python基础语法总结（四）-- list列表

python常用系统函数方法与模块

python基础语法总结（一）-- python类型转换函数+文件读写

python基础语法总结（二）-- 函数function

python基础语法总结（三）-- 数与字符串

python基础语法总结（四）-- list列表

python基础语法总结（五）-- 字典dic + 元组tuple

python基础语法总结（六）-- python类与OOP面向对象特性

---

一. 列表List

list是python中最常用的数据格式，list以[item1,item2,...]定义，以list[i]读取。list列表中的元素可变

'''
list列表，其中的元素可变
'''
l1 = [1,2,3,4,5,6]      # 声明一个list列表，并赋值

二. 基本操作

1. 读取get

# 读取
print(l1[0])            # 得到列表中的某一项，语法list[i]，索引以0开始

2. 修改

# 修改
l1[2] = 8               # 修改第三项，由3改为8
print(l1[2])            # 打印结果为8

3. 添加（list结尾）

# 添加(在list后附加)
l1.append(9)            # 在list后添加一项：9
print(l1)               # [1, 2, 8, 4, 5, 6, 9]，可以看到添加了一项

4.  插入（任意位置）

# 插入(在list中任何位置添加新元素)
l1.insert(1,23)         # 在第二项处添加一项 23，原已有的元素都向右移一个位置
print(l1)               # [1, 23, 2, 8, 4, 5, 6, 9]

5. 删除

# 删除
del l1[2]               # 删除第三个元素 2
print(l1)               # [1, 23, 8, 4, 5, 6, 9], 原先的第三个元素"2"被删除

# 删除(同时得到此元素)
item = l1.pop(4)        #
print(l1)               # [1, 23, 8, 4, 6, 9]
print(item)             # 已删除的元素“5”储存在item里

# 删除（根据值）
l1.remove(23)           # 删除已有项“23”，注意只删除第一个匹配项，如果其中有多个“23”，也只删除第一个
print(l1)               # [1, 8, 4, 6, 9]

6. 清空

# 清空
l1.clear()

7. 数组越界避免

# 数组越界避免
l1[7]                   # 因为l2长度为7 ，所以取第八项时，会报数组越界
l1[-1]                  # 为避免数组遍历或者从后向前读取时易出现的越界问题，python支持用-号从右向左读
                            # 从-1开始，依次向左偏移读取，本例：'a'

 

三. 复杂方法

1. 列表长度 

# 列表长度
len(l1)                 # 得到列表的总长度，本例：6

2. 列表反向

# 列表反向
l2.reverse()            # 列表反向，修改原list
print(l2)               # ['f', 'g', 'd', 'b', 'c', 'e', 'a']

3. 遍历 

# 遍历整个列表
for item in l2:
    print(item)

4. 排序

• 永久排序sort()
• 临时排序sorted()

# 永久性排序sort()， 原list顺序会改变
l1.sort()
print(l1)               # [1, 4, 6, 8, 9]   已排序，原l1发生改变

# 临时排序sorted(), 返回排序好的新list，原list顺序不变
l2 = ['a','e','c','b','d','g','f']
temp_list = sorted(l2)
print(temp_list)        # 排序结果['a', 'b', 'c', 'd', 'e', 'f', 'g']
print(l2)               # l2本身并没有变化，还是['a', 'e', 'c', 'b', 'd', 'g', 'f']
temp_list_reverse = sorted(l2, reverse=True)    # 反向排序
print(temp_list_reverse)        #['g', 'f', 'e', 'd', 'c', 'b', 'a']

5. 创建数字列表 

# 创建数值列表
l3 = list(range(1,5))       # l3: [1, 2, 3, 4]
l4 = list(range(2,15,3))    # 指定步长为3， l4：[2, 5, 8, 11, 14]
# 语法糖，创建1到4的平方的列表
squares = [value ** 2 for value in range(1,5)]          # squares：[1, 4, 9, 16]

6. 创建列表副本

# 创建副本
duplicate_sq = squares[:]       # 复制，真正的创建了副本，不同于duplicate_sq = squares简单的引用
squares[2] = 1                  # 修改第三项为1
print(squares)                  # [1, 4, 1, 16]
print(duplicate_sq)             # [1, 4, 9, 16]

7. 判断最大最小值

# 判断最大、最小值
l1 = [1,2,3,5]
max(l1)         #求最大值，本例：5
max(2,5,6,7)        #本例：7
min(l1)         #求最小值，本例：1

 

四. zip与*

1. zip() 函数

用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

### zip
z_list = zip([1,2,3],['a','b','c'])
list(z_list)
'''
[(1, 'a'), (2, 'b'), (3, 'c')]
'''

# 两个数组个数不相等，则会砍掉多余的项
z_list = zip([1,2,3,4],['a','b','c'])
list(z_list)
'''
[(1, 'a'), (2, 'b'), (3, 'c')]
'''

 

2. zip(*) 

因为zip()可传入不定数量的入参，类似不定入参的函数。因此可以有一种特殊写法：

通过*list这种字面量，将list等序列转成多个独立的参数，放在不定入参中

*list相当于拆列表的结构，分解成很多项进行传递；在不定入参调用时使用*，就是按照顺序进行位置传参

### zip(*) 
# 可以看到zip可以传入两个及以上的参数，那么如果传入一个二维数组，想让它的每一行进行zip，应该如何操作？
ll = [[1,2,3],['a','b','c'],['X','Y','Z']]
z_list = zip(ll[0],ll[1],ll[2])           # 这样是可以，但是写法麻烦，如果数组形状很大，或者维度很高，这种写法显然不现实
list(z_list)
'''
[(1, 'a', 'X'), (2, 'b', 'Y'), (3, 'c', 'Z')]
'''

# 因为zip()可传入不定数量的入参，类似不定入参的函数，可以有一种特殊写法，将list等序列转成多个独立的参数，放在不定入参中
zz_list = zip(*ll)      # 这里 *ll与上面：ll[0],ll[1],ll[2]的效果相同
list(zz_list)
''' 效果相同
[(1, 'a', 'X'), (2, 'b', 'Y'), (3, 'c', 'Z')]
'''

注意：*ll这种用法不能单独使用，必须在不定入参的位置上
      例如想分解  a,b,c = *ll 这种写法就会报错 

3. zip(*) 与*zip混合

zip的结果跟转置比较像。对zip之后的对象和list，再进行zip，则会恢复之前的格式

### zip的结果跟转置比较像。对zip之后的对象和list，再进行zip，则会恢复之前的格式
ori_list = zip(*zz_list)
list(ori_list)
''' 恢复之前的格式
[(1, 2, 3), ('a', 'b', 'c'), ('X', 'Y', 'Z')]
'''

# 也可以连写
ori_list = zip(*zip(*ll))
list(ori_list)
''' 
[(1, 2, 3), ('a', 'b', 'c'), ('X', 'Y', 'Z')]

因此本质上不存在*zip()这种特殊的语法，而是zip()结果和*[list]这两种语法的结合体而已，并且使用方式也局限在不定入参上。