一、列表
因为Python中没有数据类型，所有Python中没有标准意义上的数组。列表就是Python中加强版的数组，可以存储各种类型的数据。
列表的索引操作类似数组，如list[0][0]列表同样适用
（一）创建列表
member=['a','b','c','d']创建元素复杂的列表
member=['a',123,3.14,['c','d']]创建空列表
empty=[]（二）向列表中添加元素
member.append(元素)方法添加元素，每次只能添加一个
member.extend(列表)方法扩展列表，每次添加的是一个列表，本质是将两个列表合并为一个列表
member=['a',123,3.14,['c','d']]
member.extend([123,456])member.insert(索引,元素)方法插入元素，在列表的一个位置插入元素，索引是从0开始的
（三）从列表删除元素
member.remove(元素)方法删除，不需要知道元素在哪个位置，删除搜索到的第一个。不存在的话会报错。
del member[1]函数，del不是member的内部方法，像是一个释放内存的析构函数，可以用del member直接删除整个列表
member.pop()方法，弹出member列表中的最后一个元素。列表长度-1，最后一个元素被删除，有返回值。
（四）列表分片Slice
利用索引值，每次我们可以从列表获取一个元素，但是我们总是贪心的，如果一次性需要获取多个元素，有没有办法实现呢?利用列表分片，我们可以简单的实现这个要求。
>>> member=['a','b','c','d','e']
>>> member[1:3]
输出：['b', 'c']分片是对原列表一部分的复制而不是剪切，分片产生的新列表不会影响原列表。
分片可以简写，从0开始的话，可以写成member[:3]，到结尾的话可以写成member[1:]。
用member[:]可以获得对原列表的一个拷贝，产生的新列表与原列表无关。
如果直接使用list1=list2，则list1只是对list2产生了一个索引值，指向同一块内存。list1会随着list2的变化而变化。
（五）列表的操作符
1、比较运算符
列表可以进行大小的比较
>>> a=[1,2,3]
>>> b=[0]
>>> a>b
True
>>> list1=[123]
>>> list2=[234]
>>> list1>list2
False2、+号运算符
列表可以用+号拼接，相当于extend()方法。但是建议使用extend()方法使代码更规范。但是直接用+添加元素是违规的，如：
>>> list1+'1'
Traceback (most recent call last):
File "<pyshell#9>", line 1, in <module>
list1+'1'
TypeError: can only concatenate list (not "str") to list因为+号两边的数据类型要一致，在程序中+号一边是列表，一边是字符串，所以不能添加，可以改为list1+['1']，类似extend()
3、*乘号运算符
用list1*3会输出三次list1
>>> list1=['a','b','c']
>>> list1*3
['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']
>>> list1
['a', 'b', 'c']用list1*=3，会将list1扩展三倍
>>> list1=['a','b','c']
>>> list1*=3
>>> list1
['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']4、in判断元素是否在列表内
>>> list1=[1,2,3,4,5]
>>> 3 in list1
True
>>> 6 not in list1
True但是in只能判断列表的第一层，不能深入，如下：
>>> list2=[1,2,3,[4,5]]
>>> 4 in list2
False因为4是在列表中的列表中，所以无法判断，in只能判断一层列表。
（六）列表的内置函数
使用dir(list)命令就可以查看列表的所有内置函数
member.count(元素)方法，统计元素在member中出现了几次。
member.index（元素）方法，该元素出现的第一个位置；member.index(元素,起始位置,结束位置)，在区间里搜索元素存在的位置。
member.reverse()方法，没有参数，翻转列表。
member.sort()方法，对列表进行排序。默认是从小到大排序。member.sort(func,key,reverse)，func指定排序算法，key是和算法搭配的关键字，reverse是指定排序顺序。reverse=True，为从大到小排序。
二、元组
元组是限制了权限的列表。因为列表的自由度太高。元组中的内容是不可变的，也是不可以随意删除和排序的。除了元组不能改变，其他的方法元组和列表完全一样。
（一）创建和使用一个元组
因为元组是加了限制的列表，所以两者的使用方法很相似
>>> tuple1=(1,2,3,4,5,6,7,8)
>>> tuple1[1]
2
>>> tuple1[:5]
(1, 2, 3, 4, 5)
>>> tuple2=tuple1[:]
>>> tuple2
(1, 2, 3, 4, 5, 6, 7, 8)元组内容不可变，改变元组的元素的值会报错
>>> tuple1[1]=5
Traceback (most recent call last):
File "<pyshell#11>", line 1, in <module>
tuple1[1]=5
TypeError: 'tuple' object does not support item assignment创建元组的关键是","而不是()，如下，用括号创建的元素并不是元组类型而是整型
>>> temp=(1)
>>> type(temp)
<class 'int'>正确的创建方法如下，逗号才是关键
>>> temp=1,2,3
>>> type(temp)
<class 'tuple'>创建只有一个元素的元组，一定要在后面加上逗号，如type=(1,)或者type=1,才会是一个元组
创建一个空元组temp=()
temp=()（二）更新和删除一个元组
1、更新元组
要想在元组中插入一个新的元素就需要重新构造一个元组，如下：
>>> temp=('a','b','d','e')
>>> temp=temp[:2]+('c',)+temp[2:]
>>> temp
('a', 'b', 'c', 'd', 'e')实际上temp已经指向了一个新的元组，以前的元组没有指向了，一段时间后Python的回收机制会自动销毁没有指向的数组的内存。注意：在第二行中('c',)中的逗号一定不能忘。逗号表明它是一个元组。
2、删除元组
像列表一样删除一个元组中的元素是不可能的，可以像上面的方法那样删除一个元组的元素。
可以直接删除一个元组用del temp，Python中有回收机制会自动回收内存，一般不用手动释放删除整个元组。
三、字符串
字符串类似于元组，它一旦定义好了，元素不能修改。字符串的操作和元组是一样的
（一）字符串的常用操作函数
| capitalize() | 把字符串的第一个字符改为大写 |
| casefold() | 把整个字符串的所有字符改为小写 |
| center(width) | 将字符串居中，并使用空格填充至长度width的新字符串 |
| count(sub[,start[,end]]) | 返回sub在字符串里边出现的次数，start和end参数表示范围，可选。 |
| encode(encoding='utf-8',errors='strict') | 以encoding指定的编码格式对字符串进行编码。 |
| endswith(sub[,start[,end]]) | 检查字符串是否以sub子字符串结束，如果是返回True，否则返回False.start和end参数表示范围，可选。 |
| expandtabs([tabsize=8]) | 把字符串中的tab符号(\t )转换为空格，如不指定参数，默认的空格数是tabsize=8。 |
| find(sub[,start[,end]]) | 检测sub是否包含在字符串中，如果有则返回索引值，否则返回-1，start和end参数表示范围，可选。 |
| index(sub[,start[,end]]) | 跟find方法一样，不过如果sub不在string中会产生一个异常。 |
| isalnum() | 如果字符串至少有一个字符并且所有字符都是字母或数字则返回True ，否则返回False. |
| isalpha() | 如果字符串至少有一个字符并且所有字符都是字母则返回True，香则返回False. |
| isdecimal() | 如果字符串只包含十进制数则返回True，否则返回False. |
| isdigit() | 如果字符串只包含数字则返回True，否则返回False. |
| islower() | 如果字符串中至少包含一个区分大小写的字符，并且这些字符都是小写，则返回True，否则返回False. |
| isnumeric() | 如果字符串中只包含数字字符，则返回True，否则返回False. |
| isspace() | 如果字符串中只包含空格，则返回True，否则返回False。 |
| istitle() | 如果字符串是标题化(所有的单词都是以大写开始，其余字母均小写）,则返回True，否则返回False。 |
| isupper() | 如果字符串中至少包含一个区分大小写的字符，并且这些字符都是大写，则返回True，否则返回False。 |
| join(sub) | 以字符串作为分隔符，插入到sub中所有的字符之间。 |
| ljust(width) | 返回一个左对齐的字符串，并使用空格填充至长度为width的新字符串。 |
| lower() | 传换字符串中所有大写字符为小写。 |
| lstrip() | 去掉字符串左边的所有空格 |
| partition(sub) | 找到子字符串sub，把字符串分成一个3元组( pre_sub,sub,fol_sub )，如果宁符串中不包含sub则返回(‘原字符串”, ， ) |
| replace(old,new[,count]) | 把字符串中的old子字符串替换成new子字符串，如果count指定，则替换不超过count次。 |
| rfind(sub[,startt[,end]]) | 类似于find0方法，不过是从右边开始查找。 |
| rindex(sub[,start[,end]]) | 类似于index()方法，不过是从右边开始。 |
| rjust(width) | 返回一个右对齐的字符串，并使用空格填充至长度为width的新字符串。 |
| rpartition(sub) | 类似于partition()方法，不过是从右边开始查找。 |
| rstrip() | 删除字符串末尾的空格。 |
| split(sep=None, maxsplit=-1) | 不带参数默认是以空格为分隔符切片字符串，如果maxsplit参数有设置，则仅分隔maxsplit个子字符串，返回切片后的子字符串拼接的列表。 |
| splitlines(([keepends])) | 按照‘\n’分隔，返回一个包含各行作为元素的列表，如果keepends参数指定，则返回前keepends行。 |
| startswith(prefix[,start[,end]]) | 检查字符串是否以prefix开头，是则返回True，否则返回False。start和end参数可以指定范围检查，可选。 |
| strip([chars]) | 删除字符串前边和后边所有的空格，chars参数可以定制删除的字符，可选。 |
| swapcase() | 翻转字符串中的大小写。 |
| title() | 返回标题化（所有的单词都是以大写开始，其余字母均小写）的字符串。 |
| translate(table) | 根据table的规则（可以由str.maketrans(‘a’,‘b’)定制）转换字符串中的字符。 |
| upper() | 转换字符串中的所有小写字符为大写。 |
| zfill(width) | 返回长度为width的字符串，原字符串右对齐，前边用0填充。 |
（二）格式化字符串
关键字format，使用如下：
>>> "{0} is {1} {2}".format("She","is","gril")
'She is is gril'1、位置参数
括号中是数字0,1,2...用来占位，如上面的代码
2、关键字参数
指定关键字来代替，如下面：
>>> "{a} is {b} {c}".format(a="She",b="is",c="gril")
'She is is gril'如果关键字参数和位置参数一起使用，位置参数一定要在所有的关键字参数前面
3.格式化符号
>>> '{0:.1f}{1}'.format(27.658,'GB')
'27.7GB'“:”表示格式化的开始，用四舍五入保留一位小数输出。
| 符号 | 说明 |
|---|---|
| %c | 格式化字符及其ASCII码 |
| %s | 格式化字符串 |
| %d | 格式化整数 |
| %o | 格式化无符号八进制数 |
| %x | 格式化无符号十六进制数 |
| %X | 格式化无符号十六进制数（大写） |
| %f | 格式化定点数，可指定小数点后的经度 |
| %e | 用科学计数法格式化定点数 |
| %E | 作用同%e，用科学计数法格式化定点数 |
| %g | 根据值的大小决定使用%f或%e |
| %G | 作用同%g，根据值的大小决定使用%f或者%e |
格式化输出演示：
#%c字符
>>> '%c %c %c'%(97,98,99)
'a b c'
#%s字符串
>>> '%s'%'abcd'
'abcd'
#%d整数
>>> '%d+%d=%d'%(4,5,4+5)
'4+5=9'
#%o八进制数
>>> "%o"%10
'12'
#%十六进制数
>>> '%x'%10
'a'
>>> '%X'%10
'A'
#%%f浮点数，默认保留6位小数
>>> '%f'%3.14
'3.140000'
>>> '%e'%3.14
'3.140000e+00'
>>> '%g'%3.14
'3.14'格式化操作符辅助指令
| 符号 | 说明 |
|---|---|
| m.n | m是显示的最小总宽度，n是小数点后的位数 |
| - | 用于左对齐 |
| + | 在正数前面显示加号+ |
| # | 在八进制数前面显示零（' 0'），在十六进制数前面显示'0x'或‘0X’ |
| 0 | 显示的数字前面填充‘0’取代空格 |
代码演示
>>> '%5.1f'%3.14
' 3.1'
>>> '%10d'%5
' 5'
>>> '%.2e'%3.14
'3.14e+00'
>>> '%-10d'%5
'5 '
>>> '%+d'%5
'+5'
>>> '%+d'%-5
'-5'
>>> '%#o'%10
'0o12'
>>> '%#x'%10
'0xa'
>>> '%010d'%5
'0000000005'四、序列
列表、元组和字符串的共同点：
1.都可以通过索引得到每一个元素一默认索引值总是从0开始
2.可以通过分片的方法得到一个范围内的元素的集合
3.有很多共同的操作符（重复操作符、拼接操作符、成员关系操作符）
（一）list()把一个可迭代对象转换为列表
用help(list)命令可以查看list的所有方法。
>>> a='I live in China'
>>> a=list(a)
>>> a
['I', ' ', 'l', 'i', 'v', 'e', ' ', 'i', 'n', ' ', 'C', 'h', 'i', 'n', 'a']
>>> b=(1,1,2,3,5,8,13,21,34)
>>> b=list(b)
>>> b
[1, 1, 2, 3, 5, 8, 13, 21, 34]tuple()和str()和list() 的用法一样。
（二）常用内置方法
int()、float()
len()函数，返回一个元素的长度
min()/max()函数，返回序列中的最小/大值，字符串使用的是ASCII码。要保证序列中的数据类型是统一的。
sum(iterable[,start=0])函数，返回序列iterable和可选参数start的总和，只能计算数字，不能计算字符，如下：
>>> tuple1=(1,2,3)
>>> sum(tuple1)
6
>>> sum(tuple1,1)
7sorted()函数，返回一个排序。和方法list.sort()一样。
reversed()函数，将序列倒序。返回的是一个迭代器。
>>> tuple1=(1,2,3)
>>> reversed(tuple1)
<reversed object at 0x000001715C4D6B80>
>>> list(reversed(tuple1))
[3, 2, 1]enumerate()函数。枚举，生成索引值和实际值的新序列。如下：
>>> enumerate(list1)
<enumerate object at 0x000001715BF73340>
>>> list(enumerate(list1))
[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]zip()函数，返回由两个列表各个参数对应位置组成的新元组。如下：
>>> list1=['a','b','c','d']
>>> list2=[1,2,3,4,5,6,7,8]
>>> zip(list1,list2)
<zip object at 0x000001715BF73340>
>>> list(zip(list1,list2))
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]