目录
[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 元素过滤
可直接使用基于值的比较运算条件产生的布尔型数组进行过滤。
df1>2
Out[272]:
a b
0 True False
1 True False
2 True False
3 True True
df1[df1>2]
Out[273]:
a b
0 55 NaN
1 55 NaN
2 55 NaN
3 55 3.0
3 元素新增
- 3.1 方法1：通过赋值新增
df1['c']=20
df1
Out[275]:
a b c
0 55 0 20
1 55 1 20
2 55 2 20
3 55 3 20
- 3.2 方法2：通过索引重排新增
df1=df1.reindex(index=[0,1,2,3,4])
df1
Out[277]:
a b c
0 55.0 0.0 20.0
1 55.0 1.0 20.0
2 55.0 2.0 20.0
3 55.0 3.0 20.0
4 NaN NaN NaN
4 元素删除
使用drop方法通过删除指定索引来删除元素。
通过axis参数确定是删除行还是删除列，默认删除行。
- 4.1 一次删除一行/列
df1.drop(1)
Out[280]:
a b c
0 55.0 0.0 20.0
2 55.0 2.0 20.0
3 55.0 3.0 20.0
4 NaN NaN NaN
- 4.2 一次删除多行/列
df1.drop(['a','c'],axis=1)
Out[281]:
b
0 0.0
1 1.0
2 2.0
3 3.0
4 NaN
5 算术运算
DataFrame对象支持直接进行算术运算。
df2+2
Out[283]:
a b
1 13.0 113
2 24.0 224
3 35.0 335
4 NaN 446
6 判断是否有空值
使用isnull或者notnull方法判断是否有空值，返回一个布尔型DataFrame对象。
df1.isnull()
Out[297]:
a b c
0 False False False
1 False False False
2 False False False
3 False False False
4 True True True
df1.notnull()
Out[298]:
a b c
0 True True True
1 True True True
2 True True True
3 True True True
4 False False False
7 缺失值处理
缺失值的处理主要有两种方法：填充和过滤。
- 7.1 填充
使用fillna方法进行空值填充，该方法产生新对象，不会修改原对象。
df2=df2.reindex(index=[1,2,3,4,5])
df2
Out[304]:
a b
1 11.0 111.0
2 22.0 222.0
3 33.0 333.0
4 NaN 444.0
5 NaN NaN
df2.fillna(99)
Out[308]:
a b
1 11.0 111.0
2 22.0 222.0
3 33.0 333.0
4 99.0 444.0
5 99.0 99.0
- 7.2 过滤
使用dropna方法进行空值过滤，该方法产生新对象，不会修改原对象。
axis参数确定过滤行还是过滤列，默认axis=0过滤行，axis=1过滤列。
how参数控制过滤标准（有空值就丢弃（any）、全空值才丢弃（all）），默认过滤任何含有缺失值的行/列。
df2.dropna()
Out[305]:
a b
1 11.0 111.0
2 22.0 222.0
3 33.0 333.0
df2.dropna(axis=1)
Out[306]:
Empty DataFrame
Columns: []
Index: [1, 2, 3, 4, 5]
df2.dropna(how='all')
Out[307]:
a b
1 11.0 111.0
2 22.0 222.0
3 33.0 333.0
4 NaN 444.0
8 过滤重复值
使用duplicated方法返回布尔型Series对象，判断哪些行是重复值。
df1
Out[317]:
a b c
0 55.0 0.0 20.0
1 55.0 1.0 20.0
2 55.0 2.0 20.0
3 55.0 3.0 20.0
4 NaN NaN NaN
df1.duplicated()
Out[318]:
0 False
1 False
2 False
3 False
4 False
dtype: bool
使用drop_duplicates方法过滤其中的重复行，不修改原对象，而是产生一个没有重复行的新DataFrame对象。
df1.drop_duplicates()
Out[320]:
a b c
0 55.0 0.0 20.0
1 55.0 1.0 20.0
2 55.0 2.0 20.0
3 55.0 3.0 20.0
4 NaN NaN NaN
默认判断全部列，即所有列都相同才叫重复，也可以指定要判断的一列或者多列（通过传入一个列表）。
df1.duplicated(['a','c'])
Out[319]:
0 False
1 True
2 True
3 True
4 False
dtype: bool
df1.drop_duplicates(['a','c'])
Out[321]:
a b c
0 55.0 0.0 20.0
4 NaN NaN NaN
9 汇总统计
常规的统计方法：sum（求和）、mean（均值）、cumsum（累计求和）、count（非空计数），按列进行汇总。
df1.sum()
Out[322]:
a 220.0
b 6.0
c 80.0
dtype: float64
df1.mean()
Out[324]:
a 55.0
b 1.5
c 20.0
dtype: float64
df1.cumsum()
Out[325]:
a b c
0 55.0 0.0 20.0
1 110.0 1.0 40.0
2 165.0 3.0 60.0
3 220.0 6.0 80.0
4 NaN NaN NaN
df1.count()
Out[323]:
a 4
b 4
c 4
dtype: int64
使用describe方法直接生成描述性统计结果。
- 9.1 数值型
当元素的数据类型为数值型时，生成的结果包括：均值、最大值、最小值、标准差、元素个数、百分位数。
df1.describe()
Out[326]:
a b c
count 4.0 4.000000 4.0
mean 55.0 1.500000 20.0
std 0.0 1.290994 0.0
min 55.0 0.000000 20.0
25% 55.0 0.750000 20.0
50% 55.0 1.500000 20.0
75% 55.0 2.250000 20.0
max 55.0 3.000000 20.0
- 9.2 类别型
当元素的数据类型为类别型时，生成的结果包括：唯一值个数、最大类别、最大类别频数。
df5=pd.DataFrame({'a':['s','t','y','r'],'b':['w','x','y','z']})
df5
Out[330]:
a b
0 s w
1 t x
2 y y
3 r z
df5.describe()
Out[331]:
a b
count 4 4
unique 4 4
top t w
freq 1 1
10 分组聚合
使用groupby方法产生一个GroupBy对象，然后使用聚合函数（mean、sum等）进行聚合计算。
groupby方法中传入划分组的一列或者多列。
df1.groupby('a').sum()
Out[337]:
b c
a
55.0 6.0 80.0
2.1.0.4 DataFrame对象之间的操作
1 算术运算
通过+、-、*、\等运算符或者add、sub、mul、div等方法进行两个DataFrame对象之间的算术运算。
运算时，行、列索引同时对齐，对应元素进行算术运算，没有重叠的位置，运算结果为NaN。
df1
Out[338]:
a b c
0 55.0 0.0 20.0
1 55.0 1.0 20.0
2 55.0 2.0 20.0
3 55.0 3.0 20.0
4 NaN NaN NaN
df2
Out[339]:
a b
1 11.0 111.0
2 22.0 222.0
3 33.0 333.0
4 NaN 444.0
5 NaN NaN
df1+df2
Out[340]:
a b c
0 NaN NaN NaN
1 66.0 112.0 NaN
2 77.0 224.0 NaN
3 88.0 336.0 NaN
4 NaN NaN NaN
5 NaN NaN NaN
df1.add(df2)
Out[341]:
a b c
0 NaN NaN NaN
1 66.0 112.0 NaN
2 77.0 224.0 NaN
3 88.0 336.0 NaN
4 NaN NaN NaN
5 NaN NaN NaN
在使用上述方法进行算术运算时，可以使用fill_value参数进行空值填充，会先填充后进行算术运算。
df1.add(df2,fill_value=0)
Out[343]:
a b c
0 55.0 0.0 20.0
1 66.0 112.0 20.0
2 77.0 224.0 20.0
3 88.0 336.0 20.0
4 NaN 444.0 NaN
5 NaN NaN NaN
2 关联操作
使用pd.merge方法对两个DataFrame对象进行关联操作，本质上与两张数据库的二维表的join操作效果相同。
df6=pd.DataFrame({'a':{1:11,2:22,3:33},'b':{1:111,2:222,3:333},'c':{1:11,3:33,5:55}})
df6
Out[347]:
a b c
1 11.0 111.0 11.0
2 22.0 222.0 NaN
3 33.0 333.0 33.0
5 NaN NaN 55.0
df7=pd.DataFrame({'b':{1:111,2:444,3:333},'c':{1:11,2:44,3:33}})
df7
Out[348]:
b c
1 111 11
2 444 44
3 333 33
pd.merge(df6,df7,on='b')
Out[349]:
a b c_x c_y
0 11.0 111.0 11.0 11
1 33.0 333.0 33.0 33
- 2.1 how参数
决定关联方式，how='inner'相当于inner join，这是默认情况；how='left'相当于left join；how='right'相当于right join；how='outer'相当于cross join。
pd.merge(df6,df7,on='b',how='left')
Out[350]:
a b c_x c_y
0 11.0 111.0 11.0 11.0
1 22.0 222.0 NaN NaN
2 33.0 333.0 33.0 33.0
3 NaN NaN 55.0 NaN
- 2.2 on参数
决定关联条件。当两个DataFrame对象的关联列名相同时，使用on参数指定；当两个DataFrame对象的关联列名不同时，则使用left_on和right_on参数分别指定。
pd.merge(df6,df7,left_on='a',right_on='c')
Out[352]:
a b_x c_x b_y c_y
0 11.0 111.0 11.0 111 11
1 33.0 333.0 33.0 333 33
- 2.3 right_index参数
取值为True代表右侧DataFrame的行索引作为连接键参与连接。 - 2.4 left_index参数 取值为True代表左侧DataFrame的行索引作为连接键参与连接。
pd.merge(df6,df7,left_on='a',right_index=True,how='left')
Out[354]:
a b_x c_x b_y c_y
1 11.0 111.0 11.0 NaN NaN
2 22.0 222.0 NaN NaN NaN
3 33.0 333.0 33.0 NaN NaN
5 NaN NaN 55.0 NaN NaN
pd.merge(df6,df7,left_index=True,right_index=True)
Out[355]:
a b_x c_x b_y c_y
1 11.0 111.0 11.0 111 11
2 22.0 222.0 NaN 444 44
3 33.0 333.0 33.0 333 33
2.1.0.5 DataFrame对象与Series对象之间的操作
1 算术运算
通过+、-、*、\等运算符或者add、sub、mul、div等方法进行DataFrame对象和Series对象之间的算术运算。
默认将Series的索引匹配DataFrame的列索引，然后沿着行一直向下传播。
df8=pd.DataFrame({'a':{1:100,2:200,3:300},'b':{1:200,2:300,3:400},'c':{1:300,2:400,3:500}})
df8
Out[360]:
a b c
1 100 200 300
2 200 300 400
3 300 400 500
ser1=pd.Series([100,200,300],index=['a','b','c'])
ser1
Out[361]:
a 100
b 200
c 300
dtype: int64
df8-ser1
Out[362]:
a b c
1 0 0 0
2 100 100 100
3 200 200 200
df8.sub(ser1)
Out[363]:
a b c
1 0 0 0
2 100 100 100
3 200 200 200
使用上述方法时，可以使用axis参数来设定二者索引的匹配方向，是按行索引匹配（axis=0），还是按列索引匹配（axis=1，默认）。索引没有对齐的元素，运算结果为NaN。
df8.sub(ser1,axis=1)
Out[364]:
a b c
1 0 0 0
2 100 100 100
3 200 200 200
df8.sub(ser1,axis=0)
Out[365]:
a b c
1 NaN NaN NaN
2 NaN NaN NaN
3 NaN NaN NaN
a NaN NaN NaN
b NaN NaN NaN
c NaN NaN NaN
ser2=df8['a']
ser2
Out[368]:
1 100
2 200
3 300
Name: a, dtype: int64
df8.sub(ser2,axis=0)
Out[369]:
a b c
1 0 100 200
2 0 100 200
3 0 100 200
参考来源 http://www.cnblogs.com/hbsygfz/p/8880456.html
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.1.6 数据选取
2.1.6.1 []
只能对行进 行（row/index） 切片，前闭后开df[0:3]，df[:4]，df[4:]
2.1.6.2 where 布尔查找
df[df["A"]>7]
2.1.6.3 isin/isna
# 返回布尔值
s.isin([1,2,3])
df['A'].isin([1,2,3])
df.loc[df['A'].isin([5.8,5.1])]选取列A中值为5.8，5.1的所有行组成dataframe
# 返回布尔值
s.isna()
df['A'].isna()
df.loc[df['A'].isna()]选取列A中值为Nan所有行组成dataframe
2.1.6.3 query
df.query(" A>5.0 & (B>3.5 | C<1.0) ")
2.1.6.4 loc ：根据名称Label切片
# df.loc[A,B] A是行范围，B是列范围
df.loc[1:4,['petal_length','petal_width']]
# 需求1：创建一个新的变量 test
# 如果sepal_length > 3 test = 1 否则 test = 0
df.loc[df['sepal_length'] > 6, 'test'] = 1
df.loc[df['sepal_length'] <=6, 'test'] = 0
# 需求2：创建一个新变量test2
# 1.petal_length>2 and petal_width>0.3 = 1
# 2.sepeal_length>6 and sepal_width>3 = 2 3.其他 = 0
df['test2'] = 0
df.loc[(df['petal_length']>2)&(df['petal_width']>0.3), 'test2'] = 1
df.loc[(df['sepal_length']>6)&(df['sepal_width']>3), 'test2'] = 2
2.1.6.5 iloc：切位置
df.iloc[1:4,:]
2.1.6.6 ix：混切
名称和位置混切，但效率低，少用
df1.ix[0:3,['sepal_length','petal_width']]
2.1.6.7 map与lambda
alist = [1,2,3,4]
map(lambda s : s+1, alist)#map就是将自定义函数应用于Series每个元素
df['sepal_length'].map(lambda s:s*2+1)[0:3]
2.1.6.8 apply和applymap
apply和applymap是对dataframe的操作，前者操作一行或者一列，后者操作每个元素
These are techniques to apply function to element, column or dataframe.
Map: It iterates over each element of a series.
df[‘column1’].map(lambda x: 10+x), this will add 10 to each element of column1.
df[‘column2’].map(lambda x: ‘AV’+x), this will concatenate “AV“ at the beginning of each element of column2 (column format is string).
Apply: As the name suggests, applies a function along any axis of the DataFrame.
df[[‘column1’,’column2’]].apply(sum), it will returns the sum of all the values of column1 and column2.
df0[['data1']].apply(lambda s:s+1)
ApplyMap: 对dataframe的每一个元素施加一个函数
func = lambda x: x+2
df.applymap(func), dataframe每个元素加2 (所有列必须数字类型)
2.1.6.9 contains
# 使用DataFrame模糊筛选数据(类似SQL中的LIKE)
# 使用正则表达式进行模糊匹配,*匹配0或无限次,?匹配0或1次
df_obj[df_obj['套餐'].str.contains(r'.*?语音CDMA.*')]
# 下面两句效果一致
df[df['商品名称'].str.contains("四件套")]
df[df['商品名称'].str.contains(r".*四件套.*")]
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)
3 Python基础
3.1 元祖
Python的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
如下实例：
tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"
创建空元组
tup1 = ()
元组中只包含一个元素时，需要在元素后面添加逗号
tup1 = (50,)
元组与字符串类似，下标索引从0开始，可以进行截取，组合等。
3.1.1 访问元祖
元组可以使用下标索引来访问元组中的值，如下实例:
tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print "tup1[0]: ", tup1[0]
print "tup2[1:5]: ", tup2[1:5]
以上实例输出结果：
tup1[0]: physics
tup2[1:5]: (2, 3, 4, 5)
3.1.2 修改元组
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
# 创建一个新的元组
tup3 = tup1 + tup2
print tup3
