【详细】Python基础（三）

最新推荐文章于 2023-01-05 11:38:39 发布

置顶熬夜泡枸杞

最新推荐文章于 2023-01-05 11:38:39 发布

阅读量3k

点赞数 29

分类专栏： Python 文章标签： python

本文链接：https://blog.csdn.net/weixin_46818279/article/details/108916127

版权

Python 专栏收录该内容

58 篇文章 71 订阅

订阅专栏

文章目录

前言

准备在这篇中将Python基础部分完结，敬请期待，未完待续…

12. 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），依赖这三种主访问模式，还可以拓展好几种访问模式。
    
'''

12.1 文件的打开、写入、关闭

上栗子，一看就懂：

'''
在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. 注意:可以只打开和关闭文件,不进行任何读写操作
'''

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

主访问模式（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()

12.3 读取函数（read、readlines、readline）

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()

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

除了主访问模式外（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()

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

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}')  # 9

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

'''
语法：文件对象.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()

12.6 文件备份

根据前面的知识，来进行文件备份。中间有一步进行了优化：

# 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()

12.7 文件和文件夹的操作

使用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')

12.8 批量重命名

看个栗子，就懂了，用到了循环

# 需求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)   # 改名成功

12.9 小总结

文件操作小总结

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

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


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

13. Python面向对象（上）

13.1 类和对象

来个栗子，感受一下写法

# 需求：洗衣服   功能：能洗衣服
# 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()

13.1.1 添加和获取对象属性

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

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()

13.1.2 魔方方法（init、str、del）

魔法函数是具有特殊功能的函数

__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__()方法

13.1.3 举两个栗子（烤地瓜、搬家具）

烤地瓜

# 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)在这里插入代码片

13.1.4 小总结

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


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


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


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

14. Python面向对象（下）

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

14.1 封装

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

14.2 继承

体验继承

# 继承：子类默认继承父类的所有属性和方法

# 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()

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

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

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

# 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()

14.2.2 多层继承

'''
多层继承就是 爷爷的财产继承给父亲，父亲又把自己的财产传递给它的儿子
'''
# 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)

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

xiaoqiu = Tusun()
xiaoqiu.make_cake()
xiaoqiu.make_school_cake()
xiaoqiu.make_master_cake()

print(Tusun.__mro__)

14.2.3 小拓展（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'>)

14.2.4 super()方法

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


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

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

        # 2.1 super()带参数写法
        # super(School,self).__init__()
        # super(School,self).make_cake()

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



# 2. 定义徒弟类，继承师傅类 和 学校类， 添加和父类同名的属性和方法
class Prentice( School):
    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)

    # 子类调用父类的同名方法和属性：把父类的同名属性和方法再次封装
    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()

14.2.5 获取和修改私有属性

私有权限

'''
设置私有权限的方法：在属性名和方法名前面加上两个下划线__
'''
# 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

14.2.6 继承小总结


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

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

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

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

14.3 多态

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

定义的通俗理解：传入不同的对象，产生不同的结果

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

举个栗子，看完栗子再去看定义，会柳暗花明！！！


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

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

# 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)  # 追查毒品

14.4 类属性和实例属性

14.4.1 类属性

下面就是类属性

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)

14.4.2 实例属性

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

14.5 类方法和静态方法

14.5.1 类方法

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

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

# 1. 定义类：私有类属性，类方法获取这个私有类属性
class Dog(object):
    __tooth = 10

    # 定义类属性
    @classmethod
    def get_tooth(cls):    # cls代表Dog这个类
        return cls.__tooth

# 2. 创建对象(通过)
wangcai = Dog()
result = wangcai.get_tooth()
print(result)

# 也可以直接通过类名调用类方法
result1 = Dog.get_tooth()
print(result1)

14.5.2 静态方法

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

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

# 2. 创建对象
wangcai = Dog()

# 3. 调用静态方法：类 和 对象
wangcai.info_print()
Dog.info_print()

熬夜泡枸杞

关注

29
点赞
踩
114

收藏

觉得还不错? 一键收藏
10
评论
【详细】Python基础（三）

文章目录12. Python文件操作12.1 主访问模式的特点（r、w、a）12.2 文件的读写12.3 读取函数（read、readlines、readline）12.4 文件夹的相关操作12.5 文件批量修改12.6 小总结12. Python文件操作文件模式模式描述r以只读方式打开文件。文件的指针将会放在文件的开头。这时默认模式rb以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这时默认格式r+打开一个文件用于读写。文件指针将会放在文件的开头。
复制链接

扫一扫