从零基础学数据分析-Day01

Numpy的基本使用

Numpy的核心 -- 多维数组

1.代码更简洁，底层用c语言编写，性能更块

Numpy基础

import numpy as np


# np.ndarray
ary = np.array([1,2,3,4])
print(type(ary))                #<class 'numpy.ndarray'>

# np.arrange(起始值,终止值,步长值)
ary = np.arange(1,5)
print(ary)                      #[1 2 3 4]
ary01 = np.arange(0,6,2)
print(ary01)                    #[0 2 4]

# np.zeros
ary = np.zeros(5)
print(ary)                      #[0. 0. 0. 0. 0.]

# np.ones
ary = np.ones(5)
print(ary)                      #[1. 1. 1. 1. 1.]

# 操作ndarray对象属性的基本操作

# np.ndarray.shape 维度
ary = np.array([1,2,3,4,5,6])
print(ary.shape)                #(6,)

ary = np.array([
    [1,2,3],
    [4,5,6],
])
print(ary.shape)                #(2, 3)

#元素类型 np.ndarray.dtype
ary = np.array([1,2,3,4])
print(ary.dtype)                #int64/int32

ary1 = ary.astype(float)
print(ary1.dtype)               #float64/float32

# 数组元素个数 np.ndarray.size
ary = np.array([
    [1,2,3],
    [4,5,6]
])
print(ary.size)                 # 6 个数
print(len(ary))                 # 2 长度

# 数组下标与列表下标类似
ary = np.arange(1,28)
ary.shape = (3,3,3)
print(ary)                                  
"""
[[[ 1  2  3]
  [ 4  5  6]
  [ 7  8  9]]

 [[10 11 12]
  [13 14 15]
  [16 17 18]]

 [[19 20 21]
  [22 23 24]
  [25 26 27]]]
"""


for i in range(len(ary)):                    
    for j in range(len(ary[0])):            
        for c in range(len(ary[0][0])):         
            print(ary[i,j,c],end=" ")
        print()
    print()
"""
1 2 3 
4 5 6
7 8 9

10 11 12
13 14 15 
16 17 18

19 20 21 
22 23 24 
25 26 27     
"""
    

Numpy的内部基本类型

类型名	类型表示符
布尔型	bool
有符号整数型	int(-128-127)/int16/int32/int64
无符号整数型	uint(-128-127)/uint16/uint32/uint64
浮点型	float16/float/32/float64
复数型	complex64/complex128
字串型	str 每个字符串用32位Unicode编码表示

自定义复合类型

import numpy as np


# 自定义类型

data = [
    ('zs',[90,80,85],15),
    ('ls',[92,81,83],16),
    ('ww123',[95,85,95],15),
]
ary = np.array(data)
print(ary)
"""
    自动将类型转化为np的数据复合类型
[['zs' list([90, 80, 85]) 15]
 ['ls' list([92, 81, 83]) 16]
 ['ww123' list([95, 85, 95]) 15]]
"""

# 复合数据类型
ary = np.array(data,dtype='U2,3int32,int32')  #指数出data的数据类型
print(ary)
print(ary[1][2])                              # 可读写差

"""
[('zs', [90, 80, 85], 15) 
 ('ls', [92, 81, 83], 16)
 ('ww', [95, 85, 95], 15)]                    #ww123中132被抹去了,因为定义数据类型为'U2'
16                                            #拿的是第二个元组里面的第三个位置的数及16
"""

# 第二种方式为dtype的方式设置别名
ary = np.array(data,dtype=[('name','str_',2),
                           ('score','int32',3),
                           ('age','int32',1),
                           ])
print(ary)
print(ary[2]['name'],ary[0]['age'])
"""
[('zs', [90, 80, 85], 15)
 ('ls', [92, 81, 83], 16)
 ('ww', [95, 85, 95], 15)]
ww  15                                         # 拿第二个人的名字,第一个人的名字
"""

