no判断 python yes_Python 内置类型全解析（1）

在 Python 中，每个值都有一种数据类型。但由于 python 是动态类型的语言，因此并不需要事先声明变量的数据类型。Python 根据每个变量的初始赋值情况分析其类型，并在内部对其进行跟踪。

对于用户自定义类型，需要开发者事先定义属性和方法，后续才可进行操作。另外 Python 有许多内置数据类型，可以使用相应的对象操作符直接进行操作。

本文介绍几种常用的 Python 内置数据类型，一并介绍常用的操作。

Numbers［数值型］可以是 Integers［整数］（1 和 2）、Floats［浮点数］（1.1 和 1.2）、Fractions［分数］（1/2 和 2/3）；甚至是 Complex Number［复数］。
Booleans［布尔型］或为 True［真］或为 False［假］。
Strings［字符串型］是 Unicode 字符序列，例如：一份 html 文档。
Bytes［字节］和 Byte Arrays［字节数组］，例如: 一份 jpeg 图像文件。
Lists［列表］是值的有序序列。
Tuples［元组］是有序而不可变的值序列。
Sets［集合］是装满无序值的包裹。
Dictionaries［字典］是键值对的无序包裹。

1 Numbers 数值型

python 中并没有 number 这一类型，而是具体分为 int（整型）、float（浮点型）。另外，可以表示数字的还有 fractions（分数）、complex（复数）等。

1.1 int 整形

整形就是整数类型，声明整形有四种方式：

>>> var1 = 361       # 十进制
>>> var2 = 0b101001  # 二进制，0b是二进制的标志符号
>>> var3 = 0o177     # 八进制，0o是八进制的标志符号
>>> var4 = 0x9ff     # 十六进制，0x是十六进制的标志符号

用内置函数 hex()、oct()、bin()，可以把十进制数字转化为其他进制。

>>> hex(93078848) # 转为十六进制
'0x58c4540'
>>> oct(93078848) # 转为八进制
'0o543042500'
>>> bin(93078848) # 转为二进制
'0b101100011000100010101000000

另外，还可以字符串的形式把其他进制的数转化为十进制数。

>>> int('12',8)    #把八进制数12转化为十进制
10
>>> int('f',16)    #把十六进制数f转化为十进制数
15
>>> int('1010',2)  #把二进制数1010转化为十进制数
10
>>> int('13',10)
13
>>> int('13')      #如果不写转化到多少进制，默认转到十进制数
13

1.2 float 浮点型

浮点型就是小数类型，Python 通过是否有小数点来分辨 int 和 float。

>>> var1 = 314   # 整型
>>> var2 = 3.14  # 浮点型

注意：在Python 3 里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。

可以使用 type() 函数来检测任何值或变量的类型。另外，还可使用 isinstance() 函数判断某个值或变量是否为给定的某个类型。isinstance 和 type 的区别在于： type()不会认为子类是一种父类类型，isinstance()会认为子类是一种父类类型。

>>> type(1)
<class 'int'>
>>> type(1.0)
<class 'float'>
>>>
>>> isinstance(1, int)
True
>>> isinstance(1.0, float)
True

数值运算中，常见的操作符有 +、 -、 、 /、 //、 %、 *，等等。

>>> 5 + 4        # 加法
9
>>> 4.3 - 2     # 减法
2.3
>>> 3 * 7       # 乘法
21
>>> 11 ** 2     # 乘方
121
>>> 11 % 2      # 取余
1

"/ "运算符执行浮点除法。即便分子和分母都是 int，它也返回一个 float 浮点数。

>>> 12 / 2      # 除法，得到一个浮点数
6.0
>>> 11 / 2
5.5

"//" 运算符执行古怪的整数除法。如果结果为正数，其结果为朝小数位取整，而并非四舍五入，请注意这一点。

>>> 11 // 2     # 除法，得到一个整数
5

