数据类型补充

　　一、列表类型list
 
　　1.存多个值
　　2.有序
　　3.可变类型

常用操作(五颗星)：

 　　l=[‘a’,’b’,’c’,’d’,’e’]
1.按索引存取值(正向存取+反向存取)：即可存也可以取
 　　正向从0开始，反向从-1开始
 　　print(l[0])
　　 print(l[-1])

2.切片(顾头不顾尾，步长)
　　 print(l[1:4])
 　　不写步长时，默认步长=1
 　　也可以不写起始、终止，默认从0到最后

3.长度
 　　print(len(l))

4.成员运算 in和not in
　　 print(‘a’ in l)
 　　print(‘ssssss’ not in l)

5.追加&插入
　　 l.append(3333333)
　　 print(l)
　　 是加到列表的后面
 　　l.insert(0,1111)
 　　print(l)
 　　插入是按照索引位置

6.删除
 　　del l[0]
　　 del是通用的删除，没有返回值
 　　res=l.remove(‘b’)
 　　print(res)
　　 也是单纯的删除，没有返回值
 　　res=l.pop(0)
 　　print(res)
 　　print(l)
　　 pop只是取走需要删除的值，有返回值

7.循环
 　　for item in l:
 　　　　 print(item)

列表补充需掌握操作（四颗星）：

1.count 含有几个此元素
　　 l=[‘a’,’b’,’a’,’c’,’d’,’e’]
 　　print(l.count(‘a’))
 
2.extend 循环追加多个值：
　　 l=[‘a’,’b’,’a’,’c’,’d’,’e’]
　　 items=[1,2,3,4,5]
 　　l.extend(items)
 　　print(l)

3.index 指定查找范围，寻找元素位置（找不到会报错）
 　　l=[‘a’,’b’,’a’,’c’,’d’,’e’]
　　 print(l.index(‘a’,2,5))
　　 不想被报错的话可以：
　　 if 123123 in l:
 　　　　 print(l.index(123123))
  
4.reverse 颠倒顺序
　　 l.reverse()
 　　print(l)

5.sort排序
 　　l.sort() 默认从小到大排序
 　　l.sort(reverse=True) 从大到小排序
 
6.补充概念
 　　队列：先进先出
 　　# 入队
 　　　　l.append(‘first’)
 　　　　l.append(‘second’)
　　　　 l.append(‘third’)
　　　　 print(l)

　　# 出队
　　　　 print(l.pop(0))
 　　　　print(l.pop(0))
　　　　 print(l.pop(0))
 　　栈队：先进后出
 　　# 入栈
　　　　 l.append(‘first’)
　　　　 l.append(‘second’)
　　　　 l.append(‘third’)
 　　　　print(l)
 　　# 出栈
 　　　　print(l.pop())
　　　　 print(l.pop())
 　　　　print(l.pop())

　　二、元组类型tuple

 　　1.用途：元组就是一个不可变的列表
 　　2.定义方式：在()内用逗号分隔开多个任意类型的元素
 　　　　 强调：
 　　　　　　 t=(‘a’,)当元组内只有一个元素的时候要加一个逗号，否则则是字符串类型
 　　3.类型转换：
 　　4.存多个值
 　　5.有序
 　　6.不可变

 元组常用操作（五颗星）：

‘
　　　　 t=(‘a’,’b’,’c’,’e’,’f’)
1.按索引取值(正向取+反向取)：只能取
　　 print(t[0]) 正向从0开始
　　 print(t[-1]) 反向从-1开始

 2.切片(顾头不顾尾，步长)
 　　print(t[1:4])
 
3.长度
 　　print(len(t))

4.成员运算in和not in
 　　print(‘a’ in t)
 
5.循环
 　　for item in t:
 　　　　 print(item)

元组需要掌握的操作（四颗星）：

　　 t=(‘a’,’b’,’c’,’e’,’a’,’f’)
1.index 指定查找范围，寻找元素位置
 　　　　print(t.index(‘a’,1,5))
2.count 含有几个此元素
 　　　　print(t.count(‘a’))

　　三、字典类型dict

　　 1.key可以是不可变类型，但通常是字符串类型
 　　　values 是任意类型
 　　2.存多个值
 　　3.无序
 　　4.可变类型

字典常用操作（五颗星）：

 　　dic={‘name’:’egon’,’age’:18}
1.按key存取值：可存可取
 　　print(dic[‘name’]) 字典中有的话，直接用key可取出，输出的是value
 　　print(dic[‘xxx’])  字典中没有的胡啊，会报错
 　　这时候用下面这个：

　　print(dic.get(‘xxx’)) 没有的话也不会报错，只会输出None
　　dic[‘name’]=’EGON’
　　print(dic) 得到的是{‘name’: ‘EGON’, ‘age’: 18} 因此对于字典已经存在的值可以重新赋值

　　dic[‘gender’]=’male’

　　print(dic) {‘name’: ‘egon’, ‘age’: 18, ‘gender’: ‘male’} 对于没有的key也可以做赋值，添加进去

2.长度len
 　　print(len(dic))
 　　重复的会被后面一个覆盖掉，统计的是key的个数，也可以说是value的个数

3.成员运算in和not in :是以字典的key为准的
　　 print(‘name’ in dic)
 　　print(‘egon’ in dic)
