Python数据类型-List的操作

• 目标: 掌握List数据结构的所有操作

• 注: 不断迭代更新该日志

1.序列通用操作

序列: 包含List,Tuple,字符串类型 

索引 

切片 

加法 

乘法 

序列中是否包含某个元素 

序列长度 

序列内元素的最大最小值

2.创建List

#方式1 
ls1 = [1,2,3,4,5]

#方式2
ls2 = list((1,2,3,4,5,6)) 

#把其他数据类型转换为list类型
print(ls1)
print(ls2)

#查看类型
print(type(ls1))

#是否包含某一个元素
print(1 in ls1)
print(100 in ls1)

#加法
ls3 = ls1+['python','java','Go','scala','julia']
print(ls3)

#乘法
ls4 = ls1*2
print(ls4)

[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, 6]
<class 'list'>
TrueFalse
[1, 2, 3, 4, 5, 'python', 'java', 'Go', 'scala', 'julia']
[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]

3.访问List中的元素

• 索引 (用于访问其中某单个元素)

• 切片 (用于访问一定范围内元素)

#索引操作1 
students =['小白','小菜','青铜','老鸟','王者']

#索引在0开始
print(students[0])
print(students[1])
print(students[2])
print(students[3])
print(students[4])

#测试: 索引越界会出现什么情况
# print(students[5])

#知识点: 查看list的长度
print("students的长度: %s" % len(students))

#知识点: 查看list中元素的最大值与最小值

numbers = [1,100,-1,1.123]
print("numbers的最大值: %s" % max(numbers))
print("numbers的最小值: %s" % min(numbers))

小白
小菜
青铜
老鸟
王者
students的长度: 5
numbers的最大值: 100
numbers的最小值: -1

#索引操作2
students =['小白','小菜','青铜','老鸟','王者']

#负索引print(students)
print(students[-1])
print(students[-2])
print(students[-3])
print(students[-4])
print(students[-5])

#测试: 索引越界会出现什么情况
# print(students[5])

['小白', '小菜', '青铜', '老鸟', '王者']
王者
老鸟
青铜
小菜
小白

# 切片操作1
students =['小白','小菜','青铜','老鸟','王者']

#访问一定范围内的元素
print(students)
print(students[0:2])
print(students[0:4])
print(students[0:10])

['小白', '小菜', '青铜', '老鸟', '王者']
['小白', '小菜']
['小白', '小菜', '青铜', '老鸟']
['小白', '小菜', '青铜', '老鸟', '王者']

# 切片操作2 - 切片的缺省
students =['小白','小菜','青铜','老鸟','王者']

#访问一定范围内的元素
print(students)
print(students[0:])
print(students[:4])
print(students[:])

['小白', '小菜', '青铜', '老鸟', '王者']
['小白', '小菜', '青铜', '老鸟', '王者']
['小白', '小菜', '青铜', '老鸟']
['小白', '小菜', '青铜', '老鸟', '王者']

# 切片操作3 - 切片的负边界
students =['小白','小菜','青铜','老鸟','王者']

#访问一定范围内的元素
print(students)
print(students[0:-1])
print(students[-5:-1])
print(students[-5:])

['小白', '小菜', '青铜', '老鸟', '王者']
['小白', '小菜', '青铜', '老鸟']
['小白', '小菜', '青铜', '老鸟']
['小白', '小菜', '青铜', '老鸟', '王者']

# 切片操作4 - 切片的步长
students =['小白','小菜','青铜','老鸟','王者']

#访问一定范围内的元素
print(students)
print(students[0:4:2])

#负步长: 就是由后往前访问,[m:n]  无论哪个方向m都要在n前面
print(students[0:4:-1])   

#这是由后往前访问,这个方向上,4在0的前面,所以[0:4:-1]为空
print(students[4:0:-1])
print(students[::-1])

['小白', '小菜', '青铜', '老鸟', '王者']
['小白', '青铜']
[]
['王者', '老鸟', '青铜', '小菜']
['王者', '老鸟', '青铜', '小菜', '小白']

4.操作list中的元素

• 对元组进行增删改(查在上面)

# 添加元素
students =['小白','小菜','青铜','老鸟','王者']

# students[5]='xxx'
# print(students)

#添加元素: 只能通过list自带的内置函数来操作: append()
students.append('大师')
print(students)
# print(id(students))
# students = students+'大师'    

#错误方式
# print(students)students = students+['黄金','9段']  
  
#变相的实现添加元素
print(students)
# print(id(students))

#虽然实现了添加元素,但是发现这个list的id变化了,也就是创建了一个新的list

['小白', '小菜', '青铜', '老鸟', '王者', '大师']
2523064686152
['小白', '小菜', '青铜', '老鸟', '王者', '大师', '黄金', '9段']
2523065641544

