十天学会Python——第6天：面向对象

于 2024-07-16 20:25:10 发布
阅读量642 收藏 5
点赞数 20
分类专栏： 十天学会Python 文章标签： python 人工智能 机器学习 自然语言处理 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/RunningJie/article/details/140475926
版权

1 面向对象

1.1 类和对象（用类创建对象）

类的语法：

class 类名():
    执行的代码

对象的语法：

对象名 = 类名()

class Washer(): 	# 定义类
    def wash(self):
    	print("可以洗衣服")
        print(self)		# 返回结果是跟下面gree的地址一样
        
gree1 = Washer()		# 创建对象1
gree2 = Washer()		# 创建对象2

print(gree1)		# 返回结果是：对象gree的地址
gree1.wash()		# 返回结果是：可以洗衣服，此时wash()叫做实例方法/对象方法

注意：

  • self：表示调用该函数的对象
  • 一个类可以任意创建多个对象

对象属性的获取与添加：

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

类外面获取对象属性：对象名.属性名

gree1.width = 100
print(f'洗衣机的宽度是：{gree1.width}')

类内部获取对象属性：self.属性名

class Washer():
    def wash(self):
    	print("可以洗衣服")
        print(f'gree洗衣机的宽度是{self.widtf}')		# 返回结果是:gree洗衣机的宽度是500
        
gree = Washer()		# 创建对象
gree.width = 500	#添加实例属性

1.2 魔法方法

魔法方法：有特殊功能的函数，语法是：__xx__

1 __init__()，作用是初始化对象

class Washer(): 	# 定义类
    def __init__(self):
    	self.width = 500
    def print_info(self)：	# 类里面调用实例属性
    	print(f'洗衣机宽度是{self.width}')
gree = Washer()
gree.print_info()

注意：

  • __init__()方法，在创建一个对象时默认被调用，不需要手动调用
  • __init__(self)的 self 参数，不需要开发者传递，python解释器会自动把当前的对象引用传递过去

2 带参数的__init__()：一个类创建多个对象，并对不同对象设置不同的初始化属性

class Washer():
    def __init__(self，width,heigth):
    	self.width = width
        self.heigth = height
    def print_info(self):
    	print(f'洗衣机宽度是{self.width}',f'洗衣机宽度是{self.heigth}')

gree1 = Washer(10,20)
gree1.print_info()
gree2 = Washer(100,200)
gree2.print_info()

3 __str__：使用print输出对象的时候，打印在这个方法中return的数据

class Washer(): 	
    def __init__(self，width,heigth):
    	self.width = width
        self.heigth = height
    def __str__(self)：	
    	rentun '这是格力洗衣机'

gree = Washer(10,20)
print(gree)		# 此时返回的是：这是格力洗衣机

4 __del__：删除对象，python解释器会默认调用__del__方法

class Washer(): 	
    def __init__(self，width,heigth):
    	self.width = width
        self.heigth = height
    def __del__(self)：	
    	print(f'{self}对象已经被删除')

gree = Washer(10,20)
del gree		# 删除 gree 对象

案例1：烤地瓜

class SweetPotato():
    def __init__(self):
        self.cook_time = 0			# 被烤的时间
        self.cook_static = "生的"		# 地瓜的状态
        self.condiments = []		# 调料列表
    def cook(self,time):		# 烤地瓜的方法
        """烤地瓜的方法"""
        self.cook_time += time
        if 0 <= self.cook_time < 3
        self.cook_static = '生的'
        elif 3 <= self.cook_time < 5
        self.cook_static = '半生不熟'
        elif 5 <= self.cook_time < 8
        self.cook_static = '熟了'
        else self.cook_time >= 8:
            self.cook_static = '烤糊了'
    def cook(self,time):		# 添加调料的方法
        """添加调料的方法"""
        self.condiments.append(condiment)
        if 0 <= self.cook_time < 3
    def __str__(self):		# 用于输出对象状态
        return f'这个地瓜考了{self.cook_time}分钟,状态是{self.cook_static},\n
        调料有{self.cook_condiments}'
    
