• 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)

    类方法
    静态方法
  • 相关阅读:
    POJ
    POJ
    BZOJ
    HDU
    codeforces
    BZOJ
    SPOJ
    SPOJ
    SPOJ
    HDU
  • 原文地址：https://www.cnblogs.com/sandler613/p/5626984.html
Copyright © 2020-2023  润新知