01tuple

简单总结：

tuple1 = () # 空元祖
tuple1 = (1, 2, 'ab', 5) # 字面量和元素
x, y, z, a = tuple1 # 获取元素
x, y = tuple1 # 获取元素
x, y, z = tuple # 获取元素
list1 = [1, 2, 3, 'ab', 3]
print(tuple) # 一个一个的取元素
print(list1) # 一个一个的取元素
new_list = sorted(tuple1) # 对原序列进行排序，返回一个新列表
字符串.join(seq) # 将序列中的元素取出，用指定的字符串连接，序列中的元素必须是字符串
''.join(seq) # 针对sorted(序列)返回列表的用法，实现最终返回无间隔的字符串

详细总结：

1. 什么是元组（Tuple）

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

2. 字面量和元素

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

point = (100, 30)
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[1], 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, 89, 67,99)
print(name, scores)

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

*info, num1, num2 = ('小明', 100, 89, 67,99)
print(info, num1, num2)

info, *nums, num1 = ('小明', 100, 89, 67,99)
print(nums)

补充：*的用法

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

# 2. 取字典中的元素,  脱离函数无用
# dict1 = {'a':1, 'b':2}
# print(**dict1)

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

+， *
in / not in 
len(), max(), min(), sum(), tuple()
"""
tuple1 = (1, 2, 3)
tuple2 = ('aa', 'bb')
print(tuple1 + tuple2)
print(tuple1 * 3)

print('aa' in tuple2)

5. 排序

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

注意： 列表.sort（） -- 修改原列表中元素的顺序； sorted（列表） -- 产生一个新的列表

nums = (1, 34, 554, 34,23)
new_nums = sorted(nums, reverse = True)
print(new_nums, tuple(new_nums), nums)

new_strs = sorted('dsgvcdgavnk')
print(new_strs, ''.join(new_strs))

补充：join的使用

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

new_str = ''.join(('adsf', 'd', 'ggd'))
print(new_str, type(new_str))

02 dict

1. 什么是字典（dict）

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

2. 字面量和元素

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

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

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

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

dict1 = {'a': 100, 10: 200, (1, 2): 'abc', 'a': 111, 'a': [1, 11, 111]}
print(dict1)   # {'a': [1, 11, 111], 10: 200, (1, 2): 'abc'} ， key唯一

# dict2 = {[1, 2]: 120}  #TypeError: unhashable type: 'list'

3. 什么时候使用字典：多个没有相同意义的数据（需要区分），就使用字典。

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

person = ['xiaohua', 18, 'girl', 160, 90]
print(person[0])

person = {'name': 'xiaohua', 'age': 18, 'sex': 'girl', 'height': 160, 'weight': 90, 'scores': 89}
print(person['age'])

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

all_student = [
    {'name': 'xiaoming', 'tel': '3467452', 'age': 21},
    {'name': 'xiaohong', 'tel': '84646362', 'age': 23},
    {'name': 'xiaoli', 'tel': '676562', 'age': 24},
    {'name': 'xiaohua', 'tel': '325654', 'age': 22}
]
print(all_student[0])

03 dict item

字典的增删改查

1. 查（获取值）

注意：字典中的键值对单独拎出来没有任何意义

a. 字典[key] - 获取字典中key对应的值

注意：当key不存在的时候，会报KeyError
"""
car = {'color': '黄色', 'type': '跑车', 'price': 500000}
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', 100))       # 100
print(car)

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 -> 提示'没有该信息'

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

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

student = {'name': '张三', 'age': 30, 'score': 80}
message = input('请输入要修改的信息:')
if message in student:
    value = input('请输入新的值：')
    student[message] = value
    print(student)
else:
    print('没有该信息！')

# 老师的解，我的改进：
student = {'name': '张三', 'age': 30, 'score': 80}
message = input('请输入要修改的信息:')
if student.get(message):
    new_value = input('请输入新的值：')
    student[message] = new_value
    print(student)
else:
    print('没有该信息！')

# 老师的解：
student = {'name': '张三', 'age': 30, 'score': 80}
message = input('请输入要修改的信息:')
if student.get(message):
    if message == 'name':
        new_name = input('请输入新的名字：')
        student[message] = new_name
    elif message == 'age':
        new_age = input('请输入新的年龄')
        student[message] = new_age
    else:
        new_score = input('请输入新的分数：')
        student['score'] = new_score
    print(student)
else:
    print('没有该信息！')

04 dict Method

简单总结：

"""
dict1 = {} # 空字典
dict1 = {key1: value, key2: value ...} # 字典字面量和元素

dict1[key] # 查找字典
dict1.get(key) # 查找字典，如果key不存在不会报错，存在则默认返回None
dict1.get(key, value) # 查找字典，如果key不存在不会报错，存在则返回value

dict1[key] = value # 如果key存在，修改key的值，如果key不存在，增加键值对key：value

del dict1[key] # 删除键值对
dict1.pop(key) # 取出键值对

dict.clear() # 清空字典
dict.copy() # 复制字典
dict.fromkeys(seq, value) # 以序列中的元素作为key，每个key对应的值都为value，产生一个新的字典
dict.keys() # 获取字典中所有的key
dict.values() # 获取字典中所有的value
dict.items() # 获取字典中所有的key：value
dict.setdefault(key, value) # 只添加不修改。当key不存在，添加key：value，value默认值是None。当key存在，不做修改
dict1.update(dict2) # 更新字典。将字典2增加到字典1中。如果字典2中的key在字典1中存在，就修改值，不存在就添加键值对

"""

详细总结:

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(), sum(), dict()

字典求和意义不大

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

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

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

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

4. 相关方法

1. 字典.clear() - 清空字典
   注意：清空容器推荐使用clear操作，而不是重新赋一个空的容器

dict2 = {'name': 'xiaohong', 'color': 'black', 'height': 170}
dict2.clear()
print(dict2)
print(id(dict2))

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

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

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

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

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

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

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

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

dict2 = {'name': 'xiaohong', 'color': 'black', 'height': 170}
print(dict2.keys(), dict2.values(), dict2.items())

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

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

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

dict2.setdefault('name', '小胡')
print(dict2)

dict2.setdefault('sex')
print(dict2)

dict2.setdefault('name2', '小胡')
print(dict2)

6. 字典.update(字典2) - 使用字典2中的键值对,去更新字典1；
   如果字典2中的key，字典1中本身存在就是修改，不存在就添加

dict2 = {'name': 'xiaohong', 'color': 'black', 'height': 170}
dict2.update({'height': 190, 'age': 18})
print(dict2)

dict2.update([('a', 100), ('age', 30)])
print(dict2)