一、列表中的 增、删、改、查

1、修改列表元素

通过下标获取元素，然后重新赋值：列表名[下标]=新的值
注意： 这儿的下标不能越界

names = ['周星驰', '张家辉', '张学友', '洋洋']
names[-1] = '陈奕迅'
print(names)
['周星驰', '张家辉', '张学友', '陈奕迅']

2、列表的其他操作

1、len():获取列表的长度（元素的个数）
2、列表1 + 列表2 ：让列表1和列表2的元素组合在一起，产生一个新的列表
3、列表 * 数字：让列表中的元素重复N次，产生一个新的列表
4、in， not in操作
元素 in 列表：判断指定的元素是否在指定的列表里

print([1, 3] * 2)
result = 'sd' in names
print(result)
[1, 3, 1, 3]
False

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

max(列表)
min(列表)

#max运行原理
numbers = [1, 23, 43, 211, 7, 1]
max1 = numbers[0]
               
for x in numbers:
    if x > max1:
        max1 = x
print(max1)
211

4、其他方法

1、 count: 获取指定元素在列表中出现的方法
2、 extend: 格式： 列表名.extend(序列)：将序列中的每一个元素，添加到列表中

names.extend(['王祖贤'])
 names.extend('王祖贤')
print(names, names2)
['周星驰', '张家辉', '张学友', '陈奕迅', '王祖贤', '王', '祖', '贤']

3、列表.index(元素)：获取指定元素在指定列表中的索引(如果有多个元素，就取第一个)
4、列表.reverse():反向列表中的元素，对原来的列表进行操作

num = [1, 212, 3, 454, 23, 9, 23]
nnum = num.reverse()
print(num, nnum)
[23, 9, 23, 454, 3, 212, 1] None

5、列表.sort():对列表元素进行排序（默认是从小到大排序）

num.sort()
print(num)
num.sort(reverse=True)
print(num)
[1, 3, 9, 23, 23, 212, 454]
[454, 212, 23, 23, 9, 3, 1]

6、列表.clear():清空列表中的元素

num.clear() 相当于 num = []

7、列表.copy():将列表的元素全部拷贝一份创建新的列表

注意:通过一个列表变量给另一个列表变量赋值的时候,赋的是地址:两个列表对元素进行操作会相互影响,要想避免这个问题就使用copy,或[:]

列表方法
列表方法

二、元组

1.什么是元组？ 元组就是不可变得列表，列表中除了可变的操作，其他的操作都适用于元组

元组值：
当元组的元素个数是一个的时候，需要在元素后面加一个逗号，表示这个值是一个元组。
a、使用（）将元素包含起来，多个元素用逗号隔开.比如:(1,2,'22cc')
b、元素的类型可以是任何类型

2、改、增、删相关操作不能作用于元组。查可以

1、查（和列表的查一模一样）

colors = ('red', 'green', 'yellow', 'blue')
print(colors[0])
print(colors[0:2])
print(colors[2:0:-1])
red
('red', 'green')
('yellow', 'green')

2、len 可以
3、in ， not in可以
4、+和' * '可以（会生成新的元组，不会对原来的元组进行操作）

5、元组补充（列表也可以用）：

1、获取元组的元素

names = ('name1', 'name2', 'name3')
x, y, z = names   # 通过多个变量分别获取元组的元素(变量个数和元组个数相同)
print(x, y, z)
names = ('name1', 'name2', 'name3', 'name4')
a, *b, c = names  # 通过变量名前加*可以把变量变成列表，获取多个元素
print(a, b, c)

*d, e = names
print(d, e)
f, *g = names
print(f, g)

name1 name2 name3
name1 ['name2', 'name3'] name4
['name1', 'name2', 'name3'] name4
name1 ['name2', 'name3', 'name4']

三、字典

字典也是一种容器类型数据类型（序列），存的数据是以键值对的形式出现的，字典是可变的（可以增删改），但是是无序的（不能使用下标）。
字典中的元素全是键值对
键值对：键：值 （key:value）;键值对中key是形式，值才是真正要存的内容，键理论上是可以任何不可变的数据类，但是实际开发中一般使用字符串作为key
值：可以是任意数据类型的数据
字典中的key是唯一的。

1、声明一个字典

dict1 = {} # 创建一个空的字典

print(type(dict1))
dict2 = {'a': 22, 'b': 'a31', ('a', 'b'): 1, 10: [1.3, 4, 5]}
print(dict2)
<class 'dict'>
{'a': 22, 'b': 'a31', ('a', 'b'): 1, 10: [1.3, 4, 5]}

a、其他类型数据转换成字典

