深入浅出Python——Python基础语法全解

秒速五厘米 2023-02-21 11:57 72阅读 0赞

前言：

1.  Python是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。
2.  本博文主要涉及Python基础入门、流程控制（条件语句、循环语句）、数据序列等知识。
3.  本博文若存在任何知识错误，请读者第一时间在评论区指出，方便我修正内容！
4.  获取更多内容，请关注博主，在主页进行阅读，感谢您的支持！

### 文章目录 ###

*   *  一、Python简介
     *   *  1. 了解Python
         *  2. Python介绍
         *  3. Python特点
         *  4. Python发展历史
         *  5. Python版本
     *  二、Python解释器
     *   *  1. 解释器的作用
         *  2. 解释器的安装
     *  三、PyCharm安装与使用
     *   *  1. PyCharm的作用
         *  2. PyCharm安装与使用
     *  四、注释
     *   *  1. 注释的作用
         *  2. 注释的分类及语法
     *  五、变量
     *   *  1. 变量的作用
         *  2. 定义变量
         *   *  2.1 标识符
             *  2.2 命名习惯
             *  2.3 使用变量
             *  2.4 认识bug
             *  2.5 Debug工具
     *  六、数据类型
     *  七、输出
     *   *  1. 格式化输出
         *  2. 内置函数format
         *  3. f-格式化字符串
         *  4. 体验格式化字符串
         *  5. 补充知识
         *  6. 转义字符
         *  7. 结束符
     *  八、输入
     *   *  1. 输入的语法
         *  2. 输入的特点
     *  九、转换数据类型
     *   *  1. 转换数据类型的作用
         *  2. 转换数据类型的函数
         *  3. 体验转换数据类型
     *  十、运算符
     *   *  1. 运算符的分类
         *  2. 算数运算符
         *  3. 赋值运算符
         *  4. 复合赋值运算符
         *  5. 比较运算符
         *  6. 逻辑运算符
         *  7. 补充知识
     *  十一、条件语句
     *   *  1. 了解条件语句
         *  2. if语法
         *   *  2.1 体验if语句
             *  2.2 简单版：网吧上网
             *  2.3 进阶版：网吧上网
         *  3. if...else...
         *   *  3.1 实用版：网吧上网
         *  4. 多重判断
         *   *  4.1 实例：工龄判断
         *  5. if嵌套
         *   *  5.1 实例：坐公交
             *  5.2 if嵌套执行流程
         *  6. 应用：猜拳游戏
         *   *  6.1 初始版：猜拳游戏
             *  6.2 进阶版：猜拳游戏
         *  7. 三目运算符
     *  十二、循环简介
     *   *  1. 循环的作用
         *  2. 循环的分类
         *  3. while的语法
         *  4. while循环快速体验
         *  5. while的应用
         *   *  5.1 应用一：计算1-100累加和
             *  5.2 应用二：计算1-100偶数累加和
         *  6. break和continue
         *   *  6.1 理解
             *  6.2 break实例
             *  6.3 continue实例
         *  7. while循环嵌套
         *   *  7.1 语法
             *  7.2 执行过程
             *  7.3 while循环嵌套应用
         *  8. for循环
         *   *  8.1 语法
             *  8.2 快速体验
             *  8.3 break
             *  8.4 continue
     *  十三、else
     *   *  1. while...else
         *   *  1.1 语法
             *  1.2 示例
             *  1.3 退出循环的方式
         *  2. for...else
         *   *  2.1 语法
             *  2.2 示例
             *  2.3 退出循环的方式
     *  十四、字符串
     *   *  1. 认识字符串
         *  2. 字符串特征
         *  3. 字符串输出
         *  4. 字符串输入
         *  5. 下标
         *   *  5.1 概念
             *  5.2 快速体验
         *  6. 切片
         *   *  6.1 语法
             *  6.2 示例
         *  7. 常用操作方法
         *   *  7.1 查找
             *  7.2 修改
             *  7.3 判断
     *  十五、列表
     *   *  1. 列表的格式
         *  2. 列表的常用操作
         *   *  2.1 查找
             *  2.2 判断是否存在
             *  2.2 增加
             *  2.3 删除
             *  2.4 修改
             *  2.5 复制
         *  3. 列表的循环遍历
         *   *  3.1 while
             *  3.2 for
         *  4. 列表嵌套
     *  十六、元组
     *   *  1. 定义元组
         *  2. 元组的常见操作
         *  3. 元组的注意事项
     *  十七、字典
     *   *  1. 创建字典的语法
         *  2. 字典常见操作
         *   *  2.1 增
             *  2.2 删
             *  2.3 改
             *  2.4 查
         *  3. 字典的循环遍历
         *   *  3.1 遍历字典的key
             *  3.2 遍历字典的value
             *  3.3 遍历字典的元素
             *  3.4 遍历字典的键值对
     *  十八、集合
     *   *  1. 创建集合
         *  2. 集合常见操作方法
         *   *  2.1 增加数据
             *  2.2 删除数据
             *  2.3 查找数据
     *  十九、公共操作
     *   *  1. 运算符
         *   *  1.1 +
             *  1.2 \*
             *  1.3 in或not in
         *  2. 公共方法
         *   *  2.1 len()
             *  2.2 del()
             *  2.3 max()
             *  2.4 min()
             *  2.5 range()
             *  2.6 enumerate()
         *  3. 容器类型转换
         *   *  3.1 tuple()
             *  3.2 list()
             *  3.3 set()
     *  二十、推导式
     *   *  1. 列表推导式
         *   *  1.1 快速体验
             *  1.2 带if的列表推导式
             *  1.3 多个for循环实现列表推导式
         *  2. 字典推导式
         *   *  2.1 快速体验
         *  3. 集合推导式

## 一、Python简介 ##

### 1. 了解Python ###

Python是一种解释型（这意味着开发过程中没有了编译这个环节）、面向对象（支持面向对象的风格或代码封装在对象的编程技术）、动态数据类型的交互式（可在命令行中通过Python提示符及直接代码执行程序）高级程序设计语言。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0_size_16_color_FFFFFF_t_70]

### 2. Python介绍 ###

Python是时下最流行、最火爆的编程语言，具体原因：

*  简单、易学，适应人群广泛  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0_size_16_color_FFFFFF_t_70 1]
 *  免费、开源
 *  应用领域广泛  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0_size_16_color_FFFFFF_t_70 2]

> 备注：以下知名框架均是Python语言开发。
> 
> 1.  Google开源机器学习框架：TensorFlow
> 2.  开源社区主推学习框架：Scikit-learn
> 3.  百度开源深度学习框架：Paddle

### 3. Python特点 ###

1.  易于学习：Python有相对较少的关键字，结构简单，和一个明确定义的语法，学习起来更加简单。
2.  易于阅读：Python代码定义的更清晰。
3.  易于维护：Python的成功在于它的源代码是相当容易维护的。
4.  一个广泛的标准库：Python的最大的优势之一是丰富的库，跨平台的，在UNIX，Windows和Macintosh兼容很好。
5.  互动模式：互动模式的支持，您可以从终端输入执行代码并获得结果的语言，互动的测试和调试代码片断。
6.  可移植：基于其开放源代码的特性，Python已经被移植（也就是使其工作）到许多平台。
7.  可扩展：如果你需要一段运行很快的关键代码，或者是想要编写一些不愿开放的算法，你可以使用C或C++完成那部分程序，然后从你的Python程序中调用。
8.  数据库：Python提供所有主要的商业数据库的接口。
9.  GUI编程：Python支持GUI可以创建和移植到许多系统调用。
10. 可嵌入: 你可以将Python嵌入到C/C++程序，让你的程序的用户获得"脚本化"的能力。

### 4. Python发展历史 ###

