这份资料非常纯粹，只有Python的基础语法，专门针对想要学习Python的小白。

Python中用#表示单行注释，#之后的同行的内容都会被注释掉。

使用三个连续的双引号表示多行注释，两个多行注释标识之间内容会被视作是注释。

Python当中的数字定义和其他语言一样：

我们分别使用+, -, *, /表示加减乘除四则运算符。

这里要注意的是，在Python2当中，10/3这个操作会得到3，而不是3.33333。因为除数和被除数都是整数，所以Python会自动执行整数的计算，帮我们把得到的商取整。如果是10.0 / 3，就会得到3.33333。目前Python2已经不再维护了，可以不用关心其中的细节。

但问题是Python是一个 弱类型 的语言，如果我们在一个函数当中得到两个变量，是无法直接判断它们的类型的。这就导致了同样的计算符可能会得到不同的结果，这非常蛋疼。以至于程序员在运算除法的时候，往往都需要手工加上类型转化符，将被除数转成浮点数。

在Python3当中拨乱反正，修正了这个问题，即使是两个整数相除，并且可以整除的情况下，得到的结果也一定是浮点数。

如果我们想要得到整数，我们可以这么操作：

两个除号表示 取整除 ，Python会为我们保留去除余数的结果。

除了取整除操作之外还有取余数操作，数学上称为取模，Python中用%表示。

Python中支持 乘方运算 ，我们可以不用调用额外的函数，而使用**符号来完成：

当运算比较复杂的时候，我们可以用括号来强制改变运算顺序。

用and表示与操作，or表示或操作，not表示非操作。而不是C++或者是Java当中的&&, || 和！。

在Python底层， True和False其实是1和0 ，所以如果我们执行以下操作，是不会报错的，但是在逻辑上毫无意义。

我们要小心Python当中的bool()这个函数，它并不是转成bool类型的意思。如果我们执行这个函数，那么 只有0会被视作是False，其他所有数值都是True ：

Python中用==判断相等，>表示大于，>=表示大于等于， <表示小于，<=表示小于等于，!=表示不等。

我们可以用and和or拼装各个逻辑运算：

注意not，and，or之间的优先级，其中not > and > or。如果分不清楚的话，可以用括号强行改变运行顺序。

关于list的判断，我们常用的判断有两种，一种是刚才介绍的==，还有一种是is。我们有时候也会简单实用is来判断，那么这两者有什么区别呢？我们来看下面的例子：

Python是全引用的语言，其中的对象都使用引用来表示。is判断的就是 两个引用是否指向同一个对象 ，而==则是判断两个引用指向的具体内容是否相等。举个例子，如果我们把引用比喻成地址的话，is就是判断两个变量的是否指向同一个地址，比如说都是沿河东路XX号。而==则是判断这两个地址的收件人是否都叫张三。

显然，住在同一个地址的人一定都叫张三，但是住在不同地址的两个人也可以都叫张三，也可以叫不同的名字。所以如果a is b，那么a == b一定成立，反之则不然。

Python当中对字符串的限制比较松， 双引号和单引号都可以表示字符串 ，看个人喜好使用单引号或者是双引号。我个人比较喜欢单引号，因为写起来方便。

字符串也支持+操作，表示两个字符串相连。除此之外，我们把两个字符串写在一起，即使没有+，Python也会为我们拼接：

我们可以使用[]来查找字符串当中某个位置的字符，用 len 来计算字符串的长度。

我们可以在字符串前面 加上f表示格式操作 ，并且在格式操作当中也支持运算，比如可以嵌套上len函数等。不过要注意，只有Python3.6以上的版本支持f操作。

最后是None的判断，在Python当中None也是一个对象， 所有为None的变量都会指向这个对象 。根据我们前面所说的，既然所有的None都指向同一个地址，我们需要判断一个变量是否是None的时候，可以使用is来进行判断，当然用==也是可以的，不过我们通常使用is。

理解了None之后，我们再回到之前介绍过的bool()函数，它的用途其实就是判断值是否是空。所有类型的 默认空值会被返回False ，否则都是True。比如0，""，[], {}, ()等。

除了上面这些值以外的所有值传入都会得到True。

print会输出一个字符串，如果传入的不是字符串会自动调用__str__方法转成字符串进行输出。 默认输出会自动换行 ，如果想要以不同的字符结尾代替换行，可以传入end参数：

使用input时，Python会在命令行接收一行字符串作为输入。可以在input当中传入字符串，会被当成提示输出：

Python支持 三元表达式 ，但是语法和C++不同，使用if else结构，写成：

Python中用[]表示空的list，我们也可以直接在其中填充元素进行初始化：

使用append和pop可以在list的末尾插入或者删除元素：

list可以通过[]加上下标访问指定位置的元素，如果是负数，则表示 倒序访问 。-1表示最后一个元素，-2表示倒数第二个，以此类推。如果访问的元素超过数组长度，则会出发 IndexError 的错误。

