Python常用语法及函数

目录

---

[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对象的五个主要属性：索引、值、名称、数据类型、形状。

1. 索引 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. 值

• 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

3. 名称
   DataFrame对象的索引对象有名称属性。
   但是DataFrame对象没有名称属性。
4. 数据类型
   通过dtypes属性获取DataFrame对象每列的数据类型。
5. 形状
   通过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)