import tkinter as tk

root = tk.Tk()
root.title("我的第一个Tkinter窗口")
root.mainloop()

label = tk.Label(root, text="欢迎使用Tkinter")
label.pack()

def on_button_click():
    label.config(text="按钮被点击了！")

button = tk.Button(root, text="点击我", command=on_button_click)
button.pack()

entry = tk.Entry(root)
entry.pack()

def on_submit():
    text = entry.get()
    label.config(text="您输入的内容是：" + text)

submit_button = tk.Button(root, text="提交", command=on_submit)
submit_button.pack()

menu_bar = tk.Menu(root)

file_menu = tk.Menu(menu_bar, tearoff=0)
file_menu.add_command(label="打开")
file_menu.add_command(label="保存")
file_menu.add_separator()
file_menu.add_command(label="退出", command=root.quit)

menu_bar.add_cascade(label="文件", menu=file_menu)
root.config(menu=menu_bar)

from PIL import Image

# 打开图像
image = Image.open("example.jpg")

# 显示图像
image.show()

# 调整图像尺寸
new_size = (800, 600)
resized_image = image.resize(new_size)
resized_image.show()

# 裁剪图像
box = (100, 100, 500, 400)  # 左上角和右下角坐标
cropped_image = image.crop(box)
cropped_image.show()

# 旋转图像
rotated_image = image.rotate(45)  # 逆时针旋转 45 度
rotated_image.show()

from PIL import ImageFilter

# 添加模糊滤镜
blurred_image = image.filter(ImageFilter.BLUR)
blurred_image.show()

# 保存图像
resized_image.save("resized_image.jpg")

# 合并图像
image1 = Image.open("image1.jpg")
image2 = Image.open("image2.jpg")

merged_image = Image.blend(image1, image2, alpha=0.5)
merged_image.show()

# 图层叠加
image1 = Image.open("image1.jpg")
image2 = Image.open("image2.jpg")

composite_image = Image.alpha_composite(image1.convert("RGBA"), image2.convert("RGBA"))
composite_image.show()

from PIL import ImageDraw, ImageFont

# 打开图像
image = Image.open("example.jpg")

# 添加文本
draw = ImageDraw.Draw(image)
font = ImageFont.truetype("arial.ttf", 36)
text = "Hello, Pillow!"
draw.text((50, 50), text, fill=(255, 0, 0), font=font)
image.show()

# 绘制矩形
draw.rectangle([100, 100, 300, 300], outline="red")

# 绘制圆
draw.ellipse([400, 100, 600, 300], outline="green")

# 绘制线段
draw.line([(700, 100), (900, 300)], fill="blue", width=5)

image.show()

widget.pack(options)

import tkinter as tk

root = tk.Tk()
root.title("pack() 函数示例")

# 创建控件
label1 = tk.Label(root, text="Label 1", bg="red")
label2 = tk.Label(root, text="Label 2", bg="green")
label3 = tk.Label(root, text="Label 3", bg="blue")

# 使用 pack() 布局
label1.pack(side="top", fill="both", expand=True, padx=10, pady=10)
label2.pack(side="left", fill="both", padx=10, pady=10)
label3.pack(side="right", fill="both", padx=10, pady=10)

root.mainloop()

with open("example.txt", "a", encoding="utf-8") as file:
    file.write("这是追加的一行内容。\n")

with open("example.txt", "a+", encoding="utf-8") as file:
    file.write("追加的内容，带换行符。\n")
    file.seek(0)  # 将文件指针移到开头
    print(file.read())  # 读取整个文件内容

with open("example.bin", "ab") as file:
    file.write(b"\x00\x01\x02\x03")  # 追加字节数据

pair = (1, "apple")  # 一个整数和字符串的配对
print(pair[0])  # 输出 1
print(pair[1])  # 输出 "apple"

pair = [1, "banana"]
pair[1] = "orange"  # 修改第二个元素
print(pair)  # 输出 [1, 'orange']

pair_dict = {"key": "value"}
print(pair_dict["key"])  # 输出 "value"

from collections import namedtuple

Pair = namedtuple("Pair", ["first", "second"])
pair = Pair(1, "grape")

print(pair.first)  # 输出 1
print(pair.second)  # 输出 "grape"

from dataclasses import dataclass

