主頁 > 知識庫 > Python標(biāo)準(zhǔn)庫之typing的用法(類型標(biāo)注)

Python標(biāo)準(zhǔn)庫之typing的用法(類型標(biāo)注)

熱門標(biāo)簽:地圖標(biāo)注面積 所得系統(tǒng)電梯怎樣主板設(shè)置外呼 小蘇云呼電話機器人 佛山400電話辦理 北京電銷外呼系統(tǒng)加盟 儋州電話機器人 北瀚ai電銷機器人官網(wǎng)手機版 朝陽手機外呼系統(tǒng) 市場上的電銷機器人

PEP 3107引入了功能注釋的語法,PEP 484 加入了類型檢查

標(biāo)準(zhǔn)庫 typing 為類型提示指定的運行時提供支持。

示例:

def f(a: str, b:int) -> str:
    return a * b

如果實參不是預(yù)期的類型:

但是,Python運行時不強制執(zhí)行函數(shù)和變量類型注釋。使用類型檢查器,IDE,lint等才能幫助代碼進行強制類型檢查。

使用NewType 創(chuàng)建類型

NewType() 是一個輔助函數(shù),用于向類型檢查器指示不同的類型,在運行時,它返回一個函數(shù),該函數(shù)返回其參數(shù)。

import typing
Id = typing.NewType("Id", int)
a = Id(2020)

使用 NewType() 創(chuàng)建的類型會被類型檢查器視為它的原始類型的子類。

回調(diào)(Callable)

將回調(diào)函數(shù)類型標(biāo)注為 Callable[[Arg1Type, Arg2Type], ReturnType]。

from typing import Callable
def f(a: int) -> str:
    return str(a)
def callback(a: int, func: Callable[[int], str]) -> str:
    return func(a)
print(callback(1, f))

泛型

為容器元素添加預(yù)期的類型

from typing import Mapping
a: Mapping[str, str]

通過 TypeVar 進行參數(shù)化來約束一個類型集合:

from typing import TypeVar
T = TypeVar('T') # 可以是任何東西。
A = TypeVar('A', str, bytes) # 必須是 str 或 bytes

使用 TypeVar 約束一個類型集合,但不允許單個約束

例如:

T = TypeVar('T', str)

這樣會拋出一個異常 TypeError: A single constraint is not allowed

typing 包含的類型

AbstractSet = typing.AbstractSet
Any = typing.Any
AnyStr = ~AnyStr
AsyncContextManager = typing.AbstractAsyncContextManager
AsyncGenerator = typing.AsyncGenerator
AsyncIterable = typing.AsyncIterable
AsyncIterator = typing.AsyncIterator
Awaitable = typing.Awaitable
ByteString = typing.ByteString
Callable = typing.Callable
ClassVar = typing.ClassVar
Collection = typing.Collection
Container = typing.Container
ContextManager = typing.AbstractContextManager
Coroutine = typing.Coroutine
Counter = typing.Counter
DefaultDict = typing.DefaultDict
Deque = typing.Deque
Dict = typing.Dict
FrozenSet = typing.FrozenSet
Generator = typing.Generator
Hashable = typing.Hashable
ItemsView = typing.ItemsView
Iterable = typing.Iterable
Iterator = typing.Iterator
KeysView = typing.KeysView
List = typing.List
Mapping = typing.Mapping
MappingView = typing.MappingView
MutableMapping = typing.MutableMapping
MutableSequence = typing.MutableSequence
MutableSet = typing.MutableSet
NoReturn = typing.NoReturn
Optional = typing.Optional
Reversible = typing.Reversible
Sequence = typing.Sequence
Set = typing.Set
Sized = typing.Sized
TYPE_CHECKING = False
Tuple = typing.Tuple
Type = typing.Type
Union = typing.Union
ValuesView = typing.ValuesView

typing-python用于類型注解的庫

簡介

動態(tài)語言的靈活性使其在做一些工具,腳本時非常方便,但是同時也給大型項目的開發(fā)帶來了一些麻煩。

自python3.5開始,PEP484為python引入了類型注解(type hints),雖然在pep3107定義了函數(shù)注釋(function annotation)的語法,但仍然故意留下了一些未定義的行為.現(xiàn)在已經(jīng)擁有許多對于靜態(tài)類型的分析的第三方工具,而pep484引入了一個模塊來提供這些工具,同時還規(guī)定一些不能使用注釋(annoation)的情況

#一個典型的函數(shù)注釋例子,為參數(shù)加上了類型
def greeting(name: str) -> str:
    return 'Hello ' + name

伴隨著python3.6的pep526則更進一步引入了對變量類型的聲明,和在以前我們只能在注釋中對變量的類型進行說明

# 使用注釋來標(biāo)明變量類型
primes = [] # type:list[int]
captain = ... #type:str
class Starship:
    stats = {} #type:Dict[str,int]
