人生苦短，我用python
解释器：编译型语言（代码——>编译器——>最终可执行文件——>操作系统——>CPU），解释型语言(代码——>编译器运行一句，解释一句，一句一句执行——>操作系统——>CPU)，所以编译型的效率高（c语言等），但解释型的跨平台能力更强（如python等）
python的设计目标：简单直观的语言，开源，像纯英语一样容易理解，适用于短期开发的日常任务。（优雅，明确，简单）
python是面向对象的语言。面向对象是一种思维方式，比如遇到问题，找人替我们做，而且他具有这种能力。如果是自己亲力亲为，就是面向过程。
python拥有强大的标准库，因为是开源的，同事拥有非常丰富的第三方模块，覆盖了科学技术、人工智能、机器学习、web开发、数据接口、图形系统多个领域。
python拥有可扩展性，可以用c，c++来编辑一些核心代码
缺点：运行速度要慢一些，国内市场较小，中文资料匮乏
执行方式：
解释器方式执行，python
python的源程序就是一个特殊格式的文本文件
python文件扩展名.py
************************************************************面向过程**************************************************************************
1.print,打印，输出函数
2.建立.py文件，在里面输入代码。执行：python 文件，直接执行
3.BUG（1.手误，代码敲错。2.对已经学习过的知识点理解还存在不足。3.对语言学习还需要提升的地方）。每一位程序员都是在不断修改错误的过程中成长的。
4.代码一行就负责完成一个动作，动作多了就会报错：SyntaxError: invalid syntax
5.python对出错的地方，下面有箭头报错
6.python对程序要求，希望python整整齐齐，所以按空格来分级别，每行代码前面都不要添加空格
7.python2.0的解释器默认不支持中文的，
8.python的解释器：CPython，官方版本C语言实现。Jython，运行在java平台的，IronPython可以运行在.NET和Mono平台。 PyPy，是用Python实现的，支持JIT即使编辑。
9.交互式运行python（就是在终端中运行）：ipython特点：只能运行小的程序、验证，不适合大的，代码不能保存
退出解释器：1.exit(),或者快捷键：ctrl+d
10.IPython是一个交互式shell，特点（1.支持自动补全。2.自动缩进。3.支持bash shell命令。4.内置很多有用的功能和函数）。运行方式，在终端里面直接输入ipython运行。所以，交互式运行，首选ipython。
exit退出，不用加括号。ctrl+d——>Y。
ipython3是ipython的升级版
11.集成开发环境（IDE）特点（1.图形用户界面。2.代码编辑器，支持代码自动补全和缩进。3.编译器/解释器。4.有调试点，可以单步执行）。
PyCharm是一个集成开发环境，特点（1.比较优秀。2.在Windows，mac，Linux中运行。3.适合大型项目）
pycharm的配置信息在家目录下的.Pycharmxxxx.x, 如果想恢复初始设置，只需将次文件删掉即可，删除时需要关闭pycharm软件。
open一个project后，会在工程目录中生成一个.idea文件，里面有一些项目相关信息，比如解释器版本，项目包含文件情况
12.新建工程
命名规则：项目名前面都以数字编号，随着知识点递增，编号递增
文件名，命名最好只使用小写字母，数字和下划线；文件名不能以数字开始；如果没有按照好的规则来命名，在开发大型项目中就容易出现问题。
13.计算机运行原理
启动软件后，CPU把软件复制到内存中，直接和内存进行信息交换，不会直接和硬盘交换信息，这样运行才快。python程序执行原理也是，python就是在内存中，但是python很小，占用内存也很少，CPU直接和内存交换信息。
14.程序开发就是为了处理数据，各种类型的数据。
python命令：
1.+加，-减，*乘，/除，//取整，%取余，**幂。数字之间，数字与符号最好有个空格。有优先级哦。
2."字符" * 10, 会输出10遍 字符。只有*乘法运算符可以这样使用、
3.变量名只有在第一次使用时才需要定义，第二次使用不需要定义了
4.在python中，type(××)查看××的类型
5.字符串之间可以用+号拼接：
In [2]: first="张"
In [3]: last="三"
In [4]: name = first +last
In [5]: name
Out[5]: '张三'
In [6]: name * 10
Out[6]: '张三张三张三张三张三张三张三张三张三张三'
In [7]: name + "10" # name不能+10
Out[7]: '张三10'
6.range函数：
range(5)和range(0,5)意思一样，0-4的整数。如果需要打印输出，通过list来转换成列表：print(list(range(5)))
range(1,8)，1-7的数字
6.input函数，用于输入信息。
input（“请输入用户名：”）
赋值：username=input（“请输入用户名：”）
input 输入的内容都是字符串类型的，所以，如果需要计算，需要将输入的信息转换为数字类型
7. int（x），将括号内的内容转换为整数型。
float（x），将括号内的内容转换为浮点型。
8.格式化输出：
操作符： %s，字符串。
%d，十进制整数，%06d表示输出的整数显示位数，不足的地方在前面用0补全
%f，浮点数，%.2f表示小数点后只显示2位
%%，输出%
格式： print("格式化字符串"%（变量1，变量2，...）)
９．变量的命名
标识符：
要达到见名知意的效果
可以由字母、下划线和数字组成
不能以数字开头
不能与关键字重名。
查看python中的关键字:
import keyword
print(keyword.kwlist)
标识符是区分大小写的
给变量去名字时，在＝左右各保留一个空格，保证代码格式
由多个单词组成时，全用小写字母，单词之间用下划线连接。可以用驼峰命名法，每个单词的首字母大写或者小写。
10.if语句
顶格写,
条件判断后要加：冒号
下一级用Tab键，或者４个空格－－建议使用空格，要保证要么全部用Ｔａｂ，要么全部用空格，不然会出错
if下边带缩进的代码是一个整体
比较运算符：==，等于；!=不等于；>=大于等于，中间不能加空格；
逻辑运算符：and , or , not .
elif: 意思是else if。与else类似，都必须要与if联合使用，不能单独使用。
17.多行注释快捷键：选中文字所在行，ctrl+/键.
18.字体间隔不正确，shift+空格键
20.随机数的处理
导入随机函数random: import random
选择random的子函数：random.按tab键可以显示所有的函数
选择函数：random.randint(a,b),随机生成ab之间的整数，b不能比a小，两个数可以相等
21.while，格式和if一样
22.赋值运算符： c+=a,c=c+a。+，-，*,/，**,//,%都是一样
23.程序世界中，是从0开始计数的，所以计数都丛0开始
24.break 和continue
break，当满足某些条件，就退出当前循环
coutinue，直接跳到条件判断，不会执行continue后面的语句，为了避免死循环，在continue之前要加上变量的变化
25.转义字符：
# \t 在控制台输出一个 制表符， 协助在输出文本时 垂直方向保持对齐
# \n 在控制台输出一个换行符
# 转义字符\"，在print中打印“双引号。 同理，\'输出'单引号。
# 转义字符\\，在print中打印\号
26.函数：
定义函数语法：def 函数名(): ,下面所有的代码都缩进一级
注意：定义好函数之后，只表示这个函数封装了一段代码，如果不主动调用函数，函数是不会主动执行的
只有在程序中调用函数，才会让函数执行。函数调用只有在封装定义了函数之后才能调用，如果在函数定义之前调用，就会出现错误。
给函数增加注释：
根据PEP8，要在函数前面空两行来注释函数。
在函数定义的下方缩进一级，在三个引号中间注释函数。在调用的函数上点击一下鼠标，用 ctrl+q 键可以快速查看函数的注释。
删掉函数下面三个“引号的注释，鼠标点击函数，在小灯泡里面选择insert……，可以对函数中的形参进行分别注释
形参，定义函数时候def sum_2num(num1,num2):，中的参数num1，num2，在函数中座位变量，同事也是参数。
实参，调用函数时候的sum_2num(10,45)，中的实际数字。
return，返回结果命令。后续调用过程中，使用变量= 调用函数，即可得到值。return后面的语句不会执行。
27.Pycharm调试工具
F8 step over，可以单步执行代码，会把函数调用看做是一行代码直接执行
F7 step into，可以单不执行代码，如果是函数，会进入函数内部
28.模块：所有.py文件，都是一个模块，供外界直接使用
使用模块：先import，导入模块（.py文件名）
模块名也是一个标识符，是不能以数字开头命名的，不然没办法import的模块
调用模块中的函数： 模块名.函数名 （模块名+函数名，直接用.点号连接），即可使用模块函数
29.pyc文件：在工程中有个文件夹，里面有编译过自动生成的文件，以pyc结尾。
格式是：模块名.cpython-35.pyc, cpython的解释器3.5版本，生成的。
由解释器，将模块的编码转换为字节码，目的是作为启动的速度的优化。
步骤：先将代码编译生成二进制字节码，再将字节码进行处理乘CPU能识别的机器码。
有了模块字节码文件后，在下一次运行是，如果程序没有改变，python会自动加载.pyc文件，不会再次编译。如果pyc文件被删，或者代码修改过，就会重新编译代码，重新建立pyc文件。
高级变量类型：
30.列表，就是数组，但在python中一般叫做列表，对应单词是list，是python中使用最频繁的数据类型。
列表格式： 变量名 = [a,b,c], 比如： name_list = ["zhangsan","lisi","wangwu"].多个数据，数据与数据之间用逗号隔开
列表取值： 列表取值是从0开始，依次递增的。叫做：索引或下标。name_list[0]，取值。
查看列表使用方法：ipython中，先自己定义一个列表变量：alright = []；再在下面输入alright.点，按下Tab键，就可以看到操作列表的方法了。
所谓的方法，就是对前面的列表可以进行的操作。（函数名需要死记硬背，方法是不需要死记硬背的。但共同点是都有括号，里面都有参数。）
31.元组tuple：
使用圆括号
元组一旦定义完成，就不能对数据进行增删改。
列表一般定义同一类型的数据，元组一般定义不同类型的数据
元组取值，也用[]方括号
列表中name = [5]，类型是list;name = (5)，类型是int ;name = (5,)，类型是tuple元组
空元组一般用得比较少，因为元组一旦定义，不能修改。
因为元组变量通常保存的数据类型不一样，所以遍历时候对数据不一定能进行相同操作
如果希望列表中的内容不被修改，就将列表转换为元组
元组和列表的相互转换：list(tupple_),将tupple类型转换为列表；tupple（list_) 将list转换为tupple类型。转换需要用第三个变量进行缓存，元数据不变。
32.用for可以遍历：列表，元组，字典，字符串。 for .. in .. :
33.字典：
字典里面的数据是无序的。只关心里面保存的数据是什么类型的数据，只要存在就可以了，顺序没关系。
字典用{}，内容是由key和value组成的。key：value之间用冒号，成为一组数据。和其他数据之间用，逗号隔开。
字典可以取值
可以用for遍历，只是遍历的顺序不受控制，随机的
34.字符串
字符串可以用“”双引号，也可以使用‘’单引号，但大多数情况都是使用“”双引号
使用单引号的情况: '我的外号是"大西瓜"',将“大西瓜”用引号引起来
字符串也可以取值，一个字符/字符/汉字等算一个元素
字符串的使用方法比较多：比较，对齐，替换，查找，切片……等，详见工程
35.公用方法：
比较：max(),min()对列表，元组比较取值。在字典中，只比较key的大小。可以使用>,<,比较运算符。cmp在3.0中被取消了，cmp（“1”，“2”）
切片：字符串，列表，元组，方法通用。字典中不能切片，因为字典中没有索引的概念。
运算：字符串，列表，元组，方法通用。(1,2) * 2 ——> (1, 2, 1, 2)。但字典不能用*。
加法运算符：(1,2) + (3,4) ——> (1,2,3,4)，+号表示拼接。append是追加独立的元素，extend是追加元素打散后独立追加。
in：成员运算符，看in前面的是否在in后面的列表中
36.TODO功能，增强提醒：在注释#后使用：eg：# TODO（小明） 用户输入，“TODO”用于增强提醒
37.Linux中shebang的应用(在终端中运行程序）：
用which命令查看python3的路径：which python3, 一般查询到的路径是：/usr/bin/python3
先在函数的主程序顶端加入： #! /usr/bin/python3
用cd命令，进入程序文件夹
用ls 命令查看程序.py文件，可以看到此时文件是不可执行的
用chmod命令更改主程序文件的文件权限为可执行。命令为：chmod +x 文件名
执行文件： ./文件名.py ,即可执行文件
34.变量
变量和数据是分开保存的
数据保存在内存中的一个位置
变量中保存着数据在内存中的地址，这个地址叫做引用
给变量重新赋值，就是更改变量对地址的引用
使用id()函数可以查看变量中保存数据所在的内存地址。name = 1，id(name) = id(1) = 地址
列表、字典中，通过方法更改值，其地址不变。但是通过赋值，会使得其地址发生改变
字典中的key值只能是不可变类型的，比如元组。列表和字典不能作为key值
不可变类型：数字-int,bool,float,complex,long(2,x)；字符串-str；元组—tuple。一旦在内存中分配了地址，就不能修改内容，只能通过赋值语句，更改数据的引用地址。
可变类型：列表，字典。通过方法调用可以修改列表、字典中的内容，但是内存地址不会发生变化。
hash()函数可以查看数据是否是不可变类型。如果能返回结果，就是不可变类型。如果提醒错误就是可变类型数据。
35.全局变量
全局变量不能在函数内部赋值，如果赋值，就会在函数内部产生一个局部变量，和全局变量是没有任何关系的。
如果想在函数内部修改全局变量，就要在函数内部运用global 变量名，申明一下变量，这样，在后续的赋值过程中，就可以更改全局变量的值
全局变量命名规则：在变量之前增加前缀：g_，或者gl_。
函数
36.函数
需要参数的情况：当需要处理函数外部的数据时
需要增加返回值的情况：当需要对外部汇报函数的执行结果时。
函数返回多个值，可以用元组
全局变量，即使引用到函数参数中，其赋值，也不会改变其数据
全局变量（可变类型变量），在参数引用中，如果是使用方法更改值，会改变全局变量的值
37.变量交换
法一：利用第三变量
法二：利用加减法。a = a + b ; b = a - b; a = a -b.
法三：python中的专用方法。 a,b = b,a
38.列表变量，使用+=符号，是使用extend方法，此时全局变量的值会被修改。但如果是list1+list2，全局变量值不会更改。
39.缺省参数
函数中有的参数使用默认值就不需要增加其缺省值
一般默认值是使用频率最多的参数值
40.多值参数（7-9）
有时候，一个函数能够处理的参数个数是不确定的，这个时候可以使用多值参数。
参数名前加一个* 可以接收元组。一般习惯用*args存放元组参数
参数名前加两个* 可以接收字典。一般习惯用**kwargs存放字典参数。
41.拆包（作用，是避免将多值参数的值只传递给一个参数）
将元组变量，直接传递给args
将字典变量，直接传递给kwargs
42.递归
函数内部，自己调用自己
需要对参数进行一个判断，当函数满足某种条件时，利用return退出函数（通常叫做递归的出口）。不然，函数会进入死循环。
return退出是退出当前函数，继续执行后面的代码。是在调用函数内部一层一层返回。并非直接跳出全部函数。
************************************************************面向对象**************************************************************************
1.面向过程后面会比较复杂，出现各种调用。面向对象主要是侧重对象的功能（谁来做这个事情），而不是程序过程，很少出现复杂的调用情况，主要用于开发大型项目。
2.类和对象：
类相当于制造飞机的图纸；
对象相当于不同的飞机，属于 类。不同的飞机有不同的功能；
类是模板，对象 是根据 类 这个模板创建出来的，应该 先有类，再有对象
类 只有一个，而 对象 可以有很多个
不同的对象 之间 属性 可能会各不相同
类 中定义了什么 属性和方法，对象 中就有什么属性和方法，不可能多，也不可能少
类：class 类，用于创建对象
对象：由类来创建，对象= 类（xx）
属性：类中的赋值语句，描述语句
方法：类中的函数
3.设计一个对象：先做需求分析
4.命名规则：大驼峰命名
5.dir 内置函数：这个函数可以查看针对对象所使用的内置的方法或属性。
6.新建类：class，里面有def定义函数。直接调用。
7.初始化函数，可以加形参。
8.当使用 类名() 创建对象时，为对象 分配完空间后，自动 调用 __init__ 方法
当一个 对象被从内存中销毁 前，会 自动 调用 __del__ 方法
9.str，返回一个字符串，打印对象时候就不会输出类别和地址，会输出返回值
10.面向对象封装（重要案例，家具摆放，士兵突击）
不同对象之间值互不影响
初始化：参数是需要外部引入的，如果不从外部引入，就不需要参数。直接在函数里面定义即可
哪一个类要被使用，就先开发哪一个类
self：如果是在函数内部，就用self。如果是外部函数调用，就将self更改成对象名。
在封装的方法内部，还可以让自己的类使用其他类创建的对象属性（即：类里面的函数），用来调用已经封装好的方法
11.if判断中，is与==的区别。is是判断两个变量的内存地址是否一样。==只是判断两个变量的内容是否一致。
******类的三个基本特性******************************************
12.继承（实现代码的重复使用，即相同的代码不需要重复编写）：
子类拥有父类的所有属性和方法
语法。class 类名(父类名): pass
继承的传递性：孙子可以直接使用爷爷的属性和方法
方法的重写：如果说子类的方法和父类的方法不一样，就在子类中重新写一个同样名字的方法，将方法内的内容更改即可
对父类方法的扩展：1.先重写父类方法。2.用super().父类方法,来调用父类方法执行。可以同时使用新方法和旧方法。（2.0版本中没有super）
对父类方法的扩展方法二：父亲名.方法（self）,此方法不推荐在3.0中使用
子类对象不能在自己的方法内部，直接访问父类的私有属性或私有方法
子类对象可以通过父类的公有方法间接访问到私有属性或私有方法
13.多继承（继承多个类的方法和属性）
语法： class C(A, B)
注意事项：如果两个父类之间存在相同的方法和属性，就应该尽量避免不是用多继承。不然只会按照class C(A, B)的顺序，选择第一个。
MRO：方法搜索顺序，用于查看方法的搜索顺序。语法：print(C.__mro__)
dir(对象)，可以查看对象的基类，语法：dir(a),a代表创建的对象
object是所有对象的基类，但是在2.0版本中创建类时，如果后面不加object，就会识别不到，被成为经典类（旧式类）。3.0中会识别到（新式类就是后面加了object的类，保证定义的类都是新式类）。
14.多态（多个子类对象，继承同一个父类，但结果不一样）,起增加代码灵活度的效果
15.类是一个特殊的对象，也有类属性，类方法
类属性：在类定义下方，直接用赋值语句即可。
类方法：
语法：
@classmethod
def 方法名(cls):
在外部调用类方法：类名.类方法（）
静态方法：
语法：@staticmethod # 如果不需要访问实例属性和类属性，就定义静态方法
16.单例：
定义：就是单个实例，让两个对象的地址一模一样
__new__方法，给对象分配空间，返回引用，传递给__init__。
17.异常
异常捕获：
try:
# 尝试执行的代码
pass
except 错误类型1:
# 针对错误类型1，对应的代码处理
pass
except 错误类型2:
# 针对错误类型2，对应的代码处理
pass
except (错误类型3, 错误类型4):
# 针对错误类型3 和 4，对应的代码处理
pass
except Exception as result:
# 打印错误信息
print(result)
else:
# 没有异常才会执行的代码
pass
finally:
# 无论是否有异常，都会执行的代码
print("无论是否有异常，都会执行的代码")
抛出异常： raise Exception("异常提示信息")。在调用时候，使用 except Exception as result中resul的返回值。
18.模块
模块的导入：import 模块名。使用的时候，需要 模块名.工具名
模块的别名：import 模块名 as 别名
别名命名规则：大驼峰命名法，单词首字母大写，单词之间没有下划线
模块部分导入：
from 模块名 import 工具名，工具名可以是全局变量，函数，类等
这样做的好处是在后期使用时候不需要 模块名.的方式，可以直接使用工具
如果从两个不同模块中，导入了两个同名的工具，会执行后面导入的工具，后面的覆盖之前的
模块的导入：from 模块名 import *，这样就可以导入模块中的所有工具，使用时候不需要 模块名.工具名的方式调用模块。使用方便。但是不推荐使用，出现问题时候不好排查。
查看模块的位置路径：print(random.__file__)
模块导入顺序：先搜索自己定义的，如果自己没有定义就会去系统内部搜索
模块导入，执行：if __name__ == "__main__":
模块顺序：官方模块、第三方模块、应用程序模块
19.包
包里面包含多个模块，导入包，就可以一次性导入包内的所有模块
包内必须包含：__init__.py。里面通过from . import 模块名，导入所有模块进行包装
调用：先import 包。再通过 包名.模块名.工具来调用包即可
20.制作发布压缩包步骤，分享程序
1).创建setup.py文件：通过如下代码定义压缩包信息，将其复制到setup文件当中
from distutils.core import setup
setup(name="sf_message", # 包名,必须要与要打包的包名一致
version="1.0", # 版本
description="dzx的 发送和接收消息模块", # 描述信息
long_description="完整的发送和接收消息模块", # 完整描述信息
author="zhixin", # 作者
author_email="zhixindeng66@163.com", # 作者邮箱
url="www.itheima.com", # 主页
# 下面的模块名要以列表的方式列出来，并且名字必须一一对应
# 最主要的就是最后一个步骤，需要以列表的形式指定压缩包中
py_modules=["sf_message.send_message",
"sf_message.receive_message"])
2).构建模块
在终端中进入setup所在目录
运行：python3 setup.py build（要制作哪个版本的模块，就使用哪个版本的解释器执行！）
3).生成发布的压缩包
运行：python3 setup.py sdist
4).安装模块
运行--> 解压：tar -zxvf hm_message-1.0.tar.gz
跳转到解压的目录里面，再运行安装程序
安装：sudo python3 setup.py install
5).卸载模块
跳转到目录：cd /usr/local/lib/python3.5/dist-packages/
目录查找方法：先进入ipython3，导入需要卸载的模块，运行：模块名.__file__，即可查看目录
运行删除命令：sudo rm -r hm_message*
6).在终端中运行
先进入ipython
再导入模块
调用工具使用即可。
21.pip安装第三方模块
安装和卸载命令如下：
1).将模块安装到 Python 2.x 环境
$ sudo pip install pygame
$ sudo pip uninstall pygame
2).将模块安装到 Python 3.x 环境
$ sudo pip3 install pygame
$ sudo pip3 uninstall pygame
3).在 Mac 下安装 iPython
$ sudo pip install ipython
4).在 Linux 下安装 iPython
$ sudo apt install ipython
$ sudo apt install ipython3
22.文件
文本文件：可以使用文本编辑器直接查看的文件
二进制文件：需要有专门的软件直接查看的。但其实两种文件都是以二进制方式存储在计算机中的。
文件操作三步骤：1.打开。2.读、写。3.关闭
文件指针：默认放在文件的开始。当执行了read后，指针会放在读取内容的末尾
文件的打开：file = open("文件名","访问方式")
r 以只读方式打开文件。文件的指针将会放在文件的开头，这是默认模式。如果文件不存在，抛出异常
w 以只写方式打开文件。如果文件存在会被覆盖。如果文件不存在，创建新文件
a 以追加方式打开文件。如果该文件已存在，文件指针将会放在文件的结尾。如果文件不存在，创建新文件进行写入
r+ 以读写方式打开文件。文件的指针将会放在文件的开头。如果文件不存在，抛出异常
w+ 以读写方式打开文件。如果文件存在会被覆盖。如果文件不存在，创建新文件
a+ 以读写方式打开文件。如果该文件已存在，文件指针将会放在文件的结尾。如果文件不存在，创建新文件进行写入
文件的读：text = file.read()，file.read()读取的值返回给text
文件的写：file.write("hello-you1223")
文件的关闭：file.close()
小文件内容的复制，利用file.write（text）
大文件内容的赋值，利用readline一行一行地读取写入
23.文件/目录操作（创建、重命名、删除、改变路径、查看目录内容等）
先调用os模块
文件命令： 重命名，os.rename(原文件名, 目标文件名)
删除文件，os.remove(文件名)
目录命令：
listdir 目录列表 os.listdir(目录名) 目录名要加引号，并且要使用后缀/，或者可以用.表示当前目录
mkdir 创建目录 os.mkdir(目录名)
rmdir 删除目录 os.rmdir(目录名)
getcwd 获取当前目录 os.getcwd()
chdir 修改工作目录 os.chdir(目标目录)
path.isdir 判断是否是文件 os.path.isdir(文件路径)
23.将help的输出保存至文件
import os
import sys
out = sys.stdout
sys.stdout = open("help--.txt", "w")
help()
sys.stdout.close()
sys.stdout = out
24.计算机中的编码：ASCII编码和UNICODE编码。UTF-8是属于UNICODE编码（1-6个字节），一般一个汉字占用3个字节
python2只能识别ASCII编码，发现中文，python解释器会报错。
如果希望python2解释器能识别中文，就需要在文件的第一行执行：# *-* coding:utf8 *-*
在终端python2中执行文件：python 123.py，如果文件中有中文，就会运行出错，需要在第一行加上# *-* coding:utf8 *-*
为了遍历，需要在定义有中文的字符串引号前加上u
25.eval计算器
eval会将括号内的内容引号去掉，自动计算里面的值
在开发中别滥用eval：别直接转换过input的结果，不然可以通过命令对文件进行删除等操作
*********************************************pygame模块*************************************************
1.使用方法： 先导入pygame模块。
标准步骤(三步)：先初始化pygame.init(), 游戏代码， pygame.quit()
2.坐标系：
原点在左上角（0,0）, x轴水平向右增加，y垂直向下增加
在游戏中，所有可见的元素，都是以矩形区域 来描述位置的
Rect描述矩形区域四个要素： (x,y) (width,height), xy是左上区域的坐标位置，width和height指定准确大小
3.pygame 专门提供了一个类 pygame.Rect 用于描述 矩形区域: screen = pygame.display.set_mode((480,700))
4.绘制图片步骤： # 1.加载图像数据
bg = pygame.image.load("图片目录")
# 2.blit绘制图像blit(加载的图片，位置坐标)
screen.blit(bg, (0, 0))
# 3.update 更新屏幕显示
pygame.display.update()
5.update，可以将全部图像绘制完成以后，再调用update更新
6.动画效果
将图片连续快速地切换
一般在电脑上有一个高品质的效果，每秒要绘制60次，每次绘制的结果被称为帧.
进入游戏循环，先要进行游戏初始化：1.设置游戏窗口。2.绘制图像的初始位置。3.设置游戏时钟。
游戏循环：1.设置刷新帧率。2.检测用户交互。3.更新所有图像位置。4.更新屏幕显示。
帧率设置：pygame.time.Clock().tick(60)
7.事件监听：event_list = pygame.event.get()， if len(event_list) > 0: print(event_list)
8.窗口退出： for event in pygame.event.get(): if event.type == pygame.QUIT: print("游戏退出……")
pygame.quit()， exit()
9.精灵（可以储存 图像数据 和 图像位置 的 对象）：pygame.sprite.Sprite （第一个sprite是模块名，第二个是类名）
10.精灵组（让组中的精灵各自绘制各自的图像）：pygame.sprite.Group
11.类补充：如果一个类的父类不是object，在重写初始化方法之前一定要先super 一下父类的 __init__方法，保证父类中实现的方法能够正常执行
12.常量命名：字母全部大写，单词之间用下划线连接。常量是不变的数值。
13.pygame.timer，定时器
14.self.kill()与self.__del__(self)相对应
