【Python全栈系列课程（一）】Python基础入门

老夏

第四章 编码规范
    4.4 代码排版

一、空行
（1）import语句块前后保留两个空行，示例代码如下，其中①②处和③④处是两个空行

1. # Copyright 2007 Google, Inc. All Rights Reserved.
   
2. # Licensed to PSF under a Contributor Agreement.
   
3. 
   
4. """Abstract Base Classes (ABCs) according to PEP 3119."""
   
5. ①
   
6. ②
   
7. from _weakrefset import WeakSet
   
8. ③
   
9. ④

复制代码

（2）函数声明之前、后保留两个空行，示例代码如下，其中①②处是两个空行

1. from _weakrefset import WeakSet
   
2. ①
   
3. ②
   
4. def abstractmethod(funcobj):
   
5.     funcobj.__isabstractmethod__ = True
   
6.     return funcobj

复制代码

（3）类声明之前、后保留两个空行，示例代码如下，其中①②处是两个空行

1. ①
   
2. ②
   
3. class abstractclassmethod(classmethod):
   
4.     __isabstractmethod__ = True
   
5. 
   
6.     def __init__(self, callable):
   
7.         callable.__isabstractmethod__ = True
   
8.         super().__init__(callable)

复制代码

（4）方法声明之前保留一个空行，示例代码如下，其中①处是一个空行

1. class abstractclassmethod(classmethod):
   
2.     __isabstractmethod__ = True
   
3.     ①
   
4.     def __init__(self, callable):
   
5.         callable.__isabstractmethod__ = True
   
6.         super().__init__(callable)

复制代码

（5）两个逻辑代码块之间应该保留一个空行，示例代码如下，其中①处是一个空行

1. def convert_timestamp(val):
   
2.         datepart, timepart = val.split(b" ")
   
3.         year, month, day = map(int, datepart.split(b"-"))
   
4.         timepart_full = timepart.split(b".")
   
5.         hours, minutes, seconds = map(int, timepart_full[0].split(b":"))
   
6.         if len(timepart_full) == 2:
   
7.             microseconds = int('{:0<6.6}'.format(timepart_full[1].decode()))
   
8.         else:
   
9.             microseconds = 0
   
10.         ①
    
11.         val = datetime.datetime(year, month, day, hours, minutes, seconds, microseconds)
    
12.         return val

复制代码

二、空格
        可在PyCharm中通过使用【ctrl+alt+l】进行代码格式化。
（1）赋值符号前后各有一个空格

1. a = 10
   
2. c = 10

复制代码

（2）所有的二元运算符都应该使用空格与操作数分开

1. a += c + d

复制代码

（3）算法运算符取反"-"和运算符取反"~"与操作数之间不要有空格

1. a = -b
   
2. y = ~b

复制代码

（4）括号内不要有空格，Python中括号包括：小括号"()"、中括号"[]"和大括号"{}"

1. # 推荐
   
2. doque(cat[1], {dogs: 2}, [])
   
3. # 不推荐
   
4. doque(cat[ 1 ], { dogs: 2 }, [  ])

复制代码

（5）不要在逗号、分号、冒号前面有空格，而是要在他们后面有一个空格，除非该符号已经是行尾了

1. # 推荐
   
2. if x == 88:
   
3.     print x, y
   
4. x, y = y, x
   
5. # 不推荐
   
6. if x == 88 :
   
7.     print x , y
   
8. x , y = y , x

复制代码

（6）参数列表、索引或切片的左括号前不应有空格

1. # 推荐
   
2. doque(1)
   
3. dogs['key'] = list[index]
   
4. # 不推荐
   
5. doque (1)
   
6. dict ['key'] = list [index]

复制代码

三、断行
        一行代码中最多有79个字符。而对于文档注释和多行注释，一行最多72有个字符，但是，如果注释中包含URL地址，则可以不受这个限制，否则，超过规定字符数则需要断行，我们可以依据下面的一般规范进行断行。
（1）在逗号后面断开

1. bar = long_function_name(name1, name2,
   
2.                          name3, name4)
   
3. def long_function_name(var_one, var_two,
   
4.                        var_three, var_four):

复制代码

（2）在运算符前面断开

1. name1 = name2 * (name3 + name4
   
2.                          - name5) + 4 * name6

复制代码

（3）尽量不要使用续行符\，当有括号（包括：大括号、中括号和小括号）则在括号中断开，这样可以不使用续行符

