day 24 内置方法

call

对象后面加括号，触发执行。

注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者类()()

 1 class Foo:
 2 
 3     def __init__(self):
 4         pass
 5     
 6     def __call__(self, *args, **kwargs):
 7 
 8         print('__call__')
 9 
10 
11 obj = Foo() # 执行 __init__
12 obj()       # 执行 __call__

View Code

__eq__

 1 class A:
 2     def __init__(self):
 3         self.a = 1
 4         self.b = 2
 5 
 6     def __eq__(self,obj):
 7         if  self.a == obj.a and self.b == obj.b:
 8             return True
 9 a = A()
10 b = A()
11 print(a == b)

View Code

del

析构方法，当对象在内存中被释放时，自动触发执行。

注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。

 1 class Foo:
 2 
 3     def __del__(self):
 4         print('执行我啦')
 5 
 6 f1=Foo()
 7 del f1
 8 print('------->')
 9 
10 #输出结果
11 执行我啦
12 ------->

简单示范

new

1  简单示范

View Code

 1 class Singleton:
 2     def __new__(cls, *args, **kw):
 3         if not hasattr(cls, '_instance'):
 4             cls._instance = object.__new__(cls, *args, **kw)
 5         return cls._instance
 6 
 7 one = Singleton()
 8 two = Singleton()
 9 
10 two.a = 3
11 print(one.a)
12 # 3
13 # one和two完全相同,可以用id(), ==, is检测
14 print(id(one))
15 # 29097904
16 print(id(two))
17 # 29097904
18 print(one == two)
19 # True
20 print(one is two)

单例模式

item系列

getitem\setitem\delitem

 1 class Foo:
 2     def __init__(self,name):
 3         self.name=name
 4 
 5     def __getitem__(self, item):
 6         print(self.__dict__[item])
 7 
 8     def __setitem__(self, key, value):
 9         self.__dict__[key]=value
10     def __delitem__(self, key):
11         print('del obj[key]时,我执行')
12         self.__dict__.pop(key)
13     def __delattr__(self, item):
14         print('del obj.key时,我执行')
15         self.__dict__.pop(item)
16 
17 f1=Foo('sb')
18 f1['age']=18
19 f1['age1']=19
20 del f1.age1
21 del f1['age']
22 f1['name']='alex'
23 print(f1.__dict__)

View Code

str和repr

改变对象的字符串显示__str__,__repr__

自定制格式化字符串__format__

 1 #_*_coding:utf-8_*_
 2 
 3 format_dict={
 4     'nat':'{obj.name}-{obj.addr}-{obj.type}',#学校名-学校地址-学校类型
 5     'tna':'{obj.type}:{obj.name}:{obj.addr}',#学校类型:学校名:学校地址
 6     'tan':'{obj.type}/{obj.addr}/{obj.name}',#学校类型/学校地址/学校名
 7 }
 8 class School:
 9     def __init__(self,name,addr,type):
10         self.name=name
11         self.addr=addr
12         self.type=type
13 
14     def __repr__(self):
15         return 'School(%s,%s)' %(self.name,self.addr)
16     def __str__(self):
17         return '(%s,%s)' %(self.name,self.addr)
18 
19     def __format__(self, format_spec):
20         # if format_spec
21         if not format_spec or format_spec not in format_dict:
22             format_spec='nat'
23         fmt=format_dict[format_spec]
24         return fmt.format(obj=self)
25 
26 s1=School('oldboy1','北京','私立')
27 print('from repr: ',repr(s1))
28 print('from str: ',str(s1))
29 print(s1)
30 
31 '''
32 str函数或者print函数--->obj.__str__()
33 repr或者交互式解释器--->obj.__repr__()
34 如果__str__没有被定义,那么就会使用__repr__来代替输出
35 注意:这俩方法的返回值必须是字符串,否则抛出异常
36 '''
37 print(format(s1,'nat'))
38 print(format(s1,'tna'))
39 print(format(s1,'tan'))
40 print(format(s1,'asfdasdffd'))

View Code

 1 class B:
 2 
 3      def __str__(self):
 4          return 'str : class B'
 5 
 6      def __repr__(self):
 7          return 'repr : class B'
 8 
 9 
10 b=B()
11 print('%s'%b)
12 print('%r'%b)
13 
14 %s和%r