Python发展历史：[https://baike.baidu.com/item/Python/407313?fr=aladdin][https_baike.baidu.com_item_Python_407313_fr_aladdin]

### 5. Python版本 ###

*  Python 2.X
 *  Python 3.X

## 二、Python解释器 ##

### 1. 解释器的作用 ###

*  Python解释器作用：运行文件
 *  Python解释器种类
    
    1.  CPython，C语言开发的解释器\[官方\]，应用广泛的解释器。
    2.  IPython，基于CPython的一种交互式解释器。
    3.  其他解释器
        
         *  PyPy，基于Python语言开发的解释器。
         *  Jython，运行在Java平台的解释器，直接把Python代码编译成Java字节码执行。
         *  IronPython，运行在微软.Net平台上的Python解释器，可以直接把Python代码编译成.Net的字节码。

### 2. 解释器的安装 ###

Python解释器的安装：[https://blog.csdn.net/weixin\_43495473/article/details/103559812][https_blog.csdn.net_weixin_43495473_article_details_103559812]

## 三、PyCharm安装与使用 ##

### 1. PyCharm的作用 ###

PyCharm是一种Python IDE（集成开发环境），带有一整套可以帮助用户在使用Python语言开发时提高其效率的工具，内部集成的功能如下：

*  Project管理
 *  智能提示
 *  语法高亮
 *  代码跳转
 *  调试代码
 *  解释代码(解释器)
 *  框架和库
 *  …

### 2. PyCharm安装与使用 ###

PyCharm的安装：[https://blog.csdn.net/weixin\_43495473/article/details/103560198][https_blog.csdn.net_weixin_43495473_article_details_103560198]

## 四、注释 ##

### 1. 注释的作用 ###

通过用自己熟悉的语言，在程序中对某些代码进行标注说明，这就是注释的作用，能够大大增强程序的可读性。

### 2. 注释的分类及语法 ###

注释分为两类：单行注释 和 多行注释。

*  单行注释

只能注释一行内容，语法如下：

# 注释内容

*  多行注释

可以注释多行内容，一般用在注释一段代码的情况， 语法如下：

""" 第一行注释 第二行注释 第三行注释 """
    
    ''' 注释1 注释2 注释3 '''

> 快捷键： ctrl + /

**注意：解释器不执行任何的注释内容。**

## 五、变量 ##

### 1. 变量的作用 ###

变量，简单来说，其实就是计算机内存中的一块储存空间，用来存储CPU需要使用的数据。 而这个储存空间需要一个名字，这个名字的统称就叫变量。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0_size_16_color_FFFFFF_t_70 3]  
作用：

1.  用来临时保存数据
2.  便于项目的后期升级维护
3.  节约内存

### 2. 定义变量 ###

变量名 = 值

**变量名自定义，要满足标识符命名规则。**

#### 2.1 标识符 ####

标识符命名规则是Python中定义各种名字的时候的统一规范，具体如下：

*  由数字、字母、下划线组成
 *  不能数字开头
 *  不能使用内置关键字
 *  严格区分大小写

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

#### 2.2 命名习惯 ####

*  见名知义。
 *  大驼峰：即每个单词首字母都大写，例如：`MyName`。
 *  小驼峰：第二个（含）以后的单词首字母大写，例如：`myName`。
 *  下划线：例如：`my_name`。

#### 2.3 使用变量 ####

my_name = "张三"
    print(my_name)
    
    myAge = 23
    print(myAge)

#### 2.4 认识bug ####

所谓bug，就是程序中的错误。如果程序有错误，需要程序员排查问题，纠正错误。

#### 2.5 Debug工具 ####

Debug工具是PyCharm IDE中集成的用来调试程序的工具，在这里程序员可以查看程序的执行细节和流程或者调解bug。

Debug工具使用步骤：

1.  打断点
2.  Debug调试

## 六、数据类型 ##

**在 Python 里为了应对不同的业务需求，也把数据分为不同的类型。**

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

> 检测数据类型的方法：`type(变量名或者数值)`

a = 1
    print(type(a))  # <class 'int'> -- 整型
    
    b = 1.1
    print(type(b))  # <class 'float'> -- 浮点型
    
    c = True
    print(type(c))  # <class 'bool'> -- 布尔型
    
    d = "12345"
    print(type(d))  # <class 'str'> -- 字符串
    
    e = [10, 20, 30]
    print(type(e))  # <class 'list'> -- 列表
    
    f = (10, 20, 30)
    print(type(f))  # <class 'tuple'> -- 元组
    
    h = { 10, 20, 30}
    print(type(h))  # <class 'set'> -- 集合
    
    g = { "name": "张三", "age": 20}
    print(type(g))  # <class 'dict'> -- 字典

思考：

1.  为什么Python会提出这么多种的数据类型?

> 有限的内存, 无限的变量, 合理的使用内存

1.  Python中，程序员定义变量需要关心变量的类型吗?

>  *  Python弱类型语言
>  *  程序员不需要关心变量的类型, 只需要把数据书写正确即可，python会通过自动推到出您变量的类型。

## 七、输出 ##

**作用：程序输出内容给用户。**

print('hello Python')
    
    age = 18
    print(age)
    
    # 需求：输出“今年我的年龄是18岁”

### 1. 格式化输出 ###

<table> 
 <thead> 
  <tr> 
   <th align="center">格式符号</th> 
   <th align="center">转换</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">%s</td> 
   <td align="center">字符串</td> 
  </tr> 
  <tr> 
   <td align="center">%d</td> 
   <td align="center">有符号的十进制整数</td> 
  </tr> 
  <tr> 
   <td align="center">%f</td> 
   <td align="center">浮点数</td> 
  </tr> 
  <tr> 
   <td align="center">%c</td> 
   <td align="center">字符</td> 
  </tr> 
  <tr> 
   <td align="center">%u</td> 
   <td align="center">无符号十进制整数</td> 
  </tr> 
  <tr> 
   <td align="center">%o</td> 
   <td align="center">八进制整数</td> 
  </tr> 
  <tr> 
   <td align="center">%x</td> 
   <td align="center">十六进制整数（小写ox）</td> 
  </tr> 
  <tr> 
   <td align="center">%X</td> 
   <td align="center">十六进制整数（大写OX）</td> 
  </tr> 
  <tr> 
   <td align="center">%e</td> 
   <td align="center">科学计数法（小写’e’）</td> 
  </tr> 
  <tr> 
   <td align="center">%E</td> 
   <td align="center">科学计数法（大写’E’）</td> 
  </tr> 
  <tr> 
   <td align="center">%g</td> 
   <td align="center">%f和%e的简写</td> 
  </tr> 
  <tr> 
   <td align="center">%G</td> 
   <td align="center">%f和%E的简写</td> 
  </tr> 
 </tbody> 
</table>

>  *  %06d，表示输出的整数显示位数，不足以0补全，超出当前位数则原样输出。
>  *  %.2f，表示小数点后显示的小数位数。

### 2. 内置函数format ###

format()用于字符串格式化，功能非常强大，格式是str.format()，format函数可以接受不限个参数，位置可以不按顺序。

### 3. f-格式化字符串 ###

f-string是格式化字符串的一种很好的新方法。与其他格式化方式相比，它不仅更易读，更简洁，不易出错，而且速度更快！格式为：`f'{表达式}'`。

### 4. 体验格式化字符串 ###

name = "张三"
    age = 23
    weight = 75.5
    student_id = 1
    
    # 我的名字是张三
    print('我的名字是%s' % name)
    
    # 我的学号是0001
    print('我的学号是%04d' % student_id)
    
    # 我的体重是75.50公斤
    print('我的体重是%.2f公斤' % weight)
    
    # 我的名字是张三，今年23岁了
    print('我的名字是%s，今年%d岁了' % (name, age))
    
    # 我的名字是张三，明年24岁了
    print('我的名字是%s，明年%d岁了' % (name, age + 1))
    
    # 我的名字是张三，明年24岁了
    print('我的名字是{0}, 明年{1}岁了'.format(name, age+1))
    
    # 我的名字是李思，今年18岁了
    print('我的名字是{0}, 今年{1}岁了'.format("李思", 18))
    
    # 我的名字是张三，明年24岁了
    print(f'我的名字是{name}, 明年{age + 1}岁了')

![在这里插入图片描述][2020063017412140.png]

### 5. 补充知识 ###

字符串输出的本质其实就是拼接字符串，那么我们都用`%s`完全也是可以的。很多时候，我们不用区分整型、浮点型等，直接用`%s`输出就可以了。

print('我的名字是%s，今年%s岁了，我的体重是%s公斤' % (name, age ,weight))

![在这里插入图片描述][20200630174532554.png]

### 6. 转义字符 ###

*  `\n`：换行。
 *  `\t`：制表符，一个tab键（4个空格）的距离。

### 7. 结束符 ###

# print会默认换行输出
    print('输出的内容', end="\n")

> 在Python中，print()， 默认自带`end="\n"`这个换行结束符，所以导致每两个`print`直接会换行展示，用户可以按需求更改结束符。

# 改变Python换行输出
    print('内容', end=" ")
    print('内容', end="···")

## 八、输入 ##

**在Python中，程序接收用户输入的数据的功能即是输入。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0_size_16_color_FFFFFF_t_70 6]

### 1. 输入的语法 ###

input("提示信息")

### 2. 输入的特点 ###

*  当程序执行到`input`，等待用户输入，输入完成之后才继续向下执行。
 *  在Python中，`input`接收用户输入后，一般存储到变量，方便使用。
 *  在Python中，`input`会把接收到的任意用户输入的数据都当做字符串处理。

password = input('请输入您的密码：')
    
    print(f'您输入的密码是{password}')
    # <class 'str'>
    print(type(password))

![在这里插入图片描述][20200630175345998.png]

## 九、转换数据类型 ##

### 1. 转换数据类型的作用 ###

问：input()接收用户输入的数据都是字符串类型，如果用户输入1，想得到整型该如何操作？

答：转换数据类型即可，即将字符串类型转换成整型。

### 2. 转换数据类型的函数 ###

<table> 
 <thead> 
  <tr> 
   <th align="center">函数</th> 
   <th align="center">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">int(x [,base ])</td> 
   <td align="center">将x转换为一个整数</td> 
  </tr> 
  <tr> 
   <td align="center">float(x )</td> 
   <td align="center">将x转换为一个浮点数</td> 
  </tr> 
  <tr> 
   <td align="center">complex(real [,imag ])</td> 
   <td align="center">创建一个复数，real为实部，imag为虚部</td> 
  </tr> 
  <tr> 
   <td align="center">str(x )</td> 
   <td align="center">将对象 x 转换为字符串</td> 
  </tr> 
  <tr> 
   <td align="center">repr(x )</td> 
   <td align="center">将对象 x 转换为表达式字符串</td> 
  </tr> 
  <tr> 
   <td align="center">eval(str )</td> 
   <td align="center">用来计算在字符串中的有效Python表达式,并返回一个对象</td> 
  </tr> 
  <tr> 
   <td align="center">tuple(s )</td> 
   <td align="center">将序列 s 转换为一个元组</td> 
  </tr> 
  <tr> 
   <td align="center">list(s )</td> 
   <td align="center">将序列 s 转换为一个列表</td> 
  </tr> 
  <tr> 
   <td align="center">chr(x )</td> 
   <td align="center">将一个整数转换为一个Unicode字符</td> 
  </tr> 
  <tr> 
   <td align="center">ord(x )</td> 
   <td align="center">将一个字符转换为它的ASCII整数值</td> 
  </tr> 
  <tr> 
   <td align="center">hex(x )</td> 
   <td align="center">将一个整数转换为一个十六进制字符串</td> 
  </tr> 
  <tr> 
   <td align="center">oct(x )</td> 
   <td align="center">将一个整数转换为一个八进制字符串</td> 
  </tr> 
  <tr> 
   <td align="center">bin(x )</td> 
   <td align="center">将一个整数转换为一个二进制字符串</td> 
  </tr> 
 </tbody> 
</table>

### 3. 体验转换数据类型 ###

需求：input接收用户输入，用户输入“1”，将这个数据1转换成整型。

# 1. 接收用户输入
    num = input('请输入您的幸运数字：')
    
    # 2. 打印结果
    print(f"您的幸运数字是{num}")
    
    
    # 3. 检测接收到的用户输入的数据类型 -- str类型
    print(type(num))
    
    # 4. 转换数据类型为整型 -- int类型
    print(type(int(num)))

# 1. float() -- 转换成浮点型
    num1 = 1
    print(float(num1))
    print(type(float(num1)))
    
    # 2. str() -- 转换成字符串类型
    num2 = 10
    print(type(str(num2)))
    
    # 3. tuple() -- 将一个序列转换成元组
    list1 = [10, 20, 30]
    print(tuple(list1))
    print(type(tuple(list1)))
    
    
    # 4. list() -- 将一个序列转换成列表
    t1 = (100, 200, 300)
    print(list(t1))
    print(type(list(t1)))
    
    # 5. eval() -- 将字符串中的数据转换成Python表达式原本类型
    str1 = '10'
    str2 = '[1, 2, 3]'
    str3 = '(1000, 2000, 3000)'
    print(type(eval(str1)))
    print(type(eval(str2)))
    print(type(eval(str3)))

## 十、运算符 ##

### 1. 运算符的分类 ###

*  算数运算符
 *  赋值运算符
 *  复合赋值运算符
 *  比较运算符
 *  逻辑运算符

### 2. 算数运算符 ###

<table> 
 <thead> 
  <tr> 
   <th align="center">运算符</th> 
   <th align="center">描述</th> 
   <th>实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">+</td> 
   <td align="center">加</td> 
   <td>1 + 1 输出结果为 2</td> 
  </tr> 
  <tr> 
   <td align="center">-</td> 
   <td align="center">减</td> 
   <td>1-1 输出结果为 0</td> 
  </tr> 
  <tr> 
   <td align="center">*</td> 
   <td align="center">乘</td> 
   <td>2 * 2 输出结果为 4</td> 
  </tr> 
  <tr> 
   <td align="center">/</td> 
   <td align="center">除</td> 
   <td>10 / 2 输出结果为 5</td> 
  </tr> 
  <tr> 
   <td align="center">//</td> 
   <td align="center">整除</td> 
   <td>9 // 4 输出结果为2</td> 
  </tr> 
  <tr> 
   <td align="center">%</td> 
   <td align="center">取余</td> 
   <td>9 % 4 输出结果为 1</td> 
  </tr> 
  <tr> 
   <td align="center">**</td> 
   <td align="center">指数</td> 
   <td>2 ** 4 输出结果为 16，即 2 * 2 * 2 * 2</td> 
  </tr> 
  <tr> 
   <td align="center">()</td> 
   <td align="center">小括号</td> 
   <td>小括号用来提高运算优先级，即 (1 + 2) * 3 输出结果为 9</td> 
  </tr> 
 </tbody> 
</table>

> 混合运算优先级顺序：`()`高于 `**` 高于 `*` `/` `//` `%` 高于 `+` `-`

### 3. 赋值运算符 ###

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>=</td> 
   <td>赋值</td> 
   <td>将<code>=</code>右侧的结果赋值给等号左侧的变量</td> 
  </tr> 
 </tbody> 
</table>

1.  单个变量赋值

num = 1
    print(num)

1.  多个变量赋值

num1, float1, str1 = 10, 0.5, 'hello world'
    print(num1)
    print(float1)
    print(str1)

1.  多变量赋相同值

a = b = 10
    print(a)
    print(b)

### 4. 复合赋值运算符 ###

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>+=</td> 
   <td>加法赋值运算符</td> 
   <td>c += a 等价于 c = c + a</td> 
  </tr> 
  <tr> 
   <td>-=</td> 
   <td>减法赋值运算符</td> 
   <td>c -= a 等价于 c = c- a</td> 
  </tr> 
  <tr> 
   <td>*=</td> 
   <td>乘法赋值运算符</td> 
   <td>c *= a 等价于 c = c * a</td> 
  </tr> 
  <tr> 
   <td>/=</td> 
   <td>除法赋值运算符</td> 
   <td>c /= a 等价于 c = c / a</td> 
  </tr> 
  <tr> 
   <td>//=</td> 
   <td>整除赋值运算符</td> 
   <td>c //= a 等价于 c = c // a</td> 
  </tr> 
  <tr> 
   <td>%=</td> 
   <td>取余赋值运算符</td> 
   <td>c %= a 等价于 c = c % a</td> 
  </tr> 
  <tr> 
   <td>**=</td> 
   <td>幂赋值运算符</td> 
   <td>c ** = a 等价于 c = c ** a</td> 
  </tr> 
 </tbody> 
</table>

a = 100
    a += 1
    # 输出101 a = a + 1,最终a = 100 + 1
    print(a)
    
    b = 2
    b *= 3
    # 输出6 b = b * 3,最终b = 2 * 3
    print(b)
    
    c = 10
    c += 1 + 2
    # 输出13, 先算运算符右侧1 + 2 = 3， c += 3 , 推导出c = 10 + 3
    print(c)

### 5. 比较运算符 ###

**比较运算符也叫关系运算符， 通常用来判断。**

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>==</td> 
   <td>判断相等。如果两个操作数的结果相等，则条件结果为真(True)，否则条件结果为假(False)</td> 
   <td>如a=3,b=3，则（a == b) 为 True</td> 
  </tr> 
  <tr> 
   <td>!=</td> 
   <td>不等于 。如果两个操作数的结果不相等，则条件为真(True)，否则条件结果为假(False)</td> 
   <td>如a=3,b=3，则（a == b) 为 True如a=1,b=3，则(a != b) 为 True</td> 
  </tr> 
  <tr> 
   <td>&gt;</td> 
   <td>运算符左侧操作数结果是否大于右侧操作数结果，如果大于，则条件为真，否则为假</td> 
   <td>如a=7,b=3，则(a &gt; b) 为 True</td> 
  </tr> 
  <tr> 
   <td>&lt;</td> 
   <td>运算符左侧操作数结果是否小于右侧操作数结果，如果小于，则条件为真，否则为假</td> 
   <td>如a=7,b=3，则(a &lt; b) 为 False</td> 
  </tr> 
  <tr> 
   <td>&gt;=</td> 
   <td>运算符左侧操作数结果是否大于等于右侧操作数结果，如果大于，则条件为真，否则为假</td> 
   <td>如a=7,b=3，则(a &lt; b) 为 False如a=3,b=3，则(a &gt;= b) 为 True</td> 
  </tr> 
  <tr> 
   <td>&lt;=</td> 
   <td>运算符左侧操作数结果是否小于等于右侧操作数结果，如果小于，则条件为真，否则为假</td> 
   <td>如a=3,b=3，则(a &lt;= b) 为 True</td> 
  </tr> 
 </tbody> 
