数据分析2.Numpy

最新推荐文章于 2024-09-02 23:19:32 发布
最新推荐文章于 2024-09-02 23:19:32 发布
阅读量161 收藏
点赞数 3
文章标签： 数据分析 numpy 数据挖掘
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74044320/article/details/136631467
版权 
import numpy as np

score = np.array([[80, 89, 86, 67, 79],
                  [80, 89, 86, 67, 79],
                  [80, 89, 86, 67, 79],
                  [80, 89, 86, 67, 79],
                  [80, 89, 86, 67, 79],
                  [80, 89, 86, 67, 79],
                  [80, 89, 86, 67, 79],
                  [80, 89, 86, 67, 79]])

score

array([[80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79]])

type(score)

numpy.ndarray

numpy与list 对比

import random
import time

#生成一个大数组
python_list=[]

for i in range(100000000):
    python_list.append(random.random())

ndarray_list=np.array(python_list)

len(ndarray_list)

100000000

# 原生pythonlist求和
t1 = time.time()
a = sum(python_list)
t2 = time.time()
d1 =t2- t1

#ndarray求和
t3 = time.time()
b=np.sum(ndarray_list)
t4 = time.time()
d2 = t4-t3

d1

0.3330507278442383

d2

0.06101274490356445

ndarray的属性

score

array([[80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79]])

score.shape 

(8, 5)

score.ndim #维度

2

score.size

40

score.dtype

dtype('int32')

score.itemsize #单个元素的大小

4

a = np.array([[1, 2, 3], [4, 5, 6]])
b = np.array([1, 2, 3, 4])
c = np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]])

a  #(2,3)

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

b  #(4,)

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

c  #(2,2,3)从最外层开始每一个中括号内包含几个“元素”

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

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

 a.shape

(2, 3)

a.reshape(4,-1)# -1 的位置系统自动帮忙计算

array([[ 1.1       ,  0.46486002],
       [-1.61786434,  0.11906454],
       [-0.59387934,  1.1       ],
       [ 0.25657148, -1.95080153]])

b.shape

(4,)

c.shape

(2, 2, 3)

ndarray的类型

data = np.array([1.1,2.2,3.3])

data

array([1.1, 2.2, 3.3])

data.dtype

dtype('float64')

#创建数组时指定类型
np.array([1.1,2.2,3.3],dtype="float32")

array([1.1, 2.2, 3.3], dtype=float32)

np.array([1.1,2.2,3.3],dtype=np.float32)

array([1.1, 2.2, 3.3], dtype=float32)

生成数组的方法

#1.生成0和1
np.zeros(shape = (3,4),dtype = "float32")

array([[0., 0., 0., 0.],
       [0., 0., 0., 0.],
       [0., 0., 0., 0.]], dtype=float32)

np.ones(shape=[2,3] ,dtype =np.int32)

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

#2.从现有数组生成
score

array([[80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79]])

# np.array()
data1 = np.array(score)

data1

array([[80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79]])

#np.asarray()
data2 = np.asarray(score)

data2

array([[80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79]])

#np.copy()
data3 = np.copy(score)

data3

array([[80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79]])

score[3,1] 

89

score[3,1] = 10000

score

array([[   80,    89,    86,    67,    79],
       [   80,    89,    86,    67,    79],
       [   80,    89,    86,    67,    79],
       [   80, 10000,    86,    67,    79],
       [   80,    89,    86,    67,    79],
       [   80,    89,    86,    67,    79],
       [   80,    89,    86,    67,    79],
       [   80,    89,    86,    67,    79]])

data1

array([[80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79]])

data2

array([[   80,    89,    86,    67,    79],
       [   80,    89,    86,    67,    79],
       [   80,    89,    86,    67,    79],
       [   80, 10000,    86,    67,    79],
       [   80,    89,    86,    67,    79],
       [   80,    89,    86,    67,    79],
       [   80,    89,    86,    67,    79],
       [   80,    89,    86,    67,    79]])

data3

array([[80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79],
       [80, 89, 86, 67, 79]])

#生成固定范围的数组
np.linspace(0,10,5)#左闭右闭有c个元素

array([ 0. ,  2.5,  5. ,  7.5, 10. ])

np.arange(0,10,5)#左闭右开步长

array([0, 5])

np.arange(0,11,5)

array([ 0,  5, 10])

均匀分布和正态分布

#均匀分布
data1 = np.random.uniform(low=-1,high=1,size=1000000)

data1

array([ 0.60416086,  0.12537264,  0.87938927, ..., -0.27511781,
       -0.8248633 , -0.11864051])

import matplotlib.pyplot as plt

#1.创建画布
plt.figure(figsize=(20,8),dpi=20)
#2.绘制直方图
plt.hist(data1,1000)
#3.显示图像
plt.show()

在这里插入图片描述

#正态分布
data2=np.random.normal(loc=1.75,scale=0.1,size=1000000)#均值，标准差，形状

data2

array([1.5880087 , 1.91353129, 1.85618572, ..., 1.6376302 , 1.72127443,
       1.92223794])

