Python数据分析学习（二）：Numpy数组对象基础

1.1数组对象基础

 

1.初识数组对象¶

In [1]:

import numpy as np
np.__version__

Out[1]:

'1.14.0'

In [2]:

data = np.array([1,2,3,4,5])
data

Out[2]:

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

In [3]:

type(data)

Out[3]:

numpy.ndarray

In [4]:

dir(data)

Out[4]:

['T',
 '__abs__',
 '__add__',
 '__and__',
 '__array__',
 '__array_finalize__',
 '__array_interface__',
 '__array_prepare__',
 '__array_priority__',
 '__array_struct__',
 '__array_ufunc__',
 '__array_wrap__',
 '__bool__',
 '__class__',
 '__complex__',
 '__contains__',
 '__copy__',
 '__deepcopy__',
 '__delattr__',
 '__delitem__',
 '__dir__',
 '__divmod__',
 '__doc__',
 '__eq__',
 '__float__',
 '__floordiv__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__getitem__',
 '__gt__',
 '__hash__',
 '__iadd__',
 '__iand__',
 '__ifloordiv__',
 '__ilshift__',
 '__imatmul__',
 '__imod__',
 '__imul__',
 '__index__',
 '__init__',
 '__init_subclass__',
 '__int__',
 '__invert__',
 '__ior__',
 '__ipow__',
 '__irshift__',
 '__isub__',
 '__iter__',
 '__itruediv__',
 '__ixor__',
 '__le__',
 '__len__',
 '__lshift__',
 '__lt__',
 '__matmul__',
 '__mod__',
 '__mul__',
 '__ne__',
 '__neg__',
 '__new__',
 '__or__',
 '__pos__',
 '__pow__',
 '__radd__',
 '__rand__',
 '__rdivmod__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__rfloordiv__',
 '__rlshift__',
 '__rmatmul__',
 '__rmod__',
 '__rmul__',
 '__ror__',
 '__rpow__',
 '__rrshift__',
 '__rshift__',
 '__rsub__',
 '__rtruediv__',
 '__rxor__',
 '__setattr__',
 '__setitem__',
 '__setstate__',
 '__sizeof__',
 '__str__',
 '__sub__',
 '__subclasshook__',
 '__truediv__',
 '__xor__',
 'all',
 'any',
 'argmax',
 'argmin',
 'argpartition',
 'argsort',
 'astype',
 'base',
 'byteswap',
 'choose',
 'clip',
 'compress',
 'conj',
 'conjugate',
 'copy',
 'ctypes',
 'cumprod',
 'cumsum',
 'data',
 'diagonal',
 'dot',
 'dtype',
 'dump',
 'dumps',
 'fill',
 'flags',
 'flat',
 'flatten',
 'getfield',
 'imag',
 'item',
 'itemset',
 'itemsize',
 'max',
 'mean',
 'min',
 'nbytes',
 'ndim',
 'newbyteorder',
 'nonzero',
 'partition',
 'prod',
 'ptp',
 'put',
 'ravel',
 'real',
 'repeat',
 'reshape',
 'resize',
 'round',
 'searchsorted',
 'setfield',
 'setflags',
 'shape',
 'size',
 'sort',
 'squeeze',
 'std',
 'strides',
 'sum',
 'swapaxes',
 'take',
 'tobytes',
 'tofile',
 'tolist',
 'tostring',
 'trace',
 'transpose',
 'var',
 'view']

In [5]:

data?

In [6]:

# 数组元素的类型
data.dtype

Out[6]:

dtype('int64')

In [7]:

# 修改数组类型
new_data = data.astype(np.float)
new_data

Out[7]:

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

In [8]:

new_data.dtype

Out[8]:

dtype('float64')

In [9]:

data,data.dtype

Out[9]:

(array([1, 2, 3, 4, 5]), dtype('int64'))

In [10]:

# 数组的外貌
a = np.array([1,2,3])
b = np.array([1.0,2.0,3.0])
a.dtype,b.dtype

Out[10]:

