此处的应用场景是python解释器的交互模式之下:

Do not laugh at me ! I’m REALLY a newbie!!!!

1
2
3

python -c command arg
python -m module arg
//创建新New—Item name（真实的名称） ItemType type（具体的类型）

忘掉了的

数字

除法运算 (/) 总是返回浮点数。如果要做 floor division 得到一个整数结果你可以使用 // 运算符；

Something New： Python 用 ** 运算符计算乘方 [1]： 交互模式下，上次输出的表达式会赋给变量 _。把 Python 当作计算器时，用该变量实现下一步计算更简单，例如：

1
2
3
4
5
6
7
8

tax = 12.5 / 100
price = 100.50
price * tax
12.5625
price + _
113.0625
round(_, 2)
113.06

除了 int 和 float，Python 还支持其他数字类型，例如 Decimal 或 Fraction。 Python 还内置支持 复数，后缀 j 或 J 用于表示虚数 (例如 3+5j)。(wow 复数，之前没有了解过这个表达形式)

文本：有str类型表示

‘’ 和 ‘’ “无差别 要标示引号本身，我们需要对它进行“转义”，即在前面加一个 \。或者，我们也可以使用不同类型的引号: 如果要在str使用‘ ，我们可以整体上使用“ ”反之亦然；不过统一的\貌似是一个更好的选择如果不希望前置 \ 的字符转义成特殊字符，可以使用 原始字符串，在引号前添加 r 即可：

Copy

1
2
3
4
5

print('C:\this\name')  # 这里 \t 表示制表符，\n 表示换行符
C:      his
ame
print(r'C:\this\name')  # 请注意引号前的 r
C:\this\name

原始字符串还有一个微妙的限制：一个原始字符串不能以奇数个 \ 字符结束；请参阅 此 FAQ 条目 了解更多信息及绕过的办法。字符串字面值可以跨越多行。 一种做法是使用三重引号: """...""" 或 '''...'''。 行结束符会自动包括在字符串中，但可以通过在行尾添加 \ 来避免此行为。在下面的例子中，开头的换行符将不会被包括:

1
2
3
4
5
6
7
8

print("""\
Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to
""")
Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to

字符串字面值的自动拼接

相邻的两个或多个 字符串字面值 （引号标注的字符）会自动合并：

1
2

'Py' 'thon'
'Python'

拼接分隔开的长字符串时，这个功能特别实用：

1
2
3
4

text = ('Put several strings within parentheses '
        'to have them joined together.')
text
'Put several strings within parentheses to have them joined together.'

这项功能只能用于两个字面值，不能用于变量或表达式，合并变量&表达式要使用+：

Copy

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

prefix = 'Py'
prefix 'thon'  # 不能拼接变量和字符串字面值
  File "<stdin>", line 1
    prefix 'thon'
           ^^^^^^
SyntaxError: invalid syntax
('un' * 3) 'ium'
  File "<stdin>", line 1
    ('un' * 3) 'ium'
               ^^^^^
SyntaxError: invalid syntax

字符串的索引居然能够支持负数，从右边开始计数字符串支持 索引 （下标访问），第一个字符的索引是 0。单字符没有专用的类型，就是长度为一的字符串：

1
2
3
4
5

word = 'Python'
word[0]  # 0 号位的字符
'P'
word[5]  # 5 号位的字符
'n'

索引还支持负数，用负数索引时，从右边开始计数：

1
2
3
4
5
6

word[-1]  # 最后一个字符
'n'
word[-2]  # 倒数第二个字符
'o'
word[-6]
'P'

字符串的切：用于获取子字符串（substr来了说是）

1
2
3
4

word[0:2]  # 从 0 号位 (含) 到 2 号位 (不含) 的字符
'Py'
word[2:5]  # 从 2 号位 (含) 到 5 号位 (不含) 的字符
'tho'

切片索引的默认值：

1
2
3
4
5
6

word[:2]   # 从开头到 2 号位 (不含) 的字符
'Py'
word[4:]   # 从 4 号位 (含) 到末尾
'on'
word[-2:]  # 从倒数第二个 (含) 到末尾
'on'

注意，输出结果包含切片开始，但不包含切片结束。因此，s[:i] + s[i:] 总是等于 s： 都是如果结束索引是默认值，那么实际上还有一个终结符，我们可以理解为不包含这个终结符但是包含最后一位 可以换一个方式理解：切片是索引之间 直接通过索引访问单个位置可能会出现索引越界，但是切片会自动处理索引越界 Python的字符串不可修改，是immutable的（怎么和JAVA一样啊，恼！！！） 字符串长度获取：内置函数：len(); 我CHOVY，ntm讲字符串给我讲好了啊！！！ 下面是字符串的一些方法！！！ 自己去这里找 https://docs.python.org/zh-cn/3/library/stdtypes.html#textseq

列表：mutable

支持索引，切片，合并 append（）；len（）：为切片赋值可以改变列表大小，甚至清空整个列表：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
letters
['a', 'b', 'c', 'd', 'e', 'f', 'g']
# 替换一些值
letters[2:5] = ['C', 'D', 'E']
letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
# 现在移除它们
letters[2:5] = []
letters
['a', 'b', 'f', 'g']
# 通过用一个空列表替代所有元素来清空列表
letters[:] = []
letters
[]

嵌套列表（注意不是合并哦哦哦哦哦！！！！！！）

1
2
3
4
5
6
7
8
9

a = ['a', 'b', 'c']
n = [1, 2, 3]
x = [a, n]
x
[['a', 'b', 'c'], [1, 2, 3]]
x[0]
['a', 'b', 'c']
x[0][1]
'b'

• 关键字参数 end 可以取消输出后面的换行, 或用另一个字符串结尾：

  Copy

  1 2 3 4 5 6

  a, b = 0, 1 while a < 1000: print(a, end=',') a, b = b, a+b 0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

** 比 - 的优先级更高, 所以 -3**2 会被解释成 -(3**2) ，因此，结果是 -9。要避免这个问题，并且得到 9, 可以用 (-3)**2。

[2]

与其他语言不同，特殊字符如 \n 在单引号 ('...') 和双引号 ("...") 里的意义一样。 这两种引号唯一的区别是，不需要在单引号里转义双引号 " (但此时必须把单引号转义成 \')，反之亦然。

更多的控制流工具

range（）函数：

内置函数 range() 用于生成等差数列：

1
2
3
4
5
6
7
8

for i in range(5):
    print(i)

0
1
2
3
4

生成的序列绝不会包括给定的终止值；range(10) 生成 10 个值——长度为 10 的序列的所有合法索引。range 可以不从 0 开始，且可以按给定的步长递增（即使是负数步长）：

1
2
3
4
5
6
7
8

list(range(5, 10))
[5, 6, 7, 8, 9]

list(range(0, 10, 3))
[0, 3, 6, 9]

list(range(-10, -100, -30))
[-10, -40, -70]

要按索引迭代序列，可以组合使用 range() 和 len()：

1
2
3
4
5
6
7
8
9

a = ['Mary', 'had', 'a', 'little', 'lamb']
for i in range(len(a)):
    print(i, a[i])

0 Mary
1 had
2 a
3 little
4 lamb

不过大多数情况下 enumerate() 函数很方便，详见 循环的技巧。

如果直接打印一个 range 会发生意想不到的事情：

1
2

range(10)
range(0, 10)

range() 返回的对象在很多方面和列表的行为一样，但其实它和列表不一样。该对象只有在被迭代时才一个一个地返回所期望的列表项，并没有真正生成过一个含有全部项的列表，从而节省了空间。

这种对象称为可迭代对象 iterable，适合作为需要获取一系列值的函数或程序构件的参数。for 语句就是这样的程序构件；以可迭代对象作为参数的函数例如 sum()：

1
2

sum(range(4))  # 0 + 1 + 2 + 3
6

后续我们会看到更多返回可迭代对象并以可迭代对象作为参数的函数。 在 数据结构 一章中，我们将讨论 list() 的更多细节。

列表的常见方法见 https://docs.python.org/zh-cn/3/tutorial/datastructures.html

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

