01.列表

增、删、改、查

1.修改列表元素

• 通过下标获取元素，然后重新赋值：列表名[下标] = 新的值

names = ['许中秋','周佳豪','张阿洪','赵航翊','杨洋']
names[4] = '陈奕迅'
print(names)

name = names[-1]
print(name)

2.列表的其他操作

• 1.len(列表)：获取列表的长度（元素的个数）
• 2.列表1 + 列表2：让列表1和列表2的元素组合在一起产生一个新的列表
• 3.列表*数字：让列表中的元素重复N次，产生一个新的列表

new_names = names+['周杰伦','王力宏']
print(new_names)

print([1,2]*3)

• 4.in, not in
  元素 in 列表：判断指定的元素是否在指定的列表中

result = '高以翔' not in names
print(result)

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

max(列表)
min(列表)

print(max([1,2,3,4,6]))
print(max('a','c','vfd','z'))
print(min([1,2,3,4,6]))
print(min('a','c','vfd','z'))

• 获取一个数字列表中的最大值

num = [4,5,3,889,5565,7]
num1 = num[0]
for i in num:
    if i > num1:
        num1 = i
print(num1)

4.其他方法

• 1.count:获取指定元素在列表中出现的次数
  print(num.count(-1))

• 2.列表.extend（序列）：将序列中的每一个元素，添加到列表中

names.extend(['王祖贤'])
print(names)

• 3.列表.index（元素）：获取指定元素在指定列表中的索引（如果元素有多个，取第一个）
  print(names.index('许中秋'))

• 4.列表.reverse（）：反向列表中的元素(直接操作的原列表，不会产生新的列表)

numbers = [1,2,3,4]
new_numbers = numbers.reverse()
print(numbers,new_numbers)

• 5.列表.sort（）：对列表元素进行排序

numbers = [1,42,45,2,87,8]
numbers.sort()   #升序
print(numbers)

numbers.sort(reverse=True)
print(numbers)  #降序

• 6.列表.clear（）

numbers.clear()
print(numbers)

• 7.列表copy（）：将列表中的元素全部拷贝一份创建一个新的列表

names1 = ['aaa','bbb']
new_names1 = names1.copy()
print(new_names1)

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

02.元组

1.什么是元组
元组就是不可变的列表，列表中除了可变的操作以外，其他的操作都适用于元组
元组值：a.使用（）将元素包含起来，多个元素之间用逗号隔开，比如（1，2，‘abc’）b.元素的类型可以是任何类型
2.改、增、删相关操作不能作用于元组，查可以
colors = ('red','green','yellow')

• 1.查（和列表的查一模一样，没有任何区别）

print(colors[1])
print(colors[0:3])
print(colors[0::2])
for i in colors:
    print(i)

names = ('name1','name2','name3')
x,y,z = names # 通过多个变量分别获取元组的元素（变量个数和元组个数一样）
print(x,y,z)

first,*midel,last = names  # 通过变量名前加*可以把变量变成列表，获取多个元素
print(first,midel,last)

name,*name1 = names #让name获取第一个元素，剩下的部分作为列表name1的元素
print(name)

• 2.len
  print(len(colors))

• 3.in , not in
  print('red' in colors)

• 4.+和*

print((1,2) + (3,4))
print((1,2) * 2)

• 注意：当元组的元素个数是一个的时候，需要在元素后面加一个逗号，表示这个值是一个元组

03.字典

字典也是一种容器类型的数据类型（序列），存的数据是以键值对的形式出现的，字典中的元素全部都是键值对
字典是可变的（可以增删改查），但是是无序的（不能使用下标）
键是唯一的

键值对：键：值（key：value）；键值对中key是形式，值才是真正要存的内容
键：理论上可以是任何不可变的数据类型，但是实际开发的时候一般使用字符串作为key
值：可以是任意数据类型

1.声明一个字典

• a.创建一个字典变量"""

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

dict2 = {'a':1,'b':2}
print(dict2)

dict2 = {'a':1,'b':3,'a':10}
print(dict2)

• b.将其他数据类型转换成字典"""

dict3 = dict([(1,2),(3,4)])
print(dict3)

2.字典的增删改查

• a.查;获取字典的元素的值
  字典获取元素的值是通过key来获取的
  字典[key]

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


字典.get（key）
print(person.get('name'))
print(person.get('aaa'))  #如果key不存在，返回None
注意：如果key值确定存在，使用[]语法去获取。不确定key值是否存在才使用get方法去获取值

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

person['hight'] = 1.8
print(person)
person['age'] = 18
print(person)

• c.删除：

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

del person['face']
print(person)

字典.pop（key）  ---会返回被删除的键值对对应的值

age = person.pop('age')
print(person,age)

3.相关的数组属性（了解）

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

student_dic = {'name':'张三','stdudy_id':'py1805001','scores':{'english':60,'math':100}}
keys = student_dic.keys()
print(keys,type(keys))
# 遍历获取每个key
for key in keys:
    print(key)

print(student_dic.values())

print(student_dic.items())

4.遍历字典

• a.直接遍历字典获取到的是所有的key（推荐使用）

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

• b.遍历直接获取到key和value（不推荐使用）

for key,value in student_dic.items():
    print(key,value)
for value in student_dic.values():
    print(value)

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

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

class1 = {
    'name':'py1805',
    'address':'19-1',
    'students':[
        {'name':'xzq','age':18},
        {'name':'xzq1','age':18},
        {'name':'xzq2','age':18},
    ]
}

6.其他操作

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

new_dict = dict.fromkeys(range(10),'100')
new_dict = dict.fromkeys('abcde','81')
new_dict = dict.fromkeys(['abc','bcd','cde'],'111')
print(new_dict)

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

dog_dict = {'color':'white','age':3,'type':'土狗'}
print('color' in dog_dict) #判断键是否存在
print('white'in dog_dict)

• 3.update
  字典1.update（字典2）：使用字典2的键值对去更新字典1中的键值对。如果字典2中对应的键值对在字典1中不存在，就添加。存在就更新

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

04.集合

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

1.怎么声明集合

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

set1 = {1,2,3}
print(set1,type(set1))

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

set2 = set('abc123') #将其他数据转换成集合，自带一个去重功能
print(set2)
set3 = set([12,'abc','hh',32,12])
print(set3)
print(list(set3))

2.增删改查

• a.查：遍历
  注意：集合没有办法单独获取某一个元素

for item in set2:
    print(item)

• b.增
  集合.add（元素）：在指定的集合中添加指定的元素

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

• 集合1.update（集合2）：将集合2中的元素添加到集合1中，自动去重

set1.update({'a','b'})
print(set1)

• c.删除"""
  集合.remove（元素）：在指定的集合中删除指定的元素

set1.remove(1)
print(set1)

• pop删除是随机删除的

set1.pop()
print(set1)

3.判断是否包含

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

print({1,2,3,4} >= {1,4})
print({1,2,3,4} <= {1,2})

4.数学的集合运算

• 求并集：|
  print({1,2,3}| {2,3,4,5})

• 求交集：&
  print({1,2,3}& {2,3,4,5})

• 求差集：-
  print({1,2,3}- {2,3,4,5})

• 求补集：^

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

5.其他方法

• clear:清空集合"""

set1.clear()
print(set1,type(set1))

• len:获取集合中元素的个数"""
  print(len(set1))