Python提供多种数据类型来存放数据项集合，主要包括序列（列表list和元组tuple），映射（如字典dict），集合（set），下面对这几种数据类型分别介绍。
 
 
 Python中list，tuple，dict和set的主要区别：
 
 一句话来概括四种数据类型的区别是：tuple是一个不可改变的list，set是一个没有Value的dict，list和set的数据是可变的，tuple和dict的数据是不可变的！
 
 list和set的数据可变的，tuple和dict的数据是不可变的。list是最自由的，可以使用索引、切片，可以进行计算和修改；tuple是不自由的，数据不能更改，但是和list一样具有序列，可以用索引和切片；dict是半自由的，自由体现在键值对的无序，可以通过key去索引value的值，不自由体现在数据操作只能通过key来实现，键值对是不可变类型；set是半自由的，自由体现在它通过list传值给它，数据类型是可变的，还可以改变list中的值，数据集是无序的，不重复的，可以进行计算，不自由体现在无法使用索引和切片准确定位。
 
 
 
 
 
 1 .list
 
 list是一个使用方括号括起来的有序元素集合;
 
 List 可以作为以 0 下标开始的数组,任何一个非空 list 的第一个元素总是 L[0],负数索引从 list 的尾部开始向前计数来存取元素。任何一个非空的 list 最后一个元素总是 L[-1];
 
 有分片功能，两个list可以相加；
 
 append 向 list 的末尾追加单个元素；
 
 insert 将单个元素插入到 list 中； 
 
 extend 用来连接 list，使用一个 list 参数进行调用；
 
 append 接受一个参数, 这个参数可以是任何数据类型, 并且简单地追加到 list 的尾部；
 
 index 在 list 中查找一个值的首次出现并返回索引值；
 
 要测试一个值是否在 list 内, 使用 in, 如果值存在, 它返回 True, 否则返为 False ；
 
 remove 从 list 中删除一个值的首次出现；
 
 pop 可以删除 list 的最后一个元素, 然后返回删除元素的值，用索引删除制定位置的值；
 
  
 
 2.tuple
 
 tuple是不可变的list，创建了一个tuple就不能以任何方式改变它；
 
 定义tuple是将整个元素集是用小括号括起来，是有序集合；
 
 tuple的索引与list一样从0开始,所以一个非空的tuple的第一个元素总是t[0]；
 
 负数索引与 list 一样从 tuple 的尾部开始计数；
 
 与 list 一样分片 (slice) 也可以使用。分割一个 tuple 时, 会得到一个新的 tuple；
 
 没有 append、extend、remove或pop方法以及index方法；
 
 可以使用in来查看一个元素是否存在于tuple 中。
 
  
 
 3.dict
 
 dict定义了键和值之间的一一对应关系，每个元素都是一个key-value对；
 
 整个元素集合用大括号括起来，有序集合；
 
 可以通过 key 得到value, 但不能通过vaule获取 key；
 
 在一个 dict中不能有重复的 key, 并且 key 是大小写敏感的；
 
 键可以是数字、字符串或者是元组等不可变类型；
 
 用del使用key可以删除dict中的独立元素； 
 
 用clear可以清除dict中的所有元素。
 
 
 
 
 4.set
 
 set是建立一系列无序的，不重复的元素；
 
 创建set的方式是调用set()并传入一个list，list的元素将作为set的元素；
 
 set和dict的唯一区别仅在于没有存储对应的value。
 
 
 
 
 
 
 下面详细介绍python的多种数据类型的使用方法：
 
 一 序列
 
 1.列表list
 
 列表是一种有序的集合，相对于元组和字符串的不同是它其中的元素可变，可以随时添加和删除其中的元素。
 
 （1） 创建list
 
 在命令行中测试，如下：
 
 
 

  
 
 
 
>>> L1 = [1,2,3]
>>> L1
[1, 2, 3]
>>> L2 = ['abc']
>>> L2
['abc']
>>> L3 = ["a","b","c"]
>>> L3
['a', 'b', 'c']
 
 

  
 
 
 
 注意，字符串的一定要加引号。
 
 通过list对字符串创建列表非常有效，比如：
 
 
 
>>> L = list("Python")
>>> L
['P', 'y', 't', 'h', 'o', 'n']
 
 
 （2)访问list
 
 根据索引来访问，注意不能越界，这一点跟数组特别像：
 
 
 
>>> L[0]
'P'
>>> L[-1]
'n'
 
 
 （3）添加新元素
 
 用append（）方法，把新元素追加到list的末尾；insert（）可以将一个新元素添加到特定的位置。
 
 （4） 删除元素
 
 删除元素可以采用pop（）方法，执行L.pop()删除list的最后一个元素，如果是特定位置的话可以采用pop（2），2表示的是位置。
 
 （5）替换
 
 替换很简单，直接索引就可以。
 
 （6）打印
 
 
 
