py-opp 类（class）

 类的创建

class 类名：passclass Bar:def foo(self,arg): # self ,是传的实例对象，print('self:',self,arg) #因为类属性和方法会分别绑定和返回给实例对象z1 = Bar() print('实例对象:',z1) z1.foo(111) print('================') z2 = Bar() print(z2) z2.foo(666)output>>>实例对象: <__main__.Bar object at 0x000001DAF653CB70> self: <__main__.Bar object at 0x000001DAF653CB70> 111 ================ <__main__.Bar object at 0x000001DAF653CBE0> self: <__main__.Bar object at 0x000001DAF653CBE0> 666 View Code

创建方法

构造方法，__init__(self, arg)obj = 类('a1') 普通方法obj = 类(‘xxx’)obj.普通方法名() class Person:def __init__(self, name,age):#构造方法，构造方法的特性， 类名() 自动执行构造方法self.n = nameself.a = ageself.x = '0'def show(self):print('%s-%s' %(self.n, self.a)) stu1 = Person('kevin', 18) stu1.show()stu2 = Person('lemi', 73) stu2.show() View Code

面向对象三大特性

1.封装

class Bar:def __init__(self, n,a): #通过构造方法封装属性self.name = nself.age = aself.xue = 'o'b1 = Bar('alex', 123)b2 = Bar('eric', 456) View Code

1.1适用场景

#给对象封装一些值 如果多个函数中有一些相同参数时，转换成面向对象

class DataBaseHelper:def __init__(self, ip, port, username, pwd):self.ip = ipself.port = portself.username = usernameself.pwd = pwddef add(self,content):# 利用self中封装的用户名、密码等 链接数据print('content')# 关闭数据链接def delete(self,content):# 利用self中封装的用户名、密码等 链接数据print('content')# 关闭数据链接def update(self,content):# 利用self中封装的用户名、密码等 链接数据print('content')# 关闭数据链接def get(self,content):# 利用self中封装的用户名、密码等 链接数据print('content')# 关闭数据链接s1 = DataBaseHelper('1.1.1.1',3306, 'alex', 'sb') View Code

2.继承

1、继承class 父类：passclass 子类(父类):pass2、重写防止执行父类中的方法3、self永远是执行改方法的调用者4、super(子类, self).父类中的方法(...)父类名.父类中的方法(self,...) 5、Python中支持多继承a. 左侧优先b. 一条道走到黑c. 同一个根时，根最后执行 要点 class F:def f1(self):print('F.f1')def f2(self):print('F.f2')class S(F):def s1(self):print('S.s1')def f2(self):# objprint('S.f2')# super(S, self).f2() # 执行父类(基类)中的f2方法# F.f2(self) # 执行父类(基类)中的f2方法 """""" obj = S() obj.s1() obj.f2() """ """ obj = S() obj.s1() # s1中的self是形参，此时代指 obj obj.f1() # self用于指调用方法的调用者 """# obj = S() # obj.f2()""" class Base:def a(self):print('Base.a')class F0(Base):def a1(self):print('F0.a')class F1(F0):def a1(self):print('F1.a')class F2(Base):def a1(self):print('F2.a')class S(F1,F2):passobj = S() obj.a() View Code

class A(object):def test(self):print('from A')class B(A):def test(self):print('from B')class C(A):def test(self):print('from C')class D(B):def test(self):print('from D')class E(C):def test(self):print('from E')class F(D,E):# def test(self):# print('from F')pass f1=F() f1.test() print(F.__mro__)output>>> from D (<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>) View Code

在子类中调用父类的方法

 内置方法

 元类(metaclass)

 在Python中一切都是对象，类也是对象，是元类的对象，元类就是类的模板。

在我们平时创建类时，并不是那么简单，会默认执行元类的__init__等几步

---- 图片来自银角大王

class MyType(type):def __init__(self, what, bases=None, dict=None):super(MyType, self).__init__(what, bases, dict)def __call__(self, *args, **kwargs):obj = self.__new__(self, *args, **kwargs)self.__init__(obj)class Foo(object):__metaclass__ = MyTypedef __init__(self, name):self.name = namedef __new__(cls, *args, **kwargs):return object.__new__(cls)# 第一阶段：解释器从上到下执行代码创建Foo类 # 第二阶段：通过Foo类创建obj对象 obj = Foo('kevin') print(obj.name) s2

 异常处理

 异常就是程序运行时发生错误的信号(在程序出现错误时，则会产生一个异常，若程序没有处理它，则会抛出该异常，程序的运行也随之终止)

