面向对象（八）

  • 面向对象是一种编程方式，此编程方式的实现是基于对 类 和 对象 的使用
  • 类 是一个模板，模板中包装了多个“函数”供使用（可以讲多函数中公用的变量封装到对象中）
  • 对象，根据模板创建的实例（即：对象），实例用于调用被包装在类中的函数
  • 面向对象三大特性：封装、继承和多态

本篇将详细介绍Python 类的成员、成员修饰符、类的特殊成员。

类的成员

类的成员可以分为三大类：字段、方法和属性

注：所有成员中，只有普通字段的内容保存对象中，即：根据此类创建了多少对象，在内存中就有多少个普通字段。而其他的成员，则都是保存在类中，即：无论对象的多少，在内存中只创建一份。

一、字段

字段包括：普通字段和静态字段，他们在定义和使用中有所区别，而最本质的区别是内存中保存的位置不同，

  • 普通字段属于对象
  • 静态字段属于类


    

  1. class Province:
    2. 

    3. 

  3.     # 静态字段
    4. 

  4.     country = ‘中国‘
    5. 

  5.     def __init__(self, name):
    6. 

    7. 

  7.         # 普通字段
    8. 

  8.         self.name = name
    9. 

    10. 

  10. # 直接访问普通字段
    11. 

  11. obj = Province(‘河北省‘)
    12. 

  12. print(obj.name)
    13. 

  13. # 直接访问静态字段
    14. 

  14. print(Province.country)
    15.

由上述代码可以看出【普通字段需要通过对象来访问】【静态字段通过类访问】，在使用上可以看出普通字段和静态字段的归属是不同的。其

  • 静态字段在内存中只保存一份
  • 普通字段在每个对象中都要保存一份

应用场景： 通过类创建对象时，如果每个对象都具有相同的字段，那么就使用静态字段

二、方法

方法包括：普通方法、静态方法和类方法，三种方法在内存中都归属于类，区别在于调用方式不同。

  • 普通方法：由对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self；
  • 类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls；
  • 静态方法：由类调用；无默认参数；


    

  1. class Foo:
    2. 

    3. 

  3.     def __init__(self, name):
    4. 

  4.         self.name = name
    5. 

    6. 

  6.     def ord_func(self):
    7. 

  7.         """ 定义普通方法，至少有一个self参数 """
    8. 

  8.         # print self.name
    9. 

  9.         print(‘普通方法‘)
    10. 

    11. 

  11.     @classmethod
    12. 

  12.     def class_func(cls):
    13. 

  13.         """ 定义类方法，至少有一个cls参数 """
    14. 

  14.         print(‘类方法‘)
    15. 

    16. 

  16.     @staticmethod
    17. 

  17.     def static_func():
    18. 

  18.         """ 定义静态方法 ，无默认参数"""
    19. 

  19.         print(‘静态方法‘)
    20. 

    21. 

    22. 

  22. # 调用普通方法
    23. 

  23. f = Foo("xiaoyao")
    24. 

  24. f.ord_func()
    25. 

    26. 

  26. # 调用类方法
    27. 

  27. Foo.class_func()
    28. 

    29. 

  29. # 调用静态方法
    30. 

  30. Foo.static_func()
    31. 

    32. 

  32. # 调用静态方法
    33. 

  33. Foo.static_func()
    34. 





相同点：对于所有的方法而言，均属于类（非对象）中，所以，在内存中也只保存一份。

不同点：方法调用者不同、调用方法时自动传入的参数不同。

三、属性　　

如果你已经了解Python类中的方法，那么属性就非常简单了，因为Python中的属性其实是普通方法的变种。

对于属性，有以下三个知识点：

  • 属性的基本使用
  • 属性的两种定义方式

1、属性的基本使用

属性的定义和使用



    

  1. class Foo:
    2. 

  2.     def func(self):
    3. 

  3.         pass
    4. 

    5. 

  5.     @property
    6. 

  6.     def prop(self):
    7. 

  7.         print(‘属性‘)
    8. 

  8. ############### 调用 ###############
    9. 

  9. foo_obj = Foo()
    10. 

    11. 

  11. foo_obj.func()
    12. 

  12. foo_obj.prop  # 调用属性，不需要括号
    13. 





由属性的定义和调用要注意一下几点：
  • 定义时，在普通方法的基础上添加 @property 装饰器；
  • 定义时，属性仅有一个self参数
  • 调用时，无需括号
               方法：foo_obj.func()
               属性：foo_obj.prop

注意：属性存在意义是：访问属性时可以制造出和访问字段完全相同的假象

属性由方法变种而来，如果Python中没有属性，方法完全可以代替其功能。

