目标

• 列表
• 元组
• 字典
• 字符串
• 公共方法

• 变量高级

  知识点回顾

• Python 中数据类型可以分为 数字型 和 非数字型
  

• 数字型
  • 整型 (int)
  • 浮点型（float）
  • 布尔型（bool）
    • 真 True 非 0 数 —— 非零即真
    • 假 False 0
  • 复数型 (complex)
    • 主要用于科学计算，例如：平面场问题、波动问题、电感电容等问题
• 非数字型
  • 字符串
  • 列表
  • 元组
  • 字典

• 在Python中，所有非数字型变量都支持以下特点：

  1. 都是一个 序列 sequence，也可以理解为 容器
  2. 取值 []
  3. 遍历 for in
  4. 计算长度、最大/最小值、比较、删除
  5. 链接 + 和 重复 *
  6. 切片

     01. 列表

     1.1 列表的定义

• List（列表） 是 Python 中使用 最频繁 的数据类型，在其他语言中通常叫做 数组

• 专门用于存储 一串 信息
• 列表用 [] 定义，数据 之间使用 , 分隔
• 列表的索引从0开始
  • 索引 就是数据在 列表 中的位置编号，索引 又可以被称为 下标

    注意：从列表中取值时，如果 超出索引范围，程序会报错

name_list = ["zhangsan", "lisi", "wangwu"]

1.2 列表常用操作

• 在 ipython3 中定义一个 列表，例如：name_list = []
• 输入 name_list. 按下 TAB 键，ipython 会提示 列表 能够使用的 方法 如下：

  name_list = ["张三", "李四", "王五"]

  

del 关键字（科普）

• 使用 del 关键字(delete) 同样可以删除列表中元素
• del 关键字本质上是用来 将一个变量从内存中删除的
• 如果使用 del 关键字将变量从内存中删除，后续的代码就不能再使用这个变量了

del name_list[1]

在日常开发中，要从列表删除数据，建议 使用列表提供的方法

关键字、函数和方法（科普）

• 关键字 是 Python 内置的、具有特殊意义的标识符

  import keyword
  print(keyword.kwlist)
  print(len(keyword.kwlist))

  关键字后面不需要使用括号

• 函数 封装了独立功能，可以直接调用

函数名(参数)

函数需要死记硬背

• 方法 和函数类似，同样是封装了独立的功能
• 方法 需要通过 对象 来调用，表示针对这个 对象 要做的操作

对象.方法名(参数)

在变量后面输入 .，然后选择针对这个变量要执行的操作，记忆起来比函数要简单很多

1.3 循环遍历

• 遍历就是从头到尾依次从列表中获取数据
  • 在 循环体内部 针对 每一个元素，执行相同的操作
• 在 Python 中为了提高列表的遍历效率，专门提供的 迭代 iteration 遍历
  

• 使用 for 就能够实现迭代遍历
  

  # for 循环内部使用的变量 in 列表
  for name in name_list:
    # 循环内部针对列表元素进行操作
    print(name)

  

  1.4 应用场景

• 尽管 Python 的 列表 中可以 存储不同类型的数据

• 但是在开发中，更多的应用场景是
  1. 列表 存储相同类型的数据
  2. 通过 迭代遍历，在循环体内部，针对列表中的每一项元素，执行相同的操作

02. 元组

2.1 元组的定义

• Tuple（元组）与列表类似，不同之处在于元组的元素不能修改
  • 元组 表示多个元素组成的序列
  • 元组 在 Python 开发中，有特定的应用场景
• 用于存储 一串 信息，数据 之间使用 , 分隔
• 元组用 () 定义
• 元组的索引从0开始
  • 索引 就是数据在 元组 中的位置编号

    info_tuple = ("zhangsan", 18, 1.75)

    创建空元组

    info_tuple = ()

    元组中 只包含一个元素 时，需要 在元素后面添加逗号

    info_tuple = (50, )

    很好理解，为了与()基本用法作区分

2.2 元组常用操作

• 在 ipython3 中定义一个 元组，例如：info = ()
• 输入 info. 按下 TAB 键，ipython 会提示 元组 能够使用的函数如下：

