Python 面向对象

1. 面向对象编程(Object Oriented Programming)

面向对象编程是一种编程方式，此编程方式的落地需要使用"类"和"对象"来实现，所以，面向对象编程其实就是对"类"和"对象"的使用。
使用面向对象编程的原因一方面是因为它可以使程序的维护和扩展变得更简单，并且可以大大提高程序开发效率；另外，基于面向对象的程序可以使它人更加容易理解你的代码逻辑，从而使团队开发变得更从容。

1.1 类和对象

类就是一个模板，模板里可以包含多个函数，函数里实现一些功能；---函数在类中被称为方法
对象则是根据模板创建的实例，通过实例对象可以执行类中的函数；

# 定义一个类，class是定义类的语法；User是类名；(object)是新式类的写法
class User(object):
    def __init__(self,name):    # 初始化方法，(self,name)里是要初始化的属性,其中self为特殊参数，必填项；name为实际参数
        self.name = name    # 实例变量，作用域就是实例本身
    def uname(self):    # 类中创建了一个方法uname
        print("%s is the best!" % self.name)
# 对象名 = 类名("参数") ， 创建对象时自动执行 __init__ 方法
i = User('dd')    # 实例化一个对象 i
i.uname()      # 执行uname方法

1.2 self

self，指的是调用该函数的对象。谁调用的函数 self 就是谁。

# 定义类
class Name():
    def wash(self, name):
        print('我会洗衣服')
        print("我是%s的self：" % name, self)


#  创建对象
Jack = Name()
print("我是Jack：", Jack)
Jack.wash("Jack")   # Jack对象执行self就是Jack

kaer = Name()
print("我是kaer：", kaer)
kaer.wash("kaer")

# 执行结果
我是Jack： <__main__.Name object at 0x000002A19C378E90>
我会洗衣服
我是Jack的self： <__main__.Name object at 0x000002A19C378E90>

我是kaer： <__main__.Name object at 0x000002A19C378EC0>
我会洗衣服
我是kaer的self： <__main__.Name object at 0x000002A19C378EC0>

1.3 类变量和实例变量

类变量：是可在类的所有实例之间共享的值（也就是说，它们不是单独分配给每个实例的）。

实例变量：实例化之后，每个实例单独拥有的变量。

class Test(object):
    num_of_instance = 0  # 类变量

    def __init__(self, name):
        self.name = name  # 实例变量
        Test.num_of_instance += 1  


if __name__ == '__main__':
    print(Test.num_of_instance)
    t1 = Test('Jack')
    print(Test.num_of_instance)

    t2 = Test('Kaer')
    print(t1.name, t1.num_of_instance)
    print(t2.name, t2.num_of_instance)

1.4 析构函数

上面我们已经知道构造函数__init__，具有初始化的作用，也就是当该类被实例化的时候就会执行该函数,那么我们就可以把要先初始化的属性放到这个函数里面。
那么与之对应的就是析构函数__del__,用于释放对象占用的资源的函数，做收尾工作，例如关闭数据库、打开临时文件等;
del()也是可选的，如果不提供，则Python 会在后台提供默认析构函数
如果要显式的调用析构函数，可以使用del关键字，方式如下： del 对象名

1.5 私有属性和方法

在python中定义私有变量只需要在变量名或函数名前加上 "__"两个下划线，那么这个函数或变量就成为私有的了。
私有方法和属性外部不能调用，只能在内部调用

class People:
    __nationality = "中国"    # 私有属性
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __cat(self):    # 私有方法
        print(f"""姓名：{self.name}\n年龄：{self.name}\n国籍：{self.__nationality}""")
    def getCat(self):
        return self.__cat() # 内部方法可以执行，私有方法
    def getNationality(self):
        return self.__nationality
    def setNationality(self,name):
        self.__nationality = name
# 实例化对象
p = People("张三",18)
# p.__cat() # 方法会报错，外部不能调用私有方法

# 通过getCat方法，执行私有方法 __cat
p.getCat()
# 获取 __nationality 值
print(p.getNationality())
# 修改 __nationality 值
p.setNationality("地球")
# 获取 __nationality 值
print(p.getNationality())

2. 继承

面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。
子类继承父类可以使用父类的方法和属性

2.1 经典类和新式类

# 经典类 python2
class 类名:
    代码
    ........
# 新式类 python3
class 类名(object):
    代码
    ........

2.2 单继承

