python 取出两个txt文件里的同一行 比较内容是否相同

可以使用 Python 中的 fileinput 模块，结合 set 和 intersection 方法来实现这个功能。具体步骤如下：

1. 打开两个 txt 文件，将其分别读入两个列表中；
2. 转换列表为集合，使用 intersection 方法找出两个集合中相同的元素；
3. 如果相同元素不为空，则说明两个文件中存在相同的行。

以下是示例代码：

import fileinput

# 读取第一个文件
with open('file1.txt', 'r') as file1:
    lines1 = file1.readlines()

# 读取第二个文件
with open('file2.txt', 'r') as file2:
    lines2 = file2.readlines()

# 将列表转换为集合，使用 intersection 方法找出相同元素
set1 = set(lines1)
set2 = set(lines2)
result = set1.intersection(set2)

# 输出结果
if result:
    print('两个文件存在相同的行：')
    for line in result:
        print(line.strip())
else:
    print('两个文件不存在相同的行。')

注意：上述代码中使用了 strip 方法去除行末的换行符。如果你的文本文件中不包含换行符，可以不使用 strip 方法。

相关问题

写一个脚本来抓取A和B这两个文本文件中的8到12行的内容，并将抓取出的内容分别赋值给变量X和Y，然后比较X和Y这两个变量是否完全一致，一致输出PASS，不一致输出ERROR

好的，以下是Python语言的脚本实现：

with open('A.txt') as file1, open('B.txt') as file2:
    lines1 = file1.readlines()[7:11]
    lines2 = file2.readlines()[7:11]
    X = ''.join(lines1)
    Y = ''.join(lines2)

if X == Y:
    print('PASS')
else:
    print('ERROR')

假设A和B两个文本文件在同一目录下，以上脚本会打开这两个文件，读取8到12行的内容，然后分别将它们赋值给变量X和Y。最后比较X和Y是否完全一致，输出相应的结果。

在一个流水车间问题中，有一个零件仓库、三台加工机和一个成品仓库，上述设施线性等距，距离大小为1。作业在机器之间由AGV运输。车间内只有一辆AGV, AGV一次只能运送一个作业。AGV的运输时间等于运输距离。每台加工机器有3个输出缓冲区，一个缓冲区在同一时刻最多储存一个作业。在AGV不可用或者下一台机器不可用时，当前机器上加工完的作业可以自动储存到当前加工机器相应的输出缓冲区。此外，两个仓库的容量是无限的。一共有5个作业，每个作业需要从零件仓库开始运输，在加工机上依次加工，最后存入成品仓库，机器一次只能加工一个作业。设计了一种启发式算法来生成AGV运输调度的可行解，给出算法的伪代码、流程图，并给出python代码。

伪代码：

1. 初始化所有作业的状态为未完成。
2. 初始化所有缓冲区为空。
3. 初始化AGV的位置为零件仓库。
4. 初始化当前时间为0。
5. 当存在未完成的作业时，执行以下步骤：
   5.1. 找到所有可以开始运输的作业，即前置作业已完成的作业。
   5.2. 选择一个距离最短的作业，将AGV移动到该作业所在的位置。
   5.3. 将该作业从零件仓库或上一个机器的输出缓冲区中取出，并将其运输到当前机器。
   5.4. 将AGV停靠在当前机器上，等待该作业加工完成。
   5.5. 当该作业加工完成后，将其放入当前机器的一个空闲输出缓冲区中。
   5.6. 如果当前机器的所有输出缓冲区都已满，则等待一个缓冲区变为空闲状态。
   5.7. 重复步骤5.1-5.6，直到该作业完成。
   5.8. 将该作业存入成品仓库，更新该作业的状态为已完成。
6. 输出所有作业的完成时间和总运输时间。

流程图：


Python 代码：

import math

class Job:
    def __init__(self, id, pos):
        self.id = id
        self.pos = pos
        self.status = "not started"
        self.start_time = None
        self.finish_time = None

class Buffer:
    def __init__(self, size):
        self.jobs = [None] * size

    def add_job(self, job):
        for i in range(len(self.jobs)):
            if self.jobs[i] is None:
                self.jobs[i] = job
                return True
        return False

    def remove_job(self):
        for i in range(len(self.jobs)):
            if self.jobs[i] is not None:
                job = self.jobs[i]
                self.jobs[i] = None
                return job
        return None

class Workshop:
    def __init__(self, num_jobs, num_machines, buffer_size):
        self.jobs = []
        for i in range(num_jobs):
            self.jobs.append(Job(i, 0))
        self.machines = []
        for i in range(num_machines):
            self.machines.append(Buffer(buffer_size))
        self.transporter_pos = 0
        self.current_time = 0
        self.total_transport_time = 0

    def run(self):
        while True:
            # check if all jobs are completed
            all_jobs_completed = True
            for job in self.jobs:
                if job.status != "completed":
                    all_jobs_completed = False
                    break
            if all_jobs_completed:
                break

            # find all jobs that can be started
            startable_jobs = []
            for job in self.jobs:
                if job.status == "not started":
                    dependencies_completed = True
                    for i in range(job.id):
                        if self.jobs[i].status != "completed":
                            dependencies_completed = False
                            break
                    if dependencies_completed:
                        startable_jobs.append(job)

            if len(startable_jobs) == 0:
                continue

            # select the nearest startable job
            min_distance = math.inf
            nearest_job = None
            for job in startable_jobs:
                distance = abs(job.pos - self.transporter_pos)
                if distance < min_distance:
                    min_distance = distance
                    nearest_job = job

            # transport the job to the next machine
            self.total_transport_time += min_distance
            self.transporter_pos = nearest_job.pos
            nearest_job.status = "transporting"
            nearest_job.start_time = self.current_time
            nearest_job.pos += 1

            # move the job through the machines
            for i in range(len(self.machines)):
                machine = self.machines[i]
                if machine.add_job(nearest_job):
                    nearest_job.status = "processing"
                    nearest_job.pos = i + 1
                    break

            # wait for the job to finish processing
            while True:
                job_finished = False
                for machine in self.machines:
                    job = machine.remove_job()
                    if job is not None:
                        job.status = "completed"
                        job.finish_time = self.current_time
                        job_finished = True
                        break
                if job_finished:
                    break
                self.current_time += 1

            # move the AGV back to the warehouse
            self.total_transport_time += nearest_job.pos - 1
            self.transporter_pos = 0

    def print_results(self):
        for job in self.jobs:
            print("Job", job.id, "start time:", job.start_time, "finish time:", job.finish_time)
        print("Total transport time:", self.total_transport_time)

workshop = Workshop(5, 3, 3)
workshop.run()
workshop.print_results()

这个算法使用了贪心策略：每次选择距离最近且可以开始运输的作业。此外，该算法使用了缓冲区来处理当AGV不可用或下一台机器不可用时，当前机器上加工完的作业可以自动储存到当前加工机器相应的输出缓冲区的情况。