bool : 布尔型(True,False)
int : 整型(整数)
float : 浮点型(小数)
complex : 复数
int(x[, base=10])
返回一个基于数字或字符串 x 构造的整数对象，无参数时返回 0。对于浮点数，它将向零舍入取整。如果 x 不是数字，或者有 base 参数，x 必须是字符串、bytes、表示进制为 base 的整数字面值的 bytearray 实例。x 前可以有“ +” 或“ - ”。
默认的 base 为 10 ，允许的进制有 0、2-36。一个进制为 n 的数字包含 0 到 n-1 的数，其中 a 到 z （或 A 到 Z ）表示 10 到 35。2、8、16 进制的数字可以在代码中用 0b/0B 、 0o/0O 、 0x/0X 前缀来表示。

print(int(3.14))                # 3，x 为浮点数时返回其整数部分
print(int(-3.94))               # -3，x 为浮点数时返回其整数部分
print(int())                    # x 缺省时返回整数 0
print(int('256',base = 10))     # 256， x 为整数的字符串形式时，返回其数值转为base进制的整数
print(int('-256'))              # -256， base参数省略时，缺省按十进制转换，前面可以有正负号
print(int('10111111',base = 2)) # 191，按二进制转换，返回对应的十进制数
print(int('0B10111111',2))      # 191，二进制可用0B表示
print(int('FE',16))             # 254，'base =' 也可以略去不写
print(int('0XFE',16))           # 254，十六进制可用0X表示

float([x])
返回从数字或字符串 x 生成的浮点数。如果实参是整数或浮点数，则返回具有相同值的浮点数。如果实参在 Python 浮点精度范围外，则会触发 OverflowError。

print(float())             # 0.0，无参数 x 时返回浮点数 0.0
print(float(+ 3.14))       # 3.14，浮点数前后可以有正负号，多余的空格没有影响
print(float(-  3.14  ))    # -3.14，前后多余的空格没有影响
print(float('-3.14  '))    # -3.14，字符串前面可以有正负号，前后可以有空白字符
print(float('\t3.14\n'))   # 3.14，函数可以自动去除字符串开头和结尾的空白字符，包括空格和'\t'、'\n'等
print(float(pow(2,10000))) # 浮点数有大小限制，超出表示范围后会触发OverflowError
# OverflowError: int too large to convert to float

如果没有实参，则返回 0.0 。如果 x 是字符串，必须是包含十进制数字的字符串，字符串前面可以有符号，前后可以有空白字符。可选的符号有 ‘+’ 和 ‘-‘ ； ‘+’ 对创建的值没有影响。确切地说，除去首尾的空格后，输入必须遵循以下语法：

sign           ::=  "+" | "-"
numeric_value  ::=  floatnumber | infinity | nan
numeric_string ::=  [sign] numeric_value

complex([real[, imag]])
返回值为 real + imag*1j 的复数，或将字符串或数字转换为复数，无参数时返回 0j，参数可以是复数。如果第一个参数是字符串，则它被解释为一个复数。

print(complex())            # 0j，无参数时返回复数0j
print(complex(1))           # (1+0j)
print(complex(1, 2.4))      # (1+2.4j)
print(complex(3 + 4j, 2.6)) # (3+6.6j)，参数可为复数

bool([x])
返回布尔值，True 或 False。x 用标准的真值测试过程进行转换。如果 x 为 False 或省略，则返回 False；否则返回 True。 bool 类是 int 的子类，它唯一的实例就是 False 和 True

print(bool(5))         # True
print(bool('hello'))   # True
print(bool(0))         # False
print(bool(''))        # False
print(bool([]))        # False
print(bool({}))        # False
print(bool(set()))     # False

2. 进制转换(3)

bin() 将给的参数转换成二进制
otc() 将给的参数转换成八进制
hex() 将给的参数转换成十六进制
```
print(bin(100))  # 二进制:0b1100100
print(hex(100))  # 十六进制:0x64
print(oct(100))  # 八进制:0o144
```
bin(x)
将一个整数转变为一个前缀为“0b”的二进制字符串。

print(bin(3))     # '0b11'
print(bin(-10))   # '-0b1010'

oct(x)
将一个整数转变为一个前缀为“0o”的八进制字符串。

print(oct(8))          # '0o10'
print(oct(-56))        # '-0o70'

如果要将整数转换为八进制字符串，并可选择有无“0o”前缀，则可以使用如下方法：

print('%#o' % 10, '%o' % 10)               # '0o12', '12'
print(format(10, '#o'), format(10, 'o'))   # '0o12', '12'
print(f'{10:#o}', f'{10:o}')               # '0o12', '12'

hex(x)
将整数转换为以“0x”为前缀的小写十六进制字符串。

print(hex(255))    # '0xff'
print(hex(-42))    # '-0x2a'

