数据类型总结（二）（列表，元组，字典）

x=1
a=10
b=10
#
#链式赋值
a=b=c=d=e=f=10
print(a,b,c,d,e,f)


#多元赋值
#方式一
x=1
y=2

z=x #z=1
x=y #x=2
y=z #y=1
print(x,y)
#方式二：python特有
x,y=y,x
print(x,y)

#增量赋值
x=10
x+=1 #x=x+1
print(x)



#解压序列类型
s='hello'
a=s[0]
b=s[1]
c=s[2]
d=s[3]
e=s[4]
print(a,b,c,d,e)
a,b,c,d,e=s
print(a,b,c,d,e)

a,_,_,_,e='alexs'
print(a,e)
print(_)


a,*_,e='alexs'
print(a,e)


m,n,*_='alexs'
print(m,n)

*_,m,n='alexs'
print(m,n)

#1.用list的extend方法,L1.extend(L2)，该方法将参数L2的全部元素添加到L1的尾部，例如：

L1 = [1, 2, 3, 4, 5]
L2 = [20, 30, 40]
L1.extend(L2)
print(L1)  #[1, 2, 3, 4, 5, 20, 30, 40]

#2.用切片(slice)操作，L1[len(L1):len(L1)] = L2和上面的方法等价，例如：

L1 = [1, 2, 3, 4, 5]
L2 = [20, 30, 40]
L1[len(L1):len(L1)] = L2
print(L1)   #[1, 2, 3, 4, 5, 20, 30, 40]

#但切片方法用起来更灵活，可以插入到头部，或其他任意部位，例如：
加到开头：

L1 = [1, 2, 3, 4, 5]
L2 = [20, 30, 40]
L1[0:0] = L2
print(L1)   #[20, 30, 40, 1, 2, 3, 4, 5]

#3加到中间：

L1 = [1, 2, 3, 4, 5]
L2 = [20, 30, 40]
L1[1:1] = L2
print(L1)   #[1, 20, 30, 40, 2, 3, 4, 5]

#定义列表
# l=[1,'a',[3,4]]  #l=list([1,'a',[3,4]])

#取值
# print(l[0])
# print(l[2][0])
#
# l=[1,2,[['a','b'],'c']]
# print(l[2][0][1])

#循环
l=[1,2,3,[4,5]]

# count=0
# while count < len(l):
#     print(l[count])
#     count+=1


# for count in range(len(l)):
#     print(l[count])
# l=[1,2,3,[4,5]]
# for count in range(len(l)):
#     if type(l[count]) is list:
#         #pass
#         for i in range(len(l[count])):
#             print(l[count][i])
#     else:
#         print(l[count])



# l=[1,2,3,[4,5]]
# l_size=len(l)
# for index in range(l_size):
#     value=l[index]
#     if type(value) is list:
#         #value是列表,value=[4,5]
#         for i in range(len(value)):
#             print(value[i])
#     else:
#         #value不是列表，直接打印
#         print(value)




#
# print('没有修改之前的列表：',id(l),type(l),l)
#

#id不动，type也不动，value被修改了，则称为可变类型
#可变指的是：在id和type不动的前提下，值可变

# print(l[0])
# print(l[2][1])
# l[0]=11111111111111111
# print(l)
# print('修改之后的列表：',id(l),type(l),l)



#列表常用操作
# 索引
# 切片
# l=['ab',1,2,'hello']
# print(l[1:3]) #切片操作是读操作，并不会修改原来的数据
# print(l)

# 追加
# l=['ab',1,2,'hello']
# print(l)
# l.append('alex')
# l.append('alex1')
# l.append('alex2')
# l.append('alex3')
# print(l)
# 插入
# l.insert(0,'first')
# print(l)
# l.insert(2,'abc')
# print(l)
# 删除
# l=['a','b','c','hello']
# print(l)
# l.pop(1)
# print(l)
# l.pop()
# l.pop()

# l.pop(0)
# l.pop(0)
# print('刚刚删除的元素是',l.pop(0))
#
# print(l)


#队列：先进先出
l=[]
#append与pop(0)
#入队列
# l.append('people1')
# l.append('people2')
# l.append('people3')
# print(l)
#出队列
# print(l.pop(0))
# print(l.pop(0))
# print(l.pop(0))

#insert(0,item)
#入队
l.insert(0,'people1')
l.insert(0,'people2')
l.insert(0,'people3')
# print(l)

#出队
# print(l.pop())
# print(l)
# print(l.pop())
# print(l)
# print(l.pop())

#堆栈：先进后出,或者说后进的先出
#append与
# l=[]
# l.append('people1')
# l.append('people2')
# l.append('people3')
# print(l)


# print(l.pop())
# print(l.pop())
# print(l.pop())

