数据类型
 
整数型：int型，正、负整数
浮点型：float型，由小数和整数构成
字符串：文本的数据类型
布尔型：True或者False
复数：由实部和虚部构成，数据分析中很少用
 可以通过相关函数进行数据类型转换。
 
字符串
 
字符串用str函数或者引号来进行创建
字符串通过[]来进行访问
字符串中的元素是不可变的
字符串的使用
abc='I like python very much'  # 字符串的创建
abc[1]  # 访问第二个字符
abc[2:3]  # 访问第三个字符，注意：在python中，切片区间是左闭右开的
abc*3  # 字符串复制3次
abc[0]='u'  # 会报错
 
 
 

简述
 
Python 中的每个值都有一个数据类型。 
 
在 Python 编程中，一切（万物）皆对象，数据类型实际上是类，变量是这些类的实例（对象）。
 
| 版权声明：一去、二三里，未经博主允许不得转载。
 
数据类型
 
Python 中有各种数据类型，下面列出了一些重要类型：
 
Number（数字）
String（字符串）
List（列表）
Tuple（元组）
Set（集合）
Dictionary（字典）
 
Number（数字）
 
Python 支持三种不同的数字类型：
 
int（整型）
float（浮点型）
complex（复数）
 
注意： Py3.x 去除了 long 类型，现在只有一种整型 - int，表示为长整型。
 
可以使用 type() 函数获取变量或值的类型，使用 isinstance() 函数来检查一个对象是否属于一个特定的类。
 
>>> i = 5  # 整型
>>> type(i)
<class 'int'>
>>> 
>>> f = 2.5  # 浮点型
>>> type(f)
<class 'float'>
>>> 
>>> c = 1+2j  # 复数
>>> type(c)
<class 'complex'>
>>> 
>>> isinstance(c, complex)
True
 
整数可以是任何长度，只受到可用内存的限制。
 
浮点数精确到 15 位小数。
 
复数以 x + yj 的形式写成，其中 x 是实部，y 是虚部。
 
>>> i = 2 ** 500  # 2 的 500 次幂
>>> i
3273390607896141870013189696827599152216642046043064789483291368096133796404674554883270092325904157150886684127560071009217256545885393053328527589376
>>> 
>>> f = 0.12345678901234567890
>>> f
0.12345678901234568  # 值被截断
>>> 
>>> c = 5+6j
>>> c
(5+6j)
 
String（字符串）
 
字符串是 Unicode 字符的序列。
 
