《现代操作系统：原理与实现》

第一章

+++

操作系统概述

苹果Mac OS X和ISO使用开源类UNIX操作系统Darwin，谷歌的Android采用Linux作为操作系统内核。

X86、ARM、MIPS是目前具有代表性的CPU架构；其中X86是使用CISC复杂指令集的代表架构，ARM、MIPS使用的是RISC精简指令集。

操作系统的两个职责：

• 对硬件进行管理和抽象；
• 为应用提供服务并进行管理；

从硬件角度，操作系统主要包含两类共性功能：

• 管理硬件：将硬件资源纳入统一的管理；
• 对硬件进行抽象：将有限的、离散的资源高效地抽象为无限的、连续的资源；

从应用角度，操作系统主要包含两类共性功能：

• 服务于应用： 提供接口（如系统调用等）和不同类型的访问控制、应用间交互等功能；
• 管理应用：负责对应用生命周期的管理，包括应用的加载、启动、切换、调度、销毁等；

狭义的操作系统：操作系统内核加上一个Shell（即UNIX/Linux等操作系统中的命令行界面）。

广义的操作系统：进一步分为操作系统内核与操作系统框架两层。

如图1-1为操作系统的简要结构：

• 操作系统内核负责对硬件资源的管理和抽象，为操作系统框架提供基础的系统服务；
• 操作系统框架则基于操作系统内核提供的服务为不同的应用领域提供编程接口与运行环境；

操作系统的必要性：

一台机器上只有一个应用程序，开机后自动运行不会退出，是否需要操作系统？

• 若没有操作系统，则应用需要直接与硬件打交道，直接实现对硬件资源的管理和抽象，如果应用出现故障，极有可能引起计算机直接崩溃，没有诊断和调试的机会。当然解决上述问题，可以使用实现一套硬件资源管理与抽象的库的方法，但是实际上这个库实现的就是操作系统功能的一部分。目前，一些对性能和时延要求极高的场景就是通过类似的方法实现的，包括本书后面会介绍的基于外核(Exokernel)架构的库操作系统（LibOS）与虚拟化容器等方法。

如果一个应用希望直接控制硬件而不是使用操作系统提供的抽象，是否还需要操作系统？

• 尽管应用希望直接控制硬件资源，但是应用的加载与销毁、多个应用之间的切换与隔离等依然需要操作系统来完成，此外，操作系统也可以从全局的角度更合理地对应用进行调度，从而更加高效地利用硬件资源。

如果在一个死循环中，每次循环执行都调用操作系统提供的**fork()**接口创建一个新的进程，则这个程序会以指数级的速度创建大量进程。

由于每次创建进程都需要消耗一定的资源，最终可能会将计算机的物理资源耗尽。

为了避免这种情况，操作系统提供了为每个应用的资源设置配额的机制，从而限制一个应用所能使用的资源数量。

指令集架构（Instruction Set Architecture ,ISA）

在包括UNIX在内的操作系统早期，用户主要通过使用shell命令行与操作系统进行交互，用户一般是程序员。

图形用户界面（Graphical User Interface , GUI）

操作系统接口

从应用的角度来看，操作系统提供了不同层次的接口，主要包括系统调用接口、POSIX接口、领域应用接口。

系统调用接口

应用程序通过操作系统内核提供的接口（如系统调用）向内核申请服务。

例：

printf函数调用标准库libc中的write函数，libc在准备好相关的参数后，执行svc指令使得控制流从用户地址空间下陷到内核地址空间。（svc指令是一条ARM指令，表示特权调用（supervisor call））

操作系统内核的下陷处理函数根据系统调用传入的第一个参数，识别出该调用需要执行操作系统内核提供的sys_write函数，从而通过系统调用表调用对应函数。

系统调用是用户态应用向操作系统内核请求服务的方法。

POSIX接口

由于每个操作系统提供的系统调用各不相同，为了同一个应用程序在不同操作系统上的可移植性，逐渐形成了一些可移植操作系统接口标准，例如POSIX。

POSIX（Portable Operating System Interface for uniX），可移植操作系统接口，X表明其是对UNIX API的传承。

POSIX标准通常通过C library (libc) 来实现，常见的libc包括glibc 、 musl、eclibc。

通常而言，应用程序只需要调用libc提供的接口就可以实现对操作系统功能的调用，同时也实现了应用在类UNIX系统（包括Linux）上的可移植性。不同的操作系统也可以通过对libc的移植来支持现有的应用生态。

领域应用接口

在POSIX或操作系统调用的基础上还可以封装面向不同领域的领域应用接口。例如面向汽车领域、移动平台。

常见的兼容，例如POSIX API兼容与Linux ABI兼容等。

API是指应用编程接口（Application Programming Interface），它定义了两层软件（例如libc与Linux内核）之间源码层面的交互接口。

ABI是指应用二进制接口，即在某个特定体系结构下两层软件之间二进制层面的交互接口，包括如何定义二进制文件格式（如ELF（Executable and Linkable Format）或者Windows中的EXE文件格式）、应用之间的调用约定（包括参数传递与返回值处理）、数据模式（大端模式、小端模式）等。

ChCore ：一个简单的实验操作系统

ChCore是本书为教学二开发的实验操作系统，其基本架构如图所示。ChCore采用了微内核架构的设计理念，将大部分的系统功能以系统服务的形式运行在用户态，这与Linux和Windows为代表的宏内核操作系统形成鲜明对比。

在Linux或Windows中，文件系统通常作为操作系统内核一部分直接运行在内核态，然而在Chcore中，文件系统不再属于内核的一部分，而是作为一个系统服务运行在用户态，实际上是一个独立的用户态进程。

ChCore实验操作系统包括两个部分：

• 运行在内核态的ChCore微内核
• 运行在用户态的各种操作系统服务

ChCore还提供了一个简单的命令行终端程序，即图中的Shell，作为与用户交互的界面。

本文源于HarmonyOS官方教程https://developer.huawei.com/consumer/cn/training/course/introduction/C101635908637340943

如有侵权，联系helloc2333@163.com删除。

HarmonyOS简介

HarmonyOS 是一款面向万物互联时代的、全新的分布式操作系统。

功能机：软件和硬件功能单一，不可变。

智能机： 软件可变，硬件不可变。

HarmonyOS: 软件可变，硬件“可变”（实际上非单一设备可变，指的是能够协同联合调用多个IOT设备）。

全场景理念

