重制版 day 14 面向对象基础

面向对象基础

类，对象

类就是拥有相同功能和相同属性的对象的集合，对象就是类的实例

类是类型，是类别，对象就是类中一个具体的对象

定义类-用代码描述清楚这个类是拥有哪些相同功能和哪些相同属性的对象的集合

功能—函数 属性–保存数据的变量

语法结构：

创建类

class 类名：

​ 类的说明文档

​ 类的内容

类的内容-相同的功能和相同的属性

由方法（对象方法，类方法，静态方法）和属性（对象属性，类属性）组成

方法-定义在类中的函数 属性-定义在类中的变量

创建对象

语法结构：

类名()–创建指定类对应的一个对象，并将对象返回

class A:
    pass
p1=A()
p2=A()
1
2
3
4

类中的方法

方法：定义在类中的函数，用来描述类具备的功能

类中的方法由三种：对象方法，类方法，静态方法

对象方法

直接将函数定义在类里面，通过对象来调用 --对象.xxxx()

特点：自带参数self，通过对象调用对象方法的时候，参数self不用传参，系统自动传参

​ （self，谁来调用就指向谁）

一般来说，实现函数功能的时候需要用到对象属性就使用对象方法

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

    def func11(self,x,y):
        print('对象方法22',x,y)
        
# 通过对象调用对象方法
a=A()  # 创建对象  类名()
print(f'a:{a}')
a.func1()
a.func11(200,300
1
2
3
4
5
6
7
8
9
10
11
12
13

类方法

定义函数前加装饰器@classmethod，通过类来调用–类名.xxx()

特点：自带参数cls,通过类方法调用类方法的时候，不用传参，系统自动将类传递给cls

一般来说，不需要使用的对象属性的时候就可以使用类方法

@classmethod
def func2(cls):
    print('类方法')
# 通过类调用类方法
A.func2()
1
2
3
4
5

静态方法

定义函数前加装饰器@staticmethod,通过类来调用–类名.xxxx()

@staticmethod
def func3():
    print('静态方法')
# 通过类调用类方法
A.func3()
1
2
3
4
5

初始化的方法

常用的魔法方法

1）__repr__ -打印对象的时候会自动调用对应的方法，定制打印规则，返回值一般是字符串

# 常见__repr__方法
#return f'长度为:{self.length},宽度为:{self.wight},面积:{self.get_area()},周长为:{self.get_girth()}' # 方式1 直接写入需要打印的内容
#         # return str(self.__dict__)  # 方式2  以字典形式打印内容
#         return f'<{str(self.__dict__)[1:-1]}>' # 方式3
1
2
3
4

2)__init__-每次创建类的对象的时候会自动调用,除了方法名和方法类型不能改变,可以任意添加参数和函数体

创建类的对象的时候的参数个数,由__init__决定,除了self之外有几个参数,就需要几个实参

class C:
def __init__(self,x,y):
    print('C的init方法',x,y)
c1=C(100,200)
1
2
3
4

类的属性

属性分为对象属性,类属性

1)类属性

在类中直接定义变量,通过类使用,–类.xxx

2)对象属性

以’self.属性名=值’的形式定义在类的__init__方法,通过对象来使用-对象.属性名

class A:
    # x是类属性
    x=100
    # name,number,age是对象属性
    def __init__(self):
        self.name='小明'
        self.number=10
        self.age=23

# 修改类属性的值
A.x=200

# 使用类属性的值
print(A.x)

# 使用对象属性
a=A()
print(a.number,a.age)

# 修改对象属性
a.age=25
a.name='小花'
print(a.name)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

类中实现函数功能的时候,如果需要的数据是属性,不需要提供额外的参数

需要类属性,直接用类来提供-类.变量名

需要对象属性的,用self来提供 self.变量名

对象属性赋初始值的三种方式:

1.使用没有默认值的参数来赋值,创建对象的时候赋值

2.赋值固定值

3.使用默认参数来赋值

lass Person:
    def __init__(self,name,gender='男'):
        self.name=name   #  使用没有默认值的参数来赋值,创建对象的时候赋值
        self.age=1    # 赋值固定值
        self.gender=gender   # 使用有默认值的参数来赋值

p1=Person('小明')
print(p1.name,p1.age,p1.gender)

p2=Person('小花','女')
print(p2.name,p2.age,p2.gender)
1
2
3
4
5
6
7
8
9
10
11

属性的增删改查

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

1)查-获取属性值

a. 对象.属性名 -获取指定属性的值,属性不存在,报错

b.getattr(对象,属性名,默认值) --获取指定属性的值,属性不存在,返回默认值

2)增加或修改

a.对象.属性名=值 -当属性存在的时候,修改指定属性值;不存在的时候增加属性值

b.setattr(对象,属性名,值)-当属性存在的时候,修改指定属性值;不存在的时候增加属性值

3)删除

a.del 对象.属性名

b.dalattr(对象,属性名)

4)判断属性是否存在

hasattr(对象,属性名)

拓展:attr相关函数可以动态操作对象属性

继承

继承:让子类拥有父类的属性和方法

语法结构:

class 类名(父类):

​ 类的说明文档

​ 类的内容

定义类的时候如果没有写父类,默认继承object(基类)

在子类中添加内容

1)直接在子类中定义新的类属性和新的方法

2_添加对象属性

在子类的对象属性中,需要先调用父类的对象属性,然后再定义

 # super().__init__() 调用父类对象属性
class A:
	a=100

	def __init__(self):
        self.b=10
        self.c=20

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

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

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

class B(A):
    pass
print(B.a)
x=B()
print(x.b,x.c)
x.func1()
B.func2()
B.func3()

class C(A):
    m=11
    def __init__(self):
        super().__init__()  # 调用父类的__init__()的对象属性
        self.name='小明'
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33