赵工的个人空间

Python有多种数据类型，其中一些是复合数据类型，也就是数据结构，是通过某种方式组织在一起的数据元素的集合，这些数据元素可以是数字或者字符，甚至可以是其他数据结构。Python中的复合数据类型包括字符串、列表、元组、字典和集合，最基本的数据结构是序列sequence，字符串和列表、元组都可以看作是序列。

一、字符串与正则表达式：

字符串是字符的有序集合，Python中字符串是用单引号、双引号或三引号括起来的若干个字符。Python中的字符串是只读的，只能新建一个字符串去改变一个字符串中的元素。

1. 字符串编码：

Python 3.x中，字符串都是使用Unicode编码的字符序列。Unicode编码是为全世界所有语言的字符而设计，使用4字节的数字编码来表达每个字符、符号或文字。
Unicode编码有不同的实现方式，普遍使用的是UTF-8。UTF-8是一种变长的编码系统，对于ASCII字符使用1字节来编码，对扩展拉丁字符使用2字节来编码，而中文字符则使用3个字节，一些更复杂的字符则占用4个字节。UTF-8支持中英文编码，在英文系统也可以显示中文。Python支持UTF-8编码，中文字符、希腊字母也可以作为标识符使用。
1）ord()和chr()函数：
Python提供了ord和chr两个内置函数，用于字符与其机器内部编码值之间的转换。ord()函数将一个字符转化为相应的编码值，chr()函数则将一个整数转换成Unicode字符。示例：
print(ord('a'), ord('A')) # 输出97 65
print(chr(97), chr(65)) # 输出a A
print(ord('汉'), ord('字')) # 输出27721 23383
print('{:x},{:x}'.format(27721,23383)) # 输出6c49 5b57
print(chr(27721), chr(23383)) # 输出 汉 字
print(chr(0x6c49), chr(0x5b57)) # 输出 汉 字
2）encode()和decode()方法：
Python中，通过字符串的encode()方法，从Unicode编码转为指定的编码方式。
·s.encode("utf-8")：字符串s从Unicode编码为UTF-8编码
decode()方法从指定编码方式解码为Unicode方式。
·s.decode("utf-8")：字符串s从UTF-8编码解码为Unicode编码
3）其他转换：
int函数可将字符串表示的值转换为数值类型，如果是带有小数点的字符串可以使用float函数转换为浮点数类型。

2. 字符串基本操作：

1）字符串的索引：
字符串是按顺序放置的字符序列，其中的字符可以通过索引提取，最左边的字符索引为0，最右边字符索引是字符串长度减1.Python还支持负数索引，表示从右向左索引，最右边字符的索引是-1。
字符串的索引用中括号括起来。示例：
s="Hello"
print(s[1],s[4])
Python中的字符串是只读的，不支持通过索引为其中某个元素赋值，只能新建一个字符串去改变一个字符串中的元素。
2）字符串分片：
分片用来从字符串中分离、提取一部分内容，还可以用于提取部分数据、分离前缀后缀等，使用冒号分隔偏移索引的方式获取所标识的连续的内容。格式：i:j:k
左边的偏移被取作下边界，包含下边界在内，而右边的偏移值被认为是上边界，不包括上边界。如果省略上下边界，默认值分别为0和分片对象的长度。示例：
stu="hello world"
print(stu[1:3])
print(stu[1:])
print(stu[:-1])
print(stu[:])
其中，stu[:]获取的是所有字符串。分片还有第3个参数，为步长。如果只要获取偶数索引字符，可以使用：print(stu[1:-1:2])

3. 字符串的连接：

1）基本的连接操作：
Python使用“+”运算符将两个字符串连接起来，成为一个新的字符串。将字符串与数值进行连接，需要使用str()或repr()函数将数值转换成字符，然后进行连接。示例：
s="Python"+" "+str(3.6)
2）重复连接操作：
Python中可以使用“*”运算符构建一个由其自身字符重复连接而成的字符串。格式：
s*n或n*s
其中，s是一个字符串，n是一个正整数，代表重复的个数。示例：
"ABCD"*3
3）复合赋值：
字符串支持复合赋值+=和*=操作。示例：
a='xyz'
a*=3
4）join()函数：
Python中字符串是只读的，当使用“+”连接两个字符串时会生成一个新的字符串，新生成的字符串需要重新申请内存，当使用连加连接多个字符串时效率较低。对于连加操作，可以使用join()函数，这样只需要申请一次内存。示例：
""+join(['Python',' ','Program'])
其中，s.join()函数使用s为分隔符，把列表中的元素连接成一个字符串。

4. 字符串逻辑操作：

字符串也可以参与逻辑比较，操作结果是一个逻辑量。
1）关系操作：
字符比较是按计算机内部字符编码值的大小进行比较，西文字符按ASCII码值大小进行比较。比较的基本规则是，空格字符最小，数字比字母小，大写字母比小写字母小。
当进行字符串比较时，如果只包含单个字符按字符比较规则进行；两个字符串长度相同时，从左至右逐个比较，如果所有字符都相等则两个字符串相等，如果两个字符串中有不同的字符，以最左边的第1对不同字符的比较结果为准；两个字符串中字符个数不等时，则将较短的字符串后面补足空格后再比较。
2）成员关系操作：
字符串可以使用成员操作in和not in，用于判断前面的字符串是否属于后面的字符串。

