精华内容
下载资源
问答
  • Python 是一门强类型的动态语言, 对于一个 Python 函数或者方法, 无需声明形参及返回值的数据类型, 在程序的执行的过程中, Python 解释器也不会对输入参数做任何的类型检查, 如果程序中存在非法的数据操作, 程序会在...

    Python 是一门强类型的动态语言, 对于一个 Python 函数或者方法, 无需声明形参及返回值的数据类型, 在程序的执行的过程中, Python 解释器也不会对输入参数做任何的类型检查, 如果程序中存在非法的数据操作, 程序会在相应的位置停止执行, 并抛出异常. 对象的调用者也无需声明所接收返回值的数据类型,所以这里就需要开发者在开发的过程中自行注意实参及所接收返回值的数据类型,并进行相应的业务处理.

    def test_func(g, k):

    try:

    c = g + k

    except Exception:

    c = False

    return c

    如上面的示例, 函数 test_func 并不需要指明形参 g, k 及返回值的数据类型, 此时如果调用者传递了两个不同数据类型的实参, 那么就会导致该函数抛出异常. 这时就需要我们在函数中进行相应的业务处理,

    或者进行异常捕捉,否则就需要开发者在调用函数前review该函数,严格传递正确的数据类型,并了解到该函数有可能出现的返回值类型,如上面的示例中,就有可能返回布尔值.在Python代码开发的过程中,

    因为Python的这一特性,有时反而会加大我们不必要的开发时间成本

    从Python3.6开始, 加入了数据类型的检查功能,借助于现有IDE(如Pycharm)的高亮提示功能,在调用函数或者方法时,如果传递了错误的数据类型或者返回值数据类型异常,IDE会进行高亮,提示开发者及时进行更正,需要注意的是,这里只是进行提示开发者,但并不会要求你严格按照规则执行,更加不会因此而提升代码性能,它只是用来提升代码开发效率的一种方式而已,最起码可以有效的减少代码的调试时间

    # g:int, k:int 提示形参的数据类型为 int

    # -> int 提示返回值为 int

    def test_func(g: int, k: int) ->int:return g + k

    # 在IDE(pycharm)中, 如果是返回一个字符串,那么就会将该字符串进行高亮提示,但并不代表该程序无法执行

    # return "lowman"

    a: int = 1

    b: str = 2 # 仍然能赋值成功

    print(a + b) # 在IDE(pycharm)中, print 函数内的 b 参数被高亮, 但是程序仍然能执行, 结果输出 int类型 3

    所以,Python3.6版本新加入的类型检查功能, 只能算是提升开发效率的辅助方式而已.Python中的变量仍然是可动态变化的.实际上Python的数据类型检查是由Python解释器在执行代码时逐行进行完成的, 并动态的根据当前变量所指向的数据的类型为其指定,与其他语言(如Golang在使用变量之前必须先定义其数据类型,然后再根据其数据类型进行正确的赋值, Golang是强类型的静态语言)是有着本质区别.只能说,动态特性也是一把双刃剑

    展开全文
  • 问题的根本原因,就是python中一切皆是对象,函数丢失了类型信息,读起来相当痛苦,只有执行过程,才比较方便掌握代码。 解决方案 方法一,类型注释 python语言缔造者,也已经看出来了代码中没有类型信息的问题。...

    问题

    python语言是一门易学易用的语言,不过相比起c++、java语言,就是读别人的代码,是比较痛苦的,尤其代码量比较大的情况,更是如此。

     

    def add(a, b):
        return a + b
    
    print(10,20)
    print('10','20')
    

    问题的根本原因,就是python中一切皆是对象,函数丢失了类型信息,读起来相当痛苦,只有执行过程,才比较方便掌握代码。

    解决方案

    方法一,类型注释

    python语言缔造者,也已经看出来了代码中没有类型信息的问题。当下的python3版本,已经提供了类型标记。比如:

     

    def add(a:int, b:int)->int:
        return a + b
    

    上述代码中,add表示两个整数的和。不过,这个特性,可以理解为是一种注释,实际代码运行的时候,同样还可以传递字符串的参数。

    在python3.6滞后的版本,建议坚持用这种写法写python代码,毕竟代码还是要给阅读的,不带类型信息,读起来缺失很费劲。

    方法二,类型装饰器

    python有个装饰器特性,装饰器可以轻松实现面向切面的编程,比如函数的运行时间统计,函数出入口日志打印等等。代码如下:

     

    from functools import wraps
    from inspect import signature
    
    def type_assert(*type_args, **type_kwargs):
        def check(func):
            sig = signature(func)
            bound_types = sig.bind_partial(*type_args, **type_kwargs).arguments
    
            @wraps(func)
            def wrapper(*args, **kwargs):
                bound_values = sig.bind(*args, **kwargs)
                for name, value in bound_values.arguments.items():
                    if name not in bound_types:
                        continue
    
                    if not isinstance(value, bound_types[name]):
                        raise TypeError('argument {} must be {}'.format(
                            name, bound_types[name]))
                return func(*args, **kwargs)
    
            return wrapper
    
        return check
    

    测试代码如下:

     

    # 可以不指定参数使用。@type_assert(int,int)
    @type_assert(a=int, b=int))
    def add(a, b):
        return a + b
    
    print(add(10, 10))
    print(add(10.0, 10.0))
    

    运行结果如下,类型信息在运行时得到有效检查。

     

    20
    Traceback (most recent call last):
      File "/Users/xxx/data/code/python/type_assert.py", line 38, in <module>
        print(add(10.0, 10.0))
      File "/Users/xxx/data/code/python/type_assert.py", line 18, in wrapper
        raise TypeError('argument {} must be {}'.format(
    TypeError: argument a must be <class 'int'>
    

    同样,类型type_assert还可以为参数指定多种类型,完全不用修改代码。比如:

     

    @type_assert(a=(int, float), b=(int, float))
    def add(a, b):
        return a + b
    
    print(add2(10, 10))
    print(add2(10.0, 10.0))
    

    并且,类型type_assert还可以用于类的方法上,进行类型检查。只不过,因为类的方法有个self参数,指定参数的时候需要写明参数名称(当然,self是不用指定类型)。比如:

     

    class Math:
        @type_assert(a=int, b=int)
        def add(self, a, b):
            return a + b
    
    math = Math()
    math.add(10, 20)
    math.add(10.0, 20.0)
    

    输出:

     

    Traceback (most recent call last):
      File "/Users/xxx/data/code/python/type_assert.py", line 40, in <module>
        math.add(10.0, 20.0)
      File "/Users/xxx/data/code/python/type_assert.py", line 18, in wrapper
        raise TypeError('argument {} must be {}'.format(
    TypeError: argument a must be <class 'int'>
    

    这个方法看上去还比较不错,简单实用。但也不是万能的,不建议到处用,毕竟会降低性能,建议公开给外部调用的方法上使用类型断言。另外,对于类型检查比较严格时,是需要自己处理的。比如下面的代码:

     

    @type_assert(a=(int, float, str), b=(int, float, str))
    def add(a, b):
        return a + b
    add(10.0,'20.0')
    

    这个运行时,因为类型不同引起的异常,type_assert是检查不出来的。如果要支持,就需要在add函数中检查不同类型,该如何处理了。

    展开全文
  • python 函数参数类型检查

    千次阅读 2019-05-22 09:38:52
    Python中,不知道函数参数类型是...下面我们用装饰器来实现,函数参数的强制类型检查。 首先,这个装饰器,要接受类型参数,和指定函数参数的类型参数。也就是一个list和一个dict from functools import wraps...

    在Python中,不知道函数参数类型是一个很正常的事情,特别是在一个大项目里。
    我见过有些项目里,每一个函数体的前十几行都在检查参数类型,这实在是太麻烦了。而且一旦参数有改动,这部分也需要改动。
    下面我们用装饰器来实现,函数参数的强制类型检查。


    首先,这个装饰器,要接受类型参数,和指定函数参数的类型参数。也就是一个list和一个dict

    from functools import wraps
    
    def typeassert(*type_args, **type_kwargs):
        def decorate(func):
            @wraps(func)
            def wrapper(*args, **kwargs):
                return func(*args, **kwargs)
            return wrapper
        return decorate
    

    @wraps(func)的作用请看另一篇


    那么,接下来,在装饰器中,我们需要获取函数参数列表,并且要和类型参数表映射。
    这要借助Python的一个标准库——inspect 这个库一般用于Python代码调试

    from inspect import signature
    from functools import wraps
    
    def typeassert(*type_args, **type_kwargs):
        def decorate(func):
            sig = signature(func)
            bound_types = sig.bind_partial(*type_args, **type_kwargs).arguments
    
            @wraps(func)
            def wrapper(*args, **kwargs):
                return func(*args, **kwargs)
            return wrapper
        return decorate
    

    上面的代码中,我们使用inspect中的signature方法获取了funcSignature对象,然后使用bind_partial方法创建了(*type_args, **type_kwargs)func参数的映射(也就是一个字典)。


    接下来就简单了,我们只需要再获取(*args, **kwargs)的类型,使用 isinstance 函数进行比较就好。

    from inspect import signature
    from functools import wraps
    
    def typeassert(*type_args, **type_kwargs):
        def decorate(func):
            sig = signature(func)
            bound_types = sig.bind_partial(*type_args, **type_kwargs).arguments
    
            @wraps(func)
            def wrapper(*args, **kwargs):
                bound_values = sig.bind(*args, **kwargs)
                for name, value in bound_values.arguments.items():
                    if name in bound_types:
                        if not isinstance(value, bound_types[name]):
                            raise TypeError('Argument {} must be {}'.format(name, bound_types[name]))
                return func(*args, **kwargs)
            return wrapper
        return decorate
    

    运行如下代码

    @typeassert(int, int)
    def add(x, y):
        return x+y
    
    print(add("u", 2))
    

    能看到报错如下

    Traceback (most recent call last):
      File "c:\Users\Chen\Desktop\typeassert.py", line 32, in <module>
        print(add("u", 2))
      File "c:\Users\Chen\Desktop\typeassert.py", line 22, in wrapper
        'Argument {} must be {}'.format(name, bound_types[name])
    TypeError: Argument x must be <class 'int'>
    

    很贴心的提醒了我们哪一个参数应该是什么类型。你甚至可以自己改动这个装饰器,让它还能告诉你传进去了什么错误参数(特别是写爬虫的时候,参数很难掌握,一旦报错,还得重跑一遍才知道为什么。)

    你也可以指定某一个参数的类型,譬如

    @typeassert(int, z=str)
    def display(x, y, z):
        print(x, y, z)
    

    这时你会发现,y的类型就像原生的Python函数一样,什么都行。而x必须是int,z必须是str



     

    展开全文
  • python类型检查和类型转换 类型检查 type()用来检查值的类型 (整型、浮点型、布尔值、字符串、空值)该函数会将检查的结果作为返回值返回,可以通过变量来接收函数的返回值 print(type(1)) # <...
    1. 类型检查

       type()用来检查值的类型 (整型、浮点型、布尔值、字符串、空值)
       该函数会将检查的结果作为返回值返回,可以通过变量来接收函数的返回值

      print(type(1))         # <class 'int'>
      print(type(1.5))       # <class 'float'>
      print(type(True))      # <class 'bool'>
      print(type('hello'))   # <class 'str'>
      print(type(None))      # <class 'NoneType'>
      
      a=type(123)
      print('123数字类型检查结果返回值:',a)
      # 123数字类型检查结果返回值: <class 'int'>

       

    2. 类型转换
       类型转换四个函数 int() float() str() bool()

      a = '123'
      a = int(a)

      int() 可以用来将其他的对象转换为整型
      规则:
        布尔值:True -> 1 False -> 0
             浮点数:直接取整,省略小数点后的内容
             字符串:合法的整数字符串,直接转换为对应的数字
                            如果不是一个合法的整数字符串,
                            则报错 ValueError: invalid literal for int() with base 10: '11.5'  
             对于其他不可转换为整型的对象,直接抛出异常 ValueError

      float() 和 int()基本一致,不同的是它会将对象转换为浮点数

      str() 可以将对象转换为字符串
             True -> 'True'
             False -> 'False'
             123 -> '123'


      bool() 可以将对象转换为布尔值,任何对象都可以转换为布尔值
             规则:对于所有表示空性的对象都会转换为False,其余的转换为True
                        哪些表示的空性:0 、 None 、 ''

    posted on 2019-07-06 11:45 人生与戏 阅读(...) 评论(...) 编辑 收藏

    转载于:https://www.cnblogs.com/FlyingLiao/p/11142225.html

    展开全文
  • Python 类型检查实践

    2020-10-08 11:01:22
    那么如何能让 Python 像 Java 或 Go 这样的语言一样,在编译期就进行类型检查呢?从 3.5 版本开始,Python 就能支持静态类型检查了。本文整理自团队的一次内部分享,介绍了 Python 的这一新特性。 Quick Start 首先...
  • python-函数参数类型检查

    千次阅读 2019-04-24 15:08:56
    python在3.5后引入了参数类型注解,例: def add(x:int,y:int)->int:#对x,y和返回值都进行注释,为int类型 return x + y 注:注解是对函数参数和返回值的‘注释’,没有强制定义的作用(因为python是动态语言啊...
  • 主要介绍了python通过装饰器检查函数参数数据类型的方法,涉及Python装饰器的使用技巧,具有一定参考借鉴价值,需要的朋友可以参考下
  • 下面我们用装饰器来实现,函数参数的强制类型检查。 首先,这个装饰器,要接受类型参数,和指定函数参数的类型参数。也就是一个list和一个dict from functools import wraps def typeassert(*type_args, **....
  • 自定义方法,检测参数类型 def my_abs(x): if not isinstance(x,(int,float)): raise TypeError('type error') if x>=0: print x else: print -x if __name__ == '__main__': my_abs('...
  • 函数动态类型检查的装饰器代码 import inspect import functools def typeHints(fn): @functools.wraps(fn) def wrap(*args, **kwargs): sig = inspect.signature(fn) params = sig.parameters # 处理kwargs:...
  • 虽然动态语言python不对变量作出编译性质的类型声明,但可以使用装饰函数对被装饰函数进行”类型检查” 此例只是将”类型检查”的信息输出,如要实现”强制类型检查”,可以在wrapper()的类型检查语句中对”...
  • 只读函数参数做一个辅助的说明,并不对函数进行类型检查 提供第三方工具,做代码分析,发现隐藏的BUG 函数注解的信息保存在__annotations__属性中 In [1]: def add(x: int, y: int) -> int: ...
  • 把内容过程中比较常用的一些内容记录起来,下面内容段是关于python通过装饰器检查函数参数的数据类型的内容。 def check_accepts(f): assert len(types) == f.func_code.co_argcount, 'accept number of arguments...
  • python是动态语言,在后期维护的成本非常高,很重要的一点就是没有进行类型检查,当然还包括新建变量不需要声明以及指定类型等等。 但是,在python3.5之后,就新增了对函数参数和返回值的类型指定和检查,以及在...
  • inspect模块用于收集python对象的信息,可以获取类或函数的参数的信息,源码,解析堆栈,对对象进行类型检查等等 https://www.cnblogs.com/linxiyue/p/7989947.html ...
  • Python库在运行时提供类型检查函数调用 目录 介绍 让我们从一个玩具示例开始: def times_two ( value ): return 2 * value value = 3 result = times_two ( value ) print ( f' { value } * 2 == { result } ' ...
  • Python 加入类型检查

    2019-12-23 14:42:06
    Python 是一门强类型的动态语言, 对于一个 Python 函数或者方法, 无需声明形参及返回值的数据类型, 在程序的执行的过程中, Python 解释器也不会对输入参数做任何的类型检查, 如果程序中存在非法的数据操作, 程序会在...
  • 人工智障进阶之路001Python中打了激素的数组---------列表向列表的操作输入输出函数检查变量的数据类型函数type()数据类型转换函数变量的格式化输出 Python中打了激素的数组---------列表 相比于传统的计算机编程...
  • Python中的函数

    2019-08-05 15:17:36
    python中的函数与js中函数功能一样封装共用逻辑,增加代码可复用性,但是复杂性远远高于JavaScript... 函数参数的类型检查 多值返回 函数参数 函数参数又分3个部分: (1)默认值参数 (2)可变参数 (3)...
  • Python是一种非常动态的语言,函数定义中完全没有类型约束。下面这篇文章主要给大家详细介绍了Python类型检查的相关资料,需要的朋友可以参考借鉴,下面来一起看看吧。
  • Python 学习 之 函数

    2019-03-20 14:37:31
    文章目录函数调用函数数据类型转换定义函数函数参数检查返回多个值函数参数位置参数默认参数可变参数关键字参数命名关键字参数参数组合递归函数 函数 当代码出现有规律的重复的时候,便可以用函数来解决麻烦的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 806
精华内容 322
关键字:

python类型检查函数

python 订阅