master
aolingwen 6 years ago
parent 001d48028b
commit f73bad6e92

@ -53,7 +53,7 @@ Python.
部分转义字符: 部分转义字符:
|转义字符 | 描述 | |转义字符 | 描述 |
| ------------ | ------------ | | :-: | :-: |
| \ | (在行尾时) 续行符 | | \ | (在行尾时) 续行符 |
| \\\ | 反斜杠符号 | | \\\ | 反斜杠符号 |
| \' | 单引号 | | \' | 单引号 |
@ -78,7 +78,7 @@ Python.
字符串可以使用`+`号和`*`号进行运算。可以组合和复制,运算后会生成一个新的字符串。 字符串可以使用`+`号和`*`号进行运算。可以组合和复制,运算后会生成一个新的字符串。
|Python 表达式| 结果| 描述| |Python 表达式| 结果| 描述|
| ------------ | ------------ | ------------ | | :-: | :-: | :-: |
|len("abcd")| 4| 计算元素个数| |len("abcd")| 4| 计算元素个数|
|"123" + "456"| "123456"| 连接| |"123" + "456"| "123456"| 连接|
|"Hi!" * 4| 'Hi!Hi!Hi!Hi!'| 复制| |"Hi!" * 4| 'Hi!Hi!Hi!Hi!'| 复制|
@ -89,7 +89,7 @@ Python.
字符串包含了以下内置函数 字符串包含了以下内置函数
| 函数名 | 描述 | | 函数名 | 描述 |
| ------------ | ------------ | | :-: | :-: |
| len(list)|计算字符串长度| | len(list)|计算字符串长度|
| string.capitalize()|字母字符串首字母大写| | string.capitalize()|字母字符串首字母大写|
| string.split(str)|将字符串按`str`的形式分割| | string.split(str)|将字符串按`str`的形式分割|
@ -130,21 +130,21 @@ False
布尔值可以用`and`、`or`和`not`运算。 布尔值可以用`and`、`or`和`not`运算。
`and`运算是`与运算`,只有所有都为`True``and`运算结果才是`True` `and`运算是**与运算**,只有所有都为`True``and`运算结果才是`True`
``` ```
>>> 5 > 3 and 3 > 1 >>> 5 > 3 and 3 > 1
True True
``` ```
`or`运算是`或运算`,只要其中有一个为`True``or`运算结果就是`True` `or`运算是**或运算**,只要其中有一个为`True``or`运算结果就是`True`
``` ```
>>> 5 > 3 or 1 > 3 >>> 5 > 3 or 1 > 3
True True
``` ```
`not`运算是`非运算`,它是一个单目运算符,把`True`变成`False``False`变成`True` `not`运算是**非运算**,它是一个单目运算符,把`True`变成`False``False`变成`True`
``` ```
>>> not 1 > 2 >>> not 1 > 2

@ -12,7 +12,7 @@
列表是最常用的`Python`数据类型,它可以作为一个方括号内的逗号分隔值出现。列表的数据项不需要具有相同的类型创建一个列表,只要把逗号分隔的不同的数据项使用方括号括起来即可。 列表是最常用的`Python`数据类型,它可以作为一个方括号内的逗号分隔值出现。列表的数据项不需要具有相同的类型创建一个列表,只要把逗号分隔的不同的数据项使用方括号括起来即可。
简单来说列表是由一系列元素按特定顺序排列组成。你可以创建包含字母表中所有字母/数字`0-9`或一些字符串的列表;可以将其他数据类型放入列表中,甚至可以将另一个列表放在列表中。 简单来说列表是由一系列元素按特定顺序排列组成。你可以创建包含字母表中所有字母、数字或一些字符串的列表;可以将其他数据类型放入列表中,甚至可以将另一个列表放在列表中。
在`Python`中,用方括号`[]`来表示列表,并用逗号来分隔其中的元素。例如: 在`Python`中,用方括号`[]`来表示列表,并用逗号来分隔其中的元素。例如:
@ -30,7 +30,7 @@
先可以考虑前面所学的字符串类型的数据访问,例如有一字符串:`"abcd"`。如果我们需要看它的某个特定位置上的字符是什么,则只要知道它的索引位置就行了,索引位置如下图: 先可以考虑前面所学的字符串类型的数据访问,例如有一字符串:`"abcd"`。如果我们需要看它的某个特定位置上的字符是什么,则只要知道它的索引位置就行了,索引位置如下图:
| 字符串 |a | b | c | d | | 字符串 |a | b | c | d |
| ------------ | ------------ | ------------ | ------------ | ------------ | | :-: | :-: | :-: | :-: | :-: |
| 索引 -> | 0 | 1 | 2 | 3 | | 索引 -> | 0 | 1 | 2 | 3 |
|索引 <-|0|-3|-2|-1| |索引 <-|0|-3|-2|-1|
@ -151,7 +151,7 @@ h
与字符串一样,列表之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制,运算后会生成一个新的列表。 与字符串一样,列表之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制,运算后会生成一个新的列表。
|Python 表达式| 结果| 描述| |Python 表达式| 结果| 描述|
| ------------ | ------------ | ------------ | | :-: | :-: | :-: |
|len([1, 2, 3])| 3| 计算元素个数| |len([1, 2, 3])| 3| 计算元素个数|
|[1, 2, 3] + [4, 5, 6]| [1, 2, 3, 4, 5, 6]| 连接| |[1, 2, 3] + [4, 5, 6]| [1, 2, 3, 4, 5, 6]| 连接|
|['Hi!',] * 4| ['Hi!', 'Hi!', 'Hi!', 'Hi!']| 复制| |['Hi!',] * 4| ['Hi!', 'Hi!', 'Hi!', 'Hi!']| 复制|
@ -162,7 +162,7 @@ h
`Python`列表包含了以下内置函数 `Python`列表包含了以下内置函数
| 函数名 | 描述 | | 函数名 | 描述 |
| ------------ | ------------ | | :-: | :-: |
| len(list)|计算列表元素个数。| | len(list)|计算列表元素个数。|
| max(list)|返回列表中元素最大值。| | max(list)|返回列表中元素最大值。|
| min(list)|返回列表中元素最小值。| | min(list)|返回列表中元素最小值。|
@ -270,7 +270,7 @@ print(tup3)
与列表一样,元组之间可以使用`+`号和`*`号进行运算。这就意味着他们可以组合和复制,运算后会生成一个新的元组。 与列表一样,元组之间可以使用`+`号和`*`号进行运算。这就意味着他们可以组合和复制,运算后会生成一个新的元组。
|Python 表达式| 结果| 描述| |Python 表达式| 结果| 描述|
| ------------ | ------------ | ------------ | | :-: | :-: | :-: |
|len((1, 2, 3))| 3| 计算元素个数| |len((1, 2, 3))| 3| 计算元素个数|
|(1, 2, 3) + (4, 5, 6)| (1, 2, 3, 4, 5, 6)| 连接| |(1, 2, 3) + (4, 5, 6)| (1, 2, 3, 4, 5, 6)| 连接|
|('Hi!',) * 4| ('Hi!', 'Hi!', 'Hi!', 'Hi!')| 复制| |('Hi!',) * 4| ('Hi!', 'Hi!', 'Hi!', 'Hi!')| 复制|
@ -281,7 +281,7 @@ print(tup3)
`Python`元组包含了以下内置函数 `Python`元组包含了以下内置函数
| 函数名 | 描述 | | 函数名 | 描述 |
| ------------ | ------------ | | :-: | :-: |
| len(tuple)|计算元组元素个数。| | len(tuple)|计算元组元素个数。|
| max(tuple)|返回元组中元素最大值。| | max(tuple)|返回元组中元素最大值。|
| min(tuple)|返回元组中元素最小值。| | min(tuple)|返回元组中元素最小值。|
@ -404,7 +404,7 @@ False
字典是`Python`最强大的数据类型之一,通过`键-值(key-value)对`的方式建立数据对象之间的映射关系。字典的每个键-值对用冒号`:`分割,每个`键-值对`间用逗号`,`分隔开,字典是包含在`{}`中。 字典是`Python`最强大的数据类型之一,通过`键-值(key-value)对`的方式建立数据对象之间的映射关系。字典的每个键-值对用冒号`:`分割,每个`键-值对`间用逗号`,`分隔开,字典是包含在`{}`中。
每个`键`都与一个值相关联,我们可以使用键来访问与之相关联的值。与`键`相关联的值可以是数字、字符串、列表乃至字典。事实上,可将任何`Python`对象用作字典中的值。 每个**键**都与一个值相关联,我们可以使用键来访问与之相关联的值。与**键**相关联的值可以是数字、字符串、列表乃至字典。事实上,可将任何`Python`对象用作字典中的值。
### 创建字典 ### 创建字典
@ -412,7 +412,7 @@ False
`d = {key1 : value1, key2 : value2 }` `d = {key1 : value1, key2 : value2 }`
`键`必须是唯一的,但值则不必。 **键**必须是唯一的,但值则不必。
值可以取任何数据类型,但`键`必须是不可变的,如字符串,数字或元组。 值可以取任何数据类型,但`键`必须是不可变的,如字符串,数字或元组。
@ -440,7 +440,7 @@ dict['Age']: 7
### 添加元素 ### 添加元素
字典是一种动态数据结构,可随时在字典中添加`键—值对`。要添加`键—值对`时,可依次指定字典名、`键`和`键`对应的值。 字典是一种动态数据结构,可随时在字典中添加**键—值对**。要添加**键—值对**时,可依次指定字典名、**键**和**键**对应的值。
下面在字典`menu`中添加两道菜的菜名和价格: 下面在字典`menu`中添加两道菜的菜名和价格:
```python ```python

@ -32,7 +32,7 @@ except Exception,e:
except 块 #处理异常的代码 except 块 #处理异常的代码
``` ```
如果`try`中的代码块没有出现异常,则跳过`excep`t块执行后面的代码如果出现异常并被`excep`t捕获则执行`except`块中的代码,如果出现异常但未被`except`捕获,则继续向外层抛出。如果所有层都没有捕获并处理该异常,则程序终止并将异常抛给用户。 如果`try`中的代码块没有出现异常,则跳过`except`块执行后面的代码,如果出现异常并被`except`捕获,则执行`except`块中的代码,如果出现异常但未被`except`捕获,则继续向外层抛出。如果所有层都没有捕获并处理该异常,则程序终止并将异常抛给用户。
## else与finally ## else与finally

@ -1,7 +1,7 @@
# Chapter1 Python语言 # Chapter1 Python语言
由于 Python 语言的简洁性、易读性以及可扩展性,在国外用 Python 做科学计算的研究机构日益增多,一些知名大学已经采用 Python 来教授程序设计课程。例如卡耐基梅隆大学的编程基础、麻省理工学院的计算机科学及编程导论就使用 Python 语言讲授。众多开源的科学计算软件包都提供了 Python 的调用接口,例如著名的计算机视觉库 OpenCV 、三维可视化库 VTK 、医学图像处理库 ITK 。而 Python 专用的科学计算扩展库就更多了例如如下3个十分经典的科学计算扩展库NumPy、Pandas 和 matplotlib ,它们分别为 Python 提供了快速数组处理、数值运算以及绘图功能。因此Python语言及其众多的扩展库所构成的开发环境十分适合工程技术、科研人员处理实验数据、制作图表,甚至开发科学计算应用程序。 由于 Python 语言的简洁性、易读性以及可扩展性,在国外用 Python 做科学计算的研究机构日益增多,一些知名大学已经采用 Python 来教授程序设计课程。例如卡耐基梅隆大学的编程基础、麻省理工学院的计算机科学及编程导论就使用 Python 语言讲授。众多开源的科学计算软件包都提供了 Python 的调用接口,例如著名的计算机视觉库 OpenCV 、三维可视化库 VTK 、医学图像处理库 ITK 。而 Python 专用的科学计算扩展库就更多了例如如下3个十分经典的科学计算扩展库NumPy、Pandas 和 Matplotlib ,它们分别为 Python 提供了快速数组处理、结构化数据处理以及绘图功能。因此 Python 语言及其众多的扩展库所构成的开发环境十分适合工程技术、科研人员处理实验数据、制作图表,甚至开发科学计算应用程序。
Python语言相关实训已在`educoder`平台上提供,若感兴趣可以输入链接进行体验。 Python 语言相关实训已在`educoder`平台上提供,若感兴趣可以输入链接进行体验。
链接https://www.educoder.net/paths/85 链接https://www.educoder.net/paths/85

