Python学习笔记task5-字典，集合，序列

1. 作业

1.1 字典作业

1，

#作业
dic = {
    'python': 95,
    'java': 99,
    'c': 100
    }
'''
字典的长度是多少
请修改'java' 这个key对应的value值为98
删除 c 这个key
增加一个key-value对，key值为 php, value是90
获取所有的key值，存储在列表里
获取所有的value值，存储在列表里
判断 javascript 是否在字典中
获得字典里所有value 的和
获取字典里最大的value
获取字典里最小的value
字典 dic1 = {'php': 97}， 将dic1的数据更新到dic中
'''
len(dic)#3
dic['java'] = 98#{'python': 95, 'java': 98, 'c': 100}
del dic['c']#{'python': 95, 'java': 98}
dic['php'] = 90#{'python': 95, 'java': 98, 'php': 90}
dic.keys()#dict_keys(['python', 'java', 'php'])
dic.values()#dict_values([95, 98, 90])
print(dic.get('javascript'))#None

sum = 0
for value in dic.values():
    sum += value
print(sum)#283

lst  = list(dic.values())#[[95, 98, 90]]
lst.sort()
maxDic = lst[-1]#98
minDic = lst[0]#90

dic1 = {'php': 97}
dic.update(dic1)
dic#{'python': 95, 'java': 98, 'php': 97}

2，这个作业主要考点在于如何蟹盖字典中的值，一定要注意字典的值的修改，必须是通过键的方式来改变值。

data = {
        'python': {'上学期': '90', '下学期': '95'},
        'c++': ['95', '96', '97'],
        'java': [{'月考':'90', '期中考试': '94', '期末考试': '98'}]
        }
for key,value in data.items():
    if type(value) == list:
        length1 = len(value)
        for i in range(length1):
            if type(value[i]) == str:
                data[key][i] = int(data[key][i])
            elif type(value[i]) == dict:
                for key1,value1 in value[i].items():
                    if type(value1) == str:
                        value[i][key1] = int(value1)
    if type(value) == dict:
        for key2,value2 in value.items():
            if type(value2) == str:
                value[key2] = int(value2)                 
print(data)  
#{'python': {'上学期': 90, '下学期': 95}, 'c++': [95, 96, 97], 'java': [{'月考': 90, '期中考试': 94, '期末考试': 98}]}                            

1.2 集合作业

'''怎么表示只包含⼀个数字1的元组。
创建一个空集合，增加 {‘x’,‘y’,‘z’} 三个元素。
列表['A', 'B', 'A', 'B']去重。
求两个集合{6, 7, 8}，{7, 8, 9}中不重复的元素（差集指的是两个集合交集外的部分）。
求{'A', 'B', 'C'}中元素在 {'B', 'C', 'D'}中出现的次数。
'''
a = (1,)
type(a)#tuple

set1 = set()
set1.add('x')
set1.add('y')
set1.add('z')
set1#{'x', 'y', 'z'}

set(['A', 'B', 'A', 'B'])#{'A', 'B'}

a = {6,7,8}
b = {7,8,9}
a.symmetric_difference_update(b)
a#{6, 9}

c = {'A', 'B', 'C'}
d = {'B', 'C', 'D'}
len(c&d)#2

1.3 序列作业

'''怎么找出序列中的最⼤、⼩值？
sort() 和 sorted() 区别
怎么快速求 1 到 100 所有整数相加之和？
求列表 [2,3,4,5] 中每个元素的立方根。
将[‘x’,‘y’,‘z’] 和 [1,2,3] 转成 [(‘x’,1),(‘y’,2),(‘z’,3)] 的形式。'''

#1，max()找出序列中的最⼤值，min()找出序列中的最小值
#2，a,sort()是一个方法，sorted()是一个函数; b,sort()没有返回值，是直接对原来的对象进行修改，sorted()有返回值，不改变原来的对象
sum(range(101))#5050
x = [i**(1/3) for i in [2,3,4,5]]
x#[1.2599210498948732,
 #1.4422495703074083,
 #1.5874010519681994,
 #1.7099759466766968]
