Python之路_Day8

Python之路_Day8_课堂笔记
前期回顾

本期内容
一、作业
要点：
二、上节内容回顾和补充
面向对象三大特性：
多态
三、面向对象中成员
字段
方法
属性
四、成员修饰符
五、特殊成员
__init__
__doc__
__call__
__setitem__
...
六、面向对象其他知识
- isinstance
- issubclass
- 继承 2.7
- 应用：
自定义类型，对字典进行补充，有序字典
源码的扩展
七、异常处理
八、设计模式之单例模式
类方法
静态方法
一、作业
要点：
1、封装，对象中嵌套对象
2、pickle，load：切记，一定要先导入相关的类

二、上节内容回顾和补充
面向对象基本知识：
1、类和对象的关系
2、三大特性：
封装
W9EYWL5XZ7GW@~33H{7{%66.jpg
继承
_MX0NRMI7(W]%VQWQ}CG7I8.png
3、多态：多种形态，多种类型
python的多态
def func(arg):
print(arg)
func(1)
func("sandler")
func([11,22,33])

C#/Java的多态
def func(int arg):
print(arg)
func(123)
func("sandler")    # 报错


三、面向对象中类成员
1、字段
class Foo:
# 字段（静态字段）
CC = 123
def __init__(self):
# 字段（普通的字段）
self.name = 'sandler'
def show(self):
print(self.name)
U57TX_1Z22D}[`}5})@_OMX.jpg
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  6. class Province:
  7.     country = '中国'
  8.     def __init__(self,name):
  9.         self.name = name
  11. hn = Province('河南')
  12. print(hn.name)
  13. print(Province.country)
  14. print(hn.country)

一般情况下，自己访问自己的字段
规则：
普通字段只能用字段访问
静态字段用类访问（万不得已的时候可以使用对象访问）
PS：静态字段在代码加载时已经创建

2、方法
所有的方法属于类
普通方法，有对象去调用执行（方法属于类）
至少一个self，通过对象执行
静态方法，由类调用执行
任意参数，由类执行（对象执行）
类方法，由类调用执行
至少一个cls，类执行（对象执行）
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  6. class Province:
  7.     country = '中国'
  9.     def __init__(self,name):
  10.         self.name = name
  11.         # 普通方法，由对象去调用执行（方法属于类）
  13.     def show(self):
  14.         print(self.name)
  16.     @staticmethod
  17.     def f1(arg1,arg2):
  18.         # 静态方法是有类调用执行（当方法内部不需要对象中封装的值时，可以将方法携程静态方法）
  19.         print(arg1,arg2)
  21.     @classmethod
  22.     def f2(cls):
  23.         # 类方法，由类执行
  24.         print(cls)
  26. Province.f1(11,22)
  27. Province.f2()

3、属性
属性是个不伦不类的东西
具有方法的写作形式，具有字段的访问形式，
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. class Pager:
  7.     def __init__(self,all_count):
  8.         self.all_count = all_count
  10.     @property
  11.     def all_pager(self):
  12.         a1,a2 = divmod(self.all_count , 10)
  13.         if a2 == 0:
  14.             return a1
  15.         else:
  16.             return a1 + 1
  18.     @all_pager.setter
  19.     def all_pager(self,value):
  20.         print(value)
  22.     @all_pager.deleter
  23.     def all_pager(self):
  24.         print('del all_pager')
  27. p = Pager(101)
  28. ret = p.all_pager
  29. print(ret)  # 获取
  31. p.all_pager = 111   # 设置
  33. del p.all_pager # 删除
RMLYRLB~{I5SEEYAL9){R@G.png
属性的另一种表达方式：
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  6. class Pager:
  8.     def __init__(self,all_count):
  9.         self.all_count = all_count
  11.     def f1(self):
  12.         return 123
  14.     def f2(self,value):
  15.         pass
  17.     def f3(self):
  18.         pass
  20.     foo = property(fget=f1,fset=f2,fdel=f3)
  22. p = Pager(101)
  24. result = p.foo
  25. print(result)   # 自动调用f1
  27. p.foo = 'sandler'   # 自动调用f2
  29. del p.foo   # 自动调用f3
HWS]5I3PO@V]T`X}(@A5Y[A.png




四、类成员修饰符
公有：
内部和外部都可以访问的字段

私有：
只能类自己本身成员可以访问
只有内部可以访问的字段，在字段前加两个下划线表示私有字段，无法继承

  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  4. # 成员修饰符
  6. class Foo:
  7.     __cc = "123"
  9.     def __init__(self,name):
  10.         self.__name = name
  12.     def f1(self):
  13.         print(self.__name)
  15.     @staticmethod
  16.     def f3():
  17.         print(Foo.__cc)
  19. # print(Foo.__cc)
  20. obj = Foo("san")
  21. obj.f3()
  22. Foo.f3()
  24. class Foo:
  25.     __cc = "123"
  27.     def __init__(self,name):
  28.         self.__name = name
  30.     def f1(self):
  31.         print(self.__name)
  33. class Bar(Foo):
  34.     def f2(self):
  35.         print(self.__name)
  37. # obj = Bar("san")
  38. # obj.f2()
  39. # obj.f1()

强制访问私有，一般不可以使用
print(obj._Foo__name)



五、特殊成员
__init__
构造方法，创建对象时自动执行
__del__
析构方法，当对象在内存中被释放时，自动触发执行    
注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。
__doc__
表示类的描述信息
__module__
表示当前操作的对象在那个模块
__class__
表示当前操作的对象的类是什么
__call__
对象后面加括号，触发执行。
注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. class Foo:
  6.     
  7.     def __init__(self,name,age):
  8.         self.name = name
  9.         self.age = age
  10.         
  11.     def __call__(self, *args, **kwargs):
  12.         print('call')
  13.         
  14.     def __str__(self):
  15.         return '%s - %d' %(self.name,self.age)
  16.     
  17. obj = Foo()
  18. obj()

__dict__
获取对象中的所有字段数据

  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. class Foo:
  7.     def __init__(self,name,age):
  8.         self.name = name
  9.         self.age = age
  11.     def __call__(self, *args, **kwargs):
  12.         print('call')
  14.     def __str__(self):
  15.         return '%s - %d' %(self.name,self.age)
  17. obj1 = Foo('san' , 18)
  18. obj2 = Foo('yuli' , 19)
  20. ret = obj1.__dict__
  21. print(ret)

__str__
如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. class Foo:
  7.     def __init__(self,name,age):
  8.         self.name = name
  9.         self.age = age
  11.     def __call__(self, *args, **kwargs):
  12.         print('call')
  14.     def __str__(self):
  15.         return '%s - %d' %(self.name,self.age)
  17. obj1 = Foo('san' , 18)
  18. obj2 = Foo('yuli' , 19)
  19. print(obj1)
  20. print(obj2)
  22. ret = str(obj1)
  23. print(ret)

__getitem__、__setitem__、__delitem__
用于索引操作，如字典。以上分别表示获取、设置、删除数据
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. class Foo:
  7.     def __init__(self,name,age):
  8.         self.name = name
  9.         self.age = age
  11.     def __call__(self, *args, **kwargs):
  12.         print('call')
  14.     def __str__(self):
  15.         return '%s - %d' %(self.name,self.age)
  17.     def __getitem__(self, item):
  18.         print('getitem')
  20.     def __setitem__(self, key, value):
  21.         print('setitem')
  23.     def __delitem__(self, key):
  24.         print('delitem')
  26. obj = Foo('san' , 19)
  28. ret  = obj['aa']    # getitem
  29. print(ret)
  31. obj['k1'] = 111 # setitem
  33. del obj['k1']   # delitem


__getslice__、__setslice__、__delslice__
该三个方法用于分片操作
注：该三个方法在Python3中已经弃用，Python3中直接使用__getitem__,__setitem__,__delitem__
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. class Foo:
  7.     def __init__(self,name,age):
  8.         self.name = name
  9.         self.age = age
  11.     def __call__(self, *args, **kwargs):
  12.         print('call')
  14.     def __str__(self):
  15.         return '%s - %d' %(self.name,self.age)
  17.     def __getitem__(self, item):
  18.         # item.start    item.stop   item.step
  19.         print(type(item))
  20.         return 123
  22.     def __setitem__(self, key, value):
  23.         # key.start    key.stop   key.step
  24.         print(type(key),type(value))
  26.     def __delitem__(self, key):
  27.         # key.start    key.stop   ikeytem.step
  28.         print(type(key))
  30. obj = Foo('san' , 19)
  31. ret = obj[1:4:2]
  32. obj[1:4] = [11,22,33,44]
  33. del obj[1:4]

__iter__
用于迭代器，之所以列表、字典、元组可以进行for循环，是因为类型内部定义了 __iter__
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. class Foo:
  7.     def __iter__(self):
  8.         return iter([11,22,33,44])
  10. obj = Foo()
  11. for item in obj:
  12.     print(item)

__new__,__metaclass__
WNOK]YFDMQHA$20E_FU(KLV.png




六、面向对象其他知识
- isinstance    # 查看某个类是不是
- issubclass    # 查看某个类是不是子类
D63Y8ZBO9GJZ4%V7O)O`1OV.png
- 继承 2.7
- 执行父类构造方法
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  4. # 执行父类的构造方法
  6. class C1:
  8.     def f1(self):
  9.         print('C1.f1')
  11. class C2(C1):
  13.     def f1(self):
  14.         super(C2,self).f1() # 执行父类的f1
  15.         print('C2.f1')
  17. obj = C2()
  18. obj.f1()

- 应用：
自定义类型，对字典进行补充，有序字典
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  4. # 有序字典
  6. class MyDict(dict):
  8.     def __init__(self):
  9.         self.li = []
  10.         super(MyDict,self).__init__()
  12.     def __setitem__(self, key, value):
  13.         self.li.append(key)
  14.         super(MyDict,self).__setitem__(key,value)
  16.     def __str__(self):
  17.         temp_list = []
  18.         for key in self.li:
  19.             value = self.get(key)
  20.             temp_list.append("'%s',%s" %(key,value,))
  21.         temp_str = "{"+",".join(temp_list)+"}"
  22.         return temp_str
  24. obj = MyDict()
  25. obj['k1'] = 123
  26. obj['k2'] = 456
  27. print(obj)

源码的扩展



七、异常处理
Z$)RN)[C]3`XC7WK~3ADPED.png



八、设计模式之单例模式（23种，goF设计模式）
单例模式
用来创建单个实例
ZUO98VS]ILAYHU1W%$MF[E8.jpg
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  4. # 单例模式
  6. class Foo:
  7.     instance = None
  9.     def __init__(self,name):
  10.         self.name = name
  12.     @classmethod
  13.     def get_instance(cls):
  14.         # cls 类名
  15.         if cls.instance:
  16.             return cls.instance
  17.         else:
  18.             obj = cls("san")
  19.             cls.instance = obj
  20.             return obj
  22. obj1 = Foo.get_instance()
  23. print(obj1)
  24. obj2 = Foo.get_instance()
  25. print(obj2)

类方法
静态方法










posted @ 2016-06-29 15:20  滚动的沙砾  阅读(193)  评论(0)    收藏  举报