关于Python里的类型注解

Python类型注解 在Python中,类型注解是一种在变量、函数参数和函数返回值中指定类型的方法。类型注解不会影响程序的运行,但可以提供有关变量和函数预期类型的信息,可以帮助开发者更好地理解代码,并提供给IDE(集成开发环境)工具更好的代码补全和错误检查。类型注解可以用于函数参数和返回值,也可以用于变量。可以使用多种类型,如str、int、bool、list、dict等。类型注解还可以与特殊的类和类型提示库一起使用,以更详细地指定变量和参数的类型信息。 阅读详情
我们知道 Python 是一种动态语言,在声明一个变量时我们不需要显式地声明它的类型,例如下面的例子:
a = 2print('1 + a =', 1 + a)
print('1 + a =', 1 + a)

运行结果:

1 + a = 3

这里我们首先声明了一个变量 a,并将其赋值为了 2,然后将最后的结果打印出来,程序输出来了正确的结果。但在这个过程中,我们没有声明它到底是什么类型。

但如果这时候我们将 a 变成一个字符串类型,结果会是怎样的呢?改写如下:

a = '2'print('1 + a =', 1 + a)
print('1 + a =', 1 + a)

运行结果:

TypeError: unsupported operand type(s) for +: 'int' and 'str''int' and 'str'

直接报错了,错误原因是我们进行了字符串类型的变量和数值类型变量的加和,两种数据类型不同,是无法进行相加的。

如果我们将上面的语句改写成一个方法定义:

def add(a):    return a + 1
    return a + 1

这里定义了一个方法,传入一个参数,然后将其加 1 并返回。

如果这时候如果用下面的方式调用,传入的参数是一个数值类型:

add(2)2)

则可以正常输出结果 3。但如果我们传入的参数并不是我们期望的类型,比如传入一个字符类型,那么就会同样报刚才类似的错误。

但又由于 Python 的特性,很多情况下我们并不用去声明它的类型,因此从方法定义上面来看,我们实际上是不知道一个方法的参数到底应该传入什么类型的。

这样其实就造成了很多不方便的地方,在某些情况下一些复杂的方法,如果不借助于一些额外的说明,我们是不知道参数到底是什么类型的。

因此,Python 中的类型注解就显得比较重要了。

类型注解

在 Python 3.5 中,Python  PEP 484 引入了类型注解(type hints),在 Python 3.6 中,PEP 526 又进一步引入了变量注解(Variable Annotations),所以上面的代码我们改写成如下写法:

a: int = 2print('5 + a =', 5 + a)def add(a: int) -> int:    return a + 1
print('5 + a =', 5 + a)

def add(a: int) -> int:
    return a + 1

具体的语法是可以归纳为两点:

在 PEP 8 中,具体的格式是这样规定的:

有了这样的声明,以后我们如果看到这个方法的定义,我们就知道传入的参数类型了,如调用 add 方法的时候,我们就知道传入的需要是一个数值类型的变量,而不是字符串类型,非常直观。

但值得注意的是,这种类型和变量注解实际上只是一种类型提示,对运行实际上是没有影响的,比如调用 add 方法的时候,我们传入的不是 int 类型,而是一个 float 类型,它也不会报错,也不会对参数进行类型转换,如:

add(1.5)

我们传入的是一个 float 类型的数值 1.5,看下运行结果:

2.5

可以看到,运行结果正常输出,而且 1.5 并没有经过强制类型转换变成 1,否则结果会变成 2。

因此,类型和变量注解只是提供了一种提示,对于运行实际上没有任何影响。

不过有了类型注解,一些 IDE 是可以识别出来并提示的,比如 PyCharm 就可以识别出来在调用某个方法的时候参数类型不一致,会提示 WARNING。

比如上面的调用,如果在 PyCharm 中,就会有如下提示内容:

