列表的定义以及常用操作

概念：有序的、 可变的、 元素的集合

有序的就是指：列表中的元素具有一定的顺序，可以用下标索引

可变的就是指，可以进行修改

元素就是指，可以放置各种各样类型的 东西

列表的定义方式：

列表生成式：

使用情景：生成一个内容为1-99的列表

方法：range()

eg：

m = range(100)
print(list(m))##注意这个可迭代对象并不会直接转化为列表，需要用list转化类型

列表推导式：

思想：由一个列表推导出另一个列表；主要的方式有两种——1.一一映射关系，就比如将list1中的每个元素平方得到list2； 2.过滤关系，比如将list1中的奇数组成新的列表list3。

语法：[ 表达式 for 变量 in 列表 if 条件 ]

eg：

lst1 = [1,2,3,4,5]
lst2 = [i ** 2 for i in lst1 if i % 2 == 0]
print(lst2)#输出：[4, 16]

lst3 = [1 for i in lst1 if i % 2 == 0]
print(lst3)#输出：[1, 1]

lst3这个列表中的表达式有些特别，只是一个1，那么最终输出的所有结果也就都是1，新列表中的个数就为 i % 2 == 0 个

列表的常用操作

常用操作有：增、删、改、查

额外操作：判定、排序、乱序、比较、反转

语法上：这儿都是方法，而方法的基本语法为：对象 . 方法(参数)

不过要注意的是：这些方法会改变列表中的元素

列表元素的增加

1.append函数；2.insert函数 3.extend函数

append函数：

作用：追加一个新的元素

语法：append(object)

insert函数：

作用：在指定位置追加一个新的元素

语法：insert( index = , object = )

eg：

lst1 = [1,2,3,4,5]
lst1.insert(2,'j')
print(lst1)#输出：[1, 2, 'j', 3, 4, 5]

extend函数：

作用：拓展一个可迭代序列

语法：extend( iterable )

eg：

lst1 = [1,2,3,4,5]
m = range(3)
lst1.extend(m)
print(lst1)#输出：[1, 2, 3, 4, 5, 0, 1, 2]
lst1 = [1,2,3,4,5]

n = 'jiang'
lst1.extend(n)
print(lst1)#输出：[1, 2, 3, 4, 5, 'j', 'i', 'a', 'n', 'g']

lst1 = [1,2,3,4,5]
x = [1,2,'f', 'a']
lst1.extend(x)
print(lst1)#输出：[1, 2, 3, 4, 5, 1, 2, 'f', 'a']

就是将迭代对象逐个添加进列表中

列表的乘法运算：

lst = [1,2]
print(lst * 2)#输出：[1, 2, 1, 2]

注意一点：

这儿  * 2  得到的并不是把每个元素乘2，而是将每个元素重复2遍组成新列表

如果要修改的话，可以使用  列表推导式  生成列表

列表的加法运算：

lst1 = [1,2]
lst2 = ['jiang']
lst = lst1 + lst2
print(lst)#输出：[1, 2, 'jiang']

作用上：列表的加法和append那些相同，但是返回的结果上却并不相同

列表的加法得到的是一个新的列表，而且对于  ‘jiang’，和extend函数作用是有所不同的

列表的删除操作：

1. del语句   2. pop函数  3. remove函数

del语句，说明这不是函数

作用：删除指定元素

语法：del  元素

del 语句不仅可以删除列表的元素，也可以删除其他的一些东西，如列表本身

eg：#删除列表

lst1 = [1,2]
del lst1
print(lst1)#输出：NameError: name 'lst1' is not defined

eg：#删除元素

lst1 = [1,2]
del lst1[0]
print(lst1)#输出：[2]

pop函数：

作用：移除并且返回列表中的指定下标的值

语法：pop( index = -1)#默认移除最后一个

remove函数：

作用：移除列表中指定元素

语法：remove( object )