list支持切片操作，所谓的切片则是从原list当中 拷贝 出指定的一段。我们用start: end的格式来获取切片，注意，这是一个 左闭右开区间 。如果留空表示全部获取，我们也可以额外再加入一个参数表示步长，比如[1:5:2]表示从1号位置开始，步长为2获取元素。得到的结果为[1, 3]。如果步长设置成-1则代表反向遍历。

如果我们要指定一段区间倒序，则前面的start和end也需要反过来，例如我想要获取[3: 6]区间的倒序，应该写成[6:3:-1]。

只写一个:，表示全部拷贝，如果用is判断拷贝前后的list会得到False。可以使用del删除指定位置的元素，或者可以使用remove方法。

insert方法可以 指定位置插入元素 ，index方法可以查询某个元素第一次出现的下标。

list可以进行加法运算，两个list相加表示list当中的元素合并。 等价于使用extend 方法：

我们想要判断元素是否在list中出现，可以使用 in关键字 ，通过使用len计算list的长度：

tuple和list非常接近，tuple通过()初始化。和list不同， tuple是不可变对象 。也就是说tuple一旦生成不可以改变。如果我们修改tuple，会引发TypeError异常。

由于小括号是有改变优先级的含义，所以我们定义单个元素的tuple， 末尾必须加上逗号 ，否则会被当成是单个元素：

tuple支持list当中绝大部分操作：

我们可以用多个变量来解压一个tuple：

我们在b的前面加上了星号， 表示这是一个list 。所以Python会在将其他变量对应上值的情况下，将剩下的元素都赋值给b。

补充一点，tuple本身虽然是不可变的，但是 tuple当中的可变元素是可以改变的 。比如我们有这样一个tuple：

我们虽然不能往a当中添加或者删除元素，但是a当中含有一个list，我们可以改变这个list类型的元素，这并不会触发tuple的异常：

dict也是Python当中经常使用的容器，它等价于C++当中的map，即 存储key和value的键值对 。我们用{}表示一个dict，用:分隔key和value。

dict的key必须为不可变对象，所以 list、set和dict不可以作为另一个dict的key ，否则会抛出异常：

我们同样用[]查找dict当中的元素，我们传入key，获得value，等价于get方法。

我们可以call dict当中的keys和values方法，获取dict当中的所有key和value的集合，会得到一个list。在Python3.7以下版本当中，返回的结果的顺序可能和插入顺序不同，在Python3.7及以上版本中，Python会保证返回的顺序和插入顺序一致：

我们也可以用in判断一个key是否在dict当中，注意只能判断key。

如果使用[]查找不存在的key，会引发KeyError的异常。如果使用 get方法则不会引起异常，只会得到一个None ：

setdefault方法可以 为不存在的key 插入一个value，如果key已经存在，则不会覆盖它：

我们可以使用update方法用另外一个dict来更新当前dict，比如a.update(b)。对于a和b交集的key会被b覆盖，a当中不存在的key会被插入进来：

我们一样可以使用del删除dict当中的元素，同样只能传入key。

set是用来存储 不重复元素 的容器，当中的元素都是不同的，相同的元素会被删除。我们可以通过set()，或者通过{}来进行初始化。注意当我们使用{}的时候，必须要传入数据，否则Python会将它和dict弄混。

set当中的元素也必须是不可变对象，因此list不能传入set。

可以调用add方法为set插入元素：

set还可以被认为是集合，所以它还支持一些集合交叉并补的操作。

set还支持 超集和子集的判断 ，我们可以用大于等于和小于等于号判断一个set是不是另一个的超集或子集：

和dict一样，我们可以使用in判断元素在不在set当中。用copy可以拷贝一个set。

Python当中的判断语句非常简单，并且Python不支持switch，所以即使是多个条件，我们也只能 罗列if-else 。

我们可以用in来循环迭代一个list当中的内容，这也是Python当中基本的循环方式。

如果我们要循环一个范围，可以使用range。range加上一个参数表示从0开始的序列，比如range(10)，表示[0, 10)区间内的所有整数：

如果我们传入两个参数，则 代表迭代区间的首尾 。

如果我们传入第三个元素，表示每次 循环变量自增的步长 。

如果使用enumerate函数，可以 同时迭代一个list的下标和元素 ：

while循环和C++类似，当条件为True时执行，为false时退出。并且判断条件不需要加上括号：

Python当中使用 try和except捕获异常 ，我们可以在except后面限制异常的类型。如果有多个类型可以写多个except，还可以使用else语句表示其他所有的类型。finally语句内的语法 无论是否会触发异常都必定执行 ：

在Python当中我们经常会使用资源，最常见的就是open打开一个文件。我们 打开了文件句柄就一定要关闭 ，但是如果我们手动来编码，经常会忘记执行close操作。并且如果文件异常，还会触发异常。这个时候我们可以使用with语句来代替这部分处理，使用with会 自动在with块执行结束或者是触发异常时关闭打开的资源 。

以下是with的几种用法和功能：