</table>

a = 7
    b = 5
    print(a == b)  # False
    print(a != b)  # True
    print(a < b)   # False
    print(a > b)   # True
    print(a <= b)  # False
    print(a >= b)  # True

### 6. 逻辑运算符 ###

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>逻辑表达式</th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>and</td> 
   <td>x and y</td> 
   <td>布尔"与"：如果 x 为 False，x and y 返回 False，否则它返回 y 的值。</td> 
   <td>True and False， 返回 False。</td> 
  </tr> 
  <tr> 
   <td>or</td> 
   <td>x or y</td> 
   <td>布尔"或"：如果 x 是 True，它返回 True，否则它返回 y 的值。</td> 
   <td>False or True， 返回 True。</td> 
  </tr> 
  <tr> 
   <td>not</td> 
   <td>not x</td> 
   <td>布尔"非"：如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。</td> 
   <td>not True 返回 False, not False 返回 True</td> 
  </tr> 
 </tbody> 
</table>

a = 1
    b = 2
    c = 3
    print((a < b) and (b < c))  # True
    print((a > b) and (b < c))  # False
    print((a > b) or (b < c))   # True
    print(not (a > b))          # True

### 7. 补充知识 ###

数字之间的逻辑运算

a = 0
    b = 1
    c = 2
    
    # and运算符，只要有一个值为0，则结果为0，否则结果为最后一个非0数字
    print(a and b)  # 0
    print(b and a)  # 0
    print(a and c)  # 0
    print(c and a)  # 0
    print(b and c)  # 2
    print(c and b)  # 1
    
    # or运算符，只有所有值为0结果才为0，否则结果为第一个非0数字
    print(a or b)  # 1
    print(a or c)  # 2
    print(b or c)  # 1

## 十一、条件语句 ##

### 1. 了解条件语句 ###

Python条件语句是通过一条或多条语句的执行结果（True或者False）来决定执行的代码块。

### 2. if语法 ###

if 条件:
        条件成立执行的代码1
        条件成立执行的代码2
        ......

#### 2.1 体验if语句 ####

if True:
        print('条件成立执行的代码1')
        print('条件成立执行的代码2')
    
    # 下方的代码没有缩进到if语句块，所以和if条件无关
    print('我是无论条件是否成立都要执行的代码')

![在这里插入图片描述][20200630183252892.png]

#### 2.2 简单版：网吧上网 ####

需求分析：如果用户年龄大于等于18岁，即成年，输出"已经成年，可以上网"。

age = 20
    if age >= 18:
        print('已经成年，可以上网')
    
    print('系统关闭')

#### 2.3 进阶版：网吧上网 ####

新增需求：用户可以输出自己的年龄，然后系统进行判断是否成年，成年则输出"您的年龄是’用户输入的年龄’，已经成年，可以上网"。

# input接受用户输入的数据是字符串类型，条件是age和整型18做判断，所以这里要int转换数据类型
    age = int(input('请输入您的年龄：'))
    
    if age >= 18:
        print(f'您的年龄是{age},已经成年，可以上网')
    
    
    print('系统关闭')

### 3. if…else… ###

作用：条件成立执行if下方的代码; 条件不成立执行else下方的代码。

if 条件:
        条件成立执行的代码1
        条件成立执行的代码2
        ......
    else:
        条件不成立执行的代码1
        条件不成立执行的代码2
        ......

