秀智bigbang,快门3d,情人节惊喜
我要评论 1 class Person(object):
2 def __init__(self, name, age, sex, nationality):
3 self.name = name
4 self.age = age
5 self.sex = sex
6 self.nationality = nationality
7
8 def say(self):
9 print("大家好我叫：%s 今年%d岁了，我是一名%s生来自%s。" % (self.name, self.age, self.sex, self.nationality))
10
11 def __getattr__(self, item):
12 print("当实例获取属性不存在的时候会执行__getattr__方法")
13
14 def __getattribute__(self, item):
15 print("实例获取属性，不管实例dict属性字典里又没有都会执行__getattribute__方法")
16
17
18 class Chinese(Person):
19 pass
20
21
22 if __name__ == "__main__":
23 p1 = Person("里斯", 78, '男', "美国")
24 # p1 实例是否是Person类的一个实例
25 print(isinstance(p1, Person))
26 # issubclass(sub, super)检查sub类是否是 super 类的派生类
27 print(issubclass(Chinese, Person))
isinstance(obj,cls)检查是否obj是否是类 cls 的对象
issubclass(sub, super)检查sub类是否是 super 类的派生类
python面向对象中的反射：通过字符串的形式操作对象相关的属性。python中的一切事物都是对象（都可以使用反射）
hasattr(obj,"属性"):# obj.属性是否存在
getattr(obj,"属性"):# 获取 obj.属性 如果不存在就报错
getattr(obj,"属性","默认值"):# 获取 obj.属性 如果不存在不会报错，并且返回默认的
setattr(obj,"属性"):# 设置属性
delattr(obj,"属性"):# 删除属性
1 # -*- coding: utf-8 -*-
2
3 # 声明字符编码
4 # coding:utf-8
5
6
7 class Person(object):
8 name = "hah"
9
10 def __init__(self, name, age, sex, nationality):
11 self.name = name
12 self.age = age
13 self._sex = sex
14 self.__nationality = nationality
15
16 def say(self):
17 print("大家好我叫：%s 今年%d岁了，我是一名%s生来自%s" % (self.name, self.age, self._sex, self.__nationality))
18
19
20 class Chinese(Person):
21 pass
22
23
24 if __name__ == "__main__":
25 print("\r\n ==============对象的反射============ \r\n")
26 p1 = Person("张三", 18, '男', "中国")
27 p1.say()
28 # 获取 p1 对象里name的值
29 print(getattr(p1, "name"))
30
31 # 判断p1对象里又没有addr属性
32 print(hasattr(p1, "addr"))
33
34 # 设置p1 对象addrs属性并且赋值
35 setattr(p1, "addrs", "四川达州")
36 print(getattr(p1, "addrs"))
37
38 # 删除p1对象addrs属性
39 delattr(p1, "addrs")
40 print(hasattr(p1, "addrs"))
41
42 print("\r\n ==============类的反射（类本质上也是对象）============ \r\n")
43 print(hasattr(Person, "addrs"))
44 print(getattr(Person, "name", "没有这个属性"))
45 setattr(Person, "addrs", "类地址")
46 print(getattr(Person, "addrs"))
47 delattr(Person, "name")
48 print(hasattr(Person, "name"))
importlib---动态导入模块
1 # -*- coding: utf-8 -*-
2
3 # 声明字符编码
4 # coding:utf-8
5
6 from Python基础.myImport import chufa
7 import importlib
8
9 if __name__ == "__main__":
10 # 第一种导入调用
11 # print(chufa(1000,50))
12
13 # 第二种：动态导入模块
14 # m1 = __import__("myImport")
15 # print(m1)
16 # # 调用模块里的方法
17 # print(m1.chufa(10,2))
18
19 # # 第三中：动态导入模块
20 # m2 = importlib.import_module("myImport")
21 # print(m2)
22 # print(m2.chufa(4,2))
23 m3 = importlib.import_module("modular.sendMsg")
24 print(m3)
25 print(m3.SendMsage())
__getattr__:不存在的时候出发 __setattr__:设置属性的值的时候出发 __delattr__:删除属性的时候出发
1 # -*- coding: utf-8 -*-
2
3 # 声明字符编码
4 # coding:utf-8
5
6 """
7 __getattr__:不存在的时候出发
8 __setattr__:设置属性的值的时候出发
9 __delattr__:删除属性的时候出发
10
11 """
12
13
14 class Person(object):
15 def __init__(self, name, age, sex, nationality):
16 self.name = name
17 self.age = age
18 self.sex = sex
19 self.nationality = nationality
20
21 def say(self):
22 print("大家好我叫：%s 今年%d岁了，我是一名%s生来自%s。" % (self.name, self.age, self.sex, self.nationality))
23
24 def __getattr__(self, item):
25 print("执行了__getattr__")
26
27 def __setattr__(self, key, value):
28 print("执行了__setattr__")
29 # 实际上就是操作属性字典
30 self.__dict__[key] = value
31
32 def __delattr__(self, item):
33 print("执行了__delattr__")
34 self.__dict__.pop(item)
35
36
37 class Chinese(Person):
38 pass
39
40
41 class American(Person):
42 pass
43
44
45 class Korean(Person):
46 pass
47
48
49 class Japanese(Person):
50 pass
51
52
53 if __name__ == "__main__":
54 pass
55 # # 因为在类中重写了设置属性的方法，然而代码里并没有正在设置上，所以调用say会报错
56 # p1 = Person("张三",18,'男',"中国")
57 # p1.say()
58
59 # 修改后在执行
60 p1 = Person("张三", 18, '男', "中国")
61 p1.say()
62 del p1.name
63 print(hasattr(p1, "name"))
1 # -*- coding: utf-8 -*-
2
3 # 声明字符编码
4 # coding:utf-8
5
6 import time
7
8
9 class FileHelper(object):
10 def __init__(self, filepath, model="r", encoding='utf-8'):
11 self.file = open(filepath, mode=model, encoding=encoding)
12
13 def __getattr__(self, item):
14 # item 是字符串类型
15 # 通过getattr()获取 self.file 中的方法
16 return getattr(self.file, item)
17
18 def write(self, line):
19 # 在每次写入的内容前面加上时间
20 t = time.strftime("%Y-%m-%d %X")
21 self.file.write('%s %s' % (t, line + "\r\n"))
22
23
24 if __name__ == "__main__":
25 f1 = FileHelper("../files/Log/logger.log", 'w', encoding='utf-8')
26 f1.write("锄禾日当午")
27 f1.write("汗滴禾下土")
28 f1.write("谁知盘中餐")
29 f1.write("粒粒皆辛苦")
30
31 f1 = FileHelper("../files/Log/logger.log", 'r', encoding='utf-8')
32 # f1.read() 首先在f1实例中的__dict__数据字典中去找read方法，如果没有就去FileHelper类中的__dict__数据字典中找，如果还是没有
33 # 就报错，如果在FileHelper中重写的__getattr__方法，就执行该方法。所以在该方法中通过self.file属性中去找，self.file就是系统的open对象。
34 content = f1.read()
35 print(content)
1 class Chinese(Person):
2
3 def __getitem__(self, item):
4 print("执行了__getitem__")
5
6 def __setitem__(self, key, value):
7 print("执行了__setitem__")
8
9 def __delitem__(self, key):
10 print("执行了__delitem__")
11 c1 = Chinese("李四",14,"女","中国")
12 c1["addrs"] = "四川成都"
13 c1['addrs']
14 del c1["addrs"]
1 # -*- coding: utf-8 -*-
2
3 # 声明字符编码
4 # coding:utf-8
5
6 class Person(object):
7 def __init__(self, name, age, sex, nationality):
8 self.name = name
9 self.age = age
10 self.sex = sex
11 self.nationality = nationality
12
13 def say(self):
14 print("大家好我叫：%s 今年%d岁了，我是一名%s生来自%s。" % (self.name, self.age, self.sex, self.nationality))
15
16 def __getattr__(self, item):
17 print("当实例获取属性不存在的时候会执行__getattr__方法")
18
19 def __getattribute__(self, item):
20 print("实例获取属性，不管实例dict属性字典里又没有都会执行__getattribute__方法")
21
22
23
24 if __name__ == "__main__":
25 p1 = Person("里斯", 78, '男', "美国")
26 # p1 实例是否是Person类的一个实例
27 print(isinstance(p1, Person))
28 # issubclass(sub, super)检查sub类是否是 super 类的派生类
29 print(issubclass(Chinese, Person))
30
31 # getattribute方法
32 # addrs不存在与p1的dict属性字典里，所以会执行getattr方法
33 p1.addrs
34 p1.name
35 """
36 当实例中同时具有__getattr__和__getattribute__方法时候，都只会执行__getattribute__方法，如果__getattribute__方法里有
37 抛出AttributeError异常，就会出发 __getattr__方法。
38
39 """
总结
obj点的方式操作属性时候出发
__getattr__:不存在的时候出发
__setattr__:设置属性的值的时候出发
__delattr__:删除属性的时候出发
obj['属性']的的方式操作属性的时候出发
__getitem__:不存在的时候出发
__setitem__:设置属性的值的时候出发
__delitem__:删除属性的时候出发
def __get__():
pass
def __set__():
pass
def __del__():
pass
描述的就是一个新式类，这个类至少实现上述三个方法中的一个
改变对象的字符串显示__str__,__repr__
1 # -*- coding: utf-8 -*-
2
3 # 声明字符编码
4 # coding:utf-8
5
6 # 改变对象的字符串显示__str__,__repr__
7
8 class Person(object):
9 def __init__(self, name, age, sex, nationality):
10 self.name = name
11 self.age = age
12 self.sex = sex
13 self.nationality = nationality
14
15 def say(self):
16 print("大家好我叫：%s 今年%d岁了，我是一名%s生来自%s。" % (self.name, self.age, self.sex, self.nationality))
17
18 def __str__(self):
19 return '重写str方法，默认就返回我啦！！！'
20
21 def __repr__(self):
22 return '通过解释器执行后返回的'
23
24
25 if __name__ == "__main__":
26 # 实例中没有__str__函数，打印实例 地址，加了之后，打印重写后返回的内容。
27 p1 = Person("小村伊朗", 78, '妖', '小岛')
28 print(p1)
高效的求斐波拉契数列方法
1 # -*- coding: utf-8 -*- 2 3 # 声明字符编码 4 # coding:utf-8 5 6 class FeiBoLa(object): 7 def __init__(self): 8 self.__a = 1 9 self.__b = 1 10 11 def __iter__(self): 12 return self 13 14 def __next__(self): 15 self.__a, self.__b = self.__b, self.__a + self.__b 16 return self.__a 17 18 19 if __name__ == "__main__": 20 f = FeiBoLa() 21 print(f.__next__()) 22 print(f.__next__()) 23 print(f.__next__()) 24 print(f.__next__()) 25 print(f.__next__())
with MyOpen('a.txt') as f:
print(f)
print('执行代码块')
1 # -*- coding: utf-8 -*-
2
3 # 声明字符编码
4 # coding:utf-8
5 """
6
7
8 案例：
9 with MyOpen('a.txt','r',encoding='utf-8') as f:
10 pass
11
12
13 __enter__(): MyOpen('a.txt','r',encoding='utf-8') 会触发 MyOpen类中的__enter__方法
14 __exit__():执行完代码块中的代码后出发 __exit__方法。
15
16 """
17
18
19 class MyOpen(object):
20 def __init__(self, path, model='r', encoding='utf-8'):
21 self.path = path
22 self.model = model
23 self.encoding = encoding
24
25 def __enter__(self):
26 print('执行了enter方法.....')
27
28 def __exit__(self, exc_type, exc_val, exc_tb):
29 # 如果发生异常 对应三个值的说明
30 # exc_type：异常类, exc_val：异常值, exc_tb：异常追踪信息
31 print('执行了exit方法......')
32 print(exc_type)
33 print(exc_val)
34 print(exc_tb)
35 return False
36
37
38 if __name__ == "__main__":
39 with MyOpen('a.txt') as f:
40 print(f)
41 print('执行代码块')
案例：
描述符类装饰器给类动态添加属性
1 # -*- coding: utf-8 -*-
2
3 # 声明字符编码
4 # coding:utf-8
5
6 # 类属性描述
7 class AttrDesc:
8
9 def __init__(self, attr_name, attr_type):
10 self.attr_name = attr_name
11 self.attr_type = attr_type
12
13 def __get__(self, instance, owner):
14 return instance.__dict__[self.attr_name]
15
16 def __set__(self, instance, value):
17 if not isinstance(value, self.attr_type):
18 raise TypeError("%s值的类型不是:%s" % (self.attr_name, self.attr_type))
19 instance.__dict__[self.attr_name] = value
20
21 def __delete__(self, instance):
22 return instance.__dict__.pop(self.attr_name)
23
24
25 # 限制类属性类型装饰器
26 def add_attr(**kwargs):
27 def add(obj):
28 for key, val in kwargs.items():
29 setattr(obj, key, AttrDesc(key, val))
30
31 return obj
32
33 return add
34
35
36 @add_attr(height=float, weigt=float, name=str)
37 class Person(object):
38 def __init__(self, name, age, sex, nationality):
39 self.name = name
40 self.age = age
41 self.sex = sex
42 self.nationality = nationality
43
44 def say(self):
45 print("大家好我叫：%s 今年%d岁了，我是一名%s生来自%s。" % (self.name, self.age, self.sex, self.nationality))
46
47
48 if __name__ == "__main__":
49 p1 = Person('小明', 12, '男', '中国')
50 p1.height = 2.19
51 print(Person.__dict__)
案例：自定义property
可以让一个方法 看起来像一个属性，使用的时候对象点出来即可
1 # -*- coding: utf-8 -*-
2
3 # 声明字符编码
4 # coding:utf-8
5
6 class LazyPropery:
7 def __init__(self, func):
8 self.func = func
9
10 def __get__(self, instance, owner):
11 print(instance)
12 print(owner)
13 if instance is None:
14 return self
15 return self.func(instance)
16
17
18 class Person(object):
19 def __init__(self, name, age, sex, nationality):
20 self.name = name
21 self.age = age
22 self.sex = sex
23 self.nationality = nationality
24
25 # 标记上@property 变为静态属性，这样就可以通过实例名点方法名调用。
26 @property
27 def say(self):
28 print("大家好我叫：%s 今年%d岁了，我是一名%s生来自%s。" % (self.name, self.age, self.sex, self.nationality))
29
30
31 class Chinese(Person):
32
33 @LazyPropery
34 def run(self):
35 print('run')
36 return '我是%s' % self.name
37
38
39 if __name__ == "__main__":
40 print("\r\n======系统内置property=====\r\n")
41 p1 = Person('王二小', 12, '女', '中国')
42 p1.say
43 print("\r\n======自定义的property=====\r\n")
44 c1 = Chinese('王二', 15, '女', '中国')
45 print(c1.run)
工厂模式案例：
1 # -*- coding: utf-8 -*-
2
3 # 声明字符编码
4 # coding:utf-8
5 '''
6 在父类中定义，在子类中实现 ========工厂模式
7 '''
8
9
10 # 店铺类
11 class Store(object):
12 def select_car(self):
13 pass
14
15 def Order(self, car_type):
16 return self.select_car(car_type)
17
18
19 # 宝马4S店
20 class BMStore(Store):
21 def select_car(self, car_type):
22 return BMFactory().select_car_by_type(car_type)
23
24
25 # 桑塔纳4S店
26 class STNStore(Store):
27 def select_car(self, car_type):
28 return STNFactory().select_car_by_type(car_type)
29
30
31 # 雪佛兰4S店
32 class XFLStore(Store):
33 def select_car(self, car_type):
34 return XFLFactory().select_car_by_type(car_type)
35
36
37 # 宝马工厂
38 class BMFactory(object):
39 def select_car_by_type(self, car_type):
40 if car_type == "宝马X": return BaoMaX()
41 if car_type == "宝马XX": return BaoMaXX()
42 if car_type == "宝马XXX": return BaoMaXXX()
43
44
45 # 桑塔纳工厂
46 class STNFactory(object):
47 def select_car_by_type(self, car_type):
48 if car_type == "桑塔纳Q": return SangTaNaQ()
49 if car_type == "桑塔纳QQ": return SangTaNaQQ()
50
51
52 # 雪佛兰工厂
53 class XFLFactory(object):
54 def select_car_by_type(self, car_type):
55 if car_type == "雪佛兰T": return XueFuLanT()
56 if car_type == "雪佛兰TT": return XueFuLanTT()
57
58
59 # 整个车类
60 class Car(object):
61 def move(self):
62 print("车在移动......")
63
64 def music(self):
65 print("车里再放音乐....")
66
67 def stop(self):
68 print("车停下了.......")
69
70
71 # 宝马车类
72 class BaoMa(Car):
73 pass
74
75
76 class BaoMaX(BaoMa):
77 pass
78
79
80 class BaoMaXX(BaoMa):
81 pass
82
83
84 class BaoMaXXX(BaoMa):
85 pass
86
87
88 # 桑塔纳车类
89 class SangTaNa(Car):
90 pass
91
92
93 class SangTaNaQ(SangTaNa):
94 pass
95
96
97 class SangTaNaQQ(SangTaNa):
98 pass
99
100
101 # 雪佛兰车类
102 class XueFuLan(Car):
103 pass
104
105
106 class XueFuLanT(XueFuLan):
107 pass
108
109
110 class XueFuLanTT(XueFuLan):
111 pass
112
113
114 stor = BMStore()
115 s = stor.Order("宝马XX")
116 s.move()
117 s.music()
118 s.stop()
简单工厂模式案例：
1 # -*- coding: utf-8 -*-
2
3 # 声明字符编码
4 # coding:utf-8
5
6
7 #<region 简单工厂模式>
8
9 # 店铺类
10 class CarStore(object):
11 def __init__(self):
12 self.factory = Factory()
13 def Order(self,car_type):
14 return self.factory.select_car_by_type(car_type)
15
16
17 # # 店铺类
18 # class CarStore(object):
19 # def Order(self,car_type):
20 # return select_car_by_type(car_type)
21
22
23
24 class Factory(object):
25 def select_car_by_type(self,car_type):
26 if car_type =="宝马":return BaoMa()
27 if car_type == "桑塔纳":return SangTaNa()
28 if car_type == "雪佛兰":return XueFuLan()
29
30 # # 函数（达到了解耦性）
31 # def select_car_by_type(car_type):
32 # if car_type =="宝马":return BaoMa()
33 # if car_type == "桑塔纳":return SangTaNa()
34 # if car_type == "雪佛兰":return XueFuLan()
35
36 # 整个车类
37 class Car(object):
38 def move(self):
39 print("车在移动......")
40 def music(self):
41 print("车里再放音乐....")
42 def stop(self):
43 print("车停下了.......")
44
45
46 # 宝马车类
47 class BaoMa(Car):
48 pass
49 # 桑塔纳车类
50 class SangTaNa(Car):
51 pass
52 # 雪佛兰车类
53 class XueFuLan(Car):
54 pass
55
56
57
58
59 stor = CarStore()
60 s = stor.Order("宝马")
61 s.move()
62 s.music()
63 s.stop()
64
65 #<endregion>
如对本文有疑问，请在下面进行留言讨论，广大热心网友会与你互动！！ 点击进行留言回复
新手学习Python2和Python3中print不同的用法
Python基于os.environ从windows获取环境变量
网友评论