Python基础知识思维导图

纯干货！你要的Python基础知识点整理好了！本文对变量、语法、条件循环、面向对象、函数、语法规则符、文件的读取及保存、错误异常这些方面进行了全量笔记整理。

Python

搭建Python环境

安装python

安装文本编辑器geany

编写程序时，编辑器的语法突出功能可帮助你快速找出某些语法错误。看到Python代码以普通句子的颜色显示，或者普通句子以Python代码的颜色显示时，就可能意味着文件中存在引号不匹配的情况。

配置python命令路径

符合标准Python约定的文件名：使用小写字母和下划线

编程语法规则

严格缩进

可以拼接

按行执行，换行即表示新的一句语句，解释器读取一行，翻译一行，翻译一行，执行一行

注释

#标志之后的所有文本都是注释。

有时候，程序员在测试代码时，会在一行代码前面加上#，临时删除它。这称为“注释掉”代码。在你想搞清楚为什么程序不工作时，这样做可能有用。稍后，如果你准备还原这一行代码，可以去掉#。

语句

流程控制语句

代码块

一些代码行可以作为一组，放在“代码块”中。可以根据代码行的缩进，知道代码块的开始和结束。

有3条规则

1．缩进增加时，代码块开始。

2．代码块可以包含其他代码块。

3．缩进减少为零，或减少为外面包围代码块的缩进，代码块就结束了。

控制流语句

if语句

将在语句的条件为True时执行。如果条件为False，子句将跳过。

包含以下部分：

if关键字；

条件（即求值为True或False的表达式）；

冒号；

在下一行开始，缩进的代码块（称为if子句）。

else语句

if子句后面有时候也可以跟着else语句。只有if语句的条件为False时，else子句才会执行。

else语句中包含下面部分：

else关键字；

冒号；

在下一行开始，缩进的代码块（称为else子句）。

elif语句

elif语句是“否则如果”，总是跟在if或另一条elif语句后面。它提供了另一个条件，仅在前面的条件为False时才检查该条件。

elif语句总是包含以下部分：

elif关键字；

条件（即求值为True或False的表达式）；

冒号；

在下一行开始，缩进的代码块（称为elif子句）。

while循环语句

break语句

continue语句

for循环和range()函数

for i in range(12, 16):

第一个参数是for循环变量开始的值，第二个参数是上限，但不包含它，也就是循环停止的数字。

for i in range(0, 10, 2):

range()函数也可以有第三个参数。前两个参数分别是起始值和终止值，第三个参数是“步长”。步长是每次迭代后循环变量增加的值。

from import语句

global语句

在一个函数内修改全局变量

正则表达式

运算符

比较操作符

== 等于

请注意，整型或浮点型的值永远不会与字符串相等。表达式42 == '42'❶求值为False是因为，Python认为整数42与字符串'42'不同。

!= 不等于

仅用于整型和浮点型值。

> 大于

仅用于整型和浮点型值。

仅用于整型和浮点型值。

>= 大于等于

仅用于整型和浮点型值。

布尔操作符

and

True and True ==> True

True and False ==> False

False and True ==> False

False and False ==> False

or

True or True ==> True

True or False ==> True

False or True ==> True

False or False ==> False

not

和and和or不同，not操作符只作用于一个布尔值（或表达式）。not操作符求值为相反的布尔值。

和算术操作符一样，布尔操作符也有操作顺序。在所有算术和比较操作符求值后，Python先求值not操作符，然后是and操作符，然后是or操作符。

赋值操作符

=

将右边的值放到左边的变量中。

计算符

** 指数

% 取模/取余数

// 整除/商数取整

/ 除法

* 乘法

- 减法

+ 加法

变量

在程序中可随时修改变量的值，而Python将始终记录变量的最新值。

变量名注意事项

变量名只能包含字母、数字和下划线。变量名可以字母或下划线打头，但不能以数字打头，例如，可将变量命名为message_1，但不能将其命名为1_message。

不要将Python关键字和函数名用作变量名，即不要使用Python保留用于特殊用途的单词，如print （请参见附录A.4）。

变量名应既简短又具有描述性。例如，name比n好，student_name比s_n好，name_length比length_of_persons_name好。

慎用小写字母l和大写字母O，因为它们可能被人错看成数字1和0。

局部变量和全局变量

局部变量

在被调用函数内赋值的变元和变量，处于该函数的“局部作用域”。处于局部作用域的变量，被称为“局部变量”。

局部作用域可以访问全局变量；