(dtype('int64'), dtype('float64'))

In [11]:

a.shape

Out[11]:

(3,)

In [12]:

b.shape

Out[12]:

(3,)

In [13]:

c = np.array([1.0,2.0,3.0,4.0])
c.shape

Out[13]:

(4,)

In [14]:

# 维度
a.ndim

Out[14]:

1

In [15]:

# 返回元素个数
a.size

Out[15]:

3

In [16]:

c.size

Out[16]:

4

 

常用属性¶

• dtype:返回数组元素的类型
• shape:返回一个元组，元组中的每个整数依次对应数组的每个轴的元素个数
• size:返回数组中元素个数
• ndim:返回数组维度
• nbytes:返回保存数据的字节数

 

2.创建数组¶

In [17]:

np.array?

In [18]:

a = np.array([1,2,3,4])
b = np.array([1,2,3,4],dtype=float)

a

Out[18]:

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

In [19]:

a.dtype

Out[19]:

dtype('int64')

In [20]:

a.shape

Out[20]:

(4,)

In [21]:

a.size

Out[21]:

4

In [22]:

a.ndim

Out[22]:

1

In [23]:

b

Out[23]:

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

In [24]:

b.dtype

Out[24]:

dtype('float64')

In [25]:

# 多维数组,数组的元素类型必须一致
da = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
da

Out[25]:

array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12]])

In [26]:

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

Out[26]:

array([list([1, 2, 3]), list([4, 5, 6, 7]), list([8, 9])], dtype=object)

In [27]:

da.shape

Out[27]:

(3, 4)

In [28]:

da.size

Out[28]:

12

In [29]:

db = np.array([[1,2,3,4,5,6,7]],ndmin=2)
db

Out[29]:

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

In [30]:

db.shape

Out[30]:

(1, 7)

In [31]:

db.ndim

Out[31]:

2

In [32]:

dc = np.array([1,2,3,4,5,6,7])
dc

Out[32]:

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

In [33]:

dc.shape

Out[33]:

(7,)

In [34]:

dc.ndim

Out[34]:

1

In [35]:

a

Out[35]:

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

In [36]:

de = np.array(a,dtype=complex)
de

Out[36]:

array([1.+0.j, 2.+0.j, 3.+0.j, 4.+0.j])

In [37]:

de.dtype

Out[37]:

dtype('complex128')

In [38]:

# 用函数创建数组
np.zeros((2,10))

Out[38]:

array([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]])

In [39]:

np.zeros?

In [40]:

# zeros(shape, dtype=float, order='C')

 

同一种元素的数组

In [41]:

np.ones((6,))

Out[41]:

array([1., 1., 1., 1., 1., 1.])

In [42]:

# 一维数组才能这样写
np.ones(6)

Out[42]:

array([1., 1., 1., 1., 1., 1.])

In [43]:

da

Out[43]:

array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12]])

In [44]:

da.shape

Out[44]:

(3, 4)

In [45]:

np.ones(da.shape)

Out[45]:

array([[1., 1., 1., 1.],
       [1., 1., 1., 1.],
       [1., 1., 1., 1.]])

In [46]:

np.ones_like(da)

Out[46]:

array([[1, 1, 1, 1],
       [1, 1, 1, 1],
       [1, 1, 1, 1]])

In [47]:

np.ones_like(da,dtype=np.float)

Out[47]:

array([[1., 1., 1., 1.],
       [1., 1., 1., 1.],
       [1., 1., 1., 1.]])

In [48]:

df = 6.4 * np.ones_like(da)
df

Out[48]:

array([[6.4, 6.4, 6.4, 6.4],
       [6.4, 6.4, 6.4, 6.4],
       [6.4, 6.4, 6.4, 6.4]])

 

对角线独特的数组

• np.eye(),np.identity(),np.diag()都能创建对角线元素比较特殊而其他部分的元素为0的数组

In [49]:

np.eye(4,dtype=int)

Out[49]:

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

In [50]:

np.eye(4,dtype=int,k=1)

