2 Python数据分析 Tushare双均线与金叉死叉日期 Pandas数据清洗级联操作合并操作

最新推荐文章于 2024-06-11 11:09:35 发布

Jianhao92

最新推荐文章于 2024-06-11 11:09:35 发布

阅读量2.9k

点赞数 1

分类专栏： Python数据分析文章标签：数据分析 python

本文链接：https://blog.csdn.net/qq_36565509/article/details/107338818

版权

Python数据分析专栏收录该内容

5 篇文章 2 订阅

订阅专栏

Python数据分析

1 Tushare股票分析

1.1 准备数据

平安银行[000001]

import tushare as ts
import numpy as np
import pandas as pd
from pandas import Series, DataFrame

df = ts.get_k_data(code='000001', start='2010-01')
df.to_csv('pingan.csv')
df = pd.read_csv('pingan.csv')
df.drop(labels='Unnamed: 0', axis=1, inplace=True)
df['date'] = pd.to_datetime(df['date'])
df.set_index('date', inplace=True)
df.head()
'''
			 open	close	 high	  low	   volume	code
	  date						
2010-01-04	8.149	7.880	8.169	7.870	241922.76	   1
2010-01-05	7.893	7.743	7.943	7.560	556499.82	   1
2010-01-06	7.727	7.610	7.727	7.551	412143.13	   1
2010-01-07	7.610	7.527	7.660	7.444	355336.85	   1
2010-01-08	7.477	7.511	7.560	7.428	288543.06	   1
'''

1.2 双均线分析

1.2.1 移动平均线介绍

移动平均线，Moving Average(MA)，简称均线，将一定时期内的股票价格加以平均，并把不同时间的平均值连接起来，形成一根MA，是用以观察股票价格变动趋势的一种技术指标。
移动平均线常用的有5日、10日、30日、60日、120日和240日。
5日和10日的MA是短线操作的参照指标，称做日均线指标；
30日和60日的是中期均线指标，称做季均线指标；
120日和240日的是长期均线指标，称做年均线指标。

均线计算方法
MA = (C1 + C2 + C3 + … + Cn) / N
其中C为某日的收盘价，N为移动平均周期(天数)。

1.2.2 案例

需求：获取该股票历史数据的5日均线和30日均线。

1.2.2.1 时间窗函数rolling

窗口，就是将某个点扩大到包含这个点的一段区间，对区间来进行操作。
函数rolling的参数window表示时间窗的大小，可以用数字来表示向前观测数据的数量。

df['close'].rolling(5)  # Rolling [window=5, center=False, axis=0]

对区间进行操作
前4条数据无法继续向前取5条数据，因此操作结果为NaN。

df['close'].rolling(5).mean().head(10)
'''
date
2010-01-04       NaN
2010-01-05       NaN
2010-01-06       NaN
2010-01-07       NaN
2010-01-08    7.6542
2010-01-11    7.5804
2010-01-12    7.5240
2010-01-13    7.3952
2010-01-14    7.2836
2010-01-15    7.2058
Name: close, dtype: float64
'''

1.2.2.2 绘制双均线

import matplotlib.pyplot as plt

ma5 = df['close'].rolling(5).mean()
ma30 = df['close'].rolling(30).mean()
plt.plot(ma5)
plt.plot(ma30)

在这里插入图片描述

1.3 金叉日期与死叉日期

1.3.1 金叉与死叉介绍

叉指的是股票分析中短期均线与长期均线的交叉的交叉点。
如果短期均线主动向上穿越了长期均线，这个交叉点称为金叉；
如果短期均线主动向下穿越了长期均线，这个交叉点称为死叉。
但如果长期均线向下或变缓，同时短期均线向上穿越了长期均线，这个交叉点就不能叫金叉，死叉也如此。
出现金叉时，短期线从下向上突破长期线是买入信号，趋向买入，
出现死叉时，短期线从上向下跌穿过长期线是卖出信号，则趋向卖出。
在这里插入图片描述

1.3.2 案例1

需求：获取2010年至今所有金叉日期和死叉日期。

ma5 = df['close'].rolling(5).mean()
ma30 = df['close'].rolling(30).mean()

s1 = ma5 < ma30
s2 = ma5 > ma30

分析
金叉的左侧短期均线ma5低于长期均线ma30，金叉的右侧ma5高于长期均线ma30，因此金叉的左侧s1为True，s2为False，金叉的左侧s1为False，s2为True。当s1由True变为False时会出现金叉，当s1由False变为True时会出现死叉。