# 长度

l=[1,2,3]

# print(len(l))

# 切片
# 循环
# 包含
# s='alex is sb'
# print('sb' in s)
#
# names=['alex','egon','yuanhao']
# print('yuanhao' in names)



#列表的其他操作
l=list(['a1','a2','a3'])

# print(l)
# print(l.index('a2'))
#
# l.append('a2')
# print(l.count('a2'))
# print(l)
# l.extend([1,2,3])
# l.append([1,2,3])
# print(l)

# print(l)
# l.remove('a2')

# l=['a1','a2','a1','a1','a3']
# l.remove('a1')
# print(l)

# l=[2,3,1]
# l.sort(reverse=True)
# print(l)

# l=['a','c','alex']
# l.reverse()
# print(l)

# l=[1,2,3] #l=list([1,2,3])
# print(type(l))

#pat1===》优先掌握部分
# 　索引
#
# 　　　　切片
l=['a','b','c','d','e','f']

# print(l[1:5])
# print(l[1:5:2])
# print(l[2:5])
# print(l[-1])


#了解
# print(l[-1:-4])
# print(l[-4:])
# l=['a','b','c','d','e','f']
# print(l[-2:])

# 　　　　追加
# hobbies=['play','eat','sleep','study']
# hobbies.append('girls')
# print(hobbies)

# 　　　　删除
hobbies=['play','eat','sleep','study']
# x=hobbies.pop(1) #不是单纯的删除，是删除并且把删除的元素返回，我们可以用一个变量名去接收该返回值
# print(x)
# print(hobbies)

# x=hobbies.pop(0)
# print(x)
#
# x=hobbies.pop(0)
# print(x)

#队列：先进先出
queue_l=[]
#入队
# queue_l.append('first')
# queue_l.append('second')
# queue_l.append('third')
# print(queue_l)
#出队
# print(queue_l.pop(0))
# print(queue_l.pop(0))
# print(queue_l.pop(0))


#堆栈:先进后出，后进先出
# l=[]
# #入栈
# l.append('first')
# l.append('second')
# l.append('third')
# #出栈
# print(l)
# print(l.pop())
# print(l.pop())
# print(l.pop())

#了解
# del hobbies[1] #单纯的删除
# hobbies.remove('eat') #单纯的删除，并且是指定元素去删除


# 　　　　长度
# hobbies=['play','eat','sleep','study']
# print(len(hobbies))

# 　　　　包含in
# hobbies=['play','eat','sleep','study']
# print('sleep' in hobbies)

# msg='hello world egon'
# print('egon' in msg)


##pat2===》掌握部分
hobbies=['play','eat','sleep','study','eat','eat']
# hobbies.insert(1,'walk')
# hobbies.insert(1,['walk1','walk2','walk3'])
# print(hobbies)

# print(hobbies.count('eat'))
# print(hobbies)
# hobbies.extend(['walk1','walk2','walk3'])
# print(hobbies)

hobbies=['play','eat','sleep','study','eat','eat']
# print(hobbies.index('eat'))


#pat3===》了解部分
hobbies=['play','eat','sleep','study','eat','eat']
# hobbies.clear()
# print(hobbies)

# l=hobbies.copy()
# print(l)

# l=[1,2,3,4,5]
# l.reverse()
# print(l)

l=[100,9,-2,11,32]
l.sort(reverse=True)
print(l)

#为何要有元组，存放多个值，元组不可变，更多的是用来做查询
t=(1,[1,3],'sss',(1,2)) #t=tuple((1,[1,3],'sss',(1,2)))
# print(type(t))


# #元组可以作为字典的key
# d={(1,2,3):'egon'}
# print(d,type(d),d[(1,2,3)])



# 　索引
#
# 　　　　切片
# goods=('iphone','lenovo','sanxing','suoyi')
# print(goods[1:3])


#
# 　　　　长度
#
#in:
#字符串:子字符串
#列表：元素
#元组：元素
#字典：key

# goods=('iphone','lenovo','sanxing','suoyi')
# print('iphone' in goods)

# d={'a':1,'b':2,'c':3}
# print('b' in d)



#掌握
# goods=('iphone','lenovo','sanxing','suoyi')
# print(goods.index('iphone'))
# print(goods.count('iphone'))


#补充：元组本身是不可变的，但是内部的元素可以是可变类型
t=(1,['a','b'],'sss',(1,2)) #t=tuple((1,[1,3],'sss',(1,2)))

# t[1][0]='A'
# print(t)
# t[1]='aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'


#元组的元素可以是任意数据类型
t=('a',1,'b',1,(3,4))
# print(id(t),type(t),t)




#元组的特性是：不可变

#取值
# print(t[4][0])

