Python基础3

文件操作

模式	描述
r	以只读方式打开文件。文件的指针将会放在文件的开头。这时默认模式
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这时默认格式
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w	打开一个文件用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
a	打开一个文件用于追加。如果该文件已存在，文件指针会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有的内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

巧记

'''
1. 如果是带b的，不管是r和b配合，还是w、a和b配合，但凡是带b的，都是以二进制格式操作文件
2. 但凡是带+号的，都是可读可写模式。
3. r+ 、rb+、w+都是可读可写有什么区别吗？？？ 所有的访问模式，它的基础特点都要遵循与主访问模式（r、w、a）。比如：rb、r+、rb+都是基于r访问模式拓展开来。
举个栗子:
      比如说r,只读方式打开，如果文件不存在，会报错。如果rb、r+、rb+去打开一个文件，不论是读写还是二进制读写，只要文件不存在，但凡带r的都报错。
      比如说w访问模式的，不管是wb、w+、wb+，如果打开一个文件，文件不存在，则新建文件。这就可以说明w+和r+的区别了。
 
 
注意：     
	1. 文件指针：相当于光标的位置，光标后的内容可以读取出来，光标前的内容读取不出来。文件指针关系着文件写入和读取数据的内容。
    2. a访问模式，以a为基准的访问模式，文件指针都是在结尾，因为在后面才开始追加。
	3. 文件操作不仅有三种主访问模式（r、w、a），依赖这三种主访问模式，还可以拓展好几种访问模式。
    
'''

文件的打开、写入、关闭

'''
 open()函数，可以打开已经存在的文件，或者创建一个新文件
 语法 open(name,mode)
 name:要打开的目标文件名的字符串（可以包括文件所在的具体路径）
 mode:设置打开文件的模式（访问模式）：只读、写入、追加等
'''
# open打开
f = open('test.txt','w') # 存在打开，如果这个文件不存在，则新建此文件
# 读写操作write read
f.write('aaa')
# 关闭
f.close()

总结

• 文件操作的作用是把一些内容(数据)存储起来,可以让程序下一次执行的时候直接使用，而不必重新制作一份,省事省力.
• 这里的关闭相当于就是保存了。如果文件不关闭,这个文件将一直占用计算机内存,内存消耗比较大的,对于计算机来说,内存消耗大,内存占用量大，风险比较高了.
• 注意:可以只打开和关闭文件,不进行任何读写操作

主访问模式的特点（r、w、a）

# 主访问模式的特点，基础访问模式的特点（r、w、a）
'''
实验目标：
    1. 访问模式对文档的影响
    2. 访问模式对wirte（）的影响
    3. 访问模式是否可以省略
'''
# r:如果文件不存在，报错：不支持写入操作，表示只读
f = open('test.txt','r') # 读操作，没有这个文件会报错
f.write('aa') # 报错，因为r是只读模式，不能写入

# 正确操作
f = open('test.txt','r')
f.close()

# w 只写，如果文件不存在，新建文件，执行写入。如果存在，这覆盖原有的内容
f = open('1.txt','w') # 如果没有1.txt这个文件，则会新建这个文件
f.write('123456') # 1.txt文件中的内容是aaa，现在变成了123456
f.close()

# a 追加，如果文件不存在，新建文件，再写内容，如果存在，在原有内容的基础上，追加新内容
f = open('1.txt','a')  # 如果文件不存在，则新建文件
f.write('hello')
f.close()

# 访问模式参数可省略，默认为r
f.open('1.txt')
f.close()

读取函数（read、readlines、readline）

• read

'''
read()
文件对象.read(num)
num表示要从文件中读取的数据的长度（单位是字节），如果不写参数，则读取所有内容
'''

# 文章内容如果换行，底层有\n,会有字节占位，导致read书写参数读取出来的眼睛看到的个数和参数不匹配
# read不写参数表示读取所有：
f.open('1.txt','r')
print(f.read())  # read不写参数,表示读取所有
print(f.read(10))

• readline

'''
readline()一次读取一行内容
'''
f = open('1.txt','r')
con = f.readline()
print(con) # 文件内容的第一行
con = f.readline()
print(con) # 文件内容的第二行
f.close()

• readlines

'''
readlines()可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素
'''
f = open('1.txt','r')
con = f.readlines()
print(con) # ['hello word123456123456123456\n', ' word123456123456123456\n', ' 1233']
f.close()

