4_序列（字符串、列表、元组、字典、集合）

 

目录

序列的存储方式

列表

列表创建的四种方式

列表的增加

列表元素的删除

元素的访问与计数

列表的提取子列表

列表的遍历

列表的排序（有无新对象）

最小最大求和

二维列表

元组（tuple）

元组的创建（三种方式）

元组的访问，切片，排序

zip操作

字典

字典的创建方式（四种） 

字典的访问

元素的增加，修改，删除

序列解包（一次进行多个赋值）

存储一个表格（字典和列表的嵌套）

集合

 集合的创建

 集合的交集、并集、差集

---

 

• 序列的存储方式

a = [10,20,30,40]

这个序列存放的是10，20，30，40这四个数的地址，a 存放的是存放 10 的地址的单元的地址

字符串也是序列，只不过只能存放字符串

• 列表

a = [10,20,'abc',True]  # 列表是连续可变序列，元素类型可以各不相同

列表创建的四种方式

# 第一种，按定义创建
>>> a = [10, 20, 30, 'aaa']
>>> a[3]
'aaa'

# 第二种，用 list() 创建
>>> a = list()                 # 创建一个空列表，相当于 a = []

>>> a = list('abcde')          # 也可以直接在括号中给列表赋值
>>> a
['a', 'b', 'c', 'd', 'e']

# 第三种 range的用法
>>> list(range(1, 10, 2))      # range (a,b,c)  a 表示起点，b 表示终点，c 表示步长
[1, 3, 5, 7, 9]

>>> a = list(range(10))        # range(b) 相当于 0 ~ b-1，a 和 c 可以省略，b 不能省
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> list(range(10,1,-1))       # 注意步长为负值，a 和 b 的顺序要改变，否则输出为空序列
[10, 9, 8, 7, 6, 5, 4, 3, 2]
>>> list(range(1,10,-1))
[]

# 第四种 结合循环和判断
>>> a = [x*2 for x in range(5)]    #注意空格
>>> a
[0, 2, 4, 6, 8]

>>> a = [x*2 for x in range(100) if x%9==0]    # 结合 if 语句
>>> a
[0, 18, 36, 54, 72, 90, 108, 126, 144, 162, 180, 198]

列表的增加

尽量在列表的尾部增加删除元素，提高效率 

# append() 在已有列表末尾增加一个元素
>>> a = [10,20]
>>> a.append(30)
>>> a
[10, 20, 30]

# + 拼接，会产生新对象
>>> id(a)
47756032

>>> a = a+ [40]
>>> a
[10, 20, 30, 40]

>>> id(a)
43108432

# extend() 将括号列表中所有元素增加到原列表后面，不产生新的对象，推荐使用
>>> a
[10, 20, 30, 40]
>>> id(a)
43108432

>>> a.extend([50,60])
>>> a
[10, 20, 30, 40, 50, 60]

>>> id(a)
43108432                             # 与之前的地址一致

# insert() 指定元素插入任意位置
>>> a.insert(2,100)                  # 在 a[2] 处插入100
>>> a
[10, 20, 100, 30, 40, 50, 60]

# 乘法
>>> a = [10]
>>> a * 3
[10, 10, 10]

列表元素的删除

# del 删除某个位置元素，注意空格，或者 del(a[2])
>>> a = [10,20,888,30]
>>> del a[2]            # 是元素位置，不是具体值
>>> a
[10, 20, 30]

# pop() 删除指定位置元素并返回所删除的值，括号中是元素位置
>>> a = [10,20,888,30]
>>> a.pop()            # 不指定则删除最后一个
30
>>> a
[10, 20, 888]
>>> a.pop(1)           # 指定删除 a[1]，并返回它的值
20
>>> a
[10, 888]

# remove() 删除列表中首次出现的指定元素，括号中的是元素的具体值
>>> a = [10,20,30,20]
>>> a.remove(20)
>>> a
[10, 30, 20]
>>> a.remove(50)        # 值不存在，会报错
Traceback (most recent call last):
  File "", line 1, in 
    a.remove(50)
ValueError: list.remove(x): x not in list

元素的访问与计数