实例：对于主机列表页面，每次请求不可能把数据库中的所有内容都显示到页面上，而是通过分页的功能局部显示，所以在向数据库中请求数据时就要显示的指定获取从第m条到第n条的所有数据（即：limit m,n），这个分页的功能包括：

  • 根据用户请求的当前页和总数据条数计算出 m 和 n
  • 根据m 和 n 去数据库中请求数据
    

  1. class Pager:
    2. 

    3. 

  3.     def __init__(self, current_page):
    4. 

  4.         # 用户当前请求的页码（第一页、第二页...）
    5. 

  5.         self.current_page = current_page
    6. 

  6.         # 每页默认显示10条数据
    7. 

  7.         self.per_items = 10
    8. 

    9. 

  9.     @property
    10. 

  10.     def start(self):
    11. 

  11.         val = (self.current_page - 1) * self.per_items
    12. 

  12.         return val
    13. 

    14. 

  14.     @property
    15. 

  15.     def end(self):
    16. 

  16.         val = self.current_page * self.per_items
    17. 

  17.         return val
    18. 

    19. 

  19. p = Pager(11)
    20. 

  20. print(p.start)  #100就是起始值，即：m
    21. 

  21. print(p.end)  #110就是结束值，即：n
    22.

从上述可见，Python的属性的功能是：属性内部进行一系列的逻辑计算，最终将计算结果返回。

2、属性的两种定义方式

属性的定义有两种方式：

  • 装饰器 即：在方法上应用装饰器
  • 静态字段 即：在类中定义值为property对象的静态字段

装饰器方式：

在类的普通方法上应用@property装饰器

我们知道Python中的类有经典类和新式类，新式类的属性比经典类的属性丰富。（ 如果类继object，那么该类是新式类 ）
经典类，具有一种@property装饰器（如上一步实例）



新式类，具有三种@property装饰器


# ############### 定义 ###############class Goods(object):

    @property
    def price(self):
        print ‘@property‘

    @price.setter
    def price(self, value):
        print ‘@price.setter‘

    @price.deleter
    def price(self):
        print ‘@price.deleter‘# ############### 调用 ###############
obj = Goods()

obj.price          # 自动执行 @property 修饰的 price 方法，并获取方法的返回值
obj.price = 123    # 自动执行 @price.setter 修饰的 price 方法，并将  123 赋值给方法的参数del obj.price      # 自动执行 @price.deleter 修饰的 price 方法


注：经典类中的属性只有一种访问方式，其对应被 @property 修饰的方法
      新式类中的属性有三种访问方式，并分别对应了三个被@property、@方法名.setter、@方法名.deleter修饰的方法


由于新式类中具有三种访问方式，我们可以根据他们几个属性的访问特点，分别将三个方法定义为对同一个属性：获取、修改、删除


class Goods(object):

    def __init__(self):
        # 原价
        self.original_price = 100
        # 折扣
        self.discount = 0.8

    @property
    def price(self):
        # 实际价格 = 原价 * 折扣
        new_price = self.original_price * self.discount
        return new_price

    @price.setter
    def price(self, value):
        self.original_price = value

    @price.deltter
    def price(self, value):
        del self.original_price

obj = Goods()
obj.price         # 获取商品价格
obj.price = 200   # 修改商品原价del obj.price     # 删除商品原价




静态字段方式，创建值为property对象的静态字段


当使用静态字段的方式创建属性时，经典类和新式类无区别


    

  1. class Foo:
    2. 

    3. 

  3.     def get_bar(self):
    4. 

  4.         return ‘xiaoyao‘
    5. 

    6. 

  6.     BAR = property(get_bar)
    7. 

    8. 

  8. obj = Foo()
    9. 

  9. reuslt = obj.BAR        # 自动调用get_bar方法，并获取方法的返回值
    10. 

  10. print(reuslt)    # 输出 xiaoyao
    11. 





property的构造方法中有个四个参数


    

  • 第一个参数是方法名，调用 对象.属性 时自动触发执行方法
    • 

  • 第二个参数是方法名，调用 对象.属性 ＝ XXX 时自动触发执行方法
    • 

  • 第三个参数是方法名，调用 del 对象.属性 时自动触发执行方法
    • 

  • 第四个参数是字符串，调用 对象.属性.__doc__ ，此参数是该属性的描述信息
    • 



    

  1. class Foo:
    2. 

    3. 

  3.     def get_bar(self):
    4. 

  4.         print(‘get value xiaoyao‘)
    5. 

    6. 

  6.     # *必须两个参数
    7. 

  7.     def set_bar(self, value):
    8. 

  8.         print(‘set value ‘ + value)
    9. 

    10. 

  10.     def del_bar(self):
    11. 

  11.         print(‘del value‘)
    12. 

    13. 

  13.     BAR = property(get_bar, set_bar, del_bar, ‘description...xxx...‘)
    14. 

    15. 

  15. obj = Foo()
    16. 

    17. 

  17. obj.BAR                  # 自动调用第一个参数中定义的方法：get_bar
    18. 

  18. obj.BAR = "alex"         # 自动调用第二个参数中定义的方法：set_bar方法，并将“alex”当作参数传入del_bar
    19. 

  19. del obj.BAR              # 自动调用第三个参数中定义的方法：del_bar方法
    20. 

  20. print(Foo.BAR.__doc__)   # 自动获取第四个参数中设置的值：description...xxx...
    21. 





