标准数据类型

Number（数字）
String（字符串）
List（列表）
Tuple（元祖）
Set（集合）
Dictionary（字典）

按是否可变分类

不可变数据（3个）
- Number（数字）
- String（字符串）
- Tuple（元祖）
可变数据（3个）
- List（列表）
- Dictionary（字典）
- Set（集合）

List（列表）

Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。


    >>> friends = ['小明','小红','小王']  #创建一个list集合
    >>> print(friends)  #打印
    >>> print(type(friends)) #friends变量的类型是list
    >>> print(len(friends)) #使用len()函数可以获得list元素的个数
    ['小明', '小红', '小王']
    <class 'list'>
    3

    #空的list，长度为0
    >>> L = []
    >>> print(len(L))
    0

可以用索引访问list中的每一个位置的元素，从0开始


    >>> print(friends[0])    
    小明
    >>> print(friends[1])
    小红
    >>> print(friends[2])
    小王
    >>> print(friends[3]) #当索引超出范围时，会报IndexError错误
    IndexError: list index out of range
    
    #还可以使用负数做索引，-1表示最后一个元素，以此类推
    >>> print(friends[-1])
    小王
    >>> print(friends[-2])
    小红
    >>> print(friends[-3])
    小明

list是一个可变的有序列表，可以向list中追加元素


    1.追加到末尾
    >>> friends.append('小张')
    >>> print(friends)
    ['小明', '小红', '小王', '小张']
    
    2.插入到指定位置
    >>> friends.insert(1,'小李')
    >>> print(friends)
    ['小明', '小李', '小红', '小王', '小张']
    
    3.删除末尾元素
    >>> friends.pop() #删除末尾的元素并返回  这个类似于栈结构的出栈操作 
    小张
    >>> print(friends)
    ['小明', '小李', '小红', '小王']
    
    4.删除指定位置的元素，使用pop(i)，i是索引的位置
    >>> friends.pop(2)
    小红
    >>> print(friends)
    ['小明', '小李', '小王']
    
    5.替换元素，只需要直接给对应索引位置赋值
    >>> friends[0] = '我是替换后的值'
    >>> print(friends)
    ['我是替换后的值', '小李', '小王']

list中的元素的数据类型可以是不同的


    >>> L = [1,'HaHa',False]

list中存放另一个list


    >>> L1 = ['哈哈哈','嘻嘻嘻',['啦啦','咚咚'],'要不起']
    >>> print(len(L1)) #长度还是4 因为L1中还是4个元素 只不过其中一个元素是List
    >>> print(type(L1))
    4
    <class 'list'>
    
    #或者拆开写
    >>> L2 = ['啦啦','咚咚']
    >>> L3 = ['哈哈哈','嘻嘻嘻',L2,'要不起']
    >>> print(L3)
    ['哈哈哈', '嘻嘻嘻', ['啦啦', '咚咚'], '要不起']
    
    #list中存放另一个list时的取值，类似多维数组
    >>> print(L3[2][0]) #取L2中的第一个元素的值
    啦啦

Tuple（元祖）

首先tuple是一个有序但不可变列表，一旦初始化就不能修改，因此没有append(),insert()这种修改操作的方法，因此相对list较安全

    #tuple的创建用的是()
    >>> friends = ('小明','小红','小王')
    >>> print(len(friends))
    >>> print(type(friends))
    3
    <class 'tuple'>
    
    #以逗号隔开，小括号可以省略
    >>> friends = '小明','小红','小王'
    >>> print(type(friends))
    <class 'tuple'>
    
    #空tuple
    >>> friends = ()
    >>> print(friends)
    >>> print(len(friends))
    ()
    0
    
    #取值还是跟list一样的，索引取值   切片取值也可以，跟list一样
    >>> print(friends[0])  #小明
    >>> print(friends[1])  #小红    
    >>> print(friends[2])  #小王
    >>> print(friends[-1])  #小王
    >>> print(friends[-2])  #小红    
    >>> print(friends[-3])  #小明
   
    
    #测试是否可变
    >>> friends = ('小明','小红','小王')
    >>> friends[0] = '小李' #尝试将friends元祖的第一个元素变成'小李'
    
    #直接报错 tuple元祖是不支持写的，是只读的，由此可见tuple确实是一个不可变列表
    TypeError: 'tuple' object does not support item assignment

创建tuple时需注意的地方


    #定义一个只有一个元素的tuple时，需要加上一个逗号，当然是英文的。
    #如果不加
    >>> t = (1)
    >>> print(type(t))
    <class 'int'>      #可以看到这么定义python会当成数字处理 因为小括号既可以表示tuple类型，又可以表示数学中的小括号，此时会按数学中小括号计算，所以还是数字1
    
    #所以，当只有1个元素的tuple定义时候必须加上一个逗号,
    >>> t = (1,)
    >>> print(type(t))
    >>> print(t)
    <class 'tuple'>   #此时可以看到类型就是tuple了
    (1,)              #当然，显示的时候也会加上一个逗号，表示这是一个只有一个元素的tuple

