第六章面向对象基础

最新推荐文章于 2024-07-27 12:20:46 发布

我不学习机器学

最新推荐文章于 2024-07-27 12:20:46 发布

阅读量204

点赞数

文章标签： python 开发语言

本文链接：https://blog.csdn.net/m0_64916227/article/details/127813610

版权

6.1 概述

软件的开发思想包括：面向对象和面向过程

面向过程：需要实现一个功能的时候，看重的是开发的步骤和过程，每一个步骤都需要自己亲力亲为，需要自己编写代码。面向对象，当需要实现一个功能的时候，看重的不是过程和步骤，而是谁能帮我完成这件事。

面向对象的三大特征：封装性、继承性和多态性

6.2 两个重要概念：类和对象

（1）将具有共同特征和行为的一组对象抽象定义、提出类

（2）类有属性、行为两个组成部分，对象是类的具体实例

类：收集设计图

对象：实体机

（3）对象：客观存在，指代某一个具体实物

类：指代多个实物

例如：类：苹果、红苹果、红富士苹果

对象：手里吃了一半的这个苹果

（4）对象是由类创建的

6.3 类的构成

（1）类（class）由3个部分组成。类的名称（类名），类的属性：一组数据（特征），类的方法：允许进行操作的方法（行为）

例如：狗的设计。类名：狗，属性：品种、毛色、性别，方法（行为）：叫、跑、咬人、吃

（2）类的抽象

拥有相同（或相似）属性和行为的对象都可以抽象出一个类

6.4 类的定义：以狗为例

#object表示基类
class Dog(object):#类名每个单词的首字母大写，即大驼峰
    def play(self):#self暂时不管
        print('小狗在玩耍……')
dog = Dog()#创建对象
dog.play()#通过对象调用方法（函数）
>>> 小狗在玩耍……

6.5 类内外添加属性

（1）类外部添加和获取对象属性

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

类外部获取对象属性对象。属性名

类外部修改属性值，和添加一样

class Dog(object):#创建类
    def play(self):#方法
        print('啦啦啦')
    
dog = Dog()#创建对象
dog.play()
#给对象添加属性 对象.属性 = 属性值
dog.name = '汪汪'#添加属性
dog.age = 2
#获取对象属性值 对象.属性名
dog.age
>>> 啦啦啦
2

（2）类内部通过self添加和获取属性

self 作为类中方法的第一个形参，在通过对象调用方法的时候，不需要手动传递实参值，是python解释器自动将调用该方法的对象传递给self,所以self 代表的是对象

class Dog(object):#创建类
    def play(self):#方法
        print(self.name)
        
dog = Dog()#创建对象
dog.name = '汪汪'#添加属性
dog.age = 2
dog.play()
dog1 = Dog()
dog1.name = '汪呜'
dog1.play()
>>> 汪汪
汪呜

6.6 魔法方法

在python的类中，有一类方法，这类方法以两个下划线开头和两个下划线结尾，并且在满足某个特定条件的情况下回自动调用，这类方法，称为魔法方法。

（1）__init__：在创建对象之后，会立即调用，用来给对象添加属性，给对象属性一个初始值。根据代码的需求，每创建一个对象，都需要执行的代码可以写在__init__里面

#__init__
class Dog(object):
    def __init__(self,name):#可传递参数
        print('啦啦啦')
        self.name = name
 #创建对象时传递实参值       
dog = Dog('呜呜呜')
dog.name
>>> 啦啦啦
'呜呜呜'

