昨天跟同事闲聊，上周末西安下雨，气温大概10℃左右，由于还没停止供暖，所以开窗睡觉非常舒适。进而聊到，感觉上去年一年西安的气候都比往年要舒适。记得去年有篇文章，题目大意是「西北变热变湿，西安恐成最大赢家」。于是查找西安的天气数据，打算分析下。

从NOAA网站上找到1951年至2020年的西安月度气象数据，1951年至2005年的数据来自西安气象站，2006年之后的来自泾河气象站，两者距离不远，都是监测西安市的。




```python
import seaborn as sns
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline

rc = {'axes.unicode_minus': False}
sns.set(context='notebook', style='ticks', font='SimHei', rc=rc)
temps = pd.read_csv('西安站-泾河站-1951-2021-月度气象数据-来自NOAA-整理后.csv')
display(temps)
```

![](https://bode-1257862934.file.myqcloud.com/img/1614846178(1).png)

首先绘制历年的月度平均气温分布，看下2020年每月的平均气温在历史统计中处于何种位置。


```python
ax = sns.swarmplot(x="MONTH", y="TAVGC", hue="TAG", data=temps, dodge=True)
ax.set_title("图1  1951年-2020年月平均温度")
```




    Text(0.5, 1.0, '图1  1951年-2020年月平均温度')




    
![](https://bode-1257862934.file.myqcloud.com/img/2020_xian_temp_3_1.svg)
    


> ↑图1中，横座标表示月份，纵座标表示气温，橙色点表示2020年气温，蓝色点表示其他年份气温。

从个人的感觉，夏天不热，冬天不冷，便可说气温舒适。在西安，冬季最冷的时间一般是前一年12月底至第二年2月底，夏季最热时间一般是7、8月份。

从图1，2020年1、2月冬季月平均温度都在历年高位，甚至能排进历史前四分之一。7、8月夏季月平均温度相比其他年份不算高，基本都在中位数水平。而且春秋两季的气温也处于历史较高位。

也就是说，** 相比历史上大多年份，2020年西安全年较温暖，冬天不冷，夏天也不热，算是比较舒适了。**

以上是1951年至今的数据，年代太久远的年份肯定无法有直观感受。下面用泾河气象站2006年至2020年的数据重新分析，看下近十五年内的月度温度分布。


```python
ax = sns.swarmplot(x="MONTH", y="TAVGC", hue="TAG", data=temps[temps.YEAH>=2006], dodge=True)
ax.set_title("图2  2006年-2020年月平均温度（泾河站）")
```




    Text(0.5, 1.0, '图2  2006年-2020年月平均温度（泾河站）')




    
![](https://bode-1257862934.file.myqcloud.com/img/2020_xian_temp_5_1.svg)
    


> ↑图2中，横座标表示月份，纵座标表示气温，橙色点表示2020年气温，蓝色点表示其他年份气温。

2020年在近十五年的月平均温度分布中的位置与图1相似，1、2月气温处于较高位，7月气温处于中位。而8月温度处于较高位，与图1中处于中位不同，是否意味着，相比其他年份，近十五年8月平均温度整体有所下降。这就与直观感受不同了，记得零几年上学时候西安8月初热得宿舍没法呆，这要是气温比之前年份低，那几十年前的人夏天咋过的。

既然夏天不热，冬天不冷，那么全年的温度变化就没那么大。分别看1951年至今和近十五年的数据。



```python
ax = sns.lineplot(x="MONTH", y="TAVGC", hue="TAG", data=temps)
ax.set_title("图3  1951年-2020年月平均温度")
```




    Text(0.5, 1.0, '图3  1951年-2020年月平均温度')




    
![](https://bode-1257862934.file.myqcloud.com/img/2020_xian_temp_7_1.svg)
    



```python
ax = sns.lineplot(x="MONTH", y="TAVGC", hue="TAG", data=temps[temps.YEAH>=2006])
ax.set_title("图4  2006年-2020年月平均温度")
```




    Text(0.5, 1.0, '图4  2006年-2020年月平均温度')




    
![](https://bode-1257862934.file.myqcloud.com/img/2020_xian_temp_8_1.svg)
    


> ↑图3、图4中，横座标表示月份，纵座标表示月度平均气温，橙色线表示2020年气温，蓝色线表示其他年份月度平均气温的平均值。

图3中，2020年7月份的平均温度大约是26.7℃，低于1951年以来其他年份7月份的平均温度（大约为27.2℃）。其他月份的平均气温均大于等于其他年份平均值。从图上看代表2020年的橙色线更加低矮，其他年份均值的蓝色线更加陡峭。这意味着2020全年气温变化更加缓和。

图4中，近十五以来其他年份7月份的平均温度为27.0℃，依然高于2020年，1至4月平均气温也低于2020年。不过两条分布线靠得更近，说明近几年气温是在缓慢变化（上升为主），并未发生明显的气候改变。

综合以上，** 2020年西安确实变温暖了，但夏天却比其他年份要稍微凉快点。**按说全球变暖，可以解释冬天不冷，那夏天不热就说不过去了。只能说全球变暖是一个趋势，具体到一个地区的气温，还跟地理位置、人类影响、山川河流等其他许多因素相关，妥妥的复杂系统。

2020年，西安气温变舒适了

---
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>