准备在这篇中将Python基础部分完结，敬请期待，未完待续…
文件模式
模式描述r以只读方式打开文件。文件的指针将会放在文件的开头。这时默认模式rb以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这时默认格式r+打开一个文件用于读写。文件指针将会放在文件的开头。rb+以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。w打开一个文件用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件wb以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。w+打开一个文件用于读写。如果该文件已存在则打开文件，并从头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件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），依赖这三种主访问模式，还可以拓展好几种访问模式。 '''
上栗子，一看就懂：
''' 在python，使用open函数，可以打开已经存在的文件，或者创建一个新文件。 语法：open(name, mode) name：是要打开的目标文件名的字符串（可以包含文件所在的具体路径） mode: 设置打开文件的模式（访问模式）：只读、写入、追加等。 ''' # 1. 打开open() f = open('test.txt','w') # 如果这个文件不存在，则新建此文件 # 2. 读写操作 write() read() f.write('aaa') # 3. 关闭 close() f.close() ''' 总结: 1.文件操作的作用是把一些内容(数据)存储起来,可以让程序下一次执行的时候直接使用，而不必重新制作一份,省事省力. 2.这里的关闭相当于就是保存了。如果文件不关闭,这个文件将一直占用计算机内存,内存消耗比较大的,对于计算机来说,内存消耗大,内存占用量大，风险比较高了. 3. 注意:可以只打开和关闭文件,不进行任何读写操作 '''
主访问模式（r、w、a）
# 主访问模式的特点，基础访问模式的特点（r、w、a） ''' 实验目标： 1. 访问模式对文档的影响 2. 访问模式对wirte（）的影响 3. 访问模式是否可以省略 ''' ========================================================================= r: 如果文件不存在，报错：不支持写入操作，表示只读 f = open('test.txt1', 'r') # 因为是读操作，没有这个文件，所以报错 f.write('aa') # 报错,因为是只读模式，不能写入 # 下面的才能正常执行 f = open('test.txt','r') f.close() ========================================================================== # w：只写，如果文件不存在，新建文件，执行写入。如果不存在则会会覆盖原有内容 f = open('1.txt', 'w') # 如果没有1.txt这个文件，则会新建这个文件 f.write('bbb') # 1.txt文件中的内容是aaa，现在变成了bbb f.close() ========================================================================== # a：追加，如果文件不存在，新建文件，在写入内容。如果文件存在，在原有内容基础上，追加新内容 f = open('1.txt','a') # f = open('2.txt','a') # 如果文件不存在，则新建文件 f.write('helloworld') f.close() ========================================================================= # 访问模式参数是否可以省略，如果省略表示访问模式为r # f = open('100.txt') # 找不到文件，报错 f = open('1.txt') # 这个时候不报错了 f.close()
read()
''' read() 文件对象.read(num) num表示要从文件中读取的数据的长度（单位是字节），如果不写参数，则读取所有内容 ''' f = open('test.txt','r') # 文章内容如果换行，底层有\n,会有字节占位，导致read书写参数读取出来的眼睛看到的个数和参数不匹配 # read不写参数表示读取所有： # print(f.read()) # read不写参数,表示读取所有 print(f.read(10))readlines()
''' readlines()可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素 ''' f = open('test.txt','r') con = f.readlines() print(con) # 输出['aaaaa\n', 'bbbbb\n', 'ccccc\n', 'ddddd'] \n是换行符的意思 f.close()readline()
''' readline()一次读取一行内容 ''' f = open('test.txt','r') con = f.readline() print(con) # aaaaa 这是test.txt文件内容的第一行 con = f.readline() print(con) # bbbbb 这时test.txt文件内容的第二行 f.close()
除了主访问模式外（r、w、a），说一下其他的访问模式（r+、w+、a+）
""" 带加号的访问模式对文件的影响，以及文件指针对数据读取的影响 测试目标： 1.r+ 和 w+ a+的区别 2.文件指针对数据读取的影响 """ # r+：r没有该文件则报错；文件指针在开头，所以能读取出来数据 f = open('test.txt','r+') print(f.read()) # f.close() # w+: 没有该文件会新建文件：w特点：文件指针在开头，用新内容覆盖原内容 # f = open('test1.txt','w+') # 如果没有该文件则新建文件 # 用新内容把原内容覆盖掉，这里只进行了读取，没有调用write写入，那就代表写入的是空的，空的内容把有数据的内容给覆盖掉了 f = open('test.txt','w+') # 此时test文件里的内容被清空，因为被覆盖了 con = f.read() print(con) f.close() # a+:没有该文件会新建文件：文件指针在结尾，无法读取数据（文件指针后面没有数据） f = open('test100.txt','a+') # 没有test100.txt这个文件 f = open('test.txt','a+') con = f.read() # 文件指针在结尾，无法读取数据（文件指针后面没有数据） print(con) f.close()
telll()：返回文件指针的当前位置
直接上栗子，一看就懂：
# dong.txt文件中的内容是：hello,world file = open("dong.txt", "r") words = file.read(4) print(f'读取的数据是：{words}') # hell # 查找当前位置 position = file.tell() print(f'当前位置是：{position}') # 4 words = file.read(5) print(f'读取的数据是：{words}') # o,wor position = file.tell() print(f'当前位置是：{position}') # 9seek()：从指定位置开始读取或者写入文件的数据
''' 语法：文件对象.seek（偏移量，起始位置） 起始位置：0 文件开头 1 当前位置 2 文件结尾 作用：用来移动文件指针 目标： 1. r模式 ：改变文件指针位置，改变读取数据开始位置或把文件指针放结尾（无法读取数据） 2. o模式 ： 改变文件指针位置，做到可以读取出来数据 ''' # test.txt文件的内容是：aaaaa f = open('test.txt', 'r+') # 1. 改变读取数据开始位置 # f.seek(2,0) # 从第三个a开始读取 f.seek(0,2) # 指针到了文件结尾，读取不出来数据 con = f.read() print(con) # 把文件指针放结尾（无法读取数据） # f.seek(0, 2) # 2. a 改变文件指针位置，做到可以读取出来数据 f.seek(0,0) # 这时指针跑到了开头，这时可以读出数据 # f.seek(0) # 如果是两个0，可以省略写一个0 con = f.read() print(con) f.close()
根据前面的知识，来进行文件备份。中间有一步进行了优化：
# 1. 用户输入目标文件 old_name = input('请输入您要备份的文件名：') print(old_name) # 2. 规划备份文件的名字 # 2.1 提取后缀 -- 找到名字中的点 -- 名字和后缀分离 -- 最右侧的点才是后缀的点 -- 字符串查找某个字串rfind index = old_name.find('.') # 4. 进行优化：有效文件才备份 .txt这个文件名就不是有效的 if index > 0: # 提取后缀 postfix = old_name[index:] # 2.2 组织新名字 = 原名字 + [备份] + 后缀 # 原名字就是字符串的一部分字串 -- 切片[开始：结束：步长] print(old_name[:index]) # 开始从0开始，可以省略不用写 print(old_name[index:]) # 因为提取到最后，所以后面可以省略 # new_name = old_name[:index] + '[备份]' + 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.函数名() # 1. rename(目标文件，新文件名): 重命名 # rename的第一个参数其实是路径，因为这里直接在当前目录下，所以直接写的文件名 # os.rename('1.txt','1000.txt') # 此时文件已经改名 # 2. remove(目标文件名) # os.remove('1000.txt') # 此时1000.txt文件已经删除，如果要删除的文件不存在则会报错 # 3. mkdir(文件夹名字):创建文件夹 也可以带路径的文件夹名字 # os.mkdir('aa') # 创建文件夹成功 # 4.rmdir(文件夹名字): 删除文件夹 # os.rmdir('aa') # 删除成功 # 5. getcwd()：返回当前文件所在目录路径 print(os.getcwd()) # 输出 D:\PycharmProjects\pythonProject11 # 6. chdir(目录)改变目录路径 # os.mkdir('aa') # 创建aa文件夹 # 需求：在aa里面创建bb文件夹：1. 切换目录到aa 2.在aa文件夹中创建bb # os.chdir('aa') # 切换到aa文件夹 # os.mkdir('bb') # 在文件夹中创建bb # 7. listdir(目录): 获取某个文件夹下所有文件，返回一个列表 # print(os.listdir()) # 如果没有填写目录，那么显示当前文件所在的文件夹下所有文件 # print(os.listdir('aa')) # 获取aa文件夹下所有的数据 # 8. rename(目标文件名，新文件名) -- 重命名文件夹 aa重命名为aaaa os.rename('aa','aaaa')
看个栗子，就懂了，用到了循环
# 需求1：把code文件夹所有文件重命名 Python xxxx import os # 1. 找到所有文件：获取code文件夹的目录列表 -- listdir() file_list = os.listdir() print(file_list) # 2. 构造名字 for i in file_list: new_name = 'Python_' + i # 3.重命名 os.rename(i, new_name) # 改名成功文件夹重命名进行优化，用flag来控制文件名的修改
# 需求2：删除Python_ 重命名：1.构造条件的数据 2.书写if import os # 构造条件的数据 flag = 2 # 1. 找到所有文件：获取code文件夹的目录列表 -- listdir() file_list = os.listdir() print(file_list) # 2. 构造名字 for i in file_list: if flag == 1: new_name = 'Python_' + i elif flag == 2: # 删除数据 num = len('Python_') new_name = i[num:] # 3.重命名 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() """
来个栗子，感受一下写法
# 需求：洗衣服 功能：能洗衣服 # 1. 定义洗衣机类 ''' class 类名(): 代码 ''' class Washer(): def wash(self): # 这里的self指的是调用该函数的对象 print("能洗衣服") # 2. 创建对象 # 对象名 = 类名() haier = Washer() # 3. 验证成果 # 打印haier对象 print(haier) # 输出的是地址值 # 使用wash功能 -- 实例方法/对象方法 -- 对象名wash() haier.wash()self的含义
''' wash函数被调用了，haier对象调用的。也就是说haier对象调用了wash，就是将haier这个对象传入到self里面去， 当打印self，打印出来的跟haier对象打印的时候出现的内存地址是一样的。 ''' # 类：洗衣机 功能：洗衣服 class Washer(): def wash(self): print('洗衣服') print(self) haier = Washer() print(haier) haier.wash() # 由于打印对象和打印self得到的内存地址相同，所以self指的是调用该函数的对象 # self指的是调用该函数的对象一个类创建多个对象
# 1. 一个类可以创建多个对象 2. 多个对象都调用函数的时候，self地址是不相同的 class Washer(): def wash(self): print('洗衣服') print(self) haier1 = Washer() haier1.wash() haier2 = Washer() haier2.wash()
类外面添加和获取对象属性
class Washer(): def wash(self): print('洗衣服') haier1 = Washer() # 添加属性 对象名.属性名 = 值 haier1.width = 400 haier1.height = 500 # 获取属性 对象名.属性名 print(f'洗衣机的宽度是{haier1.width}') print(f'洗衣机的高度是{haier1.height}')类里面获取对象属性
class Washer(): def wash(self): print('洗衣服') def print_info(self): # self.属性名 print(f'洗衣机的宽度是{self.width}') print(f'洗衣机的高度是{self.height}') haier1 = Washer() # 添加属性 对象名.属性名 = 值 haier1.width = 400 haier1.height = 500 # 对象调用方法 haier1.print_info()
魔法函数是具有特殊功能的函数
__init__魔法方法
# _init_()方法的作用：初始化对象 class Washer(): def __init__(self): self.width = 500 self.height = 800 def print_info(self): print(f'洗衣机的宽度是{self.width}') print(f'洗衣机的高度是{self.height}') haier = Washer() haier.print_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 '解释说明：类的说明或对象状态的说明' haier = Washer() print(haier) ''' 作用说明：当使用print输出对象的时候，默认打印出现的内存地址。如果类定义了_str_方法， 那么就会打印从这个方法中return的数据 '''__def__魔法方法
''' del haier1,不去手动删除对象也能调用del魔法方法，这几行代码执行完之后，内存中存储的函数、类、变量也会自动释放内存， 即对象也会被删除掉，所以del魔法方法也是被自动调用的。 ''' class Washer(): def __init__(self): self.width = 300 def __del__(self): print('对象已经删除') haier = Washer() # del haier 当删除对象时，python解释器也会默认调用__del__()方法
烤地瓜
# 1. 定义类：初始化属性、被烤和添加调料的方法，显示对象信息的str class SweetPotato(): def __init__(self): # 被烤的时间 self.cook_time = 0 # 烤的状态 self.cook_state = '生的' # 调料列表 self.condiments = [] def cook(self, time): '''烤地瓜方法''' # 1. 先计算地瓜整体烤过的时间 self.cook_time += time # 2. 用整体烤过的时间判断地瓜的状态 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.condiments.append(condiment) def __str__(self): return f'这个地瓜的被烤过的时间是{self.cook_time},状态是{self.cook_state},调料有{self.condiments}' # 2. 创建对象并调用对应的实例方法 digua1 = SweetPotato() print(digua1) digua1.cook(2) digua1.add_condiments('辣椒面儿') print(digua1) digua1.cook(4) digua1.add_condiments('酱油') print(digua1)搬家具
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) # 房子1: 北京, 1000 jia1 = Home('北京', 1000) print(jia1) jia1.add_furniture(bed) print(jia1) ball = Furniture('篮球场', 2000) jia1.add_furniture(ball) print(jia1)在这里插入代码片
面向对象的三大特性：封装、继承和多态 类属性和实例属性 静态方法和类方法
把隐藏属性、方法与方法实现细节的过程成为封装。后面继承那里还会涉及保护类里面的属性，避免外界随意赋值。在14.6 获取和修改私有权限涉及到。
体验继承
# 继承：子类默认继承父类的所有属性和方法 # 1. 定义父类 class A(object): def __init__(self): self.num = 1 def info_print(self): print(self.num) # 2. 定义子类 继承父类 class B(A): pass # 3. 创建对象，验证结论 result = B() result.info_print() ''' 再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()多继承
# 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): pass # 3. 用徒弟类创建对象，调用实例属性和方法 daqiu = Prentice() print(daqiu.kongfu) daqiu.make_cake() ''' 多继承就是一个类同时继承多个父类 结论：如果一个类继承多个符类，优先继承第一个父类的同名属性和方法 '''
子类重写父类同名属性和方法
# 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 = '[独创煎饼果子技术]' def make_cake(self): print(f'运用{self.kongfu}制作煎饼果子') # 3. 用徒弟类创建对象，调用实例属性和方法 daqiu = Prentice() print(daqiu.kongfu) daqiu.make_cake() ''' 结论：如果子类和父类拥有同名属性和方法，子类创建对象调用属性和方法的时候， 调用到的是子类里面的同名属性和方法。这个现象在python语言里当中，简称之为子类重写父类同名方法和属性 '''子类调用父类方法和属性
''' 子类重写父类同名属性和方法，访问的是子类的属性和方法. 如果也想要访问父类的属性和方法该如何去做那？？？ 在子类中调用父类的属性和方法 ''' # 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 = '[独创煎饼果子技术]' def make_cake(self): self.__init__() print(f'运用{self.kongfu}制作煎饼果子') # 调用父类的同名方法和属性，把父类的同名属性和方法再次封装 # 调用父类方法，但是为保证调用到的也是父类的属性，必须在调用方法前调用父类的初始化 def make_master_cake(self): Master.__init__(self) Master.make_cake(self) def make_school_cake(self): School.__init__(self) School.make_cake(self) # 3. 用徒弟类创建对象，调用实例属性和方法 daqiu = Prentice() # 如果事先调用了父类的属性和方法，父类属性会覆盖子类属性，所以在调用子类属性前调用父类的初始化 print(daqiu.kongfu) daqiu.make_cake() daqiu.make_master_cake() daqiu.make_school_cake()
私有权限
''' 设置私有权限的方法：在属性名和方法名前面加上两个下划线__ ''' # 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 # 定义私有方法 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() # 添加了私有方法之后就不访问了获取和修改私有属性
''' 私有属性和私有方法只能在类里面访问和修改。 在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
定义： 多态是一种使用对象的方式，子类重写父类方法，调用不同子类对象的相同父类方法，可以产生不同的执行结果
定义的通俗理解： 传入不同的对象，产生不同的结果
好处 ： 调用灵活，有了多态，更容易编出通用的代码，做出通用的编程，以适应需求的不断变化。 举个栗子，看完栗子再去看定义，会柳暗花明！！！
# 需求: 警务人员和警犬一起工作，警犬分为两种：追击敌人和追查毒品，携带不同的警犬，执行不同的工作 ''' 实现步骤： 定义父类，并提供公共方法 定义子类，并重写父类方法 传递子类对象给调用者，可以看到不同子类执行效果不同 ''' # 1. 定义父类：提供公共方法：警犬 和 人 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设置和访问类属性
''' 类属性就是类对象所拥有的属性，它被该类的所有实例对象所共有。 类属性可以使用类对象或实例对象访问 ''' # 1. 定义类，定义类属性 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() # 1. 类 类.类属性 = 值 # Dog.tooth = 20 # print(Dog.tooth) # print(wangcai.tooth) # print(xiaohei.tooth) # 2. 测试通过对象修改类属性 wangcai.tooth = 200 print(Dog.tooth) print(wangcai.tooth) print(xiaohei.tooth)
