---
title: 学习 pandas [02]: 二进制操作
slug: er-jin-zhi-cao-zuo
date: 2021-1-23
tags:
- Pandas
- Jupyter
- python
category: 数据分析
link: 
description: 
type: text
---

# 二进制操作

Pandas数据结构之间执行二进制操作，要注意下列两个关键点：

- DataFrame与Series之间的广播机制；
- 计算中的缺失值处理。

## 加、减、乘、除、取模

DataFrame支持以下运算操作中对Series进行广播：

- add()：加
- sub()：减
- mul()：乘
- div()：除
- radd()
- rsub()

在以上方法使用中，通过`axis`参数，指定沿`index`或`columns`广播。



以`sub()`举例。

`df.sub(other, axis='columns', level=None, fill_value=None)`

- `other`：被减去的常数、序列、DataFrame或Series。如果是Series，则会按`axis`参数进行广播，也就是df的每行（或列）都执行减去Series。
- `axis`：可选值为columns或index，指定沿行或列广播。
- `level`：可选值为整数或标签，对于有多层及索引的df，指定Series对齐多层索引df的某一层级。
- `fill_value`：指定一个值代替df和other中的NaN。只对other为DataFrame时起作用。如果在df和other的相同位置都是NaN，则运算结果也是NaN。


```python
import numpy as np
import pandas as pd

df = pd.DataFrame({
    'one': pd.Series(np.random.randn(3), index=['a', 'b', 'c']),
    'two': pd.Series(np.random.randn(4), index=['a', 'b', 'c', 'd']),
    'three': pd.Series(np.random.randn(3), index=['b', 'c', 'd'])
})

df

```




<table>
  <thead>
    <tr>
      <th></th>
      <th>one</th>
      <th>two</th>
      <th>three</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <th>a</th>
      <td>-0.062689</td>
      <td>1.465328</td>
      <td>NaN</td>
    </tr>
    <tr>
      <th>b</th>
      <td>-2.187806</td>
      <td>-0.299947</td>
      <td>0.670050</td>
    </tr>
    <tr>
      <th>c</th>
      <td>-0.795105</td>
      <td>0.803948</td>
      <td>-0.016265</td>
    </tr>
    <tr>
      <th>d</th>
      <td>NaN</td>
      <td>-2.975800</td>
      <td>0.280831</td>
    </tr>
  </tbody>
</table>




```python
row = df.iloc[1]
df1 = df.sub(row, axis='columns')
df1
```




<table>
  <thead>
    <tr>
      <th></th>
      <th>one</th>
      <th>two</th>
      <th>three</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <th>a</th>
      <td>2.125118</td>
      <td>1.765275</td>
      <td>NaN</td>
    </tr>
    <tr>
      <th>b</th>
      <td>0.000000</td>
      <td>0.000000</td>
      <td>0.000000</td>
    </tr>
    <tr>
      <th>c</th>
      <td>1.392701</td>
      <td>1.103896</td>
      <td>-0.686316</td>
    </tr>
    <tr>
      <th>d</th>
      <td>NaN</td>
      <td>-2.675852</td>
      <td>-0.389220</td>
    </tr>
  </tbody>
</table>




```python
df2 = pd.DataFrame({
    'one': pd.Series(np.random.randn(3), index=['a', 'b', 'c']),
    'two': pd.Series(np.random.randn(4), index=['a', 'b', 'c', 'd']),
    'three': pd.Series(np.random.randn(4), index=['a', 'b', 'c', 'd'])
})
df2
```




<table>
  <thead>
    <tr>
      <th></th>
      <th>one</th>
      <th>two</th>
      <th>three</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <th>a</th>
      <td>-0.930814</td>
      <td>0.543193</td>
      <td>-3.300306</td>
    </tr>
    <tr>
      <th>b</th>
      <td>-0.756836</td>
      <td>1.236183</td>
      <td>-0.116324</td>
    </tr>
    <tr>
      <th>c</th>
      <td>1.270964</td>
      <td>0.958356</td>
      <td>0.802346</td>
    </tr>
    <tr>
      <th>d</th>
      <td>NaN</td>
      <td>0.818930</td>
      <td>-0.072648</td>
    </tr>
  </tbody>
</table>




```python
df3 = df.sub(df2, fill_value=10)
df3
```




