面向对象基础

面向过程编程

面向过程的核心是'过程'二字, 过程指的是做事情的步骤, 既先做什么再做什么

基于该编程思想编写程序, 就好比一条工厂流水线, 一种机械式的思维方式

优点: 逻辑清晰, 复杂的问题流程化, 进而简单化
缺点: 可扩展性差

面向对象编程

面向对象的核心是'对象'二字, 对象指的是特征和技能的结合体

基于该编程思想编写程序, 就好比在创造世界, 一种上帝式的思维方式

优点: 可扩展性强
缺点: 编写程序的复杂度要远高于面向过程编程

类

什么是类

从上面我们知道对象是特征和技能的结合体, 而类是一系列对象相同的特征和技能的结合体

在程序中, 先定义类, 再调用类来生成对象

如何定义类

定义类的规则:
1. 先从现实世界中, 基于一个个的对象, 抽取出类
2. 定义类
定义类的语法:

class 类名:
    # 对象相同的特征
    Kind = 'human'
    # 对象相同的技能
    def eat(self):
        pass  	

    
'''
class: 用来定义类的, class后跟的是类名
类名: 类的名字, 用来调用创造对象的
注意: 类名必须遵循驼峰命名法
'''

在定义类发生的事情:
1. 类定义时, 会产生一个空的名称空间
2. 把类内部所有的名字, 扔进类的名称空间中

注意: 类在定义阶段就已经产生好了名称空间, 执行Python文件时执行类内部的代码

class Human:
    print('from class Human')
    kind = 'human'
    def eat(self):
        pass
 
# 运行上述代码结果为: from class Human
# 因此类在定义阶段会执行类中的代码

类的基本操作

class Programmer:
    # 特征
    language = 'Python'
    # 技能
    def programming(self):
        print('programming...')
        
# 查看类的名称空间内所有名字
print(Programmer.__dict__)

# '__module__': '__main__', 'language': 'Python', 'programming': <function programmer.programming at 0x00000000029C7620>, '__dict__': <attribute '__dict__' of 'programmer' objects>, '__weakref__': <attribute '__weakref__' of 'programmer' objects>, '__doc__': None}


# 查
print(Programmer.__dict__.get('language'))  # Python
print(Programmer.language)  # Python

# 改
Programmer.language = 'Java'
print((Programmer.language)  # Java
     
# 增
Programmer.girlfriend = 'hands'
print(Programmer.girlfriend)  # hands

# 删
del Programmer.girlfriend
print(Programmer.girlfriend)  # type object 'Programmer' has no attribute 'girlfriend'

对象

实例化对象

实例化对象就是调用类来生成对象

语法: 对象 = 类名()
名称空间的产生:
1. 类的名称空间在类的定义阶段就已经产生了
2. 对象的名称空间, 在实例化对象的时候产生(调用类的时候)

class Programmer:
   # 特征
   language = 'Python'
   # 技能
   def programming(self):
       print('programming...')
       
pgmmer1 = Programmer()
pgmmer2 = Programmer()
pgmmer3 = Programmer()

print(pgmmer1.language)  # Pyhton

pgmmer1.programming()  # programming...

对象添加特有属性

问题: 我们通过实例化生成的对象特征和技能全都一样

解决: 在类的内部定义__init__函数, __init__函数可以为对象初始化某些属性, 在类被调用时, 自动触发该函数

class Programmer:
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
  
    language = 'Python'
    
    def programming(self):
        print('programming...')
        
        
 # 我们再__init__函数里设置了三个参数, 因此我们在调用类时就必须传入三个参数       
pgmmer1 = Programmer('A', '10', 'male')
pgmmer2 = Programmer('B', '20', 'male')
pgmmer3 = Programmer('C', '30', 'male')


print(pgmmer1.name)  # A
print(pgmmer2.name)	 # B

调用类发生的事情:
1. 首先会产生一个空的对象名称空间
2. 会自动触发__init__函数
3. 把对象本身以及括号内参数一并传给__init__函数
4. 运行__init__函数并把产生的名称丢入该对象的名称空间
总结: 调用类会产生一个对象, 调用类的过程叫做类的实例化, 产生的对象称之为类的一个实例

对象与类的查找顺序

对象与类的查找顺序:
1. 对象.属性, 若对象本身有, 则优先查找对象自己的
2. 若对象本身没有, 则去类里面找, 若类没有, 则报错

class Programmer:
    def __init__(self,language):
        self.language = language

    language = 'Python'
    
    def programming(self):
        print('programming...')
        
        
pgmmer = Programmer('Java')

print(pgmmer.language)  # Java

对象的绑定方法

对于类内部的函数, 其主要是给对象使用的:
1. 当函数由类直接调用时, 该函数只是一个普通的函数, 因此函数需要几个参数就得传几个参数
2. 当由对象调用称之为对象的绑定方法, 不同对象调用该绑定方法, 则会把不同的对象传入该绑定方法中
3. 二者调用函数实现的功能是一样的
对象的绑定方法, 是由对象来调用的, 其特殊之处就是会把对象当做第一个参数传入该方法中

class Programmer:
    # 特征
    language = 'Python'
    # 技能
    def programming(self):
        print('programming...')
        
pgmmer = Programmer()

# 由类来调用时, 需要传一个参数给self
Programmer.programming(1)  # programming...

# 由对象调用绑定方法时, 默认把对象本身传入该方法, 因此不用再传入多余的参数
pgmmer.programming()   # programming...