一、复习

1. 列表(list)

容器型数据类型(序列), 可变、有序

2. 元素

任何类型的数据都可以作为列表元素

3. 元素的增删改查（*）

• 1. 查
     查单个元素：列表[下标]
     查部分元素(切片)：列表[开始下标:结束下标:步长], 列表[:], 列表[::-1]
     遍历：直接遍历、遍历下标
• 2. 增
     列表.append(元素)、 列表.insert(下标, 元素)
• 3. 删
     del 列表[下标]
     列表.remove(元素)
     列表.pop() 列表.pop(下标)
• 4. 改
     列表[下标] = 新值

4. +, *, ==, !=, in/not in, len(), list()

5. 列表常用方法

• 1. count
     列表.count(元素) -- 统计列表中指定元素的个数,返回一个整数

nums = [1, 34, 1, 6, 8, 1]
print(nums.count(1))

• 2. extend
     列表.extend(序列) -- 将序列中的元素全部添加到列表中

nums.extend('abc')
print(nums)

nums.extend([100, 'abc', 'name'])
print(nums)

• 3. index
     列表.index(元素) -- 获取指定元素对应的下标（如果元素有多个只取第一个）
     注意：如果元素不存在会报错！

nums = [100, 60, 34, 100]
print(nums.index(34))

• 4. reverse
     列表.reverse() -- 反向列表(直接修改原列表)
     reversed(序列) -- 反向序列，不修改原序列而是产生新的序列(迭代器)

nums = [100, 60, 34, 101]
nums.reverse()
print(nums)

nums = [100, 60, 34, 101]
new_nums = reversed(nums)
print(nums, list(new_nums))

str1 = 'hello'
new_str = reversed(str1)
print(str1, ''.join(list(new_str)), str1[::-1])

# 字符串.join(序列)

• 5. sort
     列表.sort() -- 将列表中的元素升序排序(从小到大)
     列表.sort(reverse=True) -- 将列表中的元素降序排序(从大到小)
     sorted(序列) -- 排序的时候不修改原序列，产生新的序列
     注意: 能够进行排序的列表要求列表中的元素类型一致，并且支持比较运算

# sort
nums = [100, 60, 34, 101]
# nums.sort()
nums.sort(reverse=True)
print(nums)

# sorted
nums = [100, 60, 34, 101]
new_nums = sorted(nums)       # 从小到大排序
print(nums)   # [100, 60, 34, 101]
print(new_nums)   # [34, 60, 100, 101]

new_nums = sorted(nums, reverse=True)     # 从大到小排序
print(new_nums)   # [101, 100, 60, 34]

str2 = 'helloworlda'
new_str = sorted(str2)
print(new_str)    # ['a', 'd', 'e', 'h', 'l', 'l', 'l', 'o', 'o', 'r', 'w']
print(''.join(new_str))   # adehllloorw

• 6. clear
     列表.clear() -- 删除列表中所有的元素(清空列表)

nums = [100, 60, 34, 101]
print(id(nums))
# nums = []
nums.clear()
print(nums, id(nums))

• 7. copy
     列表.copy() -- 相当于列表[:], 将列表中的元素拷贝一份产生一个新的列表（浅拷贝）

nums = [100, 60, 34, 101]
new_nums = nums.copy()
print(nums, new_nums)
print(id(nums), id(new_nums))

new_nums2 = nums     # 一个变量给另一个变量赋值，赋的是地址
new_nums2.insert(0, 1000)
print(new_nums2, nums)

二、作业评讲

1. 已知一个数字列表，将所有元素乘二。

例如：nums = [1, 2, 3, 4] —> nums = [2, 4, 6, 8]

nums = [1, 2, 3, 4]
for index in range(len(nums)):
    nums[index] *= 2
print(nums)

2. 有一个长度是10的列表，数组内有10个人名，要求去掉重复的

例如:names = ['张三', '李四', '大黄', '张三'] -> names = ['张三', '李四', '大黄']