View Code

  1 # str
  2 # repr
  3 # print(repr('1'))
  4 # print(repr(1))
  5 # print(str(1))
  6 # print(str('1'))
  7 
  8 # l = [1,2,3,4]
  9 # print(l)   # 向文件中写   print替你将数据类型转化成字符串打印出来
 10 
 11 # class List:
 12 #     def __init__(self,*args):
 13 #         self.l = list(args)
 14 #     def __str__(self):
 15 #         return '[%s]'%(','.join([str(i) for i in self.l]))
 16 # l = List(1,2,3,4,5)
 17 # print(l)   #--> l.__str__()   # object类中的__str__就是返回一个数据的内存地址
 18 # print(l)
 19 # print(str(l))
 20 # print('%s'%l)
 21 # print(obj)   的结果 是 obj.__str__()的结果
 22 # str(obj)   的结果 也是 obj.__str__()的结果
 23 # '%s'%obj   的结果 也是 obj.__str__()的结果
 24 
 25 
 26 # class Teacher:
 27 #     def __init__(self,name,age):
 28 #         self.name = name
 29 #         self.age = age
 30 #     def __str__(self):
 31 #         return "Teacher's object %s"%self.name
 32 #     def __repr__(self):
 33 #         return 'repr function %s'%self.name
 34 # a = Teacher('alex',80)
 35 # b = Teacher('egon',80)
 36 # print(a)
 37 # print(b)
 38 # def repr(obj):
 39 #     return obj.__repr__()
 40 
 41 # print(repr(a))   # 函数  打印repr的返回值
 42 # print(a.__repr__())
 43 # print('%r'%a)
 44 # print(str(a))   # 函数 打印str函数的返回值
 45 
 46 # repr(obj)的结果和obj.__repr__()是一样的
 47 # '%r'%(obj)的结果和obj.__repr__()是一样的
 48 
 49 # repr(a)
 50 # print(a)
 51 
 52 # repr(1)
 53 # repr('1')
 54 # 因为 class int
 55 # 和class str
 56 #  中的__repr__方法不一样
 57 # class int:
 58 #     def __repr__(self):
 59 #         return str(1)
 60 
 61 # class str2:
 62 #     def __repr__(self):
 63 #         return "'%s'"%str(1)
 64 
 65 # a = int()
 66 # b = str2()
 67 # print(repr(a))
 68 # print(repr(b))
 69 
 70 
 71 # class Teacher:
 72 #     def __init__(self,name,age):
 73 #         self.name = name
 74 #         self.age = age
 75 #     def __str__(self):
 76 #         return "Teacher's object %s"%self.name
 77     # def __repr__(self):
 78     #     return 'repr function %s'%self.name
 79 # a = Teacher('alex',80)
 80 # b = Teacher('egon',80)
 81 # print(a)
 82 # print(repr(a))
 83 # 当需要使用__str__的场景时找不到 __str__就找__repr__
 84 # 当需要使用__repr__的场景时找不到__repr__的时候就找父类的repr
 85 # 双下repr是双下str的备胎
 86 
 87 # len   __len__
 88 # print(l)   l.__str__
 89 # 010100101   ---> 代码
 90 # class A:
 91 #     pass
 92 # A()   #->
 93 
 94 
 95 # def func(cal):
 96 #     return 1
 97 #
 98 # ret = func('1+2*3-5/5')
 99 