append（value）:
extend(iterable):
insert(index,value):
remove(value):
pop(index=-1):
clear():
index(value,start,stop)
count(value);
sort(*,key=noe,reveres = False);
reveres():
copy:

列表实现堆栈：后进先出

append();pop()

列表实现队列：性能很差，最好使用collectiond.deque

列表推导式:

创建列表非常方便 筛选满足某些特定条件的元素/对全部元素进行操作

嵌套的列表推导式

实际应用最好用内置函数替代复杂的流程函数

del：区分与pop

可接单个元素如a[0],切片，或者单个变量a

元组和序列

元组：通过’,‘隔开，通常使用（）标注，imutable，但是可以存储mutable的元素如列表 特别的单个元组：

1
2
3
4
5
6
7
8

empty = ()
singleton = 'hello',    # <-- 注意末尾的逗号
len(empty)
0
len(singleton)
1
singleton
('hello',)

解包：

1

x, y, z = t

集合：set 无序，去重

创建空集合只能用set（）；创建可以用{}和set（）； 集合推导式

字典：

以key（键）为索引；任何不可变类型都可以作为key 特别的，元组仅包含（字符串，元组，数字）时也可以为key，但是如果它直接或者间接包含可变元素，则不可 键对值的集合，键唯一

下标操作d[key]可能（空值时即key不存在）会导致KeyError，最好用get（），返回值或者none：

1
2
3
4

list（d） ：获得所有key的列表，不包含value

sort（），in
dict（）：构造函数

字典推导式：关键字是比较简单的字符串时，直接用关键字参数指定键值对更便捷：

Copy

1
2

dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'guido': 4127, 'jack': 4098}

循环的技巧

同时获得字典的（key，value） ：item（）； 同时获得（index，value）：enumerate（）； 同时循环两个或者多个序列时：zip（）； 配置这个看的更明确

1
2
3
4
5
6
7
8

questions = ['name', 'quest', 'favorite color']
answers = ['lancelot', 'the holy grail', 'blue']
for q, a in zip(questions, answers):
    print('What is your {0}?  It is {1}.'.format(q, a))

What is your name?  It is lancelot.
What is your quest?  It is the holy grail.
What is your favorite color?  It is blue.

1
2
3

逆向：reverse（）
排序：sorted（）
去重：set（）

条件控制

1
2
3
4

in  ；not in
is ；not is
链式比较操作：a < b == c
优先级:not > and > or

模块是包含 Python 定义和语句的文件。其文件名是模块名加后缀名 .py 。在模块内部，通过全局变量 __name__ 可以获取模块名（即字符串）。

导入模块：

1

import name(模块的真实名字)

本质将模块名称添加到namespeac而非把定义的函数添加进去

6.1 模块详解：

模块包含可执行语句及函数定义。这些语句用于初始化模块，且仅在 import 语句 第一次 遇到模块名时执行。 每个模块都有它自己的私有符号表，该表被定义在该模块里的所有函数当作全局符号表使用。 您可以使用与引用模块函数相同的语法去访问一个模块的全局变量，即 modname.itemname

导入其他模块：import

被放置于一个模块的最高层级，则被导入的模块名称会被添加到该模块的全局命名空间。 import的变式1：将来自某个模块的名称直接导入到导入方的命名空间里面

1
2
3

from fibo import fib, fib2
fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

变式2：导入模块内定义的所有名称（不包含以_开头的名称）

1
2
3

from fibo import *
fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

不建议：可能会覆盖已经定义的名称

变式3：模块名后接as

1
2

import fibo from fib
fib.fib(500)

或者变式1，3结合

1
2
3

from fibo import fib as fibonacci
fibonacci(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

备注

每次解释器会话只导入一次模块，若模块内容更改，需要重启解释器 如仅交互测试一个模块，可以使用importlib.reload()，例如 import importlib; importlib.reload(modulename)。

6.1.1.以脚本方式执行模块

最常见命令：

1

python fibo.py <arguments>（这个参数的必须的）

导入模块的代码，但是会将_name_命名为"main"(这里前面和后面都有一个__，但是因为md原因导致没有了)

例如

1
2

python fibo.py 50
0 1 1 2 3 5 8 13 21 34

相当于

1
2
3

if __name__ == "__main__":
    import sys
    fib(int(sys.argv[1]))

该文件既可作为模块又可以作为脚本 而像下面这种导入其他模块则不会

1

import fibo 

用于为模块提供一个便捷的用户接口，或用于测试

6.1.2.模块的搜索路径

当导入一个名为 spam 的模块时，解释器首先会搜索具有该名称的内置模块。 这些模块的名称在 sys.builtin_module_names 中列出。 如果未找到，它将在变量 sys.path 所给出的目录列表中搜索名为 spam.py 的文件。 sys.path 是从这些位置初始化的:

• 被命令行直接运行的脚本所在的目录（或未指定文件时的当前目录）。
• PYTHONPATH （目录列表，与 shell 变量 PATH 的语法一样）。
• 依赖于安装的默认值（按照惯例包括一个 site-packages 目录，由 site 模块处理）。

更多细节请参阅 sys.path 模块搜索路径的初始化。

备注

在支持符号链接的文件系统中，“被命令行直接运行的脚本所在的目录”是符号链接最终指向的目录。换句话说，符号链接所在的目录并 没有 被添加至模块搜索路径。

初始化后，Python 程序可以更改 sys.path。脚本所在的目录先于标准库所在的路径被搜索。这意味着，脚本所在的目录如果有和标准库同名的文件，那么加载的是该目录里的，而不是标准库的。这一般是一个错误，除非这样的替换是你有意为之。详见 标准模块。

6.1.3.”已编译的“Python文件

模块的编译版本存放在–pycache__目录中，文件名为module.version.pyc,

version:对编译文件格式进行编码，一般是版本号 可以让不同版本的Python编译的模块可以共存 例子：CPython 的 3.3 发行版中，spam.py 的编译版本缓存为 __pycache__/spam.cpython-33.pyc

Python会自动检查编译版本和源码的修改日期来查看编译版是否过期，是否需要重新编译 编译模块与平台无关 Python不检查缓存的两种情况 1.从命令行直接载入的模块：每次重新编译且不存储结果 2.没有源模块 隐藏源代码：将所有源代码编程编译之后的版本，并储存在源目录而非缓存目录中）

ps： .pyc的读取未必比.py快，只是加载速度更快 compileall 模块可以为一个目录下的所有模块创建 .pyc 文件。

6.2.标准模块

Python自带的，在Python的库参考中另外描述 这些模块集是一个配置选项，并且还依赖于底层的操作系统 例如winreg只在WIndows系统上提供 但是sys模块内嵌到每一个Python解释器，sys.psq和sys.ps2变量定义了一些字符，可以作为主提示符和辅助提示符 变量的sys.path：字符串列表，用于确定解释器的模块搜索路径 从环境变量PYTHONPATH提取默认路径进行初始化，若未设置PYTHONPATH，则使用内置的默认路径 可以通过标准列表操作修改该变量

1
2

import sys
sys.path.append('/ufs/guido/lib/python')

6.3.dir()函数

查找模块定义的名称，返回值：经过排序的字符串列表 没有参数时： 返回值：当前已经定义的名称 包括：变量，模块，函数…… 但是不会列出内置函数和变量的名称 这些内容的定义在标准模块 builtins 中：

6.4. 包

通过”带点号模块名“来狗仔Python模块命名空间的一种方式 可以让不同包的作者不用担心彼此的全局变量名，比如模块名冲突

导入包时，Python 搜索 sys.path 里的目录，查找包的子目录。

需要有 __init__.py 文件才能让 Python 将包含该文件的目录当作包来处理（除非使用 namespace package，这是一个相对高级的特性）。 这可以防止重名的目录如 string 在无意中屏蔽后继出现在模块搜索路径中的有效模块。 在最简单的情况下，__init__.py 可以只是一个空文件，但它也可以执行包的初始化代码或设置 __all__ 变量，这将在稍后详细描述。

还可以从包中导入单个模块，例如：

1

import sound.effects.echo

这将加载子模块 sound.effects.echo。 它必须通过其全名来引用。

1

sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)