手机内部设备模块之间通过总线连接，但是IOT设备不可能与手机使用有线连接来使用。

因此，分布式软总线解决这个问题，基于现有的通讯技术，实现低延时、高效率的连接。

HarmonyOS以手机为核心，构建1+8+N全场景应用。

HarmonyOS架构

HarmonyOS 整体遵从分层设计，从下向上依次为：内核层、系统服务层、框架层和应用层。

系统功能按照“系统 > 子系统 > 功能 /模块”逐级展开，在多设备部署场景下，支持根据实际需求裁剪某些非必要的子系统或功能 / 模块。

HarmonyOS架构解析 - 内核层

• 内核子系统

  HarmonyOS采用多内核设计，其中最常用的为Linux内核与LiteOS内核，这样的话可以支持不同资源受限设备选用适合的 OS 内核。

  • 内核抽象层(KAL ， Kernel Abstract Layer)：HarmonyOS使用内核抽象层的封装，屏蔽多内核的差异。同时，对上层提供基础的内核能
    力，包括进程 / 线程管理、内存管理、文件系统、网络管理和外设管理等。
  • 驱动子系统：硬件驱动框架 (HDF) 是 HarmonyOS 硬件生态开放的基础，提供统一外设访问能力和驱动开发、管理框架。

• 驱动子系统

  • 硬件驱动框架 (HDF) 是 HarmonyOS 硬件生态开放的基础，提供统一外设访问能力和驱动开发、管理框架。
  • 统一驱动框架：驱动与内核解耦，支持运行动态加载，让更多IoT设备接入超级终端。
  • 通过平台、系统接口解耦的构建统一的驱动平台底座，兼容如Linux、LiteOS等不同内核；
  • 根据不同设备形态，支持用户态部署和内核态部署。

HarmonyOS架构解析 - 系统服务层

根据不同设备形态的部署环境，各个子系统集内部可以按子系统粒度裁剪，每个子系统内部又可以按功能粒度裁剪。

HarmonyOS架构解析 - 框架层

HarmonyOS架构解析 - 应用层

• HarmonyOS 的应用分为一个或多个 FA(Feature Ability) 或 PA(Particle Ability) 组成。

• 基于 FA/PA 构建的新型应用生态，能够实现三方服务跨设备智能分发，提供一致、高效的用户体验。t可以根据硬件设备的能力和使用场景对FA/PA功能进行裁剪。

HarmonyOS系统安全

在搭载 HarmonyOS 的分布式终端上，可以保证“正确的人，通过正确的设备，正确地使用数据”.

超级终端

多种设备之间能够实现硬件互助、资源共享，主要依赖以下四个关键分布式技术。

分布式软总线

分布式软总线是手机、平板、智能穿戴、智慧屏、车机等分布式设备的通信基座，为设备之间的互联互通提供了统一的分布式通信能力，为设备之间的无感发现和零等待传输创造了条件。开发者只需聚焦于业务逻辑的实现，无需关注组网方式与底层协议。

本文源于HarmonyOS官方教程https://developer.huawei.com/consumer/cn/training/course/introduction/C101635908637340943

如有侵权，联系helloc2333@163.com删除。

HarmonyOS 内核

linux、UNIX内核不适合于小型化设备，需要资源多，启动时间长，非实时操作系统。

HarmonyOS有三种内核，LiteOS-A,LiteOS-M,Linux 内核。

进程

HarmonyOS 内核中的进程采用抢占式调度机制，支持时间片轮转调度方式。

HarmonyOS内核进程有0-31的进程优先级，用户进程可配置的优先级为10-31。

用户态根进程init由内核态创建，其他用户进程均由init进程fork而来。

Zombies ：保留PID，但是不占用任何资源。

对于多核 CPU 而言， HarmonyOS 通过自旋锁实现进程间防冲突，任务的重新分配实现多核处理器之间的负载均衡。

自旋锁：进程二持续的等待进程一释放资源，进程二不断的循环等待进程一释放资源。

负载均衡：多核心之间使用负载均衡来重新分配任务。

线程

对于多线程的场景， HarmonyOS 内核管理线程靠任务池和就绪队列，执行靠调度算法。

线程使用的并不是自旋锁。

HarmonyOS 线程常用的两种锁：

• 互斥锁：未得到资源的线程将不会占用 CPU 资源。

  

• 读写锁： 也称“共享 - 独占锁”适用于读比写多的场景。

  

内存、网络、文件系统

内存管理

• Hi3861 芯片使用 LiteOS-M 内核，LiteOS-M不支持多进程，无 MMU （ Memory Management Unit ，内存管理单元），内存管理依赖应用程序的 malloc 方法与 free 方法。

• Hi3516 ， Hi3518 芯片使用 LiteOS-A 内核，有 MMU 。

  

• HarmonyOS 的内存分为四个区域：代码区，静态区，栈区，堆区。

• HarmonyOS 将内存分为用户空间与内核虚拟空间，通过 MMU 对虚拟内存进行管理调度。

网络机制

网络模块实现了 TCP/IP 协议栈基本功能，提供标准的 POSIX socket 接口。

当前系统使用 LwIP 提供网络能力。

文件系统（LiteOS-A）

VFS

Virtual File System （虚拟文件系统），它不是一个实际的文件系统，而是一个异构文件系统之上的软件粘合层，为用户提供统一的类 Unix 文件操作接口。

HarmonyOS NFS

在 HarmonyOS 中，创建 NFS 目录与文件默认使用 777 权限，当前 NFS 可支持 TCP 与 UDP 两种传输层协议，默认使用 TCP 。

• 补充： 777 权限，三个数字分别对应三种用户：文件所有者，群组用户，其他用户。每一个数字可以表示执行 =1 ，写 =2 ，读 =4 权限的情况。

FAT

• 在 HarmonyOS 中，文件配置表有 FAT12 ， FAT16 ， FAT32 这三种，它将硬盘分为 MBR（ Master Boot Record ，主引导分区）， DBR （ Dos Boot Record ，操作系统引导记录区）， FAT ， DIR （ Directory ，根目录区）， DATA （数据区）五个区。
• FAT 特性：支持多种介质，尤其在可移动存储设备上使用广泛。 FAT 具有代码量和资源占用小、可裁切、支持多种物理设备、读写指针不分离的特性。

软件定时器

软件定时器的功能：制定任务循环执行的周期，用作任务的延迟执行。
在 HarmonyOS 内， swtmrTask.usTaskPrio = 0 ，软件定时器拥有最高的线程优先级。

