更新了部分文档

pull/758/head
jackfrued 2021-03-08 00:25:04 +08:00
parent 0d01379603
commit 4e091d9ba1
16 changed files with 876 additions and 25 deletions

View File

@ -316,7 +316,7 @@ if __name__ == '__main__':
但是切换作业是有代价的比如从语文切到数学要先收拾桌子上的语文书本、钢笔这叫保存现场然后打开数学课本、找出圆规直尺这叫准备新环境才能开始做数学作业。操作系统在切换进程或者线程时也是一样的它需要先保存当前执行的现场环境CPU寄存器状态、内存页等然后把新任务的执行环境准备好恢复上次的寄存器状态切换内存页等才能开始执行。这个切换过程虽然很快但是也需要耗费时间。如果有几千个任务同时进行操作系统可能就主要忙着切换任务根本没有多少时间去执行任务了这种情况最常见的就是硬盘狂响点窗口无反应系统处于假死状态。所以多任务一旦多到一个限度反而会使得系统性能急剧下降最终导致所有任务都做不好。
是否采用多任务的第二个考虑是任务的类型可以把任务分为计算密集型和I/O密集型。计算密集型任务的特点是要进行大量的计算消耗CPU资源比如对视频进行编码解码或者格式转换等等这种任务全靠CPU的运算能力虽然也可以用多任务完成但是任务越多花在任务切换的时间就越多CPU执行任务的效率就越低。计算密集型任务由于主要消耗CPU资源这类任务用Python这样的脚本语言去执行效率通常很低最能胜任这类任务的是C语言我们之前提到Python中有嵌入C/C++代码的机制。
是否采用多任务的第二个考虑是任务的类型可以把任务分为计算密集型和I/O密集型。计算密集型任务的特点是要进行大量的计算消耗CPU资源比如对视频进行编码解码或者格式转换等等这种任务全靠CPU的运算能力虽然也可以用多任务完成但是任务越多花在任务切换的时间就越多CPU执行任务的效率就越低。计算密集型任务由于主要消耗CPU资源这类任务用Python这样的脚本语言去执行效率通常很低最能胜任这类任务的是C语言我们之前提到Python中有嵌入C/C++代码的机制。
除了计算密集型任务其他的涉及到网络、存储介质I/O的任务都可以视为I/O密集型任务这类任务的特点是CPU消耗很少任务的大部分时间都在等待I/O操作完成因为I/O的速度远远低于CPU和内存的速度。对于I/O密集型任务如果启动多任务就可以减少I/O等待时间从而让CPU高效率的运转。有一大类的任务都属于I/O密集型任务这其中包括了我们很快会涉及到的网络应用和Web应用。
@ -324,9 +324,9 @@ if __name__ == '__main__':
### 单线程+异步I/O
现代操作系统对I/O操作的改进中最为重要的就是支持异步I/O。如果充分利用操作系统提供的异步I/O支持就可以用单进程单线程模型来执行多任务这种全新的模型称为事件驱动模型。Nginx就是支持异步I/O的Web服务器它在单核CPU上采用单进程模型就可以高效地支持多任务。在多核CPU上可以运行多个进程数量与CPU核心数相同充分利用多核CPU。用Node.js开发的服务器端程序也使用了这种工作模式这也是当下实现多任务编程的一种趋势
现代操作系统对I/O操作的改进中最为重要的就是支持异步I/O。如果充分利用操作系统提供的异步I/O支持就可以用单进程单线程模型来执行多任务这种全新的模型称为事件驱动模型。Nginx就是支持异步I/O的Web服务器它在单核CPU上采用单进程模型就可以高效地支持多任务。在多核CPU上可以运行多个进程数量与CPU核心数相同充分利用多核CPU。用Node.js开发的服务器端程序也使用了这种工作模式这也是当下并发编程的一种流行方案
在Python语言中单线程+异步I/O的编程模型称为协程有了协程的支持就可以基于事件驱动编写高效的多任务程序。协程最大的优势就是极高的执行效率因为子程序切换不是线程切换而是由程序自身控制因此没有线程切换的开销。协程的第二个优势就是不需要多线程的锁机制因为只有一个线程也不存在同时写变量冲突在协程中控制共享资源不用加锁只需要判断状态就好了所以执行效率比多线程高很多。如果想要充分利用CPU的多核特性最简单的方法是多进程+协程,既充分利用多核,又充分发挥协程的高效率,可获得极高的性能。关于这方面的内容,我稍后会做一个专题来进行讲解。
在Python语言中单线程+异步I/O的编程模型称为协程有了协程的支持就可以基于事件驱动编写高效的多任务程序。协程最大的优势就是极高的执行效率因为子程序切换不是线程切换而是由程序自身控制因此没有线程切换的开销。协程的第二个优势就是不需要多线程的锁机制因为只有一个线程也不存在同时写变量冲突在协程中控制共享资源不用加锁只需要判断状态就好了所以执行效率比多线程高很多。如果想要充分利用CPU的多核特性最简单的方法是多进程+协程,既充分利用多核,又充分发挥协程的高效率,可获得极高的性能。关于这方面的内容,在后续的课程中会进行讲解。
### 应用案例

