2024年Python最新python编程从入门到实践(2)

![img](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9waWMzLnpoaW1nLmNvbS84MC92Mi1iYTdmN2U1ZjVmNDJiNDRhMjQxMjNhNDg5OTZhYzIxYV83MjB3LmpwZw?x-oss-process=image/format,png)


python引入了“标记-清除” 与“分代回收”来分别解决引用计数的循环引用与效率低的问题


##### 5.2.2 解决方案：标记-清除


容器对象（比如：list，set，dict，class，instance）都可以包含对其他对象的引用，所以都可能产生循环引用。而“标记-清除”计数就是为了解决循环引用的问题。


标记/清除算法的做法是当应用程序可用的内存空间被耗尽的时，就会停止整个程序，然后进行两项工作，第一项则是标记，第二项则是清除


##### 5.2.3 问题二：效率问题

基于引用计数的回收机制，每次回收内存，都需要把所有对象的引用计数都遍历一遍，这是非常消耗时间的，于是引入了分代回收来提高回收效率，分代回收采用的是用“空间换时间”的策略。

##### 5.2.4 解决方案：分代回收


**代：**


分代回收的核心思想是：在历经多次扫描的情况下，都没有被回收的变量，gc机制就会认为，该变量是常用变量，gc对其扫描的频率会降低，具体实现原理如下：

分代指的是根据存活时间来为变量划分不同等级（也就是不同的代）

新定义的变量，放到新生代这个等级中，假设每隔1分钟扫描新生代一次，如果发现变量依然被引用，那么该对象的权重（权重本质就是个整数）加一，当变量的权重大于某个设定得值（假设为3），会将它移动到更高一级的青春代，青春代的gc扫描的频率低于新生代（扫描时间间隔更长），假设5分钟扫描青春代一次，这样每次gc需要扫描的变量的总个数就变少了，节省了扫描的总时间，接下来，青春代中的对象，也会以同样的方式被移动到老年代中。也就是等级（代）越高，被垃圾回收机制扫描的频率越低

**回收：**


回收依然是使用引用计数作为回收的依据


![img](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9waWMxLnpoaW1nLmNvbS84MC92Mi0yNDU4Njg1YjM4NWIzMzgxOTJkNmI5MDYyOGVkOTJhOF83MjB3LmpwZw?x-oss-process=image/format,png)


虽然分代回收可以起到提升效率的效果，但也存在一定的缺点：

例如一个变量刚刚从新生代移入青春代，该变量的绑定关系就解除了，该变量应该被回收，但青春代的扫描频率低于新生代，这就到导致了应该被回收的垃圾没有得到及时地清理。

没有十全十美的方案：
毫无疑问，如果没有分代回收，即引用计数机制一直不停地对所有变量进行全体扫描，可以更及时地清理掉垃圾占用的内存，但这种一直不停地对所有变量进行全体扫描的方式效率极低，所以我们只能将二者中和。

综上
垃圾回收机制是在清理垃圾&释放内存的大背景下，允许分代回收以极小部分垃圾不会被及时释放为代价，以此换取引用计数整体扫描频率的降低，从而提升其性能，这是一种以空间换时间的解决方案目录

### 6、Python语法入门之与用户交互、运算符


#### 一 程序与用户交互


#### 1.1、什么是与用户交互


用户交互就是人往计算机中input/输入数据，计算机print/输出结果


#### 1.2、为什么要与用户交互？

为了让计算机能够像人一样与用户沟通交流

#### 1.3、如何与用户交互

交互的本质就是输入、输出

##### 1.3.1 输入input:

在python3中input功能会等待用户的输入，用户输入任何内容，都存成字符串类型，然后赋值给等号左边的变量名

username=input(‘请输入您的用户名：’)
请输入您的用户名：jack # username = “jack”
password=input(‘请输入您的密码：’)
请输入您的密码：123 # password = “123”

了解知识：

1、在python2中存在一个raw_input功能与python3中的input功能一模一样

2、在python2中还存在一个input功能，需要用户输入一个明确的数据类型，输入什么类型就存成什么类型

l=input('输入什么类型就存成什么类型: ')
输入什么类型就存成什么类型: [1,2,3]
type(l)
<type ‘list’>

##### 1.3.2 输出print:

print(‘hello world’) # 只输出一个值
hello world
print(‘first’,‘second’,‘third’) # 一次性输出多个值，值用逗号隔开
first second third

默认print功能有一个end参数，该参数的默认值为"\n"(代表换行)，可以将end参数的值改成任意其它字符

print(“aaaa”,end=‘’)
print(“bbbb”,end=‘&’)
print(“cccc”,end=‘@’)
#整体输出结果为：aaaabbbb&cccc@

##### 1.3.3 输出之格式化输出


##### (1)什么是格式化输出？


把一段字符串里面的某些内容替换掉之后再输出，就是格式化输出。


##### (2)为什么要格式化输出？


我们经常会输出具有某种固定格式的内容，比如：'亲爱的xxx你好！你xxx月的话费是xxx，余额是xxx‘，我们需要做的就是将xxx替换为具体的内容。


##### (3)如何格式化输出？


这就用到了占位符，如：%s、%d：

%s占位符：可以接收任意类型的值

%d占位符：只能接收数字

print(‘亲爱的%s你好！你%s月的话费是%d，余额是%d’ %(‘tony’,12,103,11))
亲爱的tony你好！你12月的话费是103，余额是11

练习1：接收用户输入，打印成指定格式

name = input('your name: ')
age = input('your age: ') #用户输入18,会存成字符串18,无法传给%d
print(‘My name is %s,my age is %s’ %(name,age))

练习2：用户输入姓名、年龄、工作、爱好 ，然后打印成以下格式

------------ info of Tony -----------
Name : Tony
Age : 22
Sex : male
Job : Teacher
------------- end -----------------

#### 二 基本运算符


#### 2.1 算术运算符


python支持的算数运算符与数学上计算的符号使用是一致的，我们以x=9，y=2为例来依次介绍它们


![img](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9waWMzLnpoaW1nLmNvbS84MC92Mi0xZTY5MWRkMDA4ODhmZmJjNmE2YTkxZmQ2Yjg3MWZiMl83MjB3LmpwZw?x-oss-process=image/format,png)


#### 2.2 比较运算符


比较运算用来对两个值进行比较，返回的是布尔值True或False，我们以x=9，y=2为例来依次介绍它们


![img](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9waWMyLnpoaW1nLmNvbS84MC92Mi00ZjM1MTgzYjFlZjA0OWFlOGUwZGZmMjFhYTE4YmQzNV83MjB3LmpwZw?x-oss-process=image/format,png)


#### 2.3 赋值运算符


python语法中除了有=号这种简单的赋值运算外，还支持增量赋值、链式赋值、交叉赋值、解压赋值，这些赋值运算符存在的意义都是为了让我们的代码看起来更加精简。我们以x=9，y=2为例先来介绍一下增量赋值


##### 2.3.1 增量赋值


![img](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9waWM0LnpoaW1nLmNvbS84MC92Mi1iNzAwMDViMDM5Mzk4YTYzYzZlMjhmZTdkMzFhYjE0N183MjB3LmpwZw?x-oss-process=image/format,png)


##### 2.3.2 链式赋值


如果我们想把同一个值同时赋值给多个变量名，可以这么做

z=10
y=z
x=y
x,y,z
(10, 10, 10)

链式赋值指的是可以用一行代码搞定这件事

x=y=z=10
x,y,z
(10, 10, 10)

##### 2.3.3 交叉赋值


我们定义两个变量m与n


如果我们想将m与n的值交换过来，可以这么做

temp=m
m=n
n=temp
m,n
(20, 10)

交叉赋值指的是一行代码可以搞定这件事

m=10
n=20
m,n=n,m # 交叉赋值
m,n
(20, 10)

##### 2.3.4 解压赋值


如果我们想把列表中的多个值取出来依次赋值给多个变量名，可以这么做

nums=[11,22,33,44,55]

a=nums[0]
b=nums[1]
c=nums[2]
d=nums[3]
e=nums[4]
a,b,c,d,e
(11, 22, 33, 44, 55)

解压赋值指的是一行代码可以搞定这件事

a,b,c,d,e=nums # nums包含多个值，就好比一个压缩包，解压赋值因此得名
a,b,c,d,e
(11, 22, 33, 44, 55)

注意，上述解压赋值，等号左边的变量名个数必须与右面包含值的个数相同,否则会报错

#1、变量名少了

a,b=nums
Traceback (most recent call last):
File “”, line 1, in
ValueError: too many values to unpack (expected 2)

#2、变量名多了

a,b,c,d,e,f=nums
Traceback (most recent call last):
File “”, line 1, in
ValueError: not enough values to unpack (expected 6, got 5)

但如果我们只想取头尾的几个值，可以用\*\_匹配

a,b,*_=nums
a,b
(11, 22)

ps：字符串、字典、元组、集合类型都支持解压赋值


#### 2.4 逻辑运算符


逻辑运算符用于连接多个条件，进行关联判断，会返回布尔值True或False


![img](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9waWMyLnpoaW1nLmNvbS84MC92Mi1lNGMzYWJlM2VlYjI1NDZkNmQwOTNmMWU1ZDY5MDA1NV83MjB3LmpwZw?x-oss-process=image/format,png)


##### 2.4.1 连续多个and


可以用and连接多个条件，会按照从左到右的顺序依次判断，一旦某一个条件为False，则无需再往右判断，可以立即判定最终结果就为False，只有在所有条件的结果都为True的情况下，最终结果才为True。

2 > 1 and 1 != 1 and True and 3 > 2 # 判断完第二个条件，就立即结束，得的最终结果为False
False

##### 2.4.2 连续多个or


可以用or连接多个条件，会按照从左到右的顺序依次判断，一旦某一个条件为True，则无需再往右判断，可以立即判定最终结果就为True，只有在所有条件的结果都为False的情况下，最终结果才为False

2 > 1 or 1 != 1 or True or 3 > 2 # 判断完第一个条件，就立即结束，得的最终结果为True
True

##### 2.4.3 优先级not>and>or

#1、三者的优先级关系：not>and>or，同一优先级默认从左往右计算。

3>4 and 4>3 or 1==3 and ‘x’ == ‘x’ or 3 >3
False

#2、最好使用括号来区别优先级，其实意义与上面的一样
‘’’
原理为：
(1) not的优先级最高，就是把紧跟其后的那个条件结果取反，所以not与紧跟其后的条件不可分割

(2) 如果语句中全部是用and连接，或者全部用or连接，那么按照从左到右的顺序依次计算即可

(3) 如果语句中既有and也有or，那么先用括号把and的左右两个条件给括起来，然后再进行运算
‘’’

(3>4 and 4>3) or (1==3 and ‘x’ == ‘x’) or 3 >3
False

#3、短路运算：逻辑运算的结果一旦可以确定，那么就以当前处计算到的值作为最终结果返回

10 and 0 or ‘’ and 0 or ‘abc’ or ‘egon’ == ‘dsb’ and 333 or 10 > 4
我们用括号来明确一下优先级
(10 and 0) or (‘’ and 0) or ‘abc’ or (‘egon’ == ‘dsb’ and 333) or 10 > 4
短路： 0 ‘’ ‘abc’
假 假 真

返回： ‘abc’

#4、短路运算面试题：

1 or 3
1
1 and 3
3
0 and 2 and 1
0
0 and 2 or 1
1
0 and 2 or 1 or 4
1
0 or False and 1
False

#### 2.5 成员运算符


![img](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9waWMxLnpoaW1nLmNvbS84MC92Mi1iZWVjYzc3NTBmMTVmNjYwMGVkY2U2YjY0ZWU0MWMxOF83MjB3LmpwZw?x-oss-process=image/format,png)


注意：虽然下述两种判断可以达到相同的效果，但我们推荐使用第二种格式，因为not in语义更加明确

not ‘lili’ in [‘jack’,‘tom’,‘robin’]
True
‘lili’ not in [‘jack’,‘tom’,‘robin’]
True

#### 2.6 身份运算符


![img](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9waWMzLnpoaW1nLmNvbS84MC92Mi03YTY1M2U4MTUxODQ3ZTY0YTZiOTdkNjQ4OGU1MTc2Nl83MjB3LmpwZw?x-oss-process=image/format,png)


需要强调的是：==双等号比较的是value是否相等，而is比较的是id是否相等

#1. id相同，内存地址必定相同，意味着type和value必定相同
#2. value相同type肯定相同，但id可能不同,如下

x=‘Info Tony:18’
y=‘Info Tony:18’
id(x),id(y) # x与y的id不同，但是二者的值相同
(4327422640, 4327422256)

x == y # 等号比较的是value
True
type(x),type(y) # 值相同type肯定相同
(<class ‘str’>, <class ‘str’>)
x is y # is比较的是id，x与y的值相等但id可以不同
False

### 7、Python语法入门之流程控制


#### 一 引子：


流程控制即控制流程，具体指控制程序的执行流程，而程序的执行流程分为三种结构：顺序结构（之前我们写的代码都是顺序结构）、分支结构（用到if判断）、循环结构（用到while与for）


#### 二 分支结构


#### 2.1 什么是分支结构


分支结构就是根据条件判断的真假去执行不同分支对应的子代码


#### 2.2 为什么要用分支结构


人类某些时候需要根据条件来决定做什么事情，比如：如果今天下雨，就带伞


所以程序中必须有相应的机制来控制计算机具备人的这种判断能力


#### 2.3 如何使用分支结构


##### 2.3.1 if语法


用if关键字来实现分支结构，完整语法如下

