python列表基础知识

‘’'已知—个列表
lst = [1,2,3,4,5]

1. 求列表的长度
2. 判断6 是否在列表中
3. lst + [6, 7, 8] 的结果是什么? 4. lst*2 的结果是什么
4. 列表里元素的最大值是多少 6. 列表里元素的最小值是多少 7. 列表里所有元素的和是多少
5. 在索引1的后面新增—个的元素10 9. 在列表的末尾新增—个元素20
   ‘’’

#1.
lst=[1,2,3,4,5]
print(len(lst))
#2. in
print(6 in lst)
#3.
print(lst+[6,7,8])
#4 lst*2 相当于输出两遍
print(lst*2)
#5.max()
print(max(lst))
#6.min()
print(min(lst))
#7.sum()
print(sum(lst))
#8. 插入 insert
lst.insert(1,10)
print(lst)
#9. append
lst.append(20)
print(lst)

#请将列表里所有数字修改成原来的两倍

lst=[1, [4, 6], True]
lst[0] = 2
lst[1][0] = 8
lst[1][1] = 12
print(lst)
#或者写个函数 实现

def double_list(lst):
    for index, item in enumerate(lst):
        if isinstance(item, bool):
            continue
        if isinstance(item, (int, float)):
            lst[index] *= 2
        if isinstance(item, list):
            double_list(item)
    return lst

if __name__ == '__main__':
    
    lst = [1, [4, 6], True]
    double_list(lst)
    print(lst)

#元组
print((1,2)*2)
print((1,)*2)
print((1)2)
#元组里只有—个数据时，必须有逗号，如果没 有逗号，就变成了第3题的形式，第3题本质上是12,那对小括号就如同我们小学学过的小括号 —样，只是为了体现运算优先级而已。

#合并列表 列表是可变对象

#合并列表
lst1 = [1, 2, 3]
lst2 = [4, 5, 6]
lst3 = [7, 8, 9]

#方法1
lst1.extend(lst2)
lst1.extend(lst3)
print(lst1)
#方法2
lst1 = [1, 2, 3]
lst2 = [4, 5, 6]
lst3 = [7, 8, 9]
lst1.extend(lst2 + lst3)
#append 和extend 的区别append()将整个对象作为一个元素添加，而extend()则将对象的元素逐个添加
#这个过程中不会产生新的列表，最直观的检验方式就是print（id（lst））,合并前后，lst的内存地址 都没有发生变化，只是列表里的内容发生了变化
#因为列表是可变对象

#合并字符串 字符串是不可变对象

str1='abd'
str2='cdef'
str1+=str2
print(str1)
#这个过程中，产生的新的字符串，字符串是不可变对象，从字面上理解，似乎str1的内容发生  变化了，但本质上是产生了新的字符串并赋值给str1，    print（str1），   合并前后的内存地址是不 —样的

#字符串是不可变对象

#统计练习
‘’‘1. 找出列表里的最大值
2. 找出列表里的最小值
3. 找出列表里最大值的个数 4. 计算列表里所有元素的和 5. 计算列表里元素的平均值 6. 计算列表的长度
7. 找出元素6在列表中的索引’‘’

lst = [2, 5, 6, 7, 8, 9, 2, 9, 9]
print(max(lst))
print(min(lst))
print(lst.count(max(lst))) #计数 用到 count
print(sum(lst))
print(sum(lst)/len(lst)) #总和除以个数
print(lst.index(6)) #索引 index

#列表操作练习
‘’‘1. 在列表的末尾增加元素15
2. 在列表的中间位置插入元素20
3. 将列表[2， 5，6]合并到lst中
4. 移除列表中索引为3的元素
5. 翻转列表里的所有元素
6. 对列表里的元素进行排序，从小到大—次，从大到小—次’‘’

lst = [2, 5, 6, 7, 8, 9, 2, 9, 9]
lst.append(15) #append()

lst.insert(len(lst)//2,20)
lst.extend([2,5,6]) #extend()
lst.remove(lst[3]) #remove() 移除的是值
lst.reverse() #反转
lst.sort() #正向排序
print(lst)
lst.sort(reverse=True) #逆向排序
print(lst)

#复杂列表练习
‘’'1. 列表lst的长度是多少
2. 列表lst中有几个元素
3. lst[1] 的数据类型是什么
4. lst[3]的数据类型是什么
5. lst[3][4] 的值是什么
6. 如果才能访问到 9 这个值

7. 执行lst[3][4].append（[5， 6]）后，列表lst的内容是什么，手写出来 8. lst[-1][-1][-2]的值是什么
8. lst[-1][-1][-2]的值是什么
9. lst[-2]的值是什么
10. len（lst[-1]） 的值是什么
11. len（lst[-1][-1]）的值是什么
12. lst[-1][1:3] 的值是什么
13. lst[-1][-1][1:-2]的值是什么

‘’’
lst = [1, 4, 5, [1, 3, 5, 6, [8, 9, 10, 12]]]
#第1题和第2题其实是—个意思,原本统计列表里数据个数不是什么难事,可—旦出现了嵌套列 表的情况,有人就分不清了,

列表里的数据是以逗号分隔的,lst[3] 是—个列表,其余都是int 类型数据,因此lst的长度是4

#第5题,lst[3]的值是[1, 3, 5, 6, [8, 9, 10, 12]],仍然是—个列表,其索引为4的数据是[8, 9,10, 12],是列表
#6.lst[3][4][1]
#第7题,[1, 4, 5, [1, 3, 5, 6, [8, 9, 10, 12, [5, 6]]]]
#第8题,lst[-1]的值是[1, 3, 5, 6, [8, 9, 10, 12]], 再次取索引为-1的数据为[8, 9, 10, 12],取 索引为-2的数据为10
‘’‘第9题,5
第10题,5
第11题,4
第12题, [3, 5], lst[-1]的值是[1, 3, 5, 6, [8, 9, 10, 12]]
第13题,[9], lst[-1][-1]的值是[8, 9, 10, 12],切片起始位置索引是1,值为9,结束位置 是-2,值为10,由于左闭右开,最终结果是[9]
‘’’