第三节 序列 (列表,元组)

python 中常用的序列结构有: 字符串、列表、元组、字典、集合

---

列表

列表的创建

列表:用于存储任意数目、任意类型的数据集合。

基本语法[]创建

a = [10,20,30,'abc']

list()创建

a = list()  #empty list
b = list(range(5)) #[0, 1, 2, 3, 4]
c = list('abc') #['a', 'b', 'c']

range()创建整数列表

range()可以帮助我们非常方便的创建整数列表，这在开发中及其有用。语法格式为: range([start,] end [,step])

python3 中 range()返回的是一个 range 对象，而不是列表。我们需要通过 list()方法将其 转换成列表对象。

start 参数:可选，表示起始数字。默认是 0
end 参数:必选，表示结尾数字。
step 参数:可选，表示步长，默认为 1

a = list(range(3,15,2))  #[3, 5, 7, 9, 11, 13]
b = list(range(5)) #[0, 1, 2, 3, 4]
c = list(range(15,3,-1)) #[15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4]
d = list(range(3,-9,-1)) #[3, 2, 1, 0, -1, -2, -3, -4, -5, -6, -7, -8]

---

列表元素的增加和删除

增加

+运算符操作
并不是真正的尾部添加元素，而是创建新的列表对象;将原列表的元素和新列表的元素依次 复制到新的列表对象中。这样，会涉及大量的复制操作，对于操作大量元素不建议使用。其他都是原地操作

a = [10,20]
a.append(30) #[10, 20, 30]

b = [30,40]
b = b+[50] #[30, 40, 50]

c = [50,60]
c.extend([70]) #[50, 60, 70]

d = [1,2]
d.insert(1,100)  #[1, 100, 2]

删除

del 删除
删除列表指定位置的元素。

pop()方法
pop()删除并返回指定位置元素，如果未指定位置则默认操作列表最后一个元素。

remove()方法
删除首次出现的指定元素，若不存在该元素抛出异常。

a = [1,2,3,4,5]
del a[1] #[1, 3, 4, 5]

a = [1,2,3,4,5] 
a.pop() #[1, 2, 3, 4]
a = [1,2,3,4,5] 
a.pop(1) #[1, 3, 4, 5]

a = [1,2,3,4,5,2,3,4]
a.remove(2)  #[1, 3, 4, 5, 2, 3, 4]

---

列表元素访问和计数

通过索引直接访问元素

我们可以通过索引直接访问元素。索引的区间在[0, 列表长度-1]这个范围。超过这个范围则 会抛出异常。

a = [1,2,3,4,5,6,7,6,5,4,3]
a[1] #2

index()

index()可以获取指定元素首次出现的索引位置。语法是:index(value,[start,[end]])。其中， start 和 end 指定了搜索的范围。

a = [1,2,3,4,5,6,7,6,5,4,3]
a.index(3) #2
a.index(5,3) #4 从位置3开始找找到第一个5
a.index(5,1,9)  #4 从索引位置 1 到 9 这个区间，第一次出现 5 元素的位置

count() & len()

a = [1,2,3,4,5,6,7,6,5,4,3]
print(a.count(3)) #2
print(len(a)) #11

成员资格判断

判断列表中是否存在指定的元素，我们可以使用 count()方法，返回 0 则表示不存在，返回 大于 0 则表示存在。但是，一般我们会使用更加简洁的 in 关键字来判断，直接返回 True 或 False。

a = [1,2,3,4,5,6,7,6,5,4,3]
print(20 in a) #False
print(2 in a) #True
print(30 not in a) #True

---

切片操作

我们在前面学习字符串时，学习过字符串的切片操作，对于列表的切片操作和字符串类似。 切片是 Python 序列及其重要的操作，适用于列表、元组、字符串等等。切片的格式如下:
切片 slice 操作可以让我们快速提取子列表或修改。标准格式为: [起始偏移量 start:终止偏移量 end[:步长 step]]
注:当步长省略时顺便可以省略第二个冒号

切片操作时，起始偏移量和终止偏移量不在[0,字符串长度-1]这个范围，也不会报错。起始 偏移量小于 0 则会当做 0，终止偏移量大于“长度-1”会被当成”长度-1”。

---