另一种导入子模块的方法是 ：

1

from sound.effects import echo

这也会加载子模块 echo，并使其不必加包前缀，因此可按如下方式使用:

1

echo.echofilter(input, output, delay=0.7, atten=4)

Import 语句的另一种变体是直接导入所需的函数或变量：

1

from sound.effects.echo import echofilter

同样，这将加载子模块 echo，但这使其函数 echofilter() 直接可用:

1

echofilter(input, output, delay=0.7, atten=4)

注意，使用 from package import item 时，item 可以是包的子模块（或子包），也可以是包中定义的函数、类或变量等其他名称。import 语句首先测试包中是否定义了 item；如果未在包中定义，则假定 item 是模块，并尝试加载。如果找不到 item，则触发 ImportError 异常。

相反，使用 import item.subitem.subsubitem 句法时，除最后一项外，每个 item 都必须是包；最后一项可以是模块或包，但不能是上一项中定义的类、函数或变量。

6.4.1. 从包中导入*

提供包的显式索引

导入在init.py 代码定义了列表 all 发布新版本时，应更新该列表 例如：sound/effects/__init__.py 文件可以包含以下代码：

1

__all__ = ["echo", "surround", "reverse"]

这意味着 from sound.effects import * 将导入 sound.effects 包的三个命名子模块。请注意子模块可能会受到本地定义名称的影响。 例如，如果你在 sound/effects/__init__.py 文件中添加了一个 reverse 函数，from sound.effects import * 将只导入 echo 和 surround 这两个子模块，但 不会 导入 reverse 子模块，因为它被本地定义的 reverse 函数所遮挡:

1
2
3
4
5
6
7
8

__all__ = [
    "echo",      # 指向 'echo.py' 文件
    "surround",  # 指向 'surround.py' 文件
    "reverse",   # !!! 现在指向 'reverse' 函数 !!!
]

def reverse(msg: str):  # <-- 此名称将覆盖 'reverse.py' 子模块
    return msg[::-1]    #     针对 'from sound.effects import *' 的情况

没有定义____all____:

有点没懂

6.4.2. 相对导入

使用前导符号.来完成 一般用于子模块

格式化字符串字面值

在字符串开头的引号/三引号之前加f/F 特性：可以通过{}在字符之间输入引用的变量，或者字面值的Python表达式 例子如下：

1
2
3
4

year = 2016
event = 'Referendum'
f'Results of the {year} {event}'
'Results of the 2016 Referendum'

str.format（）:

特性：1.同上，但你需要提供详细的格式化指令和待格式化的信息 例子：

1
2
3
4
5

yes_votes = 42_572_654
total_votes = 85_705_149
percentage = yes_votes / total_votes
'{:-9} YES votes  {:2.2%}'.format(yes_votes, percentage)
' 42572654 YES votes  49.67%'

解释： 注意此处的输出 -9："-“表示只有在复数是才显示负号，+表示总是显示正负号 例如 {’’:+’’}.format(100) 输出+100; {’’:+’’}.format(-100) 输出-100; {’’:-’’}.format(100) 输出100; {’’:-’’}.format(-100) 输出-100; ‘9’表示最小宽度，没有达到则需要填充，比如上面只有八位，在前面填充了一个空格； {:2.2%} ： 第一个2也表示整数部分最小宽度，因达到两位所以无影响 第二个2表示小数点后保留两位； 百分号表示用%表示

str()和repr():把值转化成字符串

不需要花哨输出，用于快速显示变量进行调试

string 模块通过 string.Template 提供了一种基于正则表达式的简单模板方法支持。

这种方式为字符串中的值替换提供了另一种途径：使用类似 $x 的占位符，并将其替换为字典中的对应值。该语法使用简便，但在格式控制方面提供的功能较为有限。

7.1.1.格式化字符串字面值

字符串前夹f或F，通过{expression}表达式，把Python变量引入字符串中 格式说明符：可选，便于更好控制格式化值的方式，写在表达式的后面 例1：将pi舍入到小数点后三维 {math.pi:.3f} 例2：再：传递整数，表示最小字符宽度，常于用列对齐 常用于格式化的修饰符及其作用： '!a' 应用 ascii() ，'!s' 应用 str()，'!r' 应用 repr()： =的作用：{expression = }将其拓展为 expression = value

7.1.2.字符串format方法

基本用法： 例1：

1
2

print('We are the {} who say "{}!"'.format('knights', 'Ni'))
We are the knights who say "Ni!"

{}替换为传递给format方法的对象： {}内的数字：表示传递的对象的位置，例如

1
2
3
4

print('{0} and {1}'.format('spam', 'eggs'))
spam and eggs
print('{1} and {0}'.format('spam', 'eggs'))
eggs and spam

通过关键字参数名引入value

例：

1
2
3

print('This {food} is {adjective}.'.format(
      food='spam', adjective='absolutely horrible'))
This spam is absolutely horrible.

关键词参数和位置参数可以组合使用，例如：

1
2
3

print('The story of {0}, {1}, and {other}.'.format('Bill', 'Manfred',
                                                   other='Georg'))
The story of Bill, Manfred, and Georg.

按名称引入变量进行格式化。可以通过字典传递，使用[]进行访问 例如：

1
2
3
4

table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
print('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '
      'Dcab: {0[Dcab]:d}'.format(table))
Jack: 4098; Sjoerd: 4127; Dcab: 8637678

详解：此处的{0[Jack]:d}中参数的含义 0表示第零个参数，即table这个字典，Jack为关键字参数不必多说，：d表示demical，用十进制表示，绝非double 除此之外，此处的table还可以通过**作为参数，此时就不需要通过[]来访问了 例如

1

print('Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; Dcab: {Dcab:d}'.format(**table))

7.1.3.手动格式化字符串

蠢蠢的，自己看

7.1.4.旧式字符串格式化方法

%用于字符串插值，感觉也蠢蠢的

1
2
3

import math
print('The value of pi is approximately %5.3f.' % math.pi)
The value of pi is approximately 3.142.

7.2.读写文件

open（）的应用： 返回值：一个file object，参数open（filename,mode,encoding = none） 各个参数的意义： filename：文件名字符串 mode：描述对文件的操作，包含以下几种值： r：read only，表示只读 w：表示只写 a：表示打开文件并追加内容，将写入的数据写入文件末尾 r+：进行读写 默认值为r encoding:选择的编码，一般默认UTF-8；在模式后面加b，可以使用binary mode打开文件，二级制数据以bytes对象形式进行读写的，该情况不允许指定encoding 而默认情况是以text mode打开 读取文件，会把平台特定的行终结符统一转化为\n，而写入时，又会转化为平台对应的终结符 但是该操作会破坏二级制文件中的数据，这类数据只能通过二级制模式读写

with关键字：优点：字句结束后，文件会正确关闭，且代码更简洁

1
2

with open('workfile', encoding="utf-8") as f:
    read_data = f.read()

没有with关键字，应通过f.close()关闭文件，释放资源， 若未使用close()关闭文件或者with关键字，可能导致写入的参数未写入磁盘

7.2.1.文件对象的方法

前提：已创建f文件对象 f.read(size)：用于读取文件内容 返回值：字符串（文本模式），字节串（二进制模式） size：可选。默认值或复数：读取整个文件内容；其他值：读取size个字符或者size个字节 到达文件末尾返回空字符串’ ‘ f.readline():从文件中读取单行字符串 保留换行符’\n’,例如

1
2

f.readline()
'This is the first line of the file.\n'

只有在文件不以换行符结尾才省略换行符 若需要读取多行，通过循环遍历整个文件对象：

1
2
3
4
5

for line in f:
    print(line, end='')

This is the first line of the file.
Second line of the file

如果需要以列表形式读取，则可以用list(f)或者f.readline() f.write(string):把string内容写入文件并返回写入的字符数 写入其他类型时，要先做类型转化，转化为string或者bytes

