NumPy 1.7.0官方手册：全面指南与安装教程

需积分: 16 77 浏览量更新于2024-07-16 收藏 395KB PDF 举报

numpy-user-v1.7.0.pdf 是 NumPy 手册的英文版本，适用于 NumPy 1.7.0 时期。NumPy 是一个流行的 Python 库，用于处理大型多维数组和矩阵计算，其功能强大且高效。本手册提供了丰富的内容，包括但不限于： 1. **简介**：首先介绍了 NumPy 的基本概念，阐述其在科学计算、数据分析和机器学习等领域中的重要性。它解释了如何安装和配置 NumPy，以便用户能够充分利用其功能。 2. **NumPy 基础**： - **数据类型**：涵盖了 NumPy 支持的不同数据类型，如标量、整型、浮点型和复数等，以及它们的特点和用途。 - **数组创建**：介绍了如何使用各种函数（如 `array`、`zeros`、`ones` 和 `empty` 等）创建数组，以及从不同源（如列表、文件或其他数据结构）导入数据的方法。 - **I/O 操作**：讲解了 NumPy 在读取和保存数据方面的功能，例如 CSV 文件、文本文件和二进制格式。 - **索引和切片**：说明了如何通过不同的方式访问数组元素，以及如何进行高级的索引和切片操作。 - **广播**：阐述了 NumPy 的广播规则，使得不同类型和形状的数组运算变得简单。 - **结构化数组**：讨论了结构数组（或称记录数组），这是一种可以包含不同类型数据的数组。 - **ndarray 子类**：介绍了如何扩展 NumPy 数组的功能，通过子类化 ndarray 类。 3. **性能优化**：部分章节探讨了如何提高 NumPy 应用的效率，包括内存管理、性能调优和避免常见陷阱。 4. **其他主题**： - **浮点数特殊值**：涉及 NumPy 如何处理 IEEE 754 浮点数标准中的非正常数值，如无穷大和 NaN。 - **异常处理**：说明 NumPy 对数学运算错误的处理方式，以及用户如何捕获和处理这些异常。 - **与 C/C++/Fortran 的接口**：介绍了如何利用 NumPy 与其他编程语言交互，如调用 C 代码库或 Fortran 函数。 - **方法与函数的区别**：强调了 NumPy 方法和函数在使用上的差异，帮助用户理解何时选择哪种方式。 5. **使用 NumPy C API**：这部分指导开发者如何利用 C API 扩展 NumPy 功能，以及如何编写自定义的通用函数 (ufunc)。 6. **高级应用**：提供了一些进阶技巧和示例，帮助用户深入理解和利用 NumPy 的高级特性。整个文档旨在为 NumPy 用户提供全面且实用的指南，无论是初学者还是高级用户都能从中受益。

NumPy User Guide, Release 1.7.0

ones(shape) will create an array ﬁlled with 1 values. It is identical to zeros in all other respects.

arange() will create arrays with regularly incrementing values. Check the docstring for complete information on the

various ways it can be used. A few examples will be given here:

>>> np.arange(10)

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

>>> np.arange(2, 10, dtype=np.float)

array([ 2., 3., 4., 5., 6., 7., 8., 9.])

>>> np.arange(2, 3, 0.1)

array([ 2. , 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9])

Note that there are some subtleties regarding the last usage that the user should be aware of that are described in the

arange docstring.

linspace() will create arrays with a speciﬁed number of elements, and spaced equally between the speciﬁed beginning

and end values. For example:

>>> np.linspace(1., 4., 6)

array([ 1. , 1.6, 2.2, 2.8, 3.4, 4. ])

The advantage of this creation function is that one can guarantee the number of elements and the starting and end

point, which arange() generally will not do for arbitrary start, stop, and step values.

indices() will create a set of arrays (stacked as a one-higher dimensioned array), one per dimension with each repre-

senting variation in that dimension. An example illustrates much better than a verbal description:

>>> np.indices((3,3))

