python基础知识集合

Python基础知识

建议有程序语言基础的童鞋阅读，零基础阅读可能会有点费解

文章目录

Python基础知识注释方法数据类型输入和输出输入输出算数运算符常用运算函数比较运算符逻辑运算符成员运算符分支循环列表列表的取值获取元素的下标获取列表中多个元素（切片）列表的增删改操作增加删除修改列表的排序列表生成式列表常用函数字典（对象）字典的创建方式字典的常用操作获取字典的试图方法字典的遍历字典的生成式元组元组的创建方式元组的遍历集合集合的创建集合的常用操作集合间的关系字符串的常用操作字符串的查询操作方法字符串的大小写转换操作的方法字符串内容对齐操作的方法字符串分割操作的方法判断字符串操作的方法字符串操作的其他方法字符串格式化操作字符串编码和解码操作函数函数的定义和使用函数的返回值函数的默认值函数的参数定义python异常处理机制异常捕获异常捕获
elsetry...except...else...finally结构python常见的异常类型类与对象类的创建类实例对象动态绑定属性和方法面向对象的三大特征模块和包导入模块包文件的读写内置函数open()创建文件对象常用的文件打开模式文件对象的常用方法with语句（上下文管理器）目录操作 （os 和 os.path）python内置模块

注释方法

# 单行注释
''' 多行注释 '''

数据类型

关键字名称示例chr单个字符'', 'd'str字符串（多个chr）'dd', '你好'int整数1,2,3,4float浮点数3.1415926bool布尔Ture, Falselist列表[1,2,3,4]tuple元组('name', 'age')dict字典{'name':'zzl'}set集合{'zzl', 'age', 'gender'}

查看数据类型函数
type(变量) 返回该变量的数据类型

数据类型转换函数
int(num) 将num转换为整数类型
float(num) 将num转换为浮点数类型
bool(num) 将num转换为布尔类型
str(num) 将num转换为字符串类型

注：

int bool float 任何两种类型都可相互转换

任何类型都可以转换为字符串

注：

str -> int 要求全部为数字

str -> float 要求全部为数字，且可存在一个小数点

注：当布尔值False转换为str后， 在转换为bool会变成True

输入和输出

输入

语法 inp = input('提示文本')

注：输入结果为str数据类型，如须做其他操作可进行数据转换

输出

1. 默认输出

print('hello, world')
1

2. 占位符输出

# %s 的s表示变量的数据类型
print('名字：%s，年龄：%s，性别：%s' % (name, age, sex)) 
12

3. 推荐使用

print(f'名字：{name}，年龄：{age}，性别：{sex}')
1

算数运算符

+ - * / ** // %

前四个同其他编程语言用法相同

---

** 表示平方计算 5 ** 2 === 5的2次方
// 表示做除运算后取整
% 取余运算

简写形式
+= -= *= /= **= //+ %=

---

注：
+ 也可用于字符串拼接
* 当任意一边为字符串时，则表示重复字符串

常用运算函数

round(num, count) 表示对num四舍五入，并保留小数点后count位

比较运算符

> < >= <= = !=

常用函数

ord(chr) 返回该chr的ASCII码(只能为单个字符)

chr(num) 返回该ASCII对应的字符

逻辑运算符

and ，or ， not

运算符含义and真真为真，其他为假（第一项为真则返回第二项的值，如第一项为假则返回第一项的值）or假假为假，其他为真（第一项为真，则返回第一项的值，如第一项为假，则返回第二项的值）not取反

成员运算符

in ，not in

运算符含义示例in判断某字符是否存在于某字符串'h' in 'hello'not in判断某字符是否不存在于某字符串'h' not in 'hello'

分支

单分支

# 注意缩进
if bool表达式:  
    print('执行')  
123

双分支

# 注意缩进
if bool表达式:  
    print('执行语句1')  
else:
    print('执行语句2')
12345

分支嵌套

# 注意缩进
if bool表达式:  
    if bool表达式2:
        print('执行嵌套语句')
    else:
        print('执行语句1')  
else:
    print('执行语句2')
12345678

多分支

# 注意缩进
if bool表达式1:  
    print('执行语句1')  
elif bool表达式2:
    print('执行语句2')
elif bool表达式...:
    print('执行语句...')
else: 
    print('如上都不满足，则执行这条语句')
123456789

循环

循环控制

只能在循环语句中使用，只对距离最近的循环起作用