f.seek(offset,whence)改变文件对象的位置 通过参考点添加offset计算位置 参考点有whence指定：0：从文件开头；1：使用当前文件位置；2：使用文件末尾 默认值为0 可以和f.tell()搭配使用 在文本文件（模式字符串未使用 b 时打开的文件）中，只允许相对于文件开头搜索（使用 seek(0, 2) 搜索到文件末尾是个例外），唯一有效的 offset 值是能从 f.tell() 中返回的，或 0。其他 offset 值都会产生未定义的行为。

7.2.2. 使用 json 保存结构化数据¶

字符串可以很容易地写入文件或从文件中读取。 数字则更麻烦一些，因为 read() 方法只返回字符串，而字符串必须传给 int() 这样的函数，它接受 '123' 这样的字符串并返回其数值 123。 当你想要保存嵌套列表和字典等更复杂的数据类型时，手动执行解析和序列化操作将会变得非常复杂。

Python 允许你使用流行的数据交换格式 JSON (JavaScript Object Notation)，而不是让用户持续编写和调试代码来将复杂的数据类型存入文件中。 标准库模块 json 可以接受带有层级结构的 Python 数据，并将其转换为字符串表示形式；这个过程称为 serializing。 根据字符串表示形式JSON重建数据则称为 deserializing。 在序列化和反序列化之间，用于代表对象的字符串可以存储在文件或数据库中，或者通过网络连接发送到远端主机。

备注

JSON 格式通常用于现代应用程序的数据交换。程序员早已对它耳熟能详，可谓是交互操作的不二之选。

只需一行简单的代码即可查看某个对象的 JSON 字符串表现形式：

1
2
3
4

import json
x = [1, 'simple', 'list']
json.dumps(x)
'[1, "simple", "list"]'

dumps() 函数还有一个变体， dump() ，它只将对象序列化为 text file 。因此，如果 f 是 text file 对象，可以这样做：

1

json.dump(x, f)

要再次解码对象，如果 f 是已打开、供读取的 binary file 或 text file 对象：

1

x = json.load(f)

备注

JSON 文件必须以 UTF-8 编码。当打开 JSON 文件作为一个 text file 用于读写时，使用 encoding="utf-8" 。

这种简单的序列化技术可以处理列表和字典，但在 JSON 中序列化任意类的实例，则需要付出额外努力。json 模块的参考包含对此的解释。

又称解析错误 报错信息包括：出错的行；显示指向检测到错误位置的小箭头；文件名

8.2.异常

在执行时检测到的错误称为异常 报错信息包括：异常的类型；错误细节

8.3.异常的处理

try语句的工作原理： 1.执行try子句 2.没有触发异常，跳过except子句 3.触发异常，跳过try子句剩下部分，并且将异常与except后关键字进行匹配“如果匹配，则执行except子句；如果为未匹配，则停止执行并输出一条错误信息

特性： 一个 try 可以有多个普通 except 子句，对于一次抛出的普通异常，只有第一个匹配的 except 子句会执行。一个 except 子句中的类匹配的异常将是该类本身的实例或其所派生的类的实例（但反过来则不可以 — 列出派生类的 except 子句 不会匹配其基类的实例） 人话：基类（父类）异常可以匹配子类异常，反之不可以 so，需要主要异常匹配的顺序 异常参数 except子句可能在异常后指定一个变量（通过as），被绑定到异常实例，该实例有一个args属性，内置异常类型定义了 __str__() 来打印所有参数而不必显式地访问 .args。

异常之间的关系 BaseException 是所有异常的共同基类。它的一个子类，Exception，是所有非致命异常的基类。不是 Exception 的子类的异常通常不被处理，因为它们被用来指示程序应该终止。它们包括由 sys.exit() 引发的 SystemExit，以及当用户希望中断程序时引发的 KeyboardInterrupt。

异常匹配的注意点： Exception 可以被用作通配符，捕获（几乎）一切。然而，好的做法是，尽可能具体地说明我们打算处理的异常类型，并允许任何意外的异常传播下去。

try…except语句具有可选的else语句

异常处理程序还会处理在try子句中调用的函数的异常

8.4.触发异常

使用raise语句，强制触发指定类型的异常 唯一的参数是要触发的异常，这个参数必须是异常实例或者异常类，如果是异常类，会隐式调用无参数的构造函数来创建一个异常实例

8.5.异常链

raise a from b语句来显式表明一个异常（a）是另一个异常（b）的直接后果：此处的b必须为实例或者none，而未none时，表示禁用自动异常链

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

def func():
    raise ConnectionError

try:
    func()
except ConnectionError as exc:
    raise RuntimeError('Failed to open database') from exc

Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
    func()
    ~~~~^^
  File "<stdin>", line 2, in func
ConnectionError

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
  File "<stdin>", line 4, in <module>
    raise RuntimeError('Failed to open database') from exc
RuntimeError: Failed to open database

8.6.用户自定义异常

程序可以通过创建新的异常类命名自己的异常 (Python 类的内容详见 类)。 不论是以直接还是间接的方式，异常都应从 Exception 类派生。

异常类可以被定义成能做其他类所能做的任何事，但通常应当保持简单，它往往只提供一些属性，允许相应的异常处理程序提取有关错误的信息。

大多数异常命名都以"Error"结尾，类似标准异常的命名。

许多标准模块定义了自己的异常，以报告他们定义的函数中可能出现的错误。

8.7.定义清理操作

try-finally语句：定义在所有情况下都要执行的操作，通常在异常处理中用于清理操作 一些复杂的触发异常场景，感觉没什么意思，自己看看吧

• 如果执行 try 子句期间触发了某个异常，则某个 except 子句应处理该异常。如果该异常没有 except 子句处理，在 finally 子句执行后会被重新触发。
• except 或 else 子句执行期间也会触发异常。同样，该异常会在 finally 子句执行之后被重新触发。
• 如果 finally 子句执行 break、 continue 或 return 语句，异常不重新引发。这可能会引起混淆，因此不鼓励使用。从 3.14 版开始，编译器会为它发出一个 SyntaxWarning (参见 PEP 765)。
• 如果执行 try 语句时遇到 break、continue 或 return 语句，则 finally 子句在执行 break、continue 或 return 语句之前执行。
• 如果一个 finally 子句包含一个 return 语句，返回的值将是来自 finally 子句的 return 语句，而不是来自 try 子句的 return 语句。 这可能会引起混淆，因此不提倡使用。 从 3.14 版开始，编译器会为它发出一个 SyntaxWarning (参见 PEP 765)。

通常用于释放外部资源的逻辑

8.8.预定义的清理操作（没啥意思，自己看）

某些对象定义了不需要该对象时要执行的标准清理操作。无论使用该对象的操作是否成功，都会执行清理操作。比如，下例要打开一个文件，并输出文件内容：

1
2

for line in open("myfile.txt"):
    print(line, end="")

这个代码的问题在于，执行完代码后，文件在一段不确定的时间内处于打开状态。在简单脚本中这没有问题，但对于较大的应用程序来说可能会出问题。with 语句支持以及时、正确的清理的方式使用文件对象：

1
2
3

with open("myfile.txt") as f:
    for line in f:
        print(line, end="")

语句执行完毕后，即使在处理行时遇到问题，都会关闭文件 f。和文件一样，支持预定义清理操作的对象会在文档中指出这一点。

8.9.引发和处理多个不相关的异常

场景：继续执行收集多个错误而不是引发第一个异常 方法一：内置的 ExceptionGroup 打包了一个异常实例的列表，这样它们就可以一起被引发。它本身就是一个异常，所以它可以像其他异常一样被捕获。 方法二：使用except替代except，有选择地处理异常，注意此处地except子句就不再是只能执行一个了

例子：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

def f():
    raise ExceptionGroup(
        "group1",
        [
            OSError(1),
            SystemError(2),
            ExceptionGroup(
                "group2",
                [
                    OSError(3),
                    RecursionError(4)
                ]
            )
        ]
    )

try:
    f()
except* OSError as e:
    print("There were OSErrors")
except* SystemError as e:
    print("There were SystemErrors")

