python基础思维导图模板_ProcessOn思维导图、流程图

python环境部署

Windows

下载安装

环境变量配置

将python的安装路径配置到环境变量中

检测：python --version

linux

默认安装

安装编辑器

数据类型

数字（Numbers）

整型

int

浮点型

float

复数

complex

字符串（String）

定义

str();数字字母下划线组成的一串字符

访问

从左到右索引默认0开始的

从右到左索引默认-1开始的

str1 = 'aou! aou!' print(str1[0]) print(str1[-1])

a !

操作

合并拼接字符串：用“+”

print(str1[:5] + '!!!!') print(str1[:9] + '!!!!')

aou! !!!! aou! aou!!!!!

转义字符  \

制表符  \t   ,换行符\n

str2 = """多行字符串 可以使用Tab(\t), 也可以使用换行符(\n)""" print(str2)

多行字符串 可以使用Tab( ), 也可以使用换行符( )

\在行尾  续行符

>>>print("line1 \ ... ... line2 \ ... ... line3") line1 ... line2 ... line3

\\  反斜杠、单引号 \'、双引号\‘’

>>>print("\\") \ >>>print("\'") ' >>>print("\"") "

结束符

end=''

>>> print('hello',end='\n')

输入

input()

f-string

使用表达式

>>>x = 1 >>>f'{x+1}' '2' >>>y=1 >>>print(f'{y+1=}') y+1=2

替换变量

>>>name = 'Jason' >>>f'hi,{name}' 'hi,Jason'

常用方法

title()：首字母大写的方式显示每个单词，即将每个单词的首字母都改为大写

>>>print(mystr.title()) Process Finished With Exit Code 0

rstrip() 删除字符串尾部空格，临时删除，永久删除则需要存入变量中；lstrip() 删除字符串开头空格；strip()：删除两边空格

lstrip():删除左空白

>>>mystr = " process finished with exit code 0 " >>>print(mystr.lstrip()) process finished with exit code 0

rstrip()

>>>print(mystr.rstrip()) process finished with exit code 0

strip()

>>>print(mystr.strip()) process finished with exit code 0

find() 查找，返回改字符串下标，否则返回-1

>>> str1 = 'process finished with exit code 0' >>> print(str1.find('with')) 17

index()，返回改字符串下标，没有报错

>>> print(str1.index('with')) 17

count()  返回所查字符串的个数

>>> print(str1.count('with')) 1 >>> print(str1.count('o')) 2

rfind(),  返回字符串最后一次出现的位置，如果没有匹配项则返回-1

str1.rfind('with')

rindex(), 返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常，你可以指定可选参数[beg:end]设置查找的区间

str1.rindex('with')

replace()  修改,  str.replace(old, new[, max]) old -- 将被替换的子字符串。 new -- 新字符串，用于替换old子字符串。 max -- 可选字符串, 替换不超过 max 次

new_str = str1.replace('with','a',3)

split()    分割,通过指定分隔符对字符串进行切片,返回分割后的字符串列表

#new_str = str1.replace('with','a') new_str = str1.replace('with','a',3)#修改次

join(),将序列中的元素以指定的字符连接生成一个新的字符串,返回通过指定字符连接序列中元素后生成的新字符串

mylist = ['aa','bb','cc'] new_str1 = '***'.join(mylist)

capitalize()将字符串的第一个字母变成大写,其他字母变小写

C_str = str1.capitalize()

 ljust rjust ceter   字符串对齐,  语法字符串序列.ljust(长度,填充字符)

str1.rjust(50, '0')

判断

判断以某个字串开头startswith

>>> str1 = 'process finished with exit code 0' >>> print(str1.startswith('p')) True

判断以某个字串结尾endswith

>>>  print(str1.endswith('0')) True

列表（List）

定义

把逗号分隔的不同的数据项使用方括号括起来,可以是不同的数据类型[23,565,'aaa']，列表数据可变

格式

[数据1,数据2,数据3,数据4...]

name_list = ['Tom', 'Lily', 'Rose', 'Tom', 'Ann']

访问

从左到右索引默认0开始的

从右到左索引默认-1开始的

>>>x = [1,3,5,6,'red',8,'blue'] >>>print(x[5]) 8 >>>print(x[-3]) red >>>print(x[1:-3]) [3, 5, 6]

常用操作

添加

append()

列表结尾追加数据语法列表序列.append(数据) 如果追加数据是序列，则将整个序列追加至结尾处