> 思考：网吧上网的实例，如果成年，允许上网，如果不成年呢？是不是应该回复用户不能上网？

#### 3.1 实用版：网吧上网 ####

age = int(input('请输入您的年龄：'))
    
    if age >= 18:
        print(f'您的年龄是{age},已经成年，可以上网')
    else:
        print(f'您的年龄是{age},未成年，请自行回家写作业')
    
    print('系统关闭')

> 注意：如果条件成立执行了某些代码，那么其他的情况的代码将不会执行。

### 4. 多重判断 ###

if 条件1:
        条件1成立执行的代码1
        条件1成立执行的代码2
        ......
    elif 条件2：
    	条件2成立执行的代码1
        条件2成立执行的代码2
        ......
    ......
    else:
        以上条件都不成立执行执行的代码

多重判断也可以和else配合使用。一般else放在整个if语句的最后，表示以上条件都不成立的时候执行的代码。

> 思考：中国合法工作年龄为18-60岁，即如果年龄小于18的情况为童工，不合法；如果年龄在18-60岁之间为合法工龄；大于60岁为法定退休年龄。

#### 4.1 实例：工龄判断 ####

age = int(input('请输入您的年龄：'))
    if age < 18:
        print(f'您的年龄是{age},童工一枚')
    elif (age >= 18) and (age <= 60):
        print(f'您的年龄是{age},合法工龄')
    elif age > 60:
        print(f'您的年龄是{age},可以退休')

> 拓展：`age >= 18 and age <= 60`可以化简为`18 <= age <= 60`。

### 5. if嵌套 ###

if 条件1：
    	条件1成立执行的代码
        条件1成立执行的代码
        
        if 条件2：
        	条件2成立执行的代码
            条件2成立执行的代码

注意：条件2的if也是出于条件1的缩进关系内部。

> 思考：坐公交：如果有钱可以上车，没钱不能上车；上车后如果有空座，则可以坐下；如果没空座，就要站着。怎么书写程序？

#### 5.1 实例：坐公交 ####

1.  判断是否能上车

""" 1. 如果有钱，则可以上车 2. 上车后，如果有空座，可以坐下 上车后，如果没有空座，则站着等空座位 如果没钱，不能上车 """
    # 假设用 money = 1 表示有钱, money = 0表示没有钱
    money = 1
    if money == 1:
        print('土豪，不差钱，顺利上车')
    else:
        print('没钱，不能上车，追着公交车跑')

1.  判断是否能坐下

""" 1. 如果有钱，则可以上车 2. 上车后，如果有空座，可以坐下 上车后，如果没有空座，则站着等空座位 如果没钱，不能上车 """
    # 假设用 money = 1 表示有钱, money = 0表示没有钱; seat = 1 表示有空座，seat = 0 表示没有空座
    money = 1
    seat = 0
    if money == 1:
        print('土豪，不差钱，顺利上车')
        if seat == 1:
            print('有空座，可以坐下')
        else:
            print('没有空座，站等')
    else:
        print('没钱，不能上车，追着公交车跑')

#### 5.2 if嵌套执行流程 ####

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

### 6. 应用：猜拳游戏 ###

需求分析：

*  参与游戏的角色
    
     *  玩家
        
         *  手动出拳
     *  电脑
        
         *  随机出拳
 *  判断输赢
    
     *  玩家获胜
    
    <table> 
     <thead> 
      <tr> 
       <th>玩家</th> 
       <th>电脑</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>石头</td> 
       <td>剪刀</td> 
      </tr> 
      <tr> 
       <td>剪刀</td> 
       <td>布</td> 
      </tr> 
      <tr> 
       <td>布</td> 
       <td>石头</td> 
      </tr> 
     </tbody> 
    </table>
    
     *  平局
        
         *  玩家出拳 和 电脑出拳相同
     *  电脑获胜

随机做法：

1.  导出random模块

import 模块名

1.  使用random模块中的随机整数功能

random.randint(开始,结束)

#### 6.1 初始版：猜拳游戏 ####

""" 提示：0-石头，1-剪刀，2-布 3. 出拳 玩家输入出拳 电脑随机出拳 4. 判断输赢 玩家获胜 平局 电脑获胜 """
    
    # 导入random模块
    import random
    
    # 计算电脑出拳的随机数字
    computer = random.randint(0, 2)
    print(computer)
    
    player = int(input('请出拳：0-石头，1-剪刀，2-布：'))
    
    # 玩家胜利 p0:c1 或 p1:c2 或 p2:c0
    if (player == 0 and computer == 1) or (player == 1 and computer == 2) or (player == 2 and computer == 0):
        print('玩家获胜')
    
    # 平局：玩家 == 电脑
    elif player == computer:
        print('平局')
    else:
        print('电脑获胜')

#### 6.2 进阶版：猜拳游戏 ####

""" 石头剪刀布游戏 玩家VS电脑 站在玩家的角度，分析胜利、失败、平局 0-石头，1-剪刀，2-布 """
    # 导入随机数模块
    import random
    
    import sys
    
    print("-----欢迎来到人机对战小游戏-----")
    name = input("请输入您的游戏名：")
    while True:
        stats = input("欢迎“%s”来到本游戏，开始游戏输入Y，退出游戏输入N，请您输入：" % name)
        if stats == "Y" or stats == "y":
            print("游戏开始……")
            print("石头输入0、剪刀输入1、布输入2")
            break
        elif stats == "N" or stats == "n":
            print("游戏结束……")
            sys.exit(0)
        else:
            print("请按照要求重新输入！")
    print("-------------加载中-------------")
    
    
    def Game(user, comp):
        if (user== 0 and comp== 1) or (user== 1 and comp== 2) or (user== 2 and comp== 0):
            print("机器输入%d，您赢了！" % comp)
        elif user == comp:
            print("机器输入%d，平局了！" % comp)
        else:
            print("机器输入%d，您输了！" % comp)
        res = input("重新游戏请输入X，退出游戏按任意键")
        if res == "X" or res == "x":
            return
        else:
            sys.exit(0)
    
    
    while True:
        user = int(input("请您出拳，输入相应数字！"))
        if user == 0 or user == 1 or user == 2:
            comp = random.randint(0, 2)
            Game(user, comp)
        else:
            print("输入数字有误，请确认后，重新输入！")

### 7. 三目运算符 ###

**三目运算符也叫三元运算符。**

语法如下：

值1 if 条件 else 值2

快速体验：

a = 1
    b = 2
    
    c = a if a > b else b
    print(c)

## 十二、循环简介 ##

### 1. 循环的作用 ###

**让代码更高效的重复执行。**

### 2. 循环的分类 ###

在Python中，循环分为`while`和`for`两种，最终实现效果相同。

### 3. while的语法 ###

while 条件:
        条件成立重复执行的代码1
        条件成立重复执行的代码2
        ......

### 4. while循环快速体验 ###

需求：复现重复执行10次`print('Hello World')`。

分析：初始值是0次，终点是10次，重复做的事情输出“Hello World”。

# 循环的计数器
    i = 0
    while i < 10:
        print('Hello World')
        i += 1
    
    print('任务结束')

### 5. while的应用 ###

#### 5.1 应用一：计算1-100累加和 ####

分析：1-100的累加和，即1 + 2 + 3 + 4 +….，即前两个数字的相加结果 + 下一个数字( 前一个数字 + 1)。

i = 1
    result = 0
    while i <= 100:
        result += i
        i += 1
    
    # 输出5050
    print(result)

> 注意：为了验证程序的准确性，可以先改小数值，验证结果正确后，再改成1-100做累加。

#### 5.2 应用二：计算1-100偶数累加和 ####

分析：1-100的偶数和，即 2 + 4 + 6 + 8…，得到偶数的方法如下：

*  偶数即是和2取余结果为0的数字，可以加入条件语句判断是否为偶数，为偶数则累加
 *  初始值为0 / 2 , 计数器每次累加2

**方法一：条件判断和2取余数则累加**

# 方法一：条件判断和2取余数为0则累加计算
    i = 1
    result = 0
    while i <= 100:
        if i % 2 == 0:
            result += i
        i += 1
    
    # 输出2550
    print(result)

**方法二：计数器控制**

# 方法二：计数器控制增量为2
    i = 0
    result = 0
    while i <= 100:
        result += i
        i += 2
    
    # 输出2550
    print(result)

### 6. break和continue ###

**break和continue是循环中满足一定条件退出循环的两种不同方式。**

#### 6.1 理解 ####

举例：一共吃5个苹果，吃完第一个，吃第二个…，这里"吃苹果"的动作是不是重复执行？

情况一：如果吃的过程中，吃完第三个吃饱了，则不需要再吃第4个和第五个苹果，即是吃苹果的动作停止，这里就是break控制循环流程，即终止此循环。

情况二：如果吃的过程中，吃到第三个吃出一个大虫子…,是不是这个苹果就不吃了，开始吃第四个苹果，这里就是continue控制循环流程，即退出当前一次循环继而执行下一次循环代码。

#### 6.2 break实例 ####

i = 1
    while i <= 5:
        if i == 4:
            print(f'吃饱了不吃了')
            break
        print(f'吃了第{i}个苹果')
        i += 1

![在这里插入图片描述][2020071818190989.png]

#### 6.3 continue实例 ####

i = 1
    while i <= 5:
        if i == 3:
            print(f'大虫子，第{i}个不吃了')
            # 在continue之前一定要修改计数器，否则会陷入死循环
            i += 1
            continue
        print(f'吃了第{i}个苹果')
        i += 1

![在这里插入图片描述][20200718184445477.png]

### 7. while循环嵌套 ###

#### 7.1 语法 ####

while 条件1:
        条件1成立执行的代码
        ......
        while 条件2:
            条件2成立执行的代码
            ......

> 总结：所谓while循环嵌套，就是一个while里面嵌套一个while的写法，每个while和之前的基础语法是相同的。

#### 7.2 执行过程 ####