单继承：一个子类继承一个父类

# 父类 A
class A(object):
    __nationality = "中国"
    def run(self):
        print(f"国籍：{self.__nationality}")
# 子类B继承A类
class B(A):
    pass
p = B()
p.run() # 先在自己类中找run方法，如果没有执行父类方法

示例:

class SchoolMember(object):
    members = 0  # 初始学校人数为0

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

    def tell(self):
        pass

    def enroll(self):
        '''注册'''
        SchoolMember.members += 1
        print("\033[32;1mnew member [%s] is enrolled,now there are [%s] members.\033[0m " % (
        self.name, SchoolMember.members))

    def __del__(self):
        '''析构方法'''
        print("\033[31;1mmember [%s] is dead!\033[0m" % self.name)


class Teacher(SchoolMember):
    def __init__(self, name, age, course, salary):
        super(Teacher, self).__init__(name, age)
        self.course = course
        self.salary = salary
        self.enroll()

    def teaching(self):
        '''讲课方法'''
        print("Teacher [%s] is teaching [%s] for class [%s]" % (self.name, self.course, 's12'))

    def tell(self):
        '''自我介绍方法'''
        msg = '''Hi, my name is [%s], works for [%s] as a [%s] teacher !''' % (self.name, 'Oldboy', self.course)
        print(msg)


class Student(SchoolMember):
    def __init__(self, name, age, grade, sid):
        super(Student, self).__init__(name, age)
        self.grade = grade
        self.sid = sid
        self.enroll()

    def tell(self):
        '''自我介绍方法'''
        msg = '''Hi, my name is [%s], I'm studying [%s] in [%s]!''' % (self.name, self.grade, 'Oldboy')
        print(msg)


if __name__ == '__main__':
    t1 = Teacher("Jack", 22, 'Python', 20000)
    t2 = Teacher("Kaer", 29, 'Linux', 3000)

    s1 = Student("UZI", 24, "Python S12", 1483)
    s2 = Student("feike", 26, "Python S12", 1484)

    t1.teaching()
    t2.teaching()
    t1.tell()

2.3 多继承

多继承：一个子类继承多个父类
一个类继承多个父类，优先继承第一个父类，如果第一个类没有该方法，继承第二个类。

class A(object):
    def __init__(self):
        self.name = "A"

    def run(self):
        print(f"这是{self.name}类的方法")

class B(object):
    def __init__(self):
        self.name = "B"

    def run(self):
        print(f"这是{self.name}类的方法")

# C 类继承A类，B类，先执行A类中的方法，如果没有执行B类
class C(A, B):
    pass

p = C()
print(p.name)
p.run()

2.4 子类重写父类

子类和父类有相同的方法和属性，优先执行子类自己的方法和属性。

class A(object):
    def __init__(self):
        self.name = "jack"
    def run(self):  # 父类run
        print(f"你的名字{self.name}")
class B(A):
    def __init__(self):
        self.name = "Tom"
    def run(self):  # 子类run
        print(f"你的名字{self.name}")
p = B()
print(p.name)
p.run()

2.5 mro

__mro__，查看类的继承关系

class A(object):
    def __init__(self):
        self.name = "jack"
    def run(self):
        print(f"你的名字{self.name}")
class B(A):
    def __init__(self):
        self.name = "Tom"
    def run(self):
        print(f"你的名字{self.name}")
p = B()
print(p.name)
p.run()
# 查看B类继承那些类，(<class '__main__.B'>, <class '__main__.A'>, <class 'object'>)
print(B.__mro__)

2.6 子类调用父类同名方法

调用父类的同名方法和属性，需要先调用init初始化

class A(object):
    def __init__(self):
        self.name = "jack"
    def run(self):
        print(f"你的名字{self.name}")
class B(A):
    def __init__(self):
        self.name = "Tom"
    def run(self):
        print(f"你的名字{self.name}")
    def a_run(self):
        # init 初始化
        A.__init__(self)
        A.run(self)
p = B()
p.run()
p.a_run()

2.7 super()

super() 函数是用于调用父类(超类)的一个方法。
语法：

# 有参写法
super(自己的类名,self).__init__(参数...)
 
# 无参写法
super().__init__(参数...)

super()和写父类名的区别：

写父类名的缺点：
- 如果需要继承多个父类，不能写多个类名.init(self)。
- 如果父类名字改了，继承父类的子类都需要修改类名.init()。
super()优点：
- 可以继承多个父类，只需要写一次 super().init()。
- 父类名字改了，只需要修改继承父类的名字。

