Python学习(四)列表、元组、字典、集合

1.列表的应用场景

        一个变量一次性可以存储一个数据,多个数据要一次性存储则使用列表。

列表可以一次性存储多个数据,且可以为不同的数据类型。但一般存储相同类型(为了后期好控制)

2.列表的格式

        [数据1,数据2,数据3....]

3.列表的常用操作

        3.1查找

                3.1.1下标

a=['tom','cat','pig','dog']
print(a[2])
#结果
pig

                3.1.2函数

        语法:列表序列.index(数据,开始位置下标,结束位置下标)

                index():返回指定数据所在位置的下标

                count():统计指定数据在当前列表中出现的次数

                len():访问列表长度,即列表中数据的个数

a=['tom','cat','pig','dog','sheep','house','ox','tiger']
print(a.index('ox'))
print(a.count('ox'))
print(len(a))
#结果
6#ox的下标位置时6
1#ox出现的次数是1次
8#列表中总共有8个数据

                3.1.3判断是否存在

        in/not in 返回都是bool型,True或False

a=['tom','cat','pig','dog','sheep','house','ox','tiger']
print('tom'in a)
print('a'in a)
print('a'not in a)
#结果
True
False
True

 案例:查找用户输入的名字是否存在

a=['lily','rose','Julia','jack','kangkang','Maria']
name=input('请输入您的名字')
if name in a:
    print(f'您输入的名字是{name},名字已存在')
else:
    print(f'您输入的名字是{name},请继续下一步')

        3.2增加

作用:增加指定数据到列表中

语法:列表序列.append(数据) ,列表序列.extend(数据),列表序列.insert(位置下标,数据)

append(): 如果追加的是一个序列,则将整个序列增加在序列中

a=['lily','rose','Julia','jack','kangkang','Maria']
a.append('jesse')
print(a)
#结果
['lily', 'rose', 'Julia', 'jack', 'kangkang', 'Maria', 'jesse']
#追加一个序列[1,2]
a=['lily','rose','Julia','jack','kangkang','Maria']
name=[1,2]
a.append(name)
print(a)
#结果
['lily', 'rose', 'Julia', 'jack', 'kangkang', 'Maria', [1, 2]]
a=['lily','rose','Julia','jack','kangkang','Maria']
name=input('请输入您的账号名')
if name not in a:
    a.append(name)
    print(f'您输入的账号{name}不存在,已将您账号进行保存如下:',a)
else:
    print(f'您输入的账号已存在,具体情况如下:',a)
#结果
请输入您的账号名jesse
您输入的账号jesse不存在,已将您账号进行保存如下: ['lily', 'rose', 'Julia', 'jack', 'kangkang', 'Maria', 'jesse']

 extend():如果追加的数据是一个序列,则会将这个序列的数据拆开,逐一添加到列表。

a=['lily','rose','Julia','jack','kangkang','Maria']
a.extend('name')
a.extend(['name','haha'])
print(a)
#结果
['lily', 'rose', 'Julia', 'jack', 'kangkang', 'Maria', 'n', 'a', 'm', 'e', 'name', 'haha']
#['name','haha']被拆开,name被拆开

insert(位置下标,数据) 

a=['lily','rose','Julia','jack','kangkang','Maria']
a.insert(1,'jesse')
print(a)
#结果
['lily', 'jesse', 'rose', 'Julia', 'jack', 'kangkang', 'Maria']

        3.3删除

         del():        del目标,可以直接删除列表(del 列表;或者del (列表)),也可以删除指定下标的数据:del[下标位置]

a=['lily','rose','Julia','jack','kangkang','Maria']
del a[1]#删除指定位置的数据,用下标来实现
print(a)
#结果
['lily', 'Julia', 'jack', 'kangkang', 'Maria']

        pop()        删除指定下标的数据,如果不加下标,则是删除最后一个

a=['lily','rose','Julia','jack','kangkang','Maria']
a1=a.pop()
print(a1)
#结果a.pop()没有指定位置,则删除的是最后一个数据;会返回这个被删除的数据
Maria
#指定下标删
a=['lily','rose','Julia','jack','kangkang','Maria']
a1=a.pop(1)
print(a1)
print(a)
#结果
rose
['lily', 'Julia', 'jack', 'kangkang', 'Maria']

        remove()        移除列表中某个数据的第一个匹配项

a=['lily','rose','lily','jack','kangkang','Maria']
a.remove('lily')
print(a)
#结果
['rose', 'lily', 'jack', 'kangkang', 'Maria']

        clear()        清空列表

a=['lily','rose','lily','jack','kangkang','Maria']
a.clear(a)
print(a)

        3.4修改

                (1)逆置:reverse()

a=['lily','rose','lily','jack','kangkang','Maria']
a.reverse()
print(a)
#结果:
['Maria', 'kangkang', 'jack', 'lily', 'rose', 'lily']

                (2)排序:sort(key=None,reverse=False);False表示非逆序,即升序排序;True表示逆序,即降序排序

