访问列表中的值

有两种方法访问列表中的值：
1.使用下标索引来访问列表中的值；

list1=[1,2,3,4,5]
print(list1[0])
#Output: 1

print(list[-2]) #访问列表第倒数第2个元素
#Output: 4

2.使用方括号的形式截取字符；

list1=[1,2,3,4,5]
print(list1[1:4]) #第2个元素到第4个元素
#Output: [2,3,4]

print(list1[2:]) #第3个元素及其之后的元素
#Output: [3,4,5]

print(list1[:3]) #第3个元素及其之前第元素
#Output: [1,2,3]

更新列表

1.直接对列表的数据项进行修改或更新；

list1=[1,2,3,4,5]
list1[0]=6
print(list1)
#Output: [6,2,3,4,5]

list1[1:3]=[100,101,102,103]
print(list1)
#Output: [6,100,101,102,103,4,5]

2.使用append()方法在列表末尾添加新的对象；

list1=[1,2,3,4,5]
list1.append(6)
print(list1)
#Output: [1,2,3,4,5,6]

3.使用insert()方法将指定对象插入列表的指定位置；

list1=['a','b','c','d']
list1.insert(2, 'A')
print(list1)
#Output: ['a','b','A','c','d']

4.使用reverse() 方法反向列表中元素；

list1=[1,2,3,4,5]
list1.reverse()
print(list1)
#Output: [5,4,3,2,1]

删除列表中的元素

1.使用 del 语句来删除列表的的元素；

list1=[1,2,3,4,5]
del list1[3] #删除第4个元素
print(list1)
#Output: [1,2,3,5]

2.使用remove() 方法移除列表中某个值的第一个匹配项；

list1=[1,2,3,4,5,1]
list1.remove(1)
print(list1)
#Output: [2,3,4,5,1]

3.使用pop() 函数移除列表中的一个元素（默认最后一个元素），并且返回该元素的值；

list1=[1,2,3,4,5]
list1.pop()
print(list1)
#Output: [1,2,3,4]

list1.pop(2)
print(list1)
#Output: [1,2,4]

4.使用clear() 函数清空列表，类似于 del list1[:]；

list1=[1,2,3,4,5]
list1.clear()
print(list1)
#Output: []

列表脚本操作符

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

Python 表达式

结果

描述

len([1, 2, 3])

3

长度

[1, 2, 3] + [4, 5, 6]

[1, 2, 3, 4, 5, 6]

组合

[‘Hi!’] * 4

[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]

重复

3 in [1, 2, 3]

True

元素是否存在于列表中

for x in [1, 2, 3]: print(x, end=" ")

1 2 3

迭代

列表截取与拼接

1.直接使用脚本操作符号+进行列表拼接，如前所述；

2.使用extend() 函数在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）；

list1 = ['a', 'b', 'c']
list2=list(range(5)) # 创建 0-4 的列表
list1.extend(list2)  # 扩展列表
print(list1)
#Output: ['a','b','c',1,2,3,4,5]

extend 与 append 方法的相似之处在于都是将新接收到参数放置到已有列表的后面。而 extend 方法只能接收 list，且把这个 list 中的每个元素添加到原 list 中。而 append 方法可以接收任意数据类型的参数，并且简单地追加到 list 尾部。

其他列表函数&方法

1.len() 方法返回列表元素个数；

list1=[1,2,3,4,5]
print(len(list1))
#Output: 5

2.max() 方法返回列表元素中的最大值；

list1=[1,2,3,4,5]
print(max(list1))
#Output: 5

3.min() 方法返回列表元素中的最小值；

list1=[1,2,3,4,5]
print(min(list1))
#Output: 1

4.list() 方法用于将元组或字符串转换为列表；

aTuple = (123, 'Google', 'Runoob', 'Taobao')
list1 = list(aTuple)
print (list1)
#Output: [123, 'Google', 'Runoob', 'Taobao']

str="Hello World"
list2=list(str)
print (list2)
#Output: ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']

注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。

5.count() 方法用于统计某个元素在列表中出现的次数；

list1=['a','b','c','d','e','b']
print(list1.count('b'))
#Output: 2

6.copy() 函数用于复制列表，类似于 list1[:]；

list1=[1,2,3,4,5]
list2=list1.copy()
print(list2)
#Output: [1,2,3,4,5]

7.index() 函数用于从列表中找出某个值第一个匹配项的索引位置；

list1=['a','b','c','d','e','c']
print(list1.index('c'))
#Output: 2

该方法返回查找对象的索引位置，如果没有找到对象则抛出异常。

8.sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。

语句：list.sort(cmp=None, key=None, reverse=False)

参数
cmp – 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）。

list1 = ['Google', 'Runoob', 'Taobao', 'Facebook']
list1.sort()
print(list1)
#Output: ['Facebook', 'Google', 'Runoob', 'Taobao']


#1 降序
vowels = ['e', 'a', 'u', 'o', 'i']
vowels.sort(reverse=True)
print(vowels)
#Output: ['u', 'o', 'i', 'e', 'a']


#2 通过指定列表中的元素排序来输出列表：
# 获取列表的第二个元素
def takeSecond(elem):
    return elem[1]
    
