数据类型总结之列表字典

# 列表list(可迭代)
# 用途：用来存放多个值，根据索引存取值
# 定义：在[]内用逗号分隔开多个任意类型的值
# l=['egon','name','yxx']  #l=list['egon','name','yxx']
# ls=['hello']#list 就相当于调用了一个for循环，依次从里面取出h e l l o
# print(ls)
# ls=[123123]
# print(ls)
# ls=[{'x':1,'y':2}]
# print(ls)
# print(list(1000)) #报错 'int' object is not iterable
# 总结：存放多个值，可变类型，有序
# 可变不可变

# l=[1,2,3,4,'a','f']
# print(id(l))#2042813178504
# l[2]='v'
# print(id(l))#2042813178504
# 在改变原值的情况下，列表的id并没有发生改变，说明原值是可以发生改变的，就是可变类型

# 常用操作+内置方法
# 优先掌握的操作

# 1.按照索引取值，可反向可正向，即可存也可取  #特点是即可存也可取，还可以修改值
# l=['egon','name','age']
# print(l[0])#egon
# l[0]='sybil'
# print(l)#['sybil', 'name', 'age']
# print(l[-1])#age
# print(l[3])#list index out of range
# l[0]='Egon'#只能根据已经存在的索引去该值，如果索引不存在会报错


# 2.如果要往列表里面加值，就得用到加值操作      追加：append
# l=['egon','name','age']
# l.append(2222)
# l.append(['dfas'])
# print(l)#append 是将所加的值默认放在了最后面


# 3.插入：insert（索引位置，要添加的值）# 索引必须放在前面 往指定索引前面插入  如果要将值放在前面，不想要追加，那我们可以选用插入，就是将值插到指定位置
# l=['egon','name','age']
# l.insert(2,['fdsafas'])
# l.insert('ggu','fasfas')#'str' object cannot be interpreted as an integer
# print(l)

# 3.删除
# l=['name','age','sex']
# 单纯删除值   del ,remove
# del 是一种通用的删除操作，将所有东西删掉
# del l[0]
# print(l)#['age', 'sex']
# remove  列表独有的删除操作，没有返回值，可以指定删除值
# res=l.remove('sex')#必须指定要删除的值
# print(res)#None ,说明没有返回值
# print(l)#打印列表发现已经删除，可以指定删除

# 拿走，不是删除，需要返回值，pop
# 需求：从列表拿走一个值，拿走要删除的值
# l.pop()#按照索引删除
# res=l.pop(-1)#sex  返回删除的那个值
# l.pop()#不指定默认从末尾删除
# print(l)#['name', 'age']
# print(res)
# print(l)#['name', 'age']  已经将值删掉


# 4.切片：从一个大列表中切除一个子列表(顾头不顾尾)
# l=['egon','fse','dfasf','fsgdg',2341,4234213,5345]
# print(l[0:5])#（起始位置：所切范围：所切步数）
# print(l[0:4:2])#列表的取值
# print(l)#值还是原来的没有发生改变，所以不是删除
# print(l[::-1])#列表的翻转


# 5.长度len
# l=['egon','fse','dfasf','fsgdg',[123213],2341,4234213,5345]
# print(len(l))#8


# 6.成员运算，判断一个元素是否在列表中
# print('lxx' in l)#False
# print('egon' not in l) #False
# 对于字符串来说是判断一个子字符串是否存在字符串中，列表判断的是一个元素是否在列表中


# 7.循环
# for item in l:
#     print(item)#取出的是每一个元素
# 需要掌握的操作
# l=['egon','fse','dfasf','fsgdg',[123213],2341,2341,2341]

# 1.count，统计列表中元素重复的个数
# print(l.count(2341))#3个
# print(l.count('egon'))#1个


# 2.index，找索引的
# print(l.index('egon'))#0  第一个索引位置
# print(l.index(2341))#5,不指定找到的是第一个元素的索引
# print(l.index(2341,0,1))#可以指定范围，不存在就会报错


#3.clear  清空，没有返回值
# l.clear()
# print(l.clear())#None
# print(l)#[]清空列表，没有返回值


# 4.extend，没有返回值，单纯往列表里面加值

# l.extend('可迭代对象')#就相当于一个for循环，往列表里面加值
# items=['a','b','c']
# for item in items:
#     l.append(item)
# print(l)
# l.extend(['a','b','c'])#一行就相当于上面的三行
# print(l)
# l.extend('afsa')
# print(l)



