前情回顾
01. 列表
- 1.1 列表的定义
- 1.2 eg:
  - 1. 取值和取索引
list index out of range - 列表索引超出范围
知道数据的内容，想确定数据在列表中的位置
使用index方法需要注意，如果传递的数据不在列表中，程序会报错！
- 3. 增加
- 4. 删除
2.del 关键字（科普）
(知道)使用 del 关键字(delete)删除列表元素
提示：在日常开发中，要从列表删除数据，建议使用列表提供的方法
del 关键字本质上是用来将一个变量从内存中删除的
del name
注意：如果使用 del 关键字将变量从内存中删除
后续的代码就不能再使用这个变量了
print(name) # 无法输出了
- 3.排序
- 4.循环遍历列表
使用迭代遍历列表
- ">
- 元组和列表之间的转换
03. 字典
- 3.1 字典的定义
  - 1.定义：
字典是一个无序的数据集合，使用print函数输出字典时，通常
输出的顺序和定义的顺序是不一致的！
- 3.统计合并
3.2 字典常用操作
3.3 循环遍历
迭代遍历字典
变量k是每一次循环中，获取到的键值对的key
- 04. 字符串
  - 4.1 字符串的定义
  - 4.2字符串的切片
1. 截取从 2 ~ 5 位置的字符串
2. 截取从 2 ~ 末尾的字符串
3. 从开始位置，每隔一个字符截取字符串
4. 从索引 1 开始，每隔一个取一个
倒序切片
-1 表示倒数第一个字符
5. 截取从 2 ~ 末尾 - 1 的字符串
6. 截取字符串末尾两个字符
7. 字符串的逆序（面试题）
- 应用场景
如果循环体内部使用break退出了循环
else 下方的代码就不会被执行

前情回顾

在Python中，所有非数字型变量都支持以下特点：
1. 都是一个序列sequence，也可以理解为容器
2. 取值[]
3. 遍历for in
4. 计算长度、最大/最小值、比较、删除
5. 链接+和重复*
6. 切片

01. 列表

1.1 列表的定义

List（列表）是Python中使用最频繁的数据类型，在其他语言中通常叫做数组
专门用于存储一串信息
列表用[]定义，数据之间使用,分隔
1.2 eg:
1. 取值和取索引
```python name_list = [“zhangsan”, “lisi”, “wangwu”]

list index out of range - 列表索引超出范围

print(name_list[2])

知道数据的内容，想确定数据在列表中的位置

使用index方法需要注意，如果传递的数据不在列表中，程序会报错！

print(name_list.index(“wangwu”))

<a name="F8PUl"></a>
#### 2. 修改
```python
# 
name_list[1] = "李四"
# list assignment index out of range
# 列表指定的索引超出范围，程序会报错！
# name_list[3] = "王小二"

3. 增加


# append 方法可以向列表的末尾追加数据
name_list.append("王小二")
# insert 方法可以在列表的指定索引位置插入数据
name_list.insert(1, "小美眉")

# extend 方法可以把其他列表中的完整内容，追加到当前列表的末尾
temp_list = ["孙悟空", "猪二哥", "沙师弟"]
name_list.extend(temp_list)

4. 删除

# 4. 删除
# remove 方法可以从列表中删除指定的数据
name_list.remove("wangwu")
# pop 方法默认可以把列表中最后一个元素删除
name_list.pop()
# pop 方法可以指定要删除元素的索引
name_list.pop(3)
# clear 方法可以清空列表
name_list.clear()

print(name_list)

2.del 关键字（科普）