信号量

信号量：一个资源最多可以支持多少个任务同时进行访问。

• 信号量可以实现任务间通信，它可以实现任务间同步或共享资源的互斥访问。
• HarmonyOS 的信号量最大个数 1024 ，使用信号量的任务队列是一个双向链表。

事件运行机制

• 事件 Event 是一种任务间通信机制，常用于任务之间的同步。任务执行前需要满足一些前提条件。
• 事件模型：一对多模型与多对多模型。

锁的优先级翻转

假设有三个任务，任务 1 高优先级，任务 2 中优先级，任务 3 低优先级。

消息队列

• 消息队列常用于消息的异步处理，消息的缓冲。对于任务间通信的场景，消息发送方与消息接受方实现解耦。
• HarmonyOS 消息队列最大消息内容 1KB ， POSIX 最大消息内容 64 字节；HarmonyOS 消息队列最大消息数量256 个， POSIX 最大消息数量 16 个。

# 设备：联想拯救者 2021 R7000P 3060

CPU ：AMD 5800H

显卡 ：3060

系统：WIN10 + Ubuntu20.04.3 双系统

开始下列步骤前，先到Win 10 中把显卡模式 换成 独显直连！！！

由于在解决问题的过程中我参考的文章解决办法有点多，导致最后解决问题时，已经想不起来很多细致的步骤了，只能记得下面的一些大概的步骤，具体安装显卡驱动最好再参考其他人的文章。

• sudo gedit /etc/modprobe.d/blacklist.conf 禁用自带的nouveau nvidia驱动
  • 在最后添加如下内容

blacklist nouveau  
options nouveau modeset=0 
blacklist ideapad_laptop

• 保存退出更新 sudo update-initramfs -u

• 重启电脑：sudo reboot

• 重启后查看是否已经将自带的驱动屏蔽了，输入以下代码 lsmod | grep nouveau
  没有结果输出，则表示屏蔽成功

• sudo service lightdm stop ，如果显示没有找不到lightdm ，先安装后，再执行这一条指令

• sudo add-apt-repository ppa:graphics-drivers/ppa

• sudo apt-get update

• 使用ubuntu-drivers devices 查看系统推荐的驱动版本
  

• 我这里推荐的是driver : nvidia-driver-470 - distro non-free recommended

• 点击左下角的九宫格，在搜索框里输入driver ，找到附加驱动 ，然后找到刚才推荐的显卡驱动版本， 选中---应用更改---关闭-重启
  

• 使用nvidia-smi 查看显卡安装是否完成，出现NVIDIA驱动版本应该就安装正确了。
  

此时打开设置里的关于查看系统信息，图形就变成NVIDIA Corporation 了。

然后开始解决Ubuntu中无法在设置中拉动亮度条调节亮度的问题

参考文章：拯救者R7000P(R7 4800H + RTX2060 ) 安装Ubuntu18.04与20.04后 屏幕亮度无法调节的解决办法

解决方案：

前提：电脑切换独显直连模式

1. 进入计算机根目录 /etc/default/，进入改目录后找到并编辑grub
2. 打开grub文件后在其中找到GRUB_CMDLINE_LINUX=" "，找到这一段后将整段改为GRUB_CMDLINE_LINUX="acpi_backlight=vendor"
3. 修改结束后保存修改后的文件，执行sudo update-grub来完成更新，如果没有Terminal没有出现报错则说明这一步顺利完成.
4. 进入目录/usr/share/X11/xorg.conf.d，打开10-nvidia.conf，在文件内容的后面加上如下内容.

Section "Device"
    Identifier "Device0"
    Driver "nvidia"
    VendorName "NVIDIA Corporation"
    Option "RegistryDwords" "EnableBrightnessControl=1"
EndSection

5. 停止ideapad_laptop驱动，进入/etc/modprobe.d/blacklist.conf，在文件内容的最后加上blacklist ideapad_laptop
6. 重启检查问题是否被解决.

Python爬虫教程一

什么叫爬虫？

——通过编写程序，模拟浏览器上网，然后让其去互联网上抓取数据的过程。

爬虫的价值？

爬虫合法性

——法律不被禁止

——具有违法风险

——善意爬虫 恶意爬虫

恶意爬虫：

1. 爬虫干扰了被访问网站的正常运营；
2. 爬虫抓取了受到法律保护的特定类型的数据或信息；

避免编写爬虫时进入局子:

1. 时常优化自己的程序，避免干扰被访问网站的正常运行；
2. 使用传播爬取到的数据时，审查抓取到的内容，若有涉及用户隐私或商业机密等内容，需及时停止爬取和传播；

爬虫教程的分类

• 通用爬虫

  抓取系统的重要组成部分。（搜索引擎）抓取的是互联网中一整张的页面数据。

• 聚焦爬虫

  是建立在通用爬虫的基础之上。

  特点是只抓取页面中特定的局部内容，筛选整张页面数据中的有用数据。

• 增量式爬虫（重点）

  监测网站中数据更新的情况。

  只会抓取网站中最新更新出来的数据。

爬虫中的矛与盾

反爬机制

• 门户网站通过制定相应的策略技术手段，防止爬虫程序进行网站数据的爬取。

反反爬策略

• 爬虫程序通过制定相关的策略或者技术手段用来破解门户网站中具备的反爬机制，从而获取门户网站中相关的数据。

反爬虫机制

• robots.txt协议

  君子协议：即网站所有者可以规定那些数据可以被爬虫爬取，哪些数据不能被爬取。

  https://www.bilibili.com/robots.txt

http协议

• 概念：服务器和客户端之间进行数据交互的一种形式。
• 常用请求头信息
  • user-agent :请求载体的身份标识
  • Connection: 请求完毕后，是断开连接还是保持连接
• 常用响应头信息
  • Content-Type: 服务器响应会客户端的数据类型

https协议

• 表示安全的http（超文本传输）协议，服务器与客户端进行交互的数据进行加密。

