python入门—面向对象

Python 支持面向过程、面向对象、函数式编程等多种编程范式
面向对象和面向过程区别

挖坑

• 为什么可以这样

def init( name, score):  # self必须位于第一个参数
    name = name
    score = score
    print(name,score)

class Student:   #类名一般首字母大写，多个单词采用驼峰原则

    def __init__(self,name,score): #self必须位于第一个参数
        self.name = name
        self.score = score

    def say_score(self):   #self必须位于第一个参数
        print("{0}的分数是：{1}".format(self.name,self.score))

• 参数的重复 类方法实例方法的重名

面向过程(Procedure Oriented)思维
面向过程编程更加关注的是“程序的逻辑流程”，是一种“执行者”思维，适合编写小 规模的程序。
面向对象(Object Oriented)思维
面向对象更加关注的是“软件中对象之间的关系”，是一种“设计者”思维，适合编写 大规模的程序。
类的定义
我们把对象比作一个“饼干”，类就是制造这个饼干的“模具”。
对象是类的具体实体，一般称为“类的实例”。
从一个类创建对象时，每个对象会共享这个类的行为（类中定义的方法），但会有自己的属 性值（不共享状态）。更具体一点：“方法代码是共享的，属性数据不共享”。


Python 中，“一切皆对象”。类也称为“类对象”，类的实例也称为“实例对象”。
定义类的语法格式如下： class 类名：
类体

要点如下：
1.类名必须符合“标识符”的规则；一般规定，首字母大写，多个单词使用“驼峰原则”。
2.类体中我们可以定义属性和方法。
属性用来描述数据，方法(即函数)用来描述这些数据相关的操作。

实例属性和实例方法
实例属性
实例属性是从属于实例对象的属性，也称为“实例变量”。他的使用有如下几个要点： 1. 实例属性一般在__init__()方法中通过如下代码定义： self.实例属性名 = 初始值 2. 在本类的其他实例方法中，也是通过 self 进行访问： self.实例属性名 3. 创建实例对象后，通过实例对象访问：
obj01 = 类名() #创建对象，调用__init__()初始化属性
obj01.实例属性名 = 值 #可以给已有属性赋值，也可以新加属性
实例方法
实例方法是从属于实例对象的方法。
实例方法的定义格式如下：
def 方法名(self [, 形参列表])：
函数体
方法的调用格式如下：
对象.方法名([实参列表])
要点：

1. 定义实例方法时，第一个参数必须为 self。和前面一样，self 指当前的实例对象。
2. 调用实例方法时，不需要也不能给 self 传参。self 由解释器自动传参。
   本质：a.say_score()==Student.say_score(a)
   实例方法共用

其他操作： 1. dir(obj)可以获得对象的所有属性、方法
2. obj.dict 对象的属性字典
3. pass 空语句
4. isinstance（对象,类型） 判断“对象”是不是“指定类型”
函数和方法的区别
5. 都是用来完成一个功能的语句块，本质一样。 2. 方法调用时，通过对象来调用。方法从属于特定实例对象，普通函数没有这个特点。 3. 直观上看，方法定义时需要传递 self，函数不需要。
类属性
类属性是从属于“类对象”的属性，也称为“类变量”。由于，类属性从属于类对象，可以 被所有实例对象共享。
类属性的定义方式：class 类名： 类变量名= 初始值 在类中或者类的外面，我们可以通过：“类名.类变量名”来读写。
在类中或者类的外面，我们可以通过：“类名.类变量名”来读写。

类方法
类方法是从属于“类对象”的方法。类方法通过装饰器@classmethod 来定义，格式如下：

@classmethod
def 类方法名(cls [，形参列表]) ：
函数体
要点如下：

1. @classmethod 必须位于方法上面一行 ，一个方法定义用一次
2. 第一个 cls 必须有；cls 指的就是“类对象”本身；
3. 调用类方法格式：“类名.类方法名(参数列表)”。 参数列表中，不需要也不能给 cls 传 值。
4. 类方法中访问实例属性和实例方法会导致错误
5. 子类继承父类方法时，传入 cls 是子类对象，而非父类对象
   实例对象可以调用类属性和类方法
   不同实例对象的类属性不是同一个对象
   调用类属性不管在类里还是类外都要用“类名.类变量名”来读写
   实例对象可以通过通过 s1.Name s1.sat()的形式调用类对象和类属性，而且当实例对象有重复属性时调用实例属性，有实例对象时调用类对象（存疑）
   类方法 静态方法不能调用实例属性实例方法
   

静态方法
Python 中允许定义与“类对象”无关的方法，称为“静态方法”。
“静态方法”和在模块中定义普通函数没有区别，只不过“静态方法”放到了“类的名字空 间里面”，需要通过“类调用”。

