Task05字典、集合和序列

python的可变与不可变数据类型

引用

引用(指针)的意思就是Share一块存储空间，如果更改了这块存储区的内容，那么所有引用这块存储区的引用变量就都变了。赋值，只是传递引用。

可变数据类型

在id(内存地址)不变的情况下，value（值）可以变，则称为可变类型

不可变数据类型

value(值)一旦改变，id（内存地址）也改变，则称为不可变类型（id变，意味着创建了新的内存空间）

判断一个数据类型的两种方法：

• 麻烦方法：用 id(X) 函数，对 X 进行某种操作，比较操作前后的 id，如果不一样，则 X 不可变，如果一样，则 X 可变。

• 便捷方法：用 hash(X)，只要不报错，证明 X 可被hash，即不可变，反过来不可被hash，即可变。

i = 1
print(id(i))  # 140732167000896
i = i + 2
print(id(i))  # 140732167000960

l = [1, 2]
print(id(l))  # 4300825160
l.append('Python')
print(id(l))

1519804576
1519804640
2593978964488
2593978964488

• int型变量为不可变数据类型是有范围的，在-5—256范围内才是不可变数据类型

x =1111
y=1111
print(id(x))
print(id(y))

2593996632464
2593996632368

总结：

1. 对于不可变类型, 变量(引用)指向的地址的内容是不可变的, 改变变量的值只是将变量(引用)指向了新的地址；对于可变类型, 变量(引用)指向的地址的内容是可变的, 除非重新赋值, 否则对变量的改变都是对原地址内容的改变.
2. 对于上面说的x =1111,y=1111都指向不同地址其实是另外一个知识点：-5 至 256 永远保存在小整数池中, 方便复用.

字典

• 序列是以连续的整数为索引，与此不同的是，字典以"关键字"为索引，关键字可以是任意不可变类型，通常用字符串或数值
• 字典是 Python 唯一的一个 映射类型，字符串、元组、列表属于序列类型。

字典 是无序的 键:值（key:value）对集合，键必须是对值的描述。

• dict 内部存放的顺序和 key 放入的顺序是没有关系的。
• dict 查找和插入的速度极快，不会随着 key 的增加而增加，但是需要占用大量的内存。

字典 定义语法为 {元素1, 元素2, …, 元素n}

• 其中每一个元素是一个「键值对」-- 键:值 (key:value)
• 关键点是「大括号 {}」,「逗号 ,」和「冒号 :」
• 大括号 – 把所有元素绑在一起
• 逗号 – 将每个键值对分开
• 冒号 – 将键和值分开

brand = ['李宁', '耐克', '阿迪达斯']
slogan = ['一切皆有可能', 'Just do it', 'Impossible is nothing']
print('耐克的口号是:', slogan[brand.index('耐克')])  
# 耐克的口号是: Just do it

dic = {'李宁': '一切皆有可能', '耐克': 'Just do it', '阿迪达斯': 'Impossible is nothing'}
print('耐克的口号是:', dic['耐克'])  
# 耐克的口号是: Just do it

耐克的口号是: Just do it
耐克的口号是: Just do it

注：

1. 字典里的key不允许重复，如果重复了，后一个key对应的值会覆盖前一个
2. 字典里的value可以是任意数据类型 (列表等都可以) ，但是key只能使用不可变数据类型，一般使用字符串

person = { 'age': 18,'name': '张三','sex': '男', 'age': 20}
print(person)

{'age': 20, 'name': '张三', 'sex': '男'}

创建和访问字典

• 直接根据定义的语法创建
• dict()构造函数创建

eg1:

• dict() 创建一个空的字典

dic = dict()
dic['a'] = 1
dic['b'] = 2
dic['c'] = 3
print(dic)

{'a': 1, 'b': 2, 'c': 3}

eg2:

• dict(((key, value),…))
• dict([(key, value),…])
• dict({(key, value),…})

dic1 = dict([('apple', 4139), ('peach', 4127), ('cherry', 4098)])
print(dic1,type(dic1)) 
dic2 = dict({('apple', 4139), ('peach', 4127), ('cherry', 4098)})
print(dic2,type(dic2))  
dic3 = dict((('apple', 4139), ('peach', 4127), ('cherry', 4098)))
print(dic3,type(dic3))