tuple中放入可变列表list

    >>> t1 = ['aa','bb'] #首先创建一个list集合
    >>> t2 = ('a','b',t1) #将t1放入t2这个元祖中，此时t2 = ['a','b','aa','bb']
    >>> t2[2][0] = 'AA'  #改变t1中t2的元素的值
    >>> t2[2][1] = 'BB'  #改变t1中t2的元素的值
    >>> print(t2)
    ['a','b','AA','BB']  #打印输出后发现里面的值确实改变了，这是否违反了tuple是不可变的呢
    
    #虽然元祖t1中的list集合t2中的元素发生了改变，但实际上元祖t1中的指向的t2对象是没有改变的，
    #改变的list中元素的指向，因为list是可变的。因此要创建一个内容也不可变的tuple，就必须保证
    #tuple中的每一个元素本身也不能变，比如最开始列举的Number和Str类型。

tuple相关的内置函数（与list相仿）

1.len(tuple)：计算元祖元素个数
2.max(tuple)：返回元祖中元素最大值
3.min(tuple)：返回元祖中元素最小值
4.tuple(seq)：将列表转换为元祖
tuple的方法

1.count()：返回元素在tuple中出现的次数
2.index()：查找元素第一次出现位置的索引值
tuple与list对比

1.定义方式基本相同，tuple是小括号（可省略），list是方括号
2.都是有序的，按定义的次序排序，都支持索引、负索引、切片访问
3.tuple是不可变的，因此不能增、删、改元素（没有例如append、extend、remove、pop等方法）
4.tuple比list操作速度快，需要频繁遍历时推荐使用tuple代替list。并且只可读，相当于对数据进行了“写保护”，使代码更安全。
5.tuple和list可以互相转换，并返回一个新的集合。tuple转list后，由不可变转可变；list转tuple后，由可变转不可变。从效果上看，tuple冻结一个list，而list解冻一个tuple（这句话写的很形象）

Dict（字典）

dict是python中的字典类型，类似于java中的map，使用键-值(key-value)存储，查找速度极快，但内存消耗量大。


    #定义一个Dict 使用大括号{}
    >>> d = {'Mick':96,'Jack':97,'Lucy':98}
    #输出
    >>> d['Mick']
    96
    
    #dict是以hash的方式存储数据，其复杂度为O(1)，查找速度极快，是因为在存放时，就根据key算出了value的存放位置，这样取得时候就能根据key直接拿到value，显然这样做会加大内存的消耗，也是典型的空间换时间的做法。
    
    #dict也是一个值对应一个value，因此key是不允许重复的，如果多次对一个key放入value，后面将覆盖前面的
    >>> d['Mick'] = 100
    >>> print(d['Mick'])
    100
    
    >>> d['Mick'] = 200
    >>> print(d['Mick'])
    200
    
    #上面这些都很好理解，跟java的map很相似。
    
    #判断一个dict中是否存在某个key，使用in，返回Ture或False
    >>> print('Mick' in d)
    True   
    
    #也可以使用dict提供的get()，如果key不存在，返回None或自己指定返回值
    >>> d.get('HHH') #不存在key返回None
    None
    >>> d.get('HHH','不存在') #不存在key并且自己指定返回值
    None 不存在
    
    
    #dict删除元素 使用pop(key)
    >>> d.pop('Mick')  #返回弹出的值：100
    100
    >>> print(d)
    {'Jack': 97, 'Lucy': 98}

dict与list相比
1.dict查找和插入速度极快，不会因数据量增加而变慢，复杂度为O(1),而list正好相反
2.dict占用内存大，内存浪费多，list相反
3.由于dict要根据key来计算value的存储位置，因此每次计算相同的key的结果必须相同的（key的hash值），作为key的对象就不能变，所以dict的key必须为不可变对象，例如Number和Str，而list是可变的就不行。


    #尝试一下list作dict的key值
    >>> a = [1,2,3]
    >>> d={a:'a'}
    >>> print(d)
    TypeError: unhashable type: 'list' #可以看到报错 不可取hash值的类型


    字典类型的常见方法
    D.clear()                              #移除D中的所有项  
    D.copy()                               #返回D的副本  
    D.fromkeys(seq[,val])                  #返回从seq中获得的键和被设置为val的值的字典。可做类方法调用  
    D.get(key[,default])                   #如果D[key]存在，将其返回；否则返回给定的默认值None  
    D.has_key(key)                         #检查D是否有给定键key  
    D.items()                              #返回表示D项的(键，值)对列表  
    D.iteritems()                          #从D.items()返回的(键，值)对中返回一个可迭代的对象  
    D.iterkeys()                           #从D的键中返回一个可迭代对象  
    D.itervalues()                         #从D的值中返回一个可迭代对象  
    D.keys()                               #返回D键的列表  
    D.pop(key[,d])                         #移除并且返回对应给定键key或给定的默认值D的值  
    D.popitem()                            #从D中移除任意一项，并将其作为(键，值)对返回  
    D.setdefault(key[,default])            #如果D[key]存在则将其返回；否则返回默认值None  
    D.update(other)                        #将other中的每一项加入到D中。  
    D.values()                             #返回D中值的列表

