可变类型与不可变类型

-可变类型：当该数据类型的对应变量的值发生了改变，那么它对应的内存地址不发生改变，对于这种数据类型，就称可变数据类型

-不可变类型： 当该数据类型的对应变量的值发生了改变，那么它对应的内存地址也会发生改变，对于这种数据类型，就称不可变数据类型

**快速判断一个数据类型 `X` 是不是可变类型的两种方法**

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

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

·字典

1 基本定义

-字典是无序的键:值（`key:value`）对集合，键必须是互不相同的（在同一个字典之内）

基本形式：{元素1, 元素2, ..., 元素n}

每个元素都是一个键值对——key:value

example：dic = {'李宁': '一切皆有可能', '耐克': 'Just do it', '阿迪达斯': 'Impossible is nothing'}

**字典以"关键字"为索引，关键字可以是任意不可变类型，通常用字符串或数值**

2 创建和访问字典

2.1 通过字符串或数值作为‘key’来创建字典

2.2 通过元组作为‘key’创建字典

解释：上述三个key值分别为（1，2，3）、‘Age’和3，分别为元组、字符串和整型数据类型，都是不可变数据类型。

2.3 通过dict函数创建字典

直接dict()创建的是一个空的字典，通过key直接把数据放入字典中

2.4 dict(mapping)： 从映射对象（键、值）初始化新字典

其实就相当于是把键值对放在一个一个的元组中，再用列表了解这一个一个的元组传给dict作为参数。

2.5 dict(**kwargs)：用关键字参数列表中的名称=值对初始化新字典

**这种情况下，键只能为字符串类型，并且创建的时候字符串不能加引号，加上就会直接报语法错误**

example：dic=dict(name='Tom', age=10)

print(dic)

输出结果：{'name':'Tom', 'age':10}

3 内置方法

(更正一下：应该是clear)

3.1 有关删除的方法

1）dic.clear() 

删除字典所有元素

2）dic.pop(key[,default]) 

删除字典给定键 `key` 所对应的值

成功：返回值为被删除的值。`key` 值必须给出。

失败：若`key`不存在，则返回 `default` 值

3）dic.popitem()

随机返回并删除字典中的一对键和值（注意是随机）

如果字典已经为空，却调用了此方法，就报出KeyError异常

4）del dict[key]

删除字典给定‘key’对应的值

3.2 dict.fromkeys(seq[, value])  --创建字典相关方法

描述：创建一个新字典，以序列 `seq` 中元素做字典的键，`value` 为字典所有键对应的初始值。

3.3查询相关方法

1）dic.keys()

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

2）dic.values()

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

3） dic.items()

以列表返回可遍历的 (键, 值) 元组数组

4）dic.get(key, default=None)

返回指定键的值，如果值不在字典中返回默认值

以上四种方法的示例如图

5）dic.setdefault(key, default=None)

`get()`方法 类似, 如果键不存在于字典中，将会添加键并将值设为默认值

ps：相当于找不到的话就直接添加进去

6）key in/not in dic

in 判断键是否存在于字典中，如果键在字典 dict 里返回`true`，否则返回`false`

**get、setdefault以及in/not in都是判断的键**

3.4 dict1.update(dict2)

把字典参数 `dict2` 的 `key:value`对 更新到字典 `dict1` 里

--example：

dic1= {'Name': 'Lsgogroup', 'Age': 7}

dic2 = {'Sex': 'female', 'Age': 8}

dic1.update(dic2)

print(dic1) 

输出结果：{'Name': 'Lsgogroup',  'Age': 8, 'Sex': 'female' }

3.5 dic.copy()

返回一个字典的浅复制

**课后练习及解答**

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中

解答如下：

输出结果：

2、字典中的value

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

data = {

        'python': {'上学期': '90', '下学期': '95'},

        'c++': ['95', '96', '97'],

        'java': [{'月考':'90', '期中考试': '94', '期末考试': '98'}]

        }

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

///空一下

·集合

1 基本概念

集合与字典类似，但是他是一组`key`的集合，不存储`value`。由于`key`不能重复，所以，在`set`中，没有重复的`key`。

-example：

num = {}

print(type(num))  # <class 'dict'>

num = {1, 2, 3, 4}

print(type(num))  # <class 'set'>

**集合的两个特点：无序和唯一**

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

2 集合的创建

2.1 set（）

-先创建集合对象，再通过add方法添加元素

-ps：空集合的创建只能用set（）方法构造，不可以直接s={}，这样出来的是字典类型

2.2 直接{'元素1'，‘元素2’，‘元素3’，...}

注意：重复元素在`set`中会被自动被过滤

-example：

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

print(basket)  

输出结果： {'banana', 'apple', 'pear', 'orange'}

2.3 set(value)：把列表或元组转换成集合

**新思路：去掉列表中重复的元素，就可以先将列表转换为集合，然后再转换过去**

3 集合的访问

不可以为集合创建索引或执行切片(slice)操作，也没有键(keys)可用来获取集合中元素的值，但是可以判断一个元素是否在集合中

1) len（）

使用`len()`內建函数得到集合的大小

2) for

使用`for`把集合中的数据一个个读取出来

3) in/not in

通过`in`或`not in`判断一个元素是否在集合中已经存在

4 集合的内置方法

4.1 添加、删除

1）add 和 update

