面向对象

一、认识类和对象

1.什么是类，什么是对象

类就是拥有相同功能和相同属性的对象的集合；类是抽象的
对象就是类的实例；对象是具体的

2.类的声明

类中的内容，包含功能（函数）和属性（变量）

• a.语法
  class 类名（父类）：
  类的内容

• b.说明
  ①class - python声明类的关键字
  ②类名 - 要求：标识符，不能是关键字
  ③规范：驼峰式命名（通过首字母大写来区分不同的单词）；第一个字母大写
  ④类的内容 - 包含类的方法、属性和说明文档
  方法就是声明在类中的函数
  属性就是声明在类中的变量

3.对象的声明

语法:
类名（） - 创建指定的类的对象并且返回

声明一个类

class Person:
    """类的说明文档：人类"""
    num = 61  # 类中的属性

    # 类中的方法
    def eat(self):
        print('人在吃饭')


def main():
    # 创建Person类的对象，p1就是对象
    p1 = Person()
    print(p1)
    # 同一个类可以创建多个对象
    p2 = Person()
    print(p2)

if __name__ == '__main__':
        main()

二、对象方法

class 类名：
类中的方法
类中的属性

1.类中的方法

声明在类中的函数就是方法
类中的方法包括：对象方法（实例方法），类方法，静态方法

①对象方法：

直接声明在类中的方法就是对象方法
有默认参数self（当我们通过对象调用对象方法的时候，self不需要传参，因为系统会自动将
当前对象传给self，当前对象是指调用当前方法的对象，谁调用对象方法self就是谁）
通过'对象.方法（）'的方式来调用（对象方法要通过对象来调用）
注意：当前类的对象能做的事情self都能做

class Person:
    def run(self):
        # self = p1
        print('self:', self)
        print('人在跑步')



def main():
    # 创建对象
    p1 = Person()
    # 通过对象p1调用对象方法
    p1.run()
    print(p1)

if __name__ == '__main__':
        main()

三、init方法和构造方法

1.init方法：init

init方法是类中的一个特殊的对象方法，专门用来对创建的对象进行初始化
当通过类创建对象的时候系统就会自动调用init方法

2.构造方法

函数名和类名一样的函数就是构造方法，专门用来创建对象
python中声明类的时候系统会自动创建这个类对应的构造方法
当我们用构造方法的时候内部会先在内存中开辟空间保存对象，然后用创建的这个对象去调用init方法,用来对对象进行初始化，init方法调用结束后，返回对象

def Person（）：
    对象 = 创建对象
    对象.__init__（）
    return 对象

注意：如果类的init方法除了self以外还有其他参数，那么在创建对象的时候需要通过构造方法给init传参

class Person:
    # 类中前后有两个下划线的方法叫魔法方法，不需要主动调用，系统会自动调用
    def __init__(self):
        print('init被调用了')

class Dog:
    def __init__(self, x, y):
        print(x, y)
        print('dog的init')

class Beauti:
    def __init__(self, x):
        print('嘻嘻嘻')
        print('self', self)
        print(x)

def main():
    # 人类
    p1 = Person()

    # 狗类
    dog1 = Dog(1, 2)

    # 美人类
    beau1 = Beauti('陈儿美女')

if __name__ == '__main__':
        main()

四、对象属性

1.什么是对象属性

类中的属性分为类的字段和对象属性

• a.对象属性 —— 属性值会因为对象不同而不一样，这种属性就应该声明为对象属性
  声明在init方法中
  以'self.属性 = 值'的方式来声明（这儿的属性就是对象属性）
  通过'对象.属性'的方式来使用

• b.类的字段 - 属性的值不会因为对象不同而不同，这照片那个属性就是声明成类的字段
  直接声明类的里面，函数的外面的变量就是类的字段
  以'字段名 = 值'
  通过'类.字段'的方式来使用

class Person:
    # 在init方法中声明对象属性
    def __init__(self, name1, age1):
        self.name = name1
        self.age = age1

练习:创建Dog类，有属性名字、类型、年龄

要求创建Dog的对象的时候：不能给年龄赋值，可以给类型赋值也可以不用给类型赋值，必须给名字赋值

# 对象方法eat：打印xxx在吃什么
class Dog:
    def __init__(self, name1, form1):
        self.name = name1
        self.form = form1
        print(self.name, self.form)
    def eat(self,food):
        print('%s在吃%s' % (self.name, food))

def main():
    p1 = Person('陈儿', 18)
    # 获取对象的属性值
    print(p1.name, p1.age)
    D1 = Dog('啸天', '德牧')
    D1.eat('热翔')

if __name__ == '__main__':
    main()

五、对象属性的增删改

python中对象的属性支持增删改查

class Dog:
    __slots__ = ('name', 'color')  # 对对象的属性进行约束
    def __init__(self,name='', color='黑色'):
        self.name = name
        self.color = color
dog1 = Dog('拉斯', '黑白')
# dog1.age = 2
# dog1.name1 = '萨瓦迪卡'  因为在前面做出了约束，所以报错：AttributeError: 'Dog' object has no attribute 'age'