@dataclass
class Pair:
    first: int
    second: str

pair = Pair(1, "cherry")
print(pair.first)   # 输出 1
print(pair.second)  # 输出 "cherry"

data = {"banana": 3, "apple": 5, "cherry": 2}

sorted_dict = dict(sorted(data.items()))  # 默认按键升序
print(sorted_dict)

{'apple': 5, 'banana': 3, 'cherry': 2}

sorted_dict = dict(sorted(data.items(), reverse=True))
print(sorted_dict)

{'cherry': 2, 'banana': 3, 'apple': 5}

data = {"Banana": 3, "apple": 5, "Cherry": 2}

sorted_dict = dict(sorted(data.items(), key=lambda x: x[0].lower()))
print(sorted_dict)

{'apple': 5, 'Banana': 3, 'Cherry': 2}

sorted_dict = dict(sorted(data.items(), key=lambda x: len(x[0])))
print(sorted_dict)

from collections import OrderedDict

ordered_dict = OrderedDict(sorted(data.items()))
print(ordered_dict)

string = "Hello, world!"
substring = "python"

if substring not in string:
    print("子字符串未找到")
else:
    print("子字符串已找到")

子字符串未找到

string = "Hello, world!"
substring = "python"

if string.find(substring) == -1:
    print("子字符串未找到")
else:
    print("子字符串已找到")

子字符串未找到

string = "Hello, world!"
substring = "python"

try:
    string.index(substring)
    print("子字符串已找到")
except ValueError:
    print("子字符串未找到")

子字符串未找到

import re

string = "Hello, world!"
substring = "python"

if not re.search(substring, string):
    print("子字符串未找到")
else:
    print("子字符串已找到")

子字符串未找到

import webbrowser

# 指定 Microsoft Edge 的路径（Windows 系统默认路径）
edge_path = r"C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe"

# 注册 Microsoft Edge
webbrowser.register('edge', None, webbrowser.BackgroundBrowser(edge_path))

# 使用 Edge 打开指定网址
webbrowser.get('edge').open('https://www.example.com')

import subprocess

# Microsoft Edge 的路径（Windows 系统默认路径）
edge_path = r"C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe"

# 打开指定网址
url = "https://www.example.com"
subprocess.run([edge_path, url])

import os

# 打开指定网址
url = "https://www.example.com"
os.system(f"start microsoft-edge:{url}")

# 使用逗号作为分隔符
text = "apple,banana,cherry"
result = text.split(",")

print(result)  # 输出: ['apple', 'banana', 'cherry']

# 按空格分割
text = "Hello World Python"
result = text.split(" ")

print(result)  # 输出: ['Hello', 'World', 'Python']

# 限制分割次数
text = "apple,banana,cherry,dates"
result = text.split(",", maxsplit=2)

print(result)  # 输出: ['apple', 'banana', 'cherry,dates']

import re

# 多种分隔符
text = "apple;banana|cherry,dates"
result = re.split(r"[;|,]", text)

print(result)  # 输出: ['apple', 'banana', 'cherry', 'dates']

text = "apple,,banana,,cherry"
result = [item for item in text.split(",") if item]

print(result)  # 输出: ['apple', 'banana', 'cherry']

# 按换行符分割
text = "line1\nline2\nline3"
result = text.splitlines()

print(result)  # 输出: ['line1', 'line2', 'line3']

# 读取整个文件内容
with open("example.txt", "r") as file:
    data = file.read()

print("File content:")
print(data)

# 使用 readline() 逐行读取
with open("example.txt", "r") as file:
    line = file.readline()
    while line:
        print(line.strip())  # strip() 去除换行符
        line = file.readline()

# 读取所有行并逐行处理
with open("example.txt", "r") as file:
    lines = file.readlines()

for line in lines:
    print(line.strip())  # strip() 去除换行符

# 迭代文件对象逐行读取
with open("example.txt", "r") as file:
    for line in file:
        print(line.strip())

try:
    with open("example.txt", "r") as file:
        for line in file:
            print(line.strip())
except FileNotFoundError:
    print("The file does not exist.")
except IOError as e:
    print(f"An I/O error occurred: {e}")

import sys

# 输出所有命令行参数
print("Arguments:", sys.argv)