访问模式的特点（r+、w+、a+）

除了主访问模式外（r、w、a），说一下其他的访问模式（r+、w+、a+）

"""
带加号的访问模式对文件的影响，以及文件指针对数据读取的影响
测试目标：
    1.r+ 和 w+ a+的区别
    2.文件指针对数据读取的影响

"""
# r+:r没有该文件则报错；文件指针在开头，所以能读取出来数据
f = open('1.txt','r+')
print(f.read())
f.close()

# w+: 没有该文件会新建文件：w特点：文件指针在开头，用新内容覆盖原内容
f = open('10.txt','w+') # 如果没有该文件则新建文件

# 用新内容把原内容覆盖掉，这里只进行了读取，没有调用write写入，那就代表写入的是空的，空的内容把有数据的内容给覆盖掉了
f = open('1.txt','w+') # 此时文件里的内容被清空，因为被覆盖了
con = f.read()
print(con)
f.close()

# a+:没有该文件会新建文件：文件指针在结尾，无法读取数据（文件指针后面没有数据）
f = open('1.txt','a+')
con = f.read() # 文件指针在结尾，无法读取数据（文件指针后面没有数据）
print(con)
f.close()

文件的定位读写（tell函数、seek函数）

• tell()：返回文件指针的当前位置

# dong.txt文件中的内容是：hello,world
f = open('dong.txt','r')
w = f.read(4)
print(f'读取的是：{w}') # hell
# 查找当前位置
p = f.tell() 
print('当前位置：{p}') # 4

• seek()：从指定位置开始读取或者写入文件的数据

'''
语法：文件对象.seek（偏移量，起始位置）
起始位置：0 文件开头  1 当前位置  2 文件结尾
作用：用来移动文件指针

目标：
    1. r模式 ：改变文件指针位置，改变读取数据开始位置或把文件指针放结尾（无法读取数据）
    2. o模式 ： 改变文件指针位置，做到可以读取出来数据
'''
# test.txt文件的内容是：aaaaa

f = open('test.txt','r+')
# 改变读取数据开始位置
# f.seek(2,0) # 从第三个a开始读取
f.seek(0,2)  # 指针到了文件结尾，读取不出来数据 0 文件开头  1 当前位置  2 文件结尾
con = f.read()
print(con)

# 2. a 改变文件指针位置，做到可以读取出来数据
f.seek(0,0)  # 这时指针跑到了开头，这时可以读出数据
# f.seek(0)   # 如果是两个0，可以省略写一个0
con = f.read()
print(con)
f.close()

文件备份

# 用户输入目标文件
old_name = input('请输入要备份文件名')
print(old_name)
# 2. 规划备份文件的名字
# 2.1 提取后缀 -- 找到名字中的点 -- 名字和后缀分离 -- 最右侧的点才是后缀的点 -- 字符串查找某个字串rfind
index = old_name.find('.')

# 进行优化：有效文件才备份  .txt这个文件名就不是有效的
if index > 0:
	postfix = old_name[index:]
# 2.2 组织新名字 = 原名字 + [备份] + 后缀
# 原名字就是字符串的一部分字串 -- 切片[开始：结束：步长]
print(old_name[:index]) # 开始从0开始，可以省略不用写
print(old_name[index:])   # 因为提取到最后，所以后面可以省略
new_name = old_name[:index] + '[备份]'+postfix  # 如果用户输入的文件名不符合，则会报错
print(new_name)
# 3. 备份文件导入数据（数据和源文件一样）
# 对于计算机来讲，我们存储什么，对于底层，他都是以二进制形式做的存储以及操作，用二进制打开没有问题的。
# 3.1 打开原文件和备份原文件
old_f = open(old_name,'rb')
new_f = open(new_name,'wb')
# 3.2 原文件读取，备份文件写入
# 如果不确定目标文件大小，循环读取写入，当读取出来的数据没有了，终止循环
while True:
	con = old_f.read(1024)
	if len(con) == 0:
		break
	new_f.write(con)
# 3.3 关闭文件
old_f.close()
new_f.close()

文件和文件夹操作

使用os模块的一些方法，来进行文件和文件夹的操作

