失败只有一种,那就是半途而废!!!
目录
一、变量
变量是存储在内存中的值,这就说明在创建变量时会在内存中开辟一个空间。根据变量的数据类型,解释器会分配指定内存,并决定什么数据可以被存储在内存中。
(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再次赋值,这个时候是又开辟了一个内存空间里面放的20
1、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类型
结果:
<class 'int'>
<class 'float'>
<class '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
0
2、数学运算
- + 加法运算
- - 减法运算
- * 乘法运算
- / 除法运算(结果为浮点数)
- // 除法运算(只保留整数)
- % 取模(求余数)
- ** 幂次方运算
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))
结果:
<class 'str'>
<class 'str'>
<class 'str'>
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))
结果:
<class 'list'>
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))
结果:
<class 'tuple'>
- 元组无法修改
- 元组可以通过索引获取值
- 元组可以通过切片截取片段
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))
结果:
<class 'dict'>
- 列表中每个元素是键值对,例如上图中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
9
2、遍历字典
遍历字典和遍历列表、字符串稍微有些区别,
dict1 = {'name': "萧瑟", 'age': 18, 'sex': '男'}
for i in dict1:
print(i) # 这样遍历出来的是字典中的每个键,如果需要获取到对应的值可以print(dict1[i])
结果:
name
age
sex
3、九九乘法表
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 1
4、带参数的函数
def add_number(a, b):
return a + b
5、函数的返回值
函数的返回值可以有,也可以没有,具体看要达到的目的是什么
def add_number(a, b):
print(a+b) # 这里我就打印一下,不需要返回
def get_sum(a, b):
return a+b
6、函数的调用
函数的调用就像洗衣机的开关,你把函数写好了,不调用,就像洗衣机你不按开关一样,它自己不会运行。
不带参数:函数名()
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 0
7、函数的注释
函数如果不加注释,过半个月你自己看着都懵,写明注释,方便自己也方便他人。
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
100
10、global
在函数内部需要修改全局变量,则需要使用global关键字进行声明
num1 = 100
def bianliang():
global num1 # 声明一下这是全局变量
num1 = 10 # 此时在函数内部可以修改全局变量 此时函数内部的num1=10,函数外面的num1=10
print(num1)
bianliang() # 函数内部的num1=10
print(num1) # 函数外面的num1=10
结果:
10
10
11、匿名函数
就是没有名字的函数,一行可以写完的函数,这个在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 <module>
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 0
9、类的继承
类是可以继承的,所有的类都默认继承一个最大的类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()方法
运行结果:
修改父类的方法