a = ['x','y','z']
b = [1,2,3]
zipped = list(zip(a,b))
zipped#[('x', 1), ('y', 2), ('z', 3)]

2. 字典

2.1 字典的定义

字典的定义：字典是无序的键:值（key:value）对集合，键必须是互不相同的（在同一个字典之内）。键和值是单射关系，一个键就是一个值。字典是Python唯一一个映射类型的，形式是dict = {key1:value1,key2:value2,…}用大括号括起来，逗号隔开。

dict1 = {'a':1,'b':1}#{'a': 1, 'b': 1}
dict1 = {'a':1,'a':2}#{'a': 2}

2.2 字典的常见操作1：增删改查

2.2.1 查找

与列表等不同，字典通过用关键字来索引，关键字是地址不可变类型的，如数值，字符串，元组。一般用数值和字符串，要查找或者更改字典里面的内容，只能通过键来寻找值，通过键的名字来查找对应的值,因为它是无序的，所以不能用序列索引。

Info = {'name':1,'age':2}
Info['name']#1
Info[0][0]#KeyError: 0

这样直接找值，如果查找的键不存在则会报错，在不确定字典中是否存在某个键时，可以用get方法，Info.get(‘key’,xx)，后面的是如果不存在时返回该键的值,但是不会在原字典中添加进去。没有则默认为None

print(Info.get('id'))#None
id = Info.get('id',123)
id#123
Info#{'name': 1, 'age': 2}

2.2.2 改

直接找到key，给定一个新的值

Info['name'] = 'xiaoming'
Info#{'name': 'xiaoming', 'age': 2}

2.2.3 添加

直接在变量名后面加上Key的名字，再赋予这个键Key的值，因为在使用变量名[‘键’] = 数据(值)时，如果这个键在字典中不存在，那么就会新增这个元素，注意与get方法的区别。

Info['sex'] = 'male'
Info#{'name': 'xiaoming', 'age': 2, 'sex': 'male'}

2.2.4 删除

del函数，形式为：del 变量名[‘key’]，后面如果是整个变量，则整个变量被删

del Info['sex']
Info#{'name': 'xiaoming', 'age': 2},
# clear 方法，整个删除，清空字典
Info.clear()
Info#{}

2.3 字典的常见操作2：

1, dict.len()测量字典中键值对的个数

myInfo = {'name':'xiaoming','age':11,'score':90}
len(myInfo)#3

2, dict.keys()返回字典中所有的键，dict.values()返回字典中所有的值，dict.items()返回一个包含(键，值)元组的列表

myInfo.keys()#dict_keys(['name', 'age', 'score'])
myInfo.values()#dict_values(['xiaoming', 11, 90])
myInfo.items()#[('name', 'xiaoming'), ('age', 11), ('score', 90)]外面是列表，里面的元素是元组

2.4 字典的遍历：

字典的遍历，与列表等一样，用for或者让while循环遍历
但是由于字典有三种元素，因此字典的遍历分为键的遍历，值的遍历，键值对的遍历。
由于dict.items()，取出来的一个元组中有键和值两个变量，因此可以用两个循环变量去取值。

myInfo = {'name':'xiaoming','age':11,'score':90}
for temp in myInfo.keys():
    print(temp)
#name
#age
#score
for temp in myInfo.values():
    print(temp)
#xiaoming
#11
#90
for temp in myInfo.items():
    print(temp)
#('name', 'xiaoming'),注意这样遍历出来的键值对是元组的形式
#('age', 11)
#('score', 90)
for temp in myInfo.items():
    print('%s:%s'%(temp[0],temp[1]))
#name:xiaoming
#age:11
#score:90
for key,value in myInfo.items():
#这里由于myInfo.items()，取出来的一个元组中有键和值两个变量，因此可以用两个循环变量去取值
    print(key)
    print(value)
'''
name
xiaoming
age
11
score
90
'''

练习，如何实现带下标索引的遍历
chars = ['a','b','c','d']
i = 0
for char in chars:
    print('%d,%s'%(i,char))
    i += 1
