day22 面向对象基础

1.什么是面向过程

在介绍面向对象之前,要先明确面向过程
在这之前我们所写的任何代码都是面向过程的
什么是面向过程? 是一种编程思想
面对 朝向 在编写代码时,要时刻想着过程这两个字
过程指的是什么?解决问题的步骤,流程,即第一步干什么,第二步干什么
其目的是将一个复杂的问题拆分为若干个小的问题,按照步骤一一解决
也可以说 将一个复杂的问题,流程化(为其制定一个固定的实现流程),从而变得简单化

面向过程编程 这种方式带来的优缺点:
优点:复杂的问题,简单化,
缺点:由于其实现流程是固定的,一旦中间某一个步骤发生了修改,将导致整体都需要修改
    牵一发动全身
    大白话:本来有一个实现某个功能的固定的流程,后来需要在原来的基础增加新的功能,这时候得全部重新设计一遍
    扩展性差,维护性差
    例如工厂里的流水线,一旦中间某个岗位出问题,整体就无法正常运行,第一个没做完,第二个做不了

使用场景:对扩展性要求较低的软件,比如系统内核,脚本程序(运维工程师写的程序,其目的是安装一堆软件),Apache,HTTP服务器
当我们要开发的程序需要非常高的扩展性时就不能再使用该方式了,比如说,qq经常会增加新功能

2. 什么是面向对象

由于面向过程所存在的缺点,才催生了新的编程思想
面向对象:
是一种编程思想,即编写代码的方式方法
oop,是Object Oriented programming的简称,面向对象的英文缩写
将程序看做是一堆对象的集合,实现功能的方式就是对象之间的交互来实现

面向对象编程思想中最核心的概念就是 类与对象

3. 什么是对象?

一切皆对象
对象指的是,具备某些特征与技能的结合体,是实实在在存在的具体物体(描述完后我就能找到它)

4. 什么是类?

类就是类型,类别,分类
类是一个抽象概念,不是实际存在的,是根据一系列具备相同特征和技能的对象抽取得到的,比如说人类

类与对象之间的关系
类包含了一系列相同特征和技能的对象
对象是属于某各类的实例
在生活中是先有对象再根据对象的特征和技能 得到一个类型

程序员在程序中相当于上帝,需要什么就创造什么
在程序中先有类还是现有对象,先有类,才能通过类来产生对象,要先确定对象具备什么特征和什么行为才能产生对象


要将大象装进冰箱
打开冰箱
装进大象
关闭冰箱门
以上的实现方式,是面向过程的实现方式

换一种方式来实现
1. 找一个具备装大象这个技能的人来
2. 命令他去装大象

要开一家公司 挣钱
1.雇个财务
2.雇个人事主管
3.雇几个伙计
4.雇个秘书
5.给他们下达命令
以上方式不是面向过程,为什么?因为不关心财务如何算账,也不关心人事如何招人,只关心给他们下达命令
而是面向对象 财务 人事主管 几个伙计 秘书

如来要把经书传到东土大唐
如来,创造出,唐僧师徒,把任务交给他们,在完成整个取经任务的过程中,有一堆对象来参与
用面向对象的思想来完成任务,实际是在找一堆对象,让它们来完成任务

面向对象的优优缺点:
    优点:
        1. 不用考虑繁琐的实现步骤,从一个操作工,变成了老板
        2. 扩展性高了,当需要一个新功能时,搞一个具备新功能的对象,命令它去完成任务
        3. 各个对象之间的耦合度低,当一个对象出现问题,不会对其他对象产生影响
        4. 可维护性高
    
缺点:1. 面向对象的复杂度比面向过程高
     2. 无法预知执行结果/就像lol的游戏过程,一定不能把过程写死,每个英雄的行为是不固定的

使用场景:需要较高的扩展性时,(直接与用户发生交互的程序,例如qq,微信)
         对于不需要扩展的程序而言,使用面向对象反而提高了复杂度
         
为什么要使用面向对象,因为在当前情况下,很多的程序都是与用户直接打交道的,而用户的需求千变万化,所有对扩展性要求非常高

面向对象编程的本质,就是使用不同的对象来完成程序

什么是类:是一个抽象概念,不是具体存在的
         类是通过提取一系列对象的相同特征和技能得到的
         类的作用是用于标识对象与对象之间的不同,通过类就能大致了解一个对象的特征和行为
什么是对象:具备某些特征和技能的结合体,是具体存在的某个物体(一切皆对象)

在生活中,先有对象再有类
在程序中,先有类再有对象

5.如何用类

在计算机创建一个人类对象
要得到对象,必须先告诉计算机,这个对象具备什么特征和行为,所有需要先定义类