There were OSErrors
There were SystemErrors
  + Exception Group Traceback (most recent call last):
  |   File "<stdin>", line 2, in <module>
  |     f()
  |     ~^^
  |   File "<stdin>", line 2, in f
  |     raise ExceptionGroup(
  |     ...<12 lines>...
  |     )
  | ExceptionGroup: group1 (1 sub-exception)
  +-+---------------- 1 ----------------
    | ExceptionGroup: group2 (1 sub-exception)
    +-+---------------- 1 ----------------
      | RecursionError: 4
      +------------------------------------

注意，嵌套在一个异常组中的异常必须是实例，而不是类型。这是因为在实践中，这些异常通常是那些已经被程序提出并捕获的异常

8.10.用注释细化异常情况

add_note(note)用于在异常被捕获之后添加信息到异常地注释列表中 例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

try:
    raise TypeError('bad type')
except Exception as e:
    e.add_note('Add some information')
    e.add_note('Add some more information')
    raise

Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
    raise TypeError('bad type')
TypeError: bad type
Add some information
Add some more information

应用于异常组中，例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

def f():
    raise OSError('operation failed')

excs = []
for i in range(3):
    try:
        f()
    except Exception as e:
        e.add_note(f'Happened in Iteration {i+1}')
        excs.append(e)

raise ExceptionGroup('We have some problems', excs)
  + Exception Group Traceback (most recent call last):
  |   File "<stdin>", line 1, in <module>
  |     raise ExceptionGroup('We have some problems', excs)
  | ExceptionGroup: We have some problems (3 sub-exceptions)
  +-+---------------- 1 ----------------
    | Traceback (most recent call last):
    |   File "<stdin>", line 3, in <module>
    |     f()
    |     ~^^
    |   File "<stdin>", line 2, in f
    |     raise OSError('operation failed')
    | OSError: operation failed
    | Happened in Iteration 1
    +---------------- 2 ----------------
    | Traceback (most recent call last):
    |   File "<stdin>", line 3, in <module>
    |     f()
    |     ~^^
    |   File "<stdin>", line 2, in f
    |     raise OSError('operation failed')
    | OSError: operation failed
    | Happened in Iteration 2
    +---------------- 3 ----------------
    | Traceback (most recent call last):
    |   File "<stdin>", line 3, in <module>
    |     f()
    |     ~^^
    |   File "<stdin>", line 2, in f
    |     raise OSError('operation failed')
    | OSError: operation failed
    | Happened in Iteration 3
    +------------------------------------

9.1.名称和对象

别名：对象之间相互独立，多个名称（甚至是多个作用域内的多个名称）可以绑定到同一对象。这在其他语言中通常被称为别名，这种现象主要是有益于可变对象，比如列表，，字典等等

9.2.Python的作用域和命名空间

命名空间：namespace

名称到对象的映射 实现：大多数靠Python字典实现 不同命名空间中的名称之间绝对没有关系

属性：在点之后的名称是属性（好奇怪的定义）

模块属性和模块中定义的全局名称之间存在直接的映射：它们共享相同的命名空间 属性可以是只读或者只写的，后一种情况可以对属性进行赋值，也可以通过del来进行删除

命名空间的创建时间和生命周期（感觉有点复杂）

命名空间是在不同时刻创建的，且拥有不同的生命周期。内置名称的命名空间是在 Python 解释器启动时创建的，永远不会被删除。模块的全局命名空间在读取模块定义时创建；通常，模块的命名空间也会持续到解释器退出。从脚本文件读取或交互式读取的，由解释器顶层调用执行的语句是 __main__ 模块调用的一部分，也拥有自己的全局命名空间。内置名称实际上也在模块里，即 builtins 。

函数的局部命名空间在函数被调用时被创建，并在函数返回或抛出未在函数内被处理的异常时，被删除。（实际上，用“遗忘”来描述实际发生的情况会更好一些。）当然，每次递归调用都有自己的局部命名空间。

一个命名空间的 作用域 是 Python 代码中的一段文本区域，从这个区域可直接访问该命名空间。“可直接访问”的意思是，该文本区域内的名称在被非限定引用时，查找名称的范围，是包括该命名空间在内的。

作用域虽然是被静态确定的，但会被动态使用。执行期间的任何时刻，都会有 3 或 4 个“命名空间可直接访问”的嵌套作用域：

• 最内层作用域，包含局部名称，并首先在其中进行搜索
• 那些外层闭包函数的作用域，包含“非局部、非全局”的名称，从最靠内层的那个作用域开始，逐层向外搜索。
• 倒数第二层作用域，包含当前模块的全局名称
• 最外层（最后搜索）的作用域，是内置名称的命名空间

如果一个名称被声明为全局，则所有引用和赋值都将直接指向“倒数第二层作用域”，即包含模块的全局名称的作用域。 要重新绑定在最内层作用域以外找到的变量，可以使用 nonlocal 语句；如果未使用 nonlocal 声明，这些变量将为只读（尝试写入这样的变量将在最内层作用域中创建一个 新的 局部变量，而使得同名的外部变量保持不变）。

通常，当前局部作用域将（按字面文本）引用当前函数的局部名称。在函数之外，局部作用域引用与全局作用域一致的命名空间：模块的命名空间。 类定义在局部命名空间内再放置另一个命名空间。

划重点，作用域是按字面文本确定的：模块内定义的函数的全局作用域就是该模块的命名空间，无论该函数从什么地方或以什么别名被调用。另一方面，实际的名称搜索是在运行时动态完成的。但是，Python 正在朝着“编译时静态名称解析”的方向发展，因此不要过于依赖动态名称解析！（局部变量已经是被静态确定了。）

Python 有一个特殊规定。如果不存在生效的 global 或 nonlocal 语句，则对名称的赋值总是会进入最内层作用域。赋值不会复制数据，只是将名称绑定到对象。删除也是如此：语句 del x 从局部作用域引用的命名空间中移除对 x 的绑定。所有引入新名称的操作都是使用局部作用域：尤其是 import 语句和函数定义会在局部作用域中绑定模块或函数名称。

global 语句用于表明特定变量在全局作用域里，并应在全局作用域中重新绑定；nonlocal 语句表明特定变量在外层作用域中，并应在外层作用域中重新绑定。

9.2.1.作用域和命名空间

一个经典的例子便于理解global和nonlocal对于变量绑定的影响

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

def scope_test():
    def do_local():
        spam = "local spam"

    def do_nonlocal():
        nonlocal spam
        spam = "nonlocal spam"

    def do_global():
        global spam
        spam = "global spam"

    spam = "test spam"
    do_local()
    print("After local assignment:", spam)
    do_nonlocal()
    print("After nonlocal assignment:", spam)
    do_global()
    print("After global assignment:", spam)

scope_test()
print("In global scope:", spam)

示例代码的输出是：

1
2
3
4

After local assignment: test spam
After nonlocal assignment: nonlocal spam
After global assignment: nonlocal spam
In global scope: global spam

注意，局部 赋值（这是默认状态）不会改变 scope_test 对 spam 的绑定。 nonlocal 赋值会改变 scope_test 对 spam 的绑定，而 global 赋值会改变模块层级的绑定。

而且，global 赋值前没有 spam 的绑定。

本人的理解：经验证是正确的，但是表述没有很准确，即函数名啥的写的比较粗略等等 首先 spam = “test spam"创建在scope_test作用域的spam，然后dolocal创建属于dolocal的spam然后do_nonlocal更新属于它外围u函数也就是socpetest的spam，然后doglobal创建全局的spam，在scope——test的每次输出都是输出属于scopetest的spam，但是最后一句 scope_test() print(“In global scope:”, spam) 会输出属于global的spam 此处要理解的关键就是各个作用域中的spam和 nonlocal与global对于绑定造成的影响 nonlocal是在外围函数中创建或者更新，比如此处的scope_test就是do_local等三个函数的外围函数 global则是在全局做更新或创建

9.3.初探类

9.3.1.类的定义

class ClassName:

9.3.2 Class对象

支持两种操作：

1.属性引用

属性引用 语法：obj.name ____doc____为文档字符串属性

2.实例化