4.删除:指定key
 　　del dic[‘name’]
 　　print(dic) 
 　　del是通用的删除，没有返回值
 　　res=dic.pop(‘name’)

5.键keys()，值values()，键值对items()
 　　5.1 python2中取值：
 　　　　　　dic={‘name’:’egon’,’age’:18}
 　　　　取key，没有顺序
 　　　　print(dic.keys()) 
 　　　　 　　输出的是[‘age’, ‘name’]
 　　　　取values，也没有顺序
　　　　 print(dic.values())
 　　　　 　　输出的是values
　　　　 取键对值：
 　　　　print(dic.items())

　　　　　　　输出的是[(‘age’, 18), (‘name’, ‘egon’)]

　　5.2 python3中：
  　　　　　　dic={‘name’:’egon’,’age’:18}
 　　　　print(dic.keys())
  　　　　　　输出的是dict_keys([‘name’, ‘age’])
 　　　　print(dic.values())
  　　　　　　输出的是dict_values([‘egon’, 18])
 　　　　print(dic.items())
　　　　　　  输出的是dict_items([(‘name’, ‘egon’), (‘age’, 18)])

6.循环取值
 　　for k in dic:
  　　　　print(k)
 　　默认取的是keys
 
　　 想要取values的话：
 　　for v in dic.values():
  　　　　print(v)

　　想要取键对值的话：
 　　for item in dic.items():
 　　　　 print(item)
 　　输出的是（’name’,’egon’）(‘age’,18)
　　 for k,v in dic.items():
 　　　　 print(k,v)

 　　输出的是 name egon  age  18

字典补充，需要掌握内容（四颗星）：

　　dic={‘name’:’egon’,’age’:18}

 1. update 更新
　　 dic.update({‘age’:19,’gender’:’male’})
　　 print(dic)
 　　输出的是：{‘name’: ‘egon’, ‘age’: 19, ‘gender’: ‘male’}

2. setdefault 设置默认值
 　　当key存在时：不改原值，也有返回值，返回的是原值value
　　 res=dic.setdefault(‘name’,’EGON’)
　　 print(dic)
　　 输出的是{‘name’: ‘egon’, ‘age’: 18}
　　 print(res)
　　 返回的是原值egon

　　当key不存在时：增加值，也就是设置新值
　　 res=dic.setdefault(‘gender’,’male’)
 　　print(dic)
 　　{‘name’: ‘egon’, ‘age’: 18, ‘gender’: ‘male’}
 　　print(res)  也有返回值，返回的是新值
 　　male
所以当setdefault执行x：1结束后，一定会保证字典中有x，但是值不一定有1，返回的肯定是1

　　四、集合类型set：

 　　　　用途：I.两个几何体之间做关系运算  II.去重
 　　　　定义方式:在{}内用逗号分隔开多个元素,但是元素的特点是
 　　　　　　 I: 集合内的元素必须是不可变类型
 　　　　　　 II: 集合内元素无序
 　　　　　　 III: 集合内元素不能重复
 　　　　存多个值，用于关系运算
 　　　　无序
　　　　 集合本身是可变类型，集合内的元素是不可变类型

集合常用操作（五颗星）；

　　pythons={‘张铁蛋’,’李铜淡’,’王金蛋’,’赵银胆’,’alex’,’kevin’}
　　linuxs={‘oldboy’,’张铁蛋’,’赵银胆’,’alex’,’wxx’}

1. 长度len 
 　　元素的个数
2.成员运算
 　　in和not in
3.|合集:求所以报名的学生
 　　print(pythons | linuxs)
4. &交集:求同时报名两门课程的学生
 　　print(pythons & linuxs)

5. -差集: 求只报名python课程的学员
 　　print(pythons – linuxs)  只报名python课程的学员
 　　print(linuxs – pythons)  只报名linux课程的学员
6. ^对称差集:求没有同时报名两门课程的学生
 　　res=pythons ^ linuxs
 　　print(res)

7. ==
 　　s1={1,2,3}
　　 s2={3,2,1}
 　　print(s1 == s2)

注意:父子集描述的是一种包含与被包含的关系
8.父集：>=
9.子集：<=
 　　s1={1,2,3}
 　　s2={1,2,3,4}
 　　print(s2 >= s1)
 　　print(s1 <= s2)

集合需要掌握的内容（四星）：

1.更新，且去重
 　　s1={1,2,3}
 　　s1.update({3,4,5,6})
 　　print(s1)

 2. pop随机删除
　　 s1={1,’aa’,’bb’,3}
 　　print(s1.pop())
 　　输出的结果每次都会不一样，随机删除，每次删一个，有返回值

3.remove指定元素，无返回值
 　　s1={1,’aa’,’bb’,3}
 　　res=s1.remove(‘bb’)
 　　print(s1)
 　　print(res)
　　 不存在的元素会报错

4.diacard 根据元素删
 　　s1.discard(‘bbb’)
 　　不存在的元素不会报错

5.add
　　 随机加值

补充：集合的去重（五星）：

 　　names=[‘egon’,’egon’,’egon’,’alex’,’alex’,’kevin’]
 　　names=list(set(names))
 　　print(names)
 　　局限性
  　　　　1. 只能针对不可变类型
 　　　　 2. 不能保证原来的顺序