python学习笔记

多行自动换行

英文逗号

在print命令中输入多个变量

输出时默认为空格间隔

指定间隔符

默认\n，换行

通过end参数定义更换print输出完成后

输出目标指定，默认值为 sys.stdout输出到屏幕

先将文件打开，变量赋值后，即可写入文件

用于控制输出缓存，该参数一般保持默认 False 即可

转换说明符（Conversion Specifier）

指定最小输出宽度

指定对齐方式

指定小数精度

实例
str1 = "hello "
print(str1 * 4)

实例：
print('81**(1/4) =', 81**(1/4))
print('32**(1/5) =', 32**(1/5))

Python 是以缩进来标记代码块的
代码块一定要有缩进，没有缩进的不是代码块
另外，同一个代码块的缩进量要相同，缩进量不同的不属于同一个代码块

if、elif、else 语句的最后都有冒号:

Python 会把 True 当做“真”，把 False 当做“假”
对于数字，Python 会把 0 和 0.0 当做“假”，把其它值当做“真”
对于其它类型，当对象为空或者为 None 时，Python 会把它们当做“假”，其它情况当做真。

pass 是 Python 中的关键字，用来让解释器跳过此处，什么都不做

能缩小版的 if 语句
它用于判断某个表达式的值，如果值为真，则程序可以继续往下执行
反之，Python 解释器会报 AssertionError 错误

assert 表达式

my_char="http://c.biancheng.net/python/"
i = 0;
while i<len(my_char):
print(my_char[i],end="")
i = i + 1

my_list = [1,2,3,4,5]
for ele in my_list:
print('ele =', ele)

当循环条件为 False 跳出循环时，程序会最先执行 else 代码块中的代码

当 2 个（甚至多个）循环结构相互嵌套时
位于外层的循环结构常简称为外层循环或外循环
位于内层的循环结构常简称为内层循环或内循环

当外层循环条件为 True 时，则执行外层循环结构中的循环体；
外层循环体中包含了普通程序和内循环，当内层循环的循环条件为 True 时会执行此循环中的循环体
直到内层循环条件为 False，跳出内循环
如果此时外层循环的条件仍为 True，则返回第 2 步，继续执行外层循环体，直到外层循环的循环条件为 False；
当内层循环的循环条件为 False，且外层循环的循环条件也为 False，则整个嵌套循环才算执行完毕。

使用 for 循环实现用冒泡排序算法

data = [5,8,4,1]
#实现冒泡排序
for i in range(len(data)-1):
for j in range(len(data)-i-1):
if(data[j]>data[j+1]):
data[j],data[j+1] = data[j+1],data[j]
print("排序后：",data)

zip(iterable, ...)
iterable,... 表示多个列表、元组、字典、集合、字符串，甚至还可以为 range() 区间

my_list = [11,12,13]
my_tuple = (21,22,23)
print([x for x in zip(my_list,my_tuple)])
my_dic = {31:2,32:4,33:5}
my_set = {41,42,43,44}
print([x for x in zip(my_dic)])
my_pychar = "python"
my_shechar = "shell"
print([x for x in zip(my_pychar,my_shechar)])

对于给定的序列（包括列表、元组、字符串以及 range(n) 区间），该函数可以返回一个逆序序列的迭代器（用于遍历该逆序序列）

reversed(seq)
seq 可以是列表，元素，字符串以及 range() 生成的区间列表

list = sorted(iterable, key=None, reverse=False)
iterable 表示指定的序列
key 参数可以自定义排序规则
reverse 参数指定以升序（False，默认）还是降序（True）进行排序
sorted() 函数会返回一个排好序的列表
key 参数和 reverse 参数是可选参数

#对列表进行排序
a = [5,3,4,2,1]
print(sorted(a))
#对元组进行排序
a = (5,4,3,1,2)
print(sorted(a))
#字典默认按照key进行排序
a = {4:1,\
5:2,\
3:3,\
2:6,\
1:8}
print(sorted(a.items()))
#对集合进行排序
a = {1,5,3,2,4}
print(sorted(a))
#对字符串进行排序
a = "51423"
print(sorted(a))

#对列表进行排序
a = [5,3,4,2,1]
print(sorted(a,reverse=True))

chars=['http://c.biancheng.net',\
'http://c.biancheng.net/python/',\
'http://c.biancheng.net/shell/',\
'http://c.biancheng.net/java/',\
'http://c.biancheng.net/golang/']
#默认排序
print(sorted(chars))
#自定义按照字符串长度排序
print(sorted(chars,key=lambda x:len(x)))

可以执行一个字符串形式的 Python 代码（代码以字符串的形式提供），相当于一个 Python 的解释器

eval(source, globals=None, locals=None, /)

expression：这个参数是一个字符串，代表要执行的语句 。该语句受后面两个字典类型参数 globals 和 locals 的限制，只有在 globals 字典和 locals 字典作用域内的函数和变量才能被执行。
globals：这个参数管控的是一个全局的命名空间，即 expression 可以使用全局命名空间中的函数。如果只是提供了 globals 参数，而没有提供自定义的 __builtins__，则系统会将当前环境中的 __builtins__ 复制到自己提供的 globals 中，然后才会进行计算；如果连 globals 这个参数都没有被提供，则使用 Python 的全局命名空间。
locals：这个参数管控的是一个局部的命名空间，和 globals 类似，当它和 globals 中有重复或冲突时，以 locals 的为准。如果 locals 没有被提供，则默认为 globals。

a = 1
exec("a = 2") #相当于直接执行 a=2
print(a)
a = exec("2+3") #相当于直接执行 2+3，但是并没有返回值，a 应为 None
print(a)
a = eval('2+3') #执行 2+3，并把结果返回给 a
print(a)

在编写代码时，一般会使 repr() 数来生成动态的字符串，再传入到 eval() 或 exec() 函数内，实现动态执行代码的功能

可以执行一个字符串形式的 Python 代码（代码以字符串的形式提供），相当于一个 Python 的解释器

exec(source, globals=None, locals=None, /)

expression：这个参数是一个字符串，代表要执行的语句 。该语句受后面两个字典类型参数 globals 和 locals 的限制，只有在 globals 字典和 locals 字典作用域内的函数和变量才能被执行。
globals：这个参数管控的是一个全局的命名空间，即 expression 可以使用全局命名空间中的函数。如果只是提供了 globals 参数，而没有提供自定义的 __builtins__，则系统会将当前环境中的 __builtins__ 复制到自己提供的 globals 中，然后才会进行计算；如果连 globals 这个参数都没有被提供，则使用 Python 的全局命名空间。
locals：这个参数管控的是一个局部的命名空间，和 globals 类似，当它和 globals 中有重复或冲突时，以 locals 的为准。如果 locals 没有被提供，则默认为 globals。

执行后不返回结果

函数名：其实就是一个符合 Python 语法的标识符

