python数据分析

python 数据分析基础（小白的辛酸史）

1 常用的内置函数

`sum`

sum([1,2,3])

a=range(1,11)
b=range(1,10)
c=sum([item for item in a if item in b])
print(c)

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')

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]

	age
0	21
1	22

df1.drop('age',axis=1)  #axis=1表示列轴，不可省略

	name
0	KEN
1	John
2	JIMI

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	B
0	1	2
1	3	4

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列的数据

b. 使用切片位置选取数据：

`df.iloc[行位置，列位置]` 如：
`df.iloc`[1,1]       选取第二行，第二列的值，返回的是单个值
`df.iloc`[[0,2],:]   选取第一行和第三行的数据
`df.iloc`[0:2,:]     选取第一行到第三行(不包含)的数据
`df.iloc`[:,1]       选取所有记录的第一列的值，返回的为一个Series
`df.iloc`[1,:]       选取第一行数据，返回的为一个Series

c. 通过逻辑指针进行数据切片 df[逻辑条件]

`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

	a	b
0	1	4
1	2	5
2	3	6

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

LouieZhang

python数据分析

python 数据分析基础（小白的辛酸史）

1 常用的内置函数

zip

enumerate

eval

pandas

Dataframe

数据导入

导入MySQL库

数据导出

数据处理

1.重复值的处理

2.缺失值处理

数据抽取

(1) 字段抽取—抽出某列上指定位置的数据，做成新的列；

(2) 字段拆分—按指定的字符sep,拆分已有的字符串；

(3) 记录抽取

(4) 随机抽样

(5) 字典数据——将字典数据抽取为DataFrame，有三种方法：

1. 字典的key和value各作为一列

2. 字典里的每一个元素作为一列（同长）

3. 字典里的每一个元素作为一列(不同长)

排名索引

1. 排名排序

2.重新索引

数据合并

数据分组

日期处理

相关性程度

公告

LouieZhang

python数据分析

python 数据分析基础 （小白的辛酸史）

1 常用的内置函数

zip

enumerate

eval

pandas

Dataframe

数据导入

导入MySQL库

数据导出

数据处理

1.重复值的处理

2.缺失值处理

数据抽取

(1) 字段抽取—抽出某列上指定位置的数据，做成新的列；

(2) 字段拆分—按指定的字符sep,拆分已有的字符串；

(3) 记录抽取

(4) 随机抽样

(5) 字典数据——将字典数据抽取为DataFrame，有三种方法：

1. 字典的key和value各作为一列

2. 字典里的每一个元素作为一列（同长）

3. 字典里的每一个元素作为一列(不同长)

排名索引

1. 排名排序

2.重新索引

数据合并

数据分组

日期处理

相关性程度

公告

python 数据分析基础（小白的辛酸史）