• Python数据模型


    引言

    像大多数人一样,我在对一直传统的面向过程语言C一知半解之后,走进了面向对象的世界,尽管对OOP一无所知,还好Python还保留有函数式编程,这使得我才不那么抵触,直到现在,习惯了面向对象之后,也习惯了接口这些叫法,而不是函数。

    在看到len(collection)与collection.len(),也越来越习惯后者,他所代表的强大的思想,(其实是调用的collection对象的内部__len__方法),这种设计思想完全体现在 Python 的数据模型上,而数据模型所描述的 API,为使用最地道的语言特性来构建你自己的

    对象提供了工具。数据模型其实是对 Python 框架的描述,它规范了这门语言自身构建模块的接口,这些模块包括但不限于序列、迭代器、函数、类等。

    一、私有和被保护的属性

    类的私有属性:

    __private_attrs:两个下划线开头,声明该属性为私有,不能在类地外部被使用或直接访问。
    在类内部的方法中使用时  self.__private_attrs。

    类的方法:

    在类地内部,使用def关键字可以为类定义一个方法,与一般函数定义不同,类方法必须包含参数self,且为第一个参数

    类的私有方法 :

    __private_method:两个下划线开头,声明该方法为私有方法,不能在类地外部调用。
    在类的内部调用 self.__private_methods

    默认情况下,Python中的成员函数和成员变量都是公开的(public),在python中没有类似public,private等关键词来修饰成员函数和成员变量。
    在python中定义私有变量只需要在变量名或函数名前加上 ”__“两个下划线,那么这个函数或变量就是私有的了。
    在内部,python使用一种 name mangling 技术,将 __membername替换成 _classname__membername,也就是说,类的内部定义中,
    所有以双下划线开始的名字都被"翻译"成前面加上单下划线和类名的形式。

         例如:为了保证不能在class之外访问私有变量,Python会在类的内部自动的把我们定义的__spam私有变量的名字替换成为
    _classname__spam(注意,classname前面是一个下划线,spam前是两个下划线),因此,用户在外部访问__spam的时候就会
    提示找不到相应的变量。   python中的私有变量和私有方法仍然是可以访问的;访问方法如下:

    私有变量:实例._类名__变量名
    私有方法:实例._类名__方法名()
     1 class people():
     2     __place = "nanjing"
     3     _age1 = 20
     4 
     5     def __init__(self, name):
     6         self.name = name
     7 
     8     def __sayhello(self):
     9         print("%s say hello" % self.name)
    10 
    11 class teacher(people):
    12     pass
    13 
    14 t1 = teacher("cmz")
    15 print(t1._people__place)  # 访问私有变量
    16 t1._people__sayhello()    # 访问私有方法
    17 
    18 结果是
    19 nanjing
    20 cmz say hello
    21 
    22 python私有属性和方法案例
    View Code

    其实,Python并没有真正的私有化支持,但可用下划线得到伪私有。   尽量避免定义以下划线开头的变量!

    (1)_xxx      "单下划线" 开始的成员变量叫做保护变量,意思是只有类实例和子类实例能访问到这些变量,
                   需通过类提供的接口进行访问;不能用'from module import *'导入
    (2)__xxx    类中的私有变量/方法名 (Python的函数也是对象,所以成员方法称为成员变量也行得通。),
                  " 双下划线 " 开始的是私有成员,意思是只有类对象自己能访问,连子类对象也不能访问到这个数据。
    (3)__xxx__ 系统定义名字,前后均有一个“双下划线” 代表python里特殊方法专用的标识,如 __init__()代表类的构造函数。
     1 class people():
     2     __place = "nanjing"
     3     _age = 20
     4 
     5     def __init__(self, name):
     6         self.name = name
     7 
     8     def _test(self):
     9         print("from people test")
    10 
    11     def __sayhello(self):
    12         print("%s say hello" % self.name)
    13 
    14 class teacher(people):
    15     pass
    16 
    17 t1 = teacher("cmz")
    18 print(t1._age)
    19 print(people._age)
    20 t1._test()
    21 people._test(t1) # 传入对象t1
    22 
    23 结果是
    24 20
    25 20
    26 from people test
    27 from people test
    View Code
     1 class people():
     2     __place = "nanjing"
     3     _age = 20
     4 
     5     def __init__(self, name):
     6         self.name = name
     7 
     8     def __sayhello(self):
     9         print("%s say hello" % self.name)
    10 
    11 class teacher(people):
    12     pass
    13 
    14 t1 = teacher("cmz")
    15 print(t1._people__place)
    16 t1._people__sayhello()
    17 
    18 结果是
    19 nanjing
    20 cmz say hello
    View Code

    二、搭建一摞pythonic的纸牌

    python的另一强大之处就是丰富的标准库,还有许许多多的第三方库,这使得不用重复造轮子

    import collections
    Card = collections.namedtuple('Card', ['rank', 'suit'])
    class FrenchDeck:
      ranks = [str(n) for n in range(2, 11)] + list('JQKA')
      suits = 'spades diamonds clubs hearts'.split()
      def __init__(self):
        self._cards = [Card(rank, suit) for suit in self.suits
                  for rank in self.ranks]
      def __len__(self):
        return len(self._cards)
      def __getitem__(self, position):
        return self._cards[position]

    deck = FrenchDeck()
    for i in deck[:10]:  # 其实这里调用的是deck这个可迭代对象背后其实用的是 iter(x),而这个函数的背后则是 x.__iter__() 方法

      print(i)

    #打印十张纸牌
    Card(rank='2', suit='spades')
    Card(rank='3', suit='spades')
    Card(rank='4', suit='spades')
    Card(rank='5', suit='spades')
    Card(rank='6', suit='spades')
    Card(rank='7', suit='spades')
    Card(rank='8', suit='spades')
    Card(rank='9', suit='spades')
    Card(rank='10', suit='spades')
    Card(rank='J', suit='spades')
    # 对纸牌进行排序

    suit_values = dict(spades=3, hearts=2, diamonds=1, clubs=0) def spades_high(card): rank_value = FrenchDeck.ranks.index(card.rank) return rank_value * len(suit_values) + suit_values[card.suit] for card in sorted(deck, key=spades_high): print(card) Card(rank='2', suit='clubs') Card(rank='2', suit='diamonds') Card(rank='2', suit='hearts') ... (46 cards ommitted) Card(rank='A', suit='diamonds') Card(rank='A', suit='hearts') Card(rank='A', suit='spades')

      

    三、特殊方法

    下面来看看特殊方法

    beer_card = Card('7', 'diamonds')
    >>> beer_card
    Card(rank='7', suit='diamonds')

    len()方法与特殊方法__len__,

    特殊方法的存在是为了被 Python 解释器调用的,你自己并不需要调用它们。也就是说没有 my_object.__len__() 这种写法,而应该使用 len(my_object)。在执行 len(my_object) 的时候,如果my_object 是一个自定义类的对象,那么 Python 会自己去调用其中由

    你实现的 __len__ 方法。abs也是同理,

    如果是 Python 内置的类型,比如列表(list)、字符串(str)、字节序列(bytearray)等,那么 CPython 会抄个近路,__len__ 实际上会直接返回 PyVarObject 里的 ob_size 属性。PyVarObject 是表示内存中长度可变的内置对象的 C 语言结构体。直接读取这

    个值比调用一个方法要快很多。

    >>> deck = FrenchDeck()
    >>> len(deck)
    52

    从一叠牌中抽取特定的一张纸牌,比如说第一张或最后一张,是很容易的:deck[0] 或 deck[-1]。这都是由 __getitem__ 方法提供的

    字典中也有这种用法,类似dic[k], 其背后也是__getitem__在默默支持,不过这里返回的值而是键k所对应的值value

    >>> deck[0]
    Card(rank='2', suit='spades')
    >>> deck[-1]
    Card(rank='A', suit='hearts'

    3.1、运算符重载

    说到特殊方法来看一下运算符重载,运算符重载只是意味着在类方法中拦截内置的操作——当类的实例出现在内置操作中,Python自动调用你的方法,并且你的方法的返回值变成了相应操作的结果。

    # Number类提供了一个方法来拦截实例的构造函数(__init__),此外还有一个方法捕捉减法表达式(__sub__)。这种特殊的方法是钩子,可与内置运算绑定。
    >>> class Number: def __init__(self,start): self.data = start def __sub__(self,other): return Number(self.data - other) >>> X = Number(5) >>> X.data 5 >>> Y = X - 2 >>> Y.data 3

     3.2、 方法重载

    overloading method:是在一个类里面,方法名字相同,而参数不同。返回类型呢?可以相同也可以不同。重载是让类以统一的方式处理不同类型数据的一种手段。
    函数重载主要是为了解决两个问题。
    1.可变参数类型。
    2.可变参数个数。

    另外,一个基本的设计原则是,仅仅当两个函数除了参数类型和参数个数不同以外,其功能是完全相同的,此时才使用函数重载,如果两个函数的功能其实不同,那么不应当使用重载,而应当使用一个名字不同的函数。
     
    对于情况 1 ,函数功能相同,但是参数类型不同,python 如何处理?答案是根本不需要处理,因为 python 可以接受任何类型的参数,如果函数的功能相同,那么不同的参数类型在 python 中很可能是相同的代码,没有必要做成两个不同函数。

    对于情况 2 ,函数功能相同,但参数个数不同,python 如何处理?大家知道,答案就是缺省参数。对那些缺少的参数设定为缺省参数即可解决问题。因为你假设函数功能相同,那么那些缺少的参数终归是需要用的。

    鉴于情况 1 跟 情况 2 都有了解决方案,python 自然就不需要函数重载了。

    子类不想原封不动地继承父类的方法,而是想作一定的修改,这就需要采用方法的重写。方法重写(overriding method)又称方法覆盖。

     

    3.3、常见的特殊方法

    当然也可以使用dir内置函数来查看常见并比较的数据结构的特殊方法,如list,dict等。

    dir(list)
    ['__add__',
     '__class__',
     '__contains__',
     '__delattr__',
     '__delitem__',
     '__dir__',
     '__doc__',
     '__eq__',
     '__format__',
     '__ge__',
     '__getattribute__',
     '__getitem__',
     '__gt__',
     '__hash__',
     '__iadd__',
     '__imul__',
     '__init__',
     '__iter__',
     '__le__',
     '__len__',
     '__lt__',
     '__mul__',
     '__ne__',
     '__new__',
     '__reduce__',
     '__reduce_ex__',
     '__repr__',
     '__reversed__',
     '__rmul__',
     '__setattr__',
     '__setitem__',
     '__sizeof__',
     '__str__',
     '__subclasshook__',
     'append',
     'clear',
     'copy',
     'count',
     'extend',
     'index',
     'insert',
     'pop',
     'remove',
     'reverse',
     'sort']
    View Code
    dir(tuple)
    ['__add__',
     '__class__',
     '__contains__',
     '__delattr__',
     '__dir__',
     '__doc__',
     '__eq__',
     '__format__',
     '__ge__',
     '__getattribute__',
     '__getitem__',
     '__getnewargs__',
     '__gt__',
     '__hash__',
     '__init__',
     '__iter__',
     '__le__',
     '__len__',
     '__lt__',
     '__mul__',
     '__ne__',
     '__new__',
     '__reduce__',
     '__reduce_ex__',
     '__repr__',
     '__rmul__',
     '__setattr__',
     '__sizeof__',
     '__str__',
     '__subclasshook__',
     'count',
     'index']
    View Code
  • 相关阅读:
    经典面试题回答——学习Java基础的目的
    Woody的逻辑游戏--怎样换轮胎
    skype默认占用80和443port
    opencl+opencv实现sobel算法
    Rational 最新软件试用下载地址
    leetcode-20-Valid Parentheses
    JPA学习笔记(11)——使用二级缓存
    新浪微博授权登陆获取个人信息
    Ubuntu 12.04 64bit GCC交叉编译器制作 原创
    表单兼容类型设计
  • 原文地址:https://www.cnblogs.com/welan/p/9419230.html
Copyright © 2020-2023  润新知