# 方法一:
names = ['张三', '李四', '大黄', '张三']
new_names = []
for name in names:
    if name not in new_names:
        new_names.append(name)
names = new_names
print(names)
"""
names = ['张三', '李四', '大黄', '张三']
new_names = []
name = '张三';  new_names = ['张三']
name = '李四';  new_names = ['张三', '李四']
name = '大黄';  new_names = ['张三', '李四', '大黄']
name = '张三';  new_names = ['张三', '李四', '大黄']
"""

# 方法二:
names = ['张三', '李四', '大黄', '张三', '张三', '李四']
for name in names[:]:
    if names.count(name) > 1:
        names.remove(name)
print(names)

8. 用一个列表来保存一个节目的所有分数，求平均分数(去掉一个最高分，去掉一个最低分，求最后得分)

scores = [97, 98, 99, 94, 93, 60, 108, 60]
avge = (sum(scores) - max(scores) - min(scores)) / (len(scores) - 2)

print(sum([1, 2, 3, 4]))

9. 有两个列表A和B，使用列表C来获取两个列表中公共的元素

A = [1, 'a', 4, 90]
B = ['a', 8, 'j', 1]
C = []
for item in A:
    if item in B:
        C.append(item)

10. 有一个数字列表，获取这个列表中的最大值.(注意: 不能使用max函数)

list1 = [97, 98, 99, 94, 93, 60, 108, 60]
max1 = list1[0]
for item in list1[1:]:
    if item > max1:
        max1 = item
print(max1)

11. 获取列表中出现次数最多的元素

例如：nums = [1, 2, 3,1,4,2,1,3,7,3,3] —> 打印:3

nums = [1, 2, 3, 1, 4, 2, 1, 3, 7, 3, 3, 1, 1]
max_count = 0     # 保存最大个数
num = None    # 最大个数对应的元素, None - 空值(没有)
for item in nums:
    count = nums.count(item)
    if count > max_count:
        max_count = count
        num = item

print('出现次数最多的元素:%d, 次数是:%d' % (num, max_count))

三、元祖

1. 什么是元祖(tuple)

元祖是python提供的容器型数据类型(序列), 不可变(特色), 有序
元祖就是不可变的列表, 一般保存一些不让修改的数据
(元素1, 元素2, 元素3....)

2. 元素

空的元祖

tuple1 = ()
print(tuple1, type(tuple1))

• 1. 元素个数是1的元祖: 如果一个元祖中只有一个元素，这个元素后面必须加逗号！

tuple2 = (10,)
print(tuple2, type(tuple2))

• 2. 元祖数据中小括号可以省略。(多个数据直接用逗号隔开，表示的是一个元祖)

tuple3 = 10, 23, 89, '小明'
print(tuple3, type(tuple3))

3. 获取元素: 和列表一样

tuple2 = ('周一', '周二', '周三', '周四', '周五')
print(tuple2[1])
print(tuple2[2:])
for item in tuple2:
print(item)

• 1. 让变量的个数和元祖中元素的个数保持一致，来一一获取元祖中每个元素的值

point = (100, 50)
x, y = point
print('x:', x, 'y:', y)

a, b, c = 10, 20, 30    # a, b, c = (10, 20, 30)

• 2. 让多个变量同时获取元祖中的元素的时候，可以在一个变量前加将这个变量变成一个列表，来获取不带的变量获取后剩下的数据。（注意，带*的变量只能有一个）

student = ('小明', 18, 89, 68, 89, 90, 'abc')
name, age, *scores = student
print(name, age, scores)   # 小明 18 [89, 68, 89, 90, 100]

name, *scores, age, a = student
print(name, age, scores, a)   # 小明 90 [18, 89, 68, 89] 100

*items, a, b = student
print(items, a, b)    # ['小明', 18, 89, 68, 89] 90 abc

四、字典

1. 什么是字典(dict)

字典是python提供的容器型数据类型(序列), 可变, 无序

