python中的数据类型之【列表】、列表的常用方法、公共方法、列表推导式、拆包、成员运算符

注意：

1、非数值型的数据类型（即：列表、元组、字符串、集合、字典）所具有的公共方法：len( )、max( )、min( )、成员运算符in、 not in。

2、列表的常用方法（11个）：append、extend、insert、pop、remove、clear、index、copy、count、sort、reverse。

3、删除列表中的元素，有三种方法：remove(值)、pop( )默认删末尾或pop(索引)、del(列表名[索引])，功能跟pop第二种写法一样，但不常用。

4、列表可以进行的操作：增删改查、统计、排序、复制、公共方法。

5、Python中非数值型的特点：

（1）都是可迭代对象，都可以用for来进行遍历，都能使用公共方法。除此之外，支持索引下标的列表、元组、字符串，这三个都是序列。

（2）列表、元组、字符串，这仨可以通过变量名[ 索引 ] 的方式获取某一成员的值。集合、字典，这俩不支持索引取值。

6、python中的列表，在其它语言中叫数组array，专门用来存储一些信息。

一、列表——关键字 list

1、列表用一对中括号[ ]来定义。列表中的数据之间（也叫元素之间、成员之间）用英文的逗号进行分隔。

2、索引从0开始。所谓索引，也叫下标，就是指元素在列表中的位置编号。 

3、列表可以使用  列表名[索引值] 的方式，访问指定下标的成员、获取指定元素的值。

例如：定义一个空列表。

list1 = []   # 定义一个空列表变量，名字叫list1
print(list1)
结果：
[]


对于空列表访问成员，结果就会报错
list1 = []
print(list1[0])

结果：
IndexError: list index out of range

例如：访问指定成员。

list1 = ["苹果", "香蕉", "橘子"]
print(list1[0])   # 访问第一个元素，获取第一个元素的值

结果：
苹果


list1 = ["苹果", "香蕉", "橘子"]
print(list1[3])   # 访问第四个成员

结果：
    print(list1[3])
IndexError: list index out of range

4、查看列表所有方法——dir(list)

print(dir(list))
结果：
['__add__', '__class__', '__contains__', 
'__delattr__', '__delitem__', '__dir__', 
'__doc__', '__eq__', '__format__', '__ge__',
 '__getattribute__', '__getitem__', '__gt__', 
'__hash__', '__iadd__', '__imul__', '__init__', 
'__init_subclass__', '__iter__', '__le__', '__len__',
 '__lt__', '__mul__', '__ne__', '__new__', '__reduce__',
 '__reduce_ex__', '__repr__', '__reversed__', '__rmul__',
 '__setattr__', '__setitem__', '__sizeof__', '__str__',
 '__subclasshook__', 
'append', 'clear', 'copy', 'count', 
'extend', 'index', 'insert', 
'pop', 'remove', 'reverse', 'sort']


或者写成下面这样也可以，结果都一样，上面只是用列表的关键字代替了所有列表而已。
list1 = ["苹果", "香蕉", "橘子"]
print(dir(list1))

二、列表常用方法

1、增加

（1）insert( )——在指定位置上插入数据。

格式：列表名.insert(索引，要插入的值)

例如：

list1 = ["苹果", "香蕉", "橘子"]
list1.insert(0, "柚子")    # 在下标0的位置上插入柚子
print(list1)
结果：
['柚子', '苹果', '香蕉', '橘子']

 例如： 当要插入的下标，大于原列表最大下标时，默认插到最后。

list1 = ["苹果", "香蕉", "橘子"]
list1.insert(7, 123)  # 在下标7的位置上插入123
print(list1)        # 原列表中下标只到2 此时却要插到7的位置
结果：
['苹果', '香蕉', '橘子', 123]

（2）append——在末尾追加数据。

格式：append(一个数据)

可以添加任意数据类型，因为它是对这个数据整体的追加。

需要注意的是：只能添加一个元素。

什么叫一个元素？比如：

append(2)   # 只把2加进去，这叫一个元素，类型为数字。

append((2,4))  # 这也是一个元素，只不过类型是元组。

append(2,4)  # 这是把2和4都加进去，这就叫两个元素，类型是数字，会报错。其它数据类型同理。

例如 ：

list1 = ["苹果", "香蕉", "橘子"]
list1.append("西瓜")
print(list1)
结果：
['苹果', '香蕉', '橘子', '西瓜']

