Python程序设计快速入门01

柔光的暖阳◎ 2022-09-11 02:20 238阅读 0赞

# Python程序设计入门到考试(Day01) #

> 全系列共计6天，十二章。仅作基础入门到期末考试……

## 第1章 Python语言概述 ##

### 1.python的起源 ###

*  Python由[荷兰][Link 1][数学][Link 2]和[计算机科学][Link 3]研究学会的\[Guido van Rossum\](https://baike.baidu.com/item/Guido van Rossum/3225314) 于1990 年代初设计，作为一门叫做[ABC语言][ABC]的替代品。 Python提供了高效的高级[数据结构][Link 4]，还能简单有效地[面向对象][Link 5]编程。
 *  Python的创始人为荷兰人[吉多·范罗苏姆][Link 6]（Guido van Rossum）。1989年圣诞节期间，在[阿姆斯特丹][Link 7]，Guido为了打发[圣诞节][Link 8]的无趣，决心开发一个新的脚本解释程序，作为[ABC语言][ABC]的一种继承。
 *  Python 2于2000年10月16日发布，稳定版本是Python 2.7。Python 3于2008年12月3日发布，不完全兼容Python 2。
 *  2.x和3.x版本之间的区别：
    
     *  print 函数：python2中的 print 语句没有了，取而代之的是python3中的 **print()** 函数。即`python3中必须用括号将需要输出的对象括起来`。
     *  使用`__future__`模块：Python 3.x引入了一些与Python 2.x不兼容的关键字和特性。在Python 2.x中，可以通过内置的`__future__`模块导入这些新内容。如果你希望在Python 2.x环境下写的代码也可以在Python 3.x中运行，那么建议使用`__future__`模块。
     *  整数除法：在python 2.x中，整数相除的结果是一个整数，把小数部分完全忽略掉，浮点数除法会保留小数点的部分得到一个浮点数的结果。在python 3.x中，对于整数之间的相除，结果也会是浮点数。
     *  Unicode：python2中有基于ASCII的str()类型，可以通过unicode()函数转为Unicode类型，但没有byte类型。在python3中有了。
     *  触发异常：python2中支持新旧两种异常触发语法，但在python3中只支持带括号的语法，否则会触发SyntaxError。
     *  Xrang：在Python 2.x中，经常会用xrange()创建一个可迭代对象，通常出现在“for循环”或“列表、集合、字典推导式”中。在Python 3中，range()的实现方式与xrange()函数相同，所以不存在专用的xrange()（`在Python 3中使用xrange()会触发NameError`）。
 *  Python的[Tiobe排行榜][Tiobe]：

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center]

### 2.Python语言特点 ###

*  Python是一种**简单**、跨平台、开源、免费的解释型\*\*、**面向过程和面向对象**、**可扩展、可嵌入**、\*\*动态数据类型的高级程序设计语言，具有丰富和强大的库。
 *  Python支持命令式编程和函数式编程。
 *  Python常被昵称为胶水语言，能够把用其它语言制作的各种模块（尤其是C/C++）很轻松地联结在一起。
 *  Python的应用领域：

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 1]

### 3.python解释器 ###

*  **直接获得了一个官方版本的解释器：CPython。这个解释器是用C语言开发的，所以叫CPython。在命令行下运行python就是启动CPython解释器**。
 *  **CPython用>>>作为提示符**。
 *  **另外还有其它的解释器：**
    
     *  Jython是运行在Java平台上的Python解释器；
     *  IronPython是运行在微软.Net平台上的Python解释器；
     *  PyPy是另一个Python解释器。

### 4.下载和安装Python软件 ###

1.  打开[python官网][python]，下载相应的版本：

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 2]

1.  运行安装程序；

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 3]

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 4]

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 5]

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 6]

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 7]

*  打开CMD命令行，输入python出现如下图，即为成功。

![在这里插入图片描述][984b765ab9b845c09e487ed9c20c242b.png_pic_center]

>  *  退出上述python运行环境，输入 `exit()` 即可。
> 
> 如果在最开始安装时，没有勾选`Add Python 3.9 to PATH`，在cmd命令行中运行会出现如下：

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 8]

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 9]

*  遇到上述问题，解决方法两种：
    
     *  重装python软件，重装时勾选；
     *  手动配置python环境：

1.  右键 `此电脑` 选择 `属性`，选择 `高级` 选项卡，点击 `环境变量` ；

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 10]

1.  添加个人python安装路径，配置path环境；

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 11]

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 12]

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 13]

1.  在cmd中，运行python。

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 14]

> 至此，python安装配置完成。

--------------------

> 查看Python软件版本

1、在命令窗口中输入python或者输入python -V
    >python -V
    Python 3.9.7
    
    2、在python的交互模式下输入
    >python
    >>>help()
    
    3、在python的交互模式下如下操作：
    >>> import sys
    >>> sys.version
    
    4、在python的交互模式下如下操作：
    >>> import sys
    >>> sys.version_info
            
    5、在python的交互模式下如下操作：
    >>> import sys
    >>> sys.winver
            
    6、在python的交互模式下如下操作：
    >>> import platform
    >>> platform.python_version()

### 5.编写和运行python ###

> **默认编程环境**：IDLE
> 
> **其他常用开发环境：**
> 
>  *  Anaconda3
>  *  PyCharm
>  *  VS Code
>  *  Eclipse+PyDev
>  *  wingIDE
>  *  Eric

#### 1.用文本编辑器编写代码 ####

*  在Python中，需要选择一个合适的文本编辑器编写Python代码，如记事本、Notepad、Notepad++等文本编辑器。下面给出用Notepad++编写Python脚本并在cmd中运行。
 *  打开Notepad++后，新建一个新的文件，然后将代码写入文件并保存。

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 15]

*  对于新建的文件，设置代码所对应的语言实现语法高亮显示：语言⇒P⇒Python。

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 16]

*  打开cmd，并且切换到对应的Python脚本文件所在目录，输入刚建立的完整的文件名来运行脚本。

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 17]

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 18]

#### 2.用命令行格式的Python shell编写代码 ####

*  在IDLE中，如果使用交互式编程模式，那么直接在提示符“>>>”后面输入相应的命令并回车执行即可，如果执行顺利的话，马上就可以看到执行结果，否则会抛出异常。

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 19]

#### 3.用带图形界面的Python Shell编写代码 ####

> 当需要编写大量Python代码行时，就需要通过编写程序（也叫脚本）来避免繁琐。

*  在IDLE中编写、运行程序的步骤：
    
     *  （1）启动IDLE；
     *  （2）选择菜单File > New File创建一个程序文件，输入代码并保存为扩展名为.py的文件。

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 20]

*  （3）选择菜单Run > Run Module F5运行程序，程序运行结果将直接显示在IDLE交互界面上。

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_18_color_FFFFFF_t_70_g_se_x_16_pic_center]

![在这里插入图片描述][f2f87de1f071408a92fdf6622df261bd.png_pic_center]

> 在有些情况下可能需要在命令提示符环境中运行Python程序文件。同时按住 `Win+R，输入CMD`，然后执行Python程序。
> 
> 如果HelloWorld.py不在当前路径下，需要在前面写上路径名，如F:\\Python\\Work\\Hello.py

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_18_color_FFFFFF_t_70_g_se_x_16_pic_center 1]

*  在IDLE中一些比较常用的快捷键如下表所示：

<table> 
 <thead> 
  <tr> 
   <th align="center">加缩进</th> 
   <th align="center">Ctrl+]</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">减缩进</td> 
   <td align="center">Ctrl+[</td> 
  </tr> 
  <tr> 
   <td align="center">加注释</td> 
   <td align="center">Alt+3</td> 
  </tr> 
  <tr> 
   <td align="center">去注释</td> 
   <td align="center">Alt+4</td> 
  </tr> 
  <tr> 
   <td align="center">上一条命令</td> 
   <td align="center">Alt+p</td> 
  </tr> 
  <tr> 
   <td align="center">下一条命令</td> 
   <td align="center">Alt+n</td> 
  </tr> 
  <tr> 
   <td align="center">Enter</td> 
   <td align="center">鼠标选中后进行复制</td> 
  </tr> 
 </tbody> 
</table>

### 6.Python注释 ###

*  Python单行注释
    
     *  井号（\#）常被用作单行注释符号，在代码中使用\#时，它右边的任何数据在程序执行时都会被忽略，被当做是注释。

>>> print('Hello world.')  # 输出Hello world.
    Hello world.

*  Python多行注释
    
     *  在Python中，当注释有多行时，需用多行注释符来对多行进行注释。多行注释用三个单引号’’'或者三个双引号"""将注释括起来，例如：

''' 这是多行注释，用三个单引号 这是多行注释，用三个单引号 这是多行注释，用三个单引号 '''
    print("Hello, World!")

## 第2章 Python语言基础 ##

### 1.python中的变量 ###

>  *  变量存储在内存中的值，这就意味着在创建变量时会在内存中开辟一个空间。
>  *  基于变量的数据类型，解释器会分配指定内存，并决定什么数据可以被存储在内存中。
>  *  因此，变量可以指定不同的数据类型，这些变量可以存储整数，小数或字符。

#### 1.变量赋值 ####

*  Python 中的变量赋值不需要类型声明。
 *  每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。
 *  每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
 *  等号 `=` 用来给变量赋值。
 *  等号 `=` 运算符左边是一个变量名，等号 `=` 运算符右边是存储在变量中的值。例如：

counter = 100 # 赋值整型变量
    miles = 1000.0 # 浮点型
    name = "subei" # 字符串
     
    print(counter)
    print(miles)
    print(name)

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 21]