<table>
  <thead>
    <tr>
      <th></th>
      <th>one</th>
      <th>two</th>
      <th>three</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <th>a</th>
      <td>0.868126</td>
      <td>0.922134</td>
      <td>13.300306</td>
    </tr>
    <tr>
      <th>b</th>
      <td>-1.430970</td>
      <td>-1.536130</td>
      <td>0.786375</td>
    </tr>
    <tr>
      <th>c</th>
      <td>-2.066069</td>
      <td>-0.154408</td>
      <td>-0.818611</td>
    </tr>
    <tr>
      <th>d</th>
      <td>NaN</td>
      <td>-3.794730</td>
      <td>0.353479</td>
    </tr>
  </tbody>
</table>



## 比较操作

Series与DataFrame支持以下比较操作：

- `eq()`：等于
- `ne()`：不等于
- `lt()`：小于
- `gt()`：大于
- `le()`：小于或等于
- `ge()`：大于或等于
- `equals()`：直接比较两个Series或两个DataFrame是否相等。此方法将NaN与NaN比较结果视为相等。
用法与加减乘除类似。以`lt()`举例。

`df.lt(other, axis='columns', level=None)`

- `other`：被比较的常数、序列、DataFrame或Series。如果是Series，则会按`axis`参数进行广播，也就是df的每行（或列）都执行减去Series。
- `axis`：可选值为columns或index，指定沿行或列广播。
- `level`：可选值为整数或标签，对于有多层及索引的df，指定Series对齐多层索引df的某一层级。

`equals()`返回值为布尔值，以上其他方法返回值为与df构造相同的元素为布尔值的DataFrame或Series。


```python
df.lt(df2)
```




<table>
  <thead>
    <tr>
      <th></th>
      <th>one</th>
      <th>two</th>
      <th>three</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <th>a</th>
      <td>False</td>
      <td>False</td>
      <td>False</td>
    </tr>
    <tr>
      <th>b</th>
      <td>True</td>
      <td>True</td>
      <td>False</td>
    </tr>
    <tr>
      <th>c</th>
      <td>True</td>
      <td>True</td>
      <td>True</td>
    </tr>
    <tr>
      <th>d</th>
      <td>False</td>
      <td>True</td>
      <td>False</td>
    </tr>
  </tbody>
</table>




```python
df.lt(row, axis='columns')
```




<table>
  <thead>
    <tr>
      <th></th>
      <th>one</th>
      <th>two</th>
      <th>three</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <th>a</th>
      <td>False</td>
      <td>False</td>
      <td>False</td>
    </tr>
    <tr>
      <th>b</th>
      <td>False</td>
      <td>False</td>
      <td>False</td>
    </tr>
    <tr>
      <th>c</th>
      <td>False</td>
      <td>False</td>
      <td>True</td>
    </tr>
    <tr>
      <th>d</th>
      <td>False</td>
      <td>True</td>
      <td>True</td>
    </tr>
  </tbody>
</table>




```python
df.lt(0)
```




<table>
  <thead>
    <tr>
      <th></th>
      <th>one</th>
      <th>two</th>
      <th>three</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <th>a</th>
      <td>True</td>
      <td>False</td>
      <td>False</td>
    </tr>
    <tr>
      <th>b</th>
      <td>True</td>
      <td>True</td>
      <td>False</td>
    </tr>
    <tr>
      <th>c</th>
      <td>True</td>
      <td>False</td>
      <td>True</td>
    </tr>
    <tr>
      <th>d</th>
      <td>False</td>
      <td>True</td>
      <td>False</td>
    </tr>
  </tbody>
</table>



直接用`df == df`比较，返回False，因为df中含有NaN，两个NaN值的比较结果为不等。因此需使用`equals()`方法。


```python
(df == df).all().all()
```




    False




```python
df.equals(df)
```




    True



## 布尔简化

可以把数据汇总简化成单个布尔值。

- `empty`：DataFrame或Series的属性，非方法，验证是否为空。
- `any()`：任意一个元素为真则为真。每使用一次则返回值减少一个维度。
- `all()`：全部元素为真则为真。每使用一次则返回值减少一个维度。
- `bool()`：验证单元素pandas对象的布尔值。


```python
df.empty
```




    False




```python
pd.Series([True]).bool()
```




    True



`any()`和`all()`用法类似。以`any()`举例。

`df.any(axis=0, bool_only=None, skipna=True, level=None)`