# 创建对象，测试实例属性和实例方法
digua = SweetPotato()
print(digua)
digua.cook(2)
digua.add_condiments('酱油')
print(digua)

案例2：搬家具

class Furniture():		# 定义家居类
    def __init__(self，name,area):
        self.time = 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},\n
        剩余面积{self.free_area},家居有{self.furniture}'
    def add_funiture(self,item):	# 容纳家具
        if self.free_area >= item.area:
            self.furniture.append(ite,.name)
            self.free_area -= item.area
        else:
            print('家具太大了，剩余面积不足，无法容纳')

# 创建对象，测试实例属性和实例方法
bed = Funiture('双人床'，6)
jia = Home('北京',1200)
print(jia)
jia.add_furniture(bed)
print(jia)

2 继承

2.1 认识继承

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

  • 所有类默认继承object类，object类是顶级类或者基类，其他子类叫做派生类
  • 继承分为单继承和多继承
# 单继承
class A(object): 	# 这个是父类
    def __init__(self):
    	self.num = 1
    def info_print(self)：	
    	print(self.num)
class B(A):		# 这个是子类
    pass

result = B()
result.info_print()		# 返回结果是：1

注意：

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

2 若子类和父类具有同名属性和方法，调用的是子类的属性和方法

3 类名.__mro__：查看类的层级关系

# 多继承
class Master(object):	# 这个是父类1
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'
    def make_cake(self):
        print(f'运用{self.kongfu}做了煎饼果子')
