（翻译英文）基础知识部分章节

Author: lisniuse

docs/user/basics/broadcasting.md

@@ -1,107 +1,71 @@
-# Broadcasting
+# 广播（Broadcasting）
 
-::: tip See also
+::: tip 另见
 
-[``numpy.broadcast``](https://numpy.org/devdocs/reference/generated/numpy.broadcast.html#numpy.broadcast)
-
-[Array Broadcasting in Numpy](theory.broadcasting.html#array-broadcasting-in-numpy)
+- [``numpy.broadcast``](/reference/generated/numpy.broadcast.html#numpy.broadcast)
+- [Numpy中的数组广播](https://numpy.org/devdocs/user/theory.broadcasting.html#array-broadcasting-in-numpy)
 
 :::
 
-::: tip Note
+::: tip 注意
 
-See [this article](https://numpy.org/devdocs/user/theory.broadcasting.html)
-for illustrations of broadcasting concepts.
+有关广播概念的说明，请参阅[此文章](https://numpy.org/devdocs/user/theory.broadcasting.html)。
 
 :::
 
-The term broadcasting describes how numpy treats arrays with different
-shapes during arithmetic operations. Subject to certain constraints,
-the smaller array is “broadcast” across the larger array so that they
-have compatible shapes. Broadcasting provides a means of vectorizing
-array operations so that looping occurs in C instead of Python. It does
-this without making needless copies of data and usually leads to
-efficient algorithm implementations. There are, however, cases where
-broadcasting is a bad idea because it leads to inefficient use of memory
-that slows computation.
+术语广播（Broadcasting）描述了 numpy 如何在算术运算期间处理具有不同形状的数组。受某些约束的影响，较小的数组在较大的数组上“广播”，以便它们具有兼容的形状。广播提供了一种矢量化数组操作的方法，以便在C而不是Python中进行循环。它可以在不制作不必要的数据副本的情况下实现这一点，通常导致高效的算法实现。然而，有些情况下广播是一个坏主意，因为它会导致内存使用效率低下，从而减慢计算速度。
 
-NumPy operations are usually done on pairs of arrays on an
-element-by-element basis. In the simplest case, the two arrays must
-have exactly the same shape, as in the following example:
+NumPy 操作通常在逐个元素的基础上在数组对上完成。在最简单的情况下，两个数组必须具有完全相同的形状，如下例所示：
 
 ``` python
->>> a = np.array([1.0, 2.0, 3.0])
+>>>>>> a = np.array([1.0, 2.0, 3.0])
 >>> b = np.array([2.0, 2.0, 2.0])
 >>> a * b
 array([ 2., 4., 6.])
 ```
 
-NumPy’s broadcasting rule relaxes this constraint when the arrays’
-shapes meet certain constraints. The simplest broadcasting example occurs
-when an array and a scalar value are combined in an operation:
+当数组的形状满足某些约束时，NumPy的广播规则放宽了这种约束。当一个数组和一个标量值在一个操作中组合时，会发生最简单的广播示例：
 
 ``` python
->>> a = np.array([1.0, 2.0, 3.0])
+>>>>>> a = np.array([1.0, 2.0, 3.0])
 >>> b = 2.0
 >>> a * b
 array([ 2., 4., 6.])
 ```
 
-The result is equivalent to the previous example where ``b`` was an array.
-We can think of the scalar ``b`` being *stretched* during the arithmetic
-operation into an array with the same shape as ``a``. The new elements in
-``b`` are simply copies of the original scalar. The stretching analogy is
-only conceptual. NumPy is smart enough to use the original scalar value
-without actually making copies so that broadcasting operations are as
-memory and computationally efficient as possible.
+结果等同于前面的示例，其中``b``是数组。我们可以将在算术运算期间``b``被 *拉伸* 的标量想象成具有相同形状的数组``a``。新元素
+ ``b``只是原始标量的副本。拉伸类比只是概念性的。NumPy足够聪明，可以使用原始标量值而无需实际制作副本，因此广播操作尽可能具有内存和计算效率。
 
-The code in the second example is more efficient than that in the first
-because broadcasting moves less memory around during the multiplication
-(``b`` is a scalar rather than an array).
+第二个示例中的代码比第一个示例中的代码更有效，因为广播在乘法期间移动的内存较少（``b``是标量而不是数组）。
 
-## General Broadcasting Rules
+## 一般广播规则
 
-When operating on two arrays, NumPy compares their shapes element-wise.
-It starts with the trailing dimensions and works its way forward. Two
-dimensions are compatible when
+在两个数组上运行时，NumPy会逐元素地比较它们的形状。它从尾随尺寸开始，并向前发展。两个尺寸兼容时
 
-1. they are equal, or
-1. one of them is 1
+1. 他们是平等的，或者
+1. 其中一个是1
 
-If these conditions are not met, a
-``ValueError: operands could not be broadcast together`` exception is 
-thrown, indicating that the arrays have incompatible shapes. The size of 
-the resulting array is the maximum size along each dimension of the input 
-arrays.
+如果不满足这些条件，则抛出 ``ValueError: operands could not be broadcast together`` 异常，指示数组具有不兼容的形状。结果数组的大小是沿输入的每个轴不是1的大小。
 
-Arrays do not need to have the same *number* of dimensions. For example,
-if you have a ``256x256x3`` array of RGB values, and you want to scale
-each color in the image by a different value, you can multiply the image
-by a one-dimensional array with 3 values. Lining up the sizes of the
-trailing axes of these arrays according to the broadcast rules, shows that
-they are compatible:
+数组不需要具有相同 *数量* 的维度。例如，如果您有一个``256x256x3``RGB值数组，并且希望将图像中的每种颜色缩放不同的值，则可以将图像乘以具有3个值的一维数组。根据广播规则排列这些数组的尾轴的大小，表明它们是兼容的：
 
 ``` python
 Image (3d array): 256 x 256 x 3
 Scale (1d array): 3
 Result (3d array): 256 x 256 x 3
 ```
 
-When either of the dimensions compared is one, the other is
-used. In other words, dimensions with size 1 are stretched or “copied”
-to match the other.
+当比较的任何一个尺寸为1时，使用另一个尺寸。换句话说，尺寸为1的尺寸被拉伸或“复制”以匹配另一个尺寸。
 
-In the following example, both the ``A`` and ``B`` arrays have axes with
-length one that are expanded to a larger size during the broadcast
-operation:
+在以下示例中，``A``和``B``数组都具有长度为1的轴，在广播操作期间会扩展为更大的大小：
 
 ``` python
 A (4d array): 8 x 1 x 6 x 1
 B (3d array): 7 x 1 x 5
 Result (4d array): 8 x 7 x 6 x 5
 ```
 
-Here are some more examples:
+以下是一些例子：
 
 ``` python
 A (2d array): 5 x 4
@@ -125,7 +89,7 @@ B (2d array): 3 x 1
 Result (3d array): 15 x 3 x 5
 ```
 
-Here are examples of shapes that do not broadcast:
+以下是不广播的形状示例：
 
 ``` python
 A (1d array): 3
@@ -135,10 +99,10 @@ A (2d array): 2 x 1
 B (3d array): 8 x 4 x 3 # second from last dimensions mismatched
 ```
 
-An example of broadcasting in practice:
+实践中广播的一个例子：
 
 ``` python
->>> x = np.arange(4)
+>>>>>> x = np.arange(4)
 >>> xx = x.reshape(4,1)
 >>> y = np.ones(5)
 >>> z = np.ones((3,4))
@@ -182,12 +146,10 @@ array([[ 1., 2., 3., 4.],
  [ 1., 2., 3., 4.]])
 ```
 
-Broadcasting provides a convenient way of taking the outer product (or
-any other outer operation) of two arrays. The following example shows an
-outer addition operation of two 1-d arrays:
+广播提供了一种方便的方式来获取两个数组的外积（或任何其他外部操作）。以下示例显示了两个1-d数组的外积操作：
 
 ``` python
->>> a = np.array([0.0, 10.0, 20.0, 30.0])
+>>>>>> a = np.array([0.0, 10.0, 20.0, 30.0])
 >>> b = np.array([1.0, 2.0, 3.0])
 >>> a[:, np.newaxis] + b
 array([[ 1., 2., 3.],
@@ -196,6 +158,5 @@ array([[ 1., 2., 3.],
  [ 31., 32., 33.]])
 ```
 
-Here the ``newaxis`` index operator inserts a new axis into ``a``,
-making it a two-dimensional ``4x1`` array. Combining the ``4x1`` array
-with ``b``, which has shape ``(3,)``, yields a ``4x3`` array.
+这里 ``newaxis`` 索引操作符插入一个新轴 ``a`` ，使其成为一个二维 ``4x1`` 数组。将 ``4x1`` 数组与形状为 ``(3,)`` 的 ``b`` 组合，产生一个``4x3``数组。
+

docs/user/basics/byteswapping.md

@@ -1,27 +1,27 @@
-# Byte-swapping
+# 字节交换
 
-## Introduction to byte ordering and ndarrays
+## 字节排序和ndarrays简介
 
-The ``ndarray`` is an object that provide a python array interface to data in memory.
+``ndarray``是一个为内存中的数据提供python数组接口的对象。
 
-It often happens that the memory that you want to view with an array is not of the same byte ordering as the computer on which you are running Python.
+经常发生的情况是，要用数组查看的内存与运行Python的计算机的字节顺序不同。
 
-For example, I might be working on a computer with a little-endian CPU - such as an Intel Pentium, but I have loaded some data from a file written by a computer that is big-endian. Let’s say I have loaded 4 bytes from a file written by a Sun (big-endian) computer. I know that these 4 bytes represent two 16-bit integers. On a big-endian machine, a two-byte integer is stored with the Most Significant Byte (MSB) first, and then the Least Significant Byte (LSB). Thus the bytes are, in memory order:
+例如，我可能正在使用带有 little-endian CPU 的计算机 - 例如Intel Pentium，但是我已经从一个由 big-endian计算机 编写的文件中加载了一些数据。假设我已经从Sun（big-endian）计算机写入的文件中加载了4个字节。我知道这4个字节代表两个16位整数。在 big-endian 机器上，首先以最高有效字节（MSB）存储双字节整数，然后存储最低有效字节（LSB）。因此字节按内存顺序排列：
 
-1. MSB integer 1
-1. LSB integer 1
-1. MSB integer 2
-1. LSB integer 2
+1. MSB整数1
+1. LSB整数1
+1. MSB整数2
+1. LSB整数2
 
-Let’s say the two integers were in fact 1 and 770. Because 770 = 256 * 3 + 2, the 4 bytes in memory would contain respectively: 0, 1, 3, 2. The bytes I have loaded from the file would have these contents:
+假设两个整数实际上是1和770.因为770 = 256 * 3 + 2，内存中的4个字节将分别包含：0,1,3,2。我从文件加载的字节将包含这些内容：
 
 ``` python
 >>> big_end_buffer = bytearray([0,1,3,2])
 >>> big_end_buffer
 bytearray(b'\x00\x01\x03\x02')
 ```
 
-We might want to use an ``ndarray`` to access these integers. In that case, we can create an array around this memory, and tell numpy that there are two integers, and that they are 16 bit and big-endian:
+我们可能需要使用 ``ndarray`` 来访问这些整数。在这种情况下，我们可以围绕这个内存创建一个数组，并告诉numpy有两个整数，并且它们是16位和Big-endian：
 
 ``` python
 >>> import numpy as np
@@ -32,21 +32,21 @@ We might want to use an ``ndarray`` to access these integers. In that case, we c
 770
 ```
 
-Note the array ``dtype`` above of ``>i2``. The ``>`` means ‘big-endian’ (``<`` is little-endian) and i2 means ‘signed 2-byte integer’. For example, if our data represented a single unsigned 4-byte little-endian integer, the dtype string would be ``<u4``.
+注意上面的数组``dtype > i2``。``>`` 表示 ``big-endian``( ``<`` 是 ``Little-endian`` )，``i2`` 表示‘有符号的2字节整数’。例如，如果我们的数据表示单个无符号4字节小端整数，则dtype字符串将为 ``<u4``。
 
-In fact, why don’t we try that?
+事实上，为什么我们不尝试呢？
 
 ``` python
 >>> little_end_u4 = np.ndarray(shape=(1,),dtype='<u4', buffer=big_end_buffer)
 >>> little_end_u4[0] == 1 * 256**1 + 3 * 256**2 + 2 * 256**3
 True
 ```
 
-Returning to our ``big_end_arr`` - in this case our underlying data is big-endian (data endianness) and we’ve set the dtype to match (the dtype is also big-endian). However, sometimes you need to flip these around.
+回到我们的 ``big_end_arr`` - 在这种情况下我们的基础数据是big-endian（数据字节序），我们设置dtype匹配（dtype也是big-endian）。但是，有时你需要翻转它们。
 
 ::: danger 警告
 
-Scalars currently do not include byte order information, so extracting a scalar from an array will return an integer in native byte order. Hence:
+标量当前不包含字节顺序信息，因此从数组中提取标量将返回本机字节顺序的整数。因此：
 
 ``` python
 >>> big_end_arr[0].dtype.byteorder == little_end_u4[0].dtype.byteorder
@@ -55,64 +55,64 @@ True
 
 :::
 
-## Changing byte ordering
+## 更改字节顺序
 
-As you can imagine from the introduction, there are two ways you can affect the relationship between the byte ordering of the array and the underlying memory it is looking at:
+从介绍中可以想象，有两种方法可以影响数组的字节顺序与它所查看的底层内存之间的关系：
 
-- Change the byte-ordering information in the array dtype so that it interprets the underlying data as being in a different byte order. This is the role of ``arr.newbyteorder()``
-- Change the byte-ordering of the underlying data, leaving the dtype interpretation as it was. This is what ``arr.byteswap()`` does.
+- 更改数组dtype中的字节顺序信息，以便将基础数据解释为不同的字节顺序。这是作用 ``arr.newbyteorder()``
+- 更改基础数据的字节顺序，保留dtype解释。这是做什么的 ``arr.byteswap()``。
 
-The common situations in which you need to change byte ordering are:
+您需要更改字节顺序的常见情况是：
 
-1. Your data and dtype endianness don’t match, and you want to change the dtype so that it matches the data.
-1. Your data and dtype endianness don’t match, and you want to swap the data so that they match the dtype
-1. Your data and dtype endianness match, but you want the data swapped and the dtype to reflect this
+1. 您的数据和dtype字节顺序不匹配，并且您希望更改dtype以使其与数据匹配。
+1. 您的数据和dtype字节顺序不匹配，并且您希望交换数据以使它们与dtype匹配
+1. 您的数据和dtype字节顺序匹配，但您希望交换数据和dtype来反映这一点
 
-### Data and dtype endianness don’t match, change dtype to match data
+### 数据和dtype字节顺序不匹配，更改dtype以匹配数据
 
-We make something where they don’t match:
+我们制作一些他们不匹配的东西：
 
 ``` python
 >>> wrong_end_dtype_arr = np.ndarray(shape=(2,),dtype='<i2', buffer=big_end_buffer)
 >>> wrong_end_dtype_arr[0]
 256
 ```
 
-The obvious fix for this situation is to change the dtype so it gives the correct endianness:
+这种情况的明显解决方法是更改​​dtype，以便它给出正确的字节顺序：
 
 ``` python
 >>> fixed_end_dtype_arr = wrong_end_dtype_arr.newbyteorder()
 >>> fixed_end_dtype_arr[0]
 1
 ```
 
-Note the array has not changed in memory:
+请注意，内存中的数组未更改：
 
 ``` python
 >>> fixed_end_dtype_arr.tobytes() == big_end_buffer
 True
 ```
 
-### Data and type endianness don’t match, change data to match dtype
+### 数据和类型字节顺序不匹配，更改数据以匹配dtype
 
-You might want to do this if you need the data in memory to be a certain ordering. For example you might be writing the memory out to a file that needs a certain byte ordering.
+如果您需要内存中的数据是某种顺序，您可能希望这样做。例如，您可能正在将内存写入需要特定字节排序的文件。
 
 ``` python
 >>> fixed_end_mem_arr = wrong_end_dtype_arr.byteswap()
 >>> fixed_end_mem_arr[0]
 1
 ```
 
-Now the array has changed in memory:
+现在阵列 *已* 在内存中更改：
 
 ``` python
 >>> fixed_end_mem_arr.tobytes() == big_end_buffer
 False
 ```
 
-### Data and dtype endianness match, swap data and dtype
+### 数据和dtype字节序匹配，交换数据和dtype
 
-You may have a correctly specified array dtype, but you need the array to have the opposite byte order in memory, and you want the dtype to match so the array values make sense. In this case you just do both of the previous operations:
+您可能有一个正确指定的数组dtype，但是您需要数组在内存中具有相反的字节顺序，并且您希望dtype匹配以便数组值有意义。在这种情况下，您只需执行上述两个操作：
 
 ``` python
 >>> swapped_end_arr = big_end_arr.byteswap().newbyteorder()
@@ -122,12 +122,12 @@ You may have a correctly specified array dtype, but you need the array to have t
 False
 ```
 
-An easier way of casting the data to a specific dtype and byte ordering can be achieved with the ndarray astype method:
+使用ndarray astype方法可以更简单地将数据转换为特定的dtype和字节顺序：
 
 ``` python
 >>> swapped_end_arr = big_end_arr.astype('<i2')
 >>> swapped_end_arr[0]
 1
 >>> swapped_end_arr.tobytes() == big_end_buffer
 False
-```
+```