8--oop

zoukankan html css js c++ java

8--oop
oop-Python面向对象
- Python的面向对象
- 面向对象编程
  
  基础
  
  共有私有
  
  继承
  
  组合，Mixin
- 魔法函数
  
  魔法函数概述
  
  构造类魔法函数
  
  运算类魔法函数
1.面向对象概述（ObjectOriented,00）
- OOP思想
- 几个名词
  
  OO：面向对象
  
  OOA：面向对象的分析
  
  OOD：面向对象的设计
  
  OOI：面向对象的实现
  
  OOP：面向对象的编程
  
  OOA->OOD->OOI：面向对象的实现过程
- 类和对象的概念
  
  类：抽象名词，代表一个集合，共性的事物
  
  对象：具象的事物，单个个体
  
  类跟具象的关系
  
  一个具象，代表一类事物的某一个个体
  
  一个是抽象，代表的是一大类事物
  
  类中的内容，应该具有两个内容
  
  表明事物的特征，叫做属性（变量）
  
  表明事物功能或动作，称为成员方法（函数）
2. 类的基本实现
- 类的命名
  
  遵守变量命名的规范
  
  大驼峰（由一个或多个单词构成，每个单词首字母大写，单词跟单词直接相连）
  
  尽量避开跟系统命名相似的命名
- 如何申明一个类
  
  必须用class关键字
  
  类由属性和方法构成，其他不允许出现
  
  成员属性定义可以直接使用变量赋值，如果没有，可以使用None
  
  案例 01.py
定义一个学生类，用来形容学生
```
# 定义一个空的类
class Student():
	# 一个空类，pass代表直接跳过
	# 此处pass必须有
	pass

# 定义一个对象
mingyue = Student()

#在定义一个类，用来描述听Python的学生
class PythonStudent():
	# 用None给不确定的值赋值
	name = None
	age = 18
	course = "Python"
	
	# 需要注意
	# 1.def doHomework的缩进层级
	# 2.系统默认由一个self参数
	def doHomework(self):
		print("I 在做作业")
		
		# 推荐在函数末尾使用return语句
		return None
		
# 实例化一个叫yueyue的学生，是一个具体的人
yueyue = PythonStudent()
print(yueyue.name)
print(yueyue.age)
# 注意成员函数的调用没有传递进入参数
yueyue.doHomework()
```
```
- 案例 02.py
```
```
class A():
	name = 'jjc'
	age = 18

for k,v in A.__dict__.items():
	print(k,"--",v)
```
- 实例化类
  
  变量 = 类名() # 实例化了一个对象
- 访问对象成员
  -使用点操作符
```
        obj.成员属性名称
        obj.成员方法
```
- 可以通过默认内置变量检查类和对象的所有成员
  
  对象所有成员检查
```
        dict前后各有两个下划线
        obj.__dict__
```
- 类所有的成员
```
        class_name.__dict__
```
3.anaconda基本使用
```
- anaconda主要是一个虚拟环境管理器
- 还是一个安装包管理器
- conda list：显示anaconda安装的包
- conda  env list：显示anconda的虚拟环境列表
- conda create -n xxx python=3.6：创建python版本为3.6的虚拟环境，名称为xxx
```
4.类和对象的成员分析
- 类和对象都可以存储成员，成员可以归类所有，也可以归对象所有
- 类存储成员时使用的是与类关联的一个对象
- 对象存储成员时是存储在当前对象中
- 对象访问一个成员时，如果对象中没有该成员，尝试访问类中同名的成员，如果对象中有此成员，一定使用对象中的成员
- 创假对象的时候，类中的成员不会放人对象当中，而得到一个空对象，没有成员
- 通过对象对类中成员重新赋值后者通过对象添加成员时，对应成员会保存在对象中，而不会修改类成员
5. 关于self
- self在对象的方法中表示当前对象本身，如果，通过对象调用一个方法，那么该对象会自动传入到当前方法的第一个参数
- self并不是关键字，只是一个用于接受对象的普通参数，理论上可以用任何一个普通变量名代替
- 方法中有self形参的方法成为非绑定类的方法，可以通过对象访问，没有self的是绑定类的方法，只能通过类访问
- 使用类访问绑定类的方法时，如果类方法中需要访问当前的成员，可以通过__class__成员来访问
6. 面向对象的三大特性
- 封装
- 继承
- 多态
6.1 封装
- 封装就是对对象的成员进行访问限制
- 封装的三个级别：
  
  公开，public
  
  受保护的，public
  
  私有的，public
  
  public,public,public不是关键字
