python类型检查函数 python检查变量类型

Python中为什么推荐使用isinstance来进行类型判断

Python在定义变量的时候不用指明具体的的类型,解释器会在运行的时候会自动检查 变量的类型,并根据需要进行隐式的类型转化。因为Python是动态语言,所以一般情 况下是不推荐进行类型转化的。比如"+"操作时,如果加号两边是数据就进行加法操 作,如果两边是字符串就进行字符串连接操作,如果两边是列表就进行合并操作,甚 至可以进行复数的运算。解释器会在运行时根据两边的变量的类型调用不同的内部方法。 当加号两边的变量类型不一样的时候,又不能进行类型转化,就会抛出TypeError的异常。

创新互联建站主要从事网站设计、成都网站设计、网页设计、企业做网站、公司建网站等业务。立足成都服务德阳,10余年网站建设经验,价格优惠、服务专业,欢迎来电咨询建站服务:028-86922220

但是在实际的开发中,为了提高代码的健壮性,我们还是需要进行类型检查的。而进行 类型检查首先想到的就是用type(),比如使用type判断一个int类型。

import types

if type(1) is types.Integer:

print('1是int类型')

else:

print('1不是int类型')

上面的程序会输出:1是int类型

我们在types中可以找到一些常用的类型,在2.7.6中显示的结果:

types.BooleanType # bool类型

types.BufferType # buffer类型

types.BuiltinFunctionType # 内建函数,比如len()

types.BuiltinMethodType # 内建方法,指的是类中的方法

types.ClassType # 类类型

types.CodeType # 代码块类型

types.ComplexType # 复数类型

types.DictProxyType # 字典代理类型

types.DictType # 字典类型

types.DictionaryType # 字典备用的类型

types.EllipsisType

types.FileType # 文件类型

types.FloatType # 浮点类型

types.FrameType

types.FunctionType # 函数类型

types.GeneratorType

types.GetSetDescriptorType

types.InstanceType # 实例类型

types.IntType # int类型

types.LambdaType # lambda类型

types.ListType # 列表类型

types.LongType # long类型

types.MemberDescriptorType

types.MethodType # 方法类型

types.ModuleType # module类型

types.NoneType # None类型

types.NotImplementedType

types.ObjectType # object类型

types.SliceTypeh

types.StringType # 字符串类型

types.StringTypes

types.TracebackType

types.TupleType # 元组类型

types.TypeType # 类型本身

types.UnboundMethodType

types.UnicodeType

types.XRangeType

在Python 3中,类型已经明显减少了很多

types.BuiltinFunctionType

types.BuiltinMethodType

types.CodeType

types.DynamicClassAttribute

types.FrameType

types.FunctionType

types.GeneratorType

types.GetSetDescriptorType

types.LambdaType

types.MappingProxyType

types.MemberDescriptorType

types.MethodType

types.ModuleType

types.SimpleNamespace

types.TracebackType

types.new_class

types.prepare_class

但是我们并不推荐使用type来进行类型检查,之所以把这些类型列出来,也是为了扩展知识 面。那为什么不推荐使用type进行类型检查呢?我们来看一下下面的例子。

import types

class UserInt(int):

def __init__(self, val=0):

self.val = int(val)

i = 1

n = UserInt(2)

print(type(i) is type(n))

上面的代码输出:False

这就说明i和n的类型是不一样的,而实际上UserInt是继承自int的,所以这个判断是存在问题的, 当我们对Python内建类型进行扩展的时候,type返回的结果就不够准确了。我们再看一个例子。

class A():

pass

class B():

pass

a = A()

b = B()

print(type(a) is type(b))

代码的输出结果: True

type比较的结果a和b的类型是一样的,结果明显是不准确的。这种古典类的实例,type返回的结果都 是一样的,而这样的结果不是我们想要的。对于内建的基本类型来说,使用tpye来检查是没有问题的, 可是当应用到其他场合的时候,type就显得不可靠了。这个时候我们就需要使用isinstance来进行类型 检查。

isinstance(object, classinfo)

object表示实例,classinfo可以是直接或间接类名、基本类型或者有它们组成的元组。

isinstance(2, float)

False

isinstance('a', (str, unicode))

True

isinstance((2, 3), (str, list, tuple))

True

Python 几个重要的内置函数

在学习Python的过程中,有几个比较重要的内置函数:help()函数、dir()函数、input()与raw_input()函数、print()函数、type()函数。

第一、help()函数

