__new__ 创建一个对象
class A:
def __init__(self):
print('in init')
def __new__(cls):
print('in new')
self=object.__new__(cls)#创建一个对象
return self #再返回给self
# object.__new__()#创造对象
a=A
__new__ 构造方法
__init__ 初始化方法
算法和设计模式
设计模式--java开发过程中的一种规范或者设计模式
单例模式*****
创造一个类，这个类始终只有一个实例 ——单例模式
class A:
__mmp=None
def __init__(self,name):
self.name=name
def __new__(cls,*args,**kwars):
if not cls.__mmp:
cls.__mmp=object.__new__(cls)#创造一个空间(对象），cls相当于A
return cls.__mmp#再返回给self
a=A('aaa')
b=A('bbb')
print(a)#打印的是内存地址
print(b)#a,b内存地址相同
print(a.name)#bbb
print(b.name)#bbb
图解
__del__析构方法
对应着一个对象删除之前执行的内容
@property deleter 将方法伪装成属性，执行删除该属性
delattr 使用字符串变量名从命名空间中删除这个变量
class B:
def __del__(self):print('执行我了')#2
b=B()
print(b.__dict__)#{} 1
del b #调用__del__方法，从内存中将d删除 3
print(b.__dict__)
python 解释器
能够主动回收不用的变量
在程序结束的时候所有的数据都会被清除
如果用户主动删除某个变量
那么这个变量将会主动被删除
无论上述哪种方法
在删除一个变量之前都会主动的执行析构方法__del__
class B:
def __init__(self,path):
self.f=open(path)
def __del__(self):#对象删除之前回归一些系统资源
self.f.close()
b=B('userinfo')
item 系列--打辅助的功能
实现了之后，就可以使用对象[]去做一些事情了
lst=[1,2,3] print(lst[0]) dic={'k':'v'} print(dic['k'])
有些内置模块中的内置方法
是依赖__getitem__方法的
或者说是依赖item['a']这种调用方式的
class Item:
def __getitem__(self,item): # ***
print('-->',item)
return 'hello'
def __setitem__(self,key,value):
print(key,value)#a,b
item=Item()
print(item['a'])#--> a hello 此时的item['a']是查看值，调用的是__getitem__函数
item['a']='b'#赋值时调用的是__setitem__函数
print(item['a'])#--> a hello
此时__getitem__和__setitem__没有一点关系
class Item:
def __getitem__(self,item): # ***
print('-->',item)
return self.__dict__[item]
def __setitem__(self,key,value):
self.__dict__[key]=value
print(key,value)#a,b
item=Item()
print(item.__dict__)#{}
# print(item['a'])#不能先调用self.__dict__[item]，此时self没值，self.__dict__空间是空的，会报错。
item['a']='b'#赋值时调用的是__setitem__函数
print(item['a'])#--> a hello 此时的item['a']是查看值，调用的是__getitem__函数
此时__getitem__和__setitem__没有一点关系
class Item:?
def __getitem__(self,item): # ***
print('-->',item)
return self.__dict__[item]
def __setitem__(self,key,value):
self.__dict__[key]=value
print(key,value)
def __delitem__(self,key):
self.__dict__.pop(key)
item=Item()
print(item.__dict__)#{}
# print(item['a'])#不能先调用self.__dict__[item]，此时self没值，self.__dict__空间是空的，会报错。
item['a']='b'#a,b
print(item['a'])#-->a, b ?
print(item.a)#b ?
print(item.__dict__)#{'a': 'b'}
# del item.a
del item['a']
print(item.__dict__)#{}
python魔法方法__len__,__getitem__,__setitem__,__delitem__
python中除了可以使用内建的类型，如list,tuple,dict，还可以创建自己的对象来实现像这些内建类型的访问，
不过需要在定义类的时候对一些魔法方法逐一实现
class DictDemo:
def __init__(self,key,value):
self.dict = {}
self.dict[key] = value
def __getitem__(self,key):
return self.dict[key]
def __setitem__(self,key,value):
self.dict[key] = value
dictDemo = DictDemo('key0','value0')
print(dictDemo['key0']) #value0
dictDemo['key1'] = 'value1'
print(dictDemo['key1']) #value1
上面的对象就相当于自己创建了一个内建类型相似的字典，当实例中有类似字典的操作的时候
比如：
[python] view plain copy
dictDemo1 = {"key0":"value0"}
print(dictDemo1["key0"]) #value0
实例dictDemo["key0"]就类似上面的的操作，则会自动调用类中定义的方法__getitem__，输出在该方法返回的值
再看看dictDemo["key1"] = "value1"，就是字典的操作，会自动调用类中定义的方法__setitem__，来设置相应的值
还有一个__del__，就是当我们要删除一个元素的时候调用（魔法方法会自动调用）
__len__ 如下：
当要使用内建函数len()，而参数是DictDemo的实例的时候，那一定要实现类型中的__len__()方法
[python] view plain copy
class DictDemo:
def __init__(self,key,value):
self.dict = {}
self.dict[key] = value
def __getitem__(self,key):
return self.dict[key]
def __setitem__(self,key,value):
self.dict[key] = value
def __len__(self):
return len(self.dict)
dictDemo = DictDemo('key0','value0')
print(dictDemo['key0']) #value0
dictDemo['key1'] = 'value1'
print(dictDemo['key1']) #value1
print(len(dictDemo)) #2
class List(list):
def append(self, obj):
if type(obj) is str:
super().append(obj)#调用父类的方法，list.append(obj)
else:
# print(f'{obj}不是字符串类型')
print('%s不是字符串类型' % obj)
def show_middle(self):
return self[int(len(self) / 2)]#返回以长度的一半为索引的self的值
li = List('hello word22222')#['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'd', '2', '2', '2', '2', '2', '18', 'abc']
li.append('18')
li.append('abc')
print(li)
print(li.show_middle())#r
扑克牌
from collections import namedtuple
Card = namedtuple('Card',['rank','suit']) # 属性一旦创建就不再改变了，且可以使用属性名直接访问值
card1 = Card('K','黑桃')
print(card1.rank)
print(card1.suit)
class FranchDeck:
ranks = [str(n) for n in range(2,11)] + list('JQKA')
suits = ['红心','方板','梅花','黑桃']
def __init__(self):
self._cards = [Card(rank,suit) for rank in FranchDeck.ranks
for suit in FranchDeck.suits]
def __len__(self):
return len(self._cards)
def __getitem__(self, item):
return self._cards[item]
deck = FranchDeck()
# print(deck._cards[0]) #
print(deck[0])
from random import choice
print(choice(deck)) # choice接收iterable,__len__,__getitem__
print(choice(deck._cards)) # choice接收iterable,__len__,__getitem__
print(choice(deck))
print(choice(deck))
print(choice(deck))
print(choice(deck))
from collections import namedtuple
Card = namedtuple('Card',['rank','suit'])
class FranchDeck:
ranks = [str(n) for n in range(2,11)] + list('JQKA')
suits = ['红心','方板','梅花','黑桃']
def __init__(self):
self._cards = [Card(rank,suit) for rank in FranchDeck.ranks
for suit in FranchDeck.suits]
def __len__(self):
return len(self._cards)
def __getitem__(self, item):
return self._cards[item]
def __setitem__(self, item,value):
self._cards[item] = value
deck = FranchDeck()
from random import shuffle
# shuffle(deck._cards)
# print(deck._cards)
shuffle(deck) # __len__(self) __getitem__ __setitem__
print(deck._cards)
异常处理
捕捉异常可以使用try/except语句。
try/except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理。
如果你不想在异常发生时结束你的程序，只需在try里捕获它。
语法：
以下为简单的try....except...else的语法：
try: <语句> #运行别的代码 except <名字>： <语句> #如果在try部份引发了'name'异常 except <名字>，<数据>: <语句> #如果引发了'name'异常，获得附加的数据 else: <语句> #如果没有异常发生
try的工作原理:
当开始一个try语句后，python就在当前程序的上下文中作标记，这样当异常出现时就可以回到这里，try子句先执行，接下来会发生什么依赖于执行时是否出现异常。
- 如果当try后的语句执行时发生异常，python就跳回到try并执行第一个匹配该异常的except子句，异常处理完毕，控制流就通过整个try语句（除非在处理异常时又引发新的异常）。
- 如果在try后的语句里发生了异常，却没有匹配的except子句，异常将被递交到上层的try，或者到程序的最上层（这样将结束程序，并打印缺省的出错信息）。
- 如果在try子句执行时没有发生异常，python将执行else语句后的语句（如果有else的话），然后控制流通过整个try语句。
aaa # NameError
int('a') #ValueError
[][4] #IndexError
class A:pass
a = A()
a.name #AttributeError
print('aaaa')
def func():name
def main():
func()
main()
语法错误和逻辑错误
l = [1,2,3,4]
num = input('num : ')
if num.isdigit():
num = int(num)
if num < len(l)-1 and num >0:
print(l[num])
l = [1,2,3,4]
try:
num = int(input('num : '))
print(l[num])
except ValueError:
print('请输入一个数字')
except IndexError:
print('输入的数字超出范围')
try中的代码
一旦在一个地方发生错误
后面的代码就不执行了
会直接跳到except的位置
一个错误类型只能处理一种错误
出现异常之后
会从上到下去匹配except中的error
一旦匹配上就会执行except中的代码
执行完之后不再执行其他except
万能异常
l = [1,2,3,4]
try:
num = int(input('num : '))
print(l[num])
# except: # 所有的错误都能处理
# print('万能的异常')
# except Exception:
# print('万能的异常')
except Exception as e:
print(e)
l = [1,2,3,4]
try:
num = int(input('num : '))
print(l[num])
name
except ValueError:
print('请输入一个数字')
except IndexError:
print('输入的数字超出范围')
except Exception as e:
print(e)
有多个except的时候 万能异常永远在最后
l = [1,2,3,4]
try:
num = int(input('num : '))
print(l[num])
except ValueError:
print('请输入一个数字')
except IndexError:
print('输入的数字超出范围')
else:
print('执行我了')
else中的代码 在try中的代码全部顺利执行之后才执行
如果try中的代码出现错误，那么else就不执行
else中的代码什么时候用呢？
在代码顺利执行的时候，报成功或者报结果的时候使用的
try except格式
try except else格式
l = [1,2,3,4]
try:
f = open('')
# num = int(input('num : '))
# print(l[num])
# except ValueError:
# print('请输入一个数字')
# except IndexError:
# print('输入的数字超出范围')
# else:
# print('执行我了')
finally:
print('finally被执行了')
def func():
try:
f = open('file','w')
content = f.read()
return content
finally:
f.close()
finally
不管代码是否出错，都是一个无论如何会执行的代码
打开的操作系统的资源不管代码执行是否出错，都应该归还
这样的代码就应该写在finally中
try except格式
try except else格式
try except else finally格式
try finally格式
主动的抛一个异常
raise TypeError
raise TypeError('出现了不可思议的TypeError')
条件判断
assert 1==1
print('''aaaaaa''')
class EvaException(BaseException):
def __init__(self,msg):
self.msg=msg
raise EvaException('类型错误')
eva = EvaException('类型错误')
try:
raise EvaException('类型错误')
except EvaException as e:
print(e)
123