形参列表：设置该函数可以接收多少个参数，多个参数之间用逗号（ , ）分隔

#定义一个比较字符串大小的函数
def str_max(str1,str2):
str = str1 if str1 > str2 else str2
return str

#自定义 len() 函数
def my_len(str):
length = 0
for c in str:
length = length + 1
return length

def 函数名(...，形参名，形参名=默认值)：
代码块

指定有默认值的形式参数必须在所有没默认值参数的最后，否则会产生语法错误

Pyhton 中，可以使用“函数名.__defaults__”查看函数的默认值参数的当前值，其返回值是一个元组。

def func(required_arg, default_arg=None, *args, **kwargs):
pass
# required_arg 必传位置参数
# default_arg 默认参数
# *args 非键值可变参数
# **kwargs 键值可变参数

*args是用来传递一个非键值变长参数列表功能。
**kwargs通常用来传递关键字变长参数。

在参数前面添加两个星号（**）， 该参数支持关键字参数收集，收集的参数别当成 dict 处理
一个函数可同时支持普通参数收集和关键字参数收集

在形参前面添加一个星号（*），意味着该参数可接受多个参数值
Python 将传给带 * 参数的多个值收集成一个元组
Python 允许参数收集的形参位于形参列表的任意位置，但只能带一个支持“普通”参数收集的形参
若支持“普通”参数收集的形参位于前面，后面的参数则需要使用关键字参数传值

def test(*books, num, **scores):
print('books:', books)
print('num:', num)
print('scores:', scores)

test('python', 'java', 'c', num=3, py=90, ja=80)

return 语句在同一函数中可以出现多次，但只要有一个得到执行，就会直接结束函数的执行

def isGreater0(x):
if x > 0:
return True
else:
return False
print(isGreater0(5))
print(isGreater0(0))

多个返回值

[返回值] = 函数名([形参值])

关键字参数

逆向参数收集

直接将函数赋值给其它变量

将函数以参数的形式传入其他函数中

函数的返回值也为函数

一球从100米高度自由落下，每次落地后反跳回原高度的一半；
再落下，求它在第10次落地时，共经过多少米？第10次反弹多高？

def heigthM(num, heigth, sum):
sum += heigth
heigth /= 2 #第一次返回高度50
print(heigth, sum) # 查看每次返回的高度和经过多少米
if num == 1:
return heigth ,sum
else:
sum += heigth # 返回到最高点时，经过多少米需要加上高度
return heigthM(num - 1, heigth, sum)
print(heigthM(10, 100, 0)) #num是次数，heigth是高度，sum是经过多少米

'''
猴子吃桃问题：猴子第一天摘下若干个桃子，
当即吃了一半，还不瘾，又多吃了一个第二天早上又将剩下的桃子吃掉一半，
又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。
到第10天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少？
'''

def monkey(n):
if n == 1:
return 1
else:
return (monkey(n - 1) + 1) * 2

print(monkey(10))

将现有函数的部分参数预先绑定为指定值，从而得到一个新的函数

定义偏函数，需使用 partial 关键字（位于 functools 模块中），其语法格式如下：
偏函数名 = partial(func, *args, **kwargs)

其中，func 指的是要封装的原函数，*args 和 **kwargs 分别用于接收无关键字实参和关键字实参。

from functools import partial
def mod( n, m ):
return n % m
#定义偏函数，并设置参数 n 对应的实参值为 100
mod_by_100 = partial( mod, 100 )
print(mod( 100, 7 ))
print(mod_by_100( 7 ))

Python 支持在函数内部定义函数，此类函数又称为局部函数
默认情况下局部函数只能在其所在函数的作用域内使用

#全局函数
def outdef ():
#局部函数
def indef():
print("http://c.biancheng.net/python/")
#调用局部函数
indef()
#调用全局函数
outdef()

#全局函数
def outdef ():
#局部函数
def indef():
print("调用局部函数")
#调用局部函数
return indef
#调用全局函数
new_indef = outdef()
调用全局函数中的局部函数
new_indef()

和嵌套函数类似，不同之处在于，闭包中外部函数返回的不是一个具体的值，而是一个函数
一般情况下，返回的函数会赋值给一个变量，这个变量可以在后面被继续执行调用。

#闭包函数，其中 exponent 称为自由变量
def nth_power(exponent):
def exponent_of(base):
return base ** exponent
return exponent_of # 返回值是 exponent_of 函数
square = nth_power(2) # 计算一个数的平方
cube = nth_power(3) # 计算一个数的立方
print(square(2)) # 计算 2 的平方
print(cube(2)) # 计算 2 的立方

外部函数 nth_power() 的返回值是函数 exponent_of()，而不是一个具体的数值

常用来表示内部仅包含 1 行表达式的函数
。如果一个函数的函数体仅有 1 行表达式，则该函数就可以用 lambda 表达式来代替。

name = lambda [list] : 表达式
必须使用 lambda 关键字
[list] 作为可选参数，等同于定义函数是指定的参数列表
value 为该表达式的名称。

对于单行函数，使用 lambda 表达式可以省去定义函数的过程，让代码更加简洁；
对于不需要多次复用的函数，使用 lambda 表达式可以在用完之后立即释放，提高程序执行的性能

add = lambda x,y:x+y
print(add(3,4))

对可迭代对象中的每个元素，都调用指定的函数，并返回一个 map 对象

可以接受多个可迭代对象

map(function, iterable)

function 参数表示要传入一个函数，其可以是内置函数、自定义函数或者 lambda 匿名函数
iterable 表示一个或多个可迭代对象，可以是列表、字符串等

listDemo1 = [1, 2, 3, 4, 5]
listDemo2 = [3, 4, 5, 6, 7]
new_list = map(lambda x,y: x + y, listDemo1,listDemo2)
print(list(new_list))

对 iterable 中的每个元素，都使用 function 函数判断，并返回 True 或者 False，最后将返回 True 的元素组成一个新的可遍历的集合

可以接受多个可迭代对象

filter(function, iterable)
funcition 参数表示要传入一个函数，iterable 表示一个可迭代对象。

返回一个列表中的所有偶数。
listDemo = [1, 2, 3, 4, 5]
new_list = filter(lambda x: x % 2 == 0, listDemo)
print(list(new_list))

用来对一个集合做一些累积操作

reduce(function, iterable)

function 规定必须是一个包含 2 个参数的函数；iterable 表示可迭代对象

reduce() 函数在 Python 3.x 中已经被移除，放入了 functools 模块，因此在使用该函数之前，需先导入 functools 模块

计算某个列表元素的乘积。
 
import functools
listDemo = [1, 2, 3, 4, 5]
product = functools.reduce(lambda x, y: x * y, listDemo)
print(product)

