20181122笔记（列表、元组、字典和集合的数据类型及内置方法）

主要讲列表、元组、字典和集合的数据类型及内置方法

一、list列表类型

======================================基本使用======================================
1、用途：记录多个值（同种属性）
​
2、定义方式：在[]内用逗号分隔开多个任意类型的值。
  l=['a','b','c'] # l=list(['a','b','c'])
  
  # 类型转换 ,能被for循环的就能转换成列表
  l=list('hello')
   print(l)
   输出：
   ['h', 'e', 'l', 'l', 'o']
   
   l=list({'x':1,'y':2})
    print(l)
    输出：
    ['x', 'y']  #字典时，只输出键的值
​
3、常用操作+内置的方法
Ⅰ 按索引存取值（正向/反向存取），索引正向从0开始，反向从-1开始，可存亦可取：
l=['a','b','c','d','e']
print(l[0])
print(l[-1])
print(id(l))
l[0]='A'
print(id(l))
输出结果：
a
e
2050887798728  # 内存地址一致，证明列表是可变类型
2050887798728
​
>>> a[1:1]=list('abc')
>>> a
[1, 'a', 'b', 'c', 2, 'x', 'y', 'z']
​
 索引大于列表实际大小时会报错，以下两个都会报错：
 print（l[5])
 l[5]='aaa'
    
Ⅱ 切片，步长（顾头不顾尾）：
l=['a','b','c','d','e']
print(l[0:4:2])
输出结果：
['a', 'c']
​
Ⅲ 长度
l=['a','b','c','d','e']
print(len(l))  # 输出结果为5
​
Ⅳ 成员运算 in和not in：
l=['a','b','c','d','e']
print('a' in l)
print('sss' not in l)
输出结果均为True
​
Ⅴ 追加（append）和插入（insert）：
l=['a','b','c','d','e']
l.append(666)  # 追加只能在最后追加
print(l)
输出结果：
['a', 'b', 'c', 'd', 'e', 666]
​
l=['a','b','c','d','e']
l.insert(2,666) # 在第三个处的位置插入元素666
print(l)
输出结果：
['a', 'b', 666, 'c', 'd', 'e'] 
​
Ⅵ 删除 del，pop(),remove:
 l=['a','b','c','d','e']
 del l[0]
 print(l)
 输出结果：
 ['b', 'c', 'd', 'e']
​
 l=['a','b','c','d','e']
 res=l.pop(0)  # pop方法是唯一一个既能修改列表又能返回元素值（除了None）的列表方法
 print(l)
 print(res)
 输出结果为：
 ['b', 'c', 'd', 'e']
 a
    
 l=['a','b','c','d','e']
 res=l.remove('b') # 上面的两种方法是指定元素位置，remove则是指定元素，remove只移除列表中某个值的第一个匹配项。
 print(l)
 print(res) # 没有返回值
 输出结果为：
 ['a', 'c', 'd', 'e']
 None
​
Ⅶ 循环：由于列表是有序的，所以可以循环。
l=['a','b','c','d','e']
for item in l:
    print(item)
 输出结果为：
a
b
c
d
e
Ⅷ 计数count：
l=['a','b','a','c','d','e']
print(l.count('a')) # 输出结果为2
​
Ⅸ 扩展原来的列表extend： list.extend(seq)，用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。List表示列表，seq代表元素列表。extend方法修改了被扩展的序。
l=['a','b','a','c','d','e']
items=[1,2,3,4,5]
l.extend(items)
print(l)
输出结果：
['a', 'b', 'a', 'c', 'd', 'e', 1, 2, 3, 4, 5]
​
Ⅹ index：list.index（obj）方法用于从列表中找出某个值第一个匹配项的索引位置。
l=['a','b','a','c','d','e']
print(l.index('a',2,5)) # 输出结果为2，因为其指定了开始与结束的位置
​
十一、reverse：list.reverse()方法用于反向列表中的元素，该方法改变了列表但不返回值
l=['a','b','a','c','d','e']
l.reverse()
print(l)
输出结果：
['e', 'd', 'c', 'a', 'b', 'a']
​
十二、sort：list.sort(func)方法用于对原列表进行排序，如果指定参数，就使用参数指定的比较方法进行排序
l=[10,-1,3,11,9]
l.sort(reverse=True)
print(l)
输出结果：
[11, 10, 9, 3, -1]
如果l.sort()  # 则默认升序排列
结果则变为：[-1, 3, 9, 10, 11]
​
======================================该类型总结====================================
存多个值
​
有序
​
可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）

 