当内部循环执行完成之后，再执行下一次外部循环的条件判断。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0_size_16_color_FFFFFF_t_70 8]

#### 7.3 while循环嵌套应用 ####

**应用一：打印星号（正方形）**

# 重复打印5行星星
    j = 0
    while j <= 4:
        # 一行星星的打印
        i = 0
        while i <= 4:
            # 一行内的星星不能换行，取消print默认结束符\n
            print('*', end='')
            i += 1
        # 每行结束要换行，这里借助一个空的print，利用print默认结束符换行
        print()
        j += 1

![在这里插入图片描述][20200718185904513.png]  
**应用二：打印星号（三角形）**

# 重复打印5行星星
    # j表示行号
    j = 0
    while j <= 4:
        # 一行星星的打印
        i = 0
        # i表示每行里面星星的个数，这个数字要和行号相等所以i要和j联动
        while i <= j:
            print('*', end='')
            i += 1
        print()
        j += 1

![在这里插入图片描述][20200718192702134.png]  
**应用二：九九乘法表**

# 重复打印9行表达式
    j = 1
    while j <= 9:
        # 打印一行里面的表达式 a * b = a*b
        i = 1
        while i <= j:
            print(f'{i}*{j}={j*i}', end='\t')
            i += 1
        print()
        j += 1

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

### 8. for循环 ###

#### 8.1 语法 ####

for 临时变量 in 序列:
        重复执行的代码1
        重复执行的代码2
        ......

#### 8.2 快速体验 ####

str1 = 'Hello World'
    for i in str1:
        print(i)

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

#### 8.3 break ####

str1 = 'Hello World'
    for i in str1:
        if i == 'e':
            print('遇到e不打印')
            break
        print(i)

![在这里插入图片描述][20200718193130752.png]

#### 8.4 continue ####

str1 = 'Hello World'
    for i in str1:
        if i == 'e':
            print('遇到e不打印')
            continue
        print(i)

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

## 十三、else ##

循环可以和else配合使用，else下方缩进的代码指的是当循环正常结束之后要执行的代码。

### 1. while…else ###

#### 1.1 语法 ####

while 条件:
        条件成立重复执行的代码
    else:
        循环正常结束之后要执行的代码

#### 1.2 示例 ####

i = 1
    while i <= 5:
        print('Hello World')
        i += 1
    else:
        print('执行完毕')

![在这里插入图片描述][20200718193648276.png]

#### 1.3 退出循环的方式 ####

1.  break终止循环

i = 1
    while i <= 5:
        if i == 3:
            print("提前结束")
            break
        print('Hello World')
        i += 1
    else:
        print('执行完毕')

![在这里插入图片描述][20200718193909137.png]

> 所谓else指的是循环正常结束之后要执行的代码，即如果是break终止循环的情况，else下方缩进的代码将不执行。

1.  continue控制循环

i = 1
    while i <= 5:
        if i == 3:
            print("打断一下")
            i += 1
            continue
        print('Hello World')
        i += 1
    else:
        print('执行完毕')

![在这里插入图片描述][20200718194053236.png]

> 因为continue是退出当前一次循环，继续下一次循环，所以该循环在continue控制下是可以正常结束的，当循环结束后，则执行了else缩进的代码。

### 2. for…else ###

#### 2.1 语法 ####

for 临时变量 in 序列:
        重复执行的代码
        ...
    else:
        循环正常结束之后要执行的代码

> 所谓else指的是循环正常结束之后要执行的代码，即如果是break终止循环的情况，else下方缩进的代码将不执行。

#### 2.2 示例 ####

str1 = 'Hello World'
    for i in str1:
        print(i)
    else:
        print('循环正常结束之后执行的代码')

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

#### 2.3 退出循环的方式 ####

1.  break终止循环

str1 = 'Hello World'
    for i in str1:
        if i == 'e':
            print('遇到e不打印')
            break
        print(i)
    else:
        print('循环正常结束之后执行的代码')

![在这里插入图片描述][20200718194512861.png]

> 没有执行else缩进的代码。

1.  continue控制循环

str1 = 'Hello World'
    for i in str1:
        if i == 'e':
            print('遇到e不打印')
            continue
        print(i)
    else:
        print('循环正常结束之后执行的代码')

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

> 因为continue是退出当前一次循环，继续下一次循环，所以该循环在continue控制下是可以正常结束的，当循环结束后，则执行了else缩进的代码。

## 十四、字符串 ##

### 1. 认识字符串 ###

字符串是 Python 中最常用的数据类型。我们一般使用引号来创建字符串。创建字符串很简单，只要为变量分配一个值即可。

a = 'hello world'
    b = "abcdefg"
    print(type(a))
    print(type(b))

> 注意：控制台显示结果为`<class 'str'>`， 即数据类型为str(字符串)。

### 2. 字符串特征 ###

*  一对引号字符串

name1 = 'Tom'
    name2 = "Rose"

*  三引号字符串

name3 = ''' Tom '''
    name4 = """ Rose """
    a = ''' i am Tom, nice to meet you! '''
    
    b = """ i am Rose, nice to meet you! """

**注意：三引号形式的字符串支持换行。**

> 思考：如果创建一个字符串`I'm Tom`?

c = "I'm Tom"
    d = 'I\'m Tom'

### 3. 字符串输出 ###

print('hello world')
    
    name = 'Tom'
    print('我的名字是%s' % name)
    print(f'我的名字是{name}')

### 4. 字符串输入 ###

在Python中，使用`input()`接收用户输入。

name = input('请输入您的名字：')
    print(f'您输入的名字是{name}')
    print(type(name))
    
    password = input('请输入您的密码：')
    print(f'您输入的密码是{password}')
    print(type(password))

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

### 5. 下标 ###

#### 5.1 概念 ####

`“下标”`又叫`“索引”`，就是编号。比如火车座位号，座位号的作用：按照编号快速找到对应的座位。同理，下标的作用即是通过下标快速找到对应的数据。

#### 5.2 快速体验 ####

需求：字符串`name = "abcdef"`，取到不同下标对应的数据。

*  代码

name = "abcdef"
    
    print(name[1])
    print(name[0])
    print(name[2])

*  输出结果  
    ![在这里插入图片描述][2020071820255627.png]

> 注意：下标从0开始。  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0_size_16_color_FFFFFF_t_70 15]

### 6. 切片 ###

切片是指对操作的对象截取其中一部分的操作。**字符串、列表、元组**都支持切片操作。

#### 6.1 语法 ####

序列[开始位置下标:结束位置下标:步长]

> 注意：
> 
>  *  不包含结束位置下标对应的数据， 正负整数均可；  
>     步长是选取间隔，正负整数均可，默认步长为1。

#### 6.2 示例 ####

name = "abcdefg"
    
    print(name[2:5:1])  # cde
    print(name[2:5])  # cde
    print(name[:5])  # abcde
    print(name[1:])  # bcdefg
    print(name[:])  # abcdefg
    print(name[::2])  # aceg
    print(name[:-1])  # abcdef, 负1表示倒数第一个数据
    print(name[-4:-1])  # def
    print(name[::-1])  # gfedcba

### 7. 常用操作方法 ###

字符串的常用操作方法有查找、修改和判断三大类。

#### 7.1 查找 ####

所谓字符串查找方法即是查找子串在字符串中的位置或出现的次数。

*  find()：检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则返回-1。

1.  语法

字符串序列.find(子串, 开始位置下标, 结束位置下标)

> 注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。

1.  快速体验

mystr = "hello world and buran and list and Python"
    
    print(mystr.find('and'))  # 12
    print(mystr.find('and', 15, 30))  # 22
    print(mystr.find('ands'))  # -1

*  index()：检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则报异常。

1.  语法

字符串序列.index(子串, 开始位置下标, 结束位置下标)

> 注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。

1.  快速体验

mystr = "hello world and buran and list and Python"
    
    print(mystr.index('and'))  # 12
    print(mystr.index('and', 15, 30))  # 22
    print(mystr.index('ands'))  # 报错

*  rfind()： 和find()功能相同，但查找方向为右侧开始。
 *  rindex()：和index()功能相同，但查找方向为右侧开始。
 *  count()：返回某个子串在字符串中出现的次数。

1.  语法

字符串序列.count(子串, 开始位置下标, 结束位置下标)

> 注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。

1.  快速体验

mystr = "hello world and buran and list and Python"
    
    print(mystr.count('and'))  # 3
    print(mystr.count('ands'))  # 0
    print(mystr.count('and', 0, 20))  # 1

#### 7.2 修改 ####

所谓修改字符串，指的就是通过函数的形式修改字符串中的数据。

*  replace()：替换字符串。

1.  语法

字符串序列.replace(旧子串, 新子串, 替换次数)

> 注意：替换次数如果查出子串出现次数，则替换次数为该子串出现次数。

1.  快速体验

mystr = "hello world and buran and list and Python"
    
    print(mystr.replace('and', 'he'))
    # 结果：hello world he buran he list he Python
    print(mystr.replace('and', 'he', 10))
    # 结果：hello world he buran he list he Python
    print(mystr)
    # 结果：hello world and buran and list and Python

> 注意：数据按照是否能直接修改分为可变类型和不可变类型两种。字符串类型的数据修改的时候不能改变原有字符串，属于不能直接修改数据的类型即是不可变类型。

*  split()：按照指定字符分割字符串。

1.  语法

字符串序列.split(分割字符, num)

> 注意：num表示的是分割字符出现的次数，即将来返回数据个数为num+1个。

1.  快速体验

mystr = "hello world and buran and list and Python"
    
    print(mystr.split('and'))
    # 结果：['hello world ', ' buran ', ' list ', ' Python']
    print(mystr.split('and', 2))
    # 结果：['hello world ', ' buran ', ' list and Python']
    print(mystr.split(' '))
    # 结果：['hello', 'world', 'and', 'buran', 'and', 'list', 'and', 'Python']
    print(mystr.split(' ', 2))
    # 结果：['hello', 'world', 'and buran and list and Python']