父类名示例：

class A(object):
    def __init__(self):
        self.name = "jack"
    def run(self):
        print(f"A类的名字{self.name}")
class B(object):
    def __init__(self):
        self.name = "Tom"
    def run(self):
        print(f"B类的名字{self.name}")
class C(A,B):
    def __init__(self):
        # 写父类名字
        A.__init__(self)
        # B.__init__(self)
    def run(self):
        A.run(self)
        # B.run(self)
         
p = C()
p.run()

super()示例：

class A(object):
    def __init__(self):
        self.name = "jack"
    def run(self):
        print(f"A类的名字{self.name}")
class B(object):
    def __init__(self):
        self.name = "Tom"
    def run(self):
        print(f"B类的名字{self.name}")
class C(A,B):
    def __init__(self):
        # 有参，写自己的类名
        super(C,self).__init__()
        # 无参
        # super().__init__()
    def run(self):
        super().run()
p = C()
p.run()

2.8 组合继承

先创建 Student 对象(student)，把对象传入Teacher类中，在把类对象(student_obj)赋值给self.school_obj，然后就可以调用Student类中方法和属性。

class SchoolMember(object):
    def __init__(self, addr, tel):
        self.name = addr
        self.age = tel

    def tell(self):
        pass

class Student(object):
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

    def tell(self):
        print("Student :", self.name, self.age, self.sex)

class Teacher(SchoolMember):
    def __init__(self, addr, tel, student_obj):  # student_obj 接收Student类的对象
        super(Teacher, self).__init__(addr, tel)
        self.salary = addr
        self.coures = tel
        # 对象赋值
        self.school_obj = student_obj


school = SchoolMember("北京", 13800000000)
student = Student("Jack", 33, "M")
# 把 student对象传入 Teacher类中，
teacher = Teacher("北京", 13800000000, student)
# 这样没有继承Student类，也可以执行Student类中的方法。
print(teacher.school_obj.name)
teacher.school_obj.tell()

2.9 继承顺序

python3 经典类和新式类都是按照广度优先来继承的。
python2 经典类按照深度优先来继承，新式类按照广度优先来继承。

# D类继承 B类和C类，B类和C类继承 A类
class A(object):
    def __init__(self):
        print("A...")
class B(A):
    pass
    # def __init__(self):
    #     print("B...")
class C(A):
    def __init__(self):
        print("C...")
class D(B,C):
    pass
D()

python3继承顺序：

ABC类都没注释，运行代码，会打印B类中的，如果B类注释了，会打印C类的，如果B和C类都注释了会打印A类的。

python2继承顺序：

经典类：运行代码，会打印B类的，如果B类注释了，会打印A类的。
新式类：和python3一样

3. 封装

封装最好理解了。封装是面向对象的特征之一，是对象和类概念的主要特性。
封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

4. 多态

多态指的是一种接口，多种实现。用于接口的重用。
多态是子类重写父类方法，调用不同子类对象的相同父类方法，可以产生不同的结果。

例子： 输出狗和猫的叫声
普通类的写法： 需要创建对象，执行 talk 方法。

class Animal(object):
    def __init__(self,name):
        self.name = name
    def talk(self):
        pass
class Cat(Animal):
    def talk(self):
        print("Meow!")
class Dog(Animal):
    def talk(self):
        print("Woof! Woof!")
 
c = Cat("Cat")
c.talk()
 
d = Dog("Dog")
d.talk()

多态的写法： 创建对象，调用同一个接口（animall_talk），实现猫和狗的不同叫声。同一种接口，多种实现。

class Animal(object):
    def __init__(self,name):
        self.name = name
    def talk(self):
        pass
    @staticmethod   # 静态方法，把类中方法变成普通的函数
    def animal_talk(obj):
        obj.talk()
class Cat(Animal):
    def talk(self):
        print("Meow!")
class Dog(Animal):
    def talk(self):
        print("Woof! Woof!")
# 创建对象
c = Cat("Cat")
d = Dog("Dog")
# 调用 animall_talk 接口
Animal.animal_talk(c)
Animal.animal_talk(d)

posted @ 2025-11-10 21:32 Amoヽ柠檬阅读(5) 评论(0) 收藏举报

刷新页面返回顶部

Amoヽ柠檬