2. 字典中的元素

{键值对1, 键值对2, 键值对3,...} - 字典的元素就是键值对
键值对 - 以'键:值'的形式成对出现
键(key) - 要求不可变，唯一 (建议用字符串作为key, 用来对值进行说明和区分的)
值(value) - 任何类型的数据都可以作为值

dict1 = {10: 100, 'name': 100, (1, 2): 100, 'a': 'abc', 'b': True, 'c': [1, 2], 'd': {'a': 2}}
print(dict1)

dict2 = {10: 100, 'name': 100, [1, 2]: 100}  # TypeError: unhashable type: 'list'
dict1 = {10: 100, 'name': 100, {'a': 1}: 100}  # TypeError: unhashable type: 'dict'

dict1 = {10: 100, 'name': 100, (1, 2): 100, 10: 200}
print(dict1)   # {10: 200, 'name': 100, (1, 2): 100}

3. 元素的操作

• 1. 查 - 获取值
  • a. 字典[key] - 获取字典中key对应的value。（如果key不存在会报错！）
  • b. 字典.get(key) - 获取字典中key对应的value。（如果key不存在不报错，结果是None）
    字典.get(key, 默认值) - 获取字典中key对应的value。（如果key不存在不报错，结果是默认值）

dog = {'name': '旺财', 'color': '黄色', 'age': 3, 'type': '土狗'}
print(dog['type'])
# print(dog['gender'])     # KeyError: 'gender'

print(dog.get('name'))
print(dog.get('gender'))     # None
print(dog.get('age', 100))
print(dog.get('gender', '公狗'))   # 公狗

3. 遍历字典

• 1. 直接通过for循环遍历字典的时候，获取到的是所有的key

# 1.直接遍历(只用这个)
for key in dog:
    print(key, dog[key])

# 2.间接遍历
print('===================')
print(dog.values())
for value in dog.values():
    print(value)

print('====================')
print(dog.items())
for key, value in dog.items():
    print(key,  value)

• 2. 增/改
     字典[key] = value - 如果key存在, 修改key对应的值; 如果key不存在，添加键值对

class1 = {'name': 'py1902', 'address': '19楼5教室'}
print(class1)   # {'name': 'py1902', 'address': '19楼5教室'}

# 增
class1['num'] = 50
print(class1)    # {'name': 'py1902', 'address': '19楼5教室', 'num': 50}

# 改
class1['name'] = 'python1902'
print(class1)

• 3. 删
  • a. del 字典[key] - 删除字典中指定key对应的键值对。如果key不存在会报错
  • b. 字典.pop(key) - 取出字典中key对应的值。如果key不存在会报错

class2 = {'name': 'python1902', 'address': '19楼5教室', 'num': 50}
del class2['num']
print(class2)    # {'name': 'python1902', 'address': '19楼5教室'}

name = class2.pop('name')
print(class2, name)

4. 字典相关操作

• 1. 运算符：不支持数学运算，比较运算符只支持比较相等不支持比较大小
     print({'a': 100, 'b': 10} == {'b': 10, 'a': 100}) # True
• 2. in / not in
     key in 字典 - 判断字典中是否存在指定的key

class2 = {'name': 'python1902', 'address': '19楼5教室', 'num': 50}
print('name' in class2)    # True
print(50 not in class2)    # True

• 3. len
     print(len(class2))
• 4. dict
     能转换成字典的数据要求： 数据本身是序列，序列中的每个元素也是长度是2的序列，并且小序列中第一个元素是不可变的

data = [(1, 2), ['a', 23]]
print(dict(data))

dict2 = {'a': 10, 'b': 20}
print(list(dict2))    # ['a', 'b']

5. 相关方法

• 1. clear
     字典.clear() - 清空字典

dict2 = {'a': 10, 'b': 20}
dict2.clear()
print(dict2)

• 2)copy
  字典.copy() - 拷贝字典中的键值对产生一个新的字典

