A vector
Vector refers to a bunch number set formed
Multi-dimensional arrays, called Vector computing
Single number called a scalar
Two multi-dimensional arrays
- numpy definition of a multidimensional array:
With numpy.ndarray type (n representative of the number n, d Representative dimision dimension)
Ndarray itself is a class of this class is instantiated objects out, a multidimensional array is
Multidimensional array is an object
Create a multidimensional array object:
1> numpy.arange (start, end, step)
He is accessed through numpy. Is a function in numpy
It returns an array is an arithmetic sequence of one-dimensional arrays
2> numpy.array()
The array is not a class, is a function in numpy
In () parentheses numpy.array function, the input may be interpreted as any array container (or a list of tuples)
3> a method of obtaining the array element type:
d = np.array([[1,2,3],[4,5,6]]) 方法一: type(d[0][0]) #==>python取类型的方法 方法二: d.dtype #==> numpy 取类型的方法
4> int 32 represent four-byte integer
Why is int32?
Particular type is not specified in the definition, and now uses 4 bytes plastic just to save data d,
Therefore default value is 4 bytes default ..
Meaning 5> <U1 of
g=np.array(['1','2','3']) print(g.dtype) # <U1 print(type(g[0])) #<class 'numpy.str_'>
- Unicode encoding each four bytes. By the high and low points. Into the little-endian and big-endian
- 'U' is representative of unicode encoding
- '<' Indicates little-endian
- '1' represents only one character in each string
6> 'numpy.str_' meaning
- str represents a string
- _ And python string as distinguished
7> manually specify the type of the wording
G=np.array(['1','2','3'],dtype=np.int32) print(G.dtype) #int32 H=G.astype(np.str_) print(H.dtype) #<U11
- 'As long as the manual setting of the specified type, the type of data to do it automatically converted. While the value is a string, but we are targeting Type Int32 plastic, so it is of type int 32'
- Scene: To change back to string format, with astype function
- <U11 explanation: when the type is changed back again, back to reserve some space in memory,
Note: All types of conversion and are not actually related to the type of conversion are copied, and then press the new type of copy, however, it is a constant source
dtype attribute is used to take the type of element
8> attribute on a dimension
d = np.array([[1,2,3],[4,5,6]])
print(d.shape) #(2, 3) 2行 3列
- shape attributes:
Shape attribute value is a tuple type, comprising a plurality of elements within a tuple, respectively, from high to low to indicate the number of each dimension .. latitude i.e. high to low latitudes
If you have page ranks
Page: Maximum dimensions
Line: second place
Column: Minimum
9> arrange and array can create an array, you can sometimes mixed with
i = np.array([[np.arange(1,5),np.arange(5,9),np.arange(9,13)],[np.arange(13,17),np.arange(17,21),np.arange(21,25)]])
print(i)
# [[[ 1 2 3 4]
# [ 5 6 7 8]
# [ 9 10 11 12]]
#
# [[13 14 15 16]
# [17 18 19 20]
# [21 22 23 24]]]
We can see the dimension with the shape attributes
Numpy in multi-dimensional arrays, three-dimensional rarely used
10> element index
元素索引是从 0 开始的
数组[索引]
数组[行索引][列索引]
数组[页索引][行索引][列索引]
a=np.array([[[ 1 ,2 , 3 ,4], [ 5 ,6 , 7 , 8], [ 9 ,10 ,11 ,12]]])
print(a[0]) #[[ 1 ,2 , 3 ,4], [ 5 ,6 , 7 , 8], [ 9 ,10 ,11 ,12]]
print(a[0][0]) # [1 2 3 4]
print(a[0][0][0]) # 1
for i in range(a.shape[0]): # 0 是逐页
for j in range(a.shape[1]): # 1 是逐行
for k in range(a.shape[2]): # 2 是逐列
print(a[i][j][k])
Numpy three built-in types and custom types
Built-in type
a) Pros:
You can specify how much memory occupied by data type
can be flexible and change
b) Disadvantages:
Because the flexible variability, so at the expense of performance, (need to leave enough space)
can not use a fixed memory address calculation method can only be done dynamically, since the operation of the address would be spent running time
Note: providing a fixed size for each type numpy, the calculation of the address can therefore be determined by the type defined numpy own independent set of data types with a data type system .. fixed length, the number of bytes is fixed ..
Example: Numpy.bool a Boolean one byte
signed version (positive and negative numbers):
Int8 signed 1 byte type
Int16 2-byte signed type
Int32 4-byte signed type
unsigned version (only positive):
Uint8 1 byte unsigned
Uint16 2 byte unsigned type
Uint32 4 byte unsigned type
float type:
float16 2-byte floating-point signed
Float32 signed 4-byte floating-point
Float64 8-byte floating-point signed
type complex (real and imaginary Portions are represented by two 4-byte floating point):
complex64. 8-byte type complex
Complex128 16 bytes complex types
Note: 1 = a plurality of combinations of two floating-point
string type:
Str_ string is not a predetermined number of bytes, because the length of the string depending on the type of string of unicode
string length based on the character string contains decision
NOTE: lunicode = 4 bytes
can be set dtype type conversion and astypeCustom Types
Direct use of the original name of the built-in type
Format using the compact type (encoded string type)
simplifies the operation: string can be represented with fewer
Full name Simplified format Numpy.int8 i1 Int16 i2 Uint32 U4 Float64 F8 Complex128 Cl6 Multi-byte integers endian size of
multi-byte integers can add a prefix byte order
prefix type:
'<' low-bit little-endian lower address
'=' default, not artificially designated
'>' big endian low tree bits of addressNote: To prevent compatibility problems sometimes due to a function of the code on different processors transplant brought forcibly added so '<' and '>'
import numpy as np a=np.array([('ABC',[1,2,3])],dtype={'names':['name','scores'],'formats':['U3','3i4']}) print(a) #[('ABC', [1, 2, 3])] print(a[0]['name']) #ABC print(a[0]['scores'][0]) #1 print(a[0]['scores'][1]) #2 print(a[0]['scores'][2]) #3
b = np.array ([0x1234], dtype = ( 'u2', { 'low bit' :( 'u1', 0), 'high number of bits' :( 'u1', 1)})) #
print ( '{: x}' format (b [0]).) # B hexadecimal output element in the No. 0
print ( '{: x}, {: x}'. Format (b [ 'low order bits'] [0], b [ ' high digit'] [0]))
`
About byte order:
Without adding endian data types: one-byte integer, Boolean, complex types, floating point
Other cases: Numpy.str_ => U + number of characters
Unicode itself is multi-byte integers, a can be regarded as a unicode UInt32, there is also the size of the endian
Numpy.bool => b
Note: numpy python package is provided, a method of using custom type element may be a complete different types of access; or an element with a different type to be combined to make up the array elements where numpy homogeneous ..
Four sections
And similar python
Array [Start: End: step]
You can slice for multidimensional arrays
Default start: the first element (in steps of n), the last element (negative step) -> Reverse
Default termination: tail (positive steps), the first former (negative steps)
Default Step: 1
a = np.arange(1,10)
print(a) #[1 2 3 4 5 6 7 8 9]
print(a[:3]) #[1 2 3]
print(a[3:6]) #[4 5 6]
print(a[6:]) #[7 8 9]
print(a[:-4:-1]) #[9 8 7]
print(a[...]) #[1 2 3 4 5 6 7 8 9]
print(a[:]) #[1 2 3 4 5 6 7 8 9]
print(a[1::3]) #[2 5 8]
b=np.arange(1,25).reshape(2,3,4)
print(b)
# print(b[:,0,0]) # [ 1 13]
# print(b[0,:,:])
# print(b[0,1,::2]) #[5 7]
# print(b[-1,1:,2:])
# print(b[:,1:,1])
print(b[1,1,::2]) #[17 19]
One or more defaults sections:
a[...] a[ : ]
Five dimensions of change
It divided 4 ways
View Variable Dimension:
Get different dimensions for an array object view
Method: Array .reshape (New Dimension) -> Array view New Dimension
Array .ravel () -> one-dimensional array of view
import numpy as np a=np.array([np.arange(1,9)]) print(a) #[[1 2 3 4 5 6 7 8]] b=a.reshape(2,4) print(b) #[[1 2 3 4] [5 6 7 8]] c=b.ravel() print(c) #[1 2 3 4 5 6 7 8]
Copy the variance dimension (different dimensions of copies):
get different dimensions for a copy of the array object
method: flatten () -> that copy of the array of
functions: to obtain a copy of the original data while gaining an example, which is a copyd=b.flatten() print(d) #[1 2 3 4 5 6 7 8] 复制成一维 e=b.reshape(2,2,2).copy() print(e)
Situ variable dimension
array. Shape = (new dimension)
equivalent to the
array. Resize (New Dimension)a=np.array([np.arange(1,9)]) a.shape = (2,2,2) # a.resize =(2,2,2) print(a) #变成一个新的2页2行2列的三维数组
View transpose (the concept of linear algebra)
understood as interchanging rows
array transpose () -.> View transposed array
equivalent toArray T -.> Transpose View Properties
a=np.array([np.arange(1,9)]) a.shape = (4,2) #a是4行2列 g = a.transpose() print(g) # [[1 3 5 7] # [2 4 6 8]] print(np.array([a]).T) #先转成多维数组,再转置 print(a.reshape(-1,1)) # -1 无效值
Note: The device must be two-dimensional array can
Six and a combination of split
- Vertical composition:
numpy.vstack ((vertically)) the stack
- Vertical Split:
numpy.vsplit (array, the number of copies)
列: a,b=np.vsplit( c , 2 )
C is a variable representative of the split is split into 2 represents 2 parts
import numpy as np a=np.arange(11,20).reshape(3,3) print(a) b=np.arange(21,30).reshape(3,3) print(b) c=np.vstack((a,b)) print(c) l,h=np.vsplit(c,2) print(l,h,sep='\n') #把c 拆分成 l 和 h 两个
- Level combinations:
numpy.hstack ((left)) stack
- Split level:
numpy.hsplit (array, the number of copies)
列: a,b=np.vsplit( c , 2 )
C is a variable representative of the split is split into 2 represents 2 parts
import numpy as np a=np.arange(11,20).reshape(3,3) print(a) b=np.arange(21,30).reshape(3,3) print(b) c=np.hstack((a,b)) print(c) l,h=np.hsplit(c,2) print(l,h,sep='\n')
A combination of depth and depth resolution
numpy.dstack ((front and rear)) stack
numpy.dsplit (array, the number of copies)
c=np.dstack((a,b)) print(c) l,h=np.dsplit(c,2) print(l,h,sep='\n')
Depth combinations:
- Before and layout, to the plane of the line to cut, to cut this part are combined to form an array with a third vertical, constituting a three-digit group
- These three sections is three pages, each page has a two-dimensional array from the corresponding row, also made transposed, to cut the rows into columns
Depth Split:
a, b = np.dsplit( c , 2)
-
print (aT [0]. T, bT [0]. T, sep = '\ n') #T [0]. T transposition takes No. 0 sub-set of elements
NOTE: To return to the depth resolution two-dimensional array pattern, to be hand operated
Row / column combination
Features: Only the combination can not be split
numpy.row_stack ((vertical)) is equivalent to numpy.vstack
numpy.column_stack ((approximately)) is equivalent to numpy.hstack
numpy.column_stack ((approximately)) shorthand np.c_ [about]
Review ndarray seven properties
- dtype element type
- shape array dimensions
- T transpose view
- ndim number of dimensions
- size number of elements. equivalent to a one-dimensional array of python len ()
- Total number of bytes npytes element
- len () will never get in shape first element *** size ** get is in the shape of the product
- itemize the number of bytes element that is an element accounted for how many bytes
- flat flat obtained iterator is an iterator object may be iterating
- tolist array change list
- imag imaginary part of the array
- real real part of the array
***** numpy
There append function method, but must have a return value
import numpy as np
a=np.array([
[1+1j,2+4j,3+6j],
[1+1j,2+4j,3+6j],
[1+1j,2+4j,3+6j]
])
print(a.dtype) #complex128 16个字节 8位是实部 8位是虚部
print(a.shape) #3行3列
print(a.ndim) #2维
print(a.size,len(a)) # 9个元素 3 列
print(a.itemsize) # 每个元素占16个字节
print(a.nbytes) # 144个字节 16* 9
print(a.T)
print(a.real,a.imag,sep='\n') # 取实部和虚部
for i in a.flat: #flat 扁平迭代器
print(i)
# ----------------------------------------------------------
#列 :
def fun(z,zz):
z.append(zz)
return z
x=np.array([1,2,3])
y=40
# x=fun(x,y) #会报错 因为数组没有append方法
x=fun(x.tolist(),y)
print(x) #[1, 2, 3, 40]
y=np.append(x,50)
print(y) #[ 1 2 3 40 50]