12面向对象

面向对象

1.什么是类和对象

# 1. 定义类(创建类)
"""
语法：
class 类名(父类列表):
    类的说明文档
    类的内容
    

说明：
class       -       关键字，固定写法
类名        -        由程序员自己命名;
                    要求：是标识符；不是关键字
                    规范：见名知义；使用驼峰式命名(大驼峰)；不使用系统函数名、类名或者模块名
():         -       固定写法，如果没有父类，()不用写
父类列表     -       可以没有父类，也可以是一个父类，也可以是多个父类用逗号隔开 （继承）
类的说明文档  -       本质就是多行注释
类的内容     -       包含属性(定义在类中的变量)和方法(定义在类中的函数)
"""
# dogName  -  小驼峰
# DogName  -  大驼峰


class A:
    """A类"""
    x = 100

    def func1(self):
        print('A类中的方法')


# 2. 创建对象
# 通过类可以创建指定类的对象
"""
语法： 类名()       -        创建指定类的对象
"""
# int   ->  10、100、210
# str   ->  'abc'、'小明'
# list  ->  [10, 20]、 []
a1 = A()
a2 = A()
print(a1)
print(a2)

i1 = int()
print(i1)

l1 = list()
print(l1)

l2 = list('abc')

2.类中的方法

# 1.方法
"""
方法就是定义在类中的函数。
python中方法分为三种：对象方法、类方法、静态方法
"""

# 2.三种不同的方法
"""
需要掌握的技能：1. 看到一个类可以分清楚类中的函数的类型; 2.可以使用里面的函数对应的功能(能够调用这些函数)

1）对象方法
a.怎么定义：直接定义在类中的函数
b.怎么调用：通过对象来调用（对象.xxx()）  -  只能用对象来调用
c.特点：有一个默认参数self，在通过对象调用对象方法的时候参数self不需要传参，系统会自动将当前对象传给self(谁调用self就指向谁)

2）类方法
a.怎么定义：定义函数前加装饰器"@classmethod"
b.怎么调用：通过类和对象来调用，一般用类
c.特点：有一个默认参数cls，不需要传参，系统会自动将当前类传给cls

3）静态方法
a.怎么定义：定义函数前加装饰器"@staticmethod"
b.怎么调用：通过类和对象来调用，一般用类
c.特点：没有特点
"""


class A:
    # func1就是一个对象方法
    def func1(self, x, y=10):
        # self = a1
        print(f'self:{self}')
        print('A中的对象方法')
        print(x * 10)

    # fun2和func3是类方法
    @classmethod
    def func2(cls):
        print('A中的类方法1', cls, A)

    @classmethod
    def func3(cls, a, b):
        print('A中的类方法2')

    # func4是静态方法
    @staticmethod
    def func4():
        print('A中的静态方法')


# a1就是A的对象
a1 = A()
a2 = A()
print(f'a1:{a1}')
print(f'a2:{a2}')

# ====== 用对象调用对象方法(给对象发消息) =======
a2.func1(100)


# ========= 调用类方法 =========
A.func2()
A.func3(a=100, b=200)
a1.func2()
a1.func3(10, 20)

# ========= 调用静态方法 =========
A.func4()
a2.func4()

3.魔法方法中的初始化方法

# 1. 魔法方法
"""
1)方法名是以__开头并且以__结束
2)不需要程序员调用，系统会在特定情况下自动调用
"""


class A:
    # 1. __init__方法会在创建当前类的对象的时候调用
    def __init__(self):
        print('__init__方法')

    #   2.__repr__方法会在打印当前类的对象的时候调用，这个方法的返回值就是打印结果
    def __repr__(self):
        print('__repr__')
        return 'abc'


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


print('~~~~~~~~~~~~~~~~~~~~~~~~~~华~丽~丽~的~分~割~线~~~~~~~~~~~~~~~~~~~~~~~~~~~~')


# 2. 初始化方法： __init__
"""
创建类的对象的时候需不需要实参，需要几个实参由类中__init__方法决定。
"""


class B:
    def __init__(self, x, y, z=3):
        print(f'x:{x}, y:{y}, z:{z}')


b1 = B(111, 222)
print(b1)

b2 = B(y=20, x=10, z=30)


print(int(10).as_integer_ratio())
print(int(10).bit_length())

print(dict.fromkeys(['姓名', '年龄', '电话'], ['小明', 19, '110']))

4.属性

# 1. 属性
"""
属性就是定义在类中的变量；分为对象属性和类属性。

1）类属性
a.怎么定义：直接定义在类中的变量
b.怎么使用：通过 '类.xxx' 的方式来使用

2）对象属性
a.怎么定义：以'self.属性名 = 值' 的方式定义在__init__方法中
b.怎么使用：通过 '对象.xxx' 的方式来使用
"""


class A:
    # X、M、NAME是类属性
    X = 100
    M = 'abc'
    NAME = '小明'

    # age、n、gender就是对象属性
    def __init__(self):
        self.age = 18
        self.n = 100
        self.gender = '男'


# 通过类使用类属性
print(A.X, A.M, A.NAME)
A.X = 200
print(A.X)

# 通过对象使用对象属性
a1 = A()
print(a1.age, a1.n, a1.gender)
a1.age = 30
print(a1.age)

print('~~~~~~~~~~~~~~~~~~~~~~~华~丽~丽~的~分~割~线~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')


class Circle:
    PI = 3.1415926

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

    def get_area(self):
        # self = c1; self = c2
        return Circle.PI * self.r ** 2


c1 = Circle()
print(c1.get_area())

c2 = Circle(5)
print(c2.get_area())

print('~~~~~~~~~~~~~~~~~~~~~~~~~~~华~丽~丽~的~分~割~线~~~~~~~~~~~~~~~~~~~~~~~~~~')


class B:
    def __init__(self, y, z=30):
        self.x = 10
        self.y = y
        self.z = z


b1 = B(20)
print(b1.x, b1.y, b1.z)

b2 = B(200, 300)
b2.x = 100
print(b2.x, b2.y, b2.z)

5.继承

# 继承：让子类直接拥有父类的所有的属性和方法
"""
class 类名(父类1, 父类2, ...):
    说明文档
    类的内容
    
注意：如果定义类的时候没有指定父类，这个类会默认继承Python的基类(object)
"""
# class A:  == class A(object):


class A:
    M = 100
    N = 'abc'

    def __init__(self):
        self.x = 1000
        self.y = '你好'

    def func1(self):
        print('A中的对象方法')

    @classmethod
    def func2(cls):
        print('A中的类方法')

    @staticmethod
    def func3():
        print('A中的静态方法')


class B(A):
    NAME = 'hello'

    def func4(self):
        print('B中的对象方法func4')

    def func1(self):
        print('B中的对象方法func1')


class C(B):
    pass

b1 = B()
print(B.M, B.N)
print(b1.x, b1.y)
b1.func1()
B.func2()
B.func3()
print('~~~~~~~~~~~~~~~~~~~~~~~~~~华~丽~丽~的~分~割~线~~~~~~~~~~~~~~~~~~~~~~~~~~')
b1.func1()