#1.创建画布
plt.figure(figsize=(20,8),dpi=20)
#2.绘制直方图
plt.hist(data2,1000)
#3.显示图像
plt.show()

在这里插入图片描述

随机生成8只股票2周的交易日涨幅数据案例

stock_change = np.random.normal(loc=0,scale = 1,size=(8,10))

stock_change

array([[ 0.86535835,  1.32748828,  0.119368  , -1.45008918,  0.27322722,
         0.11545142,  0.54136865, -2.26024006, -0.50250959, -0.56330494],
       [ 0.05739357, -1.08807875,  1.83402645,  0.62271996, -1.0323532 ,
         0.01519282, -0.57755933,  0.11212502,  0.25199048,  1.50675596],
       [ 1.67717168, -2.1645031 , -1.0597855 , -1.22317734,  0.59855031,
        -2.1363636 ,  1.2269474 ,  0.1051736 ,  0.76156584,  0.95709548],
       [-0.52282848, -0.27326557,  0.67962168, -1.3064003 ,  0.46515538,
        -0.41745562, -0.08448161,  1.18754525, -0.19445   ,  1.28665287],
       [-0.03962928, -0.71634026, -0.0513155 , -0.95734692,  0.37444264,
         0.66686253,  0.71308877, -0.2676316 ,  0.11894867, -0.16560205],
       [-0.12458793,  0.89749669,  0.20515216, -0.28750428,  0.29443521,
        -0.12536528,  0.0632028 , -1.65736249,  1.94054161, -0.09121584],
       [ 0.2543928 ,  0.20969513, -2.08981621,  0.73860983, -1.32672728,
        -1.99945488,  1.0182702 , -0.62680182,  0.65736266,  2.40533051],
       [ 1.38167085, -0.39879269,  1.21162789,  0.28650195, -0.69020696,
        -2.03748556,  0.65675971,  1.64693366, -0.11617524, -0.30542202]])

# 获取第1个股票的前3个交易日的涨跌幅数据
stock_change[0,:3]

array([0.86535835, 1.32748828, 0.119368  ])

a1 = np.array([[[1, 2, 3], [4, 5, 6]], [[11, 22, 33], [44, 55, 66]]])

a1#(2,2,3)

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

       [[11, 22, 33],
        [44, 55, 66]]])

a1.shape

(2, 2, 3)

a1[1,0,2] = 100000

a1

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

       [[    11,     22, 100000],
        [    44,     55,     66]]])

#行列翻转
stock_change

array([[ 0.86535835,  1.32748828,  0.119368  , -1.45008918,  0.27322722,
         0.11545142,  0.54136865, -2.26024006, -0.50250959, -0.56330494],
       [ 0.05739357, -1.08807875,  1.83402645,  0.62271996, -1.0323532 ,
         0.01519282, -0.57755933,  0.11212502,  0.25199048,  1.50675596],
       [ 1.67717168, -2.1645031 , -1.0597855 , -1.22317734,  0.59855031,
        -2.1363636 ,  1.2269474 ,  0.1051736 ,  0.76156584,  0.95709548],
       [-0.52282848, -0.27326557,  0.67962168, -1.3064003 ,  0.46515538,
        -0.41745562, -0.08448161,  1.18754525, -0.19445   ,  1.28665287],
       [-0.03962928, -0.71634026, -0.0513155 , -0.95734692,  0.37444264,
         0.66686253,  0.71308877, -0.2676316 ,  0.11894867, -0.16560205],
       [-0.12458793,  0.89749669,  0.20515216, -0.28750428,  0.29443521,
        -0.12536528,  0.0632028 , -1.65736249,  1.94054161, -0.09121584],
       [ 0.2543928 ,  0.20969513, -2.08981621,  0.73860983, -1.32672728,
        -1.99945488,  1.0182702 , -0.62680182,  0.65736266,  2.40533051],
       [ 1.38167085, -0.39879269,  1.21162789,  0.28650195, -0.69020696,
        -2.03748556,  0.65675971,  1.64693366, -0.11617524, -0.30542202]])

stock_change.shape

(8, 10)

stock_change.reshape(10,8)#返回新的ndarray，原始数据没有改

array([[ 0.86535835,  1.32748828,  0.119368  , -1.45008918,  0.27322722,
         0.11545142,  0.54136865, -2.26024006],
       [-0.50250959, -0.56330494,  0.05739357, -1.08807875,  1.83402645,
         0.62271996, -1.0323532 ,  0.01519282],
       [-0.57755933,  0.11212502,  0.25199048,  1.50675596,  1.67717168,
        -2.1645031 , -1.0597855 , -1.22317734],
       [ 0.59855031, -2.1363636 ,  1.2269474 ,  0.1051736 ,  0.76156584,
         0.95709548, -0.52282848, -0.27326557],
       [ 0.67962168, -1.3064003 ,  0.46515538, -0.41745562, -0.08448161,
         1.18754525, -0.19445   ,  1.28665287],
       [-0.03962928, -0.71634026, -0.0513155 , -0.95734692,  0.37444264,
         0.66686253,  0.71308877, -0.2676316 ],
       [ 0.11894867, -0.16560205, -0.12458793,  0.89749669,  0.20515216,
        -0.28750428,  0.29443521, -0.12536528],
       [ 0.0632028 , -1.65736249,  1.94054161, -0.09121584,  0.2543928 ,
         0.20969513, -2.08981621,  0.73860983],
       [-1.32672728, -1.99945488,  1.0182702 , -0.62680182,  0.65736266,
         2.40533051,  1.38167085, -0.39879269],
       [ 1.21162789,  0.28650195, -0.69020696, -2.03748556,  0.65675971,
         1.64693366, -0.11617524, -0.30542202]])