凡是可以使用in语句来迭代的对象都叫做 可迭代对象 ，它和迭代器不是一个含义。这里只有可迭代对象的介绍，想要了解迭代器的具体内容，请移步传送门：

Python——五分钟带你弄懂迭代器与生成器，夯实代码能力

当我们调用dict当中的keys方法的时候，返回的结果就是一个可迭代对象。

我们 不能使用下标来访问 可迭代对象，但我们可以用iter将它转化成迭代器，使用next关键字来获取下一个元素。也可以将它转化成list类型，变成一个list。

使用def关键字来定义函数，我们在传参的时候如果指定函数内的参数名， 可以不按照函数定义的顺序 传参：

可以在参数名之前加上*表示任意长度的参数，参数会被转化成list：

也可以指定任意长度的关键字参数，在参数前加上**表示接受一个dict：

当然我们也可以两个都用上，这样可以接受任何参数：

传入参数的时候我们也可以使用*和**来解压list或者是dict：

Python中的参数 可以返回多个值 ：

函数内部定义的变量即使和全局变量重名，也 不会覆盖全局变量的值 。想要在函数内部使用全局变量，需要加上 global 关键字，表示这是一个全局变量：

Python支持 函数式编程 ，我们可以在一个函数内部返回一个函数：

Python中可以使用lambda表示 匿名函数 ，使用:作为分隔，:前面表示匿名函数的参数，:后面的是函数的返回值：

我们还可以将函数作为参数使用map和filter，实现元素的批量处理和过滤。关于Python中map、reduce和filter的使用，具体可以查看之前的文章：

我们还可以结合循环和判断语来给list或者是dict进行初始化：

使用 import语句引入一个Python模块 ，我们可以用.来访问模块中的函数或者是类。

我们也可以使用from import的语句，单独引入模块内的函数或者是类，而不再需要写出完整路径。使用from import *可以引入模块内所有内容（不推荐这么干）

可以使用as给模块内的方法或者类起别名：

我们可以使用dir查看我们用的模块的路径：

这么做的原因是如果我们当前的路径下也有一个叫做math的Python文件，那么 会覆盖系统自带的math的模块 。这是尤其需要注意的，不小心会导致很多奇怪的bug。

我们来看一个完整的类，相关的介绍都在注释当中

以上内容的详细介绍之前也有过相关文章，可以查看：

下面我们来看看Python当中类的使用：

这里解释一下，实例和对象可以理解成一个概念，实例的英文是instance，对象的英文是object。都是指类经过实例化之后得到的对象。

继承可以让子类 继承父类的变量以及方法 ，并且我们还可以在子类当中指定一些属于自己的特性，并且还可以重写父类的一些方法。一般我们会将不同的类放在不同的文件当中，使用import引入，一样可以实现继承。

我们再创建一个蝙蝠侠的类，同时继承Superhero和Bat：

我们可以通过yield关键字创建一个生成器，每次我们调用的时候执行到yield关键字处则停止。下次再次调用则还是从yield处开始往下执行：

除了yield之外，我们还可以使用()小括号来生成一个生成器：

关于生成器和迭代器更多的内容，可以查看下面这篇文章：

五分钟带你弄懂迭代器与生成器，夯实代码能力

我们引入functools当中的wraps之后，可以创建一个装饰器。装饰器可以在不修改函数内部代码的前提下，在外面包装一层其他的逻辑:

装饰器之前也有专门的文章详细介绍，可以移步下面的传送门：

一文搞定Python装饰器，看完面试不再慌

不知道有多少小伙伴可以看到结束，原作者的确非常厉害，把Python的基本操作基本上都囊括在里面了。如果都能读懂并且理解的话，那么Python这门语言就算是入门了。

如果你之前就有其他语言的语言基础，我想本文读完应该不用30分钟。当然在30分钟内学会一门语言是不可能的，也不是我所提倡的。但至少通过本文我们可以做到熟悉Python的语法，知道大概有哪些操作，剩下的就要我们亲自去写代码的时候去体会和运用了。

根据我的经验，在学习一门新语言的前期，不停地查阅资料是免不了的。希望本文可以作为你在使用Python时候的查阅文档。

最后，我这里有各种免费的编程类资料，有需要的及时私聊我，回复"学习"，分享给大家，正在发放中............

能够检查函数参数是否合格，大家都想到了有哪些方法呢？有没有同小编一样，想到了return了呢？之前利用这return进行了返回函数参数，得到大家的一致受用，最基础的使用大家也知道可以返回一个值，那么要是带入判断性质的，我们要怎么去带入使用呢？内容已整理，阅读下文详情。

函数执行return后，立即返回，不再执行其他代码 例如：检查函数参数是否合格

函数一个关键点是返回值，根据函数功能决定是否需要添加显示返回值，而return函数是可以直接进行返回，因此作为判断是否合格类型内容是十分合适的。

__init__()方法按照参数的有无（self除外）可分为有参构造方法和无参构造方法。

