Python面向对象编程：类、实例、继承与特性,-优快云博客

面向对象特性(了解即可)

类(Class): 具有相同的属性和方法的对象的集合。对象是类的实例。
方法：类中定义的函数。
类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
局部变量：定义在方法中的变量，只作用于当前实例的类。
实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
继承：即一个派生类（derived class）继承基类（base
class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例
如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
实例化：创建一个类的实例，类的具体对象。
对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

一、类和实例

1.创建类语法

在Python中，定义类是通过class关键字：

以Student类为例

class Student(object):
    pass

class后面紧接着是类名，即Student，类名通常是大写开头的单词，紧接着是(object)，表示该类是从哪个类继承下来的，通常，如果没有合适的继承类，就使用object类，这是所有类最终都会继承的类。

如何实例对象

定义好了Student类，就可以根据Student类创建出Student的实例，创建实例是通过类名+()实现的：

 stu = Student()

2、类的属性和 init方法

由于类可以起到模板的作用，因此，可以在创建实例的时候，把一些我们认为必须绑定的属性强制填写进去。通过一个特殊的__init__方法，在创建实例的时候，就把width，height等属性绑上去：

#__init__()方法，在创建一个对象时默认被调用，不需要手动调用
#__init__(self)中的self参数，不需要开发者传递，python解释器会自动把当前的对象引用传递过去
'''
1、定义类
2、创建对象
3、验证结果
'''
class Washer():
    #__init__()方法：初始化对象
    def __init__(self,width,height):
        # 添加实例属性
        self.width = 300
        self.height = 400
    # 获取实例属性
    def print_info(self):
        #类里面调用实例属性
        print(f'洗衣机的宽度是{self.width}')
        print(f'洗衣机的高度是{self.height}')

haier1 = Washer()
#对象调用实例方法
haier1.pri

3.类函数和普通函数的区别

只有一点不同，类函数第1个参数永远是实例变量self，并且，调用时不用传递该参数。除此之外和普通函数没有什么区别，所以仍然可以用默认参数、可变参数、关键字参数和命名关键字参数。

4.魔法方法str()

__str__是一个特殊的魔法方法（或称为特殊方法），用于定义对象的字符串表示形式。当你打印一个对象或将其转换为字符串时，Python会调用该对象的__str__方法来获取其字符串表示形式。

class Washer():
    #__init__()方法：初始化对象
    def __init__(self):
        # 添加实例属性
        self.width = 300
        self.height = 400
    # 当使用print输出对象的时候，默认打印对象的内存地址。如果定义了__str__方法，那么就会打印从在这个方法中return的数据
    def __str__(self):
        return '解释说明：类的说明或对象的说明'

haier= Washer()
print(haier)

二.访问限制

如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线__，在Python中，实例的变量名如果以__开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问。

class Prentice(object):
    def __init__(self):
        self.kongfu = '[独创煎饼果子配方]'
        #定义私有属性
        self.__money = 200000
    #定义私有方法
    def __print_info(self):
        print('这是私有方法')

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

#创建徒孙类
class Tusun(Prentice):
    pass
muxi = Tusun()
#AttributeError: 'Tusun' object has no attribute '__money'
print(muxi.__money)
#AttributeError: 'Tusun' object has no attribute '__print_info'
muxi.__print_info()

在类里面获取和修改私有属性的值

#注意：私有属性和私有方法只能在类里面访问和修改
#定义函数名get_XX用来获取私有属性，定义set_XX用来修改私有属性值

class Prentice(object):
    def __init__(self):
        self.kongfu = '[独创煎饼果子配方]'
        #定义私有属性
        self.__money = 200000

    #定义私有方法
    def __print_info(self):
        print('这是私有方法')

    #获取私有属性:get_X
    def get_money(self):
        return self.__money

    #修改私有属性：set_XX
    def set_money(self):
        self.__money = 500

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

#创建徒孙类
class Tusun(Prentice):
    pass
muxi = Tusun()

#调用get_money函数获取私有属性money的值
print(muxi.get_money())
#调用set_money函数修改私有属性money的值
muxi.set_money()
#调用get_money函数获取私有属性money的值
print(muxi.get_money())

三.继承和多态

在OOP程序设计中，当我们定义一个class的时候，可以从某个现有的class继承，新的class称为子类（Subclass），而被继承的class称为基类、父类或超类（Base class、Super class）。

继承可以把父类的所有功能都直接拿过来，这样就不必重零做起，子类只需要新增自己特有的方法，也可以把父类不适合的方法覆盖重写。

单继承

#子类默认继承父类的所有属性和方法
#在python中，所有类默认继承object类，object类是顶级类或基类；其他子类叫做派生类

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

多继承

#创建师傅类、属性和方法
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

#创建对象，验证结论
mx = Prentice()
#调用属性
print(mx.kongfu)
#调用方法
mx.make_cake()
#注意：当一个类有多个父类的时候，默认使用第一个父类的同名属性和方法

多态：当子类和父类都存在相同的run()方法时，我们说，子类的run()覆盖了父类的run()，在代码运行的时候，总是会调用子类的run()。这样，我们就获得了继承的另一个好处：多态。

#1、定义父类，提供公共方法： 警犬 和 人
class Dog(object):
    def work(self):
        pass

#2、定义子类，子类重写父类方法：定义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()
muxi = Person()
muxi.work_with_dog(ad)
muxi.work_with_dog(dd)

静态方法

静态方法特点：

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

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

    @staticmethod
    def print_info():
        print('这是一个静态方法')
        
#2、创建对象
wangcai = Dog()
#3、调用静态方法：类 和 对象
wangcai.print_info()
Dog.prin

类方法

类方法是一种特殊类型的方法，它与类本身相关联，而不是与类的实例相关联。类方法使用@classmethod装饰器来定义，并且第一个参数通常被命名为cls，表示类本身。

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

#1、定义类：私有类属性，类方法获取这个私有类属性
class Dog(object):
    __tooth = 10
    #定义类方法
    @classmethod #装饰器
    def get_tooth(cls):
        return cls.__tooth

#2、创建对象，调用类方法
wangcai = Dog()
result = wangcai.get_tooth()
print(result)