python基础知识点

第一周
导入库方法：
（1）import 模块名
（2）From 模块名 import 对象
（3）From 模块名 *
注意：建议使用第二种，便于追踪溯源
函数不依赖对象
方法依赖对象

第二章
编码规范
缩进：
代表受控制语句（类似if,for，while）
续航符:\
如果语句太长时，可以使用（）或者\作为续航符
注释：”””用于多行注释，#用于当行注释

Python内置对象
在python中大多是都是内置对象，可以直接用
字符串：str
列表：list  [1,2,3]
字典:dict  {1:’123’}(1:)键，(’123’)
元组:tuple (1,-5,6)
集合:set,frozenset  {‘a’,’b’,’c’}
可迭代对象：(genertator)所有可迭代对象称为generrator
需要迭代方式输出：for i in 输出内容名字
                      print(i)
复杂的数据类型对象：函数，文件，类

常量：None==null

变量
（1）不需要事先声明变量名称与类型
（2）python采用基于值的内存管理方式，如果值相同，则内存地址相同
（3）赋值语句的过程，首先计算出值，然后找一个位置放入值，最后创建变量指向这个内存地址
（4）Python中变量不直接存储值，而是存储了值的内存地址或者引用，这也是变量类型随时可以改变的原因
（5）python允许多个变量指向同一个值
（6）python属于强类型编程语言，可以自动推断变量类型，还是一种动态类型语言，可以随时变化变量类型

命名规则：
（1）变量必须以字母或下划线开头，但以下划线开头的变量在python中有特殊含义；
（2）变量名不能有空格或者标点符号（括号，引号.....）
（3）不能以关键字为变量名称
（4）不建议使用系统内置模块名，类型名或函数名以及已导入的模块名以及其成员名，可以通过dir(_builtins_)查看内置模块名称，类型和函数
（5）变量名对英文字母大小写敏感

关键字：
 
 

运算符
 

第二周
输出输入
基本输入：
输入后的数据类型一致为字符串
例子：x=input(‘Please input’)
若要转化类型：x=int(input(‘Please input’))
多个参数输入：x,y=input(“请输入多个参数”).split(“间隔标志”)
若改为:x=eval(input(“please input”)) eval自动识别类型函数

输出基本格式：
print(value1,value2,....,sep=’’,end=’\n’,file=sys.stdout,flush=False)
sep参数前是需要输出的内容
sep参数用于指定数据之间的分隔符，默认为空格；
end:参数用于指定输出以什么为末尾，默认为”\n”，可换成其他的分隔符
flush:参数用于指定输出是否被刷新，如果flush关键字为true，流会被强制刷新

输出格式控制
使用%控制
常用的格式化控制符：
%d:整数
%s:字符串
%f:浮点数
格式：
输出字符串：print(“His name is %s”%(“name”))
输出整数：print(“he is %d”%(25))
输出浮点数：print(“his height is %.2f”%(需要输出内容))
混合输出：print(“Name:%10s  Height:%8.2f.”%(“Aviad”,1.83))

使用format语句
占位符{}，可以放索引数字，留空或者参数名称，需要占位符占位置
 
格式限定符：，填充与对齐（^,<,>分别为居中，左对齐，右对齐，后面带宽度）
 

精度与类型f:
print(‘{:^8.2f}’.format(3.131412))
表示：设置8个宽度，保留2位小数居中输出3.131412
其他类型：（b,d,o,x分别是二进制，十进制，八进制，十六进制）
 
用逗号还能作为金额千分位的分隔符
Print(‘{:,}’.format(1234567789))

range(1,n):1为首位数字，末尾数字n-1
同时可以运用到for
for i in range(n)
 操作内容
range(x,y):x为开始位置，y为结束位置

pow:pow(2,4)表示2的四次方
Split(“间隔类型”),函数可以设置多个输入时的间隔标志

数据类型
如何表示数据类型（数字--整数（int），布尔(bool)，实型(float)，复数(complex)，分数(不是内置函数，而是标准库fractions内的一个对象)）
原型法：使用标识符，注意表示能力
X=123
Y=int()
分数表示方法：x=Fraction(1,4) (需要导入模块from fractions import fraction)
Turn:表示为真（1）
False:表示为假（0）
浮点型：<实数>E<整数>、小数
复数（当成内置对象）：cmoplex(2,-7)/x=6+7j
输出：print(x.rsal,x.imag)

使用相关的运算符或内置对象实现
（1）算数运算符，逻辑运算符
（2）函数：sum....(p35页)

逻辑运算符：
and:x and y 都为ture时结果为ture否则为false，若有flash时结果就为false
or:x and y 都为false输出结果为false，否则为ture
not:not ture 输出结果为false

算术运算符：
+：
1如果出现在数字上，是相加的内容，
2如果出现在组合数据类型上，就是拼接
3不可用于组合数据类型

**
1可用于数字类型上用于算数层面
2用于其他数据类型就是表示多次输出
3不可用于字典和集合上

/and//
1算数层面表除法和求整

%
1算数层面的取余
2可用于字符串的格式化

**
数字的幂运算

关系运算
1可以连写
2可以作用于数字，组合数据类型

位运算
1只能作用于整数
2将数字转化为二进制，如何按位计算，结果按十进制输出
 

逻辑运算
1and:不一定返回ture 或false,得到的是最后一个表达式的值，x and y 都为ture时结果为ture否则为false，若有flash时结果就为false
2or:不一定返回ture 或false,得到的是最后一个表达式的值，x and y 都为false输出结果为false，否则为ture
3not:只会返回ture 或false，not ture 输出结果为false

in运算符（成员测试运算符：测试某一个对象是否在另一个对象）
1用于测试一个对象是否在另一个对象中
2用于for结合实现循环
For 变量名 in 变量：
  执行语句

is
1测试两个对象，是否为同一个（比较地址）
2常量（（地址不变）不变数据类型：整数，实数，true,false,None,字符串，分配一个固定的不变的唯一内存地址），变量（（地址会变）可变数据对象：字典，元组，列表....分配内存地址时，一个对象一个地址）

数字处理函数
（1）常用内置函数：
 
（2）内置模块（math）
 
数据类型
字符串类型
字符串描述：
字符串使用单引号，双引号，三引号界定范围，还有使用r来界定字符串
r’//’
字符串特殊的字符是转义字符
还有用字符串标识符标记的内容

转义字符
 

操作：
字符串长度测试：len(测试变量名)
字符串连接：用于同种类型对象拼接
（1）+： a+b  例子：str1+str2
（2）jion函数 a.join(b)  例子：str1.join(str)
（3）可以用*来实现一个字符的多次显示的拼接
字符串遍历：
可以使用一个变量i去遍历字符串的每一个元素，使用字符串索引进行遍历
索引有两种表示方法：
（1）正向：（从左到右）0，1，2........len()-1 例子：for i in range(0,len(x)):print(x[i],end=’ ’)
（2）反向：（从右到左）-1，-2.......-len()+1  例子：for i in 
range(-1,-len(x),-1):print(x[i],end=’ ’)
range函数：
range函数：range(start,stop,step)
Start:开始位置
stop：结束位置
Step=步长：设置每遍历一次就跳过步长，就往后到（步长）个位置

字符串切片：可以切连续，也可以切不连续，反向，正向
X[start:stop:step]
Step:表示方向与元素间的间隔
方法：x[0:len(x)-5:2]
例子：
x="12345678"
#字符串切片
print(x[0:len(x)-5:2])#13
print(x[len(x):len(x)-5:-1])#8765
print(x[-1:-len(x)+3:-1])#8765
print(x[-1:-len(x):-2])#8642
字符串内置方法：
 
 
    low改为lower()
正则表达式：
使用某些字符，描述或匹配某个句法规则的字符串
正则表达式是一个特殊的字符串序列帮助你方便的检查一个 
字符串是否与某种模式匹配。

正则表达式符号：
 

 
re模块需要import引入，提供对正则表达式支持
使用：
pattern=re.complie(“\d{3,5}”)
函数：
 
 
补充：
pattern:定义的表达式
string:需要比较的字符串)

内置函数：
type函数：查看数据类
例子：print（type（变量））
类型转化
bin（变量）：将变量转化为二进制
Oct（变量）：转换为八进制字符串
hex（变量）：转化为十六进制
(以上三个参数必须为整数)
int(变量):将变量转化为整形，参数可以为整数，实数，分数或合法数字字符串
float(变量)：将变量转化为实数，complex可以用于生成复数
complex(实部,虚部)：可以生成指定实部与虚部的复数
str()用于数字转化为字符串
filter():去除空字符串

0，””,false,none的空值都默认为false

组合数据类型    
数据类型描述
集合set
概述：
1.    无序序列 
2.    可变序列
3.    使用一对大括号作为定界符
4.    元素之间用逗号隔开
5.    同一集合内元素唯一
6.    结合包含数字，字符串，元组等不可变类型（可哈希数值）
7.    不支持索引切片

创建与删除
1.直接将集合赋值给变量即可创建一个对象
例子：
a={3,5}
2.    可以使用函数set()函数将列表，元组，字符串，range对象等其对象可迭代对象转换为集合
例子：a_set=set(range(8,10))
3.    如果原来的数据中存在重复元素，则在转化为集合的时候只保留一个
例子：a_set= {1,2,3,4,4,5,6,7}
print(a_set)
显示：
{1, 2, 3, 4, 5, 6, 7}

4.    创建空集合 
例子：x=set()
5.    元素增加
（1）使用集合对象的add()方法可以增加，如果存在重复，则忽略该操作，不会抛出异常，updata()方法用于合并另外一个集合的元素到当前集合中，并且自动去除重复元素
例子：
s={1,2,3}
print(s)
s.add(4)
print(s)
s.update({5,6,4,3})
print(s)
显示：
{1, 2, 3}
{1, 2, 3, 4}
{1, 2, 3, 4, 5, 6}
6.    元素删除
pop()随机删除并且返回集合中一个元素，集合为空则抛出异常
例子：
s={1,2,3,4,5,6,7}
print(s)
s.pop()
print(s)
显示：
{1, 2, 3, 4, 5, 6, 7}
{2, 3, 4, 5, 6, 7}