> 注意：如果分割字符是原有字符串中的子串，分割后则丢失该子串。

*  join()：用一个字符或子串合并字符串，即是将多个字符串合并为一个新的字符串。

1.  语法

字符或子串.join(多字符串组成的序列)

1.  快速体验

list1 = ['hello', 'buran', 'list']
    t1 = ('aa', 'b', 'cc', 'ddd')
    
    print('_'.join(list1))
    # hello_buran_list
    print('...'.join(t1))
    # 结果：aa...b...cc...ddd

*  capitalize()：将字符串第一个字符转换成大写。

mystr = "hello world and buran and list and Python"
    
    print(mystr.capitalize())
    # 结果：Hello world and buran and list and python

> 注意：capitalize()函数转换后，只字符串第一个字符大写，其他的字符全都小写。

*  title()：将字符串每个单词首字母转换成大写。

mystr = "hello world and buran and list and Python"
    
    print(mystr.title())
    # 结果：Hello World And Buran And List And Python

*  lower()：将字符串中大写转小写。

mystr = "hello world and buran and list and Python"
    
    print(mystr.lower())
    # 结果：hello world and buran and list and python

*  upper()：将字符串中小写转大写。

mystr = "hello world and buran and list and Python"
    
    print(mystr.upper())
    # 结果：HELLO WORLD AND BURAN AND LIST AND PYTHON

*  lstrip()：删除字符串左侧空白字符。
 *  rstrip()：删除字符串右侧空白字符。
 *  strip()：删除字符串两侧空白字符。
 *  ljust()：返回一个原字符串左对齐,并使用指定字符(默认空格)填充至对应长度 的新字符串。
 *  rjust()：返回一个原字符串右对齐,并使用指定字符(默认空格)填充至对应长度 的新字符串，语法和ljust()相同。
 *  center()：返回一个原字符串居中对齐,并使用指定字符(默认空格)填充至对应长度 的新字符串，语法和ljust()相同。

#### 7.3 判断 ####

所谓判断即是判断真假，返回的结果是布尔型数据类型：True 或 False。

*  startswith()：检查字符串是否是以指定子串开头，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。

1.  语法

字符串序列.startswith(子串, 开始位置下标, 结束位置下标)

1.  快速体验

mystr = "hello world and buran and list and Python"
    
    print(mystr.startswith('hello'))
    # 结果：True
    print(mystr.startswith('hello', 5, 20))
    # 结果：False

*  endswith()：：检查字符串是否是以指定子串结尾，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。

1.  语法

字符串序列.endswith(子串, 开始位置下标, 结束位置下标)

1.  快速体验

mystr = "hello world and buran and list and Python"
    
    print(mystr.endswith('Python'))
    # 结果：True
    print(mystr.endswith('python'))
    # 结果：False
    print(mystr.endswith('Python', 2, 20))
    # 结果：False

*  isalpha()：如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False。

mystr1 = 'hello'
    mystr2 = 'hello12345'
    
    print(mystr1.isalpha())
    # 结果：True
    print(mystr2.isalpha())
    # 结果：False

*  isdigit()：如果字符串只包含数字则返回 True 否则返回 False。

mystr1 = 'aaa12345'
    mystr2 = '12345'
    
    print(mystr1.isdigit())
    # 结果： False
    print(mystr2.isdigit())
    # 结果：False

*  isalnum()：如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False。

mystr1 = 'aaa12345'
    mystr2 = '12345-'
    
    print(mystr1.isalnum())
    # 结果：True
    print(mystr2.isalnum())
    # 结果：False

*  isspace()：如果字符串中只包含空白，则返回 True，否则返回 False。

mystr1 = '1 2 3 4 5'
    mystr2 = ' '
    
    print(mystr1.isspace())
    # 结果：False
    print(mystr2.isspace())
    # 结果：True

## 十五、列表 ##

### 1. 列表的格式 ###

[数据1, 数据2, 数据3, 数据4......]

**列表可以一次性有序存储多个不同类型的数据。**

### 2. 列表的常用操作 ###

列表的作用是一次性存储多个数据，程序员可以对这些数据进行的操作有：增、删、改、查。

#### 2.1 查找 ####

1.  下标

name_list = ['Tom', 'Lily', 'Rose']
    
    print(name_list[0])  # Tom
    print(name_list[1])  # Lily
    print(name_list[2])  # Rose

1.  函数

*  index()：返回指定数据所在位置的下标 。

列表序列.index(数据, 开始位置下标, 结束位置下标)

name_list = ['Tom', 'Lily', 'Rose']
    
    print(name_list.index('Lily', 0, 2))  # 1

> 注意：如果查找的数据不存在则报错。

*  count()：统计指定数据在当前列表中出现的次数。

name_list = ['Tom', 'Lily', 'Rose']
    
    print(name_list.count('Lily'))  # 1

*  len()：访问列表长度，即列表中数据的个数。

name_list = ['Tom', 'Lily', 'Rose']
    
    print(len(name_list))  # 3

#### 2.2 判断是否存在 ####

*  in：判断指定数据在某个列表序列，如果在返回True，否则返回False。

name_list = ['Tom', 'Lily', 'Rose']
    
    # 结果：True
    print('Lily' in name_list)
    
    # 结果：False
    print('Lilys' in name_list)

*  not in：判断指定数据不在某个列表序列，如果不在返回True，否则返回False。

name_list = ['Tom', 'Lily', 'Rose']
    
    # 结果：False
    print('Lily' not in name_list)
    
    # 结果：True
    print('Lilys' not in name_list)

#### 2.2 增加 ####

**作用：增加指定数据到列表中。**

*  append()：列表结尾追加数据。

列表序列.append(数据)

name_list = ['Tom', 'Lily', 'Rose']
    
    name_list.append('xiaoming')
    
    # 结果：['Tom', 'Lily', 'Rose', 'xiaoming']
    print(name_list)

> 列表追加数据的时候，直接在原列表里面追加了指定数据，即修改了原列表，故列表为可变类型数据。

**注意点：如果append()追加的数据是一个序列，则追加整个序列到列表。**

name_list = ['Tom', 'Lily', 'Rose']
    
    name_list.append(['xiaoming', 'xiaohong'])
    
    # 结果：['Tom', 'Lily', 'Rose', ['xiaoming', 'xiaohong']]
    print(name_list)

*  extend()：列表结尾追加数据，如果数据是一个序列，则将这个序列的数据逐一添加到列表。

列表序列.extend(数据)

单个数据：

name_list = ['Tom', 'Lily', 'Rose']
    
    name_list.extend('xiaoming')
    
    # 结果：['Tom', 'Lily', 'Rose', 'x', 'i', 'a', 'o', 'm', 'i', 'n', 'g']
    print(name_list)

序列数据：

name_list = ['Tom', 'Lily', 'Rose']
    
    name_list.extend(['xiaoming', 'xiaohong'])
    
    # 结果：['Tom', 'Lily', 'Rose', 'xiaoming', 'xiaohong']
    print(name_list)

*  insert()：指定位置新增数据。

列表序列.insert(位置下标, 数据)

name_list = ['Tom', 'Lily', 'Rose']
    
    name_list.insert(1, 'xiaoming')
    
    # 结果：['Tom', 'xiaoming', 'Lily', 'Rose']
    print(name_list)

#### 2.3 删除 ####

*  del

del 目标
    # del(目标)

删除列表：

name_list = ['Tom', 'Lily', 'Rose']
    
    # 结果：报错提示：name 'name_list' is not defined
    del name_list
    print(name_list)

删除指定数据：

name_list = ['Tom', 'Lily', 'Rose']
    
    del name_list[0]
    
    # 结果：['Lily', 'Rose']
    print(name_list)

*  pop()：删除指定下标的数据(默认为最后一个)，并返回该数据。

列表序列.pop(下标)

name_list = ['Tom', 'Lily', 'Rose']
    
    del_name = name_list.pop(1)
    
    # 结果：Lily
    print(del_name)
    
    # 结果：['Tom', 'Rose']
    print(name_list)

*  remove()：移除列表中某个数据的第一个匹配项。

列表序列.remove(数据)

name_list = ['Tom', 'Lily', 'Rose']
    
    name_list.remove('Rose')
    
    # 结果：['Tom', 'Lily']
    print(name_list)

*  clear()：清空列表

name_list = ['Tom', 'Lily', 'Rose']
    
    name_list.clear()
    print(name_list) # 结果： []

#### 2.4 修改 ####

*  修改指定下标数据

name_list = ['Tom', 'Lily', 'Rose']
    
    name_list[0] = 'aaa'
    
    # 结果：['aaa', 'Lily', 'Rose']
    print(name_list)

*  逆置：reverse()

num_list = [1, 5, 2, 3, 6, 8]
    
    num_list.reverse()
    
    # 结果：[8, 6, 3, 2, 5, 1]
    print(num_list)

*  排序：sort()

列表序列.sort( key=None, reverse=False)

num_list = [1, 5, 2, 3, 6, 8]
    
    num_list.sort()
    
    # 结果：[1, 2, 3, 5, 6, 8]
    print(num_list)

> 注意：reverse表示排序规则，**reverse = True** 降序， **reverse = False** 升序（默认）

#### 2.5 复制 ####

*  函数：copy()

name_list = ['Tom', 'Lily', 'Rose']
    
    name_li2 = name_list.copy()
    
    # 结果：['Tom', 'Lily', 'Rose']
    print(name_li2)

### 3. 列表的循环遍历 ###

需求：依次打印列表中的各个数据。

#### 3.1 while ####

name_list = ['Tom', 'Lily', 'Rose']
    
    i = 0
    while i < len(name_list):
        print(name_list[i])
        i += 1

#### 3.2 for ####

name_list = ['Tom', 'Lily', 'Rose']
    
    for i in name_list:
        print(i)

### 4. 列表嵌套 ###

所谓列表嵌套指的就是一个列表里面包含了其他的子列表。

应用场景：要存储班级一、二、三三个班级学生姓名，且每个班级的学生姓名在一个列表。

