Python学习 DAY 4

程序员文章站 2022-07-14 19:02:48

...

DAY 4

字典

字典是“键值对”的无序可变序列，字典中通过“键对象”找到对应的“值对象”。“键”是任意的不可变数据，比如：整数、浮点数、字符串、元组。并且“键不可重复”。

“值”可以使任意的数据，并且可重复。

一种典型的字典的定义方式：

a = {'name':'Lee','age':'20,'job':'programmer'}

字典的创建

1.可以通过{}、dict()来创建字典对象。

a = {‘name’:‘Lee’,‘age’:20,‘job’:‘programmer’}

等价于

a = dict(name=‘Lee’,age=20,job=‘programmer’)

等价于

a = dict([(‘name’,‘Lee’),(‘age’,18),(‘job’,‘programmer’)])

>>> a = {'name':'Lee','age':20,'job':'programmer'}
>>>> a.get('name')
'Lee'

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

>>> k = ['name','age','job']
>>> v = ['Lee',18,'teacher']
>>> d = dict(zip(k,v))
>>> d
{'name': 'Lee', 'age': 18, 'job': 'teacher'}

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

>>> c = dict.fromkeys(['name','age','job'])
>>> c
{'name': None, 'age': None, 'job': None}```
## 字典元素的访问 ##

访问方法：

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

`a['age']`

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

```python
>>> a = dict([('name','Lee'),('age',18),('job','programmer')])
>>> print(a.get('age'))
18
>>> print(a.get('dddd'))
None
>>> a.get('dddd','不存在')
'不存在'
>>> print(a.get('dddd','不存在'))
不存在

3.列出所有的键值对

>>> a.items()
dict_items([('name', 'Lee'), ('age', 18), ('job', 'programmer')])

4.列出所有的键，列出所有的值

>>> a.keys()
dict_keys(['name', 'age', 'job'])
>>> a.values()
dict_values(['Lee', 18, 'programmer'])

5.len()键值对的个数

6.检测一个“键”是否在字典中

>>> 'name' in a
True

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

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

>>> a
{'name': 'Lee', 'age': 18, 'job': 'programmer'}
>>> a['address']='Nanjing'
>>> a['age']='20'
>>> a
{'name': 'Lee', 'age': '20', 'job': 'programmer', 'address': 'Nanjing'}

2.使用update()将新字典中所有键值对全部添加到旧字典对象上。如果key有重复，则覆盖。

>>> b
{'name': 'Lee', 'age': 18, 'job': 'programmer'}
>>> a
{'name': 'Lee', 'age': '20', 'job': 'programmer', 'address': 'Nanjing'}
>>> b.update(a)
>>> b
{'name': 'Lee', 'age': '20', 'job': 'programmer', 'address': 'Nanjing'}

3.字典中元素的删除，可以使用del()方法；或者clear()删除所有键值对；pop()删除指定键值对，并返回对应的“值对象”

>>> b
{'name': 'Lee', 'age': '20', 'job': 'programmer', 'address': 'Nanjing'}
>>> del(b['name'])
>>> b
{'age': '20', 'job': 'programmer', 'address': 'Nanjing'}

>>> b.pop('job')
'programmer'
>>> b
{'age': '20', 'address': 'Nanjing'}

>>> b.clear()
>>> b
{}

4.popitem():随机删除和返回该键值对。字典是“无序可变序列”，因此没有第一个和最后一个元素的概念。

>>> a
{'name': 'Lee', 'age': '20', 'job': 'programmer', 'address': 'Nanjing'}
>>> a.popitem()
('address', 'Nanjing')
>>> a
{'name': 'Lee', 'age': '20', 'job': 'programmer'}
>>> a.popitem()
('job', 'programmer')
>>> a
{'name': 'Lee', 'age': '20'}

序列解包

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

>>> x,y,z = [1,2,3]
>>> x
1
>>> (a,b,c)=(4,5,6)
>>> a
4

序列解包用于字典时，默认是对“键”进行操作

>>> s = {'name': 'Lee', 'age': '20', 'job': 'programmer', 'address': 'Nanjing'}
>>> a,b,c,d = s  #默认对键进行操作
>>> a
'name'
>>> a,b,c,d = s.items()  #对键值对进行操作
>>> a
('name', 'Lee')
>>> a,b,c,d = s.values()  #对值进行操作
>>> a
'Lee'

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

r1 = {'name':'高一','age':18,'salary':30000,'city':'北京'}
r2 = {'name':'高二','age':19,'salary':20000,'city':'上海'}
r3 = {'name':'高三','age':20,'salary':50000,'city':'深圳'}

tb = [r1,r2,r3]

#获得第二行人的薪资
print(tb[1].get('salary'))

#打印表中所有人的薪资
for i in range(len(tb)):
    print(tb[i].get('salary'))

#打印表的所有数据
for i in range(len(tb)):
    print(tb[i].get('name'),tb[i].get('age'),tb[i].get('salary'),tb[i].get('city'))

================ RESTART: D:/资料/算法学习/Python/code/DAY04mypy01.py ================
20000
30000
20000
50000
高一 18 30000 北京
高二 19 20000 上海
高三 20 50000 深圳

字典核心底层原理（重要）

字典对象的核心是散列表。散列表是一个系数数组（总有空白元素的数组），数组的每个单元叫做bucket。每个bucket有两部分：一个是键对象的引用，一个是值对象的引用。

所有bucket结果和大小一致，可以通过偏移量来读取指定bucket。

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

假设字典 a 对象创建完后，数组长度为 8：

我们要把”name”=”Lee”这个键值对放到字典对象 a 中，首先第一步需要计算键”name”的散列值。Python 中可以通过 hash()来计算。

>>> bin(hash("name")) '-0b1010111101001110110101100100101

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

扩容

python 会根据散列表的拥挤程度扩容。“扩容”指的是:创造更大的数组，将原有内容拷贝到新数组中。接近2/3时，数组就会扩容。

根据键查找“键值对”的底层过程

当我们调用 a.get(“name”)，就是根据键“name”查找到“键值对”，从而找到值对象“gaoqi”。第一步，我们仍然要计算“name”对象的散列值：

>>> bin(hash("name")) '-0b1010111101001110110101100100101

和存储的底层流程算法一致，也是依次取散列值的不同位置的数字。假设数组长度为 8，我们可以拿计算出的散列值的最右边 3 位数字作为偏移量，即“101”，十进制是数字 5。我们查看偏移量 5，对应的 bucket 是否为空。如果为空，则返回 None。如果不为空，则将这个 bucket 的键对象计算对应散列值，和我们的散列值进行比较，如果相等。则将对应“值对象”返回。如果不相等，则再依次取其他几位数字，重新计算偏移量。依次取完后，仍然没有找到。则返回 None。

用法总结

用法总结：

键必须可散列
(1) 数字、字符串、元组，都是可散列的。 (2) 自定义对象需要支持下面三点：
- 支持 hash()函数
- 支持通过__eq__()方法检测相等性。
- 若 a==b 为真，则 hash(a)==hash(b)也为真。
字典在内存中开销巨大，典型的空间换时间；
键查询速度很快；
往字典里面添加新建可能导致扩容，导致散列表中键的次序变化。因此，不要在遍历字典的同时进行字典的修改。

集合

集合是无序可变，元素不能重复。实际上，集合底层是字典实现，集合的所有元素都是字典中的“键对象”，因此是不能重复的且唯一的。

集合创建与删除

1.用{}创建集合对象，并使用add()方法添加元素

>>> a = {1,3,4}
>>> a
{1, 3, 4}
>>> a.add(9)
>>> a
{1, 3, 4, 9}

2.使用set()将列表、元组等可迭代对象转成集合；

>>> a = ['a','b','c','b']
>>> b = set(a)
>>> b
{'a', 'c', 'b'}

3.remove()删除指定元素；clear()清空整个集合；

集合相关操作

并集、交集、差集等

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

控制语句

选择结构

if 条件表达式:

语句/语句块

其中：

1.条件表达式：可以是逻辑表达式、关系表达式、算术表达式等等。

2.语句/语句块：可以是一条语句，也可以是多条语句。多条语句，缩进必须对齐一致.

在选择和循环结构中，条件表达式的值为 False 的情况如下：

False、0、0.0、空值None、空序列对象（空列表、空元祖、空集合、空字典、空字符串、空range对象、空迭代对象。其他情况，均为True。

条件表达式中不能出现赋值操作符“=”

双分支选择结构

双分支结构的语法格式如下：

if 条件表达式 :

语句 1/语句块 1

else:

语句 2/语句块 2

三元条件预算符

语法格式如下：

条件为真时的值  if (条件表达式) else  条件为假时的值

num = input("请输入一个数字")
print( num if int(num)<10 else "数字太大")

多分支选择结构

多分支选择结构的语法格式如下：

if 条件表达式1:

语句1/语句块1

elif 条件表达式2:

语句2/语句块2

·
·
·

elif 条件表达式n:

语句n/语句块n

[else:

语句n+1/语句块n+1

]

#测试多分支结构

a = int(input("请输入成绩："))
b = ''
if a<60:
    b = '不及格'
elif 60<=a<70:
    b = '及格'
elif 70<=a<80:
    b = '一般'
elif 80<=a<90:
    b = '良好'
else:
    b = '优秀'

print('分数是{0}，成绩是{1}'.format(a,b))

选择结构的嵌套

选择结构可以嵌套，使用时一定要注意控制好不同级别代码块的缩进量，因为缩进量决定了代码的从属关系。

#选择结构的嵌套练习

a = int(input('请输入成绩：'))
b = "ABCDF"
num = 0
if a>100 or a<0:
    print('成绩应在0~100范围内')
else:
    num = a//10
    if num<6:
        num=5
    print('成绩是{0}，等级是{1}'.format(a,b[9-num]))

循环结构

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

while循环

while 循环的语法格式如下：

while 条件表达式： 
	循环体语句

#计算 1-100 之间数字的累加和

num=0
sum_all=0
while num<=100:
    sum_all+=num
    num+=1
print("和为：",sum_all)

Python学习 DAY 4

DAY 4

字典

字典的创建

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

序列解包

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

字典核心底层原理（重要）

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

扩容

根据键查找“键值对”的底层过程

用法总结

集合

集合创建与删除

集合相关操作

控制语句

选择结构

双分支选择结构

三元条件预算符

多分支选择结构

选择结构的嵌套

循环结构

while循环

最全Python学习路线图【2020最新版】

Python【day 15-3】函数部分

python学习第五天--函数进阶

Python入门基础学习(面向对象)

C学习笔记（4）--- 指针的应用（第一部分）

python day19 : 购物商城作业，进程与多线程

Python 练习一（计算1-2+3-4...+99）

Python学习之旅（十四）

Python 全栈前端学习笔记

Python机器学习k-近邻算法(K Nearest Neighbor)实例详解

Python学习 DAY 4

DAY 4

字典

字典的创建

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

序列解包

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

字典核心底层原理（重要）

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

扩容

根据键查找“键值对”的底层过程

用法总结

集合

集合创建与删除

集合相关操作

控制语句

选择结构

双分支选择结构

三元条件预算符

多分支选择结构

选择结构的嵌套

循环结构

while循环

最全Python学习路线图【2020最新版】

Python【day 15-3】函数部分

python学习第五天--函数进阶

Python入门基础学习(面向对象)

C学习笔记（4）--- 指针的应用（第一部分）

python day19 : 购物商城作业，进程与多线程

Python 练习一（计算1-2+3-4...+99）

Python学习之旅（十四）

Python 全栈 前端学习笔记

Python机器学习k-近邻算法(K Nearest Neighbor)实例详解

Python 全栈前端学习笔记