print('%#x' % 255, '%x' % 255, '%X' % 255)                    # '0xff', 'ff', 'FF'
print(format(255, '#x'), format(255, 'x'), format(255, 'X'))  # '0xff', 'ff', 'FF'
print(f'{255:#x}', f'{255:x}', f'{255:X}')                    # '0xff', 'ff', 'FF'

3. 数学运算(7)

abs() 返回绝对值
divmode() 返回商和余数
round() 四舍五入
pow(a, b) 求a的b次幂, 如果有三个参数. 则求完次幂后对第三个数取余
sum() 求和
min() 求最小值
max() 求最大值

abs(x)
返回一个数的绝对值。参数可以是一个整数或浮点数。如果参数是一个复数，则返回它的模。

print(abs(-10))     # 10
print(abs(3 + 4j))  # 5.0

divmod(a, b)
它将两个（非复数）数字作为实参，并在执行整数除法时返回一对商和余数。对于混合操作数类型，适用双目算术运算符的规则。对于整数，结果和 (a // b, a % b) 一致。对于浮点数，结果是 (q, a % b) ，q 通常是 math.floor(a / b) ，但可能会比 1 小。在任何情况下， q * b + a % b 和 a 基本相等；如果 a % b 非零，它的符号和 b 一样，并且 0 <= abs(a % b) < abs(b) 。

print(divmod(10, 3))   # (3, 1)
print(divmod(10.5, 3)) # (3.0, 1.5)
print(divmod(-10.5, 3)) # (-4.0, 1.5)
print(divmod(10.5, -3)) # (-4.0, -1.5)

pow(base, exp[, mod])
返回 base 的 exp 次幂，参数必须具有数值类型。两参数形式 pow(base, exp) 等价于乘方运算符: baseexp。所有操作数都是整数时允许第三个操作数 mod 存在，返回 base 的 exp 次幂对 mod 取余，这种操作比 pow(base, exp) % mod 更高效。
对于混用的操作数类型，则将应用双目算术运算符的类型强制转换规则。对于 int 操作数，结果具有与操作数相同的类型（强制转换后），除非第二个参数为负值；在这种情况下，所有参数将被转换为浮点数并输出浮点数结果。例如，102 返回 100，但 10**-2 返回 0.01。

print(pow(2,10))       # 1024，第一个操作数是整数第二操作数为非负整数时结果为整数
print(pow(-2,9))       # -512，一个操作数是整数第二操作数为非负整数时结果为整数
print(pow(2,-2))       # 0.25，第一个操作数是整数，当第二个操作数为负数时结果为浮点数
print(pow(1,-2))       # 1.0
print(pow(2,0.5))      # 1.4142135623730951，操作数有浮点数时结果为浮点数
print(pow(2.5,10))     # 9536.7431640625
print(pow(2,10.5))     # 1448.1546878700494
print(pow(2,10,97))    # 54，操作数都是正整数时结果为整数，只有所有操作作数都是整数才允许有第三个操作数，且mod不为0
print(pow(2,10.5,97))  # TypeError: pow() 3rd argument not allowed unless all arguments are integers

round(number[, ndigits])
返回 number 舍入到小数点后 ndigits 位精度的值。如果 ndigits 被省略或为 None，则返回最接近输入值的整数。
规则：
四舍六入五考虑，五后非零就进一，五后皆零看奇偶，五前为偶应舍去，五前为奇要进一。

print(round(3.49))        # 3，四合六入，无第二个参数时返回最接近的整数
print(round(3.60))        # 4，四合六入，无第二个参数时返回最接近的整数
print(round(3.1159,3))    # 3.116，有第二个参数时保留相应的当数位数
print(round(3.10005,3))   # 3.1，取舍用使用该数的最短表示，3.100 == 3.1
print(round(3.115001,2))  # 3.12，取舍位为5时，5后有非0数字则进位
print(round(3.115000,2))  # 3.12，取舍位为5时，5后为0时，按使前一位数字为偶数的规则决定是否进位
print(round(3.125000,2))  # 3.12，取舍位为5时，5后为0时，按使前一位数字为偶数的规则决定是否进位

max(arg1, arg2, args[, key])
max(iterable, [, key, default])
参数为多个对象时返回值最大的一个数据对象；参数为一个非空的可迭代对象时返回其中最大的元素。
key和default 是可选参数，只能用关键字。key 指定排序函数用的参数。default 是当可迭代对象为空时返回的值。如果可迭代对象为空，并且没有给 default ，则会触发 ValueError。

print(max(89,-78,56,48,65,-99))            # 89,返回多个数据中最大值
print(max(89,-78,56,48,65,-99,key = abs))  # -99，按各数据的绝对值进行比较，返回绝对值最大的数
ls = ['Tom','jerry','Zena','Emma','zola']
print(max(ls))                             # zola，字符串依次比较各字符的Unicode编码值
print(max(ls,key = len))                   # jerry，按各元素的长度进行比较，返回最长的字符串

min(arg1, arg2, args[, key])
min(iterable, [, key, default])
参数为多个对象时返回值最小的一个数据对象；参数为一个非空的可迭代对象时返回其中最小大的元素。
key和default 是可选参数，只能用关键字。key 指定排序函数用的参数。default 是当可迭代对象为空时返回的值。如果可迭代对象为空，并且没有给 default ，则会触发 ValueError。

print(min(89,-78,56,48,65,-99))            # 89,返回多个数据中最大值
print(min(89,-78,56,48,65,-99,key = abs))  # -99，按各数据的绝对值进行比较，返回绝对值最大的数
ls = ['andy','jerry','Zena','Emma','zola']
print(min(ls))                             # Emma，字符串依次比较各字符的Unicode编码值
print(min(ls,key = str.upper))             # andy，按各元素的长度进行比较，返回最长的字符串

sum(iterable, start=0)
将 start 值与可迭代对象 iterable 的各项和加和，并返回总值。可迭代对象 iterable 中的元素通常均为数字， start 值不允许为字符串，其缺省值为 1。

print(sum([89,78,56,48,65,99]))             # 435
print(sum([89,78,56,48,65,99],start = 1))   # 436， 435 + 1
print(sum([89,78,56,48,65,99],start = 10))  # 445， 435 + 10
print(sum({89,78,56,48,65,99},100))         # 535， 435 + 100，'start = ' 可以省略

数据结构相关

1. 序列(13)

（1）列表和元组

list() 将一个可迭代对象转换成列表
tuple() 将一个可迭代对象转换成元组
```
print(list((1, 2, 3, 4, 5, 6)))   # [1, 2, 3, 4, 5, 6]
print(tuple([1, 2, 3, 4, 5, 6]))  # (1, 2, 3, 4, 5, 6)
```
list([iterable])
将可迭代对象转为列表类型，无参数时返回空列表。

print(list())          # 无参数时返回空列表， []
print(list('1234'))    # 字符串转为列表，['1', '2', '3', '4']
print(list({1,2,3,4})) # 集合转列表， [1, 2, 3, 4]
print(list(range(5)))  # range()转列表[0, 1, 2, 3, 4]

tuple([iterable])
将可迭代对象转为元组类型，无参数时返回空元组。

print(tuple())          # 无参数时返回空元组， ()
print(tuple('1234'))    # 字符串转为元组，('1', '2', '3', '4')
print(tuple({1,2,3,4})) # 集合转元组， (1, 2, 3, 4)
print(tuple(range(5)))  # range()转元组(0, 1, 2, 3, 4)

（2）相关内置函数

reversed() 将一个序列翻转, 返回翻转序列的迭代器

slice() 列表的切片

slice(stop)
slice(start, stop[, step])
a[start:stop:step] or a[start:stop, i]

lst = [1, 2, 3, 4, 5, 6, 7]
print(lst[1:3:1])           # [2,3]
print(lst[slice(1, 3, 1)])  # [2,3]

reversed(seq)
返回一个逆序排列的迭代器， seq 是要转换的序列，可以是str，tuple，list，range等。

print(list(reversed('wuhan')))                    # 字符串  ['n', 'a', 'h', 'u', 'w']
print(list(reversed(('w', 'u', 'h', 'a', 'n'))))  # 元组  ['n', 'a', 'h', 'u', 'w']
print(list(reversed(range(5, 10))))               # range  [9, 8, 7, 6, 5]
print(list(reversed([1, 2, 4, 3, 5])))            # 列表  [5, 3, 4, 2, 1]

（3）字符串

str() 将数据转化成字符串
str(object=’’)返回 object 的字符串类型表示，无参数时返回空字符串。
format(value[, format_spec])将 value 转换为“格式化后”的形式，格式由 format_spec 进行控制。
bytes() 返回一个新的“bytes”对象，这是一个不可变序列，包含范围为 0 <= x < 256 的整数。bytes 是 bytearray 的不可变版本——带有同样不改变序列的方法，支持同样的索引、切片操作。
bytearray() 返回一个新字节数组. 这个数字的元素是可变的, 并且每个元素的值得范围是[0,256)
ord() 对表示单个 Unicode 字符的字符串，返回代表它 Unicode 码点的整数。
chr() 返回 Unicode 码位为整数 i 的字符的字符串格式。例如，chr(97) 返回字符串 ‘a’，chr(8364) 返回字符串 ‘€’。这是 ord() 的逆函数。
ascii() 与 repr() 类似，返回一个字符串，表示对象的可打印形式，但在 repr() 返回的字符串中，非 ASCII 字符会用 \x、\u 和 \U 进行转义。
repr() 返回对象的可打印形式字符串。

print(str())          # 返回空字符串''
print(str(371))       # 返回字符串'371'，可应用文本序列方法进一步操作
print(str([1,2,3,4])) # 返回列表'[1, 2, 3, 4]'

format(value[, format_spec])

# 位置控制
s = "欢迎光临!"
print(format(s, "^20"))  #        欢迎光临!        ，居中
print(format(s, "<20"))  #                欢迎光临!，右对齐
print(format(s, ">20"))  # 欢迎光临!               ，左对齐

# 类型控制
print(format(16, 'b'))   # 二进制:10000
print(format(97, 'c'))  # 转换成unicode字符:a
print(format(16, 'd'))  # ⼗进制:16
print(format(16, 'o'))  # 八进制:20
print(format(16, 'x'))  # 十六进制(⼩写字母):10
print(format(16, 'X'))  # 十六进制(大写字母):10
print(format(16, 'n'))  # 和d⼀样:16
print(format(16))       # 和d⼀样:16

# 浮点数精度控制
print(format(12340000000, 'e'))       # 科学计数法. 默认保留6位小数:1.234000e+10
print(format(12340000000, '0.2e'))    # 科学计数法. 保留2位小数(小写):1.23e+10
print(format(12340000000, '0.2E'))    # 科学计数法. 保留2位小数(大写):1.23E+10
print(format(1.2340000000, 'f'))      # 小数点计数法. 保留6位小数:1.234000
print(format(1.2340000000, '0.5f'))   # 小数点计数法. 保留2位小数:1.23
print(format(1.2340000000, '0.10f'))  # 小数点计数法. 保留10位小数:1.2340000000
print(format(1.2340000000e+3, 'F'))   # 小数点计数法. :1234.000000
print(format(12340000000e+300, 'F'))  # 很大的时候输出INF
print(format(1.2340000000, '0.5g'))   # 小数点计数法. 保留5位小数的最短表示:1.234
print(format(1.2340000000, '0.10G'))  # 小数点计数法. 保留10位小数的最短表示:1.234

chr(i)
返回 Unicode 码值为整数 i 的字符的字符串格式，是 ord() 的逆函数。参数的合法范围是 0 到 1114111，超过这个范围，会触发 ValueError 异常。

print(chr(10084))     # ❤
print(chr(97))        # a
print(chr(9742))      # ☎

ord(c)
对表示单个 Unicode 字符的字符串，返回代表它 Unicode 码点的整数，是 chr() 的逆函数。

print(ord('❤'))      # 10084
print(ord('℃'))      # 8451
print(ord('Ω'))       # 937

bs = bytes("武汉理工大学", encoding="utf-8")
print(bs)
# b'\xe6\xad\xa6\xe6\xb1\x89\xe7\x90\x86\xe5\xb7\xa5\xe5\xa4\xa7\xe5\xad\xa6'

ret = bytearray("wuhan" ,encoding ='utf-8')
print(ret[0])    # 119
print(ret)       # bytearray(b'wuhan')
ret[0] = 65      # 把65的位置A赋值给ret[0]
print(str(ret))  # bytearray(b'Auhan')

print(ascii("@"))  #'@'
print(ascii('❤'))  # '\u2764'

s = f"面朝大海\n{2021}春暖\t花开"
print(s)
# 面朝大海
# 2021春暖    花开
print(repr(s))  
# '面朝大海\n2021春暖\t花开'

2. 数据集合(2)

字典：dict 创建一个字典
集合：set 创建一个集合

frozenset() 创建一个冻结的集合，冻结的集合不能进行添加和删除操作。
dict([mapping/iterable], **kwarg)
返回一个字典类型对象，无参数时返回空字典。

print(dict())         # 无参数时，返回空字典，{}
# 下面方法都可以返回字典 {'name': '张三', 'age': 19, 'gender': 'M'}
print(dict(name = '张三', age = 19, gender = 'M'))
print(dict([('name', '张三'), ('age', 19), ('gender', 'M')]))
print(dict(zip(('name','age','gender'), ('张三',19,'M'))))

set([iterable])
从可迭代对象获取元素返回一个集合类型对象，无参数时返回一个空集合。

print(set())                       # 无参数时返回空集合，set()
print(set('20200216'))             # 字符串转为集合,去除重复字符，{'1', '0', '6', '2'}
print(set((1, 2, 3, 4, 2, 6, 1)))  # 元组转集合，去除重复元素，{1, 2, 3, 4, 6}
print(set(range(5)))               # range()转集合{0, 1, 2, 3, 4}

3. 相关内置函数(11)

len() 返回一个对象中的元素的个数
sorted() 对可迭代对象进行排序操作 (lamda)

语法：sorted(Iterable, key=函数(排序规则), reverse=False)

Iterable: 可迭代对象
key: 排序规则(排序函数), 在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数. 根据函数运算的结果进行排序
reverse: 是否是倒叙. True: 倒叙, False: 正序
enumerate() 获取集合的枚举对象
all() 可迭代对象中全部是True, 结果才是True
any() 可迭代对象中有一个是True, 结果就是True
zip() 函数用于将可迭代的对象作为参数, 将对象中对应的元素打包成一个元组, 然后返回由这些元组组成的列表. 如果各个迭代器的元素个数不一致, 则返回列表长度与最短的对象相同
fiter() 过滤 (lamda)

语法：fiter(function. Iterable)
function: 用来筛选的函数. 在ﬁlter中会自动的把iterable中的元素传递给function. 然后根据function返回的True或者False来判断是否保留留此项数据 , Iterable: 可迭代对象

map() 会根据提供的函数对指定序列列做映射(lamda)

语法 : map(function, iterable)
可以对可迭代对象中的每一个元素进行映射. 分别去执行 function
reversed(seq)
返回一个逆序排列的迭代器， seq 是要转换的序列，可以是str，tuple，list，range等。

print(list(reversed('wuhan')))                    # 字符串  ['n', 'a', 'h', 'u', 'w']
print(list(reversed(('w', 'u', 'h', 'a', 'n'))))  # 元组  ['n', 'a', 'h', 'u', 'w']
print(list(reversed(range(5, 10))))               # range  [9, 8, 7, 6, 5]
print(list(reversed([1, 2, 4, 3, 5])))            # 列表  [5, 3, 4, 2, 1]

len(s)
返回对象的长度（元素个数）。参数是字符串和字节对象时返回值其中字符个数，包括空格和转义字符等所有类型的字符；参数是列表、元组或 range 等序列类型以及集合和字典类型时，返回值为其中元素的个数。

print(len('Hello world!\n'))   # 13
print(len([1,2,3,4,5]))        # 5
print(len(range(10)))          # 10

sorted(iterable, *, key=None, reverse=False)
根据 iterable 中的项返回一个新的已排序列表，key 和 reverse 都是可选的关键字参数，内置的 sorted() 确保是稳定的。
key 指定带有单个参数的函数，用于从 iterable 的每个元素中提取用于比较的键 (例如 key=str.lower)。默认值为 None，直接比较元素。
reverse 为一个布尔值，默认值为False ，升序排序。如果设为 True，则每个列表元素将按降序进行排序。

print(sorted([89,-78,56,48,65,-99]))                 # [-99, -78, 48, 56, 65, 89]
print(sorted([89,-78,56,48,65,-99],reverse = True))  # [89, 65, 56, 48, -78, -99]
print(sorted([89,-78,56,48,65,-99],key = abs))       # [48, 56, 65, -78, 89, -99]
print(sorted(['89','-78','56','48','65','-99']))     # ['-78', '-99', '48', '56', '65', '89'],按字符串排序
ls = ['Tom','Jerry','Zena','Geoffrey','Alanni']
print(sorted((ls)))         # ['Alanni', 'Geoffrey', 'Jerry', 'Tom', 'Zena']，字符串依次比较各字符的Unicode编码值
print(sorted(ls,key = len)) # ['Tom', 'Zena', 'Jerry', 'Alanni', 'Geoffrey']，按各元素的长度升序排序

all(iterable)
如果可迭代对象 iterable 的所有元素为真或迭代器为空，返回 True，否则返回False 。

print(all([]))              # 空的迭代器的值为 True
print(all([1,2,0,4]))       # 包含值为 0 的元素时值为False
print(all([1,2,'',4]))      # 包含空字符串的元素时值为False
print(all([1,2,'Yes',4]))   # 全部元素值都是True时结果为True

any(iterable)
如果可迭代对象 iterable 的任一元素为真则返回 True。如果迭代器为空，返回 False。

print(any([]))              # 空的迭代器的值为 False
print(any([1,2,0,4]))       # 包含值不为 0 的元素时结果为True
print(any([0.0,0,'',[]]))   # 全部元素值都是False时结果为False

filter(function, iterable)
用函数 function 返回可迭代对象 iterable 中所有值为 True 的元素，构建一个新的迭代器。iterable 可以是一个序列、一个支持迭代的容器或一个迭代器。如果函数 function 是 None ，则会假设它是一个身份函数，即 iterable 中所有返回假的元素会被移除。
请注意， filter(function, iterable) 相当于一个生成器表达式，当 function 不是 None 的时候为 (item for item in iterable if function(item))；function 是 None 的时候为 (item for item in iterable if item) 。

score = {'xiaobai':50,'xiaohei':30,'xiaolan':80,'xiaojun':100,'xiaoming':60}
result=filter(lambda score:score>60,score.values())
print(list(result))                # [80, 100] 返回及格的成绩

name = ["vasp", "castep", "turing"]
filter_name = list(filter(lambda x: len(x) < 5, name))
print(filter_name)                 # ['vasp'] 返回长度小于5的字符串

result=filter(lambda x:x % 7 ==0 and x % 13 ==0,range(1,1000))
print(list(result)) 
# [91, 182, 273, 364, 455, 546, 637, 728, 819, 910] 返回1000以内能被7和13同时整除的数

map(function, iterable, …)
返回一个将函数 function 应用于迭代器 iterable 中每一项并输出其结果的迭代器，可迭代输出其中数据或用 list 转为列表。

ls = ['89','65','58','100']
print(map(int,ls))        # <map object at 0x00000279F1005520>
print(*map(int,ls))       # 89 65 58 100
print(list(map(int,ls)))  # [89, 65, 58, 100]
ls = list(map(int,input().split()))  # 99 65 78，常用于将输入转为数值类型
print(ls)                            # [99, 65, 78]

如果传入了额外的 iterable 参数，function 必须接受相同个数的实参并被应用于从所有可迭代对象中并行获取的项。当有多个可迭代对象时，最短的可迭代对象耗尽则整个迭代就将结束。

def fun(name,score):
    return {name:score}

name = ['李明','郑化','张清','吴用']
score = [89, 65, 58, 100]
print(list(map(fun,name,score)))  # [{'李明': 89}, {'郑化': 65}, {'张清': 58}, {'吴用': 100}]

def f(x):
    return 5 * x ** 2 + 3 * x - 9


lst = [1, 2, 3, 4, 5, 6, 7, ]
it = map(f, lst)  # 把可迭代对象中的每一个元素传递给前面的函数进行处理. 处理的结果会返回成迭代器
print(list(it))   # [-1, 17, 45, 83, 131, 189, 257]

zip(*iterables)
创建一个聚合了来自每个可迭代对象中的元素的迭代器。
返回一个元组的迭代器，其中的第 i 个元组包含来自每个参数序列或可迭代对象的第 i 个元素。当所输入可迭代对象中最短的一个被耗尽时，迭代器将停止迭代。当只有一个可迭代对象参数时，它将返回一个单元组的迭代器。不带参数时，它将返回一个空迭代器。

name = ['李明','郑化','张清','吴用']
score = [89, 65, 58, 100]
print(list(zip(range(1,10),name, score)))
# [(1, '李明', 89), (2, '郑化', 65), (3, '张清', 58), (4, '吴用', 100)]

函数会保证可迭代对象按从左至右的顺序被求值。使得可以通过 zip([iter(s)]n) 这样的惯用形式将一系列数据聚类为长度为 n 的分组。这将重复同样的迭代器 n 次，以便每个输出的元组具有第 n 次调用该迭代器的结果。它的作用效果就是将输入拆分为长度为 n 的数据块。当你不用关心较长可迭代对象末尾不匹配的值时，则 zip() 只须使用长度不相等的输入即可。
zip() 与 * 运算符相结合可以用来拆解一个列表:

x = [1, 2, 3]
y = [4, 5, 6]

print(list(zip(x, y)))      # [(1, 4), (2, 5), (3, 6)]
x2, y2 = zip(*zip(x, y))
print(x2,y2)                # (1, 2, 3) (4, 5, 6)
print(x == list(x2) and y == list(y2))  # True

enumerate(iterable, start=0)
返回一个枚举对象。iterable 必须是一个序列、迭代器或其他支持迭代的对象。 enumerate() 函数返回一个元组，里面包含一个计数值（从 start 开始，默认为 0）和通过迭代 iterable 获得的值。

seasons = ['Spring', 'Summer', 'Fall', 'Winter']
print(list(enumerate(seasons)))           # [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
print(list(enumerate(seasons, start=1)))  # [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

作用域相关(2)

locals() 返回当前作用域中的名字
globals() 返回全局作用域中的名字 ```python def func(): u_name = ‘Tom’ age = 19 print(locals()) # 当前作用域中的内容,{‘u_name’: ‘Tom’, ‘age’: 19}

if name == ‘main‘: func() print(globals()) # 全局作用域中的内容

# {'__name__': '__main__', '__doc__': None, '__package__': None, 
'__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00000206B958C2E0>, 
'__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>,
'__file__': 'F:\\weiyun\\2020\\19 测试文件\\yyyy.py', '__cached__': None, 
'func': <function func at 0x00000206B986DE10>}

<a name="mYeqO"></a>
# 和迭代器生成器相关(4)

- range() 生成数据
- next() 迭代器向下执行一次, 内部实际使⽤用了__ next__()⽅方法返回迭代器的下一个项目
- iter() 获取迭代器, 内部实际使用的是__ iter__()⽅方法来获取迭代器
- range(stop)

range(start, stop[, step])<br />[range](https://docs.python.org/zh-cn/3/library/stdtypes.html#range) 实际上是一个不可变的序列类型，会产生一个整数等差数列，支持索引与切片等序列通用方法。

```python
print(range(10))                  # 惰性求值，只输出对象range(0, 10)
print(list(range(10)))            # 输出 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list(range(1,11)))          # 输出 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(list(range(0,30,5)))        # 步长5，[0, 5, 10, 15, 20, 25]
print(tuple(range(0,10,3)))       # 步长3，转为元组，(0, 3, 6, 9)
print(list(range(0,-10,-1)))      # 步长-1，[0,-1,-2,-3,-4,-5,-6,-7,-8,-9]
print(list(range(0)))             # range(0)输出[]
print(list(range(1,0)))           # 步长为1，stop<start时，输出[]

iter(object)
返回一个迭代对象，可用list转为列表输出，也可以用 * 解包输出。object 必须是支持迭代（或序列）协议的集合对象。

print(iter([1,2,3,4]))   # <list_iterator object at 0x0000014AEEDD5460>
print(iter('123'))       # <str_iterator object at 0x0000014AEEDD5460>
print(list(iter('123'))) # ['1', '2', '3']
print(*(iter('123')))    # 1 2 3

lst = [1, 2, 3, 4, 5]
it = iter(lst)  # __iter__()获得迭代器
print(it.__next__())  # 1
print(next(it))       # 2  __next__()
print(next(it))       # 3
print(next(it))       # 4
print(next(it))       # 5
print(list(it))       # 生成的数据用完，[]

字符串类型代码的执行(3)

eval() 执行字符串类型的代码. 并返回最终结果
exec() 执行字符串类型的代码
compile() 将字符串类型的代码编码. 代码对象能够通过exec语句来执行或者eval()进行求值
eval(expression, globals=None, locals=None)

expression：必选参数，可以是字符串，也可以是一个任意的code对象实例。如果它是一个字符串，它会被当作一个（使用globals和locals参数作为全局和本地命名空间的）Python表达式进行分析和解释。
globals：可选参数，表示全局命名空间（存放全局变量），如果存在，则必须是一个字典对象。
locals：可选参数，表示当前局部命名空间（存放局部变量），如果存在，可以是任何映射对象。如果该参数被忽略，那么它将会取与globals相同的值。
如果globals与locals都被省略，那么它们将取eval()函数被调用环境下的全局命名空间和局部命名空间。
返回值：
如果expression是一个code对象，且创建该code对象时，compile函数的mode参数是’exec’，那么eval()函数的返回值是None；
否则，如果expression是一个输出语句，如print()，则eval()返回结果为None；
否则，expression表达式的结果就是eval()函数的返回值；

a,b,c = eval(input())  # 输入 1,2,3
print(a,b,c)           # 输出 1 2 3

print(eval('23 + 56'))  # 79

x = 5
y = 10
a = eval('x + y')
print('a: ', a)  # a:  15
b = eval('x + y', {'x': 1, 'y': 2})
print('b: ', b)  # b:  3
c = eval('x + y', {'x': 1, 'y': 2}, {'y': 3, 'z': 4})
print('c: ', c)  # c:  4
d = eval('print(x, y)')  # 5 10
print('d: ', d)  # d:  None

对于变量a，eval函数的globals和locals参数都被忽略了，因此变量x和变量y都取得的是eval函数被调用环境下的作用域中的变量值，即：x = 5, y = 10，a = x + y = 15
对于变量b，eval函数只提供了globals参数而忽略了locals参数，因此locals会取globals参数的值，即：x = 1, y = 2，b = x + y = 3
对于变量c，eval函数的globals参数和locals都被提供了，那么eval函数会先从局部作用域locals中找到变量y，再从全局作用域globals中找到变量local中未定义的x, 即：x = 1, y = 3, c = x + y = 4
对于变量d，因为print()函数不是一个计算表达式，没有计算结果，因此返回值为None

s1 = input("请输入a+b:")  # 输入:5+8
print(eval(s1))  # 13 可以动态的执行代码. 代码必须有返回值

s2 = "for i in range(5): print(i)"
a = exec(s2)  # exec 只执行代码，返回值为None
# 0
# 1
# 2
# 3
# 4
print(a)  # None

# 动态执行代码
exec("""
def func():
    print("武汉理工大学")
""")

func()  # 武汉理工大学

code1 = "for i in range(5): print(i)"
com = compile(code1, "", mode="exec")   # compile只是编译并不会执行代码.
exec(com)                               # 执行编译的结果
# 0
# 1
# 2
# 3
# 4

code2 = "1+3+5+7+9"
com2 = compile(code2, "", mode="eval")
print(eval(com2))                       # 25

code3 = "name = input('请输入你的学校:')"  # 输入:武汉理工大学
com3 = compile(code3, "", mode='single')
exec(com3)
print(name)                              # 武汉理工大学

输入输出(2)

print() : 打印输出
input() : 获取用户输出的内容
input([prompt])

用于接收用户输入的函数，参数prompt 是显示在标准输出上用于提示的文字，输出后不换行。input() 函数从输入中读取一行，去除末尾的换行符后将其转换为字符串并返回，当读取到 EOF 时，则触发 EOFError。
一般在支持在线评判的实验平台上，写输入函数时不加参数以免干扰评判。

s = input('--> ')  # 屏幕输出“-->”后不换行，等待用户输入Monty Python's Flying Circus
print(s)           # "Monty Python's Flying Circus"

print(*objects)
用于将参数输出的函数，其完整参数如下：

print(*objects, sep=' ', end='\n')

objects 是输出到标准输出设备（ sys.stdout，即显示器）的一个或多个对象，多个对象输出时其间以 sep 指定的字符串分隔。输出结束时，末尾加上 end指定的结束符号。 sep和 end参数如果存在，它们必须以关键字参数的形式给出。如果没有给出 objects参数，则 print() 将只输出 end 指定的字符串，无参数的print()函数输出一个换行。

内存相关(2)

hash() : 获取到对象的哈希值(int, str, bool, tuple). hash算法:(1) 目的是唯一性 (2) dict 查找效率非常高, hash表.用空间换的时间比较耗费内存
hash(object)
返回该对象的哈希值。它们在字典查找元素时用来快速比较字典的键。相同大小的数字变量有相同的哈希值（即使它们类型不同，如 1 和 1.0）。
id() : 获取到对象的内存地址

print(hash(1))         # 1
print(hash(1.0))       # 1
print(hash('Hello'))   # 3267119946206711258(每次运行此值不同)
print(hash((1,2,3)))   # 529344067295497451
print(hash([1, 2, 3])) # 报错,列表是不可哈希的TypeError: unhashable type: 'list'

id(object)
返回对象的“标识值”。该值是一个整数，代表该对象在同存中的位置编码，在此对象的生命周期中是唯一且恒定的。两个生命期不重叠的对象可能具有相同的 id() 值。

num = 100
print(id(100))      # 140729933472512
print(id('Hello'))  # 1804450272688

文件操作相关(1)

open() : 用于打开一个文件, 创建一个文件句柄
open(file, mode=’r’, encoding=None)

打开 file 并返回对应的文件对象，如果该文件不能打开，则触发 OSError，如果文件不存在，则触发FileNotFoundError。
file 是一个以字符串表示的带路径的文件名，表示将要打开的文件的路径（绝对路径或者当前工作目录的相对路径）。encoding参数仅用于文本模式中，如果 encoding 没有明确指定，则根据操作系统来决定使用本地默认编码。
mode 是一个可选字符串，用于指定打开文件的模式。默认值是 ‘r’ ，这意味着它以文本模式打开并读取。其他常见模式有：写入 ‘w’ ；排它性创建 ‘x’ ；追加写 ‘a’ 。可用的模式有：

字符	意义
`'r'`	只读模式打（默认值）
`'w'`	写数据模式，如文件存在，先清除文件中的所有内容；如果文件不存在，先创建文件再打开。
`'x'`	创建文件并写入数据的模式，如果文件已存在则创建失败。
`'a'`	追加写数据模式入，如果文件存在，新数据追加到现有数据之后，如果文件不存在，先创建文件再写入数据。
`'b'`	二进制模式
`'t'`	文本模式（默认）
`'+'`	打开并允许更新，相当于增加读或写模式。与 ‘r’、’w’ 或 ‘a’ 组合使用，如 ‘r+’可读可写、’w+’可写可读、’a+’可追加写，可读。模式 ‘w+’ 与 ‘w+b’ 将打开文件并清空内容，模式 ‘r+’ 与 ‘r+b’ 将打开文件并不清空内容。

f = open('file', mode='r', encoding='utf-8')
f.read()
f.close()

模块相关(1)

import() : 用于动态加载类和函数 ```python
让用户输入一个要导入的模块
import os

name = input(“请输入你要导入的模块:”) import(name) # 可以动态导入模块

<a name="k50Tx"></a>
# 帮 助(1)

- help() : 函数用于查看函数或模块用途的详细说明
- help([object])

启动内置的帮助系统（此函数主要在交互式中使用）。如果没有实参，解释器控制台里会启动交互式帮助系统。如果实参是一个字符串，则在模块、函数、类、方法、关键字或文档主题中搜索该字符串，并在控制台上打印帮助信息。如果实参是其他任意对象，则会生成该对象的帮助页。

```python
>>> help(abs)
Help on built-in function abs in module builtins:

abs(x, /)
    Return the absolute value of the argument.

>>>

print(help(str))  # 查看字符串的用法

调用相关(1)

callable() : 用于检查一个对象是否是可调用的. 如果返回True, object有可能调用失败, 但如果返回False. 那调用绝对不会成功 ```python s = “hello” print(callable(s)) # False 变量s不能被调用

def fun(): print(“hello”) # 输出hello print(callable(f)) # True 函数是可以被调用的

if name == ‘main‘: fun() # 调用函数fun

<a name="Hetni"></a>
# 查看内置属性(2)

- dir() : 查看对象的内置属性, 访问的是对象中的__dir__()方法
- type(object)传入一个参数时，返回 object 的类型， 返回值是一个 type 对象。
- dir([object])

如果没有实参，则返回当前本地作用域中的名称列表。如果有实参，它会尝试返回该对象的有效属性列表。

```python
print(dir(list))  # 查看列表的方法
# ['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', 
'__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', 
'__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__',
'__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__',
'__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', 
'__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__',
'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 
'reverse', 'sort']

type(object)
传入一个参数时，返回 object 的类型，返回值是一个 type 对象。

print(type(100))       # <class 'int'>
print(type(98.5))      # <class 'float'>
print(type('100'))     # <class 'str'>
print(type([100,99]))  # <class 'list'>

Python程序设计数字教程

2 常用内置函数

数值相关

1. 数值类型(4)