Python入门（四）- 面向对象及关键字

Aalen86

已于 2022-06-26 15:39:36 修改

阅读量844

点赞数

分类专栏： Python 文章标签： python 开发语言

于 2022-06-14 15:26:45 首次发布

本文链接：https://blog.csdn.net/aalen86/article/details/125263530

版权

Python 专栏收录该内容

34 篇文章 11 订阅

订阅专栏

读者肯定听过 Python 中“一切皆对象”的说法，但可能并不了解它的具体含义，只是在学习的时候听说 Python 是面向对象的编程语言，本节将向大家详细介绍 Python 面向对象的含义。
一定要记住“一切皆对象”这句话，对理解后面的内容会很有帮助。
很多教程把这章的内容放在后面讲解，造成大家不理解各个名词的含义，例如：函数、关键字、方法、属性、类（其实各种基础数据类型在Python中也是类的实例）、实例、对象等。
为了便于大家理解接下来所讲的内容，我把这章提前讲解。

4.1 面向对象

面向对象编程是在面向过程编程的基础上发展来的，它比面向过程编程具有更强的灵活性和扩展性。面向对象编程是程序员发展的分水岭，很多初学者会因无法理解面向对象而放弃学习编程。

面向对象编程（Object-oriented Programming，简称 OOP），是一种封装代码的方法。其实，在前面章节的学习中，我们已经接触了封装，比如说，将乱七八糟的数据扔进列表中，这就是一种简单的封装，是数据层面的封装；把常用的代码块打包成一个函数，这也是一种封装，是语句层面的封装。
代码封装，其实就是隐藏实现功能的具体代码，仅留给用户使用的接口，就好像使用计算机，用户只需要使用键盘、鼠标就可以实现一些功能，而根本不需要知道其内部是如何工作的。

本节所讲的面向对象编程，也是一种封装的思想，不过显然比以上两种封装更先进，它可以更好地模拟真实世界里的事物（将其视为对象），并把描述特征的数据和代码块（函数）封装到一起。

打个比方，若在某游戏中设计一个乌龟的角色，应该如何来实现呢？使用面向对象的思想会更简单，可以分为如下两个方面进行描述：
从表面特征来描述，例如，绿色的、有 4 条腿、重 10 kg、有外壳等等。
从所具有的的行为来描述，例如，它会爬、会吃东西、会睡觉、会将头和四肢缩到壳里，等等。

如果将乌龟用代码来表示，则其表面特征可以用变量来表示，其行为特征可以通过建立各种函数来表示。参考代码如下所示：

class tortoise:
    bodyColor = "绿色"
    footNum = 4
    weight = 10
    hasShell = True
    #会爬
    def crawl(self):
        print("乌龟会爬")
    #会吃东西
    def eat(self):
        print("乌龟吃东西")
    #会睡觉
    def sleep(self):
        print("乌龟在睡觉")
    #会缩到壳里
    def protect(self):
        print("乌龟缩进了壳里")

注意，以上代码仅是为了演示面向对象的编程思想，具体细节后续会做详细介绍。

因此，从某种程序上，相比较只用变量或只用函数，使用面向对象的思想可以更好地模拟现实生活中的事物。

不仅如此，在 Python 中，所有的变量其实也都是对象，包括整形（int）、浮点型（float）、字符串（str）、列表(list)、元组(tuple)、字典（dict）和集合（set）。以字典（dict）为例，它包含多个函数供我们使用，例如使用 keys() 获取字典中所有的键，使用 values() 获取字典中所有的值，使用 item() 获取字典中所有的键值对，等等。

4.2 面向对象相关术语

在系统学习面向对象编程之前，初学者要了解有关面向对象的一些术语。当和其他人讨论代码的时候，或者尝试查找我们遇到的问题的解决方案时，知道正确的术语会很有帮助。

