面向对象基础

一. 初始面向对象
二. 面向对象的结构
三. 类名操作类
四. 实例化对象
五. 对象操作类

面向过程与函数对比

函数与面向对象的区别
面向对象的优点

1. 是一类相似功能函数的集合体
2. 逻辑更加清晰和规范

类名首字母要大写

类，对象
类，具有相似功能与技能的一类事物
对象：类的具体表现

# 类是一个公共模板，对象就从具体的模板实例化出来
# 类里面两个部分：
#   变量
#   函数(方法)

class Human:
    """
    此类主要是构建人类
    """
    mind = "有思想"  # 静态属性
    language = "实用语言"
    l = []
    d = {}

    def __init__(self, name, sex, age, hobby):  # 方法，动态属性
        # print(self)
        # print(666)
        # print(self, name, sex, age, hobby)
        self.n = name
        self.s = sex
        self.a = age
        self.h = hobby


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

    def tools(self):
        self.color = "blue"  # 给对象空间封装一个变量
        print("人类都会使用工具")

# 类名
# 类名操作类中的属性
#   第一种：类名.__dict__方式
print(Human.__dict__)
# {'__module__': '__main__', '__doc__': '
    此类主要是构建人类
    ', 'mind': '有思想',
# 'language': '实用语言', '__init__': <function Human.__init__ at 0x0000025D75A2AEA0>,
# 'work': <function Human.work at 0x0000025D75A2AF28>, 'tools':
# <function Human.tools at 0x0000025D75A32048>,
# '__dict__': <attribute '__dict__' of 'Human' objects>,
# '__weakref__': <attribute '__weakref__' of 'Human' objects>}
print(Human.__dict__["mind"])  # 有思想
# __dict__不能进行增删改操作
# Human.__dict__["mind"] = "无思想"

#   第二种：万能的.，可以增删改类中的静态属性
print(Human.mind)  # 有思想
# 改
Human.mind = "无思想"
# 增
Human.x = "另一个静态属性"
print(Human.x)  # 另一个静态属性
# 删
del Human.x
# print(Human.x)  # 报错
print(Human.l)  # []

# 类名操作类中的方法（一般只操作静态方法，类方法）
#   类名.方法名(参数)
# 比如下面这样不建议
Human.work(111)  # 人类会工作
print(Human.__dict__["work"](111)) # 人类会工作

# 对象
# 只要是 类名() 就是一个实例化过程，就会产生一个对象空间

# obj = Human()  # 666

# 实例化一个对象时发生了以下事情：
#   1. 产生一个空的对象空间
#   2. 自动执行类中的 __init__ 方法，并将空的对象空间传给 self
#   3. 在 __init__ 中通过 self 给这个空间添加属性，并且返回给对象，后面参数一次传入
# print(obj)  # <__main__.Human object at 0x000001F1CDB189E8>, 与上面的 print(self) 内存地址一样
obj = Human("小春", "男", 18, "睡觉")  # 看到等号，先指向右边内容
print(obj)  # <__main__.Human object at 0x00000212E9448A58>
print(obj.__dict__)
# {'n': '小春', 's': '男', 'a': 18, 'h': '睡觉'}

# 对象操作对象空间的属性
#   1. obj.__init__ 查询对象中所有的属性
#   2. 通过万能的. 的方式操作对象中的单个属性

obj.job = "IT"
print(obj.__dict__)  # 增
# {'n': '小春', 's': '男', 'a': 18, 'h': '睡觉', 'job': 'IT'}
del obj.n  # 删
print(obj.__dict__)  # {'s': '男', 'a': 18, 'h': '睡觉', 'job': 'IT'}
obj.s = "女"  # 改
print(obj.__dict__)  # {'s': '女', 'a': 18, 'h': '睡觉', 'job': 'IT'}
print(obj.s)  # 女

#   3. 对象可以查询类的属性(不能增删改)
print(obj.mind)  # 无思想
obj.a = 666
print(obj.a)  # 666

# 以下两个打印结果可以得知, obj这个实例对象并没有改变类Human的静态属性，只是给自己添加了一个 mind 属性
obj.mind = "新思想" 
print(obj.__dict__)
print(Human.__dict__)

#   4. 对象可以执行类中的方法
#       对象执行类中的所有方法(除了三个特殊方法),Python解释器都会将对象空间主动传给方法的第一个参数
#       使用默认的 self，便于统一，self 接收的就是对象空间
#       self 和 obj 在内存中指向同一个地址
print(obj)  # <__main__.Human object at 0x00000231328F8AC8>
obj.work()  # 人类会工作
print(obj.__init__)  # <bound method Human.__init__ of <__main__.Human object at 0x000001C703648908>>
obj.tools()
print(obj.__init__)  # <bound method Human.__init__ of <__main__.Human object at 0x000001C703648908>>

# 多个对象
person01 = Human("小春", "男", 20, "睡觉")
person02 = Human("小白", "女", 18, "逛街")
print(person01)
print(person02)
# <__main__.Human object at 0x00000254692F8AC8>
# <__main__.Human object at 0x00000254692F8B00>
print(person01.__dict__)  # {'n': '小春', 's': '男', 'a': 20, 'h': '睡觉'}
print(person02.__dict__)  # {'n': '小白', 's': '女', 'a': 18, 'h': '逛街'}