由于静态字段方式创建属性具有三种访问方式，我们可以根据他们几个属性的访问特点，分别将三个方法定义为对同一个属性：获取、修改、删除


class Goods(object):

    def __init__(self):
        # 原价
        self.original_price = 100
        # 折扣
        self.discount = 0.8

    def get_price(self):
        # 实际价格 = 原价 * 折扣
        new_price = self.original_price * self.discount
        return new_price

    def set_price(self, value):
        self.original_price = value

    def del_price(self, value):
        del self.original_price

    PRICE = property(get_price, set_price, del_price, ‘价格属性描述...‘)

obj = Goods()
obj.PRICE         # 获取商品价格
obj.PRICE = 200   # 修改商品原价del obj.PRICE     # 删除商品原价


注意：Python WEB框架 Django 的视图中 request.POST 就是使用的静态字段的方式创建的属性


class WSGIRequest(http.HttpRequest):
    def __init__(self, environ):
        script_name = get_script_name(environ)
        path_info = get_path_info(environ)
        if not path_info:
            # Sometimes PATH_INFO exists, but is empty (e.g. accessing# the SCRIPT_NAME URL without a trailing slash). We really need to# operate as if they‘d requested ‘/‘. Not amazingly nice to force# the path like this, but should be harmless.
            path_info = ‘/‘
        self.environ = environ
        self.path_info = path_info
        self.path = ‘%s/%s‘ % (script_name.rstrip(‘/‘), path_info.lstrip(‘/‘))
        self.META = environ
        self.META[‘PATH_INFO‘] = path_info
        self.META[‘SCRIPT_NAME‘] = script_name
        self.method = environ[‘REQUEST_METHOD‘].upper()
        _, content_params = cgi.parse_header(environ.get(‘CONTENT_TYPE‘, ‘‘))
        if ‘charset‘ in content_params:
            try:
                codecs.lookup(content_params[‘charset‘])
            except LookupError:
                passelse:
                self.encoding = content_params[‘charset‘]
        self._post_parse_error = False
        try:
            content_length = int(environ.get(‘CONTENT_LENGTH‘))
        except (ValueError, TypeError):
            content_length = 0
        self._stream = LimitedStream(self.environ[‘wsgi.input‘], content_length)
        self._read_started = False
        self.resolver_match = None

    def _get_scheme(self):
        return self.environ.get(‘wsgi.url_scheme‘)

    def _get_request(self):
        warnings.warn(‘`request.REQUEST` is deprecated, use `request.GET` or ‘‘`request.POST` instead.‘, RemovedInDjango19Warning, 2)
        if not hasattr(self, ‘_request‘):
            self._request = datastructures.MergeDict(self.POST, self.GET)
        return self._request

    @cached_property
    def GET(self):
        # The WSGI spec says ‘QUERY_STRING‘ may be absent.
        raw_query_string = get_bytes_from_wsgi(self.environ, ‘QUERY_STRING‘, ‘‘)
        return http.QueryDict(raw_query_string, encoding=self._encoding)

    # ############### 看这里看这里  ###############def _get_post(self):
        if not hasattr(self, ‘_post‘):
            self._load_post_and_files()
        return self._post

    # ############### 看这里看这里  ###############def _set_post(self, post):
        self._post = post

    @cached_property
    def COOKIES(self):
        raw_cookie = get_str_from_wsgi(self.environ, ‘HTTP_COOKIE‘, ‘‘)
        return http.parse_cookie(raw_cookie)

    def _get_files(self):
        if not hasattr(self, ‘_files‘):
            self._load_post_and_files()
        return self._files

    # ############### 看这里看这里  ###############
    POST = property(_get_post, _set_post)

    FILES = property(_get_files)
    REQUEST = property(_get_request)




所以，定义属性共有两种方式，分别是【装饰器】和【静态字段】，而【装饰器】方式针对经典类和新式类又有所不同。


类成员的修饰符


类的所有成员在上一步骤中已经做了详细的介绍，对于每一个类的成员而言都有两种形式：


    

  • 公有成员，在任何地方都能访问
    • 

  • 私有成员，只有在类的内部才能方法
    • 



私有成员和公有成员的定义不同：私有成员命名时，前两个字符是下划线。（特殊成员除外，例如：__init__、__call__、__dict__等）








1


2


3


4


5




class C:



    def __init__(self):


        self.name = ‘公有字段‘


        self.__foo = "私有字段"








