python数据分析vip班级笔记

终于从基础班毕业了，从周一开始学习python的数据分析课。

第一节课是开班典礼，没有什么重要的内容。主要是安装jupyter，直接连接国外的网站太慢，要换国内的源，比如清华源
pip install jupyter -i https://pypi.tuna.tsinghua.edu.cn/simple/
安装完之后，用jupyter-notebook 和
jupyter notebook都能运行。

有位同学好像专门写了一个文章，解决安装不上问题的诸多原因：
https://blog.csdn.net/weixin_49088841/article/details/107091652?utm_source=app

第二节课主要讲了如何画图, 刻度，标题，中文，字体，颜色，线的格式，标签等等如何设置。把以前的列表推导式，字符串的格式化，等等内容又顺带复习了一下。
import matplotlib.pyplot as plt

等同于from matplotlib import pyplot as plt

#plt.figure??
#plt.figure()

fig=plt.figure()

#plt.subplot??

# plt.subplot(221)

ax1=plt.subplot(2,2,1) # 2*2 最多为4个图形，这里选择了第一个。

#3*3则最多为9个图形， subplot(225)则报错

ax2=plt.subplot(2,2,2)

ax3=plt.subplot(2,2,3)

ax4=plt.subplot(2,2,4)

ax1.scatter(range(5),range(5))

plt.show()# 展示图片

plt.subplots(2,2)

plt.subplots(2,2,sharex=True,sharey=True)

plt.subplots(2,2,sharex=True,sharey=True,figsize=(14,8))

fig,axs=plt.subplots(2,2,sharex=True,sharey=True,figsize=(14,8))

#注意这个函数有2个返回值，一个是fig是图片，一个是axs是数组。中间用逗号，

#用fig axe接收相当于拆包

axs[0,0].scatter(range(5),range(5)) #选中第一张图

axs[0,1].scatter(range(5),list(range(5)[::-1])) #选中第二张图

plt.subplots_adjust(wspace=0,hspace=0)

plt.show()

plt.plot??

x=[1,2,3,4]

y=[4,2,3,1]

# plt.plot(x,y) #绘制折线图

plt.plot(x,y,color=“g”,linestyle="–",marker="*")# 可以设置线条的颜色和形状

plt.show()#展示图片，释放内存

#x=range(2,26,2)
plt.figure(figsize=(14,8))
x=range(0,24,2)
#range() start,stop,step不要用浮点数，只用整数
y=[15,13,14.5,17,20,25,26,26,27,22,18,15]
#设置刻度 以0 0.5 23.5显示 【i/2 for i in range (0,48)】
x_t=[i/2 for i in range (0,48)] # 注意，这个是刻度
x_l=["{}h".format(i/2) for i in range (0,48)] # 注意，这个是标签

#plt.xticks(x)
#plt.xticks(x_t)
plt.xticks(x_t, x_l,rotation=45)

#设置y的刻度
y_t=range(min(y),max(y)+1)
plt.yticks(y_t)
#添加标签标题
plt.xlabel(“time”)
plt.ylabel(“temp”)
plt.title(“temp during the day”)

#添加网格
plt.grid()

plt.plot(x,y)
plt.savefig(“mat.png”)
plt.show()
#plt.savefig(“mat.png”) 这样保存则为空白，要在show之前保存，

import matplotlib.pyplot as plt
import random
import matplotlib
font={
‘family’:‘SimHei’,
‘weight’:‘bold’,
‘size’:12
}
matplotlib.rc(“font”,**font)

这是全局设置方式，设置自带字体，只能设置ttf字体，不支持ttc字体

x=range(0,120)
y=[random.randint(30,38) for i in range(0,120)]#生成120个随机数的气温
plt.plot(x,y)
#设置刻度
x_t=range(0,120,10)
#设置标签
x_l=[“ten{}m”.format(i) for i in range(0,60,10)]

x_l=x_l+{“十一{}m”.format(i) for i in range(0,60,10)}

x_l+=[“十一{}m”.format(i) for i in range(0,60,10)]
plt.xticks(x_t,x_l,rotation=45)

plt.show()

第三节课讲了如何设置图例 plt.legend,设置字体，设置文本注释。
绘制散点图和条形图。
x1=range(11,31)

a=[1,0,1,1,2,4,3,2,3,4,4,5,6,5,4,3,3,1,1,1]
b=[1,0,3,1,2,2,2,3,1,1,1,1,1,2,1,1,2,3,2,2]
x1_t=range(11,31)
x1_l=["{}岁".format(i) for i in range(11,31)]
plt.xticks(x1_t,x1_l,rotation=45)

for x_i,y_i in zip(x1,a):

plt.annotate(f"{y_i}",xy=(x_i,y_i),xytext=(x_i,y_i-1),arrowprops={“width”:2})

for x_i,y_i in zip(x1,a):

plt.annotate(f"{y_i}",xy=(x_i,y_i),xytext=(x_i,y-i-1))

def auto_label(x_po,y_po):
for x_i,y_i in zip(x_po,y_po):
plt.annotate(f"{y_i}",xy=(x_i,y_i),xytext=(x_i,y_i))

auto_label(x1,a)
auto_label(x1,b)

plt.ylabel(“year”)
plt.xlabel(“numbers”)
plt.title(“seeking soul mates over the time”)
plt.plot(x1,a,label=“myself”)
plt.plot(x1,b,label=“desk”)
plt.legend()
plt.show()

li=[28,26,26,22,14,22,14,13,17,19]
y=li
x=range(10)
plt.plot(x,y,marker="*")
#plt.annotate(“28”,xy=(0,28),xytext=(-0.3,28))
#plt.annotate(“28”,xy=(0,28),xytext=(0,28)) 实现将每个点都使用上数据标签，思路：对应的参数坐标在变
#plt.annotate(“28”,xy=(0,28),xytext=(-0.3,25),arrowprops={“width”:2})
for x_i,y_i in zip(x,y):
plt.annotate(f"{y_i}",xy=(x_i,y_i),xytext=(x_i,y_i-1))

for x_i,y_i in zip(x,y):

plt.annotate(f"{y_i}",xy=(x_i,y_i),xytext=(x_i,y_i-1),arrowprops={“width”:2})

plt.show()

y_5 = [11,17,16,11,12,11,12,13,10,14,8,13,12,15,14,17,18,21,16,17,30,14,15,15,15,19,21,22,22,22,23]
y_10 = [26,26,28,19,21,17,16,19,18,20,20,19,22,23,17,20,21,20,22,15,11,15,5,13,15,10,11,13,12,13,6]

5月和10月的每天天气

x=range(1,32)
x_5=range(1,32)
x_10=range(51,82)

plt.scatter(x,y_4)

plt.scatter(x,y_10)

plt.scatter(x_5,y_5)
plt.scatter(x_10,y_10)

x_t=list(x_5)+list(x_10)
x_l=[“Apr{}号”.format(i) for i in x_5]
#x_l+=[“Oct{}号”.format(i) for i in x_10]
x_l+=[“Oct{}号”.format(i-50) for i in x_10]
#plt.xticks(x_t,x_l)
plt.xticks(x_t[::5],x_l[::5],rotation=45)
plt.show()

a = [“流浪地球”,“复仇者联盟4:终局之战”,“哪吒之魔童降世”,“疯狂的外星人”,“飞驰人生”,“蜘蛛侠:英雄远征”,“扫毒2天地对决”,“烈火英雄”,“大黄蜂”,“惊奇队长”,“比悲伤更悲伤的故事”,“哥斯拉2:怪兽之王”,“阿丽塔:战斗天使”,“银河补习班”,“狮子王”,“反贪风暴4”,“熊出没”,“大侦探皮卡丘”,“新喜剧之王”,“使徒行者2:谍影行动”,“千与千寻”]
b = [56.01,26.94,17.53,16.49,15.45,12.96,11.8,11.61,11.28,11.12,10.49,10.3,8.75,7.55,7.32,6.99,6.88,6.86,6.58,6.23,5.22]
plt.figure(figsize=(14,8))
#plt.bar(a,b,width=0.3,bottom=10) 默认柱子在中间，可以用edge靠右边，调整width的值为负值可以靠左
plt.bar(a,b,width=-0.3,bottom=10,align=‘edge’)
plt.xticks(rotation=90)

plt.show()

fruits=[“apple”,“pear”,“cheary”]
Q1_sales=[1000,800,3000]
Q2_sales=[1200,700,2800]
#柱子对应的位置为【0,1，2】
width=0.35

r1=plt.bar(list(range(len(fruits))),Q1_sales,width)

r2=plt.bar(list(range(len(fruits))),Q2_sales,width)

po_l=[i-width/2 for i in list(range(len(fruits)))]
po_r=[i+width/2 for i in list(range(len(fruits)))]
plt.bar(po_l,Q1_sales,width,label=“Q1”)
plt.bar(po_r,Q2_sales,width,label=“Q2”)
#设置数据标签
auto_label(po_l,Q1_sales)
auto_label(po_r,Q1_sales)
plt.xticks(list(range(len(fruits))),fruits)

plt.legend()

fruits=[“apple”,“pear”,“cheary”]
Q1_sales=[1000,800,3000]
Q2_sales=[1200,700,2800]

plt.bar(fruits,Q1_sales,width=0.5)
plt.bar(fruits,Q2_sales,width=0.5,bottom=Q1_sales)

a = [“流浪地球”,“复仇者联盟4:终局之战”,“哪吒之魔童降世”,“疯狂的外星人”,“飞驰人生”,“蜘蛛侠:英雄远征”,“扫毒2天地对决”,“烈火英雄”,“大黄蜂”,“惊奇队长”,“比悲伤更悲伤的故事”,“哥斯拉2:怪兽之王”,“阿丽塔:战斗天使”,“银河补习班”,“狮子王”,“反贪风暴4”,“熊出没”,“大侦探皮卡丘”,“新喜剧之王”,“使徒行者2:谍影行动”,“千与千寻”]
b = [56.01,26.94,17.53,16.49,15.45,12.96,11.8,11.61,11.28,11.12,10.49,10.3,8.75,7.55,7.32,6.99,6.88,6.86,6.58,6.23,5.22]
plt.figure(figsize=(14,8))
plt.barh(a,b)

第三节课我发现我的matplotlib没有老师上课时候用的一个属性，我的是2.1.2，老师的是3.0.3. 好多帖子都写了如何升级，其实那些命令我这边没有一个能用的，于是去了matplotlib的官网，果然，可以升级，我升级到了最新版3.3.1,单更麻烦的事情来了，我的plt都不能用了，因为python的版本太低了，于是我又去重新下载python3.8.5又重新安装Anaconda，设置环境变量，搞了一下午，终于工作了。这节课讲了快3个小时，东西都特别琐碎，讲了如何绘制直方图，扇形图，雷达图，箱型图（类似K线又不同于K线）如果封装函数，matplotlib的一些配置项，设置文本的另外方式，设置XY轴的上下限等。.
import matplotlib.pyplot as plt
from matplotlib import pyplot as plt
import random
import matplotlib
from matplotlib import ticker

font={
‘family’:‘SimHei’,
‘weight’:‘bold’,
‘size’:12
}
matplotlib.rc(“font”,**font)
import numpy as np
plt.rcParams[‘font.sans-serif’] = [‘SimHei’] # 步骤一（替换sans-serif字体）
plt.rcParams[‘axes.unicode_minus’] = False # 步骤二（解决坐标轴负数的负号显示问题）
temp_li= [6.9,4.1,6.6,5.2,6.4,7.9,8.6,3.0,4.4,6.7,7.1,4.7,9.1,6.8,8.6,5.2,5.8,7.9,5.6,8.8,8.1,5.7,8.4,4.1,6.4,6.2,5.2,6.8,5.6,5.6,6.8,8.2,6.4,4.8,6.9,7.1,9.7,6.4,7.3,6.8,7.1,4.8,5.8,6.5,5.9,7.3,5.5,7.4,6.2,7.7]
max(temp_li)
min(temp_li)
cha=max(temp_li)-min(temp_li)
b=1
bi=round(cha)//b # round 四舍五入
#plt.hist(temp_li,bins=bi) #注意bins为整数类型
plt.hist(temp_li,bins=bi,density=True) #注意bins为整数类型

