第五章 python面向对象

一.理解面向对象

1、面向过程和面向对象对比：
面向过程编程最易被初学者接受，往往用一长段代码来实现指定功能；随着时间的推移，开始使用了函数式编程，增强代码的复用性和可读性，就变成了这样；面向对象编程则是另一种解决问题的思路；
python中“面向过程（函数式）” 和“面向对象”编程一样重要。
面向对象：对整个代码逻辑（包含数据、函数、逻辑）进行包装（专业术语：封装），最大程度提升代
码复用，减少编码量

二.类和对象

1、 类和对象的概念
①类：类是对一系列具有相同特征和行为的事物的统称，是一个抽象的概念，不是真实存在的事物。类就相当于制造飞机的图纸，就是一个模板，是负责创建对象的
注：特征即是属性；行为即是方法

②对象：
1）对象是由类创造出来的一个具体存在的，可以直接使用的
2）由哪一个类创建出来的对象，就拥有在哪一个类中定义的：属性和方法；对象就相当于用图纸制造的飞机

2、类和对象的关系
类是模板，对象是根据类这个模板创建出来的，应该先有类，再有对象；类只有一个，而对象可以有很多个；不同的对象之间属性可能会各不相同

3、类的设计
在使用面向对象开发前，应该首先分析需求，确定一下，程序中需要包含哪些类
在程序开发中，要设计一个类，通常要满足以下三个要素
1）.类的名称： 这类事物的名字，满足大驼峰命名法
2）.类的属性： 这类事物具有什么样的特征
3）.类的方法：这类事物具有什么样的行为

4、面向对象实现方法
①语法：类名要满足标识符命名规则，同时遵循大驼峰命名习惯

class 类名(): 
      代码

class Plane(): 
  def fly(self): 
      print('我会飞')

②创建对象
语法：对象又名实例；创建对象的过程叫实例化

#对象名 = 类名()
#创建对象 
plane1 = Plane() 
print(plane1) 
plane1.fly()

③ self
self:指的是调用该函数的对象

#1.定义一个类 
class plane(): 
 def fly(self): 
  print('我会飞') 
  print(self) 
#2 实例化两个对象 
redplane = plane() 
print(redplane) 
blueplane = plane() 
print(blueplane) 
#3.调用实例方法 
redplane.fly() 
blueplane.fly()

④魔法方法：在python中， xx() 的函数叫做魔法方法，指的是具有特殊功能的函数
init 方法：
对象被初始化时，会被自动调用,专门定义一个对象具有哪些属性的方法；个人理解：每个对象定义属性值时被这个方法初始化定义，最后给下一层方法函数调用
str 方法：
返回对象的描述信息，print函数输出使用，不加 str 正常返回对象指向的内存地址；个人理解：
打印项统一直接显示各个对象的信息,

# 类 ：（模板）  人      实例方法 （行为） ：吃饭 、睡觉        属性：姓名  （特征）

class Person:

    def __init__(self,name):
        # 特殊函数 名字不能改，初始化函数
        # 实例化对象时，默认调用该方法，对象属性赋值
        # 什么时候写该函数？ 每一个对象在创建的时候需要具备一定的属性 -- name
        self.name=name # =号前name实例属性， =后是参数

    def eat(self):# self代表对象(实例)的本身
        print(f'{self.name}在吃饭')
    def sleep(self):
        print(f'{self.name}在睡觉')


    def __str__(self):# 该函数默认就有,打印项直接显示各个对象的信息,可以重写方法 -- 不常用
        return (f'{self.name}在吃饭，{self.name}在睡觉')

# 张三在吃饭
persona = Person(name='张三')
persona.eat()
# 李四在睡觉
personb = Person(name='李四')
personb.sleep()

# 王五在吃饭、睡觉
personc = Person(name='王五')
print(personc)

三.添加和获取对象属性

1、类外面添加对象属性
语法
体验

三.类属性和实例属性

1、类属性
①设置和访问类属性
类属性：就是类对象所拥有的属性，它被该类的所有实例对象所共有
类属性：可以使用类对象或实例对象访问
类属性的优点：
类的实例，记录的某项数据 始终保持一致时，则定义类属性；实例属性-要求每个对象为其单独开辟一份内存空间 来记录数据，而类属性为全类所共有，仅占用一份内存，更加节省内存空间。

class Dog(object):
#类属性 
 tooth = 10
#实例对象调用类属性
wangcai =Dog() 
xiaohei = Dog() 
print(wangcai.tooth) #10 
print(xiaohei.tooth) # 10

#类直接调用类属性
print(Dog.tooth) # 10 

2、修改类属性
定义：写在类中，在函数外面的变量就叫类属性，类属性可以直接通过类调用，可以修改
注：类属性只能通过类对象修改，不能通过实例对象修改，如果通过实例对象修改类属性，表示的是创建了

