06 - 关于几种容器数据类型

2018-07-23 本文已影响0人卅月

1.列表（补充）

(1)修改列表元素

通过下标获取元素，然后重新赋值:(下标不能越界)
方法：列表名[下标] = 新的值

names = ['周星驰', '渣渣辉', '古天乐', '黄渤', '杨洋']
names[-1] = '李健'
print(names)    # ['周星驰', '渣渣辉', '古天乐', '黄渤', '李健']

(2).列表的其他操作

len() 获取列表长度
列表1 + 列表2 将列表1和列表2的元素组合在一起，产生一个新的列表
列表 * n 让列表中的元素重复n次，产生一个新的列表
in ,not in 判断元素是否在列表里面

(3).获取列表中最大，最小的元素

max(列表)
min(列表)

(4).其他方法

count:获取指定元素在列表中出现的次数
列表.count(元素)
extend:将一个序列中的每一个元素，添加到列表中.(与 + 不同，extend不产生新的列表)

names = ['周星驰', '渣渣辉', '古天乐', '黄渤', '李健']
names.extend(['王祖贤'])
print(names)
names.extend('王祖贤')
print(names)

['周星驰', '渣渣辉', '古天乐', '黄渤', '李健', '王祖贤']
['周星驰', '渣渣辉', '古天乐', '黄渤', '李健', '王祖贤', '王', '祖', '贤']

列表.index(元素)：获取指定元素在指定列表中的索引（如果元素有多个，取第一个）
列表.reverse()：将列表中的元素顺序反向 ,并不会产生新的列表
列表.sort():对列表进行排序

nums = [12, 32, 65, 13, 7, 85]
nums.sort()     # 升序
print(nums)
nums.sort(reverse=True)   #降序
print(nums)

[7, 12, 13, 32, 65, 85]
[85, 65, 32, 13, 12, 7]

列表.clear() 清空列表元素，相当于：列表=[ ]
列表.copy()：将列表中的元素全部拷贝一份创建一个新的列表，相当于列表[ : ]

list1 = [1,2,3,4,5]
list2 = list1.copy()
print(list1)
print(list2)

2.元组

(1).什么是元组

元组就是不可变的列表
元组值： a.使用（）将元素包含起来，多个元素之间用逗号隔开，比如：（1,2,'abc'）
b.元素的类型可以是任何的类型

(2).增删改查操作

因为元组的特性，增、删、改的操作不能用于元组。但是可以查询

colors = ('red', 'green', 'yellow', 'purple')

# 查：(同列表的操作方式)
print(colors[1])
print(colors[0::2])

green
('red', 'yellow')

len() 、 in和not in 、 +和* 、(方法同列表)

将元组转化为列表：

colors = ('red', 'green', 'yellow', 'purple')
list1 = list(colors)
print(list1, type(list1))

['red', 'green', 'yellow', 'purple'] <class 'list'>

(3).元组补充：获取元组的元素

names = (1, 2, 3, 4, 5, 6)
x, y, z, a, b, c = names            #通过多个变量分别获取元组的元素
print(x, y, z, a, b, c)             #变量的数量必须与元素数量相等

a, *b, c = names            # 用*可以获取不定长度的元素序列，*对应的变量则变成列表
print(a, b, c)

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

3.字典

字典也是一种容器类型的数据类型（序列），存的数据是以键值对的形式出现的，字典中的元素全部都是键值对。
字典是可变的（可增删改），但是是无序的（不能使用下标）
字典的组成：
        键:值(key:value) 值才是真正要存的内容，key这是存值的一方式
        键: a.理论上可以使任何不可变的数据类型，但是实际开发的时候一般使用字符串作为key
              b.键是唯一的，如果存在相同的键，则后面赋的值，会覆盖前面的值
        值：可以是任意数据类型的数据

(1)字典的声明

dict1 = {}
dict2 = {'a': 1, 'b': 2, 'c': 3}

(2).字典的增删改查

a.查：

即：获取字典的元素的值，字典获取元素的值是通过key来获取的
注意:如果确定key值存在的时候，使用[]方式获取
如果不确定key是否存在的时候，使用get()方法获取

字典[key]

person = {'name': '路飞', 'age': 17, 'face': 90}
print(person['name'], person['face'])
# print(person['aaa'])  # 如果key不存在，则会报错：key Error

字典.get(key)

print(person.get('name'))
print(person.get('aaa'))        # 通过get方法，如果key不存在，返回none，不会报错

b.增加元素/修改元素

通过key获取字典元素，然后赋值。当key本身就存在的时候，就是在修改元素的值，不存在的时候就是给字典添加键值对。

person['height'] = 12
print(person)
# {'name': '路飞', 'age': 17, 'face': 90, 'height': 12}

person['age'] = 18
print(person)
# {'name': '路飞', 'age': 18, 'face': 90, 'height': 12}

c.删除