列表排序

修改原列表

a = [2,1,3,4]
a.sort() #[1, 2, 3, 4]

a.sort(reverse=True) #[4, 3, 2, 1]

import random
random.shuffle(a) #[3, 2, 4, 1]

建新列表的排序

内置函数 reversed()也支持进行逆序排列，与列表对象 reverse()方法不同的是，内置函数 reversed()不对原列表做任何修改，只是返回一个逆序排列的迭代器对象。

a = sorted(a)  #[1, 2, 3, 4]

c = sorted(a,reverse = True) #[4, 3, 2, 1]


b = reversed(a) #<listreverseiterator object at 0x102c67190>
print(list(b)) #[4, 3, 2, 1]

print(max(a)) #4
print(min(a)) #1
print(sum(a)) #10

---

多维列表

一维列表可以帮助我们存储一维、线性的数据。
二维列表可以帮助我们存储二维、表格的数据。

a = [['Jason', 18, 10000, 'SFO'],['Peter', 19, 20000, 'Vancouver'],['Daisy', 20, 20020, 'Edmonton]']]

for m in range(3):
    for n in range(3):
        print(a[m][n], end='\t')
    print()

'''
Jason	18	10000	
Peter	19	20000	
Daisy	20	20020
'''

---

元组 tuple

列表属于可变序列，可以任意修改列表中的元素。元组属于不可变序列，不能修改元组中的 元素。因此，元组没有增加元素、修改元素、删除元素相关的方法。
因此，我们只需要学习元组的创建和删除，元组中元素的访问和计数即可。元组支持如 下操作:

1. 索引访问
2. 切片操作
3. 连接操作
4. 成员关系操作
5. 比较运算操作
6. 计数:元组长度 len()、最大值 max()、最小值 min()、求和 sum()等。

元组的创建

1. 通过()创建元组。小括号可以省略。
   a = (10,20,30) 或者 a = 10,20,30
   如果元组只有一个元素，则必须后面加逗号。这是因为解释器会把(1)解释为整数 1，(1,) 解释为元组。

a = (10,20,30)
b = 10,20,30
c = (1,)
print(type(a),type(b),type(c)) #<type 'tuple'>, <type 'tuple'>, <type 'tuple'>

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

a = tuple("abc")
b = tuple(range(10))
c = tuple([1,2,3])
print(a,b,c)
#(('a', 'b', 'c'), (0, 1, 2, 3, 4, 5, 6, 7, 8, 9), (1, 2, 3))

总结:
tuple()可以接收列表、字符串、其他序列类型、迭代器等生成元组。
list()可以接收元组、字符串、其他序列类型、迭代器等生成列表。

---

元组的元素访问和计数

1. 元组的元素不能修改
2. 元组的元素访问和列表一样，只不过返回的仍然是元组对象。
3. 列表关于排序的方法 list.sorted()是修改原列表对象，元组没有该方法。如果要对元组排 序，只能使用内置函数 sorted(tupleObj)，并生成新的列表对象。

a = (1,3,5,2,2)
print(a[1]) #3
print(a[1:3]) #(3, 5)
print(sorted(a)) #[1, 2, 2, 3, 5]

zip
zip(列表 1，列表 2，…)将多个列表对应位置的元素组合成为元组，并返回这个 zip 对象。

a = [1,2,3]
b = [4,5,6]
c = [7,8,9]
d = zip(a,b,c)
print(d) #[(1, 4, 7), (2, 5, 8), (3, 6, 9)]

---

生成器推导式创建元组

从形式上看，生成器推导式与列表推导式类似，只是生成器推导式使用小括号。列表推 导式直接生成列表对象，生成器推导式生成的不是列表也不是元组，而是一个生成器对象。
我们可以通过生成器对象，转化成列表或者元组。也可以使用生成器对象的__next__() 方法进行遍历，或者直接作为迭代器对象来使用。不管什么方式使用，元素访问结束后，如 果需要重新访问其中的元素，必须重新创建该生成器对象。

s = (x*2 for x in range(5))
print(s) #<generator object <genexpr> at 0x1073394b0>
print(tuple(s))  #(0, 2, 4, 6, 8)
s = (x*2 for x in range(5))
print(s.__next__())