2.3 循环遍历

• 取值 就是从 元组 中获取存储在指定位置的数据
• 遍历 就是 从头到尾 依次 从 元组 中获取数据

  # for 循环内部使用的变量 in 元组
  for item in info:
    循环内部针对元组元素进行操作
    print(item)

  • 在 Python 中，可以使用 for 循环遍历所有非数字型类型的变量：列表、元组、字典 以及 字符串
  • 提示：在实际开发中，除非 能够确认元组中的数据类型，否则针对元组的循环遍历需求并不是很多

2.4 应用场景

• 尽管可以使用 for in 遍历 元组

• 但是在开发中，更多的应用场景是：

  • 函数的 参数 和 返回值，一个函数可以接收任意多个参数，或者一次返回多个数据
    • 有关 函数的参数 和 返回值，在后续 函数高级 给大家介绍
  • 格式字符串，格式化字符串后面的 () 本质上就是一个元组
  • 让列表不可以被修改，以保护数据安全

    ⭐元组和列表之间的转换

• 使用 list 函数可以把元组转换成列表

list(元组)

• 使用 tuple 函数可以把列表转换成元组

tuple(列表)

03. 字典

3.1 字典的定义

• dictionary（字典） 是 除列表以外 Python 之中 最灵活 的数据类型
• 字典同样可以用来存储多个数据
  • 通常用于存储 描述一个 物体 的相关信息
• 和列表的区别
  • 列表 是 有序 的对象集合
  • 字典 是 无序 的对象集合
