Python基础知识-pycharm版第四节笔记

字典

字典是“键值对”的无序可变序列，字典中的每个元素都是一个“键值对”，包含： “键
对象”和“值对象”。可以通过“键对象”实现快速获取、删除、更新对应的“值对象”。
列表中我们通过“下标数字”找到对应的对象。字典中通过“键对象”找到对应的“值
对象”。“键”是任意的不可变数据，比如：整数、浮点数、字符串、元组。但是：列表、
字典、集合这些可变对象，不能作为“键”。并且“键”不可重复。
“值”可以是任意的数据，并且可重复。
一个典型的字典的定义方式：
a = {'name':'gaoqi','age':18,'job':'programmer'}
字典的创建
1. 我们可以通过{}、dict()来创建字典对象。

a={"name":"linyi","age":26,"aa":[10,20,30]}
a
{'name': 'linyi', 'age': 26, 'aa': [10, 20, 30]}
b=dict(name="linyi",age=18)
b
{'name': 'linyi', 'age': 18}

2. 通过 zip()创建字典对象

k = ['name','age','job']
z = ['1','2','2']
d = dict(zip(k,z))
d
{'name': '1', 'age': '2', 'job': '2'}

3. 通过 fromkeys 创建值为空的字典

a=dict.fromkeys(["name","age"])
a
{'name': None, 'age': None}

字典元素的访问

1. 通过 [键] 获得“值”。若键不存在，则抛出异常。

a = {'name':'gaoqi','age':18,'job':'programmer'}
a['age']
18

2. 通过 get()方法获得“值” 。推荐使用。优点是：指定键不存在，返回 None；也可以设
定指定键不存在时默认返回的对象。推荐使用 get()获取“值对象”。

a.get('age')
18
a.get('666')
a.get('aaa')
a.get('sex','u')
'u'
3. 列出所有的键值对
a.items()
dict_items([('name', 'gaoqi'), ('age', 18), ('job', 'programmer')])
4. 列出所有的键，列出所有的值
a.keys()
dict_keys(['name', 'age', 'job'])
a.values()
dict_values(['gaoqi', 18, 'programmer'])
5. len() 键值对的个数
6. 检测一个“键”是否在字典中
a = {"name":"gaoqi","age":18}
"name" in a
True

字典元素添加、修改、删除

1. 给字典新增“键值对”。 如果“键”已经存在，则覆盖旧的键值对；如果“键”不存在，
则新增“键值对”。

a['id']='哥'
a
{'name': 'gaoqi', 'age': 18, 'job': 'programmer', 'id': '哥'}
a['age']=66
a
{'name': 'gaoqi', 'age': 66, 'job': 'programmer', 'id': '哥'}
2. 使用 update()将新字典中所有键值对全部添加到旧字典对象上。 如果 key 有重复，则直
接覆盖。
b = {'name':'gaoxixi','money':1000,'sex':'男的'}
a.update(b)
a
{'name': 'gaoxixi', 'age': 66, 'job': 'programmer', 'id': '哥', 'money': 1000, 'sex': '男的'}
3. 字典中元素的删除，可以使用 del()方法；或者 clear()删除所有键值对；pop()删除指定
键值对，并返回对应的“值对象”；
del(a['job'])
a
{'name': 'gaoxixi', 'age': 66, 'id': '哥', 'money': 1000, 'sex': '男的'}

a.pop('age')
66
a
{'name': 'gaoxixi', 'id': '哥', 'money': 1000, 'sex': '男的'}
a.clear()
a
{}
4. popitem() ：随机删除和返回该键值对。 字典是“无序可变序列”，因此没有第一个元
素、最后一个元素的概念；popitem 弹出随机的项，因为字典并没有"最后的元素"或者其
他有关顺序的概念。若想一个接一个地移除并处理项，这个方法就非常有效（因为不用首先
获取键的列表）。
a = {'name':'gaoqi','age':18,'job':'programmer'}
a.popitem()
('job', 'programmer')
a
{'name': 'gaoqi', 'age': 18}
a.popitem()
('age', 18)
a
{'name': 'gaoqi'}

序列解包
序列解包可以用于元组、列表、字典。序列解包可以让我们方便的对多个变量赋值。