#### 2.变量的注意事项 ####

> 在定义变量名的时候，需要注意以下问题：

*  变量名必须以字母、汉字或下划线开头，但以下划线开头的变量在Python中有特殊含义；具体如下：
    
    1.  单前导下划线 `_` ：下划线前缀的含义是告知其他程序员：以单个下划线开头的变量或方法仅供内部使用。
    2.  单末尾下划线 `_` ：单个末尾下划线（后缀）是一个约定，用来避免与Python关键字产生命名冲突。
    3.  双前导下划线 `__` ：双下划线前缀会导致Python解释器重写属性名称，以避免子类中的命名冲突（名称修饰），变成“\_类名\_\_变量名”格式。
    4.  双前导和双末尾下划线 `__` ：如果一个名字同时以双下划线开始和结束，则不会应用名称修饰。 由双下划线前缀和后缀包围的变量不会被Python解释器修改。
    5.  单下划线 `_`：单个独立下划线是用作一个名字，来表示某个变量是临时的或无关紧要的。在交互模式下也表示最近一个表达式的值（成功）。
 *  变量名中不能有空格以及标点符号（括号、引号、逗号、斜线、反斜线、冒号、句号、问号等等）；
 *  不能使用关键字作变量名，可以导入keyword模块后使用print(keyword.kwlist)查看所有Python关键字；
    
        >>> import keyword
        >>> print(keyword.kwlist)

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 22]

*  不建议使用系统内置的模块名、类型名或函数名以及已导入的模块名及其成员名作变量名，这将会改变其类型和含义，可以通过dir(**builtins**)查看所有内置模块、类型和函数；
    
     *  注意：dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。
 *  变量名对英文字母的大小写敏感，例如student和Student是不同的变量。

#### 3.Python中的关键字 ####

<table> 
 <thead> 
  <tr> 
   <th>关键字</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>and</td> 
   <td>逻辑运算符。</td> 
  </tr> 
  <tr> 
   <td>as</td> 
   <td>创建别名。</td> 
  </tr> 
  <tr> 
   <td>assert</td> 
   <td>用于调试。</td> 
  </tr> 
  <tr> 
   <td>break</td> 
   <td>跳出循环。</td> 
  </tr> 
  <tr> 
   <td>class</td> 
   <td>定义类。</td> 
  </tr> 
  <tr> 
   <td>continue</td> 
   <td>继续循环的下一个迭代。</td> 
  </tr> 
  <tr> 
   <td>def</td> 
   <td>定义函数。</td> 
  </tr> 
  <tr> 
   <td>del</td> 
   <td>删除对象。</td> 
  </tr> 
  <tr> 
   <td>elif</td> 
   <td>在条件语句中使用，等同于 else if。</td> 
  </tr> 
  <tr> 
   <td>else</td> 
   <td>用于条件语句。</td> 
  </tr> 
  <tr> 
   <td>except</td> 
   <td>处理异常，发生异常时如何执行。</td> 
  </tr> 
  <tr> 
   <td>False</td> 
   <td>布尔值，比较运算的结果。</td> 
  </tr> 
  <tr> 
   <td>finally</td> 
   <td>处理异常，无论是否存在异常，都将执行一段代码。</td> 
  </tr> 
  <tr> 
   <td>for</td> 
   <td>创建 for 循环。</td> 
  </tr> 
  <tr> 
   <td>from</td> 
   <td>导入模块的特定部分。</td> 
  </tr> 
  <tr> 
   <td>global</td> 
   <td>声明全局变量。</td> 
  </tr> 
  <tr> 
   <td>if</td> 
   <td>写一个条件语句。</td> 
  </tr> 
  <tr> 
   <td>import</td> 
   <td>导入模块。</td> 
  </tr> 
  <tr> 
   <td>in</td> 
   <td>检查列表、元组等集合中是否存在某个值。</td> 
  </tr> 
  <tr> 
   <td>is</td> 
   <td>测试两个变量是否相等。</td> 
  </tr> 
  <tr> 
   <td>lambda</td> 
   <td>创建匿名函数。</td> 
  </tr> 
  <tr> 
   <td>None</td> 
   <td>表示 null 值。</td> 
  </tr> 
  <tr> 
   <td>nonlocal</td> 
   <td>声明非局部变量。</td> 
  </tr> 
  <tr> 
   <td>not</td> 
   <td>逻辑运算符。</td> 
  </tr> 
  <tr> 
   <td>or</td> 
   <td>逻辑运算符。</td> 
  </tr> 
  <tr> 
   <td>pass</td> 
   <td>null 语句，一条什么都不做的语句。</td> 
  </tr> 
  <tr> 
   <td>raise</td> 
   <td>产生异常。</td> 
  </tr> 
  <tr> 
   <td>return</td> 
   <td>退出函数并返回值。</td> 
  </tr> 
  <tr> 
   <td>True</td> 
   <td>布尔值，比较运算的结果。</td> 
  </tr> 
  <tr> 
   <td>try</td> 
   <td>编写 try…except 语句。</td> 
  </tr> 
  <tr> 
   <td>while</td> 
   <td>创建 while 循环。</td> 
  </tr> 
  <tr> 
   <td>with</td> 
   <td>用于简化异常处理。</td> 
  </tr> 
  <tr> 
   <td>yield</td> 
   <td>结束函数，返回生成器。</td> 
  </tr> 
 </tbody> 
</table>

--------------------

#### 4.Python代码规范 ####

1.  缩进
    
    1.  类定义、函数定义、选择结构、循环结构、with块，行尾的冒号表示缩进的开始。
    2.  python程序是依靠代码块的缩进来体现代码之间的逻辑关系的，缩进结束就表示一个代码块结束了。
    3.  同一个级别的代码块的缩进量必须相同。
    4.  一般而言，以4个空格为基本缩进单位。
2.  注释
    
    1.  以\#开始，表示本行\#之后的内容为注释。
    2.  包含在一对三引号’’’…’’'或"""…"""之间且不属于任何语句的内容将被解释器认为是注释。
3.  每个import语句只导入一个模块，最好按标准库、扩展库、自定义库的顺序依次导入。
    
        import csv
        import random
        import pands
4.  如果一行语句太长，可以在行尾加上续行符\\来换行分成多行，但是更建议使用括号来包含多行内容。

![在这里插入图片描述][0cb14616a1e24e99ab74c62446d4cc77.png_pic_center]

1.  必要的空格与空行
    
    1.  运算符两侧、逗号后面建议增加一个空格。
    2.  不同功能的代码块之间、不同的函数定义之间建议增加一个空行以增加可读性。
2.  可以使用pip来安装pep8工具，然后使用命令`pep8 test.py`来检查test.py文件中Python代码的规范性。pep8常用的可选参数有–show-source、–first、–show-pep8等等。

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 23]

1.  flake8结合了pyflakes和pep8的特点，可以检查更多的内容，优先推荐使用，使用pip install flake8可以直接安装，然后使用命令flake8 test.py检查test.py中代码的规范性。
2.  也可以使用pip安装pylint，然后使用命令行工具pylint或者可视化工具pylint-gui来检查程序的规范性。

> 安装python3后，没有Scripts目录的解决办法
> 
>  *  设置好python环境变量后，cmd执行命令即可：`python -m ensurepip`。
>  *  之后再在PATH中添加`F:\Python\python3.9.7\Scripts`目录。

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 24]

#### 5.Python文件名 ####

