包含内容如下：1.内置类型，我来为大家讲解一下关于python中数据的类型怎么看?跟着小编一起来看一看吧!
python中数据的类型怎么看
包含内容如下：
1.内置类型
2.1基本对象-类型判断
2.2类-类型判断
3.types运用（主要用作类型判断）
4.typing运用（主要用作类型判断，数据类型检查在pycharm上并未见报错）
5.例程（用途检查任意对象的数据类型；根据需要选择相应的功能函数）
******************************************************************************************
内置类型 ------------------------------------------------------------------------------ 1.1.数据内置类型 None #缺少值None表示无，# 是NoneType唯一值 NotImplemented #builtins.NotImplemented未实现 # 数值方法和比较方法未实现所提供操作数操作返回此值 # 用于对一些二元特殊方法(如：__eq__, __It__等)中作为返回值 number： #numbers.Number int, float, complex, bool（True，False） sequence: #typing.Sequence 不可变序列 str，unicode(python2）, tuple, byte; 可变序列 list;bytearray;array;range map: dict set: set, frozenset - ---------------------------------------------------------------------------- 1.2.程序结构内置类型 可调用类型 types.BuiltinFunctionType # 内置函数或方法 type # 内置类型和类 object types.FunctionType # 用户定义函数 types.MethodType # 类方法 模块 types.ModeleType # 模块 类 object # 所有类型和类的祖先 类型 type # 内置类型和类的类型 - ----------------------------------------------------------------------------- 1.3.解释器内部使用内置类型 types.Codetype # 字节编译代码 types.FrameType # 执行帧 types.GeneratorType # 生成器对象 types.TracebackType # 异常栈跟踪 slice # 由扩展切片生成 Ellipsis # 和...是等价;用在扩展切片循环是EllipsisType类型常量 __debug__ #是一个bool类型的常量 -------------------------------------------------------------------------------- 2.example: >>> ... == Ellipsis # True >>> a = [1, 2, 3, 4] >>> a.append(a) >>> a # [1, 2, 3, 4, [...]] >>> len(a) # 5 >>> a[4] # [1, 2, 3, 4, [...]] >>> a[4][4] # [1, 2, 3, 4, [...]] -------------------------------------------------------------------------------- class A(object): def __init__(self, name, value): self.name = name self.value = value def __eq__(self, other): print('self:', self.name, self.value) print('other:', other.name, other.value) return self.value == other.value # 判断两个对象的value值是否相等 a1 = A('Tom', 1) a2 = A('Jim', 1) print(a1 == a2) # 输出 # self: Tom 1 # other: Jim 1 # True -------------------------------------------------------------------------------- class A(object): def __init__(self, name, value): self.name = name self.value = value def __eq__(self, other): print('self:', self.name, self.value) print('other:', other.name, other.value) return NotImplemented a1 = A('Tom', 1) a2 = A('Jim', 1) print(a1 == a2) # 输出 # self: Tom 1 # other: Jim 1 # self: Jim 1 # other: Tom 1 # False --------------------------------------------------------------------------------
******************************************************************************************
对象类型判断 ------------------------------------------------------------------------------------ 1.1.对象判断 对象特征： 每个对象都有一个标识一个类型和一个值。 对象判断： is运算符 比较两个对象是否相同;即id,值，类型都相同 基本类型int,float,complex，str不要用is来做相等判断 ‘==’相等判断 仅仅数值相同，id，type有可能不同 取对象ID: id(‘’‘对象’) 返回一个表示其身份的整数。 ------------------------------------------------------------------------------------- 1.2.实例 1.2.1.数值 i1=2; i2=2.0 i1 == i2, i1 is i2 # (True, False) 1.2.2.字符串 str1 = '123' ;str2 = str(123) str1 == str2, str1 is str2 #(True, False) 1.2.3.序列 a = [1, 2];b = [1, 2] a is b # False id(a), id(b) # (48189960, 48126536) 1.2.4.函数 def fun(a, b): return a b f1 = fun(1, 2);f2 = fun(1, 2) f1 is f2 #True 1.2.5.生成器，迭代器 不相等 a = [1, 2, 3, 45]; b 1= iter(a); b2= iter(a) b1 is b2 #False b1==b2 #False 1.2.6.类实例不相等 class Person(object): def __init__(self, name, age=0): self.name = name self.age = age def show(self): print(self.a, self.b) a1 = Person("Tom", 20) a2 = Person("Tom", 20) a1 == a2 # False id(a1), id(a2) # (45851760, 45854616)#类实例不相等 ******************************************************************* a1.__dict__ == a2.__dict__# True 类实例方法属性相同 ******************************************************************* #如要类实例相等重写__eq__ # class Person(object): def __eq__(self, other): if self.name != other.name: return False if self.age != other.age: return False return True a1 = Person("Tom", 20) a2 = Person("Tom", 20) a1 == a2 # True a1 is a2 # False ------------------------------------------------------------------------------------ 2.1.对象类型判断 函数： type(): 返回对象类型 用途：基本的类型判断 说明： 扩展类型最好不用，如一定要用应构建一个相似类型如： ArrayType=type(array.array('i')) b=array.array('u','hello') type(b) is ArrayType# True 不会认为子类是父类 isinstance(object,class -or -type- or -tuple)判断类型是否相同 会认为子类是父类类型 基本类型： bool, int(long), float, complex, str, tuple, list, dict,set,frozenset 直接运用于type或isinstance函数中 扩展类型： ellipsis, NoneType, object, slice, type, range, array.ArrayType，numbers.Number 需要先导入相应的模块或自荐构建此类型 ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** 2.2.实例： 数字判断 import numbers isinstance(4, numbers.Number)#True type(123) == int INT_Type=type(0) #自定义类型 type(12) is INT_Type #True bytes判断 isinstance(b'a', bytes) #True 自定义判断 lst=[1] isinstance(lst, (int, str, list)) #任意一个满足类型都为True None判断 NoneType = type(None) 切片判断 a=slice(None, 10, None) type(a) is slice # True 省略号判断 ...is Ellipsis # True range判断 isinstance(a, range) # True 数组判断 a=array.array('i', [1, 2, 3, 4])# array('i', [1, 2, 3, 4]) isinstance(a, array.ArrayType)# True正确用法 # type(a) #<class 'array.array'> # a is array.ArrayType# False不要这样应用 类类型判断 见相关：类类型判断 函数迭代器： 见types介绍 ------------------------------------------------------------------------------------ 3.对象引用计数 sys.getdefcount(a) # 获得对象的引用计数 ------------------------------------------------------------------------------------
******************************************************************************************
类判断 # -------------------------------------------------------------------------------------------------- 1.定义类 __metaclass__ = type # 确定使新式类 class father(): def __init__(self,x0=None,x=None,y=None): self.x0 = x0 self.x=x self.y=y def show(self): print("father()已经创建",self.x0,self.x,self.y) class son(father): def __init__(self,x0=100,x=200,y=300): super(son, self).__init__(x0,x,y) self.x0=-3 def show1(self): print("son()已经创建",self.x0)#如果父类有此属性，被初始化为-3 s0 = son() f0=father() # -------------------------------------------------------------------------------------------------- 2.查看类的子类 2.1查看类的子类 #__subclasses__不能是实例对象 print('1',father.__subclasses__())#[<class '__main__.son'>] print('1',son.__subclasses__()) #[] 2.2查看类的父类 #__bases__不能是实例对象 print('2',father.__bases__) #(<class 'object'>,) print('2',son.__bases__) # (<class '__main__.father'>,) 2.3type查看类 print('3',type(father),type(son),type(f0),type(s0)) # <class 'type'> # < class 'type' > # < class '__main__.father' > # < class '__main__.son' > print('3',father.__class__,son.__class__,f0.__class__,s0.__class__) # <class 'type'> # < class 'type' > # < class '__main__.father' > # < class '__main__.son' > print('3',father.mro(),son.mro()) # [<class '__main__.father'>, <class 'object'>] # <class '__main__.son'>, <class '__main__.father'>, <class 'object'>] # -------------------------------------------------------------------------------------------------- 3.判断父子类 #issubclass参数必须是类，不能为实例 print('4',issubclass(son, father)) #True #i__subclasscheck__必须是类，不能为实例 print("5.",father.__subclasscheck__(son))#True # -------------------------------------------------------------------------------------------------- 4.类的实例判断 print("6.",isinstance(s0, son)) #True print("6.",isinstance(s0, father)) # True # -------------------------------------------------------------------------------------------------- ****************************************************************************************
**************************************************************************************************************
types模块 2018/6/14 https://docs.python.org/3/library/types.html#module-types ---------------------------------------------------------------------------------------------------------- 1.动态类型创建 types.new_class（name，bases =（），kwds = None，exec_body = None ） types.prepare_class（name，bases =（），kwds = None ） 计算适当的元类并创建类命名空间. types.resolve_bases（基地） 按照指定动态解析MRO条目 PEP 560. ---------------------------------------------------------------------------------------------------------- 2.标准解释器类型 名称的典型用途是用于isinstance()或 issubclass()检查. types.FunctionType=class function(object) types.LambdaType =class function(object) lambda 表达式创建用户定义函数和函数的类型 . types.GeneratorType = class generator(object) 生成器 -iterator对象类型，由生成器函数创建. types.CoroutineType =class coroutine(object) 由函数创建协程对象类型 types.AsyncGeneratorType =class async_generator(object 由异步生成器函数创建的异步生成器 --iterator对象的类型. types.CodeType =class code(object) 代码对象的类型，如返回的compile(). types.MethodType =class method(object) 用户定义类实例方法类型. types.BuiltinFunctionType =class builtin_function_or_method(object) 内置函数的类型 types.BuiltinMethodType =class builtin_function_or_method(object) 内置类的方法 types.WrapperDescriptorType=class wrapper_descriptor(object) 一些内置数据类型和基类方法类型，如 object.__init__()或object.__lt__(). types.MethodWrapperType= class method-wrapper(object) 一些内置数据类型和基类绑定方法类型.如，它的类型object().__str__. 某些内置数据类型的方法类型如str.join(). types.ClassMethodDescriptorType= class classmethod_descriptor(object) 某些内置数据类型未绑定类方法类型，例如 dict.__dict__['fromkeys']. types.ModuleType（name，doc None ）=class module(object) 模块的类型.构造函数采用要创建的模块的名称以及可选的文档字符串. types.MemberDescriptorType=class member_descriptor(object) 扩展模块中定义对象类型PyMemberDef，如datetime.timedelta.days. 此类型用作使用标准转换函数的简单C数据成员的描述符 types.MappingProxyType（映射）=class mappingproxy(object) 映射的只读代理. types.FrameType =class frame(object) types.GetSetDescriptorType =class getset_descriptor(object) types.TracebackType =class traceback(object) ---------------------------------------------------------------------------------------------------------- class types.MappingProxyType（映射） 用途： 映射的只读代理. 方法： key in proxy True如果底层映射具有密钥， 则返回False. proxy[key] 使用键键返回基础映射的项目.引发 KeyErrorif 键不在底层映射中. iter(proxy) 在底层映射的键上返回一个迭代器.这是一个捷径iter(proxy.keys()). len(proxy) 返回基础映射中的项目数. copy（） 返回底层映射的浅表副本. get（键[，默认] ） 如果key在底层映射中，则返回key的值，否则返回 default. 如果未给出default，则默认为，因此此方法永远不会引发a .NoneKeyError items（） 返回底层映射项（ 对）的新视图.(key, value) keys（） 返回底层映射键的新视图. values（） 返回底层映射值的新视图. --------------------------------------------------------------------------------------------------------------- 3.其他实用程序类和函数 class types.SimpleNamespace 一个简单的object子类，提供对其命名空间的属性访问，以及有意义的repr. class types.DynamicClassAttribute（fget = None，fset = None，fdel = None，doc = None ） 将类的属性访问路由到__getattr__. ---------------------------------------------------------------------------------------------------------------- 4.协程实用功能 class types.coroutine（gen_func ） 此函数将生成器函数转换为协程函数.基于生成器的协程仍然是生成器迭代器， 被认为是协程对象并且是 等待的.但是，它可能不一定实现该__await__()方法. 如果gen_func是生成器函数，它将被就地修改. 如果gen_func不是生成器函数，它将被包装.如它返回一个实例collections.abc.Generator ，则实例将包装在一个等待的代理对象中.所有其他类型的对象将按原样返回. --------------------------------------------------------------------------------------------------------------------
******************************************************************************************
typing-类型检查 --------------------------------------------------------------------------------------------------------------- 1.1.typing 作用： 类型检查，防止运行时出现参数和返回值类型不符合。 作为开发文档附加说明，方便使用者调用时传入和返回参数类型。 该模块加入后并不会影响程序的运行，不会报正式的错误，只有提醒。 传入参数: 通过“参数名:类型”的形式声明参数的类型； 返回结果: 通过"-> 结果类型"的形式声明结果的类型。 说明： 调用时候参数类型不正确pycharm会有提醒，但不会影响程序的运行。 “-> List[str]”, 规定返回的是列表，并且元素是字符串。 typing常用类型： int, long, float: 整型, 长整形, 浮点型; bool, str: 布尔型，字符串类型； List, Tuple, Dict, Set:列表，元组，字典, 集合; Iterable, Iterator:可迭代类型，迭代器类型； Generator：生成器类型； ---------------------------------------------------------------------------------------------------------------- 2.实例： from typing import List, Tuple, Dict def fun1(a0:int,s0:str,f0:float,b0:bool)->Tuple[List,Tuple,Dict,bool]: list1 = list(range(a0)) tup1 = (a0, s0, f0,b0) dict1 = {s0: f0} b1 = b0 return list1, tup1, dict1, b1 print(fun1(5, "KeyName", 2.3, False)) # ([0, 1, 2, 3, 4], (5, 'KeyName', 2.3, False), {'KeyName': 2.3}, False) ************************************************************************************** from typing import List def func(a: int,b: str) -> List[int or str]:# 使用or关键字表示多种类型 list1 = [] list1.append(a) list1.append(b) return list1 ************************************************************************************* import typing T=typing.TypeVar('T',int,float,str) def foo(name:T)->str: return str(name) print(foo(2.012)) ************************************************************************************* NewId=typing.NewType('NewId',int) type(NewId)# <class 'function'> b=NewId(22) type(b)# <class 'int'> ************************************************************************************* ----------------------------------------------------------------------------------------------------------------
******************************************************************************************
# python3.7 2018/8/21#查看类的属性方法 types.example import types class A(): """ class A def...""" a_x = -1000 def __init__(self,a_id,a_name): self.a_id=a_id self.a_name=a_name def setx(self, a_id): self.a_id = a_id def getx(self): return self.a_id @staticmethod # 静态方法 def a_show_static(): print('静态方法:无法访问a_x,a_id和a_name') @classmethod def a_show_cls(cls): return (cls.a_x 100) def show(self, x): print('a show =',self.a_id, x) class AA(A): """class AA def.base is A...""" x = 11 def __init__(self, id1, name1): super(AA, self).__init__(a_id=-11, a_name='Tom1') self.id1 = id1 self.name1 = name1 def setx(self, id1): self.id1 = id1 def getx(self): return self.id1 @staticmethod # 静态方法 def static_show(): print('静态方法:无法访问id1和name1') @classmethod def cls_show(cls): return (cls.x 1000) def show(self, x): print('a show =', self.a_id, x) # ----------------------------------------------------------------------------------------------------- class view_types(): """查看对象属性方法函数""" def __init__(self): self.type_base = [ 'bool', 'int', 'float', 'complex', 'str', 'byte','bytearray','set','frozenset', 'tuple', 'list', 'dict','range', 'type(None)' 'slice','Ellipsis']
self.type_class = ['type']#内置类型和类的类型
self.type_types = [
'types.AsyncGeneratorType', 'types.BuiltinFunctionType',
'types.BuiltinMethodType',
'types.CodeType', 'types.CoroutineType',
'types.ClassMethodDescriptorType',
'types.FunctionType',
,
