pandas 学习预备知识总结
目录
第一章 预备知识
一、Python基础
1. 列表推导式与条件赋值
2. 匿名函数与map方法
3. zip对象与enumerate方法
二、Numpy基础
1. np数组的构造
2. np数组的变形与合并
3. np数组的切片与索引
4. 常用函数
5. 广播机制
6. 向量与矩阵的计算
三、练习
Ex1：利用列表推导式写矩阵乘法
Ex2：更新矩阵
Ex3：卡方统计量
Ex4：改进矩阵计算的性能
Ex5：连续整数的最大长度
第一章 预备知识
一、Python基础
1. 列表推导式与条件赋值
在生成一个数字序列的时候，在Python中可以如下写出：
1
# 相关数据下载
2
print('开始下载数据～')
3
!wget http://tianchi-media.oss-cn-beijing.aliyuncs.com/dragonball/OSP/joyful-pandas/data.zip
4
print('数据下载完成，开始解压～')
5
# 文件大小 14mb左右，解压需要3-5s
6
!unzip -q -o ./data.zip
7
print('数据解压完成，可以开始完成任务啦～')
开始下载数据～--2021-01-25 16:31:02-- http://tianchi-media.oss-cn-beijing.aliyuncs.com/dragonball/OSP/joyful-pandas/data.zipResolving tianchi-media.oss-cn-beijing.aliyuncs.com (tianchi-media.oss-cn-beijing.aliyuncs.com)... 47.95.85.21Connecting to tianchi-media.oss-cn-beijing.aliyuncs.com (tianchi-media.oss-cn-beijing.aliyuncs.com)|47.95.85.21|:80... connected.HTTP request sent, awaiting response... 200 OKLength: 3573654 (3.4M) [application/zip]Saving to: ‘data.zip’100%[======================================>] 3,573,654 13.0MB/s in 0.3s 2021-01-25 16:31:02 (13.0 MB/s) - ‘data.zip’ saved [3573654/3573654]数据下载完成，开始解压～数据解压完成，可以开始完成任务啦～
1
L = []
2
def my_func(x):
3
return 2*x
4
for i in range(5):
5
L.append(my_func(i))
6
L
[4]:
[0, 2, 4, 6, 8]
事实上可以利用列表推导式进行写法上的简化：[* for i in *]。其中，第一个*为映射函数，其输入为后面i指代的内容，第二个*表示迭代的对象。
1
[my_func(i) for i in range(5)]
[5]:
[0, 2, 4, 6, 8]
列表表达式还支持多层嵌套，如下面的例子中第一个for为外层循环，第二个为内层循环：
1
[m+'_'+n for m in ['a', 'b'] for n in ['c', 'd']]
[6]:
['a_c', 'a_d', 'b_c', 'b_d']
除了列表推导式，另一个实用的语法糖是带有if选择的条件赋值，其形式为value = a if condition else b：
1
value = 'cat' if 2>1 else 'dog'
2
value
[7]:
'cat'
等价于如下的写法：
a, b = 'cat', 'dog'
condition = 2 > 1 # 此时为True
if condition:value = a
else:value = b下面举一个例子，截断列表中超过5的元素，即超过5的用5代替，小于5的保留原来的值：
1
L = [1, 2, 3, 4, 5, 6, 7]
2
[i if i <= 5 else 5 for i in L]
[8]:
[1, 2, 3, 4, 5, 5, 5]
2. 匿名函数与map方法
有一些函数的定义具有清晰简单的映射关系，例如上面的my_func函数，这时候可以用匿名函数的方法简洁地表示：
1
my_func = lambda x: 2*x
2
my_func(3)
[9]:
6
1
multi_para_func = lambda a, b: a + b
2
multi_para_func(1, 2)
[10]:
3
但上面的用法其实违背了“匿名”的含义，事实上它往往在无需多处调用的场合进行使用，例如上面列表推导式中的例子，用户不关心函数的名字，只关心这种映射的关系：
1
[(lambda x: 2*x)(i) for i in range(5)]
[11]:
[0, 2, 4, 6, 8]
对于上述的这种列表推导式的匿名函数映射，Python中提供了map函数来完成，它返回的是一个map对象，需要通过list转为列表：
1
list(map(lambda x: 2*x, range(5)))
[12]:
[0, 2, 4, 6, 8]
对于多个输入值的函数映射，可以通过追加迭代对象实现：
1
list(map(lambda x, y: str(x)+'_'+y, range(5), list('abcde')))
[13]:
['0_a', '1_b', '2_c', '3_d', '4_e']
3. zip对象与enumerate方法
zip函数能够把多个可迭代对象打包成一个元组构成的可迭代对象，它返回了一个zip对象，通过tuple, list可以得到相应的打包结果：
1
L1, L2, L3 = list('abc'), list('def'), list('hij')
2
list(zip(L1, L2, L3))
[14]:
[('a', 'd', 'h'), ('b', 'e', 'i'), ('c', 'f', 'j')]
1
tuple(zip(L1, L2, L3))
[15]:
(('a', 'd', 'h'), ('b', 'e', 'i'), ('c', 'f', 'j'))
往往会在循环迭代的时候使用到zip函数：
1
for i, j, k in zip(L1, L2, L3):
2
print(i, j, k)
a d hb e ic f j
enumerate是一种特殊的打包，它可以在迭代时绑定迭代元素的遍历序号：
1
L = list('abcd')
2
for index, value in enumerate(L):
3
print(index, value)
0 a1 b2 c3 d
用zip对象也能够简单地实现这个功能：
1
for index, value in zip(range(len(L)), L):
2
print(index, value)
0 a1 b2 c3 d
当需要对两个列表建立字典映射时，可以利用zip对象：
1
dict(zip(L1, L2))
[16]:
{'a': 'd', 'b': 'e', 'c': 'f'}
既然有了压缩函数，那么Python也提供了*操作符和zip联合使用来进行解压操作：
1
zipped = list(zip(L1, L2, L3))
2
zipped
[17]:
[('a', 'd', 'h'), ('b', 'e', 'i'), ('c', 'f', 'j')]
1
list(zip(*zipped)) # 三个元组分别对应原来的列表
[18]:
[('a', 'b', 'c'), ('d', 'e', 'f'), ('h', 'i', 'j')]
二、Numpy基础
1. np数组的构造
最一般的方法是通过array来构造：
1
import numpy as np
2
np.array([1,2,3])
[17]:
array([1, 2, 3])
下面讨论一些特殊数组的生成方式：
【a】等差序列：np.linspace, np.arange
1
np.linspace(1,5,11) # 起始、终止（包含）、样本个数
[20]:
array([1. , 1.4, 1.8, 2.2, 2.6, 3. , 3.4, 3.8, 4.2, 4.6, 5. ])
1
np.arange(1,5,2) # 起始、终止（不包含）、步长
[21]:
array([1, 3])
【b】特殊矩阵：zeros, eye, full
1
np.zeros((2,3)) # 传入元组表示各维度大小
[22]:
array([[0., 0., 0.], , [0., 0., 0.]])
1
np.eye(3) # 3*3的单位矩阵
[23]:
array([[1., 0., 0.], , [0., 1., 0.], , [0., 0., 1.]])
1
np.eye(3, k=1) # 偏移主对角线1个单位的伪单位矩阵
[24]:
array([[0., 1., 0.], , [0., 0., 1.], , [0., 0., 0.]])
1
np.full((2,3), 10) # 元组传入大小，10表示填充数值
[25]:
array([[10, 10, 10], , [10, 10, 10]])
1
np.full((2,3), [1,2,3]) # 每行填入相同的列表
[26]:
array([[1, 2, 3], , [1, 2, 3]])
【c】随机矩阵：np.random
最常用的随机生成函数为rand, randn, randint, choice，它们分别表示0-1均匀分布的随机数组、标准正态的随机数组、随机整数组和随机列表抽样：
1
np.random.rand(3) # 生成服从0-1均匀分布的三个随机数
[27]:
array([0.92340835, 0.20019461, 0.40755472])
1
np.random.rand(3, 3) # 注意这里传入的不是元组，每个维度大小分开输入
[18]:
array([[0.27406232, 0.15754534, 0.20274407], , [0.70255975, 0.71797703, 0.29850324], , [0.03186549, 0.54798699, 0.93826835]])
对于服从区间a到b上的均匀分布可以如下生成：
1
a, b = 5, 15
2
(b - a) * np.random.rand(3) + a
[29]:
array([6.59370831, 8.03865138, 9.19172546])
一般的，可以选择已有的库函数：
1
np.random.uniform(5, 15, 3)
[30]:
array([11.26499636, 13.12311185, 6.00774156])
randn生成了N(0,I)的标准正态分布：
1
np.random.randn(3)
[31]:
array([ 1.87000209, 1.19885561, -0.58802943])
1
np.random.randn(2, 2)
[32]:
array([[-1.3642839 , -0.31497567], , [-1.9452492 , -3.17272882]])
对于服从方差为σ2σ2均值为μμ的一元正态分布可以如下生成：
1
sigma, mu = 2.5, 3
2
mu + np.random.randn(3) * sigma
[33]:
array([1.56024917, 0.22829486, 7.3764211 ])
同样的，也可选择从已有函数生成：
1
np.random.normal(3, 2.5, 3)
[34]:
array([3.53517851, 5.3441269 , 3.51192744])
randint可以指定生成随机整数的最小值最大值（不包含）和维度大小：
1
low, high, size = 5, 15, (2,2) # 生成5到14的随机整数
2
np.random.randint(low, high, size)
[35]:
array([[ 5, 12], , [14, 9]])
choice可以从给定的列表中，以一定概率和方式抽取结果，当不指定概率时为均匀采样，默认抽取方式为有放回抽样：
1
my_list = ['a', 'b', 'c', 'd']
2
np.random.choice(my_list, 2, replace=False, p=[0.1, 0.7, 0.1 ,0.1])
[36]:
array(['b', 'a'], dtype='<U1')
1
np.random.choice(my_list, (3,3))
[37]:
array([['c', 'b', 'd'], , ['d', 'a', 'd'], , ['a', 'c', 'd']], dtype='<U1')
当返回的元素个数与原列表相同时，不放回抽样等价于使用permutation函数，即打散原列表：
1
np.random.permutation(my_list)
[38]:
array(['c', 'a', 'd', 'b'], dtype='<U1')
最后，需要提到的是随机种子，它能够固定随机数的输出结果：
1
np.random.seed(0)
2
np.random.rand()
[39]:
0.5488135039273248
1
np.random.seed(0)
2
np.random.rand()
[40]:
0.5488135039273248
2. np数组的变形与合并
【a】转置：T
1
np.zeros((2,3)).T
[41]:
array([[0., 0.], , [0., 0.], , [0., 0.]])
【b】合并操作：r_, c_
对于二维数组而言，r_和c_分别表示上下合并和左右合并：
1
np.r_[np.zeros((2,3)),np.zeros((2,3))]
[42]:
array([[0., 0., 0.], , [0., 0., 0.], , [0., 0., 0.], , [0., 0., 0.]])
1
np.c_[np.zeros((2,3)),np.zeros((2,3))]
[43]:
array([[0., 0., 0., 0., 0., 0.], , [0., 0., 0., 0., 0., 0.]])
一维数组和二维数组进行合并时，应当把其视作列向量，在长度匹配的情况下只能够使用左右合并的c_操作：
1
try:
2
np.r_[np.array([0,0]),np.zeros((2,1))]
3
except Exception as e:
4
Err_Msg = e
5
Err_Msg
[44]:
ValueError('all the input arrays must have same number of dimensions, but the array at index 0 has 1 dimension(s) and the array at index 1 has 2 dimension(s)')
1
np.r_[np.array([0,0]),np.zeros(2)]
[45]:
array([0., 0., 0., 0.])
1
np.c_[np.array([0,0]),np.zeros((2,3))]
[46]:
array([[0., 0., 0., 0.], , [0., 0., 0., 0.]])
【c】维度变换：reshape
reshape能够帮助用户把原数组按照新的维度重新排列。在使用时有两种模式，分别为C模式和F模式，分别以逐行和逐列的顺序进行填充读取。
1
target = np.arange(8).reshape(2,4)
2
target
[47]:
array([[0, 1, 2, 3], , [4, 5, 6, 7]])
1
target.reshape((4,2), order='C') # 按照行读取和填充
[48]:
array([[0, 1], , [2, 3], , [4, 5], , [6, 7]])
1
target.reshape((4,2), order='F') # 按照列读取和填充
[49]:
array([[0, 2], , [4, 6], , [1, 3], , [5, 7]])
特别地，由于被调用数组的大小是确定的，reshape允许有一个维度存在空缺，此时只需填充-1即可：
1
target.reshape((4,-1))
[50]:
array([[0, 1], , [2, 3], , [4, 5], , [6, 7]])
下面将n*1大小的数组转为1维数组的操作是经常使用的：
1
target = np.ones((3,1))
2
target
[51]:
array([[1.], , [1.], , [1.]])
1
target.reshape(-1)
[52]:
array([1., 1., 1.])
3. np数组的切片与索引
数组的切片模式支持使用slice类型的start:end:step切片，还可以直接传入列表指定某个维度的索引进行切片：
1
target = np.arange(9).reshape(3,3)
2
target
[53]:
array([[0, 1, 2], , [3, 4, 5], , [6, 7, 8]])
1
target[:-1, [0,2]]
[54]:
array([[0, 2], , [3, 5]])
此外，还可以利用np.ix_在对应的维度上使用布尔索引，但此时不能使用slice切片：
1
target[np.ix_([True, False, True], [True, False, True])]
[55]:
array([[0, 2], , [6, 8]])
1
target[np.ix_([1,2], [True, False, True])]
[56]:
array([[3, 5], , [6, 8]])
当数组维度为1维时，可以直接进行布尔索引，而无需np.ix_：
1
new = target.reshape(-1)
2
new[new%2==0]
[57]:
array([0, 2, 4, 6, 8])
4. 常用函数
为了简单起见，这里假设下述函数输入的数组都是一维的。
【a】where
where是一种条件函数，可以指定满足条件与不满足条件位置对应的填充值：
1
a = np.array([-1,1,-1,0])
2
np.where(a>0, a, 5) # 对应位置为True时填充a对应元素，否则填充5
[58]:
array([5, 1, 5, 5])
【b】nonzero, argmax, argmin
这三个函数返回的都是索引，nonzero返回非零数的索引，argmax, argmin分别返回最大和最小数的索引：
1
a = np.array([-2,-5,0,1,3,-1])
2
np.nonzero(a)
[59]:
(array([0, 1, 3, 4, 5], dtype=int64),)
1
a.argmax()
[60]:
4
1
a.argmin()
[61]:
1
【c】any, all
any指当序列至少 存在一个 True或非零元素时返回True，否则返回False
all指当序列元素 全为 True或非零元素时返回True，否则返回False
1
a = np.array([0,1])
2
a.any()
[62]:
True
1
a.all()
[63]:
False
【d】cumprod, cumsum, diff
cumprod, cumsum分别表示累乘和累加函数，返回同长度的数组，diff表示和前一个元素做差，由于第一个元素为缺失值，因此在默认参数情况下，返回长度是原数组减1
1
a = np.array([1,2,3])
2
a.cumprod()
[64]:
array([1, 2, 6], dtype=int32)
1
a.cumsum()
[65]:
array([1, 3, 6], dtype=int32)
1
np.diff(a)
[66]:
array([1, 1])
【e】 统计函数
常用的统计函数包括max, min, mean, median, std, var, sum, quantile，其中分位数计算是全局方法，因此不能通过array.quantile的方法调用：
1
target = np.arange(5)
2
target
[21]:
array([0, 1, 2, 3, 4])
1
target.max()
[22]:
4
1
np.quantile(target, 0.5) # 0.5分位数
[69]:
2.0
但是对于含有缺失值的数组，它们返回的结果也是缺失值，如果需要略过缺失值，必须使用nan*类型的函数，上述的几个统计函数都有对应的nan*函数。
1
target = np.array([1, 2, np.nan])
2
target
[70]:
array([ 1., 2., nan])
1
target.max()
[71]:
nan
1
np.nanmax(target)
[72]:
2.0
1
np.nanquantile(target, 0.5)
[73]:
1.5
对于协方差和相关系数分别可以利用cov, corrcoef如下计算：
1
target1 = np.array([1,3,5,9])
2
target2 = np.array([1,5,3,-9])
3
np.cov(target1, target2)
[74]:
array([[ 11.66666667, -16.66666667], , [-16.66666667, 38.66666667]])
1
np.corrcoef(target1, target2)
[75]:
array([[ 1. , -0.78470603], , [-0.78470603, 1. ]])
最后，需要说明二维Numpy数组中统计函数的axis参数，它能够进行某一个维度下的统计特征计算，当axis=0时结果为列的统计指标，当axis=1时结果为行的统计指标：
1
target = np.arange(1,10).reshape(3,-1)
2
target
[76]:
array([[1, 2, 3], , [4, 5, 6], , [7, 8, 9]])
1
target.sum(0)
[77]:
array([12, 15, 18])
1
target.sum(1)
[78]:
array([ 6, 15, 24])
5. 广播机制
广播机制用于处理两个不同维度数组之间的操作，这里只讨论不超过两维的数组广播机制。
【a】标量和数组的操作
当一个标量和数组进行运算时，标量会自动把大小扩充为数组大小，之后进行逐元素操作：
1
res = 3 * np.ones((2,2)) + 1
2
res
[23]:
array([[4., 4.], , [4., 4.]])
1
res = 1 / res
2
res
[80]:
array([[0.25, 0.25], , [0.25, 0.25]])
【b】二维数组之间的操作
当两个数组维度完全一致时，使用对应元素的操作，否则会报错，除非其中的某个数组的维度是m×1m×1或者1×n1×n，那么会扩充其具有11的维度为另一个数组对应维度的大小。例如，1×21×2数组和3×23×2数组做逐元素运算时会把第一个数组扩充为3×23×2，扩充时的对应数值进行赋值。但是，需要注意的是，如果第一个数组的维度是1×31×3，那么由于在第二维上的大小不匹配且不为11，此时报错。
1
res = np.ones((3,2))
2
res
[81]:
array([[1., 1.], , [1., 1.], , [1., 1.]])
1
res * np.array([[2,3]]) # 第二个数组扩充第一维度为3
[82]:
array([[2., 3.], , [2., 3.], , [2., 3.]])
1
res * np.array([[2],[3],[4]]) # 第二个数组扩充第二维度为2
[83]:
array([[2., 2.], , [3., 3.], , [4., 4.]])
1
res * np.array([[2]]) # 等价于两次扩充，第二个数组两个维度分别扩充为3和2
[84]:
array([[2., 2.], , [2., 2.], , [2., 2.]])
【c】一维数组与二维数组的操作
当一维数组AkAk与二维数组Bm,nBm,n操作时，等价于把一维数组视作A1,kA1,k的二维数组，使用的广播法则与【b】中一致，当k!=nk!=n且k,nk,n都不是11时报错。
1
np.ones(3) + np.ones((2,3))
[85]:
array([[2., 2., 2.], , [2., 2., 2.]])
1
np.ones(3) + np.ones((2,1))
[86]:
array([[2., 2., 2.], , [2., 2., 2.]])
1
np.ones(1) + np.ones((2,3))
[87]:
array([[2., 2., 2.], , [2., 2., 2.]])
6. 向量与矩阵的计算
【a】向量内积：dot
a⋅b=∑iaibia⋅b=∑iaibi
1
a = np.array([1,2,3])
2
b = np.array([1,3,5])
3
a.dot(b)
[88]:
22
【b】向量范数和矩阵范数：np.linalg.norm
在矩阵范数的计算中，最重要的是ord参数，可选值如下：
| ord | norm for matrices | norm for vectors |
|---|---|---|
| None | Frobenius norm | 2-norm |
| 'fro' | Frobenius norm | / |
| 'nuc' | nuclear norm | / |
| inf | max(sum(abs(x), axis=1)) | max(abs(x)) |
| -inf | min(sum(abs(x), axis=1)) | min(abs(x)) |
| 0 | / | sum(x != 0) |
| 1 | max(sum(abs(x), axis=0)) | as below |
| -1 | min(sum(abs(x), axis=0)) | as below |
| 2 | 2-norm (largest sing. value) | as below |
| -2 | smallest singular value | as below |
| other | / | sum(abs(x)**ord)**(1./ord) |
1
matrix_target = np.arange(4).reshape(-1,2)
2
matrix_target
[89]:
array([[0, 1], , [2, 3]])
1
np.linalg.norm(matrix_target, 'fro')
[90]:
3.7416573867739413
1
np.linalg.norm(matrix_target, np.inf)
[91]:
5.0
1
np.linalg.norm(matrix_target, 2)
[92]:
3.702459173643833
1
vector_target = np.arange(4)
2
vector_target
[93]:
array([0, 1, 2, 3])
1
np.linalg.norm(vector_target, np.inf)
[94]:
3.0
1
np.linalg.norm(vector_target, 2)
[95]:
3.7416573867739413
1
np.linalg.norm(vector_target, 3)
[96]:
3.3019272488946263
【c】矩阵乘法：@
[Am×pBp×n]ij=p∑k=1AikBkj[Am×pBp×n]ij=∑k=1pAikBkj
1
a = np.arange(4).reshape(-1,2)
2
a
[97]:
array([[0, 1], , [2, 3]])
1
b = np.arange(-4,0).reshape(-1,2)
2
b
[98]:
array([[-4, -3], , [-2, -1]])
1
a@b
[99]:
array([[ -2, -1], , [-14, -9]])
三、练习
Ex1：利用列表推导式写矩阵乘法
一般的矩阵乘法根据公式，可以由三重循环写出，请将其改写为列表推导式的形式。
1
M1 = np.random.rand(2,3)
2
M2 = np.random.rand(3,4)
3
res = np.empty((M1.shape[0],M2.shape[1]))
4
for i in range(M1.shape[0]):
5
for j in range(M2.shape[1]):
6
item = 0
7
for k in range(M1.shape[1]):
8
item += M1[i][k] * M2[k][j]
9
res[i][j] = item
10
(np.abs((M1@M2 - res) < 1e-15)).all() # 排除数值误差
[24]:
True
Ex2：更新矩阵
设矩阵 Am×nAm×n ，现在对 AA 中的每一个元素进行更新生成矩阵 BB ，更新方法是 Bij=Aij∑nk=11AikBij=Aij∑k=1n1Aik ，例如下面的矩阵为 AA ，则 B2,2=5×(14+15+16)=3712B2,2=5×(14+15+16)=3712 ，请利用 Numpy 高效实现。A=⎡⎢⎣123456789⎤⎥⎦A=[123456789]
Ex3：卡方统计量
设矩阵Am×nAm×n，记Bij=(∑mi=1Aij)×(∑nj=1Aij)∑mi=1∑nj=1AijBij=(∑i=1mAij)×(∑j=1nAij)∑i=1m∑j=1nAij，定义卡方值如下：χ2=m∑i=1n∑j=1(Aij−Bij)2Bijχ2=∑i=1m∑j=1n(Aij−Bij)2Bij请利用Numpy对给定的矩阵AA计算χ2χ2
1
np.random.seed(0)
2
A = np.random.randint(10, 20, (8, 5))
Ex4：改进矩阵计算的性能
设ZZ为m×nm×n的矩阵，BB和UU分别是m×pm×p和p×np×n的矩阵，BiBi为BB的第ii行，UjUj为UU的第jj列，下面定义R=m∑i=1n∑j=1∥Bi−Uj∥22ZijR=∑i=1m∑j=1n‖Bi−Uj‖22Zij，其中∥a∥22‖a‖22表示向量aa的分量平方和∑ia2i∑iai2。
现有某人根据如下给定的样例数据计算RR的值，请充分利用Numpy中的函数，基于此问题改进这段代码的性能。
1
np.random.seed(0)
2
m, n, p = 100, 80, 50
3
B = np.random.randint(0, 2, (m, p))
4
U = np.random.randint(0, 2, (p, n))
5
Z = np.random.randint(0, 2, (m, n))
6
def solution(B=B, U=U, Z=Z):
7
L_res = []
8
for i in range(m):
9
for j in range(n):
10
norm_value = ((B[i]-U[:,j])**2).sum()
11
L_res.append(norm_value*Z[i][j])
12
return sum(L_res)
13
solution(B, U, Z)
[25]:
100566
Ex5：连续整数的最大长度
输入一个整数的Numpy数组，返回其中严格递增连续整数子数组的最大长度，正向是指递增方向。例如，输入[1,2,5,6,7]，[5,6,7]为具有最大长度的连续整数子数组，因此输出3；输入[3,2,1,2,3,4,6]，[1,2,3,4]为具有最大长度的连续整数子数组，因此输出4。请充分利用Numpy的内置函数完成。（提示：考虑使用nonzero, diff函数）
pandas 学习预备知识总结相关推荐
- react学习预备知识_在10分钟内学习React基础知识
react学习预备知识 If you want to learn the basics of React in the time it takes you to drink a cup of coff ...
- 【MakeFile】Synopsys全家桶学习预备知识 · makefile教程
本文是synopsys全家桶学习的第一篇,这个系列将按照IC设计的流程顺序学习编译仿真工具VCS,综合工具DC,参数提取工具StarRC,STA工具PrimeTime,形式化验证工具FM,布局布线IC ...
- uboot学习预备知识
为什么要有uboot 计算机系统的主要部件 (1)计算机系统就是有CPU来做核心进行运行的系统.典型的计算机系统有:PC机(台式机+笔记本).嵌入式设备(手机.平板电脑.游戏机).单片机(家用电器像电 ...
- 1.数据结构笔记学习--预备知识
数据类型: (1)结构型:用户自定义数据类型 (高分笔记P4) typedef struct{ }类型名 (2)指针型:变量内部放的变量地址 (3)结点的构造: 链表结点的 ...
- （d2l-ai/d2l-zh）《动手学深度学习》pytorch 笔记（2）前言（介绍各种机器学习问题）以及数据操作预备知识Ⅰ
开源项目地址:d2l-ai/d2l-zh 教材官网:https://zh.d2l.ai/ 书介绍:https://zh-v2.d2l.ai/ 笔记基于2021年7月26日发布的版本,书及代码下载地址在 ...
- 【李沐：动手学深度学习pytorch版】第2章：预备知识
第2章 预备知识 2.1 数据操作 2.1.1 入门 导入的是torch而不是pytorch import torch 一个数叫标量 一个轴叫向量 两个轴叫矩阵 arange # 生成行向量 x = ...
- 学习SLAM需要哪些预备知识？
点击上方"3D视觉工坊",选择"星标" 干货第一时间送达 编辑:3D视觉工坊 链接:https://www.zhihu.com/question/3518606 ...
- 学习Identity Server 4的预备知识
我要使用asp.net core 2.0 web api 搭建一个基础框架并立即应用于一个实际的项目中去.这里需要使用identity server 4 做单点登陆.下面就简单学习一下相关的预备知识. ...
- IP地址和子网划分学习笔记之《预备知识：进制计数》
一.序:IP地址和子网划分学习笔记开篇 只要记住你的名字,不管你在世界的哪个地方,我一定会去见你. --新海诚 电影<你的名字> 在我们的日常生活中,每个人的名字对应一个唯一的身(敏)份( ...
最新文章
- GUI编程之tkinter
- 人与人的差距在于认知
- js：如何在循环异步请求的每次返回中添加想要的值
- HDFS读写过程解析
- win10计算机恢复出厂设置,Windows 10 一键恢复出厂设置详细教程
- C# 强制关闭当前程序进程（完全Kill掉不留痕迹）
- PU learning学习笔记
- 【columnstore】mariadb columnstore 数据迁移
- 【Flink】Flink 流计算 容错 source节点进行数据容错
- retrofit与rxjava使用
- 位运算符 | ^ ~的厉害__10进制 To 2进制
- 卷积神经网络中的权值共享
- Python基础篇【第十篇】：正则表达式
- Java内存模型基础知识
- UEFI shell － 脚本文件
- 【干货】Android实现支付宝当面付
- 实战五十三：基于机器学习随机森林的购房贷款违约预测（完整代码+数据集）
- elasticsearch性能测试工具rally深入详解
- 贝尔-S-010W-A-芯片RK3228B卡刷固件
- 手持设备访问互联网策略综述