一个函数的局部作用域中的代码，不能使用其他局部作用域中的变量。

如果在不同的作用域中，你可以用相同的名字命名不同的变量。

全局变量

在所有函数之外赋值的变量，属于“全局作用域”。处于全局作用域的变量，被称为“全局变量”。

全局作用域中的代码不能使用任何局部变量；

在技术上，在Python中让局部变量和全局变量同名是完全合法的。

4条法则

1．如果变量在全局作用域中使用（即在所有函数之外），它就总是全局变量。

2．如果在一个函数中，有针对该变量的global语句，它就是全局变量。

3．否则，如果该变量用于函数中的赋值语句，它就是局部变量。

4．但是，如果该变量没有用在赋值语句中，它就是全局变量。

数据类型

“布尔”数据类型

只有两种值：True和False

两边没有引号。

它们总是以大写字母T或F开头，后面的字母小写。

如果大小写不正确，或者试图使用True和False作为变量名，Python就会给出错误信息。

像其他值一样，布尔值也用在表达式中，并且可以保存在变量中。

字符串

用引号括起的都是字符串，其中的引号可以是单引号，也可以是双引号，这种灵活性让你能够在字符串中包含引号和撇号

修改字符串的大小写

title()：以首字母大写的方式显示每个单词，即将每个单词的首字母都改为大写。这很有用，因为你经常需要将名字视为信息。

函数title() 不需要额外的信息，因此它后面的括号是空的。

upper()：将字符串改为全部大写

lower()：将字符串改为全部小写

合并字符串

使用加号（+ ）来合并字符串。又叫拼接

将非字符串值表示为字符串

函数str()

空白

泛指任何非打印字符，如空格、制表符和换行符

空格

制表符

\t

换行符

\n

可以作为一个字符出现在字符串中，单独使用须加字符串的引号

字符串和列表实际上很相似，只要你认为字符串是单个文本字符的列表。对列表的许多操作，也可以作用于字符串：按下标取值、切片、用于for循环、用于len()，以及用于in和not in操作符。

列表和字符串在一个重要的方面是不同的。列表是“可变的”数据类型，它的值可以添加、删除或改变。但是，字符串是“不可变的”，它不能被更改。

数字

整数

可对整数执行加（+ ）减（- ）乘（* ）除（/ ）运算。

使用两个乘号表示乘方运算

支持运算次序，因此你可在同一个表达式中使用多种运算。你还可以使用括号来修改运算次序，让Python按你指定的次序执行运算

空格不影响计算表达式的方式，它们的存在旨在让你阅读代码时，能迅速确定先执行哪些运算。

浮点数

带小数点的数字都称为浮点数。大多数编程语言都使用了这个术语，它指出了这样一个事实：小数点可出现在数字的任何位置。每种编程语言都须细心设计，以妥善地处理浮点数，确保不管小数点出现在什么位置，数字的行为都是正常的。

从很大程度上说，使用浮点数时都无需考虑其行为。你只需输入要使用的数字，Python通常都会按你期望的方式处理它们

None值

在Python中有一个值称为None，它表示没有值。None是NoneType数据类型的唯一值（其他编程语言可能称这个值为null、nil或undefined）。就像布尔值True和False一样，None必须大写首字母N。

列表

概念及特征

由一系列按特定顺序排列的元素组成。

可以将任何东西加入列表中，其中的元素之间可以没有任何关系

给列表指定一个表示复数的名称（如letters 、digits 或names ）是个不错的主意。

在Python中，用方括号（[] ）来表示列表，并用逗号来分隔其中的元素。

访问及操作列表

用下标取得列表中的单个值

下标只能是整数，不能是浮点值。

列表中第一个值的下标是0，第二个值的下标是1，第三个值的下标是2，依此类推。

负数下标：虽然下标从0开始并向上增长，但也可以用负整数作为下标。整数值−1指的是列表中的最后一个下标，−2指的是列表中倒数第二个下标，以此类推。

利用切片取得子列表

切片输入在一对方括号中，像下标一样，但它有两个冒号分隔的整数。

用len()取得列表的长度

用下标改变列表中的值

列表连接和列表复制

用del语句从列表中删除值

多重赋值技巧

增强的赋值操作

用index()方法在列表中查找值

用append()和insert()方法在列表中添加值

用remove()方法从列表中删除值

用sort()方法将列表中的值排序

使用列表

列表用于循环

in和not in操作符

元组数据类型

除了两个方面，“元组”数据类型几乎与列表数据类型一样。

