python函数可以按照参数名称方式传递参数,python定义一个函数,当传递参数时
python在声明一个函数时，指定传入参数的数据类型函数返回值的数据类型(函数参数的注释和函数返回值的注释) python内置的类型化模块：技术博客supporting _ MB 62 af F3 AFB 54 FB _ 51 CTO博客
python声明函数时，指定传入参数的数据类型函数返回值的数据类型(函数参数的注释和函数返回值的注释) python内置的类型化模块：类型提示支持
在Python 3.5中，PEP484引入了类型注释，PEP 526在Python 3.6中进一步引入了变量注释。
具体的变量注释语法可以归纳为两点：
声明变量时，可以在变量后面加一个冒号，后面跟着变量的类型，比如int，list等。声明方法的返回值时，可以在方法后添加一个箭头，后跟返回值的类型，如int、list等。在人教版8中，具体格式规定如下：
声明变量类型时，变量后面跟一个冒号，后面跟一个空格，后面跟变量类型。声明方法的返回值时，箭头的左边是方法定义，箭头的右边是返回值的类型，箭头的两边要留空格。值得注意的是，这个类型和变量注释实际上只是一个类型提示，对操作没有影响。
还有一些支持类型检查的库，比如mypy。安装后，您可以使用mypy检查Python脚本中不符合类型注释的调用。
批注表达式当你自己写一个函数或方法，想被别人调用，如果想让对方知道函数或方法传入的参数的数据类型，可以这样定义：
DEF DEMO (name: str，age: int0=20)-str: #-str表示该函数的返回值为str类型。
打印(姓名，类型(姓名))
打印(年龄，类型(年龄))
返回“hello world”
if __name__==__main__ :
Demo(1，2) #这里的参数1将显示为黄色，但它可以运行而不会出错。
Demo (Little ，2) #正常显示运行结果：
类别 int # 1
类别 int # 2
Class str # Xiaoxiao
类别“int”# 2摘要：
以上是注释表达式的应用方法，注释中最常用的是class (str或int)类型和strings(如 int 0 )。
python对注释不做任何处理，只是存储在函数的_ _ annotations _ _ attribute(dictionary)中[包括函数的参数的注释和函数return返回的值的注释]
对于注释，python不检查、不强制、不验证、不做任何事情。
换句话说，注释对于python解释器来说没有任何意义，只是为了方便使用函数的人。
指定传入参数的数据类型是any。如果声明函数时指定函数传入参数的数据类型为any，则调用函数时，此参数的参数类型可以是任意类型。
代码如下：
DEF DEMO (name: any，age: int0=20)-str: #-str表示该函数的返回值为STR类型。
打印(姓名，类型(姓名))
打印(年龄，类型(年龄))
返回“hello world”
if __name__==__main__ :
演示(姓名=1，年龄=2) #正常显示
演示(name= little ，age=2) #正常显示跑步结果：
参数注释代码如下：
DEF DEMO (name: str，age: int0=20)-str: #-str表示该函数的返回值为str类型。
打印(姓名，类型(姓名))
打印(年龄，类型(年龄))
返回“hello world”
if __name__==__main__ :
打印(演示。__annotations__)说明：演示函数的参数注释存储在__annotations__ dictionary中。
运行结果：
{name: class str ， age: int0 ， return: class str}类型化：强类型声明1。类型化将Python作为弱类型语言引入。很多时候，我们可能不知道函数参数或返回值的类型。这会导致我们写了一段时间后回过头去看代码，忘记了需要传递什么样的参数，需要返回给我们写好的函数什么样的结果。这会让我们不得不去阅读代码的具体内容，减缓阅读速度。打字模块可以很好的解决这个问题。
【注意】:打字模块只能在python3.5版本3.5以上使用，pycharm目前支持打字检查。
2.检查类型化的函数类型，防止参数和返回值类型在运行时不一致。作为开发文档的补充说明，方便用户在调用时传入和返回参数类型。模块添加后，不会影响程序的运行，也不会报错。只是提醒pycharm，目前支持键入检查，参数类型错误会提示黄色。3.常见数据类型int、long、float: integer、long、floatBool，str: Boolean，字符串类型；列表，元组，字典，集合：列表，元组，字典，集合；Iterate，Iterator:可迭代类型，迭代器类型；发电机：发电机类型；除了上述常见类型，还支持Any、Union、Tuple、Callable、TypeVar和Generic类型。完整规格见PEP 484。关于类型提示的简要介绍，请参考PEP 483。
4.代码示例
func函数要求传入的第二个参数是str类型，但是当我们调用它的时候，传入的参数是int类型。这时候Pycharm会用黄色警告你。当我们将光标置于黄色时，会出现以下提示：
上面说期望类型是str，现在是int，但键入只是提示，不会影响代码执行；
结果如下：我们会发现没有错误，因为打字只是起到一个提醒的作用。
[2, 3]5.类型别名类型别名是给复杂类型起一个单独的名字。
#给List[float]类型一个单独的名称向量。
向量=列表[浮点]
def scale(标量：浮点，向量：向量)-向量：
return[标量*矢量中的数字的数字]
New _ vector=scale (2.0，[1.0，-4.2，5.4])。当然，我们根本不需要使用类型别名。以下写法也一样，看个人喜好。
def scale(scalar: float，vector:List[float])-List[float]:
返回[标量*矢量中的数字的数字] 6。类型模块中包含的数据类型是AbstractSet=typing。抽象集
任何=打字。任何的
AnyStr=~AnyStr
AsyncContextManager=正在键入。AbstractAsyncContextManager
AsyncGenerator=打字。异步发电机
async changeable=打字。不可改变的
AsyncIterator=打字。AsyncIterator
Awaitable=打字。值得称赞的
ByteString=打字。字节字符串
可调用=输入。请求即付的
ClassVar=打字。类别变量
收藏=打字。募捐
容器=打字。容器
ContextManager=键入。AbstractContextManager
协程=打字。协同程序
计数器=打字。计数器
DefaultDict=打字。默认字典
Deque=打字。双端队列
Dict=打字。词典
FrozenSet=打字。冻结集合
生成器=打字。发电机
Hashable=打字。可哈希的
ItemsView=typing。项目视图
Iterable=类型化。可迭代的
迭代器=类型化。迭代程序
按键视图=输入。按键视图
列表=打字。目录
映射=打字。绘图
MappingView=打字。MappingView
MutableMapping=typing。可变映射
可变序列=类型化。可变序列
MutableSet=类型。可变集
NoReturn=打字。死后不回城
可选=键入。可选择的
可逆=打字。可逆的
序列=打字。顺序
Set=打字。一组
大小=打字。特定大小的
TYPE_CHECKING=False
元组=类型化。元组
类型=打字。类型
Union=打字。联盟
ValuesView=键入。ValuesView前言以上案例只是int类型/str类型的一个简单例子。我们来看一些相对复杂的数据结构，比如链表、元组、字典等。申报。
可以想象，链表用list表示，元组用tuple表示，字典用dict表示。所以很自然的，在声明的时候，可以是这样的：
名称：list=[Germey ， Guido]
版本：元组=(3，7，4)
操作：dict={show: false， sort: true}好像没什么问题。它确实被声明为对应的类型，但它实际上并不反映整个链表和元组的结构；
比如我们仅凭类型标注不知道names中的元素是什么类型，只知道names是一个列表类型，实际上是一个string str类型。
我们不知道tuple版本的每个元素是什么类型，但它实际上是一个int类型。但是这些信息我们都不知道。所以，仅仅依靠list和tuple这样的声明是非常“弱”的，我们需要一个更强的类型声明。
这时候我们就需要使用typing模块了，它提供了非常强大的类型支持。例如，List[str]和Tuple[int，int，int]可以表示由str类型的元素组成的列表和由int类型的元素组成的长度为3的元组。所以上面的语句可以改写如下：
从输入导入列表、元组、字典
名称：List[str]=[Germey ， Guido]
版本：Tuple[int，int，int]=(3，7，4)
操作：dict [str，bool]={show: false， sort: true}这样就可以非常直观的反映出变量的类型。
Python标准库中也加入了typing模块，可以直接使用，无需安装第三方模块。
打字模块的具体用法在介绍的时候直接通过打字模块介绍。
例如：
从输入导入列表，元组列表
List，list，是list的类属，基本相当于list，后面是一个方括号，代表组成这个列表的元素的类型。例如，由数字组成的列表可以声明为：
Var: List[int或float]=[2，3.5]此外，您可以嵌套声明：
Var: list [list [int]]=[[1，2]，[2，3]][注意]由于容器中元素的类型信息是由于泛型的不同而以一般方式静态推断的，所以使用抽象类来扩展和表示容器中的元素。
元组、命名元组
Tuple，tuple，是tuple的类属，后面是一个方括号，其中构成这个tuple的元素类型是按顺序声明的。例如，Tuple[X，Y]意味着构成元组的第一个元素是X类型的，第二个元素是Y类型的。
例如，如果要声明一个分别表示姓名、年龄和身高的元组，三种数据类型分别为str、int和float，可以这样声明：
Person: tuple [str，int，float]=(Mike ，22，1.75)同样，也可以使用类型嵌套：
Namedtuple，是collections.namedtuple的泛型，其实和namedtuple用法完全一样，但是个人不建议使用NamedTuple。建议attrs库声明一些具有代表性意义的类。
字典、映射、可变映射
Dict，字典，是Dict的通称；
Mapping，mapping，是collections.abc.Mapping的泛型.
根据官方文档，注释返回类型推荐使用Dict，注释参数推荐使用Mapping。它们的用法都是一样的，后面跟一个括号，在括号里分别声明键名和键值的类型，比如：
def size(rect: Mapping[str，int]) - Dict[str，int]:
return { width :rect[ width ]100， height: rect [width] 100}这里用Dict作为返回值类型注释，用Mapping作为参数类型注释。
MutableMapping是Mapping对象的一个子类，很多库中经常用MutableMapping代替Mapping。
集合、抽象集
Set，set，是set的类属；
Abstract，它是collections.abc.Set的泛型
根据官方文档，建议使用Set来注释返回类型，使用AbstractSet来注释参数。它们都以相同的方式使用，后跟一个括号，声明集合中元素的类型，例如：
def describe(s:abstract Set[int])-Set[int]:
Return (s)这里Set用作返回值类型注释，AbstractSet用作参数类型注释。
序列
Sequence，它是collections.abc.Sequence的泛型.
在某些情况下，我们可能不需要严格区分变量或参数是列表类型还是元组类型。我们可以使用一个更一般化的类型，叫做Sequence，类似于list，比如：
def square(elements:Sequence[float])-List[float]:
return[x * * 2 for x in elements]no return
NoReturn，当一个方法有NoReturn值时，为了注释其返回类型，我们可以将其注释为Noreturn，例如：
def hello() - NoReturn:
打印( hello )任何
Any是一种特殊类型，可以表示所有类型。所有类型的静态类型检查器都与任何类型兼容；
默认情况下，对于所有无参数类型批注和没有返回类型批注的批注，将使用任何类型。
例如，以下两种方法的声明完全等效：
定义添加(a):
返回1
def add(a: Any) - Any:
return a 1的原理和object类似，所有类型都是object的子类。
但是，如果我们将参数声明为对象类型，静态参数类型检查将抛出错误，而Any不会。详情请参考官方文件：https://docs.python.org/zh-cn/3/library/typing.html?highlight=键入#the-any-type .
类型变量
TypeVar，我们可以用它来定制与特定类型兼容的变量。比如有些声明为int、float、None的变量符合要求，但实际上可以表示任意数字或空内容，而其他类型则不能，比如list list、dictionary dict等。在这种情况下，我们可以使用TypeVar来表示它们。
比如一个人的身高可以用int或者float或者None来表示，但不能用dict来表示，所以可以表述如下：
身高=1.75
Height=TypeVar(Height ，int，float，None)
def get_height() -高度：
Height这里我们用TypeVar声明一个height类型，然后用它来注释方法返回的结果。
新型
NewType，我们可以用它来声明一些有特殊含义的类型。比如像Tuple的例子，我们需要把它表示为Person，也就是一个人的意思，但是表面上把它声明为Tuple并不直观，可以用NewType为它声明一个类型。比如：
Person=NewType(Person ，Tuple[str，int，float])
人=人((迈克，22，1.75))。其实这里的person是一个tuple类型，我们可以把它当做一个tuple来操作。
可调用
Callable是一种可调用类型，通常用于对方法进行批注，如下面的add方法，它是一种可调用类型：
从输入导入可调用
定义添加(a):
返回1
Print (callable，type (add)，isinstance (add，callable)，sep= \ n )运行结果：
打字。请求即付的
类别“功能”
此处为True，虽然使用type方法得到的两次相加的结果是function，但使用isinstance方法实际上是True。
Callable需要用callable [[arg1type，arg2type，]，returntype]并且参数类型和返回值类型都应该被注释，例如：
定义日期(年：整数，月：整数，日：整数)-字符串：
返回f“{年}-{月}-{日}”
def get_date_fn() - Callable[[int，int，int]，str]:
Return date这里首先声明一个方法date，它接收三个int参数并返回一个str结果。get_date_fn方法返回方法本身，其返回值类型可以标记为可调用。返回方法的参数类型和返回值类型分别标在括号内。
联合
Union，union type，Union[X，Y]表示X类型或Y类型.
联合类型的联合类型等同于扁平化类型：
Union [union [int，str]，float]==union [int，str，float]只有一个参数的联合类型被压缩到参数本身中，例如：
Union[int]==int额外的参数将被跳过，例如：
Union [int，str，int]==union [int，str]比较联合类型时，参数的顺序将被忽略，例如：
Union[int，str]==Union[str，int]这在声明一些方法参数时很有用，比如一个方法。要么传递由字符串表示的方法名，要么直接传递方法：
定义进程(fn: Union[str，Callable]):
if isinstance(fn，str):
# str2fn和流程
及格
elif isinstance(fn，可调用):
在定义一些类库方法时，fn()语句非常常见。
可选
Optional:表示该参数可以为空，也可以是声明的类型，即Optional[X]等效于Union[X，None]。
但是，值得注意的是，这并不等同于可选参数。当它被注释为参数类型时，并不是说这个参数不能被传递，而是说这个参数可以作为None被传递。
从键入导入可选
def judge(结果：bool) -可选[str]:
如果结果：
返回“出现错误”
if __name__==__main__ :
Print (when result=False作为参数：，judge(result=False))
Print (when result=True作为参数：，judge(result=True))执行结果：
当参数result=False: None #此时，函数没有返回值，但是在声明函数的时候，已经定义了函数的返回值是unit[str，None]，所以在函数没有返回值的时候会返回None。
当参数result=True:Error Occurred #函数返回字符串生成器如果有返回值。
如果要表示一个生成器类型，可以使用Generator，其声明相当特殊，后面有三个参数，分别是YieldType、SendType和ReturnType，比如：
通过键入导入生成器
def echo_round() - Generator[int，float，str]:
发送=产量0
发送时间=0:
发送=收益回合(发送)
这里返回‘Done’，紧跟yield关键字的变量的类型是yieldType，Yield返回的结果的类型是SendType，最后生成器返回的内容是ReturnType。
当然，在很多情况下，生成器只需要yield内容。我们不需要SendType和ReturnType，可以设置为null，比如：
通过键入导入生成器
def infinite _ stream(start:int)-Generator[int，None，None]:
虽然正确：
产量开始
开始=1
期待陌生，拥抱惊喜。
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。