1. def long_function_name(var_one, var_two,
   
2.                        var_three, var_four):
   
3.     return var_one + var_two + var_three \ ①
   
4.            + var_four
   
5. name1 = name2 * (name3 + name4
   
6.                          - name5) + 4 * name6
   
7. bar = long_function_name(name1, name2,
   
8.                          name3, name4)
   
9. foo = {
   
10.     long_dictionary_key: name1 + name2
    
11.                          - name3 + name4 - name5
    
12. }
    
13. c = list[name2 * name3
    
14.       + name4 - name5 + 4 * name6]

复制代码

        上述代码第①行使用了续航符进行断行，其他的断行都是在括号中实现的，所以省略了续行符。有时为了省略续行符，会将表达式用小括号包裹起来，如下代码所示：

1. def long_function_name(var_one, var_two,
   
2.                        var_three, var_four):
   
3.     return (var_one + var_two + var_three
   
4.            + var_four)

复制代码

老夏

第五章 变量类型
    5.1 整型

        整数的类型就是整型，在pthon中可以进行二进制、八进制和十六进制输入，二进制数以0b或0B为前缀，八进制数以0o或0O为前缀，十六进制数以0x或0X为前缀。

1. num=100
   
2. print(num)
   
3. # 二进制
   
4. num=0b11100
   
5. print(num)
   
6. num=123456789123456789
   
7. # Python中可以正常输出，但在PHP中则以科学计数法的形式输出。
   
8. print(num)

复制代码

老夏

第五章 变量类型
    5.2 浮点型

        小数的类型就是浮点型。

1. num=100.55
   
2. print(num)

复制代码

老夏

第五章 变量类型
    5.3 复数类型

        我们把形如z=a+bj的数称为复数，其中a和b均为实数，我们称a为实部，称b为虚部，称j为虚数单位。当虚部等于零时，这个复数可以视为实数；当z的虚部不等于零时，实部等于零时，称z为纯虚数。

1. num1=2+3j
   
2. num2=1+2j
   
3. print(num1+num2)
   
4. print(type(num1))

复制代码

老夏

第五章 变量类型
    5.4 布尔型

        注意，Python中布尔型值的真和假的首字母一定要大写，否则报错。

1. bl=True
   
2. print(bl)

复制代码

老夏

第五章 变量类型
    5.5 序列

一、序列特点
        所谓序列，指的是一块可存放多个值的连续内存空间，这些值按一定顺序排列，可通过每个值所在位置的编号（即索引）访问它们。

二、序列类型
        字符串、列表、元组。

三、序列通用操作
        下面以序列中的列表举例，介绍序列的相关操作。
（1）索引操作

1. lt=[1,3,5,7]
   
2. # 正索引，正索引的索引序号为0,1,2,3,4
   
3. print(lt[0])
   
4. # 负索引，负索引的索引序号为-5,-4,-3,-2,-1
   
5. print(lt[-2])

复制代码

（2）加和乘操作

1. lt=[1,3,5,7]
   
2. # 相当于重复
   
3. print(lt*3)
   
4. # 相当于追加
   
5. print(lt+[2,4,6])

复制代码

（3）切片（分片）操作

1. lt=[1,3,5,7,9,11,13,15]
   
2. # 从1开始到3，但是不包含3
   
3. print(lt[1:3])
   
4. # 默认从0开始
   
5. print(lt[:3])
   
6. # 从1开始到结尾
   
7. print(lt[1:])
   
8. # 默认取全部元素
   
9. print(lt[:])
   
10. # 从1开始，按步长为2，取到7，但不包含7
    
11. print(lt[1:7:2])

复制代码

老夏

第五章 变量类型
    5.6 字符串

一、创建字符串
        在Python中，我们可以通过使用单引号或双引号包裹字符来创建字符串。在Python3.x版本中，字符串是以Unicode编码的，也就是说，Python的字符串支持多种语言。

1. str='hello oldxia'
   
2. print(str)

复制代码

二、字符串遍历
        我们可以通过使用for语句对字符串进行遍历。

1. str='hello oldxia'
   
2. for s in str:
   
3.     print(s)

复制代码

三、访问字符串
（1）通过下标索引访问

1. str='hello oldxia'
   
2. # 访问下表索引为1的字符
   
3. print(str[1])

复制代码

（2）通过切片访问

1. str='hello oldxia'
   
2. # 从下表索引1开始到下标索引6，不包含下标索引7
   