前面在类中定义的属性是类属性，可以通过对象或类进行访问；在构造方法中定义的属性是实例属性，只能通过对象进行访问。

Python中的垃圾回收主要采用的是引用计数。引用计数是一种内存管理技术，它通过引用计数器记录所有对象的引用数量，当对象的引用计数器数值为0时，就会将该对象视为垃圾进行回收。

getrefcount()函数是sys模块中用于统计对象引用数量的函数，其返回结果通常比预期的结果大1。

这是因为getrefcount()函数也会统计临时对象的引用。

当一个对象的引用计数器数值为0时，就会调用__del__()方法，这个方法就是类的析构方法。

类方法与实例方法有以下不同：

类方法可以被类名或对象名调用，其语法格式如下：

静态方法与实例方法有以下不同：

Python中类与类之间具有继承关系，其中被继承的类称为父类或基类，继承的类称为子类或派生类。

单继承指的是子类只继承一个父类，其语法格式如下：

多继承指的是一个子类继承多个父类，其语法格式如下：

子类可以继承父类的属性和方法，若父类的方法不能满足子类的要求，子类可以重写父类的方法，以实现理想的功能。

如果子类重写了父类的方法，但仍希望调用父类中的方法，那么可以使用super()函数实现。

在Python中，多态指在不考虑对象类型的情况下使用对象。相比于强类型，Python更推崇“鸭子类型”。

Python中的模块可分为三类，分别是内置模块、第三方模块和自定义模块。

使用import导入模块的语法格式如下：

模块导入之后便可以通过“.”使用模块中的函数或类。

模块名.函数名()/类名

如果在开发过程中需要导入一些名称较长的模块，那么可使用as为这些模块起别名，语法格式如下：

使用“from…import …”方式导入模块之后，无需添加前缀，可以像使用当前程序中的内容一样使用模块中的内容，此种方式的语法格式如下：

from…import…也支持一次导入多个函数、类、变量等，函数与函数之间使用逗号隔开。

利用通配符“*”可使用from...import...导入模块中的全部内容，语法格式如下：

from…import…也支持为模块或模块中的函数起别名，其语法格式如下：

虽然通过“from 模块名 import …”方式可简化模块中内容的引用，但可能会出现函数重名的问题。因此，相对而言使用import语句导入模块更为安全。

sys模块中提供了一系列与Python解释器交互的函数和变量，用于操控Python的运行时环境。

os模块中提供了访问操作系统服务的功能，该模块中常用函数如下表所示。

random模块为随机数模块，该模块中定义了多个可产生各种随机数的函数。

time模块中提供了一系列处理时间的函数，常用函数的说明如下表所示。

Python中每个文件都可以作为一个模块存在，文件名即为模块名。

如果需要导入其它目录下的模块，那么可以将被导入模块的目录添加到Python模块的搜索路径中。

首先，通过sys.path查看当前模块的搜索路径。

再次查看sys.path，可看到刚刚添加的路径：

最后，使用“模块使用”目录下的module_demo模块。

__all__属性实际上是一个元组，该元组中包含的元素决定了在使用from…import *语句导入模块内容时通配符*所包含的内容。

在较大型的项目开发中，一个项目通常由多名开发人员共同开发，每名开发人员负责不同的模块。为了保证自己编写的程序在整合后可以正常运行，开发人员通常需在整合前额外编写测试代码，对自己负责的模块进行测试。

为了避免项目运行时执行这些测试代码，Python中设置了__name__属性。

Python中的包是一个包含__init__.py文件的目录，该目录下还包含一些模块以及子包。

包中的__init__.py文件可以为空，但必须存在，否则包将退化为一个普通目录。

使用import导入包中的模块时，需要在模块名的前面加上包名，格式为 “包名.模块名”。若要使用已导入模块中的函数时，需要通过“包名.模块.函数”实现。

通过from…import…导入包中模块包含的内容，若需要使用导入模块中的函数，需要通过“模块.函数”实现。

在使用第三方模块之前，需要使用包管理工具——pip下载和安装第三方模块。

如果你喜欢作画，那么一定要尝试一下Python内置模块——turtle，利用该模块通过程序绘制一些简单图形。

程序中使用变量保存运行时产生的临时数据，但当程序结束后，所产生的数据也会随之消失。

计算机中的文件能够持久保存程序运行时产生的数据。

open()函数用于打开文件，该函数调用成功会返回一个文件对象。

常用的文件打开模式有r、w、a、b、+，这些模式的含义分别如下：

文件打开模式可搭配使用，如下表所示为常用的搭配。

close()方法用于关闭文件，该方法没有参数，直接调用即可。

read()方法可以从指定文件中读取指定数据，其语法格式如下：

参数size表示设置的读取数据的字节数，若该参数缺省，则一次读取指定文件中的所有数据。

readline()方法可以从指定文件中读取一行数据，其语法格式如下：

每执行一次readline()方法便会读取文件中的一行数据。

readlines()方法可以一次读取文件中的所有数据，其语法格式如下：

