PYTHON学习整理

编程语言是什么：

使用编译器将自身等效转换成机器语言的高级语言，通常称为编译型语言；而使用解释器将自身转换成机器语言的高级语言，称为解释型语言，Python 就是解释型编程语言的一种。

python优点：

Python 简单易用，学习成本低，看起来非常优雅干净

Python 不要求在每个语句的最后写分号，当然写上也没错；
定义变量时不需要指明类型，甚至可以给同一个变量赋值不同类型的数据

Python 标准库和第三库众多，功能强大，既可以开发小工具，也可以开发企业级应用；代码简易
Python 站在了人工智能和大数据的风口上，站在风口上，猪都能飞起来。

Python 源文件是一种纯文本文件，内部没有任何特殊格式，你可以使用任何文本编辑器打开它，比如：

Windows 下的记事本程序；
Linux 下的 Vim、gedit 等

print 输出字符串的格式如下：

print("字符串内容")  或者  print('字符串内容')

字符串要放在小括号( )中传递给 print，让 print 把字符串显示到屏幕上，这种写法在 Python 中被称为函数（Function）。
引号和小括号都必须在英文半角状态下输入，而且 print 的所有字符都是小写。Python 是严格区分大小写的，print 和 Print 代表不同的含义。但是fortran不严格区分。python能够直接输出中文，但在Fortran还需要加上一行说明。

print('i''am')输出‘iam’
print('i','am') 输出'i am'

对分号的说明
有编程经验的读者应该知道，很多编程语言（比如C语言、C++、Java 等）都要求在语句的最后加上分号;，用来表示一个语句的结束。但是 Python 比较灵活，它不要求语句使用分号结尾。但并没有实质的作用（除非同一行有更多的代码），而且这种做法也不是 Python 推荐的。（我理解的是：python是一个没有{}来表示区分部分的语音，依赖缩进，所以尽量不连着写在一行上）

Python 注释

单行注释：从井号#开始，直到这行结束为止的所有内容都是注释
多行注释：Python 使用三个连续的单引号’’'或者三个连续的双引号"""注释多行内容，具体格式如下：

'''
被注释的内容（这样方便注释大块内容）
'''

不管是多行注释还是单行注释，当注释符作为字符串的一部分出现时，就不能再将它们视为注释标记，而应该看做正常代码的一部分

缩进

和其它程序设计语言（如 Java、C 语言）采用大括号“{}”分隔代码块不同，Python 采用代码缩进和冒号（ : ）来区分代码块之间的层次。一般是4个空格（1个tab）表示一个缩进。
Python 对代码的缩进要求非常严格，同一个级别代码块的缩进量必须一样

Python标识符命名规范

1 标识符是由字符（A~Z 和 a~z）、下划线和数字组成，但第一个字符不能是数字。
2 标识符不能和 Python 中的保留字相同。有关保留字，后续章节会详细介绍。
3 Python中的标识符中，不能包含空格、@、% 以及 $ 等特殊字符。
4 在 Python 中，标识符中的字母是严格区分大小写的
5 Python 允许使用汉字作为标识符

关键字

自带函数

Python 解释器自带的函数叫做内置函数，这些函数可以直接使用，不需要导入某个模块

变量类型与运算符

Python 是弱类型的语言，直接就能用，不用声明。而且可以重复使用，而不用考虑类型。但是其他语言比如Fortran就必须同类型赋予同类型的变量，不然就报错。
注意，弱类型并不等于没有类型！弱类型是说在书写代码时不用刻意关注类型，但是在编程语言的内部仍然是有类型的。type() 内置函数类检测某个变量或者表达式的类型
它的整数不分类型，或者说它只有一种类型的整数。Python 整数的取值范围是无限的，不管对于多大或者多小的整数，Python 只用一种类型存储，就是 int

整数

在 Python 中，可以使用多种进制来表示整数：

1. 十进制形式
   我们平时常见的整数就是十进制形式，它由 0~9 共十个数字排列组合而成。

2. 二进制形式
   由 0 和 1 两个数字组成，书写时以0b或0B开头。例如，101 对应十进制数是 5。

3. 八进制形式
   八进制整数由 0~7 共八个数字组成，以0o或0O开头。注意，第一个符号是数字 0，第二个符号是大写或小写的字母 O。

