题缘有你002_列表的常见事项

列表的常见事项

1. 与函数和多分支结构的综合

def fib(n):
    if n <= 0:
        return -1
    elif n == 1:
        return -1
    elif n == 2:
        return 1
    else:
        L = [1, 5]
        for i in range(2, n):
            L.append(L[-1] + L[-2])
        return L[-2]%L[-1]
print(fib(7))

2. 其实想明白了很简单，这是一个函数，怎样的函数呢？将一个功能封装在该函数中。实现怎样的功能？将实参的值传递给形参，并通过多分支结构实现条件的筛选。
3. 首先是将实参 7 的值传递给形参 n ，通过判断会发现，只有 else 后面的语句满足条件。通过 L 这个初始列表和后面的 for 遍历循环，进行最佳列表操作，并返回函数值。
4. 通过用以下的方式结果会很直观：

遍历数	n	当前列表	余数返回值
0	未遍历前	[1, 5]	——
1	2	[1, 5, 6]	5
2	3	[1, 5, 6, 11]	6
3	4	[1, 5, 6, 11, 17]	11
4	5	[1, 5, 6, 11, 17, 28]	17
5	6	[1, 5, 6, 11, 17, 28, 45]	28

• 我们会发现，当函数有多个 return 语句的时候，执行到哪个 return 语句，哪个 return 语句就会生效。

2.列表、字符串和遍历循环

ls = []
for i in "爱保"：
	for j in "国家"：
		ls.append(m+n)
print(ls)

i遍历	j遍历	m+n	ls
'爱'	'国'	'爱国'	['爱国']
'爱'	'家'	'爱家'	['爱国', '爱家']
'保'	'国'	'保国'	['爱国', '爱家', '保国']
'保'	'家'	'保家'	['爱国', '爱家', '保国', '保家']

• 需要注意的是：i 是外层遍历，j 是内层遍历

3.列表可以使用比较操作符

>>> a = [1,2]
>>> b = [3]
>>> a > b
False
>>> a < b
True

• 一旦决定胜负，立即退出

4.函数的注意事项：

ls = ['a','b','c']
def funC(a):
    ls.append(a)
    return 
funC('d')
print(ls)

['a', 'b', 'c', 'd']

• 函数的 return 语句后面如果没有表达式，则该函数没有返回值。（即尽管实现了函数的功能，但是没有函数返回值）

5.辨析reverse() 和 list.reversed()：

1. reverse() :列表的方法，用于将整个列表中的元素逆置。如：

>>> a = ['a', 'f', 'z', 'p']
>>> id(a)
1342882586440
>>> a.reverse()
>>> id(a)
1342882586440   # 原地操作，没有产生新的对象
>>> a  # 且与字符大小无关，称逆置
['p', 'z', 'f', 'a']
>>> print(a.reverse())
None  # 本身没有返回值
>>> 

2. list.reversed() ：python 内置函数：返回给定的序列逆置后的迭代器

>>> for i in reversed(range(5)):
	print(i)
	
4
3
2
1
0
>>> 

• 上例题：

for i in reversed(range(7,4,-1)):
	print(i,end=" ")

result：

5 6 7

• 分析：range(7,4,-1)，意思就是倒着来，需要注意的是不包含 4 ，所以为
  （注意：步长 step 默认是1）

7 6 5

• 而 reversed() 是倒序，因此为

5 6 7

思维拓延：（与列表生成器组合）

[x ** 2 for i in range(7, 0, -2)]

• 解释：start为7，stop为0，步长为-2
• 更好的理解方式就是，步长就是等差数列 的公差 d

    # 从0开始，不含7，隔一个输出一个
>>> for i in range(0,7,2):
	print(i)
	
0
2
4
6
    # 从7开始，不含0，逆序隔一个输出一个
>>> for i in range(7,0,-2):
	print(i)

7
5
3
1
>>> 

6.辨析 内置函数 ：all() 和 any()

• all() ：意思就是所有，想到什么？and 或者是 && ，一假则假，都真则真。
• 字母l,形似数字 1 ，故都真则真。

>>> all([1,'h',''])  # 一假则假
False
>>> all([1,'h'])     # 都真则真
True

• any() ：意思就是任何，想到什么？or 或者是 ||，一真则真，都假则假

>>> any([None,'',[],{},(),0,False,dict()])
False  # 都假则假
>>> any([None,'',[],{},(),0,False,dict(),1])
True  # 一真则真

