Python 类型判断变量存在判断 None与空字符串 is和==区别 nan inf判断

约定不等于承诺〃 2024-04-03 10:05 44阅读 0赞

### **一、类型变量** ###

**type**

> 1.  `#判断是否为整数`
> 2.  `type(varObj) is types.IntType`
> 3.  
> 4.  `StringType`
> 5.  `FloatType`
> 6.  `DictType`
> 7.  `TupleType`
> 8.  `ListType`
> 9.  `BooleanType`

**isinstance**

> 1.  `isinstance(aaa,str)`

**type与isinstance区别**

> 1.  `class A: pass class B(A): pass isinstance(A(), A) # returns True type(A()) == A # returns True isinstance(B(), A) # returns True type(B()) == A # returns False`

### **二、变量存在** ###

**异常捕获**

> 1.  `try:`
> 2.  `print self.fileReadOpen`
> 3.  `except Exception:`
> 4.  `pass`
> 5.  `else:`
> 6.  `del self.fileReadOpen`
> 7.  
> 8.  `def isset(v):`
> 9.  `try :`
> 10. `type (eval(v))`
> 11. `except :`
> 12. `return 0`
> 13. `else :`
> 14. `return 1`
> 15. 
> 16. `isset('varname') //变量只能在try里调用才会捕获异常，所以采用字符串参数。`

**命名空间**

> 1.  `'varname' in locals().keys()`
> 2.  `'varname' in dir()`

> dir()不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法**dir**()，该方法将被调用。如果参数不包含**dir**()，该方法将最大限度地收集参数信息。

### **三、None与空字符串** ###

有句话说的Python中万物皆为对象。None也是对象。这就好理解None与空字符串NULL区别：

> 1.  `type(None)`
> 2.  `<class 'NoneType'>`
> 3.  
> 4.  `type('')`
> 5.  `<class ''str'>`
> 6.  
> 7.  `>>> None == 0 //(int)`
> 8.  `False`
> 9.  `>>> None == ' ' //(str)`
> 10. `False`
> 11. `>>> None == False //(boolean)`
> 12. `False`

### **四、is和==区别** ###

is判断的是a对象是否就是b对象，是通过id来判断的。  
==判断的是a对象的值是否和b对象的值相等，是通过value来判断的。

> 1.  `>>> d = {`
> 2.  `"a":1}`
> 3.  `>>> dd = d.copy()`
> 4.  `>>> d is dd`
> 5.  `False`
> 6.  `>>> d == dd`
> 7.  `True`

### **五、nan inf** ###

记忆：对于is判断，符合is的对象比较定义：对象is对象本身，对象不is新建对象。对于==判断，除了nan，符合==的值比较的定义。对于nan在用==值比较时，可以认为，nan对象的值不==该nan对象的值，nan对象的值不==新建nan对象的值。

> 1.  `>>> inf = float("inf")`
> 2.  `>>> ninf = float("-inf")`
> 3.  `>>> nan = float("nan")`
> 4.  `>>> inf is inf`
> 5.  `True`
> 6.  `>>> ninf is ninf`
> 7.  `True`
> 8.  `>>> nan is nan`
> 9.  `True`
> 10. `>>> inf == inf`
> 11. `True`
> 12. `>>> ninf == ninf`
> 13. `True`
> 14. `>>> nan == nan // nan对象时本身对象nan`
> 15. `False`
> 16. `>>> inf is float("inf")`
> 17. `False`
> 18. `>>> ninf is float("-inf")`
> 19. `False`
> 20. `>>> nan is float("nan")`
> 21. `False`
> 22. `>>> inf == float("inf")`
> 23. `True`
> 24. `>>> ninf == float("-inf")`
> 25. `True`
> 26. `>>> nan == float("nan") //前一个nan值不等于新建对象float("nan")的值`
> 27. `False`

**判断nan方法：**

> 1.  `使用math模块：`
> 2.  `>>> import math`
> 3.  `>>> math.isinf(inf)`
> 4.  `True`
> 5.  `>>> math.isinf(ninf)`
> 6.  `True`
> 7.  `>>> math.isnan(nan)`
> 8.  `True`
> 9.  `>>> math.isinf(float("inf"))`
> 10. `True`
> 11. `>>> math.isinf(float("-inf"))`
> 12. `True`
> 13. `>>> math.isnan(float("nan"))`
> 14. `True`
> 15. 
> 16. `利用自身判断：`
> 17. `>>> def isnan(num):`
> 18. `return num != num`
> 19. `>>> isnan(float("nan"))`
> 20. `True`
> 21. 
> 22. `使用numpy：`
> 23. `>>> import numpy as np`
> 24. `>>>`
> 25. `>>> np.isnan(np.nan)`
> 26. `True`
> 27. `>>> np.isnan(float("nan"))`
> 28. `True`
> 29. `>>> np.isnan(float("inf"))`
> 30. `False`