python面向对象#3

一.面向对象之组合

        什么是组合：它不是一个新的技术栈，他是对象的另一种用法，一个对象拥有一个属性，该属性就是另一个对象。

示例：

"""一个对象拥有一个属性，该属性的值就是另一个对象"""


class A:
    def __init__(self, m):
        self.m = m


class B:
    def __init__(self, n):
        self.n = n


obj = A(10)
obj1 = B(20)
obj2 = obj1
print(obj2.n)

什么场景下使用组合什么场景下使用继承：

继承一般是is 什么是什么的情况下而组合是什么有什么的情况下

"""使用组合来进行下面代码的执行"""


class People:
    def __init__(self, name, age, gender, course_name=None, course_time=None):
        self.name = name
        self.age = age
        self.gender = gender
        self.course_name = course_name
        self.course_time = course_time


class Name(People):
    def __init__(self, name, age, gender):
        super().__init__(name, age, gender)


class Course:
    def __init__(self, name, time):
        self.name = name
        self.time = time

py = Course('python', '120min')
L = Course('linux', '222min')
# print(py.name)
# print(py.time)


class Student(People):
    def __init__(self, name, age, gender, course=None):
        super().__init__(name, age, gender)
        if course is None:
            course = []
        self.course = course


stu = Student('ll', 29, 'female')
stu.course.append(py.name)  # python
stu.course.append(py.time)  #120min
print(stu.course)   # 'python', '120min'
for i in stu.course:
    print(i)    # python  120min


class Teacher(People, Course):
    def __init__(self, name, age, gender, level):
        super().__init__(name, age, gender)
        self.level = level

t = Teacher('cc', 22, 'mael', 77)
print(t.name)
print(t.age)
print(t.level)

t.course = L
print(t.course.time)
print(t.course.name)

    

二 .反射

        在python中反射是使用字符串来操作对象的属性，涉及到的四个内置函数的使用，分别为：

        

"""反射所使用的四个内置函数"""

getattr() # 获取属性

setattr() #修改属性

delattr() #删除属性

hasattr() # 判断属性是否存在

示例：

class Student:
    school = 'SH'

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def func(self):
        print('form func')

    def __index__(self):
        print('from index')

stu = Student('l', 22)
print(Student.school)
"""反射：通过字符串操作对象的属性
1. 获取属性如果查询的属性，如果给了第三个参数，那么将返回第三个参数的值"""
res = getattr(stu, 'school', 777)
print(res)
res1 = getattr(stu, 'name', 'SK')
res2 = getattr(stu, 'age')

print(res, res1, res2)
print(stu.school)

函数的用法：

        

class Student:
    school = 'SH'

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def func(self):
        print('from func')

    def index(self):
        print('from index')

stu = Student('kk', 19)
print(stu.name)
print(stu.age)

res = getattr(stu, 'school')
print(res)
res1 = getattr(stu, 'name1', 'hhh')
print(res1)

res2 = getattr(stu, 'func1', stu.index)
print(res)
res2()


"""可以使用hasattr来做判断"""
if hasattr(stu, 'func'):
    getattr(stu, 'func')
else:
    print('权限不足')

    
"""使用delattr用来操作删除"""
delattr(stu, 'index')
if hasattr(stu, 'func'):
    getattr(stu, 'func')
else:
    delattr(stu, 'func')
    

调用类时，使用字符串来操作。

        利用字符串使用模块

        

三 .内置方法与魔术方式

内置方法有什么特点：双下划线开头的例如__init__。当它满足一定条件后便会触发。

1. __str__, repr

        

"""打印对象时输出对象时会自动触发__str__
当__str__和__repr__同时存在时，优先执行__str__
返回值必须是字符串类型"""


class Student:

    school = 'SH'

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        print('123')
        return 'fromstr'    # 返回值必须是字符串类型

    def __repr__(self):
        print('234')
        return 'from repr'

stu = Student('sds', 22)
print(stu)  # 123 fromstr

2.__del__

"""
  1.当你删除对象的时候会触发__del__的执行
  2. 当整个脚本的程序都执行完毕的时候，也会触发__del__的执行
  3. 一般用在用来在对象被删除时自动触发回收系统资源的操作
  """

class CC:
    def __init__(self, ip, port):
        self.ip = ip
        self.port = port
        self.f = open('a.txt', 'w')

    def __del__(self):
        print('form _del')
        self.f.close()

la = CC(1231, 9999)
    ### 当所有程序执行完成后，在进行del删除
print(la)
print('2222') #2222 form _del

3. enter和exit

        当出现with语句是，__enter__才能被触发，如果有返回值，则赋予给as声明的变量

        __exit__则是当with语句执行完成时，触发__exit__, with语句可以用在多个地方，当出现with语句时，后面的对象必须使用__enter__和__exit__

示例：

class Open:
    def __init__(self, name):
        self.name = name

    def __enter__(self):
        print('执行__enter__')    # 当执行with语句时执行，并且返回值返回给as后的变量


    def __exit__(self, exc_type, exc_val, exc_tb):
        print('执行__exit__') # 当with语句执行完之后，执行__exit__

    # with open('a.txt')as f:
    #     print('执行')
    #     print(f, f.name)
    #

    """如果出现异常，则不会执行with后面的代码都不能正常执行"""

    with open('a.txt')as f:
        print('执行')
        raise AttributeError('主动报错')
    print('会执行吗')

    """ 打印结果为 raise AttributeError('主动报错')
AttributeError: 主动报错"""

4. setattr,delattr,getattr）

        __setattr__,__delattr__,__getattr__

class A:
    y = 100

    def __init__(self, x):
       self.x = x

    """当所查找的属性不存在时，执行__getattr__"""

    def __getattr__(self, item):
        print('找不到了，不执行')

    def __setattr__(self, key, value):
        print('我会执行')
        self.__dict__[key] = value

    def __del__(self, item):
        print('删除')
        self.__dict__.pop(item)

obj = A(10)
print(obj.y)
del obj.x
print(obj.x)

"""执行结果为我会执行
100
找不到了，不执行
None"""

5. __setitem,getitem,delitem__

示例：

class B:
    def __init__(self, name):
        self.name = name

    def __getitem__(self, item):
        print('__getattr__')
        print(self.__dict__[item])

    def __setitem__(self, key, value):
        print('__setattr__')
        self.__dict__[key] = value

    def __delitem__(self, key):
        print('当obj= [key]时执行')
        self.__dict__.pop(key)
        pass

obj = B('mama')
obj['age'] = 18
print(obj.age)
del obj['age']