Python基础 D-01 数据类型-集合数据类型-List（列表）

数据类型-集合数据类型-List（列表）

一、什么是列表

1.1、定义

• 定义：[]内以逗号分隔，按照索引，存放各种数据类型，每个位置代表一个元素。

1.2、特点

• 可存放多个值
• 按照从左到右的顺序定义列表元素，下标从0开始顺序访问，有序
  
• 可修改指定索引位置对应的值，可变

二、列表的创建

a、普通方法创建一个列表

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list1 = ['Google', 'Runoob', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]

b、内置方法创建一个特殊列表

• 内置生成列表函数方法range()。注意：range顾头不顾尾

range
>>> range(1,100)
range(1, 100)
>>> list(range(1,100))  # 不包含100
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 
 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 
 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(0,100,2))
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 
56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98]

c、创建嵌套列表

使用嵌套列表即在列表里创建其它列表，例如：

list1 = [1, 2, 3, 4, [a, b, c] ]

三、列表的操作

3.1、列表通过非函数方法操作

a、访问列表中的值

• 使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符，顾头不顾尾。
• 注意切片访问是生成一个新的，分配的是一个新内存地址
  如下所示：

#!/usr/bin/python3
 
list1 = ['Google', 'Runoob', 1997, 2000]
list2 = [1, 2, 3, 4, 5, 6, 7]
list3 = [['a', 'b', 'c'], [1, 2, 3]]

print("list1[0]: ", list1[0])           # 正向访问某个值
print("list1[-2]: ", list1[-2])         # 逆向访问某个值
print("list2[1:5]: ", list2[1:5])       # 带起始结束值的正向切片
print("list2[2:]: ", list2[2:])         # 只带起始值的正向切片
print("list2[:3]: ", list2[:3])         # 只带结束值的正向切片
print("list2[-6:-2]: ", list2[-6:-2])   # 带起始结束值的逆向切片
print("list2[-5:]: ", list2[-5:])       # 只带起始值的逆向切片
print("list2[:-4]: ", list2[:-4])       # 只带起始值的逆向切片
print("list2[1:5:2]: ", list2[1:5:2])   # 带起始结束值,并带步长的正向切片
print("list2[::-1]: ", list2[::-1])     # 不带起始结束值,并带负步长的列表反转
print("list2[::-2]: ", list2[::-2])

"""输出结果
list1[0]:  Google
list1[-2]:  1997
list2[1:5]:  [2, 3, 4, 5]
list2[2:]:  [3, 4, 5, 6, 7]
list2[:3]:  [1, 2, 3]
list2[-6:-2]:  [2, 3, 4, 5]
list2[-5:]:  [3, 4, 5, 6, 7]
list2[:-4]:  [1, 2, 3]
list2[1:5:2]:  [2, 4]
list2[::-1]:  [7, 6, 5, 4, 3, 2, 1]
list2[::-2]:  [7, 5, 3, 1]
list3[0] : ['a', 'b', 'c']
list3[1][1] : 2
"""

• 使用for循环访问列表中的值

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

b、修改列表中的值

• 下标访问修改

#!/usr/bin/python3
 
list = ['Google', 'Runoob', 1997, 2000]
 
print ("第三个元素为 : ", list[2])
list[2] = 2001
print ("更新后的第三个元素为 : ", list[2])

"""输出结果
第三个元素为 :  1997
更新后的第三个元素为 :  2001
"""

• 运算符修改

list3 = ['a', 1]
list4 = ['b', 2]

print("['a', 1] + ['b', 2] :", list3 + list4)
print("['a', 1] * 2 :", list3 * 2)

"""输出结果
['a', 1] + ['b', 2] : ['a', 1, 'b', 2]
['a', 1] * 2 : ['a', 1, 'a', 1]
"""

3.2、列表通过函数方法操作

a、函数列举

类别	函数方法	描述
列表创建	list(seq)	将元组转换为列表
	list.copy()	复制列表
