面向对象

面向对象与面向过程分析

清晰知道操作的功能，但不明确操作的具体对象
print(len('123'))
清晰最大操作的对象，但不明确具体的操作方法
print('123'.__len__())

面向对象

Python语言是一种面向对象的语言
Python用面向过程和面向对象两种方式解决问题
面向对象的核心体现是将数据和处理数据的程序封装到对象中
面向过程编程：核心是“过程”两字，过程指的是解决问题的步骤，即先干什么再干什么
基于该思想编写程序就好比在编写一条流水线，将复杂的问题，流程简单化

面向对象编程：核心是“对象”两字，对象指得是特征与技能的结合体，，编程的复杂度高于面向过程，拓展性强
基于该思想编写程序就好比创造一个世界，你就是这个世界的上帝，是一种上帝的思维方式

变量 | 函数 => 属性 | 方法：前者直接使用，通过所属者.语法调用

函数与方法：都是解决问题的功能
函数是通过函数名直接调用
方法是通过附属者.语法来访问变量值

变量与属性
变量是通过变量名访问变量值
属性是通过附属者.语法来访问变量值

名称空间操作

所有能产生名称空间对应的对象（存放地址的变量）有__dict__值
__dict__指向的就是附属对象的名称空间
-- 文件 | 包(__init__.py文件) | 函数 | 类
-- 可以为__dict__属性添加值，简化为.语法，也可以对__dict__整体赋值一个字典
import re
print(re.__dict__) ===>re 的地址

re.__dict__['name'] = 're模块'
print(re.__dict__['name']) ====》're模块'

re.__dict__['action'] = lambda x: x
print(re.__dict__['action'](1000)) =====》1000


def fn():
pass
print(fn.__dict__) =====》{}

fn.name = 'fn函数'
print(fn.name) ====》'fn函数'

def test():
print("可以成为fn功能的函数")
fn.action = test
fn.action() =====》'可以成为fn功能的函数'

 

类与对象的概念，

-- 类是抽象的，不是真实存在：具有相同特征(属性)和行为(方法)个体的集合的抽象
-- 对象具象的，是真实存在的：具有特征与行为的实际个体(类的实际体现：实例化)

区别：两个人同时思考一个名字，想到的一定是同一个物体，就一定是对象，反之就是类

 

类的对象语法

类的声明：
class 类名： #class是定义类的语法的关键字
代码块(一堆属性与方法)
对象名 = 类名() #对象的实例化

重点：类一旦被加载(随着所属文件的加载就加载)，就会进入类的内部执行类中的所有代码
类会随所属文件加载而加载(执行内部所有代码)，形成类的名称空间

每个实例化出来的对象及类都有自己的名称空间，名称空间也是各自独立的，所以类与对象都能额外添加属性(变量)和方法(函数)
类与对象都可以通过.语法来拓展新功能
提前在类中属性的属性与方法，在对象一产生就可以使用这些属性和方法

 

对象查找属性的顺序

class People:
identify = '人类' # 类自带(不同在外界额外添加)的属性与方法
def sleep(self):
print('睡觉')

p1 = People() ====》对象的实例化
p2 = People()

p1.identify = '新人类'
print(p1.identify) # 访问自己的 ====》'新人类'
p1.__dict__.clear() # 删除自己的类
print(p1.identify) # 访问类的 ====>'人类'

print(p2.identify) # p2没有自己的，访问类的 ====>'人类'

重点：对象查找属性的顺序：先找自身的，如果没有找类的(只有访问权没有修改权)

class Student:
def __init__(self, stu_name, sex):
self.name = stu_name
self.sex = sex # 通常建议参数名与新增的属性名同名

stu = Student('Bob', 'male') # 实例化对象 self = stu
print(stu.name, stu.sex) ======>"Bob male"

__init__方法会在实例化对象时被调用
会为实例化的对象形成空的名称空间
就是一个方法，可以被传参，在 类名(实参) 这种方式下调用并传参 __init__(self, 形参)
第一个self就是要产生的当前对象
重点：在方法内部，形参拿到了实参值，利用self.属性名=形参=实参值，对对象的名称空间添加属性

 

类中方法的第一个默认参数：对象方法

class A:
def test(self, num): # 对象方法
pass
a = A()

调用方法
a.test(10) # 二级优化
A.test(a, 10) # 一级优化
A.__dict__['test'](a, 10) # 实现原理

总结：对象a传递给self，数字10传递给num
重点：方法的第一个参数一定是调用该方法的对象

类中@classmethod修饰的方法：类方法
class Tool:
@classmethod
def add(cls, n1, n2): # 统一类与对象都可以调用类方法，一定有默认传入第一个参数
return n1 + n2

建议
Tool.add(10, 20) # 默认第一个传入自身 - Tool

不建议
tool = Tool()
tool.add(100, 200) # 默认第一个传入自身所属类 - tool.__class__

 

属性与方法的总结

class OldBoy:
属于类的属性
name = '老男孩'

属于对象的属性
def __init__(self, name):
self.name = name

属于类的方法
需求：获取机构的名字
@classmethod
def get_class_name(cls):
return cls.name

属于对象的方法
需求：获取校区的名字
def get_school_name(self):
return self.name

先创建校区
shanghai = OldBoy('上海校区')
shenzhen = OldBoy('深圳校区')

类方法的使用
建议使用类调用
print(OldBoy.get_class_name()) #====>'老男孩'
类方法拿对象调用并没有多少新增的意义，不建议拿对象调用
print(shanghai.get_class_name()) #====>'老男孩'
print(shenzhen.get_class_name()) #====>'老男孩'
对象方法的使用
类调用对象方法，必须把要操作的对象手动传入，不建议使用
print(OldBoy.get_school_name(shanghai)) ====>'上海校区'
print(OldBoy.get_school_name(shenzhen)) ====>'深圳校区'
对象调用对象方法，默认将自身传入，建议使用
print(shanghai.get_school_name()) #====>'上海校区'
print(shenzhen.get_school_name()) #====>'深圳校区'
重点建议：类方法的使用，类调用类的方法
对象方法的使用，对象调用对象方法
1）类的名称空间：直接写在类中
2) 对象的名称空间：写在__init__方法中，通过self.属性形成名称空间中的名字
3) 类的方法：在类中用@classmethod装饰的方法，第一个参数一定接收类，建议只拿类来调用
4) 对象方法：在类中定义的普通方法，第一个参数一定接收对象，建议只拿对象调用