s
s1	T	T	F	F	F	T	T	F
s2	F	F	T	T	T	F	F	T
s2.shift(1)		F	F	T	T	T	F	F
`s1 & s2.shift(1)`		F	F	F	F	T	F	F
`s1 \| s2.shift(1)`		T	F	T	T	T	T	F
`~s1 \| s2.shift(1)`		F	T	F	F	F	F	T
			金叉			死叉		金叉

# 死叉
df.loc[s1 & s2.shift(1)]  # 死叉对应的数据
death_date = df.loc[s1 & s2.shift(1)].index  # 死叉出现的日期

# 金叉
df.loc[~(s1 | s2.shift(1))]  # 金叉对应的数据
golden_date = df.loc[~(s1 | s2.shift(1))].index  # 金叉出现的日期

1.3.3 案例2

如果从2010年1月1日开始，初始资金为100000元，金叉尽量买入，死叉全部卖出，分析截止到今天炒股收益。

取出指定时间段的数据

df_new = df['2010':'2020']

获取金叉日期和死叉日期
注意，前29日的ma30无法计算，为NaN，因此需要除去。

ma5_new = df_new['close'].rolling(5).mean()
ma30_new = df_new['close'].rolling(30).mean()
ma5_new = ma5_new[29:] 
ma30_new = ma30_new[29:] 
s1_new = ma5_new < ma30_new 
s2_new = ma5_new > ma30_new

# 死叉日期
death_date_new = df_new[29:].loc[s1_new & s2_new.shift(1)].index
# 金叉日期
golden_date_new = df_new[29:].loc[~(s1_new | s2_new.shift(1))].index

金叉尽量买入，死叉全部卖出。
买卖股票单价使用开盘价。
特殊情况：

如果昨天为金叉，则只能买入不能卖出；
如果手里有剩余股票，需要将剩余股票价值计算到总收益中。

将金叉日期和死叉日期分别存储到两个Series中，将日期作为索引，将1和0分别设置为值，其中1对应的日期为金叉日期，0对应的日期为死叉日期。

golden_date_series = Series(data=1, index=golden_date_new)
death_date_series = Series(data=0, index=death_date_new)

拼接两张表

all_series = golden_date_series.append(death_date_series).sort_index().sort_index()

计算总收益

initial_money = 100000  # 初始本金(固定)
hold_money = initial_money  # 手中持有金额(可变，开始时等于初始本金)
hold_shares = 0  # 持有股票支数(可变，开始时为0)

for date in all_series.index:
    # date是all_series的显式索引
    if all_series[date] == 1: 
        # 当日为金叉，需要买入股票。
        price = df_new['open'][date]  # 股票单价，开盘价
        # 尽量消耗持有本金所能购买的最大股票支数
        max_purchases = hold_money // (price * 100)
        hold_shares += max_purchases * 100
        hold_money -= (hold_shares * price)
    else:  
        # 当日为死叉，需要卖出股票。
        price = df_new['open'][date]  # 股票单价，开盘价
        hold_money += (price * hold_shares)
        hold_shares = 0 

# 计算剩余股票价值(可以根据持有股票支数hold_shares判断是否有剩余股票)
hold_shares_money = hold_shares * df_new['open'][-1]
print(hold_shares_money)
# 计算总收益
print(hold_money - initial_money)  # -36499.500000000466

2 Pandas数据清洗

2.1 介绍

数据清洗(Data cleaning)对数据进行重新审查和校验的过程，目的在于删除重复信息、处理无效值和缺失值等。

2.2 处理缺失数据

2.2.1 缺失数据类型

导入包

import numpy as np
import pandas as pd
from pandas import DataFrame

Pandas中存在两种缺失数据类型：None 和 np.nan

区别：
None不能参与计算，否则直接报错(TypeError)；
np.nan属于float类型，可以参与计算，结果为nan。

type(None)  # NoneType
type(np.nan)  # float
np.nan + 1  # nan

数据分析中会使用某些运算来处理原始数据，如果原数数据中的空值为nan，则不会干扰或者中断运算。
如果遇到了None形式的空值，Pandas会自动将其转换成nan。

df = DataFrame(data=np.random.randint(0, 100, size=(3, 4)))
df.iloc[1,1] = None
df.iloc[0,0] = np.nan
'''
    0	    1       2	3
0	NaN	    31.0	92	81
1	17.0	NaN	    8	84
2	38.0	49.0	33	88
'''

2.2.2 Pandas处理缺失数据