Expected type 'int', got 'float' insteadThis inspection detects type errors in function call expressions. Due to dynamic dispatch and duck typing, this is possible in a limited but useful number of cases. Types of function parameters can be specified in docstrings or in Python 3 function annotations.
This inspection detects type errors in function call expressions. Due to dynamic dispatch and duck typing, this is possible in a limited but useful number of cases. Types of function parameters can be specified in docstrings or in Python 3 function annotations.

另外也有一些库是支持类型检查的,比如 mypy,安装之后,利用 mypy 即可检查出 Python 脚本中不符合类型注解的调用情况。

上面只是用一个简单的 int 类型做了实例,下面我们再看下一些相对复杂的数据结构,例如列表、元组、字典等类型怎么样来声明。

可想而知了,列表用 list 表示,元组用 tuple 表示,字典用 dict 来表示,那么很自然地,在声明的时候我们就很自然地写成这样了:

names: list = ['Germey', 'Guido']version: tuple = (3, 7, 4)operations: dict = {'show': False, 'sort': True}'Guido']
version: tuple = (3, 7, 4)
operations: dict = {'show': False, 'sort': True}

这么看上去没有问题,确实声明为了对应的类型,但实际上并不能反映整个列表、元组的结构,比如我们只通过类型注解是不知道 names 里面的元素是什么类型的,只知道 names 是一个列表 list 类型,实际上里面都是字符串 str 类型。我们也不知道 version 这个元组的每一个元素是什么类型的,实际上是 int 类型。但这些信息我们都无从得知。因此说,仅仅凭借 list、tuple 这样的声明是非常“弱”的,我们需要一种更强的类型声明。

这时候我们就需要借助于 typing 模块了,它提供了非常“强“的类型支持,比如 List[str]、Tuple[int, int, int] 则可以表示由 str 类型的元素组成的列表和由 int 类型的元素组成的长度为 3 的元组。所以上文的声明写法可以改写成下面的样子:

from typing import List, Tuple, Dictnames: List[str] = ['Germey', 'Guido']version: Tuple[int, int, int] = (3, 7, 4)operations: Dict[str, bool] = {'show': False, 'sort': True}import List, Tuple, Dict

names: List[str] = ['Germey', 'Guido']
version: Tuple[int, int, int] = (3, 7, 4)
operations: Dict[str, bool] = {'show': False, 'sort': True}

这样一来,变量的类型便可以非常直观地体现出来了。

目前 typing 模块也已经被加入到 Python 标准库中,不需要安装第三方模块,我们就可以直接使用了。

typing

下面我们再来详细看下 typing 模块的具体用法,这里主要会介绍一些常用的注解类型,如 List、Tuple、Dict、Sequence 等等,了解了每个类型的具体使用方法,我们可以得心应手的对任何变量进行声明了。

在引入的时候就直接通过 typing 模块引入就好了,例如:

from typing import List, Tupleimport List, Tuple

List

List、列表,是 list 的泛型,基本等同于 list,其后紧跟一个方括号,里面代表了构成这个列表的元素类型,如由数字构成的列表可以声明为:

var: List[int or float] = [2, 3.5]2, 3.5]

另外还可以嵌套声明都是可以的:

var: List[List[int]] = [[1, 2], [2, 3]]2], [2, 3]]

Tuple、NamedTuple

Tuple、元组,是 tuple 的泛型,其后紧跟一个方括号,方括号中按照顺序声明了构成本元组的元素类型,如 Tuple[X, Y] 代表了构成元组的第一个元素是 X 类型,第二个元素是 Y 类型。

比如想声明一个元组,分别代表姓名、年龄、身高,三个数据类型分别为 str、int、float,那么可以这么声明:

person: Tuple[str, int, float] = ('Mike', 22, 1.75)22, 1.75)

同样地也可以使用类型嵌套。

NamedTuple,是 collections.namedtuple 的泛型,实际上就和 namedtuple 用法完全一致,但个人其实并不推荐使用 NamedTuple,推荐使用 attrs 这个库来声明一些具有表征意义的类。

