reader = PdfReader(pdf_path)
page_count = len(reader.pages)

 for pdf in pdf_files:
                    language = pdf.split('_')[1][0]  # 提取语言标识
                    pdf_path = os.path.join(resolution_path, pdf)
                    reader = PdfReader(pdf_path)
                    page_count = len(reader.pages)

import os
import requests
from concurrent.futures import ThreadPoolExecutor
import time
# 决议编号范围和语言版本
start_number = 1738
end_number = 1652
languages = ["A", "C", "E", "F", "R", "S"]
base_url = "https://daccess-ods.un.org/access.nsf/Get?OpenAgent&DS=s/res/{}&Lang={}"

def download_resolution(number):
    resolution_folder = f"UN_Resolutions/{number}"
    os.makedirs(resolution_folder, exist_ok=True)

    for lang in languages:
        url = base_url.format(f"{number}(2006)", lang)#换成要下载的年份
        try:
            response = requests.get(url, proxies={
                "http": "http://127.0.0.1:7890",
                "https": "http://127.0.0.1:7890"
            })
            response.raise_for_status()  # 检查请求是否成功

            file_name = f"{resolution_folder}/{number}_{lang}.pdf"
            with open(file_name, "wb") as file:
                file.write(response.content)
            print(f"{file_name} 下载成功！")
        except requests.exceptions.RequestException as e:
            print(f"{number} - {lang} 版本下载失败：", e)
            print(url)

# 使用线程池下载决议
with ThreadPoolExecutor(max_workers=25) as executor:
    executor.map(download_resolution, range(start_number, end_number - 1, -1))
    time.sleep(1)

import os
from PyPDF2 import PdfReader

def count_pages(resolutions_folder):
    overall_min_counts = {}
    total_resolutions = 0
    non_chinese_min_resolutions = []
    max_chinese_pages = 0
    max_chinese_resolution = None
    longest_resolution = None
    longest_page_count = 0
    total_language_pages = {}
    language_count = {}
    max_diff = 0

    language_names = {
        'A': '阿拉伯语',
        'C': '中文',
        'E': '英语',
        'F': '法语',
        'R': '俄语',
        'S': '西班牙语'
    }

    for resolution in os.listdir(resolutions_folder):
        resolution_path = os.path.join(resolutions_folder, resolution)
        if os.path.isdir(resolution_path):
            pdf_files = [f for f in os.listdir(resolution_path) if f.endswith('.pdf')]
            if len(pdf_files) == 6:
                total_resolutions += 1
                language_page_count = {}
                
                for pdf in pdf_files:
                    language = pdf.split('_')[1][0]  # 提取语言标识
                    pdf_path = os.path.join(resolution_path, pdf)
                    reader = PdfReader(pdf_path)
                    page_count = len(reader.pages)
                    
                    if language not in language_page_count:
                        language_page_count[language] = 0
                    language_page_count[language] += page_count

                    # 累加语言总页数和计数
                    if language not in total_language_pages:
                        total_language_pages[language] = 0
                        language_count[language] = 0
                    total_language_pages[language] += page_count
                    language_count[language] += 1

                # 更新最长决议
                total_pages = sum(language_page_count.values())
                if total_pages > longest_page_count:
                    longest_page_count = total_pages
                    longest_resolution = resolution

                # 找出最小页数和出现的语言
                min_count = min(language_page_count.values())
                min_languages = [lang for lang, count in language_page_count.items() if count == min_count]

                # 如果最小页数的语言不唯一，跳过该决议
                if len(min_languages) > 1:
                    continue

                # 唯一的最小页数语言
                min_language = min_languages[0]

                # 输出最少页数语言的信息
                print(f"决议 {resolution} 中页数最少的语言是 {language_names[min_language]}，总页数为 {min_count}。")

                # 更新最少页数统计
                if min_language not in overall_min_counts:
                    overall_min_counts[min_language] = 0
                overall_min_counts[min_language] += 1

                # 检查中文是否为最少页数
                if min_language != 'C':
                    non_chinese_min_resolutions.append(resolution)
                else:
                    # 找出第二少的语言页数
                    sorted_counts = sorted(language_page_count.values())
                    if len(sorted_counts) > 1:
                        second_least_count = sorted_counts[1]
                        diff = min_count - second_least_count
                        print(f"决议 {resolution} 中文页数与第二少语言的差值为 {diff}。")
                        max_diff = max(max_diff, diff)

                # 记录中文页数最多的决议
                if 'C' in language_page_count:
                    if language_page_count['C'] > max_chinese_pages:
                        max_chinese_pages = language_page_count['C']
                        max_chinese_resolution = resolution

    # 输出总统计
    print(f"\n 共计统计了 {total_resolutions} 份决议。")
    for language, count in overall_min_counts.items():
        print(f"{language_names[language]} 页数最少的决议有 {count} 份。")

    # 输出中文页数不是最少的决议
    if non_chinese_min_resolutions:
        print("以下决议的中文页数不是最少：")
        for res in non_chinese_min_resolutions:
            print(res)

    # 输出中文页数最多的决议
    if max_chinese_resolution:
        print(f"中文页数最多的决议是 {max_chinese_resolution}，总页数为 {max_chinese_pages}。")
        print(f"中文页数与第二少语言的最大差值为 {max_diff}。")

    # 输出最长的决议
    if longest_resolution:
        print(f"最长的决议是 {longest_resolution}，总页数为 {longest_page_count}。")

    # 计算并输出各语言的平均页数
    print("\n 各语言的平均页数：")
    for language, total_pages in total_language_pages.items():
        average_pages = total_pages / language_count[language]
        print(f"{language_names[language]}：{average_pages:.2f} 页")

# 调用函数
count_pages('UN_Resolutions')