查缺补漏 知识点备忘

成成是我

2022.11.24
Python 有三种不同的数字类型，分别是：整数、浮点数和复数

我们通常数学意义上的小数在编程里叫浮点数

精确计算浮点数
>>> import decimal
>>> a = decimal.Decimal('0.1')
>>> b = decimal.Decimal('0.2')
>>> print(a + b)
0.3

复数包含了一个实部和一个虚部
它们都是以浮点数的形式存放的，如果将一个复数赋值给一个变量 x，则可以通过 x.real 访问该复数的实部，x.imag 访问其虚部
>>> x = 1 + 2j
>>> x.real
1.0
>>> x.imag
2.0

设计一个小游戏
""" 用Python设计第一个游戏 """
   
counts = 3
   
while counts > 0:
    temp = input("不妨猜一下小甲鱼现在心里想的是哪个数字：")
    guess = int(temp)
    if guess == 8:
        print("你是小甲鱼心里的蛔虫嘛？！")
        print("哼，猜中了也没奖励！")
    else:
        if guess < 8:
            print("小啦~")
        else:
            print("大啦~")
    counts = counts - 1
    break

避免反斜杠（\）被当作转义字符解析
Python 除法的运算结果是以浮点数的形式存储的
/ 浮点数结果，//整数结果

使用三引号字符串来引用多行文本  “““   文本   ”””

并不是所有的字符串都能够转换为整数，比如 int("FishC") 你让人怎么转？对吧，还是要讲个道理的……

获取一个随机整数
random.randint(1, 10)
提供相同的种子可以使random重现

重现伪随机数
x = random.getstate()
random.randint(1, 10)

双斜杠（//）表示一种特殊的除法 —— 地板除。
地板除原理是取比目标结果小的最大整数

百分号（%）用于求两数相除的余数，如果能够整除，则余数为 0