Set（集合）

set是一个无序的不重复元素序列，set和dict类似，但是值存key不存储value，并且由于key不能重复，所以set中的key是不会重复的，可以用来去重

    #创建空集合 不能用{}来创建空的set集合 用{}创建的是dict类型 空的set需要用set()来创建
    >>> s1 = set()  #这种方式创建的是一个空set
    >>> print(type(s1))
    <class 'set'>
    
    >>> s2 = set{} #这种方式不存在
    >>> s2 = {} #这样创建的是空dict
    >>> print(type(s2))
    <class 'dict'>
    
    #用可迭代对象创建一个新的集合对角
    >>> s = set([1,2,3,4]) #放入一个list创建一个set
    >>> print(type(s))
    >>> print(s)
    <class 'set'>
    {1, 2, 3, 4}
    
    #放入一个Str类型
    >>> s = set('abcdefg')
    >>> print(type(s))
    >>> print(s)
    <class 'set'>
    {'a', 'g', 'f', 'd', 'b', 'c', 'e'} #set集合是无序的 这里也可以看出这个顺序没有按照abcdefg我们定义的顺序排序 
    
    
    #通过set(value)创建的set集合,value必须是可迭代的
    #假如放入不可迭代的对象
    >>> s = set(1)  #放入int类型后报错 int类型是不可迭代的
    TypeError: 'int' object is not iterable
    
    #重复元素在set中自动去重
    >>> s= set([1,1,2,2,3])
    >>> print(s)
    {1, 2, 3}
    
    
    #添加元素到set中，使用add(key)方法，重复添加无效
    >>> s = set([1,2,3,4])
    >>> print(s)
    {1,2,3,4}
    >>> s.add(1)
    >>> s.add(2)
    >>> s.add(3)
    >>> s.add(4)
    >>> print(s)
    {1,2,3,4}
    
    #删除set中的元素，使用remove(key)方法
    >>> s = set([1,2,3,4])
    >>> s.remove(1)
    >>> print(s)
    {2, 3, 4}

数学运算

    set可以当成数学上的无序无重复元素的结合来用，可以进行交集、并集、差集、反交集、子集和超集等操作。
    
    #1.交集
    >>> set1 = {1,2,3,4,5}
    >>> set2 = {4,5,6,7,8}
    >>> print(set1 & set2)
    >>> print(set1.intersection(set2))
    {4, 5}
    {4, 5}
    
    #2.并集
    >>> set1 = {1,2,3,4,5}
    >>> set2 = {4,5,6,7,8}
    >>> print(set1 | set2)
    >>> print(set2.union(set1))
    {1, 2, 3, 4, 5, 6, 7,8}
    {1, 2, 3, 4, 5, 6, 7,8}
    
    
    3.子集和超集
    >>> set1 = {1,2,3}
    >>> set2 = {1,2,3,4,5,6}

    >>> print(set1 < set2)
    >>> print(set1.issubset(set2))  #这两个相同，都是说明set1是set2子集。
    True
    True
    >>> print(set2 > set1
    >>> print(set2.issuperset(set1))  #这两个相同，都是说明set2是set1超集。
    True
    True

frozenset不可变集合

    #frozenset是不可变的，对一个frozenset就不能再使用add和remove方法
    >>> s = frozenset('James')
    >>> print(s)   
    >>> print(type(s))
    frozenset({'e', 's', 'J', 'a', 'm'})
    <class 'frozenset'>
    
    #尝试修改frozenset集合，会直接报错
    >>> s.add('a')
     'frozenset' object has no attribute 'add'
    >>> s.remove('J')
     'frozenset' object has no attribute 'remove'

本次主要是对list、tuple、dict和set四种类型数据进行了复习和总结，当然还有其他的包括他们的各种方法以及应用场景没有总结到，后面学习中遇到了会再次总结。上面的例子也是参考了很多博客的大神，但是每一个例子都是我自己手动尝试并总结的，一天下来收获很大，我会继续努力。