Python_OOP1

最新推荐文章于 2022-09-03 10:41:49 发布

huaxingling

最新推荐文章于 2022-09-03 10:41:49 发布

阅读量325

点赞数

分类专栏： python 学习文章标签： python

本文链接：https://blog.csdn.net/huaxingling/article/details/98897649

版权

python 学习专栏收录该内容

2 篇文章 0 订阅

订阅专栏

Python是一门面向对象(object oriented programming)的编程语言.

面向对象概述

OOP 思想

	接触到任意一个任务，首先想到的是任务这个世界的构成，是由模型构成的。

OO相关的名词

OO: 面向对象
OOA: 面向对象的分析
OOD: 面向对象的设计
OOI: 面向对象的实现
OOP: 面向对象的编程
OOA->OOD->OOI: 面向对象的实现过程

类和对象的概念

类: 抽象名词，代表一个名词，共性的事物
对象：具体的事物，单个个体
类跟对象的关系:
- 一个具象，代表一类事物的某一个个体
- 一个抽象，代表的是一大类事物

类中的内容，应该具有两个内容

表明事物的特征，叫属性
表明事物的动作或者功能，称为成员方法(函数)

类的基本实现

类的命名

遵守变量命名的规则
大驼峰（由一个或者多个单词构成，单词首字母大写，单词跟单词直接相连）
尽量避开于系统命名相识的命名

如何声明一个类

必须用class关键字
类由属性和方法构成，其他不允许出现
成员属性可以直接赋值，如果没有值，可以赋None
案例 01.py
```
  class Student():
  	 pass
  zhangsan = Student()
  class PythonStudent():
  #None赋值给值不确定的成员
  name = None
  age = 18
  course = "Python"

  	def doHomework(self):
  		print("开始做作业了")

  lisi = PythonStudent()
  print(lisi.name)
  print(lisi.age)
  print(lisi.course)
  lisi.doHomework()
  print(lisi.__dict__)
  print(PythonStudent.__dict__)
```
‘’’
#输出结果
None
18
Python
开始做作业了
{}
{‘module’: ‘main’, ‘name’: None, ‘age’: 18, ‘course’: ‘Python’, ‘doHomework’: <function PythonStudent.doHomework at 0x00999CD8>, ‘dict’: <attribute ‘dict’ of ‘PythonStudent’ objects>, ‘weakref’: <attribute ‘weakref’ of ‘PythonStudent’ objects>, ‘doc’: None}
‘’’

实例化类

变量 = 类名() #实例化一个对象

访问对象成员

使用点操作符
obj.成员属性名称
obj.成员方法
可以通过默认内置变量检查类和对象的所有成员
- 对象所有成员检查
  - dict前后各有两个下划线 obj.dict
- 类所有成员检查
  - dict前后各有两个下划线 class_name.dict

类和对象的成员分析

类和对象都可以存储成员，成员可以归类所有，也可以归对象所有
类存储成员时使用的是与类关联的一个对象
独享存储成员时是存储在当前对象中
对象访问一个成员时，如果对象中没有该成员，尝试访问类中的同名成员，如果对象中有此成员，一定使用对象中的成员
创建对象的时候，类中的成员不会放入对象当中，而是得到一个空对象，没有成员
通过对象对类中成员重新赋值或通过对象添加成员时，对应成员会保存在对象中，而不会修改类成员

案例: 01.py

 class A():
  	name = "zhangsan"
  	age = "18"

  #A是类实例
  print(A.name)
  print(A.age)
  print(id(A.name))
  print(id(A.age))
  print("*" * 20)

  #对象实例
  a = A()
  print(A.__dict__)
  print(a.__dict__)
  print(a.name)
  print(a.age)
  print(id(a.name))
  print(id(a.age))
  print("*" * 20)

  a.name = "lisi"
  a.age = 20
  print(a.__dict__)
  print(a.name)
  print(a.age)
  print(id(a.name))
  print(id(a.age))

‘’’
#输出结果
zhangsan
18
13778760
13760960

{‘module’: ‘main’, ‘name’: ‘zhangsan’, ‘age’: ‘18’, ‘dict’: <attribute ‘dict’ of ‘A’ objects>, ‘weakref’: <attribute ‘weakref’ of ‘A’ objects>, ‘doc’: None}
{}
zhangsan
18
13778760
13760960