{'apple': 4139, 'peach': 4127, 'cherry': 4098} <class 'dict'>
{'peach': 4127, 'apple': 4139, 'cherry': 4098} <class 'dict'>
{'apple': 4139, 'peach': 4127, 'cherry': 4098} <class 'dict'>

eg3:

• dict(key=value),此时key为字符串，且不加引号

dic = dict(a ='Tom', b =10)
print(dic,type(dic),len(dic))

{'a': 'Tom', 'b': 10} <class 'dict'> 2

从字典里查找数据

• 字典的数据在保存时，是无序的，不能通过下标获取数据
• 使用key,获取对应的value,如果查找的key不存在，会直接报错KeyError错误。 注意：是不能通过 value 找到key的
• 使用字典的get(key, default=None)方法，如果查找的key不存在，返回None

person = { 'age': 18,'name': '张三','sex': '男', 'age': 20}
print(person['age'])
print(person.get('name'))
print(person.get('dict'))
print(person['dict'])

20
张三
None



---------------------------------------------------------------------------

KeyError                                  Traceback (most recent call last)

<ipython-input-4-dd288b942c4d> in <module>()
      3 print(person.get('name'))
      4 print(person.get('dict'))
----> 5 print(person['dict'])


KeyError: 'dict'

字典数据的修改

• 直接通过key可以修改对应的value

person = {1: '张三', 2: 18, 3: '男'}
person[1] = '李四'
print(person)

{1: '李四', 2: 18, 3: '男'}

• 如果key在字典里存在，是修改对应的value。如果不存在时，会往字典里添加一个新的键值对

person = {1: '张三', 2: 18, 3: '男'}
person[4] = '李四'
print(person)

{1: '张三', 2: 18, 3: '男', 4: '李四'}

• **update方法的使用:**就像列表的extend方法可以将两个列表合成一个列表一样，update方法可以将两个字典合成一个

person = {'name': '张三', 'age': 18, 'sex': '男'}
person.update({'height': 176})
print(person)

{'name': '张三', 'age': 18, 'sex': '男', 'height': 176}

字典数据的删除

• pop()方法，返回值是被删除的 value 值。如果要删除的键值对不存在，会出现 Keyerror 错误

person = {'name': '张三', 'age': 18, 'sex': '男'}
result = person.pop('name')
print("返回值：", result)
print(person)

返回值： 张三
{'age': 18, 'sex': '男'}

• popitem()方法，会随机删除一个键值对，返回值为改键值对

person = {'name': '张三', 'age': 18, 'sex': '男'}
result = person.popitem()
print("返回值：", result)
print(person)

返回值： ('sex', '男')
{'name': '张三', 'age': 18}

• 清空字典

person = {'name': '张三', 'age': 18, 'sex': '男'}
person.clear()
print(person)

{}

字典的内置方法

• dict.fromkeys(key, value),

dic1 = dict.fromkeys(('name', 'age', 'sex'),(1,1,1))
print(dic1)

{'name': (1, 1, 1), 'age': (1, 1, 1), 'sex': (1, 1, 1)}

• dict.keys()返回一个可迭代对象，可以使用 list() 来转换为列表，列表为字典中的所有键。

dic = {'Name': 'lsgogroup', 'Age': 7}
print(dic.keys())  # dict_keys(['Name', 'Age'])
lst = list(dic.keys())  # 转换为列表
print(lst)  # ['Name', 'Age']

dict_keys(['Name', 'Age'])
['Name', 'Age']

• dict.values()返回一个迭代器，可以使用 list() 来转换为列表，列表为字典中的所有值。

dic = {'Name': 'lsgogroup', 'Age': 7}
print(dic.values())  
lst = list(dic.values())  # 转换为列表
print(lst) 

dict_values(['lsgogroup', 7])
['lsgogroup', 7]

• dict.items()以列表返回可遍历的 (键, 值) 元组数组。

dic = {'Name': 'Lsgogroup', 'Age': 7}
print(dic.items())
print(tuple(dic.items()))
print(list(dic.items()))

dict_items([('Name', 'Lsgogroup'), ('Age', 7)])
(('Name', 'Lsgogroup'), ('Age', 7))
[('Name', 'Lsgogroup'), ('Age', 7)]

• dict.get(key, default=None) 返回指定键的值，如果值不在字典中返回默认值。
• dict.setdefault(key, default=None)和get()方法 类似, 如果键不存在于字典中，将会添加键并将值设为默认值。

