一、学习内容概要
目录
二、主要学习内容
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)] 的形式。
1.
max(sub)
返回序列或者参数集合中的最大值
min(sub)
返回序列或参数集合中的最小值
2.
sort 与 sorted 区别:
- sort 是应用在 list 上的方法,属于列表的成员方法,sorted 可以对所有可迭代的对象进行排序操作。(就地排序无返回值)
- list 的 sort 方法返回的是对已经存在的列表进行操作,而内建函数 sorted 方法返回的是一个新的 list,而不是在原来的基础上进行的操作。
- sort使用方法为ls.sort(),而sorted使用方法为sorted(ls)
sorted 语法:
sorted(iterable[, cmp[, key[, reverse]]])
3.
a = list(range(101))
print(sum(a))
#5050
4.
list1 = [2,3,4,5]
list2 = [i**3 for i in list1]
print(list2)
#[8, 27, 64, 125]
5.
三、学习疑惑
这个例子看不懂
四、学习感悟
本次学习内容虽然偏向基础,但知识零碎,还多出现之前学过的一些语法。学习编程也需要经常性复习,做好学习笔记,方便查找和复习。临近期末,时间紧迫,完成质量不高,还有待加强。继续坚持下去,不急不躁敲好每一行代码。学无止境,还需努力。