目录

一、常规函数

元组相关函数

1.元组的创建

2.元组多变量赋值

列表相关函数

1.列表的创建

（1）将至于中括号中的、用逗号分隔开的一组数据赋值给一个变量，数据可以是多个也可以是一个

（2）使用list函数

（3）split()函数

2.列表的更新

（1）通过索引赋值改变列表中制定序号的元素

（2）还可以通过切片赋值的方法更新列表中的数据。

（3）其他操作方法，append，extend，insert

3.列表的删除

（1）list.pop（i）

（2）ls.remove（x）

（3）ls.clear（）

（4）del命令

4.列表的排序

（1）ls.sort（）方法

（2）.ls.reverse（）方法

（3）sorted（）函数

sorted（）的特殊使用方法

（4）reserved（seq）函数

5.列表的赋值与复制

（1）浅拷贝

（2）深拷贝

6.列表推导式

7.常用内置函数

（1）map（）

（2）zip（）

（3）enumerate（）

字符串相关函数

1.索引

2.切片

3.序列拼接与重复

4.成员测试in  和“not in”

二、数学运算函数

Python内置的数学运算函数

1.abs（x）

2.divmod(a,b)

3.pow（x，y[,z])

4.round（number【，n】）

5.max（）/min（）

math库常用函数

1.math.fabs

2.math.factorial（）

4.math.gcd（）

5.math.lcm（）

6.math.pow（x，y）

7.math.exp（）

8.math.sqrt（）

三、字符串相关库函数或常量

string,字符串常量

常用字符串处理方法：

（1）str.upper/str.lower：

（2）str.strip（）

（3）str.join（）

（4）str.split（）

（5）str.find（sub，strat，end）

（6）str.replace

random模块

2.random.randint（a,b）

3.random.random（）

4.random.unifrom(a,b)

5.random.chioce（）

6.random.sample（）

---

一、常规函数

元组相关函数

1.元组的创建

（1）用一堆空的小括号创建一个空元组

（2）用逗号结尾的一个单独元素

（3）用逗号分隔的多个元素（最好使用带括号的）

（4）使用内置的tuple（）函数

t1 = (1,2,3,4)
t2 = 1,2,3,4t3 = tuple()
t4 = tuple(range(4))
t5 = tuple([1,2,3,4])

2.元组多变量赋值

（1）可以使用多变量赋值语句吧元组、列表、字符串等序列解包

x,y = (5,10)
m,n = 3,4
a,b,c = 'xyz'
i,j = [3,6]

（2）多变量赋值时，序列长度必须与变量数量一致，否则会引发ValueErrorr

（3）多变量同时复制，常会用于将在一行内输入、使用空格或者逗号隔开的字符串根据分隔符切分列表，然后使用多变赋值语句分别赋值给多个变量：

name,score = input().split()
a1,a2,a3=map(int,input().split()) #可以直接获取整形而非字符型

列表相关函数

1.列表的创建

（1）将至于中括号中的、用逗号分隔开的一组数据赋值给一个变量，数据可以是多个也可以是一个

（2）使用list函数

分割元组、range、字符串、字典的键、集合或者其他类型的可迭代对象类型的数据转换为列表，当参数为空时，生成一个空列表

print(list())
print(list((1,2,3,4)))
print(list(range(5)))
print(list("1234"))

（3）split()函数

根据分隔符sep将字符串分为列表。当不确定分隔符是一个或者多个空格时，一般不加参数，多个空格值切分一次

s = "Life is  short,you need  Python"
print(s.split(","))
print(s.split())
print(s.split(' '))['Life is  short', 'you need  Python']
['Life', 'is', 'short,you', 'need', 'Python']
['Life', 'is', '', 'short,you', 'need', '', 'Python']

2.列表的更新

（1）通过索引赋值改变列表中制定序号的元素

ls[i] = a

当i值超过列表序号范围时，触发索引越界异常；原有元素的数据类型相同，也可以不同，甚至可以是列表或元组

（2）还可以通过切片赋值的方法更新列表中的数据。

当切片连续时新列表长度不限，可为空列表、与切片等长列表或者超出列表长度的列表