# 第三种方式设置dtype的方式
ary = np.array(data,dtype={
    'names':['name','score','age'],
    'formats':['U2','3int32','int32'],
})
print(ary)                                      # 打印所有
print(ary[2]['name'],ary[1]['score'])           # 拿第二个人的名字，第一个人的成绩
print(ary['name'])                              # 拿所有名字
"""
[('zs', [90, 80, 85], 15) 
 ('ls', [92, 81, 83], 16)
 ('ww', [95, 85, 95], 15)] 
 ww [92 81 83]
 ['zs' 'ls' 'ww']

"""

# 日期类型数组
time = np.array(['2011','2012-01-01','2013-01-01 01:01:01','2011-02-01'])
print(time)
print(time.dtype)
"""
['2011' '2012-01-01' '2013-01-01 01:01:01' '2011-02-01']
<U19
"""
# 转日期
times = time.astype('datetime64[D]')     # 可自动精确到天
times01 = time.astype('datetime64[s]')     # 可自动精确到秒
print(times)
print(times.dtype)
print(times01)
"""
['2011-01-01' '2012-01-01' '2013-01-01' '2011-02-01']
datetime64[D]
['2011-01-01T00:00:00' '2012-01-01T00:00:00' '2013-01-01T01:01:01' '2011-02-01T00:00:00']
"""

字符类型码

类型	字符码
np.bool_	?
np.int8/16/32/64	i1/i2/i4/i8
np.uint8/16/32/64	u1/u2/u4/u8
np.float/16/32/64	f2/f4/f8
np.complex64/128	c8/c16
np.str_	u<字符数>
np.datetime64	M8[Y] M8[M] M8[D] M8[h] M8[m] M8[S]

 

 

 

 

 

 

 

 

 

类型字符码格式

3id	释义
3i4	大端字节序，3个元素的一维数组，每个元素都是整型，每个整型元素占4个字节
<(2,3)u8	小端字节序，6个元素2行3列的二维数组，每个元素都是无符号整型，每个无符号整型元素占8个字节。
U7	包含7个字符的Unicode字符串，每个字符占4个字节，采用默认字节序。

ndarray数组对象的维度操作

import numpy as np

# 视图变维

a = np.arange(1,9)
print(a)                    # [1 2 3 4 5 6 7 8]

b = a.reshape(2,4)          # 视图变维 变为2行4列的二维数组
print(b)
"""
[[1 2 3 4]
 [5 6 7 8]]
"""

c = b.reshape(2,2,2)         # 视图变维 变为2行2列的三维数组
print(c)
"""
[[[1 2]
  [3 4]]

 [[5 6]
  [7 8]]]
"""

d = c.ravel()               # 变维一维数组
print(d)                    # [1,2,3,4,5,6,7,8]

# 复制变维(数据独立)
e = c.flatten()             #复制变维
print(e)                    # [1 2 3 4 5 6 7 8]
a += 10
print(a)                    # [11 12 13 14 15 16 17 18]
print(e)                    # [1 2 3 4 5 6 7 8]

# 就地变维:直接改变原数组的维度，不返回新数组

a.shape = (2,4)             # 变维2行思列的二维数组
print(a)
"""
[[11 12 13 14]
 [15 16 17 18]]
"""

a.resize(2,2,2)             # 变维2行2列的三维数组
print(a)
"""
[[[11 12]
  [13 14]]

 [[15 16]
  [17 18]]]
"""


# 一维数组的切片操作
a = np.arange(1,10)        # 切片操作与列表操作是一样的
print(a[:3])               # [1 2 3]

# 多维数组的切片
a = np.arange(1,28)
a.resize(3,3,3)
print(a)                    # 打印所有数据
print(a[1,:,:])             # 切出第一页
print(a[:,1,:])             # 切出所有页的第一行
print(a[0,:,1])             # 切出0页的1行1列
# print(a[::2,::2])
"""
[[[ 1  2  3]
  [ 4  5  6]
  [ 7  8  9]]

 [[10 11 12]
  [13 14 15]
  [16 17 18]]

 [[19 20 21]
  [22 23 24]
  [25 26 27]]]
  # 切出所有一页
  [[10 11 12]
 [13 14 15]
 [16 17 18]]
 # 切出所有页的第一行
 [[ 4  5  6]
 [13 14 15]
 [22 23 24]]
 # 切出0页的1行1列
 [2 5 8]
"""

