NumPy数组是一个多维数组对象,称为ndarray。其由两部分组成:
① 实际的数据
② 描述这些数据的元数据
# 导入模块
import numpy as np
① 数组的维数称为秩(rank),一维数组的秩为1,二维数组的秩为2,以此类推
② 在NumPy中,每一个线性的数组称为是一个轴(axes),秩其实是描述轴的数量:比如说,二维数组相当于是两个一维数组,其中第一个一维数组中每个元素又是一个一维数组,所以一维数组就是NumPy中的轴(axes),第一个轴相当于是底层数组,第二个轴是底层数组里的数组。而轴的数量——秩,就是数组的维数。
ar = np.array([1,2,3,4,5,6,7])
print(ar) # 输出数组,注意数组的格式:中括号,元素之间没有逗号(和列表区分)
>>> [1 2 3 4 5 6 7]
print(ar.ndim) # 输出数组维度的个数(轴数),或者说“秩”,维度的数量也称rank
>>> 1
print(ar.shape) # 数组的维度,对于n行m列的数组,shape为(n,m)
>>> (7,)
print(ar.size) # 数组的元素总数,对于n行m列的数组,元素总数为n*m
>>> 7
print(ar.dtype) # 数组中元素的类型,类似type()(注意了,type()是函数,.dtype是方法)
>>> int64
print(ar.itemsize) # 数组中每个元素的字节大小,int64类型字节为8,float64的字节为8
>>> 8
print(ar.data) # 包含实际数组元素的缓冲区,由于一般通过数组的索引获取元素,所以通常不需要使用这个属性。
>>> <memory at 0x0000000005927108>
array()
函数括号内可以是列表、元祖、数组、生成器等
ar1 = np.array(range(10)) # 整型
ar2 = np.array([1,2,3.14,4,5]) # 浮点型
ar3 = np.array([[1,2,3],('a','b','c')]) # 二维数组:嵌套序列(列表,元祖均可)
ar4 = np.array([[1,2,3],('a','b','c','d')]) # 注意嵌套序列数量不一会怎么样
print(ar1,type(ar1),ar1.dtype)
>>> [0 1 2 3 4 5 6 7 8 9] <class 'numpy.ndarray'> int64
print(ar2,type(ar2),ar2.dtype)
>>> [ 1. 2. 3.14 4. 5. ] <class 'numpy.ndarray'> float64
print(ar3,ar3.shape,ar3.ndim,ar3.size) # 二维数组,共6个元素
>>> [['1' '2' '3']
['a' 'b' 'c']] (2, 3) 2 6
print(ar4,ar4.shape,ar4.ndim,ar4.size) # 一维数组,共2个元素
>>> [[1, 2, 3] ('a', 'b', 'c', 'd')] (2,) 1 2
arange()
函数类似range(),在给定间隔内返回均匀间隔的值
print(np.arange(10)) # 返回0-9,整型
>>> [0 1 2 3 4 5 6 7 8 9]
print(np.arange(10.0)) # 返回0.0-9.0,浮点型
>>> [ 0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]
print(np.arange(5,12)) # 返回5-11
>>> [ 5 6 7 8 9 10 11]
print(np.arange(5.0,12,2)) # 返回5.0-12.0,步长为2
>>> [ 5. 7. 9. 11.]
print(np.arange(10000)) # 如果数组太大而无法打印,NumPy会自动跳过数组的中心部分,并只打印边角
>>> [ 0 1 2 ..., 9997 9998 9999]
linspace()
函数返回在间隔[开始,停止]上计算的num个均匀间隔的样本
numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
- start:起始值,stop:结束值
- num:生成样本数,默认为50
- endpoint:如果为真,则停止是最后一个样本。否则,不包括在内。默认值为True
- retstep:如果为真,返回(样本,步长),其中步长是样本之间的间距 → 输出为一个包含2个元素的元祖,第一个元素为array,第二个为步长实际值
ar1 = np.linspace(2.0, 3.0, num=5)
ar2 = np.linspace(2.0, 3.0, num=5, endpoint=False)
ar3 = np.linspace(2.0, 3.0, num=5, retstep=True)
print(ar1,type(ar1))
>>> [ 2. 2.25 2.5 2.75 3. ] <class 'numpy.ndarray'>
print(ar2)
>>> [ 2. 2.2 2.4 2.6 2.8]
print(ar3,type(ar3))
>>> (array([ 2. , 2.25, 2.5 , 2.75, 3. ]), 0.25) <class 'tuple'>
zeros()
/zeros_like()numpy.zeros(shape, dtype=float, order=‘C’):返回给定形状和类型的新数组,用零填充。
- shape:数组纬度,二维以上需要用(),且输入参数为整数
- dtype:数据类型,默认numpy.float64
- order:是否在存储器中以C或Fortran连续(按行或列方式)存储多维数据。
ar1 = np.zeros(5)
ar2 = np.zeros((2,2), dtype = np.int)
print(ar1,ar1.dtype)
>>> [ 0. 0. 0. 0. 0.] float64
print(ar2,ar2.dtype)
>>> [[0 0]
[0 0]] int64
ar3 = np.array([list(range(5)),list(range(5,10))])
ar4 = np.zeros_like(ar3)
print(ar3)
>>> [[0 1 2 3 4]
[5 6 7 8 9]]
print(ar4)
>>> [[0 0 0 0 0]
[0 0 0 0 0]]
# 返回具有与给定数组相同的形状和类型的零数组,这里ar4根据ar3的形状和dtype创建一个全0的数组
ones()
/ones_like()
#ones()/ones_like()和zeros()/zeros_like()一样,只是填充为1
ar5 = np.ones(9)
ar6 = np.ones((2,3,4))
ar7 = np.ones_like(ar3)
print(ar5)
>>> [ 1. 1. 1. 1. 1. 1. 1. 1. 1.]
print(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.]]]
print(ar7)
>>> [[1 1 1 1 1]
[1 1 1 1 1]]
eye()
print(np.eye(5))
# 创建一个正方的N*N的单位矩阵,对角线值为1,其余为0
>>> [[ 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.]]
.T/.reshape()/.resize()
.T方法:转置,例如原shape为(3,4)/(2,3,4),转置结果为(4,3)/(4,3,2) → 所以一维数组转置后结果不变
numpy.reshape(a, newshape, order=‘C’):为数组提供新形状,而不更改其数据,所以元素数量需要一致!!!
numpy.resize(a, new_shape):返回具有指定形状的新数组,如有必要可重复填充所需数量的元素
注意了:.T/.reshape()/.resize()都是生成新的数组!!!
# .T方法
ar1 = np.arange(10)
ar2 = np.ones((5,2))
print(ar1,'\n',ar1.T)
>>> [0 1 2 3 4 5 6 7 8 9]
[0 1 2 3 4 5 6 7 8 9]
print(ar2,'\n',ar2.T)
>>> [[ 1. 1.]
[ 1. 1.]
[ 1. 1.]
[ 1. 1.]
[ 1. 1.]]
# .reshape()
ar3 = ar1.reshape(2,5) # 用法1:直接将已有数组改变形状
ar4 = np.zeros((4,6)).reshape(3,8) # 用法2:生成数组后直接改变形状
ar5 = np.reshape(np.arange(12),(3,4)) # 用法3:参数内添加数组,目标形状
print(ar1,'\n',ar3)
>>> [0 1 2 3 4 5 6 7 8 9]
>>> [[0 1 2 3 4]
[5 6 7 8 9]]
print(ar4)
>>> [[ 0. 0. 0. 0. 0. 0. 0. 0.]
[ 0. 0. 0. 0. 0. 0. 0. 0.]
[ 0. 0. 0. 0. 0. 0. 0. 0.]]
print(ar5)
>>> [[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
# .resize()
ar6 = np.resize(np.arange(5),(3,4))
print(ar6)
>>> [[0 1 2 3]
[4 0 1 2]
[3 4 0 1]]
copy()
ar1 = np.arange(10)
ar2 = ar1
print(ar2 is ar1)
>>> True
ar1[2] = 9
print(ar1,ar2)
>>> [0 1 9 3 4 5 6 7 8 9] [0 1 9 3 4 5 6 7 8 9]
# 回忆python的赋值逻辑:指向内存中生成的一个值 → 这里ar1和ar2指向同一个值,所以ar1改变,ar2一起改变
# copy方法生成数组及其数据的完整拷贝
ar3 = ar1.copy()
print(ar3 is ar1)
>>> False
ar1[0] = 9
print(ar1,ar3)
>>> [9 1 9 3 4 5 6 7 8 9] [0 1 9 3 4 5 6 7 8 9]
.astype()
ar1 = np.arange(10,dtype=float)
print(ar1,ar1.dtype)
>>> [ 0. 1. 2. 3. 4. 5. 6. 7. 8. 9.] float64
# 可以在参数位置设置数组类型
ar2 = ar1.astype(np.int64)
print(ar2,ar2.dtype)
>> [0 1 2 3 4 5 6 7 8 9] int64
print(ar1,ar1.dtype)
>>> [ 0. 1. 2. 3. 4. 5. 6. 7. 8. 9.] float64
# a.astype():转换数组类型
# 注意:养成好习惯,数组类型用np.int64,而不是直接int64
.hstack()/.vstack()/.stack()
# numpy.hstack(tup):水平(按列顺序)堆叠数组
a = np.arange(5) # a为一维数组,5个元素
b = np.arange(5,9) # b为一维数组,4个元素
ar1 = np.hstack((a,b)) # 注意:((a,b)),这里形状可以不一样
print(a,a.shape)
print(b,b.shape)
print(ar1,ar1.shape)
>>> [0 1 2 3 4] (5,)
>>> [5 6 7 8] (4,)
>>> [0 1 2 3 4 5 6 7 8] (9,)
a = np.array([[1],[2],[3]]) # a为二维数组,3行1列
b = np.array([['a'],['b'],['c']]) # b为二维数组,3行1列
ar2 = np.hstack((a,b)) # 注意:((a,b)),这里形状必须一样
print(a,a.shape)
print(b,b.shape)
print(ar2,ar2.shape)
>>> [[1]
[2]
[3]] (3, 1)
>>> [['a']
['b']
['c']] (3, 1)
>>> [['1' 'a']
['2' 'b']
['3' 'c']] (3, 2)
# numpy.vstack(tup):垂直(按列顺序)堆叠数组
a = np.arange(5)
b = np.arange(5,10)
ar1 = np.vstack((a,b))
print(a,a.shape)
print(b,b.shape)
print(ar1,ar1.shape)
>>> [0 1 2 3 4] (5,)
>>> [5 6 7 8 9] (5,)
>>> [[0 1 2 3 4]
[5 6 7 8 9]] (2, 5)
a = np.array([[1],[2],[3]])
b = np.array([['a'],['b'],['c'],['d']])
ar2 = np.vstack((a,b)) # 这里形状可以不一样
print(a,a.shape)
print(b,b.shape)
print(ar2,ar2.shape)
>>> [[1]
[2]
[3]] (3, 1)
>>> [['a']
['b']
['c']
['d']] (4, 1)
>>> [['1']
['2']
['3']
['a']
['b']
['c']
['d']] (7, 1)
# numpy.stack(arrays, axis=0):沿着新轴连接数组的序列,形状必须一样!
a = np.arange(5)
b = np.arange(5,10)
ar1 = np.stack((a,b))
ar2 = np.stack((a,b),axis = 1)
print(a,a.shape)
print(b,b.shape)
print(ar1,ar1.shape)
print(ar2,ar2.shape)
>>> [0 1 2 3 4] (5,)
>>> [5 6 7 8 9] (5,)
>>> [[0 1 2 3 4]
[5 6 7 8 9]] (2, 5)
>>> [[0 5]
[1 6]
[2 7]
[3 8]
[4 9]] (5, 2)
# 重点解释axis参数的意思,假设两个数组[1 2 3]和[4 5 6],shape均为(3,0)
# axis=0:[[1 2 3] [4 5 6]],shape为(2,3)
# axis=1:[[1 4] [2 5] [3 6]],shape为(3,2)
numpy.hsplit(ary, indices_or_sections):将数组水平(逐列)拆分为多个子数组 → 按列拆分
numpy.vsplit(ary, indices_or_sections)::将数组垂直(行方向)拆分为多个子数组 → 按行拆
输出结果为列表,列表中元素为数组
ar = np.arange(16).reshape(4,4)
ar1 = np.hsplit(ar,2)
ar2 = np.vsplit(ar,4)
print(ar)
>>> [[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
print(ar1,type(ar1))
>>> [array([[ 0, 1],
[ 4, 5],
[ 8, 9],
[12, 13]]),
array([[ 2, 3],
[ 6, 7],
[10, 11],
[14, 15]])] <class 'list'>
print(ar2,type(ar2))
>>> [array([[0, 1, 2, 3]]),
array([[4, 5, 6, 7]]),
array([[ 8, 9, 10, 11]]),
array([[12, 13, 14, 15]])] <class 'list'>
# 数组简单运算
ar = np.arange(6).reshape(2,3)
print(ar)
>>> [[0 1 2]
[3 4 5]]
print(ar + 10) # 加法
>>> [[10 11 12]
[13 14 15]]
print(ar * 2) # 乘法
>>> [[ 0 2 4]
[ 6 8 10]]
print(1 / (ar+1)) # 除法
>>> [[ 1. 0.5 0.33333333]
[ 0.25 0.2 0.16666667]]
print(ar ** 0.5) # 幂
>>> [[ 0. 1. 1.41421356]
[ 1.73205081 2. 2.23606798]]
# 与标量的运算
print(ar.mean()) # 求平均值
>>> 2.5
print(ar.max()) # 求最大值
>>> 5
print(ar.min()) # 求最小值
>>> 0
print(ar.std()) # 求标准差
>>> 1.70782512766
print(ar.var()) # 求方差
>>> 2.91666666667
print(ar.sum(), np.sum(ar,axis = 0)) # 求和,np.sum() → axis为0,按列求和;axis为1,按行求和
>>> 15 [3 5 7]
print(np.sort(np.array([1,4,3,2,5,6]))) # 排序
>>> [1 2 3 4 5 6]
一维、二维、三维
# 基本索引及切片
ar = np.arange(20)
print(ar)
print(ar[4])
print(ar[3:6])
>>> [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19]
>>> 4
>>> [3 4 5]
# 一维数组索引及切片
ar = np.arange(16).reshape(4,4)
print(ar, '数组轴数为%i' %ar.ndim) # 4*4的数组
>>> [[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]] 数组轴数为2
print(ar[2], '数组轴数为%i' %ar[2].ndim) # 切片为下一维度的一个元素,所以是一维数组
>>> [ 8 9 10 11] 数组轴数为1
print(ar[2][1]) # 二次索引,得到一维数组中的一个值
>>> 9
print(ar[1:3], '数组轴数为%i' %ar[1:3].ndim) # 切片为两个一维数组组成的二维数组
>>> [[ 4 5 6 7]
[ 8 9 10 11]] 数组轴数为2
print(ar[2,2]) # 切片数组中的第三行第三列 → 10
>>> 10
print(ar[:2,1:]) # 切片数组中的1,2行、2,3,4列 → 二维数组
>>> [[1 2 3]
[5 6 7]]
# 二维数组索引及切片
ar = np.arange(8).reshape(2,2,2)
print(ar, '数组轴数为%i' %ar.ndim) # 2*2*2的数组
>>> [[[0 1]
[2 3]]
[[4 5]
[6 7]]] 数组轴数为3
print(ar[0], '数组轴数为%i' %ar[0].ndim) # 三维数组的下一个维度的第一个元素 → 一个二维数组
>>> [[0 1]
[2 3]] 数组轴数为2
print(ar[0][0], '数组轴数为%i' %ar[0][0].ndim) # 三维数组的下一个维度的第一个元素下的第一个元素 → 一个一维数组
>>> [0 1] 数组轴数为1
print(ar[0][0][1], '数组轴数为%i' %ar[0][0][1].ndim)
>>> 1 数组轴数为0
# 三维数组索引及切片
ar = np.arange(12).reshape(3,4)
i = np.array([True,False,True])
j = np.array([True,True,False,False])
print(ar)
>>> [[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
print(i)
>>> [ True False True]
print(j)
>>> [ True True False False]
print(ar[i,:]) # 在第一维度做判断,只保留True,这里第一维度就是行,ar[i,:] = ar[i](简单书写格式)
>>> [[ 0 1 2 3]
[ 8 9 10 11]]
print(ar[:,j]) # 在第二维度做判断,这里如果ar[:,i]会有警告,因为i是3个元素,而ar在列上有4个
>>> [[0 1]
[4 5]
[8 9]]
# 布尔型索引:以布尔型的矩阵去做筛选
m = ar > 5
print(m) # 这里m是一个判断矩阵
>>> [[False False False False]
[False False True True]
[ True True True True]]
print(ar[m]) # 用m判断矩阵去筛选ar数组中>5的元素 → 重点!后面的pandas判断方式原理就来自此处
>>> [ 6 7 8 9 10 11]
ar = np.arange(10)
print(ar)
>>> [0 1 2 3 4 5 6 7 8 9]
ar[5] = 100
ar[7:9] = 200
print(ar)
>>> [ 0 1 2 3 4 100 6 200 200 9]
# 一个标量赋值给一个索引/切片时,会自动改变/传播原始数组
ar = np.arange(10)
b = ar.copy()
b[7:9] = 200
print(ar)
>>> [0 1 2 3 4 5 6 7 8 9]
print(b)
>>> [ 0 1 2 3 4 5 6 200 200 9]
# 复制
numpy.random包含多种概率分布的随机样本,是数据分析辅助的重点工具之一
numpy.random.normal(d0, d1, ..., dn)
:生成一个标准正态分布的样本值 —— 标准正态分布
numpy.random.rand(d0, d1, ..., dn)
:生成一个[0,1)之间的随机浮点数或N维浮点数组 —— 均匀分布
numpy.random.randn(d0, d1, ..., dn)
:生成一个浮点数或N维浮点数组 —— 正态分布
numpy.random.randint(low, high=None, size=None, dtype='l')
:生成一个整数或N维整数数组,若high不为None时,取[low,high)之间随机整数,否则取值[0,low)之间随机整数,且high必须大于low ,dtype参数:只能是int类型
random.normal()
# 随机数生成
samples = np.random.normal(size=(4,4))
print(samples)
>>> [[ 0.17875618 -1.19367146 -1.29127688 1.11541622]
[ 1.48126355 -0.81119863 -0.94187702 -0.13203948]
[ 0.11418808 -2.34415548 0.17391121 1.4822019 ]
[ 0.46157021 0.43227682 0.58489093 0.74553395]]
# 生成一个标准正态分布的4*4样本值
random.rand()
# numpy.random.rand(d0, d1, ..., dn):生成一个[0,1)之间的随机浮点数或N维浮点数组 —— 均匀分布
import matplotlib.pyplot as plt # 导入matplotlib模块,用于图表辅助分析
% matplotlib inline
# 魔法函数,每次运行自动生成图表
a = np.random.rand()
print(a,type(a)) # 生成一个随机浮点数
>>> 0.3671245126484347 <class 'float'>
b = np.random.rand(4)
print(b,type(b)) # 生成形状为4的一维数组
>>> [ 0.95365841 0.45627035 0.71528562 0.98488116] <class 'numpy.ndarray'>
c = np.random.rand(2,3)
print(c,type(c)) # 生成形状为2*3的二维数组,注意这里不是((2,3))
>>> [[ 0.82284657 0.95853197 0.87376954]
[ 0.53341526 0.17313861 0.18831533]] <class 'numpy.ndarray'>
samples1 = np.random.rand(1000)
samples2 = np.random.rand(1000)
plt.scatter(samples1,samples2)
# 生成1000个均匀分布的样本值
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zdX9zX2u-1683527885467)(output_24_2.png)]
random.randn()
# numpy.random.randn(d0, d1, ..., dn):生成一个浮点数或N维浮点数组 —— 正态分布
samples1 = np.random.randn(1000)
samples2 = np.random.randn(1000)
plt.scatter(samples1,samples2)
# randn和rand的参数用法一样
# 生成1000个正态的样本值
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PU0qtXxn-1683527885467)(output_25_1.png)]
random.randint()
# numpy.random.randint(low, high=None, size=None, dtype='l'):生成一个整数或N维整数数组
# 若high不为None时,取[low,high)之间随机整数,否则取值[0,low)之间随机整数,且high必须大于low
# dtype参数:只能是int类型
print(np.random.randint(2))
>>> 0
# low=2:生成1个[0,2)之间随机整数
print(np.random.randint(2,size=5))
>>> [0 1 1 0 1]
# low=2,size=5 :生成5个[0,2)之间随机整数
print(np.random.randint(2,6,size=5))
>>> [2 5 2 3 5]
# low=2,high=6,size=5:生成5个[2,6)之间随机整数
print(np.random.randint(2,size=(2,3)))
>>> [[0 1 1]
[1 1 1]]
# low=2,size=(2,3):生成一个2x3整数数组,取数范围:[0,2)随机整数
print(np.random.randint(2,6,(2,3)))
>>> [[4 4 3]
[2 3 3]]
# low=2,high=6,size=(2,3):生成一个2*3整数数组,取值范围:[2,6)随机整数
numpy读取/写入数组数据、文本数据
import os
os.chdir('C:/Users/Hjx/Desktop/')
ar = np.random.rand(5,5)
print(ar)
>>> [[ 0.57358458 0.71126411 0.22317828 0.69640773 0.97406015]
[ 0.83007851 0.63460575 0.37424462 0.49711017 0.42822812]
[ 0.51354459 0.96671598 0.21427951 0.91429226 0.00393325]
[ 0.680534 0.31516091 0.79848663 0.35308657 0.21576843]
[ 0.38634472 0.47153005 0.6457086 0.94983697 0.97670458]]
np.save('arraydata.npy', ar)
# 也可以直接 np.save('C:/Users/Hjx/Desktop/arraydata.npy', ar)
ar_load =np.load('arraydata.npy')
print(ar_load)
>>> [[ 0.57358458 0.71126411 0.22317828 0.69640773 0.97406015]
[ 0.83007851 0.63460575 0.37424462 0.49711017 0.42822812]
[ 0.51354459 0.96671598 0.21427951 0.91429226 0.00393325]
[ 0.680534 0.31516091 0.79848663 0.35308657 0.21576843]
[ 0.38634472 0.47153005 0.6457086 0.94983697 0.97670458]]
# 也可以直接 np.load('C:/Users/Hjx/Desktop/arraydata.npy')
ar = np.random.rand(5,5)
np.savetxt('array.txt',ar, delimiter=',')
# np.savetxt(fname, X, fmt='%.18e', delimiter=' ', newline='\n', header='', footer='', comments='# '):存储为文本txt文件
ar_loadtxt = np.loadtxt('array.txt', delimiter=',')
print(ar_loadtxt)
>>> [[ 0.28280684 0.66188985 0.00372083 0.54051044 0.68553963]
[ 0.9138449 0.37056825 0.62813711 0.83032184 0.70196173]
[ 0.63438739 0.86552157 0.68294764 0.2959724 0.62337767]
[ 0.67411154 0.87678919 0.53732168 0.90366896 0.70480366]
[ 0.00936579 0.32914898 0.30001813 0.66198967 0.04336824]]
# 也可以直接 np.loadtxt('C:/Users/Hjx/Desktop/array.txt')
文章浏览阅读3.2k次。本文研究全球与中国市场分布式光纤传感器的发展现状及未来发展趋势,分别从生产和消费的角度分析分布式光纤传感器的主要生产地区、主要消费地区以及主要的生产商。重点分析全球与中国市场的主要厂商产品特点、产品规格、不同规格产品的价格、产量、产值及全球和中国市场主要生产商的市场份额。主要生产商包括:FISO TechnologiesBrugg KabelSensor HighwayOmnisensAFL GlobalQinetiQ GroupLockheed MartinOSENSA Innovati_预计2026年中国分布式传感器市场规模有多大
文章浏览阅读1.1k次,点赞2次,收藏12次。常用组合逻辑电路结构——为IC设计的延时估计铺垫学习目的:估计模块间的delay,确保写的代码的timing 综合能给到多少HZ,以满足需求!_基4布斯算法代码
文章浏览阅读3.3k次,点赞3次,收藏5次。OpenAI Manager助手(基于SpringBoot和Vue)_chatgpt网页版
文章浏览阅读2.2k次。USACO自1992年举办,到目前为止已经举办了27届,目的是为了帮助美国信息学国家队选拔IOI的队员,目前逐渐发展为全球热门的线上赛事,成为美国大学申请条件下,含金量相当高的官方竞赛。USACO的比赛成绩可以助力计算机专业留学,越来越多的学生进入了康奈尔,麻省理工,普林斯顿,哈佛和耶鲁等大学,这些同学的共同点是他们都参加了美国计算机科学竞赛(USACO),并且取得过非常好的成绩。适合参赛人群USACO适合国内在读学生有意向申请美国大学的或者想锻炼自己编程能力的同学,高三学生也可以参加12月的第_usaco可以多次提交吗
文章浏览阅读394次。1.1 存储程序1.2 创建存储过程1.3 创建自定义函数1.3.1 示例1.4 自定义函数和存储过程的区别1.5 变量的使用1.6 定义条件和处理程序1.6.1 定义条件1.6.1.1 示例1.6.2 定义处理程序1.6.2.1 示例1.7 光标的使用1.7.1 声明光标1.7.2 打开光标1.7.3 使用光标1.7.4 关闭光标1.8 流程控制的使用1.8.1 IF语句1.8.2 CASE语句1.8.3 LOOP语句1.8.4 LEAVE语句1.8.5 ITERATE语句1.8.6 REPEAT语句。_mysql自定义函数和存储过程
文章浏览阅读188次。半导体二极管——集成电路最小组成单元。_本征半导体电流为0
文章浏览阅读2.8k次,点赞3次,收藏18次。游戏水面特效实现方式太多。咱们这边介绍的是一最简单的UV动画(无顶点位移),整个mesh由4个顶点构成。实现了水面效果(左图),不动代码稍微修改下参数和贴图可以实现岩浆效果(右图)。有要思路是1,uv按时间去做正弦波移动2,在1的基础上加个凹凸图混合uv3,在1、2的基础上加个水流方向4,加上对雾效的支持,如没必要请自行删除雾效代码(把包含fog的几行代码删除)S..._unity 岩浆shader
文章浏览阅读5k次。广义线性模型是线性模型的扩展,它通过连接函数建立响应变量的数学期望值与线性组合的预测变量之间的关系。广义线性模型拟合的形式为:其中g(μY)是条件均值的函数(称为连接函数)。另外,你可放松Y为正态分布的假设,改为Y 服从指数分布族中的一种分布即可。设定好连接函数和概率分布后,便可以通过最大似然估计的多次迭代推导出各参数值。在大部分情况下,线性模型就可以通过一系列连续型或类别型预测变量来预测正态分布的响应变量的工作。但是,有时候我们要进行非正态因变量的分析,例如:(1)类别型.._广义线性回归模型
文章浏览阅读69次。环境保护、 保护地球、 校园环保、垃圾分类、绿色家园、等网站的设计与制作。 总结了一些学生网页制作的经验:一般的网页需要融入以下知识点:div+css布局、浮动、定位、高级css、表格、表单及验证、js轮播图、音频 视频 Flash的应用、ul li、下拉导航栏、鼠标划过效果等知识点,网页的风格主题也很全面:如爱好、风景、校园、美食、动漫、游戏、咖啡、音乐、家乡、电影、名人、商城以及个人主页等主题,学生、新手可参考下方页面的布局和设计和HTML源码(有用点赞△) 一套A+的网_垃圾分类网页设计目标怎么写
文章浏览阅读614次,点赞7次,收藏11次。之前找到一个修改 exe 中 DLL地址 的方法, 不太好使,虽然能正确启动, 但无法改变 exe 的工作目录,这就影响了.Net 中很多获取 exe 执行目录来拼接的地址 ( 相对路径 ),比如 wwwroot 和 代码中相对目录还有一些复制到目录的普通文件 等等,它们的地址都会指向原来 exe 的目录, 而不是自定义的 “lib” 目录,根本原因就是没有修改 exe 的工作目录这次来搞一个启动程序,把 .net 的所有东西都放在一个文件夹,在文件夹同级的目录制作一个 exe._.net dll 全局目录
文章浏览阅读1.5k次。本文为转载,原博客地址:http://blog.csdn.net/hujingshuang/article/details/46910259简介 BRIEF是2010年的一篇名为《BRIEF:Binary Robust Independent Elementary Features》的文章中提出,BRIEF是对已检测到的特征点进行描述,它是一种二进制编码的描述子,摈弃了利用区域灰度..._breif description calculation 特征点
文章浏览阅读4.1k次,点赞21次,收藏79次。本文是《基于SpringBoot的房屋租赁管理系统》的配套原创说明文档,可以给应届毕业生提供格式撰写参考,也可以给开发类似系统的朋友们提供功能业务设计思路。_基于spring boot的房屋租赁系统论文