当切片不连续时，要求用于替换的新列表与原列表切片元素数量相同，再按顺序一一替换，替换元素数量不相同时，返回ValueError

（3）其他操作方法，append，extend，insert

append，向列表末尾追加一个元素

ls = [88,56,95,46]
ls.append(56)
print(ls)[88, 56, 95, 46, 56]

extend，将另一个列表中的所有元素追加到现在列表的末尾

ls = [88,56,95,46]
L = [10,20,30]
ls.extend(L)
print(ls)[88, 56, 95, 46, 10, 20, 30]

insert，向列表中的任意位置插入一个元素

ls = [88,56,95,46]
ls.insert(2,99)#在序号为2的位置上插入新值99
print(ls)[88, 56, 99, 95, 46]

3.列表的删除

（1）list.pop（i）

用于移除列表中序号为i的元素，并且返回该元素。如果无参数时，删除最后一个元素.唯一一个删除元素同时返回值为被移除的元素

ls = list('08974')
print(ls.pop())    #4

（2）ls.remove（x）

删除列表中第一个与参数“x”值相同的元素，列表中存在多个只删除第一个，保留其他元素；当不存在相同元素时，报错ValueError

（3）ls.clear（）

删除列表中全部的元素，即清空列表。

（4）del命令

ls.clear（）的作用与del ls[:]相同；当一个列表不再使用时，可以使用del命令删除列表对象

ls = list('08974')
ls.clear()
print(ls)ls = list('08974')
del ls[1]
print(ls)
del ls[:]
print(ls)
del ls[]
['0', '9', '7', '4']
[]

4.列表的排序

（1）ls.sort（）方法

该方法可以让ls原地排序，reverse默认值是False，默认是由低到高排序，如果将reverse的参数改为True则获得降序列表

参数key种植钉排序时应用到每个参与排序元素的规则

ls = ['app',"Apple","at","at"]
ls.sort()
print(ls)
ls.sort(key=str.lower)
print(ls)
ls.sort(key=len)
print(ls)
ls2 = ['76','98','55','4','05']
ls2.sort(key=int)
print(ls2)['Apple', 'app', 'at', 'at']
['app', 'Apple', 'at', 'at']
['at', 'at', 'app', 'Apple']
['4', '05', '55', '76', '98']

（2）.ls.reverse（）方法

不比较元素大小，只是直接将列表ls的元素逆序

ls = ['app',"Apple","at","at"]
ls.reverse()
print(ls)['at', 'at', 'Apple', 'app']

（3）sorted（）函数

使用效果与ls.sort方法相同，但是ls是作为参数写入该函数的

ls2 = ['76','98','55','4','05']
print(sorted(ls2,key=int))['4', '05', '55', '76', '98']

sorted（）的特殊使用方法

下图意为先以第三个元素极性升序排序，如果第三元素相等，则以第1元素升序排序。排序之后所得依旧为列表

socre = [['a','1000000',99],['b','1000001',98],['c','1000002',97]]
print(sorted(socre,key=lambda x:(x[2],x[0])))[['c', '1000002', 97], 
['b', '1000001', 98],
['a', '1000000', 99]]

（4）reserved（seq）函数

使用方法与sorted相同，效果与（2）一致

5.列表的赋值与复制

（1）浅拷贝

浅拷贝只复制首地址，可变数据类型元素发生变化时也会影响原来的函数

ls = [2,5,['a',[22,33],'c'],9]
ls1 = ls
print(ls1)
ls2 = ls[1:3]
print(ls2)
ls3 = ls.copy()
print(ls3)[2, 5, ['a', [22, 33], 'c'], 9]
[5, ['a', [22, 33], 'c']]
[2, 5, ['a', [22, 33], 'c'], 9]

（2）深拷贝

递归复制到低的叫深复制，复制结果完全独立于源对象

ls5 = copy.deepcopy(ls)
print(ls5)[2, 5, ['a', [22, 33], 'c'], 9]

6.列表推导式

列表推导式时一种创建新列表的便捷的方式，可根据一个列表中的每个元素通过某种运输按或者筛选得到另一个系列的新数据，创建一个新列表。其中，该运算法则也可以是一个函数。