当整数除以负数，“//”运算符将结果朝着最近的整数“向下”取整，即向负无穷方向取最接近精确值的整数。从数学角度来说，由于 −6 比 −5 要小，因此，−11 // 2 的结果是 -6。

>>> −11 // 2
−6

"//"运算符并非总是返回整数结果。如果分子或者分母是 float，它仍将朝着最近的整数进行四舍五入，但实际返回的值将会是 float 类型。

>>> 11.0 // 2
5.0

如果想实现“向零”取整，即无论运算结果是正还是负，都向零点方向取整，可以使用 “/”运算符，并使用 int() 函数转换为整数。

>>> int(11/-2)
-5
>>> int(-11/2)
-5

如上所见，一些运算符（如：加法、减法）会根据需要把整数强制转换为浮点数。也可自行对数字进行强制转换。

通过调用float() 函数，可以显示地将 int 强制转换为 float。也可以通过调用 int() 将 float 强制转换为 int 。

>>> float(2)
2.0
>>> int(2.0)
2

int() 将进行取整，而不是四舍五入。

>>> int(2.5)
2

对于负数，int() 函数朝着 0 的方法进行取整。它是个真正的取整（截断）函数，而不是 floor（地板）函数。

>>> int(-2.5)
-2

浮点数精确到小数点后 15 位。

>>> 1.12345678901234567890
1.1234567890123457

整数可以任意大。

>>> type(1000000000000000)
<class 'int'>
>>> type(31415926535897932384626433832795028841971)
<class 'int'>

1.3 fractions 分数

Python 并不仅仅局限于整数和浮点数类型。它可以完成你在高中阶段学过、但几乎已经全部忘光的所有古怪数学运算。

分数就是其中一种。当然，分数不能直接声明，使用时需引入 fractions 模块。

为定义一个分数，创建一个 Fraction 对象并传入分子和分母。

>>> import fractions
>>> x = fractions.Fraction(1, 3)
>>> x
Fraction(1, 3)

对分数进行所有的常规数学计算。运算返回一个新的 Fraction 对象。2 * (1/3) = (2/3)

>>> x * 2
Fraction(2, 3)

Fraction 对象将会自动进行约分。(6/4) = (3/2)

>>> fractions.Fraction(6, 4)
Fraction(3, 2)

在杜绝创建以零为分母的分数方面，Python 有着良好的敏感性。

>>> fractions.Fraction(0, 0)
Traceback (most recent call last):File "<stdin>", line 1, in <module>File "fractions.py", line 96, in __new__raise ZeroDivisionError('Fraction(%s, 0)' % numerator)
ZeroDivisionError: Fraction(0, 0)

1.4 Complex 复数类型

在 Python 中可以直接声明复数，是不是让人很惊叹！

复数的完整结构为实数部分+虚数部分。声明复数的两种方式

表达式方式：变量 = 实数 + 虚数

>>> var = 3 + 2j

特定功能：变量 = complex(实数，虚数值)

var = complex(5,3)

复数的实部和虚部默认都是浮点型。

>>> aa=123-12j
>>> print(aa.real)  # 输出实数部分 123.0
123.0
>>> print(aa.imag)  # 输出虚数部分 -12.0
-12.0

2 Booleans 布尔型

布尔型（bool）是整型(int)的子类型。它有两个值：True 和 False，这两个值是 Python 中的常量。

>>> c = True
>>> c
True
>>> isinstance(c,int)
True
>>> isinstance(c,bool)
True
>>>

在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。到 Python3 中，把 True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字相加。

>>> True + True
2
>>> True - False
1
>>> True * False
0
>>> True / False
Traceback (most recent call last):File "<stdin>", line 1, in <module>
ZeroDivisionError: int division or modulo by zero

在某些地方（如 if 语句），Python 所预期的就是一个可计算出布尔类型值的表达式。这些地方称为布尔类型上下文环境。事实上，可在布尔类型上下文环境中使用任何表达式，Python 都将试图判断其真值。

