1. 【获取数字的绝对值】abs函数
语法参考
abs()函数用于获取数字的绝对值，其语法格式如下：
abs(x)
参数说明：
-
x：表示数值，参数可以是整数、浮点数或者复数；
-
返回值：返回数字的绝对值。如果参数是一个复数，则返回复数的模。
锦囊1：获取整数与浮点数的绝对值
在获取绝对值时，比较常见的数值就是整数与浮点数，使用abs()函数获取整数与浮点数绝对值的示例代码如下：
print(abs(909)) # 求绝整数绝对值
print(abs(-88)) # 求负数绝对值
print(abs(0)) # 求0绝对值
print(abs(0.558)) # 求浮点数绝对值
print(abs(-0.12)) # 浮点负数绝对值
锦囊2： 获取复数的模
除了使用abs()函数去整数与浮点数的绝对值以外，还可以通过abs()函数获取复数的模。示例代码如下：
print(abs(1-2j)) # 获取1-2j复数的模
print(abs(1+5j)) # 获取1+5j复数的模
print(abs(6*8j)) # 获取6*8j复数的模
print(abs(-1-1j)) # 获取-1-1j复数的模
2. 【获取两个数值的商和余数】divmod函数
语法参考
divmod()函数用于返回两个数值（非复数）相除得到的商和余数组成的元组。其语法格式如下：
divmod(x, y)
参数说明：
-
x：被除数；
-
y：除数；
-
返回值：返回由商和余数组成的元组。
锦囊1：获取商和余数的元组
使用divmod()函数获取商和余数的元组，示例代码如下：
print(divmod(9,2)) # 被除数为9，除数为2
print(divmod(100,10)) # 被除数为100，除数为10
print(divmod(15.5,2)) # 被除数为15.5，除数为2
说明：通过divmod()函数获取商和余数的元组时，元组中的第一个元素为商，第二个元素为余数。
提示：如果参数x和y都是整数，相当于（a//b,a%b）；如果参数x或y是浮点数，相当于（math.floor(a/b),a%b）
3. 【获取对象的长度或项目个数】len函数
语法参考
len()函数的主要功能是获取一个（字符、列表、元组等）可迭代对象的长度或项目个数。其语法格式如下：
len(s)
参数说明：
-
参数s：要获取其长度或者项目个数的对象。如字符串、元组、列表、字典等；
-
返回值：对象长度或项目个数。
锦囊1：获取字符串长度
通过len()函数获取可迭代对象的长度，也就是获取可迭代对象中有多少个元素。通过len()函数获取字符串长度的常见用法如下：
# 字符串中每个符号仅占用一个位置，所以该字符串长度为34
str1 = '今天会很残酷，明天会更残酷，后天会很美好，但大部分人会死在明天晚上。'
# 在获取字符串长度时，空格也需要占用一个位置，所以该字符串长度为10
str2 = 'hello word'
print('str1字符串的长度为:',len(str1)) # 打印str1字符串长度
print('str2字符串的长度为',len(str2)) # 打印str2字符串长度
# 打印str2字符串去除空格后的长度
print('str2字符串去除空格后的长度为：',len(str2.replace(' ','')))
# 字符串中每个元素都是相同的，len函数也会根据实际数量进行长度的获取
str3 = '000000000000'
print('str3字符串长度为：',len(str3)) # 打印str3字符串长度
# 打印机str3字符串指定元素范围的长度，仅获取下标为3及以后的所有元素长度
print('获取str3字符串指定元素范围的长度为：',len(str3[3:]))
str4 = '床前明月光，疑是地上霜。举头望明月，低头思故乡。'
# 从字符第一个开始，以步进值为3获取字符串元素，然后获取提取后字符串的长度
print('根据要求提取后字符串长度为：',len(str4[0:20:3]))
# 获取str4字符串中“床”汉字对应的ASCII码值，然后获取该ASCII码值的长度
print('床ASCII码值的长度为：',len(str(ord(str4[0]))))
锦囊2：获取列表长度
获取列表长度是python开发中比较常用的一种技术，len函数可以直接获取列表中一共有多少个元素，通过len()函数获取列表长度的常见用法如下：
# 在获取列表长度时，len函数不会在意列表内元素的类型
list = [1,2,3,4,'123',2.15]
# 同时定义两个元素类型不同的列表
list1, list2 = [1,2,3], ['a','b','c']
list3= ['库里','杜兰特','詹姆斯','哈登','威少'] # 定义一个列表
print('list列表的长度为 : ', len(list)) # 打印list列表长度
print('list1列表的长度为: ', len(list1)) # 打印list1列表长度
print('list2列表的长度为:',len(list2)) # 打印list2列表长度
print('共有',len(list3),'名球员') # 获取列表元素个数
# 获取列表下标为1~4范围的长度，不包含下标为4的元素
print('列表中指定元素范围的长度为：',len(list[1:4]))
# 创建运动员排名2维列表，内层列表中包含名次与运动员名称
listcar = [[1,'tony'],[2,'kevin'],[3,'lucy'],[4,'lily'],[5,'mike']]
print('listcar列表的长度为：',len(listcar)) # 打印二维列表的长度
print('listcar列表中的列表元素长度为：',len(listcar[0])) # 打印二维列表中元素列表长度
list3 = [] # 创建空的列表
for i in range(5): # 循环遍历0~4
list3.append(i) # 将0~4逐个添加至列表中
print('当前列表内容为：', list3) # 打印当前列表
print('当前列表长度为：',len(list3)) # 打印每次循环后列表的长度变化
锦囊3：获取元组长度
因为元组也是可迭代对象，所有在获取元组长度时与获取列表长度类似，常见用法如下：
tuple1 = (1,11,111,1111,11111) # 创建元素长度不同的元组
print('tuple1元组长度为：',len(tuple1)) # 打印tuple1元组长度
print('元组中指定元素范围的长度为：',len(tuple1[1:3])) # 打印tuple1元组指定元素范围的长度
# 创建星期英文元组
tuple2 = ('Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday')
# 打印tuple2元组中长度最大值
print('tuple2元组中元素长度最大为：',max(len(i)for i in tuple2))
# 打印tuple2元组中长度最大的元素
print('tuple2元组中长度最大的元素为：',max(tuple2,key=lambda i:len(i)))
# 打印tuple2元组中长度最小的元素
print('tuple2元组中长度最小的元素为：',min(tuple2,key=lambda i:len(i)))
# 创建国际旅游胜地前四名的二维元组
tuple3 = (('威尼斯',1),('阿姆斯特丹运河',2),('马尔代夫',3),('迪拜',4))
# 打印二维元组的长度
print('二维元组tuple3的长度为：',len(tuple3))
# 打印二维元组中旅游胜地名称最长的元组
print('旅游胜地名称最长的元组为：',max(tuple3,key = lambda i:len(i[0])))
锦囊4： 获取字典长度
字典类型的数据中包含键与对应的value值，len函数可以自动识别出一个字典类型的数据中有几对数据。常见用法如下：
# 人物基本信息
dict_name = {'Name':'Aaron','Age':18,'height':1.72,'weight':55,'sex':'g'}
print('dict_name字典长度度为：',len(dict_name)) # 打印dict_name字典长度
# 使用dict()函数创建一个字典
dictionary =dict((('邓肯', '石佛'),('吉诺比利','妖刀'), ('帕克','跑车')))
# 输出字典
print('字典：',dictionary)
# 获取字典中的元素个数
print('字典中的元素个数为：',len(dictionary))
注意：当len()函数中的参数不是一个可迭代对象时，将出现类型错误的提示信息。示例代码如下：
print(len(3.1415926))
锦囊5 计算一个字符串中包含“aeiou”这5个字符的数量
输出一个字符串中包含“aeiou”这5个字符的数量。代码如下：
import re
def count_vowels(str):
# 使用正则表达式匹配所有包括aeiou的字符，然后计算长度
return len(re.findall(r'[aeiou]', str, re.IGNORECASE))
print(count_vowels('foobar'))
print(count_vowels('gym'))
锦囊7 判断列表中的元素是否有重复的
判断一个列表中的元素是否有重复的。代码如下：
def all_unique(lst):
# 先将列表转化为集合，利用集合去重功能，删除重复元素，然后再和原来的列表对比
return len(lst) == len(set(lst))
x = [1,1,2,2,3,2,3,4,5,6]
y = [1,2,3,4,5]
print(all_unique(x))
print(all_unique(y))
4. 【获取可迭代对象（或元素）的最大值】max函数
语法参考
max()函数是python开发中使用较多的函数，主要功能为获取传入的多个参数的最大值，或者传入的可迭代对象（或之中的元素）的最大值。其语法格式如下：
max(iterable, *[, key, default])
或
max(arg1, arg2, *args[, key])
参数说明：
-
iterable：可迭代对象，如字符串、列表、元组、字典等；
-
default：命名参数，用来指定最大值不存在时返回的默认值；
-
key：命名参数，其为一个函数，用来指定获取最大值的方法；
-
arg：指定数值；
-
返回值：返回给定参数的最大值。
注意：使用max函数，如果是数值型参数，则取数值大者；如果是字符型参数，取字母表排序靠后者。当max()函数中存在多个相同的最大值时，返回的是最先出现的那个最大值。
注意：用max获取元素中的最大值，本质是获取元素的编码值大小，谁的编码值大，谁就最大。如果是数字和英文字母、标点，看谁的ASCII码值大小就可以了。汉字的编码值大于数字、英文字母和英文标点符号，常用数字、字目和标点的ASCII码值对照表如图所示。
说明：字符串按位比较，两个字符串第一位字符的ascii码谁大，字符串就大，不再比较后面的；第一个字符相同就比第二个字符串，以此类推。
锦囊1：在字符、数字、标点及汉字中取最大值
Max函数是根据元素的编码码值大小来取得最大值的。我们通常使用的字符的编码值可以通过其对应ASCII码表或相应编码表获得。max对数字、字符等的常用应用如下：
num1='123456789' # 数字的ASCII码范围49-57之间 ！‘#￥%&‘（）*+，-./的ASCII码范围33―47之间
num2='35*120-2020=?' # * - = ?的ASCII码分别是 35 42 45 61 63
print(max(num1)) # 1-9数字的ASCII码是49-57，9的ASCII码值是57，所以输出9
print(max(num2)) # ?的ASCII码是63，其他标点符号和数字的ASCII码都小于63，所以输出?
# 输出数字num2、num2的最大值和最大值的索引
print(num2,max(num2),num2.index(max(num2)))
说明：当max()函数只给定一个可迭代对象且可迭代对象为空时，则必须指定命名参数default，用来指定最大值不存在时，函数返回的默认值。代码如下：
# 参数是一个空的可迭代对象时，必须指定命名参数default
print(max((),default=100))
chart1='abcdefghijkABCDEFGHI' # 大写字母的ASCII范围65-73 小写字母的ASCII范围 97-107
print(max(chart1)) # k的ASCII码值107，其他字母、标点符号和数字的ASCII码都小于107，所以输出k
chart2='lmnopqxyz123456789' # 小写字母的ASCII码值比数字的ASCII码值要大
print(max(chart2)) # z的ASCII码是122，在这些元素中最大
print(chart2,max(chart2),chart2.index(max(chart2))) # 输出chart2、chart2的最大值和最大值对应的索引
print(chart2.replace(max(chart2),'ss')) # 将chart2的最大值替换为ss
chart3='john,23,2002.06.02' # 用max函数获取字母、数字和标点最大值，就是求他们谁的ASCII值最大
print(max(chart3[5:])) # 从字符串第5个元素开始获取最大的元素
print(max(chart3),min(chart3)) # 输出chart3的最大值和最小值
chart4='.,*56789ABCdeabcef~{' # 字母的ASCII编码值>数字的ASCII码值，标点符号的ASCII值范围较大
print(max(chart4)) # k的ASCII码是126，在这些元素中是最大的
print(max(chart4[-8:-2:2])) # 从字符串的最后一位开始到倒数第8个字符串，步进值为2获取最大元素
chart5='莱科宁358english' # 汉字的编码值比数字、字母和英文标点的值都大
print(max(chart5)) # '莱'的码值为33713，'科'的码值为31185，'宁'的码值为23425
print(max(x for x in range(10))) # 生成10以内的数字并获取最大值输出
锦囊2：在列表中使用max
在列表中有多种方法可以求最大值，max()是最方便、简单的方法。使用max函数获取列表最大值时，函数内部将对列表中的元素进行循环比较，然后返回列表元素最大的值，当存在多个相同的最大值时，返回的是最先出现的那个最大值。max()函数在列表中的常用应用如下：
listnum1=[1,3,5,7,9] # 创建整数数字列表
listnum2=[-10,-5,0,5,3,10,15,-20,25,-39,-123] # 创建包含负数的数字列表
print(max(listnum1)) # 输出listnum1的最大值
print(max(listnum2)) # 输出listnum2的最大值
print(max(listnum2,key=lambda x:abs(x))) # 获取listnum2列表中元素绝对值的最大值，abs()：绝对值函数
print(max(listnum2[2:7])) # 在列表第2项到第7项（不含第7项）求最大值
listcha1=['a','-5','b','c','d','5','3','e'] # 创建包含数字、字母的列表
print(max(listcha1)) # 小写字母的ASCII码值大于数字，并且按照字母排序递增
print(max(listcha1[1:5])) # 在列表第1项到第5项（不含第5项）求最大值
说明：我们可以通过设置命名参数key来指定取最大值的方法，key参数的另外一个作用是，通过设置适当的key函数，可以对不同类型的对象进行比较获取最大值。
list1 = ['20',5,10] # 元素为混合类型的列表
print(max(list1,key=int)) # 指定key为int函数后再取最大值
# 创建F1赛车车手积分列表，积分在后，目标练习对列表中数据不同位置元素求最大值
listcha2=['莱科宁 236','汉密尔顿 358','维泰尔 294','维斯塔潘 216','博塔斯 227']
# 创建F1赛车车手积分列表，积分在前
listcha3=['236 莱科宁','358 汉密尔顿','294 维泰尔','216 维斯塔潘','227 博塔斯']
print(max(listcha2)) # 输出为：莱科宁 236
print(max(listcha2[-3:-1])) # 输出为：维泰尔 294 在倒数第3个列表和倒数第2个列表查找最大值
print(max(listcha2,key=lambda x:x[-3:])) # 获取每个列表的倒数3个元素的最大值，即比较积分
print(max(listcha3)) # 输出为：358 汉密尔顿
# 取每个列表的第4项到最后一项的数据比较获得最大值，即获取姓名的最大值
print(max(listcha3,key=lambda x:(x[4:])))
# 创建汽车销量2维列表，内层列表中包含汽车销量和汽车名称
listcar = [[837624,'RAV4'],[791275,'途观'],[651090,'索罗德'],[1080757,'福特F系'],[789519,'高尔夫'],[747646,'CR-V'],[1181445,'卡罗拉']]
print(max(listcar)) # 输出列表listcar 的最大值
print(max(listcar,key=lambda x:x[1])) # 按照列表listcar的第2项（车名）进行迭代取最大值
# 创建NBA球员数据嵌套列表，嵌套列表中包含球员名称、出场场次、出场时间和平均得分
listnba= [['哈登',78,36.8,36.1],['乔治',77,36.9,28.0],['阿德托昆博',72,32.8,27.7],['恩比德',64,33.7,27.5],['詹姆斯',55,35.2,27.4],['库里',69,33.8,27.3]]
print(max(listnba)) # 输出列表listnba的最大值
print(max(listnba,key=lambda x:x[3])) # 按照列表的第4项，即球员的场平均分迭代取最大值
print(max(listnba,key=lambda x:(x[2],x[1],x[3]))) # 按照第3项出场时间迭代取最大值
print(max(listnba,key=lambda x:x[3]*x[1])) # 按球员平均得分和比赛场次的乘积（即总得分）迭代求最大值
print(max(listnba,key=lambda x:(str(x[3]))[1:])) # 按平均分的后3位迭代求最大值
# 创建学生考试成绩嵌套列表，嵌套列表包含考试名次、语文成绩、数学成绩、理综成绩、英语成绩。
liststud= [[1,101,128,278,123],[2,129,135,222,120],[3,127,138,227,107],[4,98,135,217,108],
[5,123,101,201,101],[6,89,125,197,90]]
print(max(liststud [1])) # 输出为：222,取第2个列表中元素的最大值
print(max(liststud,key=lambda x:x[1])) # 输出为：[2, 129, 135, 222, 120] 按照每个列表第2项迭代
print(max(liststud,key=lambda x:x[1]+x[2]+x[3]+x[4])) # 按每个列表元素的第2项到第5项的和迭代取最大值
锦囊3：在元组中使用max。
在元组中获取元素的最大值和列表相似，常用应用代码归纳如下：
tuple1=(2,4,8,16,32,64,128,256,512,1024) # 数字元祖
print(max(tuple1)) # 输出数字元祖中的最大值
print(max(tuple1[3:9])) # 输出数字元祖中第4个到第9个数值的最大值
tuple2=('Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sept','Oct','Nov','Dec','Mon','Tues','Wed','Thur','Fri') # 月份、星期简写元祖
print(max(tuple2)) # 输出tuple2的最大值（先比较元祖的第1个元素，如果相同，再比较第2个元素…）
print(max(tuple2,key=lambda x:len(x))) # 输出元祖中长度最大(即字符最多)的元祖
# NBA球队成绩元祖
tuple3=('勇士 57','掘金 54','开推者 53','火箭 53','爵士 50','雷霆 49','马刺 48','快船 48')
print(max(tuple3,key=lambda x:x[-2:])) # 获取元祖后两项数据的最大值，即获胜场次取最大值
tuple4=(('肖申克的救赎',1994,9.3),('教父',1972,9.2),('教父2',1974,9.1),('蝙蝠侠：黑暗骑士',2008,9.0),('低俗小说',1994,8.9)) # 电影信息元祖
print(max(tuple4,key=lambda x:x[1])) # 按每个元祖的第2项取最大值，即出品年份
print(max(tuple4,key=lambda x:x[2])[0]) # 按元祖的第3项（打分）取最大值，只输出最大值的第一个元素
tuple5=((90,128,87.103),(78,99,134.106),(98,102,133.80),(66,78,97,56),(98,123,88.79))
print(max(max(tuple5,key=lambda x:x[1]))) # 按照tuple5的第2项取最大值，然后在最大值中再取最大值
print(max(tuple5,key=lambda x:(x[0]+x[1]+x[2]))) # 按照元祖的3项之和获取最大值
print(max(tuple5,key=lambda x:(x[0],x[1]))) # 按元祖第1项和第2项取最大值，第一项相同，比较第2项
锦囊4：在字典中使用max。
使用max函数，默认情况下，字典迭代的是key（键值）。如果要迭代value，可以用可以直接指定，也可以通过for value in d.values()进行指定，还可以通过zip函数变换键与值位置进行指定。在利用字典求最大值时，经常要用到匿名函数key=ladmbo，需要注意的是：不论匿名函数怎么处理参数，返回的不是处理后的结果，而是结果对应的参数本身。Max在字典中的常用应用如下：
dict1 = {'name': 'john', 'age': 23,'money':1200,'gender':'male'} # 创建会员信息字典，name为会员姓名
dict2 = {'name': 'anne', 'age': 22,'money':1500,'gender':'female'} # 创建会员信息字典，age为会员年龄
dict3 = {'name': 'james', 'age': 33,'money':578,'gender':'male'} # 创建会员信息字典，money为会员账户积分
dict4 = {'name': 'nick', 'age': 46,'money':158,'gender':'male'} # 创建会员信息字典，gender为会员性别，male为男性，female为女性
dict5 = {'name': 'May', 'age': 18,'money':3210,'gender':'female'} # 创建会员信息字典
lsitdc=[dict1,dict2,dict3,dict4,dict5] # 创建2维会员信息字典
print(max(dict1)) # 默认获取键的最大值，即'name'、'age'、'money'和'gender'的最大值
# 将性别为女性的年纪最大的会员输出出来，一定要先限制性别，再按年纪取最大值，否则将按年纪排名，不区分性别。
print(max(list(filter(lambda item:item['gender'] == 'female',lsitdc)),key= lambda item:item['age']))
# 输出积分超过500，年龄最大的的会员
print(max(list(filter(lambda item:item['money']>500,lsitdc)),key=lambda item:item['age']))
print(max(lsitdc,key=lambda x:x['money'])) # 按积分输出最大者
print(max(lsitdc,key=lambda x:x['age']).get('name')) # 输出年龄最大会员，只输出名字
def dic_key(dic): # 编写函数dic_key，设置max函数的获取最大值的键
return dic['money'] # 设置'money'为max函数获取最大值的键
print(max(lsitdc,key=dic_key)) # 调用dic_key函数，获取字典中积分最高的会员
dictcar=[{'名称':'卡罗拉','销量':1181445},{'名称':'福特F系','销量':1080757},{'名称':'RAV4','销量':837624},{'名称':'思域','销量':823169},{'名称':'途观','销量':791275}]
print(max(dictcar,key=lambda x:x['名称'])) # 按照名称取最大值，即'卡罗拉'、'福特F系'等中取最大值
print(max(dictcar,key=lambda x:x['销量'])) # 按照销量取最大值，即1181445、1080757…等中取最大值
dictage={'李冰冰':'1996','张步韵':'1999','赵构':'1903','邱子丹':'2008','杨百风':'2012'}
print(max(dictage)) # 默认获取键的最大值，即'李冰冰'、'张步韵'…'杨百风'等的最大值
print(max(dictage.values())) # 希望用value取最大值，需要设定值（values）为迭代项
print(list(dictage.keys())[list(dictage.values()).index(max(dictage.values()))]) # 最大值对应的键
print(max(dictage.values())[-2:] ) # 获取value最大值项的后两个字符
print(max([x for x in dictage.keys()])) # 在字典中获取键（key）最大的项
print(max([x for x in dictage.values()])) # 在字典中获取值（value）最大的项
print(max(zip(dictage.values(), dictage.keys()))) # 用zip函数将字典的键和值调换位置，然后获取最大值
dictall={'大众':643518,'奔驰':319163,'宝马':265051,'福特':252323,'雪铁龙':227967,'雷诺':130825,'现代':114878,'奥迪':255300}
newdict=zip(dictall.values(),dictall.keys()) # 用zip函数将字典的键和值调换位置
print(max(newdict)) # 获取新生成字典的最大值
# 按位置置换后字典value取最大值
print(max(zip(dictall.values(),dictall.keys()),key=lambda x:x[1]))
5. 【获取可迭代对象（或元素）的最小值】min函数
语法参考
min()函数用于执行与max()函数相反的操作，用于获取指定的多个参数中的最小值或可迭代对象元素中的最小值。其语法格式如下：
min(iterable, *[, default=obj, key=func])
或
min(arg1, arg2, *args, *[, key=func])
参数说明：
-
iterable：可迭代对象，如字符串、列表、元组、字典等；
-
default：命名参数，用来指定最小值不存在时返回的默认值；
-
key：命名参数，其为一个函数，用来指定获取最小值的方法；
-
arg：指定数值；
-
返回值：返回给定参数的最小值。
说明：min()函数在参数使用上与max()函数基本一致，只是在执行上是与max()函数相反的操作。
6. 【获取两个数值的幂运算值】pow函数
语法参考
pow()函数用于返回两个数值的幂运算值，如果提供可选参数z的值，则返回幂乘结果之后再对z取模。其语法格式如下：
pow(x, y[, z])
参数说明：
-
x：必需参数，底数；
-
y：必需参数，指数；
-
z：可选参数，对结果取模。
-
返回值：结果返回x的y次方（相当于x**y），如果提供z的值，则返回结果之后再对z求余（相当于pow(x,y)%z）。
提示：如果参数x和y有一个是浮点数，则结果将转换成浮点数。如果参数x和y都是整数，则结果也是整数，除非参数y是负数；如果参数y是负数，则结果返回的是浮点数。浮点数不能取模，此时可选参数z不能传入值。
锦囊1：获取两个数值的幂运算值
通过pow()函数获取两个数值的幂运算值，示例代码如下：
# 参数x和y都是整数，则结果也是整数，除非y是负数，如果y是负数，则结果返回的是浮点数
print(pow(3,2)) # 相当于print(3**2)
print(pow(-2,7)) # x参数为负数
print(pow(2,-2)) # y参数为负数
# 参数x和y有一个是浮点数，则结果将转换成浮点数
print(pow(2,0.7))
print(pow(3.2,3))
锦囊2：获取幂运算值与指定整数的模值
通过pow()函数获取幂运算值与指定整数的模值，示例代码如下：
# 指定参数z的值，参数x和y必须为整数，且参数y不能为负数
print(pow(2,3,3)) # 相当于print(pow(2,3)%3)
注意：如果pow()函数中设置了可选参数z的值，则参数x和y必须为整数，且参数y不能为负数。否则将抛出异常，代码如下：
# 将提示ValueError: pow() 2nd argument cannot be negative when 3rd argument specified
print(pow(3, -2, 4))
# 将提示TypeError: pow() 3rd argument not allowed unless all arguments are integers
print(pow(3.2, 3, 2))
注意：pow()函数的所有参数必须是数值类型，否则将提示TypeError，代码如下：
# 将提示TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'int'
print(pow('3',2))
7. 【对数值进行四舍五入求值】round函数
语法参考
round()函数用于返回数值的四舍五入值，其语法格式如下：
round(number[, ndigits])
参数说明：
-
number：表示需要格式化的数值；
-
ndigits：可选参数，表示小数点后保留的位数；
-如果不提供ndigits参数（即只提供number参数），四舍五入取整，返回的是整数；
-如果把参数ndigits设置为0，则保留0位小数进行四舍五入，返回的值是浮点型。
-如果参数ndigits大于0，则四舍五入到指定的小数位；
-如果参数ndigits小于0，则对浮点数的整数部分进行四舍五入，参数ndigits用来控制对整数部分的后几位进行四舍五入，小数部分全部清0，返回类型是浮点数。如果传入的整数部分位数小于参数number的绝对值，则返回0.0； -
返回值：返回四舍五入值。
使用round()函数四舍五入的规则如下：
-
如果保留位数的后一位是小于5的数字，则舍去。例如，3.1415保留两位小数为3.14。
-
如果保留位数的后一位是大于5的数字，则进上去。例如，3.1487保留两位小数为3.15。
-
如果保留位数的后一位是5，且该位数后有数字，则进上去。例如，8.2152保留两位小数为8.22；又如8.2252保留两位小数为8.23。
-
如果保留位数的后一位是5，且该位数后没有数字。要根据保留位数的那一位来决定是进上去还是舍去：如果是奇数则进上去，如果是偶数则舍去。例如，1.35保留一位小数为1.4；又如1.25保留一位小数为1.2。
锦囊1： 小数点右侧四舍五入求值
使用round()函数对小数点右侧进行四舍五入求值，常见用法如下：
print(round(3.1415926)) # 不提供参数ndigits，四舍五入取整，返回的是整数
print(round(3.1415926, 0)) # 参数ndigits为0，保留0位小数进行四舍五入，返回的是浮点型
print(round(3.1415926, 3)) # 保留小数点后3位
print(round(-0.1233, 2)) # 保留小数点后2位
print(round(20 / 6, 2)) # 保留计算结果小数点后2位
print(round(10.15, 1)) # 保留小数点后1位
print(round(10.85, 1)) # 保留小数点后1位
注意：在使用round()函数对浮点数进行操作时，有时结果不像预期那样，比如round(2.675,2)的结果是2.67而不是预期的2.68，这不是bug，而是浮点数在存储的时候因为位数有限，实际存储的值和显示的值有一定误差。除非对浮点数精确度没什么要求，否则尽量避开用round()函数进行四舍五入求值。
锦囊2： 小数点左侧四舍五入求值
当round()函数的参数ndigits小于0时，则对浮点数的整数部分进行四舍五入，参数ndigits用来控制对整数部分的后几位进行四舍五入，小数部分全部清0，返回类型是浮点数。如果传入的整数部分位数小于参数number的绝对值，则返回0.0；常见用法如下：
print(round(23645.521,-1)) # 对整数部分的后几位进行四舍五入
print(round(23645.521,-2)) # 对整数部分倒数第二位以后的部分进行四舍五入
print(round(23645.521,-3)) # 对整数部分倒数第三位以后的部分进行四舍五入
print(round(23645.521,-6)) # 整数部分位数小于参数n的绝对值，返回0.0
锦囊3： 整数四舍五入求值
round()函数不仅可以对浮点数进行操作，还可以对整数进行操作，返回值为整型。代码如下：
print(round(23665)) # 对整数进行操作
print(round(23665,-2)) # 对整数倒数第二位进行操作
print(round(23665,-4)) # 对整数倒数第四为进行操作
8. 【对可迭代对象进行求和计算】sum函数
语法参考
sum()函数用于对列表、元组或集合等可迭代对象进行求和计算。其语法格式如下：
sum(iterable[, start])
参数说明：
-
iterable：可迭代对象，如列表、元组、range对象等；
-
start：可选参数，指定相加的参数（即序列值相加后再次相加的值），如果没有设置此参数，则默认为0；
-
返回值：求和结果。
注意：在使用sum()函数对可迭代对象进行求和时，需要满足参数必须为可迭代对象且可迭代对象中的元素类型必须是数值型，否则将提示TypeError。
锦囊1：列表元素求和
sum函数可以快速的将列表中所有的数值元素进行求和计算，然后将最后的求和结果返回。通过sum()函数对列表元素进行求和计算的常见用法如下：
a_list = [1,3,5,7,9] # 普通列表
print('a_list列表元素和为：',sum(a_list))
print('a_list列表元素和加1：',sum(a_list,1))
b_list = ['数学 98','语文 99','英语 97'] # 学生成绩列表
# 由于sum函数无法进行字符串的求和计算，所以需要先将指定元素转换为int类型
int_list = [int(b_list[0][2:]),int(b_list[1][2:]),int(b_list[2][2:]),]
print('学生的总成绩为：',sum(int_list),'分')
# 10名学生Python理论成绩列表
grade_list = ['98','99','97','100','100','96','94','89','95','100']
int_list = [int(i) for i in grade_list] # 循环将字符类型转换为int
print('Python理论总成绩为：',sum(int_list))
锦囊2：元组的元素求和
通过sum函数计算元组中元素和，与列表元素求和相似。sum()函数对元组元素进行求和计算的常见用法如下：
a_tuple = (10,20,30,33,54,21,11) # 普通元组
print('普通元组元素和为：',sum(a_tuple))
print('普通元组元素求和后加1：',sum(a_tuple,1))
print('元组中第二个元素至第五个元素的和为：',sum(a_tuple[1:5]))
print('元组中第五个元素以后的所有元素和为：',sum(a_tuple[5:]))
b_tuple = (('1月',2531),('2月',3352),('3月',1528)) # 某商品前三月销量
number_tuple = tuple(a[1] for a in b_tuple) # 将销量数据提取成元组
print('1月至3月总销量为：',sum(number_tuple))
print('最高销量与最低销量的总和为：',sum((max(number_tuple),min(number_tuple))))
锦囊3：range对象与空迭代对象的求和
在sun函数中计算range对象与空迭代对象的求和是比较特殊的，常见用法如下：
a_range = range(10) # 创建range对象
print('a_range对象的和为：',sum(a_range))
# 传入空列表对象，返回参数start值
print('空列表的和为：',sum([],10))
# 传入空元组对象，返回参数start值
print('空元组对象和为：',sum((),20))
# 传入空字典对象，返回参数start值
print('空字典对象和为：',sum({},30))
锦囊4：集合元素求和
集合也是一个比较特殊的可迭代对象，在集合中如果有相同的元素值将会被自动移除。sum()函数对集合元素进行求和计算的常见用法如下：
# 普通数值集合
a_set = {1,2,3,4,5,5,1}
# 由于集合会自动去除相同数值，所以总和为15
print('a_set集合中数值总和为：',sum(a_set))
# 由于最后相加的5为start参数，并不是集合中的元素所以不会被集合当做相同数值所去除
print('a_set集合中数值总和加5为：',sum(a_set,5))
# 由于集合并不支持指定某个元素，所以需要将集合转换为列表再进行元素范围的指定
print('a_set集合中第二个元素至第四个元素的和为：',sum(set(list(a_set)[1:5])))
# 元素为字符串类型的集合数据
b_set = {'158 厘米','179 厘米','211 厘米','158 厘米'}
# 由于集合不支持指定元素的提取所有需要转换为列表
b_list = list(b_set)
# 提取字符串数据中的数值数据并转换为int类型
int_list = list(int(i[0:3])for i in b_list)
# 在集合中相同的字符串元素也会被去除，所以集合数据中的总长度为548 厘米
print('集合数据中的总长度为：',sum(set(int_list)),'厘米')
# 字符串学生成绩集合数据
c_set = {'数学 118分','语文 119分','英语 116分'}
# 添加单个物理成绩
c_set.add('物理 68分')
# 添加列表到集合，列表元素会被分解为单个元素后添加到集合
c_set.update(['化学 47分','政治 59分','历史 60分','体育 30分'])
int_set = set(list(int(i[-4:-1]) for i in c_set))
print('该学生中考成绩为：',sum(int_set),'分')
扫一扫
8820
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