'''
在python中要操作文件和文件夹的话，要借助模块，要借助os模块。
1. 导入模块os
2. 使用模块内功能
'''
import os # 导入模块，借助os模块里面的相关功能。使用os模块相关功能：os.函数名()
# rename(目标文件,新文件名)：重命名
# rename的第一个参数其实是路径，因为这里直接在当前目录下，所以直接写的文件名
 os.rename('1.txt','100.txt')  # 此时文件已经改名

# remove(目标文件名)
os.remove('1.txt')  # 此时文件已经删除，如果要删除的文件不存在则会报错

# mkdir(文件夹名字):创建文件夹 也可以带路径的文件夹名字
os.mkdir('aa')  # 创建文件夹成功

# rmdir(文件夹名称)：删除文件夹
os.rmdir('aa')  # 删除成功

# getcwd()：返回当前文件所在目录路径
print(os.getcwd())

# chdir(目录)改变目录路径
os.mkdir('aa')  # 创建aa文件夹
os.chdir('aa')  # 切换到aa文件夹
os.mkdir('bb')   # 在文件夹中创建bb

# listdir(目录)：获取某个文件夹下所有文件，返回一个列表
print(os.listdir())  # 如果没有填写目录，那么显示当前文件所在的文件夹下所有文件
print(os.listdir('aa')) # 获取aa文件夹下所有的数据

# rename(目标文件名，新文件名) -- 重命名文件夹 aa重命名为aaaa
os.rename('aa','aaaaa')

批量重命名

# 需求1：把code文件夹所有文件重命名 Python xxxx
import os
# 找到所有文件：获取code文件夹的目录列表 -- listdir()
f_list = os.listdir()
print(f_list)
# 2. 构造名字
for i in f_list:
	new_name = 'py_'+i
	# 重命名
	os.rename(i,new_name)

文件夹重命名进行优化，用flag来控制文件名的修改

# 需求2：删除Python_   重命名：1.构造条件的数据 2.书写if
import os
flag = 2
f_list = os.listdir()
# 构造名字
for i in f_list:
	if flag == 1:
		new_name = 'py_'+i
	elif flag == 2:
		num = len('Python_')
		new_name = i[num:]
	#重命名
	os.rename(i,new_name) # 改名成功

总结

'''
r文件指针在开头，能读取出来数据
w文件指针在开头，会把原内容覆盖掉
a文件指针在结尾，向右读取不出来数据，想要a模式能读取出来数据，用seek()改变文件指针位置

可以重命名文件也可以重命名文件夹
'''


"""
文件操作步骤
    打开：文件对象 = open(目标文件，访问模式)
    操作：
        1.读
          文件对象.read()
          文件对象.readlines()
          文件对象.readline()
        2.写
           文件对象.write()
           
    改变指针：seek()
    
    关闭: 文件对象.close
主访问模式
    w:写，文件不存在则新建该文件
    r:读，文件不存在则报错
    a:追加
文件和文件夹操作
    重命名：os.rename     可以重命名文件也可以重命名文件夹
    获取当前目录路径：os.getcwd()
    获取目录列表：os.listdir()
            
"""

Python面向对象（上）

类和对象

# 需求：洗衣服   功能：能洗衣服
# 1. 定义洗衣机类
'''
class 类名():
    代码
'''
class washer():
	def wash(self): # 这里的self指的是调用该函数的对象
		print('能洗衣服') # 能洗衣服
		print(self) # <__main__.Washer object at 0x000002124371FFD0>
# 创建对象
# 对象名 = 类名()
haier = washer()
print(haier) # 输出地址值  <__main__.Washer object at 0x0000021B6277FFD0>
# 使用wash功能 -- 实例方法/对象方法 -- 对象名wash()
haier.wash() 

• self的含义

'''
wash函数被调用了，haier对象调用的。也就是说haier对象调用了wash，就是将haier这个对象传入到self里面去，
当打印self，打印出来的跟haier对象打印的时候出现的内存地址是一样的。
'''
class Washer():
	def wash(self):
	print('洗衣服')
	print(self) # <__main__.Washer object at 0x000002124371FFD0>
haier = Washer()
print(haier)  # <__main__.Washer object at 0x000002124371FFD0>
haier.wash()
# 由于打印对象和打印self得到的内存地址相同，所以self指的是调用该函数的对象
# self指的是调用该函数的对象

• 一个类出创建多个对象