5. 字符串的常用方法：

Python中，字符串类型可以看成一个类，而一个具体的字符串可以看成一个对象，该对象有很多方法。因为字符串是只读的，不能改变，任何对字符串的改变都会产生一个新的字符串。
1）字母大小写转换：
·s.upper()：全部转换为大写字母
·s.lower()：全部转换为小写字母
·s.swapcase()：字母大小写互换
·s.capitalize()：首字母大写，其余小写
·s.title()：首字母大写
2）字符串对齐处理：
·s.ljust(width,[fillchar])：输出width个字符，s左对齐，右边不足部分用fillchar填充，默认用空格填充
·s.rjust(width,[fillchar])：输出width个字符，s右对齐，左边不足部分用fillchar填充，默认用空格填充
·s.center(width,[fillchar])：输出width个字符，s中间对齐，两边不足部分用fillchar填充，默认用空格填充
·s.zfill(width)：把s变成width长，并且右对齐，左边不足部分用0填充
3）字符串搜索：
·s.find(substr,[start,[end]])：返回s中出现substr的第1个字符的编号，如果s中没有substr则返回-1。start和end作用就相当于在s[start:end]中搜索。
·s.index(substr,[start,[end]])：与find()相同，只是s中没有substr时会返回一个运行时错误。
·s.rfind(substr,[start,[end]])：返回s中出现substr的第1个字符的编号，如果s中没有substr则返回-1，也就是说从右边算起的第1次出现的substr的首字母编号。
·s.rindex(substr,[start,[end]])：与rfind()相同，只是s中没有substr时会返回一个运行时错误。
·s.count(substr,[start,[end]])：计算substr在s中出现的次数。
·s.startswith(prefix,[start,[end]])：是否以prefix开头，若是返回True，否则返回False。
·s.endswith(suffix,[start,[end]])：是否以suffix结尾，若是返回True，否则返回False。
4）字符串替换：
·s.replace(oldstr,newstr,[count]])：把s中的oldstr替换为newstr，count为替换次数。
·s.strip([chars]])：把s中前后chars中有的字符全部去掉，可以理解为把s前后chars替换为None，默认去掉前后空格。
·s.lstrip([chars])：把s左边chars中有的字符全部去掉，默认去掉左边空格。
·s.rstrip([chars])：把s右边chars中有的字符全部去掉，默认去掉右边空格。
·s.expandtabs([tabsize])：把s中的tab字符替换为空格，每个tab替换为tabsize个空格，默认是8个。
还有一个translate()函数，只处理单个字符，同时可进行多个字符的替换，替换效率比replace()高。translate()函数可以根据deletechars删除字符，可以根据包括256个字符转换规则的table转换字符，使用比较繁琐。可使用string模块提供的maketrans函数来实现替换。
5）字符串的拆分与组合：
·s.split(sep,[maxsplit])：以sep为分隔符，把字符串s拆分成一个列表，默认的分隔符为空格。maxsplit表示拆分的次数，默认取-1，表示无限制拆分。
·s.rsplit(sep,[maxsplit])：从右侧把字符串s拆分成一个列表。
·s.splitlines([keepends])：把s按行拆分，分为一个列表。keepends是一个逻辑值，如果为True，则每行拆分后会保留行分隔符\n。
·s.partition(sub)：从sub出现的第1个位置起，把字符串s拆分成一个3元素的元组(sub左边字符,sub,sub右边字符)。如果s中不包含sub，则返回(s,",")。
·s.rpartition(sub)：从右侧开始，把字符串s拆分成一个3元素的元组(sub左边字符,sub,sub右边字符)。如果s中不包含sub，则返回(s,",")。
·s.join(seq)：把seq代表的序列组合成字符串，用s将序列各元素连接起来。字符串中的字符是不能修改的，如果要修改，通常的方法是用list()函数把字符串s变为单个字符串为成员的表，再使用给列表成员赋值的方式改变值，最后再使用join()还原成字符串。
6）字符串类型测试：
字符串类型测试函数返回的都是逻辑值。
·s.isalnum()：是否全是字母和数字，并至少有一个字符。
·s.isalpha()：是否全是字母，并至少有一个字符。
·s.isdigit()：是否全是数字，并至少有一个字符。
·s.isspace()：是否全是空格，并至少有一个字符。
·s.islower()：s中的字母是否全是小写。
·s.isupper()：s中的字母是否全是大写。
·s.istitle()：s是否为首字母大写。
7）字符串转换为时间类型：
strptime()函数将字符串转换为时间类型。语法格式：
strptime(substring, format)
其中，substring为需要转换的字符串，format为输出时间格式。使用strptime()函数后往往还需要进行第2次转换，使用datetime()函数。语法：
datetime(year, month, day)
其中，year代表年，month代表月，day代表日，有时还使用可选参数时、分、秒。返回结果是一个datetime类型的变量。