当一个类定义了 __init__() 方法时，类的实例化会自动为新创建的类实例唤起 __init__()。 因此在这个例子中，可以通过以下语句获得一个已初始化的新实例: 当然，__init__() 方法还有一些参数用于实现更高的灵活性。 在这种情况下，提供给类实例化运算符的参数 将被传递给 __init__()。 例如

9.3.3.实例对象

唯一操作为属性引用，引用的对象包括两个方面：函数和数据属性

9.3.4.方法对象

方法对象可被储存卡里 例如：xf = x.f，print（xf） 方法的特殊之处就在于实例对象会作为函数的第一个参数被传入

9.3.5.实例对象和类

正确设计实例变量和类变量

一般来说，实例变量用于每个实例的唯一数据，而类变量用于类的所有实例共享的属性和方法:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

class Dog:

    kind = 'canine'         # 类变量被所有实例所共享

    def __init__(self, name):
        self.name = name    # 实例变量为每个实例所独有

>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.kind                  # 被所有的 Dog 实例所共享
'canine'
>>> e.kind                  # 被所有的 Dog 实例所共享
'canine'
>>> d.name                  # 为 d 所独有
'Fido'
>>> e.name                  # 为 e 所独有
'Buddy'

正如在 名称和对象 中所讨论的，共享数据可能在涉及 mutable 对象如列表和字典时导致令人惊讶的结果。 例如，以下代码中的 tricks 列表不应被用作类变量因为所有 Dog 实例将共享一个单独的列表:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

class Dog:

    tricks = []             # 类变量的错误用法

    def __init__(self, name):
        self.name = name

    def add_trick(self, trick):
        self.tricks.append(trick)

>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.add_trick('roll over')
>>> e.add_trick('play dead')
>>> d.tricks                # 非预期地被所有的 Dog 实例所共享
['roll over', 'play dead']

正确的类设计应该使用实例变量:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

class Dog:

    def __init__(self, name):
        self.name = name
        self.tricks = []    # 为每个 Dog 实例新建一个空列表

    def add_trick(self, trick):
        self.tricks.append(trick)

>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.add_trick('roll over')
>>> e.add_trick('play dead')
>>> d.tricks
['roll over']
>>> e.tricks
['play dead']

9.4.补充说明

1.同样的属性名称同时出现在类对象和实例对象时。优先选择实例对象

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

class Warehouse:
   purpose = 'storage'
   region = 'west'

w1 = Warehouse()
print(w1.purpose, w1.region)
storage west
//相当与给w2创建了一个实例属性region，要与属于warehouse的region属性区别开
w2 = Warehouse()
w2.region = 'east'
print(w2.purpose, w2.region)
storage east

方法的第一个参数常常被命名为 self。 这也不过就是一个约定: self 这一名称在 Python 中绝对没有特殊含义。 但是要注意，不遵循此约定会使得你的代码对其他 Python 程序员来说缺乏可读性，而且也可以想像一个 类浏览器 程序的编写可能会依赖于这样的约定。

9.5. 继承

派生类的语法：class DeriveClassName(BaseClassName): 若基类位于另一个module， 语法为：class DerivedClassName(modname.BaseClassName):

关于重写： Python 中所有的方法实际上都是 virtual 方法 如果想要调用基类的方法而非派生类的方法：BaseClassName.methodname(self, arguments)

两个有关继承机制的内置函数： isinstancel():isinstance(obj,int) 当obj为int或者int的子类时为true； issubclass(a,b):判断a是不是b的子类

9.5.1.多重继承

语法：class DerivedClassName(Base1, Base2, Base3): 多个基类访问顺序：有点复杂，自己看对于多数目的来说，在最简单的情况下，你可以认为搜索从父类所继承属性的操作是深度优先、从左到右的，当层次结构存在重叠时不会在同一个类中搜索两次。 因此，如果某个属性在 DerivedClassName 中找不到，就会在 Base1 中搜索它，然后（递归地）在 Base1 的基类中搜索，如果在那里也找不到，就将在 Base2 中搜索，依此类推。

真实情况比这个更复杂一些；方法解析顺序会动态改变以支持对 super() 的协同调用。 这种方式在某些其他多重继承型语言中被称为后续方法调用，它比单继承型语言中的 super 调用更强大。

动态调整顺序是有必要的，因为所有多重继承的情况都会显示出一个或更多的菱形关联（即至少有一个上级类可通过多条路径被最底层的类所访问）。 例如，所有类都是继承自 object，因此任何多重继承的情况都提供了一条以上的路径可以通向 object。 为了确保基类不会被访问一次以上，动态算法会用一种特殊方式将搜索顺序线性化，保留每个类所指定的从左至右的顺序，只调用每个上级类一次，并且保持单调性（即一个类可以被子类化而不影响其父类的优先顺序）。 总而言之，这些特性使得设计具有多重继承的可靠且可扩展的类成为可能。 要了解更多细节，请参阅 Python 2.3 方法解析顺序。

9.6.私有变量

意识到：仅限从一个对象内部访问的“私有”实例变量在 Python 中并不存在 约定为：带有一个下划线的名称 (例如 _spam) 应该被当作是 API 的非公有部分 名称改写：任何形式为 __spam 的标识符（至少带有两个前缀下划线，至多一个后缀下划线）的文本将被替换为 _classname__spam，其中 classname 为去除了前缀下划线的当前类名称。

9.7.杂项说明

使用datalclasses：将一些带名称的数据项捆绑在一起 from dataclasses import dataclass

1
2
3
4
5

@dataclass
class Employee:
    name: str
    dept: str
    salary: int

9.8.迭代器

for语句： 原理：在容器对象调用iter（）生成一个带有–next–（）方法的迭代器对象，准一访问到末尾引发StopIteration异常来中止 通过next（）函数调用–next–（）

9.9.生成器

一个创建迭代器的工具,返回数据时会使用yield语句

yield与return的区别:yield不会终结函数而是暂停函数,这正好符合生成器的需要 几个特性: 但生成器的写法更为紧凑，因为它会自动创建 __iter__() 和 __next__() 方法。 另一个关键特性在于局部变量和执行状态会在每次调用之间自动保存。 当生成器终结时，它们还会自动引发 StopIteration。

9.10.生成器表达式(懒得解释了自己看)

某些简单的生成器可以写成简洁的表达式代码，所用语法类似列表推导式，但外层为圆括号而非方括号。 这种表达式被设计用于生成器将立即被外层函数所使用的情况。 生成器表达式相比完整的生成器更紧凑但较不灵活，相比等效的列表推导式则更为节省内存。

示例:

Copy

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

sum(i*i for i in range(10))                 # sum of squares
285

xvec = [10, 20, 30]
yvec = [7, 5, 3]
sum(x*y for x,y in zip(xvec, yvec))         # dot product
260

unique_words = set(word for line in page  for word in line.split())

valedictorian = max((student.gpa, student.name) for student in graduates)

data = 'golf'
list(data[i] for i in range(len(data)-1, -1, -1))
['f', 'l', 'o', 'g']

import os 一定要使用import os而非from os import * 原因：防止内建的open（）函数被os.open()隐式替换掉 内置的dir（）和help（）函数可用作交互式的辅助工具

1
2
3
4

dir(os)
<返回由模块的所有函数组成的列表>
help(os)
<返回根据模块文档字符串创建的详细说明页面>

对于日常文件和目录管理任务，shutil模块提供了易用的高层级接口

10.2.文件通配符

glob模块提供了一个在目录中使用通配符搜索创建文件列表的函数

示例如下:

1
2
3

import glob
glob.glob('*.py')
['primes.py', 'random.py', 'quote.py']

10.3.命令行参数

参数是通过列表形式储存在sys模块的argv属性中 import sys来引入 argparse模块argparse 模块提供了一种更复杂的机制来处理命令行参数。 以下脚本可提取一个或多个文件名并可选择要显示的行数:（要用自己看）

1
2
3
4
5
6
7
8
9

import argparse

parser = argparse.ArgumentParser(
    prog='top',
    description='Show top lines from each file')
