कैसे मुद्रित करने के लिए "डॉट्स" (या अन्य तरह की प्रतिक्रिया) लेखन के समय में एक फ़ाइल अजगर?

requests.get डिफ़ॉल्ट रूप डाउनलोड की संपूर्णता का अनुरोध किया गया संसाधन से पहले यह हो जाता है तुम वापस करने के लिए. बहरहाल, यह एक वैकल्पिक तर्क streamअनुमति देता है , जो करने के लिए आप का आह्वान .iter_content या .iter_lines पर Response वस्तु. यह अनुमति देता है आप करने के लिए कार्रवाई ले लो हर N बाइट्स (या के रूप में प्रत्येक खंड के डेटा आता है), या हर लाइन, क्रमशः. कुछ इस तरह:

chunks = []
chunk_size = 16384     # 16Kb chunks
# alternately
# chunk_size = None    # whenever a chunk arrives
res = requests.get(url_to_file, stream=True)
for chunk in res.iter_content(chunk_size):
    chunks.append(chunk)
    print(".", end="")
data = b''.join(chunks)

यह अभी भी ब्लॉक, हालांकि, तो और कुछ नहीं हो रहा होगा । यदि आप और अधिक चाहते हैं जावास्क्रिप्ट के शैली, प्रति Grismar की टिप्पणी, आप चाहिए के तहत चलाने के लिए अजगर की async पाश । उस मामले में, मैं सुझाव है कि का उपयोग कर aiohttp के बजाय requests, के रूप में यह है के साथ बनाया async शैली के मन में है ।

यहाँ एक संस्करण को डाउनलोड करेगा कि एक फ़ाइल के bytearray में एक अलग धागा ।

के रूप में उल्लेख किया है, अन्य के जवाब और टिप्पणियों के लिए, वहाँ रहे हैं अन्य alternativs है कि विकसित कर रहे हैं के साथ async के संचालन के मन में है, तो पढ़ने के लिए नहीं बहुत ज्यादा में जाने के लिए निर्णय के साथ threading, यह बस को प्रदर्शित करने के लिए अवधारणा (और क्योंकि सुविधा के बाद से, यह के साथ आता है अजगर).

में नीचे दिए गए कोड है, अगर इस फाइल के आकार में जाना जाता है, प्रत्येक . अनुरूप होगा करने के लिए 1%. एक बोनस के रूप में, डाउनलोड किया है और कुल बाइट्स की संख्या में मुद्रित किया जाएगा के शुरू में लाइन की तरह (1234 B / 1234567 B). अगर आकार ज्ञात नहीं है, तो fallback समाधान है करने के लिए प्रत्येक . का प्रतिनिधित्व एक हिस्सा.

import requests
import threading


def download_file(url: str):
    headers = {"<some_key>": "<some_value>"}
    data = bytearray()
    with requests.get(url, headers=headers, stream=True) as request:
        if file_size := request.headers.get("Content-Length"):
            file_size = int(file_size)
        else:
            file_size = None
        received = 0
        for chunk in request.iter_content(chunk_size=2**15):
            received += len(chunk)
            data += chunk
            try:
                num_dots = int(received * 100 / file_size)
                print(
                    f"({received} B/{file_size} B) "
                    + "." * num_dots, end="\r"
                )
            except TypeError:
                print(".", end="")
        print("\nDone!")

url = "<some_url>"
thread = threading.Thread(target=download_file, args=(url,))
thread.start()
# Do something in the meantime
thread.join()

ध्यान में रखना है कि मैं बाहर छोड़ दिया ताला खिलाफ की रक्षा के लिए एक साथ उपयोग करने के लिए stdout करने के लिए शोर को कम. मैं भी बाहर छोड़ दिया लेखन bytarray करने के लिए फाइल के अंत में (या लेखन की मात्रा करने के लिए फाइल के रूप में वे प्राप्त कर रहे हैं, तो फ़ाइल बहुत बड़ी है), लेकिन मन में रखने के लिए हो सकता है कि आप उपयोग करना चाहते हैं के लिए एक ताला है कि के रूप में अच्छी तरह से अगर आप पढ़ सकते हैं और/या लिखने के लिए एक ही फ़ाइल के किसी अन्य हिस्से में अपनी स्क्रिप्ट.