私有成员和公有成员的访问限制不同：


静态字段


    

  • 公有静态字段：类可以访问；类内部可以访问；派生类中可以访问
    • 

  • 私有静态字段：仅类内部可以访问；
    • 





    

  1. class A:
    2. 

    3. 

  3.     name = "公有静态字段"
    4. 

    5. 

  5.     def func(self):
    6. 

  6.         print(A.name)
    7. 

    8. 

  8. class B(A):
    9. 

    10. 

  10.     def show(self):
    11. 

  11.         print(A.name)
    12. 

    13. 

  13. A.name         # 类访问
    14. 

  14. obj = A()
    15. 

  15. obj.func()     # 类内部可以访问
    16. 

  16. obj_son = B()
    17. 

  17. obj_son.show() # 派生类中可以访问
    18. 





    

  1. class C:
    2. 

  2.     __name = "私有静态字段"
    3. 

  3.     def func(self):
    4. 

  4.         print(C.__name)
    5. 

    6. 

  6. class D(C):
    7. 

    8. 

  8.     def show(self):
    9. 

  9.         print(C.__name)
    10. 

    11. 

  11. C.__name       # 类访问            ==> 错误
    12. 

  12. obj = C()
    13. 

  13. obj.func()     # 类内部可以访问     ==> 正确
    14. 

  14. obj_son = D()
    15. 

  15. obj_son.show() # 派生类中可以访问   ==> 错误
    16. 







普通字段


    

  • 公有普通字段：对象可以访问；类内部可以访问；派生类中可以访问
    • 

  • 私有普通字段：仅类内部可以访问；
    • 



ps：如果想要强制访问私有字段，可以通过 【对象._类名__私有字段明 】访问（如：obj._C__foo），不建议强制访问私有成员。




    

  1. class C:
    2. 

  2.     
    3. 

  3.     def __init__(self):
    4. 

  4.         self.foo = "公有字段"def func(self):
    5. 

  5.         print self.foo 　#　类内部访问class D(C):
    6. 

  6.     
    7. 

  7.     def show(self):
    8. 

  8.         print self.foo　＃　派生类中访问
    9. 

    10. 

  10. obj = C()
    11. 

    12. 

  12. obj.foo     # 通过对象访问
    13. 

  13. obj.func()  # 类内部访问
    14. 

  14. obj_son = D();
    15. 

  15. obj_son.show()  # 派生类中访问
    16. 

    17. 

  17. class C:
    18. 

  18.     
    19. 

  19.     def __init__(self):
    20. 

  20.         self.__foo = "私有字段"def func(self):
    21. 

  21.         print self.foo 　#　类内部访问class D(C):
    22. 

  22.     
    23. 

  23.     def show(self):
    24. 

  24.         print self.foo　＃　派生类中访问
    25. 

    26. 

  26. obj = C()
    27. 

    28. 

  28. obj.__foo     # 通过对象访问    ==> 错误
    29. 

  29. obj.func()  # 类内部访问        ==> 正确
    30. 

  30. obj_son = D();
    31. 

  31. obj_son.show()  # 派生类中访问  ==> 错误
    32. 





方法、属性的访问于上述方式相似，即：私有成员只能在类内部使用




ps：非要访问私有属性的话，可以通过 对象._类__属性名


类的特殊成员


上文介绍了Python的类成员以及成员修饰符，从而了解到类中有字段、方法和属

性三大类成员，并且成员名前如果有两个下划线，则表示该成员是私有成员，私有成员只能由类内部调用。无论人或事物往往都有不按套路出牌的情

况，Python的类成员也是如此，存在着一些具有特殊含义的成员，详情如下：


1. __doc__


　　表示类的描述信息


    

  1. class Foo(object):
    2. 

  2.     """
    3. 

  3.     这是一个简单类
    4. 

  4.     """
    5. 

    6. 

  6.     def __delitem__(self, key):
    7. 

  7.         print(‘__delitem__‘, key)
    8. 

    9. 

  9. obj = Foo()
    10. 

  10. print(obj.__doc__)
    11. 

  11. 

    print(Foo.__doc__)
    

    12. 

  12. print(Foo().__doc__)
    13. 





    

    2. 

  2. 这是一个简单类

    这是一个简单类

    这是一个简单类
    
    3. 





可见类本身和它的对象都可以调用这个特殊成员。


前面我们讲过函数也有个__doc__,下面一起看一下：


    

  1. def Foo():
    2. 

  2.     """
    3. 

  3.     这是一个简单函数
    4. 

  4.     """
    5. 

  5.     def __delitem__(self, key):
    6. 

  6.         print(‘__delitem__‘, key)
    7. 

    8. 

  8. print(Foo.__doc__)
    9. 





    

    2. 

  2.     这是一个简单函数
    3. 





2. __module__ 和  __class__ 


