1.Python数据分析与展示-导学
2.数据维度-Numpy入门1
3.Numpy的数组对象:ndarray-Numpy入门2
4.darray数组的创建和变换-Numpy入门3
5.ndarray数组的操作(索引和切片)-Numpy入门4
6.ndarray数组的运算-Numpy入门5
7.单元小结-Numpy入门6
网页链接【Python数据分析与展示】.MOOC. 北京理工大学
https://www.bilibili.com/video/av15825380/?from=search&seid=9346282164912355716#page=4

最近更新：2018-01-22

1.Python数据分析与展示-导学

2.数据维度-Numpy入门1

3.Numpy的数组对象:ndarray-Numpy入门2

3.1Numpy的简介

3.2 Numpy的引用

这里也可以去掉np的部分

3.3Python为什么需要一个数组对象(类型)

• 传统的语法,是把关注点放在一个个元素之间的运算上,这并不是一种科学计算的思想方式.

• numpy没有使用for循环,把一维数组a和一维数组b,当作两组数据,当这两组数据维度一样,可直接运算.

  
  
  
  
  

3.4ndarray对象的属性

3.5ndarray的元素类型()

3.6为什么numpy支持那么多中数据类型呢?

• 对比python语法
  • 整数,是没有取值范围,也没有划分的.
  • 浮点数,只有一种浮点数.
  • 负数,只有一种复数.

• 对比numpy语法

  

• 在python语法中,由于整数由于涉及到实际支持它的存储空间是不确定的,程序员很难去预估一个程序的使用空间.但是经过numpy的精确定义,这样的空间规模是可以被预测的.

3.7ndarray实例

o是一种对象类型,当ndarray元素的类型并不相同的时候或者每一个元素维度数据数量不一样的时候,ndarray将每一个元素认为是一个对象.那么事实上,ndarray每一个元素都是一个对象的时候,变成一个同质数组类型.但是使用数组类型的时候,对象是不一样的,所以交非同质的ndarray对象.

4.ndarray数组的创建和变换-Numpy入门3

4.1 ndarray数组的创建方法

4.1.1 从Python中的列表/元组等类型创建ndarray数组

如果读进的是整数,则numpy则是创建一个整数类型.如果读进的是浮点数,则numpy则是创建一个浮点数类型,并且这个类型是与数据比较接近的.

列表和元组混合使用的原则是使用的个数相同

4.1.2 使用NumPy中函数创建ndarray数组,如:arrange,ones,zeros等

• 需要注意的是ones,zereos,eye生成的数组类型都是浮点类型,除非用户通过dtype指定数据的类型.

• arrang生成的数组类型是整数类型.

  

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

>>> np.ones((3,6))
array([[1., 1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1., 1.]])

>>> np.zeros((3,6),dtype=np.int32)
array([[0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0]])

>>> np.eye(5)
array([[1., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0.],
       [0., 0., 1., 0., 0.],
       [0., 0., 0., 1., 0.],
       [0., 0., 0., 0., 1.]])

x=np.ones((2,3,4))表示最外层的元素中,有两个元素,每一个元素又有3个维度,每个维度下又有4个元素.所以shape是由最外层到内层是一个逐渐变化的一个数据表示方式.

>>> x=np.ones((2,3,4))
>>> print(x)
[[[1. 1. 1. 1.]
  [1. 1. 1. 1.]
  [1. 1. 1. 1.]]

 [[1. 1. 1. 1.]
  [1. 1. 1. 1.]
  [1. 1. 1. 1.]]]

>>> x.shape
(2, 3, 4)

4.1.3使用NumPy中其他函数创建ndarray数组

1代表起始数字,10代表结束数字,4代表生成的数字元素,创建的元素类型是浮点型

>>> a=np.linspace(1,10,4)
>>> a
array([ 1.,  4.,  7., 10.])

endpoint代表的意思是10是否为最后生成元素的一个,是将10不作为最后一个元素出现.在1-10之间,等间距的多分出一份,然后就会生成一个新的值出来

