Python入门篇

淩亂°似流年 2022-10-12 14:58 156阅读 0赞

# 前言 #

python入门篇，是博主结合暑期实训的学习，**对python常用操作的汇总整理**，偏向于个人的学习笔记，同时也加入了很多实例以便于理解❤  
![在这里插入图片描述][20210707151714489.gif_pic_center]  
python入门学习网站推荐：

*  [菜鸟教程][Link 1]（简单易懂，很适合零基础入门）  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70]
 *  [廖雪峰-python教程][-python]（清晰明了，部分知识点比菜鸟教程难些，也很适合python入门学习）  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center]
 *  CSDN平台内的python入门博客（有很多写得通俗易懂而系统便于学习的博客教程，可多看看选择最适合自己的）

# 1 Python简介 #

## python下载及安装 ##

下载地址：[python官网][python]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center 1]  
点击Downloads，选择自己喜好的版本即可

> 建议使用executable installer和安装非当前最新版本，因为最新版本往往有着不太稳定和部分报错难以搜索解决的缺点。  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70 1]

## 测试是否安装成功 ##

*  windows键（窗口形状，由四个方块组成）+R
 *  在弹出窗口输入’cmd’  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center 2]
 *  再输入python，显示如下即安装成功（最后输入exit()退出）  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center 3]

## Pycharm的安装 ##

**Python本身是一种交互式操作**，类似于一问一答，很适合学习/验证python语法或者局部代码，但也存在着代码不能保存、无法运行太大程序的缺点。故需要安装**python的集成开发环境——pycharm**，以便于更复杂多样的代码书写需求。

下载地址：[pycharm官网][pycharm]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center 4]

## 使用Pycharm编写第一个Python程序 ##

1.  运行Pycharm,选择Create New Project,创建一个新的Python工程。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70 2]
2.  选择’Pure Python’创建一个新的纯Python工程项目，Location表示该项目的保存路径，Interpreter 用来指定Python计时器的版本。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70 3]
3.  右击项目(**project**)，选择New，再选择Python File
4.  在弹出的对话框中输入的文件名mycode，点击OK，表示创建一个Python程序的文本文件，文本文件后缀名默认.py  
    ![在这里插入图片描述][20210705163813133.png_pic_center]
5.  在新建的mycode.py文件里，输入以下代码，并在空白处右键选择Run运行，表示输出一段hello world字符串。
6.  运行成功后，Pycharm Console窗口将显示我们的输出结果。(↙)  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center 5]

> 为便于使用，建议可先建立新目录，再在子目录下进行小模块代码的书写与保存

*  **皮肤设置**(File - settings - Appearance&Behavior - Appearance)  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center 6]
 *  **字体设置**(File - settings - Editor - Font)  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center 7]  
    **国内常用的pip下载源列表**:

>  *  阿里云 http://mirrors.aliyun.com/pypi/simple/ 中国科技大学
>  *  https://pypi.mirrors.ustc.edu.cn/simple/ 豆瓣(douban)
>  *  http://pypi.douban.com/simple/ 清华大学
>  *  https://pypi.tuna.tsinghua.edu.cn/simple/ 中国科学技术大学
>  *  http://pypi.mirrors.ustc.edu.cn/simple/

## 一些实用的快捷键 ##

1.  ctrl+d 快速复制一行或选中区域的几行
2.  ctrl+shift+F10 (py.file执行快捷键)
3.  ctrl+? 快速注释选中区域
4.  光标选中函数后点击ctrl，即可调出函数的详细说明

## Debug操作 ##

该操作使我们能观察到代码**每步运行**后的情况，以便于查找错误和调试代码

1.  点击待调试代码的前端，出现小红点表示选中  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center 8]
2.  点击pycharm↗小蜘蛛，或右键——Debug  
    ![在这里插入图片描述][20210706114326371.png_pic_center]
3.  使用F8快捷键，或点击如图折现按钮，即可进行调试  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center 9]

## 关于注释 ##

单行注释

#单行注释，不执行

多行注释：以’’‘开始，并以’’'结束

''' _ooOoo_ o8888888o 88" . "88 (| -_- |) O\ = /O ____/`---'\____ .' \\| |// `. / \\||| : |||// \ / _||||| -:- |||||- \ | | \\\ - /// | | | \_| ''\---/'' | | \ .-\__ `-` ___/-. / ___`. .' /--.--\ `. . __ ."" '< `.___\_<|>_/___.' >'"". | | : `- \`.;`\ _ /`;.`/ - ` : | | \ \ `-. \_ __\ /__ _/ .-` / / ======`-.____`-.___\_____/___.-`____.-'====== `=---=' ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 佛祖保佑 永无BUG 佛曰: 写字楼里写字间，写字间里程序员； 程序人员写程序，又拿程序换酒钱。 酒醒只在网上坐，酒醉还来网下眠； 酒醉酒醒日复日，网上网下年复年。 但愿老死电脑间，不愿鞠躬老板前； 奔驰宝马贵者趣，公交自行程序员。 别人笑我忒疯癫，我笑自己命太贱； 不见满街漂亮妹，哪个归得程序员？ '''

# 2 变量及类型 #

## 变量及类型 ##

# 变量 = 值； 将右侧的值放入左侧的容器中
    bing = 'elephant'
    
    #两边不对等(注意*的作用)
    b1, b2, *b3 = 'a', 'b', 'c', 'd', 'e'
    print(b1, b2, b3)
    
    b1, *b2, b3 = 'a', 'b', 'c', 'd', 'e'
    print(b1, b2, b3)

运行结果

a b ['c', 'd', 'e']
    a ['b', 'c', 'd'] e

变量没有类型，数据才有类型

''' 数值类型 example 整型 age = 18 浮点型 salary = 17.32 字符串 book = 'little prince' 布尔类型 True & False 首字母大写 列表 classroom = [21, 7, 'hello', True, [212,323]] 元组 weather = ('Wuhan', 30) 字典 content = {'name':'xiaoming', 'height':'172cm', 'hobby':'running'} '''

## 变量的取名 ##

命名规则：

1.  标识符由字母、下划线和数字组成，且数字不能开头。
2.  **严格区分大小写**。
3.  不能使用关键字。（pycharm中蓝色高亮部分）

> 关键字的概念 一些具有特殊功能的标识符，这就是所谓的关键字。 关键字，已经被python官方使用了，所以不允许开发者自己定义和关键字相同名字的标识符。  
> ![在这里插入图片描述][20210705152938847.png_pic_center]

驼峰命名法：

*  小驼峰式命名法（lower camel case）： 第一个单词以小写字母开始；第二个单词的首字母大写，例如：my**N**ame、a**D**og
 *  大驼峰式命名法（upper camel case）： 每一个单字的首字母都采用大写字母，例如：**F**irstName、**L**astName.

## 输出 ##

print('hello world') #一般输出
    user = 'ZhangSan'
    print('hello %s' % user) #格式化输出
    age = 17
    print('%s is %d years old' % (user, age))

运行结果：

hello world
    hello ZhangSan
    ZhangSan is 17 years old

> 常用格式符号  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center 10]

**换行输出**

print('=======我的名片=======')
    print('姓名：%s\nQQ: %d\n手机号: %d\n公司地址: %s' % (name, QQ, tel, address))
    print('======================')

结果输出：

=======我的名片=======
    姓名：chris
    QQ: 2736368065
    手机号: 159654538769
    公司地址: Wuhan
    ======================

