[Python知识库]Python面向对象

Python面向对象

1. 面向对象基本语法

# 小明今年18岁，身高 1.75，每天早上跑完步，回去 吃 东西
# 小美今年17岁，身高 1.65，小美不跑步，小美喜欢 吃 东西

# 定义类：类名的定义，使用class 来定义一个类
# class 类名: 类名一般需要遵守大驼峰命名法，每一个单词的首字母都大写
# 1. class <类名>:
# 2. class <类名>(object):


class Student(object):  # 关注这个类有哪些特征和行为
    # 在 __init__ 方法里，以参数的形式定义属性，称之为属性
    def __init__(self, name, age, height):
        self.name = name
        self.age = age
        self.height = height

    def run(self):
        print(f'{self.name}正在跑步')

    def eat(self):
        print(f'{self.name}正在吃东西')


# 使用 Student 类创建了两个实例对象 s1 s2
# s1 和 s2 都会有name,age,height属性，同时都有run和eat 方法
s1 = Student('小明', 18, 1.75)
s2 = Student('小美', 19, 1.65)

# 根据业务逻辑，让不同的对象执行不同的行为
s1.run()
s1.eat()

s2.eat()

2. self语句的使用

class Student(object):
    # 这个属性直接定义在类里，是一个元组，用来规定对象可以存在的属性
    __slots__ = ('name', 'age')
    def __init__(self, x, y):
        self.name = x
        self.age = y

    def sayHello(self):
        print('大家好，我是', self.name)

# Student('张三', 18) 这段代码具体做了什么呢？
# 1. 调用 __new__方法，用来申请内存空间
# 2. 调用__init__ 方法传入参数，并让self 指向申请好的那段内存空间，填充数据
# 3. 让变量 s1 也指向创建好的这段内存空间
s1 = Student('张三', 18)
# print('0x%X:'% id(s1))  # 查看地址
print('s1 的名字是', s1.name)
# 谁调用self，self就是谁
s1.sayHello()
# 如果没有这个属性会报错
# print(s1.height)

# 直接使用等号给一个属性赋值
# 如果这个属性以前不存在，会给对象添加一个新的属性
# 动态属性
s1.city = '上海'  # 给对象添加了一个city属性

# 如果这个属性以前存在，会修改这个属性对应的值
s1.name = '刘明'
print(s1.name)  # '刘明'

3. __init__魔法方法

# 魔法方法，也叫魔术方法，是类里的特殊的一些方法
# 特点：
# 1、不需要手动调用，会在合适的时机自动调用
# 2、这些方法，都是使用 __ 开始，使用 __结束
# 3、方法名都是系统规定好的，在合适的时机自己调用
# import time
import datetime

n = datetime.datetime(2021, 4, 13, 8, 40, 54, 900)
print(n)  # 调用 __str__ 方法
print(repr(n))  # 调用 __repr__ 方法


class Person(object):
    def __init__(self, name, age):
        # 在创建对象时，会自动调用这个方法
        print('__init__方法被调用了')
        self.name = name
        self.age = age

    def __del__(self):
        # 当对象被销毁时，会自动调用这个方法
        print('__del__方法被调用了')

    def __repr__(self):
        return 'hello'

    def __str__(self):
        # return self.name, self.age  # 报错，TypeError: __str__ returned non-string (type tuple)
        return '{} {}'.format(self.name, self.age)

    def __call__(self, *args, **kwargs):
        # print('__call__方法被调用了')
        # args 是一个元组，保存(1, 2)
        # kwargs 是一个字典， 保存{'fn':lambda: x, y: x + y}
        print("args = {}, kwargs = {}".format(args, kwargs))
        fn = kwargs['fn']
        return fn(args[0], args[1])


p = Person('zhangsan', 18)
# 如果不做任何的修改，直接打印一个对象，是文件的__name__.类型 内存地址
# 当打印一个对象的时候，会调用这个对象的__str__ 或者 __repr__ 方法
# 如果这两个方法都写了，选择 __str__
print(p)
# print(repr(p))  # 调用内置函数 repr 会触发对象的 __repr__ 方法
# print(p.__repr__())  # 魔法方法，一般不手动的掉一共
# del p
# time.sleep(5)

# p()  # 对象名() ==> 调用这个对象的 p.__call__() 方法
m = p(1, 2, fn=lambda x, y: x + y)  # 调用这个对象的 p.__call__(1, 2) 方法
# print(m)