列表查询	len(list)	列表元素个数
	max(list)	返回列表元素最大值
	min(list)	返回列表元素最小值
	list.count(obj)	统计某个元素在列表中出现的次数
	list.index(obj)	从列表中找出某个值第一个匹配项的索引位置
列表添加	list.append(obj)	在列表末尾添加新的对象
	list.insert(index, obj)	将对象插入列表
	list.extend(seq)	在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
列表删除	list.pop([index=-1])	移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
	list.remove(obj)	移除列表中某个值的第一个匹配项
	list.clear()	清空列表
列表排序	list.reverse()	反向列表中元素
	list.sort( key=None, reverse=False)	对原列表进行排序,注意没有返回值

b、列表的增加操作

• 追加，数据会追加到尾部

>>> names
['alex', 'jack']
>>> names.append("rain")
>>> names.append("eva")
>>> 
>>> names
['alex', 'jack', 'rain', 'eva']

• 插入，可插入任何位置

>>> names.insert(2,"黑姑娘")
>>> names
['alex', 'jack', '黑姑娘', 'rain', 'eva']
>>>

• 合并,可以把另一外列表的值合并进来

>>> n2 = ["狗蛋","绿毛","鸡头"]
>>> names
['alex', 'jack', '黑姑娘', 'rain', 'eva']
>>> names.extend(n2)
>>> names
['alex', 'jack', '黑姑娘', 'rain', 'eva', '狗蛋', '绿毛', '鸡头']

• 列表嵌套

>>> names.insert(2,[1,2,3])
>>> names 
['alex', 'jack', [1, 2, 3], '黑姑娘', 'rain', 'eva', '狗蛋', '绿毛', '鸡头']
>>> names[2][1]
2

c、删除操作

• del 直接删

>>> names
['alex', 'jack', [1, 2, 3], '黑姑娘', 'rain', 'eva', '狗蛋', '绿毛', '鸡头']
>>> del names[2]
>>> names
['alex', 'jack', '黑姑娘', 'rain', 'eva', '狗蛋', '绿毛', '鸡头']

• pop 删

>>> names
['alex', 'jack', '黑姑娘', 'rain', 'eva', '狗蛋', '绿毛', '鸡头']
>>> names.pop() #默认删除最后一个元素并返回被删除的值
'鸡头'
>>> names
['alex', 'jack', '黑姑娘', 'rain', 'eva', '狗蛋', '绿毛']
>>> names.pop(1)  #删除指定元素
'jack'

• clear 清空

>>> n2
['狗蛋', '绿毛', '鸡头']
>>> n2.clear()
>>> n2
[]

d、排序&反转方法介绍

排序

• 描述：sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。默认根据ascii表进行排序。
• 语法： list.sort( key=None, reverse=False)
• 参数：
  • key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
  • reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）。
• 返回值：该方法没有返回值，但是会对列表的对象进行排序。
• 代码实例：

#!/usr/bin/python
 
aList = ['Google', 'Runoob', 'Taobao', 'Facebook']
aList.sort()
print ( "List : ", aList)

"""输出结果
List :  ['Facebook', 'Google', 'Runoob', 'Taobao']
"""

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

"""输出结果
降序输出: ['u', 'o', 'i', 'e', 'a']
"""

# 获取列表的第二个元素
def takeSecond(elem):
    return elem[1]
 
# 列表
random = [(2, 2), (3, 4), (4, 1), (1, 3)]
 
# 指定第二个元素排序
random.sort(key=takeSecond)
 
# 输出类别
print ('排序列表：', random)
"""输出结果
排序列表：[(4, 1), (2, 2), (1, 3), (3, 4)]
"""

反转

• 描述：reverse() 函数用于反向列表中元素。
• 语法：list.reverse()
• 参数：NA
• 返回值：该方法没有返回值，但是会对列表的元素进行反向排序。
• 代码实例：

#!/usr/bin/python3

list1 = ['Google', 'Runoob', 'Taobao', 'Baidu']
list1.reverse()
print ("列表反转后: ", list1)
"""输出结果
列表反转后:  ['Baidu', 'Taobao', 'Runoob', 'Google']
"""