1.基础语法
1.1注释
- Python 使用#作为单行注释的符号：
#注释内容
- Python 使用三个连续的单引号 ‘’’ 或 三个连续的双引号 “”" 注释多行内容：
'''
使用 3 个单引号分别作为注释的开头和结尾
可一次性注释多行内容
'''
"""
使用 3 个双引号分别作为注释的开头和结尾
可一次性注释多行内容
"""
1.2缩进
- 和其它程序设计语言（如 Java、C 语言）采用大括号“{ }”分隔代码块不同，Python 采用代码缩进和冒号来区分代码块之间的层次。
- Python 要求属于同一作用域中的各行代码，缩进量必须一致，但具体缩进量为多少，不做硬性规定。（通常情况下采用 4 个空格长度，即一个Tab键作为缩进长度）
示例：
height=float(input("输入身高：")) #输入身高
weight=float(input("输入体重：")) #输入体重
bmi=weight/(height*height) #计算BMI指数
#判断身材是否合理
if bmi<18.5:
#下面 2 行同属于 if 分支语句中包含的代码，因此属于同一作用域
print("BMI指数为："+str(bmi)) #输出BMI指数
print("体重过轻")
if bmi>=18.5 and bmi<24.9:
print("BMI指数为："+str(bmi)) #输出BMI指数
print("正常范围，注意保持")
if bmi>=24.9 and bmi<29.9:
print("BMI指数为："+str(bmi)) #输出BMI指数
print("体重过重")
if bmi>=29.9:
print("BMI指数为："+str(bmi)) #输出BMI指数
print("肥胖")
若同一级别代码块的缩进量不一样，则会报SyntaxError异常错误。例如，对上面代码做缩进改动，如下所示，则会报错。
if bmi<18.5:
print("BMI指数为："+str(bmi)) #输出BMI指数
print("体重过轻")
1.3字符串
字符串是字符的有序序列，可以对其中的字符进行索引。例如：“请”是“请输入数值”中的第0个字符。
两种索引方式：从左往右以 0 开始，从右往左以 -1 开始。
字符串截取的语法格式：变量 [ 头下标 : 尾下标 : 步长 ]
- 头下标从 0 开始算起，可以是正数或负数；尾下标可为空，表示取到头或尾；步长表示间隔。
- 获取的子字符串包含头下标的字符，但不包含尾下标的字符。
字符串操作符
x+y #连接两个字符串x和y
nx 或 xn #复制n次字符串x
x in s #如果x是s的子串，返回true，否则返回false
字符串处理函数
字符串处理方法
字符串格式化
字符串格式化使用.format()方法，用法如下：
print("{1}:计算机{0}:的CPU占用率为{2}%".format("2018-10-10","C",10))
输出：
C:计算机2018-10-10:的CPU占用率为10%
format() 方法的格式控制
1.5输入与输出
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: 88
Enter another number: 99
aType: <class 'str'>
bType: <class 'str'>
resultValue: 8899
resultType: <class 'str'>
本例中输入了两个整数，但是求和失败，是因为Python 把它们当成了字符串，+号起的是拼接字符串的作用，而不是求和的作用。
若要求和，我们可以将字符串转换成想要的类型，比如：
a = input("Enter a number: ")
b = input("Enter another number: ")
a = int(a)
b = float(b)
print("aType: ", type(a))
print("bType: ", type(b))
result = a + b
print("resultValue: ", result)
print("resultType: ", type(result))
运行结果：
Enter a number: 5
Enter another number: 5.6
aType: <class 'int'>
bType: <class 'float'>
resultValue: 10.6
resultType: <class 'float'>
print( )
print () 函数不只能输出一个变量，还可以同时输出多个变量，而且它具有更多丰富的功能。
print() 函数的详细语法格式为：print
(value,…,sep=‘’,end=‘\n’,file=sys.stdout,flush=False)
可以看出，value 参数可以接受任意多个变量或值，因此 print() 函数完全可以输出多个值。例如：
name = 'A'
age = 8
#同时输出多个变量和字符串
print("读者：",name,"年龄：",age)
运行结果：
读者名： A 年龄： 8
print函数的格式化
1.6标识符
标识符就是一个名字，包括变量名、函数名、类名等等。
- python 中标识符是由字母（A~Z 和 a~z）、数字和下划线组成，但第一个字符不能是数字；
- python 标识符不能和 python 中的保留字相同；
- Python 标识符中的字母是严格区分大小写的，比如说，以下2个变量就是毫无关系的。
number = 0
Number = 0
1.7保留字
- 保留字是 Python 中已经被赋予特定意义的单词，因此在开发程序时，不能用保留字作为标识符。
- Python 是严格区分大小写的，保留字也不例外。所以可以说if是保留字，但IF就不是保留字。
- 在实际开发中，如果使用 Python 中的保留字作为标识符，则解释器会报错。
1.8数据类型
整数
pow(x,y) 表示x的y次方，x与y为整数。
浮点数
浮点数运算会产生不确定尾数。
浮点数运算及比较，一般用round()函数辅助；不确定尾数一般发生在10的-16次方左右，round()十分有效。
print(0.1+0.2)
print(0.1+0.2==0.3)
a=(round(0.1+0.2,1)==0.3) #round(x,d):对x四舍五入，d是小数截取位数
print(a)
输出：
0.30000000000000004
False
True
复数
a+bj被称为复数，其中a是实部，b是虚部
z=1.23e-4+5.6e+89j
print(z.real)#获得实部
print(z.imag)#获得虚部
输出：
0.000123
5.6e+89
数值运算操作符
整数、浮点数与复数之间可以进行混合运算，生成结果为“最宽”类型。
三种类型存在一种逐渐“扩展”的关系：整数→浮点数→复数
例如：123+4.0=127.0（整数+浮点数=浮点数）
2.变量
2.1变量和变量类型
- 变量就是一个名字，需要先赋值再使用。
- 变量要符合标识符的命名规范。
- 变量类型：
2.2数值运算函数
2.2.1.常见
abs(x) #求x绝对值
divmod(x,y) #商余，同时输出商和余数
pow(x,y[,z]) #幂余
round(x[,d]) #四舍五入，d是保留小数位数，默认值为0
max(x1,x2,x3…Xn) #返回最大值
min(x1,x2,x3…Xn) #返回最小值
2.2.2.类型转换
（1）字符串转整型： int(str) ，字符串必须是数字，例如：
a = int('123456789')
print(a)
执行结果：
123456789
（2）浮点型转整型： int(float) ，例如：
a = 10.6
b = int(a) #直接抹去小数部分
print(b)
运行结果：
10
（3）字符串转浮点型： float(str) ，字符串必须是数字，例如：
a = "12.4"
b = float(a)
print(b)
运行结果：
12.4
（4）整型转浮点型：float(int) ，例如：
a = 10
b = float(a)
print(b)
运行结果：
10.0
（5）浮点型转字符串： str(float) ，例如：
a = 10.1
b = str(a)
print(type(b).__name__) #type()是获取数据类型函数
运行结果：
str
2.2.3获取类型信息
常用的获取数据类型信息的函数有 type() 和 isinstance() 两个。
（1）type()
语法是 type(对象) ，返回的是对象的类型，是在内部返回的，如果你不输出它你是看不到的，所以经常会和输出函数print()嵌套使用。
a = 10
print(type(a))
运行结果：
<class 'int'>
class的意思是种类，可以看出 f 是 int 型的数据。
（2）isinstance()
常用来判断数据类型，它返回的是布尔值（True或False），语法是 isinstance(对象，class) 。
#判断10.1是不是整型。
a = 10.1
n = isinstance(a,int) #用n来接收一下结果
print(n)
运行结果：
False
序列切片
切片操作是访问序列中元素的另一种方法，它可以访问一定范围内的元素，通过切片操作，可以生成一个新的序列。
序列实现切片操作的语法格式为：sname [start : end : step]
- sname：表示序列的名称；
- start：表示切片的开始索引位置（包括该位置），若不指定，则默认为 0，即从开头进行切片；
- end：表示切片的结束索引位置（不包括该位置），若不指定，则默认为序列的长度；
- step：表示在切片过程中，隔几个存储位置（包含当前位置）取一次元素；如果省略设置 step 的值，则最后一个冒号可省略。
例如，对字符串“C语言中文网”进行切片：
str="C语言中文网"
#取索引区间为[0,2]之间（不包括索引2处的字符）的字符串
print(str[:2])
#隔 1 个字符取一个字符，区间是整个字符串
print(str[::2])
#取整个字符串，此时 [] 中只需一个冒号即可
print(str[:])
运行结果：
C语
C言文
C语言中文网
list列表
Python 中没有数组，但是有更加强大的列表。
列表可以存储整数、小数、字符串、列表、元组等任何类型的数据，并且同一个列表中元素的类型也可以不同。比如说：
["http://c.abc.net/python/", 1, [2,3,4] , 2.9]
可以看到，列表中可以同时包含字符串、整数、列表、浮点数这些数据类型。
1.创建列表
Python 中创建列表的方法有两种：
1.使用 [ ] 直接创建列表
listname = [element1 , element2 , element3 , ... , elementn]
下面定义的列表都是合法的：
num = [1, 2, 3, 4, 5, 6, 7]
name = ["C语言", "http://c.biancheng.net"]
program = ["C语言", "Python", "Java"]
emptylist = [ ] #列表可以为空
2.使用 list() 函数创建列表
Python 还提供了一个内置函数 list()，使用它可以将其它数据类型转换为列表类型。例如：
#将字符串转换成列表
list1 = list("hello")
print(list1)
#将元组转换成列表
tuple1 = ('Python', 'Java', 'C++', 'JavaScript')
list2 = list(tuple1)
print(list2)
#将字典转换成列表
dict1 = {'a':100, 'b':42, 'c':9}
list3 = list(dict1)
print(list3)
#将区间转换成列表
range1 = range(1, 6)
list4 = list(range1)
print(list4)
#创建空列表
print(list())
运行结果：
['h', 'e', 'l', 'l', 'o']
['Python', 'Java', 'C++', 'JavaScript']
['a', 'b', 'c']
[1, 2, 3, 4, 5]
[ ]
2.访问列表元素
3.删除列表
3.循环结构
遍历循环：for…in
for…in 常用于遍历字符串、列表，元组，字典等。
格式：
for x in y:
循环体
执行流程：x依次表示y中的一个元素，遍历完所有元素循环结束。
例1：遍历字符串
s = "i can say"
for i in s:
print(i)
输出：
i
c
a
n
例2：计数循环
for i in range(1,4):
print(i,end=",")
输出：
1,2,3,
例3：列表遍历循环
for i in [123,"py",456]:
print(i,end=",")
输出：
123,py,456,
无限循环
while 条件:
语句块
#反复执行语句块，直到条件不满足时结束
循环控制保留字
break跳出并结束当前整个循环,执行循环后的语句；
continue结束当次循环,继续执行后续次数循环；
break和continue可以与for和while循环搭配使用。
循环高级用法
循环与else
当循环没有被break语句退出时, 执行else语句块;
else语句块作为"正常"完成循环的奖励;
这里else的用法与异常处理中else用法相似。
异常处理
try…except
程序执行时，首先执行try部分：
如果try报错，就执行except部分；如果try没有报错，程序就会跳过except部分执行。
try:
a=int(input("请输入一个整数："))
print(a**2)
except:
print("输入不是整数")
结果：
请输入一个整数：6
36
请输入一个整数：1.5
输入不是整数
异常处理的高级使用
首先执行语句块1，若其不发生异常，则执行语句块3；若发生异常，则执行语句块2；无论发不发生异常，都会执行语句块4。
try:
语句块1
except:
语句块2
else:
语句块3
finally:
语句块4
4.函数
函数的定义及使用：
1.函数的定义与使用
def 函数名(参数)：#参数为0个或多个，括号必须保留
函数体
return 返回值
求n的阶乘：
#定义一个函数：n的阶乘
def fact(n):
s=1
for i in range(1,n+1):
s=s*i
return s
#调用函数，调用时要给出实际参数
a=fact(10)
print(a)
2.函数定义时，可以为某些参数指定默认值，构成可选参数。
def 函数名(必选参数，可选参数)：#可选参数必须在必选参数之后
函数体
return 返回值
求：n的阶乘除以m
def fact(n,m):
s=1
for i in range(1,n+1):
s=s*i
return s//m
a=fact(10,2) #参数按位置传递
#a=fact(m=2,n=10) 参数按名称传递
print(a)
参数传递
函数调用时，参数可以按位置传递，也可以按名称方式传递。
函数返回值
函数可以返回0个或多个结果。
return保留字用来传递返回值。
函数可以有返回值，也可以没有，可以有return，也可以没有。
return可以传递0个返回值,也可以传递任意多个返回值。
局部变量和全局变量
局部变量：函数体内的变量
全局变量：函数体外的变量
规则1：
加上 global 保留字，可以在函数内部使用全局变量：
规则2：
函数运算结束后，局部变量被释放，因此输出全局变量。
递归
递归即自己调用自己，其一般由函数与分支结构相结合；
一个简单实例来理解递归的调用过程：
def fact(n):
if n==0:
return 1
else:
return n*fact(n-1)
a=fact(5)
print(a)
实例2：
def f(n):
if n==1 or n==2:
return 1
else:
return f(n-1)+f(n-2)
5.常用函数
5.1range函数
range函数是Python中的内置函数，用于生成一系列连续的整数，一般用于for循环体中。
函数语法：range(start, stop[, step])
- start：计数从 start 开始。默认从 0 开始，例如range (5) 即range(0，5);
- stop：计数到 stop 结束，但不包括 stop。例如：range (0， 5) 是[0, 1, 2, 3, 4]；
- step：步长，默认为1。例如：range(0，5) 即range (0, 5, 1)
例1：
for i in range(1,4):
print(i)
1
2
3
例2：
for m in range(3):
print(m)
0
1
2
例3：
#range函数的反向输出
#此时结束值为-1，而-1取不到，因此取0，长是-1，相当于每次-1
for i in range(3,0,-1):
print(i)
3
2
1
5.2format函数
format基本语法与占位符基本一致，通过 { } 和 : 来替代之前的%；在python中主要用于字符串的格式化
1.通过关键字：
print('{time}是{holiday}。'.format(time="今天",holiday="周末"))
输出：
今天是周末。
2.通过位置：
print("time={} holiday={}".format("今天","周末"))
print("{}在{}".format("今天","周末"))
print("{0}在{1}".format("今天","周末"))
print("{1}在{0}".format("今天","周末"))
print('我是{0}，他是{1}，我的名字是{0}'.format('A','B'))
print('我是{1}，他是{0}，我的名字是{1}'.format('A','B'))
print('我是{2}，他是{1}，我的名字是{2}'.format('A','B',"C"))
输出：
time=今天 holiday=周末
今天在周末
今天在周末
周末在今天
我是A，他是B，我的名字是A
我是B，他是A，我的名字是B
我是C，他是B，我的名字是C
3.精度：
# 用 :.nf 来控制输出精度
print('{:.2f}'.format(3.1415926))
print('{:.6f}'.format(3.1415926)) #保留6位小数，6位后四舍五入
print('{:.5f}'.format(3.14)) #保留5位小数，不足补0
输出：
3.14
3.141593
3.14000
4.进制转换：
#b o d x 分别表示二、八、十、十六进制
print('{:b}'.format(20))
print('{:o}'.format(20))
print('{:d}'.format(20))
print('{:x}'.format(20))
输出：
10100
24
20
14
5.千位分隔符：
# 用 :, 对千位数字进行分割
print('{:,}'.format(100))
print('{:,}'.format(1000))
print('{:,}'.format(123456.789))
100
1,000
123,456.789
5.3eval函数
5.4lambda函数
其返回函数名作为结果。
lambda函数是一种匿名函数，即没有函数名；
使用lambda保留字定义，函数名是返回结果；
lambda函数用于定义简单的、能够在一行内表示的函数。
函数名 = lambda 参数 : 表达式
等价于：
def 函数名(参数)：
函数体
return 返回值
示例：
f=lambda x,y:x+y #定义一个函数f，他有两个参数x和y，运算内容为x+y
a=f(10,15)
print(a)
结果：
25
f=lambda :"lambda函数" #没有参数
print(f())
结果：
lambda函数
6.库
time库
time库的使用
- ctime()
- gmtime()
import time
print(time.ctime()) #ctime()获取当前系统时间即北京时间，返回字符串
结果：
Sat Jul 9 10:05:20 2022
import time
print(time.gmtime()) #gmtime()获取格林尼治时间（英国标准时间），输出为计算机可处理的时间格式；与ctime()有8h时间差
结果：
time.struct_time(tm_year=2022, tm_mon=7, tm_mday=9, tm_hour=2, tm_min=10, tm_sec=41, tm_wday=5, tm_yday=190, tm_isdst=0)
时间格式化
将时间以合理的方式展示出来。
使用strftime(tpl, ts)函数：
tpl是格式化模板字符串,用来定义输出效果，ts是计算机内部时间类型变量。
import time
t =time. gmtime( )
print(time. strftime("%Y-%m-%d %H:%M:%S",t))
结果：
2022-07-09 01:57:51
程序计时
程序计时指，测量起止动作所经历时间的过程。
- 测量时间：perf_counter()
返回一个CPU级别的精确时间计数值，单位为秒；由于这个计数值起点不确定，连续调用差值才有意义。
import time
start=time.perf_counter()
end=time.perf_counter()
print(start,end,end-start)
输出：
1863237.2333477 1863237.2333488 1.100124791264534e-06
- 产生时间：sleep(s)
s为拟休眠的时间，可以是浮点数。单位是秒。
import time
def wait():
time.sleep(6.5)
wait() #程序将等待6.5秒后再退出
random库
random库主要用于生成随机数。random库包括两类函数，常用共8个。
基本随机数函数: seed(, random()
扩展随机数函数: randint( ), getrandbits( ), uniform( ), randrange( ), choice( ), shuffle( )
7.类与对象
定义
定义类：
class 类名( )：
多个（≥0）类属性...
多个（≥0）类方法...
创建对象：
对象名 = 类名( )
在定义类方法时，会自动包含一个名为 self 的参数，且作为第一个参数。
根据下面程序运行结果可知：self指的是调用wash函数的对象，即haier.
class Washer(): #定义一个类
def wash(self): #在类中添加方法时，会自动添加self的参数
print('洗衣服')
print(self)
haier=Washer() #定义一个对象
print(haier)
haier.wash() #用对象调用wash函数
结果：
<__main__.Washer object at 0x00000258B104D000>
洗衣服
<__main__.Washer object at 0x00000258B104D000>
一个类还可以创建多个对象，且多个对象的地址不同：
class Washer(): #定义一个类
def wash(self): #在类中添加方法时，会自动添加self的参数
print('洗衣服')
print(self)
haier1=Washer() #定义一个对象
haier1.wash()
haier2=Washer() #定义一个对象
haier2.wash()
输出：
洗衣服
<__main__.Washer object at 0x0000021D0E8FD000>
洗衣服
<__main__.Washer object at 0x0000021D0E8FDBA0>
对象属性
1.类外添加对象属性
对象名.属性名=值
2.类外获取对象属性
对象名.属性名
实例：
class Washer(): #定义一个类
def wash(self): #在类中添加方法时，会自动添加self的参数
print('洗衣服')
haier=Washer() #定义一个对象haier
haier.width=500 #为对象haier 在类外添加属性
haier.height=800
print(f"haier洗衣机的宽度是{haier.width}") #类外获取对象属性
print(f"haier洗衣机的高度是{haier.height}")
输出：
haier洗衣机的宽度是500
haier洗衣机的高度是800
3.类内获取对象属性
self.属性名
实例：
class Washer(): #定义一个类
def wash(self): #在类中添加方法时，会自动添加self的参数
print('洗衣服')
print(self.width)
haier=Washer() #定义一个对象haier
haier.width=500 #为对象haier 在类外添加属性
haier.wash() #对象调用方法
输出：
洗衣服
500
_ _ init _ _( )类构造方法
在创建类时，可以手动添加一个 _ _ init_ _( ) 方法，该方法具有一些特殊功能，称为构造方法或构造函数。
理解：相当于在创造洗衣机类时，就为其赋予一些与生俱来的属性。
_ _ init _ _( ) 类在创建对象时默认被调用；
_ _ init _ _( self ) 中的self参数，不需手动传递，Python解释器会将其自动传递。
若构造函数有多个参数时，需要手动传递参数。
class Washer(): #定义一个类
def _ _init_ _(self): #定义__init__，并添加实例属性
self.width=500
def print_info(self):
print(f'洗衣机的宽度是{self.width}') #类内调用实例属性
haier=Washer() #定义一个对象haier
haier.print_info() #对象调用方法
结果：
洗衣机的宽度是500
带参数的 _ _ init _ _( )
class Washer():
def _ _init_ _(self,width,height):
self.width=width
self.height=height
def print_info(self):
print(f'洗衣机的宽度是{self.width},高度是{self.height}')
haier=Washer(500,800) #如果不传参，则报错
haier.print_info()
输出：
洗衣机的宽度是500,高度是800
_ _ str_ _ ( )
当使用print输出对象时，默认打印对象的内存地址，如果定义了_ _ str_ _ ( )方法，那么就会打印从这个方法中return的数据.
class Washer():
def __init__(self):
self.width=500
def __str__(self):
return '解释说明'
haier=Washer()
print(haier)
输出：
解释说明
_ _ del _ _ ( )
当删除对象时，Python解释器也默认调用_ _ del _ _ ( )方法。
class Washer():
def __init__(self,width,height):
self.width=width
self.height=height
def __del__(self):
print(f'{self}对象已被删除')
haier=Washer(10,20)
输出：
<__main__.Washer object at 0x000001E395A9C910>对象已被删除
实例-搬家
class Furniture():
def __init__(self,name,area):
self.name=name
self.area=area
class Home():
def __init__(self,address,area):
self.address=address
self.area=area #总面积
self.free_area=area #剩余面积
self.furniture=[] #家具列表
def __str__(self):
return f'房子位于{self.address},占地面积{self.area},剩余面积{self.free_area},家具包括{self.furniture}'
def add_furniture(self,item): #容纳家具
if self.free_area>=item.area:
self.furniture.append(item.name)
self.free_area-=item.area
else:
print('剩余面积不足，无法容纳')
bed=Furniture('床',10)
home=Home("武汉",200)
home.add_furniture(bed)
print(home)
ball=Furniture('球场',200)
home.add_furniture(ball)
print(home)
输出：
房子位于武汉,占地面积200,剩余面积190,家具包括['床']
剩余面积不足，无法容纳
房子位于武汉,占地面积200,剩余面积190,家具包括['床']
8.继承
8.1单继承与多继承
继承多用于创建和现有类功能相似的新类。
实现继承的类称为子类，被继承的类称为父类（也可称为基类、超类）
子类继承父类时，只需在定义子类时，将父类（可为多个）放在子类之后的圆括号里即可。
语法：
class 类名(父类1, 父类2, ...)：
#类定义部分
注：如果该类没有显式指定继承自哪个类，则默认继承 object 类（object 类是 Python中所有类的父类，即要么是直接父类，要么是间接父类）。
另外，Python 的继承是多继承机制（和 C++ 一样），即一个子类可以同时拥有多个直接父类。
多继承经常需要面临的问题是，多个父类中包含同名的类方法。对于这种情况，要根据子类继承多个父类时，这些父类的前后次序决定，即排在前面父类中的类方法会覆盖排在后面父类中的同名类方法。
class A:
def __init__(self):
self.name = A
def say(self):
print("A类", self.name)
class B:
def __init__(self):
self.name = B
def say(self):
print("B类", self.name)
# A中的name属性和say()会遮蔽B类中的
class C(A, B):
pass
u = C()
u.name = "李华"
u.say()
结果：
A类 李华
父类方法重写
父类方法重写指的是，若子类从父类继承得来的类方法中，有个别类方法，子类无法使用，必须对其进行修改的情况。
class Bird:
def isWing(self): #鸟有翅膀
print("鸟有翅膀")
def fly(self): #鸟会飞
print("鸟会飞")
#鸵鸟虽然也是鸟类，有翅膀，但它不会飞。针对这种情况，可以这样定义鸵鸟类：
class Ostrich(Bird):
def fly(self): #重写Bird类的fly()方法
print("鸵鸟不会飞")
a = Ostrich() #创建Ostrich对象
a.fly() #调用的是Ostrich类中重写的fly()类方法
输出：
鸵鸟不会飞
也就是说，如果子类中重写了从父类继承来的方法，那么在类外通过子类对象调用该方法时，Python 将执行子类中重写的方法。
那么若想调用父类中的原始方法，如何做？
Python 中的类可看做是一个独立空间，而类方法是该空间中的一个函数。而如果想要全局空间中，调用类空间中的函数，只需要在调用该函数是备注类名即可。
class Bird:
def isWing(self): #鸟有翅膀
print("鸟有翅膀")
def fly(self): #鸟会飞
print("鸟会飞")
#鸵鸟虽然也是鸟类，有翅膀，但它不会飞。针对这种情况，可以这样定义鸵鸟类：
class Ostrich(Bird):
def fly(self): #重写Bird类的fly()方法
print("鸵鸟不会飞")
a = Ostrich() #创建Ostrich对象
Bird.fly(a) #调用Bird类中的fly()方法
输出：
鸟会飞
8.2mro
mro用来显示类之间的继承关系与顺序：
class A:
def __init__(self):
self.name = A
def say(self):
print("A类", self.name)
class B:
def __init__(self):
self.name = B
def say(self):
print("B类", self.name)
class C(A, B):#A中的name属性和say()会遮蔽B类中的
pass
u = C()
u.name = "李华"
u.say()
print(C.__mro__)#查找类的继承关系、顺序
结果：
A类 李华
(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)
super( )函数
语法：
super().__ init __(self,…)
详细介绍：
http://c.biancheng.net/view/2290.html
type( )函数 ：创建类
语法：
type(name, bases, dict)
name 表示类的名称；
bases 表示一个元组，其中存储的是该类的父类；
dict 表示一个字典，用于表示类内定义的属性或者方法。
def say(self):#定义一个实例方法
print("我要学 Python！")
CLanguage = type("CLanguage",(object,),dict(say = say, name = "C语言中文网"))#使用 type() 函数创建类
clangs = CLanguage()#创建一个 CLanguage 实例对象
clangs.say()#调用say()方法
print(clangs.name)#调用name属性
注意：Python元组语法规定，当 (object,) 元组中只有一个元素时，最后的逗号不能省略
结果：
我要学 Python！
C语言中文网
95
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