# 删除元素
students =['小白','小菜','青铜','老鸟','王者']

del students[1]
print(students)

['小白', '青铜', '老鸟', '王者']

#修改: 某个元素的值

students =['小白','小菜','青铜','老鸟','王者']
print(students)

students[1] = '小学生'
print(students)

['小白', '小菜', '青铜', '老鸟', '王者']
['小白', '小学生', '青铜', '老鸟', '王者']

#修改: 某个范围元素的值
students =['小白','小菜','青铜','老鸟','王者']
print(id(students))
students[0:3]=['新手']*3
print(students)
print(id(students))

#注意: 如下操作还能改变了list的长度: 等于删除了一部分元素
students[0:3]=['高手']
print(students)
print(id(students))

#于是,进一步,是否可以通过这种切片赋值,删除元素呢?
students[0:2]=''print(students)   
#结果证明可行print(id(students))

2523066013128
['新手', '新手', '新手', '老鸟', '王者']
2523066013128
['高手', '老鸟', '王者']
2523066013128
['王者']
2523066013128

5.Python为list内置的方法

什么是方法? 方法是封装了一定功能的代码块

• 1,append

• 2,clear

• 3,copy

• 4,count

• 5,extend

• 6,index

• 7,insert

• 8,pop

• 9,remove

• 10,reverse

• 11,sort

• 12,高级排序

# 1, append
# 创建一个list数据结构,表示一个班级内的学员,并为其添加新学员
students = ['Jack Ma','Pony Ma','Elon Musk']
students.append('Jeff Dean')
students.append('Steve Jobs')
students.append('Mark Elliot Zuckerberg')
print(students)

['Jack Ma', 'Pony Ma', 'Elon Musk', 'Jeff Dean', 'Steve Jobs', 'Mark Elliot Zuckerberg']

# 2, clear
# 清空列表内的所有学员
students = ['Jack Ma','Pony Ma','Elon Musk']
students.append('Jeff Dean')
students.append('Steve Jobs')
students.append('Mark Elliot Zuckerberg')
print(students,'\n\n')
students.clear()
print(students)

['Jack Ma', 'Pony Ma', 'Elon Musk', 'Jeff Dean', 'Steve Jobs', 'Mark Elliot Zuckerberg'] 


[]

# 3, copy  
bat=['Baidu','Alibaba','Tencent']
print('bat: ',bat)
print('id(bat): ',id(bat),'\n')

# 看似复制的操作bat_plus = bat
print('bat_plus: ',bat_plus)
print('id(bat_plus): ',id(bat_plus),'\n') 

#发现虽然变量不同,但是变量指向的是同一个数据结构
# 真正的复制
bat_cpy = bat.copy()
print('bat_cpy: ',bat_cpy)
print('id(bat_cpy): ',id(bat_cpy),'\n')   
#创建了新的内存区域,保存原来的list

bat:  ['Baidu', 'Alibaba', 'Tencent']
id(bat):  2523074153160 
bat_plus:  ['Baidu', 'Alibaba', 'Tencent']
id(bat_plus):  2523074153160 
bat_cpy:  ['Baidu', 'Alibaba', 'Tencent']
id(bat_cpy):  2523061806216

# 3, copy 进一步观察复制结果
bat=['Baidu','Alibaba','Tencent']
print('bat: ',bat)
print('id(bat): ',id(bat),'\n')

# 看似复制的操作
bat_plus = bat
print('bat_plus: ',bat_plus)
print('id(bat_plus): ',id(bat_plus),'\n') 

#发现虽然变量不同,但是变量指向的是同一个数据结构# 真正的复制bat_cpy = bat.copy()
print('bat_cpy: ',bat_cpy)
print('id(bat_cpy): ',id(bat_cpy),'\n')  
 
#创建了新的内存区域,保存原来的list#前面的代码和上一节一样,下面改变bat里面的某个元素的值,再看结果
bat[0]='Huawei'
print('bat: ',bat)
print('id(bat): ',id(bat),'\n')
print('bat_plus: ',bat_plus)
print('id(bat_plus): ',id(bat_plus),'\n')
print('bat_cpy: ',bat_cpy)
print('id(bat_cpy): ',id(bat_cpy),'\n')

bat:  ['Baidu', 'Alibaba', 'Tencent']
id(bat):  2523074736968 
bat_plus:  ['Baidu', 'Alibaba', 'Tencent']
id(bat_plus):  2523074736968 
bat_cpy:  ['Baidu', 'Alibaba', 'Tencent']
id(bat_cpy):  2523076370888 
bat:  ['Huawei', 'Alibaba', 'Tencent']
id(bat):  2523074736968 
bat_plus:  ['Huawei', 'Alibaba', 'Tencent']
id(bat_plus):  2523074736968 
bat_cpy:  ['Baidu', 'Alibaba', 'Tencent']
id(bat_cpy):  2523076370888