100 # class A:
101 #     def __init__(self):pass
102 #     def __len__(self):pass
103 # def len(obj):
104 #     obj.__len__()
105 # a = A()
106 # a.__len__()
107 # len()   # 为什么要归一化设计呢？
108 # 更接近面向函数编程
109 
110 # str()
111 # print()
112 # %s
113 
114 # len()  obj.__len__()  返回值是一致的
115 # len() 的结果是依赖 obj.__len__()
116 # hash() 的结果是依赖 obj.__hash__()
117 
118 # str() 的结果是依赖 obj.__str__()
119 # print(obj) 的结果是依赖 obj.__str__()
120 # %s 的结果是依赖 obj.__str__()    # 语法糖
121 #
122 # repr() 的结果是依赖 obj.__repr__()
123 # %r 的结果是依赖 obj.__repr__()
124 
125 # repr是str的备胎
126 
127 # __str__
128 # __repr__   一定是选择repr
129 
130 # 核心编程 第2版
131 # 核心编程 第3版
132 # 流畅的python
133 # 数据结构与算法  python 机械工业出版社
134 
135 # object.__repr__()
136 # '%r' # __repr__()
137 # int.__repr__()
138 # str.__repr__()
139 
140 # class Teacher:
141 #     def __init__(self,name,age):
142 #         self.name = name
143 #         self.age = age
144 
145 # @wrapper    func = wrapper(func)
146 # 语法糖   -->
147 
148 # a==b
149 # 1>2
150 # 1+2
151 
152 # format()
153 # __format__
154 # class A:
155 #     def __init__(self,name,school,addr):
156 #         self.name = name
157 #         self.school = school
158 #         self.addr = addr
159 #     def __format__(self,format_spec):
160 #         return format_spec.format(obj=self)
161 
162 
163 # a = A('大表哥','oldboy','沙河')
164 # format_spec = '{obj.name}-{obj.addr}-{obj.school}'
165 # print(format(a,format_spec))
166 
167 
168 # print('{0}-{1}'.format('a','b'))
169 
170 # format_dict={
171 #     'nat':'{obj.name}-{obj.addr}-{obj.type}',#学校名-学校地址-学校类型
172 #     'tna':'{obj.type}:{obj.name}:{obj.addr}',#学校类型:学校名:学校地址
173 #     'tan':'{obj.type}/{obj.addr}/{obj.name}',#学校类型/学校地址/学校名
174 # }
175 # class School:
176 #     def __init__(self,name,addr,type):
177 #         self.name=name
178 #         self.addr=addr
179 #         self.type=type
180 #
181 #     def __format__(self, format_spec):   #format_spec = 'nat'
182 #         if not format_spec or format_spec not in format_dict:
183 #             format_spec='nat'
184 #         fmt=format_dict[format_spec]     #'{obj.name}-{obj.addr}-{obj.type}'
185 #         return fmt.format(obj=self)     #'{obj.name}-{obj.addr}-{obj.type}'.format(obj=self)
186 #
187 # s1=School('oldboy1','北京','私立')
188 # print(format(s1,'nat'))  #s1.__format__('nat')
189 # print(format(s1,'tna'))
190 # print(format(s1,'tan'))
191 # print(format(s1,'asfdasdffd'))
192 
193 
194 # if True:print('执行if中的代码')
195 # if False:print('不执行if中的代码')
196 #
197 # if True or False:print('or两端的条件有一个为True就执行这个if中的代码')
198 # if not True or False:pass
199 # if not False or False:pass
200 # if not format_spec or format_spec not in format_dict
201 # 0  [] '' {} () None

练习代码

  1 # __call__
  2 # __eq__
  3 # __del__
  4 # __new__
  5 # item  对象使用中括号的形式去操作
  6 
  7 # __call__
  8 # class Teacher():
  9 #     def __call__(self):
 10 #         print(123)
 11 #     def call(self):print(123)
 12 # t = Teacher()
 13 # t.call()
 14 # t()   # 对象名() 相当于调用类内置的__call__
 15 # 一个对象是否可调用 完全取决于这个对象对应的类是否实现了__call__
 16 # callable
 17 # print(callable(Teacher))
 18 # print(callable(t))
 19 
 20 # class A:
 21 #     def __eq__(self, other):
 22 #         # if self.__dict__ == other.__dict__:
 23 #             return True
 24 # # __eq__()
 25 # a = A()
 26 # a.name = 'alex'
 27 # b = A()
 28 # b.name = 'egon'
 29 # print(a)
 30 # print(b)
 31 # print(a == b)
 32 
 33 # == 是由__eq__的返回值来决定的
 34 
 35 # __del__ 析构方法:  在删除一个对象的时候做一些首尾工作
 36 # class A:
 37 #     def __init__(self):
 38 #         pass
 39 #         # self.f = open('文件','w')
 40 #     def __del__(self):
 41 #         print('执行我啦')
 42 # a = A()
 43 # del a
 44 # print('aaa')
 45 
 46 # class A:
 47 #     def __init__(self):
 48 #         self.f = open('文件','w')
 49 #     def __del__(self):
 50 #         self.f.close()
 51 #         print('执行我啦')
 52 # a = A()
 53 # del a
 54 # print(a)
 55 # print('aaa')
 56 
 57 # __new__ 构造方法
 58 # 实例化的时候
 59 # 创造对象的过程  __new__
 60 # __init__ 初始化
 61 
 62 # 设计模式 —— 单例模式
 63 # 单例模式 就是 一个类 只能有一个实例
 64 # class A:pass
 65 # a = A()
 66 # b = A()
 67 # print(a)
 68 # print(b)
 69 
 70 # class B:
 71 #     __instance = None
 72 #     def __new__(cls, *args, **kwargs):
 73 #         if cls.__instance is None:
 74 #             obj = object.__new__(cls)
 75 #             cls.__instance = obj
 76 #         return cls.__instance
 77 #     def __init__(self,name,age):
 78 #         self.name = name
 79 #         self.age = age
 80 #     def func(self):
 81 #         print(self.name)
 82 # a = B('alex',80)
 83 # print(a.__dict__)
 84 #
 85 # b = B('egon',20)
 86 # print(a.__dict__)
 87 # print(b)
 88 # print(a.name)
 89 # print(b.name)
 90 
 91 # item
 92 # dic = {'k':'v'}
 93 # print(dic['k'])
 94 
 95 
 96 # class Foo:
 97 #     def __init__(self,name):
 98 #         self.name=name
 99 #