Dict、Mapping、MutableMapping

Dict、字典,是 dict 的泛型;Mapping,映射,是 collections.abc.Mapping 的泛型。根据官方文档,Dict 推荐用于注解返回类型,Mapping 推荐用于注解参数。它们的使用方法都是一样的,其后跟一个中括号,中括号内分别声明键名、键值的类型,如:

def size(rect: Mapping[str, int]) -> Dict[str, int]:    return {'width': rect['width'] + 100, 'height': rect['width'] + 100}
    return {'width': rect['width'] + 100, 'height': rect['width'] + 100}

这里将 Dict 用作了返回值类型注解,将 Mapping 用作了参数类型注解。

MutableMapping 则是 Mapping 对象的子类,在很多库中也经常用 MutableMapping 来代替 Mapping。

Set、AbstractSet

Set、集合,是 set 的泛型;AbstractSet、是 collections.abc.Set 的泛型。根据官方文档,Set 推荐用于注解返回类型,AbstractSet 用于注解参数。它们的使用方法都是一样的,其后跟一个中括号,里面声明集合中元素的类型,如:

def describe(s: AbstractSet[int]) -> Set[int]:    return set(s)
    return set(s)

这里将 Set 用作了返回值类型注解,将 AbstractSet 用作了参数类型注解。

Sequence

Sequence,是 collections.abc.Sequence 的泛型,在某些情况下,我们可能并不需要严格区分一个变量或参数到底是列表 list 类型还是元组 tuple 类型,我们可以使用一个更为泛化的类型,叫做 Sequence,其用法类似于 List,如:

def square(elements: Sequence[float]) -> List[float]:    return [x ** 2 for x in elements]
    return [x ** 2 for x in elements]

NoReturn

NoReturn,当一个方法没有返回结果时,为了注解它的返回类型,我们可以将其注解为 NoReturn,例如:

def hello() -> NoReturn:    print('hello')
    print('hello')

Any

Any,是一种特殊的类型,它可以代表所有类型,静态类型检查器的所有类型都与 Any 类型兼容,所有的无参数类型注解和返回类型注解的都会默认使用 Any 类型,也就是说,下面两个方法的声明是完全等价的:

def add(a):    return a + 1def add(a: Any) -> Any:    return a + 1
    return a + 1

def add(a: Any) -> Any:
    return a + 1

原理类似于 object,所有的类型都是 object 的子类。但如果我们将参数声明为 object 类型,静态参数类型检查便会抛出错误,而 Any 则不会,具体可以参考官方文档的说明:https://docs.python.org/zh-cn/3/library/typing.html?highlight=typing#the-any-type。

TypeVar

TypeVar,我们可以借助它来自定义兼容特定类型的变量,比如有的变量声明为 int、float、None 都是符合要求的,实际就是代表任意的数字或者空内容都可以,其他的类型则不可以,比如列表 list、字典 dict 等等,像这样的情况,我们可以使用 TypeVar 来表示。

例如一个人的身高,便可以使用 int 或 float 或 None 来表示,但不能用 dict 来表示,所以可以这么声明:

height = 1.75Height = TypeVar('Height', int, float, None)def get_height() -> Height:    return height
Height = TypeVar('Height', int, float, None)
def get_height() -> Height:
    return height

这里我们使用 TypeVar 声明了一个 Height 类型,然后将其用于注解方法的返回结果。

NewType

NewType,我们可以借助于它来声明一些具有特殊含义的类型,例如像 Tuple 的例子一样,我们需要将它表示为 Person,即一个人的含义,但但从表面上声明为 Tuple 并不直观,所以我们可以使用 NewType 为其声明一个类型,如:

Person = NewType('Person', Tuple[str, int, float])person = Person(('Mike', 22, 1.75))
person = Person(('Mike', 22, 1.75))