View File

@ -102,7 +102,7 @@
// 查询垃圾分类的函数
search() {
if (this.word.trim().length > 0) {
let key = '9636cec76ee2593ba6b195e5b770b394'
let key = 'e8c5524dd2a365f20908ced735f8e480'
let url = `http://api.tianapi.com/txapi/lajifenlei/?key=${key}&word=${this.word}`
fetch(url)
.then(resp => resp.json())

View File

@ -954,7 +954,7 @@ Linux系统的命令通常都是如下所示的格式
8. 创建/激活/关闭交换分区 - **mkswap** / **swapon** / **swapoff**
> 说明:执行上面这些命令会带有一定的风险,如果不清楚这些命令的用法,最好不用随意使用,在使用的过程中,最好对照参考资料进行操作,并在操作前确认是否要这么做。
> **说明**:执行上面这些命令会带有一定的风险,如果不清楚这些命令的用法,最好不用随意使用,在使用的过程中,最好对照参考资料进行操作,并在操作前确认是否要这么做。
### 编辑器 - vim

View File

@ -1,5 +1,5 @@
drop database if exists hrs;
create database hrs default charset utf8mb4;
create database hrs default charset utf8mb4 collate utf8_bin;
use hrs;

View File

@ -46,7 +46,7 @@ def export_teachers_excel(request):
# 中文文件名需要处理成百分号编码
filename = quote('老师.xls')
# 通过响应头告知浏览器下载该文件以及对应的文件名
resp['content-disposition'] = f'attachment; filename*=utf-8''{filename}'
resp['content-disposition'] = f'attachment; filename*=utf-8\'\'{filename}'
return resp
```

View File

@ -225,7 +225,7 @@ XPath是在XML文档中查找信息的一种语法它使用路径表达式来
<price>29.99</price>
</book>
<book>
<title lang="eng">Learning XML</title>
<title lang="zh">三国演义</title>
<price>39.95</price>
</book>
</bookstore>

View File

@ -103,7 +103,7 @@ Numpy最为核心的数据类型是`ndarray`,使用`ndarray`可以处理一维
产生10个$[1, 100)$范围的随机整数,代码:
```Python
array5 = np.random.randint(1, 101, 10)
array5 = np.random.randint(1, 100, 10)
array5
```
@ -1124,7 +1124,7 @@ print(np.power(array37, array38))
| 函数 | 说明 |
| --------------------------------- | ---- |
| `add(x, y)` / `substract(x, y)` / `multiply` | 加法函数 / 减法函数 |
| `add(x, y)` / `substract(x, y)` | 加法函数 / 减法函数 |
|`multiply(x, y)` / `divide(x, y)`|乘法函数 / 除法函数|
| `floor_divide(x, y)` / `mod(x, y)` | 整除函数 / 求模函数 |
|`allclose(x, y)`|检查数组`x`和`y`元素是否几乎相等|
@ -1139,7 +1139,7 @@ print(np.power(array37, array38))
| `setdiff1d(x, y)` | 计算`x`和`y`的差集,返回这些元素构成的数组 |
| `setxor1d(x, y)` | 计算`x`和`y`的对称差,返回这些元素构成的数组 |
>**补充说明:在二维空间内,两个向量$\boldsymbol{A}=\begin{bmatrix} a_1 \\ a_2 \end{bmatrix}$和$\boldsymbol{B}=\begin{bmatrix} b_1 \\ b_2 \end{bmatrix}$的叉积是这样定义的:$\boldsymbol{A}\times \boldsymbol{B}=\begin{vmatrix} a_1 \quad a_2 \\ b_1 \quad b_2 \end{vmatrix}=a_1b_2 - a_2b_1$,其中$\begin{vmatrix} a_1 \quad a_2 \\ b_1 \quad b_2 \end{vmatrix}$称为行列式。但是一定要注意,叉积并不等同于行列式,行列式的运算结果是一个标量,而叉积运算的结果是一个向量。如果不明白,我们可以看看三维空间两个向量,$\boldsymbol{A}=\begin{bmatrix} a_1 \\ a_2 \\ a_3 \end{bmatrix}$和$\boldsymbol{B}=\begin{bmatrix} b_1 \\ b_2 \\ b_3 \end{bmatrix}$的叉积是$\left< \hat{i} \begin{vmatrix} a_2 \quad a_3 \\ b_2 \quad b_3 \end{vmatrix}, -\hat{j} \begin{vmatrix} a_1 \quad a_3 \\ b_1 \quad b_3 \end{vmatrix}, \hat{k} \begin{vmatrix} a_1 \quad a_2 \\ b_1 \quad b_2 \end{vmatrix} \right>$,其中$\hat{i}, \hat{j}, \hat{k}$代表每个维度的单位向量。
>**补充说明**:在二维空间内,两个向量$\boldsymbol{A}=\begin{bmatrix} a_1 \\ a_2 \end{bmatrix}$和$\boldsymbol{B}=\begin{bmatrix} b_1 \\ b_2 \end{bmatrix}$的叉积是这样定义的:$\boldsymbol{A}\times \boldsymbol{B}=\begin{vmatrix} a_1 \quad a_2 \\ b_1 \quad b_2 \end{vmatrix}=a_1b_2 - a_2b_1$,其中$\begin{vmatrix} a_1 \quad a_2 \\ b_1 \quad b_2 \end{vmatrix}$称为行列式。但是一定要注意,叉积并不等同于行列式,行列式的运算结果是一个标量,而叉积运算的结果是一个向量。如果不明白,我们可以看看三维空间两个向量,$\boldsymbol{A}=\begin{bmatrix} a_1 \\ a_2 \\ a_3 \end{bmatrix}$和$\boldsymbol{B}=\begin{bmatrix} b_1 \\ b_2 \\ b_3 \end{bmatrix}$的叉积是$\left< \hat{i} \begin{vmatrix} a_2 \quad a_3 \\ b_2 \quad b_3 \end{vmatrix}, -\hat{j} \begin{vmatrix} a_1 \quad a_3 \\ b_1 \quad b_3 \end{vmatrix}, \hat{k} \begin{vmatrix} a_1 \quad a_2 \\ b_1 \quad b_2 \end{vmatrix} \right>$,其中$\hat{i}, \hat{j}, \hat{k}$代表每个维度的单位向量。
#### 广播机制

View File

@ -2,23 +2,356 @@
Pandas是Wes McKinney在2008年开发的一个强大的**分析结构化数据**的工具集。Pandas以NumPy为基础数据表示和运算提供了用于数据处理的函数和方法对数据分析和数据挖掘提供了很好的支持同时Pandas还可以跟数据可视化工具Matplotlib很好的整合在一起非常轻松愉快的实现数据的可视化展示。
Pandas核心的数据类型是`Series`、`DataFrame`,分别用于处理一维和二维的数据,除此之外还有一个名为`Index`的类型及其子类型,它为`Series`和`DataFrame`提供了索引功能。日常工作中以`DataFrame`使用最为广泛因为二维的数据本质就是一个有行有列的表格想一想Excel电子表格和关系型数据库中的二维表。上述这些类型都提供了大量的处理数据的方法数据分析师可以以此为基础实现对数据的各种常规处理。
Pandas核心的数据类型是`Series`(数据系列)、`DataFrame`(数据表/数据框),分别用于处理一维和二维的数据,除此之外还有一个名为`Index`的类型及其子类型,它为`Series`和`DataFrame`提供了索引功能。日常工作中以`DataFrame`使用最为广泛因为二维的数据本质就是一个有行有列的表格想一想Excel电子表格和关系型数据库中的二维表。上述这些类型都提供了大量的处理数据的方法数据分析师可以以此为基础实现对数据的各种常规处理。
### Series的应用
Pandas库中的`Series`对象可以用来表示一维数据结构,跟数组非常类似,但是多了一些额外的功能。`Series`的内部结构包含了两个数组,其中一个用来保存数据,另一个用来保存数据的索引,如下图所示。
![](res/pandas-series.png)
#### 创建Series对象
> **提示**在执行下面的代码之前请先导入pandas以及相关的库文件具体的做法可以参考上一章。
- 方法1通过列表或数组创建Series对象。
####基本属性和方法
代码:
```Python
# data参数表示数据index参数表示索引标签
# 如果没有指定index属性默认使用数字索引
ser1 = pd.Series(data=[320, 180, 300, 405], index=['一季度', '二季度', '三季度', '四季度'])
ser1
```
输出:
```
一季度 320
二季度 180
三季度 300
四季度 405
dtype: int64
```
- 方法2通过字典创建Series对象。
代码:
```Python
# 字典中的键就是索引标签,字典中的值就是数据
ser2 = pd.Series({'一季度': 320, '二季度': 180, '三季度': 300, '四季度': 405})
ser2
```
输出:
```
一季度 320
二季度 180
三季度 300
四季度 405
dtype: int64
```
#### 索引和切片
跟数组一样Series对象也可以进行索引和切片操作不同的是Series对象因为内部维护了一个保存索引的数组所以除了可以使用整数索引通过位置检索数据外还可以通过自己设置的索引标签获取对应的数据。
- 使用正负向整数索引
代码:
```Python
print(ser2[0], ser2[2], ser2[-1])
ser2[0], ser2[-1] = 350, 360
print(ser2)
```
输出:
```
320 300 405
一季度 350
二季度 180
三季度 300
四季度 360
dtype: int64
```
- 使用自己设置的标签索引
代码:
```Python
print(ser2['一季度'], ser2['三季度'])
ser2['一季度'] = 380
print(ser2)
```
输出:
```
350 300
一季度 380
二季度 180
三季度 300
四季度 360
dtype: int64
```
- 切片操作
代码:
```Python
print(ser2[1:3])
print(ser2['二季度':'四季度'])
```
输出:
```
二季度 180
三季度 300
dtype: int64
二季度 500
三季度 500
四季度 520
dtype: int64
```
代码:
```Python
ser2[1:3] = 400, 500
ser2
```
输出:
```
一季度 380
二季度 400
三季度 500
四季度 360
dtype: int64
```
- 花式索引
代码:
```Python
print(ser2[['二季度', '四季度']])
ser2[['二季度', '四季度']] = 500, 520
print(ser2)
```
输出:
```
二季度 400
四季度 360
dtype: int64
一季度 380
二季度 500
三季度 500
四季度 520
dtype: int64
```
- 布尔索引
代码:
```Python
ser2[ser2 >= 500]
```
输出:
```
二季度 500
三季度 500
四季度 520
dtype: int64
```
####属性和方法
Series对象的常用属性如下表所示。
| 属性 | 说明 |
| ------------------------- | --------------------------------------- |
| `dtype` / `dtypes` | 返回`Series`对象的数据类型 |
| `hasnans` | 判断`Series`对象中有没有空值 |
| `at` / `iat` | 通过索引访问`Series`对象中的单个值 |
| `loc` / `iloc` | 通过一组索引访问`Series`对象中的一组值 |
| `index` | 返回`Series`对象的索引 |
| `is_monotonic` | 判断`Series`对象中的数据是否单调 |
| `is_monotonic_increasing` | 判断`Series`对象中的数据是否单调递增 |
| `is_monotonic_decreasing` | 判断`Series`对象中的数据是否单调递减 |
| `is_unique` | 判断`Series`对象中的数据是否独一无二 |
| `size` | 返回`Series`对象中元素的个数 |
| `values` | 以`ndarray`的方式返回`Series`对象中的值 |
`Series`对象的方法很多,我们通过下面的代码为大家介绍一些常用的方法。
- 统计相关方法
代码:
```Python
# 求和
print(ser2.sum())
# 求均值
print(ser2.mean())
# 求最大
print(ser2.max())
# 求最小
print(ser2.min())
# 计数
print(ser2.count())
# 求标准差
print(ser2.std())
# 求方差
print(ser2.var())
# 求中位数
print(ser2.median())
```
输出:
```
1900
475.0
520
380
4
64.03124237432849
4100.0
500.0
```
`Series`对象还有一个名为`describe()`的方法,可以获得上述所有的描述性统计信息,如下所示。
代码:
```Python
ser2.describe()
```
输出:
```
count 4.000000
mean 475.000000
std 64.031242
min 380.000000
25% 470.000000
50% 500.000000
75% 505.000000
max 520.000000
dtype: float64
```
> **提示**:因为`describe()`返回的也是一个`Series`对象,所以也可以用`ser2.describe()['mean']`来获取平均值。
如果`Series`对象的数据中有重复元素,我们可以使用`unique()`方法获得去重之后的`Series`对象,如果想要统计重复元素重复的次数,可以使用`value_counts()`方法,这个方法会返回一个`Series`对象,它的索引就是原来的`Series`对象中的元素,而每个元素出现的次数就是返回的`Series`对象中的数据,在默认情况下会按照元素出现次数做降序排列。
代码:
```Python
ser3 = pd.Series(data=['apple', 'banana', 'apple', 'pitaya', 'apple', 'pitaya', 'durian'])
ser3.value_counts()
```
输出:
```
apple 3
pitaya 2
durian 1
banana 1
dtype: int64
```
- 数据处理方法
`Series`对象的`dropna`和`fillna`方法分别用来删除空值和填充空值,具体的用法如下所示。
```Python
ser4 = pd.Series(data=[10, 20, np.NaN, 30, np.NaN])
ser4.dropna()
```
输出:
```
0 10.0
1 20.0
3 30.0
dtype: float64
```
代码:
```Python
# 将空值填充为40
ser4.fillna(value=40)
```
输出:
```
0 10.0
1 20.0
2 40.0
3 30.0
4 40.0
dtype: float64
```
代码:
```Python
# backfill或bfill表示用后一个元素的值填充空值
# ffill或pad表示用前一个元素的值填充空值
ser4.fillna(method='ffill')
```
输出:
```
0 10.0
1 20.0
2 20.0
3 30.0
4 30.0
dtype: float64
```
需要提醒大家注意的是,`dropna`和`fillna`方法都有一个名为`inplace`的参数,它的默认值是`False`,表示删除空值或填充空值不会修改原来的`Series`对象,而是返回一个新的`Series`对象来表示删除或填充空值后的数据系列,如果将`inplace`参数的值修改为`True`,那么删除或填充空值会就地操作,直接修改原来的`Series`对象,那么方法的返回值是`None`。后面我们会接触到的很多方法,包括`DataFrame`对象的很多方法都会有这个参数,它们的意义跟这里是一样的。
`Series`对象的`apply`和`map`方法可以用于对数据进行处理,代码如下所示。
`Series`对象的`mask`和`where`方法可以将满足或不满足条件的值进行替换。
`Series`对象的`sort_index`和`sort_values`方法可以用于对索引和数据的排序,具体的用法请参考下面的例子。
`Series`对象的`value_counts`方法可以统计每个值出现的次数并且以从大到小的顺序进行排列,`Series`对象的`unique`方法可以获取到不重复的值。
#### 绘制图表
Series对象有一个名为`plot`的方法可以用来生成图表如果选择生成折线图、散点图、柱状图等默认会使用Series对象的索引作为横坐标使用Series对象的数据作为纵坐标。
#### Index的使用
利用Series对象的数据也可以生成表示占比的饼图和显示数据分布的直方图如下面的代码所示。

View File

@ -0,0 +1,424 @@
{
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"import pandas as pd\n",
"import matplotlib.pyplot as plt"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"%matplotlib inline\n",
"%config InlineBackend.figure_format='svg'"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"plt.rcParams['font.sans-serif'] = 'FZJKai-Z03S'\n",
"plt.rcParams['axes.unicode_minus'] = False"
]
},
{
"cell_type": "code",
"execution_count": 61,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"一季度 320\n",
"二季度 180\n",
"三季度 300\n",
"四季度 405\n",
"dtype: int64"
]
},
"execution_count": 61,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"ser1 = pd.Series(data=[320, 180, 300, 405], index=['一季度', '二季度', '三季度', '四季度'])\n",
"ser1"
]
},
{
"cell_type": "code",
"execution_count": 62,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"一季度 320\n",
"二季度 180\n",
"三季度 300\n",
"四季度 405\n",
"dtype: int64"
]
},
"execution_count": 62,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"ser2 = pd.Series({'一季度': 320, '二季度': 180, '三季度': 300, '四季度': 405})\n",
"ser2"
]
},
{
"cell_type": "code",
"execution_count": 63,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"320 300 405\n",
"一季度 350\n",
"二季度 180\n",
"三季度 300\n",
"四季度 360\n",
"dtype: int64\n"
]
}
],
"source": [
"print(ser2[0], ser2[2], ser2[-1])\n",
"ser2[0], ser2[-1] = 350, 360 \n",
"print(ser2)"
]
},
{
"cell_type": "code",
"execution_count": 64,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"350 300\n",
"一季度 380\n",
"二季度 180\n",
"三季度 300\n",
"四季度 360\n",
"dtype: int64\n"
]
}
],
"source": [
"print(ser2['一季度'], ser2['三季度'])\n",
"ser2['一季度'] = 380\n",
"print(ser2)"
]
},
{
"cell_type": "code",
"execution_count": 65,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"二季度 180\n",
"三季度 300\n",
"dtype: int64\n",
"二季度 180\n",
"三季度 300\n",
"四季度 360\n",
"dtype: int64\n",
"一季度 380\n",
"二季度 400\n",
"三季度 500\n",
"四季度 360\n",
"dtype: int64\n"
]
}
],
"source": [
"print(ser2[1:3])\n",
"print(ser2['二季度': '四季度'])\n",
"ser2[1:3] = 400, 500\n",
"print(ser2)"
]
},
{
"cell_type": "code",
"execution_count": 66,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"二季度 400\n",
"四季度 360\n",
"dtype: int64\n",
"一季度 380\n",
"二季度 500\n",
"三季度 500\n",
"四季度 520\n",
"dtype: int64\n"
]
}
],
"source": [
"print(ser2[['二季度', '四季度']])\n",
"ser2[['二季度', '四季度']] = 500, 520\n",
"print(ser2)"
]
},
{
"cell_type": "code",
"execution_count": 68,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"二季度 500\n",
"三季度 500\n",
"四季度 520\n",
"dtype: int64\n"
]
}
],
"source": [
"print(ser2[ser2 >= 500])"
]
},
{
"cell_type": "code",
"execution_count": 70,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1900\n",
"475.0\n",
"520\n",
"380\n",
"4\n",
"64.03124237432849\n",
"4100.0\n",
"500.0\n"
]
}
],
"source": [
"# 求和\n",
"print(ser2.sum())\n",
"# 求均值\n",
"print(ser2.mean())\n",
"# 求最大\n",
"print(ser2.max())\n",
"# 求最小\n",
"print(ser2.min())\n",
"# 计数\n",
"print(ser2.count())\n",
"# 求标准差\n",
"print(ser2.std())\n",
"# 求方差\n",
"print(ser2.var())\n",
"# 求中位数\n",
"print(ser2.median())"
]
},
{
"cell_type": "code",
"execution_count": 78,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"count 4.000000\n",
"mean 475.000000\n",
"std 64.031242\n",
"min 380.000000\n",
"25% 470.000000\n",
"50% 500.000000\n",
"75% 505.000000\n",
"max 520.000000\n",
"dtype: float64"
]
},
"execution_count": 78,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"ser2.describe()"
]
},
{
"cell_type": "code",
"execution_count": 99,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"apple 3\n",
"pitaya 2\n",
"durian 1\n",
"banana 1\n",
"dtype: int64"
]
},
"execution_count": 99,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"ser3 = pd.Series(data=['apple', 'banana', 'apple', 'pitaya', 'apple', 'pitaya', 'durian'])\n",
"ser3.value_counts()"
]
},
{
"cell_type": "code",
"execution_count": 80,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0 10.0\n",
"1 20.0\n",
"3 30.0\n",
"dtype: float64"
]
},
"execution_count": 80,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"ser4 = pd.Series(data=[10, 20, np.NaN, 30, np.NaN])\n",
"ser4.dropna()"
]
},
{
"cell_type": "code",
"execution_count": 82,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0 10.0\n",
"1 20.0\n",
"2 40.0\n",
"3 30.0\n",
"4 40.0\n",
"dtype: float64"
]
},
"execution_count": 82,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"ser4.fillna(value=40)"
]
},
{
"cell_type": "code",
"execution_count": 98,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0 10.0\n",
"1 20.0\n",
"2 20.0\n",
"3 30.0\n",
"4 30.0\n",
"dtype: float64"
]
},
"execution_count": 98,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"ser4.fillna(method='ffill')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.7"
},
"toc": {
"base_numbering": 1,
"nav_menu": {},
"number_sections": true,
"sideBar": true,
"skip_h1_title": false,
"title_cell": "Table of Contents",
"title_sidebar": "Contents",
"toc_cell": false,
"toc_position": {},
"toc_section_display": true,
"toc_window_display": false
}
},
"nbformat": 4,
"nbformat_minor": 2
}

View File

@ -0,0 +1,45 @@
{
"cells": [
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.7"
},
"toc": {
"base_numbering": 1,
"nav_menu": {},
"number_sections": true,
"sideBar": true,
"skip_h1_title": false,
"title_cell": "Table of Contents",
"title_sidebar": "Contents",
"toc_cell": false,
"toc_position": {},
"toc_section_display": true,
"toc_window_display": false
}
},
"nbformat": 4,
"nbformat_minor": 2
}

View File

@ -0,0 +1,45 @@
{
"cells": [
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.7"
},
"toc": {
"base_numbering": 1,
"nav_menu": {},
"number_sections": true,
"sideBar": true,
"skip_h1_title": false,
"title_cell": "Table of Contents",
"title_sidebar": "Contents",
"toc_cell": false,
"toc_position": {},
"toc_section_display": true,
"toc_window_display": false
}
},
"nbformat": 4,
"nbformat_minor": 2
}

Binary file not shown.

After

Width:  |  Height:  |  Size: 80 KiB

View File

@ -1,4 +1,4 @@
## Docker容器详解
## Docker容器技术详解
Docker是基于Go语言开发的开源应用容器引擎遵从Apache Licence 2.0协议可以让开发者打包应用以及应用的依赖包到一个可移植的容器中然后发布到各种发行版本的Linux系统上。

View File

@ -394,7 +394,7 @@ Python在以下领域都有用武之地。
### Day86~90 - [大数据分析概述](./Day86-90)
####Day86 - [大数据概述](./Day86-90/86.大数据概述.md)
#### Day86 - [大数据概述](./Day86-90/86.大数据概述.md)
#### Day87 - [Hive查询](./Day86-90/87.Hive查询.md)

View File

@ -250,7 +250,11 @@ deploy:
```Markdown
---
title: Python编程惯例
category: Python基础
categories:
- Python基础
tags:
- Python
- PEP8
date: 2019-8-1
---
## Python惯例

View File

@ -12,23 +12,23 @@ PyCharm是由JetBrains公司开发的提供给Python专业的开发者的一个
第一次使用PyCharm时会有一个导入设置的向导如果之前没有使用PyCharm或者没有保存过设置的就直接选择“Do not import settings”进入下一步即可下面是我在macOS系统下第一次使用PyCharm时的截图。
![](./res/pycharm-import-settings.png)
![](res/pycharm-import-settings.png)
专业版的PyCharm是需要激活的**强烈建议大家在条件允许的情况下支付费用来支持优秀的产品**如果不用做商业用途或者不需要使用PyCharm的高级功能我们可以暂时选择试用30天或者使用社区版的PyCharm。如果你是一名学生希望购买PyCharm来使用可以看看[教育优惠官方申请指南](https://sales.jetbrains.com/hc/zh-cn/articles/207154369)。如下图所示我们需要点击“Evaluate”按钮来试用专业版PyCharm。
![](./res/pycharm-activation.png)
![](res/pycharm-activation.png)
接下来是选择UI主题可以根据个人喜好进行选择深色的主题比较护眼而浅色的主题对比度更好。
![](./res/pycharm-ui-themes.png)
![](res/pycharm-ui-themes.png)
再接下来是创建可以在“终端”或“命令行提示符”中运行PyCharm的启动脚本当然也可以不做任何勾选直接点击“Next: Featured plugins”按钮进入下一环节。
![](./res/pycharm-create-launcher.png)
![](res/pycharm-create-launcher.png)
然后可以选择需要安装哪些插件,我们可以暂时什么都不安装,等需要的时候再来决定。
![](./res/pycharm-install-plugins.png)
![](res/pycharm-install-plugins.png)
最后点击上图右下角的“Start using PyCharm”开始使用PyCharm就可以开启你的PyCharm之旅了。
@ -36,17 +36,17 @@ PyCharm是由JetBrains公司开发的提供给Python专业的开发者的一个
启动PyCharm之后会来到一个欢迎页在欢迎页上我们可以选择“创建新项目”Create New Project、“打开已有项目”Open和“从版本控制系统中检出项目”Get from Version Control
![](./res/pycharm-welcome.png)
![](res/pycharm-welcome.png)
如果选择了“Create New Project”来创建新项目就会打一个创建项目的向导页。下图所示是PyCharm专业版创建新项目的向导页可以看出专业版支持的项目类型非常的多而社区版只能创建纯Python项目Pure Python没有这一系列的选项。
![](./res/pycharm-project-wizard.png)
![](res/pycharm-project-wizard.png)
接下来我们要为项目创建专属的虚拟环境每个Python项目最好都在自己专属的虚拟环境中运行因为每个项目对Python解释器和三方库的需求并不相同虚拟环境对不同的项目进行了隔离。在上图所示的界面在我们可以选择新建虚拟环境New environment using Virtualenv这里的“Virtualenv”是PyCharm默认选择的创建虚拟环境的工具我们就保留这个默认的选项就可以了。
项目创建完成后就可以开始新建各种文件来书写Python代码了如下图所示。左侧是项目浏览器可以看到刚才创建的项目文件夹以及虚拟环境文件夹。我们可以在项目上点击鼠标右键选择“New”在选择“Python File”来创建Python代码文件下图中我们创建了两个Python文件分别是`poker_game.py`和`salary_system.py`。当然如果愿意也可以使用复制粘贴的方式把其他地方的Python代码文件复制到项目文件夹下。
![](./res/pycharm-workspace.png)
![](res/pycharm-workspace.png)
在工作窗口点击鼠标右键可以在上下文菜单中找到“Run”选项例如要运行`salary_system.py`文件右键菜单会显示“Run 'salary_system'”选项点击这个选项我们就可以运行Python代码啦运行结果在屏幕下方的窗口可以看到如下图所示。