示例：
import time;
import datetime;
t=time.strptime('2011-3-8','%Y-%m-%d')
y,m,d=t[0:3]
print(datetime.datetime(y,m,d))

6. 字节类型：

Python中，字节类型由编码介于0~255之间的字符组成的序列，分为不可变字节类型和可变字节类型，分别用bytes类型符和bytearray类型符表示。在字符串前面加“b”可以定义bytes对象，bytes对象中的每一个字符可以是一个ASCII字符或\x00~\xff的十六进制数。
by=b'abcd\x65' # 为b'abcde'
type(by) # 显示 <class 'bytes'>
可以使用内置的len()函数求bytes对象的长度，也可以使用“+”运算符连接两个bytes对象，操作结果是一个新的bytes对象。
可以使用索引来访问bytes对象中的某个字符，对bytes对象做这种操作的返回值为整数，是一个0~255之间的整数。
bytes对象是不可改变的，不能对其赋值。如果需要改变某个字节，可以组合使用字符串的分片和连接操作，也可以将bytes对象转换为bytearray对象，bytearray对象是可以被修改的。示例：
by=b'abcd\x65'
barr=bytearray(by) # 变为 bytearray(b'abcde')
barr[0]=102
barr # 变为 bytearray(b'fbcde')
使用内置函数bytearray()来完成从bytes对象到可变的bytearray对象的转换，所有对bytes对象的操作也可以用在bytearray对象上。不同的是，可以使用索引给bytearray对象的某个字节赋值，并且这个值必须是0~255之间的整数。
bytes对象和字符串是不可以混在一起的，比如将bytes对象和字符串连接就会出错，也不能对bytes对象的出现次数进行计数，因为其中没有字节字符。Python不会隐含地将bytes对象转换成字符串，或将字符串转换成bytes对象。
bytes对象有一个decode()方法，它使用某种字符编码作为参数，然后依照这种编码方式将bytes对象转换为字符串；对应地，字符串有一个encode()方法，也使用某种字符编码作为参数，然后按照它将字符串转换为bytes对象。

7. 正则表达式：

正则表达式是一种可用于模式匹配和替换的强大工具。正则表达式由字母、数字和特殊字符组成，特殊字符分为元字符和定位字符等，元字符用于描述前导字符在被匹配的对象中出现的方式。使用正则表达式时需要定界符，可以使用{}来控制字符重复的次数。
Python中的re模块集成了正则表达式的全部功能，提供了一系列方法用于正则表达式的匹配和替换，常用函数有：

re模块中的大部分函数都有flags参数，用来设置匹配的附加选项。

1）re.match()函数：
match(string[, pos[, endpos]]) | re.match(pattern, string[, flags])
该函数从string的pos下标处开始尝试匹配，如果pattern匹配结束时仍可匹配，那么将会返回一个Match对象；如果匹配过程中pattern无法匹配，或者匹配未结束就已到endpos，则返回None。pos和endpos的默认值分别为0和len(string)，参数flags用于编译pattern时指定匹配模式。
该函数并不是完全匹配。如果pattern结束时string还有剩余字符，仍然视为成功；如果要完全匹配，可以在表达式末尾加上边界匹配符$。
2）re.search()函数：
search(string[, pos[, endpos]]) | re.search(pattern, string[, flags])
该函数从string的pos下标处开始尝试匹配pattern，如果pattern匹配结束仍可匹配，则返回一个Match对象；若无法匹配，则将pos加1后重新尝试匹配，直到pos=endpos时仍无法匹配则返回None。
pos和endpos的默认值分别为0和len(string)，参数flags用于编译pattern时指定匹配模式。
3）re.findall()函数：
找到所有正则表达式匹配的字符串，并把它们作为一个列表返回。语法：
findall(string[, pos[, endpos]]) | re.findall(pattern, string[, flags])
示例：
import re
p=re.compile(r'\d+')
print(p.findall('ine1tow2three3four4'))
4）re.finditer()函数：
在字符串中找到正则表达式所匹配的所有子串，并组成一个迭代器返回。语法：
finditer(string[, pos[, endpos]]) | re.findall(pattern, string[, flags])
5）re.sub()函数：
该函数用来替换正则表达式中所匹配的选项内容。语法：
sub(repl[, string[, count]]) | re.sub(pattern, repl, string[, count])
count是模式匹配后替换的最大次数，必须是非负整数，缺省值0表示替换所有的匹配。该函数被替换后，如果匹配模式没有发现，则string原样返回。
6）re.subn()函数：
subn()函数功能和sub()函数相同，但返回新的字符串以及替换的次数组成的元组。语法：
subn(repl[, string[, count=0]]) | re.subn(pattern, repl, string[, count, flag])
7）re.split()函数：
将字符串在匹配的地方分片并生成一个列表。语法：
split( string[, maxsplit]]) | re.split(pattern, string[, maxsplit, flag])
参数maxsplit用于指定最大分割次数，不指定将全部分割。
8）re.compile()函数：
使Pattern类的工厂方法，用于将字符串形式的正则表达式编译为Pattern对象。语法：
re.compile(strPattern[, flag])
其中，flag是匹配模式，取值可以使用按位或运算符“|”表示同时生效。
9）re.escape(pattern)函数：
该函数用于在string中的正则表达式之前加上转义字符再返回，在需要大量匹配元字符时有用。

