1.4 人机交互¶

一般来说，一个程序可以没有输入，但至少要有一个输出。
内置函数 __input()__ 接收用户__输入__的字符串
内置函数 __print()__ 将程序的处理结果以字符的形式__展示__给用户

1.4.1 输出函数¶

Python主要有两种输出值的方式： __表达式语句__
__print() 函数__

表达式语句主要用于__交互模式__，在交互模式下输入变量或表达式将可以直接输出变量或表达式的值。
例如在交互模式下输入5 + 6 / 2 - 3 * 2并回车，解释器直接输出表达式计算结果。

5 + 6 / 2 - 3 * 2   # 交互模式下可以直接输出表达式结果，不用加print()

2.0

练一练1

# 模仿上面的表达式，自己写一个表达式，然后点击“运行”查看输出结果

表达式语句直接输出仅用于极少计算或测试时，更普遍的方式是用 __print()函数__ 进行输出。
print()函数的语法为：

print(*objects, sep=' ', end='\n')

print()函数主要用于将__单个对象__ 或__多个对象__ 输出到屏幕上。

print('Hello world!',end=" ")    # 单个对象原样输出，输出后自动换行
print("hello")

Hello world! hello

练一练2

# 模仿上面的程序，试着编程输出“Hi,Python!”

练一练3

# 模仿上面程序，试着编程输出：'Hello ***!' ,其中*号替换成你自己的名字
# 例如输出：你好 李明!

print(2022)    # 单个对象原样输出，输出后自动换行

area = 3.1415926 * 5 ** 2  # 表达式计算结果命名为变量 area
print(area)                # 输出变量的值

78.539815

print(3.1415926 * 5 ** 2)  # 圆的面积 78.539815

输出多个对象时，用半角逗号“,”将要输出的对象隔开作为print()函数的参数。输出时默认用空格对输出值进行分隔。

print(2022, 6, 16)    # 输出多个对象时，对象之间用半角逗号分隔
# 输出 2022 6 16，输出的多个对象之间默认用空格分隔
print("2022","6","16")

2022 6 16
2022 6 16

输出__多个对象__时，可以用 __sep参数__ 指定分隔符号，sep 参数的值必须是 __字符串__。

print(2022, 6, 16, sep='/')  # sep参数值为字符串'/'，用于分隔输出的多个对象
# 输出 2022/6/16
print('2022',"6","16",sep='/')

2022/6/16
2022/6/16

print(2022, 6, 16, sep='-')  # sep参数值为字符串'-'，用于分隔输出的多个对象
# 输出 2022-6-16

print(23, 59, 30, sep=':')   # sep参数值为字符串':'，用于分隔输出的多个对象
# 输出 23:59:30

练一练4

# 模仿上面例子，分别用“-”和“/”为分隔符,输出当前的日期
# 例如：2022年08月01日时年月日分别为2022 08 01，此时输出：
# 2022-08-01 
# 2022/08/01

print()函数中 __end 参数__ 默认值是 __换行符('\n')__ ，此参数值缺省时，执行print() 函数后会自动输出一个 __换行__ 。

下面三条输出语句会在三行中输出：

print('欢迎您')
print('学习python')
print('程序设计')
# 欢迎您
# 学习python
# 程序设计

欢迎您
学习python
程序设计

若print()函数中增加end参数，会用end的值做结束符，下面例子中end的值为空字符串，输出前面的字符串后再输出一个空字符串，不换行，三条语句的内容在同一行中输出。

print('欢迎您', end='')
print('学习python', end='')
print('程序设计')
# 欢迎您学习python程序设计

欢迎您学习python程序设计

类似的应用还有：

print('2024', end='/')
print('02', end='/')
print('29')
# 2024/02/29

print('23', end=':')
print('08', end=':')
print('35')
# 23:08:35

end参数也经常用于在同一行输出循环中的结果：下面例子会循环4次，依次输出range(4)产生的数列中的数字，每次输出都换行。

for i in range(4):     # 重复执行缩进区域的语句4次  
    print(i)           # end默认参数值是'\n'，默认输出后换行
    print("gf")
print("1234")

0
gf
1
gf
2
gf
3
gf
1234

下面例子会循环4次，每次输出字符串'Hello world!'，每次输出都换行。

for i in range(4):         # 重复执行缩进区域的语句4次  
    print('Hello world!')  # end默认参数值是'\n'，默认输出后换行

Hello world!
Hello world!
Hello world!
Hello world!

