Python 3.0 学习知识要点

这是我学习《Python编程：从入门到实践》时做的笔记，希望能给各位学习python 的同学提供帮助。

Python 3.0 学习知识要点

第一章：输出与输入

输出

print（）

字符串输出

print("你好"+str(a))

将a以字符串的形式输出

输入

input

a=input("请输入您想要输入的内容：")

输入整数

a=int(input())

否则默认str

字符或字符串

可以后续转换

a=int(b)

python 2.7

raw_input()

第二章：变量与简单数据类型

变量名

1、变量名只能包含字母、数字、下划线

2、变量名不能以数字开头

3、变量名不能包含空格

4、不能使用Python关键词和函数名做变量名

5、尽量不要使用小写字母 i 和大写字母O

字符串

1、字符串可以使用双引号“”或单引号‘’来标识运行

双引号里不能再次包含双引号，只能包含单引号！

2、方法通常一般在变量的后面加点 . 在加方法，且后面都加（）进行详细的操作命令

例如：print(name.title())

3、常用的方法函数收集

每个单词首字母大写

title（）

全部大写

upper（）

全部小写

lower（）

合并字符串——拼接

full_变量名3=变量名1+变量名2

添加制表符

\t

换行符

\n

可以同时使用，用在""之内

删除字符串末尾的空白（空格）

.rstrip()

删除字符串开头空白（空格）

.lstrip()

两者都删除

.strip()

字符串中间的空格不能被删除

方法是可以几种不同方法相嵌入而成的

set(sortde())

4、合理使用双引号和单引号，建议尽量使用双引号标识字符串

5、Python3.0中print输出一定要加（）

6、字符串同样支持 + 的运算

b=a+" nince"+d

前提是 b\a\d都是字符串类型数据

可以添加空格 “ ”

换句话说，同类型数据可以支持 + 的运算

数字

整数

+ - * \

乘方运算

**

整数乘以代数不能省略

2*b

可以做一次性复杂的运算（能遵从数学运算顺序）

求模运算

求余运算

返回余数值

%

例如：4%3

返回 1

浮点数（小数）

运算同整数功能一致

使用Python 2.0 时注意除法运算必须有一个除数指定为浮点数

3.0/2

避免类型错误

str（）

把非字符串或字符的变量转成字符（串）类型

注意

print前面不能加空格，否侧无法正常输出

加空格表示归属于上一句程式的内容，不能执行print的输出功能

自增运算

例如：a+=b

相当于：a=a+b

注释

用#标识注释内容，其后面内容直接跳过忽略

作用

个人项目

避免忘记相关目的等内容，方便记忆

合作项目

告知合作者代码的作用以及相关目的，便于合作理解

Python 之禅

作用

获得对Python 编程指导帮助

代码

import this

几条原则

+=

一个变量存储多条信息

a="" a+=""

当执行print(a)时，两条信息都会输出

a+=语句可以任意数量

自增语句

a=+1

相当于b=a+1，a=b

第三章：列表

列表含义

作用

一个变量名存储多个变量数据单元（元素）

使用

[ ]

例如：a=['1','2','3']

即便是双引号输入，但是输出是单引号

列表的使用合集

1、访问列表的元素

例如：a[2]

注意：列表的第一个元素是从0开始的

可以与字符串章节的功能语法联合使用

例如： a[2].title()

访问最后一个元素

a[-1]

以此类推访问倒数第N个元素

a[-N]

2、修改列表元素

修改列表元素

a[3]="yamaha"

添加元素

a.append("您好")

添加到末尾

括号内可以进行算法

a.append(b**2)

b的值进行平方后增加到a列表中

插入元素

a.insert(2,"您好")

把您好插入到2号位

删除元素

del a[3]

a.pop()

删除最后一个元素

删除第n个元素

a.pop(n-1)

删除元素的同时并调用该元素

b=a.pop()

根据元素内容删除

a.remove("您好")

一次使用仅能删除一个元素

可以通过转存数据再删除实现删除数据的调用

重复的元素值需要用到循环判断程序

3、组织列表

作用：修改列表元素的顺序

