Python-基础数据类型
⽬录
前⾔
Python 3.x中基础数据类型共分为4种：
整型（int）
浮点型（float）
复数（complex）
布尔型（bool）
你要问不是还有长整型（long）么？注意，长整型在Python 3.x中统⼀归为整形了。
整型：int
整型数就是不包括⼩数部分的数值，分为整数、0和负数，Python提供了int⽤于表⽰现实中的整数。
Python为int类型提供了数学运算及运算符。
>>> 2+4*2
10
>>> 2*4/4
2.0
>>> 4/2
2.0
>>> type(4*2)
<class 'int'>
>>> type(4/2)
<class 'float'>
由上例可以看出，运算规则与数学运算规则基本⼀致，只是在除法“/”时，返回的是float类型，如果想要实现复杂的计算，可以加括号，跟数学计算⼀样。>>> ((2+4) * 3 / (3 + 2)) + 2 * 3
9.6
int类型不仅能与算数运算符结合，还能跟赋值运算符结合。
>>> x = 5
>>> x += 1
>>> x
6
>>> x -= 1
>>> x
5
>>> x *= 1
>>> x
5
>>> x *= 2
>>> x
10
>>> x /= 1
>>> x
10.0
>>> x /= 2
>>> x
5.0
这⾥再次说⼀下赋值运算符，在现实中，我们知道⼀个数不可能“等于”该数加1，但在编程语⾔中是⼀个合法的语句，它的含义是将变量x指向的值加1之后再重新赋值给x本⾝，鉴于这种操作的频繁，Python包括其他语⾔提供这种+=的简写形式。
x += 1  # 等价于 x = x + 1
浮点型：float
Python提供了float类型来表⽰浮点数，float类型的数值与数学中的写法基本⼀致，但允许⼩数点后⾯没有任何数字（⼩数部分为0），如下列数值都是浮点类型。
3.1415  -6.23  12.0  -5.  .5
Python同样为浮点型数值提供了加减乘除等运算，运算符也跟整数类型⼀样，但有⼀点，在Python 3.x中，运算符/⽤于浮点数时，是保留⼩数部分的，⽽Python 2.x版本解释器则返回int类型。
>>> 6 / 3
2.0
>>> type(6/3)    # Python3.x中
<class 'float'>
>>> type(6/3)    # Python2.x中
<class 'int'>
浮点型数据能够表⽰巨⼤的数值，能够进⾏⾼精度的计算，但由于浮点型数据在计算机内部是⽤固定长度的⼆进制表⽰的，有些数值可能⽆法精确的表⽰，只能存储带有微⼩误差的近似值，⽐如下⾯的情况。
>>> 1.2 - 1.0      # ⽰例1
0.19999999999999996
>>> 2.2 - 1.2      # ⽰例2
1.0000000000000002
>>> 2.0 - 1.0      # ⽰例3
1.0
上⾯的例⼦可以看到，⽰例1的结果⽐0.2略⼩，⽽⽰例2⽐1.0略⼤，⽽⽰例3则算出了精确的结果，⼀般⽽⾔，这种微⼩的误差不影响实际应⽤，但在⼀些极端情况下，因为极⼩的误差，仍能导致出错。
>>> 1.2 - 1.0 == 0.2
False
>>> 2.0 - 1.0 == 1.0
True
上⾯我们⽤运算符==来⽐较两个表达式，结果显⽰为布尔值的True和False，从上⾯的例⼦中我们得出了⼀个重要的经验：不要在浮点数中使⽤运算符==来判断是否相等，但有较真的就想这么⽐较怎么办，我们不应该直接⽐较，⽽是通过计算两个浮点数的差值是否⾜够⼩，是的话，我们认为相等。
>>> epsilon = 0.0000000000001  # ⾜够⼩的数
>>> abs((2.2 - 1.2) - 1) <= epsilon
True
>>> abs((1.2 - 1.0) - 0.2) <= epsilon
True
注意，abs()函数返回⼀个数值的绝对值。
>>> abs(-5)
5
>>> abs(-5.0)
5.0
Python⽤浮点型数值表⽰很⼤或很⼩的数值时，会⾃动采⽤科学计数法来表⽰。
>>> 1234.56789 ** 10
8.225262591471028e+30
>>> 1234.56789 ** -10
1.2157666565404538e-31
但下⾯种情况下除外，这种情况Python将长串的数值理解为⼀串整型数，会原封不动的打印出来。⽽上⾯的例⼦则是计算的结果。
>>> 1111111111111123121213
1111111111111123121213
>>> 123123131313131313131321231321231
123123131313131313131321231321231
>>> type(123123131313131313131321231321231)
<class 'int'>
注意，从运算效率来说，float相对于int运算效率略低。所以，如果不是必须⽤到⼩数，⼀般应该采⽤整数类型。另外，不要⽤浮点数来通过运算符==来判断是否相等这样的问题。
那么，我们常⽤==和is做判断，那么⼆者是否是⼀个意思呢？我们就通过来例⼦来看看==和is 的区别。
>>> a = 256
>>> b = 256
>>> c = 257
>>> d = 257
>>> a == b
python的字符串是什么True
>>> a is b
True
>>> c == d
True
>>> c is d
False
>>> id(a)
494578096
>>> id(b)
494578096
>>> id(c)
57248800
>>> id(d)
57248784
在解释之前，我们需要补充⼀点知识，Python为了实现对内存的有效利⽤，在对⼩整数-5~256之内的整数会进⾏缓存，不在此范围内的则不缓存。那么，我们再来说上⾯的例⼦，通过各变量在内存中的id看到，a和b都指向同⼀个内存空间，所以，⽆论是is还是==都是True，那么我们再来看c和d，在内存中的i
d地址是不同的，但是两者的值是相同的，那么可以得出，==⽐较的是值，⽽is则是⽐较的是两个变量在内存中的id地址。
布尔类型：bool
上⼀节中的⽰例中，判断两个数是否相等时，Python给我们返回了布尔类型的结果，那么什么是布尔类型呢？
布尔是19世纪英国的数学家，他建⽴了命题代数，所谓的命题就是可以判断命题真假的语句。在编程语⾔中，将真假两个值组成了⼀个类型，即布尔类型，真假值也称为布尔值，以真假为值的表达式称为布尔表达式，布尔表达式在程序中的作⽤是根据条件的真假执⾏对应的语句。
Python在2.3版本之后就定义了布尔类型bool，bool类型的两个值为True和False。在2.3版本之前，Python⽤1和0来表⽰真、假，这个⽅法沿⽤⾄今。
>>> if 1:
...    print('true')
... else:
...    print('false')
...
true
布尔表达式最常⽤的是判断两个表达式的数值⼤⼩关系的。
[表达式] [运算符] [表达式]
>>> 2 == 2
True
但布尔表达式在判断字符串的时候就不那么简单了。
>>> 'oldboy' == 'oldboy'
True
>>> 'oldboy' == 'OLDBOY'
False
在Python中，字符串是按字典的顺序进⾏⽐较的，也就是说是基于字母顺序⽐较，⽽字母顺序是按照ASCII编码顺序排列的。所以，不管是⼤⼩写字母，标点符号，阿拉伯数字以及各种字符也是要按照ASCII编码来确定⼤⼩。
>>> 3 > 3
False
>>> 3 > 2
True
>>> 2 * 2 > 2
True
>>> 'like' > 'lake'
True
那么，我们怎么查看这些数字、字母、标点符号在ASCII编码中的位置⼤⼩呢？我们可以通过ord函数来查看。
>>> ord('1')
49
>>> ord('a')
97
>>> ord('A')
65
>>> ord(',')
44
>>> ord('<')
60
ord函数返回字符在ASCII中的位置序号。
当然，仅⽤简单的布尔表达式不⾜以满⾜某些需求，将多个简单的布尔表达式⽤逻辑运算符连接起来组成复杂的布尔表达式，回顾⼀下我们学过的逻辑运算符：and、or、not。
[布尔表达式] and [布尔表达式]
[布尔表达式] or [布尔表达式]
not [布尔表达式]
复杂表达式各项的值依赖于参加逻辑运算的布尔表达式的值，具体的依赖关系可以⽤真值表来定义：
在上图中，P和Q是参加运算的布尔表达式，T和F表⽰真假值。在and中，P和Q各有两种可能的值，所以P、Q组合共有4中不同的值组合，每种组合在表中⼀⾏表⽰，后⾯⼀列是P and Q的值，从表中可知，只有当P、Q都为真，并且P and Q为真，整个表达式为真。
>>> 3 > 3 and 3 < 4
False
>>> 3 > 2 and 3 < 4
True
在or中，只有P or Q为假，且P、Q也为假，表达式为假，也就是说，只要其中⼀项为真，则表达式为真。
>>> 3 > 3 or 3 < 4
True
>>> 3 > 3 or 3 == 4 or 3 == 3
True
not的⽤法相对简单。
>>> not 3 > 3
True
>>> not not 3 > 3
False
上例中，not not 3 > 3语句相当于我们⽣活中的双重否定为肯定。利⽤这三个逻辑运算符可以构建复杂的布尔型表达式。在复杂的布尔表达式中，同算数运算符⼀样，谁先谁后计算成了问题，这就要牵扯到运算符的优先级了，回顾⼀下上⼀⼩节中我们列出运算符的优先级的图，可以看到逻辑运算符的优先级。
not > and > or
在此再介绍⼀种别的语⾔不⽀持的表达式形式。
>>> 3 > 2 < 4
True
>>> 3 > 2 < 4 == 4 != 5
True
虽然这在数学中常⽤，但我们仍不推荐这种⽅式，因为这不为⼤多数语⾔所接受，对于这类表达式，还是⽤逻辑运算符⽐较好。
⼩结：有时候适当的加括号，来改变原有的优先级，就像数学运算中加括号改变计算顺序⼀样如计算：2 * (2 + 2)。
>>> print( 0 or not 0 or '')
True
>>> print( 0 or not 0 or '' and 1)
True
>>> print( 0 or not 0 or '' and 1 and 0)
True
>>> print( 0 or not 0 or '' and 1 and 0 and None)
True
>>> print( (0 or not 0 or '') and 1 and 0 and None)
>>> print( (0 or not 0 or '') and 1 and 0 or None)
None
>>> print( (0 or not 0 or '') and 1 and 0 or None)
None
通过上⾯的例⼦，我们可以发现，返回值是有⼀定的规律的。
如果⽤x、y表⽰任何表达式。
x and y
and中，如果x的值为false，则返回x的值，否则返回y的值。
>>> 1 and 0
>>> 0 and 1
or中，如果x的值为false，则返回y的值，否则返回x的值。
>>> 0 or 1
1
>>> 1 or 0
1
not中，如果x的值为false，则返True，否则返回False。
>>> x = 0
>>> not x
True
>>> y = 1
>>> not y
False
>>> not not y
True
注意：Python中，元素⾃带布尔值，也就是说，每个元素都有⾃⼰的布尔值，我们可以通过bool函数来证明。
>>> bool(0)
False
>>> bool(1)
True
>>> bool(None)
False
>>> bool('')
False
>>> bool([])
False
>>> bool(-1)
True
由上例可以看到，在Python中，0、None、空为假，其余为真。
注意：空包括，空的字符串，空的容器类型。
复数：complex
Python⽤complex表⽰复数类型，但由于不常⽤，我们只做了解。
在数学中，任意数可表⽰为a + bi，a称为实部，b称为虚部；⽽Python中complex类型的表⽰⽅法为(a + bj)。
注意，Python中的complex类型的虚数符号⽤j表⽰，⽽不是数学中的i，在不会产⽣误解的情况下，(a + bj)可以省略括号为a + bj。complex类型也可以执⾏数学运算。
>>> c1 = 3 + 5j
>>> c2 = 2 + 4j
>>> c1 + c2
(5+9j)
>>> c1 - c2
(1+1j)
>>> c1 * c2
(-14+22j)
>>> c1 ** c2
(-0.5249747542492873+0.16891854983884866j)
>>> abs(c1)
5.830951894845301
需要注意的是，abs函数对复数的计算是返回复数的模数。
我们也可以通过c1.real()和c1.imag()来分别获取c1的实数和虚数，结果都是float类型。
>>> c1 = 3 + 5j
>>> c2 = 2 + 4j
>>> c1.real
3.0
>>> c1.imag
5.0
欢迎斧正，that's all

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。