• 加密方式

  • 对称秘钥加密

    客户端制定某种加密规定，对传给服务器的数据进行加密，然后发送加密后的数据和秘钥发给服务器，服务器再用秘钥对加密数据进行解析。

    缺点：容易在传输过程中被拦截窃取。

  • 非对称秘钥加密

    使用两把锁，一把“私有秘钥”，一把“公开秘钥”。

    1. 服务器A创建秘钥对
    2. 发送公钥给客户端B
    3. B客户端按照公钥进行加密
    4. 把加密的消息发送给A
    5. A使用私钥对消息进行解密

    缺点：

    • 效率低
    • 公钥被拦截后，被第三方篡改公钥，无法保证客户端拿到的公钥是服务器发送的

  • 证书秘钥加密

    服务器和客户端充分信任一个中间的证书认证机构。

    1. 服务器的开发者携带公开密钥，向数字证书认证机构提出公开密钥的申请
    2. 数字证书认证机构认清申请者的身份后，审核通过，对申请者的公开密钥进行数字签名，然后分配这个已签名的公开密钥，将密钥放在证书里，绑定在一起。
    3. 服务器将这份数字证书发送给客户端，因为客户端也认证书机构，通过数字证书中的数字签名来验证公钥的真伪，保证服务器传过来的公钥是真实的。
    4. 确认无误，客户端使用公钥对报文进行加密后发送，服务器收到以后再使用自己的私钥进行解密。

---

---

Python爬虫教程二

requests模块

• urllib模块
• requests模块

——requests模块：python中原生的一款基于网络请求的模块，功能非常强大，简单便捷，效率高；

——作用：用来模拟浏览器发请求。

——使用方法：（requests模块的编码流程）

• 指定URL
• 发起请求
• 获取响应数据
• 持久化存储

环境安装：

• pip install requests

实战编码：

• 需求:爬取搜狗首页数据

• coding

  # -*- coding:utf-8 -*-
  # 需求：爬取搜狗首页的页面数据
  import requests
  if __name__=="__main__":
      #step_1：指定URL
      url='https://www.sogou.com/'
      #step_2：发起请求
      #get方法返回一个响应对象
      response=requests.get(url=url)
      #setp_3：获取响应数据,text返回的是字符串形式的响应数据，对应的是网页页面的源代码,
      page_text=response.text
      #在Terminal打印获取的响应数据
      print(page_text)
      #step_4：持久存储
      #sogou.html 会丢失页面的样式，但是不重要，有数据就行
      with open('./sogou.html','w',encoding='utf-8') as fp:
          fp.write(page_text)
      print('爬取数据结束！！！')

实战案例

——需求

爬取搜狗指定词条对应的搜索结果页面（简易网页采集器）

• UA检测

• UA伪装

  # -*- coding:utf-8 -*-
  #需求：简易网页采集器
  #
  
  #反爬机制：
  # UA检测：门户网站的服务器会监测对应请求的载体身份标识，若发现载体为浏览器，则是正常用户发起的请求
  #但是若发现不是浏览器，则该请求为不正常的请求（爬虫），服务器很可能会拒绝该次请求
  
  # UA伪装：让爬虫对应的请求载体身份标识伪装成某一款浏览器
  
  #UA ：User-Agent() (请求载体的身份标识，如浏览器)
  import requests
  if __name__=="__main__":
      #UA伪装：将对应的User-Agent封装到字典中
      header={
          'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:93.0) Gecko/20100101 Firefox/93.0'
      }
      url='https://www.sogou.com/web'
      #处理url携带的参数：封装到字典中
      kw=input('enter a word :')#此时词条变成动态的了
      param={
          'query':kw
      }
      #发起请求
      #此时请求对应的url具有动态参数
      response=requests.get(url=url,params=param,headers=header)
      page_text=response.text
      filename=kw+'.html'
      with open(filename,'w',encoding='utf-8') as fp:
          fp.write(page_text)
      print(filename," 保存成功！！！")

破解百度翻译

• post请求（携带了参数）
• 响应数据是一组json数据

# -*- coding:utf-8 -*-
#需求：破解百度翻译
#百度翻译具有局部刷新的特性，文本框中录入数据之后会自动刷新,ajax动态加载

#网页检查-network-右侧选中XHR类型请求-此时左侧显示的就是ajax动态加载的数据

#百度翻译ajax动态加载的内容就是我们需要的数据（翻译结果）


import requests
import json
if __name__=="__main__":
    #指定URL，网页检查-消息头-POST查看
    post_url='https://fanyi.baidu.com/sug'
    #post请求参数的处理,设置为动态参数
    word=input('enter what you need translate : ')
    data={
        'kw':word
    }
    #进行UA伪装
    header={
        'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:93.0) Gecko/20100101 Firefox/93.0'
    }
    

    #请求发送
    response=requests.post(post_url,data=data,headers=header)
    #获取响应数据
    #json返回的方法是一个字典对象obj，如果确认服务器的响应是json类型，才能使用json()方法
    # 类型查看可以在：网页检查-消息头-响应头-Content-Type: application/json
    dic_obj=response.json()
    #print(dic_obj)

    #持久化存储
    filename=word+'.json'
    fp=open(filename,'w',encoding='utf-8')
    json.dump(dic_obj,fp=fp,ensure_ascii=False)
    print('OVER !!')

爬取豆瓣电影分类排行榜 https://movie.douban.com/中电影详情数据

# -*- coding:utf-8 -*-
#需求：爬取豆瓣电影分类排行榜 https://movie.douban.com/中电影详情数据
#在排行榜页面往下滑动，网页链接不改变，当滑到底时继续滑动会刷新出新的数据，用的也是ajax动态加载
#网页检查-network-右侧选中XHR类型请求-此时左侧显示的就是ajax动态加载的数据

import requests
import json
if __name__=="__main__":
    #指定url
    url = 'https://movie.douban.com/j/chart/top_list'
    param={
        'type':'5',
        'interval_id': '100:90',
        'action':'',
        'start':'0',#从服务器数据库中第n部电影开始
        'limit':'20',#取20个
    }
    #UA伪装：将对应的User-Agent封装到字典中
    header={
        'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:93.0) Gecko/20100101 Firefox/93.0'
    }

    #发起请求
    response=requests.get(url=url,params=param,headers=header)
    #服务器的响应是json类型，使用json()方法

    list_data=response.json()

    fp=open('./douban.json','w',encoding='utf-8')
    json.dump(list_data,fp=fp,ensure_ascii=False)
    print('OVER !!')

爬取肯德基餐厅查询 http://www.kfc.com.cn/kfccda/index.aspx中指定地点的餐厅数

爬取国家药品监管总局中基于中华人民共和国化妆品生产许可证相关数据