#0,a
#1,b
#2,c
#3,d
#方法二：
#用enumerate(),这是一个类,把下标和元素当成一对了
chars = ['a','b','c','d']
for i ,char in enumerate(chars):
    print (i,char)
#0 a
#1 b
#2 c
#3 d

2.5 列表，元组，字符串，字典公用的方法

1，运算符
合并：’+’,如[1,2]+[3,4]结果为[1,2,3,4],支持的数据类型有：字符串，列表，元组,注意字典没有合并
复制：’*’,如’a’*3结果为’aaa’,支持的数据类型有：字符串，列表，元组，字典不行
判断元素是否存在：in与not in ,如3in[1,2,3],结果为True,支持的数据类型有：字符串,列表,元组,字典
python内置函数
1,cmp(temp1,temp2)比较两个值是否相同，相同返回0，不同返回1或者-1
2，len(item)计算容器中元素的个数
3，max(item)返回回容器中元素最大的数
4，min(item)返回回容器中元素最小的数
5，del(item)删除变量

3 . 集合

1，集合与字典类似，都是无序的Key集合，但不储存value，且集合中的元素不可重复，理解时可稍微按高中集合理解。。。
2，key都是不可变类型

3.1 集合的创建

1，先创建空对象再加入元素，再用add方法添加元素。注意创建空集合的时候只能使用s = set()，因为s = {}创建的是空字典。

s = set()
s.add('abc')
s.add(1)
s#{1, 'abc'}

2,直接把一堆元素用花括号括起来{元素1, 元素2, …, 元素n}。注意重复元素在set中会被自动被过滤，不会报错。

aset = {'a','b','c','a'}
aset#{'a', 'b', 'c'}

3, 使用set(value)工厂函数，把列表、元组、字符串转换成集合
虽然可以将列表元组等转换成集合，但是由于集合中的Key为不可变类型，因此转换前的列表元组中的元素也要为不可变类型，
注意：单独输入字符串类型，会把字符串拆成单个字符

a = set('abcdeab')
a#{'a', 'b', 'c', 'd', 'e'}可以给字符串去重
#单独输入字符串类型，会把字符串拆成单个字符
#b = set(['apple',{'name':'xiaoming','age':18},(1,2,2)])
#报错，要为虽然可以将列表转换成集合，但是由于集合中的Key为不可变类型，因此转换前的列表中的元素也要不可变类型，
b = set([(1,2,2),'apple',10,'aa'])
b#{{(1, 2, 2), 10, 'aa', 'apple'}

3.2 集合的内置操作:删，添，查

3.2.1 删

1，set.remove(item) 用于移除集合中的指定元素。如果元素不存在，则会报错。

fruit = {'apple','banana','cherry'}
fruit.remove('apple')
fruit#{'banana', 'cherry'}

2，set.discard(value) 也可用于移除指定的集合元素，但是元素不存在，不会报错

fruit.discard('apple')
fruit#{'banana', 'cherry'}

3，set.pop() 用于随机移除一个元素(因为集合是无序的)

fruit.pop()#输出的是删除的结果，{'banana'}
fruit#'cherry'

3.2.2 添

用set.add(value),上面已经操作过

3.2.3 改

set.update(set)用于修改当前集合，可以添加新的元素或集合到当前集合中，会过滤重复的元素

x = {'a','b','c'}
y = {'a','e','d','f'}
x.update(y)#{'a', 'b', 'c', 'd', 'e', 'f'}
x#{'a', 'b', 'c', 'd', 'e', 'f'}
y.update(['num'])
y#{'a', 'd', 'e', 'f', 'num'}

3.2.4 查

由于集合是无序的，因此不能进行索引，只能通过in,not in 来判断元素是否存在

3.2.5 遍历

以用for或while对集合遍历，但是注意的是集合是无序的，因此无法得知遍历的先后顺序

b = set([(1,19),10,'aa'])
for i in b:
    print(i)
#10
#(1, 19)
#aa

3.3 集合意义上的操作

3.3.1 交集

