Python3 学习笔记

基本规则

大小写

Python 是大小写敏感的。

代码块

代码块通过缩进创建。在同一个代码块中，各行代码的缩进量必须相同。

注释

使用#字符表明该符号至行尾的所有内容为注释。

变量

命名规则：

变量名称以下划线或字母开头。
变量名称只能包含下划线、字母、数字。
变量名称不能是 Python 关键字。

赋值

序列解包

1
x, y = 1, 2     # x: 1  y: 2
2
x, y = y, x     # x: x  y: 1
3

4
info = {
5
    'name': 'Gumby',
6
    'age': 42
7
}
8
key, value = info.popitem()     # key: 'age'    value: 42
9

10
first, second, *rest = (1, 2, 3, 4, 5)      # first: 1  second: 2   rest: [3, 4, 5]
11
first, *middle, last = (1, 2, 3, 4, 5)      # first: 1  middle: [2, 3, 4]   last: 5

链式赋值

1
x = y = somefunction()

等价：

1
y = somefunction()
2
x = y

不等价：

1
y = somefunction()
2
x = somefunction()

运算符

算术运算符

+：加。
-：减。
*：乘。
**：幂。
/：除。
//：商。
%：余。

比较运算符

==：相等。
!=：不相等。
>：大于。
>=：大于等于。
<：小于。
<=：小于等于。

赋值运算符

=
+=
-=
*=
/=
:=：用于在表达式内部直接赋值。

逻辑运算符

and：与。
or：或。
not：非。

位运算符

&：与。
|：或。
^：异或。
~：取反。
<<：左移。
>>：右移。

成员运算符

in：包含。
not in：不包含。

身份运算符

is：相同。
is not：不相同。

作用域

作用域规则：

全局作用域内的代码不能访问局部变量。
局部作用域内的代码可以访问全局变量。
- 使用global关键字。
不同局部作用域内的代码不能互相访问。

数据结构

Python 支持一种数据结构的基本概念，名为容器。容器基本上就是可包含其他对象的对象。两种主要的容器是序列和映射。在序列中，每个元素都有编号；在映射中，每个元素都有名称。还有一种既不是序列也不是映射的容器，它就是集合。

通用序列操作

索引

序列中的所有元素都有编号————从 0 开始递增。若使用负数索引时，Python 将从右往左数，因此 -1 是最后一个元素的位置。

1
greeting = 'Hello'
2
greeting[0]     # 'H'
3
greeting[-5]    # 'H'

切片

使用切片访问特定范围内的元素：

1
tag = '<a href="http://www.python.org">Python Website</a>'
2
tag[9:30]       # 'http://www.python.org'
3
tag[32:-4]      # 'Python Website'
4
tag[:32]        # '<a href="http://www.python.org">'
5
tag[-4:]        # '</a>'
6
tag[:]          # '<a href="http://www.python.org">Python Website</a>'

切片有一个可选参数是步长，默认值为 1。步长为正数，从左往右提取元素；步长为负数，从右往左提取元素。步长不能为 0。

1
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
2
numbers[::2]    # [0, 2, 4, 6, 8]
3
numbers[::-2]   # [9, 7, 5, 3, 1]

拼接

使用+运算符拼接序列：

1
[1, 2, 3] + [4, 5, 6]   # [1, 2, 3, 4, 5, 6]

重复

使用*运算符重复序列：

1
['Python'] * 3     # ['Python', 'Python', 'Python']

成员资格

使用in运算符检查特定的值是否包含在序列中：

1
permissions = 'rw'
2
'w' in permissions  # True
3
'x' in permissions  # False

列表

删除元素

使用del运算符删除元素：

1
names = ['Alice', 'Beth', 'Cecil']
2
del names[1]    # names: ['Alice', 'Cecil']

给切片赋值

使用切片赋值替换不同长度的序列：