*  `.py`：Python源文件，由Python解释器负责解释执行。
 *  `.pyw`：Python源文件，常用于图形界面程序文件。
 *  `.pyc`：Python字节码文件，无法使用文本编辑器直接查看该类型文件内容，可用于隐藏Python源代码和提高运行速度。对于Python模块，第一次被导入时将被编译成字节码的形式，并在以后再次导入时优先使用“.pyc”文件，以提高模块的加载和运行速度。对于非模块文件，直接执行时并不生成“.pyc”文件，但可以使用py\_compile模块的compile()函数进行编译以提高加载和运行速度。另外，Python还提供了compileall模块，其中包含compile\_dir()、compile\_file()和compile\_path()等方法，用来支持批量Python源程序文件的编译。
 *  `.pyo`：优化的Python字节码文件，同样无法使用文本编辑器直接查看其内容。可以使用“`python –O -m py_compile file.py`”或“`python –OO -m py_compile file.py`”进行优化编译。Python 3.5不再支持.pyo文件。
 *  `.pyd`：一般是由其他语言编写并编译的二进制文件，常用于实现某些软件工具的Python编程接口插件或Python动态链接库。

### 2.Python中的对象 ###

#### 1.Python中的对象和引用 ####

*  Python中的对象就是编程中把数据和功能包装后形成的一个对外具有特定交互接口的内存块。
 *  对象是python语言中最基本的概念，在python中处理的一切都是对象。python中有许多内置对象可供编程者使用，内置对象可直接使用，如数字、字符串、列表、del等；非内置对象需要导入模块才能使用，如正弦函数sin(x)，随机数产生函数random( )等。
    
     *  注：内置对象可以使用dir(**builtins**)来查看。
 *  每个对象都有三个属性分别是：
    
     *  身份(identity)，就是对象在内存中的地址；
     *  类型(type)，用于表示对象所属的数据类型(类)，对象的类型决定了对象可以存储什么类型的值，有哪些属性和方法，可以进行哪些操作；
     *  值(value)，对象所表示的数据。

>>> a=123    # 123创建了一个int(整型)对象，并用a来代表
    >>> id(a)    
    2921335118000	# 身份用这样一串数字表示
    >>> type(a)		# 查看a的类型
    <class 'int'>
    >>> a		# 显示a所表示的数值
    123
    >>>

--------------------

>>> b=6
    >>>
    
    简单来看，上边的代码执行了以下操作：
    （1）使用变量b来代表对象6。为了使用对象，必须通过赋值操作“=”把对象赋值给一个变量（也称之为把对象绑定到变量），这样便可通过该变量来操作内存数据块中的数据。
    （2）如果变量b不存在，创建一个新的变量b。
    （3）将变量b和数字6进行连接，即变量b成为对象6的一个引用，变量可看作是指向对象的内存空间的一个指针。

*  当多个变量都引用了相同的对象，称为共享引用。

>>> a=1
    >>> b=a		# b成为1的引用
    >>> a=2		# a成为对象2的一个引用
    >>> print(b)
    1		# 由于变量仅是对对象的一个引用，因此改变a的引用并不会导致b的变化
    >>>

*  在Python中，允许多个变量指向同一个值，例如：

![在这里插入图片描述][3cac1f2443a64cec9f20d585bbef91f9.png_pic_center]

>>> x=3
    >>> id(x)
    2921334925680
    >>> y=x
    >>> id(y)
    2921334925680
    >>>

*  然而，当为其中一个变量修改值以后，其内存地址将会变化，但这并不影响另一个变量，例如接着上面的代码再继续执行下面的代码：

![在这里插入图片描述][839d330516ea46e493e4c0e7ff066a79.png_pic_center]

>>> x += 6
    >>> id(x)
    2921334925872
    >>> y
    3
    >>> id(y)
    2921334925680
    >>>

--------------------

>>> x='python'
    >>>
    
    # 上述代码创建了一个变量x，x是字符串对象'Python'的引用，即变量x指向的对象的值为'Python'。

> 注意：类型属于对象，变量是没有类型的，变量只是对象的引用，所谓变量的类型指的是变量所引用的对象的类型。变量的类型随着所赋值的类型的变化而改变。

#### 2.python中的is和==的使用 ####

*  == 是python标准操作符中的比较操作符，用来比较判断两个对象的value(值)是否相等，是比较两个对象的内容是否相等，即两个对象的“值“”是否相等，不管两者在内存中的引用地址是否一样。

>>> a=[3,4,5]
    >>> b=[3,4,5]
    >>> id(a)
    2921340292352
    >>> id(b)
    2921340330368
    >>> a==b
    True
    >>>

*  is 比较的是两个实例对象是不是完全相同，它们是不是同一个对象，占用的内存地址是否相同。即is比较两个条件：
    
    1.  内容相同。
    2.  内存中地址相同。

>>> a=[4,5,6]
    >>> b=[4,5,6]
    >>> id(a)
    2921340330624
    >>> id(b)
    2921340292352
    >>> a is b
    False
    >>>
    >>> a=[5,6,7]
    >>> b=a
    >>> id(a)
    2921340330368
    >>> id(b)
    2921340330368
    >>> a is b
    True
    >>>

>  *  Python采用基于值的内存管理方式，如果为不同变量赋值为相同值，这个值在内存中只保存一份，多个变量指向同一个值的内存空间首地址，这样可以减少内存空间的占用，提高内存利用率。
>  *  Python启动时，会对\[-5, 256\]区间的整数进行缓存。也就是说，如果多个变量的值相等且介于\[-5, 256\]区间内，那么这些变量共用同一个值的内存空间。
>  *  对于区间\[-5, 256\]区间之外的整数，同一个程序中或交互模式下同一个语句中的同值不同名变量会共用同一个内存空间，不同程序或交互模式下不同语句不遵守这个约定。

>>> x=-6
    >>> y=-6
    >>> id(x)==id(y)
    False
    >>> x=-5
    >>> y=-5
    >>> id(x)==id(y)
    True
    >>> x=255
    >>> y=255
    >>> id(x)==id(y)
    True
    >>> x=256
    >>> y=256
    >>> id(x)==id(y)
    True
    >>> x=257
    >>> y=257
    >>> id(x)==id(y)
    False
    >>>

>>> x=4.0
    >>> y=4.0
    >>> id(x)==id(y)
    False
    >>> x,y=2000,2000
    >>> id(x)==id(y)
    True
    >>> x=[252525,252525]
    >>> y=[252525,252525]
    >>> id(x[0])==id(x[1])
    True
    >>> id(y[0])==id(y[1])
    True
    >>> id(x[0])==id(y[0])
    False
    >>>

--------------------

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 25]

*  通过上图：Python不会对实数进行缓存，交互模式（不在同一语句）下同值不同名的变量不共用同一个内存空间，同一个程序中的同值不同名变量会共用同一个内存空间。

> 赋值语句的执行过程是：首先把等号右侧表达式的值计算出来，然后在内存中寻找一个位置把值存放进去，最后创建变量并指向这个内存地址。Python中的变量并不直接存储值，而是存储了值的内存地址或者引用，这也是变量类型随时可以改变的原因。

*  使用sys.getrefcount()函数查看引用次数。
    
     *  python内都是对象，变量都是对象的引用，这有点像C语言的指针。
     *  sys模块实际上是指python这个系统，sys.getrefcount接口可以查询对象的引用计数。
     *  在使用sys.getrefcount()函数时，函数会引用一次，
     *  在使用参数引用时，参数会引用一次，同时参数会自动产生一个临时引用，所以会比预期的引用次数多1。

>>> import sys
    >>> a=1
    >>> sys.getrefcount(a)
    86
    >>> b=a
    >>> sys.getrefcount(b)
    87
    >>> sys.getrefcount(a)
    87
    >>> c=[1,2,3]
    >>> sys.getrefcount(c)
    2
    >>> d=c
    >>> sys.getrefcount(d)
    3
    >>> sys.getrefcount(c)
    3
    >>> del d	# del语句会让引用计数减少
    >>> sys.getrefcount(c)
    2
    >>>

### 3.数据类型 ###

*  Python语言中，所有对象都有一个数据类型，Python数据类型定义为一个值的集合以及定义在这个值集上的一组运算操作。一个对象上可执行且只允许执行其对应数据类型定义的操作。
 *  Python中有六个标准的数据类型：
    
     *  number（数字）(int整型，float浮点型，bool布尔型，complex复数型)，可以表示任意大小的数值。
     *  string（字符串）
     *  list（列表）
     *  tuple（元组）
     *  dictionary（字典）
     *  set（集合）

#### 1.int整型 ####

*  Python中的整数类型可以分为：
    
        十进制整数，如，0、-1、9、123
        
        十六进制整数，需要16个数字0、1、2、3、4、5、6、7、8、9、a、b、c、d、e、f来表示整数，必须以0x开头，如0x10、0xfa、0xabcdef       
        注：a、b、c、d、e、f可以大写或者小写
        
        八进制整数，只需要8个数字0、1、2、3、4、5、6、7来表示整数，必须以0o开头，如0o35、0o11
        
        二进制整数，只需要2个数字0、1来表示整数，必须以0b开头如，0b101、0b100
 *  进制转换：