stock_change.resize(10,8)#没有返回值但是对原始的ndarray进行修改

stock_change.shape

(10, 8)

stock_change

array([[ 0.86535835,  1.32748828,  0.119368  , -1.45008918,  0.27322722,
         0.11545142,  0.54136865, -2.26024006],
       [-0.50250959, -0.56330494,  0.05739357, -1.08807875,  1.83402645,
         0.62271996, -1.0323532 ,  0.01519282],
       [-0.57755933,  0.11212502,  0.25199048,  1.50675596,  1.67717168,
        -2.1645031 , -1.0597855 , -1.22317734],
       [ 0.59855031, -2.1363636 ,  1.2269474 ,  0.1051736 ,  0.76156584,
         0.95709548, -0.52282848, -0.27326557],
       [ 0.67962168, -1.3064003 ,  0.46515538, -0.41745562, -0.08448161,
         1.18754525, -0.19445   ,  1.28665287],
       [-0.03962928, -0.71634026, -0.0513155 , -0.95734692,  0.37444264,
         0.66686253,  0.71308877, -0.2676316 ],
       [ 0.11894867, -0.16560205, -0.12458793,  0.89749669,  0.20515216,
        -0.28750428,  0.29443521, -0.12536528],
       [ 0.0632028 , -1.65736249,  1.94054161, -0.09121584,  0.2543928 ,
         0.20969513, -2.08981621,  0.73860983],
       [-1.32672728, -1.99945488,  1.0182702 , -0.62680182,  0.65736266,
         2.40533051,  1.38167085, -0.39879269],
       [ 1.21162789,  0.28650195, -0.69020696, -2.03748556,  0.65675971,
         1.64693366, -0.11617524, -0.30542202]])

stock_change.resize(8,10)

stock_change

array([[ 0.86535835,  1.32748828,  0.119368  , -1.45008918,  0.27322722,
         0.11545142,  0.54136865, -2.26024006, -0.50250959, -0.56330494],
       [ 0.05739357, -1.08807875,  1.83402645,  0.62271996, -1.0323532 ,
         0.01519282, -0.57755933,  0.11212502,  0.25199048,  1.50675596],
       [ 1.67717168, -2.1645031 , -1.0597855 , -1.22317734,  0.59855031,
        -2.1363636 ,  1.2269474 ,  0.1051736 ,  0.76156584,  0.95709548],
       [-0.52282848, -0.27326557,  0.67962168, -1.3064003 ,  0.46515538,
        -0.41745562, -0.08448161,  1.18754525, -0.19445   ,  1.28665287],
       [-0.03962928, -0.71634026, -0.0513155 , -0.95734692,  0.37444264,
         0.66686253,  0.71308877, -0.2676316 ,  0.11894867, -0.16560205],
       [-0.12458793,  0.89749669,  0.20515216, -0.28750428,  0.29443521,
        -0.12536528,  0.0632028 , -1.65736249,  1.94054161, -0.09121584],
       [ 0.2543928 ,  0.20969513, -2.08981621,  0.73860983, -1.32672728,
        -1.99945488,  1.0182702 , -0.62680182,  0.65736266,  2.40533051],
       [ 1.38167085, -0.39879269,  1.21162789,  0.28650195, -0.69020696,
        -2.03748556,  0.65675971,  1.64693366, -0.11617524, -0.30542202]])

stock_change.T#实现转置

array([[ 0.86535835,  0.05739357,  1.67717168, -0.52282848, -0.03962928,
        -0.12458793,  0.2543928 ,  1.38167085],
       [ 1.32748828, -1.08807875, -2.1645031 , -0.27326557, -0.71634026,
         0.89749669,  0.20969513, -0.39879269],
       [ 0.119368  ,  1.83402645, -1.0597855 ,  0.67962168, -0.0513155 ,
         0.20515216, -2.08981621,  1.21162789],
       [-1.45008918,  0.62271996, -1.22317734, -1.3064003 , -0.95734692,
        -0.28750428,  0.73860983,  0.28650195],
       [ 0.27322722, -1.0323532 ,  0.59855031,  0.46515538,  0.37444264,
         0.29443521, -1.32672728, -0.69020696],
       [ 0.11545142,  0.01519282, -2.1363636 , -0.41745562,  0.66686253,
        -0.12536528, -1.99945488, -2.03748556],
       [ 0.54136865, -0.57755933,  1.2269474 , -0.08448161,  0.71308877,
         0.0632028 ,  1.0182702 ,  0.65675971],
       [-2.26024006,  0.11212502,  0.1051736 ,  1.18754525, -0.2676316 ,
        -1.65736249, -0.62680182,  1.64693366],
       [-0.50250959,  0.25199048,  0.76156584, -0.19445   ,  0.11894867,
         1.94054161,  0.65736266, -0.11617524],
       [-0.56330494,  1.50675596,  0.95709548,  1.28665287, -0.16560205,
        -0.09121584,  2.40533051, -0.30542202]])

