Pandas 与 Numpy 经常使用方法总结
Lambda 函数实现
简单的说，lambda 就是一个函数，可是这个函数没有名字，因此咱们介绍一下这个函数的调用形式，参数与返回值的实现。 lambda 的格式以下：python
lambda [arg1 [, agr2,.....argn]] : expression lambda x : expression
那么这个函数怎么使用了，它经常不是单独使用，单独的使用的时候能够较为简单，实现的功能过于简单。因此一般被使用的状况是，某个函数的参数是一个函数，那么这个参数就可使用 lambda来实现。express
>>> foo = [2, 18, 9, 22, 17, 24, 8, 12, 27] >>> list(map(lambda x: x * 2 + 10, foo)) # 这里的 map 函数的第一个参数就是函数
Pandas的Apply函数
apply 函数以下 DataFrame.apply(func, axis=0, broadcast=False, raw=False, reduce=None, args=(), **kwds) 。其核心部分是function 的选择，其次是 axis 表示维度，这个函数能够经过上面说的 lambda函数实现。这个函数的参数就是 DataFrame， 返回的对象既能够是 DataFrame 也能够是 series。数组
>>> import pandas as pd
>>> import numpy as np
>>> df = pd.DataFrame([[4, 9],] * 3, columns=['A', 'B'])
>>> df.apply(np.sqrt)
A B
0 2.0 3.0
1 2.0 3.0
2 2.0 3.0
# 返回的是一个 DataFrame
>>> df.apply(np.sum, axis=0)
A 12
B 27
dtype: int64 # 返回的是一个 Series
>>> df.apply(lambda x: x*2 + 1, axis = 1) # 这种状况下，x 表示的是 df 中全部的参数
A B
0 9 19
1 9 19
2 9 19
>>> df.apply(lambda x: [1, 2,5], axis=1)
0 [1, 2, 5]
1 [1, 2, 5]
2 [1, 2, 5]
>>> df.apply(lambda x: [1, 2,5], axis=0)
A B
0 1 1
1 2 2
2 5 5
>>> df.apply(lambda x: [1, 2,6,7,8,5], axis=0)
A [1, 2, 6, 7, 8, 5]
B [1, 2, 6, 7, 8, 5]
>>> type(df.apply(lambda x: [1, 2,6,7,8,5], axis=0))
<class 'pandas.core.series.Series'>
# 这时，将DataFrame变成一个 Series。
python Zip函数
zip 函数的使用就是 zip([iterable, …]) 。zip()是Python的一个内建函数，它接受一系列可迭代的对象做为参数，将对象中对应的元素打包成一个个tuple（元组），而后返回由这些tuples组成的list（列表）。app
>>> name = [ "Manjeet", "Nikhil", "Shambhavi", "Astha" ]
>>> roll_no = [ 4, 1, 3, 2 ]
>>> marks = [ 40, 50, 60, 70 ]
>>> mapped = zip(name, roll_no, marks)
>>> list(mapped)
[('Manjeet', 4, 40), ('Nikhil', 1, 50), ('Shambhavi', 3, 60), ('Astha', 2, 70)]
Pandas 中的 Map函数
Map 函数主要是对 DataFrame 的操做，其参数还能够是函数，函数
>>> import pandas as pd
>>> from pandas import Series, DataFrame
>>> data = DataFrame({'food':['bacon','pulled pork','bacon','Pastrami',
'corned beef','Bacon','pastrami','honey ham','nova lox'],
'ounces':[4,3,12,6,7.5,8,3,5,6]})
>>> data
food ounces
0 bacon 4.0
1 pulled pork 3.0
2 bacon 12.0
3 Pastrami 6.0
4 corned beef 7.5
5 Bacon 8.0
6 pastrami 3.0
7 honey ham 5.0
8 nova lox 6.0
>>> meat_to_animal = {
'bacon':'pig',
'pulled pork':'pig',
'pastrami':'cow',
'corned beef':'cow',
'honey ham':'pig',
'nova lox':'salmon' }
>>> meat_to_animal
{'bacon': 'pig', 'pulled pork': 'pig', 'pastrami': 'cow', 'corned beef': 'cow', 'honey ham': 'pig', 'nova lox': 'salmon'}
>>> data['food'].map(str.lower)
0 bacon
1 pulled pork
2 bacon
3 pastrami
4 corned beef
5 bacon
6 pastrami
7 honey ham
8 nova lox
Name: food, dtype: object
>>> data['animal'] = data['food'].map(str.lower).map(meat_to_animal)
>>> data
food ounces animal
0 bacon 4.0 pig
1 pulled pork 3.0 pig
2 bacon 12.0 pig
3 Pastrami 6.0 cow
4 corned beef 7.5 cow
5 Bacon 8.0 pig
6 pastrami 3.0 cow
7 honey ham 5.0 pig
8 nova lox 6.0 salmon
>>> data['ounces'] = data['ounces'].map(lambda x: x+ 2) # 这里使用 Map 函数与Apply函数有点相似
>>> data
food ounces animal
0 bacon 6.0 pig
1 pulled pork 5.0 pig
2 bacon 14.0 pig
3 Pastrami 8.0 cow
4 corned beef 9.5 cow
5 Bacon 10.0 pig
6 pastrami 5.0 cow
7 honey ham 7.0 pig
8 nova lox 8.0 salmon
Numpy 中stack()，hstack()，vstack()函数
stack() 函数
函数原型为：stack(arrays, axis=0)，arrays能够传数组和列表。axis的含义我下面会讲解，咱们先来看个例子。spa
>>> import numpy as np
>>> a=[[[1,2,3,4],[11,21,31,41]],
[[5,6,7,8],[51,61,71,81]],
[[9,10,11,12],[91,101,111,121]]]
>>> a
[[[1, 2, 3, 4], [11, 21, 31, 41]], [[5, 6, 7, 8], [51, 61, 71, 81]], [[9, 10, 11, 12], [91, 101, 111, 121]]]
# 能够当作 a 有三层，咱们把从外到里分别当作 axis = 0， axis = 1， axis = 2的三层，首先要肯定这个 list a，有三个元素，每一个元素都# 是一个 list_1，每一个 lsit_1 有两个 list_2 元素，
>>> np.stack(a, axis = 0)
array([[[ 1, 2, 3, 4],
[ 11, 21, 31, 41]],
[[ 5, 6, 7, 8],
[ 51, 61, 71, 81]],
[[ 9, 10, 11, 12],
[ 91, 101, 111, 121]]])
>>> d = np.stack(a, axis = 0)
>>> len(d)
3
>>> d.shape # 在shape中分别表示从外到里的维度
(3, 2, 4)
# 获得的是一个 array 的类型，堆叠的是 axis = 0的那一层，至关于没变，只是数据格式改变
>>> np.stack(a, axis = 1)
array([[[ 1, 2, 3, 4],
[ 5, 6, 7, 8],
[ 9, 10, 11, 12]],
[[ 11, 21, 31, 41],
[ 51, 61, 71, 81],
[ 91, 101, 111, 121]]])
>>> c = np.stack(a, axis = 1)
>>> c.shape
(2, 3, 4)
# 这里获取 array 的每一个元素的方式
>>> np.stack(a, axis = 2)
array([[[ 1, 5, 9],
[ 2, 6, 10],
[ 3, 7, 11],
[ 4, 8, 12]],
[[ 11, 51, 91],
[ 21, 61, 101],
[ 31, 71, 111],
[ 41, 81, 121]]])
>>> b = np.stack(a, axis = 2)
>>> b.shape
(2, 4, 3)
咱们能够这样理解，stack 过程当中堆叠了那一层的元素，将这些元素做为新的 Array 的最里层，axis != 0 的时候永远都是将第一层的元素堆叠成新的最里层元素。code
hstack() 函数
对于上面的例子，咱们作个转换就很好理解 hstack() 函数了对象
>>> d = np.stack(a, axis = -1)
>>> d
array([[[ 1, 5, 9],
[ 2, 6, 10],
[ 3, 7, 11],
[ 4, 8, 12]],
[[ 11, 51, 91],
[ 21, 61, 101],
[ 31, 71, 111],
[ 41, 81, 121]]])
>>> d = np.hstack(d)
>>> d
array([[ 1, 5, 9, 11, 51, 91],
[ 2, 6, 10, 21, 61, 101],
[ 3, 7, 11, 31, 71, 111],
[ 4, 8, 12, 41, 81, 121]])
>>> d = np.hstack(d)
>>> d
array([ 1, 5, 9, 11, 51, 91, 2, 6, 10, 21, 61, 101, 3,
7, 11, 31, 71, 111, 4, 8, 12, 41, 81, 121])
>>> a = [[[[1, 2, 3, 4], [11, 21, 31, 41]], [[5, 6, 7, 8], [51, 61, 71, 81]], [[9, 10, 11, 12], [91, 101, 111, 121]]]]
>>> a
[[[[1, 2, 3, 4], [11, 21, 31, 41]], [[5, 6, 7, 8], [51, 61, 71, 81]], [[9, 10, 11, 12], [91, 101, 111, 121]]]]
hstack() 还能够用于两个array 的横向合并
>>> a=[[1],[2],[3]]
>>> b=[[1],[2],[3]]
>>> np.hstack((a,b))
array([[1, 1],
[2, 2],
[3, 3]])
vstack() 函数用于列的合并，也就是纵向
>>> np.vstack((a,b))
array([[1],
[2],
[3],
[1],
[2],
[3]])
Pandas分组运算（groupby）函数
groupby 函数就如字面上的意思，就是分组的意思，经常使用的方法第一个是分组， mean() 方法， 而groupby 的方法也经常用在观察数据类型中，在实际中分组也会使用ip
import pandas as pd
>>> df = pd.DataFrame({'A': ['a', 'b', 'a', 'c', 'a', 'c', 'b', 'c'], 'B': [2, 8, 1, 4, 3, 2, 5, 9],'C': [102, 98, 107, 104, 115, 87, 92, 123]})
>>> df
A B C
0 a 2 102
1 b 8 98
2 a 1 107
3 c 4 104
4 a 3 115
5 c 2 87
6 b 5 92
7 c 9 123
>>> df.groupby('A').mean()
B C
A
a 2.0 108.000000
b 6.5 95.000000
c 5.0 104.666667
>>> df.groupby(['A','B']).mean()
C
A B
a 1 107
2 102
3 115
b 5 92
8 98
c 2 87
4 104
9 123
聚合方法size()和count()
size跟count的区别： size计数时包含 NaN 值，而count不包含 NaN 值， 咱们能够理解 groupby函数是用来分组，那么分组以后的函数是能够选择的，能够是 mean() ，查看，或者是 count() 计数，下面这个例子：原型
>>> df = pd.DataFrame({"Name":["Alice", "Bob", "Mallory", "Mallory", "Bob" , "Mallory"],"City":["Seattle", "Seattle", "Portland", "Seattle", "Seattle", "Portland"],"Val":[4,3,3,np.nan,np.nan,4]})
>>> df
City Name Val
0 Seattle Alice 4.0
1 Seattle Bob 3.0
2 Portland Mallory 3.0
3 Seattle Mallory NaN
4 Seattle Bob NaN
5 Portland Mallory 4.0
>>> df.groupby(["Name", "City"], as_index=False)['Val'].count()
Name City Val
0 Alice Seattle 1
1 Bob Seattle 1
2 Mallory Portland 2
3 Mallory Seattle 0
>>> df.groupby(["Name"], as_index=False)['City'].count()
Name City
0 Alice 1
1 Bob 2
2 Mallory 3
# 选择的那一组表示次数， 好比上面的 City，而Size 函数就是包含 NaN 的个数
相关文章
- 1. Pandas 与 Numpy 经常使用方法总结
- 2. Numpy 经常使用方法总结
- 3. numpy经常使用用法总结
- 4. pandas经常使用总结
- 5. numpy经常使用总结
- 6. pandas经常使用方法
- 7. numpy与pandas经常使用函数
- 8. numpy经常使用方法
- 9. Numpy经常使用方法总结及应用
- 10. Pandas经常使用用法
- 更多相关文章...
- • Scala 方法与函数 - Scala教程
- • SQLite 常用函数 - SQLite教程
- • Composer 安装与使用
- • 算法总结-回溯法
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
相关文章
- 1. Pandas 与 Numpy 经常使用方法总结
- 2. Numpy 经常使用方法总结
- 3. numpy经常使用用法总结
- 4. pandas经常使用总结
- 5. numpy经常使用总结
- 6. pandas经常使用方法
- 7. numpy与pandas经常使用函数
- 8. numpy经常使用方法
- 9. Numpy经常使用方法总结及应用
- 10. Pandas经常使用用法