之前开发了一个工具包 GerapyPyppeteer，GitHub 地址为 https://github.com/Gerapy/GerapyPyppeteer，这个包实现了 Scrapy 和 Pyppeteer 的对接，利用它我们就可以方便地实现 Scrapy 使用 Pyppeteer 爬取动态渲染的页面了。 另外，很多朋友在运行爬虫的时候可能会使用到 Docker，想把 Scrapy 和 Pyppeteer 打包成 Docker 运行，但是这个打包和测试过程中大家可能会遇到一些问题，在这里对 Pyppeteer 打包 Docker 的坑简单做一下总结。

概述

Pyppeteer 打包 Docker 主要是有这么几个坑点：

• 依赖没有安装，导致无法正确安装和启动 Pyppeteer。
• 没有关闭沙盒模式，导致可能出现 Browser closed unexpectedly 错误
• 没有提前安装好 Pyppeteer，导致每次启动时都要重新安装

下面我们分别对三个问题做下简单的 Troubleshooting。

安装依赖

首先说第一个，安装依赖。 因为 Docker 大部分都是基于 Linux 系统的，比如我常用的基础镜像就是 python:3.7，剩余 Debian 系列，当然还有很多其他的版本，具体可以查看 https://hub.docker.com/_/python 了解下。 但是对于 Pyppeteer 来说，python:3.7 内置的依赖库并不够，我们还需要额外进行安装，安装完毕之后还需要清空下 apt list，一句 Dockerfile 命令如下：

1
2
3
4
5
6
7