>>> a = [10,20,30,20]

# 访问方式一
>>> a[1]
20

# 访问方式二，使用 index() 函数，获得指定元素在列表中首次出现的索引
>>> a.index(20)        # 括号里是元素的值
1

>>> a.index(20,3)      # index(a,b,c)，bc都可省略 
3                      #  a为元素值，b，c为从a[b]开始搜索直到a[c]，但不包括a[c]

>>> a = [1, 2, 3, 2, 2, 3]
>>> a.index(3,3,5)
Traceback (most recent call last):
  File "", line 1, in 
    a.index(3,3,5)
ValueError: 3 is not in list

# 计数
>>> a = [1, 2, 3, 2, 2, 3]
>>> a.count(2)         # 具体元素值
3

# 列表长度
>>> len(a)
6

# 判断元素在不在列表中
>>> 2 in a
True
>>> 5 not in a
True

>>> a.count(5) > 0       # 也可以，但不推荐
False

列表的提取子列表

和字符串操作一致传送门 

列表的遍历

>>> for x in a:      # 冒号不能省！！！
	print(x)

	
1
2
3
4
5

列表的排序（有无新对象）

# 不创建新列表的排序
# sort() 默认升序
>>> a = [1,3,2,5,4]
>>> id(a)
41928704
>>> a.sort()
>>> a
[1, 2, 3, 4, 5]
>>> id(a)
41928704

>>> a.sort(reverse=True)       # 降序排列
>>> a
[5, 4, 3, 2, 1]

>>> import random              # 随机排序，需要调用 random
>>> random.shuffle(a)
>>> a
[5, 4, 1, 3, 2]

# 创建新列表的排序
# sorted() 默认升序
>>> a = [1,2,4,3,5]
>>> id(a)
47681984
>>> a = sorted(a)
>>> a
[1, 2, 3, 4, 5]
>>> id(a)
47682744

>>> a = sorted(a, reverse=True)   # 降序，注意不能缺少 a，以及 reverse 的拼写
>>> a
[5, 4, 3, 2, 1]

迭代器排序（这里的排序指逆向输出，不涉及大小比较）：reversed(a) 不对原列表有任何修改

>>> a = [1,3,2,5,4]
>>> c = reversed(a)

>>> c


>>> list(c)      # 也可以一步到位  list(reversed(a))
[4, 5, 2, 3, 1]  # 只是从头到尾输出，不涉及大小比较
>>> list(c)      # 迭代对象只能用一次
[]

>>> a            # 原列表没有改变
[1, 3, 2, 5, 4]

最小最大求和

>>> a = [1,3,2,5,4]

>>> min(a)
1

>>> max(a)
5

>>> sum(a)    # 如有非数值元素会报错
15

>>> a = [1,2,'sss']
>>> sum(a)
Traceback (most recent call last):
  File "", line 1, in 
    sum(a)
TypeError: unsupported operand type(s) for +: 'int' and 'str'

二维列表

>>> a = [
	["aaa", 15, 3000],        # 注意逗号
	["bbb", 16, 4000],
	["ccc", 17, 5000],
	]

>>> a[0][0]
'aaa'
>>> a[1][1]
16

• 元组（tuple）

1. 不可变序列，不可以修改元素的值！！！

2. 访问处理速度比列表快！！！

3. 与整数和字符串一样，元组可以作为字典的键，列表不可以！！！

元组的创建（三种方式）

# 第一种创建方式（两种形式都可以）
>>> a = 10,20,30
>>> b = (10,20,30)

>>> c = (10)             # 注意如果只有一个元素，后面要加逗号
>>> type(c)


>>> c = (10,)            # 或者 c = 10,
>>> type(c)


# 第二种创建方式 tuple()
>>> a = tuple()          # 创建一个空元组
>>> a
()

>>> a = tuple(range(3))  # 把其他类型的变为元组类型，相当于 list() 的用法
>>> a
(0, 1, 2)

>>> del a                # 元组的删除
>>> a
Traceback (most recent call last):
  File "", line 1, in 
    a
NameError: name 'a' is not defined