# 3, 另一种方式实现复制效果
bat=['Baidu','Alibaba','Tencent']
print('bat: ',bat)
print('id(bat): ',id(bat),'\n')
bat_copy = bat[:]
print('bat_copy: ',bat_copy)
print('id(bat_copy): ',id(bat_copy),'\n')

#改变一下原始list中的一个元素
bat[0]='Huawei'print('bat: ',bat)
print('id(bat): ',id(bat),'\n')  

#试验效果和copy是一样的print('bat_copy: ',bat_copy)
print('id(bat_copy): ',id(bat_copy))

bat:  ['Baidu', 'Alibaba', 'Tencent']
id(bat):  2523076896520 
bat_copy:  ['Baidu', 'Alibaba', 'Tencent']
id(bat_copy):  2523074504712 
bat:  ['Huawei', 'Alibaba', 'Tencent']
id(bat):  2523076896520 
bat_copy:  ['Baidu', 'Alibaba', 'Tencent']
id(bat_copy):  2523074504712

# 4,count 作用: 计算指定元素在列表中出现了多少次
# list列表和set集合的不同在于,list允许有重复元素出现,set集合内部元素都是唯一的
# 例如: 计算一个句子中,某一关键字出现了多少次
sentence = 'He laughs best who laughs last'
times = sentence.count('laughs')
print(times)

#因为string字符串,list列表,tuple元组三个类型一样都属于序列,都具备count这个方法,使用方式一样
# 为了熟练list的用法
words = sentence.split(' ')

#后面string章节会介绍split,这是string的内置方法,返回一个list结果
print(type(words))  

#查看返回的结果类型: 是一个
listprint(words.count('laughs'))
#list的count方法,计算某个元素的出现次数

2
<class 'list'>
2

# 5,extend 与attend类似,目的是给list列表末尾添加元素,通过实例看区别
companys=['Baidu','Alibaba','Tencent']
tmd=['Toutiao','Meituan','Didi']
print('companys列表长度: ',len(companys))
print('\n')

# 需求,将tmd中的元素,追加到companys列表中去# 方式1,使用append,看效果companys.append(tmd)
print('append方式插入后companys列表长度: ',len(companys))
print(companys)  

#会发现,tmd做为一个元素插入进了companys列表,这不是我们想要的print('\n')

#方式2, 使用extend,看效果
companys_2=['Baidu','Alibaba','Tencent']   

#对标效果,创建一个新列表companys_2.extend(tmd)
print('extend方式插入后companys_2列表长度: ',len(companys_2))
print(companys_2)

# 所以extend方法的作用,是将整个集合内的元素拆开,再追加到原列表里面

companys列表长度:  3
append方式插入后companys列表长度:  4
['Baidu', 'Alibaba', 'Tencent', ['Toutiao', 'Meituan', 'Didi']]


extend方式插入后companys_2列表长度:  6
['Baidu', 'Alibaba', 'Tencent', 'Toutiao', 'Meituan', 'Didi']

# 5,extend 与 拼接的区别
companys_1=['Baidu','Alibaba','Tencent'] 
tmd=['Toutiao','Meituan','Didi']
print('companys_1 ID: ',id(companys_1))
companys_1.extend(tmd)
print('extend执行插入后...')
print('companys_1: ',companys_1)
print('companys_1 ID: ',id(companys_1),'\n')

companys_2=['Baidu','Alibaba','Tencent']
print('companys_2 ID: ',id(companys_2))
companys_2 = companys_2+tmd
print('拼接插入后...')
print('companys_2: ',companys_2)
print('companys_2 ID: ',id(companys_2))

# 结论: 拼接得到的是一个新的列表,而extend的操作是就地执行

companys_1 ID:  2523075808904
extend执行插入后...
companys_1:  ['Baidu', 'Alibaba', 'Tencent', 'Toutiao', 'Meituan', 'Didi']
companys_1 ID:  2523075808904 
companys_2 ID:  2523076059912
拼接插入后...
companys_2:  ['Baidu', 'Alibaba', 'Tencent', 'Toutiao', 'Meituan', 'Didi']
companys_2 ID:  2523070862152

# 5, 列用切片赋值 实现与extend同样的结果
companys_1=['Baidu','Alibaba','Tencent'] 
tmd=['Toutiao','Meituan','Didi']
print('companys_1 ID: ',id(companys_1))
companys_1[len(companys_1):]=tmd
print('切片执行插入后...')
print('companys_1: ',companys_1)
print('companys_1 ID: ',id(companys_1),'\n')

companys_1 ID:  2523075282120
切片执行插入后...
companys_1:  ['Baidu', 'Alibaba', 'Tencent', 'Toutiao', 'Meituan', 'Didi']
companys_1 ID:  2523075282120