primes:List[int] = []
captain:str #Note: no initial value
class Starship:
    stats: ClassVar[Dict[str,int]] = {}

typing--對于type hints支持的標(biāo)準(zhǔn)庫

typing模塊已經(jīng)被加入標(biāo)準(zhǔn)庫的provisional basis中,新的特性可能會增加,如果開發(fā)者認(rèn)為有必要,api也可能會發(fā)生改變,即不保證向后兼容性

我們已經(jīng)在簡介中介紹過類型注解,那么除了默認(rèn)類型的int、str用于類型注解的類型有哪些呢?

typing庫便是一個幫助我們實現(xiàn)類型注解的庫

類型別名(type alias)

在下面這個例子中,Vector和List[float]可以視為同義詞

from typing import List
Vector = List[float]
def scale(scalar: float, vector: Vector)->Vector:
    return [scalar*num for num in vector]
new_vector = scale(2.0, [1.0, -4.2, 5.4])

類型別名有助于簡化一些復(fù)雜的類型聲明

from typing import Dict, Tuple, List
ConnectionOptions = Dict[str, str]
Address = Tuple[str, int]
Server = Tuple[Address, ConnectionOptions]
def broadcast_message(message: str, servers: List[Server]) -> None:
    ...
# The static type checker will treat the previous type signature as
# being exactly equivalent to this one.
def broadcast_message(
        message: str,
        servers: List[Tuple[Tuple[str, int], Dict[str, str]]]) -> None:
    pass

新類型(New Type)

使用NewType來輔助函數(shù)創(chuàng)造不同的類型

form typing import NewType
UserId = NewType("UserId", int)
some_id = UserId(524313)

靜態(tài)類型檢查器將將新類型視為原始類型的子類。這對于幫助捕獲邏輯錯誤非常有用

def get_user_name(user_id: UserId) -> str:
    pass
# typechecks
user_a = get_user_name(UserId(42351))
# does not typecheck; an int is not a UserId
user_b = get_user_name(-1)

你仍然可以使用int類型變量的所有操作來使用UserId類型的變量,但結(jié)果返回的都是都是int類型。例如

# output仍然是int類型而不是UserId類型
output = UserId(23413) + UserId(54341)

雖然這無法阻止你使用int類型代替UserId類型,但可以避免你濫用UserId類型

注意,這些檢查僅僅被靜態(tài)檢查器強制檢查,在運行時Derived = NewType('Derived',base)將派生出一個函數(shù)直接返回你傳的任何參數(shù),這意味著Derived(some_value)并不會創(chuàng)建任何新類或者創(chuàng)建任何消耗大于普通函數(shù)調(diào)用消耗的函數(shù)

確切地說,這個表達式 some_value is Derived(some_value) 在運行時總是對的。

這也意味著不可能創(chuàng)建派生的子類型,因為它在運行時是一個標(biāo)識函數(shù),而不是一個實際類型:

from typing import NewType
UserId = NewType('UserId', int)
# Fails at runtime and does not typecheck
class AdminUserId(UserId): pass

然而,它可以創(chuàng)建一個新的類型基于衍生的NewType

from typing import NewType
UserId = NewType('UserId', int)
ProUserId = NewType('ProUserId', UserId)

然后對于ProUserId的類型檢查會如預(yù)料般工作

Note:回想一下,使用類型別名聲明的兩個類型是完全一樣的,令Doing = Original將會使靜態(tài)類型檢查時把Alias等同于Original,這個結(jié)論能夠幫助你簡化復(fù)雜的類型聲明

與Alias不同,NewType聲明了另一個的子類,令Derived = NewType('Derived', Original)將會使靜態(tài)類型檢查把Derived看做Original的子類,這意味著類型Original不能用于類型Derived,這有助于使用最小的消耗來防止邏輯錯誤。

回調(diào)(callable)

回調(diào)函數(shù)可以使用類似Callable[[Arg1Type, Arg2Type],ReturnType]的類型注釋

例如

from typing import Callable
def feeder(get_next_item: Callable[[], str]) -> None:
    # Body
def async_query(on_success: Callable[[int], None],
                on_error: Callable[[int, Exception], None]) -> None:
    # Body

可以通過對類型提示中的參數(shù)列表替換一個文本省略號來聲明一個可調(diào)用的返回類型,而不指定調(diào)用參數(shù),例如 Callable[..., ReturnType]

泛型(Generics)

因為容器中的元素的類型信息由于泛型不同通過一般方式靜態(tài)推斷,因此抽象類被用來拓展表示容器中的元素

from typing import Mapping, Sequence
def notify_by_email(employees: Sequence[Employee],
                    overrides: Mapping[str, str]) -> None: ...
 

可以通過typing中的TypeVar將泛型參數(shù)化

from typing import Sequence, TypeVar
T = TypeVar('T')      # 申明類型變量
def first(l: Sequence[T]) -> T:   # Generic function
    return l[0]