# 第三种，生成器推导式创建
>>> a = (x*2 for x in range(5))                # 生成一个生成器对象
>>> a                             
 at 0x02D4BE30>
>>> tuple(a)                                   # 把生成器对象变成元组对象
(0, 2, 4, 6, 8)

>>> tuple(a)                                   # 生成器对象只能用一次，再用要重新生成
()

# 生成器的访问（只能用于生成器，如果在访问前改变了类型依然使用该方式访问会报错）
>>> a = (x*2 for x in range(2))

>>> a.__next__()                     # 双下划线！！！
0
>>> a.__next__()
2
>>> a.__next__()                     # 每次访问指针下移，超出范围报错
Traceback (most recent call last):
  File "", line 1, in 
    a.__next__()
StopIteration

元组的访问，切片，排序

访问、切片、最大、最小，计数、求和 和列表操作一致！

但是不能修改元组内部元素的值！！！

# 排序只能使用 sorted() ，并且生成新的列表对象，而不是元组对象
>>> a = 1,5,3,4,2
>>> sorted(a)
[1, 2, 3, 4, 5]

zip操作

# zip() 将三个列表整合成一个zip对象，再将其变为列表对象，每个元素是元组对象
# 即将列表变为元组
>>> a = [10,20,30]
>>> b = [1,2,3]
>>> c = [4,5,6]
>>> d = zip(a,b,c)
>>> list(d)
[(10, 1, 4), (20, 2, 5), (30, 3, 6)]

>>> zip(a,b,c)                # 生成的一个 zip 对象

• 字典

字典是“键值对”的无序可变序列，每一个元素都是一个“键值对”，包括“键对象”和“值对象”！！！

通过“键对象”找到“值对象”！！！

键：

任意不可改变的数据，整数、浮点数、字符串、元组都可以是键，字典，列表等可变对象不能作为键！

键不能重复！

值：

任意数据且可重复！

字典的创建方式（四种） 

# 第一种方式：使用 {}
>>> a = {'name' : 'aaa', 'age' : 15, 'dd' : [2,3,4]}
>>> a
{'name': 'aaa', 'age': 15, 'dd': [2, 3, 4]}

# 第二种方式：使用 dict() 的两种形式
>>> b = dict(name = 'aaa', age = 15, dd = [2,3,4])    # 注意等号
>>> b
{'name': 'aaa', 'age': 15, 'dd': [2, 3, 4]}

>>> c = dict([('name','aaa'), ('age',15), ('dd', [2,3,4])])  # 每一个键对象是一个元组
>>> c                                                        
{'name': 'aaa', 'age': 15, 'dd': [2, 3, 4]}

# 创建空字典
>>> a = {}
>>> a
{}
>>> b = dict()
>>> b
{}

# 第三种方式：通过 zip() 创建
>>> a = ['name', 'age', 'dd']        # 键对象
>>> b = ['aaa', 15, [2,3,4]]         # 值对象
>>> c = dict( zip(a,b) )
>>> c
{'name': 'aaa', 'age': 15, 'dd': [2, 3, 4]}

# 第四种方式：使用 fromkeys 创建值为空的字典
>>> a = dict.fromkeys(['name', 'age', 'dd'])
>>> a
{'name': None, 'age': None, 'dd': None}

字典的访问

# 通过键访问值（两种方式）
# 第一种
>>> a = {'name' : 'aaa', 'age' : 15, 'dd' : [2,3,4]}

>>> a['name']
'aaa'
>>> a[555]                                  # 如果键不存在，报错
Traceback (most recent call last):
  File "", line 1, in 
    a[555]
KeyError: 555

# 第二种：get() 推荐使用
>>> a.get('name')    
'aaa'

>>> a.get(555)                              # 如果键不存在，不打印
>>> print(a.get(555))                       # 默认值为空
None

>>> a.get(555,'不存在')                      # 可以指定打印内容
'不存在'

# 列出所有键值对
>>> a = {'name' : 'aaa', 'age' : 15, 'dd' : [2,3,4]}
>>> a.items()
dict_items([('name', 'aaa'), ('age', 15), ('dd', [2, 3, 4])])