if 条件1: # 如果条件1的结果为True，就依次执行：代码1、代码2，…
　代码1
代码2
…
elif 条件2: # 如果条件2的结果为True，就依次执行：代码3、代码4，…
　代码3
代码4
…
elif 条件3: # 如果条件3的结果为True，就依次执行：代码5、代码6，…
　代码5
代码6
…
else:　　 # 其它情况，就依次执行：代码7、代码8，…
代码7
代码8
…

注意：

1、python用相同缩进(4个空格表示一个缩进)来标识一组代码块，同一组代码会自上而下依次运行

2、条件可以是任意表达式，但执行结果必须为布尔类型

 # 在if判断中所有的数据类型也都会自动转换成布尔类型
   # 2.1、None，0，空（空字符串，空列表，空字典等）三种情况下转换成的布尔值为False
   # 2.2、其余均为True

##### 2.3.2 if应用案例


案例1：


如果：女人的年龄>30岁，那么：叫阿姨

age_of_girl=31
if age_of_girl > 30:
print(‘阿姨好’)

案例2：


如果：女人的年龄>30岁，那么：叫阿姨，否则：叫小姐

age_of_girl=18
if age_of_girl > 30:
print(‘阿姨好’)
else:
print(‘小姐好’)

案例3：


如果：女人的年龄>=18并且<22岁并且身高>170并且体重<100并且是漂亮的，那么：表白，否则：叫阿姨\*\*

age_of_girl=18
height=171
weight=99
is_pretty=True
if age_of_girl >= 18 and age_of_girl < 22 and height > 170 and weight < 100 and is_pretty == True:
print(‘表白…’)
else:
print(‘阿姨好’)

案例4：


如果：成绩>=90，那么：优秀


如果成绩>=80且<90,那么：良好


如果成绩>=70且<80,那么：普通


其他情况：很差

score=input('>>: ')
score=int(score)

if score >= 90:
print(‘优秀’)
elif score >= 80:
print(‘良好’)
elif score >= 70:
print(‘普通’)
else:
print(‘很差’)

案例 5：if 嵌套

#在表白的基础上继续：
#如果表白成功，那么：在一起
#否则：打印。。。

age_of_girl=18
height=171
weight=99
is_pretty=True
success=False

if age_of_girl >= 18 and age_of_girl < 22 and height > 170 and weight < 100 and is_pretty == True:
if success:
print(‘表白成功,在一起’)
else:
print(‘什么爱情不爱情的,爱nmlgb的爱情,爱nmlg啊…’)
else:
print(‘阿姨好’)

练习1: 登陆功能

name=input(‘请输入用户名字：’).strip()
password=input(‘请输入密码：’).strip()
if name == ‘tony’ and password == ‘123’:
print(‘tony login success’)
else:
print(‘用户名或密码错误’)

练习2：

#!/usr/bin/env python
#根据用户输入内容打印其权限

‘’’
egon --> 超级管理员
tom --> 普通管理员
jack,rain --> 业务主管
其他 --> 普通用户
‘’’
name=input(‘请输入用户名字：’)

if name == ‘egon’:
print(‘超级管理员’)
elif name == ‘tom’:
print(‘普通管理员’)
elif name == ‘jack’ or name == ‘rain’:
print(‘业务主管’)
else:
print(‘普通用户’)

#### 三 循环结构


#### 3.1 什么是循环结构


循环结构就是重复执行某段代码块


#### 3.2 为什么要用循环结构


人类某些时候需要重复做某件事情


所以程序中必须有相应的机制来控制计算机具备人的这种循环做事的能力


#### 3.3 如何使用循环结构


##### 3.3.1 while循环语法


python中有while与for两种循环机制，其中while循环称之为条件循环，语法如下

while 条件:
代码1
代码2
代码3
while的运行步骤：
步骤1：如果条件为真，那么依次执行：代码1、代码2、代码3、…
步骤2：执行完毕后再次判断条件,如果条件为True则再次执行：代码1、代码2、代码3、…，如果条件为False,则循环终止

![img](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9waWMzLnpoaW1nLmNvbS84MC92Mi02ZjU2ZmRiZDdkOTJkZDJhN2NlMDI1NzNkOTUwMTM2YV83MjB3LmpwZw?x-oss-process=image/format,png)


##### 3.3.2 while循环应用案例


案例一：while循环的基本使用


用户认证程序

#用户认证程序的基本逻辑就是接收用户输入的用户名密码然后与程序中存放的用户名密码进行判断，判断成功则登陆成功，判断失败则输出账号或密码错误
username = “jason”
password = “123”

inp_name = input(“请输入用户名：”)
inp_pwd = input(“请输入密码：”)
if inp_name == username and inp_pwd == password:
print(“登陆成功”)
else:
print(“输入的用户名或密码错误！”)
#通常认证失败的情况下，会要求用户重新输入用户名和密码进行验证，如果我们想给用户三次试错机会，本质就是将上述代码重复运行三遍，你总不会想着把代码复制3次吧。。。。
username = “jason”
password = “123”

第一次验证

inp_name = input(“请输入用户名：”)
inp_pwd = input(“请输入密码：”)
if inp_name == username and inp_pwd == password:
print(“登陆成功”)
else:
print(“输入的用户名或密码错误！”)

第二次验证

inp_name = input(“请输入用户名：”)
inp_pwd = input(“请输入密码：”)
if inp_name == username and inp_pwd == password:
print(“登陆成功”)
else:
print(“输入的用户名或密码错误！”)

第三次验证

inp_name = input(“请输入用户名：”)
inp_pwd = input(“请输入密码：”)
if inp_name == username and inp_pwd == password:
print(“登陆成功”)
else:
print(“输入的用户名或密码错误！”)

#即使是小白的你，也觉得的太low了是不是，以后要修改功能还得修改3次，因此记住，写重复的代码是程序员最不耻的行为。
#那么如何做到不用写重复代码又能让程序重复一段代码多次呢？ 循环语句就派上用场啦（使用while循环实现）

username = “jason”
password = “123”

记录错误验证的次数

count = 0
while count < 3:
inp_name = input(“请输入用户名：”)
inp_pwd = input(“请输入密码：”)
if inp_name == username and inp_pwd == password:
print(“登陆成功”)
else:
print(“输入的用户名或密码错误！”)
count += 1

案例二：while+break的使用


使用了while循环后，代码确实精简多了，但问题是用户输入正确的用户名密码以后无法结束循环，那如何结束掉一个循环呢？这就需要用到break了！

username = “jason”
password = “123”

记录错误验证的次数

count = 0
while count < 3:
inp_name = input(“请输入用户名：”)
inp_pwd = input(“请输入密码：”)
if inp_name == username and inp_pwd == password:
print(“登陆成功”)
break # 用于结束本层循环
else:
print(“输入的用户名或密码错误！”)
count += 1

案例三：while循环嵌套+break


如果while循环嵌套了很多层，要想退出每一层循环则需要在每一层循环都有一个break

username = “jason”
password = “123”
count = 0
while count < 3: # 第一层循环
inp_name = input(“请输入用户名：”)
inp_pwd = input(“请输入密码：”)
if inp_name == username and inp_pwd == password:
print(“登陆成功”)
while True: # 第二层循环
cmd = input('>>: ')
if cmd == ‘quit’:
break # 用于结束本层循环，即第二层循环
print(‘run <%s>’ % cmd)
break # 用于结束本层循环，即第一层循环
else:
print(“输入的用户名或密码错误！”)
count += 1

案例四：while循环嵌套+tag的使用


针对嵌套多层的while循环，如果我们的目的很明确就是要在某一层直接退出所有层的循环，其实有一个窍门，就让所有while循环的条件都用同一个变量，该变量的初始值为True，一旦在某一层将该变量的值改成False，则所有层的循环都结束

username = “jason”
password = “123”
count = 0

tag = True
while tag:
inp_name = input(“请输入用户名：”)
inp_pwd = input(“请输入密码：”)
if inp_name == username and inp_pwd == password:
print(“登陆成功”)
while tag:
cmd = input('>>: ')
if cmd == ‘quit’:
tag = False # tag变为False， 所有while循环的条件都变为False
break
print(‘run <%s>’ % cmd)
break # 用于结束本层循环，即第一层循环
else:
print(“输入的用户名或密码错误！”)
count += 1

案例五：while+continue的使用


break代表结束本层循环，而continue则用于结束本次循环，直接进入下一次循环

打印1到10之间，除7以外的所有数字

number=11
while number>1:
number -= 1
if number==7:
continue # 结束掉本次循环，即本次循环continue之后的代码都不会运行了，而是直接进入下一次循环
print(number)

案例五：while+else的使用


在while循环的后面，我们可以跟else语句，当while 循环正常执行完并且中间没有被break 中止的话，就会执行else后面的语句，所以我们可以用else来验证，循环是否正常结束

count = 0
while count <= 5 :
count += 1
print(“Loop”,count)
else:
print(“循环正常执行完啦”)
print(“-----out of while loop ------”)
输出
Loop 1
Loop 2
Loop 3
Loop 4
Loop 5
Loop 6
循环正常执行完啦 #没有被break打断，所以执行了该行代码
-----out of while loop ------

如果执行过程中被break，就不会执行else的语句

count = 0
while count <= 5 :
count += 1
if count == 3:
break
print(“Loop”,count)
else:
print(“循环正常执行完啦”)
print(“-----out of while loop ------”)
输出
Loop 1
Loop 2
-----out of while loop ------ #由于循环被break打断了，所以不执行else后的输出语句

练习1：


寻找1到100之间数字7最大的倍数（结果是98）

number = 100
while number > 0:
if number %7 == 0:
print(number)
break
number -= 1

练习2：

age=18
count=0
while count<3:
count+=1
guess = int(input(“>>:”))
if guess > age :
print(“猜的太大了，往小里试试…”)
elif guess < age :
print(“猜的太小了，往大里试试…”)
else:
print(“恭喜你，猜对了…”)

##### 3.3.3 for循环语法


循环结构的第二种实现方式是for循环，for循环可以做的事情while循环都可以实现，之所以用for循环是因为在循环取值（即遍历值）时for循环比while循环的使用更为简洁，


**for循环语法如下**

for 变量名 in 可迭代对象: # 此时只需知道可迭代对象可以是字符串\列表\字典，我们之后会专门讲解可迭代对象
代码一
代码二
…

#例1
for item in [‘a’,‘b’,‘c’]:
print(item)

运行结果

a
b
c

参照例1来介绍for循环的运行步骤

步骤1：从列表[‘a’,‘b’,‘c’]中读出第一个值赋值给item（item=‘a’），然后执行循环体代码

步骤2：从列表[‘a’,‘b’,‘c’]中读出第二个值赋值给item（item=‘b’），然后执行循环体代码

步骤3: 重复以上过程直到列表中的值读尽

![img](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9waWMxLnpoaW1nLmNvbS84MC92Mi03ZDdkYzVhZTQxYTA5YTdjZDZlMDQzZDc1YzYzYjgxY183MjB3LmpwZw?x-oss-process=image/format,png)


##### 3.3.4 for循环应用案例

简单版：for循环的实现方式

for count in range(6): # range(6)会产生从0-5这6个数
print(count)

复杂版：while循环的实现方式

count = 0
while count < 6:
print(count)
count += 1

案例二：遍历字典

简单版：for循环的实现方式

for k in {‘name’:‘jason’,‘age’:18,‘gender’:‘male’}: # for 循环默认取的是字典的key赋值给变量名k
print(k)

复杂版：while循环确实可以遍历字典，后续将会迭代器部分详细介绍

案例三：for循环嵌套

#请用for循环嵌套的方式打印如下图形：

---

---

---

for i in range(3):
for j in range(5):
print(“*”,end=‘’)
print() # print()表示换行

注意：break 与 continue也可以用于for循环，使用语法同while循环


练习一：


打印九九乘法表

