2019-01-03day8学习总结

1. 什么是元祖（tuple）

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

2. 字面量和元素

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

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

注意：
a. 空的元祖()

tuple1 = ()
print(type(tuple1))

b. 只有一个元素的元祖，必须加一个逗号

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

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

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

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

tuple4 = ('成都','达州','绵阳','南充','广元')

获取单个元素

print(tuple4[1],tuple4[-1])

获取部分

print(tuple4[0:3])

遍历

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

补充：特殊的获取方式
a. 变量1，变量2...=元祖 —— 用前面的变量依次获取元祖元素的值。（要求前面变量的个数和元祖元素的个数一致）

point = (100, 200)
x, y = point  # x,y=(100,200) <——> x,y=100,200
print(x,y)

b. 变量1，变量2 = 元祖 <——> 通过带的变量获取元祖中剩余的部分
注意：这个结构中带的变量只能有一个，不带的变量可以有多个

name, *scores = ('小明', 100, 89, 67, 99)
print(name, scores, type(name), type(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)

补充：*的用法
a. 取元祖和列表中的数据

nums = (1, 2, 3)
print(*nums)
nums1 = [1, 2, 3]
print(*nums1)

b. 取字典中的元素

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

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

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

print('aa'in tuple2)

5. 排序

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

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

nums = (1, 34, 89, 9)
new_nums = sorted(nums, reverse=True)
print(new_nums)

new_strs=sorted('jsisjlfhrehbfjdan')
print(new_strs)

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

new_str=''.join(['a','b','c'])
print(new_str,type(new_str))

list1 = [1, 456, 89, 76]
new_list = list1.sort()    # None
print(list1, new_list)

6. 什么是字典（dict）

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

7. 字面量和元素

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

注意：字典存储数据，实际是通过值来存储的。key是值对应的标签和获取值的方式
如果遍历字典后对字典的操作会改变字典的长度，那么就不要直接遍历字典，而且遍历字典的copy

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

空字典

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

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

例如：保存一个人的不同信息，一辆车的不同信息，
什么时候使用列表：存储的多个数据是有相同意义的数据（不需要区分），就使用列表。
例如：保存一个班的学生信息，保存所有人的姓名
练习:声明一个变量保存一个班的学生信息（4个学生），每个学生需要保存姓名、电话和年龄

all_students=[
    {'name':'小明','tel':'111','age':'18'},
    {'name':'小红', 'tel': '222', 'age': '19'},
    {'name': '小黄', 'tel': '333', 'age': '20'},
    {'name': '小蓝', 'tel': '444', 'age': '18'}
]
print(all_students[0])

字典元素的增删改查

9. 查（获取值）

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

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',0))

c. 遍历字典

dict1 = {'a': 100, 'b': 200, 'c': 300}

遍历字典取到的是key(建议使用）

for key in dict1:
    # key
    print(key, end=' ')
    # value
    print(dict1[key])

遍历字典中的value(),获取所有的值（不建议使用）

for value in dict1.values():
   print(value)

遍历字典中items(),直接获取key和value(不建议使用)

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

10. 增、改

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

movie = {'name':'喜羊羊与灰太狼','type':'卡通','time':120}

添加

movie['score'] = 7.9
print(movie)

修改

movie['type'] = '搞笑'
print(movie)

11. 删（删除键值对）

a.
del 字典[key] - 删除字典中指定的key对应的键值对
b.
字典.pop(key) - 取出字典中指定的key对应的键值对

del movie['time']
print(movie)
movie.pop('type')
name = movie.pop('name')
print(movie, name)

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

student = {'name': '小花', 'age': 18, 'score': 80}
message = input('请输入您想修改的信息')
if student.get(message):
    print('可以修改')
    if message == 'name':
        new_name = input('请输入新的名字')
        student['name'] = new_name
    elif message == 'age':
        new_age = input('请输入新的年龄')
        student['age'] = new_age
    elif message == 'score':
        new_score = input('请输入新的成绩')
        student['score'] =new_score
    print(student)
else:
    print('没有该信息')

12. 比较运算

==、!=
注意：判断俩个字典是否相等，只看键值对是否一样，不管键值对的顺序
字典是不支持比较大小的

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

13. in/not in

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

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

14. len()、min()、max()

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

# 获取字典中键值对的个数
print(len(dict1))
# 获取字典中key的最大值
print(max(dict1))
# 获取字典中key的最小值
print(min(dict1))
# 将列表转换成字典
print(dict([(1,2),('a','b'),[10,'abc']]))

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

15. 相关方法

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

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

只有本身不存在的时候可以使用

dict2={}
print(id(dict2))

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

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

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

拷贝赋值，会产生新的地址，赋值后相互不影响

dict4 = dict2.copy()
print(dict4)
del dict4['color']
print(dict4)
print(dict2)

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

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

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

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

dict2 = {'name':'xiaohua','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':'xiaohua','color':'black','height':170}
dict2.setdefault('name','小胡')
dict2.setdefault('sex')
print(dict2)

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

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

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

16. 什么是集合（set）

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

17. 字面量

{元素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, 2, 1, 2, 2]
list1 = list(set(list1))
print(list1)

18. 增删改查

a. 查
集合不能单独的获取单个元素，只能一个一个的遍历

for item in set1:
    print(item)

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

set1 = {1, 38, 90, 8}
set1.add('abc')
print(set1)

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

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

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

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

4. 数学集合运算
   交集（&）：获取两个集合公共的部分产生新的集合
   并集（|）：将两个集合中的元素合并在一起产生一个新的集合
   差集（-）：集合1 - 集合2 ：去掉集合1中包含集合2的部分，剩下的部分产生一个新的集合
   补集（^）：将两个集合合并在一起，去掉公共部分，剩下的部分产生一个新的集合
   子集的判断()：集合1>集合2——>判断集合1是否包含集合2
   集合1<集合2——>判断集合2是否包含集合1

set1 = {1, 2, 3, 4, 5, 6}
set2 = {4, 5, 6, 7, 8}

交集

print(set1 & set2)

并集

print(set1 | set2)

差集

print(set1 - set2)

补集

print(set1 ^ set2)

print({1, 2, 3, 4, 5, 6} > {1, 2, 3})          # False
print({1, 2, 3, 4, 5, 6} > {1, 2, 3, 0})       # True