可以使用单引号（''）或双引号（""）来表示字符串，多行字符串可以使用三重引号 ''' 或 """ 来表示。
 
>>> s = 'Hello, Python!'
>>> type(s)
<class 'str'>
 
各种表示方式：
 
>>> s = 'Hello, Python!'  # 单引号
>>> s
'Hello, Python!'
>>> 
>>> s = "Hello, World!"  # 双引号
>>> s
'Hello, World!'
>>> 
>>> s = '''Hello,  # 三重单引号
... Python!'''
>>> s
'Hello,\nPython!'
>>> 
>>> s = """  # 三重双引号
... Hello,
... World!
... """
>>> s
'\nHello,\nWorld!\n'
 
字符串可以被索引和截取，截取的语法格式如下：
 
 
 
变量[头下标:尾下标]
 
 
索引值以 0 开始，-1 为从末尾的开始位置。
 
>>> s = "Hello, World!"
>>>
>>> s[4]  # 第五个字符
'o'
>>>
>>> s[7:10]  # 第八个开始到第十个的字符
'Wor'
>>>
>>> s[-4:-1]  # 倒数第四个开始到倒数第一个的字符
'rld'
>>>
>>> s[5] = 'p'  # 生成错误，字符串是不可变的
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
 
加号（+）是字符串的连接符， 星号（*） 表示复制当前字符串，紧跟的数字为复制的次数。
 
>>> s1 = "Hello,"
>>> s2 = " World!"
>>>
>>> s1 + s2  # 连接字符串
'Hello, World!'
>>>
>>> (s1 + s2) * 3  # 复制 3 次字符串
'Hello, World!Hello, World!Hello, World!'
 
List（列表）
 
列表是有序的元素序列，它是 Python 中使用最频繁的数据类型，非常灵活。
 
列表中元素的类型可以不同，支持数字、字符串，甚至可以包含列表（所谓的嵌套）。
 
列表用 [] 标识，内部元素用逗号分隔。
 
>>> l = [1, 5.5, 'Python']
>>> type(l)
<class 'list'>
 
和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。
 
>>> l = [3, 2, 5, 4, 1]
>>> l
[3, 2, 5, 4, 1]  # 有序
>>> 
>>> l[2]  # 第三个元素
5
>>> 
>>> l[0:3] # 从第一个元素到第三个元素
[3, 2, 5]
>>> 
>>> l[3:] # 从第三个元素开始的所有元素
[4, 1]
 
列表是可变的，意思是说，列表中元素的值可以被改变。
 
>>> l = [1, 2, 3]
>>> l[2] = 5  # 将第三个元素 3 变为 5
>>> l
[1, 2, 5]
 
Tuple（元组）
 
元组与列表相同，也是有序序列，唯一的区别是元组是不可变的。
 
元组适用于保护性的数据，通常比列表快，因为它不能动态更改。
 
元组用 () 标识，内部元素用逗号分隔。
 
>>> t = (5, 'Python', 1+2j)
>>> type(t)
<class 'tuple'>
 
元组也可以被索引和截取，但是不能被更改。
 
>>> t = (3, 2, 5, 4, 1)
>>> t
(3, 2, 5, 4, 1)  # 有序
>>> 
>>> t[1]  # 第二个元素
2
>>> 
>>> t[0:2] # 从第一个元素到第二个元素
(3, 2)
>>> 
>>> t[0] = 10  # 生成错误，元组是不可变的
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
 
虽然元组中的元素不可变，但它可以包含可变的对象，例如：List（列表）。
 
构造一个空的或者包含一个元素的元组比较特殊，所以要采用一些额外的语法规则：
 
>>> tup1 = ()  # 空元组
>>> tup2 = (5, )  # 一个元素，需要在元素后添加逗号
 
Set（集合）
 
集合是一个无序不重复元素集。
 
集合用 {} 标识，内部元素用逗号分隔。
 
可以使用大括号 {} 或者 set() 函数创建集合，注意： 要创建一个空集合，必须使用 set() 而不是 {}，因为 {} 用于创建一个空字典。
 
>>> s = {5, 'Python', 1+2j}
>>> type(s)
<class 'set'>
 
既然集合是无序的，那么索引就没有任何意义，也就是说，切片操作符 [] 不起作用。
 
>>> s = {"Java", "Python", "PHP"}
>>> s
{'PHP', 'Python', 'Java'}  # 无序
>>> 
>>> s[1]  # 生成错误，不支持索引
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'set' object does not support indexing
 
不重复，是指集合中相同的元素会被自动过滤掉，只保留一份。
 
>>> s = {"PHP", "Python", "Java", "Python", "PHP"}
>>> s
{'PHP', 'Python', 'Java'}  # 去重
 
除了去重之外，还常用于成员关系的测试。
 
>>> if ('Python' in s) :
...      print('Python 在集合中')
... else :
...      print('Python 不在集合中')
... 
Python 在集合中
 
集合之间也可执行运算，例如：并集、差集、交集。
 
>>> a = set('abcdefg')
>>> b = set('abghijk')
>>> 
>>> a
{'b', 'f', 'e', 'd', 'a', 'c', 'g'}
>>> b
{'b', 'k', 'h', 'i', 'j', 'a', 'g'}
>>> 
>>> a - b  # 差集
{'f', 'c', 'd', 'e'}
>>> 
>>> a | b  # 并集
{'b', 'k', 'f', 'h', 'i', 'e', 'j', 'd', 'a', 'c', 'g'}
>>> 
>>> a & b  # 交集
{'b', 'a', 'g'}
>>> 
>>> a ^ b  # 对称差 - 不同时存在的元素
{'e', 'c', 'k', 'f', 'h', 'i', 'j', 'd'}
 
对称差公式：A Δ B = (A − B) ∪(B − A)。也可表示为两个集合的并集减去它们的交集：A Δ B = (A ∪B) − (A ∩B)。
 
Dictionary（字典）
 
字典是键值对的无序集合。
 
通常在有大量的数据时会使用，在检索数据时字典做了优化，必须知道要检索的 value 所对应的 key。
 
字典用 {} 标识，其中的每个元素都以 key:value 对的形式出现，key 和 value 可以是任何类型。
 
注意： 字典中的 key 必须是唯一的。
 
>>> d = {1:'value', 'key':2}
>>> type(d)
<class 'dict'>
 
可以用 key 来检索相应的 value，但相反则不行。
 
>>> d = {}  # 创建空字典
>>> d['name'] = 'Python'  # 增加新的键/值对
>>> d['site'] = 'www.python.org'
>>> 
>>> d
{'name': 'Python', 'site': 'www.python.org'}
>>> 
>>> d['site']  # 键为 'site' 的值
'www.python.org'
>>> 
>>> d['Python']  # 生成错误，不能用 value 检索 key
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Python'
 
字典有一些内置的函数，例如：keys()、values()、clear() 等。
 
>>> d.keys()  # 所有键
dict_keys(['name', 'site'])
>>> 
>>> d.values()  # 所有值
dict_values(['Python', 'www.python.org'])
>>> 
>>> d.clear()  # 清空字典
>>> d
{}
 
数据类型之间的转换
 
可以使用不同的类型转换函数来转换不同的数据类型，例如：int()、float()、str() 等。
 
从 int 转换为 float：
 
>>> float(5)
5.0
 
从 float 到 int 的转换，值将会被截断（使其接近零）：
 
>>> int(10.8)
10
>>> 
>>> int(-10.8)
-10
 
字符串的转换必须包含兼容的值：
 
>>> float('2.5')
2.5
>>> 
>>> str(25)
'25'
>>> 
>>> int('str')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'str'
 
甚至可以将一个序列转换为另一个序列：
 
>>> set([1, 2, 3])
{1, 2, 3}
>>> 
>>> tuple({4, 5, 6})
(4, 5, 6)
>>> 
>>> list('hello')
['h', 'e', 'l', 'l', 'o']
 
要转换为字典，每个元素必须是一对：
 
>>> dict([[1, 'value'], ['key', 2]])
{1: 'value', 'key': 2}

1. 数据类型分类
 
python大约有以下8种数据类型，分别是：
 
Number（数字）
String（字符串）
List（列表）
Tuple（元组）
Sets（集合）
Dictionary（字典）
None（空类型）
Object（对象类型）
 
（1）Number（数字）类型：
 
 Python3 中支持 int、float、bool、complex（复数），在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
 
Python可以同时为多个变量赋值，如a, b = 1, 2。
一个变量可以通过赋值指向不同类型的对象。
数值的除法（/）总是返回一个浮点数，要获取整数使用//操作符。
在混合计算时，Python会把整型转换成为浮点数。
 
（2）String（字符串）类型：
 
 Python中的字符串用单引号(‘)或双引号(“)括起来，同时使用反斜杠(\)转义特殊字符。
 
反斜杠可以用来转义，使用r可以让反斜杠不发生转义，如r’\tbc’就显示成’\tbc’而不会解析\t为制表符。
字符串可以用+运算符连接在一起（和java一样，php用.运算符），用*运算符重复。
Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。如：
 
str = 'abcdef'
s1 = str[2] # s1值为'c'
s2 = str[-2] # s2值为'e'
Python中的字符串不能改变，即`str[2] = ‘g’是错的，不能改变str的组成字符。
Python中也提供了许多字符串操作方法，如split()截取字符串，encode()，decode()编码解码方法等等。
Python中没有java／c／c＋＋中的字符char类型，只包含一个字符的字符串就是Python中的字符类型。
字符串的截取可以用split()方法，也可以通过下面的语法进行截取：
 
str = 'abcdef'
s = str[:3] # 值为'abc'
s = str[1:3] # 值为'bc'
s = str[3] # 值为'd'
s = str[1:6:2] # 值为'bdf'
s = str[3:] # 值为'def'
 
（3）List（列表）类型：
 
 Python中的List的学习其实可以类比java的List的学习。Python中的列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列（所谓嵌套）。列表是写在方括号([])之间、用逗号分隔开的元素列表。和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。
 
创建空列表(使用list()或[])：
 
l = list() # 也可以通过［］创建空列表，即list = []
创建普通列表(使用[])
 
l = ['a',10,'b',1 + 3j,5.5]
List提供了许多操作方法，如append(),pop(),remove(),sort(),extend(),count(),index(),insert()等等
 
注意：
 
List写在方括号之间，元素用逗号隔开，可以包含重复元素（和java一样）。
和字符串一样，list可以被索引和切片，即取元素和截取。
List可以使用+操作符进行拼接，也可以使用＊进行重复操作，如：
 
l = ['a',10,'b',1 + 3j,5.5]
l2 = l + l # l2的值为：['a', 10, 'b', (1+3j), 5.5, 'a', 10, 'b', (1+3j), 5.5]
l3 ＝ l * 2 # l3的值为：['a', 10, 'b', (1+3j), 5.5, 'a', 10, 'b', (1+3j), 5.5]
List中的元素是可以改变的。
 
（4）Tuple（元组）类型：
 
 元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号(())里，元素之间用逗号隔开。元组中的元素类型也可以不相同,也可以包含相同的元素。
 
创建空列表(使用[])：
 
t =() 
创建普通列表(使用())
 
t = ('a',10,'b',1 + 3j,5.5)
 
说明，读操作基本和List列表一样，需要注意的是Tuple中的元素是不能改的（只读），而List中的元素是可以改的，所以Tuple自然也就没了insert(),append(),pop(),reverse(),remove(),extend(),sort()等可能改变元组元素结构的方法了,也不能通过tuple[index] = value赋值。
 
注意：
 
虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。
可以将tuple当成一个只读的List。
构造空元组可以用()，需要注意的是tuple没有tuple()方法来构建空元组，同时需要注意只包含一个元素的元组的创建规则：
 
nullTuple = () # 构建空元组
t = (10,) # 一个元素的元组，一定要在元素后添加逗号，否则表示一个整数
 
（5）Set（集合）类型：
 
 集合（set）是一个无序不重复元素的序列。基本功能是进行成员关系测试和删除重复元素。可以使用大括号({})或者 set()函数创建集合。
 
创建空集合(使用set())：
 
s = set()
创建普通集合(使用{})
 
s = {'a',10,'b',1 + 3j,5.5}
进行成员测试（使用in关键字）
 
s = {'a',10,'b',1 + 3j,5.5}
if( 'b' in s):
    print('b在集合中')
else:
    print('b不在集合中')
进行集合运算
 
s1 = {'a','b','c'}
s2 = {'b','c','e'}
print(s1 - s2)     # a和b的差集，结果为｛'b'｝
print(s1 | s2)     # a和b的并集，结果为｛'a','b','c','e'｝
print(s1 & s2)     # a和b的交集，结果为｛'b','c'｝
print(s1 ^ s2)     # a和b中不同时存在的元素，结果为｛'a','e'｝
 
（6）Dictionary（字典）类型：
 
 字典（dictionary）是Python中另一个非常有用的内置数据类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。字典是一种映射类型，字典用”{ }”标识，它是一个无序的键(key) : 值(value)对集合。键(key)必须使用不可变类型。
 
在同一个字典中，键(key)必须是唯一的。可以类比java的Map来学习。
 
创建空字典(使用dict()或{})：
 
d = dict() # 创建空字典，也可以用{}创建，如d = {}
创建普通字典(使用{})
 
d = {1:'a','a':10,'c':'b',5.6:1 + 3j,100:5.5}
字典的内置函数
 
  
keys()：返回字典中所有的键构成的一个序列
values()：返回字典中所有的值构成的一个序列
clear()：清空字典
items()：返回由（key，value）组成的一个序列，可用于同时遍历出字典的键和值
pop()：
popitem()：
update()：
copy：
…
 
注意：
 
字典是一种映射类型，它的元素是键值对 ,类似java的Map。
字典的键必须为不可变类型，且不能重复。
创建空字典使用 { }。
 
（7）None（空类型）：
 
 有点类似java中的null，c／c＋＋中的NULL，但None类型不能用于计算，因为它不像True,Flase一样代表一个数字。
 
（8）Object（对象类型）：
 
 Python中的所有数据类型都是Object类型，还可以自己自定义类型，也就是创建类。
 
2. 类型转换
 
 由于Python的类型检查没那么严格，也没有变量类型声明，同一个变量可以指向不同的数据类型，我们只管给变量赋值然后使用就行了，但，有时候，我们需要对数据内置的类型进行转换，数据类型的转换，Python给我们提供了相应的函数，如：int(),str(),float(),set(),list(),tuple(),dict()等等，使用都很简单，可以参考Python手册。
 
一点技巧：可以使用内置的type()函数得到变量的类型，这对于变量类型的把握很有帮助
 
总结：
 
 使用标识符名名会发生一些意向不到的错误，尽量不要用标识符命名，因为Python的灵活性会导致一些意想不到的错误，如下图所示：
 
 
 这个错误的原因很简单，因为list这个标识符在Python中和int,str,float一样代表一种类型，这里list ＝ [‘a’,’b’,’c’]改变了list这个关键字的含义。这里我猜想的原因是list关键字是一个指向type类型的对象变量，这时如果我们使用list()者会调用list指向的对象的__call__方法，然后__call__中给我们返回了一个List。而如果我们给list这个变量赋别的值后，list不再指向原来的那个type类型对象了，也就不会调用那个对象的__call__方法返回一个列表了，这里由于我没看过源码，只是个人猜测，等以后再去看Python的源码来补充了。

Python数据类型有哪些，哪些是可变类型，哪些是不可变类型？
 
类型：
 
整数int 字符串str 浮点数float 布尔型bool 列表list 字典dict 集合set 元组tuple
 
可变类型：就是这个数据类型的值在不改变这一块内存空间，而去改变这个数据类型的值。
 
1.列表
 2.字典
 3.集合
 
不可变类型：当改变值得时候，会申请一块新的内存空间，不再是原来的那一块内存空间了。
 
整数
字符串
浮点数
布尔型
元组