精华内容
下载资源
问答
  • Python 数据模型

    2020-02-16 12:55:22
    Python 数据模型原文地址:Python 数据模型

    Python 数据模型

    原文地址:Python 数据模型

    展开全文
  • 这种设计思想完全体现在python数据模型上,而数据模型所描述的API为使用最地道的语言特性来构建自己的对象提供了工具。 简单说就是数据模型规范了这门语言(python)自身构建模块的接口,这些模块包括序列、迭代....

    python和其他语言大不相同的是,python具有自己的‘’python风格‘’

    如在python中的len(collection)在其他语言中可能是collection.len( ).

    这种设计思想完全体现在python的数据模型上,而数据模型所描述的API为使用最地道的语言特性来构建自己的对象提供了工具。 

    简单说就是数据模型规范了这门语言(python)自身构建模块的接口,这些模块包括序列、迭代器、函数等等。数据模型就好比是对python框架的描述。

    API是什么? https://segmentfault.com/q/1010000012531371 这里有介绍。

    不管在哪种框架下写程序,都会花费大量时间实现被框架本身调用的方法。python解释器在碰到特殊的句法时,会使用特殊方法去激活一些基本的对象操作。(这里的特殊方法就是两个下划线开始和结束,例如 __init__,也称双下方法 dunder-method)

    比如P[key]这句语句的背后就是__getitem__()方法。所以解释器实际上会调用 P.__getitem__(key)。

    通过实现特殊方法来利用python的数据模型有2个好处:

    1.作为编程的类的用户,用户不必去记住标准操作的各式名称。

    2.可以更加方便利用python标准库,避免重复发明轮子。



     


    展开全文
  • python官方文档中对于数据模型是这样介绍的 对象是Python对数据的抽象。Python程序中所有数据都由对象或对象之间的关系表示。在某种意义上,为了和冯诺依曼存储程序计算机模型保持一致,代码和数据一样也是一个...

    数据模型简介

    在python官方文档中对于数据模型是这样介绍的

    对象是Python对数据的抽象。Python程序中所有数据都由对象或对象之间的关系表示。在某种意义上,为了和冯诺依曼存储程序计算机模型保持一致,代码和数据一样也是一个对象(冯诺依曼模型中提到,数据和程序都以0,1存储于存储器中)

    简单的说,Python中的一切数据要么是对象,要么和对象有关系

    如果你带着来自其他面向对象语言的经验进入 Python 的世界,会对 len(object) 而不是 object.len() 写法觉得不适。但是它体现了Python的一种设计思想,也是pythonic的关键所在,而这种思想则体现在Python的数据模型中。

    数据模型其实是对 Python 框架的描述,它规范了这门语言自身构建模块的接口,这些模块包括但不限于序列、迭代器、函数、类和上下文管理器。

    特殊方法简析

    不管在哪种框架下写程序,都会花费大量时间去实现那些会被框架本身调用的方法, Python 也不例外。

    Python 解释器碰到特殊的句法时,会使用特殊方法去激活一些基本的对象操作,这些特殊方法的名字以两个下划线开头,以两个下划线结尾(例如 _ getitem_ )。比如 obj[key] 的背后就是 getitem 方法,为了能求得 my_collection[key] 的值,解释器实际上会调用 my_collection.getitem(key)
    这些特殊方法名能让你自己的对象实现和支持一下的语言架构,并与之交互

    • 迭代
    • 集合类
    • 属性访问
    • 运算符重载
    • 函数和方法的调用
    • 对象的创建和销毁
    • 字符串表示形式和格式化
    • 管理上下文(即with块)

    魔术方法(magic method)是特殊方法的昵称。特殊方法也叫双下方法(dunder method)。

    代码示例

    接下来通过一个简单的例子来展示如何实现_getitem__len_这两个特殊方法,通过这个例子我们也能见识到特殊方法的强大

    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]

    这段代码是一副扑克牌的原型,在这个自定义类中,有三个我们写的特殊方法,通过这几个方法,我们的自定义类就可以在使用的时候像Python的内置类型一样。 我们把这段代码保存为frenchdeck.py文件,然后通过命令行窗口进入该文件所在目录,这里用的是Python3,Python2应该也可以使用。

    进入Python shell后如下:

    Python 3.5.3 (v3.5.3:1880cb95a742, Jan 16 2017, 16:02:32) [MSC v.1900 64 bit (AMD64)] on win32
    Type "help", "copyright", "credits" or "license" for more information.
    >>> from frenchdeck import *
    >>> deck = FrenchDeck()
    >>> len(deck)
    >>> deck[0]
    Card(rank='2', suit='spades')
    >>> deck[-1]
    Card(rank='A', suit='hearts')
    >>>

    通过上面的这个例子,我们可以看到,当我们在使用len(deck)和deck[0]时,Python的解释器实际上分别调用了我们在自定义类中的_len__getitem_这两个方法。

    然后,假如我们现在要在这一副“扑克牌”中,随机的抽取出一张牌,我们要怎么做呢?自己在写一个方法吗?这在Python中是不用的,Python 已经内置了从一个序列中随机选出一个元素的函数 random.choice,我们直接把它用在这一摞纸牌实例上就好(解释器代码接上面):

    >>> from random import choice 
    >>> choice(deck)
    Card(rank='3', suit='hearts') 
    >>> choice(deck)
    Card(rank='K', suit='spades') 
    >>> choice(deck)
    Card(rank='2', suit='clubs')

    通过上面的两个例子,我们已经可以体会到通过实现特殊方法来利用 Python 数据模型的两个好处:

    1.作为你的类的用户,他们不必去记住标准操作的各式名称(“怎么得到元素的总数?是 .size() 还是 .length() 还是别的什么?”)。

    2.可以更加方便地利用 Python 的标准库,比如 random.choice 函数,从而不用重新发明轮子。

    同时,我们也能了解到,这些特殊方法的调用,通常都是隐式的,首先明确一点,特殊方法的存在是为了被Python解释器调用的,你自己并不需要调用它们。也就是说没有 my_object._len_() 这种写法,而应该使用 len(my_object)。在执行 len(my_object) 的时候,如果 my_object 是一个自定义类的对象,那么 Python 会自己去调用其中由你实现的 _len_ 方法。
    通过内置的函数(例如 len、iter、str,等等)来使用特殊方法是最好的选择。这些内置函数不仅会调用特殊方法,通常还提供额外的好处,而且对于内置的类来说,它们的速度更快。

    展开全文
  • 前话: python简单易用,库多就是这么强大,笔者也长期使用过java、c、c++等语言,嗯不多说,最后选择了python!...因此本文就是简单的通过介绍python数据模型和各种实用的小技巧来体现一下:PYTHONIC ,...



    前话: python简单易用,库多就是这么强大,笔者也长期使用过java、c、c++等语言,嗯不多说,最后选择了python! 但其实很多python程序猿都是其他语言转过来的,而且python兼容性也很高,所以比如java程序猿在写python的时候总能感觉到一股浓浓的java味,一个字:尬,两个字:尴尬!因此本文就是简单的通过介绍python数据模型和各种实用的小技巧来体现一下:PYTHONIC ,感受一下python语言的美妙之处,如果想更多了解python语言的风格,强烈推荐:流畅的Python



    一、python数据模型


    python数据模型是对python框架的描述,也就是说它规范了python这门语言自身构建模块的接口,这些自带模块中就含有一些
    特殊方法,在python框架下写程序,当python解释器碰到一些特殊的句法时,便会调用这些特殊方法去执行对象操作,这些特殊方法总结了一下几个特点:

    1、特殊方法的存在是为了被解释器调用的,自己并不需要调用他们
    2、大多数特殊方法的调用都是隐式的,但如__init__() 便显示调用超类的构造器
    3、调用特殊方法执行速度上很快,因为是在内置模块中的
    4、通过实现特殊方法,自定义数据类型可以表现的跟内置类型一样

    下面我们便通过实现特殊方法,自定义数据对象,来感受一下PYTHONIC

    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]


    上述代码中首先用collections.namedtuple()常见了一个的纸牌对象, 并定义了FrenchDeck类,类中实现了python的特殊方法: __len__()__getitem__()方法, 由于特殊方法__len__()定义我们可以直接对FrenchDeck对象进行len()操作,同时__getimtem__()方法把 [] 操作交给了self._cards列表, 我们可以直接把FrenchDeck对象当做list进行操作,可以直接根据索引取值,而且可以进行list的切片操作,演示如下:

    deck = FrenchDeck()
    print(len(deck))  #52
    deck[0]           #Card(rank='2', suit='spades')
    deck[1:3]  #[Card(rank='3', suit='spades'), Card(rank='4', suit='spades')]
    from random import choice
    choice(deck)   #随机对deck对象进行选择


    简而言之, python中含有很多特殊方法,可以方便的实现且快速的实现特定功能,同时我们也可以在定义的数据类型中去实现特殊方法,这样自定义数据类型就可以表现的和python内置类型一样,写出更具有python风格的代码,下面通过一些python中实用技巧再看一下python的独到之处




    二、python各种使用小技巧


    1、python一行代码定义list

    利用python的列表推导式, 可通过一行代码定义list

    numbers = [1, 2, 3, 4, 5, 6]
    list1 = [n * 2 for n in numbers]
    list2 = [n**2 for n in numbers]


    2、字典推导式

    字典推导式类似于列表推导式,在用于字典key、value翻转时十分方便

    sample = ['a', 'b', 'c', 'd', 'e']
    s_dict = {key:value for value,key in enumerate(sample)}
    print(s_dict)   #{'d': 3, 'a': 0, 'b': 1, 'e': 4, 'c': 2}
    inversed_sdict = {value:key for key,value in s_dict.items()}
    print(inversed_sdict)  #{0: 'a', 1: 'b', 2: 'c', 3: 'd', 4: 'e'}


    3、python中两个变量值交换

    看下面,一行代码,无需构建中间变量,可以说是相当方便了

    a, b = 1, 2
    a, b = b, a
    print('a=%d, b=%d'%(a, b))


    4、lambda创建匿名函数

    python中构建函数可以不适用函数定义,直接如下一条语句定义一次性匿名函数

    double = lambda x: x*2
    double(5)   #10


    5、map操作和filter操作

    map操作和filter操作可以结合lambda函数一起使用,利用简单的实现一些高效的操作

    (1)、map(func, s): 对集合s中每个元素执行func函数操作;
    (2)、filter(func, s): 筛选集合s中满足func函数定义的元素

    seq = [1, 2, 3, 4, 5]
    print(list(map(lambda x:x*2, seq)))     #[2, 4, 6, 8, 10]
    print(list(filter(lambda x:x>2, seq)))  #[3, 4, 5]


    6、python中join操作

    join操作可以有效的实现字符串的拼接操作

    a = ['my', 'name', 'is', 'CHEONG]
    print(' '.join(a))                     #my name is CHEONG
    b = [1, 2, 3, 4, 5, 6]
    print(''.join(str(ele) for ele in b))  #123456


    7、操作符链式调用、函数链式调用

    (1) 操作符链式调用

    num = 5
    if 7 > num > 4:
        print('链式比较操作符')

    (2) 函数链式调用

    class Person:
        def name(self, name):
            self.name = name
            return self
    
        def age(self, age):
            self.age = age
            return self
    
        def show(self):
            print("My name is", self.name, "and I am", self.age, "years old.")
    
    p = Person()
    p.name("CHEONG").age(8).show() #My name is CHEONG and I am 8 years old.


    8、字符串和list倒转

    直接使用list切片操作,超简单,当然也可以使用reversed() 函数

    s = 'abcdef'                   
    print(s[::-1])               #fedcba
    a = [5, 4, 3, 2, 1]
    print(a[::-1])               #[1, 2, 3, 4, 5]
    num = 123456789
    print(int(str(num)[::-1]))   #987654321


    9、按value值排序字典

    sorted()函数、items()函数、lambda()函数综合使用

    sample = ['C', 'H', 'E', 'O', 'N', 'G']
    s_dict = {key:value for value,key in enumerate(sample)}
    print(s_dict)      #{'O': 3, 'E': 2, 'H': 1, 'C': 0, 'N': 4, 'G': 5}
    sort_sdict = sorted(s_dict.items(), key = lambda x:x[1])
    print(sort_sdict)  #[('C', 0), ('H', 1), ('E', 2), ('O', 3), ('N', 4), ('G', 5)]


    10、list中最大和最小值索引

    有时候我们对list元素不感兴趣,而对list元素的索引十分感兴趣,,此时便排上用场

    lst = [4, 1, 2, 3, 5]
    min_idx = min(range(len(lst)), key=lst.__getitem__)
    max_idx = max(range(len(lst)), key=lst.__getitem__)
    print(min_idx)   #min_idx=1
    print(max_idx)   #max_idx=4


    11、list赋值技巧以及深拷贝浅拷贝

    python中list对象lst1=lst2,其中对象lst1指向的是lst2的对象所在指针,在内存中lst1、lst2指向的是同一块内存,所以有时候使用浅拷贝还是深拷贝要注意

    (1) list赋值技巧

    lst1 = [1, 2, 3, 4]
    lst2 = lst1
    lst2[2] = 4
    print(lst1)   #[1, 2, 4, 4]

    注意到上面修改lst2,则lst1也相应发生了变化,如果想要lst2指向另一个内存空间,用下面操作

    #方式1
    lst1 = [1, 2, 3, 4]
    lst2 = list(a)
    lst2[2] = 4
    print(lst1)   #[1, 2, 3, 4]
    
    #方式2
    lst1 = [1, 2, 3, 4]
    lst2 = lst1[:]
    lst2[2] = 4
    print(lst1)   #[1, 2, 3, 4]


    (2) python中浅拷贝和深拷贝

    python中的浅拷贝copy()函数,b浅拷贝a后则b、a指向同一个内存空间; 但python中copy模块有深拷贝函数deepcopy()函数,当b深拷贝a后,则b、a指向不同的内存空间

    import copy
    a = {1:[1, 2, 3], 2:[1, 2, 3, 4]}
    b = a.copy()
    a[1].append(4)
    print(a)     #{1: [1, 2, 3, 4], 2: [1, 2, 3, 4]}
    print(b)     #{1: [1, 2, 3, 4], 2: [1, 2, 3, 4]}
    
    c = copy.deepcopy(a)
    a[1].append(5)
    print(a)     #{1: [1, 2, 3, 4, 5], 2: [1, 2, 3, 4]}
    print(b)     #{1: [1, 2, 3, 4, 5], 2: [1, 2, 3, 4]}
    print(c)     #{1: [1, 2, 3, 4], 2: [1, 2, 3, 4]}


    12、collections集合模块


    (1) collections.namedtuple定义简单对象

    from collections import namedtuple
    Point = namedtuple('Point', ['x', 'y'])
    p = Point(1, 2)
    print(p.x, p.y)    #1 2


    (2) collections.Counter代替字典进行统计

    from collections import Counter
    c = Counter()
    lst = [1, 1, 2, 2, 2, 3, 4, 5, 5]
    for ele in lst:
        c[ele] += 1
    print(dict(c))  #{1: 2, 2: 3, 3: 1, 4: 1, 5: 2}


    (3) collections.deque双向列表

    python中列表list按照索引访问元素速度快,但是插入和删除就很慢了,因此可以使用collections.deque实现快速的插入和删除,并且collections.deque提供了从序列头部插入和删除

    from collections import deque
    q = deque(['a', 'b', 'c'])
    q.append('d')
    print(q)          #deque(['a', 'b', 'c', 'd'])
    q.appendleft('x')
    print(q)          #deque(['x', 'a', 'b', 'c', 'd'])
    q.pop()
    print(q)          #deque(['x', 'a', 'b', 'c'])
    q.popleft()
    print(q)          #deque(['a', 'b', 'c'])





    后话: 本文自然只是列举了部分常用的显示PYTHONIC风格的实用技巧,想了解更多多看看流畅的Python,绝对良心书籍! 欢迎大家交流分享!

    展开全文
  • 一致性品质 Python 最好的品质之一是一致性。 我对这句话的理解是,Python ...数据模型其实是对 Python 框架的描述,它规范了这门语言自身构建模块的接口,这些模块包括但不限于序列、迭代器、函数、类和上下文...
  • 这一章主要讲述如何用特殊方法去激活一些基本的对象操作,这些特殊方法的名字以两个下划线开头,以两个下划线结尾(例如getitem...本章的实例是一摞python风格的纸牌,很有嚼头。第一个示例1-1 建立了一个纸牌类:impor
  • Python数据分析常用模型介绍Python数据分析--玩转统计模型视频课程, PYTHON可视化分析数据挖掘内常用的数据模型讲解.系统、全面的介绍方差分析模型、回归模型、logistic回归等各种经典统计模型,以及树模型、神经...
  • python flask可以应用于建立各种各样的数据模型,首先初始化数据库,再将数据模型写入数据库中,具体代码如下 # -*- coding: utf-8 -*- from flask import Flask from flask_sqlalchemy import SQLAlchemy app =...
  • python与平台有关吗_Python教程Python与平台无关,... python ipo模型是指什么IPO(Input Processing Output)模式,即输入数据→处理数据→输出结果。例如:python中count函数的用法详解_Python教程python中count函...
  • 那么python数据挖掘的具体流程是怎样的,下面就跟小编一起来看吧。1.定义挖掘目标这一步骤主要是分析要python数据挖掘的目标,明确系统完成后想要达的效果,定义问题的相关范围。首先结合具体业务,分析问题,之后...
  • Python数据模型(特殊方法) 数据模型其实是对Python框架的描述,它规范了这门语言自身构架模块的接口,这些模块包括但不限于序列、迭代器、函数、类和上下文管理器。简单来说,数据模型就是Python自身的数据类型,...
  • 我用good-turning平滑计算c*时,结果出现负数,这个问题该怎么解决,望各位大神回复

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,865
精华内容 7,946
关键字:

python数据模型

python 订阅