这里实际上 person 就是一个 tuple 类型,我们可以对其像 tuple 一样正常操作。

Callable

Callable,可调用类型,它通常用来注解一个方法,比如我们刚才声明了一个 add 方法,它就是一个 Callable 类型:

print(Callable, type(add), isinstance(add, Callable))

运行结果:

typing.Callable <class 'function'> True

在这里虽然二者 add 利用 type 方法得到的结果是 function,但实际上利用 isinstance 方法判断确实是 True。

Callable 在声明的时候需要使用 Callable[[Arg1Type, Arg2Type, ...], ReturnType] 这样的类型注解,将参数类型和返回值类型都要注解出来,例如:

def date(year: int, month: int, day: int) -> str:    return f'{year}-{month}-{day}'def get_date_fn() -> Callable[[int, int, int], str]:    return date
    return f'{year}-{month}-{day}'

def get_date_fn() -> Callable[[int, int, int], str]:
    return date

这里首先声明了一个方法 date,接收三个 int 参数,返回一个 str 结果,get_date_fn 方法返回了这个方法本身,它的返回值类型就可以标记为 Callable,中括号内分别标记了返回的方法的参数类型和返回值类型。

Union

Union,联合类型,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]

这个在一些方法参数声明的时候比较有用,比如一个方法,要么传一个字符串表示的方法名,要么直接把方法传过来:

def process(fn: Union[str, Callable]):    if isinstance(fn, str):        # str2fn and process        pass    elif isinstance(fn, Callable):        fn()
    if isinstance(fn, str):
        # str2fn and process
        pass
    elif isinstance(fn, Callable):
        fn()

这样的声明在一些类库方法定义的时候十分常见。

Optional

Optional,意思是说这个参数可以为空或已经声明的类型,即 Optional[X] 等价于 Union[X, None]。

但值得注意的是,这个并不等价于可选参数,当它作为参数类型注解的时候,不代表这个参数可以不传递了,而是说这个参数可以传为 None。

如当一个方法执行结果,如果执行完毕就不返回错误信息, 如果发生问题就返回错误信息,则可以这么声明:

def judge(result: bool) -> Optional[str]:    if result: return 'Error Occurred'
    if result: return 'Error Occurred'

Generator

如果想代表一个生成器类型,可以使用 Generator,它的声明比较特殊,其后的中括号紧跟着三个参数,分别代表 YieldType、SendType、ReturnType,如:

def echo_round() -> Generator[int, float, str]:    sent = yield 0    while sent >= 0:        sent = yield round(sent)    return 'Done'
    sent = yield 0
    while sent >= 0:
        sent = yield round(sent)
    return 'Done'

在这里 yield 关键字后面紧跟的变量的类型就是 YieldType,yield 返回的结果的类型就是 SendType,最后生成器 return 的内容就是 ReturnType。

当然很多情况下,生成器往往只需要 yield 内容就够了,我们是不需要 SendType 和 ReturnType 的,可以将其设置为空,如:

def infinite_stream(start: int) -> Generator[int, None, None]:    while True:        yield start        start += 1
    while True:
        yield start
        start += 1

案例实战

接下来让我们看一个实际的项目,看看经常用到的类型一般是怎么使用的。

这里我们看的库是 requests-html,是由 Kenneth Reitz 所开发的,其 GitHub 地址为:https://github.com/psf/requests-html,下面我们主要看看它的源代码中一些类型是如何声明的。

这个库的源代码其实就一个文件,那就是 https://github.com/psf/requests-html/blob/master/requests_html.py,我们看一下它里面的一些 typing 的定义和方法定义。

首先 Typing 的定义部分如下:

from typing import Set, Union, List, MutableMapping, Optional_Find = Union[List['Element'], 'Element']_XPath = Union[List[str], List['Element'], str, 'Element']_Result = Union[List['Result'], 'Result']_HTML = Union[str, bytes]_BaseHTML = str_UserAgent = str_DefaultEncoding = str_URL = str_RawHTML = bytes_Encoding = str_LXML = HtmlElement_Text = str_Search = Result_Containing = Union[str, List[str]]_Links = Set[str]_Attrs = MutableMapping_Next = Union['HTML', List[str]]_NextSymbol = List[str]import Set, Union, List, MutableMapping, Optional

_Find = Union[List['Element'], 'Element']
_XPath = Union[List[str], List['Element'], str, 'Element']
_Result = Union[List['Result'], 'Result']
_HTML = Union[str, bytes]
_BaseHTML = str
_UserAgent = str
_DefaultEncoding = str
_URL = str
_RawHTML = bytes
_Encoding = str
_LXML = HtmlElement
_Text = str
_Search = Result
_Containing = Union[str, List[str]]
_Links = Set[str]
_Attrs = MutableMapping
_Next = Union['HTML', List[str]]
_NextSymbol = List[str]

这里可以看到主要用到的类型有 Set、Union、List、MutableMapping、Optional,这些在上文都已经做了解释,另外这里使用了多次 Union 来声明了一些新的类型,如 _Find 则要么是是 Element 对象的列表,要么是单个 Element 对象,_Result 则要么是 Result 对象的列表,要么是单个 Result 对象。另外 _Attrs 其实就是字典类型,这里用 MutableMapping 来表示了,没有用 Dict,也没有用 Mapping。

接下来再看一个 Element 类的声明:

class Element(BaseParser):    """An element of HTML.    :param element: The element from which to base the parsing upon.    :param url: The URL from which the HTML originated, used for ``absolute_links``.    :param default_encoding: Which encoding to default to.    """    __slots__ = [        'element', 'url', 'skip_anchors', 'default_encoding', '_encoding',        '_html', '_lxml', '_pq', '_attrs', 'session'    ]    def __init__(self, *, element, url: _URL, default_encoding: _DefaultEncoding = None) -> None:        super(Element, self).__init__(element=element, url=url, default_encoding=default_encoding)        self.element = element        self.tag = element.tag        self.lineno = element.sourceline        self._attrs = None    def __repr__(self) -> str:        attrs = ['{}={}'.format(attr, repr(self.attrs[attr])) for attr in self.attrs]        return "<Element {} {}>".format(repr(self.element.tag), ' '.join(attrs))    @property    def attrs(self) -> _Attrs:        """Returns a dictionary of the attributes of the :class:`Element <Element>`        (`learn more <https://www.w3schools.com/tags/ref_attributes.asp>`_).        """        if self._attrs is None:            self._attrs = {k: v for k, v in self.element.items()}            # Split class and rel up, as there are ussually many of them:            for attr in ['class', 'rel']:                if attr in self._attrs:                    self._attrs[attr] = tuple(self._attrs[attr].split())        return self._attrs
    """An element of HTML.
    :param element: The element from which to base the parsing upon.
    :param url: The URL from which the HTML originated, used for ``absolute_links``.
    :param default_encoding: Which encoding to default to.
    """


    __slots__ = [
        'element', 'url', 'skip_anchors', 'default_encoding', '_encoding',
        '_html', '_lxml', '_pq', '_attrs', 'session'
    ]

    def __init__(self, *, element, url: _URL, default_encoding: _DefaultEncoding = None) -> None:
        super(Element, self).__init__(element=element, url=url, default_encoding=default_encoding)
        self.element = element
        self.tag = element.tag
        self.lineno = element.sourceline
        self._attrs = None

    def __repr__(self) -> str:
        attrs = ['{}={}'.format(attr, repr(self.attrs[attr])) for attr in self.attrs]
        return "<Element {} {}>".format(repr(self.element.tag), ' '.join(attrs))

    @property
    def attrs(self) -> _Attrs:
        """Returns a dictionary of the attributes of the :class:`Element <Element>`
        (`learn more <https://www.w3schools.com/tags/ref_attributes.asp>`_).
        """

        if self._attrs is None:
            self._attrs = {k: v for k, v in self.element.items()}

            # Split class and rel up, as there are ussually many of them:
            for attr in ['class', 'rel']:
                if attr in self._attrs:
                    self._attrs[attr] = tuple(self._attrs[attr].split())

        return self._attrs