readlines()方法在读取数据后会返回一个列表，该列表中的每个元素对应着文件中的每一行数据。

通过write()方法向文件中写入数据，其语法格式如下。

参数str表示要写入的字符串。若字符串写入成功，write()方法返回本次写入文件的长度。

writelines()方法用于向文件中写入字符串序列，其语法格式如下：

在文件的一次打开与关闭之间进行的读写操作都是连续的，程序总是从上次读写的位置继续向下进行读写操作。

实际上，每个文件对象都有一个称为“文件读写位置”的属性，该属性用于记录文件当前读写的位置。

tell()方法用于获取当前文件读写的位置，其语法格式如下:

seek()方法用于设置当前文件读写位置，其语法格式如下：

Python提供了用于更改文件名的函数——rename()，该函数存在于os模块中，其语法格式如下：

待重命名的文件必须已存在，否则解释器会报错。

os模块中的mkdir()函数用于创建目录，其语法格式如下：

使用Python内置模块shutil中的rmtree()函数可以删除目录，其语法格式如下：

参数path表示要删除的目录。

os模块中的listdir()函数用于获取文件夹下文件或文件夹名的列表，该列表以字母顺序排序，其语法格式如下：

参数path表示要获取的目录列表。

文件相对路径指这个文件夹所在的路径与其它文件（或文件夹）的路径关系，绝对路径指盘符开始到当前位置的路径。

使用isabs()函数可以判断目标路径是否为绝对路径，若为绝对路径返回True，否则返回Faslse。

当目标路径为相对路径时，使用abspath()函数可将当前路径规范化为绝对路径。

当前路径即文件、程序或目录当前所处的路径。os模块中的getcwd()函数用于获取当前路径，其使用方法如下：

os模块中的exists()函数用于判断路径是否存在，如果当前路径存在该函数返回True，否则返回False。

os.path模块中的join()函数用于拼接路径，其语法格式如下：

参数path1、path2表示要拼接的路径。

如果最后一个路径为空，则生成的路径将以一个“\”结尾。

概念：程序运行期间检测到的错误称为异常。

所有的异常类都继承自基类BaseException。BaseException类中包含4个子类，其中子类Exception是大多数常见异常类的父类。

Exception中常见的子类及其描述如下表所示。

try-except语句用于捕获程序运行时的异常，其语法格式如下：

捕获程序运行时的单个异常

捕获程序运行中的单个异常时，需要指定具体的异常。

捕获程序运行时的多个异常

捕获程序运行中的多个异常时，既可以将多个异常以元组元素的形式放在except语句后处理，也可以联合使用多个except语句。

捕获程序运行时的所有异常

捕获程序运行中的所有异常时，既可以将所有异常的父类Exception置于except后面处理，也可以采用省略except后面的异常类型的方式处理。

通过在except子句后面省略异常类型的方式虽然能处理所有的异常，但却无法获取异常的详细信息。

else子句与try-except语句连用时，其中的代码会在try子句未出现异常时执行。

若程序中产生的异常没有被处理，产生的异常会一层一层向上传递，直至最上面一层也未做处理，则会使用系统默认的方式处理——程序崩溃。

assert断言语句用于判定一个表达式是否为真，如果表达式为True，不做任何操作，否则引发AssertionError异常。

Python允许程序开发人员自定义异常。自定义异常类的方法很简单，只需创建一个类，让它继承Exception类或其它异常类即可。

with语句适用于对资源进行访问的场合，无论资源在使用过程中是否发生异常，都可以使用with语句保证执行释放资源操作。

上下文管理协议包括了__enter__()和__exit__()方法，支持该协议的对象均需要实现了这两个方法。__enter__()和__exit__()方法的含义与用途如下所示：

支持上下文管理协议的对象就是上下文管理器，这种对象实现了__enter__()和__exit__()方法。通过with语句即可调用上下文管理器，它负责建立运行时的上下文。

with语句中关键字with之后的表达式返回一个支持上下文管理协议的协议的对象，也就是返回一个上下文管理器。

由上下文管理器创建，通过上下文管理器的__enter__()和__exit__()方法实现。__enter__()方法在语句体执行之前执行，__exit__()方法在语句体执行之后执行。

在开发中可以根据实际情况设计自定义上下文管理器，只需要让定义的类支持上下文管理协议，并实现__enter__()与__exit__()方法即可。

正则表达式就是规定了一组文本模式匹配规则的符号语言，一条正则表达式也称为一个模式，使用这些模式可以匹配指定文本中与表达式模式相同的字符串。

元字符指在正则表达式中具有特殊含义的专用字符，可以用来规定其前导字符在目标对象中出现的模式。

点字符“.”可匹配包括字母、数字、下划线、空白符（除换行符\n）等任意的单个字符。

脱字符“^”和美元符“$”

脱字符“^”和美元符“$”分别用于匹配行头和行尾。

“|” 可将多个不同的子表达式进行逻辑连接，可简单地将“|”理解为逻辑运算符中的“或”运算符，匹配结果为与任意一个子表达式模式相同的字符串。