# 5.reverse()反转
# l=['egon','fse','dfasf','fsgdg',[123213],2341,2341,2341]
# l.reverse()
# print(l)#[2341, 2341, 2341, [123213], 'fsgdg', 'dfasf', 'fse', 'egon']

# 6.sort()排序,从小到大排序  底层原理就是比大小
# nums=[3,5,9,6,8,9]
# nums.sort()
# print(nums)#[3, 5, 6, 8, 9, 9]
# nums.sort(reverse=True)#reverse=True 就是反过来从大到小排序
# nums.sort(reverse=False)#从小到大排序
# print(nums)


# nums=['a','b',132,435,[1,2,3],{'a':1,'b':2}]
# nums.sort()
# print(nums)# '<' not supported between instances of 'int' and 'str'
# 报错的原有是字符串不可以和列表比大小

# 队列：先进先出
# l=[]
# 入栈
# l.append('sdfds')
# l.append('dfasdfds')
# l.append('dfasdfsddsf')
# print(l)#['sdfds', 'dfasdfds', 'dfasdfsddsf']
# 出栈
# l.pop(0)#pop后面的内容是索引位置
# l.pop(0)
# l.pop(0)
# print(l)#[]

# 堆栈：先进后出
# l=[]
# 入栈
# l.append('one')
# l.append('two')
# l.append('thire')
# print(l)#['one', 'two', 'thire']
# 出栈
# l.pop(-1)
# print(l)#['one', 'two']
# l.pop(-1)
# l.pop(-1)
# print(l)#[]

# 元组tuple
# 用途:当成不可变的列表，记录多个值，多个值没有改的需求，用元组更合适

# 定义：在（可迭代对象）内逗号分隔开多个任意类型的值
# t=(1,2,3,'sss',[231],{'a':1,'b':2})
# print(t,type(t))
# t=tuple('anvsd')
# print(t)#('a', 'n', 'v', 's', 'd'),，直接for循环将里面的元素一个一个取出，加到元组中
# t=tuple({'a':1,'b':2})
# print(t)#('a', 'b')
# 总结：可以存放多个值，不可变类型，有序
# 可变不可变：0号索引对应的内存地址，不可变指的是内存地址可变，可变指的是内存地址不可变
# 常用操作+内置方法
# 同列表一样
# 1.按照索引取值：只能取不能改(针对元组内容不可改，但是元组里面如果有可变类型，可变类型的值可以发生改变)
# t=(1,2,3,'sss',[231,234],{'a':1,'b':2})
# t[0]='4'
# print(t)#不可以改'tuple' object does not support item assignment
# t[4][1]="abc"
# print(t)#(1, 2, 3, 'sss', [231, 'abc'], {'a': 1, 'b': 2})


# 2.切片（索引起始位置：索引全部位置，步长）

# 3.长度len


# 4.成员运算in和not in

# 5.循环for循环针对的是可迭代对象

# 需要掌握的操作
# count，index
# t=('a','b','c','d','a')
# print(t.index('a',10))# x not in tuple
# print(t.index('xxx',1,10))#x not in tuple
# print(t.count('a'))#元组里面a的个数是2个
# print(t.index('c'))#索引对号位置是2


# 字典dict：
# 用途：用来记录多个值，每一个值都有key对应value
# 定义：在{}内用逗号分隔开多个key:value这种元素，value可以是任意类型，key必须是不可变类型（str类型，具有描述作用）

# dic={0:'aaa',1:'dsfs',2:'dfsd'}
# print(dic[0]) #不知道的人以为是索引位置
# dic={['a',2]:'aas'}
# print(dic)#unhashable type: 'list'  不可hash及时可变类型
# dic={'name':12,'age':'df'}
# print(dic)#可以用，因为字符串为不可变类型
# dic={(1,2,3):123,('abc'):'avv'}
# print(dic)#也可以，元组为不可变类型
# print(dic[(1,2,3)])#取值的话直接就是dic[key],取得就是value

# 快速生成字典
# dic=dict(a=1,b=2,c=3)
# print(dic)#{'a': 1, 'b': 2, 'c': 3}

#还可以用这种方式
# dic=dict([['name','egon'],['age',28]])
# print(dic)#在dict的括号里面可以放（大列表套个小列表[[],[]])

# dic=dict([[123,'abc'],[453,'afs']])
# print(dic)#{123: 'abc', 453: 'afs'}

