关系型连接（横向连接）

连接的基本概念

把两张相关的表按照某一个或某一组键连接起来是一种常见操作，例如学生期末考试各个科目的成绩表按照 姓名 和 班级 连接成总的成绩表，又例如对企业员工的各类信息表按照 员工ID号 进行连接汇总。由此可以看出，在关系型连接中， 键是十分重要的，往往用 on 参数表示。

另一个重要的要素是连接的形式。在 pandas 中的关系型连接函数 merge 和 join 中提供了 how 参数来代表连接形式，分为左连接 left 、右连接 right 、内连接 inner 、外连接 outer，它们的区别可以用如下示意图表示：

  • 左连接即以左边的键为准，如果右边表中的键于左边存在，那么就添加到左边，否则则处理为缺失值
  • 右连接类似处理，如果左边表中的键于右边存在，那么就添加到右边，否则则处理为缺失值
  • 内连接只负责合并两边同时出现的键
  • 外连接则会在内连接的基础上包含只在左边出现以及只在右边出现的值，因此外连接又叫全连接

上面这个简单的例子中，同一个表中的键没有出现重复的情况，那么如果出现重复的键应该如何处理？只需把握一个原则，即只要两边同时出现的值，就以笛卡尔积的方式加入，如果单边出现则根据连接形式进行处理。其中，关于笛卡尔积可用如下例子说明：设左表中键 张三 出现两次，右表中的 张三 也出现两次，那么逐个进行匹配，最后产生的表必然包含 2*2 个姓名为 张三 的行。下面是一个对应例子的示意图：

显然在不同的场合应该使用不同的连接形式。其中左连接和右连接是等价的，由于它们的结果中的键是被一侧的表确定的，因此常常用于有方向性地添加到目标表。内外连接两侧的表，经常是地位类似的，想取出键的交集或者并集，具体的操作还需要业务的需求来判断。

值连接（merge）

在上面示意图中的例子中，两张表根据某一列的值来连接，事实上还可以通过几列值的组合进行连接，这种基于值的连接在 pandas 中可以由 merge 函数实现，例如第一张图的左连接：

df1 = pd.DataFrame({'Name':['San Zhang','Si Li'],'Age':[20,30]})
df1
Name Age
0 San Zhang 20
1 Si Li 30 
df2 = pd.DataFrame({'Name':['Si Li','Wu Wang'],'Gender':['F','M']})
df2
Name Gender
0 Si Li F
1 Wu Wang M 
df1.merge(df2, on='Name', how='left')
Name Age Gender
0 San Zhang 20 NaN
1 Si Li 30 F

如果两个表中想要连接的列不具备相同的列名，可以通过 left_on 和 right_on 指定：

df1 = pd.DataFrame({'df1_name':['San Zhang','Si Li'],'Age':[20,30]})
df2 = pd.DataFrame({'df2_name':['Si Li','Wu Wang'],'Gender':['F','M']})
df1.merge(df2, left_on='df1_name', right_on='df2_name', how='left')
df1_name Age df2_name Gender
0 San Zhang 20 NaN NaN
1 Si Li 30 Si Li F

如果两个表中的列出现了重复的列名，那么可以通过 suffixes 参数指定。例如合并考试成绩的时候，第一个表记录了语文成绩，第二个是数学成绩：

df1 = pd.DataFrame({'Name':['San Zhang'],'Grade':[70]})
df2 = pd.DataFrame({'Name':['San Zhang'],'Grade':[80]})
df1.merge(df2, on='Name', how='left', suffixes=['_Chinese','_Math'])
Name Grade_Chinese Grade_Math
0 San Zhang 70 80

在某些时候出现重复元素是麻烦的，例如两位同学来自不同的班级，但是姓名相同，这种时候就要指定 on 参数为多个列使得正确连接：