#display label
plt.xlabel(“区间”)
plt.ylabel(“频数/频率”)
plt.title(‘直方图’)
plt.show()
frac = [1/50,6/50,11/50,15/50,9/50,6/50,2/50]
label = [’[3,4]’,’(4,5]’,’(5,6]’,’(6,7]’,’(7,8]’,’(8,9]’,’(9,10]’]
#plt.pie(frac,labels=label,autopct="%.2f") %为00， 没有这个符号%
explodes=(0,0,0.1,0,0,0,0) # 每个数字对应lalel里的一个元组，如果想让那个label突出显示，则设置一个值
#plt.pie(frac,labels=label,autopct="%.2f%%",explode=explodes)
#plt.pie(frac,labels=label,autopct="%.2f%%",explode=explodes,shadow=True) #shadow 会让图像显得有立体感

#可以用拆包的方式来接收pie的3个返回值, 中间用逗号隔开。 print可以打印出全部，单独一个patches则显示最后一个值
patches,texts,autotexts= plt.pie(frac,labels=label,autopct="%.2f%%",explode=explodes,shadow=True)

print(patches)

print(texts)

print(autotexts)

for autotext in autotexts:
autotext.set_color(“w”)
plt.show()

data=[random.randint(1,100) for i in range(100)]
data.extend([-100,500])
#plt.boxplot(data,sym="^",widths=0.2)
plt.boxplot(data,sym="^",widths=0.2,meanline=True,showmeans=True)
plt.show()

theta=np.linspace(0,np.pi*2.5)

plt.polar(theta,sales)

quaters = [‘Q1’,‘Q2’,‘Q3’,‘Q4’] # 不是x，x是弧度
sales = [40,91,44,90,40]

求theta 2*PI

#theta = np.linspace(0,np.pi2,5) # 创建等差数列, 注意，这里是5而不是4
theta = np.linspace(0,np.pi2,5)

绘制图形

plt.polar(theta,sales)

设置刻度标签

plt.xticks(theta,quaters)
#plt.fill(theta,sales)

plt.show()
fig = plt.figure()
ax1 = plt.subplot(111)
ax1.plot(range(10),range(10),marker=“o”)

想在(0,0)的位置显示文本

ax1.text(0,0,"(0,0)")
#ax1.text(-0.3,0.5,"(0,0)")

plt.show()

fig = plt.figure()
ax1 = plt.subplot(111)
ax1.plot(range(10),range(10))

给x,y轴设置上下限 为-2 到 12

ax1.set_xlim(-2,12)
ax1.set_ylim(-2,12)
plt.show()

fig = plt.figure()
ax1 = plt.subplot(111)
ax1.bar(range(10),[random.randint(-10,40) for i in range(10)])
ax1.set_ylabel(‘温度’)
ax2=ax1.twinx()
ax2.plot(range(10),[random.randint(0,400) for i in range(10)],marker="*")
ax2.set_ylabel(‘降水量’)

plt.show()
fig = plt.figure()
ax1 = plt.subplot(111)
ax1.bar(range(10),[random.randint(-10,40) for i in range(10)])
ax1.set_ylabel(‘温度’)
#设置y轴label的位置为上方
ax1.yaxis.set_label_coords(-0.1,1)

fig = plt.figure()
width = (2,1) # 宽为2:1 0列：1列 的宽度 2:1
height = (2,1) # 高为2:1 0行:1行 的宽度 2:1
gs = fig.add_gridspec(2,2,width_ratios=width,height_ratios=height)

[行,列] [0,0] 取一整行 列取全部

fig.add_subplot(gs[0,:])
fig.add_subplot(gs[1,0])
fig.add_subplot(gs[1,1])

第二周第一节课，总第5节课。
今天上课时间正好和一个FRM的直播课程重叠，跟谁学的FRM也是8点开始，我一把老骨头了，搞的比学生还累。
今天讲了文件的各种读写操作，open，with open as f，json（json load, json dump）. 如何操作csv文件 writerow, writerows,next, for 循环还有强大的pandas pd.read_csv, df.to_csv(). 然后讲了excel的各种读取创建方法，xlwt,xlrd,openpyxl. 最后讲了大名鼎鼎的numpy,指定数据类型，创建后修改数据类型。
f=open(“student.txt”,“r”,encoding=“utf8”)

f.read() # \n 是换行符，如果在pycharm 里面则会分2行显示。

#f.readline逐行读取，但是f.readline 是不可逆的操作

f.readline()

f.readline()

f.readlines()
f.close()

f=open(“demo.txt”,“w”) #在写模式下，文件不存在则创建模式
#f.write(“hello teacher”) #返回结果为字符串的数目
f.write(“hello wuwangchuxin”) #再次写入为覆盖 ，关闭后需要重新打开
f.close()
with open(“student.txt”,“r”,encoding=“utf8”) as f:
print(f.readlines())
# 不需要写close语句，其他操作都和open一致
import json
#json与python中字典的格式非常类似，json中的数据必须用双引号包裹

data={“age”:18}
with open(“data.json”,“w”) as f:
# f.write(data) #使用write w模式必须写入str
json.dump(data,f) #dump,将python 对象转化为json对象，写入文件

with open(“data.json”,“r”) as f:

print(f.read())

print(type(f.read()))

#dict(f.read())  字符串传入dict里面生成字典会报错
#json对象转为python对象： 字典
j_data=json.load(f)
print(j_data)
print(type(j_data))
print(j_data["age"])
import csv

with open(“demo3.csv”,“w”) as f:
#创建csv写的对象
datawriter=csv.writer(f)

datawriter.writerow([“name”,“age”,“gender”])

datawriter.writerow([“amy”,“18”,“female”])# 逐行写入， 这样写中间有一行空着，

#如果不想如此，则在with open语句zhong写入with open(“demo3.csv”,“w”，newline="") as f:

datawriter.writerows([["class",'name'],["1","Amy"],["2","Jim"]])

with open(“demo3.csv”,“r”) as f:
datareader=csv.reader(f)

#迭代器，只能往下读取，每次一行

print(next(datareader))

print(next(datareader))

print(next(datareader))

#通过for 循环一次性取出
for i in datareader:
    print(i)
    import pandas as pd # pip install pandas ,同时需要安装xlwt, xlrd来操作excel 

#但是他们没有openpyxl好用，openpyxl只支持2010版本以上的xlsx文件
data=pd.read_csv(“demo3.csv”)
data

data.to_csv(“demo4.csv”) #这样多一个0和逗号

data.to_csv(“demo4.csv”,index=False)

from openpyxl import Workbook
wb=Workbook() #创建工作簿
ws=wb.active #激活第一个工作表
#数据构成
data=[[“class”,‘name’],[“1”,“Amy”],[“2”,“Jim”]]
#获取data中数据，写入工作表
for row in data:
ws.append(row)
#保存工作簿
wb.save(“demo4.xlsx”)

from openpyxl import load_workbook
wb=load_workbook(“demo4.xlsx”) #打开工作簿
ws=wb.active #读取第一个工作表
ws.rows #生成器对象
for row in ws.rows:

print(row)

for cell in row:
    #print(cell)
    print(cell.value)
    
    import pandas as pd

pd.read_excel(“demo4.xlsx”,sheet_name=0)

import numpy as np
li=[1,2,3,4]
np.array(li)
list(range(5))
np.arange(1,5)
li2=[1,2,3,4,0.5]
b=np.array(li2) # ndarrage数组是一个通用的多维同类数据容器
c=np.array([1,2,“Amy”]) #U11为unicode类型
c.dtype

li3=[“1”,“2”,“3”,“4”,“5” ]

“”.join(li3)

#map (函数，可迭代对象)
li4=[1,2,3,4,5]

list(map(str,li4))

np.array(li,dtype=“U”)
arr=np.array(li4)
arr=arr.astype(“U”) #需要赋值，否则没有改变原有数组对象
arr

第二周第二课
numpy还要讲2节课，今天的内容非常简单
讲了arr.ndim, arr.shape. adarray, arr.reshape() arr.flatten,arr.ravel,arr.transpose(), arr.T, arr.swapaxes(1,0)
asarray 和array的深拷贝，浅拷贝，不拷贝
np.ones, np.zeros, np.full np.ones_like
代码都比较简单，如下：
import numpy as np
arr=np.array(range(6))
arr.ndim
arr.shape
arr1=np.array([ [12,3,4],[5,7,9] ])
arr1
arr1.ndim
arr1.shape
arr2=np.array([ [12,3,4],[5,9] ])
arr2
arr2.ndim
arr2.shape
arr3=np.array( [[[1,2,3],[4,5,6]],[ [7,8,9],[10,11,12]]] )
arr3
print(arr3.ndim)
print(arr3.shape)
arr4=np.arange(6)
arr5=arr4.reshape(3,2)
arr5
arr6=arr4.reshape(3,2,order=“F”)
arr6
arr7=arr4.reshape(3,-100)
arr7
np.arange(24).reshape(2,3,4)
arr8=np.arange(12).reshape(3,4)
arr9=arr8.reshape(1,-1)
arr9.ndim
arr10=arr8.reshape(arr8.shape[0]*arr8.shape[1])
arr10.ndim
arr11=np.arange(12).reshape(3,2,2)

如果为3维数组，则还要增加shape【2】，shape的元组取值，通过索引

arr12=arr11.reshape(arr11.shape[0]*arr11.shape[1]*arr11.shape[2])

arr12.ndim
#或者直接-1
arr13=arr11.reshape(-1)
arr13.ndim
arr14=np.arange(16).reshape(4,4)
arr14
arr14.flatten()
arr14.ravel()
arr15=np.arange(25).reshape(5,5)
arr16=arr15.transpose() #数组的转职, T 为属性，不需要（）transpose为方法，需要（）
arr17=arr15.T
arr_t=arr15.swapaxes(1,0) #交换轴
arr_t
data=[1,2,3,4]
arr18=np.array(data)
arr19=np.asarray(data)
data[1]=5
print(data)
print(arr18)
print(arr19)
data=np.arange(1,5)
arr20=np.array(data)
arr21=np.asarray(data)
data[1]=5
print(data)
print(arr20)
print(arr21)
#当数据源为nparray的时候，array（）会copy副本，占用新的内存，但是asarray不会
#不拷贝 数据都在内存的栈区
arr22=np.arange(12)
arr23=arr22
arr23 is arr22 #Ture 说明这2者指向一致,所以改变arr22，两者都改
arr23[1]=200
arr22
#浅拷贝 数据都在内存的堆区（这两者指向同一个）
arr24=arr22.view()
arr24
arr24 is arr22 # false 两者不是同一个内存
arr24[0]=1000
arr22
#深拷贝
arr25=arr22.copy()
arr25 is arr22 # false 两者不是同一个内存栈区，也不是同一个堆区
arr25[2]=250
print(arr25)
print(arr22)
a26=np.ones(3)
a26.dtype
np.ones((2,3))
a27=np.zeros(3)
a28=np.zeros((3,3))
a28
a29=np.empty(4)
a29.dtype
np.full(3,3) #生成1维三个为3的uansu
np.full((2,3),3)#两行三列 值全为3的数组
a30=np.arange(12).reshape(3,4)
np.ones_like(a30)

Numpy的第三节课：
数组的广播机制，数组和标量进行运算，形状不一致的时候，如何运算。两个方法，垂直拼接np.vstack(), 水平拼接 np.hstack()
一维数组的切片，和list类似。二维数组如何切片，递归，逗号分隔，神奇索引，焦点。布尔索引，还有两个方法，np where(condition,True, False)
np.clip(data,min,max)
import numpy as np
[i+1 for i in range(6)]
a=[i+1 for i in range(6)]
a
def add_one(x):
return x+1
a=map(add_one,range(6)) #转化为map对象
b=list(map(add_one,range(6))) #转化为list对象
b
f=lambda x:x+1 # 定义匿名函数，x为形参，x+1为返回值
f(4)
list(map(f,range(6)))
list(map(lambda x:x+1,range(6)))
arr=np.arange(6)
arr+1 #每个 元素都会进行相加运算- 广播机制
arr1=np.arange(6).reshape(2,3)
arr1
arr1+2
arr1*2
arr1**2
arr1//2
arr3=np.arange(1,7).reshape(2,3)
arr3
arr3+arr3
arr3-arr1
arr3>arr1
arr4=np.arange(12).reshape(4,3)
arr5=np.arange(3).reshape(1,3)
print(arr4)
print(arr5)
arr4-arr5 # 与列数相同并且只有1行的数组之间进行运算
arr6=np.arange(12).reshape(4,3)
arr7=np.arange(4).reshape(4,1)
print(arr6)
print(arr7)
arr6-arr7 # 与行数相同并且只有1行的数组之间进行运算， 在numpy中，维度完全不一致的时候，无法进行广播
arr8=np.arange(12).reshape(2,6)
arr9=np.arange(12,24).reshape(2,6)
print(arr8)
print(arr9)
np.vstack((arr8,arr9)) #垂直拼接，必须列一致
np.hstack((arr8,arr9)) #水平拼接，必须行一致
arr10=np.arange(10)
arr10[2]
arr10[:4] #切片
arr10[::2]
arr10[1::2] #初始值，结束值，步长
a2=np.arange(24).reshape(4,6)
a2
a2[1]
a2[1][1] #递归的方式取值
a2.shape
a2[1,:] #取第二行
a2[1:3,:] #取2-3连续行
a2[1:4:2,:] #取2，4行
a2[::2,:]#取1，3行
a2[(0,2),:] #神奇索引
a2[1:3,2:4] # 取8,9,14,15 子矩阵
a2[(1,2),(2,3)]#神奇索引分开执行，取两个交 点
a3=np.arange(24).reshape(4,6)
a3
a3[:,1]=0 #将第二例的值变成0
a3
a3<10
a3[a3<10] #通过bool索引取值，取值为具体的数字，而非位置，先行后列
a3[a3<10]=100
a3
a3[(a3>25) & (a3>50)] #逻辑运算符写法与python有所不同 不是and 和or
np.where(a3>10,0,100) #np.where(condition,[x,y])满足condition则x，不满足则y
a3.clip(5,10) #将小于5的替换为5， 将大于10的替换为10