Out[50]:

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

In [51]:

np.eye(4,dtype=int,k=-1)

Out[51]:

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

In [52]:

np.identity(4)

Out[52]:

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

In [53]:

np.diag([1,2,3,4])

Out[53]:

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

In [54]:

np.diag([1,2,3,4],k=1)

Out[54]:

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

In [55]:

de = np.arange(16).reshape((4,4))
de

Out[55]:

array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15]])

In [56]:

np.diag(de)

Out[56]:

array([ 0,  5, 10, 15])

In [57]:

np.diag(de,k=-1)

Out[57]:

array([ 4,  9, 14])

 

元素是等差和等比的数组

In [58]:

# arange([start,] stop[, step,], dtype=None)
np.arange(1,100,3)

Out[58]:

array([ 1,  4,  7, 10, 13, 16, 19, 22, 25, 28, 31, 34, 37, 40, 43, 46, 49,
       52, 55, 58, 61, 64, 67, 70, 73, 76, 79, 82, 85, 88, 91, 94, 97])

In [59]:

np.arange?

In [60]:

# np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
np.linspace(1,10,4)

Out[60]:

array([ 1.,  4.,  7., 10.])

In [61]:

np.linspace?

In [62]:

np.logspace?

In [63]:

# np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
np.logspace(2,3,num=4)

Out[63]:

array([ 100.        ,  215.443469  ,  464.15888336, 1000.        ])

In [64]:

import math
math.log10(215.443469)

Out[64]:

2.333333333326906

In [65]:

math.log10(464.15888336)

Out[65]:

2.666666666665471

 

创建自定义类型的数组

In [66]:

my_type = np.dtype({"names":['book','version'],"formats":['S40',np.int]})
my_type

Out[66]:

dtype([('book', 'S40'), ('version', '<i8')])

In [67]:

my_books = np.array([("python",2),("java",1)],dtype=my_type)
my_books

Out[67]:

array([(b'python', 2), (b'java', 1)],
      dtype=[('book', 'S40'), ('version', '<i8')])

In [68]:

# 同my_type
my_type2 = np.dtype([('book','S40'),('version','<i8')])

In [69]:

my_books['book']

Out[69]:

array([b'python', b'java'], dtype='|S40')

In [70]:

my_books['book'][0]

Out[70]:

b'python'

In [71]:

my_books[0]

Out[71]:

(b'python', 2)

In [72]:

my_books[0]['book']

Out[72]:

b'python'

In [73]:

# 修改记录
my_books[0]['book'] = "learn python"
my_books

Out[73]:

array([(b'learn python', 2), (b'java', 1)],
      dtype=[('book', 'S40'), ('version', '<i8')])

 

• 数组一旦确定，其轴的数量就不能变化

 

用from系列函数创建数组

In [74]:

#s = 'hello world'
np.frombuffer(b'hello world',dtype='S1',count=5,offset=6)

Out[74]:

array([b'w', b'o', b'r', b'l', b'd'], dtype='|S1')

In [75]:

np.frombuffer?

In [76]:

def foo(x):
    return x + 1
np.fromfunction(foo,(5,),dtype=np.int)

Out[76]:

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

In [77]:

np.fromfunction(lambda i,j:(i+1)*(j+1),(9,9),dtype=np.int)

Out[77]:

array([[ 1,  2,  3,  4,  5,  6,  7,  8,  9],
       [ 2,  4,  6,  8, 10, 12, 14, 16, 18],
       [ 3,  6,  9, 12, 15, 18, 21, 24, 27],
       [ 4,  8, 12, 16, 20, 24, 28, 32, 36],
       [ 5, 10, 15, 20, 25, 30, 35, 40, 45],
       [ 6, 12, 18, 24, 30, 36, 42, 48, 54],
       [ 7, 14, 21, 28, 35, 42, 49, 56, 63],
       [ 8, 16, 24, 32, 40, 48, 56, 64, 72],
       [ 9, 18, 27, 36, 45, 54, 63, 72, 81]])