首先，元组输入时用圆括号()，而不是用方括号[]。

元组像字符串一样，是不可变的。元组不能让它们的值被修改、添加或删除。

元组的优点

可以用元组告诉所有读代码的人，你不打算改变这个序列的值。如果需要一个永远不会改变的值的序列，就使用元组。

因为它们是不可变的，它们的内容不会变化，Python可以实现一些优化，让使用元组的代码比使用列表的代码更快。

列表与元组类型的转换

list()

转换为列表

tuple()

转换为列表

字典

概念及特征

字典是一系列键—值对 。

字典用放在花括号{} 中的一系列键—值对表示。

每个键 都与一个值相关联，你可以使用键来访问与之相关联的值。

键和值之间用冒号分隔，而键—值对之间用逗号分隔。

在字典中，你想存储多少个键—值对都可以。

与键相关联的值可以是数字、字符串、列表乃至字典。事实上，可将任何Python对象用作字典中的值。

不像列表，字典中的表项是不排序的。

虽然确定两个列表是否相同时，表项的顺序很重要，但在字典中，键-值对输入的顺序并不重要。

因为字典是不排序的，所以不能像列表那样切片。

与大多数编程概念一样，要熟练使用字典，也需要一段时间的练习。

使用字典一段时间后，你就会明白为何它们能够高效地模拟现实世界中的情形。

创建一个空字典

yhy={}

添加键—值对

yhy['age']=43

访问字典中的值

用in关键字，可以看看输入的名字是否作为键存在于字典中，就像查看列表一样。

如果该名字在字典中，你可以用方括号访问关联的值。

如果不在，你可以用同样的方括号语法和赋值操作符添加它。

get()方法

两个参数：

要取得其值的键

如果该键不存在时，返回的备用值

setdefault()方法

为字典中某个键设置一个默认值，当该键没有任何值时赋予该值。

如果该键已经有值了，则不修改该键值

setdefault()方法是一个很好的快捷方式，可以确保一个键存在。

修改字典中的值

　删除键—值对

del 语句

遍历字典

遍历所有的键—值对

for循环+方法items（）

遍历字典中的所有键

按顺序遍历字典中的所有键

一种办法是在for 循环中对返回的键进行排序。

函数sorted()

for循环+方法keys()

遍历字典中的所有值

for循环+方法values()

嵌套

字典列表

在字典中存储列表

在字典中存储字典

包

由多个不同类型的模块组成

模块的组成

函数

方法

方法和函数是一回事，只是它是调用在一个值上。

修改字符串的大小写

title()：以首字母大写的方式显示每个单词，即将每个单词的首字母都改为大写。单词与单词之间用空格隔开

upper()：将字符串改为全部大写

lower()：将字符串改为全部小写

剔除字符串中的空白

rstrip()：剔除字符串末尾没有空白

lstrip()：剔除字符串开头的空白

strip()：同时剔除字符串两端的空白

在实际程序中，这些剥除函数最常用于在存储用户输入前对其进行清理

将非字符串值表示为字符串

函数str()

在变量 后面以句点（. ）相连。

每个方法后面都跟着一对括号，这是因为方法通常需要额外的信息来完成其工作。这种信息是在括号内提供的。

有的函数不需要额外的信息，因此它后面的括号是空的。

Python提供了这样一些内建函数，但你也可以编写自己的函数。“函数”就像一个程序内的小程序。

函数的创建

def语句

def hello（name）：

它定义了一个名为hello()的函数。

def语句之后的代码块是函数体。

这段代码在函数调用时执行，而不是在函数第一次定义时执行。

name为变元。“变元”是一个变量，当函数被调用时，参数就存放在其中。

关于变元有一件特殊的事情值得注意：保存在变元中的值，在函数返回后就丢失了。

return语句

用def语句创建函数时，可以用return语句指定应该返回什么值。

内建函数列表

print（）

关键字参数

end

为print()函数自动在传入的字符串末尾添加了换行符。但是，可以设置end关键字参数，将它变成另一个字符串。用法：print（'yhy',end='.')

sep

如果向print()传入多个字符串值，该函数就会自动用一个空格分隔它们。但是你可以传入sep关键字参数，替换掉默认的分隔字符串。用法：print('yhy','zds','yrm',sep='.')

input（）

len（）

数学运算类

abs(x)

求绝对值

1、参数可以是整型，也可以是复数

2、若参数是复数，则返回复数的模

complex([real[, imag]])

创建一个复数

divmod(a, b)

分别取商和余数

注意：整型、浮点型都可以