# 1. 一个类可以创建多个对象 2. 多个对象都调用函数的时候，self地址是不相同的
class Washer():
	def wash(self):
	print(self)
haier = Washer()
haier2 = Washer()
# self地址是不相同的
haier.wash() # self :  <__main__.Washer object at 0x000001EACFFBFFD0>
haier2.wash() # self : <__main__.Washer object at 0x000001EACFFBFFA0>

添加和获取对象属性

• 类外面添加和获取对象属性

class Washer():
	def wash(self):
	print('洗衣服')
haier = Washer()
# 添加属性 对象名.属性名 = 值
haier.width = 400
haier.height = 500
# 获取属性 对象名.属性名
print(f'洗衣机的宽度：{haier.width}') # 洗衣机的宽度是400
print(f'洗衣机的高度：{haier.height}') # 洗衣机的高度是500

• 类里面获取对象属性

class Washer():
	def wash(self):
		print('洗衣服')
	def info(self):
		print(f'洗衣机的宽度是{self.width}')
        print(f'洗衣机的高度是{self.height}')
hair = Washer()
# 添加属性 对象名.属性名 = 值
hair.width = 400
hair.height = 500
# 对象调用方法
hair.info()

魔法方法（init、str、del）

• init

# _init_()方法的作用：初始化对象
class Washer():
	def __init__(self):
		self.width = 500
		self.height = 800
	def info(self):
		print(f'洗衣机的宽度是{self.width}')
        print(f'洗衣机的高度是{self.height}')
haier = Washer()
haier.info()
'''
1. _init_()方法，再创建一个对象时默认被调用，不需要手动调用
2. _init_(self)中的self参数，不需要开发者传递，python解释器会自动把当前的对象引用传递过去
'''

• 带参数的__init__魔法方法

# 1. 定义类：带参数的init：宽度和高度   作用：创建多个对象且属性值不同
# 实例方法：调用实例属性
class Washer():
    def __init__(self, width, height):
        self.width = width
        self.height = height
    def print_info(self):
        print(f'洗衣机的宽度是{self.width},洗衣机的高度是{self.height}')

# 2.  创建对象，创建多个对象且属性值不同：调用实例方法
haier = Washer(10,20)
haier.print_info()

haier2 = Washer(100, 200)
haier2.print_info()

• str

class Washer():
    def __init__(self):
        self.width = 300
    def __str__(self):
        return '解释说明：类的说明或对象状态的说明'
hair = Washer()
print(hair)
'''
作用说明：当使用print输出对象的时候，默认打印出现的内存地址。如果类定义了_str_方法，
那么就会打印从这个方法中return的数据
'''

• del

'''
del hair ,不去手动删除对象也能调用del魔法方法，这几行代码执行完之后，内存中存储的函数、类、变量也会自动释放内存，
即对象也会被删除掉，所以del魔法方法也是被自动调用的。
'''
class Washer():
    def __init__(self):
        self.width = 300
    def __del__(self):
        print('对象已经删除')
hair = Washer()
# del hair 当删除对象时，python解释器也会默认调用__del__()方法

栗子

• 烤地瓜

#coding=gbk
class SweetPotato():
    def __init__(self):
        # 被烤时间
        self.cook_time = 0
        # 考的状态
        self.cook_state = '生的'
        # 调料列表
        self.condiment = []
    def cook(self, time):
        '''烤地瓜'''
        #计算烤的时间
        self.cook_time += time
        # 判断地瓜状态
        if 0 <= self.cook_time < 3:
            self.cook_state = '生的'
        elif 3 <= self.cook_time < 5:
            self.cook_state = '半生不熟'
        elif 5 <= self.cook_time < 8:
            self.cook_state = '熟了'
        elif self.cook_time >=8:
            self.cook_state = '烤糊了'
    def add_condiments(self,condiment):
        # 用户意愿的调料追加到调料列表
        self.condiment.append(condiment)

    def __str__(self):
        return f'这个地瓜的被烤过的时间是{self.cook_time},状态是{self.cook_state},调料有{self.condiment}'


# 2. 创建对象并调用对应的实例方法

digua1 = SweetPotato()
print(digua1)

digua1.cook(2)
digua1.add_condiments('辣椒面儿')
print(digua1)

digua1.cook(4)
digua1.add_condiments('酱油')
print(digua1)

• 搬家具