array([[[0, 0, 0], [1, 1, 1], [2, 2, 2]], [[0, 1, 2], [0, 1, 2], [0, 1, 2]]])

This is particularly useful for evaluating functions of multiple dimensions on a regular grid.

2.2.4 Reading Arrays From Disk

This is presumably the most common case of large array creation. The details, of course, depend greatly on the format

of data on disk and so this section can only give general pointers on how to handle various formats.

Standard Binary Formats

Various ﬁelds have standard formats for array data. The following lists the ones with known python libraries to read

them and return numpy arrays (there may be others for which it is possible to read and convert to numpy arrays so

check the last section as well)

HDF5: PyTables

FITS: PyFITS

Examples of formats that cannot be read directly but for which it is not hard to convert are libraries like PIL (able to

read and write many image formats such as jpg, png, etc).

Common ASCII Formats

Comma Separated Value ﬁles (CSV) are widely used (and an export and import option for programs like Excel). There

are a number of ways of reading these ﬁles in Python. There are CSV functions in Python and functions in pylab (part

of matplotlib).

More generic ascii ﬁles can be read using the io package in scipy.

12 Chapter 2. Numpy basics

NumPy User Guide, Release 1.7.0

Custom Binary Formats

There are a variety of approaches one can use. If the ﬁle has a relatively simple format then one can write a simple

I/O library and use the numpy fromﬁle() function and .toﬁle() method to read and write numpy arrays directly (mind

your byteorder though!) If a good C or C++ library exists that read the data, one can wrap that library with a variety of

techniques though that certainly is much more work and requires signiﬁcantly more advanced knowledge to interface

with C or C++.

Use of Special Libraries

There are libraries that can be used to generate arrays for special purposes and it isn’t possible to enumerate all of

them. The most common uses are use of the many array generation functions in random that can generate arrays of

random values, and some utility functions to generate special matrices (e.g. diagonal).

2.3 I/O with Numpy

2.3.1 Importing data with genfromtxt

Numpy provides several functions to create arrays from tabular data. We focus here on the genfromtxt function.

In a nutshell, genfromtxt runs two main loops. The ﬁrst loop converts each line of the ﬁle in a sequence of strings.

The second loop converts each string to the appropriate data type. This mechanism is slower than a single loop, but

gives more ﬂexibility. In particular, genfromtxt is able to take missing data into account, when other faster and

simpler functions like loadtxt cannot

Note: When giving examples, we will use the following conventions

>>> import numpy as np

>>> from StringIO import StringIO

Deﬁning the input

The only mandatory argument of genfromtxt is the source of the data. It can be a string corresponding to the name

of a local or remote ﬁle, or a ﬁle-like object with a read method (such as an actual ﬁle or a StringIO.StringIO

object). If the argument is the URL of a remote ﬁle, this latter is automatically downloaded in the current directory.

The input ﬁle can be a text ﬁle or an archive. Currently, the function recognizes gzip and bz2 (bzip2) archives. The

type of the archive is determined by examining the extension of the ﬁle: if the ﬁlename ends with ’.gz’, a gzip

archive is expected; if it ends with ’bz2’, a bzip2 archive is assumed.

Splitting the lines into columns

The delimiter argument

Once the ﬁle is deﬁned and open for reading, genfromtxt splits each non-empty line into a sequence of strings.

Empty or commented lines are just skipped. The delimiter keyword is used to deﬁne how the splitting should take

place.

Quite often, a single character marks the separation between columns. For example, comma-separated ﬁles (CSV) use

a comma (,) or a semicolon (;) as delimiter.

2.3. I/O with Numpy 13

NumPy User Guide, Release 1.7.0

>>> data = "1, 2, 3\n4, 5, 6"

>>> np.genfromtxt(StringIO(data), delimiter=",")

array([[ 1., 2., 3.],

[ 4., 5., 6.]])

Another common separator is "\t", the tabulation character. However, we are not limited to a single character, any