df1 = pd.DataFrame({'Name':['San Zhang', 'San Zhang'],'Age':[20, 21],'Class':['one', 'two']})
df1
Name Age Class
0 San Zhang 20 one
1 San Zhang 21 two 
df2 = pd.DataFrame({'Name':['San Zhang', 'San Zhang'], 'Gender':['F', 'M'],'Class':['two', 'one']})
df2
Name Gender Class
0 San Zhang F two
1 San Zhang M one 
df1.merge(df2, on='Name', how='left') # 错误的结果
Name Age Class_x Gender Class_y
0 San Zhang 20 one F two
1 San Zhang 20 one M one
2 San Zhang 21 two F two
3 San Zhang 21 two M one 
df1.merge(df2, on=['Name', 'Class'], how='left') # 正确的结果
Name Age Class Gender
0 San Zhang 20 one M
1 San Zhang 21 two F

从上面的例子来看，在进行基于唯一性的连接下，如果键不是唯一的，那么结果就会产生问题。举例中的行数很少，但如果实际数据中有几十万到上百万行的进行合并时，如果想要保证唯一性，除了用 duplicated 检查是否重复外， merge 中也提供了 validate 参数来检查连接的唯一性模式。这里共有三种模式，即一对一连接 1:1 ，一对多连接 1:m ，多对一连接 m:1 连接，第一个是指左右表的键都是唯一的，后面两个分别指左表键唯一和右表键唯一。

Question：上面以多列为键的例子中，错误写法显然是一种多对多连接，而正确写法是一对一连接，请修改原表，使得以多列为键的正确写法能够通过 validate=‘1:m’ 的检验，但不能通过 validate=‘m:1’ 的检验。

# 可以通过 validate='1:m' 的检验
df1 = pd.DataFrame({'Name':['San Zhang', 'Si Li'],'Age':[20, 21],'Class':['one', 'two']})
df2 = pd.DataFrame({'Name':['San Zhang', 'San Zhang'], 'Gender':['F', 'M'],'Class':['one', 'one']})
Err_Msg = 'NULL'
try: df1.merge(df2, on=['Name', 'Class'], how='left',validate='1:m')
except Exception as e: Err_Msg = eErr_Msg

'NULL'

# 不能通过 validate='m:1' 的检验
df1 = pd.DataFrame({'Name':['San Zhang', 'Si Li'],'Age':[20, 21],'Class':['one', 'two']})
df2 = pd.DataFrame({'Name':['San Zhang', 'San Zhang'], 'Gender':['F', 'M'],'Class':['one', 'one']})
Err_Msg = 'NULL'
try: df1.merge(df2, on=['Name', 'Class'], how='left',validate='m:1')
except Exception as e: Err_Msg = eErr_Msg

pandas.errors.MergeError('Merge keys are not unique in right dataset; not a many-to-one merge')

索引连接（join）

所谓索引连接，就是把索引当作键，因此这和值连接本质上没有区别， pandas 中利用 join 函数来处理索引连接，它的参数选择要少于 merge ，除了必须的 on 和 how 之外，可以对重复的列指定左右后缀 lsuffix 和 rsuffix。其中， on 参数指索引名，单层索引时省略参数表示按照当前索引连接。

df1 = pd.DataFrame({'Age':[20,30]},index=pd.Series(['San Zhang','Si Li'],name='Name'))
df1
Age
Name
San Zhang 20
Si Li 30 
df2 = pd.DataFrame({'Gender':['F','M']},index=pd.Series(['Si Li','Wu Wang'],name='Name'))
df2
Gender
Name
Si Li F
Wu Wang M 
df1.join(df2, how='left')
Age Gender
Name
San Zhang 20 NaN
Si Li 30 F

仿照第2小节的例子，写出语文和数学分数合并的 join 版本：

df1 = pd.DataFrame({'Grade':[70]},index=pd.Series(['San Zhang'],name='Name'))
df2 = pd.DataFrame({'Grade':[80]},index=pd.Series(['San Zhang'],name='Name'))df1.join(df2, how='left', lsuffix='_Chinese', rsuffix='_Math')
Grade_Chinese Grade_Math
Name
San Zhang 70 80