边框简化写法（效果与上同）：

print('='*7 + '我的名片' + '='*7)
    print('姓名：%s\nQQ: %d\n手机号: %d\n公司地址: %s' % (name, QQ, tel, address))
    print('='*20)

## 输入 ##

password = input("请输入密码:") #接收用户输入
    print('您刚刚输入的密码是:%s' % password)

输出结果：  
![在这里插入图片描述][20210705164518690.png]  
注意，这里不管我们输入什么类型的数据，最终的结果都是字符串(%s)

print(type(password))
    <class 'str'>

## 类型转换 ##

常见类型转换  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center 11]  
实例：

num1 = '545'
    print(type(num1))
    
    num2 = 345
    print(type(num2))
    
    # print(num1 + num2) TypeError: can only concatenate str (not "int") to str
    print(int(num1) + num2)
    print(num1 + str(num2))

输出结果：

<class 'str'>
    <class 'int'>
    890
    545345

**关于布尔值**

#为假的情况
    #整形的 0
    #浮点型的 0.0
    #空白字符串''转成假 ‘ ’代表空格与空白是两个意思
    #空列表 []
    #空元组 ()
    #空字典 {}
    #空集合 set()

**以上情况为假，其余为真**

示例

print(bool(set()))
    print(bool(0.0))

结果

False
    False

其他类型转换  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center 12]

# 3 运算符 #

## 算术运算符 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center 13]

示例：

num1 = int(input('the 1st number:')) #input最终的数据类型是字符串
    num2 = int(input('the 2nd number')) #因此需要转成整型
    #加
    print(num1 + num2)
    #商
    print(num1/num2)
    #取余
    print(num1 % num2)
    #整除
    print(num1//num2)
    #指数
    print(num1**num2)

结果：

the 1st number:3
    the 2nd number7
    10
    0.42857142857142855
    3
    0
    2187

## 比较运算符 ##

**比较运算符返回结果一定是布尔类型**  
**一个等号是赋值，’=='表判断是否相等**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center 14]  
示例1

print(3==4)
    print(3!=4)
    print(3<=4)
    print(3>=4)

输出结果：

False
    True
    True
    False

示例2  
**当布尔参与运算时， False转0 True转1**

a = 100
    b = False # False转0
    print(a*b - 1)

输出结果：

-1

示例3

time = 15678
    hour = time // 3600 #整除
    min = time % 3600 // 60
    second = time % 60 #取余
    
    print('%d时%d分%d秒' % (hour, min, second))
    print(f'{hour}时{min}分{second}秒') #f-字符串格式化

输出结果

4时21分18秒
    4时21分18秒

## 逻辑运算符 ##

*  **and**（并） 均满足时，结果才是True
 *  **or**（或） 只要有一个满足，结果为True
 *  **not**（取反）

**逻辑运算符返回结果不一定是bool类型**

**短路运算**：从左往右运算

**and** 左边开始，**只要是真，继续往后走。若遇假，立即停止**，后面不管

print('adw' and 3223 and 0 and 3>4)
    0

**or** 左边开始，只要是假，继续往右走。若遇真，立即停止，后面不管

print(0 or 0.0 or [] or 18 or ())
    18

# 4 流程控制语句 #

## 4.1 条件判断语句 ##

## if…else语句 ##

age = 18
    
    if age > 18:
        print('成年人的世界没有容易二字，但年轻人不至于躺平')
    else:
        print('人总要学会长大')

人总要学会长大

## elif语句的使用 ##

score = float(input('请输入成绩：'))
    if score < 60:
        print('未及格')
    elif score < 80:
        print('合格')
    elif score < 90:
        print('良好')
    else:
        print('优秀')

请输入成绩：85
    良好

## if语句嵌套 ##

ticket = 1 # 1买票 0未买票
    knife_length = 9 #cm
    tep = 36
    
    if ticket == 1:
        print('请排队安检')
        if knife_length <= 9:
            print('通过安检')
            if tep <= 36.5:
                print('体温正常')
            else:
                print('就地等候，需进一步检查身体状况')
        else:
            print('刀具过长，强制没收')
    else:
        print('请购票进站')

请排队安检
    通过安检
    体温正常

## 应用：猜拳游戏 ##

![在这里插入图片描述][20210707151425169.gif_pic_center]

**分析：**  
游戏双方 电脑\*用户 两者随机出下面三种中的一个  
剪刀0 石头1 布2  
用户赢得情况(左侧) 0-2 1-0 2-1（也就是说如果电脑出2，用户出0即赢得游戏）

**代码实现**

#用户赢得情况(左侧) 0-2  1-0 2-1
    
    import  random
    computer = random.randint(0,2) #随机出[0,2]中的一个整数
    print(computer)
    
    user = int(input('请输入你的选择:(0-剪刀，1-石头， 2-布):'))
    
    
    if (user==0 and computer==2) or (user==1 and computer==0) or (user==2 and computer==1):
        print('恭喜获胜')
    elif user == computer:
        print('难分伯仲，决战到天亮')
    else:
        print('失败是成功他爸，加油')

运行结果：  
![在这里插入图片描述][20210706104536910.png_pic_center]

## 4.2 循环语句 ##

## while语句 ##

while语法：

while 判断条件: （直至条件不满足，跳出循环）
        代码块

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center 15]  
示例：求1~100所有偶数的和

res = 0 #求和容器
    i = 0
    while i <= 100:
        if i % 2 == 0:
            res = res + i
        i += 1
    print(res)

2550

这里也可以使用range，注意**range左闭右开**

res = 0
    for x in range(1,101):
        if x % 2 == 0:
            res = res + x
    print(res)

2550

## break和continue的使用 ##

#不断的询问用户，"我爱你，你爱我吗?"，只有用户回答"爱"时，结束循环。
    print('I love you, you too?')
    answer = input('please put your answer:(yes) or (no)')
    while 'start': 
        if answer == 'yes':
            print('❤'); break #结束整个循环
        else:
            print('┭┮﹏┭┮'); continue #结束本次循环，继续后面的循环

![在这里插入图片描述][2021070614324067.png_pic_center]

## 嵌套循环 ##

**1.生成矩形**

i = 0
    while i < 10: #控行
        i += 1
        j = 0
        while j < 8: #控列
            j += 1
            print('*',end = ' ') 
        print()

最终效果：

* * * * * * * * 
    * * * * * * * * 
    * * * * * * * * 
    * * * * * * * * 
    * * * * * * * * 
    * * * * * * * * 
    * * * * * * * * 
    * * * * * * * * 
    * * * * * * * * 
    * * * * * * * *

**2.倒置的九九乘法表**

i = 10
    while 1 <= i <= 10:
        i -= 1
        j = 0
        while j < i:
            j += 1
            print(i,'x',j,'=',i*j,end='')
        print()

最终效果：

9 x 1 = 99 x 2 = 189 x 3 = 279 x 4 = 369 x 5 = 459 x 6 = 549 x 7 = 639 x 8 = 729 x 9 = 81
    8 x 1 = 88 x 2 = 168 x 3 = 248 x 4 = 328 x 5 = 408 x 6 = 488 x 7 = 568 x 8 = 64
    7 x 1 = 77 x 2 = 147 x 3 = 217 x 4 = 287 x 5 = 357 x 6 = 427 x 7 = 49
    6 x 1 = 66 x 2 = 126 x 3 = 186 x 4 = 246 x 5 = 306 x 6 = 36
    5 x 1 = 55 x 2 = 105 x 3 = 155 x 4 = 205 x 5 = 25
    4 x 1 = 44 x 2 = 84 x 3 = 124 x 4 = 16
    3 x 1 = 33 x 2 = 63 x 3 = 9
    2 x 1 = 22 x 2 = 4
    1 x 1 = 1