a=['12','7','3','23','77','33']
a.sort(reverse=True)
print(a)
#结果
['77', '7', '33', '3', '23', '12']

        3.5复制

                函数:copy() 

a=['12','7','3','23','77','33']
b=a.copy()
print(b)
#结果
['12', '7', '3', '23', '77', '33']

4.列表的循环遍历

需求:依次打印列表中的各个数据

        4.1while

a=['tom','maria','rose','jack']
i=0
while i

        4.2 for

a=['tom','maria','rose','jack']
for i in a:
    print(i)
#结果
tom
maria
rose
jack

5.列表的嵌套使用

        就是一个列表里面包含了其他的子列表

应用场景:要存储一、二、三,三个班级学生姓名,且每个班级的学生姓名在一个列表,查找某一个学生姓名

a=[['tom','maria'],['yes','no'],['jack','rose']]
print(a[1][0])
#结果
yes

案例:随机分配办公室——有三个办公室,将8位老师随机分配到这个三个办公室 

#有三个办公室,有8位老师,将这8位老师随机分配到办公室里去
import random  
teachers=['a','b','c','d','e','f','g','h']
offices=[[],[],[]]
for name in teachers:
    num=random.randint(0,2)   #三个列表,所以0-2
    offices[num].append(name)  #将随机在0,1,2的列表中添加name
#办公室i的人数
i=1
for office in offices:   #如果子列表office在offices中,进入循环
    print(f'办公室{i}的老师是:')  #输出办公室的编号i
    for name in office:      #如果人在子列表office中
        print(name)          #输出具体的人名
    i += 1                   #办公室编号加1,继续输出人名
#结果
办公室1的老师是:
d
办公室2的老师是:
c
e
f
g
办公室3的老师是:
a
b
h

6.元组

        元组的应用场景:存储多个数据,但是这些数据是不能修改的数据

a=('a','c','b')    #多个数据的元组
b=('a')
c=('a',)            #单个数据的元组
print(a,type(a))
print((b,type(b)))
print(c,type(c))
#结果
('a', 'c', 'b') 
('a', )             #说明单个数据的元组也要加“,”,不然会变成是这个数据的类型str
('a',) 

7.元组的常见操作

        元组只支持查找操作,统计操作(统计出现次数,统计长度)

a=('a','c','b')
print(a.index('c'))
print(len(a))
print(a.count('b'))
#结果
1        #c在下标为1的位置
3        #a元组总共3个
1        #b出现的次数是1

        元组的数据直接修改是会报错的;但是可以修改元组内列表的数据,但尽量避免修改

a=('a','c','b',['d','e'])
a[3][1]='f'  #修改元组里面列表的数据,将e改为f
print(a)
#结果
('a', 'c', 'b', ['d', 'f'])

8.字典

        8.1.字典的应用场景:有多个数据,存储的位置变换了,不改查找代码也能查到这个数据

字典里面的数据是以键值对形式出现,字典数据和数据顺序没有关系,即字典不支持下标,后期无论数据如何变化,只需要按照对应的键的名字查找数据即可。

        8.2.创建字段的语法

        符号为大括号{},数据为键值对形式出现,各个键值对之间用逗号隔开

        有数据字典:a={'a','b','c'};空字典:a={}

i={'a':'tom','b':'jack','c':'rose'}
w={}
q=dict()
print(i,type(i))
print(w,type(w))
print(q,type(q))
#结果:
{'a': 'tom', 'b': 'jack', 'c': 'rose'} 
{} 
{} 

        8.3.字典的常见操作

                8.3.1增加

        字典序列[key]=值;如果key存在则修改这个key对应的值,如果key不存在则新增此键值对

i={'a':'tom','b':'jack','c':'rose'}
i['hah']='yes'    #不存在,则直接新增
print(i)
i['a']='cat'      #存在,则在之前的基础上修改
print(i)
#结果:
{'a': 'tom', 'b': 'jack', 'c': 'rose', 'hah': 'yes'}#没有hah,直接新增
{'a': 'cat', 'b': 'jack', 'c': 'rose', 'hah': 'yes'}#将a的值tom改为了cat

               8.3.2删除

        del/del();clear()

i={'a':'tom','b':'jack','c':'rose'}
del i['b']# 或者del(i['a'])
print(i)
i.clear()
print(i)
#结果
{'a': 'tom', 'c': 'rose'}    #删除b的键值对
{}        #清空字典

                8.3.3修改

        字典序列[key]=值

        新增和修改的用法是一样的,存在则修改,不存在则新增

i={'a':'tom','b':'jack','c':'rose'}
i['a']='cat'
print(i)
#修改值结果
{'a': 'cat', 'b': 'jack', 'c': 'rose'}

              8.3.4查找

                        8.3.4.1 key值查找:当前查找的key存在,则返回对应的值,否则报错

