文件练习Python

随机生成10个100以内的整数，显示并存入文件 data1.txt中，数字之间以空格进行分隔;然后从
data1.txt中读取这些数字，利用冒泡排序方法进行升序排序后，显示并存入文件data2.txt中。

基于new bing的加以修改的编写

基于new bing的加以修改的编写

import random

# 生成随机整数列表
random_list = [random.randint(0, 100) for _ in range(10)]

# 将列表转化为字符串并用空格分隔
random_str = ' '.join(map(str, random_list))

# 存入文件data1.txt中
with open('data1.txt', 'w') as f:
    f.write(random_str)

# 从文件data1.txt中读取数据
with open('data1.txt', 'r') as f:
    data_str = f.read()

# 将字符串转化为列表
data_list = list(map(int, data_str.split()))

# 冒泡排序
for i in range(len(data_list)):
    for j in range(i+1, len(data_list)):
        if data_list[i] > data_list[j]:
            data_list[i], data_list[j] = data_list[j], data_list[i]

# 将排序后的列表转化为字符串并用空格分隔
sorted_str = ' '.join(map(str, data_list))

# 存入文件data2.txt中
with open('data2.txt', 'w') as f:
    f.write(sorted_str)

# 显示结果
print(f"随机整数列表：{random_list}")
print(f"排序后的列表：{data_list}")
print("结果已存入文件data1.txt和data2.txt中。")

import random

# 生成随机整数列表并保存到文件
def generate_numbers():
    numbers = [random.randint(1, 100) for _ in range(10)]
    numbers_str = ' '.join(map(str, numbers))
    with open('data1.txt', 'w') as file:
        file.write(numbers_str)

# 从文件中读取数字并进行冒泡排序
def bubble_sort():
    with open('data1.txt', 'r') as file:
        numbers_str = file.read()
    numbers = list(map(int, numbers_str.split()))
    
    n = len(numbers)
    for i in range(n-1):
        for j in range(n-i-1):
            if numbers[j] > numbers[j+1]:
                numbers[j], numbers[j+1] = numbers[j+1], numbers[j]
    
    sorted_numbers_str = ' '.join(map(str, numbers))
    with open('data2.txt', 'w') as file:
        file.write(sorted_numbers_str)

# 生成随机数并保存到文件
generate_numbers()

# 读取数据并进行排序
bubble_sort()

这段代码首先定义了两个函数，generate_numbers用于生成随机整数列表并保存到文件data1.txt中，bubble_sort用于从data1.txt文件中读取数字，并使用冒泡排序进行升序排序，然后将排序结果保存到文件data2.txt中。
在generate_numbers函数中，使用列表推导式和random.randint函数生成10个100以内的随机整数，并将这些数字转换为字符串，使用空格进行分隔。然后，将生成的字符串写入到data1.txt文件中。
在bubble_sort函数中，首先使用open函数打开data1.txt文件，并使用read方法读取文件内容为一个字符串。然后，使用split方法将字符串分割为数字列表。接下来，使用冒泡排序算法对数字列表进行升序排序。最后，将排序后的数字列表转换为字符串，并使用空格进行分隔，将排序结果写入到data2.txt文件中。
你可以运行这段代码来实现所需的功能。在运行之后，data1.txt文件中会包含10个随机生成的整数，data2.txt文件中会包含对这些整数进行升序排序后的结果。

该回答引用chatgpt:

import random

# 生成随机整数
random_numbers = [random.randint(1, 100) for _ in range(10)]

# 将生成的随机整数写入data1.txt文件
with open('data1.txt', 'w') as file:
    file.write(' '.join(map(str, random_numbers)))

# 从data1.txt中读取数字
with open('data1.txt', 'r') as file:
    numbers = list(map(int, file.read().split()))

# 冒泡排序
for i in range(len(numbers)):
    for j in range(len(numbers) - 1):
        if numbers[j] > numbers[j + 1]:
            numbers[j], numbers[j + 1] = numbers[j + 1], numbers[j]

# 将排序后的数字写入data2.txt文件
with open('data2.txt', 'w') as file:
    file.write(' '.join(map(str, numbers)))

# 显示结果
print("随机生成的数字:", random_numbers)
print("排序后的数字:", numbers)

这样：

import random
# 随机整数列表
random_list = [random.randint(0, 100) for _ in range(10)]
 
