pandas教程：第一章

列表推导式

In : [2*x for i in range(5)]
Out: [0, 2, 4, 6, 8]

相当于循环的简写

这样的东西还可以循环嵌套，从而实现双重循环

完整的语法应该是：

new_list = [expression for item in iterable if condition]

实际结合 if 的条件赋值的标准形式是：

value = a if condition else b

lambda 表达式

这东西就不多说了，这东西在 python 中十分的简陋

zip

zip() 是 Python 内置函数之一，它可以将多个可迭代对象中的元素按照索引位置打包成元组，返回一个可迭代的 zip 对象。这个 zip 对象可以被用于循环遍历，也可以被转化成列表、字典等数据结构。

zip() 函数的语法如下：

zip(*iterables)

其中，*iterables 表示可迭代对象，可以传入一个或多个可迭代对象。

zip() 函数将返回一个 zip 对象，该对象包含了每个可迭代对象中的元素按照索引位置打包成的元组，例如：

>>> list1 = [1, 2, 3]
>>> list2 = ['a', 'b', 'c']
>>> zip_object = zip(list1, list2)
>>> print(zip_object)
<zip object at 0x7f9b2ce7c448>
>>> for item in zip_object:
...     print(item)
...
(1, 'a')
(2, 'b')
(3, 'c')

需要注意的是，zip() 函数返回的 zip 对象只能被遍历一次，因为在第一次遍历过程中，已经将元素打包成元组，再次遍历时就已经没有可迭代的对象了。

此外，zip() 函数还可以用于解压缩（即将多个元组解压为多个列表），可以通过将 zip() 对象和 * 运算符结合使用来实现解压缩操作，例如：

>>> zip_object = zip(list1, list2)
>>> new_list1, new_list2 = zip(*zip_object)
>>> print(new_list1)
(1, 2, 3)
>>> print(new_list2)
('a', 'b', 'c')

在这个例子中，zip(*zip_object) 将 zip_object 中的元素解压为两个列表 new_list1 和 new_list2，其中 new_list1 包含了 list1 中的所有元素，new_list2 包含了 list2 中的所有元素。

enumerate

enumerate() 是 Python 内置函数之一，它可以将一个可迭代对象中的每个元素和它的索引位置一起打包成一个元组，并返回一个可迭代的 enumerate 对象。这个 enumerate 对象可以被用于循环遍历，也可以被转化成列表、字典等数据结构。

enumerate() 函数的语法如下：

enumerate(iterable, start=0)

其中，iterable 表示可迭代对象，start 表示索引位置的起始值，它的默认值为 0。

enumerate() 函数将返回一个 enumerate 对象，该对象包含了每个元素和它的索引位置打包成的元组，例如：

>>> my_list = ['apple', 'banana', 'orange']
>>> enumerate_object = enumerate(my_list)
>>> print(enumerate_object)
<enumerate object at 0x7f9b2ce7c448>
>>> for index, item in enumerate_object:
...     print(index, item)
...
0 apple
1 banana
2 orange

需要注意的是，enumerate() 函数返回的 enumerate 对象只能被遍历一次，因为在第一次遍历过程中，已经将元素和索引位置打包成元组，再次遍历时就已经没有可迭代的对象了。

此外，enumerate() 函数还可以通过设置 start 参数来指定索引位置的起始值，例如：

>>> my_list = ['apple', 'banana', 'orange']
>>> enumerate_object = enumerate(my_list, start=1)
>>> for index, item in enumerate_object:
...     print(index, item)
...
1 apple
2 banana
3 orange

在这个例子中，start=1 表示索引位置从 1 开始，所以第一个元素的索引位置为 1。

元组

元组（Tuple）是 Python 中的一种数据类型，它是一个有序、不可变的序列，可以包含任意类型的数据，包括数字、字符串、列表、元组等。

元组与列表类似，但它们有一些重要的区别。元组是不可变的，一旦创建就不能再修改，而列表是可变的，可以进行添加、删除、修改等操作。另外，元组通常用于存储一组相关的值，并且元组可以作为函数的参数和返回值，也可以用于解包操作。

元组的创建方式有多种，最常见的方式是使用圆括号 ( )，将多个元素用逗号 , 分隔开，例如：

my_tuple = (1, 2, 3, "apple", "banana")