{‘name’: ‘lisi’, ‘age’: 20}
lisi
20
13637472
269706640
‘’’

关于self

self在对象的方法中表示当前对象本身，如果通过对象调用一个方法，那么该对象会自动传入该方法的第一个参数中.
self并不是关键字，只是一个用于接收对象的普通参数，理论上可以用任何一个普通变量名代替
方法中有self 形参的方法成为非绑定类的方法，可以通过对象访问，没有self的是绑定类的方法，只能通过类访问

使用类访问绑定类的方法时，如果类方法中需要访问当前类的成员，可以通过__class__.成员名来访问.

class A():
	name = "dana"
  	age = 18
  	def say(self):
  		self.name = "cainiao"
  		self.age = 20
  		print(self.name)
  		print(self.age)
  		#通过__class__来访问类中的变量
  		print(__class__.name)
  		print(__class__.age)

  	def sayA():
  		print("I am in sayA")
  		#通过__class__来访问类中的变量
  		print(__class__.name)
  		print(__class__.age)

  a = A()
  a.say()
  A.sayA()

‘’’
#输出结果
cainiao
20
dana
18
I am in sayA
dana
18
‘’’

  class Teacher():
  	name = "dana"
  	age = 30

  	def __init__(self):
  		self.name = "cainiao"
  		self.age = 18

  	def say(self):
  		print(self.name)
  		print(self.age)

  class B():
  	name = "haizi"
  	age = 5

  a = Teacher()

  #此时，系统会默认把a作为第一个参数传入函数
  a.say()

  #此时,self被a替代
  Teacher.say(a)

  #同样可以把Teacher作为参数传入
  Teacher.say(Teacher)

  #此时，传入的是实例B，因为B具有name和age的属性，所以不会报错
  Teacher.say(B)

  #以上代码，利用了鸭子模型

‘’’
#输出结果
cainiao
18
cainiao
18
dana
30
haizi
5
‘’’

面向对象的三大特征

封装
继承
多态

封装

封装就是对对象的成员进行访问限制
封装的三个级别
- 公开 public
- 受保护的 protected
- 私有的 private
- public, protected, private不是关键字
判断对象的位置
- 对象内部
- 对象外部
- 子类中
私有
- 私有成员是最高级别的封装，只能在当前类或对象中访问
- 在成员前面添加两个下划线__即可
受保护的 protected
- 受保护的成员只能在当前类和子类中访问
- 在成员前面添加一个下划线_即可
公有的 public
- 没有任何限制

继承

继承为了减少重复代码，提高效率
继承常用的名词:
- 被继承的类称为父类，基类, 超类
- 继承的类称为子类
super使用
- super不是关键字，而是一个类
- super的作用是获取MRO列表中的第一个类
- super于父类没有直接任何实质性关系，但通过super可以调用到父类
- super使用两个方法，常见在构造函数中调用父类构造函数
单继承和多继承
- 单继承: 每个类只能继承一个类
- 多继承: 每个类可以继承多个类
单继承和多继承优缺点
- 单继承
  - 传承有序，逻辑清晰，语法简单，隐患少
  - 功能不能无限扩展，只能在当前唯一的继承链中扩展
- 多继承
  - 优点: 类的功能扩展方便
  - 缺点: 继承关系混乱
- 菱形继承/钻石继承问题
  - 多个子类继承自同一父类，这些子类又被同一个子类继承，于是继承关系图形成一个菱形图谱。
  - 关于多继承的MRO
    - MRO就是多继承中，用于保存继承顺序的一个列表
    - python本身采用C3算法来对多继承的菱形继承进行计算的结果
    - MRO列表的计算原则
      - 子类永远在父类面前
      - 如果有多个父类，则根据继承语法中括号内类的书写顺序存放
      - 如果多个子类继承同一父类，则孙子类根据括号填写顺序找到直接爷爷类
- 构造函数
  - 构造函数在对象实例化的时候自动调用，一般做些初始化的工作
  - 如果函数没有构造函数，则按照MRO顺序，往上查找父类构造函数，直到找到为止。
  - 调用父类构造函数可以通过[父类名.init()]或者[super().__init()]调用

