Fred Drake | 295da24 | 1998-08-10 19:42:37 +0000 | [diff] [blame] | 1 | \section{\module{array} --- |
Fred Drake | 4f6e4fb | 1999-04-21 16:38:53 +0000 | [diff] [blame] | 2 | Efficient arrays of numeric values} |
Fred Drake | b91e934 | 1998-07-23 17:59:49 +0000 | [diff] [blame] | 3 | |
Fred Drake | 4f6e4fb | 1999-04-21 16:38:53 +0000 | [diff] [blame] | 4 | \declaremodule{builtin}{array} |
Fred Drake | b91e934 | 1998-07-23 17:59:49 +0000 | [diff] [blame] | 5 | \modulesynopsis{Efficient arrays of uniformly typed numeric values.} |
| 6 | |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 7 | |
Martin v. Löwis | 9986633 | 2002-03-01 10:27:01 +0000 | [diff] [blame] | 8 | This module defines an object type which can efficiently represent |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 9 | an array of basic values: characters, integers, floating point |
Fred Drake | 4f6e4fb | 1999-04-21 16:38:53 +0000 | [diff] [blame] | 10 | numbers. Arrays\index{arrays} are sequence types and behave very much |
| 11 | like lists, except that the type of objects stored in them is |
| 12 | constrained. The type is specified at object creation time by using a |
| 13 | \dfn{type code}, which is a single character. The following type |
| 14 | codes are defined: |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 15 | |
Fred Drake | d5a072f | 2002-04-01 23:05:10 +0000 | [diff] [blame] | 16 | \begin{tableiv}{c|l|l|c}{code}{Type code}{C Type}{Python Type}{Minimum size in bytes} |
| 17 | \lineiv{'c'}{char} {character} {1} |
| 18 | \lineiv{'b'}{signed char} {int} {1} |
| 19 | \lineiv{'B'}{unsigned char} {int} {1} |
| 20 | \lineiv{'u'}{Py_UNICODE} {Unicode character}{2} |
| 21 | \lineiv{'h'}{signed short} {int} {2} |
| 22 | \lineiv{'H'}{unsigned short}{int} {2} |
| 23 | \lineiv{'i'}{signed int} {int} {2} |
| 24 | \lineiv{'I'}{unsigned int} {long} {2} |
| 25 | \lineiv{'l'}{signed long} {int} {4} |
| 26 | \lineiv{'L'}{unsigned long} {long} {4} |
| 27 | \lineiv{'f'}{float} {float} {4} |
| 28 | \lineiv{'d'}{double} {float} {8} |
| 29 | \end{tableiv} |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 30 | |
| 31 | The actual representation of values is determined by the machine |
Fred Drake | 4f6e4fb | 1999-04-21 16:38:53 +0000 | [diff] [blame] | 32 | architecture (strictly speaking, by the C implementation). The actual |
Fred Drake | e9e0596 | 1998-12-10 05:04:21 +0000 | [diff] [blame] | 33 | size can be accessed through the \member{itemsize} attribute. The values |
Guido van Rossum | b0b8181 | 1997-01-03 19:20:52 +0000 | [diff] [blame] | 34 | stored for \code{'L'} and \code{'I'} items will be represented as |
| 35 | Python long integers when retrieved, because Python's plain integer |
Fred Drake | 4f6e4fb | 1999-04-21 16:38:53 +0000 | [diff] [blame] | 36 | type cannot represent the full range of C's unsigned (long) integers. |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 37 | |
Guido van Rossum | ecde781 | 1995-03-28 13:35:14 +0000 | [diff] [blame] | 38 | |
Martin v. Löwis | 9986633 | 2002-03-01 10:27:01 +0000 | [diff] [blame] | 39 | The module defines the following type: |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 40 | |
Fred Drake | cce1090 | 1998-03-17 06:33:25 +0000 | [diff] [blame] | 41 | \begin{funcdesc}{array}{typecode\optional{, initializer}} |
Martin v. Löwis | 9986633 | 2002-03-01 10:27:01 +0000 | [diff] [blame] | 42 | Return a new array whose items are restricted by \var{typecode}, |
| 43 | and initialized from the optional \var{initializer} value, which |
Raymond Hettinger | 6ab78cd | 2004-08-29 07:50:43 +0000 | [diff] [blame] | 44 | must be a list, string, or iterable over elements of the |
| 45 | appropriate type. |
| 46 | \versionchanged[Formerly, only lists or strings were accepted]{2.4} |
| 47 | If given a list or string, the initializer is passed to the |
Martin v. Löwis | 9986633 | 2002-03-01 10:27:01 +0000 | [diff] [blame] | 48 | new array's \method{fromlist()}, \method{fromstring()}, or |
| 49 | \method{fromunicode()} method (see below) to add initial items to |
Raymond Hettinger | 6ab78cd | 2004-08-29 07:50:43 +0000 | [diff] [blame] | 50 | the array. Otherwise, the iterable initializer is passed to the |
| 51 | \method{extend()} method. |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 52 | \end{funcdesc} |
| 53 | |
Fred Drake | dd1f52b | 1998-04-03 03:35:24 +0000 | [diff] [blame] | 54 | \begin{datadesc}{ArrayType} |
Martin v. Löwis | 9986633 | 2002-03-01 10:27:01 +0000 | [diff] [blame] | 55 | Obsolete alias for \function{array}. |
Fred Drake | dd1f52b | 1998-04-03 03:35:24 +0000 | [diff] [blame] | 56 | \end{datadesc} |
| 57 | |
| 58 | |
Martin v. Löwis | 9986633 | 2002-03-01 10:27:01 +0000 | [diff] [blame] | 59 | Array objects support the ordinary sequence operations of |
Fred Drake | d5a072f | 2002-04-01 23:05:10 +0000 | [diff] [blame] | 60 | indexing, slicing, concatenation, and multiplication. When using |
| 61 | slice assignment, the assigned value must be an array object with the |
| 62 | same type code; in all other cases, \exception{TypeError} is raised. |
| 63 | Array objects also implement the buffer interface, and may be used |
| 64 | wherever buffer objects are supported. |
| 65 | |
| 66 | The following data items and methods are also supported: |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 67 | |
Fred Drake | dd1f52b | 1998-04-03 03:35:24 +0000 | [diff] [blame] | 68 | \begin{memberdesc}[array]{typecode} |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 69 | The typecode character used to create the array. |
Fred Drake | dd1f52b | 1998-04-03 03:35:24 +0000 | [diff] [blame] | 70 | \end{memberdesc} |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 71 | |
Fred Drake | dd1f52b | 1998-04-03 03:35:24 +0000 | [diff] [blame] | 72 | \begin{memberdesc}[array]{itemsize} |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 73 | The length in bytes of one array item in the internal representation. |
Fred Drake | dd1f52b | 1998-04-03 03:35:24 +0000 | [diff] [blame] | 74 | \end{memberdesc} |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 75 | |
Fred Drake | 8a13525 | 1998-02-27 15:19:42 +0000 | [diff] [blame] | 76 | |
Fred Drake | dd1f52b | 1998-04-03 03:35:24 +0000 | [diff] [blame] | 77 | \begin{methoddesc}[array]{append}{x} |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 78 | Append a new item with value \var{x} to the end of the array. |
Fred Drake | dd1f52b | 1998-04-03 03:35:24 +0000 | [diff] [blame] | 79 | \end{methoddesc} |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 80 | |
Fred Drake | dd1f52b | 1998-04-03 03:35:24 +0000 | [diff] [blame] | 81 | \begin{methoddesc}[array]{buffer_info}{} |
Fred Drake | bef9b0b | 1997-12-29 19:33:45 +0000 | [diff] [blame] | 82 | Return a tuple \code{(\var{address}, \var{length})} giving the current |
Fred Drake | 630a63c | 2001-08-01 16:50:49 +0000 | [diff] [blame] | 83 | memory address and the length in elements of the buffer used to hold |
| 84 | array's contents. The size of the memory buffer in bytes can be |
| 85 | computed as \code{\var{array}.buffer_info()[1] * |
| 86 | \var{array}.itemsize}. This is occasionally useful when working with |
Guido van Rossum | 8f06247 | 1997-08-14 19:50:37 +0000 | [diff] [blame] | 87 | low-level (and inherently unsafe) I/O interfaces that require memory |
Fred Drake | 630a63c | 2001-08-01 16:50:49 +0000 | [diff] [blame] | 88 | addresses, such as certain \cfunction{ioctl()} operations. The |
| 89 | returned numbers are valid as long as the array exists and no |
| 90 | length-changing operations are applied to it. |
| 91 | |
Fred Drake | 0aa811c | 2001-10-20 04:24:09 +0000 | [diff] [blame] | 92 | \note{When using array objects from code written in C or |
Fred Drake | 630a63c | 2001-08-01 16:50:49 +0000 | [diff] [blame] | 93 | \Cpp{} (the only way to effectively make use of this information), it |
| 94 | makes more sense to use the buffer interface supported by array |
| 95 | objects. This method is maintained for backward compatibility and |
| 96 | should be avoided in new code. The buffer interface is documented in |
Fred Drake | 0aa811c | 2001-10-20 04:24:09 +0000 | [diff] [blame] | 97 | the \citetitle[../api/newTypes.html]{Python/C API Reference Manual}.} |
Fred Drake | dd1f52b | 1998-04-03 03:35:24 +0000 | [diff] [blame] | 98 | \end{methoddesc} |
Guido van Rossum | 8f06247 | 1997-08-14 19:50:37 +0000 | [diff] [blame] | 99 | |
Fred Drake | 38e5d27 | 2000-04-03 20:13:55 +0000 | [diff] [blame] | 100 | \begin{methoddesc}[array]{byteswap}{} |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 101 | ``Byteswap'' all items of the array. This is only supported for |
Fred Drake | 38e5d27 | 2000-04-03 20:13:55 +0000 | [diff] [blame] | 102 | values which are 1, 2, 4, or 8 bytes in size; for other types of |
| 103 | values, \exception{RuntimeError} is raised. It is useful when reading |
| 104 | data from a file written on a machine with a different byte order. |
Fred Drake | dd1f52b | 1998-04-03 03:35:24 +0000 | [diff] [blame] | 105 | \end{methoddesc} |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 106 | |
Peter Schneider-Kamp | 5a65c2d | 2000-07-31 20:52:21 +0000 | [diff] [blame] | 107 | \begin{methoddesc}[array]{count}{x} |
Johannes Gijsbers | d345225 | 2004-09-11 16:50:06 +0000 | [diff] [blame] | 108 | Return the number of occurrences of \var{x} in the array. |
Peter Schneider-Kamp | 5a65c2d | 2000-07-31 20:52:21 +0000 | [diff] [blame] | 109 | \end{methoddesc} |
| 110 | |
Raymond Hettinger | 49f9bd1 | 2004-03-14 05:43:59 +0000 | [diff] [blame] | 111 | \begin{methoddesc}[array]{extend}{iterable} |
| 112 | Append items from \var{iterable} to the end of the array. If |
| 113 | \var{iterable} is another array, it must have \emph{exactly} the same |
| 114 | type code; if not, \exception{TypeError} will be raised. If |
| 115 | \var{iterable} is not an array, it must be iterable and its |
| 116 | elements must be the right type to be appended to the array. |
| 117 | \versionchanged[Formerly, the argument could only be another array]{2.4} |
Peter Schneider-Kamp | 5a65c2d | 2000-07-31 20:52:21 +0000 | [diff] [blame] | 118 | \end{methoddesc} |
| 119 | |
Fred Drake | dd1f52b | 1998-04-03 03:35:24 +0000 | [diff] [blame] | 120 | \begin{methoddesc}[array]{fromfile}{f, n} |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 121 | Read \var{n} items (as machine values) from the file object \var{f} |
| 122 | and append them to the end of the array. If less than \var{n} items |
Fred Drake | 8a13525 | 1998-02-27 15:19:42 +0000 | [diff] [blame] | 123 | are available, \exception{EOFError} is raised, but the items that were |
Guido van Rossum | 470be14 | 1995-03-17 16:07:09 +0000 | [diff] [blame] | 124 | available are still inserted into the array. \var{f} must be a real |
Fred Drake | dd1f52b | 1998-04-03 03:35:24 +0000 | [diff] [blame] | 125 | built-in file object; something else with a \method{read()} method won't |
Guido van Rossum | 470be14 | 1995-03-17 16:07:09 +0000 | [diff] [blame] | 126 | do. |
Fred Drake | dd1f52b | 1998-04-03 03:35:24 +0000 | [diff] [blame] | 127 | \end{methoddesc} |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 128 | |
Fred Drake | dd1f52b | 1998-04-03 03:35:24 +0000 | [diff] [blame] | 129 | \begin{methoddesc}[array]{fromlist}{list} |
Guido van Rossum | 6c4f003 | 1995-03-07 10:14:09 +0000 | [diff] [blame] | 130 | Append items from the list. This is equivalent to |
Fred Drake | 8a13525 | 1998-02-27 15:19:42 +0000 | [diff] [blame] | 131 | \samp{for x in \var{list}:\ a.append(x)} |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 132 | except that if there is a type error, the array is unchanged. |
Fred Drake | dd1f52b | 1998-04-03 03:35:24 +0000 | [diff] [blame] | 133 | \end{methoddesc} |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 134 | |
Fred Drake | dd1f52b | 1998-04-03 03:35:24 +0000 | [diff] [blame] | 135 | \begin{methoddesc}[array]{fromstring}{s} |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 136 | Appends items from the string, interpreting the string as an |
Fred Drake | 91f2f26 | 2001-07-06 19:28:48 +0000 | [diff] [blame] | 137 | array of machine values (as if it had been read from a |
Fred Drake | 8a13525 | 1998-02-27 15:19:42 +0000 | [diff] [blame] | 138 | file using the \method{fromfile()} method). |
Fred Drake | dd1f52b | 1998-04-03 03:35:24 +0000 | [diff] [blame] | 139 | \end{methoddesc} |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 140 | |
Martin v. Löwis | 9986633 | 2002-03-01 10:27:01 +0000 | [diff] [blame] | 141 | \begin{methoddesc}[array]{fromunicode}{s} |
| 142 | Extends this array with data from the given unicode string. |
| 143 | The array must be a type 'u' array; otherwise a ValueError |
| 144 | is raised. Use \samp{array.fromstring(ustr.decode(enc))} to |
| 145 | append Unicode data to an array of some other type. |
| 146 | \end{methoddesc} |
| 147 | |
Peter Schneider-Kamp | 5a65c2d | 2000-07-31 20:52:21 +0000 | [diff] [blame] | 148 | \begin{methoddesc}[array]{index}{x} |
| 149 | Return the smallest \var{i} such that \var{i} is the index of |
Johannes Gijsbers | d345225 | 2004-09-11 16:50:06 +0000 | [diff] [blame] | 150 | the first occurrence of \var{x} in the array. |
Peter Schneider-Kamp | 5a65c2d | 2000-07-31 20:52:21 +0000 | [diff] [blame] | 151 | \end{methoddesc} |
| 152 | |
Fred Drake | dd1f52b | 1998-04-03 03:35:24 +0000 | [diff] [blame] | 153 | \begin{methoddesc}[array]{insert}{i, x} |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 154 | Insert a new item with value \var{x} in the array before position |
Walter Dörwald | 9e46abe | 2003-05-18 03:15:10 +0000 | [diff] [blame] | 155 | \var{i}. Negative values are treated as being relative to the end |
| 156 | of the array. |
Fred Drake | dd1f52b | 1998-04-03 03:35:24 +0000 | [diff] [blame] | 157 | \end{methoddesc} |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 158 | |
Peter Schneider-Kamp | 5a65c2d | 2000-07-31 20:52:21 +0000 | [diff] [blame] | 159 | \begin{methoddesc}[array]{pop}{\optional{i}} |
| 160 | Removes the item with the index \var{i} from the array and returns |
| 161 | it. The optional argument defaults to \code{-1}, so that by default |
Martin v. Löwis | 9986633 | 2002-03-01 10:27:01 +0000 | [diff] [blame] | 162 | the last item is removed and returned. |
Peter Schneider-Kamp | 5a65c2d | 2000-07-31 20:52:21 +0000 | [diff] [blame] | 163 | \end{methoddesc} |
| 164 | |
Fred Drake | dd1f52b | 1998-04-03 03:35:24 +0000 | [diff] [blame] | 165 | \begin{methoddesc}[array]{read}{f, n} |
Fred Drake | 92e3194 | 1998-02-27 16:21:31 +0000 | [diff] [blame] | 166 | \deprecated {1.5.1} |
| 167 | {Use the \method{fromfile()} method.} |
Fred Drake | 8a13525 | 1998-02-27 15:19:42 +0000 | [diff] [blame] | 168 | Read \var{n} items (as machine values) from the file object \var{f} |
| 169 | and append them to the end of the array. If less than \var{n} items |
| 170 | are available, \exception{EOFError} is raised, but the items that were |
| 171 | available are still inserted into the array. \var{f} must be a real |
| 172 | built-in file object; something else with a \method{read()} method won't |
| 173 | do. |
Fred Drake | dd1f52b | 1998-04-03 03:35:24 +0000 | [diff] [blame] | 174 | \end{methoddesc} |
Fred Drake | 8a13525 | 1998-02-27 15:19:42 +0000 | [diff] [blame] | 175 | |
Peter Schneider-Kamp | 5a65c2d | 2000-07-31 20:52:21 +0000 | [diff] [blame] | 176 | \begin{methoddesc}[array]{remove}{x} |
Johannes Gijsbers | d345225 | 2004-09-11 16:50:06 +0000 | [diff] [blame] | 177 | Remove the first occurrence of \var{x} from the array. |
Peter Schneider-Kamp | 5a65c2d | 2000-07-31 20:52:21 +0000 | [diff] [blame] | 178 | \end{methoddesc} |
| 179 | |
Fred Drake | dd1f52b | 1998-04-03 03:35:24 +0000 | [diff] [blame] | 180 | \begin{methoddesc}[array]{reverse}{} |
Fred Drake | 8a13525 | 1998-02-27 15:19:42 +0000 | [diff] [blame] | 181 | Reverse the order of the items in the array. |
Fred Drake | dd1f52b | 1998-04-03 03:35:24 +0000 | [diff] [blame] | 182 | \end{methoddesc} |
Fred Drake | 8a13525 | 1998-02-27 15:19:42 +0000 | [diff] [blame] | 183 | |
Fred Drake | dd1f52b | 1998-04-03 03:35:24 +0000 | [diff] [blame] | 184 | \begin{methoddesc}[array]{tofile}{f} |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 185 | Write all items (as machine values) to the file object \var{f}. |
Fred Drake | dd1f52b | 1998-04-03 03:35:24 +0000 | [diff] [blame] | 186 | \end{methoddesc} |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 187 | |
Fred Drake | dd1f52b | 1998-04-03 03:35:24 +0000 | [diff] [blame] | 188 | \begin{methoddesc}[array]{tolist}{} |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 189 | Convert the array to an ordinary list with the same items. |
Fred Drake | dd1f52b | 1998-04-03 03:35:24 +0000 | [diff] [blame] | 190 | \end{methoddesc} |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 191 | |
Fred Drake | dd1f52b | 1998-04-03 03:35:24 +0000 | [diff] [blame] | 192 | \begin{methoddesc}[array]{tostring}{} |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 193 | Convert the array to an array of machine values and return the |
| 194 | string representation (the same sequence of bytes that would |
Fred Drake | 8a13525 | 1998-02-27 15:19:42 +0000 | [diff] [blame] | 195 | be written to a file by the \method{tofile()} method.) |
Fred Drake | dd1f52b | 1998-04-03 03:35:24 +0000 | [diff] [blame] | 196 | \end{methoddesc} |
Fred Drake | 8a13525 | 1998-02-27 15:19:42 +0000 | [diff] [blame] | 197 | |
Martin v. Löwis | 9986633 | 2002-03-01 10:27:01 +0000 | [diff] [blame] | 198 | \begin{methoddesc}[array]{tounicode}{} |
| 199 | Convert the array to a unicode string. The array must be |
| 200 | a type 'u' array; otherwise a ValueError is raised. Use |
| 201 | array.tostring().decode(enc) to obtain a unicode string |
| 202 | from an array of some other type. |
| 203 | \end{methoddesc} |
| 204 | |
Fred Drake | dd1f52b | 1998-04-03 03:35:24 +0000 | [diff] [blame] | 205 | \begin{methoddesc}[array]{write}{f} |
Fred Drake | 92e3194 | 1998-02-27 16:21:31 +0000 | [diff] [blame] | 206 | \deprecated {1.5.1} |
| 207 | {Use the \method{tofile()} method.} |
Fred Drake | 8a13525 | 1998-02-27 15:19:42 +0000 | [diff] [blame] | 208 | Write all items (as machine values) to the file object \var{f}. |
Fred Drake | dd1f52b | 1998-04-03 03:35:24 +0000 | [diff] [blame] | 209 | \end{methoddesc} |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 210 | |
| 211 | When an array object is printed or converted to a string, it is |
| 212 | represented as \code{array(\var{typecode}, \var{initializer})}. The |
| 213 | \var{initializer} is omitted if the array is empty, otherwise it is a |
| 214 | string if the \var{typecode} is \code{'c'}, otherwise it is a list of |
| 215 | numbers. The string is guaranteed to be able to be converted back to |
| 216 | an array with the same type and value using reverse quotes |
Fred Drake | 38e5d27 | 2000-04-03 20:13:55 +0000 | [diff] [blame] | 217 | (\code{``}), so long as the \function{array()} function has been |
Fred Drake | 630a63c | 2001-08-01 16:50:49 +0000 | [diff] [blame] | 218 | imported using \code{from array import array}. Examples: |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 219 | |
Fred Drake | 1947991 | 1998-02-13 06:58:54 +0000 | [diff] [blame] | 220 | \begin{verbatim} |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 221 | array('l') |
| 222 | array('c', 'hello world') |
Martin v. Löwis | 9986633 | 2002-03-01 10:27:01 +0000 | [diff] [blame] | 223 | array('u', u'hello \textbackslash u2641') |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 224 | array('l', [1, 2, 3, 4, 5]) |
| 225 | array('d', [1.0, 2.0, 3.14]) |
Fred Drake | 1947991 | 1998-02-13 06:58:54 +0000 | [diff] [blame] | 226 | \end{verbatim} |
Fred Drake | dd1f52b | 1998-04-03 03:35:24 +0000 | [diff] [blame] | 227 | |
| 228 | |
| 229 | \begin{seealso} |
Fred Drake | ba0a989 | 2000-10-18 17:43:06 +0000 | [diff] [blame] | 230 | \seemodule{struct}{Packing and unpacking of heterogeneous binary data.} |
| 231 | \seemodule{xdrlib}{Packing and unpacking of External Data |
| 232 | Representation (XDR) data as used in some remote |
| 233 | procedure call systems.} |
Neal Norwitz | ce5df49 | 2002-04-04 14:02:45 +0000 | [diff] [blame] | 234 | \seetitle[http://numpy.sourceforge.net/numdoc/HTML/numdoc.htm]{The |
Fred Drake | b4b401e | 2000-10-17 04:58:01 +0000 | [diff] [blame] | 235 | Numerical Python Manual}{The Numeric Python extension |
| 236 | (NumPy) defines another array type; see |
| 237 | \url{http://numpy.sourceforge.net/} for further information |
Fred Drake | ed911b8 | 2000-12-11 20:57:13 +0000 | [diff] [blame] | 238 | about Numerical Python. (A PDF version of the NumPy manual |
| 239 | is available at |
Raymond Hettinger | 52136a8 | 2003-05-10 03:35:37 +0000 | [diff] [blame] | 240 | \url{http://numpy.sourceforge.net/numdoc/numdoc.pdf}).} |
Fred Drake | dd1f52b | 1998-04-03 03:35:24 +0000 | [diff] [blame] | 241 | \end{seealso} |