修复了文档中的缺陷
jackfrued
parent
d3f209edf7
commit
223c4b9fed
Binary file not shown.
|
After Width: | Height: | Size: 155 KiB |
|
|
@ -61,9 +61,9 @@ print(a) # 算一下这里会输出什么
|
|||
|
||||
###比较运算符和逻辑运算符
|
||||
|
||||
比较运算符有的地方也称为关系运算符，包括`==`、`!=`、`<`、`>`、`<=`、`>=`，我相信没有什么好解释的，大家一看就能懂，唯一需要提醒的是比较相等用的是`==`，请注意这个地方是两个等号，因为`=`是赋值运算符，我们在上面刚刚讲到过，`==`才是比较相等的比较运算符。比较运算符会产生布尔值，要么是`True`要么是`False`。
|
||||
比较运算符有的地方也称为关系运算符，包括`==`、`!=`、`<`、`>`、`<=`、`>=`，我相信没有什么好解释的，大家一看就能懂，需要提醒的是比较相等用的是`==`，请注意这里是两个等号，因为`=`是赋值运算符，我们在上面刚刚讲到过，`==`才是比较相等的运算符；比较不相等用的是`!=`，这不同于数学上的不等号，Python 2中曾经使用过`<>`来表示不等关系，大家知道就可以了。比较运算符会产生布尔值，要么是`True`要么是`False`。
|
||||
|
||||
逻辑运算符有三个，分别是`and`、`or`和`not`。`and`字面意思是“而且”，所以`and`运算符会连接两个布尔值，如果两个布尔值都是`True`，那么运算的结果就是`True`；左右两边的布尔值有一个是`False`，最终的运算结果就是`False`。相信大家已经想到了，如果`and`左边的布尔值是`False`，不管右边的布尔值是什么，最终的结果都是`False`，所以在做运算的时候右边的值会被跳过（短路处理），这也就意味着在`and`运算符左边为`False`的情况下，右边的表达式根本不会执行。`or`字面意思是“或者”，所以`or`运算符也会连接两个布尔值，如果两个布尔值有任意一个是`True`，那么最终的结果就是`True`。当然，`or`运算符也是有短路功能的，在它左边的布尔值为`True`的情况下，右边的表达式根本不会执行。`not`运算符的后面会跟上一个布尔值，它的作用是得到与该布尔值相反的值，也就是说，后面的布尔值如果是`True`运算结果就是`False`，而后面的布尔值如果是`False`则运算结果就是`True`。
|
||||
逻辑运算符有三个，分别是`and`、`or`和`not`。`and`字面意思是“而且”，所以`and`运算符会连接两个布尔值，如果两个布尔值都是`True`，那么运算的结果就是`True`；左右两边的布尔值有一个是`False`，最终的运算结果就是`False`。相信大家已经想到了，如果`and`左边的布尔值是`False`，不管右边的布尔值是什么，最终的结果都是`False`，所以在做运算的时候右边的值会被跳过（短路处理），这也就意味着在`and`运算符左边为`False`的情况下，右边的表达式根本不会执行。`or`字面意思是“或者”，所以`or`运算符也会连接两个布尔值，如果两个布尔值有任意一个是`True`，那么最终的结果就是`True`。当然，`or`运算符也是有短路功能的，在它左边的布尔值为`True`的情况下，右边的表达式根本不会执行。`not`运算符的后面会跟上一个布尔值，它的作用是得到与该布尔值相反的值，也就是说，`not`后面的布尔值如果是`True`，运算结果就是`False`；而`not`后面的布尔值如果是`False`，运算结果就是`True`。
|
||||
|
||||
```Python
|
||||
"""
|
||||
|
|
|
|||
|
|
@ -120,8 +120,8 @@ print(add(1)) # 1
|
|||
print(add(1, 2)) # 3
|
||||
# 调用add函数，传入三个参数，分别赋值给a、b、c三个变量
|
||||
print(add(1, 2, 3)) # 6
|
||||
# 传递参数时可以不按照设定的顺序进行传递
|
||||
print(add(c=50, a=100, b=200))
|
||||
# 传递参数时可以不按照设定的顺序进行传递，但是要用“参数名=参数值”的形式
|
||||
print(add(c=50, a=100, b=200)) # 350
|
||||
```
|
||||
|
||||
#### 可变参数
|
||||
|
|
|
|||
|
|
@ -79,6 +79,36 @@ print(s1) # hello world!!!hello world!!!
|
|||
|
||||
用`*`实现字符串的重复是非常有意思的一个运算符，在很多编程语言中，要表示一个有10个`a`的字符串，你只能写成`"aaaaaaaaaa"`，但是在Python中，你可以写成`'a' * 10`。你可能觉得`"aaaaaaaaaa"`这种写法也没有什么不方便的，那么想一想，如果字符`a`要重复100次或者1000次又会如何呢？
|
||||
|
||||
#### 比较运算
|
||||
|
||||
对于两个字符串类型的变量，可以直接使用比较运算符比较两个字符串的相等性或大小。需要说明的是，因为字符串在计算机内存中也是以二进制形式存在的，那么字符串的大小比较比的是每个字符对应的编码的大小。例如`A`的编码是`65`， 而`a`的编码是`97`，所以`'A' < 'a'`的结果相当于就是`65 < 97`的结果，很显然是`True`；而`'boy' < 'bad'`，因为第一个字符都是`'b'`比不出大小，所以实际比较的是第二个字符的大小，显然`'o' < 'a'`的结果是`False`，所以`'boy' < 'bad'`的结果也是`False`。如果不清楚两个字符对应的编码到底是多少，可以使用`ord`函数来获得，例如`ord('A')`的值是`65`，而`ord('昊')`的值是`26122`。下面的代码为大家展示了字符串的比较运算。
|
||||
|
||||
```Python
|
||||
s1 = 'a whole new world'
|
||||
s2 = 'hello world'
|
||||
print(s1 == s2, s1 < s2) # False True
|
||||
print(s2 == 'hello world') # True
|
||||
print(s2 == 'Hello world') # False
|
||||
print(s2 != 'Hello world') # True
|
||||
s3 = '骆昊'
|
||||
print(ord('骆'), ord('昊')) # 39558 26122
|
||||
s4 = '王大锤'
|
||||
print(ord('王'), ord('大'), ord('锤')) # 29579 22823 38180
|
||||
print(s3 > s4, s3 <= s4) # True False
|
||||
```
|
||||
|
||||
需要强调一下的是，字符串的比较运算比较的是字符串的内容，Python中还有一个`is`运算符（身份运算符），如果用`is`来比较两个字符串，它比较的是两个变量对应的字符串是否在内存中相同的位置（内存地址），简单的说就是两个变量是否对应内存中的同一个字符串。看看下面的代码就比较清楚`is`运算符的作用了。
|
||||
|
||||
```Python
|
||||
s1 = 'hello world'
|
||||
s2 = 'hello world'
|
||||
s3 = s2
|
||||
# 比较字符串的内容
|
||||
print(s1 == s2, s2 == s3) # True True
|
||||
# 比较字符串的内存地址
|
||||
print(s1 is s2, s2 is s3) # False True
|
||||
```
|
||||
|
||||
#### 成员运算
|
||||
|
||||
Python中可以用`in`和`not in`判断一个字符串中是否存在另外一个字符或字符串，`in`和`not in`运算通常称为成员运算，会产生布尔值`True`或`False`，代码如下所示。
|
||||
|
|
|
|||
|
|
@ -46,11 +46,20 @@ items1 = [35, 12, 99, 68, 55, 87]
|
|||
items2 = ['Python', 'Java', 'Go', 'Kotlin']
|
||||
```
|
||||
|
||||
除此以外，还可以通过Python内置的`list`函数将其他序列变成列表。准确的说，`list`并不是一个函数，而是创建列表对象的构造器（后面会讲到对象和构造器这两个概念）。
|
||||
|
||||
```Python
|
||||
items1 = list(range(1, 10))
|
||||
print(items1) # [1, 2, 3, 4, 5, 6, 7, 8, 9]
|
||||
items2 = list('hello')
|
||||
print(items2) # ['h', 'e', 'l', 'l', 'o']
|
||||
```
|
||||
|
||||
需要说明的是，列表是一种可变数据类型，也就是说列表可以添加元素、删除元素、更新元素，这一点跟我们上一课讲到的字符串有着鲜明的差别。字符串是一种不可变数据类型，也就是说对字符串做拼接、重复、转换大小写、修剪空格等操作的时候会产生新的字符串，原来的字符串并没有发生任何改变。
|
||||
|
||||
#### 列表的运算符
|
||||
|
||||
和字符串类型一样，列表也支持拼接、重复、成员运算、索引和切片，对此我们不再进行赘述，请大家参考下面的代码。
|
||||
和字符串类型一样，列表也支持拼接、重复、成员运算、索引和切片以及比较运算，对此我们不再进行赘述，请大家参考下面的代码。
|
||||
|
||||
```Python
|
||||
items1 = [35, 12, 99, 68, 55, 87]
|
||||
|
|
@ -82,6 +91,15 @@ print(items3[:5]) # [35, 12, 99, 68, 55]
|
|||
print(items3[4:]) # [55, 87, 45, 8, 100]
|
||||
print(items3[-5:-7:-1]) # [55, 68]
|
||||
print(items3[::-2]) # [100, 45, 55, 99, 35]
|
||||
|
||||
# 列表的比较运算
|
||||
items5 = [1, 2, 3, 4]
|
||||
items6 = list(range(1, 5))
|
||||
# 两个列表比较相等性比的是对应索引位置上的元素是否相等
|
||||
print(items5 == items6) # True
|
||||
items7 = [3, 2, 1]
|
||||
# 两个列表比较大小比的是对应索引位置上的元素的大小
|
||||
print(items5 <= items7) # True
|
||||
```
|
||||
|
||||
值得一提的是，由于列表是可变类型，所以通过索引操作既可以获取列表中的元素，也可以更新列表中的元素。对列表做索引操作一样要注意索引越界的问题，对于有`N`个元素的列表，正向索引的范围是`0`到`N-1`，负向索引的范围是`-1`到`-N`，如果超出这个范围，将引发`IndexError`异常，错误信息为：`list index out of range`。
|
||||
|
|
@ -154,6 +172,14 @@ print(items) # []
|
|||
|
||||
需要提醒大家，在使用`remove`方法删除元素时，如果要删除的元素并不在列表中，会引发`ValueError`异常，错误消息是：`list.remove(x): x not in list`。在使用`pop`方法删除元素时，如果索引的值超出了范围，会引发`IndexError`异常，错误消息是：`pop index out of range`。
|
||||
|
||||
从列表中删除元素其实还有一种方式，就是使用Python中的`del`关键字后面跟要删除的元素，这种做法跟使用`pop`方法指定索引删除元素没有实质性的区别，但后者会返回删除的元素，前者在性能上略优（`del`对应字节码指令是`DELETE_SUBSCR`，而`pop`对应的字节码指令是`CALL_METHOD`和`POP_TOP`）。
|
||||
|
||||
```Python
|
||||
items = ['Python', 'Java', 'Go', 'Kotlin']
|
||||
del items[1]
|
||||
print(items) # ['Python', 'Go', 'Kotlin']
|
||||
```
|
||||
|
||||
#### 元素位置和次数
|
||||
|
||||
列表类型的`index`方法可以查找某个元素在列表中的索引位置；因为列表中允许有重复的元素，所以列表类型提供了`count`方法来统计一个元素在列表中出现的次数。请看下面的代码。
|
||||
|
|
@ -271,7 +297,7 @@ print(scores) # [[95, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
|
|||
|
||||
### 简单的总结
|
||||
|
||||
这节课我们先不做总结，等学完下节课的元组之后，我们对列表和元组的使用做一个简单的总结。
|
||||
Python中的列表底层是一个可以动态扩容的数组，列表元素在内存中也是连续存储的，所以可以实现随机访问（通过一个有效的索引获取到对应的元素且操作时间与列表元素个数无关）。我们暂时不去触碰这些底层存储细节以及列表每个方法的渐近时间复杂度（执行这个方法耗费的时间跟列表元素个数的关系），等需要的时候再告诉大家。现阶段，大家只需要知道**列表是容器**，可以**保存各种类型的数据**，**可以通过索引操作列表元素**就可以了。
|
||||
|
||||
> **温馨提示**：学习中如果遇到困难，可以加**QQ交流群**询问，群号：**789050736**。
|
||||
|
||||
|
|
|
|||
|
|
@ -1,10 +1,10 @@
|
|||
## 第012课：常用数据结构之元组
|
||||
|
||||
上一节课为大家讲解了Python中的列表，它是一种容器型数据类型，我们可以通过定义列表类型的变量来保存和操作多个元素。当然，Python中容器型的数据类型肯定不止列表一种，接下来我们为大家讲解另一种非常重要的容器型数据类型，它的名字叫元组（tuple）。
|
||||
上一节课为大家讲解了Python中的列表，它是一种容器型数据类型，我们可以通过定义列表类型的变量来保存和操作多个元素。当然，Python中容器型的数据类型肯定不止列表一种，接下来我们为大家讲解另一种重要的容器型数据类型，它的名字叫元组（tuple）。
|
||||
|
||||
### 定义和使用元组
|
||||
|
||||
在Python中，元组也是多个元素按照一定的顺序构成的序列。元组和列表的不同之处在于，元组是不可变类型，这就意味着元组类型的变量一旦定义，其中的元素不能再添加或删除，而且元素的值也不能进行修改。定义元组使用`()`字面量语法，元组类型支持的运算符跟列表是一样。下面的代码演示了元组的定义和运算。
|
||||
在Python中，元组也是多个元素按照一定的顺序构成的序列。元组和列表的不同之处在于，元组是不可变类型，这就意味着元组类型的变量一旦定义，其中的元素不能再添加或删除，而且元素的值也不能进行修改。定义元组通常使用`()`字面量语法，也建议大家使用这种方式来创建元组。元组类型支持的运算符跟列表是一样。下面的代码演示了元组的定义和运算。
|
||||
|
||||
```Python
|
||||
# 定义一个三元组
|
||||
|
|
@ -35,6 +35,11 @@ print(t3) # (30, 10, 55, '骆昊', 40, True, '四川成都')
|
|||
|
||||
# 切片
|
||||
print(t3[::3]) # (30, '骆昊', '四川成都')
|
||||
|
||||
# 比较运算
|
||||
print(t1 == t3) # False
|
||||
print(t1 >= t3) # False
|
||||
print(t1 < (30, 11, 55)) # True
|
||||
```
|
||||
|
||||
一个元组中如果有两个元素，我们就称之为二元组；一个元组中如果五个元素，我们就称之为五元组。需要提醒大家注意的是，`()`表示空元组，但是如果元组中只有一个元素，需要加上一个逗号，否则`()`就不是代表元组的字面量语法，而是改变运算优先级的圆括号，所以`('hello', )`和`(100, )`才是一元组，而`('hello')`和`(100)`只是字符串和整数。我们可以通过下面的代码来加以验证。
|
||||
|
|
@ -196,6 +201,6 @@ def find_max_and_min(items):
|
|||
|
||||
### 简单的总结
|
||||
|
||||
**列表和元组都是容器型的数据类型**，即一个变量可以保存多个数据。**列表是可变数据类型**，**元组是不可变数据类型**，所以列表添加元素、删除元素、清空、排序等方法对于元组来说是不成立的。但是列表和元组都可以进行**拼接**、**成员运算**、**索引和切片**这些操作，就如同之前讲到的字符串类型一样，因为字符串是字符按一定顺序构成的序列，在这一点上三者并没有本质区别。我们**推荐大家使用列表的生成式语法来创建列表**，它很好用，也是Python中非常有特色的语法。
|
||||
**列表和元组都是容器型的数据类型**，即一个变量可以保存多个数据。**列表是可变数据类型**，**元组是不可变数据类型**，所以列表添加元素、删除元素、清空、排序等方法对于元组来说是不成立的。但是列表和元组都可以进行**拼接**、**成员运算**、**索引和切片**这些操作，就如同之前讲到的字符串类型一样，因为字符串就是字符按一定顺序构成的序列，在这一点上三者并没有什么区别。我们**推荐大家使用列表的生成式语法来创建列表**，它很好用，也是Python中非常有特色的语法。
|
||||
|
||||
> **温馨提示**：学习中如果遇到困难，可以加**QQ交流群**询问，群号：**789050736**。
|
||||
|
|
@ -0,0 +1,193 @@
|
|||
## 第015课：常用数据结构之字典
|
||||
|
||||
迄今为止，我们已经为大家介绍了Python中的三种容器型数据类型，但是这些数据类型还不足以帮助我们解决所有的问题。例如，我们要保存一个人的信息，包括姓名、年龄、体重、单位地址、家庭住址、本人手机号、紧急联系人手机号等信息，你会发现我们之前学过的列表、元组和集合都不是最理想的选择。
|
||||
|
||||
```Python
|
||||
person1 = ['王大锤', 55, 60, '科华北路62号', '中同仁路8号', '13122334455', '13800998877']
|
||||
person2 = ('王大锤', 55, 60, '科华北路62号', '中同仁路8号', '13122334455', '13800998877')
|
||||
person3 = {'王大锤', 55, 60, '科华北路62号', '中同仁路8号', '13122334455', '13800998877'}
|
||||
```
|
||||
|
||||
集合肯定是最不合适的，因为集合有去重特性，如果一个人的年龄和体重相同，那么集合中就会少一项信息；同理，如果这个人的家庭住址和单位地址是相同的，那么集合中又会少一项信息。另一方面，虽然列表和元组可以把一个人的所有信息都保存下来，但是当你想要获取这个人的手机号时，你得先知道他的手机号是列表或元组中的第6个还是第7个元素；当你想获取一个人的家庭住址时，你还得知道家庭住址是列表或元组中的第几项。总之，在遇到上述的场景时，列表、元组、字典都不是最合适的选择，我们还需字典（dictionary）类型，这种数据类型最适合把相关联的信息组装到一起，并且可以帮助我们解决程序中为真实事物建模的问题。
|
||||
|
||||
说到字典这个词，大家一定不陌生，读小学的时候每个人基本上都有一本《新华字典》，如下图所示。
|
||||
|
||||
|
||||
|
||||
Python程序中的字典跟现实生活中的字典很像，它以键值对（键和值的组合）的方式把数据组织到一起，我们可以通过键找到与之对应的值并进行操作。就像《新华字典》中，每个字（键）都有与它对应的解释（值）一样，每个字和它的解释合在一起就是字典中的一个条目，而字典中通常包含了很多个这样的条目。
|
||||
|
||||
### 创建和使用字典
|
||||
|
||||
在Python中创建字典可以使用`{}`字面量语法，这一点跟上一节课讲的集合是一样的。但是字典的`{}`中的元素是以键值对的形式存在的，每个元素由`:`分隔的两个值构成，`:`前面是键，`:`后面是值，代码如下所示。
|
||||
|
||||
```Python
|
||||
xinhua = {
|
||||
'麓': '山脚下', '路': '道，往来通行的地方；方面，地区：南～货，外～货；种类：他俩是一～人',
|
||||
'蕗': '甘草的别名', '潞': '潞水，水名，即今山西省的浊漳河；潞江，水名，即云南省的怒江'
|
||||
}
|
||||
print(xinhua)
|
||||
person = {
|
||||
'name': '王大锤', 'age': 55, 'weight': 60, 'office': '科华北路62号',
|
||||
'home': '中同仁路8号', 'tel': '13122334455', 'econtact': '13800998877'
|
||||
}
|
||||
print(person)
|
||||
```
|
||||
|
||||
通过上面的代码，相信大家已经看出来了，用字典来保存一个人的信息远远优于使用列表或元组，因为我们可以用`:`前面的键来表示条目的含义，而`:`后面就是这个条目所对应的值。
|
||||
|
||||
当然，如果愿意，我们也可以使用内置函数`dict`或者是字典的生成式语法来创建字典，代码如下所示。
|
||||
|
||||
```Python
|
||||
# dict函数(构造器)中的每一组参数就是字典中的一组键值对
|
||||
person = dict(name='王大锤', age=55, weight=60, home='中同仁路8号')
|
||||
print(person) # {'name': '王大锤', 'age': 55, 'weight': 60, 'home': '中同仁路8号'}
|
||||
|
||||
# 可以通过Python内置函数zip压缩两个序列并创建字典
|
||||
items1 = dict(zip('ABCDE', '12345'))
|
||||
print(items1) # {'A': '1', 'B': '2', 'C': '3', 'D': '4', 'E': '5'}
|
||||
items2 = dict(zip('ABCDE', range(1, 10)))
|
||||
print(items2) # {'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5}
|
||||
|
||||
# 用字典生成式语法创建字典
|
||||
items3 = {x: x ** 3 for x in range(1, 6)}
|
||||
print(items3) # {1: 1, 2: 8, 3: 27, 4: 64, 5: 125}
|
||||
```
|
||||
|
||||
想知道字典中一共有多少组键值对，仍然是使用`len`函数；如果想对字典进行遍历，可以用`for`循环，但是需要注意，`for`循环只是对字典的键进行了遍历，不过没关系，在讲完字典的运算后，我们可以通过字典的键获取到和这个键对应的值。
|
||||
|
||||
```Python
|
||||
person = {'name': '王大锤', 'age': 55, 'weight': 60, 'office': '科华北路62号'}
|
||||
print(len(person)) # 4
|
||||
for key in person:
|
||||
print(key)
|
||||
```
|
||||
|
||||
### 字典的运算
|
||||
|
||||
对于字典类型来说，成员运算和索引运算肯定是最为重要的，前者可以判定指定的键在不在字典中，后者可以通过键获取对应的值或者向字典中加入新的键值对。值得注意的是，字典的索引不同于列表的索引，列表中的元素因为有属于自己有序号，所以列表的索引是一个整数；字典中因为保存的是键值对，所以字典的索引是键值对中的键，通过索引操作可以修改原来的值或者向字典中存入新的键值对。需要**特别提醒**大家注意的是，**字典中的键必须是不可变类型**，例如整数（`int`）、浮点数（`float`）、字符串（`str`）、元组（`tuple`）等类型的值；显然，列表（`list`）和集合（`set`）是不能作为字典中的键的，当然字典类型本身也不能再作为字典中的键，因为字典也是可变类型，但是字典可以作为字典中的值。关于可变类型不能作为字典中的键的原因，我们在后面的课程中再为大家详细说明。这里，我们先看看下面的代码，了解一下字典的成员运算和索引运算。
|
||||
|
||||
```Python
|
||||
person = {'name': '王大锤', 'age': 55, 'weight': 60, 'office': '科华北路62号'}
|
||||
# 检查name和tel两个键在不在person字典中
|
||||
print('name' in person, 'tel' in person) # True False
|
||||
# 通过age修将person字典中对应的值修改为25
|
||||
if 'age' in person:
|
||||
person['age'] = 25
|
||||
# 通过索引操作向person字典中存入新的键值对
|
||||
person['tel'] = '13122334455'
|
||||
person['signature'] = '你的男朋友是一个盖世垃圾，他会踏着五彩祥云去赢取你的闺蜜'
|
||||
print('name' in person, 'tel' in person) # True True
|
||||
# 检查person字典中键值对的数量
|
||||
print(len(person)) # 6
|
||||
# 对字典的键进行循环并通索引运算获取键对应的值
|
||||
for key in person:
|
||||
print(f'{key}: {person[key]}')
|
||||
```
|
||||
|
||||
需要注意，在通过索引运算获取字典中的值时，如指定的键没有在字典中，将会引发`KeyError`异常。
|
||||
|
||||
### 字典的方法
|
||||
|
||||
字典类型的方法基本上都跟字典的键值对操作相关，可以通过下面的例子来了解这些方法的使用。例如，我们要用一个字典来保存学生的信息，我们可以使用学生的学号作为字典中的键，通过学号做索引运算就可以得到对应的学生；我们可以把字典中键对应的值也做成一个字典，这样就可以用多组键值对分别存储学生的姓名、性别、年龄、籍贯等信息，代码如下所示。
|
||||
|
||||
```Python
|
||||
# 字典中的值又是一个字典(嵌套的字典)
|
||||
students = {
|
||||
1001: {'name': '狄仁杰', 'sex': True, 'age': 22, 'place': '山西大同'},
|
||||
1002: {'name': '白元芳', 'sex': True, 'age': 23, 'place': '河北保定'},
|
||||
1003: {'name': '武则天', 'sex': False, 'age': 20, 'place': '四川广元'}
|
||||
}
|
||||
|
||||
# 使用get方法通过键获取对应的值，如果取不到不会引发KeyError异常而是返回None或设定的默认值
|
||||
print(students.get(1002)) # {'name': '白元芳', 'sex': True, 'age': 23, 'place': '河北保定'}
|
||||
print(students.get(1005)) # None
|
||||
print(students.get(1005, {'name': '无名氏'})) # {'name': '无名氏'}
|
||||
|
||||
# 获取字典中所有的键
|
||||
print(students.keys()) # dict_keys([1001, 1002, 1003])
|
||||
# 获取字典中所有的值
|
||||
print(students.values()) # dict_values([{...}, {...}, {...}])
|
||||
# 获取字典中所有的键值对
|
||||
print(students.items()) # dict_items([(1001, {...}), (1002, {....}), (1003, {...})])
|
||||
# 对字典中所有的键值对进行循环遍历
|
||||
for key, value in students.items():
|
||||
print(key, '--->', value)
|
||||
|
||||
# 使用pop方法通过键删除对应的键值对并返回该值
|
||||
stu1 = students.pop(1002)
|
||||
print(stu1) # {'name': '白元芳', 'sex': True, 'age': 23, 'place': '河北保定'}
|
||||
print(len(students)) # 2
|
||||
# stu2 = students.pop(1005) # KeyError: 1005
|
||||
stu2 = students.pop(1005, {})
|
||||
print(stu2) # {}
|
||||
|
||||
# 使用popitem方法删除字典中最后一组键值对并返回对应的二元组
|
||||
# 如果字典中没有元素，调用该方法将引发KeyError异常
|
||||
key, value = students.popitem()
|
||||
print(key, value) # 1003 {'name': '武则天', 'sex': False, 'age': 20, 'place': '四川广元'}
|
||||
|
||||
# setdefault可以更新字典中的键对应的值或向字典中存入新的键值对
|
||||
# setdefault方法的第一个参数是键，第二个参数是键对应的值
|
||||
# 如果这个键在字典中存在，更新这个键之后会返回原来与这个键对应的值
|
||||
# 如果这个键在字典中不存在，方法将返回第二个参数的值，默认为None
|
||||
result = students.setdefault(1005, {'name': '方启鹤', 'sex': True})
|
||||
print(result) # {'name': '方启鹤', 'sex': True}
|
||||
print(students) # {1001: {...}, 1005: {...}}
|
||||
|
||||
# 使用update更新字典元素，相同的键会用新值覆盖掉旧值，不同的键会添加到字典中
|
||||
others = {
|
||||
1005: {'name': '乔峰', 'sex': True, 'age': 32, 'place': '北京大兴'},
|
||||
1010: {'name': '王语嫣', 'sex': False, 'age': 19},
|
||||
1008: {'name': '钟灵', 'sex': False}
|
||||
}
|
||||
students.update(others)
|
||||
print(students) # {1001: {...}, 1005: {...}, 1010: {...}, 1008: {...}}
|
||||
```
|
||||
|
||||
跟列表一样，从字典中删除元素也可以使用`del`关键字，在删除元素的时候如果指定的键索引不到对应的值，一样会引发`KeyError`异常，具体的做法如下所示。
|
||||
|
||||
```Python
|
||||
person = {'name': '王大锤', 'age': 25, 'sex': True}
|
||||
del person['age']
|
||||
print(person) # {'name': '王大锤', 'sex': True}
|
||||
```
|
||||
|
||||
### 字典的应用
|
||||
|
||||
我们通过几个简单的例子来讲解字典的应用。
|
||||
|
||||
**例子1：**输入一段话，统计每个英文字母出现的次数。
|
||||
|
||||
```Python
|
||||
sentence = input('请输入一段话: ')
|
||||
counter = {}
|
||||
for ch in sentence:
|
||||
if 'A' <= ch <= 'Z' or 'a' <= ch <= 'z':
|
||||
counter[ch] = counter.get(ch, 0) + 1
|
||||
for key, value in counter.items():
|
||||
print(f'字母{key}出现了{value}次.')
|
||||
```
|
||||
|
||||
**例子2**：在一个字典中保存了股票的代码和价格，找出股价大于100元的股票并创建一个新的字典。
|
||||
|
||||
> **说明**：可以用字典的生成式语法来创建这个新字典。
|
||||
|
||||
```Python
|
||||
stocks = {
|
||||
'AAPL': 191.88,
|
||||
'GOOG': 1186.96,
|
||||
'IBM': 149.24,
|
||||
'ORCL': 48.44,
|
||||
'ACN': 166.89,
|
||||
'FB': 208.09,
|
||||
'SYMC': 21.29
|
||||
}
|
||||
stocks2 = {key: value for key, value in stocks.items() if value > 100}
|
||||
print(stocks2)
|
||||
```
|
||||
|
||||
### 简单的总结
|
||||
|
||||
Python程序中的字典跟现实生活中字典非常像，允许我们**以键值对的形式保存数据**，再**通过键索引对应的值**。这是一种非常**有利于数据检索**的数据类型，底层原理我们在后续的课程中再研究。再次提醒大家注意，**字典中的键必须是不可变类型**，字典中的值可以是任意类型。
|
||||
|
||||
> **温馨提示**：大家如果觉得这个专栏还不错，**一定记得点赞收藏哟**！
|
||||
Loading…
Reference in New Issue