• Numpy部分


      1 import numpy as np
      2 
      3 #关于创建数组  以及生成常见的数组
      4 if 0:
      5     #进行类型转换
      6     if 0:  #可以这样  它起到了注释的作用
      7         arr = np.array([1, 3, 4, 5, 5], dtype=int)
      8         arr = arr.astype('float')  #将原有数据类型改为float
      9         arr.fill(2.5)
     10 
     11         print(arr)
     12         print("arr的里面存放的数据类型:>>>")
     13         print(arr.dtype)
     14 
     15     #除了上面的用np.array() 生成数组以外,
     16     #下面用np.arange()生成
     17 
     18 
     19     #01生成整数序列:
     20     if 0:
     21         arr = np.arange(10)
     22         print(arr)  #[0 1 2 3 4 5 6 7 8 9]
     23 
     24         arr2 = np.arange(1,10,3)  #1-10 3 为步长
     25         print(arr2)   #[1 4 7]
     26     #02 生成等差数列
     27     elif 0:
     28         arr = np.linspace(1,10,num=5)
     29         print(arr)  #[ 1.    3.25  5.5   7.75 10.  ]
     30 
     31         arr2 = np.linspace(1,10,5)
     32         print(arr2)   #[ 1.    3.25  5.5   7.75 10.  ]
     33 
     34         arr3 = np.linspace(1,10,endpoint=False) #endpoint 表示不包含最后一个
     35         print(arr3)
     36         # [1.   1.18 1.36 1.54 1.72 1.9  2.08 2.26 2.44 2.62 2.8  2.98 3.16 3.34
     37         #  3.52 3.7  3.88 4.06 4.24 4.42 4.6  4.78 4.96 5.14 5.32 5.5  5.68 5.86
     38         #  6.04 6.22 6.4  6.58 6.76 6.94 7.12 7.3  7.48 7.66 7.84 8.02 8.2  8.38
     39         #  8.56 8.74 8.92 9.1  9.28 9.46 9.64 9.82]
     40         #注意:此时没有写要生成几个,默认是生成50 个
     41 
     42         arr4 = np.linspace(1,10,num=5,retstep=True) #retstep 是是否返回公差
     43         #如果要返回公差的话此时返回的是个元组
     44         print(arr4) #(array([ 1.  ,  3.25,  5.5 ,  7.75, 10.  ]), 2.25)
     45     #03 生成随机数
     46     elif 1:
     47         arr = np.random.rand(10)  #使用np.random下的函数rand()来生成10 个【0,1) 的随机数
     48         print(arr)
     49 
     50         arr2 = np.random.randn(10) #10 个服从标准正太分布的随机数
     51         print(arr2)
     52 
     53         arr3  = np.random.randint(1,10,5) #生成5个 【1,10) 的随机整数
     54         print(arr3)
     55 
     56 
     57 
     58 
     59 
     60 
     61 
     62         pass
     63 
     64     else:
     65         pass
     66 
     67 #数组属性
     68 if 0:
     69     #查看类型
     70     if 0:
     71 
     72         a = np.array([1,3,4])
     73         print(type(a)) #<class 'numpy.ndarray'>
     74         pass
     75 
     76     #查看数组中的数据类型
     77     elif 0:
     78 
     79         a = np.array([1,3,4])
     80         print(a.dtype) #int32
     81 
     82         pass
     83 
     84     #查看形状 ,会返回一个元组,每个元素代表这一维 的元素数目
     85     elif 0:
     86         a = np.array([1,3,4])
     87         print(a.shape) #(3,)
     88 
     89         b = np.arange(10).reshape(2,5)
     90         print(b.shape) #(2, 5)
     91 
     92         c = np.arange(12).reshape(2,2,3)
     93         print(c)
     94         print(c.shape) #(2, 2, 3)   行列分别是最后两个 2,2,3 的意思是2个2行3列
     95 
     96 
     97 
     98         pass
     99 
    100     #查看数组里面元素的数目
    101     elif 0:
    102         arr = np.array([1,2,3,4,5])
    103         print(arr.size) #5
    104         pass
    105     #查看数组的维度
    106     elif 1:
    107         arr = np.array([1,2,3,4,5])
    108         print(arr.ndim)  #1   en :demensionality 维度
    109         pass
    110 
    111 #数组的索引和切片
    112 if 0:
    113     #切片的案例  :根据总票房来算每天的票房
    114     if 0:
    115         boxOffice =np.array([1222,1550,1899,3444,5666])
    116         #分析:每天的票房等于
    117         #1550,1899,3444,5666 -
    118         # 1222, 1550, 1899, 3444
    119         everyday_boxOffice = boxOffice[1:] - boxOffice[:-1]
    120         print(everyday_boxOffice) # [ 328  349 1545 2222]
    121     else:
    122         pass
    123 
    124 #多维数组 及其属性
    125 if 0:
    126     # array 可以生成多维数组
    127     if 0:
    128         arr  = np.array([[1,2,3,4],[3,4,5,6]])
    129         print(arr)
    130         # [[1 2 3 4]
    131         #  [3 4 5 6]]
    132         pass
    133     #查看形状
    134     if 0:
    135         arr = np.array([[1, 2, 3, 4], [3, 4, 5, 6]])
    136         print(arr.shape) #(2, 4)
    137         pass
    138     #查看总的元素的个数
    139     if 0:
    140         arr = np.array([[1, 2, 3, 4], [3, 4, 5, 6]])
    141         print(arr.size) #8
    142         pass
    143     #查看维数
    144     if 0:
    145         arr = np.array([[1, 2, 3, 4], [3, 4, 5, 6]])
    146         print(arr.ndim) #2
    147         pass
    148     else:
    149         pass
    150 
    151 #多维数组索引
    152 if 0:
    153     #对于二维数组,可以传入两个数字来索引,第一个是第一个维度,第二个是第二个维度
    154     if 0:
    155         arr = np.array([list(range(10)),list(range(10,20))])
    156         print(arr)
    157         print(arr[1,1])
    158         pass
    159     #对于二维数组的赋值也是类似于上面
    160     if 0:
    161         pass
    162     #还可以使用单个索引来索引一整行的内容
    163     if 0:
    164         arr = np.array([list(range(10)),list(range(10,20))])
    165         print(arr[1])
    166         pass
    167     #还可以使用单个索引来索引一整列的内容
    168     if 1:
    169         arr = np.array([list(range(10)),list(range(10,20))])
    170         print(arr[:,1])
    171         pass
    172     else:
    173         pass
    174 
    175 #注意:切片只是针对的是连续 或者登间隔的切片,要想实现任意位置的操作,要使用花式索引了
    176 #多维数组的切片
    177 if 0:
    178     arr = np.array([list(range(5)) , list(range(5,10)) , list(range(10,15))])
    179     if 1:
    180         print(arr)
    181         #第一行最后两个数
    182         print(arr[0,3:]) # [3 4]
    183         #最后两行的最后两列:
    184         print(arr[-2:,-2:])
    185         # [[8  9]
    186         #  [13 14]]
    187 
    188         #得到第三列
    189         print(arr[:,2]) #[ 2  7 12]
    190 
    191         #每一维都支持切片规则,包括负索引,包括步长
    192         # [lower:upper:step]
    193 
    194         #取出1,3 行的奇数列
    195         print(arr[::2,::2])
    196 
    197         pass
    198     else:
    199         pass
    200 
    201 #切片是引用:
    202 # 切片在内存中使用的引用机制,Python 并没有为arr1分配新的空间来存储它的值,就是改变来原来的数组的值
    203 if 0:
    204     if 0:
    205         arr =np.array([1,2,3,4])
    206         arr1 =arr[:2]
    207         print(arr1)
    208 
    209         arr1[0] =-1
    210         print(arr)  #此时修改arr1 但是arr 的值也跟着改变 ,这样做的好处是对于大量的数组,不用复制大量的数据
    211 
    212     #注意;这种现象在列表中是不存在的,列表中的 切片使用的不是这种机制。
    213     if 0:
    214         arr2 = [1,2,3,4]
    215         arr3 = arr2[:2]
    216         arr3[0]= -1
    217         print(arr2)
    218 
    219 
    220     #但是,如果不想跟着改变如何变,可以用copy()方法,此时就会申请一个新的内存
    221     if 1:
    222         arr = np.array([1,2,3,4])
    223         arr2 =arr[:2].copy()  #此时就会将 真实的切片内容申请一个新的内存空间,
    224         arr2[0] =-1
    225         print(arr)
    226 
    227         pass
    228 
    229 
    230 # 切片只是针对的是连续 或者登间隔的切片,要想实现任意位置的操作,要使用花式索引了
    231 if 0:
    232     #一维花式索引
    233     if 0:
    234         arr = np.arange(0, 100, 10)
    235         print(arr) #[ 0 10 20 30 40 50 60 70 80 90]
    236 
    237         #花式索引需要指定索引位置
    238         if 0:
    239             idx = [1,2,-3]
    240             print(arr[idx])  #[10 20 70]
    241         #通过布尔数组来花式索引
    242         if 1:
    243             mask =np.array([1,2,3,0,1,0,0,1,2,0],dtype=bool)
    244             print(mask) #[ True  True  True False  True False False  True  True False]
    245             print(arr[mask]) #[ 0 10 20 40 70 80]  #这就是通过布尔数组进行花式索引
    246             pass
    247     #二维花式索引
    248     if 1:
    249         #对于二维花式索引,我们要给定行和列 的值
    250         arr = np.array([[1,2,3],[2,3,4],[3,4,5]])
    251         print(arr)
    252         if 0:
    253             #获取次对角线上的数
    254             print(arr[(0,1),(1,2)])  #[2 4]
    255 
    256             #后两行的1,3,列
    257             print(arr[-2:,(0,2)])
    258             # [[2 4]
    259             #  [3 5]]
    260             pass
    261         # 还是可以用布尔数组来进行花式索引
    262         if 0:
    263             mask = np.array([1,0,1],dtype=bool)
    264             print(arr[mask,2]) #[3 5]
    265             pass
    266         pass
    267 
    268     #与切片不同,花式索引返回的是原对象的一个复制而不是一个引用
    269 
    270 #“不完全”索引
    271 if 0:
    272     arr = np.array([[1, 2, 3, 4], [3, 4, 5, 6],[1, 2, 3, 4], [3, 4, 5, 6]])
    273     print(arr)
    274     # 只给出行索引时,返回整行
    275     if 0:
    276         print(arr[:3])
    277     #这时候也可以使用花式索引取出0,2,3 行
    278     if 1:
    279         print(arr[np.array([1,0,1,1],dtype=bool)])
    280         pass
    281     pass
    282 
    283 #where 语句
    284 #where 函数会返回所有的非0 元素的索引
    285 if 0:
    286     #一维数组
    287     if 1:
    288         arr = np.array([1,2,3,4,5,9])
    289         #判断数组中的元素是否大于5
    290         print(arr>5) #[False False False False False  True]
    291 
    292         #数组中所有大于3的元素的索引位置
    293         #这时可以用where 函数了
    294         print(np.where(arr>3))    #(array([3, 4, 5], dtype=int32),)
    295 
    296         #也可以直接数组操作
    297         print(arr[arr>3])  #[4 5 9]
    298         #下面也可以
    299         print(arr[np.where(arr>3)])  #[4 5 9]
    300         pass
    301 
    302     pass
    303 
    304 
    305 #数组类型
    306 if 0:
    307     #类型转换
    308     if 1:
    309         arr = np.arange(10)
    310         print(arr)
    311         #使用asarray()函数
    312         if 0:
    313             ret = np.asarray(arr,dtype=float)
    314             print(ret) #[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]
    315             pass
    316         #使用astype方法
    317         if 1:
    318             ret = arr.astype(float)
    319             print(ret)   #[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]
    320             pass
    321         pass
    322 
    323 #数组操作:
    324 if 0:
    325     arr = np.array([1,20,2,43,1,34,34,23,34,535,45,23,2,1,64])
    326     # 数组排序
    327     if 0:
    328         #sort()函数
    329         if 0:
    330             res = np.sort(arr)
    331             print(res)
    332             pass
    333         #argsort()函数
    334         if 1:
    335             #返回元素的索引位置
    336             res = np.argsort(arr)
    337             print(res)
    338             pass
    339 
    340 
    341         pass
    342 
    343     #求和
    344     if 0:
    345         res = np.sum(arr)
    346         print(res)
    347 
    348         res = arr.sum()
    349         print(res)
    350         pass
    351 
    352     #最值
    353     if 0:
    354         res = np.min(arr)
    355         # 或用面向对象的方式书写
    356         res = arr.min()
    357         print(res)
    358 
    359         res = np.max(arr)
    360         res = arr.max()
    361         print(res)
    362         pass
    363 
    364     #均值
    365     if 0:
    366         res = np.mean(arr)
    367         res = np.average(arr)
    368         res = arr.mean()
    369         print(res)
    370         pass
    371 
    372 
    373     #标准差
    374     if 0:
    375         res  = np.std(arr)
    376         res = arr.std()
    377         print(res)
    378         pass
    379 
    380     #相关系数矩阵
    381     if 1:
    382         arr2 = np.arange(15)
    383         res = np.cov(arr,arr2 )
    384         # res = print(arr.size)
    385         print(res)
    386         # [[17828.26666667    98.64285714]
    387         #  [98.64285714    20.]]
    388         pass
    389     pass
    390 
    391 
    392 #多维数组的操作
    393 if 1:
    394     arr = np.array([[1, 2, 3, 4], [3, 4, 5, 6],[1, 2, 3, 4], [3, 4, 5, 6]])
    395     #数组形状
    396     if 0:
    397         #改变原来数组的形状
    398         if 0:
    399             arr.shape = (2,8)  #此时改变原有数组的形状
    400             print(arr)
    401             # [[1 2 3 4 3 4 5 6]
    402             #  [1 2 3 4 3 4 5 6]]
    403         #与之对应的是不改变原有数组的形状  .reshape()
    404         if 0:
    405             res = arr.reshape((2,8))
    406             print(res)
    407             print(arr)
    408             pass
    409         pass
    410 
    411     #转置
    412     if 0:
    413         #使用.T 属性转置
    414         if 0:
    415             res = arr.T
    416             print(res)
    417         #使用 .transpose()进行
    418         if 1:
    419             res = arr.transpose()
    420             print(res)
    421         pass
    422 
    423     #数组连接
    424     if 0:
    425         x = np.array([[1, 2, 3], [4, 5, 6]])
    426         y = np.array([[10, 20, 30], [40, 50, 60]])
    427         if 0:
    428             res = np.concatenate((x,y))  #默认是按照axis = 0 来连接的
    429             print(res)
    430 
    431             res2 = np.concatenate((x,y),axis=1) #沿着第二维 进行连接
    432             print(res2)
    433 
    434             #注:因为x,y 的形状相同,xy还可以连接成一个三维的数组,但是concatenate 不提供这样的功能,可以如下方法做
    435             res3 = np.array([x,y])
    436             print(res3)
    437 
    438         #事实上,Numpy 提供了上面三种的情况的函数
    439         # vstack
    440         # hstack
    441         # dstack
    442         if 1:
    443             res = np.vstack((x,y))
    444             print(res)
    445 
    446             res2 = np.hstack((x,y))
    447             print(res2)
    448 
    449             res3 = np.dstack((x,y))
    450             print(res3)
    451 
    452             # res4 = np.array((x,y))
    453             # print(res4)
    454             pass
    455         pass
    456 
    457 
    458 
    459 
    460 
    461     pass
    462 
    463 #Numpy 内置函数
    464 if 1:
    465     #绝对值
    466     np.abs()
    467     #指数
    468     np.exp()
    469     #中值
    470     np.median()
    471     #累计和
    472     np.cumsum()
    473 
    474     #内置函数总结:
    475     # https: // blog.csdn.net / nihaoxiaocui / article / details / 51992860?locationNum = 5 & fps = 1
    476 
    477     pass
    View Code

    注:复制到编辑器中, 一点一点折叠着看

  • 相关阅读:
    Linux基础知识
    c语言依赖倒转
    ios的认识
    ios数据的基本类型和流程控制
    JavaScript 创建 自定义对象
    《大道至简》读后感
    总结
    字符串转换成整型并求和
    《大道之简》第二章
    SQL Server 2008 数据库自动备份
  • 原文地址:https://www.cnblogs.com/zach0812/p/11561808.html
Copyright © 2020-2023  润新知