2.2.2.1 判断是否存在缺失数据 isnull，notnull, any, all

isnull，notnull
用于判断某个元素是否为缺失数据。

df.isnull()  # 缺失值为True，非缺失值为False。
'''
    0	    1	    2	    3
0	True	False	False	False
1	False	True	False	False
2	False	False	False	False
'''

df.notnull()  # 缺失值为False，非缺失值为True。
'''
    0	    1	    2	    3
0	False	True	True	True
1	True	False	True	True
2	True	True	True	True
'''

any, all
any：序列中存在一个True就返回True，否则为False；
all：序列中所有的值均为True才返回True，否则为False。
isnull/notnull 配合 any/all，用于判断每一个行/列中是否存在缺失数据。
axis=0 检测列(默认)中是否存在空值，
axis=1 检测行中是否存在空值。

df.isnull().any()
df.isnull().any(axis=0)  # 列
'''
0     True
1     True
2     False
3     False
dtype: bool
'''

df.isnull().any(axis=1)  # 行
'''
0     False
1     False
2     True
dtype: bool
'''

结合df.loc

取出不存在缺失数据的行及行号

df.loc[df.notnull().all(axis=1)]  # 行
'''
	0		1		2	3
2	38.0	49.0	33	88
'''
df.loc[df.notnull().all(axis=1)].index
# Int64Index([2], dtype='int64')

取出存在缺失数据的行及行号

df.loc[df.isnull().any(axis=1)]
'''
	0		1		2	3
0	NaN		31.0	92	81
1	17.0	NaN		8	84
'''
df.loc[df.isnull().any(axis=1)].index
# Int64Index([0, 1], dtype='int64')

2.2.2.2 清除缺失数据 dropna

清除指定行号的行

nan_indexs = df.loc[df.isnull().any(axis=1)].index
df.drop(labels=nan_indexs, axis=0)
'''
	0		1		2	3
2	38.0	49.0	33	88
'''

直接删除存在缺失值的行/列
注意，drop系列函数中axis=0表示行，axis=1表示列。

df.dropna(axis=0)  # 行
'''
	0		1		2	3
2	38.0	49.0	33	88
'''
df.dropna(axis=1)  # 列
'''
	2	3
0	92	81
1	8	84
2	33	88
'''

2.2.2.3 填充缺失数据 fillna

使用指定值填充缺失值。

df.fillna(value=0)
'''
	0		1		2	3
0	0.0		31.0	92	81
1	17.0	0.0		8	84
2	38.0	49.0	33	88
'''

使用近邻值填充缺失值。
method=ffill表示用缺失值的前一个值去填充缺失值，
method=bfill表示用缺失值的后一个值去填充缺失值。
axis={0 or ‘index’, 1 or ‘columns’}，0表示在列方向上下填充，1表示在行方向左右填充。
参数axis需要配合参数method使用，一般会使用缺失值所在列中的前一个/后一个值来填充缺失值，因此需要axis=0来指定列。

df
'''
	0		1		2	3
0	NaN		84.0	43	14
1	28.0	NaN		67	25
2	66.0	94.0	48	24
'''

df.fillna(method='ffill', axis=0)  
df.fillna(method='ffill', axis='index')  
# 用缺失值的前一个值去填充缺失值。
'''
	0		1		2	3
0	NaN		84.0	43	14
1	28.0	84.0	67	25
2	66.0	94.0	48	24
'''
df.fillna(method='bfill', axis=0)  
df.fillna(method='bfill', axis='index')  
# 用缺失值的后一个值去填充缺失值。
'''
	0		1		2	3
0	28.0	84.0	43	14
1	28.0	94.0	67	25
2	66.0	94.0	48	24
'''

2.2.3 处理缺失数据案例

数据说明：数据是1个冷库的温度数据，1-7对应7个温度采集设备，1分钟采集一次。
数据来源：https://download.csdn.net/download/qq_36565509/12619016
观察数据

raw_data = pd.read_excel('./testData.xlsx')
raw_data.head()
'''
				   time none	    1	    2	    3	    4 none1	    5	    6	    7
0	2019-01-27 17:00:00	 NaN	-24.8	-18.2	-20.8	-18.8	NaN	  NaN	  NaN	  NaN
1	2019-01-27 17:01:00	 NaN	-23.5	-18.8	-20.5	-19.8	NaN	-15.2	-14.5	-16.0
2	2019-01-27 17:02:00	 NaN	-23.2	-19.2	  NaN	  NaN	NaN	-13.0	  NaN	-14.0
3	2019-01-27 17:03:00	 NaN	-22.8	-19.2	-20.0	-20.5	NaN	  NaN	-12.2	 -9.8
4	2019-01-27 17:04:00	 NaN	-23.2	-18.5	-20.0	-18.8	NaN	-10.2	-10.8	 -8.8
'''

