day15-类和方法

1. 类和对象

1.1 什么是类？什么是对象？

类就是拥有相同功能或者相同属性的对象的集合

对象就是类的实例(对象是类具体的表现)

如果人是类，张三是对象，李四是另一个对象

车是类，停车场的具体的一辆车就是对象

1.2 定义类

1. 定义类：用代码来描述你的这个类拥有哪些相同功能(用函数)和哪些相同属性(用变量)的对象的集合

2. 语法：

   class 类名:

   ​ 类的说明文档

   ​ 类的内容(包含方法和属性)

3. 说明：

   a. class - 关键字；固定写法

   b. 类名 - 由程序员自己命名

   ​ 两个要求：是标识符；不是关键字

   ​ 规范：见名知义；不使用系统函数名、类名、模块名；采用驼峰式命名(大驼峰)

   c. 类的说明文档 - 本质就是一个多行注释

   d. 类的内容 - 包含定义在类中从函数(方法)和定义在类中的变量(属性)

   ​ 方法包括：对象方法、类方法、静态方法

   ​ 属性包括：类属性、对象属性

# user_name - PEP8
# userName - 小驼峰
# UserName - 大驼峰


class Dog:
    """这是狗"""
    pass

1.3 创建对象

对象是通过类来创建的

语法：类名()

dog1 = Dog()
dog2 = Dog()
print(dog1, dog2)

2. 方法

2.1 什么是方法

定义在类中的函数就是方法

2.2 不同的方法使用

1. 对象方法

   a. 怎么定义：直接定义在类中的函数就是对象方法

   b. 怎么调用：以’对象.xxx’的形式来调用

   c. 特点：自带参数self，调用函数的时候self不需要传参，系统自动将当前对象传给self(谁调用self指向谁)

2. 类方法

   a. 怎么定义：定义函数前添加装饰器 @classmethod

   b. 怎么调用：以’类名.xxx()'的形式来调用

   c. 特点：自带参数cls，调用函数的时候cls不需要传参，系统自动将当前类传给cls(谁调用cls指向谁)

3. 静态方法

   a. 怎么定义：定义函数前添加装饰器@staticmethod

   b. 怎么调用：以’类名.xxx()'的形式来调用

   c. 特点：没有特点

class A:
    # fun1是对象方法
    def fun1(self):
        print(f'self:{self}')
        print('对象方法')

    def fun2(self, a, b=2):
        print(f'self:{self}')
        print(f'对象方法2, a:{a}, b:{b}')

    # fun3是类方法
    @classmethod
    def fun3(cls):
        print(f'cls:{cls}')
        print('类方法')

    #  fun4是静态方法
    @staticmethod
    def fun4():
        print('静态方法')


a1 = A()
a2 = A()
print(f'a1:{a1}')
print(f'a2:{a2}')

# 通过对象调用对象方法
a2.fun1()
a1.fun2(100)
a1.fun2(100, 200)
a1.fun2(b=1000, a=2000)

# 通过类来调用类方法
print(f'A:{A}')
A.fun3()

# 通过类调用静态方法
A.fun4()


class Math:
    @staticmethod
    def factorial(num):
        pass

3. 初始化方法

魔法方法：

1. 魔法方法的特点：

   a. 函数名以__开头，并且以__结尾

   b. 魔法方法不需要程序员直接调用，系统会在特定情况下自动调用

2. 两个常见的魔法方法

   a. __init__：

   ​ 如果在类中添加了__init__方法，那么在创建当前类的对象的时候就会自动调用它

   ​ 创建对象的时候需不需要实参，需要几个实参，由类中的__init__决定

   b. __repr__：

   如果类中添加了__repr__方法，打印类的对象的时候会自动调用这个方法，并且将这个方法对应返回值作为打印结果进行打印

   在类中添加__repr__方法的时候，这个方法的返回值必须是字符串

class A:
    def __init__(self):
        print('init方法被调用')


a1 = A()
a2 = A()


class B:
    def __init__(self, m, n):
        print(f'm:{m}, n:{n}')

    def __repr__(self):
        return f'{hex(id(self))}>'


b1 = B(1, 2)
print(b1)


class Student:
    def __init__(self, name, age=18, gender='男'):
        self.name = name
        self.age = age
        self.gender = gender

    def __repr__(self):
        return f'姓名:{self.name}, 年龄:{self.age}, 性别:{self.gender}'


stu1 = Student('小明')
stu2 = Student('小花', 17, '女')
print(stu1)
print(stu2)

5. 属性

属性 - 定义在类中的变量

类中的属性分为：类属性，对象属性

1. 类属性

   a. 怎么定义：直接在类中定义的变量就是类属性

   b. 怎么使用：以’类名.xxx’的方式使用

   c. 什么时候用：如果属性值不会因为对象不同而不一样，就定义成类属性

2. 对象属性

   a. 怎么定义：以’self.xxx = xxx’的形式定义在__init__方法中

   b. 怎么使用：以’对象.xxx’的方式使用

   c. 什么时候用：属性值会因为对象不同而不一样，就定义成对象属性

class A:
    # a、name是类属性
    a = 10
    name = '张三'

    # x和n就是对象属性
    def __init__(self):
        self.x = 10
        self.n = 'hello'


# 通过类使用类属性
print(A.a)
print(A.name)

# 通过对象使用对象属性
a1 = A()
print(a1.x)
print(a1.n)


class Circle:
    pie = 3.1415926

    def __init__(self, r):
        self.r = r

    # 如果对象方法中需要用到对象属性，由self来提供
    def size(self):
        return Circle.pie * self.r ** 2

    def circumference(self):
        return Circle.pie * self.r * 2


c1 = Circle(10)
print(c1.size(), c1.circumference())

c1.r = 20
print(c1.size(), c1.circumference())


class Dog:
    def __init__(self, name, breed, age=3, gender='公狗'):
        self.name = name
        self.age = age
        self.gender = gender
        self.breed = breed


dog1 = Dog('小黑', '土狗')
dog2 = Dog('小黄', '金毛')
print(dog1)
print(dog2)

6. 继承

1. 继承

   让子类直接拥有父类的属性和方法

   子类 - 继承者

   父类 - 被继承者

2. 继承语法

   语法：

   ​ class 类名(父类1, 父类2, 父类3, …)：

   ​ 类的说明文档

   ​ 类的内容

3. 注意：定义类的时候没有写父类，那么这个类会默认继承object(基类)

class A:
    m = 100

    def __init__(self):
        self.n = 200

    def fun1(self):
        print('对象方法')

    @classmethod
    def fun2(cls):
        print('类方法')

    @staticmethod
    def fun3():
        print('静态方法')


class B(A):
    # 添加新的类属性
    x = 'hello'

    # 添加新的对象
    def __init__(self):
        super().__init__()      # 调用当前类的父类的__init__
        # super(B, self).__init__()
        self.p = 1000

    # 添加新的方法
    def fun11(self):
        print('对象方法2')

    @classmethod
    def fun22(cls):
        print('类方法2')

    @staticmethod
    def fun33():
        print('静态方法2')


b1 = B()

# 使用A中的内容
print(B.m)
print(b1.n)
b1.fun1()
b1.fun2()
b1.fun3()

# 使用B中的内容
print(B.x)
b1.fun11()
b1.fun22()
b1.fun33()