- `axis`：取值为0/'index'、1/'columns'、None，默认0，指定哪个维度被减少，如果取值None，则减去所有维度返回常数。
- `bool_only`：取值为布尔值，默认None。是否只利用序列中的布尔值进行判断，取None后会使用任何值。对Series无效。
- `skipna`：取值为布尔值，是否跳过NA/null值。默认值为True，则将整行/列都是NA的当作空行/列，返回False。反之不当作空行/列，返回True。
- `level`：可选值为整数或标签，对于有多层及索引的df，指定某一层级。



```python
df.lt(0).any()
```




    one      True
    two      True
    three    True
    dtype: bool




```python
df.lt(0).all()
```




    one      False
    two      False
    three    False
    dtype: bool




```python
df.lt(0).any().all()
```




    True



## 合并重叠数据

`df5.combine_first(df6)`

将df5中的NaN值以及空行/列，填充df6中对应位置的值。


```python
df5 = pd.DataFrame({'A': [1., np.nan, 3., 5., np.nan],
                    'B': [np.nan, 2., 3., np.nan, 6.]})

df6 = pd.DataFrame({'A': [5., 2., 4., np.nan, 3., 7.],
                    'B': [np.nan, np.nan, 3., 4., 6., 8.],
                    'C': [2., 3., 9., 10., 11., 12.]})

df5
```




<table>
  <thead>
    <tr>
      <th></th>
      <th>A</th>
      <th>B</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <th>0</th>
      <td>1.0</td>
      <td>NaN</td>
    </tr>
    <tr>
      <th>1</th>
      <td>NaN</td>
      <td>2.0</td>
    </tr>
    <tr>
      <th>2</th>
      <td>3.0</td>
      <td>3.0</td>
    </tr>
    <tr>
      <th>3</th>
      <td>5.0</td>
      <td>NaN</td>
    </tr>
    <tr>
      <th>4</th>
      <td>NaN</td>
      <td>6.0</td>
    </tr>
  </tbody>
</table>




```python
df6
```




<table>
  <thead>
    <tr>
      <th></th>
      <th>A</th>
      <th>B</th>
      <th>C</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <th>0</th>
      <td>5.0</td>
      <td>NaN</td>
      <td>2.0</td>
    </tr>
    <tr>
      <th>1</th>
      <td>2.0</td>
      <td>NaN</td>
      <td>3.0</td>
    </tr>
    <tr>
      <th>2</th>
      <td>4.0</td>
      <td>3.0</td>
      <td>9.0</td>
    </tr>
    <tr>
      <th>3</th>
      <td>NaN</td>
      <td>4.0</td>
      <td>10.0</td>
    </tr>
    <tr>
      <th>4</th>
      <td>3.0</td>
      <td>6.0</td>
      <td>11.0</td>
    </tr>
    <tr>
      <th>5</th>
      <td>7.0</td>
      <td>8.0</td>
      <td>12.0</td>
    </tr>
  </tbody>
</table>




```python
df5.combine_first(df6)
```




<table>
  <thead>
    <tr>
      <th></th>
      <th>A</th>
      <th>B</th>
      <th>C</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <th>0</th>
      <td>1.0</td>
      <td>NaN</td>
      <td>2.0</td>
    </tr>
    <tr>
      <th>1</th>
      <td>2.0</td>
      <td>2.0</td>
      <td>3.0</td>
    </tr>
    <tr>
      <th>2</th>
      <td>3.0</td>
      <td>3.0</td>
      <td>9.0</td>
    </tr>
    <tr>
      <th>3</th>
      <td>5.0</td>
      <td>4.0</td>
      <td>10.0</td>
    </tr>
    <tr>
      <th>4</th>
      <td>3.0</td>
      <td>6.0</td>
      <td>11.0</td>
    </tr>
    <tr>
      <th>5</th>
      <td>7.0</td>
      <td>8.0</td>
      <td>12.0</td>
    </tr>
  </tbody>
</table>

学习 pandas [02]: 二进制操作

前几天上班用的计算器彻底没电了，无法开机。型号是CASIO fx-82ES，背盖是一个整体，没给电池区单独设开盖。

因为自己的笔记本电脑也是整体后盖，拆起来难度上天，所以对拆这种整体后盖的电子设备有点忐忑，怕拆开没本事装回去。但事实证明，这个CASIO计算器设计得很方便更换电池。




