python-3.x global用法 - Python函數定義中的->意思是什麼?





python全域陣列 str用法 (4)


這些是PEP 3107中涵蓋的功能註釋。 具體來說, ->標記返回函數註釋。

例子:

>>> def kinetic_energy(m:'in KG', v:'in M/S')->'Joules': 
...    return 1/2*m*v**2
... 
>>> kinetic_energy.__annotations__
{'return': 'Joules', 'v': 'in M/S', 'm': 'in KG'}

註釋是詞典,所以你可以這樣做:

>>> '{:,} {}'.format(kinetic_energy(20,3000),
      kinetic_energy.__annotations__['return'])
'90,000,000.0 Joules'

你也可以有一個Python數據結構,而不僅僅是一個字符串:

>>> rd={'type':float,'units':'Joules','docstring':'Given mass and velocity returns kinetic energy in Joules'}
>>> def f()->rd:
...    pass
>>> f.__annotations__['return']['type']
<class 'float'>
>>> f.__annotations__['return']['units']
'Joules'
>>> f.__annotations__['return']['docstring']
'Given mass and velocity returns kinetic energy in Joules'

或者,您可以使用函數屬性來驗證調用的值:

def validate(func, locals):
    for var, test in func.__annotations__.items():
        value = locals[var]
        try: 
            pr=test.__name__+': '+test.__docstring__
        except AttributeError:
            pr=test.__name__   
        msg = '{}=={}; Test: {}'.format(var, value, pr)
        assert test(value), msg

def between(lo, hi):
    def _between(x):
            return lo <= x <= hi
    _between.__docstring__='must be between {} and {}'.format(lo,hi)       
    return _between

def f(x: between(3,10), y:lambda _y: isinstance(_y,int)):
    validate(f, locals())
    print(x,y)

打印

>>> f(2,2) 
AssertionError: x==2; Test: _between: must be between 3 and 10
>>> f(3,2.1)
AssertionError: y==2.1; Test: <lambda>

我最近注意到Python 3.3語法規範時有一些有趣的地方:

funcdef: 'def' NAME parameters ['->' test] ':' suite

Python 2中缺少可選的“箭頭”塊,我無法在Python 3中找到任何有關其含義的信息。事實證明,這是正確的Python,它已被解釋器接受:

def f(x) -> 123:
    return x

我認為這可能是某種先決條件語法,但是:

  • 我不能在這裡測試x ,它仍然是未定義的,
  • 無論我放在箭頭後面(例如2 < 1 ),它都不會影響功能行為。

任何習慣於這種語法的人都可以解釋它嗎?




這是一個功能註釋

更詳細地說,Python 2.x具有文檔字符串,它允許您將元數據字符串附加到各種類型的對象。 這非常方便,因此Python 3通過允許您將元數據附加到描述其參數和返回值的函數來擴展該功能。

沒有先入為主的用例,但PEP提出了幾個。 一個非常方便的是允許你用他們預期的類型註釋參數; 那麼編寫一個裝飾器來驗證註釋或將參數強制轉換為正確的類型將很容易。 另一種是允許參數特定的文檔,而不是將其編碼到文檔字符串中。




正如其他答案所述, ->符號被用作功能註釋的一部分。 然而,在Python >= 3.5更新版本中,它具有定義的含義。

PEP 3107 - 功能註釋描述了規範,定義了語法變化,存儲了它們的func.__annotations__ ,並且它的用例仍然是開放的。

但是,在Python 3.5PEP 484 - Type Hints將單一含義賦予此: ->用於指示函數返回的類型。 它也似乎將在未來的版本中執行,如現有使用註釋的說明中所述

最快可想像的方案將在3.6中引入對非類型提示註釋的靜態棄用,在3.7中完全棄用,並且將類型提示聲明為Python 3.8中唯一允許使用註釋的方式。

(強調我的)

據我所知,這還沒有實際實施,所以可能會碰到未來的版本。

根據這個,你提供的例子:

def f(x) -> 123:
    return x

將來會被禁止(並且在當前版本中會令人困惑),它需要被更改為:

def f(x) -> int:
    return x

因為它有效地描述函數f返回一個int類型的對象。