class Person:
    def __init__(self, name='', age=0, sex='女'):
        self.name = name
        self.age = age
        self.sex = sex

def main():
    p1 = Person('陈儿')
    p2 = Person('陈儿')
    print(p1, p2)
    # 1.查（获取对象属性）
    """
    对象.属性  - 获取指定对象指定属性值；当属性不存在的时候会报错
    getattr(对象,属性名：str) - 获取指定对象指定属性值；当属性不存在的时候，
    如果给默认值赋了值，程序不会报错并且将默认值作为结果
    """
    print('===================查=====================')
    print(p1.name)
    # print(p1.name1)  AttributeError: 'Person' object has no attribute 'name1'

    # 属性不确定的时候可以使用getattr
    attr = input('属性:')
    print(getattr(p1, attr))

    print(getattr(p1, 'name', None))

    # 2.增/改
    """
    对象.属性 = 值   -- 当属性存在的时候是修改属性的值，不存在的时候就添加属性
    setattr（对象，属性名，值） -- 当属性存在的时候是修改属性的值，不存在的时候添加属性
    """
    print('=================增/改===================')
    # 修改属性
    p2.name = '小陈儿'
    print(p2.name)

    setattr(p2, 'age', 18)
    print(p2.age)
    # 添加属性
    p2.height = 165
    print(p2.height)

    setattr(p2, 'weight', 90)
    print(p2.weight)

    # 3.删
    """
    del 对象.属性
    delattr(对象,属性名)
    """
    print('==================删=====================')
    del p1.sex
    # print(p1.sex)  AttributeError: 'Person' object has no attribute 'sex'

    # 注意：对象属性的操作，只针对操作的那一个对象，不会影响其他对象
    print(p2.sex)

if __name__ == '__main__':
        main()

六、内置属性

内置属性指的是我们创建类的时候系统自动给我们添加的属性（其实是通过继承获取到的）

class Person:
    """银根哒"""
    num = 61
    # __slots__ = ('name', 'age', 'sex')

    # 对象属性
    def __init__(self, name='', age='', sex='男'):
        self.name = name
        self.age = age
        self.sex = sex
    def eat(self, food):
        print('%s在吃%s' % (self.name, food))

定制对象的打印格式（当我们通过print打印一个对象的时候，实质就是打印对象repr函数的返回值）

# 这个函数的返回值必须是字符串
def __repr__(self):
    return '❤'+ str(self.__dict__) + '❤'

def main():
    p1 = Person('小明', 18)
    print(p1)  # 相当于打印（p1.__repr__()）
    # 1.类.__name__   获取类的名字（结果是字符串）
    class_name = Person.__name__
    print(Person, class_name)
    # 值是一个字符串，可以当成字符串来用
    print(class_name.upper())

    # 2.对象.__class__   获取对象对应的类（结果是类）
    my_class = p1.__class__
    print(my_class)
    # 可以将my_class当成类来使用
    p2 = my_class('小花')
    print(my_class.num)

    # 3.类.__doc__  获取类的说明文档（字符串）
    print(Person.__doc__)

    # 4.对象.__dict__  将对象转换成字典，将属性和值作为键值对
    # 注意：当我们给__slots__属性赋值后，对象的__dict__属性就不能使用
    print(p1.__dict__)

    # 5.类.__module__  获取当前类所在的模块的模块名
    print(Person.__module__)

    # 6.类.__bases__   获取当前类的父类(元组)
    print(Person.__bases__)


if __name__ == '__main__':
    main()

七、类方法和静态方法

1.对象方法：

• a.怎么声明：直接声明在类中
• b.特点：自带self参数，调用的时候不用传参，谁调用指向谁
• c.怎么调用：对象.方法（）

2.类方法：

• a.怎么声明：声明函数前加@classmethod
• b.特点：自带默认参数cls;调用的时候不用传参，系统会自动将调用当前函数的类传给它（cls是谁调用就指向谁，类方法智能通过类来调用，所以cls就是当前类）
• c.怎么调用：通过类来调用，类.方法（）

3.静态方法

• a.怎么声明：声明函数前加@staticmethod
• b.特点：没有默认参数
• c.怎么调用：通过类来调用，类.方法（）

4.在类中怎么选择使用哪种方法：

• 如果实现类中的函数的功能需要使用对象的属性，- 那么这个函数就要声明对象方法；
• 如果不需要对象属性，而需要类的字段，就声明成类方法
• 如果实现函数功能既不需要对象属性也不需要类的字段就声明成静态方法

class Person:
    num = 61
    @staticmethod
    def func3():
        print('我是静态方法')

    @classmethod
    def func2(cls):
        print('我是类方法2')

    @classmethod
    def func1(cls):
        # 类能做的，cls都能做
        p1 = cls()  # 用cls来创建对象
        print(p1)

        cls.num = 100
        cls.func2()  # 用cls调用类方法
        print('这是一个类方法')

def main():
    print(Person)
    Person.func1()
    Person.func3()

if __name__ == '__main__':
    main()