正则表达式中使用一对中括号“[]”标记字符组，字符组的功能是匹配其中的任意一个字符。

连字符“-”一般在字符组中使用，表示一个范围。

元字符“?”表示匹配其前导元素0次或1次。

正则表达式中使用“*”、“+”和“{}”符号来限定其前导元素的重复模式。

正则表达式中使用“()”可以对一组字符串中的某些字符进行分组。

正则表达式中预定义了一些字符集，使用字符集能以简洁的方式表示一些由元字符和普通字符表示的匹配规则。

Python中的re模块是正则表达式模块，该模块提供了文本匹配查找、文本替换、文本分割等功能。

正则对象的方法大多在re模块中也有对应的函数实现，因此用户可通过“正则对象.方法”的方式或“re.函数”的方式使用。

如果需要重复使用一个正则表达式，那么可以使用compile()函数对其进行预编译，以避免每次编译正则表达式的开销。

参数flags的常用取值如下表所示。

使用match()函数进行匹配

match()函数检测目标文本的开始位置是否符合指定模式，若匹配成功返回一个匹配对象，否则返回None。

使用match()函数对指定的字符串进行匹配搜索，示例如下：

大部分情况下，我们需要匹配的是出现在文本任意位置的字符串，这项功能由re模块中的search()函数实现。

使用match()函数和search()函数进行正则匹配时，返回的是如下形式的字符串：

span属性是一个元组，元组中有两个元素，第一个元素表示匹配对象在目标文本中的开始位置，第二个元素表示匹配对象在目标文本中的结束位置。

re模块中提供了一些与Match对象相关的方法，用于获取匹配结果中的各项数据。

当正则表达式中包含子组时，Python解释器会将每个子组的匹配结果临时存储到缓冲区中。若用户想获取子组的匹配结果，可使用Match对象的group()方法。

Match对象还有一个groups()方法，使用该方法可以获取一个包含所有子组匹配结果的元组。

若正则表达式中不包含子组，则groups()方法返回一个空元组。

findall()函数可以获取目标文本中所有与正则表达式匹配的内容，并将所有匹配的内容以列表的形式返回。

finditer()函数同样可以获取目标文本中所有与正则表达式匹配的内容，但该函数会将匹配到的子串以迭代器的形式返回。

re模块中提供的sub()、subn()函数用于替换目标文本中的匹配项。

sub() 与sunb()函数的参数及功能相同，不同的是调用成功后，sub()函数会返回替换后的字符串，subn()函数会返回包含替换结果和次数的元组。

re模块中提供的split()函数可使用与正则表达式模式相同的字符串分割指定文本。

正则表达式中有两种匹配方式：贪婪匹配和非贪婪匹配。

贪婪匹配方式也称为匹配优先，即在可匹配可不匹配时，优先尝试匹配；非贪婪匹配方式也称忽略优先，即在可匹配可不匹配时，优先尝试忽略。

• 缩进。标准的Python风格中每个缩进级别使用4个空格字符，不推荐使用Tab，禁止混用Tab与空格。

  空白行。顶层函数和定义的类之间空两行，类中的方法定义之间空一行；函数内逻辑无关的代码段之间空一行，其他地方尽量不要空行。

• 逗号、冒号、分号前不要加空格

  函数的左括号前不要加空格，如fun(1)

  序列的左括号前不要加空格，如list[2]

  操作符左右各加一个空格，如 a + b = c

  不要将多余语句写在同一行

  if、for、while语句中，即使执行语句只有一句，也必须另起一行

