## 1.以管理员的形式打开
##2.输入命令安装numpy拆件
## 3.数据创建
创建的时候一定要导包
import numpy as np
3.1使用array创建
"""
numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
"""
#使用array创建一维数组
import numpy as np
list01 = [1,2,3,4]
np01 = np.array(list01)
print(np01)
print(type(np01))
#使用array创建二维数组
list02 = [[1,2,3,4],[5,6,7,8]]
np02 = np.array(list02)
print(np02)
print(type(np02))
#使用array创建三维数组
list03 = [[[1,2,3,4],[5,6,7,8],[9,10,11,12]]]
np03 = np.array(list03)
print(np03)
print(type(np03))
3.2使用arange创建
语法：
range(start,stop,step) 函数可创建一个整数列表
1.不写start，默认从0开始
2.左开右闭
3.step步长，不写默认是1
#一维数组
a = np.arange(10) #[0 1 2 3 4 5 6 7 8 9]
a = np.arange(2,10) #[2 3 4 5 6 7 8 9]
a = np.arange(1,10,2) #[1 3 5 7 9]
a = np.arange(1,10,2,dtype=float)
print(a)
#二维数组
#切记前面的12，必须满足3*4
np01 = np.arange(12).reshape(3, 4)
print(np01)
4.使用 random 创建数组
常用的random函数
import numpy as np
3.1使用array创建
"""
numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
"""
#使用array创建一维数组
import numpy as np
list01 = [1,2,3,4]
np01 = np.array(list01)
print(np01)
print(type(np01))
#使用array创建二维数组
list02 = [[1,2,3,4],[5,6,7,8]]
np02 = np.array(list02)
print(np02)
print(type(np02))
#使用array创建三维数组
list03 = [[[1,2,3,4],[5,6,7,8],[9,10,11,12]]]
np03 = np.array(list03)
print(np03)
print(type(np03))
3.2使用arange创建
语法：
range(start,stop,step) 函数可创建一个整数列表
1.不写start，默认从0开始
2.左开右闭
3.step步长，不写默认是1
#一维数组
a = np.arange(10) #[0 1 2 3 4 5 6 7 8 9]
a = np.arange(2,10) #[2 3 4 5 6 7 8 9]
a = np.arange(1,10,2) #[1 3 5 7 9]
a = np.arange(1,10,2,dtype=float)
print(a)
#二维数组
#切记前面的12，必须满足3*4
np01 = np.arange(12).reshape(3, 4)
print(np01)
4.使用 random 创建数组
常用的random函数
numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
"""
#使用array创建一维数组
import numpy as np
list01 = [1,2,3,4]
np01 = np.array(list01)
print(np01)
print(type(np01))
#使用array创建二维数组
list02 = [[1,2,3,4],[5,6,7,8]]
np02 = np.array(list02)
print(np02)
print(type(np02))
#使用array创建三维数组
list03 = [[[1,2,3,4],[5,6,7,8],[9,10,11,12]]]
np03 = np.array(list03)
print(np03)
print(type(np03))
3.2使用arange创建
语法：
range(start,stop,step) 函数可创建一个整数列表
1.不写start，默认从0开始
2.左开右闭
3.step步长，不写默认是1
#一维数组
a = np.arange(10) #[0 1 2 3 4 5 6 7 8 9]
a = np.arange(2,10) #[2 3 4 5 6 7 8 9]
a = np.arange(1,10,2) #[1 3 5 7 9]
a = np.arange(1,10,2,dtype=float)
print(a)
#二维数组
#切记前面的12，必须满足3*4
np01 = np.arange(12).reshape(3, 4)
print(np01)
4.使用 random 创建数组
常用的random函数
list02 = [[1,2,3,4],[5,6,7,8]] np02 = np.array(list02) print(np02) print(type(np02))
#使用array创建三维数组
list03 = [[[1,2,3,4],[5,6,7,8],[9,10,11,12]]]
np03 = np.array(list03)
print(np03)
print(type(np03))
3.2使用arange创建
语法：
range(start,stop,step) 函数可创建一个整数列表
1.不写start，默认从0开始
2.左开右闭
3.step步长，不写默认是1
#一维数组
a = np.arange(10) #[0 1 2 3 4 5 6 7 8 9]
a = np.arange(2,10) #[2 3 4 5 6 7 8 9]
a = np.arange(1,10,2) #[1 3 5 7 9]
a = np.arange(1,10,2,dtype=float)
print(a)
#二维数组
#切记前面的12，必须满足3*4
np01 = np.arange(12).reshape(3, 4)
print(np01)
4.使用 random 创建数组
常用的random函数
语法：
range(start,stop,step) 函数可创建一个整数列表
1.不写start，默认从0开始
2.左开右闭
3.step步长，不写默认是1
#一维数组
a = np.arange(10) #[0 1 2 3 4 5 6 7 8 9]
a = np.arange(2,10) #[2 3 4 5 6 7 8 9]
a = np.arange(1,10,2) #[1 3 5 7 9]
a = np.arange(1,10,2,dtype=float)
print(a)
#二维数组
#切记前面的12，必须满足3*4
np01 = np.arange(12).reshape(3, 4)
print(np01)
4.使用 random 创建数组
常用的random函数
a = np.arange(10) #[0 1 2 3 4 5 6 7 8 9] a = np.arange(2,10) #[2 3 4 5 6 7 8 9] a = np.arange(1,10,2) #[1 3 5 7 9] a = np.arange(1,10,2,dtype=float) print(a)
#二维数组
#切记前面的12，必须满足3*4
np01 = np.arange(12).reshape(3, 4)
print(np01)
4.使用 random 创建数组
常用的random函数
常用的random函数
| 函数 | 描述 |
|---|---|
| np.random.random(size) | 生成0到1之间的随机数 |
| np.random.randint(low,high=None,size=None,dtype="1") | 生成随机的整数 |
| np.random.randn(d0,d1,d2,d3.........) | 生成标准正态的随机数(期望为0，方差为1) |
| np.random.normal(loc,scale,size) | 生成正态分布(指定期望和方差) |
| np.random.uniform(low,high,size) | 生成均勻分布的随机数 |
| np.random.shuffle() | 随机打乱顺序 |
| np.random.seed() | 设置随机数种子 |
| np.random.sample(size) | 生成随机的浮点数 |
# np.random.random() 生成0到1之间的随机数
#创建一维数组 size生成几个数据，可直接写4
np01= np.random.random(size=4) #[0.13475357 0.8088961 0.52055803 0.49706622]
#创建二维数组 size=(3,4) 3行4列 可用()和[] ,效果一样
np01= np.random.random((3,4))
#创建三维数组 两个三行四列
np01= np.random.random((2,3,4))
print(np01)
np.random.randint(low,high=None,size=None,dtype="1") 生成随机的整数
low:开始
high=None ：结束
size：长度
dtype数据类型,默认是int32 no01.dtype属性
1.左开右闭
2.不写low默认是0
#创建一维数组
np01= np.random.randint(1,11,10)#1-10
#创建二维数组
np01= np.random.randint(1,11,(3,4))#1-10
#创建三维数组
np01= np.random.randint(1,11,(2,3,4))#1-10
print(np01)
数据的索引和切片
一维数组的索引
list01= [1,2,3,4,5]
np01 = np.array(list01,dtype="int32")
print(np01)
正向递增索引 从0开始
1, 2, 3, 4, 5 数据
0 1 2 3 4 索引
1.左开右闭
2.不写startIndex默认从0开始
np01= np.random.random((3,4))
#创建三维数组 两个三行四列
np01= np.random.random((2,3,4))
print(np01)
np.random.randint(low,high=None,size=None,dtype="1") 生成随机的整数
low:开始
high=None ：结束
size：长度
dtype数据类型,默认是int32 no01.dtype属性
1.左开右闭
2.不写low默认是0
#创建一维数组
np01= np.random.randint(1,11,10)#1-10
#创建二维数组
np01= np.random.randint(1,11,(3,4))#1-10
#创建三维数组
np01= np.random.randint(1,11,(2,3,4))#1-10
print(np01)
数据的索引和切片
一维数组的索引
list01= [1,2,3,4,5]
np01 = np.array(list01,dtype="int32")
print(np01)
正向递增索引 从0开始
1, 2, 3, 4, 5 数据
0 1 2 3 4 索引
1.左开右闭
2.不写startIndex默认从0开始
np01= np.random.randint(1,11,10)#1-10
#创建二维数组
np01= np.random.randint(1,11,(3,4))#1-10
#创建三维数组
np01= np.random.randint(1,11,(2,3,4))#1-10
print(np01)
数据的索引和切片
一维数组的索引
list01= [1,2,3,4,5]
np01 = np.array(list01,dtype="int32")
print(np01)
正向递增索引 从0开始
1, 2, 3, 4, 5 数据
0 1 2 3 4 索引
1.左开右闭
2.不写startIndex默认从0开始
np01= np.random.randint(1,11,(2,3,4))#1-10 print(np01)数据的索引和切片 一维数组的索引
list01= [1,2,3,4,5] np01 = np.array(list01,dtype="int32") print(np01)
正向递增索引 从0开始 1, 2, 3, 4, 5 数据 0 1 2 3 4 索引 1.左开右闭 2.不写startIndex默认从0开始
print(np01[0]) #1 print(np01[1:4]) #[2 3 4] print(np01[1:5]) #[2 3 4 5] print(np01[:5]) #[1 2 3 4 5]
反向递减索引 从-1开始 1, 2, 3, 4, 5 数据 -5 -4 -3 -2 -1 索引 1.左开右闭 2.不写startIndex默认从0开始
print(np01[-1]) #5 print(np01[-5:-1]) #[1 2 3 4] print(np01[-5:]) #[1 2 3 4 5]一维数组的切片
语法[start:stop:step]
list01= [1,2,3,4,5] np01 = np.array(list01,dtype="int32") print(np01)#正向索引切片
print(np01[:])#从0到0 print(np01[3:])#从3开始到结尾 print(np01[:5])#从0开始到5结尾 print(np01[1:5:2])#步长是2#反向索引切片
print(np01[::-1])#-1证明是反向获取 print(np01[-5:-2])#正负一起使用
print(np01[-5:4]) #[1 2 3 4]二维数组的索引 #创建二维数组
list01= [
[1,2],
[3,4],
[5,6],
[7,8]
]
np01= np.array(list01)
print(np01)
#print(np01.ndim) #查看维数
print(np01[1])#获取第二行
print(np01[1][1])#获取第二行第一列
二维数组的切片
[对行进行切片,对列的切片]
对行的切片：可以有start:stop:step
对列的切片：可以有start:stop:step
list01= [
[1,2],
[3,4],
[5,6],
[7,8]
]
np01= np.array(list01)
print(np01)
print(np01[:,:])#所有行所有列
#所有行部分列
print(np01[:,1])#所有行第二列
print(np01[:,0:2])#所有行的第一列和第二列
#部分列所有行
print(np01[1,:])#获取第二行所有列
print(np01[0:2,:])#获取第一和二行所有列
print(np01[::2,:])#获取奇数行所有列
#部分行部分列
print(np01[1,1])#第二行第二列
#组合使用的时候改怎么办
#获取第三行第二列(6)，第四行第一列(7)
#行写成元组放在前面，列写成元组放在后面
a= np01[(2,3),(1,0)]
print(a)
#负索引的使用
print(np01[-1])#最后一行
print(np01[::-1])#行倒序
print(np01[::-1,::-1])#行倒序,列倒叙
##数组索引机制
#基础索引
#一维数组的索引和切片
# 索引：
# 正向递增，反向递减
# 语法 ：np01[index]
# 根据索引查询：np01[index]
# 根据索引修改数据 ：np01[index]=值
# 切片：
# 一正一负， 一负一正 左开右闭 从左到右有区间
# 语法：np01[index_01 : index_02]
（索引） np01=np.array([1,2,3,4,5,6,7,]) np01[4]=10 np01[-6]=10 print(np01)
（切片） np01=np.array([1,2,6,8,9,3,4,5,6,7]) print(np01[1:6]) #[2 6 8 9 3] print(np01[-9:-4]) print(np01[1:-4]) print(np01[-9:-6])##二维数组的索引和切片 # 索引： # 语法：np02[行] [列] # 查询和修改数据 # 切片： # 语法：np02[行_01 : 行_02 ,列_01 :列_02 ]
#切片（行）
list01=[
[1,5,6,7],
[1,2,3,4],
[9,8,7,1],
[7,6,5,9]
]
np02=np.array(list01)
print(np02[2][1])
#二位切片（列）
list01=[
[1,5,6,7],
[1,2,3,4],
[9,8,7,5],
[7,6,5,9]
]
np02=np.array(list01)
print(np02[:,1:3])
print(np02[-2:,-2:])
#### 高级索引
# 一维数组的高级索引
#语法：np01[索引数组]
np01=np.array([9,8,7,6,5,4,3,2,1,0])
#8 4 1
print(" ---------------基础索引 ------------")
print(np01[1]) #8
print(np01[5]) #4
print(np01[8]) #5
print(" --------高级索引 --------------------")
index01=np.array([1,5,8]) #1创建一个索引数组
print(np01[index01])
#二维数组的高级索引
# 1. 语法：np01[行索引数组,列索引数组]
# 2. 语法：np01[list,list]
# 3. 语法：np01[list,数组] np01[数组,list]
# 4. 语法：np01[元组，切片]
##索引
np02=np.arange(5,25).reshape(4,5) #创建二维数组
print(np02)
print("----------------------基础索引------------")
np02[0,1] #6
np02[1,2] #12
np02[2,3] #18
np02[3,4] #24
print("------------1. 高级索引-----------------")
row_index=np.array([0,1,2,3]) #行
col_index=np.array([1,2,3,4]) #列
print(np02[row_index,col_index]) #[ 6 12 18 24]
print("------------2. 使用list-----------------")
row_list=[0,1,2,3]
col_list=[1,2,3,4]
print(np02[row_list,col_list]) #[ 6 12 18 24]
print("--------------- 3.list和数组混合使用------------------------------")
print(np02[row_index,col_list]) #[ 6 12 18 24]
print(np02[row_list,col_index]) #[ 6 12 18 24]
##切片
np02=np.arange(5,25).reshape(4,5) #创建二维数组
print(np02)
[[ 5 6 7 8 9]
[10 11 12 13 14]
[15 16 17 18 19]
[20 21 22 23 24]]
6 7 8 9 11 12 13 14
'''
'''
print("-----------------基础切片------------")
print(np02[0:2,1:5]) #0:2 第一行到第三行
print("--------------高级切片--元组和切片---------------")
tuple01 = (0,1)#第一行和第二行
print(np02[tuple01,1:5])
#6 7 8 16 17 18
print(np02[tuple01,1:5])
tuple02=(0,2)#第一行到第三行
print(np02[tuple02,1:4])
# 布尔索引 False True
#一维数组的布尔索引：
# 利用布尔索引获取值：
# 1.False,不获取 True:获取
# 2.和比较运算符进行结合使用
#二维数组的布尔索引：
# 1.np.ix_(行布尔索引，列布尔索引) 计算笛卡尔乘积
# 2.np02[笛卡尔乘积]
#一维数组的布尔索引
np01=np.array([9,8,7,6,0,-4,-3,-2,-1,0])
#6
print("基础索引")
print(np01[3])#6
print("布尔索引")
index01=np.array([False,False,False,True,False,False,False,False,False,False])
print(np01[index01])#6
#8,-1
#index02=np.array([False,True,False,False,False,False,False,False,True,False])
#print(np01[index02]) #[ 8 -1]
#要所有小于0的数据[-4,-3,-2,-1]
index02=np.array([False,False,False,False,False,True,True,True,True,False])
boolean_index=np01<0
print(np01[boolean_index])
#二维数组的布尔索引：
# 1.np.ix_(行布尔索引，列布尔索引) 计算笛卡尔乘积
# 2.np02[笛卡尔乘积]
np02=np.arange(5,25).reshape(4,5)
print(np02)
'''
"""
[[ 5 6 7 8 9]
[10 11 12 13 14]
[15 16 17 18 19]
[20 21 22 23 24]]
6,7,8 11,12,13
print("-----------基础索引--------")
print(np02[0:2,1:4])
print("---------------高级索引---数组----")
row_index=np.array([0,1])
col_index=np.array([1,2,3])
print("-------------布尔索引----------")
row_index=np.array([True,True,False,False]) #4行
col_index=np.array([False,True,True,True,False])#5列
boolean01=np.ix_(row_index,col_index) #1笛卡尔乘积
print(np02[boolean01]) #[[ 6 7 8] [11 12 13]]
