python无实际意义的语句_python入门随笔笔记

人生苦短，我用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)相对应