列表_列表python - CSDN
  • Python:列表 【全用法】

    万次阅读 多人点赞 2019-08-30 18:59:36
    python中有列表、元组、集合、字典这四种可以存放多个数据元素的集合,他们在总体功能上都起着存放数据的作用,却都有着各自的特点。本片文章中我们会对列表的用法做详细说明。 演示环境: python3.6 pycharm中的...

    python中有列表、元组、集合、字典这四种可以存放多个数据元素的集合,他们在总体功能上都起着存放数据的作用,却都有着各自的特点。本片文章中我们会对列表的用法做详细说明。

    演示环境:

    python3.6
    pycharm中的python3.6


    第一部分:列表(list):

    列表(list)用来存储不同的数据类型,使用 [ ]

    例如:

    service = ['http','ssh','ftp']
    

    后续演示中的service都以上述为基础。
    在这里插入图片描述
    列表的特性:
    1.1:索引:

    print(service[1])    ##输出第二个元素,ssh
    print(service[-1])   ##输出最后一个元素,ftp
    

    在这里插入图片描述

    1.2:切片:

    print(service[1:])   ##打印第一个元素之后的内容
    print(service[:-1])  ##打印最后一个元素之前的内容
    print(service[::-1])  ##倒序输出
    

    在这里插入图片描述

    1.3:重复:

    print(service * 3)   ##输出三遍
    

    在这里插入图片描述

    1.4:连接:

    service1 = ['nfs','samba']
    print(service + service1)
    

    在这里插入图片描述

    1.5:成员操作赋:

    print('nfs' in service)   ##判断是否存在
    

    在这里插入图片描述

    1.6:迭代:[for循环遍历]

    for i in service:
    	print(i)       ##遍历输出每个元素
    

    在这里插入图片描述

    1.7列表里嵌套列表

    service2 = [['abc','def','www'],[1,2,3],['mike','tony','sun']]
    
    对其索引:print(service2[2][1])   ##第三个元素中的第二个元素
    对其切片:print(service2[:][1])   ##第二个元素
    

    在这里插入图片描述


    对以上内容进行一个练习:
    题目:输入一年中的某一天,判断这一天是这一年的第几天:【输入格式:YYYY-MM-DD】

     User_input = input('输入:年-月-日')
    Year = int(User_input.split('-')[0])   ##得到年份
    Month = int(User_input.split('-')[1])  ##得到月份
    Day = int(User_input.split('-')[2])    ##得到天
    
    li = [31,28,31,30,31,30,31,31,30,31,30,31]   ##所有平年各个月份的天数
    num = 0    ##记录天数
    if ((Year % 4 == 0) and (Year % 100 != 0) or (Year % 400 == 0)):    ##当闰年时:
        li[1] = 29   ##将二月的天数改为29
    for i in range(12):  ##遍历月份
    	if Month > i + 1:   ##i从0开始,假如是5月的某一天,i循环到3停止,经过0-1-2-3四次循环,取4个月份即取1-2-3-4月的所有天
    		num += li[i]   ##将1-4月总天数求和
    	else:            ##退出if判断后,当下一次循环时,i=4,i+1不满足if的条件,进入else,将最后5月的第几天加入总天数中
    		num += Day
    		break
    print('这一天是%d年的第%d天' %(Year,num))
    

    在这里插入图片描述
    在这里插入图片描述


    列表的增删改查:
    1.增加:

    往列表里增加元素:

    1.print(service + ['firewalld'])   ##用连接的方式
    
    2.service.append('firewalld')   print(service)    ##append:追加一个元素到列表中
    
    3.extend:拉伸 追加多个元素到列表中  service.extend(['mysql','firewalld'])
    
    4.service.insert(1,'samba')  ###在指定索引位置插入元素  ##在第二个元素的位置插入samba作为第二个元素
    

    在这里插入图片描述

    2.删除:

    1.service.pop()   ##弹出最后一个元素
    a = service.pop(0)  ##弹出第1个元素  ###可以将其赋值
    
    2.service.remove('ssh') ##指定删除对象的名字  ##直接删除,不能将其赋值   ##不能指定序号,只能指定要删除对象的
    
    3. del service  ##删除列表
    
    del service   ##直接删除整个列表
    print(service)
    

    在这里插入图片描述

    3.赋值:

    1.service[0] = 'mysql'   ##通过索引 重新赋值
    
    2.service[:2] = ['samba','iscsi']  ##通过切片给前两个元素重新赋值
    

    在这里插入图片描述

    4.查看:
    查看出现的次数

    service.count('ssh')
    

    查看指定元素的索引值

    service.index('iscsi')    ###最小索引值
    service.index('ssh',1,3)   ###从1-3中查找【第二个元素和第三个元素之间】【不取上限】
    

    在这里插入图片描述

    5.排序:
    sort 排序
    对字符串排序不区分大小写

    names = ['alice','Bob','coco','Harry']
    names.sort()
    names      ###按照ASCLL排序   ###先排序首字母为大写的,再排序首字母是小写的
    
    names.sort(key=str.lower)   ###对字符串排序不区分大小写,相当于将所有元素转换为小写,再排序
    names.sort(key=str.upper)   ###相当于将所有元素转换为大写,再排序
    

    乱序

    li = list(range(10))   ##生成0-9,将其转换为列表形式
    print(li)
    import random
    random.shuffle(li)   ##随机打乱
    print(li)    
    

    在这里插入图片描述

    在这里插入图片描述


    练习:修改用户登陆系统:用户名和用户密码存放在两个列表里。用admin超级用户登陆后,可以进行添加,删除,查看用户的操作。
    1.后台管理员admin 密码admin
    2.管理员才能看到会员信息
    3.会员信息包含
    添加会员信息
    删除会员信息
    查看会员信息
    退出

    inuser = input('UserName: ')
    inpasswd = input('Password: ')
    users = ['root', 'westos']
    passwds = ['123', '456']
    
    if inuser == 'admin' and inpasswd == 'admin':
        while True:
            print("""
                菜单
            1.添加会员信息
            2.删除会员信息
            3.查看会员信息
            4.退出
            """)
            choice = input('请输入选择: ')
            if choice == '1':
                Add_Name = input('要添加的会员名: ')
                Add_Passwd = input('设置会员的密码为: ')
                users = users + [Add_Name]
                passwds = passwds + [Add_Passwd]
                print('添加成功!')
    
            elif choice == '2':
                Remove_Name = input('请输入要删除的会员名: ')
                if Remove_Name in users:
                    Remove_Passwd = input('请输入该会员的密码: ')
                    SuoYinZhi = int(users.index(Remove_Name))
                    if Remove_Passwd == passwds[SuoYinZhi]:
                        users.remove(Remove_Name)
                        passwds.pop(SuoYinZhi)
                        print('成功删除!')
                    else:
                        print('用户密码错误,无法验证身份,删除失败')
                else:
                    print('用户错误!请输入正确的用户名')
    
    
            elif choice == '3':
                print('查看会员信息'.center(50,'*'))
                print('\t用户名\t密码')
                usercount = len(users)
                for i in range(usercount):
                    print('\t%s\t%s' %(users[i],passwds[i]))
    
    
            elif choice == '4':
                exit()
            else:
                print('请输入正确选择!')
    

    值是简单的列表使用练习,功能不全面,后续待改进。


    练习二:用python列表实现栈操作:
    1.入栈
    2.出栈
    3.栈顶元素
    4.栈长度
    5.栈是否为空

    “”"
    功能包括:
    1.入栈 放到栈顶的位置
    2.出栈 判断是不是栈顶元素,不是的话将其后元素遍历移除,再移走该元素,再将其他元素加回栈
    3.栈顶元素 索引
    4.栈长度 判断个数
    5.栈是否为空 #栈顶有无元素
    “”"
    #栈的特点:先进后出

    Zhan = []  ##定义栈列表
    
    t = []   ##定义出栈临时栈列表
    
    while True:
        print("""
            菜单
            1.入栈
            2.出栈
            3.查看栈顶元素
            4.查看栈长度
            5.查看栈中元素
            6.退出
    """)
        choice = input('请输入选择: ')
        if choice == '1':
            Aim_Name = input('请输入要入栈的元素名: ')
            Zhan = Zhan+[Aim_Name]
            print('入栈成功!')
        elif choice == '2':
            Del_Name = input('请输入要出栈的元素名: ')
            if Del_Name in Zhan:
                Length = len(Zhan)
                if Zhan.index(Del_Name) == Length-1:   #如果为栈顶元素
                    Zhan.pop()
                else:   #不为栈顶元素
                    SuoYin = Zhan.index(Del_Name)
                    for i in range(Length-1-SuoYin):   #将要出栈元素后面的元素先保留
                        t.append(Zhan.pop())    #原栈中最后一个元素变为了第一个,顺序颠倒
                    Zhan.pop()   #目标出栈
                    Zhan = Zhan+t[::-1]  #将目标元素后的其他元素移回栈中
            else:
                print('栈中没有%s' %Del_Name)
    
        elif choice == '3':
            Zhan_Top = Zhan[-1]
            print('栈顶元素为:%s' %Zhan_Top)
    
        elif choice == '4':
            Length = len(Zhan)
            print('栈的长度为%s' %Length)
    
        elif choice == '5':
            print(Zhan)
    
    
        elif choice == '6':
            exit()
        else:
            print('请输入正确的选项!')
        print('\n')
    

    在这里插入图片描述
    在这里插入图片描述在这里插入图片描述


    关于python中列表的基础用法如上所述。

                              大大的小小阳
    
    展开全文
  • 列表

    2018-05-17 14:22:51
    列表内容可以重复,列表内可以包含列表,元素之间用逗号隔开,给列表增加数据有3种方式,append(单个值),extend(单个列表),inser(位置下标,值),删除数据也有3种方式remove(值),pop(下标,为空默认删除...
    列表内容可以重复,列表内可以包含列表,元素之间用逗号隔开,给列表增加数据有3种方式,append(单个值),extend(单个列表),inser(位置下标,值),
    删除数据也有3种方式remove(值),pop(下标,为空默认删除最后一个),delete 列表名[下标];查找元素是否在列表中使用not in,in;还可对使用sort对数据
    进行排序;可进行切片操作


    列表解析:

    matrix = [[1, 2, 3],[4, 5, 6],[7, 8, 9]]

    输出列表中,每一个列表的第二个数

    c = [i[1] for i in matrix]
    print(c)
    >>>[2, 5, 8]

    列表解析后,在运算下该列表下的值能否被2整除,后面加个if判断

    c = [i[1] for i in matrix if i[1]%2 == 0]
    >>>[2,8]
    列表
    超市货架 看成一个表,同时货架的东西可以重复,列表的值也可以重复;


    存储,处理一组元素的数据结构


    创建列表
          列表明=[元素1,元素2...] 用逗号隔开


    列表与字符串一样可通过乘号(*),赋值列表的值。


    取值操作
           列表明[编号]
           列表明[起始位置:终止位置]  获取指定返回的元素,输出的起始位置到终止位置前的元素(不包括终止位置)。
                                       终止位置的值可大于列表的个数值,不会报错。
                                       起始位置的值也可以大于列表的值,但会输出空。


    修改操作
           a=[1,2,3]
           a[1]=5 则2被修改5


    增加操作
            列表明.append() 在列表最后添加
            列表名.insert(位置,值)   某个位置添加值


    删除操作
         del  列表明[索引位置]


    查找操作   使用情况,不确定某一元素是否在列表中。
         元素值 in 列表明
         返回的是True或False
    -------------------------------------------------------------------------------
    列表:
    s=[值1,值2,值3]
    append函数:给数组尾部追加一个数值。(这个值可以是字符串,列表,元组)
    extend函数:给数值尾部追加一个或多个数值,要用中括号括起来。(其实就是把一个列表加入到另一个列表当中)
    insert函数:在数组的某个位置插入一个数值


    s.append(xx) 结果:s=[值1,值2,值3,xx]
    s.extend([aa,bb]) 结果:s=[值1,值2,值3,aa,bb]
    s.insert(1,yy) 结果:s=[值1,yy,值2,值3]


    下面是将一个元素(这个元素是一个队列)插入另一个列表中。
    -------------------------------------切片---------------------------------------
    s[:-5:-1] 反序打印后4位


    '''
    反序输入的几个方法
    '''
    # 方法一:
    s = 'abcdef'
    print(s[::-1])
    
    # 方法二:
    print(s[-1::-1])
    
    #方法三:通过for循环,使用负号,从-1开始,所以变成l[-i-1]
    for i in range(len(s)):
        print(s[-i-1],end="")
    
    
    print()
    
    # 方法四:
    a  = reversed(s)
    for i in a:
        print(i,end="")
    print("")
    
    #方法五,只适用列表:
    k = [1,2,3]
    k.reverse()
    print(k)

    列表的切片:拷贝一个列表出来。重新生成一份新的其实就是copy()函数 ;可以切片的有列表,字符串,元组,这些都可通过下标查询,而集合,字典没有下标。
    s=[a,b,s,dc,g,gw]
    s[0:3] 输出:[a,b,c] 可以理解为:[),左闭右开,所以只取到3个数。
    s[:]   输出:[a,b,s,dc,g,gw]



    ls1 = [5,4,2,1]
    ls2 = ls1[:]
    ls3 = ls1 
    ls1.sort()  ##此时ls1= [1,2,4,5]
    此时
    ls2输出的结果为:[5,4,2,1]   ##切片是独立拷贝一份文件。
    ls3输出的结果为:[1,2,4,5]   ##赋值是指针指向同一个列表。
    >>> name=[1,2,3,4]
    >>> name.append(['x','y'])
    >>> name
    [1, 2, 3, 4, ['x', 'y']]
    --------------------------列表内置函数-------------------------
    如何查找列表中的列表?
    ls=[1,2,['a','b'],]
    'a' in ls[2]   ##查找列表中的第3个元素
    返回:true,
    ---------------------------------------------------------------------
    count()函数,用于统计列表中的值出现的次数。括号里面是要查找的元素名称
    ls=[1,2,['a','b'],3]
    ls.count(3)
    返回:1,表明3在列表中出现一次。
    --------------------------------------------------------------------
    index()函数,用于查找值在列表中的位置,从0开始计算。
    ls=[1,2,['a','b'],3]
    ls.index(1)
    返回:0 表明该值在列表中的第0个位置。
    ---------------------------------------------------------------------
    reverse()函数的使用:将队列反向排列。
    ls = [1,4,3,2]
    ls.reverse()
    返回:ls = [2,3,4,1]
    --------------------------------------------------------------------
    sort()函数的使用:将队列从小到达排列。   ##和reverse不同的是sort是从大到小排序或从小到大排序,而reverse是直接把序列反过来
    list1 = [3,5,1,6]
    list1.sort()
    返回:[1,3,5,6]


    sort(reverse=False),sort默认是False,从小到大排列。如果是True,则从大到小排列。
    --------------------------------------------------------------------
    in函数:
    一个数是否在列表当中:
    >>> num=[1, 2, 3, 3, 5, 6]
    >>>1 in num
    >>>True
    展开全文
  • Python列表解析

    万次阅读 2018-09-13 15:39:03
    列表解析 Python 的强大特性之一是其对 list 的解析,它提供一种紧凑的方法,可以通过对 list 中的每个元素应用一个函数,从而将一个 list 映射为另一个 list。 列表解析,又叫列表推导式( list comprehension)...

    列表解析

    Python 的强大特性之一是其对 list 的解析,它提供一种紧凑的方法,可以通过对 list 中的每个元素应用一个函数,从而将一个 list 映射为另一个 list。
    列表解析,又叫列表推导式( list comprehension)
    列表解析比 for 更精简,运行更快,特别是对于较大的数据集合
    列表解析可以替代绝大多数需要用到 map和 filter的场合

    列表推导式提供了一个创建链表的简单途径,无需使用 map() , filter() 以及 lambda 。以定义方式得到列表通常要比使用构造函数创建这些列表更清晰。每一个列表推导式包括在一个 for 语句之后的表达式,零或多个 for 或 if 语句。返回值是由 for 或 if 子句之后的表达式得到的元素组成的列表。如果想要得到一个元组,必须要加上括号。

    基本列表解析

    基本

    >>> [x for x in range(5)]   # [0, 1, 2, 3, 4]
    l1 = [1,2,3,4]
    [ x*2 for x in l1]   #[2,4,6,8]

    多个值的

    [ '%s = %s' for (k, v) in a_map.items()]

    两次循环

    >>> l1 = [1,2,3,4]
    >>> l2 = [1,2,3,4]
    >>> [x+y for x in l1 for y in l2]
    [2, 3, 4, 5, 3, 4, 5, 6, 4, 5, 6, 7, 5, 6, 7, 8]

    可以调用函数

    [ func(x) for x in l1]  #等价于map

    注意,列表解析不会改变原有列表的值,会创建新的list

    条件列表解析
    [ x for x in range(100) if x%2 ==0 ]
    嵌套列表解析
    mat = [ [1, 2, 3],[4, 5, 6], [7, 8, 9]]

    交换行列

    [ [row[i] for row in mat] for i in (0,1,2)] #[[1, 4, 7], [2, 5, 8], [3, 6, 9]]
    其他:

    1.根据索引取元素时,需要进行边界检查 IndexError 切片取,不需要,超过边界不会异常

    2.在迭代中修改列表 注意,不安全,不建议这么干 但是可以 for i in l1[:]: l1.insert()……

    3.多个list合成一个 就是

    ['a','b',.....],['a','b'.....]['a','b'.....]

    变为

    ['a','b',.....,'a','b'.....'a','b'.....]

    处理

    >>> sum ([[ 'a', 'b' ],['a' , 'b'],[ 'a' ,'b' ]], [])
    ['a' , 'b' , 'a', 'b' , 'a' , 'b']
    >>> list (itertools .chain([ 'a' ,'b' ],[ 'a', 'b' ],['a' , 'b']))
    ['a' , 'b' , 'a', 'b' , 'a' , 'b']

    4.关于堆栈和队列

    通过上面的操作,可以发现,很轻易可以拿列表当做堆栈或者队列使用
    当然,他们有自己的模块,可以查相关库

    5.序列相关模块

    array 一种受限制可变序列类型,要求所有元素必须是相同类型

    copy 提供浅拷贝和深拷贝的能力

    operator 包含函数调用形式的序列操作符,如 operator.concat(m,n) 相当于m+n

    re 正则表达式

    types 包含Python 支持的所有类型

    collections 高性能容器数据类型

    展开全文
  • python列表列表的相关运算

    千次阅读 2019-01-05 21:03:55
    一、列表 数据类型:数字类型、字符串、列表、字典、元祖、集合、迭代器、生成器、函数 1、什么是列表(list) 相当于其他语言的数组。 列表是Python提供的容器型数据类型。可变并且有序。 可变 - 列表中的每个...

    一、列表

    数据类型:数字类型、字符串、列表、字典、元祖、集合、迭代器、生成器、函数

    1、什么是列表(list)

    相当于其他语言的数组。

    列表是Python提供的容器型数据类型。可变并且有序。

    可变 - 列表中的每个元素的值可变,列表的长度可变,列表中的顺序可变。(支持增、删、改)

    有序 - 每个元素可以通过下标来确定位置

    2、列表的字面量

    通过[]括起来,里面有多多个元素,每个元素用逗号隔开。

    例如:

    # 用逗号隔开的是列表的元素
    [1, 2, 3]		
    
    # Python列表中的元素可以是任何Python支持的类型
    # 并且同一个列表中不同元素的类型可以不一样
    [10, 'abc', True]	 
    
    # 任何类型的数据都可以作为列表的元素
    a = 10
    list1 = [a, 132, 'abc', True, 10.23, [1, 2], {'a':10}]
    
    # 空列表
    []					
    
    3、获取列表元素

    和字符串获取字符的语法一样

    a、获取单个元素
    列表[下标]  # 获取列表中指定下标对应的元素
    

    例:

    list1 = [1, 2, 3, 4]
    print(list1[0]) 	# 1
    print(list1[-1]) 	# 4
    
    b、获取部分元素(切片)

    字符串的结果都是新的字符串,列表的结果是列表。

    语法:

    列表[开始下标:结束下标:步长]
    

    例子:

    list1 = ['a', 'b', 'c', 'd', 'e']
    print(list1[1:3])
    print(list1[-3:3])
    print(list1[:2])
    print(list1[::-1])
    
    c、一个一个的取出所有元素(遍历)

    方法一:可以使用for循环直接遍历列表拿到每个元素。

    操作元素的时候与下标无关用此方式。

    list1 = ['a', 'b', 'c', 'd', 'e']
    for item in list1:
        print(item)
    

    方法二:通过遍历列表中列表元素的下标来遍历列表元素。

    操作元素的时候和下标有关用此方式。

    list1 = ['a', 'b', 'c', 'd', 'e']
    for index in range(len(list1)):
        print(list1[index])
    

    二、增删改

    1、增(添加列表元素)
    a、append

    在指定的列表的最后添加指定的元素。

    列表.append(元素)
    

    例:

    list1 = [1, 2, 3, 4, 5]
    list1.append(6)
    print(list1) # [1, 2, 3, 4, 5, 6]
    
    b、insert

    在指定的下标前插入指定的元素。

    列表.insert(下标, 元素)
    

    例:

    list1 = [1, 2, 3, 4, 5]
    list1.insert(3, 3.5)
    print(list1) # [1, 2, 3, 3.5, 4, 5]
    
    2、删
    a、del

    删除指定下标的元素,del是关键字,可以删除任何东西。

    如果不加下标就删除整个列表。

    注意:如果下标越界就会报错。

    del 列表[下标]
    del 列表
    

    例:

    list1 = [1, 2, 3, 4, 5]
    del list1[0]
    print(list1) # [2, 3, 4, 5]
    

    注意:不管增加还是删除都是在原列表做改动,下标会重新分配。

    b、remove

    不是通过下标来删除,是通过元素来删,如果没有此元素程序报错。

    列表.remove(元素)
    

    例1:

    list1 = [1, 2, 3, 4, 5]
    list1.remove(5)
    print(list1) # [1, 2, 3, 4]
    

    例2:

    list1 = [1, 2, 5, 4, 5]
    list1.remove(5)
    print(list1) # [1, 2, 4, 5]	
    

    注意:remove删除元素时,有重复的元素,只删从左往右的第一个。

    c、pop

    相对于del 和 remove 来说,pop删除时,有返回值(返回的是被删除的元素);而del 和 remove没有返回值

    列表.pop()
    列表.pop(下标)
    

    不带参数时,pop将列表中最后一个元素从列表中取出;

    带下标时,pop将列表中指定下标对应的元素从列表中取出。

    list1 = [1, 2, 3, 4, 5, 5]
    num1 = list1.pop()
    print(num1)
    print(list1)
    

    删除元素时遇到的两个坑

    • 坑一:用元素遍历

      会遇到的问题:遍历列表删除部分元素,删不全!

    # 下标遍历有误
    age_list = [14, 9, 33, 44]
    for index in range(len(age_list)):
        age = age_list[index]
        if age < 18:
            age_list.pop(index)
    print(age_list)
    
    # 解决方案:遍历的时候段原列表切边复制
    # 创建新的列表来保存年龄,来保证删除时下标变动
    # 遍历没有变动的元素
    # 要用remove根据元素来删除
    age_list = [1, 2, 33, 44]
    temp = age_list[:]
    for age in temp:
        if age  < 18:
            age_list.remove(age)
    print(age_list)
    
    • 坑二:下标遍历

      会遇到的问题:删不全,而且还会越界。

    # 以下代码不能实现功能
    for index in range(len(age_list)):
        age = age_list[index]
        if age < 18:
            age_list.pop(index)
    print(age_list)
    
    # 通过while循环控制循环次数,有删除时下标不变。
    age_list = [14, 9, 33, 44]
    index = 0
    new_ages = []
    while index < len(age_list):
        age = age_list[index]
        if age < 18:
            del_item = age_list.pop(index)
            new_ages.append(del_item)
        else:
            index += 1
    print(age_list, new_ages)
    
    3、改
    列表[下标] = 新值
    

    修改列表中指定下标对应的值

    list1 = [1, 2, 3]
    list1[0] = 'abc'
    print(list1)	# ['abc', 2, 3]
    

    例子:有一个列表保存的学生的成绩,要求低于60分的改成“下一个班见”,并且统计下人数。

    count = 0
    scores = [11, 22, 33, 66, 77, 88]
    for index in range(len(scores)):
        if scores[index] < 60:
            count += 1
            scores[index] = '下一个班见'
    print('下一个班见人数共有%d人'%count)
    print(scores)
    

    三、列表的相关运算

    1、相关运算:
    a、支持+,*运算
    列表1 + 列表2
    

    将两个列表中的元素合并在一起产生一个新的列表。

    print([1, 2, 3] + ['a', 'b', 'c'])
    # [1, 2, 3, 'a', 'b', 'c']
    
    列表*N
    

    将列表中的元素重复N次,产生一个新的列表

    b、支持比较运算

    比较大写与字符串比较大小相似。

    list1 = [1, 2, 3]
    list2 = [1, 2, 3]
    print(list1 == list2) # True
    print(list1 == [1, 3, 2]) # False
    
    2、in 和 not in
    元素 in 列表
    

    判断列表中是否存在指定的元素

    print([1, 2] in [1, 2, 3]) # False
    
    3、len
    len(列表)
    

    获取列表中元素的个数。

    print(len([[1, 2], 2, 'a', 'agc'])) #4
    
    4、list

    只有序列才可以转换成列表,并且所有的序列都可以转换成列表

    list(数据)
    

    转换的时候就是将序列中所有的元素转换成列表的元素

    list1 = list('hello')
    print(list1) # ['h', 'e', 'l', 'l', 'o']
    
    list2 = list(range(10, 20))
    print(list2) 	# [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
    

    注意:不能用Python给我们提供的类型的名字来命名,否则会有隐患。

    5、序列其他方法
    max(序列)	# 获取序列中值最大的元素
    min(序列)	# 获取序列中值最小的元素
    sum(序列)	# 求序列中所有元素的和
    

    注意:以上三个方法,要求序列中的元素类型必须一致,并且这个类型支持运算和加法运算。(一般是数字序列使用)

    print(max([1, 2, 3, 3, 5, 5, 9]))
    print(min([1, 2, 3, 3, 5, 5, 9]))
    print(sum(range(101)))	# 计算1到100的和
    
    展开全文
  • python中对于列表和数组进行切片是很频繁的 1.列表切片 python中符合序列的有序序列都支持切片,例如列表、字符串、元祖。 格式:【start:end:step】 start:开始索引;end:结束索引;step:步长(步长为正时,...
  • react中列表渲染的局部刷新

    千次阅读 2019-05-11 21:21:10
    最近在写demo的时候遇到一个更新列表中某个的对象的某个值,最期待的结果肯定是局部刷新,但是我们往往在改变值之后会遇到全局都刷新的问题,以下为个人实验出来的一个小技巧。 首先我有以下数据需要通过react的...
  • 列表去重

    千次阅读 2018-09-28 18:52:01
    列表转化为集合再转化为列表,利用集合的自动去重功能。简单快速 缺点是:使用set方法无法保证去重后的顺序    2.直观方法(常用) 先建立一个空列表,通过遍历原来的列表,再利用逻辑关系not in 来去重...
  • python保存列表

    万次阅读 2018-08-24 15:03:58
    python保存列表 2018-8-24 保存为.txt文件 注:保存.txt需要将列表内容转为字符串格式 ##保存 ipTable=['123.111.111.1','111.111.111.1'] fileObject = open('sampleList.txt', 'w') for ip in ipTable: ...
  • python列表取最大值,最大值的位置

    千次阅读 2020-02-12 02:48:17
    lst = [1,2,3] a = max(lst) #最大值 b = lst.index(max(lst)) #最大值的位置 print(“列表的最大值:{}”.format(a),“位置:{}”.format(b)) 结果: 列表的最大值:3 位置:2
  • python中如何拆分列表

    千次阅读 2019-10-29 20:45:03
    python中拆分列表 1.将一个大列表列表按照n个一组来组成一个小列表 names=[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15] n=3 #将列表每3个组成一个小列表, for i in range(0, len(names), n): name=names[i:i + n] ...
  • Redis底层详解(五) 压缩列表

    万次阅读 2018-12-12 08:17:27
    一、压缩列表概述  压缩列表是一种编码过的“链表”旨在实现高效的内存管理。它可以存储整数和字符串,整数以小端序存储,字符串则以字节数组存储。压缩列表的内存存储结构如下图所示:  其中zlbytes、zltail...
  • Python杂谈 | (1)Python列表合并、去重和排序

    万次阅读 多人点赞 2019-02-06 22:03:45
    目录   一.列表合并--append() 二.列表合并--extend() ...2.列表对象的append()可以将另一个列表追加到当前列表中,作为当前列表的一个元素。 二.列表合并--extend() 与append()不同,e...
  • python列表和字典之间的相互转换

    万次阅读 多人点赞 2018-07-06 15:03:05
    列表转换成字典注:列表不能直接使用dict转换成字典。方法一:使用zip()函数a = ['a1','a2','a3','a4'] b = ['b1','b2','b3'] d = zip(a,b) print(dict(d)) # {'a1': 'b1', 'a2': 'b2', 'a3': 'b3'}将a和b两个列表内...
  • Python中将列表转换成为数据框有两种情况:第一种是两个不同列表转换成一个数据框,第二种是一个包含不同子列表列表转换成为数据框。 第一种:两个不同列表转换成为数据框from pandas.core.frame import ...
  • python 列表相加可以有两种方法实现: 1 利用操作符+ 比如: a = [1,2,3] b = [4,5,6] c = a+b c的结果:[1,2,3,4,5,6] 2 利用extend 比如: a = [1,2,3] b = [4,5,6] a.extend(b) a的结果:[1,2,3,4,5,6] ...
  • python创建二维列表的两种方法

    万次阅读 多人点赞 2018-08-28 19:17:36
    方法一: ...如此,就创建好了一个缺省值为0的10*10的二维列表,实现相同列表的方法还有b=[[0]*10]*10,而且判断 a==b 时,返回值为 True。但是通过此种方法建立的列表存在一定的问题,当我们令b[...
  • 递归处理多层嵌套列表

    万次阅读 2014-04-25 15:51:03
    建立一个多层列表(即列表中存储列表)并输出列表项 如下图: 可以看出输出的只是输出了外列表 当然也可以多次循环输出每一个子项:如下图所示 注:isinstance(object, classinfo)为python的内置函数,...
  • js下拉列表二级联动

    万次阅读 多人点赞 2018-10-18 09:38:32
    学了JS也有一段时间了,今天把JS中较为重要的下拉列表二级联动记录一下。所谓二级联动,就是要通过一个下拉列表的选择从而在另一个select下拉列表中显示出对应的数据。好比我有两个下拉列表,第一列表是选择省份,...
  • 1.列表(List)的定义 列表是Python中最基本的数据结构 列表中的每个元素都分配一个位置,一个元素对应一个位置 第一个索引是0,第二个索引是1,依此类推 2.列表的创建 列表里:可以同时储存不同的数据类型 li = [1,...
  • Python列表和元组的详细区别

    万次阅读 多人点赞 2020-09-02 13:29:34
    Python列表和元组的详细区别 一、列表和元组的区别 二、列表(List) 三、元组(Tuple) Python列表和元组的详细区别 一、列表和元组的区别 列表是动态数组,它们不可变且可以重设长度(改变其内部元素...
1 2 3 4 5 ... 20
收藏数 3,432,687
精华内容 1,373,074
关键字:

列表