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 25 36 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()方法获取指定键所对应的值，语法格式为：dictionary.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，语法格式为：str.endswith(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])。

六、正则表达式

      行定位符用来描述子串的边界。“^”表示行的开始；“$”表示行的结尾。如^tm表示要匹配子串tm的开始位置是行头，如“tm equal Tomorrow Moon”就可以匹配，而“Tomorrow Moon equal tm”则不匹配。如果使用tm$，则后者可以匹配而前者不能匹配。如果要匹配的子串可以出现在字符串的任意部分，那么可以直接写成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次