float([x])

将一个字符串或数转换为浮点数。如果无参数将返回0.0

int([x[, base]])

将一个字符转换为int类型，base表示进制

long([x[, base]])

将一个字符转换为long类型

pow(x, y[, z])

返回x的y次幂

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

产生一个序列，默认从0开始

round(x[, n])

四舍五入

sum(iterable[, start])

对集合求和

oct(x)

将一个数字转化为8进制

hex(x)

将整数x转换为16进制字符串

chr(i)

返回整数i对应的ASCII字符

bin(x)

将整数x转换为二进制字符串

bool([x])

将x转换为Boolean类型

集合类操作

basestring()

str和unicode的超类

不能直接调用，可以用作isinstance判断

format(value [, format_spec])

格式化输出字符串

格式化的参数顺序从0开始，如“I am {0},I like {1}”

unichr(i)

返回给定int类型的unicode

enumerate(sequence [, start = 0])

返回一个可枚举的对象,该对象的next()方法将返回一个tuple

iter(o[, sentinel])

生成一个对象的迭代器，第二个参数表示分隔符

max(iterable[, args...][key])

返回集合中的最大值

min(iterable[, args...][key])

返回集合中的最小值

dict([arg])

创建数据字典

list([iterable])

将一个集合类转换为另外一个集合类

set()

set对象实例化

frozenset([iterable])

产生一个不可变的set

str([object])

转换为string类型

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

队集合排序

tuple([iterable])

生成一个tuple类型

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

xrange()函数与range()类似，但xrnage()并不创建列表，而是返回一个xrange对象，它的行为与列表相似，但是只在需要时才计算列表值，当列表很大时，这个特性能为我们节省内存

逻辑判断

all(iterable)

1、集合中的元素都为真的时候为真

2、特别的，若为空串返回为True

any(iterable)

1、集合中的元素有一个为真的时候为真

2、特别的，若为空串返回为False

cmp(x, y)

如果x y,返回正数

反射

callable(object) 检查对象object是否可调用

1、类是可以被调用的

2、实例是不可以被调用的，除非类中声明了__call__方法

classmethod() 1、注解，用来说明这个方式是个类方法

2、类方法即可被类调用，也可以被实例调用

4、类方法中不需要有self参数

3、类方法类似于Java中的static方法

compile(source, filename,mode[, flags[, dont_inherit]])

将source编译为代码或者AST对象。代码对象能够通过exec语句来执行或者eval()进行求值。

1、参数source：字符串或者AST（Abstract Syntax Trees）对象。

2、参数 filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。

3、参数model：指定编译代码的种类。可以指定为 ‘exec’,’eval’,’single’。

4、参数flag和dont_inherit：这两个参数暂不介绍

dir([object])

1、不带参数时，返回当前范围内的变量、方法和定义的类型列表；

2、带参数时，返回参数的属性、方法列表。

3、如果参数包含方法__dir__()，该方法将被调用。当参数为实例时。

4、如果参数不包含__dir__()，该方法将最大限度地收集参数信息

delattr(object, name)

删除object对象名为name的属性

eval(expression [, globals [, locals]])

计算表达式expression的值

execfile(filename [, globals [, locals]])

用法类似exec()，不同的是execfile的参数filename为文件名，而exec的参数为字符串。

filter(function, iterable)

构造一个序列，等价于[ item for item in iterable if function(item)]

1、参数function：返回值为True或False的函数，可以为None

2、参数iterable：序列或可迭代对象

getattr(object, name [, defalut])

获取一个类的属性

globals()

返回一个描述当前全局符号表的字典

hasattr(object, name)

判断对象object是否包含名为name的特性

hash(object)

如果对象object为哈希表类型，返回对象object的哈希值

id(object)

返回对象的唯一标识

isinstance(object, classinfo)

判断object是否是class的实例

issubclass(class, classinfo)

判断是否是子类

len(s)

返回集合长度

locals()

返回当前的变量列表

map(function, iterable, ...)

遍历每个元素，执行function操作

memoryview(obj)

返回一个内存镜像类型的对象

next(iterator[, default])

类似于iterator.next()

object()

基类

property([fget[, fset[, fdel[, doc]]]])

属性访问的包装类，设置后可以通过c.x=value等来访问setter和getter

reduce(function, iterable[, initializer])

合并操作，从第一个开始是前两个参数，然后是前两个的结果与第三个合并进行处理，以此类推

reload(module)

重新加载模块

setattr(object, name, value)

设置属性值

