python 数据分析基础 （小白的辛酸史）
1 常用的内置函数
`sum`
sum([1,2,3])
6
a=range(1,11)
b=range(1,10)
c=sum([item for item in a if item in b])
print(c)
45
zip
`zip(t,s)` 返回 t 和 s 的一个相互匹配的列表
t= \'abc\'
s=[1,2,3]
z=zip(t,s)
list(z)
[(\'a\', 1), (\'b\', 2), (\'c\', 3)]
list(zip(\'abcd\',\'123\')) #若长度不够，以短的为主
[(\'a\', \'1\'), (\'b\', \'2\'), (\'c\', \'3\')]
enumerate
`enumerate(t)` 返回 t 的index 和元素对， t 可以是字符串、列表、元组、字典等， 若是字典， 则返回的是键名。
t={\'first\':\'j\',\'second\':\'h\',\'third\':\'abc\'}
for i,k in enumerate(t):
print(i,k)
0 first
1 second
2 third
eval
`eval()` 将字符串 `str` 当成有效的表达式来求值，并返回计算结果。
x=1
eval(\'x+1\')
2
a="[[1,2],[3,4],[5,6],[7,8],[9,0]]" ##这里a是字符串
b=eval(a)
b
[[1, 2], [3, 4], [5, 6], [7, 8], [9, 0]]
type(b)
list
c="{1:\'a\',2:\'b\'}"
d=eval(c)
d
{1: \'a\', 2: \'b\'}
type(d)
dict
e="([1,2],[3,4],[5,6],[7,8],(9,0))"
f=eval(e)
f
([1, 2], [3, 4], [5, 6], [7, 8], (9, 0))
`startswith()`、`endswith`:做文本处理时，用来判断字符串开始和结束的位置。
"fish".startswith(\'fi\')
True
"fish".startswith(\'fi\',1)
False
"fish".endswith(\'sh\')
True
"fish".endswith(\'sh\',3)
False
`isalnum()` 检测字符串是否由字母和数字组成， 若其间夹杂有空格、标点符号或者其他符号，则都返回`False`
str="this2009"
print(str.isalnum())
True
`isaipha()`: 检测字符串是否由字母组成。如果字符串中的所有字符都是字母，则返回`True`，否则返回`False`
str="this2009"
print(str.isalpha())
False
pandas
`series`:即系列（也称序列），用于存储一行或一列的数据，以及与之相关的索引的集合
from pandas import Series
X=Series([\'a\',2,\'狗\'],index=[1,2,3])
X
1 a
2 2
3 狗
dtype: object
X[3]
\'狗\'
from pandas import Series
X=Series([\'a\',2,\'狗\']) ##索引可以不要，index省略的话默认从0开始，也可以指定索引
X
from pandas import Series
X=Series([1,2,3])
X
0 1
1 2
2 3
dtype: int64
from pandas import Series
X=Series([2,3,5],index=[\'first\',\'second\',\'third\'])
P=Series([\'8\'])
Q=X.append(P)
print(Q)
print(Q.drop(0))
print(Q.pop(\'first\'))
first 2
second 3
third 5
0 8
dtype: object
first 2
second 3
third 5
dtype: object
2
Dataframe
`Dataframe`是用于存储多行和多列的数据集合，是Series 的容器
from pandas import Series
from pandas import DataFrame
df=DataFrame({\'age\':Series([21,22,23]),\'name\':Series([\'Yubg\',\'john\',\'jim\'])})
print(df)
age name
0 21 Yubg
1 22 john
2 23 jim
| 访问位置 |
方法 |
备注 |
访问列 |
变量名[列名] |
访问对应的列 |
访问行 |
变量名[n:m] |
访问n行到m-1行的数据。如df[2:3]
|
访问块(行和列) |
变量名.iloc[n1:n2,m1:m2] |
访问n1到(n-2)行，m1到(m2-1)列的数据，如df.iloc[0:3,0:2]
|
访问位置 |
变量名at[行名，列名]` |
访问（行名，列名）位置的数据，如df.at[1,\'name\']
|
A=df[\'age\']
print(A)
0 21
1 22
2 23
Name: age, dtype: int64
B=df[\'name\']
print(B)
C=df[1:3]
print(C)
0 Yubg
1 john
2 jim
Name: name, dtype: object
age name
1 22 john
2 23 jim
D=df.iloc[0:2,0:2]
print(D)
age name
0 21 Yubg
1 22 john
from pandas import DataFrame
df1=DataFrame({\'age\':[21,22,23],
\'name\':[\'KEN\',\'John\',\'JIMI\']});
df2=DataFrame(data={
\'age\':[21,22,23],
\'name\':[\'KEN\',\'John\',\'JIMI\']
},index=[\'first\',\'second\',\'third\'])
print(df[\'age\'])
df1[1:3]
0 21
1 22
2 23
Name: age, dtype: int64
|
age |
name |
| 1 |
22 |
John |
| 2 |
23 |
JIMI |
df1.iloc[0:2,0:1]
df1.drop(\'age\',axis=1) #axis=1表示列轴，不可省略
df1.drop(1,axis=0) #axis=0表示行轴，可以省略
|
age |
name |
| 0 |
21 |
KEN |
| 2 |
23 |
JIMI |
df1[\'newColumn\']=[2,3,5]
print(df1)
name newColumn
0 KEN 2
1 John 3
2 JIMI 5
df1[\'new\']=[2,6,9]
print(df1)
name newColumn new
0 KEN 2 2
1 John 3 6
2 JIMI 5 9
df=DataFrame([[1,2],[3,4]], columns=list(\'AB\'))
df
A=Series({\'a\':1,\'b\':2,\'c\':3})
A
a 1
b 2
c 3
dtype: int64
obj=Series([4.2,2.6,5.3,4.8], index=[\'a\',\'c\',\'d\',\'b\'])
obj
a 4.2
c 2.6
d 5.3
b 4.8
dtype: float64
obj2=obj.reindex([\'a\',\'b\',\'c\',\'d\',\'e\'])##reindex重排序
obj2
a 4.2
b 4.8
c 2.6
d 5.3
e NaN
dtype: float64
数据导入
1. 导入`tex`文件
read_table(file,name=[列名1,列名2,...],sep="",...)
`file` 为文件路径和文件名,`name`为列名，默认为文件的第一行作为列名,`sep` 为分隔符，默认为空，表示默认导入为一列
2. 导入`csv`文件
read_csv(file,name=[列名1,列名2,...],sep="",...)
`file` 为文件路径和文件名,`name`为列名，默认为文件的第一行作为列名,`sep` 为分隔符，默认为空，表示默认导入为一列
3. 导入`excel`文件
read_excel(file, sheetname,header=0)
`file` 为文件路径和文件名,`sheetname`为sheet的名称，例如sheet1.`header` 为列名，默认为0，文件的第一行作为列名。只接受布尔型0和1.
4. 导入`MysSQL库·
read_sql(sql,con=数据库)
`sql` 为从数据库中查询数据的SQL语句，`con`为数据库的连接对象，需要在程序中选择创建。
from pandas import read_excel##若是txt文件的话为\'read_table\',csv文件的话为‘read_csv’
df=read_excel(\'D://学生信息总表2016.xlsx\',sheetname=\'Sheet1\',header=0)##header 取0和1的区别，取0表示第一行作为表头显示，取1表示第一行丢弃，不作为表头显示。
print(df)
#sheetname可以指定读取几个sheet，数目从0开始，如果sheetname=[0,2],则代表读取第0页和第2页的sheet；skiprows=[0]代表读取时跳过第0行
导入MySQL库
import pandas
import MySQLdb
connection = MySQLdb.connect(
host = \'\', #本机的访问地址
user=\'\', #登录名
passwd=\'\', #访问密码
db=\'\', #访问的数据库
port=\'\', #访问端口
charset=\'utf8\') #编码格式
data=pandas.read_sql("select * from t_user;",con=connection) #t_user是test库中的表
connetion.close() #调用完要关闭数据库
数据导出
导出`CSV`文件
`to_csv(file_path,sep=",",index=TRUE,header=TRUE)`
`file_path`为文件路径，`sep`为分隔符，默认是逗号，`index`代表是否出行序号，默认是TRUE，导出行序号。
`header`代表是否导出列名，默认是TRUE，导出列名。
导出`excel`文件
`to_excel(file_path,index=TRUE,header=TRUE)`
`file_path`为文件路径,`index`代表是否出行序号，默认是TRUE，导出行序号。
`header`代表是否导出列名，默认是TRUE，导出列名。
导出到`MySQL`库
`to_sql(tableName,con=数据库链接)
`tableName`为数据库中的表名，`con`表示数据库的连接对象，需要在程序中选择创建
`导出CSV文件`
from pandas import DataFrame
from pandas import Series
df=DataFrame({\'age\':Series([26,85,64]),\'name\':Series([\'Ben\',\'John\',\'Jerry\'])})
print(df)
age name
0 26 Ben
1 85 John
2 64 Jerry
`导出Exel文件`
from pandas import DataFrame
from pandas import Series
df=DataFrame({\'age\':Series([26,85,64]),
\'name\':Series([\'Ben\',\'John\',\'Jerry\'])},index=[1,2,3])
df
|
age |
name |
| 1 |
85.0 |
John |
| 2 |
64.0 |
Jerry |
| 3 |
NaN |
NaN |
数据处理
`数据清洗`
1.重复值的处理
- drop_duplicates():把数据结构中行相同的数据去除(保留其中的一行).
2.缺失值处理
- （1）dropna(): 去除数据结构中值为空的数据行。
- （2）df.fillna():用其他数值替代NaN。（有些时候，空数据直接删除会影响分析的结果，可以对数据进行填补。）
- （3）df.fillna(method=\'pad\'):用前一个数据值替代NaN.
- （4）df.fillna(method=\'bfill\'):用后一个数据值替代NaN.(与pad相反，bfill表示用后一个数据代替NaN.)
- （5）df.fillna(df.mean()):用平均数或者其他描述性统计量来代替NaN.
- （6）df.fillna(df.mean()[math:physical]):选择列进行缺失值的处理。
- （7）strip(): 清除字符型数据左右（首尾）指定的字符，默认为空格，中间的不清除。
数据抽取
(1) 字段抽取—抽出某列上指定位置的数据，做成新的列；
`slice(start,stop)`:`start`为开始位置，`stop`为结束位置。
(2) 字段拆分—按指定的字符sep,拆分已有的字符串；
`split(sep,n,expand=False)`:`sep`是用于分隔字符串的分隔符；`n`是分割后的列数；`expand`代表是否展开为数据框，默认为False.
返回值：`expand`为True，返回DataFrame; 为False返回Series
(3) 记录抽取
`dataFrame[condition]`:`condition`为过滤条件
返回值：DataFrame.
常用的condition类型如下
比较运算：`<、>、>=、<=`
范围运算：between(left,right),如df[df.commets>10000]
空置运算：pandas.isnull(column),如df[df.title.isnull()]
字符匹配：str.contains(patten,na=False),如df[df.title.str.contains(\'电台\'，na=False)]
逻辑运算：&(与)、|(或)、not(取反)，如：
`df[(df.comments>=1000)&(df.comments<=10000)]` 与 `df[df.comments.between(1000,10000)]`等价
(4) 随机抽样
`numpy.random.randint(start,end,num)` 其中 `start`为范围的开始值，`end`为范围的结束值 `num`为抽样个数
返回值：行的索引值序列
- a.使用index标签选取数据：df.loc[行标签，列标签]。如
`df.loc`[\'a\':\'b\'] 选取ab两行数据，假设a、b为行索引
`df.loc`[:,\'Tsj\'] 选取Tsj列的数据
`df.iloc[行位置，列位置]` 如：
`df.iloc`[1,1] 选取第二行，第二列的值，返回的是单个值
`df.iloc`[[0,2],:] 选取第一行和第三行的数据
`df.iloc`[0:2,:] 选取第一行到第三行(不包含)的数据
`df.iloc`[:,1] 选取所有记录的第一列的值，返回的为一个Series
`df.iloc`[1,:] 选取第一行数据，返回的为一个Series
`df[df.Tcsj >= 18822256]` 单个逻辑条件
`df[(df.TCSJ >= 1354555)&(df.chhj < 1384454)]` 多个逻辑条件组合
这种方式获取的数据切片都是DataFrame
(5) 字典数据——将字典数据抽取为DataFrame，有三种方法：
1. 字典的key和value各作为一列
import pandas
from pandas import DataFrame
d1={\'a\':\'[1,2,3]\',\'b\':\'[0,1,2]\'}
a1=pandas.DataFrame.from_dict(d1,orient=\'index\')
# 将字典转化为dataframe, 且key列做成了index
a1.index.name = \'key\' #将index的列名改成\'key\'
b1=a1.reset_index() #重新增加index， 并将原index做成了\'key\'列[][]
b1.columns=[\'key\',\'value\'] #对列重新命名为\'key\'和\'value\'
b1
|
key |
value |
| 0 |
a |
[1,2,3] |
| 1 |
b |
[0,1,2] |
2. 字典里的每一个元素作为一列（同长）
d2={\'a\':[1,2,3],\'b\':[4,5,6]} # 字典的值必须长度相等
a2=DataFrame(d2)
a2
3. 字典里的每一个元素作为一列(不同长)
d={\'one\':pandas.Series([1,2,3]),\'two\':pandas.Series([1,2,3,4])}
d
{\'one\': 0 1
1 2
2 3
dtype: int64, \'two\': 0 1
1 2
2 3
3 4
dtype: int64}
d={\'one\':pandas.Series([1,2,3]),\'two\':pandas.Series([1,2,3,4])}
df=pandas.DataFrame(d)
df
|
one |
two |
| 0 |
1.0 |
1 |
| 1 |
2.0 |
2 |
| 2 |
3.0 |
3 |
| 3 |
NaN |
4 |
import numpy as np
import pandas as pd
from pandas import Series
from pandas import DataFrame
d=dict(A=np.array([1,2]),B=np.array([1,2,3,4]))
DataFrame(dict([(k,Series(v)) for k,v in d.items()]))
|
A |
B |
| 0 |
1.0 |
1 |
| 1 |
2.0 |
2 |
| 2 |
NaN |
3 |
| 3 |
NaN |
4 |
import numpy as np
import pandas as pd
my_dict = dict(A = np.array([1,2]),B = np.array([1,2,3,4]))
df = pd.DataFrame.from_dict(my_dict,orient=\'index\').T
df
|
A |
B |
| 0 |
1.0 |
1.0 |
| 1 |
2.0 |
2.0 |
| 2 |
NaN |
3.0 |
| 3 |
NaN |
4.0 |
排名索引
1. 排名排序
Series 的`sort_index(ascending=True)`方法可以对index进行操作，`ascending` 参数用于控制升序或降序，默认为升序。
在DataFrame上，`.sort_index(axis=0,by=None,ascending=True)`方法多了一个轴向的选择参数，以及一个by 参数的作用，是针对某一（些）列进行排序（不能对行使用by 参数）。
from pandas import DataFrame
df0={\'ohio\':[0,6,3],\'Texas\':[7,4,1],\'California\':[2,8,5]}
df=DataFrame(df0,index=[\'first\',\'second\',\'third\'])
df
|
California |
Texas |
ohio |
| first |
2 |
7 |
0 |
| second |
8 |
4 |
6 |
| third |
5 |
1 |
3 |
df.sort_index(by=\'ohio\')
C:\ProgramData\Anaconda3\lib\site-packages\ipykernel_launcher.py:1: FutureWarning: by argument to sort_index is deprecated, pls use .sort_values(by=...)
"""Entry point for launching an IPython kernel.
|
California |
Texas |
ohio |
| first |
2 |
7 |
0 |
| third |
5 |
1 |
3 |
| second |
8 |
4 |
6 |
df.sort_index(by=[\'California\',\'Texas\'])
C:\ProgramData\Anaconda3\lib\site-packages\ipykernel_launcher.py:1: FutureWarning: by argument to sort_index is deprecated, pls use .sort_values(by=...)
"""Entry point for launching an IPython kernel.
|
California |
Texas |
ohio |
| first |
2 |
7 |
0 |
| third |
5 |
1 |
3 |
| second |
8 |
4 |
6 |
df.sort_index(axis=1)
|
California |
Texas |
ohio |
| first |
2 |
7 |
0 |
| second |
8 |
4 |
6 |
| third |
5 |
1 |
3 |
2.重新索引
Series对象的重新索引通过其 `.reindex(index=None,**kwargs)`方法来实现。
`**kwargs`中常用的参数有两个: method=None 和 fill_value=np.NaN.
from pandas import Series
ser=Series([4.5,7.2,-5.3,3.6],index=[\'d\',\'b\',\'a\',\'c\'])
A = [\'a\',\'b\',\'c\',\'d\',\'e\']
ser.reindex(A)
a -5.3
b 7.2
c 3.6
d 4.5
e NaN
dtype: float64
ser.reindex(A,fill_value=0)
a -5.3
b 7.2
c 3.6
d 4.5
e 0.0
dtype: float64
ser.reindex(A,method=None)
a -5.3
b 7.2
c 3.6
d 4.5
e NaN
dtype: float64
数据合并
(1) 记录合并
是指两个结构相同的数据框合并成一个数据框，也就是在一个数据框中追加另一个数据框的数据记录：`concat([dataFrame1,dataFrame2,...])`
`dataFrame为数据框`，返回值DataFrame
import pandas as pd
from pandas import DataFrame
from pandas import read_excel
df1=read_excel(\'D://train.xlsx\',sheetname=\'Sheet1\')
df1
|
YHM |
TCSJ |
YWXT |
IP |
| 0 |
S1402048 |
18536982564 |
1.2220 |
221.23.32.25 |
| 1 |
S1411023 |
15832472596 |
1.5555 |
225.24.36.38 |
| 2 |
S1047259 |
15687955423 |
1.2550 |
22.45.28.5 |
| 3 |
S1255845 |
12598876542 |
NaN |
22.35.38.3 |
df2=read_excel(\'D://train.xlsx\',sheetname=\'Sheet2\')
df2
|
YHM |
TCSJ |
YWXT |
IP |
| 0 |
S1502048 |
187536982564 |
1.2200 |
231.23.32.24 |
| 1 |
S14511023 |
16832472596 |
1.4555 |
25.25.36.38 |
| 2 |
S1247259 |
15587955423 |
1.2350 |
22.45.28.5 |
| 3 |
S1555845 |
16598876542 |
NaN |
23.35.38.6 |
df=pd.concat([df1,df2])
df
|
YHM |
TCSJ |
YWXT |
IP |
| 0 |
S1502048 |
187536982564 |
1.2200 |
231.23.32.24 |
| 1 |
S14511023 |
16832472596 |
1.4555 |
25.25.36.38 |
| 2 |
S1247259 |
15587955423 |
1.2350 |
22.45.28.5 |
| 3 |
S1555845 |
16598876542 |
NaN |
23.35.38.6 |
| 0 |
S1502048 |
187536982564 |
1.2200 |
231.23.32.24 |
| 1 |
S14511023 |
16832472596 |
1.4555 |
25.25.36.38 |
| 2 |
S1247259 |
15587955423 |
1.2350 |
22.45.28.5 |
| 3 |
S1555845 |
16598876542 |
NaN |
23.35.38.6 |
(2)字段合并
指对同一个数据框中不同的列进行合并，形成新的列,如： X=x1+x2+... （x1为数据列1，x2为数据列2）
import pandas as pd
from pandas import DataFrame
from pandas import read_excel
df1=read_excel(\'D://train.xlsx\',sheetname=\'Sheet1\')
df1
|
YHM |
TCSJ |
YWXT |
IP |
| 0 |
S1402048 |
18536982564 |
1.2220 |
221.23.32.25 |
| 1 |
S1411023 |
15832472596 |
1.5555 |
225.24.36.38 |
| 2 |
S1047259 |
15687955423 |
1.2550 |
22.45.28.5 |
| 3 |
S1255845 |
12598876542 |
NaN |
22.35.38.3 |
(3) 字段匹配
是指不同结构的数据框（两个或两个以上的数据框），按照一定的条件进行合并，即追加列
`merge(x,y,left_on,right_on)` x是第一个数据框，y是第二个数据框，数据框left_on是第一个数据框的用于匹配的列，right_on是第二个数据框的用于匹配的列，返回值：DataFram
import pandas as pd
from pandas import DataFrame
from pandas import read_excel
df1=read_excel(\'D://train.xlsx\',sheetname=\'Sheet1\')
df1
|
YHM |
TCSJ |
YWXT |
IP |
| 0 |
S1402048 |
18536982564 |
1.2220 |
221.23.32.25 |
| 1 |
S1411023 |
15832472596 |
1.5555 |
225.24.36.38 |
| 2 |
S1047259 |
15687955423 |
1.2550 |
22.45.28.5 |
| 3 |
S1255845 |
12598876542 |
NaN |
22.35.38.3 |
df2=read_excel(\'D://train.xlsx\',sheetname=\'Sheet2\')
df2
|
YHM |
TCSJ |
YWXT |
IP |
| 0 |
S1502048 |
187536982564 |
1.2200 |
231.23.32.24 |
| 1 |
S14511023 |
16832472596 |
1.4555 |
25.25.36.38 |
| 2 |
S1247259 |
15587955423 |
1.2350 |
22.45.28.5 |
| 3 |
S1555845 |
16598876542 |
NaN |
23.35.38.6 |
pd.merge(df1,df2,left_on=\'YHM\',right_on=\'YHM\')
|
YHM |
TCSJ_x |
YWXT_x |
IP_x |
TCSJ_y |
YWXT_y |
IP_y |
import pandas as pd
from pandas import DataFrame
from pandas import read_excel
df=read_excel(\'D://train.xlsx\',sheetname=\'Sheet3\')
df
|
num |
price |
| 0 |
123 |
159 |
| 1 |
124 |
753 |
| 2 |
125 |
456 |
| 3 |
126 |
852 |
result=df[\'num\']*df[\'price\']##或者写为 result=df.num*df.price
result
0 19557
1 93372
2 57000
3 107352
dtype: int64
df[\'result\']=result
df
|
num |
price |
result |
| 0 |
123 |
159 |
19557 |
| 1 |
124 |
753 |
93372 |
| 2 |
125 |
456 |
57000 |
| 3 |
126 |
852 |
107352 |
(2) 数据标准化
指数据按照比例缩放，使之落入特定的区间，一般使用0-1的区间来标准化
`X*=(x-min)/(max-min)`
import pandas as pd
from pandas import DataFrame
from pandas import read_excel
df=read_excel(\'D://train.xlsx\',sheetname=\'Sheet3\')
df
|
num |
price |
| 0 |
123 |
159 |
| 1 |
124 |
753 |
| 2 |
125 |
456 |
| 3 |
126 |
852 |
scale=(df.price-df.price.min())/(df.price.max()-df.price.min())
scale
0 0.000000
1 0.857143
2 0.428571
3 1.000000
Name: price, dtype: float64
数据分组
- 指根据数据分析对象的特征，按照一定的数据指标，把数据划分为不同的区间来进行研究，以揭示其内在的联系和规律性，简单的说，就是新增一列，将原来的数据按照其性质归入到新的类别中，数据分组的语法如下：
`cut(series,bins,right=True,label=NULL)`
series 为需要分组的数据， bins为分组的依据数据
right 为分组的时候右边是否闭合 labels 为分组的自定义标签，可以不自定义
import pandas as pd
from pandas import DataFrame
from pandas import read_excel
df=read_excel(\'D://train.xlsx\',sheetname=\'Sheet4\')
df
|
序号 |
品牌 |
数据 |
价格 |
date |
| 0 |
1 |
130 |
123 |
159 |
2016-06-01 |
| 1 |
2 |
131 |
124 |
753 |
2016-06-02 |
| 2 |
3 |
132 |
125 |
456 |
2016-06-03 |
| 3 |
4 |
133 |
126 |
852 |
2016-06-04 |
bins=[min(df.价格)-1,500,max(df.价格)+1]
labels=["500以下","500以上"]
pd.cut(df.价格,bins)
0 (158, 500]
1 (500, 853]
2 (158, 500]
3 (500, 853]
Name: 价格, dtype: category
Categories (2, interval[int64]): [(158, 500] < (500, 853]]
pd.cut(df.价格,bins,right=False)
0 [158, 500)
1 [500, 853)
2 [158, 500)
3 [500, 853)
Name: 价格, dtype: category
Categories (2, interval[int64]): [[158, 500) < [500, 853)]
pa=pd.cut(df.价格,bins,right=False,labels=labels)
pa
0 500以下
1 500以上
2 500以下
3 500以上
Name: 价格, dtype: category
Categories (2, object): [500以上 < 500以下]
df[\'类别\']=pa
df
|
序号 |
品牌 |
数据 |
价格 |
类别 |
| 0 |
1 |
130 |
123 |
159 |
500以下 |
| 1 |
2 |
131 |
124 |
753 |
500以上 |
| 2 |
3 |
132 |
125 |
456 |
500以下 |
| 3 |
4 |
133 |
126 |
852 |
500以上 |
日期处理
(1) 日期转换
指将字符型的日期格式转换为日期格式数据的过程 `to_datetime(dateString,format)`
`format` 格式有：%Y：年份， %m：月份， %d: 日期， %H：小时， %M:分钟， %S:秒。
from pandas import read_excel
from pandas import to_datetime
df=read_excel(\'D://train.xlsx\',sheetname=\'Sheet4\')#,seq=\',\',encoding=\'utf8\')
df
|
序号 |
品牌 |
数据 |
价格 |
date |
| 0 |
1 |
130 |
123 |
159 |
2016-06-01 |
| 1 |
2 |
131 |
124 |
753 |
2016-06-02 |
| 2 |
3 |
132 |
125 |
456 |
2016-06-03 |
| 3 |
4 |
133 |
126 |
852 |
2016-06-04 |
df_dt=to_datetime(df.date,format="%Y%m%d")
df_dt
0 2016-06-01
1 2016-06-02
2 2016-06-03
3 2016-06-04
Name: date, dtype: datetime64[ns]
import numpy
import pandas
from pandas import read_excel
from pandas import to_datetime
df=read_excel(\'D://train.xlsx\',sheetname=\'Sheet4\')#,seq=\',\',encoding=\'utf8\')
df
|
序号 |
品牌 |
数据 |
价格 |
date |
| 0 |
1 |
130 |
123 |
159 |
2016-06-01 |
| 1 |
2 |
131 |
124 |
753 |
2016-06-02 |
| 2 |
3 |
132 |
125 |
456 |
2016-06-03 |
| 3 |
4 |
133 |
126 |
852 |
2016-06-04 |
df[\'品牌\'].corr(df[\'价格\'])## 两列之间的相关度计算
0.73484692283495334
df.loc[:,[\'品牌\',\'数据\',\'价格\']].corr()##多列之间的相关度计算
|
品牌 |
数据 |
价格 |
| 品牌 |
1.000000 |
1.000000 |
0.734847 |
| 数据 |
1.000000 |
1.000000 |
0.734847 |
| 价格 |
0.734847 |
0.734847 |
1.000000 |
相关性程度
|相关系数|r|取值范围|相关程度|
|:--