Python程序开发

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

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

析构方法

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

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

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

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

类方法

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

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

类名.类方法

对象名.类方法

静态方法

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

单继承

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

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

class 子类(父类)

多继承

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

class 子类（父类A, 父类B, ...）:

方法的重写

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

super()函数

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

super().方法名()

多态

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

第八章 模块

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

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

import 模块1, 模块2, …

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

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

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

import 模块名 as 别名

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

from 模块名 import 函数/类/变量

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

from time import sleep, time

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

from 模块名 import *

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

from 模块名 import 函数名 as 别名

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

Python内置了许多标准模块，例如sys、os、random和time模块等。

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

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

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

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

自定义模块

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

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

['D:\\Python项目\\自定义模块', 'D:\\Python项目', 'D:\\Python3.7.2\\python37.zip','D:\\Python3.7.2\\DLLs', 'D:\\Python3.7.2\\lib', 'D:\\Python3.7.2', 'D:\\Python项目\\venv', 'D:\\Python项目\\venv\\lib\\site-packages', 'D:\\Python项目\\venv\\lib\\site-packages\\pip-10.0.1-py3.7.egg',]

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

import sys

print(sys.path)

然后，将module_demo模块所在的路径添加到sys.path中。

sys.path.append("D:\Python项目\模块使用")

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

['D:\\Python项目\\自定义模块', 'D:\\Python项目',

'D:\\Python3.7.2\\python37.zip','D:\\Python3.7.2\\DLLs',

'D:\\Python3.7.2\\lib', 'D:\\Python3.7.2', 'D:\\Python项目\\venv',

'D:\\Python项目\\venv\\lib\\site-packages',

'D:\\Python项目\\venv\\lib\\site-packages\\pip-10.0.1-py3.7.egg',

'D:\Python项目\模块使用']

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

import sys

import module_demo

module_demo.introduce()

__all__属性

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

__name__属性

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

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

__name__属性通常与if条件语句一起使用，若当前模块是启动模块，则其__name__的值为“__main__”；若该模块被其它程序导入，则__name__的值为文件名。

Python中的包

包的结构

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

package ├── __init__.py ├── module_a1.py └── module_a2.py └── package_b ├── __init__.py └── module_b.py

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

__init__.py文件有两个作用，第一个作用是标识当前目录是一个Python的包；第二个作用是模糊导入。如果__init__文件中没有声明__all__属性，那么使用from ... import *导入的内容为空 。

包的导入

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

import package_demo.module_demo package_demo.module_demo.add(1, 3)

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

from package_demo import operation_demo operation_demo.add(2, 3)

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

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

第九章 文件与文件路径操作

打开文件

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

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

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

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

文件打开模式	含义
r	以只读的方式打开文件，默认值。
w	以只写的方式打开文件。
a	以追加的方式打开文件。
b	以二进制方式打开文件。
+	以更新的方式打开文件。

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

关闭文件

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

文件对象.close()

程序执行完毕后，系统会自动关闭由该程序打开的文件，但计算机中可打开的文件数量是有限的，每打开一个文件，可打开文件数量就减一；打开的文件占用系统资源，若打开的文件过多，会降低系统性能。因此，编写程序时应使用close()方法主动关闭不再使用的文件。

文件的读取

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

文件对象.read([size]) 

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

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

文件对象. readline()

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

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

文件对象. readlines()

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

read()（参数缺省时）和readlines()方法都可一次读取文件中的全部数据，但这两种操作都不够安全。因为计算机的内存是有限的，若文件较大，read()和readlines()的一次读取便会耗尽系统内存。为了保证读取安全，通常多次调用read()方法，每次读取size字节的数据。

数据写入

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

文件对象. write(str)

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

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

文件对象. writelines([str])

文件的定位读取

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

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

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

文件对象. tell()

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

文件对象. seek(offset, from)

文件的拷贝

文件的重命名

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

rename(原文件名, 新文件名)

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

目录操作

创建目录

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

os.mkdir(path, mode)

删除目录

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

rmtree(path)

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

获取目录的文件列表

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

listdir(path)

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

相对路径与绝对路径

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

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

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

获取当前路径

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

检测路径的有效性

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

路径的拼接

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

os.path.join(path1[,path2[,…]])

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

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

第十章 错误和异常

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

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

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

异常语句

try-except语句

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

try-except语句的执行过程如下：

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

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

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

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

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

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

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

                

else子句

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

finally子句

finally子句与try-except语句连用时，无论try-except是否捕获到异常，finally子句中的代码都要执行。