l1 = [2, 5]
l1.append(11)  # 添加数字，结果：[2, 5, 11]
l1.append("ok")  # 添加字符串，结果：[2, 5, 'ok']
l1.append([1, 2, 3])  # 添加列表，结果：[2, 5, [1, 2, 3]]
l1.append((3, 2))  # 添加元组，结果：[2, 5, (3, 2)]
l1.append({"age": 18})  # 添加字典，结果：[2, 5, {'age': 18}]
l1.append({2, 3})  # 添加集合，结果：[2, 5, {2, 3}]
print(l1)

如果加两个元素，就会报错：例如：下面以列表类型为例进行演示，添加两个列表，其它数据类型同理。

 例如：定义一个空列表变量，向列表内添加2，5，6这三个数字。

list1 = []
list1.append(2)
list1.append(5)
list1.append(6)
print(list1)
# 结果：
[2, 5, 6]

（3）extend——在末尾追加。

格式：extend(数据)

extend后面只能放可迭代对象，即：除了数字其它数据类型都可以。

需要注意的是：同append( )一样，也是只能添加一个元素。

l1 = [2, 5]
l1.extend("12")  # 添加字符串，结果：[2, 5, '1', '2']
l1.extend((0, 1))  # 添加元组，结果：[2, 5, 0, 1]
l1.extend([3, 6])  # 添加列表，结果：[2, 5, 3, 6]
l1.extend({"age": 18, "name": "Tom"})  # 添加字典，结果：[2, 5, 'age', 'name']
print(l1)

注意：

（1）extend( )，对于字典只追加键。

（2）对于集合，由于集合无序，所以输出的结果可能会不一样。此外，集合会自动去重复，所以，在加进去之前就会把重复的3删除，只保留一个。

l1 = [2, 5]
l1.extend({4, 3, 2, 3, "ab"})
print(l1)

# 结果：
[2, 5, 'ab', 2, 3, 4] 或 [2, 5, 2, 3, 4, 'ab']

2、删除成员——三种方法：remove删指定内容、pop默认删末尾或删指定下标、del和pop一样指定下标

（1）remove(要删除的值)——当要删除的值，在列表中有多个时，默认删除的是第一个。

list1 = ["苹果", "香蕉", "橘子", "苹果", "橘子", "梨"]
list1.remove("橘子")   # 删除第一次出现的指定数据
print(list1)
结果：
['苹果', '香蕉', '苹果', '橘子', '梨']

（2）pop( )——默认删除列表中的最后一个元素，当然也可以删指定下标的元素。

list1 = ["苹果", "香蕉", "橘子"]
list1.pop()
print(list1)
# 结果：
['苹果', '香蕉']

list1 = ["苹果", "香蕉", "橘子"]
list1.pop(1)  # 删除下标1这个元素
print(list1)
# 结果：
['苹果', '橘子']

（3）del(列表名[索引])——功能跟pop(指定索引)一样，但不常用。

list1 = ["苹果", "香蕉", "橘子"]
del (list1[0])  # 删除第一个元素
print(list1)

结果：
['香蕉', '橘子']

清空列表——clear——保留列表格式，清空里面元素。

list1 = ["苹果", "香蕉", "橘子"]
list1.clear()
print(list1)

结果：
[]

 3、修改列表成员的值

格式：列表名[索引]=值

list1 = ["苹果", "香蕉", "橘子"]
list1[0] = 123   # 把下标0位置上的元素修改成123、把“苹果”修改为123
print(list1)

结果：
[123, '香蕉', '橘子']



list1 = ["苹果", "香蕉", "橘子"]
list1[6] = 123   # 不能修改下标不存在的成员
print(list1)

结果：
    list1[6] = 123
IndexError: list assignment index out of range

注意一个问题，insert中插入的位置大于原列表下标最大值时，运行依然成功，而利用[ ]修改值的时候，如果要修改的索引不存在就会报错。

4、统计相同元素数量——count(元素)

格式：count(元素)    如果这个元素在这个列表中，有多个值和它一样，那就返回一样值的总个数，如果没有跟它一样的值，就返回0 。

list1 = ["苹果", "香蕉", "橘子", "苹果"]
print(list1.count("苹果"))   # 统计列表中有多少个苹果
print(list1.count("哈密瓜"))    # 统计列表中有多少个哈密瓜
结果：  
2   # 列表中有两个苹果元素
0  # 说明列表中没有这个元素

5、查找成员在列表中位置——index

格式：index(元素，开始查找的起始位置)   

起始位置，默认为0可以不写，要查找的元素，在列表中一定得是存在的，如果不存在就会报错。即：如果找到就返回该元素在列表中的位置下标（如果有多个相同元素，那就返回第一个元素的下标），如果没找到就报错。

注意：列表中的查找就只有index，而字符串里面的查找有index和find。

list1 = ["苹果", "香蕉", "橘子", "苹果", "橘子", "梨"]
print(list1.index("梨"))