parser.add_argument('filenames', nargs='+')
parser.add_argument('-l', '--lines', type=int, default=10)
args = parser.parse_args()
print(args)

当通过 python top.py --lines=5 alpha.txt beta.txt 在命令行运行时，该脚本会将 args.lines 设为 5 并将 args.filenames 设为 ['alpha.txt', 'beta.txt']。

10.4.错误输出重定向和程序终止

sys模块的stdin，stdout，stderr属性，其中stderr在发出警告和错误信息很有用 终止脚本：sys.exit()

10.5.字符串模式匹配

re模块为高级表达式提供正则表达式工具

1
2
3
4
5

import re
re.findall(r'\bf[a-z]*', 'which foot or hand fell fastest')
['foot', 'fell', 'fastest']
re.sub(r'(\b[a-z]+) \1', r'\1', 'cat in the the hat')
'cat in the hat'

1
2

'tea for too'.replace('too', 'two')
'tea for two'

正则表达式是的，yield 和普通函数中的 return 最大的不同在于：yield 不会让函数彻底结束，而是会让函数“暂停”，以后还能从暂停的位置继续执行。

这就是它最特别的地方。

10.6.数字

math模块：众多数学方法 random：随机选择工具 statistics：计算数值数据的基本统计属性：例如均值，中位数，方差等等

10.7.互联网访问

挺多的，最简单的两个 urllib.request 用于从URL检索数据，以及 smtplib 用于发送邮件

10.8.日期和时间

datatime模块

10.9.数据压缩

常见的数据存档和压缩格式由模块直接支持，包括：zlib, gzip, bz2, lzma, zipfile 和 tarfile

10.10.性能测试

10.10. 性能测量

一些 Python 用户对了解同一问题的不同方法的相对性能产生了浓厚的兴趣。Python 提供了一种可以立即回答这些问题的测量工具。

例如，元组封包和拆包功能相比传统的交换参数可能更具吸引力。timeit 模块可以快速演示在运行效率方面一定的优势:

1
2
3
4
5

from timeit import Timer
Timer('t=a; a=b; b=t', 'a=1; b=2').timeit()
0.57535828626024577
Timer('a,b = b,a', 'a=1; b=2').timeit()
0.54962537085770791

与 timeit 的精细粒度级别相反， profile 和 pstats 模块提供了用于在较大的代码块中识别时间关键部分的工具。

10.11.质量控制（写测试）

这个感觉会有点用

开发高质量软件的一种方法是在开发过程中为每个函数编写测试，并在开发过程中经常运行这些测试。

doctest 模块提供了一个工具，用于扫描模块并验证程序文档字符串中嵌入的测试。测试构造就像将典型调用及其结果剪切并粘贴到文档字符串一样简单。这通过向用户提供示例来改进文档，并且它允许 doctest 模块确保代码与文档保持一致:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

def average(values):
    """计算数字列表的算术平均值

    >>> print(average([20, 30, 70]))
    40.0
    """
    return sum(values) / len(values)

import doctest
doctest.testmod()   # 自动验证嵌入式测试

unittest 模块不像 doctest 模块那样易于使用，但它允许在一个单独的文件中维护更全面的测试集:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

import unittest

class TestStatisticalFunctions(unittest.TestCase):

    def test_average(self):
        self.assertEqual(average([20, 30, 70]), 40.0)
        self.assertEqual(round(average([1, 5, 7]), 1), 4.3)
        with self.assertRaises(ZeroDivisionError):
            average([])
        with self.assertRaises(TypeError):
            average(20, 30, 70)

unittest.main()  # 从命令行调用时会执行所有测试

10.12.内置电池

Python 有"自带电池"的理念。通过其包的复杂和强大功能可以最好地看到这一点。例如:

• xmlrpc.client 和 xmlrpc.server 模块使得实现远程过程调用变成了小菜一碟。 尽管存在于模块名称中，但用户不需要直接了解或处理 XML。
• email 包是一个用于管理电子邮件消息的库，包括 MIME 和其他基于 RFC 5322 的消息文档。 不同于实际发送和接收消息的 smtplib 和 poplib，email 包提供用于构建或解码复杂消息结构（包括附件）以及实现互联网编码格式和标头协议的完整工具集。
• json 包为解析这种流行的数据交换格式提供了强大的支持。 csv 模块支持以逗号分隔值格式直接读取和写入文件，这种格式通常为数据库和电子表格所支持。 XML 处理由 xml.etree.ElementTree ， xml.dom 和 xml.sax 包支持。这些模块和软件包共同大大简化了 Python 应用程序和其他工具之间的数据交换。
• sqlite3 模块是 SQLite 数据库库的包装器，提供了一个可以使用稍微非标准的 SQL 语法更新和访问的持久数据库。
• 国际化由许多模块支持，包括 gettext ， locale ，以及 codecs 包。

11. 标准库概览 · 第二部分

11.1.输出的格式化

reprlib 模块提供了一个定制化版本的 repr() 函数，用于缩略显示大型或深层嵌套的容器对象 pprint 模块提供了更加复杂的打印控制，其输出的内置对象和用户自定义对象能够被解释器直接读取。当输出结果过长而需要折行时，“美化输出机制”会添加换行符和缩进，以更清楚地展示数据结构: textwrap 模块能够格式化文本段落，以适应给定的屏幕宽度: locale 模块处理与特定地域文化相关的数据格式。locale 模块的 format 函数包含一个 grouping 属性，可直接将数字格式化为带有组分隔符的样式:

11.2.模块

string 模块包含一个通用的 Template 类，具有适用于最终用户的简化语法。它允许用户在不更改应用逻辑的情况下定制自己的应用。

上述格式化操作是通过占位符实现的，占位符由 $ 加上合法的 Python 标识符（只能包含字母、数字和下划线）构成。一旦使用花括号将占位符括起来，就可以在后面直接跟上更多的字母和数字而无需空格分割。$$ 将被转义成单个字符 $:

1
2
3
4

from string import Template
t = Template('${village}folk send $$10 to $cause.')
t.substitute(village='Nottingham', cause='the ditch fund')
'Nottinghamfolk send $10 to the ditch fund.'

如果在字典或关键字参数中未提供某个占位符的值，那么 substitute() 方法将抛出 KeyError。对于邮件合并类型的应用，用户提供的数据有可能是不完整的，此时使用 safe_substitute() 方法更加合适 —— 如果数据缺失，它会直接将占位符原样保留。

11.3.操作二进制数据记录布局

struct 模块提供了 pack() 和 unpack() 函数，用于处理不定长度的二进制记录格式。

11.4. 多线程（之前学JAVA有点学吐了）

线程是一种对于非顺序依赖的多个任务进行解耦的技术。多线程可以提高应用的响应效率，当接收用户输入的同时，保持其他任务在后台运行。一个有关的应用场景是，将 I/O 和计算运行在两个并行的线程中。

以下代码展示了高阶的 threading 模块如何在后台运行任务，且不影响主程序的继续运行:

Copy

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

import threading, zipfile

class AsyncZip(threading.Thread):
    def __init__(self, infile, outfile):
        super().__init__()
        self.infile = infile
        self.outfile = outfile

    def run(self):
        with zipfile.ZipFile(self.outfile, 'w', zipfile.ZIP_DEFLATED) as f:
            f.write(self.infile)
        print('Finished background zip of:', self.infile)

background = AsyncZip('mydata.txt', 'myarchive.zip')
background.start()
print('The main program continues to run in foreground.')

background.join()    # 等待后台任务结束
print('Main program waited until background was done.')

多线程应用面临的主要挑战是，相互协调的多个线程之间需要共享数据或其他资源。为此，threading 模块提供了多个同步操作原语，包括线程锁、事件、条件变量和信号量。

尽管这些工具非常强大，但微小的设计错误却可以导致一些难以复现的问题。因此，实现多任务协作的首选方法是将所有对资源的请求集中到一个线程中，然后使用 queue 模块向该线程供应来自其他线程的请求。 应用程序使用 Queue 对象进行线程间通信和协调，更易于设计，更易读，更可靠。

11.5.日志记录