删除列none和none1

raw_data = pd.read_excel('./testData.xlsx')
data = raw_data.drop(labels=['none', 'none1'], axis=1)
data.shape  # (1060, 8)

方案1：删除存在缺失值的行

data1 = data.dropna(axis=0)
data1.shape  # (927, 8)

方案2：使用近邻值填充缺失值

data2 = data.fillna(method='ffill', axis=0).fillna(method='bfill', axis=0)

2.2.4 处理重复数据

2.2.4.1 准备数据

df = DataFrame(data=np.random.randint(0, 100, size=(6, 8)))
df.iloc[1] = [1,1,1,1,1,1,1,1]
df.iloc[3] = [1,1,1,1,1,1,1,1]
df.iloc[5] = [1,1,1,1,1,1,1,1]
'''
	0	1	2	3	4	5	6	7
0	37	94	78	53	36	72	36	69
1	1	1	1	1	1	1	1	1
2	68	6	28	89	5	38	35	48
3	1	1	1	1	1	1	1	1
4	84	2	87	47	62	29	92	40
5	1	1	1	1	1	1	1	1
'''

2.2.4.2 duplicated

duplicated函数用于标记Series或DataFrame中的行数据是否重复，重复为True，否则为False。

pandas.DataFrame.duplicated(self, subset=None, keep='first')

subset：用于识别重复的列标签或列标签序列，默认为所有列标签；
keep=‘frist’：第一次出现外，其余相同的均被标记为重复；
keep=‘last’：最后一次出现外，其余相同的均被标记为重复；
keep=False：所有相同的都被标记为重复。

2.2.4.3 判断是否为重复行数据

第一次出现外，其余相同的行均被标记为重复。

df.duplicated(keep='first')
'''
0    False
1    False
2    False
3     True
4    False
5     True
dtype: bool
'''

2.2.4.4 获取非重复行数据

df.loc[~df.duplicated(keep='first')]
'''
	0	1	2	3	4	5	6	7
0	37	94	78	53	36	72	36	69
1	1	1	1	1	1	1	1	1
2	68	6	28	89	5	38	35	48
4	84	2	87	47	62	29	92	40
'''

2.2.4.5 直接删除重复行数据 drop_duplicates

df.drop_duplicates(keep='first')
'''
	0	1	2	3	4	5	6	7
0	37	94	78	53	36	72	36	69
1	1	1	1	1	1	1	1	1
2	68	6	28	89	5	38	35	48
4	84	2	87	47	62	29	92	40
'''

2.2.5 处理异常数据

目标：自定义一个1000行3列（A，B，C）取值范围为0-1的数据，然后对C列中值大于其两倍标准差的异常值进行清洗。

2.2.5.1 准备数据

df = DataFrame(data=np.random.random(size=(1000, 3)), columns=['A', 'B', 'C'])
df.head()
'''
		   A	       B	       C
0	0.118990	0.649505	0.978472
1	0.830928	0.120502	0.743489
2	0.081553	0.648753	0.952130
3	0.994736	0.408437	0.011220
4	0.959329	0.865392	0.110883
'''

2.2.5.2 清洗数据

计算C列标准差

df['C'].std()  # 0.28356614551282616

异常数据条件：C列中值大于其两倍标准差的数据。

twice_std = df['C'].std() * 2  # 0.5671322910256523
df['C'] > twice_std
'''
0       True
1       True
2       True
3      False
4      False
...
'''

df.loc[~(df['C'] > twice_std)]
'''
3	0.537346	0.339687	0.276611
4	0.414794	0.179321	0.094958
5	0.397169	0.610316	0.420824
7	0.740718	0.730160	0.302804
...
'''

3 级联操作与合并操作

3.1 级联操作

3.1.1 concat

import pandas as pd

pd.concat(object, axis=0, join='outer', join_axes=None, ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False)

重要参数说明
object：series，dataframe或则是panel构成的序列list；
axis：指定合并连接的轴，0表示行，1表示列；
join：指定连接方式，inner或outer。

3.1.2 准备数据

import numpy as np
import pandas as pd