>>> L = ['a','b','c']
>>> for i in L:
    print(i)   
a
b
c
 
 
  
 
 2. tuple
 
 (1)创建
 
 与list所不同的是，tuple一般采用（）括起来，命令行中测试，如下：
 
 
 

  
 
 
 
T= 1,2,3
>>> T
(1, 2, 3)
>>> T = (1,2,3)
>>> T
(1, 2, 3)
>>> T = "abc"
>>> T
'abc'
 
 

  
 
 
 
 创建空元组：T = ()
 
 定义一个元素的元组：
 
 
 
>>> T = (1)
>>> T
1
 
 
 这样运行了结果是对的，看起来也没错，但是这种定义其实并不正确，这种定义的不是tupel，而是1这个数，这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。所以定义含一个元素的元组时必须加一个逗号，如下：
 
 
 
>>> T = (1,)
>>> T
(1,)
 
 
 （2）访问
 
 直接索引就好，如下：
 
 
 
>>> T =(1,2,3)
>>> T[1]
2
 
 
 （3）更改
 
 上述定义的tuple是不变的，但是我们可以在tuple中定义list对其进行修改：
 
 
 
>>> T = (1,2,['a','b'])
>>> T[2][0]
'a'
>>> T[2][0] = 'c'
>>> T
(1, 2, ['c', 'b'])
 
 
 在tuple中，虽然元素不可以修改，但是我们可以对其进行连接组合：
 
 
 
>>> T1 = [1,2,3]
>>> T2 = [4,5,6]
>>> T3 = T1 + T2
>>> T3
[1, 2, 3, 4, 5, 6]
 
 
  
 
 3.字符串
 
 （1）创建
 
 
 
>>> str = "Hello Python"
>>> str
'Hello Python'
 
 
 （2）访问
 
 
 
>>> str[0]

'H'
 
 
 （3）相加
 
 
 
>>>str = "hello "
>>>str = "Python"
>>> str3 = str1 + str2
>>> str3

'Hello Python'
 
 
  
 
 4.通用的序列操作方法
 
 （1）索引
 
 在访问序列元素中用到，如下：
 
 
 

  
 
 
 
>>> L = ['a','b','c']
>>> L[1]

'b'

>>> T = (1,2,3)
>>> T[0]

1

>>> str = "Python"
>>> str[4]

'o'
 
 

  
 
 
 
 （2）分片
 
 分片用来访问一定范围内的元素，分片通常通过冒号相隔的两个索引来实现，常见的有如下几种：
 
 
 

  
 
 
 
>>> a = list(range(10))
>>> a

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> b = a[1:5]
>>> b

[1, 2, 3, 4]
>>> c = a[-3:-1]
>>> c

[7, 8]
>>> d = a[1:10:2]
>>> d

[1, 3, 5, 7, 9]
 
 

  
 
 
 
  
 
 二 映射（字典）
 
 映射中的每个元素都有一个专业的名字，叫做键。字典是Python中唯一内建的映射类型，下来我们对其进行详细介绍：
 
 （1）键类型
 
 字典（dict）是一个存放无序的键值映射（key/value）类型数据的容器字典的键可以是数
 
 字、字符串或者是元组，键必须唯一。在Python中，数字、字符串和元组都被设计成不可变类型，而常见的列表以及集合（set）都是可变的，所以列表和集合不能作为字典的键。键可以为任何不可变类型，这正是Python中的字典最强大的地方。
 
 （2）创建
 
 
 

  
 
 
 
>>> d = {}
>>> d[1] = 1
>>> d

{1: 1}
>>> d['cat'] = 'Lucy'
>>> d

{1: 1, 'cat': 'Lucy'}
 
 

  
 
 
 
 （3）查找
 
 dict是通过key来查找value，表示的是意义对应的关系，可以通过d[key]的方式来访问dict：
 
 
 
>>> d['cat']

'Lucy'
 
 
 （4）遍历
 
 
 
>>> d = {}
>>> d['cat'] = 'Lucy'
>>> d['dog'] = 'Ben'
>>> for key in d:

    print(key + ":",d[key])
 
 
 结果
 
 cat: Lucy
 
 dog: Ben
 
 （5）优缺点
 
 dict的第一个特点是查找速度快，而且查找的速度与元素的个数无关，而list的查找速度是随着元素的增加而逐渐下降的；第二个特点是存储的key-value序对是没有顺序的；第三个特点是作为key得到元素是不可变的，所以list不能作为key。
 
 dict的缺点是占用内存大，还会浪费很多内容。
 
 
 
 三 集合（set）
 
 dict是建立了一系列的映射关系，而set是建立一系列无序的，不重复的元素。
 
 （1）创建
 
 创建set的方式是调用set()并传入一个list，list的元素将作为set的元素。
 
 
 