dic = {'Name': 'Lsgogroup', 'Age': 7}
print("Age 键的值为 : %s" % dic.setdefault('Age', None))  
print("Sex 键的值为 : %s" % dic.setdefault('Sex', None))  
print(dic)  

Age 键的值为 : 7
Sex 键的值为 : None
{'Name': 'Lsgogroup', 'Age': 7, 'Sex': None}

• key in dict in 操作符用于判断键是否存在于字典中，如果键在字典 dict 里返回true，否则返回false。而not in操作符刚好相反，如果键在字典 dict 里返回false，否则返回true。
• dict.copy()返回一个字典的浅复制。

dic1 = {'user': 'lsgogroup', 'num': [1, 2, 3]}

# 引用对象
dic2 = dic1  
# 浅拷贝父对象（一级目录），子对象（二级目录）不拷贝，还是引用
dic3 = dic1.copy()  
print(id(dic1))  # 148635574728
print(id(dic2))  # 148635574728
print(id(dic3))  # 148635574344
dic1['user'] = 'root'
dic1['num'].remove(1)
print(dic1)  
print(dic2) 
print(dic3) 

2204846552192
2204846552192
2204846410632
{'user': 'root', 'num': [2, 3]}
{'user': 'root', 'num': [2, 3]}
{'user': 'lsgogroup', 'num': [2, 3]}

练习题：

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中

print(len(dic))

3

dic['java']=98
print(dic)

{'python': 95, 'java': 98, 'c': 100}

dic.pop('c')
print(dic)

{'python': 95, 'java': 98}

dic['php']=90
print(dic)

{'python': 95, 'java': 98, 'php': 90}

print(list(dic.keys()))

['python', 'java', 'php']

print(list(dic.values()))

[95, 98, 90]

print(dic.get("javascript"))

None

dic = {
    'python': 95,
    'java': 99,
    'c': 100
    }
print(sum(dic.values()))

294

print(max(dic.values()))

100

print(min(dic.values()))

95

dic1 = {'php': 97}
dic.update(dic1)
print(dic)

{'python': 95, 'java': 99, 'c': 100, 'php': 97}

2、字典中的value
有一个字典，保存的是学生各个编程语言的成绩，内容如下:

data = {
        'python': {'上学期': '90', '下学期': '95'},
        'c++': ['95', '96', '97'],
        'java': [{'月考':'90', '期中考试': '94', '期末考试': '98'}]
        }

各门课程的考试成绩存储方式并不相同，有的用字典，有的用列表，但是分数都是字符串类型，
请实现函数transfer_score(score_dict)，将分数修改成int类型

def transfer_score(data):
    # your code here

data = {
        'python': {'上学期': '90', '下学期': '95'},
        'c++': ['95', '96', '97'],
        'java': [{'月考':'90', '期中考试': '94', '期末考试': '98'}]
        }
def transfer_score(data):
    s=list(data.values())
    for py_names, py_scores in s[0].items():
        return("python成绩","\n",py_names, '=',  int(py_scores),type(int(py_scores)))
    s[1]=list(map(int,s[1]))
    return('c++的成绩是',s[1],type(s[1][0]),type(s[1][1]),type(s[1][2]))
    for ja_names, ja_scores in s[2][0].items():
        return("java成绩","\n",ja_names, '=', int(ja_scores),type(int(ja_scores)))
print(data.transfer_score())

不知道为什么参数传不进进去，函数调用不了。而我的原始代码可以运行如下：

data = {
        'python': {'上学期': '90', '下学期': '95'},
        'c++': ['95', '96', '97'],
        'java': [{'月考':'90', '期中考试': '94', '期末考试': '98'}]
        }
s=list(data.values())
for py_names, py_scores in s[0].items():
        print("python成绩","\n",py_names, '=',  int(py_scores),type(int(py_scores)))
s[1]=list(map(int,s[1]))
print('c++的成绩是',s[1],type(s[1][0]),type(s[1][1]),type(s[1][2]))
for ja_names, ja_scores in s[2][0].items():
        print("java成绩","\n",ja_names, '=', int(ja_scores),type(int(ja_scores)))

python成绩 
 上学期 = 90 <class 'int'>
python成绩 
 下学期 = 95 <class 'int'>
