Python开发【第七篇】：面向对象二

时间：2023-03-09 09:08:37
Python开发【第七篇】：面向对象二

字段

  1. class Foo:
  2.     #静态字段（保存在类中）
  3.     CC = 123
  5.     def __init__(self):
  6.         #普通字段（保存在对象中）
  7.         self.name = 'alex'
  9.     def show(self):
  10.         print(self.name)

静态字段的应用：

  1. class Province:
  3.     def __init__(self,name):
  4.         self.name = name
  5.         country = "中国"
  7. hn = Province('河南')
  8. hb = Province('河北')
  9. sd = Province('山东')
  10. hlj = Province('黑龙江')

节省内存空间：

  1. class Province:
  2.     country = "中国"
  4.     def __init__(self,name):
  5.         self.name = name
  7. hn = Province('河南')
  8. hb = Province('河北')
  9. sd = Province('山东')
  10. hlj = Province('黑龙江')

一般情况：自己访问自己的字段

规则：普通字段只能用对象访问，静态字段用类访问（可以使用对象访问）。

静态字段在代码加载时已经创建。

  1. print(hn.name)
  2. print(Province.country)

普通方法、静态方法、类方法

  1. class Province:
  2.     country = "中国"
  4.     def __init__(self,name):
  5.         self.name = name
  7.     #普通方法，由对象调用执行（方法属于类）
  8.     def show(self):
  9.         # print(self.name)
  10.         print("河北")
  12.     #静态方法，由类调用执行（当方法内部不需要对象中封装的对象）
  13.     @staticmethod
  14.     def f1(arg1,arg2):
  15.         print(arg1,arg2)
  17.     #类方法（静态方法的一种，至少一个参数，自动传递类名），由类调用执行
  18.     @classmethod
  19.     def f2(cls):
  20.         print(cls)
  22. Province.f1(111,222)
  23. Province.f2()
  25. obj = Province("河南")
  26. obj.show()
  27. 输出：
  28. 111 222
  29. <class '__main__.Province'>
  30. 河北

单例模式：类方法。

所有的方法属于类：

1、普通方法，至少一个self，对象执行。

2、静态方法，任意参数，类执行（可以对象执行）。

3、类方法，至少一个cls，类执行（可以对象执行）。

类成员属性

  1. class Pager:
  3.     def __init__(self,all_count):
  4.         self.all_count = all_count
  6.     def all_pager(self):
  7.         a1,a2 = divmod(self.all_count,10)
  8.         if a2 == 0:
  9.             return a1
  10.         else:
  11.             return a1 + 1
  13. p = Pager(101)
  14. ret = p.all_pager() #方法
  15. print(ret)

 

  1. class Pager:
  3.     def __init__(self,all_count):
  4.         self.all_count = all_count
  6.     @property
  7.     def all_pager(self):
  8.         a1,a2 = divmod(self.all_count,10)
  9.         if a2 == 0:
  10.             return a1
  11.         else:
  12.             return a1 + 1
  14. p = Pager(101)
  15. ret = p.all_pager
  16. print(ret)

 

  1. class Pager:
  3.     def __init__(self,all_count):
  4.         self.all_count = all_count
  6.     #获取
  7.     @property
  8.     def all_pager(self):
  9.         a1,a2 = divmod(self.all_count,10)
  10.         if a2 == 0:
  11.             return a1
  12.         else:
  13.             return a1 + 1
  15.     #设置
  16.     @all_pager.setter
  17.     def all_pager(self,value):
  18.         print(value)
  20.     #删除
  21.     @all_pager.deleter
  22.     def all_pager(self):
  23.         print("del all_pager")
  24. p = Pager(101)
  25. ret = p.all_pager
  26. print(ret)
  27. p.all_pager = 111
  28. del p.all_pager
  29. 输出：
  30. 11
  31. 111
  32. del all_pager

属性：具有方法的写作形式，具有字段访问形式。

  1. class Pager:
  3.     def __init__(self,all_count):
  4.         self.all_count = all_count
  6.     def f1(self):
  7.         return 123
  9.     def f2(self,value):
  10.         print(value)
  12.     def f3(self):
  13.         print("del")
  15.     foo = property(fget=f1,fset=f2,fdel=f3)
  17. p = Pager(101)
  18. ret = p.foo
  19. print(ret)
  20. p.foo = "alex"
  21. del p.foo
  22. 输出：
  23. 123
  24. alex
  25. del