# 获取特定参数
if len(sys.argv) > 1:
    print("First argument:", sys.argv[1])

import argparse

# 创建解析器
parser = argparse.ArgumentParser(description="A sample script.")

# 添加参数
parser.add_argument("name", help="Your name")  # 位置参数
parser.add_argument("-a", "--age", type=int, help="Your age")  # 可选参数
parser.add_argument("-v", "--verbose", action="store_true", help="Increase output verbosity")  # 开关参数

# 解析参数
args = parser.parse_args()

# 使用参数
print(f"Hello, {args.name}!")
if args.age:
    print(f"You are {args.age} years old.")
if args.verbose:
    print("Verbose mode is on.")

from optparse import OptionParser

# 创建解析器
parser = OptionParser()

# 添加参数
parser.add_option("-n", "--name", dest="name", help="Your name")
parser.add_option("-a", "--age", dest="age", type="int", help="Your age")

# 解析参数
(options, args) = parser.parse_args()

# 使用参数
if options.name:
    print(f"Hello, {options.name}!")
if options.age:
    print(f"You are {options.age} years old.")

import os

# 执行命令
os.system("dir")  # 在当前目录下列出文件

import subprocess

# 执行命令
subprocess.run("dir", shell=True)

import subprocess

# 获取命令结果
result = subprocess.run("dir", shell=True, capture_output=True, text=True)

# 打印输出
print(result.stdout)  # 标准输出
print(result.stderr)  # 错误输出（如果有）

import subprocess

# 通过列表方式传递参数（推荐）
subprocess.run(["ping", "127.0.0.1", "-n", "4"], shell=True)

import os

# 捕获命令输出
output = os.popen("dir").read()
print(output)

import shutil

# 复制文件
shutil.copy("source.txt", "destination.txt")

import shutil

# 复制文件到指定目录
shutil.copy('source_file.txt', 'destination_directory/')

# 复制并重命名
shutil.copy('source_file.txt', 'destination_directory/new_name.txt')

import shutil

# 复制文件及其权限和元数据
shutil.copy2('source_file.txt', 'destination_directory/')

import shutil

# 复制整个目录及其内容
shutil.copytree('source_directory', 'destination_directory')

import shutil

# 移动文件或目录
shutil.move('source_path', 'destination_path')

import shutil

# 删除整个目录及其所有内容
shutil.rmtree('directory_to_delete')

# 字符串
text = "Hello World"

# 将字符串编码为二进制数据
binary_data = text.encode()

# 打印二进制数据
print(binary_data)

import chardet

def detect_encoding(file_path):
    with open(file_path, 'rb') as f:
        raw_data = f.read()
        result = chardet.detect(raw_data)
        encoding = result['encoding']
        confidence = result['confidence']
        return encoding, confidence

file_path = 'your_file_path_here'
encoding, confidence = detect_encoding(file_path)

if confidence > 0.5:  # 设置一个自定义的置信度阈值
    print(f"The encoding of the file is {encoding} with confidence {confidence}.")
else:
    print("The encoding could not be reliably determined.")

def convert_encoding(input_file, output_file, input_encoding='utf-16', output_encoding='utf-8'):
    with open(input_file, 'r', encoding=input_encoding) as f:
        content = f.read()
    with open(output_file, 'w', encoding=output_encoding) as f:
        f.write(content)

input_file = 'input_utf16.txt'
output_file = 'output_utf8.txt'

convert_encoding(input_file, output_file)

x = 10
print(type(x))  # 输出: <class 'int'>

y = 'hello'
print(type(y))  # 输出: <class 'str'>

z = [1, 2, 3]
print(type(z))  # 输出: <class 'list'>

import numpy as np

# 定义轴向量和旋转角度
axis = np.array([1.0, 0.0, 0.0])  # 以 x 轴为例
angle = np.radians(45)  # 旋转角度，这里将角度转换为弧度

# 将轴向量和旋转角度合并成一个只包含三个数的一维向量
combined_vector = np.concatenate([axis * angle])

# 输出组合后的一维向量
print("轴角一维向量:", combined_vector)

import numpy as np

# 定义只包含三个数的轴角表示
axis_angle_vector = np.array([1.5, 0.0, 0.0])

# 取模，得到旋转角度
angle = np.linalg.norm(axis_angle_vector)

