定义列表

声明一个空列表： 变量 = [] 或者 变量 = list()

1
2
3
4
5
listvar = []
print(listvar,type(listvar))

listvar = list()
print(listvar,type(listvar))

声明带有数据的列表：

1
2
变量 = [值,值,值....]
变量 = list(容器类数据)  本质上就是类型转换
1
2
3
4
5
listvar = ['php','javascript','java','python',233,333]
print(listvar,type(listvar))

listvar = list(('java','c++','c','c#',666))
print(listvar,type(listvar))

列表的基本操作

1
2
3
4
5
访问列表中的值:变量[索引]
修改列表中的值:变量[索引] = 新值
删除列表中的值：del 变量[索引]
添加列表中的值:不可以使用索引直接增加
删除变量：del 变量
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
#           0     1      2     3      4    正向索引
heros = ['关羽','张飞','黄忠','马超','赵云']
#          -5    -4     -3    -2     -1    反向索引

#访问列表中的值
print(heros[1])
print(heros[-4])

#修改列表中的值
heros[4] = '赵子龙'
heros[-4] = '张翼德'
print(heros)

#删除列表中的值
#删除黄忠
#del heros[-3]
del heros[2]
print(heros)

#列表值的添加(列表的值不可以通过索引直接增加)
heros[5] = '刘备'
print(heros)

#删除列表变量本身：什么变量能删
del heros

列表的分片操作

1
2
3
4
5
6
7
8
基本格式：
  变量[开始索引:结束索引]   从开始索引获取到结束索引之前（不包含结束索引）
  变量[开始索引:]           从开始索引位置截取到最后
  变量[:结束索引]           从开头截取到结束索引之前（不包含结束索引）
  变量[:]                   截取整个列表内容

高级格式：
  变量[开始索引:结束索引:跳步值]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#        0      1      2        3       4     5      6
wei = ['张辽','许褚','夏侯惇','夏侯渊','曹洪','曹丕','曹植']
#        -7    -6      -5      -4      -3     -2     -1
#1.变量[开始索引:结束索引]
print(wei[2:4])
#2.变量[开始索引:]
print(wei[3:])
#3.变量[:结束索引]
print(wei[:3])
#4.变量[:]
print(wei[:])
#5.带有跳步的分片操作
print(wei[::2])
print(wei[1::2])

列表的分片赋值：（不能设置跳步值）

1
2
3
4
5
6
增加内容
  变量[开始索引:结束索引] = 列表数据   （注意开始索引与结束索引一直，在指定索引之前增加内容）
删除内容
  变量[开始索引:结束索引] = []  (删除了开始索引到结束索引之间的数据，不包含结束索引位置)
修改内容
  变量[开始索引:结束索引] = 列表数据    （一般保持删除多少，添加多少，就是修改操作）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#          0      1      2      3        4       5
girls = ['大乔','小乔','甄姬','黄月英','张春华','貂蝉']
#          -6     -5    -4      -3      -2      -1

#添加列表内容
#girls[3:3] = ['孙尚香']
girls[3:3] = ['孙尚香','糜夫人','甘夫人']
print(girls)

#删除列表内容
#girls[2:3] = [] #删除指定的一个数据
girls[1:4] = [] #删除连续的多个数据
print(girls)

#修改列表内容
#girls[2:3] = ['甄嬛'] #修改一个数据
#修改连续的多个数据
girls[0:2] = ['大河','小河']
print(girls)

#尝试跳步值(不可以使用)
#girls[1:4:1] = []
#print(girls)

列表的其他运算

1
2
3
*   列表乘法运算【序列相乘运算】
+   列表加法运算【序列相加运算】
in  和 not in   成员检测运算
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#*  相乘
boys = ['关羽','张飞','刘备']
result = boys * 4
print(result,type(result))

# + 相加
boys1 = ['关羽','张飞','刘备']
boys2 = ['赵云','马超','黄忠']
result = boys1 + boys2
print(result,type(result))

#成员检测运算
wu = ['孙权','孙策','孙坚','乐进']
#in 检测某个值是否在列表中
result = '孙策' in wu
print(result)
#not in 检测某个值是否不在列表中
result = '孙坚' not in wu
print(result)

列表常用函数

1
2
3
4
5
6
7
8
9
max()  获取列表中的最大值或者多个参数中的最大值
  max(列表)
  max(值,值,...)
min() 获取列表中的最小值或者多个参数中的最小值
  min(列表)
  min(值,值,...)
len()获取容器类数据的长度
  len(容器类数据)
list() 声明列表或者将其他容器类数据转换为列表
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#max() 检测容器类数据的最大值
nolist = [12,4,963,2,346,5,686,70]
result = max(nolist)

#另外一种用法:传入多个参数
result = max(12,43,64,57,578,6,9,789,8)

#min() 检测容器类数据中的最小值
nolist = [123,3,23,4,45,57,56,86,79,78,9,790,8,96,5,3]
result = min(nolist)
#另外一种用法:传入多个参数
result = min(1,2,12,31,34,34,-64,7,67,-34,53,45)

#len() 检测容器类数据的长度
listvar = ['苹果','香蕉','樱桃','榴莲','芒果']
result = len(listvar)
#集合while使用。
listvar = ['苹果','香蕉','樱桃','榴莲','芒果']
i = 0
while i < len(listvar):
    print(listvar[i])
    i += 1

列表的遍历

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
#基本列表
fruits = ['樱桃','水蜜桃','杏子','李子','无花果','苹果']
for i in fruits:
    print(i)

#嵌套列表
food = [
    ['樱桃','水蜜桃'],
    ['米饭','馒头'],
    ['红烧茄子','宫保鸡丁']
]
#遍历嵌套列表(必须是等长的嵌套列表)
for i,j in food:
    print(i,j)

#嵌套列表（不等长的嵌套列表）
food = [
    ['樱桃','水蜜桃'],
    ['米饭','馒头','煎饼'],
    ['红烧茄子']
]
for i in food:
    #print(i)
    #嵌套循环遍历小列表i
    for j in i:
        print(j)

#补充：嵌套列表的访问
food = [
    ['樱桃','水蜜桃'],
    ['米饭','馒头','煎饼'],
    ['红烧茄子']
]
print(food[1][1])