python面向对象入门（第一天）

最新推荐文章于 2023-12-27 10:02:22 发布

LZXLZX233

最新推荐文章于 2023-12-27 10:02:22 发布

阅读量526

点赞数

分类专栏： python学习文章标签： python 面向对象编程

本文链接：https://blog.csdn.net/weixin_53385818/article/details/122690192

版权

python学习专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1.类: 类是对一群具有相同特征或者行为的事物的一个统称，是抽象的，不能直接使用
    特征被称为属性
    行为被称为方法
类就相当于制造飞机时的图纸，是一个模板，是复制创建对象的

2.对象: 对象是由类创建出来的一个具体存在，可以直接使用
    由哪一个类创建出来的对象，就拥有在哪一个类中定义的: 属性和方法
对象就相当于用图纸制造的飞机
在程序开发中，应该先有类，再有对象

3.类和对象的关系
    类是模板，对象是根据类这个模板创建出来的，应该先有类，再有对象
    类只有一个，而对象可以有很多个
    不同的对象之间属性 可能会各不相同
    类中定义了什么属性和方法，对象中就有什么属性和方法，不可能多，也不可能少

4.类的设计
    在程序开发中，要设计一个类，通常需要满足一下三个要素：
        类名: 这类事物的名字，满足大驼峰命名法(每一个单词的首字母大写并且单词与单词之间没有下划线)
        属性: 这类事物具有什么样的特征
        方法: 这类事物具有什么样的行为
    4.1 类名的确定
        名词提炼法 分析整个业务流程，出现的名词，通常就是找到的类
    4.2 属性和方法的确定
        对对象的特征描述，通常可以定义成属性
        对象具有的行为（动词），通常可以定义成方法
        提示: 需求中没有涉及的属性或者方法在设计类时，不需要考虑

class Person:
    """这是一个猫类"""

    def eat(self):
        # self: 对本对象的引用
        # 1.在类封装的方法内部，self就表示当前调用方法的对象自己
        # 2.调用方法时，self参数是可以缺省的 解释器会自动帮我们传入
        # 3.在方法内部 可以通过self.访问对象的属性 也可以通过self.调用其他的对象方法
        print("%s 人会吃" % self.name)

    def drink(self):
        print("人会喝水")


# 创建对象
tom = Person()
# tom.eat()  # 在设置属性之前 调用方法报错
tom.drink()
# 在类的外部是可以直接通过.的方式去给对象添加属性的，但是不推荐
# 因为对象属性的封装应该封装在类的内部
tom.name = "Tom"
# print(tom.name)
tom.eat()  # tom.eat(tom)
# print(tom.__dict__)  # 可以查看对象绑定了哪些属性
# print(Person.__dict__)  # 可以查看类绑定了哪些命名空间

初始化方法init（相当于C++中的构造函数）：

"""
初始化方法:
    1.当使用类名()创建对象时，会自动执行以下操作:
      为对象在内存中分配空间--创建对象
      为对象的属性设置初始值--初始化方法(init)
    2.__init__方法是专门用来定义一个类具有哪些属性的方法
"""


# 在Cat中增加__init__方法，验证该方法在创建对象时会被调用
class Cat:
    """这是一个猫类"""

    # def __init__(self):
    #     print("这是一个初始化方法")
    #     # 定义用Cat类创建的猫对象都有一个name的属性
    #     self.name = "Tom"

    # 在开发中，如果希望在创建对象的同时，就设置对象的属性，可以对_init__方法进行改造
    # 把希望设置的属性值，定义成__init__方法的参数，在方法内部使用
    # self.属性 = 形参 接收外部传递的参数
    # 在创建对象时，使用类名(属性1, 属性2...)

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

    def eat(self):
        print("%s 爱吃鱼" % self.name)

    # 如果在开发中，希望使用print输出对象变量时，能够打印自定义的内容，就可以利用__str__这个内置方法了
    def __str__(self):
        return "我是小猫: %s" % self.name

    # def __del__(self):
    # __del__:如果希望在对象被销毁前，再做一些事情，可以考虑此方法
    def __del__(self):
        print("准备删除~~~")


tom = Cat("Tom")  # 创建对象时 会自动调用初始化__init__方法
tom.eat()
lazy_cat = Cat("大懒猫")
lazy_cat.eat()
# 在Python中，使用print输出对象变量，默认情况下，会输出这个变量引用的对象是由哪一个类创建的对象，
# 以及在内存中的地址（十六进制表示）
print(tom)  # <__main__.Cat object at 0x103959bd0>

del lazy_cat
print("-" * 50)
————————————————
版权声明：本文为CSDN博主「Amo Xiang」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/xw1680/article/details/103641726

私有属性：

定义的方式: 在定义属性或方法时，在属性名或者方法名前增加两个下划线，定义的就是私有属性或方法在java中的话是使用private关键字