如果想要进行类似于 merge 中以多列为键的操作的时候， join 需要使用多级索引，例如在 merge 中的最后一个例子可以如下写出：

df1 = pd.DataFrame({'Age':[20,21]},index=pd.MultiIndex.from_arrays([['San Zhang', 'San Zhang'],['one', 'two']],names=('Name','Class')))
df1
Age
Name Class
San Zhang one 20
two 21 
df2 = pd.DataFrame({'Gender':['F', 'M']},index=pd.MultiIndex.from_arrays([['San Zhang', 'San Zhang'],['two', 'one']],names=('Name','Class')))
df2
Gender
Name Class
San Zhang two F
one M 
df1.join(df2)
Age Gender
Name Class
San Zhang one 20 M
two 21 F

方向连接（拼接）

concat（纵向或者横向拼接）

前面介绍了关系型连接，其中最重要的参数是 on 和 how，但有时候用户并不关心以哪一列为键来合并，只是希望把两个表或者多个表按照纵向或者横向拼接，为这种需求， pandas 中提供了 concat 函数来实现。

在 concat 中，最常用的有三个参数，它们是 axis, join, keys，分别表示拼接方向，连接形式，以及在新表中指示来自于哪一张旧表的名字。这里需要特别注意， join 和 keys 与之前提到的 join 函数和键的概念没有任何关系。

在默认状态下的 axis=0 ，表示纵向拼接多个表，常常用于多个样本的拼接；而 axis=1 表示横向拼接多个表，常用于多个字段或特征的拼接。

例如，纵向合并各表中人的信息：

df1 = pd.DataFrame({'Name':['San Zhang','Si Li'],'Age':[20,30]})
df2 = pd.DataFrame({'Name':['Wu Wang'], 'Age':[40]})pd.concat([df1, df2])
Name Age
0 San Zhang 20
1 Si Li 30
0 Wu Wang 40

横向合并各表中的字段：

df2 = pd.DataFrame({'Grade':[80, 90]})
df3 = pd.DataFrame({'Gender':['M', 'F']})
pd.concat([df1, df2, df3], 1)
Name Age Grade Gender
0 San Zhang 20 80 M
1 Si Li 30 90 F

虽然说 concat 不是处理关系型合并的函数，但是它仍然是关于索引进行连接的。纵向拼接会根据列索引对其，默认状态下 join=outer ，表示保留所有的列，并将不存在的值设为缺失； join=inner ，表示保留两个表都出现过的列。横向拼接则根据行索引对齐， join 参数可以类似设置。

df2 = pd.DataFrame({'Name':['Wu Wang'], 'Gender':['M']})
pd.concat([df1, df2])
Name Age Gender
0 San Zhang 20.0 NaN
1 Si Li 30.0 NaN
0 Wu Wang NaN M 
df2 = pd.DataFrame({'Grade':[80, 90]}, index=[1, 2])
pd.concat([df1, df2], 1)
Name Age Grade
0 San Zhang 20.0 NaN
1 Si Li 30.0 80.0
2 NaN NaN 90.0 
pd.concat([df1, df2], axis=1, join='inner')
Name Age Grade
1 Si Li 30 80

因此，当确认要使用多表直接的方向合并时，尤其是横向的合并，可以先用 reset_index 方法恢复默认整数索引再进行合并，防止出现由索引的误对齐和重复索引的笛卡尔积带来的错误结果。

最后， keys 参数的使用场景在于多个表合并后，用户仍然想要知道新表中的数据来自于哪个原表，这时可以通过 keys 参数产生多级索引进行标记。例如，第一个表中都是一班的同学，而第二个表中都是二班的同学，可以使用如下方式合并：