类名要按照大驼峰的方式来书写 ThisIsPerson,每个单词的首字母都大写

# import configparser
# configparser.ConfigParser() 调用类

 # 在类中描述对象的特征和行为
class Person:
    pass
    # 用变量来描述特征
    name = '李四'
    sex = 'man'
    age = '20'
# 得到对象,通过调用类,也称之为实例化 或 创建对象
obj = Person() 加括号表示调用类

# 模块名为__main__,是一个Person类的对象,内存地址(真实地址)

# 使用对象的属性(说的就是特征)
通过.语法
print(obj.name)
print(obj.age)
print(obj.sex)

class Student:
    number = '007'
    name = '盖伦'
    sex = 'male'
    age = 18
    # 学生的学校,由于每个学生的学校都是相同,所以将其放到类中
    school = 'Tsinghua'
    
    
# 创建了两个学生对象
stu1 = Student()
stu2 = Student()

print(stu1)
print(stu2) 
# 每一个对象的内存地址都是不同的,在创建对象时,计算机会申请一个新的内存空间,并将对象中的内容存进去
print(stu1.name)
print(stu2.name)
值相同
id也相同
# 由于name的值是声明在类中的,所以每个对象使用的都是同一份

为对象单独指定属性

stu1.name = '韩信'
stu2.name = '陈大炮'
print(stu1.name)
print(stu2.name)

# 每个对象的那么属性都不同,则意味需要给每个对象单独指定name

# 存放属性的位置有两个,一个是类中,还有一个是对象中
# 当每个对象的某个特征都相同时,则放到类中
# 当每个对象的某个特征都不同时,则放到对象中

# 通过__dict__可以获取一个对象中包含的内容
print(stu1.__dict__)
print(stu2.__dict__)

# 获取类中包含的内容
# print(Student.__dict__)

属性的访问顺序

class Car:
    c_type = '破鞋'
    color = 'red'
    price = 40000
    
c1 = Car()
c2 = Car()

print(c1.__dict__)
print(c2.__dict__)
print(c1.c_typr) # 有值,是取得类里的
#当对象中不存在时会到类里去找属性

c1.c_type = '法拉利'
print(c1.__dict__)
print(c2.__dict__)
print(c1.c_typr) # 有值,取得对象自己的
print(c2.c_type)
# 如果对象中存在这个属性,优先访问对象中的属性

# 查找顺序为 对象->类

# 当创建一个类的时候,产生名称空间,存储类中名称和值的绑定关系
# 当创建一个对象的时候,产生名称空间,存储对象中名称和值的绑定关系 
# 类还有另一个作用,就是作为对象的模板,所有属于同一个类的对象,都具备类中的公共属性


# 即使我们什么都不写,类中也存在一些自带的属性,是从父类得到的(继承会详细讨论)