也可以使用内置函数 tuple() 来创建元组，将一个序列对象（如列表、字符串）作为参数传入，例如：

my_list = [1, 2, 3, "apple", "banana"]
my_tuple = tuple(my_list)

元组的访问方式和列表类似，可以使用索引和切片来访问元素，例如：

my_tuple = (1, 2, 3, "apple", "banana")

# 访问第一个元素
print(my_tuple[0])

# 访问最后一个元素
print(my_tuple[-1])

# 切片访问元素
print(my_tuple[1:4])

输出结果为：

1
banana
(2, 3, 'apple')

需要注意的是，由于元组是不可变的，因此不能通过索引或切片来修改元素，例如：

my_tuple = (1, 2, 3, "apple", "banana")

# 以下语句会抛出 TypeError 异常
my_tuple[0] = 10

NumPy 数组的切片和索引是一种非常强大的数据选取方法，可以快速、灵活地选取数组中的元素。下面分别介绍一下 NumPy 数组的切片和索引。

切片

NumPy 数组的切片操作类似于 Python 中的切片操作，用于选取数组的某个子集。NumPy 数组的切片操作可以使用 : 符号来指定起始位置、结束位置和步长，其语法格式为 start:stop:step。

例如，在一个形状为 (3, 4) 的二维数组中，使用 arr[1:3, 0:2] 可以选取第 2 行和第 3 行、第 1 列和第 2 列的交叉部分，即一个形状为 (2, 2) 的子数组：

import numpy as np

arr = np.array([[1, 2, 3, 4],
                [5, 6, 7, 8],
                [9, 10, 11, 12]])

sub_arr = arr[1:3, 0:2]
print(sub_arr)

输出结果为：

[[ 5  6]
 [ 9 10]]

需要注意的是，NumPy 数组的切片操作返回的是原始数组的一个视图（view），也就是说，切片操作返回的是原始数组的一个子数组，它们在内存中的位置是相同的。因此，对这个子数组进行修改会直接影响原始数组。

索引

NumPy 数组的索引操作可以用来选取数组中的某个元素或一组元素。NumPy 数组的索引操作可以使用整数、布尔值或条件表达式来指定要选取的元素。

例如，在一个形状为 (3, 4) 的二维数组中，使用 arr[1, 2] 可以选取第 2 行第 3 列的元素：

import numpy as np

arr = np.array([[1, 2, 3, 4],
                [5, 6, 7, 8],
                [9, 10, 11, 12]])

elem = arr[1, 2]
print(elem)

输出结果为：

7

同时，也可以使用布尔值或条件表达式来选取数组中满足条件的元素：

import numpy as np

arr = np.array([[1, 2, 3, 4],
                [5, 6, 7, 8],
                [9, 10, 11, 12]])

bool_arr = arr > 5   # 生成一个布尔值数组，元素为 arr 中大于 5 的元素的位置为 True，否则为 False
sub_arr = arr[bool_arr]   # 选取 arr 中大于 5 的元素

print(bool_arr)
print(sub_arr)

输出结果为：

[[False False False False]
 [False  True  True  True]
 [ True  True  True  True]]

[ 6  7  8  9 10 11 12]

需要注意的是，与切片操作不同，NumPy 数组的索引操作返回的是原始数组中被选取的元素的一个复制（copy），而不是一个视图（view）。因此，对这些元素进行修改不会影响原始数组。

numpy中的广播机制是指在进行一些数组运算时，numpy会自动处理不同形状的数组之间的运算，使得它们可以进行逐元素的运算，而无需进行显式的循环操作。

具体来说，当进行二元操作时，numpy会比较两个数组的形状，如果它们的形状不同，numpy会尝试将它们的形状进行扩展，使得它们的形状可以逐元素地进行运算。比如，如果一个数组的形状是(3,1)，另一个数组的形状是(1,4)，那么numpy会自动将第一个数组扩展成(3,4)的形状，使得两个数组可以进行逐元素的运算。

广播机制的好处是可以简化代码，使得代码更加简洁和易读，同时也可以提高代码的性能，避免了显式循环所带来的性能损失。但是需要注意的是，在使用广播机制时需要注意数组的形状，确保它们可以正确地进行扩展，避免出现意外的结果。