成员修饰符

  1. class Foo:
  3.     #__cc私有静态字段
  4.     __cc = 123
  6.     def __init__(self,name,age):
  7.         self.name = name
  8.         #__age私有普通字段
  9.         self.__age = age
  11.     def f1(self):
  12.         print("f1:"+self.name)
  13.         print(self.__age)
  15.     def f3(self):
  16.         print(Foo.__cc)
  18.     @staticmethod
  19.     def f4():
  20.         print("staticmethod:",Foo.__cc)
  22. class Bar(Foo):
  23.     def f2(self):
  24.         print(self.name)
  25.         #私有普通字段 不能访问
  26.         # print(self.__age)
  28. obj = Foo('alex',19)
  29. print(obj.name)
  30. # print(obj.age) 不能外部调用
  31. # print(Foo.__cc) 不能外部调用
  32. obj.f1()
  33. obj.f3()
  34. Foo.f4()
  36. obj1 = Bar("tom",20)
  37. obj1.f2()
  38. obj1.f1()

私有：只有类本身成员内部可以访问。

注意：特殊访问私有字段的方法（_类名__xxx）。

print(obj._Foo__age)

特殊成员

  1. class Foo:
  3.     #构造方法
  4.     def __init__(self):
  5.         print("init")
  7.     #析构方法
  8.     def __del__(self):
  9.         print("del")
  11.     def __call__(*args,**kwargs):
  12.         print("call")
  13. p = Foo()
  14. #获取类名
  15. print(p.__class__)
  16. #执行call方法
  17. p()
  18. #执行call方法
  19. Foo()()
  20. 输出：
  21. init
  22. <class '__main__.Foo'>
  23. call
  24. init
  25. call
  26. del
  27. del

 

  1. class Foo:
  3.     #构造方法
  4.     def __init__(self,name,age):
  5.         self.name = name
  6.         self.age = age
  8.     #析构方法
  9.     def __del__(self):
  10.         pass
  12.     def __call__(*args,**kwargs):
  13.         print("call")
  15.     def __str__(self):
  16.         return "%s----%d" %(self.name,self.age)
  18. obj = Foo("alex",34)
  19. print(obj)
  20. obj2 = Foo("eric",23)
  21. print(obj2)
  22. 输出：
  23. alex----34
  24. eric----23

 

  1. obj1 = Foo('alex',23)
  2. obj2 = Foo('eric',21)
  3. #获取对象中封装的数据
  4. ret = obj1.__dict__
  5. print(ret)
  6. 输出：
  7. {'age': 23, 'name': 'alex'}

 

  1. class Foo:
  3.     #构造方法
  4.     def __init__(self,name,age):
  5.         self.name = name
  6.         self.age = age
  8.     #析构方法
  9.     def __del__(self):
  10.         pass
  12.     def __call__(*args,**kwargs):
  13.         print("call")
  15.     def __str__(self):
  16.         return "%s----%d" %(self.name,self.age)
  18.     def __getitem__(self,item):
  19.         print("getitem")
  21.     def __setitem__(self, key, value):
  22.         print("setitem")
  24.     def __delitem__(self, key):
  25.         print("delitem")
  26. obj = Foo('alex',18)
  27. #call方法
  28. obj()
  29. obj["abc"] = 111
  30. del obj['abc']
  31. 输出：
  32. call
  33. setitem
  34. delitem

 

  1. class Foo:
  3.     #构造方法
  4.     def __init__(self,name,age):
  5.         self.name = name
  6.         self.age = age
  8.     def __getitem__(self,item):
  9.         print(type(item))
  10.         if type(item) == str:
  11.             pass
  12.         else:
  13.             print(item.start)
  14.             print(item.stop)
  15.             print(item.step)
  17.         print("getitem")
  19.     def __setitem__(self, key, value):
  20.         print(type(key),type(value))
  21.         print("setitem")
  23.     def __delitem__(self, key):
  24.         print(type(key))
  25.         print("delitem")
  27. obj = Foo('alex',14)
  28. #getitem
  29. ret1 = obj[1:4:2]
  30. #getitem
  31. ret2 = obj['abc']
  33. obj[1:3] = [11,22,33]
  34. del obj[1:5]
  35. 输出：
  36. <class 'slice'>
  37. 1
  38. 4
  39. 2
  40. getitem
  41. <class 'str'>
  42. getitem
  43. <class 'slice'> <class 'list'>
  44. setitem
  45. <class 'slice'>
  46. delitem

 

  1. class Foo:
  3.     """
  4.     def __iter__(self):
  5.         print("iter")
  6.         return iter([11,22,333])
  7.     """
  8.     def __iter__(self):
  9.         yield 1
  10.         yield 2
  12. obj = Foo()
  13. for item in obj:
  14.     print(item)
  15. 输出：
  16. """
  17. iter
  18. 11
  19. 22
  20. 333
  21. """
  22. 1
  23. 2

 

  1. class Bar:
  2.     pass
  4. class Foo():
  5.     pass
  6. obj = Foo()
  7. #查看某个对象是不是由某个类创建
  8. ret = isinstance(obj,Foo)
  9. ret2 = isinstance(obj,Bar)
  10. print(ret)
  11. print(ret2)
  12. 输出：
  13. True
  14. False