二、序列sequence：

Python中的字符串、列表和元组数据类型均属于序列类型，它们的每个元素是按照位置编号顺序存取，序列也不同于其他语言中的数组，因为列表和元组可以存储不同类型的元素，使得批量数据组织和处理更加方便灵活。序列中的每个元素被分配一个序号，即元素的位置，称为索引，序列可以使用索引操作符和分片操作符。

1. 创建序列：
创建字符串、列表和元组的方法分别为：
userStr='administrator'
userTuple=('admin','user','anonymous')
userList=['admin','user','anonymous']

2. 序列的索引：
序列中的每个元素被分配一个位置编号，称为索引，其实第一个元素的索引为0，第二个元素的索引为1，以此类推，序列的元素可以通过索引来访问。
序列还支持反向索引，即负数索引，从最后一个元素开始计数。最后一个元素的索引为-1，倒数第二个元素的索引是-2，以此类推。使用负数索引，可以在无须计算序列长度的前提下方便定位序列中的元素。

3. 序列的分片：
分片slice就是取出序列中某一范围内的元素，而得到一个新序列。分片的一般格式为：
sequence[start:end:step]
起始索引start是提取部分的第1个元素的编号；终止索引end对应的元素不包含在分片范围内；步长step为非零整数，当步长为负数时，从右向左提取元素。忽略参数时，起始元素默认为第1个，终止索引默认为最后一个，步长默认为1。分片操作是产生新的序列，而不会改变原来的序列。示例：
numbers=[0,1,2,3,4,5,6,7,8,9]
print(numbers[3:6])
上述代码获取numbers列表中的第4个元素到第7个元素之间的部分数据。
如果要访问序列最后的几个元素，只需要指定分片的起始位置即可，如：
numbers[7:]
numbers[-3:]
分片还有一个步长参数，默认为1。如果步长设置比1更大的数，就会跳过某些元素：
numbers[0:10:2]

4. 序列相加：
通过使用加号可以进行序列的连接操作，示例：
numbers=[0,1,2,3]+[4,5,6,7]
除了列表，元组和字符串也可以使用加号实现连接。但相加操作只能用于相同的序列之间，三种不同的序列，字符串、列表、元组之间是不能相加的。

5. 序列的乘法：
在序列中，当一个数n乘以一个序列时，该序列将被重复n次，从而生成一个新的序列：
userIdStr='0001'*6 # 得到的值为000100010001000100010001
userIdList=['0001']*5 # 得到的值为 ['0001', '0001', '0001', '0001', '0001']
当n<1时将产生一个空序列。

6. 序列的比较：
两个序列可以进行比较，规则是两个序列的第1个元素先进行比较，如果第1个元素一样则继续比较下一个元素，依次比较下去。对其中每个元素的比较是用它们的值来比较。三种不同的序列之间不能进行比较，否则会出现错误。

7. 成员测试：
可以使用in检查是否是序列的成员，返回结果为True或False。
5 in (1,2,3,4,5,6,7,8)

8. 序列拆分赋值：
使用赋值语句，可以将序列拆分赋给多个变量。示例：
a,b,c,d=[1,2,3,4]
当变量个数和序列元素的个数不一致时会导致错误。这时可以使用*，加在其中某个变量名前，将序列的多个元素赋给相应的变量。示例：
a,*b,c=[1,2,3,4,5]
但加*号的变量只允许有一个，否则会出现语法错误。

9. 序列处理函数：
1）len(s)、max(s)和min(s)函数：分别用来计算序列的长度、最大值和最小值
2）sum(s)函数：返回序列中所有元素的和，要求元素必须为数值。
3）reduce(f,s[,n])：把序列s的前两个元素作为参数传递给函数f，计算的结果和序列的下一个元素重新作为f的参数，直到序列的最后一个元素，最终结果是f的返回值。在Python 3.x中，此函数放入functools模块中，需要使用functools.reduce()方式调用。
4）enumerate(iter)函数：接收一个可迭代对象作为参数，返回一个enumerate对象，生成由iter每个元素的索引值和元素值组成的元组。示例：
s=['lin','8','wang']
for i,obj in enumerate(s):
    print(i,obj)