logging 模块提供功能齐全且灵活的日志记录系统,在最简单的情况下，日志消息被发送到文件或 sys.stderr

1
2
3
4
5
6

import logging
logging.debug('Debugging information')
logging.info('Informational message')
logging.warning('Warning:config file %s not found', 'server.conf')
logging.error('Error occurred')
logging.critical('Critical error -- shutting down')

11.6.弱引用（这个在JAVA的GC相关部分貌似也有）

weakref 模块提供的工具可以不必创建引用就能跟踪对象。 当对象不再需要时，它将自动从一个弱引用表中被移除，并为弱引用对象触发一个回调。 典型应用包括对创建开销较大的对象进行缓存

11.7.操作列表的工具（懒得看，要用的时候自然会查）

许多对于数据结构的需求可以通过内置列表类型来满足。 但是，有时也会需要具有不同效费比的替代实现。

array 模块提供了一种 array 对象，它类似于列表，但只能存储类型一致的数据且存储密度更高。 下面的例子显示了一个由存储为双字节无符号整数的数字 (类型码 "H") 组成的元组，而不是常规 Python int 对象列表所采用的每个条目 16 字节:

1
2
3
4
5
6

from array import array
a = array('H', [4000, 10, 700, 22222])
sum(a)
26932
a[1:3]
array('H', [10, 700])

collections 模块提供了一种 deque 对象，它类似于列表，但从左端添加和弹出的速度较快而在中间查找的速度较慢。 此种对象适用于实现队列和广度优先树搜索:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

from collections import deque
d = deque(["task1", "task2", "task3"])
d.append("task4")
print("Handling", d.popleft())
Handling task1
unsearched = deque([starting_node])
def breadth_first_search(unsearched):
    node = unsearched.popleft()
    for m in gen_moves(node):
        if is_goal(m):
            return m
        unsearched.append(m)

在替代的列表实现以外，标准库也提供了其他工具，例如 bisect 模块具有用于操作有序列表的函数:

1
2
3
4
5

import bisect
scores = [(100, 'perl'), (200, 'tcl'), (400, 'lua'), (500, 'python')]
bisect.insort(scores, (300, 'ruby'))
scores
[(100, 'perl'), (200, 'tcl'), (300, 'ruby'), (400, 'lua'), (500, 'python')]

heapq 模块提供了基于常规列表来实现堆的函数。 最小值的条目总是保持在位置零。 这对于需要重复访问最小元素而不希望运行完整列表排序的应用来说非常有用:

1
2
3
4
5
6

from heapq import heapify, heappop, heappush
data = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
heapify(data)                      # 将列表重新调整为堆顺序
heappush(data, -5)                 # 添加一个新条目
[heappop(data) for i in range(3)]  # 获取三个最小的条目
[-5, 0, 1]

11.8.十进制浮点算法

decimal 模块提供了一种 Decimal 数据类型用于十进制浮点运算。 相比内置的 float 二进制浮点实现，该类特别适用于 这个算有点用

• 财务应用和其他需要精确十进制表示的用途，
• 控制精度，
• 控制四舍五入以满足法律或监管要求，
• 跟踪有效小数位，或
• 用户期望结果与手工完成的计算相匹配的应用程序。

Decimal 表示的结果会保留尾部的零，并根据具有两个有效位的被乘数自动推出四个有效位。 Decimal 可以模拟手工运算来避免当二进制浮点数无法精确表示十进制数时会导致的问题。

使用不存在标准库的软件包和模块 需要特定的库

解决方法1：创建一个虚拟环境（virtual environment):一个目录树，安装有特定版本的Python版本，以及许多其他包

12.2.创建虚拟环境

用于创建虚拟环境的模块：venv 例如：python -m venv tutorial-env 虚拟环境的常见目录为.venv，通常会被隐藏 激活该虚拟环境的语句：tutorial-env\Scripts\activate 撤销激活一个虚拟环境 激活的虚拟环境并不会以任何方式改变PYTHONPATH；最佳实践实在bash中执行unset PYTHONPATH

12.3.使用pip管理包

作用：安装升级，移除软件包 默认情况下pip或从Python Package Index安装软件包 完整的用法请查阅

还有一个有趣的现象 0.1 + 0.1 + 0.1 == 0.3为False 这个原理就是上述 但是捏 如果一定要进行不精确表达，可以使用math.isclose()

BUT！

正如那篇文章的结尾所言，“对此问题并无简单的答案。” 但是也不必过于担心浮点数的问题！ Python 浮点运算中的错误是从浮点运算硬件继承而来，而在大多数机器上每次浮点运算的误差不超过 2**53 分之一。 这对大多数任务来说都已足够，但你确实需要记住它并非十进制算术，且每次浮点运算都可能会导致新的舍入错误。

而如果想要进行精确的十进制模块的计算，尝试使用decimal模块或者fractions模块 还有很多模块，但是我懒得赘述了 自己看看吧

15.1.表示性错误

定义：指的是某些十进制小数无法以二进制精确表示这一事实造成的失误本小节将详细解释 “0.1” 的例子，并说明你可以怎样亲自对此类情况进行精确分析。 假定前提是已基本熟悉二进制浮点表示法。

表示性错误 是指某些（其实是大多数）十进制小数无法以二进制（以 2 为基数的计数制）精确表示这一事实造成的错误。 这就是为什么 Python（或者 Perl、C、C++、Java、Fortran 以及许多其他语言）经常不会显示你所期待的精确十进制数值的主要原因。

为什么会这样？ 1/10 是无法用二进制小数精确表示的。 至少从 2000 年起，几乎所有机器都使用 IEEE 754 二进制浮点运算标准，而几乎所有系统平台都将 Python 浮点数映射为 IEEE 754 binary64 “双精度” 值。 IEEE 754 binary64 值包含 53 位精度，因此在输入时计算机会尽量将 0.1 转换为以 J/2**N 形式所能表示的最接近的小数，其中 J 为恰好包含 53 比特位的整数。 重新将

1

1 / 10 ~= J / (2**N)

写为

1

J ~= 2**N / 10

并且由于 J 恰好有 53 位 (即 >= 2**52 但 < 2**53)，N 的最佳值为 56:

1
2

2**52 <=  2**56 // 10  < 2**53
True

也就是说，56 是唯一能使 J 恰好有 53 位的 N 值。 这样 J 可能的最佳就是舍入之后的商:

1
2
3

q, r = divmod(2**56, 10)
r
6

由于余数超过 10 的一半，所以最佳近似值可通过向上舍入获得:

1
2

q+1
7205759403792794

因此在 IEEE 754 双精度下可能达到的 1/10 的最佳近似值为:

1

7205759403792794 / 2 ** 56

分子和分母都除以二则结果小数为:

1

3602879701896397 / 2 ** 55

请注意由于我们做了向上舍入，这个结果实际上略大于 1/10；如果我们没有向上舍入，则商将会略小于 1/10。 但无论如何它都不会是 精确的 1/10！

因此计算机永远不会 “看到” 1/10: 它实际看到的就是上面所给出的小数，即它能达到的最佳 IEEE 754 双精度近似值:

1
2

0.1 * 2 ** 55
3602879701896397.0

如果我们将该小数乘以 10**55，我们可以看到该值输出 55 个十进制数位:

1
2

3602879701896397 * 10 ** 55 // 2 ** 55
1000000000000000055511151231257827021181583404541015625

这意味着存储在计算机中的确切数字等于十进制数值 0.1000000000000000055511151231257827021181583404541015625。 许多语言（包括较旧版本的 Python）都不会显示这个完整的十进制数值，而是将结果舍入到 17 位有效数字:

1
2

format(0.1, '.17f')
'0.10000000000000001'

fractions 和 decimal 模块使得这样的计算更为容易:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

from decimal import Decimal
from fractions import Fraction

Fraction.from_float(0.1)
Fraction(3602879701896397, 36028797018963968)

(0.1).as_integer_ratio()
(3602879701896397, 36028797018963968)

Decimal.from_float(0.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')

format(Decimal.from_float(0.1), '.17')
'0.10000000000000001'

自己看看吧，讲得还是挺清楚的