# 存入文件 data1.txt 中
with open('data1.txt', 'w') as f:
    f.write(' '.join(map(str, random_list)))
 
# 数据排序
with open('data1.txt', 'r') as f:
    data = f.read().split()
    data = [int(x) for x in data]
    n = len(data)
    for i in range(n):
        for j in range(0, n-i-1):
            if data[j] > data[j+1]:
                data[j], data[j+1] = data[j+1], data[j]
 
# 存入文件 data2.txt 中
with open('data2.txt', 'w') as f:
    f.write(' '.join(map(str, data)))
```bash

```

完整代码如下，实现了生成随机数和冒泡排序，以及文件的读写操作，代码具有详细的注解，便于你查看，望采纳下：

import random

#随机生成10个100以内的整数
random_list = []
for i in range(10):#循环10次，一次随机生成一个数
    random_list.append(str(random.randint(0,100))) #生成一个随机数并转换为字符串

#显示生成的随机数
print('生成的10个100以内的随机数：',' '.join(random_list))

# 存入文件 data1.txt 中 数字之间以空格进行分隔
with open('data1.txt', 'w') as file:
    for s in random_list:  #循环每个数字
        file.write(s+' ')  #将数字写入文件，每个数字之间用空格隔开

# 从data1.txt读取数据
data = []
with open('data1.txt', 'r') as f:
    data = f.read().split() #读取数字后使用split分割出每个数字
    data = [int(x) for x in data] #循环将字符串类型的数字转为int类型的数字，目的是便于排序，因为字符串不好直接比较大小

#对数据进行冒泡排序 升序排序
n = len(data)
for i in range(n):
    for j in range(0, n - i - 1):
        if data[j] > data[j + 1]:
            data[j], data[j + 1] = data[j + 1], data[j]

# 显示排序后的结果
print('冒泡升序排序后的结果为：',' '.join(map(str,data)))

#将排序的结果存入 data2.txt
with open('data2.txt', 'w') as file:
    for s in data:  # 循环每个数字
        file.write(str(s) +' ')  # 将数字转为字符串后写入文件，每个数字之间用空格隔开

• 帮你找了个相似的问题, 你可以看下: https://ask.csdn.net/questions/7435587
• 除此之外, 这篇博客: 数据挖掘导论——Python练习中的 有两个磁盘文件test1.txt和test2.txt,各存放一行字母,要求把这两个文件中的信息合并(按字母顺序排列，每类字母大写在前，小写在后), 输出到一个新文件test3.txt中。 部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:
  

• 示例：
  注：运行以上程序前，你需要在脚本执行的目录下创建 test1.txt、test2.txt 文件
  test1.txt : AbCdEf
  test2.txt: HIiJKaBcDeF
  test3.txt: AaBbCcDdEeFfHIiJK

• 以下回答由chatgpt基于相关博客总结生成:

  import random
  
  # 生成10个100以内的随机整数
  nums = [random.randint(0, 100) for i in range(10)]
  
  # 将随机数字写入文件data1.txt
  with open('data1.txt', 'w') as f:
      f.write(' '.join(map(str, nums)))
  
  # 读取data1.txt中的数字并进行排序
  with open('data1.txt', 'r') as f:
      nums = list(map(int, f.read().split(' ')))
      for i in range(len(nums)):
          for j in range(len(nums) - 1 - i):
              if nums[j] > nums[j + 1]:
                  nums[j], nums[j + 1] = nums[j + 1], nums[j]
  
  # 将排序后的数字写入文件data2.txt
  with open('data2.txt', 'w') as f:
      f.write(' '.join(map(str, nums)))
  

  注意：由于题目中没有要求输出至一个新文件，因此没有按照参考资料提供的方法做文件合并。如果需要输出至新文件，可以在排序后使用类似参考资料中的方式进行文件合并。

```python
import random

# 随机生成10个100以内的整数
nums = [random.randint(1, 100) for _ in range(10)]

# 显示并存入文件 data1.txt 中
with open('data1.txt', 'w') as f:
    f.write(' '.join(map(str, nums)))

# 从 data1.txt 中读取数字
with open('data1.txt', 'r') as f:
    nums = list(map(int, f.read().split()))

# 冒泡排序
for i in range(len(nums)):
    for j in range(len(nums) - i - 1):
        if nums[j] > nums[j + 1]:
            nums[j], nums[j + 1] = nums[j + 1], nums[j]

# 显示并存入文件 data2.txt 中
with open('data2.txt', 'w') as f:
    f.write(' '.join(map(str, nums)))

```