>>> S = set([1,2,3])
>>> S

{1, 2, 3}
 
 
 重复元素在Set中自动过滤，如：
 
 
 
>>> S = set([1,1,2,3,4,5,4])
>>> S

{1, 2, 3, 4, 5}
 
 
 （2）添加
 
 add()添加，有重复元素可以添加，但不会有效果：
 
 
 

  
 
 
 
>>> S.add(4)
>>> S

{1, 2, 3, 4, 5}

>>> S.add(9)
>>> S

{1, 2, 3, 4, 5, 9}
 
 

  
 
 
 
 （3）删除
 
 
 
>>> S.remove(9)
>>> S

{1, 2, 3, 4, 5}
 
 
 （4）交集，并集
 
 set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集：
 
 
 

  
 
 
 
>>> S1 = set([1,2])
>>> S2 = set([2,3])
>>> S1&S2

{2}
>>> S1|S2

{1, 2, 3}
 
 

  
 
 
 
 set和dict的唯一区别仅在于没有存储对应的value，但是，set的原理和dict一样，所以，同样不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证set内部“不会有重复元素”
 

一、列表：
 
1.列表的定义：
 
可以存储多个可以重复的有顺序的数据！
 
2.列表的声明：
 
列表名称 = list（）#创建了一个空列表
 列表名称 = [ ] #创建了一个空列表
 
二、元组：
 
1.元组的定义：
 
tuple，可以存放一组有顺序的可以重复的不可改变的数据！（有顺序 可重复 但不可改变 且不能增加或者修改，，只可以删除和查询 ！！）
 就是一种简化的列表
 
2.元组的声明：
 
t1 = tuple() 声明空元组
 t2 = () 声明空元组
 t3 = (1,2,3,4,5) 声明包含元素的元组
 t4 = (“h”) t4 = (“h”,) 如果只有一个元素，添加一个逗号分隔
 t5 = (1) t5 = (1,) 如果只有一个元素，添加一个逗号分隔
 
三、 集合：
 
1.集合的定义：
 
通过哈希(hash)算法在一个容器中存放多个没有顺序的不可以重复的数据 通过hash算法让添加的数据不重复[剔重]！
 （ 无顺序，不重复 可改变！）
 
2.集合的声明：
 
s1 = set() <class ‘set’>
 s2 = {“a”} <class ‘set’>
 
四、字典：
 
1.字典的定义：
 
可以存储多个key:value 键值对数据的组合数据类型
 
2.字典的声明：
 
d1 = dict() # 空字典
 d2 = {} # 空字典

变量用来存储数据，那么大家有没有想过，我们应该让变量占用多大空间，保存什么样的数据呢?在讲解变量的类型之前，我们先来看一个生活中的例子，例如，我们要运送一台电脑，大卡车和小轿车都可以完成，但是，如果使用大卡车运送一台电脑，显然有点小题大做，浪费了大卡车的空间，如图1所示。
 
 图一：卡车和轿车运输一台电脑
 
同理，如果使用变量存储数据时，为了更充分利用内存空间，我们可以为变量指定不同的数据类型。Python中常见的数据类型如图2所示
 
 图二：Python变量数据类型
 
图二中罗列了Python中常见的数据类型，下面对这些数据类型进行一个简单介绍
 
(1)数字类型
 
Python中的数字类型包含整型、浮点型和复数类型。示例代码如下：
 整 型：0101 83 -239 0x80 299384938832
 浮点型：3.1415 4.2E-10 -2.34E-19
 复数类型：3.12+1.23j -1.23-98j
 
(2)布尔类型
 
布尔类型是特殊的整型，它的值只有两个，分别是True和False。如果将布尔值进行数值运算，True会被当作整型1，False会被当作整型0。
 
(3)字符串类型
 
Python 中的字符串被定义为一个字符集合，它被引号所包含，引号可以是单引号、双引号或者三引号(三个连续的单引号或者双引号)。字符串具有索引规则，第1个字符的索引是0，第2个字符的索引是1，以此类推。下面是字符串的示例代码：
 
string_one = 'Python'
string_two = "Python"
string_three = '''Python'''
 
(4)列表和元组类型
 