• 字典用 {} 定义
• 字典使用键值对存储数据，键值对之间使用,分隔
  • 键 key 是索引
  • 值 value 是数据
  • 键 和 值 之间使用 : 分隔
  • 键必须是唯一的
  • 值 可以取任何数据类型，但 键 只能使用 字符串、数字或 元组 ```python

    空字典

    my_dict = {}

带有整数键的字典

my_dict = {1: ‘apple’, 2: ‘ball’}

混合键字典

my_dict = {‘name’: ‘John’, 1: [2, 4, 3]}

使用 dict()

my_dict = dict({1:’apple’, 2:’ball’})

将每个项作为一对的序列

my_dict = dict([(1,’apple’), (2,’ball’)])

![image.png](https://cdn.nlark.com/yuque/0/2021/png/5365225/1614069277698-d08fba36-05b6-410b-ad68-5b53cf9d0ec3.png#align=left&display=inline&height=122&margin=%5Bobject%20Object%5D&name=image.png&originHeight=160&originWidth=766&size=8458&status=done&style=none&width=583)<br />**![image.png](https://cdn.nlark.com/yuque/0/2021/png/5365225/1614059110002-b34ef5a2-6532-4c13-a010-56d9285bd8cd.png#align=left&display=inline&height=457&margin=%5Bobject%20Object%5D&name=image.png&originHeight=577&originWidth=743&size=27408&status=done&style=none&width=589)**<br />![](https://cdn.nlark.com/yuque/0/2021/png/5365225/1614059196316-652f9fbe-a0ea-4402-ae32-6c0bdd0d2120.png#align=left&display=inline&height=738&margin=%5Bobject%20Object%5D&originHeight=738&originWidth=920&size=0&status=done&style=none&width=920)
<a name="WU5Wh"></a>
### 3.2 字典常用操作
| 方法 | 描述 |
| :--- | :--- |
| [clear()](https://www.nhooo.com/python/python-methods-dictionary-clear.html) | 从字典中删除所有项目。 |
| [copy()](https://www.nhooo.com/python/python-methods-dictionary-copy.html) | 返回字典的浅表副本。 |
| [fromkeys(seq[,v])](https://www.nhooo.com/python/python-methods-dictionary-fromkeys.html) | 用于创建一个新字典，以序列seq中元素做字典的键，v为字典所有键对应的初始值。总感觉这个属于类方法而不是成员方法！！！ |
| [get(key[,d])](https://www.nhooo.com/python/python-methods-dictionary-get.html) | 返回键的值。 如果key不存在，则返回d（默认为None）。<br />这点不同于[]取某个键的值（键不存在会报错） |
| [items()](https://www.nhooo.com/python/python-methods-dictionary-items.html) | 返回可遍历的(键, 值) 元组数组。 |
| [keys()](https://www.nhooo.com/python/python-methods-dictionary-keys.html) | 返回字典中的所有的键。 |
| [pop(key[,d])](https://www.nhooo.com/python/python-methods-dictionary-pop.html) | 删除带键的项并返回其值，如果没有找到key，则返回d。如果没有提供d，并且没有找到key，则引发KeyError错误 |
| [popitem()](https://www.nhooo.com/python/python-methods-dictionary-popitem.html) | 删除并返回<br />3.7之前：任意项（键，值）<br />3.7以及之后：最后一项（键，值）<br />如果字典为空则引发KeyError。 |
| [setdefault(key[,d])](https://www.nhooo.com/python/python-methods-dictionary-setdefault.html) | 返回指定键的值，如果指定键的值不在字典中，返回指定值，默认为 None。<br /> |
| [update([other])](https://www.nhooo.com/python/python-methods-dictionary-update.html) | 使用来自other的键/值对更新字典，覆盖现有键。 |
| [values()](https://www.nhooo.com/python/python-methods-dictionary-values.html) | 以列表形式返回字典中的所有值。 |
![image.png](https://cdn.nlark.com/yuque/0/2021/png/5365225/1614065600287-d85692e8-9c74-43eb-8186-4d9fb954b87d.png#align=left&display=inline&height=315&margin=%5Bobject%20Object%5D&name=image.png&originHeight=424&originWidth=822&size=30633&status=done&style=none&width=610)<br />![image.png](https://cdn.nlark.com/yuque/0/2021/png/5365225/1614065745366-82cd1507-15ce-4b2d-ab64-590cbec02aca.png#align=left&display=inline&height=347&margin=%5Bobject%20Object%5D&name=image.png&originHeight=347&originWidth=630&size=19058&status=done&style=none&width=630)<br />![image.png](https://cdn.nlark.com/yuque/0/2021/png/5365225/1614065852316-246128dd-75e9-4797-acaf-d1a90b9fe2fe.png#align=left&display=inline&height=568&margin=%5Bobject%20Object%5D&name=image.png&originHeight=822&originWidth=953&size=48798&status=done&style=none&width=659)<br />![image.png](https://cdn.nlark.com/yuque/0/2021/png/5365225/1614069048954-7f14738d-bf81-489f-a32f-89f34aca5663.png#align=left&display=inline&height=136&margin=%5Bobject%20Object%5D&name=image.png&originHeight=136&originWidth=544&size=5745&status=done&style=none&width=544)
<a name="AE3Gq"></a>
### 3.3 循环遍历
<a name="PhqT3"></a>
#### ⭐对字典进行遍历，遍历的是键
- **遍历** 就是 **依次** 从 **字典** 中获取所有键值对
```python
# for 循环内部使用的 `key 的变量` in 字典
for k in xiaoming:
    print("%s: %s" % (k, xiaoming[k]))

提示：在实际开发中，由于字典中每一个键值对保存数据的类型是不同的，所以针对字典的循环遍历需求并不是很多

3.4 应用场景

• 尽管可以使用 for in 遍历 字典

• 但是在开发中，更多的应用场景是：

  • 使用 多个键值对，存储 描述一个 物体 的相关信息 —— 描述更复杂的数据信息
  • 将 多个字典 放在 一个列表 中，再进行遍历，在循环体内部针对每一个字典进行 相同的处理

    card_list = [{"name": "张三",
             "qq": "12345",
             "phone": "110"},
            {"name": "李四",
             "qq": "54321",
             "phone": "10086"}
            ]

    04. 字符串

    4.1 字符串的定义

• 字符串 就是 一串字符，是编程语言中表示文本的数据类型

• 在 Python 中可以使用一对双引号"或者一对单引号'定义一个字符串
  • 虽然可以使用\"或者\'做字符串的转义，但是在实际开发中：
    • 如果字符串内部需要使用 "，可以使用 ' 定义字符串
    • 如果字符串内部需要使用 '，可以使用 " 定义字符串