可以在 if 这样的布尔类型上下文环境中使用数值。零值是 false［假］，非零值是 true［真］。

在布尔类型上下文环境中，不同的数据类型对于何值为真、何值为假有着不同的规则。

>>> def is_it_true(anything):
...   if anything:
...     print("yes, it's true")
...   else:
...     print("no, it's false")
...
>>> is_it_true(1)
yes, it's true
>>> is_it_true(-1)
yes, it's true
>>> is_it_true(0)
no, it's false
>>> is_it_true(0.1)
yes, it's true
>>> is_it_true(0.0)
no, it's false
>>> is_it_true("0")
yes, it's true
>>> is_it_true(" ")     # 引号里面是空格
yes, it's true
>>> is_it_true("")      # 引号里面没有内容
yes, it's true
>>> import fractions
>>> is_it_true(fractions.Fraction(1, 2))
yes, it's true
>>> is_it_true(fractions.Fraction(0, 1))
no, it's false

非零浮点数为真； 0.0 为假。请千万小心这一点！如果有轻微的四舍五入偏差，那么 Python 将测试 0.0000000000001 而不是 0 ，并将返回一个 True 值。

对于字符串来说，非空字符串为真（即使是对于字符串“0”以及空格字符串），空字符串为假。

分数也可在布尔类型上下文环境中使用。无论 n 为何值，Fraction(0, n) 为假。所有其它分数为真。

3 String 字符串型

在 Python 的发展过程中，在字符串处理方面，曾经有一个巨大的坑，详情见我的另一篇文章。

3.1 字符串声明

好在 Python 中对这个问题做了修复。在最新的 Python 3 版本中，所有字符串都以Unicode 进行编码。因此，Python3 的字符串默认支持多语言。声明明字符串时可以使用单引号和双引号

>>> a = "apple"
>>> b = 'banana'
>>> print('包含中文的str')
包含中文的str

对于单个字符的编码，Python提供了 ord() 函数获取字符的十进制整数表示，chr() 函数把编码转换为对应的字符：

>>> ord('A')
65
>>> ord('中')
20013
>>> chr(66)
'B'
>>> chr(25991)
'文'

如果知道字符的整数编码，还可以用十六进制写 str，两种写法完全是等价的。

>>> 'u4e2du6587'
'中文'
>>> 'u4e2du6587' == '中文'
True

3.2 索引、切片及循环遍历

字符串和整数、浮点数以及布尔类型都不同。字符串是一个序列（sequence）,即它是一个由其他值组成的有序集合，因此它支持索引、切片及循环遍历。

和其他大多数与语言一样，字符串从 0 开始编号。实际操作中，可以使用方括号为字符串下标，获取字符。

>>> fruit = "banana"
>>> letter= fruit[0]
>>> letter
b

可以使用包括变量和操作符的表达式作为下标。不过，下标必须为整数，否则会出错。

>>> i = 1
>>> fruit[i]
'a'

使用内置的 len 函数，可返回字符串中字符的个数

>>> fruit = 'banana'
>>> len(fruit)
6

字符串可以很方便的进行切片，即获取其中的一个片段，

>>> s = 'Awesome Python'
>>> s[0:7]
'Awesome'

操作符[m:n] 返回字符串从第 m 个字符到第 n 个字符的部分，包含第 m 个，但不包含第 n 个。

如果忽略掉冒号之前的下标，切片会从字符串开头开始；同理，如果忽略掉冒号后面的下标，切片会持续到字符串的结尾。

>>> fruit ='banana'
>>> fruit[:3]
'ban'
>>> fruit[3:]
'ana'

如果前一个下标大于或等于第二个下标，不会出错，但返回空字符串。

>>> fruit[3:3]
''
>>> fruit[3:2]
''

如果冒号前后都没有指定下标，很明显，结果是复制整个字符串.

>>> fruit[:]
'banana'
>>>

使用 for...in 语句可循环遍历字符串

>>> for letter in fruit:
...     print(letter)
...
b
a
n
a
n
a