stock_change.T.shape

(10, 8)

类型修改

stock_change.astype("int32")

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

stock_change.tostring()

C:\Users\PC\AppData\Local\Temp\ipykernel_27612\2974151914.py:1: DeprecationWarning: tostring() is deprecated. Use tobytes() instead.
  stock_change.tostring()





b'\x92\x8b\xa9\xfc\x03\xb1\xeb?\x8e\x83\nZd=\xf5?\x82\x064\xb5\xe6\x8e\xbe?\x13\xf0e\xb6\x903\xf7\xbf?\xfe\x8c\t\x8e|\xd1?_z5r9\x8e\xbd?T-\x18W\xe4R\xe1?\xbd0\xb7\xbd\xf8\x14\x02\xc0b+ \xfd\x8e\x14\xe0\xbf\xdbP8\x13\x98\x06\xe2\xbf\x7fV\xca\x94\xb0b\xad?\xf4+aB\xc5h\xf1\xbf9E\xf8\x1d,X\xfd?\xcbn=jR\xed\xe3?<\xa3\xe0\xc9\x84\x84\xf0\xbf*\xb1\xdd\xa2i\x1d\x8f?\x19\xae\x92\xb4]{\xe2\xbf\xf8\x16O\xb09\xb4\xbc?\xfc"\x86\xa8\x9c \xd0?\xed\xc3*#\xac\x1b\xf8?\x1d8y\xf9\xb1\xd5\xfa?V\xf0\xdd\x00\xe7P\x01\xc0I\xee\x10\xa3\xe1\xf4\xf0\xbfj\xb2\xbbg"\x92\xf3\xbf\xdd^\x02\xfcR\'\xe3?\xa9\xeb\x1c\xcdE\x17\x01\xc0!\x9b\n\x98\x93\xa1\xf3?\xab\xb0D:\xa8\xec\xba?t>\xc2R\xbf^\xe8?oM#\xb4\x86\xa0\xee?\xf0\xd2i\xca\x02\xbb\xe0\xbf@\xe6\x00\xdb.}\xd1\xbf\x1e\x0eu\xf8u\xbf\xe5?\x84(\xfa\x00\x04\xe7\xf4\xbf\x86\x8bn\x0f\x1b\xc5\xdd?\xf5\x9e\x99\xc9\x97\xb7\xda\xbf[\x9c\xf8E\x96\xa0\xb5\xbf\xd9gEs/\x00\xf3?\x88\x8fm\xd0\xbc\xe3\xc8\xbf\x8d\xe0\x8fQ!\x96\xf4?0\xe1}\xf3IJ\xa4\xbf\xb1\x8c\x0fiB\xec\xe6\xbf\xe8\xa0@N\x06F\xaa\xbf\x0eS\xe9\xff\x95\xa2\xee\xbf\x81\x9c\xe0A\xde\xf6\xd7?j\\?\x17\xf0V\xe5?\xaf|\xa2\x8c\x9f\xd1\xe6?\x90\xb6\xd6H\xe0 \xd1\xbfg\x80\xc8\x87ks\xbe?g\xe6\'\xb9r2\xc5\xbfm\xa5y\xa3\xfe\xe4\xbf\xbf\xf9\xf1d\xf9J\xb8\xec?]o\x17\x0emB\xca?^\xbe\xa4Zxf\xd2\xbf\xe7&\xed\xc7\x06\xd8\xd2?W\xa1\xdd9\xf8\x0b\xc0\xbf\x93U\xf5\x00\x0f.\xb0?\x15\xc1\xb6\x87\x8e\x84\xfa\xbf\x9b\x85\xb3[u\x0c\xff?\xd4\x1f\xa5\xd0\xebY\xb7\xbf\x83@\xc7\xb7\xf8G\xd0?\xde\x01\xba4J\xd7\xca?@\xc0\xc4\x8f\xf1\xb7\x00\xc0v\xffH\x13\xb1\xa2\xe7?\xed}\xcaaF:\xf5\xbf\xe1\xf5\xbfg\xc4\xfd\xff\xbf~U\xb4\xb0\xd5J\xf0?\x9a\xa2\xe6\xb0\xc2\x0e\xe4\xbf\xbd\x8d\xdbk\x1d\t\xe5?\x90\x19\xee\xeb\x1d>\x03@\xf9|\xd5\xe4R\x1b\xf6?83b\xca\xd1\x85\xd9\xbf\r\xad\xc0\xec\xd3b\xf3?\xd2\xed^C\x0cV\xd2?\xf4X\x8b\xe5,\x16\xe6\xbfzYX:\xc5L\x00\xc0]#l\xee,\x04\xe5?g\xdf\x01\x1d\xd7Y\xfa?r\xf3]&\xa9\xbd\xbd\xbf\x8c\x0eN\xcf\x08\x8c\xd3\xbf'