#循环
t=('a',1,'b',1,(3,4))
# index=0
# while index < len(t):
#     print(t[index])
#     index+=1

# for i in range(len(t)):
#     print(t[i])


#tuple类型的方法
# print(t.count(1))
# print(t.index('b'))


#tuple常用操作
# 索引
# 切片
# t=('a',1,'b',1,(3,4))
# print(t[1:3])
# print(t)
# 循环
# 长度
# print(len(t))
# 包含
#
# print('a' in t)



#元组的特性是：不可变,元组的元素可以是任意数据类型
# t=(1,2,['a','b'])
# print(id(t),type(t),t)

# t[2][0]='aaaaaaa'
# print(t)
# print(id(t),type(t),t)

# t[2]=3
# t[2][0]=123123123123




#评论

# comments=[('真傻比',),('确实傻逼',)]
# print(comments)
# # comments.pop(0)
# comments[0]='真牛逼'
# print(comments)

#字典的常用方法
d={'x':1,}

# d.clear()
# print(d)

# print(d['x'])
# print(d['y'])
# print(d.get('y'))
# print(d.get('y','找不到的啦'))
# print(d.get('x','找不到的啦'))


d={'x':1,'y':1}
# print(d.items())

# for item in d.items(): #[('x', 1), ('y', 1)]
#     print(item)

# for k,v in d.items(): #[('x', 1), ('y', 1)]
#     print(k,v)

# d={'x':1,'y':1}
# print(d.keys())

# for i in d.keys():
#     print(i)

# for i in d:
#     print(i)



d={'x':1,'y':1}
# print(d.keys(),type(d.keys()))
#
# res=list(d.keys())
# print(res,type(res))

d={'x':1,'y':12222}
# print(d.values())
# print(list(d.values()))
# print(list(d.values())[1])


# res=d.pop('y')
# print(res)
#
# print(d)


# d={'x':1,'y':12222}
# print(d.pop('z','没有的啦'))


#
# d={'x':1,'y':12222}
# print(d.popitem())
# print(d)

# d={'x':1,'y':12222}
#
# # d.setdefault('z',3)
# # print(d)
#
# # d['name']='egon'
# # print(d)
#

# d={'x':1,'y':12222}
# print(d.setdefault('x',3333333333333333333333333333))
# print(d)


# d1={}
# d2=dict()
# print(d1,d2)
#
# d3=dict(x=1,y=2,z=3)
# print(d3)
#
#
# d4=dict({'x':1,'y':2,'z':3})
# print(d4)
#
#
#
# d5=dict([('x',1),('y',2),('z',3)])
# print(d5)
#
#
# d6={}.fromkeys(['name','age'],None)
# print(d6)
#
# d7={}.fromkeys(['name','age'],['egon',18])
# print(d7)


#
# d={'name':'alex','sex':'male'}
#
# d1={'name':'alexsb','age':50}
# d.update(d1)
# print(d)




#新增

d={}
d['x']=1
print(d)

# 删除
# d.pop('x')
# d.popitem()
# 键、值、键值对
# d.keys()
# d.values()
# d.items()

# 循环

# 长度
#
# d={'x':1,'u':2}
# print(len(d))


# #成员运算
# d={'x':1,'u':2}
#
# print('x' in d)
# print(1 in d.values())

#字典定义的基本形式：key:value
# d={'name':'egon','age':18} #d=dict({'name':'egon','age':18})
#
# print(id(d),type(d),d)
#定义字典需要注意的问题：key必须是不可变类型，或者说是可hash类型
# print(hash(1))
# print(hash('xxxxxx'))
# print(hash((1,2,3)))

# print(hash({'a':1}))

d={1:'id','a':1,'b':2,'name':'egon',(1,2):'aaaaaaaa'}

#字典的取值,字典是无序的
# print(d[1])
# print(d['name'])
# print(d[(1,2)])




# d={'name':'alex','age':18}
# print(d['name'])
# d['name']='aaaaasb'
# print(d)

#循环
d={'name':'alex','age':18,'sex':'male','height':130,'weight':200}
# print(d.keys())
# print(d.values())
# print(type(d.keys()))

# for k in d:
    # print(k,d[k])


# l=[1,2,3]
# for i in l:
#     print(i)


# t=(1,2,3)
# for i in t:
#     print(i)

# s='hello'
# for i in s:
#     print(i)

'''
一：可变不可变
    可变：列表，字典
    不可变：数字，字符串，元组

二：存放值的个数
    一个值：数字，字符串
    多个值(容器类型)：列表，元组，字典

三：取值方式
    直接取值：数字
    序列类型：字符串，元组，列表
    映射类型：字典
'''

#字典的嵌套使用

# d={'a':1}
# print(d['b'])
# print(d.get('a'))