**3.寻找水仙花数**

for i in range(100,1000):
        a = i // 100
        b = (i - 100*a) // 10
        c = i - 100*a - 10*b
        if (a**3 + b**3 + c**3 == i): #注意：这里用**，而不是^
            print('%d是水仙花数' % i)

最终结果：

153是水仙花数
    370是水仙花数
    371是水仙花数
    407是水仙花数

**4.折叠次数的求解**  
一张纸的厚度是0.08mm，请问折叠几次达高度 8848.13m

x = 0.08*10**(-3)
    i = 0
    while True:
        x *=2
        i += 1
        if x > 8848.13:
            break
    print(i)

最终结果：

**4.百马马百担问题**

for b in range(1,100//3 + 1):
        for m in range(1, 100//2 + 1):
            for s in range(2,100,2):
                if b+m+s == 100 and b*3+m*2+s//2 == 100:
                    print('大马：%d； 中马：%d；小马：%d' % (b,m,s))

输出结果：

大马：2； 中马：30；小马：68
    大马：5； 中马：25；小马：70
    大马：8； 中马：20；小马：72
    大马：11； 中马：15；小马：74
    大马：14； 中马：10；小马：76
    大马：17； 中马：5；小马：78

## for循环 ##

语句：  
for 临时变量 in 可迭代对象：  
满足条件时执行的代码

**可迭代对象：**  
字符串、列表、字典、元组、集合  
‘’’

for i in 'happy':
        print(i)

h
    a
    p
    p
    y

# 5 字符串、元组、列表、字典、集合 #

## 切片 ##

切片的语法：\[起始:结束:步长\]，也可以简化使用 \[起始:结束\]

注意：选取的区间从"起始"位开始，到"结束"位的前一位结束（**不包含结束位本身**)，步长表示选取间隔。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70 4]

#切片
    str = '敢问路在何方，路在脚下'
    print(str[7]) #python从0开始
    print(str[2:7]) #有头没尾
    print(str[2:7:2])
    print(str[2:7:-1]) #步长为-1，表示从右往左取，而2：7是从左到右，故取不到值
    print(str[7:2:-1])
    print(str[-3:-1])

路
    路在何方，
    路何，
    
    路，方何在
    在脚

列表的切片操作与字符串类似

## 5.1 字符串常见操作 ##

*  获取长度:len
 *  查找内容:find,index,rfind,rindex  
    **find**——查找指定内容在字符串中是否存在，如果存在就**返回**该内容在**字符串中第一次出现的开始位置索引值**，如果不存在，则返回-1
 *  判断:startswith,endswith,isalpha,isdigit,isalnum,isspace

mystr = '1234' #判断字符是否为纯数字
    print(mystr.isdigit()) # True

*  计算出现次数:count
 *  替换内容:replace
 *  切割字符串:split,rsplit,splitlines,partition,rpartition

str1 = 'a,b,c,d,e'
    print(str1.split(','))
    print(str1.split(',',2)) #切两次
    print(str1.partition('b')) #把str1以b分割成三部分,b前，b和b后，三部分组成一个元组

['a', 'b', 'c', 'd', 'e']
    ['a', 'b', 'c,d,e']
    ('a,', 'b', ',c,d,e')

*  修改大小写:capitalize,title,upper,lower

mystr = 'hello world'
    print(mystr.title()) # Hello World 每个单词首字母大写

*  空格处理:ljust,rjust,center,lstrip,rstrip,strip

str = 'hello'
    print(str.ljust(10))  # 保留左侧内容，在右边补了五个空格
    print(str.rjust(10))  #返回指定长度的字符串
    print(str.center(10))  # 两端加空格，让内容居中
    
    str = ' he llo '
    print(str.lstrip())  #只去掉了左边的空格
    print(str.rstrip())  #        右
    print(str.strip())  #删除两端空格

hello     
         hello
      hello   
    
    he   llo      
        he   llo
    he   llo

*  字符串拼接:join

mystr = 'a'
    print(mystr.join('hxmdq'))  #haxamadaq 把hxmd一个个取出，并在后面添加字符a. 最后的 q 保留，没有加 a
    print(mystr.join(['hi','hello','good']))  #hiahelloagood

haxamadaq
    hiahelloagood

注意：在Python中，字符串是不可变的！**所有的字符串相关方法，都不会改变原有的字符串**，都是返回一个结果，在这个新的返回值里，保留了执行后的结果！

## 5.2 列表的常见操作 ##

**增**

animals.append('cat') #末尾添加
    print(animals)
    animals.insert(3,'duck') #指定位置前添加元素
    print(animals)
    
    a = ['a','b','c']
    b = ['d','e','f']
    a.extend(b) #通过extend可以将另一个集合中的元素逐一添加到列表中
    print(a)  # ['a', 'b', 'c', 'd', 'e', 'f'] 将 b 添加到 a 里
    print(b) # ['d','e','f'] b的内容不变

['panda', 'chicken', 'horse', 'dog', 'cat']
    ['panda', 'chicken', 'horse', 'duck', 'dog', 'cat']
    ['a', 'b', 'c', 'd', 'e', 'f']
    ['d', 'e', 'f']

**删**  
列表元素的常用删除方法有：

*  del：根据下标进行删除
 *  pop：删除最后一个元素
 *  remove：根据元素的值进行删除

#del
    movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
    print('------删除之前------%s' % movieName)
    del movieName[2]
    print('------删除之后------%s' % movieName)
    
    #pop
    movieName.pop()
    print('------删除之后------%s' % movieName)
    
    #remove
    movieName.remove('指环王')
    print('------删除之后------%s' % movieName)

------删除之前------['加勒比海盗', '骇客帝国', '第一滴血', '指环王', '霍比特人', '速度与激情']
    ------删除之后------['加勒比海盗', '骇客帝国', '指环王', '霍比特人', '速度与激情']
    ------删除之后------['加勒比海盗', '骇客帝国', '指环王', '霍比特人']
    ------删除之后------['加勒比海盗', '骇客帝国', '霍比特人']

**改**

# 定义变量A，默认有3个元素
    A = ['xiaoWang', 'xiaoZhang', 'xiaoHua']
    A[1] = 'xiaoLu' #修改第二个元素
    print(A)

['xiaoWang', 'xiaoLu', 'xiaoHua']

**查**

*  in 和 not in （存不存在）
 *  index（查找位置，无则报错） 和 count（对元素出现的次数计数）

a = ['a', 'b', 'c', 'a', 'b']
    a.index('a', 1, 3) # 注意是左闭右开区间
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    ValueError: 'a' is not in list
    >>> a.index('a', 1, 4)
    3
    >>> a.count('b')
    2
    >>> a.count('d')
    0

**遍历循环**

使用while：

namesList = ['xiaoWang','xiaoZhang','xiaoHua']
    length = len(namesList)  # 获取列表长度
    i = 0
    while i<length:
        print(namesList[i])
        i+=1