3. print(str[1:7])

复制代码

四、字符串操作
（1）字符串连接
        我们可以通过使用+号对多个字符串进行连接。

1. str='hello oldxia'
   
2. print(str+'!!!')

复制代码

（2）去除字符串两边空格
        我们可以通过是strip()方法移除字符串头尾指定的字符，默认为移除空格或换行符。注意，该方法只能删除开头或结尾的字符，不能删除中间部分的字符。

1. str='  hello oldxia  '
   
2. # 默认移除空格
   
3. print(str.strip())
   
4. str='666hello666'
   
5. # 移除指定的字符6
   
6. print(str.strip('6'))

复制代码

（3）计数
        我们可以通过使用count()方法统计字符串里某个字符出现的次数。

1. str='hello oldxia'
   
2. # 统计l出现的次数
   
3. print(str.count('l'))

复制代码

（4）查找字符
        我们可以通过使用find()方法检测字符串中是否包含指定的子字符串，如果包含则返回子字符串开始的索引，否则返回-1。

1. s='There is a string accessing example.'
   
2. print(len(s))
   
3. print(s[16])
   
4. # 查找r第一次出现的位置
   
5. print(s.find('r'))
   
6. print(s.find('ing'))
   
7. # 查找不到返回-1
   
8. print(s.find('ingg'))
   
9. # 从第15个开始，查找e
   
10. print(s.find('e',15))

复制代码

五、原始字符串
        原始字符串，即所有的字符串都是直接按照字面的意思来使用，在Python中为了使反斜杠和元字符取消字符的特殊含义，需要在字符前添加反斜杠，或在字符串的第一个引号前加上字母r。

1. # 等价于s='hello \\n world'
   
2. s=r'hello \n world'  
   
3. print(s)

复制代码

六、长字符串
        如果需要书写非常长的字符串，即需要跨多行，这时可以使用三个引号代替普通引号。
        此种引用方式，可以在长字符串之间同时使用单引号和双引号，而不需要使用反斜线进行转义。

1. # 如果使用单个或两个引号会报错
   
2. s='''hello  
   
3. 'this is wecoding'
   
4. world'''   
   
5. print(s)

复制代码

        当然，普通字符串也可以跨行，只需要在一行之中的最后一个字符后添加反斜线，那么换行符本身就被"转义"了，其换行的原本意义也就被忽略了。

1. s='hello \
   
2. world'
   
3. print(s)

复制代码

七、字符串格式化
        我们可以通过四种方式对字符串进行格式化，分别为：%格式符；使用Template类；使用format()方法；使用f-Strings。
（1）%格式符
        在%格式符左侧放置一个需要进行格式化输出的字符串，这个字符串中带有一个或多个字符串格式化符号，这些字符串格式化符号都是以%开头，如%s、%d或%f，而在%格式符的右侧放置一个由小括号包裹的变量，这些变量必须与%格式符左侧的字符串格式化符号一一对应。
        字符串格式化符号如下表：

符号	描述
%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%u	格式化无符号整型
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e，用科学计数法格式化浮点数
%g	%f和%e的简写
%G	%F和%E的简写
%p	用十六进制数格式化变量的地址

1. name='oldxia'
   
2. age=8
   
3. print('name:%s age:%o'%(name,age))
   
4. salary=12366.7893
   
5. # 指定小数精度，保留小数点后两位
   
6. print('月薪为:%.2f'%(salary))

复制代码

（2）使用format()函数
        我们可以通过使用format()函数来格式化输出字符串，其基本语法是通过{}和:来代替以前的%，format()函数可以接受不限个参数，并且位置也可以不按顺序。

1. name='oldxia'
   
2. age=35
   
3. # 指定顺序
   
4. print('name:{} age:{}'.format(name,age))
   
5. # 指定位置
   
6. print('name:{1} age:{0}'.format(age,name))
   
7. # 指定变量
   
8. print('name:{name} age:{age}'.format(name='夏正东',age=35))
   
9. salary=12366.7893
   
10. # 指定小数精度，保留小数点后两位
    
11. print('月薪为:{0:.2f}'.format(salary))
    
12. # 百分比
    
13. num=0.25
    
14. print('百分比为:{0:.2%}'.format(num))

复制代码