remove()删除集合中的元素，如果指定元素不存在则抛出异常
例子：
s={1,2,3,4,5,6,7}
print(s)
s.remove(5)
print(s)
显示：
{1, 2, 3, 4, 5, 6, 7}
{1, 2, 3, 4, 6, 7}
discard()从集合中删除一个特定元素，元素不在则忽略操作
例子：
x={1,2,3}
print(x)
x.discard(1)
print(x)
显示：
{1, 2, 3}
{2, 3}
clear()方法清空集合删除所有元素
例子：s={1,2,3,4,5,6,7}
print(s)
s.clear()
print(s)
显示：
{1, 2, 3, 4, 5, 6, 7}
set()
7.    集合运算
交并补
a_set=set([8,9,10,11]) 
b_set={1,2,3,7,8}
print(a_set|b_set)    #并集
print(a_set.union(b_set)) #并集
print(a_set&b_set)  #交集
print(a_set.intersection(b_set)) #交集
print(a_set.difference(b_set))#差集
print(b_set-a_set)#差集
输出：
{1, 2, 3, 7, 8, 9, 10, 11}
{1, 2, 3, 7, 8, 9, 10, 11}
{8}
{8}
{9, 10, 11}
{1, 2, 3, 7}

比较大小
x={1,2,3}
y={1,2,3}
z={1,2,3,4}
print(x<y)   #比较集合大小/包含关系 
print(x<x)   #真子集
print({1,2,3}<={1,2,3})#子集
显示：
False
False
True

列表list 
概述：1.有序序列 2.可变序列

基本操作：
创建：
a_list=[a,b,………](放在方括号内，用,隔开)，
a_list=list(“1234”)
创建空列表：a_list=[]
a_list=list()
注意：
1.    各种类型的数据都可放入list列表中
2.    可变长度对象
将其他数据转化为列表：
list((3,5))#将元组转化为列表[3,5,7,9]
list(range(1,10,2))#range 对象转化为列表[1,3,5,7,9]
删除：del 对象名
可以使用下标访问数据，也可以用负整数下标访问元素，由-1开始
注意：
1.    数据类型可以不相同，可以有基本数据类型，可以有列表，元组，
字典，集合，函数与其他任意类型对象
2.    基于自动内存管理模式，列表的元素是值的引用
3.    可以使用list(任意一种数据类型，可以转化数据对象)

函数：
 
内置函数示例：
 
  
zip函数：以最短的函数组合新的列表
map函数:map(函数，系列对象)
filter(规则，对象)：对元素过滤
enumerate(对象):把每一个元素和编号连接

内置方法：

 
 

 
-----------------------------------------------------------
 
 
-----------------------------------------------------------
 

 
-----------------------------------------------------------

 
内置方法范例：

 
sorted:内置函数，排序完，返回新的列表，就是不改变原始数据
sort:内置对象，原地排序
reverse:用于对列表反转，或者元素逆序
 
Copy()方法是引用复制，只是引用了方法的地址，复制列表中的原对象中的可变对象是复制后的列表会因为原列表数据变动而变动。
deepcopy:对原列表所有的元素都复制到新列表中，对嵌套的子列表不再复制引用，新列表与原列表相互独立，彼此不影响
 

列表推导式：
概念：可以从一个数据序列构建一个新的数据序列结构体，具有可读性，简洁，高效
语句形式：
[expression for expr1 in sequence1 if condition1
                     for expr2 in sequence2 if condition2
                      …                                                      ]
执行原理：
先对for遍历，某一个变量在范围内，看看条件是否成立，成立执行expression表达式，处理的将结果放在列表内。
列表推导式得到的是列表，一定在[]中
组成模块：
for:
expression（执行内容）:无论多少层循环都是循环同一个执行原句，执行语句只有一条。
if(可以没有):
例子：
for i in range(len(y)):
y[i]+=10
等价于：
newList=[i+10 for i in y]
可以遍历多个对象，实现矩阵转置
普通方法：
alist=[]
for x in range(10):
     alist.append(x*x)

列表推导式：
 alist=[x*x for x in range(10)]
（for循环可以有多个）

嵌套平铺：
例子：
Vec=[[1,2],[4,5],[7,8]]
[num for elem in vec for num in elem] #输出[1,2,4,5,7,8]

if实现过滤
例：
#从列表中选择符号条件的元素组成的新列表
aList=[-1,-4,6,7.5,-2.3,9,-11]
[i for i in aList if i>0]过滤出所有大于0的数字 [6,7.5,9]

遍历多个对象
[(x,y)for x in [1,2,3] for y in [3,1,4]if x!=y]
#输出
[(1,3),(1,4),(2,3),(2,1),(2,4),(3,1),(3,4)]

矩阵转置
例子：
Matrix=[[1,2,3,4],[5,6,7,8],[9,10,11,12]]
[[row[i] for row in matrix] for i in range(4)]
#输出
[[1,5,9],[2,6,10],[3,7,11],[4,8,12]]

切片：
1.格式：列表名[start:end:step]
start:开始位置，默认为0
end:切片截止位置，都是不包括这个位置
step:切片的步长，默认为1，当step为负整数表示反向切片
注意：返回indexError表示超出范围
作用：
1.    使用切片可以返回返回部分元素组成新列表
例子：
aList=[3,4,5,6,7,9,11,13,15,17]
print(aList[3:6:1])#6,7,9
2.切片操作不会因为下标抛出异常，而是简单的尾部截断，或者返回空列表，更具有健壮性
3.使用切片可以为列表增加元素
例子：
aList[:0]=[1,2]#在列表头部插入多个元素
aList[3:3]=[4]#在列表中间3位置插入元素
4可以替换修改列表元素
例子：
aList=[3,5,7]
aList[len(aList):]=[9]
aList[:0]=[1,2]
aList[3:3]=[4]
print(aList)
显示：
[1, 2, 3, 4, 5, 7, 9]
 
5可以删除元素
例子：
 
格式及其参数说明
 
 
 

 
 
 

元组tuple
概述：1.有序序列 2.不可变序列(元素不可修改)
创建：x=(1,2,3) 如果元组只有一个元素x=(3,)
特点：空元组创建：x=()   x=tuple()
 
 
如果元组中只有一个元素，一定要有逗号
很多内置函数的返回值也是包含若干元组的可迭代对象
例如：enumerate(),zip()
list(enumerate(range(5)))
[(0,0),(1,1),(2,2),(3,3),(4,4)]
list(zip(range(3),’abcdefg’))
[(0,’a’),(1,’b’),(2,’c’)]
元组与列表的异同
相同：
1.    都为有序序列，都支持双向索引访问
2.    使用count()方法统计指定元素的出现次数，index()方法获取元素方法，len(),map(),filter等大量内置函数和+,+=,in等运算符都可以使用元组和列表
不同：
1.    元组属于不可表序列，不可以直接修改元组元素的值，也无法为元组增加与删除
2.    元组没有append(),extend()和insert()等方法，无法向元组中添加元素；同样，元组没有remove()和pop方法，不支持对元组元素进行del操作，不能从元组中删除元素，而只能使用del命令删除整个元组
3.    元组支持切片操作，但只能切片访问元素，不允许切片来修改元组中元素的值，也不支持使用切片操作来为元组增加或者删除元素
4.    Python的内部实现对元组做了大量的优化，访问速度更快。如果定义一系列常量值，主要用途仅仅是对它们进行遍历或者其他类似用途，而不需要修改对其他元素进行任何操作修改，那么建议使用元组而不是列表
5.    元组在内部实现上不允许修改其元素值，从而使代码更加安全，例如调用函数时使用元组传递参数可以防止在函数中修改元素，而保证使用列表则很难保证这一点

生成器推导式
使用生成器对象的元素时，可以根据需要将其转化为列表或元组，也可以使用生成器对象的_next()_方法或者内置函数next（）进行遍历，或者直接使用for循环来遍历其中的元素。但是不管那种方法访问其元素，只能从前往后正向访问每个元素，没有任何方法可以再次访问以访问过了的元素，也不支持下标访问元素。当所有元素访问结束以后，如果需要重新访问其中元素，必须重新创建该生成器对象，enumerate，filter，map，zip等其他迭代器对象也有相同的特点
qenerator只能使用一次
例子：
 
 

字典dictionary
概述：
1.    无序序列
2.    可变序列
3.字典包含若干：“键：值”元素的无序可变序列，字典中的每个元素包含用冒号隔开的“键”和“值”两部分，表示一种对应关系。不同元素用逗号分开，所有元素放在一对大括号“{}”内。
4.字典元素的“键”可以是python不可变的数据，例如：整数，实数，复数，字符串，元组等类型可哈希数据
5.字典中的“键”不允许重复，而“值”可以重复。

创建对象：
aDict={‘server’:’gzist.edu.cn’,’database’:’mysql’}
使用内置对象创建字典
X=dict()/x={} 空字典
根据已有数据创建字典
Keys=[‘a’,’b’,’c’,’d’]
Values=[1,2,3,4]
Dictionary=dict(zip(keys,values))
根据关键参数创建字典
d=dict(name=’Dong’,age=’39’)

操作：
字典中每个元素表示一种映射或对应关系，根据提供的“键”作为下标就可以访问对应的值，不存在的键会报错
例子：
{'age': 39, 'score': [98, 97], 'name': 'Dong', 
'sex': 'male'} 
print(aDict[‘age’]) #“键”存在，返回对应“值”,输 
出39
直接访问aDict只返回key
访问key
For k in aDict.keys():
Print(k)
访问值
For k in aDict.values():
Print(k)
字典遍历（访问全部元素）：
for k,v in i.items():
   print(k,v)

字典提供一个get()方法来返回指定“键”的“值“，并且允许键不存在时，返回值为None
#增删改用下标法比较好，查的话就使用get比较好
例子：print(aDict.get(‘age’)) 
#如果字典中存在该“键”则返回对应的“值”,输出39 
print(aDict.get('address', 'Not Exists.')) 
#指定的“键”不存在时返回指定的默认值,输出'Not Exists.'
例子
 

当指定”键“为下标为字典元素赋值时，有两种含义：
（1）若”键”存在，则表示修改该“键”对应的值；
（2）若不存在，表示添加一个新的“键”：“值”对，即添加一个新的元素。
例子：
 

updata()
使用字典对象方法updata()方法可以将另一个字典的“键”：“值”一次性全部加入当前字典，如果两个字典存在相同的“键”，则以另一个字典中的“值”为准对当前字典进行更新。
aDict = {'age': 37, 'score': [98, 97], 'name': 'Dong', 'sex': 'male'}
print(aDict)
aDict.update({'a':10,'age':20})
print(aDict)
显示效果
{'age': 37, 'score': [98, 97], 'name': 'Dong', 'sex': 'male'}
{'age': 20, 'score': [98, 97], 'name': 'Dong', 'sex': 'male', 'a': 10}

删除
如果需要删除指定元素，可以使用del
例子：
aDict = {'age': 37, 'score': [98, 97], 'name': 'Dong', 'sex': 'male'}
print(aDict)
del aDict['age']
print(aDict)
显示
{'age': 37, 'score': [98, 97], 'name': 'Dong', 'sex': 'male'}
{'score': [98, 97], 'name': 'Dong', 'sex': 'male'}
可以使用pop()和popitem()方法弹出并删除指定元素
popitem()：不可指定元素，只能弹出栈顶元素，
例子：
aDict = {'age': 37, 'score': [98, 97], 'name': 'Dong', 'sex': 'male'}
print(aDict)
aDict.pop('name')
print(aDict)
aDict.popitem()
print(aDict)
显示：
{'age': 37, 'score': [98, 97], 'name': 'Dong', 'sex': 'male'}
{'age': 37, 'score': [98, 97], 'sex': 'male'}
{'age': 37, 'score': [98, 97]}