我们可以将列表和元组当作是普通的“数组”，它们可以保存任意数量的任意类型的 值，这些值称作元素。列表中的元素使用中括号[]包含，元素的个数和值是可以随意修改的。而元组中的元素使用小括号()包含，元素不可以被修改。下面看一下列表和元组的表示方式。
 
list_name = [1, 2, 'hello']          # 这是一个列表
tuple_name= (1, 2, 'hello')          # 这是一个元组
 
(5)字典类型
 
字典是Python中的映射数据类型，由键-值对组成。字典可以存储不同类型的元素，元素使用大括号{}来包含。通常情况下，字典的键会以字符串或者数值的形式来表示，而值可以是任意类型。示例代码如下：
 dict_name = {“name”:“zhangsan”, “age”:18} # 这是一个字典
 
上述代码中，变量dict_name存储的是一个字典类型，该字典存储了两个元素，第1个元素的键为name，值为zhangsan;第2个元素的键为age，值为18。
 
如果希望查看变量存储的数据类型，可以使用“type(变量的名字)”来实现。示例代码如下：
 
>>> number = 5.2
>>> type(number)             # 使用type函数查看存储的数据类型
 
上述代码中，变量number存储的值为5.2，系统会自动根据数值判断number变量存储的数据类型为float。因此，当使用type函数查看变量number存储的数据类型时，结果为float。
 -END-

摘要：
 
python中，一共有四种组合数据类型，他们分别是列表（list），元组（tuple），集合（set），字典（dict）。而这些数据类型分别都有什么作用？他们有哪些共同点，又有哪些不同呢？接下来我们就一起看一下。
 
1.列表（list）
 
列表可以包容多种类型数据，不管是字符串（str）还是数字（int，float）还是布尔（bool），都可以放进列表中，成为我们可以随时更改查阅以及调用的数据组合。
 
在python中，声明一个列表，仅需要
 
list = []
#声明一个空列表
a = list(1,2,3,4,5)
#也是声明一个列表
 
同时我们也会对列表进行一些增删查改操作
 
#首先声明一个列表
a = list(1,2,3,4)
#增加操作
list.append()#在末尾增加一个数据
list.insert()#在任意位置插入一个数据，其后数据向后移一位
list.extend()#添加一组数据，例如添加一个列表到另外一个列表
#删除操作
list.pop(0)#弹出某一位置一个数据
list.remove()#删除列表内的一个数据，需要知道数据名称
del list[2]#删除某一位置的数据
#查询操作
list.count()#可以查询列表中某一数据出现的次数
list.index()#可以返回列表的索引值
#修改操作
list.sort()#可以对列表中数据进行排序，前提是数据类型必须相同，数字数据默认为自然数顺序排序
list.reverse()#可以使列表中的数据翻转
#其它操作，外部函数
len(list)#返回列表数据个数
max(list)#求列表最大值
min(list)#最小值
sorted(list)#外部函数对列表排序
 
2.元组（tuple）
 
元组也可以存放多种类型的数据，但是，他一但被声明出来以后就无法更改元组里面的内容了，所以可以理解元组是特殊的列表。
 
首先我们要声明一个元组
 
#声明一个空元组
t1 = tuple()
t1 = ()
 
然后就可以对元组进行一些操作，由于元组内数据一但声明就无法更改，所以增加，修改操作就没办法使用了，而删除操作就只能删除元组本身了。
 
tuple.count()
#查询某一元素在元组中出现的次数
tuple.index
#返回元素的索引值
 
3.集合（set）
 
通过哈希(hash)算法在一个容器中存放多个没有顺序的不可以重复的数据，集合与数学上的集合差不多，要点是没有顺序的不可重复的数据。
 
首先还是，先声明一个集合
 
#声明一个集合
s1 = set()    <class ‘set’>

s2 = {“a”}    <class ‘set’>
#切记不可以
s3 = {}       <class “dict”>
 
之后就是对集合的一些数据操作
 
set.add()#集合中添加数据
set.pop()#随机删除集合中的一个数据
set.remove()#删除集合中一个具体的数据
set.discard()#删除集合中的一个具体的数据
set.clear()#清空集合
 
4.字典（dict）
 
字典是可以存储多个key:value 键值对数据的组合数据类型。也叫映射。
 
首先声明一个字典
 
#声明一个空字典
dict = {}
d1  = dict() 
 
对字典的基本数据操作
 
dict.get()#根据key值获取对应的值
dict.pop()#根据key值删除一个键值对
dict.items()#获取所有的键值对
dict.popitem()#随机删除一个键值对
dict.fromkeys()#通过制定的key生成一个值为None的字典
dict.setdefault()#增加一个数据，如果数据存在~修改
dict.values()#获取所有的值