import random  
  
# 生成10个100以内的随机整数，并保存到文件data1.txt中  
with open("data1.txt", "w") as f:  
    for i in range(10):  
        num = random.randint(1, 100)  
        f.write(str(num) + " ")  
  
# 从文件data1.txt中读取整数，用冒泡排序升序排序，并保存到文件data2.txt中  
with open("data1.txt", "r") as f:  
    lines = f.readlines()  
    sorted_lines = sorted(lines, key=lambda x: int(x.strip()))  
    with open("data2.txt", "w") as f2:  
        for line in sorted_lines:  
            f2.write(line)

```python
import random

# 生成随机数并存入文件
with open("data1.txt", "w") as f:
    nums = [random.randint(1, 100) for _ in range(10)]
    f.write(" ".join(map(str, nums)))
print("随机生成的数字：", " ".join(map(str, nums)))

# 从文件中读取数据并进行冒泡排序
with open("data1.txt", "r") as f:
    nums = list(map(int, f.read().split()))

for i in range(len(nums)):
    for j in range(len(nums) - i - 1):
        if nums[j] > nums[j + 1]:
            nums[j], nums[j + 1] = nums[j + 1], nums[j]

# 将排序后的结果存入文件
with open("data2.txt", "w") as f:
    f.write(" ".join(map(str, nums)))

# 显示结果
print("冒泡排序后的数字：", " ".join(map(str, nums)))

```

import random

# 生成随机数并存入data1.txt
with open('data1.txt', 'w') as f:
    nums = [random.randint(1, 100) for _ in range(100)]
    f.write(' '.join(map(str, nums)))

# 读取data1.txt中的数字并进行排序
with open('data1.txt', 'r') as f:
    nums = list(map(int, f.read().split()))
    for i in range(len(nums)):
        for j in range(len(nums) - i - 1):
            if nums[j] > nums[j+1]:
                nums[j], nums[j+1] = nums[j+1], nums[j]

# 将排序后的数字存入data2.txt
with open('data2.txt', 'w') as f:
    f.write(' '.join(map(str, nums)))

基于chatgpt修改

import random

# 随机生成10个100以内的整数
nums = [random.randint(1, 100) for _ in range(10)]
print("生成的随机数:", nums)

# 将数字以空格分隔的形式写入文件 data1.txt
with open("data1.txt", "w") as f:
    f.write(" ".join(map(str, nums)))

# 从文件 data1.txt 中读取数字
with open("data1.txt", "r") as f:
    nums = list(map(int, f.read().split()))

# 冒泡排序
for i in range(len(nums)):
    for j in range(i, len(nums)):
        if nums[i] > nums[j]:
            nums[i], nums[j] = nums[j], nums[i]

# 将排序后的数字以空格分隔的形式写入文件 data2.txt
with open("data2.txt", "w") as f:
    f.write(" ".join(map(str, nums)))

print("排序后的数字:", nums)

以下是Python代码实现：

import random

# 生成10个100以内的随机整数，并以空格分隔存入文件data1.txt中
with open('data1.txt', 'w') as f:
    for i in range(10):
        num = random.randint(1, 100)
        f.write(str(num) + ' ')
        
# 从data1.txt中读取数字，进行冒泡排序并存入文件data2.txt中
with open('data1.txt', 'r') as f:
    data = f.readlines()
    
for i in range(len(data)):
    num_list = [int(x.strip()) for x in data[i].split()]
    num_list.sort()
    
    # 将升序后的数字重新写入文件data2.txt中
    with open('data2.txt', 'a') as f:
        for j in range(len(num_list)):
            f.write(str(num_list[j]) + ' ')
            
# 输出结果
print('Data sorted in file data2.txt:')
with open('data2.txt', 'r') as f:
    print(f.read())

import random
 
# 生成10个100以内的随机整数
nums = [random.randint(0, 100) for i in range(10)]
 
# 将随机数字写入文件data1.txt
with open('data1.txt', 'w') as f:
    f.write(' '.join(map(str, nums)))
 