raise语句

异常的传递

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

assert断言语句

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

自定义异常

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

过渡页

with语句

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

上下文管理器

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

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

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

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

自定义上下文管理器

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

第十一章 正则表达式

元字符

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

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

点字符“.”

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

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

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

连接符“|”

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

字符组“[]”

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

连字符“-”

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

匹配符“?”

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

重复模式

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

子组

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

预定义字符集

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

re模块

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

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

预编译

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

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

使用match()函数进行匹配

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

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

使用search()函数进行匹配

大部分情况下，我们需要匹配的是出现在文本任意位置的字符串，这项功能由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学习之旅

  良好的编程约定

  PEP8编码规范指南

• 代码布局

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

         行的最大长度。每行最大长度79，换行可以使用反斜杠，但建议使用圆括号。

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

• 空格的使用

• 右括号前不要加空格

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

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

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

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

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

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

• 代码注释
• 命名规范

• 第二章 数字类型与字符串

  基本输入、输出

• input（）函数                              换行符\

• 用于输入数据

• 类型转换函数

• int        float       str

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

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

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

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

  字符串

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

   

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

  字符串的格式化输出

  占位符%               format（方法）                  f-string

  占位符%

         不同占位符为不同的变量预留位置

  符号	说明	符号	说明
  %s	字符串	%X	十六进制整数（A-F为大写）
  %d	十进制整数	%e	指数（底写为e）
  %o	八进制整数	%f	浮点数
  %x	十六进制整数（a- F为小写）

  format（方法）

         使用format（方法）不需要关注变量的类型，在format用“{     }”为变量预留位置，但需注意其位置。

                编号从0开始，或者自己指定顺序

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

                       n表示保留的小数位数

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

                       其中m表示补齐的数字，n表示补齐后数字的长度

                              即

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

                       其中n表示保留的小数位

  f-strings

         从Python3.6开始引进

                以f或F引领字符串

                       即f’我的名字是{name}

  字符串的常见操作

  字符串拼接                        可采用+

  字符串替换                        str . replace (old , new , count =None)

                                                         

                                                   原有字符串   新的字符串   替换次数

  字符串的分割                     str . split( sep = None , maxsplit = -1)

                                                  

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

  去除字符串两侧空格          str . strip( chars = None)

                                                   要去除的字符

  字符串的索引与切片

  索引

         正向索引从0开始，依次递增1

         负向索引从-1开始，从右至左递减

  切片

         切片用于截取目标对象中一部分

         语法为【起始：结束：步长】

                切片属于左闭右开型

                索引的范围不能越界

  运算符

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

  例a=3，b=5；

  35

    

  布尔类型进行算术运算时，被视为数值0或1 整型与浮点型运算时，将整型转化为浮点型 其他类型与复数运算时，将其他类型转换为复数类型

  Python在对不同类型的对象进行运算时，会强制将对象的类型进行临时类型转换，将会遵循下面规律

  比较运算符

  赋值运算符

  逻辑运算符

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

  位运算符

  运算符优先级

  使用（）可改变表达式的执行顺序

  第三章 流程控制

  if语句

  for循环

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

  while循环

  break语句

  continue语句

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

  第四章 列表与元组

  列表的基本使用

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

  创建方式

         使用中括号创建列表

                使用中括号创建”[]”列表时，只需要在”[]”中使用逗号分隔每个元素即可。

         使用list()函数创建列表

                使用list()创建列表时，需要给函数传入一个可迭代类型的数据。

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

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

  True

  from collections import Iterable print(isinstance([], Iterable))

        

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

         使用切片可以截取列表中的部分元素，得到一个新列表。

  切片        切片用于截取目标对象中一部分        语法为【起始：结束：步长】                  切片属于左闭右开型                  索引的范围不能越界

  One = [‘p’, ‘y’, ‘t’, ‘h’, ‘o’, ‘n’]

  print(one[:])     获取列表中的所有元素

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

  列表的排序

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

   

  修改列表元素

         即通过索引获取元素并对该元素重新赋值

  嵌套列表

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

  认识元组

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

  如何访问：

  使用索引访问元组元素

  使用切片访问元组元素

   

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

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

   

  第五章 字典和集合

  字典

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

  详细地址 省份 城市 邮政编码

  519088 解放路6号 广东省 广州市

   

  使用花括号创建字典

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

  {键1：值1， 键2：值2·······}

  使用dict（）函数创建字典

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

  dict（键1=值1，键2=值2.......）

  字典中的键是唯一的。当创建字典时出现重复的键—— 若使用dict（）函数创建字典，提示语法错误； 若使用花括号创建字典，键对应的值会被覆盖

  字典元素的添加和修改

  添加字典元素	字典可通过update（）方法或指定的键添加元素
  修改字典元素	字典可通过update（）方法或指定的键修改元素
  pop方法	pop（）方法可以根据指定的键删除字典中的指定元素，若删除成功则返回目标元素的值
  popitem（）方法	使用popitem（）方法可以随机删除字典中的元素，若删除成功则返回目标元素
  clear（）方法	clear（）方法用于清空字典中的元素
  items（）方法	items（）方法可以查看字典的所有元素，该方法会返回一个dict_items对象
  查看字典的所有元素	dict_items对象支持迭代操作，结合for循环可遍历其中的数据，并将遍历后的数据以（key，value）的形式显示
  keys（）方法	通过keys（）方法可以查看字典的所有元素，该方法会返回一个dict_keys对象
  查看字典中的所有键	keys对象支持迭代操作，结合for循环可遍历输出字典中所有的键
  values（）方法	通过values（）方法可以查看字典的所有元素，该方法会返回一个dict_ values对象
  查看字典中的所有值	values对象支持迭代操作，结合for循环可遍历输出字典中所有的值

  集合

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

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

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

  set（[iterable]） frozenset（[iterable]）

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

  可变集合的创建

         使用set（）函数创建可变集合。

  set_one = set（[1,2,3]） set_two = set（[1,2,3]）

                      

         还可直接使用花括号创建可变集合，花括号中的多个元素以逗号分隔，

  set_three = {1,2,3}

  不可变集合的创建

         使用frozenset（）函数创建不可变集合。

  frozenset_one = frozenset（[‘a’, ‘b’, ‘c’,’d’,’e’]） frozenset_two = frozenset（[‘a’, ‘b’, ‘c’,’d’,’e’]）

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

  添加元素	可变集合的add（）或update（）方法都可以实现向集合中添加元素，其中add（）方法只能添加一个元素，而update（）方法可以添加多个元素。
  删除元素	remove（）方法用于删除可变集合中的指定元素。
  	discard（）方法可以删除指定的元素，但若指定的元素不存在，则该方法不执行任何操作
  	pop（）方法用于删除可变集合中的随机元素
  清空可变集合元素	clear（）方法可以清空可变集合中的元素

  集合类型的操作符

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

  联合操作符	联合操作符是将集合a与b合并成一个新的集合。联合操作符使用“|”符号实现
  交集操作符	交集操作符是将集合a与b中相同的元素提取为一个新集合。交集使用“&”符号实现
  差补操作符	差补操作是将只属于a或只属于b的元素作为一个新的集合。差补使用“-”符号实现
  对称差分操作符	对称差分操作将只属于a与只属于b中的元素组成一个新集合。对称差分使用“^”符号实现

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

  类型	可变性	唯一性	有序性
  列表	可变	可重复	有序
  元组	不可变	可重复	有序
  字典	可变	可重复	无序
  集合	可变/不可变	不可重复	无序

  第六章 函数

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

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

  函数的参数传递

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

                       位置参数

                       默认值参数

                       关键字参数

                       不定长参数

  位置参数

         调用函数时，编译器会将函数的实际参数按照位置顺序依次传递给形式参数。

  关键字参数

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

  默认参数

         定义函数时可以指定形式参数的默认值。。调用函数时，可分为以下两种情况：

        

  不定长参数

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

  变量作用域

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

  局部变量

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

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

  全局变量

         全局变量是在函数外定义的变量，它在程序中任何位置都可以被访问。

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

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

  函数的特殊形式

  匿名函数

         匿名函数是无需函数名标识的函数，它的函数体只能是单个表达式。Python中使用关键字lambda定义匿名函数。

  递归函数

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

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

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

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

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

  Python常用内置函数

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

  第七章  类与面向对象

  面向对象

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

  类是面向对象的实现手段

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

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

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

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

• 对象（object）

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

• 类（class）

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

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

• 抽象（abstract）

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

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

• 封装（encapsulation）

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

• 继承（inheritance）

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

• 多态（ polymorphism）

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

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

  类与对象

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

  类的定义

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

• 对象的创建

• 创建对象的格式如下：

  对象名 = 类名()  

• 访问对象成员

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

  对象名.属性

  对象名.方法()

  访问限制

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

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

• 定义私有成员

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

  __属性名

  __方法名

• 私有成员的访问

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

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

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

  构造方法

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

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