　　__module__ 表示当前操作的对象在那个模块


　　__class__     表示当前操作的对象的类是什么


    

  1. # test.py
    2. 

    3. 

  3. class C:
    4. 

  4.     def __init__(self):
    5. 

  5.         self.name = ‘xxx‘
    6. 





    

  1. from test import C
    2. 

    3. 

  3. obj = C()
    4. 

  4. print(obj.__module__)  # 输出 test，即：输出模块
    5. 

  5. print(obj.__class__)   # 输出 <class ‘test.C‘>，即：输出类
    6. 





3. __init__


　　构造方法，通过类创建对象时，自动触发执行。


    

  1. class Foo:
    2. 

    3. 

  3.     def __init__(self, name,age=18):
    4. 

  4.         self.name = name
    5. 

  5.         self.age = age
    6. 

    7. 

  7. obj = Foo(‘xxx‘) # 自动执行类中的 __init__ 方法
    8. 

  8. print(obj.name,obj.age) #输出 xxx 18
    9. 





4. __del__


　　析构方法，当对象在内存中被释放时，自动触发执行。


注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。


class Foo:

    def __del__(self):
        pass




5. __call__


　　对象后面加括号，触发执行。


注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()




    

    2. 

    3. 

  3. class T_call():
    4. 

  4.     
    5. 

  5.     def __call__(self, *args, **kwargs):
    6. 

  6.         print(args)
    7. 

  7.         print(kwargs)
    8. 

    9. 

  9. obj1 = T_call()
    10. 

  10. obj1(‘a‘,19,"k1=v1",k1="v1")
    11. 







6. __dict__


　　类或对象中的所有成员


上文中我们知道：类的普通字段属于对象；类中的静态字段和方法等属于类，即：


    

  1. class Province:
    2. 

    3. 

  3.     country = ‘China‘
    4. 

    5. 

  5.     def __init__(self, name, count):
    6. 

  6.         self.name = name
    7. 

  7.         self.count = count
    8. 

    9. 

  9.     def func(self, *args, **kwargs):
    10. 

  10.         print(‘func‘)
    11. 

    12. 

  12. obj1 = Province(‘HeBei‘,10000)
    13. 

  13. print(obj1.__dict__)# 获取 对象obj1 的成员
    14. 

  14. # 输出：{‘count‘: 10000, ‘name‘: ‘HeBei‘}
    15. 

  15. obj2 = Province(‘HeNan‘, 3888)
    16. 

  16. print(obj2.__dict__)# 获取 对象obj1 的成员
    17. 

  17. # 输出：{‘count‘: 3888, ‘name‘: ‘HeNan‘}
    18. 

  18. print(Province.__dict__) #获取 类Province的成员
    19. 

  19. # 输出：{‘__module__‘: ‘__main__‘, ‘__dict__‘: <attribute ‘__dict__‘ of ‘Province‘ objects>, ‘__doc__‘: None, ‘__init__‘: <function Province.__init__ at 0x009DE348>, ‘__weakref__‘: <attribute ‘__weakref__‘ of ‘Province‘ objects>, ‘func‘: <function Province.func at 0x009DE300>, ‘country‘: ‘China‘}
    20. 





 7. __str__


　　如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。


    

  1. class Foo:
    2. 

    3. 

  3.     def __str__(self):
    4. 

  4.         return ‘xiaoyao‘
    5. 

    6. 

  6. obj = Foo()
    7. 

  7. print(obj) # 输出：xiaoyao
    8. 





    

  1. class Foo:
    2. 

    3. 

  3.     def __str__(self):
    4. 

  4.         pass  #当没有return值的时候，输出会报错。
    5. 

    6. 

  6. obj = Foo()
    7. 

  7. print(obj)
    8. 

    9. 

  9. Traceback (most recent call last):
    10. 

  10.   File "D:/myfiles/study/python/oldboy/Day8/t8.py", line 12, in <module>
    11. 

  11.     print(obj)
    12. 

  12. TypeError: __str__ returned non-string (type NoneType)
    13. 





8、__getitem__、__setitem__、__delitem__


用于索引操作，如字典。以上分别表示获取、设置、删除数据


    

  1. class Foo(object):
    2. 

    3. 

  3.     def __getitem__(self, key):
    4. 

  4.         print(‘__getitem__‘, key)
    5. 

    6. 

  6.     def __setitem__(self, key, value):
    7. 

  7.         # print(‘__setitem__‘, key, value)
    8. 

  8.         self.key  = key
    9. 

  9.         self.value = value
    10. 

  10.         print(key,value)
    11. 

  11.         return self.key
    12. 

    13. 

  13.     def __delitem__(self, key):
    14. 

  14.         print(‘__delitem__‘, key)
    15. 

    16. 

    17. 

  17. obj = Foo()
    18. 

    19. 

  19. result = obj[‘k1‘]   # 自动触发执行 __getitem__
    20. 

  20. obj[‘k3‘] = ‘xxxxxx‘ # 自动触发执行 __setitem__
    21. 

  21. del obj[‘k1‘]        # 自动触发执行 __delitem__
    22. 





    

  1. __getitem__ k1
    2. 

  2. k3 xxxxxx
    3. 

  3. __delitem__ k1
    4. 





