目录
[TOC]
正文
1 FUNCTION
1.1 lambda
f = lambda x:pow(x,2)
print(f(2))
表示f是一个参数为x，并计算x的2次方的函数
输出结果为：4
1.2 str 字符串
1.2.1 截取字符串
a1 = '12345678'
a2 = str(a1)[:1]
a3 = str(a1)[:4]
a4 = str(a1)[3:]
a5 = str(a1)[2:5]
print(a2)
print(a3)
print(a4)
print(a5)
a2 = 截取a1第0位至第1位（不包含）
a3 = 截取a1第0位至第4位（不包含）
a4 = 截取a1第3位至最后（包含）
a5 = 截取a1第2位至第5位（不包含）
输出结果如下：
1
1234
45678
345
2 PANDAS
2.1 DATAFRAME
2.1.0 DATAFRAME 介绍
2.1.0.1 DATAFRAME 创建
（1）方法1：通过等长列表组成的字典创建
df1 = pd.DataFrame({'a':[1,2,3,4],'b':['w','x','y','z']})
df1
Out[205]:
a b
0 1 w
1 2 x
2 3 y
3 4 z
（2）方法2：通过嵌套字典创建
外层字典的键作为列索引，内层字典的键作为行索引。
df2 = pd.DataFrame({'a':{1:11,2:22,3:33},'b':{1:111,2:222,3:333,4:444}})
df2
Out[206]:
a b
1 11.0 111
2 22.0 222
3 33.0 333
4 NaN 444
（3）方法3：通过numpy数组创建
注意传入DataFrame对象的形状。
df3 = pd.DataFrame(np.arange(12).reshape(4,3))
df3
Out[211]:
0 1 2
0 0 1 2
1 3 4 5
2 6 7 8
3 9 10 11
2.1.0.2 DATAFRAME 五个主要属性
DataFrame对象的五个主要属性：索引、值、名称、数据类型、形状。
- 索引 INDEX
- 1.1 索引的查看
行索引使用index属性，列索引使用columns属性，返回Index对象。
df1.index
Out[212]: RangeIndex(start=0, stop=4, step=1)
df1.columns
Out[213]: Index([u'a', u'b'], dtype='object')
索引可以有重复的，判断是否有重复索引，使用Index对象的is_unique属性判断。
df1.index.is_unique
Out[215]: True
- 1.2 索引的修改
索引对象是一个不可变数组，不能修改其中的值。
df1.index[1]=5
Traceback (most recent call last):
File "<ipython-input-217-360108374774>", line 1, in <module>
df1.index[1]=5
File "/usr/local/share/anaconda2/lib/python2.7/site-packages/pandas/indexes/base.py", line 1404, in __setitem__
raise TypeError("Index does not support mutable operations")
TypeError: Index does not support mutable operations
如果想修改索引，只能将其重定向到一个新的索引对象。
df1.index=[5,6,7,8]
df1
Out[221]:
a b
5 1 w
6 2 x
7 3 y
8 4 z
- 1.3 索引的重排
使用reindex方法进行索引重排。通过index参数或者columns参数来区分是对行索引重排还是对列索引重排。重排产生一个新DataFrame对象。
df1.reindex(index=[6,8,5,7])
Out[222]:
a b
6 2 x
8 4 z
5 1 w
7 3 y
df1.reindex(columns=['b','a'])
Out[223]:
b a
5 w 1
6 x 2
7 y 3
8 z 4
可同时进行行、列索引的重排。
df1.reindex(index=[6,8,5,7],columns=['b','a'])
Out[224]:
b a
6 x 2
8 z 4
5 w 1
7 y 3
索引重排可实现3个目的：
① 对现有索引进行顺序指定，即重新排列原来的元素顺序；
② 删除某个旧索引，即删除对应元素；
df1.reindex(index=[6,8,7])
Out[225]:
a b
6 2 x
8 4 z
7 3 y
③ 增加某个新索引，即增加新元素，值为NaN。
df1.reindex(index=[6,8,5,7,9])
Out[226]:
a b
6 2.0 x
8 4.0 z
5 1.0 w
7 3.0 y
9 NaN NaN
- 1.4 索引的重排
使用sort_index方法根据索引进行升序、降序排列。
axis参数指定排序的方向：行内排序\列内排序。默认axis=0，列内排序；axis=1，行内排序。
df4 = pd.DataFrame({'c':[11,33,22,44],'b':['w','x','y','z'],'a':[1,2,3,4]},index=[3,5,2,1],columns=['b','c','a'])
df4
Out[229]:
b c a
3 w 11 1
5 x 33 2
2 y 22 3
1 z 44 4
df4.sort_index()
Out[231]:
b c a
1 z 44 4
2 y 22 3
3 w 11 1
5 x 33 2
df4.sort_index(axis=1)
Out[232]:
a b c
3 1 w 11
5 2 x 33
2 3 y 22
1 4 z 44
ascending参数指定升降序，取值为True或False，默认为True，升序排列。
- 1.5 索引是否存在
使用in判断某索引是否存在。
2 in df1['b']
Out[292]: True
- 值
- 2.1 值的查看
通过DataFrame对象的values属性获取元素的值，返回一个Numpy数组。
df1.values
Out[233]:
array([[1, 'w'],
[2, 'x'],
[3, 'y'],
[4, 'z']], dtype=object)
- 2.2 值的修改
无法通过赋值对某一个元素进行取值就改。
只能对一行或者一列进行修改。
df1['a']=55
df1['b']=range(4)
df1
Out[245]:
a b
0 55 0
1 55 1
2 55 2
3 55 3
- 2.3 值的排序
使用sort_values方法根据值进行升序、降序排列。
by参数指定排序的行\列索引名，可按照多个索引进行排序，传入列表即可，索引顺序即为排序优先级。
df4.sort_values(by='c')
Out[250]:
b c a
3 w 11 1
2 y 22 3
5 x 33 2
1 z 44 4
df4.sort_values(by=['c','a'])
Out[251]:
b c a
3 w 11 1
2 y 22 3
5 x 33 2
1 z 44 4
==axis参数指定排序的方向：行内排序\列内排序，默认axis=0，列内排序，axis=1，行内排序。== 代码有问题！！！
= 代码有问题！！！：
df4.sort_values(by=3,axis=1)
Out[252]:
a c b
3 1 11 w
5 2 33 x
2 3 22 y
1 4 44 z
ascending参数指定升降序，取值为True或False，默认为True，升序排列。
- 2.4 值的排名
使用rank方法，对于并列排名，默认取其均值。
df4.rank()
Out[253]:
b c a
3 1.0 1.0 1.0
5 2.0 3.0 2.0
2 3.0 2.0 3.0
1 4.0 4.0 4.0
可通过设置axis参数，指定排名方向，默认列内排名，即axis=0，axis=1，行内排名。
==代码有问题！！！==
df4.rank(axis=1)
Out[254]:
b c a
3 3.0 2.0 1.0
5 3.0 2.0 1.0
2 3.0 2.0 1.0
1 3.0 2.0 1.0
ascending参数指定升降序，取值为True或False，默认为True，升序排列。
- 2.6 值是否存在
使用isin方法判断，要求传入一个列表，返回一个布尔型Series对象。
df1['b'].isin([2])
Out[294]:
0 False
1 False
2 True
3 False
4 False
Name: b, dtype: bool
-
名称
DataFrame对象的索引对象有名称属性。
但是DataFrame对象没有名称属性。 -
数据类型
通过dtypes属性获取DataFrame对象每列的数据类型。 -
形状
通过shape属性获取DataFrame对象的形状，返回值为一个元组。
df4.shape
Out[258]: (4, 3)
2.1.0.3 元素的操作
1 元素的选取
- 1.1 选取行
选取一行：
① 按索引名称选取：使用loc[索引名称]
df4.loc[1]
Out[261]:
b z
c 44
a 4
Name: 1, dtype: object
② 按索引位置序号选取：使用iloc[索引位置序号]
df4.iloc[1]
Out[262]:
b x
c 33
a 2
Name: 5, dtype: object
选取多行：
① 按索引名称（列表）选取：使用loc[索引名称列表]
df4.loc[[1,3]]
Out[263]:
b c a
1 z 44 4
3 w 11 1
② 按索引位置序号（切片）选取：使用iloc[索引位置序号切片]
df4.iloc[1:3]
Out[265]:
b c a
5 x 33 2
2 y 22 3
- 1.2 选取列
选取一列：
直接使用索引名称。
df4['a']
Out[267]:
3 1
5 2
2 3
1 4
Name: a, dtype: int64
选取多列：
直接使用索引名称组成的列表。
df4[['a','b']]
Out[268]:
a b
3 1 w
5 2 x
2 3 y
1 4 z
- 1.3 同时选取行和列
① 按索引名称选取：使用loc[行索引名称列表，列索引名称列表]。
df4.loc[[1,3],['a','b']]
Out[269]:
a b
1 4 z
3 1 w
② 按索引位置序号选取：使用iloc[行索引位置序号切片，列索引位置序号切片]
df4.iloc[1:3,0:1]
Out[270]:
b
5 x
2 y
2 元素过滤
- 2.1 方法1：通过赋值新增
- 2.2 方法2：通过索引重排新增
3 元素新增
4 元素删除
5 算术运算
6 判断是否有空值
7 缺失值处理
8 过滤重复值
9 汇总统计
10 分组聚合
2.1.0.4 DataFrame对象之间的操作
1 算术运算
2 关联操作
2.1.0.5 DataFrame对象与Series对象之间的操作
1 算术运算
2.1.1 APPLY
2.1.2 loc/iloc
loc
loc[],中括号里面是先行后列，以逗号分割，行和列分别是行标签和列标签
import pandas as pd
data = pd.DataFrame({'A':[1,2,3],'B':[4,5,6],'C':[7,8,9]},index=["a","b","c"])
data
A B C
a 1 4 7
b 2 5 8
c 3 6 9
比如我要得到数字5，那么就就是：
data.loc["b","B"]
上面只是选择某一个值，那么如果我要选择一个区域呢，比如我要选择5，8，6，9，那么可以这样做：
data.loc['b':'c','B':'C']
注意：区间前闭后闭
df.loc[df['车牌的市_2'] == df['市级名称_2'],'异地投保']=0
==以上用法待学习==
iloc
.iloc[]与loc一样，中括号里面也是先行后列，行列标签用逗号分割，与loc不同的之处是，.iloc是根据行数与列数来索引的，比如上面提到的得到数字5，那么用iloc来表示就是(因为5是第2行第2列，注意索引从0开始的):
data.iloc[1,1]
比如我要选择5，8，6，9，那么用,iloc来选择就是:
data.iloc[1:3,1:3]
注意：区间前闭后开
2.1.3 drop_duplicates：去除重复项
DataFrame.drop_duplicates(subset=None, keep='first', inplace=False)
subset : column label or sequence of labels, optional
用来指定特定的列，默认所有列
keep : {‘first’, ‘last’, False}, default ‘first’
删除重复项并保留第一次出现的项
inplace : boolean, default False
是直接在原来数据上修改还是保留一个副本
import pandas as pd
data= pd.DataFrame({'A':[1,1,2,2],'B':['a','b','a','b']})
print (data)
data_unique = data.drop_duplicates('B','first',False)
print (data_unique)
输出：
A B
0 1 a
1 1 b
2 2 a
3 2 b
A B
0 1 a
1 1 b
2.1.4 fillna 填充缺失数据
import pandas as pd
import numpy as np
from numpy import nan as NaN
df1=pd.DataFrame([[1,2,3],[NaN,NaN,2],[NaN,NaN,NaN],[8,8,NaN]])
print(df1)
输出：
0 1 2
0 1.0 2.0 3.0
1 NaN NaN 2.0
2 NaN NaN NaN
3 8.0 8.0 NaN
常数0填充NaN（支持inplace）：
df1.fillna(0)
输出：
0 1 2
0 1.0 2.0 3.0
1 0.0 0.0 2.0
2 0.0 0.0 0.0
3 8.0 8.0 0.0
按字典填充指定常数：
df1.fillna({0:10,1:20,2:30})
输出：
0 1 2
0 1.0 2.0 3.0
1 10.0 20.0 2.0
2 10.0 20.0 30.0
3 8.0 8.0 30.0
2.1.5 drop
DataFrame.drop(labels=None,axis=0, index=None, columns=None, inplace=False)
在这里默认：axis=0，指删除index（行），因此删除columns时要指定axis=1（列）；
inplace=False，默认该删除操作不改变原数据，而是返回一个执行删除操作后的新dataframe；
inplace=True，则会直接在原数据上进行删除操作，删除后就回不来了。
>>>df = pd.DataFrame(np.arange(12).reshape(3,4), columns=['A', 'B', 'C', 'D'])
>>>df
A B C D
0 0 1 2 3
1 4 5 6 7
2 8 9 10 11
#Drop columns,下面两种方法等价
>>>df.drop(['B', 'C'], axis=1)
A D
0 0 3
1 4 7
2 8 11
>>>df.drop(columns=['B', 'C'])
A D
0 0 3
1 4 7
2 8 11
#Drop rows by index
>>>df.drop([0, 1])
A B C D
2 8 9 10 11
2.2 merge
Definition : merge(left, right, how='inner', on=None,
left_on=None, right_on=None, left_index=False,
right_index=False, sort=False, suffixes=('_x', '_y'),
copy=True, indicator=False, validate=None)
