Python-类型提示-类型注释符号

 

# Python-类型提示-类型注释符号
##########################################
# 变量
##########################################
# This is how you declare the type of a variable type in Python 3.6
age: int = 1
# In Python 3.5 and earlier you can use a type comment instead
# (equivalent to the prevIoUs deFinition)
age = 1 # type: int
# You don't need to initialize a variable to annotate it
a: int # Ok (no value at runtime until assigned)
# The latter is useful in conditional branches
child: bool
if age < 18:
    child = True
else:
    child = False
##########################################
# 内置类型
##########################################
from typing import List, Set, Dict, Tuple, Optional
# For simple built-in types, just use the name of the type
x: int = 1
x: float = 1.0
x: bool = True
x: str = "test"
x: bytes = b"test"
# For collections, the name of the type is capitalized, and the
# name of the type inside the collection is in brackets
x: List[int] = [1]
x: Set[int] = {6, 7}
# Same as above, but with type comment Syntax
x = [1] # type: List[int]
# For mappings, we need the types of both keys and values
x: Dict[str, float] = {'field': 2.0}
# For tuples of fixed size, we specify the types of all the elements
x: Tuple[int, str, float] = (3, "yes", 7.5)
# For tuples of variable size, we use one type and ellipsis
x: Tuple[int, ...] = (1, 2, 3)
# Use Optional[] for values that Could be None
x: Optional[str] = some_function()
# Mypy understands a value can't be None in an if-statement
if x is not None:
    print(x.upper())
# If a value can never be None due to some invariants, use an assert
assert x is not None
print(x.upper())
##########################################
# 功能
##########################################
from typing import Callable, Iterator, Union, Optional, List
# This is how you annotate a function deFinition
def stringify(num: int) -> str:
    return str(num)
# And here's how you specify multiple arguments
def plus(num1: int, num2: int) -> int:
    return num1 + num2
# Add default value for an argument after the type annotation
def f(num1: int, my_float: float = 3.5) -> float:
    return num1 + my_float
# This is how you annotate a callable (function) value
x: Callable[[int, float], float] = f
# A generator function that yields ints is secretly just a function that
# returns an iterator of ints, so that's how we annotate it
def g(n: int) -> Iterator[int]:
    i = 0
    while i < n:
        yield i
        i += 1
# You can of course split a function annotation over multiple lines
def send_email(address: Union[str, List[str]],
               sender: str,
               cc: Optional[List[str]],
               bcc: Optional[List[str]],
               subject='',
               body: Optional[List[str]] = None
               ) -> bool:
    ...
# An argument can be declared positional-only by giving it a name
# starting with two underscores:
def quux(__x: int) -> None:
    pass
quux(3) # Fine
quux(__x=3) # Error
##########################################
# 标准"duck_types"
# 在典型的Python代码中，许多可以将list或dict作为参数的函数只需要它们的参数以某种方式“list-like”或“dict-like”。“list-
# like”或“dict-like”（或其他类似的）的特定含义称为“duck-type”，并且标准化了惯用Python中常见的几种duck类型。
##########################################

 

 Callable[..., Any]，可调用者接受任意数量的/类型的参数并返回任何类型的值。

 

 

https://wenku.baidu.com/view/665fca1364ec102de2bd960590c69ec3d5bbdb7b.html