name_list = [['小明', '小红', '小绿'], ['Tom', 'Lily', 'Rose'], ['张三', '李四', '王五']]

> 思考： 如何查找到数据"李四"？

# 第一步：按下标查找到李四所在的列表
    print(name_list[2])
    
    # 第二步：从李四所在的列表里面，再按下标找到数据李四
    print(name_list[2][1])

## 十六、元组 ##

**一个元组可以存储多个数据，元组内的数据是不能修改的。**

### 1. 定义元组 ###

元组特点：定义元组使用小括号，且逗号隔开各个数据，数据可以是不同的数据类型。

# 多个数据元组
    t1 = (10, 20, 30)
    
    # 单个数据元组
    t2 = (10,)

> 注意：如果定义的元组只有一个数据，那么这个数据后面也好添加逗号，否则数据类型为唯一的这个数据的数据类型。

t2 = (10,)
    print(type(t2))  # tuple
    
    t3 = (20)
    print(type(t3))  # int
    
    t4 = ('hello')
    print(type(t4))  # str

### 2. 元组的常见操作 ###

元组数据不支持修改，只支持查找，具体如下：

*  按下标查找数据

tuple1 = ('aa', 'bb', 'cc', 'bb')
    print(tuple1[0])  # aa

*  index()：查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表、字符串的index方法相同。

tuple1 = ('aa', 'bb', 'cc', 'bb')
    print(tuple1.index('aa'))  # 0

*  count()：统计某个数据在当前元组出现的次数。

tuple1 = ('aa', 'bb', 'cc', 'bb')
    print(tuple1.count('bb'))  # 2

*  len()：统计元组中数据的个数。

tuple1 = ('aa', 'bb', 'cc', 'bb')
    print(len(tuple1))  # 4

### 3. 元组的注意事项 ###

**元组内的直接数据如果修改则立即报错。**

tuple1 = ('aa', 'bb', 'cc', 'bb')
    tuple1[0] = 'aaa'

**但是如果元组里面有列表，修改列表里面的数据则是支持的，故自觉很重要。**

tuple2 = (10, 20, ['aa', 'bb', 'cc'], 50, 30)
    print(tuple2[2])  # 访问到列表
    
    # 结果：(10, 20, ['aaaaa', 'bb', 'cc'], 50, 30)
    tuple2[2][0] = 'aaaaa'
    print(tuple2)

## 十七、字典 ##

**字典里面的数据是以“键值对”形式出现，字典数据和数据顺序没有关系，即字典不支持下标，后期无论数据如何变化，只需要按照对应的键的名字查找数据即可。**

### 1. 创建字典的语法 ###

字典特点：

*  符号为大括号
 *  数据为键值对形式出现
 *  各个键值对之间用逗号隔开

# 有数据字典
    dict1 = { 'name': 'Tom', 'age': 20, 'gender': '男'}
    
    # 空字典
    dict2 = { }
    
    dict3 = dict()

> 注意：一般称冒号前面的为键(key)，简称k；冒号后面的为值(value)，简称v。

### 2. 字典常见操作 ###

#### 2.1 增 ####

写法：字典序列\[key\] = 值

> 注意：如果key存在则修改这个key对应的值；如果key不存在则新增此键值对。

dict1 = { 'name': 'Tom', 'age': 20, 'gender': '男'}
    
    dict1['name'] = 'Rose'
    # 结果：{'name': 'Rose', 'age': 20, 'gender': '男'}
    print(dict1)
    
    dict1['id'] = 110
    
    # {'name': 'Rose', 'age': 20, 'gender': '男', 'id': 110}
    print(dict1)

> 注意：字典为可变类型。

#### 2.2 删 ####

*  del() / del：删除字典或删除字典中指定键值对。

dict1 = { 'name': 'Tom', 'age': 20, 'gender': '男'}
    
    del dict1['gender']
    # 结果：{'name': 'Tom', 'age': 20}
    print(dict1)

*  clear()：清空字典

dict1 = { 'name': 'Tom', 'age': 20, 'gender': '男'}
    
    dict1.clear()
    print(dict1)  # {}

#### 2.3 改 ####

写法：字典序列\[key\] = 值

> 注意：如果key存在则修改这个key对应的值 ；如果key不存在则新增此键值对。

#### 2.4 查 ####

1.  key值查找

dict1 = { 'name': 'Tom', 'age': 20, 'gender': '男'}
    print(dict1['name'])  # Tom
    print(dict1['id'])  # 报错

> 如果当前查找的key存在，则返回对应的值；否则则报错。

1.  get()

字典序列.get(key, 默认值)

> 注意：如果当前查找的key不存在则返回第二个参数(默认值)，如果省略第二个参数，则返回None。

dict1 = { 'name': 'Tom', 'age': 20, 'gender': '男'}
    print(dict1.get('name'))  # Tom
    print(dict1.get('id', 110))  # 110
    print(dict1.get('id'))  # None

1.  keys()

dict1 = { 'name': 'Tom', 'age': 20, 'gender': '男'}
    print(dict1.keys())  # dict_keys(['name', 'age', 'gender'])

1.  values()

dict1 = { 'name': 'Tom', 'age': 20, 'gender': '男'}
    print(dict1.values())  # dict_values(['Tom', 20, '男'])

1.  items()

dict1 = { 'name': 'Tom', 'age': 20, 'gender': '男'}
    print(dict1.items())  # dict_items([('name', 'Tom'), ('age', 20), ('gender', '男')])

### 3. 字典的循环遍历 ###

#### 3.1 遍历字典的key ####

dict1 = { 'name': 'Tom', 'age': 20, 'gender': '男'}
    for key in dict1.keys():
        print(key)

#### 3.2 遍历字典的value ####

dict1 = { 'name': 'Tom', 'age': 20, 'gender': '男'}
    for value in dict1.values():
        print(value)

#### 3.3 遍历字典的元素 ####

dict1 = { 'name': 'Tom', 'age': 20, 'gender': '男'}
    for item in dict1.items():
        print(item)

#### 3.4 遍历字典的键值对 ####

dict1 = { 'name': 'Tom', 'age': 20, 'gender': '男'}
    for key, value in dict1.items():
        print(f'{key} = {value}')

## 十八、集合 ##

**集合具有确定性，无序性和去重性。**

### 1. 创建集合 ###

创建集合使用`{}`或`set()`， 但是如果要创建空集合只能使用`set()`，因为`{}`用来创建空字典。

s1 = { 10, 20, 30, 40, 50}
    print(s1)
    
    s2 = { 10, 30, 20, 10, 30, 40, 30, 50}
    print(s2)
    
    s3 = set('abcdefg')
    print(s3)
    
    s4 = set()
    print(type(s4))  # set
    
    s5 = { }
    print(type(s5))  # dict

> 特点：
> 
> 1.  集合可以去掉重复数据；
> 2.  集合数据是无序的，故不支持下标。

### 2. 集合常见操作方法 ###

#### 2.1 增加数据 ####

*  add()

s1 = { 10, 20}
    s1.add(100)
    s1.add(10)
    print(s1)  # {100, 10, 20}

> 因为集合有去重功能，所以，当向集合内追加的数据是当前集合已有数据的话，则不进行任何操作。

*  update(), 追加的数据是序列。

s1 = { 10, 20}
    # s1.update(100) # 报错
    s1.update([100, 200])
    s1.update('abc')
    print(s1)   # {'a', 100, 200, 10, 'b', 'c', 20}

#### 2.2 删除数据 ####

*  remove()，删除集合中的指定数据，如果数据不存在则报错。

s1 = { 10, 20}
    
    s1.remove(10)
    print(s1)
    
    s1.remove(10)  # 报错
    print(s1)

*  discard()，删除集合中的指定数据，如果数据不存在也不会报错。

s1 = { 10, 20}
    
    s1.discard(10)
    print(s1)
    
    s1.discard(10)
    print(s1)

*  pop()，随机删除集合中的某个数据，并返回这个数据。

s1 = { 10, 20, 30, 40, 50}
    
    del_num = s1.pop()
    print(del_num)
    print(s1)

#### 2.3 查找数据 ####

*  in：判断数据在集合序列
 *  not in：判断数据不在集合序列

s1 = { 10, 20, 30, 40, 50}
    
    print(10 in s1)
    print(10 not in s1)

## 十九、公共操作 ##

### 1. 运算符 ###

<table> 
 <thead> 
  <tr> 
   <th align="center">运算符</th> 
   <th align="center">描述</th> 
   <th align="center">支持的容器类型</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">+</td> 
   <td align="center">合并</td> 
   <td align="center">字符串、列表、元组</td> 
  </tr> 
  <tr> 
   <td align="center">*</td> 
   <td align="center">复制</td> 
   <td align="center">字符串、列表、元组</td> 
  </tr> 
  <tr> 
   <td align="center">in</td> 
   <td align="center">元素是否存在</td> 
   <td align="center">字符串、列表、元组、字典</td> 
  </tr> 
  <tr> 
   <td align="center">not in</td> 
   <td align="center">元素是否不存在</td> 
   <td align="center">字符串、列表、元组、字典</td> 
  </tr> 
 </tbody> 
</table>

#### 1.1 + ####

# 1. 字符串 
    str1 = 'aa'
    str2 = 'bb'
    str3 = str1 + str2
    print(str3)  # aabb
    
    
    # 2. 列表 
    list1 = [1, 2]
    list2 = [10, 20]
    list3 = list1 + list2
    print(list3)  # [1, 2, 10, 20]
    
    # 3. 元组 
    t1 = (1, 2)
    t2 = (10, 20)
    t3 = t1 + t2
    print(t3)  # (10, 20, 100, 200)

#### 1.2 \* ####

# 1. 字符串
    print('-' * 10)  # ----------
    
    # 2. 列表
    list1 = ['hello']
    print(list1 * 4)  # ['hello', 'hello', 'hello', 'hello']
    
    # 3. 元组
    t1 = ('world',)
    print(t1 * 4)  # ('world', 'world', 'world', 'world')

