Python for Data Science（Python資料科學）：您可能忘記的8個概念

傻了吧嗒發表於2018-09-24
Python資料科學

Python for Data Science（Python資料科學）：您可能忘記的8個概念

目錄

Python for Data Science（Python資料科學）：您可能忘記的8個概念

1.單行列表理解

2.Lambda函式

3.Map，Filter和Reduce函式

Map

Filter

Reduce

4. Arange和Linspace函式

Arange

Linspace

5. Axis真正意味著什麼

6. Concat,Merge和Join

7.Pandas Apply

Apply

Applymap

8.Pivot Tables

Pivot

Pivot Tables

1.單行列表理解

每次需要定義某種列表時寫出一個for迴圈是很乏味的，幸運的是Python有一種內建的方法可以在一行程式碼中解決這個問題。語法可能有點難以理解，但是一旦熟悉了這種技術，你就會經常使用它。

 

2.Lambda函式

Lambda函式用於在Python中建立小型，一次性和匿名函式物件。基本上，它們可以讓您建立一個函式，而無需建立函式。

lambda函式的基本語法是：

lambda引數：表示式

 

3.Map，Filter和Reduce函式

一旦掌握了lambda函式，學習將它們與map和filter函式配對就可以成為一個強大的工具。

Map

具體來說，map通過對每個元素執行某種操作來獲取列表並將其轉換為新列表。在此示例中，它遍歷每個元素並將自身結果對映到新列表。請注意，list函式只是將輸出轉換為列表型別。

map函式就像是一個黑匣子一樣，通過這個黑匣子可以對映出基於原列表或者其他東西的另一個新列表。

# Map
seq = [1, 2, 3, 4, 5]
result = list(map(lambda var: var*2, seq))
print(result)
[2, 4, 6, 8, 10]

有條件的話，大家可以觀看這個視訊：Python:Lambda,Map,Filter,Reduce Functions (YouTobe視訊)

Filter

過濾器函式接受一個列表和一個條件規則，非常類似於map，但它通過將每個元素與布林過濾規則進行比較來返回原始列表的子集。

Reduce

reduce()函式接收的引數和 map()類似，一個函式 f，一個list，但行為和 map()不同，reduce()傳入的函式 f 必須接收兩個引數，reduce()對list的每個元素反覆呼叫函式f，並返回最終結果值。

例如，編寫一個f函式，接收x和y，返回x和y的和：

1

2

def f(x, y):

    return x + y

呼叫 reduce(f, [1, 3, 5, 7, 9])時，reduce函式將做如下計算：

1

2

3

4

5

先計算頭兩個元素：f(1, 3)，結果為4；

再把結果和第3個元素計算：f(4, 5)，結果為9；

再把結果和第4個元素計算：f(9, 7)，結果為16；

再把結果和第5個元素計算：f(16, 9)，結果為25；

由於沒有更多的元素了，計算結束，返回結果25。

上述計算實際上是對 list 的所有元素求和。雖然Python內建了求和函式sum()，但是，利用reduce()求和也很簡單。

reduce()還可以接收第3個可選引數，作為計算的初始值。如果把初始值設為100，計算：

1

reduce(f, [1, 3, 5, 7, 9], 100)

結果將變為125，因為第一輪計算是：

計算初始值和第一個元素：f(100, 1)，結果為101。

 

4. Arange和Linspace函式

要建立快速簡便的Numpy陣列，請檢視arange和linspace函式。

Arange

Arange在給定間隔內返回均勻間隔的值。除了起點和終點，您還可以根據需要定義步長或資料型別。

請注意，停止點是一個“截止”值，因此它不會包含在陣列輸出中。

# np.arange(start, stop, step)
np.arange(3, 7, 2)
array([3, 5])

Linspace

Linspace非常相似，但略有不同。Linspace在指定的時間間隔內返回均勻間隔的數字。因此，給定一個起始點和停止點，以及一些值，linspace將在NumPy陣列中為您平均分配它們。這對於資料視覺化和繪圖時宣告軸特別有用。

# np.linspace(start, stop, num)
np.linspace(2.0, 3.0, num=5)
array([ 2.0,  2.25,  2.5,  2.75, 3.0])

 

5. Axis真正意味著什麼

在Pandas中刪除列或在NumPy矩陣中對值進行求和時，可能會遇到此問題。如果沒有，那麼你肯定會在某個時候遇到的。我們現在使用刪除列的示例： 

df.drop('Row A', axis=0)
df.drop('Column A', axis=1)

您可以從上面推斷出，如果要處理列，請將axis設定為1，如果需要行，則將其設定為0。但為什麼會這樣呢？我最喜歡的推理，或至少我記得這個：

df.shape
(# of Rows, # of Columns)

從Pandas呼叫shape屬性會返回一個元組，其中第一個值（即axis=0）表示行數，第二個值（即axis=1）表示列數。如果您考慮如何在Python中編制索引，則行為0且列為1，這與我們宣告軸值的方式非常相似。

 

6. Concat,Merge和Join

如果您熟悉SQL，那麼這些概念對您來說可能會很容易。無論如何，這些功能基本上只是以特定方式組合DataFrame的方法。可能很難跟蹤哪個時間最好使用哪個，所以讓我們來回顧一下。

Concat允許使用者在其下方或旁邊附加一個或多個DataFrame（取決於您如何定義軸axis）。

pandas.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, sort=None, copy=True) 

>>> s1 = pd.Series(['a', 'b'])
>>> s2 = pd.Series(['c', 'd'])
>>> pd.concat([s1, s2])
0    a
1    b
0    c
1    d
dtype: object

 

Merge將多個DataFrame組合在作為主鍵的特定公共列上。

DataFrame.merge(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)

