创建ndarray对象
通过 NumPy 的内置函数 array() 可以创建 ndarray 对象，其语法格式如下：
numpy.array(object, dtype = None, copy = True, order = None,subok=False,ndmin = 0)
参数说明
| 序号 | 参数 | 描述说明 |
|---|---|---|
| 1 | object | 表示一个数组序列。 |
| 2 | dtype | 可选参数，通过它可以更改数组的数据类型。 |
| 3 | copy | 可选参数，表示数组能否被复制，默认是 True。 |
| 4 | ndmin | 用于指定数组的维度。 |
| 5 | subok | 可选参数，类型为bool值，默认False。为True，使用object的内部数据类型；False：使用object数组的数据类型。 |
引入numpy
# 注意默认都会给numpy包设置别名为np
import numpy as np
array创建数组：
#array()函数，括号内可以是列表、元祖、数组、迭代对象,生成器等
np.array([1,2,3,4,5])
array([1, 2, 3, 4, 5])
元组
np.array((1,2,3,4,5))
array([1, 2, 3, 4, 5])
```python
a = np.array([1,2,3,4,5])
# 数组
np.array(a)
array([1, 2, 3, 4, 5])
# 迭代对象
np.array(range(10))
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
# 生成器
np.array([i**2 for i in range(10)])
array([ 0, 1, 4, 9, 16, 25, 36, 49, 64, 81])
# 列表中元素类型不相同
np.array([1,1.5,3,4.5,'5']) #哪种字符串类型越大，就变成谁，这题字符串类型最大，所以全部变成字符串。
array(['1', '1.5', '3', '4.5', '5'], dtype='<U32')
ar1 = np.array(range(10)) # 整型
ar1
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
ar2 = np.array([1,2,3.14,4,5]) # 浮点型
ar2
array([1. , 2. , 3.14, 4. , 5. ])
ar3 = np.array([[1,2,3],('a','b','c')]) # 二维数组：嵌套序列（列表，元祖均可）
ar3
array([['1', '2', '3'],
['a', 'b', 'c']], dtype='<U21')
# 注意嵌套序列数量不一会怎么样
ar4 = np.array([[1,2,3],('a','b','c','d')])
ar4
/var/folders/5r/mjtqld611xs4j0ntrkytsh6m0000gn/T/ipykernel_59155/2484585590.py:2: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.
ar4 = np.array([[1,2,3],('a','b','c','d')])
array([list([1, 2, 3]), ('a', 'b', 'c', 'd')], dtype=object)
ar4.ndim #ar4是一维的
1
ar4.shape #ar4是两行一列的
(2,)
# 注意嵌套序列数量不一会怎么样
ar4 = np.array([[1,2,3],[1,2,3,4]])
ar4
/var/folders/5r/mjtqld611xs4j0ntrkytsh6m0000gn/T/ipykernel_59155/1210354137.py:2: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.
ar4 = np.array([[1,2,3],[1,2,3,4]])
array([list([1, 2, 3]), list([1, 2, 3, 4])], dtype=object)
ar4.ndim
1
练习1
- 创建10以内的偶数的数组
a=np.array(range(0,10,2))
a
array([0, 2, 4, 6, 8])
- 设置dtype参数，默认自动识别
a = np.array([1,2,3,4,5])
print(a)
# 设置数组元素类型
has_dtype_a = np.array([1,2,3,4,5],dtype='float')
has_dtype_a
[1 2 3 4 5]
array([1., 2., 3., 4., 5.])
思考如何将浮点型的数据，设置为整形，会是什么情况？
np.array([1.1,2.5,3.8,4,5],dtype='int') #取整的话是取整数位，不是四舍五入，这点和Python一样 ，四舍五入是round()
array([1, 2, 3, 4, 5])
2.设置copy参数,默认为True,即复制后的变化不会引起自身变化
a = np.array([1,2,3,4,5])
# 定义b，复制a
b = np.array(a)
# 输出a和b的id
print('a:', id(a), ' b:', id(b))
print('以上看出a和b的内存地址')
a: 140349492993840 b: 140350279445840
以上看出a和b的内存地址
# 当修改b的元素时，a不会发生变化
b[0] = 10
print('a:', a,' b:', b)
print('='*10)
a: [1 2 3 4 5] b: [10 2 3 4 5]
==========
a = np.array([1,2,3,4,5])
# 定义b，当设置copy参数为Fasle时，不会创建副本，即a会跟着b变化
# 两个变量会指向相同的内容地址，没有创建新的对象
b = np.array(a, copy=False)
# 输出a和b的id
print('a:', id(a), ' b:', id(b))
print('以上看出a和b的内存地址')
# 由于a和b指向的是相同的内存地址，因此当修改b的元素时，a会发生变化
b[0] = 10
print('a:',a,' b:',b)
a: 140349493099472 b: 140349493099472
以上看出a和b的内存地址
a: [10 2 3 4 5] b: [10 2 3 4 5]
- ndmin 用于指定数组的维度
a = np.array([1,2,3])
print(a)
a = np.array([1,2,3], ndmin=2)
a
[1 2 3]
array([[1, 2, 3]])
4.subok参数，类型为bool值，默认False。为True，使用object的内部数据类型；False：使用object数组的数据类型。
# 创建一个矩阵
a = np.mat([1,2,3,4])
# 输出为矩阵类型
print(type(a))
#既要复制一份副本，又要保持原类型
at = np.array(a,subok=True)
af = np.array(a) # 默认为False
print('at,subok为True:',type(at))
print('af,subok为False:',type(af))
print(id(at),id(a))
<class 'numpy.matrix'>
at,subok为True: <class 'numpy.matrix'>
af,subok为False: <class 'numpy.ndarray'>
140350008279360 140349493008192
书写代码是需要注意的内容：
#定义个数组
a = np.array([2,4,3,1])
# 在定义b时，如果想复制a的几种方案：
# 1.使用np.array()
b = np.array(a)
print('b = np.array(a)：',id(b),id(a))
# 2.使用数组的copy()方法
c = a.copy()
print('c = a.copy()：',id(c),id(a))
# 注意不能直接使用=号复制，直接使用=号，会使2个变量指向相同的内存地址
d = a
# 修改d也会相应的修改a
print('d = a：',id(d),id(a))
# 注意b = np.array(a, copy=False)copy默认为true,即会产生复制，即不会变,变成false后不会产生复制,即一变都变
e=np.array(a, copy=False)
print('e=np.array(a, copy=False):',id(e),id(a))
b = np.array(a)： 140349493155184 140349493155760
c = a.copy()： 140349493156144 140349493155760
d = a： 140349493155760 140349493155760
e=np.array(a, copy=False): 140349493155760 140349493155760
练习
完成以下内容，完成后截图，图片上写上姓名发到钉钉群里。
- 创建一个一维数组
- 创建一个二维数组
- 创建嵌套序列数量不一样的数组，查看结果
- 测试数组a，将数组赋值给b，修改b中的一个元素，查看a是否变化。
- 紧接着4.如果想让b变化不影响a，如何实现
a=np.array(range(10))
a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
a=np.array([range(10)])
a.ndim
2
a=np.array([[1,2,3],[4,5,6,7]])
a
/var/folders/5r/mjtqld611xs4j0ntrkytsh6m0000gn/T/ipykernel_59155/1653823077.py:1: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.
a=np.array([[1,2,3],[4,5,6,7]])
array([list([1, 2, 3]), list([4, 5, 6, 7])], dtype=object)
arange()生成区间数组
根据 start 与 stop 指定的范围以及 step 设定的步长，生成一个 ndarray。
numpy.arange(start, stop, step, dtype)
参数说明
| 序号 | 参数 | 描述说明 |
|---|---|---|
| 1 | start | 起始值，默认为0 |
| 2 | stop | 终止值（不包含） |
| 3 | step | 步长，默认为1 |
| 4 | dtype | 返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。 |
np.arange(10)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
np.arange(3.1) #Python中range是不可以浮点数的
array([0., 1., 2., 3.])
# 这个的结果？
#Python中运行range(3.1)，结果是----报错 浮点型不可以被解析
# 返回浮点型的，也可以指定类型
x = np.arange(5, dtype = float)
print(x)
[0. 1. 2. 3. 4.]
设置了起始值、终止值及步长：
# 起始10 ，终止值20 步长2
np.arange(10,20,2)
array([10, 12, 14, 16, 18])
# 起始0 ，终止值10 步长3
ar2 = np.arange(0,10,3) # 这个书写是否正确? 或ar2=np.arange(10,step=3)
print(ar2)
[0 3 6 9]
# 如果数组太大而无法打印，NumPy会自动跳过数组的中心部分，并只打印边角：
np.arange(10000)
生成随机数
a=np.random.rand(10) ##生成0-1的10个随机数
a
array([0.4246949 , 0.1683927 , 0.76999639, 0.64073041, 0.58665124,
0.6464262 , 0.90701204, 0.21832914, 0.80919704, 0.09825616])
b=np.random.randn(10) ##生成0-1的10个随机数,随机数服从标准正太分布
b
array([-0.63973415, -0.83207253, 2.08338468, 0.95370271, -0.41984673,
-0.01435148, 0.72775703, 1.61783977, -0.11406917, 2.34731604])
c=np.random.randint(1,10,10) ##生成1-10的10个随机整数
c
array([7, 3, 5, 7, 8, 7, 3, 4, 2, 9])
题目：
在庆祝教师节活动中，学校为了烘托节日气氛，在200米长的校园主干道一侧，
从起点开始，每间隔3米插一面彩旗，由近到远排成一排，
问：1.最后一面彩旗会插到终点处吗？
2.一共应插多少面彩旗？
np.arange(0,201,3)
array([ 0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36,
39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75,
78, 81, 84, 87, 90, 93, 96, 99, 102, 105, 108, 111, 114,
117, 120, 123, 126, 129, 132, 135, 138, 141, 144, 147, 150, 153,
156, 159, 162, 165, 168, 171, 174, 177, 180, 183, 186, 189, 192,
195, 198])
#len(np.arange(0,201,3)) 或
np.arange(0,201,3).size
67
如何防止 float 不精确影响numpy.arange
注意：ceil((stop - start)/step)确定项目数，小浮点不精确(stop = .400000001)可以向列表中添加意外值。
想得到一个长度为3的、从0.1开始的、间隔为0.1的数组，想当然地如下coding，结果意料之外：
np.arange(0.1,0.4,0.1)
array([0.1, 0.2, 0.3, 0.4])
linspace() 创建等差数列
返回在间隔[开始，停止]上计算的num个均匀间隔的样本。数组是一个等差数列构成
np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
参数说明
| 序号 | 参数 | 描述说明 |
|---|---|---|
| 1 | start | 必填项，序列的起始值， |
| 2 | stop | 必填项，序列的终止值，如果endpoint为true，该值包含于数列中 |
| 3 | num | 要生成的等步长的样本数量，默认为50 |
| 4 | endpoint | 该值为 true 时，数列中包含stop值，反之不包含，默认是True。 |
| 5 | retstep | 如果为 True 时，生成的数组中会显示间距，反之不显示。 |
| 6 | dtype | ndarray 的数据类型 |
# 以下实例用到三个参数，设置起始点为 1 ，终止点为 10，数列个数为 10。
a = np.linspace(1,10,10)
a
array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])
# 使用等差数列 实现输出0 0.5 1 1.5 2 2.5 3 3.5 4
# 选择题： A 还是 B
A = np.linspace(0, 4, 9)
print(A)
B = np.linspace(0, 4.1, 9)
print(B)
[0. 0.5 1. 1.5 2. 2.5 3. 3.5 4. ]
[0. 0.5125 1.025 1.5375 2.05 2.5625 3.075 3.5875 4.1 ]
# 一下实例用到三个参数，设置起始位置为2.0，终点为3,0 数列个数为5
ar1 = np.linspace(2.0, 3.0, num=5)
ar1
array([2. , 2.25, 2.5 , 2.75, 3. ])
# 设置参数endpoint 为False时，不包含终止值
ar1 = np.linspace(2.0, 3.0, num=5, endpoint=False)
ar1
array([2. , 2.2, 2.4, 2.6, 2.8])
#设置retstep显示计算后的步长
ar1 = np.linspace(2.0,3.0,num=5, retstep=True)
ar1
(array([2. , 2.25, 2.5 , 2.75, 3. ]), 0.25)
#设置retstep显示计算后的步长
ar1 = np.linspace(2.0,3.0,num=5,endpoint=False,retstep=True)
ar1
(array([2. , 2.2, 2.4, 2.6, 2.8]), 0.2)
#想得到一个长度为10的、从0.1开始的、间隔为0.1的数组
np.linspace(0.1,1,10)
array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ])
等差数列 在线性回归经常作为样本集
如：生成x_data，值为[0, 100]之间500个等差数列数据集合作为样本特征，根据目标线性方程y=3*x+2，生成相应的标签集合y_data
x_data = np.linspace(0,100,500)
x_data
array([ 0. , 0.2004008 , 0.4008016 , 0.6012024 ,
0.80160321, 1.00200401, 1.20240481, 1.40280561,
1.60320641, 1.80360721, 2.00400802, 2.20440882,
2.40480962, 2.60521042, 2.80561122, 3.00601202,
3.20641283, 3.40681363, 3.60721443, 3.80761523,
4.00801603, 4.20841683, 4.40881764, 4.60921844,
4.80961924, 5.01002004, 5.21042084, 5.41082164,
5.61122244, 5.81162325, 6.01202405, 6.21242485,
6.41282565, 6.61322645, 6.81362725, 7.01402806,
7.21442886, 7.41482966, 7.61523046, 7.81563126,
8.01603206, 8.21643287, 8.41683367, 8.61723447,
8.81763527, 9.01803607, 9.21843687, 9.41883768,
9.61923848, 9.81963928, 10.02004008, 10.22044088,
10.42084168, 10.62124248, 10.82164329, 11.02204409,
11.22244489, 11.42284569, 11.62324649, 11.82364729,
12.0240481 , 12.2244489 , 12.4248497 , 12.6252505 ,
12.8256513 , 13.0260521 , 13.22645291, 13.42685371,
13.62725451, 13.82765531, 14.02805611, 14.22845691,
14.42885772, 14.62925852, 14.82965932, 15.03006012,
15.23046092, 15.43086172, 15.63126253, 15.83166333,
16.03206413, 16.23246493, 16.43286573, 16.63326653,
16.83366733, 17.03406814, 17.23446894, 17.43486974,
17.63527054, 17.83567134, 18.03607214, 18.23647295,
18.43687375, 18.63727455, 18.83767535, 19.03807615,
19.23847695, 19.43887776, 19.63927856, 19.83967936,
20.04008016, 20.24048096, 20.44088176, 20.64128257,
20.84168337, 21.04208417, 21.24248497, 21.44288577,
21.64328657, 21.84368737, 22.04408818, 22.24448898,
22.44488978, 22.64529058, 22.84569138, 23.04609218,
23.24649299, 23.44689379, 23.64729459, 23.84769539,
24.04809619, 24.24849699, 24.4488978 , 24.6492986 ,
24.8496994 , 25.0501002 , 25.250501 , 25.4509018 ,
25.65130261, 25.85170341, 26.05210421, 26.25250501,
26.45290581, 26.65330661, 26.85370741, 27.05410822,
27.25450902, 27.45490982, 27.65531062, 27.85571142,
28.05611222, 28.25651303, 28.45691383, 28.65731463,
28.85771543, 29.05811623, 29.25851703, 29.45891784,
29.65931864, 29.85971944, 30.06012024, 30.26052104,
30.46092184, 30.66132265, 30.86172345, 31.06212425,
31.26252505, 31.46292585, 31.66332665, 31.86372745,
32.06412826, 32.26452906, 32.46492986, 32.66533066,
32.86573146, 33.06613226, 33.26653307, 33.46693387,
33.66733467, 33.86773547, 34.06813627, 34.26853707,
34.46893788, 34.66933868, 34.86973948, 35.07014028,
35.27054108, 35.47094188, 35.67134269, 35.87174349,
36.07214429, 36.27254509, 36.47294589, 36.67334669,
36.87374749, 37.0741483 , 37.2745491 , 37.4749499 ,
37.6753507 , 37.8757515 , 38.0761523 , 38.27655311,
38.47695391, 38.67735471, 38.87775551, 39.07815631,
39.27855711, 39.47895792, 39.67935872, 39.87975952,
40.08016032, 40.28056112, 40.48096192, 40.68136273,
40.88176353, 41.08216433, 41.28256513, 41.48296593,
41.68336673, 41.88376754, 42.08416834, 42.28456914,
42.48496994, 42.68537074, 42.88577154, 43.08617234,
43.28657315, 43.48697395, 43.68737475, 43.88777555,
44.08817635, 44.28857715, 44.48897796, 44.68937876,
44.88977956, 45.09018036, 45.29058116, 45.49098196,
45.69138277, 45.89178357, 46.09218437, 46.29258517,
46.49298597, 46.69338677, 46.89378758, 47.09418838,
47.29458918, 47.49498998, 47.69539078, 47.89579158,
48.09619238, 48.29659319, 48.49699399, 48.69739479,
48.89779559, 49.09819639, 49.29859719, 49.498998 ,
49.6993988 , 49.8997996 , 50.1002004 , 50.3006012 ,
50.501002 , 50.70140281, 50.90180361, 51.10220441,
51.30260521, 51.50300601, 51.70340681, 51.90380762,
52.10420842, 52.30460922, 52.50501002, 52.70541082,
52.90581162, 53.10621242, 53.30661323, 53.50701403,
53.70741483, 53.90781563, 54.10821643, 54.30861723,
54.50901804, 54.70941884, 54.90981964, 55.11022044,
55.31062124, 55.51102204, 55.71142285, 55.91182365,
56.11222445, 56.31262525, 56.51302605, 56.71342685,
56.91382766, 57.11422846, 57.31462926, 57.51503006,
57.71543086, 57.91583166, 58.11623246, 58.31663327,
58.51703407, 58.71743487, 58.91783567, 59.11823647,
59.31863727, 59.51903808, 59.71943888, 59.91983968,
60.12024048, 60.32064128, 60.52104208, 60.72144289,
60.92184369, 61.12224449, 61.32264529, 61.52304609,
61.72344689, 61.9238477 , 62.1242485 , 62.3246493 ,
62.5250501 , 62.7254509 , 62.9258517 , 63.12625251,
63.32665331, 63.52705411, 63.72745491, 63.92785571,
64.12825651, 64.32865731, 64.52905812, 64.72945892,
64.92985972, 65.13026052, 65.33066132, 65.53106212,
65.73146293, 65.93186373, 66.13226453, 66.33266533,
66.53306613, 66.73346693, 66.93386774, 67.13426854,
67.33466934, 67.53507014, 67.73547094, 67.93587174,
68.13627255, 68.33667335, 68.53707415, 68.73747495,
68.93787575, 69.13827655, 69.33867735, 69.53907816,
69.73947896, 69.93987976, 70.14028056, 70.34068136,
70.54108216, 70.74148297, 70.94188377, 71.14228457,
71.34268537, 71.54308617, 71.74348697, 71.94388778,
72.14428858, 72.34468938, 72.54509018, 72.74549098,
72.94589178, 73.14629259, 73.34669339, 73.54709419,
73.74749499, 73.94789579, 74.14829659, 74.34869739,
74.5490982 , 74.749499 , 74.9498998 , 75.1503006 ,
75.3507014 , 75.5511022 , 75.75150301, 75.95190381,
76.15230461, 76.35270541, 76.55310621, 76.75350701,
76.95390782, 77.15430862, 77.35470942, 77.55511022,
77.75551102, 77.95591182, 78.15631263, 78.35671343,
78.55711423, 78.75751503, 78.95791583, 79.15831663,
79.35871743, 79.55911824, 79.75951904, 79.95991984,
80.16032064, 80.36072144, 80.56112224, 80.76152305,
80.96192385, 81.16232465, 81.36272545, 81.56312625,
81.76352705, 81.96392786, 82.16432866, 82.36472946,
82.56513026, 82.76553106, 82.96593186, 83.16633267,
83.36673347, 83.56713427, 83.76753507, 83.96793587,
84.16833667, 84.36873747, 84.56913828, 84.76953908,
84.96993988, 85.17034068, 85.37074148, 85.57114228,
85.77154309, 85.97194389, 86.17234469, 86.37274549,
86.57314629, 86.77354709, 86.9739479 , 87.1743487 ,
87.3747495 , 87.5751503 , 87.7755511 , 87.9759519 ,
88.17635271, 88.37675351, 88.57715431, 88.77755511,
88.97795591, 89.17835671, 89.37875752, 89.57915832,
89.77955912, 89.97995992, 90.18036072, 90.38076152,
90.58116232, 90.78156313, 90.98196393, 91.18236473,
91.38276553, 91.58316633, 91.78356713, 91.98396794,
92.18436874, 92.38476954, 92.58517034, 92.78557114,
92.98597194, 93.18637275, 93.38677355, 93.58717435,
93.78757515, 93.98797595, 94.18837675, 94.38877756,
94.58917836, 94.78957916, 94.98997996, 95.19038076,
95.39078156, 95.59118236, 95.79158317, 95.99198397,
96.19238477, 96.39278557, 96.59318637, 96.79358717,
96.99398798, 97.19438878, 97.39478958, 97.59519038,
97.79559118, 97.99599198, 98.19639279, 98.39679359,
98.59719439, 98.79759519, 98.99799599, 99.19839679,
99.3987976 , 99.5991984 , 99.7995992 , 100. ])
等比数列
返回在间隔[开始，停止]上计算的num个均匀间隔的样本。数组是一个等比数列构成
np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
参数说明
| 序号 | 参数 | 描述说明 |
|---|---|---|
| 1 | start | 必填项，序列的起始值， |
| 2 | stop | 必填项，序列的终止值，如果endpoint为true，该值包含于数列中 |
| 3 | num | 要生成的等步长的样本数量，默认为50 |
| 4 | endpoint | 该值为 true 时，数列中包含stop值，反之不包含，默认是True。 |
| 5 | base | 对数 log 的底数 |
| 6 | dtype | ndarray 的数据类型 |
a = np.logspace(0,9,10,base=2) #0到9分成十等份
a
array([ 1., 2., 4., 8., 16., 32., 64., 128., 256., 512.])
np.logspace(A,B,C,base=D)
- A: 生成数组的起始值为D的A次方
- B:生成数组的结束值为D的B次方
- C:总共生成C个数
- D:指数型数组的底数为D，当省略base=D时，默认底数为10
# 我们先使用前3个参数，将[1,5]均匀分成3个数，得到{1,3,5}，
# 然后利用第4个参数base=2(默认是10）使用指数函数可以得到最终输出结果 {2^1,2^3,2^5}
np.logspace(1,5,3,base=2) #是对1~5分成三份 不是对最终结果值2^1~2^5，分成三份
array([ 2., 8., 32.])
# 取得1到2之间10个常用对数
np.logspace(1.0,2.0,num=10)
array([ 10. , 12.91549665, 16.68100537, 21.5443469 ,
27.82559402, 35.93813664, 46.41588834, 59.94842503,
77.42636827, 100. ])
a = np.linspace(1.0,2.0,num=10)
print(a)
10 ** a
[1. 1.11111111 1.22222222 1.33333333 1.44444444 1.55555556
1.66666667 1.77777778 1.88888889 2. ]
array([ 10. , 12.91549665, 16.68100537, 21.5443469 ,
27.82559402, 35.93813664, 46.41588834, 59.94842503,
77.42636827, 100. ])
练习题
一个穷人到富人那里去借钱，原以为富人不愿意，哪知富人一口答应了下来，
但提出了如下条件：
- 在30天中，富人第一天借给穷人1万元，第二天借给2万，以后每天所借的钱数都比上一天的多一万；
- 但 借钱第一天，穷人还1分钱，第二天还2分钱，以后每天所还的钱数都是上一天的两倍。
- 30天后互不相欠，
穷人听后觉得挺划算，本想定下来，但又想到富人是个吝啬出了名的，怕上当，所以很为难。
同学们思考下，如何用我们刚才学到的方法计算出结果，确定是否向富人借钱？
np.linspace(1,30,30)
sum(np.linspace(1,30,30))
465.0
#np.linspace(0,29,30)
#[ 0., 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., 28., 29.]
np.logspace(0,29,30,base=2)
sum(np.logspace(0,29,30,base=2))
1073741823.0
全0数列
创建指定大小的数组，数组元素以 0 来填充
numpy.zeros(shape, dtype = float, order = 'C')
参数说明
| 序号 | 参数 | 描述说明 |
|---|---|---|
| 1 | shape | 数组形状 |
| 2 | dtype | 数据类型，可选 |
# 默认为浮点数
np.zeros(5)
array([0., 0., 0., 0., 0.])
# 设置为整形
#报错写法：np.zeros(5，dtype='int')
#a.shape查看形状，会返回一个元组，每个元素代表这一堆的元素数目
np.zeros((5,), dtype = 'int') #python中单个元素的元组如（5）这种表述错误，这是int，正确单个元素元组应表述为（5，）
#（5，）代表行中5各元素，不是5行
#生成单行一维数组的写法，如果是（1,5） 则是array([[0, 0, 0, 0, 0]]) 是个二维数组
array([0, 0, 0, 0, 0])
# 2行2列的全0数组
np.zeros((2,2))
array([[0., 0.],
[0., 0.]])
np.zeros((3,2,2))
array([[[0., 0.],
[0., 0.]],
[[0., 0.],
[0., 0.]],
[[0., 0.],
[0., 0.]]])
np.zeros((2,3,2))
array([[[0., 0.],
[0., 0.],
[0., 0.]],
[[0., 0.],
[0., 0.],
[0., 0.]]])
np.zeros((2,2,3))
array([[[0., 0., 0.],
[0., 0., 0.]],
[[0., 0., 0.],
[0., 0., 0.]]])
#zeros_like返回具有与给定数组相同的形状和类型的零数组
ar1 = np.array([[1,2,3],[4,5,6]])
np.zeros_like(ar1)
array([[0, 0, 0],
[0, 0, 0]])
全1数列
# 全为1的数列
ar5 = np.ones(9)
ar6 = np.ones((2,3,4))
ar7 = np.ones_like(ar3)
print('ar5:',ar5)
print('ar6:',ar6)
print('ar7:',ar7)
ar5: [1. 1. 1. 1. 1. 1. 1. 1. 1.]
ar6: [[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]
[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]]
ar7: [['1' '1' '1']
['1' '1' '1']]
可以使用fill方法将数组设定为指定值
与列表不同，数组中要求所有元素的dtype是一样的，如果传入参数的类型与数组类型不一样，需要按照已有的类型进行转换。
a=np.array([1,2,3,4])
a.fill(2.5) ##传入的参数类型会按照原数组类型进行转换
a
array([2, 2, 2, 2])
##使用fill方法将原数组类型改变
a=np.array([1,2,3,4])
a=a.astype('float')
a.fill(2.5)
a
array([2.5, 2.5, 2.5, 2.5])
NumPy 数组属性
NumPy 的数组中比较重要 ndarray 对象属性有：
| 属性 | 说明 |
|---|---|
| ndarray.ndim | 秩，即轴的数量或维度的数量 |
| ndarray.shape | 数组的维度，对于矩阵，n 行 m 列 |
| ndarray.size | 数组元素的总个数，相当于 .shape 中 n*m 的值 |
| ndarray.dtype | ndarray 对象的元素类型 |
| ndarray.itemsize | ndarray 对象中每个元素的大小，以字节为单位 |
1.ndarray.shape
返回一个包含数组维度的元组，对于矩阵，n 行 m 列，它也可以用于调整数组维度
a = np.array([1,2,3,4,5, 6])
print('一维数组：',a.shape)
b = np.array([[1, 2, 3], [4, 5, 6]])
print('二维数组：', b.shape)
c = np.array([
[
[1, 2, 3],
[4, 5, 6]
],
[
[11, 22, 33],
[44, 55, 66]
]
])
print('三维数组：', c.shape)
一维数组： (6,)
二维数组： (2, 3)
三维数组： (2, 2, 3)
调整维度 reshape
返回调整维度后的副本，而不改变原 ndarray。
a = np.array([1,2,3,4,5, 6])
print('一维数组a：',a.shape)
# 使用a数组，创建一个新的数组b，并向形状修改为2行3列
b = a.reshape((2,3))
print('b的形状：',b.shape)
print('b：', b)
print('a的形状：',a.shape)
print('a：', a)
一维数组a： (6,)
b的形状： (2, 3)
b： [[1 2 3]
[4 5 6]]
a的形状： (6,)
a： [1 2 3 4 5 6]
调整维度 resize
numpy.resize(a, new_shape)
如果新数组大于原始数组，则新数组将填充a的重复副本。
即我有20个数，reshape（4,5）是可以的，但reshape（4,6）是不行的 这时候可以用resize
# a 为2行2列
a=np.array([[0,1],[2,3]])
# 一a为原数组创建2行3列的新数组
b_2_3 = np.resize(a,(2,3))
b_2_3
array([[0, 1, 2],
[3, 0, 1]])
请注意，此行为与a.resize(new_shape)不同，后者用零而不是重复的a填充。
a.resize((2,3),refcheck=False)
a
array([[0, 1, 2],
[3, 0, 0]])
2. ndarray.ndim
返回数组的维度（秩）:轴的数量，或者维度的数量，是一个标量，一维数组的秩为 1，二维数组的秩为 2
a = np.array([1,2,3,4,5, 6])
b = a.reshape((2,3))
c = np.array([
[
[1, 2, 3],
[4, 5, 6]
],
[
[11, 22, 33],
[44, 55, 66]
]
])
print('a的ndim：',a.ndim)
print('b的ndim：', b.ndim)
print('c的ndim：', c.ndim)
a的ndim： 1
b的ndim： 2
c的ndim： 3
3. ndarray.size
数组元素的总个数，相当于 .shape 中 n*m 的值
a = np.array([1,2,3,4,5,6])
print('[1,2,3,4,5,6]的size:', a.size)
a = np.array([[1,2,3],[4,5,6]])
print('[[1,2,3],[4,5,6]]的size:', a.size)
[1,2,3,4,5,6]的size: 6
[[1,2,3],[4,5,6]]的size: 6
len(a)只能计算一维数组元素总个数，要计算多维数组，用a.size
3. ndarray.dtype
ndarray 对象的元素类型
a = np.array([1,2,3,4,5,6])
print(a.dtype)
b = np.array([1.1,2,3,4,5,6])
print(b.dtype)
int64
float64
方法astype()
numpy数据类型转换，调用astype返回数据类型修改后的数据，但是源数据的类型不会变
a=np.array([1.1, 1.2])
print('a数据类型：',a.dtype) #
print('astype修改数据类型:',a.astype('float32').dtype)
print('原数据类型未改变',a.dtype)
# 正确操作
a = a.astype('float32')
print('修改类型后再次操作，类型改变:',a.dtype)
a数据类型： float64
astype修改数据类型: float32
原数据类型未改变 float64
修改类型后再次操作，类型改变: float32
ndarray.itemsize
以字节的形式返回数组中每一个元素的大小。
例如，一个元素类型为 float64 的数组 itemsize 属性值为 8(float64 占用 64 个 bits，每个字节长度为 8，所以 64/8，占用 8 个字节）
a = np.array([1.1,2.2,3.3])
print('dtype:',a.dtype,' itemsize:',a.itemsize)
b = np.array([1,2,3,4,5])
print('dtype:',b.dtype,' itemsize:',b.itemsize)
dtype: float64 itemsize: 8
dtype: int64 itemsize: 8
定义结构化数据
使用数据类型标识码
| 字符 | 对应类型 | 字符 | 对应类型 | 字符 | 对应类型 | 字符 | 对应类型 |
|---|---|---|---|---|---|---|---|
| b | 代表布尔型 | i | 带符号整型 | u | 无符号整型 | f | 浮点型 |
| c | 复数浮点型 | m | 时间间隔（timedelta） | M | datatime（日期时间） | O | Python对象 |
| S,a | 字节串（S）与字符串（a） | U | Unicode | V | 原始数据（void） |
还可以将两个字符作为参数传给数据类型的构造函数。此时，第一个字符表示数据类型，
第二个字符表示该类型在内存中占用的字节数（2、4、8分别代表精度为16、32、64位的
浮点数）：
# 首先创建结构化数据类型
dt = np.dtype([('age','i1')])
print(dt)
# 将数据类型应用于 ndarray 对象
students = np.array([(18),(19)],dtype=dt)
students
[('age', 'i1')]
array([(18,), (19,)], dtype=[('age', 'i1')])
以下示例描述一位老师的姓名、年龄、工资的特征，该结构化数据其包含以下字段：
str 字段：name
int 字段：age
float 字段：salary
import numpy as np
teacher = np.dtype([('name',np.str_,2), ('age', 'i1'), ('salary', 'f4')])
#输出结构化数据teacher
print(teacher)
#将其应用于ndarray对象
b = np.array([('wl', 32, 8357.50),('lh', 28, 7856.80)], dtype = teacher)
print(b)
[('name', '<U2'), ('age', 'i1'), ('salary', '<f4')]
[('wl', 32, 8357.5) ('lh', 28, 7856.8)]
作业