继承：

单继承：

# ---------不使用继承开发动物和狗---------------
class Animal:

    def eat(self):
        print("吃")

    def drink(self):
        print("喝")

    def run(self):
        print("跑")

    def sleep(self):
        print("睡")


class Dog:

    def eat(self):  # 不使用继承重复书写的代码太多
        print("吃")

    def drink(self):
        print("喝")

    def run(self):
        print("跑")

    def sleep(self):
        print("睡")

    def bark(self):
        print("汪汪叫")


# 创建一个狗对象
wang_cai = Dog()

wang_cai.eat()
wang_cai.drink()
wang_cai.run()
wang_cai.sleep()
wang_cai.bark()
# # ---------使用继承开发动物和狗---------------
class Animal:
    def eat(self):
        print("吃---")

    def drink(self):
        print("喝---")

    def run(self):
        print("跑---")

    def sleep(self):
        print("睡---")


class Dog(Animal):
    def bark(self):
        print("汪汪叫---")


# 创建一个狗对象
wang_cai = Dog()
wang_cai.eat()
wang_cai.drink()
wang_cai.run()
wang_cai.sleep()
wang_cai.bark()  # 直接享受父类中已经封装好的方法 不需要再次开发

7.2.2 继承的语法
class 类名(父类名):
	pass

子类继承自父类，可以直接享受父类中已经封装好的方法，不需要再次开发
子类中应该根据职责，封装子类特有的属性和方法
专业术语
Dog类是Animal类的子类，Animal类是Dog类的父类，Dog类从Animal类继承
Dog类是Animal类的派生类，Animal类是Dog类的基类，Dog类从Animal类派生
继承的传递性
C类从B类继承，B类又从A类继承，那么C类就具有B类和A类的所有属性和方法
# -*- coding: utf-8 -*-
# @Time    : 2019/12/21 10:52
# @Author  : 我就是任性-Amo
# @FileName: 9.继承的传递性.py
# @Software: PyCharm
# @Blog    ：https://blog.csdn.net/xw1680


class Animal:

    def eat(self):
        print("吃---")

    def drink(self):
        print("喝---")

    def run(self):
        print("跑---")

    def sleep(self):
        print("睡---")


class Dog(Animal):

    def bark(self):
        print("汪汪叫")


class XiaoTianQuan(Dog):

    def fly(self):
        print("我会飞")


# 创建一个哮天犬的对象
xtq = XiaoTianQuan()

xtq.fly()
xtq.bark()
xtq.eat()
————————————————
版权声明：本文为CSDN博主「Amo Xiang」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/xw1680/article/details/103641726

多继承：

class 子类名(父类名1, 父类名2...):
	pass

7.3.4 继承的实现原理
python到底是如何实现继承的，对于你定义的每一个类，python会计算出一个方法解析顺序(MRO)列表，这个MRO列表就是一个简单的所有基类的线性顺序列表，例如：

(<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

为了实现继承,python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止。而这个MRO列表的构造是通过一个C3线性化算法来实现的。我们不去深究这个算法的数学原理,它实际上就是合并所有父类的MRO列表并遵循如下三条准则:

子类会先于父类被检查
多个父类会根据它们在列表中的顺序被检查
如果对下一个类存在两个合法的选择,选择第一个父类
在Java和C#中子类只能继承一个父类，而Python中子类可以同时继承多个父类，如果继承了多个父类，那么属性的查找方式有两种，分别是：深度优先和广度优先

————————————————
版权声明：本文为CSDN博主「Amo Xiang」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/xw1680/article/details/103641726

class A(object):
    def test(self):
        print('from A')


class B(A):
    def test(self):
        print('from B')


class C(A):
    def test(self):
        print('from C')


class D(B):
    def test(self):
        print('from D')


class E(C):
    def test(self):
        print('from E')


class F(D, E):
    # def test(self):
    #     print('from F')
    pass


f1 = F()
f1.test()
print(F.__mro__)  # 只有新式才有这个属性可以查看线性列表，经典类没有这个属性
# import inspect  # 使用inspect模块中的getmro()方法可以查看python2.x的mro顺序
————————————————
版权声明：本文为CSDN博主「Amo Xiang」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/xw1680/article/details/103641726

# 新式类继承顺序如下:
# <class '__main__.F'>, 
# <class '__main__.D'>, 
# <class '__main__.B'>, 
# <class '__main__.E'>, 
# <class '__main__.C'>, 
# <class '__main__.A'>, 
# <class 'object'>

# 经典类继承顺序如下:
# <class __main__.F at 0x1033b3c18>,
# <class __main__.D at 0x1033b3b48>,
# <class __main__.B at 0x1033b3a78>,
# <class __main__.A at 0x1033b3a10>,
# <class __main__.E at 0x1033b3bb0>,
# <class __main__.C at 0x1033b3ae0>