random = [(2, 2), (3, 4), (4, 1), (1, 3)]
random.sort(key=takeSecond)# 指定第二个元素排序
print (random)
#Output: [(4, 1), (2, 2), (1, 3), (3, 4)]


#3 根据列表中元素的长度排序
def list_sort_by_length():  
    list=["delphi","Delphi","python","Python","c++","C++","c","C","golang","Golang"]  
    list.sort(key=lambda ele:len(ele)) #按元素长度顺序升序排列  
    print("升序:",list)  
  
    list.sort(key=lambda ele:len(ele),reverse=True) #按降序排列  
    print("降序:",list)
#借助于 lambda 表达式，计算 list 列表中的元素的长度，根据元素的长度进行排序。
#Output：
#升序: ['c', 'C', 'c++', 'C++', 'delphi', 'Delphi', 'python', 'Python', 'golang', 'Golang']  
#降序: ['delphi', 'Delphi', 'python', 'Python', 'golang', 'Golang', 'c++', 'C++', 'c', 'C']


#4 根据列表中元素的多个属性进行排序：
def two_d_list_sort():  
    list=[ ["1","c++","demo"],  
           ["1","c","test"],  
           ["2","java",""],  
           ["8","golang","google"],  
           ["4","python","gil"],  
           ["5","swift","apple"]  
    ]  
    list.sort(key=lambda ele:ele[0])# 根据第1个元素排序  
    print(list)  
    list.sort(key=lambda ele:ele[1]) #先根据第2个元素排序  
    print(list)  
    list.sort(key=lambda ele:ele[1]+ele[0]) #先根据第2个元素排序，再根据第1个元素排序  
    print(list)
#Output: 同样借助于 lambda 表达式完成，当然也可以定义一个与 labmda 具有相同意义的函数实现排序。
#Output: 
#[['1', 'c++', 'demo'], ['1', 'c', 'test'], ['2', 'java', ''], ['4', 'python', 'gil'], ['5', 'swift', 'apple'], ['8', 'golang', 'google']]  
#[['1', 'c', 'test'], ['1', 'c++', 'demo'], ['8', 'golang', 'google'], ['2', 'java', ''], ['4', 'python', 'gil'], ['5', 'swift', 'apple']]  
#[['1', 'c++', 'demo'], ['1', 'c', 'test'], ['8', 'golang', 'google'], ['2', 'java', ''], ['4', 'python', 'gil'], ['5', 'swift', 'apple']]


#5 动态的根据用户指定的索引进行排序
def two_d_list_sort2(sort_index="0,1,2"): # 动态的根据传入的元素索引进行排序  
    list=[ ["1","c++","demo"],  
           ["1","c","test"],  
           ["2","java",""],  
           ["8","golang","google"],  
           ["4","python","gil"],  
           ["5","swift","apple"]  
           ]  
    key_set=""  
    for item in sort_index.split(","):  
        key_set+="ele["+item+"]+"  
    key_set=key_set.rstrip("+")  
    list.sort(key=lambda ele:eval（key_set))  
    print("排序索引:",sort_index,list)  
  
if __name__=="__main__":  
    two_d_list_sort2("0")  
    two_d_list_sort2("1")  
    two_d_list_sort2("2")  
    two_d_list_sort2("1,0")
#有时候，在写代码之前，并不知道根据二维表的哪几列排序，而是在程序运行的时候根据输入或配置决定的。
#为了解决这个动态根据多个列或属性排序的问题，借助了 eval（) 函数，eval（) 函数能够把字符串编译成 python 代码并运行，从而达到动态根据多个列或属性排序的目的。
#Output: 
#排序索引: 0 [['1', 'c++', 'demo'], ['1', 'c', 'test'], ['2', 'java', ''], ['4', 'python', 'gil'], ['5', 'swift', 'apple'], ['8', 'golang', 'google']]  
#排序索引: 1 [['1', 'c', 'test'], ['1', 'c++', 'demo'], ['8', 'golang', 'google'], ['2', 'java', ''], ['4', 'python', 'gil'], ['5', 'swift', 'apple']]  
#排序索引: 2 [['2', 'java', ''], ['5', 'swift', 'apple'], ['1', 'c++', 'demo'], ['4', 'python', 'gil'], ['8', 'golang', 'google'], ['1', 'c', 'test']]  
#排序索引: 1,0 [['1', 'c++', 'demo'], ['1', 'c', 'test'], ['8', 'golang', 'google'], ['2', 'java', ''], ['4', 'python', 'gil'], ['5', 'swift', 'apple']]

综上，基本总结了 list.sort 的使用的大部分场景，如下：
1、默认排序
2、根据类对象的单个属性进行排序，当然也可以扩展为根据类对象的多个属性进行排序
3、根据元素的固有属性进行排序，如：长度、第N个元素等。为了简单，所以借助了 lambda 表达式，当然也可以使用普通函数代替 lambda 表达式
4、动态的根据多个列进行排序，同时借助 lambda 和 eval（) 函数实现
可能还有一些场景没有涉及到，不过我相信，上面的几种情况可以满足90%以上的场景了，如果在使用中有问题欢迎留言交流。