numpy第5节课

讲了文件的操作，nan与inf
如何保存文件，np.savetxt ,如何加载文件，np.loadtxt, nan与inf，都是float类型，np.nan!=np.nan np.isnan()
np.count_nonzero()计算非0个数
np.nan 与任何数值运算都是nan。处理nan，删除缺失值所在行，np.where, np.delete
求和 求均值将np.nan 赋值给均值
import numpy as np
np.savetxt??
np.random.randint??
scores=np.random.randint(0,100,size=(40,2))
np.savetxt(“scores.csv”,scores,fmt="%d",delimiter=",",header=“mid,end”,comments="")
np.loadtxt??
np.loadtxt(“scores.csv”,delimiter=",",dtype=“object”) #不常用，数据类型指定为字符串
np.loadtxt(“scores.csv”,skiprows=1,delimiter=",") #注意文件名，跳过表头 字符串，csv文件默认以逗号作为分隔符
stock1=np.loadtxt(“云南白药.csv”,delimiter=",",dtype=“object”)
print(stock1.shape)
stock2=np.loadtxt(“五粮液.csv”,delimiter=",",dtype=“object”)
print(stock2.shape)
v_data=np.vstack((stock1,stock2))
v_data.shape
np.savetxt(“all_data.csv”,v_data,fmt="%s",delimiter=",")
#定义函数，使用可变长参数实现
def vstack_data(*args):
vstack_li=[]
#将数据都放入列表或者元组中，元组不可变，所以选择列表
for file_name in args: #取出每个文件名并且读取每个文件的数据
stock=np.loadtxt(f"{file_name}",delimiter=",",dtype=“object”)
vstack_li.append(stock)
v_data2=np.vstack(vstack_li)
np.savetxt(“all_data2.csv”,v_data2,fmt="%s",delimiter=",")

vstack_data(“云南白药.csv”,“五粮液.csv”,“all_data.csv”)
arr=np.arange(16).reshape(4,4)
arr1=arr.astype(“float”)
arr1[1,2]=np.nan
print(type(np.nan))
print(np.nan==np.nan)
a=np.arange(6).reshape(2,3).astype(“float”)
a[1,2]=np.nan
#通过布尔索引取出nan的数组，再来求其长度
len(a[a!=a])

#法2，True1. false0, 计算非0的个数
np.count_nonzero(a!=a)
#法3 利用函数，非常方便,判断元素是否为np.nan
np.isnan(a)
#注意，nan和任意数字计算都是nan，所以预处理时候一般都把nan给处理掉
b=np.arange(9).reshape(3,3).astype(“float”)
b[(0,1),(1,2)]=np.nan
np.where(np.isnan(b))
row_index=np.where(np.isnan(b))[0]
del_arr=np.delete(b,row_index,axis=0)
print(del_arr)
exam_data=np.loadtxt(“exam.csv”,skiprows=1,delimiter=",",dtype=np.str)
exam_data
#exam_data[exam_data==""]=np.nan
exam_data[exam_data==""]=0
exam_data
exam_data=exam_data.astype(float)
exam_data

exam_data[exam_data==0]=np.nan
exam_data
#将nan 替换为非nan的均值，成绩是按照列排序，要循环取出每列 元组（行，列）对应取（0,1），如果数组是三维，还有2
for exam_col in range(exam_data.shape[1]):
#取出每一列数据,所以这是一个一维数组
exam_col=exam_data[:,exam_col]

print(exam_col)

#取出非nan的值
non_nan_data=exam_col[exam_col==exam_col]
#print(non_nan_data)
#求非nan的均值，赋值给nan的值
exam_col[exam_col!=exam_col]=non_nan_data.mean()
#print(exam_col)
print(np.round(exam_col))

8月27号，numpy最后一节课

主要就是讲了各种函数
import numpy as np
np.random.rand()
#加上seed，则执行结果每次都一样
np.random.seed(1)
np.random.rand()
np.random.randn(2,3)
np.random.randint(1,10,size=(4,4))
data=np.arange(5)
np.random.choice(data,size=(4,4))
arr=np.arange(10)
np.random.shuffle(arr) #shuffle 没有返回值，洗牌洗的是数据本身
#random模块一般都是在测试中用到
arr=np.arange(12).reshape(3,4)
arr
np.sum(arr)
np.sum(arr,axis=0) #计算列
np.sum(arr,axis=1) #计算行
np.mean(arr)
np.mean(arr,axis=0) # 类型变成float
np.mean(arr,axis=0,dtype=np.int)
np.mean(arr,axis=1,dtype=np.int) #结果不会四舍五入，会直接取整，写dtype=int也可以这是python自带的，不过dtype=np.int为习惯写法
np.min(arr)
np.min(arr,axis=0)
np.max(arr,axis=0)
np.argmax(arr)
np.argmax(arr,axis=0)
np.var(arr) #样本数据和均值之间的偏离程度，方差越小，数据越稳定
np.std(arr) #反应数据的波动性，标准差越大，波动越大
np.ptp(arr) #max-min
np.ptp(arr,axis=0) #max-min
np.median(arr) #中值
np.median(arr,axis=0) #0轴中值
np.cumsum(arr) #累积和
arr4=arr.astype(“float”)
arr4.dtype
arr4[2,2]=np.nan
arr4
np.nansum(arr4)
%time sum(np.arange(100000000))
%time np.sum(np.arange(100000000))
arr5=np.random.uniform(-10,10,size=(3,5))
np.abs(arr5)
np.sqrt(arr5)
np.square(arr5)
np.exp(0) #e0
np.exp(1) #e1
np.exp(2)
#np.log 以e为底的对数
#np.log10 以10为底的对数
#np.log2 以2为底的对数
np.log(np.exp(1))
#np.sign() #将数组中的值，标签化 大于0的变成1，等于0的变成0，小于0的变成-1
np.sign(arr5)
np.ceil(5.1)
np.ceil(-6.6)
np.floor(5.99)
np.rint(4.51) #四舍六入五成偶，成为偶数才让你入
#modf 将整数和小数分开
np.modf(arr5)
np.sin(np.pi/2) # sin 90度
a=np.arange(12).reshape(3,4)
b=np.arange(12,24).reshape(3,4)
a[:,2]-b[:,1]
np.subtract(a[:,2],b[:,1])
a[(a>0)&(a<5)]
np.logical_and(a>0,a<5)
a[np.logical_and(a>0,a<5)]
a1=np.arange(10)
np.any(a1) # 只要有一个为true的，就会返回True
np.all(a1) # 所有数字为true，就会返回True
a2=np.random.randint(0,10,size=(4,4))
a2
np.sort(a2) #默认以1轴排序
np.linspace(0,10,15) #将指定区间，平均分成多少分吗，这里是将-10 等分15份
data=np.arange(6)
a3=np.random.choice(data,(2,3))
a3
np.unique(a3)
np.unique(a3,return_counts=True) #array 返回数组不重复的元素，当return为true时候，返回array出现的次数

开始学习pandas了

第一节课主要讲了常用数据类型series, dataframe. series 为1维 pd.series. data 为可迭代对象， 字典，向量。index可以重复，与data的个数要一致。 s.head and s.tail(n) 切片与索引， 字符串也可以切片，但它是双闭合区间 loc iloc
运算，有共同索引元素进行运算，其他的用nan填充

import pandas as pd
import numpy as np
s1=pd.Series([1,2,3,4,5])
s1
list(“abcde”)
s2=pd.Series([1,2,3,4,5],index=list(“abcde”)) #是否可以指定索引
s2
s3=pd.Series([1,2,3,4,5],index=list(“aacde”)) #索引是否可以重复
s3

s4=pd.Series([1,2,3,4,5],index=list(“aaacde”)) #索引是否可以与data个数不一致

s4

dic={“name”:“steven”,“age”:18,“gender”:“male”}
s5=pd.Series(dic)
s5
#index_li=[“class”,“name”,“gender”]
index_li=[“class”,“name”,“name”]
s6=pd.Series(dic,index=index_li) #以index指定的索引为主
s6
s7=pd.Series(np.random.randint(1,10,size=5))
s7
s8=pd.Series(np.random.randint(1,10,size=5),dtype=‘float’) #指定数据类型
s8
s8.astype(‘int’) #修改数据类型
s9=pd.Series(np.random.randint(1,10,size=5),name=“series_name”)
s9
s9.index.name=“index_name” #指定索引的名字
s9
s10=pd.Series(np.random.randint(1,10,size=500),name=“series_name”) #仅仅显示前5行后5行
s10.head() #默认只读取前5行，对应指定n。
s10.head(10)
s10.tail(10) #默认只读取后5行，对应指定n。
#读取数据全部.但是不建议
pd.set_option(‘display.max_columns’,None) #显示所有列
pd.set_option(‘display.max_rows’,None) #显示所有行
pd.set_option(‘max_colwidth’,500)
s10
s11=pd.Series(np.arange(1,5))
s11
s11.values
s11.index
s11.index[1] #获取b值
s2[“b”] #通过索引取值。 索引不可变，不可以修改，但是可以重置
s11.reset_index()
s2[1] #通过标签获取
s2.loc[“b”] # 通过location- loc来搜寻index定位

s2.iloc[1] #另外的loc方法，通过索引
s2[[“a”,“d”]] # 通过标签查看 ad的值
s2[[0,3]] # 通过索引查看 ad的值
s2[“a”:“d”] # 通过标签查看 a to d的值,字符串也可以切片,字符串切片 是双闭合区间
s2[0:4] # 通过索引查看 ad的值
s2[s2>3] # 取出大于3的值
data=[“a”,“b”,None]
pd.Series(data)
data1=[1,2,None]
pd.Series(data1) #自动转为浮点类型，因为NAN是浮点类型

s12=pd.Series(np.arange(10,20),index=range(10))
s13=pd.Series(np.arange(20,25),index=range(5))
print(s12)
print(s13)
s12+s13 # 有共同索引则运算，无共同索引以nan填充

pandas的dataframe课程，这节课还是挺简单的，讲的都是最基础的语法。公司在西南搞了一个项目，这2天真是忙死了。课程代码

import pandas as pd
import numpy as np
pd.DataFrame??
“”"
行索引，index 0轴，axis=0
列索引，col 1轴，axis=0

data为字典，key值为列索引，value为值，行索引，不指定就为默认
“”"
d1=pd.DataFrame(np.random.randint(1,100,size=(3,3)))
d1.index #RangeIndex
d1.columns #RangeIndex
d1.values #ndarray 的二维数组

指定index为【amy mia steven】 指定col为【java，python，R】

