面向对象式编程: 上帝视角

一, 面向对象初识

1. 回顾面向过程编程VS函数式编程

   • 函数式编程的优点

   • 减少代码的重用性

   • 增强代码的可读性

2. 函数式编程VS面向对象编程

   • 面向对象编程的优点
   • 是一类相似功能函数的集合,使代码更清晰化,更合理化
   • 面向对象,要拥有上帝的视角看问题,类其实就是一个公共模板,对象就从具体的模板实例化出来

3. 类的结构

   class Human:
       """
       此类主要是构建人类
       """
       mind = '有思想'  # 第一部分：静态属性 属性 静态变量 静态字段
       dic = {}
       l1 = []
       def work(self): # 第二部分：方法 函数 动态属性
           print('人类会工作')
   # class 是关键字与def用法相同，定义一个类。
   # Human是此类的类名，类名使用驼峰(CamelCase)命名风格，首字母大写，私有类可用一个下划线开头。
   # 类的结构从大方向来说就分为两部分：
   # 静态变量
   # 动态方法

二, 从类名的角度研究类

1. 类名操作静态属性

   # 第一种:查看类中的所有内容: 类名.__dict__方式
   class Human:
       mind = '有思想' 
       dic = {}
       l1 = []
       def work(self): 
           print('人类会工作')
   
   print(Human.__dict__) # 查看所有内容
   print(Human.__dict__['mind']) 
   Human.__dict__['mind'] = '无脑' # 报错
   print(Human.__dict__)  
   # 通过这种方式只能查询，不能增删改.一般只用于查询全部内容(一般不用单独属性查询)
   -------------------------------------------------------
   # 第二种: 万能的点
   print(Human.mind)  # 查
   Human.mind = '无脑'  # 改
   print(Human.mind)
   del Human.mind  # 删
   Human.walk = '直立行走'
   print(Human.walk)
   # 通过万能的点 可以增删改查类中的单个属性

   总结: 如果想查询类中的所有内容,通过类名.__dict__方法,如果只是操作单个属性则用万能的点的方式

2. 类名操作动态方法

   # 除了两个特殊的方法: 静态方法,类方法之外,一般不会通过类名操作一个类中的方法
   class Human:
       mind = '有思想' 
       dic = {}
       l1 = []
       def work(self): 
           print('人类会工作')
       def tools(self):
        print('人类会使用工具')
   
   Human.work(111)
   Human.tools(111)
   # 下面可以做，但不用。
   Human.__dict__['work'](111)

三, 从对象的角度研究类

1. 什么是对象?

   对象是从类中出来的,只要是类名加上(),这就是一个实例化过程,这个就会实例化一个对象

   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__方法
   print(obj)  # <__main__.Human object at 0x00000191508AA828>
   # 并且obj的地址与self的地址相同

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

   1. 在内存开辟一个对象空间
   2. 自动执行类中的__init__方法,并将这个对象空间(内存地址)传给了__init__方法的第一个位置参数self
   3. 在__init__方法中通过self给对象空间封装属性

   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,'运动')

2. 对象操作对象空间属性

   # 对象查询对象中所有属性: 对象.__dict__
   print(obj.__dict__)  # {'n': 'barry', 'h': '运动', 's': '男', 'a': 18}
   
   # 对象操作对象中的单个属性: 万能的点.
   obj.job = 'IT'  # 增
   del obj.n  # 删
   obj.s = '女' # 改
   print(obj.s)  # 查
   print(obj.__dict__)

3. 对象查看类中的属性

   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)

4. 对象操作类中的方法

   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

5. self是什么

   self其实就是类中方法(函数)的第一个位子参数,只不过解释器会自动将调用这个函数的对象传给self,所以咱们把类中的方法的第一个参数约定俗成设置成self,代表这个就是对象

6. 一个类可以实例化多个对象

   obj1= Human('小胖','男',20,'美女')
   obj2= Human('小马','女',18,'帅哥')
   print(obj1,obj2)
   print(obj1.__dict__)
   print(obj2.__dict__)

面向对象式编程: 上帝视角

原文：https://www.cnblogs.com/zyyhxbs/p/11138743.html