記事ディレクトリ
Numpy 数値計算の基礎
データ サイエンス コンピューティングの基礎モジュール。科学計算タスクを完了しながら、大規模な行列を保存および処理するための効率的な多次元データ コンテナとしても使用できます。Numpyのデータコンテナはあらゆる種類のデータを保存できるため、さまざまなデータを素早く統合できます。Numpy 自体には高度なデータ分析ツールはあまりありません。
学習目標
- Numpy を使用して多次元配列を作成し、乱数を生成する方法をマスターする
- 配列のインデックス付けと変換をマスターする
- Numpy の配列行列演算と一般関数の基本的な使い方をマスターする
- Numpy のファイルの読み書き方法と一般的に使用される統計分析関数をマスターする
2.1 配列オブジェクト ndarray
2.1.1 配列オブジェクトの作成
2-1配列の作成と配列のプロパティの表示
import numpy as np #导入numpy库
arr1=np.array([1,2,3,4]) #创建一个一维数组
print('创建的数据为：',arr1) #打印
创建的数据为： [1 2 3 4]
arr2=np.array([[1,2,3,4],[4,5,6,7],[7,8,9,10]]) ##创建一个三维数组`
print('创建的三维数组为：\n',arr2) #打印
创建的三维数组为：
[[ 1 2 3 4]
[ 4 5 6 7]
[ 7 8 9 10]]
print('数组维度为：',arr2.shape) #查看数组结构
数组维度为： (3, 4)
print('数组类型为：',arr2.dtype) #查看数组类型
数组类型为： int32
print('数组元素个数为：',arr2.size) #查看数组元素个数`
数组元素个数为： 12
print('数组每个元素大小为：',arr2.itemsize) #查看数组每个元素的大小
数组每个元素大小为： 4
2-2 配列の形状属性をリセットする
arr2.shape=4,3 #重新设置数组维度`
print('重新设置的数组2的维度为：',arr2.shape)`
重新设置的数组2的维度为： (4, 3)`
print('重新设置维度的数组2为：\n',arr2)`
重新设置维度的数组2为：`
[[ 1 2 3]
[ 4 4 5]
[ 6 7 7]
[ 8 9 10]]
上記の方法では、まず Python シーケンスを生成し、次に array 関数を使用してそれを配列形式に変換しますが、効率は低くなります。したがって、numpy は、配列の作成に特化した多くの関数を提供します。
2-3 arange関数を使って配列を作成する
開始値、最終値、およびステップ サイズは、最終値を除く 1 次元配列です。
print('使用arange函数创建的数组为：\n',np.arange(0,1,0.1)) #使用arange函数创建0开始，1.0为终值，步长为0.1的数组
使用arange函数创建的数组为：
[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
2-4 linspace関数を使って配列を作成する
linspace 関数は、開始値、最終値、要素数を指定して 1 次元配列を作成します。最終値はデフォルトで含まれます (範囲とは異なります)。
print('使用linspace函数生成的数组为：\n',np.linspace(0,1,10))
使用linspace函数生成的数组为：
[0. 0.11111111 0.22222222 0.33333333 0.44444444 0.55555556 0.66666667 0.77777778 0.88888889 1. ]
2-5 対数空間関数を使って等比級数を作成する
logspace 関数は linspace 関数に似ており、等比数列を作成します。
10 0 (1) から 10 (10) までの20 個の幾何学的シーケンスを作成します。
print('使用logspace函数创建的等比数列为:\n',np.logspace(0,10,20))
使用logspace函数创建的等比数列为:
[1.00000000e+00 3.35981829e+00 1.12883789e+01 3.79269019e+01
1.27427499e+02 4.28133240e+02 1.43844989e+03 4.83293024e+03
1.62377674e+04 5.45559478e+04 1.83298071e+05 6.15848211e+05
2.06913808e+06 6.95192796e+06 2.33572147e+07 7.84759970e+07 2.63665090e+08 8.85866790e+08 2.97635144e+09 1.00000000e+10]
2-6 zeros関数を使って配列を作成する
配列、0、eye、diag、1 などを作成するための他の特別な関数を提供します。
zeros 関数は、すべての要素が 0 に等しい配列を作成します。
print('zeros函数创建的数组：\n',np.zeros((2,3)))
zeros函数创建的数组：
[[0. 0. 0.] `
2-7 eye関数を使って配列を作成する
eye 関数は、対角が 1 の配列を作成します。
print('eye函数创建的数组：\n',np.eye((3)))
eye函数创建的数组：
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]
2-8 diag関数を使って配列を作成する
diag 関数は、対角以外の要素が 0、対角の要素が 0 またはその他の数値である対角のような配列を作成します。
``print('diag 関数によって作成された配列:\n',np.diag([1,2,3])) diag 関数によって作成された配列: [[1 0 0] [0 2 0]
[0 0 3] ]`
2-9 ones 関数を使用して配列を作成する
ones 関数は、すべての要素が 1 である配列を作成します。
print('ones函数创建的数组：\n',np.ones((3)))
ones函数创建的数组：
[1. 1. 1.]
2-10 配列のデータ型変換
print('转换结果为：\n',np.float64(32)) #int转换为float
转换结果为：
32.0
print('转换结果为：\n',np.int8(42.0)) #float转换为int
转换结果为：
42
print('转换结果为：\n',np.bool(42)) #int转换为布尔类型
转换结果为：
True
print('转换结果为：\n',np.bool(0)) #int到bool类型
转换结果为：
False
print('转换结果为：\n',np.float(True)) #bool到浮点型
转换结果为：
1.0
print('转换结果为：\n',np.float(False)) #布尔到浮点型
转换结果为：
0.0
2-11データ型を作成する
df=np.dtype([("name",np.str_,40),("numitems",np.int64),("price",np.float64)])
print('数据类型为：\n',df)
数据类型为：
[('name', '<U40'), ('numitems', '<i8'), ('price', '<f8')]
2-12 データ型を表示する
print('数据类型为：\n',df["name"])
数据类型为：
<U40
print('数据类型为：\n',np.dtype(df["name"]))
数据类型为：
<U40
array 関数を使用して配列を作成する場合、配列のデフォルトのデータ型は浮動小数点です。カスタム配列はデータ型を指定できます
カスタム配列データ
itemz=np.array([("tomatoes",42,4.14),("cabbages",13,1.72)],dtype=df)
print('自定义数据为：\n',itemz)
自定义数据为：
[('tomatoes', 42, 4.14) ('cabbages', 13, 1.72)]
2.1.2 乱数の生成
ランダムは乱数を生成するために最もよく使用される関数です
print('生成的随机数组为：',np.random.random(100)) #每次生成的随机数都不一样
生成的随机数组为： [0.5414394 0.5012236 0.35249272 0.09769069 0.6475065 0.98641875
0.64135529 0.08061222 0.04190536 0.03458307 0.08118907 0.68696491
0.51004343 0.6858908 0.54504495 0.98814038 0.26325152 0.74208912
0.54847215 0.12902914 0.44575298 0.06392824 0.08550842 0.06104936
0.7926837 0.0144069 0.07766267 0.58615123 0.61704458 0.27513275
0.25431812 0.92537037 0.15578226 0.68445613 0.02767364 0.38113537
0.79595552 0.8260522 0.59981855 0.32827585 0.1126209 0.24992717
0.91755226 0.06445743 0.10480144 0.84633844 0.7064718 0.16507553
0.34488413 0.95952993 0.64346169 0.76231375 0.6661867 0.02587888
0.26290033 0.28978876 0.68573666 0.3530325 0.26461015 0.64860455
0.09969484 0.71772394 0.0178291 0.22189977 0.08611602 0.91256162
0.37283443 0.54140164 0.69328537 0.63926342 0.98635428 0.86592274
0.4146884 0.25501787 0.69481642 0.97776931 0.81314084 0.93928548
0.06571086 0.93979774 0.57665148 0.26755796 0.78038513 0.18855067
0.55590344 0.48810975 0.89531296 0.48303248 0.99821839 0.55081464
0.28083176 0.29653623 0.13610769 0.71791088 0.37012591 0.72331635
0.84702313 0.66458812 0.21930531 0.90331974]
rand 関数は、一様分布に従う乱数を生成するために使用されます。
print('生成的随机数组为：',np.random.rand(10,5))
生成的随机数组为： [[0.01932417 0.01791003 0.74598223 0.76213752 0.75621956]
[0.10245317 0.64091723 0.44050907 0.72125074 0.797107 ]
[0.79630621 0.78402876 0.89969261 0.13664477 0.73312912]
[0.02421392 0.59043566 0.597735 0.47476056 0.13479233]
[0.40949046 0.94931334 0.24626724 0.15688518 0.4430787 ]
[0.16666454 0.0717138 0.42882409 0.92195781 0.19430092]
[0.39851859 0.71871671 0.87534222 0.84967326 0.15873748]
[0.37974825 0.34834934 0.67042749 0.56788288 0.71355081]
randh 関数は、正規分布に従って乱数を生成するために使用されます。
print('生成的随机数组为：',np.random.randn(10,5))
生成的随机数组为： [[ 1.27352466 -0.0659775 0.01888002 1.31867737 -1.6837147 ]
[-0.00567767 1.54918115 0.28218841 2.0030673 -0.80086495]
[-0.19758532 -0.39607603 -0.99615034 -0.53079879 0.8369686 ]
[-0.62874687 0.61947075 -0.53059219 0.86770825 2.16602977]
[-1.34455605 -0.6352837 0.5382481 0.88364061 1.29529511]
[ 0.22003359 2.23242998 0.58226151 2.13286719 0.97495864]
[ 0.89660402 -1.09040434 -0.12308345 -0.4312826 -1.01142497]
[-2.72122353 -1.05665528 1.28831854 -0.96534334 -1.18869332]
[-0.17032955 -0.53721905 -0.28488351 1.36280418 0.28442919]
[-1.18284567 -0.18156955 -1.10135001 -0.95745263 -1.33624823]]
randiant 関数は、指定された上限と下限の範囲で乱数を生成できます。形式は次のとおりです:
numpy.random.randiant(low.high=None,size=None,dtype='1')
print('生成的随机数组为：',np.random.randint(2,10,size=[2,5])) #返回值为最小值不低于2，不大于5的2行5列的数组
生成的随机数组为： [[5 5 5 6 6]
[2 2 5 7 4]]
2.1.3 インデックスによる配列へのアクセス
Numpy は、インデックス付けの使いやすさのおかげで、配列の効率を向上させることで知られています。主に学習するのは、1 次元配列と多次元配列のインデックス付け方法です。
- 1 次元配列のインデックス付けは、
Python のリストのインデックス付け方法と一致します。
2-18 インデックスを使用して 1 次元配列にアクセスする
arr=np.arange(10) #创建一个数组
print('数组为：\n',arr) #打印数组
数组为：
[0 1 2 3 4 5 6 7 8 9]
print('索引结果为：\n',arr[5]) #打印数组索引为5的元素
索引结果为：
5
print('索引结果为：\n',arr[3:5]) #打印数组索引从3到5的元素
索引结果为：
[3 4]
print('索引结果为：\n',arr[:5]) #打印索引为5及其之前的所有元素
索引结果为：
[0 1 2 3 4]
print('索引结果为：\n',arr[-1]) #打印倒数第一个元素
索引结果为：
9
arr[2:4]=100,101 #重新定义数组
print('索引结果为：\n',arr) #打印新建的数组
索引结果为：
[ 0 1 100 101 4 5 6 7 8 9]
print('索引结果为：\n',arr[1:-1:2]) #打印从索引1到倒数第一个元素，以2为步长的元素集合
索引结果为：
[ 1 101 5 7]
print('索引结果为：\n',arr[5:1:-2]) #打印索引5到1步长为-2的所有元素
索引结果为：
[ 5 101]
2-19 インデックスを使用した多次元配列へのアクセス
arr=np.array([[1,2,3,4,5],[4,5,6,7,8],[7,8,9,10,11]]) #创建2行5列数组
print('创建的二维数组为：\n',arr) #打印数组
创建的二维数组为：
[[ 1 2 3 4 5]
[ 4 5 6 7 8]
[ 7 8 9 10 11]]
print('索引结果为：\n',arr[0,3:5]) #打印索引为0的行的索引3到5列
索引结果为：
[4 5]
print('索引结果为：\n',arr[1:,2:]) #打印索引为1行及其之后行的索引为2列之后的元素
索引结果为：
[[ 6 7 8]
[ 9 10 11]]
print('索引结果为：\n',arr[:,2]) #打印所有行的索引为2的列
索引结果为：
[3 6 9]
2-20 整数関数とブールインデックスを使用した多次元配列へのアクセス
创建的二维数组为：
[[ 1 2 3 4 5]
[ 4 5 6 7 8]
[ 7 8 9 10 11]]
print('索引结果为：\n',arr[[0,1,2],[1,2,3]])
#使用两个数组分别对应行和列的下标
索引结果为：
[ 2 6 10]
print('索引结果为：\n',arr[1:,(0,2,3)])
#打印索引1及之后行的0,2,3索引列
索引结果为：
[[ 4 6 7]
[ 7 9 10]]
mask=np.array([1,0,1],dtype=np.bool)
#mask是一个布尔数组，
print('',mask)
[ True False True]
print('索引结果为：',arr[mask,2]) #索引第1,3行中第2列元素
索引结果为： [3 9]
2.1.4 配列の形状を変換する
2-21配列の形状を変更する
配列を操作する場合、配列の次元が変更されることがよくあります。Numpy では、配列の「形状」を変更する、つまり配列の次元を変更するために、 reshape 関数がよく使用されます。
そのパラメータは、各次元の配列のサイズを指定する正の整数のタプルです。
reshape 関数は、元のデータの値を変更せずに、元のデータの形状を変更します。指定した次元が元の配列の要素数と一致しない場合、例外がスローされます。
arr=np.arange(12)
print(arr)
[ 0 1 2 3 4 5 6 7 8 9 10 11]
print('新的一维数组为：',arr.reshape(3,4)) #改变数组的维度
新的一维数组为： [[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
print('新的数组维度为：',arr.reshape(3,4).ndim)
新的数组维度为： 2
2-22 ravel 関数を使用して配列をフラット化する
arr=np.arange(12).reshape(3,4)
print('创建的二维数组为：',arr)
创建的二维数组为： [[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
print('创建的二维数组展平后为：',arr.ravel())
创建的二维数组展平后为： [ 0 1 2 3 4 5 6 7 8 9 10 11]
2-23 flatten 関数は配列を平坦化します
print('创建的二维数组展平后为：',arr.flatten()) #横向展平数组
创建的二维数组展平后为： [ 0 1 2 3 4 5 6 7 8 9 10 11]
print('创建的二维数组展平为：',arr.flatten('F')) #纵向展平数组
创建的二维数组展平后为： [ 0 4 8 1 5 9 2 6 10 3 7 11]
2-24 hstack関数を使って配列を水平に結合する
配列を結合するための要件
arr1=np.arange(12).reshape(3,4)
print("数组1为：",arr1)
数组1为： [[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
arr2=arr1*3
print('数组2为：',arr2)
数组2为： [[ 0 3 6 9]
[12 15 18 21]
[24 27 30 33]]
print('横向组合为:',np.hstack((arr1,arr2)))
横向组合为: [[ 0 1 2 3 0 3 6 9]
[ 4 5 6 7 12 15 18 21]
[ 8 9 10 11 24 27 30 33]]
2-25 vstack関数を使って配列を垂直に結合する
print('纵向组合为:',np.vstack((arr1,arr2)))
纵向组合为: [[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[ 0 3 6 9]
[12 15 18 21]
[24 27 30 33]]
2-26 連結機能を使って関数を結合する
print('横向组合为:',np.concatenate((arr1,arr2),axis=1))
横向组合为: [[ 0 1 2 3 0 3 6 9]
[ 4 5 6 7 12 15 18 21]
[ 8 9 10 11 24 27 30 33]]
print('纵向组合为:',np.concatenate((arr1,arr2),axis=0))
纵向组合为: [[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[ 0 3 6 9]
[12 15 18 21]
[24 27 30 33]]
2-27 hsplit 関数を使用して配列の水平分割を実現する
arr=np.arange(16).reshape(4,4)
print(arr)
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
print('横向分割为：\n',np.hsplit(arr1,2))
横向分割为：
[array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2, 3],
[ 6, 7],
[10, 11]])]
2-28 vsplit 関数を使用して配列の垂直分割を実現する
print('纵向分割为：\n',np.vsplit(arr,2))
纵向分割为：
[array([[0, 1, 2, 3],
[4, 5, 6, 7]]), array([[ 8, 9, 10, 11],
[12, 13, 14, 15]])]
2-29 配列を分割するには、split 関数を使用します。
print('横向分割为：\n',np.split(arr,2,axis=1))
横向分割为：
[array([[ 0, 1],
[ 4, 5],
[ 8, 9],
[12, 13]]), array([[ 2, 3],
[ 6, 7],
[10, 11],
[14, 15]])]
print('纵向分割为：\n',np.split(arr,2,axis=0))
纵向分割为：
[array([[0, 1, 2, 3],
[4, 5, 6, 7]]), array([[ 8, 9, 10, 11],
[12, 13, 14, 15]])]
ぎこちない行列と一般関数
Numpy行列を作成する
2-30 mat関数とmatrix関数を使って行列を作成する
import numpy as np
matr1=np.mat("1 2 3;4 5 6;7 8 9")
print('创建的矩阵为：\n',matr1)
创建的矩阵为：
[[1 2 3]
[4 5 6]
[7 8 9]]
matr2=np.matrix([[1,2,3],[4,5,6],[7,8,9]])
print('创建的矩阵为:\n',matr2)
创建的矩阵为:
[[1 2 3]
[4 5 6]
[7 8 9]]
2-31 bmat 関数を使用して行列を作成する
arr1=np.eye(3)
print(arr1)
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]
arr2=arr1*3
print(arr2)
[[3. 0. 0.]
[0. 3. 0.]
[0. 0. 3.]]
print('创建的矩阵为:\n',np.bmat("arr1 arr2; arr1 arr2"))
#将小的矩阵创建为大的矩阵，即将小矩阵组合成为大矩阵。在numpy中，使用bmat分块矩阵函数实现
创建的矩阵为:
[[1. 0. 0. 3. 0. 0.]
[0. 1. 0. 0. 3. 0.]
[0. 0. 1. 0. 0. 3.]
[1. 0. 0. 3. 0. 0.]
[0. 1. 0. 0. 3. 0.]
[0. 0. 1. 0. 0. 3.]]
2-32 行列演算
numpy では、行列計算は行列全体の各要素に対して実行されます。forループを使用する場合に比べて動作速度が速くなります。
matr1=np.mat("1 2 3;4 5 6;7 8 9") #创建矩阵
print(matr1)
[[1 2 3]
[4 5 6]
[7 8 9]]
matr2=matr1*3 #矩阵与数字相乘
print(matr2)
[[ 3 6 9]
[12 15 18]
[21 24 27]]
print("矩阵相加结果为：\n",matr1+matr2) #矩阵相加
矩阵相加结果为：
[[ 4 8 12]
[16 20 24]
[28 32 36]]
print("矩阵相减结果为：\n",matr1-matr2) #矩阵相减
矩阵相减结果为：
[[ -2 -4 -6]
[ -8 -10 -12]
[-14 -16 -18]]
print("矩阵相乘结果为：\n",matr1*matr2) #矩阵相乘
矩阵相乘结果为：
[[ 90 108 126]
[198 243 288]
[306 378 450]]
2-33 行列の性質
print("矩阵转置结果为：\n",matr1.T) #矩阵的转置
矩阵转置结果为：
[[1 4 7]
[2 5 8]
[3 6 9]]
print("矩阵共轭转置结果为：\n",matr1.H) #矩阵的共轭矩阵
矩阵共轭转置结果为：
[[1 4 7]
[2 5 8]
[3 6 9]]
print("矩阵的逆矩阵结果为：\n",matr1.I) #矩阵的逆矩阵
矩阵的逆矩阵结果为：
[[ 3.15251974e+15 -6.30503948e+15 3.15251974e+15]
[-6.30503948e+15 1.26100790e+16 -6.30503948e+15]
[ 3.15251974e+15 -6.30503948e+15 3.15251974e+15]]
print("矩阵的二维数组结果为：\n",matr1.A) #矩阵的二维展示
矩阵的二维数组结果为：
[[1 2 3]
[4 5 6]
[7 8 9]]
ufunc関数をマスターする
ufunc 関数はユニバーサル関数の略で、配列内のすべての要素を操作できる関数です。ufunc 関数は配列を操作し、出力として numpy 配列を使用するため、配列のすべての要素を操作する必要はありません。配列に対して繰り返し演算を実行する場合、数学ライブラリの関数を使用するよりも ufunc 関数を使用する方がはるかに効率的です。
- 一般的に使用される ufunc 関数の演算
には、四則演算、比較演算、論理演算があります。
ufunc 関数は四則演算をすべてサポートし、数値演算と同じように使用される通常の演算子を保持しますが、演算のオブジェクトは配列であることに注意してください。
配列間の四則演算とは、各配列の要素がそれぞれ四則演算を受けることを意味するため、四則演算を実行する 2 つの配列の形状は同じでなければなりません。
2 ～ 34 の配列に対する四則演算
x=np.array([1,2,3])
y=np.array([4,5,6])
print('相加：\n',x+y)
相加：
[5 7 9]
print('相减：\n',x-y)
相减：
[-3 -3 -3]
print('相乘：\n',x*y)
相乘：
[ 4 10 18]
print('相除：\n',x/y)
相除：
[0.25 0.4 0.5 ]
print('幂运算：\n',x**y)
幂运算：
[ 1 32 729]
2-35 配列の比較演算
完全な比較演算は numpy で利用できます。
戻り値はブール値で、その各要素は配列の対応する要素の比較結果です。
x=np.array([1,2,3])
y=np.array([4,5,6])
print('数组比较结果:\n',x<y)
数组比较结果:
[ True True True]
print('数组比较结果:\n',x>y)
数组比较结果:
[False False False]
print('数组比较结果:\n',x==y)
数组比较结果:
[False False False]
print('数组比较结果:\n',x>=y)
数组比较结果:
[False False False]
print('数组比较结果:\n',x<=y)
数组比较结果:
[ True True True]
print('数组比较结果:\n',x!=y)
数组比较结果:
[ True True True]
2-36 配列の論理演算
numpy の論理演算では、numpy.all は and を意味し、numpy.any は or を意味します。
print('数组逻辑计算结果为:\n',np.all(x==y))
数组逻辑计算结果为:
False
print('数组逻辑计算结果为:\n',np.any(x==y))
数组逻辑计算结果为:
False
- ufunc 関数のブロードキャスト メカニズム
ブロードキャストとは、異なる形状の配列間で算術演算が実行される方法を指します。これは ufunc とは異なります。
ブロードキャストメカニズムの原則:
- すべての入力配列を最も長い形状の配列と揃え、形状の欠落部分は先頭に 1 を追加することで補われます。
- 出力配列の形状は、入力配列の形状の各軸の最大値です。
- 入力配列の軸が出力配列の対応する軸と同じ長さであるか、その長さが 1 の場合、この配列は計算に使用できます。それ以外の場合はエラーが発生します。
- 入力配列の軸の長さが 1 の場合、この軸に沿って操作する場合は、この軸の最初のグループが使用されます。
2-37 1次元配列のブロードキャスト機構
arr1=np.array([[0,0,0],[1,1,1],[2,2,2],[3,3,3]])
print(arr1)
[[0 0 0]
[1 1 1]
[2 2 2]
[3 3 3]]
print("数组1的shape为：\n",arr1.shape)
数组1的shape为：
(4, 3)
arr2=np.array([1,2,3])
print('数组2为：\n',arr2)
数组2为：
[1 2 3]
print('数组2的shape为：\n',arr2.shape)
数组2的shape为：
(3,)
print('数组相加的结果为：\n',arr1+arr2)
数组相加的结果为：
[[1 2 3]
[2 3 4]
[3 4 5]
[4 5 6]]
2-38 2次元配列のブロードキャスト機構
arr1=np.array([[0,0,0],[1,1,1],[2,2,2],[3,3,3]])
print('数组1为：\n',arr1)
数组1为：
[[0 0 0]
[1 1 1]
[2 2 2]
[3 3 3]]
print('数组1的维度为：\n',arr1.shape)
数组1的维度为：
(4, 3)
arr2=np.array([1,2,3,4]).reshape((4,1))
print('数组2为：\n',arr2)
数组2为：
[[1]
[2]
[3]
[4]]
print('数组2的维度为：\n',arr2.shape)
数组2的维度为：
(4, 1)
print('数组相加的结果为：\n',arr1+arr2)
数组相加的结果为：
[[1 1 1]
[3 3 3]
[5 5 5]
[7 7 7]]
統計に Numpy を使用する
配列操作はよりシンプルで高速であり、特に配列の統計計算と分析を扱う場合は、同等の Python メソッドよりも数倍高速であることがよくあります。
ファイルの読み取り/書き込み
Numpy のファイルの読み書きには、主にバイナリファイルの読み書きと、ファイルリスト形式のデータの読み書きがあります。
ファイルの読み書き時に Numpy を使用したデータ処理の基礎。次に、結果をバイナリ ファイルまたはテキスト ファイルに保存できるいくつかの関数も提供します。ファイルからデータを読み取り、配列に変換するためのメソッドも多数提供されています。
save 関数はバイナリ形式でデータを保存し、load 関数はバイナリ ファイルからデータを読み取ります。
保存関数の構文形式:
np.save(file,arr,allow_pickle=True,fix_imports=True)
2-39 バイナリデータの保存
import numpy as np
arr=np.arange(100).reshape(10,10)
np.save("../save_arr",arr)
print('保存的数组为:\n',arr)
保存的数组为:
[[ 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]
[30 31 32 33 34 35 36 37 38 39]
[40 41 42 43 44 45 46 47 48 49]
[50 51 52 53 54 55 56 57 58 59]
[60 61 62 63 64 65 66 67 68 69]
[70 71 72 73 74 75 76 77 78 79]
[80 81 82 83 84 85 86 87 88 89]
2 ～ 40 以上のアレイ ストレージ
arr1=np.array([[1,2,3],[4,5,6]])
arr2=np.arange(0,1.0,0.1)
np.savez('../savez_arr',arr1,arr2)
print('保存的数组1为：\n',arr1)
保存的数组1为：
[[1 2 3]
[4 5 6]]
print('保存的数组2为：\n',arr2)
保存的数组2为：
[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
2-41 バイナリファイルの読み込み
loaded_data=np.load("../save_arr.npy")
print('读取的数组为：\n',loaded_data)
读取的数组为：
[[ 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]
[30 31 32 33 34 35 36 37 38 39]
[40 41 42 43 44 45 46 47 48 49]
[50 51 52 53 54 55 56 57 58 59]
[60 61 62 63 64 65 66 67 68 69]
[70 71 72 73 74 75 76 77 78 79]
[80 81 82 83 84 85 86 87 88 89]
[90 91 92 93 94 95 96 97 98 99]]
print('读取的数组1为：\n',loaded_data1['arr_0'])
读取的数组1为：
[[1 2 3]
[4 5 6]]
print('读取的数组2为：\n',loaded_data1['arr_1'])
读取的数组2为：
[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
なお、拡張子はデータ保存時は省略できますが、読み出し時は省略できません。
2-42 ファイルの保存と読み込み
実際のデータ分析業務では、より多くのテキスト形式のデータが使用されます。txtやcsv形式など、テキスト形式のデータの読み込み作業にはsavetxt関数、loadtxt関数、genformtxt関数がよく使われます。
savetxtx 関数は、特定の区切り文字で区切られたテキスト ファイルに配列を書き込むことができます。構文形式は次のとおりです:
np.savetxt(fname,X,fmt='%.18e',delimiter=' ',newline='\n ' 、header=''、footer=' '、comments='# ')
ファイル名、配列配列、データ区切り文字
loadtxt 関数は逆の操作、つまりファイルを 2 次元配列にロードします。
np.savetxt('../arr.txt', arr , fmt="%d", delimiter=',')
loaded_data=np.loadtxt('../arr.txt',delimiter=",")
print('读取的数组为：',loaded_data)
读取的数组为： [[ 0. 0. 1. 1. 2. 2.]
[ 3. 3. 4. 4. 5. 5.]
[ 6. 6. 7. 7. 8. 8.]
[ 9. 9. 10. 10. 11. 11.]]
2-43 genfromtxt関数を使って配列を読み取る
genfromtxt 関数は、loadtxt 関数に似ていますが、構造化配列と欠損データを処理します。
通常、ファイル名パラメータ fname、分割文字パラメータ区切り文字、および列タイトル パラメータ名が含まれるかどうかの 3 つのパラメータがあります。
loaded_data=np.genfromtxt("../arr.txt",delimiter=",")
print('读取的数组为：\n',loaded_data)
读取的数组为：
[[ 0. 0. 1. 1. 2. 2.]
[ 3. 3. 4. 4. 5. 5.]
[ 6. 6. 7. 7. 8. 8.]
[ 9. 9. 10. 10. 11. 11.]]
関数を使用して簡単な統計分析を実行する
- numpy ソートの主なソート方法は
、直接ソートと導入ソートに要約できます。
直接ソートは値を直接ソートすることを指し、間接ソートは 1 つ以上のキーに基づいてデータ セットをソートすることを指します。直接ソートではsort関数がよく使われ、間接ソートではargsort関数とlexsort関数がよく使われます。
sort 関数は最も一般的に使用される並べ替え方法であり、戻り値はありません。対象関数がビューの場合、元のデータが変更されます。sort 関数を使用して並べ替える場合、軸パラメーターを指定すると、sort 関数が指定された軸に沿ってデータ セットを並べ替えることができます。
2-44 ソート機能を使って並べ替える
np.random.seed(42)
arr=np.random.randint(1,10,size=10)
print('创建的数组为：\n',arr)
创建的数组为：
[7 4 8 5 7 3 7 8 5 4]
arr.sort()
print('排序后数组为：\n',arr)
排序后数组为：
[3 4 4 5 5 7 7 7 8 8]
arr=np.random.randint(1,10,size=(3,3))
#生成3行3列的数组
print('创建的数组为：\n',arr)
创建的数组为：
[[8 8 3]
[6 5 2]
[8 6 2]]
arr.sort(axis=1) #按照横轴进行排序
print('排序后数组为：\n',arr)
排序后数组为：
[[3 8 8]
[2 5 6]
[2 6 8]]
arr.sort(axis=0) #按照纵轴进行排序
print('排序后数组为：\n',arr)
排序后数组为：
[[2 5 6]
[2 6 8]
[3 8 8]]
2-45 argsort関数を使って並べ替える
argsort 関数と lexsort 関数を使用すると、1 つ以上のキーを指定すると、整数で構成されるインデックス配列を取得できます。インデックス値は、新しいシーケンス内のデータの位置を表します。
arr=np.array([2,3,6,8,0,7])
print('创建的数组为：\n',arr)
创建的数组为：
[2 3 6 8 0 7]
print('排序后的数组为：\n',arr.argsort())
#返回值为重新排序值的下标
排序后的数组为：
[4 0 1 2 5 3]
2-46 lexsort関数を使って並べ替える
lexsort 関数は、複数のキーを満たす配列に対して間接的な並べ替えを一度に実行できます。
a=np.array([3,2,6,4,5])
b=np.array([50,30,40,20,10])
c=np.array([400,300,600,100,200])
d=np.lexsort((a,b,c))
print('【排序后数组为:\n',list(zip(a[d],b[d],c[d])))
【排序后数组为:
[(4, 20, 100), (5, 10, 200), (2, 30, 300), (3, 50, 400), (6, 40, 600)]
- 重複排除と重複データ
統計分析の作業では、どうしてもダーティなデータが発生します。
重複データは、ダーティ データのケースの 1 つです。それらを 1 つずつ削除するのは非常に非効率的です。
numpy では、 unique 関数を使用して配列内で一意の値を検索し、並べ替えられた結果を返すことができます。
2-47 アレイ内のデータの重複排除
names=np.array(['小明','小黄','小花','小明','小花','小兰','小白'])
print('创建的数组为：\n',names)
创建的数组为：
['小明' '小黄' '小花' '小明' '小花' '小兰' '小白']
print('去重后的数组为：\n',np.unique(names))
去重后的数组为：
['小兰' '小明' '小白' '小花' '小黄']
print('去重后的数组为：\n',sorted(set(names)))
去重后的数组为：
['小兰', '小明', '小白', '小花', '小黄']
ints=np.array([1,2,3,4,4,5,6,6,7,8,8,9,10])
print('创建的数组为：\n',ints)
创建的数组为：
[ 1 2 3 4 4 5 6 6 7 8 8 9 10]
print('去重后的数组为:\n',np.unique(ints))
去重后的数组为:
[ 1 2 3 4 5 6 7 8 9 10]
さらに、統計分析ではデータを複数回繰り返すことも必要です。
2-48 タイル機能を利用してデータの二重化を実現する
numpyではデータの繰り返しを実現するために主にfile関数とrepeat関数が使われます。
tile 関数の形式は次のとおりです。
numpy.tile(A.reps)
A は反復配列を指定し、パラメーター reps は反復数を指定します。
arr=np.arange(5)
print(arr)
[0 1 2 3 4]
print('重复后的数组为：\n',np.tile(arr,3))
重复后的数组为：
[0 1 2 3 4 0 1 2 3 4 0 1 2 3 4]
2-49 リピート機能を使ってデータの繰り返しを実現する
繰り返し関数の形式は次のとおりです。
numpy.repeat(a,repeats,axis=None)
a は繰り返しに参加する要素を指し、repeats は繰り返しの数を指し、axis は繰り返しに沿った軸を指します。は発表された。
np.random.seed(42)
arr=np.random.randint(0,10,size=(3,3))
print(arr)
[[6 3 7]
[4 6 9]
[2 6 7]]
print('重复后的数组为：\n',arr.repeat(2,axis=0))
#沿着x轴进行重复
重复后的数组为：
[[6 3 7]
[6 3 7]
[4 6 9]
[4 6 9]
[2 6 7]
[2 6 7]]
print('重复后的数组为：\n',arr.repeat(2,axis=1))
#沿着y轴进行重复
重复后的数组为：
[[6 6 3 3 7 7]
[4 4 6 6 9 9]
[2 2 6 6 7 7]]
2 つの関数の主な違いは、tile 関数は配列に対して繰り返し演算を実行し、repeat 関数は配列内の各要素に対して繰り返し演算を実行することです。
3. 一般的に使用される統計関数
一般的な統計関数には、sum、mean、std、var、min、max などが含まれます。
ほとんどすべての統計関数は、2 次元配列を計算するときに軸の概念に注意する必要があります。
axis パラメータが 0 の場合は縦軸に沿って計算が実行されることを意味し、1 の場合は横軸に沿って計算が実行されることを意味します。ただし、デフォルトでは、この関数は軸に沿った計算は行わず、合計値を計算します。
2-50 よく使われる統計関数の使い方
arr=np.arange(20).reshape(4,5)
print(arr)
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]
[15 16 17 18 19]]
print('数组的和为：\n',np.sum(arr))
数组的和为：
190
print('数组纵轴的和为：\n',arr.sum(axis=0))
数组纵轴的和为：
[30 34 38 42 46]
print('数组横轴的和为：\n',arr.sum(axis=1))
数组横轴的和为：
[10 35 60 85]
print('数组均值为：\n',np.mean(arr))
数组均值为：
9.5
print('数组纵轴的均值为：\n',arr.mean(axis=0))
数组纵轴的均值为：
[ 7.5 8.5 9.5 10.5 11.5]
print('数组横轴的均值为：\n',arr.mean(axis=1))
数组横轴的均值为：
[ 2. 7. 12. 17.]
print('数组的标准差为：\n',np.std(arr))
数组的标准差为：
5.766281297335398
print('数组的方差为：\n',np.var(arr))
数组的方差为：
33.25
print('数组的最小值为：\n',np.min(arr))
数组的最小值为：
0
print('数组的最大值为：\n',np.max(arr))
数组的最大值为：
19
print('数组的最小值的索引为：\n',np.argmin(arr))
数组的最小值的索引为：
0
print('数组的最大值的索引为：\n',np.argmax(arr))
数组的最大值的索引为：
19
上記で使用した関数の計算はすべて集計計算であり、最終的な計算結果が直接表示されます。
2-51cumsum関数とcumprod関数の使い方
しかし、numpy では、cumsum 関数とcumprod 関数は非集計計算を使用して、中間結果で構成される配列を生成します。
arr=np.arange(2,10)
print(arr)
[2 3 4 5 6 7 8 9]
print('数组元素的累计和为：\n',np.cumsum(arr))
数组元素的累计和为：
[ 2 5 9 14 20 27 35 44]
print('数组元素的累计积为：\n',np.cumprod(arr))
数组元素的累计积为：
[ 2 6 24 120 720 5040 40320 362880]
実習
実習1 配列の作成と演算
1. トレーニングのポイント
(1) NumPyの配列作成と乱数生成をマスターする。
(2) NumPy で統計解析に使用される基本的な演算関数を習得します。
2. 要件の説明
NumPy 配列は Python が提供するリストに比べて数値演算が効率的であるため、NumPy での配列の作成や基本的な演算を柔軟に使いこなす必要があります。
3. 実装の考え方と手順
(1) 値が 0 ～ 1、間隔が 0.01 の配列を作成します。
print('1.1的结果为：\n',np.arange(0,1,0.01))
1.1的结果为：
[0. 0.01 0.02 0.03 0.04 0.05 0.06 0.07 0.08 0.09 0.1 0.11 0.12 0.13
0.14 0.15 0.16 0.17 0.18 0.19 0.2 0.21 0.22 0.23 0.24 0.25 0.26 0.27
0.28 0.29 0.3 0.31 0.32 0.33 0.34 0.35 0.36 0.37 0.38 0.39 0.4 0.41
0.42 0.43 0.44 0.45 0.46 0.47 0.48 0.49 0.5 0.51 0.52 0.53 0.54 0.55
0.56 0.57 0.58 0.59 0.6 0.61 0.62 0.63 0.64 0.65 0.66 0.67 0.68 0.69
0.7 0.71 0.72 0.73 0.74 0.75 0.76 0.77 0.78 0.79 0.8 0.81 0.82 0.83
0.84 0.85 0.86 0.87 0.88 0.89 0.9 0.91 0.92 0.93 0.94 0.95 0.96 0.97
0.98 0.99]
(2) 正規分布に従う乱数を 100 個作成します。
print('1.2的结果为：\n',np.random.randn(100))
1.2的结果为：
[-0.88523035 -0.41218848 -0.4826188 0.16416482 0.23309524 0.11799461
1.46237812 1.53871497 -2.43910582 0.60344123 -0.25104397 -0.16386712
-1.47632969 1.48698096 -0.02445518 0.35555132 0.41701111 0.83246186
-0.29339915 -0.02983857 0.09512578 0.66465434 -0.1402185 -0.0331934
-0.74907652 -0.77838201 0.94884286 1.58085059 -0.36817094 0.37556463
-1.19315823 -0.4090519 -0.44674147 1.52424163 0.3229998 -1.39341694
-2.17833425 -1.04389641 0.17269371 0.32419877 0.74585954 -1.83658324
0.56446424 0.02550067 0.47319325 0.6591906 2.34074633 1.07098519
0.09641648 0.41910211 -0.95302779 -1.0478706 -1.87567677 -1.36678214
0.63630511 -0.90672067 0.47604259 1.30366127 0.21158701 0.59704465
-0.89633518 -0.11198782 1.46894129 -1.12389833 0.9500054 1.72651647
0.45788508 -1.68428738 0.32684522 -0.08111895 0.46779475 0.73612235
-0.77970188 -0.84389636 -0.15053386 -0.96555767 0.15048908 -0.11342125
2.63352822 -1.02509089 -0.78204783 0.42394307 0.8727051 2.28722598
1.6229205 0.82373308 0.29305925 0.89663038 -0.61032202 -0.3161659
-1.48242425 -0.22884752 0.96264129 -0.20969244 -0.77404293 -0.35977815
0.72408325 -0.25576464 0.8499212 -1.31132423]
(3) 作成した 2 つの配列に対して四則演算を実行します。
print('两个数组的和为:,\n',arr1+arr2)
两个数组的和为:,
[-0.87030495 -0.49664322 -1.28995069 2.97366342 -1.0562658 0.96488432
-0.60606062 -0.44378749 0.3813228 -1.36851692 -0.56273831 -0.03647281
-0.72601702 -0.69248937 1.22672702 1.15498688 -0.28176602 0.08583491
1.41701607 -1.23647888 0.53802266 2.1845712 2.18503476 -1.70991122
-0.52262696 0.41865939 -1.06187695 -0.3982467 0.142709 1.69132156
0.25459734 0.52693673 0.83242373 0.87348869 0.36809946 -0.84708706
1.1496728 0.80148946 -0.7167523 -0.29230156 1.28751161 1.01548313
-0.30029799 0.16006623 0.29653777 1.06700378 1.7089407 0.53564916
1.64920765 1.36331697 0.70565013 -0.93348335 -0.50771086 1.27124064
-1.17052958 0.66897849 1.56048561 0.72242086 -0.02139725 -0.25661436
1.41615272 1.08170729 0.3345107 1.69529247 1.49399779 2.43859386
1.22689407 0.50549957 0.53700907 -1.2445702 0.85065904 0.69428506
-0.61007407 0.70471237 2.08316821 0.01545235 -0.19989463 1.87492822
1.4142403 3.85109521 -0.51857016 1.53038724 1.13589091 0.88928128
1.75051222 0.82027464 -1.07637621 0.02264247 2.24443345 2.0620289
0.52688081 1.41359706 3.70393805 0.8988132 0.92841668 1.14059871
1.56697571 0.62109882 1.58612936 -0.95422959]
print('两个数组的差为:,\n',arr1-arr2)
两个数组的差为:,
[ 0.87030495 0.51664322 1.32995069 -2.91366342 1.1362658 -0.86488432
0.72606062 0.58378749 -0.2213228 1.54851692 0.76273831 0.25647281
0.96601702 0.95248937 -0.94672702 -0.85498688 0.60176602 0.25416509
-1.05701607 1.61647888 -0.13802266 -1.7645712 -1.74503476 2.16991122
1.00262696 0.08134061 1.58187695 0.9382467 0.417291 -1.11132156
0.34540266 0.09306327 -0.19242373 -0.21348869 0.31190054 1.54708706
-0.4296728 -0.06148946 1.4767523 1.07230156 -0.48751161 -0.19548313
1.14029799 0.69993377 0.58346223 -0.16700378 -0.7889407 0.40435084
-0.68920765 -0.38331697 0.29434987 1.95348335 1.54771086 -0.21124064
2.25052958 0.43102151 -0.44048561 0.41757914 1.18139725 1.43661436
-0.21615272 0.13829271 0.9054893 -0.43529247 -0.21399779 -1.13859386
0.09310593 0.83450043 0.82299093 2.6245702 0.54934096 0.72571494
2.05007407 0.75528763 -0.60316821 1.48454765 1.71989463 -0.33492822
0.1457597 -2.27109521 2.11857016 0.08961276 0.50410909 0.77071872
-0.07051222 0.87972536 2.79637621 1.71735753 -0.48443345 -0.2820289
1.27311919 0.40640294 -1.86393805 0.9611868 0.95158332 0.75940129
0.35302429 1.31890118 0.37387064 2.93422959]
print('两个数组的积为:,\n',arr1*arr2)
两个数组的积为:,
[-0. -0.00506643 -0.02619901 0.0883099 -0.04385063 0.04574422
-0.03996364 -0.03596512 0.02410582 -0.13126652 -0.06627383 -0.01611201
-0.10152204 -0.10692362 0.15214178 0.15074803 -0.07068256 -0.01430806
0.22266289 -0.27103099 0.06760453 0.41465995 0.43230765 -0.44617958
-0.18303047 0.04216485 -0.34368801 -0.18042661 -0.03844148 0.40638325
-0.0136208 0.06725039 0.16397559 0.17935127 0.00955382 -0.41898047
0.28428221 0.1596511 -0.41676587 -0.26609761 0.35500465 0.24824808
-0.30252516 -0.11607152 -0.06312338 0.2776517 0.57451272 0.0308551
0.56121967 0.42792531 0.10282507 -0.73617651 -0.53440965 0.39285754
-0.92368597 0.06543817 0.56027194 0.08687989 -0.3488104 -0.49950247
0.48969163 0.28774145 -0.17700337 0.67113426 0.54655858 1.16258601
0.37415009 -0.11021529 -0.09723384 -1.33485343 0.10546133 -0.01115761
-0.95765333 -0.01845997 0.99394448 -0.55091074 -0.72951992 0.85079473
0.49470743 2.41826522 -1.05485613 0.58351367 0.25903054 0.04920347
0.76483026 -0.02526655 -1.66528354 -0.73720105 1.20070143 1.04310572
-0.33580727 0.45827333 2.561223 -0.02900372 -0.01088832 0.18106877
0.58269668 -0.33843415 0.59400678 -1.9247873 ]
print('两个数组的商为:,\n',arr1/arr2)
两个数组的商为:,
[-0.00000000e+00 -1.97377555e-02 -1.52677503e-02 1.01913826e-02
-3.64875016e-02 5.46517180e-02 -9.00818907e-02 -1.36243099e-01
2.65496005e-01 -6.17065176e-02 -1.50889119e-01 -7.50992641e-01
-1.41841119e-01 -1.58056754e-01 1.28827200e-01 1.49255680e-01
-3.62182675e-01 -2.01983993e+00 1.45511448e-01 -1.33195102e-01
5.91676311e-01 1.06352205e-01 1.11957307e-01 -1.18562127e-01
-3.14701697e-01 1.48227741e+00 -1.96690017e-01 -4.04042400e-01
-2.03946357e+00 2.06947504e-01 -6.60754306e+00 1.42898810e+00
6.24483176e-01 6.07188347e-01 1.20998752e+01 -2.92376395e-01
4.55885017e-01 8.57494867e-01 -3.46477505e-01 -5.71594762e-01
4.50698327e-01 6.77145207e-01 -5.83092004e-01 -1.59298335e+00
-3.06700935e+00 7.29331031e-01 3.68312123e-01 7.15926927e+00
4.10534434e-01 5.61079216e-01 2.43131376e+00 -3.53312007e-01
-5.05978888e-01 7.15017465e-01 -3.15691706e-01 4.62268425e+00
5.59728192e-01 3.73964555e+00 -9.64420779e-01 -6.96893450e-01
7.35156525e-01 1.29317484e+00 -2.17171011e+00 5.91386890e-01
7.49416462e-01 3.63413973e-01 1.16423867e+00 -4.07293758e+00
-4.75554623e+00 -3.56668371e-01 4.64625278e+00 -4.51799375e+01
-5.41323238e-01 -2.88678744e+01 5.50936207e-01 -1.02103655e+00
-7.91753568e-01 6.96877849e-01 1.22981779e+00 2.58077565e-01
-6.06717810e-01 1.12439526e+00 2.59583287e+00 1.40010463e+01
9.22557636e-01 -2.85951143e+01 -4.44128571e-01 -1.02672127e+00
6.44956338e-01 7.59366938e-01 -2.41209786e+00 1.80700021e+00
3.30467124e-01 -2.98203103e+01 -8.11511741e+01 4.98429409e+00
1.58161189e+00 -2.78015681e+00 1.61681657e+00 -5.09199121e-01]
(4) 作成したランダム配列に対して簡単な統計解析を行います。
print('1.4的统计分析结果的数组和为：\n',np.sum(arr2))
1.4的统计分析结果的数组和为：
6.7340096554519
print('1.4的统计分析结果的均值为：\n',np.mean(arr2))
1.4的统计分析结果的均值为：
0.067340096554519
print('1.4的统计分析结果的标准差为：\n',np.std(arr2))
1.4的统计分析结果的标准差为：
1.0449116390258357
print('1.4的统计分析结果的方差为：\n',np.var(arr2))
1.4的统计分析结果的方差为：
1.0918403333716586
print('1.4的统计分析结果的最小值为：\n',np.min(arr2))
1.4的统计分析结果的最小值为：
-1.9442295937495997
print('1.4的统计分析结果的最小值为：\n',np.max(arr2))
1.4的统计分析结果的最小值为：
3.06109521437826
実習２ チェス盤を作る
1. 研修のポイント
(1) マトリックスの作成方法を習得する。(2) 配列のインデックス付けの方法をマスターします。
2. 要件の説明
チェス盤を作成し、8x8 のマトリックスを記入します。チェス盤は正方形で、縦横 8 個の小さな正方形と、濃い色と明るい色の 1 色ずつが交互に配置された 64 個の小さな正方形で構成されています。暗い色の正方形は黒い正方形で、明るい色の正方形は白い正方形です。チェスの駒はこれらの正方形内を移動します。 、図 2-3 に示すように。
3. 実装の考え方と手順
(1) 8x8 の行列を作成します。
(2) 1、3、5、7行目、2、4、6列目の要素を1に設定します。
cheese=np.zeros((8,8),dtype=int)
print(cheese)
[[0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0]]
cheese[1::2,::2]=1
print(cheese)
[[0 0 0 0 0 0 0 0]
[1 0 1 0 1 0 1 0]
[0 0 0 0 0 0 0 0]
[1 0 1 0 1 0 1 0]
[0 0 0 0 0 0 0 0]
[1 0 1 0 1 0 1 0]
[0 0 0 0 0 0 0 0]
[1 0 1 0 1 0 1 0]]
cheese[::2,1::2]=1
print(cheese)
[[0 1 0 1 0 1 0 1]
[1 0 1 0 1 0 1 0]
[0 1 0 1 0 1 0 1]
[1 0 1 0 1 0 1 0]
[0 1 0 1 0 1 0 1]
[1 0 1 0 1 0 1 0]
[0 1 0 1 0 1 0 1]
[1 0 1 0 1 0 1 0]]