JupyterLab是Jupyter Notebook的升级版。

安装：`pip install jupyterlab`，启动：`jupyter lab`。

JupyterLab官网：[https://jupyter.org/](https://jupyter.org/)

## 默认文件保存路径

查看JupyterLab默认文件保存路径：

    import os
    os.path.abspath('.')

## 快捷键

### 编辑模式快捷键

编辑模式即cell编辑模式，可使用以下快捷键：
快捷键作用说明Esc切换到命令模式Ctrl+Enter运行本单元Shift+Enter运行本单元，选中下一单元新单元默认为命令模式Alt+Enter运行本单元，在下面插入一单元新单元默认为编辑模式Ctrl+Up跳到单元开头，或者Ctrl+HomeCtrl+Down跳到单元末尾，或者Ctrl+EndCtrl+Left跳到左边一个字首Ctrl+Right跳到右边一个字首
### 命令模式快捷键

退出cell编辑模式，即可使用命令模式快捷键：
快捷键作用说明Enter进入编辑模式Y单元转入 code 状态M单元转入 markdown 状态R单元转入 raw 状态1设定 1 级标题仅在 markdown 状态下时建议使用，如果单元处于其他状态，则会强制切换到 markdown 状态
## 代码格式化

JupyterLab本身并不支持代码格式化，需要安装jupyterlab_code_formatter插件：`pip install jupyterlab_code_formatter`。

插件jupyterlab_code_formatter支持Python常见的代码格式化包，如autopep8、black、isort等，
插件安装完成后，需要安装Python代码格式化包。

插件默认支持isort和black包，安装这两个包后续会避免很多问题，安装命令：`pip install black isort`。

重启JupyterLab，点击JupyterLab左侧栏插件图标，在INSTALLED列表下，可看到jupyterlab_code_formatter已安装。

### 格式化方式

最简单的方式是通过鼠标右键菜单来格式化代码：右键 -> Format cell。

也可通过工具栏按钮来格式化代码，在笔记本上方工具栏中有一个格式化按钮。单击按钮会对单元格进行代码格式化。

另外，可以设置保存笔记本自动格式化代码：Settings -> Settings Editor -> Jupyterlab Code Formatter -> Auto format config。

## 使用

    import pandas as pd
    import matplotlib.pyplot as plt
    plt.rcParams['font.sans-serif'] = 'SimHei' # 设置中文显示
    ## 行命令，将图表直接嵌入到Notebook之中
    %matplotlib inline
    1.加载数据
    data1=pd.read_excel('1.xlsx', sheet_name='sheet1')
    data2=pd.read_excel('2.xlsx', sheet_name='sheet2')
    data=pd.concat([data1,data2], axis=0) # 按行拼接
    data.head(5)
    data.info()
    2.数据清洗
    2.1数据预处理（重复值、缺失值、格式调整）
    data.drop_duplicates(keep='first', inplace=True) # 删除重复记录
    data.dropna(axis=1, inplace=True) # 按列删除NA列并修改源数据
    data.dropna(axis=0, how='any', inplace=True) # 删除有NA的整行数据
    格式调整
    def data_deal(number):
    new_number += 1
    return new_number
    data['新列'] = data['列'].map(data_deal)
    2.2异常值处理
    data.describe()
    data = data[data['金额'] != 0] # 数据量小可以采用直接删除
    data.drop(columns=['列'], inplace=True, axis=1) # 删除列
    data.reset_index(drop=True, inplace=True) # 更新索引
    3.数据规整
    时间提取
    data['time'] = pd.to_datetime(data['字符串时间'])
    data['hour'] = data['time'].dt.hour
    data['minute'] = data['time'].dt.minute
    data['month'] = data['time'].dt.month
    4.数据分析
    round(data['列'].mean(), 2) # 求平均
    dishes_count = data['列'].value_counts()[:10] # 频数统计，取前10
    分组求和
    group_sum = data[['列1', '列2', '列3']].groupby(by='列1').sum()
    sort_counts = group_sum.sort_values(by='列', ascending=False) # 降序排序
    data['列'] = data['列'].str.strip()
    data.groupby(['月份', '列']).size().unstack()
    5.数据可视化
    dishes_count.plot(kind='line', color=['r']) # 折线图
    dishes_count.plot(kind='bar', fontsize=16, color=['r','b', 'g']) # 直方图
    plt.title('标题')
    plt.xlabel('x轴', fontsize=16)
    plt.ylabel('y轴', fontsize=16)
    for x,y in enumerate(dishes_count):
    plt.text(x, y+2, y, ha='center', fontsize=12) # 水平居中显示


Python数据科学平台JupyterLab学习笔记

## Cocosmos

是一个在线探索宇宙网站，提供丰富的宇宙探索和相关科学知识，展示宇宙奇妙之处的同时，还提供有关天文学、宇宙物理学和太空探索的信息。

通过精美的图像、令人惊叹的视频和生动的文字描述，用户可以深入了解宇宙的不可思议之处。无论是对恒星、行星、星系还是黑洞等宇宙现象的兴趣，该网站都能满足不同用户的需求。

## 网站地址

Cocosmos：[https://cocosmos.online/](https://cocosmos.online/)


Cocosmos-在线探索宇宙 掌上宇宙

## 广播迷

是一个广播电台频道大全的公益网站，在线听广播和电视直播，包括广播电台2050个频道和在线电视直播2146个频道。

广播迷免费为广大听友提供全方位的网上听广播服务，通过交流与分享，以达到公益传递与分享之目的，目前收集电台资讯、电台介绍、节目主持人信息、节目时间表、广播节目稿、各地电台收听频率等内容，非常丰富。

## 网站地址

广播迷：[http://www.guangbomi.com/](http://www.guangbomi.com/)

## 类似网站

- OneStop Radio：[https://theonestopradio.com/](https://theonestopradio.com/)
- Code Radio：[https://coderadio.freecodecamp.org/](https://coderadio.freecodecamp.org/)
- 好趣网：[http://tv.haoqu99.com/](http://tv.haoqu99.com/)
- BIG-Radio：[https://big-radio.net/zh/](https://big-radio.net/zh/)


广播迷-广播电台频道大全 在线听广播和电视直播

DataFrame数据框是一个表格型的数据结构，设计初衷是将[Series](__GHOST_URL__/post/21/)的使用场景从一维拓展到多维。DataFrame既有行索引，也有列索引。

- 行索引：index
- 列索引：columns
- 值：values(NumPy二维数组)

## 创建DataFrame

字典嵌套列表创建数据框：

    import pandas as pd
    d = {"Name": ["Alex", "Bob", "Clarke"], "Age": [10, 11, 12]}
    df = pd.DataFrame(d, index=["a", "b", "c"])  # 添加行索引
    print(df)
    输出
    Name  Age
    a    Alex   10
    b     Bob   11
    c  Clarke   12

列表创建数据框：

    data = [["Alex", 10], ["Bob", 11], ["Clarke", 12]]  # 嵌套列表
    df = pd.DataFrame(data, columns=["Name", "Age"])  # 添加列标签索引
    print(df)
    输出
    Name  Age
    0    Alex   10
    1     Bob   11
    2  Clarke   12

列表嵌套字典创建数据框：

    data = [{"Name": "Alex", "Age": 12}, {"Name": "Bob", "Age": 16, "Sex": "0"}]
    df = pd.DataFrame(data)
    print(df)
    输出
    Name  Age  Sex
    0  Alex   12  NaN
    1   Bob   16    0

## 基本属性和方法

    d = {"Name": ["Alex", "Bob", "Clarke"], "Age": [10, 11, 12]}
    df = pd.DataFrame(d, index=["a", "b", "c"])
    print(df.shape)  # 形状，查看维度，几行几列
    print(df.columns)  # 列索引
    print(df.index)  # 行索引
    print(df.values)  # 二维数组数据
    print(df.dtypes)  # 查看每列数据类型
    print(df.Age.dtype)  # 查看指定列数据类型
    print(df.describe())  # 查看每列描述性统计量
    print(df.info())  # 查看数据框基本信息，维度、列名称、数据格式、所占空间等
    print(df.head(2))  # 查看前几条数据，默认5
    print(df.tail(2))  # 查看后几条数据，默认5

## 索引

### 列索引

对列进行索引，通过类似字典的方式，或通过属性的方式。

可以将DataFrame的列获取为一个Series，返回的Series拥有原DataFrame相同的索引，且name属性也已经设置好了，就是相应的列名。

列索引选取数据列：

    d = {"Name": ["Alex", "Bob"], "Age": [10, 11], "Sex": [0, 1]}
    df = pd.DataFrame(d)
    print(df["Age"])  ## 或 df.Age
    输出
    0    10
    1    11
    Name: Age, dtype: int64
    print(df[["Name", "Sex"]])  # 一次取多列得到的类型是：数据框

### 行索引

数据框默认先取列索引，不能直接取行索引，取行索引使用.loc[]加index，或使用.iloc[]加整数来取行索引。同样返回一个Series，index为原来的columns。

行索引选取数据行：

    d = {"Name": ["Alex", "Bob", "Clarke"], "Age": [10, 11, 18], "Sex": [0, 1, 0]}
    df = pd.DataFrame(d, index=["a", "b", "c"])
    print(df.loc["a"])
    输出
    Name    Alex
    Age       10
    Sex        0
    Name: a, dtype: object
    print(df.loc[["a", "c"]])  # 一次取多行得到的类型是：数据框
    print(df.iloc[[0, 2]])

### 元素索引

    print(df["Name"]["a"])  # 先取列，再取行
    print(df.loc["a"]["Name"])  # 先取行，再取列
    print(df.loc["a", "Name"])  # Alex
    print(df.iloc[0, 0])  # Alex

### 层次化索引

创建多层行索引，隐式构造：

    index = [
    ["1班", "1班", "1班", "2班", "2班", "2班"],
    ["张三", "李四", "王五", "赵六", "孙七", "周八"],
    ]
    columns = [
    ["期中", "期中", "期中", "期末", "期末", "期末"],
    ["语文", "数学", "英语", "语文", "数学", "英语"],
    ]
    data = [
    [70, 80, 88, 85, 66, 97],
    [90, 87, 78, 85, 95, 77],
    [70, 80, 88, 75, 96, 95],
    [75, 84, 80, 85, 76, 97],
    [71, 80, 68, 85, 96, 87],
    [70, 81, 88, 85, 96, 93],
    ]
    df = pd.DataFrame(data, index=index, columns=columns)
    print(df)
    """
    期中          期末
    语文 数学 英语 语文 数学 英语
    1班 张三  70  80  88   85  66   97
    李四  90  87  78   85  95   77
    王五  70  80  88   75  96   95
    2班 赵六  75  84  80   85  76   97
    孙七  71  80  68   85  96   87
    周八  70  81  88   85  96   93
    """

显示构造，pd.MultiIndex.from_arrays()使用数组，还可以使用元组from_tuples()，使用笛卡尔积from_product()。

### 索引堆叠

    index = pd.MultiIndex.from_product([["1班", "2班"], ["张三", "李四", "王五"]])
    columns = pd.MultiIndex.from_product([["期中", "期末"], ["语文", "数学", "英语"]])
    data = [
    [70, 80, 88, 85, 66, 97],
    [90, 87, 78, 85, 95, 77],
    [70, 80, 88, 75, 96, 95],
    [75, 84, 80, 85, 76, 97],
    [71, 80, 68, 85, 96, 87],
    [70, 81, 88, 85, 96, 93],
    ]
    df = pd.DataFrame(data, index=index, columns=columns)
    df2 = df.stack()  # 默认将最里层列索引变成行索引
    df3 = df2.unstack()  # 将行索引变成列索引

## 切片

直接用中括号时：索引优先对列进行操作，切片优先对行进行操作。

行切片：

    d = {"Name": ["Alex", "Bob", "Clarke"], "Age": [10, 11, 18], "Sex": [0, 1, 0]}
    df = pd.DataFrame(d, index=["a", "b", "c"])
    print(df[0:2])  # 左闭右开
    print(df["a":"c"])  # 左闭右闭

列切片，须先进行行切片：

    print(df.loc[:, "Name":"Sex"])
    print(df.iloc[:, 0:2])

总结:

- 取一行或一列：索引
- 取连续的多行或多列：切片
- 取不连续多行或多列：中括号

## DataFrame运算

DataFrame之间的运算，会自动对齐索引进行运算。如果索引不对应，则补NaN，DataFrame没有广播机制。同样，可以使用add()函数来填充数据。

## 聚合函数

    d = [[4, 1, 9], [2, 1, 8], [1, 3, 2]]
    df = pd.DataFrame(d)
    df.count()  # 非空元素的数量
    df.values.sum()  # 所有数之和
    df.sum()  # 默认axis=0，对列求和
    df.mean()  # 平均值
    df.max()  # 最大值，最小值为 min()
    df.median()  # 中位数
    df.std()  # 标准差，方差为 var()
    df.value_counts()  # 统计元素出现次数
    df.cumsum()  # 累加
    df.cov()  # 协方差
    df.corr()  # 所有特征相关系数
    df.corrwith(df[1])  # 单一特征相关系数


Python数据分析模块pandas之DataFrame数据框

pandas是基于[NumPy](__GHOST_URL__/post/17/)的一种工具，该工具是为解决数据分析任务而创建的。安装pandas：`pip install pandas`

pandas的主要数据结构是Series(一维数据)与DataFrame(二维数据)，这两种数据结构足以处理金融、统计、社会科学、工程等领域里的大多数案例。

Series序列类似于一维数组，由两部分组成：

- values：一组数据(ndarray类型)
- index：相关的数据索引标签

Series可以看做是一个有序的字典结构。

## 创建Series

由列表或数组创建：

    import pandas as pd
    s = pd.Series([1, 2, 3])
    print(s)
    输出
    0    1
    1    2
    2    3
    dtype: int64
    print(s.values)  # 一维数组：[1 2 3]
    print(list(s.index))  # 索引：[0, 1, 2]
    s.index = ["A", "B", "C"]  # 修改索引
    s.index = list("ABC")  # 修改索引
    print(s.A, s["C"])  # 通过索引获取值 1 3

由字典创建：

    d = {"a": 1, "b": 2, "c": 3}
    s = pd.Series(d)
    print(s)
    输出
    a    1
    b    2
    c    3
    dtype: int64

## 索引

显示索引：

- 使用index中的元素作为索引值
- 使用.loc[]（推荐）

    d = {"a": 1, "b": 2, "c": 3}
    s = pd.Series(d)
    print(s[["c", "a"]])  # 一次取多个元素，得到的类型是Series
    输出
    c    3
    a    1
    dtype: int64
    print(s.loc[["c", "a"]])

隐式索引:

- 使用整数作为索引值
- 使用.iloc

[`print(s[[0, 2]])`](%E6%8E%A8%E8%8D%90)
[`print(s.iloc[[2, 0]])`](%E6%8E%A8%E8%8D%90)

[Series可以创建多层索引，可以参考下面的DataFrame。](%E6%8E%A8%E8%8D%90)

## [切片](%E6%8E%A8%E8%8D%90)

[`d = {"a": 1, "b": 2, "c": 3, "d": 4}`](%E6%8E%A8%E8%8D%90)
[`s = pd.Series(d)`](%E6%8E%A8%E8%8D%90)

# 隐式切片：左闭右开

print(s[1:3])
print(s.iloc[1:3])

# 输出

# b    2

# c    3

# dtype: int64

# 显示切片：左闭右闭

print(s["b":"d"])
print(s.loc["b":"d"])

## [基本属性和方法](%E6%8E%A8%E8%8D%90)

[基本属性：](%E6%8E%A8%E8%8D%90)

[`d = {"a": 1, "b": 2, "c": 3, "d": 4}`](%E6%8E%A8%E8%8D%90)
[`s = pd.Series(d, name="abcd")`](%E6%8E%A8%E8%8D%90)
[`print(s.shape)  # 形状：(4,)`](%E6%8E%A8%E8%8D%90)
[`print(s.size)  # 元素个数：4`](%E6%8E%A8%E8%8D%90)
[`print(s.index)  # 索引：Index(['a', 'b', 'c', 'd'], dtype='object')`](%E6%8E%A8%E8%8D%90)
[`print(s.values)  # 值：[1 2 3 4]`](%E6%8E%A8%E8%8D%90)
[`print(s.name)  # 索引名字：abcd`](%E6%8E%A8%E8%8D%90)

[方法：](%E6%8E%A8%E8%8D%90)

[`print(s.head(3))  # 查看前几条数据，默认5`](%E6%8E%A8%E8%8D%90)
[`print(s.tail(3))  # 查看后几条数据，默认5`](%E6%8E%A8%E8%8D%90)

s["b"] = None
print(s.isnull())  # isnull判断是否为空，notnull判断是否不为空

# 输出

# a    False

# b     True

# c    False

# d    False

# Name: abcd, dtype: bool

# 过滤掉空值

print(s[s.notnull()])
print(s[~s.isnull()])  # ~ 取反

## [Series运算](%E6%8E%A8%E8%8D%90)

[适用于NumPy的数组运算也适用于Series。](%E6%8E%A8%E8%8D%90)

[Series之间的运算，会自动对齐索引进行运算。如果索引不对应，则补NaN，Series没有广播机制。可以使用add()函数来填充数据。](%E6%8E%A8%E8%8D%90)

[`s1 = pd.Series([1, 3, 44])`](%E6%8E%A8%E8%8D%90)
[`s2 = pd.Series([11, 2, 8, 6])`](%E6%8E%A8%E8%8D%90)
[`print(s1 + s2)`](%E6%8E%A8%E8%8D%90)
[`print(s1.add(s2, fill_value=0))  # 先填充0，再相加`](%E6%8E%A8%E8%8D%90)


Python数据分析模块pandas之Series序列

这里是 aboss.top 的自留地。写了十几年野路子代码，攒了些摸爬滚打的经验，做成系列课程慢慢讲；也留了一小块地方，记记代码之外的胡思乱想。