• 请求的一个页面中有可能包含动态加载的数据（可能是ajax动态加载），不能直接由页面的url链接请求得到
• ajax请求得到的响应json格式的数据可复制到 json格式化校验网站查看
• 想要得到每组数据对应的详情url ，可以在json响应中找到其对应的ID，拼接用来查询详情的域名结合，便可得到详情页的URL
• 详情页的企业数据也是动态加载出来的
  • 观察后发现：
    • 所有的post请求的URL都是一样的，只有参数ID值是不同的
    • 如果我们可以批量获取多家企业的ID后，就可以将ID与URL形成一个完整的详情页数据的ajax请求URL。

---

---

python爬虫教程三

数据解析

• 聚焦爬虫：爬取页面中指定的页面内容。
  • 编码流程
    1. 指定URL
    2. 发起请求
    3. 获取响应数据
    4. 数据解析
    5. 持久化存储

• 数据解析分类：

  • 正则
  • bs4
  • xpath (***)

• 数据解析原理概述

  解析的局部的文本内容都会在标签之间或者标签对应的属性中进行存储。

  1. 指定标签的定位。

  2. 标签或者标签对应的属性中存储的数据值进行提取(解析)。

正则表达式

• 正则练习

---

需求：爬取糗事百科中糗图板块下的所有糗图图片

# -*- coding:utf-8 -*-

#需求：爬取糗事百科中糗图板块下的一张糗图图片
import requests
if __name__=="__main__":
    headers = {
        'User-Agent':'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:93.0) Gecko/20100101 Firefox/93.0'
    }
    url = 'https://pic.qiushibaike.com/system/pictures/12486/124869891/medium/HH4TOMZKZ1XETGYB.jpg'
    #content 返回的是二进制形式的图片数据
    #text (字符串)   content (二进制)  json() (对象)
    imgdata=requests.get(url=url).content

    with open('./qiutu.jpg','wb') as fp:
        fp.write(imgdata)

# -*- coding:utf-8 -*-

#需求：爬取糗事百科中糗图板块下的所有糗图图片
import requests
import re
import os
if __name__=="__main__":
    #创建一个文件夹用来保存所有图片
    if not os.path.exists('./qiutuLibs'):
        os.makedirs('./qiutuLibs')

    headers = {
        'User-Agent':'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:93.0) Gecko/20100101 Firefox/93.0'
    }
    url = 'https://www.qiushibaike.com/imgrank'

    #使用通用爬虫对url对应的一整张页面进行爬取
    page_text=requests.get(url=url,headers=headers).text
    #使用聚焦爬虫将页面中所有的图进行提取
    #在网页代码中找到图片对应的代码部分
    # <div class="thumb">

    # <a href="/article/124823437" target="_blank">
    # <img src="//pic.qiushibaike.com/system/pictures/12482/124823437/medium/E4R7L3PXE17UVETV.jpg" alt="糗事#124823437" class="illustration" width="100%" height="auto">
    # </a>
    # </div>

    #提取上面代码中的 URL ： //pic.qiushibaike.com/system/pictures/12482/124823437/medium/E4R7L3PXE17UVETV.jpg
    ex = '<div class="thumb">.*?<img src="(.*?)" alt.*?</div>'
    #如果正则作用到正则解析，使用的一定是re.S
    img_src_list=re.findall(ex,page_text,re.S)
    #print(img_src_list)
    for src in img_src_list:
        #拼接出一个完整的图片地址
        src = 'https:'+ src
        #请求到了图片的二进制数据
        img_data=requests.get(url=src,headers=headers).content
        #生成图片名称
        img_name=src.split('/')[-1]
        imgPath='./qiutuLibs/'+img_name
        with open(imgPath,'wb') as fp:
            fp.write(img_data)
            print(img_name," 图片下载成功！！\n")

• 爬取多个页面的图片

# -*- coding:utf-8 -*-

#需求：爬取糗事百科中糗图板块下的所有糗图图片
import requests
import re
import os
if __name__=="__main__":
    #创建一个文件夹用来保存所有图片
    if not os.path.exists('./qiutuLibs'):
        os.makedirs('./qiutuLibs')

    headers = {
        'User-Agent':'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:93.0) Gecko/20100101 Firefox/93.0'
    }
    #设置一个通用的URL模板（可切换页面）
    url = 'https://www.qiushibaike.com/imgrank/page/%d/'
    #page_num=2
    for page_num in range(1,3):
        #对应页面的URL
        new_url=format(url%page_num)

        #使用通用爬虫对url对应的一整张页面进行爬取
        page_text=requests.get(url=new_url,headers=headers).text
        #使用聚焦爬虫将页面中所有的图进行提取
        #在网页代码中找到图片对应的代码部分
        # <div class="thumb">

        # <a href="/article/124823437" target="_blank">
        # <img src="//pic.qiushibaike.com/system/pictures/12482/124823437/medium/E4R7L3PXE17UVETV.jpg" alt="糗事#124823437" class="illustration" width="100%" height="auto">
        # </a>
        # </div>

        #提取上面代码中的 URL ： //pic.qiushibaike.com/system/pictures/12482/124823437/medium/E4R7L3PXE17UVETV.jpg
        ex = '<div class="thumb">.*?<img src="(.*?)" alt.*?</div>'
        #如果正则作用到正则解析，使用的一定是re.S
        img_src_list=re.findall(ex,page_text,re.S)
        #print(img_src_list)
        for src in img_src_list:
            #拼接出一个完整的图片地址
            src = 'https:'+ src
            #请求到了图片的二进制数据
            img_data=requests.get(url=src,headers=headers).content
            #生成图片名称
            img_name=src.split('/')[-1]
            imgPath='./qiutuLibs/'+img_name
            with open(imgPath,'wb') as fp:
                fp.write(img_data)
                print(img_name," 图片下载成功！！\n")

bs4 进行数据解析

