• gpt-4o考场安排

            说明 ：经过多次交互，前后花了几个小时，总算完成了基本功能。如果做到按不同层次分配考场，一键出打印结果就完美了。如果不想看中间“艰苦”的过程，请直接跳到“最后结果”及“食用方法”。中间过程还省略了一部分交互，gpt-4o一个线程限制了会话的次数（100），大概开了三个线程完成了任务。在此过程中自己可能提示词描述不够准确。以后在描述问题时还需要改进，后续添加交互，打包为exe

            在日常的教务活动中，考场安装很费时的事。学校平时考场安排，不像大型考试每考室人数固定，有时还会按不同层次的学生安排考场，要求比较多，排定后还需手工调整。

    第一次给的提示语：

    1.  电子表格”考场安排demo.xlsx“的字段为：班级、准考证号、学生姓名、考场、考号。其中考场、考号需要程序来安排的，请按以下要求给出python程序。
    2.  1、总考场数为24个
    3.  2、请平均分配每考场人数
    4.  3、每个考场的座位号从1开始编号，依次为2, 3, 4,...。
    5.  4、随机安排学生，注意是随机，但要保证在一个考场中相邻两条记录，它们班级字段的值不相等。
    6.  5、将安排好的结果以“考场安排结果.xlsx"保存

    经过了几次迭代：

     上面的程序执行了很长时间，即没有结果，也没有出错提示
 错误仍然存在
 如果每考场的学生班号随机一点就更好了

    此时出现警告

     A value is trying to be set on a copy of a slice from a DataFrame

    直接将警告提交给gpt

     当我重新运行以上程序时，虽然没有了警告提示，运行很长时间没有结果

    这时给出了正确的结果

    1.  import pandas as pd
    2.  import random
    3.  from openpyxl import Workbook
    4.  import numpy as np
    5.  ​
    6.  ​
    7.  def load_data(filename):
    8.      return pd.read_excel(filename)
    9.  ​
    10.  ​
    11.  def save_data(df, filename):
    12.      df.to_excel(filename, index=False)
    13.  ​
    14.  ​
    15.  def assign_seats(df, total_halls):
    16.      # 按班级分组并随机打乱每个班级内部的顺序
    17.      grouped = df.groupby('班级')
    18.      groups = [group.sample(frac=1).reset_index(drop=True) for _, group in grouped]
    19.  ​
    20.      # 创建调度器队列，初始化为每个班级的iterator
    21.      iterators = [iter(group.iterrows()) for group in groups]
    22.  ​
    23.      arranged_data = []
    24.      hall_number = 1
    25.      seat_number = 1
    26.  ​
    27.      total_students = len(df)
    28.      students_per_hall = total_students // total_halls
    29.      extra_students = total_students % total_halls
    30.  ​
    31.      while iterators:
    32.          random.shuffle(iterators)
    33.          for it in iterators[:]:  # 遍历每个迭代器
    34.              try:
    35.                  _, student = next(it)
    36.                  student_data = student.to_dict()
    37.                  student_data["考场"] = hall_number
    38.                  student_data["考号"] = seat_number
    39.                  arranged_data.append(student_data)
    40.  ​
    41.                  seat_number += 1
    42.  ​
    43.                  if seat_number > students_per_hall + (1 if hall_number <= extra_students else 0):
    44.                      hall_number += 1
    45.                      seat_number = 1
    46.  ​
    47.                  if hall_number > total_halls:
    48.                      hall_number = 1
    49.              except StopIteration:
    50.                  iterators.remove(it)  # 当前iterator已遍历完全，移除它
    51.  ​
    52.      return arranged_data
    53.  ​
    54.  ​
    55.  def main():
    56.      input_filename = "考场安排demo.xlsx"
    57.      output_filename = "考场安排结果.xlsx"
    58.  ​
    59.      total_halls = 24
    60.  ​
    61.      df = load_data(input_filename)
    62.      arranged_students = assign_seats(df, total_halls)
    63.      arranged_df = pd.DataFrame(arranged_students)
    64.  ​
    65.      save_data(arranged_df, output_filename)
    66.  ​
    67.  ​
    68.  if __name__ == "__main__":
    69.      main()

    重新给了提示语：座位号改为01、02、03...,添加了时间戳。

     电子表格”考场安排demo.xlsx“的字段为：班级、准考证号、学生姓名、考场、考号。其中考场、考号需要程序来安排的，请按以下要求给出python程序。
 1、总考场数为24个
 2、请平均分配每考场人数
 3、每个考场的座位号从01开始编号，依次为02, 03, 04,...。
 4、随机安排学生，注意是随机，但要保证在一个考场中相邻两条记录，它们班级字段的值不相等。
 5、将安排好的结果以“考场安排结果+时间戳.xlsx"保存

    很高兴听到程序已经很好地满足了你的要求。为了确保最终程序完善且清晰，我将提供最终版本的Python代码，该代码完整处理各项要求，并生成考场安排结果文件：

    1. 总考场数为24个。

    2. 平均分配每考场人数。

    3. 每个考场的座位号从01开始编号，依次为02, 03, 04,...。

    4. 随机安排学生，保证在一个考场中，相邻两条记录的班级字段的值不相等。

    5. 将安排好的结果以“考场安排结果+时间戳.xlsx”保存。

    代码如下： 

    1. import pandas as pd
    2.  import random
    3.  from openpyxl import Workbook
    4.  from datetime import datetime
    5.  import numpy as np
    6.  ​
    7.  def load_data(filename):
    8.      return pd.read_excel(filename)
    9.  ​
    10.  def save_data(df, filename):
    11.      df.to_excel(filename, index=False)
    12.  ​
    13.  def assign_seats(df, total_halls):
    14.      # 按班级分组并随机打乱每个班级内部的顺序
    15.      grouped = df.groupby('班级')
    16.      groups = [group.sample(frac=1).reset_index(drop=True) for _, group in grouped]
    17.      
    18.      # 创建调度器队列，初始化为每个班级的iterator
    19.      iterators = [iter(group.iterrows()) for group in groups]
    20.  ​
    21.      arranged_data = []
    22.      hall_number = 1
    23.      seat_number = 1
    24.      
    25.      total_students = len(df)
    26.      students_per_hall = total_students // total_halls
    27.      extra_students = total_students % total_halls
    28.      
    29.      while iterators:
    30.          random.shuffle(iterators)
    31.          for it in iterators[:]:
    32.              try:
    33.                  _, student = next(it)
    34.                  student_data = student.to_dict()
    35.                  student_data["考场"] = hall_number
    36.                  student_data["考号"] = f"{seat_number:02d}"  # 格式化为两位字符
    37.                  arranged_data.append(student_data)
    38.                  
    39.                  seat_number += 1
    40.                  
    41.                  if seat_number > students_per_hall + (1 if hall_number <= extra_students else 0):
    42.                      hall_number += 1
    43.                      seat_number = 1
    44.                      
    45.                  if hall_number > total_halls:
    46.                      hall_number = 1
    47.              except StopIteration:
    48.                  iterators.remove(it)
    49.      
    50.      return arranged_data
    51.  ​
    52.  def main():
    53.      input_filename = "考场安排demo.xlsx"
    54.      
    55.      total_halls = 24
    56.  ​
    57.      df = load_data(input_filename)
    58.      arranged_students = assign_seats(df, total_halls)
    59.      arranged_df = pd.DataFrame(arranged_students)
    60.      
    61.      current_time = datetime.now().strftime("%Y%m%d_%H%M%S")
    62.      output_filename = f"考场安排结果_{current_time}.xlsx"
    63.      
    64.      save_data(arranged_df, output_filename)
    65.      print(f"已成功生成文件：{output_filename}")
    66.  ​
    67.  if __name__ == "__main__":
    68.      main()

    让gpt-4o进行了美化：

    为了对导出的电子表格进行格式化美化，我们可以使用 pandas 和 openpyxl 模块来提升电子表格的可读性和视觉效果。这可能包括：

    1. 设置标题行的样式（如背景颜色、字体加粗等）。

    2. 自动调整列宽。

    3. 为整个表格设置边框。

    4. 设置单元格对齐方式。

    以下是如何实现这些功能的代码示例： 

    1. import pandas as pd
    2.  import openpyxl
    3.  from openpyxl.styles import Font, Alignment, PatternFill, Border, Side
    4.  from openpyxl.utils import get_column_letter
    5.  from openpyxl.worksheet.worksheet import Worksheet
    6.  import random
    7.  from datetime import datetime
    8.  ​
    9.  def load_data(filename):
    10.      return pd.read_excel(filename)
    11.  ​
    12.  def save_data(df, filename):
    13.      df.to_excel(filename, index=False)
    14.      format_excel(filename)
    15.  ​
    16.  def assign_seats(df, total_halls):
    17.      grouped = df.groupby('班级')
    18.      groups = [group.sample(frac=1).reset_index(drop=True) for _, group in grouped]
    19.      
    20.      iterators = [iter(group.iterrows()) for group in groups]
    21.  ​
    22.      arranged_data = []
    23.      hall_number = 1
    24.      seat_number = 1
    25.      
    26.      total_students = len(df)
    27.      students_per_hall = total_students // total_halls
    28.      extra_students = total_students % total_halls
    29.      
    30.      while iterators:
    31.          random.shuffle(iterators)
    32.          for it in iterators[:]:
    33.              try:
    34.                  _, student = next(it)
    35.                  student_data = student.to_dict()
    36.                  student_data["考场"] = hall_number
    37.                  student_data["考号"] = f"{seat_number:02d}"
    38.                  arranged_data.append(student_data)
    39.                  
    40.                  seat_number += 1
    41.                  
    42.                  if seat_number > students_per_hall + (1 if hall_number <= extra_students else 0):
    43.                      hall_number += 1
    44.                      seat_number = 1
    45.                      
    46.                  if hall_number > total_halls:
    47.                      hall_number = 1
    48.              except StopIteration:
    49.                  iterators.remove(it)
    50.      
    51.      return arranged_data
    52.  ​
    53.  def format_excel(filename):
    54.      wb = openpyxl.load_workbook(filename)
    55.      ws = wb.active
    56.      
    57.      # 设置标题行的样式
    58.      for cell in ws[1]:
    59.          cell.font = Font(bold=True, color="FFFFFF")
    60.          cell.fill = PatternFill(start_color="4F81BD", end_color="4F81BD", fill_type="solid")
    61.          cell.alignment = Alignment(horizontal="center", vertical="center")
    62.      
    63.      # 自动调整列宽
    64.      for col in ws.columns:
    65.          max_length = 0
    66.          column = col[0].column_letter  # 获取列的字母
    67.          for cell in col:
    68.              try:
    69.                  if len(str(cell.value)) > max_length:
    70.                      max_length = len(str(cell.value))
    71.              except:
    72.                  pass
    73.          adjusted_width = (max_length + 2)
    74.          ws.column_dimensions[column].width = adjusted_width
    75.      
    76.      # 设置单元格边框和对齐方式
    77.      thin_border = Border(left=Side(style='thin'), 
    78.                           right=Side(style='thin'), 
    79.                           top=Side(style='thin'), 
    80.                           bottom=Side(style='thin'))
    81.      
    82.      for row in ws.iter_rows(min_row=2, max_row=ws.max_row, min_col=1, max_col=ws.max_column):
    83.          for cell in row:
    84.              cell.border = thin_border
    85.              cell.alignment = Alignment(horizontal="center", vertical="center")
    86.      
    87.      wb.save(filename)
    88.  ​
    89.  def main():
    90.      input_filename = "考场安排demo.xlsx"
    91.      
    92.      total_halls = 24
    93.  ​
    94.      df = load_data(input_filename)
    95.      arranged_students = assign_seats(df, total_halls)
    96.      arranged_df = pd.DataFrame(arranged_students)
    97.      
    98.      current_time = datetime.now().strftime("%Y%m%d_%H%M%S")
    99.      output_filename = f"考场安排结果_{current_time}.xlsx"
    100.      
    101.      save_data(arranged_df, output_filename)
    102.      print(f"已成功生成文件：{output_filename}")
    103.  ​
    104.  if __name__ == "__main__":
    105.      main()

    美化步骤：

    1. 设置标题行样式：

      • 使用 Font 来设定字体加粗和颜色。

      • 使用 PatternFill 来设定标题行的背景颜色。

      • 使用 Alignment 来设置标题单元格内容居中。

    2. 自动调整列宽：

      • 遍历每一列，计算列中最长的单元格内容长度，并据此设置列宽，使得内容完整显示。

    3. 设置单元格边框和对齐方式：

      • 使用 Border 和 Side 来为每个单元格加上细边框。

      • 对每个单元格设置居中对齐 Alignment。

            这样设置后，生成的Excel文件在视觉上会更加整洁和美观，并且更符合传统表格的排版格式。可以在正式运行前用少量数据进行测试。

    完整示例代码如下：

    1. 引入 openpyxl：添加 import openpyxl。

    2. 设置适当的页边距、行高和打印设置。

    3. 在代码最后保存并提示用户文件已生成。

    1.  import pandas as pd
    2.  import random
    3.  import openpyxl
    4.  from openpyxl.styles import Font, Alignment, PatternFill, Border, Side
    5.  from openpyxl.utils import get_column_letter
    6.  from openpyxl.worksheet.page import PageMargins
    7.  from datetime import datetime
    8.  ​
    9.  def load_data(filename):
    10.      return pd.read_excel(filename)
    11.  ​
    12.  def save_data(df, filename):
    13.      df.to_excel(filename, index=False)
    14.      format_excel(filename)
    15.  ​
    16.  def assign_seats(df, total_halls):
    17.      grouped = df.groupby('班级')
    18.      groups = [group.sample(frac=1).reset_index(drop=True) for _, group in grouped]
    19.      
    20.      iterators = [iter(group.iterrows()) for group in groups]
    21.  ​
    22.      arranged_data = []
    23.      hall_number = 1
    24.      seat_number = 1
    25.      
    26.      total_students = len(df)
    27.      students_per_hall = total_students // total_halls
    28.      extra_students = total_students % total_halls
    29.      
    30.      while iterators:
    31.          random.shuffle(iterators)
    32.          for it in iterators[:]:
    33.              try:
    34.                  _, student = next(it)
    35.                  student_data = student.to_dict()
    36.                  student_data["考场"] = hall_number
    37.                  student_data["考号"] = f"{seat_number:02d}"
    38.                  arranged_data.append(student_data)
    39.                  
    40.                  seat_number += 1
    41.                  
    42.                  if seat_number > students_per_hall + (1 if hall_number <= extra_students else 0):
    43.                      hall_number += 1
    44.                      seat_number = 1
    45.                      
    46.                  if hall_number > total_halls:
    47.                      hall_number = 1
    48.              except StopIteration:
    49.                  iterators.remove(it)
    50.      
    51.      return arranged_data
    52.  ​
    53.  def format_excel(filename):
    54.      wb = openpyxl.load_workbook(filename)
    55.      ws = wb.active
    56.      
    57.      # 设置标题行的样式
    58.      for cell in ws[1]:
    59.          cell.font = Font(bold=True, color="FFFFFF")
    60.          cell.fill = PatternFill(start_color="4F81BD", end_color="4F81BD", fill_type="solid")
    61.          cell.alignment = Alignment(horizontal="center", vertical="center")
    62.      
    63.      # 自动调整列宽
    64.      for col in ws.columns:
    65.          max_length = 0
    66.          column = col[0].column_letter
    67.          for cell in col:
    68.              try:
    69.                  if len(str(cell.value)) > max_length:
    70.                      max_length = len(str(cell.value))
    71.              except:
    72.                  pass
    73.          adjusted_width = (max_length + 2)
    74.          ws.column_dimensions[column].width = adjusted_width
    75.      
    76.      # 设置行高（适当调整以适应A4纸）
    77.      for row in range(1, ws.max_row + 1):
    78.          ws.row_dimensions[row].height = 18  # 行高设置为18像素
    79.      
    80.      # 设置单元格边框和对齐方式
    81.      thin_border = Border(left=Side(style='thin'), 
    82.                           right=Side(style='thin'), 
    83.                           top=Side(style='thin'), 
    84.                           bottom=Side(style='thin'))
    85.      
    86.      for row in ws.iter_rows(min_row=2, max_row=ws.max_row, min_col=1, max_col=ws.max_column):
    87.          for cell in row:
    88.              cell.border = thin_border
    89.              cell.alignment = Alignment(horizontal="center", vertical="center")
    90.      
    91.      # 设置页边距
    92.      ws.page_margins = PageMargins(left=0.5, right=0.5, top=0.5, bottom=0.5)
    93.      
    94.      # 设置打印区域（每张A4纸显示一个考场）
    95.      total_halls = 24
    96.      total_students = ws.max_row - 1  # 排除标题行
    97.      students_per_hall = total_students // total_halls
    98.      extra_students = total_students % total_halls
    99.  ​
    100.      for hall_number in range(1, total_halls + 1):
    101.          min_row = 2 + (hall_number - 1) * (students_per_hall + (1 if hall_number <= extra_students else 0))
    102.          max_row = min_row + students_per_hall + (1 if hall_number <= extra_students else 0) - 1
    103.  ​
    104.      ws.print_area = f"A1:E{max_row}"
    105.  ​
    106.      # 配置页面设置
    107.      ws.page_setup.orientation = 'portrait'
    108.      ws.page_setup.paperSize = ws.PAPERSIZE_A4
    109.      ws.page_setup.fitToWidth = True
    110.      ws.page_setup.fitToHeight = False
    111.  ​
    112.      wb.save(filename)
    113.  ​
    114.  def main():
    115.      input_filename = "考场安排demo.xlsx"
    116.      
    117.      total_halls = 24
    118.  ​
    119.      df = load_data(input_filename)
    120.      arranged_students = assign_seats(df, total_halls)
    121.      arranged_df = pd.DataFrame(arranged_students)
    122.      
    123.      current_time = datetime.now().strftime("%Y%m%d_%H%M%S")
    124.      output_filename = f"考场安排结果_{current_time}.xlsx"
    125.      
    126.      save_data(arranged_df, output_filename)
    127.      print(f"已成功生成文件：{output_filename}")
    128.  ​
    129.  if __name__ == "__main__":
    130.      main()

    关键美化与打印设置说明：

    1. 自动调整列宽：根据单元格内容自动调整列宽，以适应打印输出。

    2. 设置标题行的样式：加粗并设置标题行字体颜色和背景颜色，使其与数据行区别开来。

    3. 设置行高：设置统一的行高（18像素）以适应A4纸打印要求。

    4. 设置单元格边框和对齐方式：所有单元格增加边框和居中对齐。

    5. 设置页边距：为页面设置合适的页边距（0.5英寸）。

    6. 设置打印区域：每个考场的安排显示在一张A4纸上。

            现在，运行程序将生成已格式化和打印优化的Excel文件，包含每个考场的安排，并输出为设置在A4纸上的页边距和打印区域。

    运行后的结果：

    a2504e4da93e4d679a23604cde58c378.png

            这里展示了两个考场，相邻的两个考生看上去来至于不同的班级。由于各班级人数不等，有的班级人数过多，最后一个考场有几个相同班的学生连在一起。

    ad74ce27924c4aeab551c7b929c8d5ad.png

    如何解决这个问题？ 

    1. 请通过一个函数检查最后输出的结果，如果有相邻的考生来至于同一个班级，请参照前面的安排，适当的调整，全部安排，保证相邻的考生来至于不同的班级
    2.  ​
    3.  要确保没有相邻的考生来自同一个班级，我们需要一个后处理函数来检查最终的座位安排，并在发现问题时进行调整。以下是一个改进方案，它在安排考位之后，通过检查并调整相邻考生的班级来防止同一班级的考生相邻：
    4.  ​
    5.  “将相邻的学生和随后找到的另一个班级的学生交换位置”， 这个算法不完全正确。随后仍然可能是一个班级，应该是从前面已排的学生中寻找满足以下条件的记录进行调换：这个学生前后都与调整的学生班级不一样
    6.  ​
    7.  现在给出的结果，没有连续几个来至同一个班级的考生了，但还是有相邻两个来至于同一个班，请调整后，重新调用检查函数，直到不再有相邻学生来至于一个班级
    8.  ​
    9.  为了确保相邻的学生不来自同一个班级，我们可以用一个循环不断地检查并调整座位安排，直到没有相邻考生来自同一个班级为止。我们可以在`check_and_adjust_seating`函数中用一个布尔值标记调整是否完成，如果发现有相邻的学生来自同一个班级，则进行调整并再次检查。
    10.  ​
    11.  ### 改进内容:
    12.  1. 修改了`check_and_adjust_seating`函数，确保在调整座位后再一次检查是否有相邻的考生来自同一个班级。如果有相邻的考生来自同一个班级，则继续调整，直到没有相邻的考生来自同一个班级。
    13.  2. 用一个布尔值`adjusted`跟踪是否进行了调整，如果进行了调整则继续检查，否则结束循环。
    14.  ​
    15.  这样可以确保最终输出的结果中没有相邻两个考生来自同一个班级。
    16.  ​
    17.  调整后，应该反复从开始验证，最终确保最终输出的结果中没有相邻两个考生来自同一个班级，只给出调整函数

    最后结果

            看上去已经没有相邻两个考生来自同一个班级，实际上gpt只是调整记录位置，考场号和座位号还是原来的值，让gpt从新分配考场号和座位号

    1.  import pandas as pd
    2.  import random
    3.  import openpyxl
    4.  from openpyxl.styles import Font, Alignment, PatternFill, Border, Side
    5.  from openpyxl.worksheet.page import PageMargins
    6.  from datetime import datetime
    7.  ​
    8.  ​
    9.  def load_data(filename):
    10.      return pd.read_excel(filename)
    11.  ​
    12.  ​
    13.  def save_data(df, filename):
    14.      df.to_excel(filename, index=False)
    15.      format_excel(filename, df)
    16.  ​
    17.  ​
    18.  def assign_seats(df, total_halls):
    19.      grouped = df.groupby('班级')
    20.      groups = [group.sample(frac=1).reset_index(drop=True) for _, group in grouped]
    21.  ​
    22.      # Sort groups by size (descending)
    23.      groups.sort(key=lambda x: len(x), reverse=True)
    24.  ​
    25.      iterators = [iter(group.iterrows()) for group in groups]
    26.      arranged_data = []
    27.      hall_number = 1
    28.      seat_number = 1
    29.  ​
    30.      total_students = len(df)
    31.      students_per_hall = total_students // total_halls
    32.      extra_students = total_students % total_halls
    33.  ​
    34.      while iterators:
    35.          # Shuffle iterators to ensure randomness
    36.          random.shuffle(iterators)
    37.          for it in iterators[:]:
    38.              try:
    39.                  _, student = next(it)
    40.                  student_data = student.to_dict()
    41.                  student_data["考场"] = hall_number
    42.                  student_data["考号"] = f"{seat_number:02d}"
    43.                  arranged_data.append(student_data)
    44.                  seat_number += 1
    45.  ​
    46.                  # Check if seat number exceeds the allowed number of students per hall
    47.                  if seat_number > students_per_hall + (1 if hall_number <= extra_students else 0):
    48.                      hall_number += 1
    49.                      seat_number = 1
    50.                      # Reset hall number if it exceeds total halls
    51.                      if hall_number > total_halls:
    52.                          hall_number = 1
    53.              except StopIteration:
    54.                  iterators.remove(it)
    55.  ​
    56.      return arranged_data
    57.  ​
    58.  ​
    59.  def check_and_adjust_seating(arranged_data):
    60.      def has_adjacent_same_class(data):
    61.          # Check if there are any adjacent students from the same class
    62.          for i in range(len(data) - 1):
    63.              if data[i]['班级'] == data[i + 1]['班级']:
    64.                  return i
    65.          return -1
    66.  ​
    67.      def find_valid_swap(index, data):
    68.          # Find a valid swap by checking front part of the list before the index
    69.          current_class = data[index]['班级']
    70.          for j in range(len(data)):
    71.              if j != index and data[j]['班级'] != current_class:
    72.                  # Ensure new surrounding are valid
    73.                  if (j == 0 or data[j - 1]['班级'] != current_class) and (
    74.                          j == len(data) - 1 or data[j + 1]['班级'] != current_class):
    75.                      return j
    76.          return -1
    77.  ​
    78.      swap_operations = []
    79.      while True:
    80.          index = has_adjacent_same_class(arranged_data)
    81.          if index == -1:
    82.              break  # No adjacent students from the same class
    83.          swap_index = find_valid_swap(index + 1, arranged_data)
    84.          if swap_index == -1:
    85.              raise ValueError("Cannot find a valid swap to adjust the seating arrangement.")
    86.          # Record the swap operation
    87.          swap_operations.append((index + 1, swap_index))
    88.          # Swap the adjacent student with the valid student
    89.          arranged_data[index + 1], arranged_data[swap_index] = arranged_data[swap_index], arranged_data[index + 1]
    90.  ​
    91.      # Additional check and swap if any, continue from the start
    92.      while has_adjacent_same_class(arranged_data) != -1:
    93.          index = has_adjacent_same_class(arranged_data)
    94.          if index != -1:
    95.              swap_index = find_valid_swap(index, arranged_data)
    96.              if swap_index != -1:
    97.                  # Record the swap operation
    98.                  swap_operations.append((index, swap_index))
    99.                  arranged_data[index], arranged_data[swap_index] = arranged_data[swap_index], arranged_data[index]
    100.  ​
    101.      return arranged_data, swap_operations
    102.  ​
    103.  ​
    104.  def reassign_seats(arranged_data, total_halls):
    105.      hall_number = 1
    106.      seat_number = 1
    107.      total_students = len(arranged_data)
    108.      students_per_hall = total_students // total_halls
    109.      extra_students = total_students % total_halls
    110.  ​
    111.      for i, student in enumerate(arranged_data):
    112.          student['考场'] = hall_number
    113.          student['考号'] = f"{seat_number:02d}"
    114.          seat_number += 1
    115.  ​
    116.          if seat_number > students_per_hall + (1 if hall_number <= extra_students else 0):
    117.              hall_number += 1
    118.              seat_number = 1
    119.              if hall_number > total_halls:
    120.                  hall_number = 1
    121.  ​
    122.      return arranged_data
    123.  ​
    124.  ​
    125.  def format_excel(filename, df):
    126.      wb = openpyxl.load_workbook(filename)
    127.      ws = wb.active
    128.  ​
    129.      # 设置标题行的样式
    130.      for cell in ws[1]:
    131.          cell.font = Font(bold=True, color="FFFFFF")
    132.          cell.fill = PatternFill(start_color="4F81BD", end_color="4F81BD", fill_type="solid")
    133.          cell.alignment = Alignment(horizontal="center", vertical="center")
    134.  ​
    135.      # 自动调整列宽
    136.      for col in ws.columns:
    137.          max_length = 0
    138.          column = col[0].column_letter
    139.          for cell in col:
    140.              try:
    141.                  if len(str(cell.value)) > max_length:
    142.                      max_length = len(str(cell.value))
    143.              except:
    144.                  pass
    145.          adjusted_width = (max_length + 20)
    146.          ws.column_dimensions[column].width = adjusted_width
    147.  ​
    148.      # 设置行高（适当调整以适应A4纸）
    149.      for row in range(1, ws.max_row + 1):
    150.          ws.row_dimensions[row].height = 23  # 行高设置为23像素
    151.  ​
    152.      # 设置单元格边框和对齐方式
    153.      thin_border = Border(left=Side(style='thin'), right=Side(style='thin'), top=Side(style='thin'),
    154.                           bottom=Side(style='thin'))
    155.      for row in ws.iter_rows(min_row=2, max_row=ws.max_row, min_col=1, max_col=ws.max_column):
    156.          for cell in row:
    157.              cell.border = thin_border
    158.              cell.alignment = Alignment(horizontal="center", vertical="center")
    159.  ​
    160.      # 设置页边距
    161.      ws.page_margins = PageMargins(left=0.5, right=0.5, top=0.5, bottom=0.5)
    162.  ​
    163.      hall_groups = df.groupby('考场')
    164.  ​
    165.      # 设置重复打印标题行
    166.      ws.print_title_rows = '1:1'
    167.      ws.print_title_cols = None
    168.  ​
    169.      # 逐个考场设置打印区域
    170.      for hall_number, hall_df in hall_groups:
    171.          min_row = hall_df.index[0] + 2  # 加2以跳过标题行和数据框索引偏移
    172.          max_row = hall_df.index[-1] + 2  # 加2以跳过标题行和数据框索引偏移
    173.  ​
    174.          # 初始化 print area, configuration of page settings for each hall
    175.          ws.print_area = f"A1:E{max_row}"
    176.  ​
    177.          # 配置页面设置
    178.          ws.page_setup.orientation = 'portrait'
    179.          ws.page_setup.paperSize = ws.PAPERSIZE_A4
    180.          ws.page_setup.fitToPage = True
    181.          ws.page_setup.fitToWidth = 1
    182.          ws.page_setup.fitToHeight = False  # 允许纵向页面数自动扩展
    183.  ​
    184.      wb.save(filename)
    185.  ​
    186.  ​
    187.  def main():
    188.      input_filename = "11-15.xlsx"  # 修改为学生信息的电子表格名
    189.      total_halls = 9  # 修改为考场数
    190.      df = load_data(input_filename)
    191.      arranged_students = assign_seats(df, total_halls)
    192.      adjusted_students, swap_operations = check_and_adjust_seating(arranged_students)
    193.      final_students = reassign_seats(adjusted_students, total_halls)
    194.      arranged_df = pd.DataFrame(final_students)
    195.      current_time = datetime.now().strftime("%Y%m%d_%H%M%S")
    196.      output_filename = f"考场安排结果_{current_time}.xlsx"
    197.      save_data(arranged_df, output_filename)
    198.      print(f"已成功生成文件：{output_filename}")
    199.  ​
    200.  ​
    201.  if __name__ == "__main__":
    202.      main()

     ​最后在Microsoft Excel 中检测相邻单元格值是否相等

    1. 选择数据区域：

      • 选择你想要检查的单元格区域。例如，假设你要检查从A2到A100的单元格。

    2. 打开条件格式：

      • 在Excel的“开始”选项卡上，点击“条件格式”。

    3. 创建新的规则：

      • 在“条件格式”下拉菜单中，选择“新建规则”。

    4. 使用公式来检测：

      • 在“选择规则类型”窗口，选择“使用公式确定要设置格式的单元格”。

      • 在“为符合此公式的值设置格式”框中输入适当的公式。例如，如果你检查A列中的相邻单元格，可以使用公式：

         =A2=A1

      • 然后你可以设置条件匹配时应用的格式，如填充颜色或字体颜色等。

    5. 应用条件格式：

      • 设置好格式后，点击“确定”。这个操作将会在指定区域内自动应用条件格式。如果两个相邻单元格的值相同，它们将会被醒目地突出显示。

    18ff496f866340fba7aad911d547df6f.png

    程序已完全符合要求。

    食用方法

    确保你安装了所需库：

     pip install pandas openpyxl numpy

    1、表结构

    136b48d33f46485da1f237f794cd2e28.png

    2、修改input_filename的值 ，此变量存储的是学生信息的电子表格名，扩展名为.xlsx

    3、修改total_halls的值，此变量存储的是考场个数

    4、如果要分类安排考场，可将各层次学生分别建立对应的电子表格文件。

    运行程序后，将生成一个已经格式化美化好的Excel文件。

    如果有好的建议欢迎交流！！！，食用过程中错误请评论区给出！！！

     

     

  • 相关阅读:
    Xilinx FPGA 7系列 GTX/GTH Transceivers (2)--IBERT
    [C++] RBTree红黑树的模拟实现
    sap业务伙伴分组后台配置的问题
    使用 Bitnami PostgreSQL Docker 镜像快速设置流复制集群
    解密Elasticsearch：深入探究这款搜索和分析引擎
    Spring Cloud Alibaba实现服务的无损下线功能
    什么是屏蔽机房？
    纳米/聚合物/化合物/无机材料/多肽/多糖修饰聚苯乙烯微球的研究
    Maven问题相关 1 存在jar 却无法映射
    C/C++ sizeof运算符的使用
  • 原文地址：https://blog.csdn.net/chinagaobo/article/details/139062542