python面向对象

面向对象

编程思维

根据面对问题不同人呈现出来的思维模式不同，可以将编程思维分为三种：

1.面向过程编程（穷人思想） - 遇到问题马上想的是解决这个问题的具体逻辑和步骤

2.函数式编程（小资思想） - 遇到问题马上想的是有没有一个已经存在的函数可以解决这个问题，如果没有就造一个（一个函数只具备一个功能）

3.面向对象编程（富豪思想） - 遇到问题马上想的是有没有一个具有这个功能的对象，如果没有就造对象（一个对象可以同时具有多个功能） - 类和对象

类和对象

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

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

对象就是类的实例

2.定义类 - 创建类

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

2）语法：

class 类名:
    类的说明文档
    类的内容（包含方法和属性）

3）说明：

a. class  -  关键字；固定写法
b. 类名  -  由程序员自己命名
            两个要求：是标识符；不是关键字
            规范：见名知义；不使用系统的函数名、类名和模块名；采用驼峰式命名（大驼峰：单词首字母都要大写）
c.类的说明文档  -  本质就是一个多行注释
d.类的内容  -  包含定义在类中的函数（方法）和定义在类中的变量（属性）
              方法包括：对象方法、类方法、静态方法
              属性包括：类属性、对象属性

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

class Dog():
    '''这是狗'''
    pass

3.创建对象

对象是通过类来创建的。

语法：
类名()

dog1 = Dog()
print(dog1)

方法

1.什么是方法

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

2.不同的方法的使用

1）对象方法

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

​ b.怎么调用：以’对象.xxx()'的形式来调用；没有对象就创建一个对象，例：a1 = A()

​ c.特点：自带参数self，调用函数的时候self不需要传参，系统自动将当前对象传给self（谁调用self指向谁）。如果自己有添加其他参数，调用的时候需要传参。

2）类方法

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

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

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

3）静态方法

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

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

​ c.特点：没有特点

class A:
    #func1、func2是对象方法
    def func1(self):
        print('对象方法')

    def func2(self,a,b=2):
        print(f'对象方法2：a:{a},b:{b}')
    # func3是类方法
    @classmethod
    def func3(cls):
        print('类方法')
    # func4是静态方法
    @staticmethod
    def func4():
        print('静态方法')
# 创建对象
a1 = A()
a2 = A()
print(a1)
print(a2)
# 通过对象调用对象方法
a2.func2(100)
a2.func2(1000,200)
a2.func2(a=12,b=300)
# 通过类调用类方法
A.func3()
# 通过类调用静态方法
A.func4()

初始化方法

1.魔法方法

1）魔法方法的特点：

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

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

2）两个常见的魔法方法

a. _ _ init _ _：如果在类中添加了 _ _ init _ _方法，那么在创建当前类的对象的时候就会自动调用它；创建对象的时候需不需要实参，需要几个实参，由类中的 _ _ init _ _决定。

b. _ _ repr _ _：如果类中添加了 _ _ repr _ _方法，打印类的对象的时候会自动调用这个方法，并且将这个方法对应返回值作为打印结果进行打印。在类中添加 _ _ repr _ _方法的时候，这个方法的返回值必须是字符串，如果不是字符串会报错。

属性

属性 - 定义在类中的变量

1.类中的属性分为：类属性、对象属性

1）类属性

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

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

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

2）对象属性

a.怎么定义：以’self.属性名 = 属性值’的形式在_ _ 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 Dog:
    def __init__(self,name,age,gender,breed):
        self.name = name
        self.age = age
        self.gender = gender
        self.breed = breed

dog1 = Dog('小黑','3','公','土狗')
dog2 = Dog('土豆','2','公','土狗')
print(dog1.name,dog2.name)

class Circle:
    pi = 3.1415926

    def __init__(self,r=0):
        self.r = r
    # 如果对象方法中需要用到对象属性，由self来提供
    def area(self):
        return Circle.pi * self.r ** 2

    def length(self):
        return Circle.pi * 2 * self.r

c1 = Circle(10)
print(c1.area())
c2 = Circle(20)
print(c2.area())
c3 = Circle(2)
print(c3.length())

继承

1.继承

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

子类 - 继承者

父类 - 被继承的类

2.继承语法

语法：
class 类名（父类1,父类2,父类3,...）
    类的说明文档
    类的内容

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

class A:
    m = 100

    def __init__(self):
        self.n = 200

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

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

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

class B(A):
    # 添加新的类属性
    x = 'hello'
    # 添加新的对象属性
    def __init__(self):
        super().__init__() # 调用当前类的父类的__init__
        # super(B, self).__init__()
        self.p = 1000
     # 添加新的方法
    def func11(self):
        print('对象方法1')
    @ classmethod
    def func22(cls):
        print('类方法2')

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


b1 = B()
print(B.m)
print(b1.n)
b1.func1()
B.func2()
B.func3()
print(b1.p)