Python入门学习笔记

Znnjcidmslz

已于 2022-07-21 17:43:56 修改

阅读量311

点赞数

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

于 2022-07-10 22:59:25 首次发布

本文链接：https://blog.csdn.net/weixin_45216861/article/details/123995376

版权

Python 专栏收录该内容

9 篇文章 3 订阅

订阅专栏

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
1
1

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)

运行结果：

（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))

输出：

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属性