RUN apt-get update && 
  apt-get -y install libnss3 xvfb gconf-service libasound2 libatk1.0-0 libc6 libcairo2 libcups2 
  libdbus-1-3 libexpat1 libfontconfig1 libgbm1 libgcc1 libgconf-2-4 libgdk-pixbuf2.0-0 libglib2.0-0 
  libgtk-3-0 libnspr4 libpango-1.0-0 libpangocairo-1.0-0 libstdc++6 libx11-6 libx11-xcb1 libxcb1 
  libxcomposite1 libxcursor1 libxdamage1 libxext6 libxfixes3 libxi6 libxrandr2 libxrender1 libxss1 
  libxtst6 ca-certificates fonts-liberation libappindicator1 libnss3 lsb-release xdg-utils wget && 
  rm -rf /var/lib/apt/lists/*

关闭沙盒模式

在 Docker 中如果直接启动 Pyppeteer，我们还需要关闭沙盒模式，否则可能会遇到如下错误：

1
2

pyppeteer.errors.BrowserError: Browser closed unexpectedly:
[0924/153706.301300:ERROR:zygote_host_impl_linux.cc(89)] Running as root without --no-sandbox is not supported. See https://crbug.com/638180

这里提示我们要关闭沙盒模式，这里只需要在启动 Pyppeteer 的时候，给 launch 方法的 args 参数多加一个 \--no-sandbox 即可，写法如下：

1

browser = await pyppeteer.launch(options={'args': ['--no-sandbox']})

这样就不会再遇到上面的错误了。

提前安装

另外建议在打包 Docker 的时候就提前把 Pyppeteer 提前安装好，可以单独使用一句 RUN 命令安装即可。

1

RUN pip install -U pip && pip install pyppeteer && pyppeteer-install

这里是提前安装了一下 Pyppteer 这个 Python 库，然后利用 Python 库提供的 pyppeteer-install 命令提前下载了 Chromium 浏览器。 这样后面启动的时候就可以直接唤起 Chromium 浏览器进行爬取了。

总结

最后看下完整 Dockerfile，内容如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

FROM python:3.7

RUN apt-get update && 
  apt-get -y install libnss3 xvfb gconf-service libasound2 libatk1.0-0 libc6 libcairo2 libcups2 
  libdbus-1-3 libexpat1 libfontconfig1 libgbm1 libgcc1 libgconf-2-4 libgdk-pixbuf2.0-0 libglib2.0-0 
  libgtk-3-0 libnspr4 libpango-1.0-0 libpangocairo-1.0-0 libstdc++6 libx11-6 libx11-xcb1 libxcb1 
  libxcomposite1 libxcursor1 libxdamage1 libxext6 libxfixes3 libxi6 libxrandr2 libxrender1 libxss1 
  libxtst6 ca-certificates fonts-liberation libappindicator1 libnss3 lsb-release xdg-utils wget && 
  rm -rf /var/lib/apt/lists/*

RUN pip install -U pip && pip install pyppeteer && pyppeteer-install

WORKDIR /code
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD python3 run.py

这里首先就是安装了必须的依赖库，然后安装了 Pyppeteer 并下载了 Chromium 浏览器，最后拷贝项目运行即可。 当然最后的一句 CMD 大家可以随意指定入口。 最后大家可以体验一个实例来感受下 Scrapy 和 Pyppeteer 对接后在 Docker 中的运行效果：

1

docker run germey/gerapy-pyppeteer-example

如果大家对 Scrapy 和 Pyppeteer 感兴趣也可以看下我写的这个库 GerapyPyppeteer，GitHub 地址为 https://github.com/Gerapy/GerapyPyppeteer，感谢支持！

解析页面是做爬虫的过程中的重要环节，而且如果站点多了，解析也会变得非常复杂，所以智能化解析就可能是一个不错的解决方案。如果我们能够容忍一定的错误率，那么我们可以利用智能化解析算法帮我们提取一些内容，简单高效。 那有没有办法做到一个网站的全自动化解析呢？ 比如来了一个博客网站，我能首先识别出来这是一个列表页还是文章（详情）页，然后提取列表页的每篇文章的链接，然后跳转到每篇文章（详情）页再提取文章相关信息。 那么这里面可能就有四个关键部分：

• 判断当前所在的页面是列表页还是文章（详情）页
• 识别出列表页下一页的链接
• 识别出列表页所有列表链接
• 识别出文章（详情）页的文章内容和其他信息

如果我们能把这四步都用算法实现出来，那么我们只需要一个网站的主站链接就能轻松地把内容规整地爬取下来了。 那么这篇文章我们就来简单说下第一步，如何判断当前所在的页面的列表页还是文章（详情）页。

注：后文中文章页统一称之为详情页。

示例

列表页和详情页不知道大家有没有基本的概念了，列表页就是导航页，里面带有好多文章或新闻或详情链接，我们选一个链接点进去就是详情页。 比如说这里拿新浪体育来说，首页如图所示： 看到这里面有很多链接，就是一些页面导航集合，这个页面就是列表页。 然后我们随便点开一篇新闻报道，如图所示： 这里就是一篇新闻报道，带有醒目的标题、发布时间、正文等内容，这就是详情页。 现在我们要做的就是用一个算法来凭借 HTML 代码区分出来哪个是列表页，哪个是详情页。 最后的输入输出如下：

• 输入：一个页面的 HTML 代码
• 输出：这个页面是列表页还是详情页，并输出二者的判定概率。

模型选用

首先我们确认下这个问题是个什么问题。 很明显，结果要么是列表页，要么是详情页，就是个二分类问题。 那二分类问题怎么解决呢？实现一个基本的分类模型就好了。大范围就是传统机器学习和现在比较流行的深度学习。总体上来说，深度学习的精度和处理能力会强一点，但是想想我们现在的应用场景，后者要追求精度的话可能需要更多的标注数据，而前者也有比较不错的易用的模型了，比如 SVM。 所以，我们不妨先选用 SVM 模型来实现一个基本的二分类模型来试试看，效果如果已经很好了或者提升空间不大了，那就直接用就好了，如果效果比较差，那我们再选用其他模型来优化。 好，那就定下来了，我们用 SVM 模型来实现一下试试。

数据标注

既然要做分类模型，那么最重要的当然就是数据标注了，我们分两组就好了，一组是列表页，一组是详情页，我们先用手工配合爬虫找一些列表页和详情页的 HTML 代码，然后将其保存下来。 结果类似如下： 每个文件夹几百个就行了，数量不用太多，五花八门的页面混起来更好。

特征提取

既然要做 SVM，那么我们得想清楚要分清两个类别需要哪些特征。既然是特征，那我们就要选出二者不同的特征，这样更加有区分度。 比如这里我大体总结了有这么几个特征：

• 文本密度：正文页通常会包含密集的文字，比如一个 p 节点内部就包含几十上百个文字，如果用单个节点内的文字数目来表示文本密度的话，那么详情页的部分内容文本密度会很高。
• 超链接节点的数量和比例：一般来说列表页通常会包含多个超链接，而且很大比例都是超链接文本，而详情页却有很多的文字并不是超链接，比如正文。
• 符号密度：一般来说列表页通常会是一些标题导航，一般可能都不会包含句号，而详情页的正文内容通常就会包含句号等内容，如果按照单位文字所包含的标点符号数量来表示符号密度的话，后者的符号密度也会高一些。
• 列表簇的数目：一般来说，列表页通常会包含多个具有公共父节点的条目，多个条目构成一个列表簇，虽然说详情页侧栏也会包含一些列表，但至少这个数量也可以成为一个特征来判别。
• meta 信息：有一些特殊的 meta 信息是列表页独有的，比如只有详情页才会有发布时间，而列表页通常是没有的。
• 正文标题和 title 标题相似度：一般来说，详情页的正文标题和 title 标题很可能是相同的内容，而列表页通常则是站点的名称。

以上便是我简单列的几个特征，还有很多其他的特征也可以来挖掘，比如视觉特征等等。

模型训练

真正代码实现的过程就是将现有的 HTML 文本进行预处理，把上面的一些特征提取出来，然后直接声明一个 SVM 分类模型即可。 这里声明了一个 feature 名字和对应的处理方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

self.feature_funcs = {
    'number_of_a_char': number_of_a_char,
    'number_of_a_char_log10': self._number_of_a_char_log10,
    'number_of_char': number_of_char,
    'number_of_char_log10': self._number_of_char_log10,
    'rate_of_a_char': self._rate_of_a_char,
    'number_of_p_descendants': number_of_p_descendants,
    'number_of_a_descendants': number_of_a_descendants,
    'number_of_punctuation': number_of_punctuation,
    'density_of_punctuation': density_of_punctuation,
    'number_of_clusters': self._number_of_clusters,
    'density_of_text': density_of_text,
    'max_density_of_text': self._max_density_of_text,
    'max_number_of_p_children': self._max_number_of_p_children,
    'has_datetime_meta': self._has_datetime_mata,
    'similarity_of_title': self._similarity_of_title,
}
self.feature_names = self.feature_funcs.keys()

以上方法就是特征和对应的获取方法，具体根据实际情况实现即可。 然后关键的部分就是对数据的处理和模型的训练了，关键代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

list_file_paths = list(glob(f'{DATASETS_LIST_DIR}/*.html'))
detail_file_paths = list(glob(f'{DATASETS_DETAIL_DIR}/*.html'))

x_data, y_data = [], []

for index, list_file_path in enumerate(list_file_paths):
    logger.log('inspect', f'list_file_path {list_file_path}')
    element = file2element(list_file_path)
    if element is None:
        continue
    preprocess4list_classifier(element)
    x = self.features_to_list(self.features(element))
    x_data.append(x)
    y_data.append(1)

for index, detail_file_path in enumerate(detail_file_paths):
    logger.log('inspect', f'detail_file_path {detail_file_path}')
    element = file2element(detail_file_path)
    if element is None:
        continue
    preprocess4list_classifier(element)
    x = self.features_to_list(self.features(element))
    x_data.append(x)
    y_data.append(0)

# preprocess data
ss = StandardScaler()
x_data = ss.fit_transform(x_data)
joblib.dump(ss, self.scaler_path)
x_train, x_test, y_train, y_test = train_test_split(x_data, y_data, test_size=0.2, random_state=5)

# set up grid search
c_range = np.logspace(-5, 20, 5, base=2)
gamma_range = np.logspace(-9, 10, 5, base=2)
param_grid = [
    {'kernel': ['rbf'], 'C': c_range, 'gamma': gamma_range},
    {'kernel': ['linear'], 'C': c_range},
]
grid = GridSearchCV(SVC(probability=True), param_grid, cv=5, verbose=10, n_jobs=-1)
clf = grid.fit(x_train, y_train)
y_true, y_pred = y_test, clf.predict(x_test)
logger.log('inspect', f'n{classification_report(y_true, y_pred)}')
score = grid.score(x_test, y_test)
logger.log('inspect', f'test accuracy {score}')
# save model
joblib.dump(grid.best_estimator_, self.model_path)

这里首先对数据进行预处理，然后将每个 feature 存 存到 x_data 中，标注结果存到 y_data 中。接着我们使用 StandardScaler 对数据进行标准化处理，然后进行随机切分。最后使用 GridSearch 训练了一个 SVM 模型然后保存了下来。 以上便是基本的模型训练过程，具体的代码可以再完善一下。

使用

以上的流程我已经实现了，并且发布了一个开源 Python 包，名字叫做 Gerapy AutoExtractor，GitHub 地址为 https://github.com/Gerapy/GerapyAutoExtractor。 大家如需使用可以使用 pip 安装：

1

pip3 install gerapy-auto-extractor

这个库针对于以上算法提供了四个方法：

• is_detail：判断是否是详情页
• is_list：判断是否是列表页
• probability_of_detail：是详情页的概率，结果是 0-1
• probability_of_list：是列表页的概率，结果是 0-1

例如，我们随便可以找几个网址存下来，比如把上文的列表页和详情页的 HTML 代码存下来分别保存为 list.html 和 detail.html。 测试代码如下：

1
2
3
4
5
6
7
8
9
10

from gerapy_auto_extractor import is_detail, is_list, probability_of_detail, probability_of_list
from gerapy_auto_extractor.helpers import content, jsonify

html = content('detail.html')
print(probability_of_detail(html), probability_of_list(html))
print(is_detail(html), is_list(html))

html = content('list.html')
print(probability_of_detail(html), probability_of_list(html))
print(is_detail(html), is_list(html))

这里我们就调用了以上四个方法来实现了页面类型和置信度的判断。 类似的输出结果如下：

1
2
3
4

0.9990605314033392 0.0009394685966607814
True False
0.033477426883441685 0.9665225731165583
False True

这样我们就成功得到了两个页面的类别和置信度了。 以上便是判断列表页和详情页的原理和实现，如需了解更多请关注项目 Gerapy Auto Extractor，GitHub 链接为 https://github.com/Gerapy/GerapyAutoExtractor，多谢支持。

Airtest

首先需要安装 Airtest，使用 pip3 即可：

1

pip3 install airtest

初始化 device

如果设备没有被初始化的话会进行初始化，并把初始化的设备作为当前设备。 用法如下：

1
2
3
4
5
6
7
8
9

def init_device(platform="Android", uuid=None, **kwargs):
    """
    Initialize device if not yet, and set as current device.

    :param platform: Android, IOS or Windows
    :param uuid: uuid for target device, e.g. serialno for Android, handle for Windows, uuid for iOS
    :param kwargs: Optional platform specific keyword args, e.g. `cap_method=JAVACAP` for Android
    :return: device instance
    """

示例如下：

1
2

device = init_device('Android')
print(device)

运行结果如下：

1

<airtest.core.android.android.Android object at 0x1018f3a58>

可以发现它返回的是一个 Android 对象。 这个 Android 对象实际上属于 airtest.core.android 这个包，继承自 airtest.core.device.Device 这个类，与之并列的还有 airtest.core.ios.ios.IOS 、airtest.core.linux.linux.Linux、airtest.core.win.win.Windows 等。这些都有一些针对 Device 操作的 API，下面我们以 airtest.core.android.android.Android 为例来总结一下。

• get_default_device：获取默认 device
• uuid：获取当前 Device 的 UUID
• list_app：列举所有 App
• path_app：打印输出某个 App 的完整路径
• check_app：检查某个 App 是否在当前设备上
• start_app：启动某个 App
• start_app_timing：启动某个 App，然后计算时间
• stop_app：停止某个 App
• clear_app：清空某个 App 的全部数据
• install_app：安装某个 App
• install_multiple_app：安装多个 App
• uninstall_app：卸载某个 App
• snapshot：屏幕截图
• shell：获取 Adb Shell 执行的结果
• keyevent：执行键盘操作
• wake：唤醒当前设备
• home：点击 HOME 键
• text：向设备输入内容
• touch：点击屏幕某处的位置
• double_click：双击屏幕某处的位置
• swipe：滑动屏幕，由一点到另外一点
• pinch：手指捏和操作
• logcat：日志记录操作
• getprop：获取某个特定属性的值
• get_ip_address：获取 IP 地址
• get_top_activity：获取当前 Activity
• get_top_activity_name_and_pid：获取当前 Activity 的名称和进程号
• get_top_activity_name：获取当前 Activity 的名称
• is_keyboard_shown：判断当前键盘是否出现了
• is_locked：设备是否锁定了
• unlock：解锁设备
• display_info：获取当前显示信息，如屏幕宽高等
• get_display_info：同 display_info
• get_current_resolution：获取当前设备分辨率
• get_render_resolution：获取当前渲染分辨率
• start_recording：开始录制
• stop_recording：结束录制
• adjust_all_screen：调整屏幕适配分辨率

了解了上面的方法之后，我们可以用一个实例来感受下它们的用法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

from airtest.core.android import Android
from airtest.core.api import *
import logging

logging.getLogger("airtest").setLevel(logging.WARNING)

device: Android = init_device('Android')
is_locked = device.is_locked()
print(f'is_locked: {is_locked}')

if is_locked:
    device.unlock()

device.wake()

app_list = device.list_app()
print(f'app list {app_list}')

uuid = device.uuid
print(f'uuid {uuid}')

display_info = device.get_display_info()
print(f'display info {display_info}')

resolution = device.get_render_resolution()
print(f'resolution {resolution}')

ip_address = device.get_ip_address()
print(f'ip address {ip_address}')

top_activity = device.get_top_activity()
print(f'top activity {top_activity}')

is_keyboard_shown = device.is_keyboard_shown()
print(f'is keyboard shown {is_keyboard_shown}')

这里我们调用了设备的一些操作方法，获取了一些基本状态，运行结果如下：

1
2
3
4
5
6
7
8

is_locked: False
app list ['com.kimcy929.screenrecorder', 'com.android.providers.telephony', 'io.appium.settings', 'com.android.providers.calendar', 'com.android.providers.media', 'com.goldze.mvvmhabit', 'com.android.wallpapercropper', 'com.android.documentsui', 'com.android.galaxy4', 'com.android.externalstorage', 'com.android.htmlviewer', 'com.android.quicksearchbox', 'com.android.mms.service', 'com.android.providers.downloads', 'mark.qrcode', ..., 'com.google.android.play.games', 'io.kkzs', 'tv.danmaku.bili', 'com.android.captiveportallogin']
uuid emulator-5554
display info {'id': 0, 'width': 1080, 'height': 1920, 'xdpi': 320.0, 'ydpi': 320.0, 'size': 6.88, 'density': 2.0, 'fps': 60.0, 'secure': True, 'rotation': 0, 'orientation': 0.0, 'physical_width': 1080, 'physical_height': 1920}
resolution (0.0, 0.0, 1080.0, 1920.0)
ip address 10.0.2.15
top activity ('com.microsoft.launcher.dev', 'com.microsoft.launcher.Launcher', '16040')
is keyboard shown False

连接 device

连接 device 需要传入设备的 uri，格式类似 android://adbhost:adbport/serialno?param=value&param2=value2，使用方法如下：

1
2
3
4
5
6
7
8
9
10
11
12

def connect_device(uri):
    """
    Initialize device with uri, and set as current device.

    :param uri: an URI where to connect to device, e.g. `android://adbhost:adbport/serialno?param=value&param2=value2`
    :return: device instance
    :Example:
        * ``android:///`` # local adb device using default params
        * ``android://adbhost:adbport/1234566?cap_method=javacap&touch_method=adb``  # remote device using custom params
        * ``windows:///`` # local Windows application
        * ``ios:///`` # iOS device
    """

示例如下：

1
2
3
4
5
6

from airtest.core.android import Android
from airtest.core.api import *

uri = 'Android://127.0.0.1:5037/emulator-5554'
device: Android = connect_device(uri)
print(device)

运行结果如下：

1

<airtest.core.android.android.Android object at 0x110246940>

其实返回结果和 init_device 是一样的，最后 connect_device 方法就是调用了 init_device 方法。

获取当前 device

就是直接调用 device 方法，定义如下：

1
2
3
4
5
6
7

def device():
    """
    Return the current active device.

    :return: current device instance
    """
    return G.DEVICE

获取所有 device

在 airtest 中有一个全局变量 G，获取所有 device 的方法如下：

1
2
3
4
5
6
7

from airtest.core.android import Android
from airtest.core.api import *

print(G.DEVICE_LIST)
uri = 'Android://127.0.0.1:5037/emulator-5554'
device: Android = connect_device(uri)
print(G.DEVICE_LIST)

运行结果如下：

1
2

[]
[<airtest.core.android.android.Android object at 0x10ba03978>]

这里需要注意的是，在最开始没有调用 connect_device 方法之前，DEVICE_LIST 是空的，在调用之后 DEVICE_LIST 会自动添加已经连接的 device，DEVICE_LIST 就是已经连接的 device 列表

切换 device

我们可以使用 set_current 方法切换当前连接的 device，传入的是 index，定义如下：

1
2
3
4
5
6
7
8
9

def set_current(idx):
    """
    Set current active device.

    :param idx: uuid or index of initialized device instance
    :raise IndexError: raised when device idx is not found
    :return: None
    :platforms: Android, iOS, Windows
    """

这个方法没有返回值，调用 set_current 方法切换 device 之后，再调用 device 方法就可以获取当前 device 对象了。

执行命令行

可以使用 shell 方法传入 cmd 来执行命令行，定义如下：

1
2
3
4
5
6
7
8
9
10

@logwrap
def shell(cmd):
    """
    Start remote shell in the target device and execute the command

    :param cmd: command to be run on device, e.g. "ls /data/local/tmp"
    :return: the output of the shell cmd
    :platforms: Android
    """
    return G.DEVICE.shell(cmd)

直接调用 adb 命令就好了，例如获取内存信息就可以使用如下命令：

1
2
3
4
5
6
7

from airtest.core.api import *

uri = 'Android://127.0.0.1:5037/emulator-5554'
connect_device(uri)

result = shell('cat /proc/meminfo')
print(result)

运行结果如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

MemTotal:        3627908 kB
MemFree:         2655560 kB
MemAvailable:    2725928 kB
Buffers:            3496 kB
Cached:           147472 kB
SwapCached:            0 kB
Active:           744592 kB
Inactive:         126332 kB
Active(anon):     723292 kB
Inactive(anon):    16344 kB
Active(file):      21300 kB
Inactive(file):   109988 kB
Unevictable:           0 kB
Mlocked:               0 kB
HighTotal:       2760648 kB
HighFree:        2073440 kB
LowTotal:         867260 kB
LowFree:          582120 kB
SwapTotal:             0 kB
SwapFree:              0 kB
Dirty:                 0 kB
Writeback:             0 kB
AnonPages:        720100 kB
Mapped:           127720 kB
Shmem:             19428 kB
Slab:              76196 kB
SReclaimable:       7392 kB
SUnreclaim:        68804 kB
KernelStack:        7896 kB
PageTables:         8544 kB
NFS_Unstable:          0 kB
Bounce:                0 kB
WritebackTmp:          0 kB
CommitLimit:     1813952 kB
Committed_AS:   21521776 kB
VmallocTotal:     122880 kB
VmallocUsed:       38876 kB
VmallocChunk:      15068 kB
DirectMap4k:       16376 kB
DirectMap4M:      892928 kB

启动和停止 App

启动和停止 App 直接传入包名即可，其实它们就是调用的 device 的 start_app 和 stop_app 方法，定义如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

@logwrap
def start_app(package, activity=None):
    """
    Start the target application on device

    :param package: name of the package to be started, e.g. "com.netease.my"
    :param activity: the activity to start, default is None which means the main activity
    :return: None
    :platforms: Android, iOS
    """
    G.DEVICE.start_app(package, activity)

@logwrap
def stop_app(package):
    """
    Stop the target application on device

    :param package: name of the package to stop, see also `start_app`
    :return: None
    :platforms: Android, iOS
    """
    G.DEVICE.stop_app(package)

用法示例如下：

1
2
3
4
5
6
7
8
9

from airtest.core.api import *

uri = 'Android://127.0.0.1:5037/emulator-5554'
connect_device(uri)

package = 'com.tencent.mm'
start_app(package)
sleep(10)
stop_app(package)

这里我指定了微信的包名，然后调用 start_app 启动了微信，然后等待了 10 秒，然后调用了 stop_app 停止了微信。

安装和卸载

安装和卸载也是一样，也是调用了 device 的 install 和 uninstall 方法，定义如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

@logwrap
def install(filepath, **kwargs):
    """
    Install application on device

    :param filepath: the path to file to be installed on target device
    :param kwargs: platform specific `kwargs`, please refer to corresponding docs
    :return: None
    :platforms: Android
    """
    return G.DEVICE.install_app(filepath, **kwargs)

@logwrap
def uninstall(package):
    """
    Uninstall application on device

    :param package: name of the package, see also `start_app`
    :return: None
    :platforms: Android
    """
    return G.DEVICE.uninstall_app(package)

截图

截图使用 snapshot 即可完成，可以设定存储的文件名称，图片质量等。 定义如下：

1
2
3
4
5
6
7
8
9
10
11

def snapshot(filename=None, msg="", quality=ST.SNAPSHOT_QUALITY):
    """
    Take the screenshot of the target device and save it to the file.

    :param filename: name of the file where to save the screenshot. If the relative path is provided, the default
                     location is ``ST.LOG_DIR``
    :param msg: short description for screenshot, it will be recorded in the report
    :param quality: The image quality, integer in range [1, 99]
    :return: absolute path of the screenshot
    :platforms: Android, iOS, Windows
    """

示例如下：

1
2
3
4
5
6
7
8
9

from airtest.core.api import *

uri = 'Android://127.0.0.1:5037/emulator-5554'
connect_device(uri)

package = 'com.tencent.mm'
start_app(package)
sleep(3)
snapshot('weixin.png', quality=30)

运行之后在当前目录会生成一个 weixin.png 的图片，如图所示：

唤醒和首页

唤醒和回到首页分别也是调用了 device 的 wake 和 home 方法，定义如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

@logwrap
def wake():
    """
    Wake up and unlock the target device

    :return: None
    :platforms: Android

    .. note:: Might not work on some models
    """
    G.DEVICE.wake()

@logwrap
def home():
    """
    Return to the home screen of the target device.

    :return: None
    :platforms: Android, iOS
    """
    G.DEVICE.home()

直接调用即可。

点击屏幕

点击屏幕是 touch 方法，可以传入一张图或者绝对位置，同时可以指定点击次数，定义如下：

1
2
3
4
5
6
7
8
9
10
11

@logwrap
def touch(v, times=1, **kwargs):
    """
    Perform the touch action on the device screen

    :param v: target to touch, either a Template instance or absolute coordinates (x, y)
    :param times: how many touches to be performed
    :param kwargs: platform specific `kwargs`, please refer to corresponding docs
    :return: finial position to be clicked
    :platforms: Android, Windows, iOS
    """

例如我现在的手机屏幕是这样子： 这里我截图下来一张图片，如图所示： 然后我们把这个图片声明成一个 Template 传入，示例如下：

1
2
3
4
5

from airtest.core.api import *

uri = 'Android://127.0.0.1:5037/emulator-5554'
connect_device(uri)
touch(Template('tpl.png'))

启动之后它就会识别出这张图片的位置，然后点击。 或者我们可以指定点击的绝对位置，示例如下：

1
2
3
4
5
6

from airtest.core.api import *

uri = 'Android://127.0.0.1:5037/emulator-5554'
connect_device(uri)
home()
touch((400, 600), times=2)

另外上述的 touch 方法还可以完全等同于 click 方法。 如果要双击的话，还可以使用调用 double_click 方法，传入参数也可以是 Template 或者绝对位置。

滑动

滑动可以使用 swipe 方法，可以传入起始和终止位置，两个位置都可以传入绝对位置或者 Template，定义如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

@logwrap
def swipe(v1, v2=None, vector=None, **kwargs):
    """
    Perform the swipe action on the device screen.

    There are two ways of assigning the parameters
        * ``swipe(v1, v2=Template(...))``   # swipe from v1 to v2
        * ``swipe(v1, vector=(x, y))``      # swipe starts at v1 and moves along the vector.

    :param v1: the start point of swipe,
               either a Template instance or absolute coordinates (x, y)
    :param v2: the end point of swipe,
               either a Template instance or absolute coordinates (x, y)
    :param vector: a vector coordinates of swipe action, either absolute coordinates (x, y) or percentage of
                   screen e.g.(0.5, 0.5)
    :param **kwargs: platform specific `kwargs`, please refer to corresponding docs
    :raise Exception: general exception when not enough parameters to perform swap action have been provided
    :return: Origin position and target position
    :platforms: Android, Windows, iOS
    """

比如这里我们可以定义手指向右滑动：

1
2
3
4
5
6

from airtest.core.api import *

uri = 'Android://127.0.0.1:5037/emulator-5554'
connect_device(uri)
home()
swipe((200, 300), (900, 300))

放大缩小

放大缩小是使用的 pinch 方法，可以指定放大还是缩小，同时还可以指定中心位置点和放大缩小的比率。 定义如下：

1
2
3
4
5
6
7
8
9
10
11

@logwrap
def pinch(in_or_out='in', center=None, percent=0.5):
    """
    Perform the pinch action on the device screen

    :param in_or_out: pinch in or pinch out, enum in ["in", "out"]
    :param center: center of pinch action, default as None which is the center of the screen
    :param percent: percentage of the screen of pinch action, default is 0.5
    :return: None
    :platforms: Android
    """

示例如下：

1
2
3
4
5
6

from airtest.core.api import *

uri = 'Android://127.0.0.1:5037/emulator-5554'
connect_device(uri)
home()
pinch(in_or_out='out', center=(300, 300), percent=0.4)

键盘事件

可以使用 keyevent 来输入某个键，例如 home、back 等等，keyevent 的定义如下：

1
2
3
4
5
6
7
8
9

def keyevent(keyname, **kwargs):
    """
    Perform key event on the device

    :param keyname: platform specific key name
    :param **kwargs: platform specific `kwargs`, please refer to corresponding docs
    :return: None
    :platforms: Android, Windows, iOS
    """

示例如下：

1

keyevent("HOME")

这样就表示按了 HOME 键。

输入内容

输入内容需要使用 text 方法，当然前提是这个 widget 需要是 active 状态，text 的定义如下：

1
2
3
4
5
6
7
8
9
10

@logwrap
def text(text, enter=True, **kwargs):
    """
    Input text on the target device. Text input widget must be active first.

    :param text: text to input, unicode is supported
    :param enter: input `Enter` keyevent after text input, default is True
    :return: None
    :platforms: Android, Windows, iOS
    """

等待和判断

可以使用 wait 方法等待某个内容加载出来，需要传入的是 Template，定义如下：

1
2
3
4
5
6
7
8
9
10
11
12
13

@logwrap
def wait(v, timeout=None, interval=0.5, intervalfunc=None):
    """
    Wait to match the Template on the device screen

    :param v: target object to wait for, Template instance
    :param timeout: time interval to wait for the match, default is None which is ``ST.FIND_TIMEOUT``
    :param interval: time interval in seconds to attempt to find a match
    :param intervalfunc: called after each unsuccessful attempt to find the corresponding match
    :raise TargetNotFoundError: raised if target is not found after the time limit expired
    :return: coordinates of the matched target
    :platforms: Android, Windows, iOS
    """

同时也使用 exists 方法判断某个内容是否存在，定义如下：

1
2
3
4
5
6
7
8
9

@logwrap
def exists(v):
    """
    Check whether given target exists on device screen

    :param v: target to be checked
    :return: False if target is not found, otherwise returns the coordinates of the target
    :platforms: Android, Windows, iOS
    """

断言

另外 Airtest 还提供了几个断言语句来判断结果是否存在或者相同，定义如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

@logwrap
def assert_exists(v, msg=""):
    """
    Assert target exists on device screen

    :param v: target to be checked
    :param msg: short description of assertion, it will be recorded in the report
    :raise AssertionError: if assertion fails
    :return: coordinates of the target
    :platforms: Android, Windows, iOS
    """
    try:
        pos = loop_find(v, timeout=ST.FIND_TIMEOUT, threshold=ST.THRESHOLD_STRICT)
        return pos
    except TargetNotFoundError:
        raise AssertionError("%s does not exist in screen, message: %s" % (v, msg))

@logwrap
def assert_not_exists(v, msg=""):
    """
    Assert target does not exist on device screen

    :param v: target to be checked
    :param msg: short description of assertion, it will be recorded in the report
    :raise AssertionError: if assertion fails
    :return: None.
    :platforms: Android, Windows, iOS
    """
    try:
        pos = loop_find(v, timeout=ST.FIND_TIMEOUT_TMP)
        raise AssertionError("%s exists unexpectedly at pos: %s, message: %s" % (v, pos, msg))
    except TargetNotFoundError:
        pass

@logwrap
def assert_equal(first, second, msg=""):
    """
    Assert two values are equal

    :param first: first value
    :param second: second value
    :param msg: short description of assertion, it will be recorded in the report
    :raise AssertionError: if assertion fails
    :return: None
    :platforms: Android, Windows, iOS
    """
    if first != second:
        raise AssertionError("%s and %s are not equal, message: %s" % (first, second, msg))

@logwrap
def assert_not_equal(first, second, msg=""):
    """
    Assert two values are not equal

    :param first: first value
    :param second: second value
    :param msg: short description of assertion, it will be recorded in the report
    :raise AssertionError: if assertion
    :return: None
    :platforms: Android, Windows, iOS
    """
    if first == second:
        raise AssertionError("%s and %s are equal, message: %s" % (first, second, msg))

这几个断言比较常用的就是 assert_exists 和 assert_not_exists 判断某个目标是否存在于屏幕上，同时还可以传入 msg，它可以被记录到 report 里面。 以上就是 Airtest 的 API 的用法，它提供了一些便捷的方法封装，同时还对接了图像识别等技术。 但 Airtest 也有一定的局限性，比如不能根据 DOM 树来选择对应的节点，依靠图像识别也有一定的不精确之处，所以还需要另外一个库 —— Poco。

Poco

利用 Poco 我们可以支持 DOM 选择，例如编写 XPath 等来定位某一个节点。 首先需要安装 Poco，使用 pip3 即可：

1

pip3 install pocoui

安装好了之后我们便可以使用它来选择一些节点了，示例如下：

1
2
3
4
5
6
7
8
9

from airtest.core.api import *
from poco.drivers.android.uiautomation import AndroidUiautomationPoco

poco = AndroidUiautomationPoco()

uri = 'Android://127.0.0.1:5037/emulator-5554'
connect_device(uri)
home()
poco(text='Weather').click()

比如这里我们就声明了 AndroidUiautomationPoco 这个 Poco 对象，然后调用了 poco 传入一些选择器，选中之后执行 click 方法。 这个选择器非常强大，可以传入 name 和各个属性值，具体的使用方法见：https://poco.readthedocs.io/en/latest/source/poco.pocofw.html

1
2
3
4
5
6
7
8
9
10
11

from airtest.core.api import *
from poco.drivers.android.uiautomation import AndroidUiautomationPoco
from poco.proxy import UIObjectProxy

poco = AndroidUiautomationPoco()

uri = 'Android://127.0.0.1:5037/emulator-5554'
connect_device(uri)
home()
object: UIObjectProxy = poco("com.microsoft.launcher.dev:id/workspace")
print(object)

poco 返回的是 UIObjectProxy 对象，它提供了其他的操作 API，例如选取子节点，兄弟节点，父节点等等，同时可以调用各个操作方法，如 click、pinch、scroll 等等。 具体的操作文档可以参见：https://poco.readthedocs.io/en/latest/source/poco.proxy.html 下面简单总结：

• attr：获取节点属性
• child：获取子节点
• children：获取所有子节点
• click：点击
• double_click：双击
• drag_to：将某个节点拖拽到另一个节点
• exists：某个节点是否存在
• focus：获得焦点
• get_bounds：获取边界
• get_name：获取节点名
• get_position：获取节点位置
• get_size：获取节点大小
• get_text：获取文本内容
• long_click：长按
• offspring：选出包含直接子代的后代
• parent：父节点
• pinch：缩放
• scroll：滑动
• set_text：设置文字
• sibling：兄弟节点
• swipe：滑动
• wait：等待
• wait_for_appearance：等待某个节点出现
• wait_for_disappearance：等待某个节点消失

以上的这些方法混用的话就可以执行各种节点的选择和相应的操作。

最近遇到一个问题，那就是需要给别人共享一下 Kubernetes 的某个资源的使用和访问权限，这个仅仅存在于某个 namespace 下，但是我又不能把管理员权限全都给它，我想只给他授予这一个 Namespace 下的权限，那应该怎么办呢？ 比如我这边是需要只想授予 postgresql 这个 Namespace 的权限，这里我就需要利用到 Kubernetes 里面的 RBAC 机制来实现了，下面记录了我的操作流程。

创建 Namespace

1

kubectl create namespace postgresql

首先没有 Namespace 的话需要创建一个 Namespace，这里我创建的是 postgresql，大家可以自行修改。

创建 ServiceAccount

接下来需要创建一个 ServiceAccount，yaml 如下：

1
2
3
4
5

apiVersion: v1
kind: ServiceAccount
metadata:
  name: postgresql
  namespace: postgresql

创建 Role

然后还要创建一个 Role，来控制相应的权限，yaml 如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

kind: Role
apiVersion: rbac.authorization.k8s.io/v1beta1
metadata:
  name: postgresql
  namespace: postgresql
rules:
  - apiGroups: ["", "extensions", "apps"]
    resources: ["*"]
    verbs: ["*"]
  - apiGroups: ["batch"]
    resources:
      - jobs
      - cronjobs
    verbs: ["*"]

这里由于 Role 是 Namespace 级别的，所以只能在特定 Namespace 下生效，这里我要让授予本 Namespace 下的所有权限，这里 rules 就添加了所有的 API类型、资源类型和操作类型。

创建 RoleBinding

最后需要将 Role 和 ServiceAccount 绑定起来，yaml 如下：

1
2
3
4
5
6
7
8
9
10
11
12
13

kind: RoleBinding
apiVersion: rbac.authorization.k8s.io/v1beta1
metadata:
  name: postgresql
  namespace: postgresql
subjects:
  - kind: ServiceAccount
    name: postgresql
    namespace: postgresql
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: Role
  name: postgresql

创建 kubeconfig 文件

现在我们执行上述 yaml 文件之后，ServiceAccount 其实就已经创建好了，它会对应一个 secret，我们来看下详情，执行：

1

kubectl get serviceaccount postgresql -n postgresql -o yaml

好，运行结果类似如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

apiVersion: v1
kind: ServiceAccount
metadata:
  annotations:
    kubectl.kubernetes.io/last-applied-configuration: |
      {"apiVersion":"v1","kind":"ServiceAccount","metadata":{"annotations":{},"name":"postgresql","namespace":"postgresql"}}
  creationTimestamp: "2020-07-30T16:10:38Z"
  name: postgresql
  namespace: postgresql
  resourceVersion: "17800240"
  selfLink: /api/v1/namespaces/postgresql/serviceaccounts/postgresql
  uid: 6327db1f-6a93-4f1e-b988-31842989bbbc
secrets:
- name: postgresql-token-v26k7

这里它实际关联了一个 secret，叫做 postgresql-token-v26k7，这里面就隐藏了 ServiceAccount 的 token 和证书。 好，那么我们就可以利用这个 secret 来制作 kubeconfig 文件了，命令如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

server=https://your-server:443
name=postgresql-token-v26k7
namespace=postgresql

ca=$(kubectl get secret/$name -n $namespace -o jsonpath='{.data.ca.crt}')
token=$(kubectl get secret/$name -n $namespace -o jsonpath='{.data.token}' | base64 --decode)

echo "apiVersion: v1
kind: Config
clusters:
- name: test
  cluster:
    certificate-authority-data: ${ca}
    server: ${server}
contexts:
- name: test
  context:
    cluster: test
    user: postgresql
current-context: test
users:
- name: postgresql
  user:
    token: ${token}
" > postgresql.kubeconfig

这里我们需要指定三个变量：

• server：就是 Kubernetes Server API 的地址
• name：就是 ServiceAccount 对应的 secret
• namespace：就是当前操作的 Namespace

运行之后就会生成一个 portgresql.kubeconfig 文件。

使用

那么怎么使用呢？很简单，设置下环境变量切换下就好了。

1

export KUBECONFIG=postgresql.kubeconfig

这里我们就将 KUBECONFIG 设置了下，这样再执行 kubectl 就会读取到当前的 kubeconfig 文件，就会生效了。 这时候我们来测试下：

1

kubectl get nodes

运行结果如下：

1

Error from server (Forbidden): nodes is forbidden: User "system:serviceaccount:postgresql:postgresql" cannot list resource "nodes" in API group "" at the cluster scope

可以看到这里就提示没有列出节点的权限了。 然后我们操作下 postgresql 下的权限试试：

1

kubectl get svc -n postgresql

运行结果如下：

1
2
3
4
5

NAME                  TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)    AGE
postgresql            ClusterIP   10.0.193.137   <none>        5432/TCP   9d
postgresql-headless   ClusterIP   None           <none>        5432/TCP   9d
postgresql-metrics    ClusterIP   10.0.60.88     <none>        9187/TCP   9d
postgresql-read       ClusterIP   10.0.236.184   <none>        5432/TCP   9d

这里就可以看到对 postgresql 这个命名空间的操作就成功了。 到此为止我们就成功实现了特定 Namespace 的限制，大功告成。

之前也写过不少关于爬虫的博客了，比如我拿一个案例来写了一篇博客，当时写的时候好好的，结果过了一段时间这个页面改版了，甚至直接下线了，那这篇案例就废掉了。 另外如果拿别人的站或者 App 来做案例的话，比较容易触犯到对方的利益，风险比较高，比如把某个站的 JavaScript 逆向方案公布出来，比如把某个 App 的逆向方案公布出来。如果此时此刻没有对方联系你的话，一个很大原因可能是规模太小了别人没注意到，但不代表以后不会。我还是选择爱护自己的羽毛，关于逆向实际网站和 App 的案例我都不会发的。在这种情况下比较理想的方案是自建案例，只用这个案例讲明白对应的知识点就可以了。 所以，为此，这段时间我也在写一些爬虫相关的案例，比如：

• 无反爬的服务端渲染网站
• 带有参数加密的 SPA 网站
• 各类形式验证码网站
• 反 WebDriver 网站
• 字体反爬等网站
• 模拟登录网站
• App 案例，如代理检测，SSL Pining 等

今天发布一下。

案例列表

本案例平台自爬数据、自建页面、自接反爬，案例稳定后永不过期，适合教学与练习。

SSR 网站

• ssr1：猫眼电影数据网站，数据通过服务端渲染，适合基本爬虫练习。
• ssr2：HTTPS 无效证书网站，适合做跳过验证 HTTPS 案例。
• ssr3：HTTP Basic Authentication 网站，适合做 HTTP 认证案例，用户名密码均为 admin。
• ssr4：每个响应增加了 5 秒延迟，适合测试慢速网站爬取或做爬取速度测试，减少本身网速干扰。

SPA 网站

• spa1：猫眼电影数据网站，数据通过 Ajax 加载，页面动态渲染，适合 Ajax 分析和动态页面渲染爬取。
• spa2：猫眼电影数据网站，数据通过 Ajax 加载，数据接口参数加密且有时间限制，适合动态页面渲染爬取或 JavaScript 逆向分析。
• spa3：猫眼电影数据网站，数据通过 Ajax 加载，无页码翻页，适合 Ajax 分析和动态页面渲染抓取。
• spa4：新闻网站索引，数据通过 Ajax 加载，无页码翻页，适合 Ajax 分析和动态页面渲染抓取以及智能页面提取分析。
• spa5：豆瓣图书网站，数据通过 Ajax 加载，有翻页，无反爬，适合大批量动态页面渲染抓取。
• spa6：电影数据网站，数据通过 Ajax 加载，数据接口参数加密且有时间限制，源码经过混淆，适合 JavaScript 逆向分析。

验证码网站

• captcha1：对接滑动拼图验证码，适合滑动拼图验证码分析处理。
• captcha2：对接图标点选验证码，适合图标点选验证码分析处理。
• captcha3：对接图文点选验证码，适合图文点选验证码分析处理。
• captcha4：对接语序分析验证码，适合语序分析验证码分析处理。
• captcha5：对接空间推理验证码，适合空间推理验证码分析处理。
• captcha6：对接九宫格识图验证码，适合九宫格识图验证码分析处理。

模拟登录网站

• login1：登录时用户名和密码经过加密处理，适合 JavaScript 逆向分析。
• login2：对接 Session + Cookies 模拟登录，适合用作 Session + Cookies 模拟登录练习。
• login3：对接 JWT 模拟登录方式，适合用作 JWT 模拟登录练习。

反爬型网站

• antispider1：WebDriver 反爬网站，检测到 WebDriver 就不显示页面。
• antispider2：对接 User-Agent 反爬，检测到常见爬虫 User-Agent 就会拒绝响应，适合用作 User-Agent 反爬练习。
• antispider3：对接文字偏移反爬，所见顺序并不一定和源码顺序一致，适合用作文字偏移反爬练习。
• antispider4：对接字体文件反爬，显示的内容并不在 HTML 内，而是隐藏在字体文件，设置了文字映射表，适合用作字体反爬练习。
• antispider5：限制 IP 访问频率为最多 1 秒一个，如果过多则会封禁 IP。

App

• app1：最基本的 App 案例，数据通过接口加载，无反爬，无任何加密参数，适合做抓包分析和请求模拟。
• app2：设置了接口请求不走系统代理，因此无法直接抓包，适合做抓包特殊处理。
• app3：对系统代理进行了检测，如果设置了代理则无法正常请求数据，适合做抓包特殊处理。
• app4：设置了 SSL Pining，如果设置了非法证书则无法正常请求数据，适合做反 SSL Pining 处理。
• app5：接口增加了加密参数，适合做抓包实时处理或可视化爬取或逆向分析。
• app6：接口增加了加密参数，同时对源码进行了混淆，适合做抓包实时处理或可视化爬取或逆向分析。
• app7：接口增加了加密参数，同时对安装包进行了加固处理，适合做抓包实时处理或可视化爬取或逆向分析。

暂且是这么多，后续还会继续增加，大家可以试着爬爬看。

汇总链接

为了方便，我专门申请了一个域名，scrape.center，意思名为「爬取中心」，似乎听起来意义上还说的过去？ 案例平台首页 URL：https://scrape.center，截图如下： 大家可以点击任意一个网站来爬取练习。

案例预览

下面是一些部分案例的截图： 上面是一些案例的效果，基本上是使用 Django + Vue.js 开发的，主题使用了红色调，整个案例平台风格比较统一。另外还有一些 App 也是类似的风格，大家可以自行下载体验试试。 当然这里面最主要的还是案例的功能，比如各种加密、反爬、检测等等。

源代码

有朋友可能会问这个案例平台的源代码在哪里。 这里解释一下，由于这个案例平台以后会用于案例的讲解，并且可能会出现在课程、书本中，所以为了避免盗版和抄袭的问题，这里我选择了闭源，也算是对自己的知识成果的另一种保护吧。 不过这并不意味着爬取代码是闭源的，这块还是会开源出来的。

怎么爬

还有朋友会问，这一个个网站这么多类型和反爬，到底怎么爬呢？ 其实现在针对这个练习平台一些案例讲解我已经做好了，课程也基本 OK 了，如果感兴趣大家可以点击看看。 https://t.lagou.com/cRC3RGRjSu706 谢谢大家。

Persistenced：

RDB（Redis Database）：

简介：

将时间段间隔内的内存数据以快照的形式写入磁盘，它恢复时是将快照文件直接读到内存里（snapshot）

原理：

Redis 会单独创建（fork）一个子进程来进行持久化，会先将数据写入到一个临时文件中，待持久化过程都结束了，在用这个临时文件替换上次持久化号的文件。主进程是不进行任何的IO操作，确保了极高的性能。如果需要进行大规模的数据恢复，且对于数据恢复的完整性不是非常敏感，那RDB方式要比AOF方式更加的高效。RDB的缺点是最后一次持久化后的数据可能会丢失

Fork：

作用：创建一个与当前进程一样的进程。新进程的所有数据（变量、环境变量、程序计数器等）都与原进程一致。但为一个全新的进程，并作为原进程的子进程

RDB保存的是dump.rdb文件

配置位置：

在redis.conf 中的snapshoting

快照：

save，save只管保存，其他不管全部阻塞 bgsave：redis会在后台异步进行快照操作 快照同时还可以响应客户端请求，可以通过lastsave命令获取最后一次成功执行快照的时间 执行flush命令也会产生dump.rdb文件，但里面是空的，无意义

如何恢复：

将备份文件（dump.rdb）移动到redis安装目录，并启动服务即可 在连接完成之后的终端 使用 config get dir 获取目录 异常恢复: redis-check-rdb —fix {}

优势：

适合大规模的数据备份 对数据完整性和一致性要求不高

劣势：

在一定时间间隔内做一次备份，所以如果redis意外down了就会丢失最后一次快照后的所有更改 Fork的时候，内存中的数据被克隆了一份，内存等将会2倍膨胀性，需考虑！！！

如何停止：

​ 动态所有停止rdb保存规则方法：redis-cli config set save “”

AOF：（Append only File）：

导入：

为什么还会出现AOF？（新技术的出现必定弥补老技术的不足,新技术一定会借鉴老技术,是老技术的子类） 如果一个系统里面同时存在RDB是冲突呢还是协作? 为什么AOF会在RDB之后产生 AOF它会有什么优缺点?

原理:以日志的形式来记录每个写操作,将Redis执行过的所有写指令记录下来(读操作不记录),只需追加文件但不可改写文件,Redis启动之初会读取该文件重新构建数据, 换言之,redis重启就根据日志文件的内容将写指令从前到后执行一次以完成数据恢复工作 配置位置: redis.conf中的APPEND ONLY MODE 配置说明: Appendfsunc:

always: 同步持久化,每次发生更改立即记录到磁盘,性能差但数据完整性比较好 everysec:出厂默认推荐,异步操作,每秒记录,如果一秒内宕机,有数据丢失 No

No-appendfsy-on-rewrite:重写时是否可以运用Appendfsync,默认no即可,保障数据安全 Auto-aof-rewrite-min-size :设定重写基准值 Auto-aof-rewrite-percentage : 设定重写基准值

探讨dump.rdb,与aof的二者是否能共存及选择顺序

当aof损坏时,rdb完全,二者可以和平共存 二者先选择aof

AOF启动／修复／恢复:

正常恢复:

启动:将redis.conf中APPEND ONLY MODE 下appendonly no改为yes 将有数据的aof文件复制一份保存到对于目录(config get dir) 恢复: 重启redis然后重新加载即可

异常恢复:

备份被写坏的AOF文件, 修复: Redistribution-check-aof —fix 进行修复 重启redis,重新加载即可

Rewrite:重写

AOF采用文件追加的方式，文件会越来越大为避免出现此种情况，新增了重写机制， 当AOF文件的大小超过所设定的阈值时，Ｒｅｄｉｓ会启动AOF文件的内容压缩，只保留可以恢复数据的最小指令集，可以使用命令ｂｇｒｅｗｒｉｔｅａｏｆ

重新原理：

AOF文件持续增长而过大时,会fork出一条新进程来讲文件重写(也是先写零食文件最后在rename),遍历新进程的内存数据,每条记录有一条的set语句.重写aof文件的操作,并没有读取旧的aof文件,而是将整个内存中的数据库内容用命令的方式重写了一个新的aof文件.和快照有点类似

触发机制: REDIS会记录上次重写时的AOF大小,默认配置时当AOF文件大小是上次rewrite后大小的一倍且文件大于64M时触发 优势:

每秒同步:appendfsync always 同步持久化 每次发送数据变更会被立即记录到磁盘,性能较差完整性比较友好 每修改同步: appendfsync everysec 异步操作,每秒记录,如果一秒内宕机,有数据丢失 不同步:appendfsync no 从不同步

劣势: 相同数据集的数据而言aof文件要远大于rdb文件,恢复速度慢于rdb AOF运行效率要慢于rdb,每秒同步策略效率较好,不同步效率和rdb相同

Which one?：

RDB持久化方式:能够在指定的时间间隔内对数据进行快照存储 AOF持久化方式:记录每次对服务器写的操作,当服务器重启的时候会重新执行这些命令来恢复原始的数据,AOF命令以Redis协议追加保存每次写的操作到文件末尾,Redis还能对AOF文件进行后台重新,使得AOF文件的体积不至于过大 只做缓存:

如果希望数据在服务器运行的时候存在,也可以不使用热河持久化方式.

同时开启两种持久化方式:

当redis重启的时候会优先载入AOF文件来恢复原始的数据,因为在通常情况下AOF文件保存的数据集要比rdb文件保存的数据集更完整 RDB的数据不实时,同时使用两者时服务器重启也指挥找AOF文件 那干脆直接使用AOF？不建议 因为RDB更适合用于数据库（AOF在不断变化不好备份），快速重启，而且不担保有AOF可能潜在的BUG，留着作为一个万一的手段

浅谈排序算法与优化（仅部分，Updating）

欢迎查阅与star的源码 写在最前面，此文章少了各排序算法的对比，但多了一份由浅入深的个人理解，以及代码、及算法的优化的思路 阅读文章约 需 5min

列表排序

排序

将一组“无序”的记录序列调整为“有序”的记录序列

列表排序

将无序的列表变为有序列表 输入：列表； 输出：有序列表

升序与降序 内置排序函数：sort（），基于timsort排序算法

Timsort是一种混合稳定排序算法，源自归并排序（merge sort）和插入排序（insertion sort）

有兴趣的伙计可以看看这两篇文章 sort算法运用原理1 sort算法运用原理2

常见排序算法

LOW：

冒泡：

列表每两个相邻的数，如果前面比后面大，则交换这两个数 一趟排序完成后，则无序区减少一个数，有序区增加一个数

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

@cal_time def bubble_sort(li: List[List]) -> List: print('初始列表', li) print('初始列表长度：', len(li)) for i in range(len(li) - 1): # 第i躺,总次数 i += 1 for j in range(len(li) - i - 1): # 指针 if li[j] > li[j + 1]: # 如果指针所对应的值大于对比的值，则二者交换位置 li[j], li[j + 1] = li[j + 1], li[j] else: break print(f'冒泡排序第{i}次', li) li = [np.random.randint(0, 1000) for i in range(5)] bubble_sort(li) 数据来源于numpy.randmo.randint()随机取数，运行流程： 冒泡排序第1次 [257, 620, 136, 379, 392, 118, 312, 892, 647, 655] 冒泡排序第2次 [257, 620, 136, 379, 392, 118, 312, 892, 647, 655] 冒泡排序第3次 [257, 620, 136, 379, 392, 118, 312, 892, 647, 655] 冒泡排序第4次 [257, 620, 136, 379, 392, 118, 312, 892, 647, 655] 冒泡排序第5次 [257, 620, 136, 379, 392, 118, 312, 892, 647, 655] 冒泡排序第6次 [257, 620, 136, 379, 392, 118, 312, 892, 647, 655] 冒泡排序第7次 [257, 620, 136, 379, 392, 118, 312, 892, 647, 655] 冒泡排序第8次 [257, 620, 136, 379, 392, 118, 312, 892, 647, 655] 冒泡排序第9次 [257, 620, 136, 379, 392, 118, 312, 892, 647, 655] # 排序次数：列表长度-1, # 缘由将无序区转化为有序区：(再看一遍以下这段代码， 如果li[j]>li[j+1],则二者交换位置） if li[j] > li[j + 1]: li[j], li[j + 1] = li[j + 1], li[j] # 当一维数组长度为10000的时候所需时间为：

优化： 在一次回头看看冒泡排序具体实现思路，将列表每两个相邻的数，如果前面比后面大，则交换这两个数,一趟排序完成后，则无序区减少一个数，有序区增加一个数。 如果无序区已经是有序的呢？按照代码执行流程可知， 如果前者比后者大，那么则两个交换位置。（假设为降序，前面为无序区，后面为有序区） 否则不执行任何交换操作，但会执行便利（也可以理解为此运算”不执行任何交换操作，无实际意义”） 优化目标：(将“不执行任何交换的操作去掉”)，咱们在回头看看，具体实际的运算是在第二层for循环里面的，也就说所谓的“无用功”也是在这里产生的 无用功体现为：无论是否进行了位置交换，都会在往有序区在遍历检查一遍 思路如下： 主要优化的地方在跳出循环，在它不交换位置的时候，直接跳出此次的循环 假设它全部都是有序的，并设个标记True， 当如果循环内发生了位置交换，则改变标记为False。 流程控制，if。当if True的时则会执行if内部代码（设立return，或者break）主要跳出循环。避免对有序区进行有一次的排序操作 具体代码实现如下：

1 2 3 4 5 6 7 8 9 10 11

def bubble_sort(li: List): print("The len of List:", len(li)) # 输入数组长度 for i in range(len(li) - 1): # 保证输入的数组在计算范围类，此处的“-1”是因为索引=长度-1 flag = True for j in range(len(li) - i - 1): if li[j] > li[j + 1]: li[j + 1], li[j] = li[j], li[j + 1] flag = False print("Sorting times:%d， Status：%s" % (i + 1, li)) if flag: break

选择: 插入:

Stronger

快速排序： 堆排序 归并排序

其他排序：

希尔排序 计数排序 基数排序

1

break

选择: 插入:

Stronger

快速排序： 堆排序 归并排序

其他排序：

希尔排序 计数排序 基数排序

欢迎 Star 的源码

新入手，小白的我，在我眼里 Request 爬虫永远只有四大步，不服来辩？

1. 确定 URL，构造请求头
2. 发送请求，获取响应
3. 解析响应，获取数据
4. 保存数据

目标：根据视频 BV，获取 B 站视频弹幕

代码地址如下： 抓包确定 URL：

导入：

视频都有一个唯一区分视频：BV 号 那么视频的 URL 规则为：’https://wwww.bilibili.com/video/BV{BVID}’ 找一下弹幕的地址,直接 search，即可！如下

由以上抓包可知，弹幕的 URL：’https://api.bilibili.com/x/v1/dm/list.so?oid=oid‘, 我们获取到 oid 那么这一步就完成了 来，回头去找一下 oid 从何而来呢？ 据老夫多年经验指引，他一定在视频 URL 里面。（其实当时也找了挺久的，甚至逆向那一手，断点调试、调用堆栈等等什么都用出来了。最终还是功夫不负有心人，找到了） 其实回头看，oid 是等于 video_URL 页面里面的 cid 参数的（验证了 Payne 式猜想）。过程是难受的

URL，其参数规则也找到了，那么还不就随我为所欲为了。只要拿到视频地址，那不就可以直接拿到弹幕了么。of course！

此处省略 3 万字（请求，解析，网络原理。。。）

其实当时知道两个方法都去试了，JS 那个就不说了，有兴趣的盆友，可以去搞一下 说说这个提取 cid 参数吧，我用的是正则，这种情况最好是用正则，不过也看个人喜好吧。 可以回头看第二张图，初一乍看我好像不会，啊哈哈~

经过优化后（主要是看了其他视频的那啥之后）：写出这个神奇的正则

1	cid = re.findall('.*?cid":+(d{9})+', text)[0]

谢谢你认真看到了末尾，那我也写点私活吧。欢迎查阅源码与 star

1
2

其实关于很多网站（普通）的参数就算是有JS加密，以及混淆。并不代表就一定需要去解密，去逆向。有时候真的只需要serch一下惊喜多多，望诸君切记、切记。
咱们解密，逆向，有时候完全即可做一个动态维持即可。例如我源码中的scrape 拉勾

导入：

补充知识：

迭代、递归与循环：迭代与递归都是循环的子集，一个是取值推算，一个是不断的调用自己。 相同点：迭代、递归、循环都是“重复” 相似点：调用逻辑相似 不同点：我简单理解为迭代是根据自身的上一个值推算下一个值，而递归则是由上一个值与“己身”直接运算。循环是自身与外界计算 堆栈关系调用不同 当然也不能说谁好谁坏，只能说三者主针对不同

来，来，来，翠花上栗子：

递归，归去来兮 ：

1 2 3 4 5 6 7 8 9 10 11 12

def func(i): i -= 1 if i == 1: return 1 else: print(i) return func(i) print(func(8)) # 输出结果：7、6、5、4、3、2、1 print(func(4)) # 输出结果：3、2、1

迭代，更新换代（单单以数值方面考虑，凸显堆栈方面就。。。）

1 2 3 4 5 6 7 8 9 10

# 迭代 List = ['1','2','3'] i = 0 while True: print（List[i]） i += 1 # 循环、也有点递归的意思。小问题，小问题，这里探究迭代与循环 count = 0 while True： count = count + 1

个人思考及感悟：如何判断生成器与迭代器？：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

区分循环、迭代 循环：与外界计算，重复亦或者 区分迭代器与生成器 迭代器： 可以被next()函数调用并不断返回下一个值的对象称为迭代器 生成器： 不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到出现 StopIteration 可使用isinstance()方法判断是否是Iterator对象 g = (i ** i for i in range(1, 10)) print(next(g)) print(next(g)) print(next(g)) 。。。 。。。 for j in g: print(j)

迭代器是什么？

迭代取值的工具，迭代是个循环，但不是重复的过程。每次的值都基于上次的值而来。迭代是特殊的重复

迭代器能做什么？

迭代取值；程序中用的比较多就是先存后取 用时在释放。释放next()函数，以及遍历

迭代器怎么使用？

​ next（可迭代对象） 或者 可迭代对象. next () 以及在函数中yield关键字

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

def foo(): print("starting...") while True: res = yield 4 print("res:", res) g = foo() print(next(g)) print("*" * 20) print(next(g)) print(next(g)) print(next(g)) ''' starting... 4 ******************** res: None 4 res: None 4 res: None 4 '''

带yield的函数是一个生成器，而不是一个函数了，这个生成器有一个函数就是next函数

写在最前面：本人也是个算法小白，如果有什么不对还望大佬指正，谢谢

算法设计评价基本标准

算法是对特定问题求解步骤的一种描述，如果将问题看作函数，那么算法是吧输入转化为输出

算法:

是对特定问题求解步骤的一种描述，是为了解决一个或者一类问题给出的 一个确定的、有限长的操作序列。 算法的设计依赖于数据的存储结构，因此对确定的问题，应该需求子啊适宜的存储结构上设计出一种效率较高的算法

算法的重要特性：

有穷性：

对于任何一组合法的输入值，在执行有穷步骤之后一定能结束，即算法中的操作步骤为有限个，并且每个步骤都能在有限的时间内完成

确定性：

对于每种情况下所应该执行的路径的操作，在算法中都有确切的规定，使算法的执行者或阅读者都能明确其含义及如何执行；并且在确切的条件下只有唯一一条执行流程路径

可行性：

算法中的所有操作都必须足够基本，都可以通过已经实现的基本运算执行有限次实现

有输入:

作为算法加工对象的量值，通常体现为算法中的一组变量。有些输入量需要在算法的执行过程中输入，而有些算法表面上没有输入，但实际上已被嵌入算法之中

有输出：

它是一组与“输入”有确定关系的量值，是算法进行信息加工够得到的结果。这种确定关系即为算法的功能

算法设计目标：

正确性：

算法应满足具体问题的需求，正确反映求解问题对输入、输出加工处理等方面的需求

1. 程序中不含语法错误，计算的结果却不能满足规格说明要求。
2. 程序对于特定的几组输入数据能够得出满足要求的结果，而对于其他的输入数据的不出正确的计算结果；
3. 程序对于精心选择的、经典、苛刻且带有刁难性的几组输入数据能够得到满足需求的结果；（正确的算法）
4. 程序对于一切合法的输入数据都能得出满足要求的结果

可读性：

算法处理用于编写程序子啊计算机上执行之外，另一个重要用处是阅读和交流。 算法中加入适当的注释，介绍算法的设计思路、各个模块的功能等一些必要性的说明文字来帮助读者理解算法。 要求: 算法中加入适当的注释，介绍算法的设计思路、各个模块的功能等一些必要性的说明文字来帮助读者理解算法 对算法中出现的各种自定义变量和类型能做到“见名知义”，即读者一看到某个变量（或类型名）就能知道其功能

健壮性：

当输入数据非法时，算法能够适当地做出反应或进行处理，输出表示错误性质的信息并终止执行，而不会产生莫名其妙的输出结果。

时间效率与存储占用量：

一般来说，求解同一个问题若有多种算法，则 执行时间短的算法效率高 占用存储空间少的算法较好 算法的执行时间开销和存储空间开销往往相互制约，对高时间效率和低存储占用的要求只能根据问题的性质折中处理

算法复杂度

算法的时间复杂度：

算法的效率指的是算法的执行时间随问题“规模”（通常用整型量 n 表示）的增长而增长的趋势 “规模”在此指的是输入量的数目，比如在排序问题中，问题的规模可以是被排序的元素数目 假如随着问题规模 n 的增长，算法执行时间的增长率和问题规模的增长率相同则可记为： T（n） = O（f(n)）

f(n) 为问题规模 n 的某个函数； T（n）被称为算法的（渐进）时间复杂度（Time Complexity） O 表示法不需要给出运行时间的精确值； 选择 f（n），通常选择比较简单的函数形式，并忽略低次项和系数 常用的有 O（1）、O（logn）、O（n）、O（nlogn）、O（n*n）等等 多项式时间复杂度的关系为： O(1) < O(logn) < O(n) < O(N logn) < O(n²) < O(n³) 指数时间算法的关系为： O（2(n 方)）< O(n!) <O(n(n 方))

由于估算算法时间复杂度关心的只是算法执行时间的增长率而不是绝对时间，因此可以忽略一些因素。 方法：从算法中选取一种对于所研究的问题来说是“基本操作”的原操作，以该“基本操作”在算法中重复执行的次数作为算法时间复杂度的依据。 EG：

两个 n x n 的矩阵相乘，求其时间复杂度

1 2	for i in range(10): for j in range(10):

问题规模是矩阵的阶 n,算法的控制结构式三重循环，基本操作是乘法操作 乘法执行次数为 n³，则算法的时间复杂度为 O(n³)

算法的空间复杂度：

算法在执行期间所需要的存储量包括：

1. 程序代码所占用空间
2. 输入数据所占用空间
3. 辅助变量所占用的空间

为了降低复杂度，一个直观的思路是：梳理程序，看其流程中是否有无效的计算或者无效的存储。我们需要从时间复杂度和空间复杂度两个维度来考虑。 常用的降低时间复杂度的方法有递归、二分法、排序算法、动态规划等， 降低空间复杂度的方法，就要围绕数据结构做文章了。 降低空间复杂度的核心思路就是，能用低复杂度的数据结构能解决问题，就千万不要用高复杂度的数据结构。

如何评定一个程序算法的好坏？

简而言之：在符合算法设计标准的前提下，运行的更快、所用计算资源更少。即是更好的算法

请注意这里的比较级别词更！！！，对于算法，个人认为就是获得同一结果的同时探究最优解决之道

探究算法优化（自我一点点小体悟-个人能力有限）

1. 抽象化：将不必要的计算过程去掉

   利用高斯算法解决累计求和问题

2. 慎选各数据结构，善用第三方算法

   去重： 善用迭代什么的等等 使用字典的特性-不可重复性 布隆过滤器去重（源于哈希算法）

3. 时空转换：将昂贵的时间转化为廉价的空间

   当‘优无可优时’,取贵舍廉 空间是可以用钱买的，加个什么内存啊，加个处理器等等什么的 时间是逝去就不在了

   以上仅仅个人的一点点小灵感，望大家不喜勿喷

说了这么多，来道简单的算法题目导入（同一计算机，i5, python） 需求如下：累计求和 1-n 的值(1. 为防止误差，验证 10 次; 2. 验证每次计算次数)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 在同一空间复杂下(也就是说没有迭代，探究暴力解法与高斯算法)
# n = 100000
# Method one 代码如下
def func(n):
    start = time.time()
    count = 0
    theSum = 0
    for i in range(n + 1):
        theSum = theSum + n
        count += 1
    end = time.time()
    return theSum, end - start, count

for i in range(10):
    print(f"Sum is %d Required %10.10f seconds count = %d" % func(10000))
# %10.10f 表示取10位小数，运行结果如下

Sum is 100010000 Required 0.0010061264 seconds count = 10001 Sum is 100010000 Required 0.0009891987 seconds count = 10001 Sum is 100010000 Required 0.0000000000 seconds count = 10001 Sum is 100010000 Required 0.0010235310 seconds count = 10001 Sum is 100010000 Required 0.0009710789 seconds count = 10001 Sum is 100010000 Required 0.0000000000 seconds count = 10001 Sum is 100010000 Required 0.0009973049 seconds count = 10001 Sum is 100010000 Required 0.0010013580 seconds count = 10001 Sum is 100010000 Required 0.0000000000 seconds count = 10001 Sum is 100010000 Required 0.0019786358 seconds count = 10001 探究可知：n 扩大 10 倍，运算时间也会扩大 10 倍 高斯算法，从 1 累加至 n,等于(首项+尾项)项数/2 直接引用结论: 1+2+3+…+(n-1) +n={（1+n）+（2+（n-1））…}/2 = （n （n + 1））/2

1
2
3
4
5
6
7
8
9

# Gaussian算法，无迭代算法
def fun1(n):
    start = int(time.time())
    theSum = (n * (n + 1)) / 2
    end = int(time.time())
    return theSum, end - start, n / 2

for i in range(1000000):
    print(f"Sum is %d Required %10.100f seconds count = %d" % fun1(50**100))

计算结果如下： 循环计算 10000 次，出去 I/O 所需时间几乎可以不计。 Sum is 49999999999999998486656110625518082973725163772751181324120875475173424217777037767098169202353125934013756207986941204091067867184139242319692520523619938935511795533394990905590906653083564427444224 Required 0.0000000000000000000000000000000000000000000000000123123000000000000000000000000000000000000000000000 seconds count = 5000000000000000079514455548799590234180404281972640694890663778873919386085190530406734992928407552 Sum is 49999999999999998486656110625518082973725163772751181324120875475173424217777037767098169202353125934013756207986941204091067867184139242319692520523619938935511795533394990905590906653083564427444224 Required 0.000000000000000000000000000000000000000000000000012332100000000000000000000000000000000000000000000 seconds count = 5000000000000000079514455548799590234180404281972640694890663778873919386085190530406734992928407552 Sum is 49999999999999998486656110625518082973725163772751181324120875475173424217777037767098169202353125934013756207986941204091067867184139242319692520523619938935511795533394990905590906653083564427444224 Required 0.00000000000000000000000000000000000000000000000000000002310000000000000000000000000000000000000 seconds count = 5000000000000000079514455548799590234180404281972640694890663778873919386085190530406734992928407552 Sum is 49999999999999998486656110625518082973725163772751181324120875475173424217777037767098169202353125934013756207986941204091067867184139242319692520523619938935511795533394990905590906653083564427444224 Required 0.000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000 seconds count = 5000000000000000079514455548799590234180404281972640694890663778873919386085190530406734992928407552 Sum is 49999999999999998486656110625518082973725163772751181324120875475173424217777037767098169202353125934013756207986941204091067867184139242319692520523619938935511795533394990905590906653083564427444224 Required 0.000000000000000000000000000000000000000000000000000000010032000000000000000000000000000000000000 seconds count = 5000000000000000079514455548799590234180404281972640694890663778873919386085190530406734992928407552 Sum is 49999999999999998486656110625518082973725163772751181324120875475173424217777037767098169202353125934013756207986941204091067867184139242319692520523619938935511795533394990905590906653083564427444224 Required 0.0000000000000000000000000000000000000000000000012231300000000000000000000000000000000000000000000 seconds count = 5000000000000000079514455548799590234180404281972640694890663778873919386085190530406734992928407552 Sum is 49999999999999998486656110625518082973725163772751181324120875475173424217777037767098169202353125934013756207986941204091067867184139242319692520523619938935511795533394990905590906653083564427444224 Required 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 seconds count = 5000000000000000079514455548799590234180404281972640694890663778873919386085190530406734992928407552 Sum is 49999999999999998486656110625518082973725163772751181324120875475173424217777037767098169202353125934013756207986941204091067867184139242319692520523619938935511795533394990905590906653083564427444224 Required 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 seconds count = 5000000000000000079514455548799590234180404281972640694890663778873919386085190530406734992928407552 Sum is 49999999999999998486656110625518082973725163772751181324120875475173424217777037767098169202353125934013756207986941204091067867184139242319692520523619938935511795533394990905590906653083564427444224 Required 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 seconds count = 5000000000000000079514455548799590234180404281972640694890663778873919386085190530406734992928407552 Sum is 49999999999999998486656110625518082973725163772751181324120875475173424217777037767098169202353125934013756207986941204091067867184139242319692520523619938935511795533394990905590906653083564427444224 Required 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 seconds count = 5000000000000000079514455548799590234180404281972640694890663778873919386085190530406734992928407552

网络爬虫工程师面试小笔记

————小企业，7K至10k版，面试总结。Payne

面试题之一：Python单例模式

1. 什么是Python的单例模式？

单例模式（Singleton Pattern）是一种常用的软件设计模式，该模式主要目的是确保某一个类只有一个实例存在。当希望在整个系统中，某个类只能出现一个实例时，单例对象就派上用场了。 面向对象编程单例模式，保证了在程序运行中该类只实例化一次，并提供了一个全局访问点 Python的模块就是天然的单例模式 当模块在第一次导入时，就会生成 .pyc 文件 当第二次导入时就会直接先加载 .pyc 文件，而不会再次执行模块代码。 我们只需把相关函数和数据定义在一个模块中，就可以获得一个单例对象。

1. 如何实现单例模式？

1.基于类：

1 2 3 4 5 6 7 8 9 10 11 12 13 14

class Singleton(object): # def __new__(slef):类方法 # pass # 当我们没写时默认调用object__new__方法 # 然后在执行类的实例化对象：__init__ def __init__(self): # 实例方法 pass @classmethod def instance(cls, *args,**kwargs): if not has attr(Singleton,"_instance"): Singleton._instance = Singleton(*args,**kwargs) return Singleton._intance

此时是以完成了一个简单的单例模式案例，But实际开发中随时凉凉 举例说明：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

class Singleton(object): def __init__(self): pass @classmethod def instance(cls, *args, **kwargs): if not hasattr(Singleton, "_instance"): Singleton._instance = Singleton(*args, **kwargs) return Singleton._instance import threading def task(arg): obj = Singleton.instance() print(obj) for i in range(10): t = threading.Thread(target=task,args=[i,]) t.start()

当然此时也并没有什么问题，BUT在’ init ‘方法中加入I/O（input/output）操作就凉凉了 问题出现了，按照以上方式创建的单例无法支持多线程 缘由：Python中实例化对象与初始化对象是分开执行的，又由于多线程之间是通信共享的，故出现线程安全问题。主要体现为，create一个之后kill一个，create一个又被kill一个。所以就。。。 解决思路一：相互独立，分而治之。加锁独立 也就是咱们所了解、知道的线程锁的概念，使得其无序变为相对有序。具体代码便不在此赘述 在看看思路一(相互独立，分而治之。加锁独立) 解决思路二：‘反’实例化，加锁保护独立，确保通用性 在Python3中，调用父类方法是为super()，那么是否可以增加判断： 当类属性不为空时，我们便不在实例化且返回一个已实例化的类属性。这样还是不太完美，带有局限性。进一步加锁保护优化以保障多线程情况下只有一个线程同时访问。这样就保障了单例的安全 基于 new 方法实现！！！

1 2	在回到基于类的第一个代码块，并详细查看其注释。 实例化一个对象是先执行了类的__new__方法（若未写执行object.__new__），实例化对象；然后子啊执行类的__init__方法，对这个对象进行初始化。基于此实现单例。

1. 基于装饰器

使用装饰器实现，实例如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

def Singleton(cls): _instance = {} def _singleton(*args, **kargs): if cls not in _instance: _instance[cls] = cls(*args, **kargs) return _instance[cls] return _singleton @Singleton class A(object): a = 1 def __init__(self, x=0): self.x = x a1 = A(2) a2 = A(3)

1. 使用模块的方法

书写代码(并保存在Singleton.py中)：

1 2 3 4

class Singleton(object): def func(self): pass singleton = Sinleton()

// from * import singleton 需使用时，直接在其他文件中导入此文件中的对象，那么这个对象即是单例模式对象 还有个基于元类的就没书写了具体请看：https://blog.csdn.net/weixin_44239343/article/details/89376796

面试题之二：Redis有几种数据类型？

如果是单单是Redis那么常用数据类型为五种 他们分别是：String，List，hash，set，zset String：字符串，一个字符串Value最多可以是512M Hash：哈希，是一个String类型的field和Value的映射表 List：列表，时间是链表 Set：集合是一个String类型无序无重复集合，其通过Hash Table实现 Zset（sorted）：有序集合 那么应聘时，请注意这个小坑，你Python使用Redis又几种数据类型? 这个是基于语言来回答的，所用语言+Redis数据类型杂糅 Number,String，list，tuple（这个不确定），dict，aggregate 同时又涉语言所拥有的数据类型与redis，一样的就‘合二为一’嘛 以Python为例，稍后继续探究这（6+5）之间的杂糅，dict与aggregate其二者区别为主（其实我也不晓得更深的了）。以及1对1，1对多，多对1。数据结构搞起来，然后哼哼~。

面试题之三：Scrapy框架的运行流程及各模块的作用

如果简历里面写了分布式会拓展scrapy-Redis架构以及其作用。 CAP理论，估计会扯到数据这块。拓展database什么特性啊，之类的。谈优化，谈数据结构。反正数据结构与算法这块，基于此，难于此，也凉于此

面试题之四：scrapy去重所用的几种机制

谨记：先从scrapy本身的去重原理及机制说起来，最基础，优缺点，去重原理等等。一步步来，一上来就BloonFilter，风险不小啊 对于此，自我总结如下：

1、scrapy 基于内存

1 2 3 4 5

scrapy源码中可以找到一个dupefilters.py去重器; 需要将dont_filter设置为False开启去重，默认是True，没有开启去重； 对于每一个url的请求，调度器都会根据请求得相关信息加密得到一个指纹信息，并且将指纹信息和set()集合中的指纹信息进 行 比对，如果set()集合中已经存在这个数据，就不在将这个Request放入队列中;

2、redis 基于内存 更加快捷、速度快、易于管理

1	不说了，前面是叩门砖，Redis就是决胜之地，没啥可讲的，会的基本都会，不会的我也不会，在深挖其原理数据结构，估计得喝上一点，也怕自己一不小心怕给扯飞了

3、布隆过滤器 大 可能存在拥有一定的错误率

1	加分项，是满分还是SSS+。

对于此面试个人总结如下： 源于基础，死于基础（数据结构及类型， 以及算法） 知识点：点串线，线成面。 自己也还有很长一段路走，加油，加油~

之前我写过几篇文章介绍过有关爬虫的智能解析算法，包括商业化应用 Diffbot、Readability、Newspaper 这些库，另外我有一位朋友之前还专门针对新闻正文的提取算法 GeneralNewsExtractor，这段时间我也参考和研究了一下这些库的算法，同时参考一些论文，也写了一个智能解析库，在这里就做一个非正式的介绍。

引入

那首先说说我想做的是什么。 比如这里有一个网站，网易新闻，https://news.163.com/rank/，这里有个新闻列表，预览图如下： 任意点开一篇新闻，看到的结果如下： 我现在需要做到的是在不编写任何 XPath、Selector 的情况下实现下面信息的提取： 对于列表页来说，我要提取新闻的所有标题列表和对应的链接，它们就是图中的红色区域： 这里红色区域分了多个区块，比如这里一共就是 40 个链接，我都需要提取出来，包括标题的名称，标题的 URL。 我们看到页面里面还有很多无用的链接，如上图绿色区域，包括分类、内部导航等，这些需要排除掉。 对于详情页，我主要关心的内容有标题、发布时间、正文内容，它们就是图中红色区域： 其中这里也带有一些干扰项，比如绿色区域的侧边栏的内容，无用的分享链接等。 总之，我想实现某种算法，实现如上两大部分的智能化提取。

框架

之前我开发了一个叫做 Gerapy https://github.com/Gerapy/Gerapy 的框架，是一个基于 Scrapy、Scrapyd 的分布式爬虫管理框架，属 1.x 版本。现在正在开发 Gerapy 2.x 版本，其定位转向了 Scrapy 的可视化配置和调试、智能化解析方向，放弃支持 Scraypd，转而支持 Docker、Kubernetes 的部署和监控。 对于智能解析来说，就像刚才说的，我期望的就是上述的功能，在不编写任何 XPath 和 Selector 的情况下实现页面关键内容的提取。 框架现在发布了第一个初步版本，名称叫做 Gerapy Auto Extractor，名字 Gerapy 相关，也会作为 Gerapy 的其中一个模块。 GitHub 链接：https://github.com/Gerapy/GerapyAutoExtractor 现在已经发布了 PyPi，https://pypi.org/project/gerapy-auto-extractor/，可以使用 pip3 来安装，安装方式如下：

1

pip3 install gerapy-auto-extractor

安装完了之后我们就可以导入使用了。

功能

下面简单介绍下它的功能，它能够做到列表页和详情页的解析。 列表页：

• 标题内容
• 标题链接

详情页：

• 标题
• 正文
• 发布时间

先暂时实现了如上内容的提取，其他字段的提取暂时还未实现。

使用

要使用 Gerapy Auto Extractor，前提我们必须要先获得 HTML 代码，注意这个 HTML 代码是我们在浏览器里面看到的内容，是整个页面渲染完成之后的代码。在某些情况下如果我们简单用「查看源代码」或 requests 请求获取到的源码并不是真正渲染完成后的 HTML 代码。 要获取完整 HTML 代码可以在浏览器开发者工具，打开 Elements 选项卡，然后复制你所看到的 HTML 内容即可。 先测试下列表页，比如我把 https://news.163.com/rank/ 这个保存为 list.html， 然后编写提取代码如下：

1
2
3
4
5

import json
from gerapy_auto_extractor.extractors.list import extract_list

html = open('list.html', encoding='utf-8').read()
print(json.dumps(extract_list(html), indent=2, ensure_ascii=False, default=str))

就是这么简单，核心代码就一行，就是调用了一个 extract_list 方法。 运行结果如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

[
  {
    "title": "1家6口5年"结离婚"10次:儿媳"嫁"公公岳",
    "url": "https://news.163.com/20/0705/05/FGOFE1HJ0001875P.html"
  },
  {
    "title": ""港独"议员泼水阻碍教科书议题林郑月娥深夜斥责",
    "url": "https://news.163.com/20/0705/02/FGO66FU90001899O.html"
  },
  {
    "title": "感动中国致敬留德女学生:街头怒怼"港独"有理有",
    "url": "https://news.163.com/20/0705/08/FGOPG3AM0001899O.html"
  },
  {
    "title": "香港名医讽刺港警流血少过月经受访时辩称遭盗号",
    "url": "https://news.163.com/20/0705/01/FGO42EK90001875O.html"
  },
  {
    "title": "李晨独居北京复式豪宅没想到肌肉男喜欢小花椅子",
    "url": "https://home.163.com/20/0705/07/FGOLER1200108GL2.html"
  },
  {
    "title": "不战东京!林丹官宣退役正式结束20年职业生涯",
    "url": "https://sports.163.com/20/0704/12/FGML920300058782.html"
  },
  {
    "title": "香港美女搬运工月薪1.6万每月花6千租5平出租",
    "url": "https://home.163.com/20/0705/07/FGOLEL1100108GL2.html"
  },
  {
    "title": "杭州第一大P2P"凉了":近百亿未还!被警方立案",
    "url": "https://money.163.com/20/0705/07/FGON5T7B00259DLP.html"
  },
  ...
]

可以看到想要的内容就提取出来了，结果是一个列表，包含标题内容和标题链接两个字段，由于内容过长，这里就省略了一部分。 接着我们再测试下正文的提取，随便打开一篇文章，比如 https://news.ifeng.com/c/7xrdz0kysde，保存下 HTML，命名为 detail.html。 编写测试代码如下：

1
2
3
4

import json
from gerapy_auto_extractor.extractors import extract_detail
html = open('detail.html', encoding='utf-8').read()
print(json.dumps(extract_detail(html), indent=2, ensure_ascii=False, default=str))

运行结果如下：

1
2
3
4
5

{
  "title": "内蒙古巴彦淖尔发布鼠疫疫情Ⅲ级预警",
  "datetime": "2020-07-05 18:54:15",
  "content": "2020年7月4日，乌拉特中旗人民医院报告了1例疑似腺鼠疫病例，根据《内蒙古自治区鼠疫疫情预警实施方案》（内鼠防应急发﹝2020﹞7号）和《自治区鼠疫控制应急预案（2020年版）》（内政办发﹝2020﹞17号）的要求，经研究决定，于7月5日发布鼠疫防控Ⅲ级预警信息如下：n一、预警级别及起始时间n预警级别：Ⅲ级。n2020年7月5日起进入预警期，预警时间从本预警通告发布之日持续到2020年底。n二、注意事项n当前我市存在人间鼠疫疫情传播的风险，请广大公众严格按照鼠疫防控“三不三报”的要求，切实做好个人防护，提高自我防护意识和能力。不私自捕猎疫源动物、不剥食疫源动物、不私自携带疫源动物及其产品出疫区；发现病（死）旱獭及其他动物要报告、发现疑似鼠疫病人要报告、发现不明原因的高热病人和急死病人要报告。要谨慎进入鼠疫疫源地，如有鼠疫疫源地的旅居史，出现发热等不适症状时及时赴定点医院就诊。n按照国家、自治区鼠疫控制应急预案的要求，市卫生健康委将根据鼠疫疫情预警的分级，及时发布和调整预警信息。n巴彦淖尔市卫生健康委员会n2020年7月5日n来源：巴彦淖尔市卫生健康委员会"
}

成功输出了标题、正文、发布时间等内容。 这里就演示了基本的列表页、详情页的提取操作。

算法

整个算法的实现比较杂，我看了几篇论文和几个项目的源码，然后经过一些修改实现的。 其中列表页解析的参考论文：

• 面向不规则列表的网页数据抽取技术的研究
• 基于块密度加权标签路径特征的 Web 新闻在线抽取

详情页解析的参考论文和项目：

• 基于文本及符号密度的网页正文提取方法
• GeneralNewsExtractor

这些都是不完全参考，然后加上自己的一些修改最终才形成了现在的结果。 算法在这里就几句话描述一下思路，暂时先不展开讲了。 列表页解析：

• 找到具有公共父节点的连续相邻子节点，父节点作为候选节点。
• 根据节点特征进行聚类融合，将符合条件的父节点融合在一起。
• 根据节点的特征、文本密度、视觉信息（尚未实现）挑选最优父节点。
• 从最优父节点内根据标题特征提取标题。

详情页解析：

• 标题根据 meta、title、h 节点综合提取
• 时间根据 meta、正则信息综合提取
• 正文根据文本密度、符号密度、视觉信息（尚未实现）综合提取。

后面等完善了之后再详细介绍算法的具体实现，现在如感兴趣可以去看源码。

说明

本框架仅仅发布了最初测试版本，测试覆盖度比较少，目前仅仅测试了有限的几个网站，尚未大规模测试和添加对比实验，因此准确率现在还没有标准的保证。 参考：关于详情页正文的提取我主要参考了 GeneralNewsExtractor 这个项目，原项目据测试可以达到 90% 以上的准确率。 列表页我测试了腾讯、网易、知乎等都是可以顺利提取的，如： 后面会有大规模测试和修正。 项目初版，肯定存在很多不足，希望大家可以多发 Issue 和提 PR。 另外这里建立了一个 Gerapy 开发交流群，之前在 QQ 群的也欢迎加入，以后交流就在微信群了，大家在使用过程遇到关于 Gerapy、Gerapy Auto Extractor 的问题欢迎交流。 这里放一个临时二维码，后期可能会失效，失效后大家可以到公众号「进击的 Coder」获取加群方式。

待开发功能

• 视觉信息的融合
• 文本相似度的融合
• 分类模型的融合
• 下一页翻页的信息提取
• 正文图片、视频的提取
• 对接 Gerapy

最后感谢大家的支持！

最近遇到 Mac 的 Git Status 显示中文乱码的问题，类似：

1

"\343\200\220\345\267\245\344\275\234\343\200\221\345\217\221\351\202\256\344\273\266\346\234\215\345\212\241.md"

解决方案：

1

git config --global core.quotepath false

完了之后就显示正常了。

主要亮点为配置和密码找回，安装什么的就。。。

MySQL 基本配置

官网地址：www.mysql.com 安装可参考：https://cuiqingcai.com/5200.html

window：

[gallery columns=”1” size=”full” ids=”9457”] 注意终端 mysqld 开启的不能关闭！

1
2

mysqld //启动服务
mysql //启动客户端

制作服务：

1. 关闭进程

1
2
3
4

// 查找任务进程
tasklist |findstr mysqld
//终止任务进程
taskkill /F /PID PID

1. 安装服务与移除服务

1
2
3
4

//安装服务
mysqld --install
//移除服务
mysqld --remove

Linux：

1
2
3
4

centos:
yum -y install mariadb-server mariadb
ubuntu:
yum -y install mysqld-server msyql-client

基本使用： // 查看所有的数据库 show databases； // 进入对应的库： use database（name） 查看表: select * from db;

配置环境变量：

1

vim /etc/profile

在文档最后一行加入：

1
2
3
4
5

PATH = /。。。:$PATH
export PATH
保存退出即可
然后在终端输入
source /etc/profile //生效

管理员密码设置与找回：

管理员账号登录(没有密码，直接回车进入。)

1	mysql -uroot -p

设置管理员密码

1 2 3

mysqladmin -uroot -p {oldPassworld(原始密码，默认为“”,空)} password {“newpassoworld”}; mysqladmin -uroot -p password {“passoworld”}; # passoworld为你锁需要设置的密码哦

MySQL 密码找回：

密码验证思路：mysql 必定将管理员账号密码存储在某个文件夹内，使用时与输入密码验证，成功则能够连接，否则连接失败。 密码找回思路： 跳过 MySQL 密码的验证直接进入

1. 停止 mysql 服务（注：需要终端的管理员权限运行）

   // windows:

查询进程，并找到 PID：

1. tasklist | findsrt mysqld
   1
   2
   3
   4
   
                           
                           
   
                             
   2.  kill 掉 mysql 进程，否则是停止不了服务的，无论如何都需要 kill 掉：
   
   ![](https://cdn.cuiqingcai.com/wp-content/uploads/2020/06/change_password1.png)
   
   
                           
                           
                           
                           
    #此处的为上面查询到的PID，每次都是不一样的，所以就不写具体值了 taskkill /F /PID PID 
   
                             
   
                               
   
                                 
   
                                   
   1
   
                                 
                                 
   
                                   
   
   
                                 
                               
                             
                           
    net stop mysql 
   
                             
   
                               
   
                                 
   
                                   
   1
   2
   3
   4
   
                                 
                                 
   
                                   
   
   // Linux/mac:命令不同，基本思路相同 systemctl stop mysql(centos 中默认的 mysql 是 mariadb，可将 mysql 替换成 mariadb 即可)
   
   若安装了 mysqld(mysql 服务)需停止 MySQL 的进程服务 ，若没有安装 mysql 的服务则此步可省略 重新启动 mysql 服务，且跳过授权表 
   
                                 
                               
                             
                           
    Windows： //启动不起来，可能需要net start mysql（这个是特殊情况） mysqld --skip-grant-tables //Linux/mac： mysqld ——safe --skip-grant-tables 
   
                             
   
                               
   
                                 
   
                                   
   1
   2
   3
   4
   5
   6
   
                                 
                                 
   
                                   
   
   登录，重新修改密码
   
   > // 登录(此时 MySQL 的 root 权限是没有密码的，直接回车即可进入) mysql -uroot -p // 修改密码（在连接数据库状态中）： update mysql.user set password=password("yourpassword") where user="uroot" and host="localhost"
   >
   >
   
                                 
                               
                             
                           
    此语句是告诉数据库，更新密码。密码为yourpassword where 为限制条件 ，限制user为root，host为localhost MySQL的关于用户授权表是存放在mysql库user表中的 
   
                             
   
                               
   
                                 
   
                                   
   1
   2
   3
   
                                 
                                 
   
                                   
   
   刷新保存设置(这个一定需要，要不之前的功夫都白费了)：
   
   
                                 
                               
                             
                           
    flush privileges; 
   
                             
   
                               
   
                                 
   
                                   
   1
   2
   3
   
                                 
                                 
   
                                   
   
   退出：
   
   
                                 
                               
                             
                           
    q # 或者 exit 
   
                             
   
                               
   
                                 
   
                                   
   1
   2
   3
   4
   5
   6
   7
   8
   9
   
                                 
                                 
   
                                   
   
   重启启动 mysql 服务（终端中）： 安装了 MySQL 服务的：net start mysql 若没有安装则在 cmd 中 mysqld 启动一些，用另外的一个 cmd 连接即可
   
   ## 字符编码:
   
   查看字符编码
   
   登录进入 mysql 后
   
   
                                 
                               
                             
                           
    \\s 

   

进入 mysql 文件夹（这个可不设置，当然设置最好。）： 字符编码配置默认文件：my-default.ini 新建后缀名为:’.ini‘的文件

[mysqld] character-set-server=utf8 collation-server=urf8_general_ci [client] default-character=utf8 [mysql] default-character=utf8 user =”root” password =”123456”

我自己用 Mac 自带的终端很久了，感觉一直还不错。 但美中不足的是终端上面的这个标题实在让人看着太糟心了，看图： 上面这行标题，没什么用，又这么难看。 我把偏好设置里面的显示内容都去掉了，设置如下： 但是它总是还显示了一个标题，显示成这个样子： 上面这个标题看得很难受，我想把它改成无任何内容，简洁清爽，如下图所示： 但是现在无论我怎么改偏好设置都不行，总会带上那些信息。 后来搜索了一番发现是 zsh 的问题。 打开 ~/.zshrc 这个文件，找到下面这一行：

1

DISABLE_AUTO_TITLE="true"

把这行取消注释。 另外偏好设置里面把所有的勾选都去掉，如图所示： 另外注意这里标题处不能完全为空，需要打上一个空格，否则窗口上方会显示「终端」二字。 最后在 ~/.zshrc 最后还可以加上这一行语句来清屏：

1

clear

这样就不会再显示 Last Login 等相关信息了。 最后看下效果，打开终端就会显示如下样子，简洁清爽，舒服了。 完毕。

SSH 配置：

• 使用命令在 home 文件夹下新建一个 ssh 文件

配置 SSH 信息，命令：ssh-keygen -t rsa -C e-mail（此时的 C 必须是大写，Email 为绑定了 github 的邮箱），稍后一路回车选择默认值即可

查看 id_rsa.pub 信息，并将其复制到粘贴版中(稍后会用到！)

• 
• 进入到 github 中点击右上角的头像，选择 setting ——> SSH and GPG keys ——> 将上述复制内容粘贴到编辑面板中——>完成
• 

完成

远程库操作

创建远程库地址别名

git remote add [origin] [Warehouse URI] 创建别名为 origin，github 仓库地址为。。。的 git remote -v 查看相关信息

推送操作：

使用命令:

1

git push 别名(origin) 分支名(master)

注意是将本地库进行推送！！！（此时时事先完成了一些对本地库相关操作）

克隆操作：

git clone [URI]

1. 首先复制相对应的仓库地址：

这里是克隆下来的结果显示

• 克隆的作用：

  1. 完整的把远程库克隆下来
  2. 创建 origin 远程地址别名
  3. 初始化本地库

  团队内协作

• 

• 邀请成员加入仓库工作团队：

  如果没有加入团队是没有权限向所相关的库进行推送的！！！ 如何设置（获得）权限呢？（在仓库中点击设置选项进入如下界面）

完成以上操作之后在进行推送即可有权限完成推送。

fetch and merge 操作（二者一起使用相当于 pull）

git remote -v

git fetch [远程库中简称(origin)] [远程库分支名(master)]

git merge [远程库中简称/远程库分支名(origin/master)]

fetch：

1. 首先是查看了 remote
2. 然后使用 git fetch 命令下载了远程库内容
3. 查看本地库中的 project.txt 内容
4. 切换到新下载的 master 目录（可使用 git reflog 查看分支状态）
5. 查看远程库中 project.txt 内容

merge：将远程库下载的内容与本地库合并

1

git mergo origin/master

Pull 使用：

pull 冲突处理：