4. __eq__方法的使用功能

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

    def __eq__(self, other):
        # print('__eq__ 方法被调用了')
        # if self.name == other.name and self.age == other.age:
        #     return True
        # return False
        return self.name == other.name and self.age == other.age


p1 = Person('zhangsan', 18)
p2 = Person('zhangsan', 18)

# p1 和 p2 是同一个对象吗？
# 怎样比较两个对象是否是同一个对象？比较的是内存地址
print('0x%X' % id(p1))  # 0x2074BBE4B80
print('0x%X' % id(p2))  # 0x2074BC5A100

# is 身份运算符 可以用来判断两个对象是否是同一个对象
# print(p1 is p2)  # False
# __eq__ 如果不重写，默认比较依然是内存地址
print(p1 == p2)  # False  p1 == p2 本质是调用p1.__eq__(p2)，获取返回结果

# is 比较两个对象的内存地址
# == 会调用对象的 __eq__ 方法，获取这个方法的比较结果
nums1 = [1, 2, 3]
nums2 = [1, 2, 3]
# print(nums1 is nums2) # False
# print(nums1 == nums2) # True

5. 面向对象练习

"""
房子（House）有户型、总面积、剩余面积 和 家具名称列表 属性
新房子没有任何的家具
将 家具的名称 追加到 家具名称列表 中
判断 家具的面积 是否 超过剩余面积，如果超过，提示不能添加这件家具

家具（Furniture） 有 名字 和 占地面积 属性，其中
席梦思（bed） 占地 4 平米
衣柜（chest） 占地 2 平米
餐桌（table） 占地 1.5 平米
将以上三件 家具 添加 到 房子 中
打印房子时，要求输出：户型、总面积、剩余面积、家具名称列表
"""


class House(object):
    def __init__(self, house_type, total_area, fur_list=None):
        if fur_list is None:  # 如果值是None
            fur_list = []  # 将fur_list设置为空列表
        self.house_type = house_type
        self.total_area = total_area
        self.fur_list = fur_list
        self.free_area = total_area * 0.6

    def add_fur(self, fur):
        if fur.area < self.free_area:
            self.fur_list.append(fur.name)
            self.free_area -= fur.area
        else:
            print(f'房子剩余空间不够了，不能添加 "{fur.name}" 这个家具了')

    def __str__(self):
        return '户型：{}，总面积：{} 平米，剩余面积：{:.2f} 平米，家具名称列表：{}'.format(self.house_type, self.total_area,
                                                                 self.free_area, self.fur_list)


class Furniture(object):
    def __init__(self, name, area):
        self.name = name
        self.area = area


if __name__ == '__main__':
    # 创建房间对象的时候，传入户型和总面积
    house = House('三室一厅', 116)
    bed = Furniture('席梦思', 4)
    chest = Furniture('衣柜', 2)
    table = Furniture('餐桌', 1.5)
    plane = Furniture('飞机', 100)

    # 把家具添加到房间里（面向对象关注点：让谁做）
    house.add_fur(bed)
    house.add_fur(chest)
    house.add_fur(table)
    house.add_fur(plane)
    print(house)  # print打印一个对象的时候，会调用这个对象的__repr__或者__str__方法，获取它们的返回值
    # print(house.__str__())  # 相当于print(house)

6. 魔法方法介绍

class Person(object):
    def __init__(self, name, age):  # self 谁调用就指向谁，不调用不指向
        self.name = name
        self.age = age

    def eat(self):
        print(self.name + '正在吃东西')

    def __eq__(self, other):
        return self.name == other.name and self.age == other.age

    # def __ne__(self, other):  # 使用 != 运算符会自动调用这个方法
    #     pass

    # def __gt__(self, other):  # 使用 > 运算符会自动调用这个方法
    #     return self.age > other.age

    # def __ge__(self, other):  # 使用 >= 运算符会自动调用这个方法
    #     return self.age >= other.age

    # def __lt__(self, other):  # 使用 < 运算符会自动调用这个方法
    # def __le__(self, other):  # 使用 <= 运算符会自动调用这个方法
    # def __add__(self, other):  # 使用 + 运算符会自动调用这个方法
    # def __sub__(self, other):  # 使用 - 运算符会自动调用这个方法
    # def __mul__(self, other):  # *
    # def __truediv__(self, other):  # /
    # def __mod__(self, other):  #  取余
    # def __pow__(self, power, modulo=None):  # **

    # def __str__(self):
    #     return 'hello'
    # def __int__(self):
    #     return 5
    # def __float__(self):
    #     return 100.5


