python中的面向对象编程

"""
类：可以理解是一个模板，通过它可以创建出无数个具体实例
对象：类并不能直接使用，通过类创建出的实例（又称对象）才能使用。比如汽车图纸(类)和汽车(对象)的关系
属性：类中的所有变量称为属性
方法：类中的所有函数通常称为方法，和函数所有不同的是，类方法至少要包含一个 self参数
类的使用顺序：1.创建（定义）类，也就是制作图纸的过程；
2.创建类的实例对象（根据图纸造出实际的物品），通过实例对象实现特定的功能
"""

# 类的创建需要使用 class 关键字
# 基本语法格式：class 类名：
#               多个（≥0）类属性...
#               多个（≥0）类方法...

class MyClass:
  x = 7

print(MyClass)

# 创建类对象的过程，又称之为类的实例化，所以也可以称之为实例对象，后续类对象都称为实例对象
# 基本语法格式： 类名（参数）

p1 = MyClass()
print(p1.x)

# __init()类构造方法
# 语法格式：
# def __init__(self,...):
#     代码块
# __init__() 方法可以包含多个参数，但必须包含一个名为 self 的参数，且必须作为第一个参数
# 所有类都有一个名为 __init__() 的函数，它始终在启动类时执行。
# 使用 __init__() 函数将值赋给对象属性，或者在创建对象时需要执行的其他操作

class Person:
  def __init__(self, name, age):
    self.name = name
    self.age = age

p1 = Person("Bill", 63)

print(p1.name)
print(p1.age)

# 在定义类的过程中，无论是显式创建类的构造方法，还是向类中添加实例方法，都要求将 self 参数作为方法的第一个参数
# self 参数是对类的当前实例的引用，用于访问属于该类的变量。
# 它不必被命名为 self，您可以随意调用它，但它必须是类中任意函数的首个参数

# 进行实例化时最好第一个参数命名为self

class Person:
    def __init__(self):
        print("正在执行构造方法")
    # 定义一个say()实例方法
    def say(self,name):
        print(name,"正在学Python")

# 类变量和实例变量（类属性和实例属性）
# 类体中、所有函数之外：此范围定义的变量，称为类属性或类变量；
# 类体中，所有函数内部：以“self.变量名”的方式定义的变量，称为实例属性或实例变量；
# 类体中，所有函数内部：以“变量名=变量值”的方式定义的变量，称为局部变量

# 类变量：在类中，但在各个类方法外定义的变量

class Person:
    name = "you"     # 定义类变量
    age = "20"
    def say(self, content):     # 定义say实例方法
        print(content)

# name 和 age 属于类变量
# 类变量的特点：所有类的实例化对象都同时共享类变量，类变量在所有实例化对象中是作为公用资源存在的

# 类方法的调用方式：使用类名直接调用，使用类的实例化对象调用

print(Person.name)  #使用类名直接调用
Person.name = "youcanwill" #修改类变量的值
print(Person.name)

# 类名不仅可以调用类变量，也可以修改值
# 类变量为所有实例化对象共有，通过类名修改类变量的值，会影响所有的实例化对象

# 实例变量：在任意类方法内部，以“self.变量名”的方式定义的变量
# 只作用于调用方法的对象，实例变量只能通过对象名访问，无法通过类名访问

class Person:
    def __init__(self):
        self.name = "you"
        self.age = "20"

    def say(self):  # 定义say实例方法
        self.catalog = 7

# name、age以及catalog都是实例变量
# __init__() 函数在创建类对象时会自动调用，而say()方法需要类对象手动调用
# Test类的类对象都会包含name和age实例变量，只有调用了say()方法的类对象，才包含catalog实例变量

TEST = Person()  # 只有调用say(),才会拥有catalog实例变量
TEST.say()
print(TEST.catalog)

# 类方法中还可以定义局部变量,局部变量以“变量名=值”的方式进行定义

class Price :
    def count(self,money):   # 定义say实例方法
        sale = 0.8*money
        print("优惠后的价格为：",sale)
TEST= Price()
TEST.count(100)

# 优惠后的价格为： 80.0
# 定义局部变量是为了所在类方法功能的实现，局部变量只能用于所在函数中，函数执行完成后，局部变量也会被销毁

# 实例方法：定义在类中的函数：def 方法名 (self):

class Person:
    #类构造方法，也属于实例方法
    def __init__(self):
        self.name = "李四"
        self.age = "20"
    # 下面定义了一个say实例方法
    def say(self):
        print("正在调用 say() 实例方法")

# 实例方法调用：
# 1.实例方法通常会用实例对象.方法名()调用

test1 = Person()#创建一个实例对象
test1.say()

# 2.实例方法也可以使用类名调用，但是此方法需要手动给self参数传值
# 格式：类名.方法名(实例对象)

test1 = Person()
Person.say(test1)