掩码的基本操作

import numpy as np

# ndarray数组的掩码操作

a = np.arange(1,10)
print(a)                    # [1 2 3 4 5 6 7 8 9]
mask = [True,False,True,False,True,False,True,False,True]
print(a[mask])              # [1 3 5 7 9]


# 输出100以内的3的倍数
a = np.arange(100)
print(a[(a%3==0)&(a%7==0)]) # [ 0 21 42 63 84]

# 索引掩码
a = np.array([10,78,456,12,54,56,85,69,12,56,87,45])
mask = [3,6,9,7,1]          # 按位置拿数据
print(a[mask])              #[12 85 56 69 78]

 

多维数组的组合与拆分

import numpy as np
a = np.arange(1,7).reshape(2,3)    # 初始化两个数组
b = np.arange(7,13).reshape(2,3)
print(a)
print(b)
"""
[[1 2 3]
 [4 5 6]]
 
[[ 7  8  9]
 [10 11 12]]
"""
c = np.vstack((a,b))       # 合并两个数组垂直方向
print(c)
"""
[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]
"""
a,b = np.vsplit(c,2)            # 垂直方向拆分
print(a)
print(b)
"""
[[1 2 3]
 [4 5 6]]
[[ 7  8  9]
 [10 11 12]]
"""

# 水平方向
c = np.hstack((a,b))       # 水平方向合并
print(c)
"""
[[ 1  2  3  7  8  9]
 [ 4  5  6 10 11 12]]
"""
a,b = np.hsplit(c,2)       # 水平拆分
print(a)
print(b)
"""
[[1 2 3]
 [4 5 6]]
[[ 7  8  9]
 [10 11 12]]

"""


# 深度拆分
c = np.dstack((a,b))       # 深度合并
print(c)
"""
[[[ 1  7]
  [ 2  8]
  [ 3  9]]
  
   [[ 4 10]
  [ 5 11]
  [ 6 12]]]
"""
a,b = np.dsplit(c,2)       # 深度拆分
print(a)
print(b)
"""
[[[1]
  [2]
  [3]]

 [[4]
  [5]
  [6]]]
[[[ 7]
  [ 8]
  [ 9]]

 [[10]
  [11]
  [12]]]
"""

# 简单一维数组的组合方案
a = np.arange(1,9)
b = np.arange(11,19)
c = np.row_stack((a,b))# 合并行        #[[ 1  2  3  4  5  6  7  8]
print(c)                              #[11 12 13 14 15 16 17 18]]

print(c[:,:3])                        #[[ 1  2  3]
                                      #[11 12 13]]
c = np.column_stack((a,b))             # 合并列
print(c)
print(c[:,0])
print(c[:,:1])
"""
[[ 1 11]
 [ 2 12]
 [ 3 13]
 [ 4 14]
 [ 5 15]
 [ 6 16]
 [ 7 17]
 [ 8 18]]
"""

 ndarray类的其他属性

import numpy as np

a = np.array([[1+1j,2+4j,3+7j],
              [4+2j,5+5j,6+8j],
              [7+3j,8+6j,9+9j]])
print(a.shape)
print(a.dtype)
print(a.itemsize)
print(a.nbytes)
print(a.real)
print(a.imag)
print(a.T)
print([x for x in a.flat])
"""
(3, 3)
complex128
16
144
[[1. 2. 3.]
 [4. 5. 6.]
 [7. 8. 9.]]
[[1. 4. 7.]
 [2. 5. 8.]
 [3. 6. 9.]]
[[1.+1.j 4.+2.j 7.+3.j]
 [2.+4.j 5.+5.j 8.+6.j]
 [3.+7.j 6.+8.j 9.+9.j]]
 [(1+1j), (2+4j), (3+7j), (4+2j), (5+5j), (6+8j), (7+3j), (8+6j), (9+9j)]
"""