Python 控制结构

最新推荐文章于 2024-05-30 23:59:50 发布

原创最新推荐文章于 2024-05-30 23:59:50 发布 · 477 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#python #编程语言

Python快速入门专栏收录该内容

2 篇文章

订阅专栏

本文详细介绍了Python的控制结构，包括运算符与表达式，如算术、比较、赋值、位、逻辑、成员和身份运算符；三大控制结构：顺序、分支（if-else语句）、循环结构，特别讨论了for循环和while循环的使用，以及列表解析式和字典解析式；还涵盖了浅拷贝与深拷贝的概念及其区别。

一、Python 运算符与表达式

1、算术运算符

算术运算符主要包括四则运算符、求模运算符等。

运算符	描述	例子	结果
+	加	a = 7，b = 3	10
-	减	a = 7，b = 3	4
*	乘	a = 7，b = 3	21
/	除	a = 7，b = 3	2.3333333333333335
%	取模，a / b 的余数	a = 7，b = 3	1
**	幂运算，a 的 b 次方	a = 7，b = 3	343
//	取整除，a / b 取整数商	a = 7，b = 3	2

# coding=utf-8

a, b = 7, 3

print('加法:', a + b)
print('减法:', a - b)
print('乘法:', a * b)
print('除法:', a / b)
print('取模:', a % b)
print('幂运算:', a ** b)
print('取整除:', a // b)


# 结果为
加法: 10
减法: 4
乘法: 21
除法: 2.3333333333333335
取模: 1
幂运算: 343
取整除: 2

Process finished with exit code 0

2、比较（关系）运算符

比较（关系）运算符是对两个对象的比较。

运算符	表达式	描述
==	a == b	比较对象是否相等，若相等，则返回 True，反之 False
!=	a != b	比较对象是否不相等，若不相等，则返回 True，反之 False
>	a > b	比较 a 是否大于 b，若成立，则返回True，反之 False
<	a < b	比较 a 是否小于 b，若成立，则返回True，反之 False
>=	a >= b	比较 a 是否大于等于 b，若成立，则返回True，反之 False
<=	a <= b	比较 a 是否小于等于 b，若成立，则返回True，反之 False

# coding=utf-8

a, b = 7, 7

print('表达式 == :', a == b)
print('表达式 != :', a != b)
print('表达式 > :', a > b)
print('表达式 < :', a < b)
print('表达式 >= :', a >= b)
print('表达式 <= :', a <= b)


# 结果为
表达式 == : True
表达式 != : False
表达式 > : False
表达式 < : False
表达式 >= : True
表达式 <= : True

Process finished with exit code 0

3、赋值运算符

赋值运算符是把赋值运算与算术运算结合起来，简化了写法。

运算符	表达式	描述
=	c = a + b	简单赋值运算符
+=	a += b 等价于 a = a + b	加法赋值运算符
-=	a -= b 等价于 a = a - b	减法赋值运算符
*=	a = b 等价于 a = a b	乘法赋值运算符
/=	a /= b 等价于 a = a / b	除法赋值运算符
%=	a %= b 等价于 a = a % b	取模赋值运算符
**=	a = b 等价于 a = a b	幂赋值运算符
//=	a // b 等价于 a = a // b	取整除赋值运算符

# coding=utf-8

a, b = 7, 3
print('= 赋值运算符:', a + b)

a, b = 7, 3
a += b
print('+= 赋值运算符:', a)

a, b = 7, 3
a -= b
print('-= 赋值运算符:', a)

a, b = 7, 3
a *= b
print('*= 赋值运算符:', a)

a, b = 7, 3
a /= b
print('/= 赋值运算符:', a)

a, b = 7, 3
a %= b
print('%= 赋值运算符:', a)

a, b = 7, 3
a **= b
print('**= 赋值运算符:', a)

a, b = 7, 3
a //= b
print('//= 赋值运算符:', a)


# 结果为
= 赋值运算符: 10
+= 赋值运算符: 10
-= 赋值运算符: 4
*= 赋值运算符: 21
/= 赋值运算符: 2.3333333333333335
%= 赋值运算符: 1
**= 赋值运算符: 343
//= 赋值运算符: 2

Process finished with exit code 0

4、位运算符

位运算符是把数字转化为二进制数后再进行运算。

运算符	表达式	描述
&	a & b	按位与运算，参与运算的两个值转化为二进制数后，如果对应的两个相应位都为1，则该位的结果为1，否则为0
\|	a \| b	按位或运算，只要对应的两个二进制位有一个为1时，结果为1
^	a ^ b	按位异或运算，当两个对应的二进制位相异时，结果为1
~	~ a	按位取反运算符，对数据的每个二进制位取反，即把1变为0，把0变为1，-x 相当于 -x-1
<<	a << b	左移运算符，数据的各二进制位全部左移 b 位，低位补0
>>	a >> b	右移运算符，数据的各二进制位全部右移 b 位，高位弃0

# coding=utf-8

a, b = 3, 1

print('与运算:', a & b)
print('或运算:', a | b)
print('异或运算:', a ^ b)
print('取反运算符:', ~a)
print('左移运算符:', a << b)
print('右移运算符:', a >> b)


# 结果为
与运算: 1
或运算: 3
异或运算: 2
取反运算符: -4
左移运算符: 6
右移运算符: 1

Process finished with exit code 0

5、逻辑运算符

逻辑运算符与、或、非。

运算符	表达式	描述
and	a and b	布尔与，如果 a 为 False，则返回 False，否则返回 b 的计算值
or	a or b	布尔或，如果 a 为 True，则返回 a 的值，否则返回 b 的计算值
not	not a	布尔非，如果 a 的值为 True，则返回 False，如果 a 为False，则返回 True

# coding=utf-8

a, b = False, True

print('逻辑与:', a and b)
print('逻辑或:', a or b)
print('逻辑非:', not a)


# 结果为
逻辑与: False
逻辑或: True
逻辑非: True

Process finished with exit code 0

6、成员运算符

成员运算符是判断一个变量的值是否是另一个变量的一部分。

运算符	描述
in	如果在指定的序列中找到一个变量的值，则返回 True，否则返回 False
not in	如果在指定序列中找不到变量的值，则返回 True，否则返回 False

# coding=utf-8

a = 123
b = [123, 456, 789]

if a in b:
    print('a in b')
elif a not in b:
    print('a not in b')
    
    
# 结果为
a in b

Process finished with exit code 0

7、身份运算符

身份运算用于比较两个对象是否为同一个对象，is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。在Python中，每一个变量有3个属性：name、id、value。

name 是变量名，内存的名称就是变量名。实际上，内存数据都是以地址来识别的，根本没有内存名称这个说法，只是高级语言提供的抽象机制，方便操作内存数据
id 是内存地址，用于识别内存块
value 是变量值，内存的数据就是变量值对应的二进制数。

身份运算符通过 id 来进行判断，id 相同就返回 True，否则返回 False。

运算符	描述	实例
is	is 是判断两个标识符是不是引用自一个对象	x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not	is not 是判断两个标识符是不是引用自不同对象	对象 x is not y ，类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False

整数的比较

# coding=utf-8

int1, int2 = 30, 30

print('== 判断:', int1 == int2)
print('is 判断:', int1 is int2)
print('int1的地址:', id(int1))
print('int2的地址:', id(int2))


# 结果为
== 判断: True
is 判断: True
int1的地址: 140720087177792
int2的地址: 140720087177792

Process finished with exit code 0

字符串的比较

# coding=utf-8

str1, str2 = 'Python', 'Python'

print('== 判断:', str1 == str2)
print('is 判断:', str1 is str2)
print('str1的地址:', id(str1))
print('str2的地址:', id(str2))


# 结果为
== 判断: True
is 判断: True
str1的地址: 1915731808496
str2的地址: 1915731808496

Process finished with exit code 0

列表的比较

# coding=utf-8

list1, list2 = [1, 2, 3, 4, 5], [1, 2, 3, 4, 5]

print('== 判断:', list1 == list2)
print('is 判断:', list1 is list2)
print('list1的地址:', id(list1))
print('list2的地址:', id(list2))


# 结果为
== 判断: True
is 判断: False
list1的地址: 2375648806144
list2的地址: 2375648822912

Process finished with exit code 0

元组的比较

# coding=utf-8

tuple1, tuple2 = ('Java', 'Python', 'C++'), ('Java', 'Python', 'C++')

print('== 判断:', tuple1 == tuple2)
print('is 判断:', tuple1 is tuple2)
print('tuple1的地址:', id(tuple1))
print('tuple2的地址:', id(tuple2))


# 结果为
== 判断: True
is 判断: True
tuple1的地址: 2000834625280
tuple2的地址: 2000834625280

Process finished with exit code 0

字典的比较

# coding=utf-8

dict1, dict2 = {'s1': 'Java', 's2': 'Python', 's3': 'C++'}, {'s1': 'Java', 's2': 'Python', 's3': 'C++'}

print('== 判断:', dict1 == dict2)
print('is 判断:', dict1 is dict2)
print('dict1的地址:', id(dict1))
print('dict2的地址:', id(dict2))


# 结果为
== 判断: True
is 判断: False
dict1的地址: 2719551079872
dict2的地址: 2719551079936

Process finished with exit code 0

8、浅拷贝与深拷贝

为了让一哥对象发生改变时不对原对象产生副作用，我们需要一份这个对象的拷贝。Python提供了拷贝模块 copy，拷贝分为浅拷贝和深拷贝。

浅拷贝

浅拷贝就是创建一个具有相同类型、相同值，但不同 id 的新对象。浅拷贝对子对象不起作用，其中一个变量的子对象值被修改了，另外一个也跟着修改。因此浅拷贝的典型使用场景时：对象自身发生改变的同时需要保持对象中的值完全相同。

# coding=utf-8
import copy

a = [1, 2, 3, ['a', 'b', 'c']]
b = copy.copy(a)
print('a的地址:', id(a))
print('b的地址:', id(b))
print('a的值:', a)
print('b的值:', b)
print('此时a和b的地址是否相等:', a is b)
print('此时a和b的值是否相等:', a == b)
print('----------------------------')

a[3].append('d')
print('a的地址:', id(a))
print('b的地址:', id(b))
print('a的值:', a)
print('b的值:', b)
print('此时a和b的地址是否相等:', a is b)
print('此时a和b的值是否相等:', a == b)
print('----------------------------')

a.append(10)
print('a的地址:', id(a))
print('b的地址:', id(b))
print('a的值:', a)
print('b的值:', b)
print('此时a和b的地址是否相等:', a is b)
print('此时a和b的值是否相等:', a == b)


# 结果为
a的地址: 1171327117696
b的地址: 1171327336000
a的值: [1, 2, 3, ['a', 'b', 'c']]
b的值: [1, 2, 3, ['a', 'b', 'c']]
此时a和b的地址是否相等: False
此时a和b的值是否相等: True
----------------------------
a的地址: 1171327117696
b的地址: 1171327336000
a的值: [1, 2, 3, ['a', 'b', 'c', 'd']]
b的值: [1, 2, 3, ['a', 'b', 'c', 'd']]
此时a和b的地址是否相等: False
此时a和b的值是否相等: True
----------------------------
a的地址: 1171327117696
b的地址: 1171327336000
a的值: [1, 2, 3, ['a', 'b', 'c', 'd'], 10]
b的值: [1, 2, 3, ['a', 'b', 'c', 'd']]
此时a和b的地址是否相等: False
此时a和b的值是否相等: False

Process finished with exit code 0

深拷贝

深拷贝不仅仅拷贝原始对象自身，也会对其包含的值进行拷贝，它会递归地查找对象中包含的其它对象的引用来完成更深层次的拷贝。拷贝完成以后，两个变量为完全独立的对象，互不影响。因此，深拷贝产生的副本可以随意修改而不必担心会引起原始值的改变。

# coding=utf-8
import copy

a = [1, 2, 3, ['a', 'b', 'c']]
b = copy.deepcopy(a)
print('a的地址:', id(a))
print('b的地址:', id(b))
print('a的值:', a)
print('b的值:', b)
print('此时a和b的地址是否相等:', a is b)
print('此时a和b的值是否相等:', a == b)
print('----------------------------')

a[3].append('d')
print('a的地址:', id(a))
print('b的地址:', id(b))
print('a的值:', a)
print('b的值:', b)
print('此时a和b的地址是否相等:', a is b)
print('此时a和b的值是否相等:', a == b)
print('----------------------------')

a.append(10)
print('a的地址:', id(a))
print('b的地址:', id(b))
print('a的值:', a)
print('b的值:', b)
print('此时a和b的地址是否相等:', a is b)
print('此时a和b的值是否相等:', a == b)


# 结果为
a的地址: 2701847849664
b的地址: 2701848067648
a的值: [1, 2, 3, ['a', 'b', 'c']]
b的值: [1, 2, 3, ['a', 'b', 'c']]
此时a和b的地址是否相等: False
此时a和b的值是否相等: True
----------------------------
a的地址: 2701847849664
b的地址: 2701848067648
a的值: [1, 2, 3, ['a', 'b', 'c', 'd']]
b的值: [1, 2, 3, ['a', 'b', 'c']]
此时a和b的地址是否相等: False
此时a和b的值是否相等: False
----------------------------
a的地址: 2701847849664
b的地址: 2701848067648
a的值: [1, 2, 3, ['a', 'b', 'c', 'd'], 10]
b的值: [1, 2, 3, ['a', 'b', 'c']]
此时a和b的地址是否相等: False
此时a和b的值是否相等: False

Process finished with exit code 0

综上所述，关于赋值，浅拷贝、深拷贝的区别如下：赋值要变一起变：浅拷贝只对子对象负责：深拷贝两对象互不影响。

二、Python 三大控制结构

1、顺序结构

按照从上到下的顺序，一条语句一条语句的执行，是最基本的结构。

2、分支结构

分支结构又称为选择结构，指代码根据判断条件执行特定的代码块，判断条件把代码分为两部分，根据判断的结果只能执行其中的一部分，

2.1、if 语句

# coding=utf-8

a, b = 3, 2

if a > b:
    print('a大于b')


# 结果为
a大于b

Process finished with exit code 0

a>b 为判断表达式，可以是各种运算符表达式的一种或几种的组合。
判断表达式以 : 结尾。
如果判断条件为真，则执行条件下面的代码块，代码块可以是一行或多行，代码块注意缩进。

2.2、if-else 语句

# coding=utf-8

a, b = 3, 2

if a > b:
    print('a大于b')
else:
    print('a不大于b')


# 结果为
a大于b

Process finished with exit code 0

把判断条件换一下

# coding=utf-8

a, b = 2, 3

if a > b:
    print('a大于b')
else:
    print('a不大于b')


# 结果为
a不大于b

Process finished with exit code 0

2.3、if-esif-else 语句

# coding=utf-8

score = 90

if score >= 80:
    print('良好')
elif score >= 60:
    print('一般')
else:
    print('不合格')


# 结果为
良好

Process finished with exit code 0

if-esif-else 用在有三个判断条件的情况下，只要符合其中的一个，就执行相对应的代码，然后跳出所有判断语句。

2.4、if-esif-esif-else 语句

# coding=utf-8

score = 59

if score >= 90:
    print('优秀')
elif score >= 80:
    print('良好')
elif score >= 60:
    print('一般')
else:
    print('不合格')


# 结果为
不合格

Process finished with exit code 0

在有多个判断条件的情况下，只要符合其中的一个，就执行相对应的代码。

2.5、嵌套代码块

if 语句里面嵌套使用 if 语句，嵌套的 if 语句可以是上面的4种语法中的任意一种。

3、循环结构

不断重复就是循环。循环结构是在一定条件下反复执行某部分代码的操作，是Python程序数据中使用频率最高的一个结构，在Python中，常见的循环结构有 ·for· 循环和 ·while· 循环。

三、for循环

for 循环为循环结构的一种。在Python中，for 循环是一种迭代循环，每次操作都是基于上一次的结果进行的。for 循环常用于遍历字符串、列表、字典等数据结构。

# coding=utf-8

str1 = 'Hello Python'
count = 0
for i in str1:
    if i == 'o':
        count += 1
print('在字符串', str1, '中，字符o出现了', count, '次。')


# 结果为
在字符串 Hello Python 中，字符o出现了 2 次。

Process finished with exit code 0

如例子中，i 为变量名，str1 为序列，if 分支结构为每次循环后执行的代码块。
for循环也被称为 for in 结构。变量名为序列中的一个元素，遍历完所有元素循环结束。在每一次的循环中，执行代码块。
序列后以:结尾。
代码块内的每一句语句都具有相同的缩进。

1、for循环与列表

向列表添加元素

# coding=utf-8

list1 = []
for i in range(10):
    if i % 2 == 1:
        list1.append(i)
print('10以内的奇数有：', list1)


# 结果为
10以内的奇数有： [1, 3, 5, 7, 9]

Process finished with exit code 0

遍历列表

# coding=utf-8

list1 = ['Python', 'Java', 'C++']
for i in list1:
    print(i.title())

# 结果为
Python
Java
C++

Process finished with exit code 0

当需要用到元素的 index 和 value 值的时候，可以使用 enumerate 函数遍历列表。

# coding=utf-8

list1 = ['Python', 'Java', 'C++']
for index, value in enumerate(list1):
    print('值：', value, '，索引下标：', index)

# 结果为
值： Python ，索引下标： 0
值： Java ，索引下标： 1
值： C++ ，索引下标： 2

Process finished with exit code 0

利用 enumerate 函数遍历列表时创建字典。

# coding=utf-8

list1 = ['Python', 'Java', 'C++']
dict1 = {}
for index, value in enumerate(list1):
    dict1[index] = value

print(type(dict1))
print(dict1)


# 结果为
<class 'dict'>
{0: 'Python', 1: 'Java', 2: 'C++'}

Process finished with exit code 0

2、for循环与字典

Python支持使用for循环遍历字典。

使用 items() 遍历所有的键值对。
使用 keys() 遍历所有的键。
是哟个 values() 遍历所有的值。

# coding=utf-8

dict1 = {'s1': 'Python', 's2': 'Java', 's3': 'C++'}

for item in dict1.items():
    print('所有键值对：', item)

for key in dict1.keys():
    print('所有键：', key)

for value in dict1.values():
    print('所有值：', value)


# 结果为
所有键值对： ('s1', 'Python')
所有键值对： ('s2', 'Java')
所有键值对： ('s3', 'C++')
所有键： s1
所有键： s2
所有键： s3
所有值： Python
所有值： Java
所有值： C++

Process finished with exit code 0

3、嵌套for循环

# coding=utf-8

for i in range(1, 10):
    for j in range(1, i + 1):
        print(f'{i}*{j}={i * j}  ', end='')
    print()


# 结果为
1*1=1  
2*1=2  2*2=4  
3*1=3  3*2=6  3*3=9  
4*1=4  4*2=8  4*3=12  4*4=16  
5*1=5  5*2=10  5*3=15  5*4=20  5*5=25  
6*1=6  6*2=12  6*3=18  6*4=24  6*5=30  6*6=36  
7*1=7  7*2=14  7*3=21  7*4=28  7*5=35  7*6=42  7*7=49  
8*1=8  8*2=16  8*3=24  8*4=32  8*5=40  8*6=48  8*7=56  8*8=64  
9*1=9  9*2=18  9*3=27  9*4=36  9*5=45  9*6=54  9*7=63  9*8=72  9*9=81  

Process finished with exit code 0

二、列表解析式

1、概念

利用for循环创建列表非常低效，并且代码复杂，在Python编程中，我们经常用列表解析式动态创建列表，它是将一个列表转化为另一个列表的工具，它分为两种模式，分别是指定if条件和无条件。

指定if条件的转换是指定元素必须符合一定的条件时，才能添加到新的列表里，目的是所有元素都可以按照需要进行转换。
无条件转换是所有元素都可以转换为列表。

指定if条件的转换语法

列表名 = [表达式 for 变量名 in 序列 if 条件]

等价于

列表名 = []
    for 变量名 in 序列:
        if 条件:
            列表名.append()

无条件转换语法

列表名 = [表达式 for 变量名 in 序列]

等价于

列表名 = []
    for 变量名 in 序列:
        列表名.append()

2、指定if条件的列表解析式

列表解析式中的核心是for循环，每一个列表解析式都可以重写为for循环，但并不是每一个for循环都可以重写为列表解析式。

if 的形式

# coding=utf-8

list1 = []
for i in range(10):
    if i % 2 == 1:
        list1.append(i)
print('10以内的奇数有：', list1)


# 结果为
10以内的奇数有： [1, 3, 5, 7, 9]

Process finished with exit code 0

把上面的for循环转换为列表解析式步骤

复制 list1 = []
把 append() 方法中的标量i写入新列表中，list1 = [i]
复制 for 循环语句，注意最后不需要 :，list1 = [i for i in range(10)]
复制 if 条件控制语句，注意最后不需要 :，list1 = [i for i in range(10) if i % 2 == 1]

list1 = {n for n in range(10) if n % 2 == 1}

为了可读性写成以下形式

# coding=utf-8

list1 = {
    n
    for n in range(10)
    if n % 2 == 1}

print('10以内的奇数有：', list1)


10以内的奇数有： {1, 3, 5, 7, 9}

Process finished with exit code 0

if-else 的形式

求10以内的奇数，并且把偶数 +1 变成奇数。

# coding=utf-8

list1 = []
for i in range(10):
    if i % 2 == 1:
        list1.append(i)
    else:
        list1.append(i + 1)

print(list1)


# 结果为
[1, 1, 3, 3, 5, 5, 7, 7, 9, 9]

Process finished with exit code 0

列表解析式

列表名 = [表达式 if 条件 else 表达式 for 变量名 in 序列]

为了可读性写成以下形式

# coding=utf-8

list1 = [
    i
    if i % 2 == 1
    else i + 1
    for i in range(10)
]

print(list1)


# 结果为
[1, 1, 3, 3, 5, 5, 7, 7, 9, 9]

Process finished with exit code 0

3、无条件的列表解析式

无条件转换是把所有元素都转换成列表，转换步骤和有条件的列表解析式一样，只是没有 if 判断条件而已。

# coding=utf-8

list1 = []

for i in range(10):
    list1.append(i)

print(list1)


# 结果为
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Process finished with exit code 0

列表解析式

# coding=utf-8

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

print(list1)


# 结果为
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Process finished with exit code 0

4、嵌套循环的列表解析式

5、字典解析式

二、while循环

在Python中还可以定义无限循环，不需要提前定义循环次数，即 while 循环，while 的条件为各种算术表达式，如果条件表达式一直为 True是，则while循环会一直执行，知道程序崩溃或者按下组合键 CTRL+C 来终止程序执行。

# coding=utf-8

num = 1
while num <= 5:
    print(num)
    num += 1


# 结果为
1
2
3
4
5

Process finished with exit code 0

1、用户输入

在Python中可以使用 input() 函数接收用户键盘输入，当 input() 函数执行时，程序会暂时阻塞，接受完用户输入后程序会继续执行。

# coding=utf-8

sum = 0.0
count = 0
more_number = 'y'
num_list = []

while 'y' in more_number:
    number = int(input('请输入一个数字：'))
    sum += number
    count += 1
    num_list.append(number)
    more_number = input('您还需要继续输入数字么？(y or n)')

print('您输入的数字为：', num_list)
print('和：', sum)
print('平均值：', sum / count)


# 结果为
请输入一个数字：8
您还需要继续输入数字么？(y or n)y
请输入一个数字：10
您还需要继续输入数字么？(y or n)n
您输入的数字为： [8, 10]
和： 18.0
平均值： 9.0

Process finished with exit code 0

2、break与continue语句

break 与 continue 语句可以在循环结构中使用，如 for 循环、while 循环。

break 语句是立即退出循环，不再运行循环中的余下的任何代码，也不管条件判断的结果，break 语句常用来控制程序的执行流。
continue 语句是跳过本次循环，接着进行条件判断。条件为 True 则继续执行，否则直接退出。

# coding=utf-8

str1 = 'hello python'

for s in str1:
    if 'l' == s:
        continue
    elif 't' == s:
        break
    else:
        print(s)


# 结果为
h
e
o

p
y

Process
finished
with exit code 0

3、使用while循环操作列表和字典

使用while循环操作列表

# coding=utf-8

books = ['Python', '高等数学', 'Java', 'C++']
it = []
while books:
    temp = books.pop()
    if '高等数学' == temp:
        print(temp, '不是IT类书籍')
    else:
        print(temp, '是IT类书籍')
        it.append(temp)

print('\n以下是IT类书籍')
for i in it:
    print('\t', i.title())


# 结果为
C++ 是IT类书籍
Java 是IT类书籍
高等数学 不是IT类书籍
Python 是IT类书籍

以下是IT类书籍
	 C++
	 Java
	 Python

Process finished with exit code 0

使用while循环操作字典

# coding=utf-8

mail_list = {}

while 1:
    name = input('请输入姓名：')
    phone_number = input('请输入电话号码：')
    mail_list[name] = phone_number
    more = input('还需要继续添加吗？(y or n)')
    if 'y' != more:
        break
print('\n通讯录')
for k, v in mail_list.items():
    print(f'姓名：{k}\t号码：{v}')


# 结果为
请输入姓名：张三
请输入电话号码：13488888888
还需要继续添加吗？(y or n)y
请输入姓名：李四
请输入电话号码：18912341234
还需要继续添加吗？(y or n)n

通讯录
姓名：张三	号码：13488888888
姓名：李四	号码：18912341234

Process finished with exit code 0