Python学习7：输入和输出

在 Python 中，可以使用 input() 函数从标准输入读取用户输入的数据，并使用 print() 函数将数据输出到标准输出。下面是一些常用的输入输出方法：

1、使用 input() 函数读取用户输入

input() 函数会从标准输入读取用户输入的数据，并返回一个字符串类型的值。例如：

1
2
name = input("What's your name? ")
print("Hello, " + name + "!")

在上面的例子中，使用 input() 函数读取用户输入的姓名，并使用 print() 函数输出问候语。

2、使用 print() 函数输出字符串

print() 函数可以将字符串输出到标准输出。可以使用加号（+）将多个字符串连接起来，并使用逗号（,）将多个参数输出到同一行。例如：

1
2
print("Hello, World!")
print("The answer is", 42)

在上面的例子中，使用 print() 函数输出了两个字符串，第二个字符串包含了一个数字。

3、使用格式化字符串输出数据

可以使用格式化字符串将变量的值插入到字符串中。可以使用花括号（{}）表示变量的位置，并使用 format() 方法将变量的值插入到花括号中。例如：

1
2
3
name = "Alice"
age = 25
print("My name is {} and I'm {} years old.".format(name, age))

在上面的例子中，使用 format() 方法将变量 name 和 age 的值插入到字符串中。

4、使用 f-字符串输出数据

在 Python 3.6 及以后的版本中，可以使用 f-字符串来格式化字符串。f-字符串是一种特殊的字符串，以字母 f 或 F 开头，并以花括号表示变量的位置。在花括号中可以直接使用变量名，也可以使用表达式计算变量的值。例如：

1
2
3
name = "Bob"
age = 32
print(f"My name is {name.upper()} and I'm {age * 2} years old.")

在上面的例子中，使用 f-字符串将变量 name 的值转换为大写字母，并将变量 age 的值乘以 2。

5、使用文件读写数据

Python 提供了多种方式读写文件，可以使用 open() 函数打开文件，并使用 read()、write() 和 close() 方法读写文件。例如：

livecodeserver

1
2
3
4
5
6
7
8
# 读取文件
with open("input.txt", "r") as f:
    data = f.read()
    print(data)

# 写入文件
with open("output.txt", "w") as f:
    f.write("Hello, World!")

在上面的例子中，使用 with 语句打开文件并读取或写入数据。使用 “r” 参数表示读取文件，使用 “w” 参数表示写入文件。使用 read() 方法读取文件内容，使用 write() 方法写入文件内容。

6、使用标准错误输出错误信息

除了使用 print() 函数输出字符串到标准输出外，还可以使用标准错误将错误信息输出到控制台。可以使用 sys 模块中的 stderr 属性来输出错误信息。例如：

1
2
3
4
5
6
7
8
9
import sys

try:
    x = int(input("Enter a number: "))
    print(10 / x)
except ValueError:
    print("Invalid input.", file=sys.stderr)
except ZeroDivisionError:
    print("Cannot divide by zero.", file=sys.stderr)

在上面的例子中，使用 try-except 语句处理输入错误和除以零错误，并使用 print() 函数将错误信息输出到标准错误。

7、使用格式化字符串的高级特性

除了简单的格式化字符串外，还可以使用格式化字符串的高级特性来格式化输出。例如，可以使用 {name:width} 格式来指定字符串的宽度，使用 {name:.2f} 格式来指定浮点数的小数位数。例如：

1
2
3
4
5
6
name = "Alice"
age = 25
score = 85.1234
print(f"{'Name:':<10}{name:>10}")
print(f"{'Age:':<10}{age:>10}")
print(f"{'Score:':<10}{score:>10.2f}")

在上面的例子中，使用 f-字符串和 {} 格式指定字符串的宽度和对齐方式，并使用 {:.2f} 格式指定浮点数的小数位数。

8、使用 pprint 模块美化输出

pprint 模块可以美化 Python 数据结构的输出，以便更好地查看和调试数据。可以使用 pprint 模块中的 pprint() 函数将数据结构输出为美化的格式。例如：

1
2
3
4
import pprint

data = {"name": "Alice", "age": 25, "scores": [80, 85, 90]}
pprint.pprint(data)

在上面的例子中，使用 pprint.pprint() 函数将数据结构 data 输出为美化的格式。

9、使用 logging 模块输出日志信息

logging 模块可以用于输出日志信息，以便更好地理解程序的运行状态和错误信息。可以使用 logging 模块中的 getLogger() 方法创建 Logger 对象，并使用该对象的不同方法输出不同级别的日志信息。例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
import logging