• 可以使用 索引 获取一个字符串中 指定位置的字符，索引计数从 0 开始
• 也可以使用 for 循环遍历 字符串中每一个字符

  大多数编程语言都是用 " 来定义字符串

string = "Hello Python"
for s in string:
    print(s,end='')

4.2 字符串的常用操作

⭐所有字符串方法都返回新值。它们不会更改原始字符串。

• 在 ipython3 中定义一个 字符串，例如：hello_str = ""
• 输入 hello_str. 按下 TAB 键，ipython 会提示 字符串 能够使用的 方法 如下：

  提示：正是因为 python 内置提供的方法足够多，才使得在开发时，能够针对字符串进行更加灵活的操作！应对更多的开发需求！

capitalize()

casefold()

center()

count()

encode()

endswith()

expandtabs()

用法解释

• 默认tabsize值为8。制表位为8、16，依此类推。因此，当您打印原始字符串时，“ xyz”后面有5个空格，“ 12345”后面有3个空格。
  
• 将设置tabsize为2时。制表位为2、4、6、8，依此类推。对于“ xyz”，制表位是4，对于“ 12345”，制表位是10。因此，在“ xyz”后有1个空格，在“ 12345”后有1个空格。
  
• 将设置tabsize为3时。制表位为3、6、9，依此类推。对于“ xyz”，制表位是6，对于“ 12345”，制表位是12。因此，“ xyz”后有3个空格，在“ 12345”后有1个空格。
  
• 将设置tabsize为4时。制表位为4、8、12，依此类推。对于“ xyz”，制表位是4，对于“ 12345”，制表位是12。因此，在“ xyz”后有1个空格，在“ 12345”后有3个空格。
  
• 设置tabsize为5时。制表位为5、10、15，依此类推。对于“ xyz”，制表位是5，对于“ 12345”，制表位是15。因此，在“ xyz”后有2个空格，在“ 12345”后有5个空格。
  

• 设置tabsize为6时。制表位为6、12、18，依此类推。对于“ xyz”，制表位是6，对于“ 12345”，制表位是12。因此，在“ xyz”后有3个空格，在“ 12345”后有1个空格。
  

  find()

  

  format()

  format()方法的语法为：
  template``.format``(p0, p1, ..., k0=v0, k1=v1, ...)
  在这里，p0, p1,…分别是位置参数和k0, k1,…具有值的关键字参数v0, v1,…。
  并且，template是格式代码与参数占位符的混合。

  字符串format()参数

  format()方法采用任意数量的参数。但是，分为两种类型的参数：

• 位置参数 -可以使用花括号{index}中的参数索引访问的参数列表
  

• 关键字参数 -键=值类型的参数列表，可以使用花括号{key}中的参数键来访问

  字符串format()返回值

  format()方法返回格式化的字符串
  

  使用format()格式化数字

  您可以使用下面给出的格式说明符设置数字格式：
  数字格式类型

format_map()

index()

类似于find，只不过找不到会报错而不是返回-1

isalnum()

要求字符串全部是字母或数字

isalpha()

要求字符串全部是字母

isdecimal()

上标和下标被认为是数字字符，而不是小数。如果字符串包含这些字符（通常使用unicode编写），则isdecimal()返回False。
类似地，罗马数字、货币分子和分数被认为是数字(通常使用unicode编写)，而不是小数。在本示例中，isdecimal()也返回False

isdigit()

数字是具有属性值的字符：

• Numeric_Type =数字
  
• Numeric_Type =十进制
  

在Python中，上标和下标（通常使用unicode编写）也被视为数字字符。因此，如果字符串包含这些字符以及十进制字符，则isdigit()返回True。
罗马数字，货币分子和小数（通常使用unicode编写）被认为是数字字符，而不是数字。如果字符串包含这些字符，则isdigit()返回False。

isidentifier()

islower()

isnumeric()

如果字符串中的所有字符均为数字字符，则isnumeric()方法将返回True。如果不是，则返回False。
数字字符具有以下属性：

• Numeric_Type =十进制
  
• Numeric_Type = 数字（Digit）
  
• Numeric_Type = 数字（Numeric）
  