地板除的结果乘以除数 + 余数 = 被除数
x == (x // y) * y + (x % y)

divmod() 函数
Python 有个内置函数叫 divmod()，它的作用就是同时求出两参数地板除的结果和余数
>>> divmod(3, 2)
(1, 1)
>>> divmod(-3, 2)
(-2, 1)

abs() 函数的作用是返回指定数值的绝对值

int() 函数是将指定的值转换成整数
不过如果参数是一个浮点数，那么就要注意了，因为它得到的将是一个截掉小数的整数
注意：它是直接截取整数部分，扔掉小数部分，而不是四舍五入
同样的道理，float() 和 complex() 函数是将指定的值转换成浮点数和复数

通常情况下，pow() 函数和幂运算符（**）这两个实现的效果是等价的
>>> pow(2, 3)
8
>>> 2 ** 3
8
>>> pow(2, -3)
0.125
>>> 2 ** -3
0.125

不过，pow() 函数还留有一手，它支持第 3 个参数。
如果传入第 3 个参数，那么会将幂运算的结果和第 3 个参数进行取余数运算
>>> pow(2, 3, 5)
3

Python支持链式比较

布尔类型的值只有两个：True 或者 False
使用 bool() 函数可以直接给出 True 或者 False 的结果
在 Python 中，True 和 False 两个关键字是完全等值于 1 和 0 的

下面这些几乎就是结果为 False 的所有情况：
定义为 False 的对象：None 和 False
值为 0 的数字类型：0, 0.0, 0j, Decimal(0), Fraction(0, 1)
空的序列和集合：'', (), [], {}, set(), range(0)

对于 and 和 or 运算符，它的计算结果不一定是 True 或者 False。
这要看它的操作数是什么了，如果你给到操作数的是两个数值，那么它的运算结果也是数值

如果你给到操作数的是两个字符串，那么它的结果也是字符串
>>> "FishC" and "LOVE"
'LOVE'

Or 同假出后者，有真出真者，同真出前者
And 同真出后者，有假出假者，同假出前者

目前 Python 的字符串类型只支持加法拼接和乘法复制，不支持减法或者除法

Fraction(a, b) 表示分子为 a，分母为 b 的分数

Isdigit 是否由数字组成

成成是我

2022.11.25
短路逻辑
and 和 or 这两个运算符都是遵从短路逻辑的。
短路逻辑的核心思想就是：从左往右，只有当第一个操作数的值无法确定逻辑运算的结果时，才对第二个操作数进行求值
注意0的运算结果是false
当 True 参数运算时，将当作数字 1 来使用

链式比较
>>> 1 < 2 > 3 < 4 < 5
1 < 2 and 2 > 3 and 3 < 4 and 4 < 5

成成是我

2022.11.27
Python分支结构 5种if语句
第一种，if
第二种，if else
第三种，if elif
第四种，if elif else
第五种，条件成立时执行的语句 if 条件 else 条件不成立时执行的语句

Python 同一个代码块中的所有语句必须遵循同一缩进原则
Python 是通过缩进来检测代码块的，向右缩进相同距离的所有语句，都同属于一个代码块

国际惯例是使用 4 个空格来表示一个缩进层级
默认情况下，print() 函数输出的多个对象之间是使用空格分隔，但我们可以使用 sep='' 来 “避免” 这种情况发生

成成是我

2022.11.28
对于任何非空字符串，真值测试结果均为 True

大多数 if - else 条件分支还可以使用 and - or 运算符组合的表达式来代替
if C:
    X
else:
    Y
转变为 and - or 来代替就是C and X or Y
因为 C and X or Y 的含义就是 “如果 C 为真，就返回 X；如果 C 为假，就跳过 X，返回 Y”。
不过这里需要注意的一点是：上面的 X 必须是一个能得到布尔真值的表达式，否则就会出问题（像 a < b and print("A") or print("B") 这个表达式就不行了，因为 print 函数的返回值是 None）

成成是我

2022.12.1
continue 语句
continue 语句也会跳出循环体，但是，它只是跳出本一轮循环，它还会回到循环体的条件判断位置，然后继续下一轮循环（如果条件还满足的话）。
注意它和 break 语句两者的区别：
continue 语句是跳出本次循环，回到循环的开头
break 语句则是直接跳出循环体，继续执行后面的语句

while-else 可以非常容易地检测到循环的退出情况。
注意：这里的else对应的while 而非if ，while else 跟if else 是两个不用的语句
else语句结合break语句，跳出循环时，如果condition条件依旧为True，else语句则不会被执行

循环的嵌套，内层循环执行完，再执行外层循环
对于嵌套循环来说，无论是 break 语句还是 continue 语句，它们只能作用于一层循环体

招财纳宝

感谢，很有用

成成是我

2022.12.2
for 循环
for 变量 in 可迭代对象:
    某条语句或某个代码块

range()
range() 会帮你生成一个数字序列，它的用法有以下三种：
range(stop) - 将生成一个从 0 开始，到 stop（不包含）的整数数列
range(start, stop) - 将生成一个从 start 开始，到 stop（不包含）的整数数列
range(start, stop, step) - 将生成一个从 start 开始，到 stop（不包含）结束，步进跨度为 step 的整数数列
注意：无论你使用哪一种，它的参数都只能是整数。

for 循环和 while 循环一样，都是可以支持嵌套的，同样它也可以搭配 break 和 continue 语句。

len() 函数的参数需要是一个序列或者集合（才能够获取长度嘛），整数是不能作为其参数的。

成成是我

2022.12.4
列表切片
将原先的单个索引值改成一个范围即可实现切片：
>>> rhyme[0:3]
[1, 2, 3]
>>> rhyme[3:6]
[4, 5, '上山打老虎']
>>> rhyme[:3]
[1, 2, 3]
>>> rhyme[3:]
[4, 5, '上山打老虎']
>>> rhyme[:]
[1, 2, 3, 4, 5, '上山打老虎']
>>> rhyme[0:6:2]
[1, 3, 5]
>>> rhyme[::2]
[1, 3, 5]
>>> rhyme[::-2]
['上山打老虎', 4, 2]
>>> rhyme[::-1]
['上山打老虎', 5, 4, 3, 2, 1]

成成是我

2022.12.5
改，
>>> heros[3:] = ["武松", "林冲", "李逵"]
>>> heros
['蜘蛛侠', '绿巨人', '黑寡妇', '武松', '林冲', '李逵']
step one:将赋值号（=）左边指定的内容删除
step two:将包含在赋值号（=）右边的课迭代对象中的片段插入左边被删除的位置
其实它是分上面两个步骤来实现的

copy()，用于拷贝一个列表
>>> nums_copy1 = nums.copy()
>>> nums_copy1
[3, 1, 9, 6, 8, 3, 5, 3]
>>> nums_copy2 = nums[:]
>>> nums_copy2
[3, 1, 9, 6, 8, 3, 5, 3]
上面这两种拷贝方法实现的效果是等同的。
这两种拷贝的方法，在 Python 中都称为浅拷贝。

成成是我

2022.12.6
列表的加法，其实也是拼接，所以要求加号（+）两边都应该是列表
列表的乘法，则是重复列表内部的所有元素若干次

python对于不同对象的存储机制是不一样的

== 运算符用于判断两个变量的值是否相等，而 is 运算符用于判断两个变量是否为同一对象

出于性能优化方面的考虑，Python 在内部为 -5~256 范围内的整数维护了一个数组，起到缓存的作用。
这样，每次你试图创建一个 -5~256 范围内的整数时，Python 都会从这个数组中返回相对应的引用，而不是重新开辟一块新的内存空间存放。
eg:
>>> a = 250
>>> b = 250
>>> a is b
返回 True
但是，如果超过了 -5~256 这个范围（大家可以自己动手测试一下），比如 1000，那么 Python 会为两个 1000 单独开辟两块不同的内存区域，因此 a is b 的结果为 False
>>> a = 1000
>>> b = 1000
>>> a is b
返回 False

变量不是盒子
在一些编程语言中，经常会有 “变量就是盒子” 这样的比喻，因为赋值操作就像是往盒子里面放东西。
但在 Python 中变量并不是一个盒子，当赋值运算发生的时候，Python 并不是将数据放进变量里面，而是将变量与数据进行挂钩，这个行为我们称之为引用

浅拷贝和深拷贝
浅拷贝：利用列表的 copy() 方法或者切片来实现
深拷贝：利用 copy 模块的 deepcopy() 函数来实现
浅拷贝可以用于处理一维列表，对于嵌套列表的拷贝，只能拷贝第一层数据，其余仅拷贝其引用，深拷贝可以用于处理多维列表

成成是我

2022.12.7
列表推导式
基本语法
[expression for target in iterable]

ord这个内置函数的作用：将单个字符串转换为对应的编码
Column 列，row 行

将矩阵第 2 列的元素给提取出来：
>>> matrix = [[1, 2, 3],
...           [4, 5, 6],
...           [7, 8, 9]]
>>> col2 = [row[1] for row in matrix]
>>> col2
[2, 5, 8]

获取矩阵主对角线上的元素（就是从左上角到右下角这条对角线上的元素）：
>>> diag = [matrix[i][i] for i in range(len(matrix))]
>>> diag
[1, 5, 9]

成成是我

2022.12.8
带条件筛选功能的列表推导式：
[expression for target in iterable if condition1]

多层嵌套的列表推导式：
[expression for target1 in iterable1
            for target2 in iterable2
            ...
            for targetN in iterableN]

每层嵌套还可以附带一个用于条件筛选的 if 分句：先执行for 语句，然后是if 语句，最后才执行左边表达式
嵌套列表对应嵌套循环，外层循环在前。内层循环在后
[expression for target1 in iterable1 if condition1
            for target2 in iterable2 if condition2
            ...
            for targetN in iterableN if conditionN]

程序设计开发中有一个非常重要原则：KISS。
KISS 原则的全称是 Keep It Simple and Stupid，也就是 “Python之禅” 里面提到的 “简洁胜于复杂”，不要把代码搞得晦涩难懂

元组和列表的不同点：

• 列表是使用方括号，元组则是圆括号（也可以不带圆括号）
• 列表中的元素可以被修改，而元组不行，不能修改元组的内容，但是可以通过切片语法生成了一个新的元组，如果我们非要修改一个元组，创建一个新的元组，并赋值给同个变量
• 列表中涉及到修改元素的方法元组均不支持（只支持查，增删改都不可以）
• 列表的推导式叫列表推导式，元组的 “推导式” 叫生成器表达式，元组推导式不存在
  

元组和列表的共同点：

• 都可以通过下标获取元素
• 都支持切片操作
• 都支持 count() 方法和 index() 方法
• 都支持拼接（+）和重复（*）运算符
• 都支持嵌套
• 都支持迭代
  

元组可以存放多种类型的数据，而字符串只能够存放字符类型

当元组只有一个元素的时候：加逗号 “”，“”
>>> x = 520,
>>> x
(520,)
>>> type(x)
<class 'tuple'>

元组的打包和解包：赋值号左侧的变量名数量，必须跟右侧序列的元素数量一致，否则通常都会报错。

_   匿名变量

多重赋值：

>>> a, b, *c = "FishC"

>>> a

'F'

>>> c

['s', 'h', 'C']

元组中的元素虽然是不可变的，但如果元组中的元素是指向一个可变的列表，那么我们依然是可以修改列表中的内容的。（元组中包换列表项，可修改元组值，即间接修改列表）

timeit函数 获取代码的执行时间

成成是我

2022.12.9
字符串各种方法大集合
大小写字母换来换去：capitalize()、casefold()、title()、swapcase()、upper()、lower()
注意casefold() 和lower()的区别，lower()只能处理英文字母，而caseflid()除了可以处理英文之外，还可以处理更多其他语言的字符

左中右对齐：center(width, fillchar=' ')、ljust(width, fillchar=' ')、rjust(width, fillchar=' ')、zfill(width)
这种方法都要求有一个width 参数，用来指定字符串的宽度

查找：count(sub[, start[, end]])、find(sub[, start[, end]])、rfind(sub[, start[, end]])、index(sub[, start[, end]])、rindex(sub[, start[, end]])
count(sub[, start[, end]]) 方法是返回 sub 在字符串中不重叠的出现次数。什么叫“不重叠”呢？就是一个元素不能被重复匹配。
字符串的 find() 方法和 index() 方法同样是返回查找对象的下标值，两个方法的区别主要在于当找不到查找对象时，返回的结果不一样。find() 方法返回 -1 表示；index() 方法抛出异常（ValueError: substring not found）
rindex() 和 rfind() 方法都是从右往左搜索，从左往右匹配。

替换：expandtabs([tabsize=8])、replace(old, new, count=-1)、translate(table)
首先是 expandtabs([tabsize=8]) 方法，它的作用是使用空格替换制表符并返回新的字符串。使用 expandtabs(tabsize=4) 方法，就可以将字符串中的 Tab 转换成空格，其中 tabsize 参数指定的是一个 Tab 使用多少个空格来代替
replace(old, new, count=-1) 方法返回一个将所有 old 参数指定的子字符串替换为 new 的新字符串。另外，还有一个 count 参数是指定替换的次数，默认值 -1 表示替换全部
translate(table) 方法，这个是返回一个根据 table 参数（用于指定一个转换规则的表格）转换后的新字符串。
需要使用 str.maketrans(x[, y[, z]]) 方法制定一个包含转换规则的表格。
str.maketrans() 方法要求两个构成映射关系的参数必须是等长的。另外，也必须是参数的类型也必须是字符串才行哦。
这个 str.maketrans() 方法还支持第三个参数，表示将其指定的字符串忽略

成成是我

2022.12.10
判断
startswith(prefix[, start[, end]])、endswith(suffix[, start[, end]])、istitle()、isupper()、islower()、isalpha()、isascii()、isspace()、isprintable()、isdecimal()、isdigit()、isnumeric()、isalnum()、isidentifier()
[b]这 14 个方法都是应对各种情况的判断，所以返回的都是一个布尔类型的值 —— 要么是 True，要么是 False。[/b]
startswith(prefix[, start[, end]]) 方法用于判断 prefix 参数指定的子字符串是否出现在字符串的起始位置
对应的，endswith(suffix[, start[, end]]) 方法则相反，用于判断 suffix 参数指定的子字符串是否出现在字符串的结束位置
这两个方法都有 start 和 end 两个可选的参数，用于指定匹配的开始和结束位置

变量名的规则：字母，数字，下划线组成，且第一个只能以字母或下划线开头，同时不能与关键字同名
prefix 和 suffix 参数，支持以元组的形式传入多个待匹配的字符串

istitle()：判断一个字符串中的所有单词是否都是以大写字母开头，其余字母均为小写
isupper()：判断一个字符串中所有字母是否都是大写
islower()：判断是否所有字母都是小写
isascii() ：判断一个字符串中是否只是由 ASCII 字符组成
isspace()：判断是否为一个空白字符串
isprintable():判断一个字符串中是否所有字符都是可打印的
isdecimal()、isdigit() 和 isnumeric() 三个方法都是用来判断数字的
isalnum() 方法则是集大成者，只要 isalpha()、isdecimal()、isdigit() 或者 isnumeric() 任意一个方法返回 True，结果都为 True。
isidentifier():判断该字符串是否一个合法的 Python 标识符
keyword 模块的 iskeyword() :判断一个字符串是否为 Python 的保留标识符，就是像 “if”、“for”、“while” 这些关键字
isalpha() 方法判断的 “字母” 是 Unicode 编码中定义的字母，不止是 26 个英文字母

判断 s 字符串中，是否所有字符都是英文字母
x.isalpha() and x.isascii()

由于对 Unicode 编码的支持，Python 是可以使用中文作为合法标识符的

hornwong

成成是我

2022.12.12
截取
lstrip(chars=None)、rstrip(chars=None)、strip(chars=None)、removeprefix(prefix)、removesuffix(suffix)
这三个方法都有一个 chars=None 的参数，None 在 Python 中表示没有，意思就是去除的是空白
踢掉一个具体的子字符串
removeprefix(prefix) 和 removesuffix(suffix)
removeprefix(prefix) 和 removesuffix(suffix) 这两个方法是以字符串为单位的

拆分
partition(sep)、rpartition(sep)、split(sep=None, maxsplit=-1)、rsplit(sep=None, maxsplit=-1)、splitlines(keepends=False)
注意：partition(sep) 和 rpartition(sep) ，它俩如果找不到分隔符，返回的仍然是一个 3 元组，只不过将原字符串放在第一个元素，其它两个元素为空字符串
相比起 split("\n") 来说，splitlines() 方法显得更加“智能”，它可以自动判断不同系统的换行符（比如 Linux 系统下的换行符是 "\n"；Mac 是 "\r"；而 Windows 则是 "\r\n"）。另外，splitlines() 方法还可以通过 keepends 参数来指定在结果中保留换行字符。

拼接
join(iterable) 方法
字符串是作为分隔符使用，然后 iterable 参数指定插入的子字符串

格式化字符串
使用一对花括号（{}）来表示替换字段，真正的内容被放在了 format() 方法的参数中，注意，同一个索引值是可以被多次引用的，用关键字进行索引的话，它必须放在位置索引的后面，否则就会报错
在花括号外边套一层花括号，外层是对内层起到“注释“的作用。所谓”注释“，就是剥夺了花括号的特殊功能，使它变会一个正经的字符串
注：每 2 层进行一次注释
对齐选项（[align]）

                               
登录/注册后可看大图

填充选项（[fill]）这种用法只对数字有效

成成是我

2022.12.13
符号（[sign]）选项
符号（[sign]）选项仅对数字类型有效，可以使用下面3个值：

                               
登录/注册后可看大图

精度（[.precision]）选项
精度（[.precision]）选项是一个十进制整数，对于不同类型的参数，它的效果是不一样的：

• 对于以 'f' 或 'F' 格式化的浮点数值来说，是限定小数点后显示多少个数位
• 对于以 'g' 或 'G' 格式化的浮点数值来说，是限定小数点前后共显示多少个数位
• 对于非数字类型来说，限定最大字段的大小（换句话说就是要使用多少个来自字段内容的字符）
• 对于整数来说，则不允许使用该选项值（整数不允许被设置“精度”选项，如果非要这么做，可以加一个 'f'（即 f"{520:.2f}"），表示将参数以小数的形式输出）
  

类型（[type]）选项

以下类型适用于整数：

                               
登录/注册后可看大图

以下类型值适用于浮点数、复数和整数（自动转换为等值的浮点数）如下：

                               
登录/注册后可看大图

Python 事实上支持通过关键参数来设置选项的值，同时设置多个选项也是没问题的

f-字符串

>>> "{:.2f}".format(3.1415)
>>> f"{3.1415:.2f}"
'3.14'

用 f-string，最需要注意的是兼容性，在 Python3.6 之前，f-string 是不被支持的

成成是我

2022.12.14
列表、元组、字符串的共同点
都可以通过索引获取每一个元素第一个元素的索引值都是 0都可以通过切片的方法获得一个范围内的元素的集合有很多共同的运算符

根据是否能被修改这一特性，可以将序列分为可变序列和不可变序列：比如列表就是可变序列，而元组和字符串则是不可变序列

增量赋值：
在python中每个对象都有3个属性：唯一标识，类型，值，唯一标识创建时就有，不能修改且无重复

id()，返回指定对象的唯一标识值，可变序列增量赋值后，id(可变序列)值不可变，不可变序列增量赋值后，id(不可变序列)值改变

虽然可变序列和不可变序列看上去都是 “可变” 的，但实现原理却是天壤之别：可变序列是在原位置修改 “扩容”，而不可变序列则是将内容 “扩容” 后再放到一个新的位置上去。

是（is）和不是（is not）被称之为同一性运算符，用于检测两个对象之间的 id 值是否相等

del 语句用于删除一个或多个指定的对象，dei()语句删除可变现序列中的指定元素，用切片也可以（有步长要求则不行），实现y[1:4] =[]等价于del y[1:4]


list()、tuple() 和 str() 这三个 BIF 函数主要是实现列表、元组和字符串的转换。

通常对于 32 位平台来说，这个最大的数值是 2**31 - 1；而对于 64 位平台来说，这个最大的数值是 2**63 - 1。

start 参数，用于指定求和计算的起始数值
比如：

>>> sum(s, start=100)
115

sorted() 函数将重新排序 iterable 参数中的元素，并将结果返回一个新的列表，按 Unicode 编码的从小到大进行排序……数字在字母之前，大写字母在小写字母之前，reversed() 函数将返回参数的反向迭代器。可以使用 list() 函数将其转换为列表。reversed() 函数也同样支持任何形式的可迭代对象。
sort()只能用在列表排序上，并改变原列表，sorted(）可用在所有可迭代对象排序上，并创建新列表


列表的 sort() 方法和 sorted() 函数异同点:
相同点：来自：https://fishc.com.cn
n_2ZgPVUk)"v@h=Hl-~?Irb

• 默认都是从小到大正向排序来自：https://fishc.com.cn
• 都支持 key 和 reverse 两个参数AR}BKf
• 排序的结果可都是列表来自：https://fishc.com.cn
• 都是稳定排序（就是说如果存在多个相同的元素，经过排序之后，这些元素的相对次序保持不变）s[lgjh#7
  

不同点：Powered by https://fishc.com.cn
fl"tAxX'<mv%(BjLZ,?N}&sS6|I>.y

• 一个是列表的方法；一个是独立的函数版权属于：https://fishc.com.cn
• 一个叫 sort()；一个叫 sorted()S#EolY
• 列表的 sort() 方法是原地排序；sorted() 函数是讲排序后的结果返回为一个新的列表P0>#1(
• 列表的 sort() 方法只能对列表的元素进行排序；sorted() 函数则可以对任何形式的可迭代对象进行排序'[s#"(
• 列表的 sort() 方法返回值是 None；sorted() 函数返回一个新列表
  

qingqinglove555

成成是我

2022.12.15
all() 函数是判断可迭代对象中是否所有元素的值都为真，any() 函数则是判断可迭代对象中是否存在某个元素的值为真。


enumerate() 函数用于返回一个枚举对象，它的功能就是将可迭代对象中的每个元素及从 0 开始的序号共同构成一个二元组的列表，可加入start参数，enumerate() 函数生成的是一个 enumerate 枚举对象，而非迭代器，所以不能使用下标对其进行随机访问

>>> seasons = ["Spring", "Summer", "Fall", "Winter"]
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]