d2=pd.DataFrame(np.random.randint(1,100,size=(3,3)),index=[ “amy”,"mia ",“steven” ],columns=[“java”,“python”,“R”])
d2
data={
“name”:[ “amy”,"mia ",“steven” ],
“lesson”:[“java”,“python”,“R”]
}
d3=pd.DataFrame(data)
d3
pd.DataFrame(data,columns=[“lesson”,“name”])
pd.DataFrame(data,columns=[“lesson”,“name”,“age”]) #以我们指定的col为主
data1=[
{“name”:“amy”,“age”:18 ,“gender”:1},
{ “name”:“jun”,“age”:20 },
{“name”:“hy”,“gender”:1 }
]
pd.DataFrame(data1) # 字典的数据结构不一致的时候，也会补齐为nan
df=pd.DataFrame(np.arange(9).reshape(3,3),index=list(“abc”),columns=list(“ABC”))
df
df.reindex(index=[1,2,3]) # 没有找到 索引里的 1 2 3 对应值（重置索引与df指定的index无关），所以为NAN
df.reindex(index=[“b”,“c”,“a”]) # 如果乱序，则根据新顺序重置
df.reindex(index=[“b”,“c”,“a”,“e”])
df.reindex(columns=[“B”,“C”,“A”]) # 指定列索引
df.reindex(index=list(“abcd”),columns=list(“ABC”),fill_value=0)# 若有不一致的，默认为nan，可以指定填充值
data3 = [
{“name”:“amy”,“age”:18,“tel”:10086},
{“name”:“bob”,“age”:18},
{“name”:“james”,“tel”:10086},
{“name”:“zs”,“tel”:10086},
{“name”:“james”,“tel”:10086},
{“name”:“ls”,“tel”:10086},
]

d4=pd.DataFrame(data3)
d4=pd.DataFrame(data3,index=list(“abcdef”))
d4
d4.shape #?? 和shift+tab+tab都能查看说明
d4.ndim
d4.dtypes #numpy 只有一种数据类型，所以用dtype, 这里有多种数据类型，用dtypes 查看数据类型
d4.head()
d4.tail() #显示头尾 5行
d4.info() #显示信息概要
d4[:2]
d4[:“b”] #标签取值，双闭合
d4[“name”] #字典，通过key值取值，取出来单列
type(d4[“name”]) # Series 数值类型， dataframe是series容器
d4[[“name”,“tel”]]
type(d4[[“name”,“tel”]]) # dataframe数值类型
d4[:2][“name”]
d4[“name”]!=“james” # 布尔索引
d4[d4[“name”]!=“james”]

df.iloc[] #通过整数索引选择数据

df.loc[] # 通过轴标签选择数据

idx=[“php”,“java”,“python”,“go”]
col=[“one”,“two”,“three”,“four”]
d5=pd.DataFrame(np.arange(16).reshape(4,4),index=idx,columns=col)
d5
d5.loc[“python”,:] #取python这行
d5.loc[:,“three”] #取three这行
d5.loc[ [“php”,“go”],: ] #取2行
d5.loc[:,[ “one”,“four”]] #取2列
d5.loc[“java”:“go”,: ] #连续切片不需要方括号
d5.iloc[2,:]#取python这行
d5.iloc[:,2] #取three这行
d5.iloc[1::,:] # 取出连续行左闭右开
d5.loc[:,“one”:“three”][d5.two>3] #选出two列大于3 d5.two 需要有index有相当的辨识度才行，d5.2是不可以的，即使把索引
#改成1234也不行
d6=pd.DataFrame(np.arange(16).reshape(4,4),index=idx,columns=col)
d6
#修改php整行，为8， 注意，修改的是原数据
d6.loc[“php”,:]=8
d6.two=10
d6.loc[“python”,“three”]=80
d6.loc[“python”,“three”]=np.nan #无需先转成浮点数
d6.five=10
d6[“five”]=10 #添加列, 添加列保证数组的长度和该列的长度一致
#d6[“a”]=[1,2,3,4]
d6.insert(0,“sixty”,[4,5,6,7]) #在0列。插入six这列

d6.loc[“C++”,:]=np.arange(8)

d6

idx=[“php”,“java”,“python”,“go”]
col=[“one”,“two”,“three”,“four”]
d7=pd.DataFrame(np.arange(16).reshape(4,4),index=idx,columns=col)
d7.loc[“C++”,:]=np.arange(4)
d7
d8=pd.DataFrame(np.arange(4).reshape(1,4),index=[“C”],columns=d7.columns)
d8
d8.append(d7)
d9=pd.DataFrame(np.arange(9).reshape(3,3),index=list(“abc”),columns=list(“ABC”))
d9

del d9[“C”] #获取c列并且删除，直接删除原数据
d9.drop(columns=“B”) #直接有返回值，不删除原数据 删除 B
d9.drop(index=[“a”,“c”]) #直接有返回值，不删除原数据, 删除 ac
d9.drop(“b”,axis=0)
d9.drop(“A”,axis=1) #指定轴来控制， 如果指定inplace为true，则可以操作原数据

pandas第三节课

还是比较简单的，讲了算术，运算符，算术方法，映射，dfapply和dfapplymap
排序，df.sort index df.sort_value
by指定排序键，空值处理，判断空值，过滤缺失值，补全缺失值

df1=pd.DataFrame(np.ones((2,2)),columns=list(“ab”))
df2=pd.DataFrame(np.ones((3,3)),columns=list(“abc”))
print(df1)
print(df2)
df1+df2
df1-df2
df2.iloc[0,:]
s=df2.iloc[0,:]
s.shape
df2+s
s2=pd.Series(np.arange(15,20))
print(s2)
s2+df2 # 结构完全不同，全部填充NAN
df1.add(df2) # fillvalue 填充在有缺失值的数组上
df1.add(df2,fill_value=2)
df2.add(s)
df2.add(s2)
#取出数组中的最大值
df=pd.DataFrame(np.random.uniform(-10,10,size=(4,4)))
df

df.max() # 默认按照0轴
df.max(axis=1) # 可以改为1轴
f=lambda x:x.max( )
df.apply(f,axis=1) # 默认按照0轴,可以改为1轴, 对行或者列进行操作

f2=lambda x:"%.2f"%x
df.applymap(f2)
df5=pd.DataFrame(np.arange(12).reshape(3,4))
df5
df5.sort_index() # 默认为0轴，默认为升序
df5.sort_index(ascending=False)
df6=pd.DataFrame(np.arange(12).reshape(3,4),index=list(“bca”))
df6
df6.sort_index() # 当索引为字符串的时候，根据ascii排序
ord(“a”) # 查看ascii码的值
df6.sort_index(ascending=False)
df6.iloc[0,0]=10 # 赋值
df6
df6.sort_values(by=0) #通过by指定0 列，升序排列
df6.iloc[1,0]=8
df6
df6.sort_values(by=[0,1])#先给col1排序，当col1有相同值时，col2中按照排序顺序再排序
df6.sort_values(by=“c”,axis=1) # 指定轴
df6
df7=pd.DataFrame(np.arange(12).reshape(3,4),index=list(“abc”))
df7
df7.count(0) # 计算非NaN 的个数
df7.idxmin() # 计算最小值所在的标签
df7.cumsum() #累积和
df7.diff() # 后一日的值减去前一日的值
df7.pct_change() # 后一日减去前一日 除以 前一日
df7[1].corr(df7[2]) # 计算相关性
df7.pct_change()
df7.sum() # 默认按照0 轴求和
df7.iloc[1,[1,2]]=np.nan
df7
df7.sum() # 默认跳过NAN
df7.describe()
df8=pd.DataFrame(np.arange(12).reshape(3,4))
df8
df8.iloc[1,1]=np.nan
df8
pd.isnull(df8) # 数组中是nan
pd.notnull(df8) # 数组中不是nan

python 内建的none，也会被当做nan

df8.iloc[1,2]=None
df8
s=pd.Series([1,np.nan,2,3,4,np.nan])
s
s[s.notnull()] # 取出不是nan的数据， 布尔索引过滤
s.dropna() # 直接过滤缺失值
df9=pd.DataFrame(np.arange(16).reshape(4,4))
df9.iloc[1,:]=np.nan # 选择索引为1的这行赋值为nan

df9.iloc[3,1]=np.nan

df9.dropna()
df9
df10=pd.DataFrame(np.arange(16).reshape(4,4))
df10.iloc[1,:]=np.nan # 选择索引为1的这行赋值为nan

df10.iloc[3,1]=np.nan

df10.dropna()
df10.dropna(axis=1)
df10.dropna(how=“all”) # 只删除全部为nan的行
s
s.fillna(2) # 填充空值
df11=pd.DataFrame(np.arange(12).reshape(3,4),index=list(“abc”),columns=list(“WXYZ”))
df11
df11.iloc[1,[1,2]]=np.nan
df11
df11.fillna({“X”:3.0,“Y”:4.0})
df11.fillna(method=“ffill”) # 根据前面的值填充nan 还有bfill根据后面的值填充
df11.iloc[2,[1,2]]=np.nan
df11
df11.fillna(method=“ffill”,limit=1) #插值填充，limit作为限制，只填充第一行
df11.fillna(df11.mean()) #填充均值 默认填充 W XYZ 轴的均值
df11

pandas 第三节课，pandas内容还真多，介绍了这么多函数，感觉才走了一半都不到
import pandas as pd
import numpy as np

df=pd.DataFrame(np.random.randint(-1,200,size=(4,1)),index=[“zs”,“an”,“gs”,“mia”],columns=[“age”])
df

df.replace(to_replace=177,value=22)

replace 用旧数据value 新数据

#一次性替换多个值，传入列表
df.replace(to_replace=[187,92],value=[22,2])
#通过字典来进行替换

df.replace({92:22,116:20})

df2=pd.DataFrame(
{
“age”:[18,19,18,22],
“gender”:[“male”,“female”]*2,
“name”:[“amy”,“bob”]*2

}
)
df2
df2.duplicated() #判断数据中，是否有完全重复的行（subset为默认） ，从上往下看，保留首个出现的

df2.duplicated(subset=[“gender”,“name”])#判断数据依靠gengder和name
df2.drop_duplicates()
df2.drop_duplicates(subset=[“gender”,“name”])

age_arr=np.random.randint(20,60,size=20)
age_arr
bins=[20,30,40,50,60]
bins

cats=pd.cut(age_arr,bins)
cats
cats.codes # 返回的是数据分布（索引）
cats.categories # 显示分组的情况，right表示右闭合
l_name=[“youth”,“youthadult”,“middleage”,“old”] #自定义区间标签
pd.cut(age_arr,bins,labels=l_name)
pd.value_counts(cats)
data = {
“names”:[“胡歌”,“金世佳”,“林更新”,“郭麒麟”,“小岳岳”],
“grades”:np.random.randint(60,100,size=5)
}
df=pd.DataFrame(data)
data
df
diff_class={
“胡歌”:“一班”,
“小岳岳”:“一班”,
“林更新”:“一班”,
“金世佳”:“二班”,
“郭麒麟”:“二班”
}
diff_class
df[“names”].map(diff_class)
df[“diff_class”]=df[“names”].map(diff_class)
df
data2 = {
“names”:[“bobs”,“amy”,“cheney”,“jerry”],
“grades”:np.random.randint(60,100,size=4)
}

df2=pd.DataFrame(np.random.randint(60,100,size=(4,2)),index=[“bobs”,“amy”,“cheney”,“jerry”])
df2
df2.index
names_upper=lambda x:x.upper()
df2.index.map(names_upper)
df2.index=df2.index.map(names_upper)
df2
df2.rename(index=str.lower)
df2.rename(index=str.title)
df2
df2.rename(index={“AMY”:“lao Amy”})
df2.rename(index={“AMY”:“lao Amy”},columns={0:“middle”,1:“end”})
cat_name=pd.read_csv(“catNames2.csv”)
cat_name
(cat_name[“Count_AnimalName”]>700) & (cat_name[“Count_AnimalName”]<1000)
cat_name[(cat_name[“Count_AnimalName”]>700) & (cat_name[“Count_AnimalName”]<1000)]
cat_name[(cat_name[“Count_AnimalName”]>700)&(cat_name[“Row_Labels”].str.len()>4)]
df=pd.DataFrame(
{
“key”:[“b”,“b”,“a”,“c”,“a”,“b”],
“data1”:np.arange(6)
}
)
df

a 出现为1，a未出现为0

pd.get_dummies(df[“key”])
movie=pd.read_csv(“IMDB-Movie-Data.csv”)
movie.head()
movie.Genre
all_genres=[]
for x in movie.Genre:
#print(x) #想为字符串

print(x.split(","))

all_genres.extend(x.split(","))

