day06 容器型数据 2018-07-23

一、列表

增、删、改、查

1. 修改列表元素

通过下标查找然后重新赋值: 列表名[下标] = 新的值
注意： 下标不能越界

names = ['古天乐','张家辉','刘德华','吴亦凡']
names[-1] = '王祖贤'  # 获取单个元素下标不能越界
print(names[-10:10])  # 切片时下标可以越界

['古天乐', '张家辉', '刘德华', '王祖贤']

2. 列表的其他操作

a. len(列表): 获取列表长度
b. 列表1 + 列表2: 让列表1和列表2的元素组合在一起产生一个新的列表
c. [列表] * N(整数) = [列表,列表,...,一共N个]
d. in, not in

M = [1, 2, 3]
L = len([1, 2, 3, 4, 5])
print(L,M*2,M + [4, 5, 6])

5 [1, 2, 3, 1, 2, 3] [1, 2, 3, 4, 5, 6] True True

3. 获取列表中最大的元素和最小的元素

max(列表)：获取列表中值最大的元素(当值为字符串时，执行字符串的比较方法，返回编码值最大的元素)
min(列表)：获取列表中值最小的元素(当值为字符串时，执行字符串的比较方法，返回编码值最小的元素)

print(max([1, 2, 3, 4, 5, 6, 7, 8, 9, 0]))
print(max(['a','b','c','d']))

# 不使用函数获取列表中的最大值
max1 = M[0]
for item in M:
    if item > max1:
        max1 = item
print(max1)

9
d
3

4. 其他方法

a. 列表.count(元素): 统计指定元素在列表中出现的次数
b. 列表.extend(序列): 将序列中的每一个元素添加到列表中
c. 列表.index(元素): 获取列表中指定元素的索引(有多个相同元素时取第一个值)
d. 列表.reverse(): 反向排列列表中的元素(直接操作原列表)
e. 列表.sort(): 对列表元素进行排序
f. 列表.clear(): 清空列表中的元素
g. 列表.copy(): 将列表中的元素全部拷贝一份创建一个新的列表

# 输出'刘德华'在names中出现的次数
print(names.count('刘德华'))

# 在names中添加'烤面包'
names.extend(['烤面包'])
print(names)

# 打印'刘德华'元素所对应的索引值
print(names.index('刘德华'))

# 将names反向排列
names.reverse()
print(names)

# 列表以升序排列
M.sort() # 升序
print(M)

# 列表以降序排列
M.sort(reverse=True) # 降序
print(M)

# 清空列表
M.clear()
print(M)

# 列表对列表赋值的时候是地址的传递,,改变其中一个列表,会对另一个列表产生同样的影响
n = names.copy() # 等同于names = M[:]
print(n)

1
['古天乐', '张家辉', '刘德华', '王祖贤', '烤面包']
2
['烤面包', '王祖贤', '刘德华', '张家辉', '古天乐']
[1, 2, 3]
[3, 2, 1]
[ ]
['烤面包', '王祖贤', '刘德华', '张家辉', '古天乐']

二、元组

1. 什么是元组

元组就是不可变的列表,列表中除了可变操作以外,其他操作都适用于元组

元组值: 使用()将元素包含起来,多个元素间用逗号隔开,例如:(1, 2, 'ABC')
增改删操作不能用于元组,但查找可以
color = ('红', '橙', '黄', '绿', '青', '蓝', '紫')

# 1. 查找(和列表操作完全相同)
print(color[2])  # 单个取值
print(color[2:5])  # 切片取值
print(color[::2])  # 间隔取值

# 遍历元组
for item in color:
    print(item, end='-')
print('\n')
print('--------------------------')

# 2. len(): 返回元组的长度
print(len(color))
print('--------------------------')

# 3. in, not in  判断元素是否在元组中
print('红' in color)
print('黑' in color)
print('--------------------------')

# 4. + , *
print(color + ('黑', '白'))  # 将一个心元组加入到color中
print(color*2)
print('--------------------------')