5）zip([s0,s1,...,sn])：接收任意多个序列作为参数，返回一个可迭代对象，其中第1个元素是序列中所有第1个元素组成的元组，第2个元素所序列中所有第2个元素组成的元组，以此类推。若序列的长度不等，则按长度最短的序列。示例：
s=zip([1,2,3],['a','b','c'])
k=list(s) # [(1,'a'),(2,'b'),[3,'c')]
利用*操作符，可以将对象解压还原。示例：
s=zip(*k)
ss=list(s) # [1,2,3],['a','b','c']
6）sorted(iterable,key=None,reverse=False)函数：返回可迭代对象iterable中元素进行排序后的序列，返回的是副本，原值不变。其中，key指定一个用于计算比较的排序规则，默认None；reverse表示排序规则，为True时为降序排序。示例：
x=[3,18,11,21,7]
sorted(x) # [3,7,11,18,21]
还有一个类似的reversed(iterable)函数，对可迭代对象的元素按逆序排序，返回一个新的可迭代变量。
7）all(s)和any(s)函数：如果序列s的所有元素都为True则all()函数返回True，否则返回False；如果序列中任一元素为True，则any()函数返回True，否则返回False。

三、列表List：

List是处理一组有序元素的数据结构，其中每个元素之间用逗号分隔，列表中的元素包含在方括号中。列表内容是可变的，一旦创建了列表，就可以添加、插入、赋值、删除或搜索列表中的元素。列表也是序列的一种，可以使用序列的通用操作，但也有一些专用列表的操作。

1. 列表的创建和修改：
列表中可以添加任何类型的元素。创建格式为：
list_name=[element1, element2, element3, ...]
列表的长度是不固定的，可以随意更改，改变列表的方法有添加元素、元素赋值、删除元素以及分片赋值。
1）添加元素append()方法：
用于在列表的尾部添加一个元素。示例：
userList=['0001', '0002', '0003', '0004', '0005']
print('列表长度：'+str(len(userList)))
userList.append('0006')
代码中使用了len()函数，用于获取一个对象的长度，这里用于获取列表useList的长度。
2）插入元素insert()方法：
insert(index, value)
该方法有两个参数，index为将要插入到列表中的元素指定索引位置，value为要插入的值。
userList.insert(2, '0006')
3）元素赋值：
需要使用索引标记来为特定位置的元素赋值。
list_name[index]=value
其中，index表示列表的索引，从0开始；value为元素的值，可以是任意类型，包括字典类型、元组类型及其他特殊类型。不能为一个位置不存在的元素赋值。
4）删除元素remove()方法：
remove(valie)
其中，value为要删除的列表中指定的元素值。如果List列表中存在两个相同的元素，调用remove()方法将只能删除List列表中位置靠前的元素。
5）删除元素del语句：
del list_name[index]
其中，index为将要删除的元素所对应的索引位置
6）分片赋值list()方法：
分片slice是列表的一个子集，分片是从第1个索引到第2个索引（不包括）所指定的所有元素。分片索引可以为正数或负数，两个索引之间用冒号分隔。格式为：
list_name[m:n]
其中，m、n可以是正整数或负整数。
使用list()方法可以定义一个列表，并给分片赋值。示例：
userList=list('Python')
userList[2:]=list('rite')
print(userList)
代码先用list()方法定义一个有6个元素的列表，然后使用冒号将该列表分片，从列表第3个元素开始将原有元素替换为list()方法的列表。分片赋值也可以在不需要替换原有元素的情况下插入新元素。示例：
numbers=[0,6]
numbers[1:1]=[1,2,3,4,5]
print(numbers)
代码中只是替换了一个空的分片，实际操作是插入一个序列。

2. 使用列表：
1）使用负索引访问列表元素：
负索引从列表的尾部开始计数，最尾端的元素索引表示为-1，次尾端的元素索引为-2，以此类推。
2）列表的分片处理：
可以使用分片操作来访问一定访问内的元素。分片通过相隔的两个索引来实现。
subUser1=userList[2:5]
subUser2=userList[-3:-1]
3）二元列表及遍历：
列表还可以由其他列表组成。二元列表为：
list_name=[[element1, elements, ...], [element3, element4, ...], ...]
访问二元列表语法格式：
list_name[index1][index2]
其中，index1为二元列表中的元素索引，index2为要访问的二元列表中index所指向的列表中的元素索引。
如果需要将列表中的元素全部遍历输出，使用for...in循环：
userList1=['0001','0002','0003','0004']
userList2=['0005','0006','0007']
userList=[userList1,userList2]
for i in range(len(userList)):
    for j in range(len(userList[i])):
        print('userList['+str(i)+']['+str(j)+']=',userList[i][j])
这段代码实现了遍历userList二元列表的功能，最后将userList列表中的各个元素输出。
4）列表的连接：
实现列表的连接有两种方式，一种是调用extend()方法连接两个不同的列表，另一种是使用运算符+、+=或*。
userList1=['0001','0002','0003','0004']
userList2=['0005','0006','0007']
userList1.extend(userList2)
使用extend()方法修改了被扩展的列表，返回一个全新的列表。
userList3=['0008','0009','0010']
userList4=['0011','0012','0013']
userList5=userList3+userList4
userList6+=['0014']
userList7=['0015','0016']*2
使用+=连接列表与append()方法的功能相同，就是在原有列表基础上添加元素；使用“*”号，就是将列表中的元素添加一倍。