all_genres
genres=set(all_genres) #使用set去重
genres
genres2=pd.unique(all_genres) #使用unique去重,返回值为array数组
genres2
zerodata=np.zeros((len(movie),len(genres)))
zerodata=pd.DataFrame(zerodata,columns=genres2)
zerodata
movie.Genre[0]
f_data=movie.Genre[0]
f_data.split(",")
f_data_li=f_data.split(",")
zerodata.columns.get_indexer(f_data_li) #每个元素所在列的索引位置
#取出Movie.genre中的每一个元素然后将其赋值为1，需要行索引，列索引
movie.Genre[0]
for i,genre in enumerate(movie.Genre):
# print(i,genre) 获取每行元素以及对应的行索引
#现在获取列索引
indice=zerodata.columns.get_indexer(genre.split(","))
#print(indice)
#通过位置索引选择数据，赋值为1
zerodata.iloc[i,indice]=1
print(zerodata)

zerodata
li=[“a”,“b”]
for index,value in enumerate(li):
print(index,value)

9月11， 这次作业挺难的，练习2我也没写。老师讲了40多分钟的作业。而后主要讲分层索引与合并。df.set_index df.reset_index multiindex df.swaplevel() df.sort_index df.join pandas.merge 感觉这个方法这个非常难懂.最后一个方法还有pd.concat
df=pd.DataFrame(np.arange(12).reshape(3,4),index=list(“ABC”),columns=list(“MNOP”))
df
df.index
df.index[1] # 索引不能单独赋值修改
df.reindex([“A”,“D”])
df.set_index(“M”) # 指定列名，默认drop 为true，也就是M这一列为空值
df.set_index(“M”,drop=False)
df.loc[“B”,“M”]=8
df
#df.loc[8,:]
df1=df.set_index(“M”)
df1.loc[8,:] # 这是因为index只有1个，如果对df这么操作就不行
df1.index.unique()
df2=df.set_index([“M”,“N”])
df2 # 8是重复索引值，所以省略了 分层索引是pandas的一个重要属性，允许一个轴上拥有多个索引层级
df3 = pd.DataFrame({
‘a’:range(7),
‘b’:range(7,0,-1),
‘c’:[‘one’,‘one’,‘one’,‘two’,‘two’,‘two’,‘two’],
‘d’:list(“hjklmno”)
})
df3
df4=df3.set_index([“c”,“d”])
df4 # one two 为合并单元格
df4.to_excel(“test0908.xlsx”)
pd.read_excel(“test0908.xlsx”,index_col=[0,1]) # 如果不指定indexcol，则空处被NAN填充
df4.index # 多层索引类型 levels表示层级，codes 层级对应的位置索引 -names 索引名称
df4.loc[“one”] # 分层索引DataFrame取值
df4.loc[“one”:“two”] # 用切片
df4.loc[[“one”,“two”]] # 用神奇索引
df4.loc[“one”].loc[“j”]
df4.loc[“one”,“j”] # loc[外层索引，内层索引]
df4.loc[“one”].loc[“j”,“a”] #取1
df4.loc[“one”].loc[“j”][“a”] #取1
df4
df5=df4[“a”]
df5 # series 取值
df5[“one”]
df5[“one”:“two”]
df5[[“one”,“two”]]
df5[“one”][“j”] #取1
df3
df6=df3.set_index([“d”,“c”])
df6
df6.loc[“j”].loc[“one”,“a”] #先取出外层索引，在当做普通的df或者series取值
df4.swaplevel() # 默认值不传递任何参数
df4.sort_index(level=1,ascending=False) # 指定1层进行排序
df4.sort_index(level=0,ascending=False) # 指定0层进行排序
df4.sort_index(level=0) # 指定0层进行排序
df4.sum()
df4.sum(level=“c”)
df4.reset_index() # 重新设置索引为默认索引
df7 = pd.DataFrame(np.arange(12).reshape(3,4),index=list(“ABC”),columns=list(“DEFG”))
df8 = pd.DataFrame(np.arange(6).reshape(2,3),index=list(“AB”),columns=list(“WXY”))

print(df7)
print(df8)
df7.join(df8) # df.join(other,how=left) other 为链接的数组，how=left 以左边的df为主
df8.join(df7)
df9 = pd.DataFrame(np.arange(12).reshape(3,4),index=list(“ABC”),columns=list(“DEFG”))
df10 = pd.DataFrame(np.arange(10).reshape(2,5),index=list(“AB”),columns=list(“WXYZL”))

df9.merge(df10) 没有公共列，报错

df11 = pd.DataFrame(np.arange(6).reshape(2,3),index=list(“AB”),columns=list(“XYZ”))
df12 = pd.DataFrame(np.arange(6).reshape(3,2),index=list(“ABC”),columns=list(“WZ”))
pd.merge(df11,df12) #当有公共列有公共元素时，默认以公共元素拼接， z列公共5 进行拼接,公共z列中不含公共元素时，直接为空
#如果公共z列有多个共同元素，则为多行，拼接方式可以指定以left数组或者right数组为主，outer取并集，inner取交集
df13 = pd.DataFrame(np.arange(6).reshape(3,2),index=list(“ABC”),columns=list(“XZ”))
df13
pd.merge(df11,df13)
df11
df14 = pd.DataFrame(np.arange(6).reshape(3,2),index=list(“ABC”),columns=list(“YZ”))
df14
pd.merge(df11,df14)
df11 = pd.DataFrame(np.arange(6).reshape(2,3),index=list(“AB”),columns=list(“XYZ”))
df12 = pd.DataFrame(np.arange(6).reshape(3,2),index=list(“ABC”),columns=list(“WZ”))
print(df11)
print(df12)
df11.merge(df12,left_on=“Y”,right_on=“W”) # df3中的y 与df4中的W交集为4，相当于两边的最后一行进行连接
df15 = pd.DataFrame(np.arange(12).reshape(3,4),index=list(“ABC”),columns=list(“QWER”))
df16 = pd.DataFrame(np.arange(15).reshape(3,5),index=list(“ABC”),columns=list(“ZXCVB”))
pd.concat((df15,df16))
pd.concat((df15,df16),axis=1)

Pandas 最后一节课

主要说了pandas画图，时间序列，分组和聚合
df1 = pd.DataFrame(
{
“names”:[“菲菲”,“小可爱”,“mia”,“牛哥”,“老王”,“mia”,“狼人”,“药水哥”,“药水哥”],
“classes”:[“一班”,“二班”,“三班”]*3,
“grades”:np.random.randint(60,100,size=9)
} # 创建数组。注意都是9个数
)
df1
df1.groupby(by=“classes”) #返回值为对象，可以迭代
for i in df1.groupby(by=“classes”):
print(i)
print("#"*45)
for g_name,group in df1.groupby(by=“classes”): # 输出的结果为组名，每个组的数据
print(g_name) # 组名
print(group) # dataframe
print(type(group))
df1.groupby(by=“classes”)[“grades”].mean()# 求每个班同学的均值成绩
df1.groupby(by=“classes”).mean()#返回dataframe数据 分组+聚合
#定义求各班级极差的函数
def classes_ptp(x):
return x.max()-x.min()
df1.groupby(by=“classes”)[“grades”].agg(classes_ptp)
df1.groupby(by=“classes”)[“grades”].aggregate(classes_ptp)
#显示各班级的极差，最大，最小值
agg_li=[classes_ptp,np.max,np.min]
df1.groupby(by=“classes”)[“grades”].agg(agg_li)

def sort_df(df):
return df.sort_values(by=“grades”,ascending=False)
df1.groupby(by=“classes”).apply(sort_df)
df2 = pd.DataFrame(
np.random.randint(60,100,size=(5,3)),
index=[“菲菲”,“小可爱”,“mia”,“牛哥”,“老王”],
columns=[“语文”,“数学”,“英语”]
)
df2

定义字典

g_dic = {“菲菲”:“一班”,“小可爱”:“一班”,“mia”:“二班”,“牛哥”:“三班”}
df2.groupby(by=g_dic).mean() # 求各班成绩均值，通过名字将其班级关系联系起来
#series 方法
s=pd.Series(g_dic)
s
df2.groupby(by=s).mean()
#以班级同学姓名的长度进行分组，注意分组的names为索引
df3=df1.set_index(“names”)
df3.groupby(len).count() # 以名字的长度进行分组，求个数
sb_df = pd.read_csv(“starbucks_store_worldwide.csv”)
sb_df.info()
sb_df.groupby(by=“Country”).count()
data=sb_df.groupby(by=“Country”).count()[‘Store Number’]
data
data[“US”]
data[“CN”]
#datetime 对象列表
[datetime(2020,9,1)]
dates=[datetime(2020,9,1),datetime(2020,9,2),datetime(2020,9,3),datetime(2020,9,4)]
dates
ts=pd.Series(np.random.randint(1,10,size=4),index=dates)
ts
ts.index #DatetimeIndex 时间序列索引 datetime对象可以被放入datetimeindex中，就是时间序列
ts[::2]
ts[::2]+ts
ts.index.dtype
ts.index[0] #时间戳
#pandas生成时间序列,默认的频率是1天
pd.date_range(start=“20200101”,end=“20200201”)
pd.date_range(start=“20200101”,end=“20200201”,freq=“10D”)
pd.date_range(start=“20200101”,end=“20200201”,freq=“4h”)
pd.date_range(start=“20200101”,end=“20200201”,freq=“1h30min”)
pd.date_range(start=“20200101”,end=“20200201”,periods=5) #等分划分区间
pd.date_range(start=“20200101”,periods=5) #默认的freq=1天
pd.date_range(start="2020-01-01 12:59:59 ",periods=5) #默认的freq=1天
pd.date_range(start="2020-01-01 12:59:59 ",periods=5,normalize=True) #默认的freq=1天
ts2=pd.Series(np.random.randint(1,100,size=600),index=pd.date_range(“20190101”,periods=600))
ts2
ts2[‘2020’]
ts2[‘2020 01’]
ts2[‘2020 01 10’:‘2020 01 20’] #时间切片
df_ts=pd.DataFrame(np.arange(500),index=pd.date_range(“20190101”,periods=500))
df_ts
df_ts.loc[“2020”]
df_ts.loc[“2019”]
df_ts.loc[“2019 05 01”:,:]
ts2
dates=[datetime(2020,9,10),datetime(2020,9,9),datetime(2020,9,10),datetime(2020,9,10)]
dates
dup_ts=pd.Series(np.arange(4),index=dates)
dup_ts
dup_ts.index.unique
dup_ts.index.is_unique #检测时间索引是否唯一
dup_ts[“2020 09 10”]
dup_ts.groupby(level=0).mean() #时间索引不唯一，可以分组聚合level=0 指定外层索引
ts2
ts2.shift(2) #索引并不发生变化，移位的是数值
ts2.shift(-2) #索引并不发生变化，移位的是数值
#计算百分比change
ts2/ts2.shift(1)-1
ts2.pct_change()
#时间序列的移位, 指定频率
ts2.shift(2,freq=“D”)
ts3 = pd.DataFrame(np.random.randint(100,200,size=100),index=pd.date_range(start=“20200101”,periods=100))
ts3
ts3.resample(“M”) # 降采样，频率D----M
ts3.resample(“M”).sum()
ts3.resample(“10D”).sum()
ts4 = pd.DataFrame(np.random.randint(2000,5000,size=(4,4)),index=pd.date_range(start=“20200801”,freq=“10D”,periods=4),columns=[“北”,“上”,“广”,“深”])
ts4
#10天-1天, 转换为高频， 用的比较少，因为数据缺失
ts4.resample(“D”)
ts4.resample(“D”).asfreq()
ts4.resample(“D”).ffill()
df4 = pd.DataFrame(np.random.randint(1000,4000,size=(4,4)),index=[20200101,20200102,20200103,20200104],columns=[“北京”,“上海”,“广州”,“深圳”])
df4
df4.index.dtype

将int64转为datetime

df4.reset_index(inplace=True)
df4[“index”] = pd.to_datetime(df4[“index”])
df4
#df[“index”] = pd.to_datetime(df[“index”])
df = pd.DataFrame(np.random.randint(1000,4000,size=(4,4)),index=[20200101,20200102,20200103,20200104],columns=[“北京”,“上海”,“广州”,“深圳”])
df
df.reset_index(inplace=True)
df[“index”] = pd.to_datetime(df[“index”],format="%Y%m%d")
df
#series 和dataframe都有plot属性，用来绘制基本图片，默认为折线图
iris_data=pd.read_csv(“iris.csv”)
iris_data
iris_data.plot()
#直观的比较每种花的长宽的均值
iris_data.groupby(by=“Name”).mean()
iris_data.groupby(by=“Name”).mean().plot(kind=“bar”)

pandas基本讲完了，这节课和下节课都是练习
sb_df=pd.read_csv(“starbucks_store_worldwide.csv”)
sb_df.info()
sb_df.head()