• 数据解析的原理

  • 1. 标签定位
    2. 提取标签、标签属性中存储的数据值

  • bs4 数据解析的原理

    1. 实例化个BeautifulSoup对象，并且将页面源码数据加载到该对象中
    2. 通过调用BeautifulSoup对象中相关的属性或方法进行标签定位和数据提取

  • 环境安装

    • pip install bs4
    • pip install lxml

  • 如何实例化BeautifulSoup对象：

    • form bs4 import BeautifulSoup

    • 对象的实例化：

      1. 将本地的html 文档中的数据加载到该对象中

         import requests
         from bs4 import BeautifulSoup
         if __name__=="__main__":
             #将本地的html文件加载到该对象中
             fp = open('./test.html','r',encoding='utf-8')
             soup=BeautifulSoup(fp,'lxml')
             print(soup)

      2. 将互联网上获取的页面源码加载到该对象中

      #将互联网上获取的页面源码加载到该对象中
      page_text = response.text
      soup=BeautifulSoup(page_text,'lxml')

  • 提供的用于数据解析的方法和属性

    soup.tagName：返回的是html中第一次出现的tagName标签
    print(soup.find('tagName'))：等价于print(soup.tagName)
    #属性定位
    soup.find('div',class_='song'):#class后面有下划线，是因为class_是参数名称，不加_就变成关键字了
        
    soup.find_all(‘tagName’)：find_all返回,soup页面源码中所有‘tagName’页标签所包含的数据（列表）
    
    soup.select('某种选择器(id,class,标签...选择器)')：select返回的是一个列表
    #层级选择器
    soup.select('.tang > ul > li > a')[0]：定位到<ul> 下 <li> 标签 下 <a>标签中的第一个
    或者
    由于<a>不是<ul>的直接子标签，还可写成：
    soup.select('.tang > ul a')[0] ：空格表示多个层级，> 表示一个层级
    
    
    

  • 获取标签之间的文本数据

    • soup.a.text/string/get_text()
    • 这几种方法的区别
      • text/get_text() 可以获取一个标签中的所有文本内容
      • string ：只可以获取该标签下面直系的文本内容
      • 例如：soup.find('div',class_='song').string
      • soup.find('div',class_='song').text
      • soup.find('div',class_='song').get_text()

  • 获取标签中的属性值

    • soup.a['href'] : 提取 标签中属性为‘href’的值

bs4解析案例提取网页中的三国演义https://sanguo.5000yan.com/：

• 首页页面：

• 章节详情页：

• 爬取每一个章节的文字，解析出来后，写入到同一个文件当中

# -*- coding:utf-8 -*-
import requests
from bs4 import BeautifulSoup
#需求:爬取三国演义小说的章节标题和章节内容https://sanguo.5000yan.com/

if __name__=="__main__":
    #对首页的页面数据进行爬取
    url='https://sanguo.5000yan.com/'
    headers={
        'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:93.0) Gecko/20100101 Firefox/93.0'
    }
    page_text_origin = requests.get(url=url,headers=headers).text
    ##对编码格式为utf-8方式读取
    page_text=page_text_origin.encode('iso-8859-1').decode('utf-8')

    #在首页中解析出章节的标题和详情页的url
    #1.实例化BeautifulSoup对象，需要将页面源码数据加载到该对象中
    soup=BeautifulSoup(page_text,'lxml')
    #解析章节标题
    li_list=soup.select('.sidamingzhu-list-mulu > ul > li')

    fp=open('./sanguo.txt','w',encoding='utf-8')

    for li in li_list:
        title=li.a.string
        detail_url=li.a['href']
        #对详情页发起请求，解析出章节的内容
        detail_page_text_origin=requests.get(url=detail_url,headers=headers).text
        #编码格式设置为utf-8方法
        detail_page_text=detail_page_text_origin.encode('iso-8859-1').decode('utf-8')

        #解析出详情页中相关的章节内容
        detail_soup = BeautifulSoup(detail_page_text,'lxml')
        div_tag=detail_soup.find('div',class_='grap')
        #解析到了章节的内容
        context=div_tag.text
        fp.write(title+':'+context+'\n')
        print(title,'爬取成功！！\n')
       
  

xpath 解析

最常用且最便捷高效的一种解析方式。通用性。解析数据首选。

• xpath 解析原理：

  • 1. 实例化一个etree 对象，且需要将被解析的页面源码数据加载到该对象中；
    2. 调用etree 对象中的xpath方法结合xpath表达式实现标签的定位和内容的捕获。

• 环境的安装

  • pip install lxml

• 如何实例化一个etree 对象

  • 1. 将本地的html文档中的源码数据加载到etree 对象中；

       tree=etree.parse(filepath)

    2. 可以将从互联网上获取的源码数据加载到该对象中；

       tree=etree.HTML('page_text')

  • xpath(‘xpath表达式’)

    • /: 表示的是从根节点开始定位，表示的是一个层级；

      r=tree.xpath('/html/body/div')

    • // : 表示的是多个层级；

      r=tree.xpath('/html/body/div')
      #
      r=tree.xpath('/html//div')
      #
      r=tree.xpath('//div')#可以表示从任意位置开始定位

    • 属性定位：//div[@class='song'] tag[@attrName="attrValue"]

    • 索引定位：

      #找到class=song属性下标签列表中的第三个<p>标签中的内容，索引从1开始
      r=tree.xpath('//div[@class="song"]/p[3]')
      #返回class=tang中，第三个<li>标签中<a>中所包含的内容文本，是一个列表
      r=tree.xpath('//div[@class="tang"]//li[3]/a/text()')
      #如果只要其中的字符串，改为：
      r=tree.xpath('//div[@class="tang"]//li[3]/a/text()')[0]

    • 取文本：

      • /text()获取标签中直系的文本内容
      • //text()标签中非直系的文本内容（所有的文本内容）

      #返回class=tang中，第三个<li>标签中<a>中所包含的内容文本，是一个列表
      r=tree.xpath('//div[@class="tang"]//li[3]/a/text()')
      #如果只要其中的字符串，改为：
      r=tree.xpath('//div[@class="tang"]//li[3]/a/text()')[0]
      #获取<li><b>文本</b></li>中的内容
      r=etree.xpath('//li[7]//text()')

    • 取属性：

      /@attrName ==> img/@src

      #获取<img>标签中的名为src的属性值
      r=etree.xpath('//div[@class="song"]/img/@src')

xpath 案例：爬取58二手房中房源信息(由于有验证码，所以改为获取三国演义中的章节标题信息)

https://sanguo.5000yan.com/

# -*- coding:utf-8 -*-
import requests
from lxml import etree
# 需求: 爬取解析三国演义中章节信息

if __name__=="__main__":
    #爬取页面源码数据
    url="https://sanguo.5000yan.com/"
    #UA伪装
    headers={
        'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:93.0) Gecko/20100101 Firefox/93.0'
    }
    page_text_origin=requests.get(url=url,headers=headers).text
    page_text=page_text_origin.encode('iso-8859-1').decode('utf-8')
    #数据解析
    tree=etree.HTML(page_text)
    #存储的就是li标签的源码
    li_list=tree.xpath('//ul[@class="paiban"]/li')
    #print(li_list)

    fp=open('sanguo_title.txt','w',encoding='utf-8')
    for li in li_list:
        #"."点表示当前标签局部的源码内容,局部解析,列表元素只有一个，所以取[0]
        title=li.xpath('./a/text()')[0]
        print(title)
        fp.write(title+'\n')