xiaoWang
    xiaoZhang
    xiaoHua

使用for:

res = []
    for x in range(5):
        res.append([0]*3)
    print(res)

[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]

**嵌套操作**

schoolNames = [
    [1, 2, 3],
    [11, 22, 33],
    [111, 222, 333]
     ]
    schoolNames[1][2]  # 获取数字 33
    33
    schoolNames[1][2] = 'abc'  # 把 33 修改为 'abc'
    schoolNames
    [[1, 2, 3], [11, 22, 'abc'], [111, 222, 333]]
    schoolNames[1][2][2]  # 获取 'abc' 里的字符c
    'c'

**列表生成式**

res = [x for x  in range(1,101) if x%2==0]  #列表生成式
    print(res)
    # 通过列表生成式能使代码更加简洁
    
    res = [x+y for x in 'abc' for y in '123']
    print(res)  #['a1', 'a2', 'a3', 'b1', 'b2', 'b3', 'c1', 'c2', 'c3']

两种**列表元素去重**的方法

names = ['z','l','d','z']
    res = list(set(names)) #利用集合不重复的性质
    print(res)
    
    res = []
    for x in names:
        if x not in res:
            res.append(x)
    print(res)

['d', 'l', 'z']
    ['z', 'l', 'd']

## 5.3 元组 ##

**元组是不可变类型**，跟字符串一样，原来结果永不变。所以该数据类型非常适用于固定数据或想避免改变原数据的情况。

> python可变类型：列表 字典 集合  
> 不可变类型：整型 字符串 元组 bool

w1 = ('hahaha')
    print(type(w1))
    w2 = ('hahaha',) #声明元组，不得缺失','
    print(type(w2))

元组的不可变性

nums = (12,3,23,5,43,54,88,98)
    res = sorted(nums) #原元组永不改变，结果放至新容器中
    print(res)
    print(nums)

[3, 5, 12, 23, 43, 54, 88, 98]
    (12, 3, 23, 5, 43, 54, 88, 98)

## 5.4 字典的常见操作 ##

*  字典的键必须是不可变类型（一般为字符串），而value可以是任意类型
 *  字典的键不要重复，否则后边的会把前面的覆盖掉

info = { 'name':'如花', 'id':666, 'sex':'f', 'address':'地球亚洲中国上海'}
    
    # 查看元素
    print(info['address'])  # 字典使用键来获取对应的值
    
    # 修改元素
    info['id'] = 200  # 为已存在的键赋值就是修改
    print('修改之后的id为 %s:' % info)
    
    #添加元素
    info['age'] = 18  # 为不存在的键赋值就是添加元素，也可使用update合并字典
    print('添加之后的字典为:%s' % info)
    
    # 删除元素
    del info['id']  # del 可以通过键删除字典里的指定元素
    print('删除后,%s' % info)
    
    info2 = { 'name':'monitor', 'id':100}
    del info2  # del 也可以直接删除变量
    
    
    info.clear() #clear清空整个字典
    print('清空后,%s'%info)

结果：

地球亚洲中国上海
    修改之后的id为 { 'name': '如花', 'id': 200, 'sex': 'f', 'address': '地球亚洲中国上海'}:
    添加之后的字典为:{ 'name': '如花', 'id': 200, 'sex': 'f', 'address': '地球亚洲中国上海', 'age': 18}
    删除后,{ 'name': '如花', 'sex': 'f', 'address': '地球亚洲中国上海', 'age': 18}
    清空后,{ }

**字典的遍历**

遍历键：（遍历值的操作与之类似）

person = { 
        'name': 'zhangsan',
        'sex' : 'male',
        'hobby': 'running'
    }
    for x in person.keys():
        print(x,':',person[x])

name : zhangsan
    sex : male
    hobby : running

遍历字典的**键值对(.items)**：

for key,value in person.items():
        print(key,value)

name : zhangsan
    sex : male
    hobby : running

**enumerate()**  
该函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

chars = ['a', 'b', 'c', 'd']
    for i, chr in enumerate(chars):
        print("%d %s"%(i, chr))

0 a
    1 b
    2 c
    3 d

## 5.5 集合 ##

集合（set）是一个**无序的不重复元素序列**，可以使用大括号 \{ \} 或者 set() 函数创建集合。

注意：**创建一个空集合必须用 set()** 而不是 \{ \}，因为 \{ \} 是用来创建一个空字典。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center 16]  
因为集合无序，所以同一代码的输出结果或并不相同

**并、添、移、删**

p1 = { 'qsw','sas','swqsq'}
    p2 = { 'sas','sw','sq'}
    
    #合并
    res = p1.union(p2)
    print(res)
    
    #添加元素
    res.add('akui')
    print(res)
    
    #移除元素
    res.remove('swqsq')
    print(res)
    
    #随机删除
    res.pop()
    print(res)

{ 'sq', 'sas', 'qsw', 'sw', 'swqsq'}
    { 'sq', 'sas', 'qsw', 'akui', 'sw', 'swqsq'}
    { 'sq', 'sas', 'qsw', 'akui', 'sw'}
    { 'sas', 'qsw', 'akui', 'sw'}

**集合运算:**

first = { '李白','杜甫','李商隐','白居易','苏轼'}
    second={ '李白','杜甫','王维','孟浩然'}
    
    #print(first+second) # 集合不支持+
    print(first-second) # 差集
    print(first & second) # 交集
    print(first | second) # 并集
    print(first ^ second)# 异部分，即集合独特之处}

{ '苏轼', '白居易', '李商隐'}
    { '杜甫', '李白'}
    { '白居易', '苏轼', '王维', '杜甫', '李商隐', '孟浩然', '李白'}
    { '白居易', '苏轼', '王维', '李商隐', '孟浩然'}

# 6 函数 #

## 6.1 函数基础 ##

函数是对语句的封装（类似于ppt中的模板，当我们想达成某一效果时，只需选用相应的模板填入内容即可。）

**定义：**

def 函数名():
        代码

函数写好后，需要调用才能实现功能

def tell_story():
        print('once upon a time...')
    
    age = int(input('please tell me your kid\'s age:'))
    if 0 <= age <= 3:
        for i in range(3):
            tell_story()
    elif age <= 5:
        for i in range(2):
            tell_story()
    else:
        tell_story()

![在这里插入图片描述][20210707150450233.png_pic_center]  
**带参数的函数**  
![在这里插入图片描述][20210707150902571.gif_pic_center]

def ad(a,b):
        c = a + b
        print(c)
    
    ad(5,1) #结果为6

**函数返回值**

def ad(a,b):
        return a + b 
        print('see') #函数遇return，后边的代码就不执行了
    
    print(ad(12,8)) #最后用print来打印返回结果

**函数调用函数**

求n的阶乘

# n的阶乘
    def factorial(n:int):
        ''' 求阶乘 :param n: int 一个数字 :return: 结果 '''
        x = 1
        for i in range(1,n+1):
            x *= i
        return x
    print(factorial(5))

120

求m阶乘的和

def qsf(m:int):
        s = 0
        for i in range(1,m+1):
            s += factorial(i)
        return s
    
    print(qsf(6))

873

## 6.2 函数进阶 ##

**返回多个值的情况**

def tech(num1:int, num2:int):
        x = num1 // num2
        y = num1 % num2
        return x,y #返回元组
        #return [x,y] #返回列表

**可变参数**

可变位置参数

