01-tuple（元祖）

1.什么是元祖（tuple）
python提供的容器型数据类型，不可变并且有序。（元祖不可变的列表）
不可变 - 不支持增删改，支持查
有序 - 每个元素对应一个确定的下标

2.字面量和元素
（元素1，元素2····）
其中的元素可以是任何类型的数据，并且类型可以不一样，同样的元素可以有多个



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

注意：

1.空的元祖:()

tuple1 = ()
print(type(tuple1))

2.只有一个元素的元祖

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

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

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

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

tuple4 = ('昆明', '曲靖', '红河', '文山', '昭通', '普洱', '大理', '丽江')
# 获取单个元素
print(tuple4[2], tuple4[-1])
# 获取部分元素
print(tuple4[0:3])
print(tuple4[::-1])
# 遍历
for city in tuple4:
    print(city)

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

补充：特殊的获取方式

# 1.变量1，变量2···· = 元祖  - -用前面的变量依次获取元祖元素的值。
# （要求前面变量的个数和元祖的个数一致）
point = (100, 200)
x, y = point  # x,y =(100,200) <==> x,y =100,200
print(x, y)

# 2.变量1，*变量2 = 元祖   -- 通过带*的变量获取元祖中剩余的部分;
# 注意：这个结构中带*号的只能有一个，不带*的变量可以有多个

name, *scores = ('小何', 100, 88, 95, 65)
print(name, scores)

name, num, *scores = ('小何', 155, 45, 67, 68, 98)
print(name, num, scores)

补充：*的用法

# 1.取元祖和列表中的数据
nums = (1,2,3)
nums2 = [11,22,33]
print(*nums,*nums2)

#  2.取字典中的元素

4.相关运算（和列表一样）

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

5.排序

sorted（序列） - 对序列中的元素排序，产生一个新的序列（不管是什么序列，排完后
最后都是列表）

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

join的使用

字符串.join（序列 - 将序列中的元素取出，用指定的字符串连接在一起。要求序列中的字符串）

new_str = '*'.join('jjh')
# Node ，sort是空的

---

---

---

02-dict(字典)

1.什么是字典（dict）
python提供的容器型数据类型，可变并且无序
可变 - 支持元素的增删改
无序 - 不支持下标操作

2.字面量和元素
用大括号括起来，里面有多个键值对，每个键值对用逗号隔开。键值对就是字典的元素
{key1：value1,key2:value2......}

键值对  -  键/key：值/value（键值对）;键值对必须成对出现，而且脱离字典单独出现没有意义
键/key  -  必须是不可变的，而且是唯一的。实际一般将字符串作为键
值/value - 可以是任意类型的数据

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

dict1 = {}  # 空字典
print(type(dict1))

dict1 = {'a': 100, 10: 200, (1, 2): 'asd', 'a': 10}
# key重复的只保留最后一个
print(dict1)  # {'a': 10, 10: 200, (1, 2): 'asd'}


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

什么时候使用列表：存储的多个数据是有相同意义的数据（不需要区分），就使用列表。
例如：保存一个班的学生信息，保存所有的价格

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

all_students = [
    {'name': '小何', 'tel': 1234556456, 'age': 18},
    {'name': '小花', 'tel': 1234556456, 'age': 20},
    {'name': '小明', 'tel': 1234556144, 'age': 17},
    {'name': '小红', 'tel': 1234556541, 'age': 19}
]
print(all_students[2])

---

---

---

03-dictItem

字典元素的增删改查

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

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

car = {'color': '黄色', 'type': '跑车', 'price': 50000000}
print(car['color'])
print(car['price'])

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

print(car.get('type'))
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}

# 添加
movie['score'] = 7.9
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 - -提示没有该信息

student = {'name': '张三', 'age': 30, 'score': 80}
new_message = input('请输入要修改的信息：')
if student.get(new_message) == None:   # 不写==后面的值，是True
    print('没有该信息')
else:
    if new_message == 'name':
        new_name = input('请输入新的姓名：')
        student['name'] = new_name
    elif new_message == 'age':
        new_age = int(input('请输入新的年龄：'))
        student['age'] = new_age
    else:
        new_score = input('请输入新的成绩：')
        student['score'] = new_score
    print(student)

---

---

---

04-dictMethod

1.比较运算

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