# 5.获取元组元素
names = ('name1', 'name2', 'name3')
x, y, z = names  # 通过多个变量获取元组的元素(变量个数和元组长度一致)
print(x, y)

first, *middle, last = names  # 在变量名前加*可以吧变量变成列表,获取多个元素
print(first, middle, last)
a, *b = names  # a获取元组第一个元素, b以列表方式获取剩下的元素
print(a, b)
print('--------------------------')

黄
('黄', '绿', '青')
('红', '黄', '青', '紫')
红-橙-黄-绿-青-蓝-紫-

--------------------------
7
--------------------------
True
False
--------------------------
('红', '橙', '黄', '绿', '青', '蓝', '紫', '黑', '白')
('红', '橙', '黄', '绿', '青', '蓝', '紫', '红', '橙', '黄', '绿', '青', '蓝', '紫')
--------------------------
name1 name2
name1 ['name2'] name3
name1 ['name2', 'name3']
--------------------------

三、字典

字典也是一种容器类的数据类型(序列),存储的数据时以键值对的形式出现的(字典元素全是键值对)

键值对: 键:值(key:value), 键值对中,key是形式,value才是主要内容
特点: 可变(可以增删改)无序(不能使用下标)
键: 取值理论上可以是任何不可变的数据类型,但实际开发的时候,一般使用字符串作为key
值: 可以是任意数据类型

1. 声明一个字典

#a. 创建一个字典变量
dict1 = {}  # 创建一个空的字典
print(type(dict1))

dict2 = {'a': 1, 'b': 2, 'c': 'BD', (1, 2, 3): 4, 5: [1, 2, 3]}
print(dict2)

# b. 将其他数据类型转换成字典
dict3 = dict([('A', 'B'), ('C', 'D')])
print(dict3)

<class 'dict'>
{'a': 1, 'b': 2, 'c': 'BD', (1, 2, 3): 4, 5: [1, 2, 3]}
{'A': 'B', 'C': 'D'}

2. 字典的增删查改

superhero = {'name': 'Iron Man', 'power': 1200, 'speed': 8}

a. 查:获取字典元素的值

字典获取元素的值是通过key来获取的

# 格式1：字典[key]

print(superhero['name'])
# print(superhero['age'])  # key不存在时会报错

# 格式2：字典.get(key)
print(superhero.get('name'))
print(superhero.get('ABC'))  # 如果key不存在返回None

Iron Man
Iron Man
None

b. 增: 增加元素/修改元素;

通过key获取字典元素,然后赋值.

当key本身存在的时候就修改元素的值;
不存在的时候就给字典添加键值对.

# key不存在时, 添加新的键值对
superhero['height'] = 1.8
print(superhero)

# key存在时,覆盖key对应的值
superhero['name'] = 'Spider Man'
print(superhero)

{'name': 'Iron Man', 'power': 1200, 'speed': 8, 'height': 1.8}
{'name': 'Spider Man', 'power': 1200, 'speed': 8, 'height': 1.8}

c. 删除: 删除键值对

方法1: del 字典[key]
**注意: **key不存在会报错

del superhero['height']
print(superhero)

{'name': 'Spider Man', 'power': 1200, 'speed': 8}

方法2: 字典.pop()---会返回被删除的的键值对对应的值

speed = superhero.pop('speed')
print(superhero, speed)

{'name': 'Spider Man', 'power': 1200} 8

3. 相关的数组属性

keys(): 获取字典中所有的key,返回值类型是dict_keys,但可以作为列表来使用
value(): 获取字典中所有的值(value)
items(): 将字典中的每个键值对转化为一个元组(key,value)

student_dict = {'name': '派大星', 'study_id': 'CD18055511', 'score': {'English': 90, 'Math': 100}}
keys = student_dict.keys()
print(keys, type(keys))
# 遍历获取每个key
for key in keys:
    print(key)

print(student_dict.values())
print(student_dict.items())

dict_keys(['name', 'study_id', 'score']) <class 'dict_keys'>

name
study_id
score

