Python学习打卡【TASK5】

最新推荐文章于 2024-11-17 10:39:57 发布

blu.lywlzq

最新推荐文章于 2024-11-17 10:39:57 发布

阅读量393

点赞数

分类专栏：笔记文章标签： python 散列表开发语言

本文链接：https://blog.csdn.net/m0_64388246/article/details/121653362

版权

笔记专栏收录该内容

6 篇文章 0 订阅

订阅专栏

一、学习知识点概要
1、字典：可变类型与不可变类型、字典的定义、创建和访问字典、字典的内置方法
2、集合：集合的创建、访问集合中的值、集合的内置方法、集合的转换、不可变集合
3、序列：针对序列的内置函数

二、学习内容
1、字典的可变类型与不可变类型：

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

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

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

a=666
print(id(a))
a=a+888
print(id(a))

a=["马嘉祺","丁程鑫","宋亚轩","刘耀文","张真源","严浩翔","贺峻霖"]
print(id(a))
a=["马嘉祺","丁程鑫","宋亚轩","刘耀文","张真源","严浩翔","贺峻霖"]
a.append("李飞")
print(id(a))

在这里插入图片描述
*- 数值、字符和元组都能被哈希，因此它们是不可变类型。

列表、集合、字典不能被哈希，因此它是可变类型。*

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

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

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

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

3、创建和访问字典:

love=["宋亚轩","刘耀文","严浩翔"]
petphrase=["我sei大壁虎","我就看不得你们这些社会上的娃儿，嚼得很","塑料落到了木地板上，我说了一句我爱你"]
print("刘耀文的口头禅是：",petphrase[love.index("刘耀文")])

通过字符串或数值作为key来创建字典。
**注意：**如果我们取的键在字典中不存在，会直接报错KeyError。
在这里插入图片描述

通过元组作为key来创建字典，但一般不这样使用。

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

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

【例子】通过key直接把数据放入字典中，但一个key只能对应一个value，多次对一个key放入 value，后面的值会把前面的值冲掉。

dic = dict()
dic['a'] = 666
dic['b'] = 888
dic['c'] = 999
print(dic)
dic["a"]=5201314
print(dic)

4、字典的内置方法：

dict.fromkeys(seq[, value]) 用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。
dict.keys()返回一个可迭代对象，可以使用 list() 来转换为列表，列表为字典中的所有键。
dict.values()返回一个迭代器，可以使用 list() 来转换为列表，列表为字典中的所有值。
dict.items()以列表返回可遍历的 (键, 值) 元组数组。
dict.get(key, default=None) 返回指定键的值，如果值不在字典中返回默认值。
dict.setdefault(key, default=None)和get()方法类似, 如果键不存在于字典中，将会添加键并将值设为默认值。
key in dict in 操作符用于判断键是否存在于字典中，如果键在字典 dict 里返回true，否则返回false。而not in操作符刚好相反，如果键在字典 dict 里返回false，否则返回true。
dict.pop(key[,default])删除字典给定键 key 所对应的值，返回值为被删除的值。key 值必须给出。若key不存在，则返回 default 值。
del dict[key] 删除字典给定键 key 所对应的值。
dict.popitem()随机返回并删除字典中的一对键和值，如果字典已经为空，却调用了此方法，就报出KeyError异常。
dict.clear()用于删除字典内所有元素。
dict.copy()返回一个字典的浅复制。
dict.update(dict2)把字典参数 dict2 的 key:value对更新到字典 dict 里。

5、集合的创建：

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

TNT=set()
TNT.add("马嘉祺")
TNT.add("丁程鑫")
TNT.add("宋亚轩")
TNT.add("刘耀文")
TNT.add("张真源")
TNT.add("严浩翔")
TNT.add("贺峻霖")
print(TNT)

直接把一堆元素用花括号括起来{元素1, 元素2, ..., 元素n}。
重复元素在set中会被自动被过滤。
使用set(value)工厂函数，把列表或元组转换成集合。去掉
列表中重复的元素

a=[666,888,999,666,250,5201314,888]
b=set(a)
print(list(b))

从结果发现集合的两个特点：无序 (unordered) 和唯一 (unique)。

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

6、访问集合中的值：

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

a=set(["马嘉祺","丁程鑫","宋亚轩","刘耀文","张真源","严浩翔","贺峻霖"])
print(len(a))

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

TNT=set(["马嘉祺","丁程鑫","宋亚轩","刘耀文","张真源","严浩翔","贺峻霖"])
for member in TNT:
    print(member)

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

7、集合的内置方法：

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