Help()函数的参数分为两种:如果传一个字符串做参数的话,它会自动搜索以这个字符串命名的模块、方法等;如果传入的是一个对象,就会显示这个对象的类型的帮助。比如输入help(‘print’),它就会寻找以‘print’为名的模块、类等,找不到就会看到提示信息;而print在Python里是一个保留字,和pass、return同等,而非对象,所以help(print)也会报错。

第二、dir()函数

dir()函数返回任意对象的属性和方法列表,包含模块对象、函数对象、字符串对象、列表对象、字典对象等。尽管查找和导入模块相对容易,但是记住每个模块包含什么却不是这么简单,您并不希望总是必须查看源代码来找出答案。Python提供了一种方法,可以使用内置的dir()函数来检查模块的内容,当你为dir()提供一个模块名的时候,它返回模块定义的属性列表。dir()函数适用于所有对象的类型,包含字符串、整数、列表、元组、字典、函数、定制类、类实例和类方法。

第三、input与raw_input函数

都是用于读取用户输入的,不同的是input()函数期望用户输入的是一个有效的表达式,而raw_input()函数是将用户的输入包装成一个字符串。

第四、Print()函数

Print在Python3版本之间是作为Python语句使用的,在Python3里print是作为函数使用的。

第五、type()函数

Type()函数返回任意对象的数据类型。在types模块中列出了可能的数据类型,这对于处理多种数据类型的函数非常有用,它通过返回类型对象来做到这一点,可以将这个类型对象与types模块中定义类型相比较。

Python中的input()、isinstance()函数如何使用?

Python解释器内置了许多函数,这意味着我们无需定义,始终可以它们。接下来和大家一起讨论一个常用的内建函数-input()和isinstance()。

input()

input()函数读取用户输入,并转换成字符串:

a = input()  # 将input()返回的值赋值给a

Python

a            # 查看a的值(为字符串'Python')

'Python'

input()函数可以提供一个参数,用来提示用户:

b = input('请输入你最喜欢的水果:  ')   # 给用户必要的提示

请输入你最喜欢的水果:  香蕉

b

'香蕉'

需要注意的是,input()函数返回的值总是字符串,当用户输入的是数字也是这样,所以当使用它时一定要注意:

num = input('请输入一个数字: ')

请输入一个数字: 10

num + 9                            # 试图把num和数字相加

Traceback (most recent call last):

File "", line 1, in

TypeError: must be str, not int

num

'10'

type(num)                           # 查看num的数字类型

class 'str'

isinstance()

isinstance()函数用于检查对象是否为指定类(或者说数据类型)的实例。isintance()的第一个参数为一个对象,第二个参数为要检查的数据类型。

举个例子,比如有有一个变量,你想检查它是否为数字类型,可以使用isinstance()函数:

score = 90

result = isinstance(score, int)

if result:

...     print('score为int数据类型')

... else:

...     print('score不为int数据类型')

...

score为int数据类型

除了能检查是否为int类型外,isintance()还能检查其他数据类型(当然了),下面是一个综合示例:

pi = 3.14

name = 'Wang'

complex_num = 1 + 2j

isinstance(pi, float)              # 3.14为浮点数类型

True

isinstance(name, str)              # 'Wang'为字符串类型

True

isinstance(complex_num, complex)   #  1 + 2j为复数

True

isinstance()还可以验证某个对象是否为自定义的类型:

class Developer:                             # 定义一个叫做Developer的类

...

...     def __init__(self, name):                # __init__方法中,需要输入名字

...         self.name = name

...     def display(self):                       # 定义了display()方法

...         print("Developer:", self.name, "-")

...

class PythonDeveloper(Developer):            # PythonDeveloper类,继承了Developer类

...

...     def __init__(self, name, language):

...         self.name = name

...         self.language = language

...

...     def display(self):                        # 覆盖了父类的display方法

...         print("Python Developer:", self.name, "language:", self.language, "-")

...

dev = Developer('Zhang')                     # 创建一个Developer对象

dev.display()                                # 调用display()方法,以查看该对象

Developer: Zhang -

isinstance(dev, Developer)                   # 判断dev是否为Developer类,答案是肯定的

True

isinstance(dev, PythonDeveloper)             # 判断dev是否为PythonDeveloper类,当然不是

False

python_dev = PythonDeveloper('Liu', 'Python')  # 创建一个PythonDeveloper对象,注意PythonDeveloper是Developer的子类

python_dev.display()                          # 调用display方法

Python Developer: Liu language: Python -

isinstance(python_dev, Developer)             # 判断python_dev是否为Developer类,答案是肯定的

True

isinstance(python_dev, PythonDeveloper)      # 判断python是否为PythonDeveloper类,答案也是肯定的

True