每次迭代，字符串的下一个字符会赋值给变量 letter，直到没有剩余字符为止。

3.3 格式化

一个很重要的字符串操作就是格式化字符串。我们经常会输出类似'亲爱的xxx你好！你xx月的话费是xx，余额是xx'之类的字符串，而xxx的内容都是根据变量变化的，所以，需要一种简便的格式化字符串的方式。

在Python中，采用的格式化方式和 C 语言是一致的，用 % 实现。

>>> 'Hello, %s' % 'world'
'Hello, world'
>>> 'Hi, %s, you have $%d.' % ('Michael', 1000000)
'Hi, Michael, you have $1000000.'

在字符串内部，%s 表示用字符串替换，%d 表示用整数替换，%f 表示浮点数替换，%x 表示十六进制整数替换。有几个 %? 占位符，后面就跟几个变量或者值，顺序要对应好。如果只有一个 %?，括号可以省略。

>>> num =100
>>> print("%d to hex is %x" % (num, num))
100 to hex is 64
>>> print("%d to hex is %f" % (num, num))
100 to hex is 100.000000

另外，格式化整数和浮点数还可以指定是否补 0 和整数与小数的位数：

>>> print('%2d-%02d' % (3, 1))3-01
>>> print('%.2f' % 3.1415926)
3.14

有些时候，字符串里面的%是一个普通字符怎么办？这个时候就需要转义，用%%来表示一个%：

>>> 'growth rate: %d %%' % 7
'growth rate: 7 %'
format()

另一种格式化字符串的方法是使用字符串的format()方法，它会用传入的参数依次替换字符串内的占位符{0}、{1}。

s1 = '{}, {}'.format(21, 'Windridver')
s2 = '{0}, {1}, {0}'.format('Windrivder', 21)
s3 = '{name}: {age}'.format(age=21, name='Windrivder')

3.4 字符串其他操作

字符串对象还有其他操作函数，以下一并列举。

替换。使用replace()函数，还可以使用正则表达式替换

>>> s = '优雅的Python'
>>>s.replace('Python', 'Java')
'优雅的Java'

查找。find()返回第一次出现的子串的下标，找不到则返回 -1;index()返回第一次出现的子串的下标，不同与find()，查找不到会抛出异常; rfind() 表示从右向左查找，第一次出现的子串的下标；rindex()同理。

>>> s.find('P')          # 返回第一次出现的子串的下标
3
>>> s.find('h', 2)       # 设定下标2开始查找
6
>>> s.find('23333')      # 查找不到返回-1
-1,
>>> s.index('y')         # 返回第一次出现的子串的下标
4,
>>> s.index('23333')     # 不同与find()，查找不到会抛出异常
Traceback (most recent call last):File "<stdin>", line 1, in <module>
ValueError: substring not found

转大小写。 upper()、lower()、swapcase()、capitalize()、istitle()、isupper()、islower()

>>> s.upper()
'优雅的PYTHON'
>>> s.swapcase()    # 大小写互换
'优雅的pYTHON'
>>> s.istitle()     # 检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写。
True
>>> s.islower()     # 检测字符串是否由小写字母组成。
False

移除字符串头尾指定的字符（默认为空格或换行符）或字符序列。包括strip()，lstrip() 和 rstrip()，其中 strip()对字符串头尾进行操作，lstrip()仅对字符串头部进行操作，rstrip()仅对字符串尾部进行操作。

>>> str = "     this is string example....wow!!!     ";
>>> str.strip();
'this is string example....wow!!!'
>>> str.lstrip();
'this is string example....wow!!!     '
>>> str.rstrip();
>>> str.rstrip();
'     this is string example....wow!!!'
>>> str = "88888888this is string example....wow!!!8888888";
>>> str.lstrip('8');
'this is string example....wow!!!8888888'