logging.basicConfig(level=logging.DEBUG, format='%(asctime)s %(levelname)s %(message)s')
logger = logging.getLogger(__name__)

def divide(x, y):
    logger.info(f"Dividing {x} by {y}")
    try:
        result = x / y
    except ZeroDivisionError:
        logger.error("Division by zero!")
        return None
    else:
        logger.info(f"Result is {result}")
        return result

在上面的例子中，使用 logging.basicConfig() 方法配置日志级别和格式，使用 getLogger() 方法创建 Logger 对象，并使用 info()、error() 等方法输出不同级别的日志信息。

10、使用 traceback 模块输出异常信息

traceback 模块可以用于输出异常信息，以便更好地定位和解决程序错误。可以使用 traceback 模块中的 print_exc() 函数输出异常信息。例如：

1
2
3
4
5
6
7
import traceback

try:
    x = int(input("Enter a number: "))
    print(10 / x)
except:
    traceback.print_exc()

在上面的例子中，使用 try-except 语句捕获所有异常，并使用 traceback.print_exc() 函数输出异常信息。

11、使用 cProfile 模块分析程序性能

cProfile 模块可以用于分析程序的性能，以便更好地优化程序运行效率。可以使用 cProfile 模块中的 run() 方法分析程序性能。例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
import cProfile

# 定义程序
def func():
    for i in range(10000):
        for j in range(10000):
            k = i * j

# 分析程序性能
cProfile.run('func()')

在上面的例子中，定义一个程序 func() 进行计算，使用 cProfile.run() 方法分析程序性能。

12、使用 argparse 模块解析命令行参数

argparse 模块可以用于解析命令行参数，以便更好地控制程序的行为和输入输出。可以使用 argparse 模块中的 ArgumentParser 类创建解析器对象，并使用该对象的 add_argument() 方法添加命令行参数。例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
import argparse

parser = argparse.ArgumentParser(description='Process some integers.')
parser.add_argument('integers', metavar='N', type=int, nargs='+',
                    help='an integer for the accumulator')
parser.add_argument('--sum', dest='accumulate', action='store_const',
                    const=sum, default=max,
                    help='sum the integers (default: find the max)')

args = parser.parse_args()
print(args.accumulate(args.integers))

在上面的例子中，使用 ArgumentParser 类创建解析器对象，使用 add_argument() 方法添加命令行参数，使用 parse_args() 方法解析命令行参数，并使用 argparse.Namespace 对象访问解析结果。

13、使用 pprint 模块输出对象信息

pprint 模块可以用于输出 Python 对象的信息，以便更好地查看和调试对象。可以使用 pprint 模块中的 pprint() 函数将对象输出为美化的格式。例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
import pprint

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __repr__(self):
        return f"Person(name='{self.name}', age={self.age})"

person = Person("Alice", 25)
pprint.pprint(person)

在上面的例子中，使用 pprint.pprint() 函数将对象 person 输出为美化的格式，使用 repr() 方法定义对象的表示形式。

14、使用 csv 模块读写 CSV 文件

csv 模块可以用于读写 CSV 文件，以便更好地处理表格数据。可以使用 csv 模块中的 reader() 和 writer() 函数读写 CSV 文件。例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
import csv

# 读取 CSV 文件
with open("data.csv", "r") as f:
    reader = csv.reader(f)
    for row in reader:
        print(row)

# 写入 CSV 文件
with open("data.csv", "w", newline="") as f:
    writer = csv.writer(f)
    writer.writerow(["Name", "Age", "Score"])
    writer.writerow(["Alice", 25, 85])
    writer.writerow(["Bob", 32, 90])

在上面的例子中，使用 csv.reader() 函数读取 CSV 文件，使用 csv.writer() 函数写入 CSV 文件，并使用 newline="" 参数指定行结束符。

15、使用 json 模块读写 JSON 数据

json 模块可以用于读写 JSON 数据，以便更好地处理数据交换和存储。可以使用 json 模块中的 loads() 和 dumps() 函数读写 JSON 数据。例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
import json

# 读取 JSON 数据
data = '{"name": "Alice", "age": 25, "scores": [80, 85, 90]}'
json_data = json.loads(data)
print(json_data)

# 写入 JSON 数据
data = {"name": "Bob", "age": 32, "scores": [90, 95, 100]}
json_data = json.dumps(data)
print(json_data)

在上面的例子中，使用 json.loads() 函数读取 JSON 数据，使用 json.dumps() 函数写入 JSON 数据。

16、使用 xml.etree.ElementTree 模块读写 XML 数据