计算器的螺丝是十字口，先用一个某宝买东西送的十字螺丝刀，结果没拧开，反倒螺丝刀的十字刃被磨平了。果然送的没好货。于是找出多年前买的一套刀头。

![](https://bode-1257862934.file.myqcloud.com/img/CASIO1.png)

怕把十字口的又给磨平，直接上平口。

![](https://bode-1257862934.file.myqcloud.com/img/CASIO2.png)

计算器背盖上总共6颗螺丝，拧完就完事儿，背盖直接拿起。原先以为用的是纽扣电池，打算先拆开看看电池型号，一看就是普通7号电池，刚好手边就有。

![](https://bode-1257862934.file.myqcloud.com/img/CASIO3.png)

换电池，测试开机成功，再装上背盖，完事儿。

![](https://bode-1257862934.file.myqcloud.com/img/CASIO4.png)

好几个月没干过手工活，手碰的工具不是键盘就是鼠标，虽然十分钟的活，还是有一丝丝突破日常的愉悦感。

CASIO fx-82ES 计算器更换电池

---
title: 学习 pandas [01]: 数据结构
slug: series-and-dataframe
date: 2020-12-27
tags:
- Pandas
- Jupyter
- python
category: 数据分析
link: 
description: 
type: text
---

# 数据结构

pandas的数据类型主要有：

- Series，类似一维数组
- DataFrame，类似二维数组







## Series

### 创建Series

```
pd.Series(data, index=index)
```

`data`：可以是字典、一维数组、标量

`index`：索引列表，可以理解为行标签，根据`Data`的类型而不同。

#### 通过字典创建Series


```python
import numpy as np
import pandas as pd

# 通过字典创建，自动采用键值作为索引，若不指定index，则顺序同字典
d = {'b': 1, 'a': 0, 'c': 2}
s = pd.Series(d)
s
```




    b    1
    a    0
    c    2
    dtype: int64




```python
# 通过字典创建，自动采用键值作为索引，若指定index（包含键值），则顺序同index
# index中若含有字典中不存在的键值，则Series中对应的值为NaN
s = pd.Series(d, index=['a', 'b', 'c', 'd'])
s
```




    a    0.0
    b    1.0
    c    2.0
    d    NaN
    dtype: float64



#### 通过一维数组创建Series


```python
l = np.random.randn(6)

# 若不指定index，则自动生成数值型索引
s = pd.Series(l)
s
```




    0    0.215224
    1    0.803700
    2    1.141428
    3    0.526450
    4    0.577533
    5    1.051918
    dtype: float64




```python
# 若指定index，则长度必须与数组相同
s = pd.Series(l, index=['a', 'b', 'c', 'd', 'e', 'f'])
s
```




    a    0.215224
    b    0.803700
    c    1.141428
    d    0.526450
    e    0.577533
    f    1.051918
    dtype: float64



#### 通过标量值创建Series

此方法创建出的Series，每行值都相同。


```python
# 必须指定index，Series的长度按照index的长度
s = pd.Series(666, index=['a', 'b', 'c', 'd', 'e', 'f'])
s
```




    a    666
    b    666
    c    666
    d    666
    e    666
    f    666
    dtype: int64



### Series具备的方法

如果不在意索引，Series类似于NumPy数组。如果把索引当作键值，则又类似于字典。

Series所具备的方法也与NumPy数组和字典类似。

#### Series类似数组的方法

- 切片操作
- 支持大多数NumPy函数
- 矢量操作与对齐Series标签：Series之间的操作会自动基于标签对齐数据，不用顾及执行计算操作的Series是否有相同的标签


```python
# 使用numpy的exp()函数作用于每个值
s = pd.Series(l, index=['a', 'b', 'c', 'd', 'e', 'f'])
np.exp(s)
```




    a    1.240139
    b    2.233790
    c    3.131235
    d    1.692912
    e    1.781637
    f    2.863136
    dtype: float64




```python
# 两个具有不同索引标签的Series相加
s1 = pd.Series(1, index=['b', 'c', 'd', 'e', 'g'])
s + s1
```




    a         NaN
    b    1.803700
    c    2.141428
    d    1.526450
    e    1.577533
    f         NaN
    g         NaN
    dtype: float64



以上两个不同索引标签的Series相加，操作未对齐索引的Series，结果是所有涉及索引的并集。

**Pandas数据结构集成的数据对齐功能，是Pandas区别于大多数标签型数据处理工具的重要特性。**

#### Series类似字典的方法

- 使用索引标签提取值
    - 引用Series里没有的标签会触发异常
    - `get()`方法可以提取Series里没有的标签，返回`NaN`或指定默认值


```python
s['d']
```




    0.5264503416237949




```python
s.get('g', np.nan)
```




    nan



## DataFrame

### 创建DataFrame

```
pd.DataFrame(data, index=index, columns=columns)
```

`data`：可以是一维数组、二维numpy数组、列表、字典、Series字典、Series、DataFrame
`index`：行标签
`columns`：列标签

#### 通过Series字典创建DtaFrame


```python
d = {'one': pd.Series([1., 2., 3.], index=['a', 'b', 'c']),
     'two': pd.Series([1., 2., 3., 4.], index=['a', 'b', 'c', 'd'])}
# index、columns分别来自Series字典的索引和键值，index指定行标签顺序，columns指定列标签顺序
df = pd.DataFrame(d, index=['b', 'c', 'd', 'a'], columns=['two', 'one'])
df
```




<table>
  <thead>
    <tr>
      <th></th>
      <th>two</th>
      <th>one</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <th>b</th>
      <td>2.0</td>
      <td>2.0</td>
    </tr>
    <tr>
      <th>c</th>
      <td>3.0</td>
      <td>3.0</td>
    </tr>
    <tr>
      <th>d</th>
      <td>4.0</td>
      <td>NaN</td>
    </tr>
    <tr>
      <th>a</th>
      <td>1.0</td>
      <td>1.0</td>
    </tr>
  </tbody>
</table>



#### 通过数组字典创建DataFrame


```python
d = {'one': [1., 2., 3., 4.], 'two': [4., 3., 2., 1.]}
#  columns来自数组字典的键值，可指定顺序；index须指定，否则生成自然数索引
df = pd.DataFrame(d, index=['a', 'b', 'c', 'd'], columns=['two', 'one'])
df
```




<table>
  <thead>
    <tr>
      <th></th>
      <th>two</th>
      <th>one</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <th>a</th>
      <td>4.0</td>
      <td>1.0</td>
    </tr>
    <tr>
      <th>b</th>
      <td>3.0</td>
      <td>2.0</td>
    </tr>
    <tr>
      <th>c</th>
      <td>2.0</td>
      <td>3.0</td>
    </tr>
    <tr>
      <th>d</th>
      <td>1.0</td>
      <td>4.0</td>
    </tr>
  </tbody>
</table>



#### 通过字典列表创建DataFrame


```python
d = [{'a': 1, 'b': 2}, {'a': 5, 'b': 10, 'c': 20}]
# columns同样来自字典的键值，可指定顺序；index须指定，否则生成自然数索引
df = pd.DataFrame(d, columns=['a', 'b', 'c'], index=['two', 'one'])
df
```




<table>
  <thead>
    <tr>
      <th></th>
      <th>a</th>
      <th>b</th>
      <th>c</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <th>two</th>
      <td>1</td>
      <td>2</td>
      <td>NaN</td>
    </tr>
    <tr>
      <th>one</th>
      <td>5</td>
      <td>10</td>
      <td>20.0</td>
    </tr>
  </tbody>
</table>



#### 通过元组字典创建DataFrame

此方法可以生成多重行标签和列标签。

元组字典的key为元组，value为字典，且该字典的key也是元组。作为key的元组生成多重列标签，value字典中的key生成多重行标签


```python
d = {('a', 'b'): {('A', 'B'): 1, ('A', 'C'): 2},
     ('a', 'a'): {('A', 'C'): 3, ('A', 'B'): 4},
     ('a', 'c'): {('A', 'B'): 5, ('A', 'C'): 6},
     ('b', 'a'): {('A', 'C'): 7, ('A', 'B'): 8},
     ('b', 'b'): {('A', 'D'): 9, ('A', 'B'): 10}}
df = pd.DataFrame(d)
df
```




<table>
  <thead>
    <tr>
      <th></th>
      <th></th>
      <th colspan="3" halign="left">a</th>
      <th colspan="2" halign="left">b</th>
    </tr>
    <tr>
      <th></th>
      <th></th>
      <th>b</th>
      <th>a</th>
      <th>c</th>
      <th>a</th>
      <th>b</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <th rowspan="3" valign="top">A</th>
      <th>B</th>
      <td>1.0</td>
      <td>4.0</td>
      <td>5.0</td>
      <td>8.0</td>
      <td>10.0</td>
    </tr>
    <tr>
      <th>C</th>
      <td>2.0</td>
      <td>3.0</td>
      <td>6.0</td>
      <td>7.0</td>
      <td>NaN</td>
    </tr>
    <tr>
      <th>D</th>
      <td>NaN</td>
      <td>NaN</td>
      <td>NaN</td>
      <td>NaN</td>
      <td>9.0</td>
    </tr>
  </tbody>
</table>



### 提取DataFrame的列

类似于字典，直接用列标签索引。

### 删除DataFrame的列

两种方法：

- `del df['foo']`
- ` df.pop['foo']`

### 添加DataFrame的列

插入的列的数据类型可以是：

- Series，索引不同时以DataFrame为准
- 原始数组，长度必须与DataFrame一致
- 标量值，以广播方式填充

插入或生成新列的方法：

- 类似于字典，直接用列标签索引，默认插入在最后一列
- `insert(位置， 列标签， 数据)`，可指定列插入位置
- `assign()`方法利用现有的列生成新列，此方法返回的是副本，原始DataFrame不会变动

#### `assign()`方法举例


```python
d = {'one': [1., 2., 3., 4.], 'two': [4., 3., 2., 1.]}
df = pd.DataFrame(d, index=['a', 'b', 'c', 'd'])
df
```




<table>
  <thead>
    <tr>
      <th></th>
      <th>one</th>
      <th>two</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <th>a</th>
      <td>1.0</td>
      <td>4.0</td>
    </tr>
    <tr>
      <th>b</th>
      <td>2.0</td>
      <td>3.0</td>
    </tr>
    <tr>
      <th>c</th>
      <td>3.0</td>
      <td>2.0</td>
    </tr>
    <tr>
      <th>d</th>
      <td>4.0</td>
      <td>1.0</td>
    </tr>
  </tbody>
</table>




```python
df.assign(three=df['two']/df['one'])
```




<table>
  <thead>
    <tr>
      <th></th>
      <th>one</th>
      <th>two</th>
      <th>three</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <th>a</th>
      <td>1.0</td>
      <td>4.0</td>
      <td>4.000000</td>
    </tr>
    <tr>
      <th>b</th>
      <td>2.0</td>
      <td>3.0</td>
      <td>1.500000</td>
    </tr>
    <tr>
      <th>c</th>
      <td>3.0</td>
      <td>2.0</td>
      <td>0.666667</td>
    </tr>
    <tr>
      <th>d</th>
      <td>4.0</td>
      <td>1.0</td>
      <td>0.250000</td>
    </tr>
  </tbody>
</table>




```python
df.assign(four=lambda x: (x['two']/x['one']))
```




<table>
  <thead>
    <tr>
      <th></th>
      <th>one</th>
      <th>two</th>
      <th>four</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <th>a</th>
      <td>1.0</td>
      <td>4.0</td>
      <td>4.000000</td>
    </tr>
    <tr>
      <th>b</th>
      <td>2.0</td>
      <td>3.0</td>
      <td>1.500000</td>
    </tr>
    <tr>
      <th>c</th>
      <td>3.0</td>
      <td>2.0</td>
      <td>0.666667</td>
    </tr>
    <tr>
      <th>d</th>
      <td>4.0</td>
      <td>1.0</td>
      <td>0.250000</td>
    </tr>
  </tbody>
</table>

学习 pandas [01]: 数据结构

学习 seaborn [06]: 设置中文显示

---
title: 学习 seaborn [05]: 调色板
slug: color-seaborn
date: 2020-12-14
tags:
- seaborn
- python
category: 数据分析
link: 
description: 
type: text
---

# 选择调色板

调色板是一组颜色搭配方案，绘图时候程序从中选取颜色进行数据可视化。调色板中颜色之间的色相、饱和度、明度等差异，区别出不同系列的数据关系，因此调色板比其他元素更加影响绘图的视觉效果。

seaborn提供了一些现成的配色方案，也可以利用其提供的函数自定义调色板。



## 调色板分类

- **定性调色板**：一组在视觉上有差异的颜色，用于区分不具有内在顺序的离散数据；
- **顺序调色板**：一组视觉温度递增或递减的颜色，一般是单一色相，也可以是多种色相，用于当数据集的范围从相对低值(不感兴趣)到相对高值(很感兴趣)时；
- **发散调色板**：一组颜色的中间位置颜色的视觉温度最亮或最暗，然后分别向两端递增或递减，用于当数据集的低值和高值都很重要，且数据集中有明确定义的中点时。

## 生成调色板的函数

### 可生成三种调色板的函数

- `color_palette()`：生成调色盘，接受所有的seaborn调色板或者matplotlib Colormap或者Color Brewer库的配色方案，返回RGB元组的列表；
- `set_palette()`：接受与`color_palette()`相同参数，设置所有图像的默认配色方案；
- `xkcd_rgb()`：使用xkcd颜色名字设置单一颜色；
- `xkcd_palette()`：使用xkcd颜色名字生成调色板，适用于各种调色板；
- `choose_colorbrewer_palette()`：通过交互式组件辅助进行Color Brewer库的配色方案选择，适用于各种调色板，只能在Jupyter Notebook中使用；

### 用于生成定性调色板的函数

- `hls_palette()`：使用hls颜色空间生成间距相等的颜色（色调变化，明度和饱和度不变），适用于**定性调色板**；
- `husl_palette()`：使用HSLuv颜色空间生成间距相等的颜色，比上述hls更符合人眼视觉感受，适用于**定性调色板**；

### 用于生成顺序调色板的函数

- `cubehelix_palette()`：使用cubehelix调色板系统生成配色方案，适合黑白打印，且对色盲友好，适用于**顺序调色板**；
- `choose_cubehelix_palette()`：通过交互式组件辅助进行cubehelix调色板的配色方案选择，只能在Jupyter Notebook中使用；
- `light_palette()`和`dark_palette()`：指定一个颜色，会由明向暗或由暗向明生成一组颜色，适用于**顺序调色板**；

### 用于生成发散调色板的函数

- `diverging_palette()`：用来创建**发散调色板**；
- `choose_diverging_palette()`：通过交互式组件辅助进行发散调色板的配色方案选择，使用HSLuv颜色空间，只能在Jupyter Notebook中使用；

## 生成调色板的方式

seaborn中生成调色板的方式大致有三种：

1. 直接指定一组颜色代码或名字，如`color_palette()`、`xkcd_palette()`；
2. 从现成的配色方案中选取，如`color_palette()`中直接使用seaborn内置配色方案，或从Color Brewer网站上挑选；
3. 利用函数生成配色方案，如`hls_palette()`、`husl_palette()`、`cubehelix_palette()`、`light_palette()`、`dark_palette()`、`diverging_palette()`。

如果绘图时没有特殊的美学需求，方便起见可以直接使用现成的配色方案。

### seaborn内置配色方案

seaborn内置配色方案有六种，下图从上到下依次为`deep`(默认), `muted`, `pastel`, `bright`, `dark`, 和`colorblind`。


```python
import seaborn as sns
%matplotlib inline

sns.set()
for i in ('deep', 'muted', 'pastel', 'bright', 'dark', 'colorblind'):
    cp = sns.color_palette(i)
    sns.palplot(cp)
```

![](https://bode-1257862934.file.myqcloud.com/img/color_1_0.png)

![](https://bode-1257862934.file.myqcloud.com/img/color_1_1.png)

![](https://bode-1257862934.file.myqcloud.com/img/color_1_2.png)

![](https://bode-1257862934.file.myqcloud.com/img/color_1_3.png)

![](https://bode-1257862934.file.myqcloud.com/img/color_1_4.png)

![](https://bode-1257862934.file.myqcloud.com/img/color_1_5.png)


### Color Brewer库中的配色方案

Color Brewer库为三种类型调色板都提供了不少美观的配色方案，并且对色盲友好。

Color Brewer库地址：http://colorbrewer2.org

登陆网站后，通过选择调色板类型，颜色数量，配色方案，会得到配色方案的名称。

![](https://bode-1257862934.file.myqcloud.com/img/colorbrewer.png)

如上图中是个顺序调色板，配色方案名字叫`PuBuGn`，颜色数量是3，传递给`color_palette()`函数，可生成对应的调色板。


```python
pc = sns.color_palette('PuBuGn', 3)
sns.palplot(pc)
```

![](https://bode-1257862934.file.myqcloud.com/img/color_3_0.png)