组合数据类型总结

列表（list）

作用：存储数据
声明列表：
声明空列表：
方法一（推荐）：u1=list()
方法二：u2=[]
声明非空列表：
方法一：u3=list([1,2,3,4])
方法二（推荐）：u4=[1,2,3,4]
操作方法：增（数据增加）、删（删除数据）、改（数据修改）、查（查询数据）

1. 增加数据：
   a) 末尾中增加数据：append
   b) 指定位置增加数据:insert
   c) 末尾追加一组数据：extend
2. 查询数据：
   a) 通过索引查询（列表中存储的数据~有顺序，0,1,2,… 这个顺序的编号：称为列表的索引/下标/编号）
   b) 循环遍历列表中的数据（for x in u5:）
   c) emumerate()方法，可以让for循环遍历的数据添加一个索引编号
   for i， x in enumerate（u5）： （i：编号；x：数据）
3. 修改数据：
   a) 通过编号直接修改数据
4. 数据删除|删除列表：
   a) del u5[9]:删除列表u5里索引为9的数据
   b) del u5:删除列表u5
   列表详细例子讲解：
   ‘’’
   列表的基本操作
   声明
   数据操作
   ‘’’
   #声明空列表
   u1 = list() # 推荐
   u2 = []
   print(u1, u2)
   #声明非空列表
   u3 = list([1,2,3,3,4])
   u4 = [1,2,3,3,4] # 推荐
   print(u3, u4)

#1. 列表中增加数据
u5 = [“hello”, True, 50, 3.1415926]
0 1 2 3
print(u5)
#shell窗口出来的效果：
#u5 = [‘hello’, True, 50, 3.1415926]

#末尾追加一个数据
u5.append(‘world’)
print(u5)
#shell窗口出来的效果：
#u5 = [‘hello’, True, 50, 3.1415926,‘world’]

#指定位置增加一个数据
u5.insert(1, ‘jerry’)
print(u5)
#shell窗口出来的效果：
#u5 = [‘hello’,‘jerry’, True, 50, 3.1415926]

#末尾追加一组数据
u5.extend([‘suzhen’,‘xiaoqing’,‘xuxian’,‘haihai’])
print(u5)
#shell窗口出来的效果：
#u5 = [‘hello’, True, 50, 3.1415926，‘suzhen’,‘xiaoqing’,‘xuxian’,‘haihai’]

####################append和extend的区别######################################
#注意：append和extend的区别
#u5.append([‘jerry’, ‘tom’])
#print(u5)
#shell窗口出来的效果：
#[‘hello’, ‘jerry’, True, 50, 3.1415926, ‘world’, ‘suzhen’, ‘xiaoqing’, ‘xuxian’, ‘haihai’, [‘jerry’, ‘tom’]]

#u5.append(‘jerry’, ‘tom’)
#print(u5)
#TypeError: append() takes exactly one argument (2 given)#表示只能增加一个数据，现状有两个数据

#2. 查询数据
#列表中存储的数据~有顺序，0,1,2,… 这个顺序的编号：称为列表的索引/下标/编号
#列表中可以通过索引查看某个位置的数据
print(u5[2])# True
print(u5[10])# [‘jerry’, ‘tom’]
#print(u5[100]) # IndexError: list index out of range（超出了列表范围）

#循环遍历列表中的数据：专门~for循环
for x in u5:
print("–u5—>", x)#全部列出来一遍并相应的赋值
#shell窗口显示出来：
# --u5—> hello
# --u5—> jerry
# --u5—> True
# --u5—> 50
# --u5—> 3.1415926
# --u5—> world
# --u5—> suzhen
# --u5—> xiaoqing
# --u5—> xuxian
# --u5—> haihai
# --u5—> [‘jerry’, ‘tom’]

#enumerate() 方法，可以让for循环遍历的数据，添加一个索引编号
for i, x in enumerate(u5):
print(“编号：”,i, “数据:”, x)
#shell窗口中显示出来：
# 编号： 0 数据: hello
# 编号： 1 数据: jerry
# 编号： 2 数据: True
# 编号： 3 数据: 50
# 编号： 4 数据: 3.1415926
# 编号： 5 数据: world
# 编号： 6 数据: suzhen
# 编号： 7 数据: xiaoqing
# 编号： 8 数据: xuxian
# 编号： 9 数据: haihai
# 编号： 10 数据: [‘jerry’, ‘tom’]

#3. 修改数据
#通过编号直接修改数据
u5[10] = ‘hello list’
print(u5)
#shell窗口显示出来：
#[‘hello’, ‘jerry’, True, 50, 3.1415926, ‘world’, ‘suzhen’, ‘xiaoqing’, ‘xuxian’, ‘haihai’, ‘hello list’]

#4. 删除数据 | 删除列表
#del u5[9]
#print(u5)

#del u5
#print(u5)

#5. 学习过程
‘’’
dir(list)
[‘add’, ‘class’, ‘contains’, ‘delattr’,
‘delitem’, ‘dir’, ‘doc’, ‘eq’, ‘format’,
‘ge’, ‘getattribute’, ‘getitem’, ‘gt’, ‘hash’,
‘iadd’, ‘imul’, ‘init’, ‘init_subclass’, ‘iter’,
‘le’, ‘len’, ‘lt’, ‘mul’, ‘ne’, ‘new’,
‘reduce’, ‘reduce_ex’, ‘repr’, ‘reversed’, ‘rmul’,
‘setattr’, ‘setitem’, ‘sizeof’, ‘str’, ‘subclasshook’,
‘append’, ‘clear’, ‘copy’, ‘count’, ‘extend’, ‘index’, ‘insert’, ‘pop’,
‘remove’, ‘reverse’, ‘sort’]

