diff --git a/.github/workflows/ruby.yml b/.github/workflows/ruby.yml
new file mode 100644
index 0000000000..3d479c642c
--- /dev/null
+++ b/.github/workflows/ruby.yml
@@ -0,0 +1,38 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake
+# For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby
+
+name: Ruby
+
+on:
+ push:
+ branches: [ "master" ]
+ pull_request:
+ branches: [ "master" ]
+
+permissions:
+ contents: read
+
+jobs:
+ test:
+
+ runs-on: ubuntu-latest
+ strategy:
+ matrix:
+ ruby-version: ['2.6', '2.7', '3.0']
+
+ steps:
+ - uses: actions/checkout@v3
+ - name: Set up Ruby
+ # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby,
+ # change this to (see https://github.com/ruby/setup-ruby#versioning):
+ # uses: ruby/setup-ruby@v1
+ uses: ruby/setup-ruby@55283cc23133118229fd3f97f9336ee23a179fcf # v1.146.0
+ with:
+ ruby-version: ${{ matrix.ruby-version }}
+ bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+ - name: Run tests
+ run: bundle exec rake
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Cache/b7/9606fb3afea5bd1609ed40b622142f1c98125abcfe89a76a661b0e8e343910 b/.jekyll-cache/Jekyll/Cache/Jekyll--Cache/b7/9606fb3afea5bd1609ed40b622142f1c98125abcfe89a76a661b0e8e343910
new file mode 100644
index 0000000000..0f5cadf4ea
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Cache/b7/9606fb3afea5bd1609ed40b622142f1c98125abcfe89a76a661b0e8e343910
@@ -0,0 +1 @@
+I") {"source"=>"D:/Documents/GitHub/ChanJeunlam.github.io", "destination"=>"D:/Documents/GitHub/ChanJeunlam.github.io/_site", "collections_dir"=>"", "cache_dir"=>".jekyll-cache", "plugins_dir"=>"_plugins", "layouts_dir"=>"_layouts", "data_dir"=>"_data", "includes_dir"=>"_includes", "collections"=>{"posts"=>{"output"=>true, "permalink"=>"/:year/:month/:title/"}}, "safe"=>false, "include"=>[".htaccess"], "exclude"=>[".sass-cache", ".jekyll-cache", "gemfiles", "Gemfile", "Gemfile.lock", "node_modules", "vendor/bundle/", "vendor/cache/", "vendor/gems/", "vendor/ruby/"], "keep_files"=>[".git", ".svn"], "encoding"=>"utf-8", "markdown_ext"=>"markdown,mkdown,mkdn,mkd,md", "strict_front_matter"=>false, "show_drafts"=>nil, "limit_posts"=>0, "future"=>false, "unpublished"=>false, "whitelist"=>[], "plugins"=>["jekyll-paginate"], "markdown"=>"kramdown", "highlighter"=>"rouge", "lsi"=>false, "excerpt_separator"=>"\n\n", "incremental"=>false, "detach"=>false, "port"=>"4000", "host"=>"127.0.0.1", "baseurl"=>nil, "show_dir_listing"=>false, "permalink"=>"/:year/:month/:title/", "paginate_path"=>"page/:num/", "timezone"=>nil, "quiet"=>false, "verbose"=>false, "defaults"=>[], "liquid"=>{"error_mode"=>"warn", "strict_filters"=>false, "strict_variables"=>false}, "kramdown"=>{"auto_ids"=>true, "toc_levels"=>[1, 2, 3, 4, 5, 6], "entity_output"=>"as_char", "smart_quotes"=>"lsquo,rsquo,ldquo,rdquo", "input"=>"GFM", "hard_wrap"=>false, "guess_lang"=>true, "footnote_nr"=>1, "show_warnings"=>false, "math_engine"=>"mathjax", "syntax_highlighter"=>"rouge", "syntax_highlighter_opts"=>{"disable"=>true}}, "title"=>"陈同学", "subtitle"=>"个人站", "description"=>"欢迎来到我的个人站~", "avatarTitle"=>"nothing can stop me", "avatarDesc"=>"物理海洋学在读", "url"=>"http://localhost:4000", "enableToc"=>true, "social"=>{"mail"=>"jchenfl@connect.ust.hk"}, "textColor"=>nil, "cover_color"=>"clear", "blog_button"=>{"title"=>"博客主页"}, "nav"=>[{"title"=>"所有文章", "description"=>"archive", "url"=>"/archive"}, {"title"=>"标签", "description"=>"tags", "url"=>"/tags"}, {"title"=>"技术支持", "description"=>"support", "url"=>"/support"}, {"title"=>"关于我", "description"=>"about", "url"=>"/about"}], "gems"=>["jekyll-paginate", "jekyll-sitemap"], "paginate"=>20, "livereload_port"=>35729, "serving"=>true, "watch"=>true}:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/01/b5e0fc46fc760629704bd030cb0cedf5328d21c7cebd2e6ebb1815ef170054 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/01/b5e0fc46fc760629704bd030cb0cedf5328d21c7cebd2e6ebb1815ef170054
new file mode 100644
index 0000000000..3f8211c6ac
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/01/b5e0fc46fc760629704bd030cb0cedf5328d21c7cebd2e6ebb1815ef170054
@@ -0,0 +1,28 @@
+I"b
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/01/df8ce918bac1637ac6268843d1241dd157698ead997f3f1e0c56aa64ea10df b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/01/df8ce918bac1637ac6268843d1241dd157698ead997f3f1e0c56aa64ea10df
new file mode 100644
index 0000000000..2a098b2e63
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/01/df8ce918bac1637ac6268843d1241dd157698ead997f3f1e0c56aa64ea10df
@@ -0,0 +1,9 @@
+I"
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/03/583b7404770fa0fb0ca0bf3f03c507f3e7ce34dbde75144fa23f0face11849 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/03/583b7404770fa0fb0ca0bf3f03c507f3e7ce34dbde75144fa23f0face11849
new file mode 100644
index 0000000000..84c8919d5f
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/03/583b7404770fa0fb0ca0bf3f03c507f3e7ce34dbde75144fa23f0face11849
@@ -0,0 +1,23 @@
+I"
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/03/e999d53c2d290434c2ec301bc6a9e45c424054cb5eac5e5dbcf253b8b9a4e5 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/03/e999d53c2d290434c2ec301bc6a9e45c424054cb5eac5e5dbcf253b8b9a4e5
new file mode 100644
index 0000000000..8002cf7c85
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/03/e999d53c2d290434c2ec301bc6a9e45c424054cb5eac5e5dbcf253b8b9a4e5
@@ -0,0 +1,2 @@
+I"3谢春花的歌
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/04/98b4e8c3cb7957bf7a635202eb65bc47ac42d38b9de4203acf632b99585e5a b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/04/98b4e8c3cb7957bf7a635202eb65bc47ac42d38b9de4203acf632b99585e5a
new file mode 100644
index 0000000000..33e9e3e7df
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/04/98b4e8c3cb7957bf7a635202eb65bc47ac42d38b9de4203acf632b99585e5a
@@ -0,0 +1,2 @@
+I"E02 概率论与信息论
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/05/eb8f68557b04f181c1f76f54c1682ddfd8b3185805aae395f81efca906e840 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/05/eb8f68557b04f181c1f76f54c1682ddfd8b3185805aae395f81efca906e840
new file mode 100644
index 0000000000..1e82484597
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/05/eb8f68557b04f181c1f76f54c1682ddfd8b3185805aae395f81efca906e840
@@ -0,0 +1,236 @@
+I"9BDD接口测试是什么？
+
+BDD (Behavior Driven Development) 是一种软件开发方法，旨在通过定义和执行行为来增强软件的可理解性和可维护性。在接口测试中，BDD 可以帮助我们更好地描述接口的行为和期望结果，从而提高测试用例的可读性和可维护性。
+
+Pytest-BDD 是一个 Pytest 插件，它提供了对 BDD 测试的支持。下面是一些使用 Pytest-BDD 进行接口测试的步骤：
+
+
+ - 安装 Pytest-BDD
+
+
+可以使用 pip 命令安装 Pytest-BDD：
+
+pip install pytest-bdd
+
+
+
+ - 定义 Feature 文件
+
+
+在 BDD 中，测试用例通常以 Feature 文件的形式进行组织。Feature 文件是一个文本文件，用于描述测试用例的场景和期望结果。例如，以下是一个示例 Feature 文件：
+
+Feature: User API
+
+Scenario: Create a new user
+ Given I have a valid access token
+ When I make a POST request to "/users" with the following data
+ | username | john_doe |
+ | email | john_doe@example.com |
+ | password | 123456 |
+ Then the response status code should be 201
+ And the response should contain the following data
+ | username | john_doe |
+ | email | john_doe@example.com |
+
+
+在这个示例中，Feature 文件定义了一个名为 “User API” 的 Feature，其中包含一个名为 “Create a new user” 的 Scenario。Scenario 中描述了测试用例的场景和期望结果，包括给定的前提条件 (Given)、操作 (When) 和断言 (Then)。
+
+
+ - 定义 Step Definitions
+
+
+Step Definitions 是一个 Python 模块，用于实现 Feature 文件中定义的 Given、When 和 Then 步骤。例如，以下是一个示例 Step Definitions：
+
+import requests
+from pytest_bdd import given, when, then, parsers
+
+@given("I have a valid access token")
+def valid_access_token():
+ # 返回一个有效的访问令牌
+ return "valid_token"
+
+@when(parsers.parse('I make a {method} request to "{url}" with the following data'))
+def make_request(method, url):
+ # 根据方法和 URL 发送请求
+ # 将数据作为请求正文发送
+ response = requests.request(method, url, json=parsers.parse_table())
+ return response
+
+@then(parsers.parse('the response status code should be {status_code:d}'))
+def check_status_code(make_request, status_code):
+ assert make_request.status_code == status_code
+
+@then(parsers.parse('the response should contain the following data'))
+def check_response_data(make_request):
+ expected_data = parsers.parse_table()
+ actual_data = make_request.json()
+ assert expected_data in actual_data.values()
+
+
+在这个示例中，Step Definitions 实现了 Feature 文件中定义的 Given、When 和 Then 步骤。Step Definitions 使用 Pytest-BDD 提供的装饰器 (如 @given、@when 和 @then) 来标记步骤，以及 Pytest-BDD 提供的 parsers.parse 方法来解析表格数据。
+
+
+ - 运行测试用例
+
+
+使用 Pytest 运行测试用例时，可以使用 --bdd 参数来指定测试目录和模式，如：
+
+pytest --bdd tests/ --verbose
+
+
+在运行测试用例时，Pytest-BDD 将自动扫描测试目录下的 Feature 文件和 Step Definitions，然后根据 Feature 文件定义的场景执行测试用例。
+
+总之，使用 Pytest-BDD 进行接口测试可以帮助我们更好地描述接口的行为和期望结果，从而提高测试用例的可读性和可维护性。建议了解 Pytest-BDD 官方文档中有关 BDD 测试的更多内容，以便更好地使用 Pytest-BDD 进行接口测试。
+
+定义 Feature 文件的格式可以展开说明一下吗
+
+Feature 文件是 BDD 测试中用于描述测试用例的场景和期望结果的文本文件。它通常采用 Gherkin 语言进行编写，Gherkin 语言是一种基于自然语言的 DSL (Domain Specific Language)，它提供了一种简单易懂的语法，用于描述测试用例的场景和期望结果。
+
+下面是一个 Feature 文件的示例，它描述了一个用户管理系统的测试用例场景：
+
+Feature: User Management
+ As a system administrator
+ I want to manage users
+ So that I can manage access to the system
+
+ Scenario: Create a new user
+ Given I am logged in as an administrator
+ When I create a new user with the following details
+ | username | john_doe |
+ | email | john_doe@example.com |
+ | password | 123456 |
+ Then the user should be created successfully
+
+ Scenario: Update an existing user
+ Given I am logged in as an administrator
+ And there is an existing user with the username "jane_doe"
+ When I update the user with the username "jane_doe" with the following details
+ | email | jane_doe@example.com |
+ | password | 654321 |
+ Then the user should be updated successfully
+
+ Scenario: Delete an existing user
+ Given I am logged in as an administrator
+ And there is an existing user with the username "jane_doe"
+ When I delete the user with the username "jane_doe"
+ Then the user should be deleted successfully
+
+
+在这个示例中，Feature 文件包含了一个名为 “User Management” 的 Feature，它描述了一个用户管理系统的测试用例场景。Feature 文件中的每个 Scenario 描述了一个测试用例，包括前提条件 (Given)、操作 (When) 和断言 (Then)。
+
+Feature 文件的基本语法格式如下：
+
+Feature: <feature name>
+ <feature description>
+
+ Scenario: <scenario name>
+ Given <precondition>
+ When <action>
+ Then <assertion>
+
+ Scenario: <scenario name>
+ Given <precondition>
+ When <action>
+ Then <assertion>
+
+ ...
+
+
+其中，Feature、Scenario、Given、When 和 Then 等关键字都是 Gherkin 语言中的保留关键字，用于描述测试用例的场景和期望结果。Feature 文件的详细格式和语法可以参考 Gherkin 语言的官方文档和 Pytest-BDD 的官方文档。
+
+Step Definitions中的@when(parsers.parse(‘I make a request to “” with the following data’))我看不太懂
+
+这段 Step Definitions 中的 @when(parsers.parse('I make a request to "{url}" with the following data')) 是一个装饰器，用于标记一个 When 步骤。该步骤对应 Feature 文件中的一行，例如：
+
+When I make a request to "https://example.com/api/users" with the following data
+
+
+装饰器的参数 parsers.parse('I make a request to "{url}" with the following data') 表示使用 parsers.parse() 方法来解析 Feature 文件中的文本，并将其中的 {url} 参数解析为 Step Definitions 函数的 url 参数。
+
+当 Pytest-BDD 执行测试用例时，它会将 Feature 文件中的文本传递给 Step Definitions 函数，例如：
+
+@when(parsers.parse('I make a request to "{url}" with the following data'))
+def make_request(url):
+ # 执行 HTTP 请求，使用 url 和数据表格中的数据
+ pass
+
+
+在这个示例中，make_request() 函数接受一个 url 参数，并且使用该参数和数据表格中的数据来执行 HTTP 请求。例如，如果 Feature 文件中的文本是 When I make a request to "https://example.com/api/users" with the following data，则 Pytest-BDD 会将 https://example.com/api/users 作为 url 参数传递给 make_request() 函数，并且将数据表格作为函数的参数传递。
+
+希望这样的解释能够帮助您理解 Step Definitions 中的装饰器和参数。
+
+我看不太懂@then(parsers.parse(‘the response status code should be’)) def check_status_code(make_request, status_code): assert make_request.status_code == status_code
+
+这段代码是一个 Step Definitions 中的 @then 装饰器，用于标记一个 Then 步骤。该步骤对应于 Feature 文件中的一行，例如：
+
+Then the response status code should be 200
+
+
+装饰器的参数 parsers.parse('the response status code should be {status_code:d}') 表示使用 parsers.parse() 方法来解析 Feature 文件中的文本，并将其中的 {status_code} 参数解析为 Step Definitions 函数的 status_code 参数。d 表示将该参数解析为整数类型。
+
+当 Pytest-BDD 执行测试用例时，它会将 Feature 文件中的文本传递给 Step Definitions 函数，例如：
+
+@then(parsers.parse('the response status code should be {status_code:d}'))
+def check_status_code(make_request, status_code):
+ assert make_request.status_code == status_code
+
+
+在这个示例中，check_status_code() 函数接受一个 make_request 参数和一个 status_code 参数。make_request 参数是一个在之前的 Given 或 When 步骤中执行的请求对象（例如使用 requests 库发出的 HTTP 请求），而 status_code 参数则是从 Feature 文件中解析出来的 HTTP 状态码。
+
+该函数的实现是检查 make_request 对象的状态码是否等于 status_code 参数。如果状态码不相等，那么该断言会失败，从而标记该测试用例为失败。
+
+希望这样的解释能够帮助您理解 Step Definitions 中的装饰器和参数，并理解其在 Pytest-BDD 中的作用。
+
+BDD接口自动化测试怎么管理很多的测试数据呢
+
+在 BDD 接口自动化测试中，管理大量测试数据的方法有很多种，具体根据项目的实际情况和需求来选择。
+
+以下是一些常用的管理测试数据的方法：
+
+
+ - 数据库管理：将测试数据存储在数据库中，并使用 SQL 语句来获取和操作数据。这种方法可以方便地进行数据的增删改查和管理，但需要一些数据库知识和维护成本。
+ - Excel/CSV 文件管理：将测试数据存储在 Excel 或 CSV 文件中，使用 Python 的 pandas 库或其他数据处理库来读取和操作数据。这种方法可以方便地进行数据的导入导出和管理，但需要一些额外的开发工作。
+ - 配置文件管理：将测试数据存储在配置文件中，例如 YAML 或 JSON 格式的文件，使用 Python 的 ConfigParser 或其他配置文件解析库来读取和操作数据。这种方法可以方便地进行数据的配置和管理，但需要一些额外的开发工作。
+ - 数据生成工具：使用 Python 的 Faker 库或其他数据生成库来生成测试数据。这种方法可以方便地生成大量的测试数据，但需要确保生成的数据符合业务逻辑和要求。
+
+
+无论采用哪种方法，都需要注意测试数据的可维护性和可重用性，以便在测试用例变更或新增时能够快速地修改或添加测试数据。同时，也需要对测试数据进行合理的组织和分类，以便于测试用例的管理和维护。
+
+可以更加具体说一下这个步骤吗，还是不懂怎么写入大数据到feature中
+
+如果您需要在 Feature 文件中写入大量的测试数据，可以使用数据表格来组织数据，并将数据表格写入 Feature 文件中。数据表格是 Feature 文件中以表格格式表示的数据，可以包含多行和多列的数据。
+
+以下是一个示例 Feature 文件，其中包含一个数据表格：
+
+Feature: 订单管理
+
+ Scenario: 创建订单
+ Given 用户登录系统
+ When 用户创建订单
+ | 商品名称 | 数量 |
+ | 商品A | 2 |
+ | 商品B | 1 |
+ Then 订单创建成功
+
+
+在上面的示例中，数据表格位于 When 步骤下面，使用管道符 | 来分隔每一列的数据。第一行表示每一列的列名，后面的行表示实际的数据。您可以根据需要添加或删除列和行，以适应不同的测试场景。
+
+在 Step Definitions 中，您可以使用 Pytest-BDD 提供的 parsers.parse_table() 方法来解析数据表格，并将其转换为 Python 中的数据结构，例如列表或字典。以下是一个示例 Step Definitions：
+
+@when(parsers.parse('用户创建订单'))
+def create_order():
+ pass
+
+@when(parsers.parse('用户创建订单'))
+def create_order(make_request, data):
+ for row in data:
+ product_name = row['商品名称']
+ quantity = row['数量']
+ # 使用商品名称和数量创建订单项
+ pass
+
+
+在上面的示例中，create_order() 函数接受一个 make_request 参数和一个 data 参数，其中 data 参数是通过 parsers.parse_table() 方法解析出来的数据表格。在函数中，我们可以遍历数据表格的每一行，并使用其中的数据来执行一系列操作，例如创建订单项。
+
+通过使用数据表格和 parsers.parse_table() 方法，您可以方便地将大量测试数据写入 Feature 文件和 Step Definitions 中，并且可以轻松地扩展和维护这些数据。
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/06/48308429dcf44da30a98518f9713729a79a25da89bd39a5080f3afb2ece1d2 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/06/48308429dcf44da30a98518f9713729a79a25da89bd39a5080f3afb2ece1d2
new file mode 100644
index 0000000000..b31bbc41e3
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/06/48308429dcf44da30a98518f9713729a79a25da89bd39a5080f3afb2ece1d2
@@ -0,0 +1,122 @@
+I"介绍了邮件配置的目的，邮件配置的方法，邮件封装以及邮件运行。
+
+邮件配置
+
+目的
+
+使用邮件，方便获取自动化测试的结果
+
+配置文件设置以及邮件封装
+
+邮件配置
+
+举个例子：
+
+打开163邮箱或者qq邮箱的设置页面，在设置页面中找到POP3/SMTP/IMAP服务，开启服务（查看服务器地址），获取授权码，填写到配置文件config.yml中
+
+email:
+ smtpserver: "smtp.itcast.com"
+ username: "wangxu@itcast.com"
+ password: "FDSArewq1"
+ receiver: "wangxu@itcast.com"
+
+
+修改了配置文件后，需要在Conf.py中添加如下代码,来读取email配置有关信息：
+
+def get_email_info(self):
+ """
+ 获取邮件配置相关信息
+ :return:
+ """
+ return self.config["email"]
+
+
+邮件封装
+
+在utils文件夹下新建一个EmailUtil.py文件，用来封装邮件发送的方法
+
+from email.mime.multipart import MIMEMultipart # MIMEMultipart类表示邮件的主体,可以包含多个邮件体,可以包含文本,附件等
+from email.mime.text import MIMEText # MIMEText类表示邮件的文本内容
+import smtplib
+#初始化
+#smtp地址，用户名，密码，接收邮件者，邮件标题，邮件内容，邮件附件
+class SendEmail:
+ # __init__方法表示初始化方法，当类被实例化时，会自动调用该方法
+ def __init__(self,smtp_addr,username,password,recv,
+ title,content=None,file=None):
+ self.smtp_addr = smtp_addr # 邮件服务器地址
+ self.username = username
+ self.password = password
+ self.recv = recv
+ self.title = title
+ self.content = content
+ self.file = file
+ #发送邮件方法
+ def send_mail(self):
+ #MIME
+ msg = MIMEMultipart()
+ #初始化邮件信息
+ msg.attach(MIMEText(self.content,_charset="utf-8"))
+ msg["Subject"] = self.title
+ msg["From"] = self.username
+ msg["To"] = self.recv
+ #邮件附件
+ #判断是否附件
+ if self.file:
+ #MIMEText读取文件
+ att = MIMEText(open(self.file).read())
+ #设置内容类型
+ att["Content-Type"] = 'application/octet-stream'
+ #设置附件头
+ att["Content-Disposition"] = 'attachment;filename="%s"'%self.file
+ #将内容附加到邮件主体中
+ msg.attach(att)
+ #登录邮件服务器
+ self.smtp = smtplib.SMTP(self.smtp_addr,port=25)
+ self.smtp.login(self.username,self.password)
+ #发送邮件
+ self.smtp.sendmail(self.username,self.recv,msg.as_string())
+
+if __name__ == "__main__":
+ #初始化类(self,smtp_addr,username,password,recv,
+ # title,content=None,file=None):
+ from config.Conf import ConfigYaml
+ email_info = ConfigYaml().get_email_info()
+ smtp_addr = email_info["smtpserver"]
+ username = email_info["username"]
+ password = email_info["password"]
+ recv = email_info["receiver"]
+ email = SendEmail(smtp_addr,username,password,recv,"测试")
+ email.send_mail()
+
+
+邮件运行
+
+这一步主要包括：（1）封装公共方法；(2) 应用测试发送
+
+在common文件夹下面的Base.py文件中，添加如下代码：
+
+def send_mail(report_html_path="",content="",title="测试"):
+ """
+ 发送邮件
+ :param report_html_path:
+ :param content:
+ :param title:
+ :return:
+ """
+ email_info = ConfigYaml().get_email_info()
+ smtp_addr = email_info["smtpserver"]
+ username = email_info["username"]
+ password = email_info["password"]
+ recv = email_info["receiver"]
+ email = SendEmail(
+ smtp_addr=smtp_addr,
+ username=username,
+ password=password,
+ recv=recv,
+ title=title,
+ content=content,
+ file=report_html_path)
+ email.send_mail()
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/06/64630330bf3282a4b26b683af4b4bc4b8698249aeb33fe7c12b58b3de2abfd b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/06/64630330bf3282a4b26b683af4b4bc4b8698249aeb33fe7c12b58b3de2abfd
new file mode 100644
index 0000000000..76f60353c6
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/06/64630330bf3282a4b26b683af4b4bc4b8698249aeb33fe7c12b58b3de2abfd
@@ -0,0 +1,6 @@
+I"
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/07/9a88dae576eb16b57f883ca5163bfd13003aac04d2762518e1317bb6ed9d26 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/07/9a88dae576eb16b57f883ca5163bfd13003aac04d2762518e1317bb6ed9d26
new file mode 100644
index 0000000000..640009b877
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/07/9a88dae576eb16b57f883ca5163bfd13003aac04d2762518e1317bb6ed9d26
@@ -0,0 +1,2 @@
+I"E在VScode中如何配置
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/0a/482aef90222ed651eae71b72102b333e45377092643b9154e4a2e002536866 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/0a/482aef90222ed651eae71b72102b333e45377092643b9154e4a2e002536866
new file mode 100644
index 0000000000..43122ad7af
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/0a/482aef90222ed651eae71b72102b333e45377092643b9154e4a2e002536866
@@ -0,0 +1,2 @@
+I"E对CPU进行压力测试
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/11/86977ddc11f7b6a53917b6c8540459e9b7becbab41a6cb6fa3f85d25db70e3 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/11/86977ddc11f7b6a53917b6c8540459e9b7becbab41a6cb6fa3f85d25db70e3
new file mode 100644
index 0000000000..858fc2a633
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/11/86977ddc11f7b6a53917b6c8540459e9b7becbab41a6cb6fa3f85d25db70e3
@@ -0,0 +1,2 @@
+I"Ulinux系统的网络连接状态
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/13/650f01be53f8d32fe2fcf0b74f218a0686477e3162ced221a4204e56086981 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/13/650f01be53f8d32fe2fcf0b74f218a0686477e3162ced221a4204e56086981
new file mode 100644
index 0000000000..6e81fdd991
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/13/650f01be53f8d32fe2fcf0b74f218a0686477e3162ced221a4204e56086981
@@ -0,0 +1,388 @@
+I"1断言是一种判断程序执行结果是否符合预期的方法，可以帮助我们定位错误原因，是自动化测试的灵魂。本文主要介绍pytest中使用assert进行断言，断言的应用和封装。断言结果的验证，包括状态码、返回信息验证，以及数据库断言结果验证。
+
+结果断言
+
+断言介绍
+
+
+ - 断言是一种判断程序执行结果是否符合预期的方法。断言的好处是当测试用例执行失败时，可以很方便地定位错误原因。
+ - 断言是自动化最终的目的，一个用例没有断言，就失去了自动化测试的意义了。
+ - 断言用到的是 assert关键字。预期的结果和实际结果做对比，符合预期就是pass，不符合就fail。
+
+
+常用断言
+
+pytest里面的断言就是python里assert的断言方法：
+
+
+ - assert expression1, expression2 # 断言表达式1为真，否则抛出异常expression2，expression2可以省略，省略时默认抛出AssertionError异常，expression2可以是字符串，也可以是异常对象。
+ - assert not expression1 # 断言表达式1为假，否则抛出AssertionError异常。
+ - assert expression1 == expression2 # 断言表达式1和表达式2相等，否则抛出AssertionError异常。
+ - assert expression1 != expression2 # 断言表达式1和表达式2不相等，否则抛出AssertionError异常。
+ - assert expression1 in expression2 # 断言表达式1是表达式2的子集，否则抛出AssertionError异常。
+ - assert expression1 not in expression2 # 断言表达式1不是表达式2的子集，否则抛出AssertionError异常。
+
+
+import pytest
+
+#判断xx为真
+#1、定义方法进行assert
+def test_1():
+ a = True
+ assert a
+
+#判断XX不为真
+def test_2():
+ a= True
+ assert not a
+
+#判断b包含a
+def test_3():
+ a="hello"
+ b="hello world"
+ assert a in b
+#判断a==b
+def test_4():
+ a=b="hello"
+ assert a ==b
+
+#判断a!=b
+def test_5():
+ a="hello"
+ b="hello world"
+ assert a !=b
+
+#2、运行查看结果
+if __name__ == "__main__":
+ pytest.main(["pytest_assert.py"])
+
+
+测试结果如下：
+============================= test session starts ==============================
+collecting ... collected 5 items
+
+pytest_assert.py::test_1 PASSED
+pytest_assert.py::test_2 FAILED
+testcase/t_pytest/pytest_assert.py:9 (test_2)
+def test_2():
+ a= True
+> assert not a
+E assert not True
+
+pytest_assert.py:12: AssertionError
+
+
+
+
+pytest_assert.py::test_3 PASSED
+pytest_assert.py::test_4 PASSED
+pytest_assert.py::test_5 PASSED
+
+========================= 1 failed, 4 passed in 0.06s ==========================
+
+进程已结束,退出代码1
+
+
+断言应用和封装
+
+断言应用
+首先，在utils目录下新建一个AssertUtil.py文件，用来封装断言方法。
+
+from utils.LogUtil import my_log
+import json
+#1、定义封装类
+class AssertUtil:
+#2、初始化数据，日志
+ def __init__(self):
+ self.log = my_log("AssertUtil")
+#3、code相等
+ def assert_code(self,code,expected_code):
+ """
+ 验证返回状态码
+ :param code:
+ :param expected_code:
+ :return:
+ """
+ try:
+ assert int(code) == int(expected_code)
+ return True
+ except:
+ self.log.error("code error,code is %s,expected_code is %s"%(code,expected_code))
+
+ raise
+#4、body相等
+ def assert_body(self,body,expected_body):
+ """
+ 验证返回结果内容相等
+ :param body:
+ :param expected_body:
+ :return:
+ """
+ try :
+ assert body == expected_body
+ return True
+ except:
+ self.log.error("body error,body is %s,expected_body is %s"%(body,expected_body))
+ raise
+#5、body包含
+ def assert_in_body(self,body,expected_body):
+ """
+ 验证返回结果是否包含期望的结果
+ :param body:
+ :param expected_body:
+ :return:
+ """
+ try:
+ body = json.dumps(body)
+ print(body)
+ assert expected_body in body
+ return True
+ except:
+ self.log.error("不包含或者body是错误，body is %s,expected_body is %s"%(body,expected_body))
+ raise
+
+
+写好了Utils目录下的AssertUtil.py文件，接下来我们要开始在test_mall.py中调用该断言方法对返回状态码和结果进行验证。
+
+from utils.AssertUtil import AssertUtil
+
+# 测试返回的code1
+#返回状态码
+code = r["code"]
+#assert code == 200
+AssertUtil().assert_code(code,200)
+
+#返回结果内容
+#body = json.dumps(r["body"])
+body = r["body"]
+#assert '"user_id": 1, "username": "python"' in body
+AssertUtil().assert_in_body(body,'"user_id": 1, "username": "python"')
+
+
+
+数据库结果断言
+
+大多数情况下，我们接口自动化测试需要对数据库进行验证，比如说，我们在注册接口中，需要验证数据库中是否有新增的数据，这时候我们就需要对数据库进行查询，然后对查询结果进行断言。比如说，我们需要对订单接口进行测试，需要验证数据库中的订单数据是否正确，这时候我们就需要对数据库进行查询，然后对查询结果进行断言。
+
+PyMySQL安装以及简单使用
+
+PyMySQL是Python的一个MySQL数据库驱动，它实现了Python DB API 2.0规范的全部标准，基于纯Python语言编写，所以它不依赖任何其他的库，可以很好的和Twisted，web.py等框架集成。
+
+PyMySQL的安装非常简单，直接使用pip命令即可安装。
+
+pip install pymysql
+
+
+或者在requirements.txt文件中添加pymysql依赖，然后使用pip install -r requirements.txt命令安装。
+
+pymsql的使用非常简单，下面是一个简单的例子。
+
+import pymysql
+# 链接数据库
+conn = pymysql.connect(host= "database address",user ="user name",password="password",database="database name",charset="utf8")
+# 获取执行sql语句的光标对象
+cursor = conn.cursor() # 结果为元组
+# 获取执行SQL语句，结果作为字典返回
+cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)
+# define the execute sql
+sql = "select username,password from tb_user"
+# execute sql
+cursor.exectute(sql)
+# fetchone()获取单条数据
+result = cursor.fetchone()
+# fetchall()获取所有数据
+results = cursor.fetchall()
+# 关闭光标对象
+cursor.close()
+# 关闭数据库连接
+conn.close()
+
+
+工具类封装及使用
+
+在utils目录下新建一个MysqlUtil.py文件，用于封装数据库操作的方法。
+
+from utils.LogUtil import my_log
+import pymysql
+#1、创建封装类
+class Mysql:
+#2、初始化数据，连接数据库，光标对象
+ def __init__(self,host,user,password,database,charset="utf8",port=3306):
+ self.log = my_log()
+ self.conn = pymysql.connect(
+ host=host,
+ user=user,
+ password=password,
+ database=database,
+ charset=charset,
+ port=port
+ )
+ self.cursor = self.conn.cursor(cursor=pymysql.cursors.DictCursor)
+#3、创建查询、执行方法
+ def fetchone(self,sql):
+ """
+ 单个查询
+ :param sql:
+ :return:
+ """
+ self.cursor.execute(sql)
+ return self.cursor.fetchone()
+
+ def fetchall(self,sql):
+ """
+ 多个查询
+ :param sql:
+ :return:
+ """
+ self.cursor.execute(sql)
+ return self.cursor.fetchall()
+
+ def exec(self,sql):
+ """
+ 执行
+ :return:
+ """
+ try:
+ if self.conn and self.cursor:
+ self.cursor.execute(sql)
+ self.conn.commit()
+ except Exception as ex:
+ self.conn.rollback()
+ self.log.error("Mysql 执行失败")
+ self.log.error(ex)
+ return False
+ return True
+
+#4、关闭对象
+ def __del__(self):
+ #关闭光标对象
+ if self.cursor is not None:
+ self.cursor.close()
+ #关闭连接对象
+ if self.conn is not None:
+ self.cursor.close()
+
+if __name__ == "__main__":
+ mysql = Mysql("211.103.136.242",
+ "test",
+ "test123456","meiduo",
+ charset="utf8",
+ port=7090)
+ #res = mysql.fetchall("select username,password from tb_users")
+ # 执行，修改数据库里面的数据
+ res = mysql.exec("update tb_users set first_name='python' where username = 'python'")
+ print(res)
+
+
+
+数据库断言之配置文件
+
+我们上一步把数据库操作封装成了一个工具类，但是在使用的时候，我们需要把数据库的连接信息写死在代码里面，这样的话，如果我们的数据库信息发生了变化，我们就需要修改代码，这样的话，我们的代码就不够灵活，所以我们需要把数据库的连接信息放到配置文件config里面，然后在代码里面读取配置文件，这样的话，我们的代码就可以灵活的修改数据库的连接信息了。
+
+我们之前在config文件夹下面已经有了一个config.yaml文件；但是还是建议大家把数据库的连接信息放到一个单独的文件db_conf.yml里面，这样的话，我们的配置文件就更加清晰了。
+
+步骤如下：
+
+ - 在config文件夹下面新建一个db_conf.yml文件；
+ - 在db_conf.yml文件里面写入数据库的连接信息；
+
+
+#编写相关基本信息
+db_1:
+ db_host: "211.103.136.242"
+ db_user: "test"
+ db_password: "test123456"
+ db_name: "meiduo"
+ db_charset: "utf8"
+ db_port: "7090"
+
+db_2:
+ db_host: "111211.103.136.242"
+ db_user: "test"
+ db_password: "test123456"
+ db_name: "meiduo"
+ db_charset: "utf8"
+ db_port: "7090"
+
+db_3:
+ db_host: "333211.103.136.242"
+ db_user: "test"
+ db_password: "test123456"
+ db_name: "meiduo"
+ db_charset: "utf8"
+ db_port: "7090"
+
+
+ - 重构config.py,需要添加如下代码：
+
+
+#定义db_conf.yml路径
+_db_config_file = _config_path + os.sep +"db_conf.yml"
+
+def get_db_config_file():
+ return _db_config_file
+
+class ConfigYaml:
+ def get_db_conf_info(self,db_alias):
+ """
+ 根据db_alias获取该名称下的数据库信息
+ :param db_alias:
+ :return:
+ """
+ return self.db_config[db_alias]
+if __name__ == "__main__":
+ conf_read = ConfigYaml()
+ print(conf_read.get_db_conf_info("db_1"))
+ print(conf_read.get_db_conf_info("db_2"))
+ print(conf_read.get_db_conf_info("db_3"))
+
+
+数据库断言之结果验证
+
+ -
+
执行,结果验证
+
+ 1、初始化数据库信息，在common文件夹下面创建Base.py，用来init_db
+ from config.Conf import ConfigYaml
+from utils.MysqlUtil import Mysql
+
+#1、定义init_db
+def init_db(db_alias):
+
+ #2、初始数据化信息，通过配置
+ db_info = ConfigYaml().get_db_conf_info(db_alias)
+ host = db_info["db_host"]
+ user = db_info["db_user"]
+ password = db_info["db_password"]
+ db_name = db_info["db_name"]
+ charset = db_info["db_charset"]
+ port = int(db_info["db_port"])
+
+ #3、初始化mysql对象
+ conn = Mysql(host,user,password,db_name,charset,port)
+ print(conn)
+ return conn
+
+if __name__ =="__main__":
+ init_db("db_1")
+
+
+
+ 2、接口用例返回结果内容进数据库验证，在test_mall.py文件中添加如下代码：
+
+ #1、导入init_db
+from common.Base import init_db
+
+#1、初始化数据库对象
+conn = init_db("db_1")
+#2、查询结果
+res_db = conn.fetchone("select id,username from tb_users where username='python'")
+print("数据库查询结果",res_db)
+#3、验证
+user_id = body["user_id"]
+assert user_id == res_db["id"]
+
+
+
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/13/f60aa3105c212dec4af9c30c019d988916af3cf5d65c08b9d5a35166107fa1 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/13/f60aa3105c212dec4af9c30c019d988916af3cf5d65c08b9d5a35166107fa1
new file mode 100644
index 0000000000..ca2f6048a8
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/13/f60aa3105c212dec4af9c30c019d988916af3cf5d65c08b9d5a35166107fa1
@@ -0,0 +1,2 @@
+I"-控制电路
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/15/9b13cba987783b711756c68e22518b77c3cc133305142156d734260daccbae b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/15/9b13cba987783b711756c68e22518b77c3cc133305142156d734260daccbae
new file mode 100644
index 0000000000..f0090d196c
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/15/9b13cba987783b711756c68e22518b77c3cc133305142156d734260daccbae
@@ -0,0 +1,198 @@
+I"!%断言
+
+断言是为了告诉开发人员程序中发生了不可恢复的错误。对于可以预料的错误（如未找到相关文件），用户可以予以纠正或重试，断言并不是为此而生的。
+
+断言用于程序内部自检，如声明一些代码中不可能出现的条件。如果触发了某个条件，即意味着程序中存在相应的 bug。
+
+断言语法
+
+assert_stmt ::="assert" expression1 ["," expression2]
+
+
+其中，expression1 是需要测试的条件，可选的 expression2 是错误消息，如果断言失败则显示该消息。
+
+”,”表示逗号，expression1 和 expression2 之间用逗号分隔。
+
+在执行时，Python 解释器将每条断言语句大致转换为以下这些语句：
+
+if __debug__:
+ if not expression1:
+ raise AssertionError(expression2)
+
+
+代码在检查断言条件之前，还会检查__debug__全局变量。这是一个内置的布尔标记，在一般情况下为真，若进行代码优化则为假。还可以使用 expression2 传递一个可选的错误消息，该消息将与回溯中的AssertionError 一起显示，用来进一步简化调试。
+
+断言注意事项
+
+不要使用断言验证数据
+
+在 Python 中使用断言时要注意的一个重点是，若在命令行中使用-O 和-OO 标识，或修改CPython中的 PYTHONOPTIMIZE 环境变量，都会全局禁用断言。
+
+不要使用断言验证数据，因为当全局禁用断言时，验证失效，可能存在严重的安全漏洞。
+
+永不失败的断言
+
+在将一个元组作为 assert 语句中的第一个参数传递时，断言条件总为真，因此永远不会失败。
+
+assert(1 == 2, 'This should fail')
+
+
+这是因为在 Python 中非空元组总为真值。如果将元组传递给 assert 语句，则会导致断言条件始终为真，因此上述 assert 语句毫无用处，永远不会触发异常。
+
+这也是为什么应该总是对单元测试用例先做一个快速的冒烟测试。要确保在编
+写下一个测试之前，当前测试用例的确会失败。
+
+断言总结
+
+
+ - Python 断言语句是一种测试某个条件的调试辅助功能，可作为程序的内部自检
+ - 断言应该只用于帮助开发人员识别 bug，它不是用于处理运行时错误的机制。
+
+
+巧妙放置逗号
+
+如果需要在 Python 中的列表、字典或集合常量中添加或移除项，记住一个窍门：在所有行后面都添加一个逗号。
+
+如，假设代码中有如下名字组成的列表：
+
+names = ['Alice', 'Bob', 'Cindy', 'Doug']
+
+
+在修改这个名字列表时，通过 git diff 查看改动可能有点不方便。大多数源码控制系统都是基于行的，因此无法标出同一行中的多个改动。
+
+一个快速改进是根据编码规范，将列表、字典或集合常量分割成多行，如下所示：
+
+names = [
+ 'Alice',
+ 'Bob',
+ 'Cindy'
+ 'Doug'
+]
+
+
+在列表末尾添加或移除内容时Jane，需要在’Doug’后面添加逗号，再添加或移除新的名字。否则，Python就会将字符串 Doug 和 Jane 合并成了 DougJane。这称为字符串字面值拼接，是文档中有记录的刻意行为，这种行为可能会在程序中引入令人难以琢磨的 bug。
+
+在某些情况下，字符串字面值拼接是一个有用的特性。例如，在跨越多行的长字符串中可以省去反斜杠：
+
+my_str = (
+ 'This is a very long string that I want to split '
+ 'across multiple lines.'
+)
+
+
+但另一方面，这个特性有时又会成为负担。那么如何解决这个问题呢?
+
+在 Python 中，可以在列表、字典和集合常量中的每一项后面都放置一个逗号，包括最后一
+项。因此只要记住在每一行末尾都加上一个逗号，就可以避免逗号放置问题。
+
+上下文管理器和 with 语句
+
+with 语句究竟有哪些好处？它有助于简化一些通用资源管理模式，抽象出其中的功能，将
+其分解并重用。
+
+如使用 with 语句打开文件，不需要再手动关闭文件，因为 with 语句会在代码块执行完毕后自动关闭文件。
+
+with open('hello.txt','w') as f:
+ f.write('hello world")
+
+
+上面的代码如果不适用 with 语句，就需要手动关闭文件，如下所示：
+
+f = open('hello.txt','w')
+try:
+ f.write('hello world')
+finally:
+ f.close()
+
+
+如果只执行上述代码中的核心逻辑，那么这段代码就很简单。但是，如果在调用 f.write()时发生异常，这段代码不能保证文件最后被关闭，因此程序可能会泄露文件描述符。此时 with 语句就派上用场了，它能够简化资源的获取和释放。
+
+f = open('hello.txt','w')
+f.write('hello world')
+f.close()
+
+
+threading.Lock 类是 Python 标准库中另一个比较好的示例，它有效地使用了 with 语句。Lock 类的实例可以用作上下文管理器，因此可以使用 with 语句来获取和释放锁。
+
+lock = threading.Lock()
+# have problems
+lock.acquire()
+try:
+ print('Critical section 1')
+ print('Critical section 2')
+finally:
+ lock.release()
+
+
+
+改写代码后，使用 with 语句都可以抽象出大部分资源处理逻辑。不再需要手动调用 lock.release()，因为 with 语句会在代码块执行完毕后自动释放锁。with 语句不仅让处理系统资源的代码更易读，而且由于绝对不会忘记清理或释放资源，因此还可以避免 bug 或资源泄漏。
+
+lock = threading.Lock()
+# have problems
+lock.acquire()
+
+# use with
+with lock:
+ print('Critical section 1')
+
+
+在自定义对象中支持 with
+
+只要实现所谓的上下文管理器（context manager），就可以在自定义的类和函数中获得相同的功能。
+
+上下文管理器是什么？这是一个简单的“协议”（或接口），自定义对象需要遵循这个接口来支持 with 语句。总的来说，如果想将一个对象作为上下文管理器，需要做的就是向其中添加__enter__和__exit__方法。Python 将在资源管理周期的适当时间调用这两种方法。
+
+下面是open()上下文管理器的实现，它是一个内置的函数，用于打开文件并返回一个文件对象。
+
+
+class OpenFile(object):
+ def __init__(self, file, mode='r'):
+ self.file = file
+ self.mode = mode
+
+ def __enter__(self):
+ self.f = open(self.file, self.mode)
+ return self.f
+ # __exit__方法的参数是异常类型、异常值和追溯信息，type、value和traceback
+ def __exit__(self, type, value, traceback):
+ self.f.close()
+
+
+这里的OpenFile类遵循上下文管理器协议，也支持 with 语句。因此，可以使用 with 语句来打开文件，而不需要手动关闭文件。
+
+with OpenFile('hello.txt','w') as f:
+ f.write('hello world')
+
+
+当执行流程进入 with 语句上下文时，Python 会调用__enter__获取资源；离开 with 上下文时，Python 会调用__exit__释放资源。
+
+使用contextlib.contextmanager装饰器，可以简化上下文管理器的实现。contextmanager装饰器会将生成器函数包装成上下文管理器。这样，就可以使用 with 语句来管理资源，而不需要实现__enter__和__exit__方法。
+
+from contextlib import contextmanager
+
+@contextmanager
+def OpenFile(file,mode):
+ try:
+ f = open(file,mode)
+ yield f # yield 语句会在上下文管理器中暂停执行，直到离开上下文管理器
+ finally:
+ f.close()
+
+with OpenFile('hello.txt','w') as f:
+ f.write('hello world')
+
+
+这个 managed_file()是生成器，开始先获取资源，之后暂停执行并产生资源以供调用者使用。当调用者离开 with 上下文时，生成器继续执行剩余的清理步骤，并将资源释放回系统。
+
+总结：
+
+
+ - with语句通过在所谓的上下文管理器中封装 try…finally 语句的标准用法来简化异常处理；
+ - with 语句一般用来管理系统资源的安全获取和释放。资源首先由 with 语句获取，并在执行离开 with 上下文时自动释放；
+ - 有效地使用 with 有助于避免资源泄漏的问题，让代码更加易于阅读。
+
+
+来源
+
+《深入理解Python特性》P04 - P15
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/17/964e1117c07f138fb9c314ddb146a2ead39c2ae927fbab59bdae810c7b7458 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/17/964e1117c07f138fb9c314ddb146a2ead39c2ae927fbab59bdae810c7b7458
new file mode 100644
index 0000000000..dfc782f1b4
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/17/964e1117c07f138fb9c314ddb146a2ead39c2ae927fbab59bdae810c7b7458
@@ -0,0 +1,364 @@
+I" 标题表示方法
+
+最多可以使用六级标题
+
+# 一级标题
+## 二级标题
+### 三级标题
+
+
+在 vs code中使用md文件
+
+
+ - 如何在 vs code中使用md文件以及查看： 先点击左上角，选择分栏；然后在右边的分栏中，按下快捷键“control+shift+v”预览md文件
+ - 或者下载”markdown all in one”插件，方便浏览
+
+
+表格 | table
+
+
+
+
+ | 列1 |
+ 列2 |
+ 列3 |
+
+
+
+
+ | 行1 |
+ 行1 |
+ 行1 |
+
+
+ | 行2 |
+ 行2 |
+ 行2 |
+
+
+ | 行3 |
+ 行3 |
+ 行3 |
+
+
+
+
+#### 表格 | table
+
+|列1|列2|列3|
+|-|-|-|
+|行1|行1|行1|
+|行2|行2|行2|
+|行3|行3|行3|
+
+
+冒号在右边表示右对齐
+
+
+
+
+ | 列1 |
+ 列2 |
+ 列3 |
+
+
+
+
+ | 行1 |
+ 行1 |
+ 行1 |
+
+
+ | 行2 |
+ 行2 |
+ 行2 |
+
+
+ | 行3 |
+ 行3 |
+ 行3 |
+
+
+
+
+冒号在右边表示右对齐
+
+|列1|列2|列3|
+|-:|-:|-:|
+|行1|行1|行1|
+|行2|行2|行2|
+|行3|行3|行3|
+
+
+冒号在左边表示左对齐
+
+
+
+
+ | 列1 |
+ 列2 |
+ 列3 |
+
+
+
+
+ | 行1 |
+ 行1 |
+ 行1 |
+
+
+ | 行2 |
+ 行2 |
+ 行2 |
+
+
+ | 行3 |
+ 行3 |
+ 行3 |
+
+
+
+
+冒号在左边表示左对齐
+
+|列1|列2|列3|
+|:-|:-|:-|
+|行1|行1|行1|
+|行2|行2|行2|
+|行3|行3|行3|
+
+
+两边都有冒号表示中间对齐
+
+
+
+
+ | 列1 |
+ 列2 |
+ 列3 |
+
+
+
+
+ | 行1 |
+ 行1 |
+ 行1 |
+
+
+ | 行2 |
+ 行2 |
+ 行2 |
+
+
+ | 行3 |
+ 行3 |
+ 行3 |
+
+
+
+
+两边都有冒号表示中间对齐
+
+|列1|列2|列3|
+|:-:|:-:|:-:|
+|行1|行1|行1|
+|行2|行2|行2|
+|行3|行3|行3|
+
+
+列表
+
+无序列表
+
+
+
+无序列表
+
+* 无序列表
+ * 无序列表2
+ * 无序列表3
+
+
+有序列表
+
+
+ - 有序列表
+
+ - 有序列表1
+
+
+ - 有序列表
+
+ - 有序列表2
+ - 有序列表2
+
+
+
+
+有序列表
+
+1. 有序列表
+ 1. 有序列表1
+2. 有序列表
+ 1. 有序列表2
+ 2. 有序列表2
+
+
+任务列表：
+
+我明天要做的事情
+
+
+任务列表：
+
+我明天要做的事情
+- [ ] 吃饭
+- [x] 睡觉
+
+
+注解和脚注
+
+注解
+
+ 这里的内容表示注解
+
+
+注解
+> 这里的内容表示注解
+
+
+脚注：
+这是一个链接到谷歌的[^脚注]。
+
+脚注：
+这是一个链接到谷歌的[^脚注]。
+
+[^脚注]: http://www.google.com
+
+
+图片和超链接
+
+超链接：
+
+ - 内联的方式： 中括号+小括号
+
+
+ - 引用的方式：这样就可以使用[文本]+[id]的方式进行引用
+
+
+ - 还可以链接到标题
+
+
+
+
+超链接：
+1. 内联的方式： 中括号+小括号
+ * This is an [example link](http://www.google.com).
+2. 引用的方式：这样就可以使用[文本]+[id]的方式进行引用
+ * I get 10 times more traffic from [Google][1] than from [Yahoo][2] or [MSN][3].
+3. 还可以链接到标题
+ * 请参考[标题1](#一级标题)
+
+[1]: http://google.com/ "Google"
+[2]: http://search.yahoo.com/ "Yahoo Search"
+[3]: http://search.msn.com/ "MSN Search"
+
+
+图片格式：比起超链接多了一个感叹号，
+
+ - 小括号内可以使用URL地址或者本地文件的相对路径
+ - 可以空一格之后添加”“表示图片的属性，鼠标放上来就可以使用了
+ - 和超链接的区别在于多了一个感叹号
+
+
+
+图片格式：比起超链接多了一个感叹号，
+* 小括号内可以使用URL地址或者本地文件的相对路径
+* 可以空一格之后添加""表示图片的属性，鼠标放上来就可以使用了
+* 和超链接的区别在于多了一个感叹号
+{:height="40%" width="40%"}
+
+
+嵌入视频
+
+<iframe
+src="https://www.bilibili.com/video/BV1D64y1Z7Ko?share_source=copy_web&vd_source=a59f9331c2b80795dda1842d7be401ec"
+scrolling="no"
+border="0"
+frameborder="no"
+framespacing="0"
+allowfullscreen="false"
+height=600
+width=800>
+</iframe>
+
+
+文字格式
+
+这里是斜体
+
+这里是*斜体*
+
+
+这里是粗体
+这里是**粗体**
+
+
+这里是变量名内容
+这里是`变量名`内容
+
+
+下划线：
+
+要使用HTML中的u标签
+
+下划线
+
+下划线：
+
+要使用HTML中的u标签
+
+<u>下划线</u>
+
+
+==文字高亮==
+
+==文字高亮==
+
+
+代码块
+int main(){
+ return 0;
+}
+
+
+
+删除线：
+
+不太行哦
+
+删除线：
+
+~~不太行哦~~
+
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/17/c8872dff87747c23df0234bf46a0a8cc4074b6d483a3f0368a568b376c4e95 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/17/c8872dff87747c23df0234bf46a0a8cc4074b6d483a3f0368a568b376c4e95
new file mode 100644
index 0000000000..32f0bce546
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/17/c8872dff87747c23df0234bf46a0a8cc4074b6d483a3f0368a568b376c4e95
@@ -0,0 +1,2 @@
+I"6D-Tale是什么？
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/18/a586c2bdc8fc8eacd161152e64bf3ebd39c3a0dcc8290a66c7b56d532b04a5 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/18/a586c2bdc8fc8eacd161152e64bf3ebd39c3a0dcc8290a66c7b56d532b04a5
new file mode 100644
index 0000000000..df7e332d50
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/18/a586c2bdc8fc8eacd161152e64bf3ebd39c3a0dcc8290a66c7b56d532b04a5
@@ -0,0 +1,2 @@
+I"3高效的函数
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/19/6f4b2efdae37069ab0160796712dc995ef2b9bbff94cd172e5a5319c955545 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/19/6f4b2efdae37069ab0160796712dc995ef2b9bbff94cd172e5a5319c955545
new file mode 100644
index 0000000000..de7b8f69a7
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/19/6f4b2efdae37069ab0160796712dc995ef2b9bbff94cd172e5a5319c955545
@@ -0,0 +1,24 @@
+I"D-Tale是什么？
+
+Pandas数据框以带有行和列的表格格式表示。它与表格中数据的excel显示非常相似。excel有很多可以操作的界面，比如说数据排序，数据筛选，数据聚合，生成各种图片以及数据透视表等等。Pandas dataframe 和 excel 的显着区别在于，在 Pandas 中，您不能直接对数据集进行修改。您既不能通过任何 GUI 对数据进行排序，也不能通过选择一些参数来创建快速可视化。
+
+Pandas可以定制化地进行数据探索，但是要记住一些基本的语句，比如说怎么导入导出到csv,怎么进行索引等等，这不太友好；还有的时候，你希望进行一些漫无目的的探索，但是又懒得去看帮助文档或者感觉得到的信息针对性不强。你可能会希望有个GUI可视化界面，操作就和Excel一样简单，并且可以把操作过程记录下来，获得数据探索、数据清洗和绘图的代码，下次面对另外的数据也可以重复该过程。
+
+这就是D-Tale！！！D-Tale是一个强大的库，它它与jupyter notebooks和python/ipython终端无缝集成，支持诸如DataFrame，Series，MultiIndex，DateTimeIndex和RangeIndex之类的Pandas对象，可以用很轻量的代码量完成日常所需要的数据分析和可视化工作。
+
+插个楼：Pandas是啥？
+
+Pandas是啥
+
+Pandas 是一个开放源码、BSD 许可的库，提供高性能、易于使用的数据结构和数据分析工具。
+
+Pandas 名字衍生自术语 “panel data”（面板数据）和 “Python data analysis”（Python 数据分析）。
+
+Pandas 一个强大的分析结构化数据的工具集，基础是 Numpy（提供高性能的矩阵运算）。
+
+Pandas 可以从各种文件格式比如 CSV、JSON、SQL、Microsoft Excel 导入数据。
+
+Pandas 可以对各种数据进行运算操作，比如归并、再成形、选择，还有数据清洗和数据加工特征。
+
+Pandas 广泛应用在学术、金融、统计学等各个数据分析领域。
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/1b/94e6e598921e3d1a2c349b244678194fa225e3b4b36d070131b7f7ec2f7da7 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/1b/94e6e598921e3d1a2c349b244678194fa225e3b4b36d070131b7f7ec2f7da7
new file mode 100644
index 0000000000..070faae1dc
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/1b/94e6e598921e3d1a2c349b244678194fa225e3b4b36d070131b7f7ec2f7da7
@@ -0,0 +1,18 @@
+I"B
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/1f/b37e746e066360c85160b0354c48ce6b6e85d874cf6e2fe08633ecf44a4bba b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/1f/b37e746e066360c85160b0354c48ce6b6e85d874cf6e2fe08633ecf44a4bba
new file mode 100644
index 0000000000..dc9b60fac4
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/1f/b37e746e066360c85160b0354c48ce6b6e85d874cf6e2fe08633ecf44a4bba
@@ -0,0 +1,92 @@
+I"
这一讲主要是介绍了set(集合)数据结构，三元运算符等等内容。
+
+set(集合)数据结构
+
+set(集合)是一个非常有用的数据结构。它与列表(list)的行为类似，区别在于set不能包含重复的值。
+这在很多情况下非常有用。例如你可能想检查列表中是否包含重复的元素，你有两个选择，第一个需要使用for循环，就像这样：
+
+some_list = ['a', 'b', 'c', 'b', 'd', 'm', 'n', 'n']
+
+duplicates = []
+for value in some_list:
+ if some_list.count(value) > 1:
+ if value not in duplicates:
+ duplicates.append(value)
+
+print(duplicates)
+
+
+输出结果为：
+
+['b', 'n']
+
+
+但还有一种更简单更优雅的解决方案，那就是使用集合(sets)，你直接这样做：
+some_list = ['a', 'b', 'c', 'b', 'd', 'm', 'n', 'n']
+duplicates = set([x for x in some_list if some_list.count(x) > 1])
+print(duplicates)
+
+
+交集
+你可以对比两个集合的交集（两个集合中都有的数据），如下：
+valid = set(['yellow', 'red', 'blue', 'green', 'black'])
+input_set = set(['red', 'brown'])
+print(input_set.intersection(valid))
+
+输出结果为：{‘red’}
+
+差集
+
+你可以用差集(difference)找出无效的数据，相当于用一个集合减去另一个集合的数据，例如：
+
+valid = set(['yellow', 'red', 'blue', 'green', 'black'])
+input_set = set(['red', 'brown'])
+print(input_set.difference(valid))
+
+输出结果为：{'brown'}
+
+### 并集
+你可以用并集（union）来合并两个集合，如下：
+
+```python
+valid = set(['yellow', 'red', 'blue', 'green', 'black'])
+input_set = set(['red', 'brown'])
+print(input_set.union(valid))
+
+输出结果为：{‘brown’, ‘red’, ‘green’, ‘black’, ‘blue’, ‘yellow’}
+
+三元运算符
+
+三元运算符通常在Python里被称为条件表达式，这些表达式基于真(true)/假(not)的条件判断，在Python 2.4以上才有了三元操作。
+
+它允许用简单的一行快速判断，而不是使用复杂的多行if语句。 这在大多数时候非常有用，而且可以使代码简单可维护。
+
+伪代码如下：
+
+condition_is_true if condition else condition_is_false
+
+举例子：
+is_fat = True
+state = "fat" if is_fat else "not fat"
+print(state)
+
+
+输出结果为：fat
+
+另一个晦涩一点的用法比较少见，它使用了元组，请继续看：
+
+伪代码:
+#(返回假，返回真)[真或假]
+(if_test_is_false, if_test_is_true)[test]
+
+fat = True
+fitness = ("skinny", "fat")[fat]
+print("Ali is ", fitness)
+
+输出结果为：Ali is fat
+
+上面的例子没有被广泛使用，而且Python玩家一般不喜欢那样，因为没有Python味儿(Pythonic)。这样的用法很容易把真正的数据与true/false弄混。
+
+另外一个不使用元组条件表达式的缘故是因为在元组中会把两个条件都执行，而 if-else 的条件表达式不会这样。
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/22/ac9970185e7c70150e59c80d98a6f72516ef7dbd2057c97deaa9eb2bd743c1 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/22/ac9970185e7c70150e59c80d98a6f72516ef7dbd2057c97deaa9eb2bd743c1
new file mode 100644
index 0000000000..a426ba9af0
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/22/ac9970185e7c70150e59c80d98a6f72516ef7dbd2057c97deaa9eb2bd743c1
@@ -0,0 +1,47 @@
+I"安装Cockpit
+
+sudo apt install cockpit -y
+
+
+-y参数表示自动安装，不需要手动输入y。
+
+或者使用如下命令进行安装，/etc/os-release表示系统版本信息，${VERSION_CODENAME}表示系统版本代号，如Ubuntu 18.04的版本代号为bionic。
+
+. /etc/os-release
+sudo apt install -t ${VERSION_CODENAME}-backports cockpit
+
+
+启动Cockpit
+
+sudo systemctl start cockpit
+#sudo systemctl enable cockpit
+
+
+
+查看状态
+
+apt -qq list cockpit # 查看版本
+sudo systemctl status cockpit
+
+
+设置防火墙
+
+ss -tunlp | grep 9090
+
+
+ss 表示查看socket状态，-t表示TCP协议，-u表示UDP协议，-n表示不解析IP地址，-l表示监听状态，-p表示显示进程信息。grep 9090表示过滤出端口为9090的进程。如果没有显示9090端口，则表示9090端口没有被占用，可以直接使用。如果显示了9090端口，则需要修改端口号。
+
+sudo ufw allow 9090/tcp
+
+
+/tcp表示TCP协议，/udp表示UDP协议。
+
+访问Cockpit
+
+使用ifconfig命令查看服务器IP地址，然后在浏览器中输入服务器IP地址加端口9090，如http://IP_OF_SERVER:9090。
+
+一旦你登录后，你可以看到 Cockpit 的主界面，在这里可以直观的看到服务器的运行状态，包括CPU使用率、内存使用率、硬盘使用率等。
+
+在cockpit中我们可以很方便的管理各系统服务，包括磁盘管理，网络管理，系统服务（包括定时任务管理），浏览和搜索系统日志，升级软件包到最新版本等等。
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/23/4a0b22f5b23be85456d0cb3e9b3c647e50fa8821d78da21a9af626da5ce5a3 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/23/4a0b22f5b23be85456d0cb3e9b3c647e50fa8821d78da21a9af626da5ce5a3
new file mode 100644
index 0000000000..98ec701f46
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/23/4a0b22f5b23be85456d0cb3e9b3c647e50fa8821d78da21a9af626da5ce5a3
@@ -0,0 +1,2 @@
+I"_Markdowm插件Office Viewer介绍以及vscode+PicGO+Github搭建个人博客图床
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/25/2c611e1d1a45db5ef218a25c298e340f1a20ed9f7d061176e4c212a1cb4fd8 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/25/2c611e1d1a45db5ef218a25c298e340f1a20ed9f7d061176e4c212a1cb4fd8
new file mode 100644
index 0000000000..18bd8f7344
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/25/2c611e1d1a45db5ef218a25c298e340f1a20ed9f7d061176e4c212a1cb4fd8
@@ -0,0 +1,2 @@
+I" 介绍了接口自动化测试框架框架搭建，第三方插件，配置文件设置和读取，测试流程等内容。测试用例设计部分，则包括Excel测试用例，控制流和数据流，方法的应用场景，测试用例书写标准以及测试集的创建。
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/25/6fe6701d50bca94aaf79e752af7a78c47890763e85b1d06e17cd628f080af6 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/25/6fe6701d50bca94aaf79e752af7a78c47890763e85b1d06e17cd628f080af6
new file mode 100644
index 0000000000..98d576fdd4
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/25/6fe6701d50bca94aaf79e752af7a78c47890763e85b1d06e17cd628f080af6
@@ -0,0 +1,2 @@
+I"9日志文件备份
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/29/3a89eb91f0bc79e86037ac9f8678065b6835f0c0a60c15b4a5a02ef84aba10 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/29/3a89eb91f0bc79e86037ac9f8678065b6835f0c0a60c15b4a5a02ef84aba10
new file mode 100644
index 0000000000..ae26de4f09
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/29/3a89eb91f0bc79e86037ac9f8678065b6835f0c0a60c15b4a5a02ef84aba10
@@ -0,0 +1,51 @@
+I"
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/2a/4e3cd8a410691557d824241f92fbce86f9802e403e2c7ccd86b1eaaf928123 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/2a/4e3cd8a410691557d824241f92fbce86f9802e403e2c7ccd86b1eaaf928123
new file mode 100644
index 0000000000..e0e3c50f31
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/2a/4e3cd8a410691557d824241f92fbce86f9802e403e2c7ccd86b1eaaf928123
@@ -0,0 +1,89 @@
+I" JMeter安装
+
+安装Java
+
+JMeter是基于Java开发的，所以需要先安装Java环境，包括JDK,JAVA开发工具包和JRE，Java运行环境。JDK是Java开发工具包，包含了Java的开发工具，如：Java编译器、Java文档生成器、Java调试器等。JDK是Java开发的基础，JRE是Java运行的基础，JVM是Java运行的平台。
+
+下载地址：Java 19 and Java 17 available now
+
+
+下载选择Linux x64版本（x64 Compressed Archive），下载完成后，解压到指定目录，如：/usr/local
+
+sudo tar -zxvf jdk-19_linux-x64_bin.tar.gz -C /usr/local # -C 指定解压目录
+
+
+修改环境变量
+
+sudo vim /etc/profile
+
+
+在/etc/profile文件末尾添加以下内容：
+
+JAVA_HOME=/usr/local/jdk-19.0.2 # JDK安装目录
+CLASSPATH=.:$JAVA_HOME/lib.tools.jar # 这个变量设置的目的是为了程序能找到相应的被执行的".class"文件
+PATH=$PATH:$JAVA_HOME/bin # BIN是JDK的可执行文件目录
+export JAVA_HOME CLASSPATH PATH
+
+
+重新加载/etc/profile配置文件
+
+source /etc/profile
+
+
+验证Java安装
+
+java -version #
+
+
+javac -version
+
+
+安装JMeter
+
+Apache JMeter 5.5安装地址,选择Binaries中的apache-jmeter-5.5.tgz下载。
+
+如果觉得速度太慢，可以切换到国内的阿里云镜像下载
+
+解压缩
+
+tar -zxvf apache-jmeter-5.5.tgz
+
+
+配置JMeter环境变量
+
+sudo vim /etc/profile
+
+
+在/etc/profile文件末尾添加以下内容：
+
+export JMETER_HOME=/usr/local/apache-jmeter-5.5 # JMeter安装目录
+export PATH=$JMETER_HOME/bin:$PATH
+
+
+重新加载/etc/profile配置文件
+
+source /etc/profile
+
+
+验证JMeter安装
+
+jmeter -v
+
+
+运行JMeter
+
+jmeter
+
+
+JMeter入门
+
+设置
+
+修改语言为中文，如下图所示，打开options，选择choose Language，选择Chinese(simplified)
+
+
+防止中文乱码，打开jmeter.properties文件，(位于apache-jmeter-5.5/bin目录下)，修改以下内容：
+
+sampleresult.default.encoding=UTF-8
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/2a/6cd039fa285927e4f821854dac2a9de62ab652d31a215013167770b17d2be5 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/2a/6cd039fa285927e4f821854dac2a9de62ab652d31a215013167770b17d2be5
new file mode 100644
index 0000000000..434cf5d0fd
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/2a/6cd039fa285927e4f821854dac2a9de62ab652d31a215013167770b17d2be5
@@ -0,0 +1,10 @@
+I"}
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/2f/26f8a53bee031b5bca22829bbe634b92071dbb0430145658807f1c65689eb5 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/2f/26f8a53bee031b5bca22829bbe634b92071dbb0430145658807f1c65689eb5
new file mode 100644
index 0000000000..6447d78acc
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/2f/26f8a53bee031b5bca22829bbe634b92071dbb0430145658807f1c65689eb5
@@ -0,0 +1,2 @@
+I"-数据介绍
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/30/edda9a59a60dbeb58dbeacd27a4ccb695dc65e7d4ed65bcbe099e19915cbda b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/30/edda9a59a60dbeb58dbeacd27a4ccb695dc65e7d4ed65bcbe099e19915cbda
new file mode 100644
index 0000000000..069881f7ed
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/30/edda9a59a60dbeb58dbeacd27a4ccb695dc65e7d4ed65bcbe099e19915cbda
@@ -0,0 +1,2 @@
+I"O1. 什么是stable diffusion？
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/31/e708d316d6e683973ed3c1992c16427aa1992c8b232d818f4837e6f856f2db b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/31/e708d316d6e683973ed3c1992c16427aa1992c8b232d818f4837e6f856f2db
new file mode 100644
index 0000000000..fc9c819c36
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/31/e708d316d6e683973ed3c1992c16427aa1992c8b232d818f4837e6f856f2db
@@ -0,0 +1,582 @@
+I"o3
+
+utils
+
+AssertUtil.py
+
+
+ -
+
AssertUtil类（断言封装）
+
+
+
+
+
+验证返回状态码
+
+assert int(code) == int(expected_code)
+
+- assert_body方法
+
+
+验证返回结果内容相等
+
+assert body == expected_body
+
+- assert_in_body方法
+
+
+验证返回结果是否包含期望的结果
+
+assert expected_body in body
+
+EmailUtil.py
+
+
+ -
+
SendEmail类
+
+
+ - __init__方法：初始化，当类被实例化之后，会获得smtp地址，用户名，密码，接收邮件者，邮件标题，邮件内容，邮件附件等信息
+ -
+
send_mail方法
+
+
+ - 初始化邮件信息
+ - 判断是否有附件
+ - MIMEText读取文件、设置内容类型、设置附件头
+ - 将内容附加到邮件主体中
+ - 登录邮件服务器
+ - 发送邮件
+
+
+
+
+
+
+ExcelUtil.py
+
+
+ -
+
ExcelReader类
+
+
+ - data方法:读取sheet方式，名称，索引
+
+
+
+
+LogUtil.py
+
+
+
+MysqlUtil.py
+
+大多数情况下，我们接口自动化测试需要对数据库进行验证，比如说，我们在注册接口中，需要验证数据库中是否有新增的数据，这时候我们就需要对数据库进行查询，然后对查询结果进行断言。比如说，我们需要对订单接口进行测试，需要验证数据库中的订单数据是否正确，这时候我们就需要对数据库进行查询，然后对查询结果进行断言。
+
+
+ -
+
Mysql封装类
+
+
+ - __init__方法：链接数据库，光标对象
+ - fetchone方法：单个查询
+ - fetchall方法：多个查询
+ - exec方法：执行数据库，比如说增删查改
+
+
+
+
+RequestsUtil.py
+
+
+
+YamlUtil.py
+
+
+ -
+
YamlReader类
+
+
+ - data方法：单个文件读取
+ - data_all方法：多个文档读取
+
+
+
+
+config
+
+Conf.py
+
+
+ -
+
获取文件/目录路径方法
+
+
+ - report路径
+ - 测试数据data路径
+ - db_conf.yml路径
+ -
+
config目录的路径
+
+
+
+ - Log文件路径
+
+
+ -
+
ConfigYaml类
+
+
+ - get_excel_file：获取测试用例excel名称方法
+ - get_excel_sheet：获取测试用例sheet名称方法
+ - get_conf_url：获取接口地址方法
+ - get_conf_log：获取日志级别方法
+ - get_conf_log_extension：获取文件扩展名方法
+ - get_db_conf_info：根据db_alias获取该名称下的数据库信息方法
+ - get_email_info：获取邮件配置相关信息
+
+
+
+
+conf.yml
+
+
+ -
+
BASE
+
+
+ -
+
log_level
+
+
+ - debug：默认
+ - info
+ - warning
+ - error
+
+
+ - log_extension
+ -
+
test
+
+
+ - url
+ - cae_file
+ - case_sheet
+
+
+
+
+ -
+
email
+
+
+ - smtpserver
+ - username
+ - password
+ - receiver
+
+
+
+
+db_conf.yml
+
+
+ -
+
dh_1
+
+
+ - dh_host
+ - dh_user
+ - dh_password
+ - dh_name
+ - dh_charset
+ - dh_port
+
+
+ -
+
dh_2
+
+
+
+ -
+
dh_3
+
+
+
+
+
+common
+
+Base.py
+
+
+
+ExcelConfig.py
+
+
+ -
+
DataConfig类
+
+
+ - 包括用例ID，模块，接口名称，请求URL，前置条件，请求类型，请求参数类型，请求参数 预期结果，实际结果，备注，是否运行，headers，cookies，status_code，数据库验证等等
+
+
+
+
+ExcelData.py
+
+
+ -
+
Data类
+
+
+ - get_run_data方法：
+获取全部测试用例
+ - get_run_data方法：
+根据是否运行列==y，获取执行测试用例
+ - get_case_pre方法：
+根据前置条件：从全部测试用例取到测试用例
+
+
+
+
+data
+
+testdata.xlsx
+
+
+ -
+
登录
+
+
+
+ -
+
用户中心个人信息
+
+
+
+ -
+
获取商品列表数据
+
+
+ - 请求方式： GET
/categories/(?P<category_id>\d+)/skus?page=xxx&page_size=xxx&ordering=xxx
+ - 请求参数：categroy_id,page,page_size,ordering
+ - 返回参数：id name price default_image_url(默认图片） comments
+
+
+ -
+
添加到购物车
+
+
+ - 请求方式 ： POST /cart/
+ - 请求参数：sku_id(商品sku id) count(数量）selected(是否勾选，默认勾选）
+ - 返回数据：sku_id count selected
+
+
+ -
+
保存订单
+
+
+ - 请求方式 ： POST /orders/
+ - 请求参数：address pay_method
+ - 返回数据：order_id 订单编号
+
+
+
+
+testlogin.yml
+
+
+ - case_name:测试用例名称
+ - “url”: “/authorizations/”
+ -
+
data
+
+
+
+ - expect: 期望结果
+
+
+logs
+
+日志文件名称
+
+日志文件名称= logs目录 + 当前时间+扩展名
+
+日志文件内容
+
+’%(asctime)s %(name)s %(levelname)s %(message)s ‘
+
+report
+
+report.html
+
+result
+
+
+
+run and requirement
+
+pytest.ini
+
+
+ - addopts ：报告生成地址
+ - testpaths = testcase # 测试路径：testcase文件夹
+ - python_files = test_*.py # testcase文件夹下面test开头的py文件
+ - python_classes = Test_* # Test开头的类
+ - python_functions = test_* # test开头的函数
+
+
+requirements.txt
+
+
+ - pip install pipreqs # 安装pipreqs
+ - pipreqs ./ # 生成requirements.txt
+ - pip install -r requirements.txt # 安装项目依赖的包
+
+
+run.py执行测试用例
+
+
+ - report_path
+report_html_path
+pytest.main([“-s”,”–alluredir”,report_path])
+Base.send_mail()
+
+
+testcase
+
+t_log
+
+
+ - log_demo.py:设置配置信息;定义日志名称getlogger;设置日志级别
+ - log_file_demo.py：设置log级别，handler,日志级别,输出格式，将日志等写入文件
+
+
+t_allure
+
+
+ -
+
allure_demo.py
+
+
+ - @allure.feature一级标签
+ - @allure.title测试用例标题
+ - @allure.description执行测试用例结果的描述
+ - @allure.story二级标签
+ - allure.dynamic多个输入结果
+
+
+
+
+t_pytest
+
+
+ - pytest_assert.py断言测试
+ -
+
pytest_class.py
+
+
+ - setup_class在类中所有方法执行前执行
+ - teardown_class在类中所有方法执行后执行
+
+
+ -
+
pytest_demo.py
+
+
+ - 断言的方法
+ - @pytest.mark.flaky(reruns=3,reruns_delay=2) #失败重跑3次，每次间隔2秒
+flaky插件表示失败重跑
+
+
+
+
+t_excel
+
+
+ - excel_demo.py：获取testdata.xlsx行列信息
+
+
+t_yml
+
+
+ -
+
yaml_demo.py
+
+
+ - yaml.safe_load：使用yaml读取文件
+ - yaml.safe_load_all： 读取多个文档
+
+
+
+
+t_subprocess
+
+
+ -
+
subprocess_demo.py
+
+
+
+
+
+test_login.py
+
+
+ - 获取测试用例内容list
+“case_name”: “登录成功用例”
+“case_name”: “登录失败用例”
+ - 参数化执行测试用例
+
+
+test_excel_case.py
+
+
+ -
+
TestExcel类
+
+
+ - run_api方法发送请求API
+ - run_pre方法初始化数据
+ -
+
test_run方法
+
+
+ - 验证前置条件
+ - 找到执行用例
+ - allure创建执行报告
+ - 断言验证
+
+
+
+
+
+
+test_Mall.py
+
+
+ - test_login方法：登录测试
+ - test_info方法：个人信息
+ - goods_list方法：商品列表数据
+ - cart方法：添加购物车
+ - order方法：保存购物车
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/32/049041389b13152cbd760c574c739070b5095098efea4509531255073d54d5 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/32/049041389b13152cbd760c574c739070b5095098efea4509531255073d54d5
new file mode 100644
index 0000000000..0c4842e3d4
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/32/049041389b13152cbd760c574c739070b5095098efea4509531255073d54d5
@@ -0,0 +1,2 @@
+I"-数据来源
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/36/232033e9857c977c92195e0d6c9a80efaf64381291304d9c0e66b0b9d3791a b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/36/232033e9857c977c92195e0d6c9a80efaf64381291304d9c0e66b0b9d3791a
new file mode 100644
index 0000000000..c357b628fc
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/36/232033e9857c977c92195e0d6c9a80efaf64381291304d9c0e66b0b9d3791a
@@ -0,0 +1,157 @@
+I"o 1. 随机生成一个随机的string
+
+
+
+
+
+结果如下：（根据和github里面搜出来的代码块基本上是一样的，挺简洁的）
+
+
+
+调整一下就可以直接使用
+
+import random
+import string
+
+# generate a string of random characters
+def generate_random_string(length):
+ letters = string.ascii_lowercase
+ result_str = ''.join(random.choice(letters) for i in range(length))
+ return result_str
+
+print(generate_random_string(10))
+
+
+运行代码，结果如下：
+
+
+
+2. 对字符串进行切片
+
+首先，我大概想了下以后可能要处理的文件的文件名，可能是这个格式，最开始是设备的安装日期，然后是地点，机组号码，传感器编号，最后是这个装置的布防期间，大概是这样滴。
+
+string1= '2015-01-01-内蒙-机组304-308传感器-测试期间-from-2016-03-04-to-2018-05-07'
+
+接着，我希望codecursor帮我写代码切割字符串：
+
+
+
+得到的建议代码如下：
+
+
+
+print一下结果发现是可以直接用的，已经切割出了符合我们预期的substring:
+
+
+
+string1= '2015-01-01-内蒙-机组304-308传感器-测试期间-from-2016-03-04-to-2018-05-07'
+
+
+year = string1[0:4]
+month = string1[5:7]
+day = string1[8:10]
+region = string1[11:13]
+unit = string1[14:19]
+sensor = string1[20:26]
+start_date = string1[37:47]
+end_date = string1[51:61]
+print(year, month, day, region, unit, sensor,start_date, end_date)
+
+
+但是我试了下，在大部分情况下，他提取的substring都有问题，最好是print出来看看，然后再调整一下。
+
+3. 批量提取字符串中的信息
+
+我们距离目标很近了，有时候我们期待我们可以对多个文件进行操作，那么这时候我们可能需要构造一个提取信息的函数帮助我们完成这个任务。
+
+首先，我们生成一系列和string1格式相同的字符串，看看codecursor能不能帮我们做到这一点：
+
+
+
+
+
+神了，它居然这都可以做到。
+
+然后，我们构造提取信息的函数，在这里就不演示codecursor的操作了，直接上它帮助我们写好的代码：
+
+# 生成新的字符串
+
+string3 = '2022-01-01-北京-机组101-305传感器-测试期间-from-2023-03-04-to-2025-05-07'
+string4 = '2023-02-01-上海-机组102-306传感器-测试期间-from-2024-03-04-to-2026-05-07'
+string5 = '2024-03-01-广州-机组103-307传感器-测试期间-from-2025-03-04-to-2027-05-07'
+string6 = '2025-04-01-深圳-机组104-308传感器-测试期间-from-2026-03-04-to-2028-05-07'
+string7 = '2026-05-01-成都-机组105-309传感器-测试期间-from-2027-03-04-to-2029-05-07'
+string8 = '2027-06-01-重庆-机组106-310传感器-测试期间-from-2028-03-04-to-2030-05-07'
+
+# 构造提取信息的函数
+def extract_info(string):
+ year = string[0:4]
+ month = string[5:7]
+ day = string[8:10]
+ region = string[11:13]
+ unit = string[14:19]
+ sensor = string[20:26]
+ start_date = string[37:47]
+ end_date = string[51:61]
+ return year, month, day, region, unit, sensor, start_date, end_date
+year, month, day, region, unit, sensor, start_date, end_date = extract_info(string3)
+print(year, month, day, region, unit, sensor, start_date, end_date)
+
+
+运行结果如下：
+
+
+
+4.批量保存提取的信息
+
+还是跳过操作步骤，给出codecursor给的代码：
+
+# 将列表转换为表格
+string_list = [string1,string3, string4, string5, string6, string7, string8]
+table = []
+for string in string_list:
+ info = extract_info(string)
+ table.append(info)
+print(table)
+
+# 将表格转换为DataFrame，并保存为csv文件
+import pandas as pd
+df = pd.DataFrame(table, columns=['year', 'month', 'day', 'region', 'unit', 'sensor', 'start_date', 'end_date'])
+df.to_csv('string.csv', index=False)
+
+
+运行代码，结果如下：
+
+
+
+5.其他探索
+
+生成新的字符串那一步我不太满意，这次我希望他可以帮助我自动生成和string1一样格式的字符串，它给出的代码是这样的：
+
+import random
+def generate_random_string():
+ year = str(random.randint(2022, 2027))
+ month = str(random.randint(1, 12)).zfill(2)
+ day = str(random.randint(1, 28)).zfill(2)
+ region = random.choice(['北京', '上海', '广州', '深圳', '成都', '重庆'])
+ unit = '机组' + str(random.randint(101, 106))
+ sensor = str(random.randint(305, 310)) + '传感器'
+ start_year = str(random.randint(int(year)+1, 2029)) # int()方法用于将字符串转换为整数, int(year)+1表示将字符串转换为整数后加1
+ start_month = str(random.randint(1, 12)).zfill(2) # zfill()方法用于将字符串的长度补全为指定的长度，不足的部分用0填充
+ start_day = str(random.randint(1, 28)).zfill(2)
+ end_year = str(random.randint(int(start_year)+1, 2030))
+ end_month = str(random.randint(1, 12)).zfill(2)
+ end_day = str(random.randint(1, 28)).zfill(2)
+ string = year + '-' + month + '-' + day + '-' + region + '-' + unit + '-' + sensor + '-测试期间-from-' + start_year + '-' + start_month + '-' + start_day + '-to-' + end_year + '-' + end_month + '-' + end_day
+ return string
+
+string_list = []
+for i in range(20):
+ string_list.append(generate_random_string())
+print(string_list)
+
+
+运行结果如下：
+
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/37/11d8d510f61dc36eb80ed8da0f9415fa9053eaa4a2a186cffc2e76a1c4e6d6 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/37/11d8d510f61dc36eb80ed8da0f9415fa9053eaa4a2a186cffc2e76a1c4e6d6
new file mode 100644
index 0000000000..513e74f493
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/37/11d8d510f61dc36eb80ed8da0f9415fa9053eaa4a2a186cffc2e76a1c4e6d6
@@ -0,0 +1,62 @@
+I", 字符串是指由零个或多个字符组成的有限序列，是编程语言中最常用的数据类型之一。字符串是由单引号或双引号括起来的任意文本，比如’abc’，”xyz”等等。请注意，’‘或”“本身只是一种表示方式，不是字符串的一部分，因此，字符串’abc’只有a，b，c这3个字符。
+
+字符串的格式化是指在字符串中插入变量，格式化字符串的输出方式有很多种，比如通过%操作符，format方法，字符串字面值插值等。
+
+通过%操作符格式化
+
+'Hell %s' % 'world'
+
+
+%s 表示字符串，%d 表示整数，%f 表示浮点数，%x 表示十六进制整数。
+
+# 多个%操作符
+'we have bought %d apples, %d oranges and %d pears' % (3, 5, 2)
+
+
+'we have %d apples, and the apples come from %s' % (3, 'China')
+
+
+
+
+'Hello {0},welcome to {1}.'.format('Jack','China') # 0表示第一个参数,1表示第二个参数
+
+
+你还可以用别名以任意顺序替换变量。这是一个非常强大的功能，不必修改传递给格式函数的参数就可以重新排列显示顺序。
+
+'Hey {name}, welcome to {country}.'.format(country='China',name='Jack')
+
+
+字符串字面值插值
+
+Python 3.6 增加了另一种格式化字符串的方法，称为格式化字符串字面值（formatted string literal）。采用这种方法，可以在字符串常量内使用嵌入的 Python 表达式。
+
+a = 3
+b = 5
+f'we have bought {a} apples, {b} oranges and now the total fruit number is {a+b}.'
+
+
+本质上，格式化字符串字面值是 Python 解析器的功能：将 f 字符串转换为一系列字符串常量和表达式，然后合并起来构建最终的字符串。
+
+这种方法的优点是，它不仅更简洁，而且还更快。因为它不需要调用任何函数，而是由解析器在编译时处理。
+
+在函数中使用该格式化语法，如下：
+
+def greet(name, question):
+ return f"Hello, {name}! How's it {question}?"
+greeter = greet('Jack', 'going')
+print(greeter)
+
+
+模板字符串
+
+其他字符串格式化技术所用的语法更复杂，因而可能会给程序带来安全漏洞。因此，Python 3.6 引入了一种新的字符串格式化方法，称为模板字符串（template string）。
+
+from string import Template
+t = Template('we have bought $num1 apples, $num2 oranges and now the total fruit number is $total.')
+t.substitute(num1=3,num2=5,total=8)
+
+
+来源
+
+《深入理解Python特性》P022 - P027
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/37/d4f75def712769cc7babb59a4ff3fb576c533d02781cdbdd8fa964a25391fa b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/37/d4f75def712769cc7babb59a4ff3fb576c533d02781cdbdd8fa964a25391fa
new file mode 100644
index 0000000000..04622f4608
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/37/d4f75def712769cc7babb59a4ff3fb576c533d02781cdbdd8fa964a25391fa
@@ -0,0 +1,476 @@
+I"Z|Docker相关的概念
+
+1.1 虚拟机和容器
+
+借助于VMWare等软件，可以在一台计算机上创建多个虚拟机，每个虚拟机都拥有独立的操作系统，可以各自独立的运行程序。这种分身术虽然隔离度高（操作系统级），使用方便（类似物理机），但占用存储资源多（GB级）、启动速度慢（分钟级）的缺点也是显而易见的。
+
+相较于虚拟机，容器（Container）是一种轻量型的虚拟化技术，它虚拟的是最简运行环境（类似于沙盒）而非操作系统，启动速度快（秒级）、占用存储资源少（KB级或MB级），容器间隔离度为进程级。在一台计算机上可以运行上千个容器，这是容器技术对虚拟机的碾压式优势。
+
+1.2 容器、镜像和Docker
+
+Docker是一个开源的应用容器引擎，可以创建容器以及基于容器运行的程序。Docker可以让开发者打包他们的应用和依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的Linux机器上，也可以实现虚拟化。在Docker和容器之间，还隐藏着一个镜像的概念。本质上，Docker镜像是一个特殊的文件系统，它提供容器运行时所需的程序、库、资源、配置等文件。Docker镜像类似于一个py文件，它需要Docker的运行时（类似于Python解释器）运行。镜像被运行时，即创建了一个镜像的实例，一个实例就是一个容器。
+
+镜像
+是一个构建容器的只读模板，是一个包含了应用程序和其运行时依赖环境的只读文件。它包含了容器启动所需的所有信息，包括运行程序和配置数据。每一个镜像由一系列的层 (layers) 组成。Docker 使用 UnionFS 来将这些层联合到单独的镜像中。UnionFS 允许独立文件系统中的文件和文件夹(称之为分支)被透明覆盖，形成一个单独连贯的文件系统。正因为有了这些层的存在，Docker 是如此的轻量。当你改变了一个 Docker 镜像，比如升级到某个程序到新的版本，一个新的层会被创建。因此，不用替换整个原先的镜像或者重新建立(在使用虚拟机的时候你可能会这么做)，只是一个新的层被添加或升级了。现在你不用重新发布整个镜像，只需要升级，层使得分发 Docker 镜像变得简单和快速。
+
+容器
+容器是从镜像创建的运行实例。它可以被启动、开始、停止、删除。每个容器都是相互隔离的、保证安全的平台。Docker 利用容器来运行应用。一个 Docker 容器都是独立和安全的应用平台，Docker 容器是 Docker 的运行部分。可以把容器看做是一个简易版的 Linux 环境（包括root用户权限、进程空间、用户空间和网络空间等）和运行在其中的应用程序。
+
+注： 镜像是只读的，容器在启动的时候创建一层可写层作为最上层。
+
+
+
+运行容器实例有两种方式：
+
+交互型容器： 前台运行，可以通过控制台与容器交互。如果创建该容器的终端被关闭，则容器就变为停止状态。此外，在容器控制台中输入exit或者通过docker stop或docker kill也能终止容器。
+后台型容器： 后台运行，创建启动之后就与终端无关了，需要用 docker stop 或 docker kill 来终止，或者 docker logs 查看运行中的输出。
+仓库
+Docker 仓库用来保存镜像，可以理解为代码控制中的代码仓库。同样的，Docker 仓库也有公有和私有的概念。公有的 Docker 仓库名字是 Docker Hub。Docker Hub 提供了庞大的镜像集合供使用。这些镜像可以是自己创建，或者在别人的镜像基础上创建。Docker 仓库是 Docker 的分发部分。
+
+Docker 仓库的概念与 Git 版本控制工具有些类似，注册服务器可以理解为 GitHub 这样的托管服务。
+
+Docker的安装
+
+2.1 在ubuntu中安装
+
+在linux系统中安装Docker非常简单，官方为我们提供了一键安装脚本。这个方法也适用于Debian或CentOS等发行版。
+
+curl -sSL https://get.daocloud.io/docker | sh
+
+
+安装过程如果出现超时，不要灰心，多试几次，总会成功的。安装完成后，Docker只能被root用户使用，可以使用下面的命令取消权限限制：
+
+sudo gpasswd -a <你的用户名> docker
+
+
+然后，重启docker服务：
+
+sudo service docker restart
+
+
+最后，关闭当前的命令行，重新打开新的命令行就可以了。
+
+Docker镜像的使用
+
+docker官方的镜像库比较慢，在进行镜像操作之前，需要将镜像源设置为国内的站点。
+
+新建文件/etc/docker/daemon.json，输入如下内容：
+
+{
+ "registry-mirrors" : [
+ "https://registry.docker-cn.com",
+ "https://docker.mirrors.ustc.edu.cn",
+ "http://hub-mirror.c.163.com",
+ "https://cr.console.aliyun.com/"
+ ]
+}
+
+
+然后重启docker的服务：
+
+systemctl restart docker
+
+
+3.1 列出本地所有镜像
+
+执行命令 docker images 可以查看
+
+$ docker images
+REPOSITORY TAG IMAGE ID CREATED SIZE
+ubuntu 20.04 f643c72bc252 5 weeks ago 72.9MB
+hello-world latest bf756fb1ae65 12 months ago 13.3kB
+
+
+当前我本地只有刚才安装的两个镜像。
+
+3.2 从镜像库中查找镜像
+
+执行命令 docker search 镜像名称可以从docker镜像库中查找镜像。
+
+$ docker search python
+NAME DESCRIPTION STARS OFFICIAL AUTOMATED
+python Python is an interpreted, interactive, objec… 5757 [OK]
+django Django is a free web application framework, … 1039 [OK]
+pypy PyPy is a fast, compliant alternative implem… 260 [OK]
+joyzoursky/python-chromedriver Python with Chromedriver, for running automa… 57 [OK]
+nikolaik/python-nodejs Python with Node.js 57 [OK]
+arm32v7/python Python is an interpreted, interactive, objec… 53
+circleci/python Python is an interpreted, interactive, objec… 42
+centos/python-35-centos7 Platform for building and running Python 3.5… 38
+centos/python-36-centos7 Platform for building and running Python 3.6… 30
+hylang Hy is a Lisp dialect that translates express… 29 [OK]
+arm64v8/python Python is an interpreted, interactive, objec… 24
+revolutionsystems/python Optimized Python Images 18
+centos/python-27-centos7 Platform for building and running Python 2.7… 17
+bitnami/python Bitnami Python Docker Image 10 [OK]
+publicisworldwide/python-conda Basic Python environments with Conda. 6 [OK]
+d3fk/python_in_bottle Simple python:alpine completed by Bottle+Req… 5 [OK]
+dockershelf/python Repository for docker images of Python. Test… 5 [OK]
+clearlinux/python Python programming interpreted language with… 4
+i386/python Python is an interpreted, interactive, objec… 3
+ppc64le/python Python is an interpreted, interactive, objec… 2
+centos/python-34-centos7 Platform for building and running Python 3.4… 2
+amd64/python Python is an interpreted, interactive, objec… 1
+ccitest/python CircleCI test images for Python 0 [OK]
+s390x/python Python is an interpreted, interactive, objec… 0
+saagie/python Repo for python jobs 0
+
+
+最好选择官方（OFFICIAL）的镜像，这样的镜像最稳定一些。
+
+3.3 下载新的镜像
+
+执行命令docker pull 镜像名称:版本号即可下载新的镜像。
+
+$ docker pull python:3.8
+3.8: Pulling from library/python
+6c33745f49b4: Pull complete
+ef072fc32a84: Pull complete
+c0afb8e68e0b: Pull complete
+d599c07d28e6: Pull complete
+f2ecc74db11a: Pull complete
+26856d31ce86: Pull complete
+2cd68d824f12: Pull complete
+7ea1535f18c3: Pull complete
+2bef93d9a76e: Pull complete
+Digest: sha256:9079aa8582543494225d2b3a28fce526d9a6b06eb06ce2bac3eeee592fcfc49e
+Status: Downloaded newer image for python:3.8
+docker.io/library/python:3.8
+
+
+镜像下载后，就可以使用镜像来创建容器了。
+
+Docker容器的使用
+
+4.1 启动容器
+
+执行命令docker run即可启动容器，也就是创建某个镜像的实例。docker run命令非常复杂，可以先执行一个docker run –help来查看帮助：
+
+$ docker run --help
+
+Usage: docker run [OPTIONS] IMAGE [COMMAND] [ARG...]
+
+Run a command in a new container
+
+Options:
+ --add-host list Add a custom host-to-IP mapping (host:ip)
+ -a, --attach list Attach to STDIN, STDOUT or STDERR
+ --blkio-weight uint16 Block IO (relative weight), between 10 and 1000, or 0 to disable (default 0)
+ --blkio-weight-device list Block IO weight (relative device weight) (default [])
+ --cap-add list Add Linux capabilities
+ --cap-drop list Drop Linux capabilities
+ --cgroup-parent string Optional parent cgroup for the container
+ --cidfile string Write the container ID to the file
+ --cpu-period int Limit CPU CFS (Completely Fair Scheduler) period
+ --cpu-quota int Limit CPU CFS (Completely Fair Scheduler) quota
+ --cpu-rt-period int Limit CPU real-time period in microseconds
+ --cpu-rt-runtime int Limit CPU real-time runtime in microseconds
+ -c, --cpu-shares int CPU shares (relative weight)
+ --cpus decimal Number of CPUs
+ --cpuset-cpus string CPUs in which to allow execution (0-3, 0,1)
+ --cpuset-mems string MEMs in which to allow execution (0-3, 0,1)
+ -d, --detach Run container in background and print container ID
+ --detach-keys string Override the key sequence for detaching a container
+ --device list Add a host device to the container
+ --device-cgroup-rule list Add a rule to the cgroup allowed devices list
+ --device-read-bps list Limit read rate (bytes per second) from a device (default [])
+ --device-read-iops list Limit read rate (IO per second) from a device (default [])
+ --device-write-bps list Limit write rate (bytes per second) to a device (default [])
+ --device-write-iops list Limit write rate (IO per second) to a device (default [])
+ --disable-content-trust Skip image verification (default true)
+ --dns list Set custom DNS servers
+ --dns-option list Set DNS options
+ --dns-search list Set custom DNS search domains
+ --domainname string Container NIS domain name
+ --entrypoint string Overwrite the default ENTRYPOINT of the image
+ -e, --env list Set environment variables
+ --env-file list Read in a file of environment variables
+ --expose list Expose a port or a range of ports
+ --gpus gpu-request GPU devices to add to the container ('all' to pass all GPUs)
+ --group-add list Add additional groups to join
+ --health-cmd string Command to run to check health
+ --health-interval duration Time between running the check (ms|s|m|h) (default 0s)
+ --health-retries int Consecutive failures needed to report unhealthy
+ --health-start-period duration Start period for the container to initialize before starting health-retries countdown (ms|s|m|h) (default 0s)
+ --health-timeout duration Maximum time to allow one check to run (ms|s|m|h) (default 0s)
+ --help Print usage
+ -h, --hostname string Container host name
+ --init Run an init inside the container that forwards signals and reaps processes
+ -i, --interactive Keep STDIN open even if not attached
+ --ip string IPv4 address (e.g., 172.30.100.104)
+ --ip6 string IPv6 address (e.g., 2001:db8::33)
+ --ipc string IPC mode to use
+ --isolation string Container isolation technology
+ --kernel-memory bytes Kernel memory limit
+ -l, --label list Set meta data on a container
+ --label-file list Read in a line delimited file of labels
+ --link list Add link to another container
+ --link-local-ip list Container IPv4/IPv6 link-local addresses
+ --log-driver string Logging driver for the container
+ --log-opt list Log driver options
+ --mac-address string Container MAC address (e.g., 92:d0:c6:0a:29:33)
+ -m, --memory bytes Memory limit
+ --memory-reservation bytes Memory soft limit
+ --memory-swap bytes Swap limit equal to memory plus swap: '-1' to enable unlimited swap
+ --memory-swappiness int Tune container memory swappiness (0 to 100) (default -1)
+ --mount mount Attach a filesystem mount to the container
+ --name string Assign a name to the container
+ --network network Connect a container to a network
+ --network-alias list Add network-scoped alias for the container
+ --no-healthcheck Disable any container-specified HEALTHCHECK
+ --oom-kill-disable Disable OOM Killer
+ --oom-score-adj int Tune host's OOM preferences (-1000 to 1000)
+ --pid string PID namespace to use
+ --pids-limit int Tune container pids limit (set -1 for unlimited)
+ --platform string Set platform if server is multi-platform capable
+ --privileged Give extended privileges to this container
+ -p, --publish list Publish a container's port(s) to the host
+ -P, --publish-all Publish all exposed ports to random ports
+ --read-only Mount the container's root filesystem as read only
+ --restart string Restart policy to apply when a container exits (default "no")
+ --rm Automatically remove the container when it exits
+ --runtime string Runtime to use for this container
+ --security-opt list Security Options
+ --shm-size bytes Size of /dev/shm
+ --sig-proxy Proxy received signals to the process (default true)
+ --stop-signal string Signal to stop a container (default "SIGTERM")
+ --stop-timeout int Timeout (in seconds) to stop a container
+ --storage-opt list Storage driver options for the container
+ --sysctl map Sysctl options (default map[])
+ --tmpfs list Mount a tmpfs directory
+ -t, --tty Allocate a pseudo-TTY
+ --ulimit ulimit Ulimit options (default [])
+ -u, --user string Username or UID (format: <name|uid>[:<group|gid>])
+ --userns string User namespace to use
+ --uts string UTS namespace to use
+ -v, --volume list Bind mount a volume
+ --volume-driver string Optional volume driver for the container
+ --volumes-from list Mount volumes from the specified container(s)
+ -w, --workdir string Working directory inside the container
+
+
+比如我们要执行python的shell，需要添加-it参数，即：docker run -it python:3.8
+
+$ docker run -it python:3.8
+Python 3.8.7 (default, Dec 22 2020, 18:46:25)
+[GCC 8.3.0] on linux
+Type "help", "copyright", "credits" or "license" for more information.
+>>>
+
+
+4.2 将宿主机的文件挂载到容器
+
+docker容器与宿主机是隔离的，要想让容器内的程序能访问宿主机上的文件，需要通过-v参数将宿主机的文件挂载到容器中。
+
+比如我们在宿主机上有一个hello.py，可以打印hello，想要在python容器中执行，就需要进行挂载。-v后还需要接两个参数，分别是宿主机的目录和容器内的目录，两者使用:分隔，路径必须都是绝对路径。
+
+我的hello.py保存在主目录的/docker_test目录中，将这个目录挂载到容器的/docker_test目录，然后在容器内执行python /docker_test/hello.py：
+
+$ docker run -v ~/docker_test:/docker_test python:3.8 python /docker_test/hello.py
+hello
+
+
+4.3 容器管理
+
+上面的服务运行之后，可以使用docker ps命令，查看运行中的容器：
+
+$ docker ps
+CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
+ec4c86b8a163 python:3.8 "python /docker_test…" 5 seconds ago Up 4 seconds 0.0.0.0:5000->5000/tcp eager_wilson
+
+
+显示的内容有下面几列：
+
+
+ - CONTAINER ID：容器ID
+ - IMAGE：镜像名称和版本
+ - COMMAND：执行的命令
+ - CREATED：容器创建时间
+ - STATUS：容器的状态
+ - PORTS：端口映射
+ - NAMES：容器名
+
+
+要想结束容器，可以使用docker kill 容器ID命令。
+
+自制Docker镜像
+
+一般而言，当我们的程序开发完成后，会连同程序文件与运行环境一起制作成一个新的镜像。
+
+要制作镜像，需要编写Dockerfile。DockeFile由多个命令组成，常用的命令有：
+
+
+ - FROM：基于某个镜像来制作新的镜像。格式为：FROM 镜像名称:镜像版本。
+ - COPY：从宿主机复制文件，支持?、*等通配符。格式为：COPY 源文件路径 目标文件路径。
+ - ADD：从宿主机添加文件，格式与COPY相同，区别在于当文件为压缩文件时，会解压缩到目标路径。
+ - RUN：在创建新镜像的过程中执行的shell命令。格式为：RUN shell命令行。注意，此shell命令将在容器内执行。
+ - CMD：在容器实例中运行的命令，格式与RUN相同。注意，如果在docker run时指定了命令，将不会执行CMD的内容。
+ - ENTRYPOINT：在容器实例中运行的命令，格式与CMD相同。注意，如果在docker run时指定了命令，该命令会以命令行参数的形式传递到ENTRYPOINT中。
+ - ENV：在容器中创建环境变量，格式为：ENV 变量名值。
+
+
+注意，Docker镜像中有一个层的概念，每执行一个RUN命令，就会创建一个层，层过多会导致镜像文件体积增大。尽量在RUN命令中使用&&连接多条shell命令，减少RUN命令的个数，可以有效减小镜像文件的体积。
+
+5.1 自制显示文本文件内容镜像
+
+编写cat.py，接收一个文件名，由python读取文件并显示文件的内容：
+
+import os
+import sys
+
+input = sys.argv[1]
+
+with open(input, "r") as fp:
+ print(fp.read())
+
+
+这个例子比较简单，缩写Dockerfile如下：
+
+FROM python:3.8
+WORKDIR /files
+COPY cat.py /cat.py
+ENTRYPOINT ["python", "/cat.py"]
+
+
+这个Dockerfile的含义是：
+
+
+ - 以python:3.8为基础镜像
+ - 容器启动命令的工作目录为/files，在运行镜像时，需要我们把宿主机的某目录挂载到容器的/files目录
+ - 复制cat.py到容器的根目录下
+ - 启动时运行python /cat.py命令
+
+
+需要说明的是，ENTRYPOINT有两种写法：
+
+ENTRYPOINT python /cat.py
+ENTRYPOINT ["python", "/cat.py"]
+
+
+这里采用第二种写法，是因为我们要在外部给容器传递参数。执行命令编译Docker镜像：
+
+docker build -t cat:1.0 .
+
+
+这个命令中，-t的含义是目标，即生成的镜像名为hello，版本号为1.0，别忘了最后那个.，这叫到上下文路径，是指 docker 在构建镜像，有时候想要使用到本机的文件（比如复制），docker build 命令得知这个路径后，会将路径下的所有内容打包。
+
+这样，我们的第一个镜像就制作完成了，使用下面的命令执行它：
+
+docker run -it -v ~/docker_test/cat/files:/files cat:1.0 test.txt
+
+
+即可看到~/docker_test/cat/files/test.txt的内容。
+
+5.2 用 Docker 部署一个 Python 应用
+
+使用 Docker 部署应用的常规流程是：
+
+
+ - 开发项目并本地测试通过
+ - 编写 Dockerfile 放置到项目根目录
+ - 打包镜像文件
+ - 运行镜像容器
+ - 测试
+
+
+为了演示方便，这里以一个简单的 Flask 项目为例进行讲解
+
+项目开发
+
+from flask import Flask
+
+# 安装依赖
+# pip3 install -U flask
+
+app = Flask(__name__)
+
+
+@app.route('/')
+def index():
+ return "测试容器部署!"
+
+
+if __name__ == '__main__':
+ app.run(host='0.0.0.0', port=8888)
+
+# 浏览器访问测试
+# http://127.0.0.1:8888/
+
+
+项目开发完成，并在本地测试通过后就可以编写 Dockerfile 文件了
+
+编写 Dockerfile
+
+在项目根目录下，创建一个 Dockerfile 文件，使用上面的指令编写描述脚本
+
+需要注意的是，这里使用「 EXPOSE 」指令暴露的端口号与入口文件定义的端口号保持一致
+
+# Dockerfile
+
+FROM centos:7.9.2009
+RUN yum makecache fast;
+RUN yum install python3-devel python3-pip -y
+RUN pip3 install -i https://pypi.douban.com/simple flask
+COPY main.py /opt
+WORKDIR /opt
+EXPOSE 8888
+CMD ["python3","main.py"]
+
+
+构建镜像
+
+# 在当前文件夹下，根据Dockerfile文件构建一个镜像
+# 镜像名称：xag/my_flask_web
+# --no-cache：不使用旧的缓存进行镜像构建
+docker build --no-cache -t "xag/my_flask_web" .
+
+
+运行镜像容器
+
+使用 docker run 命令基于镜像运行一个容器
+
+其中
+
+
+ - -d：代表容器在后台运行，不是基于前台运行
+ - –name：用于执行容器的别名
+ - -p：用于配置宿主机与容器的端口映射
+
+
+# -d：后台运行
+# 宿主机（9999）映射容器内的8888（上面Dockerfile已经暴露了8888端口）
+docker run -d --name flask_web -p 9999:8888 xag/my_flask_web
+
+
+测试一下
+
+最后在浏览器中，通过宿主机暴露的端口号 9999 访问项目了
+
+访问地址：http://127.0.0.1:9999/
+
+导入镜像到生产环境
+
+到此，我们的镜像已经制作好了，可是，镜像文件在哪，如何在生产环境下运行呢？
+
+刚才使用docker images命令时，已经看到了生成的镜像：
+
+$ docker images
+REPOSITORY TAG IMAGE ID CREATED SIZE
+hello 1.0 01fe19111dc7 59 minutes ago 893MB
+python 3.8 f5041c8ae6b1 13 days ago 884MB
+ubuntu 20.04 f643c72bc252 5 weeks ago 72.9MB
+hello-world latest bf756fb1ae65 12 months ago 13.3kB
+
+
+我们可以使用docker save命令将镜像保存到指定的文件中，保存的文件是一个.tar格式的压缩文件：
+
+docker save -o hello.tar hello:1.0
+
+
+将hello.tar复制到生产环境的机器上，然后执行导入命令：
+
+docker load -i hello.tar
+
+
+就可以使用了。
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/37/dfa81f915abb0055c8e7be6e93af0679bc28ce570933472f35a9f1e0e19d04 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/37/dfa81f915abb0055c8e7be6e93af0679bc28ce570933472f35a9f1e0e19d04
new file mode 100644
index 0000000000..ab2648444a
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/37/dfa81f915abb0055c8e7be6e93af0679bc28ce570933472f35a9f1e0e19d04
@@ -0,0 +1,368 @@
+I"B主要包括使用一维卷积神经网络(1D CNN)对安装在远程风机的高速轴承中的现场传感器采集到的时间序列数据通过短时傅里叶变化之后得到的频谱峰度（Kurtosis Spectogram）进行分类，得到每个样品的类别：中等寿命级（预期寿命大于15天的轴承——状态良好）以及短寿命轴承（预期寿命小于15天的轴承——状态不良）。
+
+原文链接：Wind Turbine High Speed Bearing Prognosis Kaggle
+
+1. 问题描述
+
+
+
+本文展示了使用振动监测传感器的原始数据来预测轴承的RUL（剩余使用寿命）的新方法，这种方法也可以用于其他类型的机器元件，如齿轮、联轴器等剩余寿命的预测。
+
+本例中使用的数据是由安装在一个远程风力涡轮机的高速轴承上的现场传感器记录的。
+该轴承是齿轮箱的一部分，负责转子和发电机之间的耦合，特别是在高速轴上（发电机一侧）。
+
+该数据可以通过以下方式访问：
+
+
+ - WindTurbineHighSpeedBearingPrognosis-Data
+
+
+记录的变量是传感器在30天内测得的加速度（单位：g），每天6秒。
+
+2. 技术背景
+
+该方法是基于对50个样本中的每个样本的Kurtosis Spectogram（频谱峰度）的计算，并使用1D-CNN–一维卷积神经网络将每个样本划分为两个RUL等级。中等预期寿命类，代表轴承的预期寿命大于15天（状况良好）。
+
+
+ - 中等预期寿命的类别：寿命大于15天（状况良好）。
+ - 短预期寿命类别，代表轴承的寿命期望值小于15天（状况不佳）。
+
+
+基于这个假设，寿命最短的15个被标记为短寿命类，而所有剩余的被标记为中寿命类。
+
+数据处理流程
+
+导入包
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+import matplotlib
+matplotlib.rcParams['mathtext.fontset'] = 'stix'
+matplotlib.rcParams['font.family'] = 'sans-serif'
+matplotlib.rcParams['font.size'] = 10
+
+from scipy.io import loadmat # scipy加载mat文件
+from scipy.signal import stft # scipy的短时傅里叶变换
+from scipy.stats import kurtosis # kurtosis表示峰度，峰度是统计学中的一个概念，用来描述某个分布的峰值的陡峭程度
+
+from mpl_toolkits.mplot3d import Axes3D
+
+from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
+from sklearn.model_selection import train_test_split
+
+from tensorflow.keras.models import *
+from tensorflow.keras.layers import *
+from tensorflow.keras.utils import *
+
+
+定义混淆矩阵可视化函数
+
+def plotConfusionMatrix(dtrue,dpred,classes,\
+ cmap = plt.cm.Blues,bsize = 1.0): # 混淆矩阵可视化函数,dtrue表示真实值,dpred表示预测值,classes表示类别,cmap表示颜色,bsize表示图像大小
+
+ cm = confusion_matrix(dtrue,dpred,normalize = 'true') # 混淆矩阵,normalize = 'true'表示归一化
+
+ fig,ax = plt.subplots(figsize = (np.shape(classes)[0] * 1.25 * bsize,\
+ np.shape(classes)[0] * 1.25 * bsize))
+
+ im = ax.imshow(cm,interpolation = 'nearest',cmap = cmap) # interpolation = 'nearest'表示插值方式,nearest表示最近邻插值,cm表示混淆矩阵,cmap表示颜色
+
+ ax.set(xticks = np.arange(cm.shape[1]),\
+ yticks = np.arange(cm.shape[0]),\
+ xticklabels = classes,\
+ yticklabels = classes,\
+ ylabel = 'True Efficiency',\
+ xlabel = 'Predicted Efficiency')
+
+ plt.setp(ax.get_xticklabels(),rotation = 90,ha = 'right',\
+ rotation_mode = 'anchor') # ha表示水平对齐方式,rotation_mode表示旋转模式，anchor表示锚点;setp表示设置属性
+
+ fmt = '.2f' # 保留两位小数
+
+ thresh = cm.max() / 2.0
+
+ for i in range(cm.shape[0]):
+ for j in range(cm.shape[1]):
+ ax.text(j,i,format(cm[i,j],fmt),ha = 'center',va = 'center',\
+ color = 'white' if cm[i,j] > thresh else 'black') # ha表示水平对齐方式,va表示垂直对齐方式,j表示列,i表示行
+
+ fig.tight_layout()
+
+ return ax
+
+
+查看数据
+
+扫描频率为97656HZ，采样的总共时长为6s，所以采样点的个数为
+
+fname = !ls './input/data'
+fname = np.asarray(fname)
+
+df = []
+
+for i in fname:
+ df.append(loadmat('./input/data/' + i)['vibration'].flatten())# loadmat表示加载mat文件,flatten表示降维
+
+df = np.asarray(df) # 转换为数组
+
+df.shape[0]
+
+
+
+输出结果为：
+
+50 # 表示样本数量
+
+
+查看采样频率
+
+fs = int(df.shape[1] / 6.0) # 采样频率
+t = np.linspace(0.0,6.0,df.shape[1]) # df.shape[1]表示df的第二维度的长度,即采样点数；t表示一个周期内，每个采样点的时间;
+
+print('Scan frequency: {:,d} Hz'.format(fs)) # {:,d}表示以逗号分隔的十进制整数,scan frequency表示扫描频率
+
+
+输出结果为：
+
+Scan frequency: 97,656 Hz
+
+
+下图显示了加速度的测量值（单位：g），正如可以注意到的那样，加速度的振幅在时域上变化明显(x轴表示时间，每天6秒，50天)
+
+plt.subplots(figsize = (12.0,6.0))
+for i in range(df.shape[0]):
+ plt.plot(t + i * 6.0,df[i],color = 'black',lw = 0.25)
+
+plt.xlabel('Time (in s): sample = 50 days in total, 6 seconds per day')
+plt.ylabel('Acceleration (in g)')
+plt.show()
+
+
+
+
+尽管加速度有明显的变化，记录的数据数量（6 x 97,656 =
+每天585,936个记录；总共29,286,800个）很大，再加上 测量的非同步条件，使得使用传统的神经网络来对轴承状况进行分类是不可行的。
+
+这个问题需要一个不同的方法来将正弦波的时域变量转化为非周期性变量，从而使区分RUL等级成为可能。
+
+Kurtosis
+
+这个新的变量是通过短时傅里叶变换计算的Kurtosis，如下图所示的三维图。可以注意到，在正常情况下，Kurtosis是非常稳定的，无论频率如何变化(例如前五个样本)，但当异常的运行条件导致数据偏离正态分布时，则Kurtosis趋于变大。
+
+f = []
+fft = []
+
+wnd = 127
+
+for i in range(df.shape[0]):
+ u,v,w = stft(df[i],fs,nperseg = wnd,noverlap = int(0.8 * wnd),nfft = int(2.0 * wnd))
+ # stft表示短时傅里叶变换,fs表示采样频率;nperseg表示每段的长度,
+ # noverlap表示重叠的长度,nfft表示fft的长度
+ # u表示频率,v表示时域,w表示频谱
+ f.append(u)
+ fft.append(kurtosis(np.abs(w),fisher = False,axis = 1)) # 对频谱取绝对值,然后计算峰度
+ # fisher表示是否使用Fisher标准化,axis = 1表示沿着第二维度计算峰度
+
+f = np.asarray(f) # asarray表示将输入转换为数组,f表示频率
+fft = np.asarray(fft)
+
+fftn = (fft - fft.min()) / (fft.max() - fft.min()) # 归一化,n表示归一化后的频谱
+
+fftn = np.asarray(fftn)
+n = np.ones_like(f[0])# ones_like表示返回与输入形状相同的数组,数组元素为1
+fig = plt.figure(figsize = (10.0,10.0))
+ax = plt.axes(projection = '3d')
+ax.view_init(30,225)
+for i in range(f.shape[0]):
+ ax.plot(f[i] / 1.0e3,i * n,fftn[i],color = 'black',linewidth = 0.50) # / 1.0e3表示将频率转换为kHz
+
+ax.set_xlabel('Frequency (kHz)')
+ax.set_ylabel('Sample')
+ax.set_zlabel('Kurtosis')
+plt.show()
+
+
+
+
+模型训练
+
+准备模型
+
+Kurtosis被用作1D-CNN的输入(变量x)，而与两个RUL等级相关的标签则通过变量y–中寿命期望值类（y = 0）用于前35个样本，而短寿命预期类（y = 1）用于最后15个样本。
+y被转换为分类格式，以适应神经网络的输出格式。
+
+1D-CNN是通过使用Keras开源库的Sequential()函数定义的。
+
+X = fftn
+X = X.reshape(-1,f.shape[1],1) # reshape表示改变数组的形状,-1表示自动计算,1表示一维，f.shape[1]表示频率的长度
+y = np.zeros(X.shape[0],dtype = int)
+y[-15:] = 1 # y表示标签，-15表示从后往前数第15个，都是short-life expectancy class (y = 1)
+
+print('Input shape: {:d} samples x {:d} registers/sample'.format(X.shape[0],X.shape[1]))
+
+label = to_categorical(y) # to_categorical表示将标签转换为one-hot编码,one-hot编码表示将标签转换为二进制向量
+label
+
+
+Input shape: 50 samples x 128 registers/sample
+
+
+mdl = Sequential() # Sequential表示顺序模型
+mdl.add(Conv1D(100,6,activation = 'relu',\
+ input_shape = (f.shape[1],1))) # Conv1D表示一维卷积层,100表示卷积核的个数,6表示卷积核的大小,activation表示激活函数
+mdl.add(Conv1D(100,6,activation = 'relu'))
+mdl.add(MaxPooling1D(3))
+mdl.add(Conv1D(160,6,activation = 'relu'))
+mdl.add(Conv1D(160,6,activation = 'relu'))
+mdl.add(GlobalAveragePooling1D())
+mdl.add(Dropout(0.5))
+mdl.add(Dense(2,activation = 'softmax'))
+
+print(mdl.summary())
+
+
+输出结果如下：
+
+
+
+训练模型
+
+mdl.compile(loss = 'categorical_crossentropy',\
+ optimizer = 'adam',metrics = ['accuracy']) # compile表示编译模型,loss表示损失函数,optimizer表示优化器,metrics表示评估模型的指标
+
+
+该模型在50%的样本上进行了训练–需要注意的是，该数据集非常有限，只有50个样本,尽管每个样本有大量的记录。
+
+训练是基于1,000个epochs–这是为了让模型有一个良好的收敛。
+
+代价矩阵（变量cw）被用来影响分类结果并避免与错误分类相关的错误。
+
+当遇到很难决策的时候，将中等寿命的轴承归类为短寿命轴承，并将决定权交给维修专家，让维修专家来决定，而不是错误地将短寿命的轴承错误分类并导致机组故障。
+
+batch,epoch = 32,1000 # batch表示每次训练的样本数,epoch表示训练的轮数
+cw = {0: 5.0,1:75.0} # cw表示类别权重
+
+Xtrain,Xtest,ytrain,ytest = train_test_split(X,label,\
+ random_state = 21,\
+ test_size = 0.50)
+# train_test_split表示将数据集分为训练集和测试集,random_state表示随机数种子,test_size表示测试集的比例为50%
+
+hist = mdl.fit(Xtrain,ytrain,batch_size = batch,\
+ epochs = epoch,validation_split = 0.2,verbose = 0,\
+ class_weight = cw)
+# fit表示训练模型,batch_size表示每次训练的样本数,epochs表示训练的轮数,validation_split表示验证集的比例,verbose表示日志显示,0表示不显示
+
+
+训练之后，画出accracy和loss随着训练次数的变化图。我们认为，接近1的正确率说明训练收敛情况良好。
+
+plt.subplots(1,2,figsize = (9.0,4.5),sharex = True) # sharex表示共享x轴
+plt.subplot(1,2,1)
+plt.plot(hist.epoch,hist.history['accuracy'],\
+ color = 'black',lw = 2.50)
+# hist.epoch表示训练的轮数,hist.history['accuracy']表示训练集的准确率,可以看到随着训练的轮数增加,训练集的准确率也在增加
+plt.ylabel('1D-CNN Accuracy')
+plt.xlabel('Epoch')
+plt.subplot(1,2,2)
+plt.plot(hist.epoch,hist.history['loss'],\
+ color = 'pink',lw = 2.50)
+plt.ylabel('1D-CNN Loss')
+plt.xlabel('Epoch')
+plt.tight_layout()
+plt.show()
+
+
+
+
+可以发现，模型的准确率高到90%。
+
+评估模型的变现：
+
+print(mdl.evaluate(Xtest,ytest,verbose = 2)) # evaluate表示评估模型
+
+
+输出结果如下：
+
+1/1 - 0s - loss: 0.4079 - accuracy: 0.9200 - 28ms/epoch - 28ms/step
+[0.4079207181930542, 0.9200000166893005]
+
+
+分类报告显示了每个类的精度、召回率和f1-score的详细信息，包括模型的整体性能。
+
+# print(classification_report(np.where(ytest != 0)[1],\
+# mdl.predict_classes(Xtest)))
+predict=mdl.predict(Xtest)
+classes_x=np.argmax(predict,axis=1)
+print(classification_report(np.where(ytest != 0)[1],\
+ classes_x))
+
+
+输出结果如下：
+
+1/1 [==============================] - 0s 37ms/step
+ precision recall f1-score support
+
+ 0 1.00 0.88 0.94 17
+ 1 0.80 1.00 0.89 8
+
+ accuracy 0.92 25
+ macro avg 0.90 0.94 0.91 25
+weighted avg 0.94 0.92 0.92 25
+
+
+通过下面描述的混淆矩阵，可以更直观地显示召回率：
+
+plotConfusionMatrix(np.argmax(ytest,axis = 1),\
+ np.argmax(mdl.predict(Xtest),axis = 1),\
+ ['medium','short'],\
+ bsize = 1.75,cmap = 'binary')
+plt.title('Accuracy (RECALL)')
+plt.show()
+
+
+
+
+附录
+
+深度学习评价标准
+
+
+
+TP(a)：实际正类预测为正类的数量；FN(b)：实际正类预测为负类的数量
+
+FP(c)：实际负类预测为正类的数量；TN(d)：实际负类预测为负类的数量
+
+IoU交并比：用于判断检测出的目标是否和真值目标框匹配，即判断是tp、fp还是fn
+
+\[IoU = tp/(tp+fp+fn)\]
+
+Precision 精确率（也就是查准率）:
+
+\[Precision = tp /(tp+fp)\]
+
+Recall召回率（也即是查全率）
+
+\[Recall = tp/(tp+fn)\]
+
+P-R曲线
+
+
+
+从图中可以看出，Precision高，Recall就很难做到非常高；Recall高，Precision就很难做到很高。因此，一般画出P-R曲线发现成反比例。于是，产生问题：
+
+
+ - 如何选取最合适的阈值以平衡Precision和Recall？ 答案：可利用F1 score寻找Precision和Recall之间的最优平衡，即选择使得F1 score取得最大值时对应的阈值。
+
+
+\[F1 = 2* (Precision * Recall)/(Precision+Recall)\]
+
+频谱峰度（Kurtosis Spectogram）
+
+谱峭度（Spectrum kurtosis,SK）的概念最先由Dwyer在1983年提出，其本质是计算每根谱线峭度值的高阶统计量。谱峭度对信号中的瞬态冲击成分十分敏感，能有效的从含有背景噪声信号中识别瞬态冲击及其在频带中的分布。由于谱峭度的复杂性、缺少一个正式的定义和一个容易理解的计算过程使其在很长时间内都未能引入到工程应用中，直到Antoni等在2006年为谱峭度做了详细的定义，并提出了基于短时傅里叶变换的SK估计器，将理论概念与实际应用联系起来，提出了Kurtogram算法，并阐述了该算法在旋转机械故障特征提取领域的具体应用过程。
+
+轴承故障诊断之谱峭度法的一些总结
+
+1D CNN
+
+写不动了！！！
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/39/51da1edb40bf61f0340b95c9f09a765cedd9ed7d0eb2316e1d52f023583613 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/39/51da1edb40bf61f0340b95c9f09a765cedd9ed7d0eb2316e1d52f023583613
new file mode 100644
index 0000000000..8c19277c56
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/39/51da1edb40bf61f0340b95c9f09a765cedd9ed7d0eb2316e1d52f023583613
@@ -0,0 +1,7 @@
+I"
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/3a/724c5f88752885bd5b422c343e1dea7350383168ad2f65751b20f48a95c0f7 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/3a/724c5f88752885bd5b422c343e1dea7350383168ad2f65751b20f48a95c0f7
new file mode 100644
index 0000000000..a657655295
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/3a/724c5f88752885bd5b422c343e1dea7350383168ad2f65751b20f48a95c0f7
@@ -0,0 +1,276 @@
+I"x.简介
+
+一般来说，个人主页是自己的一张名片，有些人用来记录自己的生活，有些人用来分享技术、总结自己踩过的坑，有些人用来展示实验室和研究生招生等等。其实很多类似博客园之类的都可以写文章，没有必要自己弄自己的网站。
+
+但是如果想选择自己搭建自己的网站，想选择不一样的样式，那么不妨可以多看看大佬们的主页。
+
+对此，我们需要满足两个条件：
+
+第一，我们可能需要掌握一些前端的编程知识，至少我们需要学会HTML超链接文本的书写，在里面可以展示我们网站想要展示给别人的基本内容；如果需要对网页内容进行美化，则还需要学习CSS（层叠样式表）的基本知识；如果进一步还想和观众进行互动的话，可能还要学习JavaScript的知识，这个其实就跟画PPT一样，我们肯定能学会，但是能不能画好，就是另外一回事了。
+
+第二个，就是要从一些运营商购买域名，比如说我同学haris就有自己的域名，还买了上市运营商的股票。但是主要问题是有一定学习门槛，而且我心疼钱呀呜呜呜！！！
+
+那么，有没有一种方法，能够做到零成本、维护简单、以及不需要额外设计呢？答案是肯定的，GitHub 为我们提供了相应的 Pages 服务。这意味着，只要我们拿到别人已经做好的样式文件（别人写好了css,js等文件，拿来用就行了），再放入自己的 Markdown 文件，就能够建立简易的静态网页，从而实现零成本搭建个人主页的需求。
+
+以下是一些我参考过的，对我研究生生涯很有帮助的个人主页：
+
+
+ - 炸鸡人博客
+
+ - Python系列
+ - Cartopy系列
+ - Matplotlib 系列
+ - …
+
+
+ - 摸鱼的大佬
+ - Eddy’s World
+
+ - Academic
+ - Life
+
+ - 关于抑郁症这件事
+ - 关于自律的一个月尝试
+ - 小白入门系列之一：健身增肌训练
+
+
+ - Software
+
+
+ - 抽筋儿的话语权
+ - Clarmy吱声
+
+
+Jekyll简介
+
+我们首先来解决第一个问题，那就是不会一些前端语言，只会最简单的Markdown能不能写出自己的静态网站？
+
+有滴，套模板就好了。
+
+常用的静态网站生成器有：Jekyll，Hugo，Hexo等。Jekyll使用Ruby语言构建，是GitHub Pages默认支持的生成器；Hugo使用Go语言构建，Hexo使用NodeJS技术构建。据说Hugo速度是最快的,Hexo不同版本配置会差不少。
+
+为什么最后会选择Jekyll生成器呢？
+因为我看上的模板是这样搭建的
+
+如何使用GitHub Page
+
+GitHubPages 是 GitHub推出的免费静态网页托管服务，我们可以使用 GitHub 或者 Gitee 托管博客、项目官网等静态网页。它们支持以 Jekyll、Hugo、Hexo 等工具编译而成的静态资源。同时网上也存在着较多的 Jekyll Themes、Hexo Themes 、Hugo Themes 等主题资源。对于轻量的博客需求，我们只需拷贝任意一种自己喜欢的主题，然后上传至自己的仓库，就能够通过 “name.github.io” 或者 “name.gitee.io” 等域名访问自己的博客页面。
+
+Gitee据说也可以，但是好像很容易被吞图传
+
+当然这个不是必须的，WordPress等其他网站或者自己搞一个自己的域名也是很好的选择。但是，谁让它是免费的呢；而且还有这么多技术博客教你怎么？
+
+使用github page创建自己的免费个人博客主要包括以下步骤，见官网步骤：
+
+
+ - 创建一个repository，这个repository一定要命名为username.github.io的格式。
+ - 在本地克隆该repository。
+ - 进入该项目文件夹并进行修改，可以多找找其他人的博客，确定真的喜欢才行。我第一次找了个二次元大佬的博客主页，后来发现不少很适合自己。
+ - 将修改发布到repository：Add, commit, and push your changes。
+ - 刷新一下，应该一两分钟之后就可以在自己的网站看到自己的更改。
+ - 或者可以启动本地服务，现预览一遍可能的效果：jekyll serve然后在Server address: http://127.0.0.1:4000查看效果。
+
+
+撰写博文的过程
+
+比如说从写一个Markdown简介开始
+
+Jekyll 环境配置
+安装 jekyll
+gem install jekyll
+
+启动本地服务
+jekyll serve
+
+在浏览器中打开 http://127.0.0.1:4000，就可以看到本地的网页了。
+
+写完之后你的项目文件夹应该是怎么样的呢？
+
+Jekyll 的核心其实是一个文本转换引擎。它的概念其实就是： 你用你最喜欢的标记语言来写文章，可以是 Markdown，也可以是 Textile,或者就是简单的 HTML, 然后 Jekyll 就会帮你套入一个或一系列的布局中。在整个过程中你可以设置URL路径, 你的文本在布局中的显示样式等等。这些都可以通过纯文本编辑来实现，最终生成的静态页面就是你的成品了。
+
+一个基本的 Jekyll 网站的目录结构一般是像这样的：这是我写完博客之后的文件夹列表(有删减)
+
+│ .gitignore
+│ 404.html
+│ about.md
+│ archive.html
+│ feed.xml
+│ Gemfile
+│ Gemfile.lock
+│ index.html
+│ Rakefile
+│ README.md
+│ support.md
+│ tags.html
+│ _config.yml
+│
+├─.jekyll-cache
+│ └─Jekyll
+│ └─Cache
+│ ├─Jekyll--Cache
+│ │ └─b7
+│ │ 9606fb3afea5bd1609ed40b622142f1c98125abcfe89a76a661b0e8e343910
+│ │
+│ └─Jekyll--Converters--Markdown
+├─code
+│ │ 2022-07-11-D-Tale库介绍.ipynb
+│ │
+│ └─.ipynb_checkpoints
+│ 2022-07-11-D-Tale库介绍-checkpoint.ipynb
+│
+├─css
+│ animate.css
+│ main.css
+│ post.css
+│ tomorrow.css
+├─images
+│ │ avatar.jpg
+│ │ background-cover.jpg
+│
+├─js
+│ highlight.pack.js
+│ main.js
+│
+├─_includes
+│ │ comments.html
+│ │ external.html
+│ │ footer.html
+│ │ head.html
+│ │ new-old.html
+│ │ pagination.html
+│ │ read-more.html
+│ │ side-panel.html
+│ │ toc.html
+│ │
+│ ├─JB
+│ │ pages_list
+│ │ posts_collate
+│ │ setup
+│ │ tags_list
+│ │
+│ └─styles
+│ main.css
+│
+├─_layouts
+│ default.html
+│ page.html
+│ post.html
+│
+├─_posts
+│ 2022-07-10-D-Tale库介绍.md
+│ 2022-07-10-markdown简介.md
+│ 2022-08-09-海表面高度数据下载.md
+│ 2022-10-26-前端入门.md
+│ 2022-10-27-如何使用GitHub Page搭建自己的个人网页.md
+│
+└─_site
+ │ 404.html
+ │ feed.xml
+ │ index.html
+ │ Rakefile
+ │ README.md
+ │
+ ├─2022
+ │ ├─07
+ │ │ ├─D-Tale库介绍
+ │ │ │ index.html
+ │ │ │
+ │ │ └─markdown简介
+ │ │ index.html
+ │ │
+ │ └─08
+ │ └─海表面高度数据下载
+ │ index.html
+ │
+ ├─about
+ │ index.html
+ │
+ ├─archive
+ │ index.html
+ │
+ ├─code
+ │ 2022-07-11-D-Tale库介绍.ipynb
+ │
+ ├─css
+ │ animate.css
+ │ main.css
+ │ post.css
+ │ tomorrow.css
+ │
+ ├─images
+ ├─js
+ │ highlight.pack.js
+ │ main.js
+ │
+ ├─support
+ │ index.html
+ │
+ └─tags
+ index.html
+
+
+
+注意事项：
+
+ -
+
发布时间：有一个凌晨，我文章写好了，也push上去了，也没发现错误，但是左等右等都不见个人主页更新这篇文章。后来才知道，github page应该托管的服务器在美国，用的是美国东部时间可能，也就是说你在今天发布的内容，至少要到中午才能看到。
+
+ -
+
如何支持数学公式：
+在_layouts/post.html中，在head标签中加入以下代码：
+
+
+
+ <!-- 数学公式 -->
+ <script src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML" type="text/javascript"></script>
+ <script type="text/x-mathjax-config">
+ MathJax.Hub.Config({
+ tex2jax: {
+ skipTags: ['script', 'noscript', 'style', 'textarea', 'pre'],
+ inlineMath: [['$','$'], ['\\(','\\)']],
+ displayMath: [ ['$$','$$'], ['\[','\]'] ]
+ }
+ });
+ </script>
+ <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.10.2/dist/katex.min.css" integrity="sha384-yFRtMMDnQtDRO8rLpMIKrtPCD5jdktao2TV19YiZYWMDkUR5GQZR/NOVTdquEx1j" crossorigin="anonymous">
+ <script defer src="https://cdn.jsdelivr.net/npm/katex@0.10.2/dist/katex.min.js" integrity="sha384-9Nhn55MVVN0/4OFx7EE5kpFBPsEMZxKTCnA+4fqDmg12eCTqGi6+BB2LjY8brQxJ" crossorigin="anonymous"></script>
+ <script defer src="https://cdn.jsdelivr.net/npm/katex@0.10.2/dist/contrib/auto-render.min.js" integrity="sha384-kWPLUVMOks5AQFrykwIup5lo0m3iMkkHrD0uJ4H5cjeGihAutqP0yW0J6dpFiVkI" crossorigin="anonymous" onload="renderMathInElement(document.body);"></script>
+
+
+
+然后在_config.yml中加入以下代码：
+
+markdown: kramdown
+kramdown:
+ math_engine: mathjax
+ syntax_highlighter: rouge
+ input: GFM
+ hard_wrap: false
+ syntax_highlighter_opts:
+ disable: true
+
+
+写完之后如何发布
+
+写完所有代码并且在本地查看了效果之后，就可以把本地项目所做的更改push到github上了。在本地项目的根目录下，打开git bash，输入以下命令：
+
+git add .
+git commit -m "提交信息"
+git push -u origin master
+
+
+
+待解决功能
+
+
+ - 评论功能，我之前按照教程去弄，但是好像是个韩国的网站，它给我发了注册信息，但是都被我邮箱垃圾桶照单全收了。两个月之后，我才在垃圾箱里面找到，但是那个时候我已经不知道怎么搞了，真的是“出师未捷身先死。”
+
+
+参考连接
+
+
+ - Jekyll搭建个人博客 (但是这个大佬好像以及不更新了)
+ - 用 Hugo 重新搭建博客
+
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/3a/8794c986f3a8d3bfdc4fce3efdce91b9d53ee1d2e5ad547633496d6e35ae57 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/3a/8794c986f3a8d3bfdc4fce3efdce91b9d53ee1d2e5ad547633496d6e35ae57
new file mode 100644
index 0000000000..766db09c09
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/3a/8794c986f3a8d3bfdc4fce3efdce91b9d53ee1d2e5ad547633496d6e35ae57
@@ -0,0 +1,2 @@
+I"主要包括列表推导式，迭代器与生成器，装饰器，类的特殊方法（魔法方法），类的装饰器等等
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/3c/4f1c9500e2a0b7a9b723e1d04afa4ede98f9659182003ccc39c1b60e883552 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/3c/4f1c9500e2a0b7a9b723e1d04afa4ede98f9659182003ccc39c1b60e883552
new file mode 100644
index 0000000000..7953831a93
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/3c/4f1c9500e2a0b7a9b723e1d04afa4ede98f9659182003ccc39c1b60e883552
@@ -0,0 +1,100 @@
+I"1. 什么是stable diffusion？
+
+2. 环境搭建
+
+python3.10.6
+
+也可以从python release页面下载:
+https://www.python.org/downloads/windows/
+
+项目地址：
+stable diffusion
+
+拉取到本地：
+
+https://github.com/AUTOMATIC1111/stable-diffusion-webui.git
+
+
+可能会遇到的问题：
+
+windows下已经存在了其他的python版本，要先切换默认的python版本：
+
+py --version # 查看当前默认的python版本
+py -0p # 查看当前系统中安装的python版本
+py -3.x -m ensurepip --default-pip # 切换默认的python版本
+
+
+或者找到“系统属性”，点击“环境变量”，在“系统变量”中找到“Path”，在“Path”中应该已经有了两个python路径，删除其中一个python路径或者把其中想要的路径上移到最前面即可。
+
+如果已经用了其他版本的python，要先去stable-diffusion-webui文件夹下面的venv删除所有文件再进行操作。
+
+下载stable diffusion
+
+运行webui-user.bat，第一次会下载所需要的whl和依赖包，可能会比较慢，耐心等待。
+
+第一次运行出现的问题：
+gfpgan安装失败
+
+解决方案
+
+
+ - 无法安装gfpgan的原因是网络问题，就算已经科学上网，并设置为全局，也无法从github上下载源代码，从而导致install失败。
+ - 解决方法是直接到github下载 GFPGAN 代码到本地，并进行 本地安装 。
+ - 因为stable diffusion会在其根目录创建虚拟python环境venv，因此安装方法与github有所不同。可参考以下方法：
+
+ - 从github将GFPGAN的源文件下载到本地，这一步可以使用git clone也可以直接下载zip文件。下载后，解压（如果用git clone就不需要）到
d:\\stable-diffusion-webui\venv\Scripts目录下（stable-diffusion-webui是你stable diffusion webui的根目录，这个地址只是我电脑中的，请根据自己放的位置调整）。
+ - 打开cmd，cd到
d:\\stable-diffusion-webui\venv\Scripts\GFPGAN-master下。
+ - 使用命令
d:\\stable-diffusion-webui\venv\Scripts\python.exe -m pip install basicsr facexlib安装GFPGAN的依赖。
+ - 再使用
d:\\stable-diffusion-webui\venv\Scripts\python.exe -m pip install -r requirements.txt安装GFPGAN的依赖。
+ - 使用
d:\\stable-diffusion-webui\venv\Scripts\python.exe setup.py develop安装GFPGAN。
+
+
+
+
+如果文件路径有空格，要加上双引号。
+这里的python.exe -m表示使用python.exe这个文件来执行模块pip，也就是pip.py这个文件。
+
+安装open_clip失败
+
+解决方案
+
+还有其他一些小问题，很好解决的。
+
+比如说从github上面拉取Stability-AI
+/stablediffusion出现 Failed to connect to github.com port 443: Timed out的问题，可以换国内的镜像源解决。
+
+git clone https://hub.fgit.gq/Stability-AI/stablediffusion.git "D:/software1/stable diffusion/stable-diffusion-webui/repositories/stable-diffusion-stability-ai"
+
+
+运行stable diffusion
+
+训练模型时报错：
+
+torch.cuda.OutOfMemoryError: CUDA out of memory. Tried to allocate 128.00 MiB (GPU 0; 4.00 GiB total capacity; 2.20 GiB already allocated; 44.64 MiB free; 2.41 GiB reserved in total by PyTorch) If reserved memory is >> allocated memory try setting max_split_size_mb to avoid fragmentation. See documentation for Memory Management and PYTORCH_CUDA_ALLOC_CONF
+
+解决方法：
+
+
+ - 降低batch_size
+ - 换显卡
+ - repositories\stable-diffusion-stability-ai\scripts\txt2img.py
+
+ - parser.add_argument的–n_samples的default改为1
+ model.to(device)后添加 .half() 没找到这个在哪
+
+ - 1
+
+
+Civitai
+
+自己训练的照片不太满意，可以用Civitai的模型进行训练。
+
+https://civitai.com/models/8109/ulzza
+
+https://civitai.com/models/6424/chill
+
+其他
+
+txt2img只是stable diffusion最简单的功能，还可以img2img等等。
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/3d/136cba488862e037674e7417600caee920ca5f5a2d3bfaeaff0ee66c2c2ece b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/3d/136cba488862e037674e7417600caee920ca5f5a2d3bfaeaff0ee66c2c2ece
new file mode 100644
index 0000000000..2a4c8d5bce
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/3d/136cba488862e037674e7417600caee920ca5f5a2d3bfaeaff0ee66c2c2ece
@@ -0,0 +1,2 @@
+I"?Docker相关的概念
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/3d/5f622e82c5d1b6a4c9174156b456f72f4aa6b7438c70ee98eabcf40a5dac04 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/3d/5f622e82c5d1b6a4c9174156b456f72f4aa6b7438c70ee98eabcf40a5dac04
new file mode 100644
index 0000000000..61fe93c246
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/3d/5f622e82c5d1b6a4c9174156b456f72f4aa6b7438c70ee98eabcf40a5dac04
@@ -0,0 +1,2 @@
+I"Flibpython3.7m.so.1.0: /usr/local/lib/libpython3.7m.so.1.0
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/3f/22a0f3f3714bcf00016962d23f678eda0a91d1bf395f8cbda44deab0469901 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/3f/22a0f3f3714bcf00016962d23f678eda0a91d1bf395f8cbda44deab0469901
new file mode 100644
index 0000000000..0a4ca277a7
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/3f/22a0f3f3714bcf00016962d23f678eda0a91d1bf395f8cbda44deab0469901
@@ -0,0 +1,32 @@
+I"C1. 什么是知识卡片
+
+2. 如何使用ChatGPT制作知识卡片
+
+我希望你能作为一个专业的抽认卡制作者，能够根据我提供的文本制作抽认卡。
+
+制作抽认卡的说明：
+
+
+ - 一张抽认卡包含一个编号、问题、答案和其他细节
+ - 保持抽认卡的简单、清晰，合理换行，并集中于最重要的信息。
+ - 确保正确转义所有符号。
+ - 确保问题是具体的、不含糊的。
+ - 使用清晰和简洁的语言。使用简单而直接的语言，使卡片易于阅读和理解。
+ - 答案应该只包含一个关键的事实/名称/概念/术语。
+ - 关于答案的更多信息应始终放在”细节”一栏中。
+ - 输入文本是excel的文本。
+
+
+请将你制作的卡片以markdown表格（问题/答案/细节）的形式输出，不要有任何额外的文字。
+
+如果你明白，请回复：”我已经学会了如何创建抽认卡。请为我提供文本”。
+
+3. 如何在Anki卡片中利用遗忘曲线对知识点进行周期性地复习
+
+4. Linux知识点卡片
+
+5. 参考文献
+
+ChatGPT 出现后，那些靠知识记忆取胜的教育模式会被颠覆吗？ - 叶峻峣的回答 - 知乎
+https://www.zhihu.com/question/583015287/answer/2901234936
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/40/b1d6a947f69dc746983941575d10a8d4006e1d59f08c07a456a97c26eac9e9 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/40/b1d6a947f69dc746983941575d10a8d4006e1d59f08c07a456a97c26eac9e9
new file mode 100644
index 0000000000..952c3c414b
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/40/b1d6a947f69dc746983941575d10a8d4006e1d59f08c07a456a97c26eac9e9
@@ -0,0 +1,11 @@
+I"软件测试是什么
+软件测试的一个目的是验证你的猜想-猜想软件的内部逻辑，包括第三方的模块、代码包。甚至Python的内建的数据结构是如何运行的。Tasks项目使用名为Task的数据结构，它是用namedtuple工厂函数生成的。Task用于在UI层和API层之间传递信息。
+from collections import namedtuple
+Task = namedtuple('Task', ['summary', 'owner', 'done', 'id'])
+# 使用_new_.defaults_创建一个默认的Task实例
+Task.__new__.__defaults__ = (None, None, False, None)
+
+运行pytest时可以指定目录和文件。如果不指定，会搜索当前目录以及其子目录中以test_开头或者已_test结尾的文件。pytest会自动搜索这些文件中的测试用例。
+rootdir: D:\pytest\Tasks\tests,
+inifile: pytest.ini & tox.ini & setup.cfg
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/41/0dfea48e56f3f27ef73e2255127e031c043466b89e32fd0945c011667487ea b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/41/0dfea48e56f3f27ef73e2255127e031c043466b89e32fd0945c011667487ea
new file mode 100644
index 0000000000..ae7269a59f
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/41/0dfea48e56f3f27ef73e2255127e031c043466b89e32fd0945c011667487ea
@@ -0,0 +1,239 @@
+I"*"介绍了Allure的安装，环境配置；Allure命令，配置pytest.ini文件，利用allure工具生成html报告；最后，讲了Allure的应用实例。
+
+Allure
+
+快速入门
+
+安装
+
+
+ - 安装allure的python插件
+
+
+pip install allure-pytest -i https://mirrors.aliyun.com/pypi/simple/
+
+或者写入requirements.txt
+
+allure-pytest==2.8.18
+
+
+pip install -r requirements.txt -i https://mirrors.aliyun.com/pypi/simple/
+
+
+
+ - allure工具的安装
+allure的python插件（而且生成的不是html格式的文件）依赖allure工具，所以需要先安装allure工具：
+
+
+allure需要有jdk环境，所以需要先安装jdk。
+
+sudo apt-get update
+sudo apt-get install openjdk-8-jdk
+sudo update-alternatives --set java /usr/lib/jvm/java-1.8.0-openjdk-amd64/bin/java # 设置环境变量
+java -version # 显示版本信息表示安装成功
+
+
+安装Allure
+
+方法一：
+
+sudo apt-get install allure
+# 查看安装路径
+whereis allure
+# allure: /usr/share/allure
+# 配置软连接或者环境变量
+sudo ln -s /usr/share/allure /usr/bin/allure
+
+
+上述安装方式使用allure – version时候报：allure: command can not found ，需要设置allure的bin放到PATH里边。 若whereis allure找不到allure，换下边方式安装。
+
+方法二：
+
+curl -O https://repo.maven.apache.org/maven2/io/qameta/allure/allure-commandline/2.13.8/allure-commandline-2.13.8.tgz # 下载allure，文件会下载到当前目录;curl命令是linux下的下载工具，windows下可以用wget
+sudo tar -zxvf allure-commandline-2.13.8.tgz -C /opt/ # -C指定解压目录,这里解压到/opt/allure-2.13.8;一般来说，/opt目录下的文件都是安装软件的.
+sudo ln -s /opt/allure-2.13.8/bin/allure /usr/bin/allure
+allure --version # 查看版本信息以及是否安装成功
+
+
+配置环境（软连接好像不起作用）：
+
+vi /etc/profile
+# 在PATH后追加以下内容，保存
+export PATH=$PATH:/home/allure-2.13.8/bin
+# 使环境变量生效
+source /etc/profile
+
+最后，配置好环境变量后记得重启下ide（很重要）！！！
+其他下载地址：
+https://repo.maven.apache.org/maven2/io/qameta/allure/allure-commandline/
+
+https://github.com/allure-framework/allure2/releases
+
+使用
+
+首先要配置pytest.ini文件，告诉pytest使用allure插件;添加allure代码；运行；最后，利用allure工具生成html报告。
+
+addopts = -s --alluredir ./report/result
+
+
+
+添加allure代码，在testcase文件夹下面创建t_allure文件夹，新建test_allure.py文件，添加如下代码：
+
+import pytest
+def test_1():
+ print("test 1")
+
+def test_2():
+ print("test 2")
+
+def test_3():
+ print("test 3")
+
+if __name__ == '__main__':
+ pytest.main(["allure_demo.py"])
+
+
+运行代码，可以看到在同级report文件夹下生成了result文件夹，里边有allure相关的文件。
+
+最后，点击terminal，在终端中输入allure generate ./report/result -o ./report/html –clean，生成html报告。
+
+# 进入文件夹
+cd testcase/t_allure/
+ls
+# 生成html报告
+allure generate ./report/result -o ./report/html --clean
+# --clean表示清除之前的报告 -o表示输出的文件夹
+# 打开html报告,可以找到index.html文件，也可以使用allure open命令打开
+allure open ./report/html
+
+
+Allure 命令
+
+Title
+
+可以自定义用例标题，标题默认为函数名。@allure.title(“用例标题”)
+
+Description
+
+可以添加测试的详细说明，支持Markdown语法。@allure.description(“用例详细描述”)
+
+Feature
+
+功能，可以理解为模块。@allure.feature(“功能模块”)
+
+Story
+
+Story，可以理解为子模块。@allure.story(“子模块”)
+
+Severity
+
+定义用例的严重程度，分为blocker、critical、normal、minor、trivial。@allure.severity(allure.severity_level.CRITICAL)
+
+默认为normal。
+
+只运行指定级别的用例：
+
+pytest -s -q --alluredir=./report/result --allure-severities=critical # -s表示打印日志 -q表示简化输出;--allure-severities=critical表示只运行严重级别为critical的用例;
+
+
+Allure.dynamic
+
+可以动态添加测试步骤，支持Markdown语法,可以使用函数体内的数据动态生成.
+
+@allure.dynamic.description(“测试步骤”)
+
+@pytest.mark.parametrize("case",["case1","case2"])
+def test_4(self,case):
+ print(case)
+ allure.dynamic.title(case)
+
+
+Allure应用
+
+Allure测试用例
+
+打开data文件集下面的testcase.xlsx文件，查看测试数据的具体信息，根据这个信息，对allure报告的内容进行如下设置：
+sheet名称 feature 一级标签
+模块 story 二级标签
+用例ID+接口名称 title
+请求URL 请求类型 期望结果 实际结果描述
+
+
+import allure
+#allure
+#sheet名称 feature 一级标签
+allure.dynamic.feature(sheet_name)
+#模块 story 二级标签
+allure.dynamic.story(case_model)
+#用例ID+接口名称 title
+allure.dynamic.title(case_id+case_name)
+#请求URL 请求类型 期望结果 实际结果描述
+desc = "<font color='red'>请求URL: </font> {}<Br/>" \
+ "<font color='red'>请求类型: </font>{}<Br/>" \
+ "<font color='red'>期望结果: </font>{}<Br/>" \
+ "<font color='red'>实际结果: </font>{}".format(url,method,expect_result,res)
+allure.dynamic.description(desc)
+
+
+设置完成之后，每次都需要allure generate ./report/result -o ./report/html –clean来手动生成html报告，可以使用Subprocess来实现自动化生成报告。
+
+Subprocess是Python中的一个模块，用于创建新进程，连接到它们的输入/输出/错误管道，并获取它们的返回代码。
+
+方法：
+
+ - Subprocess.call()：父进程等待子进程，返回退出信息（returncode，相当于linux exit code）；0表示正常退出，非0表示异常退出。
+ - shell=True：表示使用shell执行命令，否则默认使用cmd执行命令;支持命令以字符串的形式传入，不需要再使用列表的形式传入。
+
+
+import subprocess
+
+
+res = subprocess.call(["ls","-l"])
+print(res) # 0代表正常退出，非0代表异常退出
+
+subprocess.call("ls -l",shell=True) # shell=True，支持命令以字符串的形式传入
+
+
+输出结果：
+
+总用量 4
+-rw-rw-r-- 1 hugo hugo 0 1月 30 10:00 __init__.py
+-rw-rw-r-- 1 hugo hugo 138 1月 30 10:06 subprocess_demo.py
+0
+总用量 4
+-rw-rw-r-- 1 hugo hugo 0 1月 30 10:00 __init__.py
+-rw-rw-r-- 1 hugo hugo 138 1月 30 10:06 subprocess_demo.py
+
+总用量 4
+-rw-rw-r-- 1 hugo hugo 0 1月 30 10:00 __init__.py
+-rw-rw-r-- 1 hugo hugo 138 1月 30 10:06 subprocess_demo.py
+0
+总用量 4
+-rw-rw-r-- 1 hugo hugo 0 1月 30 10:00 __init__.py
+-rw-rw-r-- 1 hugo hugo 138 1月 30 10:06 subprocess_demo.py
+
+进程已结束,退出代码0
+
+
+Allure项目运行
+
+在common文件夹下面的Base.py文件中，添加如下代码：(运用我们上一节学习的subprocess模块)
+
+def allure_report(report_path,report_html):
+ """
+ 生成allure 报告
+ :param report_path:
+ :param report_html:
+ :return:
+ """
+ #执行命令 allure generate
+ allure_cmd ="allure generate %s -o %s --clean"%(report_path,report_html)
+ #subprocess.call
+ log.info("报告地址")
+ try:
+ subprocess.call(allure_cmd,shell=True)
+ except:
+ log.error("执行用例失败，请检查一下测试环境相关配置")
+ raise
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/41/d33f07955143a150856e5c7add6fabb245cf033ca6cc9db26a4052d2146744 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/41/d33f07955143a150856e5c7add6fabb245cf033ca6cc9db26a4052d2146744
new file mode 100644
index 0000000000..e5eea2bbbf
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/41/d33f07955143a150856e5c7add6fabb245cf033ca6cc9db26a4052d2146744
@@ -0,0 +1,2 @@
+I"C包括yaml和Excel用例测试和数据驱动开发。
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/46/f37995d212e1a756871ef2a26cf13221de45e64f899d742c619ffd51353c72 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/46/f37995d212e1a756871ef2a26cf13221de45e64f899d742c619ffd51353c72
new file mode 100644
index 0000000000..ea953c2575
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/46/f37995d212e1a756871ef2a26cf13221de45e64f899d742c619ffd51353c72
@@ -0,0 +1,530 @@
+I":主要包括列表推导式，迭代器与生成器，装饰器，类的特殊方法（魔法方法），类的装饰器等等
+
+列表推导式
+
+square = []
+for i in range(10):
+ square.append(i**2)
+print(square)
+
+
+[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
+
+
+# 利用lambda表达式重构上述代码
+# map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。
+# list()函数可以将map()返回的Iterator转换为list
+Iterator = map(lambda x: x**2, range(10))
+square = list(Iterator)
+print(square)
+
+
+
+[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
+
+
+# 使用列表生成式
+square = [x**2 for x in range(10)]
+print(square)
+
+
+[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
+
+
+# 其他类型的列表表达式
+[x+y for x in 'ABC' for y in 'XYZ']
+
+
+['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']
+
+
+# 列表表达式中使用if语句
+[x for x in range(1, 11) if x % 2 == 0]
+
+
+[2, 4, 6, 8, 10]
+
+
+# 列表表达式中同时使用if语句和for语句
+[x for x in range(1, 11) if x % 2 == 0 for y in range(1, 11) if y % 3 == 0]
+
+
+
+[2, 2, 2, 4, 4, 4, 6, 6, 6, 8, 8, 8, 10, 10, 10]
+
+
+# 列表表达式中同时使用if语句和for语句
+print([(x,y) for x in [1,2,3] for y in [3,1,4] if x != y])
+# 等价于
+combination = []
+for x in [1,2,3]:
+ for y in [3,1,4]:
+ if x != y:
+ combination.append((x,y))
+print(combination)
+
+
+[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
+[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
+
+
+迭代器与生成器
+
+大多数容器对象都可以使用 for 语句，这种访问风格清晰、简洁又方便。 迭代器的使用非常普遍并使得 Python 成为一个统一的整体。 在幕后，for 语句会在容器对象上调用 iter()。 该函数返回一个定义了 __next__() 方法的迭代器对象，此方法将逐一访问容器中的元素。 当元素用尽时，__next__() 将引发 StopIteration 异常来通知终止 for 循环。
+
+for element in [1, 2, 3, 4, 5]:
+ print(element)
+
+
+1
+2
+3
+4
+5
+
+
+# 可以使用next()函数来调用__next__()方法的迭代器对象
+s = 'abc'
+it = iter(s)
+it
+print(next(it))
+print(next(it))
+print(next(it))
+print(next(it))
+
+
+a
+b
+c
+
+
+
+---------------------------------------------------------------------------
+
+StopIteration Traceback (most recent call last)
+
+<ipython-input-21-0603a1158441> in <module>
+ 6 print(next(it))
+ 7 print(next(it))
+----> 8 print(next(it))
+
+
+StopIteration:
+
+
+# 另外一种调用__next__()方法的方法
+n = iter([1, 2, 3])
+print(n.__next__())
+print(n.__next__())
+print(n.__next__())
+
+
+
+1
+2
+3
+
+
+# 第三种调用__next__()方法的方法
+n = iter([1, 2, 3])
+print(next(n))
+print(next(n))
+print(next(n))
+print(next(n))
+
+
+1
+2
+3
+
+
+
+---------------------------------------------------------------------------
+
+StopIteration Traceback (most recent call last)
+
+<ipython-input-27-39a89d3766fd> in <module>
+ 4 print(next(n))
+ 5 print(next(n))
+----> 6 print(next(n))
+
+
+StopIteration:
+
+
+看过迭代器协议的幕后机制，给你的类添加迭代器行为就很容易了。 定义一个 __iter__() 方法来返回一个带有 __next__() 方法的对象。 如果类已定义了__next__()，则 __iter__() 可以简单地返回 self:
+
+class Reverse:
+ """Iterator for looping over a sequence backwards."""
+ def __init__(self, data):
+ # 构造函数,初始化对象,传入一个可迭代对象,并将其转换为列表
+ self.data = data
+ self.index = len(data)
+
+ def __iter__(self): # 返回对象本身
+ return self
+
+ def __next__(self): # 返回下一个元素
+ if self.index == 0:
+ raise StopIteration
+ self.index = self.index - 1
+ return self.data[self.index]
+
+
+rev = Reverse('spam')
+iter(rev)
+for char in rev:
+ print(char)
+
+
+m
+a
+p
+s
+
+
+生成器
+生成器 是一个用于创建迭代器的简单而强大的工具。 它们的写法类似于标准的函数，但当它们要返回数据时会使用 yield 语句。 每次在生成器上调用 next() 时，它会从上次离开的位置恢复执行（它会记住上次执行语句时的所有数据值）。 一个显示如何非常容易地创建生成器的示例如下:
+
+with open('*.txt') as f:
+ for line in f:
+ print(line, end='')
+# 用生成器表达式来重构上述代码
+def read_file():
+ with open('*.txt') as f:
+ for line in f:
+ yield line
+
+
+---------------------------------------------------------------------------
+
+OSError Traceback (most recent call last)
+
+<ipython-input-33-96202d7342ea> in <module>
+----> 1 with open('*.txt') as f:
+ 2 for line in f:
+ 3 print(line, end='')
+
+
+OSError: [Errno 22] Invalid argument: '*.txt'
+
+
+def reverse(data):
+ for index in range(len(data)-1, -1, -1):
+ yield data[index]
+for char in reverse('spam'):
+ print(char)
+
+
+m
+a
+p
+s
+
+
+可以用生成器来完成的操作同样可以用前一节所描述的基于类的迭代器来完成。 但生成器的写法更为紧凑，因为它会自动创建 iter() 和 next() 方法。
+
+另一个关键特性在于局部变量和执行状态会在每次调用之间自动保存。 这使得该函数相比使用 self.index 和 self.data 这种实例变量的方式更易编写且更为清晰。
+
+除了会自动创建方法和保存程序状态，当生成器终结时，它们还会自动引发 StopIteration。 这些特性结合在一起，使得创建迭代器能与编写常规函数一样容易。
+
+装饰器
+在一些第三方库，比如说pytest中会使用到装饰器。
+Python-装饰器（wrapper）
+
+# 先理解函数的调用，也就是函数的传入参数可以是一个函数名
+def f1():
+ print('f1')
+def g(func):
+ print(func,type(func))
+ func()
+if __name__ == '__main__':
+ g(f1)
+
+
+<function f1 at 0x00000248DC9A2EE0> <class 'function'>
+f1
+
+
+import logging
+# logging.warning('Watch out!') # will print a message to the console
+logging.basicConfig(level=logging.DEBUG)
+def foo():
+ logging.info('执行foo函数')
+ print('foo')
+def bar():
+ logging.info('执行bar函数')
+ print('bar')
+if __name__ == '__main__':
+ foo()
+ bar()
+
+
+
+foo
+bar
+
+
+# 每个函数都写一遍logging.info()，这样会导致代码冗余，可以写个函数
+import logging
+logging.basicConfig(level=logging.DEBUG)
+def log(func):
+
+ logging.info(f'执行{func.__name__}函数')
+ return func()
+
+def foo():
+ print('foo')
+
+def bar():
+ print('bar')
+if __name__ == '__main__':
+ log(foo)
+ log(bar)
+
+
+foo
+bar
+
+
+# 函数还是太麻烦了，可以在函数里面再写一个函数
+# python装饰器用于拓展原来函数功能的一种函数，
+# 这个函数的返回值也是一个函数。
+
+
+import logging
+logging.basicConfig(level=logging.DEBUG)
+def use_logging(func): #装饰器函数
+ def wrapper():
+ logging.info(f'执行{func.__name__}函数')
+ func()
+ return wrapper
+def foo():
+ print('foo')
+def bar():
+ print('bar')
+if __name__ == '__main__':
+ foo = use_logging(foo)
+ foo()
+ bar = use_logging(bar)
+ bar()
+
+
+INFO:root:执行foo函数
+INFO:root:执行bar函数
+
+
+foo
+bar
+
+
+# 这样每次调用还要声明一下，太麻烦了，可以使用@符号装饰器的知识，这样就不用每次都声明了
+import logging
+logging.basicConfig(level=logging.DEBUG)
+def use_logging(func): # 装饰器函数，func是被装饰的函数
+ def wrapper():
+ logging.info(f'执行{func.__name__}函数')
+ func()
+ return wrapper
+@use_logging # 语法糖 @装饰器函数名 @等价于func = use_logging(func)
+# 每次调用函数的时候，都会先调用use_logging函数，然后再调用函数本身，这就是装饰器的作用
+def foo():
+ print('foo')
+@use_logging
+def bar():
+ print('bar')
+if __name__ == '__main__':
+ foo()
+ bar()
+
+
+INFO:root:执行foo函数
+INFO:root:执行bar函数
+
+
+foo
+bar
+
+
+# 装饰器@use_logging里面还可以加参数
+import logging
+logging.basicConfig(level=logging.DEBUG)
+def use_logging(level='info'): # 默认level级别是info
+ # 装饰器函数里面再增加一个装饰器
+ def decractor(func):
+ def wrapper(*args,**kwargs):
+ if level=='debug':
+ logging.debug(f'执行{func.__name__}函数')
+ elif level=='info':
+ logging.info(f'执行{func.__name__}函数')
+ elif level=='warning':
+ logging.warning(f'执行{func.__name__}函数')
+ elif level == 'error':
+ logging.error(f'执行{func.__name__}函数')
+ func(*args,**kwargs)
+ return wrapper
+ return decractor
+@use_logging()
+# 每次调用函数的时候，都会先调用use_logging函数，然后再调用函数本身，这就是装饰器的作用
+def foo():
+ print('foo')
+@use_logging(level = 'debug')
+def bar():
+ print('bar')
+if __name__ == '__main__':
+ foo()
+ bar()
+
+
+INFO:root:执行foo函数
+DEBUG:root:执行bar函数
+
+
+foo
+bar
+
+
+类的特殊方法 魔法方法
+在Python中以两个下划线开头的方法，init、str、doc、__new__等，被称为”魔术方法”（Magic methods）。魔术方法在类或对象的某些事件出发后会自动执行，如果希望根据自己的程序定制自己特殊功能的类，那么就需要对这些方法进行重写。
+
+# 最常见的是在class里面的init构造器
+class Config:
+ def __init__(self,baseip,port):
+ print('__init__')
+ self.baseip = baseip
+ self.port = port
+
+# 实例化一个类
+if __name__ == '__main__':
+ config = Config(baseip='127.0.0.1',port = 3000)
+ print(config.baseip)
+ print(config.port)
+
+
+__init__
+127.0.0.1
+3000
+
+
+class People(object):
+ # 创建对象
+ def __new__(cls, *args, **kwargs):
+ print("触发了构造方法")
+ ret = super().__new__(cls) # 调用父类的__new__()方法创建对象
+ return ret ## 将对象返
+ # 实例化对象
+ def __init__(self, name, age):
+ self.name = name
+ self.age = age
+ print("初始化方法")
+ # 删除对象
+ # del 对象名或者程序执行结束之后
+ def __del__(self):
+ print("析构方法，删除对象")
+
+
+if __name__ == '__main__':
+ p1 = People('xiaoming', 16)
+
+
+触发了构造方法
+初始化方法
+析构方法，删除对象
+
+
+# 斐波那契数列指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13
+# 特别指出：第0项是0，第1项是第一个1。从第三项开始，每一项都等于前两项之和。
+class Fib(object):
+ def __init__(self):
+ pass
+ def __call__(self,num):
+ a,b = 0,1;
+ self.l=[]
+
+ for i in range (num):
+ self.l.append(a)
+ a,b= b,a+b
+ return self.l
+ def __str__(self):
+ return str(self.l)
+ __rept__=__str__
+
+f = Fib()
+print(f(10))
+
+
+[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
+
+
+类的装饰器
+Python小技巧：装饰器(Decorator)
+
+
+
+class Foo:
+ def __init__(self,func):
+ self.func = func
+ def __call__(self,*args,**kwargs):
+ print('before __call__')
+ self.func()
+ print('after __call__')
+@Foo
+def bar():
+ print('bar')
+
+if __name__ == '__main__':
+ bar()
+
+
+before __call__
+bar
+after __call__
+
+
+import logging
+from functools import wraps
+
+from enum import Enum
+class Level(Enum):
+ debug = 0
+ info = 1
+ warn = 2
+ error = 3
+
+
+class UseLogging:
+
+ def __init__(self,level:Level):
+ self.level = level
+ logging.basicConfig(level=logging.DEBUG)
+
+
+ def __call__(self, func):
+ @wraps(func)
+ def decorator(*args, **kwargs):
+ if self.level == Level.debug:
+ logging.debug(f'正在执行{func.__name__}')
+ elif self.level == Level.info:
+ logging.info(f'正在执行{func.__name__}')
+ elif self.level == Level.warn:
+ logging.warning(f'正在执行{func.__name__}')
+ elif self.level == Level.error:
+ logging.error(f'正在执行{func.__name__}')
+ func(*args, **kwargs)
+ return decorator
+
+@UseLogging(level=Level.warn)
+def bar(name,**kwargs):
+ print('bar',name,kwargs)
+
+if __name__ == '__main__':
+ bar("xiaoming",k = 10)
+
+
+WARNING:root:正在执行bar
+
+
+bar xiaoming {'k': 10}
+
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/48/93a991101cf0a2ed76ef1aff2ac2d8f5f620f57f6858fe9bba188a8f8d1fce b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/48/93a991101cf0a2ed76ef1aff2ac2d8f5f620f57f6858fe9bba188a8f8d1fce
new file mode 100644
index 0000000000..de5b2e7808
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/48/93a991101cf0a2ed76ef1aff2ac2d8f5f620f57f6858fe9bba188a8f8d1fce
@@ -0,0 +1,96 @@
+I"代码
+
+# 添加当前时间信息
+echo "当前时间为$(date)" >> output.txt
+
+# 会输出包含 "model name" 字符串的行，即 CPU 型号的信息
+model_name=$(cat /proc/cpuinfo | grep "model name" | head -n 1 | cut -d ":" -f 2 | xargs)
+echo "CPU型号信息为$model_name" >> output.txt
+# 查看内核核心数量
+cpucores=$(cat /proc/cpuinfo | grep "cpu cores" | head -n 1 | cut -d ":" -f 2 | xargs)
+echo "内核核心数量为$cpucores" >> output.txt
+# 查看系统 CPU 使用情况
+echo "系统 CPU 使用情况如下：" >> output.txt
+iostat -c | awk '{if(NR==4){print "CPU繁忙度: "$1"%"} }' >> output.txt
+iowait=$(iostat -c | awk '{if(NR==4){print $4} }')
+if [ $(echo "$iowait >=60" | bc -l) -eq 1 ];
+then
+ echo "CPU等待输入输出完成时间的百分比为$iowait%,过高，表示硬盘存在I/O瓶颈。" >> output.txt
+else
+ echo "CPU等待输入输出完成时间的百分比为$iowait%,正常。" >> output.txt
+fi
+# 如果%idle值高，表示CPU较空闲
+# 如果%idle值持续低于10，表明CPU处理能力相对较低，系统中最需要解决的资源是CPU。
+idle=$(iostat -c | awk '{if(NR==4){print $6} }')
+if [ $(echo "$idle >= 90" | bc -l) -eq 1 ];
+then
+ echo "CPU较空闲，%idle值为$idle" >> output.txt
+elif [ $(echo "$idle < 10" | bc -l) -eq 1 ];
+then
+ echo "CPU处理能力相对较低，idle值为$idle%" >> output.txt
+fi
+
+
+# 输出系统总内存
+MemTotal=$(cat /proc/meminfo | grep "MemTotal" | cut -d ":" -f 2 | xargs)
+echo "系统总内存为$MemTotal" >> output.txt
+# 查看系统空闲内存大小
+MemFree=$(cat /proc/meminfo | grep "MemFree" | cut -d ":" -f 2 | xargs)
+echo "系统空闲内存为$MemFree" >> output.txt
+# Cached：分配给文件缓冲区的内存（比如未保存的文件就是写到该缓冲区）
+Cached=$(cat /proc/meminfo | grep "Cached" | head -n 1 | cut -d ":" -f 2 | xargs)
+echo "分配给文件缓冲区的内存（比如未保存的文件就是写到该缓冲区）为$Cached。" >> output.txt
+
+# 查看磁盘信息
+echo "磁盘容量信息如下：" >> output.txt
+df -h | sort -k 4 -hr | grep "文件系统" >> output.txt
+df -h | sort -k 4 -hr | grep -v "文件系统" | grep -v "tmpfs" >> output.txt
+
+# 查看网络
+PingInfo=$(ping -c 5 www.baidu.com | grep "bytes from" | head -n 1 )
+echo "通过ping访问百度得到的信息如下：\n $PingInfo">> output.txt
+PingStatics=$(ping -c 5 www.baidu.com | grep "1 packets transmitted" | head -n 1 )
+echo "$PingStatics">> output.txt
+
+rtt=$(ping -c 5 www.baidu.com | grep "rtt" | cut -d "=" -f 2 | head -n 1 )
+rttmin=$(echo $rtt | cut -d "/" -f 1)
+rttavg=$(echo $rtt | cut -d "/" -f 2)
+rttmax=$(echo $rtt | cut -d "/" -f 3)
+rttmdev=$(echo $rtt | cut -d "/" -f 4)
+echo "网络最小时延为$rttmin ms" >> output.txt
+echo "网络平均时延为$rttavg ms" >> output.txt
+echo "网络最大时延为$rttmax ms" >> output.txt
+echo "网络时延平均偏差为$rttmdev" >> output.txt
+
+# perf性能瓶颈分析，查看哪些进程占用CPU较高
+# 安装命令
+# apt-get install linux-tools-$(uname -r) linux-tools-generic -y
+# https://blog.51cto.com/liuzhengwei521/2360430
+#echo "CPU性能瓶颈分析如下：" >> output.txt
+#perf top -b -p $(pidof nginx) >> output.txt
+
+
+# 查看系统负载
+# https://blog.51cto.com/ghostwritten/5344990
+# 对CPU进行压力测试
+#cpu_number=$(grep -c 'processor' /proc/cpuinfo)
+#创建8个stress进程和100个io进程，持续时间600秒，模拟CPU在用户态和内核态总使用率达到100%的场景。
+#stress -c $cpu_number -i 100 --verbose --timeout 600
+
+# 对内存进行压力测试
+# 下面例子，就是创建5个进程，同时去malloc分配内存，并且保持100s后再释放内存：
+# stress --vm 5 --vm-bytes 1G --vm-hang 100 --timeout 100s
+# stress 测试内存的时候，--vm-bytes 1G --vm-hang 100 这里2个参数是关键！！！！
+# --vm-bytes 表示malloc分配多少内存
+# --vm-hang 表示malloc分配的内存多少时间后在free()释放掉
+# --vm 指定进程数量，分配的内存总数为vm*vm-bytes
+# --timeout 持续时间
+
+# 对磁盘进行压力测试，并输出结果到文件
+# stress --hdd 2 --hdd-bytes 3G --timeout 200
+# -hdd forks 产生多个执行write()函数的进程
+# --hdd-bytes bytes 指定写的Bytes数，默认是1GB
+
+
+结果
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/49/ce37d440d936db2308420be070d0c64679dadec31486ee111f6b89d48b5950 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/49/ce37d440d936db2308420be070d0c64679dadec31486ee111f6b89d48b5950
new file mode 100644
index 0000000000..6be885074f
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/49/ce37d440d936db2308420be070d0c64679dadec31486ee111f6b89d48b5950
@@ -0,0 +1,3 @@
+I".联系方式
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/49/f3c7935296cdcfc4c39dfc7f4189b0ce084e1df0d42352b911e90d4332353b b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/49/f3c7935296cdcfc4c39dfc7f4189b0ce084e1df0d42352b911e90d4332353b
new file mode 100644
index 0000000000..48010c65a6
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/49/f3c7935296cdcfc4c39dfc7f4189b0ce084e1df0d42352b911e90d4332353b
@@ -0,0 +1,11 @@
+I"
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/4a/9c8389ea75cf48fa4b027a946219f65753e2211d90b4b1c991d799bf43c2d6 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/4a/9c8389ea75cf48fa4b027a946219f65753e2211d90b4b1c991d799bf43c2d6
new file mode 100644
index 0000000000..e65163f4cf
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/4a/9c8389ea75cf48fa4b027a946219f65753e2211d90b4b1c991d799bf43c2d6
@@ -0,0 +1,16 @@
+I"
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/4b/a388856166733cdfceec511f069df53f4e95640ba363ac2d0d74b7276c6cef b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/4b/a388856166733cdfceec511f069df53f4e95640ba363ac2d0d74b7276c6cef
new file mode 100644
index 0000000000..2eb89e0221
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/4b/a388856166733cdfceec511f069df53f4e95640ba363ac2d0d74b7276c6cef
@@ -0,0 +1,183 @@
+I"1. 数据来源
+
+kaggle-Wind Farms
+
+2. 数据探索
+
+import numpy as np # linear algebra
+import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
+import matplotlib.pyplot as plt
+from mpl_toolkits.basemap import Basemap
+
+# Input data files are available in the "../input/" directory.
+# For example, running this (by clicking run or pressing Shift+Enter) will list the files in the input directory
+
+from subprocess import check_output
+print(check_output(["ls", "../input"]).decode("utf8")) # ls表示列出当前目录下的文件,check_output表示执行命令,decode表示解码
+
+wtfile='../input/windTurbines.csv'
+wtdat=pd.read_csv(wtfile)
+print(wtdat.head())
+
+结果如下：
+
+ FID unique_id site_name total_turb \
+0 0 982 unknown Gilliam County 2
+1 1 1065 unknown Gilliam County 2
+2 2 1895 Banner Wind Project 2
+3 3 1897 Banner Wind Project 2
+4 4 2608 unknown Tehachapi Wind Resource Area 1 549
+
+ on_year year_range on_year_s manufac model type_tower ... \
+0 unknown unknown -99999 unknown unknown unknown ...
+1 unknown unknown -99999 unknown unknown unknown ...
+2 2008 no 2008 Entegrity EW50 trestle ...
+3 2008 no 2008 Entegrity EW50 trestle ...
+4 1982_1990 yes 1982 unknown unknown monopole ...
+
+ conf_attr conf_loc WENDI_name EIA_name FAA_jdate FAA_AGL \
+0 0 0 unknown unknown 2013192 124.09
+1 0 0 unknown unknown 2013192 124.09
+2 2 2 Banner Wind Project unknown 2009065 38.72
+3 2 2 Banner Wind Project unknown 2009065 38.72
+4 0 2 unknown unknown -99999 -99999.00
+
+ FAA_ORS image_name image_year \
+0 41-020577 Bing Maps Aerial unknown
+1 41-020578 Bing Maps Aerial unknown
+2 02-020064 Bing Maps Aerial unknown
+3 02-020070 Bing Maps Aerial unknown
+4 unknown NAIP 2012
+
+ comments
+0 FAA lists as Dismantle, google temporal analys...
+1 FAA lists as Dismantle, google temporal analys...
+2 trestle turbines removed, new monopoles instal...
+3 trestle turbines removed, new monopoles instal...
+4
+
+[5 rows x 32 columns]
+
+
+数据描述如下：
+
+字段名称 解释说明
+
+FID 文件编码ID
+
+unique_id 唯一识别码
+
+site_name 地点名称
+
+total_turb 发电机数量
+
+on_year 服役时间
+
+year_range 服役时间区间
+
+on_year_s 服役开始时间
+
+manufac 制造商
+
+model 型号
+
+type_tower tower的种类
+
+decommiss 是否退役
+
+MW_turbine 电机的MW
+
+total_cpcy 总的cpcy
+
+total_ht 总的高度
+
+tower_h tower的高度
+
+blade_l 叶片的长度
+
+rotor_dia 电机转子的直径
+
+rotor_s_a 电机转子的面积
+
+lat_DD 纬度
+
+long_DD 经度
+
+state 所属的州
+
+county 所属的郡
+
+conf_attr conf的attr
+
+conf_loc conf的位置
+
+WENDI_name WENDI的名称
+
+EIA_name EIA的名称
+
+FAA_jdate FAA的注册日期
+
+FAA_AGL FAA的AGL
+
+FAA_ORS FAA的ORS
+
+image_name 照片名称
+
+image_year 照片年份
+
+comments 评论
+
+3. 数据可视化
+
+在可视化之前，应该还需要对数据进行预处理，比如去除缺失值，去除重复值等等。
+
+#% setup the map
+fig,ax=plt.subplots(figsize=(20,10))
+
+c1=(-127.6+66.1)/2
+c2=(50.5+23.2)/2
+m = Basemap(resolution='i', # c, l, i, h, f or None
+ projection='merc',
+ lat_0=c2, lon_0=c1,
+ llcrnrlon=-127.6, llcrnrlat= 23.2, urcrnrlon=-66.1, urcrnrlat=50.5)
+# lat_0表示地图中心的纬度，lon_0表示地图中心的经度
+# llcrnrlon表示西经，llcrnrlat表示南纬，urcrnrlon表示东经，urcrnrlat表示北纬
+
+# draw the map
+m.drawmapboundary(fill_color='#46bcec') # 设置地图边界颜色, #46bcec是蓝色
+m.fillcontinents(color='#f2f2f2',lake_color='#46bcec')
+# 设置陆地颜色,#f2f2f2是灰色,lake_color是湖泊颜色,#46bcec是蓝色
+m.drawcoastlines(linewidth=0.5)
+m.drawcountries(linewidth=0.5)
+m.drawstates(linewidth=0.5)
+x,y=m(np.array(wtdat['long_DD']),np.array(wtdat['lat_DD']))
+
+# plot each turbine with marker size based on machine size
+
+# Check the number of missing values in 'MW_turbine'
+print("Number of missing values in 'MW_turbine':", wtdat['MW_turbine'].isnull().sum())
+
+
+mx=wtdat['MW_turbine'].max() # 最大的MW,MW_turbine表示电机的MW
+for i in range(len(wtdat)):
+ if wtdat['MW_turbine'].loc[i]>0:
+ m.plot(x[i],y[i],'o',
+ color='red',
+ markersize=wtdat['MW_turbine'].loc[i]/mx*15,
+ alpha=0.25,
+ markeredgecolor='none')
+ else:
+ m.plot(x[i],y[i],
+ 'x',
+ color='brown') # x表示叉号
+
+plt.show()
+fig.savefig('WindTurbineMap.png',orientation='landscape',dpi=600)
+
+
+这段代码的含义是，首先设置地图的中心点，然后绘制地图，最后绘制风力发电机的位置，其中地图上的散点的大小是根据风力发电机的MW来决定的。
+
+运行结果如下：
+
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/4d/66527a1c13334114e501c3fc4ce1170ffaaf00f7c8791b1cb51728413e91c0 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/4d/66527a1c13334114e501c3fc4ce1170ffaaf00f7c8791b1cb51728413e91c0
new file mode 100644
index 0000000000..838451edb5
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/4d/66527a1c13334114e501c3fc4ce1170ffaaf00f7c8791b1cb51728413e91c0
@@ -0,0 +1,283 @@
+I".1. pytest简介
+Pytest 是一个比较成熟且功能完备的 Python 测试框架。其提供完善的在线文档，并有着大量的第三方插件和内置帮助，适用于许多小型或大型项目。Pytest 灵活易学，打印调试和测试执行期间可以捕获标准输出，适合简单的单元测试到复杂的功能测试。还可以执行 nose, unittest 和 doctest 风格的测试用例，甚至 Django 和 trial。支持良好的集成实践， 支持扩展的 xUnit 风格 setup，支持非 python 测试。支持生成测试覆盖率报告，支持 PEP8 兼容的编码风格。
+
+2. pytest安装
+pip install pytest
+
+
+3. pytest基本使用
+3.1 pytest命令行参数
+py.test [options] [file_or_dir] [file_or_dir] [...]
+
+3.1.1 常用参数
+py.test -h,--help # 查看命令行和配置文件帮助
+pytest --markers # 查看所有的标记标记
+
+
+-l,--showlocals #在traceback中显示本地变量
+-q,--quiet #减少输出
+--collect-only：只收集测试用例，不执行测试用例
+-v,--verbose #详细输出
+# 调试输出
+-x：遇到用例失败后，停止执行后面的用例
+--maxfail=num：最多允许num个测试用例失败，后面的用例不再执行
+--pdb：当测试用例失败时，进入调试模式
+--tb=style：指定traceback的输出风格
+ - long：完整的traceback信息
+ - short：只显示每个失败用例的第一行信息
+ - no：不显示traceback信息
+ - native：使用C语言的格式化1输出traceback信息
+-m MARKEXPR：只运行标记了指定标记的用例
+
+
+3.2 执行选择用例
+
+# 执行单个模块中的全部用例
+pytest test_module.py
+# 执行单个类中的全部用例
+pytest test_module.py::TestClass
+# 执行单个方法
+pytest test_module.py::TestClass::test_method
+# 执行指定module中的某个测试函数
+pytest test_module.py::test_func
+
+# 执行指定路径下的全部用例
+pytest test_dir/
+# 执行字符串匹配的用例
+pytest -k "string_expression"
+# 执行标记为smoke的用例
+pytest -m smoke
+# 执行标记为smoke且用例名中包含add的用例
+pytest -k "add and smoke"
+# 执行标记为smoke或用例名中包含add的用例
+pytest -k "add or smoke"
+# 导入模块，使用其文件系统中的路径来查找和执行用例，执行pkg包中的全部用例
+pytest --pyargs pkg # pyargs参数,pkg是包名
+
+3.3 断言
+
+通常情况下使用 assert 语句就能对大多数测试进行断言。对于异常断言，可以使用上下文管理器 pytest.raises：
+
+# 断言异常,可以使用上下文管理器**pytest.raises**
+def test_divide_by_zero():
+ with pytest.raises(ZeroDivisionError):
+ 1 / 0 # 在这里抛出异常，断言成功
+# 还可以使用pytest.raises的context manager的value属性来获取异常信息
+def test_divide_by_zero():
+ with pytest.raises(ZeroDivisionError) as excinfo: #excinfo是异常信息
+ 1 / 0
+ assert 'division by zero' in str(excinfo.value)
+# 捕捉异常信息还包括
+def test_divide_by_zero():
+ with pytest.raises(ZeroDivisionError,message=" integer division or modulo by zero"):
+ 1 / 0
+# 对于警告断言，可以使用pytest.warns（上下文管理器）：
+# UserWarning是警告类型,match是匹配的字符串
+with pytest.warns(UserWarning,match='must be 0 or None'):
+ warnings.warn("my warning", UserWarning)
+with pytest.warns(RuntimeWarning):
+ warnings.warn("my warning", RuntimeWarning)
+
+对于自定义的assert比较断言，还可以通过在conftest.py中定义pytest_assertrepr_compare函数来实现：
+
+
+# content of test_foocompare.py
+class Foo:
+ def __init__(self, val):
+ self.val = val
+
+ def __eq__(self, other):
+ return self.val == other.val
+
+def test():
+ assert 1 == 1
+
+def test_compare():
+ f1 = Foo(1)
+ f2 = Foo(2)
+ f3 = Foo(1)
+ assert f1 == f3
+ assert f1 == f2
+
+
+# content of conftest.py
+def pytest_assertrepr_compare(op, left, right):
+ from test_foocompare import Foo
+ if isinstance(left, Foo) and isinstance(right, Foo) and op == "==":
+ return ['Comparing Foo instances:', 'vals: %s != %s' % (left.val, right.val)]
+
+
+如果需要手动设置断言失败的信息，可以使用pytest.fail函数：
+
+def test_fail():
+ pytest.fail("manual fail")
+
+def test_sys_version():
+ # skip test if not running on Python 3.x
+ if sys.version_info < (3, 0):
+ pytest.fail("requires python3")
+
+
+3.4 跳过用例
+
+# 跳过用例
+@pytest.mark.skip(reason="no way of currently testing this")
+def test_function():
+ pass
+# 跳过用例，如果条件为真
+@pytest.mark.skipif(sys.version_info < (3, 0), reason="requires python3")
+def test_function():
+ pass
+# 跳过用例，如果条件为假
+@pytest.mark.skipif(sys.version_info >= (3, 0), reason="requires python3")
+def test_function():
+ pass
+
+
+使用 pytest.skip 和 pytest.xfail 能够实现跳过测试的功能，skip 表示直接跳过测试，而 xfail 则表示存在预期的失败，但两者的效果差不多：
+
+def test_skip_and_xfail():
+ if sys.version_info[0] < 3:
+ pytest.skip("requires python3")
+ else:
+ pytest.xfail("xfail on python3")
+
+
+pytest.importorskip 函数可以用来跳过测试，如果导入模块失败：
+
+# 跳过用例，如果导入模块失败
+def test_importorskip():
+ pytest.importorskip("this_module_does_not_exist")
+# 要求导入的模块的版本号大于等于指定的版本号
+def test_importorskip():
+ pytest.importorskip("this_module_does_not_exist", minversion="1.0")
+
+断言近似相等时，可以使用pytest.approx函数：
+
+def test_approx():
+ assert 0.1 + 0.2 == pytest.approx(0.3)
+def test_approx2():
+ assert 2.2==pytest.approx(2.3,rel=0.1) # rel是相对误差
+
+
+3.5 conftest.py
+从广义理解，conftest.py是一个配置文件，可以用来配置pytest的运行环境，从狭义理解，conftest.py是一个pytest的插件，可以用来定义pytest的fixture、hook函数、命令行参数等。conftest.py文件可以放在测试用例所在的目录下，也可以放在测试用例所在目录的上一级目录下，如果放在上一级目录下，那么该目录下的所有子目录都会加载该conftest.py文件。
+
+conftest.py文件功能如下：
+
+
+# content of conftest.py
+import pytest
+
+def pytest_addoption(parser):
+ parser.addoption("--full", action="store_ture",
+ help="run full test")
+
+# content of test.py
+@pytest.mark.skipif(not pytest.config.getoption("--runslow"))
+def test_func_slow_1():
+ """当在命令行执行 --runslow 参数时才执行该测试"""
+ print 'skip slow'
+
+
+3.6 Fixture
+Fixture 是 pytest 特有的功能，它用 pytest.fixture 标识，定义在函数前面。在编写测试函数的时候，可以将此函数名称做为传入参数，pytest 将会以依赖注入方式，将该函数的返回值作为测试函数的传入参数。
+
+@pytest.fixture
+def login():
+ print("登录操作")
+ username
+ return username
+def test_soso(login):
+ print(f"搜索{login}")
+def test_cart(login):
+ print(f"添加购物车{login}")
+
+
+fixture 的作用域 fixture 的作用域默认是函数级别的，也就是说，每个测试用例都会执行一次 fixture 函数。如果想要在多个测试用例中使用 fixture 函数的返回值，可以将 fixture 的作用域设置为模块级别.
+
+
+ - function：默认值，每个测试用例都会执行一次 fixture 函数；
+ - module: 每个模块加载前执行一次；
+ - session：每个会话加载前执行一次；
+
+
+3.7 Markers
+
+marker 是 pytest 特有的功能，它用于给测试用例打标签，可以用于过滤测试用例，也可以用于给测试用例分类。
+
+# 跳过测试
+@pytest.mark.skip(reason="no way of currently testing this")
+# 满足某个条件时跳过测试
+@pytest.mark.skipif(sys.version_info < (3, 3), reason="requires python3.3+")
+# 期望测试失败
+@pytest.mark.xfail(condition, reason, run=True, raises=None, strict=False)
+# 参数化测试函数，给测试用例传入参数，供运行时填充到测试中
+@pytest.mark.parametrize(argnames, argvalues, indirect=False, ids=None, scope=None)
+# 执行某一类测试用例
+pytest -m smoke
+# 测试顺序
+@pytest.mark.run(order=1)
+# 让测试尽早地被执行
+@pytest.mark.tryfirst
+# 让测试尽晚地被执行
+@pytest.mark.trylast
+
+
+
+3.8 生成测试报告
+
+3.9 第三方插件
+
+pytest-randomly: 测试顺序随机
+
+pytest-ordering: 测试顺序控制
+
+pytest-xdist: 分布式测试
+
+pytest-cov: 生成测试覆盖率报告
+
+pytest-rerunfailures: 失败重试
+
+pytest-timeout: 超时测试，允许在命令行指定超时时间，或者直接在测试代码中标注超时时间。
+
+pytest-repeat: 重复测试(可以使用–count参数指定重复次数)
+
+pytest-instafail: 测试失败时立即停止，查看错误的详细信息。
+
+pytest-sugar: 优化测试报告,显示色彩和进度条
+
+pytest-html: 为测试生成HTML报告
+pytest --html=report.html
+
+
+
+静态分析用的插件
+
+pytest-pycodestyle:
+
+
+pytest-pep8: 检测代码是否符合 PEP8 规范
+
+pytest-flakes: 检测代码风格
+
+
+
+Web开发用的插件：
+Web项目有特定的测试逻辑，pytest也不能让测试变简单，但是有几个插件可以帮忙。
+
+pytest-django: 用于测试 Django 项目，Django是很流行的基于Python的web开发框架，它本身包含用于测试的hook函数，允许测试Django应用的各个组件，Django测试使用的是unittest；
+
+pytest-selenium:借助浏览器完成自动化测试，比如说启动一个web浏览器，打开网址URL，运行web应用；
+
+pytest-flask：测试Flask应用，Flask是一个轻量级的web框架,pytest-flask插件提供了一组很有用的fixture来帮助Flask应用；
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/4e/f47eab595eb52d9e12b1a2f2bc8988c787f0c8155dd59dce1dbef6e4fda321 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/4e/f47eab595eb52d9e12b1a2f2bc8988c787f0c8155dd59dce1dbef6e4fda321
new file mode 100644
index 0000000000..b35e59811a
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/4e/f47eab595eb52d9e12b1a2f2bc8988c787f0c8155dd59dce1dbef6e4fda321
@@ -0,0 +1,8 @@
+I"2
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/4f/65da3016c9f3f4ad88467e1d7f66a4ae118bb8ab24683c709623ae3e05ece0 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/4f/65da3016c9f3f4ad88467e1d7f66a4ae118bb8ab24683c709623ae3e05ece0
new file mode 100644
index 0000000000..ad1ff6dd1d
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/4f/65da3016c9f3f4ad88467e1d7f66a4ae118bb8ab24683c709623ae3e05ece0
@@ -0,0 +1,9 @@
+I"
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/52/5773bd3b62123de1f97859b66c64fd7de4f6efda159fa1183c8d91de7e6780 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/52/5773bd3b62123de1f97859b66c64fd7de4f6efda159fa1183c8d91de7e6780
new file mode 100644
index 0000000000..b054c35895
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/52/5773bd3b62123de1f97859b66c64fd7de4f6efda159fa1183c8d91de7e6780
@@ -0,0 +1,2 @@
+I"UExcel参数化之参数化运行
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/52/7aa5512bd1ee1e0387def21aad45c79540e24818a86513295ba17bccf2fe42 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/52/7aa5512bd1ee1e0387def21aad45c79540e24818a86513295ba17bccf2fe42
new file mode 100644
index 0000000000..ac98d1993d
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/52/7aa5512bd1ee1e0387def21aad45c79540e24818a86513295ba17bccf2fe42
@@ -0,0 +1,14 @@
+I"
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/53/7fcffef9ff8b359b4f9a7fa30b4b7d6e1b1e8328d379972bbd53bfe0d18ae7 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/53/7fcffef9ff8b359b4f9a7fa30b4b7d6e1b1e8328d379972bbd53bfe0d18ae7
new file mode 100644
index 0000000000..586f59976f
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/53/7fcffef9ff8b359b4f9a7fa30b4b7d6e1b1e8328d379972bbd53bfe0d18ae7
@@ -0,0 +1,23 @@
+I"
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/54/294d345a050b453de9936be52c9c058a8f7b35aa40b4278545852932f3ecf4 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/54/294d345a050b453de9936be52c9c058a8f7b35aa40b4278545852932f3ecf4
new file mode 100644
index 0000000000..551c8841f4
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/54/294d345a050b453de9936be52c9c058a8f7b35aa40b4278545852932f3ecf4
@@ -0,0 +1,2 @@
+I"主要包括Yaml文件的语法规则，安装方法，Yaml的编写规则，读取方法，Yaml的封装，以及如何在config文件夹下面简历config.yaml配置文件以实现测试用例和测试数据分离。
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/54/82915f099e32f6acec059c1b2eda732c2023b9bef2389fed011cdf2ff51935 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/54/82915f099e32f6acec059c1b2eda732c2023b9bef2389fed011cdf2ff51935
new file mode 100644
index 0000000000..61aa482a8c
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/54/82915f099e32f6acec059c1b2eda732c2023b9bef2389fed011cdf2ff51935
@@ -0,0 +1,327 @@
+I"mB高效的函数
+
+函数是 Python 的头等对象
+
+Python 程序中的所有数据都是由对象或对象之间的关系来表示的。①字符串、列表和模块等都是对象。Python 中的函数也不例外，同样是对象。
+
+由于 yell 函数是 Python 中的一个对象，因此像任何其他对象一样，也可以将其分配给另一
+个变量：
+
+def yell(text):
+ return text.upper()+"!"
+bark = yell # 这一行没有调用函数，而是获取 yell 引用的函数对象，再创建一个指向该对象的名称 bark。
+# 现在调用 bark 就可以执行相同的底层函数对象
+bark('hello') # 'HELLO!'
+
+
+此时，删除 yell 的引用，不会影响 bark 的引用：
+
+del yell
+yell('hello') # NameError: name 'yell' is not defined
+bark('hello') # 'HELLO!'
+
+
+Python在创建函数时为每个函数附加了一个用于调试的字符串标识符，使用函数的 name 属性可以访问该标识符：
+
+bark.__name__ # 'yell'
+
+
+虽然函数的__name__仍然是 yell，但已经无法用这个名称在代码中访问函数对象。名称标识符仅仅用来辅助调试，指向函数的变量和函数本身实际上是彼此独立的。
+
+函数可以传递给其他函数
+
+由于函数是对象，因此可以将其作为参数传递给其他函数。将函数对象作为参数传递给其他函数的功能非常强大，可以用来将程序中的行为抽象出来并传递出去。
+
+def greet(func):
+ greeting = func("Hi, I am a Python program")
+ print(greeting)
+greet(bark) # 'HI, I AM A PYTHON PROGRAM!'
+
+向 greet 函数传递 bark 函数，greeting = bark(“Hi, I am a Python program”) = “HI, I AM A PYTHON PROGRAM!”，然后打印出来。
+
+能接受其他函数作为参数的函数被称为高阶函数。高阶函数是函数式编程风格中必不可少的一部分。
+
+Python 中具有代表性的高阶函数是内置的 map 函数。map 接受一个函数对象和一个可迭代对象，然后在可迭代对象中的每个元素上调用该函数来生成结果。map 返回一个迭代器，可以使用 list 函数将其转换为列表。
+
+list(map(bark,['hello','hey','hi'])) # ['HELLO!', 'HEY!', 'HI!']
+
+
+map 遍历整个列表并将 bark 函数应用于每个元素，然后将结果放入一个列表中。
+
+函数可以嵌套
+
+Python 允许在函数中定义函数，这通常被称为嵌套函数或内部函数。
+
+def speak(text):
+ def whisper(t):
+ return t.lower()+"..."
+ return whisper(text)
+speak('Hello, World') # 'hello, world...'
+
+
+每次调用 speak 时，都会定义一个新的内部函数 whisper 并立即调用。’Hello, World’被传递给text参数，然后whisper函数被调用，返回whisper(‘Hello, World’) = ‘hello, world…‘,最后speak函数返回这个值。
+
+内部函数可以访问外部函数的局部变量，但外部函数不能访问内部函数的局部变量。也就是说whisper函数可以访问speak函数的text参数，但speak函数不能访问whisper函数的t参数。
+
+whisper('Hello, World') # NameError: name 'whisper' is not defined
+
+
+whisper 函数的作用域仅限于 speak 函数，因此在 speak 函数外部无法访问它。
+
+那怎么才能从 speak 外部访问嵌套的 whisper 函数呢？由于函数是对象，因此可以将内部函数返回给父函数的调用者.
+
+例如，下面这个函数定义了两个内部函数。顶层函数根据传递进来的参数向调用者返回对应的内部函数：
+
+def get_speak_func(text, volume):
+ def whisper():
+ return text.lower()+"..."
+ def yell():
+ return text.upper()+"!"
+ if volume > 0.5:
+ return yell
+ else:
+ return whisper
+get_speak_func('Hello, World', 0.7) # <function get_speak_func.<locals>.yell at 0x7f9b8c0b0d08>
+get_speak_func('Hello, world',0.3) # <function get_speak_func.<locals>.whisper at 0x7f9b8c0b0c80>
+
+
+也就是说，get_speak_func 实际上不调用任何内部函数，只是根据 volume 参数选择适当的内部函数，然后返回这个函数对象。
+
+如何调用这个函数对象呢？可以像调用普通函数一样调用它：
+
+speak_func = get_speak_func('Hello, World', 0.7)
+speak_func('Hello') # 'HELLO!'
+
+
+这意味着函数不仅可以通过参数接受行为，还可以返回行为。这里的 speak_func 函数就是一个行为。
+
+函数可捕捉局部状态
+
+内部函数不仅可以从父函数返回，还可以捕获并携带父函数的某些状态。
+
+下面对前面的 get_speak_func 示例做些小改动来逐步说明这一点。新版在内部就会使用
+volume 和 text 参数，因此返回的函数是可以直接调用的：
+
+def get_speak_func(text, volume):
+ def whisper():
+ return text.lower()+"..."
+ def yell():
+ return text.upper()+"!"
+ if volume > 0.5:
+ return yell()
+ else:
+ return whisper()
+
+
+仔细看看内部函数 whisper 和 yell，注意其中并没有 text 参数。但不知何故，内部函数仍然可以访问在父函数中定义的 text 参数。它们似乎捕捉并“记住”了这个参数的值。
+拥有这种行为的函数被称为词法闭包（lexical closure），简称闭包。闭包在程序流不在闭包范围内的情况下，也能记住封闭作用域（enclosing scope）中的值.
+
+词法闭包的一个重要特性是，它们可以捕捉并携带封闭作用域中的状态。这意味着函数不仅可以返回行为，还可以预先配置这些行为。
+
+def make_adder(n):
+ def add(x):
+ return x + n
+ return add # 返回函数对象
+plus_3 = make_adder(3) # plus_3 是一个add函数
+plus_3(4) # 7
+plus_5 = make_adder(5) # plus_5 是一个add函数,但是n的值不同
+plus_5(4) # 9
+
+在这个例子中，make_adder 作为工厂函数来创建和配置各种 adder 函数。注意，这些 adder函数仍然可以访问 make_adder 函数中位于封闭作用域中的参数n。
+
+对象也可以作为函数使用
+
+虽然 Python 中的所有函数都是对象，但反之不成立。有些对象不是函数，但依然可以调用，因此在许多情况下可以将其当作函数来对待。
+
+如果一个对象是可调用的，意味着可以使用圆括号函数调用语法，甚至可以传入调用参数。
+这些都由__call__双下划线方法完成。
+
+class Adder:
+ def __init__(self, n):
+ self.n = n
+ def __call__(self, x):
+ return self.n + x # self.n 是Adder对象的属性，x是调用时传入的参数
+plus_3 = Adder(3) # plus_3 是一个Adder对象,调用__init__方法
+# 在幕后，像函数那样“调用”一个对象实例实际上是在尝试执行该对象的__call__方法
+plus_3(4) # 7，调用__call__方法，返回self.n + x
+
+
+在这个例子中，Adder 类的实例可以像函数一样被调用。这是因为 Adder 类定义了__call__方法，这个方法的实现就是一个函数。当然，并不是所有的对象都可以调用，因此 Python 内置了 callable 函数，用于检查一个对象是否可以调用。
+
+lambda 是单表达式函数
+
+你可能想知道 lambda 有什么独特之处：如果只是比用 def 声明函数稍微方便一点，那有什么大不了的？
+
+来看下面的例子，同时脑海里要记着函数表达式这个概念：
+
+(lamba x,y:x+y)(5,3)# 8,lambda表达式的结果是一个函数对象，意味着可以使用圆括号函数调用语法，圆括号之后的参数是传入函数的参数
+
+
+从概念上讲，lambda 表达式 lambda x，y：x + y 与用 def 声明函数相同，但从语法上来说表达式位于 lambda 内部。两者的关键区别在于，lambda 不必先将函数对象与名称绑定，只需在 lambda 中创建一个想要执行的表达式，然后像普通函数那样立即调用进行计算。
+
+lambda 和普通函数定义之间还有另一个语法差异。lambda 函数只能含有一个表达式，这意味着 lambda 函数不能使用语句或注解（annotation），甚至不能使用返回语句。
+那么应该如何从 lambda 返回值呢？执行 lambda 函数时会计算其中的表达式，然后自动返回表达式的结果，所以其中总是有一个隐式的返回表达式。因此有些人把 lambda 称为单表达式函数。
+
+lambda 的用途
+
+从技术上讲，每当需要提供一个函数对象时，就可以使用 lambda 表达式。而且，因为 lambda 是匿名的，所以不需要先分配一个名字.
+
+比如说，可以用lamba表达式来定义简短的key函数：
+
+tuples = [(1,'d'),(2,'b'),(3,'c'),(4,'a')]
+sorted(tuples,key = lamba x: x[1]) # [(4,'a'),(2,'b'),(3,'c'),(1,'d')]
+
+
+上面的例子按照每个元组中的第 2 个值对元组列表进行排序。在这种情况下，用 lambda 函数能快速修改排序顺序。
+
+下面是另外一个例子，使用lambda函数快速改变排序顺序：
+
+sorted(range(-5,6),lamba x: x*x) # [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]
+
+
+lamba函数的另外应用场景是作为回调函数传递给其他函数。比如，下面的代码使用 lambda 函数来定义一个回调函数，然后将其传递给内置的 filter 函数：
+
+list(filter(lambda x: x % 2, range(10))) # [1, 3, 5, 7, 9]
+# filter函数的第一个参数是一个函数对象，第二个参数是一个可迭代对象
+
+lambda 还有一个有趣之处：与普通的嵌套函数一样，lambda 也可以像词法闭包那样工作。
+
+
+def make_repeater(n):
+ return lambda s: s * n
+repeat_5 = make_repeater(5)
+repeat_5(3) # 15
+repeat_5('hello') # 'hellohellohellohellohello'
+repeat_3 = make_repeater(3)
+repeat_3('hello') # 'hellohellohello'
+repeat_3(3) # 9
+
+
+lambda 的局限性
+
+若工作代码用到了 lambda，虽然看起来很“酷”，但实际上对自己和同事都是一种负担。
+
+将 lambda 和 map()或 filter()结合起来构建复杂的表达式也很难让人理解，此时用列表解析式或生成器表达式通常会清晰不少.
+
+# 用lambda和filter构建复杂的表达式
+list(filter(lambda x: x % 2==0, range(16))) # [0, 2, 4, 6, 8, 10, 12, 14]
+# 用列表解析式
+[x for x in range(16) if x % 2 == 0] # [0, 2, 4, 6, 8, 10, 12, 14]
+
+
+装饰器
+
+Python 的装饰器可以用来临时扩展和修改可调用对象（函数、方法和类）的行为，同时又不会永久修改可调用对象本身。
+
+装饰器的一大用途是将通用的功能应用到现有的类或函数的行为上，这些功能包括：
+
+
+ - 日志记录
+ - 访问控制和授权
+ - 衡量函数，如执行时间
+ - 限制请求速率（rate-limiting ）
+ - 缓存，等等
+
装饰器是什么？
+
+
+
+装饰器是用来“装饰”或“包装”另一个函数的，在被包装函数运行之前和之后执行一些代码。
+
+那么简单装饰器的实现会是什么样子的呢？用基本术语来说，装饰器是可调用的，将可调用
+对象作为输入并返回另一个可调用对象。
+
+下面这个函数就具有这种特性，因此可以认为它是最简单的装饰器：
+
+def null_decorator(func):
+ return func
+
+
+下面用这个装饰器函数装饰（或包装）另一个函数：
+
+def greet():
+ return 'Hello!'
+greet = null_decorator(greet)
+greet() # 'Hello!'
+
+
+这个例子中定义了一个 greet 函数，然后立即运行 null_decorator 函数来装饰它。这个例子看起来没什么用，因为 null_decorator 是刻意设计的空装饰器。
+
+Python中有一个语法糖，可以让装饰器更加简洁，就是使用 @ 符号。下面的代码和上面的代码是等价的：
+
+@null_decorator
+def greet():
+ return 'Hello!'
+greet() # 'Hello!'
+
+
+在函数定义之前放置一个@null_decorator，相当于先定义函数然后运行这个装饰器。
+
+注意，使用@语法会在定义时就立即修饰该函数。这样，若想访问未装饰的原函数则需要折
+腾一番。因此如果想保留调用未装饰函数的能力，那么还是要手动装饰需要处理的函数。
+
+装饰器可以修改行为
+
+在熟悉装饰器语法之后，下面来编写一个有实际作用的装饰器来修改被装饰函数的行为。
+
+这个装饰器将被装饰函数返回的结果转换成大写字母：
+
+def uppercase(func):
+ def wrapper():
+ original_result = func()
+ modified_result = original_result.upper() # 修改行为, 转换成大写
+ return modified_result # 返回修改后的结果
+ return wrapper
+
+
+这个装饰器的实现中，定义了一个内部函数 wrapper，它将被装饰函数的返回值转换成大写字母。然后，这个内部函数被返回，作为装饰器函数。
+
+这个 uppercase 装饰器不像之前那样直接返回输入函数，而是在其中定义一个新函数（闭
+包）。在调用原函数时，新函数会包装原函数来修改其行为。
+
+包装闭包（新函数）可以访问未经装饰的输入函数（原函数），并且可在调用输入函数之前
+和之后自由执行额外的代码。
+
+来看看加了uppercase装饰器的greet函数,会对原来的greet函数产生什么影响：
+@uppercase
+def greet():
+ return 'Hello!'
+greet() # 'HELLO!'
+
+
+与 null_decorator 不同，uppercase 装饰器在装饰函数时会返回一个不同的函数对象：
+
+>>> greet
+<function greet at 0x10e9f0950>
+>>> null_decorator(greet)
+<function greet at 0x10e9f0950>
+>>> uppercase(greet)
+<function uppercase.<locals>.wrapper at 0x76da02f28>
+
+
+uppercase 定义并返回了另一个函数（闭包），这个函数在后续调用时会运行原输入函数并修改其结果.
+
+利用这种特性可以将可重用的代码块（如日志记录和其他功能）应用于现有的函数和类。因
+此装饰器是 Python 中非常强大的功能，在标准库和第三方包中经常用到.
+
+函数式编程
+
+函数式编程通过在函数中定义表达式和对表达式求值完成计算。它尽量避免由于状态变化和使用可变对象引入复杂性，让程序变得简洁明了。
+
+编程范式并没有统一的划分标准。其中两个范式：函数式编程和命令式编程。
+
+在命令式语言（比如 Python）中，计算的状态是通过不同命名空间中变量的值反映的。变量的值决定计算的当前状态，一条语句通过增加或改变（甚至是删除）变量来改变当前状态。“命令式”语言的每一条语句都是一个通过某种方式改变状态的命令。
+
+有两种方法可以返回一系列值，而不是生成器表达式。
+
+
+ - 编写显式 for 循环：for x in some_iter: yield x
+ - 使用 yield from 语句：yield from some_iter
+
+
+来源
+
+《Python函数式编程第2版》没看懂
+
+《深入理解Python特性》28-40页
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/54/c7243f767b62659de9a594cc3f777fa5ed502b826d214927d3c6c3cae5e2eb b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/54/c7243f767b62659de9a594cc3f777fa5ed502b826d214927d3c6c3cae5e2eb
new file mode 100644
index 0000000000..b076409ab9
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/54/c7243f767b62659de9a594cc3f777fa5ed502b826d214927d3c6c3cae5e2eb
@@ -0,0 +1,11 @@
+I"
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/56/64a27f7a5b09cea1f19bc9ba91a59c1bced58360b93a97c6e4c71b765ac33a b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/56/64a27f7a5b09cea1f19bc9ba91a59c1bced58360b93a97c6e4c71b765ac33a
new file mode 100644
index 0000000000..546d4daa17
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/56/64a27f7a5b09cea1f19bc9ba91a59c1bced58360b93a97c6e4c71b765ac33a
@@ -0,0 +1,9 @@
+I"
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/58/405baca6d4424a4a780e588995457ae494990f38a08ec67e9471383a0adbe5 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/58/405baca6d4424a4a780e588995457ae494990f38a08ec67e9471383a0adbe5
new file mode 100644
index 0000000000..51040941db
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/58/405baca6d4424a4a780e588995457ae494990f38a08ec67e9471383a0adbe5
@@ -0,0 +1,2 @@
+I"O回顾一下昨天有关引用传递与值传递有关的内容。
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/5a/18773190c8af55b5ede0dd0371fb72f1ec0b5b720e6b9992a17142c94f9aa2 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/5a/18773190c8af55b5ede0dd0371fb72f1ec0b5b720e6b9992a17142c94f9aa2
new file mode 100644
index 0000000000..492a9503dd
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/5a/18773190c8af55b5ede0dd0371fb72f1ec0b5b720e6b9992a17142c94f9aa2
@@ -0,0 +1,22 @@
+I"在VScode中如何配置
+
+
+ - 下载扩展“Live Server”,可以实时刷新和浏览在浏览器中显示的内容
+
+ - 记住一些快捷键，比如说使用(!+Enter)可以补全基本的HTML文件信息，比如说(.+ClassName)可以创建一个标签属性为ClassName的块级元素。
+
+
+
+
+简介
+
+HTML、CSS和JavaScript的关系如下：
+
+HTML是网页的结构，CSS是网页的外观，而JavaScript是页面的行为
+
+HTML基本语法
+
+CSS基本语法
+
+Javascript
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/5a/63ef031c654d1b86cf4d25b4d96787e53c37d4abd442c1aed75c17fe7aca45 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/5a/63ef031c654d1b86cf4d25b4d96787e53c37d4abd442c1aed75c17fe7aca45
new file mode 100644
index 0000000000..04656308d5
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/5a/63ef031c654d1b86cf4d25b4d96787e53c37d4abd442c1aed75c17fe7aca45
@@ -0,0 +1,40 @@
+I"
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/5b/35427906cd1dc545dc0f39a33111144ca53777f7680d0d1051f6a4cc98e7b9 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/5b/35427906cd1dc545dc0f39a33111144ca53777f7680d0d1051f6a4cc98e7b9
new file mode 100644
index 0000000000..c7a6f11cc8
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/5b/35427906cd1dc545dc0f39a33111144ca53777f7680d0d1051f6a4cc98e7b9
@@ -0,0 +1,10 @@
+I"
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/5b/9c0b64a1321a0a12b8bfb35035f4c2c2e3fe6428af995e361cc5a8208b27b0 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/5b/9c0b64a1321a0a12b8bfb35035f4c2c2e3fe6428af995e361cc5a8208b27b0
new file mode 100644
index 0000000000..21b2497b19
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/5b/9c0b64a1321a0a12b8bfb35035f4c2c2e3fe6428af995e361cc5a8208b27b0
@@ -0,0 +1,32 @@
+I"介绍最近发现的实用小工具: 在线查看github仓库的项目结构，pycharm中好用的插件.
+
+在线查看github仓库的项目结构
+
+方式一：使用gitpod
+
+Gitpod是一个在线的IDE，可以直接在浏览器中打开github仓库，查看项目结构，编辑代码，运行代码，提交代码等等。
+https://github.com/JuliaGeo/NaturalEarth.jl
+
+
+添加前缀gitpod.io/#/：
+https://gitpod.io/#/github.dev/JuliaGeo/NaturalEarth.jl
+
+
+方式二：按下句号
+
+按下句号，可以在github仓库中查看项目结构，但是只能查看，不能编辑代码。
+举例子：
+https://github.com/JuliaGeo/NaturalEarth.jl
+
+
+按下句号之后，会进入下面的页面：
+https://github.dev/JuliaGeo/NaturalEarth.jl
+
+
+这是一个在线的IDE，可以直接在浏览器中打开github仓库，查看项目结构，等等。
+
+pycharm中好用的插件
+
+Key Promoter X
+Key Promoter X 是用于基于 IntelliJ 产品（如 IDEA，Android Studio 或 CLion）的插件，它有助于在工作时从鼠标操作中 学习基本的键盘快捷键。 当您在 IDE 内部的按钮上 使用鼠标时，Key Promoter X 会显示您应该使用的键盘快捷键（如下图）。 这提供了一种简单的方法来学习如何用键盘按键代替繁琐的鼠标工作，并有助于过渡到更快的 无鼠标开发。
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/5b/d60e13dfa915a87b29fabe3a2d3338db338de81055fa8f1d4135f4debe564f b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/5b/d60e13dfa915a87b29fabe3a2d3338db338de81055fa8f1d4135f4debe564f
new file mode 100644
index 0000000000..8683ef09df
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/5b/d60e13dfa915a87b29fabe3a2d3338db338de81055fa8f1d4135f4debe564f
@@ -0,0 +1,8 @@
+I"
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/5c/960fe41a55ff0957c57d4ea2645131080b19e04e34f87a877fd8769183b833 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/5c/960fe41a55ff0957c57d4ea2645131080b19e04e34f87a877fd8769183b833
new file mode 100644
index 0000000000..3741f08cd3
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/5c/960fe41a55ff0957c57d4ea2645131080b19e04e34f87a877fd8769183b833
@@ -0,0 +1,12 @@
+I"x
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/5f/ed42ba27b808419a04b0720479e036f9306848d640a4c13c25f022e3457d4a b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/5f/ed42ba27b808419a04b0720479e036f9306848d640a4c13c25f022e3457d4a
new file mode 100644
index 0000000000..1ecd6db9be
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/5f/ed42ba27b808419a04b0720479e036f9306848d640a4c13c25f022e3457d4a
@@ -0,0 +1,2 @@
+I"wind turbine数据，如何使用机器学习算法预测轴承健康程度和风功率曲线呢
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/63/cdcc2d98977179ae7faf773f13ad74111c1e3419c9b1f7d3f340c335bc5bfd b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/63/cdcc2d98977179ae7faf773f13ad74111c1e3419c9b1f7d3f340c335bc5bfd
new file mode 100644
index 0000000000..04ea52b20e
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/63/cdcc2d98977179ae7faf773f13ad74111c1e3419c9b1f7d3f340c335bc5bfd
@@ -0,0 +1,28 @@
+I"h
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/64/7c732ecb4de6aaf6f9f0dd456f97ec2493b692fc8a80676a4b8fc37b97e432 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/64/7c732ecb4de6aaf6f9f0dd456f97ec2493b692fc8a80676a4b8fc37b97e432
new file mode 100644
index 0000000000..a09de8467a
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/64/7c732ecb4de6aaf6f9f0dd456f97ec2493b692fc8a80676a4b8fc37b97e432
@@ -0,0 +1,382 @@
+I";对CPU进行压力测试
+
+stress.sh
+
+#对CPU进行压力测试
+cpu_number=$(grep -c 'processor' /proc/cpuinfo)
+#模拟CPU在内核使用率达到100%的场景。
+stress --cpu $cpu_number
+
+输出结果导txt文件中（StressResult.sh）
+
+#!/bin/bash
+# 添加当前时间信息
+echo "当前时间为$(date)" >> stress.txt
+echo "模拟CPU在内核使用率达到100%的场景:" >> stress.txt
+
+./stress.sh & # run stress.sh in the background
+pid=$! # get the PID of the background process
+
+SECONDS=0 # initialize SECONDS variable to 0
+
+while [ $SECONDS -lt 50 ] # check if script has been running for less than 50 seconds
+do
+ echo "Current value of SECONDS: $SECONDS" >> stress.txt
+ uptime >> stress.txt
+ #echo "\n处理器实时统计信息如下" >> stress.txt
+ #-P ALL参数指定该命令应报告所有处理器的统计信息
+ #mpstat -P ALL 5 1 >> stress.txt
+ #echo "\n" >> stress.txt
+ SECONDS=$((SECONDS+2))
+ sleep 2
+done
+
+kill -9 $pid # kill the background process after 50 seconds
+kill $(pgrep stress)
+kill $(pgrep StressResult.sh)
+kill $(pgrep sleep)
+
+
+结果
+
+当前时间为2023年 03月 29日 星期三 14:34:33 CST
+模拟CPU在内核使用率达到100%的场景:
+Current value of SECONDS: 0
+ 14:34:33 up 59 min, 1 user, load average: 2.49, 2.49, 2.14
+Current value of SECONDS: 2
+ 14:34:35 up 59 min, 1 user, load average: 2.61, 2.52, 2.15
+Current value of SECONDS: 4
+ 14:34:38 up 59 min, 1 user, load average: 2.61, 2.52, 2.15
+Current value of SECONDS: 6
+ 14:34:40 up 59 min, 1 user, load average: 2.61, 2.52, 2.15
+Current value of SECONDS: 8
+ 14:34:42 up 59 min, 1 user, load average: 2.80, 2.56, 2.16
+Current value of SECONDS: 10
+ 14:34:44 up 59 min, 1 user, load average: 2.80, 2.56, 2.16
+Current value of SECONDS: 12
+ 14:34:46 up 59 min, 1 user, load average: 2.98, 2.60, 2.18
+Current value of SECONDS: 14
+ 14:34:48 up 59 min, 1 user, load average: 2.98, 2.60, 2.18
+Current value of SECONDS: 16
+ 14:34:50 up 59 min, 1 user, load average: 2.98, 2.60, 2.18
+Current value of SECONDS: 18
+ 14:34:52 up 59 min, 1 user, load average: 3.06, 2.62, 2.19
+Current value of SECONDS: 20
+ 14:34:54 up 59 min, 1 user, load average: 3.06, 2.62, 2.19
+Current value of SECONDS: 22
+ 14:34:56 up 59 min, 1 user, load average: 3.29, 2.68, 2.21
+Current value of SECONDS: 24
+ 14:34:58 up 59 min, 1 user, load average: 3.29, 2.68, 2.21
+Current value of SECONDS: 26
+ 14:35:00 up 59 min, 1 user, load average: 3.29, 2.68, 2.21
+Current value of SECONDS: 28
+ 14:35:02 up 59 min, 1 user, load average: 3.43, 2.72, 2.22
+Current value of SECONDS: 30
+ 14:35:04 up 59 min, 1 user, load average: 3.43, 2.72, 2.22
+Current value of SECONDS: 32
+ 14:35:06 up 59 min, 1 user, load average: 3.48, 2.74, 2.23
+Current value of SECONDS: 34
+ 14:35:08 up 59 min, 1 user, load average: 3.48, 2.74, 2.23
+Current value of SECONDS: 36
+ 14:35:10 up 59 min, 1 user, load average: 3.52, 2.76, 2.24
+Current value of SECONDS: 38
+ 14:35:12 up 1:00, 1 user, load average: 3.52, 2.76, 2.24
+Current value of SECONDS: 40
+ 14:35:14 up 1:00, 1 user, load average: 3.52, 2.76, 2.24
+Current value of SECONDS: 42
+ 14:35:16 up 1:00, 1 user, load average: 3.72, 2.82, 2.26
+Current value of SECONDS: 44
+ 14:35:18 up 1:00, 1 user, load average: 3.72, 2.82, 2.26
+Current value of SECONDS: 46
+ 14:35:20 up 1:00, 1 user, load average: 3.74, 2.84, 2.27
+Current value of SECONDS: 48
+ 14:35:22 up 1:00, 1 user, load average: 3.74, 2.84, 2.27
+
+
+对内存进行压力测试
+
+memory.sh
+
+# 新增4个内存分配进程，每次分配大小730M，分配后不释放，长期保持测试
+stress --vm 4 --vm-bytes 730M --vm-keep
+
+
+输出结果导txt文件中（memoryResult.sh）
+
+#!/bin/bash
+# 添加当前时间信息
+echo "当前时间为$(date)" >> memorystress.txt
+echo "# 新增4个内存分配进程，每次分配大小730M，分配后不释放，长期保持测试 " >> memorystress.txt
+
+./memory.sh & # run stress.sh in the background
+pid=$! # get the PID of the background process
+
+SECONDS=0 # initialize SECONDS variable to 0
+
+while [ $SECONDS -lt 50 ] # check if script has been running for less than 50 seconds
+do
+ echo "Current value of SECONDS: $SECONDS" >> memorystress.txt
+ uptime >> memorystress.txt
+ #echo "\n处理器实时统计信息如下" >> stress.txt
+ #-P ALL参数指定该命令应报告所有处理器的统计信息
+ #mpstat -P ALL 5 1 >> stress.txt
+ #echo "\n" >> stress.txt
+ SECONDS=$((SECONDS+2))
+ sleep 2
+done
+
+kill -9 $pid # kill the background process after 50 seconds
+kill $(pgrep stress)
+kill $(pgrep memoryResult.sh)
+kill $(pgrep sleep)
+
+
+执行memoryResult.sh
+
+[root@localhost ~]# ./memoryResult.sh
+
+
+输出结果
+
+当前时间为2023年 03月 29日 星期三 14:32:07 CST
+# 新增4个内存分配进程，每次分配大小730M，分配后不释放，长期保持测试
+Current value of SECONDS: 0
+ 14:32:07 up 56 min, 1 user, load average: 2.24, 2.34, 2.02
+Current value of SECONDS: 2
+ 14:32:09 up 56 min, 1 user, load average: 2.24, 2.34, 2.02
+Current value of SECONDS: 4
+ 14:32:11 up 57 min, 1 user, load average: 2.46, 2.38, 2.04
+Current value of SECONDS: 6
+ 14:32:13 up 57 min, 1 user, load average: 2.46, 2.38, 2.04
+Current value of SECONDS: 8
+ 14:32:15 up 57 min, 1 user, load average: 2.46, 2.38, 2.04
+Current value of SECONDS: 10
+ 14:32:17 up 57 min, 1 user, load average: 2.83, 2.46, 2.07
+Current value of SECONDS: 12
+ 14:32:19 up 57 min, 1 user, load average: 2.83, 2.46, 2.07
+Current value of SECONDS: 14
+ 14:32:21 up 57 min, 1 user, load average: 2.92, 2.48, 2.08
+Current value of SECONDS: 16
+ 14:32:23 up 57 min, 1 user, load average: 2.92, 2.48, 2.08
+Current value of SECONDS: 18
+ 14:32:25 up 57 min, 1 user, load average: 3.01, 2.51, 2.09
+Current value of SECONDS: 20
+ 14:32:27 up 57 min, 1 user, load average: 3.01, 2.51, 2.09
+Current value of SECONDS: 22
+ 14:32:29 up 57 min, 1 user, load average: 3.01, 2.51, 2.09
+Current value of SECONDS: 24
+ 14:32:31 up 57 min, 1 user, load average: 3.09, 2.53, 2.10
+Current value of SECONDS: 26
+ 14:32:33 up 57 min, 1 user, load average: 3.09, 2.53, 2.10
+Current value of SECONDS: 28
+ 14:32:35 up 57 min, 1 user, load average: 3.16, 2.56, 2.11
+Current value of SECONDS: 30
+ 14:32:37 up 57 min, 1 user, load average: 3.16, 2.56, 2.11
+Current value of SECONDS: 32
+ 14:32:39 up 57 min, 1 user, load average: 3.16, 2.56, 2.11
+Current value of SECONDS: 34
+ 14:32:41 up 57 min, 1 user, load average: 3.23, 2.58, 2.12
+Current value of SECONDS: 36
+ 14:32:43 up 57 min, 1 user, load average: 3.23, 2.58, 2.12
+Current value of SECONDS: 38
+ 14:32:45 up 57 min, 1 user, load average: 3.29, 2.61, 2.13
+Current value of SECONDS: 40
+ 14:32:47 up 57 min, 1 user, load average: 3.29, 2.61, 2.13
+Current value of SECONDS: 42
+ 14:32:49 up 57 min, 1 user, load average: 3.29, 2.61, 2.13
+Current value of SECONDS: 44
+ 14:32:51 up 57 min, 1 user, load average: 3.35, 2.63, 2.14
+Current value of SECONDS: 46
+ 14:32:53 up 57 min, 1 user, load average: 3.35, 2.63, 2.14
+Current value of SECONDS: 48
+ 14:32:55 up 57 min, 1 user, load average: 3.40, 2.65, 2.15
+
+
+对IO进行压力测试
+
+io.sh
+
+# 新增6个I/O进程，测试100秒
+stress -i 6
+
+
+ioResult.sh(输出结果到iostress.txt)
+
+#!/bin/bash
+# 添加当前时间信息
+echo "当前时间为$(date)" >> iostress.txt
+echo "模拟新增6个I/O进程的场景:" >> iostress.txt
+
+./io.sh & # run stress.sh in the background
+pid=$! # get the PID of the background process
+
+SECONDS=0 # initialize SECONDS variable to 0
+
+while [ $SECONDS -lt 50 ] # check if script has been running for less than 50 seconds
+do
+ echo "Current value of SECONDS: $SECONDS" >> iostress.txt
+ uptime >> iostress.txt
+ #echo "\n处理器实时统计信息如下" >> stress.txt
+ #-P ALL参数指定该命令应报告所有处理器的统计信息
+ #mpstat -P ALL 5 1 >> stress.txt
+ #echo "\n" >> stress.txt
+ SECONDS=$((SECONDS+2))
+ sleep 2
+done
+
+kill -9 $pid # kill the background process after 50 seconds
+kill $(pgrep stress)
+kill $(pgrep ioResult.sh)
+kill $(pgrep sleep)
+
+
+查看结果
+
+当前时间为2023年 03月 29日 星期三 14:30:31 CST
+模拟新增6个I/O进程的场景:
+Current value of SECONDS: 0
+ 14:30:31 up 55 min, 1 user, load average: 1.69, 1.90, 1.84
+Current value of SECONDS: 2
+ 14:30:33 up 55 min, 1 user, load average: 1.69, 1.90, 1.84
+Current value of SECONDS: 4
+ 14:30:35 up 55 min, 1 user, load average: 1.69, 1.90, 1.84
+Current value of SECONDS: 6
+ 14:30:37 up 55 min, 1 user, load average: 2.04, 1.97, 1.87
+Current value of SECONDS: 8
+ 14:30:39 up 55 min, 1 user, load average: 2.04, 1.97, 1.87
+Current value of SECONDS: 10
+ 14:30:41 up 55 min, 1 user, load average: 2.44, 2.05, 1.89
+Current value of SECONDS: 12
+ 14:30:43 up 55 min, 1 user, load average: 2.44, 2.05, 1.89
+Current value of SECONDS: 14
+ 14:30:45 up 55 min, 1 user, load average: 2.44, 2.05, 1.89
+Current value of SECONDS: 16
+ 14:30:47 up 55 min, 1 user, load average: 3.04, 2.19, 1.94
+Current value of SECONDS: 18
+ 14:30:49 up 55 min, 1 user, load average: 3.04, 2.19, 1.94
+Current value of SECONDS: 20
+ 14:30:51 up 55 min, 1 user, load average: 3.60, 2.32, 1.98
+Current value of SECONDS: 22
+ 14:30:53 up 55 min, 1 user, load average: 3.60, 2.32, 1.98
+Current value of SECONDS: 24
+ 14:30:55 up 55 min, 1 user, load average: 3.60, 2.32, 1.98
+Current value of SECONDS: 26
+ 14:30:57 up 55 min, 1 user, load average: 3.95, 2.41, 2.01
+Current value of SECONDS: 28
+ 14:30:59 up 55 min, 1 user, load average: 3.95, 2.41, 2.01
+Current value of SECONDS: 30
+ 14:31:01 up 55 min, 1 user, load average: 4.20, 2.49, 2.04
+Current value of SECONDS: 32
+ 14:31:03 up 55 min, 1 user, load average: 4.20, 2.49, 2.04
+Current value of SECONDS: 34
+ 14:31:05 up 55 min, 1 user, load average: 4.26, 2.53, 2.06
+Current value of SECONDS: 36
+ 14:31:07 up 55 min, 1 user, load average: 4.26, 2.53, 2.06
+Current value of SECONDS: 38
+ 14:31:09 up 55 min, 1 user, load average: 4.26, 2.53, 2.06
+Current value of SECONDS: 40
+ 14:31:11 up 56 min, 1 user, load average: 4.40, 2.59, 2.08
+Current value of SECONDS: 42
+ 14:31:13 up 56 min, 1 user, load average: 4.40, 2.59, 2.08
+Current value of SECONDS: 44
+ 14:31:15 up 56 min, 1 user, load average: 4.53, 2.64, 2.10
+Current value of SECONDS: 46
+ 14:31:17 up 56 min, 1 user, load average: 4.53, 2.64, 2.10
+Current value of SECONDS: 48
+ 14:31:19 up 56 min, 1 user, load average: 4.53, 2.64, 2.10
+
+
+对磁盘IO进行压力测试
+
+hdd.sh
+
+# 开启2个磁盘IO进程，每次写10GB数据到磁盘
+stress --hdd 2 --hdd-bytes 10G --backoff 2000000
+
+
+hddResult.sh(输出结果到hddstress.txt)
+
+#!/bin/bash
+# 添加当前时间信息
+echo "当前时间为$(date)" >> hddstress.txt
+echo "模拟开启2个磁盘IO进程，每次写10GB数据到磁盘的场景:" >> hddstress.txt
+
+./hdd.sh & # run stress.sh in the background
+pid=$! # get the PID of the background process
+
+SECONDS=0 # initialize SECONDS variable to 0
+
+while [ $SECONDS -lt 50 ] # check if script has been running for less than 50 seconds
+do
+ echo "Current value of SECONDS: $SECONDS" >> hddstress.txt
+ uptime >> hddstress.txt
+ #echo "\n处理器实时统计信息如下" >> stress.txt
+ #-P ALL参数指定该命令应报告所有处理器的统计信息
+ #mpstat -P ALL 5 1 >> stress.txt
+ #echo "\n" >> stress.txt
+ SECONDS=$((SECONDS+2))
+ sleep 2
+done
+
+kill -9 $pid # kill the background process after 50 seconds
+kill $(pgrep stress)
+kill $(pgrep hddResult.sh)
+kill $(pgrep sleep)
+
+
+查看结果
+
+当前时间为2023年 03月 29日 星期三 14:33:22 CST
+模拟开启2个磁盘IO进程，每次写10GB数据到磁盘的场景:
+Current value of SECONDS: 0
+ 14:33:22 up 58 min, 1 user, load average: 2.24, 2.44, 2.09
+Current value of SECONDS: 2
+ 14:33:24 up 58 min, 1 user, load average: 2.24, 2.44, 2.09
+Current value of SECONDS: 4
+ 14:33:26 up 58 min, 1 user, load average: 2.22, 2.43, 2.09
+Current value of SECONDS: 6
+ 14:33:28 up 58 min, 1 user, load average: 2.22, 2.43, 2.09
+Current value of SECONDS: 8
+ 14:33:30 up 58 min, 1 user, load average: 2.22, 2.43, 2.09
+Current value of SECONDS: 10
+ 14:33:32 up 58 min, 1 user, load average: 2.28, 2.44, 2.10
+Current value of SECONDS: 12
+ 14:33:34 up 58 min, 1 user, load average: 2.28, 2.44, 2.10
+Current value of SECONDS: 14
+ 14:33:36 up 58 min, 1 user, load average: 2.34, 2.45, 2.10
+Current value of SECONDS: 16
+ 14:33:38 up 58 min, 1 user, load average: 2.34, 2.45, 2.10
+Current value of SECONDS: 18
+ 14:33:40 up 58 min, 1 user, load average: 2.39, 2.46, 2.11
+Current value of SECONDS: 20
+ 14:33:42 up 58 min, 1 user, load average: 2.39, 2.46, 2.11
+Current value of SECONDS: 22
+ 14:33:44 up 58 min, 1 user, load average: 2.39, 2.46, 2.11
+Current value of SECONDS: 24
+ 14:33:46 up 58 min, 1 user, load average: 2.44, 2.47, 2.11
+Current value of SECONDS: 26
+ 14:33:48 up 58 min, 1 user, load average: 2.44, 2.47, 2.11
+Current value of SECONDS: 28
+ 14:33:51 up 58 min, 1 user, load average: 2.49, 2.48, 2.12
+Current value of SECONDS: 30
+ 14:33:53 up 58 min, 1 user, load average: 2.49, 2.48, 2.12
+Current value of SECONDS: 32
+ 14:33:55 up 58 min, 1 user, load average: 2.53, 2.49, 2.12
+Current value of SECONDS: 34
+ 14:33:58 up 58 min, 1 user, load average: 2.53, 2.49, 2.12
+Current value of SECONDS: 36
+ 14:34:01 up 58 min, 1 user, load average: 2.49, 2.48, 2.12
+Current value of SECONDS: 38
+ 14:34:03 up 58 min, 1 user, load average: 2.49, 2.48, 2.12
+Current value of SECONDS: 40
+ 14:34:04 up 58 min, 1 user, load average: 2.49, 2.48, 2.12
+Current value of SECONDS: 42
+ 14:34:09 up 58 min, 1 user, load average: 2.45, 2.47, 2.12
+Current value of SECONDS: 44
+ 14:34:12 up 59 min, 1 user, load average: 2.49, 2.48, 2.12
+Current value of SECONDS: 46
+ 14:34:17 up 59 min, 1 user, load average: 2.93, 2.57, 2.15
+Current value of SECONDS: 48
+ 14:34:19 up 59 min, 1 user, load average: 2.93, 2.57, 2.15
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/64/d3d7d50ab58f0bee7021a8f7a795be89a84d154ab2ec743cdd0a86189f13ea b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/64/d3d7d50ab58f0bee7021a8f7a795be89a84d154ab2ec743cdd0a86189f13ea
new file mode 100644
index 0000000000..d7840e518d
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/64/d3d7d50ab58f0bee7021a8f7a795be89a84d154ab2ec743cdd0a86189f13ea
@@ -0,0 +1,144 @@
+I"介绍了接口自动化测试框架框架搭建，第三方插件，配置文件设置和读取，测试流程等内容。测试用例设计部分，则包括Excel测试用例，控制流和数据流，方法的应用场景，测试用例书写标准以及测试集的创建。
+
+接口自动化测试总结
+
+框架搭建
+
+
+ - 工具
+ - 目录
+ - 配置
+ - pytest框架
+
+ - pytest.ini
+ - conftest.py
+ - 基本命令
+ - 三方插件
+
+
+ - Yaml配置文件
+
+
+ - Excel
+
+
+ - 日志
+
+
+ - Allure报告
+
+
+ - 邮件配置
+
+
+ - 接口测试框架流程
+
+
+主程序 -> Excel测试用例 -> Request请求 -> 断言 -> 日志 -> Allure报告 -> 邮件发送
+
+测试设计
+
+测试框架的设计
+
+测试用例的设计
+
+测试用例是为了某个特定的测试目标而设计的，它是测试操作过程序列、条件、期望结果和相关数据的一个特定的集合。
+
+从需求出发，设计测试用例，不同的测试数据或测试条件和用户故事（user story）、应用场景叠加，形成测试用例。
+
+还可以基于被测系统(system under test)的功能点、业务流程、业务规则、业务数据等，设计测试用例。
+
+测试用例和功能结构有对应关系，呈现出层次结构。
+
+例如，在“登录”功能模块中，层次结构如下：
+
+
+ - 用户身份合法性验证（父用例）
+
+ - 用户名验证（子用例）
+
+ - 正常用户名的输入（孙用例）
+
+ - 含有特殊字符的用户名输入
+ - 字母大小写无关性测试
+ - 非法用户名输入
+
+
+ - 密码验证（子用例）
+
+ - 正常密码
+ - 含有特殊字符的密码
+ - 字母区分大小写的测试
+ - 密码有效期验证
+ - 密码保存
+ - 忘记密码之后找回密码功能
+
+
+
+
+
+
+
+
+Excel测试用例
+
+一个完整的Excel测试用例表应该包括以下几个部分：
+
+用例编号，用例名称，用例类型，用例优先级，用例状态，用例版本，用例创建人，用例创建时间，用例修改人，用例修改时间，用例描述，用例前置条件，用例后置条件，用例步骤，用例预期结果，用例附件，用例备注。
+
+控制流和数据流
+
+可以从代码、功能点和场景等维度去衡量测试覆盖率，但是场景、功能点具有不确定性，比较确定的测试覆盖率是基于数据分析的数据流和基于逻辑结构的控制流。测试设计方法就是通过测试用例的不断设计、优化，最终达到控制流和数据流的覆盖。
+
+在业务层，控制流主要体现在业务流程图，数据流体现在数据流程图。
+
+如“用户登录”功能模块的业务流程图：
+
+
+
+根据上述流程图来设计测试用例，需要覆盖每个分支和条件，以保证测试的覆盖率。
+
+首先，要考虑分成“不能自动登录”和“自动登录”两类；对于“不能自动登录”，要考虑“记住密码”和“不记住密码”两种情况；对于“自动登录”，要考虑“记住密码”和“不记住密码”两种情况。对于不同输入项的错误，可以分成“用户名错误”、“密码错误”、“验证码错误”、“用户名和密码错误”、“用户名和验证码错误”、“密码和验证码错误”、“用户名、密码和验证码错误”等情况。这样，就可以设计出对呀的测试用例。
+
+清楚方法的应用场景
+
+
+ - 表单中单个输入框的测试属于单因素测试，可以使用等价类划分法、边界值分析法等方法。等价类划分让我们优化测试数据，并关注无效等价类；边界值分析方法则让我们关注边界值。
+ - 如果考虑多个条件（条件只包括成立和不成立）组合作用时，这时选用决策表方法。如果很难构造出决策表，可以先用因果图分析，再由因果图产生决策表。
+ - 如果不是条件，而是多个因素/变量，每个因素/变量有多个选项（取值），这时要看能否完全组合。如果完全组合数很大，就考虑用两两组合（pairwise）方法或者正交实验方法。
+
+
+测试用例书写标准
+
+测试用例标准模板的主要元素如下：
+
+
+ - 标识符
+ - 测试项
+ - 测试环境要求
+ - 输入标准
+ - 输出标准
+ - 测试用例之间的关联
+
+
+测试集的创建
+
+测试集是测试用例的集合，可以对测试用例进行分类管理。测试集的创建可以按照模块、功能、功能模块、功能点等方式进行分类。
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/67/f75227eb3aa4ffa692aa5c6fc0512a0451636e9329322dbab3a930627541fd b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/67/f75227eb3aa4ffa692aa5c6fc0512a0451636e9329322dbab3a930627541fd
new file mode 100644
index 0000000000..5f9b6f90fe
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/67/f75227eb3aa4ffa692aa5c6fc0512a0451636e9329322dbab3a930627541fd
@@ -0,0 +1,74 @@
+I" 下划线、双下划线
+
+单下划线和双下划线在 Python 变量名和方法名中都有各自的含义。有些仅仅是作为约定，用于提示开发人员；而另一些则对 Python 解释器有特殊含义。
+
+前置单下划线：_var
+
+前置单下划线只有约定含义。它对于程序员而言是一种提示。提示其他程序员，以单下划线开头的变量或方法只在内部使用。PEP8中定义了这个约定。
+
+Python 在“私有”和“公共”变量之间并没有很强的区别。
+
+class Test:
+ def __init(self):
+ self.foo = 11
+ self._bar = 23
+
+
+如果实例化这个类并尝试访问在__init__构造函数中定义的 foo 和_bar 属性，会发生什么情况？
+
+t = Test()
+print(t.foo) # 11
+print(t._bar) # 23
+
+
+可以看到，__bar 前面的单下划线并没有阻止我们“进入”这个类访问变量的值。
+
+后置单下划线：var_
+
+有时，某个变量最合适的名称已被 Python 语言中的关键字占用。在这种情况下，可以追加一个下划线来绕过命名冲突。
+
+这是PEP8中的约定。
+
+前置双下划线：__var
+
+双下划线前缀会让 Python 解释器重写属性名称，以避免子类中的命名冲突。
+
+这也称为名称改写（name mangling），即解释器会更改变量的名称，以便在稍后扩展这个类时避免命名冲突。
+
+class Test:
+ def __init__(self):
+ self.__baz = 23
+t = Test()
+print(t.__baz) # AttributeError: 'Test' object has no attribute '__baz'
+dir(t) # ['_Test__baz']
+print(t._Test__baz) # 23
+class Test2(Test):
+ def __init__(self):
+ super().__init__()# super() 函数是用于调用父类(超类)的一个方法.
+ self.__baz = 42
+t2 = Test2()
+print(t2._baz)
+dir(t2)
+print(t2._Test__baz) # 23
+print(t2._Test2__baz) # 42
+
+
+
+前后双下划线：var
+
+如果名字前后都使用双下划线，则不会发生名称改写;前后由双下划线包围的变量不受 Python 解释器的影响。
+
+同时具有前后双下划线的名称在 Python 中有特殊用途。比如说，__init__这样的对象构造函数；用来让对象可调用的__call__函数。
+
+这些双下划线方法通常被称为魔法方法（magic methods），因为它们的名字都是以双下划线开头和结尾的。
+
+单下划线：_
+
+单下划线是一个有效的变量名，用作临时或无意义变量的名称。
+
+在 Python 交互式解释器中，单下划线是最后一个表达式的值。
+
+来源
+
+《深入理解Python特性》P015 - P022
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/68/1ff7b47416228d95ae9286610306df85d85f1b6d7c49243840c97cffd767b7 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/68/1ff7b47416228d95ae9286610306df85d85f1b6d7c49243840c97cffd767b7
new file mode 100644
index 0000000000..b4c5fe8e7e
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/68/1ff7b47416228d95ae9286610306df85d85f1b6d7c49243840c97cffd767b7
@@ -0,0 +1,24 @@
+I"( 软件测试是什么
+软件测试的一个目的是验证你的猜想-猜想软件的内部逻辑，包括第三方的模块、代码包。甚至Python的内建的数据结构是如何运行的。Tasks项目使用名为Task的数据结构，它是用namedtuple工厂函数生成的。Task用于在UI层和API层之间传递信息。
+from collections import namedtuple
+Task = namedtuple('Task', ['summary', 'owner', 'done', 'id'])
+# 使用_new_.defaults_创建一个默认的Task实例
+Task.__new__.__defaults__ = (None, None, False, None)
+
+运行pytest时可以指定目录和文件。如果不指定，会搜索当前目录以及其子目录中以test_开头或者已_test结尾的文件。pytest会自动搜索这些文件中的测试用例。
+rootdir: D:\pytest\Tasks\tests,
+inifile: pytest.ini & tox.ini & setup.cfg
+
+测试结果
+每个文件的测试情况只占据一行，两个点号表示两个测试用例均已通过；而Failure/erro/skip/xfail/xpass表示测试用例失败/错误/跳过/预期失败/预期失败但通过，会被标记为F/E/s/x/X。
+
+编写测试函数
+测试函数的命名规则：test_开头或者以_test结尾。
+测试Tasks项目的文件目录如下：
+
+
+所有的测试都放在tests文件夹中，与包含程序源代码的src文件夹分开。有一些文件比较重要，如README.rst(rst是使用reStrucuredText编写的文档格式,readme是项目须知，CHANGELOG是记录项目变更的日志文件)，LICENSE.txt(许可证文件)，setup.py(安装脚本)，setup.cfg(配置文件)，pytest.ini(配置文件)，tox.ini(配置文件)，conftest.py（本地插件库，hook函数将自定义逻辑引入pytest,用于改善pytest的执行流程；fixtures则是一些用于测试前后执行配置及销毁逻辑的外壳函数）、init.py(初始化文件,表示函数主入口)。
+
+使用fixture执行配置和销毁逻辑
+@pytest.fixture()中的参数scope表示fixture的作用域，有function、class、module、session四个待选值。
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/68/d9e3961ac53c8c849e350691ac5cec41e2af1220a52ca18d433cd8d105fd5e b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/68/d9e3961ac53c8c849e350691ac5cec41e2af1220a52ca18d433cd8d105fd5e
new file mode 100644
index 0000000000..50f4a441dc
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/68/d9e3961ac53c8c849e350691ac5cec41e2af1220a52ca18d433cd8d105fd5e
@@ -0,0 +1,2 @@
+I"软件包管理是任何Linux发行版的重要功能之一，可简化Linux应用程序的安装和维护方法。不同的Linux发行版采用不同的方法来打包和分发软件。
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/6a/2fbc251249a3a45f304812546c51bdbbcb349841605df2ff20826743272e2f b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/6a/2fbc251249a3a45f304812546c51bdbbcb349841605df2ff20826743272e2f
new file mode 100644
index 0000000000..a04d6d759d
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/6a/2fbc251249a3a45f304812546c51bdbbcb349841605df2ff20826743272e2f
@@ -0,0 +1,30 @@
+I"
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/6a/b53f1efd00f90bc8f292322ffd24e52517f628ead7b317637e53c73e4ff696 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/6a/b53f1efd00f90bc8f292322ffd24e52517f628ead7b317637e53c73e4ff696
new file mode 100644
index 0000000000..3e60b1bdab
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/6a/b53f1efd00f90bc8f292322ffd24e52517f628ead7b317637e53c73e4ff696
@@ -0,0 +1,2 @@
+I"w介绍最近发现的实用小工具: 在线查看github仓库的项目结构，pycharm中好用的插件.
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/6c/b8512fe0777b3955fcc1847f0f830dca68479c3826686d1846dd48829fda26 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/6c/b8512fe0777b3955fcc1847f0f830dca68479c3826686d1846dd48829fda26
new file mode 100644
index 0000000000..71358ee913
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/6c/b8512fe0777b3955fcc1847f0f830dca68479c3826686d1846dd48829fda26
@@ -0,0 +1,90 @@
+I"数据介绍
+
+哥白尼海洋服务（Copernicus Marine Service）提供免费开放的海洋数据和服务，助力海洋政策实施，支持蓝色增长和科学创新。
+
+其官网主页如下：
+
+
+
+如何选择我们需要的数据
+
+首先，我们需要注册一个账号，账号说明使用数据的用途以及我们所属的高校，大概两三天就能审核通过。
+
+接着，是检索数据，以我们需要的sea level anomaly (SLA) 数据为例，点击OCEAN PRODUCTS，在General catalogue中输入”SLA”然后点击搜索，以下是呈现结果：
+
+
+
+我们发现，第一个数据集（GLOBAL OCEAN GRIDDED L4 SEA SURFACE HEIGHTS AND DERIVED VARIABLES REPROCESSED (1993-ONGOING)）可能是我们需要的数据，这个数据集涵括了1993年以来高度计卫星栅格海平面异常（海表面高度减去20年的平均值）,同时提供了其他的一些变量如ADT(动态地形)，尤其是地转流和地转异常（geostrophic currents (absolute and anomalies)），能够节省数据处理的时间，其变量时间分辨率是0.25° × 0.25°分辨率，提供数据下载格式是nc格式。
+
+从SLA计算地转流速（UG/VG)是比较基础的内容，有关代码可以看一下这两个博客：
+
+matlab版本
+
+python版本
+
+
+
+至于ADT和SSH和SLA的关系，可以看一下博客：
+What are the differences between the SSH and SLA?
+
+
+
+数据在线可视化
+
+在初步了解了数据的基本信息，提供的变量类型以及具体属性之后，网站还提供了非常良好的交互式地帮助我们在线可视化变量的工具，点击“view products”即可进入：
+
+
+
+在左边的面板，有“add layers”,可以选择画图需要的数据，，可以更改colormap的类型，更改显示的日期等等。
+
+
+
+数据下载
+
+同时，我们还发现在左边的面板上有个下载的按钮（
+
+
+
+下方可以设置选择研究的区域以及选择的时间范围，研究区域的选取可以在地图上选择一个矩形区域或者手动输入东西南北边界来获得：
+
+
+
+如图所示，这个网站提供了直接下载（紫色圆圈）和API下载两种方式（红色圆圈），前者更加简便，后者可以提供较为定制化地下载选择。
+
+其中，如果我们想要下载东经100°到东经150°，北纬20°到40°，时间跨度是2022年2月份的海表面东西方向的地转速度，只需要在配置好MOTU服务的基础上，在命令行输入以下指令即可把把数据下载到指定文件夹（OUTPUT_DIRECTORY）：
+
+python -m motuclient --motu https://my.cmems-du.eu/motu-web/Motu --service-id SEALEVEL_GLO_PHY_L4_MY_008_047-TDS --product-id cmems_obs-sl_glo_phy-ssh_my_allsat-l4-duacs-0.25deg_P1D --longitude-min 100 --longitude-max 150 --latitude-min 20 --latitude-max 40 --date-min "2022-02-01 00:00:00" --date-max "2022-02-28 23:59:59" --variable ugos --out-dir <OUTPUT_DIRECTORY> --out-name <OUTPUT_FILENAME> --user <USERNAME> --pwd <PASSWORD>
+
+
+
+
+同时，如果我们想要批量下载该研究区域其他时间段或者更大时间尺度范围的海表流场信息，只需要对该段代码进行细微的改动或者增加循环的方式即可!
+
+可能遇到的问题
+
+
+ - 网络问题和其他
+
+ -
+
On Linux and macOS, please replace double quotes with single quotes. On Windows, use double quotes as shown above.
+
+ -
+
If you use an HTTP proxy, add the following option:
+
+
+
+ --proxy-server <PROXY_SERVER_URL>:<PROXY_PORT_NUMBER>
+
+
+ - If your proxy-server requires authentication, add the following options:
+
+
+ --proxy-user <PROXY_USERNAME> --proxy-pwd <PROXY_PASSWORD>
+
+ -
+
什么是MOTU Client以及需要的python环境要求？
+
+ 提防python版本问题
+
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/6d/aae6c2a6c9c8e14eee5d866ec1c871c0efbee5c545c4a7e6f2cdf88f190e2e b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/6d/aae6c2a6c9c8e14eee5d866ec1c871c0efbee5c545c4a7e6f2cdf88f190e2e
new file mode 100644
index 0000000000..b8710509ff
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/6d/aae6c2a6c9c8e14eee5d866ec1c871c0efbee5c545c4a7e6f2cdf88f190e2e
@@ -0,0 +1,2 @@
+I"`这一讲主要是介绍了set(集合)数据结构，三元运算符等等内容。
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/6e/0e8473db248dc8859b448e5ecc48e1dc1e6e631b55742f1da1f6664244939c b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/6e/0e8473db248dc8859b448e5ecc48e1dc1e6e631b55742f1da1f6664244939c
new file mode 100644
index 0000000000..585181dccd
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/6e/0e8473db248dc8859b448e5ecc48e1dc1e6e631b55742f1da1f6664244939c
@@ -0,0 +1,27 @@
+I"
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/6f/54bb3d577dd69d0a677ef98ecf3dbac15db2c2fee0b7e950806b525db6aeb8 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/6f/54bb3d577dd69d0a677ef98ecf3dbac15db2c2fee0b7e950806b525db6aeb8
new file mode 100644
index 0000000000..98e94db2a0
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/6f/54bb3d577dd69d0a677ef98ecf3dbac15db2c2fee0b7e950806b525db6aeb8
@@ -0,0 +1,348 @@
+I"(-主要包括pytest安装；pytest创建简单的测试用例；pytest基础使用如函数级别的方法和类级别的方法；pytest常见插件如pytest-html将测试结果以html的形式展示出来，pytest-rerunfailures可以进行测试代码的失败重试；pytest的数据参数化，可以实习同样的测试用例函数对多个输入的测试数据的测试；最后是根据pytest运行原则以及pytest.ini指定测试的文件夹，测试函数等对之前的接口模块函数进行重构，进行自动化测试。
+
+pytest安装
+
+在requirements.txt中添加pytest
+pytest~=4.5.0
+
+
+在项目根目录下执行
+pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
+
+
+pytest使用
+
+创建简单的测试用例
+
+在testcase文件夹下面创建文件夹t_pytest，然后在t_pytest文件夹下创建pytest_demo.py文件，内容如下：
+
+
+import pytest
+
+#1、创建简单测试方法
+"""
+1、创建普通方法
+2、使用pytest断言的方法
+"""
+#普通方法
+def func(x):
+ return x+1
+
+#断言的方法
+def test_a():
+ print("---test_a----")
+ assert func(3) == 5 #断言失败
+
+def test_b():
+ print("---test_b----")
+ assert 1 #断言
+
+
+#2、pytest运行
+"""
+1、Pycharm代码直接执行
+2、命令行执行
+"""
+
+#代码直接执行
+if __name__ == "__main__":
+ pytest.main(["pytest_demo.py"])
+
+
+在Pycharm中直接运行pytest_demo.py文件，还可以增加一些参数：
+#代码直接执行
+import pytest
+if __name__ == "__main__":
+ pytest.main(["-s","pytest_demo.py"]) # -s参数可以打印print的内容
+
+在命令行中执行代码，操作如下：
+# 进入到项目根目录下
+cd testcase/t_pytest
+# 执行代码
+python pytest_demo.py
+
+测试结果一个通过，一个失败
+
+============================= test session starts ==============================
+collecting ... collected 2 items
+
+pytest_demo.py::test_a FAILED [ 50%]---test_a----
+
+testcase/t_pytest/pytest_demo.py:13 (test_a)
+4 != 5
+
+预期:5
+实际:4
+<点击以查看差异>
+
+def test_a():
+ print("---test_a----")
+> assert func(3) == 5 #断言失败
+E assert 4 == 5
+E + where 4 = func(3)
+
+pytest_demo.py:16: AssertionError
+
+
+
+
+pytest_demo.py::test_b PASSED [100%]---test_b----
+
+
+========================= 1 failed, 1 passed in 0.04s ==========================
+
+进程已结束,退出代码1
+
+
+pytest的基础使用
+
+函数级别的方法
+
+运行于测试方法的始末，运行一次测试函数会运行一次 setup 和 teardown。
+
+在t_pytest文件夹下创建pytest_func.py文件，内容如下：
+
+
+import pytest
+"""
+1、定义类
+2、创建测试方法test开头
+3、创建setup,teardown
+4、运行查看结果
+
+"""
+
+#1、定义类
+class TestFunc:
+ #3、创建setup,teardown
+ def setup(self):
+ print("---setup----")
+
+ def teardown(self):
+ print("---teardown---")
+
+ #2、创建测试方法test开头
+ def test_a(self):
+ print("test_a")
+
+ def test_b(self):
+ print("test_b")
+
+#4、运行查看结果
+if __name__ =="__main__":
+ pytest.main(["-s","pytest_func.py"])
+
+
+返回控制台结果如下：
+
+Testing started at 上午10:37 ...
+Launching pytest with arguments /home/hugo/PycharmProjects/InterAutoTest_W/testcase/t_pytest/pytest_func.py --no-header --no-summary -q in /home/hugo/PycharmProjects/InterAutoTest_W/testcase/t_pytest
+
+============================= test session starts ==============================
+collecting ... collected 2 items
+
+pytest_func.py::TestFunc::test_a
+pytest_func.py::TestFunc::test_b
+
+======================== 2 passed, 4 warnings in 0.01s =========================
+
+进程已结束,退出代码0
+---setup----
+PASSED [ 50%]test_a
+---teardown---
+---setup----
+PASSED [100%]test_b
+---teardown---
+
+
+我们发现，这里在运行每个测试方法之前都会运行setup方法，运行完每个测试方法之后都会运行teardown方法。
+
+类级别方法
+
+运行于测试类的始末，在一个测试内只运行一次 setup_class 和 teardown_class，不关心测试类内有多少个测试函数。
+
+在t_pytest文件夹下创建pytest_class.py文件，内容如下：
+
+
+import pytest
+"""
+1、定义类
+2、创建测试方法test开头
+3、创建setup_class,teardown_class
+4、运行查看结果
+
+"""
+
+#1定义类
+class TestClass:
+ #3、创建setup_class,teardown_class
+ def setup_class(self):
+ print("---setup_class---")
+
+ def teardown_class(self):
+ print("---teardown_class---")
+
+ #2、创建测试方法test开头
+ def test_a(self):
+ print("test_a")
+
+ def test_b(self):
+ print("test_b")
+
+#4、运行查看结果
+if __name__ =="__main__":
+ pytest.main(["-s","pytest_class.py"])
+
+
+返回信息如下：
+
+============================= test session starts ==============================
+collecting ... collected 2 items
+
+pytest_class.py::TestClass::test_a ---setup_class---
+PASSED [ 50%]test_a
+
+pytest_class.py::TestClass::test_b PASSED [100%]test_b
+---teardown_class---
+
+
+============================== 2 passed in 0.01s ===============================
+
+进程已结束,退出代码0
+
+
+我们发现，无论执行多少个测试方法，setup_class和teardown_class方法只会执行一次。
+
+pytest常用插件
+
+pytest-html
+
+测试报告插件，可以将测试结果以html的形式展示出来。
+
+安装pytest-html插件，在requirements.txt文件中添加pytest-html，然后在终端中运行pip install -r requirements.txt安装插件。
+
+使用,在配置文件pytest.ini中的命令行参数中增加 –html=用户路径/report.html
+
+[pytest]
+addopts = -s --html=../../report/report.html
+
+
+执行之前写好的pytest_demo.py文件，查看生成的测试报告。./../report是回到根目录下，创建一个report文件夹，report.html是生成的测试报告。
+
+失败重试
+
+自动化测试脚本可能会使用到网络，如果网络不好可能最终会使脚本不通过。像这种情况可能并不是脚本本身的问题，仅仅是因为网络忽快忽慢，那么我们可以使用失败重试的插件，当失败后尝试再次运行。一般情况最终成功可以视为成功，但最好进行进行排查时候是脚本问题。
+
+安装方法：在requirements.txt文件中添加pytest-rerunfailures，然后在终端中运行pip install -r requirements.txt安装插件。
+
+使用方法：在配置文件pytest.ini中的命令行参数中增加 –reruns=3,表示失败之后重试3次。重试时，如果脚本通过，那么后续不再重试。
+
+[pytest]
+addopts =-s --html=../../report/report.html --reruns 3
+
+
+也可以加reruns-delay参数，表示失败之后重试的间隔时间。
+
+[pytest]
+addopts =-s --html=../../report/report.html --reruns 3 --reruns-delay 2
+
+
+除了在pytest.ini中配置，也可以添加mark标记，在测试用例中添加@mark.flaky(reruns=3,reruns_delay=2)，可以只对某个测试用例进行失败重试。
+@mark是装饰器，flaky表示标记。
+
+数据参数化
+
+应用场景
+
+登录功能都是输入用户名，输入密码，点击登录。但登录的用户名和密码如果想测试多个值是没有办法用普通的操作实现的。数据参数化可以帮我实现这样的效果。
+
+方法名
+pytest.mark.parametrize(argnames,argvalues,indirect=False,ids=None,scope=None)
+
+argnames：参数名
+
+argvalues：参数对应值，类型必须为可迭代类型，一般使用list
+
+indirect：是否对参数值进行间接调用，如果为True，那么参数值必须是函数名，否则报错;
+
+ids：参数值对应的id，如果不指定，那么默认使用参数值，如果指定，那么参数值必须和ids的长度一致，否则报错;
+
+scope：参数值的作用域，可以是function、class、module、session，如果不指定，那么默认为function.
+
+以下是传入单个参数的例子：
+
+import pytest
+
+"""
+1、创建类和测试方法
+2、创建数据
+3、创建参数化
+4、运行
+"""
+#1、创建类和测试方法
+class TestDemo:
+ # 2、创建测试数据
+ data_list = ["xiaoming","xiaohong"]
+
+ # 3、参数化
+ @pytest.mark.parametrize("name",data_list)
+
+ # 1、创建类和测试方法
+ def test_a(self,name):
+ print("test_a")
+ print(name)
+ assert 1
+
+if __name__ == "__main__":
+ pytest.main(["pytest_one.py"])
+
+
+以下是多个参数的例子：多个参数是以元祖的方式传入的，元祖中的每个元素对应一个参数。
+@pytest.mark.parametrize((‘param1’,’param2’),[(value1[0],value1[1]),(value2[0],value2[1])])
+
+
+import pytest
+
+"""
+1、创建类和测试方法
+2、创建数据
+3、创建参数化
+4、运行
+"""
+#1、创建类和测试方法
+class TestDemo:
+ #2、创建测试数据
+ data_list = [("xiaoming","123456"),("xiaohong","456789")]
+
+ #3、参数化
+ @pytest.mark.parametrize(("name","password"),data_list)
+ def test_a(self,name,password):
+ print("test_a")
+ print(name,password)
+ assert 1
+
+if __name__ == "__main__":
+ pytest.main(["pytest_two.py"])
+
+
+利用pytest来进行接口自动化测试
+
+pytest运行原则：在不指定运行目录，运行文件，运行函数等参数的默认情况下，pytest会执行当前目录下所有以test为前缀(test.py)或者以_test结尾(_test.py)的文件中以test开头的测试方法。
+
+因此，我们需要根据默认运行原则，调整py文件命名，函数命名（比如所之前的login():改成test_login():，也就算重构我们之前的五个接口模块。 然后，pytest.main()运行，或者命令行直接pytest运行。
+
+另外，我们还可以通过pytest.ini文件来配置运行参数，比如指定运行文件，运行函数等。
+
+pytest.ini文件内容如下：
+
+[pytest]
+# 指定运行路径
+testpaths = ./testcase
+# 指定执行目录下的文件
+python_files = test_*.py
+# 指定执行测试类
+python_classes = Test*
+# 指定执行测试方法
+python_functions = test_*
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/71/399fec69e0edfa2680f147ed854192127986d74b4f63298f73a6d304413c89 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/71/399fec69e0edfa2680f147ed854192127986d74b4f63298f73a6d304413c89
new file mode 100644
index 0000000000..53bc5df1a3
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/71/399fec69e0edfa2680f147ed854192127986d74b4f63298f73a6d304413c89
@@ -0,0 +1,91 @@
+I"Markdowm插件Office Viewer介绍以及vscode+PicGO+Github搭建个人博客图床
+
+Markdowm插件
+
+
+
+图片、表格、代码块，列表（有序、无序、任务）、引用、分隔、斜体等傻瓜式操作；方便快速写标题以及大纲视图；导出PDF极其方便；最上方预览小按钮点击之后进入预览界面，可以选择桌面或者手机端浏览，可以把写好的内容直接发布到微信公众号或者知乎；CSDN博客的内容如果是用markdown写的，直接复制进来，格式都不用调整。
+
+
+
+PicGO介绍
+
+vscode上有一个picgo插件，可以让我们用快捷键即可上传图片到默认的免费服务器，具体的使用方法是，安装完成后：
+
+
+ - Ctrl+Alt+U 从剪切板粘贴图片，上传到服务器；
+ - Ctrl+Alt+E 打开资源管理器，选择图片。
+
+
+picgo默认上传的服务器是 SM.MS服务器，由于你懂得原因，国内的访问速度让人抓狂，但是picgo支持github以及阿里云作为图床。
+
+其中，github图床最为稳定，且一个仓库上限是100G，只做图床绰绰有余。最糟糕的一点是速度，但是使用cdn加速之后速度还是可以的。
+
+Github图床设置
+
+
+ - 打开github，创建新的public仓库，仓库名称可以设置为PicgoBed。
+ -
+
进入个人设置页面，选择开发者设置
+
+ 
+
+ -
+
选择Personal access tokens，选择生成新token，此token是图床上传时验证身份用的；添加描述，将repo选上，Expiration选择no expiration
+
+ 
+
+ - 将生成的字符串保存，关闭页面后将再也无法看到这个字符串了
+
+
+PicGO设置
+
+GitHub设置完之后，我们需要修改picgo插件的设置，把服务器编程我们的图床，具体设置如下：
+
+
+ - vscode右下角选择设置,搜索设置里面输入PicGO,打开扩展里面的PicGO
+ - 设置如下,github token写我们刚才复制下来的
+
+
+
+
+
+ current设置为GitHubBranch是我们仓库的分支，默认为 master 或者 maincustom url 使我们图片上传的连接，有两种方式可以使用
+
+ - 原生方式
+
+ - 使用GitHub原生连接，格式为
https://raw.githubusercontent.com/用户名/仓库名/分支名
+ - 我的例子
https://raw.githubusercontent.com/ChanJeunlam/PicgoBed
+ - 原生方式有一个弊端就是，国内速度比较慢
+
+
+ - cdn加速方式
+
+ - 格式为
https://cdn.jsdelivr.net/gh/用户名/仓库名@分支名
+ - 我的例子
https://cdn.jsdelivr.net/gh/ChanJeunlam/PicgoBed
+ - cdn加速的优点是国内访问速度比较快
+
+
+
+ path是我们的图片存储在仓库中的路径，比如我的是 blogs/pictures/Repo是我们的仓库地址，Username/Repo,比如说我的是 ChanJeunlam/PicgoBed.
+
+其他可能出现的问题的处理:
+
+
+ Branch里面的main写错成masterChanJeunlam/PicgoBed 加了空格，写错成 ChanJeunlam / PicgoBed，导致上传到服务器失败。
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/73/bf7ce919aad37ede3b68422e6412301d59231379af8b15d68347df9b1b1a39 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/73/bf7ce919aad37ede3b68422e6412301d59231379af8b15d68347df9b1b1a39
new file mode 100644
index 0000000000..9234863b44
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/73/bf7ce919aad37ede3b68422e6412301d59231379af8b15d68347df9b1b1a39
@@ -0,0 +1,207 @@
+I" 1. 数据来源
+
+和鲸社区-太湖站2001-2006年水质监测数据集
+
+包括两个文件：
+
+
+ - 太湖站水质观测站点数据.xlsx
+ - 2001-2006年太湖水体物理及水体化学监测数据.xlsx
+
+
+2. 站点分布示意图
+
+import pandas as pd
+import folium
+import matplotlib.pyplot as plt
+# 1. 读取数据
+df = pd.read_excel(r'.\太湖站水质观测站点数据.xlsx')
+print(df.head())
+
+# Drop the second row of the dataframe to remove the header
+df = df.drop([0])
+# Reset the index of the dataframe
+df = df.reset_index(drop=True)
+
+
+# 2. 画出站点分布
+
+# Create a map object centered at (31.3, 120.6)
+# Set the range of longitude and latitude for the map
+east_min = df['东经'].min() - 5
+east_max = df['东经'].max() + 5
+north_min = df['北纬'].min() - 5
+north_max = df['北纬'].max() + 5
+
+# Create a map object centered at with the new range of longitude and latitude
+map = folium.Map(location=[(north_max+north_min)/2, (east_max+east_min)/2], zoom_start=10, control_scale=True, tiles='Stamen Terrain')
+# tiles表示地图的样式；max_bounds表示地图的最大范围；control_scale表示是否显示比例尺
+# Add markers to the map for each observation station
+for index, row in df.iterrows():
+ folium.Marker(location=[row['北纬'], row['东经']], tooltip=row['观测站代码']).add_to(map)
+
+# Display the map
+map
+
+# Save the map as an HTML file
+map.save('map.html')
+
+
+
+
+3. 物理性质数据分析
+
+对水深随着时间变化进行探究。
+
+import pandas as pd
+import matplotlib.pyplot as plt
+# 读入2001-2006年太湖水体物理及水体化学监测数据.xlsx中的表格2001-2006年太湖水体物理监测数据
+df2 = pd.read_excel(r'.\2001-2006年太湖水体物理及水体化学监测数据.xlsx', sheet_name='2001-2006年太湖水体物理监测数据')
+df2 = df2.drop([0])
+# Reset the index of the dataframe
+df2 = df2.reset_index(drop=True)
+# Round the values in the '年' column to the nearest integer
+df2['年'] = df2['年'].astype(int)
+df2['月'] = df2['月'].astype(int)
+# Combine the '年' and '月' columns into a single 'date' column in df2
+df2['date'] = pd.to_datetime({'year': df2['年'], 'month': df2['月'], 'day': 1})
+print(df2.head())
+
+# 画出水深随时间变化的折线图
+df2_THL00 = df2[df2['站点'] == 'THL00']
+df2_THL00 = df2_THL00.set_index('date')
+df2_THL00['水深'].plot()
+# title表示图的标题；xlabel表示x轴的标题；ylabel表示y轴的标题
+plt.title('THL00 Water Depth')
+plt.xlabel('Date')
+plt.ylabel('Water Depth (m)')
+
+# 画出所有的站点水深随时间变化的折线图
+for station in df2['站点'].unique():
+ df2_station = df2[df2['站点'] == station]
+ df2_station = df2_station.set_index('date')
+ df2_station['水深'].plot()
+ plt.title(station + ' Water Depth')
+ plt.xlabel('Date')
+ plt.ylabel('Water Depth (m)')
+ plt.show()
+
+# 画在一张图上
+# 设置图的大小
+plt.figure(figsize=(10, 10))
+for station in df2['站点'].unique():
+ df2_station = df2[df2['站点'] == station]
+ df2_station = df2_station.set_index('date')
+ df2_station['水深'].plot()
+plt.title('Water Depth')
+plt.xlabel('Date')
+plt.ylabel('Water Depth (m)')
+# 设置legend的位置在图的外面
+plt.legend(df2['站点'].unique(), loc='center left', bbox_to_anchor=(1, 0.5))
+plt.show()
+
+
+输出结果部分：
+
+
+
+
+
+
+
+4. 化学性质数据分析
+
+对PH值进行探究，使用克里金插值的方法。
+
+import pandas as pd
+# 读入2001-2006年太湖水体物理及水体化学监测数据.xlsx中的表格2001-2006年太湖水体物理监测数据
+df3 = pd.read_excel(r'.\2001-2006年太湖水体物理及水体化学监测数据.xlsx', sheet_name='2001-2006年太湖水体化学监测数据')
+df3 = df3.drop([0])
+# Reset the index of the dataframe
+df3 = df3.reset_index(drop=True)
+# Round the values in the '年' column to the nearest integer
+df3['年'] = df3['年'].astype(int)
+df3['月'] = df3['月'].astype(int)
+# Combine the '年' and '月' columns into a single 'date' column in df3
+df3['date'] = pd.to_datetime({'year': df3['年'], 'month': df3['月'], 'day': 1})
+df3=df3.set_index('date')
+print(df3.head())
+
+
+# 读取站点位置
+df = pd.read_excel(r'.\太湖站水质观测站点数据.xlsx')
+# Drop the second row of the dataframe to remove the header
+df = df.drop([0])
+# Reset the index of the dataframe
+df = df.reset_index(drop=True)
+
+# Rename the columns
+df['站点'] = df['观测站代码']
+# drop columns
+df = df.drop(['观测站序号','观测站代码'], axis=1) # axis=1表示列
+print(df.head())
+
+# 提取df3中的两列，分别是站点和PH值
+df3_ph = df3[['站点', 'pH']]
+
+df3_ph_20010101 = df3_ph[df3_ph.index == '2001-01-01']
+
+# 根据站点拼接df3_ph_20010101和df
+df_merged = pd.merge(df, df3_ph_20010101, on='站点', how='left')
+
+# 克里金插值，df_merged中的ph
+# 克里金插值需要使用外部库pykrige，需要先安装
+# pip install pykrige
+
+# 导入外部库
+import numpy as np
+from pykrige.ok import OrdinaryKriging
+
+
+# 将df_merged中的经纬度和pH值提取出来
+X = df_merged[['东经', '北纬']].values
+y = df_merged['pH'].values
+
+# 设置克里金插值的网格范围
+grid_lon = np.arange(df_merged['东经'].min()-0.1, df_merged['东经'].max()+0.1, 0.01)
+grid_lat = np.arange(df_merged['北纬'].min()-0.1, df_merged['北纬'].max()+0.1, 0.01)
+
+
+# Generate ordinary kriging object
+OK = OrdinaryKriging(
+ np.array(X[:, 0]),
+ np.array(X[:, 1]),
+ y,
+ variogram_model = "linear",
+ verbose = False,
+ enable_plotting = False,
+ coordinates_type = "euclidean",
+)
+
+# 进行克里金插值
+z, ss = OK.execute('grid', grid_lon, grid_lat)
+
+# 将插值结果可视化
+plt.figure(figsize=(10, 10))
+# pcolor of z
+plt.pcolor(grid_lon, grid_lat, z, cmap='jet')
+plt.colorbar()
+#plt.scatter(X[:, 0], X[:, 1], c=y, cmap='jet', edgecolor='k')
+plt.title('pH Interpolation')
+plt.xlabel('Longitude')
+plt.ylabel('Latitude')
+plt.show()
+
+
+部分结果输出如下：
+
+
+
+
+
+
+
+克里金插值结果如下：（感觉是错的，不改了）
+
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/74/343a67d62c7266afee8847734ba8d326a307a68e34b1b6b55e81fe7c040aa9 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/74/343a67d62c7266afee8847734ba8d326a307a68e34b1b6b55e81fe7c040aa9
new file mode 100644
index 0000000000..cd98241a98
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/74/343a67d62c7266afee8847734ba8d326a307a68e34b1b6b55e81fe7c040aa9
@@ -0,0 +1,13 @@
+I"
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/74/951bcce75676fc2548ca6b73dfc78df9f36df8be8a1630b4a4b708b30c645f b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/74/951bcce75676fc2548ca6b73dfc78df9f36df8be8a1630b4a4b708b30c645f
new file mode 100644
index 0000000000..6ccdafcc1b
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/74/951bcce75676fc2548ca6b73dfc78df9f36df8be8a1630b4a4b708b30c645f
@@ -0,0 +1,199 @@
+I" libpython3.7m.so.1.0: /usr/local/lib/libpython3.7m.so.1.0
+
+安装 MySQL
+
+sudo apt update
+sudo apt install mysql-server
+
+
+查看默认用户名和密码
+
+新版的MySQL安装后，默认用户名不是root，为了方便，一般我们需要修改成我们想要的用户名和密码。进入配置文件：
+
+vim /etc/mysql/debian.cnf
+
+
+结果如下：
+
+
+
+默认的密码为：
+
+user = debian-sys-maint
+password = VDgQcUjzyfPfgxbA
+
+
+登录数据库并修改用户名和密码
+
+mysql -udebian-sys-maint -p
+
+
+查看mysql中默认数据库：（记得sql结尾要加分号）
+
+show databases;
+
+
+
+
+使用数据库mysql:
+
+use mysql;
+
+
+
+
+将root密码设置为空：
+
+update user set authentication_string='' where user='root';
+
+
+清空root用户默认的密码：
+
+select user,authentication_string from user where user='root';
+
+
+
+
+为root设置密码：ALTER user
+
+ALTER user 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY '123456';
+
+
+查看设置root用户和密码：
+
+select user,authentication_string from user where user='root';
+
+
+
+
+退出SQL:
+
+quit;
+
+
+在mysql8.0之后的版本中，password函数已被取消，加密方式不再使用mysql_native_password，换成了caching_sha2_password.
+
+原本的sql语句为：
+
+UPDATE user SET authentication_string=password("密码") WHERE user="root";
+1
+
+
+对应的写法可以改为：
+
+UPDATE user SET authentication_string=SHA1("密码") WHERE user="root";
+
+
+配置MySQL远程登陆
+
+#修改配置文件，注释掉 bind-address = 127.0.0.1
+$ sudo vi /etc/mysql/mysql.conf.d/mysqld.cnf
+
+# 保存退出，然后进入mysql服务，执行授权命令：(输入密码123456)
+$ mysql -uroot -p
+
+
+
+
+localhost即本地主机的域名，如同：www.baidu.com ，也是本机ip地址，整个127.* 网段通常被用作loopback网络接口的默认地址，按照惯例通常设置为127.0.0.1。我们当前这个主机上的这个地址，别人不能访问，即使访问，也是访问自己。因为每一台TCP/IP协议栈的设备基本上都有local/127.0.0.1.
+
+进入数据库之后，查看当前主机配置信息为localhost，需要修改为%：(目的是为了让所有主机都能访问)
+
+use mysql;
+select host from user where user='root';
+
+
+将Host设置为通配符%:
+
+update user set host = '%' where user ='root';
+
+
+修改后要刷新一下:
+
+flush privileges;
+
+
+查看是否修改成功:
+
+select host from user where user='root';
+
+
+
+
+退出数据库后重启数据库服务：(然后就可以在数据库工具远程MySQL数据库了。)
+
+sudo /etc/init.d/mysql restart #重启mysql服务
+
+
+在远程数据库远程连接MySQL数据库了
+
+首先是进行测试，无论您如何安装它，MySQL 都应该自动开始运行。要对此进行测试，请检查其状态。
+
+sudo systemctl status mysql
+
+
+
+
+然后，使用 ss 命令检查开放端口：
+
+sudo ss -ltn
+
+
+
+
+可以看出，我们的服务器正在侦听端口 3306 和 33060 上的连接。这些是与 HTTP 和 MySQL 相关的端口。
+
+在我们的本地系统上使用ss或者nmap localhost命令时，我们绕过了防火墙。实际上，这些命令显示处于侦听状态的端口，但这并不一定意味着端口对 Internet 开放，因为我们的防火墙可能拒绝连接。
+
+使用以下命令检查 ufw 防火墙的状态。
+
+sudo ufw status verbose
+
+
+可以发现，防火墙状态为不活动。
+
+
+
+如果防火墙状态为active状态， ufw 拒绝传入连接。由于端口 80 和 3306 尚未添加为例外，因此 HTTP 和 MySQL 无法接收传入连接，尽管ss并nmap报告它们处于侦听状态。
+
+让我们使用以下命令为这些端口添加例外。
+
+sudo ufw allow 80/tcp
+sudo ufw allow 3306/tcp
+
+
+navicat安装破解教程
+
+使用ifconfig查看服务器ip地址，然后在navicat中连接数据库。
+
+
+连接结果如下：
+
+
+
+也可以用VSCode来管理MySql数据库：
+
+
+ - 点击左侧扩展插件，然后搜索下MySql；
+ - 安装过后，我们就需要连接了，直接快捷键，Ctrl+Shift+P，打开窗口；
+ - 设置如下：
+
+ 
- 端口号默认3306
+ - 连接结果如下：
+
+
+
+
+参考链接
+
+Ubuntu安装MySQL8.0，并用Navicat远程连接_任求其-zzx的博客-CSDN博客
+
+Ubuntu 20.04 安装 MySQL 8.0 并且远程连接数据库(包括后续遇到的新坑)_Nymph2333的博客-CSDN博客_executing /lib/systemd/systemd-sysv-install enable
+
+在 Ubuntu 22.04 上安装 Python 3.9（多版本适用） - 知乎 (zhihu.com)
+
+Index of python-local/3.7.12 (huaweicloud.com)
+
+在Ubuntu 18.04上安装不同版本的python及选择默认Python_WMLCOLIN的博客-CSDN博客
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/75/3c88e5609975d95219cc90dd345f64a43b37ecd09b5cf04cc7acdf753c9e16 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/75/3c88e5609975d95219cc90dd345f64a43b37ecd09b5cf04cc7acdf753c9e16
new file mode 100644
index 0000000000..012b967929
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/75/3c88e5609975d95219cc90dd345f64a43b37ecd09b5cf04cc7acdf753c9e16
@@ -0,0 +1,18 @@
+I"
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/75/ce283c59e3d6a53016cac19bfe1d45faa26da27c7577b0da4de534a6a38f0e b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/75/ce283c59e3d6a53016cac19bfe1d45faa26da27c7577b0da4de534a6a38f0e
new file mode 100644
index 0000000000..a9414cdaaf
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/75/ce283c59e3d6a53016cac19bfe1d45faa26da27c7577b0da4de534a6a38f0e
@@ -0,0 +1,184 @@
+I" 音乐-起风了
+
+https://link.jscdn.cn/sharepoint/aHR0cHM6Ly9oa3VzdGNvbm5lY3QtbXkuc2hhcmVwb2ludC5jb20vOnU6L2cvcGVyc29uYWwvamNoZW5mbF9jb25uZWN0X3VzdF9oay9FVE1tNEYwRU1CSkt0UGJKNDlmbkFVWUJWdUZXYUJ0RzVZTlVoRlFGV0FtY2NBP2U9RlZ4bkxB.mp3
+
+要求
+
+
+ - jekyll
+ - 七牛
+ - Onedrive
+
+
+开始使用
+
+step1
+
+首先下载这个文件open-embed.html,右键,另存为 Html;下面是源码,也可以复制保存下面的源码;
+
+<style>
+.videoWrapper {
+ position: relative;
+ padding-bottom: 56.333%;
+ height: 0;
+ background: black;
+}
+.videoWrapper iframe {
+ position: absolute;
+ top: 0;
+ left: 0;
+ width: 100%;
+ height: 100%;
+ border: 0;
+}
+</style>
+
+<script>
+function get_youtube_id(url) {
+ var p = /^(?:https?:\/\/)?(?:www\.)?(?:youtu\.be\/|youtube\.com\/(?:embed\/|v\/|watch\?v=|watch\?.+&v=))((\w|-){11})(?:\S+)?$/;
+ return (url.match(p)) ? RegExp.$1 : false;
+}
+function vimeo_embed(url,el) {
+ var id = false;
+ $.ajax({
+ url: 'https://vimeo.com/api/oembed.json?url='+url,
+ async: true,
+ success: function(response) {
+ if(response.video_id) {
+ id = response.video_id;
+ if(url.indexOf('autoplay=1') !== -1) var autoplay=1; else var autoplay=0;
+ if(url.indexOf('loop=1') !== -1) var loop=1; else var loop=0;
+ var theInnerHTML = '<div class="videoWrapper"><iframe src="https://player.vimeo.com/video/'+id+'/?byline=0&title=0&portrait=0';
+ if(autoplay==1) theInnerHTML += '&autoplay=1';
+ if(loop==1) theInnerHTML += '&loop=1';
+ theInnerHTML += '" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe></div>';
+ el.innerHTML = theInnerHTML;
+ }
+ }
+ });
+}
+function video_embed() {
+ var p = document.getElementsByTagName('p');
+ for(var i = 0; i < p.length; i++) {
+ //check if this is an external url (that starts with https:// or http://
+ if (p[i].innerHTML.indexOf("http://") == 0 ||
+ p[i].innerHTML.indexOf("https://") == 0) {
+ var youtube_id = get_youtube_id(p[i].innerHTML);
+ if(youtube_id) {
+ if(p[i].innerHTML.indexOf('autoplay=1') !== -1) var autoplay=1; else var autoplay=0;
+ if(p[i].innerHTML.indexOf('loop=1') !== -1) var loop=1; else var loop=0;
+ var theInnerHTML = '<div class="videoWrapper"><iframe width="720" height="420" src="https://www.youtube.com/embed/' + youtube_id + '?rel=0&showinfo=0';
+ if(autoplay==1) theInnerHTML += '&autoplay=1';
+ if(loop==1) theInnerHTML += '&loop=1&playlist='+youtube_id+'&version=3';
+ theInnerHTML += '" frameborder="0" allowfullscreen></iframe></div>';
+ p[i].innerHTML = theInnerHTML;
+ }
+ if(p[i].innerHTML.indexOf('vimeo.com') !== -1) {
+ //ask vimeo for the id and place the embed
+ vimeo_embed(p[i].innerHTML,p[i]);
+ }
+ }
+ }
+}
+video_embed();
+
+function mp3_embed() {
+ var p = document.getElementsByTagName('p');
+ var song_format = ['.mp3','.m4a','.wma']; // 音乐格式，判断是否属于这几个格式
+ for(var i = 0; i < p.length; i++) {
+ for(var j=0;j<song_format.length;j++){
+ if(p[i].innerHTML.toLowerCase().indexOf(song_format[j]) !== -1) {
+ var str = p[i].innerHTML.split('?');
+ if(str.length == 1) str[1] = '';
+ var str1 = str[1];
+ str1 = str1.replace('&','').replace('&','');
+ str1 = str1.replace('autoplay=1','').replace('autoplay=0','');
+ str1 = str1.replace('loop=1','').replace('loop=0','');
+ str1 = str1.replace('controls=0','').replace('controls=1','');
+
+ if (str[0].toLowerCase().lastIndexOf(song_format[j], str[0].length - 4) === str[0].length - 4 && str1.length == 0) {
+ if(str[1].indexOf('autoplay=1') !== -1) var autoplay=1; else var autoplay=0;
+ if(str[1].indexOf('loop=1') !== -1) var loop=1; else var loop=0;
+ if(str[1].indexOf('controls=0') !== -1) var controls=0; else var controls=1;
+ var newInnerHTML = '<audio';
+ if(autoplay==1) newInnerHTML += ' autoplay';
+ if(loop==1) newInnerHTML += ' loop';
+ if(controls==1) newInnerHTML += ' controls';
+ newInnerHTML += '><source src="'+str[0]+'" type="audio/mpeg">Your browser does not support the audio element.</audio>';
+ p[i].innerHTML = newInnerHTML;
+ }
+ }
+ }
+
+ }
+}
+mp3_embed();
+</script>
+
+
+step2
+
+将上一步存储好的文件,保存到_includes目录下,就像下面这个样子
+
+
+
+step3
+
+在_layouts目录下,default.html这个文件,打开,在最下面,找到对应的标签 </body> ,加入如下代码,注意:标签不要重复了
+
+
+
+使用语法
+
+借助七牛云之类的图床或云端存储，将需要的音乐文件上传至图床，并获得外链。
+
+然后，在Markdown中直接使用：
+
+<p>音乐外链url</p>
+
+
+注意：音乐链接url增加了支持MP3、wma、m4a格式
+
+Onedrive音乐文件获取外链
+
+参考如下链接：
+
+生成外链
+
+先想办法把你要生成外链的音乐或者图片上传到OneDrive中。
+网页版的应该是被墙了，不科学上网用不了。
+现在的电脑上一般都有OneDrive的，自己搜一下。
+
+
+上图中我已经把两首歌放到OneDrive中了。
+
+然后把文件共享：在文件上右击，点 共享
+
+
+
+共享之后你就能看到这个，点左下角的按钮复制链接。
+
+
+
+我复制到的链接如下：
+
+
+ https://1drv.ms/u/s!AjennNdWMahGijT1WWHNP-Wjj_CF?e=LNajCn
+
+
+现在这样子肯定不能直接用了，需要借助转换工具。
+
+可以直接用这个生成链接：
+
+https://onedrive.gimhoy.com/
+
+你输入之后就会可以生成了。
+
+
+
+还有一个小工具可以批量生成 ：
+
+https://github.com/Mapaler/GetOneDriveDirectLink
+
+https://mapaler.github.io/GetOneDriveDirectLink/
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/75/f166839fcf41f5fcd91694fdebe6dff0810b621f1ed632c444ac477f6acc9c b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/75/f166839fcf41f5fcd91694fdebe6dff0810b621f1ed632c444ac477f6acc9c
new file mode 100644
index 0000000000..16b5011fa5
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/75/f166839fcf41f5fcd91694fdebe6dff0810b621f1ed632c444ac477f6acc9c
@@ -0,0 +1,2 @@
+I"Dbash脚本测试Ubuntu服务器的性能并输出报告
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/76/14a9950ae3faee1f360721b484bcf7e4d6e33d8bdf68c9ef4a64c3f4d1ccb1 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/76/14a9950ae3faee1f360721b484bcf7e4d6e33d8bdf68c9ef4a64c3f4d1ccb1
new file mode 100644
index 0000000000..e2da2cdf23
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/76/14a9950ae3faee1f360721b484bcf7e4d6e33d8bdf68c9ef4a64c3f4d1ccb1
@@ -0,0 +1,2 @@
+I"!代码
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/79/f6013351b8fda2b1a3306e17fa2d74bab6971113a4a2d5927b47b8448d3e92 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/79/f6013351b8fda2b1a3306e17fa2d74bab6971113a4a2d5927b47b8448d3e92
new file mode 100644
index 0000000000..7142b60d92
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/79/f6013351b8fda2b1a3306e17fa2d74bab6971113a4a2d5927b47b8448d3e92
@@ -0,0 +1,9 @@
+I"&
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/7a/75d4e541fa2cde30ba4939c1e9ac1598d2858635ee3e56ce6f512f99285530 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/7a/75d4e541fa2cde30ba4939c1e9ac1598d2858635ee3e56ce6f512f99285530
new file mode 100644
index 0000000000..6dbc161fe8
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/7a/75d4e541fa2cde30ba4939c1e9ac1598d2858635ee3e56ce6f512f99285530
@@ -0,0 +1,2 @@
+I"!简介
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/7b/d5786b713525fd15f62b0cb4fd4154a422f8dab9e238838e0e233dfc82b60b b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/7b/d5786b713525fd15f62b0cb4fd4154a422f8dab9e238838e0e233dfc82b60b
new file mode 100644
index 0000000000..d9215cf523
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/7b/d5786b713525fd15f62b0cb4fd4154a422f8dab9e238838e0e233dfc82b60b
@@ -0,0 +1,2 @@
+I"B下划线、双下划线
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/7c/8fdf8c5e407ae14d8f089388a98ca6edbbaaa17822490d2ce097298da031c8 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/7c/8fdf8c5e407ae14d8f089388a98ca6edbbaaa17822490d2ce097298da031c8
new file mode 100644
index 0000000000..571783dfdf
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/7c/8fdf8c5e407ae14d8f089388a98ca6edbbaaa17822490d2ce097298da031c8
@@ -0,0 +1,43 @@
+I"U
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/81/5825b0779fefc38d2c2ccca64ac0234f5707982313d15797a9214b2a0a43b5 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/81/5825b0779fefc38d2c2ccca64ac0234f5707982313d15797a9214b2a0a43b5
new file mode 100644
index 0000000000..b2e7e57e85
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/81/5825b0779fefc38d2c2ccca64ac0234f5707982313d15797a9214b2a0a43b5
@@ -0,0 +1,9 @@
+I"Y
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/81/cafdef9a37a00dda1e61d8b0095c065de6a48328e9b7769ec3db582cd9029a b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/81/cafdef9a37a00dda1e61d8b0095c065de6a48328e9b7769ec3db582cd9029a
new file mode 100644
index 0000000000..0390e24c80
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/81/cafdef9a37a00dda1e61d8b0095c065de6a48328e9b7769ec3db582cd9029a
@@ -0,0 +1,5 @@
+I"o一个学不会地球流体力学的物理海洋学生瓜蛋子。
+
+ 为啥想写博客
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/82/31e44b713294aef928bdd73b43fe22afaa6345225e0b1556f2dc1b5927d0ad b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/82/31e44b713294aef928bdd73b43fe22afaa6345225e0b1556f2dc1b5927d0ad
new file mode 100644
index 0000000000..c48fbfbe1d
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/82/31e44b713294aef928bdd73b43fe22afaa6345225e0b1556f2dc1b5927d0ad
@@ -0,0 +1,2 @@
+I"主要包括使用一维卷积神经网络(1D CNN)对安装在远程风机的高速轴承中的现场传感器采集到的时间序列数据通过短时傅里叶变化之后得到的频谱峰度（Kurtosis Spectogram）进行分类，得到每个样品的类别：中等寿命级（预期寿命大于15天的轴承——状态良好）以及短寿命轴承（预期寿命小于15天的轴承——状态不良）。
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/85/0def218df037c02eeee1561a058a6a19343ca5995d03da6f95d68145cb54bf b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/85/0def218df037c02eeee1561a058a6a19343ca5995d03da6f95d68145cb54bf
new file mode 100644
index 0000000000..9b60d0efd1
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/85/0def218df037c02eeee1561a058a6a19343ca5995d03da6f95d68145cb54bf
@@ -0,0 +1,2 @@
+I"5音乐-起风了
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/85/27e4718365c7e3600a86cde789b4bba7ea0217be256323998f0dd795f628fb b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/85/27e4718365c7e3600a86cde789b4bba7ea0217be256323998f0dd795f628fb
new file mode 100644
index 0000000000..613f15b1d4
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/85/27e4718365c7e3600a86cde789b4bba7ea0217be256323998f0dd795f628fb
@@ -0,0 +1,270 @@
+I",主要包括python一些不太常见的知识点以及python高阶编程需要用到的知识点等等。
+比如说*args 和 **kwargs在函数传参以及函数调用中的用法，以及python中的装饰器等等。
+还比如说pdb在程序运行时查看变量的值，查看程序的执行流程，以及查看函数的调用栈。
+还例如，python中的Map、Reduce、Filter、Lambda等在函数式编程中的用法。
+
+*args 和 **kwargs
+
+其实并不是必须写成*args 和*kwargs。 只有变量前面的 *(星号)才是必须的. 你也可以写成*var 和*vars. 而写成*args 和**kwargs只是一个通俗的命名约定。
+
+*args 和 **kwargs 主要用于函数定义。 你可以将不定数量的参数传递给一个函数。
+
+预先并不知道, 函数使用者会传递多少个参数给你, 所以在这个场景下使用这两个关键字。
+
+*args 是用来发送一个非键值对的可变数量的参数列表给一个函数.
+
+def test_var_args(f_arg, *argv):
+ print("first normal arg:", f_arg)
+ for arg in argv:
+ print("another arg through *argv:", arg)
+
+test_var_args('yasoob', 'python', 'eggs', 'test')
+
+这会产生如下输出:
+first normal arg: yasoob
+another arg through *argv: python
+another arg through *argv: eggs
+another arg through *argv: test
+
+
+**kwargs 允许你将不定长度的键值对, 作为参数传递给一个函数. 如果你想要在一个函数里处理带名字的参数, 你应该使用**kwargs.
+
+举个例子：
+
+def greet_me(**kwargs):
+ for key, value in kwargs.items():
+ print("{0} == {1}".format(key, value)) # .format()是python3的新特性, 用于格式化字符串,{0}表示第一个参数,{1}表示第二个参数
+ # 也可以用%来格式化字符串
+ print("%s == %s" % (key, value)) %s表示字符串,%d表示整数,%f表示浮点数
+gree_me(name="yasoob")
+
+这会产生如下输出:
+name == yasoob
+name == yasoob
+
+
+使用 *args 和 **kwargs 来调用函数
+
+那现在我们将看到怎样使用*args和**kwargs 来调用一个函数。 假设，你有这样一个小函数：
+def test_args_kwargs(arg1, arg2, arg3):
+ print("arg1:", arg1)
+ print("arg2:", arg2)
+ print("arg3:", arg3)
+
+我们可以使用下面的方式来调用这个函数：
+# first with *args
+args = ("two", 3, 5)
+test_args_kwargs(*args)
+# now with **kwargs:
+kwargs = {"arg3": 3, "arg2": "two", "arg1": 5}
+test_args_kwargs(**kwargs)
+
+这会产生如下输出:
+arg1: two
+arg2: 3
+arg3: 5
+arg1: 5
+arg2: two
+arg3: 3
+
+使用顺序
+
+那么如果你想在函数里同时使用所有这三种参数， 顺序是这样的：
+some_func(fargs, *args, **kwargs)
+
+
+def test_args_kwargs(arg1, arg2, arg3, *args, **kwargs):
+ print("arg1:", arg1)
+ print("arg2:", arg2)
+ print("arg3:", arg3)
+ for arg in args:
+ print("another arg:", arg)
+ for kwarg in kwargs:
+ print("another keyword arg: {0} = {1}".format(kwarg, kwargs[kwarg]))
+
+
+什么时候使用它们？
+要看你的需求而定，最常见的用例是在写函数装饰器的时候，此外它也可以用来做猴子补丁(monkey patching)。猴子补丁的意思是在程序运行时(runtime)修改某些代码。
+
+打个比方，你有一个类，里面有个叫get_info的函数会调用一个API并返回相应的数据。如果我们想测试它，可以把API调用替换成一些测试数据。例如：
+
+import someclass # someclass是你定义的类
+
+def get_info(self, *args): # 这里的self是类的实例，*args是可变参数，可以传入任意多个测试数据
+ return "Test data"
+
+someclass.get_info = get_info
+
+
+调试（Debugging）
+
+利用好调试，能大大提高你捕捉代码Bug的。
+Python debugger(pdb)可以帮助我们在程序运行时查看变量的值，查看程序的执行流程，以及查看函数的调用栈。
+
+pdb 模块定义了一个交互式源代码调试器，用于 Python 程序。它支持在源码行间设置（有条件的）断点和单步执行，检视堆栈帧，列出源码列表，以及在任何堆栈帧的上下文中运行任意 Python 代码。它还支持事后调试，可以在程序控制下调用。
+
+调试器是可扩展的——调试器实际被定义为 Pdb 类。该类目前没有文档，但通过阅读源码很容易理解它。扩展接口使用了 bdb 和 cmd 模块。
+
+pdb
+从命令行运行
+将 pdb.py 作为脚本调用，来调试其他脚本。你可以在命令行使用Python debugger运行一个脚本， 举个例子：
+python -m pdb myscript.py
+
+这会触发debugger在脚本第一行指令处停止执行。这在脚本很短时会很有帮助。你可以通过(Pdb)模式接着查看变量信息，并且逐行调试。
+
+从脚本内部运行
+
+同时，你也可以在脚本内部设置断点，这样就可以在某些特定点查看变量信息和各种执行时信息了。这里将使用pdb.set_trace()方法来实现。举个例子：
+import pdb
+def make_bread():
+ pdb.set_trace() # 这里设置断点,程序会在这里停止,你可以查看运行到这里时的变量信息，然后按任意键继续执行，或者按c继续执行到下一个断点
+ return "I don't have time"
+
+试下保存上面的脚本后运行之。你会在运行时马上进入debugger模式。现在是时候了解下debugger模式下的一些命令了。
+
+
+
+
+ | 命令 |
+ 简写 |
+ 说明 |
+
+
+
+
+ | help |
+ h |
+ 显示帮助信息 |
+
+
+ | list |
+ l |
+ 查看当前行的代码段 |
+
+
+ | continue |
+ c |
+ 继续执行到下一个断点 |
+
+
+ | quit |
+ q |
+ 退出debugger |
+
+
+ | print |
+ p |
+ 打印变量的值 |
+
+
+ | args |
+ a |
+ 打印函数的参数 |
+
+
+ | break |
+ b |
+ 设置断点 |
+
+
+ | bt |
+ |
+ 打印函数的调用栈 |
+
+
+ | return |
+ r |
+ 打印函数的返回值 |
+
+
+ | next |
+ n |
+ 执行下一行代码 |
+
+
+ | step |
+ s |
+ 进入函数内部 |
+
+
+
+
+单步跳过（next）和单步进入（step）的区别在于， 单步进入会进入当前行调用的函数内部并停在里面， 而单步跳过会（几乎）全速执行完当前行调用的函数，并停在当前函数的下一行。
+
+Map，Filter 和 Reduce
+
+Map，Filter 和 Reduce 三个函数能为函数式编程提供便利。我们会通过实例一个一个讨论并理解它们。
+
+Map
+Map会将一个函数映射到一个输入列表的所有元素上。这是它的规范：
+
+map(function_to_apply, list_of_inputs)
+
+
+大多数时候，我们要把列表中所有元素一个个地传递给一个函数，并收集输出。比方说：
+
+items = [1, 2, 3, 4, 5]
+squared = []
+for i in items:
+ squared.append(i**2)
+
+
+这里我们使用了一个循环来计算列表中每个元素的平方Map可以让我们用一种简单而漂亮得多的方式来实现。
+
+items = [1, 2, 3, 4, 5]
+squared = list(map(lambda x: x**2, items)) # map()返回一个迭代器，所以我们需要将它转换为一个列表
+
+
+不仅用于一列表的输入， 我们甚至可以用于一列表的函数！也即是说，list_of_inputs不仅可以是一个列表，还可以是一个函数列表。比方说：
+
+def multiply(x):
+ return (x*x)
+def add(x):
+ return (x+x)
+def exponent(x):
+ return (x**x) # x的x次方
+
+funcs = [multiply, add,exponent] # 这里我们有一个函数列表,我们可以将它传递给map,
+for i in range(5):
+ value = list(map(lambda x: x(i), funcs)) # x(i)将会调用funcs中的函数,并传递i作为参数
+ print(list(value))
+
+
+输出结果为：
+[0, 0, 1]
+[1, 2, 1]
+[4, 4, 4]
+[9, 6, 27]
+[16, 8, 256]
+
+
+Filter
+
+顾名思义，filter过滤列表中的元素，并且返回一个由所有符合要求的元素所构成的列表，符合要求即函数映射到该元素时返回值为True. 这里是一个简短的例子：
+
+number_list = range(-5, 5)
+less_than_zero = filter(lambda x: x < 0, number_list) # lambda x: x < 0是一个函数，它将会映射到number_list中的每个元素上,符合要求的元素将会被保留
+print(list(less_than_zero))
+
+输出结果为：
+[-5, -4, -3, -2, -1]
+
+这个filter类似于一个for循环，但它是一个内置函数，并且更快。
+注意：如果map和filter对你来说看起来并不优雅的话，那么你可以看看列表/字典/元组推导式。
+
+Reduce
+
+当需要对一个列表进行一些计算并返回结果时，Reduce 是个非常有用的函数。举个例子，当你需要计算一个整数列表的乘积时。
+
+通常在 python 中你可能会使用基本的 for 循环来完成这个任务。
+
+现在我们来试试 reduce：
+
+from functools import reduce # python3中reduce被移到了functools模块中
+product = reduce((lambda x, y: x * y), [1, 2, 3, 4]) # reduce()函数将会对列表中的元素进行迭代计算，x是上一次计算的结果，y是下一个元素，这里我们计算的是1*2*3*4，第一次迭代时x=1,y=2,第二次迭代时x=2,y=3,第三次迭代时x=6,y=4，最后保留的结果为24，是x的最终值。
+print(product)
+
+输出结果为：
+24
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/87/a5e13589cd2334bb457120bd4ab7f7410acb6534772cb568ba7a3afa1b1580 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/87/a5e13589cd2334bb457120bd4ab7f7410acb6534772cb568ba7a3afa1b1580
new file mode 100644
index 0000000000..0abb3518ad
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/87/a5e13589cd2334bb457120bd4ab7f7410acb6534772cb568ba7a3afa1b1580
@@ -0,0 +1,121 @@
+I"定义自己的异常类
+
+定义自己的错误类型有很多好处，比如可以清楚地显示出潜在的错误，让函数和模块更具可维护性。自定义错误类型还可用来提供额外的调试信息。
+
+Python中比较常见的泛型异常类包括像 ValueError，但是在栈调试回溯中，返回的内容可能用处不大。
+
+class NameTooShortError(ValueError):
+ pass
+def validate(name):
+ if len(name) < 10:
+ raise NameTooShortError(name)
+
+
+引入自定义异常类型来表示名字验证失败,现在有了能够“顾名思义”NameTooShortError 异常类型，它扩展自内置的 ValueError类。（其他的内置Error还包括Exception和TypeError类）
+
+还可以使用继承来根据逻辑对异常分组，组成层次结构。
+
+克隆对象
+
+Python 中的赋值语句不会创建对象的副本，而只是将名称绑定到对象上。对于不可变对象也是如此。但为了处理可变对象或可变对象集合，需要一种方法来创建这些对象的“真实副本”或“克隆体”。
+有时需要用到对象的副本，以便修改副本时不会改动本体。
+
+浅复制是指构建一个新的容器对象，然后填充原对象中子对象的引用。本质上浅复制只执行
+一层，复制过程不会递归，因此不会创建子对象的副本。
+深复制是递归复制，首先构造一个新的容器对象，然后递归地填充原始对象中子对象的副本。这种方式会遍历整个对象树，以此来创建原对象及其所有子项的完全独立的副本。
+
+下面的例子中将创建一个新的嵌套列表，然后用 list()工厂函数浅复制：
+
+xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+xs
+ys = list(xs)
+ys
+
+
+
+这里ys是一个新的独立对象，与xs具有相同的内容：
+
+>>> xs
+[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+>>> ys
+[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+>>>
+
+
+我们向原对象添加一个新列表，查看ys是否会跟着xs的变化而改变：
+
+xs.append(['new sublist'])
+xs
+ys
+
+
+可以看到,修改浅复制的列表完全不会影响副本。
+
+>>> xs
+[[1, 2, 3], [4, 5, 6], [7, 8, 9], ['new sublist']]
+>>> ys
+[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+>>>
+
+
+但由于前面只创建了原列表的浅副本，所以 ys 仍然含有 xs 子对象的引用！
+
+这些子对象没有复制，只是在 ys 中再次引用。因此在修改 xs 中的子对象时，这些改动也会反映在 ys 中——因为两个列表共享相同的子对象。这个副本是仅含有一层的浅复制：
+
+xs[1][0] = 'X'
+xs
+ys
+
+
+
+这里看上去这是修改了xs,但是ys和xs中索引1处的子列表都被修改了。
+
+>>> xs
+[[1, 2, 3], ['X', 5, 6], [7, 8, 9], ['new sublist']]
+>>> ys
+[[1, 2, 3], ['X', 5, 6], [7, 8, 9]]
+>>>
+
+
+而如果在第一步中创建的是 xs 的深副本，那么这两个对象会互相完全独立。
+
+制作深副本
+
+使用 copy 模块中定义的 deepcopy()函数创建深副本:
+
+import copy
+xs = [[1,2,3],[4,5,6],[7,8,9]]
+zs = copy.deepcopy(xs)
+
+
+这里，它们看起来是一样的。
+
+>>> xs
+[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+>>> zs
+[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+>>>
+
+
+我们看到如果修改原对象（xs）中的某个子对象，则会发现这些修改不会影响深副本（zs）。
+
+xs[1][0] = 'X'
+xs
+zs
+
+
+输出结果如下：
+
+>>> xs
+[[1, 2, 3], ['X', 5, 6], [7, 8, 9]]
+>>> zs
+[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+>>>
+
+
+还可以使用 copy 模块中的一个函数来创建浅副本。copy.copy()函数会创建
+对象的浅副本。
+
+在代码中，copy.copy()可以清楚地表明这里创建的是浅副本。但对于内置容器，只需要
+使用 list、dict 和 set 这样的工厂函数就能创建浅副本，这种方式更具 Python 特色.
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/89/6e0928f4fa79ec286df727c6dea3bef2849c6956b7dda4085c29204bd87b7d b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/89/6e0928f4fa79ec286df727c6dea3bef2849c6956b7dda4085c29204bd87b7d
new file mode 100644
index 0000000000..c9fbf5e616
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/89/6e0928f4fa79ec286df727c6dea3bef2849c6956b7dda4085c29204bd87b7d
@@ -0,0 +1,705 @@
+I"T02 概率论与信息论
+
+2.1.1 概论与随机变量
+频率学派概率（frequency probability):概率和事件发生的频率相关。频率是指事件发生的次数与事件总次数的比值。频率学派概率的缺点是，它只能用于离散事件，而不能用于连续事件。因为连续事件的发生次数是无穷的，而事件总次数是有限的，所以它们的比值是无穷小的，这样就无法用频率来表示概率了。因此，频率学派概率只能用于离散事件，而不能用于连续事件。
+贝叶斯学派概率（bayesian probability）:概率和事件发生的先验知识相关。也就是说，概率是对某件事情发生的信心程度的度量。每次事件发生，都会更新先验知识，从而得到后验知识。贝叶斯学派概率的缺点是，它需要先验知识，而先验知识往往是不确定的，所以贝叶斯学派概率也是不确定的。
+随机变量（random variable)变量：一个可能随机取不同值的变量，如，抛硬币的结果，掷骰子的结果，抽取的样本的特征等。随机变量的取值是随机的，但是随机变量的取值是有限的，所以随机变量是离散的。
+
+2.1.2 随机变量的分布
+
+概论质量函数(probability Mass Function),对于离散型变量，我们先定义一个随机变量，然后用概率质量函数来描述这个随机变量的取值分布。概率质量函数是一个函数，它的输入是随机变量的取值，输出是随机变量取这个值的概率。概率质量函数的定义是，对于离散型随机变量X，它的概率质量函数是一个函数P(x)，它的定义域是随机变量X的取值集合。
+
+如一个离散型x有k个不同的取值，假设x是均匀分布的，那么概率质量函数为：
+\(P(x=x^i)=\frac{1}{k}\)
+
+概论密度函数(probability Density Function),对于连续型变量，我们先定义一个随机变量，然后用概率密度函数来描述这个随机变量的取值分布。概率密度函数是一个函数，它的输入是随机变量的取值，输出是随机变量取这个值的概率。概率密度函数的定义是，对于连续型随机变量X，它的概率密度函数是一个函数P(x)，它的定义域是随机变量X的取值集合。P（x)是一个非负的函数，它的积分是1，即：
+\(\int_{-\infty}^{\infty}P(x)dx=1\)
+且满足非负性：
+\(\forall x \in \mathbb{X}, P(x)\geq 0\)
+
+累计分布函数(cumulative distribution function)表示对小于x的概率进行积分，即：
+\(CDF(x)=\int_{-\infty}^{x}P(x)dx\)
+
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy.stats import uniform
+%matplotlib inline
+
+
+# generate the sample
+fig,ax = plt.subplots(1,1)
+# 使用参数loc和scale,可以得到[loc, loc + scale]上的均匀分布，size=1000表示样本数，random_state=123表示随机种子
+r = uniform.rvs(loc=0,scale=1,size=1000,random_state=123)
+# density=True表示概率密度，histtype='stepfilled'表示填充，alpha=0.5表示透明度
+ax.hist(r,density=True,histtype='stepfilled',alpha=0.5)
+# 均匀分布pdf
+x = np.linspace(uniform.ppf(0.01),uniform.ppf(0.99),100)
+ax.plot(x,uniform.pdf(x),'r-',lw=5,alpha =0.6,label='uniform pdf')
+
+
+
+[<matplotlib.lines.Line2D at 0x277a8b4d400>]
+
+
+
+
+2.1.3 条件概论与条件独立
+
+边缘概论（Marginal Probability）如果我们知道了一组变量的联合概论分布，想要了解其中一个子集的概率分布。这种定义在子集上的概率分布成为边缘概论分布:
+\(\forall x \in \mathbb{X},P(\mathrm{x}=x) = \sum_y P(\mathrm{x}=x,\mathrm{y}=y)\)
+
+条件概论（conditional probability）在很多情况下，我们不仅关心一个事件的概率，还关心在另一个事件发生的条件下，这个事件的概率。这种在另一个事件发生的条件下，事件的概率称为条件概论。条件概论的定义是：
+\(P(\mathrm{x}=x|\mathrm{y}=y)=\frac{P(\mathrm{x}=x,\mathrm{y}=y)}{P(\mathrm{y}=y)}\)
+这个公式表示在y发生的条件下，x发生的概率。
+
+条件概论的链式法则(chain rule of conditional probability)：任何多维随机变量的联合概论分布，都可以分解成只有只有一个变量的条件概论相乘的形式
+\(P(\mathrm{x}=x,\mathrm{y}=y,\mathrm{z}=z)=P(\mathrm{x}=x|\mathrm{y}=y,\mathrm{z}=z)P(\mathrm{y}=y,\mathrm{z}=z)=P(\mathrm{x}=x|\mathrm{y}=y,\mathrm{z}=z)P(\mathrm{y}=y|\mathrm{z}=z)P(\mathrm{z}=z)\)
+
+\[P(x_1,x_2,\cdots,x_n)=P(x_1|x_2,\cdots,x_n)P(x_2|x_3,\cdots,x_n)\cdots P(x_{n-1}|x_n)P(x_n)\]
+
+独立性（independence）如果两个随机变量X和Y满足：
+\(P(\mathrm{x}=x,\mathrm{y}=y)=P(\mathrm{x}=x)P(\mathrm{y}=y)\)
+也即是联合概论分布可以表示成只有一个变量的条件概论相乘的形式。
+
+条件独立性（conditional independence）如果关于x和y的条件概率分布对于z的每一个值都满足独立性，那么我们就说x和y在z的条件下是条件独立的。
+\(P(\mathrm{x}=x,\mathrm{y}=y|\mathrm{z}=z)=P(\mathrm{x}=x|\mathrm{z}=z)P(\mathrm{y}=y|\mathrm{z}=z)\)
+
+2.1.4 随机变量的度量
+期望（expectation）是随机变量的平均值，期望的定义是：
+\(E(X)=\sum_x xP(X=x)\)
+对于连续型随机变量可以通过积分的形式表示：
+\(E(X)=\int_{-\infty}^{\infty}xP(X=x)dx\)
+
+另外，期望是线性的，即：
+\(E(aX+bY)=aE(X)+bE(Y)\)
+
+方差（variance）是随机变量的离散程度，方差的定义是：
+\(Var(X)=E[(X-E(X))^2]\)
+
+标准差（standard deviation）是方差的平方根，标准差的定义是：
+\(\sigma(X)=\sqrt{Var(X)}\)
+
+协方差（covariance）是两个随机变量的线性相关程度，协方差的定义是：
+\(Cov(X,Y)=E[(X-E(X))(Y-E(Y))]\)
+
+注意协方差的符号表示两个随机变量的线性相关程度，正数表示正相关，负数表示负相关，0表示不相关。
+注意独立与零协方差更强，因为独立还排除了非线性的相关。
+
+x= np.array([1,2,3,4,5,6,7,8,9,10])
+y = np.array([10,9,8,7,6,5,4,3,2,1])
+Mean = np.mean(x)
+Var = np.var(x)
+Var_unbiased = np.var(x,ddof=1)# ddof=1表示无偏估计
+Std = np.std(x)
+Cov = np.cov(x,y)
+Mean,Var,Var_unbiased,Std,Cov
+
+
+(5.5,
+ 8.25,
+ 9.166666666666666,
+ 2.8722813232690143,
+ array([[ 9.16666667, -9.16666667],
+ [-9.16666667, 9.16666667]]))
+
+
+2.1.5 常用概率分布
+伯努利分布（Bernoulli distribution）是一个二项分布的特例，它只有两个可能的取值，0和1，它的概率质量函数是（表示一次实验成功的概率）：
+\(P(X=1)=p\),
+\(P(X=0)=1-p\),
+\(P(X=x)=p^x(1-p)^{1-x}\)
+
+def plot_distribution(X,axes=None):
+ '''给定随机变量X，绘制其PDF,PMF,CDF'''
+ if axes is None:
+ fig,axes = plt.subplots(1,3,figsize=(12,4))
+ x_min,x_max = X.interval(0.99)# 99%的概率密度在区间内
+ x = np.linspace(x_min,x_max,1000)
+ # 连续型变量，画PDF；离散型变量，画PMF
+ if hasattr(X.dist,'pdf'):
+ # axes[0]表示第一行，第一列
+ axes[0].plot(x,X.pdf(x),label='PDF')
+ axes[0].fill_between(x,X.pdf(x),alpha=0.5) # 填充,透明度0.5
+ else:
+ x_int = np.unique(x.astype(int))# 取整,unique去重
+ axes[0].bar(x_int,X.pmf(x_int),label='PMF')
+ # CDF
+ axes[1].plot(x,X.cdf(x),label='CDF')
+ for ax in axes:
+ ax.legend()
+ return axes
+
+
+from scipy.stats import bernoulli
+fig,axes = plt.subplots(1,2,figsize=(12,4))
+r = bernoulli(p=0.6) # 生成伯努利分布
+plot_distribution(r,axes)
+
+
+array([<matplotlib.axes._subplots.AxesSubplot object at 0x00000277A9C8B8E0>,
+ <matplotlib.axes._subplots.AxesSubplot object at 0x00000277A9CB3100>],
+ dtype=object)
+
+
+
+
+# 生成实验成功的次数
+p = 0.6
+def trials(n_samples):
+ # 二项分布，n_samples表示实验次数，p表示成功的概率，samples表示成功的次数
+ samples = np.random.binomial(n_samples,p)
+ proba_zero = (n_samples-samples)/n_samples# 0次成功的概率
+ proba_one = samples/n_samples# 1次成功的概率
+ return [proba_zero,proba_one]
+fig,axes = plt.subplots(1,2,figsize=(12,4))
+# 一次实验，伯努利分布
+n_samples = 1
+axes[0].bar([0,1],trials(n_samples),label ='Bernoulli')
+axes[0].set_title('n_samples = {}'.format(n_samples))
+# n次实验，二项分布
+n_samples = 1000
+axes[1].bar([0,1],trials(n_samples),label ='Binomial')
+axes[1].set_title('n_samples = {}'.format(n_samples))
+for ax in axes:
+ ax.legend()
+
+
+
+
+范畴分布（Categorical distribution，分类分布）是一个多项分布的特例，它的概率质量函数是（表示第k类的概率）：
+\(P(X=k)=p_k\)
+
+例如每次试验的结果就可以表示成一个k维的向量，每个维度表示一种结果，只有此次试验的结果对应的维度为1，其余维度为0，例如：
+\(P(X=(1,0,0,0))=p_1\)
+\(P(X=(0,1,0,0))=p_2\)
+\(P(X=(0,0,1,0))=p_3\)
+\(P(X=(0,0,0,1))=p_4\)
+
+def k_possibilities(k):
+ '''生成k个可能的结果'''
+ res = np.random.rand(k)# random.rand(k)生成k个[0,1)之间的随机数
+ _sum = sum(res) # 求和
+ for i,x in enumerate(res):
+ res[i] = x/_sum # 归一化,enumerate返回索引和值,i表示索引，x表示值
+ return res
+fig,axes = plt.subplots(1,2,figsize=(12,4))
+# 一次实验，范畴分布
+n_samples = 1
+k=10
+samples = np.random.multinomial(n_samples,k_possibilities(k))
+axes[0].bar(range(len(samples)),samples/n_samples,label ='Multinomial')
+
+# n次实验，多项分布
+n_samples = 1000
+samples = np.random.multinomial(n_samples,k_possibilities(k))
+axes[1].bar(range(len(samples)),samples/n_samples,label ='Multinomial')
+for ax in axes:
+ ax.legend()
+
+
+
+
+高斯分布（Gaussian distribution，正态分布）是一个连续型概率分布，若随机变量$X\sim \mathcal{N}(\mu,\sigma^2)$,它的概率密度函数是：
+\(P(X=x)=\frac{1}{\sqrt{2\pi\sigma^2}}e^{-\frac{(x-\mu)^2}{2\sigma^2}}\)
+有时也会用$\beta = \frac{1}{\sigma^2}$来表示分布的精度(精度越大，分布越狭窄，precision)：
+\(P(X=x)=\frac{1}{\sqrt{2\pi\beta^{-1}}}e^{-\frac{(x-\mu)^2}{2\beta}}\)
+
+中心极限定理（central limit theorem）是一个重要的定理，它表示当样本量足够大时，样本均值的分布会趋近于正态分布，如噪声的分布就是一个典型的例子，噪声的分布是均匀分布，但是当噪声的数量足够多时，噪声的均值的分布就会趋近于正态分布。
+
+如果我们对随机变量进行标准化，即将随机变量减去均值并除以标准差，那么标准化后的随机变量的均值为0，标准差为1，这样的随机变量称为标准正态分布（standard normal distribution），
+\(Z=\frac{X-\mu}{\sigma}\)
+
+from scipy.stats import norm
+fig,axes = plt.subplots(1,2,figsize= (12,4))
+mu,sigma = 0,1# 均值，标准差
+r = norm(loc=mu,scale=sigma)# 生成正态分布
+plot_distribution(r,axes) #绘制r的PDF和CDF
+
+
+array([<matplotlib.axes._subplots.AxesSubplot object at 0x000001B387029910>,
+ <matplotlib.axes._subplots.AxesSubplot object at 0x000001B386E8E430>],
+ dtype=object)
+
+
+
+
+多元高斯分布（multivariate Gaussian distribution）是一个多维的高斯分布，它的概率密度函数是：
+\(P(X=x;\sigma,\Sigma)=\frac{1}{(2\pi)^{n/2}|\Sigma|^{1/2}}e^{-\frac{1}{2}(x-\mu)^T\Sigma^{-1}(x-\mu)}\)
+
+具体推导过程如下：
+先假设 $\mathrm{n}$ 个变量 $x=\left[x_1, x_2, \cdots, x_n\right]^{\mathrm{T}}$ 互不相关，且服从正态分布 (维度不相关多元正态分布)，各个维度的均值 $E(x)=\left[\mu_1, \mu_2, \cdots, \mu_n\right]^{\mathrm{T}}$ ，方差 $\sigma(x)=\left[\sigma_1, \sigma_2, \cdots, \sigma_n\right]^{\mathrm{T}}$
+
+根据联合概率密度公式:
+\(\begin{aligned}
+& f(x)=p\left(x_1, x_2 \ldots x_n\right)=p\left(x_1\right) p\left(x_2\right) \ldots p\left(x_n\right)=\frac{1}{(\sqrt{2 \pi})^n \sigma_1 \sigma_2 \cdots \sigma_n} e^{-\frac{\left(x_1-\mu_1\right)^2}{2 \sigma_1^2}-\frac{\left(x_2-\mu_2\right)^2}{2 \sigma_2^2} \cdots-\frac{\left(x_n-\mu_n\right)^2}{2 \sigma_n}} \\
+& \text { 令 } z^2=\frac{\left(x_1-\mu_1\right)^2}{\sigma_1^2}+\frac{\left(x_2-\mu_2\right)^2}{\sigma_2^2} \cdots+\frac{\left(x_n-\mu_n\right)^2}{\sigma_n^2}, \sigma_z=\sigma_1 \sigma_2 \cdots \sigma_n
+\end{aligned}\)
+这样多元正态分布又可以写成一元那种漂亮的形式了(注意一元与多元的差别):
+\(f(z)=\frac{1}{(\sqrt{2 \pi})^n \sigma_z} e^{-\frac{z^2}{2}}\)
+
+因为多元正态分布有着很强的几何思想，单纯从代数的角度看待z很难看出 z的概率分布规律，这里需要转换成矩阵形式:
+\(z^2=z^{\mathrm{T}} z=\left[x_1-\mu_1, x_2-\mu_2, \cdots, x_n-\mu_n\right]\left[\begin{array}{cccc}
+\frac{1}{\sigma_1^2} & 0 & \cdots & 0 \\
+0 & \frac{1}{\sigma_2^2} & \cdots & 0 \\
+\vdots & \cdots & \cdots & \vdots \\
+0 & 0 & \cdots & \frac{1}{\sigma_n^2}
+\end{array}\right]\left[x_1-\mu_1, x_2-\mu_2, \cdots, x_n-\mu_n\right]^{\mathrm{T}}\)
+
+等式比较长，让我们要做一下变量替换:
+\(x-\mu_x=\left[x_1-\mu_1, x_2-\mu_2, \cdots, x_n-\mu_n\right]^{\mathrm{T}}\)
+
+定义一个符号
+\(\sum=\left[\begin{array}{cccc}
+\sigma_1^2 & 0 & \cdots & 0 \\
+0 & \sigma_2^2 & \cdots & 0 \\
+\vdots & \cdots & \cdots & \vdots \\
+0 & 0 & \cdots & \sigma_n^2
+\end{array}\right]\)
+
+$\sum$ 代表变量 $\mathrm{X}$ 的协方差矩阵， i行j列的元素值表示 $x_i$ 与 $x_j$ 的协方差
+因为现在变量之间是相互独立的，所以只有对角线上 $(i=j)$ 存在元素，其他地方都等于 0 ，且 $x_i$ 与它本身的协方差就等于方差。
+
+
+$\sum$ 是一个对角阵，根据对角矩阵的性质，它的逆矩阵:
+\(\left(\sum\right)^{-1}=\left[\begin{array}{cccc}
+\frac{1}{\sigma_1^2} & 0 & \cdots & 0 \\
+0 & \frac{1}{\sigma_2^2} & \cdots & 0 \\
+\vdots & \cdots & \cdots & \vdots \\
+0 & 0 & \cdots & \frac{1}{\sigma_n^2}
+\end{array}\right].\)
+
+对角矩阵的行列式 $=$ 对角元素的乘积
+\(\sigma_z=\left|\sum\right|^{\frac{1}{2}}=\sigma_1 \sigma_2 \ldots \sigma_n\)
+
+替换变量之后，等式可以简化为:
+\(z^{\mathrm{T}} z=\left(x-\mu_x\right)^{\mathrm{T}} \sum^{-1}\left(x-\mu_x\right)\)
+
+代入以z为自变量的标准高斯分布函数中:
+\(f(z)=\frac{1}{(\sqrt{2 \pi})^n \sigma_z} e^{-\frac{z^2}{2}}=\frac{1}{(\sqrt{2 \pi})^n \sum^{\frac{1}{2}}} e^{-\frac{\left(x-\mu_x\right)^T(\Gamma)^{-1}\left(x-\mu_x\right)}{2}}\)
+
+注意前面的系数变化: 从非标准正态分布 $->$ 标准正态分布需要将概率密度函数的高度压缩 $\left|\sum\right|^{\frac{1}{2}}$ 倍，从一维 $\rightarrow$ n维的过 程中，每增加一维，高度将压缩 $\sqrt{2 \pi}$ 倍
+
+reference:
+https://www.cnblogs.com/bingjianing/p/9117330.html
+
+from scipy.stats import multivariate_normal
+x,y = np.mgrid[-1:1:.01,-1:1:.01]# 生成网格点,步长为0.01
+pos = np.dstack((x,y))# 生成网格点坐标,shape=(200,200,2)
+sigma = [[2,0.3],[0.3,0.5]] # 协方差矩阵
+mu = [0.5,0.2]
+X = multivariate_normal(mu,sigma)# 生成多元正态分布
+fig,axes = plt.subplots(1,1,figsize=(12,4))
+axes.contourf(x,y,X.pdf(pos))# 绘制等高线,pos表示在网格点上的概率密度
+
+
+<matplotlib.contour.QuadContourSet at 0x1b386e185b0>
+
+
+
+
+指数分布（Exponential distribution）是描述泊松过程中的事件之间的时间的概率分布，即事件以恒定平均速率连续且独立地发生的过程。 这是伽马分布的一个特殊情况。 它是几何分布的连续模拟，它具有无记忆（Memoryless Property)的关键性质,也即是$P(T>t+s|T>t)=P(T>s)$。
+
+除了用于分析泊松过程外，还可以在其他各种环境中找到，其概率密度函数为：
+
+\(p(x)=\left\{\begin{array}{c}
+\frac{1}{\theta} e^{-\frac{x}{\theta}}, x>0 \\
+0, x \leq 0
+\end{array} \quad(\theta>0)\right.\)
+
+则称随机变量$X$ 服从参数为 $\theta$ 的指数分布, 记为 $X \sim \operatorname{EXP}(\theta)$.
+
+其中 $\lambda = \frac{1}{\theta}$ 称为率参数（rate parameter）。
+
+即每单位时间内发生某事件的次数（比方说：如果你平均每个小时接到2次电话，那么你预期等待每一次电话的时间是半个小时）。指数分布的期望和方差分别为 $\theta$ 和 $\theta^2$.
+
+指数分布的累计分布函数为：
+\(P(X \leq x) = 1 - e^{-\frac{x}{\theta}}\)
+
+from scipy.stats import expon
+fig,axes = plt.subplots(1,2,figsize=(12,4))
+r = expon(scale=2)# 生成指数分布，scale=2表示λ=1/2
+plot_distribution(r,axes)
+
+
+
+array([<matplotlib.axes._subplots.AxesSubplot object at 0x000001B387102DF0>,
+ <matplotlib.axes._subplots.AxesSubplot object at 0x000001B387165340>],
+ dtype=object)
+
+
+
+
+拉普拉斯分布（Laplace distribution）是一种连续概率分布，它是双指数分布的特殊情况。它是一种对称分布，其概率密度函数为：
+\(p(x) = \frac{1}{2 \lambda} e^{ - \frac{|x - \mu|}{\lambda}}\)
+
+其中 $\mu$ 称为分布的位置参数（location parameter），$\lambda$ 称为分布的尺度参数（scale parameter）。拉普拉斯分布的期望和方差分别为 $\mu$ 和 $2 \lambda^2$.
+
+from scipy.stats import laplace
+fig,axes = plt.subplots(1,2,figsize=(12,4))
+mu,gamma = 0,1 # 均值，标准差
+r = laplace(loc=0,scale=1)# 生成拉普拉斯分布
+plot_distribution(r,axes)
+
+
+array([<matplotlib.axes._subplots.AxesSubplot object at 0x000001B3870DF130>,
+ <matplotlib.axes._subplots.AxesSubplot object at 0x000001B385D4DE20>],
+ dtype=object)
+
+
+
+
+Dirac 分布:Dirac delta function，也称为 Dirac 分布。
+
+Dirichlet分布
+基础知识：conjugate priors共轭先验
+共轭先验是指这样一种概率密度：它使得后验概率的密度函数与先验概率的密度函数具有相同的函数形式。它极大地简化了贝叶斯分析。
+如何解释这句话。由于$P(u|D) = p(D|u)p(u)/p(D)$,其中D是给定的一个样本集合，因此对其来说p(D)是一个确定的值，可以理解为一个常数。P(u|D)是后验概率—-即观察到一系列样本数据后模型参数服从的概率，p(D|u)是似然概率—-在给定的模型参数u下样本数据服从这一概率模型的相似程度，p(u)是u的先验概率—-在我们一无所知的情况下u的概率分布。P(u|D)的函数形式完全由p(D|u)和p(u)的乘积决定。如果p(u)的取值使p(u|D)和p(D|u)相同的表达形式（关于u的表达形式），就称p(u)为共轭先验。
+
+reference:
+机器学习的数学基础（1）–Dirichlet分布
+
+Beta分布式二项分布的共轭先验分布.
+
+Dirichlet分布是一个多维的概率分布，它是一组(多元）独立的 $\operatorname{Beta}$ 分布的共轭先验分布。在贝叶斯推断（Bayesian inference）中，狄利克雷分布作为多项分布的共轭先验得到应用，在机器学习（machine learning）中被用于构建狄利克雷混合模型（Dirichlet mixture model）是一类在实数域以正单纯形（standard simplex）为 支撑集（support）的高维连续概率分布，是Beta分布在高维情形的推广。
+
+reference:
+理解Gamma分布、Beta分布与Dirichlet分布
+
+
+最通俗易懂的白话狄利克雷过程(Dirichlet Process）
+
+2.1.6 常见函数的有用性质
+
+logisitc sigmoid函数通常用来产生伯努利分布的概率，因为它的范围是 (0, 1)，因此它的导数是伯努利分布的概率密度函数。sigmoid 函数在变量取绝对值⾮常⼤的正值或负值时会出现饱和 (Saturate)现象，意味着函数会变得很平，并且对输⼊的微⼩改变会变得不敏感。
+\(sigmoid(x) = \frac{1}{1+e^{-x}}\)
+
+softplus函数
+\(softplus(x) = \log(1+e^x)\)
+
+因为它的范围是 (0, ∞)，softplus函数可以用来产生正太分布的$\beta$和$\sigma$参数，因此它的导数是正太分布的概率密度函数。
+softplus函数名称来源于它是一个平滑的ReLU函数，ReLU函数是一个非线性函数，它的定义是
+\(ReLU(x) = max(0, x)\)
+
+x = np.linspace(-10,10,1000)
+sigmoid = 1/(1+np.exp(-x))
+softplus = np.log(1+np.exp(x))
+fig,axes = plt.subplots(1,2,figsize=(12,4))
+axes[0].plot(x,sigmoid)
+axes[0].set_title('Sigmoid')
+axes[1].plot(x,softplus)
+axes[1].set_title('Softplus')
+
+
+
+Text(0.5, 1.0, 'Softplus')
+
+
+
+
+2.2 信息论
+信息论背后的思想：一件不太可能的事件比一件比较可能的事件更有信息量。（信息量的度量就等于不确定性的多少。）
+信息 (Information) 需要满⾜的三个条件：
+
+ - ⽐较可能发⽣的事件的信息量要少
+ - ⽐较不可能发⽣的事件的信息量要⼤
+ - 独⽴发⽣的事件之间的信息量应该是可以叠加的。例如，投掷的硬币两次正⾯朝上传递的信息量，应该是投掷⼀次硬币正⾯朝上的信息量的两倍
+
+
+自信息 (Self-information) 是信息论中的基本概念，它是指单个事件发⽣的信息量。自信息的定义是
+\(I(x) = -\log P(x)\)
+
+香农熵 (Shannon Entropy)是对于整个概论分布P，随机变量的不确定性的衡量：
+\(H(P) = -（ p_1 * \log p_1 + p_2 * \log p_2 + \cdots + p_n * \log p_n) =-\sum_{x}P(x)\log P(x)\)
+
+联合熵 (Joint Entropy) 是对于两个随机变量X和Y，它们的联合分布P(X, Y)，随机变量的不确定性的衡量：
+\(H(X, Y) = -\sum_{x,y}P(x, y)\log P(x, y)\)
+
+条件熵 (Conditional Entropy) 是对于两个随机变量X和Y，它们的联合分布P(X, Y)，随机变量的不确定性的衡量：
+\(H(Y|X) = -\sum_{x,y}P(x, y)\log P(y|x)\)
+
+互信息 (Mutual Information) 表示两个信息相交的部分：
+\(I(X;Y) = H(X)+H(Y) - H(X,Y)\)
+
+信息变差(Variation of Information) 表示两个事件的信息不想交的部分：
+\(VI(X;Y) = H(X)+H(Y) - 2I(X;Y)\)
+
+p = np.linspace(1e-6,1-1e-6,1000) # 生成概率
+entropy = -p*np.log(p)-(1-p)*np.log(1-p) # 香农熵 (Shannon Entropy)
+plt.figure(figsize=(4,4))
+plt.plot(p,entropy)
+plt.title('Shannon Entropy')
+
+
+
+Text(0.5, 1.0, 'Shannon Entropy')
+
+
+
+
+信息增益（Kullback–Leibler divergence）又称information divergence，information gain，relative entropy 或者KLIC。
+在概率论和信息论中，信息增益是非对称的，用以度量两种概率分布P和Q的差异。
+\(D_{KL}(P||Q) = \sum_{x}P(x)\log \frac{P(x)}{Q(x)}\)
+
+交叉熵 (Cross Entropy) 假设P是真实的分布，Q是预测的分布，那么交叉熵就是真实分布和预测分布之间的距离：
+\(H(P, Q) = H(P) + D_{KL}(P||Q) = -\sum_{x}P(x)\log Q(x)\)
+
+# D_{KL}(P||Q) 与D_{KL}(Q||P)比较
+x = np.linspace(1,8,500)
+y1 = norm.pdf(x,loc =3,scale = 0.5) # loc=3,scale=0.5表示均值为3，标准差为0.5
+y2 = norm.pdf(x,loc =6,scale = 0.5)
+p = y1+y2 #构造p(x)
+KL_pq ,KL_qp = [],[]
+q_list = []
+for mu in np.linspace(0,10,50):
+ for sigma in np.linspace(0.1,1,50): # 生成50*50个q(x),寻找最优q(x)
+ q = norm.pdf(x,loc =mu,scale = sigma) # 构造q(x)
+ q_list.append(q)
+ KL_pq.append(np.sum(p*np.log(p/q))) # D_{KL}(P||Q)
+ KL_qp.append(np.sum(q*np.log(q/p))) # D_{KL}(Q||P)
+# min
+min_KL_pq = np.argmin(KL_pq) # 最小值的索引
+min_KL_qp = np.argmin(KL_qp)
+
+fig,axes = plt.subplots(1,2,figsize=(12,4))
+axes[0].set_ylim(0,0.8)
+axes[0].plot(x,p/2,'b',label='p(x)')
+axes[0].plot(x,q_list[min_KL_pq],'r',label='$q^*(x)$')
+axes[0].set_title('min D_{KL}(P||Q) ')
+axes[0].set_xlabel('x')
+axes[0].set_ylabel('p(x)')
+
+axes[1].set_ylim(0,0.8)
+axes[1].plot(x,p/2,'b',label='p(x)')
+axes[1].plot(x,q_list[min_KL_qp],'r',label='$q^*(x)$')
+axes[1].set_title('min D_{KL}(Q||P)')
+axes[1].set_xlabel('x')
+axes[1].set_ylabel('p(x)')
+
+
+<ipython-input-60-0ceffff0da69>:12: RuntimeWarning: divide by zero encountered in true_divide
+ KL_pq.append(np.sum(p*np.log(p/q))) # D_{KL}(P||Q)
+<ipython-input-60-0ceffff0da69>:12: RuntimeWarning: overflow encountered in true_divide
+ KL_pq.append(np.sum(p*np.log(p/q))) # D_{KL}(P||Q)
+<ipython-input-60-0ceffff0da69>:13: RuntimeWarning: divide by zero encountered in log
+ KL_qp.append(np.sum(q*np.log(q/p))) # D_{KL}(Q||P)
+<ipython-input-60-0ceffff0da69>:13: RuntimeWarning: invalid value encountered in multiply
+ KL_qp.append(np.sum(q*np.log(q/p))) # D_{KL}(Q||P)
+
+
+
+
+
+Text(0, 0.5, 'p(x)')
+
+
+
+
+信息增益 (Information Gain) 是指在知道特征X的条件下，特征Y的不确定性减少的程度：
+\(IG(X;Y) = H(Y) - H(Y|X)\)
+
+import numpy as np
+import pandas as pd
+from math import log
+
+def create_data():
+ datasets = [['青年', '否', '否', '一般', '否'],
+ ['青年', '否', '否', '好', '否'],
+ ['青年', '是', '否', '好', '是'],
+ ['青年', '是', '是', '一般', '是'],
+ ['青年', '否', '否', '一般', '否'],
+ ['中年', '否', '否', '一般', '否'],
+ ['中年', '否', '否', '好', '否'],
+ ['中年', '是', '是', '好', '是'],
+ ['中年', '否', '是', '非常好', '是'],
+ ['中年', '否', '是', '非常好', '是'],
+ ['老年', '否', '是', '非常好', '是'],
+ ['老年', '否', '是', '好', '是'],
+ ['老年', '是', '否', '好', '是'],
+ ['老年', '是', '否', '非常好', '是'],
+ ['老年', '否', '否', '一般', '否'],
+ ]
+ labels = [u'年龄', u'有工作', u'有自己的房子', u'信贷情况', u'类别']
+ # 返回数据集和每个维度的名称
+ return datasets, labels
+
+
+# 熵
+def calc_ent(datasets):
+ data_length = len(datasets)
+ label_count = {}
+ for i in range(data_length):
+ label = datasets[i][-1]
+ if label not in label_count:
+ label_count[label] = 0
+ label_count[label] += 1
+ ent = -sum([(p / data_length) * log(p / data_length, 2) for p in label_count.values()])
+ return ent
+
+
+# 经验条件熵
+def cond_ent(datasets, axis=0):
+ data_length = len(datasets)
+ feature_sets = {}
+ for i in range(data_length):
+ feature = datasets[i][axis]
+ if feature not in feature_sets:
+ feature_sets[feature] = []
+ feature_sets[feature].append(datasets[i])
+ cond_ent = sum([(len(p) / data_length) * calc_ent(p) for p in feature_sets.values()])
+ return cond_ent
+
+
+# 信息增益
+def info_gain(ent, cond_ent):
+ return ent - cond_ent
+
+
+def info_gain_train(datasets):
+ count = len(datasets[0]) - 1
+ ent = calc_ent(datasets)
+ best_feature = []
+ for c in range(count):
+ c_info_gain = info_gain(ent, cond_ent(datasets, axis=c))
+ best_feature.append((c, c_info_gain))
+ print('特征({}) - info_gain - {:.3f}'.format(labels[c], c_info_gain))
+ # 比较大小
+ best_ = max(best_feature, key=lambda x: x[-1])
+ return '特征({})的信息增益最大，选择为根节点特征'.format(labels[best_[0]])
+
+datasets, labels = create_data()
+train_data = pd.DataFrame(datasets, columns=labels)
+print(train_data)
+print('特征信息增益为：', info_gain_train(np.array(datasets)))
+
+
+ 年龄 有工作 有自己的房子 信贷情况 类别
+0 青年 否 否 一般 否
+1 青年 否 否 好 否
+2 青年 是 否 好 是
+3 青年 是 是 一般 是
+4 青年 否 否 一般 否
+5 中年 否 否 一般 否
+6 中年 否 否 好 否
+7 中年 是 是 好 是
+8 中年 否 是 非常好 是
+9 中年 否 是 非常好 是
+10 老年 否 是 非常好 是
+11 老年 否 是 好 是
+12 老年 是 否 好 是
+13 老年 是 否 非常好 是
+14 老年 否 否 一般 否
+特征(年龄) - info_gain - 0.083
+特征(有工作) - info_gain - 0.324
+特征(有自己的房子) - info_gain - 0.420
+特征(信贷情况) - info_gain - 0.363
+特征信息增益为： 特征(有自己的房子)的信息增益最大，选择为根节点特征
+
+
+2.3 图模型
+图模型（Graphical Model)是一种表示概率分布的方法，它将概率分布表示为一个图，图中的节点表示随机变量，节点之间的边表示随机变量之间的依赖关系。
+
+2.3.1 有向图模型 directed graphical model
+
+有向图模型是指图中的边是有向的，即边的方向表示了随机变量之间的依赖关系。有向图模型可以表示条件概率分布(CPD)，也可以表示马尔科夫随机场。
+
+有向图的代表是贝叶斯网。
+贝叶斯⽹与朴素贝叶斯模型建⽴在相同的直观假设上：通过利用分布的条件独立性来获得紧凑而自然的表示。贝叶斯⽹核⼼是⼀个有向⽆环图(DAG)，其节点为论域中的随机变量，节点间的有向箭头表⽰这两个节点的依赖关系。
+
+
+
+有向⽆环图可以由如下 3 种元结构构成：
+
+
+贝叶斯网的独立性
+
+
+import networkx as nx
+from pgmpy.models import BayesianModel
+from pgmpy.factors.discrete import TabularCPD
+import matplotlib.pyplot as plt
+%matplotlib inline
+
+# 建立一个简单贝叶斯模型框架
+model = BayesianModel([('a', 'b'), ('a', 'c'), ('b', 'c'), ('b', 'd'), ('c', 'e')])
+# 最顶层的父节点的概率分布表
+cpd_a = TabularCPD(variable='a', variable_card=2, values=[[0.6, 0.4]]) # a: (0,1)
+
+# 其它各节点的条件概率分布表（行对应当前节点索引，列对应父节点索引）
+cpd_b = TabularCPD(variable='b', variable_card=2, # b: (0,1)
+values=[[0.75, 0.1],
+[0.25, 0.9]],
+evidence=['a'],
+evidence_card=[2])
+cpd_c = TabularCPD(variable='c', variable_card=3, # c: (0,1,2)
+values=[[0.3, 0.05, 0.9, 0.5],
+[0.4, 0.25, 0.08, 0.3],
+[0.3, 0.7, 0.02, 0.2]],
+evidence=['a', 'b'],
+evidence_card=[2, 2])
+cpd_d = TabularCPD(variable='d', variable_card=2, # d: (0,1)
+values=[[0.95, 0.2],
+[0.05, 0.8]],
+evidence=['b'],
+evidence_card=[2])
+cpd_e = TabularCPD(variable='e', variable_card=2, # e: (0,1)
+values=[[0.1, 0.4, 0.99],
+[0.9, 0.6, 0.01]],
+evidence=['c'],
+evidence_card=[3])
+
+# 将各节点的概率分布表加入网络
+model.add_cpds(cpd_a, cpd_b, cpd_c, cpd_d, cpd_e)
+# 验证模型数据的正确性
+print(u"验证模型数据的正确性:",model.check_model())
+# 绘制贝叶斯图 (节点 + 依赖关系)
+nx.draw(model, with_labels=True, node_size=1000, font_weight='bold', node_color='y', \
+pos={"e":[4,3],"c":[4,5],"d":[8,5],"a":[2,7],"b":[6,7]})
+plt.text(2,7,model.get_cpds("a"), fontsize=10, color='b')
+plt.text(5,6,model.get_cpds("b"), fontsize=10, color='b')
+plt.text(1,4,model.get_cpds("c"), fontsize=10, color='b')
+plt.text(4.2,2,model.get_cpds("e"), fontsize=10, color='b')
+plt.text(7,3.4,model.get_cpds("d"), fontsize=10, color='b')
+
+plt.show()
+
+
+---------------------------------------------------------------------------
+
+ModuleNotFoundError Traceback (most recent call last)
+
+<ipython-input-1-96c0e1595c11> in <module>
+ 1 import networkx as nx
+----> 2 from pgmpy.models import BayesianModel
+ 3 from pgmpy.factors.discrete import TabularCPD
+ 4 import matplotlib.pyplot as plt
+ 5 get_ipython().run_line_magic('matplotlib', 'inline')
+
+
+ModuleNotFoundError: No module named 'pgmpy'
+
+
+2.3.2 无向图模型 (Undirected Model)
+马尔可夫网节点间的依赖关系是无向的（相互平等的关系），⽆法⽤条件概率分布来表⽰，为此为引⼊极大团概念，进⽽为每个极⼤团引⼊⼀个势函数作为因⼦，然后将联合概率分布表⽰成这些因⼦的乘积再归⼀化，归⼀化常数被称作配分函数。
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/8a/3c35c98b80d23a92f5607416c89d74b4e2f6df6a65a01ae9fbc5f0a97f9370 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/8a/3c35c98b80d23a92f5607416c89d74b4e2f6df6a65a01ae9fbc5f0a97f9370
new file mode 100644
index 0000000000..ac6da5c2fb
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/8a/3c35c98b80d23a92f5607416c89d74b4e2f6df6a65a01ae9fbc5f0a97f9370
@@ -0,0 +1,10 @@
+I"
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/8a/cb3939c95b34248ff340d740e1710ffe248f6bb0bf665d1a7ddff0c8ba173b b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/8a/cb3939c95b34248ff340d740e1710ffe248f6bb0bf665d1a7ddff0c8ba173b
new file mode 100644
index 0000000000..cf38d3e862
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/8a/cb3939c95b34248ff340d740e1710ffe248f6bb0bf665d1a7ddff0c8ba173b
@@ -0,0 +1,16 @@
+I"
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/8d/5d61d223788af1226aa03f3307b97ae69ed96673ec2e9086d6602fd5a814e0 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/8d/5d61d223788af1226aa03f3307b97ae69ed96673ec2e9086d6602fd5a814e0
new file mode 100644
index 0000000000..ac12ff5c75
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/8d/5d61d223788af1226aa03f3307b97ae69ed96673ec2e9086d6602fd5a814e0
@@ -0,0 +1,2 @@
+I"\1. 随机生成一个随机的string
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/8d/b8a20d229e46ab19f3807a83d3723d880b68a4bb88084a2155363a52035a7e b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/8d/b8a20d229e46ab19f3807a83d3723d880b68a4bb88084a2155363a52035a7e
new file mode 100644
index 0000000000..f166054b5f
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/8d/b8a20d229e46ab19f3807a83d3723d880b68a4bb88084a2155363a52035a7e
@@ -0,0 +1,13 @@
+I"
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/90/013f2eb8f0b885d1fed67948900fb41787f6704b94dd0bb3aaa04b4cc4fca2 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/90/013f2eb8f0b885d1fed67948900fb41787f6704b94dd0bb3aaa04b4cc4fca2
new file mode 100644
index 0000000000..c934c5cf2a
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/90/013f2eb8f0b885d1fed67948900fb41787f6704b94dd0bb3aaa04b4cc4fca2
@@ -0,0 +1,6 @@
+I"
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/90/56943a71b88e2eefd911fec807a6d15382d681283cab5f62b8de33fd3f6970 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/90/56943a71b88e2eefd911fec807a6d15382d681283cab5f62b8de33fd3f6970
new file mode 100644
index 0000000000..52c8fbd5a8
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/90/56943a71b88e2eefd911fec807a6d15382d681283cab5f62b8de33fd3f6970
@@ -0,0 +1,5 @@
+I"00 写在前面
+如何将ipynb文件转为markdown文件？
+jupyter nbconvert --to markdown note.ipynb
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/91/51c77c1f9ab47b4721f0eb597c21abc53166e7d5996cda3bba0c5c217dcda0 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/91/51c77c1f9ab47b4721f0eb597c21abc53166e7d5996cda3bba0c5c217dcda0
new file mode 100644
index 0000000000..f344862976
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/91/51c77c1f9ab47b4721f0eb597c21abc53166e7d5996cda3bba0c5c217dcda0
@@ -0,0 +1,356 @@
+I"mB1. 基本命令
+
+top
+
+du
+
+查看/proc目录下的系统各种信息
+
+/proc 是一个虚拟文件系统，它提供了一种机制，通过读取和写入特定的文件或目录，可以访问内核和系统信息。
+
+# 命令行数太多可以使用more命令或者grep命令进行筛选
+# 查看CPU信息
+cat /proc/cpuinfo
+# 会输出包含 "model name" 字符串的行，即 CPU 型号的信息
+cat /proc/cpuinfo | grep "model name"
+# 只查看 CPU 核心数，可以使用以下命令：
+cat /proc/cpuinfo | grep "cpu cores"
+
+# 查看内存参数
+cat /proc/meminfo
+# 查看总内存
+cat /proc/meminfo | grep "MemTotal"
+# 查看系统空闲内存大小
+cat /proc/meminfo | grep "MemFree"
+
+# 系统的各种参数和设置，如内核参数、网络设置、文件系统设置等
+# abi debug dev fs kernel net user vm
+cat /proc/sys/*
+# 网络信息，如 TCP/IP 连接、网络接口、路由表等
+# 包括tcp、tcp6、udp、udp6等
+cat /proc/net/*
+# 查看tcp连接的各种信息
+cat /proc/net/tcp
+
+# 指定进程的信息，如进程状态、内存占用、打开的文件等(进程资源使用情况)
+cd /proc/pidnumber
+
+
+top：查看系统的进程信息，包括 CPU 占用率、内存占用率等。
+
+重要参数：
+
+-d: seconds：指定 top 命令的刷新时间间隔，单位为秒;如，”top -d 5” 表示每 5 秒刷新一次 top 命令的输出；
+
+-b：以批处理模式运行 top 命令，将结果输出到文件中，而不是交互式界面；
+
+-p pid1,pid2,…：只显示指定进程 ID 的进程信息，多个进程 ID 之间用逗号分隔。
+
+-n iterations：指定 top 命令的迭代次数，即 top 命令将输出多少次后自动退出。例如，”top -n 10” 表示 top 命令将输出 10 次后自动退出；
+
+htop命令
+
+显示系统中运行进程的状态和资源使用情况，界面更加美观。
+
+atop：都是用于查看系统进程信息的命令，可以按照不同的方式显示进程信息。
+
+vmstat：可以监控操作系统的进程状态、内存、虚拟内存、磁盘IO、CPU的信息。
+
+-a：显示活动和非活动的内存使用情况；
+
+-d：显示磁盘 I/O 统计信息
+
+
+ - iostat：查看系统的磁盘 I/O 使用情况。
+ - netstat：查看系统的网络连接情况。
+
+
+输出接果：
+
+Proto：显示网络连接的协议类型，如 TCP、UDP 等。
+
+Local Address 显示本地IP地址和端口号
+
+Recv-Q：显示接收队列的大小
+
+nmon：可以监测 CPU 使用率、内存使用情况、磁盘 I/O、网络流量、进程和线程等多个系统资源，还可以监测系统温度和风扇转速等硬件指标。
+
+dmesg：来显示内核环缓冲区（kernel-ring buffer）内容。
+
+
+ -
+
free：查看系统的内存使用情况，包括物理内存、交换内存(swap)和内核缓冲区内存。
+
+ 输出：
+
+ buff/cache 列显示被 buffer 和 cache 使用的物理内存大小。
+
+
+
+df disk free
+
+显示磁盘分区上可以使用的磁盘空间；（通过文件系统来快速获取空间大小的信息，当我们删除一个文件的时候，这个文件不是马上就在文件系统当中消失了，而是暂时消失了，当所有程序都不用时，才会根据OS的规则释放掉已经删除的文件， df记录的是通过文件系统获取到的文件的大小，他比du强的地方就是能够看到已经删除的文件，而且计算大小的时候，把这一部分的空间也加上了，更精确了。当文件系统也确定删除了该文件后，这时候du与df就一致了。）
+-a #查看全部文件系统，单位默认KB
+-h #使用-h选项以KB、MB、GB的单位来显示，可读性高
+
+du disk usage
+
+显示每个文件和目录的磁盘使用空间，也就是文件的大小。（通过搜索文件来计算每个文件的大小然后累加，du能看到的文件只是一些当前存在的，没有被删除的。他计算的大小就是当前他认为存在的所有文件大小的累加和。）
+
+-h : 以K M G为单位显示，提高可读性
+
+–max-depth=1 : 显示层级
+
+uptime：查看系统的运行时间和平均负载。
+
+load average: 3.17, 3.45, 3.65,分别描述了1分钟5分钟15分钟内系统平均负载.
+
+ps：查看系统的进程信息，包括进程 ID、CPU 占用率等。
+
+-aux ：显示所有进程，包括其他用户的进程。
+
+aux格式：USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
+
+USER: 行程拥有者
+PID: pid
+%CPU: 占用的 CPU 使用率
+%MEM: 占用的记忆体使用率
+VSZ: 占用的虚拟记忆体大小
+RSS: 占用的记忆体大小
+TTY: 终端的次要装置号码 (minor device number of tty)
+STAT: 行程状态
+
+查找指定进程（如Java）的进程号：
+ps -ef | grep java
+
+lsof：查看系统打开的文件和网络连接情况;lscpu:查看CPU信息.
+
+tcpdump：抓取和分析网络数据包。
+
+ping、traceroute、mtr：用于测试网络连接和延迟。
+
+ping -c 5 www.baidu.com # -c 5表示发送5个数据包
+
+traceroute命令用于追踪数据包在网络上的传输时的全部路径，它默认发送的数据包大小是40字节。通过traceroute我们可以知道信息从你的计算机到互联网另一端的主机是走的什么路径.
+traceroute www.baidu.com
+
+rsync：用于远程备份和同步文件和目录。
+
+同步同一台机上的两个目录：
+
+$ rsync -zvr /var/opt/installation/inventory/ /root/temp
+building file list ... done
+sva.xml
+svB.xml
+.
+sent 26385 bytes received 1098 bytes 54966.00 bytes/sec
+total size is 44867 speedup is 1.63
+
+
+-z –compress：压缩数据
+-v –verbose：显示详细信息
+-r –recursive：递归处理，将指定目录下的所有文件和子目录一并处理
+
+还可以拷贝单个文件：
+
+$ rsync -v /var/lib/rpm/Pubkeys /root/temp/
+Pubkeys
+
+sent 42 bytes received 12380 bytes 3549.14 bytes/sec
+total size is 12288 speedup is 0.99
+
+
+从本地拷贝多个文件到远端：
+
+$ rsync -avz /root/temp/ thegeekstuff@192.168.200.10:/home/thegeekstuff/temp/
+Password:
+building file list ... done
+./
+rpm/
+rpm/Basenames
+rpm/Conflictname
+
+sent 15810261 bytes received 412 bytes 2432411.23 bytes/sec
+total size is 45305958 speedup is 2.87
+
+
+从本地拷贝多个文件到远端:
+使用rsync, 也可以从本地拷贝多个文件或目录到远端.
+
+$ rsync -avz /root/temp/ thegeekstuff@192.168.200.10:/home/thegeekstuff/temp/
+Password:
+building file list ... done
+./
+rpm/
+rpm/Basenames
+rpm/Conflictname
+
+sent 15810261 bytes received 412 bytes 2432411.23 bytes/sec
+total size is 45305958 speedup is 2.87
+
+
+从远程服务器拷贝文件到本地:
+
+$ rsync -avz thegeekstuff@192.168.200.10:/var/lib/rpm /root/temp
+Password:
+receiving file list ... done
+rpm/
+rpm/Basenames
+.
+sent 406 bytes received 15810230 bytes 2432405.54 bytes/sec
+total size is 45305958 speedup is 2.87
+
+
+scp、sftp：用于远程复制和传输文件。
+
+scp是一种基于SSH的协议，可在网络上的主机之间提供文件传输。
+
+ssh、telnet：用于远程登录和管理系统。
+
+telnet是明文传送, ssh是加密的且支持压缩。
+
+crontab：用于定时执行任务。
+
+systemctl、service：用于管理系统服务和启动、停止、重启服务。
+
+firewall-cmd、iptables：用于管理系统防火墙和配置网络规则。
+
+systemctl start firewalld # 启动防火墙
+systemctl stop firewalld # 关闭防火墙
+systemctl restart firewalld # 重启防火墙
+systemctl status firewalld # 查看防火墙状态
+systemctl enable firewalld # 设置开机启动
+
+selinux：用于管理系统安全策略和访问控制。
+
+sysctl：用于调整内核参数和系统性能优化。
+
+sysctl命令被用于在内核运行时动态地修改内核的运行参数，可用的内核参数在目录/proc/sys中。它包含一些TCP/IP堆栈和虚拟内存系统的高级选项， 这可以让有经验的管理员提高引人注目的系统性能。用sysctl可以读取设置超过五百个系统变量。
+
+vim /etc/sysctl.conf
+net.ipv4.ip_forward = 1 # 开启IP转发
+net.ipv4.conf.all.accept_redirects = 0 # 禁止所有接口接收重定向报文
+
+
+ulimit：用于限制系统资源使用和保护系统安全。
+
+perf、、systemtap：用于系统性能分析和瓶颈诊断。
+
+perf、、systemtap：用于系统性能分析和瓶颈诊断。
+
+init、systemd、upstart：用于系统进程管理和服务管理。
+
+lspci、lsusb、lshw：用于硬件信息和诊断。
+
+lp、lpr、cups：用于打印管理和打印队列控制。
+
+tree、fd、rg：用于文件和目录搜索和查找。
+
+2. 综合检测集成方案和工具
+
+Unixbench
+
+Unixbench是一个类unix系（如Unix， Linux）统下的性能测试工具，被广泛用在linux系统主机的性能的测试，主要提供的测试项目有：系统调用、读写、进程、图形化测试、2D、3D、管道、运算、C库等系统基准性能提供测试数据。
+
+要运行UnixBench测试，请按照以下步骤进行：
+
+打开终端并进入UnixBench的根目录。在大多数情况下，UnixBench的根目录位于/usr/share/UnixBench。您可以使用以下命令进入该目录：
+
+
+ - cd /usr/share/UnixBench
+如果UnixBench安装在其他位置，请相应地更改路径。
+ - 运行./Run命令。这将会运行所有可用的测试，包括CPU、内存、磁盘、文件系统和网络等方面的测试。测试过程可能需要一些时间，具体时间取决于您的系统性能。
+ - 等待测试完成后，将生成一个HTML格式的报告。该报告位于UnixBench根目录下的results文件夹中，文件名为UnixBench.html。您可以使用Web浏览器打开该文件，并查看测试的结果和性能数据。
+
+
+除了运行所有测试之外，您还可以运行单个测试或一组测试。以下是一些示例命令：
+
+运行CPU测试：./Run cpu
+运行内存测试：./Run memory
+运行磁盘测试：./Run disk
+运行文件系统测试：./Run fs
+运行网络测试：./Run network
+
+Sysbench工具
+
+内建测试项
+
+fileio：文件I/O测试。
+cpu：CPU性能测试。
+memory：内存速度测试。
+threads：线程子系统性能测试。
+mutex：互斥性能测试。
+oltp：OLTP（在线事务处理）测试。
+
+其他工具
+
+Nagios：一款开源的企业级 IT 基础设施监控软件，可监测服务器、网络设备、应用程序等多种设备和服务状态。
+
+Zabbix：一款功能强大的开源网络监控软件，支持多种监测方式，如 SNMP、JMX、IPMI、HTTP 等，并具有自定义告警、数据可视化等功能。
+
+Munin：一款基于 Web 的监测软件，可以监测 CPU、内存、磁盘、网络等多种系统指标，还支持插件扩展和数据可视化。
+
+Cacti：一款基于 RRDtool 的网络图形化监测工具，可以监测网络带宽、路由器、交换机等设备的状态，并生成图表和报告。
+
+Prometheus：一款开源的服务监测系统，可监测多种应用程序、数据库、中间件等服务状态，并提供数据可视化和告警功能。
+
+Sysdig：一款基于系统调用跟踪的容器监测工具，可以监测容器的运行状态、资源使用情况、网络流量等，并提供数据可视化和安全分析功能。
+
+Netdata：一款轻量级的实时系统监测工具，支持多种系统指标和网络流量监测，并具有数据可视化和告警功能。
+
+网络监视器，如 tcpdump、Wireshark
+
+3. 检测步骤
+
+检查系统资源使用情况：可以使用 top 命令查看系统中正在运行的进程，以及它们占用的 CPU 和内存资源。可以使用 free 命令查看系统中可用的内存和交换空间的使用情况。
+
+检查磁盘使用情况：可以使用 df 命令查看系统中磁盘分区的使用情况，以及剩余的可用空间。可以使用 du 命令查看特定目录或文件的磁盘使用情况。
+
+检查网络带宽和连接情况：可以使用 iftop 命令查看系统中正在使用的网络连接和带宽使用情况。可以使用 netstat 命令查看特定端口或协议的网络连接情况。
+
+检查系统负载和性能指标：可以使用 uptime 命令查看系统的负载情况。可以使用 vmstat 命令查看系统的虚拟内存使用情况和 CPU 使用情况。可以使用 iostat 命令查看系统的磁盘 I/O 使用情况。
+
+进行基准测试：可以使用一些基准测试工具，如 UnixBench、Geekbench、Sysbench 等，对系统进行性能测试，以便比较不同系统或不同配置的性能差异。
+
+4. 使用crontab定时调度任务进行自动化运维（对系统日志进行备份等）
+
+有时候，为了系统稳定性,除了在/var/log通过回滚机制生成各种日志文件以排查系统故障之外，我们也想把这些关键的日志文件保存到指定文件夹，防止突然断电或者磁盘分区被破坏之后丢失关键的日志信息。
+
+代码如下：（文件名为backup_sysconfig.sh）
+
+#! /bin/bash
+# this script is used to backup the syslog file in /var/log dir everyday
+echo `date`
+cp /var/log/syslog /home/hugo/test_BASH/log/
+# adding the user with x permission
+chmod u+x /home/hugo/test_BASH/log/syslog
+# chnage the firname
+today=$(date +%y%m%d)
+echo $today
+mv /home/hugo/test_BASH/log/syslog /home/hugo/test_BASH/log/syslog_$today
+
+
+定时调度任务
+
+crontab 的语句是“分 时 日 月 周 命令”.
+
+开启定时调度任务，每天凌晨1点执行一次
+
+crontab -e
+# 0 1 * * * /home/hugo/test_BASH/backup_sysconfig.sh
+
+
+显示 crontab: installing new crontab，表示定时任务已经开启。
+
+查看定时任务
+
+crontab -l
+
+
+开启或者关闭定时任务
+
+service crondstart
+service crondstop
+
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/91/7a6f1ff22b1d0b8f41726999fa00eaee7bee43f9a1fce1de3505bebc16d412 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/91/7a6f1ff22b1d0b8f41726999fa00eaee7bee43f9a1fce1de3505bebc16d412
new file mode 100644
index 0000000000..ea0c13100b
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/91/7a6f1ff22b1d0b8f41726999fa00eaee7bee43f9a1fce1de3505bebc16d412
@@ -0,0 +1,8 @@
+I"
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/91/e5d9c0ec9e91bd96613e7375121fd534504cae381cf711a7121b785259259e b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/91/e5d9c0ec9e91bd96613e7375121fd534504cae381cf711a7121b785259259e
new file mode 100644
index 0000000000..2a3f6829ff
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/91/e5d9c0ec9e91bd96613e7375121fd534504cae381cf711a7121b785259259e
@@ -0,0 +1,33 @@
+I"E
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/93/96ce43a514d99f10f89bf434507300f2bbec2342162cb5e65eb83ea0400579 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/93/96ce43a514d99f10f89bf434507300f2bbec2342162cb5e65eb83ea0400579
new file mode 100644
index 0000000000..1154de5d1e
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/93/96ce43a514d99f10f89bf434507300f2bbec2342162cb5e65eb83ea0400579
@@ -0,0 +1,2 @@
+I"21. 基本命令
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/97/f070ec086293858776e467ff152e9a83d8978da36f4bcf67b260d23788ab72 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/97/f070ec086293858776e467ff152e9a83d8978da36f4bcf67b260d23788ab72
new file mode 100644
index 0000000000..157eb32b31
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/97/f070ec086293858776e467ff152e9a83d8978da36f4bcf67b260d23788ab72
@@ -0,0 +1,3 @@
+I"1. pytest简介
+Pytest 是一个比较成熟且功能完备的 Python 测试框架。其提供完善的在线文档，并有着大量的第三方插件和内置帮助，适用于许多小型或大型项目。Pytest 灵活易学，打印调试和测试执行期间可以捕获标准输出，适合简单的单元测试到复杂的功能测试。还可以执行 nose, unittest 和 doctest 风格的测试用例，甚至 Django 和 trial。支持良好的集成实践， 支持扩展的 xUnit 风格 setup，支持非 python 测试。支持生成测试覆盖率报告，支持 PEP8 兼容的编码风格。
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/9a/4861c553486b643a9709c0c334b6c3a2364e9c9f42a8736ff85842ab927123 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/9a/4861c553486b643a9709c0c334b6c3a2364e9c9f42a8736ff85842ab927123
new file mode 100644
index 0000000000..fdc89b7bec
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/9a/4861c553486b643a9709c0c334b6c3a2364e9c9f42a8736ff85842ab927123
@@ -0,0 +1,14 @@
+I"
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/9c/87f7a9ec62311e22997bc3c28abc8eefbb00fa11e055f98b488453f31ca4d9 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/9c/87f7a9ec62311e22997bc3c28abc8eefbb00fa11e055f98b488453f31ca4d9
new file mode 100644
index 0000000000..cff1117616
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/9c/87f7a9ec62311e22997bc3c28abc8eefbb00fa11e055f98b488453f31ca4d9
@@ -0,0 +1,2 @@
+I"Q软件测试分类思维导图
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/9e/c478316b106e4a004357a83f54f8b75f1676d56d499325893d59bdbccf7df7 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/9e/c478316b106e4a004357a83f54f8b75f1676d56d499325893d59bdbccf7df7
new file mode 100644
index 0000000000..e02b36bf77
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/9e/c478316b106e4a004357a83f54f8b75f1676d56d499325893d59bdbccf7df7
@@ -0,0 +1,2 @@
+I"E定义自己的异常类
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/9f/0fae7a49763d3e9c784594d1900378cb5af58018ec70d1566c543f4a9754ab b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/9f/0fae7a49763d3e9c784594d1900378cb5af58018ec70d1566c543f4a9754ab
new file mode 100644
index 0000000000..740a265d1c
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/9f/0fae7a49763d3e9c784594d1900378cb5af58018ec70d1566c543f4a9754ab
@@ -0,0 +1,2 @@
+I"dapt修改为阿里源， sudo vim /etc/apt/sources.list之后出现问题:
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/9f/202dfaed20036a9cab8c88cc3a3d51a4fe2c599476c1ae975472ea3d5f4aea b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/9f/202dfaed20036a9cab8c88cc3a3d51a4fe2c599476c1ae975472ea3d5f4aea
new file mode 100644
index 0000000000..306e354931
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/9f/202dfaed20036a9cab8c88cc3a3d51a4fe2c599476c1ae975472ea3d5f4aea
@@ -0,0 +1,6 @@
+I"a
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/a0/4ef86925c9b84e711522702ab48ab2d8482da070a4c23cc4ee5fabd90fe3a6 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/a0/4ef86925c9b84e711522702ab48ab2d8482da070a4c23cc4ee5fabd90fe3a6
new file mode 100644
index 0000000000..db489ec5b5
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/a0/4ef86925c9b84e711522702ab48ab2d8482da070a4c23cc4ee5fabd90fe3a6
@@ -0,0 +1,97 @@
+I"M软件测试分类思维导图
+
+
+
+软件测试分类思维导图-文本模式
+按阶段划分
+ 单元测试
+ 概念：指对软件中的最小可测单元的检测认证（一般是函数）
+ 应用场景： 测试某个函数的功能是否正确
+ 集成测试
+ 概念： 在单元测试的基础上按照设计要求组装成子系统或系统进行测试
+ 测试需求： 实践证明，一些模块可以单独工作，但是不能保证集成起来也能正常工作
+ 系统测试
+ 概念： 系统测试是将经过集成测试的软件和操作系统/硬件看成一个整体，在实际运行环境下测试
+ 举例： 百度在浏览器和手机上不同操作系统，都要进行测试
+ 验收测试
+ 按对象划分
+ 产品验收： 基于需求文档的需求验收
+ 项目验收： 客户根据需求进行验证性测试
+ 按阶段划分
+ α测试（内测版本）
+ β测试（公测版本）
+ γ测试（待发布版本）
+ 负责人
+ 产品： 产品经理
+ 项目：客户（甲方）或第三方测评机构（乙方）
+
+按代码逻辑划分
+ 黑盒测试
+ 概念： 把测试对象看成一个不能打开的黑盒子，测试时候，完全不考虑盒子里面的代码逻辑结构和具体运行，只根据需求文档，检测程序功能是否符合文档中的说明，检测输出结果对不对
+ 测试依据
+ 需求文档
+ 重点： 以客户的角度，从输入的数据和输出的数据的对应关系出发进行测试
+ 分类
+ 功能相关
+ 功能测试
+ 检查产品是否满足要求
+ 界面测试
+ UI测试，如元素布局
+ 易用性测试
+ 用户体验
+ 专项测试
+ 如安装卸载升级、网络专项
+ 性能相关
+ 性能测试
+ 模拟用户场景，测试系统的各项性能指标，查看是否满足要求
+ 压力测试
+ 在高负载、资源少的情况下运行测试，找出性能隐患
+ 负载测试
+ 不断增加负载，测试软件吞吐量上限，以验证系统的负载能力
+ 白盒测试
+ 概念：把测试对象看成一个打开的透明盒子，测试时候，测试人员利用内部逻辑结构以及相关信息，通过不同分支检查程序状态，检查程序中每条路线能否按照预定要求正确工作
+ 测试依据
+ 源代码
+ 重点
+ 必须检查程序的内部结构，从程序的逻辑着手，得出测试的数据（输入和输出的数据）
+ 对应关系
+ 单元测试：白盒
+ 集成测试：白盒
+ 系统测试：黑盒
+ 验收测试：黑盒
+ 灰盒测试
+ 概念
+ 介于黑盒与白盒测试之间，只关注一部分代码逻辑
+
+按是否运行代码划分
+ 静态测试
+ 概念： 静态测试是指不运行被测程序本身，通过分析或检查程序语法/结构/过程来检查程序的正确性
+ 测试对象
+ 文档
+ 需求文档
+ 各种设计文档
+ 源代码
+ 找出程序可能重复的地方
+ 找出不安全
+ 动态测试
+ 概念： 动态测试就是通过运行被测程序，检查运行结果与预期结果的差距，并分析运行效率、健壮性
+ 测试对象
+ 系统
+ 步骤
+ 测试用例设计
+ 执行测试用例
+ 检查运行实际结果与预期结果
+
+按是否自动化执行划分
+ 手工测试： 手工的方法去执行测试
+ 自动化测试：需要借助工具和代码完成手工测试的工作
+
+其他
+ 回归测试： 回归测试是指修改代码之后，重新进行测试，已确定修改没有引入新的错误
+ 冒烟测试： 针对最基本的功能或者流程进行测试
+
+来源
+ https://blog.csdn.net/karsa__/article/details/108036552
+
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/a0/5dd1b0ddce674bdfba0b58b5fb8d1b8f1a1d1e0c462a94f822f8e34f4e8f25 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/a0/5dd1b0ddce674bdfba0b58b5fb8d1b8f1a1d1e0c462a94f822f8e34f4e8f25
new file mode 100644
index 0000000000..8902ddef4f
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/a0/5dd1b0ddce674bdfba0b58b5fb8d1b8f1a1d1e0c462a94f822f8e34f4e8f25
@@ -0,0 +1,174 @@
+I" 回顾一下昨天有关引用传递与值传递有关的内容。
+
+引用传递与值传递
+
+可变对象为引用传递（传址），不可变对象为值传递（传值）。
+
+传值和传址的区别
+传值就是传入一个参数的值，传址就是传入一个参数的地址，也就是内存的地址（相当于指针）。他们的区别是如果函数里面对传入的参数重新赋值，函数外的全局变量是否相应改变，用传值传入的参数是不会改变的，用传址传入就会改变。
+
+Python函数参数传递方式：传递对象引用（传值和传址的混合方式），如果是数字，字符串，元组（不可变对象）则传值；如果是列表，字典（可变对象）则传址；
+
+举个例子：
+a=1
+def f(a):
+ a+=1
+f(a)
+print(a)
+
+
+结果如下：
+
+1
+
+
+这段代码里面，因为a是数字类型，所以是传值的方式，a的值并不会变，输出为1
+
+a=[1]
+def f(a):
+ a[0]+=1
+f(a)
+print(a)
+
+
+结果如下：
+
+[2]
+
+
+这段代码里面，因为a的类型是列表，所以是传址的形式，$a[0]$的值会改变，输出为$[2]$.
+
+我们再打印一下a的地址：
+def changelist(a):
+ a.append(0)
+ print(id(a))
+ print(a)
+a = [4,5,6]
+
+changelist(a)
+print("-"*60)
+print(id(a))
+print(a)
+
+返回结果为：
+2375999356032
+[4, 5, 6, 0]
+------------------------------------------------------------
+2375999356032
+[4, 5, 6, 0]
+
+发现在函数内部和函数外部，a的地址是一样的，说明a是传址的，而且在函数内部改变了a的值，函数外部的a的值也改变了。
+
+函数作用域
+
+所谓作用域（Scope），就是变量的有效范围，就是变量可以在哪个范围以内使用。有些变量可以在整段代码的任意位置使用，有些变量只能在函数内部使用，有些变量只能在 for 循环内部使用。
+
+Python局部变量
+
+在函数内部定义的变量，它的作用域也仅限于函数内部，出了函数就不能使用了，我们将这样的变量称为局部变量（Local Variable）。
+
+要知道，当函数被执行时，Python 会为其分配一块临时的存储空间，所有在函数内部定义的变量，都会存储在这块空间中。而在函数执行完毕后，这块临时存储空间随即会被释放并回收，该空间中存储的变量自然也就无法再被使用。
+
+举例子：
+def demo():
+ add = "http://c.biancheng.net/python/"
+ print("函数内部 add =",add)
+demo()
+print("函数外部 add =",add)
+
+
+运行结果如下：
+函数内部 add = http://c.biancheng.net/python/
+Traceback (most recent call last):
+
+ File "<ipython-input-3-3af67579cb4d>", line 5, in <module>
+ print("函数外部 add =",add)
+
+NameError: name 'add' is not defined
+
+
+可以看到，如果试图在函数外部访问其内部定义的变量，Python 解释器会报 NameError 错误，并提示我们没有定义要访问的变量，这也证实了当函数执行完毕后，其内部定义的变量会被销毁并回收。
+
+Python全局变量
+
+除了在函数内部定义变量，Python 还允许在所有函数的外部定义变量，这样的变量称为全局变量（Global Variable）。
+
+和局部变量不同，全局变量的默认作用域是整个程序，即全局变量既可以在各个函数的外部使用，也可以在各函数内部使用。
+
+定义全局变量的方式有以下 2 种：
+
+ - 在函数体外定义的变量，一定是全局变量，在函数内部也可以使用。
+
+
+
+
+ - 在函数体内定义全局变量。即使用 global 关键字对变量进行修饰后，该变量就会变为全局变量。
+
+
+查看变量作用域
+
+globals()函数
+globals() 函数为 Python 的内置函数，它可以返回一个包含全局范围内所有变量的字典，该字典中的每个键值对，键为变量名，值为该变量的值。
+
+举例子：
+#全局变量
+Pyname = "Python教程"
+Pyadd = "http://c.biancheng.net/python/"
+def text():
+ #局部变量
+ Shename = "shell教程"
+ Sheadd= "http://c.biancheng.net/shell/"
+print(globals())
+
+输出结果如下：
+{ ...... , 'Pyname': 'Python教程', 'Pyadd': 'http://c.biancheng.net/python/', ......}
+
+这个结果中，我们可以看到，全局变量 Pyname 和 Pyadd 的键值对都被包含在了 globals() 函数返回的字典中。
+
+locals()函数
+
+locals() 函数也是 Python 内置函数之一，通过调用该函数，我们可以得到一个包含当前作用域内所有变量的字典。这里所谓的“当前作用域”指的是，在函数内部调用 locals() 函数，会获得包含所有局部变量的字典；而在全局范文内调用 locals() 函数，其功能和 globals() 函数相同。
+
+#全局变量
+Pyname = "Python教程"
+Pyadd = "http://c.biancheng.net/python/"
+def text():
+ #局部变量
+ Shename = "shell教程"
+ Sheadd= "http://c.biancheng.net/shell/"
+ print("函数内部的 locals:")
+ print(locals())
+text()
+print("函数外部的 locals:")
+print(locals())
+
+程序执行结果为：
+函数内部的 locals:
+{'Sheadd': 'http://c.biancheng.net/shell/', 'Shename': 'shell教程'}
+函数外部的 locals:
+{...... , 'Pyname': 'Python教程', 'Pyadd': 'http://c.biancheng.net/python/', ...... }
+
+当使用 locals() 函数获取所有全局变量时，和 globals() 函数一样，其返回的字典中会默认包含有很多变量，这些都是 Python 主程序内置的，读者暂时不用理会它们。
+
+var(object)函数
+
+vars() 函数也是 Python 内置函数，其功能是返回一个指定 object 对象范围内所有变量组成的字典。如果不传入object 参数，vars() 和 locals() 的作用完全相同。
+
+Pyname = "Python教程"
+Pyadd = "http://c.biancheng.net/python/"
+class Demo:
+ name = "Python 教程"
+ add = "http://c.biancheng.net/python/"
+print("有 object：")
+print(vars(Demo))
+print("无 object：")
+print(vars())
+
+程序执行结果为：
+有 object：
+{...... , 'name': 'Python 教程', 'add': 'http://c.biancheng.net/python/', ......}
+无 object：
+{...... , 'Pyname': 'Python教程', 'Pyadd': 'http://c.biancheng.net/python/', ...... }
+
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/a1/036f49cb34dbd5a746cd84ecac57c2c51e7507d3d2f636227dc78bd1390e28 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/a1/036f49cb34dbd5a746cd84ecac57c2c51e7507d3d2f636227dc78bd1390e28
new file mode 100644
index 0000000000..cb2611ed20
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/a1/036f49cb34dbd5a746cd84ecac57c2c51e7507d3d2f636227dc78bd1390e28
@@ -0,0 +1,419 @@
+I"B00 写在前面
+如何将ipynb文件转为markdown文件？
+jupyter nbconvert --to markdown note.ipynb
+
+
+chapter 01
+
+import numpy as np
+# 向量
+v = np.array([1,2,3])
+# 矩阵
+m = np.array([[1,2,3],[4,5,6],[7,8,9]])
+# 张量
+t = np.array([
+ [[1,2,3],[4,5,6],[7,8,9]],
+ [[11,12,13],[14,15,16],[17,18,19]],
+ [[21,22,23],[24,25,26],[27,28,29]],
+])
+print("向量："+str(v))
+print("矩阵："+str(m))
+print("张量："+str(t))
+
+
+向量：[1 2 3]
+矩阵：[[1 2 3]
+ [4 5 6]
+ [7 8 9]]
+张量：[[[ 1 2 3]
+ [ 4 5 6]
+ [ 7 8 9]]
+
+ [[11 12 13]
+ [14 15 16]
+ [17 18 19]]
+
+ [[21 22 23]
+ [24 25 26]
+ [27 28 29]]]
+
+
+1.2 矩阵转置
+
+a = np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])
+a_t = a.transpose()
+print(a)
+# print one line to separate the two outputs
+print('-'*30)
+print(a_t)
+
+
+[[ 1 2 3]
+ [ 4 5 6]
+ [ 7 8 9]
+ [10 11 12]]
+------------------------------
+[[ 1 4 7 10]
+ [ 2 5 8 11]
+ [ 3 6 9 12]]
+
+
+1.3 矩阵加法
+有时候允许矩阵和向量相加，得到一个矩阵，本质上是构造了一个将b按行复制的一个新矩阵，这种操作叫做广播（broadcasting）。
+
+1.4 矩阵乘法
+矩阵乘法的结果是一个矩阵，其第i行第j列的元素是矩阵A的第i行与矩阵B的第j列的内积。A的形状为m×n，B的形状为n×p，那么A×B的形状为m×p。矩阵乘法的计算可以用下面的公式表示：
+ \(c[i,j] = a[i,:] * b[:,j]\)
+
+m1 = np.array([[1.0,3.0],[1.0,0.0]])
+m2 = np.array([[1.0,2.0],[3.0,5.0]])
+print(m1)
+print(m2)
+# 矩阵乘法
+m3 = np.dot(m1,m2)
+print(m3)
+# 矩阵按元素相乘
+m4 = np.multiply(m1,m2)
+# 矩阵按元素相乘
+m5 = m1*m2
+print(m4)
+print(m5)
+
+
+[[1. 3.]
+ [1. 0.]]
+[[1. 2.]
+ [3. 5.]]
+[[10. 17.]
+ [ 1. 2.]]
+[[1. 6.]
+ [3. 0.]]
+[[1. 6.]
+ [3. 0.]]
+
+
+1.5 单位矩阵
+单位矩阵是一个方阵，对角线上的元素为1，其余元素为0。单位矩阵的作用是不改变矩阵的值，它乘以任何矩阵都等于原矩阵。
+
+np.identity(3)
+
+array([[1., 0., 0.],
+ [0., 1., 0.],
+ [0., 0., 1.]])
+
+
+1.6 矩阵的逆
+矩阵A的逆（inverse）是一个矩阵B，使得A×B=I，其中I是单位矩阵。矩阵A的逆记为$A^{−1}$。如果A是一个方阵，那么A的逆也是一个方阵。如果A的逆存在，那么A的逆也叫做A的伪逆（pseudo-inverse）。
+
+A = [[1,2],[4,5]]
+A_inv = np.linalg.inv(A)
+print(A_inv)
+
+[[-1.66666667 0.66666667]
+ [ 1.33333333 -0.33333333]]
+
+
+1.7范数 norm
+向量$L^P$范数定义为：
+\(||x||_p = (\sum_{i=1}^n |x_i|^p)^{1/p},p\geq 1,p\in\mathbb{R}\)
+
+L1范数：向量中各个元素绝对值之和
+\(||x||_1 = \sum_{i=1}^n |x_i|\)
+
+L0范数：向量中非零元素的个数
+\(||x||_0 = \sum_{i=1}^n \mathbb{1}(x_i\neq 0)\)
+
+L2范数：向量中各个元素平方和的平方根,也叫欧式范数,是向量x到原点的欧几里得距离，有时候也用L2范数的来衡量向量：$x^Tx$.
+\(||x||_2 = \sqrt{\sum_{i=1}^n x_i^2}\)
+
+L∞范数：向量中各个元素绝对值的最大值
+\(||x||_\infty = \max_{i=1,\cdots,n}|x_i|\)
+
+机器学习中常用的范数有L1范数和L2范数，L1范数用于稀疏性的优化，L2范数用于凸优化。
+
+import numpy as np
+a = np.array([1.0,3.0,5.0])
+print("向量的2范数："+str(np.linalg.norm(a,ord=2)))
+print("向量的1范数："+str(np.linalg.norm(a,ord=1)))
+print("向量的无穷范数："+str(np.linalg.norm(a,ord=np.inf)))
+# 矩阵才有Frobenius范数
+b = np.array([[1.0,3.0,5.0],[2.0,4.0,6.0]])
+print('向量的Frobenius范数：'+str(np.linalg.norm(b,ord='fro')))
+
+
+向量的2范数：5.916079783099616
+向量的1范数：9.0
+向量的无穷范数：5.0
+向量的Frobenius范数：9.539392014169456
+
+
+1.8 特征值分解
+如果一个n×n的矩阵A有n组线性无关的单位特征向量{$v^1$, $v^2$, $\cdots$, $v^n$}，并且对应的特征值为{$\lambda_1$, $\lambda_2$, $\cdots$, $\lambda_n$}，那么矩阵A可以被分解为：
+ \(A = V diag(\lambda) V^{-1}\)
+
+不是所有的矩阵都有特征值分解，如果A是一个n×n的矩阵，那么A的特征值分解存在当且仅当A是可逆的且A的行列式不为0。如果A的特征值分解存在，那么A的特征值分解是唯一的。
+
+A = np.array([[1,2,3],[4,5,6],[7,8,9]])
+# 计算特征值
+eig_value,eig_vector = np.linalg.eig(A)
+print("特征值："+str(eig_value))
+print("特征向量："+str(eig_vector))
+
+
+特征值：[ 1.61168440e+01 -1.11684397e+00 -1.30367773e-15]
+特征向量：[[-0.23197069 -0.78583024 0.40824829]
+ [-0.52532209 -0.08675134 -0.81649658]
+ [-0.8186735 0.61232756 0.40824829]]
+
+
+1.9 奇异值分解
+奇异值分解（Singular Value Decomposition，SVD）是一种矩阵分解方法，它将一个矩阵分解为奇异向量和奇异值，它的分解形式如下：
+ \(A = U\Sigma V^T\)
+
+若A是m×n的矩阵，那么U是m×m的正交矩阵（其列向量称为左奇异向量），V是n×n的正交矩阵（其列向量称为右奇异向量），$\Sigma$是m×n的对角矩阵（对角线上的元素称为奇异值）。奇异值分解的作用是将一个矩阵分解为三个矩阵的乘积，这三个矩阵分别是正交矩阵和对角矩阵，这样就可以将矩阵的秩降低，从而达到降维的目的。
+
+事实上，左奇异向量式$AA^T$的特征向量，右奇异向量是$A^TA$的特征向量，奇异值是$AA^T$特征值的平方根。
+
+A = np.array([[1,2,3],[4,5,6],[7,8,9]])
+U,D,V= np.linalg.svd(A)
+print("U："+str(U))
+print("D："+str(D))
+print("V："+str(V))
+
+
+U：[[-0.21483724 0.88723069 0.40824829]
+ [-0.52058739 0.24964395 -0.81649658]
+ [-0.82633754 -0.38794278 0.40824829]]
+D：[1.68481034e+01 1.06836951e+00 4.41842475e-16]
+V：[[-0.47967118 -0.57236779 -0.66506441]
+ [-0.77669099 -0.07568647 0.62531805]
+ [-0.40824829 0.81649658 -0.40824829]]
+
+
+1.10 PCA分解
+假设我们有m个数据点$x^1,x^2,\cdot,x^m \in \mathbb{R}^n$,每个数据点是一个n维的向量，我们希望将这些数据点投影到一个l维的空间中(降纬之后的损失信息尽可能地少），使得投影后的数据点之间的距离尽可能的大，而投影后的数据点与原始数据点之间的距离尽可能的小。这就是PCA分解。
+PCA分解是线性变化，假设$x^i$分解之后的对应点为$c^i$，那么有：
+ \(f(x) =c\)
+ \(c \approx =g(f(x))\)
+ \(g(c)=Dc,D \in \mathbb{R}^{n\times l}\)
+为了计算方便，我们将这个矩阵的列向量约束为相互正交的；而且，考虑到尺度缩放的问题，我们将这个矩阵的列向量约束为具有单位范数来获得唯⼀解。
+对于给定的x，我们需要找到信息损失最小的$\boldsymbol{c}^{\star}$:
+\(\boldsymbol{c}^{\star}=\arg \min _{\boldsymbol{c}}\|\boldsymbol{x}-g(\boldsymbol{c})\|_2=\arg \min _{\boldsymbol{c}}\|\boldsymbol{x}-g(\boldsymbol{c})\|_2^2\)
+
+这里我们用二范数来衡量信息的损失。展开之后我们有:
+\(\|\boldsymbol{x}-g(\boldsymbol{c})\|_2^2=(\boldsymbol{x}-g(\boldsymbol{c}))^{\top}(\boldsymbol{x}-g(\boldsymbol{c}))=\boldsymbol{x}^{\top} \boldsymbol{x}-2 \boldsymbol{x}^{\top} g(\boldsymbol{c})+g(\boldsymbol{c})^{\top} g(\boldsymbol{c})\)
+
+结合 $g(\boldsymbol{c})$ 的表达式, 忽略不依赖 $\boldsymbol{c}$ 的 $\boldsymbol{x}^{\top} \boldsymbol{x}$ 项, 我们有:
+\(\begin{aligned}
+\boldsymbol{c}^{\star} & =\arg \min _{\boldsymbol{c}}-2 \boldsymbol{x}^{\top} \boldsymbol{D} \boldsymbol{c}+\boldsymbol{c}^{\top} \boldsymbol{D}^{\top} \boldsymbol{D} \boldsymbol{c} \\
+& =\arg \min _{\boldsymbol{c}}-2 \boldsymbol{x}^{\top} \boldsymbol{D} \boldsymbol{c}+\boldsymbol{c}^{\top} \boldsymbol{I}_l \boldsymbol{c} \\
+& =\arg \min _{\boldsymbol{c}}-2 \boldsymbol{x}^{\top} \boldsymbol{D} \boldsymbol{c}+\boldsymbol{c}^{\top} \boldsymbol{c}
+\end{aligned}\)
+
+这里 $\boldsymbol{D}$ 具有单位正交性。
+对 $\boldsymbol{c}$ 求梯度, 并令其为零, 我们有:
+
+\[\begin{aligned}
+\nabla_{\boldsymbol{c}}\left(-2 \boldsymbol{x}^{\top} \boldsymbol{D} \boldsymbol{c}+\boldsymbol{c}^{\top} \boldsymbol{c}\right) & =\mathbf{0} \\
+-2 \boldsymbol{D}^{\top} \boldsymbol{x}+2 \boldsymbol{c} & =\mathbf{0} \\
+\boldsymbol{c} & =\boldsymbol{D}^{\top} \boldsymbol{x}
+\end{aligned}\]
+
+因此, 我们的编码函数为:
+\(f(x)=D^{\top} \boldsymbol{x}\)
+
+此时通过编码解码得到的 $重构\boldsymbol{x}$ 为:
+\(r(x)=g(f(x))=DD^{\top}x\)
+
+接下来求解最优的变换 $\boldsymbol{D}$ 。由于我们需要将 $\boldsymbol{D}$ 应用到所有的 $\boldsymbol{x}_i$ 上，所以我们需要最优化:
+\(\begin{array}{l}
+\boldsymbol{D}^{\star}=\arg \min _{\boldsymbol{D}} \sqrt{\sum_{i, j}\left(\boldsymbol{x}_j^{(i)}-r\left(\boldsymbol{x}^{(i)}\right)_j\right)^2} \\
+\text { s.t. } \boldsymbol{D}^{\top} \boldsymbol{D}=\boldsymbol{I}_l
+\end{array}\)
+
+为了方便, 我们考虑 $l=1$ 的情况, 此时问题简化为:
+\(\begin{array}{l}
+\left.\boldsymbol{d}^{\star}=\arg \min _{\boldsymbol{d}} \sum_i\left(\boldsymbol{x}_j^{(i)}-\boldsymbol{d} \boldsymbol{d}^{\top} \boldsymbol{x}^{(i)}\right)\right)^2 \\
+\text { s.t. } \boldsymbol{d}^{\top} \boldsymbol{d}=1
+\end{array}\)
+
+考虑 $\mathrm{F}$ 范数, 并进一步的推导:
+\(\begin{array}{l}
+\boldsymbol{d}^{\star}=\arg \max _{\boldsymbol{d}} \operatorname{Tr}\left(\boldsymbol{d}^{\top} \boldsymbol{X}^{\top} \boldsymbol{X} \boldsymbol{d}\right) \\
+\text { s.t. } \boldsymbol{d}^{\top} \boldsymbol{d}=1
+\end{array}\)
+
+优化问题可以用特征值分解来求解。
+
+实际计算中,PCA分解的实现是基于SVD分解的,即假设有一个 $m \times n$ 的矩阵 $\boldsymbol{X}$, 数据的均值为零, 即 $\mathbb{E}[\boldsymbol{x}]=0, \boldsymbol{X}$ 对应的无偏样本协方差矩阵: $\operatorname{Var}[\boldsymbol{x}]=\frac{1}{m-1} \boldsymbol{X}^{\top} \boldsymbol{X}^{\mathrm{d}}$
+
+PCA 是通过线性变换找到一个 $\operatorname{Var}[c]$ 是对角矩阵的表示 $\boldsymbol{c}=\boldsymbol{V}^{\top} \boldsymbol{x}$, 矩阵 $\boldsymbol{X}$ 的主成分可以通过奇异值分解 (SVD) 得到, 也就是说主成分是 $\boldsymbol{X}$ 的右奇异向量。假设 $\boldsymbol{V}$ 是 $\boldsymbol{X}=\boldsymbol{U} \boldsymbol{\Sigma} \boldsymbol{V}^{\top}$ 奇异值分解的右奇异向量, 我们得到原来的特征向量方程:
+\(\boldsymbol{X}^{\top} \boldsymbol{X}=\left(\boldsymbol{U} \boldsymbol{\Sigma} \boldsymbol{V}^{\top}\right)^{\top} \boldsymbol{U} \boldsymbol{\Sigma} \boldsymbol{V}^{\top}=\boldsymbol{V} \boldsymbol{\Sigma}^{\top} \boldsymbol{U}^{\top} \boldsymbol{U} \boldsymbol{\Sigma} \boldsymbol{V}^{\top}=\boldsymbol{V} \boldsymbol{\Sigma}^2 \boldsymbol{V}^{\top}\)
+因为根据奇异值的定义 $\boldsymbol{U}^{\top} \boldsymbol{U}=\boldsymbol{I}$ 。因此 $\boldsymbol{X}$ 的方差可以表示为： $\operatorname{Var}[\boldsymbol{x}]=\frac{1}{m-1} \boldsymbol{X}^{\top} \boldsymbol{X}=\frac{1}{m-1} \boldsymbol{V} \boldsymbol{\Sigma}^2 \boldsymbol{V}^{\top}$ 。
+所以 $\boldsymbol{c}$ 的协方差满足： $\operatorname{Var}[\boldsymbol{c}]=\frac{1}{m-1} \boldsymbol{C}^{\top} \boldsymbol{C}=\frac{1}{m-1} \boldsymbol{V}^{\top} \boldsymbol{X}^{\top} \boldsymbol{X} \boldsymbol{V}=\frac{1}{m-1} \boldsymbol{V}^{\top} \boldsymbol{V} \boldsymbol{\Sigma}^2 \boldsymbol{V}^{\top} \boldsymbol{V}=\frac{1}{m-1} \boldsymbol{\Sigma}^2$, 因为根据奇异值定义 $\boldsymbol{V}^{\top} \boldsymbol{V}=\boldsymbol{I}$ 。 $\boldsymbol{c}$ 的协方差是对 角的, $c$ 中的元素是彼此无关的。
+
+# 以 iris 数据为例，展⽰ PCA 的使⽤。
+import pandas as pd
+import numpy as np
+from sklearn.datasets import load_iris
+import matplotlib.pyplot as plt
+from sklearn.preprocessing import StandardScaler
+%matplotlib inline
+
+ # 载入数据
+iris = load_iris()
+df = pd.DataFrame(iris.data, columns=iris.feature_names)
+df['label'] = iris.target
+df.columns = ['sepal length', 'sepal width', 'petal length', 'petal width', 'label']
+# 查看数据
+df.tail()
+
+
+
+
+
+
+
+ |
+ sepal length |
+ sepal width |
+ petal length |
+ petal width |
+ label |
+
+
+
+
+ | 145 |
+ 6.7 |
+ 3.0 |
+ 5.2 |
+ 2.3 |
+ 2 |
+
+
+ | 146 |
+ 6.3 |
+ 2.5 |
+ 5.0 |
+ 1.9 |
+ 2 |
+
+
+ | 147 |
+ 6.5 |
+ 3.0 |
+ 5.2 |
+ 2.0 |
+ 2 |
+
+
+ | 148 |
+ 6.2 |
+ 3.4 |
+ 5.4 |
+ 2.3 |
+ 2 |
+
+
+ | 149 |
+ 5.9 |
+ 3.0 |
+ 5.1 |
+ 1.8 |
+ 2 |
+
+
+
+
# 准备数据
+X = df.iloc[:,0:4]# 取前4列为特征
+y =df.iloc[:,4]# 最后一列为标签
+
+
+class PCA():
+ def __init(self):
+ pass
+ def fit(self,X,n_components):
+ n_samples = np.shape(X)[0]
+ covariance_matrix = 1/(n_samples-1) * (X-X.mean(axis=0)).T.dot(X-X.mean(axis=0))
+ # 对协方差矩阵进行特征值分解
+ eig_vals, eig_vecs = np.linalg.eig(covariance_matrix)
+ # 对特征值进行降序排序
+ idx = eig_vals.argsort()[::-1]
+ eig_vals = eig_vals[idx][:n_components] # 取前n个特征值
+ # atleast_1d函数将输入转换为至少为1维的数组
+ eig_vecs = np.atleast_1d(eig_vecs[:,idx])[:,:n_components]
+
+ # 得到降纬之后的数据
+ X_transformed = X.dot(eig_vecs)
+ return X_transformed
+
+
+
+model = PCA()
+Y = model.fit(X,2)# 降维到2维
+
+
+# 降维后的数据,2列，分别是pca1和pca2,columns表示列名
+pcaDf = pd.DataFrame(np.array(Y),columns=['pca1','pca2'])
+Df = pd.concat([pcaDf,y],axis=1)# axis =1表示列合并
+ax= plt.figure(figsize = (5,5))
+ax = plt.subplot(1,1,1)
+ax.set_xlabel('pca1',fontsize = 15)
+ax.set_ylabel('pca2',fontsize = 15)
+
+targets = [0,1,2] # 3个类别
+colors = ['r','g','b'] # 3种颜色，表示3个类别
+# for target,color in zip(targets,colors):
+# ax.scatter(Df[Df['label']==target]['pca1'],Df[Df['label']==target]['pca2'],c=color,s=50)
+for target,color in zip(targets,colors):
+ indicesToKeep = Df['label'] == target
+ ax.scatter(Df.loc[indicesToKeep,'pca1'],Df.loc[indicesToKeep,'pca2'],c=color,s =50)
+ax.legend(targets)
+# title
+ax.set_title('PCA of IRIS dataset')
+ax.grid()
+
+
+
+
+# 使用sklearn实习PCA
+from sklearn.decomposition import PCA
+sklearn_pca = PCA(n_components=2)
+Y = sklearn_pca.fit_transform(X)
+
+
+PCADf = pd.DataFrame(np.array(Y),columns=['pca1','pca2'])
+Df = pd.concat([PCADf,y],axis=1)
+ax= plt.figure(figsize = (5,5))
+ax = plt.subplot(1,1,1)
+ax.set_xlabel('pca1',fontsize = 15)
+ax.set_ylabel('pca2',fontsize = 15)
+targets = [0,1,2] # 3个类别
+colors = ['r','g','b'] # 3种颜色，表示3个类别
+for target,color in zip(targets,colors):
+ indicesToKeep = Df['label'] == target
+ ax.scatter(Df.loc[indicesToKeep,'pca1'],Df.loc[indicesToKeep,'pca2'],c=color,s =50)
+ax.legend(targets)
+# title
+ax.set_title('PCA of IRIS dataset')
+ax.grid()
+
+
+
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/ab/7635c37c2ea63419e2d29da2e26636a5b6ea159470e6ddd7819f60923b197e b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/ab/7635c37c2ea63419e2d29da2e26636a5b6ea159470e6ddd7819f60923b197e
new file mode 100644
index 0000000000..f4ee2778bc
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/ab/7635c37c2ea63419e2d29da2e26636a5b6ea159470e6ddd7819f60923b197e
@@ -0,0 +1,253 @@
+I"$主要包括日志文件介绍以及快速使用，文件封装，日志配置文件重构，日志工具类应用等等内容。
+
+日志文件
+简介
+logging模块是Python内置的标准模块，主要用于输出运行日志，可以设置输出日志的等级/日志保存路径等
+基本使用
+在testcase文件夹下面，新建t_log文件夹，创建log_demo.py文件，这个文件夹用来存储日志有关的测试用例。
+# 1. 导入logging
+import logging
+# 2. set the basic information
+logging.basicConfig(level = logging.INFO,format='%(asctime)s-%(levelname)s-%(message)s')
+# format: 时间-日志等级-日志信息 %括号里面的内容可以自定义
+# level: INFO表示，只有INFO级别的日志才会被输出，如INFO，WARNING，ERROR，CRITICAL
+# 如果是DEBUG级别的日志，就不会被输出
+#3、定义日志名称getlogger
+logger = logging.getLogger("log_demo")
+#4、info,debug
+logger.info("info") # 只有INFO级别的日志才会被输出
+logger.debug("debug") # 不会被输出
+logger.warning("warning") # WARNING级别的日志会被输出
+
+
+执行这段代码，结果如下：
+```console
+2023-01-17 09:28:54,466-INFO-info
+2023-01-17 09:28:54,466-WARNING-warning
+
+
+日志输出到控制台，文件，指定文件
+
+ - 设置logger名称
+ - 设置logger级别
+ - 创建handler，用于输出控制台或者写入日志文件
+ - 设置日志级别
+ - 定义handler的输出格式
+ - 给logger添加handler
+
+
+在testcase文件夹下面的t_log文件夹下面，创建log_file_demo.py文件,输出到控制台.
+
+# 输出到控制台
+import logging
+# 1. 设置logger名称
+logger = logging.getLogger("log_file_demo")
+# 2. 设置logger级别,这里设置为INFO，只有INFO级别的日志才会被输出
+logger.setLevel(logging.INFO)
+# 3. 创建handler，用于输出控制台或者写入日志文件
+fh_stream = logging.StreamHandler() # StreamHandler表示输出到控制台
+# 4. 设置日志级别
+fh_stream.setLevel(logging.INFO)
+# 5. 定义handler的输出格式，这里设置为时间-日志等级-日志信息
+formatter = logging.Formatter('%(asctime)s %(name)s %(levelname)s')
+fh_stream.setFormatter(formatter)
+# 6. 给logger添加handler，这里添加的是fh_stream,也就是输出到控制台,如果想输出到文件，可以添加fh_file
+logger.addHandler(fh_stream)
+#7、运行输出
+logger.info("this is a info")
+logger.debug("this is a debug")
+logger.warning("this is a warning")
+
+
+在控制台查看输出结果：
+2023-01-17 10:04:31,711 log_file_demo INFO
+2023-01-17 10:04:31,711 log_file_demo WARNING
+
+
+输出到文件：
+#输出到文件
+import logging
+#1、设置logger名称
+logger = logging.getLogger("log_file_demo")
+#2、设置log级别
+logger.setLevel(logging.INFO)
+#3、创建handler
+#写入文件
+fh_file = logging.FileHandler("./test.log")
+#4、设置日志级别
+fh_file.setLevel(logging.WARNING)
+#5、定义输出格式
+formatter = logging.Formatter('%(asctime)s %(name)s %(levelname)s %(message)s ')
+fh_file.setFormatter(formatter)
+#6、添加handler
+logger.addHandler(fh_file)
+#7、运行输出
+logger.info("this is a info")
+logger.debug("this is a debug")
+logger.warning("this is a warning")
+
+
+结果会输出到同文件目录下的test.log文件中，内容如下：
+2023-01-17 10:07:10,826 log_file_demo WARNING this is a warning
+
+为啥这里只有warning级别的日志被输出到文件中呢？
+虽然日志级别设置为INFO，但是在添加handler的时候，设置了日志级别为WARNING，所以只有WARNING级别的日志会被输出到文件中。
+
+
+
+
+
+
+ | 格式 |
+ 说明 |
+
+
+
+
+ | %(name)s |
+ Logger的名字 |
+
+
+ | %(levelno)s |
+ 数字形式的日志级别 |
+
+
+ | %(levelname)s |
+ 文本形式的日志级别 |
+
+
+ | %(pathname)s |
+ 调用日志输出函数的模块的完整路径名，可能没有 |
+
+
+ | %(filename)s |
+ 调用日志输出函数的模块的文件名 |
+
+
+ | %(asctime)s |
+ 字符串形式的当前时间。默认格式是“2003-07-08 16:49:45,896”。逗号后面的是毫秒 |
+
+
+ | %(message)s |
+ 用户输出的消息 |
+
+
+
+
+日志文件的封装
+
+
+ - 封装Log工具类
+在utils文件夹下面创建LogUtil.py文件，封装Log工具类，代码如下：
+
+
+# 创建类
+import logging
+# 定义日志级别关系映射
+# 定义之后，就可以用log_l[self.log_level]去更新原来的self.log_level
+log_l = {
+ "debug":logging.DEBUG,
+ "info":logging.INFO,
+ "warning":logging.WARNING,
+ "error":logging.ERROR
+}
+class Logger:
+# 定义参数
+## 输出文件名称，Loggername,日志级别
+ def __init__(self,log_file,log_name,log_level):
+ self.log_file = log_file
+ self.log_name = log_name
+ self.log_level = log_level
+ # 编写输出控制台或者文件，利用之前写好的log_file_demo.py
+ #1、设置logger名称
+ self.logger = logging.getLogger(self.log_name)
+ #2、设置log级别
+ self.logger.setLevel(log_l[self.log_level])
+ # 首先判断handler是否存在 创建handler
+ if not self.logger.handlers:
+
+ formatter = logging.Formatter('%(asctime)s %(name)s %(levelname)s %(message)s ')
+ # 输出到控制台
+ fh_stream = logging.StreamHandler()
+ fh_stream.setLevel(log_l[self.log_level])
+ fh_stream.setFormatter(formatter)
+
+ #写入文件
+ fh_file = logging.FileHandler(self.log_file)
+ fh_file.setLevel(log_l[self.log_level])
+ fh_file.setFormatter(formatter)
+ #6、添加handler
+ self.logger.addHandler(fh_file)
+ self.logger.addHandler(fh_stream)
+
+
+
+ - 重构配置文件
+
+
+根据我们封装的LogUtil.py文件，重构配置文件，需要的配置信息包括: log_file,log_lovel
+
+log_name作为参数传入，不写在配置文件中。
+
+打开config文件夹下面的conf.yml文件，修改配置信息，添加如下信息代码如下：
+BASE:
+ # log
+ log_level: "debug"
+ log_extension: ".log"
+
+
+然后修改config.py文件，添加如下代码(第一步，定义logs文件路径；第二步，获取该Log文件路径；第三步，根据该路经获取日志级别和文件扩展名：
+# 定义logs文件路径
+_log_path = base_dir + os.sep + "logs" #下划线开头的变量，表示私有变量
+# 获取该Log文件路径
+def get_log_path():
+ """
+ 获取log文件路径
+ """
+ return _log_path
+# 根据该路经获取日志级别和文件扩展名
+def get_conf_log(self):
+ return self.config["BASE"]["log_level"]
+# 获取文件扩展名
+def get_config_log_extension(self):
+ return self.config["BASE"]["log_extension"]
+
+
+测试以下，在config.py文件的if name == ‘main‘:中执行代码：
+if __name__ == '__main__':
+ conf_read = ConfigYaml()
+ # print(conf_read.get_conf_url())
+ print(conf_read.get_conf_log())
+ print(conf_read.get_config_log_extension())
+
+
+ - 日志工具应用
+
+
+在LogUtil.py文件中，首先初始化参数数据，然后对外提供方法，初始化log工具类，提供其他类使用。
+
+from config import config
+from config.config import ConfigYaml
+import datetime
+import os
+
+# 初始化参数数据
+# 日志文件路径
+log_path = config.get_log_path()
+# 获取当前时间
+current_time = datetime.datetime.now().strftime("%Y-%m-%d")
+# 获取扩展名
+log_extension = ConfigYaml.get_config_log_extension()
+logfile = os.path.join(log_path+current_time+log_extension)
+# 日志文件级别
+loglevel = ConfigYaml.get_conf_log()
+
+# 2. 对外方法，初始化log工具类，提供其他类使用
+def my_log():
+ return Logger(log_file=logfile,log_name=log_name,log_level=loglevel).logger
+
+if __name__ == "__main__":
+ my_log().debug("this is a bug")
+
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/ab/77c6de971ef7774e392b885bdd56b99c37213311bef3f1fd11177fd4914b8f b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/ab/77c6de971ef7774e392b885bdd56b99c37213311bef3f1fd11177fd4914b8f
new file mode 100644
index 0000000000..e2db82c039
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/ab/77c6de971ef7774e392b885bdd56b99c37213311bef3f1fd11177fd4914b8f
@@ -0,0 +1,2 @@
+I"/安装Cockpit
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/ac/600f030df7b5791a1baf804bb10655a9211ce40e8f58907e14b82e962df415 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/ac/600f030df7b5791a1baf804bb10655a9211ce40e8f58907e14b82e962df415
new file mode 100644
index 0000000000..53c0110088
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/ac/600f030df7b5791a1baf804bb10655a9211ce40e8f58907e14b82e962df415
@@ -0,0 +1,21 @@
+I"
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/ae/1bb32df60fb9c0c8f0fb7bd886f9236d694290e157c2d3eea9fdedc4a7a308 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/ae/1bb32df60fb9c0c8f0fb7bd886f9236d694290e157c2d3eea9fdedc4a7a308
new file mode 100644
index 0000000000..a8f6472fb7
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/ae/1bb32df60fb9c0c8f0fb7bd886f9236d694290e157c2d3eea9fdedc4a7a308
@@ -0,0 +1,136 @@
+I"准备工作
+
+shp文件是一个矢量文件，可以用来绘制地图，包括guangdong.dbf（属性表）、guangdong.shp（地图信息）、guangdong.shx（索引信息）。
+
+cursor是什么？
+
+Cursor.so 是一个集成了 GPT-4 的国内直接可以访问的，优秀而强大的免费代码生成器，可以帮助你快速编写、编辑和讨论代码。
+ 它支持多种编程语言，如 Python, Java, C#, JavaScript 等，并且可以根据你的输入和需求自动生成代码片段。
+ Cursor.so 还可以帮助你重构、理解和优化代码，提高开发效率。
+
+官网地址：https://www.cursor.so/
+
+代码生成
+
+使用geopandas
+
+import geopandas as gpd
+import matplotlib.pyplot as plt
+
+# Read the shapefile
+gdf = gpd.read_file('guangdong.shp', encoding='utf-8')
+
+# Plot the map
+gdf.plot()
+
+# Show the plot
+plt.show()
+
+
+结果如下：
+
+
+
+folium和geopandas
+
+folium 建立在 Python 生态系统的数据应用能力和 Leaflet.js 库的映射能力之上，在Python中操作数据，然后通过 folium 在 Leaflet 地图中可视化。
+
+import geopandas as gpd
+import folium
+
+# Read the shapefile
+gdf = gpd.read_file('guangdong.shp', encoding='utf-8')
+
+# Set the CRS of the GeoDataFrame
+gdf = gdf.set_crs('EPSG:4326')
+
+# Create a new map
+m = folium.Map(location=[23.5, 116.5], zoom_start=7)
+
+# Add the shapefile to the map
+folium.GeoJson(gdf).add_to(m)
+
+# Save the map as an HTML file
+m.save('map.html')
+
+
+结果如下：
+
+
+
+使用shapefile
+
+import shapefile
+import matplotlib.pyplot as plt
+
+# Read the shapefile
+sf = shapefile.Reader("guangdong.shp")
+
+# Plot the map
+for shape in sf.shapeRecords():
+ x = [i[0] for i in shape.shape.points[:]]
+ y = [i[1] for i in shape.shape.points[:]]
+ plt.plot(x, y)
+
+# Show the plot
+plt.show()
+
+# %%
+import shapefile
+import matplotlib.pyplot as plt
+
+# Read the shapefile
+sf = shapefile.Reader("guangdong.shp")
+
+
+shapefile2
+
+import shapefile
+import matplotlib.pyplot as plt
+
+# Read the shapefile
+sf = shapefile.Reader("guangdong.shp")
+
+# Plot the map
+for shape in sf.shapeRecords():
+ x, y = zip(*shape.shape.points)
+ plt.plot(x, y)
+
+# Show the plot
+plt.show()
+
+
+结果如下：
+
+
+
+使用basemap
+
+from mpl_toolkits.basemap import Basemap
+import shapefile
+import matplotlib.pyplot as plt
+
+# Read the shapefile
+sf = shapefile.Reader("guangdong.shp")
+
+# Create a new map
+m = Basemap(llcrnrlon=109, llcrnrlat=20, urcrnrlon=118, urcrnrlat=26, projection='lcc', lat_1=33, lat_2=45, lon_0=100)
+
+# Plot the map
+for shape in sf.shapeRecords():
+ x, y = zip(*shape.shape.points)
+ x, y = m(x, y)
+ m.plot(x, y, 'k-', linewidth=0.5)
+
+# Show the plot
+plt.show()
+
+
+结果如下：
+
+
+
+项目地址
+
+guangdong_map
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/b0/8cb70a1ff17a91ce4cc14f8a9e3ea3e874a647835dc9e4a41ab58aaf848980 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/b0/8cb70a1ff17a91ce4cc14f8a9e3ea3e874a647835dc9e4a41ab58aaf848980
new file mode 100644
index 0000000000..f639b51e3e
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/b0/8cb70a1ff17a91ce4cc14f8a9e3ea3e874a647835dc9e4a41ab58aaf848980
@@ -0,0 +1,2 @@
+I"9标题表示方法
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/b3/24692a2892dd72dff75c3917bbddcc9d206127f179f4e0b6c2df8eac904534 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/b3/24692a2892dd72dff75c3917bbddcc9d206127f179f4e0b6c2df8eac904534
new file mode 100644
index 0000000000..6b3b2abac2
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/b3/24692a2892dd72dff75c3917bbddcc9d206127f179f4e0b6c2df8eac904534
@@ -0,0 +1,259 @@
+I"X#Excel参数化之参数化运行
+
+在testcase文件夹下面创建test_excel_case.py文件，代码如下：
+
+from config.Conf import ConfigYaml
+from config import Conf
+import os
+from common.ExcelData import Data
+from utils.LogUtil import my_log
+from common import ExcelConfig
+from utils.RequestsUtil import Request
+import json
+import pytest
+from common import Base
+from utils.AssertUtil import AssertUtil
+import allure
+#1、初始化信息
+#1）.初始化测试用例文件
+case_file = os.path.join(Conf.get_data_path(),ConfigYaml().get_excel_file())
+#2）.测试用例sheet名称
+sheet_name = ConfigYaml().get_excel_sheet()
+#3）.获取运行测试用例列表
+data_init = Data(case_file,sheet_name)
+run_list = data_init.get_run_data()
+
+#4）.日志
+log = my_log()
+#初始化dataconfig
+data_key = ExcelConfig.DataConfig
+#2、测试用例方法，参数化运行
+#一个用例的执行
+class TestExcel:
+ #1、增加Pyest
+ #2、修改方法参数
+ #3、重构函数内容
+ #4、pytest.main
+
+ def run_api(self,url,method,params=None,header=None,cookie=None):
+ """
+ 发送请求api
+ :return:
+ """
+ # 2）.接口请求
+ request = Request()
+ # params 转义json
+ # 验证params有没有内容
+ if len(str(params).strip()) is not 0:
+ params = json.loads(params)
+ # method post/get
+ if str(method).lower() == "get":
+ # 2.增加Headers
+ res = request.get(url, json=params, headers=header, cookies=cookie)
+ elif str(method).lower() == "post":
+ res = request.post(url, json=params, headers=header, cookies=cookie)
+ else:
+ log.error("错误请求method: %s" % method)
+
+ return res
+
+ def run_pre(self,pre_case):
+ #初始化数据
+ pass
+ url = ConfigYaml().get_conf_url()+pre_case[data_key.url]
+ method = pre_case[data_key.method]
+ params = pre_case[data_key.params]
+ headers = pre_case[data_key.headers]
+ cookies = pre_case[data_key.cookies]
+
+ # 1.判断headers是否存在，json转义，无需
+ # if headers:
+ # header = json.loads(headers)
+ # else:
+ # header = headers
+ header = Base.json_parse(headers)
+ # 3.增加cookies
+ # if cookies:
+ # cookie = json.loads(cookies)
+ # else:
+ # cookie = cookies
+ cookie = Base.json_parse(cookies)
+ res = self.run_api(url,method,params,header)
+ print("前置用例执行：%s"%res)
+ return res
+
+#1）.初始化信息，url,data
+
+ # 1、增加Pyest
+ @pytest.mark.parametrize("case",run_list)
+ # 2、修改方法参数
+ def test_run(self,case):
+ # 3、重构函数内容
+ #data_key = ExcelConfig.DataConfig
+ # run_list第1个用例，用例，key获取values
+ url = ConfigYaml().get_conf_url()+case[data_key.url]
+ print(url)
+ case_id = case[data_key.case_id]
+ case_model = case[data_key.case_model]
+ case_name = case[data_key.case_name]
+ pre_exec = case[data_key.pre_exec]
+ method = case[data_key.method]
+ params_type = case[data_key.params_type]
+ params = case[data_key.params]
+ expect_result = case[data_key.expect_result]
+ headers = case[data_key.headers]
+ cookies =case[data_key.cookies]
+ code = case[data_key.code]
+ db_verify = case[data_key.db_verify]
+
+
+
+ # 1、验证前置条件
+ if pre_exec:
+ pass
+ # 2、找到执行用例
+ # 前置测试用例
+ pre_case = data_init.get_case_pre(pre_exec)
+ print("前置条件信息为：%s"%pre_case)
+ pre_res = self.run_pre(pre_case)
+ headers,cookies = self.get_correlation(headers,cookies,pre_res)
+
+ header = Base.json_parse(headers)
+ cookie = Base.json_parse(cookies)
+ res = self.run_api(url, method, params, header,cookie)
+ print("测试用例执行：%s" % res)
+
+ #allure
+ #sheet名称 feature 一级标签
+ allure.dynamic.feature(sheet_name)
+ #模块 story 二级标签
+ allure.dynamic.story(case_model)
+ #用例ID+接口名称 title
+ allure.dynamic.title(case_id+case_name)
+ #请求URL 请求类型 期望结果 实际结果描述
+ desc = "<font color='red'>请求URL: </font> {}<Br/>" \
+ "<font color='red'>请求类型: </font>{}<Br/>" \
+ "<font color='red'>期望结果: </font>{}<Br/>" \
+ "<font color='red'>实际结果: </font>{}".format(url,method,expect_result,res)
+ allure.dynamic.description(desc)
+
+ #断言验证
+ #状态码，返回结果内容，数据库相关的结果的验证
+ #状态码
+ assert_util = AssertUtil()
+ assert_util.assert_code(int(res["code"]),int(code))
+ #返回结果内容
+ assert_util.assert_in_body(str(res["body"]),str(expect_result))
+ #数据库结果断言
+ Base.assert_db("db_1",res["body"],db_verify)
+
+
+ #1、初始化数据库
+ # from common.Base import init_db
+ # sql = init_db("db_1")
+ # #2、查询sql，excel定义好的
+ # db_res = sql.fetchone(db_verify)
+ # log.debug("数据库查询结果：{}".format(str(db_res)))
+ # #3、数据库的结果与接口返回的结果验证
+ # #获取数据库结果的key
+ # verify_list = list(dict(db_res).keys())
+ # #根据key获取数据库结果，接口结果
+ # for line in verify_list:
+ # res_line = res["body"][line]
+ # res_db_line = dict(db_res)[line]
+ # #验证
+ # assert_util.assert_body(res_line,res_db_line)
+ # 1.判断headers是否存在，json转义，无需
+ # if headers:
+ # header = json.loads(headers)
+ # else:
+ # header = headers
+ # # 3.增加cookies
+ # if cookies:
+ # cookie = json.loads(cookies)
+ # else:
+ # cookie = cookies
+
+ # #2）.接口请求
+ # request = Request()
+ # #params 转义json
+ # #验证params有没有内容
+ # if len(str(params).strip()) is not 0:
+ # params = json.loads(params)
+ # #method post/get
+ # if str(method).lower()=="get":
+ # # 2.增加Headers
+ # res = request.get(url,json=params,headers = header,cookies=cookie)
+ # elif str(method).lower()=="post":
+ # res = request.post(url, json=params,headers = header,cookies=cookie)
+ # else:
+ # log.error("错误请求method: %s"%method)
+ # print(res)
+#TestExcel().test_run()
+
+ def get_correlation(self,headers,cookies,pre_res):
+ """
+ 关联
+ :param headers:
+ :param cookies:
+ :param pre_res:
+ :return:
+ """
+ #验证是否有关联
+ headers_para,cookies_para = Base.params_find(headers,cookies)
+ #有关联，执行前置用例，获取结果
+ if len(headers_para):
+ headers_data = pre_res["body"][headers_para[0]]
+ #结果替换
+ headers = Base.res_sub(headers,headers_data)
+ if len(cookies_para):
+ cookies_data = pre_res["body"][cookies_para[0]]
+ # 结果替换
+ cookies = Base.res_sub(headers, cookies_data)
+ return headers,cookies
+if __name__ == '__main__':
+ #pass
+ report_path = Conf.get_report_path()+os.sep+"result"
+ report_html_path = Conf.get_report_path()+os.sep+"html"
+ pytest.main(["-s","test_excel_case.py","--alluredir",report_path])
+
+
+ #Base.allure_report("./report/result","./report/html")
+ #Base.send_mail(title="接口测试报告结果",content=report_html_path)
+ #固定headers请求
+ #1.判断headers是否存在，json转义，无需
+ #2.增加Headers
+ #3.增加cookies
+ #4.发送请求
+
+ #动态关联
+ #1、验证前置条件
+ #if pre_exec:
+ #pass
+ #2、找到执行用例
+ #3、发送请求，获取前置用例结果
+ #发送获取前置测试用例，用例结果
+ #数据初始化，get/post，重构
+ #4、替换Headers变量
+ #1、验证请求中是否${}$，返回${}$内容
+ # str1 = '{"Authorization": "JWT ${token}$"}'
+ # if "${" in str1:
+ # print(str1)
+ # import re
+ # pattern = re.compile('\${(.*)}\$')
+ # re_res = pattern.findall(str1)
+ # print(re_res[0])
+ # #2、根据内容token，查询 前置条件测试用例返回结果token = 值
+ # token = "123"
+ # #3、根据变量结果内容，替换
+ # res = re.sub(pattern,token,str1)
+ # print(res)
+ #5、请求发送
+
+ #1、查询，公共方法
+ #2、替换，公共方法
+ #3、验证请求中是否${}$，返回${}$内容，公共方法
+ #4、关联方法
+
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/b5/0f26f28478912068a9c50450e07f3df7b174e5e752771a7dc6fcf3d55fc4c9 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/b5/0f26f28478912068a9c50450e07f3df7b174e5e752771a7dc6fcf3d55fc4c9
new file mode 100644
index 0000000000..85903b9cde
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/b5/0f26f28478912068a9c50450e07f3df7b174e5e752771a7dc6fcf3d55fc4c9
@@ -0,0 +1,23 @@
+I"P
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/b5/3081c88583aa9c3dd968a18cd448188fc58c043f90eaaae8807a6239bc447c b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/b5/3081c88583aa9c3dd968a18cd448188fc58c043f90eaaae8807a6239bc447c
new file mode 100644
index 0000000000..0624b3e8c9
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/b5/3081c88583aa9c3dd968a18cd448188fc58c043f90eaaae8807a6239bc447c
@@ -0,0 +1,327 @@
+I"4主要包括Yaml文件的语法规则，安装方法，Yaml的编写规则，读取方法，Yaml的封装，以及如何在config文件夹下面简历config.yaml配置文件以实现测试用例和测试数据分离。
+
+配置文件Yaml
+Yaml 介绍
+Yaml 是一种所有编程语言可用的友好的数据序列化标准。语法和其他高阶语言类似，并且可以简单表达字
+典、列表和其他基本数据类型的形态。例如，我们登录接口地址，就可以写在配置文件中，方便后续调用。
+
+语法规则如下：
+
+ - 大小写敏感。
+ - 使用缩进表示层级关系。
+ - 使用空格键缩进，而非Tab键缩进
+ - 缩进的空格数目不重要，只要相同层级的元素左侧对齐即可。
+ - 文件中的字符串不需要使用引号标注，但若字符串包含有特殊字符则需用引号标注；
+ - 注释标识为#，注释只能单独占一行。
+
+
+Yaml的安装
+pip install pyyaml -i https://mirror.aliyun.com/pypi/simple/
+
+
+Yaml的编写
+字典格式:键值对的形式，每个键值对占据一行，记得要在：后面加一个空格
+name: "test_yml"
+result: "success"
+
+列表格式:用-表示列表，后面跟着空格。
+- "a"
+- "b"
+- "c"
+
+输出结果如下：
+{'name': 'test_yml', 'result': 'success'}
+['a', 'b', 'c']
+
+字典嵌套字典： 下一级的内容要缩进一格再写
+person1:
+ name: xiaoming
+ age: 18
+person2:
+ name: xiaohong
+ age: 20
+
+输出结果如下：
+{'person1': {'name': 'xiaoming', 'age': 18}, 'person2': {'name': 'xiaohong', 'age': 20}}
+
+字典嵌套列表：下一级的内容要缩进一格再写
+person1:
+ - xiaoming
+ - 18
+person2:
+ - xiaohong
+ - 20
+
+输出结果如下：
+{'person1': ['xiaoming', 18], 'person2': ['xiaohong', 20]}
+
+列表嵌套列表：
+-
+ - a
+ - b
+ - c
+-
+ - 1
+ - 2
+ - 3
+
+输出结果如下：
+[['a', 'b', 'c'], [1, 2, 3]]
+
+列表嵌套字典：
+-
+ name: xiaoming
+ age: 18
+-
+ name: xiaohong
+ age: 20
+
+输出结果如下：
+[{'name': 'xiaoming', 'age': 18}, {'name': 'xiaohong', 'age': 20}]
+
+
+Yaml的读取
+读取单个文件：
+import yaml
+with open("./data.yaml", "r", encoding="utf-8") as f: # 获取文件对象，f是文件句柄,encoding="utf-8"是指定编码格式,防止出现中文乱码
+ # load方法将yaml文件转换成字典或列表
+ data = yaml.load(f, Loader=yaml.FullLoader)
+ # safe_load和load方法一样，但是不支持python的所有数据类型
+ print(data)
+
+读取多个文件：这个主要用在比如所多个测试用例的数据都放在一个文件下。
+import yaml
+with open("./data.yaml", "r", encoding="utf-8") as f:
+ # load_all方法将yaml文件转换成生成器对象,每次读取一个文档,每个文档是一个字典或列表.
+ data = yaml.load_all(f, Loader=yaml.FullLoader) # Loader=yaml.FullLoader是指定加载器,防止出现警告
+ for i in data:
+ print(i)
+
+对应的yaml文件如下：
+---
+"username1": "test123"
+"password": "123456"
+---
+"username1": "test456"
+"password": "123456"
+
+输出结果如下：
+{'username1': 'test123', 'password': '123456'}
+{'username1': 'test456', 'password': '123456'}
+
+
+配置文件-Yaml封装
+yaml封装 → 配置文件conf.yaml → 基本目录配置 → 配置文件读取及使用
+
+在utils文件夹下面新建一个YamlUtil.py文件，用来封装yaml文件的读取操作。
+import yaml
+import os
+# set up the class to read the yaml file
+class YamlReader:
+ def __init__(self, yamlf):
+ # 判断文件是否存在
+ if os.path.exists(yamlf):
+ self.yamlf = yamlf
+ else:
+ raise FileNotFoundError("文件不存在！")
+ self._data = None # 定义一个私有属性，用来存储读取的数据
+ # @property装饰器的作用是把一个方法变成属性调用
+ @property
+ def data(self):
+ # read data from yaml file
+ # 判断是否已经读取过数据，如果已经读取过数据，此时self._data为字典，不为None，就不需要再次读取数据。
+ if not self._data:
+ with open(self.yamlf, 'rb') as f: # rb是以二进制读取
+ self._data = yaml.safe_load(f)
+ return self._data # 返回读取的数据
+
+测试一下这个util文件是否可以正常读取yaml文件,在t_yaml文件夹下面新建一个yaml_demo.py文件，用来测试YamlUtil.py文件是否可以正常读取yaml文件。
+from utils.YamlUtil import YamlReader
+yaml_path = "./data.yml"
+data = YamlReader(yaml_path).data
+print(data)
+
+yaml文件内容如下：
+name: "test_yml"
+result: "success"
+
+输出结果如下：
+{'name': 'test_yml', 'result': 'success'}
+
+
+以上封装的YamlUtil.py文件只能读取单个yaml文件，如果要读取多个yaml文件，需要在YamlUtil.py文件中添加一个方法，用来读取多个yaml文件。
+
+以上的YamlUtil.py模块在读取下列多个yaml文件时候的报错信息如下：
+yaml文件内容：
+---
+"username1": "test123"
+"password": "123456"
+---
+"username1": "test456"
+"password": "123456"
+
+报错信息如下：
+raise ComposerError("expected a single document in the stream",
+yaml.composer.ComposerError: expected a single document in the stream
+ in "./data.yaml", line *, column 1
+
+
+在YamlUtil.py文件中添加一个方法，用来读取多个yaml文件:
+import yaml
+import os
+# set up the class to read the yaml file
+class YamlReader:
+ def __init__(self, yamlf):
+ # 判断文件是否存在
+ if os.path.exists(yamlf):
+ self.yamlf = yamlf
+ else:
+ raise FileNotFoundError("文件不存在！")
+ self._data = None # 定义一个私有属性，用来存储读取的数据
+ self._data_all = None # 定义一个私有属性，用来存储读取的数据
+ # @property装饰器的作用是把一个方法变成属性调用
+ @property
+ def data(self):
+ # read data from yaml file
+ # 判断是否已经读取过数据，如果已经读取过数据，此时self._data为字典，不为None，就不需要再次读取数据。
+ if not self._data:
+ with open(self.yamlf, 'rb') as f: # rb是以二进制读取
+ self._data = yaml.safe_load(f)
+ return self._data # 返回读取的数据
+ # 读取多个yaml文件
+ def data_all(self):
+ # read data from yaml file
+ # 判断是否已经读取过数据，如果已经读取过数据，此时self._data为字典，不为None，就不需要再次读取数据。
+ if not self._data_all:
+ with open(self.yamlf, 'rb') as f: # rb是以二进制读取
+ self._data_all = list(yaml.safe_load_all(f)) # list()函数将yaml.safe_load_all(f)转换为列表
+ return self._data_all # 返回读取的数据
+
+yaml文件内容：
+---
+"username1": "test123"
+"password": "123456"
+---
+"username1": "test456"
+"password": "123456"
+
+yaml_demo.py文件内容：
+from utils.YamlUtil import YamlReader
+yaml_path = "./data.yaml"
+data = YamlReader(yaml_path).data_all()
+print(data)
+
+输出结果如下：
+[{'username1': 'test123', 'password': '123456'}, {'username1': 'test456', 'password': '123456'}]
+
+Yaml配置文件设置
+在config文件下面，新建一个yaml文件，命名为config.yaml，文件内容如下：
+# 测试环境
+BASE:
+ test:
+ url: "http://211.103.136.242:8064"
+
+在config文件下面，新建一个py文件，命名为config.py，用来读取配置文件config.yaml中的内容，文件内容如下：
+首先是，获取当前目录
+# 1. 获取当前基本目录
+import os
+current = os.path.abspath(__file__)# __file__表示当前文件,这步操作是获取当前文件的绝对路径
+# /home/hugo/PycharmProjects/InterAutoTest_W/venv/bin/python /home/hugo/PycharmProjects/InterAutoTest_W/config/config.py
+tmp_dir = os.path.dirname(current)# 获取当前文件的父目录
+# /home/hugo/PycharmProjects/InterAutoTest_W/venv/bin/python /home/hugo/PycharmProjects/InterAutoTest_W/config
+# 获取config目录的父路径
+base_dir = os.path.dirname(tmp_dir)
+# /home/hugo/PycharmProjects/InterAutoTest_W/venv/bin/python /home/hugo/PycharmProjects/InterAutoTest_W
+# 定义config目录的路径
+_config_dir = os.path.join(base_dir, "config") # _开头的变量表示私有变量
+# /home/hugo/PycharmProjects/InterAutoTest_W/venv/bin/python /home/hugo/PycharmProjects/InterAutoTest_W/config
+# 或者也可以这样写：
+# _config_dir = base_dir + os.sep + "config"
+# 定义config.yaml文件的路径
+_config_yaml = os.path.join(_config_dir, "config.yaml")
+
+def get_config_path():
+ return _config_dir
+def get_config_file():
+ return _config_yaml
+
+
+然后是，读取配置文件config.yaml中的内容
+from utils.YamlUtil import YamlReader
+# 1. 获取当前基本目录
+import os
+current = os.path.abspath(__file__)# __file__表示当前文件,这步操作是获取当前文件的绝对路径
+# /home/hugo/PycharmProjects/InterAutoTest_W/venv/bin/python /home/hugo/PycharmProjects/InterAutoTest_W/config/config.py
+tmp_dir = os.path.dirname(current)# 获取当前文件的父目录
+# /home/hugo/PycharmProjects/InterAutoTest_W/venv/bin/python /home/hugo/PycharmProjects/InterAutoTest_W/config
+# 获取config目录的父路径
+base_dir = os.path.dirname(tmp_dir)
+# /home/hugo/PycharmProjects/InterAutoTest_W/venv/bin/python /home/hugo/PycharmProjects/InterAutoTest_W
+# 定义config目录的路径
+_config_dir = os.path.join(base_dir, "config") # _开头的变量表示私有变量
+# /home/hugo/PycharmProjects/InterAutoTest_W/venv/bin/python /home/hugo/PycharmProjects/InterAutoTest_W/config
+# 或者也可以这样写：
+# _config_dir = base_dir + os.sep + "config"
+# 定义config.yaml文件的路径
+_config_yaml = os.path.join(_config_dir, "config.yaml")
+
+def get_config_path():
+ return _config_dir
+def get_config_file():
+ return _config_yaml # _下划线开头的变量表示私有变量
+
+# 2. 读取配置文件
+class ConfigYaml:
+ # 初始化yaml读取配置文件
+ def __init__(self):
+ self.config = YamlReader(get_config_file()).data # self.表示当前类的实例
+ # 获取url
+ def get_conf_url(self):
+ return self.config['BASE']['test']['url']
+if __name__ == '__main__':
+ conf_read = ConfigYaml()
+ print(conf_read.get_conf_url())
+
+这一步做完之后，回到测试用例文件test_mall.py，在这个测试用例，调用config.py文件中的内容，可以实现测试数据和测试用例的分离。
+
+例如，原来的登录测试代码如下：
+from utils.RequestsUtils import requests_get, requests_post
+
+def login():
+# define the testing data
+
+ url = "http://211.103.136.242:8064/autuorizations/"
+ data ={"username":"python","password":"12345678"}
+ # # sent the POST request
+ # response = requests.post(url=url,json=data)
+ # # print the response
+ # print(response.json())
+
+ # 使用utils封装的方法
+ response = requests_post(url=url,json=data,headers=None)
+ # print the response
+ print(response)
+
+
+后来的代码如下：
+from utils.RequestsUtils import requests_get, requests_post
+from config.config import ConfigYaml
+
+# 定义测试的url
+conf_y = ConfigYaml()
+url_path = conf_y.get_conf_url()
+## define login in function
+
+def login():
+ # define the testing data
+
+ url = url_path +"/autuorizations/"
+ # url = "http://211.103.136.242:8064/autuorizations/"
+ data = {"username": "python", "password": "12345678"}
+
+ # 使用utils封装的方法
+ response = requests_post(url=url, json=data, headers=None)
+ # print the response
+ print(response)
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/b5/63e4ebfb45e034659a343d1418930dbeb05b4ac28468e767925df854405087 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/b5/63e4ebfb45e034659a343d1418930dbeb05b4ac28468e767925df854405087
new file mode 100644
index 0000000000..e7b0607ec4
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/b5/63e4ebfb45e034659a343d1418930dbeb05b4ac28468e767925df854405087
@@ -0,0 +1,5 @@
+I"主要包括python一些不太常见的知识点以及python高阶编程需要用到的知识点等等。
+比如说*args 和 **kwargs在函数传参以及函数调用中的用法，以及python中的装饰器等等。
+还比如说pdb在程序运行时查看变量的值，查看程序的执行流程，以及查看函数的调用栈。
+还例如，python中的Map、Reduce、Filter、Lambda等在函数式编程中的用法。
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/b7/4d23b02c0db31e3567f0a12bd887c6f4abc524cb135dbb58391c9345d0d75e b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/b7/4d23b02c0db31e3567f0a12bd887c6f4abc524cb135dbb58391c9345d0d75e
new file mode 100644
index 0000000000..2d5cc659cc
Binary files /dev/null and b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/b7/4d23b02c0db31e3567f0a12bd887c6f4abc524cb135dbb58391c9345d0d75e differ
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/b7/a9c67d334754d36bfa089ae7a409dd1ff69e77eb1a136d0365235962e30610 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/b7/a9c67d334754d36bfa089ae7a409dd1ff69e77eb1a136d0365235962e30610
new file mode 100644
index 0000000000..d8485ff3d0
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/b7/a9c67d334754d36bfa089ae7a409dd1ff69e77eb1a136d0365235962e30610
@@ -0,0 +1,71 @@
+I" 日志文件备份
+
+有时候，为了系统稳定性,除了在/var/log通过回滚机制生成各种日志文件以排查系统故障之外，我们也想把这些关键的日志文件保存到指定文件夹，防止突然断电或者磁盘分区被破坏之后丢失关键的日志信息。
+
+代码如下：（文件名为backup_sysconfig.sh）
+
+#! /bin/bash
+# this script is used to backup the syslog file in /var/log dir everyday
+echo `date`
+cp /var/log/syslog /home/hugo/test_BASH/log
+# adding the user with x permission
+chmod u+x syslog
+# chnage the firname
+today=$(date +%y%m%d)
+echo $today
+mv ./log/syslog ./log/syslog_$today # 同一个文件夹下面就相当于重命名
+
+
+定时调度任务
+crontab 的语句是“分 时 日 月 周 命令”.
+
+开启定时调度任务，每天凌晨1点执行一次
+
+crontab -e
+# 0 1 * * * /home/hugo/test_BASH/back_sysconfig.sh
+
+显示crontab: installing new crontab，表示定时任务已经开启。
+
+查看定时任务
+
+crontab -l
+
+
+开启或者关闭定时任务
+
+service crond start
+service crond stop
+
+
+发现报错：Failed to start crond.service: Unit crond.service not found.
+
+删除调度任务：
+
+
+ - crontab -r ，删除所有任务调度工作
+ - 直接编辑 vim /etc/crontab ，文件内容如下：
+
+
+# Unlike any other crontab you don't have to run the `crontab'
+# command to install the new version when you edit this file
+# and files in /etc/cron.d. These files also have username fields,
+# that none of the other crontabs do.
+
+SHELL=/bin/sh
+# You can also override PATH, but by default, newer versions inherit it from the environment
+#PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
+
+# Example of job definition:
+# .---------------- minute (0 - 59)
+# | .------------- hour (0 - 23)
+# | | .---------- day of month (1 - 31)
+# | | | .------- month (1 - 12) OR jan,feb,mar,apr ...
+# | | | | .---- day of week (0 - 6) (Sunday=0 or 7) OR sun,mon,tue,wed,thu,fri,sat
+# | | | | |
+# * * * * * user-name command to be executed
+17 * * * * root cd / && run-parts --report /etc/cron.hourly
+25 6 * * * root test -x /usr/sbin/anacron || ( cd / && run-parts --report /etc/cron.daily )
+47 6 * * 7 root test -x /usr/sbin/anacron || ( cd / && run-parts --report /etc/cron.weekly )
+52 6 1 * * root test -x /usr/sbin/anacron || ( cd / && run-parts --report /etc/cron.monthly )
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/bb/24a3cfee922a3c35cda7cc183e79cfc0e50c8ccb5d2415f3e70f2d3b31e9ac b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/bb/24a3cfee922a3c35cda7cc183e79cfc0e50c8ccb5d2415f3e70f2d3b31e9ac
new file mode 100644
index 0000000000..5e12360db3
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/bb/24a3cfee922a3c35cda7cc183e79cfc0e50c8ccb5d2415f3e70f2d3b31e9ac
@@ -0,0 +1,330 @@
+I"1包括yaml和Excel用例测试和数据驱动开发。
+
+数据驱动的自动化测试
+
+什么是数据驱动
+
+数据驱动是指将测试数据与测试代码分离，将测试数据存储在一个独立的文件中，然后在测试代码中读取测试数据，最后将测试数据作为参数传递给测试代码。这样做的好处是，测试数据和测试代码分离，测试数据可以独立于测试代码进行修改，测试代码可以独立于测试数据进行修改，测试数据可以被多个测试用例共享，测试数据可以被多个测试框架共享。
+
+yaml数据驱动
+
+yaml是一种数据序列化格式，可以用来存储数据，也可以用来存储配置信息。yaml的语法比较简单，可以用来存储简单的数据结构，比如列表、字典、字符串、数字等。
+
+首先，在data文件夹下面创建所需要用到的测试数据文件，比如testlogin.yaml，然后在login_data.yaml文件中存储测试数据，比如：
+
+
+#登录测试用例
+# ---用来分割不同的测试用例
+---
+#测试用例名称
+"case_name": "登录成功用例"
+#url地址
+"url": "/authorizations/"
+#data
+"data":
+ username: "python"
+ password: "12345678"
+#期望结果
+"expect": '"user_id": 1, "username": "python"'
+---
+#测试用例名称
+"case_name": "登录失败用例"
+#url地址
+"url": "/authorizations/"
+#data
+"data":
+ username: "test123456"
+ password: "111111"
+#期望结果
+"expect": '"user_id": 1, "username": "python"'
+
+
+在这个测试数据着哦功能，当输入用户名和密码正确时，登录成功，当输入用户名和密码错误时，登录失败。
+
+接下来，在测试代码中读取测试数据，执行测试用例，然后将测试数据作为参数传递给测试代码（也即是参数化），比如：在testcases文件夹下面创建test_login.py文件，然后在test_login.py文件中编写测试代码.
+
+这个测试代码应该包括以下内容：
+
+ - 获取测试用例内容,包括获取testlogin.yaml文件的文件路径，使用工具类来读取多个文档内容。
+
+ - 获取testlogin.yaml文件的文件路径：在config文件夹下面的Conf.py文件中添加获取testlogin.yaml文件的文件路径的方法，比如：
+
import os
+from utils.YamlUtil import YamlReader
+#1、获取项目基本目录
+#获取当前项目的绝对路径
+current = os.path.abspath(__file__)
+#print(current)
+BASE_DIR = os.path.dirname(os.path.dirname(current))
+#定义data目录的路径
+_data_path = BASE_DIR + os.sep + "data" # _开头的变量表示私有变量
+def get_data_path():
+ return _data_path
+
+
+
+
+ - 参数化执行测试用例，使用pytest.mark.parametrize来实现参数化。
+
+
+test_login.py文件代码如下：
+
+from config import Conf
+import os
+from utils.YamlUtil import YamlReader
+import pytest
+from config.Conf import ConfigYaml
+from utils.RequestsUtil import Request
+#1、获取测试用例内容list
+#获取testlogin.yml文件路径
+test_file = os.path.join(Conf.get_data_path(),"testlogin.yml")
+#print(test_file)
+#使用工具类来读取多个文档内容
+data_list = YamlReader(test_file).data_all()
+print(data_list)
+#2、参数化执行测试用例
+
+@pytest.mark.parametrize("login",data_list)
+def test_yaml(login):
+ #初始化url,data
+ url = ConfigYaml().get_conf_url()+login["url"]
+ print("url %s"%url)
+ data = login["data"]
+ print("data %s"%data)
+ #post请求
+ request = Request()
+ res = request.post(url,json=data)
+ #打印结果
+ print(res)
+
+if __name__ == "__main__":
+ pytest.main(["-s","Test_login.py"])
+
+
+
+到这里，我们已经完成了测试数据的编写，以及测试代码文档的编写，然后我们编写了使用登录的测试例，通过测试用例参数化去获取这个列表，最后我们还需要对得到的结果进行断言，断言的结果是否和我们期望的结果一致，如果一致，那么就是测试通过，如果不一致，那么就是测试失败。
+
+Excel数据驱动开发
+
+在上面的测试用例中，我们使用了yaml文件来存储测试数据，但是yaml文件的可读性不是很好，所以我们可以使用Excel来存储测试数据，然后使用python来读取Excel中的数据，然后再进行参数化。
+
+这一节内容主要包括Excel用例设计，Excel读取以及Excel参数化运行等等。
+
+Excel用例设计
+
+EXCEL用例设计非常重要，要充分全面的覆盖到测试用例的各个方面，比如：测试用例编号、测试用例名称、测试用例描述、测试用例前置条件、测试用例步骤、测试用例预期结果、测试用例实际结果、测试用例执行结果等等。
+
+
+
+Excel读取
+
+在testcase文件夹下面创建文件夹t_excel，然后在t_excel文件夹下面创建文件excel_demo.py，然后在excel_demo.py文件中编写代码，代码如下：
+
+在这里要注意xlrd读取excel文件的具体报错。
+
+xlrd==1.2.0,报错信息如下:(在新版python3.10中，更新删除了getiterator方法，所以我们老版本的xlrd库调用getiterator方法时会报错。)
+AttributeError: 'ElementTree' object has no attribute 'getiterator'
+
+解决方法：
+通过pip show xlrd命令，找出目录python\Lib\site-packages\xlrd下的xlsx.py文件
+
+修改两个地方的的getiterator()改成iter(),下面的两个地方，这里已经把getiterator()改成iter()了
+
+#1、导入包，xlrd
+import xlrd
+#2、创建workbook对象,这里先把excel文件拷贝一份到当前目录下
+book = xlrd.open_workbook("testdata.xlsx")
+#3、sheet对象
+#索引
+#sheet = book.sheet_by_index(0)
+#名称
+sheet = book.sheet_by_name("美多商城接口测试")
+#4、获取行数和列数
+rows = sheet.nrows #行数
+cols = sheet.ncols #列数
+#5、读取每行的内容
+for r in range(rows):
+ r_values = sheet.row_values(r)
+ #print(r_values)
+#6、读取每列的内容
+for c in range(cols):
+ c_values = sheet.col_values(c)
+ #print(c_values)
+#7、读取固定列的内容
+print(sheet.cell(1,1))
+
+
+
+Excel参数化运行
+
+在utils文件夹下面创建ExcelUtil.py文件，然后在ExcelUtil.py文件中编写代码，主要用于参数化，代码如下：
+
+import os
+import xlrd
+
+#目的：参数化，pytest 需要返回的数据用list来封装
+#自定义异常
+class SheetTypeError:
+ pass
+#1、验证文件是否存在，存在读取，不存在报错
+class ExcelReader:
+ def __init__(self,excel_file,sheet_by):
+ if os.path.exists(excel_file):
+ self.excel_file = excel_file
+ self.sheet_by = sheet_by
+ self._data=list()
+ else:
+ raise FileNotFoundError("文件不存在")
+#2、读取sheet方式，名称，索引
+ def data(self):
+ #存在不读取，不存在读取
+ if not self._data:
+ workbook = xlrd.open_workbook(self.excel_file)
+ if type(self.sheet_by) not in [str,int]:
+ raise SheetTypeError("请输入Int or Str")
+ elif type(self.sheet_by) == int:
+ sheet = workbook.sheet_by_index(self.sheet_by)
+ elif type(self.sheet_by) == str:
+ sheet = workbook.sheet_by_name(self.sheet_by)
+ #3、读取sheet内容
+ #返回list，元素:字典
+ #格式[{"a":"a1","b":"b1"},{"a":"a2","b":"b2"}]
+ #1.获取首行的信息
+ title = sheet.row_values(0)
+ #2.遍历测试行，与首行组成dict，放在list
+ #1 循环，过滤首行，从1开始
+ for col in range(1,sheet.nrows):
+ col_value = sheet.row_values(col)
+ #2 与首组成字典，放list
+ self._data.append(dict(zip(title, col_value)))
+
+#4、结果返回
+ return self._data
+
+# head = ["a","b"]
+# value1 = ["a1","b1"]
+# value2 = ["a2","b2"]
+# data_list= list()
+# #zip
+# data_list.append(dict(zip(head,value1)))
+# data_list.append(dict(zip(head,value2)))
+# #print(dict(zip(head,value1)))
+# #print(dict(zip(head,value2)))
+# print(data_list)
+
+if __name__ == "__main__":
+ reader = ExcelReader("../data/testdata.xlsx","美多商城接口测试")
+ print(reader.data())
+
+
+然后，获取是否运行，参数化，并进行结果断言。
+
+获取是否运行
+
+获取是否运行：在common文件夹下面创建ExcelData.py文件，然后在ExcelData.py文件中编写代码，代码如下：
+
+from utils.ExcelUtil import ExcelReader
+from common.ExcelConfig import DataConfig
+
+class Data:
+ def __init__(self,testcase_file,sheet_name):
+ #1、使用excel工具类，获取结果list
+ #self.reader = ExcelReader("../data/testdata.xlsx","美多商城接口测试")
+ self.reader = ExcelReader(testcase_file,sheet_name)
+ #print(reader.data())
+ #2、列是否运行内容，y
+ def get_run_data(self):
+ """
+ 根据是否运行列==y，获取执行测试用例
+ :return:
+ """
+ run_list = list()
+ for line in self.reader.data():
+ if str(line[DataConfig().is_run]).lower() == "y":
+ #print(line)
+ #3、保存要执行结果，放到新的列表。
+ run_list.append(line)
+ print(run_list)
+ return run_list
+
+ def get_case_list(self):
+ """
+ 获取全部测试用例
+ :return:
+ """
+ # run_list=list()
+ # for line in self.reader.data():
+ # run_list.append(line)
+ run_list = [ line for line in self.reader.data()]
+ return run_list
+
+ def get_case_pre(self,pre):
+ #获取全部测试用例
+ #list判断，执行，获取
+ """
+ 根据前置条件：从全部测试用例取到测试用例
+ :param pre:
+ :return:
+ """
+ run_list = self.get_case_list()
+ for line in run_list:
+ if pre in dict(line).values():
+ return line
+ return None
+
+
+其中，我们这个是根据是否运行列==y，获取执行测试用例，还需要创建一个ExcelConfig.py文件，来表示对应的映射关系。代码如下：
+
+
+
+#定义类
+class DataConfig:
+#定义列属性
+ #用例ID 模块 接口名称 请求URL 前置条件 请求类型 请求参数类型
+ #请求参数 预期结果 实际结果 备注 是否运行 headers cookies status_code 数据库验证
+ #用例ID
+ case_id = "用例ID"
+ case_model = "模块"
+ case_name = "接口名称"
+ url = "请求URL"
+ pre_exec = "前置条件"
+ method = "请求类型"
+ params_type = "请求参数类型"
+ params = "请求参数"
+ expect_result = "预期结果"
+ actual_result = "实际结果"
+ is_run = "是否运行"
+ headers = "headers"
+ cookies = "cookies"
+ code = "status_code"
+ db_verify = "数据库验证"
+
+
+
+我们还需要获取testcase_file,sheet_name，所以我们需要修改config文件夹下面的config.yml，代码如下：
+
+BASE:
+ test:
+ url: "http://211.103.136.242:8064"
+ case_file: "testdata.xlsx"
+ case_sheet: "美多商城接口测试"
+
+
+改完之后，需要修改Conf.py文件，获取测试用例sheet名称,代码如下：
+
+class ConfigYaml:
+ #定义方法获取需要信息
+ def get_excel_file(self):
+ """
+ 获取测试用例excel名称
+ :return:
+ """
+ return self.config["BASE"]["test"]["case_file"]
+
+ def get_excel_sheet(self):
+ """
+ 获取测试用例sheet名称
+ :return:
+ """
+ return self.config["BASE"]["test"]["case_sheet"]
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/bb/3016622bd0b0892951e1d1abc4923518588a6791585e633eb5ba50c3eefb41 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/bb/3016622bd0b0892951e1d1abc4923518588a6791585e633eb5ba50c3eefb41
new file mode 100644
index 0000000000..f696dfd69c
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/bb/3016622bd0b0892951e1d1abc4923518588a6791585e633eb5ba50c3eefb41
@@ -0,0 +1,9 @@
+I"|
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/bb/3d642272ddd172760c586a4d9dd0cc33f67dcd173405e5d1d782682d9b73d2 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/bb/3d642272ddd172760c586a4d9dd0cc33f67dcd173405e5d1d782682d9b73d2
new file mode 100644
index 0000000000..c71aa688e4
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/bb/3d642272ddd172760c586a4d9dd0cc33f67dcd173405e5d1d782682d9b73d2
@@ -0,0 +1,209 @@
+I"主要包括requests库的安装，接口用例编写，requests库的使用，requests库的返回值介绍，requests库的用例编写以及Requests的封装等等。
+
+接口用例编写
+实际情况下，每个模块的测试用例写的越详细越好，要根据接口文档进行编写。
+
+
+
+安装项目依赖
+下载requirements.txt中所需的package:
+pip install -r requirements.txt
+
+列出已经安装的包裹
+pip list
+
+
+pip install临时添加镜像源：
+pip install pytest -i https://pypi.tuna.tsinghua.edu.cn/simple
+
+国内镜像源包括：
+
+
+
+
+ | 镜像源 |
+ 地址 |
+
+
+
+
+ | 清华 |
+ https://pypi.tuna.tsinghua.edu.cn/simple |
+
+
+ | 阿里 |
+ http://mirrors.aliyun.com/pypi/simple/ |
+
+
+ | 豆瓣 |
+ http://pypi.douban.com/simple/ |
+
+
+ | 百度 |
+ https://mirror.baidu.com/pypi/simple |
+
+
+
+
+Requests
+Requests是一个Python HTTP库，用于发送HTTP请求。它比urllib更加方便，但是它不支持验证、cookies或者其它复杂的HTTP客户端功能。Requests是一个Apache2 Licensed开源项目，由Kenneth Reitz创建和维护。
+安装
+pip install requests
+
+使用
+import requests
+r = requests.get('https://api.github.com/events')
+print(r.text)
+
+请求返回介绍
+r.status_code #响应状态
+r.content #字节方式的响应体，会自动为你解码 gzip 和 deflate 压缩
+r.headers #以字典对象存储服务器响应头，若键不存在则返回None
+r.json() #Requests中内置的JSON
+r.url # 获取url
+r.encoding # 编码格式
+r.cookies # 获取cookie
+r.raw #返回原始响应体
+r.text #字符串方式的响应体，会自动根据响应头部的字符编码进行
+r.raise_for_status() #失败请求(非200响应)抛出异常
+
+Requests用例编写
+
+编写登录脚本
+import requests
+def login():
+ url = "http://172.17.0.139:5004/authorizations/"
+ data = {"username":"python",
+ "password":"12345678"}
+ r= requests.post(url,json=data)
+ print(r.text)
+
+编写个人信息获取脚本
+
+import requests
+def info():
+ url = "http://172.17.0.139:5004/user/"
+ token = "***"
+ headers = {
+ "Authorization": "JWT"+token
+ }
+ r = requests.get(url,headers=headers)
+ print(r.text)
+
+
+编写商品列表脚本
+import requests
+def goods_list():
+ url = "http://172.17.0.139:5004/categories/115/skus"
+ data = {
+ # "categroy_id":"115",
+ "page":"1",
+ "page_size": "10",
+ "ordering": "create_time",#'create_time', 'price', 'sales'
+ }
+ r = requests.get(url, json=data)
+ print(r.text)
+ print(r.json)
+
+添加到购物车
+import requests
+def cart():
+ url = "http://172.17.0.139:5004/cart/"
+ data = {
+ "sku_id": "3",
+ "count": "1",
+ "selected": "true",
+ }
+ token = "***"
+ headers = {
+ "Authorization": "JWT"+token
+ }
+ r = requests.post(url, json=data,headers=headers)
+ print(r.text)
+
+保存订单
+import requests
+def order():
+ url = "http://172.17.0.139:5004/cart/"
+ token = "***"
+ headers = {
+ "Authorization": "JWT"+token
+ }
+ r = requests.get(url,headers=headers)
+ print(r.text)
+
+
+Requests的封装
+封装requests_get方法
+#1、创建封装get方法
+def requests_get(url,headers):
+ #2、发送requests get请求
+ r = requests.get(url,headers = headers)
+ #3、获取结果相应内容
+ code = r.status_code
+ try:
+ body = r.json()
+ except Exception as e:
+ body = r.text
+ #4、内容存到字典
+ res = dict()
+ res["code"] = code
+ res["body"] = body
+ #5、字典返回
+ return res
+
+requests_post方法封装
+#1、创建post方法
+def requests_post(url,json=None,headers=None):
+ #2、发送post请求
+ r= requests.post(url,json=json,headers=headers)
+ #3、获取结果内容
+ code = r.status_code
+ try:
+ body = r.json()
+ except Exception as e:
+ body = r.text
+ #4、内容存到字典
+ res = dict()
+ res["code"] = code
+ res["body"] = body
+ #5、字典返回
+ return res
+
+
+可以发现,requests_get和requests_post方法的区别就是请求方式不同,其他都是一样的,所以我们可以把这两个方法合并成一个方法,这样就可以减少代码量,提高代码的复用性.
+# 重构
+# 1、创建类
+class Requests:
+# 2、定义公共方法
+# 2.1 增加方法的参数，根据参数来验证请求方式是get还是post
+# 2.2 重复的内容，复制进来即可
+# 后续参数还可以加入data、cookies等
+ def requests_api(self,url,json=None,headers=None,method="get"):
+ # 3、判断请求方式
+ if method == "get":
+ r = requests.get(url,headers=headers)
+ elif method == "post":
+ r = requests.post(url,json=json,headers=headers)
+ # 4、获取结果内容
+ code = r.status_code
+ try:
+ body = r.json()
+ except Exception as e:
+ body = r.text
+ # 5、内容存到字典
+ res = dict()
+ res["code"] = code
+ res["body"] = body
+ # 6、字典返回
+ return res
+### 重构get/post方法
+ def get(self,**kwargs):
+ # 调用公共方法
+ return self.requests_api(url,method="get",**kwargs)
+ def post(self,**kwargs):
+ # 调用公共方法
+ return self.requests_api(url,method="post",**kwargs)
+
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/bd/f1b3223fbed6ccf28daefebd00c001e5d7b0f49aeba74c2139ba7368cfa5cb b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/bd/f1b3223fbed6ccf28daefebd00c001e5d7b0f49aeba74c2139ba7368cfa5cb
new file mode 100644
index 0000000000..266c5c73e4
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/bd/f1b3223fbed6ccf28daefebd00c001e5d7b0f49aeba74c2139ba7368cfa5cb
@@ -0,0 +1,105 @@
+I"谢春花的歌
+
+https://link.jscdn.cn/sharepoint/aHR0cHM6Ly9oa3VzdGNvbm5lY3QtbXkuc2hhcmVwb2ludC5jb20vOnU6L2cvcGVyc29uYWwvamNoZW5mbF9jb25uZWN0X3VzdF9oay9FVThfNm53Y1ZSQkVtc1FCdzY1WDJnNEJmcnhjaXBrSDdKZHZvWWg2R1Z0ekR3P2U9QUh6cWhP.mp3
+
+
+
+locust是一个简单易用的分布式负载测试工具，主要用来对网站进行负载压力测试。locust使用python语言开发，测试资源消耗远远小于java语言开发的jmeter。且其支持分布式部署测试，能够轻松模拟百万级用户并发测试。
+
+什么是性能测试
+
+性能测试目的主要是解决三个问题：
+
+
+ - 系统及服务能承受的最大负载是多少 ？
+ - 有没有性能平瓶颈 ？
+ - 如果有性能瓶颈，瓶颈在哪里？
+
+
+这三个问题需要从测试的结果中分析得出，其中最重要的性能指标有三点：
+
+（1）响应时间
+
+（2）吞吐量
+
+（3）成功率
+
+传统的性能测试工具有很多， 比如 **Apache Bench、JMeter、LoadRunner **等等，它们都能用来持续增加压力。
+
+不过，Apache Bench 之类的专用工具用来做简单的 HTTP 接口测试还行，如果需要做业务接口的串联测试就力有未逮了。
+
+**JMeter **当然功能强大，也有一定的扩展性，但在这节课我并不想用 JMeter , 原因有两点，一是因为 JMeter 是资源消耗黑洞， 每个任务 / 用户都要使用一个线程，二是因为 JMeter 是基于配置的。
+
+相比之下，新一代的性能测试工具 ** Locust** （蝗虫）是基于编程来实现测试用例的性能测试工具，它更加灵活。而且，它使用 Python 代码来定义用户行为，用写 Python 代码的方式来写测试脚本，远离了复杂的配置脚本和图形界面，利用强大而丰富的 Python 类库可以轻松支持各种协议，简单易用，扩展方便。
+
+locust优缺点
+
+优点：
+
+1.不同与wrk和jmeter使用线程数提高并发量，locust借助于协程实现对用户的模拟，相同物理资源（机器cpu、内存等）配置下locust能支持的并发用户数相比jmeter可以提升一个数量级
+2.相比wrk对复杂场景测试的捉襟见肘和jmeter需要界面点击录制复杂场景的麻烦，locust只需用户使用python编写用户场景完成测试
+3.不同与jmeter复杂的用户使用界面，locust的界面干净整洁，可以实时显示测试的相关细节（如发送请求数、失败数和当前发送请求速度等）
+4.locust虽然是面向web应用测试的，但是它可以用来测试几乎所有系统。给locust编写一个客户端，可以满足你所有的测试要求
+
+缺点：
+
+1.同wrk一样，locust测试结果输出不如jmeter的测试结果展示类型多
+
+运行
+
+运行脚本如下：
+
+from config.config_read import read_yml_file, read_test_data
+from locust import HttpUser, task
+
+headers = read_yml_file('./config/config.yml')['headers']
+params = read_test_data('./config/test_data_process.yml', 'findByPidAndStatusActive')[0]
+
+
+
+class Quickstart(HttpUser):
+ min_wait = 100 # 最小等待时间(ms)，模拟用户在执行每个任务之间等待的最小时间
+ max_wait = 500 # 最大等待时长(ms)，模拟用户在执行每个任务之间等待的最大时长
+ host = read_yml_file('./config/config.yml')['baseurl'] # 访问的域名
+
+ def on_start(self):
+ #开始任务
+ print("start working")
+
+ # 任务target，用@task标记
+ @task
+ def mytask(self):
+ self.client.get('/process/findByPidAndStatusActive', headers=headers, params=params)
+
+
+
+ - 运行脚本方法：
+
+
+ locust -f ***.py
+
+
+-f 指定脚本文件路径
+
+
+ - 访问locust UI界面
+
+
+Starting web interface at http://0.0.0.0:8089 (accepting connections from all network interfaces)
+
+
+ -
+
模拟用户访问
+
+ 指定模拟的用户数（Number of users），以及孵化率（Spawn rate，每秒增加的用户数）, 以及所要测试的服务器地址（Host）。
+
+
+ -
+
查看结果
+RPS(Request Per Second): 每秒请求数的变化，它反映了吞吐量
+Number of Users, 用户并发数量的变化, 它反映了系统能承受的并发请求吞吐量
+ Response Time 响应时间的变化
+
+
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/c1/001764edb9a020f7bd5c8c44ecdc54b5c493b97960cbd9b426dd598303e9fd b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/c1/001764edb9a020f7bd5c8c44ecdc54b5c493b97960cbd9b426dd598303e9fd
new file mode 100644
index 0000000000..ad72f68115
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/c1/001764edb9a020f7bd5c8c44ecdc54b5c493b97960cbd9b426dd598303e9fd
@@ -0,0 +1,2 @@
+I"21. 数据来源
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/c7/6a4190b85b5ae7c8d4ea84f08b33b8122c8f3bfc033140b435062cd711679f b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/c7/6a4190b85b5ae7c8d4ea84f08b33b8122c8f3bfc033140b435062cd711679f
new file mode 100644
index 0000000000..7c9ad89e3c
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/c7/6a4190b85b5ae7c8d4ea84f08b33b8122c8f3bfc033140b435062cd711679f
@@ -0,0 +1,2 @@
+I"-JMeter安装
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/c7/793940fc42a0badec0de24c0eb990dc1af6d6beb8628878acbf6c2229d1961 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/c7/793940fc42a0badec0de24c0eb990dc1af6d6beb8628878acbf6c2229d1961
new file mode 100644
index 0000000000..80aa84e7fd
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/c7/793940fc42a0badec0de24c0eb990dc1af6d6beb8628878acbf6c2229d1961
@@ -0,0 +1,144 @@
+I"字符串转换（每个类都需要__repr__）
+
+在 Python 中定义一个自定义类之后，如果尝试在控制台中输出其实例或在解释器会话中查看，并不能得到十分令人满意的结果。默认的“转换成字符串”功能非常原始，缺少细节：
+
+class Person:
+ def __init__(self, name, age):
+ self.name = name
+ self.age = age
+Person_Bob = Person('Bob', 35)
+print(Person_Bob)
+
+
+输出结果：
+
+<__main__.Person object at 0x0000015BC9246640>
+
+
+可以看到，print只显示类名和对象实例id的字符串（这是CPython中对象的内存地址）。
+
+如何查看具体的内容？
+
+
+ - 直接打印类的属性
+ - 向类中加入自定义的to_string()方法来绕过这个问题。
+
+
+class Person:
+ def __init__(self, name, age):
+ self.name = name
+ self.age = age
+ def to_string(self):
+ return f'Person(name={self.name}, age={self.age})'
+Person_Bob = Person('Bob', 35)
+print(Person_Bob.to_string())
+
+
+输出结果：
+
+Person(name=Bob, age=35)
+
+
+但是，这样做有一个问题，如果我们想要打印一个列表中的所有对象，那么就需要一个一个地调用to_string()方法。这样做显然不够优雅。
+
+或者，直接打印类的属性，还是不够优雅：
+
+class Person:
+ def __init__(self, name, age):
+ self.name = name
+ self.age = age
+Person_Bob = Person('Bob', 35)
+print(Person_Bob.name)
+print(Person_Bob.age)
+
+
+可以向类中添加双下划线方__str__和__repr__。这两个方法以具有 Python 特色的方式在不同情况下将对象转换为字符串。
+
+class Person:
+ def __init__(self, name, age):
+ self.name = name
+ self.age = age
+ def __str__(self):
+ return f'Person(name={self.name}, age={self.age})'
+
+Person_Bob = Person('Bob', 35)
+print(Person_Bob)
+Person_Bob
+
+
+
+输出结果：
+
+Person(name=Bob, age=35)
+Out[6]: <__main__.Person at 0x15bc9249250>
+
+
+可以看到，在控制台中查看 Car 对象得到的依然是之前包含对象 id 的结果，但是打印对象就会得到由新添加的__str__方法返回的字符串。
+
+现在，我们可以格式化字符串，而不必担心对象的内部细节：
+
+f'{Person_Bob}'
+'{0}'.format(Person_Bob)
+
+
+__repr__和__str__的区别
+
+__repr__和__str__的区别在于，__str__是面向用户的，而__repr__是面向开发者的。__repr__的目的是为了让开发者能够更容易地理解对象的内容，而__str__的目的是为了让用户能够更容易地理解对象的内容。
+
+我们在类中定义了__str__方法，在解释器会话中查看Person_Bob对象时，返回结果依然是<main.Person at 0x15bc9249250>。这是因为解释器会话中的对象是__repr__方法返回的字符串，而不是__str__方法返回的字符串。
+
+class Car:
+ def __init__(self,color,mileage):
+ self.color = color
+ self.mileage = mileage
+ def __str__(self):
+ return f'a {self.color} car'
+ def __repr__(self):
+ return f'Car(color={self.color}, mileage={self.mileage})'
+my_car = Car('red', 37281)
+my_car # 在解释器会话中查看对象,返回的是__repr__方法的结果
+# Out[8]: Car(color=red, mileage=37281)
+print(my_car) # 在控制台中查看对象,返回的是__str__方法的结果
+# a red car
+'{0}'.format(my_car) # 使用format函数,返回的是__str__方法的结果
+# a red car
+
+
+从中可以看出，在 Python 解释器会话中查看对象得到的是对象的__repr__结果。
+
+有趣的是，像列表和字典这样的容器总是使用__repr__的结果来表示所包含的对象，哪怕对容器本身调用 str()也是如此。
+
+为了手动选择其中一种字符串转换方法，最好使用内置的str()和 repr()函数。
+
+在 date 对象上调用 str()时，得到的是一些看起来像 ISO 日期格
+式的东西；__repr__侧重的则是得到无歧义的结果，此在对象上调用 repr()会得到相对更复杂的结
+果，其中甚至包括完整的模块和类名称：
+
+import datetime
+today = datetime.date.today()
+# Out[22]: '2023-02-18'
+str(today)
+# Out[23]: 'datetime.date(2023, 2, 18)'
+repr(today)
+
+
+复制并粘贴由这个__repr__返回的字符串，可以作为有效的 Python 语句重新创建原 date对象。
+
+为什么每个类都需要__repr__
+
+如果没有定义__repr__方法，那么Python会使用默认的__repr__方法，这个方法返回的是对象的内存地址，这对于调试来说是非常不方便的。因此建议总是为自定义类添加__repr__方法!!!
+
+class Car:
+ def __init__(self,color,mileage):
+ self.color = color
+ self.mileage = mileage
+ def __repr__(self):
+ return f'Car({self.color!r}, {self.mileage!r})'
+
+
+这里使用!r 转换标志来确保输出字符串使用的是 repr(self.color)和 repr(self. mileage)，而不是 str(self.color)和 str(self.mileage)。
+
+来源
+
+《深入理解Python特性》P051 - P058
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/cb/47a38153dbf0934c2604e36638334450016fe85f37ca906e29a426f23d2b0e b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/cb/47a38153dbf0934c2604e36638334450016fe85f37ca906e29a426f23d2b0e
new file mode 100644
index 0000000000..880c1fc996
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/cb/47a38153dbf0934c2604e36638334450016fe85f37ca906e29a426f23d2b0e
@@ -0,0 +1,6 @@
+I"a
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/cd/4a6925972d2020313cc89e1f9e0291a6cd69a39212d026c51c42757fe97959 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/cd/4a6925972d2020313cc89e1f9e0291a6cd69a39212d026c51c42757fe97959
new file mode 100644
index 0000000000..f34ddb5998
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/cd/4a6925972d2020313cc89e1f9e0291a6cd69a39212d026c51c42757fe97959
@@ -0,0 +1,207 @@
+I" 数据来源
+
+数据来源于和鲸社区-2022年中国狭义乘用车分车型销量数据。
+
+查看数据
+
+import pandas as pd
+df = pd.read_csv('car_sales_2022.csv', names=['rank', 'model', 'manufacturer', 'category', 'segment', 'is_new_energy', 'is_pure_electric', 'price', 'price_min', 'price_max', 'price_mean', 'sales'], header=0)
+print(df.head(10))
+import matplotlib.pyplot as plt
+plt.rcParams['font.sans-serif'] = ['SimHei']
+plt.rcParams['axes.unicode_minus'] = False
+
+
+结果如下：
+
+
+
+数据清理
+
+print("数据清理前行数：", len(df))
+df.drop(df[(df['price_mean'] ==0) | (df['price_mean'].isna())].index, inplace=True)
+print("数据清理后行数：", len(df))
+
+
+结果如下：
+
+数据清理前行数： 612
+数据清理后行数： 607
+
+
+数据查看
+
+按品牌统计车的数量
+
+print(df.groupby('manufacturer')['model'].count().sort_values(ascending=False))
+
+
+结果如下：
+
+manufacturer
+长安汽车 24
+长城汽车 23
+比亚迪 20
+吉利汽车 20
+上汽集团 17
+ ..
+云度新能源 1
+云雀汽车 1
+华晨鑫源 1
+创维汽车 1
+智己汽车 1
+Name: model, Length: 106, dtype: int64
+
+
+查看汽车类型
+
+# 查看category的取值
+print(df['category'].unique())
+# 画柱状图，显示category在不同价格区间的车的数量
+plt.figure(figsize=(10, 6))
+plt.bar(df['category'].unique(), df.groupby('category')['model'].count())
+# ['model'] 为列名，['category'] 为行名
+plt.title('不同车型的数量')
+
+
+结果如下：
+
+
+
+#以category为行名，model为列名，显示销量
+pd.pivot_table(df, values='sales', index='category', columns='model')
+
+
+结果如下：
+
+
+
+# 查看segment的取值
+print(df['segment'].unique())
+# 画饼状图，显示segment的占比
+plt.figure(figsize=(6, 6))
+plt.pie(df.groupby('segment')['model'].count(), labels=df['segment'].unique(), autopct='%1.1f%%')
+plt.title('车型的车身类型占比')
+
+
+结果如下：
+
+
+
+查看新能源车的数量
+
+# 查看新能源车和非新能源车的销售量
+print(df.groupby('is_new_energy')['sales'].sum())
+
+# 查看新能源车和非新能源车的销售量占比
+print(df.groupby('is_new_energy')['sales'].sum() / df['sales'].sum())
+
+# 画图
+
+plt.figure(figsize=(6, 6))
+plt.pie(df.groupby('is_new_energy')['sales'].sum(), labels=['非新能源车', '新能源车'], autopct='%1.1f%%')
+plt.title('新能源车和非新能源车的销售量占比')
+plt.show()
+
+
+结果如下：
+
+is_new_energy
+False 14619974
+True 5512203
+Name: sales, dtype: int64
+is_new_energy
+False 0.726199
+True 0.273801
+Name: sales, dtype: float64
+
+
+
+
+按价格区间统计车的品牌和数量
+
+# 按价格区间统计车的品牌和数量
+bins = [5, 10, 15, 20, 30, 50, 100]
+labels = ['5-10', '10-15', '15-20', '20-30', '30-50', '50-100']
+df['price_range'] = pd.cut(df['price_mean'], bins=bins, labels=labels)
+print(df.groupby('price_range')['model'].value_counts())
+
+plt.figure(figsize=(10,6))
+top_30 = df.nlargest(30, 'sales') # 取销量前30的车型
+plt.scatter(top_30['price_mean'], top_30['sales'], s=100, alpha=0.5, c=top_30['sales'], cmap='Reds')
+plt.colorbar(label='销量(台)')
+
+for i, txt in enumerate(top_30['model']):
+ #plt.annotate(txt, (top_30['price_mean'].iloc[i], top_30['sales'].iloc[i]))
+ plt.annotate(txt, (top_30['price_mean'].iloc[i], top_30['sales'].iloc[i]), xytext=(5, 5), textcoords='offset points', fontsize=8, ha='center')
+ # 标注车型 enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，
+ # 同时列出数据和数据下标，一般用在 for 循环当中。
+ # iloc[] 通过行号来获取行数据
+
+plt.xlabel('平均价格')
+plt.ylabel('销量')
+plt.title('销量前30的车型价格与销量关系散点图')
+plt.show()
+
+
+结果如下：
+
+price_range model
+5-10 VGV U70 1
+ VGV U70Pro 1
+ YARiS L 致享 1
+ YARiS L 致炫 1
+ YOUNG光小新 1
+ ..
+50-100 红旗H9 1
+ 英菲尼迪QX60 1
+ 蔚来ES7 1
+ 蔚来ES8 1
+ 飞行家 1
+Name: model, Length: 597, dtype: int64
+
+
+
+
+查看比亚迪销售情况
+
+print(df[df['manufacturer']=='比亚迪'][['model', 'price_mean', 'sales']])
+plt.figure(figsize=(10,6))
+df_byd = df[df['manufacturer']=='比亚迪']
+plt.scatter(df_byd['price_mean'], df_byd['sales'], s=100, alpha=0.5, c='blue')
+for i, txt in enumerate(df_byd['model']):
+ plt.annotate(txt, (df_byd['price_mean'].iloc[i], df_byd['sales'].iloc[i]))
+
+plt.xlabel('价格')
+plt.ylabel('销量')
+plt.title('比亚迪车型价格与销量关系散点图')
+plt.show()
+
+
+结果如下：
+
+ model price_mean sales
+2 宋PLUS DM-i 18.68 388048
+13 海豚 12.68 204226
+15 秦PLUS DM-i 13.98 188522
+16 元PLUS 15.38 167220
+28 汉EV 27.58 143895
+35 汉DM 26.98 128524
+39 唐DM 27.08 125368
+47 秦PLUS EV 16.13 119755
+96 宋PLUS EV 19.53 66935
+102 驱逐舰 05 13.98 61949
+121 海豹 25.13 51200
+160 秦EV 14.98 33665
+181 元Pro 10.88 26313
+199 唐EV 31.28 23217
+226 宋Pro DM-i 15.33 20323
+242 比亚迪e2 12.33 17790
+308 宋MAX DM-i 16.13 11037
+385 比亚迪e3 15.48 5726
+488 护卫舰 07 24.63 1805
+529 比亚迪D1 16.28 994
+
+
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/cf/b655bc3e0f254694d8d1624f4a07a3b19ed39c71c775c6e87d3b40a16112fd b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/cf/b655bc3e0f254694d8d1624f4a07a3b19ed39c71c775c6e87d3b40a16112fd
new file mode 100644
index 0000000000..b62092fa85
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/cf/b655bc3e0f254694d8d1624f4a07a3b19ed39c71c775c6e87d3b40a16112fd
@@ -0,0 +1,9 @@
+I"
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d0/b40f77b9b019d6a3fa8ffd054d26156484d8e6c0effa6472dd6cce10d7d7dc b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d0/b40f77b9b019d6a3fa8ffd054d26156484d8e6c0effa6472dd6cce10d7d7dc
new file mode 100644
index 0000000000..f435041429
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d0/b40f77b9b019d6a3fa8ffd054d26156484d8e6c0effa6472dd6cce10d7d7dc
@@ -0,0 +1,2 @@
+I"!断言
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d2/bdac414aca4c0d9ad46165bfd14a98b97d3e8c590475acbbf9dab978c21a34 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d2/bdac414aca4c0d9ad46165bfd14a98b97d3e8c590475acbbf9dab978c21a34
new file mode 100644
index 0000000000..dea0544177
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d2/bdac414aca4c0d9ad46165bfd14a98b97d3e8c590475acbbf9dab978c21a34
@@ -0,0 +1,2 @@
+I"!主要包括pytest安装；pytest创建简单的测试用例；pytest基础使用如函数级别的方法和类级别的方法；pytest常见插件如pytest-html将测试结果以html的形式展示出来，pytest-rerunfailures可以进行测试代码的失败重试；pytest的数据参数化，可以实习同样的测试用例函数对多个输入的测试数据的测试；最后是根据pytest运行原则以及pytest.ini指定测试的文件夹，测试函数等对之前的接口模块函数进行重构，进行自动化测试。
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d3/27c1432636b803b627fa04cba38ed5367ebc27b624654f5cd26a359c6c5b88 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d3/27c1432636b803b627fa04cba38ed5367ebc27b624654f5cd26a359c6c5b88
new file mode 100644
index 0000000000..c0c51a90bc
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d3/27c1432636b803b627fa04cba38ed5367ebc27b624654f5cd26a359c6c5b88
@@ -0,0 +1,5 @@
+I"1.安装Pycharm
+Pycharm现在也以snap软件包的形式提供，可以使用命令行的方式进行安装
+sudo snap install pycharm-community --classic
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d3/3249943bd12c579125c3d88e0f730f0ce601533d3eba71db4240acf0398842 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d3/3249943bd12c579125c3d88e0f730f0ce601533d3eba71db4240acf0398842
new file mode 100644
index 0000000000..9c9ce27dbd
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d3/3249943bd12c579125c3d88e0f730f0ce601533d3eba71db4240acf0398842
@@ -0,0 +1,2 @@
+I"HBDD接口测试是什么？
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d3/c070f1e7fd82a9553f927aa8500d2defaac8c1f6979f594a4e9948b2ce828d b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d3/c070f1e7fd82a9553f927aa8500d2defaac8c1f6979f594a4e9948b2ce828d
new file mode 100644
index 0000000000..68e3c74e60
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d3/c070f1e7fd82a9553f927aa8500d2defaac8c1f6979f594a4e9948b2ce828d
@@ -0,0 +1,5 @@
+I"m
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d4/b82eeaa55f29477b48ce45e3633583876bf0cbe3f0262b504d1d1206dec006 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d4/b82eeaa55f29477b48ce45e3633583876bf0cbe3f0262b504d1d1206dec006
new file mode 100644
index 0000000000..9e3cdca6da
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d4/b82eeaa55f29477b48ce45e3633583876bf0cbe3f0262b504d1d1206dec006
@@ -0,0 +1,33 @@
+I"=apt修改为阿里源， sudo vim /etc/apt/sources.list之后出现问题:
+
+W: 无法下载 http://mirrors.aliyun.com/ubuntu/dists/jammy/InRelease 暂时不能解析域名“mirrors.aliyun.com”
+W: 无法下载 http://mirrors.aliyun.com/ubuntu/dists/jammy-security/InRelease 暂时不能解析域名“mirrors.aliyun.com”
+W: 无法下载 http://mirrors.aliyun.com/ubuntu/dists/jammy-updates/InRelease 暂时不能解析域名“mirrors.aliyun.com”
+W: 无法下载 http://mirrors.aliyun.com/ubuntu/dists/jammy-proposed/InRelease 暂时不能解析域名“mirrors.aliyun.com”
+W: 无法下载 http://mirrors.aliyun.com/ubuntu/dists/jammy-backports/InRelease 暂时不能解析域名“mirrors.aliyun.com”
+W: 无法下载 https://ppa.launchpadcontent.net/deadsnakes/ppa/ubuntu/dists/jammy/InRelease 暂时不能解析域名“ppa.launchpadcontent.net”
+W: 部分索引文件下载失败。如果忽略它们，那将转而使用旧的索引文件。
+
+
+
+原因
+
+DNS没有配置好
+
+解决
+
+sudo vim /etc/resolv.conf
+# 或
+sudo vim /run/systemd/resolve/stub-resolv.conf # 建议改这个
+
+
+添加nameserver,如下：(使用阿里巴巴提供的DNS域名解析服务)
+
+# 添加
+# Dynamic resolv.conf(5) file for glibc resolver(3) generated by resolvconf(8)
+# DO NOT EDIT THIS FILE BY HAND -- YOUR CHANGES WILL BE OVERWRITTEN
+
+nameserver 223.5.5.5
+nameserver 223.6.6.6
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d7/3d3b73aaac1d6cd305474b7db6996735d1a203fef9f6f07db5e4eefad3af8c b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d7/3d3b73aaac1d6cd305474b7db6996735d1a203fef9f6f07db5e4eefad3af8c
new file mode 100644
index 0000000000..fa86e42578
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d7/3d3b73aaac1d6cd305474b7db6996735d1a203fef9f6f07db5e4eefad3af8c
@@ -0,0 +1,67 @@
+I"
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d8/581a711ead1c7e512e795d4b1c2abb9ec7c94beabfb41c1bf61968e7d02a5b b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d8/581a711ead1c7e512e795d4b1c2abb9ec7c94beabfb41c1bf61968e7d02a5b
new file mode 100644
index 0000000000..04b99ac693
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d8/581a711ead1c7e512e795d4b1c2abb9ec7c94beabfb41c1bf61968e7d02a5b
@@ -0,0 +1,2 @@
+I"D1. 什么是知识卡片
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d8/d26f5257e81825750fabb07fef0f79fcd466bfe5d09fd8db5a3bb47dcdb588 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d8/d26f5257e81825750fabb07fef0f79fcd466bfe5d09fd8db5a3bb47dcdb588
new file mode 100644
index 0000000000..e7969dd2d1
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d8/d26f5257e81825750fabb07fef0f79fcd466bfe5d09fd8db5a3bb47dcdb588
@@ -0,0 +1,16 @@
+I")
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d9/5b350b89da785ade70ae9e8342915a5b75ef081c5b803eb4d49bf62e86dbc0 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d9/5b350b89da785ade70ae9e8342915a5b75ef081c5b803eb4d49bf62e86dbc0
new file mode 100644
index 0000000000..a46bff45da
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d9/5b350b89da785ade70ae9e8342915a5b75ef081c5b803eb4d49bf62e86dbc0
@@ -0,0 +1,18 @@
+I"
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d9/68dabd18d62274a0cde04cdb1012f9bdcfde94c30c85ab03874bd19e88eb90 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d9/68dabd18d62274a0cde04cdb1012f9bdcfde94c30c85ab03874bd19e88eb90
new file mode 100644
index 0000000000..dc1466aced
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d9/68dabd18d62274a0cde04cdb1012f9bdcfde94c30c85ab03874bd19e88eb90
@@ -0,0 +1,2 @@
+I"m字符串转换（每个类都需要__repr__）
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d9/696f61be8c95089b3162bacba2f98c766aff94766cf17479a108c8a9fff35e b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d9/696f61be8c95089b3162bacba2f98c766aff94766cf17479a108c8a9fff35e
new file mode 100644
index 0000000000..ff8c0bd87d
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d9/696f61be8c95089b3162bacba2f98c766aff94766cf17479a108c8a9fff35e
@@ -0,0 +1,110 @@
+I"1.安装Pycharm
+Pycharm现在也以snap软件包的形式提供，可以使用命令行的方式进行安装
+sudo snap install pycharm-community --classic
+
+
+2.安装python
+sudo apt install python3
+
+查看python版本
+python3 --version
+
+3.安装git
+sudo apt install git
+
+查看git版本
+git --version
+
+4.配置git环境
+因为Gitee会用到SSH，因此需要在shell里检查是否可以连接到Gitee.
+ssh -T git@gitee.com
+
+如果出现以下内容，说明可以连接，需要进行下一步的配置。
+Warning: Permanently added ‘***’ (RSA) to the list of known hosts.
+Permission denied (publickey).
+
+去注册一个Gitee账号，然后配置邮箱。
+
+接着，安装SSH Keys(这一步一定要在~/.ssh目录下进行，否则会报错)。
+cd ~/.ssh
+ls
+
+如果没有id_rsa和id_rsa.pub文件，就需要生成SSH Keys。
+# 备份并移除已经存在的ssh keys,以防万一
+mkdir backup
+mv id_rsa* backup
+rm id_rsa*
+# 生成ssh keys
+ssh-keygen -t rsa -C "***@***.com"
+
+运行的时候会出来输入文件名，就输入id_rsa就可以
+
+接着又会提示你输入两次密码（该密码是你push文件的时候要输入的密码，而不是github管理者的密码），
+
+当然，你也可以不输入密码，直接按回车。那么push的时候就不需要输入密码，直接提交到gitee上了。
+
+发现，id_rsa（私钥）和id_rsa.pub（公钥）这两个文件被创建了。
+
+最后一步，将公钥添加到Gitee上。
+（1）利用gedit/cat命令，查看id_rsa.pub的内容
+（2）在GitHub中，依次点击Settings -> SSH Keys -> Add SSH Key，将id_rsa.pub文件中的字符串复制进去，注意字符串中没有换行和空格。
+(3) 检查SSH Keys是否添加成功
+ssh -T git@gitee.com
+
+如果出现以下内容，说明可以连接，需要进行下一步的配置。
+Hi Chamjeumlam! You’ve successfully authenticated, but GitHub does not provide shell access.
+
+
+通过以上的设置之后，就能够通过SSH的方式，直接使用Git命令访问Gitee托管服务器了.
+
+5.配置Pycharm的python
+在Pycharm中，选择File -> Settings -> Project -> Project Interpreter -> Add -> Existing environment -> 选择python的安装路径 -> OK
+python的安装路径可以通过命令行查看
+which python3
+
+6.配置Pycharm的git
+在Pycharm中，选择File -> Settings -> Version Control -> Git -> Path to Git executable -> 选择git的安装路径 -> OK
+git的安装路径可以通过命令行查看
+which git
+
+7.配置Pycharm的gitee
+下载安装gitee
+ 1、在Setting中选择Plugins#
+ 2、在Marketplace下搜索框中搜索gitee
+ 3、点击Install进行下载安装
+ 4、安装完后点击Restart IDE
+登陆码云
+ 1、File->Setting->搜索gitee#
+ 2、点击Add account#
+ 3、输入账号密码进行登陆
+登陆成功后，会有登陆信息提示.
+8. 建立远程仓库并提交代码
+在Pycharm中，选择VCS -> Import into Version Control -> Share Project on Gitee -> 输入Gitee的用户名和密码 -> OK
+
+做完这一步，提示错误：successfully created project on Gitee but initial commit failed.
+需要进行设置，告诉gitee是谁在运行和更改代码。
+Git 全局设置:
+git config --global user.name "ChanJeunlam"
+git config --global user.email "1120952003@qq.com"
+
+创建 git 仓库:
+mkdir InterAutoTest_W
+cd InterAutoTest_W
+git init
+touch README.md
+git add README.md
+git commit -m "first commit"
+git remote add origin https://gitee.com/chanjeunlam/InterAutoTest_W.git
+git push -u origin "master"
+
+已有仓库?
+cd existing_git_repo
+git remote add origin https://gitee.com/chanjeunlam/InterAutoTest_W.git
+git push -u origin "master"
+
+
+9. Pycharm中其他设置
+更改字体大小：
+1、点击顶部菜单栏中的File选项，接着点击Settings选项；2、依次打开Editor、Font选项；3、根据需要设置字体和字号即可。
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d9/a38deb6a312229ee32029fde457ecf21977f11be1f3369faf9b28075a3bfa0 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d9/a38deb6a312229ee32029fde457ecf21977f11be1f3369faf9b28075a3bfa0
new file mode 100644
index 0000000000..ef7f1ab352
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/d9/a38deb6a312229ee32029fde457ecf21977f11be1f3369faf9b28075a3bfa0
@@ -0,0 +1,2 @@
+I"-单元测试
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/db/0e758dca563da5b4ab6282cd0db7818eada9628e4f677af65cf3ede448a74a b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/db/0e758dca563da5b4ab6282cd0db7818eada9628e4f677af65cf3ede448a74a
new file mode 100644
index 0000000000..ea37aea613
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/db/0e758dca563da5b4ab6282cd0db7818eada9628e4f677af65cf3ede448a74a
@@ -0,0 +1,191 @@
+I"$介绍python中引用与对象，可变数据类型与不可变数据类型，值传递，变量和内存管理等方面的内容
+
+引用与对象
+
+Python 中，一切皆对象。 每个对象由：标识（identity）、类型（type）、value（值）
+组成。
+
+ - 标识用于唯一标识对象，通常对应于对象在计算机内存中的地址。使用内置函数 id(obj)可返回对象 obj 的标识。
+ - 类型用于表示对象存储的“数据”的类型。类型可以限制对象的取值范围以及可执行的
+操作。可以使用 type(obj)获得对象的所属类型。
+ - 值表示对象所存储的数据的信息。使用 print(obj)可以直接打印出值。
+
+
+对象的本质就是：一个内存块，拥有特定的值，支持特定类型的相关操作.
+
+变量也成为：对象的引用。因为，变量存储的就是对象的地址。
+变量通过地址引用了“对象”。
+
+简单来说，在 Python中,采用的是基于值的内存管理方式,每个值在内存中只有一份存储。如果给多个变量赋相同的值(如数值类型、字符串类型、元组),那么多个变量存储的都是指向这个值的内存地址,即id。也就是说，Python中的变量并没有存储变量的值,而是存储指向这个值的地址或引用。
+
+
+
+Python 的赋值机制
+
+x = 666
+y = x
+print(id(x))
+print(id(y))
+
+x = x + 1
+print(id(x))
+print(id(y))
+
+结果如下：
+2015992431536
+2015992431536
+2015992431024
+2015992431536
+
+执行以上三句，在 python 中意味着什么, 实际发生了什么？
+
+x = 666会在内存中创建一个整型对象，然后变量x相当于一个标签,贴在此对象上。
+y = x 将y也作为这个整型对象的标签，而不是重新在内存中创建一个对象。
+x = x+1 将 x 的值加 1，然后在内存中创建另一个整型对象667，将x贴在这个对象上，而不是原来的666 上。
+
+a=3
+b=3
+c=1
+print("a is b结果："+str(a is b)) #True
+print("a is c结果："+str(a is c)) #False
+print("id(a)=%d,id(b)=%d,id(c)=%d"%(id(a),id(b),id(c)))
+
+运行结果如下：
+a is b结果：True
+a is c结果：False
+id(a)=140730432239456,id(b)=140730432239456,id(c)=140730432239392
+
+对象保存在内存空间,这里的’a’和’b’是变量,变量是对象的引用,外部想要使用对象的值，需要通过变量来引用对象。同样的值在内存中只有一份存储,所以’a’和’b’引用的对象是相同的，id(a)=140730432239456=id(b)，这个对象的引用数量为2。当某个对象的引用数量为0时，对象会被回收。
+
+变量回收机制
+当我们使用 del 删除变量时，我们到底做了什么？
+一句话 : 删除贴在对象上的标签，而不是真的删除内存中的对象。
+那么我们就无法删除内存中的对象，然后节省内存吗？
+可以，但是需要通过 python 的垃圾回收机制。简单来说,就是贴在对象上的标签数量为 0 时，会被 python 自动回收。
+
+可变数据类型与不可变数据类型
+
+
+ - 可变数据类型：列表list和字典dict
+ - 不可变数据类型：整型int、浮点型float、字符串型string和元组tuple
+
+
+这里的可变不可变，是指内存中的那块内容（value）是否可以被改变。如果是不可变类型，在对对象本身操作的时候，必须在内存中新申请一块区域(因为老区域不可变)。如果是可变类型，对对象操作的时候，不需要再在其他地方申请内存，只需要在此对象后面连续申请(+/-)即可，也就是它的address会保持不变，但区域会变长或者变短。
+
+也就是说：
+
+ - python中的不可变数据类型，不允许变量的值发生变化，如果改变了变量的值，相当于是新建了一个对象，而对于相同的值的对象，在内存中则只有一个对象，内部会有一个引用计数来记录有多少个变量引用这个对象；
+ - 可变数据类型，允许变量的值发生变化，即如果对变量进行append、+=等这种操作后，只是改变了变量的值，而不会新建一个对象，变量引用的对象的地址也不会变化；对于相同的值的不同对象，在内存中则会存在不同的对象，即每个对象都有自己的地址，相当于内存中对于同值的对象保存了多份，这里不存在引用计数，是实实在在的对象。
+
+
+
+
+
+
+引用传递与值传递
+
+可变对象为引用传递（传址），不可变对象为值传递（传值）。
+
+传值和传址的区别
+传值就是传入一个参数的值，传址就是传入一个参数的地址，也就是内存的地址（相当于指针）。他们的区别是如果函数里面对传入的参数重新赋值，函数外的全局变量是否相应改变，用传值传入的参数是不会改变的，用传址传入就会改变。
+
+Python函数参数传递方式：传递对象引用（传值和传址的混合方式），如果是数字，字符串，元组（不可变对象）则传值；如果是列表，字典（可变对象）则传址；
+
+举个例子：
+a=1
+def f(a):
+ a+=1
+f(a)
+print(a)
+
+
+结果如下：
+
+1
+
+
+这段代码里面，因为a是数字类型，所以是传值的方式，a的值并不会变，输出为1
+
+a=[1]
+def f(a):
+ a[0]+=1
+f(a)
+print(a)
+
+
+结果如下：
+
+[2]
+
+
+这段代码里面，因为a的类型是列表，所以是传址的形式，$a[0]$的值会改变，输出为$[2]$.
+
+浅拷贝和深拷贝
+
+不止是函数里面，函数外面的引用也同样遵循这个规则：
+
+a=1
+b=a
+a=2
+print(a,b)
+a=[1]
+b=a
+a[0]=2
+print(a,b)
+
+输出结果如下：
+2 1
+[2] [2]
+
+所以在python中，当运行上面的代码时，如果a是字典或者列表的话，程序执行的操作并不是新建一个b变量，然后a的值复制给b，而是新建一个b变量，把b的值指向a,也就是相当于在c语言里面的新建一个指向a的指针。
+所以当a的值发生改变时，b的值会相应改变。
+
+如果想要a的值改变时，b的值不改变，就需要用到浅拷贝和深拷贝。
+
+import copy
+
+a=[1,2,3]
+b=a
+a.append(4)
+print(a,b)
+
+a=[1,2,3]
+b=copy.copy(a)
+a.append(4)
+print(a,b)
+
+输出结果如下：
+[1, 2, 3, 4] [1, 2, 3, 4]
+[1, 2, 3, 4] [1, 2, 3]
+
+这里用了copy来让b与a相等，后面如果修改了a的值，b的值并不会改变。看来copy已经可以实现我们上面的提到的需求了，那么deepcopy又有什么用？
+
+如果我们遇到这种情况，copy就解决不了了：
+import copy
+a = [1,[1,2],3]
+b = copy.copy(a)
+a[1].append(3)
+print(a,b)
+
+输出结果如下：
+[1, [1, 2, 3], 3] [1, [1, 2, 3], 3]
+
+这里a和b的值都改变了，这是因为copy只是复制了一层，如果a里面还有列表，那么b里面的列表也是指向a里面的列表的，所以a里面的列表改变了，b里面的列表也会改变。
+这时候就需要用到deepcopy了：
+import copy
+a = [1,[1,2],3]
+b = copy.deepcopy(a)
+a[1].append(3)
+print(a,b)
+
+输出结果如下：
+[1, [1, 2, 3], 3] [1, [1, 2], 3]
+
+这里a的值改变了,b的值没有改变，这是因为deepcopy是递归的复制了所有的值，所以a里面的列表改变了，b里面的列表不会改变。
+
+总结如下：
+浅拷贝：浅拷贝中的元素,是对原对象中子对象的引用。此时如果原对象中某一子对象是可变的，改变后会影响拷贝后的对象，存在副作用。一不小心就会触发很大的问题。
+
+深拷贝：深拷贝则会递归的拷贝原对象中的每一个子对象，拷贝之后的对象与原对象没有关系。
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/db/1c22ad0a7ce25a1e040d1df1b5e88604f1b5bfc3b41b043081568648ea382e b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/db/1c22ad0a7ce25a1e040d1df1b5e88604f1b5bfc3b41b043081568648ea382e
new file mode 100644
index 0000000000..7fb10bee36
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/db/1c22ad0a7ce25a1e040d1df1b5e88604f1b5bfc3b41b043081568648ea382e
@@ -0,0 +1,683 @@
+I"wind turbine数据，如何使用机器学习算法预测轴承健康程度和风功率曲线呢
+
+可以使用机器学习算法进行预测。以下是一个基本的流程，希望能为您提供一些帮助：
+
+
+ - 数据收集和准备：收集风力涡轮机的传感器数据，包括机械振动、电流、温度等。确保数据集中包含健康和故障状态下的数据，并对数据进行清理和处理，例如去除缺失值和异常值。
+ - 特征工程：从原始数据中提取有用的特征，例如频率和幅度特征。可以使用信号处理技术、统计学方法或深度学习方法进行特征提取。
+ - 模型选择和训练：选择适当的机器学习算法进行轴承健康程度和风功率预测，例如支持向量机（SVM）、随机森林（Random Forest）、神经网络等。使用训练数据对模型进行训练，并使用交叉验证技术评估模型性能。
+ - 模型优化和部署：通过调整模型参数和优化特征工程过程，进一步提高模型性能。使用测试数据集评估模型的性能，并将其部署到实际应用中。
+
+
+需要注意的是，风能发电量预测的准确性受多种因素影响，包括风速、风向、空气密度、温度等。因此，最好使用多变量模型进行预测，并考虑使用其他数据源（如天气数据）来提高预测准确性。
+
+第一步需要收集什么样的数据，怎么进行数据预处理呢
+
+在收集风力涡轮机数据时，需要收集与轴承健康状态和风能发电量相关的传感器数据，例如振动、电流、温度等。这些传感器数据可以通过直接连接到风力涡轮机上的传感器进行收集，也可以通过数据日志记录器进行收集。
+
+对于轴承健康状态的预测，需要收集不同状态下的传感器数据，例如正常运行时和轴承故障时的振动数据。收集的数据应该包含不同的轴承类型、负载条件和环境条件。
+
+对于风能发电量的预测，需要收集与风能发电量相关的传感器数据，例如风速、风向、温度、气压等。这些数据可以来自风场的气象站，也可以通过安装在风力涡轮机上的传感器进行收集。
+
+在进行数据预处理时，需要进行以下步骤：
+
+
+ - 数据清洗：去除缺失值、异常值、重复值等。
+ - 数据转换：将数据转换为适合机器学习算法处理的形式，例如将时间序列数据转换为频域数据。
+ - 特征提取：从原始数据中提取有用的特征，例如频率和幅度特征。
+ - 特征缩放：将特征缩放到相同的范围内，以便机器学习算法更好地处理数据。
+ - 特征选择：选择与轴承健康状态和风能发电量预测相关的特征。
+ - 数据划分：将数据集划分为训练集、验证集和测试集。
+
+
+以上步骤可以提高机器学习算法的性能，并帮助提高预测准确性。
+
+第一步数据清理python代码
+
+以下是一些Python代码示例，用于数据清理：
+
+
+ - 去除缺失值
+
+
+
+import pandas as pd
+
+
+# 读取数据集
+
+df = pd.read_csv('data.csv')
+
+
+# 去除缺失值
+
+df.dropna(inplace=True)
+
+
+
+
+ - 去除异常值
+
+
+
+import numpy as np
+
+import pandas as pd
+
+
+# 读取数据集
+
+df = pd.read_csv('data.csv')
+
+
+# 计算异常值的阈值
+
+mean = np.mean(df['column_name'])
+
+std = np.std(df['column_name'])
+
+threshold = 3 * std
+
+
+# 去除异常值
+
+df = df[np.abs(df['column_name'] - mean) < threshold]
+
+
+
+
+ - 去除重复值
+
+
+
+import pandas as pd
+
+
+# 读取数据集
+
+df = pd.read_csv('data.csv')
+
+
+# 去除重复值
+
+df.drop_duplicates(inplace=True)
+
+
+
+这些代码示例仅仅是对数据清洗的基本操作，实际情况需要根据数据集的具体情况进行适当的修改。
+
+重复的取值需要去掉吗
+
+一般来说，重复的取值需要去掉。重复的取值可能会对数据分析和建模产生影响，因此在进行数据清洗时，通常会去除重复的取值。
+
+在Python中，可以使用Pandas库的drop_duplicates()方法来去除DataFrame中的重复行。例如，假设我们有一个名为df的DataFrame，其中包含重复的行，可以按如下方式去除重复的行：
+
+
+import pandas as pd
+
+
+# 读取数据集
+
+df = pd.read_csv('data.csv')
+
+
+# 去除重复行
+
+df.drop_duplicates(inplace=True)
+
+
+
+需要注意的是，drop_duplicates()方法默认根据所有列的值来判断是否为重复行，如果只想根据特定列的值来判断是否为重复行，可以在方法中指定subset参数，例如：
+
+
+# 根据 'column_name' 列的值来去除重复行
+
+df.drop_duplicates(subset=['column_name'], inplace=True)
+
+
+
+另外，有些情况下，重复的取值可能是由于数据采集或存储过程产生的，如果确定这些重复的取值不会对数据分析和建模产生影响，可以保留这些重复的取值。
+
+请问不同的数据之间需要归一化吗，怎么确定在建模过程中不同数据的权重呢
+
+在建模过程中，不同的数据通常需要进行归一化。归一化的目的是将不同数据之间的尺度统一，避免不同数据之间的尺度差异对建模结果产生影响。例如，在使用基于距离的算法（如KNN）时，如果不对数据进行归一化，那么具有较大尺度的数据特征将会对距离计算产生更大的影响，从而可能会导致错误的分类结果。
+
+常用的归一化方法包括最小-最大归一化和Z-score归一化。最小-最大归一化将数据缩放到[0,1]的范围内，而Z-score归一化将数据转换为均值为0，标准差为1的分布。在使用这些方法进行归一化时，需要注意对训练集和测试集进行相同的归一化处理，以避免在测试集上产生不合理的结果。
+
+在建模过程中，不同数据的权重通常是通过特征选择、特征提取或特征工程等方法来确定的。这些方法可以根据不同的场景和问题，选择合适的特征，从而确定不同数据的权重。在选择特征时，需要考虑特征的相关性、重要性和稳定性等因素，并尽可能地保留有用的信息，以提高建模的准确性和泛化性能。
+
+我对这句话理解不够深入“不同数据的权重通常是通过特征选择、特征提取或特征工程等方法来确定的”，请问有具体例子吗
+
+当我们在构建机器学习模型时，我们需要选择哪些数据特征用于训练模型。在这个过程中，我们需要考虑每个特征对模型的贡献以及它们之间的相关性。
+
+特征选择、特征提取和特征工程是一些常用的方法，用于确定不同数据的权重以及如何将它们组合在一起。以下是一些具体的例子：
+
+
+ - 特征选择
+
+
+特征选择是一种通过选择最具有预测能力的特征来减少特征数量的技术。这有助于提高模型的准确性并减少过拟合。一些常用的特征选择方法包括卡方检验、皮尔逊相关系数、互信息等。这些方法可以帮助确定哪些特征对于预测目标变量是有用的，从而决定不同数据的权重。
+
+
+ - 特征提取
+
+
+特征提取是一种将原始数据转换为更具有预测效力的特征的技术。例如，在图像识别问题中，我们可以使用卷积神经网络（CNN）来提取图像的特征，然后将这些特征用于训练分类器。特征提取可以帮助我们确定哪些特征对于预测目标变量是最有用的，并从原始数据中提取出这些特征，从而确定不同数据的权重。
+
+
+ - 特征工程
+
+
+特征工程是一种将原始数据转换为更有意义的特征的技术。例如，在自然语言处理中，我们可以使用词袋模型来将文本转换为向量表示，并使用TF-IDF等方法来加权不同的单词。在这种情况下，我们可以将不同单词的权重作为不同数据的权重。特征工程可以帮助我们确定哪些特征对于预测目标变量是最有用的，并将这些特征组合在一起以确定不同数据的权重。
+
+你能否提供一些机器学习模型中常用的特征选择方法？
+
+当构建机器学习模型时，特征选择是一个重要的步骤。特征选择的目的是从原始数据中选择有用的特征，以提高模型的准确性和泛化性能。以下是一些常用的特征选择方法：
+
+
+ - 方差选择法
+
+
+方差选择法是一种过滤方法，它基于特征的方差来选择特征。如果一个特征的方差很小，那么该特征对目标变量的预测能力可能很低。因此，方差选择法认为这些特征是不重要的，应该被删除。
+
+
+ - 相关系数法
+
+
+相关系数法是一种过滤方法，它基于特征与目标变量之间的相关性来选择特征。如果一个特征与目标变量之间的相关性很小，那么该特征对目标变量的预测能力可能很低。因此，相关系数法认为这些特征是不重要的，应该被删除。
+
+
+ - 卡方检验
+
+
+卡方检验是一种过滤方法，它基于特征与目标变量之间的独立性来选择特征。卡方检验的基本思想是，如果一个特征与目标变量之间是独立的，那么它对目标变量的预测能力可能很低。因此，卡方检验认为这些特征是不重要的，应该被删除。
+
+
+ - 互信息
+
+
+互信息是一种过滤方法，它基于特征与目标变量之间的信息量来选择特征。互信息的基本思想是，如果一个特征与目标变量之间的信息量很大，那么它对目标变量的预测能力可能很高。因此，互信息认为这些特征是重要的，应该被保留。
+
+
+ - Lasso回归
+
+
+Lasso回归是一种包装方法，它通过对特征进行稀疏化来选择特征。Lasso回归的基本思想是，如果一个特征对目标变量的预测能力很低，那么它在Lasso回归中的系数可能很小，从而被压缩为0。因此，Lasso回归认为这些特征是不重要的，应该被删除。
+
+以上是一些常用的特征选择方法，当然还有其他的方法，如随机森林、主成分分析等。在实践中，应根据数据集的特点和问题的需求来选择合适的特征选择方法。
+
+特征工程这一步涉及到的信号处理技术和统计学方法有哪些呢
+
+特征工程是机器学习模型构建过程中非常重要的一步，它涉及到从原始数据中提取有意义的特征，以提高模型的准确性和泛化性能。在特征工程过程中，信号处理技术和统计学方法都具有重要的作用。以下是一些常用的信号处理技术和统计学方法：
+
+
+ - 时频分析
+
+
+时频分析是一种将信号在时间和频率上分解的技术。在特征工程中，时频分析可以用来提取信号的频域特征，如功率谱、频谱峰值等。常用的时频分析方法包括傅里叶变换、小波变换等。
+
+
+ - 滤波
+
+
+滤波是一种将信号的某些频率成分去除或增强的技术。在特征工程中，滤波可以用来去除噪声、减少信号中的干扰等。常用的滤波方法包括低通滤波、高通滤波、带通滤波等。
+
+
+ - 峰值检测
+
+
+峰值检测是一种从信号中提取峰值或极值的技术。在特征工程中，峰值检测可以用来提取信号的峰值或极值，例如心电图中的QRS波群。常用的峰值检测方法包括阈值法、斜率法、二阶导数法等。
+
+
+ - 统计分析
+
+
+统计分析是一种从数据中提取统计特征的技术。在特征工程中，统计分析可以用来提取数据的分布、中心趋势、离散程度等信息。常用的统计分析方法包括均值、标准差、方差、偏度、峰度等。
+
+
+ - 主成分分析
+
+
+主成分分析是一种从高维数据中提取主要特征的技术。在特征工程中，主成分分析可以用来降维和提取主要特征，以减少数据的复杂性和冗余性。常用的主成分分析方法包括奇异值分解、特征值分解等。
+
+以上是一些常用的信号处理技术和统计学方法，在实际应用中需要结合具体问题和数据特点来选择合适的方法。
+
+特征工程这一步涉及到的深度学习方法包括哪些，请至少列出20种，并详细说明他们的优劣势和使用情况（尤其是在风机上）
+
+特征工程是机器学习模型构建中非常重要的一步，涉及到从原始数据中提取有意义的特征。在特征工程中，深度学习方法可以用来自动地学习数据中的特征，并提高模型的准确性和泛化能力。以下是一些常见的深度学习方法，以及它们在风机上的应用情况、优劣势。
+
+
+ - 卷积神经网络（Convolutional Neural Network，CNN）：主要应用于图像和视频处理任务，在风机中可以用于图像数据的分类和检测。优势在于能够自动提取图像的特征，但需要大量的数据和计算资源。
+ - 长短时记忆网络（Long Short-Term Memory，LSTM）：是一种特殊的RNN结构，能够有效地处理长期依赖性问题，在风机中可以用于时间序列数据的建模和预测。优势在于能够有效地解决梯度消失和梯度爆炸等问题，但需要更多的计算资源。
+ - 自编码器（Autoencoder，AE）：主要用于特征提取和降维，在风机中可以用于提取信号的特征表示。优势在于能够自动地学习数据的特征表示，但需要大量的数据和计算资源。
+ - 生成对抗网络（Generative Adversarial Network，GAN）：主要用于生成新的数据，在风机中可以用于生成合成数据，如合成风速、温度等。优势在于能够生成逼真的合成数据，但需要更多的计算资源和优化技巧。
+ - 注意力机制（Attention Mechanism）：主要用于提高模型的准确性和泛化能力，在风机中可以用于对重要特征的加权。优势在于能够提高模型的准确性和泛化能力，但需要更多的计算资源。
+ - 深度置信网络（Deep Belief Network，DBN）：主要用于特征提取和分类，在风机中可以用于信号的分类和故障诊断。优势在于能够自动地学习数据的特征表示和分类器，但需要大量的数据和计算资源。
+ - 变分自编码器（Variational Autoencoder，VAE）：主要用于生成新的数据和特征提取，在风机中可以用于合成数据和信号的降维。优势在于能够自动地学习数据的特征表示和生成器，但需要更多的计算资源。
+ - 深度强化学习（Deep Reinforcement Learning，DRL）：主要用于处理决策问题，在风机中可以用于优化风机的控制策略。优势在于能够自动地学习最优的控制策略，但需要更多的计算资源和优化技巧。
+ - 对抗训练（Adversarial Training）：主要用于提高模型的鲁棒性和泛化能力，在风机中可以用于提高模型的抗干扰能力。优势在于能够提高模型的鲁棒性和泛化能力，但需要更多的计算资源和优化技巧。
+ - 循环神经网络（Recurrent Neural Network，RNN）：是一种专门用于处理序列数据的神经网络结构，在风机中可以用于时间序列数据的建模和预测。优势在于能够考虑时间序列数据的时序关系和长期依赖性，但需要更多的计算资源和调整超参数。对于风机中的数据，RNN可以用于预测风机的状态和剩余寿命，以及识别故障模式和异常情况。例如，可以使用LSTM或GRU等常见的RNN变体来构建预测模型，并对输入数据进行适当的特征工程和预处理。
+ - 卷积自编码器（Convolutional Autoencoder，CAE）：是一种自编码器，专门用于图像处理，在风机中可以用于图像数据的降噪和特征提取。优势在于能够自动地学习图像的特征表示和降噪，但需要更多的计算资源。
+ - 前馈神经网络（Feedforward Neural Network，FNN）：是一种最基本的神经网络结构，在风机中可以用于分类和回归任务。优势在于简单易懂，但需要更多的数据和调整超参数。
+ - 残差网络（Residual Network，ResNet）：是一种特殊的神经网络结构，主要用于解决梯度消失问题，在风机中可以用于信号分类和故障诊断。优势在于能够解决梯度消失问题和提高模型的准确性，但需要更多的计算资源。
+ - 双向循环神经网络（Bidirectional Recurrent Neural Network，BiRNN）：是一种RNN结构的变体，能够同时考虑过去和未来的信息，在风机中可以用于时间序列数据的建模和预测。优势在于能够同时考虑过去和未来的信息，但需要更多的计算资源。
+ - 深度卷积生成对抗网络（Deep Convolutional Generative Adversarial Network，DCGAN）：是一种特殊的GAN结构，主要用于图像生成，在风机中可以用于生成合成图像数据。优势在于能够生成高质量的合成图像，但需要更多的计算资源和优化技巧。
+ - 长短时注意力网络（Long Short-Term Attention Network，LSTAN）：是一种结合了LSTM和注意力机制的神经网络结构，在风机中可以用于时间序列数据的建模和预测。优势在于能够同时考虑时间序列数据和关键特征，但需要更多的计算资源。
+ - 神经网络集成（Neural Network Ensemble）：是一种将多个神经网络模型组合在一起的方法，在风机中可以用于提高模型的准确性和鲁棒性。优势在于能够综合多个模型的优点，但需要更多的计算资源和数据。
+ - 深度强化学习（Deep Reinforcement Learning，DRL）：是一种结合了深度学习和强化学习的方法，在风机中可以用于优化控制策略和调节参数。优势在于能够自动学习最优策略和调节参数，但需要更多的计算资源和调整超参数。
+ - 变分自编码器（Variational Autoencoder，VAE）：是一种自编码器，能够生成新的样本，用于数据增强，在风机中可以用于数据增强和特征提取。优势在于能够生成高质量的合成数据，但需要更多的计算资源和优化技巧。
+
+
+以上是一些常见的深度学习方法在特征工程中的应用，不同的方法适用于不同的任务和数据。在风机上，常见的任务包括信号分类、故障诊断、预测和控制优化等。针对不同的任务和数据，可以选择不同的方法来进行特征工程和模型训练。
+
+特征工程这一步涉及的机器学习算法，在风机上的应用以及优缺点
+
+特征工程是机器学习的重要步骤，它主要是通过对原始数据进行处理和转换，提取有用的信息和特征，以便机器学习算法能够更好地进行模型训练和预测。在风机领域，特征工程通常包括信号处理、统计分析、频谱分析、小波变换、特征选择等方法。以下是一些常见的机器学习算法，在风机上的应用以及优缺点：
+
+
+ - 支持向量机（Support Vector Machine，SVM）：SVM是一种常见的监督学习算法，在风机中可以用于分类和回归任务，例如故障诊断和剩余寿命预测。SVM的优点在于泛化性能好、适用于高维数据和非线性数据，但需要适当调整超参数和处理缺失数据。
+ - 决策树（Decision Tree）：决策树是一种基于树形结构的分类和回归算法，在风机中可以用于故障诊断和异常检测等任务。决策树的优点在于易于理解和解释、能够处理非线性数据和缺失数据，但容易过拟合和不稳定。
+ - 随机森林（Random Forest）：随机森林是一种基于多个决策树的集成学习算法，在风机中可以用于故障诊断和预测任务。随机森林的优点在于具有较高的准确性和泛化能力、能够处理高维数据和缺失数据，但需要更多的计算资源和时间。
+ - 神经网络（Neural Network）：神经网络是一种基于生物神经元结构的人工智能算法，在风机中可以用于故障诊断、剩余寿命预测和控制等任务。神经网络的优点在于能够处理复杂的非线性数据和时序数据、具有良好的泛化性能和自适应性，但需要更多的计算资源和训练时间。
+ - 梯度提升决策树（Gradient Boosting Decision Tree，GBDT）：GBDT是一种基于决策树的集成学习算法，在风机中可以用于故障诊断和预测任务。GBDT的优点在于能够处理高维数据和非线性数据、具有较高的准确性和泛化能力，但需要较多的计算资源和时间。
+
+
+总之，在风机领域，不同的机器学习算法具有各自的优缺点，需要根据具体的应用场景选择合适的算法和特征工程方法，以达到最佳的预测性能和效果。
+
+还有一些其他的机器学习算法吗
+
+是的，还有其他一些常见的机器学习算法，以下是一些例子：
+
+
+ - K近邻算法（K-Nearest Neighbors，KNN）：KNN是一种基于实例的非参数算法，在风机领域可用于故障诊断和分类任务。KNN的优点在于简单易用、不需要训练过程，但需要适当的距离度量和选择K值。
+ - 贝叶斯分类器（Bayesian Classifier）：贝叶斯分类器是一种基于贝叶斯定理的分类算法，可用于风机中的故障诊断和分类任务。贝叶斯分类器的优点在于具有较高的准确性和泛化能力、能够处理高维数据和缺失数据，但需要适当的假设和模型选择。
+ - 主成分分析（Principal Component Analysis，PCA）：PCA是一种常见的降维算法，可用于风机中的特征提取和可视化。PCA的优点在于能够提取数据的主要特征和结构、降低模型复杂度和计算成本，但可能会损失一些信息和解释性。
+ - 独立成分分析（Independent Component Analysis，ICA）：ICA是一种基于统计学的盲源分离算法，可用于风机中的信号分离和特征提取。ICA的优点在于能够提取数据的独立成分和特征、对噪声和干扰具有较好的鲁棒性，但需要适当的假设和调整参数。
+ - 聚类分析（Cluster Analysis）：聚类分析是一种无监督学习算法，可用于风机中的异常检测和行为分析。聚类分析的优点在于能够发现数据的内在结构和相似性、不需要先验知识和标记，但需要适当的距离度量和聚类方法。
+ - 联合概率模型（Joint Probability Model，JPM）：JPM是一种基于概率模型的机器学习算法，可用于风机中的异常检测和故障诊断等任务。JPM的优点在于能够建立数据的联合概率分布、对复杂数据具有较好的建模能力，但需要适当的假设和参数估计。
+ - 马尔可夫链蒙特卡罗（Markov Chain Monte Carlo，MCMC）：MCMC是一种基于马尔可夫链的采样算法，可用于风机中的贝叶斯推断和模型拟合。MCMC的优点在于能够处理高维参数空间和复杂的后验分布、对参数估计具有较好的收敛性和精度，但需要适当的调整步长和采样次数。
+ - 集成学习（Ensemble Learning）：集成学习是一种基于多个模型的组合算法，可用于风机中的分类、回归和聚类等任务。集成学习的优点在于能够减少模型的方差和偏差、提高模型的准确性和泛化能力，但需要适当的模型选择和集成方式。
+ - 深度学习（Deep Learning）：深度学习是一种基于多层神经网络的机器学习算法，可用于风机中的故障诊断、剩余寿命预测和控制等任务。深度学习的优点在于能够处理复杂的非线性数据和时序数据、具有良好的泛化性能和表征能力，但需要更多的计算资源和训练时间。
+
+
+这么多模型，应该怎么选择合适的机器学习算法呢
+
+选择合适的机器学习算法需要考虑多个因素，包括问题类型、数据特征、计算资源和时间成本等。以下是一些选择机器学习算法的一般性建议：
+
+
+ - 确定问题类型：首先需要确定问题类型，例如分类、回归、聚类、异常检测等。不同的问题类型需要使用不同的算法和评估指标。
+ - 分析数据特征：其次需要分析数据的特征，例如数据的维度、分布、缺失值和噪声等。不同的数据特征需要使用不同的特征工程方法和算法。
+ - 选择合适的算法：根据问题类型和数据特征，选择合适的机器学习算法。例如，对于分类问题和高维数据，可以考虑使用支持向量机（SVM）或神经网络；对于聚类问题和非线性数据，可以考虑使用K均值聚类或高斯混合模型（GMM）等。
+ - 调整参数和超参数：对于选择的算法，需要适当调整参数和超参数，以达到最佳的预测性能和效果。例如，对于SVM算法，需要选择合适的核函数和正则化参数；对于神经网络算法，需要选择合适的层数、节点数和激活函数等。
+ - 评估和比较算法：最后需要评估和比较不同的算法和模型，以选择最佳的算法和特征工程方法。常用的评估指标包括准确率、召回率、精度、F1值等。同时，需要注意过拟合和欠拟合问题，避免模型复杂度过高或过低。
+
+
+总之，在选择机器学习算法时，需要根据具体的问题类型和数据特征，结合实际情况和经验选择合适的算法和特征工程方法，并进行适当调整和优化，以获得最佳的预测性能和效果。
+
+确定问题类型和分析数据特征看上去很关键。请问你可以列出这两步需要考虑的所有组合，并且为这些组合提供合适的机器学习算法吗
+
+确定问题类型和分析数据特征确实是选择合适的机器学习算法的关键步骤。以下是一些常见的问题类型和数据特征的组合，以及相应的机器学习算法建议：
+
+
+ - 二分类问题和结构化数据：对于二分类问题和结构化数据，可以考虑使用逻辑回归、决策树、随机森林等算法。
+ - 多分类问题和结构化数据：对于多分类问题和结构化数据，可以考虑使用朴素贝叶斯、K近邻、支持向量机（SVM）等算法。
+ - 回归问题和结构化数据：对于回归问题和结构化数据，可以考虑使用线性回归、岭回归、Lasso回归等算法。
+ - 聚类问题和非结构化数据：对于聚类问题和非结构化数据，可以考虑使用K均值聚类、层次聚类、高斯混合模型（GMM）等算法。
+ - 异常检测问题和非结构化数据：对于异常检测问题和非结构化数据，可以考虑使用离群点检测、孤立森林、基于密度的异常检测等算法。
+ - 时序预测问题和序列数据：对于时序预测问题和序列数据，可以考虑使用循环神经网络（RNN）、长短时记忆网络（LSTM）、卷积神经网络（CNN）等算法。
+ - 图像识别问题和图像数据：对于图像识别问题和图像数据，可以考虑使用卷积神经网络（CNN）、深度残差网络（ResNet）、网络中的网络（NiN）等算法。
+ - 自然语言处理问题和文本数据：对于自然语言处理问题和文本数据，可以考虑使用循环神经网络（RNN）、长短时记忆网络（LSTM）、卷积神经网络（CNN）等算法。
+
+
+需要注意的是，这些组合和算法建议仅供参考，实际选择算法需要结合具体情况进行综合考虑和比较。
+
+我想了解风机二分类问题，应该怎么下手，最好提供一些机器学习和深度学习的算法案例
+
+针对风机二分类问题，可以采用以下步骤：
+
+
+ - 数据预处理
+
+
+首先需要对数据进行预处理，包括数据清洗、数据可视化、数据归一化等，以便更好地应用机器学习算法。特别是对于风机的传感器数据，需要对数据进行去噪、异常值处理、缺失值填充等操作。
+
+
+ - 特征提取
+
+
+对于风机数据，可以提取多种特征，包括振动信号、温度、湿度等。特别是针对振动信号，可以提取频域特征、时域特征、小波包能量等特征。
+
+
+ - 机器学习算法
+
+
+针对风机二分类问题，可以采用以下机器学习算法：
+
+
+ - 逻辑回归：适用于二分类问题，可以通过线性分类器进行分类。
+ - 支持向量机（SVM）：适用于处理高维度的特征向量，可以通过核函数进行非线性分类。
+ - 随机森林：适用于处理具有多个特征的数据，可以通过集成多个决策树进行分类。
+ - GBDT：适用于处理非线性数据，可以通过集成多个决策树进行分类。
+
+
+
+ - 深度学习算法
+
+
+除了机器学习算法，深度学习算法也可以应用于风机二分类问题中。以下是一些适用于风机二分类问题的深度学习算法：
+
+
+ - 卷积神经网络（CNN）：适用于图像、信号等数据的分类，可以通过卷积操作提取数据的特征。
+ - 循环神经网络（RNN）：适用于序列数据（如时间序列数据）的分类，可以学习到序列数据中的时间依赖关系。
+ - 长短时记忆网络（LSTM）：适用于处理序列数据的分类，可以记住长时间间隔的依赖关系。
+ - 自编码器（Autoencoder）：可以学习到数据的压缩表示，是进行无监督学习的一种方法。
+
+
+需要注意的是，机器学习算法和深度学习算法的选择需要结合具体问题进行综合考虑和比较，并且需要进行模型的调参和优化，以提高分类的准确性和效率。同时，对于风机数据的预处理和特征提取也是影响分类效果的重要因素。
+
+我对随机深林的算法比较感兴趣，请问您接下来我应该如何进行参数调呢
+
+针对随机森林算法的参数调优，以下是一些常用的方法和技巧：
+
+
+ - n_estimators：这个参数指的是随机森林中决策树的数量。一般来说，n_estimators越大，模型的性能会越好，但同时也会增加模型的计算时间。因此，需要通过交叉验证等方法来确定合适的n_estimators值。
+ - max_depth：这个参数指的是决策树的最大深度。一般来说，设置max_depth可以防止过拟合，但同时也会使模型的泛化能力降低。因此，需要通过交叉验证等方法来确定合适的max_depth值。
+ - min_samples_split：这个参数指的是分裂一个内部节点需要的最小样本数。一般来说，这个值越小，模型会越容易过拟合。因此，需要通过交叉验证等方法来确定合适的min_samples_split值。
+ - min_samples_leaf：这个参数指的是每个叶子节点需要的最小样本数。一般来说，这个值越小，模型会越容易过拟合。因此，需要通过交叉验证等方法来确定合适的min_samples_leaf值。
+ - max_features：这个参数指的是在寻找最佳分割点时，随机选择的特征数量。一般来说，max_features越小，模型会越容易过拟合。因此，需要通过交叉验证等方法来确定合适的max_features值。
+
+
+以上是一些常用的调参方法和技巧，需要注意的是，在调参过程中需要避免过拟合问题，并且需要结合具体问题进行综合考虑和比较。同时，可以采用网格搜索、随机搜索等方法来进行参数搜索和优化。
+
+通过交叉验证等方法来确定合适的n_estimators值是什么意思呢
+
+在随机森林算法中，n_estimators是指随机森林中包含的决策树的数量。n_estimators越大，模型的性能通常会更好，但同时也会增加模型的计算时间和存储空间。因此，需要通过交叉验证等方法来确定合适的n_estimators值，以达到平衡模型性能和效率的目的。
+
+交叉验证是一种常用的机器学习方法，可以将数据集划分为训练集和验证集，并重复进行多次，以评估模型的性能和泛化能力。在确定n_estimators值时，可以采用交叉验证来评估不同的n_estimators值对模型性能的影响。具体来说，可以将数据集划分为训练集和验证集，然后针对不同的n_estimators值训练多个模型，并在验证集上进行评估，得到不同n_estimators值下的模型性能指标。然后，可以比较不同n_estimators值的性能指标，选择最优的n_estimators值作为最终模型的参数。
+
+需要注意的是，交叉验证的结果具有一定的随机性，因此需要进行多次交叉验证，并取平均值来获得更可靠的结果。同时，为了避免过拟合，还需要在每次交叉验证中随机选择训练集和验证集，并对模型进行平均化处理，以提高模型的泛化能力。
+
+还不是很懂，看上去参数的选择都需要设计到交叉验证的方法，请问这种方法运行开销是怎么样的呢
+
+是的，参数选择通常需要采用交叉验证等方法来评估不同参数值对模型性能的影响。交叉验证方法的运行开销取决于数据集的大小和交叉验证的折数等因素。
+
+交叉验证方法的一般流程是将数据集划分为k个互不重叠的子集，然后选择其中一个子集作为验证集，剩余的k-1个子集作为训练集，进行模型训练和测试，并记录性能指标。然后，循环k次，每次选择不同的验证集，并进行模型训练和测试，最后对性能指标进行平均或求和，得到最终的性能指标。因此，交叉验证的运行开销取决于数据集的大小和交叉验证的折数。通常来说，数据集越大，交叉验证的开销就越大。
+
+在随机森林算法中，交叉验证通常用于选择合适的参数值，例如n_estimators、max_depth、min_samples_split等。具体来说，可以采用网格搜索或随机搜索等方法，在不同的参数范围内进行搜索，并通过交叉验证方法评估不同参数值对模型性能的影响。搜索过程的开销取决于参数范围的大小和搜索方法的复杂度等因素。
+
+总的来说，交叉验证方法的运行开销较大，但可以有效评估模型的性能和泛化能力，提高模型的准确性和可靠性。在实际应用中，需要根据具体情况选择合适的交叉验证方法和参数搜索方法，以达到平衡模型性能和效率的目的。
+
+看上去，参数搜素可以减少运行开销，请问您可以提供具体的参数搜索的方法吗
+
+是的，参数搜索可以通过精心设计的搜索策略来减少运行开销，并找到最优的参数组合。以下是几种常用的参数搜索方法：
+
+
+ - 网格搜索(Grid Search)：网格搜索是一种基于穷举搜索的方法，通过指定参数的范围和步长，对每个参数进行排列组合，然后在所有参数组合中选择性能最好的一组参数。这种方法简单直观，但搜索空间很大时计算开销很大。
+ - 随机搜索(Random Search)：随机搜索是一种基于随机采样的方法，通过指定参数范围和采样分布，随机采样若干次，然后在所有采样中选择性能最好的一组参数。这种方法计算开销较小，但搜索效率可能较低，因为搜索过程是基于随机采样的。
+ - 贝叶斯优化(Bayesian Optimization)：贝叶斯优化是一种基于高斯过程的方法，通过建立参数空间的概率模型，不断更新模型的先验概率分布，然后根据模型的预测结果选择下一个参数组合，直到找到性能最好的一组参数。这种方法计算开销较大，但搜索效率较高，在高维参数空间中表现良好。
+ - 梯度提升调参(Gradient Boosting Tuning)：梯度提升调参是一种基于梯度提升决策树算法的方法，通过不断迭代模型，对每个参数进行微调，然后根据模型的性能指标进行选择，直到找到性能最好的一组参数。这种方法计算开销较大，但搜索效率较高，并且可以避免过度拟合。
+
+
+需要注意的是，不同的参数搜索方法适用于不同的场景，需要根据具体情况进行选择。同时，为了进一步减少运行开销，可以采用并行计算、分布式计算等方法，加速参数搜索的过程。
+
+请问如何选择最优的搜索方法？
+
+选择最优的搜索方法需要考虑多个因素，包括搜索空间大小、搜索效率、搜索准确性、计算资源等。以下是几个选择最优搜索方法的建议：
+
+
+ - 首先需要根据问题的特性和参数搜索空间的大小来选择搜索方法。如果搜索空间较小，可以考虑网格搜索或随机搜索；如果搜索空间较大，可以考虑贝叶斯优化或梯度提升调参等方法。
+ - 其次需要考虑搜索效率和搜索准确性的平衡。随机搜索和贝叶斯优化等方法可以在较短时间内找到较好的参数组合，但搜索结果可能并不是全局最优解；而网格搜索和梯度提升调参等方法可以较精确地找到全局最优解，但需要较长的时间。
+ - 另外需要考虑计算资源的限制。如果计算资源有限，可以选择随机搜索等方法，通过限制搜索次数或时间来控制计算开销；如果计算资源充足，可以选择网格搜索或贝叶斯优化等方法，以获得更准确的搜索结果。
+ - 最后，需要根据具体情况进行实验和评估，选择最优的搜索方法。可以通过交叉验证等方法，评估不同搜索方法的性能和泛化能力，选择最优的搜索方法并得到最优的参数组合。
+
+
+需要注意的是，选择最优的搜索方法并不是一件容易的事情，需要综合考虑多个因素。同时，搜索方法的选择并不是唯一的，可以根据实际情况进行调整和优化。
+
+选择了合适的参数之后，一般怎么进行模型训练
+
+选择了合适的参数之后，可以使用所选参数来训练模型。以下是一般的模型训练流程：
+
+
+ - 数据准备：首先需要准备训练数据和测试数据。训练数据用于模型的训练，测试数据用于模型的验证和评估。可以使用交叉验证等技术来进一步优化数据准备过程。
+ - 模型定义：根据所选的算法和参数，定义模型的结构和参数设置。可以使用现有的深度学习框架（如TensorFlow、PyTorch等）来定义模型。
+ - 损失函数定义：根据具体问题，选择相应的损失函数（如交叉熵、均方误差等）来描述模型的性能指标。
+ - 模型训练：使用训练数据来训练模型。训练过程中，模型根据损失函数的反馈进行参数更新，不断优化模型的性能指标。
+ - 模型验证：使用测试数据来验证模型的性能。验证过程中，可以计算模型的准确率、精度、召回率等指标，评估模型的性能和泛化能力。
+ - 模型调整：根据验证结果，调整模型的参数设置和结构，优化模型的性能。可以多次进行模型训练和验证，直到获得满意的结果。
+ - 模型保存：保存训练好的模型，方便后续的模型预测和应用。
+
+
+需要注意的是，模型训练过程中需要进行参数初始化、梯度计算、反向传播、优化器选择等操作。同时，为了防止过拟合，需要使用正则化技术、数据增强等方法进行模型调整和优化。
+
+看上去损失函数很重要，在随机深林的算法中，Ibanez是怎么定义这个损失函数的呢
+
+Ibanez提出的随机森林算法中，损失函数是构建随机森林模型的一个重要组成部分，它被用来度量模型预测结果与真实标签之间的差距。Ibanez使用的损失函数是分类问题中的交叉熵损失函数，它的定义如下：
+
+\[H(p,q) = - \sum_{i=1}^m p_i \log q_i\]
+
+其中，$p_i$表示真实标签的概率分布，$q_i$表示模型预测的概率分布。交叉熵损失函数可以度量模型预测结果与真实标签之间的差距，是分类问题中常用的损失函数之一。当模型的预测结果与真实标签完全一致时，交叉熵损失函数取最小值0；当模型的预测结果与真实标签完全不一致时，交叉熵损失函数取最大值。
+
+在随机森林算法中，对于每个决策树，都会使用交叉熵损失函数来度量分裂节点的优劣，选择最优的特征和阈值进行分裂。在多棵决策树的集成中，随机森林使用投票的方式来进行分类预测，将每个决策树的预测结果进行投票，得到最终的分类结果。在投票过程中，每个决策树的权重是由交叉熵损失函数来确定的，交叉熵损失函数越小的决策树，权重越大，对最终的分类结果影响越大。
+
+tell me more
+
+除了交叉熵损失函数，随机森林算法中还可以使用其他的损失函数来度量模型的性能和预测结果与真实标签之间的差距。常见的损失函数包括：
+
+
+ - 均方误差（Mean Squared Error，MSE）：均方误差是回归问题中常用的损失函数，它度量模型预测结果与真实标签之间的平均差距。均方误差越小，模型的预测结果越接近真实标签。在随机森林算法中，可以使用均方误差来选择最优的特征和阈值进行分裂。
+ - 绝对误差（Mean Absolute Error，MAE）：绝对误差是回归问题中另一种常用的损失函数，它度量模型预测结果与真实标签之间的平均绝对差距。与均方误差不同，绝对误差对误差的大小不敏感，更加稳健。在随机森林算法中，可以使用绝对误差来选择最优的特征和阈值进行分裂。
+ - 基尼不纯度（Gini Impurity）：基尼不纯度是分类问题中常用的损失函数之一，它度量随机选择一个样本，它被错误分类为其它类别的概率。基尼不纯度越小，表示样本的纯度越高，模型的分类效果越好。在随机森林算法中，可以使用基尼不纯度来选择最优的特征和阈值进行分裂。
+
+
+随机森林算法中的损失函数选择依赖于具体的问题和数据集，不同的损失函数可能导致不同的模型性能和预测结果。因此，在模型训练过程中，需要根据具体问题和数据集选择合适的损失函数，对模型进行优化和调整。
+
+模型的性能指标如何选取
+
+模型的性能指标应该根据具体的问题和任务进行选择。不同的问题和任务可能需要不同的性能指标，因此需要根据具体情况进行选择。
+
+以下是一些常见的模型性能指标及其适用范围：
+
+
+ - 准确率（Accuracy）：准确率是最常用的模型性能指标之一，它度量模型正确分类的样本占总样本数的比例。准确率适用于类别平衡的问题，但对于类别不平衡的问题，准确率可能会忽略掉少数类别，因此需要使用其他指标来衡量模型性能。
+ - 精度（Precision）：精度是指在所有被预测为正例的样本中，实际为正例的样本占比。精度适用于关注预测结果为正例的问题，如垃圾邮件识别等。
+ - 召回率（Recall）：召回率是指在所有实际为正例的样本中，被预测为正例的样本占比。召回率适用于关注所有正例被正确预测的问题，如疾病诊断等。
+ - F1值（F1 Score）：F1值是精度和召回率的调和平均数，它综合考虑了精度和召回率的性能，适用于关注精度和召回率的平衡问题。
+ - ROC曲线和AUC值（ROC curve and AUC）：ROC曲线展示了模型预测结果的真正率和假正率之间的关系，AUC值是ROC曲线下的面积，表示模型分类效果的综合性能，适用于关注模型分类效果全面性的问题。
+ - 平均绝对误差（Mean Absolute Error，MAE）：MAE是回归问题中常用的性能指标，它度量模型预测结果与真实标签之间的平均绝对差距，适用于回归问题的性能评估。
+
+
+在选择模型性能指标时，需要根据具体问题和任务选择合适的指标，并综合考虑模型性能和应用场景的需求，进行权衡和选择.
+
+在随机深林中，如何构建性能指标，根据损失函数更新参数呢
+
+在随机深林中，通常使用交叉熵损失函数作为性能指标来度量模型的预测性能。对于每个决策树，都会使用交叉熵损失函数来度量分裂节点的优劣，选择最优的特征和阈值进行分裂。在多棵决策树的集成中，随机深林使用投票的方式来进行分类预测，将每个决策树的预测结果进行投票，得到最终的分类结果。
+
+在模型训练过程中，随机深林使用梯度提升（Gradient Boosting）算法来更新模型参数。梯度提升算法通过迭代的方式，将每个决策树的预测结果与真实标签之间的误差作为损失函数，更新模型参数，使得模型能够更好地拟合训练数据。
+
+具体来说，梯度提升算法通过以下步骤来更新模型参数：
+
+
+ - 初始化模型参数。随机深林通常使用浅层决策树作为基分类器，对于每个决策树，需要确定其最大深度、节点分裂的最小样本数等参数。
+ - 对于每个决策树，计算其预测结果与真实标签之间的误差。随机深林使用交叉熵损失函数来度量分类预测的误差，使用均方误差（MSE）来度量回归预测的误差。
+ - 根据误差计算每个样本的梯度。对于分类问题，样本的梯度是预测结果与真实标签之间的差值，对于回归问题，样本的梯度是预测结果与真实标签之间的差值。
+ - 使用梯度下降算法更新模型参数。随机深林使用梯度提升算法来更新模型参数，将每个决策树的预测结果与真实标签之间的误差作为损失函数，通过梯度下降算法来更新模型参数。
+ - 重复步骤2-4，直到达到指定的迭代次数或达到收敛条件为止。
+
+
+在随机深林中，由于每个决策树都是独立训练的，因此可以使用并行化的方式来加速模型训练，提高模型的性能和效率。
+
+Tell me more.
+
+随机深林(Random Forest)是一种集成学习算法，它通过组合多个决策树来进行分类和回归预测。随机深林中的每个决策树都是独立训练的，每棵树都是通过随机选择特征和样本进行训练的，从而增强了模型的泛化能力，避免了过拟合问题。
+
+随机深林的核心思想是基于袋装法（Bagging）和随机特征选择（Random Feature Selection）的组合。具体来说，随机深林采用以下步骤来构建模型：
+
+
+ - 从训练数据集中使用有放回抽样的方式，随机选择一定数量的样本，构建一组新的训练集。
+ - 对于每个新的训练集，使用随机特征选择的方式，随机选择一定数量的特征进行训练，构建一棵决策树。
+ - 重复步骤1和步骤2，构建多棵决策树，形成随机深林。
+ - 对于分类问题，随机深林使用投票的方式来进行分类预测，将每个决策树的预测结果进行投票，得到最终的分类结果；对于回归问题，随机深林使用平均值的方式来进行回归预测，将每个决策树的预测结果进行平均，得到最终的回归结果。
+
+
+与单棵决策树相比，随机深林具有以下优点：
+
+
+ - 随机深林能够有效地避免过拟合问题，通过组合多个决策树进行预测，能够降低模型的方差，提高模型的泛化能力。
+ - 随机深林能够处理高维数据和噪声数据，随机特征选择的方式可以有效地减少冗余特征和噪声特征的影响，从而提高模型的准确性。
+ - 随机深林能够并行化处理，每棵决策树都是独立训练的，可以使用多线程或分布式计算的方式加速模型训练，提高模型的效率。
+
+
+总之，随机深林是一种高效、准确、稳定的集成学习算法，被广泛应用于分类、回归、特征选择等领域。
+
+更新得到新的参数之后，怎么确定自己的模型已经是最优的呢
+
+在随机深林中，确定模型是否已经达到最优状态通常需要进行模型评估。模型评估可以通过使用交叉验证方法来进行，常见的交叉验证方法包括K折交叉验证和留一交叉验证。
+
+K折交叉验证是指将原始数据集分成K份，每次选取其中的K-1份作为训练集，剩余的1份作为验证集，重复K次，得到K个模型的预测结果，最终将K个模型的预测结果进行平均或投票，得到最终的模型预测结果。
+
+留一交叉验证是指将原始数据集中的每个样本都作为验证集，其余样本作为训练集，重复N次，得到N个模型的预测结果，最终将N个模型的预测结果进行平均或投票，得到最终的模型预测结果。
+
+在交叉验证过程中，可以使用常见的评估指标来评估模型的性能，如准确率、精确率、召回率、F1值等。通常情况下，选择具有最高评估指标的模型作为最优模型，但也可以根据具体应用场景和需求进行选择。
+
+此外，还可以使用网格搜索(Grid Search)等方法来进行模型调优，通过在模型参数空间中搜索，找到最优的模型参数组合，从而提高模型的性能和泛化能力。
+
+总之，在随机深林中，确定最优模型需要进行模型评估和调优，根据具体应用场景和需求进行选择。
+
+请问如何提高模型的泛化能力？
+
+在机器学习中，提高模型的泛化能力是非常重要的，因为泛化能力是指模型在未见过的数据上的表现能力，是衡量模型优劣的重要指标之一。以下是提高模型泛化能力的一些方法：
+
+
+ - 增加训练数据量：增加训练数据量可以帮助模型更好地学习数据的特征，从而提高模型的泛化能力。
+ - 数据预处理：数据预处理包括数据清洗、特征选择、特征缩放等，可以帮助模型更好地学习数据的特征，从而提高模型的泛化能力。
+ - 减少模型复杂度：过于复杂的模型容易过拟合，可以通过减少模型的复杂度来提高模型的泛化能力，如降低模型的层数、节点数等。
+ - 正则化：正则化是通过增加模型复杂度惩罚项或限制模型参数的范围来防止过拟合的一种方法，可以提高模型的泛化能力。
+ - 集成学习：集成学习是通过组合多个模型来进行预测，可以有效地降低模型的方差，提高模型的泛化能力。
+ - Dropout技术：Dropout技术是一种正则化方法，通过在模型训练时随机关闭一定比例的神经元，可以有效地防止模型过拟合，提高模型的泛化能力。
+ - 交叉验证：交叉验证是一种通过将数据集划分为多个子集来评估模型性能的方法，可以帮助防止模型过拟合，提高模型的泛化能力。
+
+
+总之，提高模型的泛化能力需要采取多种方法，包括增加训练数据量、数据预处理、减少模型复杂度、正则化、集成学习、Dropout技术、交叉验证等，根据具体情况选择合适的方法可以有效地提高模型的泛化能力。
+
+评估模型泛化能力，有什么具体的指标吗
+
+评估模型泛化能力的常用指标包括：
+
+
+ - 准确率(Accuracy)：准确率指分类模型中正确分类的样本数占总样本数的比例，是最常用的指标之一。
+ - 精确率(Precision)：精确率指被模型预测为正类的样本中，真正为正类的样本比例。
+ - 召回率(Recall)：召回率指真正为正类的样本中，被模型预测为正类的比例。
+ - F1值(F1-score)：F1值是精确率和召回率的调和平均数，综合考虑了二者的表现。
+ - ROC曲线和AUC值：ROC曲线是以假正率(FPR)为横坐标，真正率(TPR)为纵坐标画出的曲线，用于评估二分类模型的性能。AUC值是ROC曲线下的面积，可以用于比较不同模型的性能。
+ - R2值：R2值是用于评估回归模型的性能指标，表示模型预测值与真实值之间的相关性，取值范围为0~1，越接近1表示模型拟合效果越好。
+ - 平均绝对误差(MAE)和均方误差(MSE)：MAE和MSE是用于评估回归模型的常用指标，分别表示预测值与真实值之间的平均绝对误差和平均平方误差。
+
+
+总之，评估模型泛化能力需要根据具体的应用场景选择合适的指标，常用的指标包括准确率、精确率、召回率、F1值、ROC曲线和AUC值、R2值、MAE和MSE等
+
+我有点混淆了，请问性能指标和泛化能力指标的差别
+
+性能指标和泛化能力指标都是用于评估机器学习模型的指标，但它们的侧重点不同。
+
+性能指标主要用于评估模型在训练集上的表现，是衡量模型是否能够很好地拟合训练数据的指标。常用的性能指标包括模型的准确率、精确率、召回率、F1值、均方误差(MSE)、平均绝对误差(MAE)等。性能指标可以用于评估模型训练的效果和调整模型参数。
+
+泛化能力指标主要用于评估模型在未知数据上的表现，即模型是否能够很好地适应新数据。常用的泛化能力指标包括模型的交叉验证结果、测试集上的准确率、AUC值、R2值等。泛化能力指标可以用于评估模型的泛化能力和避免模型的过拟合。
+
+综上所述，性能指标和泛化能力指标都是用于评估机器学习模型的指标，但是它们的侧重点不同，性能指标主要用于评估模型在训练集上的表现，而泛化能力指标主要用于评估模型在未知数据上的表现。
+
+如何在模型训练中平衡性能指标和泛化能力指标？
+
+在模型训练中平衡性能指标和泛化能力指标是一个非常重要的问题。如果只关注性能指标而忽略泛化能力指标，可能会导致模型过拟合，而如果只关注泛化能力指标而忽略性能指标，可能会导致模型欠拟合。以下是一些平衡性能指标和泛化能力指标的方法：
+
+
+ - 数据预处理：数据预处理可以帮助模型更好地学习数据的特征，从而提高模型的性能和泛化能力。例如，可以进行特征选择、特征缩放、数据清洗等操作。
+ - 模型选择和调参：选择合适的模型和调整模型参数可以平衡性能指标和泛化能力指标。需要根据实际情况选择合适的模型和调整超参数，避免模型过拟合或欠拟合。
+ - 正则化技术：正则化技术可以帮助平衡性能指标和泛化能力指标。例如，L1正则化和L2正则化可以控制模型的复杂度，避免模型过拟合。
+ - 交叉验证：交叉验证可以帮助评估模型的泛化能力，避免模型在训练集上过拟合。可以使用K折交叉验证或留一交叉验证等方法。
+ - 集成学习：集成学习可以通过组合多个模型的预测结果来提高模型的性能和泛化能力。例如，可以使用Bagging、Boosting、随机森林等方法。
+
+
+综上所述，平衡性能指标和泛化能力指标需要采取一系列方法，包括数据预处理、模型选择和调参、正则化技术、交叉验证和集成学习等。需要根据实际情况选择合适的方法，从而平衡性能指标和泛化能力指标。
+
+正则化技术看上去很重要，可以提供更详细的数学定义吗
+
+正则化是一种常用的降低模型复杂度的技术，它通过在模型的损失函数中添加一个正则项来惩罚模型的复杂度，从而避免模型过拟合。
+
+在线性回归中，正则化通常采用L1正则化和L2正则化。L1正则化将模型的损失函数定义为：
+
+\[\min_{\theta}\frac{1}{2m}\sum_{i=1}^{m}(h_{\theta}(x^{(i)})-y^{(i)})^2+\lambda\sum_{j=1}^{n}|\theta_j|\]
+
+其中，$\theta$是模型的参数，$h_{\theta}(x^{(i)})$是模型对第$i$个样本$x^{(i)}$的预测值，$y^{(i)}$是第$i$个样本的真实值，$m$是样本数，$n$是特征数，$\lambda$是控制正则化强度的超参数。
+
+L2正则化将模型的损失函数定义为：
+
+\[\min_{\theta}\frac{1}{2m}\sum_{i=1}^{m}(h_{\theta}(x^{(i)})-y^{(i)})^2+\lambda\sum_{j=1}^{n}\theta_j^2\]
+
+L1正则化和L2正则化的区别在于正则项的形式不同。L1正则化的正则项是所有参数的绝对值之和，它倾向于将一些参数压缩到0，从而产生稀疏性，可以用于特征选择和模型压缩；而L2正则化的正则项是所有参数的平方和，它倾向于将所有参数都缩小，从而产生平滑性。
+
+在深度学习中，正则化也是一种常用的技术。例如，Dropout正则化可以随机地将一些神经元输出置为0，从而减少了神经元之间的依赖性，避免模型过拟合。Batch Normalization正则化可以通过对每个批次的输入数据进行标准化，从而减少了模型对输入数据的依赖性，提高了模型的泛化能力。
+
+综上所述，正则化是一种常用的降低模型复杂度的技术，可以通过在模型的损失函数中添加一个正则项来惩罚模型的复杂度，从而避免模型过拟合。常用的正则化技术包括L1正则化、L2正则化、Dropout正则化和Batch Normalization正则化等。
+
+如何部署到实际的应用中呢
+
+部署机器学习模型到实际的应用中需要考虑多个方面，包括模型选择、数据预处理、模型训练、模型评估、模型部署、性能优化和安全性等问题。以下是一些常用的部署机器学习模型的方法：
+
+
+ - 模型选择：需要根据实际情况选择合适的模型，并进行模型训练和评估。可以使用开源的机器学习库，如Scikit-learn、TensorFlow、PyTorch等。
+ - 数据预处理：需要对输入数据进行预处理，包括数据清洗、特征提取、特征缩放等操作。可以使用Pandas、NumPy等库进行数据处理。
+ - 模型训练和评估：需要进行模型训练和评估，选择合适的算法、超参数和评估指标。可以使用交叉验证、网格搜索等技术进行模型优化。
+ - 模型部署：需要将训练好的模型部署到实际的应用中。可以使用各种部署技术，如Docker、Kubernetes等。
+ - 性能优化：需要对模型进行性能优化，包括模型压缩、量化、加速等操作。可以使用TensorRT、TensorFlow Lite等库进行性能优化。
+ - 安全性：需要保证模型的安全性，包括数据隐私、模型盗用等问题。可以使用加密、数据脱敏、模型水印等技术保证模型的安全性。
+
+
+综上所述，部署机器学习模型到实际的应用中需要考虑多个方面，包括模型选择、数据预处理、模型训练、模型评估、模型部署、性能优化和安全性等问题。需要根据实际情况选择合适的技术和方法，从而实现高性能、高可靠性和高安全性的部署。
+
+需要将训练好的模型部署到实际的应用中。可以使用各种部署技术，如Docker、Kubernetes等。请问可以详细一点吗
+
+当需要将训练好的机器学习模型部署到实际的应用中时，通常会选择使用一些容器化技术，如Docker和Kubernetes。这些技术可以帮助开发人员更轻松地管理和部署应用程序和服务，并提供一些额外的好处，例如可扩展性、安全性和可靠性等。
+
+下面是一些常用的容器化技术和部署方法：
+
+
+ - Docker：Docker是一种流行的开源容器化平台，可以将应用程序和服务打包成容器，从而实现快速、可重复和可移植的部署。可以使用Dockerfile文件定义容器镜像，然后使用Docker命令构建和运行容器。
+ - Kubernetes：Kubernetes是一个开源的容器编排平台，可以管理容器化应用程序和服务的部署、扩展、升级和滚动更新等操作。可以使用Kubernetes的配置文件定义应用程序和服务的部署和管理。
+ - 容器编排工具：除了Kubernetes之外，还有一些其他的容器编排工具，如Docker Compose、Apache Mesos、HashiCorp Nomad等。这些工具可以帮助开发人员更轻松地管理和部署多个容器化应用程序和服务。
+ - 云计算平台：云计算平台，如AWS、Azure、GCP等，提供了各种容器化服务和工具，可以帮助开发人员更轻松地部署和管理容器化应用程序和服务。
+
+
+综上所述，将训练好的机器学习模型部署到实际的应用中，可以使用容器化技术，如Docker和Kubernetes等。这些技术可以帮助开发人员更轻松地管理和部署应用程序和服务，并提供一些额外的好处，例如可扩展性、安全性和可靠性等。需要根据实际情况选择合适的技术和方法，从而实现高性能、高可靠性和高安全性的部署。
+
+可以把所有的基于机器学习的风机轴承健康监测评估的步骤列一下吗
+
+基于机器学习的风机轴承健康监测评估通常包括以下步骤：
+
+
+ - 数据收集：收集与风机轴承相关的传感器数据，例如振动、温度、压力等。
+ - 数据预处理：对收集到的数据进行预处理，包括数据清洗、去噪、滤波、降采样等操作，以提高数据质量和降低数据维度。
+ - 特征提取：从预处理后的数据中提取重要的特征，例如时域特征、频域特征、小波特征等。可以使用相关统计学方法、信号处理技术和机器学习算法进行特征提取。
+ - 特征选择：从提取的特征中选择最具有代表性和预测能力的特征，以减少特征维度和提高模型性能。可以使用相关统计学方法、机器学习算法和特征重要性评估等技术进行特征选择。
+ - 模型训练：使用机器学习算法训练模型，例如支持向量机、随机森林、神经网络等。可以使用交叉验证、网格搜索等技术进行模型选择和优化。
+ - 模型评估：对训练好的模型进行评估，例如精度、召回率、F1分数等。可以使用混淆矩阵、ROC曲线、AUC值等指标进行模型评估。
+ - 模型部署：将训练好的模型部署到实际的应用中，例如使用Docker、Kubernetes等技术进行容器化部署。
+ - 实时监测：在实际使用中，对风机轴承进行实时监测，获取新的传感器数据，进行数据预处理、特征提取、特征选择和模型预测等操作，以实现实时健康监测和预测。
+
+
+综上所述，基于机器学习的风机轴承健康监测评估通常包括数据收集、数据预处理、特征提取、特征选择、模型训练、模型评估、模型部署和实时监测等步骤。需要根据实际情况选择合适的技术和方法，从而实现高性能、高可靠性和高安全性的风机轴承健康监测和预测。
+
+有具体别人做过的案例可以学习吗，比如说发布的文章或者博客
+
+是的，有很多机器学习的案例可以学习，以下是一些基于机器学习的风机轴承健康监测评估的案例，供您参考：
+
+
+ - “A Deep Convolutional Neural Network Based Method for Fault Diagnosis of Wind Turbine Bearings”（基于深度卷积神经网络的风力涡轮机轴承故障诊断方法）：该论文提出了一种基于深度卷积神经网络的轴承故障诊断方法，在实验中取得了良好的效果。论文链接：https://ieeexplore.ieee.org/document/8353225
+ - “Wind turbine gearbox fault diagnosis based on PCA and SVM“（基于PCA和SVM算法的风力涡轮机齿轮箱故障诊断）：该论文提出了一种基于主成分分析和支持向量机算法的齿轮箱故障诊断方法，在实验中取得了良好的效果。论文链接：https://www.sciencedirect.com/science/article/pii/S1876610213002019
+ - “Wind turbine fault detection using machine learning algorithms“（利用机器学习算法进行风力涡轮机故障检测）：该论文提出了一种基于K近邻算法和支持向量机算法的风力涡轮机故障检测方法，在实验中取得了良好的效果。论文链接：https://www.sciencedirect.com/science/article/pii/S0378779616302521
+ - “Wind Turbine Fault Detection and Diagnosis Based on Machine Learning Techniques“（基于机器学习技术的风力涡轮机故障检测和诊断）：该博客介绍了一种基于机器学习技术的风力涡轮机故障检测和诊断方法，包括数据预处理、特征提取、特征选择、模型训练和评估等步骤。博客链接：https://towardsdatascience.com/wind-turbine-fault-detection-and-diagnosis-based-on-machine-learning-techniques-52c0b4f4b4e8
+
+
+以上是一些基于机器学习的风机轴承健康监测评估的案例，希望对您有所帮助。
+
+你提供的链接全都是错误的
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/dd/486be81de2456668b05959dd40bbc9d824be82f68b42b3aabcb329b3cf6498 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/dd/486be81de2456668b05959dd40bbc9d824be82f68b42b3aabcb329b3cf6498
new file mode 100644
index 0000000000..80c4e3565e
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/dd/486be81de2456668b05959dd40bbc9d824be82f68b42b3aabcb329b3cf6498
@@ -0,0 +1,2 @@
+I"介绍了Allure的安装，环境配置；Allure命令，配置pytest.ini文件，利用allure工具生成html报告；最后，讲了Allure的应用实例。
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/dd/8f09a12c740b832964e70777ff42929f7dc09119bf0f81be701f3a9fdf8d0d b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/dd/8f09a12c740b832964e70777ff42929f7dc09119bf0f81be701f3a9fdf8d0d
new file mode 100644
index 0000000000..3776c51ae9
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/dd/8f09a12c740b832964e70777ff42929f7dc09119bf0f81be701f3a9fdf8d0d
@@ -0,0 +1,44 @@
+I"2
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/e1/31f876cd92c281f2badda6be08ddd39a7ec0e7772532bcdac86388d303fbba b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/e1/31f876cd92c281f2badda6be08ddd39a7ec0e7772532bcdac86388d303fbba
new file mode 100644
index 0000000000..35b6ba2983
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/e1/31f876cd92c281f2badda6be08ddd39a7ec0e7772532bcdac86388d303fbba
@@ -0,0 +1,18 @@
+I"T
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/e2/a06b550f880b5f003d487c29ea2f8fa57a3ccd444264c1bd5777aa04501040 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/e2/a06b550f880b5f003d487c29ea2f8fa57a3ccd444264c1bd5777aa04501040
new file mode 100644
index 0000000000..1977affca1
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/e2/a06b550f880b5f003d487c29ea2f8fa57a3ccd444264c1bd5777aa04501040
@@ -0,0 +1,23 @@
+I"j
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/e3/5197203d6200fee8b0e241535efac12ce0301761f47d6d1dcfff779d24b46f b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/e3/5197203d6200fee8b0e241535efac12ce0301761f47d6d1dcfff779d24b46f
new file mode 100644
index 0000000000..9d27822a95
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/e3/5197203d6200fee8b0e241535efac12ce0301761f47d6d1dcfff779d24b46f
@@ -0,0 +1,2 @@
+I"q字符串是指由零个或多个字符组成的有限序列，是编程语言中最常用的数据类型之一。字符串是由单引号或双引号括起来的任意文本，比如’abc’，”xyz”等等。请注意，’‘或”“本身只是一种表示方式，不是字符串的一部分，因此，字符串’abc’只有a，b，c这3个字符。
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/e3/b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/e3/b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
new file mode 100644
index 0000000000..e135808ffe
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/e3/b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
@@ -0,0 +1,2 @@
+I"
+:EF
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/e5/b61562c4bec5675f8d2d17bfe8270831f4aeae3d306ca2b583a5caa9ef0b6c b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/e5/b61562c4bec5675f8d2d17bfe8270831f4aeae3d306ca2b583a5caa9ef0b6c
new file mode 100644
index 0000000000..5cc45fb977
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/e5/b61562c4bec5675f8d2d17bfe8270831f4aeae3d306ca2b583a5caa9ef0b6c
@@ -0,0 +1,2 @@
+I"主要包括requests库的安装，接口用例编写，requests库的使用，requests库的返回值介绍，requests库的用例编写以及Requests的封装等等。
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/e6/0d90ec63542ec055b8f79c8be81c0773538753c4a4726392242ce3b09bde4e b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/e6/0d90ec63542ec055b8f79c8be81c0773538753c4a4726392242ce3b09bde4e
new file mode 100644
index 0000000000..ed2ac2ca88
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/e6/0d90ec63542ec055b8f79c8be81c0773538753c4a4726392242ce3b09bde4e
@@ -0,0 +1,2 @@
+I"F断言是一种判断程序执行结果是否符合预期的方法，可以帮助我们定位错误原因，是自动化测试的灵魂。本文主要介绍pytest中使用assert进行断言，断言的应用和封装。断言结果的验证，包括状态码、返回信息验证，以及数据库断言结果验证。
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/e7/4d8a7ed08d57597132f9bb6ad381a9d133693e9709174c1cda2243f85a3ee0 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/e7/4d8a7ed08d57597132f9bb6ad381a9d133693e9709174c1cda2243f85a3ee0
new file mode 100644
index 0000000000..c359fc8131
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/e7/4d8a7ed08d57597132f9bb6ad381a9d133693e9709174c1cda2243f85a3ee0
@@ -0,0 +1,2 @@
+I"介绍python中引用与对象，可变数据类型与不可变数据类型，值传递，变量和内存管理等方面的内容
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/e7/961aab13cec6f759467edbb24cc556136af4826b5fefbb84d76680c7784c12 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/e7/961aab13cec6f759467edbb24cc556136af4826b5fefbb84d76680c7784c12
new file mode 100644
index 0000000000..2e06c1c1d7
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/e7/961aab13cec6f759467edbb24cc556136af4826b5fefbb84d76680c7784c12
@@ -0,0 +1,71 @@
+I"\ 软件包管理是任何Linux发行版的重要功能之一，可简化Linux应用程序的安装和维护方法。不同的Linux发行版采用不同的方法来打包和分发软件。
+
+但是对于某些切换到不同的Linux发行版来的人说，相同的功能有时反而会成为绊脚石。他们发现很难理解新的软件包管理器，并且无法安装应用程序。为了使用多个程序包管理器解决此类问题，Linux发行版已经发展出了通用的包管理系统，如Snap、Appimage和Flatpak。
+
+什么是Flatpak？
+
+Flatpak是一个通用的软件包管理系统，用于在任何Linux发行版上构建和分发应用程序。您无需学习特定于发行版的软件包管理器即可安装Flatpak应用。它为所有Linux发行版提供了一个命令行实用程序，以下载，安装和更新该应用程序。
+
+什么是Flathub？
+
+Flathub 是一个包含了几乎所有 flatpak 应用的仓库，可为Linux系统提供大量的应用程序和游戏。它还为想要构建，分发和定期更新应用程序的开发人员提供了构建服务。
+
+设置Flatpak
+
+# 安装flatpak
+sudo apt install flatpak
+# 安装图形化界面，但是我没有安装成功
+sudo apt install gnome-software-plugin-flatpak
+# 添加flathub仓库
+flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
+
+
+从Flathub商店下载和安装Flatpak应用程序
+
+安装和运行OBS
+
+从Flathub商店下载
+
+
+ - 打开flathub网站，搜索OBS，点击安装
+ - 这时候，com.obsproject.Studio.flatpakref会被安装到/home/hugo/下载路径下
+ - 安装flatpakref后缀文件
+
+
+ - 安装完成后，可以查找到OBS
+
+
+ - 运行OBS
+
+ -
+
flatpak run <app id>
+
+
+
+
+
+
+搜索安装
+
+flatpak search obs
+flatpak install <app id>
+flatpak run <app id>
+
+
+查看安装结果
+
+flatpak list
+
+
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/e8/6ec102b9044b4c9b243c33489b4e4f2ad40a01a52a7e093a0834226ea21f3e b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/e8/6ec102b9044b4c9b243c33489b4e4f2ad40a01a52a7e093a0834226ea21f3e
new file mode 100644
index 0000000000..5f7193c599
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/e8/6ec102b9044b4c9b243c33489b4e4f2ad40a01a52a7e093a0834226ea21f3e
@@ -0,0 +1,166 @@
+I"单元测试
+
+单元测试的英文是Unit Testing,特指在一个分隔的代码单元中进行的测试，一个单元可以是整个模块，一个单独的类或者函数。
+
+编写单元测试的代码可以帮助我们在早期快速找到bug，以较小的代价在早期找到bug。
+
+被测函数
+
+我们先编写一个函数，判断输入数据是否是素数，并且可以判断距离这个数最近的素数。
+
+.
+# Author: chenjunllin
+# Date: 2022-03-16
+# File: is_prime.py
+
+
+def is_prime(number):
+ """如果是质数，返回为True"""
+ for element in range(2, number):
+ if number % element == 0:
+ return False
+ return True
+
+
+def print_next_prime(number):
+ """打印输入number数字最近的质数"""
+ index = number
+ while True:
+ index += 1
+ if is_prime(index):
+ print(index)
+
+
+测试is_prime函数
+
+使用测试驱动开发(TDD)的方法，编写的最简单的测试代码测试is_prime函数是否实现了功能，代码如下：
+
+
+# Author: chenjunlin
+# Date: 2023-03-16
+# File: test_is_prime.py
+
+import pytest
+
+from src.chapter7unit.method_examples.is_prime import is_prime
+
+
+class TestPrimes(object):
+ """测试is_prime"""
+
+ def test_is_zero_not_prime(self):
+ """测试边界值0是不是质数"""
+ assert is_prime(0) is False
+
+ def test_is_one_not_prime(self):
+ """测试边界值1是不是质数"""
+ assert is_prime(1) is False
+
+ def test_is_two_prime(self):
+ """2是质数"""
+ assert is_prime(2) is True
+
+ def test_is_four_non_prime(self):
+ """4不是质数"""
+ assert is_prime(4) is False
+
+ def test_is_five_prime(self):
+ """5是不是质数？"""
+ assert is_prime(5) is True
+
+
+if __name__ == '__main__':
+ pytest.main()
+
+
+
+输出结果如下：
+
+也就是说，0和1不是素数，但是函数返回的结果是1，说明is_prime函数没有实现功能。
+
+
+回到原来的函数，发现是因为range函数的范围是从2到number，所以0和1都没有被判断，所以我们修改一下代码，如下：
+
+def is_prime(number):
+ """如果是质数，返回为True"""
+ if number < 2:
+ return False
+ for element in range(2, number):
+ if number % element == 0:
+ return False
+ return True
+
+
+再次运行test_is_prime.py测试代码，发现测试通过了。
+
+
+
+测试print_next_prime函数
+
+我们再来编写一个测试函数，测试print_next_prime函数，代码如下：
+
+# Author: chenjunlin
+# Date: 2023-03-16
+# File: test_print_is_prime.py
+
+import pytest
+
+from src.chapter7unit.method_examples.is_prime import print_next_prime
+
+class TestPrimes(object):
+ """测试print_next_prime"""
+
+ def test_print_next_prime_0(self):
+ """ 0的最近质数是2 """
+ assert print_next_prime(0) is 2
+
+ def test_print_next_prime_4(self):
+ """ 4的最近质数是5 """
+ assert print_next_prime(4) is 5
+
+ def test_print_next_prime_5(self):
+ """ 5的最近质数是7 """
+ assert print_next_prime(5) is 7
+
+ def test_print_next_prime_7(self):
+ """ 7的最近质数是11 """
+ assert print_next_prime(7) is 11
+
+
+if __name__ == '__main__':
+ pytest.main()
+
+
+没有通过测试，结果如下：
+
+
+
+原来是因为print_next_prime函数返回结果并不是距离输入数字最近的素数，而是返回了所有大于输入数字的素数，所以在running tests中，我们可以发现一直在打转，没有返回assert断言的结果。
+
+我们还可以通过在is_prime.py中添加魔术方法__name__ == ‘main‘来测试print_next_prime函数，代码如下：
+
+if __name__ == '__main__':
+
+ print(is_prime(2))
+ print_next_prime(0)
+
+
+
+发现结果确实是打印了所有大于输入数字的素数：
+
+
+
+我们修改一下代码，如下：
+
+def print_next_prime2(number):
+ """打印输入number数字最近的质数"""
+ index = number
+ while True:
+ index += 1
+ if is_prime(index):
+ return index
+
+
+再次运行测试代码，发现测试通过了。
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/e9/a63e64ea6263849bc7c2fc92752c654ea00c64fa2583cf63aa87ce28470916 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/e9/a63e64ea6263849bc7c2fc92752c654ea00c64fa2583cf63aa87ce28470916
new file mode 100644
index 0000000000..9658ecbf1c
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/e9/a63e64ea6263849bc7c2fc92752c654ea00c64fa2583cf63aa87ce28470916
@@ -0,0 +1,16 @@
+I"
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/e9/e4496eb136082ba0cc40b726b7f1d7a018f86a57f56c5092ce4317ed9e612c b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/e9/e4496eb136082ba0cc40b726b7f1d7a018f86a57f56c5092ce4317ed9e612c
new file mode 100644
index 0000000000..988accbe13
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/e9/e4496eb136082ba0cc40b726b7f1d7a018f86a57f56c5092ce4317ed9e612c
@@ -0,0 +1,27 @@
+I"e
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/e9/f9dc47b44c68b25f1c714e9a64b3f33204369a0efb6965cba56f0bb3f732f4 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/e9/f9dc47b44c68b25f1c714e9a64b3f33204369a0efb6965cba56f0bb3f732f4
new file mode 100644
index 0000000000..54dd7b37ba
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/e9/f9dc47b44c68b25f1c714e9a64b3f33204369a0efb6965cba56f0bb3f732f4
@@ -0,0 +1,10 @@
+I"
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/ea/d0d98217b213bb2621eecb66afac0f3744100575b7e3132d0d505c4a769294 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/ea/d0d98217b213bb2621eecb66afac0f3744100575b7e3132d0d505c4a769294
new file mode 100644
index 0000000000..2b45d09f7e
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/ea/d0d98217b213bb2621eecb66afac0f3744100575b7e3132d0d505c4a769294
@@ -0,0 +1,13 @@
+I"s
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/eb/922c261846befa764ead7a768aac96392215ca9bd7c78dc8d807d224b38293 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/eb/922c261846befa764ead7a768aac96392215ca9bd7c78dc8d807d224b38293
new file mode 100644
index 0000000000..3b0eb2fdc9
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/eb/922c261846befa764ead7a768aac96392215ca9bd7c78dc8d807d224b38293
@@ -0,0 +1,24 @@
+I"2
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/eb/9cb95107d59a9c0651a22e42aa25c08b9fcb5d43c6d6b2450f0146a80f5101 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/eb/9cb95107d59a9c0651a22e42aa25c08b9fcb5d43c6d6b2450f0146a80f5101
new file mode 100644
index 0000000000..a870680019
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/eb/9cb95107d59a9c0651a22e42aa25c08b9fcb5d43c6d6b2450f0146a80f5101
@@ -0,0 +1,2 @@
+I"主要包括日志文件介绍以及快速使用，文件封装，日志配置文件重构，日志工具类应用等等内容。
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/ef/42dd0b5037e9e5097e6cc18edc3d37f398e616808339ef307e9c7fe87b2235 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/ef/42dd0b5037e9e5097e6cc18edc3d37f398e616808339ef307e9c7fe87b2235
new file mode 100644
index 0000000000..d56bf3d993
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/ef/42dd0b5037e9e5097e6cc18edc3d37f398e616808339ef307e9c7fe87b2235
@@ -0,0 +1,2 @@
+I"g介绍了邮件配置的目的，邮件配置的方法，邮件封装以及邮件运行。
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/ef/735e951df7da8fe87ca7a2c12db8e5217748441d490e8adb2dd41e24de8c40 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/ef/735e951df7da8fe87ca7a2c12db8e5217748441d490e8adb2dd41e24de8c40
new file mode 100644
index 0000000000..780aae01df
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/ef/735e951df7da8fe87ca7a2c12db8e5217748441d490e8adb2dd41e24de8c40
@@ -0,0 +1,2 @@
+I"
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/f0/fd74681aaa4d6ef9dba552d51dafe77d7a58926919e454bc577db3b3ccadd6 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/f0/fd74681aaa4d6ef9dba552d51dafe77d7a58926919e454bc577db3b3ccadd6
new file mode 100644
index 0000000000..ac5f557e73
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/f0/fd74681aaa4d6ef9dba552d51dafe77d7a58926919e454bc577db3b3ccadd6
@@ -0,0 +1,2 @@
+I"-准备工作
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/f1/1632c41d0180fdcd2843af8d2ea5f000e14778f6d2cbae55f33c989384d5b7 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/f1/1632c41d0180fdcd2843af8d2ea5f000e14778f6d2cbae55f33c989384d5b7
new file mode 100644
index 0000000000..6172802bdb
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/f1/1632c41d0180fdcd2843af8d2ea5f000e14778f6d2cbae55f33c989384d5b7
@@ -0,0 +1,7 @@
+I"
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/f6/c60f72d31287e9364ea72d7bd37e44eeb824addd9e6bcb68b6d001cca1dd53 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/f6/c60f72d31287e9364ea72d7bd37e44eeb824addd9e6bcb68b6d001cca1dd53
new file mode 100644
index 0000000000..c759ab9be8
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/f6/c60f72d31287e9364ea72d7bd37e44eeb824addd9e6bcb68b6d001cca1dd53
@@ -0,0 +1,368 @@
+I"8linux系统的网络连接状态
+
+LINUX网络设置
+这一节主要讲如何查看并修改如主机名，路由器，网卡，网络连接方式等等。
+
+1.查看网络配置
+
+查看所有活动的网络接口
+
+ifconfig -a
+
+
+ens33:第一块以太网卡的名称,”ens33”中的”en”是”“EtherNet””的缩写，表示网卡类型为以太网，”s”表示热插拔插槽上的设备(hot-plugslot.·数字“33”表示插槽编号。
+
+ifconfig ens33
+inet 192.168.245.211 #ip地址
+netmask 255.
+broadcast 192.168.245.255 #广播地址
+inet6
+ether 00:0c:29:5a:5a:5a #mac地址
+
+
+2.查看网络状态
+
+netstat -tunlp
+# -t：查看TCP (Transmission Control Protocol，传输控制协议）相关的信息
+# -u：查看UDP (User Datagram Protocol，用户数据报协议）相关的信息
+# -n：显示数字格式的IP地址(主机地址、端口信息)
+# -l：显示监听套接字（Listenin状态的网络连接及端口信息）
+# -p：显示进程信息（该选项需要root权限）
+
+
+3. 临时修改主机名
+
+hostnamectl set-hostname ### 4.永久修改主机名
+
+vim /etc/hostname
+vim /etc/hosts
+
+
+5.测试网络连通性
+
+ping www.baidu.com
+ping -c 3 www.baidu.com #测试3次
+ping -c 3 -i 0.2 www.baidu.com #每次间隔0.2秒
+ping -c 3 -i 0.2 -w 1 www.baidu.com #超时时间为1秒（只ping五秒，5秒之后结束）
+
+
+一般来说，网络不通，用ping来定位问题节点的位置，ping的顺序如下：
+
+ping 127.0.0.1 #ping 本地回环，测试本地网络协议是否正常
+ping 192.168.0.31 #ping 本地IP，测试本地网络接口是否正常
+ping 192.168.0.254 # ping 网关，测试网关是否工作正常
+ping 202.106.0.20 # ping 外部网络，测试服务商网络是否工作正常
+
+
+6.查看路由表
+
+ route -n
+ # -n：以数字格式显示路由表信息
+ # -v：显示详细的路由表信息
+ # -e：显示路由表中的错误信息
+ # -A：显示所有的路由表信息
+ # -g：显示网关信息
+ # -C：显示缓存信息
+ # -F：显示过滤信息
+ # -M：显示多播信息
+ # -N：显示网络信息
+ # -S：显示套接字信息
+ # -T：显示TCP信息
+ # -U：显示UDP信息
+ # -V：显示版本信息
+ # -W：显示网卡信息
+ # -X：显示X.25信息
+ # -Z：显示SCTP信息
+
+
+7.查看DNS服务器
+
+cat /etc/resolv.conf
+#nameserver
+#测试DNS服务器是否可用
+nslookup www.baidu.com #目标主机地址
+# 解析DNS信息收集
+dig www.baidu.com
+# 本地主机映射文件
+# etc/hosts 文件中记录着一份主机名与 IP 地址的映射关系表，一般用来保存经常需要访问的主机的信息。
+# 当访问一个未知的域名时，先查找该文件中是否有相应的映射记录，如果找不到再去向DNS 服务器查询
+cat /etc/hosts
+# 本地主机名解析文件
+# /etc/nsswitch.conf 文件中记录着本地主机名解析的顺序，一般情况下，本地主机名解析的顺序为：
+# hosts > dns > files > nis > nisplus > db > ldap > compat > hesiod > myhostname
+
+
+8.查看网卡信息
+
+ ifconfig
+ # -a：显示所有网卡信息
+ # -s：显示网卡的简要信息
+ # -d：显示网卡的详细信息
+ # -v：显示网卡的详细信息
+ # -r：显示路由信息
+ # -m：显示多播信息
+ # -u：显示UDP信息
+ # -t：显示TCP信息
+ # -x：显示X.25信息
+ # -z：显示SCTP信息
+
+
+9.网络连接方式
+
+动态网络dhcp
+
+网桥方式
+link: https://blog.csdn.net/qq_59323083/article/details/125531699
+
+ # 1.安装网桥工具
+ yum install bridge-utils
+ # 2.配置网桥
+ vim /etc/sysconfig/network-scripts/ifcfg-eth0
+ # 添加以下内容
+ DEVICE=eth0
+ BOOTPROTO=dhcp
+ ONBOOT=yes
+ BRIDGE=br0
+ # 3.配置网桥
+ vim /etc/sysconfig/network-scripts/ifcfg-br0
+ # 添加以下内容
+ DEVICE=br0
+ BOOTPROTO=static
+ IPADDR=
+
+
+NAT方式
+打开虚拟网络编辑器，所有数据不要去改动，如下图所示：
+
+打开虚拟机设置，网络适配器，选择NAT模式，然后点击高级，选择端口转发，添加端口转发规则，如下图所示：
+
+重启网络
+
+systemctl restart network
+
+
+检查网络连通性
+
+ ping www.baidu.com
+
+
+静态网络
+
+网桥模式联网（static）
+
+通过VMware编辑菜单栏点击虚拟网络编辑器,设置VMnet0，选择桥接模式，外部连接不要选自动，而是选择你的宿主主机的网卡，考虑到一般有有线和无线两块网卡，但这里选择的这块网卡是连接Internet的，比如，这个图中所示，我使用无线网卡连接到Internet，所以选择它，然后“确定”。(如图所示)
+
+虚拟机 设置 网络适配器 选择桥接模式，如下图所示：
+
+修改配置文件/etc/sysconfig/network-scripts/ifcfg-ens33
+
+重启网络服务
+
+systemctl restart network
+
+
+NAT模式联网（static）
+
+通过VMware编辑菜单栏点击虚拟网络编辑器，选中VMnet8点击NAT设置：
+
+不使用本地DHCP服务，这样就得勾消DHCP选项，然后查看DHCP确保未启用。
+
+
+第四步，打开NAT设置，记录下图中表示的数据用于修改配置文件：
+
+
+第五步，打开虚拟机设置，配置网络适配器，如下图所示：
+
+第六步，修改配置文件/etc/sysconfig/network-scripts/ifcfg-ens33，修改的时候必须按第四步的IP网段和网关修改，具体根据你自己的情况决定这个网段，比如，我的网段是192.168.75.0，网关是192.168.75.2，子网掩码是255.255.255.0。
+
+
+
+第七步，重启服务：
+
+systemctl restart network
+
+
+配置DNS
+
+第一步：修改配置文件 /etc/resolv.conf ，如果你公司有自己的DNS服务器，那么用本公司的，也可以到网上查找免费的DNS服务器，比如：
+
+中国互联网络中心：1.2.4.8、210.2.4.8、101.226.4.6（电信及移动）、123.125.81.6（联通）
+阿里DNS：223.5.5.5、223.6.6.6
+googleDNS：8.8.8.8、8.8.4.4
+openDNS：208.67.222.222208.67.220.220208.67.222.220208.67.220.222
+可以阻挡含有恶意网站的dns
+208.67.220.123
+
+无劫持 去广告或粗俗网站dns:114.114.114.114 和 114.114.115.115
+
+拦截钓鱼病毒木马网站,可增强网银、证券、购物、游戏、隐私信息安全的DNS 114.114.114.119 和 114.114.115.119
+
+然后修改配置文件 /etc/resolv.conf，如下表所示：
+
+
+可最多写3个
+
+当你配好resolv.conf文件后，过了一会，发现刚才配置好的DNS又失效了，原来DNS被系统重新覆盖或者被清除！所以你还必须完成以下工作。
+
+第二步：修改/etc/NetworkManager/NetworkManager.conf文件
+
+
+
+网络基本管理–与网络配置相关的常用命令
+
+
+ -
+
查看网络配置信息
+ifconfig 的功能是管理网络接口，用于查看、配置、启用或禁用网络接口。
+
+ ifconfig interface [aftype] options | address …
+
+
+ 
+
+
+
+ifconfig命令是Linux下用来配置和显示网络接口信息的命令，它可以显示网络接口的详细信息，包括IP地址、子网掩码、广播地址、MAC地址等。
+
+ifconfig
+#安装ifconfig命令
+yum -y install net-tools
+# 从源头开始安装
+yum -y install net-tools.x86_64
+
+
+ifconfig语法
+
+ ifconfig [选项] [接口名]
+ ifconfig [选项] [接口名] [地址] [广播地址] [子网掩码] 网卡控制命令
+
+ifconfig eth0 up # 启动网卡
+ifconfig eth0 down # 关闭网卡
+ifconfig eth0
+ifup eth0 # 启动网卡
+ifup ens33
+ifup eth0:0 # 启动虚拟网卡
+ifdown ens33
+
+
+nmcli命令
+该命令可以完成网卡上所有的配置工作，并且可以写入配置文件，重启后依然有效。
+
+nmcli device show ens33 # 查看网卡信息
+nmcli device status # 查看网卡状态
+nmcli device disconnect ens33 # 断开网卡
+nmcli device connect ens33 # 连接网卡
+nmcli device modify ens33 ipv4.addresses
+nmcli device modify ens33 ipv4.addresses
+
+
+检查网卡知否连接网线的命令
+
+ethtool ens33 # 查看网卡信息
+ethtool ens33 | grep "Link detected" # 查看网卡是否连接网线
+
+
+
+ -
+
ping命令
+
+ ping [options] hostname/ip
+
+
+ 
+
+ -
+
检查网络状态（netstat）
+
+ netstat [-veenNcCF] [<Af>] -r
+
+
+
+
+ens33是我们用于连网的网卡，其功能大多已经了解；下面我们着重介绍一下lo和virbr0的功能。
+关于lo
+
+lo（lo: local loopback的简写）是一个虚拟网络接口。所谓虚拟网络接口，是指不从外界接收和发送数据包，只在系统内部接收和发送数据包，不需要驱动程序。
+
+lo接口的作用是为本地不同进程间进行数据交换提供服务。直观地说lo就是回环地址127.0.0.1，用于本机通信，数据经过内核处理后直接返回，不会在任何网络中出现。
+
+利用命令ping 127.0.0.1可以检查本地TCP/IP协议以及基本数据接口等是否工作正常。
+
+观察本机间不同进程交换数据包的过程，可以使用命令tcpdump -i lo。
+
+tpcpdump -i lo
+
+
+也可以用WireShark进行抓包，选择lo网卡即可。
+
+yum -y install wireshark -gnome # 安装wireshark 带有gnome界面
+
+
+然后再终端输入 wireshark 即可打开wireshark
+
+
+关于virbr0
+
+在虚拟机下安装Linux，这样便会看到vibro这个网络设备，其中的IP地址，子网掩码等都是虚拟机控制程序分配的。
+
+virbr0其实就是一个虚拟网桥（virtual bridge），你也可以理解为在虚拟网络中的交换机，当你在VMware Workstation下安装了多个虚拟机时，这些虚拟机之间就是通过这个交换机virbr0互联的，没有virbr0，各虚拟机之间无法通信。尽管你的虚拟机与virbr0的IP地址192.168.122.1不属于同一网段，但ping 192.168.122.1是通的，你不妨试试ping一下。
+
+时间与网络时间同步
+
+使用date命令查看之后，发现时间与本地时间不一致。
+NTP（Network Time Protocol）是网络时间协议，是用来同步网络中各个计算机时间的协议。
+
+
+ -
+
安装ntpdate
+
+ yum -y install ntpdate
+ yum install ntp ntp-doc ntpdate # 安装ntp
+ systemctl start ntpd # 启动ntp服务
+ systemcl enable ntpd # 设置开机启动
+
+
+
+
+需要提醒的是，每当修改配置文件后，都需要重启NTP 服务。
+
+
+ -
+
同步时间
+
+ ntpdate后面可以选择
+
+ 1.asia.pool.ntp.org、
+2.asia.pool.ntp.org、
+3.asia.pool.ntp.org
+
+ 也可以选择其他国家的ntp服务器，比如美国的ntp服务器为
+
+ 0.us.pool.ntp.org、
+1.us.pool.ntp.org、
+2.us.pool.ntp.org、
+3.us.pool.ntp.org。
+
+ ntpdate cn.pool.ntp.org
+ date #系统时间和本地时间一致
+
+
+ -
+
将系统时间写入硬件时间
+
+ hwclock --systohc
+ timedatectl
+
+
+ -
+
强制系统时间写入CMOS中防止重启失效
+
+ hwclock -w #将系统时间写入CMOS中
+hwclock -s # 将CMOS时间写入硬件
+hwclock --show # 查看硬件时间
+hwclock -r # 查看CMOS时间
+
+
+
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/f7/80903e237784afa195dc34276fd42d3ec1a7b792679323c6ca2ec633987ac6 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/f7/80903e237784afa195dc34276fd42d3ec1a7b792679323c6ca2ec633987ac6
new file mode 100644
index 0000000000..c90c532bcb
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/f7/80903e237784afa195dc34276fd42d3ec1a7b792679323c6ca2ec633987ac6
@@ -0,0 +1,19 @@
+I"
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/f9/7e207ea3a551d55ffa0aa8fc59c9506a50d5ce4d61306c381080e26205791f b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/f9/7e207ea3a551d55ffa0aa8fc59c9506a50d5ce4d61306c381080e26205791f
new file mode 100644
index 0000000000..e1b052c0ca
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/f9/7e207ea3a551d55ffa0aa8fc59c9506a50d5ce4d61306c381080e26205791f
@@ -0,0 +1,25 @@
+I"
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/f9/f59e2d7818d90669cb7eb06f864b13c8800c75e315006180d4cfd736757bb5 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/f9/f59e2d7818d90669cb7eb06f864b13c8800c75e315006180d4cfd736757bb5
new file mode 100644
index 0000000000..7699717f1e
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/f9/f59e2d7818d90669cb7eb06f864b13c8800c75e315006180d4cfd736757bb5
@@ -0,0 +1,21 @@
+I"
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/fa/9df514c0a07fba58476a5e04917db1fbe565e6e7307266a8b0830970a8beb1 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/fa/9df514c0a07fba58476a5e04917db1fbe565e6e7307266a8b0830970a8beb1
new file mode 100644
index 0000000000..5b9686d988
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/fa/9df514c0a07fba58476a5e04917db1fbe565e6e7307266a8b0830970a8beb1
@@ -0,0 +1,11 @@
+I"z
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/fb/de25c51b0454c9f2143282eb94b7c90eb37c27f06f1646ad16f5ea3fcba042 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/fb/de25c51b0454c9f2143282eb94b7c90eb37c27f06f1646ad16f5ea3fcba042
new file mode 100644
index 0000000000..e061a9a7fd
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/fb/de25c51b0454c9f2143282eb94b7c90eb37c27f06f1646ad16f5ea3fcba042
@@ -0,0 +1,5 @@
+I"E
+
+:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/fc/868752ffc2cbf71f6b84e427bdfdbd7913312f446645bc11351b0cdfcdb7f5 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/fc/868752ffc2cbf71f6b84e427bdfdbd7913312f446645bc11351b0cdfcdb7f5
new file mode 100644
index 0000000000..61d6be2de7
--- /dev/null
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/fc/868752ffc2cbf71f6b84e427bdfdbd7913312f446645bc11351b0cdfcdb7f5
@@ -0,0 +1,72 @@
+I"bash脚本测试Ubuntu服务器的性能并输出报告
+
+
+#!/bin/bash
+
+# This script is used to test server performance and output report
+
+# Get the system information
+hostname=`hostname`
+kernel=`uname -r`
+
+# Get the CPU information
+cpu_model=`cat /proc/cpuinfo | grep "model name" | head -1 | cut -d: -f2`
+cpu_cores=`cat /proc/cpuinfo | grep "cpu cores" | head -1 | cut -d: -f2`
+cpu_freq=`cat /proc/cpuinfo | grep "cpu MHz" | head -1 | cut -d: -f2`
+
+# Get the memory information
+mem_total=`cat /proc/meminfo | grep "MemTotal" | cut -d: -f2`
+swap_total=`cat /proc/meminfo | grep "SwapTotal" | cut -d: -f2`
+
+# Get the disk information
+disk_total=`df -h | grep "/$" | awk '{print $2}'`
+disk_used=`df -h | grep "/$" | awk '{print $3}'`
+
+# Print the report
+echo "System Information"
+echo "-----------------"
+echo "Hostname: $hostname"
+echo "Kernel: $kernel"
+echo ""
+echo "CPU Information"
+echo "---------------"
+echo "Model: $cpu_model"
+echo "Cores: $cpu_cores"
+echo "Frequency: $cpu_freq MHz"
+echo ""
+echo "Memory Information"
+echo "-----------------"
+echo "Total: $mem_total"
+echo "Swap: $swap_total"
+echo ""
+echo "Disk Information"
+echo "----------------"
+echo "Total: $disk_total"
+echo "Used: $disk_used"
+echo ""
+
+
+结果如下：
+root@hugo-virtual-machine:/opt# sh service.sh
+System Information
+-----------------
+Hostname: hugo-virtual-machine
+Kernel: 5.15.0-58-generic
+
+CPU Information
+---------------
+Model: AMD Ryzen 7 4800H with Radeon Graphics
+Cores: 2
+Frequency: 2894.461 MHz
+
+Memory Information
+-----------------
+Total: 8105812 kB
+Swap: 1999868 kB
+
+Disk Information
+----------------
+Total: 23G
+Used: 12G
+
+:ET
\ No newline at end of file
diff --git a/Gemfile b/Gemfile
index 0612ed55db..21390fcd83 100755
--- a/Gemfile
+++ b/Gemfile
@@ -3,3 +3,4 @@ gem 'jekyll'
gem 'redcarpet'
gem 'jekyll-paginate'
gem 'jekyll-sitemap'
+
diff --git a/Gemfile.lock b/Gemfile.lock
index afef6f8693..f5100620f1 100755
--- a/Gemfile.lock
+++ b/Gemfile.lock
@@ -1,70 +1,78 @@
GEM
remote: https://rubygems.org/
specs:
- addressable (2.6.0)
- public_suffix (>= 2.0.2, < 4.0)
+ addressable (2.8.0)
+ public_suffix (>= 2.0.2, < 5.0)
colorator (1.1.0)
- concurrent-ruby (1.1.4)
- em-websocket (0.5.1)
+ concurrent-ruby (1.1.10)
+ em-websocket (0.5.3)
eventmachine (>= 0.12.9)
- http_parser.rb (~> 0.6.0)
+ http_parser.rb (~> 0)
eventmachine (1.2.7)
- ffi (1.10.0)
+ ffi (1.15.5-x64-mingw-ucrt)
forwardable-extended (2.6.0)
- http_parser.rb (0.6.0)
- i18n (0.9.5)
+ http_parser.rb (0.8.0)
+ i18n (1.10.0)
concurrent-ruby (~> 1.0)
- jekyll (3.8.5)
+ jekyll (4.2.2)
addressable (~> 2.4)
colorator (~> 1.0)
em-websocket (~> 0.5)
- i18n (~> 0.7)
- jekyll-sass-converter (~> 1.0)
+ i18n (~> 1.0)
+ jekyll-sass-converter (~> 2.0)
jekyll-watch (~> 2.0)
- kramdown (~> 1.14)
+ kramdown (~> 2.3)
+ kramdown-parser-gfm (~> 1.0)
liquid (~> 4.0)
- mercenary (~> 0.3.3)
+ mercenary (~> 0.4.0)
pathutil (~> 0.9)
- rouge (>= 1.7, < 4)
+ rouge (~> 3.0)
safe_yaml (~> 1.0)
+ terminal-table (~> 2.0)
jekyll-paginate (1.1.0)
- jekyll-sass-converter (1.5.2)
- sass (~> 3.4)
- jekyll-sitemap (1.1.1)
- jekyll (~> 3.3)
- jekyll-watch (2.1.2)
+ jekyll-sass-converter (2.2.0)
+ sassc (> 2.0.1, < 3.0)
+ jekyll-sitemap (1.4.0)
+ jekyll (>= 3.7, < 5.0)
+ jekyll-watch (2.2.1)
listen (~> 3.0)
- kramdown (1.17.0)
- liquid (4.0.1)
- listen (3.1.5)
- rb-fsevent (~> 0.9, >= 0.9.4)
- rb-inotify (~> 0.9, >= 0.9.7)
- ruby_dep (~> 1.2)
- mercenary (0.3.6)
+ kramdown (2.4.0)
+ rexml
+ kramdown-parser-gfm (1.1.0)
+ kramdown (~> 2.0)
+ liquid (4.0.3)
+ listen (3.7.1)
+ rb-fsevent (~> 0.10, >= 0.10.3)
+ rb-inotify (~> 0.9, >= 0.9.10)
+ mercenary (0.4.0)
pathutil (0.16.2)
forwardable-extended (~> 2.6)
- public_suffix (3.0.3)
- rb-fsevent (0.10.3)
- rb-inotify (0.10.0)
+ public_suffix (4.0.7)
+ rb-fsevent (0.11.1)
+ rb-inotify (0.10.1)
ffi (~> 1.0)
- redcarpet (3.4.0)
- rouge (3.3.0)
- ruby_dep (1.5.0)
- safe_yaml (1.0.4)
- sass (3.7.3)
- sass-listen (~> 4.0.0)
- sass-listen (4.0.0)
- rb-fsevent (~> 0.9, >= 0.9.4)
- rb-inotify (~> 0.9, >= 0.9.7)
+ redcarpet (3.5.1)
+ rexml (3.2.5)
+ rouge (3.29.0)
+ safe_yaml (1.0.5)
+ sassc (2.4.0)
+ ffi (~> 1.9)
+ terminal-table (2.0.0)
+ unicode-display_width (~> 1.1, >= 1.1.1)
+ unicode-display_width (1.8.0)
+ wdm (0.1.1)
+ webrick (1.7.0)
PLATFORMS
- ruby
+ x64-mingw-ucrt
DEPENDENCIES
jekyll
jekyll-paginate
jekyll-sitemap
redcarpet
+ wdm (>= 0.1.0)
+ webrick (~> 1.7)
BUNDLED WITH
- 1.16.1
+ 2.3.7
diff --git a/README.md b/README.md
index 2a9187d4c6..2069322903 100755
--- a/README.md
+++ b/README.md
@@ -1,115 +1 @@
-
-[leopard](http://leopardpan.cn) 是一个简洁的博客模板，响应式主题， 适配了电脑、手机各种屏幕，看效果直接点击下面链接
-
- * [博客链接](http://leopardpan.cn) （部署在国内，访问更快）
- * [Demo链接](http://leopardpan.github.io/) （部署在github page）
-
-如果你喜欢请 Star ，你的 Star 是我持续更新的动力, 谢谢 😄.
-
-### 你在搭建个人博客遇到任何问题都可以找我
-
-遇到解决不了的问题 [需要技术支持联系我](http://leopardpan.cn/support/)
-
-
-### 环境要求
-
-* Jekyll 支持: Mac 、Windows、ubuntu 、Linux 操作系统
-* Jekyll 需要依赖: Ruby、bundler
-
-### 使用手册
-
-[Jekyll搭建个人博客](http://leopardpan.cn/2016/10/jekyll_tutorials1/) : 使用Jekyll搭建个人博客的教程，及如何把这个博客模板修改成你自己的博客，里面也有大量的评论、Jekyll 搭建博客各种环境出现过的问题。
-
-[HEXO搭建个人博客](http://leopardpan.cn/2015/08/HEXO%E6%90%AD%E5%BB%BA%E4%B8%AA%E4%BA%BA%E5%8D%9A%E5%AE%A2/) : 使用 HEXO 基于 Github Page 搭建个人博客， 教程里面累计了大量提问和评论，如果你在搭建博客时遇到问题，可以看看这个教程。
-
-
-#### 安装Jekyll
-
-[Jekyll中文官方文档](http://jekyll.bootcss.com/) ， 如果你已经安装过了 Jekyll，可以忽略此处。
-
-> $ gem install jekyll
-
-#### 获取博客模板
-
-> $ git clone https://github.com/leopardpan/leopardpan.github.io.git
-
-或者直接[下载博客](https://github.com/leopardpan/leopardpan.github.io/archive/master.zip)
-
-进leopardpan.github.io/ 目录下， 开启本地服务
-
-> $ jekyll server
-
-在浏览器输入 [127.0.0.1:4000](127.0.0.1:4000) ， 就可以看到博客效果了。
-
-
-### 提示
-
->* 如果你想使用我的模板，请把 _posts/ 目录下的文章都去掉。
->* 修改 _config.yml 文件里面的内容为你自己的个人信息。
-
-如果在部署博客的时候发现问题，可以直接在[Issues](https://github.com/leopardpan/leopardpan.github.io/issues)里面提问。
-
-
-### 把这个博客变成你自己的博客
-
-根据上面【提示】修改过后，在你的github里创建一个username.github.io的仓库，username指的值你的github的用户名。
-创建完成后，把我的这个模板使用git push到你的username.github.io仓库下就行了。
-搭建博客如果遇到问题可以看看我教程[Jekyll搭建个人博客](http://leopardpan.cn/2016/10/jekyll_tutorials1/)。
-
-
-### 赞助
-
-你可以通过下方二维码赞助本项目，资金将用于服务器开销以及今后的公共服务
-
-感谢所有赞助过本项目的朋友，你们都为本项目贡献了自己的一份力量
-
-
-
-微信二维码
-
-
-
-
-
-支付宝二维码
-
-
-
-
-### 效果预览
-
-#### 头像效果
-
-
-
-如果你只想要我博客里的头像效果，你只需要拿 leopardpan.github.io/_includes/side-panel.html 文件里面 `头像效果` 和 leopardpan.github.io/css/main.css 里面最后面 `头像效果` 部分就行了。
-
-
-***
-
-#### 博客首页
-
-
-
-***
-
-#### 每篇文章下面都支持打赏
-
-
-
-#### 文章详情
-
-
-
-
-#### 文章支持标签分类
-
-
-
-#### 手机端效果
-
-
-
-#### 感谢
-
-本博客在[Vno Jekyll](https://github.com/onevcat/vno-jekyll)基础上修改的。
\ No newline at end of file
+## 物理海洋学在读
diff --git a/_config.yml b/_config.yml
index 9795797653..c40bd3b830 100755
--- a/_config.yml
+++ b/_config.yml
@@ -1,50 +1,49 @@
# Basic
-title: 潘柏信
+title: 陈同学
subtitle: 个人站
description: 欢迎来到我的个人站~
# 头像里面的标题
-avatarTitle: leopardpan
+avatarTitle: nothing can stop me
# 头像里面的描述
-avatarDesc: iOS / 机器学习
-url: "http://leopardpan.cn"
+avatarDesc: 物理海洋学在读
+url: "https://chanjeunlam.github.io/"
# 博客是否自动生成目录，false为不生成
enableToc: true
# Comment
-comment:
- # livere: MTAyMC81MDk5NC8yNzQ3Ng # https://www.livere.com
- disqus: leopard
- # uyan: 2143225 # 有言id,登录有言官网申请
+# comment:
+# # livere: MTAyMC81MDk5NC8yNzQ3Ng # https://www.livere.com
+# disqus: leopard
+# # uyan: 2143225 # 有言id,登录有言官网申请
# Social
social:
- weibo: 5366874726
- github: leopardpan
+ # weibo:
+ # github:
# zhihu: panpanleopard
# juejin: xxx
- jianshu: 2ada30d8d0f7
+ # jianshu: 2ada30d8d0f7
# twitter:
- mail: leopardpan@icloud.com
+ mail: jchenfl@connect.ust.hk
# 百度统计
# 使用博客模板请去掉或者更换 id
-baidu:
- id: 8ba1c6be0953b6f9c2ba38e57f615421
+# baidu:
+# id: 8ba1c6be0953b6f9c2ba38e57f615421
# Google Analytics
# 使用博客模板请去掉或者更换 id
-ga:
- id: UA-84134159-3
- host: auto
+# ga:
+# id: UA-84134159-3
+# host: auto
# 《----------------- 上面的信息修改成你自己的 ---------------------------》
#
#
# _post/ 下的文章更换成你自己的文章
-# 帮忙star一下，感谢~😆 地址： https://github.com/leopardpan/leopardpan.github.io
#
#
# 《--------------- 下面的信息可以自行选择是否修改 ------------------------》
@@ -73,7 +72,16 @@ nav:
# Pagination
gems: [jekyll-paginate,jekyll-sitemap]
+plugins: [jekyll-paginate]
paginate: 20
paginate_path: "page/:num/"
-
+# fomula
+markdown: kramdown
+kramdown:
+ math_engine: mathjax
+ syntax_highlighter: rouge
+ input: GFM
+ hard_wrap: false
+ syntax_highlighter_opts:
+ disable: true
\ No newline at end of file
diff --git a/_includes/open-embed.html b/_includes/open-embed.html
new file mode 100644
index 0000000000..e45e8d553c
--- /dev/null
+++ b/_includes/open-embed.html
@@ -0,0 +1,95 @@
+
+
+
diff --git a/_layouts/default.html b/_layouts/default.html
index e21abb61fd..d4323a978f 100755
--- a/_layouts/default.html
+++ b/_layouts/default.html
@@ -32,8 +32,12 @@
{% include footer.html %}
-
+
+
{% include external.html %}
+ {% include open-embed.html %}
+
+
diff --git a/_layouts/post.html b/_layouts/post.html
index 71d4530a7e..2c8f35b99f 100755
--- a/_layouts/post.html
+++ b/_layouts/post.html
@@ -4,6 +4,22 @@
+
+
+
+
+
+
+