本文是关于Python3的基础教程，涵盖了Python的安装、数据类型、对象引用、组合数据类型、逻辑操作符、控制流语句、算术操作符、输入输出、函数创建与调用等内容。详细讲解了Python的语法特性，包括字符串操作方法、列表、元组、集合、字典等数据结构的使用，并介绍了控制结构如if、while、for以及异常处理。此外，还涉及正则表达式和文件处理的基础知识。
##Python3之路
#####前言：到目前发帖为止博主踢野球也有8年时间（不长不短），和中乙职业球员也踢过几次，发现业余和职业最大的区别就是基础的停，传，射，整体攻防思路最为明显，而这些最重要的恰恰是最基础的。
版权声明：本文为博主原创文章，欢迎转载，但必须标识出处，且在文章明显位置给出原文链接
##Python基础
####工具
- JetBrains PyCharm Community Edition 5.0.3
####Linux下安装Python3
’
说明：一般Linux系统自带Pyhton2，卸载可能导致系统内其他软件无法使用。
1.下载：https://www.python.org/ftp/python/3.6.0/Python-3.6.0a1.tar.xz
2.解压：tar xvf Python-3.6.0a1.tar.xz
3.编译安装：进入目录 ./configure 后 make && make install
4.测试：输入Python显示Python的版本信息说明安装成功。
5.Python3源码自带pip3工具
####Windows下安装Python3
’
只需要安装完成之后设置环境变量即可
（一）快速入门
#####（1）数据类型
1.Python提供了集中内置的数据类型比如整形（int）和字符型（str）。
2.Python所能表示的整数大小之受限于机器内存，而非固定数量的字节数
3.字符串可以使用对称的’'或""进行封装
4.Python使用的是Unicode编码，所以字符串不局限于ASCII字符
5.Python可以使用[]（[]适用于任意数据类型的数据项）来存取字符串等序列中的一项。
6.Python语法中的索引位置是从0开始
7.如果要把数据项从一种数据类型转换为另一种数据类型可以使用 datatype（item）语法
#####（2）对象引用
1.x=blue （x是对象引用，blue是对象）：x引用的就是这个str对象
2.“=”的作用是将对象引用（x）和内存中的某对象（blue）进行绑定
3.Pthon的标识符是大小写敏感的
4.Python使用的是“动态类型”机制：只要需要，某个对象引用都可以重新引用一个不同的对象。而强类型语言（C++，JAVA）只允许与特定数据类型进行绑定。
比如：temp=33（type：int）之后执行temp=dingm（type：str）；而（C++中需要先进行对象声明）int i；i=10；
5.type（）函数会返回给定数据的数据类型
#####（3）组合数据类型
1.Python提供了关联数组与集合等组合数据类型
2.元组是固定数据类型，创建之后不可以改变。元组使用（，）的方式进行创建
2.列表是可变数据类型，创建之后可以改变，列表使用[]进行创建
3.组合数据类型也是对象，可以将某种组合数据类型嵌套在其他组合数据类型中。比如可以在列表中嵌套列表进行迭代
4.点操作符用于存取对象个某个属性
#####（4）逻辑操作符
1.身份操作符:is是一个二元操作符，如果左边对象引用和右边对象引用指向的是同一个对象，返回TRUE。（is只对对象引用的内存地址进行比较，同一地址存的是相同对象）
2.比较操作符（>,<,=）:Python中比较操作符可以进行结链比较（0<a<10）,只能在相同数据类型之间进行比较
3.逻辑运算符：and，or，not。
#####（5）控制流语句
1.Python中的每条语句都是顺序执行的。函数，方法调用或者控制流结构都可以使控制流转向。
2.Python中一块代码也就是一条或多条语句组成的序列，叫suite，Python某些语法中要求有一个suite，python就提供了关键字Pass（空语句适合于需要suite，但又不需要任何处理的情况）
3.if语句语法：
if boolean_expression1:
suite
elif boolean_expression2:
suite
else:
suite
Python的if语句和C++，JAVA不同的在于没有圆括号多了“：”
4.while语句语法：
while boolean_expression1：
suite
5.for…in语句语法：
for variable in iterable
suite
iterable可以是字符串，列表，元组等组合数据类型
6.基本的异常处理：
try:
try_suite
except exceptsion1 as variable
exception_suite
如果try块中的suite正常执行，则except模块将会被跳过；如果try块中的suite出现异常，则控制流会转向第一个与异常匹配的suite，同时异常suite后面的语句不再继续执行。
如果给定了as variable部分，在异常处理suite内部，variable引用的是异常对象。对异常处理模块的搜索是向外扩展的，可以延伸到调用栈内。
#####（6）算术操作符
1.常用的算术操作符：+,-,*,/,+=。其中减号既可以作为单值操作符（否定），也可以作为二元操作符（减法）
2.对于固定类型对象使用增强型操作符时，实际上创建一个新的对象来存储结果，之后再和对象引用进行重新绑定
3.对于可变数据类型使用增强型操作符时，会对原始列表对象进行修改，所以没有必要进行重新绑定。
4.Python语法隐藏了可变数据类型和不可变数据类型的区别，但是还要规定这两种数据类型最可能的原因是因为固定数据类型具有更高的潜力。
#####（7）输入输出
1.Python提供了，内置的input（）函数，来接受用户的输入
2.异常处理模块集中放置在程序末端，保证流程尽可能清晰
#####（8）函数的创建与调用
1.函数创建的语法：
def functionName(arguments):
suite
函数也是对象，可以存储在组合数据类型中，作为参数进行调用
2.标准模块中的模块名都是小写，所以自己编写的模块使用首字母大写
###（二）基本数据类型
#####（1）标志符和关键字
1.只要是Unicode编码的字符都可以充当引导字符
2.Python标志符不能和关键字重名
3.关于下划线（_）不能在名的开头和结尾都使用
4.数字只能充当后续字符
#####（2）整数
1.二进制以0b引导，八进制以0o引导，十六进制以0x引导
2.常见的数值操作符与函数
x//y :用x除以y，舍弃小数部分得到整数
x**y:计算x的y次幂
-x：对x取负数
abs（x）：返回x的绝对值
divmod(x,y):二元组的方式返回x除以y所得的商和余数
pow（x，y，z）：等同于（x**y）%z
round（x，n）：将浮点数x四舍五入到n位小数
3.整数转换函数
bin(i):返回整数i的二进制表示的字符串
hex（i）：返回i的十六进制表示的字符串
int(x):将对象x转换为整数，失败返回异常，浮点数截去小数部分
oct（i）：返回i的八进制标识的字符串
int（s，base）：将字符串转化为整数，失败时产生异常。如果给定了基参数，那么应该为2到36号
4.整数位逻辑运算
i|j:对整数i和j进行OR运算
i^j:对整数i和j进行XOR运算
i&j:对整数i和j进行AND运算
i<<j:将i左移j位
~i:反转i的每一位
#####（3）布尔型
1.有两个内置布尔型对象：true和flase
2.布尔数据类型也可以作为函数进行调用
#####（4）浮点类型
1.Python提供了三种浮点值：内置的float和complex类型，以及标准库中的decimal.Decimal类型，都是固定数据类型
2.Python支持混合计算模式：比如int和float类型进行运算得到float类型数据。decimal.Decimal是混合双精度的所以只能用于其他decimal.Decimal和intS进行运算
3.sys.float_info.epsilon 是机器可以区分两个浮点数的最小区别
4.指数使用p表示而不是e，e是一个有效的十六进制数字
5.math模块的函数和常量
math.acos(x):弧度x的反余弦
math.acosh(x):弧度x的反正切
math.asin(x):弧度x的反正弦
math.asinh(x):弧度x的双曲正弦
math.atan(x):弧度x的反正切
math.atan2(y,x):弧度y/x的反正切
math.atanh(x):弧度x的反双曲正切
math.ceil(x):返回大于等于x的最小整数
math.copysign(x,y):将x的符号设置为y的符号
math.cos(x):弧度x余弦
math.cosh(x):弧度x的余弦值（角度）
math.degree(r):浮点数r从弧度转化为度数
math.e:常数e
math.exp(x):返回e的x次幂
math.fabs(x):返回浮点数的绝对值
math.factorial(x):返回x！
math.floor(x):返回小于等于x的最小整数
math.fmod(x,y):x除以y的模（比%产生更好的结果）
math.frexp(x):返回一个元组(m,e),其计算方式为：x分别除0.5和1,得到一个值的范围，
2**e的值在这个范围内，e取符合要求的最大整数值,然后x/(2**e),得到m的值
如果x等于0,则m和e的值都为0,m的绝对值的范围为(0.5,1)之间，不包括0.5和1
math.fsum(x):对迭代序列x中的值进行求和
math.hypoot(x,y):返回根号下x平方加上y的平方
math.isinf(x):如果x是正无穷大或负无穷大，则返回True,否则返回False
math.isnan(x):如果x不是数字True,否则返回False
math.ldexp(m,e):返回m*(2**e)的值
math.log(x,b):返回x的自然对数，默认以e为基数，base参数给定时，将x的对数返回给定的base,计算式为：log(x)/log(base)
math.log1p(x):返回x+1的自然对数(基数为e)的值
math.modf(x):返回由x的小数部分和整数部分组成的元组
math.pi:常数π
math.pow(x,y):返回x的y次幂
math.radians(d):将d从角度转换为弧度值
math.sqrt(x):返回x的平方根
math.trync(x):返回x的整数部分
2018/8/29 17:21:05
#####（5）复数
1.复数的数据类型是固定的
2.复数的两个部分都是以属性名的形式存在的，分别是real和imag 。例如：z=-89.5（real）+2.125j（imag）
3.conjugate（）方法用于改变虚数部分的符号。例如：z.conjugate()->-89.5-2.125j
4.math模块中的函数不能处理复数，要想使用复数，需要先导入cmath模块，cmath模块有math模块中的所有函数的复数版，也有一些复数特定的函数。
#####（6）十进制数
1.decimal模块可以提供固定的十进制数，精度可以自己指定，要使用Decimal模块就先导入decimal模块
2.十进制数是使用decimal.Decimal()函数创建的，该函数可以接受一个整数或者字符串作为参数，但是不以浮点数作为参数，因为浮点数不够精确
3.decimal.Decimal form-float()函数可以将float转换为十进制（返回与float数值最为接近的decimal.Decimal）
4.在使用decimal.Decimal()处理的结果作为参数给print函数调用时，打印的是字符串形式。如果只是简单的输入表达式，得到的是表象形式（生成备用的输出信息）
#####（7）字符串
1.str()函数也可以作为一个转换函数，第一个参数是字符串或者需要转换的数据类型，第二个参数是指定编码格式，第三个参数是指定如何处理编码错误。
2.在引号包含的字符串中使用引号，如果是相同引号，就必须进行转义
3.Python字符串转义
\N{name}：给定名称的Unicode字符
\uhhhh:给定16位十六进制的Unicode字符
\ooo:给定八进制的字符
\Uhhhhhhhh：给定32位十六进制的Unicode字符
\xhh：给定8位十六进制的Unicode字符
4.如果写一个长字符串跨越多行有3种办法:
使用三引号包含字符串
a='''asbaklsdvnk
asdnfv'''
使用（）包含字符串
a=("sfhaskdfashdflhasd"
"sakdfhaksdhf")
使用+\连接字符串
a="sdkashfksadhfks"+\
"ashfklsdhflas"
5.在进行字符串比较时，Python使用的是字符串的内存字节表示，此时的排序是基于Unicode字元的。
#####（8）字符串分片和步距
1.分片的语法：seq[strat?step],step是-1时，是从最后一个字符开始，从终点到起点。最后总会返回反转字符串
#####（9）字符串的操作方法
s.capitalze():返回字符串的副本，首字母大写
s.center(width,char)：返回字符串中间部分的子字符串，长度width，并使用空格或者chars进行填充
s.count(t,start,end)：返回字符串中t字符串出现的次数
s.encode（encoding,err）：返回一个bytes对象（字节序列），使用默认或指定编码格式表示该字符串，并且可以根据可选的err参数处理错误
s.endswith(x,start,end)：如果s以字符串（或者s的分片）是以字符串x结尾就返回true，否则返回flase
s.expandtabs(size)：返回字符串的副本，其中制表符使用8个或指定数量的空格代替
s.find(t,start,end)：返回字符串t在s字符串中最左位置，找不到返回-1。使用rfind()可以发现字符串t在s字符串中最右位置
s.format(…)：返回给定参数进行格式化后的字符串副本
s.index(t,start,end)：回字符串t在s字符串中最左位置，找不到就产生ValueError异常。
s.isalnum()：如果s不为空，并且其中每个字符都是字母数字就返回true
s.isalpha()：如果s不为空，并且其中每个字符都是字母就返回true
s.isdecimal()：如果s不为空，并且其中每个字符都是Unicode基数为10的数字就返回true
s.isdigit()：如果s不为空，并且每个字符都是ASCII数字就返回true.[注意："\N{digit}02"和"203"作为参数调用时都会返回TRUE，所以不能因为isdigit()返回True就判断某个字符串可以转换为整数]
s.isdentifier()：如果s不为空，并且是一个有效的标志服就返回true
s.islowser()：所有可小写的字符都是小写就返回true
s.isnumeric()：如果s不为空，并且其中每个字符都是数值型Unicode字符，比如数字和小数，就返回true
s.printable()：如果s非空，其中每个字符都是可打印的，不包括换行，就返回true
s.isspace()：如果s非空，每个字符都是空白字符，就返回true
s.istitle()：如果s是一个非空的首字母大写的字符串，就返回true
s.isupper()：所有可大写的字符都是大写就返回true
s.jion(seq)：返回序列seq中每个项连接起来之后的结果，并且以s在每两项之间分割
s.ljust(with,char)：返回长度为width的字符串（使用chars进行填充），中左对齐的字符串s的一个副本
s.lower()：将s中的字符变为小写
s.partituon(t)：返回包含三个字符串的元组（s在t的最左边之前的部分，s在t之后的部分，如果t不在s中则返回s和两个空字符串）
s.respace(t,u,n)：返回s的一个副本，其中从第一个到第n个字符串t都使用u进行替换
s.split(t,n)：返回一个字符串列表，在字符串t处最多分割n次
s.splitlines(f)：返回终结符处进行分割产生的行列表，剥离终结符
s.startwith(x,start,end)：如果字符串s是从字符串x开始就返回true
s.strip(chars)：将开始处和结尾处的空白字符进行删除（lstrip:仅删除开始处空白，rstrip：仅删除结尾处的空白）
s.swapcase()：将s中大写字符变为小写，小写字符变为大写
s.title()：将每个单词首字母大写，其他字母都小写
s.upper()：所有字符都变为大写
s.zfill(w)：返回s的副本，如果比w短，就在开始处添加0使其长度为w
()操作符提供了字符串复制功能。例如 s=10 输出"=========="
str.maketrans()和str.translate()用法：
str.maketrans()用于创建字符间映射转换表，两个参数是字符串且有一样长度
str.translate()以转换表为参数，返回某个字符串根据转换表进行转换之后的副本
#####（10）使用str.format()对字符串进行格式化
str.format()方法会返回一个新的字符串，在新字符串中原字符串的替换字段被适当格式化后的参数替换
>>>stock=["paper","pens","note","pad"]
>>>"we have {0[1]} and {1[2]} in stock" .format(stock)
>>>we have pens and note in stock"
0是位置参数，通过字段名语法，可以引用传递给str.format()方法位置参数与关键字参数。
使用local（）函数可以访问作用范围内的局部变量，会返回一个字典，键是局部变量名，值是对变量值的引用。
>>>name="dingm"
>>>sex="man"
>>>"nameis{name},sex is{sex}".format(**local())
>>>name is dingm,sex is man
将字典拆分并提供给str.format()方法时，允许字典的键作为字段名。
若果需要将多个参数传递给format()方法时，只有最后一个参数才可以使用映射拆分
三种指定符：s用于强制使用字符串形式，r用于强制使用表象形式，a表示强制使用表象形式（仅限于ASCII字符）也可以用于阻止非ASCII字符输出
>>>"{0}{0!s}{0!r}{0!a}".format(decimal.Decimal("93.4"))
>>>"93.4 93.4 Decimal('93.4) Decimal('93.4)"
#####（11）格式规约
“{位置参数：填充字符 对齐字符（<左对齐，^居中对齐，>右对齐） 最小宽度(使用最大宽度前加一个句点（.）) }”
>>>s=“123456”
>>>"{0:-^10}".format(s)
>>>’–123456–’
在格式化规约内部也可以使用计算格式替换字段名
格式规约冒号开始，其后可以跟随一个可选字符串对（一个填充字符，一个对齐字符），之后是可选字符：+表示必须输出符号，-表示只输出复数符号，空格表示为正数输出空格；负数输出符号-，之后跟随的是最小宽度整数值
（最小宽度整数值之前可以使用字符#引导，获取某种[b表示二进制，o表示八进制，x表示小写的十六进制，X表示大写十六进制，c表示输出整数对应的Unicode字符]基数进制为前缀的输出，n代表以场所敏感的方式输出数字）
n的特殊之处在于考虑当前场景，在其产生的输出信息中使用场所特定的十进制字符与分组字符,默认场所为C（十进制符是一个句点，分组符是一个空字符串），Python会尝试自动确定用户场所（检查LANG环境变量）
>>>import locale
>>>loacle.setlocale(locale.LC_ALL,"C")
>>>x,y=(123456789,1234.56)
>>>c="{0:n} {1:n}".format(x,y)
>>>c="123456789 1234.56"
>>>loacle.setlocale(locale.LC_ALL,"en_US.UTF-8")
>>>en="{0:n}{1:n}".format(x,y)
>>>en="123,456,789 1,234.56"
>>>loacle.setlocale(locale.LC_ALL,"de_DE.UTF-8")
>>>de="{0:n}{1:n}".format(x,y)
>>>de="123.456.789 1.234,56"
注意：为整数指定最大字段是不可能的，数字可裁剪会使整数没有意义
从Python3.1开始才支持对复数进行格式化
通过把复数的实数部分和虚数部分分别作为单独的浮点数进行格式化来实现
>>>"{0.real:.3f}{0.imag:+.3f}".format(4.75917+1.2042j)
>>>'4.759+1.204j'
>>>"{0.real:.3f}{0.imag:+.3f}".format(4.75917-1.2042j)
>>>'4.759-1.204j'
>>>(4.75917+1.2042j).conjugate() #改变虚数部分的符号
>>>(4.759+1.204j)
2018/8/30 15:23:52
###（三）组合数据类型
#####（1）元组
1.元祖是固定有序序列支持分片和步距，但不能替换删除其中的任意数据项。如果需要修改元祖，可以使用list()函数转换为列表进行修改。
2.空元组是使用（）创建的，如果含有多个数据项可以使用逗号分隔进行创建
3.collections.namedtuple()用于创建自定义数据类型的元组。第一个参数是想要创建的自定义元组数据类型的名称，第二个参数是一个字符串，其中包含使用空格分割的名称，每个名称代表该元组数据类型的一项。
>>>Aircraft=collection.namedtuple(“Aircraft”,“manufacturer model seating”)
>>>seating=collection.namedtuple(“seating”,“minimum maximum”)
>>>aircraft=Aircraft(“Airbus”,“A320-200”,seating(100,200))
>>>aircraft.seating.maximum
>>>220
>>>print("{0}{1}".format(aircraft.manufacturer,aircraft.model))
>>>Airbus,A320-200
4.namedtuple._asdict()返回的是键值对的映射，其中每个键都是元祖元素的名称，值是对应的值。使用映射拆分将映射转换为str.format()方法的键值参数
#####（2）列表
1.空列表可以使用[]来创建，包含多个项的列表则可以使用逗号分隔来创建。列表中的所有数据实际上都是对象引用
2.列表方法
l.append(x)：将数据项x追加到列表l的尾部
l.count(x)：返回数据项x在列表了l中出现的次数
l.extend(m):将序列m的项追加到l的结尾处
l.index(x):返回数据项在列表中最左边出现的索引位置，否则会产生ValueError
l.insert(i,x):在索引位置int i处将数据项x插入列表l
l.pop():返回并移除list l最右边的数据项
l.pop(i):返回并移除索引位置i处的数据项
l.remove(x):从列表中移除最左边出现的x数据项，如果找不到x就产生ValueError异常
l.reverse():对列表l进行反转
l.sort(…):对列表进行排序，与内置sorted（）函数一样
3.序列拆分*。用于赋值操作符左边有两个或多个变量时，其中一个使用进行引导，数据项将会赋值给该变量，所有剩下的数据项赋值给带星号的变量
>>>first,rest=[9,2,6,8]
>>>first,rest
>>>(9,[2,6,8])
操作符到底是多复制操作符还是序列差分符并不会有二义性，出现在赋值操作符的左边时是序列拆分符，其他时候（做单值操作符是拆分操作符，做二进制操作符，是多复制操作符）
4.DEL语句删除，不一定是删除数据，对于某些对象引用时，del语句的作用是取消该对象引用到数据项的绑定，并删除对象引用，如果这个数据项没有被其他的对象引用进行引用，就进入垃圾回收流程。不能确定垃圾回收流程是否自动进行时，需要手动清理。一种是Try…finally语句块，另一种是使用with语句。
5.假定要x中每个奇数索引项设置为0
>>>x=[1,2,3,4,5,6,7,8,9]
>>>x[1::2]=0len(x[1::2])
6.words.sort(key=str.lower):对words列表进行大小写不敏感排序，key用于指定一个函数，该函数用于每个数据项其返回值在排序时进行比较
#####（3）列表内涵
1.语法格式：[expression for item in iterable if condition] 返回一个列表，其中包含iterable中的每个数据
相同功能代码：
codes=[]
for sex in “MF”
for size in “SMXL”
if sex==“f” and size==“x”:
continue
for color in “BGW”:
codes.append(sex+size+color)
codes=[s+z+c for s in "MF"for z in "SMXL"for c in "BGW" if not(s=="F"and z=="X")]
如果生成的的列表非常大，那么生成每个数据项会比一次性生成整个列表要高效，这可以通过生成器实现，而不是列表内涵。
#####（4）集合
1.Python提供两种内置的集合类型（集合是0个或多个对象引用的具有排他性的无序组合）：可变的set类型，固定的frozentset类型，进行迭代输出时是以任意顺序提供数据项
2.只有可哈希运算的对象可以添加到集合当中，所有内置数据类型都是可哈希运算（float，frozentstest，int，str，tuple），内置的可变数据类型（list，dict，set）都是不可以哈希运算的。
3.空集合必须是由set()创建的，而不能用{}进行创建，集合常用于删除重复的数据
4.集合方法
s.add(x):将数据项添加到集合s中(前提是集合中尚未包含x)
s.clear():移除集合s中的所有数据项
s.copy():返回集合的浅拷贝
s.different(t)s-t：返回一个新集合，包含在s中而不在t中的数据项
s.different_update(t)s-=t：移除每一个在t中而不在s中的数据项
s.discard(x):如果数据x在集合s中就删除该数据项
s.intersection(t)s&t:返回一个新集合，包含同时在t中也在s中的数据项
s.intersection_update(t)s&=t:集合s包含自身与集合t的交集
s.isdisjoint(t):如果s中没有和t中相同的项就返回true
s.issubset(t)s<=t:如果集合s是t集合的真子集，就返回true
s.issuperset(t)s>=t:如果集合t是集合s的真子集就返回true
s.pop():返回并移除集合s中的一个随机项，如果s时空机就产生KeyError异常
s.remove(x):从集合s中移除数据项x，如果s中不包含x就产生KeyError
s.symmetric_different(t)s^t:返回一个新集合，包含s和t中的每个数据项，但不包含同时在s和t中的数据项
s.symmetric_different(t)s^=t:使得集合s只包含自身和集合t的对称差
s.union(t)s|t:返回一个新集合，其中包含集合s所有数据项以及在t中而不在s中的数据项
s.update(t)s|=t:将集合t中，每个，s中不包含的数据项添加到集合s中
#####（5）字典———映射数据类型
1.dict是一种无序的数据类型，包含0个或者多个键值对，键是指向可哈希运算的对象的对象应用，值是可以指向任意类型对象的对象应用。
2.字典的键是独一无二的，如果向字典中添加一个键值项，如果与字典中存在的某个键相同，则实际效果是新值替换久值
3.添加和删除字典，d[“X”]=59; del d[“X”]
4.字典方法
d.clear():移除dict中所有的项
d.copy()：返回dict d的浅拷贝
d.fromkeys(s,y):返回一个dict，该字典的键为序列s中的项，值为None或v
d.get(k):返回字典k关联的值，如果不在就返回None
d.get(k,v):返回字典k关联的值，如果不在就返回v
d.items():返回dict d中所有键值对的视图
d.keys():返回dict d中所有键的视图
d.pop(k):返回k在dict中关联的项，并删除键为k的项，若果k不在d中产生Keyerror异常
d.pop(k,v):返回k在dict中关联的项，并删除键为k的项，若果k不在d中就返回v
d.popitem():返回并移除d中如人意的一个键值对，如果d为空就返回KeyError
d.setdefault(k,v):返回k关联的值，若果k不在d中就插入一个键为k的新项，值为v（没给定v就返回None）
d.updeate(a):将a中不存在于字典d的键值对添加到d中，同时存在于a,d中的键，使用a中对应的值替换d中值（a可以使字典，也可以是序列或参数）
d.valuse():返回d中所有值的视图
5.视图是一个只读的序列，如果视图的字典发生变化则视图也发生变化，键视图和项视图支持一些类似类似集合的操作（交，并，对称）
6.字典常用于存放排他性的个数
7.文件的读写，文件使用内置的open函数打开，返回一个文件对象。
fin=open(filename,"w",encoding="utf-8")
8.通常不使用words[word]+=1这种语法，因为遇到新word时会产生KeyError异常（无法对不存在的对象进行递增操作）而使用words.[word]=words.get(word,0)+1
9.默认字典：
创建方式:words=collections.defdault(int)
特点：永远不会产生KeyError异常。
使用words=["xyz"],如果不存在，立即创建一个新键并且值为0
10.有序字典：有序字典可以用作无需字典的下降替代，有序字典是顺序存储的。
创建方式：d=collection.OrderdDict([('z',-4)],('e',19)) 在使用list.(d.key())会返回['z','e']
特点：如果我们改变某数据项的值时（插入新的数据项，键相同，新值替代旧值），顺序不会改变。
生成排序字典 d=collection.OrderedDict(sorted(d.items())) 只有希望对字典进行多次迭代，并且创建之后不需要进行任何插入操作时，生产成排序字典才有意义。
#####（6）迭代操作符和函——组合数据的迭代和复制
s+t:返回一个序列，该序列是序列s和序列t的连接
s*n:返回一个序列，该序列是序列s的n个副本的连接
x in i:如果x在序列i中返回true
all(i):如果i中的每一项都是true，就返回true
any(i):如果i中任意一项都是true，就返回true
enumerate(i,start):以迭代子为参数，并返回一个二元组（迭代次数，迭代子的下一项）
len(x):测量序列长度
max(i,key):返回序列i中的最大项，给定key函数就返回key（item）值的最大项
min(i,key):返回序列i中的最小项，给定key函数就返回key（item）值的最小项
range(start，stop,step)：返回一个整数迭代子，使用一个参数时，迭代子取值范围是0到stop-1
reversed(i):反序倒转序列i中的每一项
sorted(i,key,reverse):以排序后的顺序从迭代子i返回项，key用于提供DUS（修饰，排序，反转）排序，如果reverse为true时，则排序以反序进行
sum(i,satrt):返回序列i的所有项之和
zip(il,iN):返回元祖的迭代子
#####（7）组合类型的复制
1.Python适用对象引用，在使用赋值操作符=时，并没有进行复制操作
2.无论通过哪一个对象引用造成的改变对另一个对象引用都是可见的
3.再进行提取数据片时，会产生一个单独的副本。所以如果需要整个序列的副本时，可以通过：words=word[:]实现，另一种方式是使用，copy()函数。但是这些复制技术都是浅拷贝（复制的都是对象引用而不是对象）。
4.深拷贝:复制之后的序列是完全独立的。
>>>import copy
>>>x=[“a”,“b”,“c”]
>>>y=deepcopy(x)
2018/9/3 14:33:38
###（四）控制结构与函数
#####（1）控制结构
1.条件分支
if boolean_expression1:
suite1
if bollean_expressionN:
suiteN
else:
else_suite
如果我们需要考虑某个特定情况，又不需要做任何处理，可以使用pass作为suite。
也可以将一条if...else分支缩减为单一的条件表达式：
expression1 if bolean_expression else expression2
如果boolean_expression为True，条件表达式的结果为expression1，否则为expression2
2.循环
while boolean_expression：
while_suite
else:
else_suite
如果循环不能正常终止，就会跳过所有可选的else分支
如果由于break语句，或返回语句，或者由于发生异常导致跳出循环，else分支的suite就不会执行
for expression in iterable：
for_suite
else
else_suite
#####（2）异常处理
1.捕获异常
异常捕获语法：
try:
try_suite
except exception_group 1 as variable1:
except_suiteN
except exception_groupN as variableN:
except_suiteN
else:
else_suite
finally:
finally_suite
如果某个异常发生在try块的suite中，那么每个except分支会顺序尝试执行。如果异常与某个异常组匹配，则相应的suite得到执行。要与异常组进行匹配，异常必须与组中列出的异常类型一致，或者与组中列出的异常类型的子类一致。
注意：在使用多个except块时，我们必须对其排序，从最具针对性的（在一场体系中最底层）异常到最通常（异常体系中最顶层）的异常。如果没有哪个except块匹配到该异常，首先会执行finally块中的suite，如果没有异常产生，finally块的suite总会得到执行，Python会沿着调用栈，并寻找适当的异常处理程序。如果找不到，程序就终止并在控制台上打印一场以及回溯信息。
try...except...finally块一种常见应用是处理文件错误
2.产生异常
异常提供了一种改变控制流的有用方法，有两种可以产生异常的的语法：
raise exception（args）
raise exception（args) from original_exception
raise
使用第一种语法时，指定的异常应该或者是内置异常，或者是继承来自Exception的自定义异常
使用第二种语法时，也就是没有指定异常时，raise将重新产生当前的异常，没有就产生TypeError
3.自定义异常
自定义异常是自定义数据类型（类），基类应该是Exception类或者继承Exception的类
语法：clas exceptionName（baseException）:pass
自定义类的一个用处在于跳出深层嵌套循环
#####（3）自定义函数
函数可以用于将相关功能打包并参数化，Python可以创建四种函数：全局函数，局部函数，lambda函数，方法。
局部函数：定义在其他函数内部，本地函数只对对其定义的函数可见的，对于创建不在其他地方使用的小helper函数，本地函数尤其有用
lambda函数是表达式，因此可以在需要使用的地方创建，不过，这类函数通常要比通常函数受到更多限制
方法是与特定数据类型关联的函数，并且只能与数据类型关联在一起使用。
创建一个全局函数或拒不函数的通用语法：
def functionName(parameters):
suite
1.名称与Docstrings
使用命名框架，并保持一致性。对常量使用UPPERCASE，对类使用TitleCase，对GUI函数与方法使用camel_Case(驼峰式)，对其他对象则适用lowercase或lowercase_with_underscores（带下划线的小写字母），对所有名称，避免使用缩略，除非是标准化并广泛使用，合理使用变量名与参数名名称应该具备良好的描述性，准确描述数据的含义，函数名和方法名应该可以表明行为或返回值。
使用Docstring为函数添加文档信息，可以简单的添加到def行之后，函数代码开始之前的字符串。第一行只是简短的描述，之后一个空白行，再之后跟随的就是完整的描述信息。
2.参数与参数拆分
可以使用序列拆分操作符（*）来提供位置参数
将 * 本身作为参数也是可能的，用于表示*后面不应该再出现位置参数，但关键字参数是允许的。、
将 * 作为第一个参数，那么不允许使用任何位置参数，只能使用关键字参数
可以使用映射拆分符（**）对映射进行拆分。
也可以在参数中使用映射拆分符，通过这种方式创建的函数可以接收任意数量的关键字参数。
3.lambda函数
创建语法：
lambda parameters：expression
paramerters是可选的，通常是逗号分隔的变量名形式，也就是未知参数。expression不能包含分支或循环，也不能包含return。lambda表达式的结果是一个匿名函数。
对内置的sorted（）函数与list.sort（）方法lambda函数通常用做键值函数。比如：对列表内元组按照特定值进行排序
elements=[(2,12,"Mg"),(1,11,"Na"),(1,3,"Li")]
elements.sort(key=lambda e:(e[1],e[2]))
另一种使用lambda函数的场所是，需要创建默认字典时，例如：
minus_one_dict=collections.defaultdict(lambda:-1)
使用一个不存在的键存取minus_one_dict字典，就会创建一个新项，键为minus_one_dict，值为-1 。
4.断言
如果函数接受了无效参数，最坏的结果就是正常运行，没有任何错误提示，一种方法是编写测试，另一种方法是声明前提和后果。
前提和后果可以使用assert语句指定，语法格式是：
assert boolean_expression, option_expression
如果boolean_expression评价为flase，就产生一个AssertionError异常，如果给定了option_expression就将其作为AssertionError异常的参数。可以通过运行程序时在命令行指定 -OO 选项来实现掘弃assert语句与docstrings。或者产生程序的一个副本，所有assert语句被注释掉。
2018/9/25 18:16:43
###（五）模块
#####(1)模块与包
1.Python模块，简单来说就是.py文件，可以包含任意代码，即是程序也是模块。关键区别在于程序设计的目的是运行，模块的设计目标是被其他程序导入并使用。对于程序而言，模块使用的是哪种语言并不重要，因为所有的模块倒入与使用方式都是相同的。
2.所有的import语句部署在.py文件的起始处，并放在shebang行及模块文档之后。我们应该首先导入标准模块，之后是第三方模块库，最后才是我们自定义的模块。
导入时有几种语法：
import importable
import importable1，importable2，
import importable as preferred_name
第一和第二种语法中通常importable是一个模块，或者是一个包中包的模块，可以用（.）进行分隔。第三种语法允许我们对导入的模块或包赋予一个名称，虽然可能会引起名称冲突。但是实践中as语法可以避免这种冲突。
还有一些导入语法：
from importable import object as preferred_name
form importable import object1，object2，哦不ject
form importable import （（object1，object2，，，objectN）
from importable import *
以上最后一种语法意味着导入非私有的一切对象，在实践中意味着导入模块的每一个对象或者模块中有一个全局的_all_变量，其中存放一个名称列表，就导入名称包含在_all_变量中的所有对象。
注意：由于import* 这种语法存在潜在的导致名称冲突的可能性，建议只使用import importable这种语法格式
内置的sys模块中包含一个sys.path列表，其中存放了构成python路径的目录列表，其中第一个目录就是程序所在目录，即便程序可能是从其他目录中调用的。如果设置了环境变量，那么其中指定的路径就是sys.path列表中的下一个路径。
初次导入一个模块时，如果该模块不是内置模块，那么python就回依次在sys.path列出的每个路径中搜索该模块。如果我们创建的模块和pyhton某个库的模块名称相同，就会先找到我们自定义的模块，从而导致问题。
有一种快速检测某个模块名是否使用中的方法是导入该模块，可以在控制台中带命令行选项-c（“执行代码”）调用解释器，之后跟随一个导入语句。例如：python -c "import Music" 。如果产生异常就说明无模块火丁及目录使用该名称，任何其他输出或者无输出都意味着该名称已经被使用。但是后面我们可能会安装第三方python包或模块，其中也可能导致发生冲突。对于自定义模块的文件名我们将第一个字母大写（标准库中都是小写）
在导入某个模块时，pyhton首先检查该模块是否已经导入了，如果没有导入，python就会执行该模块的字节码编译的代码，从而创建该模块提供的变量，函数以及其他对象，并在内部记录该模块已经被导入。
当python需要某个模块的字节码编译的代码时，就会对其自动生成。python首先查找与模块的.py文件同名，但是以.pyo结尾的文件（最优字节码编译版本）如果python找到该模块最新的字节码编译版本，就对其进行加载；否则，python就会加载.py文件，并将其编译成字节码编译版本。无论哪种方式，python都会一字解码便宜行事将相应的模块加载到内存中。
3.包就是一个目录，其中包含一组模块和一个_init_.py文件。
例如：
Graphics/
_init_.py
Bmp.py
Jpeg.py
Png.py
Tiff.py
Xpm.py
只要Graphics目录是我们程序的子目录（或者在Python路径中）我们就可以导入这些模块并使用。我们必须保证顶级模块名称和标准库中的任何顶级名称都不相同。
导入自己的模块：import Graphics.Bmp
也可以在_init_.py文件中添加_all_变量
_all_=["Bmp","Jpeg","Png","Png","Tiff","Xpm"] 这样就可以使用 from Graphcis import* 就可以导入包中的所有模块。
注意：相对导入（from module import）这种语法，并在模块名前有 (.)号，即每个句点跨越一层目录，只能用于包内部的模块。相对导入使得顶层包的重命名更容易，可以防止无意间导入标准模块。
4.自定义模块
如果希望自定义模块dingm.py对特定程序可用，就将dingm.py模块放在该程序所在的目录中。如果希望自定义模块对所有的程序都可用有三种办法：（1）将该模块放在Python分发的site-package目录中（C:\Pyhon30\Lib\site-package）。（2）为该模块创建专用目录并把目录添加到环境变量PYTHONPATH中。（3）把该模块放在本地site—package目录中（%APPDATA%Python/Python30/site-package）
如果想尝试执行docstring中的实例，可以向.py文件末尾添加三行代码：
if_name_=="_name_":
import doctest
doctest.testmod()
doctest.testmod()函数使用Python的内省功能来发现模块及所有的docstring函数，并尝试运行所有docstring代码段
###（六）面向对象程序设计
#####(1)面向对象方法
1.创建对象时无法对其进行有效性验证，这是纯过程型程序设计方法最大的弊端。
2.对象通常包含属性（方法是可以调用的属性），其他属性则是数据。
3.在Python中，每个内置类，库类以及我们创建的每个类都直接或间接的从最顶层的基类Object衍生来。如果没有指定基类，就是Object的直接子类。
4.如果有一个MyDict（继承自dict类）类的对象，并调用同时由dict与MyDict定义的方法，Python将会正确的调用MyDict版本的方法——也就是动态方法绑定，多态性。
注意：Python没有提供两个功能：第一，重载。第二，访问控制（在创建属性时，在属性名前以两个下划线引导，Python就会阻止无心访问，因此也可以看做私有的）
#####(2)自定义类
创建两种自定义类的新语法：
class className：
suite
class className（base_classes）:
suite
1.属性与方法
创建一个对象需要两个步骤，在创建对象时（例如：p=Shape.Point），首先调用特殊方法_new_()来创建对象，之后调用特殊方法_init_()对其进行初始化。
在实际编程中，自定义所有的泪都只需要重新实现_init_()方法，如果自定义类没有提供_new_()方法，Python就会调用object._new_()方法。
如果基类中的方法已经足够用，那么我们可以不在子类中对其进行重新实现，这种方法之所以有效，是因为如果我们对某对象调用了一个方法，而对象所在类没有实现该方法，Python就会自动在类树中进行回溯，直到找到该方法。（如果没有找到，就产生一个AttributeError异常）
方法名的起始和结尾不应该是用两个下划线（除非是预定义的特殊方法）
比较的特殊方法：
_lt_(self,other):如果x比y小，返回true
_le_(self,other):如果x小于或等于y，返回true
_eq_(self,other):如果x和y相等，返回true
_ne_(self,other):如果x和y不相等，返回true
_ge_(self,other):如果x大于等于y，返回true
_gt_(self,other):如果x大于y，返回true
自定义类的所有实例都是可哈希运算的，因此，可对其调用hash（），也可以将其作为字典的键，或者存储在集合中。
内置的isinstance（）函数以一个对象和一个类（或类构成的元组）为参数，如果该类属于给定的类（或类元组中的某个类），或者属于给定的类（或类元组中的某个类）的基类，就返回true。
2.继承和多态
多态意味着，给定类的任意对象在使用时都可以看做该类的任意某个基类的对象，创建子类时只需要实现我们需要的附加方法。必须重新实现的也只是那些需要替换的方法。如果有必要可以使用基类的方法版本可以通过在实现中调用super()函数来实现。
3.使用特制进行属性存取控制
修饰器是一个函数，该函数以一个函数或方法作为参数，并返回参数“修饰后”的版本，也就是对该函数或方法进行修改后的版本。
property()修饰器函数是一个内置的函数，最多可以接受四个参数：一个获取者函数，一个设置者函数，一个删除者函数，一个docstring。使用@property的效果与仅适用一个参数（获取这函数）调用property()的效果是相同的。
Python程序员通常使用特性，而非在其他面向设计语言使用显示的获取函数和设置函数，这是因为将数据属性变为特性非常容易，而不影响该类的有效使用。
4.创建完全整合的数据类型
创建一个完全整合的数据类型一般有两种办法：第一种，从头开始创建，虽然该数据类型必然要继承来自object，但是该数据类型所需要的每个数据属性及方法都必须提供。第二种，继承来自现有的数据类型，这种数据类型与我们需要创建的数据类型相似，对于这种情况，需要重新实现那些不同行为的方法，其他方法则直接继承。
_del_(self)特殊方法，如果我们使用语句del x，实际上发生的处理是对象引用x被删除，并且x所指向的对象的对象引用计数减去1。只有在计数变为0时，才可能调用_del_()方法。
Python提供了两种用于确保资源被正确释放的机制，一种方法是使用try...finally语句块，另一种方法是将上下文对象与with语句一起使用。
所有对象都具备Python自动提供的某些特殊方法，其中的一种方法称为_class_，实际上是对对象类的一个对象引用。所有类都有一个私有的_name_属性，也是Python自动提供的。我们使用这些属性来提供类名（表象形式），如果某个父类被继承时只是添加了一些额外的方法，那么继承来的某个子类就可以正常工作，而不需要重新实现，因为它可以获得子类的类名。
is操作符使用id()函数来确定两个对象是否只想相同的对象。内置的id()函数会对作为参数的对象返回一个独一无二的整数，这一证书通常是该对象在内存中的地址。
类方法的第一个参数是Python指定的，也就是方法所属的类。通常方法的第一个参数也是Python提供的，是调用该参数的实例。静态方法没有Python指定的第一个参数。
5.取消多余的继承方法（这种行为会破坏多态性）
第一种方法:
def_add_(self,other):
raise NotlmplementedError()
注意：NotlmplementedError是一个标准的异常。与内置的Notlmplemented对象是不同的。
第二种方法：
def_add_(self,other):
raise TypeError("unsupported operand type(s) for +:" "'{0}'and'{1}'".foramt(self._class_._name_,other._class_._name_))
如果需要更紧密的模拟Python内置类的行为时，可以产生一个TypeError异常。上面的异常就像Python内置类遇到无效操作符异常。
def_neg_(self):
raise TypeERror("bad operand type for unary -:'{0}'".foramt(self._class_._name_))
对于单值操作，以模拟内置类的方式取消其方法实现
def_eq_(self,other):
return Notlmplemented
对于操作符，是一种跟简单有效的方法。
#####(3)自定义组合类
未完待续。。。
2018/10/15 17:09:20
###（七）正则表达式
#####(1)前言
正则表达式（regexes）是使用mini-language定义的，mini-language完全不同于Python，但是Python包含的re模块可以无缝的创建并使用regexes。
Regexes主要有五种用途：
1.分析：识别提取符合特定标准文本————正则表达式用于创建各种情况的分析器。包括传统的分析工具。
2.搜索：定位可以有不止一种形式的字符串
3.搜索和替换：使用一个字符串和regex匹配的对象进行替换。
4.字符串分割：在regex匹配的地方对字符串进行分割
5.验证：检测文本是否符合某些标准
注意：正则表达式存在一个限制，只能处理递归结构的文本（递归的最大层已知）。
#####（2）正则表达式语言
1.字符串和字符类：
. :可以匹配出换行符以外的任意字符，或者带有re.DOTALL标记的任意字符，或匹配字符类内部的字面意义的字符
\d：匹配一个Unicode字符，或带re.ASCII标记的[0-9]
\D：匹配一个非Unicode字符，或带re.ASCII标记的[^0-9]
\s：匹配Unicode空白，或者带有re.ASCII[\t\n\r\f\v]
\S：匹配Unicode非空白，或带re.ASCII[^\t\n\r\f\v]
\w：匹配一个Unicode单词字符，或带re.ASCII标记的[a-zA-Z0-9]
\W：匹配一个Unicode非单词字符，或带re.ASCII标记的[^a-zA-Z0-9]
2.量词：量词的形式是{m.n}，其中m,n分别表示使用该量词的表达式必须匹配的最少次数与最多次数。量词的{0，1}的使用是非常常见的，并具有一个速记形式（？）。
正则表达式量词：
e? or e{0,1}：贪婪的匹配表达式e的0次或1次出现
e?? or e{0，1}：非贪婪地匹配表达式e e+或e{1，}的0次或1次出现，贪婪地匹配表达式e的1次或多次出现
e+? or e{1,}?：非贪婪地匹配表达式e的1次或多次出现
e* or e{0，}：贪婪地匹配表达式e的0次或1次出现
e*? or e{0,}?：非贪婪地匹配表达式e的0次或多次出现
e{m}：准确匹配表达式e的m次
e{m，}：贪婪地匹配表达式至少m次出现
e{m，}?：非贪婪地匹配表达式e至少m次出现
e{，n}：贪婪的匹配表达式e至多n次出现
e{，n}?:非贪婪的匹配表达式e的至多n次出现
e{m，n}：贪婪的匹配表达式e至少m次，至多n次出现
e{m，n}?：费贪婪的匹配表达式e至少m次，至多n次出现
量词+是非常有用的，比如要匹配整数，可以使用\d+，因为可以匹配一个或多个整数。如果需要标准化一个l的拼写形式，并只匹配两个或者多个1的出现，就可以使用bevell+ed对其进行寻找。
量词*通常会导致意外的结果，要确保正则表达式中至少包含一个其他表达式，并使用一个非0量词————因此至少一个*或?之外的量词，因为这两个量词都可以对表达式进行0次匹配。默认情况下，所有量词都是贪婪地，总是会匹配更多的字符。
问号（？）有两个不同含义，作为其自身标识的是对两次{0，1}的速记，跟随在量词后面时，则表示该量词是非贪婪地。
3.组与捕捉
我们需要某个量词可以应用于几个表达式，所有的这些某地都可以使用()进行组合完成，在多种方案中选取一个的情况下则使用替换符(|)
圆括号可以使实现两种不同目标————对表达式进行组合，匹配某个表达式的文本。使用正则表达式（aircraft|airplane|jet）将其与正则表达式（air（craft|plane）|jet）进行比较，如果第一个表达是匹配成功，那么air的后者有两次捕获（aircraft或airplane作为第一次捕获，craft或plane组为第二次捕获），如果是匹配（jet）就只有一次捕获。通过在左括号后添加一个（?:）就可以关闭捕获，因此（air（?:craft|plane）|jet）在匹配aircraft或airplane或jet时就只有一次捕获。
4.断言和标记
断言不会匹配任何文本，而是对断言所在的文本时间某些规则和约束。
\b（word边界）是一种断言，其含义在于要求在其之前的字符必须是一个单词（\w），而跟随其后的字符必须是一个费单词（\W），或反过来。
正则表达式断言：
^：在起始处匹配，也可以在带MULTILNE标记的每个换行符后匹配
$：在结尾处匹配，也可以在带MULTILNE标记的每个换行符前匹配
\A：在起始处匹配
\b：在单词边界匹配，受re.ASCII标记影响————在字符类内部，则是backspace字符的转义字符。
\B：在费单词边界匹配，受re.ASCII标记影响
\Z：在结尾处匹配
(?=e)：如果表达式e在此断言处匹配，但没有超越此处————称为前瞻或正前瞻，则匹配
(?！e)：如果表达式e在次断言处不匹配，也不需要超越此处————称为负前瞻，则匹配
（?<=e）：如果表达式e恰好在本断言之前匹配————称为正回顾，则匹配
（？<!e）：如果表达式e恰好在本断言之前不匹配————称为负回顾，则匹配
使用re.VERBOSE标记————该标记允许我们在正则表达式中自由的使用空白字符，就必须使用\s或字符类，比如[]。
#####（3）正则表达式模块
re模块提供了两种操纵正则表达式的方法，其中每一个函数都已给定的正则表达式作为第一个参数，每个函数都将正则表达式进行一次编译之后再进行处理。如果只使用一次这种处理非常便利，如果需要重复使用同样的正则表达式就使用re.compile()函数对其进行编译，以避免每次使用该正则表达式时都编译一次的开销。
1.正则表达式模块函数:
re.compoile(r,f)：返回编译后的正则表达式r，如果指定就将其命名为f
re.escape(s)：返回字符串s，其中所有非字母数字的字符都是用反斜线进行转义处理，因此，返回的字符串没有特殊的正则表达式字符
re.findall(r,s,f)：返回正则表达式r在字符串s中所有的非交叠匹配（如果给定f，就受其限制）。如果正则表达式中有捕获，那么每次匹配都作为一个捕获元组返回。
re.finditer(r,s,f)：对正则表达式r在字符串s中每个非交叠的匹配（如果给定f，就受其限制），都返回一个对象。
re.match(r,s,f)：如果正则表达式r在字符串s的起始处匹配（如果给定f，就受其限制），就返回一个匹配对象，否则返回None
re.search(r,s,f)：如果正则表达式r在字符串s任意位置处匹配（如果给定f，就受其限制），就返回一个匹配对象，否则返回None
re.split(r,s,m)：返回分割字符串s（在正则表达式多处出现分割）所产生的字符串的列表，至多分割m次（如果没有给定m，就分割尽量多次），如果正则表达式中包含捕获，就被包含在分割的部分之间。
re.sub(r,x,s,m)：对正则表达式r的每次匹配（如果给定m，就至多匹配m次），返回字符串s的一个副本，并将其替换x————这可以是一个字符串，也可以是一个函数
re.subn(r,x,s,m)：与re.sub函数相同，区别在于此函数返回一个二元组，其中一项为生成的字符串，一项为带入的次数
2.正则表达式模块的标记
re.A或re.ASCII：使\b,\B,\s,\S,\w,\W都假定字符串为ASCII，默认为这些字符类的速记法，依赖于Unicode规范
re.I或re.IGNORECASE：使正则表达式以大小写不敏感的方式进行匹配
re.M或re.MULTILINE：使^在起始处并在每个换行符之后进行匹配，使$在结尾处，但在每个换行符之前进行匹配
re.S或re.DOTALL：使.匹配每个字符，包括换行符
re.X或re.VERBOSE：使空白与注释包含在匹配中
3.正则表达式对象方法
rx.findall(sstart,end)：返回字符串s中（或s的start：end分片中）正则表达式多有的非交叠的匹配，如果正则表达式有捕获，那么每次匹配时返回一个捕获元组
rx.finditer(sstart,end)：对字符串s中（或s的start：end分片中）的每个非交叠匹配，返回一个匹配对象
rx.flags：正则表达式编译时的标记
rx.groupindex：一个字典，其键位捕获组名，值为捕获组编号，如果没有使用名称，就为空
rx.match(s,start,end)：如果正则表达式在字符串s的起始处（或s的start:end分片起始处）匹配，就返回一个匹配对象，否则返回None
rx.pattern：正则表达式被编译时使用的字符串
rx.search(s,start,end)：如果正则表达式在字符串s的任意位置（或s的start:end分片的任意位置）匹配，就返回一个匹配对象，否则就返回None
rx.split(s,m)：返回字符串列表，其中每个字符串都源自对字符串s的分割(在正则表达式的每次匹配处)，但至多有m个分割（如果没有给定m，则尽可能多的分割）;如果正则表达式有捕获，就包含在列表中每两个分割之间
rx.sub(x,s,m)：返回字符串s的副本，其中每个（至多m个，如果给定）匹配处使用x（可以是字符串或函数）进行替换
rx.subn(x,s,m)：与rx.sub相同，区别在于返回的是二元组，其中一项是结果字符串，一项是所做替换的个数
4.匹配对象属性与方法
m.end(g)：返回组g（假如给定）在文本中匹配的终点索引位置，对组0，则表示整体匹配；如果匹配中不包含该组，就返回-1
m.endpos：搜索的终点索引位置（文本的终点，或赋予match()或search()的end）
m.expand(s)：返回字符串s，并将其中的补货表示（\1,\2,\g<name>等类似标识）用相应的捕获替代
m.group(g，...)：返回编号的或命名的组g，如果给定的不止一个，就返回相应的捕获组成的元组（组0表示整体匹配）
m.groupdict(default)：返回一个字典，其中存放所有命名的捕获元组，组名作为键，捕获作为值；如果给定了default参数就将其用做那些不参与匹配的捕获组的值
m.groups(default)：返回包含所有捕获组的元组，从1开始；如果给定default，就将其用做那些不参与匹配的捕获组的值
m.lastgroup：匹配的，编号最高的捕获组的名称，如果不存在或没使用名称就返回None
m.lastindex：匹配的，编号最高的捕获组的编号，如果没有就返回None
m.pos：搜索的起始索引位置（文本的起始处，或赋予match()或search()的start）
m.span(g)：如果给定g，就返回组g在文本中匹配的起始索引位置与结尾索引位置（对组0，则是整体匹配）；如果该组不参与匹配，就返回-1
m.start(g)：如果给定g，就返回组g在文本中匹配的起始索引位置（对组0，则是整体匹配）；如果该组不参与匹配，就返回-1
m.string：传递给match()或search()的字符串
2018/10/17 18:06:11
-------------------------------------我是分割线------------------------------------------------
写了这么多都是基础理论知识，打算到这里先暂停一下。写两个小项目锻炼一下code能力。。。剩下的慢慢再写吧。。。
-------------------------------------我是分割线------------------------------------------------
###（八）文件处理
未完待续。。。
###（九）进程和线程
未完待续。。。
###（十）高级程序设计技术
未完待续。。。
版权声明：本文为博主原创文章，欢迎转载，但必须标识出处，且在文章明显位置给出原文链接
5353
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