关于Python的基础问题可以看下这个网页的视频教程,网页链接,希望我的回答能帮到你。

python内置函数有哪些

python常见的内置函数有:

1. abs()函数返回数字的绝对值。

2. all() 函数用于判断给定的参数中的所有元素是否都为 TRUE,如果是返回 True,否则返回 False。元素除了是 0、空、None、False 外都算 True;空元组、空列表返回值为True。

3. any() 函数用于判断给定的参数是否全部为False,是则返回False,如果有一个为True,则返回True。 元素除了是 0、空、False外都算 TRUE。

4. bin()函数返回一个整数int或者长整数long int的二进制表示。

5. bool() 函数用于将给定参数转换为布尔类型,如果参数不为空或不为0,返回True;参数为0或没有参数,返回False。

6. bytearray()方法返回一个新字节数组。这个数组里的元素是可变的,并且每个元素的值范围: 0 = x 256(即0-255)。即bytearray()是可修改的二进制字节格式。

7. callable()函数用于检查一个对象是否可调用的。对于函数、方法、lambda函式、类以及实现了 __call__ 方法的类实例, 它都返回 True。(可以加括号的都可以调用)

8. chr()函数用一个范围在range(256)内(即0~255)的整数作参数,返回一个对应的ASCII数值。

9. dict()函数用来将元组/列表转换为字典格式。

10. dir()函数不带参数时,返回当前范围内的变量、方法和定义的类型列表;带参数时,返回参数的属性、方法列表。

扩展资料:

如何查看python3.6的内置函数?

1、首先先打开python自带的集成开发环境IDLE;

2、然后我们直接输入"dir(__builtins__)",需要注意的是builtins左右的下划线都是两个;

3、回车之后我们就可以看到python所有的内置函数;

4、接下来我们学习第二种查看python内置函数的方法,我们直接在IDLE中输入"import builtins",然后输入"dir(builtins)";

5、然后回车,同样的这个方法也可以得到所有的python内置的函数;

6、这里我们可以使用python内置函数len()来查看python内置函数的个数,这里我们直接输入"len(dir(builtins))";

7、回车之后我们可以看到系统返回值153,说明我们现在这个版本中有153个内置函数;

8、最后我们介绍一个比较有用的内置函数"help",python内置函数有一百多个,我们当然不能记住所有的函数,这里python提供了一个"help"函数,我们来看一个例子一起来体会一下help函数的用法,这里我们直接输入"help(len)",然后回车,会看到系统给我们对于内置函数"len"的解释,当然对于其他函数可能会有更加详细的解释以及用法提示。

python 函数参数的类型

1. 不同类型的参数简述

#这里先说明python函数调用得语法为:

复制代码

代码如下:

func(positional_args,

keyword_args,

*tuple_grp_nonkw_args,

**dict_grp_kw_args)

#为了方便说明,之后用以下函数进行举例

def test(a,b,c,d,e):

print a,b,c,d,e

举个例子来说明这4种调用方式得区别:

复制代码

代码如下:

#

#positional_args方式

test(1,2,3,4,5)

1 2 3 4 5

#这种调用方式的函数处理等价于

a,b,c,d,e = 1,2,3,4,5

print a,b,c,d,e

#

#keyword_args方式

test(a=1,b=3,c=4,d=2,e=1)

1 3 4 2 1

#这种处理方式得函数处理等价于

a=1

b=3

c=4

d=2

e=1

print a,b,c,d,e

#

#*tuple_grp_nonkw_args方式

x = 1,2,3,4,5

test(*x)

1 2 3 4

5

#这种方式函数处理等价于

复制代码

代码如下:

a,b,c,d,e = x

print

a,b,c,d,e

#特别说明:x也可以为dict类型,x为dick类型时将键传递给函数

y

{'a': 1,

'c': 6, 'b': 2, 'e': 1, 'd': 1}

test(*y)

a c b e d

#

#**dict_grp_kw_args方式

y

{'a': 1, 'c': 6, 'b': 2, 'e': 1, 'd': 1}

test(**y)

1 2 6

1 1

#这种函数处理方式等价于

a = y['a']

b = y['b']

... #c,d,e不再赘述

print

a,b,c,d,e

2.

不同类型参数混用需要注意的一些细节

接下来说明不同参数类型混用的情况,要理解不同参数混用得语法需要理解以下几方面内容.

首先要明白,函数调用使用参数类型必须严格按照顺序,不能随意调换顺序,否则会报错. 如 (a=1,2,3,4,5)会引发错误,;

(*x,2,3)也会被当成非法.