name_list.append('Sarah') name_list.append([11,22])#如果追加数据是序列，则将整个序列追加至结尾处

extend()

将字符串或列表数据拆开加至列表结尾

name_list.extend('Sarah') name_list.extend([11,22,'Eric'])

insert()

语法

列表.insert(位置下标，数据)

name_list.insert(1,'aaa') print(name_list)

insert()在指定索引处添加空间，并将插入的值存储到这个地方。这种操作将列表中既有的每个元素都右移一个位置

查找

index()

返回指定数据所在位置的下标（不存在报错） 列表序列.index(数据,开始位置下标，结束位置下标)

print(name_list.index('Tom')) # #print(name_list.index('tom'))#数据不存在报错

count()

统计指定数据在当前列表中出现的次数（不存在返回0）

print(name_list.count('Tom')) print(name_list.count('Toms'))#数据不存在返回0

len()

访问列表长度即列表中数据的个数

name_list = ['Tom', 'Lily', 'Rose', 'Tom', 'Ann'] print(len(name_list)) print(name_list.__len__())

判断

in

判断指定数据在某个列表序列存在返回True 否则返回False

print('Tom' in name_list)

not in

判断指定数据不在某个列表序列不存在返回True 否则返回False

print('Tom' not in name_list)

修改

修改指定下标的数据

>>>x[2] = 'aou' >>>print(x) [1, 3, 'aou', 6, 'red', 8, 'blue']

删除

del

语法

del 目标或者del(目标)

del name_list del(name_list)

可删除指定下标数据

del name_list[2]

pop()

删除指定下标数据如未指定则删除最后数据

pop_name = name_list.pop() pop_name = name_list.pop(2)

remove

remove(数据)，删除匹配到的第一项

name_list.remove('Tom')

clear

清空列表

name_list.clear()

排序

reverse

逆序

name_list.reverse()

sort

升序降序默认升序

list1 = ['aAfe', 'kfre', 'Agrew', 'Bew', '43', '?', '6', '387', '/', '\\', '!', '~'] list1.sort()

语法

列表序列.sort(key=None,reverse=False) reverse表示排序规则，True降序，False升序

list1.sort(reverse=True) list1.sort(reverse=False)

list1.sort(reverse=False,key=str.lower)

遍历

列表中遍历

while

print(name_list) i= 0 while i <len(name_list):      print(name_list[i])      i += 1

for

print(name_list) for i in name_list:      print(i)

切片

格式

[start:end:step]

start:起始索引，从0开始，-1表示结束 end：结束索引 step：步长，end-start，步长为正时，从左向右取值。步长为负时，反向取值

name_list = ['Tom', 'Lily', 'Rose', 'Tom', 'Ann'] print(name_list[:]) print(name_list[:2]) print(name_list[0:3:2]) print(name_list[5:0:-1])

复制

copy（）

list2 = name_list.copy()

列表嵌套

name_list1 = [['赵', '钱', '孙', '李'], ['周', '吴', '郑', '王'], ['冯', '陈', '褚', '卫']] print(name_list1[2]) print(name_list1[2][1])

元组(Tuple)

定义

定义使用（）逗号隔开，数据可为不同数据类型

t1 = ('aa', 'bb', 'cc', 'dd') t2 = ('aa', 'bb', ['cc', 'dd'])

常见操作

查找

index（）

print(t1.index('bb')) print(t1.index('bba'))#不存在数据报错

按下标查找

print(t1[0])

修改

不可修改，元组中包含有可修改类型数据，如列表，则列表中数据可修改

t2[2][0] = 'tom'

删除

元组中的元素值是不允许删除的，但可以使用del语句来删除整个元组

del t1

切片

格式

[start:end:step]

start:起始索引，从0开始，-1表示结束 end：结束索引 step：步长，end-start，步长为正时，从左向右取值。步长为负时，反向取值

print(t1[4:0:-1])

len()

访问列表长度即元组中数据的个数

print(len(t2))

字典(Dictionary)

特点

符号为花括号，数据为键值对形式出现，各个键值对之间用键值对隔开，字典为可变类型

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

常见操作

增

写法（注意如果key存在则修改对应的值，如果不存在则新增）,字典序列[]=值

# dict1['name'] = 'Rose' # {'name': 'Rose', 'age': 20, 'gender': '男'} # dict1['id'] = 110 # {'name': 'Rose', 'age': 20, 'gender': '男', 'id': 110}

update

将一个字典添加到另一个字典

dict2 = {'1': '1111', '2': '2222'} dict1.update(dict2)

