pythoy 列表学习笔记

'''
1，列表的创建与删除
2，列表的查询操作
3，列表元素的增删改操作
4，列表元素的排序
5，列表推导式
为什么需要列表？
变量可以存储一个元素，列表是一个大容器，可以存储N个元素，程序可以方便地对这些数据进行整体操作
列表相当于其他语言中的数组
索引   -7       -6      -5   -4  -3     -2  -1
数据  'hello' 'world'  123   34  12.3   12  'world'
索引    0      1        2    3   4      5   6
'''

lst = ['hello', 'world', 123, 65.7]
print(id(lst))  # 1934092996224
print(type(lst))  # <class 'list'>
print(lst)  # ['hello', 'world', 123, 65.7]

print(id(lst[0]))
print(type(lst[0]))
print(lst[0])

print(id(lst[-4]))
print(type(lst[-4]))
print(lst[-4])
# 创建列表的第一种方式
lst1 = ['hello', 'world', 123, 65.7]

# 创建列表的第2种方式list()
lst2 = list(['hello', 'world', 123, 65.7])

# 创建列表的第2种方式list()

'''
列表的特点：
1，列表元素按顺序有序排序
2，索引映射唯一一个数据
3，列表可以存储重复数据
4，任意数据混存
5，根据需要动态分配和回收内存

索引   -7       -6      -5    -4  -3     -2  -1
数据  'hello' 'world'  123   34  12.3   12  'world'
索引    0      1        2    3   4      5    6

正向索引从 0 ~ N-1  如： lst[0]
逆向索引从—N ~ -1   如： lst[—N]

'''

print("======================48集 列表的查寻操作========================")
'''
获取列表中指定元素的索引
index():  查询列表中存在N个相同元素，只返回相同元素中的第一个元素的索引
          如果查询的元素在列表中不存在，则会抛出ValueError
          还可以在指定的satrt和stop之间进行查找
                   
获取列表中的单个元素
正向索引从 0 ~ N-1  如： lst[0]
逆向索引从—N ~-1    如： lst[—N]
指定索引不存在，则会抛出ValueError

'''
lst = ["hello", "world", 98, "hello"]
print(lst.index('hello'))  # 0 查询列表中存在N个相同元素，只返回相同元素中的第一个元素的索引
# print(lst.index('python'))  # ValueError: 'python' is not in list  如果查询的元素在列表中不存在，则会抛出ValueError
# print(lst.index('hello', 1, 3))  #   从第一个位置开始到索引为3的地方查找，但是不包括3 ValueError: 'hello' is not in list
print(lst.index('hello', 1, 4))

'''
列表切片语法格式
列表名[start : stop : step]

    索引     -9 -8 -7 -6 -5 -4 -3 -2 -1
             [1, 2, 3, 4, 5, 6, 7, 8, 9]
     索引     0  1  2  3  4  5  6  7  8

'''
lst = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print('源列表', id(lst))
# start =1,stop =6,step=1
print(lst[1:6:1])  # [2, 3, 4, 5, 6]   从索引为1开始，到第5个结束，不包括6，步长为1
print(lst[1:6:])   #冒号后面不写也代表步长为1
print('切的列表片段', id(lst[1:6:1])) #拷贝出来的内容存到新地方
# start =1,stop =6,step=2
print(lst[1:6:2]) #[2, 4, 6]

# stop =6,step=2
print(lst[:6:2]) #[1, 3, 5]  缺start 则从第0个索引开始

# start =1,step=2
print(lst[1::2]) #stop没有指定，则一直到最后


'''
step为负数  ：
             [:stop:step]  切片的第一个元素默认是列表的最后一个元素，从start开始往前计算切片
             [start::step]  切片的第一个元素默认是列表的第一个元素，从start开始往前计算切片
     索引     -9 -8 -7 -6 -5 -4 -3 -2 -1
             [1, 2, 3, 4, 5, 6, 7, 8, 9]
     索引      0  1  2  3  4  5  6  7  8
             
'''
print('源列表', lst)#源列表 [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(lst[::-1])#         [9, 8, 7, 6, 5, 4, 3, 2, 1]
# start =7,stop 省略,step=-1
print(lst[7::-1]) #[8, 7, 6, 5, 4, 3, 2, 1]
# start =6,stop=0 ,step=-2
print(lst[6:0:-2])#[7,5,3]  不包括 stop 对应的索引位置

'''
判断指定元素在列表中是否存在
元素 in 列表名
元素 not in 列表名

列表元素的遍历
for 迭代变量 in 列表名
'''
print('p' in 'python')
print('k' not in 'python')

lst = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(10 in lst)
print(100 not in lst)

for i in lst:
    print(i, end='\t')

