组合
它不是一个新的技术栈,它是对象的另外一种用法
什么是组合?
组合就是,一个对象拥有一个属性,该属性的值是另外一个对象.
class Foo:
def __init__(self, m):
self.m = m
class Bar():
def __init__(self, n):
self.n = n
"""一个对象拥有一个属性,该属性的值是另外一个对象."""
obj=Bar(10)
obj1 = Foo(20)
# 超级对象,通过一个属性可以访问到另外一个对象的值
obj.x=obj1
print(obj.x.m)
"""什么场景下使用继承? 什么场景下使用组合?"""
继承一般情况用在:什么是什么的情况 is
组合一般用在:什么有什么的情况 has
class People():
school = 'SH'
def __init__(self, name, age, gender, course_name=None, course_price=None, course_period=None):
self.name = name
self.age = age
self.gender = gender
self.course_name = course_name
self.course_price = course_price
self.course_period = course_period
class Admin(People):
def __init__(self, name, age, gender):
super().__init__(name, age, gender)
class Course():
def __init__(self, name, price, period):
self.name = name
self.price = price
self.period = period
python=Course('python', 10000, '6mon')
linux=Course('linux', 20000, '5mon')
# print(python.name)
# print(python.price)
# print(python.period)
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('kevin', 20, 'male')
stu.course.append(python.name)
stu.course.append(linux.name)
print(stu.course) # [<__main__.Course object at 0x000001F258F86B80>, <__main__.Course object at 0x000001F258F511C0>]
# stu.course: []
for i in stu.course:
print(i)
class Teacher(People):
def __init__(self, name, age, gender, level):
super().__init__(name, age, gender)
self.level = level
tea = Teacher('ly', 19, 'female', 10)
print(tea.course_name)
tea.course=linux
print(tea.course.name)
print(tea.course.price)
反射
在Python中,反射指的是通过字符串来操作对象的属性,涉及到四个内置函数的使用(Python中一切皆对象,类和对象都可以用下述四个方法)
四个内置函数:
getattr: 获取属性 ##### 用的最多
setattr:设置属性
hasattr:判断是否有某个属性
delattr:删除
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('kevin', 20)
# attr=input('请输入你要操作的属性名:')
# print(stu.school)
# print(stu."school")
"""反射:就是通过字符串的形式来操作对象的属性"""
# 1. 获取属性
"""当你查询的属性不存在的时候,如果给了第三个参数,就返回第三个参数"""
# res=getattr(stu, 'school1', 666) # SH 666
"""如果你给了第三个参数,查询的属性也存在,那就直接返回属性对应的值,默认值就没用了"""
# res=getattr(stu, 'school', 666) # SH 666
# res1=getattr(stu, 'name') # SH
# res2=getattr(stu, 'age') # SH
# print(res,res1, res2)
# print(stu.school)
# print(res)
### 函数的用法
"""必须掌握!!!!!!"""
# res=getattr(stu, 'func1', stu.index) #### 用的是最多的
# print(res) # <bound method Student.func of <__main__.Student object at 0x000001963F5C5A60>>
# res()
### 设置
# setattr(stu, 'x', 666) # stu.x=666
# print(stu.__dict__)
### hasattr
print(hasattr(stu, 'func'))
if hasattr(stu, 'func'):
getattr(stu, 'func')()
else:
...
### delattr
# delattr(stu, 'name')
# del stu.name
# print(stu.__dict__)
# import time
# time=__import__('time') # import time
# print(time.time())
random=__import__('random')
print(random.randint(0,8))
内置方法之魔术方式
它的特点就是双下划线开头的方法,它满足一定的条件就会自动触发,简称魔法
聊聊面向对象中得魔术方法有哪些? 怎么用?
1. __init__
2. __str__,__repr__
class Student():
def __init__(self, name, age):
self.name = name
self.age = age
"""
1. 打印对象的时候,输出对象的时候会自动触发类中得__str__方法
2. 返回值必须是字符串形式
3. 如果它跟__repr__方法同时存在,__str__的优先级更高
"""
def __str__(self): # 这个用的是最多的
print('str')
return 'from str'
def __repr__(self):
print('repr')
return 'from repr'
stu = Student('ly', 20)
# print(stu) # <__main__.Student object at 0x00000226AC4F5A60>
# print('repr:', repr(stu))
print('str:', str(stu))
class MySQL:
def __init__(self, ip, port):
self.ip = ip
self.port = port
self.f = open('a.txt', 'w')
"""
1.当你删除对象的时候会触发__del__的执行
2. 当整个脚本的程序都执行完毕的时候,也会触发__del__的执行
3. 一般用在用来在对象被删除时自动触发回收系统资源的操作
"""
def __del__(self):
print('from _del')
self.f.close()
mysql = MySQL('127.0.0.1', 3306)
print('1223')
print('1223')
print('1223')
print('1223')
print('1223')
print(isinstance(123, str))
print(type(123) is int)
class Foo:
pass
class Bar(Foo):
pass
class Bar1():
pass
print(issubclass(Bar1, Foo))
class Foo:
"""
'我是描述信息asdasd'
'我是描述信息asdasd'
'我是描述信息asdasd'
"""
pass
class Bar(Foo):
pass
print(Bar.__doc__)
enter_和_exit
lass Open:
def __init__(self, name):
self.name = name
def __enter__(self):
print('出现with语句,对象的__enter__被触发,有返回值则赋值给as声明的变量')
# return self
def __exit__(self, exc_type, exc_val, exc_tb):
print('with中代码块执行完毕时执行我啊')
"""with它可以用在很多地方,但是,出现with语句后面的对象中得类必须要声明__enter__和__exit__"""
with Open('a.txt') as f:
print('=====>执行代码块')
print('=====>执行代码块')
print('=====>执行代码块')
print('=====>执行代码块')
print('=====>执行代码块')
# print(f,f.name)
简答题:先聊聊with 的用法? 问with上下文管理协议的执行原理? 为什么打开文件只会可以自动关闭?请说出原因
class Open:
def __init__(self, name):
self.name = name
def __enter__(self):
print('出现with语句,对象的__enter__被触发,有返回值则赋值给as声明的变量')
# return self
def __exit__(self, exc_type, exc_val, exc_tb):
print('with中代码块执行完毕时执行我啊')
print(exc_type) # 异常类型
print(exc_val) # 异常值
print(exc_tb) # 追溯信息
return True # 如果你在这个方法里面返回了True,with代码块中出现了异常,就相当于没有出现异常
"""with它可以用在很多地方,但是,出现with语句后面的对象中得类必须要声明__enter__和__exit__"""
# with Open('a.txt') as f:
# print('=====>执行代码块')
# print('=====>执行代码块')
# print('=====>执行代码块')
# print('=====>执行代码块')
# print('=====>执行代码块')
# # print(f,f.name)
"""如果with代码块中出现了异常,则with语句之后的代码都不能正常执行"""
with Open('a.txt') as f:
print('=====>执行代码块')
raise AttributeError('***着火啦,救火啊***') # 抛出异常,主动报错
print('0'*100) #------------------------------->不会执行
setitem,__getitem,delitem
__setitem__,__getitem,__delitem__
class Foo:
def __init__(self, name):
self.name = name
"""当你通过中括号获取对象的属性的时候,会自动触发__getitem__"""
def __getitem__(self, item):
print('__getitem__')
print(self.__dict__[item])
def __setitem__(self, key, value):
# key:age
# value:18
print('__setitem__')
self.__dict__[key] = value
# self.__dict__['age'] = 18
def __delitem__(self, key):
print('del obj[key]时,我执行')
self.__dict__.pop(key)
pass
# def __delattr__(self, item):
# print('del obj.key时,我执行')
# self.__dict__.pop(item)
obj=Foo('tom')
# print(obj.name)
# obj['name']
obj['age'] = 18
# obj.age=18
print(obj.age)
del obj['age']
call
class Foo:
def __init__(self):
pass
#### 当对象加括号的时候会触发__call__的执行
def __call__(self, *args, **kwargs):
print('__call__')
obj=Foo()
print(obj)
obj()