这里 __init__ 方法接收非常多的参数,同时使用 _URL 、_DefaultEncoding 进行了参数类型注解,另外 attrs 方法使用了 _Attrs 进行了返回结果类型注解。

整体看下来,每个参数的类型、返回值都进行了清晰地注解,代码可读性大大提高。

以上便是类型注解和 typing 模块的详细介绍。

近期热门:

用Python给女友 准备个绝对甜蜜的七夕礼物

5天破10亿的哪吒,为啥这么火,Python来分析

零基础学了8个月的Python,到底有啥感悟


学习群:

小密圈人气很高的两个实战项目

小密圈的趣味实战-微信主题

3个月还没入门Python,看这100名小密圈的同学3周学Python的杰作


Python类型注解(Typing Hint) 编程详解 本文介绍 Python 类型注解 type hint的作用与用法。主要内容 : 类型提示的基本语法,使用mypy工具检查代码中类型的示是否确; 基本类型的类型提示,使用typeing 标准库对list, tuple, dict等集合类型的类型提示,以及复合型的集合类型的类型提示,类型别名的使用, 在函数定义,类定义中使用泛型 generic type, 并以 FastAPI 示例 如何使用类型提示。 阅读详情

相关推荐

Python类型注解(十)

python类型注解,类似其他语言中的变量声明,但是他并没有约束以及检查变量的作用,仅仅是给自己以及代码编辑器起到提示的作用

观止study 5890

Expected type ‘Optional[bool]‘ (matched generic type ‘_VT‘), got ‘str‘ instead

问题:Expected type ‘Optional[bool]’ (matched generic type ‘_VT’), got ‘str’ instead 如图所示,在调用管理员登录接口的过程中,判断用户未登录,修改登录状态时,account变量飘黄。 这是由于 admin_login 中 ‘account’ 的数据类型为 bool 类型,而 account 为 str 类型,两者数据类型不同而提示。只需将 admin_login 中 ‘account’ 的 None 修改为空字符串即可解决,即.

Cream_Bule的博客 3171

AI Agent技术架构与规模化应用:2025年技术深度解析

2025年,AI Agent(人工智能智能体)迎来了规模化应用的拐点时刻。根据Gartner等权威机构预测,企业软件中整合自主型AI的比例将从2024年的不足1%跃升至2028年的33%。本文深入剖析AI Agent的核心技术架构,从规划模块、记忆模块、工具调用模块到底层实现原理,结合Python和Go语言的实际代码示例,全面阐述AI Agent的技术实现路径。同时,本文探讨多智能体协作系统、企业级部署架构以及未来的技术演进方向,为开发者和技术决策者提供系统性的技术参考。关键词:AI Agent、大语言模型

shao.bing的专栏 1349

使用类型注解让 Python 代码更易读