- 判别对象的位置
  
  对象内部
  
  对象外部
  
  子类中
- 私有
  
  私有成员是最高级别的封装，只能在当前类或对象中访问
  
  在成员前面添加两个下划线即可
  
  python的私有不是真私有，是一种name mangling的改名策略，可以使用对象._classname__attributename访问
```
class Person():
    # name是共有的成员
    name = 'jjc'
    # __age就是私有成员
    __age = 18
p = Person()
print(p._Person__age)
```
- 受保护的封装
  
  受保护的封装是将对象成员进行一定级别的封装，然后，在类中或者子类中都可以进行访问，但是在外部不可以
  
  封装方法：在成员名称添加一个下划线即可
- 公开的
  
  公开的封装实际对成员没有任何操作，任何地方都可以访问
6.2 继承
- 继承就是一个类可以获得另外一个类中的成员属性和成员方法
- 作用：减少代码，增加代码的复用功能，同时可以设置类与类直接的关系
- 继承与被继承的概念：
  
  被继承的类叫父类，也叫基类，也叫超类
  
  用于继承的类，叫子类，也叫派生类
  
  继承与被继承一定存在一个 is-a 关系
- 继承的语法
```
# 继承的语法
# 在python中，任何类都有一个共同的父类叫object

class Person():
	name = 'NoName'
	age = 0
	def sleep(self):
		print('Sleeping')
# 父类写在括号内
class Teacher(Person):
	pass
	
t = Teacher()
t.sleep()
print(t.name)
```
- 继承的特征
  
  所有的类都继承自object类，即所有的类都是object类的子类
  
  子类一旦继承父类，则可以使用父类中除私有成员外的所有内容
  
  子类继承父类后并没有将父类成员完全赋值到子类中，而是通过引用关系访问调用
  
  子类中可以定义独有的成员属性和方法
  
  子类中定义的成员和父类成员相同，则优先使用子类成员
  
  子类想扩充弄父类的方法，可以在定义新方法的同时访问父类成员来进行代码重用，可以使用 [父类名.父类成员] 的格式来调用父类成员，也可以使用 [super().父类成员] 的格式
- 继承变量函数的查找顺序问题
  
  优先查找自己的变量
  
  没有则查找父类
  
  构造函数如果本类中没有定义，则自动查找调用父类构造函数
  
  如果本类有定义，则不再继续向上查找
```
# 继承的语法
# 在python中，任何类都有一个共同的父类叫object
# 子类和父类定义同一个名称变量，则优先使用子类本身
class Person():
	name = 'NoName'
	age = 18
	__score = 0 # 考试成绩是秘密，只有自己知道
	_petname = "sec" # 小名，保护的，子类可以用，但不公用
	def sleep(self):
		print('Sleeping')
		
	def work(self):
		print('make some money')
# 父类写在括号内
class Teacher(Person):
	teacher_id = '9527'
	name = 'jjc'
	def make_test(self):
		print('attention')

	def work(self):
		# 扩充父类的功能只需要调用父类相应的函数
		# Person.work(self)
		# 另一种方法，super代表父类
		Person.work(self)
		super().work()
		self.make_test()
		
t = Teacher()

t.work()
```
- 构造函数
  
  是一类特殊的函数，在类进行实例化之前进行调用
  
  如果定义了构造函数，则实例化时使用构造函数，不查找父类构造函数
  
  如果没定义，则自动查找父类构造函数
  
  如果子类没定义，父类的构造函数带参数，则构造对象时的参数应该按父类参数构造