set.add(element)：用于给集合添加元素，如果添加的元素在集合中已存在，则不执行任何操作

set1.update(set2)：用于修改当前集合，可以添加新的元素或集合到当前集合中，如果添加的元素在集合中已存在，则该元素只会出现一次，重复的会忽略

2）clear、remove、discard、pop

-set.clear()：移除集合中的所有元素

-set.remove(item)：移除集合中的指定元素。如果元素不存在，则会发生错误

-set.discard(item)：移除集合中的指定元素，如果元素不存在，不会发生错误

-set.pop()：返回值为随机移除的一个元素

4.2 集合操作

1）交集 intersection

-  set.intersection(set1, set2)：返回两个集合的交集。

-  set1 & set2：返回两个集合的交集

-  set.intersection_update(set1, set2 ... etc))交集，在原始的集合上移除不重叠的元素，获取两个或更多集合中都重叠的元素，即计算交集。

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

**intersection和intersection_update的区别在于 前者是返回一个新的交集，后者是在原始集合上移除不重叠 的元素 **

2）并集 union

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

- set1 | set2：返回两个集合的并集。

3）差集 difference

（相当于set1减去两者交集元素）

- set.difference(set)：返回集合的差集

- set1 - set2：返回集合的差集

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

4）异或 symmetric_difference

（相当于除了两者交集元素以外的所有元素）

- set.symmetric_difference(set)：返回集合的异或

- set1 ^ set2：返回集合的异或

- set.symmetric_difference_update(set)：移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。

5）其他

-判断集合是不是被其他集合包含，如果是则返回 True，否则返回 False

    set.issubset(set)

    set1 <= set2

-判断集合是不是包含其他集合，如果是则返回 True，否则返回 False

    set.issuperset(set)

    set1 >= set2

5 不可变集合

不可变集合，即不能增加或删除元素，类型名叫`frozenset`。

**需要注意的是`frozenset`仍然可以进行集合操作，只是不能用带有`update`的方法。

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

**课后练习及解答

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

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

3. 列表\['A', 'B', 'A', 'B']去重

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

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

解答如下

输出结果

·序列

1 基本概念 

序列类型：字符串、列表、元组、集合和字典

这些序列支持一些通用的操作，但比较特殊的是，集合和字典不支持索引、切片、相加和相乘操作。

序列的内置函数

2 内置函数

2.1 转换函数

- list(sub)：把一个可迭代对象转换为列表

- tuple(sub)：把一个可迭代对象转换为元组

- str(obj)：把obj对象转换为字符串

2.2 len、max、min和sum

- len(s)：返回对象（字符、列表、元组等）长度或元素个数

- max(sub)：返回序列或者参数集合中的最大值

- min(sub)：返回序列或参数集合中的最小值

- sum(iterable[, start=0])：返回序列`iterable`与可选参数`start`的总和

*example

print(sum([1, 3, 5, 7, 9]))            输出：25

print(sum([1, 3, 5, 7, 9], 10))     输出：35

2.3 排序 

- sorted(iterable, key=None, reverse=False)

     `iterable`：可迭代对象

     `key` ：主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序

      `reverse` ：排序规则，`reverse = True` 降序 ， `reverse = False` 升序（默认）

        返回重新排序的列表。

*example：

x = [-8, 99, 3, 7, 83]

print(sorted(x))                              输出：[-8, 3, 7, 83, 99]

print(sorted(x, reverse=True))     输出： [99, 83, 7, 3, -8]

t = ({"age": 20, "name": "a"}, {"age": 25, "name": "b"}, {"age": 10, "name": "c"})

x = sorted(t, key=lambda a: a["age"])

print(x)

输出：[{'age': 10, 'name': 'c'}, {'age': 20, 'name': 'a'}, {'age': 25, 'name': 'b'}]

2.4 其他

1）reverse(seq) ：返回一个反转的迭代器

-`seq` ：要转换的序列，可以是 tuple, string, list 或 range

-example：

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']

2）enumerate(sequence, [start=0])

-将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中

-example

seasons = ['Spring', 'Summer', 'Fall', 'Winter']

a = list(enumerate(seasons))

print(a)               输出：[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]

b = list(enumerate(seasons, 1))

print(b)               输出：[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

for i, element in a:

    print('{0},{1}'.format(i, element))

输出：

# 0,Spring

# 1,Summer

# 2,Fall

# 3,Winter

3）zip(iter1 [,iter2 [...]])

- 将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。

- 我们可以使用 `list()` 转换来输出列表。

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

-example

a = [1, 2, 3]

b = [4, 5, 6]

c = [4, 5, 6, 7, 8]

zipped = zip(a, b)

print(zipped)                输出： <zip object at 0x000000C5D89EDD88>

print(list(zipped))        输出： [(1, 4), (2, 5), (3, 6)]

zipped = zip(a, c)

print(list(zipped))        输出：[(1, 4), (2, 5), (3, 6)]

a1, a2 = zip(*zip(a, b))

print(list(a1))                输出： [1, 2, 3]

print(list(a2))                输出：[4, 5, 6]

**课后练习及解答

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

2. sort() 和 sorted() 区别

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

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

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

解答如下

第二题：

sorted（）为序列通用内置方法,排序后返回排序后序列，对原序列无影响

sort() 为列表类的内置方法，排序并修改列表，无返回值

其他：