• 转换后为临时对象。并未被保存

  type()函数可用于测试函数类型

  int float函数只能转换为符合数字类型格式规范的字串

  使用int将浮点转为整数时会进行截断，而非四舍五入

  单、双引号用于定义普通字符串，而三引号用于定义行字符串

  使用双引号可以嵌套单引号，而双引号不可嵌套双引号。

  十六进制整数（A-F为大写）

  保留n位小数，可以保留浮点数的n位小数，其格式为“{:nf}”

  数字补齐，使用format可以对数字进行补齐，其格式为{：m>nd}”

  显示百分比，使用format可以将数字以百分比的形式显示，其格式为“{：.n%}”

  默认为空字符包括空格，换行（\n）制表符（\t）

  算术运算符包括+、-、*、/、//、%和**，这些都是双目运算符，每个运算符可以与两个操作数组成一个表达式

  • 布尔类型进行算术运算时，被视为数值0或1
  • 整型与浮点型运算时，将整型转化为浮点型
  • 其他类型与复数运算时，将其他类型转换为复数类型
  Python在对不同类型的对象进行运算时，会强制将对象的类型进行临时类型转换，将会遵循下面规律

  Python中分别用or、and、not这三个关键字作为逻辑运算“或”、“与”、“非”的运算符，其中or与and为双目运算符，not为单目运算符。

  for循环常与range（）函数搭配使用，以控制循环中代码段的执行次数

  若break语句位于循环结构中，该语句只会跳出离它最近的一级循环，不会影响其他循环的执行

  列表是Python最灵活的有序序列，它可以存储任意类型的元素。。开发人员可以对列表中的元素进行添加、删除、修改等操作。

  可直接使用for循环的对象称为可迭代对象

  可以使用isinstance()函数判断一个对象是否为可迭代对象。。

  使用切片方式访问列表元素

  列表的遍历，可通过for循环

  sort()方法能够对列表元素排序，该方法语法如下：

  列表可以存储任何元素，当然也可以存储列表，若列表中存储的元素也是列表，则称为嵌套列表

  使用圆括号“（）”创建元组，并将元组中的元素用逗号进行分隔。

  元组中的元素是不允许修改的，除非在元组中包含可变类型的数据

  从表面上看，元组的元素确实变了，但其实变的不是元组的元素，而是列表的元素。。元组最初指向的列表并没有改成别的列表，因此元组所谓的“不变”意为元组每个元素的指向永远不变

  映射类型是“键-值”数据项的组合，其最典型的代表就是字典

  使用花括号“{ }”创建字典时，字典的键（key）和值（value）使用冒号连接，每个键值对之间使用逗号分隔。。

  使用dict（）函数创建字典

  使用dict（）函数创建字典时，键和值使用“=”进行连接。

  字典中的键是唯一的。当创建字典时出现重复的键——

  若使用dict（）函数创建字典，提示语法错误；

  若使用花括号创建字典，键对应的值会被覆盖

  字典可通过update（）方法或指定的键添加元素

  字典可通过update（）方法或指定的键修改元素

  pop（）方法可以根据指定的键删除字典中的指定元素，若删除成功则返回目标元素的值

  使用popitem（）方法可以随机删除字典中的元素，若删除成功则返回目标元素

  clear（）方法用于清空字典中的元素

  items（）方法可以查看字典的所有元素，该方法会返回一个dict_items对象

  dict_items对象支持迭代操作，结合for循环可遍历其中的数据，并将遍历后的数据以（key，value）的形式显示

  通过keys（）方法可以查看字典的所有元素，该方法会返回一个dict_keys对象

  keys对象支持迭代操作，结合for循环可遍历输出字典中所有的键

  通过values（）方法可以查看字典的所有元素，该方法会返回一个dict_ values对象

  values对象支持迭代操作，结合for循环可遍历输出字典中所有的值

  Python中的集合分为可变集合与不可变集合

  由set（）函数创建，集合中的元素可以动态的增加或删除。	由 frozenset（）函数创建，集合中的元素不可改变

  set（）与frozenset（）函数的语法格式如下：

  上述函数的参数iterable接收一个可迭代对象，若没有指定可迭代的对象，则会返回一个空的集合。

  集合元素的添加、删除和清空

  可变集合的add（）或update（）方法都可以实现向集合中添加元素，其中add（）方法只能添加一个元素，而update（）方法可以添加多个元素。

  remove（）方法用于删除可变集合中的指定元素。

  discard（）方法可以删除指定的元素，但若指定的元素不存在，则该方法不执行任何操作

  pop（）方法用于删除可变集合中的随机元素

  clear（）方法可以清空可变集合中的元素

  Python支持通过操作符 | 、& 、- 、 ^对集合进行联合，取交集、差补和对称差分操作

  联合操作符是将集合a与b合并成一个新的集合。联合操作符使用“|”符号实现

  交集操作符是将集合a与b中相同的元素提取为一个新集合。交集使用“&”符号实现

  差补操作是将只属于a或只属于b的元素作为一个新的集合。差补使用“-”符号实现

  对称差分操作将只属于a与只属于b中的元素组成一个新集合。对称差分使用“^”符号实现

  列表、元组、字典和集合都是Python中的组合数据类型，它们都拥有不同的特定。。

  函数指被封装起来的、实现某种功能的一段代码。Python安装包、标准库中自带的函数统称为内置函数，用户自己编写的函数称为自定义函数，不管是哪种函数，其定义和调用方式都是一样的。

  Python中使用关键字def定义函数

  函数的参数传递是指将实际参数传递给形式参数的过程。根据不同的传递形式，函数的参数可分为：

         关键字参数通过“形式参数=实际参数”的格式将实际参数与形式参数相关联，根据形参的名称进行参数传递。

         若要传入函数中的参数的个数不确定，可以使用不定长参数。不定长参数也称为可变参数，此种参数接收参数的数量可以任意改变。

  变量的作用域指变量的作用范围。根据作用范围，Python中的变量分为局部变量与全局变量。

  局部变量是在函数内定义的变量，只在定义它的函数内生效。

  局部变量只能在函数内部使用，不能在函数外部使用。

  函数中只能访问全局变量，但不能修改全局变量。

  若要在函数内部修改全局变量的值，需先在函数内使用关键字“global”进行声明。

  递归是一个函数过程在定义中直接调用自身的一种方法，它通常把一个大型的复杂问题层层转化为一个与有问题相似，但规模较小的问题求解。

  如果一个函数中调用了函数本身，这个函数就是递归函数。

  递归函数只需少量代码就可描述出解题过程所需的多次重复计算，大大地减少了程序的代码量。

  函数递归调用时，需要确定两点：一是递归公式，二是边界条件。

  阶乘是可利用递归方式求解的经典问题。

  Python内置了一些实现特定功能的函数，这些函数无需由Python使用者重新定义便可直接使用。

  面向对象是程序开发领域中的重要思想，这种思想模拟了人类认识客观世界的逻辑，是当前计算机软件工程学的主流方法。

  类是面向对象的实现手段

  面向过程编程的基本思想是：分析解决问题的步骤，使用函数实现步骤相应的功能，按照步骤的先后顺序依次调用函数。

  面向过程只考虑如何解决当前问题，它着眼于问题本身。

  面向对象编程的基本思想是：首先会从问题之中提炼出问题涉及的角色，将不同角色各自的特征和关系进行封装，以角色为主体，通过描述角色的行为去描述解决问题的过程。

  面向对象编程的着眼之处在于角色以及角色之间的联系。

