1.ceil(x):返回数字的向上整数。如math.ceil(4.1) 返回 5。
floor(x):返回数字的下舍整数。如math.floor(4.9)返回 4
gcd(x,y):返回x和y的最大公约数。如math.gcd(3,6) 返回3
divmod(x,y):返回x除以y的商和余数。 如divmod(10,3) 返回(3, 1)。
factorial(x):返回x阶乘的值 如math.factorial(3) 返回 6。
prod(x):返回迭代器x里每个元素之积。如prod(2,3,4) 返回 24。
2.随机函数
random()：在[0,1)范围内随机生成一个浮点数。如random.random()。
uniform(x,y)：[x,y]范围内随机生成一个浮点数。如random.uniform(3,5)。
randint(x,y)：在指定范围内随机一个整数。如random.randint(1,10)。
randrange([start,] stop [,step])：指定范围内按指定基数递增集合中获取一个随机数，默认值为 1。
start -- 指定范围内的开始值，包含在范围内。
stop -- 指定范围内的结束值，不包含在范围内。
step -- 指定递增基数。
如random.randrange(1, 100, 2)从 1-100 中选取一个奇数。
choice(x)：从序列x中随机挑选一个元素，x --可以是一个列表、元组、字符串。
如random.choice(range(10))，从0到9中随机挑选一个整数。
sample(x,y)：从序列中随机指定个数的元素。如x = [1,2,3,4,5]，random.sample(x,3)。
seed([x])：改变随机数生成器种子，需在调用其他随机函数前调用此函数。
如random.seed(8)，提前指定种子数字为8。
shuffle(x)：将序列x的所有元素随机排序。如random.shuffle(x)。
3.字符函数:
split(): split(str="", num=string.count(str)) 以 str 为分隔符截取字符串，如果 num 有指定值，
则仅截取 num+1 个子字符串。x = 'h,e,l,l,o'，x.split(',')返回['h', 'e', 'l', 'l', 'o']。
rsplit():rsplit(str="", num=string.count(str))以 str 为分隔符从右边截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串。
x = 'h,e,l,l,o'，x.rsplit(',',2)返回['h, e, l', 'l', 'o']。
rpartition():指定字符串最后一次出现，并将该字符串拆分为包含三个元素的元组。
x = 'hello'，x.rpartition('l')，返回('hel', 'l', 'o')
find(x):find(str, beg=0, end=len(string))检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，
则检查是否包含指定范围内，如果包含返回开始索引值，否则返回-1。
x = 'hello world' x.find('l')返回2；x.find('l',5)返回9
rfind():rfind(str, beg=0,end=len(string))类似于 find()函数，不过是从右边开始查找。
x = 'hello'，x.rfind('l')，返回3，x.rfind('l',0,3)返回2
index(x):index(str, beg=0, end=len(string))跟find()方法一样，只不过如果str不在字符串中会报一个异常。x = 'hello world' x.index('l')返回2； x.index('l',5)返回9
rindex():rindex( str, beg=0, end=len(string))类似于 index()，不过是从右边开始。
x = 'hello'，x.rindex('l')，返回3，x.rindex('l',0,3)返回2。
center(x,y):返回一个指定的宽度 x 居中的字符串，y 为填充的字符，默认为空格。
x = '漫步桔田' x.center(10,'*') ，返回 ***漫步桔田***。
ljust():ljust(width[, fillchar])返回一个原字符串左对齐,并使用 fillchar,填充至长度 width 的新字符串，fillchar 默认为空格。x = 'hello'，x.ljust(8,'*')，返回hello***。
rjust():rjust(width,[, fillchar])返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串。x = 'hello'，x.rjust(8,'*')，返回***hello
count(x):count(x, beg= 0,end=len(string))返回 x在字符出现次数， beg和end 用于返回指定范围内 x 出现次数。x = 'Hello' x.count('l') 返回 2；x.count('l',3)返回 1 。
replace():replace(old, new [, max])将字符串中 old 替换成 new,如果 max 指定，则替换不超过 max 次。x = 'aacc'，x.replace('c','b')，返回aabb，x.replace('c','b',1)，返回aabc。
join(x):join(x)以指定字符作为分隔符，将 x 中所有元素合并为一个新字符串。
x = 'hello' '*'.join(x) ，返回h*e*l*l*o。
zfill():返回长度为 width 的字符串，原字符串右对齐，前面填充0。x = 'hello'，x.zfill(10)，返回00000hello
lstrip():截掉字符串左边的空格或指定字符。x = ' HELLO'，x.lstrip()，返回HELLO。
rstrip():删除字符串末尾的空格或指定字符。x = 'hello***'，x.rstrip('*')，返回hello。
strip():在字符串上执行 lstrip()和 rstrip()。x = '**hello**'，x.strip('*')，返回hello。
splitlines(x):按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，
如果参数 x 为 False，不包含换行符，如果为 True，则保留换行符。
'12\r34\r\n56\n78'.splitlines()，返回['12', '34', '56', '78']。
'12\r34\r\n56\n78'.splitlines(True)，返回['12\r', '34\r\n', '56\n', '78']。
expandtabs():
expandtabs(tabsize=8):expandtabs() 方法把字符串中的 tab 符号 \t 转为空格，tab 符号 \t 默认的空格数是 8，在第 0、8、16...等处给出制表符位置，如制表符位置字符数不足 8 倍数则以空格代替。x = 'hello\tworld' x.expandtabs() 返回hello world补充3个空格。
startswith():startswith(x, beg=0,end=len(string))检查字符串是否是以指定子字符串 x 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。
x = 'hello'，x.startswith('h')，返回True。
endswith():
endswith(x, beg=0, end=len(string))检查字符串是否以 x 结尾，如果 beg 和 end 指定则检查指定范围内是否以 suffix 结束，如果是，返回 True,否则返回 False。
x = 'hello' x.endswith('o')返回True；x.endswith('l',0,3)返回True。
isalnum():如果字符串不为空并且所有字符都是字母或数字，则返回 True，否则返回 False。
x = 'hello world' x.isalnum()返回False。
isalpha():如果字符串不为空且所有字符都是字母或中文字，则返回 True, 否则返回 False。
x = 'hello漫步' x.isalpha()返回 True
isdigit():如果字符串只包含数字则返回 True 否则返回 False。x = '123456' x.isdigit()，返回 True
isnumeric():如果字符串中只包含数字字符，则返回 True，否则返回 False。x = '123456' x.isnumeric() 返回 True。
isdecimal():检查字符串是否只包含十进制字符，如果是返回 True，否则返回 false。
x = '123'，x.isdecimal()，返回True。
isspace():如果字符串中只包含空格，则返回 True，否则返回 False。x = ' ' x.isspace()，返回 True。
字符格式%
%c 格式化字符及其ASCII码。 '我是字母 %c 。' % (97) ，返回我是字母 a 。
%u 格式化无符号整型。 '我的年龄 %u。' % (21)，返回我的年龄 21 。
%i 格式化无符号十进制数。 '我的年龄 %i。' % (21)，返回我的年龄 21
%g%G:自动将整数、浮点数转换浮点或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是e）。'我的体重 %.2g。' % (1.001260e+02)，返回我的体重 100.126
%[(name)][flags][width].[precision] typecode
(name)：参数名称，用来传入字典值的，（传入参数必须是字典）；
flags：作为用户对一些格式的选择，只有固定的几个值，以下
+ 右对齐：正数前加正好，负数前加负号；
- 左对齐：正数前无符号，负数前加负号；
' ' 右对齐：正数前加空格，负数前加负号；
0 右对齐：正数前无符号，负数前加负号；用0填充空白处
width：表示显示宽度，如果设置宽度低于实际字符宽度时，会按照实际的宽度来输出
如果设置宽度高于字符宽度时，会按照设置的宽度输出，空白符自动补位，右对齐。
precision：表示小数点后精度
typecod：用于指定输出类型（%s、%d、%f）。
字符格式format
| 数字 | 格式 | 输出 | 描述 |
| 3.1415926 | {:.2f} | 3.14 | 保留小数点后两位 |
| 3.14159/-1 | {:+.2f} | +3.14/-1.00 | 带符号保留小数点后两位 |
| 2.71828 | {:.0f} | 3 | 不带小数 |
| 5 | {:0>2d} | 05 | 数字补零 (填充左边, 宽度为2) |
| 5/10 | {:x<4d} | 5xxx/10xx | 数字补x (填充右边, 宽度为4) |
| 1000000 | {:,} | 1,000,000 | 以逗号分隔的数字格式 |
| 0.25 | {:.2%} | 25.00% | 百分比格式 |
| 1000000000 | {:.2e} | 1.00e+09 | 科学计数法（1*10^9） |
| 13 | {:>10d} | 13 | 右对齐 (默认, 宽度为10) |
| 13 | {:<10d} | 13 | 左对齐 (宽度为10) |
| 13 | {:^10d} | 13 | 中间对齐 (宽度为10) |
| 11 | {:b}.format(11) {:d}.format(11) {:o}.format(11) {:x}.format(11) {:#x}.format(11) {:#X}.format(11) | 1011 11 13 b 0xb 0XB | 进制 |
| ^, <, > 分别是居中、左对齐、右对齐，后面带宽度； : 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充； + 表示在正数前显示 +，负数前显示 -； （空格）表示在正数前加空格 b、d、o、x 分别是二进制、十进制、八进制、十六进制。 |
列表函数
| 序号 | 函数名 | 方法及描述 |
| 1 | len(x) | 列表元x素个数。 x = [1,2,3,4,5]， len(x)， 返回 5。 |
| 2 | max(x) | 返回列表x元素最大值。 x = [1,2,3,4,5]，max(x) ，返回 5。 |
| 3 | min(x) | 返回列表x元素最小值。 x = [1,2,3,4,5]，min(x) ，返回 1 |
| 4 | list(x) | 将序列x转换为列表。 x = (1,2,3,4,5)， list(x)， 返回 [1,2,3,4,5]。 |
| 5 | append(x) | 在列表末尾添加新的对象。 x = [1,2,3,4,5]，x.append(6)，返回 x [1, 2, 3, 4, 5, 6]。 |
| 6 | count(x) | 统计某个元素在列表中出现的次数。 x = [1,2,3,3,5]，x.count(3)，返回 2 |
| 7 | extend(x) | 在列表末尾一次性追加另一个序列（用新列表扩展原来的列表）。 x = [1,2,3]，y = [4,5,6]，x.extend(y)，返回 x = [1, 2, 3, 4, 5, 6]。 |
| 8 | index(x) | 从列表中找出某个值第一个匹配项的索引位置。 x = [1,2,3]，x.index(3)，返回 2。 |
| 9 | insert(x,y) | 将对象插入列表，x.insert(index, obj) |
| 10 | pop(x) | 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。 x = [1,2,3,4,5]，x.pop()，返回 x = [1, 2, 3, 4]。 x = [1,2,3,4,5]，x.pop(3)，返回 x = [1, 2, 3, 5]。 |
| 11 | del | 移除列表中指定位置元素。 x = [1, 2, 3 ,4, 5]，del x[3]，返回 x = [1, 2, 3, 5]。 |
| 12 | remove(x) | 移除列表中某个值的第一个匹配项。 x = [1,2,3,3,5]，x.remove(3)，返回 x = [1, 2, 3, 5]。 |
| 13 | reverse(x) | 反向排列列表中元素 。 x = [1,2,3,4,5]，x.reverse()，返回 x = [5, 4, 3, 2, 1]。 |
| 14 | sort(x) | 对原列表进行排序，list.sort( key=None, reverse=False)。 key - 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。 reverse - 规则，reverse = True 降序， reverse = False 升序（默认）。 x = [2,1,4,3,5]，x.sort() 返回 x = [1, 2, 3, 4, 5]。 x.sort(reverse=True)，返回 x = [5, 4, 3, 2, 1]。 |
| 15 | clear(x) | 清空列表 。 x = [1,2,3,4,5]，x.clear()，返回 x = []。 |
| 16 | copy(x) | 复制列表 。 x = [1,2,3,4,5]，y = x.copy()，返回 y = [1,2,3,4,5]. |
元组函数
元组是不可变数据类型，不可以进行“增删改”操作，但可通过拼接、切片完成“增删改”操作
| 序号 | 函数名 | 方法及描述 |
| 1 | tuple(x) | 将可迭代对象x转换为元组。 x = [1, 2, 3 ,4, 5]，tuple(x)，返回 (1, 2, 3, 4, 5) |
| 2 | len(x) | 计算元组x元素个数。 x = (1, 2, 3 ,4, 5)，len(x)，返回 5。 |
| 3 | max(x) | 返回元组x中元素最大值。 x = (1, 2, 3 ,4, 5) ，max(x) 返回 5。 |
| 4 | min(x) | 返回元组x中元素最小值。 x = (1, 2, 3 ,4, 5) ，min(x) 返回 1 |
| 5 | count(x) | 返回元素x在元组出现次数 x = (1, 3, 3 ,3, 5)，x.count(3)，返回 3。 |
| 6 | index(x) | 从元组中找出某个值第一个匹配项的索引位置。 x = (1, 2, 3 ,3, 5)，x.count(3)，返回 2。 |
| 7 | zip(x,y) | 将两个列表组合为元组，再用list函数转为列表。 x = [1,2,3]，y = [4,5,6]，list(zip(x,y))，返回 [(1, 4), (2, 5), (3, 6)] |
| 8 | enumerate(x[,y]) | 将列表内容和序号组合为元组对象，再利用list函数转为列表。 x = ['A','B','C']，list(enumerate(x))，返回[(0, 'A'), (1, 'B'), (2, 'C')] |
字典函数
| 序号 | 函数名 | 方法及描述 |
| 1 | diact(x) | 创建一个字典。 序列x必须是元组。 x = (('漫漫',23),) |
| 2 | len(x) | 计算字典x元素个数，即键的总数。 x = {'name':'漫步桔田','age':21}，len(x)，返回 2 |
| 3 | max(x) | 返回字典中键的最大值。 x = {'a':1,'b':2,'c':3}，max(x)，返回 c。 |
| 4 | min(x) | 返回字典中键的最小值。 x = {'a':1,'b':2,'c':3}，min(x)，返回 a。 |
| 5 | clear() | 删除字典内所有元素。 x = {'name':'漫步桔田','age':21}，x.clear()，返回 x = {}。 |
| 6 | copy() | 返回一个字典的浅复制。 x = {'name':'漫步桔田','age':21}，y = x.copy()， 返回 y = {'name':'漫步桔田','age':21}。 |
| 7 | fromkeys() | dict.fromkeys(seq[, value]) value -- 可选参数, 设置键序列（seq）对应的值，默认为 None。 y = [1,2,3]，dict.fromkeys(y)，返回{1: None, 2: None, 3: None} |
| 8 | update() | 把字典dict2的键/值对更新到dict里。 x = {'name':'漫步桔田','age':21} |
| 9 | get() | dict.get(key,default=None) x = {'name':'漫步桔田','age':21} x.get('name') 返回 漫步桔田。 |
| 10 | setdefault() | dict.setdefault(key,default=None) x = {'name':'漫步桔田','age':21} x.setdefault('name') 返回 漫步桔田。 |
| 11 | items() | 返回一个视图对象。 x = {'name':'漫步桔田','age':21} x.items() 返回 dict_items([('name', '漫步桔田'), ('age', 21)])。 |
| 12 | keys() | 返回一个视图对象。 x = {'name':'漫步桔田','age':21} x.keys() 返回 dict_keys(['name', 'age'])。 |
| 13 | values() | 返回一个视图对象。 x = {'name':'漫步桔田','age':21} |
| 14 | pop() | 删除字典 key（键）所对应的值，返回被删除的值。 x = {'name':'漫步桔田','age':21} |
| 15 | popitem() | 返回并删除字典中的最后一对键和值。 x = {'name':'漫步桔田','age':21} |
字典操作：
字典创建 ： x = dict(name = '漫步',age =21) print(x) 结果: {'name': '漫步桔田', 'age': 21}
nama = ['漫漫','桔桔'] age = [23,21] x = dict(zip(name,age))
print(x) 结果: {'漫漫: 23, '桔桔': 21}
#字典增加
x = {'name': '漫步桔田', 'age': 21} x['scores'] = 100 print(x)
字典：{'name': '漫步桔田', 'age': 21，’scores': 100}
#字典删除
x = {'name': '漫步桔田', 'age': 21} del x['age'] print(x)
结果：{'name': '漫步桔田'}
#字典修改
x = {'name': '漫步桔田', 'age': 21} x['age'] = 25 print(x)
结果： {'name': '漫步桔田', 'age': 25}
#字典查询
x = {'name': '漫步桔田', 'age': 21} print(x['age']) 结果：21
#字典嵌套
x = {} x['name'] = [1,2,3] print(x) 结果：{'name':[1,2,3]}
print(x['name'][1]) 结果：2
#字典判断
x = { '漫漫':23, '桔桔': 21} print('漫漫' in x) 结果：True 判断字典键轴是否包含'漫漫'
print('小漫' in x) 结果：False 判断字典键轴是否包含'小漫'
三、集合
无序不重复 {}或者set()函数创建，例如：{1,2,3}
set()
将序列转换为集合。
x = [1,2,3]，set(x)，返回 {1, 2, 3} 。
y = (4,5,6)，set(y)，返回 {4, 5, 6} 。
len() 计算集合中元素个数。x = {1,2,3}，len(x))，返回 3
max()返回集合中最大值。 x = {1,2,3}，max(x)，返回 3 。y = {'a','b','c'}，max(x)，返回 c
add() 为集合添加新元素。 x = {1,2,3,4,5} x.add(6) 返回 x = {1,2,3,4,5,6}。
union() 返回两个集合的并集。 x = {1,3,5} y = {5,7} x.union(y)，返回 {1, 3, 5, 7}
intersection() 返回集合的交集。 x = {1,3,5} y = {2,3,4} z = x.intersection(y)，返回 z = {3}。
update()将集合 y 中元素过滤掉相同元素后添加到集合 x 中 x = {1,3,5} y = {5,7} x.update(y)，返回 x = {1, 3, 5, 7}。
clear()移除集合中的所有元素。x = {1,2,3,4,5} x.clear()，返回 x = set()
copy()拷贝一个集合。 x = {1,2,3,4,5} y = x.copy()，返回y = {1,2,3,4,5}
pop()随机移除元素 x = {1,2,3,4,5} x.pop()，返回 x = {2, 3, 4, 5}
remove()移除指定元素 x = {1,2,3,4,5} x.remove(4)，返回 x = {1, 2, 3, 5}。
discard()删除集合中指定的元素。x = {1,3,5} y = {2,3,4} x.discard(3)，返回 x = {1, 5}
difference_update() 删除x集合中与y集合中相同的元素。 x = {1,3,5} y = {2,3,4}
x.difference_update(y)，返回x = {1, 5}
intersection_update() 删除集合 x 中与指定集合 y 中不同元素。 x = {1,3,5} y = {2,3,4}
x.intersection_update(y)，返回 x = {3}
difference()返回仅存在于集合 x 中而不存在于集合 y 中的元素 x = {1,2,3} y = {2,3,4}
z = x.difference(y)，返回 z = 1
symmetric_difference()返回两个集合中不重复的元素集合。x = {1,3,5} y = {3,5,7}z = x.symmetric_difference(y)，返回 z = {1, 7}。
symmetric_difference_update()
移除集合x、集合y中的相同元素，并将集合y中不同元素插入到集合x中。
x = {3,5} y = {5,7} x.symmetric_difference_update(y)，返回 x = {3, 7}。
isdisjoint()判断集合x、y 是否包含相同的元素，是返回 True，否则返回 False
x = {1,3,5} y = {2,3,4} x.isdisjoint(y)，返回 False
issubset()判断指定集合 x 是否为集合 y 的子集，是返回 True，否则返回 False
x = {1,3,5} y = {1,3,5,7,9} x.issubset(y)，返回 True
issuperset()判断集合 y 是否包含指定集合 x， 是返回 True，否则返回 False。
x = {1,3,5} y = {1,3,5,7,9}，y.issuperset(x)，返回 True。
集合操作：
-
x = {1,2,3} print(2 in x) # True 判断元素 2 是否在集合 x 中
-
x = [1,1,2,3,5,5] print(list(set(x))) # [1, 2, 3, 5] 列表、元组去重
-
x = {1,3,5} y = {2,3,4} print(x-y) # {1, 5} #差集：返回一个新集合，包括集合 x 中与集合y不同元素。
-
print(x|y) # {1, 2, 3, 4, 5} #并集：返回一个新集合，包括集合 x 和集合 y 中所有元素
-
print(x&y) # {3} #交集：返回一个新集合，仅包括集合 x 和 y 中相同的元素。
-
print(x^y) # {1, 2, 4, 5} #补集：返回一个新集合，仅包括集合 x 和 y 中的不同元素
四、条件判断
if ...if 与 if ....elif 的区别：前者不管条件是否成立都会依次进行判断，不会跳出条件判断；后者只要条件成立立即跳出判断，不会再执行后面判断语句。
三元表达
表达语法是：表达式 1 if 条件表达式 else 表达式 2；
当条件为 True 时，返回结果表达式 1，否则返回结果表达式 2。
例子1：
x = 100
print('A') if x > 100 else print('B')
# 如果 if 语句满足条件，执行 if 前语句，否则执行 else 后语句，
# 因为 x=100 ,不满足 if 条件，故执行执行 else 后语句，返回 B 。
例子2：
x = 100
print(('B','A')[x == 100])
# (x,y), x 为 else 后执行语句，y 为 if 满足条件执行语句，
# 因为 x=100 ，满足 if 条件，故执行括号第二参数 ，返回 A 。
例子3：
x = 100
print({True:'A',False:'B'}[x == 100])
# 以字典形式传入判断条件满足执行键值，
# 因为 x==100 条件成立即为 True ，故返回 A
match ....case python3.10新增，match 后的对象会依次与 case 后的内容进行匹配，如果匹配成功，则执行匹配到的表达式，否则直接跳过，_ 可以匹配一切。
x = 200
match x: # 设置判断对象 。
case 100:
print(1)
case 200: # 当条件满足 x = 200 时执行打印语句返回 2 。
print(2)
case _: # 注意case 和 _ 中间有一个空格 。
print(3)
例子2：
x = 100
match x:
case 100|200: # 也可以设置多个判断，条件用 | 进行分割，
print(1) # 当 x = 100 or 200 都会执行打印返回 1 。
case 300:
print(2)
case _:
print(3)
contimue
continue语句用来跳过当前循环的剩余语句，然后继续进行下一轮循环。
# while......continue语句
x = 0
while x < 5:
x += 1
if x == 4:
continue
else:
print(x)
# 依次打印 1 2 3 5，因为当 x = 4 时执行if判断中语句continue，
# 跳过当前循环，执行下一个循环，所以不会执行else中语句故不会打印x值。
# for......continue语句
for x in range(1,6):
if x == 4:
continue
else:
print(x)
# 依次打印 1 2 3 5，因为当 x = 4 时执行if判断中语句continue，
# 跳过当前循环，执行下一个循环，所以不会执行else中语句故不会打印x值。
break用来终止循环语句，即循环条件没有 False 条件或者序列还没被完全循环完成，也会停止执行循环语句。
# while......break
x = 0
while x < 5:
x += 1
if x == 4:
break
else:
print(x)
# 依次打印 1 2 3 ，因为当 x = 4 时执行 if 判断中语句 break ，跳过出循环，
# 不再执行下一个循环，所以不会执行剩余语句和 else 中语句，故不会打印 x 值。
# for......break
for x in range(1,6):
if x == 4:
break
else:
print(x)
# 依次打印 1 2 3 ，因为当 x = 4 时执行 if 判断中语句 break ，跳过出循环，
# 不再执行下一个循环，所以不会执行剩余语句和 else 中语句，故不会打印 x 值。
1129
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
