2.Python中的序列结构

Python中，序列是最基本的数据结构，常用的有列表，元组，集合，字典和字符串

1.序列概述

①索引与切片

>>索引：

如：verse[2], 从零开始，可以为负数

>>切片：

a[1：3]表示 a[1],a[2]

a[1:]表示a[1]后面所有元素

②序列运算

>>相乘

a = [None]
print(a * 3)

输出：
[None, None, None]

>>相加

a = [None]
b = [1,2]
print(a + b)

输出：
[None, 1, 2]

③序列操作

>>检查元素

in 和 not in ,返回一个布尔类型

a = 1
b = [1,2]
print(a in b)

>>

len(序列）返回长度

max（序列）返回最大值

2.列表

①创建列表（赋值，list函数）

[] 框起来的，里面可以有多种数据类型的

a = []          #空列表
b = [3,'好啊']   #不同元素

list(), 输入可以是range对象，字符串，元组，或者任何可迭代对象

print(list(range(10)))
print(list('这是一个列表'))

输出：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
['这', '是', '一', '个', '列', '表']

②列表推导式

回忆之前的for循环

for i in range(10):
    print(i)

则

i for i in range(10)

应理解为一个可迭代对象

[]框住这样一个可迭代对象，就成了一个列表

print(list(i for i in range(5)))
print([i for i in range(5)])

1.for前面可以与i无关

import random
print([random.randint(10,100) for i in range(5)])

2.最后可以加一个if条件

price = [300,200,100,900,600]
price_1 = [i for i in price if i >= 300]
print(price_1)

③列表的访问与遍历

访问:

a[0]

遍历：

1.用for循环

2.enumerate函数：

price = [00,10,20,30]
for i,p in enumerate(price):
    if i >= 1:
        print(p)

输出：
10
20
30

④列表元素的增删改

1.增

a = [1,2]
a.append(3)
print(a)

》》
[1, 2, 3]

a = [1,2]
b = [3,4]
a.extend(b)
print(a)

》》
[1, 2, 3, 4]  #整个表添加到后面

2.删除

>>根据下标删

del a[1]

>>根据值删

a.remove("3")   删除首次出现该值的元素

3.修改

a = [1,2]
a[1] = 999
print(a)

》》
[1, 999]

⑤列表的统计与排序

1.统计：

a.count("3")   a中”3“出现的次数

a.index("3")  a中”3“首次出现时的下标，若不存在会报错

sum(a)   计算数值列表a各元素之和

2.列表排序

a.sort(key = None,reverse = False)   key参数指定用于比较的键，reverse指定是否排序

sorted(a,key = None,reverse = False) 不改变原列表，返回一个排序后的新列表

⑥二维列表

列表里面的元素可以是列表

a = [[1],[1,2],[1,2,3]]

 但这样的列表不叫作二维列表，如下，形如矩阵形式的叫做二维列表

使用1-9创建一个3*3二维列表

a = [[i + j * 3 for i in range(1,4)] for j in range(3)]
print(a)

》》
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

3.元组

元组可以理解为不可变列表，用小括号（）括起来

①创建元组（赋值，tuple函数）

注意：

1.元组只有一个元素的话要加逗号，否则认为是字符串

a = ('这是字符串')
b = ('这是元组',)
print(a)
print(b)

》》

这是字符串
('这是元组',)

2.不用括号也可创建元组

a = 1,2,3
print(a)

》》
(1, 2, 3)

tuple函数的使用完全参照list函数

②元组推导式

a = (i for i in range(3))
b = [i for i in range(3)]
print(a,'\n',b)

》》
<generator object <genexpr> at 0x00000217B976FC10> 
 [0, 1, 2]

与列表推导式不同，a会视为一个生成器对象，应借助tuple函数

a = tuple(i for i in range(3))
print(a)

③元组的访问与遍历

和列表一样的

④元组不能对元素修改，只能整体重新赋值

a = (1,2,3)
a = (1,2)
print(a)

⑤元组和列表的区别

1.元组属于不可变序列，它的处理速度比列表要快

2.列表不能作为字典的键，元组可以

4.集合

集合就是用大括号{}把元素括起来

①集合的创建（赋值，set函数）

注意：

1.集合会自动去除重复元素

a = {1,2,3,1}
print(a)

》》
{1, 2, 3}

2.集合里面不可以有列表，元组等可迭代对象 

a = {1,2,[3,4]}

》》
TypeError: unhashable type: 'list'

set函数使用同list函数

②集合推导式

a = {i for i in range(3)}
print(a)

》》
{0, 1, 2}

不会像元组那样生成一个生成器对象

③集合不能按下标访问元素，集合可以遍历元素（但不推荐）

a = {i for i in range(3)}
for i in a:
    print(i)

》》
0
1
2

④集合元素的增删

由于不存在下标，不存在改这一说

1.增

a.add(element)  ,会自动剔除重复元素

2.删除

a.remove(element) 删除指定元素

a.pop() 删除集合第一个元素，并将该值返回

a.clear() 清空集合，把它变成空集

⑤集合的运算（交，并，差）

& 交

| 并

-差

a = {1,2,3}
b = {3,4,5}
print(a&b)
print(a|b)
print(a-b)

》》
{3}
{1, 2, 3, 4, 5}
{1, 2}

5.字典

字典是用{}括起来的“键”“值”对的集合

字典的特征：

1.可以通过“键”访问元素，不能通过索引

2.字典是无序的

3.字典的值可以是任意而且是可重复的，包括列表或者字典

对于键：

1.必须唯一

2.必须不可变“数字，字符串，元组”

①字典的创建（赋值，dict函数）

a = {'1':188,"2":177}

zip函数：

zip（a，b），a，b为可迭代对象（列表，元组等），返回值为连续的数对

dict（）输入值要是数对元素 

a = ["a","b","c"]
b = (i for i in range(2))
c = zip(a,b)
print(dict(c))
》》

{'a': 0, 'b': 1}

dict（）另一种用法

a = dict(A127 = 12,sdi = 123)
print(a)

创建键的值为空的字典

a = [1,2,3]
b = dict.fromkeys(a)
print(b)

》》
{1: None, 2: None, 3: None}

②字典推导式

a = {i:i*10 for i in range(5)}
print(a)

》》
{0: 0, 1: 10, 2: 20, 3: 30, 4: 40}

③字典元素的访问与遍历

访问：

1.  a[键名]

a = {1:10,"2":20}
print(a[1])
print(a['2'])

》》
10
20

2.get（）方法     若无该键，可指定默认值

a = {1:10,"2":20}
print(a.get(9,"没有该键"))

》》
没有该键

遍历：三种方法

1.  a.items()  依次返回键-值对  

2.  a.keys()   依次返回键

3.  a.values() 依次返回值

a = {1:10,"2":20}
for i in a.items():
    print(i)
for k,v in a.items():
    print("这个键",k,"对应这个值",v)

》》
(1, 10)
('2', 20)
这个键 1 对应这个值 10
这个键 2 对应这个值 20

④字典元素的增删改

1.字典元素的增和改是同一个逻辑：

a[键名] = 值                (中间一定不要加· ，这是与列表访问的区别）

2.字典元素删除:

del a[键名]