100 #     def __getitem__(self,item):
101 #         return  self.__dict__[item]
102 #
103 #     def __setitem__(self, key, value):
104 #         self.__dict__[key]=value
105 #
106 #     def __delitem__(self, key):
107 #         print('del obj[key]时,我执行')
108 #         self.__dict__.pop(key)
109 
110 # f = Foo('alex')
111 # # f.name = ...
112 # print(f['name'])    # f.__getitem__('name')
113 # f['age']  = 18      # 赋值
114 # print(f.age)         # 自带的语法
115 # print(f['age'])     # 修改
116 # f['age']  = 80
117 # print(f['age'])     # 通过实现__getitem__得到的
118 # del f['age']
119 # print(f.age)         # 删除
120 
121 # class Foo:
122 #     def __init__(self,name):
123 #         self.name=name
124 #     def __delattr__(self, item):
125 #         print('del obj.key时,我执行')
126 #         self.__dict__.pop(item)
127 # f = Foo('alex')
128 # del f.name     #相当于执行了__delattr__
129 # # delattr(f,'name')
130 
131 # 100个同一个类的对象
132 # Person name age sex
133 # 100 name sex
134 # class A:
135 #     pass

练习代码

 1 class FranchDeck:
 2     ranks = [str(n) for n in range(2,11)] + list('JQKA')
 3     suits = ['红心','方板','梅花','黑桃']
 4 
 5     def __init__(self):
 6         self._cards = [Card(rank,suit) for rank in FranchDeck.ranks
 7                                         for suit in FranchDeck.suits]
 8 
 9     def __len__(self):
10         return len(self._cards)
11 
12     def __getitem__(self, item):
13         return self._cards[item]
14 
15 deck = FranchDeck()
16 print(deck[0])
17 from random import choice
18 print(choice(deck))
19 print(choice(deck))

纸牌游戏

 1 class FranchDeck:
 2     ranks = [str(n) for n in range(2,11)] + list('JQKA')
 3     suits = ['红心','方板','梅花','黑桃']
 4 
 5     def __init__(self):
 6         self._cards = [Card(rank,suit) for rank in FranchDeck.ranks
 7                                         for suit in FranchDeck.suits]
 8 
 9     def __len__(self):
10         return len(self._cards)
11 
12     def __getitem__(self, item):
13         return self._cards[item]
14 
15     def __setitem__(self, key, value):
16         self._cards[key] = value
17 
18 deck = FranchDeck()
19 print(deck[0])
20 from random import choice
21 print(choice(deck))
22 print(choice(deck))
23 
24 from random import shuffle
25 shuffle(deck)
26 print(deck[:5])

纸牌游戏2

 1 class Person:
 2     def __init__(self,name,age,sex):
 3         self.name = name
 4         self.age = age
 5         self.sex = sex
 6 
 7     def __hash__(self):
 8         return hash(self.name+self.sex)
 9 
10     def __eq__(self, other):
11         if self.name == other.name and self.sex == other.sex:return True
12 
13 
14 p_lst = []
15 for i in range(84):
16     p_lst.append(Person('egon',i,'male'))
17 
18 print(p_lst)
19 print(set(p_lst))