#数组的去重

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

temp

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

np.unique(temp)

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

set(temp.flatten())

{1, 2, 3, 4, 5, 6}

ndarray的运算

stock_change = np.random.normal(loc=0,scale=1,size=(8,10))

stock_change

array([[ 1.04751667,  0.46486002, -1.61786434,  0.11906454, -0.68363202,
         0.44428458, -0.89320011, -0.53622568, -0.04982269, -1.37548725],
       [-0.59387934,  1.03760708,  0.25657148, -1.95080153,  0.9333926 ,
         0.3309002 ,  0.34197949, -1.41123087, -1.2785237 , -0.99897667],
       [-0.1673152 , -1.16306811,  0.83782136,  1.21692891,  0.12162377,
         0.02345734, -1.19401328,  1.69296728,  0.52260451, -1.08154369],
       [-1.28653761, -1.22515179, -0.22371267,  0.54140464,  0.86739731,
        -0.45585076, -1.12682035, -1.36204496,  1.10002775, -0.44349517],
       [-0.06124892,  0.23700134,  0.58331525,  0.35952943,  0.78413974,
         0.93241559,  0.71465741,  1.03538431,  0.14607477,  0.20083777],
       [-2.84961053,  0.88840185,  1.83522977, -0.1142927 , -1.44721851,
         2.1728862 , -0.82129029,  0.44726567, -0.4111181 ,  1.53027437],
       [ 0.84042996,  0.21890664,  1.2651368 , -1.14924987, -0.24219501,
        -0.32279737,  0.20622132,  0.63059689,  1.11997916,  0.82184066],
       [-0.83045758, -0.51879743,  0.38548503,  0.77859703, -0.2464859 ,
        -0.52022002, -0.70104983,  1.9108389 ,  0.13960665, -0.05175743]])

#逻辑判断
stock_change>0.5

array([[ True, False, False, False, False, False, False, False, False,
        False],
       [False,  True, False, False,  True, False, False, False, False,
        False],
       [False, False,  True,  True, False, False, False,  True,  True,
        False],
       [False, False, False,  True,  True, False, False, False,  True,
        False],
       [False, False,  True, False,  True,  True,  True,  True, False,
        False],
       [False,  True,  True, False, False,  True, False, False, False,
         True],
       [ True, False,  True, False, False, False, False,  True,  True,
         True],
       [False, False, False,  True, False, False, False,  True, False,
        False]])

stock_change[stock_change>0.5] = 1.1

stock_change

array([[ 1.1       ,  0.46486002, -1.61786434,  0.11906454, -0.68363202,
         0.44428458, -0.89320011, -0.53622568, -0.04982269, -1.37548725],
       [-0.59387934,  1.1       ,  0.25657148, -1.95080153,  1.1       ,
         0.3309002 ,  0.34197949, -1.41123087, -1.2785237 , -0.99897667],
       [-0.1673152 , -1.16306811,  1.1       ,  1.1       ,  0.12162377,
         0.02345734, -1.19401328,  1.1       ,  1.1       , -1.08154369],
       [-1.28653761, -1.22515179, -0.22371267,  1.1       ,  1.1       ,
        -0.45585076, -1.12682035, -1.36204496,  1.1       , -0.44349517],
       [-0.06124892,  0.23700134,  1.1       ,  0.35952943,  1.1       ,
         1.1       ,  1.1       ,  1.1       ,  0.14607477,  0.20083777],
       [-2.84961053,  1.1       ,  1.1       , -0.1142927 , -1.44721851,
         1.1       , -0.82129029,  0.44726567, -0.4111181 ,  1.1       ],
       [ 1.1       ,  0.21890664,  1.1       , -1.14924987, -0.24219501,
        -0.32279737,  0.20622132,  1.1       ,  1.1       ,  1.1       ],
       [-0.83045758, -0.51879743,  0.38548503,  1.1       , -0.2464859 ,
        -0.52022002, -0.70104983,  1.1       ,  0.13960665, -0.05175743]])

#通用判断函数
np.all(stock_change[0:2,0:5] >0)#只要有一个False返回false，只有全是true才是true

False

np.any(stock_change[:5,:]>0)#只要有一个true返回true,全是false才返回false

True

temp = stock_change[:4,:4]

temp

array([[ 1.1       ,  0.46486002, -1.61786434,  0.11906454],
       [-0.59387934,  1.1       ,  0.25657148, -1.95080153],
       [-0.1673152 , -1.16306811,  1.1       ,  1.1       ],
       [-1.28653761, -1.22515179, -0.22371267,  1.1       ]])

np.where(temp>0,1,0)  #第一个为条件，满足则变成第二个，不满足变成第三个

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