面向对象中，常用术语包括：
类：可以理解是一个模板，通过它可以创建出无数个具体实例。比如，前面编写的 tortoise 表示的只是乌龟这个物种，通过它可以创建出无数个实例来代表各种不同特征的乌龟（这一过程又称为类的实例化）。
对象：类并不能直接使用，通过类创建出的实例（又称对象）才能使用。这有点像汽车图纸和汽车的关系，图纸本身（类）并不能为人们使用，通过图纸创建出的一辆辆车（对象）才能使用。
属性：类中的所有变量称为属性。例如，tortoise 这个类中，bodyColor、footNum、weight、hasShell 都是这个类拥有的属性。

对象.属性

方法：类中的所有函数通常称为方法。不过，和函数所有不同的是，类方法至少要包含一个 self 参数（后续会做详细介绍）。例如，tortoise 类中，crawl()、eat()、sleep()、protect() 都是这个类所拥有的方法，类方法无法单独使用，只能和类的对象一起使用。
使用方法为：

对象.方法（）

关于类的详细介绍会放在后面章节。

4.3 函数

函数就是一段封装好的，可以重复使用的代码，它使得我们的程序更加模块化，不需要编写大量重复的代码。

函数可以提前保存起来，并给它起一个独一无二的名字，只要知道它的名字就能使用这段代码。函数还可以接收数据，并根据数据的不同做出不同的操作，最后再把处理结果反馈给我们。
函数分为两种：

内置函数
自定义函数

4.3.1 dir()和help()帮助函数

开始介绍函数之前，我们先介绍两个对于初学者很重要的两个函数：dir（）和help（）。
dir() 函数用来列出某个类或者某个模块/类中的全部内容，包括变量、方法、函数和类等，它的用法为：

dir(obj)

obj 表示要查看的对象。obj 可以不写，此时 dir() 会列出当前范围内的变量、方法和定义的类型。

Python help() 函数用来查看某个函数或者模块的帮助文档，它的用法为：

help(obj)

obj 表示要查看的对象。obj 可以不写，此时 help() 会进入帮助子程序。

掌握了以上两个函数，我们就可以自行查阅 Python 中所有方法、函数、变量、类的用法和功能了。

【实例】使用 dir() 查看字符串类型（str）支持的所有方法：

>>> dir(str)
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', 
'__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', 
'__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', 
'__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', 
'__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', 
'__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 
'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 
'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier',
 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 
 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex',
  'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith',
   'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

在 Python 标准库中，以__开头和结尾的方法都是私有的，不能在类的外部调用。

【实例】使用 help() 查看 str 类型中 lower() 函数的用法：

>>> help(str.lower)
Help on method_descriptor:

lower(self, /)
    Return a copy of the string converted to lowercase.

可以看到，lower() 函数用来将字符串中的字母转换为小写形式，并返回一个新的字符串。

注意，使用 help() 查看某个函数的用法时，函数名后边不能带括号，例如将上面的命令写作help(str.lower())就是错误的。

4.3.2 内置函数

上一章我们看到了内置函数的清单（），现在教大家怎么查看所有的内置函数：
方法一：

首先先打开python自带的集成开发环境IDLE或者任何你计划使用的IDE，或者终端。
然后我们直接输入"dir( _ _builtins _ _)",需要注意的是builtins左右的下划线都是两个。
回车之后我们就可以看到python所有的内置函数。

方法二：

我们直接在IDLE中输入"import builtins",然后输入"dir(builtins)",
然后回车，同样的这个方法也可以得到所有的python内置的函数
这里我们可以使用python内置函数len（）来查看python内置函数的个数，这里我们直接输入"len(dir(builtins))"
回车之后我们可以看到系统返回值153，说明我们现在这个版本中有153个内置函数。

最后我们介绍一个比较有用的内置函数"help"，python内置函数有一百多个，我们当然不能记住所有的函数，这里python提供了一个"help"函数，我们来看一个例子一起来体会一下help函数的用法.

这里我们直接输入"help(len)",然后回车，会看到系统给我们对于内置函数"len"的解释，当然对于其他函数可能会有更加详细的解释以及用法提示。
接下来我们介绍几个前期常用的内置函数。

4.3.2.1 内置函数input（）

input() 是 Python 的内置函数，用于从控制台读取用户输入的内容。input() 函数总是以字符串的形式来处理用户输入的内容，所以用户输入的内容可以包含任何字符。