print('===========52集==========')
'''
列表元素的增加操作
append() 在列表的末尾添加一个元素
extend() 在列表的末尾至少添加一个元素（一次添加多个）
insert() 在列表的任意位置添加一个元素
切片      在列表的任意位置至少添加一个元素
'''

lst = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print('添加之前',lst,id(lst))
lst.append(20)  #在列表的末尾添加一个元素
print('添加之后',lst,id(lst))
lst2 =['hello','world']
lst.append(lst2) #将lst2作为一个元素，添加在列表的末尾
print('添加之后',lst,id(lst)) #[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 20, ['hello', 'world']] 2186363080320

lst.extend(lst2)#将lst2里的每一个元素，添加在列表的末尾
print('添加之后',lst,id(lst))# 添加之后 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 20, ['hello', 'world'], 'hello', 'world'] 1800063880832

lst3 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print('添加之前',lst3,id(lst3))
lst3.insert(1,12)
print('添加之后',lst3,id(lst3))

lst4 = [True,False,'he']
lst3[1:]=lst4  #把第1个位置向后的所有元素都切掉，并把lst4 的元素放到1的位置上
print('添加之后',lst3,id(lst3))#  添加之后 [1, True, False, 'he'] 2262640187392


'''
53.列表元素的删除操作

remove()  一次删除一个元素
          重复元素只删除第一个
          元素不存在抛出ValueError
          
pop()     删除一个指定索引位置的元素
          如果指定索引不存在抛出ValueError
          不指定索引，删除最后一个元素
          
切片     一次至少删除一个元素，将产生一个新的列表对象

clear() 清空列表

del     删除列表
'''
lst3 = [1, 2, 3, 3, 5, 6, 7, 8, 9, 10]
lst3.remove(3)  # 一次删除一个元素，重复元素只删除第一个
print(lst3)  # [1, 2, 3, 5, 6, 7, 8, 9, 10]
# lst3.remove(100) #不存在抛出ValueError: list.remove(x): x not in list
lst3.pop(1)  # 删除一个指定索引位置的元素
print(lst3)  # [1, 3, 5, 6, 7, 8, 9, 10]
lst3.pop()  # 不指定索引，删除最后一个元素
print(lst3,id(lst3))  # [1, 3, 5, 6, 7, 8, 9]  1131877327936

new_list = lst3[1:3] #一次至少删除一个元素，将产生一个新的列表对象
print(new_list,id(new_list)) # [3, 5] 1131877390720

print('=================================')
'''
不产生新的列表对象，而是删除原来列表中的内容
'''
lst3 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(lst3,id(lst3))#[1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 2494568294784
lst3[1:3] =[] # 使用空列表将原来列表的这个切片位置替代
print(lst3,id(lst3))#[1, 4, 5, 6, 7, 8, 9, 10] 2494568294784
lst3.clear()
print(lst3,id(lst3))#[] 1908272757184

del lst3
print(lst3,id(lst3)) #NameError: name 'lst3' is not defined

lst = [10, 20, 30, 40, 50, 60, 70]
print(lst)
lst[2] = 100
print(lst)
lst[1:3] = ['a', 'b', 'c']  # 索引为1和2位置的元素被替换，不包含索引3
print(lst)  # [10, 'a', 'b', 'c', 40, 50, 60, 70]

print('=========列表的排序操作================')
lst = [10, 20, 30, 40, 50, 60, 70]
print(lst, id(lst))
lst.reverse()
print(lst, id(lst))
lst.sort()
print(lst, id(lst))
# 通过指定关键字参数，将列表中的元素进行降序排序
lst.sort(reverse=True)  # 降序排序
print(lst, id(lst))
lst.sort(reverse=False)
print(lst, id(lst))  # 默认升序排序
print("====使用内置函数sorted()对列表进行排序，将产生一个新的列表对象，原列表不发生改变=================")
lst = [10, 70, 40, 20, 50, 60, 30]
print(lst, id(lst))
new_list = sorted(lst)
print(lst, id(lst))  # 源列表没有任何变化
print(new_list, id(new_list))
new_list = sorted(lst, reverse=True)  # 降序排序
print(lst, id(lst))  # 源列表没有任何变化
print(new_list, id(new_list))

print('======列表生成式=========')
'''
语法：
[i*i  for  i in range(1,10)]
i*i 表示列表元素的表达式
range(1,10) 可迭代对象
注意：表示列表元素的表达式中，通常包含自定义变量
'''

lst = [i for i in range(1, 10)]  # [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(lst, id(lst))
lst = [i * i for i in range(1, 10)]  # 每次取出的数字是i，for前面的表达式是列表元素的表达式
print(lst, id(lst))

lst1 = [i*2 for i in range(1, 6)]
print(lst1, id(lst1)) #[2, 4, 6, 8, 10]