与pop区别在于，不返回删除值；其次，里面的参数是 要删除的对象而非元素的下标，因此remove在这个角度上而言会更加方便。

eg：

x = [1,2,'f', 'a','f']
x.remove('f')
print(x)#输出结果为：[1, 2, 'a', 'f']

注意这个语法：1. 对比和pop函数的不同   2. 删除的顺序是从左往右，最后一个  f  没有删除

此外，这个remove函数在循环遍历中慎重使用！，非常弄个容易判断出错，具体参考视频p93-73节大约15min左右开始讲解的例子。

也即是说，要移除列表中某一个指定元素时，下面的操作是错误的：

nums = [1,2,2,2,3,4,2]
for num in nums:
    if num == 2:
        nums.remove(2)
print(nums)#输出结果：[1, 3, 4, 2]

具体逻辑再看这些笔记时可能会忘记，具体逻辑不好记录，看视频进行了解

列表元素的修改

语法：lst[ index ] = 元素

列表元素的查询

1. 获取单个元素     2. 获取指定元素的索引    3. 获取指定元素的个数  4.获取多个元素

获取单个元素：lst [ index ]

获取指定元素的索引：lst.index(元素, start = , end = )

应用：

values = ['a','c','a','b']
#要求返回每个元素的下标索引
for i in values:
    print(i)
    print(values.index(i))
a
0
c
1
a
0
b
3
#如果是这样的话，那么无法打出后面两个字符'a'的左边，因为index只能返回最左边元素的下标

#完善方法
values = ['a','c','a','b']
currentIndex = 0
#要求返回每个元素的下标索引
for i in values:
    print(i)
    print(values.index(i, currentIndex))
    currentIndex += 1

a
0
c
1
a
2
b
3

有一个创建 索引表的小技巧：

values = ['a','c','a','b']
n = len(values)####获取列表的长度，可以间接地对应索引
IndexList = range(n)##用range函数创建索引表
for i in IndexList:
    print(values[i],i,sep=' ')##sep表示的时结果之间通过什么符号进行连接

获取指定元素的个数：count( object )

获取多个元素：切片 

列表中遍历的方式有两种：1. 按照下标进行遍历  2. 按照元素进行遍历

列表的额外操作

额外操作主要有：判定、比较、排序、乱序、反转

判定：

语法：元素 in 列表   /  元素 not in 列表；返回bool类型数据

比较：方法是运用比较运算符，针对每一个元素进行对比

value = ['a','c','a','b']
value1 = ['a','c','a','b']
value2 = ['a','c','a','c']
result1 = value == value1
print(result1)#输出True，说明这两个列表中的元素都完全相同
result2 = value == value2
print(result2)#输出False，说明这两个列表中的元素不完全相同

num = [1,2,3,4,5]
num1 = [1,2,3,4,5]
num2 = [1,2,3,4]
r1 = num == num1
print(r1)#输出True，说明这两个列表中的元素都完全相同
r2 = num == num2
print(r2)#输出False，说明这两个列表中的元素不完全相同

排序操作：

sorted函数：注意这是内建函数，和sort方法函数区分开

语法：sorted( itrearble, key = None, reverse = False )，False是默认升序

返回结果：结果是一个列表，不论之前的可迭代对象是什么。但列表本身不会发生改变

sort函数：对象方法函数

与上区别在于：自身列表会发生改变

eg：

s = [1,6,1,7,5,3,9]
result = sorted(s)
print(result, s)#输出：[1, 1, 3, 5, 6, 7, 9] [1, 6, 1, 7, 5, 3, 9]
#原列表没有发生改变
s.sort()
print(s)#输出：[1, 1, 3, 5, 6, 7, 9] ;原列表顺序发生了改变

列表乱序排列：

用法：需要random模块中的shuffle函数

语法：random . shuffle(lst)

列表反序：两种方法——对象 . reverse()  与  切片[ : : -1 ]

lst.reverse()

lst2 = lst[ : : -1]