python之面向对象初识

一、面向对象之初识

面向过程编程vs函数式编程vs面向对象编程
- 函数式编程较之面向过程编程：1.减少了代码的重用性；2.增强了代码的可读性
- 面型对象编程交织函数式编程：1.面向对象编程是一类相似功能函数的集合体，可以使代码更清晰化，合理化。2.面向对象要拥有上帝视角看问题，类就是一个公共的模板，对象就是从具体的模板实例化出来的。
1. 什么是类，什么是对象
  
  类：具有相同属性和功能的一类事物
  
  对象：类的具体表现
2. 类的结构
```
class Student:
    """
    此类为构建学生
    """
    daily = '学习'	# 第一部分：静态属性 属性 静态变量 静态字段
    examination = '考试'
    def work(self):		# 第二部分：方法 函数 动态属性
        print('每天上课')
    def homework(self):
        print('家庭作业')
```
  class 是关键字与def用法相同，定义一个类。
  Student是此类的类名，类名使用驼峰(CamelCase)命名风格，首字母大写，私有类可用一个下划线开头。
  类的结构从大方向来说就分为两部分：
  静态变量。
  动态方法。

从类名的角度研究类

类名操作静态属性

第一种，查看类中的所有内容：类名.__dict__方式

print(Student.__dict__)
# {'__module__': '__main__', '__doc__': '
    此类为构建学生
    ', 'daily': '学习', 'examination': '考试', 'work': <function Student.work at 0x0000019191C9BBF8>, 'homework': <function Student.homework at 0x0000019191C9BC80>, '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>}

第二种，万能的.点

print(Student.daily)	# 查 学习
Student.examination = '不考试'
print(Student.examination)	# 改 不考试
Student.cloth = '校服'	# 增
del Student.daily	# 删
print(Student.__dict__)
# {'__module__': '__main__', '__doc__': '
    此类为构建学生
    ', 'examination': '不考试', 'work': <function Student.work at 0x000001DA1410BBF8>, 'homework': <function Student.homework at 0x000001DA1410BC80>, '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>, 'cloth': '校服'}

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

类名操作动态方法

除了两个特殊方法：静态方法，类方法之外，一般不会通过类名操作一个类中的方法。
```
Student.work(11)	# 每天上课
Student.__dict__['work'](11)	# 可以作，但没必要
```

从对象角度研究类

什么是对象

对象是从类中出来的，只要是类名加上括号()，这就是一个实例化过程，就会实例化一个对象
```
class Student:
    daily = '学习'
    examination = '考试'
    def __init__(self):
        print(self)
        print(666)
    def work(self,n):
        self.color = n
        print(f'{self.n}每天上课')
    def homework(self):
        print('家庭作业')
obj = Student()
# <__main__.Student object at 0x0000022B93988E80>
# 666
# <__main__.Student object at 0x0000022B93988E80>
```
从上看出，实例化一个对象总共发生了三件事：
- 在内存中开辟一个对象空间
- 自动执行类中的__init__方法，并将这个对象空间（内存地址）传给了__init__方法的第一个位置参数self。
- 在__init__方法中通过self给对空间添加了属性
```
class Student:
    daily = '学习'
    examination = '考试'
    def __init__(self,name,sex):
        self.n = name
        self.s = sex
obj = Student('小黑','男')
print(obj.__dict__)
# {'n': '小黑', 's': '男'}
```
什么是self：self其实就是类中方法（函数）的第一个位置参数，只不过解释器会自动将调用这个函数的对象传给self。所以咱们把类中的方法的第一个参数约定俗成设置成self, 代表这个就是对象。

对象操作对象空间属性

对象查询对象中的所有属性，对象.__dict__
```
print(obj.__dict__)
# {'n': '小黑', 's': '男'}
```

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

class Student:
    daily = '学习'
    examination = '考试'
    def __init__(self,name,sex):
        self.n = name
        self.s = sex
obj = Student('小黑','男')
print(obj.n)    # 查
obj.color = '绿色'    # 增
del obj.s
obj.n = '哒哒哒'
print(obj.__dict__)
# 小黑
# {'n': '哒哒哒', 'color': '绿色'}

对象查看类中的属性

只能查询，不能增删改

class Student:
    daily = '学习'
    examination = '考试'
    def __init__(self,name,sex):
        self.n = name
        self.s = sex
obj = Student('小黑','男')
print(obj.daily)	# 学习

对象操作类中的方法

class Student:
    daily = '学习'
    examination = '考试'
    def __init__(self):
        self.n = '小黑'
        self.sex = '随便'
    def work(self,n):
        self.color = n
        print(f'{self.n}每天上课')
    def homework(self):
        print('家庭作业')
obj = Student()
obj.work('绿色')	# 可在外部给obj空间添加属性
print(obj.__dict__)
# 小黑每天上课
# {'n': '小黑', 'sex': '随便', 'color': '绿色'}

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

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

class Student:
    daily = '学习'
    examination = '考试'
    def __init__(self,name,sex):
        self.n = name
        self.s = sex
obj = Student('小黑','男')
obj1 = Student('皮皮寒','男')
print(obj,obj1)
print(obj.__dict__)
print(obj1.__dict__)
# <__main__.Student object at 0x000001850A988E80> <__main__.Student object at 0x000001850A98F320>
# {'n': '小黑', 's': '男'}
# {'n': '皮皮寒', 's': '男'}