'''
demo 模块中包含以下内容：
name 字符串变量：初始值为“Python教程”
add 字符串变量：初始值为“http://c.biancheng.net/python”
say() 函数
CLanguage类：包含 name 和 add 属性和 say() 方法。
'''

可以通过模板的 __doc__ 属性，来访问模板的说明文档 
import demo
print(demo.__doc__)

当直接运行一个模块时，name 变量的值为 __main__；
而将模块被导入其他程序中并运行该程序时，处于模块中的 __name__ 变量的值就变成了模块名。
因此，如果希望测试函数只有在直接运行模块文件时才执行，则可在调用测试函数时增加判断
即只有当 __name__ =='__main__' 时才调用测试函数

一般情况下，当我们写完自定义的模块之后，都会写一个测试代码，检验一些模块中各个功能是否能够成功运行
例如，创建一个 candf.py 文件，并编写如下代码：
纯文本复制
'''
摄氏度和华氏度的相互转换模块
'''
def c2f(cel):
fah = cel * 1.8 + 32
return fah
def f2c(fah):
cel = (fah - 32) / 1.8
return cel
def test():
print("测试数据：0 摄氏度 = %.2f 华氏度" % c2f(0))
print("测试数据：0 华氏度 = %.2f 摄氏度" % f2c(0))
test()

# 导入sys整个模块
import sys
# 使用sys模块名作为前缀来访问模块中的成员
print(sys.argv[0])

导入整个模块时，也可以为模块指定别名。 
# 导入sys整个模块，并指定别名为s
import sys as s
# 使用s模块别名作为前缀来访问模块中的成员
print(s.argv[0])

一次导入多个模块，多个模块之间用逗号隔开 
 
# 导入sys、os两个模块
import sys,os
# 使用模块名作为前缀来访问模块中的成员
print(sys.argv[0])
# os模块的sep变量代表平台上的路径分隔符
print(os.sep)

在导入多个模块的同时，也可以为模块指定别名 
# 导入sys、os两个模块，并为sys指定别名s，为os指定别名o
import sys as s,os as o
# 使用模块别名作为前缀来访问模块中的成员
print(s.argv[0])
print(o.sep)

使用 from...import 最简单的语法来导入指定成员：
 
# 导入sys模块的argv成员
from sys import argv
# 使用导入成员的语法，直接使用成员名访问
print(argv[0])

form...import 导入模块成员时，支持一次导入多个成员：
纯文本复制
# 导入sys模块的argv,winver成员
from sys import argv, winver
# 使用导入成员的语法，直接使用成员名访问
print(argv[0])
print(winver)

导入模块成员时，也可以为成员指定别名：
纯文本复制
# 导入sys模块的argv成员，并为其指定别名v
from sys import argv as v
# 使用导入成员（并指定别名）的语法，直接使用成员的别名访问
print(v[0])

main.py

# import module_test
from module_test import * #这种是把模块中的代码复制到了这个py脚本中

如果模块中包含空格或者以数字开头，就需要使用 Python 提供的 __import__() 内置函数引入模块

__import__("demo text")

__import__("1demo")

使用 __import__() 函数引入模块名时，要以字符串的方式将模块名引入，否则会报 SyntaxError 错误

通常情况下，当使用 import 语句导入模块后，Python 会按照以下顺序查找指定的模块文件：
在当前目录，即当前执行的程序文件所在目录下查找；
到 PYTHONPATH（环境变量）下的每个目录中查找；
到 Python 默认的安装目录下查找。

向 sys.path 中临时添加模块文件存储位置的完整路径

将模块放在 sys.path 变量中已包含的模块加载路径中

设置 path 系统环境变量

该变量的值是一个列表，存储的是当前模块中一些成员（变量、函数或者类）的名称
通过在模块文件中设置 __all__ 变量，当其它文件以“from 模块名 import *”的形式导入该模块时，该文件中只能使用 __all__ 列表中指定的成员

def say():
print("人生苦短，我学Python！")
def CLanguage():
print("C语言中文网：http://c.biancheng.net")
def disPython():
print("Python教程：http://c.biancheng.net/python")
__all__ = ["say","CLanguage"]

__all__ 变量仅限于在其它文件中以“from 模块名 import *”的方式引入

以“import 模块名”的形式导入模块。通过该方式导入模块后
总可以通过模块名前缀（如果为模块指定了别名，则可以使用模快的别名作为前缀）来调用模块内的所有成员（除了以下划线开头命名的成员）

以“from 模块名 import 成员”的形式直接导入指定成员
使用此方式导入的模块，__all__ 变量即便设置，也形同虚设

新建一个文件夹，文件夹的名称就是新建包的包名；
在该文件夹中，创建一个 __init__.py 文件（前后各有 2 个下划线‘_’），该文件中可以不编写任何代码。
也可以编写一些 Python 初始化代码，则当有其它程序文件导入包时，会自动执行该文件中的代码

import 包名[.模块名 [as 别名]]
用 [] 括起来的部分，是可选部分，即可以使用，也可以直接忽略

from 包名 import 模块名 [as 别名]

from 包名.模块名 import 成员名 [as 别名]

导入包的同时，会在包目录下生成一个含有 __init__.cpython-36.pyc 文件的 __pycache__ 文件夹

可以被import语句导入的对象是以下类型：

模块文件（.py文件）
C或C++扩展（已编译为共享库或DLL文件）
包（包含多个模块）
内建模块（使用C编写并已链接到Python解释器中）

import string
print(dir(string))

import string
print(string.__all__)

和 dir() 函数相比，__all__ 变量在查看指定模块成员时，它不会显示模块中的特殊成员，同时还会根据成员的名称进行排序显示

并非所有的模块都支持使用 __all__ 变量，因此对于获取有些模块的成员，就只能使用 dir() 函数

help() 函数

import my_package
print(my_package.module1.display.__doc__)

import my_package
print(my_package.__file__)

因为当引入 my_package 包时，其实际上执行的是 __init__.py 文件
因此这里查看 my_package 包的存储路径，输出的 __init__.py 文件的存储路径

import string
print(string.__file__)

并不是所有模块都提供 __file__ 属性，因为并不是所有模块的实现都采用 Python 语言
有些模块采用的是其它编程语言（如 C 语言）

https://pypi.org/

可以使用 Python 提供的 pip 命令实现。pip 命令的语法格式如下：
pip install|uninstall|list 模块名

其中，install、uninstall、list 是常用的命令参数，各自的含义为：
install：用于安装第三方模块，当 pip 使用 install 作为参数时，后面的模块名不能省略。
uninstall：用于卸载已经安装的第三方模块，选择 uninstall 作为参数时，后面的模块名也不能省略。
list：用于显示已经安装的第三方模块。

以安装 numpy 模块为例（该模块用于进行科学计算），可以在命令行窗口中输入以下代码：
pip install numpy

执行此代码，它会在线自动安装 numpy 模块