#coding=gbk
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 item.area <= self.free_area :
            self.furniture.append(item.name)
            self.free_area -= item.area
        else:
            print('用户家具太大,剩余面积不足,无法容纳')

bed = Furniture('双人床',6)
sofa = Furniture('沙发',10)

jia1 = Home('北京',1000)
print(jia1)
jia1.add_furniture(bed)
print(jia1)
ball = Furniture('篮球场',2000)
jia1.add_furniture(ball)
print(jia1)

总结

'''
类
    创建类
        class 类名():
            代码
对象
    对象名 = 类名()


添加对象属性
    类外面
        对象名.属性名 = 值
    类里面
        self.属性名 = 值


获取对象属性
    类外面
        对象名.属性名
    类里面
        self.属性名


魔法方法
    __init__():初始化
    __str__():输出对象信息
    __del__():删除对象时调用
魔法方法具有特殊功能的函数,这三个魔法方法不需要手动调用,因为当某一种情况发生的时候,解释器会自动调用的函数.
'''

Python面向对象（下）

• 面向对象的三大特性：封装、继承和多态
• 类属性和实例属性
• 静态方法和类方法

封装

把隐藏属性、方法与方法实现细节的过程成为封装。后面继承那里还会涉及保护类里面的属性，避免外界随意赋值。在获取和修改私有权限涉及到。

继承

# 继承：子类默认继承父类的所有属性和方法
# 定义父类
class A(object):
    def __init__(self):
        self.num = 1

    def info(self):
        print(self.num)
# 2. 定义子类 继承父类
class B(A):
    pass
# 3. 创建对象，验证结论
res = B()
res.info()

'''
再python中，所有类默认继承object类，object类是顶级类或基类其他子类叫做派生类
'''

• 单继承

# 1. 师傅类 属性和方法
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
# 2. 定义徒弟类，继承师傅类
class Prentice(Master):
    pass
# 3. 用徒弟类创建对象，调用实例属性和方法
daqiu  = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()

• 多继承

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')

class School(object):
    def __init__(self):
        self.kongfu = '[哈哈煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')

class Prentice(School,Master):
    pass

daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()

'''
多继承就是一个类同时继承多个父类
结论：如果一个类继承多个符类，优先继承第一个父类的同名属性和方法
'''

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

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

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')

class School(object):
    def __init__(self):
        self.kongfu = '[哈哈煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
# 定义徒弟类，继承师傅类 和 学校类， 添加和父类同名的属性和方法
class Prentice(School,Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果子技术]'
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')

daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()
'''
结论：如果子类和父类拥有同名属性和方法，子类创建对象调用属性和方法的时候，
调用到的是子类里面的同名属性和方法。这个现象在python语言里当中，简称之为子类重写父类同名方法和属性
'''

• 子类调用父类方法和属性

'''
子类重写父类同名属性和方法，访问的是子类的属性和方法.
如果也想要访问父类的属性和方法该如何去做那？？？
在子类中调用父类的属性和方法
'''
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')

class School(object):
    def __init__(self):
        self.kongfu = '[哈哈煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')

class Prentice(School,Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果子技术]'
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
	 # 调用父类的同名方法和属性，把父类的同名属性和方法再次封装
     # 调用父类方法，但是为保证调用到的也是父类的属性，必须在调用方法前调用父类的初始化
    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)

    def male_school_cake(self):
        School.__init__(self)
        School.make_cake(self)

daqiu = Prentice()
 # 如果事先调用了父类的属性和方法，父类属性会覆盖子类属性，所以在调用子类属性前调用父类的初始化
print(daqiu.kongfu)
daqiu.make_cake()

daqiu.make_master_cake()
daqiu.male_school_cake()

多层继承

'''
多层继承就是 爷爷的财产继承给父亲，父亲又把自己的财产传递给它的儿子
'''
# 师傅类 属性和方法
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
# 为了验证多继承，添加School父类
class School(object):
    def __init__(self):
        self.kongfu = '[哈哈煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
        
# 2. 定义徒弟类，继承师傅类 和 学校类， 添加和父类同名的属性和方法
class Prentice(School,Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果子技术]'
    def make_cake(self):
    # 如果事先调用了父类的属性和方法，父类属性会覆盖子类属性，所以在调用子类属性前调用父类的初始化
        print(f'运用{self.kongfu}制作煎饼果子')

	 # 调用父类的同名方法和属性，把父类的同名属性和方法再次封装
    # 调用父类方法，但是为保证调用到的也是父类的属性，必须在调用方法前调用父类的初始化
    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)

    def male_school_cake(self):
        School.__init__(self)
        School.make_cake(self)