df1 = pd.DataFrame({'Name':['San Zhang','Si Li'],'Age':[20,21]})
df2 = pd.DataFrame({'Name':['Wu Wang'],'Age':[21]})
pd.concat([df1, df2], keys=['one', 'two'])
Name Age
one 0 San Zhang 20
1 Si Li 21
two 0 Wu Wang 21

序列与表的合并

利用 concat 可以实现多个表之间的方向拼接，如果想要把一个序列追加到表的行末或者列末，则可以分别使用 append 和 assign 方法。

在 append 中，如果原表是默认整数序列的索引，那么可以使用 ignore_index=True 对新序列对应索引的自动标号，否则必须对 Series 指定 name 属性。

df1
Name Age
0 San Zhang 20
1 Si Li 21 
s = pd.Series(['Wu Wang', 21], index = df1.columns)df1.append(s, ignore_index=True)
Name Age
0 San Zhang 20
1 Si Li 21
2 Wu Wang 21

对于 assign 而言，虽然可以利用其添加新的列，但一般通过 df[‘new_col’] = … 的形式就可以等价地添加新列。同时，使用 [] 修改的缺点是它会直接在原表上进行改动，而 assign 返回的是一个临时副本：

s = pd.Series([80, 90])
df1.assign(Grade=s)
Name Age Grade
0 San Zhang 20 80
1 Si Li 21 90 
df1 # assign 返回的是一个临时副本，df1并没有被改变
Name Age
0 San Zhang 20
1 Si Li 21 
df1['Grade'] = s # 添加新的列，df1被改变
df1
Name Age Grade
0 San Zhang 20 80
1 Si Li 21 90

类连接操作

除了上述介绍的若干连接函数之外， pandas 中还设计了一些函数能够对两个表进行某些操作，这里把它们统称为类连接操作。

比较

compare 能够比较两个表或者序列的不同处并将其汇总展示：

df1 = pd.DataFrame({'Name':['San Zhang', 'Si Li', 'Wu Wang'],'Age':[20, 21 ,21],'Class':['one', 'two', 'three']})
df1
Name Age Class
0 San Zhang 20 one
1 Si Li 21 two
2 Wu Wang 21 three 
df2 = pd.DataFrame({'Name':['San Zhang', 'Li Si', 'Wu Wang'],'Age':[20, 21 ,21],'Class':['one', 'two', 'Three']})
df2
Name Age Class
0 San Zhang 20 one
1 Li Si 21 two
2 Wu Wang 21 Three 
df1.compare(df2)
Name Class
self other self other
1 Si Li Li Si NaN NaN
2 NaN NaN three Three

结果中返回了不同值所在的行列，如果相同则会被填充为缺失值 NaN ，其中 other 和 self 分别指代传入的参数表和被调用的表自身。

如果想要完整显示表中所有元素的比较情况，可以设置 keep_shape=True ：

df1.compare(df2, keep_shape=True)
Name Age Class
self other self other self other
0 NaN NaN NaN NaN NaN NaN
1 Si Li Li Si NaN NaN NaN NaN
2 NaN NaN NaN NaN three Three

组合

combine 函数能够让两张表按照一定的规则进行组合，在进行规则比较时会自动进行列索引的对齐。对于传入的函数而言，每一次操作中输入的参数是来自两个表的同名 Series，依次传入的列是两个表列名的并集，例如下面这个例子会依次传入 A,B,C,D 四组序列，每组为左右表的两个序列。同时，进行 A 列比较的时候， s1 指代的就是一个全空的序列，因为它在被调用的表中并不存在，并且来自第一个表的序列索引会被 reindex 成两个索引的并集。具体的过程可以通过在传入的函数中插入适当的 print 方法查看。

下面的例子表示选出对应索引位置较小的元素：

def choose_min(s1, s2):s2 = s2.reindex_like(s1) print(s2)res = s1.where(s1<s2, s2)res = res.mask(s1.isna()) # isna表示是否为缺失值，返回布尔序列return res

