面向对象初识

面向对象初识

面向过程编程vs函数式编程

好处

• 减少代码的重用性
• 增强代码的可读性
• 出色的完成之前布置的所有需求

缺点

• 但凡更改或者增加一条需求,可能整个项目都随之改变
• 即 牵一发而动全身

# 面向过程式编程 

s1 = 'fjdsklafsjda'
count = 0
for i in s1:
    count += 1


l1 = [1,2,3,4]
count = 0
for i in l1:
    count += 1
    
    
# 函数式编程 
def func(s):
    count = 0
    for i in s:
        count += 1
    return count
func('fdsafdsa')
func([1,2,3,4])

函数式编程vs面向对象编程

# 函数式编程

# auth 认证相关
def login():
    pass

def regisgter():
    pass

# account 账户相关
def func1():
    pass


# 面向对象编程
class LoginHandler:  # 分类
    def login(self):
        pass

    def regisgter(self):
        pass

class Account:
    def func1(self):
        pass

    def func2(self):
        pass

面向对象编程优点

• 提高代码的 / 是一类相似功能函数的集合,使你的代码更清晰化，更合理化
• 可读性较高 (无论是开发者，还是调用者都能明确的分辨每个角色拥有的方法和属性)
• 增强了代码可
• 增强了复用性
• 代码更加规范化

提高代码的 清晰度 / 可读性 / 扩展性 / 复用性 / 规范化

对象：就是类的具体表现

• 对象就从具体的模板实例化出来（慢慢体会）/ 从模板产出的具体实例

类的结构(变量+函数)

class Human: # 类名 要具有可描述性 首字母大写 类名不宜用 _
    """
    此类主要是构建人类
    """               # 解释描述构建的对象
    mind = '有思想'  # 第一部分：静态属性/属性/静态变量/静态字段（名词）
    dic = {}   #  变量(之前) 在类外面叫变量 里面叫属性
    l1 = []   
    def work(self): # 第二部分：函数(之前)  (构造)方法 / 动态(变量)方法 /动态属性 / ( 类中定义的函数 )（动词）  包括 def __init__(self): pass
        print('人类会工作')
class 是关键字与def用法相同，定义一个类。
type是所有类的元类，object是所有类的父类
Human是此类的类名，类名使用驼峰(CamelCase)命名风格，首字母大写，私有类可用一个下划线开头。
类的结构从大方向来说就分为两部分：
静态变量。
动态方法。

从类名的角度研究类

类名操作静态属性

类名.__dict__ 查看全部内容

• 查看类中的所有内容, 只用于获取类中的全部内容 , 不能更改数据

class Human:
    mind = '123'
    dic = {}
    l1 = []
    def work(self):
        print('人类会工作')
print(Human.__dict__)  # 结果是一个dict / 全部内容
print(Human.__dict__['mind'])  # 123


Human.__dict__['mind'] = '无脑'  # 报错
print(Human.__dict__)  # 错误
#通过这种方式只能查询，不能增删改.

# 第一种方式只用户查询全部内容（一般不用单独属性查询）.

万能的点 . / 增删改查 (单个) ***

• 一般类中的属性都是通过类名 . 的方式去操作的

class Human:
    mind = '123'  
    dic = {}
    l1 = []
    def work(self): 
        print('333')
        
# 增
Human.walk = '直立行走'   
print(Human.walk)   # 直立行走

# 删
del Human.mind  
print(Human.mind) #　报错　已经删除　此类中无mind属性

# 查
print(Human.mind)   # 123

 # 改
Human.mind = '无脑' 
print(Human.mind)  # 无脑
# 通过万能的点 可以增删改查类中的单个属性

总结

• 如果想查询类中的所有内容，通过 第一种__dict__方法，如果只是操作单个属性则用万能的点的方式。

类名操作动态方法

• 前提：除了两个特殊方法：静态方法，类方法之外，一般不会通过类名操作一个类中的方法

class Human:
    mind = '有思想'  # 第一部分：静态属性 属性 静态变量 静态字段  (名词)
    dic = {}
    l1 = []
    def work(self): # 第二部分：方法 函数 动态属性 (动词 形式上的动)
        print(self)  # 111
        print('人类会工作')
    def tools(self):
        print(self)  # 222
        print('人类会使用工具')

Human.work(111)  # 人类会工作
Human.tools(222) # 人类会使用工具


下面可以做，但不用。
Human.__dict__['work'](111) 

从对象的角度研究类

对象定义

• 对象是从类中出来的，只要是类名加上（），这就是一个实例化过程，这个就会实例化一个对象 , 例 : obj

class Human:
    mind = '有思想'
    def __init__(self): # 双下方法  / 不叫构建方法
        print(666)
        print(self)  # <__main__.Human object at 0x00000191508AA828>

    def work(self): 
        print('人类会工作')

    def tools(self):
        print('人类会使用工具')
obj = Human() # 只要实例化对象，它会自动执行__init__方法 /  此过程成为实例化 一个对象 / obj
print(obj)  # <__main__.Human object at 0x00000191508AA828>
# 并且obj的地址与self的地址相同

实例化一个对象发生三件事

• 执行obiect.__new__双下方法在内存中创建一个对象空间 即 类名() 就会创建一个对象空间
• 自动执行类中的__init__方法，并将这个对象空间（内存地址）传给了__init__方法的第一个位置参数self
• 执行__init__ 方法中的代码 , 通过self给对象空间 添加 / 封装 属性

对象操作对象空间属性 / 对象.__dict__

对象查询对象中所有属性。 对象.__dict__

class Human:

    mind = '有思想'
    language = '实用语言'
    def __init__(self,name,sex,age,hobby):
        # self 和 obj 指向的是同一个内存地址同一个空间，下面就是通过self给这个对象空间封装四个属性。
        self.n = name
        self.s = sex
        self.a = age
        self.h = hobby

obj = Human('barry','男',18,'运动')
print(obj.__dict__)  # {'n': 'barry', 'h': '运动', 's': '男', 'a': 18}

对象操作对象中的单个属性 → 万能的点 .

class Human:

    mind = '有思想'
    language = '实用语言'
    def __init__(self,name,sex,age,hobby):
        # self 和 obj 指向的是同一个内存地址同一个空间，下面就是通过self给这个对象空间封装四个属性。
        self.n = name
        self.s = sex
        self.a = age
        self.h = hobby

obj = Human('barry','男',18,'运动')
obj.job = 'IT'  # 增
del obj.n  # 删
obj.s = '女' # 改
print(obj.s)  # 查
print(obj.__dict__)

对象查看 类中的属性

class Human:

    mind = '有思想'
    language = '实用语言'
    def __init__(self,name,sex,age,hobby):
        self.n = name
        self.s = sex
        self.a = age
        self.h = hobby

obj = Human('barry','男',18,'运动')
print(obj.mind) # '有思想'
print(obj.language) # '实用语言'
obj.a = 666 
print(obj.a) # 666

对象操作 类中的方法

class Human:

    mind = '有思想'
    language = '实用语言'
    def __init__(self,name,sex,age,hobby):
        self.n = name
        self.s = sex
        self.a = age
        self.h = hobby

    def work(self):
        print(self)
        print('人类会工作')

    def tools(self):
        print('人类会使用工具')

obj = Human('barry','男',18,'运动')
obj.work()
obj.tools()

self

• 就是类中方法的第一个位置参数
• 类中的方法一般都是通过对象执行的（除去类方法，静态方法外），并且对象执行这些方法都会自动将对象空间传给方法中的第一个参数self.