在 Python 2.x 中，八进制数字还可以直接以0（数字零）开头。
4) 十六进制形式
由 0~9 十个数字以及 A~F（或 a~f）六个字母组成，书写时以0x或0X开头，
注释：这里和C语言的是一致的
Python 3.x 允许使用下划线_作为数字（包括整数和小数）的分隔符。通常每隔三个数字添加一个下划线，类似于英文数字中的逗号。下划线不会影响数字本身的值。

浮点数

1. 十进制形式
   这种就是我们平时看到的小数形式，例如 34.6、346.0、0.346。书写小数时必须包含一个小数点，否则会被 Python 当作整数处理。
2. 指数形式
   Python 小数的指数形式的写法为：

aEn 或 aen

a 为尾数部分，是一个十进制数；n 为指数部分，是一个十进制整数；E或e是固定的字符，用于分割尾数部分和指数部分。整个表达式等价于 a×10n。
Python 只有一种小数类型，就是 float。
注释：C语言有两种小数类型，分别是 float 和 double：float 能容纳的小数范围比较小，double 能容纳的小数范围比较大。

Python复数类型（complex）

a + bj   #a 表示实部，b 表示虚部

字符串

'' ""  '''  '''

注意字符串里面包含引号的情况：1）当成转义字符， 引号前面添加反斜杠\就可以对引号进行转义
2）使用不同的引号包围字符串
字符串换行需要在后面加\
长字符串 ‘’’ ‘’’ 或者""" “”" ，会把长字符串原样输出
在普通字符串或者长字符串的开头加上r前缀，就变成了原始字符串（原样输出）
Python bytes 类型用来表示一个字节串。字节串可以恢复成字符串；反之亦然，字符串也可以转换成字节串
可以通过字符串来创建 bytes 对象，或者说将字符串转换成 bytes 对象。有以下三种方法可以达到这个目的：

1. 如果字符串的内容都是 ASCII 字符，那么直接在字符串前面添加b前缀就可以转换成 bytes。
2. bytes 是一个类，调用它的构造方法，也就是 bytes()，可以将字符串按照指定的字符集转换成 bytes；如果不指定字符集，那么默认采用 UTF-8。
3. 字符串本身有一个 encode() 方法，该方法专门用来将字符串按照指定的字符集转换成对应的字节串；如果不指定字符集，那么默认采用 UTF-8。

b5 = "C语言中文网8岁了".encode('UTF-8')
print("b5: ", b5)

bytes 类也有一个 decode() 方法，通过该方法可以将 bytes 对象转换为字符串。紧接上面的程序，添加以下代码：

str1 = b5.decode('UTF-8')  #通过 decode() 方法将 bytes 转换成字符串

布尔类型

布尔类型可以当做整数来对待，即 True 相当于整数值 1，False 相当于整数值 0

Python input()函数：获取用户输入的字符串

input() 函数的用法为：

str = input(tipmsg)   #str 表示一个字符串类型的变量，input 会将读取到的字符串放入 str 中。
#tipmsg 表示提示信息，它会显示在控制台上，告诉用户应该输入什么样的内容；如果不写 tipmsg，就不会有任何提示信息。

Python print()函数高级用法

print (value,...,sep='',end='\n',file=sys.stdout,flush=False)

sep 分隔符设置，end结尾设置，file输出设置，默认的表示屏幕，flush参数用于控制输出缓存，该参数一般保持为 False 即可

类型转换

解释器提示我们字符串和浮点类型变量不能直接相连，需要提前将浮点类型变量 height 转换为字符串才可以

运算符

= 和 == 是两个不同的运算符，= 用来赋值，而 == 用来判断两边的值是否相等，千万不要混淆
比较运算符，也称关系运算符，用于对常量、变量或表达式的结果进行大小比较。如果这种比较是成立的，则返回 True（真），反之则返回 False（假）。

== 用来比较两个变量的值是否相等，而 is 则用来比对两个变量引用的是否是同一个对象
Python 逻辑运算符可以用来操作任何类型的表达式，不管表达式是不是 bool 类型；同时，逻辑运算的结果也不一定是 bool 类型，它也可以是任意类型。
逻辑运算符的本质
1.在 Python 中，and 和 or 不一定会计算右边表达式的值，有时候只计算左边表达式的值就能得到最终结果。

2.另外，and 和 or 运算符会将其中一个表达式的值作为最终结果，而不是将 True 或者 False 作为最终结果。
注：print函数的返回值是None

>>> print(print('true'))
true
None

三目运算符 和C语言里面的一样
exp1 if contion else exp2
运算符优先级：简单来说就是括号>算术>关系>逻辑

列表、元组、字典、集合

在 Python 中，序列类型包括字符串、列表、元组、集合和字典，这些序列支持以下几种通用的操作，但比较特殊的是，集合和字典不支持索引、切片、相加和相乘操作。

列表

Python 中没有数组，但是加入了更加强大的列表。如果把数组看做是一个集装箱，那么 Python 的列表就是一个工厂的仓库。
同一个列表中元素的类型也可以不同，但通常情况下不这么做，同一列表中只放入同一类型的数据，这样可以提高程序的可读性。

列表修改：

1. 添加元素
   Python append()方法添加元素 append() 方法用于在列表的末尾追加元素

listname.append(obj)

extend()方法添加元素 extend() 不会把列表或者元祖视为一个整体，而是把它们包含的元素逐个添加到列表中

listname.extend(obj)

insert()方法插入元素 当插入列表或者元祖时，insert() 也会将它们视为一个整体，作为一个元素插入到列表中，这一点和 append() 是一样的。

listname.insert(index , obj)

2. 删除元素
   del：根据索引值删除元素 del listname[start : end]
   pop()：根据索引值删除元素 listname.pop(index)
   remove()：根据元素值进行删除，remove() 方法只会删除第一个和指定值相同的元素，而且必须保证该元素是存在的，否则会引发 ValueError 错误listname.remove(value)
   clear()：删除列表所有元素listname.clear()
3. 修改元素
   修改单个元素：直接对元素赋值
   修改一组元素：更改的同时可以添加或者删除元素
   注意：python中一般切片增加或者修改列表的时候是不包括最后一个元素的！！！
4. 查找元素
   index() 方法用来查找某个元素在列表中出现的位置（也就是索引）listname.index(obj, start, end)
   count() 方法用来统计某个元素在列表中出现的次数listname.count(obj)

元组

没啥重要的，它不能够改变

字典

字典（dict）是一种无序的、可变的序列，它的元素以“键值对（key-value）”的形式存储
注意，copy() 方法所遵循的拷贝原理，既有深拷贝，也有浅拷贝。拿拷贝字典 a 为例，copy() 方法只会对最表层的键值对进行深拷贝，也就是说，它会再申请一块内存用来存放 {‘one’: 1, ‘two’: 2, ‘three’: []}；而对于某些列表类型的值来说，此方法对其做的是浅拷贝，也就是说，b 中的 [1,2,3] 的值不是自己独有，而是和 a 共有。一个改变则在另一个字典里面也会改变。

update() 方法可以使用一个字典所包含的键值对来更新己有的字典。
pop() 和 popitem() 都用来删除字典中的键值对，不同的是，pop() 用来删除指定的键值对，而 popitem() 用来随机删除一个键值对

集合

同一集合中，只能存储不可变的数据类型，包括整形、浮点型、字符串、元组，无法存储列表、字典、集合这些可变的数据类型
Python set集合方法详解：集合方法合集
set 的元素不能是 set，只能是 frozenset。

Python字符串常用方法

字符串拼接

字符串拼接strname = "str1" "str2" #这种写法只能拼接字符串常量。
如果需要使用变量，就得借助+运算符来拼接strname = str1 + str2

字符串和数字的拼接

先转为字符串再拼接

str(obj)
repr(obj)

分割字符串

str.split(sep,maxsplit)

合并字符串

join() 方法也是非常重要的字符串方法，它是 split() 方法的逆方法，用来将列表（或元组）中包含的多个字符串连接成一个字符串

newstr = str.join(iterable)

newstr：表示合并后生成的新字符串；
str：用于指定合并时的分隔符；
iterable：做合并操作的源字符串数据，允许以列表、元组等形式提供。

统计字符串出现的次数

str.count(sub[,start[,end]])

检测字符串中是否包含某子串

返回第一次出现该字符串的索引

str.find(sub[,start[,end]]) #str：表示原字符串；
#sub：表示要检索的目标字符串；
#start：表示开始检索的起始位置。如果不指定，则默认从头开始检索；
#end：表示结束检索的结束位置。如果不指定，则默认一直检索到结尾。

Python 还提供了 rfind() 方法，与 find() 方法最大的不同在于，rfind() 是从字符串右边开始检索

str.index(sub[,start[,end]]) #index() 方法也可以用于检索是否包含指定的字符串，不同之处在于，当指定的字符串不存在时，index() 方法会抛出异常。

字符串对齐方法

左对齐：S.ljust(width[, fillchar])
S：表示要进行填充的字符串；
width：表示包括 S 本身长度在内，字符串要占的总长度；
fillchar：作为可选参数，用来指定填充字符串时所用的字符，默认情况使用空格
右对齐：S.rjust(width[, fillchar])
文本居中：S.center(width[, fillchar])

字符串大小写转换

title() 方法用于将字符串中每个单词的首字母转为大写，其他字母全部转为小写str.title()
lower() 方法用于将字符串中的所有大写字母转换为小写字母str.lower()
upper() 的功能和 lower() 方法恰好相反，它用于将字符串中的所有小写字母转换为大写字母，str.upper()

编码

encode()方法：用于将 str 类型转换成 bytes 类型，这个过程也称为“编码”

str.encode([encoding="utf-8"][,errors="strict"])

decode() 方法用于将 bytes 类型的二进制数据转换为 str 类型，这个过程也称为“解码”

bytes.decode([encoding="utf-8"][,errors="strict"])

流程控制

sys 模块的 exit() 函数用于退出程序

函数

允许我们将常用的代码以固定的格式封装（包装）成一个独立的模块，只要知道这个模块的名字就可以重复使用它，这个模块就叫做函数（Function）。
Python 中，根据实际参数的类型不同，函数参数的传递方式可分为 2 种，分别为值传递和引用（地址）传递：
**值传递：**适用于实参类型为不可变类型（字符串、数字、元组）；
**引用（地址）传递：**适用于实参类型为可变类型（列表，字典）；

lambda表达式（匿名函数）

lambda 表达式，又称匿名函数，常用来表示内部仅包含 1 行表达式的函数

name = lambda [list] : 表达式
等价于普通形式：
def name(list):
    return 表达式
name(list)

面向对象

面向对象中，常用术语包括：
**类：**可以理解是一个模板，通过它可以创建出无数个具体实例。比如，前面编写的 tortoise 表示的只是乌龟这个物种，通过它可以创建出无数个实例来代表各种不同特征的乌龟（这一过程又称为类的实例化）。
**对象：**类并不能直接使用，通过类创建出的实例（又称对象）才能使用。这有点像汽车图纸和汽车的关系，图纸本身（类）并不能为人们使用，通过图纸创建出的一辆辆车（对象）才能使用。
属性：类中的所有变量称为属性。例如，tortoise 这个类中，bodyColor、footNum、weight、hasShell 都是这个类拥有的属性。
**方法：**类中的所有函数通常称为方法。不过，和函数所有不同的是，类方法至少要包含一个 self 参数（后续会做详细介绍）。例如，tortoise 类中，crawl()、eat()、sleep()、protect() 都是这个类所拥有的方法，类方法无法单独使用，只能和类的对象一起使用。
self参数：对象就是第一个参数self
对于构造函数中的 self 参数，其代表的是当前正在初始化的类对象

类变量与实例变量

类属性其实就是在类体中定义的变量，类方法是在类体中定义的函数
前面章节提到过，在类体中，根据变量定义的位置不同，以及定义的方式不同，类属性又可细分为以下 3 种类型：

1. 类体中、所有函数之外：此范围定义的变量，称为类属性或类变量；
   类变量在所有实例化对象中是作为公用资源存在的，既可以使用类名直接调用，也可以使用类的实例化对象调用（此方法不推荐，因为同名的情况下优先调用实例变量）
   通过类名修改类变量，会作用到所有的实例化对象
   注意，通过类对象是无法修改类变量的。通过类对象对类变量赋值，其本质将不再是修改类变量的值，而是在给该对象定义新的实例变量
   可以简单理解为类名修改则是改图纸，对象修改改不了最根本的东西

2. 类体中，所有函数内部：以“self.变量名”的方式定义的变量，称为实例属性或实例变量；

3. 类体中，所有函数内部：以“变量名=变量值”的方式定义的变量，称为局部变量。
   局部变量直接以“变量名=值”的方式进行定义

property()函数：定义属性

属性名=property(fget=None, fset=None, fdel=None, doc=None)

fget 参数用于指定获取该属性值的类方法，fset 参数用于指定设置该属性值的方法，fdel 参数用于指定删除该属性值的方法，最后的 doc 是一个文档字符串，用于说明此函数的作用

Python类特殊成员（属性和方法）

凡是以双下划线 “__” 开头和结尾命名的成员（属性和方法），都被称为类的特殊成员（特殊属性和特殊方法）。即不能在类的外部直接调用，但允许借助类中的普通方法调用甚至修改它们。如果需要，还可以对类的特殊方法进行重写，从而实现一些特殊的功能。
__new__()方法：负责创建类实例的静态方法，它无需使用 staticmethod 装饰器修饰，且该方法会优先 init() 初始化方法被调用
看不懂啊 ~~~~~~~~~~~~

异常处理

语法错误：Python解释器在解析时就会报出 SyntaxError 语法错误，与此同时还会明确指出最早探测到错误的语句。
运行时错误：指明了错误的位置，表示出错的类型

try except异常处理详解

try:
    可能产生异常的代码块
except [ (Error1, Error2, ... ) [as e] ]:
    处理异常的代码块1
except [ (Error3, Error4, ... ) [as e] ]:
    处理异常的代码块2
except  [Exception]:
    处理其它异常

该格式中，[] 括起来的部分可以使用，也可以省略。其中各部分的含义如下：
(Error1, Error2,…) 、(Error3, Error4,…)：其中，Error1、Error2、Error3 和 Error4 都是具体的异常类型。显然，一个 except 块可以同时处理多种异常。
[as e]：作为可选参数，表示给异常类型起一个别名 e，这样做的好处是方便在 except 块中调用异常类型（后续会用到）。
[Exception]：作为可选参数，可以代指程序可能发生的所有异常情况，其通常用在最后一个 except 块。

正常的效果应该是，只有直接运行模板文件时，测试代码才会被执行；反之，如果是其它程序以引入的方式执行模板文件，则测试代码不应该被执行
要实现这个效果，可以借助 Python 内置的 __name__ 变量。当直接运行一个模块时，name 变量的值为 __main__；而将模块被导入其他程序中并运行该程序时，处于模块中的 __name__ 变量的值就变成了模块名。因此，如果希望测试函数只有在直接运行模块文件时才执行，则可在调用测试函数时增加判断，即只有当 __name__ =='__main__' 时才调用测试函数

if __name__ == '__main__':

Python __name__=='__main__'作用详解

就是为了不运行测试代码，只在原模块中才运行
因此，if __name__ == '__main__': 的作用是确保只有单独运行该模块时，此表达式才成立，才可以进入此判断语法，执行其中的测试代码；反之，如果只是作为模块导入到其他程序文件中，则此表达式将不成立，运行其它程序时，也就不会执行该判断语句中的测试代码。

Python创建包，导入包

创建包：
新建一个文件夹，文件夹的名称就是新建包的包名；
在该文件夹中，创建一个 __init__.py 文件（前后各有 2 个下划线‘_’）
__init__.py 文件的作用是将文件夹变为一个Python模块,Python 中的每个模块的包中，都有__init__.py 文件
导入包：

1. import 包名[.模块名 [as 别名]]
   通过此语法格式导入包中的指定模块后，在使用该模块中的成员（变量、函数、类）时，需添加“包名.模块名”为前缀
2. from 包名 import 模块名 [as 别名]
   使用此语法格式导入包中模块后，在使用其成员时不需要带包名前缀，但需要带模块名前缀
3. from 包名.模块名 import 成员名 [as 别名]
   通过该方式导入的变量（函数、类），在使用时可以直接使用变量名（函数名、类名）调用

注意，导入包的同时，会在包目录下生成一个含有 __init__.cpython-36.pyc 文件的 __pycache__ 文件夹。
直接导入包名，并不会将包中所有模块全部导入到程序中，它的作用仅仅是导入并执行包下的 __init__.py 文件，因此，运行该程序，在执行 __init__.py 文件中代码的同时，还会抛出 AttributeError 异常（访问的对象不存在

文件基本操作

删除、修改权限：作用于文件本身，属于系统级操作。可以借助 Python 中的专用模块（os、sys 等），并调用模块中的指定函数来实现
写入、读取：是文件最常用的操作，作用于文件的内容，属于应用级操作。通常需要按照固定的步骤进行操作
文件的应用级操作可以分为以下 3 步，每一步都需要借助对应的函数实现：

1. 打开文件：使用 open() 函数，该函数会返回一个文件对象；
2. 对已打开文件做读/写操作：读取文件内容可使用 read()、readline() 以及 readlines() 函数；向文件中写入内容，可以使用 write() 函数。
3. 关闭文件：完成对文件的读/写操作之后，最后需要关闭文件，可以使用 close() 函数。

open() 函数用于创建或打开指定文件

file = open(file_name [, mode='r' [ , buffering=-1 [ , encoding = None ]]])

file.name：返回文件的名称；
file.mode：返回打开文件时，采用的文件打开模式；
file.encoding：返回打开文件时使用的编码格式；
file.closed：判断文件是否己经关闭。

读取文件中数据

1. read() 函数：逐个字节或者字符读取文件中的内容；file.read([size])
   file 表示已打开的文件对象；size 作为一个可选参数，用于指定一次最多可读取的字符（字节）个数，如果省略，则默认一次性读取所有内容
2. readline() 函数：逐行读取文件中的内容；file.readline([size])
   readlines() 函数：一次性读取文件中多行内容。file.readlines()
   这 2 个函数都以“行”作为读取单位，即每次都读取目标文件中的一行。对于读取以文本格式打开的文件，读取一行很好理解；对于读取以二进制格式打开的文件，它们会以“\n”作为读取一行的标志
   readlines() 函数用于读取文件中的所有行，它和调用不指定 size 参数的 read() 函数类似，只不过该函数返回是一个字符串列表，其中每个元素为文件中的一行内容。

向文件中写入数据

file.write(string) #file 表示已经打开的文件对象；string 表示要写入文件的字符串（或字节串，仅适用写入二进制文件中）

如果向文件写入数据后，不想马上关闭文件，也可以调用文件对象提供的 flush() 函数，它可以实现将缓冲区的数据写入文件中。例如：f.flush()
writelines()函数:实现将字符串列表写入文件中
使用 writelines() 函数向文件中写入多行数据时，不会自动给各行添加换行符

关闭文件

file.close()

文件指针

文件指针用于标明文件读写的起始位置
tell() 函数用于判断文件指针当前所处的位置，而 seek() 函数用于移动文件指针到文件的指定位置
file.tell() ，当使用 open() 函数打开文件时，文件指针的起始位置为 0，表示位于文件的开头处。当程序使用文件对象读写数据时，文件指针会自动向后移动：读写了多少个数据，文件指针就自动向后移动多少个位置
seek() 函数用于将文件指针移动至指定位置
file.seek(offset[, whence])
whence：作为可选参数，用于指定文件指针要放置的位置，该参数的参数值有 3 个选择：0 代表文件头（默认值）、1 代表当前位置、2 代表文件尾。
offset：表示相对于 whence 位置文件指针的偏移量，正数表示向后偏移，负数表示向前偏移

上下文管理器

同时包含 __enter__() 和 __exit__() 方法的对象就是上下文管理器
with as

fileinput模块：逐行读取多个文件

fileinput.input（files="filename1, filename2, ...", inplace=False, backup='', bufsize=0, mode='r', openhook=None）

files：多个文件的路径列表；
inplace：用于指定是否将标准输出的结果写回到文件，此参数默认值为 False；
backup：用于指定备份文件的扩展名；
bufsize：指定缓冲区的大小，默认为 0；
mode：打开文件的格式，默认为 r（只读格式）；
openhook：控制文件的打开方式，例如编码格式等。

linecache模块用法：随机读取文件指定行