元祖(tuple)

1. 什么是元祖

• python提供的容器型数据类型，不可变并且有序。(元祖就是不可变的列表)
• 不可变 - 不支持增删改，只支持查
• 有序 - 每个元素对应一个确定的下标

2. 字面量和元素
   (元素1,, 元素2, 元素3...)

• 其中的元素可以是任何类型的数据，并且类型可以不一样，同样的元素可以有多个

point = (100, 30)
print(point, type(point))

注意：

• 空的元祖：()

tuple1 = ()
print(type(tuple1))

• 只有一个元素的元祖

tuple2 = (100,)
print(tuple2, type(tuple2))

• 直接将多个元素用逗号隔开，不加小括号表示也是一个元祖

tuple3 = 1, 2, 3
print(tuple3, type(tuple3))

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

tuple4 = ('成都', '达州', '绵阳', '广元')
print(tuple4[1], tuple4[-3])
print(tuple4[1:3])
print(tuple4[::])
for t in tuple4:
    print(t)

for index in range(len(tuple4)):
    print(tuple4[index])

补充：特殊的获取方式

• 变量1, 变量2... = 元祖 -- 用前面的变量依次获取元祖元素的值（要求前面元素的个数与元祖元素的个数一致）

point = (100, 200)
x, y = point
print(x, y)

• 变量1, *变量2 = 元祖 -- 通过带*的变量获取元祖中剩余的部分

注意：在这个结构中，带*的变量只能有一个，不带*的变量可以有多个

name, num, *scores = ('小明', '100', 89, 67)
print(name, num, scores)

补充：*的用法

• 取元祖和列表中的数据

nums = (1, 2, 3)
nums2 = [11, 22, 33]
print(*nums, *nums2)

4. 相关运算(和列表一样)

• +, *
• in / not in
• len(), max(), min(), sum(), tuple()

tuple1 = (1, 2, 3)
tuple2 = ('aa', 'bb')
print(tuple1 + tuple2)
print(tuple2*3)
print('aa' in tuple2)

5. 排序
   sorted(序列) - 对序列中的元素排序，产生一个新的序列

注意：列表.sort() -- 修改原列表中元素的顺序; sorted(列表)

nums = [1, 34, 45, 67, 5, 16]
print(sorted(nums))

nums2 = (1, 34, 45, 67, 5, 16)
new_nums2 = sorted(nums2, reverse=True)
print(new_nums2, tuple(new_nums2), nums2)

new_strs = sorted('dfghgnhnmhjmg')
print(new_strs)

join的使用

• 字符串.join(序列) - 将序列中的元素取出，用指定的字符串连接在一起。要求序列中的元素必须是字符串

new_str = ''.join(['ask', 'df', 'fd'])

print(new_str)

字典（dict）