1
name = list('Perl')         # name: ['P', 'e', 'r', 'l']
2
name[1:] = list('ython')    # name: ['P', 'y', 't', 'h', 'o', 'n']

使用切片赋值插入元素：

1
numbers = [1, 5]
2
numbers[1:1] = [2, 3, 4]    # numbers: [1, 2, 3, 4, 5]

使用切片赋值删除元素：

1
numbers = [1, 2, 3, 4, 5]
2
numbers[1:4] = []           # numbers: [1, 5]

append 方法

使用append方法将一个对象附加到列表末尾：

1
versions = [2, 3]
2
versions.append(4)  # versions: [2, 3, 4]

clear 方法

使用clear方法清空列表内容：

1
versions = [2, 3]
2
versions.clear()    # versions: []

copy 方法

使用copy方法复制列表：

1
a_list = [1, 2, 3]
2
b_list = a_list.copy()

与=运算符的区别：

1
a_list = [1, 2, 3]
2

3
b_list = a_list.copy()
4
b_list[1] = 4           # a_list: [1, 2, 3]     b_list: [1, 4, 3]
5

6
b_list = a_list
7
b_list[1] = 4           # a_list: [1, 4, 3]     b_list: [1, 4, 3]

注意：copy方法执行的是浅复制。

1
a_list = [1, 2, [3]]
2

3
b_list = a_list.copy()
4
b_list[2][0] = 4        # a_list: [1, 2, [4]]   b_list: [1, 2, [4]]

count 方法

使用count方法计算指定元素在列表中的出现次数：

1
[1, 1, 2, 1, 2, 1].count(1)     # 4

extend 方法

使用extend方法将多个值附加到列表末尾：

1
extend_list = [1, 2, 3]
2
extend_list.extend([4, 5, 6])   # extend_list: [1, 2, 3, 4, 5, 6]

与append方法的区别：

1
append_list = [1, 2, 3]
2
append_list.append([4, 5, 6])   # append_list: [1, 2, 3, [4, 5, 6]]

index 方法

使用index方法查找指定值的对象在列表中首次出现的位置：

1
x = [1, 9, 9, 1, 1, 1, 2, 1]
2
x.index(9)                      # 1

insert 方法

使用insert方法将一个对象插入到列表：

1
numbers = [0, 1, 2, 3, 5, 6]
2
numbers.insert(4, 'four')       # numbers: [0, 1, 2, 3, 'four', 5, 6]

pop 方法

使用pop方法将一个元素从列表中删除，并返回该元素：

1
numbers = [5, 4, 3, 2, 1, 0]
2
ret = numbers.pop(-1)           # ret: 0    numbers: [5, 4, 3, 2, 1]
3
ret = numbers.pop(2)            # ret: 3    numbers: [5, 4, 2, 1]
4
ret = numbers.pop(0)            # ret: 5    numbers: [4, 2, 1]
5
ret = numbers.pop()             # ret: 1    numbers: [4, 2]

remove 方法

使用remove方法将指定值的对象从列表中首次出现的位置删除：

1
x = [1, 9, 9, 1, 1, 1, 2, 1]
2
x.remove(9)                     # x: [1, 9, 1, 1, 1, 2, 1]

reverse 方法

使用reverse方法将列表中的元素按相反的顺序排列：

1
numbers = [5, 4, 3, 2, 1, 0]
2
numbers.reverse()               # numbers: [0, 1, 2, 3, 4, 5]

sort 方法

使用sort方法将列表中的元素排序，该方法有两个可选参数，key参数为排序指定一个函数，reverse参数指定是否要用相反的顺序排列。

1
names = ['Beatrice', 'Clara', 'Amelia']
2
names.sort()                                # names: ['Amelia', 'Beatrice', 'Clara']
3
names.sort(key=len)                         # names: ['Clara', 'Amelia', 'Beatrice']
4
names.sort(reverse=True)                    # names: ['Clara', 'Beatrice', 'Amelia']
5
names.sort(key=len, reverse=True)           # names: ['Beatrice', 'Amelia', 'Clara']