结果：
5



list1 = ["苹果", "香蕉", "橘子", "苹果", "橘子", "梨"]
print(list1.index("哈密瓜"))

结果：
    print(list1.index("哈密瓜"))
ValueError: '哈密瓜' is not in list

例如：

list1 = ["苹果", "香蕉", "橘子", "苹果", "橘子", "梨"]
print(list1.index("橘子")) #不写起始位置，默认从0开始查找
结果： 
2

list1 = ["苹果", "香蕉", "橘子", "苹果", "橘子", "梨"]
print(list1.index("橘子", 3))  # 从下标3开始查找
结果：
4

6、排序——升序、降序、逆置

sort( )  ——对列表成员从小到大排序，即：升序

sort(reverse=True)    ——降序

reverse() ——逆序、倒序、逆置

list1 = [5, 2, 4, 6, 0, 8, 1]
list1.sort()
print(list1)
结果：
[0, 1, 2, 4, 5, 6, 8]


list1 = [5, 2, 4, 6, 0, 8, 1]
list1.sort(reverse=True)   # 降序
print(list1)

结果：
[8, 6, 5, 4, 2, 1, 0]

例如：逆置、逆序。

list1 = [5, 2, 4, 6, 0, 8, 1]

list1.reverse()  # 逆序、倒序、逆置
print(list1)

结果：
[1, 8, 0, 6, 4, 2, 5]

三、循环遍历列表——注意避坑

所谓遍历就是说，从头到尾依次的获取列表中的数据（也叫元素、成员、值）。

常用for来进行遍历。在Python中，可以使用for来循环遍历所有非数值型的变量，比如：列表、元组、字符串、字典、集合。

格式：

for 变量名 in 列表名：

        代码

其中，列表中有多少个成员，for就会循环多少次。变量名代表for 每次循环的时候，得到的列表成员的值。

list1 = ["甲", "乙", "丙"]
for i in list1:   # for 循环会循环三次，因为list1里有三个成员
    print(i)
                      # for第1次循环的时候，i的值是“甲”
结果：                 # for第2次循环的时候，i的值是“乙”   
甲                      # for第3次循环的时候，i的值是“丙”
乙
丙

例如：定义一个列表变量，内容如下：[3,3,6,2,0]，使用for循环遍历计算列表中一共有多少数字。

# 法1
list1 = [3, 3, 6, 2, 0]
print(len(list1))

结果：
5


# 法2
list1 = [3, 3, 6, 2, 0]
sum = 0
for n in list1:
    sum += 1
print(sum)

结果：
5

例如：计算列表中所有数字相加的总和，以及平均值。

list1 = [3, 1, 6, 2]
sum = 0
for n in list1:
    sum += n   # 给列表成员求和
print(sum)
print(sum/len(list1))  # 给列表成员求均值

结果：
12
3.0

前方高能！！注意避坑~~

在用for循环遍历列表时，如果后面循环的代码中，要对成员进行处理，那么要注意看，列表中的成员数据类型是否统一，如果不统一，那就要注意类型的转化，需要把它们转化为统一的数据类型。

例如：输出友情提示“列表第几个成员是：”，发现列表中，既有字符串类型，也有数值型。

#法1 ————不推荐
list1 = [7, "张三", 1, 3.14, "李四", "王二麻子"]
n = 1
for i in list1:
    print("列表第%d个成员是：%s" % (n, str(i)))
    n += 1

结果：
列表第1个成员是：7
列表第2个成员是：张三
列表第3个成员是：1
列表第4个成员是：3.14
列表第5个成员是：李四
列表第6个成员是：王二麻子

#法2 ————推荐
list1 = [7, "张三", 1, 3.14, "李四", "王二麻子"]
i = 0
for j in list1:
    i += 1
    print(f"列表第{i}个成员是：{j}")
# 结果同上

解析：因为print语句中是%s,意思是要输出字符串类型，而列表中存在整型浮点型，所以要用str()全转为字符串类型。

例如：对列表中成员进行求和。此时，列表中存在字符串类型。

list1 = [1, "56", 3]
sum = 0
for n in list1:
    sum += int(n)  # 要把列表中的元素全部转为整型再计算
print(sum)

结果：
60

解析：因为是要求和，而列表中存在字符串类型，没办成参与求和，所以就要用int（）把它强制转化为整型，这样就能统一列表中成员的数据类型了。

例如：统计字符串长度。

#法1
str1 = "甲乙丙"
print(len(str1))
结果：
3


#法2
n = "甲乙丙"
sum = 0
for a in n:
    sum += 1
print(sum)  

结果：
3

例如：统计列表中水果名称为两个字的有几个。