xml.etree.ElementTree 模块可以用于读写 XML 数据，以便更好地处理数据交换和存储。可以使用 xml.etree.ElementTree 模块中的 ElementTree 类和 Element 类读写 XML 数据。例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
import xml.etree.ElementTree as ET

# 读取 XML 数据
tree = ET.parse("data.xml")
root = tree.getroot()
for child in root:
    print(child.tag, child.attrib)

# 写入 XML 数据
root = ET.Element("data")
child1 = ET.SubElement(root, "name")
child1.text = "Alice"
child2 = ET.SubElement(root, "age")
child2.text = "25"
tree = ET.ElementTree(root)
tree.write("data.xml")

在上面的例子中，使用 ET.parse() 方法读取 XML 文件，使用 Element 对象和 SubElement() 方法创建 XML 元素，使用 ElementTree 对象和 write() 方法写入 XML 文件。

17、使用 sqlite3 模块读写 SQLite 数据库

sqlite3 模块可以用于读写 SQLite 数据库，以便更好地持久化数据。可以使用 sqlite3 模块中的 connect() 和 cursor() 方法连接数据库和执行 SQL 语句。例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import sqlite3

# 连接数据库
conn = sqlite3.connect("data.db")

# 创建表格
c = conn.cursor()
c.execute('''CREATE TABLE IF NOT EXISTS students
             (id INTEGER PRIMARY KEY, name TEXT, age INTEGER, score REAL)''')

# 插入数据
c.execute("INSERT INTO students (name, age, score) VALUES (?, ?, ?)", ("Alice", 25, 85))
c.execute("INSERT INTO students (name, age, score) VALUES (?, ?, ?)", ("Bob", 32, 90))

# 查询数据
c.execute("SELECT * FROM students")
rows = c.fetchall()
for row in rows:
    print(row)

# 关闭数据库
conn.commit()
conn.close()

在上面的例子中，使用 sqlite3.connect() 方法连接数据库，使用 cursor() 方法执行 SQL 语句，使用 fetchall() 方法获取查询结果，使用 commit() 方法提交事务并关闭数据库。

18、使用 Pillow 模块读写图片文件

Pillow 模块可以用于读写图片文件，以便更好地处理图像数据。可以使用 Pillow 模块中的 Image 类读写图片文件。例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
from PIL import Image

# 读取图片文件
im = Image.open("image.jpg")
print(im.format, im.size, im.mode)

# 显示图片
im.show()

# 保存图片文件
im.save("image.png")

在上面的例子中，使用 Image.open() 方法读取图片文件，使用 format、size 和 mode 属性获取图片信息，使用 show() 方法显示图片，使用 save() 方法保存图片文件。

19、使用 matplotlib 模块绘制图表

matplotlib 模块可以用于绘制各种类型的图表，以便更好地展示数据分布和趋势。可以使用 matplotlib 模块中的 pyplot 模块绘制图表。例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
import matplotlib.pyplot as plt

# 绘制折线图
x = [1, 2, 3, 4, 5]
y = [1, 4, 9, 16, 25]
plt.plot(x, y)
plt.xlabel("X Label")
plt.ylabel("Y Label")
plt.title("Line Chart")
plt.show()

# 绘制柱状图
x = ["Apple", "Banana", "Orange"]
y = [50, 30, 70]
plt.bar(x, y)
plt.xlabel("Fruit")
plt.ylabel("Quantity")
plt.title("Bar Chart")
plt.show()

在上面的例子中，使用 plt.plot() 方法绘制折线图，使用 plt.bar() 方法绘制柱状图，使用 xlabel、ylabel 和 title 方法设置图表标签，使用 show() 方法显示图表。

20、使用 Pygame 模块绘制游戏界面

Pygame 模块可以用于绘制游戏界面，以便更好地实现游戏功能。可以使用 Pygame 模块中的各种类和方法绘制游戏界面和处理游戏事件。例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import pygame

# 初始化 Pygame
pygame.init()

# 创建游戏窗口
screen = pygame.display.set_mode((400, 300))
pygame.display.set_caption("My Game")

# 创建游戏循环
running = True
while running:
    # 处理游戏事件
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    # 绘制游戏界面
    screen.fill((255, 255, 255))
    pygame.draw.circle(screen, (255, 0, 0), (200, 150), 50)
    pygame.display.update()

# 退出 Pygame
pygame.quit()

在上面的例子中，使用 pygame.init() 初始化 Pygame，使用 pygame.display.set_mode() 创建游戏窗口，使用 pygame.event.get() 处理游戏事件，使用 pygame.draw.circle() 绘制游戏界面，使用 pygame.display.update() 更新游戏界面，使用 pygame.quit() 退出 Pygame。