pip 命令会将下载完成的第三方模块，默认安装到 Python 安装目录中的 \Lib\site-packages 目录下

#直接导入 numpy 模块即可
import numpy as nu
#用 numpy 模块中的开发函数
print(nu.sqrt(16))

如果想要查看 Python 中目前有哪些模块（包括标准模块和第三方模块），可以在 IDLE 中输入以下命令：
help('modules')

在此基础上，如果只是想要查看已经安装的第三方模块，可以在使用如下命令：
pip list

将单个文件和路径上的文件夹名称的字符串传递给它
os.path.join() 就会返回一个文件路径的字符串，包含正确的路径分隔符

>>> import os
>>> os.path.join('demo', 'exercise')
'demo\\exercise'

>>> import os
>>> os.getcwd()
'C:\\Users\\mengma\\Desktop'
>>> os.chdir('C:\\Windows\\System32')
>>> os.getcwd()
'C:\\Windows\\System32'

>>> path = 'C:\\Windows\\System32\\calc.exe'
>>> os.path.split(path)
('C:\\Windows\\System32', 'calc.exe')

文件的应用级操作可以分为以下 3 步，每一步都需要借助对应的函数实现：
打开文件：使用 open() 函数，该函数会返回一个文件对象；
对已打开文件做读/写操作：读取文件内容可使用 read()、readline() 以及 readlines() 函数；向文件中写入内容，可以使用 write() 函数。
关闭文件：完成对文件的读/写操作之后，最后需要关闭文件，可以使用 close() 函数。

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

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

#当前程序文件同目录下没有 a.txt 文件
file = open("a.txt")
print(file)

使用 open() 打开文件时，默认采用 GBK 编码
但当要打开的文件不是 GBK 编码格式时，可以在使用 open() 函数时，手动指定打开文件的编码格式

缓冲区

常用属性

使用 open() 函数打开的文件对象，必须手动进行关闭
Python 垃圾回收机制无法自动回收打开文件所占用的资源

文本文件通常用来保存肉眼可见的字符，比如 .txt 文件、.c 文件、.dat 文件等
二进制文件通常用来保存视频、图片、音频等不可阅读的内容

按字节（字符）读取文件

如果文件是以文本模式（非二进制模式）打开的，则 read() 函数会逐个字符进行读取
如果文件以二进制模式打开，则 read() 函数会逐个字节进行读取

file.read([size])

其中，file 表示已打开的文件对象；
size 作为一个可选参数，用于指定一次最多可读取的字符（字节）个数，
如果省略，则默认一次性读取所有内容。

每次都读取目标文件中的一行。
对于读取以二进制格式打开的文件，它们会以“\n”作为读取一行的标志

file.readline([size])

readlines() 函数用于读取文件中的所有行，
它和调用不指定 size 参数的 read() 函数类似，
只不过该函数返回是一个字符串列表，
其中每个元素为文件中的一行内容

file.readlines()

其中，file 为打开的文件对象。
和 read()、readline() 函数一样，
它要求打开文件的模式必须为可读模式（包括 r、rb、r+、rb+ 4 种）。

file.write(string)

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

在写入文件完成后，一定要调用 close() 函数将打开的文件关闭，否则写入的内容不会保存到文件中

当向文件中写入数据时，如果不是文件的尾部，写入位置的原有数据不会自行向后移动，
新写入的数据会将文件中处于该位置的数据直接覆盖掉

f = open("a.txt", 'w')
f.write("写入一行新数据")
f.flush()

需要在将数据成功写入到文件中，但并不想关闭文件

将 a.txt 文件中的数据复制到其它文件中

使用 writelines() 函数向文件中写入多行数据时，不会自动给各行添加换行符

file.close()

import os
f = open("my_file.txt",'w')
#...
os.remove("my_file.txt")

import os
f = open("my_file.txt",'w')
f.close()
#...
os.remove("my_file.txt")

file.seek(offset[, whence])

其中，各个参数的含义如下：
file：表示文件对象；
whence：作为可选参数，用于指定文件指针要放置的位置，该参数的参数值有 3 个选择：0 代表文件头（默认值）、1 代表当前位置、2 代表文件尾。
offset：表示相对于 whence 位置文件指针的偏移量，正数表示向后偏移，负数表示向前偏移。例如，当whence == 0 &&offset == 3（即 seek(3,0) ），表示文件指针移动至距离文件开头处 3 个字符的位置；当whence == 1 &&offset == 5（即 seek(5,1) ），表示文件指针向后移动，移动至距离当前位置 5 个字符处。
注意，当 offset 值非 0 时，Python 要求文件必须要以二进制格式打开，否则会抛出 io.UnsupportedOperation 错误。

f = open('a.txt', 'rb')
# 判断文件指针的位置
print(f.tell())
# 读取一个字节，文件指针自动后移1个数据
print(f.read(1))
print(f.tell())
# 将文件指针从文件开头，向后移动到 5 个字符的位置
f.seek(5)
print(f.tell())
print(f.read(1))
# 将文件指针从当前位置，向后移动到 5 个字符的位置
f.seek(5, 1)
print(f.tell())
print(f.read(1))
# 将文件指针从文件结尾，向前移动到距离 2 个字符的位置
f.seek(-1, 2)
print(f.tell())
print(f.read(1))

file.tell()

f = open("a.txt",'r')
print(f.tell())
print(f.read(3))
print(f.tell())

实现任意对象与文本之间的相互转化，
也可以实现任意对象与二进制之间的相互转化

pickle.dumps()函数

pickle.loads()函数

pickle.dump()函数

pickle.load()函数

input() 函数

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

此函数会返回一个 FileInput 对象，它可以理解为是将多个指定文件合并之后的文件对象。其中，各个参数的含义如下：
files：多个文件的路径列表；
inplace：用于指定是否将标准输出的结果写回到文件，此参数默认值为 False；
backup：用于指定备份文件的扩展名；
bufsize：指定缓冲区的大小，默认为 0；
mode：打开文件的格式，默认为 r（只读格式）；
openhook：控制文件的打开方式，例如编码格式等。
注意，和 open() 函数不同，input() 函数不能指定打开文件的编码格式，
这意味着使用该函数读取的所有文件，除非以二进制方式进行读取，
否则该文件编码格式都必须和当前操作系统默认的编码格式相同，不然 Python 解释器可能会提示 UnicodeDecodeError 错误。

import fileinput
#使用for循环遍历 fileinput 对象
for line in fileinput.input(files=('my_file.txt', 'file.txt')):
# 输出读取到的内容
print(line)
# 关闭文件流
fileinput.close()

读取文件内容的次序，取决于 input() 函数中文件名的先后次序

linecache 模块常用来读取 Python 源文件中的代码，它使用的是 UTF-8 编码格式来读取文件内容

import linecache
import string
#读取string模块中第 3 行的数据
print(linecache.getline(string.__file__, 3))
# 读取普通文件的第2行
print(linecache.getline('my_file.txt', 2))

