【Python学习笔记—保姆版】第二章—Python的基本运算符、数据类型、常用函数

Yedge

已于 2022-07-12 23:25:11 修改

阅读量445

点赞数 2

文章标签： python 学习开发语言

于 2022-07-12 16:18:55 首次发布

本文链接：https://blog.csdn.net/Yedge/article/details/125726821

版权

Python的基本运算符、数据类型、常用函数

运算符
数据类型
函数

欢迎访问我搞事情的【知乎账号】：Coffee
以及我的【B站漫威剪辑账号】：VideosMan
若我的笔记对你有帮助，请用小小的手指，点一个大大的赞哦。

运算符

算数运算符

+	加法——加——两个对象相加	a + b = 30
-	减法——得到负数或是一个数减去另一个数	a - b = -10
*	乘法——两个数相乘或是返回一个被重复若干次的字符串	a * b = 200
/	除法——b除以a	b / a = 2
%	取模——返回除法的余数	b % a = 0
**	指数——返回a的b次幂	a**b = 10 的幂 20
//	取整除——返回商的整数部分	9//2 = 4 而 9.0//2.0 = 4.0

比较运算符

==	\检查两个操作数的值是否相等，若相等则条件为真	(a == b) 不为true
!=	检查两个操作数的值是否相等，若不等则条件为真	(a != b) 为true
>	检查左操作数的值是否大于右操作数的值，若大于则条件为真	(a> b) 不为true\
<	检查左操作数的值是否小于右操作数的值，若小于则条件为真	(a< b) 为true
>=	检查左操作数的值是否大于等于右操作数的值，若大于等于则条件为真	(a>= b) 不为true
≤	检查左操作数的值是否小于等于右操作数的值，若小于等于则条件为真	(a <= b) 为true

赋值运算符

=	简单的赋值运算符，赋值从右侧操作数到左侧操作数	c=a+b
+=	加法赋值运算符	c+=a → c=c+a
-=	减法赋值运算符	c-=a → c=c-a
//=	地板除，左操作数地板除右操作数，结果赋给左操作数	c//=a → c=c//a
**=	指赋值运算符，左操作数的右操作数指数之值赋给左操作数	c=a →c=ca
%=	模赋值运算符	c%=a→ c=c%a
/=	除法赋值运算符	c/=a → c=c/a
*=	乘法赋值运算符	c=a → c=ca

数据类型

数字（Numbers）

查看数据类型的方法：type(变量名)
>>> a = 1  #int
>>> type(a)
<class 'int'>
>>> b = True  #boolean
>>> type(b)
<class 'bool'>
>>> c = 4+3j  #complex
>>> type(c)
<class 'complex'>
>>> d = 3.14   #float
>>> type(d)
<class 'float'>

字符串（String）

引号的使用