使用del关键字(delete) 同样可以删除列表中元素
del关键字本质上是用来将一个变量从内存中删除的
如果使用del关键字将变量从内存中删除，后续的代码就不能再使用这个变量了 ```python name_list = [“张三”, “李四”, “王五”]

(知道)使用 del 关键字(delete)删除列表元素

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

del name_list[1]

del 关键字本质上是用来将一个变量从内存中删除的

name = “小明”

del name

注意：如果使用 del 关键字将变量从内存中删除

后续的代码就不能再使用这个变量了

print(name) # 无法输出了

print(name_list)

![image.png](https://cdn.nlark.com/yuque/0/2021/png/812258/1620609073802-2749e4f7-e639-4cfc-84c7-73c80f6da4ef.png#clientId=u1514eacd-e96b-4&from=paste&height=129&id=u039cc768&margin=%5Bobject%20Object%5D&name=image.png&originHeight=129&originWidth=386&originalType=binary&ratio=1&size=5801&status=done&style=none&taskId=ua26a7a0b-f1d0-452c-aa94-7a02c73f5f6&width=386)
<a name="z5a1p"></a>
### 2.统计
```python
name_list = ["张三", "李四", "王五", "王小二", "张三"]

# len(length 长度) 函数可以统计列表中元素的总数
list_len = len(name_list)
print("列表中包含 %d 个元素" % list_len)

# count 方法可以统计列表中某一个数据出现的次数
count = name_list.count("张三")
print("张三出现了 %d 次" % count)

# 从列表中删除第一次出现的数据，如果数据不存在，程序会报错
name_list.remove("张三")

print(name_list)

3.排序

name_list = ["zhangsan", "lisi", "wangwu", "wangxiaoer"]
num_list = [6, 8, 4, 1, 10]

# 升序
name_list.sort()
num_list.sort()

# 降序
# name_list.sort(reverse=True)
# num_list.sort(reverse=True)

# # 逆序（反转）
# name_list.reverse()
# num_list.reverse()

print(name_list)
print(num_list)

4.循环遍历列表