十进制转换其它进制数：bin()、oct()、hex()  
    >>> bin(20)
    '0b10100'
    >>> oct(20)
    '0o24'
    >>> hex(200)
    '0xc8'
    >>>
    
    其它进制数转换成十进制：
    	a.原始数据为字符串，可以使用int("其它进制数", base=)。
        	注：其它进制数前可加也可不加标志         
            >>> int("637270012", base=8)
            108883978
            >>> int("0o637270012", base=8)
            108883978
            >>>
    
    	b.原始数据为字符串且进制数前加上标志，如二进制前加0b，可以使用eval()
        	>>> x=eval('0b1010')
            >>> x
            10
            >>>
            
    	c.在进制数前加上标志，如二进制前加0b,显示时会自动转换为十进制。  
        	>>> 0b1010
            10
            >>>

#### 2.float浮点型 ####

*  浮点数又称小数（有部分浮点数在计算机中是不能精确存贮）。

1、一般写法
       15.0、0.37、-11.2、1.2e2、314.15e-2
    2、特殊写法
       .3  、12.
    3、特殊字符串
        A、"Infinity"或"inf","-Infinity"或"-inf",可以用float()转换成无穷大
        >>> x=float("inf")
        >>> x
        inf
        >>> x=float("Infinity")
        >>> x
        inf
        >>> x=float("Infinity")
        >>> y=float("inf")
        >>> x==y
        True
        >>>
    
        B、"nan"，代表Not A Number（不是一个数），它并不等于0。
        >>> x=float("nan")
        >>> x
        nan
        >>> y=float("nan")
        >>> y
        nan
        >>> x==y
        False
        >>>
        
    注：两个无穷大的数是相等的，两个不是数"nan"比较是不相等。

*  浮点数的有效位数是17位。

>>> 123456789012345678.0+1-123456789012345678.0
    0.0
    >>> 123456789012345678.0-123456789012345678.0+1
    1.0
    >>>

#### 3.bool布尔型 ####

*  bool布尔型。bool布尔型对应两个布尔值：True和False，分别对应1和0。

>>> True+1
    2
    >>> False-1
    -1
    >>>

#### 4.complex复数型 ####

*  Python内置支持**复数**类型。

>>> a=3+4j
    >>> b=5+6j
    >>> c=9-8j
    >>> d=a+b+c
    >>> d
    (17+2j)
    >>> d.real		# 查看复数实部
    17.0
    >>> d.imag		# 查看复数虚部
    2.0
    >>> c.conjugate()	# 返回共轭复数
    (9+8j)
    >>> a*b			# 复数乘法
    (-9+38j)
    >>> b/c			# 复数除法
    (-0.020689655172413775+0.6482758620689656j)
    >>>
    
    注：
    	1.所谓共轭可以理解为加减号的变换，互为共轭的两个复数相乘是个实常数。
    	2.复数的加法按照以下规定的法则进行：设z1=a+bi，z2=c+di是任意两个复数，则它们的和是 (a+bi)+(c+di)=(a+c)+(b+d)i。
        3.复数的减法按照以下规定的法则进行：设z1=a+bi，z2=c+di是任意两个复数，则它们的差是 (a+bi)-(c+di)=(a-c)+(b-d)i。
        4.复数的乘法按照以下规定的法则进行：设z1=a+bi，z2=c+di(a、b、c、d∈R)是任意两个复数，那么它们的积(a+bi)(c+di)=(ac-bd)+(bc+ad)i。
        5.复数的除法按照以下规定的法则进行：可以把除法换算成乘法做，在分子分母同时乘上分母的共轭。
        	设(a+bi)/(c+di)，先在分子分母上同时乘以(c-di),这是(c+di)的共轭复数。
            这样分母变为常数(a+bi)/(c+di)
    					=(a+bi)*(c-di)/(c+di)*(c-di)
    					=(ac+adi+bci+bd)/(c*c+d*d)

> 注：Python 3.6.x开始支持在数字中间位置使用单个下划线作为分隔来提高数字的可读性，类似于数学上使用逗号作为千位分隔符。

>>> 1_000_000
    1000000
    >>> 2_4_2_6
    2426
    >>> 1_2 + 6_1j
    (12+61j)
    >>> 1_2.5_6_1
    12.561
    >>>

#### 5.数值数据的运算 ####

*  Python的数值数据 支持的运算操作的+、-、\*、/、//、\*\*、%（复数不支持）。

>>> 25/5
    5.0
    >>> 18//4
    4
    >>> 18//4.
    4.0
    >>> 18//-3
    -6
    >>> 18//-4
    -5
    >>> 2.1**3
    9.261000000000001
    >>> 18//-3.
    -6.0
    >>> 18%5
    3
    >>> 18%5.0
    3.0
    >>> 18%(3+4j)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: can't mod complex numbers.
    >>> (3+4j)**3
    (-117+44j)
    >>>

> 数值类型中常用的数学函数

<table> 
 <thead> 
  <tr> 
   <th align="center">函数</th> 
   <th align="left">返回值 ( 描述 )</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center"><a href="https://www.runoob.com/python/func-number-abs.html" rel="nofollow">abs(x)</a></td> 
   <td align="left">返回数字的绝对值，如abs(-10) 返回 10</td> 
  </tr> 
  <tr> 
   <td align="center"><a href="https://www.runoob.com/python/func-number-ceil.html" rel="nofollow">math.ceil(x)</a></td> 
   <td align="left">返回数字的上入整数，如math.ceil(4.1) 返回 5</td> 
  </tr> 
  <tr> 
   <td align="center"><a href="https://www.runoob.com/python/func-number-cmp.html" rel="nofollow">cmp(x, y)</a></td> 
   <td align="left">如果 x &lt; y 返回 -1, 如果 x == y 返回 0, 如果 x &gt; y 返回 1</td> 
  </tr> 
  <tr> 
   <td align="center"><a href="https://www.runoob.com/python/func-number-exp.html" rel="nofollow">exp(x)</a></td> 
   <td align="left">返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045</td> 
  </tr> 
  <tr> 
   <td align="center"><a href="https://www.runoob.com/python/func-number-fabs.html" rel="nofollow">fabs(x)</a></td> 
   <td align="left">返回数字的绝对值，如math.fabs(-10) 返回10.0</td> 
  </tr> 
  <tr> 
   <td align="center"><a href="https://www.runoob.com/python/func-number-floor.html" rel="nofollow">math.floor(x)</a></td> 
   <td align="left">返回数字的下舍整数，如math.floor(4.9)返回 4</td> 
  </tr> 
  <tr> 
   <td align="center"><a href="https://www.runoob.com/python/func-number-log.html" rel="nofollow">math.log(x)</a></td> 
   <td align="left">如math.log(math.e)返回1.0,math.log(100,10)返回2.0</td> 
  </tr> 
  <tr> 
   <td align="center"><a href="https://www.runoob.com/python/func-number-log10.html" rel="nofollow">math.log10(x)</a></td> 
   <td align="left">返回以10为基数的x的对数，如math.log10(100)返回 2.0</td> 
  </tr> 
  <tr> 
   <td align="center"><a href="https://www.runoob.com/python/func-number-max.html" rel="nofollow">max(x1, x2,…)</a></td> 
   <td align="left">返回给定参数的最大值，参数可以为序列。</td> 
  </tr> 
  <tr> 
   <td align="center"><a href="https://www.runoob.com/python/func-number-min.html" rel="nofollow">min(x1, x2,…)</a></td> 
   <td align="left">返回给定参数的最小值，参数可以为序列。</td> 
  </tr> 
  <tr> 
   <td align="center"><a href="https://www.runoob.com/python/func-number-modf.html" rel="nofollow">math.modf(x)</a></td> 
   <td align="left">返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。</td> 
  </tr> 
  <tr> 
   <td align="center"><a href="https://www.runoob.com/python/func-number-pow.html" rel="nofollow">pow(x, y)</a></td> 
   <td align="left">x**y 运算后的值。</td> 
  </tr> 
  <tr> 
   <td align="center"><a href="https://www.runoob.com/python/func-number-round.html" rel="nofollow">round(x [,n])</a></td> 
   <td align="left">返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。</td> 
  </tr> 
  <tr> 
   <td align="center"><a href="https://www.runoob.com/python/func-number-sqrt.html" rel="nofollow">sqrt(x)</a></td> 
   <td align="left">返回数字x的平方根</td> 
  </tr> 
 </tbody> 
</table>

*  isinstance()函数

>>> a=2
    >>> isinstance(a,int)
    True
    >>> isinstance(a,str)
    False
    >>> isinstance(a,(str,int,list))	# 是元组中的一个返回 True
    True
    >>>

