Python NumPy库：高效数值计算工具

需积分: 10 151 浏览量更新于2024-07-18 收藏 752KB PDF 举报

Python的NumPy系统是一个强大的开源数值计算库，由NumericalPython项目发起，由David Ascher、Paul F. Dubois、Konrad Hinsen、Jim Hugunin以及Travis Oliphant等人共同开发。它最初在Lawrence Livermore National Laboratory（LLNL）的加州利弗莫尔实验室（Livermore, CA 94566）诞生，并在UCRL-MA-128569项目下进行。这个库的核心目标是提供一个高效的方式来存储和处理大型矩阵，特别是在Python中，相较于传统的嵌套列表结构（nested list structure），它在性能上有着显著的优势。 NumPy的设计使得矩阵操作变得简单易行，这对于在人工智能、数据科学、机器学习等领域广泛应用的Python开发者来说，是不可或缺的工具。它的基础是N-dimensional array（N维数组），这些数组可以看作是向量或矩阵的高级表示形式，提供了诸如矩阵乘法、排序、统计运算等一系列功能，极大地提高了代码的执行效率和计算精度。版权方面，根据1999年的协议，该软件由加州大学的 Regents 所有，用户在不收取费用的情况下被允许使用、复制、修改和分发，但必须完整保留版权声明。此外，这个工作是基于美国能源部与加州大学之间的合同W-7405-ENG-48完成，这意味着它受到政府资助，并且使用时需注意免责声明：软件是由美国政府赞助的，政府、加州大学及其员工对软件的准确性、完整性或特定用途的适用性不作任何保证或承担法律责任。 NumPy系统是Python编程语言中用于数值计算的强大基石，其在科学计算、数据分析和机器学习中的广泛应用彰显了其在现代IT技术中的核心地位。对于想要深入理解和利用Python进行数值处理的专业人士来说，掌握NumPy是提升工作效率和技术能力的关键一步。

• High-Level Overview

4. High-Level Overview

In this chapter, a high-level overview of the extensions is provided, giving the reader the

definitions of the key components of the system. This section defines the concepts used by

the remaining sections.

Numeric Python consists of a set of modules:

• Numeric.py (and its helper modules multiarray, umath and fast_umath)

This module defines two new object types, and a set of functions which manipulate these objects, as well as

convert between them and other Python types. The objects are the new array object (technically called

multiarray objects), and universal functions (technically ufunc objects).

• RandomArray.py (and its helper module ranlib)

This module provides a high-level interface to a random-number generator.

• FFT.py (and its helper module fftpack)

This module provides a high-level interface to the fast Fourier transform routines implemented in the FFT-

PACK library if it is available, or to the compatible but less optimized fftpack library which is shipped with

Numeric Python..

• LinearAlgebra.py (and its helper module lapack_litemodule)

This module provides a high-level interface to the linear algebra routines implemented in the LAPACK li-

brary if it is available, or to the compatible but less optimized lapack_lite library which is shipped with

Numeric Python.

Array Objects

The array objects are generally homogeneous collections of potentially large numbers of numbers. All numbers

in a multiarray are the same kind (i.e. number representation, such as double-precision floating point). Array

objects must be full (no empty cells are allowed), and their size is immutable. The specific numbers within

them can change throughout the life of the array. The shape of an array is the set of numbers which describe the

number of indices of the array in each dimension. The total number of dimensions of an array is called its rank,

and is the number of numbers which make up the shape. A vector is a rank-1 array (it has only one dimension

along which it can be indexed). A matrix as used in linear algebra is a rank-2 array (it has two dimensions along

which it can be indexed). There are also rank-0 arrays, which can hold single scalars -- they have no dimension

along which they can be indexed, but they contain a single number. Mathematical operations on arrays return

new arrays containing the results of these operations performed

elementwise

on the arguments of the operation.

The

size

of an array is the total number of elements therein (it can be 0 or more). It does not change throughout

the life of the array.

The

shape

of an array is a description of the number of dimensions of the array and its extent in each of these

dimensions (it can be 0, 1 or more). It can change throughout the life of the array.

The

rank

of an array is the number of dimensions along which it is defined. It can change throughout the life of

the array.

The

typecode

of an array is a single character description of the kind of element it contains (number format,

character or Python reference). It determines the itemsize of the array.

• High-Level Overview

[0 1 0 1 0 1 0 1 0]

[1 0 1 0 1 0 1 0 1]

[0 1 0 1 0 1 0 1 0]

[1 0 1 0 1 0 1 0 1]

[0 1 0 1 0 1 0 1 0]

[1 0 1 0 1 0 1 0 1]

[0 1 0 1 0 1 0 1 0]]

All of the functions which operate on NumPy arrays are described in “Array Functions” on page 43.

RandomArray

The RandomArray module provides a high-level interface to the ranlib number generator. It provides a uni-

form distribution generator of pseudo-random numbers, as well as some convenience functions:

>>> from RandomArray import random, uniform, randint, permutation

>>> print random((5,5))