二、tuple元组类型：

======================================基本使用======================================
1、用途：元组就是一个不可变的列表
​
2、定义方式：在()内用逗号分隔开多个任意类型的元素。
  t=('a','b','c') # t=tuple('a','b','c')
  元组内只有一个元素时，命名方式应为：
  t=('a',)  # 注意逗号，如果不添加逗号会被认为是str字符串
  
  # 类型转换 ,能被for循环的就能转换成元组
  t=tuple('hello')
  print(t)
  输出结果：
  ('h', 'e', 'l', 'l', 'o')
​
3、常用操作+内置的方法
Ⅰ 按索引取值（正向/反向取），索引正向从0开始，反向从-1开始，只可取：
t=（'a','b','c','d','e'）
print(t[0])
输出结果：
a
​
 索引大于列表实际大小时会报错，以下两个都会报错：
 print(t[5])
    
Ⅱ 切片，步长（顾头不顾尾）：
t=('a','b','c','d','e')
print(l[0:4:2])
输出结果：
('a', 'c')
​
Ⅲ 长度
t=('a','b','c','d','e')
print(len(t))  # 输出结果为5
​
Ⅳ 成员运算 in和not in：
t=('a','b','c','d','e')
print('a' in t)
print('sss' not in t)
输出结果均为True
​
Ⅴ 循环
t=('a','b','c','d','e')
for item in t:
    print(item)  # 输出a,b,c,d,e
​
Ⅵ index：tuple.index（obj）方法用于从元组中找出某个值第一个匹配项的索引位置。
t=('a','b','a','c','d','e')
print(t.index('a',2,5)) # 输出结果为2，因为其指定了开始与结束的位置
​
Ⅶ count计数：
t=('a','b','c','e','a','f')
print(t.count('a')) # 输出结果为2
​
Ⅷ 关于元组不可变的解释（元组就是不可变的列表）：
元组的不变是指每个元素的指向永远不变，指向一个list就不能改成指向其他对象，但指向的list列表本身是可变的。
>>> t=('a','b',['A','B'])
>>> t[2][0]='X'
>>> t[2][1]='Y'
>>> t
('a', 'b', ['X', 'Y'])
此处使用了嵌套列表，一个列表中包含另一个列表，也可以称为二维数组。一个单一的列表称为一维数组，还有三维四维等多维数组。
取二维数组中的元素的方式为：先取得二维数组里嵌套的数组，如上例中的t[2]，取得的是[‘A’,’B’]，t[2]是一个一维数组，从一维数组中获取的元素是以a[0]的方式获取的，因而从t[2]中取得编号为0的元素的方式为t[2][0]。
​
​
​
​
======================================该类型总结====================================
存多个值
​
有序
​
不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）

 

三、dict字典类型

======================================基本使用======================================
1、用途：记录多个值，列表是索引对应值，而字典是key对应值，其中key对value有描述性的功能，而value则可以是任意类型。字典是python中唯一内建的映射类型，字典指定值并没有特殊顺序。
​
2、定义方式：字典的创建格式为：
d={key1:value1,key2:value2}
字典由多个键及其对应的值构成的对组成（把键/值对称为项）。字典的每个键/值对用冒号分隔，每个项之间用逗号分隔，整个字典包含在大括号中。空字典（不包含任何项）由两个大括号组成{}。
键必须是唯一的，但值不必。值可以取任何数据类型，键必须是不可变的，如字符串、数字或元组。
​
  
  # 类型转换 
d=dict(x=1,y=2,z=3)
print(d)
输出结果：
{'x': 1, 'y': 2, 'z': 3}
items=[('name','egon'),('age',18),('gender','male')]
#d={}
#for item in items:
#    d[item[0]]=item[1] #这三句话是解释下面的一句话的
d=dict(items)
print(d)
输出结果：
{'name': 'egon', 'age': 18, 'gender': 'male'}
​
创建字典的一个方法：
fromkeys（）方法：用于创建一个新字典，以序列seq中的元素做字典的键，value为字典所有键对应的初始值。
语法如下：dict.fromkeys(seq[,value])，dict代表字典；seq代表字典键值列表；value代表可选参数，设置键序列（seq）的值。该方法返回结果为列表。
fromkeys方法使用给定的键建立新字典，每个键默认对应的值为None。
>>> seq=('name','age','sex')
>>> info=dict.fromkeys(seq)
>>> print('新的字典为:%s'%info)
新的字典为:{'name': None, 'age': None, 'sex': None}
>>> info=dict.fromkeys(seq,10)
>>> print('新的字典为:%s'%info)
新的字典为:{'name': 10, 'age': 10, 'sex': 10}
​
​
3、常用操作+内置的方法
Ⅰ 按key存取值，可存可取：
get（）方法：返回指定键的值，如果值不在字典中，就返回默认值。语法为：dict.get(key,default=None)，dict代表字典，key代表字典中要查找的键，default代表指定键的值不存在时返回默认值。该方法返回的结果为指定键的值，如果值不在字典中，就返回默认值None。
dic={'name':'egon','age':18}
print(dic.get('name'))
输出结果为：
egon
    
