标准数据类型
- 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'