wordpress新建页面不能保存路径/贵州快速整站优化

list 列表

• 列表定义与使用
• 列表常用方法
• 列表嵌套
• 列表推导式

列表定义

• 列表是有序的可变元素的集合，使用中括号[]包围，元素之间用逗号分隔

• 列表是动态的，可以随时扩展和收缩

• 列表是异构的，可以同时存放不同类型的对象

• 列表中允许出现重复元素
  

列表使用：创建

• 创建列表
  • 通过构造函数创建
  • 中括号创建并填充
  • 列表推导式

# 1、通过构造函数创建
li1 = list()  # 空列表
li1 = list('hogwarts')  # 字符串
li1 = list((1, 2, 3))  # 元组
li1 = list({4, 5, 6})  # 集合
li1 = list({'a': 7, 'b': 8})  # 字典
print(type(li1), li1)# 2、中括号创建并填充元素
li2 = []  # 空列表
li2 = [1, 2, 3]  # 直接填充对象
print(type(li2), li2)

列表使用：索引

• 索引
  • 默认正向索引，编号从 0 开始。
  • 支持反向索引，编号从-1 开始。

li = [1, 2, 3, 4, 5]# 1、正向索引
print(li[0])  # 打印1
print(li[3])  # 打印4# 2、反向索引
li = [1, 2, 3, 4, 5]
print(li[-1])  # 打印 5

列表使用：索引示意图

列表使用：切片

• 切片 [start: stop: step]

  • start 值: 指示开始索引值，如果没有指定，则默认开始值为 0；
  • stop 值: 指示到哪个索引值结束，但不包括这个结束索引值。如果没有指定，则取列表允许的最大索引值；
  • step 值: 步长值指示每一步大小，如果没有指定，则默认步长值为 1。
  • 三个值都是可选的，非必填

列表使用：切片示意图

列表使用：切片实例

# 切片基本用法
li = ['h', 'o', 'g', 'w', 'a', 'r', 't', 's']
print(li[0:5:2])  # 打印['h', 'g', 'a']
print(li[2:4])  # 省略了step，打印['g', 'w']
print(li[:4])  # 省略了start和step，打印['h', 'o', 'g', 'w']
print(li[2:])  # 省略了stop和step，打印['g', 'w', 'a', 'r', 't', 's']
print(li[::2])  # 省略start和stop，打印['h', 'g', 'a', 't']
print(li[::-1])  # 特殊的切片写法：逆序打印['s', 't', 'r', 'a', 'w', 'g', 'o', 'h']

