Python训练营Task05【字典、集合、序列】_python中序列、集合和字典实训题-CSDN博客

本文链接：https://blog.csdn.net/m0_49210538/article/details/121647253

一、学习内容概要

二、主要学习内容

A.字典

1. 可变类型与不可变类型

不可变数据类型在第一次声明赋值声明的时候, 会在内存中开辟一块空间, 用来存放这个变量被赋的值, 而这个变量实际上存储的, 并不是被赋予的这个值, 而是存放这个值所在空间的内存地址，通过这个地址, 变量就可以在内存中取出数据了.

不可变：Number（数字）、String（字符串）、Tuple（元组）

可变数据类型是指变量所指向的内存地址处的值是可以被改变的,也就是说可变类型在赋值的时候copy的是地址或者引用.

可以变：Set（集合）、List（列表）、Dictionary（字典）

可变数据类型：当该数据类型对应的变量的值发生了变化时，如果它对应的内存地址不发生改变，那么这个数据类型就是可变数据类型。

不可变数据类型：当该数据类型对应的变量的值发生了变化时，如果它对应的内存地址发生了改变，那么这个数据类型就是不可变数据类型。

总结：可变数据类型更改值后，内存地址不发生改变。不可变数据类型更改值后，内存地址发生改变。

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

那么如何快速判断一个数据类型 X 是不是可变类型的呢？两种方法：

麻烦方法：用 id(X) 函数，对 X 进行某种操作，比较操作前后的 id，如果不一样，则 X 不可变，如果一样，则 X 可变。
便捷方法：用 hash(X)，只要不报错，证明 X 可被哈希，即不可变，反过来不可被哈希，即可变。

id()

i = 0;
print(id(i))
#1906338848

i = i + 10;
print(id(1))
#1906338880

i = 0;
print(id(i))
#1906338848

i = i + 0;
print(id(i))
#1906338848

哈希hash()

i = 0;
print(hash(i))

#0

print(hash([1,2,3]))

'''
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-6-bb4a063cfa33> in <module>()
----> 1 print(hash([1,2,3]))

TypeError: unhashable type: 'list'
'''

数值、字符和元组都能被哈希，因此它们是不可变类型。
列表、集合、字典不能被哈希，因此它是可变类型。

2. 字典的定义

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

格式

dict = {key1 : value1, key2 : value2, key3 : value3 }

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

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

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

3. 创建和访问字典

使用大括号 { } 创建空字典

# 使用大括号 {} 来创建空字典
emptyDict = {}
 
# 打印字典
print(emptyDict)
 
# 查看字典的数量
print("Length:", len(emptyDict))
 
# 查看类型
print(type(emptyDict))


'''
{}
Length: 0
<class 'dict'>
'''

dic1 = {1: 'one', 2: 'two', 3: 'three'}
print(dic1)  # {1: 'one', 2: 'two', 3: 'three'}
print(dic1[1])  # one
print(dic1[4])  # KeyError: 4

 注意：如果我们取的键在字典中不存在，会直接报错KryError

通过构造函数dict来创建字典。

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

#通过`key`直接把数据放入字典中，但一个`key`只能对应一个`value`.
dic = dict()
dic['a'] = 1
dic['b'] = 2
dic['c'] = 3

print(dic)
# {'a': 1, 'b': 2, 'c': 3}

#多次对一个`key`放入 `value`，后面的值会把前面的值冲掉。

dic['a'] = 11
print(dic)
# {'a': 11, 'b': 2, 'c': 3}

4. 字典的内置方法

dict.fromkeys(seq[, value]) 用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。

seq = ("a","b","c")
dic1 = dict.fromkeys(seq)
print(dic1)


#{'a': None, 'b': None, 'c': None}

dic2 = dict.fromkeys(seq,10086)
print(dic2)

#{'a': 10086, 'b': 10086, 'c': 10086}

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

dic = {"me":"huangxx","age":19}
print(dic.keys())
list1 = list(dic.keys())# 转换为列表
print(list1)




#dict_keys(['me', 'age'])
#['me', 'age']

练习题：

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类型

   
def transfer_score(data):
    # your code here

B.集合

Python 中set(集合)与dict（字典）类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。

注意，key为不可变类型，即可哈希的值。

num = {}
print(type(num))  # <class 'dict'>
num = {1, 2, 3, 4}
print(type(num))  # <class 'set'>

1. 集合的创建

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

basket = set()

#加入元素apple
basket.add('apple')

加入元素banana
basket.add('banana')

print(basket)  # {'banana', 'apple'}

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

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

set和list的区别

set() 集合：
1.无序；

2.内容不能重复，对其可以进行删除重复数据；

列表List：

1.创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可；

2.列表的数据项不需要具有相同的类型；

3.可以创建一个空list；

4.列表中的值可以重复并且有顺序的；

集合的两个特点：无序 (unordered) 和唯一 (unique)。

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

2. 访问集合中的值

可以使用len()內建函数得到集合的大小。（元素的个数）

s = set(['Google', 'Baidu', 'Taobao'])
print(len(s)) 
 # 3

可以使用for把集合中的数据一个个读取出来。（遍历）

s = set(['Google', 'Baidu', 'Taobao'])
for item in s:
    print(item)

# Baidu
# Google
# Taobao

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

s = set(['Google', 'Baidu', 'Taobao'])
print('Taobao' in s)  
# True
print('Facebook' not in s) 
 # True

3. 集合的内置方法

4. 集合的转换

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

5. 不可变集合

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({'g', 's', 'p', 'r', 'u', 'o', 'l'})

练习题：

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

C.序列

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

针对序列的内置函数

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

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

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

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

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

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

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

sorted(iterable, key=None, reverse=False) 对所有可迭代的对象进行排序操作。
- iterable -- 可迭代对象。
- key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
- reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。
- 返回重新排序的列表。

reversed(seq) 函数返回一个反转的迭代器。
- seq -- 要转换的序列，可以是 tuple, string, list 或 range。

enumerate(sequence, [start=0])用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

zip(iter1 [,iter2 [...]])
- 用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。
- 我们可以使用 list() 转换来输出列表。
- 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

练习题：

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

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

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

sort 与 sorted 区别：

sort 是应用在 list 上的方法，属于列表的成员方法，sorted 可以对所有可迭代的对象进行排序操作。（就地排序无返回值）
list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
sort使用方法为ls.sort()，而sorted使用方法为sorted(ls)

sorted 语法：

sorted(iterable[, cmp[, key[, reverse]]])

a = list(range(101))

print(sum(a))

#5050

list1 = [2,3,4,5]
list2 = [i**3 for i in list1]
print(list2)

#[8, 27, 64, 125]

三、学习疑惑

这个例子看不懂

四、学习感悟

本次学习内容虽然偏向基础，但知识零碎，还多出现之前学过的一些语法。学习编程也需要经常性复习，做好学习笔记，方便查找和复习。临近期末，时间紧迫，完成质量不高，还有待加强。继续坚持下去，不急不躁敲好每一行代码。学无止境，还需努力。