【Python】基础（学习笔记）
一、Python介绍
1、Python优点
学习成本低
开源
适应⼈群⼴泛
应⽤领域⼴泛
2、Python解释器
Python解释器作用：运行Python文件
Python解释器分类
CPython：C语⾔开发的解释器[官⽅]，应⽤⼴泛的解释器。
IPython：基于CPython的⼀种交互式解释器。
PyPy：基于Python语⾔开发的解释器。
Jython：运⾏在Java平台的解释器，直接把Python代码编译成Java字节码执⾏。
IronPython：运⾏在微软.Net平台上的Python解释器，可以直接把Python代码编译成.Net的字节码。
3、PyCharm
PyCharm是⼀种Python IDE（集成开发环境）
1）PyCharm新建⽂件
项⽬管理空⽩位置 — 右键 – New – PythonFile
2）运⾏⽂件
代码内部 — 右键 – Run
3）修改代码⽂字格式
[fifile] – [Settings]/[Default Settings] – [Editor] – [Font]
4）Debug⼯具
断点位置：⽬标要调试的代码块的第⼀⾏代码即可，即⼀个断点即可。
打断点的⽅法：单击⽬标代码的⾏号右侧空⽩位置，在⽂件内部任意位置 — 右键 – Debug’⽂件名’ — 即可调出Debug⼯具⾯板 – 单击StepOver/F8，即可按步执⾏代码。
Debug输出⾯板：
Debugger显示变量和变量的细节
Console：输出内容
4、查看python版本
cmd --> Python3 -V
二、Python基础语法
1、编码
Python 3 源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串
2、标识符
- 第一个字符必须是字母表中字母或下划线 _
- 标识符的其他的部分由字母、数字和下划线组成
- 标识符对大小写敏感
- 可以用中文作为变量名
3、保留字
保留字即关键字，我们不能把它们用作任何标识符名称。
Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字
>>> import keyword
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
4、注释
Python中单行注释以 # 开头
# 第一个注释
print ("Hello, Python!") # 第二个注释
多行注释可以用多个 #号，还有 ''' 和 """
# 第一个注释
# 第二个注释
'''
第三注释
第四注释
'''
"""
第五注释
第六注释
"""
5、行与缩进
缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数
6、多行语句
Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠 \ 来实现多行语句
total = item_one + \
item_two + \
item_three
在 [], {}, 或 () 中的多行语句，不需要使用反斜杠 \
total = ['item_one', 'item_two', 'item_three',
'item_four', 'item_five']
7、空行
函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。
空行与代码缩进不同，空行并不是 Python 语法的一部分。书写时不插入空行，Python 解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。
空行也是程序代码的一部分。
8、同一行显示多条语句
Python 可以在同一行中使用多条语句，语句之间使用分号 ; 分割
name = 'wmh'; print(name)
9、多个语句构成代码组
缩进相同的一组语句构成一个代码块，我们称之代码组。
像if、while、def和class这样的复合语句，首行以关键字开始，以冒号( : )结束，该行之后的一行或多行代码构成代码组。
我们将首行及后面的代码组称为一个子句(clause)
10、print 输出
print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=""
x="a"
y="b"
# 换行输出
print( x )
print( y )
print('---------')
# 不换行输出
print( x, end=" " )
print( y, end=" " )
print()
11、import 与 from…import
在 python 用 import 或者 from...import 来导入相应的模块。
- 将整个模块(somemodule)导入，格式为：
import somemodule - 从某个模块中导入某个函数,格式为：
from somemodule import somefunction - 从某个模块中导入多个函数,格式为：
from somemodule import firstfunc, secondfunc, thirdfunc - 将某个模块中的全部函数导入，格式为：
from somemodule import *
三、数据类型
1、赋值
Python 中的变量不需要声明。但每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。
一个变量可以通过赋值指向不同类型的对象。
等号（=）用来给变量赋值。
a = 'wmh'
print(a)
Python允许你同时为多个变量赋值
a = b = c = 1
可以为多个对象指定多个变量
a, b, c = 1, 2, "runoob"
交换两变量的值
a,b = b,a
2、标准数据类型
- Number（数字）
- String（字符串）
- List（列表）
- Tuple（元组）
- Set（集合）
- Dictionary（字典）
**不可变数据（3 个）：**Number（数字）、String（字符串）、Tuple（元组）
**可变数据（3 个）：**List（列表）、Dictionary（字典）、Set（集合）
3、Number（数字）
Python3 支持 int、float、bool、complex（复数）
- 整型(int)：不分正负但不带小数点。Python3 整型是没有限制大小的，所以 Python3 没有 Python2 的 Long 类型。布尔(bool)是整型的子类型。
- 浮点型(float)：浮点型由整数部分与小数部分组成，可以用科学计数法表示（2.5e2 = 2.5 x 102 = 250）
- 复数(complex)：复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， a和b都是浮点型。
可以用十六进制和八进制来代表整数
>>> number = 0xA0F # 十六进制
>>> number
2575
>>> number=0o37 # 八进制
>>> number
31
内置的 type() 函数可以用来查询变量所指的对象类型
>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
可以用 isinstance 来判断
>>> a = 111
>>> isinstance(a, int)
True
sinstance 和 type 的区别在于：
- type()不会认为子类是一种父类类型
- isinstance()会认为子类是一种父类类型
Python3 中，bool 是 int 的子类，True 和 False 可以和数字相加，True==1、False==0会返回 True，但可以通过 is 来判断类型。
issubclass(bool, int) # True
True==1 # True
False==0 # True
True+1 # 2
False+1 # 1
1 is True # False
0 is False # False
del语句删除单个或多个对象
del var
del var_a, var_b
Python还支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型
在交互模式中，最后被输出的表达式结果被赋值给变量 _
类似于jQuery中的
$
>>> 1 + 2
3
>>> _
3
4、String（字符串）
字符串：单引号 ' 或双引号 " 括起来，同时使用反斜杠 \ 转义特殊字符。
变量[头下标:尾下标:步长] # 字符串分片(左闭右开)
索引值：从左往右以0开始，从右往左以-1开始
用+运算符连接在一起，用*运算符重复
print (str * 2) # 输出字符串两次，也可以写成 print (2 * str)
print (str + "TEST") # 连接字符串
使用反斜杠 \ 转义特殊字符
\r：回车，将 \r 后面的内容移到字符串开头，并逐一替换开头部分的字符，直至将 \r 后面的内容完全替换完成
>>> print('google runoob taobao\r123456')
123456 runoob taobao
在字符串前面添加一个 r，表示原始字符串
>>> print('Ru\noob')
Ru
oob
>>> print(r'Ru\noob')
Ru\noob
反斜杠(\)可以作为续行符，表示下一行是上一行的延续。也可以使用 """...""" 或者 '''...''' 跨越多行。
字符串格式化输出
print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
| 符号 | 描述 |
|---|---|
| %c | 格式化字符及其ASCII码 |
| %s | 格式化字符串 |
| %d | 格式化整数 |
| %f | 格式化浮点数字，可指定小数点后的精度 |
f-string输出
>>> name = 'Runoob'
>>> f'Hello {name}' # 替换变量
'Hello Runoob'
>>> x = 1
>>> print(f'{x+1=}') # Python 3.8
x+1=2
Python 没有单独的字符类型，一个字符就是长度为1的字符串。
与 C 字符串不同的是，Python 字符串不能被改变。向一个索引位置赋值，word[0] = 'm'会导致错误。
5、List（列表）
列表中元素的类型可以不相同，它支持数字，字符串与列表嵌套
列表写在方括号 [] 之间、用逗号分隔开的元素列表
和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。
变量[头下标:尾下标:步长] # 列表分片
索引值：从左往右以0开始，从右往左以-1开始
用+运算符连接在一起，用*运算符重复
列表中的元素是可以改变的
删除列表元素：del list[2]
列表比较
import operator
a = [1, 2]
b = [2, 3]
c = [2, 3]
print("operator.eq(a,b): ", operator.eq(a,b)) # False
print("operator.eq(c,b): ", operator.eq(c,b)) # True
6、Tuple（元组）
与列表类似，不同之处在于元组的元素不能修改。
所谓元组的不可变指的是元组所指向的内存中的内容不可变
重新赋值的元组变量，绑定到了新的对象，不是修改了原来的对象了
元组写在小括号 () 里，元素之间用逗号隔开
元组也可以被索引和切片，也可以使用+操作符进行拼接
可以把字符串看作一种特殊的元组
虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表
构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则
tup1 = () # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号
string、list 和 tuple 都属于 sequence（序列）
7、Set（集合）
集合（set）：由一个或数个形态各异的大小整体组成的
构成集合的事物或对象称作元素或是成员
基本功能：进行成员关系测试和删除重复元素
可以使用大括号 { } 或者 set() 函数创建集合
创建一个空集合必须用 set() ，因为 { } 是用来创建一个空字典
parame = {value01,value02,...}
set(value)
sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'}
print(sites) # 输出集合，重复的元素被自动去掉
# 成员测试
if 'Runoob' in sites :
print('Runoob 在集合中')
else :
print('Runoob 不在集合中')
# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
print(a - b) # a 和 b 的差集
{'r', 'b', 'd'}
print(a | b) # a 和 b 的并集
{'b', 'c', 'a', 'z', 'm', 'r', 'l', 'd'}
print(a & b) # a 和 b 的交集
{'c', 'a'}
print(a ^ b) # a 和 b 中不同时存在的元素
{'z', 'b', 'm', 'r', 'l', 'd'}
1）添加元素
添加元素：s.add( x )
添加元素、列表、元组、字典：s.update( x )
x 可以有多个，用逗号分开
2）移除元素
不存在报错：s.remove( x )
不存在不报错：s.discard( x )
随机删一个：s.pop()
set 集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除
3）其他操作
计算集合元素个数：len(s)
清空集合：s.clear()
判断元素是否在集合中存在：x in s
8、Dictionary（字典）
列表是有序的对象集合，字典是无序的对象集合
两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取
字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。
键(key)必须使用不可变类型。
键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行
在同一个字典中，键(key)必须是唯一的。
创建时如果同一个键被赋值两次，后一个值为准
注：dict 作为 Python 的关键字和内置函数，变量名不建议命名为 dict
dict = {}
dict['one'] = "123"
dict[2] = "456"
print (dict['one']) # 输出键为 'one' 的值
print (dict[2]) # 输出键为 2 的值
print (dict) # 输出完整的字典
print (dict.keys()) # 输出所有键
print (dict.values()) # 输出所有值
创建空字典使用 {}
修改字典
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
tinydict['Age'] = 8 # 更新 Age
tinydict['School'] = "No.1" # 添加信息
9、隐式类型转换
较低数据类型（整数）就会转换为较高数据类型（浮点数）以避免数据丢失
10、显式类型转换
int() 强制转换为整型
x = int(1) # x 输出结果为 1
y = int(2.8) # y 输出结果为 2
z = int("3") # z 输出结果为 3
float() 强制转换为浮点型
x = float(1) # x 输出结果为 1.0
y = float(2.8) # y 输出结果为 2.8
z = float("3") # z 输出结果为 3.0
w = float("4.2") # w 输出结果为 4.2
str() 强制转换为字符串类型
x = str("s1") # x 输出结果为 's1'
y = str(2) # y 输出结果为 '2'
z = str(3.0) # z 输出结果为 '3.0'
| 函数 | 描述 |
|---|---|
| int(x [,base]) | 将x转换为一个整数 |
| float(x) | 将x转换到一个浮点数 |
| [complex(real ,imag]) | 创建一个复数 |
| str(x) | 将对象 x 转换为字符串 |
| repr(x) | 将对象 x 转换为表达式字符串 |
| eval(str) | 用来计算在字符串中的有效Python表达式,并返回一个对象 |
| tuple(s) | 将序列 s 转换为一个元组 |
| list(s) | 将序列 s 转换为一个列表 |
| set(s) | 转换为可变集合 |
| dict(d) | 创建一个字典。d 必须是一个 (key, value)元组序列。 |
| frozenset(s) | 转换为不可变集合 |
| chr(x) | 将一个整数转换为一个字符 |
| ord(x) | 将一个字符转换为它的整数值 |
| hex(x) | 将一个整数转换为一个十六进制字符串 |
| oct(x) | 将一个整数转换为一个八进制字符串 |
四、推导式
1、什么是推导式
Python 推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体
- 列表(list)推导式
- 字典(dict)推导式
- 集合(set)推导式
- 元组(tuple)推导式
2、列表推导式
[表达式 for 变量 in 列表]
[out_exp_res for out_exp in input_list]
[表达式 for 变量 in 列表 if 条件]
[out_exp_res for out_exp in input_list if condition]
out_exp_res：列表生成元素表达式，可以是有返回值的函数。for out_exp in input_list：迭代 input_list 将 out_exp 传入到 out_exp_res 表达式中。if condition：条件语句，可以过滤列表中不符合条件的值。
过滤掉长度小于或等于3的字符串列表，并将剩下的转换成大写字母
>>> names = ['Bob','Tom','alice','Jerry','Wendy','Smith']
>>> new_names = [name.upper() for name in names if len(name)>3]
>>> print(new_names)
['ALICE', 'JERRY', 'WENDY', 'SMITH']
计算 30 以内可以被 3 整除的整数
>>> multiples = [i for i in range(30) if i % 3 == 0]
>>> print(multiples)
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]
3、字典推导式
{ key_expr: value_expr for value in collection }
{ key_expr: value_expr for value in collection if condition }
提供三个数字，以三个数字为键，三个数字的平方为值来创建字典
>>> dic = {x: x**2 for x in (2, 4, 6)}
>>> dic
{2: 4, 4: 16, 6: 36}
4、集合推导式
{ expression for item in Sequence }
{ expression for item in Sequence if conditional }
判断不是 abc 的字母并输出
>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'d', 'r'}
>>> type(a)
<class 'set'>
5、元组推导式
(expression for item in Sequence )
或
(expression for item in Sequence if conditional )
元组推导式和列表推导式的用法也完全相同，只是元组推导式是用 () 圆括号将各部分括起来，而列表推导式用的是中括号 []
元组推导式返回的结果是一个生成器对象
>>> a = (x for x in range(1,10))
>>> a
<generator object <genexpr> at 0x7faf6ee20a50> # 返回的是生成器对象
>>> tuple(a) # 使用 tuple() 函数，可以直接将生成器对象转换成元组
(1, 2, 3, 4, 5, 6, 7, 8, 9)
五、运算符
1、算数运算符
| 运算符 | 说明 |
|---|---|
| + | 加 - 两个对象相加 |
| - | 减 - 得到负数或是一个数减去另一个数 |
| * | 乘 - 两个数相乘或是返回一个被重复若干次的字符串 |
| / | 除 - x 除以 y |
| % | 取模 - 返回除法的余数 |
| ** | 幂 - 返回x的y次幂 |
| // | 取整除 - 向下取接近商的整数 |
2、比较运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 等于 - 比较对象是否相等 | (a == b) 返回 False。 |
| != | 不等于 - 比较两个对象是否不相等 | (a != b) 返回 True。 |
| > | 大于 - 返回x是否大于y | (a > b) 返回 False。 |
| < | 小于 - 返回x是否小于y。 | (a < b) 返回 True。 |
| >= | 大于等于 - 返回x是否大于等于y。 | (a >= b) 返回 False。 |
| <= | 小于等于 - 返回x是否小于等于y。 | (a <= b) 返回 True。 |
所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。
3、赋值运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 赋值运算符 | c = a + b 将 a + b 的运算结果赋值为 c |
| += | 加法赋值运算符 | c += a 等效于 c = c + a |
| -= | 减法赋值运算符 | c -= a 等效于 c = c - a |
| *= | 乘法赋值运算符 | c *= a 等效于 c = c * a |
| /= | 除法赋值运算符 | c /= a 等效于 c = c / a |
| %= | 取模赋值运算符 | c %= a 等效于 c = c % a |
| **= | 幂赋值运算符 | c **= a 等效于 c = c ** a |
| //= | 取整除赋值运算符 | c //= a 等效于 c = c // a |
:= 海象运算符
可在表达式内部为变量赋值。（Python3.8 版本新增运算符）
List = ['r','e','x','h','a','o']
for i in range(Len := len(List)):
print(List[i],end="")
# rexhao
4、位运算符（摆烂）
| 运算符 | 描述 | 实例 |
|---|---|---|
| & | 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 | (a & b) 输出结果 12 ，二进制解释： 0000 1100 |
| | | 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。 | (a | b) 输出结果 61 ，二进制解释： 0011 1101 |
| ^ | 按位异或运算符：当两对应的二进位相异时，结果为1 | (a ^ b) 输出结果 49 ，二进制解释： 0011 0001 |
| ~ | 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1 | (~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。 |
| << | 左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。 | a << 2 输出结果 240 ，二进制解释： 1111 0000 |
| >> | 右移动运算符：把">>“左边的运算数的各二进位全部右移若干位，”>>"右边的数指定移动的位数 | a >> 2 输出结果 15 ，二进制解释： 0000 1111 |
5、逻辑运算符
| 运算符 | 逻辑表达式 | 描述 | 实例 |
|---|---|---|---|
| and | x and y | 布尔"与" - 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。 | (a and b) 返回 20。 |
| or | x or y | 布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。 | (a or b) 返回 10。 |
| not | not x | 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 | not(a and b) 返回 False |
6、成员运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| in | 如果在指定的序列中找到值返回 True，否则返回 False。 | x 在 y 序列中 , 如果 x 在 y 序列中返回 True。 |
| not in | 如果在指定的序列中没有找到值返回 True，否则返回 False。 | x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。 |
7、身份运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| is | is 是判断两个标识符是不是引用自一个对象 | x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False |
| is not | is not 是判断两个标识符是不是引用自不同对象 | x is not y ， 类似 id(x) != id(y)。如果引用的不是同一个对象则返回结果 True，否则返回 False。 |
id()：获取对象内存地址。
is 与 == 区别：is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。
8、运算符优先级
| 运算符 | 描述 |
|---|---|
(expressions...),[expressions...], {key: value...}, {expressions...} |
圆括号的表达式 |
x[index], x[index:index], x(arguments...), x.attribute |
读取，切片，调用，属性引用 |
| await x | await 表达式 |
** |
乘方(指数) |
+x, -x, ~x |
正，负，按位非 NOT |
*, @, /, //, % |
乘，矩阵乘，除，整除，取余 |
+, - |
加和减 |
<<, >> |
移位 |
& |
按位与 AND |
^ |
按位异或 XOR |
| ` | ` |
in,not in, is,is not, <, <=, >, >=, !=, == |
比较运算，包括成员检测和标识号检测 |
not x |
逻辑非 NOT |
and |
逻辑与 AND |
or |
逻辑或 OR |
if -- else |
条件表达式 |
lambda |
lambda 表达式 |
:= |
赋值表达式 |
Pyhton3 已不支持 <> 运算符
六、分支
1、if
Python 中用 elif 代替了 else if，所以if语句的关键字为：if - elif - else
使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
在Python中没有switch – case语句。
2、while
在 Python 中没有 do…while 循环
使用 CTRL+C 来退出死循环
支持while - else语句，break跳出不执行else
3、for
for 循环用来遍历任何可迭代对象
break 语句用于跳出当前循环体
range(起始值, 结束值, 步长)：创建数字序列
4、pass
pass是空语句，是为了保持程序结构的完整性。
pass 不做任何事情，一般用做占位语句（空着会报错）
5、迭代器
1）迭代器概述
迭代：用来访问集合（字符串，列表或元组对象）元素
迭代器：一个可以记住遍历的位置的对象
迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束（只能往前不会后退）
迭代器的两个基本的方法：iter() 和 next()
list=[1,2,3,4]
it1 = iter(list) # 创建迭代器对象
print (next(it1)) # 输出迭代器的下一个元素
# 1
it2 = iter(list) # 创建迭代器对象
for x in it2:
print (x, end="")
# 1234
2）迭代器创建
把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__()
__iter__() 返回一个特殊的迭代器对象， 这个迭代器对象实现了 __next__() 并通过 StopIteration 异常标识迭代的完成
__next__() 会返回下一个迭代器对象
创建一个返回数字的迭代器，初始值为 1，逐步递增 1
class MyNumbers:
def __iter__(self):
self.a = 1
return self
def __next__(self):
x = self.a
self.a += 1
return x
myclass = MyNumbers()
myiter = iter(myclass)
print(next(myiter))
3）StopIteration
StopIteration 异常用于标识迭代的完成，防止出现死循环
import sys # 引入 sys 模块
list=[1,2,3,4]
it = iter(list) # 创建迭代器对象
while True:
try:
print (next(it))
except StopIteration:
sys.exit()
在__next__()方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代
class MyNumbers:
def __iter__(self):
self.a = 1
return self
def __next__(self):
if self.a <= 20:
x = self.a
self.a += 1
return x
else:
raise StopIteration
myclass = MyNumbers()
myiter = iter(myclass)
for x in myiter:
print(x)
6、生成器
生成器：使用了 yield 的函数
生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器
在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行
# 使用 yield 实现斐波那契数列
import sys
def fibonacci(n): # 生成器函数 - 斐波那契
a, b, counter = 0, 1, 0
while True:
if (counter > n):
return
yield a
a, b = b, a + b
counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成
while True:
try:
print (next(f), end=" ")
except StopIteration:
sys.exit()
七、函数
1、定义函数
def 函数名（参数列表）:
函数体
return [表达式] ：结束函数，选择性地返回一个值给调用方
不带表达式的 return 相当于返回 None
2、传参
1）值传递和引用传递
类型属于对象，对象有不同类型的区分，变量是没有类型的
- **不可变类型：**类似 C++ 的值传递，如整数、字符串、元组。
- **可变类型：**类似 C++ 的引用传递，如 列表、字典。
python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象
2）必需参数
必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样
3）关键字参数
关键字参数允许函数调用时参数的顺序与声明时不一致，解释器能够用参数名匹配参数值
def printinfo( name, age ):
print ("名字: ", name)
print ("年龄: ", age)
return
printinfo( age=50, name="wmh" )
4）默认参数
调用函数时，如果没有传递参数，则会使用默认参数
def printinfo( name, age = 35 ):
print ("名字: ", name)
print ("年龄: ", age)
return
printinfo( name="wmh" )
5）不定长参数
你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。
def functionname([formal_args,] *var_args_tuple ):
function_suite
return [expression]
星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数
def printinfo( arg1, *vartuple ):
print (arg1)
print (vartuple)
return
printinfo( 70, 60, 50 )
# 70
# (60, 50)
加了两个星号 ** 的参数会以字典的形式导入
def printinfo( arg1, **vardict ):
print ("输出: ")
print (arg1)
print (vardict)
return
printinfo(1, a=2,b=3)
# 1
# {'a': 2, 'b': 3}
参数中星号 * 可以单独出现
def f(a,b,*,c):
return a+b+c
f(1,2,3) # 报错
f(1,2,c=3) # 正常
3、匿名函数
使用 lambda 来创建匿名函数
lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数
虽然 lambda 函数看起来只能写一行，却不等同于 C 或 C++ 的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率
lambda [arg1 [,arg2,.....argn]]:expression
sum = lambda a,b: a + b
sum(1,2) # 3
4、强制位置参数
Python3.8 新增了一个函数形参语法 / 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式
def f(a, b, /, c, d, *, e, f):
print(a, b, c, d, e, f)
return
f(10, 20, 30, d=40, e=50, f=60) # 对
f(10, b=20, c=30, d=40, e=50, f=60) # 错：b 不能使用关键字参数的形式
f(10, 20, 30, 40, 50, f=60) # 错：e 必须使用关键字参数的形式