9、__getslice__、__setslice__、__delslice__  #3.x 废弃，都用上面的__getitem__、__setitem__、__delitem__


该三个方法用于分片操作，如：列表


    

  1. class Foo(object):
    2. 

  2.     def __getitem__(self, key):
    3. 

  3.         print(‘__getitem__‘, key)
    4. 

  4.         
    5. 

  5.     def __setitem__(self, key, value):
    6. 

  6.         # print(‘__setitem__‘, key, value)
    7. 

  7.         self.key  = key
    8. 

  8.         self.value = value
    9. 

  9.         print(key,value)
    10. 

  10.         return self.key
    11. 

  11.     
    12. 

  12.     def __delitem__(self, key):
    13. 

  13.         print(‘__delitem__‘, key)
    14. 

  14. obj = Foo()
    15. 

  15. # result = obj[‘k1‘]   # 自动触发执行 __getitem__
    16. 

  16. # obj[‘k3‘] = ‘xxxxxx‘ # 自动触发执行 __setitem__
    17. 

  17. # del obj[‘k1‘]        # 自动触发执行 __delitem__
    18. 

    19. 

  19. obj[1:10:2] # 输出slice(1, 10, 2) slice类型的起始值，结束值，步长值
    20. 

  20. obj[2:20:4] = [11,22,33,44,55] # 输出 slice(2, 20, 4) [11, 22, 33, 44, 55]
    21. 

  21. obj[2:20:4] = ‘alex‘ # 输出slice(2, 20, 4) alex
    22. 

  22. del obj[4:20:4] # 输出 slice(4, 20, 4)
    23. 





10. __iter__ 


用于迭代器，之所以列表、字典、元组可以进行for循环，是因为类型内部定义了 __iter__


    

  1. class A:
    2. 

    3. 

  3.     def __init__(self, sq):
    4. 

  4.         self.sq = sq
    5. 

    6. 

  6.     def __iter__(self):
    7. 

  7.         return iter(self.sq)
    8. 

    9. 

  9. obj1 = A("11,22,33,44")
    10. 

  10. obj2 = A([11,22,33,44])
    11. 

    12. 

  12. for i in obj1:
    13. 

  13.     print(i)
    14. 

  14. for i in obj2:
    15. 

  15.     print(i)
    16. 





    

  1. 1
    2. 

  2. 1
    3. 

  3. ,
    4. 

  4. 2
    5. 

  5. 2
    6. 

  6. ,
    7. 

  7. 3
    8. 

  8. 3
    9. 

  9. ,
    10. 

  10. 4
    11. 

  11. 4
    12. 

  12. 11
    13. 

  13. 22
    14. 

  14. 33
    15. 

  15. 44
    16. 





以上步骤可以看出，for循环迭代的其实是  iter([11,22,33,44]) ，所以执行流程可以变更为：


    

  1. obj = iter([11, 22, 33, 44])
    2. 

    3. 

  3. for i in obj:
    4. 

  4.     print(i)
    5. 





在加两个例子，加深理解：（__iter__函数返回的是可迭代对象）


    

  1. class A:
    2. 

    3. 

  3.     def __iter__(self):
    4. 

  4.         return iter([11,22,33])
    5. 

    6. 

  6. obj = A()
    7. 

  7. for x in obj:
    8. 

  8.     print(x)
    9. 

    10. 

  10. class B:
    11. 

    12. 

  12.     def __iter__(self):
    13. 

  13.         yield ‘‘
    14. 

  14.         yield 1
    15. 

  15.         yield 2
    16. 

  16.         yield 3
    17. 

    18. 

  18. obj = B()
    19. 

  19. for x in obj:
    20. 

  20.     print(x)
    21. 







11.super  主动执行父类的方法



    

  1. class A:
    2. 

    3. 

  3.     def f1(self):
    4. 

  4.         print(‘c1.f1‘)
    5. 

  5.         return 123
    6. 

    7. 

  7. class B(A):
    8. 

    9. 

  9.     def f1(self):
    10. 

  10.         print(‘before c2.f1‘)
    11. 

  11.         # 主动执行父类的方法
    12. 

  12.         super(B,self).f1()   # 这里第一个参数是子类而不是父类
    13. 

  13.         print(‘after c2.f1‘)
    14. 

    15. 

    16. 

  16. obj1 = A()
    17. 

  17. obj2 = B()
    18. 

  18. obj1.f1()
    19. 

  19. obj2.f1()
    20. 





    

  1. c1.f1
    2. 

  2. before c2.f1
    3. 

  3. c1.f1
    4. 

  4. after c2.f1
    5. 