在Python中，十进制字符（例如：0、1、2 ..），数字（例如：下标，上标）和具有Unicode数值属性的字符（例如：小数，罗马数字，货币分子）都被视为数字字符。

isprintable()

如果字符串中的所有字符都是可打印的或字符串为空，则isprintable()方法将返回True。如果不是，则返回False。
占用屏幕打印空间的字符称为可打印字符。例如：

• 字母和符号
  
• 数字
  
• 标点
  
• 空格
  

isspace()

如果字符串中仅包含空格字符，则isspace()方法将返回True。如果不是，则返回False。
用于间隔的字符称为空白字符。例如：制表符，空格，换行符等。

istitle()

isupper()

⭐join()

join()是一个字符串方法，它返回与iterable元素连接在一起的字符串。
join()方法提供了一种灵活的方式来连接字符串。它将可迭代的每个元素（如列表，字符串和元组）连接到字符串，并返回连接后的字符串。
join()的语法为：
string``.``join``(iterable)

join()参数

join()方法采用一个可迭代的对象-能够一次返回其成员的对象
可迭代的一些示例是：

• 原生数据类型 - 列表，元组，字符串，字典和集合
  
• 文件对象和使用iter ()或getitem()方法定义的对象
  

  join()返回值

  join()方法返回一个与iterable元素串联的字符串。
  如果Iterable包含任何非字符串值，则将引发TypeError异常
  

  ljust()

  

  lower()

  

  lstrip()

maketrans()

partition()

replace()

rfind()

find倒着找，仅此而已！

rindex()

index倒着找，仅此而已！

rjust()

rpartition()

rpartition()方法类似于 partition() 方法，只是该方法是从目标字符串的末尾也就是右边开始搜索分割符。

rsplit()

rsplit()方法从右侧开始将字符串拆分为列表。
如果未指定 “maxsplit”，则此方法将返回与 split() 方法相同的结果。
注释：若指定 maxsplit，列表将包含指定数量加一的元素。

rstrip()

split()

splitlines()

splitlines()的语法为：
str``.splitlines``(``[keepends]``)

splitlines()参数

splitlines()最多可包含1个参数。
keepends （可选）-如果提供了keepends且为True，则换行符也包括在列表的项目中。
默认情况下，不包含换行符。

splitlines()返回值

splitlines()返回字符串中的行列表。
如果没有换行符，则返回包含单个项目（单个行）的列表。
splitlines()在以下行边界上拆分：

startswith()

strip()

swapcase()

title()

translate()

upper()

zfill()

4.3 字符串的切片

• 切片方法适用于字符串、列表、元组
  • 切片 使用 索引值 来限定范围，从一个大的 字符串 中 切出 小的 字符串
  • 列表 和 元组 都是 有序 的集合，都能够 通过索引值 获取到对应的数据
  • 字典 是一个 无序 的集合，是使用 键值对 保存数据

字符串[开始索引:结束索引:步长]
注意：

1. 指定的区间属于左闭右开型[开始索引, 结束索引)=>开始索引 >= 范围 < 结束索引
   • 从 起始 位开始，到 结束位的前一位 结束（不包含结束位本身)
2. 从头开始，开始索引 数字可以省略，冒号不能省略
3. 到末尾结束，结束索引 数字可以省略，冒号不能省略
4. 步长默认为 1，如果连续切片，数字和冒号都可以省略

   索引的顺序和倒序

• 在 Python 中不仅支持 顺序索引，同时还支持 倒序索引
• 所谓倒序索引就是从右向左计算索引
  • 最右边的索引值是 -1，依次递减

演练需求