# 类方法：和实例方法相似，它最少也要包含一个参数，只不过类方法中通常将其命名为cls，Python 会自动将类本身绑定给cls参数
# 类方法需要使用＠classmethod修饰符进行修饰

class Person:
    #类构造方法，也属于实例方法
    def __init__(self):
        self.name = "王五"
        self.age = "26"
    #下面定义了一个类方法
    @classmethod
    def info(cls):
        print("正在调用类方法",cls)

# 如果没有 ＠classmethod，则Python解释器会将info()方法认定为实例方法，而不是类方法
# 类方法推荐使用类名直接调用

#使用类名直接调用类方法

Person.info()

# property()函数
# 在不破坏类封装原则的前提下，依旧使用“类对象.属性”的方式操作类中的属性
# 属性名=property(fget=None, fset=None, fdel=None, doc=None)
# fget参数：指定获取该属性值的类方法
# fset参数：指定设置该属性值的方法
# fdel参数：指定删除该属性值的方法，最后的doc是文档字符串，说明此函数的作用
# property() 函数中参数的指定并不是完全随意的，可以仅指定第1个、或前2个、或前3个，也可以全部指定

class Person:
    def __init__(self, n):  # 构造函数
        self.__name = n

    def setname(self, n):  # 设置 name 属性值的函数
        self.__name = n

    def getname(self):  # 访问nema属性值的函数
        return self.__name

    def delname(self):  # 删除name属性值的函数
        self.__name = "xxx"

    name = property(getname, setname, delname, '说明文档')  # 为name 属性配置 property() 函数


# 说明文档，print(test.name.__doc__)
help(Person.name)
TEST = Person("you")

print(TEST.name)  # 调用 getname() 方法

TEST.name = "胡汉三"  # 调用 setname() 方法
print(TEST.name)

del TEST.name  # 调用 delname() 方法
print(TEST.name)

# getname()方法中需要返回name属性，如果使用self.name的话，其本身又被调用getname()，会进入死循环
# name属性必须设置为私有属性，即__name
# name = property(getname, setname)
# name是一个可读写的属性，但不能删除，因为函数中并没有为name配置用于函数该属性的方法
# Person类中设计有delname()函数，这种情况下也不能用来删除name属性

# Python 继承
# 继承允许我们定义继承另一个类的所有方法和属性的类。
# 父类是继承的类，也称为基类。
# 子类是从另一个类继承的类，也称为派生类。
# object 类是 Python 中所有类的父类
# python中类的继承包括 单继承和多继承
# 语法格式：
# class 类名(父类1, 父类2, ...)：
#     类定义部分

class ParentClass1: #定义父类
    pass

class ParentClass2: #定义父类
    pass

class SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClass
    pass

class SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类
    pass

# 父类重写：子类继承父类后，个别类方法并不适用，对这类方法进行修改

class Bird:
    #鸟有翅膀
    def isWing(self):
        print("鸟有翅膀")
    #鸟会飞
    def fly(self):
        print("鸟会飞")
class Ostrich(Bird):
    # 重写Bird类的fly()方法
    def fly(self):
        print("鸵鸟不会飞")
# 创建Ostrich对象
ostrich = Ostrich()
#调用 Ostrich 类中重写的 fly() 类方法
ostrich.fly()

# 调用父类中被重写的方法

# 调用父类中被重写的方法
class Bird:
    #鸟有翅膀
    def isWing(self):
        print("鸟有翅膀")
    #鸟会飞
    def fly(self):
        print("鸟会飞")
class Ostrich(Bird):
    # 重写Bird类的fly()方法
    def fly(self):
        print("鸵鸟不会飞")
# 创建Ostrich对象
ostrich = Ostrich()
#调用 Bird 类中的 fly() 方法
Bird.fly(ostrich)
#使用 类名调用其类方法，Python 不会为该方法的第一个 self 参数自定绑定值，因此采用这种调用方法，需要手动为 self 参数赋值。

# 在子类中调用父类同名的方法
# 两种方式：
# 1. 父类名.方法名(self)
# 2. super().方法名()

# Python 3.x 中，super() 函数有一种更简单的语法格式
# super().__init__(self,...)

class People:
    def __init__(self,name):
        self.name = name
    def say(self):
        print("我是人，名字为：",self.name)
class Animal:
    def __init__(self,food):
        self.food = food
    def display(self):
        print("我是动物,我吃",self.food)
class Person(People, Animal):
    #自定义构造方法
    def __init__(self,name,food):
        #调用 People 类的构造方法
        super().__init__(name)
        #super(Person,self).__init__(name) #执行效果和上一行相同
        #People.__init__(self,name)#使用未绑定方法调用 People 类构造方法
        #调用其它父类的构造方法，需手动给 self 传值
        Animal.__init__(self,food)
per = Person("zhangsan","熟食")
per.say()
per.display()