xpath 案例：4K图片解析获取

# -*- coding:utf-8 -*-
import requests
from lxml import etree
import os
# 需求: 解析下载图片

if __name__=="__main__":
    #爬取页面源码数据
    url="https://pic.netbian.com/4kmeinv/"
    #UA伪装
    headers={
        'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:93.0) Gecko/20100101 Firefox/93.0'
    }
    page_text_origin=requests.get(url=url,headers=headers)
    #手动设定响应数据的编码格式
    #page_text_origin.encoding='utf-8'#不一定有效
    page_text=page_text_origin.text
    #数据解析
    tree=etree.HTML(page_text)

    li_list=tree.xpath('//ul[@class="clearfix"]/li')
    #print(li_list)

    if not os.path.exists('./piclibs'):
        os.mkdir('./piclibs')

    for li in li_list:
        #"."点表示当前标签局部的源码内容,局部解析;列表元素只有一个，所以取[0]
        img_src='https://pic.netbian.com/'+li.xpath('./a/img/@src')[0]
        img_name=li.xpath('./a/img/@alt')[0]+'.jpg'
        #通用处理中文乱码的解决方案
        img_name=img_name.encode('iso-8859-1').decode('gbk')
        #print(img_name,img_src)

        #图片持久化存储
        img_data=requests.get(url=img_src,headers=headers).content
        
        img_path='piclibs/'+img_name
        with open(img_path,'wb') as fp:
            fp.write(img_data)
            print(img_name,'下载成功！！')

xpath 案例：解析出全国所有城市的名称

# -*- coding:utf-8 -*-
import requests
from lxml import etree
import os
# 需求：解析出所有城市的名称https://www.aqistudy.cn/historydata/

if __name__=="__main__":
    #爬取页面源码数据
    url="https://www.aqistudy.cn/historydata/"
    #UA伪装
    headers={
        'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:93.0) Gecko/20100101 Firefox/93.0'
    }
    page_text_origin=requests.get(url=url,headers=headers).text

    tree=etree.HTML(page_text_origin)
    # host_li_list=tree.xpath('//div[@class="bottom"]/ul/li')
    # #print(host_li_list)
    # all_city_names=[]
    # #解析热门城市的名称
    # for li in host_li_list:
    #     host_city_name=li.xpath('./a/text()')[0]
    #     #print(host_city_name)
    #     all_city_names.append(host_city_name)


    # #解析全部城市的名称
    # all_city_list=tree.xpath('//div[@class="bottom"]/ul/div[2]/li')
    # for li in all_city_list:
    #     city_name=li.xpath('./a/text()')[0]
    #     all_city_names.append(city_name)

    # print(all_city_names,'\n',len(all_city_names))



    #解析到热门城市和所有城市对应的a标签
    #热门城市对应的标签层级关系：//div[@class="bottom"]/ul/li/a
    #全部城市对应标签层级关系： //div[@class="bottom"]/ul/div[2]/li/a
    #热门+全部城市一次性解析到列表，综合上面两个步骤
    a_list=tree.xpath('//div[@class="bottom"]/ul/li | //div[@class="bottom"]/ul/div[2]/li')
    citys_name=[]
    for a in a_list:python
        city_name=a.xpath('./a/text()')[0]
        citys_name.append(city_name)

    print(citys_name,'\n',len(citys_name))

作业：爬取站长素材中的简历模板

---

---

python爬虫教程四

验证码识别

• 反爬机制：验证码。

• 识别验证码图片中的数据用于模拟登录操作。

• 识别验证吗的操作：

  • 人工肉眼识别（效率低）
  • 第三方自动识别（推荐使用）
    • 云打码（没了）

Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.

Quick Start

Create a new post

$ hexo new "My New Post"

More info: Writing

Run server

$ hexo server

More info: Server

Generate static files

$ hexo generate

More info: Generating

Deploy to remote sites

$ hexo deploy

More info: Deployment

一、标题

---

使用#表示标题

一号标题

二号标题

三号标题

四号标题

五号标题

六号标题

二、分割线

---

---

三、斜体和粗体

使用* 和** 分别表示斜体和粗体，删除线使用两个~表示：

斜体

粗体

粗体

有斜又粗

• 扩展

删除线使用两个”~” 表示，例如：

这是需要删除的文字

四、超链接和图片

超链接和图片的写法类似，图片仅在超链接前多了一个！，一般是 [文字描述] (链接)