1. 什么是字典(

• python提供的容器型数据类型，可变并且无序的
• 可变 - 支持元素的增删改
• 无序 - 不支持下标操作

2. 字面量和元素

• 用大括号括起来，里面多个键值对，每个键值对用逗号隔开。键值对就是字典的元素。
• {key1:value1, key2:value2, key3:value3...}
• 键值对：键/key:值/value(键值对); 键值对必须成对出现，而且脱离字典单独出现没有任何意义
• 键/key - 必须是不可变的，而且是唯一的。实际一般将字符串作为键
• 值/value - 可以是任意类型的数据

注意： 字典存储数据，实质是通过值来存储的。key是值对应的标签和获取值的方式

dict1 = {}
print(type(dict1))


dict1 = {'a': 100, 10: 200, (1, 2): 'ac'}
print(dict1)

3. 什么时候使用字典：多个没有相同意义的数据(需要分区)， 就使用字典。例如：保存一个人的不同信息。

• 什么时候使用列表：存储的多个数据是有相同意义的数据(不需要区分)，就使用列表

person = {'name': 'ming', 'age': 18, 'sex': 'boy'}
print(person['name'])

练习：声明一个变量保存一个班的学生信息(4个学生)，每个学生需要保存，姓名，电话和年龄

students = [
    {'name': 'ming', 'tel': 12343, 'age': 18},
    {'name': 'mike', 'tel': 45677, 'age': 22},
    {'name': 'karsa', 'tel': 63377, 'age': 22},
    {'name': 'amzing', 'tel': 54646, 'age': 22}
]
print(students[0])

字典元素的增删改查

1. 查(获取值)
   注意：字典中的键对单独拎出来没有任何意义

• a. 字典[key] - 获取字典中key对应值
  注意：当key不存在的时候，会报KeyError

car = {'color': '黄色', 'type': '跑车', 'price': 5000000}
print(car['color'])
print(car['price'])
# print(car['speed'])   # KeyError: 'speed'

• b.字典.get(key) - 获取字典中key对应值; 当key不存在的时候不会报错，并取到一个默认值None
• 字典.get(key,值1) - 获取字典中key对应值；当key不存在的时候不会报错，并取到指定的值1

print(car.get('type'))
print(car.get('speed'))

print(car.get('color', '红色'))   # 黄色
print(car.get('speed', 0))  # 0

• c.遍历字典
  注意： 直接通过for-in遍历字典取到的是key

dict1 = {'a': 100, 'b': 200, 'c': 300}
# 遍历字典取到的是key(推荐使用)
for key in dict1:
    # key
    print(key, end=' ')
    # value
    print(dict1[key])

# 遍历字典的values(), 获取所有的值
for value in dict1.values():
    print(value)

# 遍历字典的items()，直接获取key和value (不建议使用)
for key, value in dict1.items():
    print(key, value)

2. 增、改

• a.
  字典[key] = 值 - 当key不存在就是添加键值对；当key存在的时候就是修改key对应的值

movie = {'name': '功夫', 'type': '喜剧', 'time': 120}

# 添加
print(movie)
movie['score'] = 9.0
print(movie)

# 修改
movie['type'] = '动作'
print(movie)

3. 删(删除键对值)

• a.
  del 字典[key] - 删除字典中指定的key对应的键值对

• b.
  字典.pop(key) - 取出字典中key对应的值

del movie['time']
print(movie)

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

练习：用一个字典保存一个学生的信息：{'name': '张三', 'age':30, 'score':80}.(输入需要修改的信息，例如输入：name ->修改名字，age ->修改年龄... abc -> 提示'提示没有该信息')

请输入要修改的信息：name
请输入新的名字：李四
{'name': '李四', 'age':30, 'score':80}

请输入要修改的信息：age
请输入新的年龄：18
{'name': '张三', 'age':18, 'score':80}

请输入要修改的信息：abc
没有该信息

student = {'name': '张三', 'age': 30, 'score': 80}
message = input('请输入要修改的信息：')
if student.get(message):
    if message == 'name':
        student['name'] = input('请输入新的名字：')
    elif message == 'age':
        student['age'] = int(input('请输入新的年龄：'))

    else:
        student['score'] = input('请输入新的成绩：')
    print(student)

else:
    print('没有该信息')

字典相关运算

1. 比较运算

• ==, !=
  注意：判断两个字典是否相等，只看键值对是否一样，不管键值对的顺序
• 字典不支持>和<符号

print({'a': 1} == {'aa': 11})
print({'a': 11, 'b': 22} == {'b': 22, 'a': 11})

2. in / not in

• key in 字典 -- 判断字典中指定的key是否存在
• key not in 字典 -- 判断字典中指定的key是否不存在

dict1 = {'a': 1, 'b': 2, 'c': 3}
print('a' in dict1)     # True
print(1 not in dict1)   # False

3. len(), max(), min(), sum()

• dict(数据) - 数据要求是序列，并且序列中的元素都是有两个元素的子序列

# 获取字典中键值对的个数
print(len(dict1))
# 获取字典中key的最大值/最小值
print(max(dict1), min(dict1))

# 将列表转换成字典
print(dict([(1, 2), ['a', 4]]))

dict2 = {'name': 'xiaohua', 'color': 'yellow'}
# 字典转列表/元祖/集合都是将字典中的key取出来作为列表/元祖
print(list(dict2))      # ['name', 'color']

4. 相关方法
   1. 字典.clear() - 清空字典

• 注意：清空容器推荐使用clear操作，而不是重新赋一个空的容器

dict2 = {'name': 'xiaohua', 'color': 'yellow'}
print(id(dict2))
dict2.clear()
print(dict2, id(dict2))

# 只有容器本身不存在的时候，可以使用
dict2 = {}
print(id(dict2))

2. 字典.copy() - 复制字典中的元素，产生一个新的字典

dict2 = {'name': 'xiaohua', 'color': 'yellow'}
# 直接赋值，修改其中一个的元素，会影响另外一个
dict3 = dict2
print(dict3)
dict3['name'] = '小明'
print(dict3)
print(dict2)


dict2 = {'name': 'xiaohua', 'color': 'yellow'}
# 拷贝赋值，会产生新的地址，赋值后相互不影响
dict4 = dict2.copy()
print(dict4)
dict4['name'] = '小明'
print(dict4)
print(dict2)

3. 字典.fromkeys(序列, 值) -- 以序列中所有的元素作为key，指定的值作为value创建一个新的字典

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

new_dict = dict.fromkeys(['name', 'age', 'tel'], 30)
print(new_dict)

4. 字典.keys() - 将字典所有的key取出产生一个新的序列

• 字典.values() - 将所有的value取出产生一个新的序列
• 字典.items() - 将字典所有的key和value作为一个元祖取出产生一个新的序列

dict2 = {'name': 'xiaohua', 'color': 'yellow'}
print(dict2.keys(), dict2.values(), dict2.items())

5. 字典.setdefault(key, value=None)

• 字典.setdefault(key) - 当key不存在的时候，添加键值对key:None
• 字典.setdefault(key, value) - 当key不存在的时候，添加键值对key:value

dict2 = {'name': 'mike', 'color': 'red', 'score': 80}

dict2.setdefault('name', '小明')
dict2.setdefault('sex')
print(dict2)

6. 字典1.update(字典2) - 使用字典2中的键值对去更新字典1，

• 如果字典2中的key，字典1中本身存在就是修改，不存在就添加

dict2.update({'height': 180, 'age': 18})
print(dict2)
dict2.update([('a', 100)])
print(dict2)

集合（set）

1. 什么是集合

• 可变的， 无序的；元素是唯一并且不可变

2. 字面量

• {元素1， 元素2， 元素3...}

set1 = {1, 23, 'abc'}
print(set1)

# set1 = {1, 23, 'abc', [1, 2]}   # TypeError: unhashable type: 'list'

# 表示空集合
set2 = set()
print(type(set2))

set3 = {1, 2, 1, 2, 2}
print(set3)

# 集合自带去重功能
list1 = [1, 1, 2, 1, 3, 2]
list1 = list(set(list1))
print(list1)

3. 增删改查

• 查

# 集合不能单独的获取单个元素，只能一个一个的遍历
for item in set1:
    print(item)

• 增
  a.集合.add(元素) - 在集合中添加指定的元素
  b.集合.update(序列) - 将序列中的元素添加到元素中

set1 = {1, 38, 98, 8}
set1.add('girl')
print(set1)


set1 = {1, 38, 98, 8}
set1.update('boy')
print(set1)

set1 = {1, 38, 98, 8}
set1.update({'a': 1, 'dd': 'da'})
print(set1)

• 删
  集合.remove(元素) - 删除集合中指定的元素

set1 = {1, 38, 98, 8}
set1.remove(8)
print(set1)

4. 数学集合运算

• 交集(&)：获取两个集合公共的元素产生一个新的集合
• 并集(|): 将两个集合的元素合在一起产生一个新的集合
• 差集(-): 集合1 - 集合2: 去掉集合1中包含集合2的元素
• 补集(^): 将两个几何合并在一起，去掉公共的部分，剩下的部分产生一个新的集合
• 子集的判断：集合1>集合2 -> 判断集合1中是否包含集合2， 集合1<集合2 - 判断集合1中是否包含集合2

set1 = {1, 2, 3, 4, 5, 6}
set2 = {4, 5, 6, 7, 8}
# 交集
print(set1 & set2)  # {4, 5, 6}
# 并集
print(set1 | set2)  # {1, 2, 3, 4, 5, 6, 7, 8}
# 差集
print(set1 - set2)  # {1, 2, 3}
# 补集
print(set1 ^ set2)  # {1, 2, 3, 7, 8}

print({1, 2, 3, 9, 18} > {1, 2, 3})   # True
print({1, 2, 3, 9, 18} > {1, 2, 3, 0})   # False
print({1, 2, 3} > {1, 2, 3})   # False
print({1, 2, 3} >= {1, 2, 3})   # True