静态方法通过装饰器@staticmethod 来定义，格式如下：
@staticmethod
def 静态方法名([形参列表]) ：
函数体
要点如下：
1.@staticmethod 必须位于方法上面一行
2.调用静态方法格式：“类名.静态方法名(参数列表)”。
静态方法中访问实例属性和实例方法会导致错误
** del（） 方法(析构函数)和垃圾回收机制**
del 方法称为“析构方法”，用于实现对象被销毁时所需的操作。比如：释放对象占用的资源，例如：打开的文件资源、网络连接等。
Python 实现自动的垃圾回收，当对象没有被引用时（引用计数为 0），由垃圾回收器调用 del 方法。
我们也可以通过 del 语句删除对象，从而保证调用 del 方法。
del 对象
系统会自动提供 del 方法，一般不需要自定义析构方法。
** call() 方法和可调用对象**
定义了 call 方法的对象，称为**“可调用对象”**，即该对象可以像函数一样被调用。
s1()就是调用__call__()方法
方法没有重载
在其他语言中，可以定义多个重名的方法，只要保证方法签名唯一即可。方法签名包含 3 个部分：方法名、参数数量、参数类型。
Python 中，方法的的参数没有声明类型（调用时确定参数的类型），参数的数量也可以由可变参数控制。因此，Python 中是没有方法的重载的。定义一个方法即可有多种调用方式， 相当于实现了其他语言中的方法的重载
如果我们在类体中定义了多个重名的方法，只有最后一个方法有效。
方法的动态性
Python 是动态语言，我们可以动态的为类添加新的方法，或者动态的修改类的已有的方法。

class Person:
	def work(self):
		print("努力上班！")

def play_game(self):
	print("{0}玩游戏".format(self))

def work2(s):
print("好好工作，努力上班！")
Person.play = play_game 
Person.work = work2
p = Person() 
p.play()
p.work()
'''方法也是对象,方法名即是属性，一个指针属性，通过创建指针和更改指针所指位置来达到修改实例对象的目的'''

方法也是对象,方法名即是属性，一个指针属性，通过创建指针和更改指针所指位置来达到修改实例对象的目的
私有属性和私有方法(实现封装)
Python 对于类的成员没有严格的访问控制限制，这与其他面向对象语言有区别。关于私有属性和私有方法，有如下要点：
1.通常我们约定，两个下划线开头的属性是私有的(private)（后面不能有两个下划线）。其他为公共的(public)。
2.类内部可以访问私有属性(方法)
3.类外部不能直接访问私有属性(方法)
4.类外部可以通过**“_类名 私有属性(方法)名”**访问私有属性(方法)
私有属性 __x实际上是按照 _类名__x 这个属性来存储的
@property 装饰器
@property 可以将一个方法的调用方式变成“属性调用”。
getter setter

**属性和方法命名总结 **
· _xxx：保护成员，不能用“from module import * ”导入，只有类对象和子类对象能访 问这些成员。
· xxx：系统定义的特殊成员
· __xxx： 类中的私有成员，只有类对象自己能访问，子类对象也不能访问。（但，在类外部可以通过“对象名. _类名__xxx”这种特殊方式访问。Python 不存在严格意义的私有成员）
注：再次强调，方法和属性都遵循上面的规则。
类编码风格

1. 类名首字母大写，多个单词之间采用驼峰原则。
2. 实例名、模块名采用小写，多个单词之间采用下划线隔开。
3. 每个类，应紧跟“文档字符串”，说明这个类的作用。
4. 可以用空行组织代码，但不能滥用。在类中，使用一个空行隔开方法；模块中，使用两个空行隔开多个类。
   面向对象三大特征介绍

Python 是面向对象的语言，也支持面向对象编程的三大特性：继承、封装（隐藏）、多态。

封装（隐藏）
隐藏对象的属性和实现细节，只对外提供必要的方法。相当于将“细节封装起来”，只 对外暴露“相关调用方法”。
通过前面学习的“私有属性、私有方法”的方式，实现“封装”。Python 追求简洁的语法，没有严格的语法级别的“访问控制符”，更多的是依靠程序员自觉实现。
·继承
继承可以让子类具有父类的特性，提高了代码的重用性。
从设计上是一种增量进化，原有父类设计不变的情况下，可以增加新的功能，或者改进 已有的算法。

·多态
多态是指同一个方法调用由于对象不同会产生不同的行为。生活中这样的例子比比皆 是：同样是休息方法，人不同休息方法不同。张三休息是睡觉，李四休息是玩游戏，程序员休息是“敲几行代码”。
继承
语法格式
Python 支持多重继承，一个子类可以继承多个父类。继承的语法格式如下：
class 子类类名(父类 1[，父类 2，…])：
类体

如果在类定义中没有指定父类，则默认父类是 object 类。也就是说，object 是所有类的父类，里面定义了一些所有类共有的默认实现，比如： __new __()。
定义子类时，必须在其构造函数中调用父类的构造函数。调用格式如下：
父类名. init (self, 参数列表)
不调用就没有父类构造函数里定义的属性
子类会继承父类除构造方法之外的所有成员，父类的构造函数必须显式调用
子类调用父类私有成员或者方法要用_父类__成员名或方法
类名.mro()
输出类的继承关系
类成员的继承和重写