class Dog(object): 
    tooth = 10 
wangcai = Dog() 
xiaohei = Dog() 
#修改类属性 
Dog.tooth = 20 
print(Dog.tooth) # 20 
print(wangcai.tooth) #20 
print(xiaohei.tooth) # 20
print('*' * 10) 
wangcai.tooth = 30 
print(wangcai.tooth) #给实例对象增加一个实例属性 30 
print(Dog.tooth) # 20 
print(xiaohei.tooth) # 20

3、实例属性
定义：类的初始化函数中定义的变量；

class Plane:
    #初始化函数
    def __init__(self,height,width,no):
        self.height = height # 定义在初始化函数当中的变量，用self.xxx命名的就叫实例属性
        self.width =width
        self.no = no
    def fly(self):
        print("在类的内部访问实例属性", self.height)
        print("在类的内部访问实例属性", self.width)

plane1 = Plane(height=100,width=300,no=700)
plane1.fly()
#对象名.属性
res = plane1.height
print(res)

四.类方法和静态方法

1、类方法
①类方法特点：第一个形参时类对象的方法，需要用装饰器 @classmethod 来标识其为类方法,对于类方法，第一个参数必须是类对象，一般以cls 作为第一个参数。
②类方法使用场景：当方法中 需要使用类对象（如访问私有属性等）时，定义类方法；类方法一般和类属性配合使用

class Dog(object): 
     __tooth = 10 
     @classmethod 
     def get_tooth(cls):
        return cls.__tooth 
wangcai = Dog()
result = wangcai.get_tooth() #实例对象访问类方法 
print(result) # 10 
print(Dog.get_tooth()) # 10 类对象访问类方法

2、静态方法

①静态方法特点：
·需要通过装饰器 @staticmethod 来进行修饰，静态方法既不需要传递类对象也不需要传递实例对
象（形参没有 self 或者 cls ）
·静态方法 也能通过实例对象和类对象去访问
②静态方法使用场景：
·当方法中既不需要使用实例对象（如实例对象，实例属性），也不需要使用类对象（如类属性，类
方法，创建实例对象等）时，定义 静态方法
·取消不需要的参数传递，有利于减少不必要的内存占用和性能消耗

class Dog(object): 
   @staticmethod 
   def info_print(): 
      print('这是一个狗类，用于创建狗的实例......') 
wangcai = Dog() #静态方法既可以使用对象访问又可以使用类访问
wangcai.info_print() 
Dog.info_print()

五、 面向对象-继承

1、继承的概念：
①生活中的继承，一般指的是子女继承父辈的财产。Python面向对象的继承指的是多个类之间的所属关系，即子类默认继承父类的所有属性的方法，具体如下：

class Base():
    def __init__(self, company):
        self.company = company

    def team_work(self):
        print('每周五聚餐')


class teacher(Base):
    def work(self):
        print('每天备课，讲课')


class leader(Base):
    def work(self):
        print('新员工培训，分派工作')

②super()方法：直接从父类里面找方法，找到了就用，没找到就报错了
①子类无初始化方法，调用父类的普通方法，会自动调用父类的初始化方法
②子类有初始化方法，调用父类的普通方法，不会自动调用父类的初始化方法，调用的是子类自己的初始化方法

class Mtx:

    def __init__(self,name,phone,weixin,qq):
        self.name = name
        self.phone = phone
        self.weixin = weixin
        self.qq = qq

    def homework(self):
        print(f'{self.name}写作业')

class PythonAuto(Mtx):
    # 类属性定义  当前课程名称 课程时间
    class_name = 'Python自动化'
    class_time = '每周日上课'
    # 实例属性  学员信息   姓名、手机号、微信、qq
    # 实例方法  homework

    # 多态 需求变化 python 自动化的学员 还需要提供性别 sex
    # 子类 在父类的基础上扩展__init__的属性，-- 实现父类属性的初始化
    def __init__(self,name,phone,weixin,qq,sex):
        super().__init__(name,phone,weixin,qq)# 父类初始化
        # 我们调用super()的时候  实例化一个super类
        #  和父类的方法名称一致，但是具体的方法代码不一致，这个现象叫多态
        self.sex = sex

六、面向对象-多态

1、多态
多态：简单地说，多态就是“具有多种形态”，它指的是：即便不知道一个变量所引用的对象到底是什么
类型，仍然可以通过这个变量调用方法，在运行过程中根据变量所引用对象的类型，动态决定调用哪个
对象中的方法。

class Animal():
    def eat(self):
        print('动物要吃东西')
class Dog(Animal):
    def eat(self):
        print('狗喜欢吃骨头')
class Person(object):
    def eat(self):
        print('人吃五谷杂粮')
Animal().eat()
Dog().eat()
Person().eat()