标准库操作字典
（1）OrderedDict类
Python内置字典是无序的，需要记住元素插入顺序的字典，可以使用collections.OrdereDict。
例子：
import collections
x=collections.OrderedDict()
x['a']=3
x['b']=6
x['c']=7
print(x)
显示：
OrderedDict([('a', 3), ('b', 6), ('c', 7)])
（2）defaultdict类
1.    用于产生一个带默认值的dict
2.    对于普通的dict,key不存在报错
3.    但是对于defaultdict,key不存在就会返回默认值
4.    Defaultdict（默认值类型）
例子：
from collections import  defaultdict
dict1=defaultdict(int)
print(dict1['a'])
显示：
0

其他：range  zip  map  enumerate:1.有序序列 2.不可变序列
numpy数据ndarray
pands数据类型series
pands数据类型datafrme

程序控制结构的概述
1.    数据类型和数据结构是实现对数据进行描述与表达，但实现特定的业务逻辑处理还要依赖于程序控制结构
2.    Python的程序控制结构包括顺序控制，选择结构和循环结构
3.    一个完整选择结构或循环结构控制语句可以看作是一个大当前”语句“，形成一条”组合“语句，需要通过python的相关规范格式进行控制

选择结构
条件表达式
1.在选择和循环结构中，条件表达式的值只要不是False，0（或0.0，0j等）,空值None，空列表，空元组，空集合，空字典，空字符串，空range对象或其他空的迭代对象，python解释器均认为与ture等价
2.在条件表达式一般使用关系运算符进行条件设置，使用逻辑运算符进行条件连接

（1）
Python中的关系运算符可以连续使用，这样不仅可以减少代码量，也比较符合人类的思维方式
例子：
 代码：print(1<2<3)
输出：ture
代码：print(1<2>3)

输出：False

代码：print(1<3>2)
输出：True

在python语法中，条件表达式判断是否相等不允许使用赋值运算符”=“，而是关系运算符”==“。在条件表达式中用赋值运算符”=“抛出异常，提示语法错误。
例子：
代码：if a=3:
    print('1')
显示： 
代码：if (a=3) and (b=4):
    print("1")
显示：
 
（3）逻辑运算符
1.    逻辑运算符and和or具有短路求值或惰性求职的特点，可能不会对所有表达式进行求值，
而是只计算必须计算的表达式的值
2.    以”and”为例，对于表达式”表达式1 and 表达式“而言，如果”表达式1“的值为”False“或其他等价值时，无论”表达式2“的值是什么，整个表达式的值都是”False”，丝毫不受”表达式2“影响，因此无论”表达式2“不会被计算

Python选择结构概述
用于判断在多个分区时，如何选择的判断语句

单分支选择结构
if 条件表达式：
      执行体
执行模式图例：
 
例子：
代码：
x=input("请输入指令：")
if x=='ready':
    print("开始执行")
输出：
 
双分支循环
if 表达式：
执行体1
else: 
执行体2
执行样式图：
 
例子：
代码：
id_people=input("请输入身份：")
if id_people=="学生":
    print("享受五折优惠")
else:
    print("不享受优惠")
显示：
 
python提供三元运算符，并且在三元运算符构成的表达式中还可以嵌套三元运算符，可以实现与选择结构相似效果
语法为：value2 if condition else valuse2
当条件表达式condition的值与ture等价时，表达式的值为value1，否则表达式的值为value2
例子：
a=14
b=6 if a>13 else 9
print(b)
多分支结构
多分支结构格式：
if 表达式1：
执行体1
elif 表达式2：
执行体2
.......
else:
执行体n+1
其中elif是else if缩写
执行演示图：

 
选择结构嵌套
选择结构嵌套格式：
if 表达式1：
语句块1：
if 表达式2：
语句块2
else:
        语句块3
else:
if 表达式4：
语句块
注意：缩进必须要正确并且一致
执行样式图：
 
循环结构
Python有两种形式的循环,for与while循环
1.while循环一把用于不知道循环次数的情况，但是知道循环终止条件
2.for循环一般用于循环次数可以确定情况下，适用于枚举或遍历或迭代对象中的场合
（1）while 完整语法形式：
While 条件表达式：
循环体
[else:
else子句代码块]
注;else语句可选语句，即循环条件表达式不成立或序列遍历自然结束时执行else结构中的语句
（2）for语句完整语法形式：
for 取值 in 序列或可迭代对象：
循环体
[else :
Else子句代码块]
注：else语句是可选语句，即循环条件表达式不成立或序列遍历自然结束则执行else结构中的语句

(3)    break与continue语句
1.    一旦break语句被执行，将使得break语句所属层次的循环提前结束；
2.    continue语句的作用是提前结束本次循环，忽略continue之后的所有语句，提前进入下一次循环

#pss语句
#等于空占位符号，防止if语句报错
# a=33
# b=200
# if b>a:
#     pass
 

异常概述
1.异常是python对象，当python脚本发生异常时我们需要及时捕获并获取它，否则会造成程序发生严重问题，甚至终止运行
2.python一般产生的错误有两种：语法错误和异常
3.语法错误通常时程序员在编写程序不小心出错的，编译时会报错
4.异常与语法报错无关，是一个事件，该事件会在程序执行过程报错
5.异常与语法错误无关，是一个事件，该事件会在程序执行过程中发生，影响了程序的正常执行
6.在python中，程序在执行过程中产生的错误称之为异常，比如索引异常，打开不存在文件
常见错误：
 
 异常处理：
try: 
#可能会引发异常的代码 
except Exception1: 
#处理异常类型1的代码 
except Exception2: 
#处理异常类型2的代码 
...... 
except Exceptionn: 
#处理异常类型n的代码 
else: 
#如果try子句中的代码没有引发异常，就继续执行这里的代码 
finally: 
#无论try子句中的代码是否引发异常，都会执行这里的代码

 try子句:放入的代码块是可能会引发异常的语句； 
 except子句:则用来捕捉try子句中代码的异常，按顺序依次检 
查与哪一个except子句匹配，如果某个except捕捉到了异常， 
其他的except子句将不会再尝试捕捉异常。 
 else子句:try中的代码没有引发异常，则执行else块的代码。 
 finally子句:无论try中的代码是否发生异常，也不管抛出的异 
常有没有被except语句捕获， finally子句中的代码总是会得 
到执行。

抛出异常有两种方法：
1、使用raise语句 
2、使用assert语句
使用rasise语句能触发异常
（1）raise异常类名 raise IndexError

                                           引发指定异常类的实例

（2）raise 异常类对象 index=IndexError()
                        raise index

assert语句又称作断言，指的是期望用户满足指定的条件。 
当用户定义的约束条件不满足的时候，它会触发AssertionError异常，所以assert语句可以当做条件式的raise语句。
assert语句格式如下：
 
说明：assert后面紧跟一个逻辑表达式，相当于条件。data通常是一个字符串，当条件为false时作为异常的描述信息。
 为避免文件读取的过程中产生问题，可以操作文件过程添加处理异常语句with
#平时写法：
file=open(“/tmp/foo.txt”)
try:
data=file.read()
finally:
    file.close()
#使用with代替：
with open(“/tmp/foo.txt”)as file:
data=file.read()
with语句适用于对资源进行访问的场合，确保不管使用过程中是否发生异常都会执行必要的“清理”操作，释放资源。

自定义异常
创建一个继承Exception类的子类，就是自定义异常类。
当遇到自己设定的错误时，使用raise语句抛出自定义异常

函数与模块
函数，模块，包的关系
Python项目程序由包，模块，函数组成
模块（module）：处理一类型问题的集合，由类与函数组成
包（package）：一系列模块组成的集合
函数+类=模块
函数+模块=包
函数+类+模块+包=python项目程序

函数概述
函数是可以实现某一部分功能的代码块
用用户使用的角度来看，函数可分为：
（1）系统内置函数，由系统提供，可以直接使用它们
（2）用户自定义的函数。它是用以解决用户特定问题的函数，可以实现特定功能
（3）无参函数。无参函数被调用时不需要向其传输其他数据
（4）有参函数。有参函数被调用时需要将参数传递该函数

Python需要先定义再使用
定义函数包括内容：
（1）指定函数名称，使用是按名称调用
（2）指定函数返回值
（3）指定函数参数名称，以便调用函数时向他们传递数据
（4）指定函数应完成什么操作，即函数代码功能

定义函数
 def
格式：
def 函数名称(参数列表):
函数语句
return 返回值

说明：
参数和返回值都可以省略，为函数指定参数时，参数之间用逗号隔开
例子：
def area_of_square(x):
    s=x*x
    return  s
print(area_of_square(9))
显示：
 

函数调用
调用函数格式：
函数名（参数表）
调用方法：
（1）函数调用语句
把函数单独作为作为语句
例子：
print(area_of_square(5))
显示：
 
（2）函数表达式
函数调用出现在另一个表达式中
例子：
x=area_of_square(9)
print(x)
显示：
 

嵌套调用
允许函数内部创建另一个函数，这种函数叫内置函数或者内部函数，内置函数作用域在其内部，如果内置函数的作用域超出这个范围不起作用
例子：
def functionn_1():
    print("正在执行function_1()")
    def function_2():
        print("zheng'zaifunction_2")
    function_2()
print(functionn_1())
代码：
 

函数调用—递归调用
递归属于算法范畴
递归条件
（1）调用函数自身，设置正确返回条件
（2）递归深度100层
递归危险性：消耗空间和事件，递归基于弹栈与出栈操作，递归忘返回会系统崩溃，消耗内存
例子：
def fac1(x):
    s=1
    for i in range(1,x):
        s=s*i
def face2(x):
    if x==1:
        s=1
    else:
        s=face2(x-1)*x
    return s
print(fac1(10))
显示：
 

函数参数
在python中对函数参数没有限制，参数之间使用逗号隔开定义参数不宜太多，一般2~5个，定义函数需要注释清楚，便于阅读程序。
形参：函数定义小括号部分中的参数
实参：是指函数被调用过程指定的具有实际意义的参数

函数参数的使用方式：
（1）位置参数：调用时按位置直接传入，如果有多个参数，实参位置与形参要一致
（2）关键字参数：调用时使用形参名字直接赋值，可不考虑位置
（3）默认值参数：在定义时对形参赋值，调用时不传递就直接使用原形参中设置的值，传递就使用新值
（4）可变参数（不定长）
示例：
（1）位置参数：
def Sub(x,y):
    return x-y