c++的成绩是 [95, 96, 97] <class 'int'> <class 'int'> <class 'int'>
java成绩 
 月考 = 90 <class 'int'>
java成绩 
 期中考试 = 94 <class 'int'>
java成绩 
 期末考试 = 98 <class 'int'>

集合

定义：

Python 中set与dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。
注意:

• key为不可变类型，即可哈希的值。
• 集合是无序的-> 不支持下标索引
• 集合（set）是可变的数据类型
• 集合中的元素是唯一的
• 集合一般用于元组或者列表中的元素去重

集合的创建与删除

• 先创建对象再加入元素。
• 在创建空集合的时候只能使用s = set()，因为s = {}创建的是空字典。

basket = set()
basket.add('apple')
basket.add('banana')
print(basket)

{'apple', 'banana'}

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

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(basket) 

{'orange', 'apple', 'banana', 'pear'}

• 使用set(value)工厂函数，把列表或元组转换成集合。

a = set('abracadabra')
print(a)  
b = set(("Google", "Lsgogroup", "Taobao", "Taobao"))
print(b)  
c = set(["Google", "Lsgogroup", "Taobao", "Google"])
print(c)  
d = set(('abracadabra'))
print(d)

{'a', 'b', 'c', 'r', 'd'}
{'Lsgogroup', 'Google', 'Taobao'}
{'Lsgogroup', 'Google', 'Taobao'}
{'a', 'b', 'c', 'r', 'd'}

集合的两个特点：无序 (unordered) 和唯一 (unique)。
由于 set 存储的是无序集合，所以我们不可以为集合创建索引或执行切片(slice)操作，也没有键(keys)可用来获取集合中元素的值，但是可以判断一个元素是否在集合中。

读取集合元素

• 可以使用len()內建函数得到集合的大小。
• 可以使用for把集合中的数据一个个读取出来。
• 可以通过in或not in判断一个元素是否在集合中已经存在

set1={1,2,'we','f','?'}
for element in set1:
    print(element)
print('Taobao' in  set1)
print(1 in set1)

1
2
we
f
?
False
True

添加、删除集合元素

添加元素:

• setname.add(element) 在集合中添加一个新的元素e；如果元素已经存在，则不添加；
  此处element只能使用字符串、数字及布尔类型，不可使用列表、元组等可迭代对象

• setname01.update(setname02) 将集合setname02合并到集合setname01中，去除重复元素

删除元素：

• setname.remove(element)
  从集合中删除一个元素，如果元素不存在于集合中，则会产生一个KeyError错误

• setname.discard（element）
  从集合setname中移除一个元素element,在元素element不存在时什么都不做

• setname.pop()
  随机删除一个元素

• setname.clear()
  清空集合内的所有元素

fruits = {"banana","apple",  "cherry"}
x = fruits.pop()
print(fruits)  # {'cherry', 'apple'}

{'banana', 'cherry'}

集合运算