__enter__(self)：进入上下文管理器自动调用的方法，该方法会在 with as 代码块执行之前执行。如果 with 语句有 as子句，那么该方法的返回值会被赋值给 as 子句后的变量；该方法可以返回多个值，因此在 as 子句后面也可以指定多个变量（多个变量必须由“()”括起来组成元组）。
__exit__（self, exc_type, exc_value, exc_traceback）：退出上下文管理器自动调用的方法。该方法会在 with as 代码块执行之后执行。如果 with as 代码块成功执行结束，程序自动调用该方法，调用该方法的三个参数都为 None：如果 with as 代码块因为异常而中止，程序也自动调用该方法，使用 sys.exc_info 得到的异常信息将作为调用该方法的参数。

http://c.biancheng.net/view/5319.html

通过使用 with as 语句，即便最终没有关闭文件，修改文件内容的操作也能成功

子主题

import os

print (os.sep)
print (os.name)
print (os.getenv('path'))
print (os.getcwd())

 

dirs="D:\\Release\\bin"
files= os.listdir(dirs)
print files

删除目录

打印当前目录中包含homeword的文件，已经打印出绝对路径

思路：

第一步：获取当前路径路径，获取当前路径下的文件或者文件夹

第二步：循环文件，判断是否问文件，如果是文件，就判断是否包含 字符串，然后打印

import os
#coding=utf-8
'''编写程序：
1：能在当前目录下查找文件名包含指定字符串的文件
2：并打印出绝对路径
'''
sub_str="homework"
cur_dir=os.getcwd()
files=os.listdir(cur_dir)
for item in files:
print item
if os.path.isfile(os.path.join(cur_dir,item)):
if item.find(sub_str) != -1:
print (os.path.join(cur_dir,item))

 

import os
#coding:utf-8
#列出当前目录下的所有文件
dirs="D:\\Release\\bin"
if os.path.exists(dirs):
files= os.listdir(dirs)
print files
#拼接了路径
fullpath=os.path.join(dirs,files[0])
print fullpath
#判断一个路径是否是一个文件，是否目录
if os.path.isfile(fullpath):
print '我是一个文件'
elif os.path.isdir(fullpath):

from os import path
# 获取绝对路径
print(path.abspath("my_file.txt"))
# 获取共同前缀
print(path.commonprefix(['C://my_file.txt', 'C://a.txt']))
# 获取共同路径
print(path.commonpath(['http://c.biancheng.net/python/', 'http://c.biancheng.net/shell/']))
# 获取目录
print(path.dirname('C://my_file.txt'))
# 判断指定目录是否存在
print(path.exists('my_file.txt'))

from pathlib import *
# 创建PurePath，实际上使用PureWindowsPath
path = PurePath('my_file.txt')
print(type(path))

from pathlib import *
# 创建PurePath，实际上使用PureWindowsPath
path = PurePath('http:','c.biancheng.net','python')
print(path)

如果想在 Windows 系统上输出 UNIX 风格的路径字符串，就需要使用 PurePosixPath 类。例如：
纯文本复制
from pathlib import *
path = PurePosixPath('http:','c.biancheng.net','python')
print(path)

在使用 PurePath 类构造方法时，不传入任何参数，则等同于传入点‘.’（表示当前路径）作为参数。

如果传入 PurePath 构造方法中的多个参数中，包含多个根路径，则只会有最后一个根路径及后面的子路径生效

如果传给 PurePath 构造方法的参数中包含有多余的斜杠或者点（ . ，表示当前路径），会直接被忽略（ .. 不会被忽略）

对余同种风格的路径字符串来说，可以判断是否相等，也可以比较大小
（实际上就是比较字符串的大小）
from pathlib import *
# Unix风格的路径区分大小写
print(PurePosixPath('C://my_file.txt') == PurePosixPath('c://my_file.txt'))
# Windows风格的路径不区分大小写
print(PureWindowsPath('C://my_file.txt') == PureWindowsPath('c://my_file.txt'))

支持对路径的真实性进行判断

含负数

含0

3.14

314e-2/314E-2

示例：12.3 * 0.1

单引号或双引号效果一致

长字符串，连续三个单引号

原始字符串

repr()

strname = "str1" "str2"

strname = str1 + str2

字符串和数字的拼接

strname[index]

strname[start : end : step]

len（string）

encode()

split()

str.split(sep,maxsplit)

将一个字符串按照指定的分隔符切分成多个子串，这些子串会被保存到列表中（不包含分隔符），作为方法的返回值反馈回来

join()