[第一种写法] (https://www.baidu.com)

[第二种写法] [www.baidu.com]

图片的话按照如下写法：

五、无序列表

使用 ‘-‘、’+’ 、’*’

表示无序列表，前后留一行空白，可嵌套，例如：

• 一层

  • 二层

    • 三层

    • 四层

      • 五层
      • 六层

• 一层

六、有序列表

使用 ‘1. ‘ (点号后面有一个空格)表示有序列表，可嵌套，例如：

1. 一层
2. 二层
   1. 二层
   2. 三层
      1. 三层
      2. 四层
   3. 五层
3. 六层

七、文字引用

使用 ‘>’ 表示，可以有多个 ‘ > ‘ ，表示层次更深，例如：

第一层

第二层

第三层

第一层

八、行内代码块

使用 `表示，这个符号位于键盘ESC下方，在英文格式下输入, 例如：

行内代码块

很多字符需要使用反斜杠 \ 进行转义

九、代码块

连续输入三个``` ,这个符号位于键盘ESC下方，在英文格式下输入。

#include <iostream>
using namesapce std;
int main(){
    std::cout<<"Hello World!"<<std::endl;
    return 0;
}

十、表格

|商品|数量|单价| 结果如下

商品	数量	单价

十一、流程图

Typora支持三类流程图：

• sequence
• flow
• mermaid

首先输入```,然后回车，选择语言为 sequence ,编写如下代码，可得：

UML时序图源码样例：

对象A->对象B: 对象B你好吗?（请求）
Note right of 对象B: 对象B的描述
Note left of 对象A: 对象A的描述(提示)
对象B-->对象A: 我很好(响应)
对象A->对象B: 你真的好吗？

对于 flow ：

主要的语法为 name=>type: describe，其中 type 主要有以下几种：

• 开始和结束：start end
• 输入输出：inputoutput
• 操作：operation
• 条件：condition
• 子程序：subroutine

st=>start: 开始框
op=>operation: 处理框
cond=>condition: 判断框(是或否?)
sub1=>subroutine: 子流程
io=>inputoutput: 输入输出框
e=>end: 结束框
st->op->cond
cond(yes)->io->e
cond(no)->sub1(right)->op

对于mermaid：

横向流程图源码格式:

graph LR

A[方形] -->B(圆角)

    B --> C{条件a}

    C -->|a=1| D[结果1]

    C -->|a=2| E[结果2]

    F[横向流程图]

竖向流程图源码格式：

graph TD

A[方形] -->B(圆角)

    B --> C{条件a}

    C -->|a=1| D[结果1]

    C -->|a=2| E[结果2]

    F[竖向流程图]

UML标准时序图样例：

%% 时序图例子,-> 直线，-->虚线，->>实线箭头

  sequenceDiagram
    participant 张三
    participant 李四
    张三->王五: 王五你好吗？
    loop 健康检查
        王五->王五: 与疾病战斗
    end
    Note right of 王五: 合理 食物 <br/>看医生...
    李四-->>张三: 很好!
    王五->>李四: 你怎么样?
    李四-->王五: 很好!

甘特图样例：

%% 语法示例

        gantt
        dateFormat  YYYY-MM-DD
        title 软件开发甘特图
        section 设计
        需求                      :done,    des1, 2014-01-06,2014-01-08
        原型                      :active,  des2, 2014-01-09, 3d
        UI设计                     :         des3, after des2, 5d
    未来任务                     :         des4, after des3, 5d
        section 开发
        学习准备理解需求                      :crit, done, 2014-01-06,24h
        设计框架                             :crit, done, after des2, 2d
        开发                                 :crit, active, 3d
        未来任务                             :crit, 5d
        耍                                   :2d
    
        section 测试
        功能测试                              :active, a1, after des3, 3d
        压力测试                               :after a1  , 20h
        测试报告                               : 48h

十二、数学公式

使用 $表示，其中一个 $ 表示在行内，两个 $ 表示独占一行。

例如 ： $\sum_{i=1}^n a_i=0$

质量守恒公式： $$E=mc^2$$

支持 LaTeX 编辑显示支持，访问 MathJax 参考更多使用方法。
$$
\sum_{i=1}^n a_i=0
$$

$$
E=mc^2
$$

1 Typora数学公式汇总

[2] 使用Typora添加数学公式

[3] Typora数学公式大全

2的n次方表示：2ⁿ

2<sup>n</sup>

十三、支持HTML标签

例如想要段落的缩进，可以如下：

  不断行的空白格 或 
  半方大的空白 或 
  全方大的空白 或 

页面内的跳转：

我是一个锚点

点我跳转

十四、空行或空格

• 空行

1233333

<br/>

89956665

效果：

1233333

89956665

• 空格

  4578454&nbsp;dgaugduw

  效果：

  4578454  gaugduw

配置ssh免密登录云服务器

• 若本地电脑上之前没生成过ssh key，则需先通过执行ssh-keygen -t rsa -P ""生成 ssh key
• ssh-copy-id root@远程IP地址 将本地公钥id_rsa.pub追加到远程主机的authorized_keys文件集中

• ssh root@远程IP地址 ,此时不用输入密码即可登录到远程主机

---

使用SSH上传文件及文件夹到Linux服务器的方法

参考文献：https://help.aliyun.com/knowledge_detail/157164.html?spm=5176.22414175.sslink.14.3ac96cefNS1Eqp

• 上传文件到服务器

  scp [$File_name] [$Username]@[$IP]:[$File]

  - [$File_name]指的是文件的名字。
  - [$Username]指的是服务器的用户名字。
  - [$IP]指的是服务器的IP地址。
  - [$File]指的是指定的服务器目录。

• 上传文件夹到服务器

  scp -r [$Folder] [$Username]@[$IP]:[$File]

  注意：[$Folder]指的是文件夹的名字。在要上传文件夹的前面加-r参数，否则报错。

• 从服务器上下载文件

  scp username@servername:/path/filename /var/www/local_dir（本地目录）

• 从服务器下载整个目录

  scp -r username@servername:/var/www/remote_dir/（远程目录） /var/www/local_dir（本地目录）

注：目标服务器要开启写入权限。

适用于

• 云服务器ECS

使得容器内能够访问宿主机内的文件：

docker run -it -v /宿主机绝对路径目录:/容器内目录 镜像名

例如：

docker run -it -v /home/username/:/root/ image_name

参考文献：https://www.cnblogs.com/sueyyyy/p/10985443.html

Linux软连接的使用

软连接功能是为某一个文件在另外一个位置建立一个链接到这个文件的链接，类似于Windows中的快捷方式。

使用方法：ln -s 源文件/源目录 目标文件/目标目录

例如：

ln -s /usr/local/mysql/bin/mysql /usr/bin

• 硬连接：硬连接通过索引节点进行连接，使多个文件名指向同一个索引节点，允许一个文件拥有多个有效路径名，用户建立硬连接到重要文件，即使删除了其中一个路径下的文件，也不会影响其他路径下的文件。即只删除一个连接不会影响索引节点本身与其他路径的连接，要想真正完全地删除这个文件，只有将其相关的所有的硬连接文件删除。
• 软连接：也称为符号连接，实际上是一个特殊的文件，文件中存储的是连接到的文件的位置信息。如果删除的是源文件，则所有的符号连接将不可用，只删除符号连接不影响源文件。

删除软连接

同删除普通的文件相同rm -rf dir

修改指向的新路径

ln –snf /var/www/test1 /var/test

常用参数

　　-f : 链结时先将与 dist 同档名的档案删除
　　-d : 允许系统管理者硬链结自己的目录
　　-i : 在删除与 dist 同档名的档案时先进行询问
　　-n : 在进行软连结时，将 dist 视为一般的档案
　　-s : 进行软链结(symbolic link)
　　-v : 在连结之前显示其档名
　　-b : 将在链结时会被覆写或删除的档案进行备份
　　-S SUFFIX : 将备份的档案都加上 SUFFIX 的字尾
　　-V METHOD : 指定备份的方式
　　--help : 显示辅助说明
　　--version : 显示版本