isinstance和issubclass

  1. class Bar:
  2.     pass
  4. class Foo(Bar):
  5.     pass
  8. obj = Foo()
  9. #查看某个对象是不是由某个类创建
  10. ret = isinstance(obj,Foo)
  11. ret2 = isinstance(obj,Bar) #obj类型和obj类型的父类
  12. print(ret)
  13. print(ret2)
  15. #查看某个类是不是另一个类的子类
  16. ret3 = issubclass(Bar,Foo)
  17. ret4 = issubclass(Foo,Bar)
  18. print(ret3)
  19. print(ret4)
  20. 输出：
  21. True
  22. True
  23. False
  24. True

继承super

  1. class C2(C1):
  3.     def f1(self):
  4.         #执行C1中的f1
  5.         super(C2,self).f1() #C1.f1(self)
  6.         print('c2.f1')
  8. obj = C2()
  9. #默认执行C2中的f1
  10. obj.f1()
  11. 输出：
  12. c1.f1
  13. c2.f1

 

有序字典

  1. class MyDict(dict):
  3.     def __init__(self):
  4.         self.li = []
  5.         super(MyDict,self).__init__()
  7.     def __setitem__(self,key,value):
  8.         self.li.append(key)
  9.         super(MyDict,self).__setitem__(key,value)
  11.     def __str__(self):
  12.         temp_list = []
  13.         for key in self.li:
  14.             value = self.get(key)
  15.             temp_list.append("'%s':%s"%(key,value))
  16.         temp_list = "{" + ",".join(temp_list) + "}"
  17.         return temp_list
  19. obj = MyDict()
  20. obj['k1'] = 123
  21. obj['k2'] = 456
  22. print(obj)

单例模式

单例模式用来创建单个实例。

  1. class Foo:
  3.     instance = None
  5.     def __init__(self,name):
  6.         self.name = name
  8.     @classmethod
  9.     def get_instance(cls):
  10.         #cls类名
  11.         if cls.instance:
  12.             print("已经创建对象")
  13.             return cls.instance
  14.         else:
  15.             #创建对象
  16.             obj = cls('alex')
  17.             print("新创建对象")
  18.             cls.instance = obj
  19.             return obj
  21. obj = Foo.get_instance()
  22. obj1 = Foo.get_instance()
  23. print(id(obj),id(obj1))
  24. 输出：
  25. 新创建对象
  26. 已经创建对象
  27. 7225864 7225864

异常处理

  1. while True:
  2.     num1 = input("num1:")
  3.     num2 = input("num2:")
  4.     try:
  5.         num1 = int(num1)
  6.         num2 = int(num2)
  7.         result = num1 + num2
  8.     except Exception as ex: #捕获所有错误
  9.         print(ex)

 

  1. except ValueError as ve: #捕获ValueError
  2.     print(ve)
  3. except IndexError as ie: #捕获IndexError
  4.     print(ie)
  5. except Exception as ex: #捕获所有错误
  6.     print(ex)

 

  1. try:
  2.     pass
  3. except ValueError as ve:
  4.     print(ve)
  5. except Exception as ex:
  6.     print(ex)
  7. finally: #不管有无错误都执行finally
  8.     pass

 

  1. try:
  2.     raise ValueError('主动触发错误')
  3.     pass
  4. except ValueError as ve:
  5.     print("ValueError",ve)
  6. except Exception as ex:
  7.     print(ex)
  8. finally: #不管有无错误都执行finally
  9.     pass
  10. 输出：
  11. ValueError 主动触发错误

断言

  1. assert 1 == 1
  2. #报错
  3. assert 1 == 2

 

 

相关文章