python中的序列：列表，元祖

序列是一种数据储存方式，用来储存一系列数据。
序列储存的是对象的地址，而不是对象的值。
python中常用的序列结构：字符串，列表，元祖，字典，集合

1.列表

列表：内置可变序列，包含多个元素的有序连接的内存空间，列表中的元素可以各不相同，可以是任意类型。
列表对象 的常用方法：增加元素，删除元素，访问元素，计数，列表长度。
python中的列表大小可变，可根据需要随时增加或缩小。

1.1 列表的创建

1.基本语法创建
使用[]符进行创建

a=[10,20,'ju','feng']#创建列表a
b=[]#创建空对象

2.list()创建
使用list()进行列表创建，可以将任何可迭代的数据转化成列表。

a=list()#创建空对象
a=list('ju')#创建列表['ju']

使用range()创建整数列表
函数格式：range([start],end,[step])
其中end为必填项，其余为选填，start默认为0，step默认为1.

a=list(range(10))#创建列表[0,1,2,3,4,5,6,7,8,9]
a=list(range(3,10,2)#创建列表[2,4,6,8]
a=list(range(8,3,-1)#创建列表[7,6,5,4,3,2]

3.推导式生成列表
使用for循环

a=[x*2 for x in range(5)]#生成列表[0,2,4,6,8]
a=[x*2 for x in range(30) if x%9==0]#生成列表[0,18,36,54]

1.2列表元素的增加

列表元素的增加或减少最好在列表的尾部进行，可提高列表操作效率。

1. append()方法
   该方法在原地址修改列表对象，真正的列表尾部添加新元素，速度最快，推荐使用。

a=[20,40]
a.append(80)#生成[20, 40, 80]

2. +运算符操作
   不是真正的添加，是创建新对象，涉及大量复制工作，效率不高。

a=[20,40]
a=a+[50]#生成[20, 40, 50]

3. extend()方法
   原地操作，可用于整合两个列表

a=[20,40]
a.extend([50,60])#生成[20, 40, 50, 60]

4. insert()插入
   将指定元素插入列表对象任意指定位置，这样会让插入位置后的所有元素移动，影响处理速度。
   listobj.insert(索引号，替换元素）

a=[10,20,40]
a.insert(1,60)#在a(1)处插入60，生成列表[10, 60, 20, 40]

1.3列表元素的删除

1.del 方法
删除指定位置的元素

a=[10,20,40]
del a[1]#删除列表a中索引为a[1]的元素

2.pop()方法
删除并返回指定位置元素，如果未指定位置则操作最后一位元素

a=[10,20,40]
b=a.pop()#b为40，a此时为[10,20]

3.remove()方法
删除首次出现的指定元素，若不存在该元素则抛出异常。
括号内为该元素的值。

a=[10,20,40]
a.remove(20)#生成[10, 40]

1.4列表元素的访问和计数

1.通过索引直接访问
listobj[n]

a=[10, 20]
a[1]#即访问a中第二个元素，20

2.index()
获得指定元素在列表中首次出现的索引
函数格式：index(value,[start,[end]])
start end 选填，表示搜索区间

a=[10,20,40,50,60]
b=a.index(20)#元素20首次出现的索引1
c=a.index(20,1,3)#在a[1]到a[3]之间搜索

3.count()
获得指定元素在列表中出现的次数

a=[10,20,40,50,60]
b=a.count(20)#元素20在列表a中出现的次数，1

4.len()
返回列表长度

5.成员资格判断
in/not in
判断元素是否在该列表里，返回值为布尔值。

6.切片操作
与字符串的切片操作相同
[起始偏移量start：终止偏移量end：[步长step]]

7.列表的遍历
使用for循环
for obj in listobj
print(obj)

1.5列表的排序

1.sort
listobj.sort():默认是升序排列
修改原列表，不新建列表

a=[40,20,10,30,60]
a.sort()#列表a重新排序得[10, 20, 30, 40, 60]

a.sort(reverse=True):降序排列

a=[40,20,10,30,60]
a.sort(reverse=True)#列表a重新排列得[60, 40, 30, 20, 10]

random.shuffle(a)：打乱顺序

2.内置函数sorted()
这是建新列表的排序
a=sorted(a)#默认升序
a=sorted(a.reverse=True)#降序排列

reversed():返回迭代器
内置函数reversed()支持逆序排列，但迭代器只能用一次。

a=[40,20,10,30,60]
c=reversed(a)
b=list(c)#列表b为[60, 30, 10, 20, 40]

3.max min sum
max(a)#返回最大值
min(a)#返回最小值
sum(a)#数值列表求和

1.6多维列表

多维列表中一般用到二维列表
二维列表是用于存储二维表格的数据，列表可以作为列表的元素进行嵌套。
如a=[[‘ju’,18,20000],[‘feng’,19,10000],[‘ga’,20,30000]]
列表a中的元素是三个列表，a[0][0]指第一个元素中第一个元素‘ju’

2.元祖

元祖属于不可变序列，不能修改元祖中的元素。
元祖支持以下操作：索引访问，切片操作，连接操作，成员关系操作，比较运算操作及计数操作。
元祖访问和处理速度比列表快。
元祖可作为字典的键，列表不可以。

2.1元祖的创建和删除

1.通过()创建
a=(10,20,30)或
a=10,20,30
当元祖里只有一个元素时，应写作
a=(10,)或a=10,
需要有逗号

2.通过tuple()创建
tuple(可迭代的对象)

b=tuple()#空元祖
b=tuple('abc')
b=tuple(range(3))
b=tuple([2,3,4])

3.生成器推导式创建元祖
生成器推导式生成的不是列表也不是元祖，是一个生成器对象。
与生成器推导式创建列表操作一致：

s=(x*2,for x in range(5))
a=tuple(s)

4.zip
将多个列表对应位置的元素合成为元祖

a=[40,20,10]
b=[20,30,50]
c=[60,70,80]
d=zip(a,b,c)
e=tuple(d)#e=((40, 20, 60), (20, 30, 70), (10, 50, 80))

元祖的删除：del tupleobj

元祖的排序只能使用内置函数sorted(tupleobj)
a=sorted(a)