Python函数（详解）

见贤思齐

文章目录一、Python基础1.1、函数加括号+函数不加括号1.2、数据类型：整型+浮点型+复数+布尔+空值+字符串1.3、数据结构：列表+元组+字典+集合1.4、数据类型（可变+不可变）1.4.1、可变-数据类型——可以在原地修改其内容，而不会创建新的对象（列表+集合+字典）1.4.2、不可变-数据类型——创建后不能修改其内容，每次修改都会生成一个新的对象（整数+浮点数+字符串+元组）1.5、序列——是一种有序的数据结构（字符串+列表+元组）1.6、容器（Container）——用于存储多个元素的对象（列表、元组、集合、字典）1.7、可迭代对象+迭代器+生成器1.7.1、可迭代对象（iterable）：列表+元组+集合+字典+字符串1.7.2、迭代器（iterator）1.7.3、生成器（yield）二、Python运算符2.1、算术运算符——用于执行基本的数学运算。2.2、关系运算符——用于比较两个值之间的关系。2.3、逻辑运算符——用于对布尔值进行操作。2.4、位运算符——用于对二进制数进行操作。2.5、成员运算符——用于检查指定的值是否存在于数据结构中。2.6、身份运算符——用于检查两个对象的内存地址是否相同，即它们是否引用同一个对象。2.7、三元条件运算符——用于根据条件的真假返回两个值中的一个。三、Python数据结构：列表、元祖、集合、字典、链表1、列表（list）的常用操作（15+9函数）——列表是一个有序可变序列。2、元组（tuple）的常用操作（7+9函数）——元组是一个有序不可变序列。3、集合（set）的常用操作（7+4函数）——集合是一个不重复元素的无序可变序列。4、字典（dict）的常用操作（14+4函数）——字典是一个无序可变序列。5、链表的常用操作（8个函数）——链表是一个非连续存储的线性表（节点=数据域+指针域）。四、Python数据类型：整型、浮点型、复数、布尔、空值、字符串4.1、整型int()：将指定进制（默认十进制）的一个字符串或数字（向下取整）转换为十进制整型（强转）。1、bin()：十进制整数转换为二进制码。返回值为字符串。2、ord()：ASCII字符转换为十进制整数（Unicode字符——Unicode数值）。3、chr()：将10进制或16进制数转换为ASCII字符。（Unicode数值——Unicode字符）。4.2、浮点型float()：将数字、字符串或布尔值转化为浮点数（强转）——只支持十进制输入和输出。4.3、复数complex()：将数字、字符串或布尔值转化为复数类型（强转）。4.4、字符串str()：将参数转换成字符串类型（强转）——字符串是一个有序不可变序列。【4.4.1、字符串的常用函数】1.1、str.join()：将序列（字符串、元组、列表、字典）中的元素以指定字符连接，并返回一个新的字符串。1.2、str.split()：通过指定分隔符（默认为空格）对字符串进行切片，并返回分割后的字符串列表（list）。1.3、str.count()：统计字符串里某个字符出现的次数。可以选择字符串索引的起始位置和结束位置。1.4、str.strip()：删除字符串（开头/结尾）指定字符（默认空格）或字符序列，但不能删除中间部分的字符。1.5、str.lstrip()：删除字符串左边指定字符（默认空格）。1.6、str.rstrip()：删除字符串右边指定字符（默认空格）。1.7、str.upper()：将字符串中所有小写字母转换为大写字母。若存在非字母字符，则正常显示。1.8、str.lower()：将字符串中所有大写字母转换为小写字母。若存在非字母字符，则正常显示。1.9、str.title()：将字符串中所有英文单词的首字母转换为大写，其余转字母换为小写。若存在非字母字符，则正常显示。1.10、str.ljust()：左对齐文本。向指定字符串的右侧填充指定字符。1.11、str.rjust()：右对齐文本。向指定字符串的左侧填充指定字符。1.12、str.center()：居中对齐文本。1.13、str.find()：查找字符串中，指定子串在指定范围内第一次出现的位置。若无，则返回-1。1.14、str.rfind()：查找字符串中，指定子串在指定范围内最后一次出现的位置。若无，则返回-1。1.15、str.index()：检测指定范围内的字符串中是否包含子串。若无，则系统报错。1.16、str.replace()：将指定字符或子串替换为另一种字符。原字符串不改变。1.17、str.endswith()：判断字符串中（可指定范围）是否以指定字符或子串结尾。返回bool值。【4.4.2、字符串的判断函数】1.1、str.isdigit()，str.isnumeric()，str.isdecimal()：检查字符串是否只包含十进制数字，返回布尔值。1.2、str.isupper()，str.islower()，str.istitle()：检测字符串的大小写，返回布尔值。1.3、str.isalpha()：检测字符串是否只有字母，返回布尔值。1.4、str.isalnum()：检测字符串是否只有字母和数字，返回布尔值。1.5、str.isspace()：判断字符串中是否只有空白字符（可以有多个空白字符），返回布尔值。五、Python函数5.1、高阶函数：sorted+map+filter+reduce+lambda+enumerate+zip+iter+next3.1、sorted()：对所有可迭代类型进行排序，不改变原始序列——按照ASCII的大小进行排序（数字>>大写字母>>小写字母）。3.2、map()：将指定函数依次作用于序列中的每一个元素——返回一个迭代器，结果需指定数据结构进行转换后输出。3.3、filter()：过滤掉不符合条件的元素——返回一个迭代器，结果需指定数据结构进行转换后输出。3.4、reduce()：取序列的前2个元素，执行指定函数，然后将结果与第3个元素继续传入函数，循环到最后一个元素——返回一个数值。3.5、匿名函数（lambda）：对输入参数进行表达式计算3.6、枚举函数（enumerate）：同时获取可迭代对象的索引和值——与for循环一起使用。3.7、组合序列（zip）：将多个可迭代对象的第i个元素组合在一起（压缩），得到一个元祖，最后输出N个元组——返回一个迭代器，结果需指定数据结构进行转换后输出。3.8、iter()：输入一个可迭代对象，将其转换成一个迭代器——与next()一起使用。3.9、next()：检索迭代器的下一个元素——与iter()、yield()一起使用5.2、通用函数1、input()：获取控制台（任意形式）的输入，输出为字符串。  1.1、int(input())与map(int,input().spilt())的区别  1.2、input()与list(input())的区别、及其相互转换方法2、print()：用于打印输出3、range()：输出指定范围内的所有值（前闭后开）4、len()：返回可迭代对象的长度（字符串、列表、字典、元组等）5、eval()：返回表达式的值——输入可以是任意类型，输出与输入类型一致5.3、数学函数+随机数函数+三角函数+数学常量1、数学函数  1.1、round()：四舍五入——支持保留小数点的指定位数  1.2、sum()：求和  1.3、abs()+fabs()：返回绝对值  1.4、开根号（四种方法）2、随机数函数3、三角函数4、数字常量文献参考一、Python基础1.1、函数加括号+函数不加括号函数名后面加括号(参数)：表示调用该函数；函数名后面不加括号：表示引用函数对象本身；importnumpyasnparray=np.array([[1,2,3],[4,5,6]])max_value1=np.max(array)#获取数组中的最大值max_value2=array.max#获取数组中的最大值max_value3=array.max()#获取数组中的最大值print(max_value1,max_value2,max_value3)"""66"""12345678910111213'运行运行1.2、数据类型：整型+浮点型+复数+布尔+空值+字符串整型（int）：表示整数，包括正整数和负整数。浮点型（float）：表示带有小数点的数值。如：科学记数法3.14E2=3.14*10^2=314复数（complex）：由实部和虚部构成的数值。如：a+bj=complex(a,b)布尔类型（bool）：表示逻辑值，包括True和False。True为1，False为0空值（None）：表示不存在的对象或尚未赋值的变量。字符串类型（str）：如：空字符串为False，非空字符串为True使用单引号（'hello'）或双引号（"python"）来创建字符串。字符串是由字符组成的序列，Python中没有单独的字符类型，字符也是字符串的一种。1.3、数据结构：列表+元组+字典+集合列表（list）：有序的可变序列。——可以存储任意类型的数据，使用方括号（[]）来创建，可以通过索引访问和修改其中的元素。元组（tuple）：有序的不可变序列。——可以存储任意类型的数据，使用圆括号（()）来创建，一旦创建后，不能修改其内容。字典（dict）：无序的键值对的集合。——用于存储具有映射关系的数据，使用花括号（{}）来创建，每个键值对由键和值组成，通过键来访问对应的值。集合（set）：无序的不重复元素的集合。——用于存储不重复的数据，使用花括号（{}）来创建，可以进行集合运算（交集、并集、差集等）。1.4、数据类型（可变+不可变）在Python中，数据类型可分为可变（mutable）和不可变（immutable）两种。1.4.1、可变-数据类型——可以在原地修改其内容，而不会创建新的对象（列表+集合+字典）可变数据类型（Mutable）：可以在原地修改其内容，而不会创建新的对象。如：列表、集合、字典。#列表list1=[1,2,3]print("Beforemodification:",id(list1))#Beforemodification:2410633776192list1.append(4)#在原地修改列表aprint("Aftermodification:",id(list1))#Aftermodification:2410633776192#集合set1={1,2,3}print("Beforemodification:",id(set1))#Beforemodification:2410634053440set1.add(4)#在原地修改集合print("Aftermodification:",id(set1))#Aftermodification:2410634053440#字典dict1={'a':1,'b':2}print("Beforemodification:",id(dict1))#Beforemodification:2410633737344dict1['c']=3#在原地修改字典print("Aftermodification:",id(dict1))#Aftermodification:2410633737344123456789101112131415161718'运行运行1.4.2、不可变-数据类型——创建后不能修改其内容，每次修改都会生成一个新的对象（整数+浮点数+字符串+元组）不可变数据类型（Immutable）：一旦创建就不能修改其内容，每次对不可变对象进行修改操作，都会生成一个新的对象。如：整数、浮点数、字符串、元组。#整数int1=10print("Beforemodification:",id(int1))#Beforemodification:1660585536080int1+=1#将整数a加1，实际上是创建了一个新的整数对象print("Aftermodification:",id(int1))#Aftermodification:1660585536112#浮点数float1=3.14print("Beforemodification:",id(float1))#Beforemodification:1660590708464float1*=2#将浮点数b乘2，实际上是创建了一个新的浮点数对象print("Aftermodification:",id(float1))#Aftermodification:1660594531152#字符串string1="hello"print("Beforemodification:",id(string1))#Beforemodification:1660594841840string1+="world"#将字符串s连接上"world"，实际上是创建了一个新的字符串对象print("Aftermodification:",id(string1))#Aftermodification:1660594842032#元组tuple1=(1,2,3)print("Beforemodification:",id(tuple1))#Beforemodification:1660592804416tuple1+=(4,5)#将元组t与(4,5)进行连接，实际上是创建了一个新的元组对象print("Aftermodification:",id(tuple1))#Aftermodification:1660590584592123456789101112131415161718192021222324'运行运行1.5、序列——是一种有序的数据结构（字符串+列表+元组）在Python中，序列是一种有序的数据结构，提供了丰富的方法和操作符来进行元素访问、添加、删除、切片等操作。序列的特点：（1）有序性：序列中的元素按照特定的顺序排列，每个元素都有一个唯一的位置或索引。字符串（有序不可变序列）元组（有序不可变序列）列表（有序可变序列）：range类型：list(range(10))map类型：list(map(int,[23.2,33.1]))（2）可变性：某些序列是可变的，可以修改其中的元素（如列表），而另一些序列是不可变的，无法修改其中的元素（如元组、字符串）。（3）可迭代性：序列可以被迭代遍历。如：使用for循环遍历序列中的每个元素。1.6、容器（Container）——用于存储多个元素的对象（列表、元组、集合、字典）容器（Container）：用于存储多个元素的对象。如：列表、元组、集合、字典。两种容器类型：有序容器：元素按照一定顺序排列的容器。有序可变容器：列表有序不可变容器：元组无序容器：元素没有固定顺序的容器。无序可变容器：集合（无序可变容器）——集合中的元素是不可变的，但可以通过添加或删除元素而改变字典（无序可变容器）——字典中的键是不可变的，但可以通过添加或删除键而改变无序不可变容器：无1.7、可迭代对象+迭代器+生成器可迭代对象（iterable）不是迭代器，使用iter()函数可以将可迭代对象转为迭代器。迭代器（iterator）是可迭代对象的一种特殊形式生成器（yield）本质上是一个迭代器Python中的for循环就是基于可迭代对象和迭代器实现的，它能够遍历容器对象中的每一个元素。"""使用内置函数isinstance判断对象为可迭代对象or迭代器"""fromcollectionsimportIterable,Iteratorprint(isinstance([],Iterable)) #Trueprint(isinstance([],Iterator)) #False。因为list还没有被转为迭代器，仅是可迭代对象123456#（1）可迭代对象iterable_obj=[1,2,3,4,5]#使用for循环迭代print("iterableobject:")foriteminiterable_obj:print(item)###################################################（2）迭代器————使用iter()函数将可迭代对象转为迭代器。iterator_obj=iter(iterable_obj)#使用next()函数逐个访问元素print("iteratorobject:")print(next(iterator_obj))#输出第一个元素：1print(next(iterator_obj))#输出第二个元素：2print(next(iterator_obj))#输出第三个元素：312345678910111213141516'运行运行python：可迭代对象、迭代器、生成器（全解）1.7.1、可迭代对象（iterable）：列表+元组+集合+字典+字符串可迭代对象（iterable）：通过迭代（循环）访问其元素的对象。包括：列表、元组、集合、字典、字符串。可迭代对象的两种访问方式：（1）__iter__()方法，迭代元素。如：forindexinobject（2）__getitem__()方法，访问元素。如：object[index]classMyIterable1:#（1）使用__iter__()方法迭代访问：def__init__(self,data):self.data=datadef__iter__(self):returniter(self.data)classMyIterable2:#（2）使用__getitem__()方法访问元素：def__init__(self,data):self.data=datadef__getitem__(self,index):returnself.data[index]def__len__(self):returnlen(self.data)if__name__=="__main__":my_iterable1=MyIterable1([1,2])#创建一个可迭代对象foriteminmy_iterable1:print("my_iterable1",item)my_iterable2=MyIterable2([1,2])#创建一个可迭代对象foriinrange(len(my_iterable2)):print("my_iterable2",my_iterable2[i])"""my_iterable11my_iterable12my_iterable21my_iterable22"""12345678910111213141516171819202122232425262728293031323334353637'运行运行1.7.2、迭代器（iterator）迭代器（iterator）：是一种对象，它实现了迭代协议。用于在迭代过程中逐个返回其元素，而不需要在内存中同时存储所有元素。迭代器对象具有两个方法：（1）__iter__()方法：返回迭代器本身，以便在for循环等上下文中使用。（2）__next__()方法：返回迭代器的下一个元素；若没有下一个元素，则引发StopIteration异常。classMyIterator:def__init__(self,data):self.data=dataself.index=0def__iter__(self):#返回迭代器对象自身returnselfdef__next__(self):ifself.index>=len(self.data):#如果已经遍历完所有元素，则抛出StopIteration异常raiseStopIterationelse:#返回下一个元素，并将索引指向下一个位置result=self.data[self.index]self.index+=1returnresultif__name__=="__main__":#创建一个可迭代对象my_iterable=MyIterator([1,2])#（1）使用for循环迭代元素foriteminmy_iterable:print("my_iterable",item)#（2）使用next()函数遍历迭代器whileTrue:print(next(my_iterable))"""my_iterable1my_iterable2Traceback(mostrecentcalllast):File"F:\py\main222.py",line31,inprint(next(my_iterable))File"F:\py\main222.py",line13,in__next__raiseStopIterationStopIteration"""1234567891011121314151617181920212223242526272829303132333435363738394041421.7.3、生成器（yield）生成器（yield）：是一种特殊类型的迭代器。在需要时逐个生成值，而不是一次性生成所有值并将它们存储在内存中。生成器函数：使用yield语句返回一个值，但是并不结束函数的执行，而是将函数的状态保存下来，以便下次调用next()函数时从上次yield语句的位置继续执行。每次调用生成器函数时，它会返回一个生成器对象。生成器用关键字yield返回值，而普通函数用return返回值。生成器对象：可以通过next()函数来获取下一个值。defmy_generator():yield1yield2yield3if__name__=="__main__":#创建一个生成器对象gen=my_generator()#使用next()函数获取生成器的值print(next(gen))#输出：1print(next(gen))#输出：21234567891011121314'运行运行二、Python运算符2.1、算术运算符——用于执行基本的数学运算。序列运算符名称说明举例结果数据类型【1】+加（1）对于数字：求和。c=1+2c=3int型【1】+加（2）对于序列类型（如：字符串）：拼接操作str='a'+'b'str='ab'字符串型2-减求差值c=1-2c=-1int型【3】*乘（1）对于数字：求积。c=2*3c=6int型【3】*乘（2）对于序列类型（如：字符串）：重复操作str='a'*3str='aaa'字符串型4/除求商（两个整数或浮点数相除，结果为float型）c=3/2c=1.5浮点型5%取模求余数c=3%2c=1int型6**幂运算求次幂c=3**2c=9int型【7】//地板除法（向下取整）两个整数相除，结果为int型c=3//2c=1int型【7】//地板除法（向下取整）除数或被除数为float类型，结果为float型c=3//2.0c=1.0浮点型a=10b=3print("加法:",a+b)#输出:13print("减法:",a-b)#输出:7print("乘法:",a*b)#输出:30print("除法:",a/b)#输出:3.3333333333333335print("取模:",a%b)#输出:1print("幂运算:",a**b)#输出:1000############################################################print("加法（序列）:","a"+"b")#输出:abprint("乘法（序列）:","a"*3)#输出:aaa############################################################print("地板除法（向下取整）:",a//b)#输出:3print("地板除法（向下取整）:",a//float(b))#输出:3.0123456789101112131415'运行运行2.2、关系运算符——用于比较两个值之间的关系。常见的关系运算符包括：等于（==）：判断两个值是否相等，若相等则返回True，否则返回False。不等于（!=）：判断两个值是否不相等，若不相等则返回True，否则返回False。大于（>）：判断左边的值是否大于右边的值，若成立则返回True，否则返回False。小于（=）：判断左边的值是否大于或等于右边的值，若成立则返回True，否则返回False。小于等于（y)#大于 Falseprint(x=y)#大于等于 Falseprint(x>）：将一个数的所有位向右移动指定的位数，左侧空出的位取决于原来的数是正数还是负数。正数用0填充，负数用1填充。x=0b1010#十进制为10y=0b1100#十进制为12print(bin(x&y))#按位与 0b1000print(bin(x|y))#按位或 0b1110print(bin(x^y))#按位异或 0b110print(bin(~x))#按位取反 -0b1011print(bin(x<< 2)) # 左移 0b101000 print(bin(y >>1))#右移 0b110123456789'运行运行2.5、成员运算符——用于检查指定的值是否存在于数据结构中。常见的成员运算符包括：存在（in）：若指定的值存在于数据结构中，则返回True，否则返回False。不存在（notin）：若指定的值不存在于数据结构中，则返回True，否则返回False。my_list=[1,2,3,4,5]print(3inmy_list)#Trueprint(3notinmy_list)#False1234'运行运行2.6、身份运算符——用于检查两个对象的内存地址是否相同，即它们是否引用同一个对象。常见的身份运算符包括：地址相同（is）：若两个变量引用同一个对象，则返回True，否则返回False。地址不相同（isnot）：若两个变量引用的不是同一个对象，则返回True，否则返回False。x=[1,2,3]y=[1,2,3]z=xprint(xisy)#False，虽然值相同，但是它们引用的是不同的对象print(xisz)#True，变量x和z引用的是同一个对象print(xisnoty)#Trueprint(xisnotz)#False12345678'运行运行2.7、三元条件运算符——用于根据条件的真假返回两个值中的一个。基本形式为：value_if_trueifconditionelsevalue_if_false其中，condition是一个表达式，若结果为真，则返回value_if_true；否则返回value_if_false。x=5result="even"ifx%2==0else"odd"print(result) #输出dd，因为5是奇数123'运行运行三、Python数据结构：列表、元祖、集合、字典、链表1、列表（list）的常用操作（15+9函数）——列表是一个有序可变序列。一般来说，有序序列类型都支持索引，切片，相加，相乘，成员操作。不可变数据类型：布尔类型（bool）、整型（int）、字符串（str）、元组（tuple）可变数据类型：列表（list）、集合（set）、字典（dict）序号函数说明0list1=[]创建空列表0list1=list()创建空列表1list2=[元素]创建列表。输入参数可以是任意类型1list2=list(元素)创建列表。输入参数可以是任意类型——————2list[index]索引（负数表示倒叙）3list[start,end]切片（获取指定范围元素）4list[::-1]逆序输出（步长为1）——————5list.append(元素)在列表末尾添加任意类型的一个元素6list.extend(元素)添加可迭代序列7list.insert(index,元素)在指定位置插入一个元素——————8list.remove(元素)删除指定元素。（1）若有多个相同元素，则只删除第一个元素。（2）若不存在，则系统报错。9list.pop(index)删除指定位置元素。默认删除最后一项。10dellist(index)删除指定位置元素11list.clear()清空内容，返回空列表——————12list.index(元素)索引元素位置。（1）若有多个相同元素，则只返回第一个元素的位置。（2）若不存在，则系统报错。13list.count(元素)计算指定元素出现的次数14list.reverse()逆序输出15list.sort(*,key=None,reverse=False)（1）默认从小到大排列。（2）reverse=True表示从大到小排序。——————（1）len(list)元素个数（2）type(list)查看数据类型（3）max(list)返回最大值（不能有嵌套序列）（4）min(list)返回最小值（不能有嵌套序列）（5）list(tuple)将元组转换为列表（6）list1+list2+操作符（拼接）（7）list*3*操作符（重复）（8）元素inlist（in/notin）成员操作符（判断给定值是否在序列中）（9）foriinlist:遍历2、元组（tuple）的常用操作（7+9函数）——元组是一个有序不可变序列。（1）Python的元组与列表类似，不同之处在于元组的元素不能修改（不可变）。所谓元组不可变是指元组所指向的内存中的内容不可变。（2）元组使用小括号()，列表使用方括号[]。（3）一般来说，有序序列类型都支持索引，切片，相加，相乘，成员操作。（4）元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用。如：整型：tup1=(50)、元组：tup1=(50,)不可变数据类型：布尔类型（bool）、整型（int）、字符串（str）、元组（tuple）可变数据类型：列表（list）、集合（set）、字典（dict）序号函数说明0tuple1=()创建空元组0tuple1=tuple()创建空元组1tuple2=(元素)创建列表。输入参数可以是任意类型——————2tuple[index]索引（负数表示倒叙）3tuple[start,end]切片（获取指定范围元素）4tuple[::-1]逆序输出（步长为1）——————5deltuple删除整个元组，不可以指定元素。删除后若打印变量，则系统报错（未定义）。——————6tuple.index(元素)索引元素位置。（1）若有多个相同元素，则只返回第一个元素的位置。（2）若不存在，则系统报错。7tuple.count(元素)计算指定元素出现的次数——————（1）len(tuple)元素个数（2）type(tuple)查看数据类型（3）max(tuple)返回最大值（不能有嵌套序列）（4）min(tuple)返回最小值（不能有嵌套序列）（5）list(iterable)将可迭代系列转换为元组。（6）tuple1+tuple2+操作符（拼接）（7）tuple*3*操作符（重复）（8）元素intuple（in/notin）成员操作符（判断给定值是否在序列中）（9）foriintuple:遍历3、集合（set）的常用操作（7+4函数）——集合是一个不重复元素的无序可变序列。无序：赋值后，各元素位置将随机输出。不重复：赋值变量时，若存在重复元素，系统会自动去除，只保留一个。set(str)对字符串去重set(tuple)对元组去重set(list)对列表去重。备注：字符串、元祖、列表是有序序列。备注：无法对无序序列进行去重。序号函数说明0set1=set()创建空集合1set2={元素1,元素2}创建集合1set2=set({元素1,元素2})创建集合。输入参数可以是任意类型——————2set.add(元素)（只能添加一个元素）将元素添加到集合中。若元素存在，则不进行任何操作。3set.update(元素)（添加多个元素）将元素添加到集合中。（1）参数可以是列表，元组，字典等。（2）若是字符串，将按字符拆分后再添加。4set.copy()浅拷贝——————4set.remove(元素)删除指定元素。若元素不存在，则系统报错。5set.discard(元素)删除指定元素。若元素不存在，则不进行任何操作。6set.pop()随机删除一个元素。（1）对集合进行无序排列，然后删除第一个元素。（2）若指定元素，则系统报错。7set.clear()清空内容，返回空集合——————（1）len(set)元素个数（2）type(set)查看数据类型（3）元素inset（in/notin）成员操作符（判断给定值是否在序列中）（4）foriinset:遍历4、字典（dict）的常用操作（14+4函数）——字典是一个无序可变序列。（2）键必须是唯一的（不可变数据类型），但值可以取任意数据类型。（3）不支持索引、切片、重复和连接操作。不可变数据类型：布尔类型（bool）、整型（int）、字符串（str）、元组（tuple）可变数据类型：列表（list）、集合（set）、字典（dict）序号函数说明0dict1={}创建空字典0dict1=dict()创建空字典1dict2={key1:value1,key2:value2}创建字典1dict2=dict({key:value,key2:value2})创建字典——————2dict.keys()查看字典中所有的key值3dict.values()查看字典中所有的value值4dict.items()查看字典中所有的key-value值5dict(key)获取指定key对应的value值。若key值不存在，程序会报错。6dict.get(key,default=None)获取指定key对应的value值。若key不存在，返回设置的default。7dict.copy()浅拷贝——————8dict(key)=value若key存在，更新value值。若不存在，新增key-value值。9dict1.update(dict2)添加元素（可同时添加多对）。若key存在，则更新value值。10dict.setdefault(key,default=None)若key存在，既不新增也不更新value值。若key不存在，将会添加键，并将value值设为default。——————11dict.pop(key)弹出指定的key-value值12dict.popitem()删除最后一个key-value13dict.clear()清空字典内容，返回空字典14deldict[key]删除指定的key-value值。——————（1）len(dict)列表元素个数（2）type(dict)查看数据类型（3）'key1'indictor'key1'indict.keys判断给定值是否在字典的key中（默认：dict.keys()）（4）'value1'indict.values()判断给定值是否在字典的value中（5）'dict.has_key('name')判断字典中是否有指定的key元素（5）foriindict:遍历字典的key值（默认：dict.keys()）5、链表的常用操作（8个函数）——链表是一个非连续存储的线性表（节点=数据域+指针域）。在C/C++中，通常采用指针+结构体来实现链表；而在Python中，则采用引用+类来实现链表。常用的数据结构：数组、链表(一对一)、栈和队列、哈希表、树(一对多)、图(多对多)。列表与链表的对比链表（LinkedList）是一种线性表数据结构，使用一组任意的存储单元（不是进行连续存储的。），来存储一组具有相同类型的数据。链表：由多个元素组成，每个元素都是一个对象，每个对象称为一个节点。每个节点包含两个部分：左边存储着自定义数据（数据域），右边存储着下一个节点的链接地址（指针域）。通过各个节点之间的相互连接，最终串联成一个链表。（1）单链表：它的每个链节点指向下一个链节点。（2）双向链表（DoublyLinkedList）：它的每个链节点中有两个指针，分别指向直接后继和直接前驱。（3）循环链表（CircularLinkedList）：它的最后一个链节点指向第一个链节点，形成一个环。链表的常见操作链表的常见操作说明is_empty()链表是否为空length()链表长度travel()遍历整个链表add(item)链表头部添加元素append(item)链表尾部添加元素insert(pos,item)指定位置添加元素remove(item)删除节点search(item)查找节点是否存在算法实现步骤+图解具体代码：classNode(object):"""单链表的节点类，即ListNode类。定义了两个实例变量"""def__init__(self,elem):self.elem=elemself.next=NoneclassSingleLinkList(object):"""单链表的链表类，即LinkedList类。定义了常用操作"""def__init__(self,node=None):self.__head=nodedefis_empty(self):"""判断链表是否为空"""returnself.__headisNonedeflength(self):"""链表长度"""cursor=self.__headcount=0whilecursorisnotNone:count+=1cursor=cursor.nextreturncountdeftravel(self):"""遍历链表"""cursor=self.__headwhilecursorisnotNone:print(cursor.elem,end='')cursor=cursor.nextdefadd(self,elem):"""链表头部添加元素"""node=Node(elem)node.next=self.__headself.__head=nodedefappend(self,elem):"""链表尾部添加元素"""node=Node(elem)ifself.is_empty():self.__head=nodeelse:cursor=self.__headwhilecursor.nextisnotNone:cursor=cursor.nextcursor.next=nodedefinsert(self,pos,elem):"""在指定位置插入元素"""node=Node(elem)ifpos(self.length()-1):self.append(elem)else:cursor=self.__headcount=0whilecount'''1234567'运行运行2、ord()：ASCII字符转换为十进制整数（Unicode字符——Unicode数值）。函数说明：ord(字符)print(ord('A'))print(type(ord('A')))'''65'''1234567'运行运行3、chr()：将10进制或16进制数转换为ASCII字符。（Unicode数值——Unicode字符）。函数说明：chr(number)print(chr(97))print(type(chr(97)))'''a'''1234567'运行运行4.2、浮点型float()：将数字、字符串或布尔值转化为浮点数（强转）——只支持十进制输入和输出。函数说明：float(object)输入参数：object：整数、字符串、布尔值（若没有输入参数，则float=0.0）备注1：当非十进制的字符串作为参数时，若超出数字字符时会报错。比如：float('2a1')备注2：不能进行不同进制之间的转换，否则系统报错。与int()完全不同。print('空输入参数',float())print('整数转换为浮点数',float(5))print('浮点数转换为浮点数',float(-5.5))print('字符串转换为浮点数',float('-5.5'))print('布尔值转换为浮点数',float(True))'''空输入参数0.0整数转换为浮点数5.0浮点数转换为浮点数-5.5字符串转换为浮点数-5.5布尔值转换为浮点数1.0'''12345678910111213'运行运行4.3、复数complex()：将数字、字符串或布尔值转化为复数类型（强转）。复数由实数和虚数构成，其实部a和虚部b都是浮点型。返回值是复数类型。函数说明：a+bj或complex(a,b)4.4、字符串str()：将参数转换成字符串类型（强转）——字符串是一个有序不可变序列。函数说明：str(x,base=10)一般来说，有序序列类型都支持索引，切片，相加，相乘，成员操作。print('返回空字符串:',str())print('整数转换为字符串:',str(-23))print('浮点数转换为字符串:',str(1.3e2))print('返回空字符串:',type(str()))print('整数转换为字符串:',type(str(-23)))print('浮点数转换为字符串:',type(str(1.3e2)))print('列表转换为字符串:',str([12,'-23.1','Python']))print('元组转换为字符串:',str((23,'9we',-8.5)))print('字典转换为字符串:',str({'Huawei':'China','Apple':'USA'}))print('集合转换为字符串:',str({'China','Japan','UK'}))'''返回空字符串:整数转换为字符串:-23浮点数转换为字符串:130.0返回空字符串:整数转换为字符串:浮点数转换为字符串:列表转换为字符串:[12,'-23.1','Python']元组转换为字符串23,'9we',-8.5)字典转换为字符串:{'Huawei':'China','Apple':'USA'}集合转换为字符串:{'China','UK','Japan'}'''123456789101112131415161718192021222324252627'运行运行【4.4.1、字符串的常用函数】1.1、str.join()：将序列（字符串、元组、列表、字典）中的元素以指定字符连接，并返回一个新的字符串。函数说明：'Separator'.join(Sequence)功能说明：以Separator为分隔符，对Sequence所有元素进行逐个分割，并返回一个新的字符串。输入参数：Separator：代表分隔符。可以是单个字符（如：''、','、'.'、'-'、'*'等），也可以是字符串（如:'abc'）。Sequence：代表要连接的元素序列。可以是字符串、元组、列表、字典。备注1：Separator和Sequence都只能是string型，不能是int型和float型，否则系统报错。备注2：字典的读取是随机的。a1='ILoveChina!'print('字符串:',''.join(a1))a11='ILoveChina!'print('字符串:',''.join(a11))a2=['I','Love','China','!']print('列表:',''.join(a2))a3=('I','Love','China','!')print('元祖:',''.join(a3))a4={'I':1,'Love':2,'China':3,'!':4}print('字典:',''.join(a4))'''字符串:ILoveChina!字符串:ILoveChina!列表:ILoveChina!元祖:ILoveChina!字典:ILoveChina!'''12345678910111213141516171819202122'运行运行importos #导入路径模块os.getcwd() #获取当前路径data_save=os.path.join(os.getcwd(),'data_save')#获取当前路径并组合新的路径print(data_save)1234'运行运行1.2、str.split()：通过指定分隔符（默认为空格）对字符串进行切片，并返回分割后的字符串列表（list）。函数说明：str.split(str=".",num=string.count(str))[n]参数说明：str：表示分隔符，默认为空格，但是不能为空。若字符串中没有分隔符，则把整个字符串作为列表的一个元素。num：表示分割次数。如果存在参数num，则仅分隔成num+1个子字符串，并且每一个子字符串可以赋给新的变量。[n]：表示选取第n个切片。注意：当使用空格作为分隔符时，对于中间为空的项会自动忽略。s='www.dod.com.cn'print('分隔符(默认):',s.split())#【输出结果】分隔符(默认):['www.dod.com.cn']print('分隔符(.):',s.split('.'))#【输出结果】分隔符(.):['www','dod','com','cn']print('分割1次,分隔符(.):',s.split('.',1))#【输出结果】分割1次,分隔符(.):['www','dod.com.cn']print('分割2次,分隔符(.):',s.split('.',2))#【输出结果】分割2次,分隔符(.):['www','dod','com.cn']print('分割2次,分隔符(.),取出分割后下标为1的字符串:',s.split('.',2)[1])#【输出结果】分割2次,分隔符(.),取出分割后下标为1的字符串:dodprint(s.split('.',-1))#【输出结果】['www','dod','com','cn']############################################分割2次,并分别保存到三个变量s1,s2,s3=s.split('.',2)print('s1:',s1)#【输出结果】s1:wwwprint('s2:',s1)#【输出结果】s2:wwwprint('s3:',s2)#【输出结果】s3:dod############################################连续多次分割a='HelloBye'print(a.split('['))#【输出结果】['HelloBye']print(a.split('[')[1].split(']')[0])#【输出结果】www.dodo.com.cnprint(a.split('[')[1].split(']')[0].split('.'))#【输出结果】['www','dodo','com','cn']12345678910111213141516171819'运行运行1.3、str.count()：统计字符串里某个字符出现的次数。可以选择字符串索引的起始位置和结束位置。函数说明：str.count("char",start,end)或str.count("char")参数说明：str：为要统计的字符（可以是单字符，也可以是多字符）。start：为索引字符串的起始位置，默认参数为0。end：为索引字符串的结束位置，默认参数为字符串长度即len(str)。str_temp="ilovepython,iamlearningpython"print(str_temp.count("i"))#【输出结果】3#单字符统计：start和end为默认参数print(str_temp.count("i",2))#【输出结果】2#单字符统计：star=2，end值为默认参数print(str_temp.count("i",0,5))#【输出结果】1#单字符统计：star=2，end=5################################################################################################print(str_temp.count("py"))#【输出结果】2#多字符统计：start和end为默认参数123456'运行运行1.4、str.strip()：删除字符串（开头/结尾）指定字符（默认空格）或字符序列，但不能删除中间部分的字符。函数说明：str3=str1.strip(str2)其中，str1是操作字符串，str2是待移除指定的字符或字符序列。str3是移除后生成的新字符串。str_temp1="123ABCDEFG321"str_temp2="123ABCDEFG321"str_temp3="123ABCDEFG321"print(str_temp1.strip())#【输出结果】"123ABCDEFG321"print(str_temp2.strip('12'))#【输出结果】"3ABCDEFG321"print(str_temp3.strip('3'))#【输出结果】"123ABCDEFG321"123456'运行运行1.5、str.lstrip()：删除字符串左边指定字符（默认空格）。txt_temp1="_hello_world_"print(txt_temp1.rstrip('_'))#【输出结果】"_hello_world"12'运行运行1.6、str.rstrip()：删除字符串右边指定字符（默认空格）。txt_temp2="_hello_world_"print(txt_temp2.rstrip(''))#【输出结果】"_hello_world_"12'运行运行1.7、str.upper()：将字符串中所有小写字母转换为大写字母。若存在非字母字符，则正常显示。str_temp="ILOVEpython"print(str_temp.upper())#【输出结果】ILOVEPYTHON12'运行运行1.8、str.lower()：将字符串中所有大写字母转换为小写字母。若存在非字母字符，则正常显示。str_temp="ILOVEpython"print(str_temp.lower())#【输出结果】ilovepython12'运行运行1.9、str.title()：将字符串中所有英文单词的首字母转换为大写，其余转字母换为小写。若存在非字母字符，则正常显示。str_temp="ILOVEpython"print(str_temp.title())#【输出结果】ILovePython12'运行运行1.10、str.ljust()：左对齐文本。向指定字符串的右侧填充指定字符。函数说明：str.ljust(width,fillchar)输入参数：str：表示要进行填充的字符串；width：表示包括str本身长度在内，字符串要占的总长度；fillchar：指定填充字符串时所用的字符，默认情况使用空格（可选参数）。S='www.baidu.com'addr='http://www.baidu.com'print(S.ljust(35,'-')) #【输出结果】www.baidu.com--------------------print(addr.ljust(35,'-')) #【输出结果】http://www.baidu.com-------------1234'运行运行1.11、str.rjust()：右对齐文本。向指定字符串的左侧填充指定字符。函数说明：str.rjust(width,fillchar)输入参数：str：表示要进行填充的字符串；width：表示包括str本身长度在内，字符串要占的总长度；fillchar：指定填充字符串时所用的字符，默认情况使用空格（可选参数）。S='http://www.baidu.com/python'addr='http://www.baidu.com'print(S.rjust(35,'-')) #【输出结果】-----http://www.baidu.com/pythonprint(addr.rjust(35,'-')) #【输出结果】------------http://www.baidu.com1234'运行运行1.12、str.center()：居中对齐文本。函数说明：str.center(width,fillchar)输入参数：str：表示要进行填充的字符串；width：表示包括str本身长度在内，字符串要占的总长度；fillchar：指定填充字符串时所用的字符，默认情况使用空格（可选参数）。S='http://www.baidu.com/python/'addr='http://www.baidu.com'print(S.center(35,'-')) #【输出结果】----http://www.baidu.com/python/---print(addr.center(35,'-')) #【输出结果】--------http://www.baidu.com-------1234'运行运行1.13、str.find()：查找字符串中，指定子串在指定范围内第一次出现的位置。若无，则返回-1。函数说明：str.find(sub,start,end)输入参数：sub：指定的子串start：索引的起始位置。默认值为0。end：索引的结束位置。默认值为字符串长度len(str)。str1='123xyzzaraabc'print(str1.find('z')) #结果512'运行运行1.14、str.rfind()：查找字符串中，指定子串在指定范围内最后一次出现的位置。若无，则返回-1。函数说明：str.find(sub,start,end)输入参数：sub：指定的子串start：索引的起始位置。默认值为0。end：索引的结束位置。默认值为字符串长度len(str)。str1='123xyzzaraabc'print(str1.rfind('z')) #结果612'运行运行1.15、str.index()：检测指定范围内的字符串中是否包含子串。若无，则系统报错。函数说明：str.index(sub,start,end)输入参数：sub：指定的子串start：索引的起始位置。默认值为0。end：索引的结束位置。默认值为字符串长度len(str)。A='123xyzzaraabc'print(A.index('xyz')) #结果3print(A.index('zzz')) #报错：ValueError:substringnotfound1231.16、str.replace()：将指定字符或子串替换为另一种字符。原字符串不改变。函数说明：str.replace('old_str','new_str',count)输入参数：old_str：指定待替换的字符或子串new_str：替换的字符或子串count：替换的次数，默认全部替换。备注：当查看字符串时，发现原字符串并没有发生改变，说明str.replace()函数并不对原有的字符串进行改变。str1='1112QQQQQQ444QQQ'str1.replace('1','5') #不改变原字符串 print(str1)str2=str1.replace('1','5') #默认全部替换print(str2)str3=str1.replace('Q','g',7) #指定替换次数print(str3)'''1112QQQQQQ444QQQ5552QQQQQQ444QQQ1112gggggg444gQQ'''123456789101112131415'运行运行1.17、str.endswith()：判断字符串中（可指定范围）是否以指定字符或子串结尾。返回bool值。函数说明：str.endswith(suffix,start,end)输入参数：suffix：后缀。可以是字符、字符串、元组（常用于判断文件类型）。start：索引字符串的起始位置。默认0。end：索引字符串的结束位置。默认字符串的长度。备注：空字符的情况。返回值通常为True。str="ilovepython"print("1:",str.endswith("")) #空字符print("2:",str.endswith("n"))print("3:",str.endswith("python"))print("4:",str.endswith("n",0,6)) #索引'ilove'是否以'n'结尾。print("5:",str.endswith(("n","z"))) #遍历元组，任意一个满足条件即返回Trueprint("6:",str.endswith(("k","m"))) #遍历元组，任意一个满足条件即返回True#判断文件类型file="python.txt"iffile.endswith("txt"): #字符串类型print("该文件为文本。")eliffile.endswith(("AVI","WMV","RM")): #元祖类型print("该文件为视频。")else:print("文件格式未知。")'''1:True2:True3:True4:False5:True6:False该文件为文本。'''1234567891011121314151617181920212223242526'运行运行【4.4.2、字符串的判断函数】1.1、str.isdigit()，str.isnumeric()，str.isdecimal()：检查字符串是否只包含十进制数字，返回布尔值。中文汉字和英文数字的unicode编码范围方法Unicode数字全角数字（双字节）罗马数字汉字数字byte数字（单字节）浮点数负数科学计数法二进制八进制十六进制isdecimal()TrueTrueFalseFalseErrorFalseFalseFalseFalseFalseFalseisdigit()TrueTrueFalseFalseTrueFalseFalseFalseFalseFalseFalseisnumeric()TrueTrueTrueTrueErrorFalseFalseFalseFalseFalseFalsestr='123'print(str.isdecimal()) print(str.isdigit()) print(str.isnumeric())'''TrueTrueTrue'''12345678910'运行运行1.2、str.isupper()，str.islower()，str.istitle()：检测字符串的大小写，返回布尔值。（1）str.isupper()：判断字符串中，含有字母的部分是否全大写。（2）str.islower()：判断字符串中，含有字母的部分是否全小写。（3）str.istitle()：检测字符串中，所有单词拼写的首字母是否为大写，且其他字母为小写。str='123aaa'print(str.islower()) print(str.isupper()) str='ThisIsAll'print(str.istitle())str='ThisIsALL'print(str.istitle())'''TrueFalseTrueFalse'''123456789101112131415'运行运行1.3、str.isalpha()：检测字符串是否只有字母，返回布尔值。str='12aaAA'print(str.isalpha()) str='aaAA'print(str.isalpha()) str='aaAA'print(str.isalpha()) '''FalseFalseTrue'''1234567891011121314'运行运行1.4、str.isalnum()：检测字符串是否只有字母和数字，返回布尔值。str='12aaAA'print(str.isalnum()) str='12aaAA'print(str.isalnum())'''TrueFalse'''12345678910'运行运行1.5、str.isspace()：判断字符串中是否只有空白字符（可以有多个空白字符），返回布尔值。str='123aaa'print(str.isspace()) str=''print(str.isspace()) str=''print(str.isspace()) '''FalseTrueTrue'''1234567891011121314'运行运行五、Python函数Python3内置函数（大全）5.1、高阶函数：sorted+map+filter+reduce+lambda+enumerate+zip+iter+next3.1、sorted()：对所有可迭代类型进行排序，不改变原始序列——按照ASCII的大小进行排序（数字>>大写字母>>小写字母）。函数说明：sorted(iterable,key=None,reverse=False)输入参数：iterable：可迭代的对象（如：字典、列表）。key：可迭代类型中某个属性，对指定函数进行排序。默认=Nonereverse：默认升序（reverse=False）、降序（reverse=Ture）。备注：字符串按照ASCII的大小进行排序。默认先排序数字（0~9），再排序大写字母（A~Z），后排序小写字母（a~z）。lst1=(5,4,3,-2,1)L1=sorted(lst1)L2=sorted(lst1,key=abs)L3=sorted(lst1,reverse=True)print(L1) #【输出结果】[-2,1,3,4,5]print(L2) #【输出结果】[1,-2,3,4,5] print(L3) #【输出结果】[5,4,3,1,-2]###################################################################################lst2=('F','D','Y','e','a','v','9','6')L4=sorted(lst2)L5=sorted(lst2,key=str.lower) #对指定函数进行排序（将所有字母转换为小写，然后排序。不改变原字符串。）print(L4) #【输出结果】['6','9','D','F','Y','a','e','v']print(L5) #【输出结果】['6','9','e','F','v','Y']12345678910111213'运行运行3.2、map()：将指定函数依次作用于序列中的每一个元素——返回一个迭代器，结果需指定数据结构进行转换后输出。函数说明：map(function,iterable)输入参数：function：指定函数。iterable：可迭代对象print('返回一个迭代器:',map(int,(1,2,3)))#返回一个迭代器:12'运行运行结果需指定数据结构进行转换后输出数据结构：list、tuple、set。可转换后输出结果数据结构：str。返回一个迭代器数据结构：dict。ValueError，需输入两个参数print('将元组转换为list:',list(map(int,(1,2,3))))print('将字符串转换为list:',tuple(map(int,'1234')))print('将字典中的key转换为list:',set(map(int,{1:2,2:3,3:4})))'''将元组转换为list:[1,2,3]将字符串转换为list1,2,3)将字典中的key转换为list:{1,2,3}'''################################################################################dict_a=[{'name':'python','points':10},{'name':'java','points':8}]print(list(map(lambdax:x['name']=='python',dict_a)))print(dict(map(lambdax:x['name']=='python',dict_a)))"""[True,False]TypeError:cannotconvertdictionaryupdatesequenceelement#0toasequence"""123456789101112131415161718193.3、filter()：过滤掉不符合条件的元素——返回一个迭代器，结果需指定数据结构进行转换后输出。函数说明：filter(function,iterable)输入参数：function：判断函数iterable：可迭代对象函数功能：将序列中的每个元素循环传递给判断函数，并返回结果为True的元素组合成的新列表。print('返回一个迭代器:',filter(lambdax:x,list_num))#返回一个迭代器:12结果需指定数据结构进行转换后输出数据结构：list、tuple、set。可转换后输出结果数据结构：str。返回一个迭代器数据结构：dict。需输入两个参数，否则系统报错：ValueErrorlist_num=[1,2,3,0,8,0,3]print(list(filter(lambdax:x,list_num))) #过滤：数字0list_word=['a','B','c','d','E']print(tuple(filter(lambdax:x.isupper(),list_word))) #过滤：小写字母print(set(filter(lambdax:x.islower(),list_word))) #过滤：大写字母"""[1,2,3,8,3]('B','E'){'c','d','a'}"""################################################################################dict_a=[{'name':'python','points':10},{'name':'java','points':8}]print(list(filter(lambdax:x['name']=='python',dict_a)))print(dict(filter(lambdax:x['name']=='python',dict_a)))"""[{'name':'python','points':10}]{'name':'points'}"""123456789101112131415161718192021'运行运行3.4、reduce()：取序列的前2个元素，执行指定函数，然后将结果与第3个元素继续传入函数，循环到最后一个元素——返回一个数值。reduce函数在python2中是个内置函数，但在python3中已被移到functools模块。函数说明：reduce(function,iterable,initializer)输入参数：function：指定函数（输入为两个元素）iterable：可迭代对象initializer：初始参数（可选），即指定第一个元素的值，然后与序列的第一个元素执行指定函数。#常与匿名函数lambda同时使用fromfunctoolsimportreduceprint(reduce(lambdax,y:x+y,[1,2,3]))print(reduce(lambdax,y:x+y,[1,2,3],10)) #表达式：取和print(reduce(lambdax,y:xifx10else0 #判断输入参数的大小，大于取1，小于取0a1=lambdax,y:x*y #函数输入是x和y，输出是它们的积x*ya2=lambda:None #函数没有输入参数，输出是Nonea3=lambda*args:sum(args) #输入是任意个数的参数，输出是它们的和(隐性要求是输入参数必须能够进行加法运算)a4=lambda**kwargs:1 #输入是任意键值对参数，输出是1print(a0(2))print(a1(2,3))print(a2())print(a3(2,3,4))print(a4())"""06None91"""12345678910111213141516171819'运行运行❤️四个用法（1）将lambda函数赋值给一个变量，通过这个变量间接调用该lambda函数。如：add0=lambdax,y:x+y，返回两个变量的和。与add(1,2)==3等效。（2）将lambda函数赋值给其他函数，从而将其他函数用该lambda函数替换。如：time.sleep=lambdax:None。返回None，即调用标准库time中的sleep函数不执行。（3）将lambda函数作为其他函数的返回值，返回给调用者。如：returnlambdax,y:x+y，返回一个加法函数。此时lambda函数实际上是定义在某个函数内部的函数，称为嵌套函数或内部函数。（4）将lambda函数作为参数传递给其他函数。如：sorted()、filter()、map()、reduce()。11、sorted()：此时lambda函数用于对列表中所有元素进行排序。如：sorted([1,2,3,4,5],key=lambdax:abs(3-x))。将列表[1,2,3,4,5]中元素与3的距离，从小到大进行排序，其结果是列表：[3,2,4,1,5]。22、filter()：此时lambda函数用于过滤列表元素。如：list(filter(lambdax:x%3==0,[1,2,3]))。将列表[1,2,3]中能够被3整除的元素过滤出来，其结果是列表：[3]。33、map()：此时lambda函数用于对列表中每一个元素的共同操作。如：list(map(lambdax:x+1,[1,2,3]))。将列表[1,2,3]中的元素分别加1，其结果是列表：[2,3,4]。44、reduce()：此时lambda函数用于列表中两两相邻元素的结合。fromfunctoolsimportreducereduce(lambdaa,b:a+b,[1,2,3,4])。将列表[1,2,3,4]中的元素，从左往右取出2个元素并执行指定函数，然后将输出结果与第3个元素传入指定函数，…，循环到最后一个元素。其结果是整型：10。备注：reduce函数原本在python2中也是个内置函数，不过在python3中被移到functools模块中。3.6、枚举函数（enumerate）：同时获取可迭代对象的索引和值——与for循环一起使用。函数说明：index,value=enumerate(iteration,start)输入参数：iteration：可迭代对象。start：自定义起始索引值，可选参数，默认为0。备注：指定起始点，改变的只是可迭代对象中每个元素对应的索引的变化。即无论是否指定起始点，可迭代对象都是从第一个元素读取。输出参数：index：索引值。value：可迭代对象中索引对应的元素值。特点1：匿名函数，即没有名字的函数。list1=[1,2,3,4,5,6]forindex,valueinenumerate(list1): #默认起始点print(indx,value)########################################print('*'*10)########################################forindx,valueinenumerate(list1,2): #指定起始点print(indx,value)"""011223**********516273"""1234567891011121314151617183.7、组合序列（zip）：将多个可迭代对象的第i个元素组合在一起（压缩），得到一个元祖，最后输出N个元组——返回一个迭代器，结果需指定数据结构进行转换后输出。函数说明：res=zip(iterable_1,iterable_2,...,iterable_n)输入参数：iteration：n个可迭代对象。res：返回一系列元组的迭代器，第i个元组包含各输入iterables的第i个元素。解压缩：unzip（把组合序列进行反向分解）——python没有unzip函数函数说明：zip(*res)输入参数：*：表示解包运算符。res：由zip()生成的结果。#（1）不传递参数，返回空的迭代器print('1:',zip()) #print('1:',list(zip())) #[]#######################################################################（2）传递一个参数，返回tuple的迭代器。print('2:',list(zip([1,2,3]))) #[(1,),(2,),(3,)]#######################################################################（3）传递两个参数，返回tuple的迭代器。a3=['a','c','b']b3=['2','1']print('3:',list(zip(a3,b3))) #[('a','2'),('c','1')]print('3:',dict(zip(a3,b3))) #{'a':'2','c':'1'}#######################################################################4.1、传递长度不等的参数（截取最短，删除冗余）print('4:',list(zip(range(3),range(100)))) #[(0,0),(1,1),(2,2)]#4.2、传递长度不等的参数，若想要以最长的进行迭代处理，缺少部分补Noneimportitertoolsasitfruits=['apple','banana','melon','strawberry']prices=[10,20,30]print(list(it.zip_longest(fruits,prices))) #[('apple',10),('banana',20),('melon',30),('strawberry',None)]#######################################################################（5）并行排序（以第一个输入参数进行排序）print('5:',sorted(list(zip(a3,b3)))) #[('a','2'),('c','1')]print('5:',sorted(list(zip(b3,a3)))) #[('1','c'),('2','a')]#######################################################################（6）解压缩序列：解包运算符*。result=zip(a3,b3)origin=list(zip(*result)) #创建两个不同的元祖（数字和字母）print('6:',origin[0]) #('a','c')print('6:',origin[1]) #('2','1')#######################################################################（7）将数据成对进行计算total_sales=[52000.00,51000.00,48000.00]prod_cost=[46800.00,45900.00,43200.00]forsales,costsinzip(total_sales,prod_cost): profit=sales-costs print(f'Totalprofit:{profit}') """Totalprofit:5200.0Totalprofit:5100.0Totalprofit:4800.0"""1234567891011121314151617181920212223242526272829303132333435363738394041424344'运行运行3.8、iter()：输入一个可迭代对象，将其转换成一个迭代器——与next()一起使用。"""##################################################函数说明：iter(object,sentinel)#输入参数：#object：可迭代对象，但不一定可调用。若传入sentinel则必须是可调用对象。#sentinel（哨符,又叫标记符）：（可选参数）当枚举值等于sentinel时，则自动停止。且不会输出sentinel值。#输出参数：#返回迭代器对象#################################################"""a_iter=iter([1,2])print(a_iter) #print(next(a_iter)) #1print(next(a_iter)) #2print(next(a_iter)) #迭代器耗尽，未指定默认值，提示StopIteration异常"""12Traceback(mostrecentcalllast):File"F:\py\main222.py",line14,inprint(next(a_iter)) #迭代器耗尽，未指定默认值，提示StopIteration异常StopIteration"""123456789101112131415161718192021222324253.9、next()：检索迭代器的下一个元素——与iter()、yield()一起使用"""##################################################函数说明：next(iterator,default)#输入参数：#iteration：迭代器（不是可迭代对象，可迭代对象不是迭代器）#default（可选）：如果迭代器耗尽则返回此默认值。#若没有给定默认值，则抛出StopIteration异常。#输出参数：#返回下一个元素#################################################"""it=iter([1,2])print(next(it)) #1print(next(it)) #2print(next(it)) #迭代器耗尽，未指定默认值，提示StopIteration异常。print(next(it,5))#5"""Traceback(mostrecentcalllast):File"F:\py\main222.py",line13,inprint(next(it)) #迭代器耗尽，未指定默认值，提示StopIteration异常。StopIteration12"""######################################################################it=iter([1,3,5])try:whileTrue:x=next(it)print(x,end="")exceptStopIteration:#遇到StopIteration就退出循环print("raiseStopIteration!")"""135raiseStopIteration!"""1234567891011121314151617181920212223242526272829303132333435365.2、通用函数1、input()：获取控制台（任意形式）的输入，输出为字符串。str1=input()print(str1)print('打印字符串:',str1)print('字符串类型:',type(str1))'''as&d123#打印字符串:as&d123#字符串类型：'''1234567891011'运行运行  1.1、int(input())与map(int,input().spilt())的区别常用的强转类型说明int(input())强转为整型（int类型只能输入一个整数字符串）map(int,input().spilt())强转为整型（map函数可以输入多个整数字符串）list(input())强转为列表（输入可以是任意类型）  1.2、input()与list(input())的区别、及其相互转换方法相同点：两个方法都可以进行for循环迭代提取字符，提取后都为字符串类型。不同点：str=list(input())将输入字符串转换为list类型，可以进行相关操作。如：str.append()将列表转换为字符串：str_list=['A','aA',2.0,'',1]方法一：print(''.join(str))方法二：print(''.join(map(str,str_list)))备注：若list中包含数字，则不能直接转化成字符串，否则系统报错。方法一：print(''.join([str(ii)foriiinstr_list]))方法二：print(''.join(map(str,str_list)))map()：根据给定函数对指定序列进行映射。即把传入函数依次作用到序列的每一个元素，并返回新的序列。（1）举例说明：若list中包含数字，则不能直接转化成字符串，否则系统报错。str=['25','d',19,10]print(''.join(str))'''Traceback(mostrecentcalllast):File"C:/Users/Administrator/Desktop/test.py",line188,inprint(''.join(str))TypeError:sequenceitem3:expectedstrinstance,intfound'''123456789（2）举例说明：若list中包含数字，将list中的所有元素转换为字符串。str_list=['A','aA',2.0,'',1]print(''.join(str(ii)foriiinstr_list))print(''.join([str(ii)foriiinstr_list]))print(''.join(map(str,str_list))) #map()：根据给定函数对指定序列进行映射。即把传入函数依次作用到序列的每一个元素，并返回新的序列。'''AaA2.01AaA2.01AaA2.01'''12345678910'运行运行2、print()：用于打印输出【Python】print()函数的用法x,y=1,9print('{},{}'.format(x,y))#打印方法一print(x,',',y) #打印方法二print('*'*10) #打印分割符'''1,91,9**********'''1234567891011'运行运行3、range()：输出指定范围内的所有值（前闭后开）"""##################################################函数说明：range(start=0，stop，step=1)#输入参数：#start（可选）：序列的起始点（默认0）#stop：序列的终止点#step（可选）：滑动步长（默认1）#（1）正数表示迭代上升#（2）负数表示迭代下降##备注：前闭后开[A，B)，即能取到A值，但取不到B值。#################################################"""#（1）指定stop=3,start默认为0，step默认为1foriinrange(3):print('A=',i)#（2）指定start=2,stop=3,step默认为1foriinrange(2,3):print('B=',i)#（3）指定start=5,stop=2,step=-2foriinrange(5,2,-2):print('C=',i)'''A=0A=1A=2B=2C=5C=3'''123456789101112131415161718192021222324252627282930313233'运行运行4、len()：返回可迭代对象的长度（字符串、列表、字典、元组等）"""##################################################函数说明：len(iter_object)#输入参数：可迭代对象#输出参数：可迭代对象的长度（即：参数的个数）#################################################"""str_temp="Hello,boy!"print(len(str_temp))#【输出结果】12#############################################list_temp=['h','e','l','l','o']print(len(list_temp))#【输出结果】5#############################################dict_temp={'num':520,'name':"dodo"}print(len(dict_temp))#【输出结果】2#############################################tuple_temp=('G','o','o','d')print(len(tuple_temp))#【输出结果】4123456789101112131415161718'运行运行5、eval()：返回表达式的值——输入可以是任意类型，输出与输入类型一致"""##################################################函数说明：eval(expression,globals,locals)#输入参数：#expression：字符串表达式。输入可以是任意类型。#globals：变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。#locals：变量作用域，局部命名空间，如果被提供，可以是任何映射对象。##优先级：locals>globals>expression。若三个参数有相同的变量，则按照优先级进行赋值。#################################################"""print(type(eval('1')))print(type(eval('1.0')))print(type(eval("'1'")))print(type(eval('{1}')))print(type(eval('[1,2]')))print(type(eval('{2:2}')))print(type(eval('(1,2)')))""""""###########################（1）expression参数示例a1=10temp1=eval("a1+1") #a1=10print(temp1)print(type(temp1))###########################（2）globals参数示例a2=10g={'a2':4}temp2=eval("a2+1",g) #a2=4print(temp2)print(type(temp2))###########################（3）locals参数示例a3=10b3=20c3=30g={'a3':6,'b3':8}t={'b3':100,'c3':10}temp3=eval("a3+b3+c3",g,t) #a3=6、b3=100、c3=10print(temp3)print(type(temp3))##########################"""115116"""1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859'运行运行5.3、数学函数+随机数函数+三角函数+数学常量Python标准库：importmath（常量+数学函数+幂与对数+三角函数）1、数学函数  1.1、round()：四舍五入——支持保留小数点的指定位数"""##################################################函数功能：四舍五入#函数说明：round(x,n)#输入参数：#x：浮点数或整数。若为整数，则n无效，直接输出整数。#n：保留小数点的位数。#################################################"""#四舍五入规则：#（1）若保留位数的后一位=6，则进位。如：round(5.216,2)结果为5.22。print(round(5,2)) #5 #整数print(round(5.214,2)) #5.21 #=6，则进位12345678910111213141516171819'运行运行  1.2、sum()：求和"""##################################################函数说明：sum(iterable,start)#输入参数：#iterable：可迭代对象（如：列表+元组+集合+字典+字符串）#start：指定相加的参数，默认为0。#################################################"""print(sum([1,2,3])) #6print(sum((1,2,3))) #6print(sum({1,2,3})) #6print(sum(range(5))) #10##########################print(sum([1,2,3],2)) #8print(sum((1,2,3),2)) #8print(sum({1,2,3},2)) #8print(sum(range(5),2)) #121234567891011121314151617'运行运行  1.3、abs()+fabs()：返回绝对值abs()fabs()abs()是python的内置函数fabs()是math模块中的函数（importmath）适用范围float、int、complexfloat、int1若输入为整型，则返回整型；若输入为整型，则自动保留一个小数。2若输入为浮点型或复数类型，则返回浮点型。若输入为浮点型，则返回浮点型importmath#输入整型print(abs(10)) #10print(math.fabs(10)) #10.0#输入浮点型print(abs(10.125)) #10.125print(math.fabs(10.125)) #10.125#输入复数类型print(abs(10.125+12j)) #15.62850460696736#print(math.fabs(10.125+12j)) #TypeError:can'tconvertcomplextofloat12345678910111213'运行运行  1.4、开根号（四种方法）#方法1：数字**0.5x=int(input('数字:'))**0.5 #数字:50print(x)#7.0710678118654755print(type(x))#################################################################方法2：pow(数字，次方)x=pow(int(input('数字:')),0.5)#数字:50print(x)#7.0710678118654755print(type(x))#################################################################方法3：math.sqrt(数字)importmathx=math.sqrt(int(input('数字:')))#数字:50print(x)#7.0710678118654755print(type(x)) #################################################################方法4：cmath.sqrt(数字)importcmathx=cmath.sqrt(int(input('数字:')))#数字:50print(x)#(7.0710678118654755+0j)print(type(x))#123456789101112131415161718192021222324252、随机数函数3、三角函数4、数字常量文献参考1.【Python3】内置函数（大全）2.【Python3】字符串常用方法（大全）3.【Python】encode()函数4.【Python】decode()与encode()详解5.【Python】字符串isdecimal()isdigit()isnumeric()等判断方法的区分。6.TypeError:sequenceitem0:expectedstrinstance,intfound的解决办法