（3）使用f-string
        f-string是Python3.6新引入的一种字符串格式化方法，主要目的是使格式化字符串的操作更加简便。f-string在形式上是以f或F修饰符开头的的字符串，f-string在功能方面不逊于传统的%格式符和format()函数，同时性能又优于二者，且使用起来也更加简洁明了，因此对于Python3.6及以后的版本，推荐使用f-string进行字符串格式化。

1. name='夏正东'
   
2. age=35
   
3. def getsalary():
   
4.     return 10329.788
   
5. # 占位符类型可以为函数
   
6. str = f"名字：{name}，年龄：{age}岁，薪水：{getsalary()}元"
   
7. print(str)
   
8. class Person:
   
9.     def __init__(self):
   
10.         self.name = '夏正东'
    
11.         self.age = 35
    
12.         self.salary = 10329.788
    
13.     def getsalary(self):
    
14.         return self.salary
    
15. person = Person()
    
16. # 占位符类型可以为对象，并且可以指定小数精度
    
17. str = f"名字：{person.name}，年龄：{person.age}岁，薪水：{person.getsalary():.2f}元"
    
18. print(str)

复制代码

（4）使用Template类
        我们可以通过使用Template类中的substitute方法来对字符串进行格式化输出。

1. from string import Template
   
2. # $为占位符
   
3. template1 = Template('我的姓名是$name，我的年龄是$age岁')
   
4. # substitute()方法中的参数名必须与要替换的占位符后的变量名相一致
   
5. print(template1.substitute(name = '夏正东',age = 30))
   
6. # 如果需要替换的值后是英文字符，可以使用大括号包裹需要替换的值
   
7. template2 = Template('${s}ay hello')
   
8. print(template2.substitute(s= 'Python'))
   
9. # 可以使用$转义$，即$表示$
   
10. template3 = Template('$dollar可对换￥$pounds')
    
11. print(template3.substitute(dollar=1,pounds=6.6))
    
12. template4 = Template('我的姓名是$name，我的年龄是$age岁')
    
13. # substitute()方法中也可以传递字典
    
14. data = {'name':'夏正东','age':30}
    
15. print(template4.substitute(data))

复制代码

老夏

第五章 变量类型
    5.7 列表

一、列表创建
        使用中括号将元素包裹，元素之间用逗号分隔，即可完成列表创建。

1. lt=[1,2,3,4,5]
   
2. print(lt)

复制代码

二、列表特点
        列表中的数据不需要具有相同的类型，并且列表的值是可以被修改的。

三、列表遍历

1. lt=[1,3,4,5,6,7]
   
2. for x in lt:
   
3.     print(x)

复制代码

四、列表操作
（1）访问列表
        我们可以通过使用索引的方式进行元素访问。

1. # 索引访问
   
2. tp=[1,4,3,2,5,6]
   
3. print(tp[2])

复制代码

（2）插入元素
        我们可以通过使用insert(i, x)方法往列表中插入指定元素，其中，参数i是要插入的索引；参数x是要插入的元素。

1. lt=[1,3,4,5]
   
2. lt.insert(1,7)
   
3. print(lt)

复制代码

（3）替换元素
        我们可以通过使用列表的下标索引进行赋值。

1. lt=[1,2,3,4,5]
   
2. print(lt[0])
   
3. lt[0]=100
   
4. print(lt)

复制代码

（4）追加元素
        追加元素分为追加单个元素和追加列表。其中，append()方法是追加单个元素；而+运算符或extend()方法则是追加一个列表。

1. lt=[1,3,4,5]
   
2. lt.append(7)
   
3. print(lt)
   
4. lt+=[8,9]
   
5. print(lt)
   
6. lt.extend(['hello','world'])
   
7. print(lt)

复制代码

（5）删除元素
        我们可以通过使用remove(x)方法进行指定元素的删除。其中，参数x是要删除的元素，如果x不存在，则会抛出异常。我们还可以通过使用pop(i)方法来进行指定元素的删除，其返回值是删除的元素，其中，参数i是要删除的索引，如果不填写索引，则默认删除最后一位的元素。

1. lt=[1,3,4,5]
   
2. lt.remove(4)
   
3. print(lt)
   
4. new_lt=lt.pop(1)
   
5. print(lt,new_lt)
   
6. new_lt=lt.pop()
   
7. print(lt,new_lt)

复制代码

（6）列表倒置
        我们可以通过使用reverse()方法将列表倒置。

1. lt=[1,3,4,5]
   
2. lt.reverse()
   
3. print(lt)

复制代码