方法1 先获取中国的数据，然后把市作为分组

cn_df=sb_df[sb_df[“Country”]==“CN”] # 布尔索引取值
cn_df
cn_df.groupby(“City”)
cn_df.groupby(“City”).count()
cn_df.groupby(“City”).count()[“Brand”]

方法2 直接以国家和市进行索引

all_data=sb_df.groupby([“Country”,“City”]).count()
all_data.loc[“CN”]
df=pd.read_csv(“911.csv”)
df.info()
df.head()

将object转为时间序列

df[“timeStamp”]=pd.to_datetime(df[“timeStamp”])
df.dtypes
df.set_index(“timeStamp”,inplace=True)
df.head()
df.resample(“M”).count()
countmonth=df.resample(“M”).count()[“title”]
countmonth
x=countmonth.index
y=countmonth.values
#$plt.plot(x,y) # 绘制折线图

plt.plot(range(len(x)),y) #x轴的刻度标签为 count_month.index 来显示
#时间序列里每个元素都是timeStamp，用函数strftime
x_fmt=[i.strftime( “%Y-%m-%d”) for i in x]
plt.xticks(range(len(x)),x_fmt,rotation=90)
plt.show()
bj_df=pd.read_csv("./PM2.5/BeijingPM20100101_20151231.csv")
bj_df

年月日合并为一个时间, 转为时间段索引

period_df=pd.PeriodIndex(year=bj_df[“year”],month=bj_df[“month”],day=bj_df[“day”],freq=“D”)
period_df
#为bj新增timestamp 再将timestamp设为索引
bj_df[“timeStamp”]=period_df
bj_df
bj_df.set_index(“timeStamp”,inplace=True)

bj_df
bj_df.resample(“7D”)
dfbj=bj_df.resample(“7D”).mean()
dfbj
data=dfbj[“PM_US Post”]
data
x=data.index
y=data.values

plt.plot(x,y)

plt.show()

type(x) #PeriodIndex 数据类型不能直接绘图
gz_df=pd.read_csv("./瓜子/guazi.csv")
#gz_df.rename(columns={“leixing”:“类型”})
gz_df.columns=[“类型”,“年份”,“里程”,“地点”,“售价”,“原价”]
gz_df
gz_df=gz_df[gz_df[“年份”]!=“nianfen”]
gz_df.drop_duplicates(inplace=True) # 删除重复值
gz_df
gz_df.dropna(inplace=True)
gz_df
#数据含有单位，object，不方便计算，需求，将年份里程等转为数值类型

def clean_unit(x):

return x.alnum

gz_df.loc[:,[“年份”,“里程”,“售价”,“原价”]].apply()

def clean_unit(x):

return x.str.replace(“年”,"")

gz_df.loc[:,[“年份”,“里程”,“售价”,“原价”]].apply(clean_unit)

gz_df[“年份”]=gz_df[“年份”].str.replace(“年”,"")
gz_df[“里程”] = gz_df[“里程”].str.replace(“万公里”,"")
gz_df[“里程”] = gz_df[“里程”].str.replace(“公里”,"")
gz_df[“售价”] = gz_df[“售价”].str.replace(“万”,"")
gz_df[“原价”] = gz_df[“原价”].str.replace(“万”,"")
gz_df

将object类型转为 数值类型

gz_df[“里程”] = gz_df[“里程”].astype(“float”)

gz_df[“售价”] = gz_df[“售价”].astype(“float”)

gz_df[“原价”] = gz_df[“原价”].astype(“float”)
gz_bj = pd.read_csv("./瓜子/guazi_bj.csv")
gz_gz = pd.read_csv("./瓜子/guazi_gz.csv")
gz_sh = pd.read_csv("./瓜子/guazi_sh.csv")
gz_sz = pd.read_csv("./瓜子/guazi_sz.csv")
gz_gz.head()
gz_gz.info()
all_gz=pd.concat([gz_bj,gz_gz,gz_sh,gz_sz])
all_gz
all_gz.drop_duplicates(inplace=True)
all_gz
all_gz.reset_index()
all_gz.groupby(“speedbox”).count()
all_gz.groupby(“city”).count()
all_gz.groupby(“city”).count().sort_values(by=“title”,ascending=False)
all_gz[all_gz[“city”]“深圳”].groupby(“brand”).count()
all_gz[all_gz[“city”]“深圳”].groupby(“brand”).count().sort_values(by=“title”,ascending=False)

继续练习python
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
df=pd.read_json(“population_data.json”)
df.info()
df.head()
popu_data=df.pivot_table(index=“Country Name”,columns=“Year”,values=“Value”)
popu_data
country_list = [“Afghanistan”,“Albania”,“Arab World”,“Aruba”,“Bangladesh”]

选择数据，用神奇索引,需求是2010年的数据，所以加上2010

country_data=popu_data.loc[country_list,2010]
country_data_list=country_data.values
country_data_list
plt.figure(figsize=(15,8))
plt.pie(country_data_list,labels=country_data.index,autopct="%1.2f%%")
plt.show()
df2=pd.read_excel(“合并1.xls”)
df2.info() # 这是一种打印， 所以最好放在head上面
df2.head()
#创建pivot table，可以用pd，也可以用df
pd.pivot_table(df2,index=“到期日/返售日”,columns=“额度占用人名称”,values=“票面金额”) # 默认分组之后，aggfunc求均值，如果求和，需要设定aggfunc
df2_pivot=pd.pivot_table(df2,index=“到期日/返售日”,columns=“额度占用人名称”,values=“票面金额”,aggfunc=np.sum)
df2_pivot.head() #生成透视表，并且index分组后指定聚合函数为np.sum

实现按月取值，时间转为时间序列，时间序列，选取数据2020 05

重置索引

df2_pivot = df2_pivot.reset_index()
df2_pivot.head()

将 到期日/返售日 修改为obejct类型

df2_pivot[“到期日/返售日”] = df2_pivot[“到期日/返售日”].astype(“object”)
df2_pivot.dtypes

转为时间序列类型

df2_pivot[“到期日/返售日”] = pd.to_datetime(df2_pivot[“到期日/返售日”],format="%Y%m%d")
df2_pivot

将时间序列设置为索引

df2_pivot.set_index(“到期日/返售日”,inplace=True)
df2_pivot.info()
df2_pivot

#df2_pivot.loc[“2020-05”,:].to_excel(“05数据.xlsx”) 保存到工作簿中，而非sheet中，需要根据月份保存，需要xlwt 和xlrd

创建工作簿对象

writer=pd.ExcelWriter(“拆分.xls”)
df2.to_excel(writer,sheet_name=“总表”,index=False)
#生成有起始值值终止值的时间序列
#pd.date_range(“2020-05”,“2021-05”,freq=“M”) # 月底， MS 为月初
for i in pd.date_range(“2020-05”,“2021-05”,freq=“MS”):
df2_time=i.strftime("%Y-%m")

df2_data=df2_pivot.loc[df2_time,:]

#print(df2_data)
df2_data.to_excel(writer,sheet_name=str(df2_time))
writer.save() #保存工作簿
ath_df = pd.read_csv(“athlete_events.csv”)
ath_df.info()
ath_df.head()
countries = {
‘CHN’:‘中国’,
‘JPN’:“日本”,
‘KOR’:‘韩国’,
‘USA’:“美国”,
‘CAN’:“加拿大”,
‘BRA’:“巴西”,
‘GBR’:“英国”,
‘FRA’:“法国”,
‘ITA’:“意大利”,
‘ETH’:“埃塞俄比亚”,
‘KEN’:“肯尼亚”,
‘NIG’:“尼日利亚”,
}
countries.keys()
dfs=[]
for code in countries.keys():
coun_df=ath_df[ath_df[“NOC”]==code][“Height”].dropna()
#print(coun_df)
dfs.append(coun_df) # 构建每个国家数据的列表

plt.rcParams[“font.sans-serif”] = [“SimHei”]
plt.figure(figsize=(14,8))
plt.boxplot(dfs) #绘制箱型图
plt.xticks(range(1,len(countries.keys())+1),countries.values())
plt.show()
#排序，获取中国的数据，以身高排序
ath_df[ath_df[“NOC”]==“CHN”].sort_values(“Height”,ascending=False).head()
df3=pd.read_excel(“lagouzp.xls”)
df3.info()
df3.head()
def rpl_k(s):
return s.replace(“k”,“000”).replace(“K”,“000”).split("-")
sli=df3[“薪资”].apply(rpl_k)
sli
df3[“max salary”]=sli.str[0]
df3[“min salary”]=sli.str[1]

df3[“max salary”]=df3[“max salary”].astype(“int”)
df3[“min salary”]=df3[“min salary”].astype(“int”)
df3[“ave salary”]=(df3[“max salary”]+df3[“min salary”])/2
df3
df3.groupby(“城市”).mean().sort_values(by=“ave salary”)
df3.pivot_table(index=“工作年限”,values=“ave salary”)
df3.describe()
bins = [0,10000,20000,30000,40000,50000,60000,70000,80000]
cats=pd.cut(df3[“ave salary”].values,bins)
cats

df3[“salary rank”]=cats.codes
df3
food_df=pd.read_csv(“餐饮.csv”,encoding=“gbk”)
food_df.info()
food_df.head()
food_df[“人均”].max()
bins = [0,50,100,150,200,40533]
cats=pd.cut(food_df[“人均”].values,bins)
cats
food_df[“消费等级”]=cats.codes
food_df # 不在bin里面的数，就会被分到-1组
food_df[“消费等级”]=food_df[“消费等级”].replace(-1,np.nan)
food_df.groupby(by=[“城市”,“消费等级”]).count()
food_df2=food_df.dropna()
food_df2.info()

去除异常值

dp_max=food_df2[food_df2[“点评”]==food_df2[“点评”].max()].index.values
del_data=food_df2.drop(dp_max)
dp_max=food_df2[food_df2[“人均”]==food_df2[“人均”].max()].index.values
del_data=food_df2.drop(dp_max)
khf_target=(del_data[“口味”]+del_data[“环境”]+del_data[“服务”])/3
#将点评进行收敛
del_data[“点评”]=np.log(del_data[“点评”])
del_data

del_data[“人均”]=np.log(del_data[“人均”])
del_data
ana=khf_target+del_data[“点评”]-del_data[“人均”]
ana
#数据归一
ana_max=max(ana)
ana_min=min(ana)
del_data[“归一化评价”]=(ana-ana_min)/(ana_max-ana_min)
del_data.sort_values(“归一化评价”)

9月18的课程，终于把pandas讲完了，练习就讲了3节课，比10多年前上新东方还累！
今天的练习也是比较难，用到了类，都快忘光了。还有一个meshgrid方法，头大。
import pandas as pd
import numpy as np
from matplotlib import pyplot as plt

#c_con_df=pd.read_csv(“covid_concern_toplines.csv”)
c_con_df= pd.read_csv(“covid_concern_toplines.csv”)
c_con_df.info()
c_con_df.head()
con_infe_df=c_con_df[c_con_df[“subject”]“concern-infected”] # 取出关心感染的数据
con_infe_df
con_infe_df[“modeldate”]=pd.to_datetime(con_infe_df[“modeldate”])
con_infe_df2=con_infe_df.set_index(“modeldate”)
con_infe_df3=con_infe_df2.resample(“MS”).mean()
plt.figure(figsize=(80,8))
con_infe_df3.plot()
#安装pip install pyecharts 最新版本1.8
#安装pip install pyecharts1.0.0 教程版本1.0
import pyecharts.options as opts # 导入配置项
from pyecharts.charts import Line # 导入折线图类

from pyecharts.faker import Faker

c = (
Line() # 创建折线图对象
.add_xaxis([1,2,3,4]) # 添加x轴,数据
.add_yaxis(“商家A”, [1,2,3,4], is_smooth=True) # 添加y轴：图例,y数据
.add_yaxis(“商家B”, [5,6,7,8], is_smooth=True) # 添加y轴：图例,数据
.set_global_opts(title_opts=opts.TitleOpts(title=“Line-smooth”)) # 全局配置项,指定标题

.render(“line_smooth.html”) # 渲染到本地的网页呈现

)
c.render_notebook() # 渲染到编辑器中 在使用pyecharts过程中，它的数据一定是python原生的list

绘图前处理数据，处理时间 年月日 列表