>>> b=np.linspace(1,10,4,endpoint=False)
>>> b
array([1.  , 3.25, 5.5 , 7.75])

>>> c=np.concatenate((a,b))
>>> c
array([ 1.  ,  4.  ,  7.  , 10.  ,  1.  ,  3.25,  5.5 ,  7.75])

4.1.4为什么numpy默认元素的类型是浮点型呢?

因为numpy是科学计算的一个库,往往使用的数据都是浮点数.除了arange这种类型,其他数据类型默认为浮点型数据.

4.2 ndarray数组的变换

4.2.1ndarray数组的维度变换

reshape是不改变原数组,而重新创建了一个数组并进行返回.

>>> a.reshape((3,8))
array([[1, 1, 1, 1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1, 1, 1, 1]])
>>> a
array([[[1, 1, 1, 1],
        [1, 1, 1, 1],
        [1, 1, 1, 1]],

       [[1, 1, 1, 1],
        [1, 1, 1, 1],
        [1, 1, 1, 1]]])

resize是直接改变了一个数组

>>> a.resize((3,8))
>>> a
array([[1, 1, 1, 1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1, 1, 1, 1]])

>>> a=np.ones((2,3,4),dtype=np.int32)
>>> a
array([[[1, 1, 1, 1],
        [1, 1, 1, 1],
        [1, 1, 1, 1]],

       [[1, 1, 1, 1],
        [1, 1, 1, 1],
        [1, 1, 1, 1]]])

>>> a.flatten()
array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1])
>>> a
array([[[1, 1, 1, 1],
        [1, 1, 1, 1],
        [1, 1, 1, 1]],

       [[1, 1, 1, 1],
        [1, 1, 1, 1],
        [1, 1, 1, 1]]])

>>> b=a.flatten()
>>> b
array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1])

4.2.2ndarray数组的类型变换

dtype=np.int代表的是整数类型,没有写int32orint64,由电脑自动识别.
astype.即使一模一样的数据,可以作为原数组的拷贝.

>>> a=np.ones((2,3,4),dtype=np.int)
>>> a
array([[[1, 1, 1, 1],
        [1, 1, 1, 1],
        [1, 1, 1, 1]],

       [[1, 1, 1, 1],
        [1, 1, 1, 1],
        [1, 1, 1, 1]]])

np.float是浮点数类型

>>> b=a.astype(np.float)
>>> b
array([[[1., 1., 1., 1.],
        [1., 1., 1., 1.],
        [1., 1., 1., 1.]],

       [[1., 1., 1., 1.],
        [1., 1., 1., 1.],
        [1., 1., 1., 1.]]])

列表与数组不同,仅在于列表是python最原始的一种数据类型,在空间和运算速度比numpy慢很多.在传统或原生的python语言和语法中.列表的转换也是非常常见的.

>>> a=np.full((2,3,4),25,dtype=np.int32)
>>> a
array([[[25, 25, 25, 25],
        [25, 25, 25, 25],
        [25, 25, 25, 25]],

       [[25, 25, 25, 25],
        [25, 25, 25, 25],
        [25, 25, 25, 25]]])

>>> a.tolist()
[[[25, 25, 25, 25], [25, 25, 25, 25], [25, 25, 25, 25]], [[25, 25, 25, 25], [25, 25, 25, 25], [25, 25, 25, 25]]]

5.ndarray数组的操作(索引和切片)-Numpy入门4

5.1一维数组的索引和切片

这里的:起始,终止编号,步长是针对一维数组进行切片的基本方法.

5.2多维数组的索引

5.3多维数组的切片

::两个冒号代表的意思是,第一个冒号是覆盖所有的范围,第二个冒号是以2为步长,以获得取值.

6.ndarray数组的运算-Numpy入门5

6.1数组与标量之间的运算

这里的a.mean()是一个标量值

