zoukankan      html  css  js  c++  java
  • Python之列表

    一、列表的特点

    • 列表也是一种数据类型
    • 列表元素是有序的,有编号的
    • 列表元素的下标从0开始
    • 列表中的每一个值叫一个元素,编号叫下标(索引/角标):
    stu_name=['崔海龙','杨帆','lrx',1,1.5]

    这里,崔海龙是一个元素,它的索引是0。

    二、列表操作

    1、增删改查操作

    #增:

    使用.append()方法:

    stu_name.append('杨月') #list的末尾追加元素

    使用.insert()方法:

    stu_name.insert(2,'小军')#在指定位置之前添加元素,要指定元素下标
    • 区别:

    .append()是只能追加到list末尾,而.insert()可以指定角标位置。

    • 重复执行一条语句多次,会不会添加多个相同的值?

    # #由于写代码都是在内存中运行的,一旦执行完毕就会释放变量,因此重复执行多次都只插入一个变量值,不会重复插入同样的值。

    # # 列表定义的变量是在内存中执行的,一旦关闭程序就会丢失,而文件则是在磁盘中保存的,关闭程序不会丢失数据。

    • 重复添加多次,会不会添加多个相同的值?

    会。一条语句就是添加一个值:

    stu_name.insert(2,'小军')
    stu_name.insert(2,'小军')
    #结果为[x,x,'小军','小军',x]

     #改:

    直接赋新值,覆盖原值:

    stu_name[5]='孔垂顶'

    #删:

    • 使用.pop()方法:

    .pop()方法默认删的是最后一个元素。

    stu_name.pop()#删除最后一个元素
    stu_name.pop(4)#删除指定下标的元素
    • 使用.remove()方法:
    stu_name.remove('小军')#删除指定的元素,如果有一样的元素,只会删掉第一个
    • 使用del方式:
    del stu_name[-1]#下标从右往左数,-1代表最后一个,-2代表倒数第二个

    区别:

    • .pop()里面是元素的下标,而.remove()里面是元素。
    • .pop()里面如果写的是不存在的下标,则运行会报错。
    • 如果存在多个相同的元素,.remove()只会删除第一个。
    • 如果想删除多个元素,就需要用到列表循环了。

    下标:

    • 下标从右往左数,-1代表最后一个,-2代表倒数第二个;
    • 下标从左往右数,0代表第一个,1代表第2个。


    #查:

    • 指定下标查:
    my_list=['小黑','小白',1,1,2,1.5]
    print(my_list[-1])
    print(my_list[0])
    • 使用.index()方法查询指定元素的下标:
    print('index方法:',my_list.index(3))#查找下标的元素

    使用.index()方法,如果输入不存在的下标,则执行会报错。

    • 使用.count()方法查询某个元素在list里出现的次数:
    print(my_list.count(5))#查询某个元素在list里面出现的次数

    .count()的应用场景:可以用于校验用户名

    .count()里面是元素,而不是下标!

    2、反转

    使用.reverse()方法:

    print('reverse:',my_list.reverse())#结果是None
    print(my_list)#.reverse()本身不会给出结果,需要打印列表
    • .reverse()本身不会给出结果,没有返回值,需要打印列表

    3、清空列表

    使用.clear()方法:

    my_list.clear()#清空整个list

    4、排序

    • 使用.sort()方法,默认为升序排序:
    nums.sort()#排序,默认升序
    • 使用.sort()方法,指定reverse=True,则降序排列:
    nums.sort(reverse=True)#排序,如果指定了reverse=True,那么就降序排列了
    • 使用.reverse()方法,降序排序:
    nums.reverse()

    5、将其他列表里的元素加入到本列表中

    使用.extend()方法:

    nums.extend(my_list)#把一个list里面的元素加入到nums列表里面

    6、合并列表

    使用“+”进行列表合并:

    new_list=nums+my_list

    ##    extend和+的区别:extend是将my_list的内容加入到nums里;而+是nums和my_list内容不变,重新建立一个新的list。

    7、复制列表

    使用“*”进行列表复制:

    print(new_list*3) #复制3个new_list

    8、取列表长度,也就是list里面元素的个数

    使用len()方法:

    passwords =['123456','123123','7891234','password']
    print(len(passwords)) #取长度,也就是list里面元素的个数

    三、列表应用

    #校验手机号是否存在,使用.count()或 in  not in都可以
    users =[]
    for i in range(5):
        username=input('请输入用户名:')
        #如果用户不存在的话,就说明可以注册
        # if users.count(username)>0:
    #关键字in   not in--------------------------------------------
        if username not in users:
            print('用户未注册,可以注册')
            users.append(username)
        else:
            print('用户已经被注册')

    四、数组

    nums1=[1,2,3] #一维数组
    nums2=[1,2,3,[4,56]] #二维数组
    nums=[1,2,3,4,['a','b','c','d','e',['','','']],['','']] #三维数组
    nums4=[1,2,3,4,['a','b','c','d','e',['一','二','三',[1,2,3]]]]#四维数组
    • 多维数组取值:

    三维数组取“五”:print(nums[-1][-1])

    四维数组取“2”:print(nums4[-1][-1][-1][1])

    五、列表循环

    • 原理

    #循环list取值
    count=0   #最原始的list取值方式,是通过每次计算下标来获取元素的
    while count<len(passwords):
        s=passwords[count]
        print('每次循环的时候',s)
        count+=1
    • 利用元素下标进行循环

    index = 0
    for p in passwords:#for循环直接循环一个list,那么循环的时候就是每次计算下标获取元素
        print('每次循环的值'+p)
        passwords[index]='abc_'+p
        index+=1
    print(passwords)

    Python中的列表循环内置了列表下标,因此只用一个变量p就可以,p就是每次取下标时对应的元素值。

    • 使用enumerate()枚举函数

    使用enumerate()函数,会自动将list的下标和元素都显示出来:

    for index,p in enumerate(passwords):#使用枚举函数时,它会帮你计算下标和元素
        passwords[index]='abc_'+p
        print('enumerate每次循环的时候',index,p)
    print(passwords)
    • 列表循环删除元素

    • 循环删list元素的时候,会导致下标错位:

    1、现象:

    l=[1,1,1,2,3,4,5]
      #1,1,2,3,4,5
      #0 1 2 3 4 5 6
    for i in l:
        if i%2!=0:
            l.remove(i)    #.remove()里面是元素;.pop()里面是下标
    print(l) #结果为[1,2,4]
    #循环删list元素的时候,会导致下标错位

    2、解决方法:

    l1=[1,1,1,2,3,4,5]
      #1,1,2,3,4,5
      #0 1 2 3 4 5 6
    l2=[1,1,1,2,3,4,5]
    for i in l2:  #使用l2中的元素判断,删除l1里的元素,由于l1没有参与判断,因此下标不会错位
        if i%2!=0:
            l1.remove(i)    
    print(l) #结果为[2,4]

    循环删除列表元素时,要定义两个相同的列表,一个判断,另一个删除。

    • 存址方式:

    列表中:

    1、现象:

    l1=[1,1,1,2,3,4,5]
      #1,1,2,3,4,5
      #0 1 2 3 4 5 6
    l2=l1
    for i in l2:  
        if i%2!=0:
            l1.remove(i)    
    print(l1) #结果为[1,2,4]
    #l1和l2其实指向的是同一块内存地址,因此删除l1的元素时,l2也会跟着变

    2、原因:

    字符串中:

     1、现象:

    a='tanailing'
    b=a
    a='niuniu'
    print(b)#结果为tanailing
    print(a)#结果为niuniu

    2、原因:

    • 字符串是直接开辟新的内存空间,不会共用一块内存空间,因此修改了a的内容后,b不会变。

    六、深拷贝与浅拷贝

    1、现象:

    l1=[1,1,1,2,3,4,5]
      #1,1,2,3,4,5
      #0 1 2 3 4 5 6
    l2=l1  #浅拷贝
    for i in l2:  
        if i%2!=0:
            l1.remove(i)    
    print(l1)
    
    #打印内存地址
    print(id(l1))  #结果为:1986281423432
    print(id(l2))  #结果为:1986281423432

    2、用法:

    import copy #引入copy模块
    l1=[1,1,1,2,3,4,5]
      #1,1,2,3,4,5
      #0 1 2 3 4 5 6
    l2=l1  #浅拷贝方式1
    l4=l1.copy() #浅拷贝方式2
    
    l3=copy.deepcopy()  #深拷贝
    
    #打印内存地址
    print(id(l1))  #结果:2629934030152
    print(id(l2))  #结果:2629934030152
    print(id(l3))  #结果:2629934028872

    3、区别:

    • 浅拷贝内存地址不变,深拷贝内存地址改变。
    • 循环删除列表元素时,使用深拷贝方式。

    七、切片

    1、range()生成器

     就是list取值的一种方式。

    • 生成器range(),用于写列表的范围,如果只写一个数,就表示从0开始,到写入的值-1:
    l=list(range(10))#生成的是[0,1,2,3,4,5,6,7,8,9]
    • 如果写入范围,则是从写入的第一个数值开始,从写入的第二个数-1结束:
    l=list(range(1,11))
    l=['a','b','c','d','e','j','k','l','m','n','o']
    #   0   1   2   3   4   5   6   7   8   9   10
    print(l[2:8])#顾头不顾尾
    print(l[:5])#如果冒号前面没写的话,代表从0开始取的
    print(l[4:])#如果冒号后面没写的话,代表取到最后
    print(l[:])#如果冒号前后都没写的话,代表取全部

    切片操作的特点:

    • 顾头不顾尾
    • 使用range()生成器时,如果冒号前面没写的话,代表从0开始取元素
    • 使用range()生成器时,如果冒号后面没写的话,代表取到最后的元素
    • 如果冒号前后都没写的话,代表取全部

    2、 步长

    步长是从自己元素开始,再走几步到想要的元素:

    nums=list(range(1,11))
    print(nums[1::2])#打印偶数
    #1 2 3 4 5 6 ...10
    print(nums[::2])#打印奇数
    print(nums[::-2]) #取偶数,从右往左取值

    步长特点:

    • 如果步长是正数的话,就从前往后开始取值;
    • 如果步长是负数的话,就从后往前开始取值,类似于reverse()。

     

    每天进步一点点,快乐生活多一点。
  • 相关阅读:
    nat
    ICE协议下NAT穿越的实现(STUN&TURN)
    比特币源码分析--端口映射
    IO复用,AIO,BIO,NIO,同步,异步,阻塞和非阻塞 区别(百度)
    从数据的角度带你深入了解IPFS
    IPFS 到底是怎么工作的?
    从数据的角度带你深入了解IPFS
    IPFS
    IPFS中文简介
    bootstrap 表单验证 dem
  • 原文地址:https://www.cnblogs.com/yiruliu/p/9563519.html
Copyright © 2011-2022 走看看