一、简介

Python基本数据类型一般分为：数字、字符串、列表、元组、字典、集合这六种基本数据类型。

其中数字又包含整型(整型又包括标准整型、长整型(Python2.7及之前版本有)）、浮点型、复数类型、布尔型(布尔型就是只有两个值的整型)、这几种数字类型。列表、元组、字符串都是序列。

二、各种数据类型详解


2.1、数字

数字类型是不可更改的对象。对变量改变数字值就是生成/创建新的对象。Python支持多种数字类型：

整型(标准整型和长整型(Python2.7及之前的有这种类型))、布尔型、双精度浮点型、十进制浮点型、复数。

  • 标准整型int，标准整型，在大多数32位机器上标准整型取值范围是-2^31到2^31-1，也就是-2147483648~2147483647，如果在64位机器使用64位编译器，那么这个系统的标准整型将是64位。
    Python2.7代码：
• >>> 2**63-1
• 9223372036854775807L
• >>> -2**63
• -9223372036854775808L
• >>> 9223372036854775807
• 9223372036854775807
• >>> 9223372036854775808
• 9223372036854775808L
• >>> -9223372036854775808
• -9223372036854775808
• >>> -9223372036854775809
• -9223372036854775809L
  • 长整型long，长整型包含的最大值数字大小由内存决定。长整型及数字末尾加个L(大写小写均可)。Python3中已经取消了标准整型和长整型的区分，都是整型。Python2.7代码：
• >>> a = 123L
• >>> type(a)
• <type 'long'>
• >>> a
• 123L

Python3.6代码：

>>> a = 111111111111111111111111111111
>>> type(a)
<class 'int'>
>>> a
111111111111111111111111111111
  • 布尔型bool，从Python2.3开始Python中添加了布尔类型。布尔类型有两种True和False。对于没有__nozero__方法的对象默认是True。对于值为0的数字、空集（空列表、空元组、空字典等）在Python中的布尔类型中都是False。
• >>> bool(1)
• True
• >>> bool('a')
• True
• >>> bool(0)
• False
• >>> bool('')
• False
  • 浮点型float，每个浮点型占8个字节（64位），完全遵守IEEE754号规范（52M/11E/1S）,其中52个位用于表示底，11个位用于表示指数（可表示的范围大约是±10**308.25），剩下的一个位表示符号。这看上去相当完美，然而，实际精度依赖于机器架构和创建Python解释器的编译器。
    浮点型值通常都有一个小数点和一个可选的后缀e（大写或小写，表示科学计数法）。在e和指数之间可以用正（+）或负（-）表示指数的正负（正数的话可以省略符号）。
    以上是Python核心编程的对浮点型(双精度浮点型)的说明。经过Python实测浮点型默认长度是24字节如果超出这个范围会自动
    以下时Python3.6测试过程：
• >>> import sys
• >>> a = 1.1
• >>> sys.getsizeof(a)
• 24
• >>> a = 4.4e25
• >>> type(a)
• <class 'float'>
• >>> a = 10**308.25
• >>> a
• 1.7782794100389228e+308
• >>> sys.getsizeof(a)
• 24
• >>> a = 10**308.25+1
• >>> sys.getsizeof(a)
• 24>>> a = float(10)
• >>> a
• 10.0
• >>> type(a)
• <class 'float'>
  • 复数类型complex，在复数中虚数不能单独存在，它们总是和一个值为0.0的实数部分一起来构成一个复数。 复数由实数部分和虚数部分构成。 表示虚数的语法：real+imagj。 实数部分和虚数部分都是浮点型。 虚数部分必须有后缀j或J。
• >>> a = 1+1j
• >>> a
• (1+1j)
• >>> type(a)
• <class 'complex'>
• >>> import sys
• >>> sys.getsizeof(a)
• 32
• >>> a = complex(2.2)
• >>> a
• (2.2+0j)
• >>> sys.getsizeof(a)
• 32


2.2、字符串

字符串(string)是不可变类型，就是说改变一个字符串的元素需要新建一个新的字符串。字符串是由独立的字符组成的，并且这些字符可以通过切片操作顺序地访问。Python里面通过在引号间包含字符的方式创建字符串，单引号和双引号的作用是相同的。
Python用“原始字符串”操作符来创建直接量字符串，所以再做区分就没什么意义了。其他的语言，比如C语言里面用单引号来标示字符，双引号标示字符串，而在Python里面没有字符这个类型。这可能是双引号和单引号在Python里面被视作一样的另一个原因。
Python实际上有三类字符串。通常意义的字符串（str） 和Unicode字符串（unicode） 实际上都是抽象类basestring的子类。这个basestring是不能实例化的。

以下时Python3.6代码：

>>> a = 'abc'
>>> a
'abc'
>>> a = "cba"
>>> a
'cba'
>>> type(a)
<class 'str'>
>>> import sys
>>> sys.getsizeof(a)
52
>>> len(a)
3
>>> a[1]
'b'
>>> del a
>>> a
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined

2.3、列表

列表(list)像字符串类型一样，列表类型也是序列式的数据类型。字符串只能由字符组成，而且是不可变的（不能单独改变它的某个值），而列表则是能保留任意数目的Python对象的灵活的容器。
列表不仅可以包含Python的标准类型，而且可以用用户定义的对象作为自己的元素。列表可以包含不同类型的对象，而且要比C或者Python自己的数组类型（包含在array扩展包中）都要灵活，因为数组类型所有的元素只能是一种类型。列表可以执行pop,sort、reverse等操作。列表也可以添加或者减少元素，还可以跟其他的列表结合或者把一个列表分成几个。可以对单独一个元素或者多个元素执行insert、update或remove操作。

下面是Python3.6代码：

>>> li = [1,'12','abc',['a','123',1]]
>>> li
[1, '12', 'abc', ['a', '123', 1]]
>>> type(li)
<class 'list'>
>>> a = list('abcde')
>>> a
['a', 'b', 'c', 'd', 'e']
>>> a.pop()
'e'
>>> a
['a', 'b', 'c', 'd']
>>> a.reverse()
>>> a
['d', 'c', 'b', 'a']


2.4、元组

元组类型在很多操作上都跟列表一样，许多用在列表上的例子在元组上照样能跑，我们有一节内容专门讲解元组类型。它们的主要不同在于元组是不可变的，或者说是只读的，所以那些用于更新列表的操作，比如用切片操作来更新一部分元素的操作，就不能用于元组类型。

以下是Python3.6代码：

CPython>>> a = ('a','123',['a',123])
>>> a
('a', '123', ['a', 123])
>>> type(a)
<class 'tuple'>
>>> tu = tuple('abcde')
>>> tu
('a', 'b', 'c', 'd', 'e')

2.5、字典

字典是Python语言中唯一的映射类型。映射类型对象里哈希值（键，key） 和指向的对象
（值。value） 是一对多的关系。一个字典对象是可变的，它是一个容器类型，能存储任意个数
的Python对象，其中也包括其他容器类型。字典类型和序列类型容器类（列表、元组） 的区
别是存储和访问数据的方式不同。序列类型只用数字类型的键（从序列的开始起按数值顺序
索引） 。映射类型可以用其他对象类型做键，一般最常见的是用字符串做键。和序列类型的
键不同，映像类型的键直接或间接地和存储的数据值相关联。但因为在映射类型中，我们不
再用“序列化排序”的键，所以映像类型中的数据是无序排列的
映射类型不要求用数字值做索引以从一个容器中
获取对应的数据项。你可以用键直接“映射”到值，这就是为什么叫映射类型（“mapping
type”） 的原因。映射类型通常被称做哈希表，是因为字典对象就是哈希类型的。字典是
Python中最强大的数据类型之一。

字典常见的操作有：字典创建、字典赋值、字典中值的访问、字典更新、字典元素删除等操作。

C>>> d1 = {}
>>> type(d1)
<class 'dict'>
>>> d1['name']='xiaohong'
>>> d1
{'name': 'xiaohong'}
>>> d1['name']
'xiaohong'
>>> del d1['name']
>>> d1
{}Python

2.6、集合

集合最早出现在Python2.3版本中，通过集合模块来创建，并通过ImmutableSet类和Set类进行访问。
集合有两种不同的类型，可变集合（set）和不可变集合（frozenset）。可变集合，你可以添加和删除元素，对不可变集合则不允许这样做。请注意，可变集合不是可哈希的，因此既不能用做字典的键也不能做其他集合中的元素。不可变集合则正好相反，即，他们有哈希值，能被用做字典的键或是作为集合中的一个成员。集合对象是一组无序排列的可哈希的值。
集合支持用in和not in操作符检查成员，由len()内建函数得到集合的基数（大小） ，用for循环迭代集合的成员。但是因为集合本身是无序的，你不可以为集合创建索引或执行切片（slice） 操作，也没有键可用来获取集合中元素的值。

以下时Python3.6代码：

>>> s1 = set('a')
>>> s1
{'a'}
>>> type(s1)
<class 'set'>
>>> 'a' in s1
True
>>> s1.add('cd')
>>> s1
{'cd', 'a'}
>>> s1.remove('a')
>>> s1
{'cd'}
>>> del s1
>>> s1 = set(['abc'])
>>> s1
{'abc'}
>>> s1 = set('abc')
>>> s1
{'c', 'a', 'b'}
>>> s2 = frozenset(s1)
>>> s2
frozenset({'c', 'a', 'b'})
>>> type(s2)
<class 'frozenset'>