python_面向对象

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

什么是面向对象？

-- 一种主流编程范式，编程思维框架，世界主流两个方向，面向对象和面向过程。

--  面向是把关注点集中一个具体东西，比如看向手机，也叫面向手机，手机就是一个对象，我们

把手机的属性，比如什么牌子，长多少，宽多少，这些都是属性，然后可以打电话，刷微博，

和微信好友抢红包，这些都是功能，也称之为方法

-- 本质上是分类，所有的手机都具有以上属性，不妨把其抽象出一个手机类，然后通过这个类

具体出各种各样的手机

形式：

class 类

-- 一个类，也单独占用一个内存

object对象

-- 实例，每生成一个对象开辟一个新的内存，

object = 类名(参数)

特性：

封装

-- 类中数据与方法，对类外透明，类外无法访问其中       内部数据+内部方法

-- 实际上是透明细节，留下更应该关注的点，而不去深化细节

继承

-- 方法+属性 全部继承父类，子类可以 重新修改+新增

多态

-- 一个接口，多种实现。调用父类方法，子类都执行各自工作

语法：

属性：

私有：       -- 只在类中能访问，类外不可访问

-- __属性名                        --声明一个私有属性

-- 通过def一个方法，通过object.方法进行访问

方法

私有：    -- def __函数名()         --定义一个私有方法

构造函数

-- 初始化参数，让类中的方法能够调用

def __init__(self,参数)

self.参数 = 参数

析构函数：

-- 实例释放、销毁时候，执行收尾工作

-- 关闭数据库连接和临时文件

def __del__(self):

-- 直到实例释放、销毁时候执行，此执行体

类变量

-- 定义在类下，和def函数同级，不需要实例化就可以直接通过“类名.变量名 ”进行调用

-- 新增对象的类变量改了，对于另外一个新增对象的类变量还是原来类的，

相当于每个对象，都继承原类属性，自己开了新的内存存储自己

-- 大家共用的属性，节省开销                 -- 国籍

-- 对于列表 全部共享

实例变量

-- 参数作用域于实例本身

-- 可以通过类外   “object.属性 = 值”         -- 新增初始化参数或者修改初始化参数

-- 类变量如果是列表，任何修改都会共享

类变量和实例变量的优先级？

-- 先找实例变量，再往上找类变量，最后找全局变量

面向对象编程有什么好处？

-- 降低重复写代码

-- 降低耦合度，程序要经常修改，不会改一处而动全身

面向对象的框架是什么？

class 类名(object):

def __init__(self,参数):       # 可设置默认参数，self本质上是object_n，构造函数

self.参数 = 参数         # 实例变量（静态属性）

def 作用(self.参数):            # 调用变量是类中的self.参数，类的方法，功能（动态属性）

sdlf.参数.一顿犀利古怪操作

object_n = 类名(传入参数)     # 本质上是   类名(object_n, object_n.参数 = 参数)

-- object_n 类的实例

__init__的本质是什么？

def __init__(self,参数):

self.参数 = 参数

相当于类外

object = 类名()                   # 实例化一个参数

obiect.参数 = 值               # 可以进行新增或者赋值

在类外删除一个属性

del 参数

什么是python的回收机制？

-- python内部有个循环，只要变量存在，就认为此变量还在用，

不管你认为这个整个程序只用一次，或者多年运行才调用一次，

python不会自作聪明的释放，如果想要释放，就必须手动 del 声明

继承主要作用是什么？

-- 节省代码

-- 继承的本质是把父类的属性和方法全部拷贝到子类中，

子类通过重构增加或修改属性和方法，所有的继承全部是子类的

子类继承父类有什么特性？

class 子类(父类)

-- 全部继承父类的方法和属性，可以覆盖父类方法重新定义，重构

-- 如果不想覆盖，可以子类中通过“父类.方法(self) ”进行父类方法调用

如何子类调用父类析构函数？

def __init__(self,子类参数):                                   # 重构析构

父类.__init__(self,父类参数)                           # 调用父类析构