# 步骤：1. 创建Tusun，用这个类创建对象   2. 用这个对象调用父类的属性或方法
class Tusun(Prentice):
    pass

xiaoqiu = Tusun()
xiaoqiu.make_cake()
xiaoqiu.male_school_cake()
xiaoqiu.make_master_cake()
print(Tusun.__mro__)

• 小拓展（mro）

'''
如果要查看某个类的父类继承关系， 类.__mro__ 进行查看
'''
# 1. 师傅类 属性和方法
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
# 2. 定义徒弟类，继承师傅类
class Prentice(Master):
    pass

# 3. 用徒弟类创建对象，调用实例属性和方法
daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()

print(Prentice.__mro__)   # (<class '__main__.Prentice'>, <class '__main__.Master'>, <class 'object'>)

super()方法

'''
super方法的作用是调用父类方法用的，有参数写法，有无参写法。
无参写法最简单直观。
使用super()可以自动查找父类。调用顺序遵循_mro_类属性的顺序。比较适合单继承使用。
'''
class Master(object):
	def __init__(self):
		self.kongfu = '[古法煎饼果子配方]'
	def make_cake(self):
		print(f'运用{self.kongfu}制作煎饼果子')
class School(Master):
	def __init__(self):
		self.kongfu = '[黑马煎饼果子配方]'
	def make_cake(self):
		print(f'运用{self.kongfu}制作煎饼果子')
		#  super()带参数写法
		#super(School,self).__init__()
		#super(School,self).make_cake()

		# 无参数super()
		supper().__init__()
		supper().make_cake()

class Prentice(School):
	def __init__(self):
		self.kongfu = '[独创煎饼果子技术]'
	def make_cake(self):
		self.__init__()
		print(f'运用{self.kongfu}制作煎饼果子')
		# 调用父类的同名方法和属性，把父类的同名属性和方法再次封装
    	# 调用父类方法，但是为保证调用到的也是父类的属性，必须在调用方法前调用父类的初始化
    def make_mast_cake(self):
    	Master.__init__(self)
    	Master.make_cake(self)
    def make_school_cake(self):
    	School.__init__(self)
    	School.make_cake(self)

		 # 子类调用父类的同名方法和属性：把父类的同名属性和方法再次封装
	def make_old_cake(self):
		# 方法一：如果定义的类名修改，麻烦。代码量庞大，冗余。
        # School.__init__(self)
        # School.make_cake(self)
        # Master.__init__(self)
        # Master.make_cake(self)
        
        # 方法二: super()
        # 2.1 super(当前类名，self).函数()
        # super(Prentice,self).__init__()
        # super(Prentice,self).make_cake()

		 # 2.2 无参数的super()
        super().__init__()
        super().make_cake()
		
daqiu = Prentice()
daqiu.make_old_cake()

获取和修改私有属性

• 私有权限

'''
私有属性和私有方法只能在类里面访问和修改。
在Python中，一般定义函数名get_xx用来获取私有属性，定义set_xx用来修改私有属性值
get_xx、set_xx函数名可以是其他的名，使用他们只是工作习惯
'''
# 1. 师傅类 属性和方法
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


# 为了验证多继承，添加School父类
class School(object):
    def __init__(self):
        self.kongfu = '[黑马煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')

# 2. 定义徒弟类，继承师傅类 和 学校类， 添加和父类同名的属性和方法
class Prentice( School,Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果子技术]'
        # self.money = 3000000
        # 添加私有属性
        self.__money = 3000000

    # 定义函数：获取私有属性值 get_xx
    def get_money(self):
        return self.__money
    # 定义函数：修改私有属性值 set_xx
    def set_money(self):
        self.__money = 999999

    # 定义私有方法
    def __info_print(self):
        print("这是一个私有方法")

    def make_cake(self):
        # 如果事先调用了父类的属性和方法，父类属性会覆盖子类属性，所以在调用子类属性前调用父类的初始化
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')


# 步骤：1. 创建Tusun，用这个类创建对象   2.用这个对象调用父类的属性或方法
class Tusun(Prentice):
    pass