count(）

检索指定字符串在另一字符串中出现的次数，如果检索的字符串不存在，则返回 0，否则返回出现的次数

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

find()

rfind()

index()

rindex()

ljust()

rjust()

center()

startswith()

endswith()

title()

lower()

upper()

制表符（\t）、回车符（\r）、换行符（\n）

strip()：删除字符串前后（左右两侧）的空格或特殊字符

lstrip()：删除字符串前面（左边）的空格或特殊字符

rstrip()：删除字符串后面（右边）的空格或特殊字符

Python 的 str 是不可变的（不可变的意思是指，字符串一旦形成，它所包含的字符序列就不能发生任何改变），因此这三个方法只是返回字符串前面或后面空白被删除之后的副本，并不会改变字符串本身

%

format()

str.format(args)

str 用于指定字符串的显示样式；args 用于指定要进行格式转换的项，如果有多项，之间有逗号进行分割

str 显示样式的书写格式  { [index][ : [ [fill] align] [sign] [#] [width] [.precision] [type] ] }

#以货币形式显示
print("货币形式：{:,d}".format(1000000))
#科学计数法表示
print("科学计数法：{:E}".format(1200.12))
#以十六进制表示
print("100的十六进制：{:#x}".format(100))
#输出百分比形式
print("0.01的百分比表示：{:.0%}".format(0.01))

Python 3.x 默认采用 UTF-8 编码格式

在 Python 中，有 2 种常用的字符串类型，分别为 str 和 bytes 类型
其中 str 用来表示 Unicode 字符
bytes 用来表示二进制数据
str 类型和 bytes 类型之间就需要使用 encode() 和 decode() 方法进行转换

encode()

decode()

dir()

help()

b4 = bytes('C语言中文网8岁了', encoding='UTF-8')

当函数执行完毕后，其内部定义的变量会被销毁并回收

def demo():
add = "http://c.biancheng.net/python/"
print("函数内部 add =",add)
demo()
print("函数外部 add =",add)

locals()函数

vars(object)

在函数体外定义的变量，一定是全局变量

在函数体内定义全局变量。
即使用 global 关键字对变量进行修饰后，该变量就会变为全局变量

 globals()函数

全局变量默认可以在所有函数内被访问
但是，如果当函数中定义了与全局变量同名的变量时，就会发生局部变量遮蔽（hide）全局变量的情形

name = 'Charlie'

def test ():

# 声明name是全局变量，后面的赋值语句不会重新定义局部变量

global name

# 直接访问name全局变量

print(name) # Charlie

name = '孙悟空'

test()

print(name) # 孙悟空

使用负值作为列序中各元素的索引值时，是从 -1 开始，而不是从 0 开始

sname[start : end : step]

sname：表示序列的名称；
start：表示切片的开始索引位置（包括该位置），此参数也可以不指定，会默认为 0，也就是从序列的开头进行切片；
end：表示切片的结束索引位置（不包括该位置），如果不指定，则默认为序列的长度；
step：表示在切片过程中，隔几个存储位置（包含当前位置）取一次元素，也就是说，如果 step 的值大于 1，则在进行切片去序列元素时，会“跳跃式”的取元素。如果省略设置 step 的值，则最后一个冒号就可以省略。

检查元素是否包含在序列中

not in

[element1, element2, element3, ..., elementn]

多个数据挨个存储到一起

通常同一列表中只放入同一类型的数据，这样可以提高程序的可读性

emptylist = [ ] 创建一个空列表

list()

append()

extend()

insert()

修改单个元素

修改一组元素

通过索引访问列表中的某个元素

index()

count()

pop()

clear()

remove()

del

collect()

快速初始化数字列表

指定步长
even_numbers = list(range(2,11,2))

队列

栈

deque

但小括号不是必须的，只要将各元素用逗号隔开，Python 就会将其视为元组

元组是 tuple 类型

元组是不可变序列，元组中的元素不能被修改

元组的性能速度要优于列表

tuple()

通过索引访问列表中的某个元素

是 Python 中唯一的映射类型

习惯将各元素对应的索引称为键（key），各个键对应的元素称为值（value），键及其关联的值称为“键值对”

字典特征

dictname = {'key':'value1', 'key2':'value2', ..., 'keyn':valuen}
dictname 表示字典变量名，keyn : valuen 表示各个元素的键值对

同一字典中的各个键必须唯一，不能重复

fromkeys()

dict()

dictname[key]
dictname 表示字典变量的名字，key 表示键名

get()

in 或 not in

keys()

values()

items()

setdefault()

添加键值对

copy()

update()

del

pop()

popitem()

集合会将所有元素放在一对大括号 {} 中，相邻元素之间用“,”分隔

同一集合中，只能存储不可变的数据类型，包括整形、浮点型、字符串、元组，无法存储列表、字典、集合这些可变的数据类型

另一种 frozenset 类型的集合

{}赋值

set()

for循环语句

add()

remove()

集合运算

frozenset 集合是不可变序列，程序不能改变序列中的元素

set 集合中所有能改变集合本身的方法，比如 remove()、discard()、add() 等，frozenset 都不支持；set 集合中不改变集合本身的方法，fronzenset 都支持

>>> dir(frozenset)
['copy', 'difference', 'intersection', 'isdisjoint', 'issubset', 'issuperset', 'symmetric_difference', 'union']

variable = [out_exp_res for out_exp in input_list if out_exp == 2]

out_exp_res:列表生成元素表达式，可以是有返回值的函数。
for out_exp in input_list：迭代input_list将out_exp传入out_exp_res表达式中。
if out_exp == 2：根据条件过滤哪些值可以

list3=[i for i in range(10)]
print(list3)
#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

list4=[i for i in range(0,10,2)]
print(list4) #[0, 2, 4, 6, 8]

list5=[i for i in range(0,10) if i%2==0]
print(list5)
#[0, 2, 4, 6, 8]

list5=[]
for i in range(1,3):
for j in range(3):
list5.append((i,j))

print(list5)
#[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

list6=[(i,j) for i in range(1,3) for j in range(3)]
print(list6)
#[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

multiples = [i for i in range(30) if i % 3 is 0]
print(multiples)
# Output: [0, 3, 6, 9, 12, 15, 18, 21, 24, 27]

def squared(x):
return x*x
multiples = [squared(i) for i in range(30) if i % 3 is 0]
print multiples
# Output: [0, 9, 36, 81, 144, 225, 324, 441, 576, 729]

使用()生成generator

dict1={i: i**2 for i in range(1,5)}
print(dict1) #{1: 1, 2: 4, 3: 9, 4: 16}

list1=['name', 'age','gender']
list=['Tom',20,'男']
dict2={list1[i]:list[i] for i in range(len(list1))}
print(dict2) #{'name': 'Tom', 'age': 20, 'gender': '男'}

counts={'MBP':220,'hp':123,'dell':125,'lenovo':199,'acer':99}

count1={key:value for key ,value in counts.items() if value >=200}
print(count1)
#{'MBP': 220}

mcase = {'a': 10, 'b': 34, 'A': 7, 'Z': 3}
mcase_frequency = {
k.lower(): mcase.get(k.lower(), 0) + mcase.get(k.upper(), 0)
for k in mcase.keys()
if k.lower() in ['a','b']
}
print mcase_frequency
# Output: {'a': 17, 'b': 34}

mcase = {'a': 10, 'b': 34}
mcase_frequency = {v: k for k, v in mcase.items()}
print mcase_frequency
# Output: {10: 'a', 34: 'b'}

比如，前面编写的 tortoise 表示的只是乌龟这个物种，通过它可以创建出无数个实例来代表各种不同特征的乌龟（这一过程又称为类的实例化）。

这有点像汽车图纸和汽车的关系，图纸本身（类）并不能为人们使用，通过图纸创建出的一辆辆车（对象）才能使用。

例如，tortoise 这个类中，bodyColor、footNum、weight、hasShell 都是这个类拥有的属性。

和函数所有不同的是，类方法至少要包含一个 self 参数。
例如，tortoise 类中，crawl()、eat()、sleep()、protect() 都是这个类所拥有的方法，类方法无法单独使用，只能和类的对象一起使用。

定义在各个类方法之外（包含在类中）的变量为类变量（或者类属性）
定义在类方法中的变量为实例变量（或者实例属性）

类名通用习惯为首字母大写

类是模板，而实例则是根据类创建的对象

class 类名：
多个（≥0）类属性...
多个（≥0）类方法...

class TheFirstDemo:
'''这是一个学习Python定义的第一个类'''
# 下面定义了一个类属性
add = 'http://c.biancheng.net'
# 下面定义了一个say方法
def say(self, content):
print(content)

脑图参考

用于区分不同的实例

每次在创建类后，再为实例添加属性会比较麻烦
创建实例时给类初始属性，_init__() 方法被自动调用为创建的实例增加实例属性

__init__() 方法
构造方法（或构造函数）

每个实例的共有属性

实例属性访问优先级比类属性高

类体中、所有函数之外：此范围定义的变量，称为类属性或类变量；
类体中，所有函数内部：以“self.变量名”的方式定义的变量，称为实例属性或实例变量；
类体中，所有函数内部：以“变量名=变量值”的方式定义的变量，称为局部变量

Python 类中如果有属性不希望被外部访问，我们可以在属性命名时以双下划线开头( __ )，那么该属性就不能使用原变量名访问，使得该属性变为本类私有的（伪私有）
但，如果一个属性以"__xxx__"的形式定义，那么它可以被外部访问。以"__xxx__"定义的属性在 Python 的类中是特殊属性
有很多预定义的特殊属性都是以“__xxx__”定义，所以我们不要把普通属性用"__xxx__" 定义

class Circle(object):
pi = 3.14 # 类属性

def __init__(self, r):
self.r = r

circle1 = Circle(1)
circle2 = Circle(2)
print('----未修改前-----')
print('pi=\t', Circle.pi)
print('circle1.pi=\t', circle1.pi) # 3.14
print('circle2.pi=\t', circle2.pi) # 3.14
print('----通过类名修改后-----')
Circle.pi = 3.14159 # 通过类名修改类属性，所有实例的类属性被改变
print('pi=\t', Circle.pi) # 3.14159
print('circle1.pi=\t', circle1.pi) # 3.14159
print('circle2.pi=\t', circle2.pi) # 3.14159
print('----通过circle1实例名修改后-----')
circle1.pi=3.14111 # 实际上这里是给circle1创建了一个与类属性同名的实例属性
print('pi=\t', Circle.pi) # 3.14159
print('circle1.pi=\t', circle1.pi) # 实例属性的访问优先级比类属性高，所以是3.14111
print('circle2.pi=\t', circle2.pi) # 3.14159
print('----删除circle1实例属性pi-----')

表明这个类用是来做什么

类的内部，使用 def 关键字来定义方法，与一般函数定义不同，类方法必须第一个参数为 self, self 代表的是类的实例（即你还未创建类的实例），其他参数和普通函数是完全一样

class Circle(object):
pi = 3.14 # 类属性

def __init__(self, r):
self.r = r # 实例属性

def get_area(self):
""" 圆的面积 """
# return self.r**2 * Circle.pi # 通过实例修改pi的值对面积无影响，这个pi为类属性的值
return self.r**2 * self.pi # 通过实例修改pi的值对面积我们圆的面积就会改变

circle1 = Circle(2)
print(circle1.get_area()) # 调用方法 self不需要传入参数，不要忘记方法后的括号 

class People:
def say(self):
print("我是一个人，名字是：",self.name)
class Animal:
def display(self):
print("人也是高级动物")
#同时继承 People 和 Animal 类
#其同时拥有 name 属性、say() 和 display() 方法
class Person(People, Animal):
pass
zhangsan = Person()
zhangsan.name = "张三"
zhangsan.say()
zhangsan.display()

通过给 WhoSay 类中的 say() 函数添加一个 who 参数，其内部利用传入的 who 调用 say() 方法。这意味着，当调用 WhoSay 类中的 say() 方法时，我们传给 who 参数的是哪个类的实例对象，它就会调用那个类中的 say() 方法。
 Python 这种由多态衍生出的更灵活的编程机制，又称为“鸭子模型”或“鸭子类型”

def say(self):
print("我正在学Python")
class CLanguage:
def __init__ (self):
self.name = "C语言中文网"
self.add = "http://c.biancheng.net"
clangs = CLanguage()
print(clangs.name)
print(clangs.add)
setattr(clangs,"name",say)
clangs.name(clangs)

def say(self):
print("我正在学Python")
class CLanguage:
pass
clangs = CLanguage()
setattr(clangs,"name","C语言中文网")
setattr(clangs,"say",say)
print(clangs.name)
clangs.say(clangs)

data = (20, 'fkit')
print('data是否为列表或元组: ', isinstance(data, (list, tuple))) # True
# str不是list或者tuple的子类，输出False
print('str是否为list或tuple的子类: ', issubclass(str, (list, tuple)))
# str是list或tuple或object的子类，输出True
print('str是否为list或tuple或object的子类 ', issubclass(str, (list, tuple, object)))

class A:
pass
class B:
pass
class C(A, B):
pass
print('类A的所有父类:', A.__bases__)
print('类B的所有父类:', B.__bases__)
print('类C的所有父类:', C.__bases__)

      

iter(obj[, sentinel])

其中，obj 必须是一个可迭代的容器对象，而 sentinel 作为可选参数，如果使用此参数，要求 obj 必须是一个可调用对象

可调用对象，指的是该类的实例对象可以像函数那样，直接以“对象名()”的形式被使用。通过在类中添加 __call__() 方法，就可以将该类的实例对象编程可调用对象

# 将列表转换为迭代器
myIter = iter([1, 2, 3])
# 依次获取迭代器的下一个元素
print(myIter.__next__())
print(myIter.__next__())
print(myIter.__next__())
print(myIter.__next__())

iter() 函数第 2 个参数
如果使用该参数，则要求第一个 obj 参数必须传入可调用对象（可以不支持迭代）
当使用返回的迭代器调用 __next__() 方法时，它会通过执行 obj() 调用 __call__() 方法
如果该方法的返回值和第 2 个参数值相同，则输出 StopInteration 异常；反之，则输出 __call__() 方法的返回值

class Reverse:
def __init__(self, string):
self.__string = string
self.__index = len(string)
def __iter__(self):
return self
def __next__(self):
if self.__index == 0:
raise(StopIteration)
self.__index -= 1
return self.__string[self.__index]
revstr = Reverse('Python')
for c in revstr:
print(c,end=" ")

分析一个程序的执行流程：
1) 首先，在创建有 num 生成器的前提下，通过其调用 next() 内置函数，会使 Python 解释器开始执行 intNum() 生成器函数中的代码，因此会输出“开始执行”，程序会一直执行到yield i，而此时的 i==0，因此 Python 解释器输出“0”。由于受到 yield 的影响，程序会在此处暂停。

2) 然后，我们使用 num 生成器调用 __next__() 方法，该方法的作用和 next() 函数完全相同（事实上，next() 函数的底层执行的也是 __next__() 方法），它会是程序继续执行，即输出“继续执行”，程序又会执行到yield i，此时 i==1，因此输出“1”，然后程序暂停。

3) 最后，我们使用 for 循环遍历 num 生成器，之所以能这么做，是因为 for 循环底层会不断地调用 next() 函数，使暂停的程序继续执行，因此会输出后续的结果

通过调用 next() 或者 __next__() 方法，可以实现从外界控制生成器的执行。除此之外，通过 send() 方法，还可以向生成器中传值。

值得一提的是，send() 方法可带一个参数，也可以不带任何参数（用 None 表示）。其中，当使用不带参数的 send() 方法时，它和 next() 函数的功能完全相同

虽然 send(None) 的功能是 next() 完全相同，但更推荐使用 next()，不推荐使用 send(None)

def foo():
bar_a = yield "hello"
bar_b = yield bar_a
yield bar_b
f = foo()
print(f.send(None))
print(f.send("C语言中文网"))
print(f.send("http://c.biancheng.net"))

当程序在生成器函数中遇到 yield 语句暂停运行时，此时如果调用 close() 方法，会阻止生成器函数继续执行，该函数会在程序停止运行的位置抛出 GeneratorExit 异常

def foo():
try:
yield 1
except GeneratorExit:
print('捕获到 GeneratorExit')
f = foo()
print(next(f))
f.close()

虽然通过捕获 GeneratorExit 异常，可以继续执行生成器函数中剩余的代码，带这部分代码中不能再包含 yield 语句，否则程序会抛出 RuntimeError 异常

def foo():
try:
yield 1
except GeneratorExit:
print('捕获到 GeneratorExit')
yield 2 #抛出 RuntimeError 异常
f = foo()
print(next(f))
f.close()

生成器函数一旦使用 close() 函数停止运行，后续将无法再调用 next() 函数或者 __next__() 方法启动执行，否则会抛出 StopIteration 异常

def foo():
yield "c.biancheng.net"
print("生成器停止执行")
f = foo()
print(next(f)) #输出 "c.biancheng.net"
f.close()
next(f) #原本应输出"生成器停止执行"

在生成器函数执行暂停处，抛出一个指定的异常，之后程序会继续执行生成器函数中后续的代码，直到遇到下一个 yield 语句。需要注意的是，如果到剩余代码执行完毕没有遇到下一个 yield 语句，则程序会抛出 StopIteration 异常。

def foo():
try:
yield 1
except ValueError:
print('捕获到 ValueError')
f = foo()
print(next(f))
f.throw(ValueError)

通常的for...in...循环中，in后面是一个数组，这个数组就是一个可迭代对象，类似的还有链表，字符串，文件。它可以是mylist = [1, 2, 3]，也可以是mylist = [x*x for x in range(3)]。
它的缺陷是所有数据都在内存中，如果有海量数据的话将会非常耗内存。
生成器是可以迭代的，但只可以读取它一次。因为用的时候才生成。比如 mygenerator = (x*x for x in range(3))，注意这里用到了()，它就不是数组，而上面的例子是[]。
我理解的生成器(generator)能够迭代的关键是它有一个next()方法，工作原理就是通过重复调用next()方法，直到捕获一个异常。可以用上面的mygenerator测试。
带有 yield 的函数不再是一个普通函数，而是一个生成器generator，可用于迭代，工作原理同上。
yield 是一个类似 return 的关键字，迭代一次遇到yield时就返回yield后面(右边)的值。重点是：下一次迭代时，从上一次迭代遇到的yield后面的代码(下一行)开始执行。
简要理解：yield就是 return 返回一个值，并且记住这个返回的位置，下次迭代就从这个位置后(下一行)开始。
带有yield的函数不仅仅只用于for循环中，而且可用于某个函数的参数，只要这个函数的参数允许迭代参数。比如array.extend函数，它的原型是array.extend(iterable)。
send(msg)与next()的区别在于send可以传递参数给yield表达式，这时传递的参数会作为yield表达式的值，而yield的参数是返回给调用者的值。——换句话说，就是send可以强行修改上一个yield表达式值。比如函数中有一个yield赋值，a = yield 5，第一次迭代到这里会返回5，a还没有赋值。第二次迭代时，使用.send(10)，那么，就是强行修改yield 5表达式的值为10，本来是5的，那么a=10
send(msg)与next()都有返回值，它们的返回值是当前迭代遇到yield时，yield后面表达式的值，其实就是当前迭代中yield后面的参数。
第一次调用时必须先next()或send(None)，否则会报错，send后之所以为None是因为这时候没有上一个yield(根据第8条)。可以认为，next()等同于send(None)。

函数装饰器，就是通过装饰器函数，在不修改原函数的前提下，来对函数的功能进行合理的扩充。

用 funA() 函数装饰器去装饰 funB() 函数

Python 也支持多个装饰器

语法错误，也就是解析代码时出现的错误。当代码不符合 Python 语法规则时，Python解释器在解析时就会报出 SyntaxError 语法错误，与此同时还会明确指出最早探测到错误的语句。

序在语法上都是正确的，但在运行时发生了错误

AssertionError 当 assert 关键字后的条件为假时，程序运行会停止并抛出 AssertionError 异常

AttributeError 当试图访问的对象属性不存在时抛出的异常

IndexError 索引超出序列范围会引发此异常

KeyError 字典中查找一个不存在的关键字时引发此异常

NameError 尝试访问一个未声明的变量时，引发此异常

TypeError 不同类型数据之间的无效操作

ZeroDivisionError 除法运算中除数为 0 引发此异常

通过在 try 块中判断用户的输入数据是否合理，如果不合理，程序受 raise 的影响会进行到 except 代码块，对用户的错误输出进行处理，然后会继续执行正常的业务代码；反之，如果用户输入合理，那么程序将直接执行正常的业务代码。
try except 是 Python 实现异常处理机制的核心结构

对于 try 块中可能出现的任何异常，Python 解释器都会交给仅有的这个 except 块处理
因为它的参数是 Exception，表示可以接收任何类型的异常

根据用户输入 a 和 b 值的不同，可能会导致 ValueError、ArithmeticError 异常：
如果用户输入的 a 或者 b 是其他字符，而不是数字，会发生 ValueError 异常，try 块会捕获到该类型异常，同时 Python 解释器会调用第一个 except 块处理异常；
如果用户输入的 a 和 b 是数字，但 b 的值为 0，由于在进行除法运算时除数不能为 0，因此会发生 ArithmeticError 异常，try 块会捕获该异常，同时 Python 解释器会调用第二个 except 块处理异常；
当然，程序运行过程中，还可能由于其他因素出现异常，try 块都可以捕获，同时 Python 会调用最后一个 except 块来处理。

在调试完程序后，可能并不希望所有这些日志消息出现在屏幕上，这时就可以使用 logging.disable() 函数禁用这些日志消息，从而不必进入到程序中，手工删除所有的日志调用

logging.disable() 函数的用法是，向其传入一个日志级别，它会禁止该级别以及更低级别的所有日志消息。因此，如果想要禁用所有日志，只要在程序中添加 logging.disable(logging.CRITICAL) 即可

>>> import logging
>>> logging.basicConfig(level=logging.INFO, format=' %(asctime)s - %(levelname)s - %(message)s')
>>> logging.critical('Critical error! Critical error!')
2019-09-11 14:42:14,833 - CRITICAL - Critical error! Critical error!
>>> logging.disable(logging.CRITICAL)
>>> logging.critical('Critical error! Critical error!')
>>> logging.error('Error! Error!')