其次,函数对不同方式处理的顺序也是按照上述的类型顺序.因为#keyword_args方式和**dict_grp_kw_args方式对参数一一指定,所以无所谓顺序.所以只需要考虑顺序赋值(positional_args)和列表赋值(*tuple_grp_nonkw_args)的顺序.因此,可以简单理解为只有#positional_args方式,#*tuple_grp_nonkw_args方式有逻辑先后顺序的.

最后,参数是不允许多次赋值的.

举个例子说明,顺序赋值(positional_args)和列表赋值(*tuple_grp_nonkw_args)的逻辑先后关系:

复制代码

代码如下:

#只有在顺序赋值,列表赋值在结果上存在罗辑先后关系

#正确的例子1

x =

{3,4,5}

test(1,2,*x)

1 2 3 4 5

#正确的例子2

test(1,e=2,*x)

1 3 4 5 2

#错误的例子

test(1,b=2,*x)

Traceback (most recent call

last):

File "stdin", line 1, in module

TypeError: test()

got multiple values for keyword argument 'b'

#正确的例子1,处理等价于

a,b = 1,2 #顺序参数

c,d,e = x #列表参数

print a,b,c,d,e

#正确的例子2,处理等价于

a = 1 #顺序参数

e = 2 #关键字参数

b,c,d = x #列表参数

#错误的例子,处理等价于

a = 1 #顺序参数

b = 2 #关键字参数

b,c,d = x

#列表参数

#这里由于b多次赋值导致异常,可见只有顺序参数和列表参数存在罗辑先后关系

函数声明区别

理解了函数调用中不同类型参数得区别之后,再来理解函数声明中不同参数得区别就简单很多了.

1. 函数声明中的参数类型说明

函数声明只有3种类型, arg, *arg , **arg 他们得作用和函数调用刚好相反.

调用时*tuple_grp_nonkw_args将列表转换为顺序参数,而声明中的*arg的作用是将顺序赋值(positional_args)转换为列表.

调用时**dict_grp_kw_args将字典转换为关键字参数,而声明中**arg则反过来将关键字参数(keyword_args)转换为字典.

特别提醒:*arg

和 **arg可以为空值.

以下举例说明上述规则:

复制代码

代码如下:

#arg, *arg和**arg作用举例

def

test2(a,*b,**c):

print a,b,c

#

#*arg 和

**arg可以不传递参数

test2(1)

1 () {}

#arg必须传递参数

test2()

Traceback (most recent call last):

File "stdin", line 1,

in module

TypeError: test2() takes at least 1 argument (0 given)

#

#*arg将顺positional_args转换为列表

test2(1,2,[1,2],{'a':1,'b':2})

1 (2, [1, 2], {'a': 1, 'b': 2})

{}

#该处理等价于

a = 1 #arg参数处理

b = 2,[1,2],{'a':1,'b':2} #*arg参数处理

c =

dict() #**arg参数处理

print a,b,c

#

#**arg将keyword_args转换为字典

test2(1,2,3,d={1:2,3:4}, c=12, b=1)

1 (2, 3) {'c': 12, 'b': 1, 'd': {1: 2, 3:

4}}

#该处理等价于

a = 1 #arg参数处理

b= 2,3 #*arg参数处理

#**arg参数处理

c =

dict()

c['d'] = {1:2, 3:4}

c['c'] = 12

c['b'] = 1

print

a,b,c

2. 处理顺序问题

函数总是先处理arg类型参数,再处理*arg和**arg类型的参数.

因为*arg和**arg针对的调用参数类型不同,所以不需要考虑他们得顺序.

复制代码

代码如下:

def test2(a,*b,**c):

print

a,b,c

test2(1, b=[1,2,3], c={1:2, 3:4},a=1)

Traceback (most

recent call last):

File "stdin", line 1, in

module

TypeError: test2() got multiple values for keyword argument

'a'

#这里会报错得原因是,总是先处理arg类型得参数

#该函数调用等价于

#处理arg类型参数:

a = 1

a = 1

#多次赋值,导致异常

#处理其他类型参数

...

print a,b,c

def foo(x,y):

... def bar():

... print

x,y

... return bar

...

#查看func_closure的引用信息

a =

[1,2]

b = foo(a,0)

b.func_closure[0].cell_contents

[1, 2]

b.func_closure[1].cell_contents

b()

[1, 2] 0

#可变对象仍然能被修改

a.append(3)

b.func_closure[0].cell_contents

[1, 2, 3]

b()

[1, 2, 3] 0


网页名称:python类型检查函数 python检查变量类型
网页链接:http://pwwzsj.com/article/hjcgse.html