“ 阅读本文大概需要 10分钟。 ”我们知道 Python 是一种动态语言,在声明一个变量时我们不需要显式地声明它的类型,例如下面的例子:a=2print('1+...

静觅 2552

从零开始使用CubeMX配置STM32使用lwip实现httpd服务器以及使用vscode编辑阅读keil代码(三)

使用stm32搭载lwip实现HTTPd服务器

qq_30623327的博客 5935

使用python对创芯科技CANalyst-II分析仪进行二次开发(详细教程)

使用python对创芯科技CANalyst-II分析仪进行二次开发

ningqingzy的博客 1万+

【Python】和BUG说再见!

Python使用类型注解以提高代码可读性

wang720521的博客 1667

PCB设计必看:铜皮厚度与载流能力对照表(附Excel计算工具)

本文深入解析了PCB设计中铜皮厚度与载流能力的核心关系,提供了基于IPC-2152标准的动态计算逻辑与实用Excel工具。文章不仅分享了载流对照表,更重点剖析了影响载流能力的关键因素(如铜厚、线宽、温升、布线层),并给出了高电流设计的实战技巧与测试验证方法,帮助工程师规避常见陷阱,实现从理论到实践的闭环设计。

weixin_29228781的博客 728

python – Pycharm期望类型’optional [bytes]’得到’str’而不是

我使用rsplit来分割路径名, rootPath = os.path.abspath(__file__) rootPath = (rootPath.rsplit('/', 1)[0]).rsplit('/', 1)[0] 但是Pycharm警告说, expected typeoptional [bytes], gotstrinstead 在python doc中,它声明...

大西瓜不甜的博客 6303

SMILES:化学结构的线性表示方法

SMILES:化学结构的线性表示方法

jasminefeng的博客 1万+

(R,线性回归)R语言里的模型诊断图(Residuals vs Fitted,Normal QQ , Scale-Location ,Residuals Leverage)

线性回归,是概率统计学里最重要的统计方法,也是机器学习中一类非常重要的算法。线性模型简单理解非常容易,但是内涵是非常深奥的。尤其是线性回归模型中的Diagnostics plot的阅读与理解一直被认为是线性回归中的一个难点。 在任何线性模型中,能够直接“lm”(模型有意义),既要考虑各个参数的t-test所得出的p-value,也要考虑总体模型F-检验得出的p-value。在这之后,还要清楚一个...

qq_35837578的博客 7万+

python 数据类型-字符串(str)

文章目录 ① 字符串由一对单引号或一对双引号表示 'pyhton' "python" ② 字符串是字符的有序序列,可以对其中的字符进行索引 ③ 字符串属于不可变类,无法对原字符串进行修改

m0_69412818的博客 753

OpenCV C++ 图像处理实战 ——《基于轮廓比对的缺陷检测》

本文使用OpenCV C++ 实现基于轮廓比对的缺陷检测。

Zero___Chen的博客 1151

[转]关于Python里的类型注解

我们知道 Python 是一种动态语言,在声明一个变量时我们不需要显式地声明它的类型,例如下面的例子: a=2print('1+a=',1+a) print('1+a=',1+a) 运行结果: 1+a=3 这里我们首先声明了一个变量 a,并将其赋值为了 2,然后将最后的结果打印出来,程序输出来了正确的结果。但在这个过程中,我们没有声明它到底是什么类型。 但如果这时候我们将 a 变成一个字符串类型,结果会是怎样的呢?改写如下: a='2'pri...

江州司马 454

Unreal5从入门到精通之Landscape地形系统

虚幻引擎 5 (UE5) 能够利用其强大的地形编辑工具套件创建大规模的地形世界。使用地形工具可以创建身临其境的户外地形,这些地形经过优化,可在多种不同设备上保持可播放的帧速率。

TxNet 4147

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

82、python-第二阶段-第一章-9-变量的类型注解

menghuannvxia的专栏 129

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

python注解的使用

Python 中 typing 模块和类型注解的使用 | 静觅

zwz_home的专栏 155

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

NTscan扫描工具

ntscan是一个扫描器,可以扫描没有密码和弱密码的共享,先到配置文件中填写猜测的用户名和密码,扫描过程中右侧出现的是扫描日志。

Python中使用logging模块

import os# 获取当前时间戳(精确到微秒)# 将时间戳转换为可读的格式seconds = int(current_time) # 获取秒部分# 格式化输出return f"global_logger = None def get_current_time() : # 获取当前时间戳(精确到微秒) import time。

喜欢打篮球的普通人 339

Python中如何判断一个变量是否为None

在Python中,判断一个变量是否为None是一个常见的需求,特别是在处理可选值、默认值或者是在函数返回结果可能不存在时。虽然这个操作本身相对简单,但围绕它的讨论可以扩展到Python的哲学、类型系统、以及如何在不同场景下优雅地处理None值。

Good_tea_h的博客 1470

Python中的“:”

在函数定义、循环】条件语句等代码块中,冒号用于表示语句的结束和代码块的开始。这类似于C/C++中的大括号{},用于划定代码块的范围。在切片中,start:end的格式表示从start开始到end之前的元素。在这个例子中,name:str表示name参数的类型是字符串,-> str表示函数的返回类型也是字符串。在Python中,冒号用于切片操作,可以用来获取序列(如列表、字符串、元组)中的特定部分。Python支持类型注解,在变量和函数的定义中,可以使用冒号来说明变量或参数的类型。3、格式化字符串中的冒号。

haohandzhanshi的博客 3264

【Python】类型注解

本文介绍了Python类型注解的使用方法。主要内容包括:变量类型注解的语法格式(如int、float等基础类型及list、dict等容器类型)、函数参数和返回值的类型标注、以及Union联合类型的应用。类型注解虽不会影响程序运行,但能提升IDE的代码提示功能,增强代码可读性。文章通过具体示例展示了如何为变量、函数参数和返回值添加类型提示,特别说明了当数据类型不唯一时如何使用Union类型进行标注。

2302_81115588的博客 1万+

Python的类型注解

参考: Python类型注解,你需要知道的都在这里了Python 是动态语言,其显著特点是在声明变量时,你不需要显式声明它的类型。比如这个: 你看,虽然代码里没有明确指定 的类型,但是程序运行时隐式推断出它是 类型,因此可以顺利执行 的动作。除此之外,已经确定类型的变量,可以随时更改其类型,比如: Python 这种动态特性的好处是它非常的自由,大部分时候你不用纠结类型声明、类型转化等麻烦事,可以用很少的代码完成各种骚操作。但是缺点也在这里:如果你代码某些变量的类型有错,编辑器、IDE等工具无法在早期

sally的jerry 5119

Python 类型注解详细指南

新类型from typing import NewType , TypedDict # 新类型 UserId = NewType('UserId' , int) def get_user_name(user_id : UserId) - > str : return f"user_ {

qq_17275369的博客 4087

python中的类型注解

在编写函数((方法),使用形参data的时候,工具没有任何提示·在调用函数(方法),传入参数的时候,工具无法提示参数类型这些都是因为,我们在定义函数(方法)的时候,没有给形参进行注解。Python在3.5版本的时候引入了类型注解,以方便静态类型检查工具,IDE等第三方工具类型注解:在代码中涉及数据交互的地方,提供数据类型的注解(显式的说明)。如图,就算不写注解,也明确的知晓变量的类型,一般,无法直接看出变量类型之时会添加变量的类型注解。除了使用变量:类型,这种语法做注解外,也可以在注释中进行类型注解。

weixin_63318044的博客 4529

python 类型注解 list_Python 类型注解

说明Python 教程正在编写中,欢迎大家加微信 sinbam 提供意见、建议、纠错、催更。简单说,Python 类型注解功能可以让我们的代码更加易读,从而达到编写更加健壮的代码目标。类型注解又叫类型暗示,将函数、变量声明为一种特定类型。当然,它并不是严格的类型绑定,所以这个机制并不能阻止调用者传入不应该传入的参数。背景由于 Python 是一个动态语言,定义和使用变量时不需要申明变量的数据类型即...

weixin_39616056的博客 2133
上一篇: 用Python给女友 准备个绝对甜蜜的七夕礼物
下一篇: Python Web 开发哪家强?
菜鸟学Python
博客等级 码龄9年 8092粉丝 571原创
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值