元组

元组（用()表示）与列表（用[]表示）的区别：元组是不可修改的。

字符串

所有的通用序列操作都适用于字符串。因为字符串是不可修改的，所以元素赋值和切片赋值对于字符串来说是非法的。

设置字符串格式

替换字段没有名称：

1
'{3} {2} {1} {0} {3} {2}'.format('not', 'or', 'be', 'to')   # 'to be or not to be'

替换字段有名称：

1
'{name} is approximately {value:.2f}'.format(name='pi', value=3.1415926)    # 'pi is approximately 3.14'

center 方法

使用center方法在字符串两边填充字符：

1
'Centered Title'.center(20, '*')    # '***Centered Title***'

find 方法

使用find方法在字符串中查找子串：

1
'Welcome to China'.find('China')    # 11
2
'Welcome to Greece'.find('Rome')    # -1

find方法还有两个可选参数用于指定查找位置：

1
'How are you'.find('you', 0, -1)    # -1

join 方法

使用join方法合并序列中的元素：

1
'/'.join(['usr', 'bin', 'env'])     # 'usr/bin/env'

lower 方法

使用lower方法返回字符串的小写版本：

1
'KEEP SMILING EVERY DAY'.lower()    # 'keep smiling every day'

replace 方法

使用replace方法替换字符串中的子串为指定子串：

1
'/home/u1'.replace('u1', 'u2')      # '/home/u2'

split 方法

使用split方法拆分字符串为序列：

1
'/usr/bin/env'.split('/')           # ['', 'usr', 'bin', 'env']

strip 方法

使用strip方法删除字符串首尾的指定子串：

1
'***Centered Title***'.strip('*')   # 'Centered Title'

translate 方法

使用translate方法替换字符串中的字符为指定字符：

1
# '1B3D5F7H9'
2
'ABCDEFGHIJKLMN'.translate(
3
    str.maketrans(
4
        'ACEGI',
5
        '13579',
6
        'JKLMN'
7
    )
8
)

str.maketrans方法为translate方法生成“转换表”。前两个参数为等长字符串，位置一一对应；第三个参数为额外字符串，额外字符串中的字符与 None 进行对应。

字典

成员资格

使用in运算符检查特定的键是否包含在字典中：

1
info = {
2
    'name': 'Gumby',
3
    'age': 42
4
}
5
'name' in info          # True
6
'phone' in info         # False

clear 方法

使用clear方法删除字典的所有键值对：

1
info = {
2
    'name': 'Gumby',
3
    'age': 42
4
}
5
info.clear()            # info: {}

copy 方法

使用copy方法复制字段：

1
a_dict = {
2
    'name': 'Gumby',
3
    'age': 42
4
}
5
b_dict = a_dict.copy()

注意：copy方法执行的是浅复制。

fromkeys 方法

使用fromkeys方法从一个字典创建具有相同键的新字典：

1
{}.fromkeys({
2
    'name': 'Gumby',
3
    'age': 42
4
})                      # {'name': None, 'age': None}

fromkeys方法还有一个可选参数用于指定默认值：

1
{}.fromkeys({
2
    'name': 'Gumby',
3
    'age': 42
4
}, '(unknown)')         # {'name': '(unknown)', 'age': '(unknown)'}

get 方法

使用get方法安全访问字典：

1
info = {
2
    'name': 'Gumby',
3
    'age': 42
4
}
5
info['phone']           # KeyError: 'phone'
6
info.get('phone')       # None

get方法还有一个可选参数用于指定默认值：

1
info = {
2
    'name': 'Gumby',
3
    'age': 42
4
}
5
info.get('phone', 'N/A')    # 'N/A'

items 方法

使用items方法返回一个包含字典所有键值对的字典视图：