删

del()/del

删除字典或者删除指定的键值对

# del(dict1) # print(dict1) # del dict1['name'] # {'age': 20, 'gender': '男'} # dict1.clear() # {} # print(dict1)

clear()

清空字典

dict1.clear() # {}

改

字典序列[key]=值

查

key值查找

如果key存在则返回对应的值，不存在报错

print(dict1['name']) # Tom

get()，字典序列.get(key,默认值)

注意如果当前查找的key不存在则返回第二个参数（默认值） 如果省略第二个参数，则返回None

# print(dict1.get('age')) # 20 # print(dict1.get('id', 110)) # 110 # print(dict1.get('id')) #None

keys()

查找字典中所有的key 返回可迭代对象

# keys() # print(dict1.keys()) # dict_keys(['name', 'age', 'gender']) # print(type(dict1.keys())) # <class 'dict_keys'>

values()

查找字典中所有的值返回可迭代对象

print(dict1.values()) # dict_values(['Tom', 20, '男'])

items()

返回所有的键值对，返回可迭代对象里面数据是元组

print(dict1.items()) # dict_items([('name', 'Tom'), ('age', 20), ('gender', '男')])

遍历

遍历key

for key in dict1.keys():    print(key)

遍历value

for value in dict1.values():     print(value)

遍历键值对

for item in dict1.items():      print(item)

for key, value in dict1.items():     print(f'{key} = {value}')

嵌套

dict11 = {'name': 'Tom', 'age': 20, 'gender': '男', 'aa': {'1': '1111', '2': '2222'}}

集合

定义

创建集合使用{}或者set(),创建空集合只能用set()，{}是空字典

s1 = {'10', '20'}

特点

不允许重复数据无顺序 集合是可变类型

s2 = {10, 20, 30, 30, 20} print(s2) # {10, 20, 30}

s3 = set('wfewrgjiwr') print(s3) # {'e', 'g', 'r', 'j', 'f', 'i', 'w'}

常见操作

增

add()

集合有去重功能当追加数据是重复的则不进行任何操作

s1.add(100) # {'20', 100, '10'}

update()

追加的数据是序列

s1.update([10, 20, 30, 40, 50]) # {40, 10, 50, '10', 20, '20', 30}

删

remove()

删除集合中指定数据如不存在报错

s7 = {10, 20, 30, 40, 50}  s7.remove(10) # {40, 50, 20, 30}

discard()

删除集合中指定数据如不存在也不报错

s7.discard(10) # {40, 50, 20, 30}

pop()

随机删除集合中某个数据并返回该数据

del_num = s7.pop() print(del_num) # 40

查

in

print(10 in s7) # True

not in

print(10 not in s7) # False

变量和运算符/注释

变量

命名规则

以字母或下划线开头的字母数字下划线组合

不能用关键字

区分大小写

变量作用域

定义

指变量生效的范围，分为局部变量和全局变量

局部变量

定义在函数体内的变量只在函数体内生效 在函数体内部临时保存数据函数调用完成后则销毁局部变量

全局变量

函数体内外都能访问

global

声明是全局变量，函数体内声明global a，在函数体外也能访问a

a = 100 print(a) def testA():      print(a) def testB():      global a # 声明a是全局变量      global b      b =300      a = 200      print(a) testA() testB() print(a) testA() print(b)

100 100 200 200 200 300

运算符

算数运算符

加+、减-、乘*、除/

取模%、幂**、整除//（取商的整数部分，向下取整）

//

>>>23//8 2 ->>>23//8 -3

%(返回出发的余数)

>>>23%8 7

比较运算符

等于==、不等于！=、大于>、小于<、大于等于>=、小于等于<=

返回布尔型

>>>3<=2 False 2>>>!=3 True >>>1+1==2 True

逻辑运算符

and:与，同时满足条件

>>>(1>2 and 3>2) False >>>1<2 and 3>2 True

or:或，至少满足一条

>>>1>2 or 3>2 True

not:非，条件为False，则返回True

>>>not 1>2 True >>>not 3>2 False

赋值运算符

=、+=、-=、*=、/=、%=、**=、//=

成员运算符

in

在指定序列中找到指定之，返回True，否则返回False

>>>1 in [1,2,3] True >>>1 in [3,4,5] False

not in

在指定序列中没找到指定之，返回True，否则返回False

>>>'s' not in 'se' False >>>'s' not in 'rg' True

运算符优先级

（）高于** 高于 * 、/、 //、 % 高于 +、 -