# 列出所有的键
>>> a.keys()
dict_keys(['name', 'age', 'dd'])

# 列出所有的值
>>> a.values()
dict_values(['aaa', 15, [2, 3, 4]])

# 键值对个数
>>> len(a)
3

# 检测键是否在字典中
>>> 'name' in a
True

元素的增加，修改，删除

# 增加
# 如果键不存在，则新建一个键，如果键存在，则覆盖键的值
>>> a = {'name' : 'aaa', 'age' : 15, 'dd' : [2,3,4]}

>>> a['address'] = 'cc'            # 增加键的名字和它的值
>>> a['age'] =  17

>>> a
{'name': 'aaa', 'age': 17, 'dd': [2, 3, 4], 'address': 'cc'}

# 把一个字典全部添加到另一个字典上，相同键覆盖，不同则添加
>>> a = {'name' : 'aaa', 'age' : 15, 'dd' : [2,3,4]}
>>> b = {'name' : 'bbb', 'age1' : 17}

>>> a.update(b)
>>> a
{'name': 'bbb', 'age': 15, 'dd': [2, 3, 4], 'age1': 17}  # 覆盖了 'aaa'

>>> a = {'name' : 'aaa', 'age' : 15, 'dd' : [2,3,4]}

# 删除某个键
>>> del(a['age'])
>>> a
{'name': 'aaa', 'dd': [2, 3, 4]}

# 删除某个键并返回它的值
>>> a.pop('dd')
[2, 3, 4]

# 删除所有键
>>> a.clear()
>>> a
{}

# 随机删除并返回值
>>> a = {'name' : 'aaa', 'age' : 15, 'dd' : [2,3,4]}

>>> a.popitem()
('dd', [2, 3, 4])

>>> a
{'name': 'aaa', 'age': 15}

>>> a.popitem()
('age', 15)

>>> a
{'name': 'aaa'}

序列解包（一次进行多个赋值）

# 默认对键进行解包
>>> a = {'name' : 'aaa', 'age' : 15, 'dd' : [2,3,4]}

>>> x, y, z = a        # 解包

>>> x
'name'
>>> y
'age'
>>> z
'dd'

# 对键值对解包
>>> x, y, z = a.items()

>>> x
('name', 'aaa')
>>> y
('age', 15)
>>> z
('dd', [2, 3, 4])

# 对键值解包
>>> x, y, z = a.values()

>>> x
'aaa'
>>> y
15
>>> z
[2, 3, 4]

存储一个表格（字典和列表的嵌套）

# 每一行信息作为一个字典
r1 = {'name' : 'aaa', 'age' : 15, 'city' : 'A'}
r2 = {'name' : 'bbb', 'age' : 16, 'city': 'B'}
r3 = {'name' : 'ccc', 'age' : 17, 'city' : 'C'}

# 所有信息作为一个列表
r = [r1,r2,r3]

for x in range(len(r))：        # 注意冒号
    print(r[x].get('name'), r[x].get('age'), r[x].get('city'))

# 表格如下
'''
aaa 15 A
bbb 16 B
ccc 17 C
'''  

• 集合

无序可变，元素不能重复！！！

集合的底层是字典实现，集合的元素相当于字典中的键，因此不能重复！！！

 集合的创建

# 第一种：直接创建
>>> a = {1,5,'dd','aa'}
>>> a
{'dd', 1, 5, 'aa'}

# 增加元素，如果存在没有变化
>>> a.add(15)
>>> a
{1, 5, 'dd', 15, 'aa'}

# 第二种：将元组数列等可迭代的变为集合
>>> a = [1,2,3,'a']
>>> b = set(a)
>>> b
{1, 2, 3, 'a'}

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

清除所有元素  a.clear()

 集合的交集、并集、差集

>>> a = {1,2,3,4}
>>> b = {1,2,'aa'}

# 交集  
>>> a|b            # 或者 a.union(b)
{1, 2, 3, 4, 'aa'}

# 并集  
>>> a&b            # 或者 a.intersection(b)
{1, 2}

# 差集  （ a 集合中去除和 b 相同的元素）
>>> a-b            # 或者 a.difference(b)
{3, 4}