i={'a':'tom','b':'jack','c':'rose'}
print(i['a'])
print(i['d'])
#结果
tom
Traceback (most recent call last):        #没有就直接报错
  File "D:\工作\python script\字典.py", line 3, in 
    print(i['d'])
KeyError: 'd'

                      8.3.4.2 get()函数查找:如果当前查找的key不存在,则返回第二个参数(默认值),如果省略第二个参数,则返回None

i={'a':'tom','b':'jack','c':'rose'}
print(i.get('a'))
print(i.get('jac'))
print(i.get('jac','找不到'))
#结果
tom
None    #找不到就返回None
找不到    #找不到就返回第二个参数(默认值):找不到

                    8.3.4.3 keys() :查找字典中所有的key,返回可迭代对象

i={'a':'tom','b':'jack','c':'rose'}
print(i.keys())        #查找字典中所有的key,返回可迭代对象
#结果
dict_keys(['a', 'b', 'c'])

                    8.3.4.4 values() :查找字典中所有的值,返回可迭代对象

i={'a':'tom','b':'jack','c':'rose'}
print(i.keys())
print(i.values())        #查找字典中所有的value,返回可迭代对象
#结果
dict_keys(['a', 'b', 'c'])
dict_values(['tom', 'jack', 'rose'])

                    8.3.4.5items():查找字典中所有的键值对,返回可迭代对象

        里面的数据是元组,元组数据1是字典的key,元组数据2是字典的value

i={'a':'tom','b':'jack','c':'rose'}
print(i.keys())
print(i.values())
print(i.items())    #查找字典中所有的键值对,返回可迭代对象,里面的数据是元组
#结果
dict_keys(['a', 'b', 'c'])
dict_values(['tom', 'jack', 'rose'])
dict_items([('a', 'tom'), ('b', 'jack'), ('c', 'rose')])#元组数据1是字典的key,元组数据2是字典的value

        8.4.字典的循环遍历

                8.4.1遍历字典的key

i={'a':'tom','b':'jack','c':'rose'}
print(i.keys())
for key in i.keys():
    print(key)
#结果
dict_keys(['a', 'b', 'c'])
a
b
c

                8.4.2遍历字典的value

i={'a':'tom','b':'jack','c':'rose'}
print(i.values())
for values in i.values():
    print(values)

#结果
dict_values(['tom', 'jack', 'rose'])
tom
jack
rose

                8.4.3遍历字典的键值对

i={'a':'tom','b':'jack','c':'rose'}
for a in i.items():
    print(a)
#结果
('a', 'tom')
('b', 'jack')
('c', 'rose')

                8.4.4遍历字典的键值对(拆包)

i={'a':'tom','b':'jack','c':'rose'}
for key,value in i.items():
    print(f'{key}={value}')
#结果
a=tom
b=jack
c=rose

9.集合

        创建集合使用{}或set();但如果要创建空集合,只能用set(),因为{}是用来创建空字典的

集合里面有重复的会去重

i={1,2,3,4,1,2}    #集合里面有重复的数据
print(i,type(i))
#结果
{1, 2, 3, 4}     #会去重

集合里面是没有顺序的

i={1,2,3,4,6,5}
q={10,34,20,45,50,43}
p={1,2,3,4,5}
w=set('abcdefg')
print(i,type(i))
print(q)
print(p)
print(w)
#结果
{1, 2, 3, 4, 5, 6} 
{34, 50, 20, 10, 43, 45}
{1, 2, 3, 4, 5}
{'d', 'g', 'f', 'c', 'e', 'a', 'b'}

10.集合的常见操作方法

        10.1增加

        1、add(),增加的只能是单一数据,不能是数组,会报错;且增加相同的数据,会去重。

        2、update(),增加的数据是序列,如果写单一数据的话,会报错

i={1,2,3,4,6,5}
q=i.add('hah')
w=i.update([100,'hahaha'])
print(i)
#结果
{1, 2, 3, 4, 5, 6, 'hahaha', 'hah', 100}

        10.2删除数据

        1、pop(),随机删除某个数,如果pop是删除不存在的数据,则会报错 

i={10,20,13,14,16,15}
q=i.pop()
print(i)
#结果
{20, 10, 13, 14, 15}

        2、remove(),指定数删除,如果remove是删除不存在的数据,则会报错 

i={1,2,3,4,6,5}
q=i.remove(2)
print(i)
#结果
{1, 3, 4, 5, 6}

        3、discard(),指定数删除,即是删除的数据不存在,也不会报错

i={10,2,3,4,6,5}
q=i.discard(100)    #删除的数据不存在,也不会报错
print(i)
#结果
{2, 3, 4, 5, 6, 10}

        10.3查找

        in:在集合里;not in :不在集合里;返回的是bool值

i={10,20,13,14,16,15}
print(1 in i)
print(10 in i)
print(10 not in i)
#结果
False
True
False

你可能感兴趣的:(学习,python)