# 归一化轴向量
axis_vector = axis_angle_vector / angle

# 输出归一化后的轴向量和旋转角度
print("归一化后的轴向量:", axis_vector)
print("旋转角度:", angle)

file = open('文件名.txt', 'w')

data_to_write = "要写入的数据\n"
file.write(data_to_write)
file.flush()

file.close()

file = open('文件名.txt', 'w')
data_to_write = "要写入的数据\n"
file.write(data_to_write)
file.flush()
file.close()

with open('文件名.txt', 'a') as file:
    # 在这里执行追加操作

with open('文件名.txt', 'a') as file:
    data_to_append = "要追加的数据\n"
    file.write(data_to_append)

with open('文件名.txt', 'a') as file:
    data_to_append = "要追加的数据\n"
    file.write(data_to_append)

my_list = [1, 2, 3]
my_empty_list = []
another_list = list(range(5))

my_list = [10, 20, 30, 40, 50]
print(my_list[0])  # 输出 10
print(my_list[2])  # 输出 30

my_list = [10, 20, 30]
my_list[1] = 25  # 修改第二个元素为 25
print(my_list)  # 输出 [10, 25, 30]

my_list = [1, 2, 3]
my_list.append(4)
print(my_list)  # 输出 [1, 2, 3, 4]

my_list = [1, 2, 3]
del my_list[1]  # 删除第二个元素
print(my_list)  # 输出 [1, 3]

my_list = [1, 2, 3, 4, 5]
sublist = my_list[1:4]  # 获取索引 1 到 3 的元素
print(sublist)  # 输出 [2, 3, 4]

list1 = [1, 2, 3]
list2 = [4, 5, 6]
combined_list = list1 + list2
print(combined_list)  # 输出 [1, 2, 3, 4, 5, 6]

original_list = [1, 2, 3]
copy_list = original_list[:]  # 使用切片创建副本

my_list = [1, 2, 3, 4, 5]
length = len(my_list)
print(length)  # 输出 5

squared_numbers = [x ** 2 for x in range(5)]
print(squared_numbers)  # 输出 [0, 1, 4, 9, 16]

my_list = [3, 1, 2, 5, 4]
my_list.sort()
print(my_list)  # 输出 [1, 2, 3, 4, 5]

my_list = [1, 2, 3]
my_list.reverse()
print(my_list)  # 输出 [3, 2, 1]

import re

text = "1.1 1.2 1.3 Some other text here."

# 定义匹配浮点数的正则表达式模式
pattern = r'\d+\.\d+'

# 使用 re.findall() 函数提取匹配的浮点数
matches = re.findall(pattern, text)

print("Matches:", matches)

import time

# 获取当前系统时间的秒数
current_time_seconds = time.time()

# 打印当前时间的秒数
print("当前系统时间的秒数:", current_time_seconds)

user_input = input("请输入一些文本: ")
print("您输入的文本是:", user_input)

user_input = input("请输入一个整数: ")
try:
    user_input_as_int = int(user_input)
    print("您输入的整数是:", user_input_as_int)
except ValueError:
    print("无法将输入转换为整数。")

import sys
import argparse

def main():
    # 创建ArgumentParser对象
    parser = argparse.ArgumentParser(description='一个命令行工具示例')

    # 添加命令行参数
    parser.add_argument('-f', '--file', required=True, help='指定文件名')
    parser.add_argument('-n', '--number', type=int, default=1, help='指定一个整数（默认为1）')
    parser.add_argument('--flag', action='store_true', help='设置此标志将为True，否则为False')

    # 解析命令行参数
    args = parser.parse_args()

    # 访问解析后的参数
    print('文件名:', args.file)
    print('整数值:', args.number)
    print('标志值:', args.flag)

if __name__ == '__main__':
    main()

import argparse

def main():
    # 创建ArgumentParser对象
    parser = argparse.ArgumentParser(description='一个命令行工具示例')

    # 添加命令行参数
    parser.add_argument('-f', '--file', required=True, help='指定文件名', default='default.txt')
    parser.add_argument('-n', '--number', type=int, help='指定一个整数', default=1)
    parser.add_argument('--flag', action='store_true', help='设置此标志将为True，否则为False', default=False)

    # 解析命令行参数
    args = parser.parse_args()

    # 访问解析后的参数
    print('文件名:', args.file)
    print('整数值:', args.number)
    print('标志值:', args.flag)

    # 输出帮助信息
    parser.print_help()

