本章主要讲解可迭代对象ndarray，函数，

1. numpy迭代对象：nditer

import numpy as np
dt = np.arange(10).reshape((2,5))
print(dt)
for numbers in np.nditer(dt):
    print(numbers,end=' ')

2. 循环转置之后的ndarray对象，记住转置方法transpose或者T

print(dt.T)
for numbers in np.nditer(dt.T):
    print(numbers,end=' ')

以上实例不是使用标准 C 或者 Fortran 顺序，选择的顺序是和数组内存布局一致的，这样做是为了提升访问的效率，默认是行序优先（row-major order，或者说是 C-order）

• 下面的按照列方式的访问

dt = np.arange(10).reshape((2,5))
print(dt)
# 强制使用C
print('显示设置使用C')
for members in np.nditer(dt,order='C'):
    print(members,end=' ')
else:
    print('')
# '强制使用F'
print('显示设置使用F')
for members in np.nditer(dt,order='F'):
    print(members,end=' ')
else:
    print('')

上面的所有都是,显示设置顺序，使用给定顺序，循环数据

dt = np.arange(10).reshape((5,2))
print(dt)
print('copy对象使用F')
for members in np.nditer(dt.copy(order='F')):
    print(members,end=' ')
else:
    print('')
print('转置之后copy对象使用F')
for members in np.nditer(dt.T.copy(order='F')):
    print(members,end=' ')
else:
    print('')

注意上面的循环都ndarray中的对象都是只读的，不能修改循环内容
eg: 打印迭代对象

Traceback (most recent call last):
  File "numpy.function.py", line 64, in <module>
    members[...] = members*2
ValueError: assignment destination is read-only

使用参数：op_flags=readwrite或者readonly
readwrite: 可修改
readonly： 只读的

此外还可以指定nditer类拥有的构造器参数flags，参数：

• c_index 可以跟踪 C 顺序的索引 和order='C'一致
• f_index 可以跟踪 Fortran 顺序的索引 和order='F'一致multi-index每次迭代可以跟踪一种索引类型
• external_loop 给出的值是具有多个值的一维数组，而不是零维数组可以理解为不是ndarray对象中的元素

dt = np.linspace(10,58,24,dtype='int').reshape((4,6))
print(dt)
print('打印迭代对象')
for members in np.nditer(dt,op_flags=['readwrite']):
    # print(members[...])
    members[...] = members*2
    print(members,end=' ')
else:
    print('')
print(dt)


dt = np.logspace(1,10,20,dtype='int').reshape((5,4))
print(dt)
# 遍历所有对象，合并成一个对象
for members in np.nditer(dt,flags=['external_loop'],order='F'):
    print(members,end=', ')
else:
    print('')

如果两个对象是可以广播的，则可以迭代两个对象

dt1 = np.array([[2,3,4],[4,5,6],[6,53,2]])
dt2 = np.arange(3,12).reshape((3,3))
print('两个可迭代对象的元素是：')
for x,y in np.nditer([dt1,dt2]):
    print('{}:{}'.format(x,y),end=' ')
print('')

下面全是numpy的一些函数，包括以下几大类：

1. 修改数组形状 【必须显示的给定形状. eg:（4,5）】
2. 翻转数组
3. 修改数组维度
4. 连接数组
5. 分割数组
6. 数组元素的添加与删除

np.reshape第三个参数 order='C','F','A'
order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'k' -- 元素在内存中的出现顺序。

print('函数相关！')
# reshape
dt = np.asarray([[1,2,3,4],[4,5,6,7],[5,6,7,8]])
print(dt)
dt = np.reshape(dt,(2,6))
print(dt)
dt = dt.reshape((6,2))
print(dt)

flat元素可迭代对象,注意是个对象

print('原始数组')
for i in dt:
    print(i)
print('flat元素可迭代后的数组')
for members in dt.flat:
    print(members)

flatten，返回一组拷贝,并且对拷贝所做的修改不会影响原始数组，类似于deepcopy，格式如下：ndarray.flatten(order='C') order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'K' -- 元素在内存中的出现顺

print('flatten元素可迭代后的数组')
for members in dt.flatten(order='C'):
    print(members)

不同风格的展开数组，以 C 风格展开数组和以 F 风格顺序展开的数组

flatten意思是变平，展平

print('使用flatten展平对象')
print(dt.flatten())
print(dt.flatten(order='F'))
# print(dt.flat())

np.ravel展平对象，这个是数组视图（view，有点类似 C/C++引用reference的意味），修改会影响原始数组。order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'K' -- 元素在内存中的出现顺序。该函数接收两个参数：数组和顺序，ravel(dt,order='C')

print('使用ravel展平对象')
print(dt.ravel())
print(dt.ravel(order='F'))

• 翻转数组
• dt.transpose() 【开始的时候已经使用过】
• dt.T 和上面的函数一致
• rollaxis 向后翻转指定轴
• swapaxes 交换两个轴

print('数组转置')
print(dt)
print('数组转置T')
print(dt.T)
print('数组转置transpose')
print(dt.transpose())

2019-06-30,太多了，无法一次整理完成
...待续

数组的rollaxis，交换两个轴

print(np.rollaxis(dt,0,1))

数组函数包括：

1. 位运算
2. 字符串函数
3. 数学函数

>>> a= np.array([2,3,4,5])
>>> a.shape=[2,2]
>>> a
array([[2, 3],
       [4, 5]])
>>> b = np.arange(1,5)
>>> b
array([1, 2, 3, 4])
>>> b = np.arange(1,5).reshape((2,2))
>>> b
array([[1, 2],
       [3, 4]])
<!--加-->
>>> a+b
array([[3, 5],
       [7, 9]])
<!--减-->
>>> a-b
array([[1, 1],
       [1, 1]])
<!--乘-->
>>> a*b
array([[ 2,  6],
       [12, 20]])
<!--除-->
>>> a/b
array([[2.        , 1.5       ],
       [1.33333333, 1.25      ]])
<!--整除-->
>>> a//b
array([[2, 1],
       [1, 1]])
<!--幂运算-->
>>> print(a**b)
[[  2   9]
 [ 64 625]]
 <!--布尔运算-->
 >>> a>b
array([[ True,  True],
       [ True,  True]])
>>> a<b
array([[False, False],
       [False, False]])

上面的是逐行运算，若使用矩阵元素运算，需要使用下面的运算方法，就是所说的点积运算，返回的是一个：注意算数运算和矩阵运算的区别

>>> a.dot(b)
array([[11, 16],
       [19, 28]])

1. 算术函数
2. 统计函数

>> a
array([[2, 3],
       [4, 5]])
>>> b
array([[1, 2],
       [3, 4]])
<!--求和-->
>>> a.sum()
14
>>> b.sum()
10
<!--最大值-->
>>> a.max()
5
>>> b.max()
4
<!--最小值-->
>>> a.min()
2
>>> b.min()
1
<!--计算元素中逐个求和，返回一个一维的数组-->
>>> a.cumsum()
array([ 2,  5,  9, 14])
<!--计算元素中逐个求和，返回一个一维的数组-->
>>> b.cumsum()
array([ 1,  3,  6, 10])

1. 排序，条件刷新函数
2. 字节交换
3. 布尔计算

>>> a
array([[2, 3],
       [4, 5]])
<!--返回满足条件的列表-->
>>> a[a>1]
array([2, 3, 4, 5])
<!--返回布尔类型数组-->
>>> a>1
array([[ True,  True],
       [ True,  True]])
<!--返回布尔类型数组-->
>>> a<3
array([[ True, False],
       [False, False]])