用戶定義泛型類型

from typing import TypeVar, Generic
from logging import Logger
T = TypeVar('T')
class LoggedVar(Generic[T]):
    def __init__(self, value: T, name: str, logger: Logger) -> None:
        self.name = name
        self.logger = logger
        self.value = value
    def set(self, new: T) -> None:
        self.log('Set ' + repr(self.value))
        self.value = new
    def get(self) -> T:
        self.log('Get ' + repr(self.value))
        return self.value
    def log(self, message: str) -> None:
        self.logger.info('%s: %s', self.name, message)

定義了Generic[T]作為LoggedVar的基類,同時T也作為了方法中的參數(shù)。

通過Generic基類使用元類(metaclass)定義__getitem__()使得LoggedVar[t]是有效類型

from typing import Iterable
def zero_all_vars(vars: Iterable[LoggedVar[int]]) -> None:
    for var in vars:
        var.set(0)

泛型可以是任意類型的變量,但也可以被約束

from typing import TypeVar, Generic
...
T = TypeVar('T')
S = TypeVar('S', int, str)
class StrangePair(Generic[T, S]):
    ...

每個類型變量的參數(shù)必須是不同的

下面是非法的

from typing import TypeVar, Generic
...
T = TypeVar('T')
class Pair(Generic[T, T]):   # INVALID
    ...

你可以使用Generic實現(xiàn)多繼承

from typing import TypeVar, Generic, Sized
T = TypeVar('T')
class LinkedList(Sized, Generic[T]):
    ... 

當(dāng)繼承泛型類時,一些類型變量可以被固定

from typing import TypeVar, Mapping
T = TypeVar('T')
class MyDict(Mapping[str, T]):
    ...

使用泛型類而不指定類型參數(shù)則假定每個位置都是Any,。在下面的例子中,myiterable不是泛型但隱式繼承Iterable [Any]

from typing import Iterable
class MyIterable(Iterable): # Same as Iterable[Any]

還支持用戶定義的泛型類型別名。實例:

from typing import TypeVar, Iterable, Tuple, Union
S = TypeVar('S')
Response = Union[Iterable[S], int]
# Return type here is same as Union[Iterable[str], int]
def response(query: str) -> Response[str]:
    ...
T = TypeVar('T', int, float, complex)
Vec = Iterable[Tuple[T, T]]
def inproduct(v: Vec[T]) -> T: # Same as Iterable[Tuple[T, T]]
    return sum(x*y for x, y in v)

Generic的元類是abc.ABCMeta的子類,泛型類可以是包含抽象方法或?qū)傩缘腁BC類(A generic class can be an ABC by including abstract methods or properties)

同時泛型類也可以含有ABC類的方法而沒有元類沖突。

Any

一種特殊的類型是。靜態(tài)類型檢查器將將每個類型視為與任何類型和任何類型兼容,與每個類型兼容。

from typing import Any
a = None    # type: Any
a = []      # OK
a = 2       # OK
s = ''      # type: str
s = a       # OK
def foo(item: Any) -> int:
    # Typechecks; 'item' could be any type,
    # and that type might have a 'bar' method
    item.bar()
    ...

以上為個人經(jīng)驗,希望能給大家一個參考,也希望大家多多支持腳本之家。

您可能感興趣的文章:
  • python 內(nèi)置庫wsgiref的使用(WSGI基礎(chǔ)入門)
  • Python實現(xiàn)socket庫網(wǎng)絡(luò)通信套接字
  • Python趣味挑戰(zhàn)之turtle庫繪畫飄落的銀杏樹
  • 讓文件路徑提取變得更簡單的Python Path庫
  • 關(guān)于python3安裝pip及requests庫的導(dǎo)入問題
  • Python的這些庫,你知道多少?

標(biāo)簽:云南 金融催收 商丘 寧夏 龍巖 定西 江蘇 酒泉

巨人網(wǎng)絡(luò)通訊聲明:本文標(biāo)題《Python標(biāo)準(zhǔn)庫之typing的用法(類型標(biāo)注)》,本文關(guān)鍵詞  Python,標(biāo)準(zhǔn),庫之,typing,的,;如發(fā)現(xiàn)本文內(nèi)容存在版權(quán)問題,煩請?zhí)峁┫嚓P(guān)信息告之我們,我們將及時溝通與處理。本站內(nèi)容系統(tǒng)采集于網(wǎng)絡(luò),涉及言論、版權(quán)與本站無關(guān)。
  • 相關(guān)文章
  • 下面列出與本文章《Python標(biāo)準(zhǔn)庫之typing的用法(類型標(biāo)注)》相關(guān)的同類信息!
  • 本頁收集關(guān)于Python標(biāo)準(zhǔn)庫之typing的用法(類型標(biāo)注)的相關(guān)信息資訊供網(wǎng)民參考!
  • 推薦文章