1
info = {
2
    'name': 'Gumby',
3
    'age': 42
4
}
5
info.items()            # dict_items([('name', 'Gumby'), ('age', 42)])

keys 方法

使用keys方法返回一个包含字典所有键的字典视图：

1
info = {
2
    'name': 'Gumby',
3
    'age': 42
4
}
5
info.keys()             # dict_keys(['name', 'age'])

pop 方法

使用pop方法将一个键值对从字典中删除，并返回该键值对的值：

1
info = {
2
    'name': 'Gumby',
3
    'age': 42
4
}
5
ret = info.pop('age')   # ret: 42   info: {'name': 'Gumby'}

setdefault 方法

使用setdefault方法获取并指定键的默认值：

1
info = {
2
    'name': 'Gumby',
3
    'age': 42
4
}
5
ret = info.setdefault('age', 1)         # ret: 42       info: {'name': 'Gumby', 'age': 42}
6
ret = info.setdefault('phone', 1234)    # ret: 1234     info: {'name': 'Gumby', 'age': 42, 'phone': 1234}

update 方法

使用update方法从一个字典更新该字典：

1
info = {
2
    'name': 'Gumby',
3
    'age': 42
4
}
5
info.update({
6
    'name': 'Beth',
7
    'phone': 1234
8
})                      # info: {'name': 'Beth', 'age': 42, 'phone': 1234}

values 方法

使用values方法返回一个包含字典所有值的字典视图：

1
info = {
2
    'name': 'Gumby',
3
    'friend': 'Gumby'
4
}
5
info.values()           # dict_values(['Gumby', 'Gumby'])

控制结构

布尔值

用作布尔表达式时，下列值为假：

False
None
0
''
()
[]
{}

if

1
if condition1:
2
    pass
3
elif condition2:
4
    pass
5
else:
6
    pass

while

1
while condition:
2
    pass

for

1
for index in range(len(a_list)):
2
    pass
3

4
for index, value in enumerate(str_list):
5
    pass
6

7
for key, value in a_dict.items():
8
    pass

break

使用break关键字结束当前控制结构。

continue

使用continue关键字跳过当前循环迭代的剩余部分。

pass

使用pass关键字作为代码块占位符。

函数

使用def关键字定义函数。

参数

在调用函数时，Python 将函数调用中的实参关联到函数定义中的形参。

位置实参：基于实参的顺序关联形参。使用*args形式表示函数接收任意数量的位置实参。
关键字实参：基于实参的键值对关联形参。使用**kwargs形式表示函数接收任意数量的关键字实参。

可以给形参指定默认值。在形参列表中，先列出没有默认值的形参，后列出有默认值的形参。

返回值

使用return关键字传递返回值。

类

使用class关键字定义类。

self：实例对象自身。
super()：父类代理对象。
__init__()：构造函数。

继承

1
class MyClass(BaseClass):
2

3
    def __init__(self):
4
        super().__init__()

异常

捕获异常

1
try:
2
    pass
3
except Exception as e:
4
    pass
5
else:
6
    pass
7
finally:
8
    pass

引发异常

使用raise关键字引发异常。

断言

使用assert关键字设置断言。

模块

`name`

运行 Python 脚本文件时，内置变量__name__表明该脚本文件的运行方式：

作为主程序运行时，__name__被赋值为__main__。
作为模块被导入时，__name__被赋值为模块名。

导入方式

以module.function为例：

导入方式	语法示例	调用方式	说明
导入整个模块	`import module`	`module.function()`	可以使用`as`关键字定义别名。
导入指定成语	`from module import function`	`function`
导入全部	`from module import *`	`function`	慎用。

包管理

在 Python 中，包（package）就是一个包含__init__.py文件的文件夹。

其他

关键字

1
import keyword
2

3
keyword.kwlist

内置函数

1
import builtins
2

3
[
4
    name for name, obj in builtins.__dict__.items()
5
    if callable(obj) and (name[0].islower() or name == '__import__')
6
]