1，set.intersection(set1, set2) 返回两个集合的交集,格式也可为set1.intersection(set2)
2，set1 & set2 也可返回两个集合的交集。
3，set1.intersection_update(set2) 交集，在原始的集合上移除不重叠的元素，意思是不返回值，只是更改了原来的set1

b = set([(1,2,2),'apple',10,'aa'])
c = {'apple'}
set.intersection(b,c)#{'apple'}
b&c#{'apple'}
a1 = set('abracadabra')
b1 = set('alacazam')
a1.intersection_update(b1)
print(a1)  # {'a', 'c'}

3.3.2 并集

1，set.union(set1, set2) 返回两个集合的并集
2，set1 | set2 返回两个集合的并集

b = set([(1,2,2),'apple',10,'aa'])
d = {'bb','apple'}
b.union(d)#{(1, 2, 2), 10, 'aa', 'apple', 'bb'}
b|d##{(1, 2, 2), 10, 'aa', 'apple', 'bb'}

3.3.3 集合的差集

1，set1.difference(set2) 返回集合的差集
2，set1 - set2 返回集合的差集
3，set1.difference_update(set2) 集合的差集，直接在原来set1中移除元素，没有返回值。

b = set([(1,2,2),'apple',10,'aa'])
d = {'bb','apple'}
b.difference(d)#{(1, 2, 2), 10, 'aa'}

b-d #{(1, 2, 2), 10, 'aa'}
b.difference_update(d)
b##{(1, 2, 2), 10, 'aa'}

3.3.4 集合的异或即a-(a&b)

1，set1.symmetric_difference(set2)返回集合的异或。
2，set1 ^ set2 返回集合的异或。
3，set1.symmetric_difference_update(set2)移除set1中在set2相同的元素，
并将set2中与set1不同的元素插入到set1中。即(a-(a&b))|(b-(a&b)),注意这个也是直接修改set1的值，不返回值

b = set([(1,2,2),'apple',10,'aa'])
d = {'bb','apple'}
b.symmetric_difference(d)#{(1, 2, 2), 10, 'aa', 'bb'}

b^d#{(1, 2, 2), 10, 'aa', 'bb'}

b.symmetric_difference_update(d)
b#{(1, 2, 2), 10, 'aa', 'bb'}

3.3.5 集合的包含关系

1，set1.issubset(set2)判断set1是不是被set2包含，如果是则返回 True，否则返回 False。
2，set1 <= set2 判断set1是不是被set2包含，如果是则返回 True，否则返回 False。

b = set([(1,2,2),'apple',10,'aa'])
c = {'apple'}
b.issubset(c)#False
c.issubset(b)#True,小的在前，大的在后为真

b <= c#False
c <= b#True

3，set1.issuperset(set2)用于判断set1是不是包含set2，如果是则返回 True，否则返回 False
4，set1 >= set2 判断set1是不是包含set2，如果是则返回 True，否则返回 False

b.issuperset(c)#True,大的在前，小的在后为真
c.issuperset(b)#False

b >= c#True
c >= b#False

5，set1.isdisjoint(set2) 用于判断两个集合是不是不相交，如果是返回 True，否则返回 False。

b.isdisjoint(c)#False相交时为假

4. 针对序列的内置函数

在 Python 中，序列类型包括字符串、列表、元组、集合和字典，这些序列支持一些通用的操作，但比较特殊的是，集合和字典由于是无序的，因此不支持索引、切片、相加和相乘操作。

4.1 一些通用的函数：

1，list(sub) 把一个可迭代对象转换为列表。sub可以是序列类型中任何类型。转换过程就是把原来的对象的固定外面的限制如元组的小括号，字典的大括号等都变成中括号，然后把里面的每一个元素用逗号分开，注意字典中只显示键。

b = 'I Love LsgoGroup'
b = list(b)
print(b)  
# ['I', ' ', 'L', 'o', 'v', 'e', ' ', 'L', 's', 'g', 'o', 'G', 'r', 'o', 'u', 'p']
a = {'月考': 90, '期中考试': 94, '期末考试': 98}
list(a)
#['月考', '期中考试', '期末考试']