s =[]
for x in range(10):s.append(x**2)
print(s)s2 = [x**2 for x in range(10)]
print(s2)[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

7.常用内置函数

（1）map（）

该函数可以将函数作用于可迭代对象中的每一个元素，返回一个可迭代对象（生成器），常用于讲一个序列映射为另一种数据类型的序列

第一个参数是一个函数，如int，float，str等，第二个对象是刻碟嗲对象，比如列表

s= ['1','2','3']
print(map(int,s))
print(*map(int,s))
print(list(map(int,s)))<map object at 0x0000010AA4312FD0>
1 2 3
[1, 2, 3]

亦可以用于同行输入

m ,n = map(int, input().split())

print('+'.join(map(str,range(5))))  #整数序列映射为字符序列并拼接
#输出字符串“0+1+2+3+4”
print(sum(map(int,str(pow(2,64))))) #整数字符串映射为整数序列
#2的64次方的结果是18446744073709551616，每一位上的加和为88

（2）zip（）

zip可以组合多个遍历对象，生成一个zip文件，最终生成“生成器对象”，列表长度取决于最短的可遍历对象

第i个元组的数据可以为各可遍历对象的第i个元素组成的元组，知道所有的可遍历对象中最短的元组最后一个元素组成的元组为止

可以使用list或者*对生成器对象进行解包，但是解包后生成器文件就会变空。使用‘*’解包会以多个元组的形式返回

city = ['上海','北京','深圳']
gdp = ['45665','64565']
rate = [-2.6,-3.2,0.1]
datail = zip(city,gdp,rate)
print(list(datail))
print(list(datail))  #生成器对象被访问后就会变空
datail = zip(city,gdp,rate)
print(*datail)[('上海', '45665', -2.6), ('北京', '64565', -3.2)]
[]
('上海', '45665', -2.6) ('北京', '64565', -3.2)

（3）enumerate（）

根据一个可遍历对象生成一个新的可遍历序列，给原来的iter对应的增添一个序号。如果不填写第二个参数则自动以0为序号开始填写。

ls = ['shanghai','beijing','jinan']
LS = enumerate(ls)
print(list(LS))ls = ['shanghai','beijing','jinan']
LS = enumerate(ls,1)
print(list(LS))[(0, 'shanghai'), (1, 'beijing'), (2, 'jinan')]
[(1, 'shanghai'), (2, 'beijing'), (3, 'jinan')]

字符串相关函数

1.索引

索引序号必须为整数或者结果是整数的表达式，索引的对象可以是字符串，元组，列表等多种类型。

s = "Holle World!"
print(s[4])  #返回序号为4的字符，即第5个字符‘e’
print(s[-1]) #返回最后一个字符‘！’

2.切片

字符串序列、列表、元组、range等类型都支持切片操作

seq[start:end:step]

print(s[6:8])
print(s[:5])
print(s[6:])
print(s[-3:-1])
print(s[6:-1])#负向索引，但是不包括最右边的元素
print(s[::])#以字符串开始到结束进行切片
print(s[::-1])#倒序输出
print(s[::2])#步长为2Wo
Holle
World!
ld
World
Holle World!
!dlroW elloH
HleWrd

3.序列拼接与重复

序列拼接是通过“+”将两个相同类型的序列拼接成一个包含参与拼接的序列中所有元素的新序列。

序列重复（s*n）是将一个序列s乘以一个整数n产生一个新序列

year = 2018
s = "年"
print('=' * 10)
print(str(year)+s)
print('='*10)==========
2018年
==========

4.成员测试in  和“not in”

用于检测某对象是否是字符串、列表或元组等序列或者集合中的成员，返回布尔值True或者False。

二、数学运算函数

Python内置的数学运算函数

不可以用math引用，如果使用引用就会报错

1.abs（x）

返回x的绝对值，x可以是整数或者浮点数，当x为复数的模

2.divmod(a,b)

相当于（a//b，a%b），以元组的形式返回整数商和余数

3.pow（x，y[,z])

返回x的y次幂，当z存在时，返回x的y次幂计算结果的同时，再对z取余

print(pow(2,3)) #计算2**3，输出8
print(pow(1999,1998,1997))#1999**1998%1997

4.round（number【，n】）

返回浮点数number保留n为小数的形式,n微整形,默认值为0