dict3 = dict([('a', 12), (323, 'da')])
print(dict3)
{'a': 12, 323: 'da'}

b、字典的键是惟一的，如果键有多个，后面的键会覆盖前面的

2、字典的增删改查

a、查：获取字典的元素的值
字典获取元素的值是通过key来获取的
字典[key]

person = {'name': 'luck', 'age': 13, 'height': 133}
print(person['name'], person['age'])
luck 13
# 如果key值不存在，会报KeyError

字典.get(key)

print(person.get('name'))
print(person.get('aasda'))
luck
None
  # 如果key不存在，会返回none
# 注意：如果key确定存在，使用[]去获取，不确定key是否存在才使用get方法去获取

b、增加元素、修改元素
通过key获取字典元素，然后赋值。当key存在的时候，就是修改元素的值，

#如果key不存在的时候，就是给字典添加键值对
person['weight'] = 100
print(person)

person['age'] = 22
print(person)
{'name': 'luck', 'age': 13, 'height': 133, 'weight': 100}
{'name': 'luck', 'age': 22, 'height': 133, 'weight': 100}

c、删除 :删除的是键值对
del 字典[key] ---key不存在会报错，报的还是KeyError
字典.pop(key) ---会返回删除的键值对对应的值

3、相关的数组属性

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

student_dict = {'names': '张三', 'student_id': 'Py1805002', 'scores': {'english': 32, 'math': 98}}
keys = student_dict.keys()
print(keys, type(keys))
dict_keys(['names', 'student_id', 'scores']) <class 'dict_keys'>

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、列表中有字典和字典中有字典，以及字典中有列表

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

students = {'names': ['张三', '李四', '王五'], 'ages': [18, 19, 20], 'sex': ['fmale', 'male', 'famale'] }

6、其他操作

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

dict4 = dict.fromkeys('abc', '1000')
print(dict4)
{'a': '1000', 'b': '1000', 'c': '1000'}

2、in
key in 字典：判断字典中是否存在指定的key
3、update
字典1.update(字典2)：使用字典2的键值对去更新字典1中的键值对。如果字典2中对应键值对在字典1中不存在，就添加，存在就更新.

dict1 = {'1': 'a', '2': 'b'}
dict1.update({'1': 'aaa', '3': 'sdsa'})
print(dict1)
{'1': 'aaa', '2': 'b', '3': 'sdsa'}

字典其他的用法如图：

字典函数

四、集合

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

1、怎么声明集合

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

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

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

set2 = set('adwdqqqaa12222333')  # 将其他数据转换成集合，自带去重
print(set2)
{'a', 'w', '1', '3', 'd', 'q', '2'}

2、增删改查

a、查：

# 注意:集合没办法单独获取一个元素
for item in set2:
    print(item)
print('=====')
a
w
1
3
d
q
2
=====

b、增：
集合.add（元素）在指定的集合中，添加指定的元素
集合1.update(集合2) ：将集合2中的元素添加到集合1中，自动去重

c.删除：
set.remove(元素) 在指定的集合中，删除指定的元素

set2.remove('a')
print(set2)
print('====')
# pop删除虽然看上去是删除第一个，但是随机删除一个
set2.pop()
print(set2)
set2.pop()
print(set2)
{'w', '1', '3', 'd', 'q', '2'}
====
{'1', '3', 'd', 'q', '2'}
{'3', 'd', 'q', '2'}

3、判断是否包含

集合1 >= 集合2 ---判断集合1中是否包含集合2
集合1 <= 集合2 ---判断集合2中是否包含集合1

print({1, 3, 4, 5, 7, 9} >= {1, 3})
print({1, 3, 4, 5, 7, 9} <= {1, 3})
True
False

4、数学的集合运算

求并集 ： |

print({1, 3, 4, 5, 7, 9} | {1, 3, 99, 10, 5})

求交集： &

print({1, 3, 4, 5, 7, 9} & {1, 3, 99, 10, 5})

求差集：- (返回一个新的集合，包含前一个集合但后一个集合没有的元素)

print({1, 3, 4, 5, 7, 9} - {1, 3, 99, 10, 5})

求补集: ^(返回含有两个集合中有但不是两者都有的元素的 集合)

print({1, 3, 4, 5, 7, 9} ^ {1, 3, 99, 10, 5})

输出结果

{1, 3, 4, 5, 99, 7, 9, 10}
{1, 3, 5}
{9, 4, 7}
{99, 4, 7, 9, 10}

5、其他的方法

clear : 清空集合

set1.clear()
print(set1, type(set1))
set() <class 'set'>

len:获取集合中元素的个数

print(len(set1))
0