p1 = Person('小明', 18)
p2 = Person('小李', 20)

# print(p1 is p2)  # False
# == 运算符本质其实是调用对象的 __eq__ 方法，获取 __eq__方法的返回结果
# a == b => a.__eq__(b)
# print(p1 == p2)  # False  p1.__eq__(p2) 比较内存地址

# != 本质是调用 __ne__方法 (not equal) 或者 __eq__ 方法取反
# print(p1 != p2)  # 未重写 __ne__ 方法False
# print(p1 > p2)  # 未重写__gt__ 方法时会报错（没有这个方法）
# print(p1 >= p2)  # 未重写__ge__方法时会报错

# nums1 = [1, 2, 3]
# nums2 = [1, 2, 3]
# print(nums1 == nums2)  # 系统自动重写了__eq__方法，比较的是值

# str() 将对象转换成为字符串，会自动调用 __str__ 方法
# 1. str() 2. 打印对象也会调用
print(str(p1))  # 转换成为字符串，默认会转换成为类型 + 内存地址
# print(int(p1))  # 调用对象的__int__方法

7. 内置属性

class Person(object):
    """
    这是一个人类
    """
    __slots__ = ('name', 'age')  # 限制对象能够拥有的属性
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def eat(self):
        print(self.name + '正在吃东西')


# 'name':'zhangsan', 'age':18, 'eat':<function>
p1 = Person('zhangsan', 18)
# print(dir(p1))
# print(p1.__class__)  # <class '__main__.Person'>
# print(p1.__dict__)  # {'name': 'zhangsan', 'age': 18}，把对象的属性和值转换成为一个字典
# print(p1.__dir__())  # 相当于dir(p1)
print(p1.__doc__)  # 对象名.__doc__ , 类的说明
print(Person.__doc__)  # 类名.__doc__
print(p1.__module__)  # __main__

# print(range.__doc__)  # range的说明

8. 把对象当做一个字典使用

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

    def __setitem__(self, key, value):
        self.__dict__[key] = value

    def __getitem__(self, item):
        return self.__dict__[item]


p1 = Person('张三', 18)
# print(p1.__dict__)  # 将对象转换成为字典 {'name': '张三', 'age': 18}
# [] 语法会调用对象的__setitem__ 方法
p1['name'] = 'lisi'  # 未写__setitem__会报错，不能直接把一个对象当做字典来使用
print(p1.name)  # lisi
print(p1['name'])  # 调用 __getitem__ 方法

9. 对象属性和类属性

class Person(object):
    type = '人类'  # 这个属性定义在类里，函数之外，我们称之为类属性
    def __init__(self, name, age):
        self.name = name
        self.age = age


# 对象 p1 和 p2 是通过 Person 类创建出来的实例对象
# 只要创建了一个实例对象，这个实例对象就有自己的name 和 age 属性
# name 和 age 是对象属性， 在 __init__ 方法里，以参数的形式定义的
# 对象属性：每个实例对象都单独保存的属性
# 每个实例对象之间的属性没有关联、互不影响
p1 = Person('张三', 18)
p2 = Person('李四', 20)
# print(p1.name, p1.age)  # 获取对象的属性

# 类属性可以通过类对象和实例对象获取
# print(Person.type)  # 可以通过类对象获取类属性
# 可以通过实例对象来获取类属性
# print(p1.type)
# print(p2.type)

# 类属性只能通过类对象来修改，实例对象无法修改类属性
p1.type = 'human'  # 并不会修改类属性，而是给实例对象新增了type属性
# print(p1.type)  # human
# print(Person.type)  # 人类

Person.type = '哺乳类'  # 修改了类属性
print(Person.type)  # 哺乳类
print(p2.type)  # 哺乳类
print(p1.type)  # human ,自己有这个属性，取自己的，没有才会去找类属性

# print('p1内存地址: 0x%X, p2内存地址: 0x%X' % (id(p1), id(p2)))  # p1内存地址: 0x1DB33A14B80, p2内存地址: 0x1DB33A8A100
# print('Person类的内存地址： 0x%X' % id(Person))  # Person类的内存地址： 0x1DB31BB6590

10. 私有属性的使用

import datetime