#### 1.3 in或not in ####

# 1. 字符串
    print('a' in 'abcd')  # True
    print('a' not in 'abcd')  # False
    
    # 2. 列表
    list1 = ['a', 'b', 'c', 'd']
    print('a' in list1)  # True
    print('a' not in list1)  # False
    
    # 3. 元组
    t1 = ('a', 'b', 'c', 'd')
    print('aa' in t1)  # False
    print('aa' not in t1)  # True

### 2. 公共方法 ###

<table> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>len()</td> 
   <td>计算容器中元素个数</td> 
  </tr> 
  <tr> 
   <td>del 或 del()</td> 
   <td>删除</td> 
  </tr> 
  <tr> 
   <td>max()</td> 
   <td>返回容器中元素最大值</td> 
  </tr> 
  <tr> 
   <td>min()</td> 
   <td>返回容器中元素最小值</td> 
  </tr> 
  <tr> 
   <td>range(start, end, step)</td> 
   <td>生成从start到end的数字，步长为 step，供for循环使用</td> 
  </tr> 
  <tr> 
   <td>enumerate()</td> 
   <td>函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。</td> 
  </tr> 
 </tbody> 
</table>

#### 2.1 len() ####

# 1. 字符串
    str1 = 'abcdefg'
    print(len(str1))  # 7
    
    # 2. 列表
    list1 = [10, 20, 30, 40]
    print(len(list1))  # 4
    
    # 3. 元组
    t1 = (10, 20, 30, 40, 50)
    print(len(t1))  # 5
    
    # 4. 集合
    s1 = { 10, 20, 30}
    print(len(s1))  # 3
    
    # 5. 字典
    dict1 = { 'name': 'Rose', 'age': 18}
    print(len(dict1))  # 2

#### 2.2 del() ####

# 1. 字符串
    str1 = 'abcdefg'
    del str1
    print(str1)
    
    # 2. 列表
    list1 = [10, 20, 30, 40]
    del(list1[0])
    print(list1)  # [20, 30, 40]

#### 2.3 max() ####

# 1. 字符串
    str1 = 'abcdefg'
    print(max(str1))  # g
    
    # 2. 列表
    list1 = [10, 20, 30, 40]
    print(max(list1))  # 40

#### 2.4 min() ####

# 1. 字符串
    str1 = 'abcdefg'
    print(min(str1))  # a
    
    # 2. 列表
    list1 = [10, 20, 30, 40]
    print(min(list1))  # 10

#### 2.5 range() ####

# 1 2 3 4 5 6 7 8 9
    for i in range(1, 10, 1):
        print(i)
    
    # 1 3 5 7 9
    for i in range(1, 10, 2):
        print(i)
    
    # 0 1 2 3 4 5 6 7 8 9
    for i in range(10):
        print(i)

> 注意：range()生成的序列不包含end数字。

#### 2.6 enumerate() ####

enumerate(可遍历对象, start=0)

> 注意：start参数用来设置遍历数据的下标的起始值，默认为0。

list1 = ['a', 'b', 'c', 'd', 'e']
    
    for i in enumerate(list1):
        print(i)
    
    for index, char in enumerate(list1, start=1):
        print(f'下标是{index}, 对应的字符是{char}')

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

### 3. 容器类型转换 ###

#### 3.1 tuple() ####

**作用：将某个序列转换成元组。**

list1 = [10, 20, 30, 40, 50, 20]
    s1 = { 100, 200, 300, 400, 500}
    
    print(tuple(list1))
    print(tuple(s1))

#### 3.2 list() ####

**作用：将某个序列转换成列表。**

t1 = ('a', 'b', 'c', 'd', 'e')
    s1 = { 100, 200, 300, 400, 500}
    
    print(list(t1))
    print(list(s1))

#### 3.3 set() ####

**作用：将某个序列转换成集合。**

list1 = [10, 20, 30, 40, 50, 20]
    t1 = ('a', 'b', 'c', 'd', 'e')
    
    print(set(list1))
    print(set(t1))

> 注意：
> 
> 1.  集合可以快速完成列表去重。
> 2.  集合不支持下标。

## 二十、推导式 ##

### 1. 列表推导式 ###

**作用：用一个表达式创建一个有规律的列表或控制一个有规律列表。**

列表推导式又叫列表生成式。

#### 1.1 快速体验 ####

需求：创建一个0-10的列表。

*  while循环实现

# 1. 准备一个空列表
    list1 = []
    
    # 2. 书写循环，依次追加数字到空列表list1中
    i = 0
    while i < 10:
        list1.append(i)
        i += 1
    
    print(list1)

*  for循环实现

list1 = []
    for i in range(10):
        list1.append(i)
    
    print(list1)

*  列表推导式实现

list1 = [i for i in range(10)]
    print(list1)

#### 1.2 带if的列表推导式 ####

需求：创建0-10的偶数列表

*  方法一：range()步长实现

list1 = [i for i in range(0, 10, 2)]
    print(list1)

*  方法二：if实现

list1 = [i for i in range(10) if i % 2 == 0]
    print(list1)

#### 1.3 多个for循环实现列表推导式 ####

需求：创建列表如下：

[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

*  代码如下：

list1 = [(i, j) for i in range(1, 3) for j in range(3)]
    print(list1)

### 2. 字典推导式 ###

**字典推导式作用：快速合并列表为字典或提取字典中目标数据。**

#### 2.1 快速体验 ####

1.  创建一个字典：字典key是1-5数字，value是这个数字的2次方。

dict1 = { i: i**2 for i in range(1, 5)}
    print(dict1)  # {1: 1, 2: 4, 3: 9, 4: 16}

1.  将两个列表合并为一个字典

list1 = ['name', 'age', 'gender']
    list2 = ['Tom', 20, 'man']
    
    dict1 = { list1[i]: list2[i] for i in range(len(list1))}
    print(dict1)

1.  提取字典中目标数据

counts = { 'MBP': 268, 'HP': 125, 'DELL': 201, 'Lenovo': 199, 'acer': 99}
    
    # 需求：提取上述电脑数量大于等于200的字典数据
    count1 = { key: value for key, value in counts.items() if value >= 200}
    print(count1)  # {'MBP': 268, 'DELL': 201}

### 3. 集合推导式 ###

需求：创建一个集合，数据为下方列表的2次方。

list1 = [1, 1, 2]

代码如下：

list1 = [1, 1, 2]
    set1 = { i ** 2 for i in list1}
    print(set1)  # {1, 4}

> 注意：集合有数据去重功能。

***补充：接下来的Python高级语法：函数、文件操作、面向对象、模块、包、异常等知识，我将陆续更新在自己的博客之中。如果本博文的知识能帮助到您的Python学习，本博主实属荣幸。更多后续知识，请关注博主，方便您第一时间查看，谢谢！***

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

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200630181125144.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200630160133585.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200630160612457.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0,size_16,color_FFFFFF,t_70
[https_baike.baidu.com_item_Python_407313_fr_aladdin]: https://baike.baidu.com/item/Python/407313?fr=aladdin
[https_blog.csdn.net_weixin_43495473_article_details_103559812]: https://blog.csdn.net/weixin_43495473/article/details/103559812
[https_blog.csdn.net_weixin_43495473_article_details_103560198]: https://blog.csdn.net/weixin_43495473/article/details/103560198
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200630164812899.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200630165207881.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200630165739123.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0,size_16,color_FFFFFF,t_70
[2020063017412140.png]: https://img-blog.csdnimg.cn/2020063017412140.png
[20200630174532554.png]: https://img-blog.csdnimg.cn/20200630174532554.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/2020063018072652.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0,size_16,color_FFFFFF,t_70
[20200630175345998.png]: https://img-blog.csdnimg.cn/20200630175345998.png
[20200630183252892.png]: https://img-blog.csdnimg.cn/20200630183252892.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20200701094142253.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0,size_16,color_FFFFFF,t_70
[2020071818190989.png]: https://img-blog.csdnimg.cn/2020071818190989.png
[20200718184445477.png]: https://img-blog.csdnimg.cn/20200718184445477.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20200718185621834.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0,size_16,color_FFFFFF,t_70
[20200718185904513.png]: https://img-blog.csdnimg.cn/20200718185904513.png
[20200718192702134.png]: https://img-blog.csdnimg.cn/20200718192702134.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20200718192817742.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0_size_16_color_FFFFFF_t_70 10]: https://img-blog.csdnimg.cn/20200718193008674.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0,size_16,color_FFFFFF,t_70
[20200718193130752.png]: https://img-blog.csdnimg.cn/20200718193130752.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0_size_16_color_FFFFFF_t_70 11]: https://img-blog.csdnimg.cn/20200718193216851.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0,size_16,color_FFFFFF,t_70
[20200718193648276.png]: https://img-blog.csdnimg.cn/20200718193648276.png
[20200718193909137.png]: https://img-blog.csdnimg.cn/20200718193909137.png
[20200718194053236.png]: https://img-blog.csdnimg.cn/20200718194053236.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0_size_16_color_FFFFFF_t_70 12]: https://img-blog.csdnimg.cn/20200718194325854.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0,size_16,color_FFFFFF,t_70
[20200718194512861.png]: https://img-blog.csdnimg.cn/20200718194512861.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0_size_16_color_FFFFFF_t_70 13]: https://img-blog.csdnimg.cn/20200718194628478.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0_size_16_color_FFFFFF_t_70 14]: https://img-blog.csdnimg.cn/20200718195918184.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0,size_16,color_FFFFFF,t_70
[2020071820255627.png]: https://img-blog.csdnimg.cn/2020071820255627.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0_size_16_color_FFFFFF_t_70 15]: https://img-blog.csdnimg.cn/20200718202624144.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0_size_16_color_FFFFFF_t_70 16]: https://img-blog.csdnimg.cn/20200724200540723.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0_size_16_color_FFFFFF_t_70 17]: https://img-blog.csdnimg.cn/20200724202014569.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0,size_16,color_FFFFFF,t_70