class A ():
    pass
class B ():
    def __init__(self, name):
        print("I am B init")
        print(name)
class C (B):
    def __init__(self, name):
        #通过父类名.init调用父类构造函数
        B.__init__(self, name)
        print("I am C init")

class D (B):
    def __init__(self, name):
        #通过super调用父类构造函数,python 3.0以后，下面两种写法都可以
        super().__init__(name)
        super(D, self).__init__(name)
        print("I am D init")

c = C ("I am C")
'''
输出结果:
I am B init
I am C
I am C init
'''
d = D ("I am D")
'''
输出结果:
I am B init
I am D
I am B init
I am D
I am D init
'''

多态

同一对象在不同状态下有不同的状态出现
多态不是一种语法，是一种设计思想
多态性：一种调用方式，不同的执行效果
多态：同一事物的多种形态，动物分为人类、狗类、猪类
多态和多态性
Mixin设计
- 主要采用多继承方式对类进行扩展
- 我们使用多继承语法来实现Mixin
- 使用Mixin实现多继承的时候非常小心
  - 首先他必须表示某一单一功能，而不是某个物品
  - 职责必须单一，如有多个功能，则写多个Mixin
  - Mixin不能依赖子类实现
  - 子类即使没有继承这个Mixin类，也能照样工作，只是缺少类某个功能
- 优点:
  - 使用Mixin可以在不对类进行修改的情况下，扩展功能
  - 可以方便地组织维护不同功能的组件的划分
  - 可以根据需要任意调整功能类的组合
  - 可以避免创建很多新的类，导致类的继承混乱

#Minxin相关实例
class Person():
    def eat(self):
        print("EATING")
    def sleep(self):
        print("SLEEPING")

#只有teach功能
class TeacherMixin():
    def teach(self):
        print("TEACHING")

#只有study功能
class StudentMixin():
    def study(self):
        print("STUDING")

class Tutor(Person, TeacherMixin, StudentMixin):
    pass

t = Tutor()
print(Tutor.__mro__)
print(t.__dict__)
print(Tutor.__dict__)
'''
输出结果:
(<class '__main__.Tutor'>, <class '__main__.Person'>, <class '__main__.TeacherMixin'>, <class '__main__.StudentMixin'>, <class 'object'>)
{}
{'__module__': '__main__', '__doc__': None}
'''

类相关函数

issubclass: 检测一个类是否是另一个类的子类

#issubclass 实例,前面参数是子类名,后面参数是父类名
class A():
    pass

class B (A):
    pass

print(issubclass(B, A))
print(issubclass(A, object))
'''
输出结果:
True
True
'''

isinstance: 检测一个类是否是另一个类的实例

#isinstance实例，前面参数是实例，后面参数是类名
class A():
    pass

class B (A):
    pass

a = A()
print(isinstance(a, A))
print(isinstance(a, B))
'''
输出结果:
True
False
'''

hasattr: 检测一个对象是否有成员xxx

# hasattr实例
class C ():
    name ='test'
    pass
c = C ()
print(hasattr(c, 'name'))
print(hasattr(c, 'age'))
'''
True
False
'''

getattr: get attribute
setattr: set attribute
delattr: delete attribute
dir: 获取对象的成员列表

# dir实例
class C ():
    name ='test'
    pass
c = C ()
print(dir(C))
print(dir(c))
'''
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name']
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name']
'''

#help 案例
help(setattr)
'''
输出:
Help on built-in function setattr in module builtins:

setattr(obj, name, value, /)
    Sets the named attribute on the given object to the specified value.
    
    setattr(x, 'y', v) is equivalent to ``x.y = v''
'''

huaxingling

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Python_OOP1

Python是一门面向对象(object oriented programming)的编程语言.面向对象概述OOP 思想接触到任意一个任务，首先想到的是任务这个世界的构成，是由模型构成的。OO相关的名词OO: 面向对象OOA: 面向对象的分析OOD: 面向对象的设计OOI: 面向对象的实现OOP: 面向对象的编程OOA->OOD->OOI: 面向对象的实现过程...
复制链接

扫一扫

专栏目录