xli=[i.strftime("%Y-%M-%D") for i in con_infe_df3.index ]
def cope_with_data(s):
return round(s,4)
y_df=con_infe_df3.loc[:,“very_estimate”:“not_at_all_estimate”].apply(cope_with_data)
y_df
#取出4列，转为list
very_estimate_li=y_df[“very_estimate”].tolist()
somewhat_estimate_li = y_df[“somewhat_estimate”].tolist()
not_very_estimate_li = y_df[“not_very_estimate”].tolist()
not_at_all_estimate_li = y_df[“not_at_all_estimate”].tolist()
import pyecharts.options as opts # 导入配置项
from pyecharts.charts import Line # 导入折线图类

from pyecharts.faker import Faker

c = (
Line() # 创建折线图对象
.add_xaxis(xli) # 添加x轴,数据
.add_yaxis(“very_estimate”, very_estimate_li, is_smooth=True) # 添加y轴：图例,y数据
.add_yaxis(“somewhat_estimate”, somewhat_estimate_li, is_smooth=True) # 添加y轴：图例,y数据
.add_yaxis(“not_very_estimate”, not_very_estimate_li, is_smooth=True) # 添加y轴：图例,y数据
.add_yaxis(“not_at_all_estimate”, not_at_all_estimate_li, is_smooth=True) # 添加y轴：图例,y数据
.set_global_opts(title_opts=opts.TitleOpts(title=“US people’s concern on Covid”)) # 全局配置项,指定标题

.render(“line_smooth.html”) # 渲染到本地的网页呈现

)
c.render_notebook()
#使用类来实现 读取数据，处理数据，绘制数据
class DataAna(object):
#初始化方法
def init(self,get_what_data):
self.get_what_data=get_what_data
#实例方法
def read_data(self):
c_con_df= pd.read_csv(“covid_concern_toplines.csv”)
con_infe_df=c_con_df[c_con_df[“subject”]==self.get_what_data]
return con_infe_df

# 对数据进行处理
def cope_data(self):
    con_infe_df=self.read_data()
    con_infe_df["modeldate"]=pd.to_datetime(con_infe_df["modeldate"])
    con_infe_df2=con_infe_df.set_index("modeldate")
    con_infe_df3=con_infe_df2.resample("MS").mean()
    return con_infe_df3
    


def plot_fig(self,fig_title):
    con_infe_df3 = self.cope_data()
    
    # 处理时间 年月日 列表
    x_li = [i.strftime("%Y-%m-%d") for i in con_infe_df3.index]

    def cope_with_data(s):
        return round(s,4)

    y_df = con_infe_df3.loc[:,"very_estimate":"not_at_all_estimate"].apply(cope_with_data)
    y_df


    # 取出4列 转为 list
    very_estimate_li = y_df["very_estimate"].tolist()
    somewhat_estimate_li = y_df["somewhat_estimate"].tolist()
    not_very_estimate_li = y_df["not_very_estimate"].tolist()
    not_at_all_estimate_li = y_df["not_at_all_estimate"].tolist()
    
    c = (
        Line()
        .add_xaxis(x_li)
        .add_yaxis("very_estimate", very_estimate_li, is_smooth=True)
        .add_yaxis("somewhat_estimate", somewhat_estimate_li, is_smooth=True)
        .add_yaxis("not_very_estimate", not_very_estimate_li, is_smooth=True)
        .add_yaxis("not_at_all_estimate", not_at_all_estimate_li, is_smooth=True)
        .set_global_opts(title_opts=opts.TitleOpts(title=fig_title))
    )
    return c.render_notebook()

concern_economy=DataAna(“concern-economy”)
concern_economy.plot_fig(“US concerns”)
from matplotlib import pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
%matplotlib notebook
#将0-15 分成1000份。 3D曲线图的绘制
zline=np.linspace(0,15,1000)
xline=np.sin(zline)
yline=np.cos(zline)
fig=plt.figure()
ax=Axes3D(fig)
ax.plot(xline,yline,zline)
plt.show()
x=np.random.rand(100)
y=np.random.rand(100)
z=np.random.rand(100)
fig=plt.figure()
ax=Axes3D(fig)
ax.scatter(x,y,z,color=“r”)
x=[1,2,3,4]
y=[5,6,7,8]
np.meshgrid(x,y) # 构建数据 网格
X,Y=np.meshgrid(x,y)
print(X)
print(Y)
fig=plt.figure()
ax=Axes3D(fig)
ax.plot_surface(X,Y,Z=X*0+3)
ax.set_xlabel(“x”)
ax.set_ylabel(“y”)
ax.set_zlabel(“z”)

plt.show()
import seaborn as sns
#sns.load_dataset(“tips”) 网关有问题，不建议
pd.read_csv(’./seaborn-data-master/tips.csv’)

开始讲seaborn 图形的类型和关系真多
关系型绘图，sns.relplot 有散点图和折线图，分类型绘图，sns.catplot. 分类散点图，stripplot, swarmplot. 分类分布图，箱型图，小提琴图，分类统计图，有条形图barplot，柱状图countplot（xy只能有1个），点线图，pointplot。最后是分布绘图，单一变量distplot，多变量jointplot，pairplot vars

from matplotlib import pyplot as plt
import pandas as pd
import numpy as np
import seaborn as sns
tips=pd.read_csv("./seaborn-data-master/tips.csv")
tips
sns.relplot(x=“total_bill”,y=“tip”,data=tips)
#通过点的颜色，表示日期,hue 分组后不同值显示不同颜色
sns.relplot(x=“total_bill”,y=“tip”,data=tips,hue=“day”)
tips.groupby(by=“day”).count()
sns.relplot(x=“total_bill”,y=“tip”,data=tips,col=“time”) # col从列的方向添加子图表示分类
sns.relplot(x=“total_bill”,y=“tip”,data=tips,col=“time”,row=“sex”)
sns.relplot(x=“total_bill”,y=“tip”,data=tips,col=“day”,col_wrap=3,size=“size”)
#当图形展示多个时，控制列的换行，不能与row同时使用
fmri=pd.read_csv("./seaborn-data-master/fmri.csv")
sns.relplot(x=“timepoint”,y=“signal”,data=fmri,kind=“line”)

阴影部分为置信区间，如果不需要，则可以设定ci参数

sns.relplot(x=“timepoint”,y=“signal”,data=fmri,kind=“line”,ci=None)
sns.relplot(x=“timepoint”,y=“signal”,data=fmri,kind=“line”,hue=“region”)
sns.relplot(x=“timepoint”,y=“signal”,data=fmri,kind=“line”,hue=“region”,col=“event”)
df=pd.DataFrame({“x”:np.arange(10),“y”:np.cos(np.arange(10))})
sns.relplot(x=“x”,y=“y”,data=df,kind=“line”)
sns.catplot(x=“day”,y=“total_bill”,data=tips)
sns.catplot(x=“day”,y=“total_bill”,data=tips,hue=“sex”)
sns.catplot(x=“day”,y=“total_bill”,data=tips,hue=“sex”,kind=“swarm”) # 点不会被覆盖
athletes=pd.read_csv(“athlete_events.csv”)
countries = {
‘CHN’:‘中国’,
‘JPN’:“日本”,
‘KOR’:‘韩国’,
‘USA’:“美国”,
‘CAN’:“加拿大”,
‘BRA’:“巴西”,
‘GBR’:“英国”,
‘FRA’:“法国”,
‘ITA’:“意大利”,
‘ETH’:“埃塞俄比亚”,
‘KEN’:“肯尼亚”,
‘NIG’:“尼日利亚”,
}

athletes[athletes[“NOC”].isin(list(countries.keys()))]
myathletes=athletes[athletes[“NOC”].isin(list(countries.keys()))]
sns.boxplot(x=“NOC”,y=“Height”,data=myathletes)
#小提琴图(默认两边对称，kde曲线）绘制日期与小费的关系
sns.violinplot(x=“day”,y=“total_bill”,data=tips)
sns.violinplot(x=“day”,y=“total_bill”,data=tips,hue=“sex”,inner=“quartile”,split=True) # 四分位
#绘制分类统计图,黑色的线为置信区间，越长则说明数据越离散
sns.catplot(x=“day”,y=“total_bill”,data=tips,kind=“bar”)
sns.catplot(x=“day”,y=“total_bill”,data=tips,kind=“bar”,estimator=sum) #对数据求和
titanic=pd.read_csv("./seaborn-data-master/titanic.csv")
sns.catplot(x=“sex”,y=“survived”,data=titanic,kind=“bar”)#获救男性和女性的情况

sum指定频次

sns.catplot(x=“sex”,y=“survived”,data=titanic,kind=“bar”,estimator=sum)
#仓位与营救情况
sns.catplot(x=“sex”,y=“survived”,data=titanic,kind=“point”,hue=“class”)
#分布绘图，所有人年龄的情况,取出非nan的数据
age_ti=titanic[~np.isnan(titanic[“age”])]

sns.distplot(titanic[“age”])# 如果不想要这种曲线，则指定kde=false,bins 可以指定组数 rug数据越密集则数据越集中
sns.distplot(age_ti[“age”],kde=False,bins=30,rug=True)

sns.jointplot(x=“total_bill”,y=“tip”,data=tips) # 两个变量的关系
sns.jointplot(x=“total_bill”,y=“tip”,data=tips,kind=“reg”) # 显示回归线和kde曲线
#六边形绘图，用颜色显示集中情况
china_ath=athletes[athletes[“NOC”]==“CHN”]
sns.jointplot(x=“Height”,y=“Weight”,data=china_ath)
sns.jointplot(x=“Height”,y=“Weight”,data=china_ath,kind=“hex”,gridsize=20,color=‘r’)
iris=pd.read_csv("./seaborn-data-master/iris.csv")
iris
sns.pairplot(iris,vars=[“sepal_length”,“sepal_width”,“petal_length”,“petal_width”])

从基础班开课以后，终于讲到干货的部分了.

#使用tushare获取五粮液股票的历史行情数据
wly_stock=pro.daily(ts_code=“000858.SZ”,start_date=“20000101”)
#将数据保存为csv文件
wly_stock.to_csv(“00858.csv”,index=False)
#读取五粮液文件，指定trade_date为时间序列索引
#parse_dates 只能指定布尔值，列表，和字典 为时间序列索引，该函数不能指定星期，换算星期要做降采样
wly_df=pd.read_csv(“00858.csv”,index_col=“trade_date”,parse_dates=[“trade_date”])
wly_df.info()
wly_df.head()
wly_df[wly_df[“pct_chg”]>3] #该股票上涨3%以上的数据
wly_df[wly_df[“pct_chg”]>3].index #该股票上涨3%以上的日期
#开盘-收盘 除以前日开盘：
wly_df[(wly_df[“open”]-wly_df[“close”].shift(-1))/wly_df[“close”].shift(-1)>0.02].index
#截取2010年开始，2019年结束的数据 wly_df[“2010”:“2019”] 这样是截取不到的，因为切片有顺序
wly_df2=wly_df[“2019”:“2010”]
#每个月第一个交易日数据 first（）取每个月中第一个交易日的数据
wlymonthly=wly_df2.resample(“MS”).first()
wly_yearly=wly_df2.resample(“A”).last()
wly_yearly
#初始化变量 cost_money=0 已经持有股票 hold=0
cost_money=0
hold=0
for year in range(2010,2019):
# print(wlymonthly[str(year)][“open”].sum()*100)
cost_money+=wlymonthly[str(year)][“open”].sum()*100
# len(wlymonthly[str(year)]) 如果求2020年的9个月，则用len看看今年有几个月的数据
hold+=len(wlymonthly[str(year)])*100 # 一年持有的股数
#wly_yearly[str(year)][“open”] 依然是series 对象
#wly_yearly[str(year)][“open”].values 是列表
#wly_yearly[str(year)][“open”].values[0] 才是对应股价
sell_money=wly_yearly[str(year)][“open”].values[0]*hold
cost_money-=sell_money #每年总成本，-收入
hold=0 # 已卖出，将持有股数清0
print(cost_money,hold)
print(f"save_money:{-cost_money},hold:{hold}")

这节课讲了金叉和死叉在tushare中的用法，简单介绍了聚宽
by_stock=pro.daily(ts_code=“000538.SZ”,start_date=“20100101”) # 获取云南白药2010年之后的数据
by_stock

保存至csv

by_stock.to_csv(“000538.CSV”,index=False)
#读取云南白药的数据

pd.read_csv(“000538.csv”,index_col=“trade_date”,parse_dates=[“trade_date”]) 通过神奇索引获取部分列的数据