3. 列表的查找、排序与反转：
1)列表的查找：
index()方法用于从列表中找到某个值的第1个匹配项的索引位置。
userList.index('0002')
另一种方法是使用保留字in来判断元素是否在列表中：
print('0002' in userList)
使用保留字in可以判断元素0002是否在列表中。
2)列表的排序sort()方法：
sort()方法用于在原始位置对列表进行排序，会让其中的元素按一定的顺序排列，但返回值是空值。
userList.sort()
sort()方法有一个可选的参数reverse，为布尔值True或False，用来指明列表是否要进行反向排序。
3)列表的反转reverse()方法：
将列表中的元素反向存放，但不返回值。
userList.reverse()
4)获取列表中某个值的出现次数count(x)函数：
x=[1,2,3,4,5,4,3,2,1]
x.count(2) # 2

4. 用列表实现堆栈：
堆栈和队列是数据结构中常用的结构，使用列表的append()和pop()方法可以模拟这两种数据结构。pop()方法会移除列表中的元素，默认是最后一个，并且返回该元素的值。
userList.pop()
userList.pop(0)
pop()方法是唯一一个既能修改又能返回元素值的列表操作方法。使用pop()方法可以实现堆栈。堆栈符合“后进先出”的规则。可以调用append()方法将一个元素添加到堆栈的顶部，调用pop()方法则可以把堆栈中的最后一个元素弹出来。
userList=['0001','0002','0003','0004']
userList.append('0005')
value=userList.pop()

四、元组Tuple：

元组是一种不可更改的用圆括号括起来的列表。元组的元素被包含在一对圆括号中，元素之间用逗号分开，每个元素可以存储不同类型的数据，例如字符串、数字和元组。

1. 创建元组：
创建时可以不指定元素的个数，相当于不定长数组，但是一旦创建就不能修改元组的长度。
tuple_name=()
tuple_name=(element, element2, element3, ...)
如果创建的元组只包含一个元素，那么该元素后面的逗号是不能忽略的，如果忽略就不能识别是元组还是表达式。示例：
userTuple=('0001','0002','0003','0004','0005','0006')
print(userTuple)
元组的索引也是从0开始。

2. 添加元组：
将一个元组中的元素类型定义为元组，这样可以实现元组元素的添加。示例：
newTuple=(userTuple,'0007','0008')
print(newTuple)
输出结果为：(('0001', '0002', '0003', '0004', '0005', '0006'), '0007', '0008')

3. 元组的访问：
元组的访问与列表相似，同样支持负索引、分片及多元特性，但元组中的元素不能修改。
tuple_name[n]
其中，n表示要访问元组中元素的索引，支持负索引。
如果元组中包含可改变的元素，比如列表，其中列表的元素值是可以改变的。

4. 二元元组：
由其他不同元组组成的元组就是二元元组。语法：
tuple_name=((element1, element2, element3, ...), (element4, element5, element6, ...))
示例：
userTuple1=('0001','0002','0003')
userTuple2=('0004','0005','0006')
userTuple=(userTuple1,userTuple2)
print(userTuple)
a=userTuple[1][0]
print(a)

5. 元组的解包：
将元组的创建称为打包，元组的解包则是将元组中的各个元素分别赋值给多个变量。示例：
stu1,stu2,stu3=userTuple1
元组userTuple含有3个元素，因此赋值号左边有3个变量，这样就将元组中的3个元素分别赋值给这3个变量。

6. 使用range()遍历元组：
元组遍历通过循环语句for...in依次访问元组中各个元素的值。元组遍历常常使用range()函数和len()函数。range()返回一个递增或递减的数字列表，语法：
range([start ,] stop[, step])
其中，可选参数start表示列表的开始值，默认0；必需参数stop表示结束的值；可选参数step表示步长，默认1。示例：
userTuple=('0001','0002','0003','0004','0005','0006')
for item in range(len(userTuple)):
    print(userTuple[item])
二元元组的遍历要使用嵌套for...in循环。

7. 使用map()遍历元组：
可以使用map()函数实现对元组的解包，得到每一个子元组，然后对每个子元组进行遍历。map(function_name, sequence[, sequence, ...])
其中，function_name是一个自定义函数，用于处理参数sequence。如果function_name的值为None，则map()函数返回一个由参数sequence组成的元组或列表。示例：
userTuple1=('0001','0002','0003')
userTuple2=('0004','0005','0006')
userTuple=(userTuple1,userTuple2)
for item in map(None, userTuple):
    for i in item:
        print(i)
新版本中已经不支持此方法。

8. 元组和列表的转换：
使用list()和tuple()函数可以在元组和列表之间相互转换。list()函数接收一个元组返回包含同样元素的列表，tuple()函数接收一个列表返回包含同样元素的元组。

五、字典Dictionary：