2，tuple(sub) 把一个可迭代对象转换为元组。sub可以是序列类型中任何类型。tuple()与list()类似，只是把中括号变为小括号。
3，str(obj) 把obj对象转换为字符串，这里的转换是把原来的对象直接在外面加上了一对双引号变成字符串，双引号中的任何字符都是字符串中的元素。

a = (1,2,'a')
b = str(a)#"(1, 2, 'a')"，是把原来的元组直接在外面加上了一对双引号变成字符串，因此之前元组的括号逗号都是字符
len(b)#11,这里注意把逗号中间加了个空格，因此长度变为11
b[3]#' '

4，eval(sub)相当于把字符串外面的引号去掉，与str(obj)过程相反。

a = (1,2,'a')
b = str(a)#"(1, 2, 'a')"
eval(b)#(1,2,'a')

5，len(s) 返回对象（字符、列表、元组等）长度或元素个数。前面都介绍过具体用法，这里不再详细说明
6，max(sub)返回序列或者参数集合中的最大值。注意这里的序列中的元素必须是同类型能比较大小的，只有同为字符，或者同为数值才能进行比较，否则会报错。

b = [(1,2,2),'apple',10,'aa']
max(b)#TypeError: '>' not supported between instances of 'str' and 'tuple'
b = ['a','p']
max(b)#'p'
b = '123abc'
max(b)#'c'

7，min(sub)返回序列或参数集合中的最小值，与max()用法一致
8，sum(iterable[, start=0]) 返回序列iterable与可选参数start的总和，start不输入则默认为0。元素只能是数值

print(sum([1, 3, 5, 7, 9]))  # 25
print(sum([1, 3, 5, 7, 9], 10))  # 35
print(sum((1, 3, 5, 7, 9)))  # 25
print(sum((1, 3, 5, 7, 9), 20))  # 45

9，sorted(iterable, key=None, reverse=False) 对所有可迭代的对象进行排序操作。
注意点:
a, key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
b, reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
c, 会返回值。
与sort()的区别：
a, sort()是一个方法，sorted()是一个函数;
b, sort()没有返回值，是直接对原来的对象进行修改，sorted()有返回值，不改变原来的对象。
10，reversed(seq) 函数返回一个反转的迭代器，有返回值，
与reverse的区别：
a, reverse()是一个方法，reversed()是一个函数;
b, reverse()没有返回值，是直接对原来的对象进行修改，reversed()有返回值，不改变原来的对象。

s = 'lsgogroup'
x = reversed(s)
print(type(x))  # <class 'reversed'>
print(x)  # <reversed object at 0x000002507E8EC2C8>
print(list(x))
# ['p', 'u', 'o', 'r', 'g', 'o', 'g', 's', 'l']

t = ('l', 's', 'g', 'o', 'g', 'r', 'o', 'u', 'p')
print(list(reversed(t)))
# ['p', 'u', 'o', 'r', 'g', 'o', 'g', 's', 'l']

r = range(5, 9)
print(list(reversed(r)))
# [8, 7, 6, 5]

x = [-8, 99, 3, 7, 83]
print(list(reversed(x)))
# [83, 7, 3, 99, -8]

11，zip(iter1 ,iter2])，用于将可迭代的对象作为参数，将iter1 ,iter2中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，注意是两个对象下标一一对应的，对于无序的对象，集合不一定按照原来对象的顺序对应，字典是键的组成。
这样做的好处是节约了不少的内存。但是没有输出值，要使用 list() 转换才能输出列表。

a = [1,2,3]
b = [4,5,6]
c = [4,5,6,7]
zip(a,b)#<zip at 0x1e2ce5f1cc8>
list(zip(a,b))#[(1, 4), (2, 5), (3, 6)]

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

list(zip(a,c))#[(1, 4), (2, 5), (3, 6)]
a1,a2 = zip(*zip(a,b))
print(a1)#(1, 2, 3)
print(a2)#(4, 5, 5)