def add(*args): #*args 可变位置参数
        res = sum(args)
        return res
    
    print(add(5,7,8))

关键字参数以字典形式保存，且永远放在参数列表的末尾

def test(**kwargs): #关键字参数会以字典形式保存到kwargs中
        res = { key:value for key,value in kwargs.items()}
        return res
    print(test(name='景天',love='雪见',said='抬头能看到的不是云，是天'))

{ 'name': '景天', 'love': '雪见', 'said': '抬头能看到的不是云，是天'}

## 6.3 匿名函数 ##

为更好理解，我们先来看如下例子：

def calculate(a,b,fn):
        """ :param a: 第一个数字 :param b: 第二个数字 :param fn: 函数 :return: 返回结果c """
        c = fn(a,b)
        return c
    
    def add(x,y):
        return x + y
    
    def minus(x,y):
        return x - y
    
    res1 = calculate(10,20,add) #这里不要传()
    print(res1) #因为这里由calculate执行add，如果传入()，则代表add自己执行了
    
    res2 = calculate(20,10,minus)
    print(res2)

30
    10

用**lambda**关键词能创建小型匿名函数。(这种函数得名于省略了用def声明函数的标准步骤) 从而可以实现与上面相同的功能。

lambda 参数列表: 运算表达式

print(calculate(10,20,lambda x,y:x+y))
    print(calculate(20,10,lambda x,y:x-y))

30
    10

匿名函数的应用：

1 按年龄排序

students = [
        { 'name':'Shelly','age':20,'height':163},
        { 'name':'Linda','age':22,'height':160},
        { 'name':'Mike','age':21,'height':183},
        { 'name':'June','age':22,'height':175}
    ]
    students.sort(key = lambda s:s['age'], reverse = True)
    print(students)

[{ 'name': 'Linda', 'age': 22, 'height': 160}, { 'name': 'June', 'age': 22, 'height': 175}, { 'name': 'Mike', 'age': 21, 'height': 183}, { 'name': 'Shelly', 'age': 20, 'height': 163}]

2 寻找大于18的年龄

ages = [12,23,45,7,18,19,20]
    # filter()返回的是一个对象，需要转成list
    res = list(filter(lambda s:s>18,ages))
    print(res)

[23, 45, 19, 20]

3 统一涨薪

salaries = [10000,11000,15000,21000,9000]
    res = list(map(lambda s:s+2000, salaries))
    print(res)

[12000, 13000, 17000, 23000, 11000]

# 7 面向对象 #

## 面向对象与面向过程 ##

>  *  面向过程：根据业务逻辑从上到下写代码。
>  *  面向对象：将变量与函数绑定到一起，分类进行封装，每个程序只要负责分配给自己的分类，这样能够更快速的开发程序，减少了重复代码。
> 
> 面向过程编程最易被初学者接受，其往往用一长段代码来实现指定功能，开发过程的思路是将数据与函数按照执行的逻辑顺序组织在一起，数据与函数分开考虑，面向过程基本是由函数组成的。

**01.面向过程编程**

面向过程编程的关注点在于**怎么做**

*  把完成某一个需求的 所有步骤 从头到尾 逐步实现
 *  根据开发需求，将某些 功能独立 的代码 封装 成一个又一个 函数
 *  最后完成的代码，就是顺序地调用 不同的函数

特点:

*  注重步骤与过程，不注重职责分工
 *  如果需求复杂，代码会变得很复杂
 *  开发复杂项目，没有固定的套路，开发难度很大！  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70 5]

**02.面向对象基本概念**

面向对象编程（Object Oriented Programming，OOP，面向对象程序设计）和面相对象，是两种不同的编程方式。

面向对象编程的关注点在于**谁来做**

> 相比较函数，面向对象是更大的封装，根据职责在 一个对象中封装多个方法

*  在完成某一个需求前，首先确定职责 —— 要做的事情（方法）
 *  根据 职责 确定不同的 对象，在对象内部封装不同的方法（多个）
 *  最后完成的代码，就是顺序地调用不同对象的相应方法。

特点:

*  注重 对象和职责，不同的对象承担不同的职责。
 *  更加适合应对复杂的需求变化，是专门应对复杂项目开发，提供的固定套路。
 *  需要在面向过程基础上，再学习一些面向对象的语法。

## 面向对象编程的核心概念——类和对象 ##

**类**：

对一群具有相同特征或者行为的事物的一个统称，是抽象的，**不能直接使用**

*  特征其实就是一个变量，在类里我们称之为属性。
 *  行为其实就是一个函数，在类里我们称之为方法。
 *  类其实就是由 属性 和 方法 组成的一个抽象概念。

> 类就相当于制造飞机时的图纸，是一个模板。这个模板只规定了飞机的某些特征(例如大小，颜色，型号等等)和行为(例如起飞，降落，飞行等等)，它并不是一个具体的飞机，而是对飞机的一个抽象概念。它出现的目的，是为了让我们的创建飞机对象。  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70 6]

**对象**:

对象是由类创建出来的一个具体存在，可以直接使用。**由哪一个类创建出来的 对象，就拥有在哪一个类中定义的属性和方法。**

> 对象就相当于用图纸制造的飞机。在开发中，应该先有类，在类里定义好属性和行为，再根据类来创建对象。

**类和对象的关系**

1.  类是模板，对象是根据类这个模板创建出来的，应该先有类，再有对象。
2.  使用同一个类，能够创建出很多对象。
3.  类中定义了什么属性和方法，对象中就有什么属性和方法。
4.  不同对象对应的属性值也会不同。

## 面向对象基本语法 ##

class Cat:
        """这是个猫类"""
    
        def eat(self):
            print("小猫在吃东西")
    
        def drink(self):
            print("小猫在喝水")
    
    tom = Cat()  # 创建了一个Cat对象
    tom.eat()
    tom.drink()
    
    hello_kitty = Cat()  # 又创建了一个新的Cat对象
    hello_kitty.eat()
    hello_kitty.drink()

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70 7]

## 魔法方法 ##

Python 里有一种方法，叫做魔法方法。Python 的类里提供的，**两个下划线开始，两个下划线结束的方法**，就是魔法方法，魔法方法在恰当的时候就会被激活，自动执行。 魔法方法的两个特点：

*  两侧各有两个下划线；
 *  "咒语"名字已经由 Python 官方定义好，我们不能乱写。

''' class 类名(object) object 是所有类的父亲 '''
    #python3版本(object)可写可不写，两者效果一样
    #python2 版本 写不写差别很大
    
        #静态的 叫属性; 如果有多个对象，每个对象的属性是各自保存的，都有各自独立的地址。
        #动态的 叫方法; 方法是所有对象共享的，只占用一份内存空间，方法被调用时会通过self来判断是哪个对象调用了实例方法。
    
    class Person(object): #类名一般遵循‘大驼峰’命名
        def __init__(self,name,age,height):   #__init__()方法，在创建一个对象时默认被调用，不需要手动调用
            self.name = name       # 哪个对象调用了方法，方法里的self指的就是谁。
            self.age = age         # 通过self.属性名 可以访问到这个对象的属性；通过 self.方法名() 可以调用这个对象的方法。
            self.height = height
    
        def eat(self):
            print(f'{self.name}吃饭') #方法中可调用属性
    
        def sleep(self):
            print(f'{self.name}睡觉')
    
        def bin(self):
            print(f'{self.name}打豆豆')
    
        #对象格式化输出，__str__方法返回对象的描述信息
        def __str__(self): #不加str，打印对象为#<__main__.Person object at 0x00000255ED39A3C8>
            return f'姓名{self.name},年龄{self.age},身高{self.height}'
    
    xiaoming = Person('小明',20,'180cm')
    xiaoming.eat()
    xiaoming.sleep()
    xiaoming.bin()
    print(xiaoming)