--- while True:try:# 代码块，逻辑inp = input('请输入序号：')i = int(inp)except Exception as e:# e是Exception对象，对象中封装了错误信息# 上述代码块如果出错，自动执行当前块的内容print(e)i = 1print(i)---异常的捕捉---def fun():ret = 0try:li = [11, 22] #一旦有错误，就会捕捉，下面的错误就不执行，不会出来li[81]int('w3r')except IndexError as e: #逐级细分错误分类捕捉print('IndexError',e) #将子异常放在前面，如果Exception在这就包含了所有异常，后面细分就没用了except ValueError as e:print('ValueError',e)except Exception as e:print('Exception',e)else: #前面错误没有捕捉到才会执行这句，因为有的话前面捕捉到就结束啦。可以原来检测前面的捕捉有没有执行。和while-else 是 while 条件不成立才执行else语句ret = 1print('没有错误。。')finally: #最后都要执行这句print('....')return ret r = fun() if r == 0:print('500') else:pass---主动抛异常---try:# 主动出发异常raise Exception('不过了...') except Exception as e:print(e)--运用def db():# return Truereturn Falsedef index():try:result = db()if not result:r = open('log','a') #当数据库返回有错误时，想要写日志，就想要打开文件写，若果主动抛出异常，就可以在下面一起写r.write('数据库处理错误')# 打开文件，写日志#raise Exception('数据库处理错误') #抛出错误给下面捕捉，写日志就写一个啦except Exception as e:str_error = str(e)print(str_error)r = open('log', 'a')r.write(str_error)# 打开文件，写日志index() ----------自定义异常--------- class OldBoyError(Exception):def __init__(self, msg):self.message = msgdef __str__(self):return self.message# obj = OldBoyError('xxx') # print(obj) try:raise OldBoyError('我错了...') except OldBoyError as e:print(e)# e对象的__str__()方法，获取返回 View Code

断言

assert 条件,断言，用于强制用户服从，不服从就报错，可捕获，一般不捕获
print(23) assert 1==2　　　　#不成立，直接报错，不会执行下面的语句 print(456)

总结try..except

把错误处理和真正的工作分开来

代码更易组织，更清晰，复杂的工作任务更容易实现；

毫无疑问，更安全了，不至于由于一些小的疏忽而使程序意外崩溃了；

反射

通过字符串的形式操作对象相关的属性。python中的一切事物都是对象(都可以使用反射)

class Foo:def __init__(self, name,age):self.name = nameself.age = agedef show(self):return "%s-%s " %(self.name,self.age)def __int__(self):return 123def __str__(self):return 'uuu' obj = Foo('alex', 18) r = int(obj) # r = 123 u = str(obj)我们知道，可以用obj.name去访问对象的属性name，当b = 'name'，obj.b时会报错，不能这样 那能不能用字符串也能访问里面的属性或方法这就要用到反射了func = getattr(obj, 'show') print(func) r = func() print(r)output>>> <bound method Foo.show of <__main__.Foo object at 0x000001FA6205CC88>> alex-18 #是否有某个属性 print(hasattr(obj, 'name'))#设置 setattr(obj, 'k1', 'v1') print(obj.k1) # v1#删除 delattr(obj, 'name') # obj.name #已经没有name属性#运用：去什么东西里面获取什么内容 #获取输入，然后返回值 inp = input('>>>') v = getattr(obj, inp) print(v)Python中一切都是对象，当然也可以对模块进行反射操作 import s2# r1 = s2.NAME # print(r1) # r2 = s2.func() # print(r2)r1 = getattr(s2, 'NAME') print(r1)r2 = getattr(s2, 'func') result = r2() print(result)cls = getattr(s2, 'Foo') print(cls) obj = cls() print(obj) print(obj.name)--运用-- import s2 inp = input('请输入要查看的URL：') if hasattr(s2, inp):func = getattr(s2, inp)result = func()print(result) else:print('404') 网页的导航栏，选择不同标题返回不同界面 当反射对象中的方法时，注意返回的是对象方法的地址，外面用一个变量接收后，再变量.()执行才会执行对象中的方法 s2

单例模式

单例，用于使用同一份实例(对象)

class Foo:def __init__(self, name,age):self.name = nameself.age = ageobj = Foo() # obj是Foo的对象，obj也可以叫做Foo类的 实例(实例化) obj1 = Foo() obj2 = Foo() obj3 = Foo() 平时我们创建对象，都是 对象名=类() 这里每个obj对象都是独立的内存地址，然而在某些运用环境下需要使用同一个对象 能不能创建一个实例后，接下来的实例都用同一份实例(或对象)，当然可以啦，就是下面的单例模式class Foo:def __init__(self, name,age):self.name = nameself.age = agedef show(self):print(self.name,self.age)v = Nonewhile True:if v:v.show()else:v = Foo('alex', 123)v.show() 刚开始v是None，进入while 循环会创建一个实例，后面调用v实例就不用创建了，直接调用他的方法高级一点的表现 class Foo:__v = None@classmethoddef get_instance(cls):if cls.__v:return cls.__velse:cls.__v = Foo()return cls.__v# 既然都用单例模式了，就不要在使用 类()去创建实例 #在Foo内部用，get_instance 类方法创建一个实例，后面调用都是返回的同一个，看看输出就知道(都是同一个内存地址) obj1 = Foo.get_instance() print(obj1) obj2 = Foo.get_instance() print(obj2) obj3 = Foo.get_instance() print(obj3)>>>output <__main__.Foo object at 0x0000016C3FB4C4A8> <__main__.Foo object at 0x0000016C3FB4C4A8> <__main__.Foo object at 0x0000016C3FB4C4A8> s2

实际运用

　　当用户操作数据库操作数据库连接池时，连接池的接口数量是一定的，用户连接只能共用创建好的连接，不能再创建，当连接都被占用，只有等释放后，供下一个用户连接

总结

以上是生活随笔为你收集整理的py-opp 类（class）的全部内容，希望文章能够帮你解决所遇到的问题。

如果觉得生活随笔网站内容还不错，欢迎将生活随笔推荐给好友。