print(Sub(100,30))
print(Sub(30,100
显示：
 
关键字参数：
def Subtraction(num_1,num_2):
    return (num_1-num_2)
print(Subtraction(34,11))
print(Subtraction(11,34))
print(Subtraction(num_1=34,num_2=11))
显示：
 
默认值参数：
def Subtraction(num_1=99,num_2=45):
    return (num_1-num_2)
print(Subtraction())
print(Subtraction(num_1=46))
print(Subtraction(num_1=46,num_2=12))
显示：
 
可变参数：是将一个元组或字典赋值给可变参数
函数定义：
 def fun(*args,**kwargs):
函数体语句
（1）*的作用：收集实参中所有未匹配的位置参数组成一个tuple对象，局部变量args指向tuple对象
（2）**参数作用：收集实参中所有未匹配的关键字参数组成一个dict对象，局部变量kwargs指向dict对象
例子：
def fun(age,name='11',*p2,**p3):
    print(age)
    print(name)
    print('元组可变参数的长度是：',len(p2))
    for i in p2:
        print(i)
        print('字典可变长度是：',len(p3))
    for k,v in p3.items():
        print(k,v)
fun(1,'张三',2,4,a=1,b=2)#2，4传入p2，a,b传入**p3
显示：
 
注意事项：
（1）函数定义时，二者同时存在，需要将*args放在**kargs前
（2）可变函数，可以接受数量不定的参数，可以是0~多个参数
（3）可变参数，必须定义位置参数。默认值参数的后面，这是因为可变参数会收集未匹配的参数，如果定义在前面，那么位置参数和默认值参数无法传入的参数（因为会被收集到可变参数中了.....）
（4）调用包含*args参数的函数时，需要传入一个tuple对象，我们可以将tuple对象的元素使用元组解包语法传入，解包语法：*tuple
（5）调用**args参数的函数时，同样不要直接传入一个字典对象，因为一个字典对象只算一个参数。字典对象可以使用字典解包语法，解包语法：**dict
匿名函数：
特点：
（1）lambda只是一个表达式，函数体比def简单很多
（2）lambda函数能接受任何数量的参数但只能返回一个表达式的值
（3）匿名函数不能只是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数
（4）lambda函数的语法：
lambda [arg1,[arg2,arg3,......]]：expression

作用
（1）命名使用
lambda可以看作是定义函数的一个简单方法，可以给一个名称，像一样使用
（例子）
代码：
lambda_add_tem=lambda x:x+10
print(lambda_add_tem(5))
显示：
 
（2）与高阶函数配合
可以将lambda函数与map（），filter（）和reduce（）一起使用，优化程序
（例子）
代码：
numbers = [1, 12, 37, 43, 51, 62, 83, 43, 90, 2020]
print(list(filter(lambda x:x%2==1,numbers)))
print(list(map(lambda x:-x,numbers)))
显示：
 
（3）赋予“key”参数
一些内置方法有关键参数，使用sorted（）或sort（）方法对Python中的迭代继续排序时，关键参数决定如何比较迭代中的两个元素
（例子）
代码：
leaders1 = ["Warren Buffett", "Yang Zhou", "Tim Cook", "Elong Musk"]
leaders1.sort(key=lambda x:len(x))
print(leaders1)
leaders2 = {4: "Yang Zhou", 2: "Elon Musk", 3: "Tim Cook", 1: "Warren Buffett"}
leaders2=dict(sorted(leaders2.items(),key=lambda x:x[0]))
print(leaders2)
显示：
 
（4）闭包使用（嵌套定义函数）
闭包是一个功能强大的函数式编程特性，在Python中也可以使用。因为它是关于嵌套函数的，所以我们可以使用lambda函数来使程序更加清晰
（例子）
代码：
def outer_func():
    leader="Yang Zhou"
    return lambda location:leader+" in the "+location
print(outer_func()("UK"))
显示：
 

变量作用域
作用域分类：
（1）变量作用域是值变量的可使用范围，也称为变量的命名空间，在第一次给变量赋值时python创建变量，变量创建的位置决定了变量的作用域
（2）Python的变量的作用域可分为三种：内置作用域，文件作用域和本地作用 
（3）本地作用域：函数体作为本地作用域。函数内通过赋值创建的变量，函数参数都属于本地作用域。
（4）文件作用域：程序文件的内部为文件作用域
（5）内置作用域：python运行时的环境为内置作用域，包含了python的各种定义变量和函数
（6）内置作用域和文件作用域可称为全局作用域
例子：
import math
y=10#文件（模块作用域）
def fac(x):
    return x*y*math.pi#内置作用域
def fac2(x,y,z):#本地作用域
    return x+y+z

全局变量与局部变量
（1）根据作用域范围，通常将变量分为两种：全局变量和本地变量
（2）根据作用域的范围大小，作用域外部的变量和函数可以作用在作用域内使用
（3）作用域内变量和函数不能在作用域外使用
（4）在内置作用域和文件作用域中定义的变量和函数都属于全局变量
（5）在本地作用域内定义的变量都属于本地变量，本地变量也称为全局变量
例子：
a=10#全局变量
def add(b):#add是全局变量
    c=a+b#c是add的本地变量，a是函数外的全局变量
    return c
print(add(5))
该程序概述
全局变量：a,add
局部（本地）变量：b,c

global函数
函数内golbal声明全局变量，可以在在后面语句修改全局变量a
例子：
a=10#声明全局变量
def show():
    global a#函数内声明全局变量
    print("a=",a)
    a=100
    print("a=",a)
show()
显示：
 
注意：如果变量为组合数据类型且在函数内部未创建而直接调用，则等同于全局变量

nonlpcal 
如果要嵌套函数使用外层函数本地变量，并为其赋值，python提供了nonlocal语句与global语句不同，它声明变量是外层函数的本地变量
例子：
def test():
    a=10
    print("in test(),a=",a)
    def show():
        nonlocal a
        a=100
        print("in show(),a=",a)
    show()
    print("in test(),a=",a)
test()

显示：
 

模块与包应用
作用：
（1）有逻辑的组织python代码段
（2）相关的代码分配到一个模块中更好用，更易懂
（3）能定义函数，类和变量，也能包含可执行的代码

包
（1）大型系统通常会根据代码功能将模块文件放在多个目录中，在导入位于目录中的模块文件时，需要指定目录路径，python将存放模块文件的目录称之为包
（2）包就是一个完成特定任务的工具箱。Python提供了许多自带工具包可以直接供程序员直接使用，提高开发效率，达到代码重用效果，自带工具包和模块放置在python安装目录下的lib子目录中
（3）lib目录的xml文件夹就是一个包，用于xml开发，文件_init_.py是xml包的注册文件
（4）包也是一个文件夹，文件夹必须至少包含一个_init_.py文件，_init_py文件的内容可以为空，它用于识别当前文件夹就是一个包
（5）模块需要先导入，然后才能使用其中的变量，函数或者类等
（6）在导入模块时，python会执行下列三个步骤：
（1）按特定路径搜索模块文件
（2）找模块后根据文件时间戳情况，必要时修改编译模块
（3）执行模块的字节码文件

导入模块
可使用import或from语句带入模块，格式
Import 模块名称
import 模块名称 as 新名称
from 模块名称 import 导入对象名称
from 模块名称 import 导入对象名称 as 新名称
from 模块名称 import*
例子:
import math
print(math.fabs(-5))
print(math.e)

自定义模块：
用户编写的函数，为了共享给大家使用，可以做成模块并发布
首先，创建模块文件test.py代码如下
x=100
print(x)
print("这是模块test.py输出的")
def show():
    print('这是模块test.py中的show（）函数中的输出')
放在同一路径下，导入模块使用
代码：
import test
print(test.x)
test.x=200
import test
print(test.x)

导入自定义模块使用时，如果原模块文件内容被修改，可以使用：from importlib impot reload
 reload(模块名)     重新导入使用

文件及数据组织
文件操作
文件类型分为：文本文件和二进制文件
文本文件根据字符编码保存文本：ASCII，UTF_8,GB2312，    
二进制文件可以保存照片，音频和视频，各自编码不同，二进制文件格式写文件中的数据

对于文件的操作：
内容操作：写，读
文件操作：打开文件，关闭文件，删除文件，重命名文件，查看当前目录下文件

文件打开操作流程
打开文件-------------->操作文件------------->关闭并保存文件

文件打开命令
 open(文件名，访问模式)
“文件名”：必须填写
“访问模式”：选填
r:只读，默认值，不创建，不存在报错
w:只写，创建新文件，若文件存在，则原文件被覆盖
a:追加，文件存在，在末尾添加数据，不存在创建文件
x:只写模式，创建新文件，若文件存在，则报错
t:按文本格式读写文件，默认方式
b:按二进制格式读写文件数据
+:组合读写模式，同时进行读，写操作
“t”,”b”和”r”，“w”，“a”，“x”可组合使用
“+”必须和“r”，“w”，“a”组合使用
r+读写模式
打开文件之后光标位置位于0的位置
根据光标位置读写
w+写读模式
会清空文件
打开文件之后光标位置位于0的位置
根据光标位置读写
a+追加模式
不会清空
打开文件之后自动将光标至于最后，而光标位置只会影响读操作
每一次追加都会将光标置于最后

按文本格式读取文件
myfile=open('D:\opject.txt','rt')
print(myfile.readline())
myfile.close()
按文本文件格式读取数据时，python会根据字符编码将数据解码为字符串，将数据转化为有意义的数据

按照二进制文件格式读取文件读取文件数据
代码：
f1=open('D:\\two.png','rb')
img_bin=f1.read()
f2=open('D:\\two_1.png','wb')
f2.write(img_bin)
f1.close()
f2.close()
按照二进制文件格式读取数据时，数据为字节流，python不执行解码操作，读取的数据为bytes字符串，并按照bytes字符串格式输出

文件关闭
代码：myfile.close()
通常，python会使用内存缓冲区缓存文件数据
关闭文件时，python将缓冲区的数据写入文件，然后关闭文件，释放对文件的引用
程序结束时，python可自动关闭未使用的文件
 flush()方法可将缓冲区文件内容写入我呢见，但不关闭文件
代码：myfile.flush()

文件读写
写文件
向文件写数据，需要使用write方法来完成，在操作某个文件时，每次调用一次write方法，写入的数据就会追加到文件末尾
f=open('itheima.txt','w')
f.write('hellow itheima,i am here!')
f.close()

读文件
使用read方法读取文件
f=open('itheima.txt','r')
content=f.read(12)
print(content)
print("--"*30)
content=f.read()
print(content)
f.close()

方式2：使用readlines方法读取文件
f=open('itheima.txt','r')
content=f.readlines()
i=1
for temp in content:
    print("%d:%s"%(i,temp))
    i+=1
f.close()

方式3：使用readline方法一行一行读数据
f=open('itheima.txt','r')
content=f.readlines()
print("1:%s"%content)
content=f.readline()
print("2:%s"%content)
f.close()

文件读写
文件指针tell
tell()方法返回文件的当前位置，即文件指针当前位置
f=open('itheima.txt','r')
str1=f.read(4)
print('读取的数据是',str1)
position=f.tell()
print('当前文件位置：',position)

方法2：
使用seek()方法来获取文件当前读写位置
seek(offset，from)方法包含两个参数：
-offset:表示偏移量，也就是代表需要移动偏移的字节数
-from：表示方向，可以指定从那个位置开始偏移
0：表示文件开头（默认量）
1：表示当前位置
2：表示文件末尾
例子：
fo=open("itheima.txt","r")#打开文件
print("文件名为：%s"%fo.name)#获取文件名
line=fo.readline()#获取文件数据
print("读取数据为:%s"%line)
fo.seek(0,0)#获取文件数据
line=fo.readline()
print("读取数据为：%s"%(line))
fo.close()

文件重命名
os模块中的rename()方法可以完成文件重命名
格式：rename(修改文件名称，新的文件名)
例子：
# os.rename("itheima.txt","newittheima.txt")#重写文件名称

文件删除
os模块中的remove()方法可以完成文件的删除操作
格式：remove(待删除的文件名称)
# import os
# os.remove("newittheima.txt")#删除文件

文件其他操作
 

目录操作
创建目录
文件用os模块创建目录与os.path实现
例子：# os.mkdir("张三")

获取当前目录
例子：
os.getcwd()

修改默认目录
例子：
os.chdir("../")

获取目录列表
例子：
os.listdir("./")

删除目录
os.rmdir("张三")

目录操作
os.path

数据操作
主要针对csv文件
csv:即逗号分隔的数据，分隔符号可以为逗号，空格，制表符或其他字符

读取csv文件
先导入csv模块

1.    常规读取器
读取文件前先导入模块，打开文件
格式：csvfile=csv.reader(文件名称，[分隔号，编码格式])
返回一个可迭代的常规读取器对象，使用for循环或next函数迭代常规读取器对象
例子：
import csv
csvfile=open("it.csv")
cr=csv.reader(csvfile)
for row in cr:
    print(row)
csvfile.seek(0)#将文件表头指针移动到文件开头
next(cr)#使用next（）函数读取csv文件
csvfile.close()

使用字典读取器
在读取csv数据前，先导入模块打开文件
常规读取器读数据语句格式：
csv=csv.DictReader(文件名称，[分隔，编码格式])
返回一个可迭代的字典读取器对象，包含csv文件的第一行作为文件的名称（键），从第二行开始的数据作为键的映射的值，可以使用for或next函数迭代常规读取器对象

例子：
csvfile=open("it.csv")
cr=csv.DictReader(csvfile)
for row in cr:
    print(row)
for row in cr:
    print(row["字段1"],row["字段2"],row["字段3"])
csvfile.seek(0)
next(cr)#使用next()函数读取文件
csvfile.close()

1.    使用常规对象写文件
在读取csv数据前，需要先导入模块及打开文件
格式：csvwriter=csv.writer(文件名称)
返回一个引用写对象
Csvwiter.writerow(data)x
写入一行数据，会在每一行数据末尾添加换行符号
例子：
csvfile=open("it.csv",'w')
# csvwriter=csv.DictWriter(csvfile,fieldnames=['id','name','sex'])
# csvwriter.writeheader()
# csvwriter.writerow({'id':'202010244','name':'张三','sex':'男'})
# csvfile.close()

面向对象
概述：
（1）是在程序中使用角色来映射问题涉及事物，为不同对象定义不同方法和数学，来描述个子所有的属性与行为
（2）面向对象编程两个重要概念：类与对象
类（Class）：用来描述具有相同属性和方法的对象的集合
对象：类的实例，有类的属性与方法
属性：类中定义的变量，用于描述类
方法：类中定义的方法，描述类的行为
封装：是对类进行封装，外界无法访问
继承：生成一个子类，继承父类的方法与属性
多态：不同类型对象相同行为具有相同结果
方法重写：对父类计息重写，将父类方法覆盖

类的定义
格式：class 类名 (基类名称):
类的属性
类的方法
示例：
class Person(object):
    count=0
    def __init__(self,name="",sex="男",age=20):#设置类的属性
        self.name=name
        self.sex=sex
        self.age=age
    def show(self):#实例方法
        Person.count=Person.count+1
        print("{},这是第{}个对象".format(self.name,Person.count))

类的实例化
格式：
对象名=类名（）
对象创建后可以使用’.’来访问属性与方法
格式：
对象名.类属性
对象名.方法（参数）
添加属性
对象名.新属性名称=值
注意:定义后的对象需要设置参数，要不会报错
例子：
P0=Person()
P1=Person("张三","男")
P1.show()
类属性与实例属性
类属性在类函数外定义的，类属性属于类，是列所有实例共享
实例属性通常子啊构造函数中计息定义并初始化，属于具体实例对象

类属性和实例属性的访问区别:
（1）在类的成员函数中：通过 类名. 的方式，访问类属性；通过“self.”的方法访问类属性
（2）在类外部：通过”类名.”的方式，访问类属性，也可以通过”实例对象.”的方式访问类对象；访问实例属性，只能通过“实例对象.”的方法
（3）无论是类对象或是实例对象，都可以在类外部，通过类名和实例对象增加
例子：
class Person(object):
    count=0
    def __init__(self,name,sex="男",age=20):#设置类的属性
        self.name=name
        self.sex=sex
        self.age=age
        Person.count+=1#类属性内部访问
        print("创建了{}对象".format(self.name))#实例化内部对象
    def get_stu(self):#实例方法
        return "人员信息：姓名:{},性别:{},年龄:{}".format(self.name,self.sex,self.age)
    def show(self):#实例方法
        Person.count=Person.count+1
        print("{},这是第{}个对象".format(self.name,Person.count))
if __name__=='__main__':#main方法
    p1=Person("张三","男",21)
    print(p1.get_stu())
    p2=Person("李四")
    p2.sex="女"#实例属性外部访问
    p2.age=22
    print(p2.get_stu())
    print("目前人数",Person.count)#实例属性外部访问

特殊属性：
Python会为类对象添加一系列类的特殊属性：
（1）__name__:返回类的名称
（2）__module__:返回类所在模块
（3）__class__:返回类对象的类型名称，与type函数返回结果相同
伪私有属性：
（1）除特殊属性外
（2）双下划开头，不以双下滑结束命名的对象
（3）类外部不能直接访问

类的方法：
实例方法：
（1）公有实例方法（与公有实例属性相似）
（2）私有实例方法（与私有化实例属性类似）
（3）相同特殊方法（系统设置）
（4）抽象方法(为类的特性——继承而设置)
类方法
静态方法

实例方法
所有实例方法都必须至少有一个名为self参数，并且必须是方法的第一个形参，self参数代表当前对象
实例方法是第一个参数通常用”self”表示，表示实例对象
实例方法中：既可以通过”self.”的方式，访问实例成员，也可以通过”类名.”的方式，访问类成员
在类的外部：实例方法只能通过实例对象进行调用

系统特殊方法：
__new__(cls[,argl,.....])：
函数体
(1)    __new__是python类的系统内置方法，自动调用，实现类的实例对象的创建及返，并将该实例交给__init__方法去初始化
(2)    第一个参数是cls，其他参数（来自类的实例化括号参数）直接传递给__init__方法
(3)    __new__平时很少去重写它，一般让python用默认的方案指向
(4)    重写__new__一定要有return语句

__init__(self[,argl,...]):
函数体
（1）__init__python类系统内置方法，被称为类的构造函数或初始化方法。当创建类的构造函数或初始化方法。当创建类的实例时，系统自动调用该方法，对实例属性进行初始化，self表示实例对象本身，argl.....通常用来初始化实例属性
（2）__init__(self[,argl,......])方法可重载，以实现实例对象的多种初始化方法
（3）用户没有显示定义__init__方法时，则系统自动调用缺省的构造函数，创建实例对象
例子：
class Car:
    def __init__(self,color):
        self.color=color
    def toot(self):
        print("{}的车在鸣笛....".format(self.color))
if __name__=="__main__":
    car1=Car("红色")
    car1.toot()

__del__析构方法
当对象不需要使用时，通过del函数删除该对象来释放类所占用资源，python解释器默认会调用另外一个方法，这个方法就是__del__（）方法
__del__方法被称为析构方法，格式如下：
__del__(self):
函数体
说明：如果用户没有显式定义析构函数，则系统自动调用缺省的析构函数

抽象方法：
抽象方法一般在抽象类中定义，并且要求在派生类中重新实现，否则不允许派生类创建实例
在python3中引入abc模块，通过@abc.abstractmethod可以更加简洁的使用抽象类，抽象方法

静态方法与类方法
静态方法和类方法不能直接访问属于对象的成员，只能访问属于类的成员，但都可以通过类名和对象名称调用
静态方法和类方法不属于任何实例，不会绑定任何实例

类方法
类方法是类拥有的方法，需要用修饰器”@classmethod”来标识其类方法
类方法的第一个参数通常用”cls”表示，表示类对象
类方法中：只能通过“类名.”的方式，访问类成员
在类的外部:类方法可以通过类名和实例对象进行调用
例子：
class Root:
    __total=0
    def __init__(self,v):#构造方法
        self.__value=v
        Root.__total+=1
    @classmethod #在这里使用@classmethod修饰器，声明类方法
    def classShowTotal(cls): #类方法
            print(cls.__total)
r=Root(3)
rr=Root(5)
rrr=Root(7)
r.classShowTotal()#通过对象来调用类方法
Root.classShowTotal()#通过类名调用类方法

静态方法
（1）使用修饰器@staticmethod来标识静态方法
（2）静态方法是没有self参数，在静态方法中无法访问实例变量
（3）静态方法中不可以直接访问类属性，但是可以通过类名引用类属性
（4）静态方法跟定义它的类没有直接关系，只是想到类似函数的作用

类的封装
在python中，公有属性和方法，通过（.）操做符来访问
为了保护类里面的属性可采用以下方式：
（1）把属性定义为私有属性，即在属性名称钱加下滑线
（2）添加用于设置或获取属性值的方法，供外界调用
注意：python中不存在严格意义上的私有成员
_XXX:受保护成员，只有类对象，子类对象可以访问，在类外部不建议直接使用，不能用from module import *导入
__XX__:系统定义的特殊成员
__XXX:私有成员，只有类对象自己能访问，子类对象不能直接访问，但在对象外部可以通过
“对象名._类名_XXX”这样的特殊方式来访问
例子：
class Person():
    count=0#类属性
    def __init__(self,name='',sex='男',age=20):#self就代表实例本身
        self.name=name  #实例属性（name,sex,sge）
        self.sex=sex
        self.__age=age  #设置私有属性的目的是为了实现类的封装，类的外部不能直接访问，可以通过调用私有属性对应set方法
    #类的封装（私有属性通过设置对应的set与get方法供外部访问）
    #方法一：
    #相当于get方法（私有属性）
    @property
    def age(self):
        return self.__age
    #相当于get方法（私有属性）
    @age.setter
    def age(self,age):
        if (age<=0 or age>150):
            self.__age="不详"
            print("年龄有误")
        else:
            self.__age=age
    #方法二
    def getAge(self):
        return self.__age

    #相当于set方法（私有属性）
    def setAge(self,age):
        if (age<=0 or age>150):
            self.__age="不详"
            print("年龄有误")
        else:
            self.__age=age
    def get_stu(self):
        return "人员信息：姓名：{}，性别：{}，年龄：{}".format(self.name,self.sex,self.__age)#私有实例属性内部可以访问
if __name__=="__main__":
    p1=Person("张三")
    p2=Person("李四")
    p1.setAge(25)#私有实例属性调用方法一的set方法设置值
    p2.setAge=222#访问私有实例属性调用方法调用set方法设置值
    print("姓名",p1.name,"年龄",p1.getAge())#私有实例属性调用方法一的get方法获取值
    print("姓名", p2.name, "年龄", p1.age)#私有实例属性调用方法二的get方法获取值

类的继承
概述：
（1）继承时实现代码复用和设计复用的机制
（2）继承关系中，需要设计好父类与基类，新设计的类为子类或派生类，派生类继承父类的公有成员，但是不能继承其私有成员，派生类，调用基类方法，可使用内置函数super()或者通过”基类名称.方法名（）”来调用
（3）python支持多继承，如果父类中有相同名字，而子类没有指定父类名，则python解释器按顺序从左往右按顺序进行搜索

语法：
Class className(BaseClassName):
.......
className:子类名称，第一个字母需要大写
BaseClassName:父类名称
被继承的类称为父类，基类和超类，而继承者我们称为子类，子类可以继承父类任何属性和方法
例子：
class Animal():#基类
    name='animal'
class Cat(Animal):#子类
    kind="猫"
class BingCat(Cat):#孙子类
    height=20
bigcat=BingCat#创建
bigcat.name="小猫"#访问父类内容
bigcat.kind="cat"
bigcat.height=15

单继承
Python程序中，继承使用格式：
  class 子类名（父类名）：
例子：
class A(object):
Pass
class B(A):
Pass
默认继承object
例子：
import  abc#导入abc模块，目的实现抽象方法
class Animal(object):#定义基类
    def __init__(self,name="",food=""):
        self.name=name
        self.food=food
    @abc.abstractmethod #抽象方法
    def eat(self):
        pass
#创建派生类（子类）Cat,继承基类Animal的初始化方法，eat抽象方法重写他们，同时新建show()方法
class Cat(Animal):
    def __init__(self,name='',food='',age=''):
        super().__init__(name,food)
        self.__age=age
    def show(self):
        print("我是{},今年{}岁，喜欢吃{}".format(self.name,self.__age,self.eat()))
    def eat(self):
        return self.food
# 创建派生类（子类）Dog，继承了基类Animal的初始化方法，eat抽象方法重写它们，同时新建show（）方法
class Dog(Animal):
    def __init__(self,name="",food="",age=""):
        super().__init__(name,food)
        self.__age=age
    def show(self):
        print("我是{},今年{}岁，喜欢吃{}".format(self.name, self.__age, self.eat()))
    def eat(self):
        return self.food 

多继承
多继承可以看做是单继承的扩展，语法格式
 class 子类名(父类1，父类2.....):
如果子类继承的多个父类是平行关系，子类先继承那个类就会先调用那个方法
例子：
class bird():
    print("我会飞")
class fish():
    print("我会游泳")
class flybird(bird,fish):
      name="飞鸟"
      heiht=20
if __name__=="__main__":
    fb=flybird()
类多态
概述：
（1）基于同一个方法再不同派生对象具有不同的表现和行为，基于基类派生对象属性后会增加某些特定行为和属性，同时还可能会对继承来的某些行为进行改变，这就是多态的表现形式
（2）Python大多数运算可以作用与多种不同类型的操作数，并且对于不同类型的操作往往有不同表现，这本身是对象的多态，是通过特殊方法与运算符重载实线
（3）python定义函数时，不需要指定参数类型
（4）python使用多态不需要太过显式强调
例子：
class Animal(object):
    def show(self):
        print("I am an animal")
class Cat(Animal):
    def show(self):
        print("I am an cat")
class Dog(Animal):
    def show(self):
        print("I am an Dog")
class Tiger(Animal):
    def show(self):
        print("I am an tiger")
x=[item() for item in (Animal,Cat,Dog,Tiger)]
for item in x:
    item.show(

迭代器
Python迭代器
迭代器是一种对象，对象包含值的可计数数字
迭代器可迭代的对象，这意味这可以遍历所有值
在python中，迭代器是实现迭代器的对象，方法包含__iter__()和__next__()

迭代器与迭代器对象（lierable）
列表，元组，字典和集合都是可迭代对象，他们是可迭代的容器，可以从(Iterator)
所有这些对象都用与获取迭代器（iter()）方法

python标准库
（1）turtle库
turtle库提供了简单、直观的绘图方法，Python接纳了turtle库，并将其作为标准库提供给用户。
turtle库在图形窗口中完成绘画为一个坐标系
 
在用turtle绘画时，画笔的第一笔落笔点默认是在画布中心，画笔朝东（向右）。 turtle库通过画笔在画布中的移动完成绘图。

窗口控制函数
1、turtle.bye() ：关闭绘图窗口
2、turtle.exitonclick()：单击时关闭绘图窗口
3、turtle.setup(width, height, startx, starty)
设置绘图主窗口的大小和位置。各参数作用如下。
width：整数表示窗口宽度为多少像素；浮点数表示窗口宽度占屏幕的百分比（默认50%）。
height：整数表示窗口高度为多少像素；浮点数表示窗口高度占屏幕的百分比（默认75%）。
startx：正数表示窗口位置距离屏幕左边缘多少像素，负数表示距离屏幕右边缘的像素数，None（默认值）表示窗口水平居中。
starty：正数表示窗口位置距离屏幕上边缘多少像素，负数表示距离屏幕下边缘的像素数，None（默认值）表示窗口垂直居中
4、turtle.screensize(canvwidth, canvheight, bg)
设置绘图窗口中画布的大小，无参数时返回画布大小。各参数的作用如下。
canvwidth：正整型数，以像素表示画布的新宽度值。
canvheight：正整型数，以像素表示画面的新高度值。
bg：颜色字符串，新的背景颜色。
turtle库中使用的颜色有3种表示方法。
颜色名称字符串：red、blue、yellow等。
十六进制颜色值字符串：#FF0000、#00FF00、#FFFF00等。
RGB颜色元组：
颜色元组格式为(r,g,b)，r、g、b的取值为1或255。
颜色模式为255：(255,0,0)、(0,210,0)、(155,215,0)等是有效的颜色元组
颜色模式为1时：(1,0,0)、(0,0.3,0)、(1,0.5,0)等是有效的颜色元组。
5、turtle.bgcolor(*args)
设置背景颜色，无参数时返回当前背景颜色。
参数args是一个颜色字符串或颜色元组，或者是3个取值范围为0~colormode内的数值（即省略圆括号的颜色元组）。
6、turtle.bgpic(picname=None)
设置背景图片或返回当前背景图片名称。
如果picname为一个以gif或png为后缀名的图片文件名，则将相应图片设为背景。
如果picname为“nopic”，则删除当前背景图片。
未提供参数时返回当前背景图片文件名。
7、turtle.clear()和turtle.clearscreen()
从绘图窗口中删除全部绘图，将绘图窗口重置为初始状态：
白色背景
无背景图片
无事件绑定并启用追踪。
8、turtle.reset()和turtle.resetscreen()
将绘图窗口中的画笔重置为初始状态，示例代码如下。
    turtle.reset()
    turtle.resetscreen()
9、turtle.window_height()和turtle.window_width()
返回绘图窗口的高度和高度，示例代码如下。
turtle.window_height()        
turtle.window_width()

画笔控制函数
1、turtle.pendown()、turtle.pd()和turtle.down()
画笔落下，移动画笔时画线，示例代码如下。
   turtle.pendown()
2、turtle.penup()、turtle.pu()和turtle.up()
画笔抬起，移动画笔时不画线，示例代码如下。
   turtle.penup()
3、turtle.pensize(width=None)和turtle.width(width=None)
参数with为一个正数。
提供参数with时，将其设置为画笔大小，画笔大小决定线条粗细。
如未指定参数，则返回画笔的当前大小。
示例代码如下。
   turtle.pensize()
   turtle.pensize(5)
4、turtle.pen(pen=None, **pendict)
提供参数时设置画笔属性；未指定参数时返回画笔属性。
参数pen为字典，pendict为一个或多个关键字参数，可用的关键字及其取值如下。
shown：值为True（显示画笔形状）或False（不显示画笔形状）。
pendown：值为True（画笔落下）或False（画笔抬起）。
pencolor：值为颜色字符串或颜色元组，用于设置画笔颜色。
fillcolor：值为颜色字符串或颜色元组，用于设置填充颜色。
pensize：值为正数，用于设置画笔大小。
speed：值为0～10范围内的数，用于设置绘图速度。
resizemode：值为“auto”“user”或“noresize”，用于设置绘图窗口大小调整模式。
stretchfactor：值为“(正数值,正数值)”格式的元组，用于设置画笔裁剪比例。
outline：值为正数，用于设置轮廓宽度。
tilt：值为整数或小数，用于设置画笔倾斜角度。
示例代码如下。
  turtle.pen(fillcolor="yellow", pensize=5)       #设置关键字参数
  turtle.pen({'shown':False,'tilt':15})    #使用字典参数
  turtle.pen()   #返回画笔属性
5、turtle.isdown()
画笔落下时返回True，画笔抬起时返回False，示例代码如下。
   turtle.penup()
   turtle.isdown()
   turtle.pendown()
   turtle.isdown()
6、turtle.pencolor(*args)
提供参数时设置画笔颜色，未提供参数时返回画笔颜色，示例代码如下。
    colormode()
    turtle.pencolor()
    turtle.pencolor("blue")
    turtle.pencolor()
    turtle.pencolor((0.3, 0.5, 0.6))
    turtle.pencolor('#FF00FF')
7、turtle.fillcolor(*args)
提供参数时设置填充颜色
未提供参数时返回填充颜色
示例代码如下。
   turtle.fillcolor("yellow")
   turtle.fillcolor()
8、turtle.color(*args)
提供两个颜色参数，分别设置为画笔颜色和填充颜色；
未提供参数时返回画笔颜色和填充颜色。
示例代码如下。
   turtle.color()
   turtle.color("red", "green")
9、turtle.filling()
返回填充状态，要填充是返回True，不填充时返回False。
10、turtle.begin_fill()
开始填充，在绘制填充形状之前调用。
11、turtle.end_fill()
结束填充，同时执行填充操作，填充调用begin_fill()之后绘制的封闭形状。
12、turtle.clone()
创建并返回画笔的克隆体，克隆体具有与画笔相同的位置、朝向和其他属性。
克隆得到的画笔可以设置与原画笔不同的属性，执行不同的绘图操作。
示例代码如下。
  t2=turtle.clone()
turtle允许使用多个画笔，可调用Turtle()函数创建画笔，
示例代码如下。
  t3=turtle.Turtle()

画笔运动函数
1、turtle.forward(distance)和turtle.fd(distance)
画笔前进distance指定的距离，参数distance为像素值，不改变画笔的朝向，示例代码如下。
   turtle.forward(50)
2、turtle.back(distance)、turtle.bk(distance)和turtle.backward(distance)
画笔后退distance指定的距离，不改变画笔的朝向，示例代码如下。
    turtle.backward(50)
3、turtle.right(angle)和turtle.rt(angle)
画笔向右旋转angle个单位，单位默认为角度，可调用turtle.degrees()和turtle.radians()函数设置度量单位。
角度的正负由画笔模式确定，可调用turtle.mode()函数设置画笔模式。
函数turtle.degrees()将角度的度量单位设置为度，turtle.radians()将角度的度量单位设置为弧度。
示例代码如下。
   turtle.degrees()        #设置角度单位为度
   turtle.heading()        #画笔当前朝向
   turtle.right(60)        #画笔向右旋转60度
   turtle.heading()
4、turtle.mode(mode=None):设置或返回画笔模式(即画布坐标系)
参数mode为字符串“standard”“logo”或“world”。“standard”模式与旧版本的turtle兼容，“logo”模式与大部分Logo画笔绘图兼容，“world”模式使用用户自定义的“世界坐标系”。
模式、画笔初始朝向和角度正负之间的关系如下。
standard模式：画笔初始朝右（东）、逆时针为角度正方向。
logo模式：画笔初始朝上（北）、顺时针为角度正方向。
示例代码如下。
   turtle.mode('logo')
   turtle.heading()
   turtle.right(60)
   turtle.heading()
5、turtle.left(angle)和turtle.lt(angle)
画笔向左旋转angle个单位，示例代码如下。
  turtle.left(45)
6、turtle.goto(x, y=None)、turtle.setpos(x, y=None)和turtle.setposition(x, y=None)
将画笔移动到绝对坐标的位置。
如果画笔已落下将画直线。不改变画笔的朝向。
同时提供参数x和y时，(x,y)为新坐标。省略参数y时，x为坐标向量。
示例代码如下。
  turtle.pos()        #查看画笔当前位置
  turtle.goto(20,30)        #移动画笔到(20,30)
  turtle.pos()
  turtle.goto((50,50))        #移动画笔到(50,50)
7、turtle.setx(x)
画笔水平移动，横坐标变为x，纵坐标保持不变。
示例代码如下。
  turtle.pos()
  turtle.setx(100)
  turtle.pos()
8、turtle.sety(y)
画笔垂直移动，横坐标不变，纵坐标变为y，示例代码如下。
   turtle.pos()
   turtle.sety(100)
   turtle.pos()
 9．turtle.setheading(to_angle)
   turtle.seth(to_angle)
将画笔的方向设置为to_angle（注意由画笔模式决定具体方向）
示例代码如下。
   turtle.setheading(45)
10、turtle.home()
将画笔移至初始坐标(0,0)，并设置方向为初始方向(由画笔模式确定)，示例代码如下。
  turtle.pos()            #当前位置
  turtle.heading()        #当前朝向
  turtle.home()    #画笔回归原点，重置为初始朝向
  turtle.heading()
  turtle.pos()
11、turtle.circle(radius, extent=None, steps=None)
绘制半径为radius圆，圆心在画笔左侧radius个单位的位置。
参数radius为数值，extent为数值或None，steps为整数或None。
extent为一个角度，省略时绘制圆，指定extent参数时绘制指定角度的圆弧。
绘制圆弧时，如果radius为正值，则沿逆时针方向绘制圆弧，否则沿顺时针方向绘制圆弧。最终画笔的朝向由extent的值决定。
turtle库实际上是用内切正多边形来近似表示圆，其边的数量由steps指定。
省略steps参数时自动确定边数。此方法也可用来绘制正多边形。
示例代码如下。
 turtle.circle(50)           #绘制半径为50圆
 turtle.circle(100,180)       #绘制半径为100半圆
 turtle.circle(200,None,4)       #绘制对角线长为200正方形
 turtle.circle(200,steps=6)  #绘制对角线长为200正六边形
12、turtle.dot(size=None, *color)
绘制一个直径为size，颜色为color的圆点。
如果未指定size，则直径取pensize+4和2*pensize中的较大值，
示例代码如下。
  turtle.dot()         #绘制默认大小的点。
  turtle.dot(100)          #绘制直径为100的点
  turtle.dot(50,'red')#绘制直径为50的点，颜色为红色
13、turtle.undo()：撤消最近的一个画笔动作
可撤消的次数由撤消缓冲区的大小决定，示例代码如下。
  turtle.undo()
14、turtle.speed(speed=None)：设置画笔的移动速度。
不指定参数（或为None）时返回画笔的移动速度。
参数speed为0~10范围内的整数或速度字符串，除0以外的速度值越大绘图速度越快（0表示没有动画效果）。
可用的速度字符串与速度值的对应关系如下。
fastest：0，最快。
fast：10，快。
normal：6，正常。
slow：3，慢。
slowest：1，最慢。
示例代码如下。
  turtle.speed()   #3
  turtle.speed('fast')
  turtle.speed()     #10
  turtle.speed(6)
15、turtle.position()和turtle.pos()
返回画笔当前的坐标，示例代码如下。
   turtle.pos()
16、turtle.xcor()
返回画笔的x坐标。
17、turtle.ycor()
返回画笔的y坐标。
18、turtle.heading()
返回画笔的当前朝向。
19、turtle.distance(x, y=None)
返回从画笔位置到坐标(x,y)或另一画笔对应位置的距离。
参数x为画笔对象时，y为None
示例代码如下。
   turtle.home()
   turtle.goto(100,100)
   turtle.distance(0,0)

形状函数
1、turtle.getshapes()
返回画笔形状列表，列表包含当前可用的所有画笔形状的名称，示例代码如下。
 turtle.getshapes()  #返回['arrow', 'blank', 'circle',  
               'classic', 'square', 'triangle', 'turtle']
2、turtle.shape(name=None)
将画笔形状设置为name指定的形状，如未提供参数则返回当前的画笔形状的名称，示例代码如下。
   turtle.shape('turtle')        #将画笔设置为海龟形状
3、turtle.begin_poly()
开始记录多边形的顶点，当前画笔位置为多边形的第一个顶点。
4、turtle.end_poly()
停止记录多边形的顶点，当前画笔位置为多边形的最后一个顶点，它将连线到第一个顶点。
5、turtle.get_poly()
返回最新记录的多边形，示例代码如下。
  turtle.begin_poly()    #开始记录
  turtle.fd(50)
  turtle.lt(60)
  turtle.fd(50)
  turtle.lt(60)
  turtle.fd(50)
  turtle.lt(60) 
  turtle.fd(50)
  turtle.lt(60)
  turtle.fd(50)
6、使用复合形状
复合形状由多个不同颜色的多边形构成。
使用复合形状包含下列步骤。
创建一个类型为“compound”的Shape对象。
调用addcomponent()方法为Shape对象添加多边形。
注册Shape对象，并将其设置为画笔形状。
示例代码如下。
  s = turtle.Shape("compound") #创建空的复合形状对象
  p = ((0,0),(50,0),(50,50),(0,50))  #定义多边形顶点
  s.addcomponent(p, "red", "blue")#将多边形添加到复合形状对象
  p = ((10,10),(40,10),(40,40),(10,40))
  s.addcomponent(p, "blue", "red")
  p = ((20,20),(30,20),(30,30),(20,30))
  s.addcomponent(p, "red", "blue")
  turtle.register_shape("mycs", s)#注册复合形状对象
  turtle.shape('mycs')    #将复合形状设置为画笔形状

输入输出函数
1、turtle.write(arg,move=False,align="left",font=("Arial", 8, "normal"))
将对象arg输出到画笔位置，参数move为True时（默认为False），画笔会移动到文本的右下角。参数align指定对齐方式，取值范围(left、center、right)，对齐位置为画笔当前位置。参数font是一个三元组(fontname, fontsize, fonttype)，用于指定字体名称、字号和字体类型。参数font默认为("Arial", 8, "normal")，
示例代码如下。
  turtle.home()
  turtle.write((0.0))
  turtle.write("Python", True, align="center")
2、turtle.textinput(title, prompt)
用对话框输入字符串。参数title为对话框的标题，prompt为提示信息。
函数返回输入的字符串，取消对话框时返回None，
示例代码如下。
 turtle.textinput("Turtle绘图", "请输入一个字符串")
3、turtle.numinput(title, prompt, default=None, minval=None, maxval=None)
用对话框输入数值。
参数title为对话框标题，prompt为提示信息，default为输入框初始值，minval为允许输入的最小值，maxval为允许输入的最大值。
函数返回输入的数值，取消对话框时返回None。
示例代码如下。
 turtle.numinput("Turtle绘图", "输入一个数值",None,1,10)

事件处理相关函数
1、turtle.mainloop()和turtle.done()
开始事件循环，调用Tkinter库的mainloop()函数，用于实现turtle绘图窗口的交互功能。
应将turtle.mainloop()或turtle.done()作为一个绘图程序的结束语句，否则其后的绘图语句不会执行。
示例代码如下。
   turtle.done()
2、turtle.listen()
使绘图窗口获得焦点，以便接收键盘和鼠标事件。
3、turtle.onkeypress(fun, key=None)
   turtle.onkey(fun, key)
   turtle.onkeyrelease(fun, key)
三个函数功能类似，注册按键事件函数，fun为函数名，在按下（未释放）key指定的键时调用fun()函数。
注意，在onkey、onkeyrelease和onkeypress等事件发生后，Python执行绑定的函数。
在函数执行过程中，如果发生其他事件，则会中断正在执行的函数，转去执行其他事件的绑定函数。
示例代码如下：
  def fun():
      turtle.fd(50)
      turtle.circle(45)
  #在按下键盘上的字母b键时，调用fun()函数
  turtle.onkeypress(fun,'b')    
  turtle.listen()
4、turtle.onclick(fun, btn=1, add=None)
   turtle.onscreenclick(fun, btn=1, add=None)
onclick()为画笔绑定鼠标单击事件函数。 
onscreenclick()为绘图窗口绑定鼠标单击事件函数。
将函数fun()绑定到鼠标单击事件，fun为None时删除现有的绑定，参数fun为函数名，调用时将传入两个参数表示鼠标所在点的坐标。
参数btn为1（默认值）时，表示鼠标左键，2表示鼠标中间键，3表示鼠标右键。
参数add为True时将添加一个新绑定，否则将取代先前的绑定。
示例代码如下：
 def fun(x,y):
      turtle.goto(x,y)
      turtle.circle(45)

  turtle.onscreenclick(fun) #单击绘图窗口时调用函数fun()
  turtle.onclick(fun,3)    #右键单击画笔时调用函数fun()
5、turtle.onrelease(fun, btn=1, add=None)
将函数fun()绑定到鼠标释放事件，与turtle.onclick()类似。
示例代码如下。
   def fun(x,y):
      turtle.circle(50)
   #在画笔上按下并释放鼠标右键时调用函数fun()
   turtle.onrelease(fun,3)    
6、turtle.ondrag(fun, btn=1, add=None)
将fun()函数绑定到画笔的拖动事件。
如果fun值为None，则移除现有的绑定。
在拖动画笔时，首先会触发画笔的鼠标单击事件
示例代码如下。
   #拖动画笔在绘图窗口中手绘线条
   turtle.ondrag(turtle.goto)    
7、turtle.ontimer(fun, t=0)
创建一个计时器，在t毫秒后调用fun()函数。
fun是函数名称，函数无参数
示例代码如下：
 def f():
    turtle.fd(100)
    turtle.circle(50)
 turtle.ontimer(f)        #立即执行f()函数
 turtle.ontimer(f,2000)    #2秒后执行f()函数

（2）random库（PPT 69）
概述：
random库提供了随机数生成函数，其模块文件为Python安装目录下的“Lib”子目录中的random.py。
Python的伪随机数生成器采用应用最为广泛的马特赛特旋转（Mersenne Twister）算法，它可以产生53位精度浮点数，周期为219937-1，其在底层用C实现。
random库提供的函数主要包括随机数种子函数、整数随机数函数、浮点数随机数函数和序列随机函数。
导入模块语句：import random

随机数种子
随机树种子函数基本格式：random.seed(a)
seed()的返回值为None
seed()相同的数字得到的抽取结果一致
Seed()省略a时，相当于使用当前系统时间作为随机数种子，可以保证每次运行程序得到不同的随机数
import random
# 使用seed函数设置随机种子，a的取值一样
# a取值不同，产生随机树序不同，不设置a，相当于把系统时间当作随机种子
random.seed(a=1)
for i in range(5) :
    print(random.randint(1,9))
print("-------------------------------------")
random.seed(a=2)
for i in range(5) :
    print(random.randint(1,9))

帧数随机数函数
1.    random.randrange(n)
返回一个范围为[0,n)的一个随机数
例子：
#产生五个0~9的随机数
import random
for i in range(5):
    print(random.randrange(0,10))
2.    random.randrange(m,n,step)
返回[m,n]范围内的一个整数
未指定step时，从当前随机数序列中连续取数；指定step参数时，取数的间隔为step-1
#产生五个数字，每个数字之间间隔5
for i in range(5) :
    print(random.randrange(5,15,5))

浮点数随机数
1.    random.random()
返回[0.0,1.0]之间的随机一个浮点数
例子：
#产生五个浮点数随机数
for i in range(5):
    print(random.random())
2.    random.uniform(a,b)
返回一个[a,b）随机浮点数
当a<=b时取值范围为[a,b]
当a>=b时取值范围为[b,a]
#产生五个-5~5之间的浮点数
for i in range(5):
    print(random.uniform(-5,5))

序列随机函数
1.random.choice(seq)
从非空seq随机选择一个元素返回
如果seq为空，就会引发IndexError异常
代码如下：
#从一个序列中随机产生答案
seq = ["达子",'胖子','狗']
for i in range(5) :
    print(random.choice(seq)
3.    random.shuffle(seq)
将seq序列打乱
代码如下：
#将一个序列的数据打乱输出
a = [1,2,3,4,5]
print(a)
random.shuffle(a)
print(a)
适用于一个可变的序列打乱顺序，若为不可变序列需要返回一个打乱的列表应该使用
Sample(seq,k=len(seq))
例子：
a = (1,2,3,4)
x = random.sample(a,k=2)
print(a)
print(x)
注意：k的数量决定打乱后取出的元素个数

（3）time库
概述：
time库提供时间相关的函数。
与时间相关的模块有：time、datetime和calendar。
time库不适用于所有的平台，其定义的大部分函数都是调用平台的C语言库中的同名函数。
time库属于内置模块，直接导入即可使用。
time库提供的函数可分为时间处理函数、时间格式化函数和计时函数。
导入模块语句：import time

1.    Epoch：时间起点
取决于平台，通常为“1970年1月1日00：00：00”
可调用time.localetime(0)返回当前平台的Epoch
2.    时间戳timestamp
时间戳通常指自Epoch到现在的时间的秒数
3（UTC）
UTC指Coordinated Universal Time，世界标准时间，以格林尼治天文台的经线为0 度经线，将世界分为24 个时区，在中国为UTC+8 。
5、struct_time：该类表示时间对象
gmtime()、localtime()和strptime()等函数返回struct_time对象表示的时间。
 

时间处理函数
1、time.time()
返回自Epoch以来的时间的秒数。
示例代码如下。
   time.time()
2、time.gmtime()
将秒数转换为UTC的struct_time对象，其中dst标志始终为零。
如果未提供参数或参数为None，则转换当前时间。
示例代码如下。
   time.gmtime()            #转换当前时间
   time.gmtime(10**8)     #转换指定秒数
   t=time.gmtime(10**8)     #转换秒数
   t[0]                #索引年份字段
   t.tm_year                   #以属性的方式访问年份字段
3、time.localtime()
将秒数转换为当地时间。如果未提供参数或参数为None，则转换当前时间。
如果给定时间适用于夏令时，则将dst标志设置为1
示例代码如下。
   time.localtime()            #转换当前时间
   time.localtime(10**8)        #转换指定秒数

时间格式化函数
1、time.mktime()
mktime()是localtime()的反函数，其参数是struct_time对象或者完整的9元组。
如果输入值不能转换为有效时间，则发生OverflowError或ValueError异常。
函数可以生成的最早日期取决于操作系统。
示例代码如下。
   t=time.localtime()    #获得本地时间的struct_time对象
   time.mktime(t)            #获得本地时间的秒数
   a=(2017,12,31,9,30,45,7,365,0)    #构造9元组
   time.mktime(a)            #生成时间
2、time.strftime(format[, t]))
参数t是一个时间元组或struct_time对象，可以将其转换为format参数指定的时间格式化字符串。
如果未提供t，则使用当前时间。
format必须是一个字符串。
如果t中的任何字段超出允许范围，则发生ValueError异常。
0可作为时间元组中任何位置的参数；如果它是非法的，则会被强制改为正确的值。
 
 
示例代码如下。
  t=time.localtime()
  time.strftime('%Y-%m-%d %H:%M:%S',t)  
 
strftime()函数的时间格式化字符串中不支持非ASCII码字符，要获得中文时间字符串，需使用struct_time的字段来构造字符串
示例代码如下。
  t=time.localtime()
  format='%s年%s月%s日 %s时%s分%s秒'
  print(format %(t.tm_year,t.tm_mon,t.tm_mday,t.tm_hour,t.tm_min,t.tm_sec))
 
3、time.strptime(t,format)
strptime()可看作是strtime()的逆函数，按格式化字符串format解析字符串t中的时间，返回一个struct_time对象。
示例代码下。
   time.strptime("1 Nov 01", "%d %b %y")

计时函数
1、time.sleep(secs)
暂停执行当前线程secs秒。参数secs可以是浮点数，以便更精确地表示暂停时间。
示例代码如下。
  a = time.time()
time.sleep(5)
b = time.time()
print(b-a)
 
2、time.monotonic()
返回单调时钟的秒数（小数），时钟不能后退、不受系统时间影响，连续调用获得的秒数差值可作为有效的计时时间
示例代码如下。
print(time.monotonic())
 
3、perf_counter()
返回性能计数器的秒数（小数），包含线程睡眠时间，连续调用获得的秒数差值可作为有效的计时时间。
示例代码如下。
a = time.perf_counter()
time.sleep(2)
b = time.perf_counter()
print(b-a)
 

4、perf_counter_ns()
与perf_counter()类似，返回纳秒数（整数）
示例代码如下。
a = time.perf_counter_ns()
time.sleep(2)
b = time.perf_counter_ns()
print(b-a)

对比：
a = time.time()
time.sleep(2)
b = time.time()
print(b-a)
a = time.perf_counter_ns()
time.sleep(2)
b = time.perf_counter_ns()
print(b-a)
a = time.perf_counter()
time.sleep(2)
b = time.perf_counter()
print(b-a)
 

（4）Tkinter库（PPT 107）
介绍：
Tkinter是Python默认的图形用户界面（GUI)库，Tkinter是Tk interface的缩写，Tkinter库已成为Python的内置模块。
在Python3中，Tkinter库的模块名被重命名为tkinter（首字母小写）。
Tkinter程序的基本结构如下：
导入tkinter模块
创建主窗口
在主窗口中创建控件
打包控件
开始事件循环
导入模块语句：import Tkinter as tk
下面的代码使用Tkinter库创建一个窗口，在窗口中显示一个字符串。
import tkinter #导入包
w = tkinter.Tk() #创建主窗口
label = tkinter.Label(w,text="爱你呀，宝贝！")#创建标间
label.pack()#打包标签
w.mainloop()#开始循环事件
Tkinter程序的基本结构如下。
（1）导入tkinter模块。
（2）创建主窗口：所有控件默认情况下都以主窗口作为容器。
（3）在主窗口中创建控件：调用控件类对象创建控件时，第一个参数为主窗口。
（4）打包控件：打包器决定如何在窗口中显示控件。未打包的控件不会在窗口中显示。
（5）开始事件循环：开始事件循环后，Tkinter监听窗口中的键盘和鼠标事件，响应用户操作。mainloop()函数会一直运行，直到关闭主窗口结束程序。