# 创建学校类
class School(object):	# 这个是父类2
    def __init__(self):
        self.kongfu = '小明煎饼果子配方'
    def make_cake(self):
        print('f'运用了{self.kongfu}制作了煎饼果子')
class Prentice(School,Mater):	# 这个是子类
    pass
daqiu = Prentice()
print(daqiu.kongfu())
daqiu.make_cake()	# 返回结果是：运用[小明煎饼果子配方]做了煎饼果子
              
print(prentice.__mro__)

2.2 继承中子类的调用

  • 子类调用属性和方法时，可以自定义调用子类或者父类的属性和方法
  • 多层继承子类的子类也可以继承子类和父类
# 多继承
class Master(object):	# 这个是父类1
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'
    def make_cake(self):
        print(f'运用{self.kongfu}做了煎饼果子')
# 创建学校类
class School(object):	# 这个是父类2
    def __init__(self):
        self.kongfu = '小明煎饼果子配方'
    def make_cake(self):
        print('f'运用了{self.kongfu}制作了煎饼果子')
class Prentice(School,Mater):	# 这个是子类
    def __init__:
        self.kongfu = '[独创煎饼果子配方]'
    # 调用子类方法
    def make_cake(self):
        self.__init___()	# 为了保证调用的子类方法属性，需要将子类进行初始化
        print(f.'运用{self.kongfu}做了煎饼果子')
    # 调用父类方法
    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)
class Tusun(Prentice):		# 这是多层继承的使用
    pass
              
daqiu = Prentice()
daqiu.make_cake()	# 返回结果是：运用[独创煎饼果子配方]做了煎饼果子
daqiu.make_master_cake()	# 返回结果是：运用[古法煎饼果子配方]做了煎饼果子

xiaoqiu = Tusun()
xiaoqiu.make_school_cake()
  • 利用super()方法调用父类方法和属性
# 需求：一次性调用两个父类
class Master(object):
class School(Maater):
    # 如果要调用Mater里面的方法与属性，需要在此处加上super()方法
    # 后面测试案例返回结果为：运用[小明煎饼果子配方]做了煎饼果子 运用[古法煎饼果子配方]做了煎饼果子
    # super() 带参数写法：
    super(School,self).__init__()
    super(School,self).make_cake()
    # super() 无参数写法
    super().__init__
    super().make.cake()
class Prentice(School):	
    ......
    def make_old_cake(self):
        # 方法1(带参数)：super(当前类名，self).函数()
        super(Prentice,self).__init__()
        super(Prentice,self).makecake()		返回结果是：运用[小明煎饼果子配方]做了煎饼果子
        # 方法2（无参数）：super(当前类名，self).函数()
        super.__init__()
        super.makecake()		返回结果是：运用[小明煎饼果子配方]做了煎饼果子

2.3 私有权限

私有权限：设置某个实例属性或者实例方法，不继承给子类，在属性名和方法名前面加上两个下划线__

  • 私有属性和私有方法只能在类里面进行访问和修改
  • 一般定义函数名 get_xx 来获取私有属性，定义set_xx 来修改私有属性值
class Prentice(School,Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果子配方]'
        #定义私有属性
        self.__money = 200
    def fet_money(self):	# 获取私有属性
        return self.__money
    def set_money(self):	# 修改私有属性
        self.__money = 300
    # 定义私有方法
    def __info_print(self):
        print(self.kongfu)
class Tusun(Prentice):
    pass
xiaoqiu = Tusun()
print(xiaoqiu.money)	# 此时程序报错，调用不了父类属性

2.4 多态

多态：调用不同子类对象的相同对象方法，可以产生不同的执行结果

class Dog(object):
    def work(self):		# 父类提供统一的方法
        print('指哪打哪...')
class ArmyDog(Dog):		# 继承Dog类
    def work(self):		# 子类重写父类的方法
        print('追击敌人...')
class DrugyDog(Dog):	# 继承Dog类
    def work(self):		# 子类重写父类的方法
        print('追查毒品...')
class Person(object):
    def work_with_dog(self,dog):	# 传入不用的对象，执行不同的work函数
        dog.work()

ad = ArmyDog()
dd = DrugDog()

daqiu = Person()
daqiu.work_with_dog(ad)		# 返回的结果是：追击敌人...
daqiu.work_with_dog(dd)		# 返回的结果是：直接毒品...

2.5 类属性和类方法

类属性：类对象所拥有的属性，他被该类的所有实例对象所共有

  • 类属性只能通过类对象进行修改，不能通过实例对象修改
class Dog(object):
    tooth = 10
wangcai = Dog()
xiaohei = Dog()

print(Dog.tooth)		# 返回的结果是：10
print(wangcai.tooth)	# 返回的结果是：10

Dog.tooth = 20
print(Dog.tooth)		# 返回的结果是：20

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

  • 当方法中需要使用类对象（如访问私有属性等）时，定义类方法
  • 类方法一般和类属性配合使用
class Dog(object):
    __tooth = 10
    @classmethod
    def get_tooth(cls):
        return cls.__tooth
wangcai = Dog()
print(wangcai.get_tooth())		# 返回结果是：10

2.6 静态方法

静态方法：需要通过装饰器@staticmethod来进行修饰，静态方法不需要传递类对象和实例对象

  • 静态方法可以通过实例对象和类对象进行访问
  • 当不需要进行参数传递的时候，就使用静态方法
class Dog(object):
    @staticmethod
    def info_print():
        print('这是一个狗类')
wangcai = Dog()
# 静态方法，既可以使用对象访问，又可以使用类访问
Dog.info_print()
wangcai.info_print()

3 学生管理系统（面向对象）

学员类的创建（sudent.py文件）

  • 学员信息包括：姓名、性别、手机号
  • 添加__str__魔法s方法，方便查看学员对象信息
class Student(object):
    def __init__(self,name,gender,tel):
        # 姓名、性别、手机号
        self.name = name
        self.gengder = gender
        self.tel = tel
    def __str__(self):
        return f'{self,name},{self.gender},{self.tel}'

管理系统的创建（managerSystem.py文件）

  • 管理系统循环使用，用户输入不同的功能序号执行不同功能

  • 存储数据的形式：列表存储学员对象

  • 系统功能：添加学员、删除学员、修改学员、查询学员信息、显示所有学员信息、保存学员信息

  • 步骤：定义程序入口函数（加载数据、显示功能菜单、用户输入功能序号、系统执行功能）——系统定义功能函数

from stdent import *

class StudentManager(object):
    def __init__(self):
        # 存储数据所用的列表
        self.student_list = []
    # 一、程序入口函数，启动程序后执行的函数
    def run(self):
        # 1 加载学员信息
        self.load_student()
        
        while True:
            # 2 显示功能菜单
            self.show_meu()
            # 3 用户输入功能序号
            menu_num = int(input('请输入您需要的功能序号：'))
            # 4 根据用户输入的功能序号执行不同的功能
            if menu_num == 1:		# 添加学员信息
                self.add_student()
            elif menu_num == 2:		# 删除学员信息
                self.del_student()
            elif menu_num == 3:		# 修改学员信息
                self.modefy_student()
            elif menu_num == 4:		# 查询学员信息
                self.search_student()
            elif menu_num == 5:		# 展示学员信息
                self.show_student()
            elif menu_num == 6:		# 保存学员信息
                self.saveh_student()
            elif menu_num == 7:		# 退出系统
                break
	# 二、系统功能函数
	# 1 展示功能菜单
	def show_menu():
        print('请选择如下功能：')
        print('1 添加学员信息')
        print('2 删除学员信息')
        print('3 修改学员信息')
        print('4 查询学员信息')
        print('5 显示所有学院信息')
        print('6 保存学员信息')
        print('7 退出系统')
    # 2 添加学员信息：用户输入信息---创建学员对象---将对象添加到学员列表
    def add_student(self):
        name = input('请输入您的姓名：')
        gender = input('请输入您的性别：')
        tel = input('请输入您的手机号：')
        student = Student(name,gender,tel)
        self.student_list.append(student)
        print(self.student_list)
    # 3 删除学员，删除指定姓名的学员
    def del_student(self):
        del_name = input('请输入要删除的学员姓名：')
        for i in self.student_list:
            if i,name == del_name:
                self.student_list.remove(i)
                break
            else:
                print('查无此人！')
            print(self.student_list)
    # 4 修改学员信息，用户输入学员姓名，修改学员信息
    def modefy_student(self):
        modefy_name = input('请输入您要修改的学员姓名：')
        for i in self.student_list:
            if i.name == modify_name:
                i.name == input('请输入学员姓名：')
                i.gengder == input('请输入学员性别：')
                i.tel == input('请输入学员手机号：')
                print(f'修改学员信息成功，姓名：{i.name}，性别：{i.gender}，手机号：{i.tel}')
                break
            else:
                print('查无此人！')
    # 5 查询学员信息
    def search_student(self):
        search_name = input('请输入您要查询的学员姓名：')
        for i in self.student_list:
            if i.name == search_name:
                print(f'查询学员信息成功，姓名：{i.name}，性别：{i.gender}，手机号：{i.tel}')
                break
            else:
                print('查无此人！')
    # 6 显示所有学员信息
    def show_student(slef):
        print('姓名\t性别\t手机号')
        for i in self.student_list:
            print(f'姓名：{i.name}，性别：{i.gender}，手机号：{i.tel}')
    # 7 保存学员信息
    def save_student(self):
        # 1 打开文件
        f = open('student.data','w')	# 打开文件
        # 文件写入数据不能是内存地址，需要把学员数据转换成列表字典数据再做存储
        new_list = [i.__dict__ for i in self.student_list]
        # 文件内数据要求为字符串类型，需将数据类型转换成字符串
        f.write(str(new_list))
        f.cloese
    # 8 加载学员信息
    def load_student(self):
        try:
            f = open('student.data','r')
        except:
            f = open('student.data','w')
        else:
            data = f.read()
            new_list = eval(data)
            # 文件中读取数据为字典类型，需转换字典为对象后再存储到学员列表
            self.student_list = [Student(i['name'],i['gender']),i['tel'] for i in new_list]
        finally:
            f.close（）

主函数的创建(main.py文件)

# 1 导入managerSystem模块
from managerSysyem import *
# 2 启动学员管理系统
if __name__ == '__main__':
    student_maneger = StudentManager()
    student_manager.run()

拓展：

__dict__：返回类或实例属性中对应的字典

eval：用于执行字符串形式的 Python 表达式，并返回表达式的结果

夏风肆意
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值