利用上面的知识点，写一个有序字典：


    

  1. class MyDict(dict):
    2. 

    3. 

  3.     def __init__(self):
    4. 

  4.         self.temp_list = []
    5. 

  5.         super(MyDict,self).__init__()
    6. 

    7. 

  7.     def __setitem__(self, key, value):
    8. 

  8.         self.temp_list.append(key)
    9. 

  9.         super(MyDict,self).__setitem__(key, value)
    10. 

    11. 

  11.     def __str__(self):
    12. 

  12.         my_list = []
    13. 

  13.         for x in self.temp_list:
    14. 

  14.             value = self.get(x)
    15. 

  15.             my_list.append("‘{}‘:{}".format(x,value))
    16. 

  16.         temp_dict = ‘{‘+‘,‘.join(my_list)+‘}‘
    17. 

  17.         return temp_dict
    18. 

    19. 

  19. obj = MyDict()
    20. 

  20. obj["k1"] = 123
    21. 

  21. obj["k2"] = 456
    22. 

  22. obj["k3"] = 789
    23. 

  23. print(obj)
    24. 





单例模式：


    

  1. class B:
    2. 

  2.     instance = None
    3. 

    4. 

  4.     def __init__(self,name):
    5. 

  5.         self.name = name
    6. 

    7. 

  7.     @classmethod
    8. 

  8.     def get_instance(cls):
    9. 

  9.         if cls.instance:
    10. 

  10.            return cls.instance
    11. 

  11.         else:
    12. 

  12.             obj = cls(‘xiaoyao‘)
    13. 

  13.             cls.instance = obj
    14. 

  14.             return obj
    15. 

    16. 

  16. obj1 = B.get_instance()
    17. 

  17. print(obj1)
    18. 

  18. obj2 = B.get_instance()
    19. 

  19. print(obj2)
    20. 





    

  1. <__main__.B object at 0x004CB2F0>
    2. 

  2. <__main__.B object at 0x004CB2F0>
    3. 





 异常捕获：




    

  1. while True:
    2. 

  2.     num1 = input("num1:").strip()
    3. 

  3.     num2 = input("num2:").strip()
    4. 

  4.     try:
    5. 

  5.         num = int(num1) + int(num2)
    6. 

  6.         print(num)
    7. 

  7.     except Exception as ex:
    8. 

  8.         print(ex)
    9. 





完整语法：


没有异常的执行顺序：try--else--finally


有异常的执行顺序：try--except--finally






try:    print(‘a‘)    raise ValueError(‘主动抛出异常！‘) # 错误类型ValueError可以改成你想要的except ValueError as ex:    print(ex)except Exception as ex:    print(ex)else:    print(‘b‘)finally:


    print(‘c‘)




断言：


assert 1==1assert 1==2


    assert 1==2
AssertionError