TNT=["马嘉祺","丁程鑫","宋亚轩","刘耀文","张真源","严浩翔","贺峻霖"]
TNT.add("李飞")
TNT.add("刘耀文")
print(TNT)

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

TNT={"马嘉祺","丁程鑫","宋亚轩","刘耀文","张真源","严浩翔","贺峻霖"}
dear={"任嘉伦","朱一龙"}
TNT.update(dear)
print(TNT)

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

TNT={"马嘉祺","丁程鑫","宋亚轩","刘耀文","张真源","严浩翔","贺峻霖","任嘉伦","朱一龙"}
TNT.remove("朱一龙")
print(TNT)

set.discard(value) 用于移除指定的集合元素。remove() 方法在移除一个不存在的元素时会发生错误，而 discard() 方法不会。

TNT={"马嘉祺","丁程鑫","宋亚轩","刘耀文","张真源","严浩翔","贺峻霖"}
TNT.discard("李飞")
print(TNT)

set.pop() 用于随机移除一个元素。

由于 set 是无序和无重复元素的集合，所以两个或多个 set 可以做数学意义上的集合操作。

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

a=set("ahdneckshixj")
b=set("shidihxsldhf")
c=a.intersection(b)
print(c)
print(a&b)
a.intersection_update(b)
print(a)

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

a=set("ahdneckshixj")
b=set("shidihxsldhf")
c=a.union(b)
print(c)
print(a|b)

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

a=set("ahdneckshixj")
b=set("shidihxsldhf")
c=a.difference(b)
print(c)
a.difference_update(b)
print(a)
print(a-b)

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

a=set("ahdneckshixj")
b=set("shidihxsldhf")
c=a.symmetric_difference(b)
print(c)
print(a^b)

set.issubset(set)判断集合是不是被其他集合包含，如果是则返回 True，否则返回 False。
set1 <= set2 判断集合是不是被其他集合包含，如果是则返回 True，否则返回 False。

a={"a","b","c"}
b={"d","a","f","e","b","j","c"}
c=a.issubset(b)
print(c)
print(a<=b)

set.issuperset(set)用于判断集合是不是包含其他集合，如果是则返回 True，否则返回 False。
set1 >= set2 判断集合是不是包含其他集合，如果是则返回 True，否则返回 False。

a={"a","b","c"}
b={"d","a","f","e","b","j","c"}
c=b.issuperset(a)
print(c)
print(b>=a)

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

a={"a","b","c"}
b={"d","a","f","e","b","j","c"}
c=a.isdisjoint(b)
print(c)

8、集合的转换：

a=set(range(10))
b=list(a)
c=tuple(a)
print(a,type(a))
print(b,type(b))
print(c,type(c))

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

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

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

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

a=(666,888,999,5201314,250)
a=list(a)
print(a)

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

a="I Love Liuyaowen"
a=tuple(a)
print(a)

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

a=666
a=str(a)
print(a)

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

a=list("I Love Liuyaowen")
print(len(a))

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

print(max(666,888,999,5201314))
print(max("I Love Liuyaowen"))

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

print(min(-444,555,-999,357235))
print(min("I Love Liuyaowen"))

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

a=range(1,101)
b=list(a)
print(sum(list(b)))

（这个也是练习中的解答）
sorted(iterable, key=None, reverse=False) 对所有可迭代的对象进行排序操作。

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

a=[-454,-698,666,999,5201314,888]
print(sorted(a))
print(sorted(a,reverse=True))
print(sorted(a,reverse=False))

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

a=range(1,11)
print(list(reversed(a)))

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

TNT=["马嘉祺","丁程鑫","宋亚轩","刘耀文","张真源","严浩翔","贺峻霖"]
a=list(enumerate(TNT))
print(a)
b=list(enumerate(TNT,1))
print(b)

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

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

a=[1,2,3]
b=[-4,-5,-6]
c=[666,888,999,5201314]
zipped=zip(a,b)
print(zipped)
print(list(zipped))
x=zip(a,c)
print(list(x))
a1,a2=zip(*zip(a,c))
print(list(a1))
print(list(a2))

三、学习问题与解答
“字典”和“集合”文件中“字典的内置方法”和“集合的内置方法”对我来说真的挺难理解的，希望如果较多同学也是这种情况的话后续可以集中讲一下。

四、学习思考与总结
最近的学习中“元组”、“字符串”、“字典”、“集合”的内置方法，自己学习的时候，第一感觉就是“这什么玩意儿？杀了我吧”，对我来说真的难以理解，希望自己能多去B站找视频学习，不要置之不理，得过且过。发现做了练习后，对知识点掌握的更好了，本来不理解的知识点在做练习的过程中也慢慢的掌握了。