np.logical_and(temp>0.5,temp<1)

array([[False, False, False, False],
       [False, False, False, False],
       [False, False, False, False],
       [False, False, False, False]])

np.where(np.logical_and(temp>0.5,temp<1),1,0)

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

np.where(np.logical_or(temp>0.5,temp>-0.5),1,0)

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

temp

array([[ 1.1       ,  0.46486002, -1.61786434,  0.11906454],
       [-0.59387934,  1.1       ,  0.25657148, -1.95080153],
       [-0.1673152 , -1.16306811,  1.1       ,  1.1       ],
       [-1.28653761, -1.22515179, -0.22371267,  1.1       ]])

temp.max()

1.1

np.max(temp,axis=1)#np.std标准差   np.mean平均值

array([1.1, 1.1, 1.1, 1.1])

np.argmax(temp,axis=-1)#返回最大值所在的位置

array([0, 1, 2, 3], dtype=int64)

数组间的运算

#数组与数的运算
arr = np.array([[1, 2, 3, 2, 1, 4], [5, 6, 1, 2, 3, 1]])

arr+1

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

arr1 = np.array([[1, 2, 3, 2, 1, 4], [5, 6, 1, 2, 3, 1]]) # 2 x 6\

arr2 = np.array([[1], [3]]) # 2 x 1

arr1.shape

(2, 6)

arr2.shape

(2, 1)

arr1+arr2#一个地方维度为1，一个地方对应维数相等，可以运算

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

矩阵运算

#ndarray存储矩阵
data = np.array([[80, 86],
[82, 80],
[85, 78],
[90, 90],
[86, 82],
[82, 90],
[78, 80],
[92, 94]])


data

array([[80, 86],
       [82, 80],
       [85, 78],
       [90, 90],
       [86, 82],
       [82, 90],
       [78, 80],
       [92, 94]])

#matrix存储矩阵
data_mat = np.mat([[80, 86],
[82, 80],
[85, 78],
[90, 90],
[86, 82],
[82, 90],
[78, 80],
[92, 94]])

type(data_mat)

numpy.matrix

weight = np.array([[0.3],[0.7]]) 

weight_mat=np.mat([[0.3],[0.7]])

#矩阵乘法  np.matmul  np.dot

#矩阵运算
np.matmul(data,weight)

array([[84.2],
       [80.6],
       [80.1],
       [90. ],
       [83.2],
       [87.6],
       [79.4],
       [93.4]])

np.dot(data,weight)

array([[84.2],
       [80.6],
       [80.1],
       [90. ],
       [83.2],
       [87.6],
       [79.4],
       [93.4]])

data_mat*weight_mat

matrix([[84.2],
        [80.6],
        [80.1],
        [90. ],
        [83.2],
        [87.6],
        [79.4],
        [93.4]])

data@weight

array([[84.2],
       [80.6],
       [80.1],
       [90. ],
       [83.2],
       [87.6],
       [79.4],
       [93.4]])

合并与分割

#竖直拼接是0  水平拼接是1

a = stock_change[:2,0:4]
b = stock_change[4:6,0:4]

a

array([[ 1.1       ,  0.46486002, -1.61786434,  0.11906454],
       [-0.59387934,  1.1       ,  0.25657148, -1.95080153]])

b

array([[-0.06124892,  0.23700134,  1.1       ,  0.35952943],
       [-2.84961053,  1.1       ,  1.1       , -0.1142927 ]])

np.hstack((a,b))   #水平拼接

array([[ 1.1       ,  0.46486002, -1.61786434,  0.11906454, -0.06124892,
         0.23700134,  1.1       ,  0.35952943],
       [-0.59387934,  1.1       ,  0.25657148, -1.95080153, -2.84961053,
         1.1       ,  1.1       , -0.1142927 ]])

np.concatenate((a,b),axis=1)

array([[ 1.1       ,  0.46486002, -1.61786434,  0.11906454, -0.06124892,
         0.23700134,  1.1       ,  0.35952943],
       [-0.59387934,  1.1       ,  0.25657148, -1.95080153, -2.84961053,
         1.1       ,  1.1       , -0.1142927 ]])

np.vstack((a,b))   #竖直拼接

array([[ 1.1       ,  0.46486002, -1.61786434,  0.11906454],
       [-0.59387934,  1.1       ,  0.25657148, -1.95080153],
       [-0.06124892,  0.23700134,  1.1       ,  0.35952943],
       [-2.84961053,  1.1       ,  1.1       , -0.1142927 ]])

np.concatenate((a,b),axis=0)

array([[ 1.1       ,  0.46486002, -1.61786434,  0.11906454],
       [-0.59387934,  1.1       ,  0.25657148, -1.95080153],
       [-0.06124892,  0.23700134,  1.1       ,  0.35952943],
       [-2.84961053,  1.1       ,  1.1       , -0.1142927 ]])