# user_info=[
#     {'username':'egon','password':'123'},
#     {'username':'alex','password':'alex3714'},
#     {'username':'yuanhao','password':'sb123'},
# ]
# for item in user_info:
#     print(item['username'],item['password'])


# tag=True
# while tag:
#     user=input('u>>: ')
#     pwd=input('p>>: ')
#     for item in user_info:
#         if user == item['username'] and pwd ==item['password']:
#             print('login ok')
#             tag=False
#             break


# user_info=[
#     {'username':'egon','password':'123'},
#     {'username':'alex','password':'alex3714'},
#     {'username':'yuanhao','password':'sb123'},
# ]

user_dic={
    'egon':'123',
    'alex':'alex3714',
    'yuanhao':'sb123'
}
# print('egon' in user_dic)
while True:
    user=input('u>>: ')
    pwd=input('p>>: ')
    if user in user_dic:
        if pwd == user_dic[user]:
            print('login ok')
            break




    # if user == 'egon' and pwd == '123':
    #     print('login ok')
    #     break

a={'k1':[],'k2':[]}
c=[11,22,33,44,55,66,77,88,99,90]
for i in c:
    if i>66:
        a['k1'].append(i)
    else:
        a['k2'].append(i)
print(a)

s='hello alex alex say hello sb sb'

l=s.split()
dic={}
for item in l:
    if item in dic:
        dic[item]+=1
    else:
        dic[item]=1
print(dic)

s='hello alex alex say hello sb sb'
dic={}
words=s.split()
print(words)
for word in words: #word='alex'
    dic[word]=s.count(word)
    print(dic)


#利用setdefault解决重复赋值
'''
setdefault的功能
1：key存在，则不赋值，key不存在则设置默认值
2：key存在，返回的是key对应的已有的值，key不存在，返回的则是要设置的默认值
d={}
print(d.setdefault('a',1)) #返回1

d={'a':2222}
print(d.setdefault('a',1)) #返回2222
'''
s='hello alex alex say hello sb sb'
dic={}
words=s.split()
for word in words: #word='alex'
    dic.setdefault(word,s.count(word))
    print(dic)



#利用集合，去掉重复，减少循环次数
s='hello alex alex say hello sb sb'
dic={}
words=s.split()
words_set=set(words)
for word in words_set:
    dic[word]=s.count(word)
    print(dic)

# 有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}
linuxs={'wupeiqi','oldboy','gangdan'}
# 求出即报名python又报名linux课程的学员名字集合
print(pythons & linuxs)
# 求出所有报名的学生名字集合
print(pythons | linuxs)
# 求出只报名python课程的学员名字
print(pythons - linuxs)
# 求出没有同时这两门课程的学员名字集合
print(pythons ^ linuxs)

l=[    {'name':'egon','age':18,'sex':'male'},    {'name':'alex','age':73,'sex':'male'},    {'name':'egon','age':20,'sex':'female'},    {'name':'egon','age':18,'sex':'male'},    {'name':'egon','age':18,'sex':'male'},]

#去重,无需保持原来的顺序
l=['a','b',1,'a','a']
print(set(l))

#去重,并保持原来的顺序
#方法一:不用集合
l=[1,'a','b',1,'a']

l1=[]
for i in l:
    if i not in l1:
        l1.append(i)
print(l1)
#方法二:借助集合
l1=[]
s=set()
for i in l:
    if i not in s:
        s.add(i)
        l1.append(i)

print(l1)


#同上方法二,去除文件中重复的行
import os
with open('db.txt','r',encoding='utf-8') as read_f,\
        open('.db.txt.swap','w',encoding='utf-8') as write_f:
    s=set()
    for line in read_f:
        if line not in s:
            s.add(line)
            write_f.write(line)
os.remove('db.txt')
os.rename('.db.txt.swap','db.txt')

#列表中元素为可变类型时,去重,并且保持原来顺序
l=[
    {'name':'egon','age':18,'sex':'male'},
    {'name':'alex','age':73,'sex':'male'},
    {'name':'egon','age':20,'sex':'female'},
    {'name':'egon','age':18,'sex':'male'},
    {'name':'egon','age':18,'sex':'male'},
]
# print(set(l)) #报错:unhashable type: 'dict'
s=set()
l1=[]
for item in l:
    val=(item['name'],item['age'],item['sex'])
    if val not in s:
        s.add(val)
        l1.append(item)

print(l1)






#定义函数,既可以针对可以hash类型又可以针对不可hash类型
def func(items,key=None):
    s=set()
    for item in items:
        val=item if key is None else key(item)
        if val not in s:
            s.add(val)
            yield item

print(list(func(l,key=lambda dic:(dic['name'],dic['age'],dic['sex']))))