自动化之python基础，0基础手把手教学，最细的教程通俗易懂
失败只有一种，那就是半途而废！！！
目录
一、变量
二、python数据类型
1、number（数字）
数字类型的转换
数学运算
2、字符串
字符串的运算
3、列表
列表的运算
4、元组
5、集合
三、条件判断if...elif...else语句
1、if...else语句
2、if...elif...else语句
四、while循环
1、break
2、continue
五、for循环
1、range（）函数
2、遍历字典
3、九九乘法表
六、函数
1、函数的作用
2、函数的定义
3、不带参数的函数
4、带参数的函数
5、函数的返回值
6、函数的调用
7、函数的注释
8、函数的传参
8.1、位置参数
8.2、默认参数
8.3、关键字参数
8.4、不定长参数
8.5、不定长键值对
9、函数的作用域
10、global
11、匿名函数
七、类的定义和使用
1、类的定义
2、生成实例
3、__init__()方法
3、__init__()方法带参数
4、类的方法
5、类的属性
6、方法的属性
7、self专题讲解
8、方法中调用另一个方法
9、类的继承
10、父类方法的重写
一、变量
变量是存储在内存中的值，这就说明在创建变量时会在内存中开辟一个空间。根据变量的数据类型，解释器会分配指定内存，并决定什么数据可以被存储在内存中。
(1)变量必须赋值
(2)中间的“=”是赋值的意思
(3)“=”左边是变量名，“=”右边是存储在变量中的值
(4)可以多个变量一起赋值
num1 = 5 # 定义一个变量num1，它的值是数字5
str1 = '蒙恬' # 定义一个str1，它的值是字符串蒙恬
#多个变量一起赋值
num2 = num3 = num4 = 5
str2 , str3 , str4 = "上单" , "AD" , "打野"二、python数据类型
python数据类型有八种，分别是：number(数字)、string(字符串)、Boolean(布尔值)、None(空值)
list(列表)、tuple(元组)、dict(字典)、set(集合)。其中number(数字)、tuple(元组)、string(字符串)都是不可变的。下面就常用的数据类型以及相应的方法做讲解。
number(数字)
数字类型的是不可改变的，当我对num1再次赋值后，原来的10还占用内存空间，只是没人引用了，python的垃圾回收机制会自动回收这个内存空间。
num1 = 10 #这是开辟一个内存空间，里面放的10
num1 = 20 #对num1再次赋值，这个时候是又开辟了一个内存空间里面放的201、number（数字）
number是一个大类型，包含下面几个小类，它们是不可变的：
- int（整型） 1，2，3，-1，-2
- float(浮点数) 1.23 ， 3.69
- bool(布尔值) True 或者False,True 即为‘真’，表示为1；False即为‘假’，表示为‘0’
- 复数 这个用不到，不用管它
num1 = 369
num2 = 3.69
num3 = False
#print()是打印函数
#type()这个方法回返回所传值的类型
print(type(num1)) # 这个是int类型
print(type(num2)) # 这个是float类型
print(type(num3)) # 这个是bool类型
结果：
数字类型的转换：
1、数字类型的转换
- int() 转整型
- float()转浮点型
- bool()非0数字转布尔值都为True
- 0转布尔值为false
- True转整型为1
- False转整型为0
num1 = 369
num2 = 3.69
num3 = 0
num4 = True
num5 = False
print(float(num1)) # int类型转浮点型 369.0
print(int(num2)) # 浮点型转int类型,会把后面的数字粗暴的全部切掉 3
print(bool(num1)) # 非0数字转布尔值 True
print(bool(num3)) # 0转布尔值 False
print(int(num4)) # 布尔值True转int类型 1
print(int(num5)) # 布尔值False转int类型 0
结果：
369.0
3
True
False
1
02、数学运算
- + 加法运算
- - 减法运算
- * 乘法运算
- / 除法运算（结果为浮点数）
- // 除法运算（只保留整数）
- % 取模（求余数）
- ** 幂次方运算
num1 = 2
num2 = 3
num3 = 4
print(num1 + num2) # 加法运算 5
print(num2 - num1) # 减法运算 1
print(num1 * num2) # 乘法运算 6
print(num3 / num1) # 除法运算（结果为浮点数） 2.0
print(num3 // num1) # 除法运算（结果为整数） 2
print(num2 % num1) # 求模运算（求余数) 1
print(num1 ** num2) # 求2的3次方 8
结果：
5
1
6
2.0
2
1
8
2、字符串
python中字符串需要用单引号、双引号、三引号包围，字符串是不可变的
str1 = '天下风云出我辈'
str2 = "一入江湖岁月催"
str3 = '''皇图霸业谈笑中'''
print(type(str1))
print(type(str2))
print(type(str3))
结果：
1、字符串的运算
- + 字符串的拼接
- * 字符串可以和int类型进行运算，就是把字符串重复输出几遍
- 索引 字符串可以根据索引获取某个字符
- 切片 根据索引获取字符串某一段的字符
- len() 获取字符串的长度
str1 = '天下风云出我辈'
str2 = "一入江湖岁月催"
str3 = '''皇图霸业谈笑中'''
print(str1 + str2) # 把两个字符串拼接在一起
print(str1 * 2) # 把str1输出两次
print(len(str1)) # len()方法获取字符串长度
print(str3[0]) # 获取字符串索引为0的字符
print(str3[0:2]) # 字符串的切片，从索引0开始到索引2结束（不包含索引2），顾头不顾尾
结果：
天下风云出我辈一入江湖岁月催
天下风云出我辈天下风云出我辈
7
皇
皇图
3、列表
列表是使用 [ ] 方括号包含各个数据项，列表是可变的，有序
li = [] # 这样就可以定义一个列表（list）
print(type(li))
结果：
1、列表的运算
- + 多个列表的合并
- appand() 在列表末尾添加元素
- pop() pop()中不添加索引默认删除列表最后一个；pop中添加索引，删除对应的元素
- remove() 移除指定值
- reverse() 将列表内容倒序
- sort() 将列表从小到大排序
list1 = [1, 2, 3, 4, 5]
list2 = [6, 7, 8, 9, 10]
print(list1 + list2) # 两个列表合并 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
list3 = ['我是土著1', '我是土著2']
list3.append('我是最后添加的')
print(list3) # 在列表末尾添加元素 ['我是土著1', '我是土著2', '我是最后添加的']
list4 = ['盖聂', '卫庄', '墨玉麒麟']
list4.pop()
print(list4) # pop()中不添加索引，默认删除列表最后一个 ['盖聂', '卫庄']
list5 = ['徐达', '常遇春', '蓝玉']
list5.pop(0)
print(list5) # pop中添加索引，删除对应索引的元素 ['常遇春', '蓝玉']
list6 = ['司徒南', '遁天老祖', '玄罗大天尊', '道一大天尊']
list6.remove('道一大天尊')
print(list6) # 移除指定值 ['司徒南', '遁天老祖', '玄罗大天尊']
list7 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
list7.reverse()
print(list7) # 将列表内容倒序 [9, 8, 7, 6, 5, 4, 3, 2, 1]
list8 = [6, 4, 6, 8, 3, 2, 0, 1]
list8.sort()
print(list8) # 将列表从小到大排序 [0, 1, 2, 3, 4, 6, 6, 8]
list9 = ['朱厚照', '朱由检', '朱允炆', '朱祐樘']
print(list9[0]) # 获取列表索引为0的值 朱厚照
print(list9[1:3]) # 和字符串的切片一样，从索引为1的位置截取，截取到索引为3的位置（不包含3） ['朱由检', '朱允炆']
结果：
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
['我是土著1', '我是土著2', '我是最后添加的']
['盖聂', '卫庄']
['常遇春', '蓝玉']
['司徒南', '遁天老祖', '玄罗大天尊']
[9, 8, 7, 6, 5, 4, 3, 2, 1]
[0, 1, 2, 3, 4, 6, 6, 8]
朱厚照
['朱由检', '朱允炆']4、元组
tuple 是使用 ( ) 小括号包含各个数据，不可修改，有序
tup = () # 定义元组
print(type(tup))
结果：
- 元组无法修改
- 元组可以通过索引获取值
- 元组可以通过切片截取片段
tup1 = (1, 2, 3, 4, 5)
print(tup1[1]) # 获取索引为1的元素 2
print(tup1[1:3]) # 获取从索引1开始到索引3结束的片段（不包含3） (2, 3)
结果：
2
(2, 3)
5、集合
是一个无序不重复元素的序列，用{}包裹，可变
set1 = {'name': '章邯', 'age': 18}
print(type(set1))
结果：
- 列表中每个元素是键值对，例如上图中name就是键，章邯就是值
- 键不能重复，如果重复了，依最后那个为准
- 键必须是Number、String、元组中的一种
- 值可以是任意类型
- 增加 ：给字典中不存在的键赋值就可以新增一个键值对
- 修改 ：给字典中存在的键再赋值一次就可以修改原来的值
- 删除：删除使用del语句
# 添加键值对
dict1 = {'name': '章邯', 'age': 18}
dict1['work'] = '帝国将领' # {'name': '章邯', 'age': 18, 'work': '帝国将领'}
print(dict1)
# 修改键值对
dict2 = {'name': '章邯', 'age': 18}
dict2['age'] = 25 # {'name': '章邯', 'age': 25}
print(dict2)
# 删除键值对
dict3 = {'name': '章邯', 'age': 18}
del dict3['name'] # {'age': 18}
print(dict3)
结果:
{'name': '章邯', 'age': 18, 'work': '帝国将领'}
{'name': '章邯', 'age': 25}
{'age': 18}三、条件判断if...elif...else语句
if语句，若条件判定为真（True），那么后面的语句块就会被执行。若条件判定为假(False)，语句块就会被跳过，不会执行
1、if...else语句
python是以代码缩进区分代码块的，要按Tab键，不要用空格
money = 10
if money > 20: # 如果兜里有二十多块钱，就买利群
print('买盒利群')
else: # 否则就买煊赫门
print('买煊赫门')2、if...elif...else语句
四、while循环
while是一个条件循环语句，如果条件表达式为真（true），while中的代码就会一直循环执行，直到循环条件为假（false）停止。
num1 = 1
while num1 < 5: # 判断条件表达式num1 < 5是都为True，如果是True就往下循环，如果为False就结束循环
print('剑来！！！')
num1 = num1 + 1 # 这个是赋值 先计算右边的num1+1 再赋值给左边的num1
# 第一轮循环：num1 = 1,为True，while往下执行-->打印"剑来"-->num1=num1+1,此时num1=2，进入第二轮循环
# 第二轮循环：num1 = 2,为True，while往下执行-->打印"剑来"-->num1=num1+1,此时num1=3，进入第三轮循环
# 第三轮循环：num1 = 3,为True，while往下执行-->打印"剑来"-->num1=num1+1,此时num1=4，进入第四轮循环
# 第四轮循环：num1 = 4,为True，while往下执行-->打印"剑来"-->num1=num1+1,此时num1=5，进入第五轮循环
# 第五轮循环：num1 = 5,为False，while循环结束。
结果：
剑来！！！
剑来！！！
剑来！！！
剑来！！！1、break
循环语句遇到break立即结束，终止循环
num1 = 1
while num1 < 5: # 判断条件表达式num1 < 5是都为True，如果是True就往下循环，如果为False就结束循环
if num1 == 3:
break # 立即结束整个循环
print('剑来！！！')
num1 = num1 + 1 # 这个是赋值 先计算右边的num1+1 再赋值给左边的num1，达到自增的效果
# 第一轮循环：num1 = 1,为True，while往下执行-->判断不符合if条件-->打印"剑来"-->num1=num1+1,此时num1=2，进入第二轮循环
# 第二轮循环：num1 = 2,为True，while往下执行-->判断不符合if条件-->打印"剑来"-->num1=num1+1,此时num1=3，进入第三轮循环
# 第三轮循环：num1 = 3,为True，while往下执行-->符合if条件-->执行if里面的break，立即结束整个循环
结果：
剑来！！！
剑来！！！2、continue
执行到continue时结束当前轮次的循环
num1 = 1
while num1 < 5: # 判断条件表达式num1 < 5是都为True，如果是True就往下循环，如果为False就结束循环
num1 = num1 + 1 # 这个是赋值 先计算右边的num1+1 再赋值给左边的num1，达到自增的效果
if num1 == 3:
continue # 结束这个轮次的循环，不再执行后面的代码（不打印剑来），直接进入下一轮
print('剑来！！！')
# 第一轮循环：num1 = 1,为True，while往下执行-->判断不符合if条件-->打印"剑来"-->num1=num1+1,此时num1=2，进入第二轮循环
# 第二轮循环：num1 = 2,为True，while往下执行-->判断不符合if条件-->打印"剑来"-->num1=num1+1,此时num1=3，进入第三轮循环
# 第三轮循环：num1 = 3,为True，while往下执行-->符合if条件-->执行if里面的continue，结束这个轮次的循环，不再执行后面的代码（不打印剑来），直接进入下一轮
# 第二轮循环：num1 = 4,为True，while往下执行-->判断不符合if条件-->打印"剑来"-->num1=num1+1,此时num1=5，进入第四轮循环
结果：
剑来！！！
剑来！！！
剑来！！！五、for循环
for循环用于遍历一个序列（列表，元组，字典，集合或字符串）
list1 = ['青云门', '鬼王宗', '焚香谷', '草庙村'] # 定义一个列表
for i in list1: # 遍历这个列表
print(i) # 输出列表中的每一个元素
结果:
青云门
鬼王宗
焚香谷
草庙村1、range（）函数
对一组代码进行指定次数的循环，可以使用range()函数，range()函数返回一个数字序列，默认情况下从0开始，递增1(默认情况下)，到最后一个数字结束。range()函数里面有三个参数（初始值，结束值，步长），步长不写就默认为1
for i in range(1, 10): # range()函数里面有三个参数（初始值，结束值，步长），步长不写就默认为1
print(i) # 打印结果为1 2 3 4 5 6 7 8 9不包括10
结果：
1
2
3
4
5
6
7
8
92、遍历字典
遍历字典和遍历列表、字符串稍微有些区别，
dict1 = {'name': "萧瑟", 'age': 18, 'sex': '男'}
for i in dict1:
print(i) # 这样遍历出来的是字典中的每个键，如果需要获取到对应的值可以print(dict1[i])
结果:
name
age
sex3、九九乘法表
for i in range(1, 10):
for j in range(1, i + 1):
print(f'{i}*{j}={i * j}', end='\t') # f'{i}'这是字符串的格式化，让i以传参的形式传进来，end=''这个是结尾不换行的，\t这是制表符，就相当于按了一下Tab
print() # 这个是换行的意思
结果：
1*1=1
2*1=2 2*2=4
3*1=3 3*2=6 3*3=9
4*1=4 4*2=8 4*3=12 4*4=16
5*1=5 5*2=10 5*3=15 5*4=20 5*5=25
6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36
7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49
8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64
9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81 六、函数
1、函数的作用
函数的作用就是把一些代码封装起来，留一个入口方便你或者同事复用。就像生活中的洗衣机、电视机，那是工厂封装好的，你只需要按一下开关就可以，根本不需要了解内部是怎么实现的。
2、函数的定义
函数定义要用关键字def,参数非必填，函数名有一定的规范一大堆，就记住一条就行：见名知意，不会英语了去百度在线翻译下
def 函数名(参数):
执行语句
return 结果3、不带参数的函数
def add_number():
return 14、带参数的函数
def add_number(a, b):
return a + b
5、函数的返回值
函数的返回值可以有，也可以没有，具体看要达到的目的是什么
def add_number(a, b):
print(a+b) # 这里我就打印一下，不需要返回
def get_sum(a, b):
return a+b6、函数的调用
函数的调用就像洗衣机的开关，你把函数写好了，不调用，就像洗衣机你不按开关一样，它自己不会运行。
不带参数：函数名()
def add_number():
print('空山新雨后')
add_number() #调用函数D:\code\pythonStudy\venv\Scripts\python.exe D:\code\pythonStudy\数据类型.py
空山新雨后
Process finished with exit code 0
带参数：函数名(参数1，参数2...)
def add_number(a, b):
print(a + b)
add_number(1, 5) # 调用函数D:\code\pythonStudy\venv\Scripts\python.exe D:\code\pythonStudy\数据类型.py
6
Process finished with exit code 07、函数的注释
函数如果不加注释，过半个月你自己看着都懵，写明注释，方便自己也方便他人。
def get_sum(num1, num2):
'''''' # 函数写完后，在这里敲六个单引号，然后再按enter键，会自动得到下图的效果
return num1 + num2
def get_sum(num1, num2):
'''
#这一行可以对函数的作用写个说明
:param num1: #说明第一个参数是什么
:param num2: #说明第二个参数是什么
:return: #说明返回值
'''
return num1 + num2
8、函数的传参
8.1、位置参数
位置参数就是传参的时候必须和函数定义的参数一一对应，不能打乱顺序
def get_info(name, adr):
print(name + '家住' + adr)
get_info('张顺', '浔阳江口') # 张顺对应name，浔阳江口对应adr
结果：
张顺家住浔阳江口8.2、默认参数
先给参数设置默认值，调用参数的时候如果没有传参，就使用默认值
def get_info(name, adr='浔阳江口'): # 默认参数一定要在最后面，否则会报错
print(name + '家住' + adr)
get_info('张顺') # 张顺对应name，adr没有传参，就使用默认值
结果：
张顺家住浔阳江口8.3、关键字参数
参数多的时候，为了避免位置传错，可以使用关键字参数生命，这样传参的时候位置错乱也没关系
def get_info(name, adr):
print(name + '家住' + adr)
get_info(adr='浔阳江口', name='张顺') # 张顺对应name，浔阳江口对应adr
结果:
张顺家住浔阳江口
8.4、不定长参数
有时候不确定参数的数量，就用不定长参数，*args
def get_info(name, *args): *是把参数打包成元组
print(name)
print(args) # 返回元组
get_info('张顺', '花荣', '林冲') # 张顺对应name，'花荣'和'林冲'给*args
结果：
张顺
('花荣', '林冲')8.5、不定长键值对
传不定长的键值对用**kwargs
def get_info(**kwargs): **是把键值对打包成字典，kwargs只是个约定俗成的，用其他的也可以，比如**ac
print(kwargs) # 返回元组
get_info(name='花荣', age=18, work='梁山头目') # 参数传键值对
结果：
{'name': '花荣', 'age': 18, 'work': '梁山头目'}9、函数的作用域
在函数里面的变量只能在函数里面使用
def bianliang():
num1 = 10 #在函数内部定义的变量，在函数外面使用会报错
print('aaa')
print(num1)
结果：
NameError: name 'num1' is not defined #没有定义num1这个变量在函数内无法修改函数外面的变量
num1 = 100
def bianliang():
num1 = 10 # 在函数内部无法修改全局变量 此时函数内部的num1=10，函数外面的num1=100
print(num1)
bianliang() # 函数内部的num1=10
print(num1) # 函数外面的num1=100
结果：
10
10010、global
在函数内部需要修改全局变量，则需要使用global关键字进行声明
num1 = 100
def bianliang():
global num1 # 声明一下这是全局变量
num1 = 10 # 此时在函数内部可以修改全局变量 此时函数内部的num1=10，函数外面的num1=10
print(num1)
bianliang() # 函数内部的num1=10
print(num1) # 函数外面的num1=10
结果：
10
1011、匿名函数
就是没有名字的函数，一行可以写完的函数，这个在UI自动化的时候会用到
lambda x, y: x + y # lamdba就是个关键字，类似与def。x,y是参数，x+y是函数体.它就是个正常函数的简写，青春版七、类的定义和使用
补充：类就是把一些具有相同属性的实例抽象出来，比如狗就是一个人们抽象出来的一个模板，狗生下来就有四条腿一个尾巴。说通俗点，狗就是一个类，某一条狗就是实例，狗都会汪汪叫，这就是类的方法
1、类的定义
类的定义使用驼峰命名法比如：ClassName
class Dog: # class关键字创建类，要使用驼峰命名法，约定俗成的规矩，首字母要大写
pass
2、生成实例
类定义完成后需要调用生成实例，生成实例后会开辟一个实例的内存空间，放置这个实例的属性、方法等，比如狗这个类生成实例就是出生一条小狗，在地球上就有一片空间属于这个小狗
class Dog: # class关键字创建类
pass
hashiqi = Dog() # Dog()是生成一个实例对象，这时候一条小哈士奇出生了3、__init__()方法
这个方法，是你生成实例的时候自动执行的，不需要调用，比如一个小狗出生了，它自动就会有条尾巴，__init__方法中必须传一个参数self,这个参数是实例本身，也可以不叫self，自己定义也可以，但不建议
class Dog: # class关键字创建类
def __init__(self):
print('有一条尾巴')
xiaogou = Dog() # Dog()是生成一个实例对象，这时候一条小狗出生了，天生带有一条尾巴3、__init__()方法带参数
参数需要写在self后面，用逗号分隔
class Dog:
def __init__(self, type, name): # 这两个参数必须写在self的后面
print(f'出生了一条{type},名字叫{name}有一条尾巴')
xiaogou = Dog('哈士奇', '哮天犬')
结果：
出生了一条哈士奇,名字叫哮天犬有一条尾巴4、类的方法
类的方法就好比小狗会叫，会摇尾巴，方法必须传self
步骤：1、先生成一个实例(先出生一个小狗)
2、实例再调用方法（小狗再使用它的方法叫）
class Dog:
def __init__(self, type, name): # 这两个参数必须写在self的后面
print(f'出生了一条{type},名字叫{name}有一条尾巴')
def call(self): # 方法名小写字母开头，后面的单词首字母大写
print('小狗会叫')
def wagItsTail(self):
print('摇尾巴')
运行结果：
xiaogou = Dog('哈士奇', '哮天犬') # 这是生成一个实例
xiaogou.call() # 小狗使用它的方法5、类的属性
类的属性是所有实例都可以用的，在方法中可以调用。比如狗身上有毛，会伸舌头
class Dog:
type1 = '长毛'
type2 = '伸舌头'
def __init__(self, type, name): # 这两个参数必须写在self的后面
print(f'出生了一条{type},名字叫{name}有一条尾巴')
def call(self):
print('小狗会叫')
def wagItsTail(self):
print('摇尾巴')
xiaogou = Dog('哈士奇', '哮天犬') # 这是生成一个实例
print(xiaogou.type1) # 小狗使用类属性
print(xiaogou.type2) # 小狗使用类属性6、方法的属性
方法的属性只有在方法内部可以使用
class Dog:
type1 = '长毛'
type2 = '伸舌头'
def __init__(self, type, name): # 这两个参数必须写在self的后面
print(f'出生了一条{type},名字叫{name}有一条尾巴')
def call(self):
type3 = '撕咬'
print('小狗会叫')
def wagItsTail(self):
print(type3) #在call中定义的type3，在wagItsTail中使用就会报错
print('摇尾巴')
运行结果：
Traceback (most recent call last):
File "D:\code\pythonStudy\数据类型.py", line 19, in
xiaogou.wagItsTail()
File "D:\code\pythonStudy\数据类型.py", line 14, in wagItsTail
print(type3)
NameError: name 'type3' is not defined. Did you mean: 'type'? 7、self专题讲解
self是指实例本身，我用Dog()生成一个实例小狗，那这个self就是这个小狗。用下面例子来证明
第一步：生成实例后打印实例，得到实例的地址
第二步：在方法中打印self，调用这个方法，看打印的self的地址
class Dog:
def call(self):
print(f'这是self{self}')
xiaogou = Dog() # 这是生成一个实例
print(f'这是生成的实例{xiaogou}')
xiaogou.call()
运行结果：
这是生成的实例<__main__.Dog object at 0x0000029DC9FFBD60> # self的地址和实例地址是一样的
这是self<__main__.Dog object at 0x0000029DC9FFBD60>8、方法中调用另一个方法
在方法中调用另一个方法需要加self
class Dog:
def call(self):
print('被其他方法调用')
def change(self):
self.call() # 调用其他方法要加self
xiaogou = Dog() # 这是生成一个实例
xiaogou.change() # change()方法调用call()方法
运行结果：
D:\code\pythonStudy\venv\Scripts\python.exe D:\code\pythonStudy\数据类型.py
被其他方法调用了
Process finished with exit code 09、类的继承
类是可以继承的，所有的类都默认继承一个最大的类Object类
类的继承需要在类名后面写，比如Dog(Object)只不过Object是默认继承的，可以不写。
类的继承举个现实中的例子，狗是一个父类，中华田园犬是子类，子类可以继承父类的属性和方法，狗会长尾巴，中华田园犬也会长尾巴
子类可以使用父类的属性和方法，前面要加self。父类无法使用父类的方法。这就好比你爸爸的钱、房子你随便拿，但你爸爸不会找你索取任何东西。
class Dog: # 这是父类
type1 = '会长毛'
def call(self):
print('被其他方法调用了')
class ZhongHuaTianYuanQuan(Dog): # 这是子类，继承父类Dog
def myCall(self):
print(self.type1) # 子类可以使用父类的属性
self.call() # 子类可以使用父类的方法
xiaogou = ZhongHuaTianYuanQuan() # 这是生成一个实例
xiaogou.myCall() # 调用myCall()方法
运行结果：
会长毛
被其他方法调用了10、父类方法的重写
有时候父类的方法无法满足子类的要求，子类就可以对父类的方法进行重写。
class Dog: # 这是父类
type1 = '会长毛'
def call(self):
print('被其他方法调用了')
class ZhongHuaTianYuanQuan(Dog): # 这是子类，继承父类Dog
def call(self):
print('修改父类的方法')
xiaogou = ZhongHuaTianYuanQuan() # 这是生成一个实例
xiaogou.call() # 调用call()方法
运行结果：
修改父类的方法