break # 跳出本循环
continue # 结束本次循环，执行下一次循环 
12

while循环

# 注意判断条件
while bool表达式:
    print('执行语句')
123

for循环

# range(start, end, rule) 从start开始，到end-1，间隔为rule,rule的正负表示正序或倒序
# range(1, 11) 输出1~10，不包括最大值11
# range(1, 11, 2) 输出1~10，不包括最大值11, 第三个参数表示为每次间隔2
# range(11, 1, -2) 输出11~2，不包括最小值值1, 第三个参数为负数，则表示为倒序且每次间隔2
# range(5) 简写形式，0~5的范围

for i in range(1,11):
    print(i)
123456789

循环else结构

只有循环完整执行完毕后，才会执行else语句
当循环过程中执行break语句后，else将不执行

# while  
while bool表达式:  
    print('执行语句')
else:
    print('while  else语句')
    
# for  
for i in range(10):  
    print('执行语句')
else:
    print('for  else语句')
1234567891011

列表

对象是存储单个数据的容器，而列表（数组）就是存储多个数据的容器，任何数据类型都可以存放

# 字面量创建新列表
lst = [1,'2','三']

# 使用list函数创建新列表
lst = list([1,'2','三'])
12345

列表的取值

1. 通过索引下标取值
2. 使用for循环

获取元素的下标