python菜丝
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Python数据分析 3.numpy数据科学库
Serein_txw的博客
04-04 1496
Python数据分析 3.numpy基础库 1.数组的创建 import numpy as np t1 = np.array([1,2,3,]) print(t1) print(type(t1)) t2 = np.array(range(3)) print(t2) t3 = np.arange(4,10,2) print(t3) print(t3.dtype) [1 2 3] <class 'numpy.ndarray'> [0 1 2] [4 6 8] int32 numpy中常见
数据分析基础之Numpy库
qq_64997449的博客
05-30 3520
NumPy库提供了一种称为数组的数据结构，它可以容纳多维数组，并且支持各种数学运算。数组操作是数据分析中的基础，因为它可以快速地对大量数据进行操作，例如筛选、排序、聚合等等。NumPy库还提供了各种数学函数，例如求和、均值、标准差等等，这些函数可以帮助我们更好地理解和分析数据。NumPy是Python中一个重要的数据处理库，它提供了高效的数组操作和数值计算功能。在数据分析中，NumPy库的重要性不言而喻，因为数据分析通常需要处理大量的数据，并进行各种复杂的数学运算。返回一个新的数组，改变数组形状。
【Python】数据分析.numpy.本地数据读取、转置
懂得一千零一种,赋予你失败的方法！
05-10 1892
Python----数据分析-numpy.本地数据读取 本地数据的读取 CSV：comma-separated value,逗号分隔值文件 显示：表格状态 源文件：换行和逗号分隔行列的格式化文本，每一行的数据表示以条记录 frame属性 import numpy as np #设置frame data_file_path = "../数据分析_numpy/data.csv" t1 = np.loadtxt(data_file_path) print(t1) 只传入数据文档地址，将会报错，原文件中
2.数据分析-Numpy_①
哦吼
07-07 302
1 numpy初见 1.1 ndarray的介绍 import numpy as np import matplotlib.pyplot as plt from pylab import mpl #显示中文字体 mpl.rcParams["font.sans-serif"] = ["SimHei"] #设置正常显示字符 mpl.rcParams["axes.unicode_minus"] = False #hello numpy x=np.array([[1,2,3], [9,8
数据分析（二）Numpy
cainiaoayue的博客
08-28 294
文章目录一.Numpy应用1.numpy创建数组2.矩阵的转置3.numpy的索引和切片4.numpy中数值的修改5.获取矩阵中的四角元素6.数组拼接与分割7.数组元素的添加和删除二.Numpy案例1.学生身高体重统计分析2.基于Numpy的股价统计分析应用 一.Numpy应用 1.numpy创建数组 import numpy as np # 1). 创建数组: a, b, c创建的数组相同，...
基于五种机器学习的某游戏数据分析与胜负预测系统设计与实现，采用Django+MySQL+HTML+CSS实现
weixin_49081159的博客
09-02 581
该系统有效整合了 Django 的强大功能与机器学习算法的预测能力，实现了对游戏胜负的精准预测，为游戏玩家提供了数据驱动的决策支持。未来可以通过引入更多的游戏特征和优化算法，进一步提升预测准确性和用户体验。
梯度提升机：数据分析的强有力工具
2401_85761003的博客
08-30 833
GBM是一种集成学习方法，它通过迭代地训练决策树来最小化损失函数。在每一步迭代中，GBM都会添加一个新的树来纠正前一个模型的错误。这种方法可以显著提高模型的性能，尤其是在复杂的非线性问题上。
【Python】企业排名、地域分布与词云分析可视化
Frost_Descent的博客
09-02 672
生成的可视化数据显示，世界五百强企业的营业收入呈现出显著的差异，这种差异不仅体现了行业内巨头企业与新兴或中小型产业代表之间的鲜明对比，还深刻揭示了不同经济领域之间市场规模的差异性。紧随其后的是由香港、上海、深圳和杭州构成的第二梯队，这些城市同样凭借其强大的经济实力、完善的产业体系和创新能力，吸引了大量五百强企业的入驻，形成了较为密集的企业集群。：Pyecharts支持多种常用的图表类型，包括但不限于折线图、柱状图、散点图、饼图、地图、热力图、雷达图、箱形图、K线图等，能够满足不同场景下的数据可视化需求。
每天一个数据分析题（五百一十五）- 朴素贝叶斯分类器
shiguangre的博客
09-02 130
朴素贝叶斯分类器是一系列以假设特征之间强（朴素）独立下运用贝叶斯定理为基础的简单概率分类器。下列选项不属于朴素贝叶斯分类器特点的是？内容涵盖Python，SQL，统计学，数据分析理论，深度学习，可视化，机器学习，Spark八个方向的专项练习题库，数据分析从业者刷题必备神器！C. 相关属性可能会降低朴素贝叶斯分类器的性能，因为对这些属性，条件独立的假设已不成立。A. 面对孤立的噪声点,朴素贝叶斯分类器是健壮的。B. 面对无关属性,朴素贝叶斯分类器是健壮的。
每天一个数据分析题（五百一十四）- 决策树算法
shiguangre的博客
09-02 133
内容涵盖Python，SQL，统计学，数据分析理论，深度学习，可视化，机器学习，Spark八个方向的专项练习题库，数据分析从业者刷题必备神器！决策树由节点和边两种元素组成的结构，决策树中不包含一下哪种结点？B. 内部结点（internal node）C. 外部结点（external node）A. 根结点（root node)D. 叶结点（leaf node）
机器学习/数据分析--通俗语言带你入门随机森林，并用随机森林进行天气分类预测(Accuracy为0.92)
weixin_74085818的博客
08-29 1459
Bagging集成核心思想：将数据集集随机分为N份，每一份用一个模型求解，最后将所有模型结果进行投票得出结果。自动采样法自动采样法，可以有放回的采样，假设m个样本的数据集，每一次随机拿去一个样本，然后放回，这样就有概率下一次再被选中，经过m次采样，一次大概有百分之63.2%(数学公式推导而出)的数据被选中。数学公式推导：假设每一个样本被选择的概率为 1/m，这样进行m次选择，没有选择的概率为：​1−1mm1−m1​m当m->∞\infty∞1e≈0.368。e。
奥威-金蝶云星空BI方案
qq_43696218的博客
09-02 181
这是一套可以在半个时候内无缝对接金蝶云星空，自动取数分析，生成200+BI数据可视化分析报表（覆盖销售、财务、库存、生产、采购、应收，你想到的，想不到的分析，它都已提前规划预设）的标准化BI数据分析方案。奥威-金蝶云星空BI方案预设200+BI数据可视化报表，覆盖销售、财务、库存、生产、采购、应收，同时提供实用型数据分析模型。基于丰富BI项目，立足于金蝶云星空、奥威BI软件，让这套BI方案更具适配性，拿来就能用，可满足80%的数据分析共性分析，并为快速实现个性化开发提供便利。奥威-金蝶云星空BI方案。
数据分析- 海量数据求中位数
weixin_53731307的博客
08-30 1415
如果内存足够容纳所有数据，可以将数据加载到内存中，进行排序，然后直接找到中间位置的元素或者中间两个元素求平均值作为中位数。
每天一个数据分析题（五百一十三）- 决策树算法
shiguangre的博客
09-02 205
内容涵盖Python，SQL，统计学，数据分析理论，深度学习，可视化，机器学习，Spark八个方向的专项练习题库，数据分析从业者刷题必备神器！在决策树算法中，ID3使用哪个度量来进行特征的选择？D. Gini指数。B. 信息增益比。C. 信息增益。A. 信息熵。
【数据分析预备】Numpy入门
？的博客
09-02 219
New一个Python3文件即可得到ipynb文件。核心数据结构: ND array n维数组。解决：切换到python安装目录。数据类型统一，执行效率高。
零基础入门转录组数据分析——预后模型之随机生存森林模型
weixin_49878699的博客
08-29 865
转录组数据分析之一，先介绍相关基础知识，其次用实际案例为基础，由浅入深介绍构建预后随机森林模型并用模型计算风险评分的全过程
Python 数据可视化：工具与实践
最新发布
loveting99的博客
09-02 931
数据可视化指的是使用图形、图表或其他视觉手段来展示数据的过程。其主要目的是将复杂的数据转化为直观的视觉信息，使观众能够更容易地理解数据的结构、趋势和关系。揭示模式和趋势：通过图表中的图形和颜色变化，揭示数据中的潜在模式和趋势。识别异常和异常值：帮助识别数据中的异常值和异常模式，从而进行进一步的分析。简化复杂数据：将复杂的数据集简化为易于理解的视觉形式，提高数据的可读性。支持决策制定：为业务决策提供数据驱动的支持，使决策过程更加科学和合理。
【数据分析工具】使用Pandas进行数据分析
weixin_39372311的博客
08-29 606
Pandas是基于Python的开源数据分析工具，特别适用于结构化数据的处理。它提供了高效的数据操作功能，包括数据清洗、转换、合并、过滤和统计分析。Pandas的核心数据结构是Series和DataFrame，分别用于一维和二维数据的表示。Pandas凭借其强大的数据处理和分析功能，已经成为数据科学家和分析师的必备工具。从数据导入、清洗、处理，到分析与可视化，Pandas为我们提供了一站式解决方案。掌握Pandas的使用，将极大地提升数据处理和分析的效率，使数据科学工作变得更加高效和便捷。
​如何通过Kimi强化论文写作中的数据分析？
2401_85812784的博客
09-01 904
在学术研究领域，数据分析是验证假设、发现新知识和撰写高质量论文的关键环节。
探索 Power BI Desktop：数据分析的超级英雄
xueyunshengling的博客
09-02 313
你好，数据爱好者们！今天我们要探讨的是一个强大而有趣的工具，它能让你的数据分析如虎添翼。无论你是数据分析的新手还是老手，Power BI Desktop 都会成为你不可或缺的伙伴。那么，准备好一场数据的冒险之旅了吗？让我们一起来探索 Power BI Desktop 的奇妙世界。首先，我们需要揭开 Power BI Desktop 的神秘面纱。Power BI Desktop 是由微软开发的一款功能强大的数据可视化和商业智能工具。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值