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

#获取某只股票的历史行情数据
#code:字符串形式的股票代码
df = ts.get_k_data(code='600519',start='2000-01-01')
df
本接口即将停止更新，请尽快使用Pro版接口：https://tushare.pro/document/2

#将互联网上获取的股票数据存储到本地
df.to_csv('./maotai.csv')#调用to_xxx方法将df中的数据写入到本地进行存储

#将本地存储的数据读入到df
df = pd.read_csv('./maotai.csv')
df.head()

#需要对读取出来的数据进行相关的处理

#删除df中指定的一列
df.drop(labels='Unnamed: 0',axis=1,inplace=True)

#查看每一列的数据类型
df.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 4911 entries, 0 to 4910
Data columns (total 7 columns):
 #   Column  Non-Null Count  Dtype  
---  ------  --------------  -----  
 0   date    4911 non-null   object 
 1   open    4911 non-null   float64
 2   close   4911 non-null   float64
 3   high    4911 non-null   float64
 4   low     4911 non-null   float64
 5   volume  4911 non-null   float64
 6   code    4911 non-null   int64  
dtypes: float64(5), int64(1), object(1)
memory usage: 268.7+ KB

#将date列转为时间序列类型
df['date'] = pd.to_datetime(df['date'])

df.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 4911 entries, 0 to 4910
Data columns (total 7 columns):
 #   Column  Non-Null Count  Dtype         
---  ------  --------------  -----         
 0   date    4911 non-null   datetime64[ns]
 1   open    4911 non-null   float64       
 2   close   4911 non-null   float64       
 3   high    4911 non-null   float64       
 4   low     4911 non-null   float64       
 5   volume  4911 non-null   float64       
 6   code    4911 non-null   int64         
dtypes: datetime64[ns](1), float64(5), int64(1)
memory usage: 268.7 KB

#将date列作为源数据的行索引
df.set_index('date',inplace=True)

df.head()

#输出该股票所有收盘比开盘上涨3%以上的日期
#伪代码：（收盘-开盘）/开盘 > 0.03
(df['open'] - df['close']) / df['open'] > 0.03

#在分析的过程中如果产生了boolean值则下一步马上将布尔值作为源数据的行索引
 #如果布尔值作为df的行索引，则可以取出true对应的行数据，忽略false对应的行数据
df.loc[(df['open'] - df['close']) / df['open'] > 0.03] #获取了True对应的行数据（满足需求的行数据）

df.loc[(df['open'] - df['close']) / df['open'] > 0.03].index #df的行数据

DatetimeIndex(['2006-05-29', '2006-06-12', '2006-10-09', '2006-10-25',
               '2006-11-14', '2006-11-16', '2006-11-29', '2006-11-30',
               '2006-12-11', '2006-12-14',
               ...
               '2021-07-26', '2021-07-27', '2021-07-29', '2021-08-17',
               '2021-08-26', '2021-10-18', '2021-12-29', '2022-01-13',
               '2022-01-28', '2022-03-07'],
              dtype='datetime64[ns]', name='date', length=680, freq=None)

#输出该股票所有开盘比前日收盘跌幅超过2%的日期
#伪代码：(开盘-前日收盘)/前日收盘 < -0.02
(df['open'] - df['close'].shift(1))/df['close'].shift(1) < -0.02
#将布尔值作为源数据的行索引取出True对应的行数据
df.loc[(df['open'] - df['close'].shift(1))/df['close'].shift(1) < -0.02]

df.loc[(df['open'] - df['close'].shift(1))/df['close'].shift(1) < -0.02].index

DatetimeIndex(['2006-02-13', '2006-04-17', '2006-04-18', '2006-04-19',
               '2006-04-20', '2006-05-25', '2006-05-30', '2006-12-27',
               '2007-01-04', '2007-01-22',
               ...
               '2020-03-13', '2020-03-23', '2020-10-26', '2021-02-26',
               '2021-03-04', '2021-04-28', '2021-08-20', '2021-11-01',
               '2022-03-14', '2022-03-15'],
              dtype='datetime64[ns]', name='date', length=377, freq=None)