初始化函数(同一个模块里不能有同名的类

class Student: pass

指定属性

stu1.name = '张无忌'
stu1.sex = 'male'
stu1.age = 18

stu2= Student()
stu2.name = '周芷若'
stu2.sex = 'female'
stu2.age = 78

# 定义一个函数,用于为对象设置属性
def set_sttr(obj,name,sex,age):
    obj.name = name 
    obj.sex = sex
    obj.age = age

stu3 = Student()
stu4=Student()
set_attr(stu3,'灭绝','male',88)
set_attr(stu4,'金毛狮王','female',88)

#set_attr这个函数目的是用于设置对象的属性,如果没有对象,该函数就没有存在的意义,也就是初始化函数与类应该是一个整体
# 应该将这个函数放到类中

stu3 = Student()
stu4 = Student()
Student.set_attr(stu3,'金毛狮王','male',80)
print(stu3.__dict__)
Student.set_attr(stu4,'张全蛋','male',28)
print(stu4.__dict__)

# 现在已经简化了代码,但是对象的创建与初始化步骤是分开的,通常对象一旦创建,就应该进行初始化,所有最好时将创建于初始化进行绑定


# 作为一个人,一旦出生,性别必须要指定
# 带有__开头__结尾的函数,是一些特殊的内置函数,会在某个时间点自动触发执行
class Person:
    # 初始化函数名称是固定的,该函数会在调用类时自动执行,self参数必须有,表示要进行初始化的对象,系统会自动传值
    def __init__(self):
        print('执行了__init__')
        print(self)
        self.name = '张三丰'
        self.age = 18
        
p1 = Person('张三丰',88)
print(p1.__dict__)

p2 = Person('李狗蛋',28)
print(p2.__dict__)

#init函数用于初始化对象,它会在创建对象时,自动执行,并传入调用时传递的参数.第一个参数表示要初始化的对象本身
# self(第一个)参数不需要手动传递
# self表示自己,是一个形式参数,名字可以随便取,但是不建议修改

绑定方法

把两个东西捆绑在一起
方法:就是函数
函数是专业术语,不好理解,面向对象编程思想,是要我们模仿现实生活中的抽象概念,为了方便理解把函数称之为方法
绑定方法是把对象与函数进行绑定
为什么要把方法与对象进行绑定
    调用函数就变成了调用对象的方法
对象本质上就是一种存放数据的容器

为什么要把数据与函数绑定在一起
函数适用于处理数据的代码

绑定方法就是将数据与处理数据的函数绑定在一起

将要处理的数据和处理数据的函数进行绑定

# 第一个问题传递参数,必须手动传递,很有可能传参顺序而发生错误
# 第二个问题每次处理数据 都需要手动传参数
# 第三个问题 当要处理的数据特别的多 就不能再定义为变量了 你可以使用列表出来存储要处理的数据
# 但是 每次处理 都需要先获取数据 在传递给处理数据的函数
# 所以将 要处理的数据与 处理数据的函数进行绑定







# 如何使用绑定方法


class Student:
    school = 'Beijing'
    
    def __init__(self,name,sex,age):
        self.name = name
        self.sex = sex
        self.age = age
    def learning(self):
        print('正在学习')
    def sayHi(self):
        print(self,'正在打招呼...')
# 在默认情况下,在类中定义的函数都是绑定方法,共同点是,都会将对象作为第一个参数,也就是self

stu1 = Student('一个学生','male',18)        
stu1.sayHI()        
Student.sayHI(stu1)


# 当用对象来调用类中的方法时,默认会把对象传入方法中
# 2️而用类名来调用时,则需要手动传入对象

ptint(stu1.sayHI)
# bound method Student.sayHI函数,现在把这个函数绑定给了内存地址的对象

stu2 = Student('李四','女',19)
stu2.sayHI()
print(stu2.sayHI)

# 只要拿到对象,就同时拿到了数据和处理数据的方法

绑定给类的方法

class Student:
school = 'beijing'


#绑定方法分两种,一种是绑定给对象的,一种是绑定给类的

def sayhello(self):
    print(self.name,'说你好')

@classmethod
def print_school_name(self):
    print('学校名为:%s' % school)

#绑定给类的方法,使用一个装饰器,叫classmethod,必须有一个参数,表示当前类,建议不修改    

# 这是绑定给对象的方法,可以使用对象来调用,也可以使用类名来调用
在对象调用时会自动传入对象自己
类调用时不会自动传参

# 类的绑定方法,对象和类都能调用,并且都会自动传入这个类

stu1 = Student('印度阿三,'woman',20)

stu1.print_school()

def sayhello(self):
    print(self.name,'说你好')

@classmethod
def print_school_name(cls):
    print(cls.school)
    print('学校名为:%s' % school)
    
# 如何定义对象绑定方法,以及类的绑定方法
# 在调用时的区别

# 一个方法到底应该绑定给对象还是给类
# 当要处理的数据包含在类中时,就应该绑定给类
# 当要处理的数据包含在对象中时,就应该绑定给对象



# 类的绑定方法和对象的绑定方法的相同与不同
相同点:
    1.都会自动传值
    2.都可以被类和对象调用

不同点:
    1.对象绑定方法在对象调用时,传的是对象自己,而类绑定方法自动传的是类自己
    2.第一个参数,一个cls,一个叫self

为什么要绑定:


之所以绑定,简化代码,提高效率

对象绑定方法  可以使用对象来调用 也可以使用类名来调用
# 在对象调用时会自动传入对象自己
# 类调用时不会自动传参

非绑定方法

class Teacher:
    def __init__(self,name,sex):
        self.name = name 
        self.sex = sex
        
    @staticmethod # 用于定义一个非绑定方法
    def test_func(num):
        print('test_func run!')
        print(num)
    Teacher.test_func(1)
    
    t1 = Teacher('egon','男')
    t1.test_func(1)
    
    # 什么是非绑定方法,在类中定义,即不绑定给类,也不绑定给对象
    特点:没有自动传参数的效果,类和对象都能调用,就是一个普通函数
    
    当你的这个功能不需要访问类的数据,也不需要访问对象的数据,就可以作为一个非绑定方法
    使用场景较少
    class Teacher:
    
    def __init__(self,name,sex):
        self.name = name
        self.sex = sex
    
    # @staticmethod 用于定义个非绑定方法
    @staticmethod
     def test_func(num):
        print("test_func run!")
        print(num)
    
    Teacher.test_func(1)