（7）列表拷贝
        我们可以通过使用copy()方法拷贝列表。

1. lt=[1,3,4,5]
   
2. new_lt=lt.copy()
   
3. print(lt,new_lt)

复制代码

（8）清空列表中的所有元素
        我们可以通过使用clear()方法将列表中的元素清空。

1. lt=[1,3,4,5]
   
2. new_lt=lt.clear()
   
3. print(lt,new_lt)

复制代码

（9）查找元素索引
        我们可以通过使用index(x[,i[, j]])方法查找指定元素的索引，其中，参数x为要查找索引的元素，参数i是开始索引的位置，参数j是结束索引的位置，参数i和j可以默认不填写，该方法返回x第一次出现的索引位置。

1. lt=[1,3,4,5]
   
2. # 查找元素5的索引
   
3. new_lt=lt.index(5)
   
4. print(lt,new_lt)
   
5. lt=[1,3,4,5]
   
6. # 查找索引位置在0到2之间元素5的索引，因为没有元素5，所以报错
   
7. new_lt=lt.index(5,0,2)
   
8. print(lt,new_lt)

复制代码

（10）查找元素出现的次数
        我们可以通过使用count(x)方法查找指定元素出现的次数，其中，参数x为要查找出现次数的元素。

1. lt=[1,3,4,5,5,3,5]
   
2. new_lt=lt.count(3)
   
3. print(lt,new_lt)

复制代码

五、列表推导式
        列表推导式需要将推导式放到中括号中执行。
        列表推导式的格式：n_list=[x**2 for x in range(10) if x%2 == 0]，其中，"x**2"是输出表达式，"for x in range(10)"中的x是元素变量，range(10)是输入序列，"if x%2 ==0"是条件语句。

1. # 打印1到9之间偶数的平方
   
2. # 传统写法
   
3. n_list=[]
   
4. for n in range(1,10):
   
5.     if n%2==0:
   
6.         n_list.append(n**2)
   
7. print(n_list)
   
8. # 列表推导式
   
9. n_list=[x**2 for x in range(1,10) if x%2==0]
   
10. print(n_list)

复制代码

老夏

第五章 变量类型
    5.8 元组

一、元组创建
        创建元组可以直接使用逗号将元素分隔，或使用小括号将元素包裹，元素间使用逗号分隔，强烈推荐使用小括号将元素包裹。

1. # 使用小括号包裹方式创建元组
   
2. tp=(1,3,4,5,6)
   
3. print(tp)
   
4. # 使用逗号将元素分割方式创建元组
   
5. tp=1,3,5,7,9
   
6. print(tp)
   
7. # 此种方式创建的是元组
   
8. tp=1,
   
9. # 此种方式创建的是元组
   
10. tp=(1,)
    
11. # 此种方式创建的是整型
    
12. tp=(1)
    
13. print(type(tp))

复制代码

二、元组特点
        元组是一种不可变的序列，一旦创建，其内部的元素不可以被修改。

三、元组遍历

1. tp=('hello','world',2,5,6)
   
2. for x in tp:
   
3.     print(x)

复制代码

四、元组操作
（1）访问元组
        我们可以通过使用索引的方式进行元素访问。

1. # 索引访问
   
2. tp=(1,4,3,2,5,6)
   
3. print(tp[2])

复制代码

（2）修改元组
        由于元组是一种不可变的序列，所以其内部的元素不可以被修改。但是，我们可以通过使用del语句删除整个元组。

1. tp=(1,2,3,4,5)
   
2. tp[0]=100
   
3. # 此处报错，因为元组的值不可修改
   
4. print(tp)
   
5. del tp
   
6. # 此时的错误提示为，tp未定义，因为tp已经被删除
   
7. print(tp)

复制代码

（3）切片操作

1. tp=(1,4,3,2,5,6)
   
2. print(tp[2:5])

复制代码

（4）拆包操作

1. tp=('hello','world',3,4,5)
   
2. str1,str2,a,b,c=tp
   
3. print(str1,str2,a,b,c)
   
4. # 此时n为列表[3,4,5]
   
5. str1,str2,*n=tp
   
6. print(n)
   
7. # 拆包必须一一对应，如果有不需要的可以使用_代替
   
8. str1,str2,n1,_,n2=tp
   
9. print(n1,n2)

复制代码

五、元组推导式
        元组推导式需要将推导式放到小括号中执行，但与列表推导式不同的是，列表推导式得到的结果是一个列表，而元组推导式得到的是一个生成器对象，我们需要使用tuple()函数，for循环或者next()方法来获得新元组或新元素。

