python学习笔记-（4）面向对象

类定义格式

class类名：
    代码

例子
class Washer():
  /// 对象方法
  def wash(self):
    print('洗衣服功能')

haier = Washer()

haier.wash()

添加和获取对象属性

• 类外面添加对象属性

格式
对象命.属性名 = 值

• 类外面获取对象属性

对象命.属性名

• 类里面获取对象属性

格式
self.属性

例子
class Washer():
  def wash(self):  
    /// 类里面获取对象属性
    print(f'洗衣机高度{self.height}')
    print('洗衣服功能')

haier = Washer()

haier.height = 100

魔法方法

在Python中，__xx__()的函数叫做`魔法方法`,指的是具有特殊功能的函数

• __init__()

作用：初始化对象
注意：
  1. __init__()方法，在创建一个对象时默认被调用，不需要手动调用
  2.__init__(self)中self参数，不需要开发者传递，python解释器会自动把当前对象引用传递过去

例子
class Washer():
    def __init__(self):
        #添加实例属性
        self.width = 100
        self.heigth = 200

    def print_info(self):
        print(f'{self.heigth}')


haier = Washer()
haier.print_info()

• 带参数的__init__()

class Washer():
    def __init__(self,width,height):
        #添加实例属性
        self.width = width
        self.height = height

    def print_info(self):
        print(f'{self.width}')
        print(f'{self.height}')


haier = Washer(200,100)
haier.print_info()

• __str__

当使用print输出对象的时候，默认打印对象的内存地址，如果类定义了__str__方法，那么就会打印从这个方法中return的数据

例子
class Washer():
    def __init__(self,width,height):
        #添加实例属性
        self.width = width
        self.height = height

    def print_info(self):
        print(f'{self.width}')
        print(f'{self.height}')

    def __str__(self):
        return '海尔冰箱'

/// 也可以使用关键字的方式初始化对象
haier = Washer(width=1000,height=200)

print(haier)

• __del__()

当删除对象时，python解释器也会默认调用__del__()方法

例子
class Washer():
    def __del__(self):
        print('对象被删除了')

haier = Washer()
del  haier

综合实例1：烤地瓜

class SweetPotato():
    def __init__(self):
        # 烤的时间
        self.cook_time = 0
        # 烤的状态
        self.cook_state = '生的'
        # 添加的调料
        self.condiments = []

    def cook(self,time):
        """烤地瓜"""
        self.cook_time += time;
        if 0 < self.cook_time < 3:
            self.cook_state = '生的'
        elif 3 <= self.cook_time < 5:
            self.cook_state = '半生不熟'
        elif 5 <= self.cook_time < 8:
            self.cook_state = '熟了'
        elif self.cook_time >= 8:
            self.cook_state = '烤糊了'

    def add_condiments(self,condiment):
        """添加调料"""
        self.condiments.append(condiment)

    def __str__(self):
        return f'这个地瓜烤了{self.cook_time}分钟，现在是{self.cook_state}，添加了以下的调料：{self.condiments}'


digua1 = SweetPotato()
print(digua1)
digua1.cook(2)
print(digua1)
digua1.add_condiments('花椒粉')
digua1.add_condiments('辣椒')
print(digua1)

综合案例2：搬家

家具类
class Furniture():
    def __init__(self, name, area):
        # 家具名称
        self.name = name
        # 家具占地面积
        self.area = area

    def __str__(self):
        return f'家具：{self.name} 占地：{self.area}'


# 房子
class Home():
    def __init__(self, address, area):
        # 地址
        self.address = address
        # 房子面积
        self.area = area
        # 剩余面积
        self.free_area = area
        # 家具列表
        self.frunitures = []

    def __str__(self):
        return f'房子的地址：{self.address},面积：{self.area},剩余面积：{self.free_area},家具：{self.frunitures}'

    def add_fruniture(self, item):
        if self.free_area >= item.area:
            self.free_area -= item.area
            self.frunitures.append(item)
        else:
            print('家具太大了，放不下了')


shafa = Furniture(name='沙发', area=16)
chuang = Furniture(name='床', area=8)

jia = Home(address='广州', area=100)
print(jia)
jia.add_fruniture(shafa)
print(jia)
jia.add_fruniture(chuang)
print(jia)

__dict__

类的继承

Python面向对象的继承指的是多个类之间的所属关系，即子类默认继承父类的所有属性和方法。

在Python中，所有类默认继承object类，object类是顶类或基类，其他子类叫做派生类

Python是`多继承`：当一个类有多个父类的时候回，默认使用`第一个`父类同名属性和方法

1、子类和父类具有同名属性和方法，默认使用子类的同名属性和方法

2、 子类调用父类的同名方法和属性：
super().函数名   super().属性
/// 使用super()可以自动查找父类。调用顺序遵循__mro__类属性的顺序，比较适合单继承使用

`__mro__`查看类的父类
格式
类.__mro__

定义私有属性和方法

在python中，可以为实例属性和方法设置私有权限，即设置某个实例属性或方法不继承给子类。
设置私有权限的方法：在属性和方法名 前面 加上两个下划线__

获取和修改私有属性值

一般定义函数名`get_xx`用来获取私有属性，定义`set_xx`用来修改私有属性

类属性

* 类属性就是 `类对象` 所拥有的属性，它被该类的`所有实例对象`所共有
* 类属性可以使用 `类对象` 或 `实例对象` 访问

/// 类属性的优点
/// 记录的某项数据，始终保持一致时，则定义类属性
/// 实例属性 要求 每个对象 为其 单独开辟一份内存空间来记录数据，而类属性为全类所共有，仅占用一分内存，更加节省内存空间

class Dog():
    tooth = 10

wangcai = Dog()
xiaohei = Dog()

print(Dog.tooth)
print(wangcai.tooth)
print(xiaohei.tooth)


* 修改类属性
/// 类属性只能通过类对象修改，不能通过实例对象修改，如果通过实例对象修改类属性，表示的是创建了一个实例对象

类方法

* 特点：
需要使用装饰器`@classmethod` 来标识其为类方法，对于类方法，第一个参数必须是类对象，一般以`cls`作为第一个参数

* 使用场景
1.当方法中需要使用类对象(如访问私有类属性等)时，定义类方法
2.类方法一般和类属性配合使用

class Dog(object):
    __tooth = 10

    @classmethod
    def get_tooth(cls):
        return cls.__tooth

wangcai = Dog()
print(wangcai.get_tooth())

静态方法

* 特点：
1、 需要通过 @staticmethod 来进行修饰，静态方法即不需要传递类对象，也不需要传递实例对象(形参没有self/cls)
2、静态方法也能够通过实例对象和类对象去访问

* 使用场景
1、当方法中 即不需要使用实例对象(如实例对象、实例属性)，也不需要使用类对象（如类属性，类方法，创建实例等）时，定义静态方法
2、取消不需要的参数传递，有利于减少不必要的内存占用和性能消耗


class Dog(object):
    @staticmethod
    def info_print():
        print('这是一个静态方法')

wangcai = Dog()
wangcai.info_print()
Dog.info_print()