Ⅱ 长度len()
dic={'name':'egon','age':18}
print(len(dic))  # 输出结果为2
​
Ⅲ 成员运算in和not in :是以字典的key为准的：
dic={'name':'egon','age':18}
print('name' in dic)  #输出结果为True
print('egon' in dic)  #输出结果为False
​
Ⅳ 删除del,pop,popitem
dic={'name':'egon','age':18}
del dic['name']
print(dic)
输出结果为：
{'age': 18}
​
dic={'name':'egon','age':18}
res=dic.pop('name')
print(dic)
print(res)
输出结果：
{'age': 18}
egon
​
popitem() 方法随机返回并删除字典中的一对键和值。
如果字典已经为空，却调用了此方法，就报出KeyError异常。
dic={'name':'egon','age':18}
res=dic.popitem()
print(res)
print(dic)
输出结果为：
('age', 18)
{'name': 'egon'}
​
Ⅴ 键keys(),值values(),键值对items()
在python2
>>> dic={'name':'egon','age':18}
>>> dic.keys()
['age', 'name']
>>> dic.values()
[18, 'egon']
>>> dic.items()
[('age', 18), ('name', 'egon')]
​
在python3
>>> dic={'name':'egon','age':18}
>>> dic.keys()
dict_keys(['name', 'age'])
>>> dic.values()
dict_values(['egon', 18])
>>> dic.items()
dict_items([('name', 'egon'), ('age', 18)])
​
Ⅵ 循环
dic={'name':'egon','age':18}
for k in dic:
    print(k)
输出：
name
age
for k in dic.keys():
    print(k)
输出：
name
age
for v in dic.values():
    print(v)
输出：
egon
18
for k,v in dic.items(): #k,v=('name', 'egon')
    print(k,v)
输出：
name egon
age 18
​
Ⅶ update（）方法：用于把字典dict2的键/值对更新到dict里面。语法如下dict.update(dict2)，dict代表指定字典，dict2代表添加到指定字典dict里的字典。该方法没有任何返回值。提供的字典中的项被添加到旧字典中，如果有相同的键会被覆盖。
>>> a={'小明':'1001'}
>>> b={'小智':'1002'}
>>> a.update(b)
>>> print('新字典a为：%s'%a)
新字典a为：{'小明': '1001', '小智': '1002'}
>>> c={'小智':'1003'}
>>> a.update(c)
>>> print('新字典a为：%s'%a)
新字典a为：{'小明': '1001', '小智': '1003'}
​
​
​
Ⅷ setdefault()方法：与get（）方法类似，用于获得与给定键相关联的值。如果键不存在于字典中，就会添加键并将值设为默认值。
语法为：dict.setdefault(key,default=None)，dict代表指定字典，key代表查找的键值，default代表键不存在时设置的默认值。该方法没有任何返回值。
dic={'name':'egon','age':18}
# 当key存在时,不改原值,返回原值
res=dic.setdefault('name','EGON')
print(dic)
print(res)
输出结果：
{'name': 'egon', 'age': 18}
egon
​
# 当key不存在时,增加新值
res=dic.setdefault('gender','male')
print(dic)
print(res)
输出结果：
{'name': 'egon', 'age': 18, 'gender': 'male'}
male
​
​
======================================该类型总结====================================
存多个值
​
无序
​
可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）

四、set集合