• 对象是现实世界中可描述的事物，它可以是有形的也可以是无形的，从一本书到一家图书馆，从单个整数到繁杂的序列等都可以称为对象。

• 从具体的事物中把共同的特征抽取出来，形成一般的概念称为“归类”，忽略事物的非本质特牲，关注与目标有关的本质特征，找出事物间的共性，抽象出一个概念模型，就是定义一个类。

  在面向对象的方法中，类是具有相同属性和行为的一组对象的集合，它提供一个抽象的描述，其内部包括属性和方法两个主要部分，它就像一个模具，可以用它铸造一个个具体的铸件。

• 抽象是抽取特定实例的共同特征，形成概念的过程。

  例如苹果、香蕉、梨、葡萄等，抽取出它们共同特性就得出“水果”这一类，那么得出水果概念的过程，就是一个抽象的过程。

• 封装是面向对象的核心思想，将对象的属性和行为封装起来，不需要让外界知道具体实现细节，这就是封装思想。

• 继承描述的是类与类之间的关系，通过继承，新生类可以在无需赘写原有类的情况下，对原有类的功能进行扩展。

• 多态指同一个属性或行为在父类及其各派生类中具有不同的语义。

  封装、继承、多态是面向对象程序设计的三大特征，它们的简单关系如下图所示。

  面向对象的思想中提出了两个概念：类和对象。

  类中可以定义数据成员和成员函数，数据成员用于描述对象特征，成员函数用于描述对象行为，其中数据成员也被称为属性，成员函数也被称为方法。

• 若想在程序中真正地使用对象，需掌握访问对象成员的方式。对象成员分为属性和方法，它们的访问格式分别如下：

  类中定义的属性和方法默认为公有属性和方法，该类的对象可以任意访问类的公有成员。

  为了契合封装原则，保证类中的代码不被外部代码轻易访问。 Python支持将类中的成员设置为私有成员，在一定程度上限制对象对类成员的访问。

• Python通过在类成员名之前添加双下划线（__）来限制成员的访问权限，语法格式如下:

• 由以上展示的错误信息可以判断，对象无法直接访问类的私有成员。

  私有属性可在公有方法中通过指代对象本身的默认参数“self”访问，类外部可通过公有方法间接获取类的私有属性。

  私有方法同样在公有方法中通过参数“self”访问。

  每个类都有一个默认的__init__()方法。

• 如果定义类时显式地定义__init__()方法，那么创建对象时Python解释器会调用显式定义的__init__()方法；
• 如果定义类时没有显式定义__init__()方法，那么Python解释器会调用默认的__init__()方法。
• 子类在继承父类时，会自动拥有父类中的方法和属性。
• “鸭子类型”是这样推断的：如果一只生物走起路来像鸭子，游起泳来像鸭子，叫起来也像鸭子，那么它就可以被当做鸭子。也就是说，“鸭子类型”不关注对象的类型，而是关注对象具有的行为。
• 如果__all__中只包含模块的部分内容，那么from…import *语句只会将__all__中包含的部分内容导入程序。
• offset：表示偏移量，即读写位置需要移动的字节数；
•   from：用于指定文件的读写位置，该参数的取值有：0、1、2，其中0表示在开始位置读写；1表示在当前位置读写；2表示在末尾位置读写。
• path：表示要创建的目录。
•  mode：表示目录的数字权限，该参数在Windows系统下可忽略。
• 若异常不被处理，默认会导致程序崩溃而终止运行。
• 解释器优先执行try子句中的代码。
• 若try子句未产生异常，则忽略except子句中的代码。
• 若try子句产生异常，则忽略try子句的剩余代码，转而执行except子句中的代码。
• __enter__(self)：进入上下文管理器时调用此方法，它的返回值被放入with-as语句as说明符指定的变量中。