```
# 构造函数的概念
# 继承中的构造函数
class Animal():
	def __init__(self):
		print('Dong wu')
	
class PaxingAni(Animal):
	
	def __init__(self,name):
		print('Paxing Dongwu {0}'.format(name))

class Dog(PaxingAni):
	# __init__就是构造函数
	# 每次实例化的时候，第一个被调用
	# 因为主要工作是进行初始化，所以得名
	def __init__(self):
		print("I'm init in dog")
# 实例化的时候，括号内的参数需要跟构造函数参数匹配
# 因为找到了构造函数，则不再查找父类的构造函数
kaka = Dog()
# 实例化Dog时，查找到Dog的构造函数，参数匹配，不报错


# 猫没有写构造函数
class Cat(PaxingAni):
	pass
# 此时Cat没有构造函数，则向上查找
# 因为PaxingAni的构造函数需要两个参数，实例化的时候给了一个，报错
c = Cat('jjc')
```
- super
  
  super不是关键字，而是一个类
  
  super的作用是获取MRO列表中的一个类
  
  super与父类没有实质性关系，但通过super可以调用到父类
  
  super使用的两个方法，参见在构造函数中调用父类的构造函数
- 单继承和多继承
  
  单继承：每个类只能继承一个类
  
  多继承：每个类允许继承多个类
- 单继承和多继承的优缺点
  
  单继承：
  
  传承有序逻辑清晰语法简单隐患少
  
  功能不能无限扩展，只能在当前唯一的继承链中扩展
  
  多继承：
  
  优点：类的功能扩展方便
  
  缺点：继承关系混乱
- 菱形继承/钻石继承问题
  
  多个子类继承自同一个父类，这些子类游被同一个类继承，于是继承关系图星程了一个菱形
  
  关于多继承的MRO
  
  MRO就是多继承中，用于保存继承顺序的一个列表
  
  python本身采用C3算法来多继承的菱形继承进行计算的结果
  
  MRO列表的计算原则：
  
  子类永远在父类之前
  
  如果多个父类，则根据继承语法中括号内类的书写顺序存放
  
  如果多个类继承同一个父类，孙子类中只会选取继承语法括号中第一个父类的父类