xiaoqiu = Tusun()
# print(xiaoqiu.money)  # 添加了私有属性之后就不能访问了
# xiaoqiu.info_print()   # 添加了私有方法之后就不访问了
print(xiaoqiu.get_money())    # 3000000
xiaoqiu.set_money()
print(xiaoqiu.get_money())   # 999999

'''
继承的特点：
    子类默认拥有父类的所有属性和方法
    子类重写父类同名方法和属性
    子类调用父类同名方法和属性
super()方法快速调用父类方法

私有权限：
    不能继承给子类的属性和方法需要添加私有权限
    语法
class 类名():
    # 私有属性
    __属性名 = 值

    # 私有方法
    def __函数名(self)
        代码

在类的里面可以要获取私有属性get_xx
修改私有属性set_xx
'''

多态

定义： 多态是一种使用对象的方式，子类重写父类方法，调用不同子类对象的相同父类方法，可以产生不同的执行结果
定义的通俗理解： 传入不同的对象，产生不同的结果
好处 ： 调用灵活，有了多态，更容易编出通用的代码，做出通用的编程，以适应需求的不断变化。

# 需求: 警务人员和警犬一起工作，警犬分为两种：追击敌人和追查毒品，携带不同的警犬，执行不同的工作

'''
实现步骤：
定义父类，并提供公共方法
定义子类，并重写父类方法
传递子类对象给调用者，可以看到不同子类执行效果不同
'''
class Dog(object):
	def work(self):
		pass
# 2. 定义子类.  子类重写父类方法：定义两个类表示不同的警犬
class ArmyDog(Dog):
	def work(self):
		print('追击敌人')
class DrugDog(Dog):
	def work(self):
		print('追查毒品')
class Person(object):
	def work_with_dog(self,dog):
		dog.work()
# 3. 创建对象. 调用不同的功能. 传入不同的对象， 观察执行的结果
ad = ArmyDog()
dd = DrugDog()
daqiu = Person()
daqiu.work_with_dog(ad)  # 追击敌人
daqiu.work_with_dog(dd)  # 追查毒品

类属性和实例属性

类属性

class Dog(object):
	 # 类属性
	tooth = 10

• 设置和访问类属性

'''
类属性就是类对象所拥有的属性，它被该类的所有实例对象所共有。
类属性可以使用类对象或实例对象访问
'''
class Dog(object):
	# 类属性
	tooth = 10

# 2. 创建对象
wangcai = Dog()
xiaohei = Dog()
# 3. 访问类属性：类和对象

print(Dog.tooth)
print(wangcai.tooth)
print(xiaohei.tooth)

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

• 修改类属性

'''
类属性只能通过类对象修改，不能通过实例对象修改，如果通过实例对象修改类属性，表示的是创建了一个实例属性
'''
class Dog(object):
	# 类属性
	tooth = 10

#  创建对象
wangcai = Dog()
xiaohei = Dog()

Dog.tooth = 20

print(Dog.tooth)
print(wangcai.tooth)
print(xiaohei.tooth)

wangcai.tooth = 200

print(Dog.tooth)
print(wangcai.tooth)
print(xiaohei.tooth)

实例属性

def __init__(self):
	# 实例属性
	self.age = 1

类方法和静态方法

• 类方法

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

类方法使用场景:
    1. 当方法中 需要使用类对象（如访问私有类属性等）时，定义类方法
    2. 类方法一般和类属性配合使用
'''
class Dog(object):
	__tooth = 10

	# 定义类属性
	@classmethod
	def get_tooth(cls): #cls代表Dog这个类
		return cls.__tooth
# 创建对象(通过)
wangcai = Dog()
res = wangcai.get_tooth()
print(res)
# 也可以直接通过类名调用类方法
res = Dog.get_tooth()
print(res)

静态方法

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

静态方法使用场景：
    1. 当方法中既不需要使用实例对象（如实例方法，实例属性），也不需要使用类对象（如类属性、类方法、创建实例等）时，
    定义静态方法
    2. 取消不需要的参数传递，有利于减少不必要的内存占用和性能消耗
'''
class Dog(object):
	@staticmethod
	def info():
		print('这是一个静态方法')
wangcai = Dog()
# 调用静态方法：类 和 对象
wangcai.info()
Dog.info()