来自为知笔记(Wiz)
				


				
时间： 2024-11-07 14:57:20 

		


		


	

	
	

		


		
面向对象（八）的相关文章


						

		

			

                疯狂java学习笔记之面向对象(八) - static和final
			

		

		

									

				一.static: 1.static是一个标识符: - 有static修饰的成员表明该成员是属于类的; - 没有static修饰的成员表明该成员是属于实例/对象的. 2.static修饰的成员(Field.方法.初始化块),与类共存亡:static修饰的成员建议总是通过类名来访问,虽然它也可以通过实例来访问(实质也是通过类来访问的),所以平时若在其他程序中见到通过实例/对象来访问static成员时,可以直接将实例/对象 替换成类名: 3.程序都是先有类再有对象的,有可能出现有类但没有实例/对象的			

		

	

				

		

			

                java基础学习总结——面向对象1
			

		

		

									

				目录 一.面向过程的思想和面向对象的思想 二.简单理解面向对象 三.面向对象的设计思想 四.对象和类的概念 五.如何抽象出一个类? 六.类(对象)之间的关系 七.Java与面向对象 八.为什么使用面向对象编程? 一.面向过程的思想和面向对象的思想 面向对象和面向过程的思想有着本质上的区别, 作为面向对象的思维来说,当你拿到一个问题时,你分析这个问题不再是第一步先做什么,第二步再做什么,这是面向过程的思维,你应该分析这个问题里面有哪些类和对象,这是第一点,然后再分析这些类和对象应该具有哪些属性和方			

		

	

				

		

			

                Python学习系列（八）( 面向对象基础）
			

		

		

									

				 Python学习系列(八)( 面向对象基础) Python学习系列(七)( 数据库编程) 一,面向对象 1,域:属于一个对象或类的变量.有两种类型,即实例变量—属于每个实例/类的对象:类变量—属于类本身. 2,类的方法:对象也可以使用属于类的函数来具有功能,这样的函数称之为类的方法.域和方法合称为类的属性.类使用class关键字创建,类的属性被列在一个缩进块中. 3,self:类的方法与普通的函数只有一个特别的区别----他们必须有一个额外的第一个参数名称,但是在调用的时候不能为其赋值,Pyt			

		

	

				

		

			

                JavaScript基础--面向对象三大特性（八）：继承封装多态
			

		

		

									

				一.构造函数基本用法:function 类名(参数列表){属性=参数值} 1 function Person(name,age){ 2 this.name = name; 3 this.age = age; 4 } 5 6 //创建Person对象的时候,可以直接给名字和年龄 7 var p1 = new Person('abc',80); 8 window.alert(p1.name); 9 var p2 = new Person('hello',9); 10 window.alert(p2.			

		

	

				

		

			

                java面向对象编程(八)--抽象类、接口
			

		

		

									

				1.抽象类 1.1抽象类概念 当父类的一些方法不能确定时,可以用abstract关键字来修饰该方法[抽象方法],用abstract来修饰该类[抽象类]. //抽象类的必要性[Demo124.java] public class Demo124 { public static void main(String[] args) { //Animal an=new Animal();抽象类不允许实例化 Animal an=new Cat(); an.cry(); an=new Dog(); an.cr			

		

	

				

		

			

                sdut 面向对象程序设计上机练习八（对象数组）
			

		

		

									

				面向对象程序设计上机练习八(对象数组) Time Limit: 1000MS Memory limit: 65536K 题目描述 利用类对象数组完成N个学生数据(学号是字符串类型.成绩是整型)的输入.输出. 输入 输入有N+1行: 第一行的整数N表示学生数目: 以下N行是N个学生的数据,每行中第一个是表示学号的字符串,第二个是表示学生成绩的整数. 输出 输出N个学生数据.每个学生的数据占一行. 示例输入 5 01 89 02 78 03 56 04 92 05 76 示例输出 01 89 02			

		

	

				

		

			

                第八篇：面向对象
			

		

		

									

				1 类与对象 类即类别.种类,是面向对象设计最重要的概念,对象是特征与技能的结合体,而类则是一系列对象相似的特征与技能的结合体 那么问题来了,先有的一个个具体存在的对象(比如一个具体存在的人),还是先有的人类这个概念,这个问题需要分两种情况去看 在现实世界中:先有对象,再有类 世界上肯定是先出现各种各样的实际存在的物体,然后随着人类文明的发展,人类站在不同的角度总结出了不同的种类,如人类.动物类.植物类等概念 也就说,对象是具体的存在,而类仅仅只是一个概念,并不真实存在 在程序中:务必保证先定义			

		

	

				

		

			

                杨玲 201771010133《面向对象程序设计（java）》第八周学习总结
			

		

		

									

				<面向对象程序设计(java)>第八周学习总结 第一部分:理论知识学习部分 1. 接口:用interface声明,是抽象方法和常量值定义的集 合.从本质上讲,接口是一种特殊的抽象类. (1)在Java程序设计语言中,接口不是类,而是对类 的一组需求描述,由常量和一组抽象方法组成. ? 接口中不包括变量和有具体实现的方法. (2)接口体中包含常量定义和方法定义,接口中只进 行方法的声明,不提供方法的实现. (3)通常接口的名字以able或ible结尾: (4)接口中的所有常量必须是public			

		

	

				

		

			

                张季跃&#160;201771010139《面向对象程序设计（java）》第八周学习总结
			

		

		

									

				张季跃 201771010139<面向对象程序设计(java)>第八周学习总结 理论知识部分: 6.1 接口 l(1)Java为了克服单继承的缺点,Java使用了接口, 一个类可以实现一个或多个接口. l (2) 在Java程序设计语言中,接口不是类,而是对类 的一组需求描述,由常量和一组抽象方法组成. l (3) 接口中不包括变量和有具体实现的方法. l (4) 只要类实现了接口,则该类要遵从接口描述的统 一格式进行定义,并且可以在任何需要该接口的 地方使用这个类的对象. 6.2 接口示例			

		

	

				

		

			

                201771010126 王燕《面向对象程序设计（java）》第十八周学习总结
			

		

		

									

				实验十八  总复习 实验时间 2018-12-30 1.实验目的与要求 (1) 综合掌握java基本程序结构: (2) 综合掌握java面向对象程序设计特点: (3) 综合掌握java GUI 程序设计结构: (4) 综合掌握java多线程编程模型: (5) 综合编程练习. 2.实验内容和步骤 任务1:填写课程课后调查问卷,网址:https://www.wjx.cn/jq/33108969.aspx. 任务2:综合编程练习 练习1:设计一个用户信息采集程序,要求如下: 1 package pro