连接两个字符串。可以使用 + 运算符，但每次操作会重新计算、开辟、释放内存，效率很低。join 操作函数可将序列中的元素以指定的字符连接生成一个新的字符串，操作更便捷。

l = ['2017', '03', '29', '22:00']
s5 = '-'.join(l)            # '2017-03-29-22:00'
s6 = s5.split('-')            # ['2017', '03', '29', '22:00']

还有一些常用的，这里只列出来。

S.endswith()             # 字符串是否以给定字符串结尾
S.startswith()             # 字符串是否以给定字符串开始
S.isalnum()             # 是否全是字母和数字
S.isalpha()             # 是否全是字母
S.isspace()               # 是否全是空白字符
S.center(width, [fillchar])     # 中间对齐
S.ljust(width,[fillchar])     # 左对齐，默认是空格补全
S.rjust(width,[fillchar])     # 右对齐
S.count(substr, [start, [end]])# 计算substr在S中出现的次数
S.splitlines([keepends])     # 按行分割成list，keepends是一个bool值，如果为真每行后而会保留行分割符。

4 Bytes 字节型

由于 Python 的字符串类型是 str，在内存中以 Unicode 表示，一个字符对应若干个字节。如果要在网络上传输，或者保存到磁盘上，就需要把 str 变为以字节为单位的bytes。

4.1 字节声明

Python对 bytes 类型的数据用带 b 前缀的单引号或双引号表示：

>>> by = b'ABC'
>>> s = 'ABC'
>>> type(by)
<class 'bytes'>
>>> type(s)
<class 'str'>

要注意区分 'ABC' 和 b'ABC'，前者是 str，后者虽然内容显示得和前者一样，但 bytes 的每个字符都只占用一个字节。

使用“byte字面值” 语法b''来定义 bytes 对象。byte 字面值里的每个字节可以是 ascii 字符或者是从 x0 0到 xff 编码了的16进制数。

>>> by = b'abcdx65'
>>> by
b'abcde'
>>> type(by)
<class 'bytes'>

4.2 字节常用操作

我们可以通过内置函数 len()来获得 bytes 对象的长度。

>>> len(by)
5

使用 + 操作符可以连接 bytes 对象。操作的结果是一个新的 bytes对象。连接 5 个字节的和 1 个字节的 bytes 对象会返回一个 6 字节的 bytes 对象。

>>> by += b'xff'
>>> by
b'abcdexff'
>>> len(by)
6

和字符串一样，可以使用下标记号来获取 bytes 对象中的单个字节。对字符串做这种操作获得的元素仍为字符串，而对 bytes 对象做这种操作的返回值则为整数。确切地说，是0–255之间的整数。

>>> by[0]
97

bytes对象是不可变的；我们不可以给单个字节赋上新值。

>>> by[0] = 102
Traceback (most recent call last):File "<stdin>", line 1, in <module>
TypeError: 'bytes' object does not support item assignment

如果需要改变某个字节，可以组合使用字符串的切片和连接操作（效果跟字符串是一样的），或者我们也可以将 bytes 对象转换为 bytearray 对象。使用内置函数 bytearray() 来完成从 bytes 对象到可变的 bytearray 对象的转换。

>>> by = b'abcdx65'
>>> barr = bytearray(by)
>>> barr
bytearray(b'abcde')

所有对 bytes 对象的操作也可以用在 bytearray 对象上。

>>> len(barr)
5

有一点不同的就是，我们可以使用下标标记给bytearray对象的某个字节赋值。并且，这个值必须是0–255之间的一个整数。

>>> barr[0] = 102
>>> barr
bytearray(b'fbcde')

虽然在某些情况下，bytes和strings 给人的感觉是“看起来一样”，但两者不能混用。

>>> by = b'd'
>>> s = 'abcde'
>>> by + s                       ①
Traceback (most recent call last):File "<stdin>", line 1, in <module>
TypeError: can't concat bytes to str
>>> s.count(by)                  ②
Traceback (most recent call last):File "<stdin>", line 1, in <module>
TypeError: Can't convert 'bytes' object to str implicitly
>>> s.count(by.decode('ascii'))  ③
1

