第一章 快速上手 ：基础知识

1.3 x%y=x-((x//y)*y) 注意求余运算符

​ 向下圆整，如果是负数，则更远离0

10//3
10//-3
10%3
10%-3

​ 十六进制：0x 八进制：0o 十进制：0b

0xAF=175
0o10=8
0b1011010010=722

1.6输入

input("The meaning of life:")

x=input("x:")
y=input("y:")
print(int(x)*int(y))

1.7函数

​ abs 为绝对值 round 为圆整到最近的整数

1.8模块

​ import为导入模块

​ math模块中 floor:小于或等于给数的最大整数

​ ceil:大于或等于给数的最小整数

​ 用一次 from modole import function

from math import sqrt
sqrt()

​ 定义变量来应用函数

foo=math.sqrt
foo(4)

1.81 cmath和复数

j 为虚数单位（即为i）

1.8.2回到未来

—future—

海龟绘图法 turtle.forward(100)

1.10.1单引号与双引号以及对引号转义

​ ''的意义和C中一样，转义字符

1.10.2拼接字符串

​ '+'可用于连接字符串

"Hello,"+"World!"
x="Hello."
y="World"
x+y

1.10.3字符串表示str 和repr

'\n’为换行符

1.10.4长字符串，原始字符串和字节

1.长字符串

要表示很长的字符串（换行），可使用三引号或者三个双引号

常规字符串也可以跨行，只要再末尾加上反斜杠’’

2.原始字符串

前缀r，将不会对反斜杠进行特殊处理，但不能以单个反斜杠结尾

3.Unicode，butes和bytearray

小结：本节函数

abs(number) 返回绝对值

cmath.sqrt(number) 返回平方根，可用于负数

math.sqrt() 返回平方根，不可用于复数

floa他（object） 转化为浮点型

help([object]) 提供交会时帮助

input() 输入

int() 转化为整型

math.ceil() 浮点型方式返回向上圆整结果

math.floor() 浮点型方式返回向下圆整结果

pow(x,y[ ,z]) 返回X的Y次方对z求模的结果

print 输出

round(number[ ,ndights]) 四舍五入为指定精度

第二章 列表与元组

2.1 序列概述

a=['long',1]
b=['weng',2]
database=[a,b]

2.2通用的序列操作

2.2.1索引

greeting = 'Hello'
greeting[0]
greeting[-1]

括号内为负数时从右往左数，可直接在字符串后引用,也是从零开始

fourth=input('year: ')[3]
year:2005
    fourth
    

2.2.2切片

除了用索引引用一个时，可以用切片提取一部分的，第一个索引为包含的第一个元素的编号，第二个索引为切片后余下的第一个元素的编号，中间用冒号隔开

步长：

[ a: b : c ],a,b同上，而c则为步长，从a开始跳过c各单位取数，也可以为负数从右向左

a=[1,2,3,4,5,6]
a[-3:-1]
[4,5]

2.2.3序列相加（拼接）

必须拼接相同的类型序列 用‘+’连接

2.2.4相乘

序列与数相乘代表序列的重复次数

2.25成员资格

成员资格： x in y,True or False

database = [['albert','1234'],['dilbert','4242'],['smith','7542'],['jones','9843']]
username = input('Usename: ')
pin = input('PIN code: ')
if[username,pin] in database: print('Access granted')

2.3列表：python的主力

2.3.1函数list

list('Hello')
['H','e','l','l','o']

可将任意序列作为list的参数

字符列表转换为字符串：‘ ’.join(somelist)

2.3.2基本的列表操作

1.修改列表：给元素赋值

通过索引表示法来给特定位置的元素进行赋值

2.删除元素

用del语句进行删除

names = ['a','b','c']
del names[2]

3给切片赋值

name = list('perl')
['p','e','r','l']
name[2:] = list('ar')

name = list('perl')
name[1:] = list('ython')

name = [1,5]
name[1:1] = [2,3,4]

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

2.3.3列表方法

1.append

将对象添加到列表末尾

1st=[1,2,3]
1st.append(1)

2.clear

清空列表

1st=[1,2,3]
1st.clear()

3.copy

常规赋值，相关联

a=[1,2,3]
b=a
b[1]=4
a
a=[1,4,3]

a=[1,2,3,4]
b=a.copy()
a
[1,2,3,4]

4.count

用于计算出现了多少次

['to','to','to','dg','tr'].count('to')

x=['to','to','to','dg','tr']
x.count('to')

5.extend

列表来扩展列表

a=[1,2,3]
b=[4,5,6]
a.extend(b)
a
[1,2,3,4,5,6]

a=[1,2,3]
b=[4,5,6]
a+b
a
[1,2,3]

6.index

查找指定值第一次出现的索引

knights=['we','are','the','knights','who','say','ni']
knights.index('who')
4

7.insert

将一个对象插入列表

numbers=[1,2,3,4,5,6,7]
nimbers.insert(3,'four')
numbers
[1,2,3,'four',5,6,7]

8.pop

从列表删去一个元素，并返回这一元素

x=[1,2,3]
x.pop()
3
x.pop(0)
1
x
2

x=[1,2,3]
x.append(x.pop())
x
[1,2,3]

9.remove

删除第一个为指定值的元素

x=['to','bo','or','not','to','be']
x.remove('be')
x
['to','or','not','to','be']

10.reverse

按相反的顺序排列

x=[1,2,3]
x.reverse()
x
[3,2,1]

11.sort

对列表就地排序

x=[4,6,2,1,7,9]
x.sort()
x
[1,2,4,6,7,9]

x=[4,6,2,1,7,9]
y=x.copy()
y.sort()
x
[4,6,2,1,7,9]
y
[1,2,4,6,7,9]

x=[4,6,2,1,7,9]
y=sorted(x)
y
[1,2,4,6,7,9]

12.高级排序

sort(sorted)接受两个可选参数：key 和 reverse

key:不会直接比较大小而是通过为每一个函数设置一个键，再根据这些键进行排序

x=['a','aaaaa','aa','aaaa','aaa']
x.sort(key=len)
x
['a','aa','aaa','aaaa','aaaaa']

reverse:为其指定一个真值，以指出是否按相反顺序进行排序

x=[4,6,2,1,7,9]
x.sort(reverse=True)
x
[9,7,6,4,2,1]

2.4元组：不可修改的序列

用逗号隔开，自动创建元组

1,2,3
(1,2,3)

(1,2,3)
(1,2,3)

（）
（）

42
42

42，
（42，）

3*(40+2)
126
3*(40+2,)
(42,42,42)

tuple:将序列作为参数，并将其转换为元组，如果已经是元组，则原封不动的返回,和list相似

tuple([1,2,3])
(1,2,3)
tuple('abc')
('a','b','c')

小结

1.序列：

序列：列表，字符串，元组

​ 列表可变，元组和字符串不可变

2.成员资格

3.方法

4.新函数

len(seq) 返回序列长度

list(seq) 将序列转换为列表

max(arges) 返回列表或参数中的最大值

min(arges) 返回列表或参数中的最小值

reverse(seq) 反向迭代序列

sorted（seq) 返回一个有序列表

tuple(seq) 将序列转换为元组

第三章 使用字符串

3.2设置字符串格式：精简版

format = "Hello,%s. %s enough for ya?"
values = ('world','Hot')
format%values
'Hello,world.Hot enough for ya?'

%转换说明符 s意味着将值视为字符串进行格式转换 %.3f将值格式设置为包含3位小数的浮点数

"{},{} and {}".format('first','second','third')
first,second and third

.format 需替换的部分用{}包括起来（里面可以有值）之后将需要的部分包含在后面的（）括号中用’‘包起

也可以用索引，则无需按顺序排列

"{2},{1} and {0}".format('third','second','first')
first,second and third

也可以直接命名

"{2},{1} and {0}".format('0=third','1=second','2=first')
first,second and third

如果变量与替换字段同名 则可以用简写 但在前面需要添加f

from math import e
f"Euler's constant is roughly {e}."
"Euler's constant is roughly 2.7182818."

3.3设置字符串的格式：完整版

"{foo}{}{bar}{}".format(1,2,bar=4,foo=3)

3.3.1 替换字段名

3.3.2 基本转换

‘!’+‘s’,‘r’,‘a’ ‘s’:普通字符串版本 ‘r’:字符串字面量 ‘a’：ASCLL字符表示

‘:’+

3.3.3 宽度，精度和千位分隔符

‘:’ 宽度 ‘.’:精度 ','千位分隔符

3.3.4 符号，对齐和用0填充

‘<’:左对齐 ‘>’：右对齐 ‘^’:居中

‘+’：加上符号（在对齐说明符后）

‘#’:符号说明符和宽度之间，

3.4.1 center

在两边填充字符（默认为空格）让字符串居中

‘.center(39,"#")’

3.4.2 find

在字符串中找子串，返回 索引 .find( , 起点，终点)

3.4.3 join

合并字符串

3.4.4 lower

转变为小写 title转变为大写

3.4.5 replace

替换字符串 .replace(’ ‘,’ ')

3.4.6 split

拆分字符串 .split(’ ')

3.4.7 strip

删除字符串中指定值 .strip(’ ')

3.4.8 translate

table = str.maketrans('cs','kz')
'this is an incredible test'.translate(table)
'thiz iz aninlredible tezt'

3.4.9 判断字符串是否满足特定的条件

'is ’

新函数

.capwords(s[ , sep]) 使用split拆分s，将每项的首字母大写，在以空格为分隔符将他们合并起来

ascii(obj) 创建指定对象的ASCII表示

第四章 当索引行不通

4.2 创建和使用字典

phonebook = {‘alice’:‘3121’,‘robin’:‘1641’,‘cecil’:‘2155’} 键 ： 值 合成项

4.2.1 函数 dict

从其他映射或键值中创建一个字典

a=[('name','robin'),('age','19')]
d=dict(items)
d
{'age':19,'name':robin}

d=dict(name='robin',age='19')
d
{'age':19,'name':robin}

4.2.4 字典方法

1.clear

clear会清除所有

2.copy

浅复制 替换不受影响，修改则会

form copy import deepcopy 深复制 则不会受影响

3.fromkey

创建一个字典，其中包含指定键，其中的值为None

也可以给它复制

dict.fromkey(['name','age'],['unknown'])
{'age':'unknown','name':'unknown'}

4.get

从字典中访问，如果没有，则返回None，也可以自己设置

5.items

返回一个字典里面的列表，其中每个元素都为（key,value）

6.keys

返回字典中的键

7.pop

获取指定键，并将键-值同时从字典中删除

8.popitem

同pop，但是随机

9.setdefault

类似于get，但如果原字典中没有该值，则会自动添加

10.update

使用一个字典的项来更新另一个字典，如果包含相同的键，则替换其中的值

11.values

类似于keys,但其中可以包含相同的值

第五章 条件，循环和其他语句

5.4.4 elif

elif==else if

5.4.6 更复杂的运算

1比较运算符

is 检查两个对象是否相同（指向同一个对象），而‘==’则判断是否相等

in 是否是容器的成员

可以是用链式比较

2.布尔运算符

‘||’==and 还有 or 和not

5.5.4 一些迭代工具

1.并行迭代

zip将两个序列缝合起来 并返回一个有元组组成的序列，以最短的长度来作为标准

2.迭代是获取索引

enumerate 获取想要的索引，并可进行替换

5.7 三人行

5.7.1 什么都不做

pass 过

5.7.2 使用del来删除

5.8 小结

5.8.1 新函数

chr(n)

返回一个字符串，字符串对应于输入的顺序值n

eval（source[,globals[,lcols]])

计算并返回字符串表示的表达式的结果

exec（source[,globals[,lcols]])

将字符串作为语句执行

enumerate（seq）

生成可迭代的索引 值

ord( c)

接 受 一 个 只 包 含 一 个 字 符 的 字 符 串， 并 返 回 这 个 字 符 的 顺 序 值（ 一 个 整 数）

range([ start,] stop[, step])

创 建 一 个 由 整 数 组 成 的 列 表

reversed( seq)

按 相 反 的 顺 序 返 回 seq 中 的 值， 以 便 用 于 迭 代

sorted( seq[, cmp][, key][, reverse])

\返 回 一 个 列 表， 其 中 包 含 seq 中 的 所 有 值 且 这 些 值 是 经 过 排 序 的

xrange([ start,] stop[, step])

创 建 一 个 用 于 迭 代 的 xrange 对 象

zip( seq1, seq2,…)

创 建 一 个 适 合 用 于 并 行 迭 代 的 新 序 列

eval()

函数用来执行一个字符串表达式，并返回表达式的值。

第六章 抽象

6.4.4 收集参数

def print(*paramas)

*将提供的所以值都放在一个元组里面，也就是将这些值收集起来

** 如果拥有两个星号，则会得到一个字典（收集关键字参数）

[]:列表 （）:元组 {}：字典

小结 函数

map( func, seq[, seq, …]) 对 序 列 中 的 所 有 元 素 执 行 函 数 filter( func, seq) 返 回 一 个 列 表， 其 中 包 含 对 其 执 行 函 数 时 结 果 为 真 的 所 有 元 素

reduce( func, seq[, initial]) 等 价 于 func( func( func( seq[ 0], seq[ 1]), seq[ 2]), …)

sum( seq) 返 回 seq 中 所 有 元 素 的 和

apply( func[, args[, kwargs]]) 调 用 函 数（ 还 提 供 要 传 递 给 函 数 的 参数

blocked()

将括号内的元素变为空格

第七章 再谈抽象

对象：

由属性和方法组成。属 性 不 过 是 属 于 对 象 的 变 量， 而 方 法 是 存 储 在 属 性 中 的 函 数。 相 比 于 其 他 函 数，（ 关 联 的） 方 法 有 一 个 不 同 之 处， 那 就 是 它 总 是 将 其 所 属 的 对 象 作 为 第 一 个 参 数， 而 这 个 参 数 通 常 被 命 名 为 self。

多态：

对不同类型的对象可以执行相同的操作

封装：

对外部隐藏有关对象工作原理的细节

继承：

可基于通用类创建专用类

class:创建类

7.2.7 深入讨论继承

issubclass:确定一个类是否是另一个类的子类

bases:想知道一个类的子类

isinstance:是否为特殊类

class:获悉对象是哪一个类

7.2.8 多个超类

多重继承

如果两个类中有相同的方法，则前一个将覆盖后一个，可以通过顺序来决定执行的方法

Talk.register(Herring)：将Herring注册为Talker

新函数：

callable( object)

判 断 对 象 是 否 是 可 调 用 的（ 如 是 否 是 函 数 或 方 法）

getattr( object, name[, default])

获 取 属 性 的 值， 还 可 提 供 默 认 值

hasattr( object, name)

确 定 对 象 是 否 有 指 定 的 属 性

isinstance( object, class)

确 定 对 象 是 否 是 指 定 类 的 实 例

issubclass( A, B)

确 定 A 是 否 是 B 的 子 类

random.choice( sequence)

从 一 个 非 空 序 列 中 随 机 地 选 择 一 个 元 素

setattr( object, name, value)

将 对 象 的 指 定 属 性 设 置 为 指 定 的 值 type( object) 返 回 对 象 的 类 型

第八章 异常

一些内置的异常类

Exception 几 乎 所 有 的 异 常 类 都 是 从 它 派 生 而 来 的 AttributeError 引 用 属 性 或 给 它 赋 值 失 败 时 引 发

OSError 操 作 系 统 不 能 执 行 指 定 的 任 务（ 如 打 开 文 件） 时 引 发， 有 多 个 子 类

IndexError 使 用 序 列 中 不 存 在 的 索 引 时 引 发， 为 LookupError 的 子 类

KeyError 使 用 映 射 中 不 存 在 的 键 时 引 发， 为 LookupError 的 子 类

NameError 找 不 到 名 称；（ 变 量） 时 引 发

SyntaxError 代 码 不 正 确 时 引 发

TypeError 将 内 置 操 作 或 函 数 用 于 类 型 不 正 确 的 对 象 时 引 发

ValueError 将 内 置 操 作 或 函 数 用 于 这 样 的 对 象 时 引 发： 其 类 型 正 确 但 包 含 的 值 不 合 适

ZeroDivisionError 在 除 法 或 求 模 运 算 的 第 二 个 参 数 为 零 时 引 发

8.3 　 捕 获 异 常

前 面 说 过， 异 常 比 较 有 趣 的 地 方 是 可 对 其 进 行 处 理， 通 常 称 之 为 捕 获 异 常。 为 此， 可 使 用 try/ except 语 句。 假 设 你 创 建 了 一 个 程 序， 让 用 户 输 入 两 个 数， 再 将 它 们 相 除， 如 下 所 示：

x = int( input(' Enter the first number: '))
y = int( input(' Enter the second number: ')) 
print( x / y)

8.3.2 多个except语句

try: 
    x = int( input(' Enter the first number: '))
    y = int( input(' Enter the second number: ')) 		print( x / y) 
except ZeroDivisionError: 
    print(" The second number can't be zero!")
except TypeError: 
    print(" That wasn't a number, was it?")

8.3.6 万事大吉时

一 种 更 佳 的 替 代 方 案 是 使 用 空 的 except 子 句 来 捕 获 所 有 属 于 类 Exception（ 或 其 子 类） 的 异 常。 你 不 能 完 全 确 定 这 将 捕 获 所 有 的 异 常， 因 为 try/ except 语 句 中 的 代 码 可 能 使 用 旧 式 的 字 符 串 异 常 或 引 发 并 非 从 Exception 派 生 而 来 的 异 常。 然 而， 如 果 使 用 except Exception as e， 就 可 利 用 8.3.4 节 介 绍 的 技 巧 在 这 个 小 型 除 法 程 序 中 打 印 更 有 用 的 错 误 消 息。

8.3.7 　 最 后

x = None
try: 
    x = 1 / 0 
 finally:
    print(' Cleaning up ...') 
    del x

8.7 　 小 结

本 章 介 绍 了 如 下 重 要 主 题。

异 常 对 象： 异 常 情 况（ 如 发 生 错 误） 是 用 异 常 对 象 表 示 的。 对 于 异 常 情 况， 有 多 种 处 理 方 式； 如 果 忽 略， 将 导 致 程 序 终 止。

引 发 异 常： 可 使 用 raise 语 句 来 引 发 异 常。 它 将 一 个 异 常 类 或 异 常 实 例 作 为 参 数， 但 你 也 可 提 供 两 个 参 数（ 异 常 和 错 误 消 息）。 如 果 在 except 子 句 中 调 用 raise 时 没 有 提 供 任 何 参 数， 它 将 重 新 引 发 该 子 句 捕 获 的 异 常。

自 定 义 的 异 常 类： 你 可 通 过 从 Exception 派 生 来 创 建 自 定 义 的 异 常。

捕 获 异 常： 要 捕 获 异 常， 可 在 try 语 句 中 使 用 except 子 句。 在 except 子 句 中， 如 果 没 有 指 定 异 常 类， 将 捕 获 所 有 的 异 常。 你 可 指 定 多 个 异 常 类， 方 法 是 将 它 们 放 在 元 组 中。 如 果 向 except 提 供 两 个 参 数， 第 二 个 参 数 将 关 联 到 异 常 对 象。 在 同 一 条 try/ except 语 句 中， 可 包 含 多 个 except 子 句， 以 便 对 不 同 的 异 常 采 取 不 同 的 措 施。

else 子 句： 除 except 子 句 外， 你 还 可 使 用 else 子 句， 它 在 主 try 块 没 有 引 发 异 常 时 执 行。

finally： 要 确 保 代 码 块（ 如 清 理 代 码） 无 论 是 否 引 发 异 常 都 将 执 行， 可 使 用 try/ finally， 并 将 代 码 块 放 在 finally 子 句 中。

异 常 和 函 数： 在 函 数 中 引 发 异 常 时， 异 常 将 传 播 到 调 用 函 数 的 地 方（ 对 方 法 来 说 亦 如 此）。

警 告： 警 告 类 似 于 异 常， 但（ 通 常） 只 打 印 一 条 错 误 消 息。 你 可 指 定 警 告 类 别， 它 们 是 Warning 的 子 类。

8.7.1 　 本 章 介 绍 的 新 函 数

warnings.filterwarnings( action, category = Warning, …) 用 于 过 滤 警 告

warnings.warn( message, category = None) 用 于 发 出 警 告

第九章 魔法方法，特性和迭代器

9.3.1 　 基 本 的 序 列 和 映 射 协 议

len( self)：

这 个 方 法 应 返 回 集 合 包 含 的 项 数， 对 序 列 来 说 为 元 素 个 数， 对 映 射 来 说 为 键-值 对 数。 如 果__len__ 返 回 零（ 且 没 有 实 现 覆 盖 这 种 行 为 的__nonzero__）， 对 象 在 布 尔 上 下 文 中 将 被 视 为 假（ 就 像 空 的 列 表、 元 组、 字 符 串 和 字 典 一 样）。

getitem( self, key)：

这 个 方 法 应 返 回 与 指 定 键 相 关 联 的 值。 对 序 列 来 说， 键 应 该 是 0 ~ n - 1 的 整 数（ 也 可 以 是 负 数， 这 将 在 后 面 说 明）， 其 中 n 为 序 列 的 长 度。 对 映 射 来 说， 键 可 以 是 任 何 类 型。

setitem( self, key, value)：

这 个 方 法 应 以 与 键 相 关 联 的 方 式 存 储 值， 以 便 以 后 能 够 使 用__getitem__ 来 获 取。 当 然， 仅 当 对 象 可 变 时 才 需 要 实 现 这 个 方 法。

delitem( self, key)：

这 个 方 法 在 对 对 象 的 组 成 部 分 使 用__del__ 语 句 时 被 调 用，应 删 除 与 key 相 关 联 的 值。 同 样， 仅 当 对 象 可 变（ 且 允 许 其 项 被 删 除） 时， 才 需 要 实 现 这 个 方 法。

9.5.1 函数property

9.5.3 　getattr、setattr 等 方 法

getattribute( self, name)：

在 属 性 被 访 问 时 自 动 调 用（ 只 适 用 于 新 式 类）。

getattr( self, name)：

在 属 性 被 访 问 而 对 象 没 有 这 样 的 属 性 时 自 动 调 用。

setattr( self, name, value)：

试 图 给 属 性 赋 值 时 自 动 调 用。

delattr( self, name)：

试 图 删 除 属 性 时 自 动 调 用。

9.6 迭代器

iter__与__next

9.7 生成器

yield语句

9.9 　 小 结

新 式 类 和 旧 式 类：

Python 类 的 工 作 方 式 在 不 断 变 化。 较 新 的 Python 2 版 本 有 两 种 类， 其 中 旧 式 类 正 在 快 速 退 出 舞 台。 新 式 类 是 Python 2.2 引 入 的， 提 供 了 一 些 额 外 的 功 能， 如 支 持 函 数 super 和 property， 而 旧 式 类 不 支 持。 要 创 建 新 式 类， 必 须 直 接 或 间 接 地 继 承 object 或 设 置__metaclass__。

魔 法 方 法：

Python 中 有 很 多 特 殊 方 法， 其 名 称 以 两 个 下 划 线 开 头 和 结 尾。 这 些 方 法 的 功 能 各 不 相 同， 但 大 都 由 Python 在 特 定 情 况 下 自 动 调 用。 例 如__init__ 是 在 对 象 创 建 后 调 用 的。

构 造 函 数：

很 多 面 向 对 象 语 言 中 都 有 构 造 函 数， 对 于 你 自 己 编 写 的 每 个 类， 都 可 能 需 要 为 它 实 现 一 个 构 造 函 数。 构 造 函 数 名 为__init__， 在 对 象 创 建 后 被 自 动 调 用。

重 写：

类 可 重 写 其 超 类 中 定 义 的 方 法（ 以 及 其 他 任 何 属 性）， 为 此 只 需 实 现 这 些 方 法 即 可。 要 调 用 被 重 写 的 版 本， 可 直 接 通 过 超 类 调 用 未 关 联 版 本（ 旧 式 类）， 也 可 使 用 函 数 super 来 调 用（ 新 式 类）。

序 列 和 映 射：

要 创 建 自 定 义 的 序 列 或 映 射， 必 须 实 现 序 列 和 映 射 协 议 指 定 的 所 有 方 法， 其 中

iter( obj)

从 可 迭 代 对 象 创 建 一 个 迭 代 器

next( it)

让 迭 代 器 前 进 一 步 并 返 回 下 一 个 元 素

property( fget, fset, fdel, doc)

返 回 一 个 特 性； 所 有 参 数 都 是 可 选 的

super( class, obj)

返 回 一 个 超 类 的 关 联 实 例