liuliuya's blog
0%

面向对象高级

发表于 更新于 分类于

python的第九节课笔记（基础高级）

本节课除了魔法方法，其他的了解即可

常用内置函数

属性访问函数

1
2
3
4
5
6
7
8
9
10
hasattr 判断属性是否存在
    hasattr(对象,"属性名")   属性名需要引号包裹
    存在返回True 不存在返回False
getattr    得到属性值，没有则报错
setattr    设置属性值，有则改无则增
    setattr(对象,"属性名", "值")
    存在则修改，不存在则新增
delattr    删除属性
    delatrr(对象,"属性名")
    删除对象对应的属性
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
34
35
36
37
38
39
40
41
42
# 创造一个人类
class Person():
    def __init__(self, name, age, sex):
        # self.属性名 = 属性的值
        self.name = name
        self.age = age
        self.sex = sex

    def paly(self):
        print(f"{self.name}是一个{self.sex}孩子，喜欢打游戏")

    def study(self):
        print(f'{self.name}，今年{self.age}岁了，正在上学')


lf = Person("冷风", 28, "男")
print(lf.name)
#print(lf.sg)  # 没有这个属性，报错
print(hasattr(lf, "sg"))  # False
print(hasattr(lf, "sex"))  # True

setattr(lf, "sex", "女")  # 没有返回值，直接更改对象的参数
setattr(lf, "sg", "188")
print(lf.sex)
print(lf.sg)
delattr(lf, "sg")
delattr(lf, "sex")
print(lf.sex)
print(lf.sg)




# 1、判断属性是否存在
if hasattr(lf, "sg"):
    # 存在，获取属性值
    getattr(lf, "sg")
else:  # 不存在--->设置属性值
    setattr(lf,"sg", 188)

print(lf.sg)
print(lf.tz)

对象关系方法

1
2
3
4
5
6
对象关系属性

issubclass  判断第一个类是否继承于后面类  
isinstance  判断实例是否是后面的实例， 考虑继承关系
is          不考虑继承关系
type 也可以判断，但是只能判断单个类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Ape():
    pass


class Person(Ape):  # 继承Ape类
    pass


实例化对象
monkey = Ape()
xjy = Person()
print(type(monkey), type(xjy))  #判断是什么类
# 判断xjy 是否属于 Ape 类
print(xjy is Ape)  # False
print(isinstance(xjy, Ape))  # True
print(issubclass(Person, Ape))  # 人类由猿类继承，True
print(issubclass(Ape, Person))   #False

属性调用过程

1
属性的调用顺序

当实例调用一个不存在的属性的时候，会发生报错，
但是如果类中增加__getattr__方法，则不会报错，而是自动执行此方法内的程序
__getattr__：必须要有两个参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Person():
    def __init__(self, name, age, sex):
        # self.属性名 = 属性的值
        self.name = name
        self.age = age
        self.sex = sex

    def __getattr__(self, item):
        """
        当出现不存在的时候，会自动调用
        :param item: 当前属性
        :return:
        """
        return "没有这个属性", item


qy = Person("青云", 18, "女")
print(qy.sg)  #（‘没有这个属性’，‘sg’）
print(qy.name)   #青云

*魔法方法

Python中很多内置方法左右两边都是两个下划线中间一个英文单词，把这种方法都称之为魔法方法
魔法方法：在特殊场景下由python解释器自动调用，完成某些功能

__new__：
在实例化对象的时候自动调用(最先调用)
功能：创建实例对象
__init__：
在实例化对象的时候自动调用
功能：实例对象属性的初始化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
魔法方法：
    调用:不需要手动调用，特定场景自动执行
    定义： __方法名__

__new__
    场景  在对象要被实例化的时候
    功能  创造一个实例化对象
__init__
    场景  对象被实例化之后
    功能  初始化对象属性
__str__
    场景  打印对象的时候执行
    功能  修改打印对象名的时候的返回值
__repr__
    场景 引用对象的时候执行
__del__
    场景  对象被释放的时候执行
    功能  删除

引用对象：通过对象名访问对象的值
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
class Lei(object):

    def __new__(cls, *args, **kwargs):
        """
        cls :代指当前的类
        self:代指当前对象
        # new方法里面原来有很多代码帮助我们创建对象
        # 子类和父类重名，覆盖了父类的功能
        # 解决： 重新调用父类功能 super()，并且将创建好的对象返回出去
        """
        print("创建对象的方法")
        return super().__new__(cls)

    def __init__(self, name, age):
        # self.属性名 = 属性的值
        self.name = name
        self.age = age
        print("初始化属性值的方法")

    # def __str__(self):
    #     return "hello"

    # def __repr__(self):
    #     return "this is reper"


# st = Lei("孙涛", 22)
# print(st)  # 直接打印对象，返回的是内存地址

单例模式

1
2
单例模式： 只有一个对象
        操作基于对象属性值的更改
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
class Lei(object):

    def __new__(cls, *args, **kwargs):
        """
        判断这个类是否有对象
        没有： 重新调用父类方法创造对象
        有： 不需要重新调用，由于已经重写了父类方法，本身就没有对象会被创造出来
        """
        if not hasattr(cls, "_instance"):  # 没有对象
            cls._instance = super().__new__(cls)
        return cls._instance

    def __init__(self, name, age):
        # self.属性名 = 属性的值
        self.name = name
        self.age = age


sw = Lei("圣文", 28)
print(sw)
print(sw.name)  # 只有一个对象，出来的就是圣文的属性
xw = Lei("向往", 24)
print(xw)
print(sw.name)  # 有了新的值，对原来的属性进行修改，覆盖就对象，，，向往
print(xw.name)     #向往