new_df = df['2010-01':'2020-02']
new_df

new_df.head(2)

#买股票：找每个月的第一个交易日对应的行数据（捕获到开盘价）==》每月的第一行数据
#根据月份从原始数据中提取指定的数据
#每月第一个交易日对应的行数据
df_monthly = new_df.resample('M').first()#数据的重新取样
df_monthly

#买入股票花费的总金额
cost = df_monthly['open'].sum()*100
cost

3245315.6

#卖出股票到手的钱
#特殊情况：2020年买入的股票卖不出去
new_df.resample('A').last()
#将2020年最后一行切出去
df_yearly = new_df.resample('A').last()[:-1]
df_yearly

#卖出股票到手的钱
resv = df_yearly['open'].sum()*1200
resv

3632786.4000000004

#最后手中剩余的股票需要估量其价值计算到总收益中
#使用昨天的收盘价作为剩余股票的单价
last_monry = 200*new_df['close'][-1]

#计算总收益
resv+last_monry-cost

591607.2000000002

df = pd.read_csv('./maotai.csv').drop(labels='Unnamed: 0',axis=1)
df

#将date列转为时间序列且将其作为源数据的行索引
df['date'] = pd.to_datetime(df['date'])

df.set_index('date',inplace=True)

df.head()

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

ma5

date
2001-08-27          NaN
2001-08-28          NaN
2001-08-29          NaN
2001-08-30          NaN
2001-08-31     -90.9912
                ...    
2022-03-09    1763.9760
2022-03-10    1762.8620
2022-03-11    1760.5640
2022-03-14    1759.1640
2022-03-15    1729.1240
Name: close, Length: 4911, dtype: float64

import matplotlib.pyplot as plt
%matplotlib inline
plt.plot(ma5[50:180])
plt.plot(ma30[50:180])

[<matplotlib.lines.Line2D at 0x21df8d5fb20>]

ma5 = ma5[30:]
ma30 = ma30[30:]

s1 = ma5 < ma30
s2 = ma5 > ma30

df = df[30:]

death_ex = s1 & s2.shift(1) #判定死叉的条件
df.loc[death_ex] #死叉对应的行数据
death_date = df.loc[death_ex].index

golden_ex = ~(s1 | s2.shift(1))#判定金叉的条件
golden_date = df.loc[golden_ex].index #金叉的时间

s1 = Series(data=1,index=golden_date) #1作为金叉的标识
s2 = Series(data=0,index=death_date) #0作为死叉的标识

s = s1.append(s2)
s = s.sort_index() #存储的是金叉和死叉对应的时间

s = s['2010':'2020']##存储的是金叉和死叉对应的时间

first_monry = 100000 #本金，不变
money = first_monry #可变的，买股票话的钱和卖股票收入的钱都从该变量中进行操作
hold = 0 #持有股票的数量（股数：100股=1手）

for i in range(0,len(s)): #i表示的s这个Series中的隐式索引
    #i = 0(死叉：卖) = 1（金叉：买）
    if s[i] == 1:#金叉的时间
        #基于100000的本金尽可能多的去买入股票
        #获取股票的单价（金叉时间对应的行数据中的开盘价）
        time = s.index[i] #金叉的时间
        p = df.loc[time]['open'] #股票的单价
        hand_count = money // (p*100) #使用100000最多买入多少手股票
        hold = hand_count * 100 

        money -= (hold * p) #将买股票话的钱从money中减去
    else:
        #将买入的股票卖出去

        #找出卖出股票的单价
        death_time = s.index[i]
        p_death = df.loc[death_time]['open'] #卖股票的单价
        money += (p_death * hold) #卖出的股票收入加入到money
        hold = 0

#如何判定最后一天为金叉还是死叉
last_monry = hold * df['close'][-1] #剩余股票的价值

#总收益
money + last_monry - first_monry

32376838.699999996