s = {'name':'gaoqi','age':18,'job':'teacher'}
a,b,c=s
a
'name'
b
'age'
c
'job'
序列解包用于字典时，默认是对“键”进行操作； 如果需要对键值对操作，则需要使用
items()；如果需要对“值”进行操作，则需要使用 values()；
d,e,f=s.values()
d
'gaoqi'
c
'job'
e
18
r,t,y=s.items()
r
('name', 'gaoqi')
t
('age', 18)
y
('job', 'teacher')

表格数据使用字典和列表存储，并实现访问

输出结果：

40000
30000
40000
60000
林一 18 30000 北京
林二 20 40000 厦门
林三 33 60000 上海

字典核心底层原理(重要)

字典对象的核心是散列表。散列表是一个稀疏数组（总是有空白元素的数组），数组的
每个单元叫做 bucket。每个 bucket 有两部分：一个是键对象的引用，一个是值对象的引
用。
由于，所有 bucket 结构和大小一致，我们可以通过偏移量来读取指定 bucket。

将一个键值对放进字典的底层过程

由于数组长度为 8，我们可以拿计算出的散列值的最右边 3 位数字作为偏移量，即
“101”，十进制是数字 5。我们查看偏移量 5，对应的 bucket 是否为空。如果为空，则
将键值对放进去。如果不为空，则依次取右边 3 位作为偏移量，即“100”，十进制是数字
4。再查看偏移量为 4 的 bucket 是否为空。直到找到为空的 bucket 将键值对放进去。流
程图如下：

扩容
python 会根据散列表的拥挤程度扩容。“扩容”指的是:创造更大的数组，将原有内容
拷贝到新数组中。
接近 2/3 时，数组就会扩容。
根据键查找“键值对”的底层过程
我们明白了，一个键值对是如何存储到数组中的，根据键对象取到值对象，理解起来就
简单了。

a.get("name")
'gaoqi'
当我们调用 a.get(“name”)，就是根据键“name”查找到“键值对”，从而找到值
对象“gaoqi”。
第一步，我们仍然要计算“name”对象的散列值：
bin(hash("name"))
'-0b1010111101001110110101100100101'
和存储的底层流程算法一致，也是依次取散列值的不同位置的数字。 假设数组长度为
8，我们可以拿计算出的散列值的最右边 3 位数字作为偏移量，即“101”，十进制是数字
5。我们查看偏移量 5，对应的 bucket 是否为空。如果为空，则返回 None。**如果不为空，
则将这个 bucket 的键对象计算对应散列值，和我们的散列值进行比较，如果相等。则将对
应“值对象”返回。如果不相等，则再依次取其他几位数字，重新计算偏移量。依次取完后，
仍然没有找到。则返回 None。**流程图如下：

用法总结：
1. 键必须可散列
(1) 数字、字符串、元组，都是可散列的。
(2) 自定义对象需要支持下面三点：
1
支持 hash()函数
2
支持通过__eq__()方法检测相等性。
3
若 a==b 为真，则 hash(a)==hash(b)也为真。
2. 字典在内存中开销巨大，典型的空间换时间。
3. 键查询速度很快
4. 往字典里面添加新建可能导致扩容，导致散列表中键的次序变化。因此，不要在遍历字
典的同时进行字典的修改。
集合
集合是无序可变，元素不能重复。实际上，集合底层是字典实现，集合的所有元素都是字典
中的“键对象”，因此是不能重复的且唯一的。
集合创建和删除
1. 使用{}创建集合对象，并使用 add()方法添加元素

a = {3,5,7}
a
{3, 5, 7}
a.add(9)
a
{9, 3, 5, 7}
2. 使用 set()，将列表、元组等可迭代对象转成集合。如果原来数据存在重复数据，则只保
留一个。
a = ['a','b','c','b']
b = set(a)
b
{'b', 'a', 'c'}
3. remove()删除指定元素；clear()清空整个集合
a = {10,20,30,40,50}
a.remove(20)
a
{10, 50, 30}

集合相关操作
像数学中概念一样，Python 对集合也提供了并集、交集、差集等运算。我们给出示例：