常用表命令集合

排序

1、根据首字母（假设全部小写）排序（从a到z）

a.sort()

根据首字母反向拍序

a.sort(reverse=True)

操作具有永久性，不可逆回

注意：该程序无法直接使用到 print() 语句中

2、临时根据首字母的排序

sorted(a)

临时倒序

sorted(a,reverse=True)

注意：

汉字的排序是根据汉字字体的标准大纲来排序的，如果需要根据拼音排序需要额外的程序进行转换

倒序处理（非排序，原始倒序输出）

a.reverse()

永久性处理

再次恢复原序列

再次使用 reverse()

注意：该程序无法直接使用到 print() 语句中

列表长度

len()

从1开始计算，结果无误

第四章：操作列表

1、历遍整个列表

将列表a的每个元素显示出来

for b in a :

依次把a中的元素储存到b中，然后执行下个 程序

下一个程序执行完后再次执行for in 语句

执行for循环操作的语句的程序一定要缩进

for操作执行后，仅保留for操作语句最后一次的操作数据

注意冒号不要遗漏

2、创建数值列表

创建数列

range(a,n)

仅创建a到（n-1）的数列

并非列表

竖向打印数字

for sex in range (a,n)

创建数值列表

list(range(a,n))

偶数集合

a=list(range(2,20,2))

第一个2表示从2开始创建数值

20表示创建后的数值范围在20以内，不包括20

最后一个2表示数值加2

葵花宝典

先进行可易于理解的功能代码实现

在进行审核进行代码精简化

查看数值列表元素操作

最小值

print(min(a))

最大值

print(max(a))

总和

print(sum(a))

列表解析

一行解析代码运算完成一个数值列表几行代码的复杂的创建

a=[b**2 for b in range(2,10)]

解析运算

a=[]

for b in range(2,10)

c=b**2

a.append(c)

3、使用列表的一部分

切片

print(a[0:3])

输出0~3的元素，但是不包含位置3的元素

注意：第n个元素是位置为n-1的元素

print(a[:3])

没有指定第一个元素位置时，默认从第一个元素开始

print(a[2:])

没有指定末尾一个元素位置时，默认到最后一个元素开始

print(a[-2:])

输出倒数最后2个元素

历遍切片

for a in b[1:4]

复制列表

a=b[:]

全部复制

a=b[1:3]

以切片的形式复制

截取信息

注意：a[]=b[] 表示两个列表一模一样，任何一个列表的变化都将引起另一个列表做出相同的变化

4、元组（不可以修改的列表元素）

定义元组

子主题 1

第五章：if 语句

if语句

if :

条件测试

True

执行if 语句后面的程序

默认非空字符

False

忽略if语句后面的程序

默认为空字符

比较语句

等于

==

注意：if 语句在执行相等判断时，是要区分大小写的

不等于

！=

小于

大于

>

小于等于

大于等于

>=

多条件比较

并行多条件

and

单行多条件

or

建议将比较的条件用（）圈起来，增加易读性

特定值是否在列表中

在列表中？

if "a" in b

不在列表中？

if "a" not in b

布尔表达式

自定义True和False的命名标记

game_active = True

can_edit = False

条件语句常见结构

普通IF结构

if - else 结构

一个条件

if elif else 结构

条件超过2个的情形

多次使用 elif

有且只能满足一个条件时，后面语句直接跳过

串联结构

只要有一条件通过便结束

多if结构

多个条件都可以同时查询并给出指示

并联结构

无论哪一个条件是否通过所有if都要执行

if 用于列表

1、检查特殊元素

for in 下加入 if 结构 对特定值进行操作

2、确定列表是否为空集

if 下用 for 列举

if a :

for b in a :

3、多个列表

for in 下使用 if in

第六章：字典

概念

字典是用来储存数据的，数据量大小无限制，并且是动态的

简单字典

a={"键":"值"}

{ }

"键":"值"

键

值

数字

字符串

列表

字典

键：值 是一对的

访问字典的值

print(a["color"])

直接访问键

字典的全局输出

print(a)

添加键—值对