如果希望多个print() 语句的输出在 __换行符('\n')__ 同一行中，可以给print() 函数里的end 参数一个 __字符串__类型的值。
例如设置 __end=' '__ 或 __end=','__ ，使每条print() 语句的输出后用 __空格__ 或 __逗号__ 代替默认的 __换行符('\n')__ ，实现多条print() 语句输出在 __同一行__ 内的效果。

for i in range(4):     # 重复执行缩进区域的语句4次  
    print(i, end=' ')  # end参数值不是'\n'时，输出后不换行，单引号间有一个空格，输出的字符间有空格分隔
    # 输出的每个数后有一个空格：0 1 2 3

for i in range(4):                  # 重复执行缩进区域的语句4次  
    print('Hello world!', end=' ')  # end默认参数值是'\n'，默认输出后换行

设置end=''（空字符串），实现多个对象连续输出的效果（相当于拼接到一起）。

for i in range(4):     # 重复执行缩进区域的语句4次  
    print(i, end='')  # end参数值不是'\n'时，输出后不换行，单引号间没有空格，输出的字符连在一起
    # 输出的每个数后没有空格，连续输出：0123

注意， __中文逗号与英文逗号__ 是不同的，英文符号是半角，中文符号是全角表示，注意观察下面两组代码的输出：

for i in range(4):     # 重复执行缩进区域的语句4次  
    print(i, end=',')  # 输出的结尾是一个英文逗号，逗号占位较小
    # 输出：0,1,2,3,

for i in range(4):      # 重复执行缩进区域的语句4次  
    print(i, end='，')  # 输出的结尾是一个中文逗号，逗号占位更宽
    # 输出：0，1，2，3，

练一练5

# 模仿上面例子，在同一行内输出从0到50的整数，每个整数后有一个空格
# range()括号中的数字控制输出数字的范围
# 正确结果：0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

练一练6

# 模仿上面例子，在同一行内输出从0到49的整数，每个整数后有一个半角逗号（英文逗号）
# 正确结果：0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,

1.4.2 输出格式¶

print() 函数只能输出用特定分隔符分隔的值，当需要更多的控制输出格式时，可以使用以下方法。

（1）格式化字符串字面值¶

__格式化字符串字面值__，又称为f-string，这是Python 3.6以后提供的一个新方法，用“f”或“F”做前缀格式化字符串输出。

使用时，在字符串开始的引号前加上 __“f”或“F”__，字符串中可放置 __大括号“{}”__作为 __替换域__，输出时，字符串将被原样输出， __替换域__中的变量或表达式在程序运行时会被变量和表达式的值代替。

a = 5
b = 3
print(f"{a} - {b} = {a - b}")   # 大括号中可以放变量名或表达式，输出： 5 - 3 = 2
print(f'{a} - {b} = {a - b}')   # 大括号中可以放变量名或表达式，输出： 5 - 3 = 2

5 - 3 = 2
5 - 3 = 2

练一练7

# 模仿上面例子，按“加+”“减-”“乘*”“除/”的顺序，在4行中输出a与b四则运算的结果，空白处添加你的代码
# 注意输出中的空格应该在字符串中，大括号中只放变量名或表达式
a = 4
b = 8

print(f'{a}+{b}={a}')


# 正确结果：
# 4 + 8 = 12
# 4 - 8 = -4
# 4 * 8 = 32
# 4 / 8 = 0.5

4+8=4

f 后面的字符串中可以包含各种文字和符号，下面例子中字符串中包含冒号和豆号。

user_name = 'Tom'
gender = 'male'
age = '20'
print(f'姓名：{user_name}，性别：{gender}，年龄：{age}')
# 输出：姓名：Tom，性别：male，年龄：20

姓名：Tom，性别：male，年龄：20

大括号中的变量值可以为任意类型，当大括号中的值为 __字符串__时，需使用与f 后面引号不同的 __引号__，f 后面是单引号做定界符时，字符串用双引号，f 后面是双引号做定界符时，字符串用单引号。

说明：python 3.12.0以后的版本中，大括号中的字符串可以使用与外面相同的引号。
例如：
3.12以前的版本的写法：
f"""{f'''{f'{f"{1+1}"}'}'''}"""
3.12.0以后可以简单写作：
f"{f"{f"{f"{f"{f"{1+1}"}"}"}"}"}"

print(f'姓名：{"Tom"}，性别：{"male"}，年龄：{40}')
# 姓名：Tom，性别：male，年龄：40