同优先级运算从左到右，逻辑运算符and 拥有更高优先级

>>>True or False and False True >>>not True or False and False False >>>not False or False and False True

三目运算符

语法

条件成立执行的表达是 if 条件 else 条件不成立执行的表达式

a = 1 b = 2 c = a if a > b else b print(c) aa = int(input("输入aa:")) bb = int(input("输入bb:")) cc = aa - bb if aa > bb else bb - aa print(cc)

注释

单行注释   #

多行注释   三个引号（单引号或双引号）

控制结构

条件

if语法

if 语法 if 条件：（注意缩进） 条件成立执行代码1 .。。 elif 条件2: 条件2成立执行代码1 ... else: 条件都不成立执行语句代码 。。。。

age = int(input('输入年龄')) if age >= 18 :      print("可以上网") else:      print("未成年")

if嵌套语法

if 条件1： 条件1成立执行代码 。。。 if 条件2： 条件2成立执行的代码

money = int(input("1为有钱非1为无：")) seat = int(input("1为有座非1为无：")) if money == 1:      print("上车") if seat == 1:      print("有空座") else:      print("无空座位") else:      print("不能坐车")

循环

while

语法

while 条件:      条件成立重复执行的代码

i = 0 while i < 5:      print('减肥')      i += 1

退出循环的方式

breaker  推出整个循环

i = 1 while i <= 5:      if i== 4:          print('吃饱')          break      print(f'吃了第{i}个苹果')      i += 1

continue   当条件成立退出当前一次循环，继续执行下一次循环

j = 1 while j <= 5:    if j ==3:       print('吃出个虫，这个不吃了')       #continue前要执行要从修改计数器否则会进入死循环       j += 1       continue    print(f'吃了第{j}个苹果')    j += 1

while循环嵌套

语法

while 条件1:    条件1成立执行的代码     。。。    while 条件2：      条件2成立执行的代码      。。。

print('===========九九乘法表================') j =1 while j<= 9:     i =1     while i<=j:          print(f'{i}*{j}={i*j}',end='\t')          i+=1      print()      j+=1

for

语法

for 临时变量 in 序列：      重复执行的代码1      重复执行的代码2

str1 = input("输入字符串：") for i in str1:      if i == 'e':          break      elif i== 'i':          continue      print(i)

退出循环的方式

breaker 推出整个循环

continue 当条件成立退出当前一次循环，继续执行下一次循环

函数

定义函数

def 函数名（参数）：      代码。。。

def add_num1():    result = 1 + 2     print(result)

调用函数

函数名（参数）

add_num1()

参数

形参

定义的函数里允许调用者提供一些参数，就把这些参数写在括号里

def add_num(n1, n2):      result1 = n1 + n2      print(result1) # add_num(10, 20)

缺省参数（默认参数）

调用函数时可不传默认参数

位置参数

调用函数时根据函数定义的位置来传递参数

传递和定义参数的顺序和个数必须保持一致

位置参数必须写在关键字参数前面 所有的位置参数必须在默认参数前，包括函数的定义和调用

关键字参数

通过键=值的形式加以指定

def user_info(name, age=40, gender='男'):      print(f'名字{name},年龄{age},性别{gender}') # user_info('tom', 3, '男') # user_info('rose', gender='女', age=20)

不定长参数（可变参数）

包裹位置传递

传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组，*args 返回元组

def user_info1(*args):      print(args)      return args user_info1('Tom') user_info1('Tom', 19) a = user_info1('tom', 20) print(a[1])

包裹关键字参数

收集所有的关键字参数，返回的是一个字典，无论是包裹位置还是包裹关键字传递，都是一个组包的过程

def user_info4(**kwargs):      print(kwargs) user_info4(name='Tom') user_info4(name='Tom', age=18, gender='男')

函数返回值

return  表示函数调用的结束并将结果返回至函数调用处

一个函数两个返回值

def return_num():      # return 1, 2 # 返回元组      # return (10, 20)      # return [100, 300]      return {'name': 'python', 'age': 30} result = return_num() print(result)

执行流程

先定义后调用

调用函数解释器会回到定义函数的地方去执行函数体，定义的时候函数体没有被执行

函数说明文档

函数体第一行多行注释

def sum_num(a, b): ''' 求和函数 :param a: :param b: :return: ''' return a + b

查看

help(sum_num)

函数嵌套调用

def testB():      print('bbbbbbbb')      return 1 def testA():      print('aaaaaaaaaaaaa')      testB()      return      print('end') testA()