集合类型set
======================================基本使用======================================
1、用途:I: 关系运算  II:去重
​
2、定义方式:在{}内用逗号分隔开多个元素,但元素的特点是
I: 集合内的元素必须是不可变类型
II: 集合内元素无序
III: 集合内元素不能重复
    s={1,'aaa',2,} #s=set(...)
    print(s,type(s))
    输出结果：{1, 2, 'aaa'} <class 'set'>
    
    s=set()
    print(s,type(s))
    输出结果：set() <class 'set'>
    
    s={1,1,1,1,1,1,1,1,1,1,1,1,'a','a','a'}
    print(s)
    输出结果：{1, 'a'}
    # 数据类型转换
    res=set('hello')
    print(res)
    输出结果：
    {'h', 'l', 'e', 'o'}  # 去重
    res=set([1,'a','b'])
    print(res)
    输出结果：
    {1, 'a', 'b'}
    
3、常用操作+内置的方法
优先掌握的操作：
1、长度len
2、成员运算in和not in
​
pythons={'张铁蛋','李铜淡','王金蛋','赵银胆','alex','kevin'}
linuxs={'oldboy','张铁蛋','赵银胆','alex','wxx'}
3、|合集:求所有报名的学生
print(pythons | linuxs)
print(pythons.union(linuxs)) #两种方法相同
输出结果：
{'李铜淡', 'wxx', 'kevin', '张铁蛋', '赵银胆', '王金蛋', 'oldboy', 'alex'}
​
4、&交集:求同时报名两门课程的学生
print(pythons & linuxs)
输出结果：
{'张铁蛋', '赵银胆', 'alex'}
​
5、-差集: 求只报名python课程的学员
print(pythons - linuxs)
print(linuxs - pythons) #求只报名linux课程的学员
输出结果：
{'王金蛋', 'kevin', '李铜淡'}
{'wxx', 'oldboy'}
​
6、^对称差集:求没有同时报名两门课程的学生
res=(pythons - linuxs) | (linuxs - pythons)
res=pythons ^ linuxs #和上面的方法相同
print(res)
输出结果：
{'wxx', '王金蛋', '李铜淡', 'oldboy', 'kevin'}
​
7、==
s1={1,2,3}
s2={3,2,1}
print(s1 == s2)
输出结果为True
​
注意:父子集描述的是一种包含与被包含的关系
8、父集：>=
9、子集：<=
s1={1,2,3}
s2={1,2,3,4}
print(s2 >= s1)  # 输出为True
print(s1 <= s2)  # 输出为True
    
10、update：
s1={1,2,3}
s1.update({3,4,5,6})
print(s1)
输出结果：
{1, 2, 3, 4, 5, 6}
    
11.pop(),因为集合是无序的，所以是随机删除：
s1={1,'aa','bb',3}
print(s1.pop())  #输出结果可能是集合中的任意一项
​
12.remove和discard：remove 集合中没有的元素，会报错，而discard 集合中没有的元素不会报错。
s1={1,'aa','bb',3}
res=s1.remove('bb')
print(s1)
print(res)
输出结果为：
{'aa', 1, 3}
​
s1={1,'aa','bb',3}
s1.discard('bb')
print(s1)
输出结果为：
{'aa', 1, 3}
   
======================================该类型总结====================================
存多个值
​
无序
​
可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
​
​
集合的去重
局限性
1. 只能针对不可变类型
2. 不能保证原来的顺序
names=['egon','egon','egon','alex','alex','kevin']
new_names=list(set(names)) #先做成集合，去重，然后再改回列表
print(new_names)
输出结果：
['kevin', 'alex', 'egon']
​
 去重一例：
 l=[
    {'name':'egon','age':18,'sex':'male'},
    {'name':'alex','age':73,'sex':'male'},
    {'name':'kevin','age':20,'sex':'female'},
    {'name':'egon','age':18,'sex':'male'},
    {'name':'egon','age':18,'sex':'male'},
]
new_l=[]
for dic in l:
    if dic not in new_l:
        new_l.append(dic)
print(new_l)
输出结果：
[{'name': 'egon', 'age': 18, 'sex': 'male'}, {'name': 'alex', 'age': 73, 'sex': 'male'}, {'name': 'kevin', 'age': 20, 'sex': 'female'}]
    

栈：一种数据结构，最后放入栈的最先被移除，称为LIFO(Last in first out)，即后进先出。栈中的放入和移除操作有统一的称谓：入栈（push）和出栈（pop）。Python中没有入栈的方法，但可以用append方法代替。Pop方法和append方法的操作结果正好相反，如果入栈（或者追加）刚刚出栈的值，最后得到的结果就不会变。

队列：先进先出。