>>> A              >>> B
    lkey value         rkey value
0   foo  1         0   foo  5
1   bar  2         1   bar  6
2   baz  3         2   qux  7
3   foo  4         3   bar  8
>>> A.merge(B, left_on='lkey', right_on='rkey', how='outer')
   lkey  value_x  rkey  value_y
0  foo   1        foo   5
1  foo   4        foo   5
2  bar   2        bar   6
3  bar   2        bar   8
4  baz   3        NaN   NaN
5  NaN   NaN      qux   7

 

Join，就像merge一樣，結合了兩個DataFrame。但是，它根據它們的索引加入它們，而不是某些指定的列。

DataFrame.join(other, on=None, how='left', lsuffix='', rsuffix='', sort=False)

>>> caller = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3', 'K4', 'K5'],
                           'A': ['A0', 'A1', 'A2', 'A3', 'A4', 'A5']})
>>> other = pd.DataFrame({'key': ['K0', 'K1', 'K2'],
                          'B': ['B0', 'B1', 'B2']})
>>> caller.join(other, lsuffix='_caller', rsuffix='_other')
>>>     A key_caller    B key_other
    0  A0         K0   B0        K0
    1  A1         K1   B1        K1
    2  A2         K2   B2        K2
    3  A3         K3  NaN       NaN
    4  A4         K4  NaN       NaN
    5  A5         K5  NaN       NaN

 

 

7.Pandas Apply

Apply

Apply會根據您指定的內容向列或行中的每個元素應用一個函式。您可以想象這可能是多麼有用，特別是對於整個DataFrame列的格式化和操作值，而不必進行迴圈。

DataFrame.apply(func, axis=0, broadcast=None, raw=False, reduce=None, result_type=None, args=(), **kwds)

>>> df = pd.DataFrame([[4, 9],] * 3, columns=['A', 'B'])
>>> df
   A  B
0  4  9
1  4  9
2  4  9
>>> df.apply(np.sqrt)
     A    B
0  2.0  3.0
1  2.0  3.0
2  2.0  3.0

By the way，你還可以用axis來控制：

>>> df.apply(np.sum, axis=0)
A    12
B    27
dtype: int64
>>> df.apply(lambda x: pd.Series([1, 2], index=['foo', 'bar']), axis=1)
   foo  bar
0    1    2
1    1    2
2    1    2

Applymap

DataFrame.applymap(func)

>>> df = pd.DataFrame([[1, 2.12], [3.356, 4.567]])
>>> df
       0      1
0  1.000  2.120
1  3.356  4.567
>>> df.applymap(lambda x: len(str(x)))
   0  1
0  3  4
1  5  5

 

8.Pivot Tables

Pivot

DataFrame.pivot(index=None, columns=None, values=None)

>>> df = pd.DataFrame({'foo': ['one', 'one', 'one', 'two', 'two',
...                            'two'],
...                    'bar': ['A', 'B', 'C', 'A', 'B', 'C'],
...                    'baz': [1, 2, 3, 4, 5, 6],
...                    'zoo': ['x', 'y', 'z', 'q', 'w', 't']})
>>> df
    foo   bar  baz  zoo
0   one   A    1    x
1   one   B    2    y
2   one   C    3    z
3   two   A    4    q
4   two   B    5    w
5   two   C    6    t
>>> df.pivot(index='foo', columns='bar', values=['baz', 'zoo'])
      baz       zoo
bar   A  B  C   A  B  C
foo
one   1  2  3   x  y  z
two   4  5  6   q  w  t

Pivot Tables

Last but certainly not least is 資料透視表。如果你熟悉Microsoft Excel，那麼你可能已經在某些方面聽說過資料透視表。Pandas內建的pivot_table函式將電子表格樣式的資料透視表建立為DataFrame。請注意，資料透視表中的級別儲存在結果DataFrame的索引和列上的MultiIndex物件中。

pandas.pivot_table(data, values=None, index=None, columns=None, aggfunc='mean', fill_value=None, margins=False, dropna=True, margins_name='All')

>>> df = pd.DataFrame({"A": ["foo", "foo", "foo", "foo", "foo",
...                          "bar", "bar", "bar", "bar"],
...                    "B": ["one", "one", "one", "two", "two",
...                          "one", "one", "two", "two"],
...                    "C": ["small", "large", "large", "small",
...                          "small", "large", "small", "small",
...                          "large"],
...                    "D": [1, 2, 2, 3, 3, 4, 5, 6, 7]})
>>> df
     A    B      C  D
0  foo  one  small  1
1  foo  one  large  2
2  foo  one  large  2
3  foo  two  small  3
4  foo  two  small  3
5  bar  one  large  4
6  bar  one  small  5
7  bar  two  small  6
8  bar  two  large  7
>>> table = pivot_table(df, values='D', index=['A', 'B'],
...                     columns=['C'], aggfunc=np.sum)
>>> table
C        large  small
A   B
bar one    4.0    5.0
    two    7.0    6.0
foo one    4.0    1.0
    two    NaN    6.0
>>> table = pivot_table(df, values='D', index=['A', 'B'],
...                     columns=['C'], aggfunc=np.sum)
>>> table
C        large  small
A   B
bar one    4.0    5.0
    two    7.0    6.0
foo one    4.0    1.0
    two    NaN    6.0
>>> table = pivot_table(df, values=['D', 'E'], index=['A', 'C'],
...                     aggfunc={'D': np.mean,
...                              'E': [min, max, np.mean]})
>>> table
                  D   E
               mean max median min
A   C
bar large  5.500000  16   14.5  13
    small  5.500000  15   14.5  14
foo large  2.000000  10    9.5   9
    small  2.333333  12   11.0   8

 

 

相關文章