>>> a.mean()
11.5
>>> a=a/a.mean()
>>> a
array([[[0.        , 0.08695652, 0.17391304, 0.26086957],
        [0.34782609, 0.43478261, 0.52173913, 0.60869565],
        [0.69565217, 0.7826087 , 0.86956522, 0.95652174]],

       [[1.04347826, 1.13043478, 1.2173913 , 1.30434783],
        [1.39130435, 1.47826087, 1.56521739, 1.65217391],
        [1.73913043, 1.82608696, 1.91304348, 2.        ]]])

6.2numpy一元函数对ndarray中的数据执行元素级运算的函数

• ceil是表示不超过这个元素的值,floor是小于这个元素的最大整数值.
• 以下这些函数可以用记,原因是与传统的python语言很接近,偶尔看一眼即可.

6.3numpy一元函数实例

需要注意运算之后是新生成数组呢?还是原数组真实被改变,几乎所有的原函数都是新生成数组,如果需要改变,需要将结果再赋值给原来的数组.

>>> a=np.arange(24).reshape((2,3,4))
>>> a
array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]],

       [[12, 13, 14, 15],
        [16, 17, 18, 19],
        [20, 21, 22, 23]]])

>>> np.square(a)
array([[[  0,   1,   4,   9],
        [ 16,  25,  36,  49],
        [ 64,  81, 100, 121]],

       [[144, 169, 196, 225],
        [256, 289, 324, 361],
        [400, 441, 484, 529]]], dtype=int32)

>>> a=np.sqrt(a)
>>> a
array([[[0.        , 1.        , 1.41421356, 1.73205081],
        [2.        , 2.23606798, 2.44948974, 2.64575131],
        [2.82842712, 3.        , 3.16227766, 3.31662479]],

       [[3.46410162, 3.60555128, 3.74165739, 3.87298335],
        [4.        , 4.12310563, 4.24264069, 4.35889894],
        [4.47213595, 4.58257569, 4.69041576, 4.79583152]]])

np.modf(a)生成的第一部分是小数,第二部分是整数,都是浮点型.

>>> np.modf(a)
(array([[[0.        , 0.        , 0.41421356, 0.73205081],
        [0.        , 0.23606798, 0.44948974, 0.64575131],
        [0.82842712, 0.        , 0.16227766, 0.31662479]],

       [[0.46410162, 0.60555128, 0.74165739, 0.87298335],
        [0.        , 0.12310563, 0.24264069, 0.35889894],
        [0.47213595, 0.58257569, 0.69041576, 0.79583152]]]), array([[[0., 1., 1., 1.],
        [2., 2., 2., 2.],
        [2., 3., 3., 3.]],

       [[3., 3., 3., 3.],
        [4., 4., 4., 4.],
        [4., 4., 4., 4.]]]))

6.4numpy二元函数

>>> a=np.arange(24).reshape((2,3,4))
>>> a
array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]],

       [[12, 13, 14, 15],
        [16, 17, 18, 19],
        [20, 21, 22, 23]]])
>>> b=np.sqrt(a)
>>> b
array([[[0.        , 1.        , 1.41421356, 1.73205081],
        [2.        , 2.23606798, 2.44948974, 2.64575131],
        [2.82842712, 3.        , 3.16227766, 3.31662479]],

       [[3.46410162, 3.60555128, 3.74165739, 3.87298335],
        [4.        , 4.12310563, 4.24264069, 4.35889894],
        [4.47213595, 4.58257569, 4.69041576, 4.79583152]]])

>>> np.maximum(a,b)#a,b两数据类型不同,最后生成的是浮点数#
array([[[ 0.,  1.,  2.,  3.],
        [ 4.,  5.,  6.,  7.],
        [ 8.,  9., 10., 11.]],

       [[12., 13., 14., 15.],
        [16., 17., 18., 19.],
        [20., 21., 22., 23.]]])
>>> a>b
array([[[False, False,  True,  True],
        [ True,  True,  True,  True],
        [ True,  True,  True,  True]],

       [[ True,  True,  True,  True],
        [ True,  True,  True,  True],
        [ True,  True,  True,  True]]])

7.单元小结-Numpy入门6