a["键"]=值

在字典中键—值的顺序无关要紧，只要对应关系正确即可

创建字典

一般先创建字典空集，再逐步增加键—值，增加字典元素

a={}

a["b"]="c"

a["d"]=e

修改字典中的值

a["键"]="新值"

删除键—值

del a["键"]

大内容的字典的创建

字典拆分行，键—值，一行一行的写

遍历字典

可遍历的内容

键—值

键

值

遍历方法

1、遍历整个字典

for x,y in a.items()

x用于储存键

y用于储存值

a.itmes()

字典名.方法

核心代码

2、历遍字典所有的键

a.keys()

按照顺序历遍所有的键

例如：sorted(a.keys())

3、历遍字典所有的值

a.values()

去掉重复项

set(a.values())

嵌套

字典嵌套到列表

方式一

先定义字典 a_1={"颜色":"黄色","分数":"10"}

在定义列表 b=[a_1,a_2,a_3]

方式二

先定义列表 a=[]

用for in 方法和 a.appen() 的方法嵌入到列表中

列表嵌套到字典

直接在字典中嵌入列表内容

a={"c":["2","3","4","5"]}

列表名=键

列表内容=值

列表仅做为值嵌入列表

字典嵌套到字典

同上者

字典名=键

字典内容=值

第七章：while循环

概念

循环运行代码，直到不满足结束循环

与 for 的区别

for 一般针对集合型元素处理 如列表 字典等

受元素个数控制

while 条件循环运作，不受元素数量控制

while循环的使用

简单使用

while a<=5：

while 后面跟循环条件

符合条件执行后面的程序

不符合条件，立即终止

用户选择退出

基本思想：用户指定一个文本值，当 不 符合这个文本值，就退出

while a！=“退出”

即只有输入退出才会退出

使用标志

c=True while c:

当c为True时执行循环，为False跳出循环

break 的使用

控制循环语句流程

用 break 结束当前循环（仅作执行语句，不作为条件语句）

任何循环语句都可用采用break

for if while 等等

continue 的使用

两个执行语句

1、遇到countinue终止，保存当前数据，停止执行后面语句

2、然后返回到循环开头继续执行

避免无限循环

Ctrl + C 关闭终端窗口

用while 处理列表与字典

优势，可以涂在循环中对元素更改，不要跟踪。

1、列表之间的元素的移动

while a:

对列表a进行循环处理

列表a为空集时跳出循环

a.pop

列表a从删除元素（一次一个）

b.append

给列表b添加元素

2、删除包含有特定值的所有列表元素

while "b" in a:

当检测“b”在列表a中时执行如下循环

直到检测不出“b”跳出循环

a.remove("b")

将元素“b”从列表a中删除

3、使用用户输入填充字典

a={}

创建字典空集

b=input()

创建 键 的内容

c=input()

创建 值 的内容

a[b]=c

将键和值关联起来并存储到字典a中

需要加额外的标记控制循环

控制字典是否还要添加输入

d=True

设置循环条件初始值

while d:

进入循环

if ***:

对d循环条件设置变动条件

d=False

对while 跳出循环

第八章：函数

概念

定义

用于完成具体工作的，有名字的代码块

作用

实现程序的多次调用，提高生产效率

可以在一个函数中调用另一个函数

简单使用

1、定义简单函数