*  注意：isinstance() 与 type() 区别：
    
     *  1）type() 不会认为子类是一种父类类型，不考虑继承关系。
     *  2）isinstance() 会认为子类是一种父类类型，考虑继承关系。

#### 6.del语句 ####

>>> a=1		# 对象1被变量a引用，对象1的引用计数器为1 
    >>> b=a		# 对象1被变量b引用，对象1的引用计数器加1 
    >>> c=a		# 1对象1被变量c引用，对象1的引用计数器加1 
    >>> del a	# 删除变量a，解除a对1的引用 
    >>> del b	# 删除变量b，解除b对1的引用 
    >>> print(c)	 # 最终变量c仍然引用1 
    1
    >>>

注意：python的del不同于C的free和C++的delete。由于python都是引用，而python有GC机制。所以，del语句作用在变量上，而不是数据对象上。

> **注意：**
> 
>     1、Python可以同时为多个变量赋相同值。
>     	>>> a=b=c=d=1
>     
>     2、Python可以同时为多个变量赋不同值。
>     	>>> a,b,c=1,2,3
>     
>     3、Python可以在同一行中写多条语句，用分号分隔。
>     	>>> a=1;b=2
>     
>     4、一个变量可以有为不同对象的引用
>     	>>> a=1
>     	>>> a="qwww"
>     
>     5、在数值混合计算中，整数会转换成浮点数参加运算。

#### 7.Python数字类型转换 ####

*  当需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。
    
     *  int(x) 将x转换为一个整数，参数可以是一个数或者一个字符串。
     *  float(x) 将x转换到一个浮点数。
     *  complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
     *  complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

>>> int(3.2)
    3
    >>> float(3)
    3.0
    >>> complex(3)
    (3+0j)
    >>> complex(1,2)
    (1+2j)
    >>>

#### 8.Python序列概述 ####

> Python中常用的序列结构有列表、元组、字符串，字典、集合以及range、zip、filter等对象也支持很多类似的操作。

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 26]

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th><strong>列表</strong></th> 
   <th><strong>元组</strong></th> 
   <th><strong>字典</strong></th> 
   <th><strong>集合</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>类型名称</strong></td> 
   <td><strong>list</strong></td> 
   <td><strong>tuple</strong></td> 
   <td><strong>dict</strong></td> 
   <td><strong>set</strong></td> 
  </tr> 
  <tr> 
   <td><strong>定界符</strong></td> 
   <td><strong>方括号[]</strong></td> 
   <td><strong>圆括号()</strong></td> 
   <td><strong>大括号{}</strong></td> 
   <td><strong>大括号{}</strong></td> 
  </tr> 
  <tr> 
   <td><strong>是否可变</strong></td> 
   <td><strong>是</strong></td> 
   <td><strong>否</strong></td> 
   <td><strong>是</strong></td> 
   <td><strong>是</strong></td> 
  </tr> 
  <tr> 
   <td><strong>是否有序</strong></td> 
   <td><strong>是</strong></td> 
   <td><strong>是</strong></td> 
   <td><strong>否</strong></td> 
   <td><strong>否</strong></td> 
  </tr> 
  <tr> 
   <td><strong>是否支持下标</strong></td> 
   <td><strong>是（使用序号作为下标）</strong></td> 
   <td><strong>是（使用序号作为下标）</strong></td> 
   <td><strong>是（使用“键”作为下标）</strong></td> 
   <td><strong>否</strong></td> 
  </tr> 
  <tr> 
   <td><strong>元素分隔符</strong></td> 
   <td><strong>逗号</strong></td> 
   <td><strong>逗号</strong></td> 
   <td><strong>逗号</strong></td> 
   <td><strong>逗号</strong></td> 
  </tr> 
  <tr> 
   <td><strong>对元素形式的要求</strong></td> 
   <td><strong>无</strong></td> 
   <td><strong>无</strong></td> 
   <td><strong>键:值</strong></td> 
   <td><strong>必须可哈希</strong></td> 
  </tr> 
  <tr> 
   <td><strong>对元素值的要求</strong></td> 
   <td><strong>无</strong></td> 
   <td><strong>无</strong></td> 
   <td><strong>“键”必须可哈希</strong></td> 
   <td><strong>必须可哈希</strong></td> 
  </tr> 
  <tr> 
   <td><strong>元素是否可重复</strong></td> 
   <td><strong>是</strong></td> 
   <td><strong>是</strong></td> 
   <td><strong>“键”不允许重复，“值”可以重复</strong></td> 
   <td><strong>否</strong></td> 
  </tr> 
  <tr> 
   <td><strong>元素查找速度</strong></td> 
   <td><strong>非常慢</strong></td> 
   <td><strong>很慢</strong></td> 
   <td><strong>非常快</strong></td> 
   <td><strong>非常快</strong></td> 
  </tr> 
  <tr> 
   <td><strong>新增和删除元素速度</strong></td> 
   <td><strong>尾部操作快</strong> <strong>其他位置慢</strong></td> 
   <td><strong>不允许</strong></td> 
   <td><strong>快</strong></td> 
   <td><strong>快</strong></td> 
  </tr> 
 </tbody> 
</table>

### 4.字符串 ###