print(f"姓名：{'Tom'}，性别：{'male'}，年龄：{40}")
# 姓名：Tom，性别：male，年龄：40

姓名：Tom，性别：male，年龄：40
姓名：Tom，性别：male，年龄：40

练一练8

# 请模仿上面例子，编程输出：我的名字是李明，来自湖北省武汉市。
user_name = '李明'
city = '武汉'
province = '湖北'

# 将练一练8中的李明、武汉和湖北分别替换为你自己的姓名、入学前的省市，再执行程序查看输出。

用 ':m' 在 ':'后传递一个整数m可以让该字段最小字符宽度为m个，可用于设置右对齐。

下面例子中，当输出少于3个字符时至少占3个字符宽度，可用于保证输出右对齐。

print(f'{1} *  {9} = {1 * 9:3}')   # 1 *  9 =   9
print(f'{9} *  {9} = {9 * 9:3}')   # 9 *  9 =  81
print(f'{9} * {19} = {9 * 19:3}')  # 9 * 19 = 171

1 *  9 =   9
9 *  9 =  81
9 * 19 = 171

当输出 __多于m个字符__时按全部字符 __实际字符宽度__输出。

print(f'{1} *  {9} = {1 * 9:4}')    # 1 *  9 =   9
print(f'{9} * {19} = {9 * 999:4}')  # 9 * 19 = 8991

1 *  9 =    9
9 * 19 = 8991

用__':.nf'__在__冒号 ':'__ 后传递一个整数 n 和字母 f 可以__精确控制__浮点数输出时的__小数位数为n__。

pi = 3.141592653589793

print(f'小学生用圆周率时精确到小数点后3位，结果为{pi:.3f}')
# 小学生用圆周率时精确到小数点后2位，结果为3.14
print(f'大学生用圆周率时精确到小数点后7位，结果为{pi:.7f}')
# 大学生用圆周率时精确到小数点后7位，结果为3.1415927
print(round(pi,7))

小学生用圆周率时精确到小数点后3位，结果为3.142
大学生用圆周率时精确到小数点后7位，结果为3.1415927
3.1415927

a = 7
b = 3

# 输出默认精度的结果
print(f'{a} / {b} = {a / b}')       # 输出7 / 3 = 2.3333333333333335

# 输出结果保留小数点后2位，冒号后面的点表示小数点，2表示保留2位数字，f表示浮点数
print(f'{a} / {b} = {a / b:.2f}')   # 输出 7 / 3 = 2.33

# :.2%是一个格式说明符。.表示小数点，2表示小数点后的位数，%表示将数值转换为百分比。
print(f'{a} / {b} = {a / b:.2%}')   # 7 / 3 = 233.33%

7 / 3 = 2.3333333333333335
7 / 3 = 2.33
7 / 3 = 233.33%

练一练9

# 模仿上面例子，按“加+”“减-”“乘*”“除/”的顺序，在4行中输出a与b四则运算的结果，结果保留4位小数，空白处添加你的代码

a = 5.3267
b = 7.35364

【拓展】利用f-string方法，还可以构建采色的打印，模板如下：¶

f'\033[效果;前景色;背景色m要打印的文本\033[0m'

'\x1b[效果;前景色;背景色m要打印的文本\x1b[0m'

print(f'\033[031m{"我要用红色输出"}\033[0m')

我要用红色输出

print(f'\033[034m{"我要用蓝色输出"}\033[0m')

我要用蓝色输出

下面说明一下上面的参数如何设置：

参数	参数值
文字效果	0：终端默认，1：高亮，4：下划线，5：闪烁，7：反白显示
前景色	30（黑），31（红），32（绿），33（黄），34（蓝），35（紫），36（青），37（灰）
背景色	40（黑），41（红），42（绿），43（黄），44（蓝），45（紫），46（青），47（灰）

print(f'\033[4;031m{"我要用红色带下划线输出"}\033[0m')

print(f'\033[7;031m{"我要用红色反白输出"}\033[0m')

每次都重新编辑转义字符串、查颜色表是一件很麻烦的事情。Python有一些封装好颜色字符库可以使用。下面代码主要用于打印服务器日志记录，提供高亮黑底状态下的红、黄、绿、白字显示，并且可以选择是否在字符串开头打印时间戳，可用于演示自定义颜色自字符串输出的效果。

import time