dict2 = {'a': 10, 'b': 20}
dict3 = dict2
dict3['a'] = 100
print(dict2)   # {'a': 100, 'b': 20}

dict2 = {'a': 10, 'b': 20}
dict3 = dict2.copy()
dict3['a'] = 100
print(dict2)   # {'a': 10, 'b': 20}

• 3. fromkeys
     dict.fromkeys(序列, 值) - 创建一个新的字典，字典的key是序列的元素， key对应的value是值

new_dict = dict.fromkeys('hello', 100)
print(new_dict)

• 4. keys, values, items
     字典.keys() - 获取字典中所有的key, 结果是一个序列
     字典.values() - 获取字典中所有的value, 结果是一个序列
     字典.items() - 获取字典中中的key和value， key和value以元祖的形式返回

students = {'name': '张三', 'age': 18, 'stu_id': 'stu001', 'gender': '女'}
print(students.keys())
print(students.values())
print(students.items())

• 5. setdefault
     字典.setdefault(key, value) - 添加键值对(不能修改)

students.setdefault('tel', '15300022783')
print(students)

• 6. update
     字典1.update(字典2) - 使用字典2中的键值对去更新字典1(不存在添加、存在修改)

dict1 = {'a': 1, 'b': 2, 'c': 3}
dict2 = {'b': 200, 'd': 300, 'e': 400}
dict1.update(dict2)
print(dict1)   # {'a': 1, 'b': 200, 'c': 3, 'd': 300, 'e': 400}

六、集合

1. 什么是集合(set)

容器型数据类型(序列), 可变、无序

2. 集合中的元素

{元素1, 元素2, 元素3,...}
元素: 不可变、唯一(自带去重功能)
注意: {}不是能表示空的集合，set() - 空集合

set1 = set()
set2 = {1, 'abc', (1, 3), False, 1, 1, 1}
print(set2)   # {False, 1, (1, 3), 'abc'}

# 集合可以去重
str1 = 'hekskfahhheuwjseaaa'
print(''.join(set(str1)))

list1 = [1, 34, 34, 2, 2]   # hfkaweujs
print(list(set(list1)))   # [1, 34, 2]

3. 元素相关操作

• 1. 查
     集合不能单独获取指定的某一个元素, 只支持遍历

set3 = {12, 34, 56, 2, 7, 88}
for x in set3:
    print(x)

• 2. 增
     集合.add(元素) - 往集合中添加一个元素
     集合.update(序列) - 将序列中的元素添加到集合中(自带去重)

set1 = {1}
print(set1)
set1.add(100)
print(set1)

set1.update('abc')
print(set1)

set1.update({'name': '张三', 'age': 20})
print(set1)

• 3. 删
     集合.remove(元素) - 删除集合中指定的元素。（元素不存在会报错!）

set4 = {1, 'b', 100, 'a', 'age', 'c', 'name'}
set4.remove(100)
print(set4)

• *4. 数学集合运算

set1 = {1, 2, 3, 4, 5, 6}
set2 = {4, 5, 6, 7, 8}
# 1) 并集: |
集合1 | 集合2   -  将两个集合中的元素合并产生新的集合
print(set1 | set2)

# 2) 交集: &  - 求两个集合公共的部分
print(set1 & set2)  # {4, 5, 6}

# 3) 差集/相对补集: 集合1 - 集合2   --- 获取集合1中除了集合2以外的部分
print(set1 - set2)  # {1, 2, 3}
print(set2 - set1)  # {7, 8}

# 4) 对称差分: 集合1^集合2    --- 两个集合除了公共部分以外的部分
print(set1 ^ set2)

# 5) 包含关系
"""
集合1 >= 集合2   -  集合1中是否包含集合2
集合1 <= 集合2   -  集合2中是否包含集合1
"""
print({5, 6, 7, 8, 9} >= {1, 2, 3})    # False
print({5, 6, 7, 8, 9} >= {5, 9})    # True