df1 = pd.DataFrame({'A':[1,2], 'B':[3,4], 'C':[5,6]})
df1
A B C
0 1 3 5
1 2 4 6 
df2 = pd.DataFrame({'B':[5,6], 'C':[7,8], 'D':[9,10]}, index=[1,2])
df2
B C D
1 5 7 9
2 6 8 10 
df1.combine(df2, choose_min)

0   NaN
1   NaN
2   NaN
Name: A, dtype: float64
0    NaN
1    5.0
2    6.0
Name: B, dtype: float64
0    NaN
1    7.0
2    8.0
Name: C, dtype: float64
0     NaN
1     9.0
2    10.0
Name: D, dtype: float64
A B C D
0 NaN NaN NaN NaN
1 NaN 4.0 6.0 NaN
2 NaN NaN NaN NaN

Question: 请在上述代码的基础上修改，保留 df2 中4个未被 df1 替换的相应位置原始值。

def choose_min_1(s1, s2):s2 = s2.reindex_like(s1) res = s1.where(s1<s2, s2)return res

df1.combine(df2, choose_min_1)
A B C D
0 NaN NaN NaN NaN
1 NaN 4.0 6.0 9.0
2 NaN 6.0 8.0 10.0

此外，设置 overtwrite 参数为 False 可以保留被调用表中未出现在传入的参数表中的列，而不会设置未缺失值：

df1.combine(df2, choose_min, overwrite=False)
A B C D
0 1.0 NaN NaN NaN
1 2.0 4.0 6.0 NaN
2 NaN NaN NaN NaN

Question： 除了 combine 之外， pandas 中还有一个 combine_first 方法，其功能是在对两张表组合时，若第二张表中的值在第一张表中对应索引位置的值不是缺失状态，那么就使用第一张表的值填充。下面给出一个例子，请用 combine 函数完成相同的功能。

df1 = pd.DataFrame({'A':[1,2], 'B':[3,np.nan]})
df2 = pd.DataFrame({'A':[5,6], 'B':[7,8]}, index=[1,2])
df1.combine_first(df2)
A B
0 1.0 3.0
1 2.0 7.0
2 6.0 8.0 
def my_combine_first(s1, s2):s2 = s2.reindex_like(s1) res = s2.where(s1.isna(), s1)return resdf1.combine(df2, my_combine_first)
A B
0 1.0 3.0
1 2.0 7.0
2 6.0 8.0

练习

美国疫情数据集

现有美国4月12日至11月16日的疫情报表，请将 New York 的 Confirmed, Deaths, Recovered, Active 合并为一张表。

date = pd.date_range('20200412', '20201116').to_series()
date = date.dt.month.astype('string').str.zfill(2) +'-'+ date.dt.day.astype('string').str.zfill(2) +'-'+ '2020'
date = date.tolist()
date[:5]

['04-12-2020', '04-13-2020', '04-14-2020', '04-15-2020', '04-16-2020']

L = []
for d in date:df = pd.read_csv('G:/代码/joyful-pandas-master/data/us_report/' + d + '.csv', index_col='Province_State')data = df.loc['New York', ['Confirmed','Deaths','Recovered','Active']]L.append(data.to_frame().T)res = pd.concat(L)
res.index = date
res.head()
Confirmed Deaths Recovered Active
04-12-2020 189033 9385 23887 179648
04-13-2020 195749 10058 23887 185691
04-14-2020 203020 10842 23887 192178
04-15-2020 214454 11617 23887 202837
04-16-2020 223691 14832 23887 208859

实现 join 函数

请实现带有 how 参数的 join 函数

  • 假设连接的两表无公共列

  • 调用方式为 join(df1, df2, how=“left”)

  • 给出测试样例