print(round(3.1415926))#3，返回最接近输入数字的整数
print(round(-3.14))    #3
print(round(3.8))      #4
print(round(3.12500001,2))# 3.13,后非0就进1
print(round(3.125,2))    #3.12,5后为0，且前位偶数不进位
print(round(3.115,2))    #3.12,5前位奇，进1

5.max（）/min（）

从多个参数或者一个可迭代对象中返回最大/小值，有多个最大/小值返回第一个

math库常用函数

1.math.fabs

以浮点数形式返回参数的绝对值

2.math.factorial（）

返回参数的阶乘，不可以接受整数值的浮点数作为参数

3.math.fsum（）

返回浮点数迭代求和的精确值，避免精度损失

print(sum([.1,.1,.1,.1,.1,.1,.1,.1,.1,.1]))
print(math.fsum([.1,.1,.1,.1,.1,.1,.1,.1,.1,.1]))0.9999999999999999
1.0

4.math.gcd（）

返回给定的整数参数的最大公约数

5.math.lcm（）

返回给定的整数参数的最小公倍数

6.math.pow（x，y）

返回x的y次幂

7.math.exp（）

返回e的x次幂

8.math.sqrt（）

返回x的平方根

三、字符串相关库函数或常量

string,字符串常量

string.ascii_letters,"abcdefghijklmnopqrstuvwhyzABCDEFGHIGKLMNOPQRSTUVWHYZ"

string.ascii_lowercase,"abcdefghijklmnopqrstuvwhyz"

string.ascii_uppercase,"ABCDEFGHIGKLMNOPQRSTUVWHYZ"

string.digits，“0123456789”

string.hexdigits，“0123456789abcdefABCDEF”

string.octdigits,"01234567"

string.punctuatuion,"!"#$%&\'()*+,-:;<=>?@[\\]^_`{|}~"

string.printable,"0123456789abcdefghijklmnopqrstuvwhyzABCDEFGHIGKLMNOPQRSTUVWHYZ!"#$%&\'()*+,-:;<=>?@[\\]^_`{|}~\t\n\r\x0b\x0c"

string.whitespace,"\t\n\r\x0b\x0c"

常用字符串处理方法：

（1）str.upper/str.lower：

转换字符串中所有字母的大小写，前者全部改为大写，后者改为小写

（2）str.strip（）

用于移除字符串开头结尾的指定字符，参数省略时删掉空白字符\t\n\r\x0b\x0c等

此外还有rstrip（）函数，用于移除字符串结尾置顶的函数

lstrip（）函数删除字符串左侧空白字符

s = "001230"
s1 = s.strip('0')
print(s1)
s2 = s.rstrip("0")
print(s2)123
00123

（3）str.join（）

以字符串为作为分隔符，将参数中的字符串元素拼接成一个新的的字符串，当参数中存在非字符串元素时，返回异常

（4）str.split（）

根据分隔符sep酱紫夫差切分为列表，sep参数省略时根据空格分隔。当maxsplit存在且不为-1时，可以最多切分maxsplit次

（5）str.find（sub，strat，end）

检测字符串中是否包含参数，如果是，则返回开始的索引值，否则返回-1。start和end为取值范围

（6）str.replace

把字符串中的参数1全部换为参数2，如果还有整数x参数3，则最多执行x次

遍历输出文件   with open('filename',mode='r',encoding = 'utf-8') as file：

filename是读取的带扩展名的文件名，读取模式mode的是为“r”表示阅读模式（read），不修改文件，也可以省略。file值读取文件后创建的对象。

random模块

1.random.seed（）

初始化随机生成器，如果参数省略或者为None时以系统时间作为种子。seed必须是以下类型之一：NoneType，int，float，strbytes，bytearray

2.random.randint（a,b）

产生[a,b]之间的一个随机整数

3.random.random（）

产生[0.0,1.0)之间的随机浮点数

4.random.unifrom(a,b)

产生[a,b)范围内随机一个浮点数

5.random.choice（）

从非空序列中随机产生一个元素，当序列为空时，触发异常

6.random.sample（）

参数1：列表、元组、字符串、集合、range对象等。参数2：整数

在参数1中随机选择n个元素，并以列表形式返回