- 运算符
- 算数运算符
- 比较运算符
- 赋值运算符
- 数据类型
- 数字（Numbers）
- 字符串（String）
- 引号的使用
- 索引、切片、包含判断
- string模块提供的方法、内置函数、str转换
- Range (左闭右开)
- 列表（List）
- 对字符串的操作
- List索引与切片
- List串联操作
- 字符串转换为列表
- 排序
- 元素追加：append()、extend()、insert()
- 删除：pop()、del()、remove()
- List操作符：":"、"+"、"*"
- List索引
- List其他方法
- 元组（Tuple）
- 特点
- 访问元组
- 元组的内置函数
- 解包
- 集合（Sets）
- 集合运算
- 去重
- 字典（Dictionaries）
- 特点
- 构造函数 dict()
- item()方法
- update()方法
- tuple()方法
- dictionary()方法
- 字典内置方法get()
- 字典排序
- 字典的函数
- 函数
- strip、rstrip、lstrip
- Python中没有字符类型的说法，只有字符串。
- divmod
- join
- 常用的函数（汇总）
运算符 算数运算符欢迎访问我搞事情的【知乎账号】：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=c**a |
| %= | 模赋值运算符 | c%=a→ c=c%a |
| /= | 除法赋值运算符 | c/=a → c=c/a |
| *= | 乘法赋值运算符 | c*=a → c=c*a |
查看数据类型的方法：type(变量名) >>> a = 1 #int >>> type(a)字符串（String） 引号的使用>>> b = True #boolean >>> type(b) >>> c = 4+3j #complex >>> type(c) >>> d = 3.14 #float >>> type(d)
使用单引号('）
可以用单引号指示字符串，就如同’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
字符串分片的扩展形式
[ i : j : k ]：起始位置，终止位置，步长（终止位置取不到）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’) | 寻找字符串中最小的字符 |
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 "", line 1, in
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') 4
元组与字符串类似，可以被索引且下标索引从0开始，也可以进行截取切片，其实，可以把字符串看作一种特殊的元组。
- 元组由不同的元素组成，每个元素可以存储不同类型的数据，而元组中的元素则代表不同的数据项。
- 创建元组，不定长，但一旦创建后和字符串一样都是不可变的
>>> 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 "", line 1, in
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 1join
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 "", line 1, in
'|'.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]