Python中，字典是放置在大括号中用逗号分隔的“键-值”对，其中的元素并没有顺序。键就相当于索引，对应的值是数据，数据是根据键来存储的。键可以是数字、字符串或元组。
Python对键进行哈希函数运算，根据计算结果决定存储地址，所以是无序存储的。键必须是可以哈希计算的，可以使用hash()函数来判断一个数据能否作为字典的键。

1. 创建字典：
创建字典的语法为：
dictionary_name={key1:value1, key2:value2, key3:value3, ...}
其中，key1、key2、key3表示字典的键，value1、value2、value3表示字典的值。字典由一系列“键-值”对组成，每个键和对应的值之间用冒号隔开，而每一项键值对之间用逗号隔开，整个字典则由花括号括起来。字典中的键是唯一的，而值并不唯一。空字典由两个花括号组成。示例：
userDic={'0001':'June', '0002':'Tom'}
print(userDic)
创建字典也可以使用dict()函数。示例：
userData=[(2,'user'),(1,'tom'),(3,'merry')]
userDic=dict(userData)
代码中先定义了一个列表，其中有3个元素，每个元素都是有映射关系的序列对，这时可以使用dict()函数将这种列表转换成字典类型。dict()函数也可以通过关键字参数来创建，示例：
userDic=dict(name='tom',age=24,sex='0')
字典与列表一样，可以进行增加元素、删除元素、访问元素和遍历元素等操作。

2. 向字典中添加元素：
字典是无序的，如果要向字典中插入新元素，要调用setdefault()方法：
setdefault(key[, default_value])
其中，key表示字典的键值；可选参数default_value表示字典元素的默认value值，不指定时默认None。要添加的参数key的值如果字典中已存在，那么此函数将返回原有的值，如果key不存在将添加一个新元素，并返回新元素的value值。示例：
userDic={'0001':'June', '0002':'Tom'}
userDic.setdefault('0004', 'Merry')
userDic.setdefault('0001', 'Peter')
不使用setdefault()方法也可以向字典中添加元素，只需要使用赋值语句：
dictionary_name['key']='value'
如果key不在字典中key列表中，将被添加一条新的映射；如果key已在字典中，将直接修改key对应的值。示例：
userDic={'0001':'June', '0002':'Tom'}
userDic['0004']= 'Merry'
userDic['0001']= 'Peter'

3. 删除字典中原有元素：
1）使用del()方法删除字典中的元素：
del()是内建函数，可以直接调用。语法：
del(dictionary_name[key])
其中，key为字典中已经存在的键，即需要删除元素所对应的键。示例：
del(userDic['0002'])
2）使用pop()方法删除字典中的元素：
字典中也有pop()方法，用于删除并返回指定键的条目。语法：
pop(key[, default_value])
如果字典中存在key，则返回值为key所对应的值，否则返回default_value。示例：
userDic.pop('0001')
3）可以使用del语句删除字典中的元素：
del userDic['0002']

4. 字典的遍历：
1）使用for...in循环语句遍历字典：
userDic={'0001':'June', '0002':'Tom', '0003':'Peter'}
for key in userDic:
    print('userDic[%s]='%key,userDic[key])
代码中，%s表示要输出userDic字典的内容，%key表示%s所对应的值，即字典中的所有key。
2）使用items()方法遍历字典：
Python提供了专用于遍历字典的items()方法。示例：
userDic={'0001':'June', '0002':'Tom', '0003':'Peter'}
for (key, value) in userDic.items():
    print('userDic[%s]='%key,value)
使用items()方法后获取的结果为[(key1,value1),(key2,value2)]序列，在遍历userDic.items()时，声明变量(key, value)将每个元素的键和值分别赋值给key和value，这样key所存储的就是userDic字典中的键，value所存储的就是userDic字典中键所对应的值。
3）使用iteritems()、iterkeys()和itervalues()方法遍历字典：
还可以使用iteritems()、iterkeys()和itervalues()方法遍历字典，示例：
userDic={'0001':'June', '0002':'Tom', '0003':'Peter'}
for (key, value) in userDic.iteritems():
    print('userDic[%s]='%key,value)
for key in userDic.iterkeys():
    print(key)
for value in userDic.itervalues():
    print(key)
for (key, value) in zip(userDic.iterkeys(), userDic.itervalues()):
    print('userDic[%s]='%key,value)