@ -128,7 +128,7 @@ print(a.argmin())
有的时候,我们在统计时需要根据轴来统计。举个例子,公司员工的基本工资,绩效工资,年终奖的信息如下: 有的时候,我们在统计时需要根据轴来统计。举个例子,公司员工的基本工资,绩效工资,年终奖的信息如下:
| 工号 | 基本工资 | 绩效工资 | 年终奖 | | 工号 | 基本工资 | 绩效工资 | 年终奖 |
| ------------ | ------------ | ------------ | ------------ | | :-: | :-: | :-: | :-: |
| 1 | 3000 | 4000 | 20000 | | 1 | 3000 | 4000 | 20000 |
| 2 | 2700 | 5500 | 25000 | | 2 | 2700 | 5500 | 25000 |
| 3 | 2800 | 3000 | 15000 | | 3 | 2800 | 3000 | 15000 |

@ -9,7 +9,7 @@ stack 的意思是堆叠的意思,所谓的堆叠就是将两个 ndarray 对
假如你是某公司的 HR ,需要记录公司员工的一些基本信息。可能你现在已经记录了如下信息: 假如你是某公司的 HR ,需要记录公司员工的一些基本信息。可能你现在已经记录了如下信息:
| 工号 | 姓名 | 出生年月 | 联系电话 | | 工号 | 姓名 | 出生年月 | 联系电话 |
| ------------ | ------------ | ------------ | ------------ | | :-: | :-: | :-: | :-: |
| 1 | 张三 | 1988.12 | 13323332333 | | 1 | 张三 | 1988.12 | 13323332333 |
| 2 | 李四 | 1987.2 | 15966666666 | | 2 | 李四 | 1987.2 | 15966666666 |
| 3 | 王五 | 1990.1 | 13777777777 | | 3 | 王五 | 1990.1 | 13777777777 |
@ -18,7 +18,7 @@ stack 的意思是堆叠的意思,所谓的堆叠就是将两个 ndarray 对
世界上没有不变的需求,你的老板让你现在记录一下公司所有员工的居住地址和户籍地址。此时你只好屁颠屁颠的记录这些附加信息。然后可能会有这样的结果: 世界上没有不变的需求,你的老板让你现在记录一下公司所有员工的居住地址和户籍地址。此时你只好屁颠屁颠的记录这些附加信息。然后可能会有这样的结果:
| 居住地址 | 户籍地址 | | 居住地址 | 户籍地址 |
| ------------ | ------------ | | :-: | :-: |
| 江苏省南京市禄口机场宿舍202 | 江西省南昌市红谷滩新区天月家园A座2201 | | 江苏省南京市禄口机场宿舍202 | 江西省南昌市红谷滩新区天月家园A座2201 |
| 江苏省南京市禄口机场宿舍203 | 湖南省株洲市天元区新天华府11栋303 | | 江苏省南京市禄口机场宿舍203 | 湖南省株洲市天元区新天华府11栋303 |
| 江苏省南京市禄口机场宿舍204 | 四川省成都市武侯祠安置小区1栋701 | | 江苏省南京市禄口机场宿舍204 | 四川省成都市武侯祠安置小区1栋701 |
@ -27,7 +27,7 @@ stack 的意思是堆叠的意思,所谓的堆叠就是将两个 ndarray 对
接下来你需要把之前记录的信息和刚刚记录好的附加信息整合起来,变成这样: 接下来你需要把之前记录的信息和刚刚记录好的附加信息整合起来,变成这样:
| 工号 | 姓名 | 出生年月 | 联系电话 | 居住地址 | 户籍地址 | | 工号 | 姓名 | 出生年月 | 联系电话 | 居住地址 | 户籍地址 |
| ------------ | ------------ | ------------ | ------------ | ------------ | ------------ | | :-: | :-: | :-: | :-: | :-: | :-: |
| 1 | 张三 | 1988.12 | 13323332333 | 江苏省南京市禄口机场宿舍202 | 江西省南昌市红谷滩新区天月家园A座2201 | | 1 | 张三 | 1988.12 | 13323332333 | 江苏省南京市禄口机场宿舍202 | 江西省南昌市红谷滩新区天月家园A座2201 |
| 2 | 李四 | 1987.2 | 15966666666 | 江苏省南京市禄口机场宿舍203 | 湖南省株洲市天元区新天华府11栋303 | | 2 | 李四 | 1987.2 | 15966666666 | 江苏省南京市禄口机场宿舍203 | 湖南省株洲市天元区新天华府11栋303 |
| 3 | 王五 | 1990.1 | 13777777777 | 江苏省南京市禄口机场宿舍204 | 四川省成都市武侯祠安置小区1栋701 | | 3 | 王五 | 1990.1 | 13777777777 | 江苏省南京市禄口机场宿舍204 | 四川省成都市武侯祠安置小区1栋701 |
@ -74,7 +74,7 @@ print(np.hstack((a,b,c)))
你还是某公司的 HR ,你记录了公司员工的一些信息,如下: 你还是某公司的 HR ,你记录了公司员工的一些信息,如下:
| 工号 | 姓名 | 出生年月 | 联系电话 | | 工号 | 姓名 | 出生年月 | 联系电话 |
| ------------ | ------------ | ------------ | ------------ | | :-: | :-: | :-: | :-: |
| 1 | 张三 | 1988.12 | 13323332333 | | 1 | 张三 | 1988.12 | 13323332333 |
| 2 | 李四 | 1987.2 | 15966666666 | | 2 | 李四 | 1987.2 | 15966666666 |
| 3 | 王五 | 1990.1 | 13777777777 | | 3 | 王五 | 1990.1 | 13777777777 |
@ -83,14 +83,14 @@ print(np.hstack((a,b,c)))
今天有两位新同事入职,你需要记录他们的信息,如下: 今天有两位新同事入职,你需要记录他们的信息,如下:
| 工号 | 姓名 | 出生年月 | 联系电话 | | 工号 | 姓名 | 出生年月 | 联系电话 |
| ------------ | ------------ | ------------ | ------------ | | :-: | :-: | :-: | :-: |
| 5 | 刘七 | 1986.5 | 13323332331 | | 5 | 刘七 | 1986.5 | 13323332331 |
| 6 | 胡八 | 1997.3 | 15966696669 | | 6 | 胡八 | 1997.3 | 15966696669 |
然后你需要将新入职同事的信息和已经入职的员工信息整合在一起。 然后你需要将新入职同事的信息和已经入职的员工信息整合在一起。
| 工号 | 姓名 | 出生年月 | 联系电话 | | 工号 | 姓名 | 出生年月 | 联系电话 |
| ------------ | ------------ | ------------ | ------------ | | :-: | :-: | :-: | :-: |
| 1 | 张三 | 1988.12 | 13323332333 | | 1 | 张三 | 1988.12 | 13323332333 |
| 2 | 李四 | 1987.2 | 15966666666 | | 2 | 李四 | 1987.2 | 15966666666 |
| 3 | 王五 | 1990.1 | 13777777777 | | 3 | 王五 | 1990.1 | 13777777777 |

@ -1,5 +1,5 @@
# 2.1.4:线性代数 # 2.2.4:线性代数
## numpy的线性代数 ## numpy的线性代数

@ -1,9 +1,9 @@
# 2.1.5:排序和条件筛选 # 2.2.5:排序和条件筛选
## numpy中的快速排序 ## numpy中的快速排序
`numpy`中的排序相对 Python 的更加高效,默认情况下`np.sort`的排序算法是 **快速排序**,也可以选择 **归并排序** **堆排序**。 `numpy`中的排序相对 Python 的更加高效,默认情况下`np.sort`的排序算法是**快速排序**,也可以选择**归并排序**和**堆排序**。
| 类型 |速度 |最坏情况 |工作空间 |稳定性 | | 类型 |速度 |最坏情况 |工作空间 |稳定性 |
| :------------: | :------------: | :------------: | :------------: | :------------: | | :------------: | :------------: | :------------: | :------------: | :------------: |

@ -1,6 +1,6 @@
# Chapter2 Numpy # Chapter2 Numpy
NumPy 是 Python 语言的一个扩充程序库。支持高级大量的维度数组与矩阵运算此外也针对数组运算提供大量的数学函数库。Numpy 内部解除了 Python 的 PIL(全局解释器锁),运算效率极好,是大量机器学习框架的基础库! NumPy 是 Python 语言的一个扩充程序库。支持高级大量的维度数组与矩阵运算此外也针对数组运算提供大量的数学函数库。Numpy 内部解除了 Python 的 PIL(全局解释器锁)运算效率极好,是大量机器学习框架的基础库!
Numpy 相关实训已在`educoder`平台上提供,若感兴趣可以输入链接进行体验。 Numpy 相关实训已在`educoder`平台上提供,若感兴趣可以输入链接进行体验。

Binary file not shown.

After

Width:  |  Height:  |  Size: 12 KiB

@ -1,9 +1,7 @@
# 3.1.1Series对象 # 3.1.1Series对象
## 创建Series对象 ## 创建Series对象
创建`Pandas`的`Series`对象的方法: 创建`Pandas`的`Series`对象的方法:`pd.Series(data,index=index)`
> pd.Series(data,index=index)
其中,`index`是一个可选参数,默认为`np.arange(n)``data`参数支持多种数据类型。 其中,`index`是一个可选参数,默认为`np.arange(n)``data`参数支持多种数据类型。

@ -53,7 +53,7 @@ Out: California 423967
Name: area, dtype: int64 Name: area, dtype: int64
``` ```
*注意:在 `NumPy` 的二维数组里,`data[0]` 返回第一行;而在 `DataFrame` 中,`data['列名']`返回与列名相匹配的那一列。* **注意:在 `NumPy` 的二维数组里,`data[0]` 返回第一行;而在 `DataFrame` 中,`data['列名']`返回与列名相匹配的那一列。**