repr(object)

将一个对象变幻为可打印的格式

slice（）

staticmethod

声明静态方法，是个注解

super(type[, object-or-type])

引用父类

type(object)

返回该object的类型

vars([object])

返回对象的变量，若无参数与dict()方法类似

bytearray([source [, encoding [, errors]]])

返回一个byte数组

1、如果source为整数，则返回一个长度为source的初始化数组；

2、如果source为字符串，则按照指定的encoding将字符串转换为字节序列；

3、如果source为可迭代类型，则元素必须为[0 ,255]中的整数；

4、如果source为与buffer接口一致的对象，则此对象也可以被用于初始化bytearray.

zip([iterable, ...])

实在是没有看懂，只是看到了矩阵的变幻方面

IO操作

file(filename [, mode [, bufsize]])

file类型的构造函数，作用为打开一个文件，如果文件不存在且mode为写或追加时，文件将被创建。添加‘b’到mode参数中，将对文件以二进制形式操作。添加‘+’到mode参数中，将允许对文件同时进行读写操作

1、参数filename：文件名称。

2、参数mode：'r'（读）、'w'（写）、'a'（追加）。

3、参数bufsize：如果为0表示不进行缓冲，如果为1表示进行行缓冲，如果是一个大于1的数表示缓冲区的大小 。

input([prompt])

获取用户输入

推荐使用raw_input，因为该函数将不会捕获用户的错误输入

open(name[, mode[, buffering]])

打开文件

与file有什么不同？推荐使用open

print

打印函数

raw_input([prompt])

设置输入，输入都是作为字符串处理

其他

help()--帮助信息

后记

内置函数，一般都是因为使用频率比较频繁或是是元操作，所以通过内置函数的形式提供出来，通过对python的内置函数分类分析可以看出来：基本的数据操作基本都是一些数学运算（当然除了加减乘除）、逻辑操作、集合操作、基本IO操作，然后就是对于语言自身的反射操作，还有就是字符串操作，也是比较常用的，尤其需要注意的是反射操作。

类

使用类几乎可以模拟任何东西。

class

类中的函数称为方法 ；

有关函数的一切都适用于方法，就目前而言，唯一重要的差别是调用方法的方式。❸

创建和使用类

方法__init__()

在这个方法的名称中，开头和末尾各有两个下划线，这是一种约定，旨在避免Python默认方法与普通方法发生名称冲突。

三个形参

self

在这个方法的定义中，形参self 必不可少，还必须位于其他形参的前面。

每个与类相关联的方法调用都自动传递实参self ，它是一个指向实例本身的引用，让实例能够访问类中的属性和方法。

name

age

根据类创建实例

访问属性

调用方法

使用类和实例

给属性指定默认值

修改属性的值

直接修改属性的值

通过方法修改属性的值

通过方法对属性的值进行递增

继承

子类的方法__init__()

给子类定义属性和方法

重写父类的方法

将实例用作属性

模拟实物

导入类

导入单个类

在一个模块中存储多个类

导入整个模块

导入模块中的所有类

在一个模块中导入另一个模块

自定义工作流程

模块的类型

内建模块

pprint模块

pprint()

pformat()

math模块有数学运算相关的函数

random模块

用于生成随机数。有随机数相关的函数

logging 模块

在代码中使用 print() 打印输出是临时性的调试用途的方案。如果希望在线上记录应用日志或者错误日志等, 可以使用 Python 自带的日志模块 logging。

子主题

os 模块

os 模块中主要包含创建和管理进程或者文件系统内容(比如文件和目录)的函数

os.path 模块

os 模块下有一个独有的 path 子模块, 可以使用 os.path.函数名字 的方式调用, 也可以 import os.path。os.path 模块是和路径有关的。

sys 模块

提供了特定系统的配置和操作。

csv 模块

逗号分隔值（Comma-Separated Values，CSV，有时也称为字符分隔值，因为分隔字符也可以不是逗号），其文件以纯文本形式存储表格数据（数字和文本）。 纯文本意味着该文件是一个字符序列，不含必须像二进制数字那样被解读的数据。

子主题

datetime 模块

re 模块

使 Python 语言拥有全部的正则表达式功能。

正则表达式模式

模式字符串使用特殊的语法来表示一个正则表达式：

字母和数字表示他们自身。一个正则表达式模式中的字母和数字匹配同样的字符串。

多数字母和数字前加一个反斜杠时会拥有不同的含义。

标点符号只有被转义时才匹配自身，否则它们表示特殊的含义。