del 字典[key] 注意：如果key不存在，会报错

del person['age']
print(person)
# {'name': '路飞', 'face': 90, 'height': 12}

字典.pop(key) 把需要删的键值对取出来,把值保存在别处

he = person.pop('height')
print(person, he)
# {'name': '路飞', 'face': 90} 12   ------此处删除了‘height’对应的键值，并把value赋给了变量he得以保存。

(3)相关的数组属性

字典.keys():获取字典所有的key，返回值的类型是dict_keys，但是可以把他当成列表来使用
字典.values():获取字典所有的值(value)
字典.items():将字典中所有的键值对转换成一个一个的元组，key作为元组的第一个元素，value作为元组的第二个元素

student_dict = {'name': '张三', 'study_id': 'py1805220', 'scores': {'english': 60, 'math':100}}

keys = student_dict.keys()
print(keys, type(keys))
# dict_keys(['name', 'study_id', 'scores']) <class 'dict_keys'>

# 遍历获取每个key
for key in keys:
    print(key)
"""name
study_id
scores
"""
print(student_dict.values(), type(student_dict.values()))
print(student_dict.items(), type(student_dict.items()))
# dict_values(['张三', 'py1805220', {'english': 60, 'math': 100}]) <class 'dict_values'>

(4).遍历字典

a.直接遍历字典获取到的是所有的key ------推荐使用
for key in student_dict:
print(key, student_dict[key])
b.遍历直接获取到key和value ------ 不推荐，消耗cpu较高
for key, value in student_dict.items():
print(key, value)

(5).列表中有字典、字典中有字典、字典中有列表

"""
声明一个变量，作用是用来存储一个班级的学生的信息。其中学生的信息包括姓名、性别、年龄、电话
至少存3个学生的信息

stu_info = [{'name': '张三', 'age': 15, 'sex': '男', 'tel': '123421323'},   #-------->使用:列表 [{字典}]
            {'name': '李四', 'age': 16, 'sex': '女', 'tel': '123421323223'},
            {'name': '王五', 'age': 18, 'sex': '男', 'tel': '12323232421323'}]

print(stu_info)

(6).其他操作

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

# new_dict = dict.fromkeys('abc', 100)
# new_dict = dict.fromkeys(range(10), 100)
new_dict = dict.fromkeys(['abc', 'edf', '12'], 100)
print(new_dict)

#{'abc': 100, 'edf': 100, '12': 100}

2.in
key in 字典：判断字典中是否存在指定的key
value in 字典：判断字典中是否存在指定的value

dog_dict = {'color': 'while', 'age': 3, 'type': '土狗'}
print('age' in dog_dict)

# True

3.update
字典1.update(字典2):
使用字典2的键值对去更新字典1中的键值对。如果：字典2中对应的键值对在字典1中不存在就添加到字典1中，如果存在的话，就更新相应的键值对。

dict1 = {'1': 'a', '2': 'b'}
dict2 = {'1': 'aa', '3': 'cc'}
dict1.update(dict2)
print(dict1)

# {'1': 'aa', '2': 'b', '3': 'cc'}

4.集合

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

(1）声明一个集合

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

(2)将其他的数据转换成集合(自带去重功能)

set2 = set('abc123aaa5')
print(set2)
set3 = set([12, 'abc', 'hh', 12, 32, 'abcn'])
print(set3)
print(list(set3))

{'b', '3', 'c', '2', '5', 'a', '1'}
{32, 'hh', 'abcn', 12, 'abc'}
[32, 'hh', 'abcn', 12, 'abc']

(3).增删改查

a.查 : (遍历)

注意：集合没有办法单独通过索引获取某一个元素，需要循环遍历

b.增 / 改

集合.add(元素)：在指定的集合中添加指定的元素

set1 = {1, 2, 3}
set1.add(100)
print(set1)

{1, 2, 3, 100}

集合1.update(集合2)：将集合2中的元素添加到集合1中，并自动去重
set1.update(set2)

c.删

remove()
集合.remove(元素)：在指定的集合中删除指定的元素
pop()删除是随机删除一个元素
集合.pop()

(4).判断是否包含

集合1 >= 集合2 -- 判断集合1中是否包含集合2
集合1 <= 集合2 -- 判断集合2中是否包含集合1
print({1, 2, 4} >= {1, 2, 3, 4, 5}) # False

(5).数学中的集合运算

"""求并集 |  """
print({1, 2, 3} | {2, 4, 5})  #{1, 2, 3, 4, 5}

"""求交集 &  """
print({1, 2, 3, 4} & {2, 4, 5})  #{2, 4}

"""求差集  -  """  
print({1, 2, 3, 5} - {2, 3, 4, 7})  #{1, 5}

"""求补集  ^  """
print({1, 2, 4} ^ {1, 2, 3, 4, 5})  #{3, 5}

(6)其他方法

集合.clear()：清楚集合内容

print(set1.clear())  #None