不能连接bytes对象和字符串，因为它们是两种不同的数据类型。也不允许针对字符串中bytes 对象的出现次数进行计数，因为串里面根本没有 bytes。字符串是一系列的字符序列。也许你是想要先把这些字节序列通过某种编码方式进行解码获得字符串，然后对该字符串进行计数？可以，但是需要显式地指明它。Python 3 不会隐含地将 bytes 转换成字符串，或者进行相反的操作，你必须手动将bytes对象转换成字符串后该串的出现次数。

仔细看上面的例子，你已经注意到 bytes 对象有一个 decode 方法，可以将 bytes 对象转换为字符串。事实上，按一定规则进行编码的字符串与 bytes 对象之间可以互相转换。

4.3 Unicode 字符串和 bytes 之间可互相转换。

以 Unicode 表示的 str 通过 encode()方法可以编码为指定的bytes.

>>> 'ABC'.encode('ascii')
b'ABC'
>>> '中文'.encode('utf-8')
b'xe4xb8xadxe6x96x87'
>>> '中文'.encode('ascii')
Traceback (most recent call last):File "<stdin>", line 1, in <module>
UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)

纯英文的 str 可以用 ASCII 编码为bytes，内容是一样的，含有中文的 str 可以用UTF-8 编码为 bytes。含有中文的 str 无法用 ASCII 编码，因为中文编码的范围超过了 ASCII 编码的范围，Python 会报错。

在 bytes中，无法显示为 ASCII 字符的字节，用x##显示。

反过来，如果我们从网络或磁盘上读取了字节流，那么读到的数据就是 bytes。要把bytes变为str，就需要用decode()方法：

>>> b'ABC'.decode('ascii')
'ABC'
>>> b'xe4xb8xadxe6x96x87'.decode('utf-8')
'中文'

如果 bytes 中包含无法解码的字节，decode()方法会报错

>>> b'xe4xb8xadxff'.decode('utf-8')
Traceback (most recent call last):...
UnicodeDecodeError: 'utf-8' codec can't decode byte 0xff in position 3: invalid start byte

如果bytes中只有一小部分无效的字节，可以传入errors='ignore'忽略错误的字节：

>>> b'xe4xb8xadxff'.decode('utf-8', errors='ignore')
'中'

要计算str包含多少个字符，可以用len()函数：

>>> len('ABC')
3
>>> len('中文')
2

len()函数计算的是 str 的字符数，如果换成 bytes，len()函数就计算字节数：

>>> len(b'ABC')
3
>>> len(b'xe4xb8xadxe6x96x87')
6
>>> len('中文'.encode('utf-8'))
6

可见，1 个中文字符经过 UTF-8 编码后通常会占用 3 个字节，而 1 个英文字符只占用 1 个字节。

在操作字符串时，我们经常遇到 str 和 bytes 的互相转换。为了避免乱码问题，应当始终坚持使用 UTF-8 编码对 str 和 bytes 进行转换。

除了 Unicode 字符串以外，以其他编码方式也可以将字符串与 bytes 进行转换。

>>> a_string = '深入 Python'
>>> len(a_string)
9
>>> by = a_string.encode('utf-8')
>>> by
b'xe6xb7xb1xe5x85xa5 Python'
>>> len(by)
13
>>> by = a_string.encode('gb18030')
>>> by
b'xc9xeexc8xeb Python'
>>> len(by)
11
>>> by = a_string.encode('big5')
>>> by
b'xb2`xa4J Python'
>>> len(by)
11
>>> roundtrip = by.decode('big5')
>>> roundtrip
'深入 Python'
>>> a_string == roundtrip
True

由于编码方式不同，转换成 bytes 之后的结果会不一样，长度也各不相同。当然，这种转换并没有实际意义，除非有特殊业务要求，否则不要使用不一致的编码解码方式。