zip() 函数（拉链）用于创建一个聚合多个可迭代对象的迭代器，做法是将作为参数传入的每个可迭代对象的每个元素依次组合成元组，即第 i 个元组包含来自每个参数的第 i 个元素。
如果传入的可迭代对象长度不一致，那么将会以最短的那个为准，如果那些值对于我们来说是有意义的，我们可以使用 itertools 模块的 zip_longest() 函数来代替

>>> import itertools
>>> zipped = itertools.zip_longest(x, y, z)
>>> list(zipped)
[(1, 4, 'F'), (2, 5, 'i'), (3, 6, 's'), (<font color="#ff0000">None, None</font>, 'h'), (<font color="#ff0000">None, None</font>, 'C')]

map() 函数会根据提供的函数对指定的可迭代对象的每个元素进行运算，并将返回运算结果的迭代器，如果指定的函数需要两个参数，后面跟着的可迭代对象的数量也应该是两个，如果可迭代对象的长度不一致，那么 Python 采取的做法跟 zip() 函数一样，都是在最短的可迭代对象终止时结束

与 map() 函数类似，filter() 函数也是需要传入一个函数作为参数，不过 filter() 函数是根据提供的函数，对指定的可迭代对象的每个元素进行运算，并将运算结果为真的元素，以迭代器的形式返回，如果提供的函数是 None，则会假设它是一个 “鉴真” 函数，即可迭代对象中所有值为假的元素会被移除

可迭代对象和迭代器：一个迭代器肯定是一个可迭代对象，最大的区别是：可迭代对象咱们可以对其进行重复的操作，而迭代器则是一次性的！，通过 type() 函数，可以观察到这个区别

将可迭代对象转换为迭代器：iter() 函数


next() 函数，它是专门针对迭代器的，它的作用就是逐个将迭代器中的元素提取出来（返回迭代器下一个项目，一次只能访问一个），添加第二个字符串参数，异常时弹出

异常可控，错误不可控