1.列表

1.1.修改列表元素

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

names = ['周星驰', '张家辉', '刘德华', '黄渤', '杨洋']

names[4] = '陈奕迅'
print(names)

1.2.列表的其他操作

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

print(len(names))

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

print([1,2]*3)

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

max(列表)
min(列表)

print(max([1,2,5,2,7,99]))
print(max(['a', 'hjj', 'sfoj', 'z']))
# 获取一个数字列表中的最大值
def max_ (li):
    max_num = li[0]
    for item in li:
        if max_num < item:
            max_num = item
    return max_num

numbers = [1, 243, 4, 1, 88]
print(max_(numbers))

1.4.其它方法

1.列表.count(元素)：统计某个元素在列表中出现的次数
2.列表.extend(序列)：将序列中的每一个元素，添加到列表中
3.列表.index(元素)：获取指定元素在指定列表中的索引，如有多个，则取第一个元素的索引
4.列表.reverse()：反向列表中的元素(直接操作原列表，不生成新列表)
5.列表.sort()：对列表元素排序（默认是升序）
6.列表.clear()：清空列表
7.列表.copy()：将列表中的元素全部拷贝到一个新的列表中
注意：通过一个列表变量给另一个列表变量赋值时，赋的是地址，两个列表对元素的操作会相互影响
想要避免这个问题就使用copy或者切片

# .count(元素)计数
print(numbers.count(1))

# .extend(序列)序列添加
names.extend(['王祖贤'])
print(names)

# .index(元素)获取元素索引
print(names.index('张家辉'))

# .reverse()反向
numbers = [1, 22, 3, 44, 8]
numbers.reverse()
print(numbers)

# .sort(）排序
numbers.sort()  # 升序
print(numbers)

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

# .clear()清空
numbers.clear()
# numbers = []  # 效果同上
print(numbers)

# .copy()复制
new_names1 = names.copy()
# new_names1 = names[:]  # 效果同上，且用更多
print(new_names1)

2.元祖

2.1. 什么是元祖

1.元祖就是不可变的列表
元祖值：a.使用()将元素包含起来，元素之间用逗号分开：如(1, 2, '33')
               b.元素的类型可以是任何类型
2.增、删、改相关操作不能作用于元祖。查 可以

# 1.查
print(colors[1])
print(colors[0:3])
print(colors[0::2])
for item in colors:
    print(item)

# 2.len()
print(len(colors))

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

# 4.+和*
print((1, 2) + (3, 4))
print((1, 2) * 2)

2.2.元祖补充

获取元祖的元

colors1 = ('red', 'greer', 'yellow')
x, y, z = colors1  # 通过多个变量分别获取元祖的元素（变量数=元祖元素个数）
print(x, y, z)

colors1 = ('red', 'greer', 'yellow', 'purple')
first, *midel, last = colors1  # 变量名前加*可以把变量变成列表，获取多个元素
print(first, midel, last)

*midel, last = colors1  # 获取最后一个元素
print(midel, last)

first, *midel = colors1  # 获取第一个元素
print(first, midel)

3.字典

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

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

3.1.声明字典

a.创建一个字典变量

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

dict2 = {'a': 1, 'b': 'abc', 10: 100, ('a', 'b'): '111'}
print(dict2)

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

b.将其它类型转换成字典

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

3.2.字典的增删查改

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

person = {'name': '路飞', 'age': 19, 'face': 90}

print(person['name']),print(person['face'])

字典.get(key)

print(person.get('name'))
print(person.get('aaa'))  # 如果key不存在，返回None

注意：如果key值确定存在，使用[]语法取获取值。不确定key是否存在才使用get方法去获取。
b.增加元素、修改元素
通过key获取字典元素，然后赋值。当key存在时，就是修改；当key不存在时，就是字典添加键值对。

person['height'] = 1.8
print(person)

person['age'] = 20
print(person)

c.删除：删除的是键值对
del 字典[key]：注意：key如果不存在会报错
字典.pop[key]：会返回被删除的键值对对应的值

del person['face']
print(person)

person.pop('height')
print(person)

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

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

students_dict ={'name': '张三', 'stu_id': '23443', 'scores':{'english':66,'math':100}}
keys = students_dict.keys()
print(keys, type(keys))
# 遍历获取每个key
for key in keys:
    print(key)

print(students_dict.values())

print(students_dict.items())

3.4.遍历字典

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

for key in students_dict:
    print(key, students_dict[key])  #取到的是key

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

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

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

"""
声明一个变量，作用是用来存储一个班级的学生信息。其中学生信息有姓名、性别、电话
至少存三个学生信息
"""
class_1805 = []
students = {}
count = int(input('请输入将存储的学生个数：'))
for x in range(count):
    name = input('请输入第%d个学生姓名：' % (x+1))
    sex = input('请输入第%d个学生性别：' % (x+1))
    tel = input('请输入第%d个学生电话：' % (x+1))
    students['name'] = name
    students['sex'] = sex
    students['tel'] = tel
    class_1805.append(students)
print(class_1805)

3.6.其它函数或方法

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

new_dict2 = dict.fromkeys('abc', 1)
print(new_dict2)

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 = {'a': 1, 'b': 2}
dict1.update({'a': 111, 'c': 3})
print(dict1)

4.集合

集合也是一种容器类型的数据类型（序列），数据放在{}中，多个之间使用逗号隔开：{1, 2, 'a'}
集合是无序的（不能通过索引取值），可变（可以增删改），元素不能重复

集合可以进行数学中集合的相关操作：判断是否包含，求交、并、差、补

4.1.声明集合

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

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

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

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

4.2.增删改查

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

for item in set3:
    print(item)

b.增

#集合.add(元素)：在指定的集合中添加指定的元素
set1 = {1, 2, 3}
set1.add(100)
print(set1)

# 集合1.update(集合2)：将集合2中的元素添加到集合1中，自动去重
set1.update({'abc', 12})
print(set1)

c.删

# 集合.remove(元素)：在指定的集合中删除指定的元素
set1.remove(12)
print(set1)

# 集合.pop()：删除是随机删除一个
set1.pop()
print(set1)

.4.3.判断是否包含

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

print({1, 2, 3} >= {1})  # True
print({1, 2, 3} >= {1, 5})  # False

4.4.数学的集合运算

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

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

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

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

4.5.其它方法

"""
clear:清空集合
"""
set1.clear()
print(set1, type(set1))

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