if __name__ == '__main__':
    main()

import cv2
import numpy as np

# 创建一个空白图像
image = np.zeros((400, 400, 3), dtype=np.uint8)  # 创建一个 400x400 的黑色图像

# 定义矩形的左上角坐标 (x, y) 和宽度 (w)、高度 (h)
x, y, w, h = 100, 100, 200, 150

# 定义矩形的颜色 (BGR 格式)
color = (0, 255, 0)  # 绿色

# 在图像上绘制矩形
cv2.rectangle(image, (x, y), (x + w, y + h), color, thickness=2)

# 显示图像
cv2.imshow('Rectangle', image)

# 等待按下任意键然后关闭窗口
cv2.waitKey(0)
cv2.destroyAllWindows()

import cv2
import numpy as np

# 假设 binary_data 是包含二进制图像数据的变量
# 请替换为您自己的方式来获取二进制数据
binary_data = b'\xff\xd8\xff\xe0\x00\x10\x4a\x46\x49...'

# 将二进制数据转换为 NumPy 数组
image_data = np.frombuffer(binary_data, np.uint8)

# 解码二进制数据为图像对象
image = cv2.imdecode(image_data, cv2.IMREAD_COLOR)

# 保存图像到文件
cv2.imwrite('output_image.jpg', image)

import cv2
import numpy as np

# 假设 binary_data 是包含二进制图像数据的变量
# 请替换为您自己的方式来获取二进制数据
binary_data = b'\xff\xd8\xff\xe0\x00\x10\x4a\x46\x49...'

# 将二进制数据转换为 NumPy 数组
image_data = np.frombuffer(binary_data, np.uint8)

# 解码二进制数据为图像对象
image = cv2.imdecode(image_data, cv2.IMREAD_COLOR)

# 保存图像到文件
cv2.imwrite('output_image.jpg', image)

# 要写入文件的二进制数据
binary_data = b'\x48\x65\x6c\x6c\x6f\x2c\x20\x57\x6f\x72\x6c\x64\x21'

# 打开文件以二进制写入模式（'wb'表示二进制写入，如果文件不存在则创建，如果文件已存在则覆盖）
# 您可以指定文件路径和名称
file_path = "binary_data.bin"

# 使用with语句打开文件，以确保在完成写入后关闭文件
with open(file_path, 'wb') as file:
    # 将二进制数据写入文件
    file.write(binary_data)

# 文件现在已经写入，可以关闭

print(f"二进制数据已写入文件 {file_path}")

import base64

# 要编码的二进制数据
binary_data = b'Hello, World!'

# 进行 Base64 编码
encoded_data = base64.b64encode(binary_data)

# 将编码后的数据转换为字符串
encoded_string = encoded_data.decode('utf-8')

print(encoded_string)

import base64

# Base64 编码后的字符串
encoded_string = 'SGVsbG8sIFdvcmxkIQ=='

# 进行 Base64 解码
decoded_data = base64.b64decode(encoded_string)

# 打印解码后的二进制数据
print(decoded_data)

import base64

# 要编码的二进制数据
binary_data = b'Hello, World!'

# 进行 URL 安全的 Base64 编码
urlsafe_encoded_data = base64.urlsafe_b64encode(binary_data)

# 将编码后的数据转换为字符串
urlsafe_encoded_string = urlsafe_encoded_data.decode('utf-8')

print(urlsafe_encoded_string)

# 进行 URL 安全的 Base64 解码
decoded_data = base64.urlsafe_b64decode(urlsafe_encoded_string)

# 打印解码后的二进制数据
print(decoded_data)

# 要写入的字符串
my_string = "这是要写入文件的字符串。"

# 打开文件以写入模式（'w'表示写入，如果文件不存在则创建，如果文件已存在则覆盖）
# 您可以指定文件路径和名称
file_path = "my_file.txt"

# 使用with语句打开文件，以确保在完成写入后关闭文件
with open(file_path, 'w') as file:
    # 将字符串写入文件
    file.write(my_string)

# 文件现在已经写入，可以关闭

