面向对象

1. 编程思维

根据面对问题不同人层显示的思维模式不同，将编程思维分为三种：

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

2）函数式编程（小资思想） - 遇到问题想到的是有没有一个函数可以解决，如果没有就造一个。

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

2. 类和对象

2.1 什么是类？什么是对象？

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

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

如果人是类， xx是对象，具体某一个人是对象

如果车是类，婷姐的车是对象

如果斗地主游戏是类，某一场游戏是对象

2.1 定义类 - 创建类

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

2）语法：

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

3）说明

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

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

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

​ 规范：见名知义；不使用系统函数名、类名和模块名；采用大驼峰式命名（比如：UserName）

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

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

• 方法包括：对象方法、类方法、静态方法
• 属性包括：类属性、对象属性

类的创建

# 类的创建
class Dog:"""这是狗"""pass

创建对象

• 对象是通过类来创建的
• 语法：类名()

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

3. 方法

3.1 什么是方法

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

3.2 不同方法的使用

1）对象方法

a. 怎么定义：直接定义在类中函数就是对象方法
b. 怎么调用：以‘对象.xxx()’的形式来调用
c. 特点：自带参数self,调用函数的时候不需要传参，系统会自动将当前对象传给self（谁调用self指向谁）

2）类方法

a. 怎么定义:定义函数前添加装饰器 @classmethod
b. 怎么调用：以‘类名.xxx()’的形式调用
c. 特点:自带参数cls,调用函数的时候cls不需要传参，系统会自动将类传给cls

3）静态方法

a. 怎么定义：定义函数前添加装饰器 @staticmethod
b. 怎么调用：以‘类名.xxx()’的形式调用
c. 特点:没有特点

class A:# func1 是对象方法def func1(self):# self = a1print(f'self:{self}')   # self:<__main__.A object at 0x0000013C61394BB0>print('对象方法1')def func2(self, a, b=2):print(f'对象方法2, a:{a}, b:{b}')   # 对象方法2, a:100, b:2     # 对象方法2, a:100, b:200# func3是类方法@classmethoddef func3(cls):print(f'cls:{cls}')     # cls:<class '__main__.A'>print('类方法')# func4是静态方法@staticmethoddef func4():print('静态方法')# 创建对象
# a1 和 a2 不一样
a1 = A()
a2 = A()
print(f'a1:{a1}')    # a1:<__main__.A object at 0x0000013C61394BB0>
print(f'a2:{a2}')    # a2:<__main__.A object at 0x0000013C613952A0># 通过对象调用对象方法
a1.func1()
a2.func2(100)
a2.func2(100,200)# 调用类方法
print(f'A:{A}')     # A:<class '__main__.A'>
A.func3()# 调用静态方法
A.func4()

4. 初始化方法

4.1 魔法方法

1）魔法方法特点：

• 函数名以’‘开头，并且以’'结尾

• 魔法方法不需要程序员自己调用，系统会在在特定条件条件下自动调用

2）两个常见魔法方法

a. init:

• 如果在类中添加了__init__方法，那么在创建对象的时候就会自动调用；不需要创建对象后使用调用函数的方法调用
• 创建对象的时候需不需要实参，需要几个实参，由类中的__init__决定

b. repr:

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

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

class A:def __init__(self):print('init被调用')a1 = A()    # init被调用
a2 = A()    # init被调用
print(a1)   # <__main__.A object at 0x0000026EA6B34BB0>
# 无需使用a1.__init__调用print('------------------------------华丽分割线-----------------------------')class B:def __init__(self, m, n):print(f'm:{m}, n:{n}')def __repr__(self):return '<B的对象>'# b1 = B()  # 报错
b1 = B(10, 20)
print(b1)   # <B的对象>

class Students:def __init__(self, name, age=18, gender='男'):self.name = nameself.age = ageself.gender = genderdef __repr__(self):# self = stu1return f'姓名：{self.name}, 年龄：{self.age}, 性别：{self.gender}'stu1 = Students('小明')
stu2 = Students('小花', 17, '女')
print(stu1)
print(stu2)

5. 类中属性

属性 - 定义在类中的变量

• 类中的属性分为两种：类属性、对象属性

5.1 类属性

1）怎么定义：直接在类中定义的变量就是类属性
2）怎么使用：以’类名.xxx()'的方式使用
3）什么时候用：如果属性值不会因为对象不同而不一样，就定义成类属性

5.2 对象属性

1）怎么定义：以’self.属性名 = 属性值’ 的形式定义在__init__方法中
2）怎么使用：以’对象.xxx()'的形式使用
3）什么时候用：如果属性值会因为对象不同而不一样，就定义成对象属性

class A:# a、name是类属性m = 10n = '张三'#x,n就是对象属性def __init__(self):self.x = 10self. n = 'hello'# 通过类使用类属性
print(A.m)      # 10
print(A.n)   # 张三# 通过对象使用对象属性
# 需要先创建对象
a1 = A()
print(a1.x)     # 10
print(a1.n)     # helloclass Circle:# 类属性pi = 3.1415926# 对象属性def __init__(self):self.r = 1print('------------------------------华丽分割线-----------------------------')class Dog:# 也可以添加默认值def __init__(self, name, age, breed, gender='公'):self.name = nameself.age = ageself.breed = breedself.gender = genderdog1 = Dog('小黑', 2, '金毛')
# dog2 = Dog('小小')
print(dog1.name)

class Circles:# 类属性pi = 3.1415926# 对象属性def __init__(self, r=0):self.r = r# 面积# 如果对象方法用到对象属性，有self提供def area(self):return Circles.pi * self.r ** 2# 周长def perimeter(self):return Circles.pi * (self.r * 2)c1 = Circles(10)
print(c1.area())
print(c1.perimeter())c1 = Circles(20)
print(c1.area())
print(c1.perimeter())

6. 继承

6.1 继承

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

子类 - 继承者
父类 - 被继承的类

6.2 继承语法

语法：

class 类名(父类1, 父类2, 父类3, ...):类的说明文档类的内容

• 注意：如果定义类的时候没有写父类，那么这个类会继承object（基类）

class A:m = 100def __init__(self):self.n = 200def func1(self):print('对象方法')@classmethoddef func2(cls):print('类方法')@staticmethoddef fenc4():print('静态方法')class  B(A):# 添加新的类属性x = 'hello'# 添加新对象 父类继承的__init__不调用时失效# def __init__(self):#     self.p = 1000def __init__(self):super().__init__()  # 调用当前父类的__init__，使子类和父类的__init__都可以使用self.p = 1000# 添加新的对象方法def func11(self):print('对象方法2')@classmethoddef func22(cls):print('类方法2')@staticmethoddef func33():print('静态方法2')b1 = B()
print(B.m)
print(b1.n)
print(b1.func1())
print(B.func2())
print(B.fenc4())print(B.x)
print(b1.p)
print(b1.func11())
print(B.func22())
print(B.func33())