递归

特点

函数内部自己调用自己 必须有出口

def sum_numbers(num):      if num ==1:          return 1      return num +sum_numbers(num-1) sumresult = sum_numbers(3) print(sumresult)

常见函数

lambda

如果一个函数有一个返回值，并且只有一句代码，可以使用lambda简化

fn1 = lambda a, b: a + b print(fn1(1, 2))

语法

lambda 参数列表：表达式

fn2 = lambda: 100 print(fn2) # lambda内存地址 <function <lambda> at 0x030F8E80> print(fn2()) # 100

参数形式

无参数 fn = lambda: 100 一个参数 fn = lambda a: a 两个参数 fn = lambda a, b, c=100: a + b + c 可变参数 *args lambda *args:args 注：可变参数传入到lambda之后，返回值为元组

注意

lambda表达式的参数可有可无，函数的参数在lambda表达式中完全适用 lambda表达式能接收任何数量的参数但只能返回一个表达式的值

abs()

求绝对值

print(abs(-7)) # 7

round()

四舍五入

print(round(1.2)) # 1 print(round(1.6)) # 2

map()

map(func,lst) 将传入的函数变量func作用到lst变量的每一个元素中， 并将结果组成新的迭代器返回

list1 = [1, 2, 3, 4, 5] def func(x):      return x ** 2 result = map(func, list1) print(result) # <map object at 0x0000026D5F36C9C8> print(list(result)) # [1, 4, 9, 16, 25]

reduce(func, lst)

其中func必须有两个参数，每次func计算的结果继续和序列的写一个元素做累计计算

# 计算list1序列中各个数字的累加值和 import functools list1 = [1, 2, 3, 4, 5] def func(a, b):      return a + b result = functools.reduce(func, list1) print(result) # 15

filter(func, lst)

用于过滤序列，过滤不符合条件的元素，返回一个filter对象 如果要转换为列表，可以用list()来转换

list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] def func(x):      return x % 2 == 0 result = filter(func, list1) print(result) # <filter object at 0x00000225167AC988> print(list(result)) # [2, 4, 6, 8, 10]

文件处理

打开文件

写法

open(name,mode)

name:文件名可包括具体路径 mode：访问模式只读写入追加

访问模式

-- w 写 文件不存在新建文件 文件对象.write('内容') 覆盖原有内容

f = open('test.txt', 'w')

-- r 读 文件不存在报错 不支持write（） 访问模式省略时默认为 r

f = open('test.txt', 'r')

-- a 追加 如果文件不存在则新建 write（）在原有内容上追加

f = open('test2.txt', 'a')

常用方法

read()

文件对象.read(num) num标识要从文件中读取的数据的长度（单位是字节），如未传入num,读取所有数据

#print(f.read()) # print(f.read(8))

write（）

写操作

f.write('rr')

readlines()

按照行的方式把文件内容进行一次性读取，并且返回的是一个列表，每一行的数据为一个元素

readline()

一次读取一行内容

seek()

用来移动文件指针

语法

文件对象.seek(偏移量，起始位置) 起始位置：0 文件开头 1当前位置 2 文件结尾 r: 改变文件指针位置，改变读取数据开始位置或文件指针放结尾（无法读取数据） a: 改变文件指针位置,可以读取数据

文件操作  os

os.rename(目标文件名，新文件名)

文件重命名

os.remove(目标文件名)

删除文件

os.getcwd()

获取当前目录

os.chdir()

改变目录路径

os.listdir()

获取某个文件夹下所有文件  返回一个列表

os.mkdir(文件夹名字)

建文件夹

os.rmdir(文件夹名字)

删文件夹

面向对象

类

简介

用来描述具有相同的属性和方法的对象的集合，定义了该集合中每个对象所共有的属性和方法

class Car(object):      def __init__(self, make, model, year):          self.make = make          self.model = model          self.year = year          self.odometer_reading = 0      def get_descriptive_name(self):           long_name = str(self.year) + ' ' + self.make + ' ' + self.model           return long_name.title()      def read_odometer(self):           print('This car has ' + str(self.odometer_reading) + ' miles on it')      def update_odometer(self, mileage):          if mileage >= self.odometer_reading:              self.odometer_reading = mileage          else:               print("You can't roll back an odometer!")      def increment_odometer(self, miles):           self.odometer_reading += miles

命名规则

要满足标识符命名规则

类的创建，访问。。。

class Car(object):      '''         车类      '''      odometer_reading = 0