@ -33,6 +33,7 @@ Out: area pop density
Texas 695662 26448193 38.018740 Texas 695662 26448193 38.018740
``` ```
## 将DataFrame看作二维数组 ## 将DataFrame看作二维数组
`DataFrame`可以看成是一个增强版的二维数组,许多数组操作方式都可以用在`DataFrame`对象上,例如,用`value`属性按行查看数组数据,对`DataFrame`进行转置等等。 `DataFrame`可以看成是一个增强版的二维数组,许多数组操作方式都可以用在`DataFrame`对象上,例如,用`value`属性按行查看数组数据,对`DataFrame`进行转置等等。
```python ```python
In: data.value In: data.value
@ -46,7 +47,7 @@ array(
In: data.T In: data.T
Out: Out:
``` ```
![](/api/attachments/367560) ![](1.jpg)
--- ---
将`DataFrame`看作数组时,我们可以是使用单个行索引获取一行数据。 将`DataFrame`看作数组时,我们可以是使用单个行索引获取一行数据。

@ -3,6 +3,7 @@
## 通用函数:保留索引 ## 通用函数:保留索引
因为`Pandas`是建立在`NumPy`基础之上的,所以`NumPy`的通用函数同样适用于`Pandas`的`Series`和`DataFrame`对象。 因为`Pandas`是建立在`NumPy`基础之上的,所以`NumPy`的通用函数同样适用于`Pandas`的`Series`和`DataFrame`对象。
```Python ```Python
import numpy as np import numpy as np
import pandas as pd import pandas as pd
@ -27,7 +28,9 @@ Out:
``` ```
## 通用函数:索引对齐 ## 通用函数:索引对齐
### Series索引对齐 ### Series索引对齐
假如你要整合两个数据源的数据,其中一个是美国面积最大的三个州的面积数据,另一个是美国人口最多的三个州的人口数据: 假如你要整合两个数据源的数据,其中一个是美国面积最大的三个州的面积数据,另一个是美国人口最多的三个州的人口数据:
```python ```python
# 面积 # 面积
@ -46,9 +49,11 @@ Out:
dtype: float64 dtype: float64
``` ```
对于缺失的数据,`Pandas`会用`NaN`填充,表示空值。这是`Pandas`表示缺失值的方法(后面的关卡会介绍)。这种索引对齐方式是通过`Python`内置的集合运算规则实现的,任何缺失值默认都用`NaN`填充。
对于缺失的数据,`Pandas`会用`NaN`填充,表示空值。这是`Pandas`表示缺失值的方法。这种索引对齐方式是通过`Python`内置的集合运算规则实现的,任何缺失值默认都用`NaN`填充。
### DataFrame索引对齐 ### DataFrame索引对齐
在计算两个`DataFrame`时,类似的索引对齐规则也同样会出现在共同列中: 在计算两个`DataFrame`时,类似的索引对齐规则也同样会出现在共同列中:
```python ```python
A = pd.DataFrame(rng.randint(0, 20, (2, 2)), columns=list('AB')) A = pd.DataFrame(rng.randint(0, 20, (2, 2)), columns=list('AB'))
@ -60,6 +65,7 @@ A:
""" """
B = pd.DataFrame(rng.randint(0, 10, (3, 3)), columns=list('BAC')) B = pd.DataFrame(rng.randint(0, 10, (3, 3)), columns=list('BAC'))
""" """
B: B:
B A C B A C
@ -73,7 +79,9 @@ Out:: A B C
1 13.0 6.0 NaN 1 13.0 6.0 NaN
2 NaN NaN NaN 2 NaN NaN NaN
``` ```
从上面的例子可以发现,两个对象的行列索引可以是不同顺序的,结果的索引会自动按顺序排列。在`Series`中,我们可以通过运算符方法的` fill_value`参数自定义缺失值;这里我们将用`A`中所有值的均值来填充缺失值。 从上面的例子可以发现,两个对象的行列索引可以是不同顺序的,结果的索引会自动按顺序排列。在`Series`中,我们可以通过运算符方法的` fill_value`参数自定义缺失值;这里我们将用`A`中所有值的均值来填充缺失值。
```python ```python
fill = A.stack().mean() # stack()能将二维数组压缩成多个一维数组 fill = A.stack().mean() # stack()能将二维数组压缩成多个一维数组
print(A.add(B,fill_value=fill)) print(A.add(B,fill_value=fill))
@ -83,10 +91,11 @@ Out:
1 13.0 6.0 4.5 1 13.0 6.0 4.5
2 6.5 13.5 10.5 2 6.5 13.5 10.5
``` ```
下表中列举了与`Python`运算符相对应的`Pandas`对象方法。 下表中列举了与`Python`运算符相对应的`Pandas`对象方法。
|Python运算符|Pandas方法 |Python运算符|Pandas方法
|--|--| |:-:|:-:|
|+|add() |+|add()
|-|sub()、substract() |-|sub()、substract()
|\*|mul()、multiply() |\*|mul()、multiply()
@ -96,7 +105,9 @@ Out:
|\*\*|pow() |\*\*|pow()
## 通用函数DataFrame与Series的运算 ## 通用函数DataFrame与Series的运算
`DataFrame`和`Series`的运算规则与`Numpy`中二维数组与一维数组的运算规则是一样的。来看一个常见运算,让一个二维数组减去自身的一行数据。 `DataFrame`和`Series`的运算规则与`Numpy`中二维数组与一维数组的运算规则是一样的。来看一个常见运算,让一个二维数组减去自身的一行数据。
```python ```python
A = rng.randint(10, size=(3, 4)) A = rng.randint(10, size=(3, 4))
A - A[0] A - A[0]
@ -105,7 +116,9 @@ array([[ 0, 0, 0, 0],
[-1, -2, 2, 4], [-1, -2, 2, 4],
[ 3, -7, 1, 4]]) # 根据Numpy的广播规则默认是按行运算的 [ 3, -7, 1, 4]]) # 根据Numpy的广播规则默认是按行运算的
``` ```
在`Pandas`里默认也是按行运算的,如果想按列计算,那么就需要利用前面介绍过的运算符方法,通过设置`axis(轴)`实现
在`Pandas`里默认也是按行运算的,如果想按列计算,那么就需要利用前面介绍过的运算符方法,通过设置`axis(轴)`实现。
```python ```python
df = pd.DataFrame(A, columns=list('QRST')) df = pd.DataFrame(A, columns=list('QRST'))
print(df - df.iloc[0]) print(df - df.iloc[0])
@ -122,5 +135,6 @@ Out:
1 -4 0 -2 2 1 -4 0 -2 2
2 5 0 2 7 2 5 0 2 7
``` ```
`DataFrame/Series`的运算与前面介绍的运算一样,结果的索引都会自动对齐。 `DataFrame/Series`的运算与前面介绍的运算一样,结果的索引都会自动对齐。

@ -1,4 +1,4 @@
# 3.1.6:数值运算与缺失值处理 # 3.1.7:数值运算与缺失值处理
## 选择处理缺失值的方法 ## 选择处理缺失值的方法
一般情况下可以分为两种:一种方法是通过一个覆盖全局的**掩码**表示缺失值,另一种方法是用一个**标签值`sentinel value`**表示缺失值。 一般情况下可以分为两种:一种方法是通过一个覆盖全局的**掩码**表示缺失值,另一种方法是用一个**标签值`sentinel value`**表示缺失值。
@ -12,37 +12,48 @@
- **`None``Python`对象类型的缺失值** - **`None``Python`对象类型的缺失值**
`Pandas`可以使用的第一种缺失值标签是`None`,它是一个`Python`单体对象,由于`None`是一个`Python`对象,所以不能作为任何`NumPy / Pandas`数组类型的缺失值,只能用于`'object'`数组类型(即由` Python`对象构成的数组) `Pandas`可以使用的第一种缺失值标签是`None`,它是一个`Python`单体对象,由于`None`是一个`Python`对象,所以不能作为任何`NumPy / Pandas`数组类型的缺失值,只能用于`'object'`数组类型(即由` Python`对象构成的数组)
```python ```python
np.array([1, None, 3, 4]) np.array([1, None, 3, 4])
Out: array([1, None, 3, 4], dtype=object) Out: array([1, None, 3, 4], dtype=object)
``` ```
- **`NaN`:数值类型的缺失值** - **`NaN`:数值类型的缺失值**
另一种缺失值的标签是`NaN`(全称`Not a Number`),是一种按照`IEEE`浮点数标准设计、在任何系统中都兼容的特殊浮点数: 另一种缺失值的标签是`NaN`(全称`Not a Number`),是一种按照`IEEE`浮点数标准设计、在任何系统中都兼容的特殊浮点数:
```python ```python
vals2 = np.array([1, np.nan, 3, 4]) vals2 = np.array([1, np.nan, 3, 4])
vals2.dtype vals2.dtype
Out: dtype('float64') Out: dtype('float64')
``` ```
**注意:**`NumPy`会为这个数组选择一个原生浮点类型,这意味着和之前的 `object`类型数组不同,这个数组会被编译成`C`代码从而实现快速操作。你可以把`NaN`看作是一个数据类病毒——它会将与它接触过的数据同化。**无论和`NaN`进行何种操作,最终结果都是`NaN`** **注意:**`NumPy`会为这个数组选择一个原生浮点类型,这意味着和之前的 `object`类型数组不同,这个数组会被编译成`C`代码从而实现快速操作。你可以把`NaN`看作是一个数据类病毒——它会将与它接触过的数据同化。**无论和`NaN`进行何种操作,最终结果都是`NaN`**
```python ```python
1 + np.nan 1 + np.nan
0 * np.nan #这两个的结果都为nan 0 * np.nan #这两个的结果都为nan
``` ```
虽然这些累计操作的结果定义是合理的(即不会抛出异常),但是并非总是有效的: 虽然这些累计操作的结果定义是合理的(即不会抛出异常),但是并非总是有效的:
```python ```python
vals2 = np.array([1, np.nan, 3, 4]) vals2 = np.array([1, np.nan, 3, 4])
vals2.sum(), vals2.min(), vals2.max() vals2.sum(), vals2.min(), vals2.max()
Out:(nan, nan, nan) Out:(nan, nan, nan)
``` ```
`NumPy`也提供了一些特殊的累计函数,它们可以忽略缺失值的影响: `NumPy`也提供了一些特殊的累计函数,它们可以忽略缺失值的影响:
```python ```python
np.nansum(vals2), np.nanmin(vals2), np.nanmax(vals2) np.nansum(vals2), np.nanmin(vals2), np.nanmax(vals2)
Out: (8.0, 1.0, 4.0) Out: (8.0, 1.0, 4.0)
``` ```
*谨记,`NaN`是一种特殊的**浮点数**,不是整数、字符串以及其他数据类型。* *谨记,`NaN`是一种特殊的**浮点数**,不是整数、字符串以及其他数据类型。*
- **`Pandas`中`NaN`与`None`的差异** - **`Pandas`中`NaN`与`None`的差异**
虽然`NaN`与`None`各有各的用处,但是`Pandas`把它们看成是可以等价交换的: 虽然`NaN`与`None`各有各的用处,但是`Pandas`把它们看成是可以等价交换的:
```python ```python
pd.Series([1, np.nan, 2, None]) pd.Series([1, np.nan, 2, None])
Out: Out:
@ -55,7 +66,7 @@ Out:
`Pandas`会将没有标签值的数据类型自动转换为`NA`。例如我们将整形数组中的一个值设置为`np.nan`时,这个值就会强制转换成浮点数缺失值`NA`,下表表示`Pandas`对不同类型缺失值的转换规则: `Pandas`会将没有标签值的数据类型自动转换为`NA`。例如我们将整形数组中的一个值设置为`np.nan`时,这个值就会强制转换成浮点数缺失值`NA`,下表表示`Pandas`对不同类型缺失值的转换规则:
|类型|缺失值转换规则|NA标签值 |类型|缺失值转换规则|NA标签值
|--|--|--| |:-:|:-:|:-:|
|floating 浮点型|无变化|np.nan |floating 浮点型|无变化|np.nan
|object 对象类型|无变化|np.nan或None |object 对象类型|无变化|np.nan或None
|integer 整数类型|强制转换为 float64|np.nan |integer 整数类型|强制转换为 float64|np.nan
@ -63,6 +74,7 @@ Out:
## 发现缺失值 ## 发现缺失值
`Pandas`有两种方法可以发现缺失值:`isnull()`和`notnull()`,这俩个中方法皆可用于`Series`和`DataFrame`。每种方法都返回布尔类型的掩码数据。 `Pandas`有两种方法可以发现缺失值:`isnull()`和`notnull()`,这俩个中方法皆可用于`Series`和`DataFrame`。每种方法都返回布尔类型的掩码数据。
```python ```python
data=pd.Series([1,np.nan,'hello',None]) data=pd.Series([1,np.nan,'hello',None])
data.isnull() data.isnull()
@ -74,6 +86,7 @@ Out:
dtype: bool dtype: bool
``` ```
布尔类型掩码数组可以直接作为`Series`或`DataFrame`的索引使用。 布尔类型掩码数组可以直接作为`Series`或`DataFrame`的索引使用。
```python ```python
data[data.notnull()] data[data.notnull()]
Out: Out:
@ -81,9 +94,11 @@ Out:
2 hello 2 hello
dtype: object dtype: object
``` ```
## 处理缺失值 ## 处理缺失值
- dropna()删除缺失值 - dropna()删除缺失值
作用在`Series`对象上时,它的作用和`data[data.notnull()]`一样,而在`DataFrame`上使用它们时需要设置一些参数: 作用在`Series`对象上时,它的作用和`data[data.notnull()]`一样,而在`DataFrame`上使用它们时需要设置一些参数:
```python ```python
df = pd.DataFrame([[1, np.nan, 2], df = pd.DataFrame([[1, np.nan, 2],
[2, 3, 5], [2, 3, 5],
@ -101,7 +116,9 @@ Out:
1 5 1 5
2 6 2 6
``` ```
但是这么做也会把**非缺失值一并剔除**,因为可能有时候只需要剔除全部是缺失值的行或列,或者绝大多数是缺失值的行或列。这些需求可以通过设置`how`或`thresh`参数来满足,它们可以设置剔除行或列缺失值的数量阈值。 但是这么做也会把**非缺失值一并剔除**,因为可能有时候只需要剔除全部是缺失值的行或列,或者绝大多数是缺失值的行或列。这些需求可以通过设置`how`或`thresh`参数来满足,它们可以设置剔除行或列缺失值的数量阈值。
```python ```python
df[3] = np.nan df[3] = np.nan
Out: Out:
@ -122,8 +139,10 @@ Out:
0 1 2 3 0 1 2 3
1 2.0 3.0 5 NaN 1 2.0 3.0 5 NaN
``` ```
- fillna()填充缺失值 - fillna()填充缺失值
有时候你可能并不想移除缺失值,而是想把它们替换成有效的数值。虽然你可以通过`isnull()`方法建立掩码来填充缺失值,但是`Pandas`为此专门提供了一个`fillna()`方法,它将返回填充了缺失值后的数组副本。 有时候你可能并不想移除缺失值,而是想把它们替换成有效的数值。虽然你可以通过`isnull()`方法建立掩码来填充缺失值,但是`Pandas`为此专门提供了一个`fillna()`方法,它将返回填充了缺失值后的数组副本。
```python ```python
data=pd.Series([1, np.nan, 2, None, 3],index=list('abcd') data=pd.Series([1, np.nan, 2, None, 3],index=list('abcd')
data.fillna(0) # 将缺失值填充为0 data.fillna(0) # 将缺失值填充为0
@ -135,6 +154,7 @@ Out
e 3.0 e 3.0
dtype: float64 dtype: float64
``` ```
可以用缺失值前面的有效值来从前往后填充`forward-fill`,也可以用缺失值后面的有效值来从后往前填充`back-fill` 可以用缺失值前面的有效值来从前往后填充`forward-fill`,也可以用缺失值后面的有效值来从后往前填充`back-fill`
```python ```python

Binary file not shown.

After

Width:  |  Height:  |  Size: 11 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 9.3 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 18 KiB

@ -13,7 +13,9 @@ index1
Out Out
MultiIndex(levels=[['California', 'New York', 'Texas'], [2000, 2010]], codes=[[0, 0, 1, 1, 2, 2], [0, 1, 0, 1, 0, 1]]) MultiIndex(levels=[['California', 'New York', 'Texas'], [2000, 2010]], codes=[[0, 0, 1, 1, 2, 2], [0, 1, 0, 1, 0, 1]])
``` ```
`MultiIndex`里面有一个`levels`属性表示索引的等级——这样做可以将州名和年份作为每个数据点的不同标签。如果将前面创建的`pop`的索引重置`reindex`为`MultiIndex`,就会看到层级索引。其中前两列表示`Series`的多级索引值,第三列式数据。 `MultiIndex`里面有一个`levels`属性表示索引的等级——这样做可以将州名和年份作为每个数据点的不同标签。如果将前面创建的`pop`的索引重置`reindex`为`MultiIndex`,就会看到层级索引。其中前两列表示`Series`的多级索引值,第三列式数据。
```python ```python
pop1 = pop.reindex(index1) pop1 = pop.reindex(index1)
pop1 pop1
@ -26,7 +28,9 @@ Out
2010 25145561 2010 25145561
dtype: int64 dtype: int64
``` ```
查询`2010`年的数据。 查询`2010`年的数据。
```python ```python
pop[:, 2010] # 得到的是一个单索引数组 pop[:, 2010] # 得到的是一个单索引数组
Out Out
@ -35,10 +39,12 @@ Out
Texas 25145561 Texas 25145561
dtype: int64 dtype: int64
``` ```
以上的例子都是`Series`创建多级行索引,而每个`DataFrame`的行与列都是对称的,也就是说既然有多级行索引,那么同样可以有多级列索引。只需要在创建`DataFrame`时将`columns`的参数传入一个`MultiIndex`。 以上的例子都是`Series`创建多级行索引,而每个`DataFrame`的行与列都是对称的,也就是说既然有多级行索引,那么同样可以有多级列索引。只需要在创建`DataFrame`时将`columns`的参数传入一个`MultiIndex`。
2. 通过二维索引数组创建多级索引 2. 通过二维索引数组创建多级索引
`Series`或`DataFrame`创建多级索引最直接的办法就是将`index`参数设置为至少二维的索引数组。 `Series`或`DataFrame`创建多级索引最直接的办法就是将`index`参数设置为至少二维的索引数组。
```python ```python
df = pd.DataFrame(np.random.rand(4, 2), index=[['a', 'a', 'b', 'b'], [1, 2, 1, 2]], columns=['data1', 'data2']) df = pd.DataFrame(np.random.rand(4, 2), index=[['a', 'a', 'b', 'b'], [1, 2, 1, 2]], columns=['data1', 'data2'])
df df
@ -49,12 +55,14 @@ Out:
b 1 0.441759 0.610054 b 1 0.441759 0.610054
2 0.171495 0.886688 2 0.171495 0.886688
``` ```
`MultiIndex`的创建工作将在后台完成。同理,如果你把将元组作为键的字典传递给`Pandas``Pandas`也会默认转换为`MultiIndex`。 `MultiIndex`的创建工作将在后台完成。同理,如果你把将元组作为键的字典传递给`Pandas``Pandas`也会默认转换为`MultiIndex`。
3. 显示的创建多级索引 3. 显示的创建多级索引
你可以用`pd.MultiIndex`中的类方法更加灵活地构建多级索引。 你可以用`pd.MultiIndex`中的类方法更加灵活地构建多级索引。
```python ```python
# 不同等级的若干简单数组组成的列表来构建 # 不同等级的若干简单数组组成的列表来构建
pd.MultiIndex.from_arrays([['a', 'a', 'b', 'b'], [1, 2, 1, 2]]) pd.MultiIndex.from_arrays([['a', 'a', 'b', 'b'], [1, 2, 1, 2]])
# 包含多个索引值的元组构成的列表创建 # 包含多个索引值的元组构成的列表创建
pd.MultiIndex.from_tuples([('a', 1), ('a', 2), ('b', 1), ('b', 2)]) pd.MultiIndex.from_tuples([('a', 1), ('a', 2), ('b', 1), ('b', 2)])
@ -65,6 +73,7 @@ Out:
MultiIndex(levels=[['a', 'b'], [1, 2]], MultiIndex(levels=[['a', 'b'], [1, 2]],
codes=[[0, 0, 1, 1], [0, 1, 0, 1]]) codes=[[0, 0, 1, 1], [0, 1, 0, 1]])
``` ```
*在创建`Series`或`DataFrame`时,可以将这些对象作为`index`参数,或者通过`reindex`方法更新`Series`或`DataFrame`的索引。* *在创建`Series`或`DataFrame`时,可以将这些对象作为`index`参数,或者通过`reindex`方法更新`Series`或`DataFrame`的索引。*
4. 多级索引的等级名称 4. 多级索引的等级名称
@ -130,8 +139,7 @@ year
2. `DataFrame`多级索引 2. `DataFrame`多级索引
```python ```python
index = pd.MultiIndex.from_product([[2013, 2014], [1, 2]], index = pd.MultiIndex.from_product([[2013, 2014], [1, 2]], names=['year', 'visit'])
names=['year', 'visit'])
columns = pd.MultiIndex.from_product([['Bob', 'Guido', 'Sue'], ['HR', 'Temp']], names=['subject', 'type']) columns = pd.MultiIndex.from_product([['Bob', 'Guido', 'Sue'], ['HR', 'Temp']], names=['subject', 'type'])
# 模拟数据 # 模拟数据
data = np.round(np.random.randn(4, 6), 1) data = np.round(np.random.randn(4, 6), 1)

@ -4,7 +4,9 @@
使用多级索引的关键是掌握有效数据转换的方法,`Pandas`提供了许多操作,可以让数据在内容保持不变的同时,按照需要进行行列转换。上一关我们用`stack()`和`unstack()`演示过简单的行列转换,但其实还有许多合理控制层级行列索引的方法,让我们来一探究竟。 使用多级索引的关键是掌握有效数据转换的方法,`Pandas`提供了许多操作,可以让数据在内容保持不变的同时,按照需要进行行列转换。上一关我们用`stack()`和`unstack()`演示过简单的行列转换,但其实还有许多合理控制层级行列索引的方法,让我们来一探究竟。
1. 有序和无序的索引 1. 有序和无序的索引
如果`MultiIndex`不是有序的索引,那么大多数切片操作都会失败,如下例: 如果`MultiIndex`不是有序的索引,那么大多数切片操作都会失败,如下例:
```python ```python
# 首先创建一个不按字典顺序排列的多级索引Series # 首先创建一个不按字典顺序排列的多级索引Series
index = pd.MultiIndex.from_product([['a', 'c', 'b'], [1, 2]]) index = pd.MultiIndex.from_product([['a', 'c', 'b'], [1, 2]])
@ -30,7 +32,9 @@ Out
<class 'KeyError'> <class 'KeyError'>
'Key length (1) was greater than MultiIndex lexsort depth (0)' 'Key length (1) was greater than MultiIndex lexsort depth (0)'
``` ```
问题是出在`MultiIndex`无序排列上,局部切片和许多其他相似的操作都要求`MultiIndex`的各级索引是有序的。为此,`Pandas`提供了许多便捷的操作完成排序,如`sort_index()`和`sortlevel()`方法。 问题是出在`MultiIndex`无序排列上,局部切片和许多其他相似的操作都要求`MultiIndex`的各级索引是有序的。为此,`Pandas`提供了许多便捷的操作完成排序,如`sort_index()`和`sortlevel()`方法。
```python ```python
data = data.sort_index() data = data.sort_index()
data["a":"b"] data["a":"b"]
@ -44,7 +48,8 @@ b 1 0.001693
``` ```
2. 索引stack与unstack 2. 索引stack与unstack
上一关提过,我们可以将一个多级索引数据集转换成简单的二维形式,可以通过`level`参数设置转换的索引层级。
上一节提过,我们可以将一个多级索引数据集转换成简单的二维形式,可以通过`level`参数设置转换的索引层级。
```python ```python
pop pop
Out: Out:
@ -75,7 +80,9 @@ Out
`unstack()`是`stack()`的逆操作,同时使用这两种方法`pop.unstack().stack()`让数据保持不变。 `unstack()`是`stack()`的逆操作,同时使用这两种方法`pop.unstack().stack()`让数据保持不变。
3. 索引的设置与重置 3. 索引的设置与重置
层级数据维度转换的另一种方法是行列标签转换,可以通过`reset_index`方法实现。也可以用数据的`name`属性为列设置名称: 层级数据维度转换的另一种方法是行列标签转换,可以通过`reset_index`方法实现。也可以用数据的`name`属性为列设置名称:
```python ```python
pop_flat = pop.reset_index(name='population') pop_flat = pop.reset_index(name='population')
pop_flat pop_flat
@ -88,7 +95,9 @@ Out:
4 Texas 2000 20851820 4 Texas 2000 20851820
5 Texas 2010 25145561 5 Texas 2010 25145561
``` ```
在解决实际问题的时候,可以使用`DataFrame`的`set_index`方法将类似这样的原始输入数据的列直接转换成`MultiIndex`,返回结果就会是一个带多级索引的`DataFrame`。 在解决实际问题的时候,可以使用`DataFrame`的`set_index`方法将类似这样的原始输入数据的列直接转换成`MultiIndex`,返回结果就会是一个带多级索引的`DataFrame`。
```python ```python
pop_flat.set_index(['state', 'year']) pop_flat.set_index(['state', 'year'])
Out Out
@ -101,8 +110,10 @@ Out
Texas 2000 20851820 Texas 2000 20851820
2010 25145561 2010 25145561
``` ```
## 多级索引的数据累计方法 ## 多级索引的数据累计方法
`Pandas`有一些自带的数据累计方法,比如`mean()`、`sum()`和`max()`。而对于层级索引数据,可以设置参数`level`实现对数据子集的累计操作。以体检数据为例: `Pandas`有一些自带的数据累计方法,比如`mean()`、`sum()`和`max()`。而对于层级索引数据,可以设置参数`level`实现对数据子集的累计操作。以体检数据为例:
```python ```python
health_data health_data
Out Out
@ -114,7 +125,9 @@ Out
2014 1 30.0 37.4 39.0 37.8 61.0 36.9 2014 1 30.0 37.4 39.0 37.8 61.0 36.9
2 47.0 37.8 48.0 37.3 51.0 36.5 2 47.0 37.8 48.0 37.3 51.0 36.5
``` ```
如果你需要计算每一年各项指标的平均值,那么可以将参数`level`设置为索引`year` 如果你需要计算每一年各项指标的平均值,那么可以将参数`level`设置为索引`year`
```python ```python
data_mean = health_data.mean(level='year') data_mean = health_data.mean(level='year')
data_mean data_mean
@ -125,7 +138,9 @@ Out
2013 37.5 38.2 41.0 35.85 32.0 36.95 2013 37.5 38.2 41.0 35.85 32.0 36.95
2014 38.5 37.6 43.5 37.55 56.0 36.70 2014 38.5 37.6 43.5 37.55 56.0 36.70
``` ```
如果再设置`axis`参数,就可以对列索引进行类似的累计操作了: 如果再设置`axis`参数,就可以对列索引进行类似的累计操作了:
```python ```python
data_mean.mean(axis=1, level='type') data_mean.mean(axis=1, level='type')
Out Out

@ -1,10 +1,11 @@
# 3.2.3Concat与Append操作 # 3.2.3Concat与Append操作
## 相关知识 ## 相关知识
在`Numpy`中,我们介绍过可以用`np.concatenate`、`np.stack`、`np.vstack`和`np.hstack`实现合并功能。`Pandas`中有一个`pd.concat()`函数与`concatenate`语法类似,但是配置参数更多,功能也更强大,主要参数如下。 在`Numpy`中,我们介绍过可以用`np.concatenate`、`np.stack`、`np.vstack`和`np.hstack`实现合并功能。`Pandas`中有一个`pd.concat()`函数与`concatenate`语法类似,但是配置参数更多,功能也更强大,主要参数如下。
参数名|说明 参数名|说明
--|--- :-:|:-:
objs|参与连接的对象,必要参数 objs|参与连接的对象,必要参数
axis|指定轴默认为0 axis|指定轴默认为0
join|inner或者outer默认为outer指明其他轴的索引按哪种方式进行合并,inner表示取交集outer表示取并集 join|inner或者outer默认为outer指明其他轴的索引按哪种方式进行合并,inner表示取交集outer表示取并集
@ -43,11 +44,13 @@ Out
3 A3 B3 3 A3 B3
4 A4 B4 4 A4 B4
``` ```
## 合并时索引的处理 ## 合并时索引的处理
`np.concatenate`与`pd.concat`最主要的差异之一就是`Pandas`在合并时会保留索引,即使索引是重复的! `np.concatenate`与`pd.concat`最主要的差异之一就是`Pandas`在合并时会保留索引,即使索引是重复的!
```python ```python
df3 = pd.DataFrame([["A1","B1"],["A2","B2"]],index=[1,2],columns=["A","B"]) df3 = pd.DataFrame([["A1","B1"],["A2","B2"]],index=[1,2],columns=["A","B"])
df4 = pd.DataFrame([["A1","B1"],["A2","B2"]],index=[1,2],columns=["A","B"]) df4 = pd.DataFrame([["A3","B3"],["A4","B4"]],index=[1,2],columns=["A","B"])
pd.concat([df3,df4]) pd.concat([df3,df4])
Out Out
A B A B

@ -1,10 +1,11 @@
# 3.2.4:合并与连接 # 3.2.4:合并与连接
## 相关知识 ## 相关知识
`merge()`可根据一个或者多个键将不同的`DataFrame`连接在一起,类似于`SQL`数据库中的合并操作。 `merge()`可根据一个或者多个键将不同的`DataFrame`连接在一起,类似于`SQL`数据库中的合并操作。
参数名|说明 参数名|说明
--|--- :-:|:-:
left|拼接左侧DataFrame对象 left|拼接左侧DataFrame对象
right|拼接右侧DataFrame对象 right|拼接右侧DataFrame对象
on|列(名称)连接必须在左和右DataFrame对象中存在(找到)。 on|列(名称)连接必须在左和右DataFrame对象中存在(找到)。
@ -12,13 +13,14 @@ left_on|左侧DataFrame中的列或索引级别用作键可以是列名、索
right_on|右侧DataFrame中的列或索引级别用作键。可以是列名索引级名称也可以是长度等于DataFrame长度的数组。 right_on|右侧DataFrame中的列或索引级别用作键。可以是列名索引级名称也可以是长度等于DataFrame长度的数组。
left_index|如果为True则使用左侧DataFrame中的索引(行标签)作为其连接键。 left_index|如果为True则使用左侧DataFrame中的索引(行标签)作为其连接键。
right_index|与left_index相似 right_index|与left_index相似
how|它可以等于left, right, outer, inner. 默认inner。inner是取交集outer取并集。 how|它可以等于left, right, outer, inner. 默认inner。inner是取交集outer取并集。
sort|sort - 按照字典顺序通过连接键对结果DataFrame进行排序。 sort|按照字典顺序通过连接键对结果DataFrame进行排序。
suffixes|用于追加到重叠列名的末尾。例如左右两个DataFrame都有data列,则结果中就会出现data_xdata_y. suffixes|用于追加到重叠列名的末尾。例如左右两个DataFrame都有data列则结果中就会出现data_x和data_y.
copy|默认总是复制 copy|默认总是复制
--- ---
## 数据连接的类型 ## 数据连接的类型
- 一对一的连接 - 一对一的连接
```python ```python
@ -27,32 +29,44 @@ df2 = pd.DataFrame({'employee': ['Lisa', 'Bob', 'Jake', 'Sue'], 'hire_date': [20
df3 = pd.merge(df1,df2) df3 = pd.merge(df1,df2)
df3 df3
``` ```
输出: 输出:
![](/api/attachments/375684)
![](/api/attachments/375685) ![](21.jpg)
- 多对一的连接 - 多对一的连接
```python ```python
df4 = pd.DataFrame({'group': ['Accounting', 'Engineering', 'HR'], 'supervisor': ['Carly', 'Guido', 'Steve']}) df4 = pd.DataFrame({'group': ['Accounting', 'Engineering', 'HR'], 'supervisor': ['Carly', 'Guido', 'Steve']})
pd.merge(df3,df4) pd.merge(df3,df4)
``` ```
输出: 输出:
![](/api/attachments/375666)
![](31.jpg)
- 多对多连接 - 多对多连接
```python ```python
df5 = pd.DataFrame({'group': ['Accounting', 'Accounting', 'Engineering', 'Engineering', 'HR', 'HR'], 'skills': ['math', 'spreadsheets', 'coding', 'linux', 'spreadsheets', 'organization']}) df5 = pd.DataFrame({'group': ['Accounting', 'Accounting', 'Engineering', 'Engineering', 'HR', 'HR'], 'skills': ['math', 'spreadsheets', 'coding', 'linux', 'spreadsheets', 'organization']})
pd.merge(df1,df5) pd.merge(df1,df5)
``` ```
输出: 输出:
![](/api/attachments/375667)
![](41.jpg)
## merge()的主要参数 ## merge()的主要参数
**1. `on`** 可以是列名字符串或者一个包含多列名称的列表 **1. `on`** 可以是列名字符串或者一个包含多列名称的列表
```python ```python
pd.merge(df1, df2, on='employee') pd.merge(df1, df2, on='employee')
``` ```
输出: 输出:
![](/api/attachments/375672)
![](51.jpg)
*这个参数只能在两个`DataFrame`有共同列名的时候才可以使用。* *这个参数只能在两个`DataFrame`有共同列名的时候才可以使用。*
**2. `left_on`与`right_on`参数** **2. `left_on`与`right_on`参数**
有时你也需要合并两个列名不同的数据集,例如前面的员工信息表中有一个字段不是`employee`而是`name`。在这种情况下,就可以用`left_on`和`right_on`参数来指定列名。 有时你也需要合并两个列名不同的数据集,例如前面的员工信息表中有一个字段不是`employee`而是`name`。在这种情况下,就可以用`left_on`和`right_on`参数来指定列名。
@ -60,71 +74,94 @@ pd.merge(df1, df2, on='employee')
df3 = pd.DataFrame({'name': ['Bob', 'Jake', 'Lisa', 'Sue'], 'salary': [70000, 80000, 120000, 90000]}) df3 = pd.DataFrame({'name': ['Bob', 'Jake', 'Lisa', 'Sue'], 'salary': [70000, 80000, 120000, 90000]})
dfx = pd.merge(df1,df3,left_on="employee",right_on="name") dfx = pd.merge(df1,df3,left_on="employee",right_on="name")
``` ```
输出: 输出:
![](/api/attachments/375673)
![](/api/attachments/375676) ![](61.jpg)
**如果出现重复列,但是列名不同时,可以使用`drop`方法将这列去掉** **如果出现重复列,但是列名不同时,可以使用`drop`方法将这列去掉**
```python ```python
dfx.drop("name",axis=1) dfx.drop("name",axis=1)
``` ```
输出: 输出:
![](/api/attachments/375837)
![](71.jpg)
**3. left_index与right_index参数** 用于合并索引 **3. left_index与right_index参数** 用于合并索引
```python ```python
df1a = df1.set_index('employee') df1a = df1.set_index('employee')
df2a = df2.set_index('employee') df2a = df2.set_index('employee')
pd.merge(df1a,df2a,left_index=True,right_index=True) pd.merge(df1a,df2a,left_index=True,right_index=True)
``` ```
输出: 输出:
![](/api/attachments/375677)
![](81.jpg)
--- ---
用`join()`方法也可以实现该功能: 用`join()`方法也可以实现该功能:
```python ```python
df1a.join(df2a) df1a.join(df2a)
``` ```
输出: 输出:
![](/api/attachments/375679)
![](91.jpg)
--- ---
如果想将索引与列混合使用,那么可以通过结合`left_index`与` right_on`,或者结合`left_on`与`right_index`来实现。 如果想将索引与列混合使用,那么可以通过结合`left_index`与` right_on`,或者结合`left_on`与`right_index`来实现。
```python ```python
pd.merge(df1a, df3, left_index=True, right_on='name') pd.merge(df1a, df3, left_index=True, right_on='name')
``` ```
输出: 输出:
![](/api/attachments/375681)
![](101.jpg)
--- ---
**4. how参数** **4. how参数**
`how`参数默认情况下是`inner`也就是取交集。how参数支持的数据连接方式还有`outer`、`left`和`right`。`outer`表示外连接,取并集。 `how`参数默认情况下是`inner`,也就是取交集。`how`参数支持的数据连接方式还有`outer`、`left`和`right`。`outer`表示外连接,取并集。
```python ```python
df6 = pd.DataFrame({'name': ['Peter', 'Paul', 'Mary'], 'food': ['fish', 'beans', 'bread']}, columns=['name', 'food']) df6 = pd.DataFrame({'name': ['Peter', 'Paul', 'Mary'], 'food': ['fish', 'beans', 'bread']}, columns=['name', 'food'])
df7 = pd.DataFrame({'name': ['Mary', 'Joseph'], 'drink': ['wine', 'beer']}, columns=['name', 'drink']) df7 = pd.DataFrame({'name': ['Mary', 'Joseph'], 'drink': ['wine', 'beer']}, columns=['name', 'drink'])
pd.merge(df6, df7, how='outer') pd.merge(df6, df7, how='outer')
``` ```
输出: 输出:
![](/api/attachments/375691)
![](201.jpg)
--- ---
左连接和右连接返回的结果分别只包含左列和右列。 左连接和右连接返回的结果分别只包含左列和右列。
```python ```python
pd.merge(df6, df7, how='left') pd.merge(df6, df7, how='left')
``` ```
输出: 输出:
![](/api/attachments/375692)
![](301.jpg)
**5. suffixes参数** **5. suffixes参数**
如果输出结果中有两个重复的列名,因此`pd.merge()`函数会自动为它们增加后缀 `_x ``_y`,当然也可以通过`suffixes`参数自定义后缀名。 如果输出结果中有两个重复的列名,因此`pd.merge()`函数会自动为它们增加后缀 `_x ``_y`,当然也可以通过`suffixes`参数自定义后缀名。
```python ```python
df8 = pd.DataFrame({'name': ['Bob', 'Jake', 'Lisa', 'Sue'], 'rank': [1, 2, 3, 4]}) df8 = pd.DataFrame({'name': ['Bob', 'Jake', 'Lisa', 'Sue'], 'rank': [1, 2, 3, 4]})
df9 = pd.DataFrame({'name': ['Bob', 'Jake', 'Lisa', 'Sue'], 'rank': [3, 1, 4, 2]}) df9 = pd.DataFrame({'name': ['Bob', 'Jake', 'Lisa', 'Sue'], 'rank': [3, 1, 4, 2]})
pd.merge(df8, df9, on="name", suffixes=["_L", "_R"]) pd.merge(df8, df9, on="name", suffixes=["_L", "_R"])
``` ```
输出: 输出:
![](/api/attachments/375698)
![](401.jpg)
`suffixes`参数同样适用于任何连接方式,即使有三个及三个以上的重复列名时也同样适用。 `suffixes`参数同样适用于任何连接方式,即使有三个及三个以上的重复列名时也同样适用。

@ -135,7 +135,7 @@ df.groupby("B").describe()
输出: 输出:
![](/api/attachments/376362) ![](501.jpg)
### 应用多个聚合函数 ### 应用多个聚合函数

@ -1,16 +1,22 @@
# 3.2.7:字符串操作方法 # 3.2.7:字符串操作方法
## 字符串方法 ## 字符串方法
如果你对`Python`字符串方法十分了解,那么下面的知识对你来说如瓮中捉鳖,几乎所有的`Python`内置的字符串方法都被复制到`Pandas`的向量化字符串方法中。下图列举了`Pandas`的`str`方法借鉴`Python`字符串方法的内容: 如果你对`Python`字符串方法十分了解,那么下面的知识对你来说如瓮中捉鳖,几乎所有的`Python`内置的字符串方法都被复制到`Pandas`的向量化字符串方法中。下图列举了`Pandas`的`str`方法借鉴`Python`字符串方法的内容:
![](/api/attachments/376455)
![](601.jpg)
--- ---
它们的作用与`Python`字符串的基本一致,但是需要注意这些方法的返回值不同。举两个例子: 它们的作用与`Python`字符串的基本一致,但是需要注意这些方法的返回值不同。举两个例子:
```python ```python
monte = pd.Series(['Graham Chapman', 'John Cleese', 'Terry Gilliam', 'Eric Idle', 'Terry Jones', 'Michael Palin']) monte = pd.Series(['Graham Chapman', 'John Cleese', 'Terry Gilliam', 'Eric Idle', 'Terry Jones', 'Michael Palin'])
monte.str.lower() # 返回字符串 monte.str.lower() # 返回字符串
``` ```
输出: 输出:
```python ```python
0 graham chapman 0 graham chapman
1 john cleese 1 john cleese
@ -20,10 +26,13 @@ monte.str.lower() # 返回字符串
5 michael palin 5 michael palin
dtype: object dtype: object
``` ```
``` ```
monte.str.split() # 返回列表 monte.str.split() # 返回列表
``` ```
输出: 输出:
```python ```python
0 [Graham, Chapman] 0 [Graham, Chapman]
1 [John, Cleese] 1 [John, Cleese]
@ -33,9 +42,13 @@ monte.str.split() # 返回列表
5 [Michael, Palin] 5 [Michael, Palin]
dtype: object dtype: object
``` ```
--- ---
`pandas`中还有一些自带的字符串方法,如下图所示: `pandas`中还有一些自带的字符串方法,如下图所示:
![](/api/attachments/376459)
![](701.jpg)
其中`get_dummies()`方法有点难以理解,给大家举个例子,假设有一个包含了某种编码信息的数据集,如 `A`= 出生在美国、`B`= 出生在英国、`C`= 喜欢奶酪、`D`= 喜欢午餐肉: 其中`get_dummies()`方法有点难以理解,给大家举个例子,假设有一个包含了某种编码信息的数据集,如 `A`= 出生在美国、`B`= 出生在英国、`C`= 喜欢奶酪、`D`= 喜欢午餐肉:
```python ```python
full_monte = pd.DataFrame({ full_monte = pd.DataFrame({
@ -69,8 +82,11 @@ full_monte['info'].str.get_dummies('|')
``` ```
## 正则表达式方法 ## 正则表达式方法
还有一些支持正则表达式的方法可以用来处理每个字符串元素。如下图所示: 还有一些支持正则表达式的方法可以用来处理每个字符串元素。如下图所示:
![](/api/attachments/376458)
![](801.jpg)
众所周知,正则表达式“无所不能”,我们可以利用正则实现一些独特的操作,例如提取每个人的`first name` 众所周知,正则表达式“无所不能”,我们可以利用正则实现一些独特的操作,例如提取每个人的`first name`
```python ```python
monte.str.extract('([A-Za-z]+)') monte.str.extract('([A-Za-z]+)')

@ -1,8 +1,7 @@
# 3.2.8:日期与时间工具 # 3.2.8:日期与时间工具
## 相关知识 ## 相关知识
`Pandas`是为金融模型而创建的,所以拥有一些功能非常强大的日期、时间、带 `Pandas`是为金融模型而创建的,所以拥有一些功能非常强大的日期、时间、带时间索引数据的处理工具。本关卡介绍的日期与时间数据主要包含三类:
时间索引数据的处理工具。本关卡介绍的日期与时间数据主要包含三类:
- **时间戳**:表示某个具体的时间点(例如`2015`年`7`月`4`日上午 7 点) - **时间戳**:表示某个具体的时间点(例如`2015`年`7`月`4`日上午 7 点)
- **时间间隔与周期**:期表示开始时间点与结束时间点之间的时间长度,例如`2015`年(指的是`2015`年`1`月`1`日至`2015`年`12`月`31`日这段时间间隔)。周期通常是指一种特殊形式的时间间隔,每个间隔长度相同,彼此之间不会重叠(例如,以`24`小时为周期构成每一天) - **时间间隔与周期**:期表示开始时间点与结束时间点之间的时间长度,例如`2015`年(指的是`2015`年`1`月`1`日至`2015`年`12`月`31`日这段时间间隔)。周期通常是指一种特殊形式的时间间隔,每个间隔长度相同,彼此之间不会重叠(例如,以`24`小时为周期构成每一天)
- **时间增量或持续时间**:表示精确的时间长度(例如,某程序运行持续时间`22.56`秒) - **时间增量或持续时间**:表示精确的时间长度(例如,某程序运行持续时间`22.56`秒)

@ -1,4 +1,4 @@
# 3.2.8日期与时间工具 # 3.2.9 时间序列的高级应用
## 相关知识 ## 相关知识
@ -7,7 +7,7 @@ Pandas 时间序列工具的基础是时间频率或偏移量代码。就像之
Pandas频率代码表如下 Pandas频率代码表如下
代码|描述 代码|描述
--|-- :-:|:-:
D|天calendar day按日历算含双休日 D|天calendar day按日历算含双休日
W|周weekly M 月末month end W|周weekly M 月末month end
Q|季末quarter end Q|季末quarter end
@ -134,8 +134,7 @@ In[6]fig, ax = plt.subplots(3, sharey=True)
![](4.jpg) ![](4.jpg)
`shift(900)`将数据向前推进了`900`天,这样图形中的一段就消失了(最左侧 `shift(900)`将数据向前推进了`900`天,这样图形中的一段就消失了(最左侧就变成了缺失值),而`tshift(900)`方法是将时间索引值向前推进了`900`天。
就变成了缺失值),而`tshift(900)`方法是将时间索引值向前推进了`900`天。
## 移动时间窗口 ## 移动时间窗口

Binary file not shown.

After

Width:  |  Height:  |  Size: 9.0 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 15 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 14 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 24 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 11 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 20 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 22 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 20 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 15 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 8.4 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 18 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 18 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 8.1 KiB

@ -22,7 +22,7 @@ ax2 = fig.add_axes([0.1, 0.1, 0.8, 0.4],
ylim=(-1.2, 1.2)) ylim=(-1.2, 1.2))
x = np.linspace(0, 10) x = np.linspace(0, 10)
ax1.plot(np.sin(x)) ax1.plot(np.sin(x))
ax2.plot(np.cos(x)); ax2.plot(np.cos(x))
``` ```
![](21.jpg) ![](21.jpg)

@ -1,4 +1,4 @@
# 5.1 什么是机器学习 # 5.1.1 什么是机器学习
机器学习的定义有很多种,但是最准确的定义是:"A computer program is said to learn from experience E with respect to some class of tasks T and performance measure P, if its performance at tasks in T, as measured by P, improves with experience E." 这个定义除了非常押韵之外还体现了机器学习的几个关键点task , experience 和 performance 。 机器学习的定义有很多种,但是最准确的定义是:"A computer program is said to learn from experience E with respect to some class of tasks T and performance measure P, if its performance at tasks in T, as measured by P, improves with experience E." 这个定义除了非常押韵之外还体现了机器学习的几个关键点task , experience 和 performance 。

@ -2,7 +2,7 @@
## 模型 ## 模型
根据历史数据总结归纳出规律的过程,即学习过程,或模型的训练过程。模型这个词看上去 很高大上,其实可以把他看成是一个函数。例如:现在想用机器学习来识别图片里的是香蕉还是苹果,那 么机器学习所的事情就是得到一个比较好的函数,当输入一张香蕉图片时,能得到识别结果为香蕉的输 出,当输入一张苹果图片时,能得到识别结果为苹果的输出。 根据历史数据总结归纳出规律的过程,即学习过程,或模型的训练过程。模型这个词看上去很高大上,其实可以把他看成是一个函数。例如:现在想用机器学习来识别图片里的是香蕉还是苹果,那么机器学习所的事情就是得到一个比较好的函数,当输入一张香蕉图片时,能得到识别结果为香蕉的输 出,当输入一张苹果图片时,能得到识别结果为苹果的输出。
![](5.jpg) ![](5.jpg)
@ -28,7 +28,7 @@
## 欠拟合与过拟合 ## 欠拟合与过拟合
最好的情况下,模型应该不管在训练集上还是测试集上,它的性能都不错。但是有的时候,模型在训练集上的性能比较差,那么这种情况我们称为**欠拟合**。那如果模型在训练集上的性能好到爆炸,但在测试集上的性能却不尽人意,那么这种情况我们称为**过拟合**。 最好的情况下,模型应该不管在训练集上还是测试集上,它的性能都不错。但是有的时候,模型在训练集上的性能比较差,那么这种情况我们称为**欠拟合**。那如果模型在训练集上的性能好到爆炸,但在测试集上的性能却不尽人意,那么这种情况我们称为**过拟合**。
其实欠拟合与过拟合的区别和生活中学生考试的例子很像。如果一个学生在平时的练习中题目的正确率都不高,那么说明这个学生可能基础不牢或者心思没花在学习上,所以这位学生可能欠缺基础知识或者智商可能不太高或者其他种种原因,像这种情况可以看成是**欠拟合**。那如果这位学生平时练习的正确率非常高,但是他不怎么灵光,喜欢死记硬背,只会做已经做过的题,一碰到没见过的新题就不知所措了。像这种情况可以看成是**过拟合**。 其实欠拟合与过拟合的区别和生活中学生考试的例子很像。如果一个学生在平时的练习中题目的正确率都不高,那么说明这个学生可能基础不牢或者心思没花在学习上,所以这位学生可能欠缺基础知识或者智商可能不太高或者其他种种原因,像这种情况可以看成是**欠拟合**。那如果这位学生平时练习的正确率非常高,但是他不怎么灵光,喜欢死记硬背,只会做已经做过的题,一碰到没见过的新题就不知所措了。像这种情况可以看成是**过拟合**。
@ -48,7 +48,7 @@
比如现在要对手写数字进行识别,那么我就可能会训练一个分类模型。但可能模型对于数字`1`的识别准确率比较低 ,而验证集中没多少个数字为`1`的样本,然后用验证集测试完后得到的准确率为`0.96`。然后您可能觉得哎呀,我的模型很厉害了,但其实并不然,因为这样的验证集让您的模型的性能有了误解。那有没有更加公正的验证算法性能的方法呢?有,那就是**k-折交叉验证** 比如现在要对手写数字进行识别,那么我就可能会训练一个分类模型。但可能模型对于数字`1`的识别准确率比较低 ,而验证集中没多少个数字为`1`的样本,然后用验证集测试完后得到的准确率为`0.96`。然后您可能觉得哎呀,我的模型很厉害了,但其实并不然,因为这样的验证集让您的模型的性能有了误解。那有没有更加公正的验证算法性能的方法呢?有,那就是**k-折交叉验证**
在**K-折交叉验证**中,把原始训练数据集分割成`K`个不重合的⼦数据集,然后做`K`次模型训练和验证。每⼀次,使⽤⼀个⼦数据集验证模型,并使⽤其它`K1`个⼦数据集来训练模型。在这`K`次训练和验证中,每次⽤来验证模型的⼦数据集都不同。最后,对这`K`次在验证集上的性能求平均。 在**K-折交叉验证**中把原始训练数据集分割成K个不重合的⼦数据集然后做K次模型训练和验证。每⼀次使⽤⼀个⼦数据集验证模型并使⽤其它K1个⼦数据集来训练模型。在这K次训练和验证中每次⽤来验证模型的⼦数据集都不同。最后对这K次在验证集上的性能求平均。
`K`的值由我们自己来指定,如以下为`5`折交叉验证。 `K`的值由我们自己来指定,如以下为`5`折交叉验证。

@ -32,12 +32,12 @@
![](7.jpg) ![](7.jpg)
然后把每条小竖线的长度加起来就等于现在通过这条直线预测出的房价与实际房价之间的差距。那每条小竖线的长度的加和怎么算?其实就是欧式距离加和,公式为:$$\sum_{i=1}^m(y^{(i)}-y\hat{^{(i)}})^2$$(其中$$y(i)$$表示的是实际房价,$$y \hat (i)$$表示的是预测房价)。 然后把每条小竖线的长度加起来就等于现在通过这条直线预测出的房价与实际房价之间的差距。那每条小竖线的长度的加和怎么算?其实就是欧式距离加和,公式为:$$\sum_{i=1}^m(y^{(i)}-\hat y{^{(i)}})^2$$(其中$$y(i)$$表示的是实际房价,$$\hat y (i)$$表示的是预测房价)。
这个欧氏距离加和其实就是用来量化预测结果和真实结果的误差的一个函数。在机器学习中称它为**损失函数**(说白了就是计算误差的函数)。那有了这个函数,就相当于有了一个评判标准,当这个函数的值越小,就越说明找到的这条直线越能拟合房价数据。所以说啊,线性回归就是通过这个损失函数做为评判标准来找出一条直线。 这个欧氏距离加和其实就是用来量化预测结果和真实结果的误差的一个函数。在机器学习中称它为**损失函数**(说白了就是计算误差的函数)。那有了这个函数,就相当于有了一个评判标准,当这个函数的值越小,就越说明找到的这条直线越能拟合房价数据。所以说啊,线性回归就是通过这个损失函数做为评判标准来找出一条直线。
如果假设$$h_{(\theta)}(x)$$表示当权重为$$\theta$$,输入为$$x$$时计算出来的$$y \hat (i)$$,那么线性回归的损失函数$$J(\theta)$$就是: 如果假设$$h_{(\theta)}(x)$$表示当权重为$$\theta$$,输入为$$x$$时计算出来的$$ \hat y(i)$$,那么线性回归的损失函数$$J(\theta)$$就是:
<center> <center>
$$ $$

@ -53,7 +53,7 @@ kNN 算法其实是众多机器学习算法中最简单的一种,因为该算
## sklearn中的kNN算法 ## sklearn中的kNN算法
想要使用`sklearn`中使用`kNN`算法进行分类,只需要如下的代码(其中`train_feature`、`train_label`和`test_feature`分别表示训练集数据、训练集标签和测试集数据) 想要使用`sklearn`中使用`kNN`算法进行分类,代码如下(其中`train_feature`、`train_label`和`test_feature`分别表示训练集数据、训练集标签和测试集数据)
```python ```python
from sklearn.neighbors import KNeighborsClassifier from sklearn.neighbors import KNeighborsClassifier

@ -100,7 +100,7 @@ $$
假设样本只有`X`和`Y`这两个特征,现在把`X`与`X``X`与`Y``Y`与`X``Y`与`Y`的协方差组成矩阵,那么就构成了协方差矩阵。而协方差矩阵反应的就是特征与特征之间的相关关系。 假设样本只有`X`和`Y`这两个特征,现在把`X`与`X``X`与`Y``Y`与`X``Y`与`Y`的协方差组成矩阵,那么就构成了协方差矩阵。而协方差矩阵反应的就是特征与特征之间的相关关系。
| | X | Y | | | X | Y |
| ------------ | ------------ | ------------ | | :-: | :-: | :-: |
| X |conv(X,X) | conv(X,Y) | | X |conv(X,X) | conv(X,Y) |
| Y |conv(Y,X) |conv(Y,Y) | | Y |conv(Y,X) |conv(Y,Y) |

@ -2,18 +2,18 @@
* [第一部分: Python从0到1](Part1/简介.md) * [第一部分: Python从0到1](Part1/简介.md)
* [第一章: Python基础知识](Part1/Chapter1/简介.md) * [第一章: Python基础知识](Part1/Chapter1/简介.md)
* [1.1: Python基础]() * [1.1 Python基础]()
* [1.1.1 Hello, Python](Part1/Chapter1/1.1 Python基础/1.1.1 HelloPython.md) * [1.1.1 Hello, Python](Part1/Chapter1/1.1 Python基础/1.1.1 HelloPython.md)
* [1.1.2 数据类型与变量](Part1/Chapter1/1.1 Python基础/1.1.2 数据类型与运算.md) * [1.1.2 数据类型与变量](Part1/Chapter1/1.1 Python基础/1.1.2 数据类型与运算.md)
* [1.1.3 数据结构](Part1/Chapter1/1.1 Python基础/1.1.3 数据结构.md) * [1.1.3 数据结构](Part1/Chapter1/1.1 Python基础/1.1.3 数据结构.md)
* [1.1.4 分支与循环](Part1/Chapter1/1.1 Python基础/1.1.4 分支与循环.md) * [1.1.4 分支与循环](Part1/Chapter1/1.1 Python基础/1.1.4 分支与循环.md)
* [1.2 Python进阶]() * [1.2 Python进阶]()
* [1.2.1 函数]((Part1/Chapter1/1.2 Python进阶/1.2.1 函数.md) * [1.2.1 函数](Part1/Chapter1/1.2 Python进阶/1.2.1 函数.md)
* [1.2.2 模块]((Part1/Chapter1/1.2 Python进阶/1.2.2 模块.md) * [1.2.2 模块](Part1/Chapter1/1.2 Python进阶/1.2.2 模块.md)
* [1.2.3 模块]((Part1/Chapter1/1.2 Python进阶/1.2.3 类与对象.md) * [1.2.3 类与对象](Part1/Chapter1/1.2 Python进阶/1.2.3 类与对象.md)
* [1.2.4 模块]((Part1/Chapter1/1.2 Python进阶/1.2.4 文件IO.md) * [1.2.4 文件IO](Part1/Chapter1/1.2 Python进阶/1.2.4 文件IO.md)
* [1.2.5 模块]((Part1/Chapter1/1.2 Python进阶/1.2.5 异常处理.md) * [1.2.5 异常处理](Part1/Chapter1/1.2 Python进阶/1.2.5 异常处理.md)
* [1.2.6 模块]((Part1/Chapter1/1.2 Python进阶/1.2.6 正则表达式.md) * [1.2.6 正则表达式](Part1/Chapter1/1.2 Python进阶/1.2.6 正则表达式.md)
* [第二章:数值计算利器---NumPy](Part1/Chapter2/简介.md) * [第二章:数值计算利器---NumPy](Part1/Chapter2/简介.md)
* [2.1: NumPy基础]() * [2.1: NumPy基础]()
* [2.1.1 ndarray对象](Part1/Chapter2/2.1 NumPy基础/2.1.1 ndarray对象.md) * [2.1.1 ndarray对象](Part1/Chapter2/2.1 NumPy基础/2.1.1 ndarray对象.md)
@ -24,16 +24,16 @@
* [2.2: NumPy进阶]() * [2.2: NumPy进阶]()
* [2.2.1 堆叠操作](Part1/Chapter2/2.2 NumPy进阶/2.2.1 堆叠操作.md) * [2.2.1 堆叠操作](Part1/Chapter2/2.2 NumPy进阶/2.2.1 堆叠操作.md)
* [2.2.2 花式索引与布尔索引](Part1/Chapter2/2.2 NumPy进阶/2.2.2 花式索引与布尔索引.md) * [2.2.2 花式索引与布尔索引](Part1/Chapter2/2.2 NumPy进阶/2.2.2 花式索引与布尔索引.md)
* [2.2.3 广播机制](Part1/Chapter2/2.2 NumPy进阶/2.2.2 广播机制.md) * [2.2.3 广播机制](Part1/Chapter2/2.2 NumPy进阶/2.2.3 广播机制.md)
* [2.2.4 线性代数](Part1/Chapter2/2.2 NumPy进阶/2.2.4 线性代数.md) * [2.2.4 线性代数](Part1/Chapter2/2.2 NumPy进阶/2.2.4 线性代数.md)
* [2.2.5 排序和条件筛选](Part1/Chapter2/2.2 NumPy进阶/2.2.5排序和条件筛选.md) * [2.2.5 排序和条件筛选](Part1/Chapter2/2.2 NumPy进阶/2.2.5排序和条件筛选.md)
* [2.2.6 结构化数组](Part1/Chapter2/2.2 NumPy进阶/2.2.6结构化数组.md) * [2.2.6 结构化数组](Part1/Chapter2/2.2 NumPy进阶/2.2.6结构化数组.md)
* [第三章:结构化数据大杀器---Pandas](Part1/Chapter3/简介.md) * [第三章:结构化数据大杀器---Pandas](Part1/Chapter3/简介.md)
* [3.1 Pandas基础]() * [3.1 Pandas基础]()
* [3.1.1 Series对象](Part1/Chapter3/3.1 Pandas基础/3.1.1Series对象.md) * [3.1.1 Series对象](Part1/Chapter3/3.1 Pandas基础/3.1.1Series对象.md)
* [3.1.2 DataFrame对象](Part1/Chapter3/3.1 Pandas基础/3.1.2DataFrame对象.md) * [3.1.2 DataFrame对象](Part1/Chapter3/3.1 Pandas基础/3.1.2DateFrame对象.md)
* [3.1.3 Index对象](Part1/Chapter3/3.1 Pandas基础/3.1.3Index对象.md) * [3.1.3 Index对象](Part1/Chapter3/3.1 Pandas基础/3.1.3Index对象.md)
* [3.1.4 Series对象数据选择](Part1/Chapter3/3.1 Pandas基础/3.1.4 Series对象数据选择.md) * [3.1.4 Series对象数据选择](Part1/Chapter3/3.1 Pandas基础/3.1.4Series数据选择.md)
* [3.1.5 DataFrame数据选择方法](Part1/Chapter3/3.1 Pandas基础/3.1.5DataFrame数据选择方法.md) * [3.1.5 DataFrame数据选择方法](Part1/Chapter3/3.1 Pandas基础/3.1.5DataFrame数据选择方法.md)
* [3.1.6 数值运算方法](Part1/Chapter3/3.1 Pandas基础/3.1.6数值运算方法.md) * [3.1.6 数值运算方法](Part1/Chapter3/3.1 Pandas基础/3.1.6数值运算方法.md)
* [3.1.7 数值运算与缺失值处理](Part1/Chapter3/3.1 Pandas基础/3.1.7数值运算与缺失值处理.md) * [3.1.7 数值运算与缺失值处理](Part1/Chapter3/3.1 Pandas基础/3.1.7数值运算与缺失值处理.md)
@ -58,18 +58,18 @@
* [4.1.7 网格子图](Part1/Chapter4/4.1matplotlib基础/4.1.7网格子图.md) * [4.1.7 网格子图](Part1/Chapter4/4.1matplotlib基础/4.1.7网格子图.md)
* [4.1.8 更复杂的排列方式](Part1/Chapter4/4.1matplotlib基础/4.1.8更复杂的排列方式.md) * [4.1.8 更复杂的排列方式](Part1/Chapter4/4.1matplotlib基础/4.1.8更复杂的排列方式.md)
* [4.2 Matplotlib进阶]() * [4.2 Matplotlib进阶]()
* [4.2.1 配置颜色条](Part1/Chapter4/4.2matplotlib基础/4.2.1配置颜色条.md) * [4.2.1 配置颜色条](Part1/Chapter4/4.2matplotlib进阶/4.2.1配置颜色条.md)
* [4.2.1 设置注释](Part1/Chapter4/4.2matplotlib基础/4.2.2设置注释.md) * [4.2.2 设置注释](Part1/Chapter4/4.2matplotlib进阶/4.2.2设置注释.md)
* [4.2.3 自定义坐标刻度](Part1/Chapter4/4.2matplotlib基础/4.2.3自定义坐标刻度.md) * [4.2.3 自定义坐标刻度](Part1/Chapter4/4.2matplotlib进阶/4.2.3自定义坐标刻度.md)
* [4.2.4 配置文件与样式表](Part1/Chapter4/4.2matplotlib基础/4.2.4配置文件与样式表.md) * [4.2.4 配置文件与样式表](Part1/Chapter4/4.2matplotlib进阶/4.2.4配置文件与样式表.md)
* [4.2.5 绘制三维图](Part1/Chapter4/4.2matplotlib基础/4.2.5绘制三维图.md) * [4.2.5 绘制三维图](Part1/Chapter4/4.2matplotlib进阶/4.2.5绘制三维图.md)
* [4.2.5 曲面三角剖分](Part1/Chapter4/4.2matplotlib基础/4.2.6曲面三角剖分.md) * [4.2.6 曲面三角剖分](Part1/Chapter4/4.2matplotlib进阶/4.2.6曲面三角剖分.md)
* [第二部分: 机器学习与综合实战](Part2/简介.md) * [第二部分: 机器学习与综合实战](Part2/简介.md)
* [第五章: 机器学习](Part2/Chapter5/简介.md) * [第五章: 机器学习](Part2/Chapter5/简介.md)
* [5.1 机器学习概述]() * [5.1 机器学习概述]()
* [5.1.1 机器学习概述](Part2/Chapter5/5.1 机器学习概述/机器学习常见术语.md) * [5.1.1 机器学习概述](Part2/Chapter5/5.1 机器学习概述/什么是机器学习.md)
* [5.1.2 机器学习概述](Part2/Chapter5/5.1 机器学习概述/机器学习的主要内容.md) * [5.1.2 机器学习的主要内容](Part2/Chapter5/5.1 机器学习概述/机器学习的主要任务.md)
* [5.1.3 机器学习概述](Part2/Chapter5/5.1 机器学习概述/怎样评估模型性能.md) * [5.1.3 怎样评估模型性能](Part2/Chapter5/5.1 机器学习概述/机器学习常见术语.md)
* [5.2 监督学习]() * [5.2 监督学习]()
* [5.2.1 近朱者赤近墨者黑---kNN](Part2/Chapter5/5.2 监督学习/近朱者赤近墨者黑---kNN.md) * [5.2.1 近朱者赤近墨者黑---kNN](Part2/Chapter5/5.2 监督学习/近朱者赤近墨者黑---kNN.md)
* [5.2.2 最简单的回归算法---线性回归](Part2/Chapter5/5.2 监督学习/最简单的回归算法---线性回归.md) * [5.2.2 最简单的回归算法---线性回归](Part2/Chapter5/5.2 监督学习/最简单的回归算法---线性回归.md)
@ -77,10 +77,10 @@
* [5.2.4 用概率说话---朴素贝叶斯分类器](Part2/Chapter5/5.2 监督学习/用概率说话---朴素贝叶斯分类器.md) * [5.2.4 用概率说话---朴素贝叶斯分类器](Part2/Chapter5/5.2 监督学习/用概率说话---朴素贝叶斯分类器.md)
* [5.2.5 最接近人类思维的算法---决策树](Part2/Chapter5/5.2 监督学习/最接近人类思维的算法---决策树.md) * [5.2.5 最接近人类思维的算法---决策树](Part2/Chapter5/5.2 监督学习/最接近人类思维的算法---决策树.md)
* [5.2.6 好还不够,我要最好---支持向量机](Part2/Chapter5/5.2 监督学习/好还不够,我要最好---支持向量机.md) * [5.2.6 好还不够,我要最好---支持向量机](Part2/Chapter5/5.2 监督学习/好还不够,我要最好---支持向量机.md)
* [5.2.7 群众的力量时伟大的---随机森林](Part2/Chapter5/5.2 监督学习/群众的力量时伟大的---随机森林.md) * [5.2.7 群众的力量是伟大的---随机森林](Part2/Chapter5/5.2 监督学习/群众的力量是伟大的---随机森林.md)
* [5.2.8 知错能改善莫大焉---Adaboost](Part2/Chapter5/5.2 监督学习/知错能改善莫大焉---Adaboost.md) * [5.2.8 知错能改善莫大焉---Adaboost](Part2/Chapter5/5.2 监督学习/知错能改善莫大焉---Adaboost.md)
* [5.3 无监督学习]() * [5.3 无监督学习]()
* [5.3.1 物以类聚人以群分---k-Means](Part2/Chapter5/5.3 无监督学习/物以类聚人以群分---k-Means.md) * [5.3.1 物以类聚人以群分---k-Means](Part2/Chapter5/5.3 无监督学习/物以类聚人以群分---k Means.md)
* [5.3.2 用密度来聚类---DBSCAN](Part2/Chapter5/5.3 无监督学习/用密度来聚类---DBSCAN.md) * [5.3.2 用密度来聚类---DBSCAN](Part2/Chapter5/5.3 无监督学习/用密度来聚类---DBSCAN.md)
* [5.3.3 分久必合---AGNES](Part2/Chapter5/5.3 无监督学习/分久必合---AGNES.md) * [5.3.3 分久必合---AGNES](Part2/Chapter5/5.3 无监督学习/分久必合---AGNES.md)
* [5.3.4 最重要的才是我想要的---PCA](Part2/Chapter5/5.3 无监督学习/最重要的才是我想要的---PCA.md) * [5.3.4 最重要的才是我想要的---PCA](Part2/Chapter5/5.3 无监督学习/最重要的才是我想要的---PCA.md)

Binary file not shown.
Loading…
Cancel
Save