1. 成员继承：子类继承了父类除构造方法之外的所有成员。
2. 方法重写：子类可以重新定义父类中的方法，这样就会覆盖父类的方法，也称为“重写”
   查看类的继承层次结构
   通过类的方法 mro()或者类的属性__mro__可以输出这个类的继承层次结构。
   类.mro()
   类.mro
   object 根类
   object 类是所有类的父类，因此所有的类都有 object 类的属性和方法。
   内置函数dir()
   dir()查看对象属性
   dir(对象名）
   重写 __str __()方法
   object 有一个 str()方法，用于返回一个对于“对象的描述”，对应于内置函数 str() 经常用于 print()方法，帮助我们查看对象的信息。 str()可以重写。
   str(self) :将对象转化成一个字符串，一般用于print方法
   多重继承
   Python 支持多重继承，一个子类可以有多个“直接父类”。这样，就具备了“多个父 类”的特点。但是由于，这样会被“类的整体层次”搞的异常复杂，尽量避免使用
   MRO()
   Python 支持多继承，如果父类中有相同名字的方法，在子类没有指定父类名时，解释器将 “从左向右”按顺序搜索。
   MRO（Method Resolution Order）：方法解析顺序。
   我们可以通过 mro()方法获得 “类的层次结构”，方法解析顺序也是按照这个“类的层次结构”寻找的。
   super()获得父类定义
   常用于子类重名函数继承父类重名函数的定义
   在子类中，如果想要获得父类的方法时，我们可以通过 super()来做
   super()代表父类的定义，不是父类对象。

#A.say(self) 调用父类的 say 方法 
super().say() #通过 super()调用父类的方法

多态
多态（polymorphism）是指同一个方法调用由于对象不同可能会产生不同的行为。在现实 生活中，我们有很多例子。比如：同样是调用人的休息方法，张三的休息是睡觉，李四的休 息是玩游戏，高淇老师是敲代码。同样是吃饭的方法，中国人用筷子吃饭，英国人用刀叉吃 饭，印度人用手吃饭。
关于多态要注意以下 2 点：

1. 多态是方法的多态，属性没有多态。
2. 多态的存在有 2 个必要条件：继承、方法重写。

def animalShout(a): 
	if isinstance(a,Animal): 
		a.shout()

特殊方法和运算符重载
Python 的运算符实际上是通过调用对象的特殊方法实现的

特殊属性

dir（obj）
class.mro()
对象的浅拷贝和深拷贝
·变量的赋值操作
只是形成两个变量，实际还是指向同一个对象。
·浅拷贝
Python 拷贝一般都是浅拷贝。拷贝时，对象包含的子对象内容不拷贝。因此，源对象和拷贝对象会引用同一个子对象。
·深拷贝
使用 copy 模块的 deepcopy 函数，递归拷贝对象中包含的子对象。源对象和拷贝对象所有的子对象也不同。
import copy
m2 = copy.copy(m)
m3 = copy.deepcopy(m)
深拷贝中数字属性不会拷贝，子对象是指实例对象吗？？？
组合
“is-a”关系，我们可以使用“继承”。从而实现子类拥有的父类的方法和属性。“is-a” 关系指的是类似这样的关系：狗是动物，dog is animal。狗类就应该继承动物类。
“has-a”关系，我们可以使用“组合”，也能实现一个类拥有另一个类的方法和属性。” has-a”关系指的是这样的关系：手机拥有 CPU。 MobilePhone has a CPU。
设计模式
设计模式是面向对象语言特有的内容，是我们在面临某一类问题时候固定的做法，设计模式有很多种，比较流行的是：GOF（Goup Of Four）23 种设计模式。当然，我们没有必要全部学习，学习几个常用的即可。
对于初学者，我们学习两个最常用的模式：工厂模式和单例模式。
工厂模式
工厂模式实现了创建者和调用者的分离，使用专门的工厂类将选择实现类、创建对象进 行统一的管理和控制。
单例模式
单例模式（Singleton Pattern）的核心作用是确保一个类只有一个实例，并且提供一个访问该实例的全局访问点。
单例模式只生成一个实例对象，减少了对系统资源的开销。当一个对象的产生需要比较 多的资源，如读取配置文件、产生其他依赖对象时，可以产生一个“单例对象”，然后永久驻留内存中，从而极大的降低开销。
单例模式有多种实现的方式，我们这里推荐重写 new ()的方法。

class MySingleton:

    __obj = None           #类属性
    __init_flag = True

    def __new__(cls, *args, **kwargs):
        if cls.__obj ==None:
            cls.__obj = object.__new__(cls)

        return cls.__obj

    def __init__(self,name):
        if MySingleton.__init_flag:
            print("init.....")
            self.name = name
            MySingleton.__init_flag = False

设计模式称之为“模式”，就是一些固定的套路。我们很容易用到其他场景上