# 打印彩色字符
def colormsg(msg: str, color: str = "", timestamp: bool = True):
    str = ""
    if timestamp:
        str += time.strftime('{}-{}-{} {}:{}:{} '.format(*time.localtime(time.time())))
    if color == "red":
        str += "\033[1;31;42m"  # 红字绿背景色
    elif color == "green":
        str += "\033[1;32;40m"  # 绿字黑背景
    elif color == "yellow":
        str += "\033[1;33;47m"  # 黄字灰背景
    else:
        print(str + msg)
        return
    str += msg + "\033[0m"      # 结束标记
    print(str)


# 调用定义的函数实现不同颜色字符串的输出
colormsg("[ERROR]网络连接异常！", "red")
colormsg("[OK]认证成功！", "green")
colormsg("[INFO]远程连接已关闭", "yellow")

（2）str.format() 方法¶

与f-string类似，__<模版字符串>__由一系列的用__大括号“{}”__表示的__替换域__组成，用来控制修改字符串中嵌入值出现的__位置__。调用此方法的“模版字符串”可以包含字符串以及若干个大括号表示的替换域。

format() 括号中的放置与替换域__数量相同__的参数值，运行时默认按替换域出现的顺序__一一对应__填入到前面的替换域中。

a = 5
b = 3
print('{} + {} = {}'.format(a, b, a + b))     # 参数值按出现顺序填入替换域

5 + 3 = 8

如果替换域中标有序号，将__根据序号__到format()括号里查找序号对应的值进行填入。

# 这三条语句输出相同格式信息：
a = 5
b = 3
print('{} * {} = {}'.format(a, b, a * b))     # 参数值按出现顺序填入替换域
print('{2} * {1} = {0}'.format(a * b, b, a))  # 参数序号从0开始编号，依次为：0，1，2
print('{2} * {0} = {1}'.format(b, a * b, a))  # 括号中序号根据参数序号调整

5 * 3 = 15
5 * 3 = 15
5 * 3 = 15

练一练10

# 应用str.format() 方法，按“加+”“减-”“乘*”“除/”的顺序，在4行中输出a与b四则运算的结果，结果保留 2 位小数，空白处添加你的代码
a = 5.3267
b = 7.35364

print('我叫{}，今年{}岁'.format('王伟', 18))                # 我叫王伟，今年18岁

我叫王伟，今年18岁

print('这是{0}，我喜欢喝{1}'.format('咖啡', '茶'))          # 这是茶，我喜欢喝咖啡

这是咖啡，我喜欢喝茶

print('这是{1}，我喜欢喝{1}'.format('咖啡', '茶'))          # 这是茶，我喜欢喝茶

print('这是{0}，我喜欢喝{0}'.format('茶', '咖啡', '红酒'))  # 这是茶，我喜欢喝茶

print('这是{1}，我喜欢喝{0}'.format('茶')) # 错误用法，测试时去掉行首#号
# IndexError: Replacement index 1 out of range for positional args tuple

除此以外，还可以在每个替换域中传入一个变量，在format()方法里给每一个变量赋值，输出时，将值按替换域的顺序进行输出。

print('{b} - {b} = {c}'.format(a=5, b=3, c=5-3))  # 5 - 3 = 2

3 - 3 = 2

使用变量名形式的简单字段名传递关键字参数，关键字参数的位置可以随意调换

print('我叫{user}，今年{age}岁'.format(user='王伟', age=18))
print('我叫{user}，今年{age}岁'.format(age=18, user='王伟'))
# 我叫王伟，今年18

练一练11

# 应用str.format() 方法，输出：这是一辆2022年生产，型号是L90的红旗牌汽车，售价1000万元。
year = 2022
model = 'L90'
brand = '红旗'
price = 1000
# 补充你的代码，得到输出结果

str.format()中也可以在大括号中加冒号和“格式限定符”，在冒号后面加“.mf”控制输出保留小数点后m位数字的浮点数（f代表float）。

print('{} / {} = {}'.format(a, b, a / b))   # 5 / 3 = 1.6666666666666667
print('{} / {} = {:.4f}'.format(a, b, a / b))  # 5 / 3 = 1.6667，.4f保留4位小数浮点数
print(round(3.345,2))          ##保留2 位小数

5 / 3 = 1.6666666666666667
5 / 3 = 1.6667
3.35

（3）字符串拼接的方法¶

用“+”将多个字符串拼接为一个字符串输出。
参与拼接的可以是字符串也可以是字符串变量。
参与拼接的变量为整数等其他数据类型时，需先用str()函数将其转为字符串类型再参与拼接。

user = '王伟'
age = 18  # 18是整数，用str(age)转为字符串 '18'
print(type(age))
print('我叫' + user + '，今年' +str(age)  + '岁')  # 我叫王伟，今年18岁