dict_values(['派大星', 'CD18055511', {'English': 90, 'Math': 100}])
dict_items([('name', '派大星'), ('study_id', 'CD18055511'), ('score', {'English': 90, 'Math': 100})])

4. 遍历字典

a. 直接遍历字典得到的是所有的key(推荐使用)

for key in student_dict:
    print(key, student_dict[key])

name 派大星
study_id CD18055511
score {'English': 90, 'Math': 100}

b. 遍历直接获取到key和value(会占用更多的CPU资源,不推荐使用)

for key, value in student_dict.items():
    print(key, value)

name 派大星
study_id CD18055511
score {'English': 90, 'Math': 100}

5. 列表中有字典，字典中有字典，字典中有列表

当遇到一些情况时,需要容器数据的互相嵌套
声明一个变量,作用是用来储存一个班级学生的信息,其中学生的信息包括姓名,性别,年龄,电话
至少存三个学生信息

info_class1 = [{'name': '海绵宝宝', 'gender': '男', 'age': 8, 'tel': '17764827400'},
               {'name': '派大星', 'gender': '男', 'age': 5, 'tel': '17764827401'},
               {'name': '章鱼哥', 'gender': '男', 'age': 15, 'tel': '17764827402'}
               ]
class1 = {
    'name': 'Python1805',
    'address': '19-01',
    'student': info_class1
}

6. 其他操作

a. fromkeys()

dict.fromkeys(key序列, value): 创建一个新的字典,序列中的元素为key,value为值

dict1 = dict.fromkeys('abc', 100)
print(dict1)

{'a': 100, 'b': 100, 'c': 100}

2. in

key in 字典: 判断字典中是否存在指定的key

dog_dict = {'color': 'white', 'age': 3, 'breed': '哈士奇'}
print('萨摩耶' in dog_dict)
print('color' in dog_dict)

False
True

c. update

字典1.update(字典2): 使用字典2中的键值对去更新字典1中的键值对.如果字典2中的键值对在字典1中不存在,就添加该键值对,否则更新其值.

dict1 = {1:1, 2: 2, 4: 4}
dict1.update({1: 3, 3: 3})
print(dict1)

{1: 3, 2: 2, 4: 4, 3: 3}

四、集合

集合也是一种容器类型的数据类型(序列): 数据放在{}中, 多个元素之间同逗号隔开:{1,2,3}
集合是无序的(不能通过索引取值), 可变(可以增删改), 元素是唯一的(不重复的)
集合可以进行数学中集合的相关操作: 判断是否包含,求交集,并集,差集,补集

1. 如何声明集合

a. 声明一个变量,赋值一个集合

set0 = set()  # 创建一个空集合
set1 = {1, 2, 3}
print(set1, type(set1))

{1, 2, 3} <class 'set'>

b. 将其他类型数据转换成集合

set2 = set('ABCD123')  # 将其他类型数据转换成集合可以去重
print(set2)

set3 = set([1, 2, 4, 5, 2, 3, 'a', 'c'])
print(set3)
print(list(set3))  # 将集合转换成列表

{'1', 'A', 'C', 'D', '2', 'B', '3'}

{1, 2, 3, 4, 5, 'c', 'a'}
[1, 2, 3, 4, 5, 'c', 'a']

2. 增删改查

a. 查: 遍历

注意: 集合无法单独获取某一个元素

set2 = {'1', 'A', 'C', 'D', '2', 'B', '3'}
# 遍历集合
for item in set2:
    print(item)

1
A
C
D
2
B
3

b. 增: 增加元素

set1 = {1, 2, 3}

集合.add(元素):在指定集合添加指定元素

set1.add(4)
print(set1)

{1, 2, 3, 4}

集合1.update(集合2): 将集合2的元素添加到集合1中

set1.update({4, 5})
print(set1)

{1, 2, 3, 4, 5}

c. 删

set1 = {1, 2, 3, 4, 5}

集合.remove(元素):在指定的集合中删除指定的元素

set1.remove(5)
print(set1)