'''
list = ["red","green","blue","yellow","white","black"]
"""
正向索引：step为正数
"""
# 正向索引：start_index为0到end_index为6
print(list[0:6]) # ['red', 'green', 'blue', 'yellow', 'white', 'black']# start_index没有填写，默认从第一个开始,一直取到end_index=6
print(list[:6]) # ['red', 'green', 'blue', 'yellow', 'white', 'black']# step没有填写，默认是1，start_index为0,一直取到end_index=2
print(list[0:2])  #['red', 'green']# step没有填写，默认是1，start_index为1,一直取到end_index=4
print(list[1:4])  # ['green', 'blue', 'yellow']# start_index为1,一直取到end_index=5，step是2
print(list[1:5:2])  # ['green', 'yellow']

'''
反向索引：step为负数
'''
print("反向索引=============")
# step=1，反向索引，从start_index=-6开始，一直取到end_index=0为止。
print(list[-6::])  #['red', 'green', 'blue', 'yellow', 'white', 'black']# step=-1，反向索引，从start_index=3开始，一直取到end_index=0为止。
print(list[3:0:-1])  #['yellow', 'blue', 'green']# step=-2，反向索引，从start_index=6开始，一直取到end_index=0为止。
print(list[6::-2])  #['black', 'yellow', 'green']# step=-3，反向索引，从start_index=5开始，一直取到end_index=2为止。
print(list[5:2:-3])  #['black']# step=-1，反向索引，从start_index=-3开始，一直取到end_index=-5为止。
print(list[-3:-5:-1])  #['yellow', 'blue']# start_index > end_index时，取出的结果为空
print(list[4:2])  #[]
print(list[-5:-3:-1])  # []

'''多层切片'''
list = ["red","green","blue","yellow","white","black"]
# 链式列表切片
print(list[:6][2:5][-1:])'''上边的链式列表与下边的步骤是相等的'''
list2 = list[:6]
# ['red', 'green', 'blue', 'yellow', 'white', 'black']
print(list2)
list3 = list2[2:5]
# ['blue', 'yellow', 'white']
print(list3)
list4 = list3[-1:]
# ['white']
print(list4)

列表使用：运算符

• 重复
  • 使用 * 运算符可以重复生成列表元素。
• 合并
  • 使用 + 加号运算符，可以将两个列表合二为一。

# 1、重复
li = [1] * 5
print(li)  # 打印[1, 1, 1, 1, 1]# 2、合并
li1 = [1, 2, 3]
li2 = [99, 100]
print(li1 + li2)  # 打印[1, 2, 3, 99, 100]

列表使用：成员检测

• in：检查一个对象是否在列表中，如果在则返回 True，否则返回 False。

• not in：检查一个列表是否不包含某个元素。如果不在返回 True，否则返回 False。

li = [1, 2, 3]# in
print(1 in li)  # 返回True
print(100 in li)  # 返回False# not in
print(1 not in li)  # 返回False
print(100 not in li)  # 返回True

列表方法

• append()
• extend()
• insert()
• pop()
• remove()
• sort()
• reverse()

列表方法 append()

• append(item)：将一个对象 item 添加到列表的末尾。

• 入参：对象 item

• 返回：None

# 添加元素
# 添加元素
li = []
li.append(1)
li.append(3.14)
li.append("hogwarts")
li.append([6, 6, 6])
li.append((1.2, 1.5))
li.append({'msg': "Hello"})print(li)  # 打印列表
print(len(li))  # 获取列表元素个数

列表方法 extend()

• extend(iterable)：将一个可迭代对象的所有元素，添加到列表末尾。

• 入参：可迭代对象 iterable

• 返回：None

# extend()的用法li = []
li.extend('hogwarts')  # 添加的是字符串的所有字母
li.extend([1, 2, 3])  # 接收列表的所有元素
li.extend((4, 5, 6))  # 接收元组的所有元素
li.extend({'a': 1, 'b': 2})  # 接收字典的所有key值
print(li)

列表方法 insert()

• insert(index, item)：将一个对象插入到指定的索引位置

• 入参：索引值 index ，一个对象 item

• 返回：None

• 原索引位置及后面的元素后移一位

li = [0, 1, 2]
print("插入前: ", li)  # 打印 [0, 1, 2]# 在索引0的位置插入元素
li.insert(0, 'hogwarts')
print("插入后: ", li)  # 打印 ['hogwarts', 0, 1, 2]

列表方法 pop()

• pop(index) 或 pop()

• 弹出并返回所指定索引的元素。

• 入参：索引值 index，可不传

• 返回：指定索引的元素

• 返回：未指定索引则返回末尾元素

• 如果索引值不正确，或者列表已经为空，则引发 IndexError 错误

letters = ['h', 'o', 'g', 'w', 'a', 'r', 't', 's']# 传入索引3，弹出元素 w
n1 = letters.pop(3)
print(n1)  # 打印 w# 不传参数，默认弹出末尾元素
n2 = letters.pop()
print(n2)  # 打印 s

列表方法 remove()

• remove(item)

• 移除列表中第一个等于 item 的元素

• 入参：指定元素 item

• 返回：None

• 目标元素必须已存在，否则会报 ValueError

li = ['h', 'o', 'g', 'w', 'a', 'r', 't', 's']
print(len(li))  # 打印 8# 1、删除指定元素'h'
li.remove('h')
print(li)  # 打印 ['o', 'g', 'w', 'a', 'r', 't', 's']
print(len(li))  # 打印 7# 2、移除第一个2
li = [1, 2, 3, 2, 1]
li.remove(2)
print(li)  # 打印 [1, 3, 2, 1]# 3、删除不存在的元素，会报ValueError错误
li = [1, 2, 3]
li.remove(100)

列表方法 sort()

• sort(key=None, reverse=False)

• 对列表进行原地排序，只使用 < 来进行各项间比较。

• 入参：支持 2 个关键字参数：

  • key：指定带有一个参数的函数，用于从每个列表元素中提取比较键。
  • reverse：默认值为 False 表示升序，为 True 表示降序

• 返回：None

nums = [2, 4, 3, 1, 5]# 1、不传参数，默认升序，数字从小到大排列
nums.sort()
print(nums)  # 打印 [1, 2, 3, 4, 5]# 2、指定key=len，按元素的长度排序
words = ['Python', 'Java', 'R', 'Go']
words.sort(key=len)
print(words)  # 打印 ['R', 'Go', 'Java', 'Python']# 3、指定reverse=True，降序
nums = [2, 4, 3, 1, 5]
nums.sort(reverse=True)
print(nums)  # 打印 [5, 4, 3, 2, 1]

列表方法 reverse()

• reverse()：将列表中的元素顺序反转
• 参数：无
• 返回：None
• 反转只是针对索引值，元素之间不相互比较。

# 反转顺序
nums = [8, 1, 5, 2, 77]
nums.reverse()
print(nums)  # 打印[77, 2, 5, 1, 8]

book_a = [('yuwen',20),('yingyu',18),('shuxue',30)
]
b = []
for x in book_a:b.append(x[::-1])
print(sorted(b))

列表嵌套

• 嵌套列表是指在列表里存放列表
• 列表的常用方法都适用于嵌套列表

# 1、创建嵌套列表
li_2d = [['a', 'b', 'c'], [1, 2, 3]]
print(type(li_2d))  # 打印<class 'list'>
print(len(li_2d))  # 打印 2# 2、访问嵌套列表中的元素
print(li_2d[0][2])  # 打印 'c'

列表推导式

• 列表推导式是指循环创建列表，相当于 for 循环创建列表的简化版

• 语法：[x for x in li if x ...]

"""
实例：将 1-10 中的所有偶数平方后组成新的列表
"""# 1、传统解决方案
result = []
for ele in range(1, 11):if ele % 2 == 0:result.append(ele ** 2)
print(result)  # 打印 [4, 16, 36, 64, 100]# 2、使用列表推导式
result = [ele ** 2 for ele in range(1, 11) if ele % 2 == 0]
print(result)  # 打印 [4, 16, 36, 64, 100]

使用range()创建数字列表

要想创建数字列表，可使用函数list()将range()的结果直接转换为列表，可使用list（）：

numbers = list(range(1,6))
# [1, 2, 3, 4, 5]
print(numbers)

使用函数range()时，还可指定步长。为此，可给这个函数指定第三个参数，Python将根据这个步长来生成函数。
例如，下面的代码打印1~10的偶数：

numbers = list(range(2,11,2))
# [2, 4, 6, 8, 10]
print(numbers)

打印1~10的平方：

list_squra = []
for i in list(range(1,11)):list_squra.append(i**2)
# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
print(list_squra)# 使用列表推导式：
list_squra = [i**2 for i in list(range(1,11))]
# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
print(list_squra)

遍历切片：

如果想要遍历列表的部分元素，可在for循环中可使用切片，下面的示例是遍历前三个元素，并打印出来：

list = ["a","b","c","d","e","f","g"]
for i in list[0:3]:print(i)

复制列表

要想复制列表，可创建一个包含整个列表的切片，方法是同是省略起始索引和种植索引（[:]）.

my_foods = ["apple","pear","cake","pizza"]
friend_foods = my_foods[:]
print(my_foods)
print(friend_foods)