小明吃饭
    小明睡觉
    小明打豆豆
    姓名小明,年龄20,身高180cm

## 面向对象继承 ##

class Animal(object):
        def __init__(self,name,age):
            self.name = name
            self.age = age
    
        def sleep(self):
            print(self.name+'正在睡觉')
    
    class Dog(Animal):
        def bark(self):
            print(self.name+'正在狂吠')
    
    d1 = Dog('金毛',7)
    d1.bark()
    d1.sleep()

## 重写父类的属性和方法 ##

class Person:
        def __init__(self,name,age):
            self.name = name
            self.age = age
    
        def action(self):
            print(self.name + '立即行动')
    
        def study(self):
            print(self.name + '正在学习')
    
    class Student(Person):
        def __init__(self,name,age,school):
            super(Student,self).__init__(name, age)
            self.school = school
    
        def study(self):
            print(f'孙中山对{self.school}的{self.name}说：革命尚未成功，同志仍需努力')
    s1 = Student('小华',18,'奋斗大学')
    s1.study()
    s1.action()

# 8 模块和包 #

## 几种安装包的方法 ##

方法一（菜单操作）：  
File - settings - Project - **Project Interpreter** \- “+” - 搜索包名下载即可  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center 17]

方法二（**pip**）：

先打开**Terminal**（pycharm左下），通过以下命令可完成相应需求

**1 使用pip list查看已下载包**

(venv) C:\Users\JSJSYS\PycharmProjects\untitled>pip list
    Package    Version
    ---------- ---------
    certifi    2021.5.30
    chardet    4.0.0
    idna       2.10
    numpy      1.21.0
    pip        10.0.1
    requests   2.25.1
    setuptools 39.1.0
    urllib3    1.26.6

**2 pip install '包名’**  
这种方法很直接，但直接在[官网][Link 2]下载经常会因各种原因卡顿、甚至下载失败。此时，我们可以去国内镜像网站下载相应包。

**国内常用的pip下载源列表:**

*  [阿里云][Link 3] http://mirrors.aliyun.com/pypi/simple/
 *  [中国科技大学][Link 3] https://pypi.mirrors.ustc.edu.cn/simple/
 *  [豆瓣(douban)][douban] http://pypi.douban.com/simple/
 *  [清华大学][Link 4] https://pypi.tuna.tsinghua.edu.cn/simple/
 *  [中国科学技术大学][Link 5] http://pypi.mirrors.ustc.edu.cn/simple/

**3 pip install 包名 -i 国内源地址**

pip install flask -i https://pypi.mirrors.ustc.edu.cn/simple/ 
    # 从中国科技大学(ustc)的服务器上下载flask(基于python的第三方web框架)

**实用操作**

>pip freeze > requirements.txt
    >#生成已安装包及其型号的文档

![在这里插入图片描述][2021071011543872.png_pic_center]  
![在这里插入图片描述][20210710115223308.png_pic_center]  
在External Libraries可查看已下载包  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center 18]

## 常见系统模块 ##

为了方便程序员开发代码，Python提供了很多内置的模块给程序员用来提高编码效率。常见的内置模块有:

*  **os模块**: OS全称OperationSystem,即操作系统模块，这个模块可以用来操作系统的功能，并且实现跨平台操作。

import os
    os.getcwd()  # 获取当前的工作目录，即当前python脚本工作的目录
    os.chdir('test') # 改变当前脚本工作目录，相当于shell下的cd命令
    os.rename('毕业论文.txt','毕业论文-最终版.txt') # 文件重命名
    os.remove('毕业论文.txt') # 删除文件
    os.rmdir('demo')  # 删除空文件夹,文件夹非空则无法删除
    os.removedirs('demo') # 删除空文件夹
    os.mkdir('demo')  # 创建一个文件夹
    os.chdir('C:\\') # 切换工作目录
    os.listdir('C:\\') # 列出指定目录里的所有文件和文件夹
    os.name # nt->widonws posix->Linux/Unix或者MacOS
    os.environ # 获取到环境配置
    os.environ.get('PATH') # 获取指定的环境配置
    
    os.path.abspath(path) # 获取Path规范会的绝对路径
    os.path.exists(path)  # 如果Path存在，则返回True
    os.path.isdir(path)  # 如果path是一个存在的目录，返回True。否则返回False
    os.path.isfile(path) # 如果path是一个存在的文件，返回True。否则返回False
    os.path.splitext(path)  # 用来将指定路径进行分隔，可以获取到文件的后缀名

*  **sys模块**

import sys
    sys.path # 模块的查找路径
    sys.argv # 传递给Python脚本的命令行参数列表
    sys.exit(code) # 让程序以指定的退出码结束
    
    sys.stdin # 标准输入。可以通过它来获取用户的输入
    sys.stdout # 标准输出。可以通过修改它来百变默认输出
    sys.stderr # 错误输出。可以通过修改它来改变错误删除

*  **math模块**

import math
    print(math.fabs(-100)) # 取绝对值
    print(math.ceil(34.01))  #向上取整
    print(math.factorial(5)) # 计算阶乘
    print(math.floor(34.98))  # 向下取整
    print(math.pi)   # π的值，约等于 3.141592653589793
    print(math.pow(2, 10)) # 2的10次方
    print(math.sin(math.pi / 6))  # 正弦值
    print(math.cos(math.pi / 3))  # 余弦值
    print(math.tan(math.pi / 2))  # 正切值

*  **random模块**

print(random.random())  # 生成 [0,1)的随机浮点数
    print(random.uniform(20, 30))  # 生成[20,30]的随机浮点数
    print(random.randint(10, 30))  # 生成[10,30]的随机整数
    print(random.randrange(20, 30))  # 生成[20,30)的随机整数
    print(random.choice('abcdefg'))  # 从列表里随机取出一个元素
    print(random.sample('abcdefghij', 3)) # 从列表里随机取出指定个数的元素

*  **datetime模块**

import datetime
    print(datetime.date(2020, 1, 1))  # 创建一个日期
    print(datetime.time(18, 23, 45)) # 创建一个时间
    print(datetime.datetime.now())  # 获取当前的日期时间
    print(datetime.datetime.now() + datetime.timedelta(3))  # 计算三天以后的日期时间

*  **time模块**: datetime模块主要用来显示日期时间，这里主要涉及 date类，用来显示日期；time类，用来显示时间；dateteime类，用来显示日期时间;timedelta类用来计算时间。

print(time.time())  # 获取从1970-01-01 00:00:00 UTC 到现在时间的秒数
    print(time.strftime("%Y-%m-%d %H:%M:%S")) # 按照指定格式输出时间
    print(time.asctime()) #Mon Apr 15 20:03:23 2019
    print(time.ctime()) # Mon Apr 15 20:03:23 2019
    
    print('hello')
    print(time.sleep(10)) # 让线程暂停10秒钟
    print('world')

*  **calendar模块**