self.父类没有的属性 = 父类没有的属性         # 析构自己拥有的属性

-- 子类参数和父类参数相同时候才调用父类析构函数

-- 还有个高级方法调用父类的析构函数

--super(子类名,self).__init__(父类参数)

等价于

--父类.__init__(self,父类参数)

方便在于，父类析构方法改变了，子类不需要进行修改

什么是经典类和新式类？

-- 唯一形式区别 新式类需要继承object，super是新式类的写法，object是基类，所有类都需要继承object

--主要区别在于多继承：

-- 经典类对于多继承搜索方式是从左到右，深度优先，py2

-- 新式类对于多继承搜索方式是从左到右，广度优先，py3

-- 通过 类名.__mro__查看搜索路径，对于相同的属性方法搜索路径，不是都走，而是找的一个就停下来了

-- 新式类中可以把一个实例对象当做参数传入另外一个实例对象中，相当于另外一个实例对象继承了参数对象的类

为什么要多继承？

继承额外的功能

什么是多态？

一种接口，多种实现，实现对接口的重用

一般调用实例的方法是什么？

object_1 = 类名1(参数n)

object_1.方法()

object_2 = 类名2(参数m)

object_2.方法()

思考？

-- 能不能实现通过      类名.方法()    进行实现方法调用？

-- 在类中添加

@staticmethod                         # 静态方法

def 接口名(obj):                        # 定义接口

obj.类方法()                       # 调用方法

-- 可以通过 obj = 类名(参数)

类名. 接口名(obj)           # 通过接口调用类方法

-- 本质上是把实例对象当做参数传入进去，所有才能调用类属性和方法

什么是@staticmethod静态方法？

-- 在类中定义一个静态方法，被装饰的类函数，类函数不再是类的方法，

变成一个函数，不能在此函数中调用任何类属性和方法，名义上是属于类，实际跟类没什么关系

-- 可以把实例对象当做参数传入进去，所有才能调用类属性和方法

什么是@classmethod类方法？

-- 被装饰的类函数，函数只能访问类变量，不能访问实例变量，（当类变量和实例变量都存在时候，强制读取类变量）

什么是@property       属性方法？

-- 把一个方法变成一个静态属性，无法进行传参

obj = 类名(参数)

obj.静态属性名                               # 后面不需要加 “()”

-- 如果想要传入参数，必须在下面定义同一个同名函数，写入参数，前面加 @静态属性名.setter

- 通过 obj.静态属性名 = 参数

@静态属性名.setter

def 静态属性名(self,参数)：

self.__参数 = 参数

obj.静态属性名 = 参数                    # 进行传参

--如何删除？

del obj.属性                                      # 删除obj的属性

@静态属性名.deleter

def 静态属性名(self):

del 静态属性名

静态属性和方法有什么用？

1. 连接API
2. 解析结果
3. 返回用户

--用户不关心上面的实现动作过程，用户只需要调用这个属性，

把过程封装在这个属性中，对用户来说，就是一步操作

类中有哪些特殊方法？

对类和实例对象

-- .__doc__                        --查看类的注释

--.__module__                   --当前操作的对象在哪个模块

--.__class__                       --当前操作的对象类是什么

--.__dict__

--通过类名.__dict__调用，打印类中所有属性，不包括实例属性，通过实例对象调用，打印实例属性

在类中定义，类外调用

-- __str__(self)                   --给实例对象显示一个属性名，便于区分

def __str__(self):

return “<输出模版>” self.实例属性名

# 返回self.实例属性名，给该实例对象

-- __call__                   --在类中定义

def __call__(self,*args,**kwargs):

函数体

类外 “实例对象()”<=>”object()”或者 类名()()     进行调用__call__函数

类的起源于type类

还有哪些接口？

__getitem__(self,参数)      --通过     对象[传入参数]     进行传值并且调用__getitem__方法

__setitem__(self,key,value)             -- 通过 对象[key] = value  进行传值，并调用此方法

__delitem__(self,参数)                           -- del 对象[参数]  进行传值，并调用此方法