# 读取data1.txt中的数字并进行排序
with open('data1.txt', 'r') as f:
    nums = list(map(int, f.read().split(' ')))
    for i in range(len(nums)):
        for j in range(len(nums) - 1 - i):
            if nums[j] > nums[j + 1]:
                nums[j], nums[j + 1] = nums[j + 1], nums[j]
 
# 将排序后的数字写入文件data2.txt
with open('data2.txt', 'w') as f:
    f.write(' '.join(map(str, nums)))

以下是代码实现：

import random

# 随机生成10个100以内的整数
nums = [random.randint(1, 100) for _ in range(10)]

# 将数字以空格分隔并存入文件data1.txt中
with open('data1.txt', 'w') as f:
    f.write(' '.join(map(str, nums)))

# 从data1.txt中读取数字并进行冒泡排序
with open('data1.txt', 'r') as f:
    nums = list(map(int, f.read().split()))

for i in range(len(nums)):
    for j in range(len(nums) - i - 1):
        if nums[j] > nums[j+1]:
            nums[j], nums[j+1] = nums[j+1], nums[j]

# 将排序后的数字以空格分隔并存入文件data2.txt中
with open('data2.txt', 'w') as f:
    f.write(' '.join(map(str, nums)))

# 显示排序后的数字
print(nums)

运行后，会生成data1.txt和data2.txt两个文件，其中data1.txt中存储了随机生成的10个数字，data2.txt中存储了排序后的数字。同时，程序也会在控制台输出排序后的数字。

import random
 # 生成10个100以内的随机整数
nums = [random.randint(1, 100) for _ in range(10)]
 # 将数字以空格分隔的形式存入文件data1.txt中
with open('data1.txt', 'w') as f:
    f.write(' '.join(map(str, nums)))
 # 从文件data1.txt中读取数字
with open('data1.txt', 'r') as f:
    nums = list(map(int, f.read().split()))
 # 冒泡排序
for i in range(len(nums)-1):
    for j in range(len(nums)-i-1):
        if nums[j] > nums[j+1]:
            nums[j], nums[j+1] = nums[j+1], nums[j]
 # 将排序后的数字以空格分隔的形式存入文件data2.txt中
with open('data2.txt', 'w') as f:
    f.write(' '.join(map(str, nums)))
 # 显示排序后的数字
print(nums)

这是我的代码，希望对您有帮助

import random

# 生成随机整数列表
random_numbers = [random.randint(1, 100) for _ in range(10)]
print("随机生成的整数列表:", random_numbers)

# 写入文件 data1.txt
with open("data1.txt", "w") as file:
    file.write(" ".join(map(str, random_numbers)))

# 读取文件 data1.txt
with open("data1.txt", "r") as file:
    numbers = file.read().split()

# 将读取的数字列表转换为整数
numbers = list(map(int, numbers))

# 冒泡排序
for i in range(len(numbers)):
    for j in range(len(numbers) - i - 1):
        if numbers[j] > numbers[j + 1]:
            numbers[j], numbers[j + 1] = numbers[j + 1], numbers[j]

# 打印排序后的数字列表
print("排序后的数字列表:", numbers)

# 写入文件 data2.txt
with open("data2.txt", "w") as file:
    file.write(" ".join(map(str, numbers)))

print("数据已写入文件 data2.txt")

麻烦提问者点击一下采纳按钮，谢谢啦

讲真，直接百度更方便，也可以加深理解

import random

# 生成随机整数并保存到文件 data1.txt 中
with open('data1.txt', 'w') as f:
    nums = [random.randint(1, 100) for _ in range(10)] # 生成随机整数列表
    f.write(' '.join(map(str, nums))) # 将整数列表转换为字符串并写入文件
    print(f"随机生成的整数为: {nums}")

# 从文件 data1.txt 中读取数字并进行冒泡排序，然后保存到文件 data2.txt 中
with open('data1.txt', 'r') as f1, open('data2.txt', 'w') as f2:
    nums = [int(num) for num in f1.read().split()] # 读取文件中的数字并转换为整数列表
    n = len(nums)

    # 冒泡排序
    for i in range(n):
        for j in range(n - i - 1):
            if nums[j] > nums[j+1]:
                nums[j], nums[j+1] = nums[j+1], nums[j]

    f2.write(' '.join(map(str, nums))) # 将排序后的整数列表转换为字符串并写入文件
    print(f"排序后的整数为: {nums}")