print(f"字符串已写入文件 {file_path}")

# 写入文本数据
with open("example.txt", "w") as file:
    file.write("Hello, World!\n")
    file.write("This is a new line of text.\n")

print("Data has been written to example.txt.")

# 写入多行数据
lines = ["Line 1\n", "Line 2\n", "Line 3\n"]
with open("example.txt", "w") as file:
    file.writelines(lines)

print("Multiple lines have been written to example.txt.")

# 追加数据
with open("example.txt", "a") as file:
    file.write("This line is appended.\n")

print("Data has been appended to example.txt.")

# 写入二进制数据
binary_data = b"Hello, binary world!"
with open("example.bin", "wb") as file:
    file.write(binary_data)

print("Binary data has been written to example.bin.")

try:
    with open("example.txt", "w") as file:
        file.write("Safe write operation.")
except IOError as e:
    print(f"An error occurred: {e}")
else:
    print("Data successfully written.")

import threading

# 定义一个简单的函数，作为新线程的任务
def print_numbers():
    for i in range(1, 6):
        print(f"Number: {i}")

# 创建一个新线程并指定要运行的函数
new_thread = threading.Thread(target=print_numbers)

# 启动新线程
new_thread.start()

# 主线程继续执行其他任务
for letter in 'abcde':
    print(f"Letter: {letter}")

import json

# 打开JSON文件并读取数据
with open('data.json', 'r') as file:
    data = json.load(file)

# 访问JSON中的数据
name = data['name']
age = data['age']
city = data['city']

# 打印解析后的数据
print(f"Name: {name}")
print(f"Age: {age}")
print(f"City: {city}")

import json

# 打开JSON文件并读取数据
with open('data.json', 'r') as file:
    data = json.load(file)

# 遍历JSON数组中的对象
for person in data:
    name = person['name']
    age = person['age']
    city = person['city']
    
    print(f"Name: {name}")
    print(f"Age: {age}")
    print(f"City: {city}")

import requests

# 发送GET请求
response = requests.get('https://www.example.com')

# 检查响应状态码
if response.status_code == 200:
    print('请求成功')
    print(response.text)  # 打印响应内容
else:
    print(f'请求失败，状态码：{response.status_code}')

import requests

# POST请求的数据
data = {'key1': 'value1', 'key2': 'value2'}

# 发送POST请求
response = requests.post('https://www.example.com/api', data=data)

# 检查响应状态码
if response.status_code == 200:
    print('请求成功')
    print(response.text)  # 打印响应内容
else:
    print(f'请求失败，状态码：{response.status_code}')

import requests

# 发送GET请求
response = requests.get('https://api.example.com/data')

# 检查响应状态码
if response.status_code == 200:
    print('请求成功')
    json_data = response.json()  # 将JSON响应解析为Python字典或列表
    print(json_data)
else:
    print(f'请求失败，状态码：{response.status_code}')

import requests
import json

# 定义要发送的JSON数据
data = {
    "name": "John",
    "age": 30,
    "city": "New York"
}

# 将JSON数据转换为字符串
json_data = json.dumps(data)

# 设置请求头，指明发送的数据是JSON格式
headers = {'Content-Type': 'application/json'}

# 发送POST请求
response = requests.post('https://www.example.com/api', data=json_data, headers=headers)

# 检查响应状态码
if response.status_code == 200:
    print('请求成功')
    print(response.text)  # 打印响应内容
else:
    print(f'请求失败，状态码：{response.status_code}')

import json

# 打开JSON文件并读取数据
with open('data.json', 'r') as file:
    data = json.load(file)

# 遍历JSON数组中的对象
for person in data:
    name = person['name']
    age = person['age']
    city = person['city']

    # 检查字段类型
    if isinstance(age, int):
        age_str = str(age)  # 将年龄转换为字符串
        age_type = 'int'
    elif age is None:
        age_str = 'N/A'  # 如果年龄字段为null，则将其标记为N/A
        age_type = 'null'
    elif isinstance(age, str):
        age_str = age
        age_type = 'string'
    else:
        age_str = 'Unknown'
        age_type = 'unknown'

    # 打印信息
    print(f"Name: {name}")
    print(f"Age: {age_str} (Type: {age_type})")
    print(f"City: {city}")
    print()