不去继承自己书写的类，默认级成所有类的顶级类 object ；其他类都叫派生类

引号中，是类的说明，在类的第一行，通过.__doc__查看

print(Car.__doc__)

类变量

odometer_reading是类变量，它的值能在这个类里面的所有实例间共享，可以通过Car.odometer_reading访问

__init__()

__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法

self

self 代表类的实例，self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数

创建实例对象

使用类的名称 Car来实例化，并通过 __init__ 方法接收参数

my_new_car = Car('audi', 'a4', 2016)

类属性

访问属性

通过  .  来访问对象的属性

my_new_car.read_odometer()

增加修改删除类的属性

my_new_car.age = 1 my_new_car.age = 8 del my_new_car.age

类属性只能通过类对象修改，不能通过实例对象修改，如果通过实例对象修改类属性，表示的是重新创键了一个实例属性

定义

类属性就是类对象所拥有的属性 被该类的有所实例对象所共有 类属性可以使用类对象或实例对象访问

优点

记录的某行数据始终保持一致时，则定义类属性 实例属性要求每个对象为其单独开辟一份内存空间来记录数据 类属性为全类所共有，仅占一份内存，更加节省内存空间

类方法的特点

需要用装饰器@classmethod来标识其为类方法，第一个参数必须是类对象，一般以cls作为第一个参数

方法使用场景

当方法中需要使用类对象（入访问私有属性等）是定义类方法 类方法一般和类属性配合使用

封装

将属性和方法写到类里面，可以为属性添加私有属性

继承

定义

指多个类之间的所属关系，及子类默认继承父类的所有属性和方法

#父类 class A(object):      pass # 子类 class B(A):      pass

注意

创建子类时，父类必须位于子类前面

类别

单继承

单一的继承关系，一个父类继承给一个子类

多继承

一个类同事继承了多个父类

当一个类有多个父类的时候，默认使用第一个父类的同名属性和方法

重写（子类重写父类同名属性和方法）

子类和父类拥有同名属性和方法，用子类去创建对象，该对象调用同名属性和方法，调用的是子类里面封装的属性和方法

子类调用父类同名方法和属性

用父类方法，为保证调用到的是父类属性，必须在调用前调用父类初始化

super()

关联父类子类

多层继承中使用

super(当前类名.self).函数名 父类中写super

私有属性

写法

在方法属性前加  __

注意

对象不能访问私有属性和方法子类无法继承父类的私有属性和私有方法 一般定义get_XX、set_XX函数来获取和修改私有属性

多态

定义

一种使用对象的方式，子类重写父类的方法，调用不同的子类对象的相同父类方法，可以产生不同的执行结果

好处

调用灵活，有了多态更容易编写通用的代码，做出通用的编程，以适应需求的不断变化

实现步骤

定义父类，并提供公共方法 定义子类，并重写父类方法 传递子类对象给调用者，可以看到不同子类执行效果不同

静态方法

静态方法特点

需要通过装饰器@staticmethod来进行修饰，静态方法既不需要传递类对象，也不需要传递实例对象（形参没有self/cls） 静态方法也能通过实例对象和类对象访问

静态方法的使用场景

当方法中既不需要使用实例对象（如实例对象，实例属性），也不需要使用类对象（如类属性，类方法，创建实例属性）时，定义静态方法 取消不需要的参数传递，有利于减少不惜要的内存占用和性能消耗

异常

定义

检测到错误,解释器就无法继续执行了，出现一些错误的提示，这就是异常

try：      code #需要判断是否会抛出异常的代码，如果没有异常处理，python会直接停止执行程序 except: #这里会捕捉到上面代码中的异常，并根据异常抛出异常处理信息 #except ExceptionName，args： #同时也可以接受异常名称和参数，针对不同形式的异常做处理      code #这里执行异常处理的相关代码，打印输出等 else： #如果没有异常则执行else      code #try部分被正常执行后执行的代码 finally：      code #退出try语句块总会执行的程序

捕获异常

语法

try:      可能发生异常的代码 except:      发生错误的时候执行的代码

捕获指定异常

try:      可能发生异常的代码 except 异常类型:      如果捕获到该异常类型执行的代码

捕获多个指定异常

try:      可能发生异常的代码 except (异常类型1,异常类型2):      如果捕获到该异常类型执行的代码

try-finally 语句

finally表示无论是否发生异常都要执行的代码

try: <语句> finally: <语句> #退出try时总会执行

自定义异常

通过创建一个新的异常类，可以命名它们自己的异常