```
# 菱形继承
class A():
	pass
	
class B(A):
	pass

class C(A):
	pass
	
class D(B,C):
	pass
```
6.3 多态
- 多态就是同一个对象在不同情况下有不痛的状态出现
- 多态不是语法，是一种设计思想
- 多态性：一种调用方式，不同的执行效果
- 多态：同一事物的多种形态，动物分为人类，狗类，猪类
- [多态及多态性[(https://www.cnblogs.com/luchuangao/p/6739557.html)
- Mixin设计模式
  
  主要采用多继承方式对类的功能进行扩展
  
  我们使用多继承语法来实现MIxin
  
  使用Mixin实现多继承的时候非常小心
  
  首先他必须表示某一单一功能，而不是某个物品
  
  职责必须单一，如果由多个功能，则写多个Mixin
  
  Mixin不能依赖于子类的实现
  
  子类即使没有继承这个Mixin类，也能照样工作，只是缺少了某个功能
  
  优点
  
  使用Mixin可以在不对类进行任何修改的情况下，扩展功能
  
  可以方便的组织和维护不同功能组件的划分
  
  可以根据需要任意调整功能类的组合
  
  可以避免创建很多新的类，导致类的继承混乱
7. 类相关函数
- issubclass：检测一个类是否是另一个类的子类
- isinstance：检测一个对象是否是一个类的实例
- hasattr：检测一个对象是否有成员XXX
- getattr： get attribute
- setattr： set attribute
- delattr：delete attribute
- dir：获取对象的成员列表
```
class A():
	name = 'Jjc'
class B(A):
	pass
class C():
	pass
#检测B是否为A的子类
print(issubclass(B,A))
print(issubclass(B,object))
# 返回True

a=A()
print(isinstance(a,A))

print(hasattr(a,'name'))
```
8. 类的成员描述符（属性）
```
# 属性案例
# 创建Student类，描述学生类
# 学生具有Student.name属性
# 但 named格式不统一

class Student():
    def __init__(self,name,age):
        self.name = name
        self.age = age
        #self.setName(name)
    def intro(self):
        print('Hi, my name is {0}'.format(self.name.upper()))
    
    def setName(self,name):
        self.name = name.title()
        
        
s1 = Student('jJC',19)
s2 = Student('wcx',18.0)
s1.intro()
s2.intro()
```
- 类的成员描述符是为了在类中对类的成员属性进行相关操作而创建的一种方式
  
  get：获取属性的操作
  
  set：修改后者添加属性操作
  
  delete：删除属性的操作
- 如果想使用类的成员描述符，大概有三种方法
  
  使用类实现描述器
  
  使用属性修饰符
  
  使用property函数
  
  property（fget, fset, fdel,doc）
- 案例
```
# property案例
class A():
	def __init__(self):
		self._name = 'haha'
		self._age = 18
	# 此功能，是对类变量进行读取操作的时候应该执行的函数功能
	def fget(self):
		print("{0}被读取了".format(self._name))
		return self._name
	# 模拟的是对变量进行写操作的时候执行的功能
	def fset(self, val):
		print("{0}我被写入了，但是还可以做好多事情".format(val))
		self._name = '我是' + val
		
	# fdel模拟的是删除变量的时候进行的操作
	def fdel(self):
		del self._name
	
	name = property(fget, fset, fdel, "这是一个property的例子")
	
a = A()
a.name = "jjc"
print(a.name)
```
```
#上面的代码等价于下面的代码

class A(object):
	
	@property
	def name(self):
		print("{0}被读取了".format(self._name))
		return self._name
	
	@name.setter
	def name(self,val):
		print("{0}我被写入了，但是还可以做好多事情".format(val))
		self._name = '我是' + val
		
	@name.deleter
	def name(self):
		del self._name
		
a = A()
a.name = "jjc"
print(a.name)
```
- 无论哪种修饰符都是为了队成员属性进行相应的控制
  
  类的方式：适合多个类中的多个属性共用一个描述符
  
  property：使用当前类中使用，可以控制一个类中多个属性
  
  属性修饰符：使用于当前类中使用，控制一个类中的一个属性
9. 类的内置属性
```
- __dict__：以字典的方式显示类的成员组成
- __doc__：获取类的文档信息
- __name__：获取类的名称，如果在模块中使用，获取模块的名称
- __bases__：获取某个类的所有父类，以元组的方式显示
```
10. 类的常用魔术方法
- 魔术方法就是不需要人为调用的方法，基本是在特定的时刻自动触发
- 魔术方法的统一的特征，方法名被前后各两个下划线包裹
- 操作类
  
  'init'：构造函数
  
  'new'：对象实例化方法
  
  'call'：对象当函数使用的时候触发
  
  'str'：当对象被当做字符串使用的时候调用
  
  repr：返回字符串，跟__str__
```
# __init__ 举例
class A():
	def __init__(self,name = 0):
		print("sa")
	# __call__举例
	
	def __call__(self):
		print("我被举报了")
	
	def __str__(self):
		return 'bu'
a = A()
a()
print(a)
```
- 描述符相关
  
  set
  
  get
  
  delete
- 属性操作相关
  
  getattr：访问一个不存在的属性时触发,案例
  
  setattr：对成员属性进行设置的时候触发，案例
  
  参数：
  
  self用来获取当前对象
  
  被设置的属性名称，以字符串形式出现
  
  需要对属性名称设置的值
  
  作用：进行属性设置的时候进行验证或者修改
  
  注意：在该方法中不能对属性直接进行赋值操作，否则死循环
```
class A():
	def __getattr__(self,name):
		print('没找到')
		print(name)
a = A()

print(a.name)
print(a.addr)
```
```
# __setattr__案例
class Person():
	def __init__(self):
		pass
	
	def __setattr__(self, name, value):
		print('设置属性：{0}'.format(name))
		# 下面语句会导致问题，死循环
		#self.name = value
		# 此种情况，为了避免死循环，规定统一调用父类魔法函数
		super().__setattr__(name,value)
p = Person()
print(p.__dict__)
p.age = 18
```
- 运算分类相关魔术方法
  
  gt：进行大于判断的时候触发的函数
  
  参数
  
  self
  
  第二个参数是第二个对象
  
  返回值可以是任意值，推荐返回布尔值
  
  案例
```
# __get__
class Student():
	def __init__(self,name):
		self._name = name
	
	def __gt__(self,obj):
		print("haha, {0}会比{1}大吗？".format(self._name,obj._name))
		return self._name > obj._name
# 字符串的比较是按什么规则
stu1 = Student('one')
stu2 = Student('two')
print(stu1 > stu2)
# 问，如何让显示结果美观，one 会比 twi大吗
```
11. l类和对象的三种方法
- 实例方法
  
  需要实例化对象才能使用的方法，使用过程中可能需要截止对象的其他的方法完成
- 静态方法
  
  不需要实例化，通过类直接访问
- 类方法
  
  不需要实例化
- 参看案例
```
# 三种方法案例
class Person:
	# 实例方法
	def eat(self):
		print(self)
		print('Eating……')
		
	# 类方法
	# 类方法的第一个参数，一般命名为cls，区别于self
	@classmethod
	def play(cls):
		print(cls)
		print('Playing……')
		
	# 静态方法
	# 不需要用第一个参数表示自身或者类
	@staticmethod
	def say():
		print('Saying……')
yueyue = Person()

#实例方法
yueyue.eat()
# 类方法
Person.play()
yueyue.play()
# 静态方法
Person.say()
yueyue.say()
```
12.抽象类
- 抽象方法：没有具体实现内容的方法成为抽象方法
- 抽象方法的主要意义是规范了子类的行为和接口
- 抽象类的使用需要借助abc模块
  
  import abc
- 抽象类：包含抽象方法的类叫抽象类，通常成为ABC类
- 抽象类的使用
  
  抽象类可以包含抽象方法，也可以包含具体方法
  
  抽象类中可以有方法也可以有属性
  
  抽象类不允许直接实例化
  
  必须继承才可以使用，且继承的子类必须实现所有继承来的抽象方法
  
  假定子类没有实现所有的抽象方法，则子类也不能实例化
  
  抽象类的主要作用是设定类的标准，以便于开发的时候具有统一的规范
```
# 抽象类的实现
import abc
# 申明一个类并且制定当前类的元类
class Human(metaclass = abc.ABCMeta):
	
	# 定义一个抽象的方法
	@abc.abstractmethod
	def smoking(self):
		pass
		
	# 定义类抽象方法
	@abc.abctractclassmethod
	def drink():
		pass
	
	# 定义静态抽象方法	
	@abc.abstractstaticmethod
	def play():
		pass
```
13.自定义类
- 类其实是一个类定义和各种方法的自由组合
```
# 自己组装一个类
# 如果要绑定对象,用下面一句代码，绑定类，不需要
from types import MethodType

class A():
	pass
	
def say(self):
	print("saying……")
	
a = A()
a.tt = MethodType(say,A)
a.tt()
```
- 可以定义类和函数，然后自己通过类直接赋值
- 可以借助MethodType实现
- 借助于type实现
- 利用元类实现，MetaClass
  
  元类是类
  
  备用来创造别的类
```
# 利用type造一个类
# 先定义类应该具有的成员函数
def say(self):
	print("saying……")
def talk(self):
	print("Talking……")

# 用type来创建一个类
A = type("AName",(object,),{"class_say":say, "class_talk":talk})

# 然后可以像正常访问一样使用类
a = A()

a.class_say()
a.class_talk()
```
```
# 元类演示
# 元类写法是固定的，必须继承自type
# 元类一般命名以MetaClass结尾
class TulingMetaClass(type):
	# 注意一下写法
	def __new__(cls, name, bases, attrs):
		# 自己的业务处理
		print("我是元类")
		attrs['id'] = '000000'
		attrs['addr'] = "苏州市"
		return type.__new__(cls, name, bases, attrs)

# 元类定义完就可以使用，使用注意写法
class Teacher(object, metaclass = TulingMetaClass):
	pass
	
t = Teacher()

t.id
```
查看全文

相关阅读:
Day11作业
 day12作业
 samba共享服务
 PHP7 redis扩展安装
 linux lin命令
 PhpStorm,Pycharm,Goland破解
 PHP规范PSR2
PHP 过滤器（Filter）
Linux下Redis的安装与配置
 linux命令汇总

原文地址：https://www.cnblogs.com/rener0424/p/10358103.html

oop-Python面向对象

1.面向对象概述（ObjectOriented,00）

2. 类的基本实现

3.anaconda基本使用

4.类和对象的成员分析

5. 关于self

6. 面向对象的三大特性

6.1 封装

6.2 继承

6.3 多态

7. 类相关函数

8. 类的成员描述符（属性）

9. 类的内置属性

10. 类的常用魔术方法

11. l类和对象的三种方法

12.抽象类

13.自定义类