Python本身沒有以任何方式使用註釋,它幾乎填充並忽略它們。 第三方庫需要與他們合作。




類作為對象

在理解元類之前,您需要掌握Python中的類。 Python對Smalltalk語言借用的類有一個非常奇特的想法。

在大多數語言中,類只是描述如何生成對象的代碼片段。 在Python中也是如此:

>>> class ObjectCreator(object):
...       pass
...

>>> my_object = ObjectCreator()
>>> print(my_object)
<__main__.ObjectCreator object at 0x8974f2c>

但是類比Python更多。 類也是對象。

是的,對象。

一旦使用關鍵字class ,Python就會執行它並創建一個OBJECT。 指示

>>> class ObjectCreator(object):
...       pass
...

在內存中創建一個名為“ObjectCreator”的對象。

這個對象(類)本身能夠創建對象(實例),這就是為什麼它是一個類

但是,它仍然是一個對象,因此:

  • 您可以將其分配給變量
  • 你可以復制它
  • 你可以添加屬性
  • 您可以將其作為函數參數傳遞

例如:

>>> print(ObjectCreator) # you can print a class because it's an object
<class '__main__.ObjectCreator'>
>>> def echo(o):
...       print(o)
...
>>> echo(ObjectCreator) # you can pass a class as a parameter
<class '__main__.ObjectCreator'>
>>> print(hasattr(ObjectCreator, 'new_attribute'))
False
>>> ObjectCreator.new_attribute = 'foo' # you can add attributes to a class
>>> print(hasattr(ObjectCreator, 'new_attribute'))
True
>>> print(ObjectCreator.new_attribute)
foo
>>> ObjectCreatorMirror = ObjectCreator # you can assign a class to a variable
>>> print(ObjectCreatorMirror.new_attribute)
foo
>>> print(ObjectCreatorMirror())
<__main__.ObjectCreator object at 0x8997b4c>

動態創建類

由於類是對象,因此您可以像任何對像一樣動態創建它們。

首先,您可以使用類在函數中創建一個class

>>> def choose_class(name):
...     if name == 'foo':
...         class Foo(object):
...             pass
...         return Foo # return the class, not an instance
...     else:
...         class Bar(object):
...             pass
...         return Bar
...
>>> MyClass = choose_class('foo')
>>> print(MyClass) # the function returns a class, not an instance
<class '__main__.Foo'>
>>> print(MyClass()) # you can create an object from this class
<__main__.Foo object at 0x89c6d4c>

但它不是那麼有活力,因為你還是要自己寫全班。

由於類是對象,因此它們必須由某些東西生成。

使用class關鍵字時,Python會自動創建此對象。 但與Python中的大多數內容一樣,它為您提供了一種手動操作方法。

還記得功能type嗎? 一個很好的舊函數,可以讓您知道對象的類型:

>>> print(type(1))
<type 'int'>
>>> print(type("1"))
<type 'str'>
>>> print(type(ObjectCreator))
<type 'type'>
>>> print(type(ObjectCreator()))
<class '__main__.ObjectCreator'>

嗯, type具有完全不同的能力,它也可以動態創建類。 type可以將類的描述作為參數,並返回一個類。

(我知道,根據您傳遞給它的參數,相同的函數可以有兩個完全不同的用途,這很愚蠢。由於Python中的向後兼容性,這是一個問題)

type這種方式工作:

type(name of the class,
     tuple of the parent class (for inheritance, can be empty),
     dictionary containing attributes names and values)

例如:

>>> class MyShinyClass(object):
...       pass

可以通過以下方式手動創建:

>>> MyShinyClass = type('MyShinyClass', (), {}) # returns a class object
>>> print(MyShinyClass)
<class '__main__.MyShinyClass'>
>>> print(MyShinyClass()) # create an instance with the class
<__main__.MyShinyClass object at 0x8997cec>

您會注意到我們使用“MyShinyClass”作為類的名稱,並使用變量來保存類引用。 它們可以不同,但​​沒有理由使事情複雜化。

type接受字典以定義類的屬性。 所以:

>>> class Foo(object):
...       bar = True

可以翻譯成:

>>> Foo = type('Foo', (), {'bar':True})

並用作普通類:

>>> print(Foo)
<class '__main__.Foo'>
>>> print(Foo.bar)
True
>>> f = Foo()
>>> print(f)
<__main__.Foo object at 0x8a9b84c>
>>> print(f.bar)
True

當然,你可以繼承它,所以:

>>>   class FooChild(Foo):
...         pass

將會:

>>> FooChild = type('FooChild', (Foo,), {})
>>> print(FooChild)
<class '__main__.FooChild'>
>>> print(FooChild.bar) # bar is inherited from Foo
True

最後,您需要為您的班級添加方法。 只需使用正確的簽名定義一個函數並將其指定為屬性即可。

>>> def echo_bar(self):
...       print(self.bar)
...
>>> FooChild = type('FooChild', (Foo,), {'echo_bar': echo_bar})
>>> hasattr(Foo, 'echo_bar')
False
>>> hasattr(FooChild, 'echo_bar')
True
>>> my_foo = FooChild()
>>> my_foo.echo_bar()
True

在動態創建類之後,您可以添加更多方法,就像向正常創建的類對象添加方法一樣。

>>> def echo_bar_more(self):
...       print('yet another method')
...
>>> FooChild.echo_bar_more = echo_bar_more
>>> hasattr(FooChild, 'echo_bar_more')
True

你會看到我們要去的地方:在Python中,類是對象,你可以動態地創建一個類。

這就是Python在使用關鍵字class時所做的事情,它通過使用元類來實現。

什麼是元類(最後)

元類是創建類的“東西”。

你定義類來創建對象,對嗎?

但我們了解到Python類是對象。

好吧,元類是創建這些對象的原因。 他們是班級的班級,你可以這樣畫出來:

MyClass = MetaClass()
my_object = MyClass()

您已經看到該type允許您執行以下操作:

MyClass = type('MyClass', (), {})

這是因為函數type實際上是一個元類。 type是Python用於在幕後創建所有類的元類。

現在你想知道為什麼它是用小寫寫的,而不是Type

好吧,我想這是與str的一致性問題,創建字符串對象的類,以及創建整數對象的類。 type只是創建類對象的類。

您可以通過檢查__class__屬性來看到它。

一切,我的意思是一切,都是Python中的一個對象。 這包括整數,字符串,函數和類。 所有這些都是對象。 所有這些都是從一個類創建的:

>>> age = 35
>>> age.__class__
<type 'int'>
>>> name = 'bob'
>>> name.__class__
<type 'str'>
>>> def foo(): pass
>>> foo.__class__
<type 'function'>
>>> class Bar(object): pass
>>> b = Bar()
>>> b.__class__
<class '__main__.Bar'>

現在,任何__class____class__是什麼?

>>> age.__class__.__class__
<type 'type'>
>>> name.__class__.__class__
<type 'type'>
>>> foo.__class__.__class__
<type 'type'>
>>> b.__class__.__class__
<type 'type'>

因此,元類只是創建類對象的東西。

如果您願意,可以稱之為“班級工廠”。

type是Python使用的內置元類,但當然,您可以創建自己的元類。

__metaclass__屬性

在Python 2中,您可以在編寫類時添加__metaclass__屬性(請參閱Python 3語法的下一節):

class Foo(object):
    __metaclass__ = something...
    [...]

如果這樣做,Python將使用元類來創建類Foo

小心,這很棘手。

您首先編寫class Foo(object) ,但類對象Foo尚未在內存中創建。

Python將在類定義中查找__metaclass__ 。 如果找到它,它將使用它來創建對像類Foo 。 如果沒有,它將使用type來創建類。

多讀一遍。

當你這樣做時:

class Foo(Bar):
    pass

Python執行以下操作:

Foo是否有__metaclass__屬性?

如果是的話,在內存中創建一個類對象(我說一個類對象,留在這裡),使用名稱Foo ,使用__metaclass__

如果Python找不到__metaclass__ ,它將在MODULE級別查找__metaclass__ ,並嘗試執行相同的操作(但僅適用於不繼承任何內容的類,基本上是舊式類)。

然後,如果它根本找不到任何__metaclass__ ,它將使用Bar (第一個父)自己的元類(可能是默認type )來創建類對象。