遍历就是从头到尾依次从列表中获取数据
- 在循环体内部针对每一个元素，执行相同的操作
在Python中为了提高列表的遍历效率，专门提供的迭代 iteration 遍历
使用for就能够实现迭代遍历 ```python name_list = [“张三”, “李四”, “王五”, “王小二”]

使用迭代遍历列表

“”” 顺序的从列表中依次获取数据，每一次循环过程中，数据都会保存在　 my_name 这个变量中，在循环体内部可以访问到当前这一次获取到的数据

for my_name in 列表变量:

print("我的名字叫　%s" % my_name)

“”” for my_name in name_list:

print("我的名字叫　%s" % my_name)

![image.png](https://cdn.nlark.com/yuque/0/2021/png/812258/1620609365698-66fad889-4ac7-4c36-b4f9-46abbb187ee1.png#clientId=u1514eacd-e96b-4&from=paste&height=279&id=u42ac73d6&margin=%5Bobject%20Object%5D&name=image.png&originHeight=279&originWidth=472&originalType=binary&ratio=1&size=15076&status=done&style=none&taskId=u23e447d0-4b13-4b2b-97b2-5ab24ae1605&width=472)
<a name="IhVbC"></a>
## 02. 元组
<a name="trj1k"></a>
### 2.1 元组的定义

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

# 1. 取值和取索引
print(info_tuple[0])
# 已经知道数据的内容，希望知道该数据在元组中的索引
print(info_tuple.index("zhangsan"))

# 2. 统计计数
print(info_tuple.count("zhangsan"))
# 统计元组中包含元素的个数
print(len(info_tuple))

#元组的遍历
info_tuple = ("zhangsan", 18, 1.75)

# 使用迭代遍历元组
for my_info in info_tuple:

    # 使用格式字符串拼接 my_info 这个变量不方便！
    # 因为元组中通常保存的数据类型是不同的！
    print(my_info)

info = ("zhangsan", 18)

print("%s 的年龄是 %d" % info)

元组和列表之间的转换

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

python list(元组)

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

python tuple(列表)

03. 字典

3.1 字典的定义

dictionary（字典）是除列表以外Python之中最灵活的数据类型
字典同样可以用来存储多个数据
- 通常用于存储描述一个物体的相关信息
和列表的区别
- 列表是有序的对象集合
- 字典是无序的对象集合
字典用{}定义
字典使用键值对存储数据，键值对之间使用,分隔
- 键key是索引
- 值value是数据
- 键和值之间使用:分隔
- 键必须是唯一的
- 值可以取任何数据类型，但键只能使用字符串、数字或元组
  1.定义：
```python
字典是一个无序的数据集合，使用print函数输出字典时，通常
输出的顺序和定义的顺序是不一致的！
xiaoming = {“name”: “小明”,
```
     "age": 18,
     "gender": True,
     "height": 1.75,
     "weight": 75.5}
```

print(xiaoming)

<a name="NBKLM"></a>
#### 2.使用
```python
xiaoming_dict = {"name": "小明"}

# 1. 取值
print(xiaoming_dict["name"])
# 在取值的时候，如果指定的key不存在，程序会报错！
# print(xiaoming_dict["name123"])

# 2. 增加/修改
# 如果key不存在，会新增键值对
xiaoming_dict["age"] = 18
# 如果key存在，会修改已经存在的键值对
xiaoming_dict["name"] = "小小明"

# 3. 删除
xiaoming_dict.pop("name")
# 在删除指定键值对的时候，如果指定的key不存在，程序会报错！
# xiaoming_dict.pop("name123")

print(xiaoming_dict)

3.统计合并

xiaoming_dict = {"name": "小明",
                 "age": 18}

# 1. 统计键值对数量
print(len(xiaoming_dict))

# 2. 合并字典
temp_dict = {"height": 1.75,
             "age": 20}

# 注意：如果被合并的字典中包含已经存在的键值对，会覆盖原有的键值对
xiaoming_dict.update(temp_dict)

# 3. 清空字典
xiaoming_dict.clear()

print(xiaoming_dict)

3.2 字典常用操作

在ipython3中定义一个字典，例如：xiaoming = {}
输入xiaoming.按下TAB键，ipython会提示字典能够使用的函数如下：

In [1]: xiaoming. xiaoming.clear xiaoming.items xiaoming.setdefault xiaoming.copy xiaoming.keys xiaoming.update xiaoming.fromkeys xiaoming.pop xiaoming.values xiaoming.get xiaoming.popitem
有关字典的常用操作可以参照上图练习

3.3 循环遍历

遍历就是依次从字典中获取所有键值对 ```python xiaoming_dict = {“name”: “小明”,
```
           "qq": "123456",
           "phone": "10086"}
```

迭代遍历字典

变量k是每一次循环中，获取到的键值对的key

for k in xiaoming_dict:

print("%s - %s" % (k, xiaoming_dict[k]))

```python
# 使用 多个键值对，存储 描述一个 物体 的相关信息 —— 描述更复杂的数据信息
# 将 多个字典 放在 一个列表 中，再进行遍历
card_list = [
    {"name": "张三",
     "qq": "12345",
     "phone": "110"},
    {"name": "李四",
     "qq": "54321",
     "phone": "10086"}
]

for card_info in card_list:

    print(card_info)

04. 字符串

4.1 字符串的定义

字符串就是一串字符，是编程语言中表示文本的数据类型
在 Python 中可以使用一对双引号“或者一对单引号‘定义一个字符串
- 虽然可以使用\”或者\’做字符串的转义，但是在实际开发中：
  - 如果字符串内部需要使用”，可以使用’定义字符串
  - 如果字符串内部需要使用’，可以使用”定义字符串
可以使用索引获取一个字符串中指定位置的字符，索引计数从0开始
也可以使用for循环遍历字符串中每一个字符

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

1.字符串定义和遍历

str1 = "hello python"
str2 = '我的外号是"大西瓜"'

print(str2)
print(str1[6])

for char in str2:

    print(char)

2.字符串统计操作

hello_str = "hello hello"

# 1. 统计字符串长度
print(len(hello_str))

# 2. 统计某一个小（子）字符串出现的次数
print(hello_str.count("llo"))
print(hello_str.count("abc"))

# 3. 某一个子字符串出现的位置
print(hello_str.index("llo"))
# 注意：如果使用index方法传递的子字符串不存在，程序会报错！
print(hello_str.index("abc"))

3.字符串判断方法

string.isspace() | 如果 string 中只包含空格，则返回 True
string.isalnum() | 如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True
string.isalpha() | 如果 string 至少有一个字符并且所有字符都是字母则返回 True
string.isdecimal() | 如果 string 只包含数字则返回 True，全角数字
string.isdigit() | 如果 string 只包含数字则返回 True，全角数字、⑴、\u00b2
string.isnumeric() | 如果 string 只包含数字则返回 True，全角数字，汉字数字
string.istitle() | 如果 string 是标题化的(每个单词的首字母大写)则返回 True
string.islower() | 如果 string 中包含至少一个区分大小写的字符，并且所有这些字符都是小写，则返回 True
string.isupper() | 如果 string 中包含至少一个区分大小写的字符，并且所有这些字符都是大写，则返回 True

# 1. 判断空白字符
space_str = "      \t\n\r"

print(space_str.isspace())

# 2. 判断字符串中是否只包含数字
# 1> 都不能判断小数
# num_str = "1.1"
# 2> unicode 字符串
# num_str = "\u00b2"
# 3> 中文数字
num_str = "一千零一"

print(num_str)
print(num_str.isdecimal())
print(num_str.isdigit())
print(num_str.isnumeric())

4.查找和替换

hello_str = "hello world"

# 1. 判断是否以指定字符串开始
print(hello_str.startswith("Hello"))

# 2. 判断是否以指定字符串结束
print(hello_str.endswith("world"))

# 3. 查找指定字符串
# index同样可以查找指定的字符串在大字符串中的索引
print(hello_str.find("llo"))
# index如果指定的字符串不存在，会报错
# find如果指定的字符串不存在，会返回-1
print(hello_str.find("abc"))

# 4. 替换字符串
# replace方法执行完成之后，会返回一个新的字符串
# 注意：不会修改原有字符串的内容
print(hello_str.replace("world", "python"))

print(hello_str)

5.大小写转换 - 5

6.文本对齐 - 3

# 假设：以下内容是从网络上抓取的
# 要求：顺序并且居中对齐输出以下内容
poem = ["\t\n登鹳雀楼",
         "王之涣",
         "白日依山尽\t\n",
         "黄河入海流",
         "欲穷千里目",
         "更上一层楼"]

for poem_str in poem:

    # 先使用strip方法去除字符串中的空白字符
    # 再使用center方法居中显示文本
    print("|%s|" % poem_str.strip().center(10, "　"))

7.去除空白字符 - 3

8.拆分和连接 - 5

# 假设：以下内容是从网络上抓取的
# 要求：
# 1. 将字符串中的空白字符全部去掉
# 2. 再使用 " " 作为分隔符，拼接成一个整齐的字符串
poem_str = "登鹳雀楼\t 王之涣 \t 白日依山尽 \t \n 黄河入海流 \t\t 欲穷千里目 \t\t\n更上一层楼"

print(poem_str)

# 1. 拆分字符串
poem_list = poem_str.split()
print(poem_list)

# 2. 合并字符串
result = " ".join(poem_list)
print(result)

4.2字符串的切片

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

注意：

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

索引的顺序和倒序

在 Python 中不仅支持顺序索引，同时还支持倒序索引
所谓倒序索引就是从右向左计算索引
- 最右边的索引值是-1，依次递减 ```python num_str = “0123456789”
  1. 截取从 2 ~ 5 位置的字符串
  print(num_str[2:6])
  2. 截取从 2 ~ 末尾的字符串
  print(num_str[2:])

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

print(num_str[::2])

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

print(num_str[1::2])

倒序切片

-1 表示倒数第一个字符

print(num_str[-1])

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

print(num_str[2:-1])

6. 截取字符串末尾两个字符

print(num_str[-2:])

7. 字符串的逆序（面试题）

print(num_str[::-1])

<a name="EYr7i"></a>
## 05. 公共方法
<a name="ot2Jr"></a>
### 5.1 Python 内置函数
Python 包含了以下内置函数：<br />len(item) | 计算容器中元素个数 | | | <br />del(item) | 删除变量 | del 有两种方式 | |<br />max(item) | 返回容器中元素最大值 | 如果是字典，只针对 key 比较 | | <br />min(item) | 返回容器中元素最小值 | 如果是字典，只针对 key 比较 | | <br />cmp(item1, item2) | 比较两个值，-1 小于/0 相等/1 大于 | Python 3.x 取消了 cmp 函数 |<br />**注意**

- **字符串**比较符合以下规则： "0" < "A" < "a"
<a name="SFfoL"></a>
### 5.2 切片
切片 | "0123456789"[::-2] | "97531" | 字符串、列表、元组 |

- **切片**使用**索引值**来限定范围，从一个大的**字符串**中**切出**小的**字符串**
- **列表**和**元组**都是**有序**的集合，都能够**通过索引值**获取到对应的数据
- **字典**是一个**无序**的集合，是使用**键值对**保存数据
<a name="troke"></a>
### 5.3 运算符
| 运算符 | Python 表达式 | 结果 | 描述 | 支持的数据类型 | | :---: | --- | --- | --- | --- | | <br />+ | [1, 2] + [3, 4] | [1, 2, 3, 4] | 合并 | 字符串、列表、元组 | |<br />* | ["Hi!"] * 4 | ['Hi!', 'Hi!', 'Hi!', 'Hi!'] | 重复 | 字符串、列表、元组 | | <br />in | 3 in (1, 2, 3) | True | 元素是否存在 | 字符串、列表、元组、字典 | | <br />not in | 4 not in (1, 2, 3) | True | 元素是否不存在 | 字符串、列表、元组、字典 | | <br />> >= == < <= | (1, 2, 3) < (2, 2, 3) | True | 元素比较 | 字符串、列表、元组 |<br />**注意**

- in在对**字典**操作时，判断的是**字典的键**
- in和not in被称为**成员运算符**
<a name="cU5yq"></a>
#### 成员运算符
成员运算符用于**测试**序列中是否包含指定的**成员**<br />| 运算符 | 描述 | 实例 | | --- | --- | --- | | in | 如果在指定的序列中找到值返回 True，否则返回 False |3 in (1, 2, 3)返回True| | not in | 如果在指定的序列中没有找到值返回 True，否则返回 False |3 not in (1, 2, 3)返回False|<br />注意：在对**字典**操作时，判断的是**字典的键**
<a name="cl9Ev"></a>
### 5.4 完整的 for 循环语法

- 在Python中完整的for 循环的语法如下：

```python for 变量 in 集合:<br />循环体代码

else: 没有通过 break 退出循环，循环结束后，会执行的代码

应用场景

在迭代遍历嵌套的数据类型时，例如一个列表包含了多个字典
需求：要判断某一个字典中是否存在指定的值
- 如果存在，提示并且退出循环
- 如果不存在，在循环整体结束后，希望得到一个统一的提示 ```python for num in [1, 2, 3]:
  
  print(num)
  
  if num == 2: break else:
  
  如果循环体内部使用break退出了循环
  else 下方的代码就不会被执行
  print(“会执行吗？”)

print(“循环结束”)

<a name="byn3X"></a>
### 5.5遍历字典的列表
```python
students = [
    {"name": "阿土"},
    {"name": "小美"}
]

# 在学员列表中搜索指定的姓名
find_name = "张三"

for stu_dict in students:

    print(stu_dict)

    if stu_dict["name"] == find_name:

        print("找到了　%s" % find_name)

        # 如果已经找到，应该直接退出循环，而不再遍历后续的元素
        break
    # else:
    #     print("抱歉没有找到　%s" % find_name)
else:
    # 如果希望在搜索列表时，所有的字典检查之后，都没有发现需要搜索的目标
    # 还希望得到一个统一的提示！
    print("抱歉没有找到　%s" % find_name)

print("循环结束")

【Python】二、列表、元组、字典、字符串