1. 截取从 2 ~ 5 位置 的字符串
2. 截取从 2 ~ 末尾 的字符串
3. 截取从 开始 ~ 5 位置 的字符串
4. 截取完整的字符串
5. 从开始位置，每隔一个字符截取字符串
6. 从索引 1 开始，每隔一个取一个
7. 截取从 2 ~ 末尾 - 1 的字符串
8. 截取字符串末尾两个字符
9. 字符串的逆序（面试题） ```python num_str = “0123456789”

截取[2,5] 字符串

print(num_str[2:6])

截取从 2 ~ 末尾 的字符串

print(num_str[2:])

截取从 开始 ~ 5 位置 的字符串

print(num_str[:6])

截取完整的字符串

print(num_str[:])

从开始位置，每隔一个字符截取字符串

print(num_str[::2])

从索引 1 开始，每隔一个取一个

print(num_str[1::2])

截取从 2 ~ 末尾 - 1 的字符串

print(num_str[2:-1])

截取字符串末尾两个字符

print(num_str[-2:])

字符串的逆序（面试题)

print(num_str[::-1])

![image.png](https://cdn.nlark.com/yuque/0/2021/png/5365225/1614152762234-c3cc8c16-c66a-4f77-8356-e165c494454c.png#align=left&display=inline&height=684&margin=%5Bobject%20Object%5D&name=image.png&originHeight=882&originWidth=777&size=55928&status=done&style=none&width=603)
<a name="YJDCW"></a>
## 05. 公共方法
<a name="OP6XH"></a>
### 5.1 Python 内置函数
Python 包含了以下内置函数：
| 函数 | 描述 | 备注 |
| --- | --- | --- |
| len(item) | 计算容器中元素个数 |  |
| del(item) | 删除变量 | del 有两种方式 |
| max(item) | 返回容器中元素最大值 | 如果是字典，只针对 key 比较 |
| min(item) | 返回容器中元素最小值 | 如果是字典，只针对 key 比较 |
| cmp(item1, item2) | 比较两个值，-1 小于/0 相等/1 大于 | Python 3.x 取消了 cmp 函数 |
**注意**
- **字符串** 比较符合以下规则： "0" < "A" < "a"
<a name="dw3xh"></a>
### 5.2 运算符
| 运算符 | Python 表达式 | 结果 | 描述 | 支持的数据类型 |
| --- | --- | --- | --- | --- |
| + | [1, 2] + [3, 4] | [1, 2, 3, 4] | 合并 | 字符串、列表、元组 |
| * | ["Hi!"] * 4 | ['Hi!', 'Hi!', 'Hi!', 'Hi!'] | 重复 | 字符串、列表、元组 |
| in | 3 in (1, 2, 3) | True | 元素是否存在 | 字符串、列表、元组、字典 |
| not in | 4 not in (1, 2, 3) | True | 元素是否不存在 | 字符串、列表、元组、字典 |
| > >= == < <= | (1, 2, 3) < (2, 2, 3) | True | 元素比较 | 字符串、列表、元组 |
**注意**
- `in` 在对 **字典** 操作时，判断的是 **字典的键**
- `in` 和 `not in` 被称为 **成员运算符**
<a name="U1mbf"></a>
#### 成员运算符
成员运算符用于 **测试** 序列中是否包含指定的 **成员**
| 运算符 | 描述 | 实例 |
| --- | --- | --- |
| in | 如果在指定的序列中找到值返回 True，否则返回 False | `3 in (1, 2, 3)` 返回 `True` |
| not in | 如果在指定的序列中没有找到值返回 True，否则返回 False | `3 not in (1, 2, 3)` 返回 `False` |
<a name="Dt3Vh"></a>
### 5.3 完整的 for 循环语法
- 在 `Python` 中完整的 `for 循环` 的语法如下：
**for** 变量 in 集合:<br />    <br />    循环体代码<br />**else**:<br />    没有通过 **break** 退出循环，循环结束后，会执行的代码
<a name="qyRxb"></a>
#### 应用场景
- 在 **迭代遍历** 嵌套的数据类型时，例如 **一个列表包含了多个字典**
- 需求：要判断 某一个字典中 是否存在 指定的 值
   - 如果 **存在**，提示并且退出循环
   - 如果 **不存在**，在 **循环整体结束** 后，希望 **得到一个统一的提示**
```python
students = [
    {"name": "阿土",
     "age": 20,
     "gender": True,
     "height": 1.7,
     "weight": 75.0},
    {"name": "小美",
     "age": 19,
     "gender": False,
     "height": 1.6,
     "weight": 45.0},
]
find_name = "阿土"
for one in students:
    if(one['name'] == find_name):
        print("找到！")
        break
else:
    print("未找到！")

找到！