calendar.setfirstweekday(calendar.SUNDAY) # 设置每周起始日期码。周一到周日分别对应 0 ~ 6
    calendar.firstweekday()# 返回当前每周起始日期的设置。默认情况下，首次载入calendar模块时返回0，即星期一。
    c = calendar.calendar(2019)  # 生成2019年的日历，并且以周日为其实日期码
    print(c)  #打印2019年日历
    print(calendar.isleap(2000)) # True.闰年返回True,否则返回False
    count = calendar.leapdays(1996,2010) # 获取1996年到2010年一共有多少个闰年
    print(calendar.month(2019, 3))  # 打印2019年3月的日历

*  **hashlib模块**: 一个提供字符加密功能的模块，包含MD5和SHA的加密算法，具体支持md5,sha1, sha224, sha256, sha384, sha512等算法。 该模块在用户登录认证方面应用广泛，对文本加密也很常见。

import hashlib
    
    # 待加密信息
    str = '这是一个测试'
    
    # 创建md5对象
    hl = hashlib.md5('hello'.encode(encoding='utf8'))
    print('MD5加密后为 ：' + hl.hexdigest())
    
    h1 = hashlib.sha1('123456'.encode())
    print(h1.hexdigest())
    h2 = hashlib.sha224('123456'.encode())
    print(h2.hexdigest())
    h3 = hashlib.sha256('123456'.encode())
    print(h3.hexdigest())
    h4 = hashlib.sha384('123456'.encode())
    print(h4.hexdigest())

*  **hmac模块**: HMAC算法也是一种一种单项加密算法，并且它是基于上面各种哈希算法/散列算法的，只是它可以在运算过程中使用一个密钥来增增强安全性。hmac模块实现了HAMC算法，提供了相应的函数和方法，且与hashlib提供的api基本一致。

h = hmac.new('h'.encode(),'你好'.encode())
    result = h.hexdigest()
    print(result)  # 获取加密后的结果

*  **copy模块**

import copy
    
    nums = [1, 5, 3, 8, [100, 200, 300, 400], 6, 7]
    nums1 = copy.copy(nums)  # 对nums列表进行浅复制
    nums2 = copy.deepcopy(nums)  # 对nums列表进行深复制

*  **uuid模块**: UUID是128位的全局唯一标识符，通常由32字节的字母串表示，它可以保证时间和空间的唯一性，也称为GUID。通过MAC地址、时间戳、命名空间、随机数、伪随机数来保证生产的ID的唯一性。随机生成字符串，可以当成token使用，当成用户账号使用，当成订单号使用。

import uuid
    
    print(uuid.uuid1())  # 根据时间戳和机器码生成uuid,可以保证全球唯一
    print(uuid.uuid4())  # 随机生成uuid,可能会有重复
    
    # 使用命名空间和字符串生成uuid.
    # 注意一下两点:
    # 1. 命名空间不是随意输入的字符串，它也是一个uuid类型的数据
    # 2. 相同的命名空间和想到的字符串，生成的uuid是一样的
    print(uuid.uuid3(uuid.NAMESPACE_DNS, 'hello'))
    print(uuid.uuid5(uuid.NAMESPACE_OID, 'hello'))

# 9 文件操作 #

## 相对路径与绝对路径 ##

文件的路径分为相对路径和绝对路径两种。

**绝对路径**：指的是绝对位置，完整地描述了目标的所在地，所有目录层级关系是一目了然的。

例如：C:/Users/chris/AppData/Local/Programs/Python/Python37/python.exe，从电脑的盘符开始，表示的就是一个绝对路径。

**相对路径**：是从当前文件所在的文件夹开始的路径。

*  test.txt，是在当前文件夹查找 test.txt 文件
 *  ./test.txt，也是在当前文件夹里查找test.txt文件， ./ 表示的是当前文件夹。
 *  …/test.txt，从当前文件夹的上一级文件夹里查找 test.txt 文件。 …/ 表示的是上一级文件夹
 *  demo/test.txt，在当前文件夹里查找 demo这个文件夹，并在这个文件夹里查找 test.txt文件。

**访问模式**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70 8]

## 文件的读取与输入(简易) ##

**1 文件的输入**

f = open('test.txt', 'w')
    f.write('hello world, i am here!\n' * 5)
    f.close()

使用write命令一定要记得close掉。使用’with open’更便捷，无需在末尾手动close。

with open('anjie.txt', 'w', encoding='utf-8') as fp:
        fp.write('you are beautiful')

**2 文件的读取**

with open('anjie.txt','r',encoding='utf-8') as fp:
        while True:
            content = fp.readline() #按行读取
            print(content)
            if content == '':
                break

## CSV文件的读写 ##

**读**

import csv
    #读取csv
    with open('stock.csv','r') as fp:
        reader = csv.reader(fp)
        title = next(reader) #获取表头
        #print(type(reader))
        for x in reader:
            print(x) #返回为列表，使用csv.DictWriter即可返回字典

['0', '000001.XSHE', '1', '平安银行', 'XSHE', '2017/12/1', '13.38', '13.4', '13.48', '12.96', '13', '178493315']
    ['1', '000002.XSHE', '2', '万科A', 'XSHE', '2017/12/1', '31.22', '30.5', '32.03', '30.5', '30.73', '55743855']
    ['2', '000004.XSHE', '4', '国农科技', 'XSHE', '2017/12/1', '25.56', '25.41', '26.4', '25.18', '26.2', '2211059']
    #后续输出略

使用csv.DictWriter返回字典

import csv
    #读取csv
    with open('stock.csv','r') as fp:
        reader = csv.DictReader(fp)
        title = next(reader) #获取表头
        #print(type(reader))
        for x in reader:
            value = { 'name':x['secShortName'], 'Vol':x['turnoverVol']}
            print(value)

{ 'name': '万科A', 'Vol': '55743855'}
    { 'name': '国农科技', 'Vol': '2211059'}
    { 'name': '世纪星源', 'Vol': '2365348'}
    { 'name': '深振业A', 'Vol': '0'}
    #后续输出略

**写**

import csv
    def write_csv_demo1():
        headers = ['username', 'age', 'height']
        values = [
            ('小明', 18, '175cm'),
            ('王珏', 20, '165cm'),
            ('张三', 22, '170cm'),
        ]
        with open('class_list.csv', 'w', encoding='utf8', newline='') as fp:
            writer = csv.writer(fp)
            writer.writerow(headers)
            writer.writerows(values)
    
    if __name__=='__main__':
        #下面的代码只在当前文件写入.py中运行
        # 别的文件除非导入 之后调用 否则不运行
        write_csv_demo1()

![在这里插入图片描述][20210710161614369.png_pic_center]

## 序列化与反序列化 ##

通过文件操作，我们可以将字符串写入到一个本地文件。但是，**如果是一个对象(例如列表、字典、元组等)，就无法直接写入到一个文件里**，需要对这个对象进行序列化，然后才能写入到文件里。

设计一套协议，按照某种规则，**把内存中的数据转换为字节序列，保存到文件，这就是序列化**，反之，从文件的字节序列恢复到内存中，就是反序列化。

Python中提供了JSON和pickle两个模块用来实现数据的序列化和反序列化。

**Json模块**（**JSON的本质是字符串！**）

