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>