专栏首页Python数据类型总结(二)(列表,元组,字典)

数据类型总结(二)(列表,元组,字典)

一.变量的赋值操作

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.可存放多个值 2.可修改指定索引位置对应的值,可变 3.按照从左到右的顺序定义列表元素,下标从0开始顺序访问,有序 用途(存多个值,可以修改):爱好,装备,女朋友们 hobby=['play','eat','sleep'] 方法: hobby.append hobby.remove 操作: 查看: >>> girls=['alex','wsb',['egon','ysb']] >>> girls[2] ['egon', 'ysb'] >>> girls[2][0] 增加 girls.append(元素) 删除 girls.remove(元素) del girls[元素的索引] 修改 girls[0]='alexSB'

列表的拼接:

#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)

三.元组

作用:存多个值,对比列表来说,元组不可变,主要是用来读

  定义:与列表类型,只不过[]换成()

    可以当做字典的key

    age=(11,22,33,44,55)本质age=tuple((11,22,33,44,55))

  常用操作:

    索引

    切片

    循环

    长度

    包含in

#为何要有元组,存放多个值,元组不可变,更多的是用来做查询
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)

四.字典

用途:存多个值,这一点与列表相同,值可以是任意数据类型 特征:每一个值都一个唯一个对应关系,即key,强调一点,key必须是 不可变类型:字符串,数字,元组,集合 student_info={ 'age':81, 'name':'alex', 'sex':None, 'hobbies':['zsb0','zsb1','zsb2','zsb30'] } 操作: 查看 >>> student_info={ ... 'age':81, ... 'name':'alex', ... 'sex':None, ... 'hobbies':['zsb0','zsb1','zsb2','zsb30'] ... } >>> >>> student_info['age'] 81 >>> student_info['hobbies'] ['zsb0', 'zsb1', 'zsb2', 'zsb30'] >>> student_info['hobbies'][2] 'zsb2' 增加 student_info['stu_id']=123456 删除 del student_info['stu_id'] 修改 student_info['name']='alexSB'

#字典的常用方法
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

 练习

  1 有如下值集合 [11,22,33,44,55,66,77,88,99,90...],将所有大于 66 的值保存至字典的第一个key中,将小于 66 的值保存至第二个key的值中。(2分)

  即: {'k1': 大于66的所有值, 'k2': 小于66的所有值}

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)

2 统计s='hello alex alex say hello sb sb'中每个单词的个数

  结果如:{'hello': 2, 'alex': 2, 'say': 1, 'sb': 2}

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)

五.集合

作用:去重,关系运算,

知识点回顾

可变类型是不可hash类型 不可变类型是可hash类型

定义集合:

集合:可以包含多个元素,用逗号分割,

集合的元素遵循三个原则:

1:每个元素必须是不可变类型(可hash,可作为字典的key)

2:没有重复的元素

3:无序 注意集合的目的是将不同的值存放到一起,不同的集合间用来做关系运算,无需纠结于集合中单个值

常用方法:

    in 和 not in

    |合集

    &交集

    -差集

    ^对称差集

    ==

    >,>= ,<,<= 父集,子集

  练习:

  一.关系运算   有如下两个集合,pythons是报名python课程的学员名字集合,linuxs是报名linux课程的学员名字集合   pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}   linuxs={'wupeiqi','oldboy','gangdan'}   1. 求出即报名python又报名linux课程的学员名字集合   2. 求出所有报名的学生名字集合   3. 求出只报名python课程的学员名字   4. 求出没有同时这两门课程的学员名字集合

# 有如下两个集合,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)

二.去重

   1. 有列表l=['a','b',1,'a','a'],列表元素均为可hash类型,去重,得到新列表,且新列表无需保持列表原来的顺序

 2.在上题的基础上,保存列表原来的顺序

   3.去除文件中重复的行,肯定要保持文件内容的顺序不变    4.有如下列表,列表元素为不可hash类型,去重,得到新列表,且新列表一定要保持列表原来的顺序

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']))))

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • Python 操作redis有序集合(sorted set)

    Zadd 命令用于将一个或多个成员元素及其分数值加入到有序集当中。 如果某个成员已经是有序集的成员,那么更新这个成员的分数值,并通过重新插入这个成员元素,来保证...

    用户1214487
  • Python常见数据结构整理 Python常见数据结构整理

    Python常见数据结构整理 Python中常见的数据结构可以统称为容器(container)。序列(如列表和元组)、映射(如字典)以及集合(set)是三类主要...

    用户1214487
  • 浅淡python中with的用法,上下文管理器

    例子一 首先来看一段代码: class Foo(object): def __init__(self): print('实例化一个对象...

    用户1214487
  • python %r %s %d 用法和区

    %可以理解为就是一个占位符。 python中用%代表格式符,表示格式化操作,常用的操作有%s,%d,%r等. %r用rper()方法处理对象 %s用str()方...

    py3study
  • python学习(day4)

    py3study
  • python3(元组,列表,集合,字典)

    1.列表 1)创建列表 数组:存储同一种数据类型的集合 scores=[12,13,14] 列表:(打了激素的数组):可以存储任意数据类型的集合

    py3study
  • 【专业技术】linux下如何打造一个最简单的Makefile

    相信在linux下编程的没有不知道makefile的,刚开始学习unix平台 下的东西,了解了下makefile的制作,觉得有点东西可以记录下。   下...

    程序员互动联盟
  • 建议你吃透这68个内置函数!

    内置函数就是Python给你提供的, 拿来直接用的函数,比如print,input等。截止到python版本3.6.2 ,一共提供了68个内置函数,具体如下?

    全栈自学社区
  • python 文件

    #写进文件 myfile = open('myfile.txt', 'w') myfile.write('hello textfile\n') myfile.w...

    py3study
  • python3--列表推导式,生成器表达式,内置函数

    3,python不但使用迭代器协议,让for循环变得更加通用,大部分内置函数,也是使用迭代器协议访问对象的,例如sum函数是python的内置函数,该函数使用迭...

    py3study

扫码关注云+社区

领取腾讯云代金券