這裡要小心,不會繼承__metaclass__屬性,父類的元類( Bar.__class__ )將是。 如果Bar使用__metaclass__屬性創建了帶有type() Bar (而不是type.__new__() ),則子類將不會繼承該行為。

現在最大的問題是,你能在__metaclass____metaclass__什麼?

答案是:可以創建一個類的東西。

什麼可以創造一個類? type ,或子類或使用它的任何東西。

Python中的元類3

在Python 3中更改了設置元類的語法:

class Foo(object, metaclass=something):
    [...]

即不再使用__metaclass__屬性,而是支持基類列表中的關鍵字參數。

然而,元類的行為基本保持不變

自定義元類

元類的主要目的是在創建類時自動更改類。

您通常對API執行此操作,您希望在其中創建與當前上下文匹配的類。

想像一個愚蠢的例子,你決定模塊中的所有類都應該用大寫字母寫出它們的屬性。 有幾種方法可以做到這一點,但一種方法是在模塊級別設置__metaclass__

這樣,將使用此元類創建此模塊的所有類,我們只需告訴元類將所有屬性轉換為大寫。

幸運的是, __metaclass__實際上可以是任何可調用的,它不需要是一個正式的類(我知道,其名稱中帶有'class'的東西不需要是一個類,去圖......但它很有幫助)。

因此,我們將從一個簡單的例子開始,使用一個函數。

# the metaclass will automatically get passed the same argument
# that you usually pass to `type`
def upper_attr(future_class_name, future_class_parents, future_class_attr):
    """
      Return a class object, with the list of its attribute turned
      into uppercase.
    """

    # pick up any attribute that doesn't start with '__' and uppercase it
    uppercase_attr = {}
    for name, val in future_class_attr.items():
        if not name.startswith('__'):
            uppercase_attr[name.upper()] = val
        else:
            uppercase_attr[name] = val

    # let `type` do the class creation
    return type(future_class_name, future_class_parents, uppercase_attr)

__metaclass__ = upper_attr # this will affect all classes in the module

class Foo(): # global __metaclass__ won't work with "object" though
    # but we can define __metaclass__ here instead to affect only this class
    # and this will work with "object" children
    bar = 'bip'

print(hasattr(Foo, 'bar'))
# Out: False
print(hasattr(Foo, 'BAR'))
# Out: True

f = Foo()
print(f.BAR)
# Out: 'bip'

現在,讓我們做同樣的事情,但是對於元類使用真正的類:

# remember that `type` is actually a class like `str` and `int`
# so you can inherit from it
class UpperAttrMetaclass(type):
    # __new__ is the method called before __init__
    # it's the method that creates the object and returns it
    # while __init__ just initializes the object passed as parameter
    # you rarely use __new__, except when you want to control how the object
    # is created.
    # here the created object is the class, and we want to customize it
    # so we override __new__
    # you can do some stuff in __init__ too if you wish
    # some advanced use involves overriding __call__ as well, but we won't
    # see this
    def __new__(upperattr_metaclass, future_class_name,
                future_class_parents, future_class_attr):

        uppercase_attr = {}
        for name, val in future_class_attr.items():
            if not name.startswith('__'):
                uppercase_attr[name.upper()] = val
            else:
                uppercase_attr[name] = val

        return type(future_class_name, future_class_parents, uppercase_attr)

但這不是真正的OOP。 我們直接調用type ,我們不會覆蓋或調用父__new__ 。 我們開始做吧:

class UpperAttrMetaclass(type):

    def __new__(upperattr_metaclass, future_class_name,
                future_class_parents, future_class_attr):

        uppercase_attr = {}
        for name, val in future_class_attr.items():
            if not name.startswith('__'):
                uppercase_attr[name.upper()] = val
            else:
                uppercase_attr[name] = val

        # reuse the type.__new__ method
        # this is basic OOP, nothing magic in there
        return type.__new__(upperattr_metaclass, future_class_name,
                            future_class_parents, uppercase_attr)

你可能已經註意到額外的參數upperattr_metaclass 。 它沒有什麼特別之處: __new__總是接收它定義的類,作為第一個參數。 就像你有self的普通方法接收實例作為第一個參數,或者類方法的定義類。