1. list.index('元素’) 找不到元素则抛出异常， 可预先使用in方法判断是否存在

获取列表中多个元素（切片）

list[start:end:step]
从start索引位置开始，截取到end-1位置结束，步长为step

其中step可为负值，表示从start位置往左边截取开始

start默认值为0
end默认值为列表长度
step默认值为1

省略参数但 : 必须存在 list[::]

列表的增删改操作

增加

append(item)
在原有的列表末尾添加一个元素

lst = [10, 20, 30] 
lst.append(100)
print(lst) # [10, 20, 30, 100] 
123

extend( [] )
在原有的列表末尾至少添加一个元素，添加元素必须是列表（添加多个）

lst = [10, 20, 30] 
lst.extend([99, 100])
print(lst) # [10, 20, 30, 99, 100] 
123

insert(index, item)
在原有的列表指定位置添加一个元素

lst = [10, 20, 30] 
lst.insert(1, 99)
print(lst) # [10, 99, 20, 30] 
123

切片添加多个元素(指定位置添加多个元素)
使用切片把选择到的元素替换掉

lst = [10, 20, 30] 
lst[1:] = [99]
print(lst) # [10, 99]
123

删除

remove(item)
在原有的列表删除一个元素，如果有重复元素只删除一个，如果元素不存在则抛出异常

lst = [10, 20, 30] 
lst.remove(20)
print(lst) # [10, 30] 
123

pop(index)
删除指定索引位置的元素，如果指定索引不存在则抛出异常
不传index，则删除末尾元素

lst = [10, 20, 30] 
lst.pop(1)
print(lst) # [10, 30] 
123

clear()
清空列表

lst = [10, 20, 30] 
lst.clear()
print(lst) # []  
123

切片删除元素
使用切片把选择到的元素替换为空

lst = [10, 20, 30] 
lst[1:] = []
print(lst) # [10]
123

删除列表，即释放内存（谨慎使用）

lst = [10, 20, 30] 
del lst
print(lst) # 会抛出异常， lst is not defined
123

修改

直接重新赋值

lst = [10, 20, 30] 
lst[1] = 40
print(lst) # [10, 40, 30]  
123

切片修改（批量修改）

lst = [10, 20, 30] 
lst[1:3] = [40, 50, 60]
print(lst) # [10, 40, 50, 60]  
123

列表的排序

sort()
在原列表的基础上排序
传入reserse=True降序排序
传入reserse=False生序升序
不传默认升序

# sotr()  
lst = [9, 3, 2, 8] 
lst.sort()  
print(lst) # [2, 3, 8, 9]  

# sotr(reserse=True)  
lst = [9, 3, 2, 8] 
lst.sort(reserse=True)  
print(lst) # [9, 8, 3, 2]

# sotr(reserse=False)  
lst = [9, 3, 2, 8] 
lst.sort(reserse=False)  
print(lst) # [2, 3, 8, 9]  
1234567891011121314

sorted(lst[,rule ])
使用内置函数sorted()进行排序，将产生一个新列表对象
传入第二参数reserse=True降序排序
传入第二参数reserse=False生序升序
不传第二参数默认升序

# sorted(lst)  
lst = [9, 3, 2, 8] 
new_list = sorted(lst)  
print(new_list) # [2, 3, 8, 9]  

# sorted(lst, reserse=True) 
lst = [9, 3, 2, 8] 
new_lsit = sorted(lst, reserse=True)  
print(new_list) # [9, 8, 3, 2]

# sorted(lst, reserse=False)  
lst = [9, 3, 2, 8] 
new_lsit = sorted(lst, reserse=False)   
print(new_list) # [2, 3, 8, 9]  
1234567891011121314

列表生成式

[i for i in renge(1, 11)]
列表生成的表达式

lst = [i*i for i in renge(1, 6)]
print(lst) # [1, 4, 9, 16, 25]
12

列表常用函数

len(list)：列表元素个数

max(list)：返回列表元素最大值

min(list)：返回列表元素最小值

字典（对象）

python的内置数据结构之一，以键值对的方式存储数据。在其他语言中也叫对象。

字典的创建方式

info = {'name':'zzl', 'age':18}

info = dict(name='zzl', age=18)

字典的常用操作

获取字典中的元素

info = {'name':'zzl', 'age':18}  

# []方式
print(info['name']) # zzl  
print(info['sex']) # error: keyError 

# get()方式
print(info.get('name')) # zzl
print(info.get('sex')) # None  
print(info.get('sex', '男')) # 如果sex字段为None的话，则打印 '男' 默认值
12345678910

key的判断
in, not in

info = {'name':'zzl', 'age':18}  

# in
print('name' in info) # True  

# not in
print('sex' nor in info) # True
1234567

key的删除

info = {'name':'zzl', 'age':18}  

del info['name'] # 删除name字段
print(info) # {'age':18}

info.clear() # 清空该字典  
print(info) # {}
1234567

新增key

info = {'name':'zzl', 'age':18}  
info['sex'] = '男'
print(info) # {'name':'zzl', 'age':18, 'sex':'男'}  
123

修改key

info = {'name':'zzl', 'age':18}  
info['age'] = 20
print(info) # {'name':'zzl', 'age':20}  
123

获取字典的试图方法

keys()
返回字典的所有key组成的列表

info = {'name':'zzl', 'age':18}  
keys = info.keys()
print(keys) # ['age', 'name']
123

values()
返回字典的所有value组成的列表

info = {'name':'zzl', 'age':18}  
values = info.value()
print(values) # [18, 'zzl']
123

items()
返回字典的所有key:value组成的列表

info = {'name':'zzl', 'age':18}  
itmes = info.items()
print(items) # [('age', 18), ('name', 'zzl')]
123

字典的遍历

info = {'name':'zzl', 'age':18}  

for item in info:
    print(item，info[item])
# age 'zzl'
# name 18
123456

字典的生成式

items = ['Fruits', 'Books', 'Others'] 
prices = [98, 97, 95] 
d = { item:price for item, price in zip(items, prices) }
print(d) # {'Others': 95, 'Books': 97, 'Fruits': 98}
1234

字典的特点

1. 字典中的所有元素都是一个key-value对，key不允许重复，value可以重复
2. 字典中的元素是无序的
3. 字典中的key必须是不可变对象，（即key不能为变量）
4. 字典也可以根据需要动态的伸缩
5. 字典会浪费较大的内存，是一种使用空间换时间的数据结构

元组

列表的另一种形式，是不可变序列

元组的创建方式

# 直接用小括号书写
t = ('python', 'world', '20') 

# 使用内置函数tuple() 
t1 = tuple( ('python', 'world', '20') )

t3 = ('python',) # 如果元组只有一个元素，则在元素后面加上 ，  

# 获取元组的元素
t[0] # python
12345678910

元组的遍历

t = ('python', 'world', '20') 

for item in t:
    print(item)
# python
# world 
# 20

12345678

注：

1. 如果元组中对象本身是不可变对象，则不能再引用其他对象
2. 如果元组中的对象是可变对象，则可变对象的引用不允许改变，但数据可以改变

集合

python语言提供的内置数据结构
与列表、字典都属于可变类型的序列
集合是没有value的字典
集合的存储是无序的

集合的创建

# 集合的value不能重复
s = {2, 3, 4, 5, 2, 4} 
print(s)  # {2,3,4,5}

# set()函数  
s1 = set(range(6)) 
print(s1) # set([0, 1, 2, 3, 4, 5])

s2 = set([1,2,3,5,6,4,3])
print(s2) # set([1, 2, 3, 4, 5, 6])

s3 = set((1,23,5,32,1))
print(s3) # set([32, 1, 5, 23])

s4 = set('python')  
print(s4) # set(['h', 'o', 'n', 'p', 't', 'y'])

s5 = set({12,4,23,4,12})  
print(s5) # set([12, 4, 23])

# 定义集合
s6 = set()

1234567891011121314151617181920212223

集合的常用操作

s = {10, 20, 30, 40, 50}   

# 判断是否存在
print(10 in s) # True   
print(70 in s) # False

# 新增  
s.add(80) 
print(s) # {10, 20, 30, 40, 50, 80}  

# 新增多个  
s.update({200, 400})  
print(s) # {10, 20,, 200, 30, 40, 50, 400, 80}  

# 删除  
s.remove(10) 
print(s) # {20,, 200, 30, 40, 50, 400, 80} 
s.remove(900) # error: keyError
s.discard(900) # 如果有则删除900， 没有也不会报错
s.pop() # 随机删除一个， 不能传参  
s.clear() # 清空集合
123456789101112131415161718192021

集合间的关系

两个集合是否相等（判断集合中的元素是否完全相等）

s1 = {10, 20, 30, 40}
s2 = {20, 40, 10, 20} 
print(s1 == s2) # True
print(s1 != s2) # False
1234

一个集合是否是另一个集合的子集

假如集合s1的元素里包括集合s2的全部元素，则s2是s1的子集

s1 = {10, 20, 30, 40}
s2 = {20, 40} 
print(s2.issubset(s1)) # True
123

一个集合是否是另一个集合的超集

与上相反，假如集合s1的元素里包括集合s2的全部元素，则s1是s2的超集

s1 = {10, 20, 30, 40}
s2 = {20, 40} 
print(s1.issuperset(s2)) # True
123

一个集合和另一个集合是否无交集

如果一个集合里某个元素，在另一个集合里也有存储，则两个集合有交集

s1 = {10, 20, 30, 40}
s2 = {80, 60} 
print(s1.isdisjoint(s2)) # False 无交集
123

字符串的常用操作

字符串的查询操作方法

方法名称作用index()查找子串第一次出现的位置，如果查找的子串不存在时，则抛出ValueErrorrindex()查找子串最后一次出现的位置，如果查找的子串不存在时，则抛出ValueErrorfind()查找子串第一次出现的位置，如果查找的子串不存在时，则返回-1rfind()查找子串最后一次出现的位置，如果查找的子串不存在时，则返回-1

字符串的大小写转换操作的方法

方法名称作用upper()把字符串中所有字符都转成大写字母lower()把字符串中所有字符都转成小写字母swapcase()把字符串中所有大写字母转成小写字母，把所有小写字母转成大写字母capitalize()把第一个字符转换为大写，其余字符小写title()把每个单词的第一个字符转换为大写，把每个单词的剩余字符转换为小写

字符串内容对齐操作的方法

方法名称作用center()居中对齐，第一个参数指定宽度，第二个参数指定填充符，第二个参数是可选的，默认是空格，如果设置宽度小于实际宽度，则返回原字符串ljust()左对齐，第一个参数指定宽度，第二个参数指定填充符，第二个参数是可选的，默认是空格，如果设置宽度小于实际宽度，则返回原字符串rjust()右对齐，第一个参数指定宽度，第二个参数指定填充符，第二个参数是可选的，默认是空格，如果设置宽度小于实际宽度，则返回原字符串zfill()右对齐，左边用0填充，该方法只接收一个参数，用于指定字符串的宽度，如果设置宽度小于实际宽度，则返回原字符串

字符串分割操作的方法

方法名称作用split(cha, max)从字符串的左边开始分割，默认分割符是空格，返回值是一个列表，第一个参数为分割符，第二个参数为最大分割次数split(cha, max)从字符串的右边开始分割，默认分割符是空格，返回值是一个列表，第一个参数为分割符，第二个参数为最大分割次数

判断字符串操作的方法

方法名称作用isidentifier()判断指定字符串是不是合法的标识符isspace()判断指定字符串是否由空白字符组成（回车、换行、水平制表符tab）isalpha()判断指定字符串是否全部由字母组成isdecimal()判断指定字符串是否全部由十进制的数字组成isnumeric()判断指定字符串全部由数字组成isalnum()判断指定字符串是否全部由字母和数字组成

字符串操作的其他方法

方法名称作用replace()第1个参数指定被替换的子串
第2个参数指定替换子串的字符串
该方法返回替换后的字符串，替换前的字符串不会发生变化
该方法的第3个参数可以指定最大替换次数cha.join(lst)用cha将列表后元组的字符串合并成一个字符串。使用方法为cha.join(lst)

字符串格式化操作

# %s 的s表示数据类型  s:字符串  i:整数
print('我叫%s，我今年%i岁' % ('zzl', 18)) # 我叫zzl，我今年18岁'

# {}里的数字表示后面变量的索引，可重复使用
print('我叫{0}，我今年{1}岁，我真的叫{0}'.format('zzl', 18)) # 我叫zzl，我今年18岁，我真的叫zzl'

# 前面加f  可在{}中直接填写变量
print(f'我叫{'zzl'}，我今年{18}岁') # 我叫zzl，我今年18岁'

123456789

字符串编码和解码操作

# 编码

s = '好好学习，天天向上'
# 使用GBK格式进行编码, 此格式中，一个中文占两个字节
print(s.encode(encoding='GBK')) #b'\xba\xc3\xba\xc3\xd1\xa7\xcf\xb0\xa3\xac\xcc\xec\xcc\xec\xcf\xf2\xc9\xcf'

# 使用UTF-8格式进行编码 此格式中，一个中文占三个字节
print(s.encode(encoding='UTF-8')) #b'\xe5\xa5\xbd\xe5\xa5\xbd\xe5\xad\xa6\xe4\xb9\xa0\xef\xbc\x8c\xe5\xa4\xa9\xe5\xa4\xa9\xe5\x90\x91\xe4\xb8\x8a'



# 解码  （使用什么格式编码，就必须使用什么格式解码，否则会报错）

# 使用GBK格式进行编码
print(s.encode(encoding='GBK').decode(encoding='GBK')) # 好好学习，天天向上

# 使用UTF-8格式进行编码
print(s.encode(encoding='UTF-8').decode(encoding='UTF-8')) # 好好学习，天天向上

12345678910111213141516171819

函数

函数的定义和使用

# 定义
def 函数名(a, b): # 参数a和b
    函数体  
    return  # 返回值  
    
# 使用  
函数名()  

# 代码演示  
def cals(a, b):
    c = a + b 
    return c
    
res = cals(20, 30) # 50  
1234567891011121314

函数的参数传递

位置传参，cals(20, 30) ，此时a的值是20， b的值是30

关键字传参， cals(b=70, a=30) 此时a的值是30， b的值是70

函数的返回值

1. 如果函数没有返回值（函数执行完毕之后，不需要给调用处提供数据）,return可以省略不写
2. 函数的返回值，如果是1个，直接返回原值
3. 函数的返回值，如果是多个，返回的结果为元组

def fun(lst):
    odd = [] # 存放奇数  
    even = [] # 存放偶数
    for i in lst:
        if (i%2) :
            odd.append(i)
        else:
            even.append(i)
    return odd,even

lst = [10, 23, 65, 78, 32, 77] 
print(fun(lst)) # ([23, 65, 77], [10, 78, 32])
123456789101112

函数的默认值

在定义函数的时候，可以给形参赋上默认值，当没传参数的时候，函数会取默认值，如果传参和默认值同时存在，传的参数会替换掉默认值

def cals(a, b = 10):
    c = a + b 
    return c
    
res = cals(20) # 30  
res = cals(20, 30) # 50
123456

函数的参数定义

个数可变的位置参数
定义函数时，可能无法确定传递的实参个数，这个时候就要使用可变的位置形参。使用*定义，结果为一个元组

def fun(*args);
    print(args)

fun(1)  # (1,)
fun(1,2,3)  # (1, 2, 3)
12345

个数可变的关键字参数（指定参数名传递参数）
定义函数时，可能无法确定传递的关键字实参个数，这个时候就要使用可变的关键字形参。使用*定义，结果为一个字典

def fun(**args);
    print(args)

fun(a=10)  # {'a':10}
fun(a=10, b=20, c=30)  # {'a':10, 'b':20, 'c':30}
12345

以上参数在函数定义时，一种方式只能定义一次。
当两种参数定义方式同时存在时，位置形参必须在关键字形参前面

python异常处理机制

异常捕获

try:
    可能出现异常的语句放在这里 
except 你要捕获的异常类型:
    捕获到异常后你想做什么
except 你要捕获的异常类型:
    捕获到异常后你想做什么
...
except BaseException as e: # 这种情况是以上异常类型都没捕获到，则执行这块代码
    print('出错了', e)
print('程序照常执行')
12345678910

异常捕获else

try:
    可能出现异常的语句放在这里 
except 你要捕获的异常类型:
    捕获到异常后你想做什么
except 你要捕获的异常类型:
    捕获到异常后你想做什么
...
except BaseException as e: # 这种情况是以上异常类型都没捕获到，则执行这块代码
    print('出错了', e)
else:
    print('如果没有异常则执行else部分')
1234567891011

try…except…else…finally结构

try:
    a = int(input('请输入第一个整数'))
    b = int(input('请输入另一个整数'))
    res = a/b
except BaseException as e:
    print('出错了', e)
else:
    print('结果为:'res)
finlly:
    print('无论是否产生异常，总会被执行的代码')
12345678910

python常见的异常类型

异常类型描述ZeroDivisionError除零or向零取余IndexError序列中没有此索引KeyError映射中没有这个键NameError未声明or未定义SyntaxError语法错误ValueError传入无效的参数

类与对象

类的创建

类属性: 类中方法外的变量称为类属性，被该类的所有实例对象共享

类方法: 使用@classmethod修饰的方法，可使用类名直接访问

静态方法: 使用@staticmethod修饰的方法，可使用类名直接访问

# Stubent为类的名称，由一个或多个单词组成。（建议类名书写方式为每个单词首字母大写）
class Student:
    native_pace = '河南' # 直接写在类里的变量，称为属性
    
    # 初始化函数( 构造函数 )
    def __init__(self, name ,age):
        # 创建实例的时候 对name和age属性进行赋值
        self.name = name
        self.age = age
    
    # 定义在类里面的方法为实例方法
    def eat(self):
        print('吃饭')
    
    # 静态方法 （静态方法里不允许写self）
    @staticmethod 
    def method():
        print('使用staticmethod进行修饰，所以我是静态方法')
        
        
    # 类方法
    @classmethod 
    def cm(cls):
        print('使用calssmethod进行修饰，所以我是类方法')
    
12345678910111213141516171819202122232425

类实例对象

# 类实例创建语法  stu = Student()
# 假设已存在上面的 Student 类  

# stu1就是Student类的实例对象，该实例对象中可以访问到类中的属性和方法
stu1 = Student('zzl', 18) # 创建实例
print(stu1.name) # zzl
print(stu1.age) # 18
stu1.eat() # 吃饭
12345678

动态绑定属性和方法

# 假设已存在Student类  
stu = Student('zzl', 18)  

# 绑定 gender 属性 
stu.gender = '男' 
print(stu.gender) # 男

# 绑定 show 方法
def show():
    print('show方法执行')
stu.show = show
stu.show() # show方法执行

12345678910111213

面向对象的三大特征

封装 （提高程序的安全性）
将数据（属性）和行为（方法）封装到类对象中，在方法内部对属性进行操作，在类对象的外部调用方法。这样无需关心方法内部的具体实现细节，从而隔离了复杂度。在python中没有专门的修饰符用户属性的私有化，如果该属性不想被类对象访问，可以在属性名前面加两个 '_’

继承

多态

代码演示

# 继承
class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def info(self):
        print(self.name, self.age)


class Student(Person):
    def __init__(self, name, age, stu_no):
        super().__init__(name, age)
        self.stu_no = stu_no


class Teacher(Person):
    def __init__(self, name, age, teachofyear):
        super().__init__(name, age)
        self.teachofyear = teachofyear


stu = Student('张三', 20, 10001)
teacher = Teacher('李四', 35, 10)

stu.info() # 张三 20
teacher.info() # 李四 35

# python 支持多继承 
class A(class1, class2):  
    pass
    
# 方法重写  
# 方法重写就是在子类里定义与父类重名的方法，这样就会优先调用子类的定义的方法
12345678910111213141516171819202122232425262728293031323334

模块和包

定义：每一个.py文件就是一个模块

使用模块化的好处

1. 方便其他程序和脚本的导入使用
2. 避免函数名和变量名冲突
3. 提高代码的可维护性
4. 提高代码的可重用性

导入模块

# 导入模块
import 模块名称 [as 别名]  

# 导入模块中的指定函数(or 变量 or 类)
from 模块名称 import 函数/变量/类
12345

包

包是一个分层次的目录结构，它将一组功能相近的模块组织在一个目录下

作用

1. 代码规范
2. 避免模块名称冲突

包与目录的区别

1. 包含__init__.py文件的目录称为包
2. 目录里通常不存在__init__.py文件

包的导入
import 包名.模块名

文件的读写

内置函数open()创建文件对象

# file = open( filename, [mode, encoding] )

# 假设有一个名为a的文本文件，里面有hello world
file = open('a.txt', 'r')
print(file.readlines()) # ['hello world']
file.close()
123456

常用的文件打开模式

打开模式描述r以只读模式打开文件，文件的指针将会放在文件的开头w以只写模式打开文件，如果文件不存在则创建，如果文件存在，则覆盖原有内容，文件指针在文件的开头a以追加模式打开文件，如果文件不存在则创建，文件指针在文件开头，如果文件存在，则在文件末尾追加内容b以二进制方式打开文件，不能单独使用，需要与其他模式一起使用，rb,后者wb+以读写方式打开文件，不能单独使用，需要与其他模式一起使用，如a+

文件对象的常用方法

方法名描述read([size])从文件中读取size个字节或字符的内容返回，若省略size，则读取到文件末尾，即一次读取文件所有内容readline()从文本文件中读取一行内容readlines()把文本文件中每一行都作为独立的字符串对象，并将这些对象放入列表返回write(str)将字符串str内容写入文件writelines(s_list)将字符串列表s_list写入文本文件，不添加换行符seek(offset[, whence])把文件指针移动到新的位置，offset表示相对与whence的位置：
offset：为正则往结束方向移动，为负则往开始方向移动
whence不同的值代表不同含义：
0：从文件头开始计算（默认值）
1：从当前位置开始计算
2：从文件末尾开始计算tell()返回文件指针的当前位置flush()把缓冲区的内容写入文件，但不关闭文件close()把缓冲区的内容写入文件，同时关闭文件，释放文件对象相关资源

with语句（上下文管理器）

with语句可以自动管理上下文资源，不论什么原因跳出with语句都能确保文件正确的关闭，以此来达到释放资源的目的

# with使用  
with open(filename, mode) as file:
    pass 
123

目录操作 （os 和 os.path）

1. os模块是python内置的与操作系统功能和文件系统相关的模块，该模块中的语句的执行结果通常与操作系统有关，在不同的操作系统上运行，得到的结果可能不一样
2. os模块与os.path模块用于对目录或文件进行操作

import os
# 打开计算器
os.system('calc.exe')
# 打开记事本
os.system('notepad.exe')

# 打开可执行文件
os.startfile('路径')
12345678

os模块操作目录相关函数

函数说明getcwd()返回当前的工作目录listdir(path)返回指定路径下的文件和目录信息mkdir(path[, mode])创建目录makedirs(path1/path2…[, mode])创建多级目录rmdir(path)删除目录removedirs(path1/path2…)删除多级目录chdir(path)将path设置为当前工作目录

os.path模块操作目录相关函数

函数说明abspath(path)用于获取文件或目录的绝对路径exists(path)用于判断文件或目录是否存在，如果存在返回True,否则返回Falsejoin(path, name)将目录与目录，或者目录与文件名连接起来split(path)分离目录和文件名splittext(name)分离文件名和扩展名basename(path)从一个目录中提取文件名dirname(path)从一个路径中提取文件路径，不包括文件名isdir(path)判断是否为路径

python内置模块

使用import关键字引入

模块描述random随机数生成traceback处理异常sys与python解释器及环境操作相关的标准库time提供与时间相关的各种函数的标准库os提供了访问操作系统服务功能的标准库calendar提供与日期相关的各种函数的标准库urllib用于读取来自网上（服务器）数据的标准库json用于使用JSON序列化和反序列化对象re用于在字符串中执行正则表达式匹配和替换math提供标准算术运算函数的标准库decimal用于进行精准控制运算精度、有效数位和四舍五入操作的十进制运算logging提供了灵活的记录事件、错误、警告和调试信息等日志信息的功能