by_df=pd.read_csv(“000538.csv”,index_col=“trade_date”,parse_dates=[“trade_date”]) [[“open”,“high”,“low”,“close”]]
by_df.sort_index(inplace=True)
#使用tushare包计算该股票历史数据的5日均线和30日均线
by_df[“MA5”]=np.nan
by_df[“MA30”]=np.nan
by_df.head()
#求取MA5
for i in range(4,len(by_df)):
#获取到MA5列i行的值，不可以直接用i，i是位置索引， 这里要获取行索引。by_df.index获取行索引.而后赋值收盘价的5日均价
by_df.loc[by_df.index[i],“MA5”]=by_df[“close”][i-4:i+1].mean()

for i in range(29,len(by_df)):
#获取到MA5列i行的值，不可以直接用i，i是位置索引， 这里要获取行索引。by_df.index获取行索引.而后赋值收盘价的5日均价
by_df.loc[by_df.index[i],“MA30”]=by_df[“close”][i-29:i+1].mean()
by_df
#时间升序
by_df.sort_index()
#方法2，rolling实现
by_df[“close”].rolling(5).mean()
by_df[“close”].rolling(30).mean()
by_df[[“close”,“MA5”,“MA30”]].plot()
plt.show()
#输出所有的金叉日期和死叉日期，需要去除nan,然后重新建立一个新变量
by_data=by_df.dropna()
by_data.info()
by_data.head()
golden_cross=[]
death_cross=[]
for i in range(1,len(by_data)):
#by_data[“MA5”]相当于series，一列
if by_data[“MA5”][i]>=by_data[“MA30”][i] and by_data[“MA5”][i-1]<=by_data[“MA30”][i-1]:
#将金叉的时间构建成列表
golden_cross.append(by_data.index[i])
if by_data[“MA5”][i]<=by_data[“MA30”][i] and by_data[“MA5”][i-1]>=by_data[“MA30”][i-1]:
#将死叉的时间构建成列表
death_cross.append(by_data.index[i])

#方法2， 死叉过渡到金叉， M5MA30，则为 FFFFFFFT, 2个都是F的时候，是金叉，错位比较2个都是T的时候，是死叉
se1=by_data[“MA5”] se2=by_data[“MA5”]>=by_data[“MA30”]
#如果要保证2个都为false，用or， 2个都是false
golden_cross2=by_data[~(se1 | se2.shift(1))].index #注意 要取非
#2个都是T的时候，才是死叉
death_cross2=by_data[se1 & se2.shift(1)].index

#golden_cross3=by_data[(se1 & se2.shift(1))].index
sr1=pd.Series(1,index=golden_cross2) #1 代表金叉
sr2=pd.Series(0,index=death_cross2) #0 代表死叉
#sr1 和sr2拼接成一个seris对象
sr=sr1.append(sr2)
sr1.append(sr2).sort_index()
sr = sr1.append(sr2).sort_index()
money=100000
hold=0
for i in range(0,len(sr)):

买卖需要价格，获取open列，通过取出sr的时间索引获取对应的时间价格

#print(by_data["open"][sr.index[i]]) 
# 索引值为1 的时候，为金叉，买入。索引值为1 的时候，为死，买入。
p=(by_data["open"][sr.index[i]]) 
if sr.iloc[i]==1:
    buy=money//(100*p) # 买入多少股，100的倍数
    hold+=buy*100   # 一共持有多少股
    money-=buy*100*p  # 起始资金会减少
else:
    #卖出
    money+=hold*p
    hold=0
    # 注意，最后一个点是金叉点，买入所花的钱算作收入

money

这节课是国庆节前最后一节，我到今天才有时间把他学完，在聚宽里面编程，体验又是另外一种方便。

导入函数库

from jqdata import *

初始化函数，设定基准等等

def initialize(context):
# A 股指数 成分股
g.security=get_index_stocks(“000002.XSHG”)

#查询数据，在数据字典/股票数据/搜索市值 valuation表格中有market cap
#构建get_fundamentals中的query对象, 查询code在股票池中的valuation表
g.q=query(valuation).filter(valuation.code.in_(g.security))
g.N=20
#每月执行策略函数，1是每月第一个交易日
run_monthly(handle_month,1) 

def handle_month(context):
#获取市值最小的20个股票，获取两列： code.market-cap
df=get_fundamentals(g.q)[[“code”,“market_cap”]]
#对market cap升序，再切片
df=df.sort_values(“market_cap”).iloc[:g.N,:]
#print(df)
#调仓，持有的股票在df里面就保留。如果不在又没有持有的话则买入
#取出股票代码
to_hold=df[“code”].values
#遍历现在所持有的股票,如果股票没在to hold列表里，就卖掉
for stock in context.portfolio.positions:
if stock not in to_hold:
order_value(stock,0)
#买入的股票，在to hold里面，但是不在我的持仓,用列表推导式
tobuy=[stock for stock in to_hold if stock not in context.portfolio.positions]
#计算每支股票可以使用的资金，注意tobuy可能是0
if len(tobuy)>0:
cash_per_stock= context.portfolio.available_cash/len(tobuy)
for stock in tobuy:
order_value(stock,cash_per_stock)

导入函数库

from jqdata import *

初始化函数，设定基准等等

def initialize(context):
g.security=get_index_stocks(“000300.XSHG”)

run_daily(period,time="every_bar")

def period(context):
tobuy=[]
for stock in g.security:
amount=context.portfolio.positions[stock].total_amount
#当前股票开盘价
p=get_current_data()[stock].day_open

    #计算买入时候的成本
    cost=context.portfolio.positions[stock].avg_cost
    
    #如果涨幅超过25%，则止盈
    if amount>0 and p>=cost*(1+0.25):
        order_target(stock,0)
    #如果跌幅超过10%，则止损
    if amount>0 and p<=cost*0.9:
        order_target(stock,0)
     
    #如果当前股价小于10元/股且当前不持仓，则买入

    #获取当前账户持有对应股票股数
    
    if p<=10 and amount ==0:
        tobuy.append(stock)
        #将可用资金除以tobuy的长度，计算每个股票可以花的钱
cash_per_stock=context.portfolio.available_cash/len(tobuy)

for stock in tobuy:
    order_value(stock,cash_per_stock)

每天买100股平安股票

导入函数库

from jqdata import *

初始化函数，设定基准等等

def initialize(context):
#定义全局变量
g.security=“000001.XSHE”
run_daily(period,time=“every_bar”)

def period(context):
#实现买股票，下单函数
order(g.security,120) #amount 不为100的整数时候，自动调整
#计算股票的收益率，当股票亏损达到1%的时候，卖出
#print(context.portfolio.positions[“000001.XSHE”])
#成本
cost=context.portfolio.positions[“000001.XSHE”].avg_cost
#收入
price=context.portfolio.positions[“000001.XSHE”].price
#计算收益率,为-0.01则清仓
ret=price/cost -1
if ret<-0.01:
order_target(g.security,0)

导入函数库

from jqdata import *

初始化函数，设定基准等等

def initialize(context):

g.security=["000001.XSHE"]

#初始化参数
g.d5=5
g.d60=60
 
run_daily(period,time="every_bar")

def period(context):
#金叉买入，死叉卖出
for stock in g.security:
#构建均线数据
df_5=attribute_history(stock,g.d5)
df_60=attribute_history(stock,g.d60)
#求均值
MA_5=df_5[“close”].mean()
MA_60=df_60[“close”].mean()
#金叉且不持仓则买入
if MA_5>MA_60 and stock not in context.portfolio.positions:
order(stock,context.portfolio.available_cash)

    #死叉且持仓则卖出
    if MA_5

#上周六补得最后一课，知道现在才有时间看。
数据库的5节课，外加一个画图的选修，我都没时间看了，需要的时候再说吧。
还是在聚宽里面。练习了4个程序。

roe减去市值，越大越好

from jqdata import *

1初始化函数

def initialize(context):
#初始化股票池
g.security=get_index_stocks(“000002.XSHG”)

#市值，roe 财务数据  构建查询对象
# market cap 所属表为valuation. roe 所属表为indicator
g.q= query(valuation,indicator).filter(valuation.code.in_(g.security))




# 执行函数
run_monthly(handle_month,1) #1 是第一个交易日

def handle_month(context):
#获取对应的股票代码的market cap和roe
df=get_fundamentals(g.q)[[“code”,“market_cap”,“roe”]]
#print(df)
#市值和roe 差的很远，用归一化方法（x-min）/(max-min )
df[“market_cap”]= (df[“market_cap”]-df[“market_cap”].min())/(df[“market_cap”].max()-df[“market_cap”].min())
df[“roe”]= (df[“roe”]-df[“roe”].min())/(df[“roe”].max()-df[“roe”].min())
#print(df)
#roe -market_cap
df[“score”]=df[“roe”]-df[“market_cap”]
#取前面20个股票
df=df.sort_values(“score”,ascending=False).iloc[:20,:]
#股票代码
to_hold= df[“code”].values

#目前账户所持有的股票
for stock in context.portfolio.positions:
    #不在to_hold股票就卖掉
    if stock not in to_hold:
        order_target(stock,0)
#买入tohold里面，但是不在我持有的股票里        
tobuy=[stock for stock in to_hold if stock not in context.portfolio.positions]

if len(tobuy)>0:
    cash_per_stock=context.portfolio.available_cash/len(tobuy)
    for stock in tobuy:
        order_value(stock,cash_per_stock)

#(MA -P)/MA 定义偏离程度，均值减去现在的价格
from jqdata import *

def initialize(context):
g.security=get_index_stocks(“000300.XSHG”)

g.ma_days=30

run_monthly(handle_month,1)

def handle_month(context):
sr=pd.Series(index=g.security)

for stock in sr.index:
    #MA30  
    ma=attribute_history(stock,g.ma_days)["close"].mean()
    
    #获取当天价格
    p=get_current_data()[stock].day_open
    # 偏离率
    ratio=(ma-p)/ma   
    sr[stock]=ratio

print(sr)

#从sr里面选择10个最大的取出来
to_hold=sr.nlargest(10).index.values
print(to_hold)

#目前账户所持有的股票
for stock in context.portfolio.positions:
    #不在to_hold股票就卖掉
    if stock not in to_hold:
        order_target(stock,0)
#买入tohold里面，但是不在我持有的股票里        
tobuy=[stock for stock in to_hold if stock not in context.portfolio.positions]

if len(tobuy)>0:
    cash_per_stock=context.portfolio.available_cash/len(tobuy)
    for stock in tobuy:
        order_value(stock,cash_per_stock)

#布林带策略
from jqdata import *

def initialize(context):
g.security= “600036.XSHG”

# 择时策略

run_daily(period,time="every_bar")

def period(context):
#压力线，支撑线（a.mean(）-2std(), a.mean()+2std())
#求20日均线
sr=attribute_history(g.security,20)[“close”]
#求均值
ma_20=sr.mean()
#求标准差
std_20=sr.std()
#压力线
up_line=ma_20+2std_20
#支撑线
down_line=ma_20-2std_20

# 当前价格突破则卖出，跌破买入
p=get_current_data()[g.security].day_open

#当前可用资金
cash=context.portfolio.available_cash

if pup_line and g.security in context.portfolio.positions:
    order_target(g.security,0)

#peg策略

from jqdata import *

def initialize(context):
g.security=get_index_stocks(“000300.XSHG”)

# 市盈率  净利润同比增长率 财务数据 query对象
# PE所属表valuation，净利润同比增长率所属表indicator

g.q=query(valuation.code,valuation.pe_ratio,indicator.inc_net_profit_year_on_year).filter(valuation.code.in_(g.security))
run_monthly(handle_month,1)

def handle_month(context):
#获取财务数据
df=get_fundamentals(g.q)
#print(df)
#选取pe和g都大于0的数据
df=df[ (df[“pe_ratio”]>0) & (df[“inc_net_profit_year_on_year”]>0 ) ]
#计算peg
df[“peg”]=df[“pe_ratio”]/df[“inc_net_profit_year_on_year”]*100
#排序

df=df.sort_values("peg")
# 取前20个股票
to_hold=df["code"][:20].values # series 不用[:20，：]

#目前账户所持有的股票
for stock in context.portfolio.positions:
    #不在to_hold股票就卖掉
    if stock not in to_hold:
        order_target(stock,0)
#买入tohold里面，但是不在我持有的股票里        
tobuy=[stock for stock in to_hold if stock not in context.portfolio.positions]

if len(tobuy)>0:
    cash_per_stock=context.portfolio.available_cash/len(tobuy)
    for stock in tobuy:
        order_value(stock,cash_per_stock)