这个程序首先使用 random 模块生成 10 个 1~100 之间的随机整数，并将其保存到文件 data1.txt 中。然后从 data1.txt 中读取这些数字并进行冒泡排序，最后将排序后的整数保存到文件 data2.txt 中。

import random

# 生成10个100以内的随机整数
random_numbers = [random.randint(0, 100) for _ in range(10)]

# 将随机整数写入 data1.txt 文件
with open("data1.txt", "w") as f:
    f.write(" ".join(str(x) for x in random_numbers))

# 从 data1.txt 文件中读取随机整数
with open("data1.txt", "r") as f:
    numbers_str = f.read()
    numbers = [int(x) for x in numbers_str.split()]

# 冒泡排序对随机整数进行升序排序
for i in range(len(numbers)):
    for j in range(i + 1, len(numbers)):
        if numbers[i] > numbers[j]:
            numbers[i], numbers[j] = numbers[j], numbers[i]

# 将排序后的整数写入 data2.txt 文件
with open("data2.txt", "w") as f:
    f.write(" ".join(str(x) for x in numbers))
    
# 打印结果
print("生成的随机整数：", random_numbers)
print("排序后的整数：", numbers)

---

如果以上回答对您有所帮助，点击一下采纳该答案～谢谢

Python 代码：

import random

# 生成10个100以内的整数
nums = [random.randint(1, 100) for _ in range(10)]

# 将生成的数字写入 data1.txt 文件
with open('data1.txt', 'w') as f1:
    f1.write(' '.join([str(num) for num in nums]))

# 读取 data1.txt 文件中的数字
with open('data1.txt', 'r') as f1:
    nums = [int(num) for num in f1.read().split()]

# 使用冒泡排序升序排序
for i in range(len(nums)):
    for j in range(0, len(nums)-i-1):
        if nums[j] > nums[j+1]:
            nums[j], nums[j+1] = nums[j+1], nums[j]

# 将排序后的数字写入 data2.txt 文件
with open('data2.txt', 'w') as f2:
    f2.write(' '.join([str(num) for num in nums]))

引用GPT和自己的思路：
这是一个Python代码示例，用于生成10个100以内的随机整数，将它们存储到data1.txt文件中，然后从文件中读取这些数字，使用冒泡排序进行升序排序，并将排序后的数字存储到datal.txt文件中。

import random

# 生成10个100以内的随机整数
random_numbers = [random.randint(1, 100) for _ in range(10)]

# 将随机整数写入data1.txt文件
with open("data1.txt", "w") as f:
    f.write(" ".join(str(num) for num in random_numbers))

# 从data1.txt文件中读取数字
with open("data1.txt", "r") as f:
    numbers = list(map(int, f.read().split()))

# 使用冒泡排序对数字进行升序排序
for i in range(len(numbers)):
    for j in range(len(numbers) - i - 1):
        if numbers[j] > numbers[j + 1]:
            numbers[j], numbers[j + 1] = numbers[j + 1], numbers[j]

# 将排序后的数字写入datal.txt文件
with open("datal.txt", "w") as f:
    f.write(" ".join(str(num) for num in numbers))

# 显示原始随机数字和排序后的数字
print("原始随机数字:", random_numbers)
print("排序后的数字:", numbers)

这段代码首先生成10个100以内的随机整数，然后将它们写入data1.txt文件。接下来，从文件中读取这些数字并使用冒泡排序进行升序排序。最后，将排序后的数字写入datal.txt文件，并显示原始随机数字和排序后的数字。

import random
# zs    2023053017:54

def main():
    # 随机生成10个100以内的整数
    nums = [random.randint(0, 100) for i in range(10)]
    print(nums)

    # 显示并存入文件data1.txt中
    with open('data1.txt', 'w') as f:
        f.write(' '.join(str(n) for n in nums))

    # 读取data1.txt中的数字
    with open('data1.txt', 'r') as f:
        nums = [int(n) for n in f.read().split()]

    # 冒泡排序并显示
    for i in range(len(nums) - 1):
        for j in range(len(nums) - i - 1):
            if nums[j] > nums[j + 1]:
                nums[j], nums[j + 1] = nums[j + 1], nums[j]
    print(nums)

    # 保存至data2.txt
    with open('data2.txt', 'w') as f:
        f.write(' '.join(str(n) for n in nums))


if __name__ == '__main__':
    main()