string will do. By default, genfromtxt assumes delimiter=None, meaning that the line is split along white

spaces (including tabs) and that consecutive white spaces are considered as a single white space.

Alternatively, we may be dealing with a ﬁxed-width ﬁle, where columns are deﬁned as a given number of characters.

In that case, we need to set delimiter to a single integer (if all the columns have the same size) or to a sequence of

integers (if columns can have different sizes).

>>> data = " 1 2 3\n 4 5 67\n890123 4"

>>> np.genfromtxt(StringIO(data), delimiter=3)

array([[ 1., 2., 3.],

[ 4., 5., 67.],

[ 890., 123., 4.]])

>>> data = "123456789\n 4 7 9\n 4567 9"

>>> np.genfromtxt(StringIO(data), delimiter=(4, 3, 2))

array([[ 1234., 567., 89.],

[ 4., 7., 9.],

[ 4., 567., 9.]])

The autostrip argument

By default, when a line is decomposed into a series of strings, the individual entries are not stripped of leading nor

trailing white spaces. This behavior can be overwritten by setting the optional argument autostrip to a value of

True.

>>> data = "1, abc , 2\n 3, xxx, 4"

>>> # Without autostrip

>>> np.genfromtxt(StringIO(data), dtype="|S5")

array([[’1’, ’ abc ’, ’ 2’],

[’3’, ’ xxx’, ’ 4’]],

dtype=’|S5’)

>>> # With autostrip

>>> np.genfromtxt(StringIO(data), dtype="|S5", autostrip=True)

array([[’1’, ’abc’, ’2’],

[’3’, ’xxx’, ’4’]],

dtype=’|S5’)

The comments argument

The optional argument comments is used to deﬁne a character string that marks the beginning of a comment. By

default, genfromtxt assumes comments=’#’. The comment marker may occur anywhere on the line. Any

character present after the comment marker(s) is simply ignored.

>>> data = """#

... # Skip me !

... # Skip me too !

... 1, 2

... 3, 4

... 5, 6 #This is the third line of the data

... 7, 8

... # And here comes the last line

... 9, 0

... """

>>> np.genfromtxt(StringIO(data), comments="#", delimiter=",")

14 Chapter 2. Numpy basics

NumPy User Guide, Release 1.7.0

[[ 1. 2.]

[ 3. 4.]

[ 5. 6.]

[ 7. 8.]

[ 9. 0.]]

Note: There is one notable exception to this behavior: if the optional argument names=True, the ﬁrst commented

line will be examined for names.

Skipping lines and choosing columns

The skip_header and skip_footer arguments

The presence of a header in the ﬁle can hinder data processing. In that case, we need to use the skip_header

optional argument. The values of this argument must be an integer which corresponds to the number of lines to skip

at the beginning of the ﬁle, before any other action is performed. Similarly, we can skip the last n lines of the ﬁle by

using the skip_footer attribute and giving it a value of n.

>>> data = "\n".join(str(i) for i in range(10))

>>> np.genfromtxt(StringIO(data),)

array([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])

>>> np.genfromtxt(StringIO(data),

... skip_header=3, skip_footer=5)

array([ 3., 4.])

By default, skip_header=0 and skip_footer=0, meaning that no lines are skipped.

The usecols argument

In some cases, we are not interested in all the columns of the data but only a few of them. We can select which

columns to import with the usecols argument. This argument accepts a single integer or a sequence of integers

corresponding to the indices of the columns to import. Remember that by convention, the ﬁrst column has an index of

0. Negative integers correspond to

For example, if we want to import only the ﬁrst and the last columns, we can use usecols=(0, -1):

>>> data = "1 2 3\n4 5 6"

>>> np.genfromtxt(StringIO(data), usecols=(0, -1))

array([[ 1., 3.],

[ 4., 6.]])

If the columns have names, we can also select which columns to import by giving their name to the usecols argument, either as a sequence of strings or a comma-separated string.

>>> data = "1 2 3\n4 5 6"