df1 = pd.DataFrame(data=np.random.randint(0, 100, size=(5, 3)), columns=['A', 'B', 'C'])
df1_copy = pd.DataFrame(data=np.random.randint(0, 100, size=(5, 3)), columns=['A', 'B', 'C'])
df2 = pd.DataFrame(data=np.random.randint(0, 100, size=(5, 3)), columns=['A', 'D', 'C'])

3.1.3 级联种类

3.1.3.1 匹配级联

匹配级联：行索引和列索引完全一致。

pd.concat((df1, df1_copy), axis=0)
'''
	A	B	C
0	74	1	71
1	80	84	61
2	59	93	74
3	80	59	52
4	72	4	8
0	65	0	1
1	30	70	13
2	48	40	11
3	63	48	29
4	96	93	91
'''

3.1.3.2 非匹配级联

非匹配级联：级联维度的索引不一致，即纵向级联时列索引不一致，横向级联时行索引不一致。

非匹配级联有两种连接方式：内连接inner 和外连接outer。
inner：inner方式只会对匹配的项进行连接；
outer：无论是否匹配，outer方式会将所有的项进行连接，将不存在的值设置为nan。
使用参数join指定连接方式，默认为外连接outer。

外连接outer

pd.concat((df1, df2), axis=0)
pd.concat((df1, df2), axis=0, join='outer')
'''
	A	B		C	D
0	67	61.0	36	NaN
1	67	63.0	11	NaN
2	80	43.0	52	NaN
3	59	39.0	18	NaN
4	7	75.0	21	NaN
0	49	NaN	    97	97.0
1	65	NaN	    21	89.0
2	64	NaN		42	88.0
3	32	NaN		62	42.0
4	58	NaN		12	66.0
'''

内连接inner

pd.concat((df1, df2), axis=0, join='inner')
'''
	A	C
0	67	36
1	67	11
2	80	52
3	59	18
4	7	21
0	49	97
1	65	21
2	64	42
3	32	62
4	58	12
'''

3.1.2 append

append方法无法指定级联方向，只能在列方向上进行级联。

df1.append(df2)
'''
	A	B		C	D
0	67	61.0	36	NaN
1	67	63.0	11	NaN
2	80	43.0	52	NaN
3	59	39.0	18	NaN
4	7	75.0	21	NaN
0	49	NaN	    97	97.0
1	65	NaN	    21	89.0
2	64	NaN		42	88.0
3	32	NaN		62	42.0
4	58	NaN		12	66.0
'''

3.2 合并操作

3.2.1 merge

merge函数可以将不同数据集依照某些字段(属性)进行合并操作，得到一个新的数据集。

pd.merge(left=DataFrame1, right=DataFrame2, how=‘inner’, on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=(’_x’, ‘_y’))

参数说明
how：inner(默认)，outer，left，right；
on：指定根据某列进行合并，必须存在于两个DateFrame中；
left_on：左连接，指定根据DataFrame1中的某列进行合并；
right_on：左连接，指定根据DataFrame2中的某列进行合并；
left_index：是否根据DataFrame1的行索引进行合并；
right_index：是否根据DataFrame2的行索引进行合并；
sort：是否对合并后的数据根据连接键进行排序；
suffixes：如果两个数据集中出现重复列，新数据集中加上后缀_x,_y进行区别。

3.2.2 merge与concat的区别

merge需要指定某列进行数据合并；
concat只是在行/列方向上进行表格拼接。

3.2.3 合并操作

3.2.3.1 一对一合并

from pandas import DataFrame

df1 = DataFrame({
    'employee': ['Bob', 'Jake', 'Lisa'],
    'group': ['Accounting', 'Engineering', 'Engineering'],
})
'''
	employee		group
0		 Bob   Accounting
1		Jake  Engineering
2		Lisa  Engineering
'''

df2 = DataFrame({
    'employee': ['Lisa', 'Bob', 'Jake'],
    'hire_date': [2004, 2008, 2012],
})
'''
    employee	hire_date
0		Lisa	     2004
1		 Bob	     2008
2		Jake		 2012
'''

参数on：指定根据某列进行合并，必须存在于两个DateFrame中。

pd.merge(df1, df2, on='employee')
'''
	employee		group	hire_date
0		 Bob   Accounting		 2008
1		Jake  Engineering		 2012
2		Lisa  Engineering		 2004
'''

如果不指定参数，默认根据两表中相同列进行合并，df1和df2的相同列是employee。