• ascii() ：

ascii（“python”）
>>>"'python'"
ascii（520）
>>>'520'
>ascii（None）
>>>'None'

7.列表的元素也可以称为项，并且列表没有固定的大小。

8.列表的stop可以超出原有的范围

>>> ls = [1,2,3,4,5,6,7,8]
>>> ls[:100:2]
[1, 3, 5, 7]

9.

10.

个人觉得，key可以理解为一种映射，或者是一种规则，这里所谓的规则就是将列表以长度进行排序，升序（从小到大）。因此有：

#    0        1        2          3
['apple', 'banana', 'pear', 'watermolon']

• 其中，sorted() 的默认参数是 reverse=False（升序）
  日后作为记忆节点，用于复习

11.列表的深拷贝

对于列表，深拷贝相当于是，为原列表取了化名，如：

ls = [2,3,4]
love = ls
print(ls)

这里将 ls 化名为了 love ，因此在删除 love 的时候，其实就是删除了原列表 ls （相当于一个人叫 tom，他的别名是 love，你杀了 love 就等于杀了 tom 本人），而在程序世界中，删除了变量不就相当于杀了它吗？

11.列表的浅拷贝

ls = [2,3,4]
love = ls.copy()
love.reverse()
print(ls)

result

[2,3,4]

• 至于浅拷贝嘛，小白还没有想到好的方法举例子

12.list.index(obj[,start=0[,stop=len(L)]])

• obj ：待查找对象
• start： 可选项 索引的开始位置
• stop ：可选项 索引的结束位置（默认为列表的长度）

name = ['我','是','奋斗','的','_','小白']
i = '奋斗'
i0 = '_'
print(name.index(i,0))  # 2
print(name.index(i,2))  # 2
# 索引的范围内不含i 元素（项），下一行会报错
print(name.index(i,3))  
print(name.index(i0,4,5))  # 4
print(name.index(i0,3,4))  # '_' is not in list

result：

2
2
Traceback (most recent call last):
  File "C:\Users\lenovo\Desktop\text.py", line 5, in <module>
    print(name.index(i,3))
ValueError: '奋斗' is not in list  
>>> 

13. 辨析 str.strip() 和 str.split()

对于表达式：ls = [1,2,3,7,4,5,6,7,9]
如何变成123745679？

分析：先整体变成一个字符串，然后将方括号去掉，在以逗号分割，最后再用join方法组合起来。
步骤：

1. str(ls)

ls = [1,2,3,7,4,5,6,7,9]
>>> s = str(ls)
>>> s
'[1, 2, 3, 7, 4, 5, 6, 7, 9]'

2. s.strip("[]")

>>> s.strip("[]")
'1, 2, 3, 7, 4, 5, 6, 7, 9'

3. a = s.strip("[]").split(",")

# 注意：这里的", "：逗号和空格
>>> a = s.strip("[]").split(", ")
>>> a
['1', '2', '3', '7', '4', '5', '6', '7', '9']
>>> 
>>> 

4. ''.join(a)

>>> ''.join(a)
'123745679'

5. print(''.join(a))

>>> print(''.join(a))
123745679
>>> 

15. 对于表达式 ls = ['ab','44','cd','46'],如何输出 46cd44ab ?

ls = ['ab','44','cd','46']
ls.reverse()

分析：观察法发现，哦，元素的逆置。而方法reverse（）就是逆置。因此这里仅仅需要将元素进行结合即可。

ls = ['ab','44','cd','46']
ls.reverse()
print(''.join(ls))

其他选项：

# 负负得正
>>> print(''.join(ls[-1::-1]))
ab44cd46
# 返回索引为 -1 的元素
>>> print(''.join(ls[-1::]))
ab
# 这两个一样
>>> print(''.join(ls[-1]))
ab
# 返回索引为 1 的元素
>>> print(''.join(ls[1]))
cd
# 返回索引为 1 以后的元素
>>> print(''.join(ls[1:]))
cd44ab
# 返回索引为 1 以后的元素
>>> print(''.join(ls[1::]))
cd44ab
# 返回索引为 -2 以后的元素
>>> print(''.join(ls[-2::]))
44ab
# 返回索引为 -2 的元素
>>> print(''.join(ls[-2]))
44

ss = [1,8,4,6,7,9,5]
for i in ss:
	ss.remove(min(ss))
	print(min(ss),end = ',')

分析：