一、成员修饰符
公有成员
私有成员, __字段名
- 无法直接访问，只能间接访问
class Foo:
def __init__(self,name,age):
self.name = name
#self.age = age
self.__age = age
obj = Foo()
obj.name
#obj.age
obj.__age
二、特殊成员
__init__ 类()自动执行
__del__
__call__ 对象() 类()() 自动执行
__int__ int(对象)
__str__ str()
__add__
__dict__ # 将对象中封装的所有内容通过字典的形式返回
__getitem__ # 切片（slice类型）或者索引
__setitem__
__delitem__
__iter__
# 如果类中有 __iter__ 方法，对象=》可迭代对象
# 对象.__iter__() 的返回值： 迭代器
# for 循环，迭代器，next
# for 循环，可迭代对象，对象.__iter__()，迭代器，next
# 1、执行li对象的类F类中的 __iter__方法，并获取其返回值
# 2、循环上一步中返回的对象
三、metaclass,类的祖宗
a. Python中一切事物都是对象
b.
class Foo:
pass
obj = Foo()
# obj是对象，Foo类
# Foo类也是一个对象，type的对象
c.
类都是type类的对象 type(..)
“对象”都是以类的对象 类()
四、异常处理
raise Exception('数据库处理错误')
五、反射
六、单例模式
成员修饰符：
#Python中类的成员有字段、方法、属性
#一、成员修饰符，二、特殊成员，三、metaclass,类的祖宗，四、异常处理，五、反射，六、单例模式
class Foo:
def __init__(self, name, age):
self.name = name
self.age = age
self.__age = age #私有，外部无法直接访问
def show(self):
return self.__age
obj = Foo('alex',12)
print(obj.name)
print(obj.age)
# print(obj.__age) #Foo' object has no attribute '__age'
ret=obj.show()
print(ret)
#静态字段也可以私有化
class foo:
__v='1233'
def __init__(self):
pass
def show(self):
return foo.__v
@staticmethod
def stat():
return foo.__v
# print(foo.__v) #此时静态方法私有化，无法直接访问
ret=foo().show()
print(ret)
ret=foo.stat()
print(ret)
#方法也有公有私有化
class foo:
def __f1(self):
return 'abc'
def f2(self):
r=self.__f1()
return r
obj=foo()
# ret=obj.__f1
# print(ret) #'foo' object has no attribute '__f1'
ret=obj.f2()
print(ret)
#子类不能访问父类中的私有字段，私有字段只是本类中能访问
class F:
def __init__(self):
self.ge=123
self.__gene=123
class S(F):
def __init__(self,name):
self.name=123
self.__age=17
super(S,self).__init__()
def show(self):
print(self.name)
print(self.__age)
print(self.ge)
# print(self.__gene)
s=S('alex')
s.show() #'S' object has no attribute '_S__gene'
print('========================================================')
#特殊成员
class foo:
def __init__(self):
print(123)
def __call__(self, *args, **kwargs):
print('call')
# obj=foo()
# obj()
# foo()() #对象加括号只执行call方法，或者是类加两个括号
class Foo:
def __init__(self,name,age):
self.name=name
self.age=age
def __add__(self, other):
return 'ppp'
# def __del__(self):
# print('析构方法') #对象被销毁时被自动执行
obj1=Foo('alex',12)
obj2=Foo('abc',13)
r=obj1+obj2 #两个对象相加时，自动执行第一个对象的__add__方法，并且将第二个对象当作参数传递进入
print(r)
#__dict__将成员以字典的形式显示
class Foo:
def __init__(self,name,age):
self.name=name
self.age=age
self.n=123
obj=Foo('alex',12)
d=obj.__dict__
print(d)
li=[1,2,3,4,5]
# r=li[3]
li[3]=9
del li[2]
print(li)
#自定义方法对字典进行操作
class Foo:
def __init__(self,name,age):
self.name=name
self.age=age
#__getitem__ __setitem__ __delitem__都没有返回值
def __getitem__(self, item):
# return item+10
#如果item是基本类型，int，str,索引获取
#如果是slice对象的话，切片
if type(item)==slice:
print('调用者希望内部做切片处理')
else:
# print(item.start)
# print(item.end)
# print(item.step)
print('调用者希望内部做索引处理')
# print(item,type(item))
def __setitem__(self, key, value):
print(key,value)
def __delitem__(self, key):
print(key)
li=Foo('alex',13)
r=li[8] #自动执行li对象中的__getitem__方法，8当作参数传递给item
print(r)
li[100]=123 #自动执行__setitem__方法
li[1:4:2]
del li[999]
# class Slice:
# def __init__(self,a,b,c):
# self.start=a
# self.end=b
# self.step=c
# obj=Slice(1,4,2)
print('=================================================')
class Foo:
def __init__(self,name,age):
self.name=name
self.age=age
print(name,age)
def __iter__(self):
return iter([1,2,3,4])
li=Foo('alex',8)
#如果类中有__iter__方法，对象就叫做可迭代对象
#对象.__iter__方法的返回值：迭代器
#获取li对象的类中的__iter__方法,并获取其返回值
#循环上一步返回的对象
for i in li:
print(i)
li=[1,2,3,4]
li=list([1,2,3,4])
metaclass和异常：
#在Python中一切事物都是对象
class Foo:
pass
obj=Foo()
#obj是Foo对象，Foo类也是一个对象，是type的对象
#类都是type类的对象，对象都是以类的对象，类（）
class foo:
def func(self):
print(123)
obj=Foo()
#声明了一个类，类中有一个成员func
# foo=type('foo',(object,),{'func':function})
# obj=foo()
print('=====================================================')
#foo类的创建不用type创建，用Mytype创建foo类（用关键字metaclass）
class Mytype(type):
#Mytype中的self代指foo类
def __init__(self,*args,**kwargs):
print(123)
pass
def __call__(self, *args, **kwargs): #self代指foo类
#self=foo
obj=self.__new__(self, *args, **kwargs)
self.__init__(obj) #执行了new方法，创建了对象之后，然后才执行foo的 构造方法
print(456)
class foo(object,metaclass=Mytype):
def __init__(self):
pass
def __new__(cls, *args, **kwargs): #obj是在new里面创建的
return object.__new__(cls,*args, **kwargs) #对象就是obj
def func(self):
print('hello world')
obj=foo() #foo是Mytype的对象，foo（）执行Mytype的call方法
#此时只执行了Mytype的方法，还没有执行foo中的方法，要想执行foo的方法，需要用Mytype调用foo中的方法
print('=========================================================')
class Bar:
def __init__(self):
print(123)
obj = Bar()
# while True:
# try:
# # 代码块，逻辑
# inp = input('请输入序号：')
# i = int(inp)
# except Exception as e:
# # e是Exception对象，对象中封装了错误信息
# # 上述代码块如果出错，自动执行当前块的内容
# print(e)
# i = 1
# print(i)
#li = [11,22]
#li[999] # IndexError
# int('qwe') # ValueError
# def fun():
# ret = 0
# try:
# li = [11, 22]
# li[1]
# int('w3r')
#
# except IndexError as e:
# print('IndexError',e)
# except ValueError as e:
# print('ValueError',e)
# except Exception as e:
# print('Exception',e)
# else:
# ret = 1
# print('elese')
# finally:
# print('....')
#
# return ret
# r = fun()
# if r == 0:
# print('500')
# else:
# pass
#
#
# class F:
# def __init__(self):
# self.__a = 132
#
# def show(self):
# # print(self.__a)
# return self.__a
#
# class S(F):
# def __init__(self):
# self.name = 123
# super(S, self).__init__()
# obj = S()
# r = obj.show()
# print(r)
try:
# int('asdf')
# 主动出发异常
raise Exception('不过了...')
except Exception as e:
print(e)
def db():
# return True
return False
def index():
try:
r = input(">>")
int(r)
result = db()
if not result:
# r = open('log','a',encoding='utf8')
# r.write('数据库处理错误')
# 打开文件，写日志
raise Exception('数据库处理错误')
except Exception as e:
str_error = str(e)
print(str_error)
r = open('log', 'a',encoding='utf8')
r.write(str_error)
# 打开文件，写日志
index()
class OldBoyError(Exception):
def __init__(self, msg):
self.message = msg
def __str__(self):
return self.message
obj = OldBoyError('xxx')
print(obj)
try:
raise OldBoyError('我错了...')
except OldBoyError as e:
print(e) #执行e对象的__str__()方法，获取返回值
#assert 条件,断言，用于强制用户服从，不服从就报错，可补货，一般不补货
print(23)
assert 1==2
print(456)
反射：
#反射 getattr hasattr setattr delattr
class Foo:
def __init__(self,name,age):
self.name=name
self.age=age
def show(self):
return "%s-%s"%(self.name,self.age)
obj=Foo('alex',12)
print(obj.name) #name 是变量名，不是字符串
b='name'
print(obj.__dict__[b])
#去什么东西里面获取什么内容
r=getattr(obj,'name')
print(r)
# inp=input('>>>')
# v=getattr(obj,inp)
# print(v)
func=getattr(obj,'show')
print(func)
r=func()
print(r)
#hasattr() 判断对象中是否有字段
print(hasattr(obj,'name'))
setattr(obj,'k1','v1')
print(obj.k1)
print(obj.name)
# delattr(obj,'name')
obj.name
class Foo:
stat='123'
def __init__(self,name,age):
self.name=name
self.age=age
r=getattr(Foo,'stat')
print(r)
#模拟网站
import f1
inp=input("请输入要查看的URL:")
if hasattr(f1,inp):
func=getattr(f1,inp)
result=func()
print(result)
else:
print('404')
单例：
class Foo:
def __init__(self,name,age):
self.name=name
self.age=age
def show(self):
print(self.name,self.age)
obj=Foo('alex',15) #obj对象，obj也称为Foo类的实例，（实例化）
#单例就是单个实例，永远使用同一份实例（对象）
# v=None #依赖于全局变量
# while True:
# if v:
# v.show #执行循环的时候永远用一个实例
# else:
# v=Foo('alex',123)
# v.show()
#节省内存
class foo:
__v=None
@classmethod
def get_instance(cls):
if cls.__v:
return cls.__v
else:
cls.__v=foo()
return cls.__v
obj1=foo.get_instance()
print(obj1)
obj2=foo.get_instance()
print(obj2)