[[ 0.45456091 0.53438765 0.72412336 0.12156525 0.79255972]

[ 0.14763653 0.93401444 0.38913983 0.97293309 0.45860398]

[ 0.57528652 0.9801351 0.19893601 0.3396503 0.12224415]

[ 0.9067847 0.37667559 0.71613152 0.24334284 0.68907028]

[ 0.9655151 0.29746972 0.42734603 0.72314573 0.66344323]]

>>> print uniform(-1.0,1.0, (5,))

[-0.2637264 0.12331069 0.11497829 -0.25969645 0.36571342]

>>> print randint(10, 20, (4,2))

[[19 14]

[14 11]

[13 11]

[13 11]]

>>> print permutation(10)

[0 5 9 4 2 1 6 8 3 7]

>>> print permutation(10)

[3 7 1 2 9 0 4 8 5 6]

The reader should also be aware that LLNL provides an alternative random number generator, called RNG,

which also provides normal, log-normal and exponential distribution number generators (XXX other differenc-

es?). It is available at

ftp://ftp.icf.llnl.gov/pub/python/XXX

. See “RandomArray Reference” on page 86 for de-

tails.

FFT

The FFT module provides a high-level interface to the fast Fourier transform routines which are implemented

in the FFTPACK library. It performs one and two-dimensional FFT’s, forward and backwards (inverse FFTs),

and includes efficient routines for FFTs of real-valued arrays. It is most efficient for arrays whose size is a pow-

er of two.

>>> from FFT import fft, inverse_fft

>>> data = array((1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0))

>>> print data

[ 1. 0. 0. 0. 1. 0. 0. 0.]

>>> print fft(data)

[ 2.+0.j 0.+0.j 2.+0.j 0.+0.j 2.+0.j 0.+0.j 2.+0.j 0.+0.j]

>>> print inverse_fft(fft(data))

[ 1.+0.j 0.+0.j 0.+0.j 0.+0.j 1.+0.j 0.+0.j 0.+0.j 0.+0.j]

See “FFT Reference” on page 81 for details.

• Array Basics

5. Array Basics

This chapter introduces some of the basic functions which will be used throughout the text.

Basics

Before we explore the world of image manipulation as a case-study in array manipulation, we should first de-

fine a few terms which we’ll use over and over again. Discussions of arrays and matrices and vectors can get

confusing due to disagreements on the nomenclature. Here is a brief definition of the terms used in this tutorial,

and more or less consistently in the error messages of NumPy.

The python objects under discussion are formally called “multiarray” objects, but informally we’ll just call

them “array” objects or just “arrays.” These are different from the array objects defined in the standard array

module (which is designed at processing one-dimensional data such as sound files).

These array objects are arrays in the computer science meaning of homogeneous block of elements, i.e. their el-

ements all have the same “kind” (usually, a specific kind of number, such as a 64-bit integer). This is quite dif-

ferent from most Python container objects, which can contain heterogeneous collections. Imposing this

restriction was a necessary step for a fast implementation, and in practice, it is not a cumbersome restriction in

many cases

Any given array object has a rank, which is the number of “dimensions” or “axes” it has. For example, a point

in 3D space [1, 2, 1] is an array of rank 1 – it has one dimension. That dimension has a

length

of 3.

As another example, the array

1.0 0.0 0.0

0.0 1.0 2.0

is an array of rank 2 (it is 2-dimensional). The first dimension has a length of 2, the second dimension has a

length of 3. Because the word “dimension” has many different meanings to different folks, in general the word

“axis” will be used instead. Axes are numbered just like Python list indices: they start at 0, and can also be

counted from the end, so that axis -1 is the last axis of an array, axis -2 is the penultimate axis, etc.

There are two important and potentially unintuitive behaviors of NumPy arrays which take some getting used

to. The first is that by default, operations on arrays are performed element-wise. This means that when adding

two arrays, the resulting array has as elements the pairwise sums of the two operand arrays. This is true for all

operations, including multiplication. Thus, array multiplication using the * operator will default to element-

wise multiplication, not matrix multiplication as used in linear algebra. Many people will want to use arrays as

linear algebra-type matrices (including their rank-1 versions, vectors). For those users, the Matrix class pro-

vides a more intuitive interface. We defer discussion of the Matrix class until later. The second behavior which

will catch many users by surprise is that functions which return arrays which are simply different views at the

same data will in fact

their data. This will be discussed at length when we have more concrete examples

of what exactly this means.

Now that all of these definitions and warnings are laid out, let's see what we can do with these arrays.

1. As we’ll also see, one valid “object kind” is a Python reference – in other words, these arrays can be

made heterogeneous at the cost of speed.

剩余92页未读，继续阅读

xinliang_6

粉丝: 4
资源: 7

Python NumPy库：高效数值计算工具

Numpy 参考手册英文版

numpy入门教程 第二版（英文版）

numpy_1.15.0官方文档

python numpy安装教程

pythonnumpy库安装

python numpy离线安装

windows pythonnumpy安装

ubuntu20.04 python numpy库安装

python numpy库下载

python numpy pandas matplotlib

最新资源

numpy入门教程第二版（英文版）