精华内容
参与话题
问答
  • Python:列表 【全用法】

    万次阅读 多人点赞 2019-07-02 09:31:28
    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中列表的基础用法如上所述。

                              大大的小小阳
    
    展开全文
  • 列表(list)的特性

    千次阅读 2018-08-11 21:23:58
    Python内置的一种数据类型是列表(list) list是一种有序的集合,可以随时添加和删除其中的元素,可以存储任意数据类型的集和 li = [1, 1.2, 2j+3, True, "hello"] print( li, type( li )) list...

    一  什么是 list

    Python内置的一种数据类型是列表(list)

    list是一种有序的集合,可以随时添加和删除其中的元素,可以存储任意数据类型的集和

    li = [1,  1.2,  2j+3,  True,  "hello"]
    print( li,  type( li ))

    list 里面可以是整形,浮点数,复数,布尔类型,也可以是字符串

    二  列表里面也是可以嵌套列表的
    li1 = [1,  1.2,  2j+3,  True,  "hello",  [1, 2, 3, 4, 5]]
    print(li1,  type(li1))

    list 里面嵌套 list 也是可以的

    三  列表里面不嵌套

    1) 索引:正向索引, 反向索引

    2) 切片
    print(services[::-1])     # 列表的反转
    print(services[1:])       # 除了第一个之外的其他元素
    print(services[:-1])     # 除了最后一个之外的其他元素

    3) 重复
    print(services*3)

    4)连接
    services1 = ['mysql', 'firewalld']
    print(services + services1)

    5) 成员操作符
    print('firewalld' in services)
    print('ftp' in services)
    print('firewalld' not in services)
    print('ftp' not in services)

    四  列表里面嵌套列表

    li = [ ['http', 80],  ['ssh', 22],  ['ftp',21] ]

    1) 索引
    print( li [0][0])   
    print( li [-1][1])

    2) 切片
    print( li [:][1])
    print( li [:-1][0])
    print( li [0][:-1])

    五   如何for循环遍历

    print("服务显示".center(50, "*"))
    for service in services:
        # print输出不换行,
        print(service, end=',')

    六   切片,字符串的join方法

    假定有下面这样的列表:
          names = ['fentiao', 'fendai', 'fensi', 'apple']

     使其的输出结果为: 'I have fentiao, fendai, fensi and apple.'

    ' , '.join(name[:-1])     ##除了最后一个其他name列表中的元素用  ' ,'  隔开

    七   列表元素的增加

    1) 普通的在列表中添加

    1)  append追加: append是追加一个元素到列表中最后一个

    2)extend:拉伸: 追加多个元素到列表中

    3)insert:插入

    八  列表元素的删除

    1) pop弹出删除

    pop为空,则删除列表最后一个

    pop加索引序号

    如果列表为空,pop时,会报错

    2)  remove:加列表中的对象删除

    3)  clear: 清空列表里面的所有元素

    4)  del : 删除列表元素的,加索引值

    也可以是切片的方式

    九  列表元素的修改

    1)  通过索引重新赋值

    2) 通过切片重新赋值

    十  列表的查看

    1) 查看重复次数

    2) 查看指定元素的索引值(也可与以指定范围查看)

    3) 排序查看, 按照Ascii码进行排序的

    4) 对字符串排序不区分大小写

    十一   随机生成10个整形数, 范围为1~10之间,然后将其打乱

    将原有的列表顺序打乱, 间接实现随机生成整形数

    十二  copy  和  reverse  的区别

    可以看到,li  和 li1 的 id  是相同的,而 li2 是不同的,等同于 软链接 与 硬链接的区别

     

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

    千次阅读 2019-01-02 09:33:31
    一、列表 数据类型:数字类型、字符串、列表、字典、元祖、集合、迭代器、生成器、函数 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-列表学习笔记(完)

    万次阅读 多人点赞 2020-06-06 09:35:03
    列表推导式列表元素的增加列表元素的删除列表元素的访问列表元素出现的次数切片(slice)列表的排序列表元素的查找列表的其他方法列表相关的内置函数 列表 列表:用于存储任意数目、任意类型的数据集合。 列表的...

    列表

    列表:用于存储任意数目、任意类型的数据集合。

    列表的创建

    1. 基本语法[]创建
    a = [1, 'jack', True, 100]
    b = []
    
    2. list()创建

    使用list()可以将任何可迭代的数据转化成列表

    a = list()  # 创建一个空列表
    b = list(range(5))  # [0, 1, 2, 3, 4]
    c = list('nice')  # ['n', 'i', 'c', 'e']
    
    3. 通过range()创建整数列表

    range()可以帮助我们非常方便的创建整数列表,这在开发中及其有用。语法格式为:range([start,]end[,step])

    start参数:可选,表示起始数字。默认是0。

    end参数:必选,表示结尾数字。

    step参数:可选,表示步长,默认为1。

    python3中range()返回的是一个range对象,而不是列表。我们需要通过list()方法将其转换成列表对象。

    a = list(range(-3, 2, 1))  # [-3, -2, -1, 0, 1]
    b = list(range(2, -3, -1))  # [2, 1, 0, -1, -2] 
    
    4. 列表推导式
    a = [i * 2 for i in range(5) if i % 2 == 0]  # [0, 4, 8]
    
    points = [(x, y) for x in range(0, 2) for y in range(1, 3)]
    print(points)  # [(0, 1), (0, 2), (1, 1), (1, 2)]
    

    列表元素的增加

    当列表增加和删除元素时,列表会自动进行内存管理,大大减少了程序员的负担。但这个特点涉及列表元素的大量移动,效率较低。除非必要,我们一般只在列表的尾部添加元素或删除元素,这会大大提高列表的操作效率

    • append()
    >>>a = [20,40]
    >>>a.append(80)
    >>>a
    [20,40,80]
    
    • +运算符

    并不是真正的尾部添加元素,而是创建新的列表对象;将原列表的元素和新列表的元素依次复制到新的列表对象中。这样,会涉及大量的复制操作,对于操作大量元素不建议使用。

    >>> a = [3, 1, 4]
    >>> b = [4, 2]
    >>> a + b
    [3, 1, 4, 4, 2]
    
    • extend()

    将目标列表的所有元素添加到本列表的尾部,属于原地操作,不创建新的列表对象。

    >>> a = [3, 2]
    >>> a.extend([4, 6])
    >>> a
    [3, 2, 4, 6]
    
    • insert()

    使用insert()方法可以将指定的元素插入到列表对象的任意指定位置。这样会让插入位置后面所有的元素进行移动,会影响处理速度。涉及大量元素时,尽量避免使用。类似发生这种移动的函数还有:remove()、pop()、del(),它们在删除非尾部元素时也会发生操作位置后面元素的移动。

    >>> a = [2, 5, 8]
    >>> a.insert(1, 'jack')
    >>> a
    [2, 'jack', 5, 8]
    
    • 乘法

    使用乘法扩展列表,生成一个新列表,新列表元素时原列表元素的多次重复。

    >>> a = [4, 5]
    >>> a * 3
    [4, 5, 4, 5, 4, 5]
    

    适用于乘法操作的,还有:字符串、元组。

    列表元素的删除

    • del()

    删除列表指定位置的元素。

    >>> a = [2, 3, 5, 7, 8]
    >>> del a[1]
    >>> a
    [2, 5, 7, 8]
    
    • pop()

    删除并返回指定位置元素,如果未指定位置则默认操作列表最后一个元素。

    >>> a = [3, 6, 7, 8, 2]
    >>> b = a.pop()
    >>> b
    2
    >>> c = a.pop(1)
    >>> c
    6
    
    • remove()

    删除首次出现的指定元素,若不存在该元素抛出异常。

    >>> a=[10,20,30,40,50,20,30,20,30]
    >>> a.remove(20)
    >>> a
    [10, 30, 40, 50, 20, 30, 20, 30]
    
    • clear()

    清空一个列表。

    a = [3, 6, 7, 8, 2]
    a.clear()
    print(a)  # []
    

    列表元素的访问

    • 通过索引直接访问元素
    >>> a = [2, 4, 6]
    >>> a[1]
    4
    
    • index()获得指定元素在列表中首次出现的索引

    index()可以获取指定元素首次出现的索引位置。语法是:index(value,[start,[end]])。其中,startend指定了搜索的范围。

    >>> a = [10, 20, 30, 40, 50, 20, 30, 20, 30]
    >>> a.index(20)
    1
    >>> a.index(20, 3)
    5
    >>> a.index(20, 6, 8)
    7
    

    列表元素出现的次数

    返回指定元素在列表中出现的次数。

    >>> a = [10, 20, 30, 40, 50, 20, 30, 20, 30]
    >>> a.count(20)
    3
    

    切片(slice)

    [起始偏移量start:终止偏移量end[:步长step]]

    • 三个量为正数的情况下
    操作和说明 示例 结果
    [:]
    提取整个列表
    [10, 20, 30][:] [10, 20, 30]
    [start:]
    从start索引开始到结尾
    [10, 20, 30][1:] [20, 30]
    [:end]
    从头开始到 end-1
    [10, 20, 30][:2] [10, 20]
    [start:end]
    从 start 到 end-1
    [10, 20, 30, 40][1:3] [20, 30]
    [start:end:step]
    从 start 提取到 end-1,步长是step
    [10, 20, 30, 40, 50, 60, 70][1:6:2] [20, 40, 60]
    • 三个量为负数的情况
    示例 说明 结果
    [10, 20, 30, 40, 50, 60, 70][-3:] 倒数三个 [50, 60, 70]
    [10, 20, 30, 40, 50, 60, 70][-5:-3] 倒数第五个至倒数第四个 [30, 40]
    [10,20,30,40,50,60,70][::-1] 逆序 [70,60,50,40,30,20,10]
    t1 = [11, 22, 33, 44, 55, 66, 77, 88, 99]
    print(t1[100:])  # []
    print(t1[0:-1])  # [11, 22, 33, 44, 55, 66, 77, 88]
    
    print(t1[1:5:-1])  # []
    print(t1[-1:-5:-1])  # [99, 88, 77, 66]
    
    print(t1[-5:-1:-1])  # []
    
    
    print(t1[5:-1:-1])  # []
    
    print(t1[::-1])  # [99, 88, 77, 66, 55, 44, 33, 22, 11]
    
    # 注意以下两个
    print(t1[3::-1])  # [44, 33, 22, 11]
    print(t1[3::1])  # [44, 55, 66, 77, 88, 99]
    
    

    列表的排序

    • 修改原列表,不创建新列表的排序
    a = [3, 2, 8, 4, 6]
    print(id(a))  # 2180873605704
    a.sort()  # 默认升序
    print(a)  # [2, 3, 4, 6, 8]
    print(id(a))  # 2180873605704
    
    a.sort(reverse=True)
    print(a)  # [8, 6, 4, 3, 2]
    
    # 将序列的所有元素随机排序
    import random
    b = [3, 2, 8, 4, 6]
    random.shuffle(b)
    print(b)  # [4, 3, 6, 2, 8]
    
    • 创建新列表的排序

    通过内置函数sorted()进行排序,这个方法返回新列表,不对原列表做修改。

    a = [3, 2, 8, 4, 6]
    b = sorted(a)  # 默认升序
    c = sorted(a, reverse=True)  # 降序
    print(b)  # [2, 3, 4, 6, 8]
    print(c)  # [8, 6, 4, 3, 2]
    
    • 冒泡排序
    list1 = [34,54,6,5,65,100,4,19,50,3]
    
    #冒泡排序,以升序为例
    
    #外层循环:控制比较的轮数
    for i in range(len(list1) - 1):
        #内层循环:控制每一轮比较的次数,兼顾参与比较的下标
        for j in range(len(list1) - 1 - i):
            #比较:只要符合条件则交换位置,
            # 如果下标小的元素 > 下标大的元素,则交换位置
            if list1[j] < list1[j + 1]:
                list1[j],list1[j + 1] = list1[j + 1],list1[j]
    print(list1)
    
    • 选择排序
    li = [17, 4, 77, 2, 32, 56, 23]
    
    # 外层循环:控制比较的轮数
    for i in range(len(li) - 1):
        # 内层循环:控制每一轮比较的次数
        for j in range(i + 1, len(li)):
            # 如果下标小的元素>下标大的元素,则交换位置
            if li[i] > li[j]:
                li[i], li[j] = li[j], li[i]
    print(li)
    

    列表元素的查找

    • 顺序查找
    # 顺序查找
    
    # 1.需求:查找指定元素在列表中的位置
    list1 = [5, 6, 5, 6, 24, 17, 56, 4]
    key = 6
    for i in range(len(list1)):
        if key == list1[i]:
            print("%d在列表中的位置为:%d" % (key,i))
    
    # 2.需求:模拟系统的index功能,只需要查找元素在列表中第一次出现的下标,如果查找不到,打印not found
    # 列表.index(元素),返回指定元素在列表中第一次出现的下标
    list1 = [5, 6, 5, 6, 24, 17, 56, 4]
    key = 10
    for i in range(len(list1)):
        if key == list1[i]:
            print("%d在列表中的位置为:%d" % (key,i))
            break
    else:
        print("not found")
    
    # 3.需求:查找一个数字列表中的最大值以及对应的下标
    num_list = [34, 6, 546, 5, 100, 16, 77]
    max_value = num_list[0]
    max_index = 0
    for i in range(1, len(num_list)):
        if num_list[i] > max_value:
            max_value = num_list[i]
            max_index = i
    print("最大值%d在列表中的位置为:%d" % (max_value,max_index))
    
    # 4.需求:查找一个数字列表中的第二大值以及对应的下标
    num_list = [34, 6, 546, 5, 100, 546, 546, 16, 77]
    # 备份
    new_list = num_list.copy()
    
    # 升序排序
    for i in range(len(new_list) - 1):
        for j in range(len(new_list) - 1 - i):
            if new_list[j] > new_list[j + 1]:
                new_list[j],new_list[j + 1] = new_list[j + 1],new_list[j]
    print(new_list)
    
    # 获取最大值
    max_value = new_list[-1]
    
    # 统计最大值的个数
    max_count = new_list.count(max_value)
    
    # 获取第二大值
    second_value = new_list[-(max_count + 1)]
    
    # 查找在列表中的位置:顺序查找
    for i in range(len(num_list)):
        if second_value == num_list[i]:
            print("第二大值%d在列表中的下表为:%d" % (second_value,i))
    
    
    • 二分法查找
    # 二分法查找的前提:有序
    li = [45, 65, 7, 67, 100, 5, 3, 2, 35]
    
    # 升序
    new_li = sorted(li)
    key = 100
    
    # 定义变量,表示索引的最小值和最大值
    left = 0
    right = len(new_li) - 1
    
    # left和right会一直改变
    # 在改变过程中,直到left==right
    while left <= right:
        # 计算中间下标
        middle = (left + right) // 2
    
        # 比较
        if new_li[middle] < key:
            # 重置left的值
            left = middle + 1
        elif new_li[middle] > key:
            # 重置right的值
            right = middle - 1
        else:
    
            print(f'key的索引为{li.index(new_li[middle])}')
            break
    else:
        print('查找的key不存在')
    
    

    列表的其他方法

    • reverse()

    用于列表中数据的逆序排列。

    a = [3, 2, 8, 4, 6]
    a.reverse()
    print(a)  # [6, 4, 8, 2, 3]
    
    • copy()

    复制列表,属于浅拷贝。

    a = [3, 6, 7, 8, 2]
    b = a.copy()
    print(b)  # [3, 6, 7, 8, 2]
    

    列表相关的内置函数

    • max()min()

    返回列表中的最大值和最小值

    a = [3, 2, 8, 4, 6]
    print(max(a))  # 8
    print(min(a))  # 2
    
    • sum()

    对数值型列表的所有元素进行求和操作,对非数值型列表运算则会报错。

    a = [3, 2, 8, 4, 6]
    print(sum(a))  # 23
    
    展开全文
  • 列表

    2018-03-12 12:49:27
    列表内容可以重复,列表内可以包含列表,元素之间用逗号隔开,给列表增加数据有3种方式,append(单个值),extend(单个列表),inser(位置下标,值),删除数据也有3种方式remove(值),pop(下标,为空默认删除...
  • 什么是列表? 有序 内容不限 用方括号表示,用逗号分隔其中元素 1. 创建列表 a = [1, 'ana lovelance', [1, 2, 3], 'EasyPython'] # 列表内容不限,可以嵌套列表 a1 = list(range(4)) # 使用函数 list() 2. 访问...
  • 列表

    2020-05-23 21:23:07
    列表基本知识 **列表(List)**是可变的序列,也是一种可以存储各种数据类型的集合,用( [ ] )中括号表示列表的开始和结束,元素之间用逗号( , )分隔。列表中每个元素提供一个对应的下标。 列表基本操作 ...
  • 列表

    2020-04-11 21:55:35
    初始化 ...通过索引获取和修改列表元素。与c/c++相同。 长度获取 1.len(s),等于3。此函数可以获取字符串、列表和字典的长度。但是不能修改列表元素。 2.range(s),等于3.与一样,但可以修改列表元素...
  • 列表

    2020-04-16 22:06:08
    列表是一种序列。它里面的元素可以是任意一种数据类型,列表中的值叫列表的元素或者列表项。 创建列表List 最简单的是直接用方括号括起来。 列表的类型: >>> a=[10,20,30] >>> print(a) [10, 20,...
  • 列表

    2020-10-29 09:20:10
    列表 添加元素 # 在列表尾部添加一个元素 list.append() # 在指定位置添加元素,如果下标不存在,就在末尾添加 list.insert(n, '4') # 列表合并, list2中仍有元素 list1.extend(list2) 查询列表中的值 # ...
  • 三、Python的列表

    2020-10-29 17:54:57
    列表 1、什么是列表 2、列表的创建 3、列表的查操作之获得指定元素的索引 最后一个元素的索引是 -1 。 我们想要获得列表中9这个元素的索引,也就是要找到9这个元素在列表中对应的索引: 由于列表中可以...
  • 有序列表(ol-li) <li>dd <li>aa <li>dd 如图一 可以发现在有序列表中默认的type类型是数字,而且是从1开始的。它有两个属性:type、start。 type:有五个属性值:1、a、A、i、I(罗马数字),表示列表
  • 访问字符串、列表、元组中的元素需要通过“索引”,也可以称为下标,即给字符编号,方便我们“点名”。 可以从左往右编号,即正序,起始序号是“0”,如:0、1、2、3…… 也可以从右往左编号,即逆序,起始序号是“-...
  • Python中如何求列表list的平均数

    万次阅读 多人点赞 2019-09-28 10:12:07
    Python中如何求列表list的平均数 当列表list中只包含数字时,如何求取它的平均数: from numpy import * a = [52,69,35,65,89,15,34] b = mean(a) print(b) 运行结果: 51.285714285714285 ...
  • 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杂谈 | (1)Python列表合并、去重和排序

    万次阅读 多人点赞 2018-10-13 14:10:27
    目录   一.列表合并--append() 二.列表合并--extend() ...2.列表对象的append()可以将另一个列表追加到当前列表中,作为当前列表的一个元素。 二.列表合并--extend() 与append()不同,e...
  • Python列表推导式

    万次阅读 多人点赞 2019-05-18 00:51:24
    Python列表推导式 列表推导式是Python构建列表(list)的一种快捷方式,可以使用简洁的代码就创建出一个列表. 一、range()函数 python的range()函数可用来创建一个整数列表,一般用在 for 循环中. range()语法:...
  • Redis底层详解(五) 压缩列表

    万次阅读 2018-12-12 08:04:04
    一、压缩列表概述  压缩列表是一种编码过的“链表”旨在实现高效的内存管理。它可以存储整数和字符串,整数以小端序存储,字符串则以字节数组存储。压缩列表的内存存储结构如下图所示:  其中zlbytes、zltail...
  • Android自定义的下拉列表框控件

    万次阅读 2017-10-20 13:49:40
    Android中的有个原生的下拉列表控件Spinner,但是这个控件有时候不符合我们自己的要求, 比如有时候我们需要类似windows 或者web网页中常见的那种下拉列表控件,类似下图这样的: 这个时候只有自己动手...
  • 【python】输出列表元素,以空格/逗号为分隔符

    万次阅读 多人点赞 2017-08-12 19:34:00
    输出列表元素,以空格/逗号为分隔符

空空如也

1 2 3 4 5 ... 20
收藏数 3,706,997
精华内容 1,482,798
关键字:

列表