• 交集(取重复）

set.intersection(set1, set2) 返回两个集合的交集。
set1 & set2 返回两个集合的交集。
set.intersection_update(set1, set2) 交集，在原始的集合上移除不重叠的元素。

• 并集(去重复)

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

• 差集

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

• 异或

set.symmetric_difference(set)返回集合的异或。
set1 ^ set2 返回集合的异或。
set.symmetric_difference_update(set)移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。

a = set('abracadabra')
b = set('alacazam')
print(a)  # {'r', 'a', 'c', 'b', 'd'}
print(b)  # {'c', 'a', 'l', 'm', 'z'}
c = a.symmetric_difference(b)
print(c)  # {'m', 'r', 'l', 'b', 'z', 'd'}
print(a ^ b)  # {'m', 'r', 'l', 'b', 'z', 'd'}
print(a)  # {'r', 'd', 'c', 'a', 'b'}
a.symmetric_difference_update(b)
print(a)  # {'r', 'b', 'm', 'l', 'z', 'd'}

{'a', 'b', 'c', 'r', 'd'}
{'a', 'c', 'z', 'm', 'l'}
{'b', 'z', 'm', 'r', 'l', 'd'}
{'b', 'z', 'm', 'r', 'l', 'd'}
{'a', 'b', 'c', 'r', 'd'}
{'b', 'z', 'm', 'r', 'l', 'd'}

• 子集

set.issubset(set1)判断set是不是被set1包含，如果是则返回 True，否则返回 False。
set1 <= set2 判断set1是不是被aet2包含，如果是则返回 True，否则返回 False。
set.issuperset(set1)用于判断set是不是包含set1，如果是则返回 True，否则返回 False。

• 相交

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

集合的转换

se = set(range(4))
li = list(se)
tu = tuple(se)

print(se, type(se))  # {0, 1, 2, 3} <class 'set'>
print(li, type(li))  # [0, 1, 2, 3] <class 'list'>
print(tu, type(tu))  # (0, 1, 2, 3) <class 'tuple'>

{0, 1, 2, 3} <class 'set'>
[0, 1, 2, 3] <class 'list'>
(0, 1, 2, 3) <class 'tuple'>

不可变集合

Python 提供了不能改变元素的集合的实现版本，即不能增加或删除元素，类型名叫frozenset。需要注意的是frozenset仍然可以进行集合操作，只是不能用带有update的方法。

• frozenset([iterable]) 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

a = frozenset(range(10))  # 生成一个新的不可变集合
print(a)  
# frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})

b = frozenset('lsgogroup')
print(b)  

frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
frozenset({'u', 's', 'g', 'p', 'r', 'l', 'o'})

练习题：

1.怎么表示只包含⼀个数字1的元组。

a=(1,)
print(a)

(1,)

2.创建一个空集合，增加 {‘x’,‘y’,‘z’} 三个元素。

b = set()
b.update({'x','y','z'})
print(b)

{'x', 'y', 'z'}

3.列表[‘A’, ‘B’, ‘A’, ‘B’]去重。

lst=['A', 'B', 'A', 'B']
lst=list(set(lst))
print(lst)

['A', 'B']

4.求两个集合{6, 7, 8}，{7, 8, 9}中不重复的元素（差集指的是两个集合交集外的部分）。

print({6, 7, 8}^{7, 8, 9})

{9, 6}

5.求{‘A’, ‘B’, ‘C’}中元素在 {‘B’, ‘C’, ‘D’}中出现的次数。

for i in {'A', 'B', 'C'}:
    print(i,'出现次数：',int(i in {'B', 'C', 'D'}))

A 出现次数： 0
B 出现次数： 1
C 出现次数： 1

序列

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

内置函数

• list(sub)
  把一个可迭代对象转换为列表
• tuple(sub)
  把一个可迭代对象转换为元组
• str(obj)
  把obj对象转换为字符串
• len(s)
  返回对象（字符、列表、元组等）长度或元素个数。
• max(sub)
  返回序列或者参数集合中的最大值
• min(sub)
  返回序列或参数集合中的最小值
• sum(iterable[, start=0])
  返回序列的和，可指定序列的起始位置
• sorted(iterable, key=None, reverse=False)
  对所有可迭代的对象进行排序
• iterable是可迭代对象
  key是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序
• reverse是排序规则，默认为升序
• reversed(seq)
  返回一个反转的迭代器；转换的序列seq可以是 tuple, string, list 或 range
• enumerate(sequence, [start=0])
  用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时返回数据和数据下标，一般用在 for 循环当中；可指定数据下标的初始位置

练习题：

1.怎么找出序列中的最⼤、⼩值？

找最大值max()
找最小值min()

2.sort() 和 sorted() 区别？

python中的sort和sorted都属于排序函数，但是两者有用一些区别：

• sort()函数排序是对列表本身进行排序，使用这个函数后，原来的list列表也会发生改变，而且调用方式为
  列表名.sort()，而且不可另外赋给一个列表
• sorted的函数是对列表排序后不改变原来的列表，会另外生成一个列表，调用方式为sorted(列表名）

3.怎么快速求 1 到 100 所有整数相加之和？

lst=[i for i in range(1,101)]
print(sum(lst))

5050

4.求列表 [2,3,4,5] 中每个元素的立方根。

lst=[i**3 for i in [2,3,4,5]]
print(sum(lst))

224

5.将[‘x’,‘y’,‘z’] 和 [1,2,3] 转成 [(‘x’,1),(‘y’,2),(‘z’,3)] 的形式。

a=['x','y','z']
b=[1,2,3]
lst = list(zip(a ,b))
print(lst)

[('x', 1), ('y', 2), ('z', 3)]