# userinfo=[['name','egon'],['age',28],['sex','male']]
# dic={}
# # for k,v in userinfo:
# #     print(k,v)
# #     dic[k]=v
# # print(dic)#{'name': 'egon', 'age': 28, 'sex': 'male'}
# for item in userinfo:
#     print(item) #['name', 'egon']  ['age', 28]  ['sex', 'male']
#     k=item[0],v=item[1]
#     dic[k]=v
# print(dic)#['name', 'egon']
# dic=dict(userinfo)#dict本质上就是一个for循环，就是将里面的值一个一个取出，添加到字典
# print(dic)#{'name': 'egon', 'age': 28, 'sex': 'male'}
# 总结：存放多个值，用key:value对应存放，无序，可变
# 可变不可变
# 常用操作+内置方法

# 优先掌握的操作

# 1.按照key存取值：可存可取
# dic={'name':'egon'}
# print(dic['name']) #egon
# dic['name']='Egon'
# print(dic) #{'name': 'Egon'}
# dic['age']=18#但是字典不会，不存在直接添加
# print(dic)#{'name': 'egon', 'age': 18}
# l=['a','b']#列表取值不存在就会报错，不会将值添加到列表中
# l[0]='A'
# l[2]='c'#list assignment index out of range
# print(l)


# ***** 列表与字典区别是都是可以取值，但是列表是按照索引取值，字典是按照key:value取值
# 列表和字典都可以改变里面的元素，但是列表不能修改里面没有的元素，字典如果里面的元素没有，
# 那么就会直接添加


# 2.长度len
# dic={'name':'egon','age':18,'name':'EGON','name':'lxx'}
# print(dic)#{'name': 'lxx', 'age': 18}
# print(len(dic))#2,想像成不重复的key的元素


# 3.成员运算in 和not in
# dic={'name': 'lxx', 'age': 18}
# 对于字典来说成员运算判断的是key,列表（元素）元组（元素）字符串（子字符串）
# print(18 in dic) #False
# print('age' in dic)#True
# 所以字典成员运算判断就是key


# 4.删除（key不存在就会报错）
# 通用删除，del没有返回值
# dic={'name': 'lxx', 'age': 18}
# del 是一种通用的删除
# del dic['name'] #指定key删除
# print(dic)
# 字典自带的删除
# clear  pop
#                       pop(key)
# res=dic.pop('name')
# print(res)#lxx  有返回值 返回的是value
# print(dic)#{'age': 18}
# res=dic.pop('sex')
# print(res) #删除不存在的值会报错
# print(dic)
# res=dic.popitem()#随即删除
# print(res)#('age', 18) 返回的值是一个元组，第一个是key,第二个是value



# 5.键keys（），值values（），键值对items（）
# 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)])
# 单独取key
# l=[]
# for k in dic.keys():
#     l.append(k)
# print(l) #['name', 'age']
# print(list(dic.keys()))
# 单独取value
# print(list(dic.values()))
# 取key,value
# print(list(dic.items()))

#6.循环
# dic={'name':'egon','age':18}
# for k in dic.keys():#取key
#     print(k,dic[k])
# for k in dic:#for循环不加.keys默认也是取key值
#     print(k,dic[k])
# for v in dic.values():#取values
#     print(v)
# for k,v in dic.items():取key,value
#     print(k,v)

#需要掌握的操作
# dic={'name':'egon','age':18}
#**************get  不会报错，返回None
# dic['xxx']#会报错
# print(dic)
# v=dic.get('xxx')
# print(v) #None,不会报错
# v=dic.get('name')
# print(v) #egon 有返回值
# print(dic)#{'name': 'egon', 'age': 18}
# dic={'name':'egon','age':18}


# formekeys的用法
# dic.fromkeys()#快速初始化
# l=['name','egon','sex']
# 需求
# dic={'name':None,'age':None,'sex':None}
# dic={}
# for k in l:
#     dic[k]=None
# print(dic)#可以实现需求
# dic=dic.fromkeys(l,123)#一行代码搞定上面的三行代码
# print(dic)#{'name': 123, 'egon': 123, 'sex': 123}
# dic=dic.fromkeys(l,None)
# print(dic)


# update()的用法   更新
# dic={'name': 'egon', 'age': 18}
# dic['sex']='male'#直接添加
# print(dic)
# new_d={'name':'EGON','x':1,'y':2}
# dic.update(new_d)
# print(dic)




# setdefault 的用法
# 1.有则不动，返回原值，无则添加，返回新值（针对的是key）
# dic={'name': 'egon', 'age': 18}
# dic.setdefault('name','egon')#字典中已经存在的key,返回已经存在key的vallue
# print(dic)
# dic.setdefault('name','EGON')
# print(dic)
# dic.setdefault('sex','male')#字典中不存在key,则添加'sex'：'male',返回已经存在的key对应的value
# print(dic)