input() 函数的用法为：

str = input(tipmsg)

说明：
str 表示一个字符串类型的变量，input 会将读取到的字符串放入 str 中。
tipmsg 表示提示信息，它会显示在控制台上，告诉用户应该输入什么样的内容；如果不写 tipmsg，就不会有任何提示信息。

【实例】input() 函数的简单使用：

a = input("Enter a number: ")
b = input("Enter another number: ")
print("aType: ", type(a))
print("bType: ", type(b))
result = a + b
print("resultValue: ", result)
print("resultType: ", type(result))
运行结果示例：
Enter a number: 100↙
Enter another number: 45↙
aType:  <class 'str'>
bType:  <class 'str'>
resultValue:  10045
resultType:  <class 'str'>

↙表示按下回车键，按下回车键后 input() 读取就结束了。

本例中我们输入了两个整数，希望计算出它们的和，但是事与愿违，Python 只是它们当成了字符串，+起到了拼接字符串的作用，而不是求和的作用。

我们可以使用 Python 内置函数将字符串转换成想要的类型，比如：
int(string) 将字符串转换成 int 类型；
float(string) 将字符串转换成 float 类型；
bool(string) 将字符串转换成 bool 类型。
此处不用深入理解，后面我们会介绍数据类型。
修改上面的代码，将用户输入的内容转换成数字：

a = input("Enter a number: ")
b = input("Enter another number: ")
a = float(a)
b = int(b)
print("aType: ", type(a))
print("bType: ", type(b))
result = a + b
print("resultValue: ", result)
print("resultType: ", type(result))
运行结果：
Enter a number: 12.5↙
Enter another number: 64↙
aType:  <class 'float'>
bType:  <class 'int'>
resultValue:  76.5
resultType:  <class 'float'>

关于 Python 2.x
上面讲解的是 Python 3.x 中 input() 的用法，但是在较老的 Python 2.x 中情况就不一样了。Python 2.x 共提供了两个输入函数，分别是 input() 和 raw_input()：
Python 2.x raw_input() 和 Python 3.x input() 效果是一样的，都只能以字符串的形式读取用户输入的内容。
Python 2.x input() 看起来有点奇怪，它要求用户输入的内容必须符合 Python 的语法，稍有疏忽就会出错，通常来说只能是整数、小数、复数、字符串等。

比较强迫的是，Python 2.x input() 要求用户在输入字符串时必须使用引号包围，这有违 Python 简单易用的原则，所以 Python 3.x 取消了这种输入方式。

修改本节第一段代码，去掉 print 后面的括号(此处也事2.x与3.x的区别)：

a = input("Enter a number: ")
b = input("Enter another number: ")
print "aType: ", type(a)
print "bType: ", type(b)
result = a + b
print "resultValue: ", result
print "resultType: ", type(result)
在 Python 2.x 下运行该代码：
Enter a number: 45↙
Enter another number: 100↙
aType:  <type 'int'>
bType:  <type 'int'>
resultValue:  145
resultType:  <type 'int'>

4.3.2.2 内置函数print（）

使用 print() 函数时，都只输出了一个变量，但实际上 print() 函数完全可以同时输出多个变量，而且它具有更多丰富的功能。

print() 函数的详细语法格式如下：

print (value,...,sep='',end='\n',file=sys.stdout,flush=False)

从上面的语法格式可以看出，value 参数可以接受任意多个变量或值，因此 print() 函数完全可以输出多个值。例如如下代码:

user_name ＝ 'Charlie'
user_age = 8
#同时输出多个变量和字符串
print("读者名：",user_name,"年龄：",user_age)
运行上面代码，可以看到如下输出结果：
读者名： Charlie 年龄： 8

从输出结果来看，使用 print() 函数输出多个变量时，print() 函数默认以空格隔开多个变量，如果读者希望改变默认的分隔符，可通过 sep 参数进行设置。例如输出语句：

#同时输出多个变量和字符串，指定分隔符
print("读者名：" ,user_name,"年龄：",user_age,sep='|')
运行上面代码，可以看到如下输出结果：
读者名：|Charlie|年龄：|8

在默认情况下，print() 函数输出之后总会换行，这是因为 print() 函数的 end 参数的默认值是“\n”，这个“\n”就代表了换行。如果希望 print() 函数输出之后不会换行，则重设 end 参数即可，例如如下代码：

#设置end 参数，指定输出之后不再换行
print(40,'\t',end＝"")
print(5O,'\t',end＝"")
print(60,'\t',end＝"")

上面三条 print() 语句会执行三次输出，但由于它们都指定了 end＝""，因此每条 print() 语句的输出都不会换行，依然位于同一行。运行上面代码，可以看到如下输出结果：

40    50    60

file 参数指定 print() 函数的输出目标，file 参数的默认值为 sys.stdout，该默认值代表了系统标准输出，也就是屏幕，因此 print() 函数默认输出到屏幕。实际上，完全可以通过改变该参数让 print() 函数输出到特定文件中，例如如下代码：

f = open("demo.txt","w")#打开文件以便写入
print('沧海月明珠有泪',file=f)
print('蓝回日暖玉生烟',file=f)
f.close()

上面程序中，open() 函数用于打开 demo.txt 文件，接连 2 个 print 函数会将这 2 段字符串依次写入此文件，最后调用 close() 函数关闭文件，教程后续章节还会详细介绍关于文件操作的内容。

print() 函数的 flush 参数用于控制输出缓存，该参数一般保持为 False 即可，这样可以获得较好的性能。

有没有发现跟Linux的print（）函数很类似？
使用输入输出函数时，有一个问题我们经常会涉及到，那就是转移字符。

4.3.2.3 转义字符

ASCII 编码为每个字符都分配了唯一的编号，称为编码值。在 Python 中，一个 ASCII 字符除了可以用它的实体（也就是真正的字符）表示，还可以用它的编码值表示。这种使用编码值来间接地表示字符的方式称为转义字符（Escape Character）。

转义字符以\0或者\x开头，以\0开头表示后跟八进制形式的编码值，以\x开头表示后跟十六进制形式的编码值，Python 中的转义字符只能使用八进制或者十六进制。具体格式如下：

\0dd
\xhh
dd 表示八进制数字，hh 表示十六进制数字。

ASCII 编码共收录了 128 个字符，\0和\x后面最多只能跟两位数字，所以八进制形式\0并不能表示所有的 ASCII 字符，只有十六进制形式\x才能表示所有 ASCII 字符。

我们一直在说 ASCII 编码，没有提及 Unicode、GBK、Big5 等其它编码（字符集），是因为 Python 转义字符只对 ASCII 编码（128 个字符）有效，超出范围的行为是不确定的。

字符 1、2、3、x、y、z 对应的 ASCII 码的八进制形式分别是 61、62、63、170、171、172，十六进制形式分别是 31、32、33、78、79、7A。下面的例子演示了转义字符的用法：

str1 = "Oct: \061\062\063"
str2 = "Hex: \x31\x32\x33\x78\x79\x7A"
print(str1)
print(str2)
运行结果：
Oct: 123
Hex: 123xyz

注意，使用八进制形式的转义字符没法表示 xyz，因为它们的编码值转换成八进制以后有三位。

对于 ASCII 编码，0~31（十进制）范围内的字符为控制字符，它们都是看不见的，不能在显示器上显示，甚至无法从键盘输入，只能用转义字符的形式来表示。不过，直接使用 ASCII 码记忆不方便，也不容易理解，所以，针对常用的控制字符，C语言又定义了简写方式，完整的列表如下。
也就是使用‘'开头的字符，被赋予了特殊的含义，有别于字面意思。
表 1 Python 支持的转义字符

转义字符	说明
\n	换行符，将光标位置移到下一行开头。
\r	回车符，将光标位置移到本行开头。
\t	水平制表符，也即 Tab 键，一般相当于四个空格。
\a	蜂鸣器响铃。注意不是喇叭发声，现在的计算机很多都不带蜂鸣器了，所以响铃不一定有效。
\b	退格（Backspace），将光标位置移到前一列。
\	反斜线
’	单引号
"	双引号
\	在字符串行尾的续行符，即一行未完，转到下一行继续写。

转义字符在书写形式上由多个字符组成，但 Python 将它们看作是一个整体，表示一个字符。

Python 转义字符综合示例：

#使用\t排版
str1 = '网站\t\t域名\t\t\t年龄\t\t价值'
str2 = 'Python学习\thttps://editor.csdn.net/'
str3 = '百度\t\twww.baidu.com\t\t20\t\t500000W'
print(str1)
print(str2)
print(str3)
print("--------------------")
# \n在输出时换行，\在书写字符串时换行
info = "Python教程：https://editor.csdn.net/Python\n\
C++教程：https://editor.csdn.net/C++\n\
Linux教程：https://editor.csdn.net/Linux/"
print(info)
运行结果：
网站        域名                年龄    价值
Python学习 https://editor.csdn.net/     8       500W
百度        www.baidu.com       20      500000W
--------------------
Python教程：https://editor.csdn.net/Python
C++教程：https://editor.csdn.net/C++
Linux教程：https://editor.csdn.net/Linux/

4.3.2.4 格式化输出

前面讲到过 print() 函数的用法，这只是最简单最初级的形式，print() 还有很多高级的玩法，比如格式化输出，这就是本节要讲解的内容。
熟悉C语言 printf() 函数的读者能够轻而易举学会 Python print() 函数，它们是非常类似的。

转换说明符
print() 函数使用以%开头的转换说明符对各种类型的数据进行格式化输出，具体请看下表。

在这里插入图片描述

转换说明符（Conversion Specifier）只是一个占位符，它会被后面表达式（变量、常量、数字、字符串、加减乘除等各种形式）的值代替。

【实例】输出一个整数：

age = 1
print("我开始学习Python %d 年了" % age)
运行结果：
我开始学习Python 1 年了

在 print() 函数中，由引号包围的是格式化字符串，它相当于一个字符串模板，可以放置一些转换说明符（占位符）。本例的格式化字符串中包含一个%d说明符，它最终会被后面的 age 变量的值所替代。

中间的%是一个分隔符，它前面是格式化字符串，后面是要输出的表达式。

当然，格式化字符串中也可以包含多个转换说明符，这个时候也得提供多个表达式，用以替换对应的转换说明符；多个表达式必须使用小括号( )包围起来。请看下面的例子：

name = "Python学习"
age = 1
url = "https://editor.csdn.net/"
print("%s已经%d岁了，它的网址是%s。" % (name, age, url))
运行结果：
Python学习已经1岁了，它的网址是https://editor.csdn.net/。

总之，有几个占位符，后面就得跟着几个表达式。

指定最小输出宽度
当使用表1中的转换说明符时，可以使用下面的格式指定最小输出宽度（至少占用多少个字符的位置）：

%10d 表示输出的整数宽度至少为 10；
%20s 表示输出的字符串宽度至少为 20。

请看下面的演示：

n = 1234567
print("n(10):%10d." % n)
print("n(5):%5d." % n)
url = "https://editor.csdn.net/"
print("url(35):%35s." % url)
print("url(20):%20s." % url)
运行结果：
n(10):   1234567.
n(5):1234567.
url(35):           http://c.biancheng.net/python/.
url(20):http://c.biancheng.net/python/.

从运行结果可以发现，对于整数和字符串，当数据的实际宽度小于指定宽度时，会在左侧以空格补齐；当数据的实际宽度大于指定宽度时，会按照数据的实际宽度输出。

你看，这里指定的只是最小宽度，当数据的实际宽度足够时，指定的宽度就没有实际意义了。

指定对齐方式
默认情况下，print() 输出的数据总是右对齐的。也就是说，当数据不够宽时，数据总是靠右边输出，而在左边补充空格以达到指定的宽度。Python 允许在最小宽度之前增加一个标志来改变对齐方式，Python 支持的标志如下：

Python 支持的标志

标志	说明
-	指定左对齐
+	表示输出的数字总要带着符号；正数带+，负数带-。
0	表示宽度不足时补充 0，而不是补充空格。

几点说明：
对于整数，指定左对齐时，在右边补 0 是没有效果的，因为这样会改变整数的值。
对于小数，以上三个标志可以同时存在。
对于字符串，只能使用-标志，因为符号对于字符串没有意义，而补 0 会改变字符串的值。

请看下面的代码：

n = 123456
# %09d 表示最小宽度为9，左边补0
print("n(09):%09d" % n)
# %+9d 表示最小宽度为9，带上符号
print("n(+9):%+9d" % n)
f = 140.5
# %-+010f 表示最小宽度为10，左对齐，带上符号
print("f(-+0):%-+010f" % f)
s = "Hello"
# %-10s 表示最小宽度为10，左对齐
print("s(-10):%-10s." % s)
运行结果：
n(09):000123456
n(+9):  +123456
f(-+0):+140.500000
s(-10):Hello     .

指定小数精度
对于小数（浮点数），print() 还允许指定小数点后的数字位数，也即指定小数的输出精度。

精度值需要放在最小宽度之后，中间用点号.隔开；也可以不写最小宽度，只写精度。具体格式如下：

%m.nf
%.nf

m 表示最小宽度，n 表示输出精度，.是必须存在的。

请看下面的代码：

f = 3.141592653
# 最小宽度为8，小数点后保留3位
print("%8.3f" % f)
# 最小宽度为8，小数点后保留3位，左边补0
print("%08.3f" % f)
# 最小宽度为8，小数点后保留3位，左边补0，带符号
print("%+08.3f" % f)
运行结果：
   3.142
0003.142
+003.142

以上两个内置函数会在后续学习中应用比较频繁，所以拿到这里讲解，其他函数的讲解请查看 Python入门（六）- 内置函数详解

4.3.3 自定义函数

自定义函数涉及的内容比较多，现在我们刚刚入门，没必要一下子都搞清楚，会打消积极性，所以函数的知识放在后面的章节。

4.4 关键字

前面我们介绍了关键字的查询方法，现在我们来详细讲解其中重要的关键字。

>>> import keyword
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 
'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 
'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is',
 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 
 'try', 'while', 'with', 'yield']

4.4.1 断言assert

Python 断言，即 Python assert 语句，简单理解就是简易版的 if 语句，
用于判断某个表达式的值，结果为 True，程序运行，否则，程序停止运行，抛出 AssertionError 错误。

语法格式如下所示：

assert 表达式

类比 if 语句，如下所示：

if not 表达式:
	raise AssertionError

在 assert 表达式之后，可以增加一个参数 [, arguments]，等价的 if 语句如下所示：

if not 表达式:
	raise AssertionError(arguments)

例如，在游戏里面设置一个未满 18 岁禁止访问的功能。

def overage18(age):
    assert age >= 18, "对不起未满18岁，无法进行游戏"
    print("享受欢乐游戏时光")

if __name__ == '__main__':
    overage18(15)

但是这个案例并不是一个完美的案例，因为断言是为了告知开发人员，你写的程序发生异常了。
如果一个潜在错误在程序编写前就能考虑到，例如程序运行时网络中断，这个场景就不需要使用断言。

断言主要为调试辅助而生，为的是程序自检，并不是为了处理错误，程序 BUG 还是要依赖 try… except 解决。

由于断言是给开发人员看的，所以下述案例的断言是有效的。

def something():
	"""该函数执行了很多操作"""
	my_list = [] # 声明了一个空列表
	# do something
	return my_list

def func():
	"""调用 something 函数，基于结果实现某些逻辑"""
	ret = something()
	assert len(ret) == 18, "列表元素数量不对"
	# 完成某些操作

使用断言要注意：
不要用断言验证用户的输入，这是因为 python 通过命令行运行时，如果增加 -O 标识，断言就被全局禁止了，你的所有验证就都丢失了。

常用断言函数

assertEqual(a,b,msg=msg)：判断两个值是否相等；
assertNotEqual(a,b,msg=msg)：上一函数的反义；
self.assertTrue(a,msg=none)：判断变量是否为 True；
assertFalse(a,msg=none)：同上反义；
assertIsNone(obj=‘’)：判断 obj 是否为空；
assertIsNotNone(obj=‘’)：同上反义；