1. n_tuple=(x**2 for x in range(1,10) if x%2==0)
   
2. print(n_tuple)
   
3. # 使用tuple()函数
   
4. print(tuple(n_tuple))
   
5. # 使用for循环遍历
   
6. for num in n_tuple:
   
7.     print(num,end=',')
   
8. # 使用next()方法
   
9. print(n_tuple.__next__())
   
10. print(n_tuple.__next__())
    
11. print(n_tuple.__next__())

复制代码

老夏

第五章 变量类型
    5.9 字典

一、字典创建
        使用大括号将【键:值】对包裹，【键:值】对之间用逗号分隔，即可完成字典创建。

1. dc={'name1':'php','name2':'python','name3':'javascript'}
   
2. print(dc)

复制代码

二、字典访问
（1）下标（键）访问

1. dt={'name1':'val1','name2':'val2','name3':'val3'}
   
2. dt_item=dt['name1']
   
3. print(dt_item)

复制代码

（2）使用get()方法访问

1. dt={'name1':'val1','name2':'val2','name3':'val3'}
   
2. dt_item=dt.get('name1')
   
3. print(dt_item)
   
4. # 注意，如果键值不存在，则返回默认值。
   
5. dt={'name1':'val1','name2':'val2','name3':'val3'}
   
6. dt_item=dt.get('name4','hello python')
   
7. print(dt_item)

复制代码

（3）使用items()方法访问
        该方法返回字典的所有键值对，但是，此时的数据类型是dict_items，可以通过使用list()方法转化成列表。

1. dt={'name1':'val1','name2':'val2','name3':'val3'}
   
2. dt_item=dt.items()
   
3. print(dt_item)

复制代码

（4）使用keys()方法
        该方法返回字典的键，但是，此时的数据类型是dict_keys，可以通过使用list()方法转化成列表。

1. dt={'name1':'val1','name2':'val2','name3':'val3'}
   
2. dt_item=dt.keys()
   
3. print(dt_item)

复制代码

（5）使用values()方法
        该方法返回字典的值，但是，此时的数据类型是dict_values，可以通过使用list()方法转化成列表。

1. dt={'name1':'val1','name2':'val2','name3':'val3'}
   
2. dt_item=dt.values()
   
3. print(dt_item)

复制代码

三、字典遍历
（1）普通遍历

1. dt={'name1':'val1','name2':'val2','name3':'val3'}
   
2. for key in dt:
   
3.     print(key,dt[key])

复制代码

（2）使用items()方法加列表的拆包方式进行遍历

1. dt={'name1':'val1','name2':'val2','name3':'val3'}
   
2. for key,val in list(dt.items()):
   
3.     print(key,val)

复制代码

四、字典添加

1. dt={'name1':'val1','name2':'val2'}
   
2. dt['name3']='val3'
   
3. print(dt)

复制代码

五、字典替换

1. dt={'name1':'val1','name2':'val2'}
   
2. dt['name2']=123
   
3. print(dt)

复制代码

六、字典删除
        使用del语句删除字典中的元素。

1. dt={'name1':'val1','name2':'val2','name3':'val3'}
   
2. del dt['name2']
   
3. print(dt)

复制代码

        使用pop(key[,default])方法删除字典中的元素。

1. dt={'name1':'val1','name2':'val2','name3':'val3'}
   
2. new_dt=dt.pop('name2')
   
3. # 如果删除的字段不存在，并且给定默认值，则返回默认值
   
4. new_dt1=dt.pop('name4','no item')
   
5. print(dt,new_dt,new_dt1)

复制代码

        使用popitem()方法删除字典中的最后一个元素，该方法返回的数据类型是元组。

1. dt={'name1':'val1','name2':'val2','name3':'val3'}
   
2. new_dt=dt.popitem()
   
3. print(dt,new_dt)

复制代码

七、字典推导式
        字典推导式需要将推导式放到大括号中执行。

1. input_dt={'one':1,'two':2,'three':3}
   
2. output_dt={key:val for key,val in list(input_dt.items()) if val%2==0} print(output_dt)

复制代码

        如果不需要value值，则可以使用_来代替即可。

1. input_dt={'one':1,'two':2,'three':3}
   
2. output_dt={key for key,_ in input_dt.items()}
   
3. print(output_dt)

复制代码