pd.merge(df1, df2)
'''
	employee		group	hire_date
0		 Bob   Accounting		 2008
1		Jake  Engineering		 2012
2		Lisa  Engineering		 2004
'''

3.2.3.2 一对多合并

df3 = DataFrame({
    'employee': ['Lisa', 'Jake'],
    'group': ['Accounting', 'Engineering'],
    'hire_date': [2004, 2016],
})
'''
	employee		 group	hire_date
0		Lisa	Accounting		 2004
1		Jake   Engineering		 2016
'''

df4 = DataFrame({
	'group': ['Accounting', 'Engineering', 'Engineering'],
	'supervisor': ['Carly', 'Guido', 'Steve'],
})
'''
		  group		supervisor
0	 Accounting			 Carly
1	Engineering			 Guido
2	Engineering			 Steve
'''

pd.merge(df3, df4)  # 相同列为group
'''
	employee	  	group	hire_date	supervisor
0		Lisa   Accounting		 2004	     Carly
1		Jake  Engineering	     2016		 Guido
2		Jake  Engineering		 2016		 Steve
'''

3.2.3.3 多对多合并

参数how：inner(默认)，outer，left，right。

df1 = DataFrame({
    'employee': ['Bob', 'Jake', 'Lisa'],
    'group': ['Accounting', 'Engineering', 'Engineering'],
})
'''
	employee		group
0		 Bob   Accounting
1		Jake  Engineering
2		Lisa  Engineering
'''

df5 = DataFrame({
    'group': ['Engineering', 'Engineering', 'HR'],
    'supervisor': ['Carly', 'Guido', 'Steve'],
})
'''
		  group		supervisor
0	Engineering			 Carly
1	Engineering	         Guido
2			 HR		     Steve
'''

pd.merge(df1, df5, how='inner')
'''
	employee		group	supervisor
0		Jake  Engineering		 Carly
1		Jake  Engineering		 Guido
2		Lisa  Engineering		 Carly
3		Lisa  Engineering		 Guido
'''

pd.merge(df1, df5, how='outer')
'''
	employee		group	supervisor
0		 Bob   Accounting		   NaN
1		Jake  Engineering		 Carly
2		Jake  Engineering		 Guido
3		Lisa  Engineering		 Carly
4		Lisa  Engineering		 Guido
5		 NaN		   HR		 Steve
'''

pd.merge(df1, df5, how='left')
'''
	employee		group	supervisor
0		 Bob   Accounting		   NaN
1		Jake  Engineering		 Carly
2		Jake  Engineering		 Guido
3		Lisa  Engineering		 Carly
4		Lisa  Engineering		 Guido
'''

pd.merge(df1, df5, how='right')
'''
	employee		group	supervisor
0		Jake  Engineering		 Carly
1		Jake  Engineering		 Guido
2		Lisa  Engineering		 Carly
3		Lisa  Engineering		 Guido
4		 NaN		   HR		 Steve
'''

3.2.3.4 key规范化

当两张表没有相同列时，可使用参数left_on和right_on分别指定左右表中的列作为连接列进行合并。

df1 = DataFrame({
    'employee': ['Bob', 'Jake', 'Lisa'],
    'group': ['Accounting', 'Engineering', 'Engineering'],
})
'''
	employee		group
0		 Bob   Accounting
1		Jake  Engineering
2		Lisa  Engineering
'''

df6 = DataFrame({
    'name': ['Lisa', 'Bob', 'Bill'],
    'hire_date': [1998, 2016, 2007],
})
'''
	name	hire_date
0	Lisa		 1998
1	 Bob		 2016
2	Bill		 2007
'''

pd.merge(df1, df6, left_on='employee', right_on='name')
'''
	employee		group		name	hire_date
0		 Bob   Accounting		 Bob		 2016
1		Lisa  Engineering		Lisa		 1998
'''

Jianhao92

关注

1
点赞
踩
38

收藏

觉得还不错? 一键收藏
1
评论
2 Python数据分析 Tushare双均线与金叉死叉日期 Pandas数据清洗级联操作合并操作

Python数据分析1 Tushare股票分析1.1 双均线策略制定1.2 金叉日期与死叉日期2 Pandas数据清洗2.1 介绍数据清洗(Data cleaning)对数据进行重新审查和校验的过程，目的在于删除重复信息、处理无效值和缺失值等。2.2 处理缺失数据2.2.1 缺失数据类型导入包import numpy as npimport pandas as pdfrom pandas import DataFramePandas中存在两种缺失数据类型：None 和 np.na
复制链接

扫一扫