df1 = pd.DataFrame({'Alp':['A','B','C'],'Num':[1,2,3]},index=pd.Series(['L1','L2','L3'],name='Ind'))
df1
Alp Num
Ind
L1 A 1
L2 B 2
L3 C 3 
df2 = pd.DataFrame({'Bet':['D','E','F','G'],'Number':[2,4,6,8]},index=pd.Series(['L1','L3','L5','L7'],name='Ind'))
df2
Bet Number
Ind
L1 D 2
L3 E 4
L5 F 6
L7 G 8 
df1.join(df2,how='left')
Alp Num Bet Number
Ind
L1 A 1 D 2.0
L2 B 2 NaN NaN
L3 C 3 E 4.0 
# 方法一
def my_join(df1,df2,how = 'left'):# 因为两表无公共列，所以只需要把df2中和df1具有相等index的列加到对应的位置if how == 'left': # 因为是左连接，所以以df1为基础，最终结果的行数和df1保持一致base = df1.copy()L1 = [i for i in df1.index if i in df2.index] # df1和df2相同的index，这些位置需要赋值C1 = [i for i in df2.columns if i not in df1.index] # df2中出现，df1中未出现的列，需要把这些列添加到df1中base[C1] = np.full((df1.shape[0],len(C1)), np.nan) # 添加这些列到df1中base.loc[L1,C1]  = df2.loc[L1,C1] # 再对对应的位置进行赋值return base
# 此处只写出how = 'left'的
# how = 'right'的只需要把以df1为基础改成以df2为基础
# how = 'inner'的只需要把以df1为基础改成以df1和df2的交集为基础
# how = 'outer'的只需要把以df1为基础改成以df1和df2的并集为基础

my_join(df1,df2,how = 'left')
Alp Num Bet Number
Ind
L1 A 1 D 2.0
L2 B 2 NaN NaN
L3 C 3 E 4.0 
# 方法二
# 只能应用于列数为1的情形
def another_join(df1, df2, how='left'):res_col = df1.columns.tolist() +  df2.columns.tolist()dup = df1.index.unique().intersection(df2.index.unique())res_df = pd.DataFrame(columns = res_col)for label in dup:cartesian = [list(i)+list(j) for i in df1.loc[label].values for j in df2.loc[label].values]dup_df = pd.DataFrame(cartesian, index = [label]*len(cartesian), columns = res_col)res_df = pd.concat([res_df,dup_df])if how in ['left', 'outer']:for label in df1.index.unique().difference(dup):if isinstance(df1.loc[label], pd.DataFrame):cat = [list(i)+[np.nan]*df2.shape[1] for i in df1.loc[label].values]else: cat = [list(i)+[np.nan]*df2.shape[1] for i in df1.loc[label].to_frame().values]dup_df = pd.DataFrame(cat, index = [label]*len(cat), columns = res_col)res_df = pd.concat([res_df,dup_df])if how in ['right', 'outer']:for label in df2.index.unique().difference(dup):if isinstance(df2.loc[label], pd.DataFrame):cat = [[np.nan]+list(i)*df1.shape[1] for i in df2.loc[label].values]                else: cat = [[np.nan]+list(i)*df1.shape[1] for i in df2.loc[label].to_frame().values]dup_df = pd.DataFrame(cat, index = [label]*len(cat), columns = res_col)res_df = pd.concat([res_df,dup_df])return res_df

df1 = pd.DataFrame({'col1':list('123')}, index=list('ABC'))
df2 = pd.DataFrame({'col2':list('02468')}, index=list('ABCDE'))
another_join(df1, df2, how='left')
col1 col2
A 1 0
B 2 2
C 3 4