所有下划线开头的_{可以暂时忽略。【面向对象以后}我们会针对带下划线的变量进行详细讲解】
‘append’, 末尾追加一个数据
‘clear’, 清空列表
‘copy’, 复制一个有相同数据的列表
‘count’, 查询某个数据在列表中出现的次数
‘extend’, 末尾追加一组数据
‘index’, 查询某个具体数据在列表中的位置
‘insert’, 在指定位置增加一个数据
‘pop’, 从列表中删除一个末尾的数据
‘remove’, 从列表中删除指定的一个数据
‘reverse’, 翻转列表
‘sort’ 排序
‘’’
#存在一个列表
x = [1,5,2,3,5,6,2,5,7,8,8,4,2,1,5,8,3,10,11]

#查询3在列表中出现的次数
print(x.count(3))

#删除一个末尾的数据
res = x.pop()
print(‘删除了一个数据’, res)
print(‘pop()----------->’, x)

#删除一个指定的数据
x.remove(10)
print(‘删除了一个数据’, 10)
print(‘remove(10)----------->’, x)

#翻转列表
x.reverse()
print(‘reverse()----------->’, x)

#排序
x.sort()
print(‘sort()----------->’, x)

#查看列表中总共有多少数据:系统提供的方法
print(len(x))

#如果都是数字，可以查看列表中的最大的数字，和最小的数字
print(max(x), min(x))

元组（tuple）

作用：存储多个，可重复，有顺序，不能修改的数据
声明：

1. 声明空列表：t=tuple()
2. 声明非空列表：t=tuble(“hello”,“world”)
   由于元组内的内容不能修改，所以元组的才做方法只有查看数据
   操作方法：查看元组内数据
   a) count:查看某个指定的数据，在元组中出现的次数
   b) index：查看某个指定的数据在元组中的位置
   c) len(x):查看元组元素的个数、总数
   d) max(x)/min(x):查看最大/最小值

集合（set）

作用：用于存储多个，不能重复，随机排列（无顺序），可修改的数据
声明定义：
声明一个空集（建议）：s=set()
声明一个非空集（建议）：s={1,2,3,4,5,“hello”}
操作方法：增、删、改、查

1. 数据的增加：add
2. 数据的删除：
   a) pop():随机删除一个数据
   b) remove():删除指定数据
   c) clear():清空集合中的数据
   d) del ：删除集合
3. 数据的修改：完整流程为：查询数据是否存在，然后删除原有数据，再加上新的数据，便达到了修改数据的效果，得用到成员运算符。比如把“hello”改为“olleh”：
   print(“hello” in s) #打印出来为：True （用来确认“hello”是否存在于集合s里，之后把“hello”删除，增加“olleh”）
   if “hello” in s:
   s.remove(“hello”)
   s.add(“olleh”)
   一些例子：
   s=set()#声明一个空集 建议
   s={1,2,3,4,5,“hello”}#声明一个非空集 建议
   #增加数据
   s.add(“jerry”)
   print(s)#打印：{1, 2, 3, 4, 5, ‘jerry’}

#修改数据
#完整流程为：查询数据是否存在，然后修改数据的值，得用到成员运算符
#成员运算符
print(“hello” in s)#打印：True
#修改hello数据为olleh
if “hello” in s:
s.remove(“hello”)
s.add(“olleh”)
print(s) #打印：{1, 2, 3, 4, 5,‘jerry’, ‘olleh’}

#查询数据（只有遍历循环）
for x in s:
print("–for–>",x)#打印：
–for–> 1
–for–> 2
–for–> 3
–for–> 4
–for–> 5
–for–> jerry
–for–> olleh
#删除数据和删除集合
s.pop()#随机删除一个数据
print(s)#打印：{2, 3, 4, 5, ‘jerry’}
s.remove(“jerry”)#删除指定数据
print(s)#打印：{2, 3, 4, 5}
s.clear()#清空集合中的数据
del s#删除集合

字典（dict）

作用:可以存放多组key-value 键值对 的 键不能重复，值可以重复的数据对
声明：
声明空字典：d=dict() #推荐
d2={}
声明非空字典： d3={‘key’ : ’value’ , ’key2’ ; ‘value2’} #推荐
d4=dict([(‘k1’ , ‘v1’ ) , ( ‘ k2‘, ‘v2’)]) #不推荐
d5=dict([[ ‘k1’ , ‘v1’],[ ‘k2’ , ‘v2’ ]]) #不推荐
操作方法：增、删、改、查
# 增加数据
#key和value都是基本数据类型，都是字符串
d[‘key’] = ‘value’
print(d)
#key是一个字符串，value是一个列表
d[‘admin’] = [‘admin’, ‘123456’]
print(d)
#key是一个字符串，value是一个字典
d[‘manager’] = {‘username’: ‘manager’, ‘password’: ‘123’}
print(d)

#setdefault # 如果admin已经在字典中存在，下面的这行代码什么都不做
d.setdefault(‘admin’, ‘Administrator’)
print(d)
#setdefault 如果设置的key值在字典中不存在的~ 新增数据
d.setdefault(‘root’, ‘123456’)
print(d)

2. 查询数据
   通过key直接查询对应的value值
   print(d[‘admin’])
   print(d.get(‘manager’))

循环遍历 key值
for x in d: