list判空与否

1
2
if numbers:
    print('numbers is not empty')

反之

1
2
if not numbers:
    print('numbers is empty')

为什么不用if numbers != []，因为它需要比较所有的元素，而不仅仅是判断列表是否为空，并且不够直观。

那么，if numbers is not None呢？这样写用于判断一个对象是否为None，然而，空列表和None表示不同的概念。

如果我们明确要判断一个变量是否为None，应该使用 if variable is not None，而如果只关心列表是否为空，使用 if numbers，简洁易懂。

max 和 min 使用条件

max() 和 min() 是 Python 内置的函数，用于找到可迭代对象中的最大值和最小值。如果列表为空，即没有任何元素，使用将会引发 ValueError 异常。为了避免引发异常，在使用之前，需要判空。

1
2
3
4
5
6
if numbers:
    max_num = max(empty_list)
    min_num = min(empty_list)
else:
    max_num = None
    min_num = None

列表解包

python列表解包是指将可迭代对象中的值分别赋值给多个变量的过程，具体语法和c语言指针似乎如出一辙，是在赋值语句中使用*运算符来表示解包，将列表中的元素解包到多个变量中。

如果通过解包，我们可以直接访问列表中的每个元素，而不需要使用索引。例如：

1
2
3
4
5
numbers=[1,2,3]
first,second,third=numbers
print(first) # 1
print(second) # 2
print(third) # 3

如果列表的长度超过了解包的变量数量，会引发ValueError异常，为了解决这个问题，可以使用 * 运算符来将剩余的值解包到一个单独的列表中。

1
2
3
4
5
numbers=[1,2,3]
first,*others=numbers
print(first) # 1
print(others) # [2, 3]
print(*others) # 2 3

同样是追加元素

同样是追加元素，lst.append(element)和lst+[element]有什么区别呢？

1
2
3
4
5
6
numbers=[]
numbers.append(1)
numbers.append(2)
numbers.append(3)
numbers.append(4)
numbers # [1, 2, 3, 4]
1
2
3
4
5
6
numbers=[]
numbers=numbers+[1]
numbers=numbers+[2]
numbers=numbers+[3]
numbers=numbers+[4]
numbers # [1, 2, 3, 4]

就结果而言没有区别，都是在列表后追加元素。但是前者是将元素直接追加到列表末尾，而不会创建新的列表对象。这意味着将元素直接追加到列表末尾，而不会创建新的列表对象，不会产生额外的内存开销；而后者，每次会创建一个新的列表对象，并将原来的列表与新元素组合在一起，新的列表对象将被分配新的内存空间。

列表生成式

原先，用迭代器创建列表

1
2
3
4
5
numbers=[1,2,3,4]
new_numbers=[]
for item in numbers:
    new_numbers.append(item)
new_numbers # [1, 2, 3, 4]

为了用一种简单快捷的方式创建列表，在一个方括号内使用表达式来定义列表元素，并可以使用一个可迭代对象作为生成的数据源。

1
2
numbers=[number for number in range(1,10) if number % 2 == 0]
numbers # [2, 4, 6, 8]

上述是带有if的列表生成式，还可以有带if-else的列表生成式，例如将所有的数据内容复制一份，判断如果是奇数就保留，是偶数的话都除以2：

1
2
3
numbers = [0,1,2,3,4,5,6]
new_numbers=[number if number % 2 == 1 else number // 2 for number in numbers]
new_numbers # [0, 1, 1, 3, 2, 5, 3]

注意：if-else的位置

使用嵌套的列表生成式创建一个 3x3 的矩阵。外部的列表生成式用于生成每一行，内部的列表生成式用于生成每一行的元素。

1
2
matrix=[[number for number in range(1,4)] for _ in range(3)]
matrix # [[1, 2, 3], [1, 2, 3], [1, 2, 3]]

尽管，列表生成式是一种简洁和灵活的方式，但是在处理大量数据时，可能会产生较大的内存开销。

使用生成器表达式代替列表生成式：生成器表达式使用圆括号而不是方括号，与列表生成式类似，但是会返回一个生成器对象而不是列表。生成器对象使用惰性计算的方式生成数据，即只有在需要时才生成数据，可以节省大量的内存空间。例如：

1
numbers = (x for x in range(1, 1000000) if x % 2 == 0)

在这个例子中，生成器表达式将生成器对象 numbers 定义为包含 1 到 1000000 之间的偶数的序列。当需要遍历这个序列时，将根据需要逐个生成元素，而不会一次性生成所有元素。

sort函数

sorted() 返回一个新的list
lst.sort() 仅对自身进行排序，改变自身

1
2
3
4
5
lst=[1,5,4,2]
sorted(lst1) # [1, 2, 4, 5]
lst1 # [1, 5, 4, 2]
lst.sort()
lst1 # [1, 2, 4, 5]

sorted() 默认从小到大进行排序，如果加参数reverse=True，则从大到小进行排序。

刷题

第3天的作业打卡

输入一个正整数，判断组成该整数的各个数字是升序降序还是无序的。

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
35
36
import sys
try:
    numbers=input("An integer please: ")
    if not numbers:
        raise Exception
except Exception:
    print("Input is not an integer, giving up.")
# 输入格式为字符串类型，使用生成式转化成整型数组
numbers_to_list=[int(number) for number in numbers]

always_repete=True
first=numbers_to_list[0]

# 判断整个数组中的元素是否都相等
for item in numbers_to_list[1:]:
    if item!=first:
        always_repete=False

is_ascending=True
is_descending=True

# 使用双指针移动判断前后两个元素的大小关系
for second in numbers_to_list[1:]:
    if second<first:
        is_ascending=False
    if second>first:
        is_descending=False
    first=second

# 如果整个数组的元素相同或者无序，则输出该组数字无序
if is_ascending and not always_repete:
    print(f'{numbers} is ascending')
elif is_descending and not always_repete:
    print(f'{numbers} is descending')
else:
    print(f'{numbers} is disordering')

求最长升序子序列

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
import sys

try:
    numbers = int(input("An integer please: "))
    if not numbers:
        raise Exception
except Exception:
    print("Input is not an integer, giving up.")
    sys.exit()
numbers_to_list = list(str(numbers))

longest_group = []
current_group = [numbers_to_list[0]]

for i in range(1, len(numbers_to_list)):
    if numbers_to_list[i] >= numbers_to_list[i - 1]:
        current_group.append(numbers_to_list[i])
    else:
        if len(current_group) > len(longest_group):
            longest_group = current_group
        current_group = [numbers_to_list[i]]
if len(current_group) > len(longest_group):
    longest_group = current_group
longest_sequence = ', '.join(longest_group)

print(f'{numbers}的最长子序列: {longest_sequence}')

快来参与讨论吧~