# 法1
list1 = ["圣女果", "苹果", "橘子", "香蕉", "哈密瓜", "梨"]
sum = 0
for i in list1:   # 对成员进行遍历
    if len(i) == 2:   # 判断成员字符个数是否为2
        sum += 1
print(sum)


结果：
3


# 法2————不推荐
list1 = ["圣女果", "苹果", "橘子", "香蕉", "哈密瓜", "梨"]
sum = 0  # 存放名字为2个字的出现次数
for i in list1:  # i 是列表中的每个成员，list1中有多少个成员就循环几次
    b = 0
    for a in i:  # a是字符串i中的每个字符，i中有几个字符for就循环几次
        b += 1  # b 统计字符串i的长度
    if b == 2:
        sum += 1
print(sum)

结果：
3

四、拆包——适用于所有非数值型，即：列表、元组、集合、字典、字符串。

就是把一个列表中的每个值都拆出来。

格式：

变量1，变量2，...变量n = 列表名

注意：等号左边的变量个数，要等于等号右边的列表成员个数。

list1 = [1, "甲", 123]
a, b, c = list1
print(a, b, c)

结果：
1 甲 123


# 拆包后，成员是什么类型，拆包后就是什么类型
list1 = [1, "甲", 123]
a, b, c = list1
print(a, b, c)
print(type(a))
print(type(b))

结果：
1 甲 123
<class 'int'>
<class 'str'>


# 对字符串拆包
str1 = "hell"
a, b, c, d = str1
print(a, b, c, d)

结果：
h e l l

五、列表推导式、列表生成式

一种快速创建数字列表的方法。就是用for跟range范围函数结合的方式，生成列表。

格式：

写法1：列表变量名=[x for x in range(开始值，结束值，步长)]

写法2：列表变量名=[x for x in range(开始值，结束值，步长) if 条件 ]

例如：快速创建一个列表，内容为：[0，2，4，6，8，10] 。

# 法1
list1 = [x for x in range(0, 11, 2)]  # 用步长
print(list1)

结果：
[0, 2, 4, 6, 8, 10]

# 法2
list1 = [x for x in range(0, 11) if x % 2 == 0]  # 用 if 条件
print(list1)

结果：
[0, 2, 4, 6, 8, 10]

六、非数值型变量中的一些公共方法

所谓非数值型变量就是常说的那5个：列表、元组、集合、字典、字符串。

下面以列表为例进行说明。

1、len()——返回列表中元素个数。

list1 = [1, 3, 5]   # 统计列表，就是返回列表成员个数
print(len(list1))

str1 = "1234abc"   # 统计字符串，就是返回字符串中字符的个数
print(len(str1))、

结果：
3
7

2、max()——返回列表中最大的数据。如果是字符串，就返回ASSCII码值最大的那个字符。

list1 = [1, 3, 5]
print(max(list1))
结果：
5

str1 = "1234abc"  
print(max(str1))   # 返回字符串中ASSCII码值最大的那个字符

结果：
c

3、min()——返回列表中最小的数据。

4、成员运算符——判断值是否在列表中存在

格式：

值 in 列表——判断值是否在列表内

值 not in 列表——判断值是否不在列表内

list1 = [3, 5, "张三", 3.14]
print(3 in list1)  # 3在里面
结果：
True    # 说明3在

list1 = [3, 5, "张三", 3.14]
print(1 in list1)     # 1在里面
结果：
False   # 说明1不在


# 法2：——不推荐
list1 = [3, 5, "张三", 3.14]
if 3 in list1:
    print("3在")

结果:
3在

list1 = [3, 5, "张三", 3.14]
print(1 in list1)    # 1在里面
print(1 not in list1)   # 1不在里面

结果：
False
True

法2——不推荐
list1 = [3, 5, "张三", 3.14]
if 2 not in list1:
    print("2不在")
结果：
2不在

例如：判断列表中是否有“苹果”，如果有，把它删掉。

list1 = ["苹果", "橘子", 1]
if "苹果" in list1:
    list1.remove("苹果")
print(list1)

结果：
['橘子', 1]

但是有弊端，当个数不等于1时候就会删不掉了。例如：

list1 = ["苹果", "橘子", 1,"苹果"]
if "苹果" in list1:
    list1.remove("苹果")
print(list1)

# 结果：
['橘子', 1, '苹果']

进程已结束，退出代码 0

因为if只判断了一次，没有进行循环，改进：

# 推荐！！
list1 = ["苹果", "橘子", 1,"苹果"]

while 1:  # 非0即位真
    if "苹果" in list1:
        list1.remove("苹果")
    else:break

print(list1)

# 结果：
['橘子', 1]

进程已结束，退出代码 0