# json本质上是字符串
    import json #文件只能写入字符串或二进制
    # json 键和值全部是双引号
    person = { 
        'username': '董大',
        'age': 20,
        'height': '182'
    }
    with open('扛把子.txt', 'w', encoding = "utf-8") as fp:
        fp.write(json.dumps(person))
    
    #JSON提供了dump和dumps方法，将一个对象进行序列化。
    # 可以调用 json的dumps方法，传入一个对象参数
    data = json.dumps(person, ensure_ascii = False) #dumps方法的作用是把对象转换成为字符串，它本身不具备将数据写入到文件的功能。
    # dumps 方法得到的结果是一个字符串
    print(type(data)) # <class 'str'>
    
    #使用loads和load方法，可以将一个JSON字符串反序列化成为一个Python对象。
    # 调用loads方法，传入一个字符串，可以将这个字符串加载成为Python对象
    res = json.loads(data, encoding='utf-8')
    print(type(res)) #<class 'dict'>

补充：利用json选出所需网页数据：

import json
    
    data = '{"reason":"查询成功!","result":{"city":"武汉","realtime":{"temperature":"33","humidity":"64","info":"多云","wid":"01","direct":"南风","power":"4级","aqi":"33"},"future":[{"date":"2021-07-10","temperature":"28\/34℃","weather":"多云","wid":{"day":"01","night":"01"},"direct":"南风"},{"date":"2021-07-11","temperature":"28\/34℃","weather":"多云","wid":{"day":"01","night":"01"},"direct":"南风"},{"date":"2021-07-12","temperature":"27\/34℃","weather":"多云转阴","wid":{"day":"01","night":"02"},"direct":"南风"},{"date":"2021-07-13","temperature":"26\/34℃","weather":"小雨转阴","wid":{"day":"07","night":"02"},"direct":"南风"},{"date":"2021-07-14","temperature":"28\/35℃","weather":"阴转多云","wid":{"day":"02","night":"01"},"direct":"南风转东南风"}]},"error_code":0}'
    
    res = json.loads(data)
    print(res['result']['city'])
    
    weathers = res['result']['future']
    #print(weather)列表
    for index, weather in enumerate(weathers):
        date = weather['date']
        temperature = weather['temperature']
        weather1 = weather['weather']
        direct = weather['direct']
        print(date,temperature,weather1,direct)

武汉
    2021-07-10 28/34℃ 多云 南风
    2021-07-11 28/34℃ 多云 南风
    2021-07-12 27/34℃ 多云转阴 南风
    2021-07-13 26/34℃ 小雨转阴 南风
    2021-07-14 28/35℃ 阴转多云 南风转东南风

# 正则表达式（略） #

正则表达式是一个特殊的字符序列，计算机科学的一个概念。通常被**用来检索、替换那些符合某个模式(规则)的文本。**

许多程序设计语言都支持利用正则表达式进行字符串操作。在Python中需要通过正则表达式对字符串进行匹配的时候，可以使用re模块。**re 模块**使 Python 语言拥有全部的正则表达式功能。

**特点：**

*  灵活性、逻辑性和功能性非常强；
 *  可以迅速地用极简单的方式达到字符串的复杂控制。
 *  对于刚接触的人来说，比较晦涩难懂。

[20210707151714489.gif_pic_center]: /images/20221005/443ed3f5fdc547a997503c5434bdd069.png
[Link 1]: https://www.runoob.com/python3/python3-tutorial.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70]: /images/20221005/b7ef128f7b7b4375a86d6c52d60b312b.png
[-python]: https://www.liaoxuefeng.com/wiki/1016959663602400
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center]: /images/20221005/7c01140b7eef42de8463d73768a01e01.png
[python]: https://www.python.org/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221005/3308e2445ab44826a77ec9c9ddad4220.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70 1]: /images/20221005/a805c8a5f6364264a360eefe09d1bb0f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221005/8680d877cc864f34a411f8ded8422660.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221005/c15b4760e8194349a3095fc5bcda2e15.png
[pycharm]: http://www.jetbrains.com/pycharm/download
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221005/b9304ed5b7f743bfb501825c7d2b0e46.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70 2]: /images/20221005/fa23c680473b477db5d62d5e47f4f53a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70 3]: /images/20221005/cd5f70032a4345d9b258aab8976de3fe.png
[20210705163813133.png_pic_center]: /images/20221005/2f011ff63eae465790de1f232ae9a702.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221005/bdf57cbf27524c8fa3c8ebb4c868cdb8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221005/db6f112b7ace4d2a81c4bc445b6822a0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221005/412dccd299da487e88ad48746ee61f2b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20221005/1dccf4b42c8b487291b5ee8d1e25438a.png
[20210706114326371.png_pic_center]: /images/20221005/f90df6d56dec48b9bebfe9770a66353c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20221005/96c2bd64646f4f8389565ce6d4465f2e.png
[20210705152938847.png_pic_center]: /images/20221005/26de50679b70457b85273520f8a1ef13.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center 10]: /images/20221005/7b4e6f883da64a6a9497079aaf0736f3.png
[20210705164518690.png]: /images/20221005/f014215a33bc4a1ba80f9f272724589b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center 11]: /images/20221005/8cfd02f2534e4be986d07812942494a9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center 12]: /images/20221005/4f6a213effc14fe7a68f5c0c9236fc45.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center 13]: /images/20221005/17c918de82c84f87ada524fa49624b11.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center 14]: /images/20221005/da9a473a1ccb475684128b38c70b797c.png
[20210707151425169.gif_pic_center]: /images/20221005/37677a78610744159b0227162505422a.png
[20210706104536910.png_pic_center]: /images/20221005/dd13be3f379d42799314a4a0d19c5c64.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center 15]: /images/20221005/a23f470c8e55446280af0be55745cc30.png
[2021070614324067.png_pic_center]: /images/20221005/768e5b42772744609c446b10d2d1826f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70 4]: /images/20221005/6a4643333a0346d59c2df338f2838a88.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center 16]: /images/20221005/ab2156472dc140038697b3690f8efa6d.png
[20210707150450233.png_pic_center]: /images/20221005/1c550b530edb42d69320b73bf5da47d9.png
[20210707150902571.gif_pic_center]: /images/20221005/e4240a004a184bedafdd4e6366264265.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70 5]: /images/20221005/83a35028a92b4a31bd715854793f5e26.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70 6]: /images/20221005/b582864f55f243669c04efc8e3016a28.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70 7]: /images/20221005/63cdc55c94d741c1b44c20f51ba91e80.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center 17]: /images/20221005/9bcff19d67284fec8fc45b5cec50bf75.png
[Link 2]: https://files.pythonhosted.org/
[Link 3]: http://mirrors.aliyun.com/pypi/simple/
[douban]: http://pypi.douban.com/simple/
[Link 4]: https://pypi.tuna.tsinghua.edu.cn/simple/
[Link 5]: http://pypi.mirrors.ustc.edu.cn/simple/
[2021071011543872.png_pic_center]: /images/20221005/d0396bb106d54724ae5af6eaf6011dd9.png
[20210710115223308.png_pic_center]: /images/20221005/d1f233f7d23d4e739b09e624b12c52c6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70_pic_center 18]: /images/20221005/263fc89c32a64070a977e4d955008884.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDYwNjc0_size_16_color_FFFFFF_t_70 8]: /images/20221005/5a26b89bcbe64eac90532ca3d45ed82d.png
[20210710161614369.png_pic_center]: /images/20221005/d8588840623b4e59b5896b0f511ccd3d.png