print({'a': 11, 'b': 22} == {'b': 22, 'a': 11})  # True

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 in dict1)  # False

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

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

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

# 将列表转换成字典
print(dict([(1, 2), ('a', 'b'), [10, 'abc']]))  # {1: 2, 'a': 'b', 10: 'abc'}

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

4.相关方法

# 1.字典.clear() - 清空字典
# 注意：清空容器推荐使用clear操作，而不是重新赋一个空的容器
dict2 = {'name': 'xiaoming', 'color': 'black', 'height': 170}
dict2.clear()
print(dict2, id(dict2))

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

# 2.字典.copy() - 复制字典中的元素，产生一个新的字典
dict2 = {'name': 'xiaoming', 'color': 'black', 'height': 170}
# 直接赋值，修改其中一个元素，会影响另外一个

dict3 = dict2
print(dict3)
dict3['name'] = '小何'
print(dict2)
print(dict3)

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

# 3.字典类型（dict）.fromkeys(序列，值)  -- 以序列中所有的元素作为key，
# 指定的值作为value创建一个新的字典
new_dict = dict.fromkeys('asd', 100)
print(new_dict)  # {'a': 100, 's': 100, 'd': 100}


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

dict2 = {'name': 'xiaoming', 'color': 'black', 'height': 170}
print(dict2.keys(), dict2.values(), dict2.items())
# dict_keys(['name', 'color', 'height'])
#  dict_values(['xiaoming', 'black', 170])
#  dict_items([('name', 'xiaoming'), ('color', 'black'), ('height', 170)])

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

字典.setdefault(key) - 当key不存在的时候，添加键值对key:None
字典.setdefault(key,value) - 当key不存在的时候，添加键值对key:value
注意：这个操作当key存在的时候，不会修改

dict2 = {'name': 'xiaoming', 'color': 'black', 'height': 170}

dict2.setdefault('name2', '剩菜')
dict2.setdefault('sex')
print(dict2)

# 字典1.update(字典2) - 使用字典2中的键值对去更新字典1；
# 如果字典2中的key，字典1中本身存在就是修改，不存在就添加
dict2 = {'name': 'xiaoming', 'color': 'black', 'height': 170}
dict2.update({'height': 180, 'age': 20})
print(dict2)
# {'name': 'xiaoming', 'color': 'black', 'height': 180, 'age': 20}

dict2.update([('a', 100), ('age', 30)])
print(dict2)
# {'name': 'xiaoming', 'color': 'black', 'height': 180, 'age': 30, 'a': 100}

---

---

---

05-set

1.什么是集合（set）

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

2.字面量

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

set1 = {1, 2, 13, 'asd'}
print(set1)

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

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

3.增删改查

# 1.查
# 集合不能单独色获取单个元素，只能一个一个的遍历
set1 = {1, 38, 16, 64, 56}
for item in set1:
    print(item)

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

set1 = {1, 38, 16, 64, 56}
set1.add('abc')
print(set1)

set1.update('asd')
print(set1)

set1.update({'aa': 10, 'bb': 20})
print(set1)

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


set1 = {1, 2, 3, 4, 5, 6}
set1.remove(1)
print(set1)


4.数学运算
交集（&）：获取两个集合公共的元素产生一个新的集合
并集（|）：将两个集合中的元素合并在一起产生一个新的集合
差集（-）：集合1-集合2：去掉集合1中包含集合2的部分，剩下的产生一个新的集合
补集（^）：将两个集合合并在一起去掉公共部分，剩下的部分产生一个新的集合
子集的判断：集合一<集合二 ->判断集合1中是否包含集合2,
           集合二>集合一 ->判断集合2中是否包含集合1。
set1 = {1, 2, 3, 4, 5, 6}
set2 = {4, 5, 6, 7, 8, 9}
# 交集
print(set1 & set2)  # {4, 5, 6}
# 并集
print(set1 | set2)  # {1, 2, 3, 4, 5, 6, 7, 8, 9}
# 差集
print(set1 - set2)  # {1, 2, 3}
# 补集
print(set1 ^ set2)  # {1, 2, 3, 7, 8, 9}
# 子集判断
print({1, 2, 3, 4, 5, 6} > {1, 2, 3})  # True
print({1, 2, 3, 4, 5, 6} > {1, 2, 3, 0})  # False

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