Pandas学习——连接相关推荐

  1. python中 s是什么意思_什么是Pandas？Pandas学习什么？

    pandas数据分析核心工具包,基于numpy构建,为数据分析而存在!具有以下特点: 1.一位数组Series+二维数组Dataframe 2.可直接读取数据做处理 3.兼容各种数据库 4.支持各种分 ...

  2. pandas python2_Python数据分析之pandas学习（二）

    有关pandas模块的学习与应用主要介绍以下8个部分: 1.数据结构简介:DataFrame和Series 2.数据索引index 3.利用pandas查询数据 4.利用pandas的DataFram ...

  3. Pandas 学习手册中文第二版：1~5

    原文:Learning pandas 协议:CC BY-NC-SA 4.0 译者:飞龙 一.Pandas 与数据分析 欢迎来到<Pandas 学习手册>! 在本书中,我们将进行一次探索我们 ...

  4. pandas学习笔记之DateFrame

    pandas学习笔记之DateFrame 文章目录 pandas学习笔记之DateFrame 1.DateFrame的创建 1)认识DataFrame对象 2)由二维列表创建(默认index和colu ...

  5. python数据分析-pandas学习

    文章目录 一.pandas环境的搭建 1.pandas 简介 2.pandas安装和调用 二.pandas学习 1.pandas简介 2.pandas学习资源 3.pandas核心数据结构 4.Ser ...

  6. 数据分析之pandas学习笔记（六）（层次化索引、重塑、轴向旋转、行列变换、合并表数据）

    数据分析之Pandas学习笔记(六)(层次化索引.重塑.轴向旋转.行列变换.合并表数据) level层次化索引 unstack()与stack()进行重塑,即:行列索引变换 swaplevel()交换 ...

  7. pandas学习(数据分组与分组运算、离散化处理、数据合并)

    pandas学习(数据分组与分组运算.离散化处理.数据合并) 目录 数据分组与分组运算 离散化处理 数据合并 数据分组与分组运算 GroupBy技术:实现数据的分组,和分组运算,作用类似于数据透视表数 ...

  8. Pandas学习（三）---数值运算

    Pandas学习--数值运算 数值计算和统计基础 常用数学.统计方法 基本参数:axis.skipna 主要数学计算方法,可用于Series和DataFrame(1) 主要数学计算方法,可用于Seri ...

  9. [Pandas 学习笔记] - No.1 pandas学习笔记

    pandas学习笔记 pandas是基于numpy开发出的数据分析包,用于高效地操作大型数据集.pandas的数据结构有三种 分别为 series,dataframe和panel,对应一维,二维,三维 ...

最新文章

  1. mac下导出kindle单词本的单词
  2. Json和XML之间的对比
  3. Qt OpenGL 问题总结
  4. LeetCode 2201. 统计可以提取的工件（哈希）
  5. PLSQL 设置日期格式为年月日不显示时分秒
  6. 大话项目管理工具之Confluence篇
  7. css不继承上级样式_【FrontEnd】CSS
  8. negative binomial（Pascal） distribution —— 负二项式分布（帕斯卡分布）
  9. 一句python，一句R︱python中的字符串操作、中文乱码、NaN情况
  10. 全国地图poi数据下载
  11. 学习C语言必须掌握的10个经典的C语言小程序
  12. 永磁同步电机的直接转矩控制（三）一一一滑模控制器改进DTC
  13. visio2019画思维导图
  14. IGBT最小死区时间计算
  15. Oracle基础——第一章 Oracle简介
  16. libreCAD使用
  17. cython大白话基础教程
  18. 什么是Cookie和Session？—— Cookie和Session的区别？—— 一文教你理解清楚什么是Cookie和Session，以及常见的开发面试问题？
  19. bzoj2448 挖油
  20. 如何免费创建一个自己的网站(可通过外网访问)

热门文章

  1. 解读多重启动引导文件——BOOT.INI
  2. JSJ——java基本概念一
  3. CentOS7挂载CentOS7 everything安装光盘和设置yum源为挂载的光盘
  4. Mac环境下利用Python解锁ViVo BL锁
  5. python json和java json的使用
  6. Unity2d游戏开发日志（菜只因版）-2月1日-视差
  7. Jmeter安装及配置教程
  8. kali入侵内网电脑和入侵外网电脑
  9. OpenCV-Python入门实战13例
  10. 我，90后，有点想住养老院