class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.__money = 1000  # 以两个下划线开始的变量是私有变量

    def test(self):
        self.__money += 10  # 在这里可以访问私有属性

    def get_money(self):
        print('查询余额时间 {}'.format(datetime.datetime.now()))
        return self.__money

    def set_money(self, new_money):
        if type(new_money) == int:
            print('修改余额了')
            self.__money = new_money
        else:
            print('修改余额失败')

    def __demo(self):  # 以两个下划线开始的函数，是私有函数，在外部无法调用
        print('我是demo函数')

    def test_demo(self):
        self.__demo()


p1 = Person('张三', 18)
print(p1.name, p1.age)  # 可以直接获取到
# print(p1.__money)  # 不能够直接获取到私有变量
# p1.__demo()  # 不能直接调用demo函数，它是私有方法
p1._Person__demo()  # 强行调用

# p1.test()
# 获取私有变量的方式：
# 1. 使用 对象._类名__私有变量名获取
# print(p1._Person__money)  # 通过这种方式也能获取到私有属性

# 2. 定义get 和 set 方法来获取
print(p1.get_money())
p1.set_money(2000)
print(p1.get_money())

# 3. 使用property来获取()

11. 类方法和静态方法

class Person(object):
    type = '人类'

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

    def eat(self, food):  # 默认的方法都是对象方法，对象方法有一个参数self，指的是实例对象
        print(self.name + '正在吃' + food)

    # 如果一个方法里面没有用到实例对象的任何属性，也不用类对象，可以将这个方法定义成static 静态方法
    @staticmethod
    def demo():
        print('我是demo方法，我被调用了')

    # 如果这个函数只用到了类属性，可以定义成为一个类方法
    @classmethod
    def test(cls):  # 类方法会有一个参数 cls，也不需要手动的传参，会自动传参，cls指的是类对象: cls is Person
        print('test函数使用了类属性: {}'.format(cls.type))


class Calculator(object):
    @staticmethod
    def add(a, b):
        return a + b

    @staticmethod
    def minus(a, b):
        return a - b


# c = Calculator()
# print(c.add(1, 2))
print(Calculator.add(1, 2))


p1 = Person('张三', 18)
p2 = Person('李斯', 20)
# 实例对象在调用对象方法时，不需要给形参self传参，会自动的把实例对象传递给self
# eat 对象方法，可以直接使用实例对象，方法名(参数)调用
# 使用 对象名.方法名(参数) 调用的方式，不需要传递self，会自动将对象名传递给self
p1.eat('樱桃')  # 直接使用实例对象调用方法
p1.demo()

# 对象方法还可以使用 类对象来调用 类名.方法名()
# 这种方式，不会自动传self传参，需要手动的指定self 实例对象
# Person.eat('西红柿鸡蛋面')  # 报错，缺少self参数
Person.eat(p2, '西红柿鸡蛋面')
Person.demo()

# 类方法可以使用实例对象和类对象调用
p1.test()
Person.test()

# print(p1.eat)  # <bound method Person.eat of <__main__.Person object at 0x000001CAD4804B80>>
# print(p2.eat)  # <bound method Person.eat of <__main__.Person object at 0x000001CAD487A100>>
# print(p1.eat is p2.eat)  # False, p1 和 p2 分别绑定函数
# print(Person.eat) # <function Person.eat at 0x0000022C4B5433A0>

12. 单例设计模式

class Singleton(object):
    __instance = None
    __isfirst = True

    def __new__(cls, *args, **kwargs):
        if cls.__instance is None:
            # 申请内存，创建一个对象，并把对象的类型设置为cls
            cls.__instance = object.__new__(cls)
        return cls.__instance

    def __init__(self, a, b):
        if self.__isfirst:
            self.a = a
            self.b = b
            self.__isfirst = False  # 在对象里加了一个__isfirst 对象属性


# 调用 __new__ 方法申请内存
# 如果不重写 __new__方法，会调用 object 的 __new__ 方法
# object的 __new__ 方法会申请内存
# 如果重写了 __new__ 方法，需要自己手动的申请内存
s1 = Singleton('abc', '好的')
s2 = Singleton('hello', '世界')
# print(type(s1))  # <class '__main__.Singleton'>
# print(hex(id(s1)), hex(id(s2)))
print(s1.a, s1.b)  # hello 世界 , s2 把 s1 覆盖了
print(s1 is s2)

• 练习

# 定义一个类属性，记录通过这个类创建了多少个对象
class Person(object):
    __count = 0

    # def __new__(cls, *args, **kwargs):
    #     instance = object.__new__(cls)
    #     cls.__count += 1
    #     return instance

    def __init__(self, name, age):
        Person.__count += 1
        self.name = name
        self.age = age

    @classmethod
    def get_count(cls):
        return cls.__count