>>> np.genfromtxt(StringIO(data),

... names="a, b, c", usecols=("a", "c"))

array([(1.0, 3.0), (4.0, 6.0)],

dtype=[(’a’, ’<f8’), (’c’, ’<f8’)])

>>> np.genfromtxt(StringIO(data),

... names="a, b, c", usecols=("a, c"))

array([(1.0, 3.0), (4.0, 6.0)],

dtype=[(’a’, ’<f8’), (’c’, ’<f8’)])

2.3. I/O with Numpy 15

NumPy User Guide, Release 1.7.0

Choosing the data type

The main way to control how the sequences of strings we have read from the ﬁle are converted to other types is to set

the dtype argument. Acceptable values for this argument are:

• a single type, such as dtype=float. The output will be 2D with the given dtype, unless a name has been

associated with each column with the use of the names argument (see below). Note that dtype=float is the

default for genfromtxt.

• a sequence of types, such as dtype=(int, float, float).

• a comma-separated string, such as dtype="i4,f8,|S3".

• a dictionary with two keys ’names’ and ’formats’.

• a sequence of tuples (name, type), such as dtype=[(’A’, int), (’B’, float)].

• an existing numpy.dtype object.

• the special value None. In that case, the type of the columns will be determined from the data itself (see below).

In all the cases but the ﬁrst one, the output will be a 1D array with a structured dtype. This dtype has as many ﬁelds as

items in the sequence. The ﬁeld names are deﬁned with the names keyword.

When dtype=None, the type of each column is determined iteratively from its data. We start by checking whether a

string can be converted to a boolean (that is, if the string matches true or false in lower cases); then whether it can

be converted to an integer, then to a ﬂoat, then to a complex and eventually to a string. This behavior may be changed

by modifying the default mapper of the StringConverter class.

The option dtype=None is provided for convenience. However, it is signiﬁcantly slower than setting the dtype

explicitly.

Setting the names

The names argument

A natural approach when dealing with tabular data is to allocate a name to each column. A ﬁrst possibility is to use an

explicit structured dtype, as mentioned previously.

>>> data = StringIO("1 2 3\n 4 5 6")

>>> np.genfromtxt(data, dtype=[(_, int) for _ in "abc"])

array([(1, 2, 3), (4, 5, 6)],

dtype=[(’a’, ’<i8’), (’b’, ’<i8’), (’c’, ’<i8’)])

Another simpler possibility is to use the names keyword with a sequence of strings or a comma-separated string.

>>> data = StringIO("1 2 3\n 4 5 6")

>>> np.genfromtxt(data, names="A, B, C")

array([(1.0, 2.0, 3.0), (4.0, 5.0, 6.0)],

dtype=[(’A’, ’<f8’), (’B’, ’<f8’), (’C’, ’<f8’)])

In the example above, we used the fact that by default, dtype=float. By giving a sequence of names, we are

forcing the output to a structured dtype.

We may sometimes need to deﬁne the column names from the data itself. In that case, we must use the names

keyword with a value of True. The names will then be read from the ﬁrst line (after the skip_header ones), even

if the line is commented out.

16 Chapter 2. Numpy basics

剩余106页未读，继续阅读

梁啊啊_洞拐两拐

粉丝: 1
资源: 2

NumPy 1.7.0官方手册：全面指南与安装教程

Numpy用户指南.pdf

numpy-1.22.2-1.5.7-API文档-中文版.zip

numpy-1.10.1.api参考手册.chm

numpy官方帮助文档

python的numpy库手册官方文档

numpy-1.22.2-1.5.7-API文档-中英对照版.zip

echart渐变折线图

Java项目-基于微信小程序的驾校预约管理系统（包括源码，数据库，教程）.zip

毕业答辩模板极简创意几何风毕业答辩模板毕业答辩模板极简创意几何风毕业答辩模板

Python与深度学习基础作业1,利用PyQt5,以桌面GUI为载体,requests库为爬虫手段

最新资源