當然,為了清楚起見,我在這裡使用的名稱很長,但是對於self ,所有的參數都有傳統的名稱。 所以真正的生產元類看起來像這樣:

class UpperAttrMetaclass(type):

    def __new__(cls, clsname, bases, dct):

        uppercase_attr = {}
        for name, val in dct.items():
            if not name.startswith('__'):
                uppercase_attr[name.upper()] = val
            else:
                uppercase_attr[name] = val

        return type.__new__(cls, clsname, bases, uppercase_attr)

我們可以通過使用super來使它更乾淨,這將使繼承變得更容易(因為是的,你可以擁有元類,繼承自元類,繼承自類型):

class UpperAttrMetaclass(type):

    def __new__(cls, clsname, bases, dct):

        uppercase_attr = {}
        for name, val in dct.items():
            if not name.startswith('__'):
                uppercase_attr[name.upper()] = val
            else:
                uppercase_attr[name] = val

        return super(UpperAttrMetaclass, cls).__new__(cls, clsname, bases, uppercase_attr)

而已。 實際上沒有關於元類的更多信息。

使用元類的代碼複雜性背後的原因不是因為元類,而是因為你通常使用元類來依賴於內省,操縱繼承,諸如__dict__變量等來做扭曲的東西。

實際上,元類特別適用於製作黑魔法,因此也很複雜。 但它們本身很簡單:

  • 攔截班級創作
  • 修改課程
  • 返回修改後的類

為什麼要使用元類而不是函數?

由於__metaclass__可以接受任何可調用的,為什麼你會使用一個類,因為它顯然更複雜?

有幾個原因可以這樣做:

  • 目的很明確。 當您閱讀UpperAttrMetaclass(type) ,您知道將要遵循的內容
  • 你可以使用OOP。 Metaclass可以從元類繼承,覆蓋父方法。 元類甚至可以使用元類。
  • 如果指定了元類,但沒有使用元類函數,則類的子類將是其元類的實例。
  • 您可以更好地構建代碼。 你從不使用元類來處理像上面例子那樣簡單的事情。 它通常用於復雜的事情。 能夠製作多個方法並將它們組合在一個類中對於使代碼更易於閱讀非常有用。
  • 你可以掛鉤__new__ __init____init____call__ 。 這將允許你做不同的東西。 即使通常你可以在__new__完成所有__new__ ,但有些人使用__init__更舒服。
  • 這些被稱為元類,該死的! 它必須意味著什麼!

你為什麼要使用元類?

現在是個大問題。 為什麼要使用一些不起眼的容易出錯的功能?

好吧,通常你不會:

元類是更深刻的魔力,99%的用戶永遠不會擔心。 如果你想知道你是否需要它們,你就不會(實際需要它們的人確切地知道他們需要它們,並且不需要解釋為什麼)。

Python大師Tim Peters

元類的主要用例是創建API。 一個典型的例子是Django ORM。

它允許您定義如下內容:

class Person(models.Model):
    name = models.CharField(max_length=30)
    age = models.IntegerField()

但是如果你這樣做:

guy = Person(name='bob', age='35')
print(guy.age)

它不會返回IntegerField對象。 它將返回一個int ,甚至可以直接從數據庫中獲取它。

這是可能的,因為models.Model定義了__metaclass__並且它使用了一些魔法,它將您剛剛使用簡單語句定義的Person轉換為數據庫字段的複雜鉤子。

Django通過公開一個簡單的API並使用元類,從這個API重新創建代碼來完成幕後的實際工作,從而使復雜的外觀變得簡單。

最後一個字

首先,您知道類是可以創建實例的對象。

事實上,類本身就是實例。 元類。

>>> class Foo(object): pass
>>> id(Foo)
142630324

一切都是Python中的對象,它們都是類的實例或元類的實例。

除了type

type實際上是它自己的元類。 這不是你可以在純Python中重現的東西,而是通過在實現級別上作弊來完成的。

其次,元類很複雜。 您可能不希望將它們用於非常簡單的類更改。 您可以使用兩種不同的技術更改類:

99%的時間你需要改變課程,你最好使用這些。

但是98%的情況下,你根本不需要改變課程。





python python-3.x annotations function-definition