反斜杠本身需要使用反斜杠转义。

由于正则表达式通常都包含反斜杠，所以你最好使用原始字符串来表示它们。模式元素(如 r'\t'，等价于 '\\t')匹配相应的特殊字符。

下表列出了正则表达式模式语法中的特殊元素。如果你使用模式的同时提供了可选的标志参数，某些模式元素的含义会改变。

^

匹配字符串的开头

$

匹配字符串的末尾。

.

匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。

[...]

用来表示一组字符,单独列出：[amk] 匹配 'a'，'m'或'k'

[^...]

不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。

re*

匹配0个或多个的表达式。

re+

匹配1个或多个的表达式。

re?

匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式

re{ n}

精确匹配 n 个前面表达式。例如， o{2} 不能匹配 "Bob" 中的 "o"，但是能匹配 "food" 中的两个 o。

re{ n,}

匹配 n 个前面表达式。例如， o{2,} 不能匹配"Bob"中的"o"，但能匹配 "foooood"中的所有 o。"o{1,}" 等价于 "o+"。"o{0,}" 则等价于 "o*"。

re{ n, m}

匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式

a| b

匹配a或b

(re)

匹配括号内的表达式，也表示一个组

(?imx)

正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。

(?-imx)

正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。

(?: re)

类似 (...), 但是不表示一个组

(?imx: re)

在括号中使用i, m, 或 x 可选标志

(?-imx: re)

在括号中不使用i, m, 或 x 可选标志

(?#...)

注释.

(?= re)

前向肯定界定符。如果所含正则表达式，以 ... 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。

(?! re)

前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功

(?> re)

匹配的独立模式，省去回溯。

\w

匹配字母数字及下划线

\W

匹配非字母数字及下划线

\s

匹配任意空白字符，等价于 [\t\n\r\f].

\S

匹配任意非空字符

\d

匹配任意数字，等价于 [0-9].

\D

匹配任意非数字

\A

匹配字符串开始

\Z

匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。

\z

匹配字符串结束

\G

匹配最后匹配完成的位置。

\b

匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。

\B

匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。

\n, \t, 等.

匹配一个换行符。匹配一个制表符。等

\1...\9

匹配第n个分组的内容。

\10

匹配第n个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。

Re模块的方法：

(1)re.match函数

re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。

re.match(pattern, string, flags=0)

pattern

匹配的正则表达式

string

要匹配的字符串。

flags

标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表达式修饰符 - 可选标志

匹配成功re.match方法返回一个匹配的对象，否则返回None。

(2)re.search方法

扫描整个字符串并返回第一个成功的匹配。

re.search(pattern, string, flags=0)

pattern

匹配的正则表达式

string

要匹配的字符串。

flags

标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

（3）re.split方法

split 方法按照能够匹配的子串将字符串分割后返回列表

re.split(pattern, string[, maxsplit=0, flags=0])

pattern

匹配的正则表达式

string

要匹配的字符串。

maxsplit

分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数。

flags

标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表达式修饰符 - 可选标志

(4)re.sub检索和替换

re 模块提供了re.sub用于替换字符串中的匹配项。

re.sub(pattern, repl, string, count=0, flags=0)

pattern : 正则中的模式字符串。

repl : 替换的字符串，也可为一个函数。

string : 要被查找替换的原始字符串。

count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。

(5)findall方法

在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。

语法格式为：findall(string[, pos[, endpos]])

参数：

string : 待匹配的字符串。

pos : 可选参数，指定字符串的起始位置，默认为 0。

endpos : 可选参数，指定字符串的结束位置，默认为字符串的长度。

(6)finditer方法

和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。

re.finditer(pattern, string, flags=0)

pattern

匹配的正则表达式

string

要匹配的字符串。

flags

标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表达式修饰符 - 可选标志

Python 自1.5版本起增加了re 模块，它提供 Perl 风格的正则表达式模式。re模块是python中处理正则表达式的一个模块，通过re模块的方法，把正则表达式pattern编译成正则对象，以便使用正则对象的方法

compile 函数根据一个模式字符串和可选的标志参数生成一个正则表达式对象。该对象拥有一系列方法用于正则表达式匹配和替换。

re 模块也提供了与这些方法功能完全一致的函数，这些函数使用一个模式字符串做为它们的第一个参数。

第三方模块

自定义模块

导入模块

import语句

import关键字；

模块的名称；

可选的更多模块名称，之间用逗号隔开。

注意事项

消除重复能够使程序更短、更易读、更容易更新。