# 每次创建对象，都会调用 __new__ 和 __init__ 方法
# 调用 __new__ 方法，用来申请内存
# 如果不重写 __new__ 方法，它会自动找 object 的 __new__
# object 的 __new__ 方法， 默认实现是申请了一段内存，创建一个对象
p1 = Person('张三', 18)
p2 = Person('李斯', 20)
p3 = Person('王武', 21)
p4 = object.__new__(Person)
p4.__init__('刘明', 22)

print(p1, p2, p3, p4)
print(Person.get_count())

13. 面向对象三大特性

# 面向对象编程有三大特性： 封装、继承和多态
# 封装：函数时对语句的封装；类是对函数和变量的封装
# 继承：类和类之间可以人为手动的简历父子关系，父类的属性和方法，子类可以使用
# 多态：是一种技巧，提高代码的灵活度


# 一个个的语句
def test():
    a = 23  # 赋值语句
    a += 3  # 算术运算符表达式语句
    print('hello')
    print('good')


class Persion(object):
    type = '人类'

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

    def eat(self):
        print('吃东西')

14. 继承的使用

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

    def sleep(self):
        print(self.name + '正在睡觉')


class Dog(Animal):  # 继承父类(基类), Dog是Animal子类（派生类),子类可以使用父类的方法
    def bark(self):
        print(self.name + '正在汪汪叫……')


class Student(Animal):
    def study(self):
        print(self.name + '正在好好学习')


# Dog() 调用__new__ 方法，再调用 __init__ 方法
# Dog 里没有 __new__ 方法，会查看父类是否重写了 __new__ 方法
# 如果父类里也没有重写__new__ 方法，会查找父类的父类，找到object

# 调用 __init__ 方法,Dog类没有实现，会自动找 Animal父类
d1 = Dog('大黄', 6)
# print(d1)  # 父类里定义的属性，子类可以直接使用
d1.sleep()  # 父类的方法子类实例对象可以直接调用
d1.bark()

s1 = Student('小明', 18)
s1.sleep()
s1.study()
# s1.bark()  # 报错，Student里没有bark() 方法，父类里也没有

15. python里继承的特点

class A(object):

    def demo_a(self):
        print('我是A类里的方法demo_a')

    def foo(self):
        print('我是A类里的方法foo')


class B(object):

    def demo_b(self):
        print('我是B类里的方法demo_b')

    def foo(self):
        print('我是B类里的方法foo')


# python里允许多继承
class C(A, B):
    pass


c = C()
c.demo_a()
c.demo_b()

# 如果两个不同的父类有同名方法，谁写前面先调用谁
# 有一个类属性可以查看方法的调用顺序
c.foo()  # 我是A类里的方法foo
print(C.__mro__)  # (<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)

16. python里的多继承

class A(object):
    pass


class B(object):
    def foo(self):
        print('我是B类里的foo方法')


class C(A):
    def foo(self):
        print('我是C类里的foo方法')


class D(B):
    pass


class X(D, C):
    pass


x = X()
x.foo()  # 我是B类里的foo方法
print(X.__mro__)
# (<class '__main__.X'>, <class '__main__.D'>,
# <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

17. 私有属性的继承特点

class Animal(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.__weight = 50

    def eat(self):
        print(self.name + '正在吃东西')

    def __test(self):
        print('我是Animal类里的test方法')


class Dog(Animal):
    def __demo(self):
        print('我是Dog里的私有的demo方法')


d = Dog('小六', 3)
print(d.name)
d.eat()
# d.__test()
# d._Animal__test()  # 我是Animal类里的test方法，可以通过 对象名._父类名__私有方法  调用
# d._Dog__demo()  # 我是Dog里的私有的demo方法，自己类里定义的私有方法， 对象名._类名__私有方法()
# d._Dog__test()  # 报错，父类的私有方法，子类没有继承

print(d._Animal__weight)  # 50

18. 新式类和经典类

# -*— coding:utf8-*-  # python2里需加上这个才能识别中文
# 后面加括号，手动的指定Animal类继承自obj
class Animal(object):
    pass


# 没有指定Dog的父类，python3里默认继承自object
class Dog:
    pass



# 新式类和经典类的概念：
# 1.新式类：继承自object 的类我们称之为新式类
# 2.经典类：不继承自object 的类

# 在python2里，如果不手动的指定一个类的父类是object，这个类就是一个经典类
# 在python3里不存在 经典类，都是新式类