三、Python基础（高级变量类型篇）
三、Python基础（高级变量类型篇）
目录：
- 三、Python基础（高级变量类型篇）
-
-
-
- 一、列表 list
-
- 1.列表的定义
- 2.列表的常用方法和操作
-
- 对象.方法名(参数)
-
-
-
- 3.for in对列表迭代遍历
- 4.利用 for in 的输出技巧
- 二、元组 tuple
-
- 1.元组的定义
- 2.元组的两个方法和一个函数：count 、 index 和 len()
- 3.for in对列表迭代遍历（较少使用）
- 4.元组的应用场景
-
- （1）print 的语句格式输出
- （2）作为函数的 参数值 使用
- （3）作为函数的 返回值 使用
- 5.元组 和 列表 之间的转换
-
-
- list(元组)
- tuple(列表)
-
-
- 三、字典 dictionary
-
- 1.字典的定义
- 2.字典的常用方法和操作
- 3.for in对字典迭代遍历（较少使用）
- 4.字典的应用场景
-
- （1）将多个字典嵌套在列表中，组成“ 结构体数组/顺序表 ”
- 四、字符串 string
-
- 1.字符串的定义
- 2.字符串的常用方法和操作
-
- （1）访问、统计与查找
- （2）类型判断
- （3）查找和替换
- （4）文本对齐
- （5）去除空白字符
- （6）拆分和连接
- 3.for in对字符串迭代遍历（较少使用）
- 4.字符串的切片
-
- 字符串[开始下标:结束下标]
- 字符串[开始下标:结束下标:步长]
-
-
- 五、高级数据类型的公共方法
-
- 1.Python的内置函数
- 2.切片
- 3.运算符
- 4.完整的for循环语法
- 六、阶段学习小结——综合应用：名片管理系统
-
- 1.框架搭建
- 2.完善其余函数
-
- （1）building() -> dict 函数
- （2）listing(list) 函数
- （3）inquire(list) 函数
- 3.源代码
-
- （1）administration_function.py 文件：
- （2）administration_main.py 文件：
- 上一篇文章
- 下一篇文章
-
-
一、列表 list
列表是 Python 中使用次数最频繁的数据类型，在其他语言中其被称为数组
1.列表的定义
list_name = ["张三", "李四", "王二"]
- 利用下标/索引访问列表中的内容，如：list_name[0] = “张三”
- 同其他语言一样，列表的下标/索引从 0 开始
2.列表的常用方法和操作
方法的调用格式：
对象.方法名(参数)
- 方法和函数类似，同样是封装好了的独立功能
- 方法需要通过对象来调用，表示针对这个对象要做的操作
- 其中列表表示列表名——属于对象
- del() 和 len() 属于函数，其他属于方法
| 序号 | 分类 | 关键字/函数/方法 | 含义 |
|---|---|---|---|
| 1 | 增加 | 列表.insert(下标, 数据) | 在指定位置插入数据 |
| 列表.append(数据) | 在末尾追加数据 | ||
| 列表.extend(列表2) | 将列表2的数据追加到列表 | ||
| 2 | 修改 | 列表[下标] = 数据 | 修改指定下标的数据 |
| 3 | 查找 | 列表.index(数据) | 查找第一次出现数据的位置，返回下标 |
| 4 | 删除 | del 列表[下标] | 删除指定下标的数据 |
| 列表.remove(数据) | 删除第一次出现的指定数据 | ||
| 列表.pop | 删除末尾数据 | ||
| 列表.pop(下标) | 删除指定下标的数据 | ||
| 列表.clear | 清空列表 | ||
| 5 | 统计 | len(列表) | 统计列表长度 |
| 列表.count(数据) | 统计数据在列表中出现的次数 | ||
| 6 | 排序 | 列表.sort() | 升序排序 |
| 列表.sort(reverse=True) | 降序排序 | ||
| 列表.reverse() | 逆序、反转 |
- 注：由于列表是连续的，因此每次删除数据后，后面的数据会整体向前移动，来填补删除后的空缺，以此来保持列表的连续性（重要 )
同理，每次插入数据后，该位置和后面的数据会整体向后移动，来空出指定的位置用来插入数据，以此来保持列表的连续性（重要) - 查找中的 index(self, value, start, stop) 实际上是有四个参数的，以后会讲到，若仅需查找数据则指定 列表.index(数据) 即可
- del 列表[下标] 和 列表.pop(下标) 的区别：del 本质上是用于清除内存的；而 pop 的定义是用与列表的，因此 del 还可以用于其他数据类型，例如：
- del 列表 和 列表.clear 的区别：列表.clear 后，虽然列表被清空，但列表仍然存在（是个空列表），仍然可以用 print(列表) 来访问；而 del 列表 后，列表的内存直接被清除，列表都不存在了，自然不能用 print(列表) 来访问
- 在指定数据中，若指定的数据不存在，则PyCharm会直接报错，如：若指定的数据不存在，则index会报错（重要）
- 在 列表.append(数据) 中，若所追加的数据也是一个列表，那么Python就会把新的列表当成一个对象追加到列表中，如：[0, 1, 2, 3].append([4, 5]) = [0, 1, 2, 3, [4, 5]]
例：下面展示增删改查以及各种操作的使用
list_name = ["张三", "李四", "王二", "李四"]
# 可以使用下标进行取值
print(list_name)
# 查找
print(list_name.index("李四"))
# 插入
list_name.insert(0, "老王")
print(list_name)
list_name.append("老樊")
print(list_name)
other_list = ["莫德凯撒"]
list_name.extend(other_list)
print(list_name)
# 修改
list_name[2] = "王五"
print(list_name)
# 删除
del list_name[0]
print(list_name)
list_name.remove("老樊")
print(list_name)
list_name.clear()
print(list_name)
例：查看 Python 中自带的关键字个数
import keyword
print(len(keyword.kwlist))
3.for in对列表迭代遍历
在 Python 中，为了提高列表的遍历效率，专门提供的迭代 iteration 遍历
使用 for 就能实现迭代遍历，即按列表顺序地把列表里的元素依次访问获取，放在指代词中
"""for 循环内部使用的变量 in 列表"""
for name in list_name:
"""循环内部针对列表元素进行操作"""
print(name)
- 注：此处的 name 是随意起的，其作用是用来分别在每一层遍历中指代 list_name 里面的元素
迭代遍历逻辑与格式如图所示：
提示：Python 的列表是可以存放不同数据类型的元素的，但一般是存放相同数据类型的数据，更加便于迭代遍历
4.利用 for in 的输出技巧
例：
for data in ["姓名", "性别", "年龄", "学号"]:
print(data, end="\t\t\t")
二、元组 tuple
在SQL数据库中，我们知道元组由若干个数据类型不尽相同的属性组成，于是在 Python 中，或者说与列表不同地方在于，元组用于存储数据类型不同的元素，并且元组内的元素不能更改
1.元组的定义
"""创建一个元组的两种方式"""
info_tuple0 = ("张三", "男", 18, 20201111)
info_tuple1 = "张三", "男", 18, 20201111
"""创建一个空元组，极少使用"""
empty_tuple = ()
"""这不是一个元组"""
info_tuple2 = (5)
"""如果元组只有一个元素，可以这样定义"""
info_tuple2 = (5, )
- 列表的定义是用 [ ] ，而元组的定义可以用 ( ) ，但 ( ) 并不唯一标识元组，而是逗号 " , "
- 但是，元组里的元素不能修改，它侧重于储存一组固定的数据，如：个人信息
- 元组的下标 [ ] 同样从 0 开始计数
- 元组内部可以嵌套列表，此时可以改变列表的值，这并不算改变元组
- 列表内部可以嵌套元组，此时可以组成一张关系表，而列表一般标记的可以是主码
2.元组的两个方法和一个函数：count 、 index 和 len()
| 序号 | 分类 | 函数/方法 | 含义 |
|---|---|---|---|
| 1 | 统计 | 元组.count(数据) | 统计数据在元组中出现的次数 |
| len(元组) | 统计元组中的元素个数 | ||
| 2 | 查找 | 元组.index(数据) | 查找数据第一次出现在元组的位置，返回下标 |
例：
info_tuple = "张三", "男", 18, 2020111
print(info_tuple.count("张三"), end=" ")
print(info_tuple.index(18), end=" ")
print(len(info_tuple), end="")
3.for in对列表迭代遍历（较少使用）
例：
"""定义一个元组"""
info_tuple = ("张三", "男", 18, 2020111)
"""迭代遍历"""
for information in info_tuple:
print(information)
4.元组的应用场景
（1）print 的语句格式输出
info_tuple = ("张三", "男", 18, 2020111)
print("学生名字叫 %s，性别 %s，今年 %d 岁，学号是 %d" % info_tuple)
"""字段还可以被视为字符串"""
info_str = "学生名字叫 %s，性别 %s，今年 %d 岁，学号是 %d" % info_tuple
print(info_str)
（2）作为函数的 参数值 使用
def info_function(temporary_tuple):
"""元组作为函数的参数值使用"""
print(temporary_tuple)
new_tuple = ("李红", "女", 18, 20001111)
info_function(new_tuple)
（3）作为函数的 返回值 使用
def info_function():
"""元组作为函数的返回值使用"""
temporary_tuple = ("老王", "男", 36, 19991111)
return temporary_tuple
new_tuple = info_function()
print(info_function())
5.元组 和 列表 之间的转换
list(元组)
把元组转换成列表
tuple(列表)
把列表转换成元组
三、字典 dictionary
字典是无序的对象集合，我们不关心其内容的顺序，它类似于关系数据库中的一张关系表，或者说是C语言中的一个结构体
1.字典的定义
student = {
"name": "张三",
"sex": "男",
"height": 1.75,
"weight": 135}
- 字典通过键来访问，如：student[“name”] = “张三”
- 字典的定义使用 { } ，其中 键 key 是索引/下标， 值 value 是数据，键必须是唯一的
- 键值对之间用逗号 " , " 分开，而 键 与 值 之间用冒号 " : " 分开
- 上述字典所定义的关系表为：
| 键 key | 值 value |
|---|---|
| name | 张三 |
| sex | 男 |
| height | 1.75 |
| weight | 135 |
2.字典的常用方法和操作
| 序号 | 分类 | 关键字/函数/方法 | 含义 |
|---|---|---|---|
| 1 | 访问 | 字典[键] | 访问字典中对应键的值 |
| 字典.get(键) | 访问字典中对应键的值 | ||
| 2 | 增加 | 字典[键] = 值 | 其中键为原字典不存在的键，即可新增键值 |
| 字典.setdefault(键, 值) | 如果键存在，不会修改值；如果键不存在，则新建键值对 | ||
| 3 | 修改 | 字典[键] = 修改值 | 其中键为原字典存在的键，即可修改值，相当于重新赋值 |
| 4 | 删除 | 字典.pop(键) | 删除指定的键值对 |
| del 字典[键] | 删除字典中指定的键值对 | ||
| 字典.clear() | 清空字典 | ||
| del 字典 | 删除字典 | ||
| 字典.popitem() | 删除字典中的最后一个键值对 | ||
| 5 | 列表 | 字典.keys() | 依次列出所有的key |
| 字典.values() | 依次列出所有的value | ||
| 字典.items() | 依次列出所有的键值对，比 print(字典) 更好 | ||
| 6 | 合并 | 字典.update(字典2) | 将字典2合并到字典中 |
| 7 | 统计 | len(字典) | 统计键值对的数量 |
例：
student = {
"name": "张三",
"sex": "男",
"height": 1.75,
"weight": 135,
"score": 95}
print(student.keys())
print(student.values())
print(student.items())
print(student)
提示：由于各函数和方法简单易懂、易使用，因此这里不再作详细的示例
3.for in对字典迭代遍历（较少使用）
迭代遍历逻辑与格式如图所示：
注：指代词指代的是键，可用每层迭代的不同键来访问不同值
例：
student = {
"name": "张三",
"sex": "男",
"height": 1.75,
"weight": 135,
"score": 95}
for key in student:
print("%s %s" % (key, student[key]))
4.字典的应用场景
（1）将多个字典嵌套在列表中，组成“ 结构体数组/顺序表 ”
例：
student_list = [{
"name": "张三",
"sex": "男"},
{
"name": "李红",
"sex": "女"},
{
"name": "老王",
"sex": "男"}]
"""打印方式1"""
for table in student_list:
print(table)
"""打印方式2"""
for table in student_list:
for key in table:
print("%s %s" % (key, table[key]))
四、字符串 string
实际上，我们在 二、Python基础（基础篇）已经大量使用过字符串了
1.字符串的定义
str1 = "欢迎来到 ~宪宪 的博客"
str2 = '欢迎来到"~宪宪"的博客'
- 一般来说，我们定义字符串时使用的是双引号 " "
- 但是如果我们想让字符串里面有 " " 的字符，那我们就使用单引号 ’ ’ 来定义
- 字符串可以通过下标/索引来访问字符串中的字符，如：str1[0] = ”欢“，str1[1] = “迎”
2.字符串的常用方法和操作
（1）访问、统计与查找
| 序号 | 分类 | 关键字/函数/方法 | 含义 |
|---|---|---|---|
| 1 | 访问 | 字符串[下标] | 访问字符串中的字符 |
| 2 | 查找 | 字符串.index(小字符串) | 查找子字符串第一次出现在大字符串的位置，返回下标 |
| 3 | 统计 | len(字符串) | 统计字符串的长度 |
| 字符串.count(小字符串) | 统计子字符串在大字符串中出现的次数 |
（2）类型判断
这里的方法名很好理解，都是由 isXXX 构成，isXXX 就是“是XXX”的意思
| 序号 | 方法 | 含义 |
|---|---|---|
| 1 | string.isspace() | 如果string中只包含空白字符（空格、\t、\n、\r），则返回True |
| 2 | string.isalnum() | 如果string至少有一个字符并且所有字符都是字母或数字则返回True |
| 3 | string.isalpha | 如果string至少有一个字符并且所有字符都是字符则返回True |
| 4 | string.isdecimal() | 如果string只包含数字则返回True，全角数字 |
| 5 | string.isdigit() | 如果string只包含数字则返回True，全角数字、⑴、\u00b2 |
| 6 | string.isnumeric() | 如果string只包含数字则返回True，全角数字、汉字数字 |
| 7 | string.istitle() | 如果string是标题化的（每个单词的首字母大写）则返回True |
| 8 | string.islower() | 如果string中包含至少一个区分大小写的字符（如：字母），并且所有这些区分大小写的字符（如：字母）都是小写，则返回True |
| 9 | string.isupper() | 如果string中包含至少一个区分大小写的字符（如：字母），并且所有这些区分大小写的字符（如：字母）都是大写，则返回True |
- 是则返回True，否则返回False
- 方法4、5、6都不能判断小数，如：3.14（注意）
- 方法4：阿拉伯数字
- 方法5：阿拉伯数字、⑴⑵——unicode字符串，无法直接通过键盘直接输入，但可以通过输入法输入、\u00b2即：²——上标数字，无法直接通过键盘直接输入，在Python中用 \u00bX 表示
- 方法6：阿拉伯数字、汉字数字
例：我们展示较为常用的几个方法
str1 = " \n \t \r"
print(str1.isspace())
print()
str2 = "abc123"
print(str2.isalnum())
print()
str3 = "12345"
str4 = "4⑴²³\u00b2"
str5 = "一千零一6六万三千"
print(str3.isdecimal())
print(str4.isdigit())
print(str5.isnumeric())
（3）查找和替换
| 序号 | 方法 | 含义 |
|---|---|---|
| 1 | string.startswith(str) | 检查字符串是否以str开头，是则返回True |
| 2 | string.endswith(str) | 检查字符串是否以str结束，是则返回True |
| 3 | string.find(str, start, end) | 检测str是否包含在string内，如果start和end指定范围，则检查是否包含在指定范围内，如果是则返回str第一次出现时字符开始的下标，否则返回-1 |
| 4 | string.rfind(str, start, end) | 类似于find()函数，不过是查找str在右边第一次出现的位置（str可能出现多次） |
| 5 | string.index(str, start, end) | 跟find()方法类似，只不过如果str不再string会报错 |
| 6 | string.rindex(str, start, end) | 类似于index()，不过是查找str在右边第一次出现的位置（str可能出现多次） |
| 7 | string.replace(old_str, new_str, num | 把string中的old_str替换成new_str，如果num指定，则替换不超过num次 |
- str指的是string中的一段小字符串
- 指定范围 [start,end)：start指的是开始的下标，end表示结束的下标，检索start，但不检索end
- 方法7：在执行完之后会返回一个新的的字符串，但不会把修改结果覆盖到string中（重要）
- 方法7：num 为可执行替换的最高次数，若num>len(string)，则全部替换；若num
- 如果要查找的数据不存在于string中，index 会报错，而 find 会返回-1不会报错
例：我们展示较为常用的几个方法
str1 = "Hello Python"
print(str1.startswith("He"))
print(str1.endswith("on"))
print(str1.find("Py", 6, 7))
print(str1.find("Py", 6, 8))
print(str1.replace("o", "6", 1))
print(str1.replace("o", "6"))
print(str1)
（4）文本对齐
| 序号 | 方法 | 含义 |
|---|---|---|
| 1 | string.ljust(width) | 返回一个 原字符串左对齐，并使用空格填充至长度width的 新字符串 |
| 2 | string.rjust(width) | 返回一个 原字符串右对齐，并使用空格填充至长度width的 新字符串 |
| 3 | string.center(width) | 返回一个 原字符串居中，并使用空格填充至长度width的 新字符串 |
- 注：这些方法只是返回一个新的字符串，而不会覆盖原字符串string
- ljust(width, str) 、rjust(width, str) 和 **center(width, str)**都有原型，当 str 缺省时，会使用半角空格（一个英文长度的空格）来进行填充；当 str 指定后，会使用 str 指定的字符来进行填充
- 如果 width 的长度比 string 短，那么对齐可能无效
例：由于是中文的对齐，因此我们指定 str 为全角空格（一个中文长度的空格）来进行对齐
- 其中 " " 中的 | | 用于观察 width 的长度，显然长度都一致
"""假设以下文本是从网络上爬取的，要进行文本对齐"""
poem = ["岁月极美",
"在于它必然的流逝",
"我们将掌心拢起",
"也抓不住飘渺的云烟",
"攥不住流动的细沙",
"更留不住逝去的年华"]
for sentence in poem:
print("|%s|" % sentence.rjust(20, " "))
for sentence in poem:
print("|%s|" % sentence.ljust(20, " "))
for sentence in poem:
print("|%s|" % sentence.center(20, " "))
（5）去除空白字符
| 序号 | 方法 | 含义 |
|---|---|---|
| 1 | string.lstrip() | 截掉string左边的（开始）的空白字符 |
| 2 | string.rstrip() | 截掉string右边的（末尾）的空白字符 |
| 3 | string.strip() | 截掉string左右两边的空白字符 |
- 注：这些方法只是返回一个新的字符串，而不会覆盖原字符串string
例：还是以poem为例，我们随意地向诗句上面增加一些空白字符
"""假设以下文本是从网络上爬取的"""
poem = ["\n\t岁月极美",
"在于它必然的流逝",
"我们将掌心拢起\t\n",
"\t也抓不住飘渺的云烟",
"攥不住流动的细沙",
"更留不住逝去的年华"]
for sentence in poem:
"""我们去除空白字符，再进行文本对齐"""
print("|%s|" % sentence.strip().center(20, " "))
- 补充：在这个代码中，我们首次展示了方法的连用：
print("|%s|" % sentence.strip().center(20, " "))
即首先通过 strip() 得到一个新的字符串，再通过 center() 来对这个新字符串再进行操作，从而形成了方法的连用，本质上，原字符串和第一个新字符串都是一个对象，它们均能够使用方法
（6）拆分和连接
| 序号 | 方法 | 含义 |
|---|---|---|
| 1 | string.partition(str) | 把字符串string分成一个3元素的元组（str前面，str，str后面） |
| 2 | string.rpartition(str) | 类似于partition()方法，不过是查找str在右边第一次出现的位置（str可能有多个） |
| 3 | string.split(str, num) | 以str为分隔符拆分string，如果num有指定值，则仅分隔num+1个子字符串（str缺省时，str为空白字符\r、\t、\n和空格） |
| 4 | string.splitlines() | 按照行(\r、\n、\r\n)分隔，返回一个包含各行作为元素的列表 |
| 5 | string.join(seq) | 以string作为分隔符，将seq（字符串或元组）中所有的元素（的字符串表示）合并为一个新的字符串 |
- 注：这些方法只是返回一个新的字符串或元组，而不会覆盖原字符串string
- 方法1、2、3、4的返回值是一个元组
例：
str1 = "Hello World"
print(str1.partition("l"))
print(str1.rpartition("l"))
str2 = "\n\t岁月极美\t在于它必然的流逝\n我们将掌心拢起 也抓不住飘渺的云烟\n攥不住流动的细沙\t更留不住逝去的年华"
new_str = str2.split()
for information in new_str:
print(information)
print(" ".join(new_str))
3.for in对字符串迭代遍历（较少使用）
str = "欢迎来到 ~宪宪 的博客"
for char in str:
print(char, end='')
4.字符串的切片
字符串[开始下标:结束下标]
截取范围 [开始下标,结束下标) 的字符串
字符串[开始下标:结束下标:步长]
可以从 开始下标~结束下标 的范围对字符串进行切片，其中步长指的是下一次切片时相对于这一次切片时的位置按步长的方向向后位移的元素个数（下标数），因此步长不能为0，否则切片的位置不动是显然不正确的
- 当 步长>0 时：表示从左到右进行切片，此时范围应满足：开始下标<结束下标
- 当 步长<0 时：表示从右到左进行切片，此时范围应满足：开始下标>结束下标
- 当 步长缺省时，则默认：步长=1
- 范围：[开始下标,结束下标) 中，结束下标的字符不包含在范围内
（1）若开始下标缺省，则开始下标默认为字符串的最左端或最右端，这个开始位置由切片的方向决定，若步长>0，则开始下标为字符串最左端；若步长<0，则开始下标为字符串最右端
（2）若结束下标缺省，则按步长方向切片到字符串的另一端尽头 - 当不知道字符串的长度时，开始下标或结束下标可用负数来指定，表示倒数第几个元素，如-1就是倒数第1个字符（由于没有-0之说，所以负下标是从-1开始）
- 步长，如：对"欢迎来到~宪宪的博客"进行步长为2的切片，从 [0,10) 的范围进行切片，第一次切下的是"欢"，由于步长为2，第二次切片的位置相对这一次切片时的位置向后位移2个下标（间隔1个字符），故第二次切下的是"来"，第三次切下的是"~"，接着"宪"，“博”
——于是，上述截取的结果为：“欢来~宪博” - 当步长缺省时，则默认为1，即每次切片向后位移一个下标的单位
例：str1[::]表示截取完整的字符串
例：str1[::2]表示每次切片后下次切片时下标位移2个单位（间隔1个字符），截取范围为整个字符串
例：str1[-1]倒数第1个字符，即下标访问
例：
str1 = "岁月极美 在于它必然的流逝 我们将掌心拢起 也抓不住飘渺的云烟 攥不住流动的细沙 更留不住逝去的年华"
print(str1)
print(new_str2[0:4])
"""从开始到结束，步长为2"""
print(new_str2[0::2])
print(new_str2[0:-2:2])
例：字符串逆序输出
str2 = "0123456789"
print(str2[-1::-1])
五、高级数据类型的公共方法
针对高级变量类型列表、元组、字典和字符串都可以使用的方法称为公共方法
1.Python的内置函数
| 函数 | 描述 | 备注 |
|---|---|---|
| len(item) | 计算容器中元素个数 | |
| del(item) | 删除变量 | del有两种方式 |
| max(item) | 返回容器中元素最大值 | 如果是字典，只针对key比较 |
| min(item) | 返回容器中元素最小值 | 如果是字典，只针对key比较 |
| cmp(item1, item2) | 比较两个值（-1小于/0相等/1大于） | Python3.X取消了cmp函数 |
- del的两种方式分别是关键字和函数前面我们使用的是关键字，它们效果是完全相同的
- 比较字符的大小会按照ASCII码和字典排序的方式来进行比较（不懂字典排序可自行百度）
- 在Python3.X中，可以通过比较运算符来代替cmp函数，比较运算符返回值为True或False
- 两个字典之间不能比较大小
- 列表和元组的比较大小，对列表或元组内的元素依次进行比较，当相同下标的元素第一次出现不同时，则返回这个比较结果（按ASCII或字典排序比较），如果所有相同下标的元素都相等，则返回相等结果（重要）
2.切片
除字符串外，列表和元组的元素也可以通过下标来进行访问，因此它们也可以进行切片操作
| 描述 | Python表达式 | 结果 | 支持的数据类型 |
|---|---|---|---|
| 切片 | “0123456789”[::-2] | “97531” | 字符串、列表、元组 |
例：
"""其他类型的切片"""
list_name = [1, 2, 3, 4, 5, 6]
print(list_name[::-2])
info_tuple = ("张三", "男", 18, 1.75)
print(info_tuple[::-3])
3.运算符
| 运算符 | 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 | 元素比较 | 字符串、列表、元组 |
- 列表.extend(列表2) 会把列表2追加到列表上，而列表1 + 列表2会生成新的列表
4.完整的for循环语法
完整的迭代遍历逻辑与格式如图所示：
- 注：continue 不会影响else的执行
例：
for num in [0, 1, 2, 3]:
if num == 3:
break
else:
print("这段代码不会被执行")
完整的for else语句对求范围内的素数时非常好用
常用应用场景：
例：在指定的字典列表中寻找信息，如：查找李红和李华的性别，如果没找到则告诉用户
student_list = [{
"name": "张三",
"sex": "男"},
{
"name": "李红",
"sex": "女"},
{
"name": "老王",
"sex": "男"}]
"""在字典中查找李红的性别"""
for info_tuple in student_list:
if info_tuple["name"] == "李红":
print("找到了李红，性别：%s" % info_tuple["sex"])
break
else:
print("没有找到李红")
"""在字典中查找李华的性别"""
for info_tuple in student_list:
if info_tuple["name"] == "李华":
print("找到了李红，性别：%s" % info_tuple["sex"])
break
else:
print("没有找到李华")
六、阶段学习小结——综合应用：名片管理系统
名片信息包含：姓名、电话、QQ、邮箱
需求：
- 新增名片
- 显示所有名片
- 名片查询——修改名片、删除名片
- 要有一个选择的界面
1.框架搭建
我们约定用 administration_main.py 文件作为名片管理系统的主函数
其次，用 administration_function.py 文件作为名片管理系统封装函数的文件
于是， administration_main.py 文件中搭建的功能代码框架如下：
import administration_function
"""创建一个空列表，用于放置用户的名片字典"""
list_card = []
"""保证用户循环输入"""
while 1:
administration_function.welcome()
choice = input("请输入您的选择：")
if choice == "0":
exit(0)
elif choice == "1":
list_card.append(administration_function.building())
elif choice == "2":
administration_function.listing(list_card)
elif choice == "3":
administration_function.inquire(list_card)
else:
print("请输入有效的选项！")
continue
下面介绍上述代码中所出现的 administration_function.py 文件中的函数：
- welcome()：欢迎界面，用于指引用户进行选择
- building()：新建名片，返回一个字典
list_card.append(administration_function.building()) 表示把新建的字典追加到列表后 - listing(list)：显示所有名片（ list_card ）
- inquire(list)：在 list_card 中查询名片
administration_function.py 文件中的 welcome() 欢迎界面函数代码如下：
提示：print("******************************************************") 可以用 print(" * " * 50) 来表示
def welcome():
"""欢迎界面"""
print("******************************************************")
print("欢迎使用【名片管理系统】 V1.0")
print()
print("1.新建名片")
print("2.查看所有名片")
print("3.查询名片")
print()
print("0.退出系统")
print("******************************************************")
输入错误判断：
于是，名片管理系统的总体框架我们已经搭建起来了
2.完善其余函数
（1）building() -> dict 函数
building() -> dict 函数用于新建名片，并且返回一个字典，因此我们要求用户输入并获取新建名片时输入的信息：姓名、电话、QQ和邮箱；新建一个字典，把获得的信息置于字典中，并返回字典
def building():
"""新建名片"""
print("------------------------------------------------------")
temp_name = input("请输入姓名：")
temp_phone = input("请输入电话：")
temp_qq = input("请输入QQ号码：")
temp_email = input("请输入邮箱：")
print("名片添加成功！")
print("------------------------------------------------------")
temp_dict = {
"name": temp_name,
"phone": temp_phone,
"qq": temp_qq,
"email": temp_email}
return temp_dict
（2）listing(list) 函数
listing(list) 函数用于显示所有名片，因此需要把由 名片字典 组成的 列表 list_card 作为参数传入函数，当程序中没有名片时我们要告诉用户名片集为空，否则按照一定的文本格式来输出程序中的名片
def listing(temp_list):
"""列出所有名片"""
"""用len()函数来判断列表是否为空"""
if len(temp_list) == 0:
print("------------------------------------------------------")
print("名片为空！")
print("------------------------------------------------------")
return
"""控制输出格式"""
print("******************************************************")
print("姓名".center(6, " "),
"电话".center(12, " "),
"QQ".center(12, " "),
"邮箱".center(12, " "))
for card in temp_list:
print(card["name"].ljust(6, " "),
card["phone"].ljust(12, " "),
card["qq"].ljust(12, " "),
card["email"].ljust(12, " "))
print("******************************************************")
当程序中名片为空时：
当程序中名片不为空时：
（3）inquire(list) 函数
inquire(list) 函数用于查询名片，因此需要判断所查询的名片是否存在，在查询名片后，提供用户两个选择：修改名片、删除名片，还有返回到主菜单，因此在 inquire(list) 函数中，又另外添加了一个函数：change(dict) 函数，主要用于修改名片中的值，因此需要传入需要更改的名片字典作为参数
inquire(list) 函数代码如下：
def inquire(temp_list):
"""查询名片"""
print("------------------------------------------------------")
temp_name = input("请输入您要查询的名片的姓名：")
print("------------------------------------------------------")
"""根据用户输入的姓名查找名片，并列出名片信息"""
for card in temp_list:
if card["name"] == temp_name:
print("******************************************************")
print("姓名".center(6, " "),
"电话".center(12, " "),
"QQ".center(12, " "),
"邮箱".center(12, " "))
print(card["name"].ljust(6, " "),
card["phone"].ljust(12, " "),
card["qq"].ljust(12, " "),
card["email"].ljust(12, " "))
print("******************************************************")
print("1.修改名片")
print("2.删除名片")
print()
print("0.返回")
print("******************************************************")
while 1:
temp_choice = input("请输入您的选择：")
if temp_choice == "0":
return
elif temp_choice == "1":
change(card)
break
elif temp_choice == "2":
# 删除名片
del temp_list[temp_list.index(card)]
print("删除成功！")
break
else:
print("请输入有效的选项")
continue
break
else:
print("没有找到该姓名的名片")
print("------------------------------------------------------")
- 注意指代词card，由于无法直接通过指代词card来删除列表中的元素，因此我们需要通过
列表.index(数据) 函数先找到需要删除的名片字典所在的下标，再用 del temp_list[下标] 才能正确删除列表中的名片字典
change(dict) 函数代码如下：
直接传入需要修改的字典即可修改名片字典
def change(temp_dict):
"""修改名片"""
print("------------------------------------------------------")
temp_name = input("新姓名【若不修改则直接回车】：")
if temp_name != "":
temp_dict["name"] = temp_name
temp_phone = input("新电话【若不修改则直接回车】：")
if temp_phone != "":
temp_dict["phone"] = temp_phone
temp_qq = input("新QQ号码【若不修改则直接回车】：")
if temp_qq != "":
temp_dict["qq"] = temp_qq
temp_email = input("新邮箱【若不修改则直接回车】：")
if temp_email != "":
temp_dict["email"] = temp_email
print("修改成功！")
print("------------------------------------------------------")
- 当用户直接按下回车时，表示输入的内容为 “” 空，我们以此来表示用户不想作修改时的选择
最后，名片管理系统顺利完成！
3.源代码
（1）administration_function.py 文件：
def welcome():
"""欢迎界面"""
print("******************************************************")
print("欢迎使用【名片管理系统】 V1.0")
print()
print("1.新建名片")
print("2.查看所有名片")
print("3.查询名片")
print()
print("0.退出系统")
print("******************************************************")
def building():
"""新建名片"""
print("------------------------------------------------------")
temp_name = input("请输入姓名：")
temp_phone = input("请输入电话：")
temp_qq = input("请输入QQ号码：")
temp_email = input("请输入邮箱：")
print("名片添加成功！")
print("------------------------------------------------------")
temp_dict = {
"name": temp_name,
"phone": temp_phone,
"qq": temp_qq,
"email": temp_email}
return temp_dict
def listing(temp_list):
"""列出所有名片"""
if len(temp_list) == 0:
print("------------------------------------------------------")
print("名片为空！")
print("------------------------------------------------------")
return
print("******************************************************")
print("姓名".center(6, " "),
"电话".center(12, " "),
"QQ".center(12, " "),
"邮箱".center(12, " "))
for card in temp_list:
print(card["name"].ljust(6, " "),
card["phone"].ljust(12, " "),
card["qq"].ljust(12, " "),
card["email"].ljust(12, " "))
print("******************************************************")
def change(temp_dict):
"""修改名片"""
print("------------------------------------------------------")
temp_name = input("新姓名【若不修改则直接回车】：")
if temp_name != "":
temp_dict["name"] = temp_name
temp_phone = input("新电话【若不修改则直接回车】：")
if temp_phone != "":
temp_dict["phone"] = temp_phone
temp_qq = input("新QQ号码【若不修改则直接回车】：")
if temp_qq != "":
temp_dict["qq"] = temp_qq
temp_email = input("新邮箱【若不修改则直接回车】：")
if temp_email != "":
temp_dict["email"] = temp_email
print("修改成功！")
print("------------------------------------------------------")
def inquire(temp_list):
"""查询名片"""
print("------------------------------------------------------")
temp_name = input("请输入您要查询的名片的姓名：")
print("------------------------------------------------------")
for card in temp_list:
if card["name"] == temp_name:
print("******************************************************")
print("姓名".center(6, " "),
"电话".center(12, " "),
"QQ".center(12, " "),
"邮箱".center(12, " "))
print(card["name"].ljust(6, " "),
card["phone"].ljust(12, " "),
card["qq"].ljust(12, " "),
card["email"].ljust(12, " "))
print("******************************************************")
print("1.修改名片")
print("2.删除名片")
print()
print("0.返回")
print("******************************************************")
while 1:
temp_choice = input("请输入您的选择：")
if temp_choice == "0":
return
elif temp_choice == "1":
change(card)
break
elif temp_choice == "2":
# 删除名片
del temp_list[temp_list.index(card)]
print("删除成功！")
break
else:
print("请输入有效的选项")
continue
break
else:
print("没有找到该姓名的名片")
print("------------------------------------------------------")
（2）administration_main.py 文件：
import administration_function
list_card = []
while 1:
administration_function.welcome()
choice = input("请输入您的选择：")
if choice == "0":
exit(0)
elif choice == "1":
list_card.append(administration_function.building())
elif choice == "2":
administration_function.listing(list_card)
elif choice == "3":
administration_function.inquire(list_card)
else:
print("请输入有效的选项！")
continue
上一篇文章
- 二、Python基础（基础篇）