5. 字典的一些常用方法：
1）d.clear()方法：用于清除字典中所有的项，无返回值。
2）d.copy()方法：返回一个具有相同键-值对的新字典。
dictionary_targetName=dictionary_sourceName.copy()
其中，dictionary_targetName为要复制的目标字典名，dictionary_sourceName为源字典名。
targetDic=userDic.copy()
字典复制后，当在副本中替换值时源字典不受影响，但如果修改了源字典中的值，副本字典会改变。
3）d.keys()方法：返回一个包含字典所以关键字的列表。
4）d.value()方法：返回一个包含字典所有值的列表。
5）d.items()方法：返回一个包含所有(键,值)元组的列表。
6）d.pop(key)方法：从字典中删除键key并返回删除的值。
7）d.popitem()方法：随机删除字典中的元素，并返回删除的值。
8）d.get(key[,value])方法：用于访问字典中的某个元素，返回该元素的value值。
如果访问的字典元素不存在，则返回None。语法：
dictionary_name.get(key)
其中，key为要访问的字典中的键。示例：
userDic.get('0002')
9）d.fromkeys()方法：使用给定的键来建立新的字典，每个键默认对应的值为None。
dictionary_name.fromkeys([key1, key2, ...], (default_values))
其中，key1、key2等定义了要创建的新字典中的所有键；可选参数default_values指定了新字典中所有键所对应的默认值，这里只能指定一个相同的默认值，未指定默认为None。
{}.fromkeys(['0001','0002'])
上述代码首先构造了新的空字典，然后调用fromkeys()方法建立了另一个字典，结果为：
{'0001': None, '0002': None}
10）d.setdefault(key[,value])方法：如果字典中key存在则返回其值，若key不存在则添加。
11）d.update(d1)方法：将字典d1中的键值对添加到字典d中。
12）has_key()方法：检查字典中是否含有指定的键，如果有返回True，否则返回False。
dictionary_name.has_key(key)
13）d.sorted()方法：对字典按键key或按值value排序。
wordDic={'a':9, 'world':10, 'z':8, 'hello':12}
print(sorted(wordDic.items(),key=lambda d:d[0]))
print(sorted(wordDic.items(),key=lambda d:d[1]))

六、集合set：

集合是一个无序排列的数据集合体，可以进行交、并、差等运算，但其中的元素不能重复。

1. 集合的创建：
创建集合有两种方式，用大括号将多个用逗号分隔的数据括起来，或者使用set()函数。
s={1,2,3,4,5,6,7,8,9}
s2=set('abcdefg')
空集合使用set()表示。集合中不能包括重复元素，如果有重复元素会自动删除。
上述方法创建的集合是可变集合，可以添加和删除集合元素，但不能更改其中的元素，所以集合的元素只能是数值、字符串或元组，不能为列表或字典。
Python提供了frozenset()函数创建不可变集合，创建后不能修改，因此可以作为其他集合的元素，也可以作为字典的键。

2. 集合的常用运算：
集合支持多种运算，包括集合类运算。
⑴集合运算：
·s1|s2|...|sn：求多个集合的并集。
·s1&s2&...&sn：求多个集合的交集。
·s1-s2-...-sn：求多个集合的差集。
·s1^s2：求两个集合的差集，即两个集合的不相同元素。
⑵集合的比较：
·s1==s2：如果两个集合具有相同的元素，则返回True，否则返回False。
·s1!=s2：如果两个集合具有不同的元素，则返回True，否则返回False。
·s1<s2：如果s1是集合s2的纯子集，则返回True，否则返回False。
·s1<=s2：如果s1是集合s2的子集，则返回True，否则返回False。
·s1>s2：如果s1是集合s2的纯超集，则返回True，否则返回False。
·s1>=s2：如果s1是集合s2的超集，则返回True，否则返回False。
⑶集合的并入：将s2的元素并入s1
s1|=s2
⑷集合的遍历：
集合与for语句配合使用，可以实现对集合各个元素的遍历。示例：
s={10,20,30,40}
t=0
for x in s:
    print (x,end='\t')
    t+=x
print(t)

3. 集合的常用方法：
⑴s.issubset(s1)：如果集合s是s1的子集，则返回True，否则返回False
⑵s.issuperset(s1)：如果集合s是s1的超集，则返回True，否则返回False
⑶s.isdisjoint(s1)：如果集合s与s1没有共同元素，则返回True，否则返回False
⑷s.union(s1,s2,...,sn)：返回集合s，s1，s2，...，sn的并集
⑸s.intersection(s1,s2,...,sn)：返回集合s，s1，s2，...，sn的交集
⑹s.difference(s1,s2,...,sn)：返回集合s，s1，s2，...，sn的差集
⑺s.symmetric_difference(s1)：返回集合s，s1的对称差值
⑻s.copy()：复制集合s

4. 可变集合的操作方法：
⑴s.add(x)：在集合s中添加元素x
⑵s.update(s1,s2,...,sn)：用集合s1，s2，...，sn中的成员修改集合s，是用s1，s2，...，sn的并集作为s的集合
⑶s.intersection_update(s1,s2,...,sn)：集合s是s，s1，s2，...，sn的交集
⑶s.difference_update(s1,s2,...,sn)：集合s是s，s1，s2，...，sn的差集
⑷s.symmetric_difference_update(s1)：集合s是s与s1的对称差集
⑸s.remove(x)：从集合s中删除x，如果x不存在则引发错误
⑸s.discard(x)：如果x是s的成员则删除x，如果不存在也不会出现错误
⑸s.pop()：删除集合s中任意一个元素，并返回此值
⑹s.clear()：删除集合s中的所有元素