# 6 index  作用: 在列表中查找一个元素第一次出现的索引
numbers=[10,20,30,40,50]*3
print(numbers)
print('元素20在numbers列表中第一次出现的索引位置: ',numbers.index(20))
print('元素20在numbers列表中第二次出现的索引位置: ',numbers.index(20,2))
print('元素20在numbers列表中第三次出现的索引位置: ',numbers.index(20,7))

#探索一下第二个参数的意义

[10, 20, 30, 40, 50, 10, 20, 30, 40, 50, 10, 20, 30, 40, 50]
元素20在numbers列表中第一次出现的索引位置:  1
元素20在numbers列表中第二次出现的索引位置:  6
元素20在numbers列表中第三次出现的索引位置:  11

# 7,insert   在list列表某个位置插入元素
# numbers=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]   
#下面效果与该句相同numbers=list(range(0,10))   
#实践一下不同的参数: 给list函数传入的参数可以是一个range构造出来的排列,也可以是list或者tuple

print(numbers)
# 在某个位置插入一个元素numbers.insert(2,'zero')
print(numbers)

#探索,插入一个列表是什么效果? 是把列表作为一个元素插入进去,还是列表的元素展开各自作为一个元素呢?
# numbers.insert(0,[100,200,300])
# print(numbers)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 'zero', 2, 3, 4, 5, 6, 7, 8, 9]
[[100, 200, 300], 0, 1, 'zero', 2, 3, 4, 5, 6, 7, 8, 9]

# 8 pop   与append方法相反的功能,默认弹出末尾一个元素
numbers=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
print('Pop前: ',id(numbers))
numbers.pop()
print(numbers)
print('Pop后: ',id(numbers))
# 使用append/insert与pop配合就可以创建 "栈" 这种数据结构了
# 探索一下,是否可以弹出其它位置上的元素
# numbers.pop(2)
# print(numbers)

Pop前:  2523066247304[0, 1, 2, 3, 4, 5, 6, 7, 8]
Pop后:  2523066247304[0, 1, 3, 4, 5, 6, 7, 8]

# 9 remove   类似于查找index发现"第一个"符合条件的元素,这里是删除"第一个"符合条件的元素
names=['扎克伯格','小马哥','李彦宏','小马哥','张亚勤','李开复','小马哥','吴军']
names.remove('小马哥')
print(names)

['扎克伯格', '李彦宏', '小马哥', '张亚勤', '李开复', '小马哥', '吴军']

# 10,reverse 将列表倒序
numbers=[1,2,3,4,5,6]
print('倒排前: ',id(numbers))
numbers.reverse()
print(numbers)
print('倒排后: ',id(numbers),'\n')

#另一种方式实现
# numbers1 = [1,2,3,4,5,6]
# numbers2 = numbers1[::-1]
# print('倒排前: ',id(numbers1))
# numbers.reverse()
# print(numbers2)
# print('倒排后: ',id(numbers2))

倒排前:  2523075533192
[6, 5, 4, 3, 2, 1]
倒排后:  2523075533192 
倒排前:  2523077111624
[6, 5, 4, 3, 2, 1]
倒排后:  2523077111496

# 11,sort 排序
numbers=[88,18,25,100,-1,99]
print(id(numbers))
print(numbers)
print(id(numbers))   #试验证明: sort是就地操作

2523075495752
[88, 18, 25, 100, -1, 99]
2523075495752

# 测试copy之后的问题
numbers=[88,18,25,100,-1,99]
num = numbers.copy()
print(num)
numbers[1]=1000
print(numbers)
print(num)
print(sorted(num))

[88, 18, 25, 100, -1, 99]
[88, 1000, 25, 100, -1, 99]
None
None

#12 高级排序,为sort指定参数 key与reverse
# key: 就是为排序指定一个函数(自定义或者内置)
# reverse: 正序或者倒序整理排好序的列表
words=['Mark','Jack','Mark Elliot Zuckerberg','Pony Ma','Elon Musk']
words.sort(key=len)
print(words)
words.sort(key=len,reverse=True)
print(words)

#我就是盲探索一下,key以后可以用自定义的函数替代
# words=['Mark','Jack','Mark Elliot Zuckerberg','Pony Ma','Elon Musk']
# words.sort(key=min)
# print(words)
# words.sort(key=max)
# print(words)

['Mark', 'Jack', 'Pony Ma', 'Elon Musk', 'Mark Elliot Zuckerberg']
['Mark Elliot Zuckerberg', 'Elon Musk', 'Pony Ma', 'Mark', 'Jack']
['Mark Elliot Zuckerberg', 'Pony Ma', 'Elon Musk', 'Jack', 'Mark']
['Jack', 'Mark', 'Mark Elliot Zuckerberg', 'Elon Musk', 'Pony Ma']