<class 'int'>
我叫王伟，今年18岁

1.4.3 输入函数¶

input()函数:
作用是从标准输入设备（键盘）获得用户输入的一行数据，不管用户输入的是字符型还是数字型的数据，input()函数都会将其作为一个字符串类型处理。

a = input()        # 输入 5，默认为字符串'5'
b = input()        # 输入 3，默认为字符串'3'
print(f'输入给a的数据的类型是：{type(a)}')     # 输出<class 'str'>，a的类型是字符串 
print(f'a + b 的结果是两个字符串拼接到一起：{a + b}')       # 输出 53，'+' 作用是将两个字符串拼接为一个字符串
print(f'a * int(b)是将字符串{a}重复整数{int(b)}次：{a * int(b)}')    # 输出 555，'*' 作用是将字符串重复整数b次

输入给a的数据的类型是：<class 'str'>
a + b 的结果是两个字符串拼接到一起：53
a * int(b)是将字符串5重复整数3次：555

为了提高程序的用户友好性，input()可以包含一些__提示性的文字__，提示性文字以__双引号或单引号__引起来放于input后的括号内，如：

a = input("请输入一个正整数，表示长方形边长：")        # 输入 5，默认为字符串'5'
b = input('请输入一个正整数，表示长方形边长：')        # 输入 3，默认为字符串'3'
print(f'边长为{a}和{b}的长方形面积为：{int(a) * int(b)}')    # 输出15

边长为1和6的长方形面积为：6

提示性文字及输入：
请输入一个正整数，表示长方形边长：5
请输入一个正整数，表示长方形边长：3
提示性文字及输出：
边长为5和3的长方形面积为：15

当输入数据需要参与数值运算时，可以直接将input()函数做为类型转换函数int()或float()的参数，在输入同时完成数据类型的转换。

a = int(input()) # 输入字符串'3'转为整数 3¶

b = int(input()) # 输入字符串'5转为整数 5 print(a b) # 输出数值计算结果 15 print(f'{a} {b} = {a b}') # 输出： 3 5 = 15 print(f'边长为{a}和{b}的长方形面积为：{a * b}') # 输出边长为3和5的长方形面积为：15

输入：
3
5
输出：
15
3 * 5 = 15
边长为3和5的长方形面积为：15

练一练12

# 空白处补充你的代码

user = input('请输入姓名：')          # 输出“请输入姓名：”等待输入，输入：张华
print('你真的是', user, '?')          # 输出3个对象，空格分隔，你真的是 张华 ?
print('你真的是', user, '?', sep='')  # 输出3个对象，空字符串分隔，你真的是张华?
print('你真的是' + user + '?')        # 字符串拼接，无分隔，你真的是张华?
print(f'你真的是{user}?')             # 格式化字符串输出，你真的是张华?

运行时屏幕上会看到“请输入姓名：”的提示，同时程序做好接收用户输入的准备。
注意到第一个print语句输出时，在变量user的值“张华”的前后各输出一个空格，这是由print()函数的参数sep的默认值为空格导致的，可以在输出时设置参数“sep=''”来消除空格，也可以用字符串拼接或“f”前缀格式化字符串的方法消除多余的空格。

练一练13

运行以下代码，查看结果：

def print_hi(user_name):
    print(f'=    欢迎{user_name}    =')
    
    
def print_line():
    print("==================")
    
    
def print_blank():
    print("=                =")
    
    
print_line()
print_blank()
print_hi('小明')

欢迎以上代码的代行结果，修改以下代码，得到下面示例的输出：

def print_hi(user_name):
    print(f'=    欢迎{user_name}    =')
    
    
def print_line():
    print("==================")
    
    
def print_blank():
    print("=                =")
    
    
# 补充你的代码

需要注意的是，用自动评测平台测试程序时，为简化问题，**一般不在input()中添加提示性文字**。

例如：
输入两个整数，计算两个数的和：

a = int(input())  # int()将输入的整数字符串转为整数类型，数值类型才能进行数学运算
b = int(input())
print(a + b)

输入：  
6  
9  
输出：  
15

例如：
输入表示矩形长和宽的两个整数，计算矩形面积：

width = int(input())  # int()将输入的整数字符串转为整数类型，数值类型才能进行数学运算
length = int(input())
area = width * length
print(area)

输入：
4
5
输出：
20

1.4 人机交互.ipynb @master — view markup · raw · history · blame