for i in range(1,10):
for j in range(1,i+1):
print(‘%s*%s=%s’ %(i,j,i*j),end=’ ')
print()

练习二：


打印金字塔

分析

‘’’
#max_level=5
* # current_level=1，空格数=4，*号数=1
*** # current_level=2,空格数=3,*号数=3
***** # current_level=3,空格数=2,*号数=5
******* # current_level=4,空格数=1,*号数=7
********* # current_level=5,空格数=0,*号数=9

数学表达式

空格数=max_level-current_level
号数=2current_level-1
‘’’

实现：

max_level=5
for current_level in range(1,max_level+1):
for i in range(max_level-current_level):
print(’ ‘,end=’‘) #在一行中连续打印多个空格
for j in range(2current_level-1):
print('’,end=‘’) #在一行中连续打印多个空格
print()

### 8、基本数据类型及内置方法


#### 一 引子


数据类型是用来记录事物状态的，而事物的状态是不断变化的(如:一个人年龄的增长（操作int类型） ，单个人名的修改（操作str类型），学生列表中增加学生（操作list类型）等)，这意味着我们在开发程序时需要频繁对数据进行操作，为了提升我们的开发效率， python针对这些常用的操作，为每一种数据类型内置了一系列方法。本章的主题就是带大家详细了解下它们，以及每种数据类型的详细定义、类型转换。


#### 二 数字类型int与float


#### 2.1 定义

1、定义：

1.1 整型int的定义

age=10 # 本质age = int(10)

1.2 浮点型float的定义

salary=3000.3 # 本质salary=float(3000.3)

注意：名字+括号的意思就是调用某个功能，比如

print(…)调用打印功能

int(…)调用创建整型数据的功能

float(…)调用创建浮点型数据的功能

#### 2.2 类型转换

1、数据类型转换

1.1 int可以将由纯整数构成的字符串直接转换成整型，若包含其他任意非整数符号，则会报错

s = ‘123’
res = int(s)
res,type(res)
(123, <class ‘int’>)

int(‘12.3’) # 错误演示：字符串内包含了非整数符号.
Traceback (most recent call last):
File “”, line 1, in
ValueError: invalid literal for int() with base 10: ‘12.3’

1.2 进制转换

十进制转其他进制

bin(3)
‘0b11’
oct(9)
‘0o11’
hex(17)
‘0x11’

其他进制转十进制

int(‘0b11’,2)
3
int(‘0o11’,8)
9
int(‘0x11’,16)
17

1.3 float同样可以用来做数据类型的转换

s = ‘12.3’
res=float(s)
res,type(res)
(12.3, <class ‘float’>)

#### 2.3 使用


数字类型主要就是用来做数学运算与比较运算，因此数字类型除了与运算符结合使用之外，并无需要掌握的内置方法


#### 三 字符串


#### 3.1 定义：

定义：在单引号\双引号\三引号内包含一串字符

name1 = ‘jason’ # 本质:name = str(‘任意形式内容’)
name2 = “lili” # 本质:name = str(“任意形式内容”)
name3 = “”“ricky”“” # 本质:name = str(“”“任意形式内容”“”)

#### 3.2 类型转换

数据类型转换：str()可以将任意数据类型转换成字符串类型，例如

type(str([1,2,3])) # list->str
<class ‘str’>
type(str({“name”:“jason”,“age”:18})) # dict->str
<class ‘str’>
type(str((1,2,3))) # tuple->str
<class ‘str’>
type(str({1,2,3,4})) # set->str
<class ‘str’>

#### 3.3 使用


##### 3.3.1 优先掌握的操作

str1 = ‘hello python!’

1.按索引取值(正向取，反向取)：

1.1 正向取(从左往右)

str1[6]
p

1.2 反向取(负号表示从右往左)

str1[-4]
h

1.3 对于str来说，只能按照索引取值，不能改

str1[0]=‘H’ # 报错TypeError

2.切片(顾头不顾尾，步长)

2.1 顾头不顾尾：取出索引为0到8的所有字符

str1[0:9]
hello pyt

2.2 步长：0:9:2,第三个参数2代表步长，会从0开始，每次累加一个2即可，所以会取出索引0、2、4、6、8的字符

str1[0:9:2]
hlopt

2.3 反向切片

str1[::-1] # -1表示从右往左依次取值
!nohtyp olleh

3.长度len

3.1 获取字符串的长度，即字符的个数，但凡存在于引号内的都算作字符)

len(str1) # 空格也算字符
13

4.成员运算 in 和 not in

4.1 int:判断hello 是否在 str1里面

‘hello’ in str1
True

4.2 not in:判断tony 是否不在 str1里面

‘tony’ not in str1
True

5.strip移除字符串首尾指定的字符(默认移除空格)

5.1 括号内不指定字符，默认移除首尾空白字符(空格、\n、\t)

str1 = ’ life is short! ’
str1.strip()
life is short!

5.2 括号内指定字符，移除首尾指定的字符

str2 = ‘tony’
str2.strip(‘*’)
tony

6.切分split

6.1 括号内不指定字符，默认以空格作为切分符号

str3=‘hello world’
str3.split()
[‘hello’, ‘world’]

6.2 括号内指定分隔字符，则按照括号内指定的字符切割字符串

str4 = ‘127.0.0.1’
str4.split(‘.’)
[‘127’, ‘0’, ‘0’, ‘1’] # 注意:split切割得到的结果是列表数据类型

7.循环

str5 = ‘今天你好吗？’
for line in str5: # 依次取出字符串中每一个字符
… print(line)
…
今
天
你
好
吗
？

##### 3.3.2 需要掌握的操作


**1. strip, lstrip, rstrip**

str1 = ‘tony*’

str1.strip(‘‘) # 移除左右两边的指定字符
‘tony’
str1.lstrip(’’) # 只移除左边的指定字符
tony***
str1.rstrip(‘*’) # 只移除右边的指定字符
**tony

**2. lower(),upper()**

str2 = ‘My nAme is tonY！’

str2.lower() # 将英文字符串全部变小写
my name is tony！
str2.upper() # 将英文字符串全部变大写
MY NAME IS TONY！

**3. startswith,endswith**

str3 = ‘tony jam’

startswith()判断字符串是否以括号内指定的字符开头，结果为布尔值True或False

str3.startswith(‘t’)
True
str3.startswith(‘j’)
False

endswith()判断字符串是否以括号内指定的字符结尾，结果为布尔值True或False

str3.endswith(‘jam’)
True
str3.endswith(‘tony’)
False

**4.格式化输出之format**


之前我们使用%s来做字符串的格式化输出操作，在传值时，必须严格按照位置与%s一一对应，而字符串的内置方法format则提供了一种不依赖位置的传值方式


案例：

format括号内在传参数时完全可以打乱顺序，但仍然能指名道姓地为指定的参数传值，name=‘tony’就是传给{name}

str4 = ‘my name is {name}, my age is {age}!’.format(age=18,name=‘tony’)
str4
‘my name is tony, my age is 18!’

str4 = ‘my name is {name}{name}{name}, my age is {name}!’.format(name=‘tony’, age=18)
str4
‘my name is tonytonytony, my age is tony!’

format的其他使用方式（了解）

类似于%s的用法，传入的值会按照位置与{}一一对应

str4 = ‘my name is {}, my age is {}!’.format(‘tony’, 18)
str4
my name is tony, my age is 18!

把format传入的多个值当作一个列表，然后用{索引}取值

str4 = ‘my name is {0}, my age is {1}!’.format(‘tony’, 18)
str4
my name is tony, my age is 18!

str4 = ‘my name is {1}, my age is {0}!’.format(‘tony’, 18)
str4
my name is 18, my age is tony!

str4 = ‘my name is {1}, my age is {1}!’.format(‘tony’, 18)
str4
my name is 18, my age is 18!

**5.split,rsplit**

split会按照从左到右的顺序对字符串进行切分，可以指定切割次数

str5=‘C:/a/b/c/d.txt’
str5.split(‘/’,1)
[‘C:’, ‘a/b/c/d.txt’]

rsplit刚好与split相反，从右往左切割，可以指定切割次数

str5=‘a|b|c’
str5.rsplit(‘|’,1)
[‘a|b’, ‘c’]

**6. join**

从可迭代对象中取出多个字符串，然后按照指定的分隔符进行拼接，拼接的结果为字符串

‘%’.join(‘hello’) # 从字符串’hello’中取出多个字符串，然后按照%作为分隔符号进行拼接
‘h%e%l%l%o’
‘|’.join([‘tony’,‘18’,‘read’]) # 从列表中取出多个字符串，然后按照*作为分隔符号进行拼接
‘tony|18|read’

**7. replace**

用新的字符替换字符串中旧的字符

str7 = ‘my name is tony, my age is 18!’ # 将tony的年龄由18岁改成73岁
str7 = str7.replace(‘18’, ‘73’) # 语法:replace(‘旧内容’, ‘新内容’)
str7
my name is tony, my age is 73!

可以指定修改的个数

str7 = ‘my name is tony, my age is 18!’
str7 = str7.replace(‘my’, ‘MY’,1) # 只把一个my改为MY
str7
‘MY name is tony, my age is 18!’

**8.isdigit**

判断字符串是否是纯数字组成，返回结果为True或False

str8 = ‘5201314’
str8.isdigit()
True

str8 = ‘123g123’
str8.isdigit()
False

##### 3.3.3 了解操作

1.find,rfind,index,rindex,count

1.1 find：从指定范围内查找子字符串的起始索引，找得到则返回数字1，找不到则返回-1

msg=‘tony say hello’
msg.find(‘o’,1,3) # 在索引为1和2(顾头不顾尾)的字符中查找字符o的索引
1

1.2 index:同find,但在找不到时会报错

msg.index(‘e’,2,4) # 报错ValueError

1.3 rfind与rindex：略

1.4 count:统计字符串在大字符串中出现的次数

msg = “hello everyone”
msg.count(‘e’) # 统计字符串e出现的次数
4
msg.count(‘e’,1,6) # 字符串e在索引1~5范围内出现的次数
1

2.center,ljust,rjust,zfill

name=‘tony’
name.center(30,‘-’) # 总宽度为30，字符串居中显示，不够用-填充
-------------tony-------------
name.ljust(30,‘') # 总宽度为30，字符串左对齐显示，不够用填充
tony**************************
name.rjust(30,’') # 总宽度为30，字符串右对齐显示，不够用填充
**************************tony
name.zfill(50) # 总宽度为50，字符串右对齐显示，不够用0填充
0000000000000000000000000000000000000000000000tony

3.expandtabs

name = ‘tony\thello’ # \t表示制表符(tab键)
name
tony hello
name.expandtabs(1) # 修改\t制表符代表的空格数
tony hello

4.captalize,swapcase,title

4.1 captalize：首字母大写

message = ‘hello everyone nice to meet you!’
message.capitalize()
Hello everyone nice to meet you!

4.2 swapcase：大小写翻转

message1 = ‘Hi girl, I want make friends with you!’
message1.swapcase()
hI GIRL, i WANT MAKE FRIENDS WITH YOU!
#4.3 title：每个单词的首字母大写
msg = ‘dear my friend i miss you very much’
msg.title()
Dear My Friend I Miss You Very Much

5.is数字系列

#在python3中
num1 = b’4’ #bytes
num2 = u’4’ #unicode,python3中无需加u就是unicode
num3 = ‘四’ #中文数字
num4 = ‘Ⅳ’ #罗马数字

#isdigt:bytes,unicode

num1.isdigit()
True
num2.isdigit()
True
num3.isdigit()
False
num4.isdigit()
False

#isdecimal:uncicode(bytes类型无isdecimal方法)

num2.isdecimal()
True
num3.isdecimal()
False
num4.isdecimal()
False

#isnumberic:unicode,中文数字,罗马数字(bytes类型无isnumberic方法)

num2.isnumeric()
True
num3.isnumeric()
True
num4.isnumeric()
True

三者不能判断浮点数

num5 = ‘4.3’
num5.isdigit()
False
num5.isdecimal()
False
num5.isnumeric()
False

‘’’
总结:
最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
如果要判断中文数字或罗马数字,则需要用到isnumeric。
‘’’

6.is其他

name = ‘tony123’
name.isalnum() #字符串中既可以包含数字也可以包含字母
True
name.isalpha() #字符串中只包含字母
False
name.isidentifier()
True
name.islower() # 字符串是否是纯小写
True
name.isupper() # 字符串是否是纯大写
False
name.isspace() # 字符串是否全是空格
False
name.istitle() # 字符串中的单词首字母是否都是大写
False

#### 四 列表


#### 4.1 定义

定义：在[]内,用逗号分隔开多个任意数据类型的值

l1 = [1,‘a’,[1,2]] # 本质:l1 = list([1,‘a’,[1,2]])

#### 4.2 类型转换

但凡能被for循环遍历的数据类型都可以传给list()转换成列表类型，list()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到列表中

list(‘wdad’) # 结果：[‘w’, ‘d’, ‘a’, ‘d’]
list([1,2,3]) # 结果：[1, 2, 3]
list({“name”:“jason”,“age”:18}) #结果：[‘name’, ‘age’]
list((1,2,3)) # 结果：[1, 2, 3]
list({1,2,3,4}) # 结果：[1, 2, 3, 4]

#### 4.3 使用


##### 4.3.1 优先掌握的操作

1.按索引存取值(正向存取+反向存取)：即可存也可以取

1.1 正向取(从左往右)

my_friends=[‘tony’,‘jason’,‘tom’,4,5]
my_friends[0]
tony

1.2 反向取(负号表示从右往左)

my_friends[-1]
5

1.3 对于list来说，既可以按照索引取值，又可以按照索引修改指定位置的值，但如果索引不存在则报错

my_friends = [‘tony’,‘jack’,‘jason’,4,5]
my_friends[1] = ‘martthow’
my_friends
[‘tony’, ‘martthow’, ‘jason’, 4, 5]

2.切片(顾头不顾尾，步长)

2.1 顾头不顾尾：取出索引为0到3的元素

my_friends[0:4]
[‘tony’, ‘jason’, ‘tom’, 4]

2.2 步长：0:4:2,第三个参数2代表步长，会从0开始，每次累加一个2即可，所以会取出索引0、2的元素

my_friends[0:4:2]
[‘tony’, ‘tom’]

3.长度

len(my_friends)
5

4.成员运算in和not in

‘tony’ in my_friends
True
‘xxx’ not in my_friends
True

5.添加

5.1 append()列表尾部追加元素

l1 = [‘a’,‘b’,‘c’]
l1.append(‘d’)
l1
[‘a’, ‘b’, ‘c’, ‘d’]

5.2 extend()一次性在列表尾部添加多个元素

l1.extend([‘a’,‘b’,‘c’])
l1
[‘a’, ‘b’, ‘c’, ‘d’, ‘a’, ‘b’, ‘c’]

5.3 insert()在指定位置插入元素

l1.insert(0,“first”) # 0表示按索引位置插值
l1
[‘first’, ‘a’, ‘b’, ‘c’, ‘alisa’, ‘a’, ‘b’, ‘c’]

6.删除

6.1 del

l = [11,22,33,44]
del l[2] # 删除索引为2的元素
l
[11,22,44]

6.2 pop()默认删除列表最后一个元素，并将删除的值返回，括号内可以通过加索引值来指定删除元素

l = [11,22,33,22,44]
res=l.pop()
res
44
res=l.pop(1)
res
22

6.3 remove()括号内指名道姓表示要删除哪个元素，没有返回值

l = [11,22,33,22,44]
res=l.remove(22) # 从左往右查找第一个括号内需要删除的元素
print(res)
None

7.reverse()颠倒列表内元素顺序

l = [11,22,33,44]
l.reverse()
l
[44,33,22,11]

8.sort()给列表内所有元素排序

8.1 排序时列表元素之间必须是相同数据类型，不可混搭，否则报错

l = [11,22,3,42,7,55]
l.sort()
l
[3, 7, 11, 22, 42, 55] # 默认从小到大排序
l = [11,22,3,42,7,55]
l.sort(reverse=True) # reverse用来指定是否跌倒排序，默认为False
l
[55, 42, 22, 11, 7, 3]

8.2 了解知识：

我们常用的数字类型直接比较大小，但其实，字符串、列表等都可以比较大小，原理相同：都是依次比较对应位置的元素的大小，如果分出大小，则无需比较下一个元素，比如

l1=[1,2,3]
l2=[2,]
l2 > l1
True

字符之间的大小取决于它们在ASCII表中的先后顺序，越往后越大

s1=‘abc’
s2=‘az’
s2 > s1 # s1与s2的第一个字符没有分出胜负，但第二个字符’z’>‘b’,所以s2>s1成立
True

所以我们也可以对下面这个列表排序

l = [‘A’,‘z’,‘adjk’,‘hello’,‘hea’]
l.sort()
l
[‘A’, ‘adjk’, ‘hea’, ‘hello’,‘z’]

9.循环

循环遍历my_friends列表里面的值

for line in my_friends:
print(line)
‘tony’
‘jack’
‘jason’
4
5

##### 4.3.2 了解操作

l=[1,2,3,4,5,6]
l[0:3:1]
[1, 2, 3] # 正向步长
l[2::-1]
[3, 2, 1] # 反向步长

通过索引取值实现列表翻转

l[::-1]
[6, 5, 4, 3, 2, 1]

#### 五 元组


#### 5.1 作用


元组与列表类似，也是可以存多个任意类型的元素，不同之处在于元组的元素不能修改，即元组相当于不可变的列表，用于记录多个固定不允许修改的值，单纯用于取


#### 5.2 定义方式

在()内用逗号分隔开多个任意类型的值

countries = (“中国”，“美国”，“英国”) # 本质:countries = tuple(“中国”，“美国”，“英国”)

强调：如果元组内只有一个值，则必须加一个逗号，否则()就只是包含的意思而非定义元组

countries = (“中国”，) # 本质:countries = tuple(“中国”)

#### 5.3 类型转换

但凡能被for循环的遍历的数据类型都可以传给tuple()转换成元组类型

tuple(‘wdad’) # 结果：(‘w’, ‘d’, ‘a’, ‘d’)
tuple([1,2,3]) # 结果：(1, 2, 3)
tuple({“name”:“jason”,“age”:18}) # 结果：(‘name’, ‘age’)
tuple((1,2,3)) # 结果：(1, 2, 3)
tuple({1,2,3,4}) # 结果：(1, 2, 3, 4)

tuple()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到元组中

#### 5.4 使用

tuple1 = (1, ‘hhaha’, 15000.00, 11, 22, 33)

1、按索引取值(正向取+反向取)：只能取，不能改否则报错！

tuple1[0]
1
tuple1[-2]
22
tuple1[0] = ‘hehe’ # 报错：TypeError:

2、切片(顾头不顾尾，步长)

tuple1[0:6:2]
(1, 15000.0, 22)

3、长度

len(tuple1)
6

4、成员运算 in 和 not in

‘hhaha’ in tuple1
True
‘hhaha’ not in tuple1
False

5、循环

for line in tuple1:
… print(line)
1
hhaha
15000.0
11
22
33

#### 六 字典


#### 6.1 定义方式

定义：在{}内用逗号分隔开多元素，每一个元素都是key:value的形式，其中value可以是任意类型，而key则必须是不可变类型，详见第八小节，通常key应该是str类型，因为str类型会对value有描述性的功能

info={‘name’:‘tony’,‘age’:18,‘sex’:‘male’} #本质info=dict({…})

也可以这么定义字典

info=dict(name=‘tony’,age=18,sex=‘male’) # info={‘age’: 18, ‘sex’: ‘male’, ‘name’: ‘tony’}

#### 6.2 类型转换

转换1:

info=dict([[‘name’,‘tony’],(‘age’,18)])
info
{‘age’: 18, ‘name’: ‘tony’}

转换2：fromkeys会从元组中取出每个值当做key，然后与None组成key:value放到字典中

{}.fromkeys((‘name’,‘age’,‘sex’),None)
{‘age’: None, ‘sex’: None, ‘name’: None}

#### 6.3 使用


##### 6.3.1 优先掌握的操作

1、按key存取值：可存可取

1.1 取

dic = {
… ‘name’: ‘xxx’,
… ‘age’: 18,
… ‘hobbies’: [‘play game’, ‘basketball’]
… }
dic[‘name’]
‘xxx’
dic[‘hobbies’][1]
‘basketball’

1.2 对于赋值操作，如果key原先不存在于字典，则会新增key:value

dic[‘gender’] = ‘male’
dic
{‘name’: ‘tony’, ‘age’: 18, ‘hobbies’: [‘play game’, ‘basketball’],‘gender’:‘male’}

1.3 对于赋值操作，如果key原先存在于字典，则会修改对应value的值

dic[‘name’] = ‘tony’
dic
{‘name’: ‘tony’, ‘age’: 18, ‘hobbies’: [‘play game’, ‘basketball’]}

2、长度len

len(dic)
3

3、成员运算in和not in

‘name’ in dic # 判断某个值是否是字典的key
True

4、删除

dic.pop(‘name’) # 通过指定字典的key来删除字典的键值对
dic
{‘age’: 18, ‘hobbies’: [‘play game’, ‘basketball’]}

5、键keys()，值values()，键值对items()

dic = {‘age’: 18, ‘hobbies’: [‘play game’, ‘basketball’], ‘name’: ‘xxx’}

获取字典所有的key

dic.keys()
dict_keys([‘name’, ‘age’, ‘hobbies’])

获取字典所有的value

dic.values()
dict_values([‘xxx’, 18, [‘play game’, ‘basketball’]])

获取字典所有的键值对

dic.items()
dict_items([(‘name’, ‘xxx’), (‘age’, 18), (‘hobbies’, [‘play game’, ‘basketball’])])

6、循环

6.1 默认遍历的是字典的key

for key in dic:
… print(key)
…
age
hobbies
name

6.2 只遍历key

for key in dic.keys():
… print(key)
…
age
hobbies
name

6.3 只遍历value

for key in dic.values():
… print(key)
…
18
[‘play game’, ‘basketball’]
xxx

6.4 遍历key与value

for key in dic.items():
… print(key)
…
(‘age’, 18)
(‘hobbies’, [‘play game’, ‘basketball’])
(‘name’, ‘xxx’)

##### 6.3.2 需要掌握的操作


**1. get()**

dic= {‘k1’:‘jason’,‘k2’:‘Tony’,‘k3’:‘JY’}
dic.get(‘k1’)
‘jason’ # key存在，则获取key对应的value值
res=dic.get(‘xxx’) # key不存在，不会报错而是默认返回None
print(res)
None
res=dic.get(‘xxx’,666) # key不存在时，可以设置默认返回的值
print(res)
666

ps:字典取值建议使用get方法

**2. pop()**

dic= {‘k1’:‘jason’,‘k2’:‘Tony’,‘k3’:‘JY’}
v = dic.pop(‘k2’) # 删除指定的key对应的键值对,并返回值
dic
{‘k1’: ‘jason’, ‘kk2’: ‘JY’}
v
‘Tony’

**3. popitem()**

dic= {‘k1’:‘jason’,‘k2’:‘Tony’,‘k3’:‘JY’}
item = dic.popitem() # 随机删除一组键值对,并将删除的键值放到元组内返回
dic
{‘k3’: ‘JY’, ‘k2’: ‘Tony’}
item
(‘k1’, ‘jason’)

**4. update()**

用新字典更新旧字典，有则修改，无则添加

dic= {‘k1’:‘jason’,‘k2’:‘Tony’,‘k3’:‘JY’}
dic.update({‘k1’:‘JN’,‘k4’:‘xxx’})
dic
{‘k1’: ‘JN’, ‘k3’: ‘JY’, ‘k2’: ‘Tony’, ‘k4’: ‘xxx’}

**5. fromkeys()**

dic = dict.fromkeys([‘k1’,‘k2’,‘k3’],[])
dic
{‘k1’: [], ‘k2’: [], ‘k3’: []}

**6. setdefault()**

key不存在则新增键值对，并将新增的value返回

dic={‘k1’:111,‘k2’:222}
res=dic.setdefault(‘k3’,333)
res
333
dic # 字典中新增了键值对
{‘k1’: 111, ‘k3’: 333, ‘k2’: 222}

key存在则不做任何修改，并返回已存在key对应的value值

dic={‘k1’:111,‘k2’:222}
res=dic.setdefault(‘k1’,666)
res
111
dic # 字典不变
{‘k1’: 111, ‘k2’: 222}

#### 七 集合


#### 7.1 作用


集合、list、tuple、dict一样都可以存放多个值，但是集合主要用于：去重、关系运算


#### 7.2 定义

“”"
定义：在{}内用逗号分隔开多个元素，集合具备以下三个特点：
1：每个元素必须是不可变类型
2：集合内没有重复的元素
3：集合内元素无序
“”"
s = {1,2,3,4} # 本质 s = set({1,2,3,4})

注意1：列表类型是索引对应值，字典是key对应值，均可以取得单个指定的值，而集合类型既没有索引也没有key与值对应，所以无法取得单个的值，而且对于集合来说，主要用于去重与关系元素，根本没有取出单个指定值这种需求。

注意2:{}既可以用于定义dict，也可以用于定义集合，但是字典内的元素必须是key:value的格式，现在我们想定义一个空字典和空集合，该如何准确去定义两者?

d = {} # 默认是空字典
s = set() # 这才是定义空集合

#### 7.3 类型转换

但凡能被for循环的遍历的数据类型（强调：遍历出的每一个值都必须为不可变类型）都可以传给set()转换成集合类型

s = set([1,2,3,4])
s1 = set((1,2,3,4))
s2 = set({‘name’:‘jason’,})
s3 = set(‘egon’)
s,s1,s2,s3
{1, 2, 3, 4} {1, 2, 3, 4} {‘name’} {‘e’, ‘o’, ‘g’, ‘n’}

#### 7.4 使用


##### 7.4.1 关系运算


我们定义两个集合friends与friends2来分别存放两个人的好友名字，然后以这两个集合为例讲解集合的关系运算

friends1 = {“zero”,“kevin”,“jason”,“egon”} # 用户1的好友们
friends2 = {“Jy”,“ricky”,“jason”,“egon”} # 用户2的好友们

两个集合的关系如下图所示


![img](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9waWMxLnpoaW1nLmNvbS84MC92Mi1kYjk4YTUwOTJkMzM0NDljNDY2N2ZkMmY5NzE3YTJjMF83MjB3LmpwZw?x-oss-process=image/format,png)

1.合集/并集(|)：求两个用户所有的好友（重复好友只留一个）

friends1 | friends2
{‘kevin’, ‘ricky’, ‘zero’, ‘jason’, ‘Jy’, ‘egon’}

2.交集(&)：求两个用户的共同好友

friends1 & friends2
{‘jason’, ‘egon’}

3.差集(-)：

friends1 - friends2 # 求用户1独有的好友
{‘kevin’, ‘zero’}
friends2 - friends1 # 求用户2独有的好友
{‘ricky’, ‘Jy’}

4.对称差集(^) # 求两个用户独有的好友们（即去掉共有的好友）

friends1 ^ friends2
{‘kevin’, ‘zero’, ‘ricky’, ‘Jy’}

5.值是否相等(==)

friends1 == friends2
False

6.父集：一个集合是否包含另外一个集合

6.1 包含则返回True

{1,2,3} > {1,2}
True
{1,2,3} >= {1,2}
True

6.2 不存在包含关系，则返回False

{1,2,3} > {1,3,4,5}
False
{1,2,3} >= {1,3,4,5}
False

7.子集

{1,2} < {1,2,3}
True
{1,2} <= {1,2,3}
True

##### 7.4.2 去重


集合去重复有局限性

1. 只能针对不可变类型

2. 集合本身是无序的，去重之后无法保留原来的顺序

示例如下

l=[‘a’,‘b’,1,‘a’,‘a’]
s=set(l)
s # 将列表转成了集合
{‘b’, ‘a’, 1}
l_new=list(s) # 再将集合转回列表
l_new
[‘b’, ‘a’, 1] # 去除了重复，但是打乱了顺序

针对不可变类型，并且保证顺序则需要我们自己写代码实现，例如

l=[
{‘name’:‘lili’,‘age’:18,‘sex’:‘male’},
{‘name’:‘jack’,‘age’:73,‘sex’:‘male’},
{‘name’:‘tom’,‘age’:20,‘sex’:‘female’},
{‘name’:‘lili’,‘age’:18,‘sex’:‘male’},
{‘name’:‘lili’,‘age’:18,‘sex’:‘male’},
]

new_l=[]

for dic in l:
if dic not in new_l:
new_l.append(dic)

print(new_l)

结果：既去除了重复，又保证了顺序，而且是针对不可变类型的去重

[
{‘age’: 18, ‘sex’: ‘male’, ‘name’: ‘lili’},
{‘age’: 73, ‘sex’: ‘male’, ‘name’: ‘jack’},
{‘age’: 20, ‘sex’: ‘female’, ‘name’: ‘tom’}
]

##### 7.4.3 其他操作

1.长度

s={‘a’,‘b’,‘c’}
len(s)
3

2.成员运算

‘c’ in s
True

3.循环

for item in s:
… print(item)
…
c
a
b

#### 7.5 练习

“”"
一.关系运算
　　有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
　　pythons={‘jason’,‘egon’,‘kevin’,‘ricky’,‘gangdan’,‘biubiu’}
　　linuxs={‘kermit’,‘tony’,‘gangdan’}
　　1. 求出即报名python又报名linux课程的学员名字集合
　　2. 求出所有报名的学生名字集合
　　3. 求出只报名python课程的学员名字
　　4. 求出没有同时这两门课程的学员名字集合
“”"

求出即报名python又报名linux课程的学员名字集合

pythons & linuxs

求出所有报名的学生名字集合

pythons | linuxs

求出只报名python课程的学员名字

pythons - linuxs

求出没有同时这两门课程的学员名字集合

pythons ^ linuxs

#### 八 可变类型与不可变类型


\*\*可变数据类型：\*\*值发生改变时，内存地址不变，即id不变，证明在改变原值


\*\*不可变类型：\*\*值发生改变时，内存地址也发生改变，即id也变，证明是没有在改变原值，是产生了新的值


**数字类型:**

x = 10
id(x)
1830448896
x = 20
id(x)
1830448928

内存地址改变了，说明整型是不可变数据类型，浮点型也一样

![img](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9waWMyLnpoaW1nLmNvbS84MC92Mi1hYmE0ODNiNWE0ZmNlNWJlM2M5N2M0ZTllYjM1OGM2ZF83MjB3LmpwZw?x-oss-process=image/format,png)


**字符串**

x = “Jy”
id(x)
938809263920
x = “Ricky”
id(x)
938809264088

内存地址改变了，说明字符串是不可变数据类型

![img](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9waWMyLnpoaW1nLmNvbS84MC92Mi1iYjY3MTE0ZGM2YzhmZTI2OTRkNGY5OTcxYjhkZGMwOV83MjB3LmpwZw?x-oss-process=image/format,png)


**列表**

list1 = [‘tom’,‘jack’,‘egon’]
id(list1)
486316639176
list1[2] = ‘kevin’
id(list1)
486316639176
list1.append(‘lili’)
id(list1)
486316639176

对列表的值进行操作时，值改变但内存地址不变，所以列表是可变数据类型

![img](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9waWM0LnpoaW1nLmNvbS84MC92Mi1lMmNjNmE5MDc5NGQwZDc5NzE5ZmYwYTg5OGIzYzQ2N183MjB3LmpwZw?x-oss-process=image/format,png)


**元组**

t1 = (“tom”,“jack”,[1,2])
t1[0]=‘TOM’ # 报错：TypeError
t1.append(‘lili’) # 报错：TypeError

元组内的元素无法修改，指的是元组内索引指向的内存地址不能被修改

t1 = (“tom”,“jack”,[1,2])
id(t1[0]),id(t1[1]),id(t1[2])
(4327403152, 4327403072, 4327422472)
t1[2][0]=111 # 如果元组中存在可变类型，是可以修改，但是修改后的内存地址不变
t1
(‘tom’, ‘jack’, [111, 2])
id(t1[0]),id(t1[1]),id(t1[2]) # 查看id仍然不变
(4327403152, 4327403072, 4327422472)

![img](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9waWM0LnpoaW1nLmNvbS84MC92Mi0xOWJjMzdlNGE5ZmVkZjgzZDFiMzUyYTUwMmM0OWE1N183MjB3LmpwZw?x-oss-process=image/format,png)


**字典**

dic = {‘name’:‘egon’,‘sex’:‘male’,‘age’:18}

id(dic)
4327423112
dic[‘age’]=19
dic
{‘age’: 19, ‘sex’: ‘male’, ‘name’: ‘egon’}
id(dic)
4327423112

对字典进行操作时，值改变的情况下，字典的id也是不变，即字典也是可变数据类型

![img](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9waWMzLnpoaW1nLmNvbS84MC92Mi01MmUyYmFhYjVhZDY1ZjNlNDcwMTY2ZTM1YmRlNzcyYV83MjB3LmpwZw?x-oss-process=image/format,png)


#### 九 数据类型总结


![img](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9waWM0LnpoaW1nLmNvbS84MC92Mi1kZTcwZmMwYjUxZjY5YWRlNjJkZjVjYzIzNWFjZDQ5M183MjB3LmpwZw?x-oss-process=image/format,png)

1、数字类型：
2、字符串类型
3、列表类型
4、元组类型
5、字典类型
6、集合类型

### 9、字符编码


#### 一 引入


字符串类型、文本文件的内容都是由字符组成的，但凡涉及到字符的存取，都需要考虑字符编码的问题。


#### 二 知识储备


#### 2.1 三大核心硬件


所有软件都是运行硬件之上的，与运行软件相关的三大核心硬件为cpu、内存、硬盘，我们需要明确三点

#1、软件运行前，软件的代码及其相关数据都是存放于硬盘中的

#2、任何软件的启动都是将数据从硬盘中读入内存，然后cpu从内存中取出指令并执行

#3、软件运行过程中产生的数据最先都是存放于内存中的，若想永久保存软件产生的数据，则需要将数据由内存写入硬盘

![img](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9waWMzLnpoaW1nLmNvbS84MC92Mi00OGUyNWU3ZjAzMDMwZTA2NmY4ZmNhZjQ3NTBjYzg5Ml83MjB3LmpwZw?x-oss-process=image/format,png)


#### 2.2 文本编辑器读取文件内容的流程

#阶段1、启动一个文件编辑器（文本编辑器如nodepad++，pycharm，word）

#阶段2、文件编辑器会将文件内容从硬盘读入内存

#阶段3、文本编辑器会将刚刚读入内存中的内容显示到屏幕上

#### 2.3 python解释器执行文件的流程


以python test.py为例，执行流程如下

#阶段1、启动python解释器，此时就相当于启动了一个文本编辑器

#阶段2、python解释器相当于文本编辑器，从硬盘上将test.py的内容读入到内存中

#阶段3、python解释器解释执行刚刚读入的内存的内容，开始识别python语法

#### 2.4 总结


python解释器与文件本编辑的异同如下

#1、相同点：前两个阶段二者完全一致，都是将硬盘中文件的内容读入内存，详解如下
python解释器是解释执行文件内容的，因而python解释器具备读py文件的功能，这一点与文本编辑器一样

#2、不同点：在阶段3时，针对内存中读入的内容处理方式不同，详解如下
文本编辑器将文件内容读入内存后，是为了显示或者编辑，根本不去理会python的语法，而python解释器将文件内容读入内存后，可不是为了给你瞅一眼python代码写的啥，而是为了执行python代码、会识别python语法）

#### 三、字符编码介绍


#### 3.1 什么是字符编码？


人类在与计算机交互时，用的都是人类能读懂的字符，如中文字符、英文字符、日文字符等


而计算机只能识别二进制数,详解如下

#二进制数即由0和1组成的数字，例如010010101010。计算机是基于电工作的，电的特性即高低电平，人类从逻辑层面将高电平对应为数字1,低电平对应为数字0，这直接决定了计算机可以识别的是由0和1组成的数字

毫无疑问，由人类的字符到计算机中的数字，必须经历一个过程，如下


![img](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9waWMxLnpoaW1nLmNvbS84MC92Mi04MGI5MjVlMTkyNTc5ZmFhNTlkY2ZmYmIwNDY1MzVhNF83MjB3LmpwZw?x-oss-process=image/format,png)


翻译的过程必须参照一个特定的标准，该标准称之为字符编码表，该表上存放的就是字符与数字一一对应的关系。


字符编码中的编码指的是翻译或者转换的意思，即将人能理解的字符翻译成计算机能识别的数字


#### 3.2 字符编码表的发展史 (了解)


字符编码的发展经历了三个重要的阶段，如下


##### 3.2.1 阶段一：一家独大


现代计算机起源于美国，所以最先考虑仅仅是让计算机识别英文字符，于是诞生了ASCII表

ASCII表的特点:

1、只有英文字符与数字的一一对应关系
2、一个英文字符对应1Bytes，1Bytes=8bit，8bit最多包含256个数字，可以对应256个字符，足够表示所有英文字符

![3.2.2 阶段二：诸侯割据、天下大乱](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9waWMyLnpoaW1nLmNvbS84MC92Mi1jNGEyMTBlZmIxYTU3Yjg2OTI4OGViN2U4OWJmNmZjOV83MjB3LmpwZw?x-oss-process=image/format,png)


##### 3.2.2 阶段二：诸侯割据、天下大乱


为了让计算机能够识别中文和英文，中国人定制了GBK

GBK表的特点：

1、只有中文字符、英文字符与数字的一一对应关系
2、一个英文字符对应1Bytes
   一个中文字符对应2Bytes   
   补充说明：
   1Bytes=8bit，8bit最多包含256个数字，可以对应256个字符，足够表示所有英文字符
   2Bytes=16bit，16bit最多包含65536个数字，可以对应65536个字符，足够表示所有中文字符

每个国家都各自的字符，为让计算机能够识别自己国家的字符外加英文字符，各个国家都制定了自己的字符编码表

Shift_JIS表的特点：

1、只有日文字符、英文字符与数字的一一对应关系

Euc-kr表的特点：

1、只有韩文字符、英文字符与数字的一一对应关系

此时,美国人用的计算机里使用字符编码标准是ASCII、中国人用的计算机里使用字符编码标准是GBK、日本人用的计算机里使用字符编码标准是Shift\_JIS,如下图所示，


![img](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9waWMzLnpoaW1nLmNvbS84MC92Mi0xOWJhYzdiMDkxMDY1MmJiZDFmN2UwMjY2ODNhMjhiZV83MjB3LmpwZw?x-oss-process=image/format,png)


字符编码发展到了这个阶段，可以用一句话概括：诸侯割据、天下大乱，详解如下


图1中，文本编辑存取文件的原理如下

文本文件内容全都为字符，无论存取都是涉及到字符编码问题
#1、存文本文件
人类通过文本编辑器输入的字符会被转化成ASCII格式的二进制存放于内存中，如果需要永久保存，则直接将内存中的ASCII格式的二进制写入硬盘

#2、读文本文件
直接将硬盘中的ASCII格式的二进制读入内存，然后通过ASCII表反解成英文字符

图2图3都是相同的过程，此时无论是存还是取由于采用的字符编码表一样，所以肯定不会出现乱码问题，但问题是在美国人用的计算机里只能输入英文字符，而在中国人用的计算机里只能输入中文字符和英文字符…,毫无疑问我们希望计算机允许我们输入万国字符均可识别、不乱码，而现阶段计算机采用的字符编码ASCII、GBK、Shift\_JIS都无法识别万国字符，所以我们必须定制一个兼容万国字符的编码表，请看阶段三


##### 3.2.3 阶段三：分久必合


unicode于1990年开始研发，1994年正式公布，具备两大特点：

1. 存在所有语言中的所有字符与数字的一一对应关系,即兼容万国字符

#2. 与传统的字符编码的二进制数都有对应关系，详解如下

很多地方或老的系统、应用软件仍会采用各种各样传统的编码，这是历史遗留问题。此处需要强调：软件是存放于硬盘的，而运行软件是要将软件加载到内存的，面对硬盘中存放的各种传统编码的软件，想让我们的计算机能够将它们全都正常运行而不出现乱码，内存中必须有一种兼容万国的编码，并且该编码需要与其他编码有相对应的映射/转换关系，这就是unicode的第二大特点产生的缘由


![img](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9waWMxLnpoaW1nLmNvbS84MC92Mi00ODRhNDMwNTRkMjIxN2VkMTFjN2Q1ZDkxNzA2NzVmOF83MjB3LmpwZw?x-oss-process=image/format,png)


文本编辑器输入任何字符都是最新存在于内存中，是unicode编码的，存放于硬盘中，则可以转换成任意其他编码，只要该编码可以支持相应的字符

英文字符可以被ASCII识别

英文字符—>unciode格式的数字—>ASCII格式的数字

中文字符、英文字符可以被GBK识别

中文字符、英文字符—>unicode格式的数字—>gbk格式的数字

日文字符、英文字符可以被shift-JIS识别

日文字符、英文字符—>unicode格式的数字—>shift-JIS格式的数字

#### 3.3 编码与解码


由字符转换成内存中的unicode，以及由unicode转换成其他编码的过程，都称为编码encode


![img](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9waWMzLnpoaW1nLmNvbS84MC92Mi0wOGExMjgxNDM5N2E1YTZkM2U1MzBhNjZjZjJkYmMwMl83MjB3LmpwZw?x-oss-process=image/format,png)


由内存中的unicode转换成字符，以及由其他编码转换成unicode的过程，都称为解码decode


![img](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9waWM0LnpoaW1nLmNvbS84MC92Mi01ZjdiMjVhYWViNGNjYzkxM2YwYzIzZDU4NmFjZGJhYl83MjB3LmpwZw?x-oss-process=image/format,png)


在诸多文件类型中，只有文本文件的内存是由字符组成的，因而文本文件的存取也涉及到字符编码的问题


#### 3.4 utf-8的由来


注意：如果保存到硬盘的是GBK格式二进制，当初用户输入的字符只能是中文或英文，同理如果保存到硬盘的是Shift\_JIS格式二进制，当初用户输入的字符只能是日文或英文……如果我们输入的字符中包含多国字符，那么该如何处理？

#多国字符—√—》内存（unicode格式的二进制）——X—》硬盘（GBK格式的二进制）

#多国字符—√—》内存（unicode格式的二进制）——X—》硬盘（Shift_JIS格式的二进制）

#多国字符—√—》内存（unicode格式的二进制）——√—》硬盘（???格式的二进制）

理论上是可以将内存中unicode格式的二进制直接存放于硬盘中的，但由于unicode固定使用两个字节来存储一个字符，如果多国字符中包含大量的英文字符时，使用unicode格式存放会额外占用一倍空间（英文字符其实只需要用一个字节存放即可），然而空间占用并不是最致命的问题，最致命地是当我们由内存写入硬盘时会额外耗费一倍的时间，所以将内存中的unicode二进制写入硬盘或者基于网络传输时必须将其转换成一种精简的格式，这种格式即utf-8（全称Unicode Transformation Format，即unicode的转换格式）

多国字符—√—》内存（unicode格式的二进制）——√—》硬盘（utf-8格式的二进制）

![img](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9waWMzLnpoaW1nLmNvbS84MC92Mi1jMmE0ZWM4MmQ5NDZlNGUzNTY0NWY5NzgyZGJjNzk4YV83MjB3LmpwZw?x-oss-process=image/format,png)


那为何在内存中不直接使用utf-8呢？

utf-8是针对Unicode的可变长度字符编码：一个英文字符占1Bytes，一个中文字符占3Bytes，生僻字用更多的Bytes存储

unicode更像是一个过渡版本，我们新开发的软件或文件存入硬盘都采用utf-8格式，等过去几十年，所有老编码的文件都淘汰

#### 四 字符编码的应用


我们学习字符编码就是为了存取字符时不发生乱码问题：

#1、内存中固定使用unicode无论输入任何字符都不会发生乱码

#2、我们能够修改的是存/取硬盘的编码方式，如果编码设置不正确将会出现乱码问题。乱码问题分为两种：存乱了，读乱了

#2.1 存乱了：如果用户输入的内容中包含中文和日文字符，如果单纯以shift_JIS存，日文可以正常写入硬盘，而由于中文字符在shift_jis中没有找到对应关系而导致存乱了

#2.2 读乱了：如果硬盘中的数据是shift_JIS格式存储的，采GBK格式读入内存就读乱了

总结：

#1. 保证存的时候不乱：在由内存写入硬盘时，必须将编码格式设置为支持所输入字符的编码格式
#2. 保证存的时候不乱：在由硬盘读入内存时，必须采用与写入硬盘时相同的编码格式

#### 4.1 文本编辑器nodpad++存取文本文件


文本编辑器存取的都是文本文件，而文本文件中包含的内容全为字符，所以存取文本文件都涉及到字符编码的问题。


![img](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9waWM0LnpoaW1nLmNvbS84MC92Mi04MGQxNzljZGI5MjYyZWNlZDY1MGM4NTc0YmM3NGQzM183MjB3LmpwZw?x-oss-process=image/format,png)


#### 4.2 python解释器执行文件的前两个阶段


执行py文件的前两个阶段就是python解释器读文本文件的过程，与文本编辑读文本文件的前两个阶段没人任何区别，要保证读不乱码，则必须将python解释器读文件时采用的编码方式设置为文件当初写入硬盘时的编码格式，如果没有设置，python解释器则才用默认的编码方式，在python3中默认为utf-8，在python2中默认为ASCII，我们可以通过指定文件头来修改默认的编码


* 在文件首行写入包含#号在内的以下内容

coding: 当初文件写入硬盘时采用的编码格式

解释器会先用默认的编码方式读取文件的首行内容，由于首行是纯英文组成，而任何编码方式都可以识别英文字符。


#### 4.3 python解释器执行文件的第三个阶段


设置文件头的作用是保证运行python程序的前两个阶段不乱码，经过前两个阶段后py文件的内容都会以unicode格式存放于内存中。


在经历第三个阶段时开始识别python语法，当遇到特定的语法name = ‘上’（代码本身也都全都是unicode格式存的）时，需要申请内存空间来存储字符串’上’，这就又涉及到应该以什么编码存储‘上’的问题了。


在Python3中，字符串类的值都是使用unicode格式来存储


由于Python2的盛行是早于unicode的，因此在Python2中是按照文件头指定的编码来存储字符串类型的值的（如果文件头中没有指定编码，那么解释器会按照它自己默认的编码方式来存储‘上’），所以，这就有可能导致乱码问题

coding:utf-8

x = ‘上’ # x的值为untf-8格式的二进制
print(x) # 打印操作是将x的值，即utf-8格式的二进制交给终端，当终端收到后发现并不是unicode（只有unicode才与字符有对应关系），所以终端会执行操作：utf-8二进制—解码–>unicode格式的二进制，解码的过程终端会采用自己默认的编码，而在pycharm的终端默认编码为utf-8、windows下的cmd终端的默认编码为gbk，所以该打印操作在pycharm中显示正常，而在windows下的cmd中则乱码

在windows下的cmd中运行效果如下

C:\Users\Administrator>python2 E:\aaa.py
涓

python2后推出了一种补救措施，就是在字符串类型前加u，则会将字符串类型强制存储unicode，这就与python3保持一致了，对于unicode格式无论丢给任何终端进行打印，都可以直接对应字符不会出现乱码问题

coding:utf-8

x = u’上’ # 即便文件头为utf-8，x的值依然存成unicode

#### 4.4 字符串encode编码与decode解码的使用

1、unicode格式------编码encode-------->其它编码格式

x=‘上’ # 在python3在’上’被存成unicode
res=x.encode(‘utf-8’)
res,type(res) # unicode编码成了utf-8格式，而编码的结果为bytes类型，可以当作直接当作二进制去使用
(b’\xe4\xb8\x8a’, <class ‘bytes’>)

2、其它编码格式------解码decode-------->unicode格式

res.decode(‘utf-8’)
‘上’

### 10、文件处理


应用程序运行过程中产生的数据最先都是存放于内存中的，若想永久保存下来，必须要保存于硬盘中。应用程序若想操作硬件必须通过操作系统，而文件就是操作系统提供给应用程序来操作硬盘的虚拟概念，用户或应用程序对文件的操作，就是向操作系统发起调用，然后由操作系统完成对硬盘的具体操作。


#### 二 文件操作的基本流程


#### 2.1 基本流程


有了文件的概念，我们无需再去考虑操作硬盘的细节，只需要关注操作文件的流程：

1. 打开文件，由应用程序向操作系统发起系统调用open(…)，操作系统打开该文件，对应一块硬盘空间，并返回一个文件对象赋值给一个变量f

f=open(‘a.txt’,‘r’,encoding=‘utf-8’) #默认打开模式就为r

2. 调用文件对象下的读/写方法，会被操作系统转换为读/写硬盘的操作

data=f.read()

3. 向操作系统发起关闭文件的请求，回收系统资源

f.close()

#### 2.2 资源回收与with上下文管理


打开一个文件包含两部分资源：应用程序的变量f和操作系统打开的文件。在操作完毕一个文件时，必须把与该文件的这两部分资源全部回收，回收方法为：

1、f.close() #回收操作系统打开的文件资源
2、del f #回收应用程序级的变量

其中del f一定要发生在f.close()之后，否则就会导致操作系统打开的文件无法关闭，白白占用资源， 而python自动的垃圾回收机制决定了我们无需考虑del f，这就要求我们，在操作完毕文件后，一定要记住f.close()，虽然我们如此强调，但是大多数读者还是会不由自主地忘记f.close()，考虑到这一点，python提供了with关键字来帮我们管理上下文

1、在执行完子代码块后，with 会自动执行f.close()

with open(‘a.txt’,‘w’) as f:
pass

2、可用用with同时打开多个文件，用逗号分隔开即可

with open(‘a.txt’,‘r’) as read_f,open(‘b.txt’,‘w’) as write_f:
data = read_f.read()
write_f.write(data)

#### 2.3 指定操作文本文件的字符编码

f = open(…)是由操作系统打开文件，如果打开的是文本文件，会涉及到字符编码问题，如果没有为open指定编码，那么打开文本文件的默认编码很明显是操作系统说了算了，操作系统会用自己的默认编码去打开文件，在windows下是gbk，在linux下是utf-8。
这就用到了上节课讲的字符编码的知识：若要保证不乱码，文件以什么方式存的，就要以什么方式打开。

f = open(‘a.txt’,‘r’,encoding=‘utf-8’)

#### 三 文件的操作模式


#### 3.1 控制文件读写操作的模式

r(默认的)：只读
w：只写
a：只追加写

##### 3.1.1 案例一：r 模式的使用

r只读模式: 在文件不存在时则报错,文件存在文件内指针直接跳到文件开头

with open(‘a.txt’,mode=‘r’,encoding=‘utf-8’) as f:
res=f.read() # 会将文件的内容由硬盘全部读入内存，赋值给res

小练习：实现用户认证功能

inp_name=input(‘请输入你的名字: ‘).strip()
inp_pwd=input(‘请输入你的密码: ‘).strip()
with open(r’db.txt’,mode=‘r’,encoding=‘utf-8’) as f:
for line in f:
# 把用户输入的名字与密码与读出内容做比对
u,p=line.strip(’\n’).split(’😂
if inp_name == u and inp_pwd == p:
print(‘登录成功’)
break
else:
print(‘账号名或者密码错误’)

##### 3.1.2 案例二：w 模式的使用

w只写模式: 在文件不存在时会创建空文档,文件存在会清空文件,文件指针跑到文件开头

with open(‘b.txt’,mode=‘w’,encoding=‘utf-8’) as f:
f.write(‘你好\n’)
f.write(‘我好\n’)
f.write(‘大家好\n’)
f.write(‘111\n222\n333\n’)
#强调：

1 在文件不关闭的情况下,连续的写入，后写的内容一定跟在前写内容的后面

2 如果重新以w模式打开文件，则会清空文件内容

##### 3.1.3 案例三：a 模式的使用

a只追加写模式: 在文件不存在时会创建空文档,文件存在会将文件指针直接移动到文件末尾

with open(‘c.txt’,mode=‘a’,encoding=‘utf-8’) as f:
f.write(‘44444\n’)
f.write(‘55555\n’)
#强调 w 模式与 a 模式的异同：

1 相同点：在打开的文件不关闭的情况下，连续的写入，新写的内容总会跟在前写的内容之后

2 不同点：以 a 模式重新打开文件，不会清空原文件内容，会将文件指针直接移动到文件末尾，新写的内容永远写在最后

小练习：实现注册功能:

name=input('username>>>: ').strip()
pwd=input(‘password>>>: ‘).strip()
with open(‘db1.txt’,mode=‘a’,encoding=‘utf-8’) as f:
info=’%s:%s\n’ %(name,pwd)
f.write(info)

##### 3.1.4 案例四：+ 模式的使用(了解)

r+ w+ a+ :可读可写

#在平时工作中，我们只单纯使用r/w/a，要么只读，要么只写，一般不用可读可写的模式

#### 3.2 控制文件读写内容的模式

大前提: tb模式均不能单独使用,必须与r/w/a之一结合使用
t（默认的）：文本模式
1. 读写文件都是以字符串为单位的
2. 只能针对文本文件
3. 必须指定encoding参数
b：二进制模式:
1.读写文件都是以bytes/二进制为单位的
2. 可以针对所有文件
3. 一定不能指定encoding参数

##### 3.2.1 案例一：t 模式的使用

t 模式：如果我们指定的文件打开模式为r/w/a，其实默认就是rt/wt/at

with open(‘a.txt’,mode=‘rt’,encoding=‘utf-8’) as f:
res=f.read()
print(type(res)) # 输出结果为：<class ‘str’>

with open(‘a.txt’,mode=‘wt’,encoding=‘utf-8’) as f:
s=‘abc’
f.write(s) # 写入的也必须是字符串类型

#强调：t 模式只能用于操作文本文件,无论读写，都应该以字符串为单位，而存取硬盘本质都是二进制的形式，当指定 t 模式时，内部帮我们做了编码与解码

##### 3.2.2 案例二： b 模式的使用

b: 读写都是以二进制位单位

with open(‘1.mp4’,mode=‘rb’) as f:
data=f.read()
print(type(data)) # 输出结果为：<class ‘bytes’>

with open(‘a.txt’,mode=‘wb’) as f:
msg=“你好”
res=msg.encode(‘utf-8’) # res为bytes类型
f.write(res) # 在b模式下写入文件的只能是bytes类型

#强调：b模式对比t模式
1、在操作纯文本文件方面t模式帮我们省去了编码与解码的环节，b模式则需要手动编码与解码，所以此时t模式更为方便
2、针对非文本文件（如图片、视频、音频等）只能使用b模式

小练习： 编写拷贝工具

src_file=input(‘源文件路径: ‘).strip()
dst_file=input(‘目标文件路径: ‘).strip()
with open(r’%s’ %src_file,mode=‘rb’) as read_f,open(r’%s’ %dst_file,mode=‘wb’) as write_f:
for line in read_f:
# print(line)
write_f.write(line)

#### 四 操作文件的方法


#### 4.1 重点

读操作

f.read() # 读取所有内容,执行完该操作后，文件指针会移动到文件末尾
f.readline() # 读取一行内容,光标移动到第二行首部
f.readlines() # 读取每一行内容,存放于列表中

强调：

f.read()与f.readlines()都是将内容一次性读入内容，如果内容过大会导致内存溢出，若还想将内容全读入内存，则必须分多次读入，有两种实现方式：

方式一

with open(‘a.txt’,mode=‘rt’,encoding=‘utf-8’) as f:
for line in f:
print(line) # 同一时刻只读入一行内容到内存中

方式二

with open(‘1.mp4’,mode=‘rb’) as f:
while True:
data=f.read(1024) # 同一时刻只读入1024个Bytes到内存中
if len(data) == 0:
break
print(data)

写操作

f.write(‘1111\n222\n’) # 针对文本模式的写,需要自己写换行符
f.write(‘1111\n222\n’.encode(‘utf-8’)) # 针对b模式的写,需要自己写换行符
f.writelines([‘333\n’,‘444\n’]) # 文件模式
f.writelines([bytes(‘333\n’,encoding=‘utf-8’),‘444\n’.encode(‘utf-8’)]) #b模式

#### 4.2 了解

f.readable() # 文件是否可读
f.writable() # 文件是否可读
f.closed # 文件是否关闭
f.encoding # 如果文件打开模式为b,则没有该属性
f.flush() # 立刻将文件内容从内存刷到硬盘
f.name

#### 五 主动控制文件内指针移动

#大前提:文件内指针的移动都是Bytes为单位的,唯一例外的是t模式下的read(n),n以字符为单位
with open(‘a.txt’,mode=‘rt’,encoding=‘utf-8’) as f:
data=f.read(3) # 读取3个字符

with open(‘a.txt’,mode=‘rb’) as f:
data=f.read(3) # 读取3个Bytes

之前文件内指针的移动都是由读/写操作而被动触发的，若想读取文件某一特定位置的数据，则则需要用f.seek方法主动控制文件内指针的移动，详细用法如下：

f.seek(指针移动的字节数,模式控制):

模式控制:

0: 默认的模式,该模式代表指针移动的字节数是以文件开头为参照的

1: 该模式代表指针移动的字节数是以当前所在的位置为参照的

2: 该模式代表指针移动的字节数是以文件末尾的位置为参照的

强调:其中0模式可以在t或者b模式使用,而1跟2模式只能在b模式下用

#### 5.1 案例一： 0模式详解

a.txt用utf-8编码，内容如下（abc各占1个字节，中文“你好”各占3个字节）

abc你好

0模式的使用

with open(‘a.txt’,mode=‘rt’,encoding=‘utf-8’) as f:
f.seek(3,0) # 参照文件开头移动了3个字节
print(f.tell()) # 查看当前文件指针距离文件开头的位置，输出结果为3
print(f.read()) # 从第3个字节的位置读到文件末尾，输出结果为：你好
# 注意：由于在t模式下，会将读取的内容自动解码，所以必须保证读取的内容是一个完整中文数据，否则解码失败

with open(‘a.txt’,mode=‘rb’) as f:
f.seek(6,0)
print(f.read().decode(‘utf-8’)) #输出结果为: 好

#### 5.2 案例二： 1模式详解

1模式的使用

with open(‘a.txt’,mode=‘rb’) as f:
f.seek(3,1) # 从当前位置往后移动3个字节，而此时的当前位置就是文件开头
print(f.tell()) # 输出结果为：3
f.seek(4,1) # 从当前位置往后移动4个字节，而此时的当前位置为3
print(f.tell()) # 输出结果为：7

#### 5.3 案例三： 2模式详解

a.txt用utf-8编码，内容如下（abc各占1个字节，中文“你好”各占3个字节）

abc你好

2模式的使用

with open(‘a.txt’,mode=‘rb’) as f:
f.seek(0,2) # 参照文件末尾移动0个字节， 即直接跳到文件末尾
print(f.tell()) # 输出结果为：9
f.seek(-3,2) # 参照文件末尾往前移动了3个字节
print(f.read().decode(‘utf-8’)) # 输出结果为：好

小练习：实现动态查看最新一条日志的效果

import time
with open(‘access.log’,mode=‘rb’) as f:
f.seek(0,2)
while True:
line=f.readline()
if len(line) == 0:
# 没有内容
time.sleep(0.5)
else:
print(line.decode(‘utf-8’),end=‘’)

#### 六 文件的修改

文件a.txt内容如下

张一蛋 山东 179 49 12344234523
李二蛋 河北 163 57 13913453521
王全蛋 山西 153 62 18651433422

执行操作

with open(‘a.txt’,mode=‘r+t’,encoding=‘utf-8’) as f:
f.seek(9)
f.write(‘<妇女主任>’)

文件修改后的内容如下

张一蛋<妇女主任> 179 49 12344234523
李二蛋 河北 163 57 13913453521
王全蛋 山西 153 62 18651433422

强调：

1、硬盘空间是无法修改的,硬盘中数据的更新都是用新内容覆盖旧内容

2、内存中的数据是可以修改的

文件对应的是硬盘空间,硬盘不能修改对应着文件本质也不能修改, 那我们看到文件的内容可以修改,是如何实现的呢? 大致的思路是将硬盘中文件内容读入内存,然后在内存中修改完毕后再覆盖回硬盘 具体的实现方式分为两种:


#### 6.1 文件修改方式一

实现思路：将文件内容发一次性全部读入内存,然后在内存中修改完毕后再覆盖写回原文件

优点: 在文件修改过程中同一份数据只有一份

缺点: 会过多地占用内存

with open(‘db.txt’,mode=‘rt’,encoding=‘utf-8’) as f:
data=f.read()

with open(‘db.txt’,mode=‘wt’,encoding=‘utf-8’) as f:
f.write(data.replace(‘kevin’,‘SB’))

#### 6.1 文件修改方式二

实现思路：以读的方式打开原文件,以写的方式打开一个临时文件,一行行读取原文件内容,修改完后写入临时文件…,删掉原文件,将临时文件重命名原文件名

优点: 不会占用过多的内存

缺点: 在文件修改过程中同一份数据存了两份

import os

with open(‘db.txt’,mode=‘rt’,encoding=‘utf-8’) as read_f,
open(‘.db.txt.swap’,mode=‘wt’,encoding=‘utf-8’) as wrife_f:
for line in read_f:
wrife_f.write(line.replace(‘SB’,‘kevin’))

os.remove(‘db.txt’)
os.rename(‘.db.txt.swap’,‘db.txt’)

### 11、函数的基本使用


#### 一 引入


在程序中，具备某一功能的‘工具’指的就是函数，‘事先准备工具’的过程即函数的定义，‘拿来就用’即函数的调用。


#### 二 定义函数


函数的使用必须遵循’先定义，后调用’的原则。函数的定义就相当于事先将函数体代码保存起来，然后将内存地址赋值给函数名，函数名就是对这段代码的引用，这和变量的定义是相似的。没有事先定义函数而直接调用，就相当于在引用一个不存在的’变量名’。


定义函数的语法

def 函数名(参数1,参数2,…):
“”“文档描述”“”
函数体
return 值

1. def: 定义函数的关键字；
2. 函数名：函数名指向函数内存地址，是对函数体代码的引用。函数的命名应该反映出函数的功能；
3. 括号：括号内定义参数，参数是可有可无的，且无需指定参数的类型；
4. 冒号：括号后要加冒号，然后在下一行开始缩进编写函数体的代码；
5. “”“文档描述”“”: 描述函数功能，参数介绍等信息的文档，非必要，但是建议加上，从而增强函数的可读性；
6. 函数体：由语句和表达式组成；
7. return 值：定义函数的返回值，return是可有可无的。


参数是函数的调用者向函数体传值的媒介，若函数体代码逻辑依赖外部传来的参数时则需要定义为参函数，

def my_min(x,y):
res=x if x < y else y
return res

否则定义为无参函数

def interactive():
user=input('user>>: ').strip()
pwd=input('password>>: ').strip()
return (user,pwd)

函数体为pass代表什么都不做，称之为空函数。定义空函数通常是有用的，因为在程序设计的开始，往往是先想好程序都需要完成什么功能，然后把所有功能都列举出来用pass充当函数体“占位符”，这将使得程序的体系结构立见，清晰且可读性强。例如要编写一个ftp程序，我们可能想到的功能有用户认证，下载，上传，浏览，切换目录等功能，可以先做出如下定义：

def auth_user():
“”“user authentication function”“”
pass

def download_file():
“”“download file function”“”
pass

def upload_file():
“”“upload file function”“”
pass

def ls():
“”“list contents function”“”
pass

def cd():
“”“change directory”“”
pass

之后我们便可以统筹安排编程任务，有选择性的去实现上述功能来替换掉pass，从而提高开发效率。


#### 三 调用函数与函数返回值


函数的使用分为定义阶段与调用阶段，定义函数时只检测语法，不执行函数体代码，函数名加括号即函数调用，只有调用函数时才会执行函数体代码

#定义阶段
def foo():
print(‘in the foo’)
bar()

def bar():
print(‘in the bar’)

#调用阶段
foo()

执行结果：

in the foo
in the bar

定义阶段函数foo与bar均无语法错误，而在调用阶段调用foo()时，函数foo与bar都早已经存在于内存中了，所以不会有任何问题。


按照在程序出现的形式和位置，可将函数的调用形式分为三种

#1、语句形式：
foo()

#2、表达式形式：
m=my_min(1,2) #将调用函数的返回值赋值给x
n=10*my_min(1,2) #将调用函数的返回值乘以10的结果赋值给n

#3、函数调用作为参数的形式：

my_min（2，3）作为函数my_min的第二个参数，实现了取1,2,3中的较小者赋值给m

m=my_min(1，my_min（2，3）)

若需要将函数体代码执行的结果返回给调用者，则需要用到return。return后无值或直接省略return，则默认返回None，return的返回值无类型限制，且可以将多个返回值放到一个元组内。

def test(x,y,z):
… return x,y,z #等同于return (x,y,z)
…
res=test(1,2,3)
print(res)
(1, 2, 3)

return是一个函数结束的标志,函数内可以有多个return，但只执行一次函数就结束了，并把return后定义的值作为本次调用的结果返回。


### 12、函数的参数


#### 一 形参与实参介绍


函数的参数分为形式参数和实际参数，简称形参和实参：


形参即在定义函数时，括号内声明的参数。形参本质就是一个变量名，用来接收外部传来的值。


实参即在调用函数时，括号内传入的值，值可以是常量、变量、表达式或三者的组合:

#1：实参是常量
res=my_min(1,2)

#2：实参是变量
a=1
b=2
res=my_min(a,b)

#3：实参是表达式
res=my_min(102,10my_min(3,4))

#4：实参可以是常量、变量、表达式的任意组合
a=2
my_min(1,a,10*my_min(3,4))

在调用有参函数时，实参（值）会赋值给形参（变量名）。在Python中，变量名与值只是单纯的绑定关系，而对于函数来说，这种绑定关系只在函数调用时生效，在调用结束后解除。


#### 二 形参与实参的具体使用


#### 2.1 位置参数


位置即顺序，位置参数指的是按顺序定义的参数，需要从两个角度去看：


1. 在定义函数时，按照从左到右的顺序依次定义形参,称为位置形参，凡是按照这种形式定义的形参都必须被传值

def register(name,age,sex): #定义位置形参：name，age，sex，三者都必须被传值
print(‘Name:%s Age:%s Sex:%s’ %(name,age,sex))
register() #TypeError：缺少3个位置参数

在调用函数时，按照从左到右的顺序依次定义实参，称为位置实参，凡是按照这种形式定义的实参会按照从左到右的顺序与形参一一对应

def register(name,age,sex): #定义位置形参：name，age，sex，三者都必须被传值
print(‘Name:%s Age:%s Sex:%s’ %(name,age,sex))
register() #TypeError：缺少3个位置参数

#### 2.2 关键字参数


在调用函数时，实参可以是key=value的形式，称为关键字参数，凡是按照这种形式定义的实参，可以完全不按照从左到右的顺序定义，但仍能为指定的形参赋值

register(sex=‘male’,name=‘lili’,age=18)
Name:lili Age:18 Sex:male

需要注意在调用函数时，实参也可以是按位置或按关键字的混合使用，但必须保证关键字参数在位置参数后面，且不可以对一个形参重复赋值

register(‘lili’,sex=‘male’,age=18) #正确使用
register(name=‘lili’,18,sex=‘male’) #SyntaxError：关键字参数name=‘lili’在位置参数18之前
register(‘lili’,sex=‘male’,age=18,name=‘jack’) #TypeError：形参name被重复赋值

#### 2.3 默认参数


在定义函数时，就已经为形参赋值，这类形参称之为默认参数，当函数有多个参数时，需要将值经常改变的参数定义成位置参数，而将值改变较少的参数定义成默认参数。例如编写一个注册学生信息的函数，如果大多数学生的性别都为男，那完全可以将形参sex定义成默认参数

def register(name,age,sex=‘male’): #默认sex的值为male
… print(‘Name:%s Age:%s Sex:%s’ %(name,age,sex))
…

定义时就已经为参数sex赋值，意味着调用时可以不对sex赋值，这降低了函数调用的复杂度

register(‘tom’,17) #大多数情况,无需为sex传值,默认为male
Name:tom Age:17 Sex:male
register(‘Lili’,18,‘female’) #少数情况,可以为sex传值female
Name:Lili Age:18 Sex:female

需要注意：


1. 默认参数必须在位置参数之后
2. 默认参数的值仅在函数定义阶段被赋值一次

x=1
def foo(arg=x):
… print(arg)
…
x=5 #定义阶段arg已被赋值为1，此处的修改与默认参数arg无任何关系
foo()
1

1. 默认参数的值通常应设为不可变类型

def foo(n,arg=[]):
arg.append(n)
return arg
foo(1)
[1]
foo(2)
[1, 2]
foo(3)
[1, 2, 3]

每次调用是在上一次的基础上向同一列表增加值，修改如下

def foo(n,arg=None):
if arg is None:
arg=[]
arg.append(n)
return arg
foo(1)
[1]
foo(2)
[2]
foo(3)
[3]

#### 2.4 可变长度的参数（\*与\*\*的用法）


参数的长度可变指的是在调用函数时，实参的个数可以不固定，而在调用函数时，实参的定义无非是按位置或者按关键字两种形式，这就要求形参提供两种解决方案来分别处理两种形式的可变长度的参数


##### 2.4.1 可变长度的位置参数


如果在最后一个形参名前加\_号,那么在调用函数时，溢出的位置实参，都会被\_接收，以元组的形式保存下来赋值给该形参

def foo(x,y,z=1,args): #在最后一个形参名args前加号
… print(x)
… print(y)
… print(z)
… print(args)
…
foo(1,2,3,4,5,6,7) #实参1、2、3按位置为形参x、y、z赋值，多余的位置实参4、5、6、7都被*接收，以元组的形式保存下来，赋值给args，即args=(4, 5, 6,7)

1
2
3
(4, 5, 6, 7)

如果我们事先生成了一个列表,仍然是可以传值给\*args的

def foo(x,y,*args):
… print(x)
… print(y)
… print(args)
…
L=[3,4,5]
foo(1,2,*L) # *L就相当于位置参数3，4，5, foo(1,2,*L)就等同于foo(1,2,3,4,5)
1
2
(3, 4, 5)

注意：如果在传入L时没有加\*,那L就只是一个普通的位置参数了

foo(1,2,L) #仅多出一个位置实参L
1
2
([1, 2, 3],)

如果形参为常规的参数（位置或默认），实参仍可以是\*的形式

def foo(x,y,z=3):
… print(x)
… print(y)
… print(z)
…
foo(*[1,2]) #等同于foo(1,2)
1
2
3

如果我们想要求多个值的和，\*args就派上用场了

def add(*args):
… res=0
… for i in args:
… res+=i
… return res
…
add(1,2,3,4,5)
15

##### 2.4.2 可变长度的关键字参数


如果在最后一个形参名前加**号,那么在调用函数时，溢出的关键字参数，都会被**接收，以字典的形式保存下来赋值给该形参

def foo(x,kwargs): #在最后一个参数kwargs前加
… print(x)
… print(kwargs)
…
foo(y=2,x=1,z=3) #溢出的关键字实参y=2，z=3都被**接收，以字典的形式保存下来，赋值给kwargs
1
{‘z’: 3, ‘y’: 2}

如果我们事先生成了一个字典,仍然是可以传值给\*\*kwargs的

def foo(x,y,**kwargs):
… print(x)
… print(y)
… print(kwargs)
…
dic={‘a’:1,‘b’:2}
foo(1,2,**dic) #**dic就相当于关键字参数a=1，b=2，foo(1,2,**dic)等同foo(1,2,a=1,b=2)
1
2
{‘a’: 1, ‘b’: 2}

注意：如果在传入dic时没有加\*\*,那dic就只是一个普通的位置参数了

foo(1,2,dic) #TypeError:函数foo只需要2个位置参数，但是传了3个

如果形参为常规参数（位置或默认），实参仍可以是\*\*的形式

def foo(x,y,z=3):
… print(x)
… print(y)
… print(z)
…
foo(**{‘x’:1,‘y’:2}) #等同于foo(y=2,x=1)
1
2
3

如果我们要编写一个用户认证的函数，起初可能只基于用户名密码的验证就可以了，可以使用\*\*kwargs为日后的扩展供良好的环境，同时保持了函数的简洁性。

def auth(user,password,**kwargs):
… pass
…

#### 2.5 命名关键字参数


在定义了\*\*kwargs参数后，函数调用者就可以传入任意的关键字参数key=value，如果函数体代码的执行需要依赖某个key，必须在函数内进行判断

def register(name,age,**kwargs):
… if ‘sex’ in kwargs:
… #有sex参数
… pass
… if ‘height’ in kwargs:
… #有height参数
… pass
…

想要限定函数的调用者必须以key=value的形式传值，Python3提供了专门的语法：需要在定义形参时，用\*作为一个分隔符号，\*号之后的形参称为命名关键字参数。对于这类参数，在函数调用时，必须按照key=value的形式为其传值，且必须被传值

def register(name,age,*,sex,height): #sex,height为命名关键字参数
… pass
…
register(‘lili’,18,sex=‘male’,height=‘1.8m’) #正确使用
register(‘lili’,18,‘male’,‘1.8m’) # TypeError:未使用关键字的形式为sex和height传值
register(‘lili’,18,height=‘1.8m’) # TypeError没有为命名关键字参数height传值。

命名关键字参数也可以有默认值，从而简化调用

def register(name,age,*,sex=‘male’,height):
… print(‘Name:%s,Age:%s,Sex:%s,Height:%s’ %(name,age,sex,height))
…
register(‘lili’,18,height=‘1.8m’)
Name:lili,Age:18,Sex:male,Height:1.8m

需要强调的是：sex不是默认参数，height也不是位置参数，因为二者均在\_后，所以都是命名关键字参数，形参sex=’male’属于命名关键字参数的默认值，因而即便是放到形参height之前也不会有问题。另外，如果形参中已经有一个\_args了，命名关键字参数就不再需要一个单独的\*作为分隔符号了

def register(name,age,*args,sex=‘male’,height):
… print(‘Name:%s,Age:%s,Args:%s,Sex:%s,Height:%s’ %(name,age,args,sex,height))
…
register(‘lili’,18,1,2,3,height=‘1.8m’) #sex与height仍为命名关键字参数
Name:lili,Age:18,Args:(1, 2, 3),Sex:male,Height:1.8m

#### 2.6 组合使用


综上所述所有参数可任意组合使用，但定义顺序必须是：位置参数、默认参数、\*args、命名关键字参数、\*\*kwargs


可变参数\*args与关键字参数**kwargs通常是组合在一起使用的，如果一个函数的形参为\*args与**kwargs，那么代表该函数可以接收任何形式、任意长度的参数

def wrapper(*args,**kwargs):
… pass
…

在该函数内部还可以把接收到的参数传给另外一个函数（这在4.6小节装饰器的实现中大有用处）

def func(x,y,z):
… print(x,y,z)
…
def wrapper(*args,**kwargs):
… func(*args,**kwargs)
…
wrapper(1,z=3,y=2)
1 2 3

按照上述写法，在为函数wrapper传参时，其实遵循的是函数func的参数规则，调用函数wrapper的过程分析如下：


1. 位置实参1被\*接收，以元组的形式保存下来，赋值给args，即args=(1,),关键字实参z=3，y=2被\*\*接收，以字典的形式保存下来，赋值给kwargs，即kwargs={‘y’: 2, ‘z’: 3}
2. 执行func(*args,*kwargs),即func(*(1,),*\* {‘y’: 2, ‘z’: 3}),等同于func(1,z=3,y=2)

提示： *args、**kwargs中的args和kwargs被替换成其他名字并无语法错误，但使用args、kwargs是约定

### 13、名称空间与作用域


#### 一 名称空间


名称空间即存放名字与对象映射/绑定关系的地方。对于x=3，Python会申请内存空间存放对象3，然后将名字x与3的绑定关系存放于名称空间中，del x表示清除该绑定关系。


在程序执行期间最多会存在三种名称空间


#### 1.1 内建名称空间


伴随python解释器的启动/关闭而产生/回收，因而是第一个被加载的名称空间，用来存放一些内置的名字，比如内建函数名

max
#built-in内建

#### 1.2 全局名称空间


伴随python文件的开始执行/执行完毕而产生/回收，是第二个被加载的名称空间，文件执行过程中产生的名字都会存放于该名称空间中，如下名字

import sys #模块名sys

x=1 #变量名x

if x == 1:
y=2 #变量名y

def foo(x): #函数名foo
y=1
def bar():
pass

Class Bar: #类名Bar
pass

#### 1.3 局部名称空间


伴随函数的调用/结束而临时产生/回收，函数的形参、函数内定义的名字都会被存放于该名称空间中

def foo(x):
y=3 #调用函数时，才会执行函数代码，名字x和y都存放于该函数的局部名称空间中

名称空间的加载顺序是：内置名称空间->全局名称空间->局部名称空间，而查找一个名字，必须从三个名称空间之一找到，查找顺序为：局部名称空间->全局名称空间->内置名称空间。


#### 二 作用域


#### 2.1 全局作用域与局部作用域


按照名字作用范围的不同可以将三个名称空间划分为两个区域：


1. 全局作用域:位于全局名称空间、内建名称空间中的名字属于全局范围，该范围内的名字全局存活（除非被删除，否则在整个文件执行过程中存活）、全局有效（在任意位置都可以使用）；
2. 局部作用域:位于局部名称空间中的名字属于局部范围。该范围内的名字临时存活（即在函数调用时临时生成，函数调用结束后就释放）、局部有效（只能在函数内使用）。


#### 2.2 作用域与名字查找的优先级


在局部作用域查找名字时，起始位置是局部作用域，所以先查找局部名称空间，没有找到，再去全局作用域查找：先查找全局名称空间，没有找到，再查找内置名称空间，最后都没有找到就会抛出异常

x=100 #全局作用域的名字x
def foo():
x=300 #局部作用域的名字x
print(x) #在局部找x
foo()#结果为300

在全局作用域查找名字时，起始位置便是全局作用域，所以先查找全局名称空间，没有找到，再查找内置名称空间，最后都没有找到就会抛出异常

x=100
def foo():
x=300 #在函数调用时产生局部作用域的名字x
foo()
print(x) #在全局找x,结果为100

提示：可以调用内建函数locals()和globals()来分别查看局部作用域和全局作用域的名字，查看的结果都是字典格式。在全局作用域查看到的locals()的结果等于globals()


Python支持函数的嵌套定义，在内嵌的函数内查找名字时，会优先查找自己局部作用域的名字，然后由内而外一层层查找外部嵌套函数定义的作用域，没有找到，则查找全局作用域

x=1
def outer():
x=2
def inner(): # 函数名inner属于outer这一层作用域的名字
x=3
print(‘inner x:%s’ %x)

inner()
print('outer x:%s' %x)

outer()
#结果为
inner x:3
outer x:2

在函数内，无论嵌套多少层，都可以查看到全局作用域的名字，若要在函数内修改全局名称空间中名字的值，当值为不可变类型时，则需要用到global关键字

x=1
def outer():
x=2
def inner(): # 函数名inner属于outer这一层作用域的名字
x=3
print(‘inner x:%s’ %x)

inner()
print('outer x:%s' %x)

outer()
#结果为
inner x:3
outer x:2

在函数内，无论嵌套多少层，都可以查看到全局作用域的名字，若要在函数内修改全局名称空间中名字的值，当值为不可变类型时，则需要用到global关键字

x=1
def foo():
global x #声明x为全局名称空间的名字
x=2
foo()
print(x) #结果为2

当实参的值为可变类型时，函数体内对该值的修改将直接反应到原值，

num_list=[1,2,3]
def foo(nums):
nums.append(5)

foo(num_list)
print(num_list)
#结果为
[1, 2, 3, 5]

对于嵌套多层的函数，使用nonlocal关键字可以将名字声明为来自外部嵌套函数定义的作用域（非全局）

def f1():
x=2
def f2():
nonlocal x
x=3
f2() #调用f2(),修改f1作用域中名字x的值
print(x) #在f1作用域查看x

f1()

#结果
3

nonlocal x会从当前函数的外层函数开始一层层去查找名字x，若是一直到最外层函数都找不到，则会抛出异常。


### 14、函数对象和闭包


#### 一 函数对象


函数对象指的是函数可以被当做’数据’来处理，具体可以分为四个方面的使用，我们如下


#### 1.1 函数可以被引用

def add(x,y):
… return x+y
…
func=add
func(1,2)
3

#### 1.2 函数可以作为容器类型的元素


学好 Python 不论是就业还是做副业赚钱都不错，但要学会 Python 还是要有一个学习规划。最后大家分享一份全套的 Python 学习资料，给那些想学习 Python 的小伙伴们一点帮助！



### 一、Python所有方向的学习路线



Python所有方向路线就是把Python常用的技术点做整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。



![](https://img-blog.csdnimg.cn/img_convert/9f49b566129f47b8a67243c1008edf79.png)



### 二、学习软件

工欲善其事必先利其器。学习Python常用的开发软件都在这里了，给大家节省了很多时间。



![](https://img-blog.csdnimg.cn/img_convert/8c4513c1a906b72cbf93031e6781512b.png)



### 三、全套PDF电子书



书籍的好处就在于权威和体系健全，刚开始学习的时候你可以只看视频或者听某个人讲课，但等你学完之后，你觉得你掌握了，这时候建议还是得去看一下书籍，看权威技术书籍也是每个程序员必经之路。

![](https://img-blog.csdnimg.cn/img_convert/46506ae54be168b93cf63939786134ca.png)



### 四、入门学习视频

我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了。



![](https://img-blog.csdnimg.cn/afc935d834c5452090670f48eda180e0.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA56iL5bqP5aqb56eD56eD,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center)



### 五、实战案例



光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。



![](https://img-blog.csdnimg.cn/img_convert/252731a671c1fb70aad5355a2c5eeff0.png)



### 六、面试资料

我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。



![](https://img-blog.csdnimg.cn/img_convert/6c361282296f86381401c05e862fe4e9.png)  

![](https://img-blog.csdnimg.cn/img_convert/d2d978bb523c810abca3abe69e09bc1a.png)




**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化学习资料的朋友，可以戳这里无偿获取](https://bbs.youkuaiyun.com/topics/618317507)**

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**