def a():"""函数说明“”“

def

定义函数

a():

函数名

： 后面跟函数体（具体要执行的程序）

”“”函数说明“”“

3个”号 文档字符串 注释用

调用

a()

调用函数，执行函数体内容

2、向函数传递信息

函数名（）内加入需要传递的信息

定义时

def a(b):

这里的 （）内是形参，就是变量名

调用时

a("您好！")

这里的（）内是实参，变量值

工作时候，将值传递给形参，即b="您好！"

3、print 输出内容仅在函数体内可执行，函数体外无法执行，有错误！

传递实参

1、实参

1、位置实参

实参与形参顺序一致

定义时

def a(b,c):

定义了b,c两个形参

调用时

a("何远东","28岁")

定义两个实参

b=“何远东”,c="28岁"

与形参的位置顺序相对应

可以多次调用，实参根据需求定义

实参可以是纯数字类型，无需加 “”

2、关键字实参

在调用的时候就直接把形参与实参关联起来，避免了顺序的问题，既顺序随便，但一定关联。

调用时

a(b="何远东",c="28岁")

也可以是a(c="28岁",b="何远东")

3、默认值

在定义的时候就直接把形参与实参关联起来。

调用时，只对未设置默认值的实参赋值

遇到需要调整的，需求非默认的，可以使用关键字实参进行改动和调用

等号 = 两边不要有空格！

3种函数方式根据使用情况灵活编写调用程序，实现多种调用对形参和实参赋值

2、实参传递

1、传递任意数量的实参

def a(*b):

*b 是一个元组，可以存放任意数量的实参

2、使用任意数量的关键字实参

def a(**b):

**b 为创建空字典

可以接收任意数量的键—值对

返回值

概念

定义

函数返回的值

作用

1、函数不一定要直接输出显示，仅返回可用的数值即可

2、将繁重的计算任务通过返回值转到函数去完成

1、简单的返回值

return

2、让实参变成可选的

形参提供初始默认值

用 if else 语句处理形参使之变成可选的（既执行需要的运行条件）

3、返回字典

函数体内部制作字典，并与形参进行关联即可

4、函数与其他结构联合使用

传递列表

外置列表，再将列表传达给函数形参

在函数中修改列表值（永久性的）

在函数体中实现修改

禁止函数修改列表

传递列表的副本即可

[:] 创建列表副本

函数储存在模块中

作用

1、实现与主程序的分离

2、储存为独立的模块文件，实现多次调用和文件的共享

方法

1、导入模块

1、先编写函数程序（纯粹的函数程序）保存为.py文件

创建函数模块

2、创建编写主体函数

3、主题函数调用模块函数

import a

打开文件名为 a 的函数模块文件，并复制函数程序

a.b(23,"c")

调用，指明 函数文件名a 以及函数程序的函数名b

2、导入特定的函数

导入一个函数

from 模块名（文件名） import 函数名

导入多个函数

from 模块名 import 函数名1，函数名2，函数名3

3、用 as 为函数指定别名

作用：避免与主题程序的设置的形参名有冲突，或搞个简称替代

from 模块名（文件名） import 函数名 as 别名

4、用 as 为模块指定别名

import 模块名 as 别名

后面的调用就直接使用别名

5、导入模块中所有函数

from 模块名（文件名） import *

用 * 表示所有函数

a("b")

调用时，实参赋值仍然需要指明函数名a

不推荐使用该种方法

易于主体程序有冲突

函数编写指南与注意事项

1、如果形参很多，导致函数定义的长度超过了79字符，可在函数定义中输入左括号后按回车键，并在下一行按两次Tab键，从而将形参列表和只缩进一层的函数体区分开来

2、如果程序或模块包含多个函数，可使用两个空行将相邻的函数分开，这样将更容易知道前一个函数在什么地方结束，下一个函数从什么地方开始。

第九章：类

概念

定义

表述现实某种存在的事物的特性，也可表述虚拟创作的某种事物

类就是将某种事物以数据的形式模拟化

用数据（程序）来描述某种事物

作用

面向对象的编程时，通过类创建对象，完成实例化

模块的共享，与其他程序员实现快速对接和高效的工作

具体内容

简单的创建和使用类

创建类

举例

class Dog():

创建类，首字母大写就表示类

Python 2.7 中

class Dog(object):

"""做出描述解释"""

对类进行描述说明

def _init_(self,name,age)

用函数的形式定义类具有的属性

形参 self 是必须有的，且永远在最前面

用来自动传递实参，做引用使用

形参 name , age

有效的形参

仅对有效的形参传递具体数值

方法 __init__():

Python自动运行它

开头语末尾 __

注意：是双下划线！！！

一种约定

目的是避免默认方法与普通方法在名称上发生冲突

"""对函数进行描述"""

对函数的功能做出说明

self.name=name

以 self 为前缀的变量都可供类中的所有方法使用

可以通过类的任何实例来访问这些变量

该变量成为属性

根据类创建实例

概念

类是方法，是框架

实例是值，是具体的属性参数值

可以创建多个实例运行

实例把值传递到类中

举例

my_dog=Dog("大黄",6)

传递实参

name="大黄"

age=6

my_dog.name

访问属性

等同于：my_dog.name = self.name

my_dog.sit()

调用方法

使用类和实例

使用类修改实例的属性为主要操作

1、类中增加默认值的的属性

例如：self.att=2

只要是给属性赋予默认值，则函数名的（）中无需将该属性写入

2、修改属性的值

3种操作

直接修改属性值

直接访问属性，对属性值进行修改

例如：my_dog.name="阿西吧"

通过方法修改属性值

方法

1、先在类中定义一个函数属性作为中间值

def a(self,b_1):

2、实例编写时调用方法（中间值），给中间值属性赋值

my_dog.a(66)

通过方法对属性进行递增赋值

方法

1、先在类中定义一个函数属性作为中间值

def a(self,b_1):

2、自增程序编写

self.c+=b_1

3、实例编写时调用方法（中间值），给中间值属性赋值

my_dog.a(66)

继承

概念

用类生类

两个类方法属性一致

父类

原有的类

子类

新生成的类

可以新增创建自己的类

作用

更加快速简单的建立新的类

主要内容

1、子类的方法__init__()

直接拿来主义，在原有的类的基础后创建新类

class Bra(Car):

创建新类，指明父类

def __init__(self,make,model,year)

创建新类的方法属性

super().__init__(self,make,model,year)

super() 函数将子类与父类属性关联起来

相当于把子类的属性形参传递给父类的属性形参

my_tesla.get_descriptive_name()

子类实例直接调用父类的方法

2、给子类定义属性和方法

在子类新建一个方法，并给属性形参赋值

只有子类具有该信息，父类不具有的

3、重写父类的方法

使用环境

父类有定义但与子类不相符合时

使用方法

直接在子类中对该方法重新定义

调用时父类方法无效了

4、将实例用作属性

使用环境

实例属性太多，为了便于结构化，将某些方法和属性单独作为放到一个独立的类模块化

可以避免与子类产生混乱

使用方法

1、将需要模块化的方法和属性用类创建出来

Class Battery():

不需要在括号中关联子类

self.battery_size=battery

定义模块中的形参和值

该模块还可添加其他属性信息

2、子类中需要新加关联形参属性并与模块类关联起来

self.battery=Battery()

3、调用时，需要调用子类中关联的形参和关联模块类中的方法

my_tesla.battery.describe_battery()

my_tesla

实例名

battery

子类形参（属性）

describe_size

模块类方法

导入类

目标

文件简洁

繁杂简单化

关注主程序

模块共享化

将类储存在模块中，主程序允许导入这些模块

导入方法

1、导入单个类

1、用类创建模块

文档首行用 ''' '''' 对该模块做出概念性说明

2、创建主体文件调用

调用语句

from ai import Ai

主体实例为形参赋值

2、一个模块中储存多个类

一个模块创建多个类来完成对某一特性的描述

3、从一个模块中导入多个类

调用模块

from car import Car,ElectricCar

import后加上需要调用模块中的类名

同导入多个函数一样

实例给参数

实例1

my_beetle=Car()

实例2

my_tesla=ElectricCar()

根据用户需求不同数量的实例需要对应不同的类

4、导入整个模块

简易版导入模块的类

调用模块

import car

import 后加文件名（模块名）

实例给参数

实例1

my_beetle=car.Car()

实例2

my_tesla=car.ElectricCar()

调用类需要在具体类的前面加上文件名（模块名）句点表示法

5、导入模块中的所有类

from car import *

一般不推荐，因为导入类不易明确

6、从一个模块导入另一个模块

使用环境

一个模块含类太多需要将类划分到其他模块中

模块之间相互关联

运用

模块间相互关联

from car import Car

该语句是另一个模块（非主模块）

调用car主模块

实例调用模块

不同实例各调用各的模块

from car import Car

调用主模块

from electric_car import ElectricCar

调用关联模块

Python 标准库

概念

标准库是一组模块（Python包）

运用

举例调用OrderedDict模块创建一个有序的字典

调用模块

from collection import OrderedDict

使用模块

favorite_languages=OrderedDict()

添加键——值

favorite_languages['jen']='Python'

如需调用外部模块需要下载相关文件使用

类的编码风格

1、命名

类名用驼峰命名法

首字母大写

实例名全部小写

具体描述可以在后面加下划线加上具体说明单词

2、每个类后面应当写下文档字符串

"""这个类（模块）用来干嘛的"""

3、空行分行

类中一个空行分割

模块中可以使用两个空行分割

4、同时调用标准库模块和自己的模块时

先调用标准库模块

空行

再调用创建的模块

第十章：文件和异常

本章学习目标

1、学习处理文件，让程序能快速分析数据

2、学习错误处理，避免程序崩溃

3、学习异常，用于管理程序运行时出现的错误

4、学习json模块，用于保存用户数据，避免数据意外丢失

5、提高程序的适用性、可用性和稳定性

文件

读取文件

1、从文件中读取数据

1、读取整个文件

with open("您的文件名.txt") as file_object:

关键字：with

实现访问文件后自动将其关闭的功能

否则就需要手动编写close（）关闭

方法：open()

接收要打开文件的名称

仅打开与本程序在同一根目录下的文件

VScode 配置

文件名 . 文件格式

as

实现储存

file_object

用于储存文件内容的形参

a=file_object.read()

方法：read()

对file_object的内容进行读取

注意

读取的结果相比源文件后面会多一个空行（read自带功能）

解决：形参后加 .rstrip()

2、文件路径

相对路径

相对于当前程序所在目录

例如：访问当前目录下text_files文件夹下的filename文件

Linux或OS X 系统 open（“text_files/filename.txt"）

Windows系统下是反斜杠 \

绝对路径

直接访问文件实际目录

一般的先将绝对路径储存到一个变量中然后再用open调用

例如Windows系统下：

a="c:\users\ehmatthes\other_files\filename.txt"

open (a)

3、逐行读取

用for方法

消除空行用rstrip()方法

4、创建一个包含文件各行内容的列表

lines=file_object.readlines()

lines 为列表

方法：readlines()

将读取文件内容的每一行并储存到列表lines中

5、使用文件的内容

储存到变量中使用就行了，没啥好说的

6、包含一百万位的大型文件

同上面一样，列表限制访问位数就行

写入文件

1、写入空文件

a="programming"

把要命名的文件名传递给形参a

with open(a,"w") as file_object:

open()

该程序目录中没有与要命名的文件名相同时，自动创建一个文件

新建的文件没有格式，可以用记事本打开查看其内容

有与文件名相同的文件时会直接将改文件内容清空，并重新编辑

a

用形参的方式告诉要创建或打开的文件名

文件模式

“w”

写入模式

"r"

读取模式

"a"

附加模式

"r+"

读取和写入模式

省略模式（默认）

只读模式

file_object.write("我爱你!")

方法 .write()

将指定的内容写入文件

只能将文本以字符串的形式写入

写入数字需要 str() 进行转换

不会在文本末尾添加换行符

2、写入多行

需要在write（）写入的内容中加入换行符 \n

3、附加到文件

在原文件内容不变的情况下加入其它内容

开启附加模式 “a”

异常

概念

Python发生错误是会创建一个异常对象

对错误代码进行新编辑会继续运行

否则停止，并显示 traceback

异常的处理

使用 try-except 代码块处理

告诉程序遇到异常时应该执行什么操作

1、处理 ZeroDivisionError 异常

try-except 代码处理

try:

后面跟导致错误的代码

except ZeroDivisionError:

如果try后面的代码能运行则跳过该代码

如果不能，则执行该代码后面的内容

使用异常避免崩溃

try-except-else

try:

后面跟导致错误的代码

except ZeroDivisionError:

如果try后面的代码能运行则跳过该代码

如果不能，则执行该代码后面的内容

else:

应当返回继续执行try后面的程序

2、处理 FileNotFoundError 异常

一般发生在读取文件的情况下

一般将open（）放入 try: 中

处理

分析文本

a.split()

方法 split() 将一个字符串创建一个单词列表（以空格作为拆分）

使用多个文件

用创建函数的方法调用处理

失败时一声不吭

运行错误是不做任何提示和报错处理

在 except ZeroDivisionError: 后编写 pass

决定报告哪些错误

存储数据

概念

json

存储数据到文件，程序再次运行会加载该文件的数据

在Python之间分享数据

json 最初用于 JavaScript 语言

使用方法

1、json.domp() 与 json.load() 的使用

json.domp()

存储数据

1、import json

调用 json 功能模块

2、a=[]

编写要存储的数据

3、filename=“numbers.json”

给要存储到文件的文件名命名（形参的传递的方式）

json格式

4、with open(numbers,"w") as file_object:

创建文件并以写入的模式打开

5、json.bump(a,file_object)

将数据写入文件

将 a 传递给 file_object

json.load()

数据读取到内存中

1、import json

调用 json 功能模块

3、filename=“numbers.json”

给要打开文件的文件名命名（形参的传递的方式）

json格式

4、with open(numbers,"w") as file_object:

以只读的模式打开文件

5、b=json.load(file_object)

将数据读出入文件

将 file_object 传递给 b

2、保存和读取文件的数据

将 json.dump() 和 json.load() 联合使用

适当加入 try—except 结构

3、重构

概念

使用环境

对代码进一步优化修改或者是增加拓展

思想

将代码划分为一系列完成具体工作的函数

使用方法

将 json.domp() 与 json.load() 拆分到两个不同的函数中运用

第十一章：测试代码

1、测试函数

单元测试与测试用例

概念

单元测试

核实函数某个方面有没有问题

测试用例 = ∑ 单元测试

全覆盖式测试用例 = 一套单元测试

在程序项目被广泛使用时即可以使用，一般情况不用

使用案例

import unittest

先调用 unittest （数据库有的）模块

from a import a_a

调用要测试的文件 a 的 a_a 程序

class Test_care(unittest.TestCare):

创建类用于测试一系列针对 a_a 的单元测试

并继承 unittest.TestCare 类

def test_a_a(self):

创建函数 函数名（方法）必须以 test_ 开头

test_ 开头的方法都将自动运行（在class的类中）

b=a_a('ccs','ssc')

正式调用执行函数 a_a 并赋实参值 ccs 和 ssc

self.assertEqual(b,'CCS SSC')

将 b 的值（a_a运行的结果）与 CCS SSC（应该得到的结果） 进行比较

是（=）

返回 OK

不是（≠）

返回 FAILED

unittest,main()

输出返回值

测试不通过

不要修改测试用的代码

应当修改源代码

添加新测试

增加新的测试用的函数

2、测试类

各种断言方法

概念

检查编程者认为应该满足的条件是否正确满足

unittest.TestCase 类已经提供很多的断言方法

断言返回的值只能为 True 和 False

操作

常见的6种断言方法

assertEqual(a,b)

核实 a==b

assertNotEqual(a,b)

核实 a!=b

assertTrue(x)

核实 x 为 True

assertFalse(x)

核实 x 为 False

assertIn(Item,List)

核实 Item 在 List 中

assertNotIn(Item,List)

核实 Item 在 List 中

使用方法基本和测试函数一样

setUp() 方法

概念

unittes.TestCase 类包含方法 setUp()

仅用于测试

在 setUp() 中创建对象，在每个测试方法多次使用

优先运行 setUp() 方法，再运行 test_ 开头的方法

使用操作

把原来单个测试方法的对象提取出来，用 setUp() 创建出来

def setUp(self):

创建调查对象

创建答案列表

变量名都带 self.

3、测试结果显示含义

没完成一个单元测试，python都会打印一个字符

测试通过时，打印一句点

.

测试错误失败时，打印一个

E

测试导致断言失败时答应一个

F