Python列表、元组、字典、集合、字符串常⽤操作
⼀、列表
Python在采⽤负数作为索引值时，是从-1开始的，⽽不是从0开始，即最后⼀个元素的下标为-1。
切⽚操作是访问序列中元素的另⼀种⽅法，它可以访问⼀定范围内的元素。实现切⽚操作的语法格式：sname[start:end:step]。其中sname表⽰序列的名称；start表⽰切⽚的开始位置（包括该位置），如果不指定，则默认为0；end表⽰切⽚的截⽌位置（不包括该位置），如果不指定则默认为序列的长度；step表⽰切⽚的步长，如果省略，则默认为1，当省略该步长时，最后⼀个冒号也可以省略。列表的切⽚并没有破坏原有的列表，⽽是根据语法规则，建⽴了⼀个原有列表的部分副本。
len()函数计算序列的长度，max()函数返回序列中的最⼤值，min()函数返回序列中的最⼩值，list()函数将序列转换成列表，str()将序列转换成字符串，sum()计算元素
和，sorted()对元素进⾏排序。
列表的基本操作
append(x)：将x追加到列表尾部
extend(L)：将列表L中所有的元素追加到列表的尾部
insert(index, x)：在列表index位置处插⼊x，该位置后⾯的所有元素后移并且在列表中的索引加1，如果index为正数且⼤于列表长度则在列表尾部追加x，如果index为负数且⼩于列表长度的相反数则在列表头部插⼊元素x
remove(x)：在列表中删除第⼀个值为x的元素，该元素之后所有元素前移并且索引减1，如果列表中不存在x则抛出异常
pop(index)：删除并返回列表中下标为index的元素，如果不指定index则默认为-1，弹出最后⼀个元素；如果弹出中间位置的元素则后⾯的元素索引减1；如果index不是[-L，L]区间上的整数则抛出异常
clear()：清空列表，删除列表中所有的元素，保留列表对象
index(x)：返回列表中第⼀个值为x的元素的索引，若不存在值为x的元素则抛出异常
count(x)：返回x在列表中出现的次数
reverse()：对列表所有元素进⾏原地逆序，⾸位交换
sort(key=None, reverse=False)：对列表中的元素进⾏原地排序，key⽤来指定排序规则，reverse为False表⽰升序，True表⽰降序
copy()：返回列表的浅复制
列表对象提供了sort()⽅法⽤于对原列表中的元素进⾏排序，基本语法格式为：listname.sort(key=None, reverse=False)，其中key表⽰指定⼀个从每个元素中提取⼀个⽤于⽐较的键，例如“key=str.lower”表⽰在排序时不区分字母⼤⼩写；reverse为可选参数，如果指定其值为True，则表⽰降序排列，如果是False，则表⽰升序排列，默认为升序排列。
sorted()也可以⽤于排序，基本语法为sorted(iterable, key=None, reverse=False)，其中iterable表⽰要进⾏排序的列表名称。列表对象的sort()⽅法和内置sorted()函数的作⽤相同，不同的是使⽤sort()⽅法时，会改变原列表的排列顺序，⽽使⽤sorted()函数时，会建⽴⼀个原列表的副本，该副本为排序后的列表。
（1）列表的添加：append()、insert()、entend()
append()⽤于向列表尾部追加⼀个元素，insert()⽤于向列表任意指定位置插⼊⼀个元素，extend()⽤于将另⼀个列表中的所有元素追加⾄当前列表的尾部。这3个⽅法都属于原地操作，不影响列表对象在内存中的起始地址。
（2）列表的删除：pop()、remove()、clear()
pop()⽤于删除并返回指定位置（默认是最后⼀个）上的元素；remove()⽤于删除列表中第⼀个值与指定值相等的元素；clear()⽤于清空列表中的所有元素。这3个⽅法也属于原地操作。
random.shuffle(x)：把列表x中的元素随机乱序。
乘法运算符*可以⽤于列表和整数相乘，表⽰列表重复，返回新列表。运算符*=也可以⽤于列表元素重复，属于原地操作。
enumerate()函数返回包含若⼲下标和值的迭代对象。
>>> a = ['a','b','c','d']
>>> enumerate(a)
<enumerate object at 0x7ffc2e3af940>
>>> list(enumerate(a))
[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]
map()函数把函数映射到列表上的每个元素，filter()函数根据指定函数的返回值对列表元素进⾏过滤。
all()函数⽤来测试列表中是否所有元素都等价于True，any()⽤来测试列表中是否有等价于True的元素。
zip()函数将多列表元素进⾏重新组合。如果两个列表不等长，以短的为准
>>> a = [1,2,3]
>>> b = ['a','b','c']
>>> zip(a,b)
<zip object at 0x7ffc2e3af040>
>>> list(zip(a,b))
[(1, 'a'), (2, 'b'), (3, 'c')]
>>> c = [4,5,6]
>>> d = ['e','f']
>>> list(zip(c,d))
[(4, 'e'), (5, 'f')]
列表推导式
a_list = [x*x for x in range(10)]
相当于
a_list = []
for x in range(10):
a_list.append(x*x)
⼆、元组
列表和元组的区别：（1）列表属于可变序列，它的元素可以随时修改或者删除；⽽元组属于不可变序列，其中的元素不可以修改，除⾮整体替换。（2）列表可以使⽤append()、extend()、insert()、remove()和pop()等⽅法实现添加和修改列表元素；⽽元组则没有这⼏个⽅法，因为不能向元组中添加和
修改元素，同样也不能删除元素。（3）列表可以使⽤切⽚访问和修改列表中的元素；元组也⽀持切⽚，但是它只⽀持通过切⽚访问元组中的元素，不⽀持修改。（4）列表不能作为字典的键，⽽元组则可以。
⽣成器推导式的⽤法与列表的推导式⾮常相似，在形式上⽣成器推导式使⽤圆括号作为定界符，⽽不是列表推导式所使⽤的⽅括号。
字符串函数注册登录与列表推导式最⼤的不同是，⽣成器推导式的结果是⼀个⽣成器对象。⽣成器对象类似于迭代器对象，具有惰性求值的特点，只在需要时⽣成新元素，⽐列表推导式具有更⾼的效率，空间占⽤⾮常少，尤其适合⼤数据处理的场合。
使⽤⽣成器对象的元素时，可以根据需要将其转化为列表或元组，也可以使⽤⽣成器对象的__next__()⽅法或者内置函数next()进⾏遍历，或者直接使⽤for循环来遍历其中的元素。但是不管使⽤哪种⽅法访问其中的元素，只能从前往后正向访问每个元素。当所有元素访问结束以后，如果需要重新访问其中的元素，必须重新创建该⽣成器对象。
使⽤⽣成器对象__next__()⽅法或内置函数next()进⾏遍历
>>> g = ((i+2)**2 for i in range(10)) #创建⽣成器对象
>>> g
<generator object <genexpr> at 0x7fcd9de095f0>
>>> tuple(g) #将⽣成器对象转换为元组
(4, 9, 16, 25, 36, 49, 64, 81, 100, 121)
>>> list(g) #⽣成器对象已遍历结束，没有元素了
[]
>>> g = ((i+2)**2 for i in range(10)) #重新创建⽣成器对象
>>> g.__next__() #使⽤⽣成器对象的__next__()⽅法获取元素
4
>>> g.__next__() #获取下⼀个元素
9
>>> next(g) #使⽤函数next()获取⽣成器对象中的元素
16
使⽤for循环直接迭代⽣成器对象中的元素
>>> g = ((i+2)**2 for i in range(10))
>>> for item in g:  #使⽤循环直接遍历⽣成器对象中的元素
print(item, end=' ')
4 9 16 2
5 3
6 49 64 81 100 121
三、字典
通过映射函数创建字典，语法格式为：dictionary=dict(zip(list1,list2))，其中dictionary表⽰字典名称；zip
()函数⽤于将多个列表或元组对应位置的元素组合成元组；list1为⼀个列表，⽤于指定要⽣成字典的键；list2⽤于指定要⽣成字典的值。返回值，如果list1和list2的长度不同，则与最短的列表长度相同。
>>> name = ['姓名','年龄','学号']
>>> sige = ['xiaoming','21','6005']
>>> dictionary = dict(zip(name,sige))
>>> dictionary
{'姓名': 'xiaoming', '年龄': '21', '学号': '6005'}
通过给定的“键值对”创建字典，语法格式为：dictionary=dict(key1=value1,key2=value2,…,keyn=valuen)。
>>> dictionary = dict(姓名='xiaoming'，年龄=21，学号=6005)
>>> dictionary
{'姓名': 'xiaoming', '年龄': 21, '学号': 6005}
可以使⽤dict对象的fromkeys()⽅法创建值为空的字典，语法格式为：dictionary=dict.fromkeys(list1)，其中list1为字典的键的列表。
>>> list = ['name','age','sex']
>>> dictionary = dict.fromkeys(list)
>>> dictionary
{'name': None, 'age': None, 'sex': None}
在Python中，访问字典的元素可以通过下标的⽅式实现，与列表和元组不同，这⾥的下标不是索引号，⽽是键。
Python中推荐的⽅法是使⽤字典对象的get()⽅法获取指定键所对应的值，语法格式为：(key,[default])，其中key为指定的键；default为可选项，⽤于指定当指定的键不存在时，返回⼀个默认值，如果省略，则返回None。
>>> a = {'name':'xiaoming','age':21,'sex':'man'}
>>> a.get('name')
'xiaoming'
>>> a.get('RNG','Uzi')
'Uzi'
使⽤字典对象的items()⽅法可以获取字典的“键值对”列表，语法格式为：dictionary.items()，返回值为可遍历的“键值对”的元组列表。想要获取到具体的“键值对”，可以通过for 循环遍历该元组列表。
>>> a = {'name':'xiaoming','age':21,'sex':'man'}
>>> a.items()
dict_items([('name', 'xiaoming'), ('age', 21), ('sex', 'man')])
>>> for b in a.items():
print(b)
('name', 'xiaoming')
('age', 21)
('sex', 'man')
使⽤字典对象的items()⽅法可以返回字典的键、值对。使⽤字典对象的keys()⽅法可以返回字典的键。使⽤字典对象的values()⽅法可以返回字典的值。
问题解决：⾸先⽣成包含1000个随机字符的字符串，然后统计每个字符的出现次数
>>> import string
>>> import random
>>> x = string.ascii_letters + string.digits + string.punctuation
#string.ascii_letters⽤来⽣成全部⼩写字母和全部⼤写字母
#string.digits⽤来⽣成0-9的数字
#string.punctuation⽤来⽣成特殊字符
>>> y = [random.choice(x) for i in range(1000)] #列表推导式⽣成1000个随机字符
>>> z = ''.join(y) #将1000个随机字符转为字符串
>>> d = dict() #使⽤字典保存每个字符出现的次数
>>> for ch in z:
d[ch] = d.get(ch, 0) + 1
当以指定键为下标为字典元素赋值时，有两种含义：1）若该键存在，则表⽰修改该键对应的值；2）若不存在，则表⽰添加⼀个新的键：值对，也就是添加⼀个新元素。
可以⽤del dictionary[key]来删除不需要的元素。
使⽤字典对象的update()⽅法可以将另⼀个字典的键：值⼀次性全部添加到当前字典对象，如果两个字典中存在相同的键，则以另⼀个字典中的值为准对当前字典进⾏更新。>>> a = {'age':37,'score':[98,97],'name':'xiao','sex':'male'}
>>> a.update({'a':97,'age':39}) #修改age键的值，同时添加新元素'a':97
>>> a
{'age': 39, 'score': [98, 97], 'name': 'xiao', 'sex': 'male', 'a': 97}
如果需要删除字典中指定的元素，可以使⽤del命令。
>>> del a['age']
>>> a
{'score': [98, 97], 'name': 'xiao', 'sex': 'male', 'a': 97}
也可以使⽤字典对象的pop()和popitem()⽅法弹出并删除指定的元素。
>>> a.popitem() #弹出⼀个元素，对空字典会抛出异常
('a', 97)
>>> a.pop('sex') #弹出指定键对应的元素
'male'
>>> a
{'score': [98, 97], 'name': 'xiao'}
四、集合
在Python中可以直接使⽤{}创建set集合，语法格式为：setname={element 1,element2,……, element n}。也可以使⽤set()函数将列表、元组等其他可迭代对象转换为集合，语法格式为：setname=set(iteration)，其中iteration表⽰要转换为集合的可迭代对象，可以是列表、元组、range对象等，也可以是字符串，如果是字符串，返回的集合将是包含全
部不重复字符的集合。
使⽤集合对象的add()⽅法可以增加新元素，如果该元素已存在则忽略该操作，不会抛出异常；update()⽅法⽤于合并另外⼀个集合中的元素到当前集合中，并⾃动去除重复元
素。
pop()⽅法⽤于随机删除并返回集合中的⼀个元素，如果集合为空则抛出异常；remove()⽅法⽤于删除集合中的元素，如果指定元素不存在则抛出异常；discard()⽤于从集合
中删除⼀个特定元素，如果元素不在集合中则忽略该操作；clear()⽅法清空集合，删除所有元素。
五、字符串
字符串的拼接可以直接使⽤“+”实现，但字符串不允许直接与其他类型的数据拼接。len()函数计算字符串的长度，在默认情况下，通过len()函数计算字符串的长度时，不区分
英⽂、数字和汉字，所有字符都认为是⼀个。可以通过使⽤encode()⽅法进⾏编码后再进⾏获取。
切⽚⽅法可以截取字符串，语法格式为：string[start : end : step]，其中string表⽰要截取的字符串；start表⽰要截取的第⼀个字符的索引，如果不指定，则默认为0；end表⽰
要截取的最后⼀个字符的索引，不指定则默认为字符串的长度；step表⽰切⽚的步长。
字符串对象的split()⽅法可以实现字符串分割，也就是把⼀个字符串按照指定的分隔符切分为字符串列表，该列表的元素中，不包括分隔符，语法格式为：str.split(sep,
maxsplit)，其中str表⽰要进⾏分割的字符串；sep⽤来指定分隔符，默认为None，即所有空字符；maxsplit为可选参数，⽤于指定分割的次数。在split()⽅法中，如果不指定sep
参数，那么也不能指定maxsplit参数。
>>> s = 'apple,peach,banana,pear'
>>> s.split(',')
['apple', 'peach', 'banana', 'pear']
count()⽅法⽤来返回⼀个字符串在当前字符串中出现的次数。
find()⽅法⽤于检索是否包含指定的⼦字符串，如果检索的字符串不存在，则返回-1，否则返回⾸次出现该⼦字符串时的索引。rfind()⽤来查⼀个字符串在另⼀个字符串指定
范围中最后⼀次出现的位置，如果不存在则返回-1。
>>> s = 'apple,peach,banana,peach,pear'
>>> s.find('peach')
6
>>> s.find('peach',7)
19
>>> s.find('peach',7,20)
-1
>>> s.rfind('p')
25
index()和rindex()⽅法⽤来返回⼀个字符串在另⼀个字符串指定范围中⾸次和最后⼀次出现的位置，如果不存在则抛出异常。
字符串连接join()
>>> li = ['apple','peach','banana','pear']
>>> ','.join(li)
'apple,peach,banana,pear'
>>> '.'.join(li)
'apple.peach.banana.pear'
>>> '::'.join(li)
'apple::peach::banana::pear'
startswith()⽅法⽤于检索字符串是否以指定⼦字符串开头，如果是则返回True，否则返回False，语法格式为：str.startswith(prefix[,start[,end]])，其中prefix表⽰要检索的⼦字
符串。
endswith()⽅法⽤于检索字符串是否以指定⼦字符串结尾，如果是返回True，否则返回False，语法格式为：dswith(suffix[,start[,end]])，其中suffix表⽰要检索的⼦字符
串。
lower()⽅法⽤于将字符串中的⼤写字母转换为⼩写字母，语法格式为：str.lower()。
upper()⽅法⽤于将字符串中的⼩写字母转换为⼤写字母，语法格式为：str.upper()。
capitalize()⽅法，字符串⾸字符⼤写。
title()⽅法，每个单词的⾸字母⼤写。
swapcase()⽅法，⼤⼩写互换。
查替换replace()，类似于word中的“全部替换”功能。
>>> s = '中国，中国'
>>> s
'中国，中国'
>>> s2 = s.replace('中国','中华⼈民共和国')
>>> s2
'中华⼈民共和国，中华⼈民共和国'
strip()⽅法⽤于去掉字符串左、右两侧的空格和特殊字符，语法格式为：str.strip([chars])，其中str为要去掉空格的字符串；chars为可选参数，⽤于指定要去掉的字符，可以指
定多个，如果不指定chars参数，默认将去除空格、制表符“\t”、回车符“\r”、换⾏符“\n”等。
lstrip()⽅法⽤于去掉字符串左侧的空格和特殊字符，语法格式为：str.lstrip([chars])。
rstrip()⽅法⽤于去掉字符串右侧的空格和特殊字符，语法格式为：str.rstrip([chars])。
六、正则表达式
⾏定位符⽤来描述⼦串的边界。“^”表⽰⾏的开始；“
”表⽰⾏的结尾。如t m表⽰要匹配⼦串tm的开始位置是⾏头，如“tmequalTomorrowMoon”就可以匹配，⽽“TomorrowMoonequaltm”则不匹配。如果，则后者可以匹配⽽前者不能匹配。如果要匹配的⼦串可以出现在字符串的任意部分，那么可以直接写成tm。
常⽤的元字符：
.：匹配除换⾏符以外的任意字符
\w：匹配字母、数字、下划线或汉字
\W：匹配除字母、数字、下划线或汉字以外的字母
\s：匹配单个的空⽩符（包括<Tab>键和换⾏符）
\S：除单个空⽩字符以外的所有字符
\d：匹配数字
\b：匹配单词的开始或结束，单词的分界符通常是空格、标点符号或者换⾏
^：匹配字符串的开始
$：匹配字符串的结束
常⽤的限定符：
？：匹配前⾯的字符零次或⼀次（colou?r，该表达式可以匹配colour和color）      +：匹配前⾯的字符⼀次或多次（go+gle，该表达式可以匹配的范围从gogle到goo…gle）      *：匹配前⾯的字符零次或多次（go*gle，该表达式可以匹配的范围为ggle到goo…gle）
{n}：匹配前⾯的字符n次（go{2}gle，该表达式只匹配google）
{n,}：匹配前⾯的字符最少n次（go{2,}，该表达式可以匹配的范围从google到goo…gle）
{n,m}：匹配前⾯的字符最少n次，最多m次
Processing math: 100%

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。