Python中的字符串属于不可变序列，是用单引号(’)、双引号(")、三单引号(’’’)或三双引号(’’’’’’)等界定符括起来的字符序列。  
  单引号、双引号、三单引号、三双引号可以互相嵌套，用来表示复杂字符串。 例： ‘abc’、‘123’、‘中国’、“Python”、’’‘Tom said, “Let’s go”’’’（这一种类型可以不转义）。  
  空字符串表示为’‘或 “”。  
  三引号’’'或"""表示的字符串可以换行，支持排版较为复杂的字符串；三引号还可以在程序中表示较长的注释。  
  Python中没有字符类型，另外：python中的单行注释是\#，多行注释(块注释）是三引号。

#### 1.创建字符串 ####

*  创建字符串，只要为变量分配一个用字符串界定符括起来的字符序列即可创建一个字符串。例如：
    
        var1 = 'Hello World!'

#### 2.转义字符 ####

*  常用转义字符

<table> 
 <thead> 
  <tr> 
   <th align="center">转义字符</th> 
   <th align="center">含义</th> 
   <th align="center">转义字符</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">\在行尾时</td> 
   <td align="center">换行符</td> 
   <td align="center">\000</td> 
   <td>空</td> 
  </tr> 
  <tr> 
   <td align="center">\b</td> 
   <td align="center">退格，把光标移动到前一列位置</td> 
   <td align="center"><code>\\</code></td> 
   <td>一个斜线\</td> 
  </tr> 
  <tr> 
   <td align="center">\f</td> 
   <td align="center">换页符</td> 
   <td align="center">\’</td> 
   <td>单引号’</td> 
  </tr> 
  <tr> 
   <td align="center">\n</td> 
   <td align="center">换行符</td> 
   <td align="center">\”</td> 
   <td>双引号”</td> 
  </tr> 
  <tr> 
   <td align="center">\r</td> 
   <td align="center">回车</td> 
   <td align="center">\oyy</td> 
   <td>八进制yy数对应的字符</td> 
  </tr> 
  <tr> 
   <td align="center">\t</td> 
   <td align="center">水平制表符</td> 
   <td align="center">\xhh</td> 
   <td>2位十六进制数对应的字符</td> 
  </tr> 
  <tr> 
   <td align="center">\v</td> 
   <td align="center">垂直制表符</td> 
   <td align="center">\uhhhh</td> 
   <td>4位十六进制数表示的Unicode字符</td> 
  </tr> 
 </tbody> 
</table>

*  如果定义字符串时，字符串的边界符不在字符串中，则可不转义。

>>> a="ssss\'ddd\'ddd"
    >>> a
    "ssss'ddd'ddd"
    >>> a="ssss'ddd'ddd"
    >>> a
    "ssss'ddd'ddd"

*  如果定义字符串时，字符串的边界符在字符串中，必须转义。\\不计入字符串中的内容。

>>> a="ssss'ddd'd\"dd"
    >>> a
    'ssss\'ddd\'d"dd'

*  字符串界定符前面加字母r或R表示`原始字符串`，其中的特殊字符不进行转义，但字符串的`最后一个字符不能是\`。原始字符串主要用于正则表达式、文件路径或者URL的场合。

>>> path="C:\Windows\notepad.exe"
    >>> print(path)		# 字符\n被转义为换行符
    C:\Windows
    otepad.exe
    >>> path=r"C:\Windows\notepad.exe"		# 原始字符串，任何字符都不转义
    >>> print(path)
    C:\Windows\notepad.exe
    >>>
    >>> x=r'dsepd\'		# 错误
      File "<stdin>", line 1
        x=r'dsepd\'
                   ^
    SyntaxError: EOL while scanning string literal
    >>>

#### 3.字符串编码 ####

*  Python 3的字符串编码，可以通过以下代码查看Python 3的字符串默认编码：
    
        >>> sys.getdefaultencoding()
        'utf-8'
        >>>

> encode()方法
> 
>  *  以 encoding 指定的编码格式编码字符串。errors参数可以指定不同的错误处理方案。

*  encode() 方法为字符串类型（str）提供的方法，用于将 str 类型转换成 bytes 类型，这个过程也称为“编码”。
 *  encode() 方法的语法格式如下：

str.encode(encoding='UTF-8',errors='strict')
    	- encoding -- 要使用的编码，如"UTF-8"。
    	- errors -- 设置不同错误的处理方案。默认为 'strict',意为编码错误引起一个UnicodeError。

>>> S = "懒羊羊的C411";
    >>> S_utf8 = S.encode("UTF-8")
    >>> S_gbk = S.encode("GBK")
    >>>
    >>> print(S)
    懒羊羊的C411
    >>>
    >>> print("UTF-8 编码：", S_utf8)
    UTF-8 编码： b'\xe6\x87\x92\xe7\xbe\x8a\xe7\xbe\x8a\xe7\x9a\x84C411'
    >>> print("GBK 编码：", S_gbk)
    GBK 编码： b'\xc0\xc1\xd1\xf2\xd1\xf2\xb5\xc4C411'
    >>>
    >>> print("UTF-8 解码：", S_utf8.decode('UTF-8', 'strict'))
    UTF-8 解码： 懒羊羊的C411
    >>> print("GBK 解码：", S_gbk.decode('GBK', 'strict'))
    GBK 解码： 懒羊羊的C411
    >>>

--------------------

*  UTF-8和GBK编码、解码

例如:
        >>> str = "this is string example....wow!!!"
        >>> S_utf8 = str.encode("UTF-8")
        >>> S_gbk = str.encode("GBK")
        >>>
        >>> print(str)
        this is string example....wow!!!
        >>>
        >>> print("UTF-8 编码：", S_utf8)
        UTF-8 编码： b'this is string example....wow!!!'
        >>> print("GBK 编码：", S_gbk)
        GBK 编码： b'this is string example....wow!!!'
        >>> print("UTF-8 解码：", S_utf8.decode('UTF-8', 'strict'))
        UTF-8 解码： this is string example....wow!!!
        >>> print("GBK 解码：", S_gbk.decode('GBK', 'strict'))
        GBK 解码： this is string example....wow!!!
        >>>

*  base64编码、解码

>>> import base64	
        >>> # str 转成bytes 的string
        >>> str3 = str.encode(encoding ='utf-8',errors = 'strict')
        >>> # bytes 再进行 base64 编码
        >>> str4= base64.b64encode(str3)
        >>> # 再base64 decode 一下
        >>> print ("base64 编码：",str4.decode())
        base64 编码： dGhpcyBpcyBzdHJpbmcgZXhhbXBsZS4uLi53b3chISE=
        >>> enstr = base64.b64decode(str4.decode())
        >>> print("base64 解码：",enstr.decode())
        base64 解码： this is string example....wow!!!
        >>>

> decode()方法
> 
>  *  和 encode() 方法正好相反，decode() 方法用于将 bytes 类型的二进制数据转换为 str 类型，这个过程也称为“解码”。
>  *  decode() 方法的语法格式如下：
> 
>     bytes.decode([encoding="utf-8"][,errors="strict"])
> 
>  *  说明：encoding=“utf-8” ：
>     
>      *  （1）指定解码时采用的字符编码，默认采用 utf-8 格式。
>      *  （2）当方法中只使用这一个参数时，可以省略“encoding=”，直接写编码方式即可。

*  注意：对 bytes 类型数据解码，要选择和当初编码时一样的格式。

>>> str="蛋糕房"
    >>> bytes=str.encode()
    >>> bytes.decode()
    '蛋糕房'
    >>>

*  注意，如果编码时采用的不是默认的 UTF-8 编码，则解码时要选择和编码时一样的格式，否则会抛出异常。案例如下：

>>> str="蛋糕房"
    >>> bytes=str.encode("GBK")
    >>> bytes.decode()	# 默认使用 UTF-8 编码，会抛出以下异常
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    UnicodeDecodeError: 'utf-8' codec can't decode byte 0xb5 in position 0: invalid start byte
    >>>

#### 4.内置函数ord()、chr()和str() ####

*  ord()和chr()是一对功能相反的函数，ord()用来返回单个字符的序数或Unicode码，而chr()则用来返回某序数对应的字符，str()则直接将其任意类型参数转换为字符串。

>>> ord('d')
    100
    >>> chr(ord('R')+1)
    'S'
    >>> str(1253)
    '1253'
    >>> str((1,2,3))
    '(1, 2, 3)'
    >>> chr(65)
    'A'
    >>> str(5)
    '5'
    >>> str([1,2,3])
    '[1, 2, 3]'
    >>> str({ 1,2,3})
    '{1, 2, 3}'
    >>>

#### 5.字符串运算符 ####

<table> 
 <thead> 
  <tr> 
   <th align="center">操作符</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center"><strong>+</strong></td> 
   <td><strong>字符串连接</strong></td> 
  </tr> 
  <tr> 
   <td align="center">*</td> 
   <td><strong>重复输出字符串</strong></td> 
  </tr> 
  <tr> 
   <td align="center"><strong>[]</strong></td> 
   <td><strong>通过索引获取字符串中字符</strong></td> 
  </tr> 
  <tr> 
   <td align="center"><strong>[ : ]</strong></td> 
   <td><strong>截取字符串中的一部分</strong></td> 
  </tr> 
  <tr> 
   <td align="center"><strong>in</strong></td> 
   <td><strong>成员运算符–如果字符串中包含给定的字符串返回True</strong></td> 
  </tr> 
  <tr> 
   <td align="center"><strong>not in</strong></td> 
   <td><strong>成员运算符–如果字符串中不包含给定的字符串返回True</strong></td> 
  </tr> 
  <tr> 
   <td align="center"><strong>r/R</strong></td> 
   <td><strong>原始字符串–在字符串的第一个引号前加上字母r或R，字符串中的所有的字符直接按照字面的意思来使用，不再转义特殊或不能打印的字符</strong>。</td> 
  </tr> 
  <tr> 
   <td align="center"><strong>%</strong></td> 
   <td><strong>格式化字符串</strong></td> 
  </tr> 
 </tbody> 
</table>

>>> str1='Python'
    >>> str2='good'
    >>> str3=str1+str2	# 字符串连接
    >>> print(str3)
    Pythongood
    >>> print(str1*3)	# 输出字符串三次
    PythonPythonPython
    >>> print(3*str1)
    PythonPython
    >>>

*  Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。

![在这里插入图片描述][49bb269cc733479bb972472fcfc3ca8c.png_pic_center]

>>> str1='Python'
    >>> print(str1[0]) # 通过索引输出字符串第一个字符
    P
    >>> print(str1[2:5])	# 输出从第三个开始到第五个的字符
    tho
    >>> print(str1[0:-1])	# 输出第一个到倒数第二个的所有字符
    Pytho
    >>>
    >>> 'y' in str1
    True
    >>> 'sd' in str1
    False
    >>> 'as' not in 'dffv'
    True
    >>>

#### 6.Python中strip()、lstrip()、rstrip()用法详解 ####

> [参考博客园][Link 9]

Python中有三个去除头尾字符、空白符的函数，它们依次为:

*  strip： 用来去除头尾字符、空白符(包括\\n、\\r、\\t、’ '，即：换行、回车、制表符、空格)；
 *  lstrip：用来去除开头字符、空白符(包括\\n、\\r、\\t、’ '，即：换行、回车、制表符、空格)；
 *  rstrip：用来去除结尾字符、空白符(包括\\n、\\r、\\t、’ '，即：换行、回车、制表符、空格)；
 *  注意：这些函数都只会删除头和尾的字符，中间的不会删除。
 *  用法分别为：

string.strip([chars])
    string.lstrip([chars])
    string.rstrip([chars])

*  参数chars是可选的，当chars为空，默认删除string头尾的空白符(包括\\n、\\r、\\t、’ ')。
 *  当chars不为空时，函数会被chars解成一个个的字符，然后将这些字符去掉。
 *  它返回的是去除头尾字符(或空白符)的string副本，string本身不会发生改变。

举例说明如下：

1.  当chars为空时，默认删除空白符(包括’\\n’, ‘\\r’, ‘\\t’, ’ ')

>>> str = ' ab cd '
    >>> str
    ' ab cd '
    >>> str.strip() #删除头尾空格
    'ab cd'
    >>> str.lstrip() #删除开头空格
    'ab cd '
    >>> str.rstrip() #删除结尾空格
    ' ab cd'

1.  当chars不为空时，函数会被chars解成一个个的字符，然后将这些字符去掉。

>>> str2 = '1a2b12c21'
    >>> str2.strip('12') #删除头尾的1和2
    'a2b12c'
    >>> str2.lstrip('12') #删除开头的1和2
    'a2b12c21'
    >>> str2.rstrip('12') #删除结尾的1和2
    '1a2b12c'

#### 7.字符串大小写转换 ####

*  str.lower()：将字符串str中的大写字母转小写字母。
 *  str.upper()：将str中的小写字母转成大写字母。
 *  str.swapcase()：将str中的大小写互换。
 *  str.capitalize()：返回一个只有首字母大写的字符串。

>>> 'Adobe'.lower()
    'adobe'
    >>> 'Adobe'.upper()
    'ADOBE'
    >>> 'Adobe'.swapcase()
    'aDOBE'
    >>> 'Adobe'.capitalize()
    'Adobe'
    >>>

*  string.capwords(str\[, sep\])：以sep作为分隔符(不带参数sep时，`默认以空格为分隔`符)，分割字符串str，然后将每个字段的首字母换成大写，将每个字段除首字母外的字母均置为小写，最后合并连接到一起组成一个新字符串。
 *  注意：capwords(str)是string模块中的函数，使用之前需要先导入string模块，即`import string`。

>>> import string
    >>> string.capwords("ShaRP tools make good work.")
    'Sharp Tools Make Good Work.'
    >>>

#### 8.字符串分割 ####

*  str.split(s,num) \[n\]：按s中指定的分隔符(默认为所有的空字符，包括空格、换行(\\n)、制表符(\\t)等)，将一个字符串str分裂成num+1个字符串所组成的列表。若带有\[n\]，表示选取分割后的第n个分片，n表示返回的列表中元素的下标，从0开始。
    
        >>> str='hello world'
        >>> str.split()
        ['hello', 'world']
        >>>
        >>> str2="www.taobao.com"
        >>> str2.split('.',1)	# 分隔一次
        ['www', 'taobao.com']
        >>> str2.split('.')[2]	# 选取分割后的第2片作为结果返回
        'com'
        >>> str2.split('.')[1]	# 选取分割后的第1片作为结果返回
        'taobao'
        >>>
    
        >>> str2="www.taobao.com"
        >>> s1,s2,s3=str2.split('.',2)	# s1，s2，s3分别被赋值得到被切割的三个部分
        >>> print(s1,s2,s3)
        www taobao com
        >>> s='call\nme\nbaby'
        >>> s.split('\n')
        ['call', 'me', 'baby']
        >>> s="hello!<[www.subeily.com.cn]>Good"
        >>> s.split('[')[1].split(']')[0]
        'www.subeily.com.cn'
        >>>
    
    > partition()方法
 *  如果字符串`包含`指定的分隔符，则返回一个3元素的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。如果字符串`不包含`指定的分隔符，则返回一个3元素的元组，第一个为原始字符串，第二个为空串，第三个为空串。

>>> str="http://www.suse.edu.cn"
    >>> str.partition("://")
    ('http', '://', 'www.suse.edu.cn')
    >>> str.partition("b")
    ('http://www.suse.edu.cn', '', '')
    >>>

> 字符串搜索：find()、rfind()、index()、rindex()、count()

*  find()和rfind方法分别用来查找一个字符串在另一个字符串指定范围（默认是整个字符串）中首次和最后一次出现的位置，如果`不存在则返回-1`；
 *  index()和rindex()方法用来返回一个字符串在另一个字符串指定范围中首次和最后一次出现的位置，如果`不存在则抛出异常`；
 *  count()方法用来`返回`一个字符串在当前字符串中`出现的次数`。
 *  str.find(substr \[,start \[, end \] \])：返回str中指定范围(默认是整个字符串)第一次出现的substr的第一个字母的位置，如果str中没有substr则返回-1。
    
        >>> 'He that can have patience.'.find('can')
        8
        >>> 'He that can have patience.'.find('aan')
        -1
        >>>
    
        >>> s="apple,peach,banana,peach,pear"
        >>> s.find("peach")
        6
        >>> s.find("peach",7)
        19
        >>> s.find("peach",7,20)
        -1
        >>> s.rfind('p')
        25
        >>> s.index('p')
        1
        >>> s.index('pe')
        6
        >>> s.index('pear')
        25
        >>> s.index('ppp')
        Traceback (most recent call last):
          File "<stdin>", line 1, in <module>
        ValueError: substring not found
        >>> s.count('p')
        5
        >>> s.count('pp')
        1
        >>> s.count('ppp')
        0
        >>>
    
        >>> str="this is really a string example....wow!!!"
        >>> substr="is"
        >>> print(str.rfind(substr))
        5
        >>> print(str.rfind(substr,0,10))
        5
        >>> print(str.rfind(substr,10,0))
        -1
        >>> print(str.find(substr))
        2
        >>> print(str.find(substr,0,10))
        2
        >>> print(str.find(substr,10,0))
        -1
        >>>
    
    > 字符串替换
 *  str.replace(oldstr, newstr \[, count\])：把str中的oldstr字符串替换成newstr字符串，如果指定了count参数，表示替换最多不超过count次。如果未指定count参数，表示全部替换，有多少替换多少。
 *  str.count(substr\[, start, \[end\] \]) ：在字符串str中统计子字符串substr出现的次数，如果不指定开始位置start和结束位置end，表示从头统计到尾。

>>> str='This is a string example.This is a really string.'
    >>> str.replace("is","was")
    'Thwas was a string example.Thwas was a really string.'
    >>> 'dfgfhfjbfyjhgfbfguhbdyutyukum'.count('df')
    1
    >>>

> 字符串映射

*  str.maketrans(instr, outstr)：用于创建字符映射的转换表（映射表），第一个参数instr表示需要转换的字符串，第二个参数outstr表示要转换的目标字符串。两个字符串的长度必须相同，为一一对应的关系。
 *  str.translate(table)：使用str.maketrans(instr, outstr)生成的映射表table，对字符串str进行映射。

>>> table=str.maketrans('abcdef','123456')	# 创建映射表，将'abcdef'一一转换为'123456'
    >>> table
    { 97: 49, 98: 50, 99: 51, 100: 52, 101: 53, 102: 54}
    >>> s1='Python is a greate programming language.I like it.'
    >>> s1.translate(table)		# 使用映射表table对字符串s1进行映射
    'Python is 1 gr51t5 progr1mming l1ngu1g5.I lik5 it.'
    >>> table=''.maketrans('0123456789','零一二三四五六七八九')
    >>> '2021年09月11日'.translate(table)
    '二零二一年零九月一一日'
    >>>

> 判断字串的开始和结束

*  str.startswith(substr\[, start, \[end\]\])：用于检查字符串str是否是以字符串substr开头，如果是则返回True，否则返回False。

>>> s='Work makes the workman.'
    >>> s.startswith('Work')	# 检查整个字符串
    True
    >>> s.startswith('the',11)
    True
    >>> s.startswith('the',12)
    False
    >>> s.startswith('the',12,13)
    False
    >>>

*  str.endswith(substr\[, start\[, end\]\])：用于检查字符串str是否是以字符串substr结尾，如果是则返回True，否则返回 False。

>>> s='Constant dropping wears the stone.'
    >>> s.endswith('stone.')
    True
    >>> s.endswith('ears',0,23)
    True
    >>>

> 列出指定目录下扩展名为.md或.xmind的文件

import os
    items = os.listdir("F:\\java\\Github\\Blog-Java\\文档\\02-Java Web") # 返回指定路径下的文件和文件夹列表
    newlist=[]
    for names in items:
        if names.endswith((".md",".xmind")):
            newlist.append(names)
    print(newlist)

> 连接字符串

*  str.join(sequence)：返回通过指定字符str连接序列sequence中元素后生成的新字符串。
 *  使用split()和join()方法删除字符串中多余的空白字符，连续多个空白字符只保留一个。

>>> str = "-"
    >>> seq = ('a', 'b', 'c','d')
    >>> str.join( seq )
    'a-b-c-d'
    >>> seq1 = ['Keep','on','going','never','give','up']
    >>> print(' '.join(seq1))
    Keep on going never give up
    >>>
    >>> seq2={ 'hello':1,'good':2,'boy':3,'world':4}
    >>> '-'.join(seq2)
    'hello-good-boy-world'
    >>> ''.join(('/hello/','good/boy/','world'))
    '/hello/good/boy/world'
    >>>
    >>> x = 'aaa bb c d e fff '
    >>> ' '.join(x.split())		# 使用空格作为连接符
    'aaa bb c d e fff'
    >>> ''.join(x.split())
    'aaabbcdefff'
    >>> '#'.join(x.split())
    'aaa#bb#c#d#e#fff'
    >>>

> 判断两个字符串在Python意义上是否等价

def equavilent(s1, s2):
        if s1 == s2:
            return True
        elif ' '.join(s1.split()) == ' '.join(s2.split()):
            return True
        elif ''.join(s1.split()) == ''.join(s2.split()):
            return True
        else:
            return False
    print(equavilent('pip list', 'pip list'))    # True

> 判断字符串是否全为数字、字符等
> 
>     str.isalnum()：str所有字符都是数字或者字母，返回 Ture
>     str.isalpha()：str所有字符都是字母，返回 Ture
>     str.isdigit()：str所有字符都是数字，返回 Ture
>     str.islower()：str所有字符都是小写，返回 Ture
>     str.isupper()：str所有字符都是大写，返回 Ture
>     str.istitle()：str所有单词都是首字母大写，返回 Ture
>     str.isspace()：str所有字符都是空白字符，返回 Ture

>>> '1234abcd'.isalnum()  # 全部由字母和数字时返回True
    True
    >>> '1234abcd'.isalpha()  # 全部为英文字母时返回True
    False
    >>> '1234abcd'.isdigit()  # 全部为数字时返回True
    False
    >>> 'abcd'.isalpha()
    True
    >>> '1234.0'.isdigit()
    False
    >>> '四'.isnumeric()    # isnumeric()方法支持汉字数字，罗马数字
    True
    >>> '4526'.isdigit()
    True
    >>> '六'.isdigit()
    False
    >>> '六'.isdecimal()
    False
    >>> 'ⅣⅢⅩ'.isdecimal()
    False
    >>> 'ⅣⅢⅩ'.isdigit()
    False
    >>> 'ⅣⅢⅩ'.isnumeric()
    True
    >>>

isdigit()
        True: Unicode数字，byte数字（单字节），全角数字（双字节），罗马数字
        False: 汉字数字
        Error: 无
    
    isdecimal()
        True: Unicode数字，，全角数字（双字节）
        False: 罗马数字，汉字数字
        Error: byte数字（单字节）
    
    isnumeric()
        True: Unicode数字，全角数字（双字节），罗马数字，汉字数字
        False: 无
    	Error: byte数字（单字节）

> 字符串对齐及填充

*  center()、ljust()、rjust()，返回指定宽度的新字符串，原字符串居中、左对齐或右对齐出现在新字符串中，如果指定宽度大于字符串长度，则使用指定的字符（默认为空格）进行填充。zfill()返回指定宽度的字符串，在左侧以字符0进行填充。

>>> 'Hello SpringBoot!'.center(20)	# 居中对齐，以空格进行填充
    ' Hello SpringBoot! '
    >>> 'Hello SpringBoot!'.center(20,'=')	# 居中对齐，以字符=进行填充
    '=Hello SpringBoot!=='
    >>> 'Hello SpringBoot!'.ljust(20,'=')	# 左对齐
    'Hello SpringBoot!==='
    >>> 'Hello SpringBoot!'.rjust(20,'=')	# 右对齐
    '===Hello SpringBoot!'
    >>> str="this is String exmaple!"
    >>> print(str.zfill(40))
    00000000000000000this is String exmaple!
    >>>

#### 9.字符串常量 ####

> Python标准库string中定义了数字、标点符号、英文字母、大写英文字母、小写英文字母等字符串常量。

>>> import string
    >>> string.ascii_letters      # 所有字母
    'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
    >>> string.ascii_lowercase   # 所有小写字母
    'abcdefghijklmnopqrstuvwxyz'
    >>> string.ascii_uppercase   # 所有大写字母
    'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    >>> string.digits           # 所有数字0-9
    '0123456789'
    >>>

[Link 1]: https://baike.baidu.com/item/%E8%8D%B7%E5%85%B0/190469
[Link 2]: https://baike.baidu.com/item/%E6%95%B0%E5%AD%A6/107037
[Link 3]: https://baike.baidu.com/item/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%A7%91%E5%AD%A6/9132
[ABC]: https://baike.baidu.com/item/ABC%E8%AF%AD%E8%A8%80/334996
[Link 4]: https://baike.baidu.com/item/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/1450
[Link 5]: https://baike.baidu.com/item/%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/2262089
[Link 6]: https://baike.baidu.com/item/%E5%90%89%E5%A4%9A%C2%B7%E8%8C%83%E7%BD%97%E8%8B%8F%E5%A7%86/328361
[Link 7]: https://baike.baidu.com/item/%E9%98%BF%E5%A7%86%E6%96%AF%E7%89%B9%E4%B8%B9/2259975
[Link 8]: https://baike.baidu.com/item/%E5%9C%A3%E8%AF%9E%E8%8A%82/127881
[Tiobe]: https://www.tiobe.com/tiobe-index/
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center]: /images/20220829/99ad65f472f54e0c951d78f58c8d6eb4.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 1]: /images/20220829/b06f017e92d5436eb03cd55f4046c60f.png
[python]: http://www.pyton.org/
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 2]: /images/20220829/4f67e06028614594b2ba033562ed64bb.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 3]: /images/20220829/4e55327aaeda4b81ab1fad330a9196be.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 4]: /images/20220829/bdd6ecebb6d3477eaf7ec7c004807b69.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 5]: /images/20220829/973abb84cd2e4ac28edf34a8a7603b31.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 6]: /images/20220829/1cf62deed475460787f7405a86d48018.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 7]: /images/20220829/864f1cd1ab574bbe95a32546b6230329.png
[984b765ab9b845c09e487ed9c20c242b.png_pic_center]: /images/20220829/c737d210c91647dc97aff9575b524ef6.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 8]: /images/20220829/61dda46831d843e8bed7c96d83363238.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 9]: /images/20220829/e2ee721fd4cb47aa9efa74fe29f62969.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 10]: /images/20220829/bd8123b34c234cd5b0285e1c7e693797.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 11]: /images/20220829/1464c478034347839a59024117a5496b.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 12]: /images/20220829/62f7704348814bd99ed9d72733324a18.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 13]: /images/20220829/9efecf685c0e470c9fe15f8efbb20c9c.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 14]: /images/20220829/4ad2c087d76f4467a812e2f280d2244c.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 15]: /images/20220829/7fe32f44dcea432a9439fd8fbc2d10ea.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 16]: /images/20220829/1fdc955aaf784b09ab95ae04fea2c14d.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 17]: /images/20220829/8892fe029d9040ac83ac19d5f9d168ff.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 18]: /images/20220829/cc04bb885a344d1ca081e03e4bf56272.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 19]: /images/20220829/660530b36b214012ad4fdc81046f0fca.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 20]: /images/20220829/c2feb8ffacad4ea29bad125e4344c7cb.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_18_color_FFFFFF_t_70_g_se_x_16_pic_center]: /images/20220829/9efbf9c89ec34f2c93c25bfa8f1b231e.png
[f2f87de1f071408a92fdf6622df261bd.png_pic_center]: /images/20220829/aa64741727164bc397b70c2c9be0f249.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_18_color_FFFFFF_t_70_g_se_x_16_pic_center 1]: /images/20220829/b78d8b77969b4e5daf8b8afc8bca2635.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 21]: /images/20220829/afb8e5f90f41468494bcd6fa42533b73.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 22]: /images/20220829/3b84effb0f3548a0a89dca7949e779ac.png
[0cb14616a1e24e99ab74c62446d4cc77.png_pic_center]: /images/20220829/449862fa94364e5aaf5c5a1b1c862576.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 23]: /images/20220829/3136a53036804b4391461925e18b82fe.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 24]: /images/20220829/ae330b7d02d84cf2a50ffe9b8450d080.png
[3cac1f2443a64cec9f20d585bbef91f9.png_pic_center]: /images/20220829/6a9b3b5b8d87458d9983bcbe8cec571f.png
[839d330516ea46e493e4c0e7ff066a79.png_pic_center]: /images/20220829/0f9e6161bb7c493fbd64160b19f52356.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 25]: /images/20220829/6f4f215a73234f8ea43269789f1460dd.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc3ViZWlMWQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 26]: /images/20220829/a4615adbaa31401a9bc10dfe421d7c51.png
[49bb269cc733479bb972472fcfc3ca8c.png_pic_center]: /images/20220829/efae94aff0ed47b8a680e5645dce55eb.png
[Link 9]: https://www.cnblogs.com/huangbiquan/p/7923008.html