正文

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位（不包含）
输出结果如下：

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 "", line 1, in 
    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)

输出：

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

Python学习

目录

正文

1 FUNCTION

1.1 lambda

1.2 str 字符串

1.2.1 截取字符串

2 PANDAS

2.1 DATAFRAME

2.1.0 DATAFRAME 介绍

2.1.0.1 DATAFRAME 创建

2.1.0.2 DATAFRAME 五个主要属性

2.1.0.3 元素的操作

2.1.0.4 DataFrame对象之间的操作

2.1.0.5 DataFrame对象与Series对象之间的操作

2.1.1 APPLY

2.1.2 loc/iloc

loc

iloc

2.1.3 drop_duplicates：去除重复项

2.1.4 fillna 填充缺失数据

2.1.5 drop

2.1.6 数据选取

2.1.6.1 []

2.1.6.2 where 布尔查找

2.1.6.3 isin/isna

2.1.6.3 query

2.1.6.4 loc ：根据名称Label切片

2.1.6.5 iloc：切位置

2.1.6.6 ix：混切

2.1.6.7 map与lambda

2.1.6.8 apply和applymap

2.1.6.9 contains

2.2 merge

3 Python基础

3.1 元祖

3.1.1 访问元祖

3.1.2 修改元组

你可能感兴趣的:(Python学习)