使用单引号('）

可以用单引号指示字符串，就如同’Quote me on this’这样。所有的空白，即空格和制表符都照原样保留。

使用双引号( " ）

在双引号中的字符串与单引号中的字符串的使用完全相同，例如"What’s your name?"。

使用三引号(’ ’ ’ 或" " " ）

利用三引号，可以指示一个多行的字符串。可以在三引号中自由的使用单引号和双引号。如注释一段文字*可用三引号。

索引、切片、包含判断

字符串可以使用 + 运算符串连接在一起，或者用 * 运算符重复：

>>> print('str'+'ing', 'my'*3)
string mymymy

字符串索引

给出一个字符串，可输出任意一个字符。Python中的字符串有两种索引方式：第一种是从左往右，从0开始依次增加；第二种是从右往左，从-1开始依次减少。

>>> word = 'Python'
>>> print(word[0])
P
>>> print(word[-1], word[-6])
n P

字符串切片

分片就是从给定的字符串中分离出部分内容。形式为变量[头下标:尾下标]，截取的范围是前闭后开的，并且两个索引都可以省略。

>>> str = "Hello My friend"
>>> print(str[1:4])
ell
>>> print(str[:-7])
Hello My
>>> print(str[5:])
    My friend
>>> print(str[:])
Hello My friend

字符串分片的扩展形式

str[I：J：K] 意思是从I到J-1，每隔K个元素索引一次，如果K为负数，就是按从右往左索引。

>>> str = "Hello My friend"
>>> print(str[2:7:2])
loM
>>> print(str[2:7:1])
llo M

字符串包含的判断操作符

字符串包含判断操作符：in，not in

>>> str = "Hello My friend"
>>> "He" in str
True
>>> "she" not in str
True
>>> str.find('o')  #字符串模块提供的查找方法
4

string模块提供的方法、内置函数、str转换

string模块提供的方法

string 提供的方法	描述
S.find(substring, [start [,end]])	可指范围查找子串，返回索引值，否则返回-1
S.rfind(substring,[start [,end]])	反向查找
S.index(substring,[start [,end]])	同find，只是找不到产生ValueError异常
S.rindex(substring,[start [,end]])	同上反向查找
S.count(substring,[start [,end]])	返回找到子串的个数
S.lower()	转小写
S.upper()	转大写
S.swapcase()	大小写互换
S.split()	将string转list，默认以空格切分，也可以指定字符切分

处理字符串的内置函数

内置函数	描述
len(str)	串长度
max(‘abcxyz’)	寻找字符串中最大的字符
min(‘abcxyz’)	寻找字符串中最小的字符

Range (左闭右开)

python中的内置函数range(n),其中参数n代表：从0到n-1的一个序列,即长度为n的一个序列。

也可以自定义我们需要的起始点和结束点，如：

>>>range(1,5)  #代表从1到5(不包含5)，即：1、2、3、4

还可以定义步长。定义一个从1开始到30结束，步长为3的列表。

>>>list(range(1, 30, 3)) 	#用list把值显示出来
[1, 4, 7, 10, 13, 16, 19, 22, 25, 28]

列表（List）

对字符串的操作

列表是写在方括号之间、用逗号分隔开的元素列表。列表中元素的类型可以不相同。如：a = [“I”,“you”,“he”,5] 。
索引同字符串和元组一样，从0开始，0表示第一个元素索引，-1最后一个元素索引，-len()第一个元素的索引，len()-1最后一个元素的索引。

创建连续的list
>>> list(range(1,5))
[1, 2, 3, 4]
>>> list(range(1, 10, 2))  #步长为2，从1开始，每隔2取一个数
[1, 3, 5, 7, 9]

List索引与切片

和字符串一样，列表同样可以被索引和切片，列表被切片后返回一个包含所需元素的新列表。

>>> a = ["I","you","he",5]
>>> a[1:3]
['you', 'he']
>>> a[1]
'you'
>>> a[1]='she'
>>> a
['I', 'she', 'he', 5]

List串联操作

列表还支持串联操作，使用“+”操作符：

>>> a = [1, 2, 3, 4, 5]
>>> a + [6, 7, 8]
[1, 2, 3, 4, 5, 6, 7, 8]

字符串转换为列表

在列表a中n位置插入一个值‘q’：a[n:n]=['q'] 
将字符串转化为列表：list(str)
>>> a = [1, 2, 4, 5]
>>> a[2:2]=[3]         #在列表中的某位置插入一个值
>>> a
[1, 2, 3, 4, 5]
>>> len(a)               #测试列表的长度（含元素的个数）
5
>>> word='hello'
>>> list(word)         #将字符串转化为列表
['h', 'e', 'l', 'l', 'o']

排序

List排序：sort()

sort()函数对列表排序时改变了原来的列表，从而让其中的元素能按一定的顺序排列。（默认从小到大排列）

>>> a = [3,2,5,4,9,8,1]
>>> a.sort()
>>> a
[1, 2, 3, 4, 5, 8, 9]
>>> sort(a)
Traceback (most recent call last):
    File "<pyshell#3>", line 1, in <module>
    sort(a)
NameError: name 'sort' is not defined

>>> e=[1, 3, 2,4,5]
>>> e.sort(reverse=True)
>>> e
[5, 4, 3, 2, 1]

sort()函数改变原来的列表，函数返回值是空值，即None。因此，如果需要一个已排好序的列表副本，同时又要保留原有列表不变的时候，就不能直接简单的使用sort()函数。

为了实现上述功能使用sort()的方法是：先获取列表a的副本b和c，然后再对b和c进行排序。

>>> a = [3,2,5,4,9,8,1]
>>> id(a)                 	#查看a的存储地址
55494776
>>> b=a[:]             	#拷贝一个副本b
>>> b
[3, 2, 5, 4, 9, 8, 1]
>>> id(b)                 	#查验b的存储地址
55486264                 	#发现b和a地址不一致，说明复制了一份
>>> c=a                  	#复制一个副本c
>>> c
[3, 2, 5, 4, 9, 8, 1]
>>> id(c)                 	#查验c的存储地址
55494776         	#发现c的地址跟a一致，说明c是a一个标签，不是真复制
>>> b.sort()    		#对b进行排序
>>> b
[1, 2, 3, 4, 5, 8, 9]
>>> a                       	#b排序后对a没有影响
[3, 2, 5, 4, 9, 8, 1]
>>> c.sort()            	#对c进行排序
>>> c
[1, 2, 3, 4, 5, 8, 9]
>>> a                      	#c排序后对a有影响，与a、c一致
[1, 2, 3, 4, 5, 8, 9]

List排序：sorted()

获取已排序的列表副本的方法是使用sorted()函数。
>>> a = [3,2,5,4,9,8,1]
>>> sorted(a)                #对a排序后产生一个新的列表
[1, 2, 3, 4, 5, 8, 9]
>>> a
[3, 2, 5, 4, 9, 8, 1]

注意：a.sort()和sorted(a)的区别，sorted(a)产生的是一个新列表，而a.sort()是对a直接排序了。

List排序： reverse() list一下才可以

L.reverse()     		   #倒序排列
>>> e.reverse()
>>> e
[1, 2, 3, 4, 5]
或者:
>>> reversed([1,2,'L'])   #返回的是一个迭代器，必须再list一下才可以
>>> list(reversed([1,2,'L']))
['L', 2, 1]
或者：
>>> w=[1,2,'L']
>>> w[::-1]
['L', 2, 1]

元素追加：append()、extend()、insert()

List元素追加：append() 不是串联

L.append(var)   #追加元素，追加的元素可以是一个list、数、字符串等
>>> w=[1,2,'L']
>>> q=[8,9]
>>> w.append(q)   #不能写成w= w.append(q)
>>> w
[1, 2, 'L', [8, 9]]

List元素追加：extend() 串联

L.extend(list)  #追加list，即合并list到L上，只能是追加list。
>>> w=[1,2,'L']
>>> q=[8,9]
>>> w.extend(q)
>>> w
[1, 2, 'L', 8, 9]

注意:append和extend的区别是：append整体添加成list的一个元素。

List元素追加：insert()

L.insert(index,var) #在index位置插入var
>>>a = ["I","you","he",5] 
>>>a.insert(1,'love')
>>>a
    ['I', 'love', 'you', 'he', 5]

删除：pop()、del()、remove()

List元素删除：pop()

L.pop(index)   #返回被删除的index位置元素，只能删一个元素，并从list中删除之,默认删除最后一个元素。
>>>a = ["I","you","he",5] 
>>>a.pop(2)
'he'
>>>a
['I', 'you', 5]
>>>a.pop()
5
>>>a
['I', 'you']

List元素删除：del()

del L[1]    #删除指定下标的元素
>>>a = ["I","you","he",5] 
>>>del a[3]
>>>a
    ['I', 'you', 'he']

del L[1:3]  #删除指定下标范围的元素

List元素删除：remove()

L.remove(var)   #删除第一次出现的var元素
>>>li = [1,2,3,4,5,6]
>>>li.remove(4)
>>>li
[1, 2, 3, 5, 6]

>>>li = [1,2,3,4,5,6]
>>>li = li[:-1]
>>>li
[1, 2, 3, 4, 5]

List操作符：“:”、“+”、“*”

a[1:]             #片段操作符，用于子list的提取

[1,2]+[3,4]    #结果为[1,2,3,4]。同extend()

[2]*4             #结果为[2,2,2,2]

List索引

列表：array = [1, 2, 5, 3, 6, 8, 4]

列表的索引如下图，对应的元素1=array[0]= array[-7]，以此类推。
在这里插入图片描述

>>> array[0:] #列出0以后的
[1, 2, 5, 3, 6, 8, 4]
>>> array[1:] #列出1以后的
[2, 5, 3, 6, 8, 4]
>>> array[:-1] #列出-1之前的
[1, 2, 5, 3, 6, 8]
>>> array[3:-3] #列出3到-3之间的
[3]
>>> array[::2]  #表示步长为2取元素，即隔一个元素取一个元素
[1, 5, 6, 4]
>>> array[2::]
[5, 3, 6, 8, 4]
>>> array[::3]
[1, 3, 4]
>>> array[::4]
[1, 6]
>>> array[::-1]	#倒序效果
[4, 8, 6, 3, 5, 2, 1]
>>> array[::-2]
[4, 6, 5, 1]

List其他方法

L.count(var) #该元素在列表中出现的个数

L.index(var) #返回第一个var元素的位置,无则抛异常

元组（Tuple）

特点

元组（tuple）与列表类似，不同之处在于元组的元素不能修改（同字符串）。元组写在小括号里，元素之间用逗号隔开，类似于向量写法。元组中的元素类型也可以不相同。

>>> a = (1991, 2014, 'physics', 'math')
>>> print(a, type(a), len(a))
    (1991, 2014, 'physics', 'math')  <class 'tuple'>  4

元组由不同的元素组成，每个元素可以存储不同类型的数据，而元组中的元素则代表不同的数据项。
创建元组，不定长，但一旦创建后和字符串一样都是不可变的

>>> tup = (1, 2, 3, 4, 5, 6)
>>> print(tup[0], tup[1:5])
1 (2, 3, 4, 5)
>>> tup[0] = 11 # 修改元组元素的操作是非法的
Traceback (most recent call last):
        File "<pyshell#21>", line 1, in <module>
        tup[0] = 11
TypeError: 'tuple' object does not support item assignment

元组的（,）不可省略

创建只有一个元素的元组，该元素后面的逗号不可忽略

>>> tup2 = (20,) #创建只有一个元素的元组，该元素后面的逗号不可忽略
>>> tup2
(20,)
>>> tup3 = (20)
>>> tup3
20

+操作符

元组是不可添加删除的。另外，元组也支持用+操作符。
>>> tup1, tup2 = (1, 2, 3), (4, 5, 6)
>>> print(tup1+tup2)
(1, 2, 3, 4, 5, 6)

元组的嵌套

添加元组  
>>> user = ('01','02','03','04')
>>> user = (user,'05')
>>> user
(('01', '02', '03', '04'), '05')

访问元组

访问一元元组
>>> user = ('01','02','03','04')
>>>user[0]
    '01'
>>>user[2]
'03'

访问二元元组
>>>user1 = (1,2,3)  
    >>>user2 = (4,5,6)  
    >>>user = (user1,user2)  
    >>>print(user[1][2])
    6

元组的内置函数

内置函数

函数	描述
len(tuple)	计算元组元素个数。
max(tuple)	返回元组中元素最大值。
min(tuple)	返回元组中元素最小值。
tuple(list)	将列表转换为元组。

解包

>>> user = (1,2,3)
>>> a,b,c = user    #变量个数要等于元组的长度
>>> a
1
>>> b
2
>>> c
3

集合（Sets）

集合（set）是一个无序不重复元素的集，基本功能是去重。

可以使用大括号或者set()函数创建set集合。

注意：创建一个空集合必须用 set()而不是{ }，因为{ }是用来创建一个空字典。 >>> dic = {} #创建一个空字典

集合运算

>>> a = set('abracadabra')	#将字符串拆成集合
>>> a
{'b', 'd', 'r', 'a', 'c'}
>>> b = set('alacazam')    	#将字符串拆成集合
>>> b
{'l','m','z','a','c'}
>>> a-b                    	#从a中去除b的元素
{'b', 'd', 'r'}
>>> a|b                    	#a和b的并集
{'l','r','a','c','z','b','m','d'}
>>> a&b              		#提取 a和b的公共元素——交集
{'a', 'c'}
>>> a＾b    #提取 a和b中不同时存在的元素（交集的补集，也叫对称差）
{'l','r','z','m','b','d'}

去重

集合有过滤重复元素的功能，自动将重复的元素删除。

    >>> set((2,2,2,4,4))
    {2, 4}

字典（Dictionaries）

特点

字典是一种映射类型（mapping type），它是一个无序的“键: 值”对集合。每一个元素是pair，包含key、value两部分。key是Integer或string类型，value 是任意类型。即： {Key: Value}

>>> dic = {}    # 创建一个空字典
>>> dic_tel = {'Jack':1557, 'Tom':1320, 'Rose':1886}
        #创建一个字典
>>> print(dic_tel)
{'Tom': 1320, 'Rose': 1886, 'Jack': 1557}

【例2-5】打印通讯录
>>> name=["Ben","Jone","Jhon","Jerry","Anny","Ivy","Jan","Wong"]
>>> tel=[6601,6602,6603,6604,6605,6606,6607,6608]
>>> Tellbook={}  #创建一个空字典
>>> for i in range(len(name)):
        n1="{}".format(name[i])    #从name中取一个姓名
        t1="{}".format(tel[i])     #从tel中取一个电话
        Tellbook[n1]=t1    #再把d2这个号码赋值给字典Tellbook的d1键
>>> print(Tellbook)
{'Jan': '6607', 'Ben': '6601', 'Ivy': '6606', 'Anny': '6605', 'Wong': '6608', 'Jhon': '6603', 'Jone': '6602', 'Jerry': '6604'}

Tellbook['Wang'] = 3 
            #给键赋值，不管键是否存在，不存在则直接创建。
del Tellbook['Wong']     	# 删除一个键值对
Tellbook['Ben']          	#通过key查询对应的值
list(Tellbook.keys())    	# 返回所有key组成的list
list(Tellbook.values()) 	# 返回所有value组成的list
sorted(Tellbook.keys()) 	# 按key对字典排序
'Ben' in Tellbook         	# 成员测试
'Mary' not in Tellbook   	# 成员测试

构造函数 dict()

直接从键值对构建字典，如下：
>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'guido': 4127, 'jack': 4098, 'sape': 4139}
>>> dict(sape=4139, guido=4127, jack=4098)
{'guido': 4127, 'jack': 4098, 'sape': 4139}

item()方法

Items()方法：将字典里的元素（一个键值对）转化为元组作为列表的一个元素。

>>> d= {'a':1, 'b':2, 'c':3}
>>> t= d.items()
>>> print(t)
    dict_items([('b', 2), ('c', 3), ('a', 1)])
>>> list(t)
    [('b', 2), ('c', 3), ('a', 1)]

>>> t=[('a',1),( 'b',2),( 'c',3)]
>>> d=dict(t)
>>> print(d)
{'b': 2, 'c': 3, 'a': 1}

update()方法

Update可以合并两个字典

>>> dict = {'Name': 'Zara', 'Age': 7}
>>> dict2 = {'Sex': 'female' }
>>> dict.update(dict2)
>>> dict
{'Age': 7, 'Sex': 'female', 'Name': 'Zara'}

tuple()方法

用tuple作为键创建字典

>>> seq = ('name', 'age', 'sex')
>>> dict = dict.fromkeys(seq)  #给字典key赋值来自seq
>>> dict  #因为仅有key，没有vale，所以显示键值为空None
{'sex': None, 'age': None, 'name': None}
>>> dict = dict.fromkeys(seq, 10) #给字典键值对赋值，这里假设都赋10
>>> dict
{'sex': 10, 'age': 10, 'name': 10}

dictionary()方法

D.get(key,0)	#同dict[key]，多了个没有则返回指定的值（此处为0）
D.keys()	#返回字典键的列表
D.values()	#返回字典值的列表
D.items()	#将字典转化为元组作为元素的一个列表
D.update(dict2)	#合并字典，将dict2增加到当前的字典中
D.pop(key)	#从字典中删除指定的键值对，键名这个参数必须有。
D.popitem()	#没有参数则从字典中随机删除一个键值对。已空则抛异常
D.clear()	#清空字典，不同于del
D.copy()	#拷贝字典
Dict1=dict.copy()	#克隆，即另一个浅拷贝，深拷贝则是deepcopy，如下例

举例

>>> dict={'sex': 10, 'age': 10, 'name': 10}
>>> dict.get('sex', 'None')    #若没有sex键，则返回指定的None
    10

>>> dict.keys()      #要想获取键名列表，直接list(dict.keys())即可
    dict_keys(['sex', 'age', 'name'])

>>> dict.items()     #要想获取键值列表，直接tuple(dict.keys())即可
    dict_items([('sex', 10), ('age', 10), ('name', 10)])

>>> dict.pop('sex')       #删除sex键值对
    10
>>> dict
    {'age': 10, 'name': 10}
>>> dict['sex']=10    #增加键值对sex：10
>>> dict
    {'sex': 10, 'age': 10, 'name': 10}

>>> dict.popitem()  #随即删除一个键值对
('sex', 10)
>>> dict
{'age': 10, 'name': 10}

>>> dict1=dict.copy()  #复制(浅拷贝)一个字典，浅拷贝只对简单类型拷贝
>>> dict1
{'age': 10, 'name': 10}

>>> dict.clear()  #清空字典，不是删除字典，即得到一个空字典
>>> dict          #dict已经变成了一个空字典
{}

>>> import copy   #导入copy函数（或者是模块）
>>> dict=copy.deepcopy(dict1)   #深拷贝，将dict1拷贝给dict
>>> dict
{'age': 10, 'name': 10}

字典内置方法get()

>>>info={‘1’:’first’,’2’:’second’,’3’:’third’}
>>>print(info.get(input(‘input your number:’),’error’))
input your number:2
second

D.get(key,Name)：表示字典D中若有key这个键，则返回其键值，否则,返回指定的值Name.

字典排序

在程序中使用字典进行数据信息统计时，由于字典是无序的，所以打印字典时内容也是无序的。因此，为了使统计得到的结果更方便查看需要进行排序。Python中字典的排序分为按“键”排序和按“值”排序。

按“值”排序

可以使用内置的sorted()函数。
>>> dict={'班级': 1, 'age': 10, 'score': 10}
>>> sorted(dict.items(), key=lambda e:e[1], reverse=True)
[('score', 10), ('age', 10), ('班级', 1)]

说明：字典的items()函数返回的是一个列表，列表的每个元素是一个键和值组成的元组。sorted(dict.items(), key=lambda e:e[1], reverse=True)返回的值同样是由元组组成的列表。
其中e表示dict.items()中的一个元素，e[1]则表示按值排序。如果把e[1]改成e[0]，那么则是按键排序，reverse=False可以省略，默认为升序排列。

按“键”排序

对字典进行按键排序也可以使用上面的sorted函数，只要改为sorted(dict.items(), key=lambda e:e[0], reverse=True)就可以了。不过除了这个方式之外，还可通过列表的排序来达到使字典有序的目的。
在这里插入图片描述

字典的函数


Tellbook.key(
Tellbook.values(
Tellbook.clear()
t2=Tellbook.copy()
t3=dict.fromkeys(('Alice','Leo'),8888)
Tellbook.get('Ben')
Tellbook.get
Tellbook.setdefault('Jan',666)

type()

函数

strip、rstrip、lstrip

>>> theString = 'saaaay yes or no yaaaass'
>>> print(theString.strip('say'))
yes or no 
>>> theString
'saaaay yes or no yaaaass'

lstrip和rstrip原理是一样的。注意：当没有传入参数时，默认去除首尾空格。

>>> theString = 'saaaay yes or no yaaaass'
>>> theString
'saaaay yes or no yaaaass'

>>> print(theString.strip('say') )
yes or no 
>>> theString.strip('say')
' yes or no '
>>> theString.strip('say ')
'es or no'
>>> theString.lstrip('say')
' yes or no yaaaass'
>>> theString.rstrip('say')
'saaaay yes or no '

Python中没有字符类型的说法，只有字符串。

1.  按某一个字符分割，如‘.’
>>> str = ('www.i-nuc.com')
>>> print(str)
www.i-nuc.com
>>> str_split = str.split('.')
>>> print(str_split)
['www', 'i-nuc', 'com']

2. 按某一个字符分割，且分割n次。如按‘.’分割1次
>>> str = ('www.i-nuc.com')
>>> str_split = str.split('.',1)
>>> print(str_split)
['www', 'i-nuc.com']

3. 按某一字符（或字符串）分割，且分割n次，并将分割完成的字符串（或字符）赋给新的（n+1个）变量。如：按‘.’分割字符，且分割1次，并将分割后的字符串赋给2个变量str1，str2
>>> url = ('http://inuc.xin')
>>> str1, str2 = url.split('.', 1)
>>> print(str1，str2)    #注意中文逗号
SyntaxError: invalid character in identifier
>>> print(str1,str2)
http://inuc xin 
>>> print(str1)
http://inuc 
>>> print(str2)
xin

divmod

返回商和余数是一个tuple。
Divmod(被除数，除数)=(商，余数)
>>> t = divmod(7,3)
>>> t
(2, 1)

或者：
>>> quot,rem = divmod(7,3)
>>> print(quot,rem)
2 1

join

join把一个list、tuple中所有的元素按照定义的分隔符连接起来，但限于元素是字符型。
语法： ‘sep’.join(seq)

>>> a = ['a','b','c']
>>> sep = '|'
>>> "|".join(a)
'a|b|c'

>>> s=('1','2','3')
>>> "|".join(s)
'1|2|3'
>>> c=[1,2,3]
>>> '|'.join(c)
Traceback (most recent call last):
File "<pyshell#50>", line 1, in <module>
'|'.join(c)
TypeError: sequence item 0: expected str instance, int found
>>> c=['1','2','3']
>>> '|'.join(c)
'1|2|3'

只能连接字符串

a=['a','b','c']
'|'.join(a)

方法一：

a="Python is a widely used high-level"
#分割为若干个单词
#用capitalize()方法装换
#再join回去
lst = a.split()
li = []
for word in lst:
li.append(word.capitalize())
' '.join(li)
print(li)

常用的函数（汇总）

函数名	使用对象	形式	描述
strip()	字符串	theString.strip(‘say’)	去掉字符串两边的空格
lstrip	字符串	theString.lstrip(‘say’)	去掉字符串左边的空格
rstrip	字符串	theString.rstrip(‘say’)	去掉字符串右边的空格
split()	字符串	str.split(‘.’,1) —— 如按‘.’分割1次	对字符串进行分割
divmod()	公式	divmod(7,3)	divmod(被除数，除数) 返回值：（商，余数）
join()	字符串	‘sep’.join(seq)	split()，的逆操作
append（）	列表	w.append(q) [1, 2, ‘L’, [8, 9]]	元素添加到列表的结尾，相当于：a[len(a):]=[x]
extend（）	列表	w.extend(q) [1, 2, ‘L’, [8, 9]]	将一个给定列表中的所有元素，添加到另一个列表当中，相当于：a[len(a):]=L
insert()	列表	a.insert(1,‘love’)	在index位置插入var
reverse()	列表	e.reverse()	排序（倒序）
sort（）	列表	a.sort() e.sort(reverse=True)	排序（默认从小到大）
sorted（）	列表	sorted(a)	sorted(a)产生的是一个新列表，而a.sort()是对a直接排序了
pop（）	元组,列表,字典	L.pop(index) ——输入索引	默认删除最后一个元素
del（）	元组,列表,字典	del L[1]、del L[1:3]——输入下标
remove（）	列表	L.remove(var) ——输入元素	删除第一次出现的var元素
dict()	字典	dict([(‘sape’, 4139), (‘guido’, 4127), (‘jack’, 4098)])	构造函数
item()	字典	d.items()	将字典里的元素（一个键值对）转化为元组作为列表的一个元素。
update()	字典	dict.update(dict2)	Update可以合并两个字典
tuple()	字典	dict.fromkeys(seq, 10)	用tuple作为键创建字典
dictionary()	字典		https://www.notion.so/384c69e4e3654340bcd76112048980bd#fd66eafb2d7a4637b4a3ced12b10c00c
get()	字典	D.get(key,Name)	表示字典D中若有key这个键，则返回其键值，否则,返回指定的值Name.

锦囊！

排序：sort，sorted，reverse，reversed
增：lst[n:n]=[x]
删：a.pop(2)/a.pop(-2)，del a[2]