（2）__str__方法：print(对象)时会自动调用该方法，返回__str__方法的返回值，或者str(对象）使用类型转换时，将自定义对象转换为字符串时，会自动调用。该方法必须返回(return)一个字符串，只有self一个参数。

class Dog(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __str__(self):
        return f'小狗的名字是{self.name},年龄是{self.age}'#必须return
dog = Dog('黄',2)#创建对象
print(dog)
>>> 小狗的名字是黄,年龄是2

（3）__del__方法：

①对象在内存中被销毁删除的时候会自动调用__del__方法，如程序代码运行结束，其中创建的所有变量和对象都会被删除；使用del 变量，将这个对象的引用计数变为0，会自动调用。

引用计数：是python内存管理的一种机制，是指一块内存，有多少个变量在引用。当一个变量引用一块内存时，引用计数加1，当内存的引用计数变为0的时候，这块内存被删除，内存中的数据被销毁。

② 对象被删除销毁的时候，要书写的代码可以写在__del__中，一般很少使用

class Dog(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __str__(self):
        return f'小狗的名字是{self.name},年龄是{self.age}'#必须return

    def __del__(self):
        print('lll')
   
    
dog = Dog('d',2)
print(dog)
>>> lll
小狗的名字是d,年龄是2

6.7 继承

（1）①继承描述的是多个类之间的所属关系。如果一个类A里的方法和属性可以复制使用，就能通过继承的方式传递到类B里面。类A就是基类，也叫作父类，类B就是派生类，也叫作子类

② class 类B（类A）:

pass

③单继承：一个类只有一个父类，把这种继承关系称为单继承。

多继承：一个类有多个父类，为多继承

多层继承：一条继承链上的方法都可以使用

#定义一个动物类
#在动物类书写play方法，输出快乐的玩耍
#创建dog类，继承动物类
#创建Dog类对象，调用animal类方法
class Animal(object):
    def play(self):
        print('快乐玩耍中……')
class Dog(Animal):
    pass
dog = Dog()#创建相应对象
dog.play()#调用父类方法
>>> 快乐玩耍中……

（2）子类重写父类的同名方法

重写：子类定义和父类名字相同的方法。当父类中的方法不能满足子类对象的需求，重写之后，子类调用自己的方法。

class Dog(object):
    def bark(self):
        print('呜呜呜叫')
        
class XTQ(Dog):
    def bark(self):
        print('嗷嗷嗷叫')
        
dog = Dog()
dog.bark()

xtq = XTQ()
xtq.bark()
>>> 呜呜呜叫
嗷嗷嗷叫

（3）子类调用父类的同名方法

① 父类名.方法名(self,其他参数)，通过对象调用实参值不需要传递实参值

② super(类A，self).方法名(参数)，会调用类A父类的方法

③ super().bark() 方法2的简写

class Dog(object):
    def bark(self):
        print('呜呜呜叫')
        
class XTQ(Dog):
    def bark(self):
        print('嗷嗷嗷叫')
    def see_host(self):
        Dog.bark(self)#调用父类方法
        
xtq = XTQ()
xtq.bark()
xtq.see_host()
>>> 嗷嗷嗷叫
呜呜呜叫

（4）继承中的init

如果子类重写了父类的init方法，在子类中需要调用父类的init方法，给对象添加从父类继承的属性。

class Dog(object):
    def __init__(self,name):
        self.age = 0
        self.name = name
    def __str__(object):
        return f'名字为{self.name}年龄为{self.age}'
        
class XTQ(Dog):
    pass
xtq = XTQ('小黑')
print(xtq)

（5）多继承

一个类有多个父类，这种继承关系称为多继承。

class Dog(object):
    def bark(self):
        print('呜呜呜叫')
    def eat(self):
        print('啃骨头')

class God(object):
    def play(self):
        print('云中君……')
        
    def eat(self):
        print('吃仙丹')
        
class XTQ(Dog,God):#多继承
    pass
xtq = XTQ()
xtq.bark()
xtq.play()

xtq.eat()#父类中两个相同方法，默认定义XTQ时第一个父类中的方法
>>> 呜呜呜叫
云中君……
啃骨头

6.8 私有权限

（1）① 类的私有属性和私有方法，都不能通过对象直接访问，但可以在本类内部访问

②类的私有属性和私有方法，都不会被子类继承，子类也无法访问

③ 私有属性和私有方法往往用来处理类的内部事情，不通过对象处理，起到安全作用

（2）访问权限控制。在方法和属性前面加上两个下划线，就变为私有。①不能在类外部通过对象直接访问和使用，只能在类内部访问和使用；②不能被子类继承。

（3）对象.__dict__ 可以查看对象具有的属性信息，类型是字典，字典的属性是属性名，字典的Value 是属性值。python的私有本质是修改属性的名字

#私有属性，只需要在原属性前加上两个下划线
#定义一个公有的方法，通过这个方法使用
class People(object):
    def __init__(self):
        self.__ICBC = 0#定义私有属性
    def save_money(self):
        return self.__ICBC
    def set_money(self,money):
        self.__ICBC = self.__ICBC + money
        
xz = People()
xz.set_money(1000)
xz.save_money()
>>>1000

（4）私有方法。在方法前加两个下划线，成为私有方法，不能在类外访问

class Dog(object):
    def born(self):
        print('生了一只小狗')
        self.__sleep()
    
    def __sleep(self):
        print('休息30天')
        
dog = Dog()
dog.born()
>>> 生了一只小狗
休息30天

6.9 类属性和类方法和静态方法

类对象：通过class定义的，又称为类对象，是python在创建类的时候自动创建的。通过类对象可以定义实例对象，并且可以保存属性信息，即类属性。

（1）类属性

class Dog(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
        
    class_name = '狗类'
    
dog = Dog('得到',2)
Dog.__dict__#查看类属性
Dog.class_name#访问类属性
>>> '狗类'

（2）类方法

class Dog(object):
    class_name = '狗类'
    def __init__(self,name,age):
        self.name = name
        self.age = age
        
    def play(self):
        print(f'{self.name}在玩耍')
        
    @classmethod
    def get_class_name(cls):
        return cls.class_name
    
dog = Dog('大黄',2)
dog.play()
dog.get_class_name()
>>> 大黄在玩耍
'狗类'

（3）静态方法

使用@staticmethod装饰的方法成为静态方法，对参数无要求。

class Dog(object):
    class_name = '狗类'
    def __init__(self,name,age):
        self.name = name
        self.age = age
        
    def play(self):
        print(f'{self.name}在玩耍')
        
    @staticmethod#创建静态方法
    def show_info():
        print('这是一个Dog类')
    
dog = Dog('大黄',2)
dog.play()
dog.show_info()#调用静态方法
>>> 大黄在玩耍
这是一个Dog类

6.9 多态

在需要使用父类对象的地方，也可以使用子类对象，这种情况就叫多态

class Dog(object):
    def __init__(self,name):
        self.name = name
    def play(self):
        print(f'{self.name}在玩耍')
        
class XTQ(Dog):
    def play(self):
        print(f'{self.name}在啦啦啦')
    
def play_with_dog(obj_dog):
    obj_dog.play()
    
dog = Dog('大黄')
play_with_dog(dog)
xtq = XTQ('小黑')
play_with_dog(xtq)
>>> 大黄在玩耍
小黑在啦啦啦