a = {1,3,'sxt'}
b = {'he','it','sxt'}
> >> a|b #并集
{1, 3, 'sxt', 'he', 'it'}
> >> a&b #交集
{'sxt'}
> >> a-b #差集
{1, 3}
a.union(b) #并集
{1, 3, 'sxt', 'he', 'it'}
a.intersection(b) #交集
{'sxt'}
a.difference(b) #差集
{1, 3}

章 节 实 操 作 业

2. 使用 range 生成序列：30,40,50,60,70,80

list(range(30,90,10))
[30, 40, 50, 60, 70, 80]
3. 推导式生成列表： a = [x*2 for x in range(100) if x%9==0]，手写出结果。

[0, 18, 36, 54, 72, 90, 108, 126, 144, 162, 180, 198]
4. 使用二维列表存储表格信息，并画出简单的内存存储示意图：
姓名 年龄 薪资 城市
高小一 18 30000 北京
高小二 19 20000 上海
高小五 20 10000 深圳

6. 创建一个字典对象 ，包含如下信息：
支出金额：300.15，支出日期：2018.10.18，支出人：高小七

a = {'支出金额':300.15,'支出日期':'2018.10.18','支出人':'高小七'}
7. 使用字典存储行数据，最后将整个表使用列表存储起来。
姓名 年龄 薪资 城市
高小一 18 30000 北京
高小二 19 20000 上海
高小五 20 10000 深圳

第 4 章 控制语句

选择结构

选择结构通过判断条件是否成立，来决定执行哪个分支。选择结构有多种形式，分为：单分
支、双分支、多分支。流程图如下：

单分支选择结构
if 语句单分支结构的语法形式如下：
if 条件表达式:
语句/语句块
其中：
1 ．条件表达式：可以是逻辑表达式、关系表达式、算术表达式等等。
2 ．语句/语句块：可以是一条语句，也可以是多条语句。多条语句，缩进必须对齐一致。

num = input("输入一个数字：")
if int(num)<10:
print(num)

条件表达式详解
在选择和循环结构中，条件表达式的值为 False 的情况如下：
False、0、0.0、空值 None、空序列对象（空列表、空元祖、空集合、空字典、空字
符串）、空 range 对象、空迭代对象。
其他情况，均为 True。

测试各种条件表达式

执行结果如下：

空列表是false
空字符串
10
3<c<10

·条件表达式中，不能有赋值操作符“=”
在 Python 中，条件表达式不能出现赋值操作符“=”，避免了其他语言中经常误将关系运
算符“==”写作赋值运算符“=”带来的困扰。如下代码将会报语法错误：

双分支选择结构

双分支结构的语法格式如下：
if 条件表达式 :
语句 1/语句块 1
else:
语句 2/语句块 2

三元条件运算符
Python 提供了三元运算符，用来在某些简单双分支赋值情况。三元条件运算符语法格式如
下：
条件为真时的值 if (条件表达式) else 条件为假时的值

多分支选择结构
多分支选择结构的语法格式如下：
if 条件表达式 1 :
语句 1/语句块 1
elif 条件表达式 2:
语句 2/语句块 2
.
.
.
elif 条件表达式 n :
语句 n/语句块 n
[else:
语句 n+1/语句块 n+1
]

多分支结构，几个分支之间是有逻辑关系的，不能随意颠倒顺序。
【操作】输入一个学生的成绩，将其转化成简单描述：不及格(小于 60)、及格(60-79)、良
好(80-89)、优秀(90-100)。

【操作】已知点的坐标(x,y)，判断其所在的象限

选择结构嵌套
选择结构可以嵌套， 使用时一定要注意控制好不同级别代码块的缩进量， 因为缩进量决定了
代码的从属关系。语法格式如下：
if 表达式 1：
语句块 1
if 表达式 2：
语句块 2
else:
语句块 3
else:
if 表达式 4：
语句块 4

    **#或者也可以用下面代码更少的方法**

循环结构
循环结构用来重复执行一条或多条语句。表达这样的逻辑：如果符合条件，则反
复执行循环体里的语句。在每次执行完后都会判断一次条件是否为 True，如果
为 True 则重复执行循环体里的语句。图示如下：

while 循环
while 循环的语法格式如下：
while 条件表达式：
循环体语句