urllib.request.po

# Copyright (C) 2001-2024, Python Software Foundation
# This file is distributed under the same license as the Python package.
#
# Translators:
# Adrian Liaw <adrianliaw2000@gmail.com>, 2018
msgid ""
msgstr ""
"Project-Id-Version: Python 3.13\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-11-25 00:14+0000\n"
"PO-Revision-Date: 2022-04-21 17:59+0800\n"
"Last-Translator: Jordan Su <newjordansu1126@gmail.com>\n"
"Language-Team: Chinese - TAIWAN (https://github.com/python/python-docs-zh-"
"tw)\n"
"Language: zh_TW\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"
"X-Generator: Poedit 3.0.1\n"

#: ../../library/urllib.request.rst:2
msgid ":mod:`!urllib.request` --- Extensible library for opening URLs"
msgstr ":mod:`!urllib.request` --- 用來開啟 URLs 的可擴充函式庫"

#: ../../library/urllib.request.rst:11
msgid "**Source code:** :source:`Lib/urllib/request.py`"
msgstr "**原始碼：**\\ :source:`Lib/urllib/request.py`"

#: ../../library/urllib.request.rst:15
msgid ""
"The :mod:`urllib.request` module defines functions and classes which help in "
"opening URLs (mostly HTTP) in a complex world --- basic and digest "
"authentication, redirections, cookies and more."
msgstr ""
":mod:`urllib.request` module（模組）定義了一些函式與 class（類別）用以開啟 "
"URLs（大部分是 HTTP），並處理各式複雜情況如：basic 驗證與 digest 驗證、重新導"
"向、cookies。"

#: ../../library/urllib.request.rst:21
msgid ""
"The `Requests package <https://requests.readthedocs.io/en/master/>`_ is "
"recommended for a higher-level HTTP client interface."
msgstr ""
"有關於更高階的 HTTP 用戶端介面，推薦使用 `Requests 套件 <https://requests."
"readthedocs.io/en/master/>`_。"

#: ../../library/urllib.request.rst:26
msgid ""
"On macOS it is unsafe to use this module in programs using :func:`os.fork` "
"because the :func:`getproxies` implementation for macOS uses a higher-level "
"system API. Set the environment variable ``no_proxy`` to ``*`` to avoid this "
"problem (e.g. ``os.environ[\"no_proxy\"] = \"*\"``)."
msgstr ""

#: ../../includes/wasm-notavail.rst:3
msgid "Availability"
msgstr ""

#: ../../includes/wasm-notavail.rst:5
msgid ""
"This module does not work or is not available on WebAssembly. See :ref:`wasm-"
"availability` for more information."
msgstr ""
"此模組在 WebAssembly 平台上不起作用或無法使用。更多資訊請參閱 :ref:`wasm-"
"availability`。"

#: ../../library/urllib.request.rst:34
msgid "The :mod:`urllib.request` module defines the following functions:"
msgstr ":mod:`urllib.request` module 定義下列函式："

#: ../../library/urllib.request.rst:39
msgid ""
"Open *url*, which can be either a string containing a valid, properly "
"encoded URL, or a :class:`Request` object."
msgstr ""
"打開 *url*，其值可以是一個包含有效且適當編碼 URL 的字串或是一個 :class:"
"`Request` 物件。"

#: ../../library/urllib.request.rst:42
msgid ""
"*data* must be an object specifying additional data to be sent to the "
"server, or ``None`` if no such data is needed.  See :class:`Request` for "
"details."
msgstr ""
"*data* 必須是一個包含傳送給伺服器額外資料的物件，若不需要傳送額外資料則指定"
"為 ``None``。更多細節請見 :class:`Request`。"

#: ../../library/urllib.request.rst:46
msgid ""
"urllib.request module uses HTTP/1.1 and includes ``Connection:close`` header "
"in its HTTP requests."
msgstr ""
"urllib.request module 使用 HTTP/1.1 並包含 ``Connection:close`` header（標"
"頭）在其 HTTP 請求中。"

#: ../../library/urllib.request.rst:49
msgid ""
"The optional *timeout* parameter specifies a timeout in seconds for blocking "
"operations like the connection attempt (if not specified, the global default "
"timeout setting will be used).  This actually only works for HTTP, HTTPS and "
"FTP connections."
msgstr ""
"透過選擇性參數 *timeout* 來指定 blocking operations（阻塞性操作，如：嘗試連"
"接）的 timeout（超時時間），以秒為單位。若沒有指定值，則會使用全域預設超時時"
"間設定。實際上，此參數僅作用於 HTTP、HTTPS 以及 FTP 的連接。"

#: ../../library/urllib.request.rst:54
msgid ""
"If *context* is specified, it must be a :class:`ssl.SSLContext` instance "
"describing the various SSL options. See :class:`~http.client."
"HTTPSConnection` for more details."
msgstr ""
"若 *context* 有被指定時，它必須是一個 :class:`ssl.SSLContext` 的實例並描述著"
"各種 SSL 選項。更多細節請見 :class:`~http.client.HTTPSConnection`。"

#: ../../library/urllib.request.rst:58
msgid ""
"This function always returns an object which can work as a :term:`context "
"manager` and has the properties *url*, *headers*, and *status*. See :class:"
"`urllib.response.addinfourl` for more detail on these properties."
msgstr ""
"這個函式總是回傳一個可作為 :term:`context manager` 使用的物件，並有著特性 "
"(property) *url*、*headers* 與 *status*。欲知更多這些特性細節請參見 :class:"
"`urllib.response.addinfourl`。"

#: ../../library/urllib.request.rst:62
msgid ""
"For HTTP and HTTPS URLs, this function returns a :class:`http.client."
"HTTPResponse` object slightly modified. In addition to the three new methods "
"above, the msg attribute contains the same information as the :attr:`~http."
"client.HTTPResponse.reason` attribute --- the reason phrase returned by "
"server --- instead of the response headers as it is specified in the "
"documentation for :class:`~http.client.HTTPResponse`."
msgstr ""
"對於 HTTP 與 HTTPS 的 URLs，這個函式回傳一個稍有不同的 :class:`http.client."
"HTTPResponse` 物件。除了上述提到的三個方法外，另有 msg 屬性並有著與 :attr:"
"`~http.client.HTTPResponse.reason` 相同的資訊 --- 由伺服器回傳的原因敘述 "
"(reason phrase)，而不是在 :class:`~http.client.HTTPResponse` 文件中提到的回"
"應 headers。"

#: ../../library/urllib.request.rst:70
msgid ""
"For FTP, file, and data URLs and requests explicitly handled by legacy :"
"class:`URLopener` and :class:`FancyURLopener` classes, this function returns "
"a :class:`urllib.response.addinfourl` object."
msgstr ""
"對於 FTP、檔案、資料的 URLs、以及那些由傳統 classes :class:`URLopener` 與 :"
"class:`FancyURLopener` 所處理的請求，這個函式會回傳一個 :class:`urllib."
"response.addinfourl` 物件。"

#: ../../library/urllib.request.rst:74
msgid "Raises :exc:`~urllib.error.URLError` on protocol errors."
msgstr "當遇到協定上的錯誤時會引發 :exc:`~urllib.error.URLError`。"

#: ../../library/urllib.request.rst:76
msgid ""
"Note that ``None`` may be returned if no handler handles the request (though "
"the default installed global :class:`OpenerDirector` uses :class:"
"`UnknownHandler` to ensure this never happens)."
msgstr ""
"請注意若沒有 handler 處理請求時，``None`` 值將會被回傳。（即使有預設的全域類"
"別 :class:`OpenerDirector` 使用 :class:`UnknownHandler` 來確保這種情況不會發"
"生）"

#: ../../library/urllib.request.rst:80
msgid ""
"In addition, if proxy settings are detected (for example, when a ``*_proxy`` "
"environment variable like :envvar:`!http_proxy` is set), :class:"
"`ProxyHandler` is default installed and makes sure the requests are handled "
"through the proxy."
msgstr ""
"另外，若有偵測到代理服務的設定（例如當 ``*_proxy`` 環境變數像是：:envvar:!"
"http_proxy` 有被設置時），:class:`ProxyHandler` 會被預設使用以確保請求有透過"
"代理服務來處理。"

#: ../../library/urllib.request.rst:85
msgid ""
"The legacy ``urllib.urlopen`` function from Python 2.6 and earlier has been "
"discontinued; :func:`urllib.request.urlopen` corresponds to the old "
"``urllib2.urlopen``.  Proxy handling, which was done by passing a dictionary "
"parameter to ``urllib.urlopen``, can be obtained by using :class:"
"`ProxyHandler` objects."
msgstr ""
"Python 2.6 或更早版本的遺留函式 ``urllib.urlopen`` 已經不再被維護；新函式 :"
"func:`urllib.request.urlopen` 對應到舊函式 ``urllib2.urlopen``。有關代理服務"
"的處理，以往是透過傳遞 dictionary（字典）參數給 ``urllib.urlopen`` 來取得的，"
"現在則可以透過 :class:`ProxyHandler` 物件來取得。"

#: ../../library/urllib.request.rst:91 ../../library/urllib.request.rst:93
msgid ""
"The default opener raises an :ref:`auditing event <auditing>` ``urllib."
"Request`` with arguments ``fullurl``, ``data``, ``headers``, ``method`` "
"taken from the request object."
msgstr ""
"預設的 opener 會觸發一個 :ref:`auditing event <auditing>` ``urllib.Request`` "
"與其從請求物件中所獲得的引數 ``fullurl``、``data``、``headers``、``method``。"

#: ../../library/urllib.request.rst:97
msgid "*cafile* and *capath* were added."
msgstr "新增 *cafile* 與 *capath*。"

#: ../../library/urllib.request.rst:100
msgid ""
"HTTPS virtual hosts are now supported if possible (that is, if :const:`ssl."
"HAS_SNI` is true)."
msgstr ""
"HTTPS 虛擬主機 (virtual hosts) 現已支援，只要 :const:`ssl.HAS_SNI` 的值為 "
"true。"

#: ../../library/urllib.request.rst:103
msgid "*data* can be an iterable object."
msgstr "*data* 可以是一個可疊代物件。"

#: ../../library/urllib.request.rst:105
msgid "*cadefault* was added."
msgstr "*cadefault* 被新增。"

#: ../../library/urllib.request.rst:108
msgid "*context* was added."
msgstr "*context* 被新增。"

#: ../../library/urllib.request.rst:111
msgid ""
"HTTPS connection now send an ALPN extension with protocol indicator "
"``http/1.1`` when no *context* is given. Custom *context* should set ALPN "
"protocols with :meth:`~ssl.SSLContext.set_alpn_protocols`."
msgstr ""
"當 *context* 沒有被指定時，HTTPS 連線現在會傳送一個帶有協定指示器 "
"``http/1.1`` 的 ALPN 擴充 (extension)。自訂的 *context* 應該利用 :meth:`~ssl."
"SSLContext.set_alpn_protocols` 來自行設定 ALPN 協定。"

#: ../../library/urllib.request.rst:116
msgid ""
"Remove *cafile*, *capath* and *cadefault* parameters: use the *context* "
"parameter instead."
msgstr ""

#: ../../library/urllib.request.rst:123
msgid ""
"Install an :class:`OpenerDirector` instance as the default global opener. "
"Installing an opener is only necessary if you want urlopen to use that "
"opener; otherwise, simply call :meth:`OpenerDirector.open` instead of :func:"
"`~urllib.request.urlopen`.  The code does not check for a real :class:"
"`OpenerDirector`, and any class with the appropriate interface will work."
msgstr ""
"安裝一個 :class:`OpenerDirector` 實例作為預設的全域 opener。僅在當你想要讓 "
"urlopen 使用該 opener 時安裝一個 opener，否則的話應直接呼叫 :meth:"
"`OpenerDirector.open` 而非 :func:`~urllib.request.urlopen`。程式碼不會檢查 "
"class 是否真的為 :class:`OpenerDirector`，而是任何具有正確介面的 class 都能適"
"用。"

#: ../../library/urllib.request.rst:133
msgid ""
"Return an :class:`OpenerDirector` instance, which chains the handlers in the "
"order given. *handler*\\s can be either instances of :class:`BaseHandler`, "
"or subclasses of :class:`BaseHandler` (in which case it must be possible to "
"call the constructor without any parameters).  Instances of the following "
"classes will be in front of the *handler*\\s, unless the *handler*\\s "
"contain them, instances of them or subclasses of them: :class:`ProxyHandler` "
"(if proxy settings are detected), :class:`UnknownHandler`, :class:"
"`HTTPHandler`, :class:`HTTPDefaultErrorHandler`, :class:"
"`HTTPRedirectHandler`, :class:`FTPHandler`, :class:`FileHandler`, :class:"
"`HTTPErrorProcessor`."
msgstr ""
"回傳一個 :class:`OpenerDirector` 實例，以給定的順序把 handlers 串接起來。"
"*handler*\\s 可以是 :class:`BaseHandler` 的實例，亦或是 :class:`BaseHandler` "
"的 subclasses（這個情況下必須有不帶參數的建構函式能夠被呼叫）。以下 classes "
"的實例順位會在 *handler*\\s 之前，除非 *handler*\\s 已經包含它們，是它們的實"
"例，或是它們的 subclasses：:class:`ProxyHandler`\\ （如果代理服務設定被偵測"
"到）、:class:`UnknownHandler`、:class:`HTTPHandler`、:class:"
"`HTTPDefaultErrorHandler`、:class:`HTTPRedirectHandler`、:class:"
"`FTPHandler`、:class:`FileHandler`、:class:`HTTPErrorProcessor`。"

#: ../../library/urllib.request.rst:143
msgid ""
"If the Python installation has SSL support (i.e., if the :mod:`ssl` module "
"can be imported), :class:`HTTPSHandler` will also be added."
msgstr ""
"如果 Python 安裝時已帶有 SSL 支援（如果 :mod:`ssl` module 能夠被 import），"
"則 :class:`HTTPSHandler` 也在上述 class 之中。"

#: ../../library/urllib.request.rst:146
msgid ""
"A :class:`BaseHandler` subclass may also change its :attr:`handler_order` "
"attribute to modify its position in the handlers list."
msgstr ""
"一個 :class:`BaseHandler` 的 subclass 可能透過改變其 :attr:`handler_order` 屬"
"性來調整它在 handlers list 中的位置。"

#: ../../library/urllib.request.rst:152
msgid ""
"Convert the given local path to a ``file:`` URL. This function uses :func:"
"`~urllib.parse.quote` function to encode the path. For historical reasons, "
"the return value omits the ``file:`` scheme prefix. This example shows the "
"function being used on Windows::"
msgstr ""

#: ../../library/urllib.request.rst:157
msgid ""
">>> from urllib.request import pathname2url\n"
">>> path = 'C:\\\\Program Files'\n"
">>> 'file:' + pathname2url(path)\n"
"'file:///C:/Program%20Files'"
msgstr ""
">>> from urllib.request import pathname2url\n"
">>> path = 'C:\\\\Program Files'\n"
">>> 'file:' + pathname2url(path)\n"
"'file:///C:/Program%20Files'"

#: ../../library/urllib.request.rst:165
msgid ""
"Convert the given ``file:`` URL to a local path. This function uses :func:"
"`~urllib.parse.unquote` to decode the URL. For historical reasons, the given "
"value *must* omit the ``file:`` scheme prefix. This example shows the "
"function being used on Windows::"
msgstr ""

#: ../../library/urllib.request.rst:170
msgid ""
">>> from urllib.request import url2pathname\n"
">>> url = 'file:///C:/Program%20Files'\n"
">>> url2pathname(url.removeprefix('file:'))\n"
"'C:\\\\Program Files'"
msgstr ""
">>> from urllib.request import url2pathname\n"
">>> url = 'file:///C:/Program%20Files'\n"
">>> url2pathname(url.removeprefix('file:'))\n"
"'C:\\\\Program Files'"

#: ../../library/urllib.request.rst:177
msgid ""
"This helper function returns a dictionary of scheme to proxy server URL "
"mappings. It scans the environment for variables named ``<scheme>_proxy``, "
"in a case insensitive approach, for all operating systems first, and when it "
"cannot find it, looks for proxy information from System Configuration for "
"macOS and Windows Systems Registry for Windows. If both lowercase and "
"uppercase environment variables exist (and disagree), lowercase is preferred."
msgstr ""
"這個輔助函式 (helper function) 回傳一個代理伺服器 URL mappings（對映）的 "
"dictionary。在所有的作業系統中，它首先掃描環境中有著 ``<scheme>_proxy`` 名稱"
"的變數（忽略大小寫的），如果找不到的話就會在 macOS 中的系統設定 (System "
"Configuration) 或是 Windows 系統中的 Windows Systems Registry 尋找代理服務設"
"定。如果大小寫的環境變數同時存在且值有不同，小寫的環境變數會被選用。"

#: ../../library/urllib.request.rst:187
msgid ""
"If the environment variable ``REQUEST_METHOD`` is set, which usually "
"indicates your script is running in a CGI environment, the environment "
"variable ``HTTP_PROXY`` (uppercase ``_PROXY``) will be ignored. This is "
"because that variable can be injected by a client using the \"Proxy:\" HTTP "
"header. If you need to use an HTTP proxy in a CGI environment, either use "
"``ProxyHandler`` explicitly, or make sure the variable name is in lowercase "
"(or at least the ``_proxy`` suffix)."
msgstr ""
"如果環境變數 ``REQUEST_METHOD`` 有被設置（通常這代表著你的 script 是運行在一"
"個共用閘道介面 (CGI) 環境中），那麼環境變數 ``HTTP_PROXY`` （大寫的 "
"``_PROXY``）將被忽略。這是因為變數可以透過使用 \"Proxy:\" HTTP header 被注"
"入。如果需要在共用閘道介面環境中使用 HTTP 代理服務，可以明確使用 "
"``ProxyHandler``，亦或是確認變數名稱是小寫的（或至少 ``_proxy`` 後綴是小寫"
"的）。"

#: ../../library/urllib.request.rst:196
msgid "The following classes are provided:"
msgstr "提供了以下的 classes："

#: ../../library/urllib.request.rst:200
msgid "This class is an abstraction of a URL request."
msgstr "這個 class 是一個 URL 請求的抽象 class。"

#: ../../library/urllib.request.rst:202
msgid "*url* should be a string containing a valid, properly encoded URL."
msgstr "*url* 是一個包含有效且適當編碼的 URL 字串。"

#: ../../library/urllib.request.rst:204
msgid ""
"*data* must be an object specifying additional data to send to the server, "
"or ``None`` if no such data is needed.  Currently HTTP requests are the only "
"ones that use *data*.  The supported object types include bytes, file-like "
"objects, and iterables of bytes-like objects. If no ``Content-Length`` nor "
"``Transfer-Encoding`` header field has been provided, :class:`HTTPHandler` "
"will set these headers according to the type of *data*.  ``Content-Length`` "
"will be used to send bytes objects, while ``Transfer-Encoding: chunked`` as "
"specified in :rfc:`7230`, Section 3.3.1 will be used to send files and other "
"iterables."
msgstr ""
"*data* 必須是一個包含要送到伺服器的附加資料的物件，若不需帶附加資料則其值應"
"為 ``None``。目前 HTTP 請求是唯一有使用 *data* 參數的，其支援的物件型別包含位"
"元組、類檔案物件 (file-like objects)、以及可疊代的類位元組串物件 (bytes-like "
"objects)。如果沒有提供 ``Content-Length`` 及 ``Transfer-Encoding`` headers 欄"
"位，:class:`HTTPHandler` 將會根據 *data* 的型別設置這些 header。``Content-"
"Length`` 會被用來傳送位元組串物件，而 :rfc:`7230` 章節 3.3.1 所定義的 "
"``Transfer-Encoding: chunked`` 則會被用來傳送檔案或是其它可疊代物件 "
"(iterables)。"

#: ../../library/urllib.request.rst:214
msgid ""
"For an HTTP POST request method, *data* should be a buffer in the standard :"
"mimetype:`application/x-www-form-urlencoded` format.  The :func:`urllib."
"parse.urlencode` function takes a mapping or sequence of 2-tuples and "
"returns an ASCII string in this format. It should be encoded to bytes before "
"being used as the *data* parameter."
msgstr ""
"對於一個 HTTP POST 請求方法，*data* 應為一個標準 :mimetype:`application/x-"
"www-form-urlencoded` 格式的 buffer。:func:`urllib.parse.urlencode` 方法接受一"
"個 mapping 或是 sequence（序列）的 2-tuples，並回傳一個對應格式的 ASCII 字"
"串。在被作為 *data* 參數前它應該被編碼成位元組串。"

#: ../../library/urllib.request.rst:220
msgid ""
"*headers* should be a dictionary, and will be treated as if :meth:"
"`add_header` was called with each key and value as arguments. This is often "
"used to \"spoof\" the ``User-Agent`` header value, which is used by a "
"browser to identify itself -- some HTTP servers only allow requests coming "
"from common browsers as opposed to scripts. For example, Mozilla Firefox may "
"identify itself as ``\"Mozilla/5.0 (X11; U; Linux i686) Gecko/20071127 "
"Firefox/2.0.0.11\"``, while :mod:`urllib`'s default user agent string is "
"``\"Python-urllib/2.6\"`` (on Python 2.6). All header keys are sent in camel "
"case."
msgstr ""
"*headers* 必須是一個 dictionary，並會被視為如同每對 key 和 value 作為引數來呼"
"叫 :meth:`add_header`。經常用於「偽裝」 ``User-Agent``  header 的值，這個 "
"header 是用來讓一個瀏覽器向伺服器表明自己的身分 --- 有些 HTTP 伺服器僅允許來"
"自普通瀏覽器的請求，而不接受來自程式腳本的請求。例如，Mozilla Firefox 會將 "
"header 的值設為 ``\"Mozilla/5.0 (X11; U; Linux i686) Gecko/20071127 "
"Firefox/2.0.0.11\"``，而 :mod:`urllib` 的值則是 ``\"Python-urllib/2.6\"``\\ "
"（在 Python 2.6 上）。所有 header 的鍵都會以 camel case（駝峰式大小寫）來傳"
"送。"

#: ../../library/urllib.request.rst:231
msgid ""
"An appropriate ``Content-Type`` header should be included if the *data* "
"argument is present.  If this header has not been provided and *data* is not "
"``None``, ``Content-Type: application/x-www-form-urlencoded`` will be added "
"as a default."
msgstr ""
"當有給定 *data* 引數時，一個適當的 ``Content-Type`` header 應該被設置。如果這"
"個 header 沒有被提供且 *data* 也不為 ``None`` 時，預設值 ``Content-Type: "
"application/x-www-form-urlencoded`` 會被新增至請求中。"

#: ../../library/urllib.request.rst:236
msgid ""
"The next two arguments are only of interest for correct handling of third-"
"party HTTP cookies:"
msgstr ""
"接下來的兩個引數的介紹提供給那些有興趣正確處理第三方 HTTP cookies 的使用者："

#: ../../library/urllib.request.rst:239
msgid ""
"*origin_req_host* should be the request-host of the origin transaction, as "
"defined by :rfc:`2965`.  It defaults to ``http.cookiejar."
"request_host(self)``.  This is the host name or IP address of the original "
"request that was initiated by the user. For example, if the request is for "
"an image in an HTML document, this should be the request-host of the request "
"for the page containing the image."
msgstr ""
"*origin_req_host* 應為原始傳輸互動的請求主機 (request-host)，如同在 :rfc:"
"`2965` 中的定義。預設值為 ``http.cookiejar.request_host(self)``。這是使用者發"
"起的原始請求的主機名稱或是 IP 位址。例如當請求是要求一個 HTML 文件中的一個影"
"像，則這個屬性應為請求包含影像頁面的請求主機。"

#: ../../library/urllib.request.rst:247
msgid ""
"*unverifiable* should indicate whether the request is unverifiable, as "
"defined by :rfc:`2965`.  It defaults to ``False``.  An unverifiable request "
"is one whose URL the user did not have the option to approve.  For example, "
"if the request is for an image in an HTML document, and the user had no "
"option to approve the automatic fetching of the image, this should be true."
msgstr ""
"*unverifiable* 應該標示一個請求是否是無法驗證的，如同在 :rfc:`2965` 中的定"
"義。其預設值為 ``False``。一個無法驗證的請求是指使用者沒有機會去批准請求的 "
"URL，例如一個對於 HTML 文件中的影像所做的請求，而使用者沒有機會去批准是否能自"
"動擷取影像，則這個值應該為 true。"

#: ../../library/urllib.request.rst:254
msgid ""
"*method* should be a string that indicates the HTTP request method that will "
"be used (e.g. ``'HEAD'``).  If provided, its value is stored in the :attr:"
"`~Request.method` attribute and is used by :meth:`get_method`. The default "
"is ``'GET'`` if *data* is ``None`` or ``'POST'`` otherwise. Subclasses may "
"indicate a different default method by setting the :attr:`~Request.method` "
"attribute in the class itself."
msgstr ""
"*method* 應為一個標示 HTTP 請求方法的字串（例如：``'HEAD'``）。如果有提供值，"
"則會被存在 :attr:`~Request.method` 屬性中且被 :meth:`get_method` 所使用。當 "
"*data* 是 ``None`` 時，其預設值為 ``'GET'``，否則預設值為 ``'POST'``。"
"Subclasses 可以透過設置其 :attr:`~Request.method` 屬性來設定不一樣的預設請求"
"方法。"

#: ../../library/urllib.request.rst:262
msgid ""
"The request will not work as expected if the data object is unable to "
"deliver its content more than once (e.g. a file or an iterable that can "
"produce the content only once) and the request is retried for HTTP redirects "
"or authentication.  The *data* is sent to the HTTP server right away after "
"the headers.  There is no support for a 100-continue expectation in the "
"library."
msgstr ""
"如果資料物件無法重複提供其內容（例如一個檔案或是只能產生一次內容的可疊代物"
"件）且請求因為 HTTP 重導向 (redirects) 或是 HTTP 驗證 (authentication) 而被重"
"新嘗試傳送，則該請求不會正常運作。*data* 會接在 headers 之後被送至 HTTP 伺服"
"器。此函式庫沒有支援 100-continue expectation。"

#: ../../library/urllib.request.rst:269
msgid ":attr:`Request.method` argument is added to the Request class."
msgstr "新增 :attr:`Request.method` 引數到 Request class。"

#: ../../library/urllib.request.rst:272
msgid "Default :attr:`Request.method` may be indicated at the class level."
msgstr "能夠在 class 中設置預設的 :attr:`Request.method`。"

#: ../../library/urllib.request.rst:275
msgid ""
"Do not raise an error if the ``Content-Length`` has not been provided and "
"*data* is neither ``None`` nor a bytes object. Fall back to use chunked "
"transfer encoding instead."
msgstr ""
"如果 ``Content-Length`` 尚未被提供且 *data* 既不是 ``None`` 也不是一個位元組"
"串物件，則不會觸發錯誤，並 fall back（後備）使用分塊傳輸編碼 (chunked "
"transfer encoding)。"

#: ../../library/urllib.request.rst:282
msgid ""
"The :class:`OpenerDirector` class opens URLs via :class:`BaseHandler`\\ s "
"chained together. It manages the chaining of handlers, and recovery from "
"errors."
msgstr ""

#: ../../library/urllib.request.rst:288
msgid ""
"This is the base class for all registered handlers --- and handles only the "
"simple mechanics of registration."
msgstr ""

#: ../../library/urllib.request.rst:294
msgid ""
"A class which defines a default handler for HTTP error responses; all "
"responses are turned into :exc:`~urllib.error.HTTPError` exceptions."
msgstr ""

#: ../../library/urllib.request.rst:300
msgid "A class to handle redirections."
msgstr ""

#: ../../library/urllib.request.rst:305
msgid "A class to handle HTTP Cookies."
msgstr ""

#: ../../library/urllib.request.rst:310
msgid ""
"Cause requests to go through a proxy. If *proxies* is given, it must be a "
"dictionary mapping protocol names to URLs of proxies. The default is to read "
"the list of proxies from the environment variables ``<protocol>_proxy``.  If "
"no proxy environment variables are set, then in a Windows environment proxy "
"settings are obtained from the registry's Internet Settings section, and in "
"a macOS environment proxy information is retrieved from the System "
"Configuration Framework."
msgstr ""

#: ../../library/urllib.request.rst:318
msgid "To disable autodetected proxy pass an empty dictionary."
msgstr ""

#: ../../library/urllib.request.rst:320
msgid ""
"The :envvar:`no_proxy` environment variable can be used to specify hosts "
"which shouldn't be reached via proxy; if set, it should be a comma-separated "
"list of hostname suffixes, optionally with ``:port`` appended, for example "
"``cern.ch,ncsa.uiuc.edu,some.host:8080``."
msgstr ""

#: ../../library/urllib.request.rst:327
msgid ""
"``HTTP_PROXY`` will be ignored if a variable ``REQUEST_METHOD`` is set; see "
"the documentation on :func:`~urllib.request.getproxies`."
msgstr ""

#: ../../library/urllib.request.rst:333
msgid "Keep a database of  ``(realm, uri) -> (user, password)`` mappings."
msgstr ""

#: ../../library/urllib.request.rst:338
msgid ""
"Keep a database of  ``(realm, uri) -> (user, password)`` mappings. A realm "
"of ``None`` is considered a catch-all realm, which is searched if no other "
"realm fits."
msgstr ""

#: ../../library/urllib.request.rst:345
msgid ""
"A variant of :class:`HTTPPasswordMgrWithDefaultRealm` that also has a "
"database of ``uri -> is_authenticated`` mappings.  Can be used by a "
"BasicAuth handler to determine when to send authentication credentials "
"immediately instead of waiting for a ``401`` response first."
msgstr ""

#: ../../library/urllib.request.rst:355
msgid ""
"This is a mixin class that helps with HTTP authentication, both to the "
"remote host and to a proxy. *password_mgr*, if given, should be something "
"that is compatible with :class:`HTTPPasswordMgr`; refer to section :ref:"
"`http-password-mgr` for information on the interface that must be "
"supported.  If *passwd_mgr* also provides ``is_authenticated`` and "
"``update_authenticated`` methods (see :ref:`http-password-mgr-with-prior-"
"auth`), then the handler will use the ``is_authenticated`` result for a "
"given URI to determine whether or not to send authentication credentials "
"with the request.  If ``is_authenticated`` returns ``True`` for the URI, "
"credentials are sent.  If ``is_authenticated`` is ``False``, credentials are "
"not sent, and then if a ``401`` response is received the request is re-sent "
"with the authentication credentials.  If authentication succeeds, "
"``update_authenticated`` is called to set ``is_authenticated`` ``True`` for "
"the URI, so that subsequent requests to the URI or any of its super-URIs "
"will automatically include the authentication credentials."
msgstr ""

#: ../../library/urllib.request.rst:372
msgid "Added ``is_authenticated`` support."
msgstr "新增 ``is_authenticated`` 的支援。"

#: ../../library/urllib.request.rst:378
msgid ""
"Handle authentication with the remote host. *password_mgr*, if given, should "
"be something that is compatible with :class:`HTTPPasswordMgr`; refer to "
"section :ref:`http-password-mgr` for information on the interface that must "
"be supported. HTTPBasicAuthHandler will raise a :exc:`ValueError` when "
"presented with a wrong Authentication scheme."
msgstr ""

#: ../../library/urllib.request.rst:387 ../../library/urllib.request.rst:421
msgid ""
"Handle authentication with the proxy. *password_mgr*, if given, should be "
"something that is compatible with :class:`HTTPPasswordMgr`; refer to "
"section :ref:`http-password-mgr` for information on the interface that must "
"be supported."
msgstr ""

#: ../../library/urllib.request.rst:395
msgid ""
"This is a mixin class that helps with HTTP authentication, both to the "
"remote host and to a proxy. *password_mgr*, if given, should be something "
"that is compatible with :class:`HTTPPasswordMgr`; refer to section :ref:"
"`http-password-mgr` for information on the interface that must be supported."
msgstr ""

#: ../../library/urllib.request.rst:404
msgid ""
"Handle authentication with the remote host. *password_mgr*, if given, should "
"be something that is compatible with :class:`HTTPPasswordMgr`; refer to "
"section :ref:`http-password-mgr` for information on the interface that must "
"be supported. When both Digest Authentication Handler and Basic "
"Authentication Handler are both added, Digest Authentication is always tried "
"first. If the Digest Authentication returns a 40x response again, it is sent "
"to Basic Authentication handler to Handle.  This Handler method will raise "
"a :exc:`ValueError` when presented with an authentication scheme other than "
"Digest or Basic."
msgstr ""

#: ../../library/urllib.request.rst:414
msgid "Raise :exc:`ValueError` on unsupported Authentication Scheme."
msgstr ""

#: ../../library/urllib.request.rst:429
msgid "A class to handle opening of HTTP URLs."
msgstr ""

#: ../../library/urllib.request.rst:434
msgid ""
"A class to handle opening of HTTPS URLs.  *context* and *check_hostname* "
"have the same meaning as in :class:`http.client.HTTPSConnection`."
msgstr ""

#: ../../library/urllib.request.rst:437
msgid "*context* and *check_hostname* were added."
msgstr "新增 *context* 與 *check_hostname*。"

#: ../../library/urllib.request.rst:443
msgid "Open local files."
msgstr ""

#: ../../library/urllib.request.rst:447
msgid "Open data URLs."
msgstr ""

#: ../../library/urllib.request.rst:453
msgid "Open FTP URLs."
msgstr "打開 FTP URLs。"

#: ../../library/urllib.request.rst:458
msgid ""
"Open FTP URLs, keeping a cache of open FTP connections to minimize delays."
msgstr ""

#: ../../library/urllib.request.rst:463
msgid "A catch-all class to handle unknown URLs."
msgstr ""

#: ../../library/urllib.request.rst:468 ../../library/urllib.request.rst:1174
msgid "Process HTTP error responses."
msgstr ""

#: ../../library/urllib.request.rst:474
msgid "Request Objects"
msgstr "Request 物件"

#: ../../library/urllib.request.rst:476
msgid ""
"The following methods describe :class:`Request`'s public interface, and so "
"all may be overridden in subclasses.  It also defines several public "
"attributes that can be used by clients to inspect the parsed request."
msgstr ""

#: ../../library/urllib.request.rst:483
msgid "The original URL passed to the constructor."
msgstr ""

#: ../../library/urllib.request.rst:487
msgid ""
"Request.full_url is a property with setter, getter and a deleter. Getting :"
"attr:`~Request.full_url` returns the original request URL with the fragment, "
"if it was present."
msgstr ""

#: ../../library/urllib.request.rst:493
msgid "The URI scheme."
msgstr ""

#: ../../library/urllib.request.rst:497
msgid ""
"The URI authority, typically a host, but may also contain a port separated "
"by a colon."
msgstr ""

#: ../../library/urllib.request.rst:502
msgid "The original host for the request, without port."
msgstr ""

#: ../../library/urllib.request.rst:506
msgid ""
"The URI path.  If the :class:`Request` uses a proxy, then selector will be "
"the full URL that is passed to the proxy."
msgstr ""

#: ../../library/urllib.request.rst:511
msgid "The entity body for the request, or ``None`` if not specified."
msgstr ""

#: ../../library/urllib.request.rst:513
msgid ""
"Changing value of :attr:`Request.data` now deletes \"Content-Length\" header "
"if it was previously set or calculated."
msgstr ""

#: ../../library/urllib.request.rst:519
msgid ""
"boolean, indicates whether the request is unverifiable as defined by :rfc:"
"`2965`."
msgstr ""

#: ../../library/urllib.request.rst:524
msgid ""
"The HTTP request method to use.  By default its value is :const:`None`, "
"which means that :meth:`~Request.get_method` will do its normal computation "
"of the method to be used.  Its value can be set (thus overriding the default "
"computation in :meth:`~Request.get_method`) either by providing a default "
"value by setting it at the class level in a :class:`Request` subclass, or by "
"passing a value in to the :class:`Request` constructor via the *method* "
"argument."
msgstr ""

#: ../../library/urllib.request.rst:534
msgid ""
"A default value can now be set in subclasses; previously it could only be "
"set via the constructor argument."
msgstr ""

#: ../../library/urllib.request.rst:541
msgid ""
"Return a string indicating the HTTP request method.  If :attr:`Request."
"method` is not ``None``, return its value, otherwise return ``'GET'`` if :"
"attr:`Request.data` is ``None``, or ``'POST'`` if it's not. This is only "
"meaningful for HTTP requests."
msgstr ""

#: ../../library/urllib.request.rst:546
msgid "get_method now looks at the value of :attr:`Request.method`."
msgstr ""

#: ../../library/urllib.request.rst:552
msgid ""
"Add another header to the request.  Headers are currently ignored by all "
"handlers except HTTP handlers, where they are added to the list of headers "
"sent to the server.  Note that there cannot be more than one header with the "
"same name, and later calls will overwrite previous calls in case the *key* "
"collides. Currently, this is no loss of HTTP functionality, since all "
"headers which have meaning when used more than once have a (header-specific) "
"way of gaining the same functionality using only one header.  Note that "
"headers added using this method are also added to redirected requests."
msgstr ""

#: ../../library/urllib.request.rst:564
msgid "Add a header that will not be added to a redirected request."
msgstr ""

#: ../../library/urllib.request.rst:569
msgid ""
"Return whether the instance has the named header (checks both regular and "
"unredirected)."
msgstr ""

#: ../../library/urllib.request.rst:575
msgid ""
"Remove named header from the request instance (both from regular and "
"unredirected headers)."
msgstr ""

#: ../../library/urllib.request.rst:583
msgid "Return the URL given in the constructor."
msgstr ""

#: ../../library/urllib.request.rst:587
msgid "Returns :attr:`Request.full_url`"
msgstr "回傳 :attr:`Request.full_url`"

#: ../../library/urllib.request.rst:592
msgid ""
"Prepare the request by connecting to a proxy server. The *host* and *type* "
"will replace those of the instance, and the instance's selector will be the "
"original URL given in the constructor."
msgstr ""

#: ../../library/urllib.request.rst:599
msgid ""
"Return the value of the given header. If the header is not present, return "
"the default value."
msgstr ""

#: ../../library/urllib.request.rst:605
msgid ""
"Return a list of tuples (header_name, header_value) of the Request headers."
msgstr ""

#: ../../library/urllib.request.rst:607
msgid ""
"The request methods add_data, has_data, get_data, get_type, get_host, "
"get_selector, get_origin_req_host and is_unverifiable that were deprecated "
"since 3.3 have been removed."
msgstr ""

#: ../../library/urllib.request.rst:616
msgid "OpenerDirector Objects"
msgstr "OpenerDirector 物件"

#: ../../library/urllib.request.rst:618
msgid ":class:`OpenerDirector` instances have the following methods:"
msgstr ":class:`OpenerDirector` 物件有以下的方法："

#: ../../library/urllib.request.rst:623
msgid ""
"*handler* should be an instance of :class:`BaseHandler`.  The following "
"methods are searched, and added to the possible chains (note that HTTP "
"errors are a special case).  Note that, in the following, *protocol* should "
"be replaced with the actual protocol to handle, for example :meth:"
"`http_response` would be the HTTP protocol response handler.  Also *type* "
"should be replaced with the actual HTTP code, for example :meth:"
"`http_error_404` would handle HTTP 404 errors."
msgstr ""

#: ../../library/urllib.request.rst:631
msgid ""
":meth:`!<protocol>_open` --- signal that the handler knows how to open "
"*protocol* URLs."
msgstr ""

#: ../../library/urllib.request.rst:634
msgid "See |protocol_open|_ for more information."
msgstr "更多資訊請見 |protocol_open|_。"

#: ../../library/urllib.request.rst:636
msgid ""
":meth:`!http_error_\\<type\\>` --- signal that the handler knows how to "
"handle HTTP errors with HTTP error code *type*."
msgstr ""

#: ../../library/urllib.request.rst:639
msgid "See |http_error_nnn|_ for more information."
msgstr "更多資訊請見 |http_error_nnn|_。"

#: ../../library/urllib.request.rst:641
msgid ""
":meth:`!<protocol>_error` --- signal that the handler knows how to handle "
"errors from (non-\\ ``http``) *protocol*."
msgstr ""

#: ../../library/urllib.request.rst:644
msgid ""
":meth:`!<protocol>_request` --- signal that the handler knows how to pre-"
"process *protocol* requests."
msgstr ""

#: ../../library/urllib.request.rst:647
msgid "See |protocol_request|_ for more information."
msgstr "更多資訊請見 |protocol_request|_。"

#: ../../library/urllib.request.rst:649
msgid ""
":meth:`!<protocol>_response` --- signal that the handler knows how to post-"
"process *protocol* responses."
msgstr ""

#: ../../library/urllib.request.rst:652
msgid "See |protocol_response|_ for more information."
msgstr "更多資訊請見 |protocol_response|_。"

#: ../../library/urllib.request.rst:661
msgid ""
"Open the given *url* (which can be a request object or a string), optionally "
"passing the given *data*. Arguments, return values and exceptions raised are "
"the same as those of :func:`urlopen` (which simply calls the :meth:`open` "
"method on the currently installed global :class:`OpenerDirector`).  The "
"optional *timeout* parameter specifies a timeout in seconds for blocking "
"operations like the connection attempt (if not specified, the global default "
"timeout setting will be used). The timeout feature actually works only for "
"HTTP, HTTPS and FTP connections."
msgstr ""

#: ../../library/urllib.request.rst:673
msgid ""
"Handle an error of the given protocol.  This will call the registered error "
"handlers for the given protocol with the given arguments (which are protocol "
"specific).  The HTTP protocol is a special case which uses the HTTP response "
"code to determine the specific error handler; refer to the :meth:`!"
"http_error_\\<type\\>` methods of the handler classes."
msgstr ""

#: ../../library/urllib.request.rst:679
msgid ""
"Return values and exceptions raised are the same as those of :func:`urlopen`."
msgstr ""

#: ../../library/urllib.request.rst:681
msgid "OpenerDirector objects open URLs in three stages:"
msgstr ""

#: ../../library/urllib.request.rst:683
msgid ""
"The order in which these methods are called within each stage is determined "
"by sorting the handler instances."
msgstr ""

#: ../../library/urllib.request.rst:686
msgid ""
"Every handler with a method named like :meth:`!<protocol>_request` has that "
"method called to pre-process the request."
msgstr ""

#: ../../library/urllib.request.rst:689
msgid ""
"Handlers with a method named like :meth:`!<protocol>_open` are called to "
"handle the request. This stage ends when a handler either returns a non-\\ :"
"const:`None` value (ie. a response), or raises an exception (usually :exc:"
"`~urllib.error.URLError`).  Exceptions are allowed to propagate."
msgstr ""

#: ../../library/urllib.request.rst:694
msgid ""
"In fact, the above algorithm is first tried for methods named :meth:"
"`~BaseHandler.default_open`.  If all such methods return :const:`None`, the "
"algorithm is repeated for methods named like :meth:`!<protocol>_open`.  If "
"all such methods return :const:`None`, the algorithm is repeated for methods "
"named :meth:`~BaseHandler.unknown_open`."
msgstr ""

#: ../../library/urllib.request.rst:700
msgid ""
"Note that the implementation of these methods may involve calls of the "
"parent :class:`OpenerDirector` instance's :meth:`~OpenerDirector.open` and :"
"meth:`~OpenerDirector.error` methods."
msgstr ""

#: ../../library/urllib.request.rst:704
msgid ""
"Every handler with a method named like :meth:`!<protocol>_response` has that "
"method called to post-process the response."
msgstr ""

#: ../../library/urllib.request.rst:711
msgid "BaseHandler Objects"
msgstr "BaseHandler 物件"

#: ../../library/urllib.request.rst:713
msgid ""
":class:`BaseHandler` objects provide a couple of methods that are directly "
"useful, and others that are meant to be used by derived classes.  These are "
"intended for direct use:"
msgstr ""

#: ../../library/urllib.request.rst:720
msgid "Add a director as parent."
msgstr ""

#: ../../library/urllib.request.rst:725
msgid "Remove any parents."
msgstr ""

#: ../../library/urllib.request.rst:727
msgid ""
"The following attribute and methods should only be used by classes derived "
"from :class:`BaseHandler`."
msgstr ""

#: ../../library/urllib.request.rst:732
msgid ""
"The convention has been adopted that subclasses defining :meth:`!"
"<protocol>_request` or :meth:`!<protocol>_response` methods are named :class:"
"`!\\*Processor`; all others are named :class:`!\\*Handler`."
msgstr ""

#: ../../library/urllib.request.rst:739
msgid ""
"A valid :class:`OpenerDirector`, which can be used to open using a different "
"protocol, or handle errors."
msgstr ""

#: ../../library/urllib.request.rst:745
msgid ""
"This method is *not* defined in :class:`BaseHandler`, but subclasses should "
"define it if they want to catch all URLs."
msgstr ""

#: ../../library/urllib.request.rst:748
msgid ""
"This method, if implemented, will be called by the parent :class:"
"`OpenerDirector`.  It should return a file-like object as described in the "
"return value of the :meth:`~OpenerDirector.open` method of :class:"
"`OpenerDirector`, or ``None``. It should raise :exc:`~urllib.error."
"URLError`, unless a truly exceptional thing happens (for example, :exc:"
"`MemoryError` should not be mapped to :exc:`~urllib.error.URLError`)."
msgstr ""

#: ../../library/urllib.request.rst:755
msgid "This method will be called before any protocol-specific open method."
msgstr ""

#: ../../library/urllib.request.rst:762
msgid ""
"This method is *not* defined in :class:`BaseHandler`, but subclasses should "
"define it if they want to handle URLs with the given protocol."
msgstr ""

#: ../../library/urllib.request.rst:765
msgid ""
"This method, if defined, will be called by the parent :class:"
"`OpenerDirector`. Return values should be the same as for  :meth:"
"`~BaseHandler.default_open`."
msgstr ""

#: ../../library/urllib.request.rst:771
msgid ""
"This method is *not* defined in :class:`BaseHandler`, but subclasses should "
"define it if they want to catch all URLs with no specific registered handler "
"to open it."
msgstr ""

#: ../../library/urllib.request.rst:775
msgid ""
"This method, if implemented, will be called by the :attr:`parent` :class:"
"`OpenerDirector`.  Return values should be the same as for :meth:"
"`default_open`."
msgstr ""

#: ../../library/urllib.request.rst:782
msgid ""
"This method is *not* defined in :class:`BaseHandler`, but subclasses should "
"override it if they intend to provide a catch-all for otherwise unhandled "
"HTTP errors.  It will be called automatically by the  :class:"
"`OpenerDirector` getting the error, and should not normally be called in "
"other circumstances."
msgstr ""

#: ../../library/urllib.request.rst:787
msgid ""
"*req* will be a :class:`Request` object, *fp* will be a file-like object "
"with the HTTP error body, *code* will be the three-digit code of the error, "
"*msg* will be the user-visible explanation of the code and *hdrs* will be a "
"mapping object with the headers of the error."
msgstr ""

#: ../../library/urllib.request.rst:792
msgid ""
"Return values and exceptions raised should be the same as those of :func:"
"`urlopen`."
msgstr ""

#: ../../library/urllib.request.rst:799
msgid ""
"*nnn* should be a three-digit HTTP error code.  This method is also not "
"defined in :class:`BaseHandler`, but will be called, if it exists, on an "
"instance of a subclass, when an HTTP error with code *nnn* occurs."
msgstr ""

#: ../../library/urllib.request.rst:803
msgid "Subclasses should override this method to handle specific HTTP errors."
msgstr ""

#: ../../library/urllib.request.rst:805
msgid ""
"Arguments, return values and exceptions raised should be the same as for :"
"meth:`~BaseHandler.http_error_default`."
msgstr ""

#: ../../library/urllib.request.rst:813
msgid ""
"This method is *not* defined in :class:`BaseHandler`, but subclasses should "
"define it if they want to pre-process requests of the given protocol."
msgstr ""

#: ../../library/urllib.request.rst:816
msgid ""
"This method, if defined, will be called by the parent :class:"
"`OpenerDirector`. *req* will be a :class:`Request` object. The return value "
"should be a :class:`Request` object."
msgstr ""

#: ../../library/urllib.request.rst:825
msgid ""
"This method is *not* defined in :class:`BaseHandler`, but subclasses should "
"define it if they want to post-process responses of the given protocol."
msgstr ""

#: ../../library/urllib.request.rst:828
msgid ""
"This method, if defined, will be called by the parent :class:"
"`OpenerDirector`. *req* will be a :class:`Request` object. *response* will "
"be an object implementing the same interface as the return value of :func:"
"`urlopen`.  The return value should implement the same interface as the "
"return value of :func:`urlopen`."
msgstr ""

#: ../../library/urllib.request.rst:838
msgid "HTTPRedirectHandler Objects"
msgstr "HTTPRedirectHandler 物件"

#: ../../library/urllib.request.rst:842
msgid ""
"Some HTTP redirections require action from this module's client code.  If "
"this is the case, :exc:`~urllib.error.HTTPError` is raised.  See :rfc:`2616` "
"for details of the precise meanings of the various redirection codes."
msgstr ""

#: ../../library/urllib.request.rst:846
msgid ""
"An :exc:`~urllib.error.HTTPError` exception raised as a security "
"consideration if the HTTPRedirectHandler is presented with a redirected URL "
"which is not an HTTP, HTTPS or FTP URL."
msgstr ""

#: ../../library/urllib.request.rst:853
msgid ""
"Return a :class:`Request` or ``None`` in response to a redirect. This is "
"called by the default implementations of the :meth:`!http_error_30\\*` "
"methods when a redirection is received from the server.  If a redirection "
"should take place, return a new :class:`Request` to allow :meth:`!"
"http_error_30\\*` to perform the redirect to *newurl*.  Otherwise, raise :"
"exc:`~urllib.error.HTTPError` if no other handler should try to handle this "
"URL, or return ``None`` if you can't but another handler might."
msgstr ""

#: ../../library/urllib.request.rst:863
msgid ""
"The default implementation of this method does not strictly follow :rfc:"
"`2616`, which says that 301 and 302 responses to ``POST`` requests must not "
"be automatically redirected without confirmation by the user.  In reality, "
"browsers do allow automatic redirection of these responses, changing the "
"POST to a ``GET``, and the default implementation reproduces this behavior."
msgstr ""

#: ../../library/urllib.request.rst:872
msgid ""
"Redirect to the ``Location:`` or ``URI:`` URL.  This method is called by the "
"parent :class:`OpenerDirector` when getting an HTTP 'moved permanently' "
"response."
msgstr ""

#: ../../library/urllib.request.rst:878
msgid ""
"The same as :meth:`http_error_301`, but called for the 'found' response."
msgstr ""

#: ../../library/urllib.request.rst:883
msgid ""
"The same as :meth:`http_error_301`, but called for the 'see other' response."
msgstr ""

#: ../../library/urllib.request.rst:888
msgid ""
"The same as :meth:`http_error_301`, but called for the 'temporary redirect' "
"response. It does not allow changing the request method from ``POST`` to "
"``GET``."
msgstr ""

#: ../../library/urllib.request.rst:895
msgid ""
"The same as :meth:`http_error_301`, but called for the 'permanent redirect' "
"response. It does not allow changing the request method from ``POST`` to "
"``GET``."
msgstr ""

#: ../../library/urllib.request.rst:905
msgid "HTTPCookieProcessor Objects"
msgstr "HTTPCookieProcessor 物件"

#: ../../library/urllib.request.rst:907
msgid ":class:`HTTPCookieProcessor` instances have one attribute:"
msgstr ""

#: ../../library/urllib.request.rst:911
msgid "The :class:`http.cookiejar.CookieJar` in which cookies are stored."
msgstr ""

#: ../../library/urllib.request.rst:917
msgid "ProxyHandler Objects"
msgstr "ProxyHandler 物件"

#: ../../library/urllib.request.rst:923
msgid ""
"The :class:`ProxyHandler` will have a method :meth:`!<protocol>_open` for "
"every *protocol* which has a proxy in the *proxies* dictionary given in the "
"constructor.  The method will modify requests to go through the proxy, by "
"calling ``request.set_proxy()``, and call the next handler in the chain to "
"actually execute the protocol."
msgstr ""

#: ../../library/urllib.request.rst:933
msgid "HTTPPasswordMgr Objects"
msgstr "HTTPPasswordMgr 物件"

#: ../../library/urllib.request.rst:935
msgid ""
"These methods are available on :class:`HTTPPasswordMgr` and :class:"
"`HTTPPasswordMgrWithDefaultRealm` objects."
msgstr ""

#: ../../library/urllib.request.rst:941
msgid ""
"*uri* can be either a single URI, or a sequence of URIs. *realm*, *user* and "
"*passwd* must be strings. This causes ``(user, passwd)`` to be used as "
"authentication tokens when authentication for *realm* and a super-URI of any "
"of the given URIs is given."
msgstr ""

#: ../../library/urllib.request.rst:949
msgid ""
"Get user/password for given realm and URI, if any.  This method will return "
"``(None, None)`` if there is no matching user/password."
msgstr ""

#: ../../library/urllib.request.rst:952
msgid ""
"For :class:`HTTPPasswordMgrWithDefaultRealm` objects, the realm ``None`` "
"will be searched if the given *realm* has no matching user/password."
msgstr ""

#: ../../library/urllib.request.rst:959
msgid "HTTPPasswordMgrWithPriorAuth Objects"
msgstr "HTTPPasswordMgrWithPriorAuth 物件"

#: ../../library/urllib.request.rst:961
msgid ""
"This password manager extends :class:`HTTPPasswordMgrWithDefaultRealm` to "
"support tracking URIs for which authentication credentials should always be "
"sent."
msgstr ""

#: ../../library/urllib.request.rst:968
msgid ""
"*realm*, *uri*, *user*, *passwd* are as for :meth:`HTTPPasswordMgr."
"add_password`.  *is_authenticated* sets the initial value of the "
"``is_authenticated`` flag for the given URI or list of URIs. If "
"*is_authenticated* is specified as ``True``, *realm* is ignored."
msgstr ""

#: ../../library/urllib.request.rst:976
msgid "Same as for :class:`HTTPPasswordMgrWithDefaultRealm` objects"
msgstr ""

#: ../../library/urllib.request.rst:982
msgid ""
"Update the ``is_authenticated`` flag for the given *uri* or list of URIs."
msgstr ""

#: ../../library/urllib.request.rst:988
msgid ""
"Returns the current state of the ``is_authenticated`` flag for the given URI."
msgstr ""

#: ../../library/urllib.request.rst:995
msgid "AbstractBasicAuthHandler Objects"
msgstr "AbstractBasicAuthHandler 物件"

#: ../../library/urllib.request.rst:1000
msgid ""
"Handle an authentication request by getting a user/password pair, and re-"
"trying the request.  *authreq* should be the name of the header where the "
"information about the realm is included in the request, *host* specifies the "
"URL and path to authenticate for, *req* should be the (failed) :class:"
"`Request` object, and *headers* should be the error headers."
msgstr ""

#: ../../library/urllib.request.rst:1006
msgid ""
"*host* is either an authority (e.g. ``\"python.org\"``) or a URL containing "
"an authority component (e.g. ``\"http://python.org/\"``). In either case, "
"the authority must not contain a userinfo component (so, ``\"python.org\"`` "
"and ``\"python.org:80\"`` are fine, ``\"joe:password@python.org\"`` is not)."
msgstr ""

#: ../../library/urllib.request.rst:1015
msgid "HTTPBasicAuthHandler Objects"
msgstr "HTTPBasicAuthHandler 物件"

#: ../../library/urllib.request.rst:1020 ../../library/urllib.request.rst:1031
#: ../../library/urllib.request.rst:1056 ../../library/urllib.request.rst:1067
msgid "Retry the request with authentication information, if available."
msgstr ""

#: ../../library/urllib.request.rst:1026
msgid "ProxyBasicAuthHandler Objects"
msgstr "ProxyBasicAuthHandler 物件"

#: ../../library/urllib.request.rst:1037
msgid "AbstractDigestAuthHandler Objects"
msgstr "AbstractDigestAuthHandler 物件"

#: ../../library/urllib.request.rst:1042
msgid ""
"*authreq* should be the name of the header where the information about the "
"realm is included in the request, *host* should be the host to authenticate "
"to, *req* should be the (failed) :class:`Request` object, and *headers* "
"should be the error headers."
msgstr ""

#: ../../library/urllib.request.rst:1051
msgid "HTTPDigestAuthHandler Objects"
msgstr "HTTPDigestAuthHandler 物件"

#: ../../library/urllib.request.rst:1062
msgid "ProxyDigestAuthHandler Objects"
msgstr "ProxyDigestAuthHandler 物件"

#: ../../library/urllib.request.rst:1073
msgid "HTTPHandler Objects"
msgstr "HTTPHandler 物件"

#: ../../library/urllib.request.rst:1078
msgid ""
"Send an HTTP request, which can be either GET or POST, depending on ``req."
"has_data()``."
msgstr ""

#: ../../library/urllib.request.rst:1085
msgid "HTTPSHandler Objects"
msgstr "HTTPSHandler 物件"

#: ../../library/urllib.request.rst:1090
msgid ""
"Send an HTTPS request, which can be either GET or POST, depending on ``req."
"has_data()``."
msgstr ""

#: ../../library/urllib.request.rst:1097
msgid "FileHandler Objects"
msgstr "FileHandler 物件"

#: ../../library/urllib.request.rst:1102
msgid ""
"Open the file locally, if there is no host name, or the host name is "
"``'localhost'``."
msgstr ""

#: ../../library/urllib.request.rst:1105
msgid ""
"This method is applicable only for local hostnames.  When a remote hostname "
"is given, a :exc:`~urllib.error.URLError` is raised."
msgstr ""

#: ../../library/urllib.request.rst:1113
msgid "DataHandler Objects"
msgstr "DataHandler 物件"

#: ../../library/urllib.request.rst:1117
msgid ""
"Read a data URL. This kind of URL contains the content encoded in the URL "
"itself. The data URL syntax is specified in :rfc:`2397`. This implementation "
"ignores white spaces in base64 encoded data URLs so the URL may be wrapped "
"in whatever source file it comes from. But even though some browsers don't "
"mind about a missing padding at the end of a base64 encoded data URL, this "
"implementation will raise a :exc:`ValueError` in that case."
msgstr ""

#: ../../library/urllib.request.rst:1128
msgid "FTPHandler Objects"
msgstr "FTPHandler 物件"

#: ../../library/urllib.request.rst:1133
msgid ""
"Open the FTP file indicated by *req*. The login is always done with empty "
"username and password."
msgstr ""

#: ../../library/urllib.request.rst:1140
msgid "CacheFTPHandler Objects"
msgstr "CacheFTPHandler 物件"

#: ../../library/urllib.request.rst:1142
msgid ""
":class:`CacheFTPHandler` objects are :class:`FTPHandler` objects with the "
"following additional methods:"
msgstr ""

#: ../../library/urllib.request.rst:1148
msgid "Set timeout of connections to *t* seconds."
msgstr ""

#: ../../library/urllib.request.rst:1153
msgid "Set maximum number of cached connections to *m*."
msgstr ""

#: ../../library/urllib.request.rst:1159
msgid "UnknownHandler Objects"
msgstr "UnknownHandler 物件"

#: ../../library/urllib.request.rst:1164
msgid "Raise a :exc:`~urllib.error.URLError` exception."
msgstr ""

#: ../../library/urllib.request.rst:1170
msgid "HTTPErrorProcessor Objects"
msgstr "HTTPErrorProcessor 物件"

#: ../../library/urllib.request.rst:1176
msgid "For 200 error codes, the response object is returned immediately."
msgstr ""

#: ../../library/urllib.request.rst:1178
msgid ""
"For non-200 error codes, this simply passes the job on to the :meth:`!"
"http_error_\\<type\\>` handler methods, via :meth:`OpenerDirector.error`. "
"Eventually, :class:`HTTPDefaultErrorHandler` will raise an :exc:`~urllib."
"error.HTTPError` if no other handler handles the error."
msgstr ""

#: ../../library/urllib.request.rst:1186
msgid "Process HTTPS error responses."
msgstr ""

#: ../../library/urllib.request.rst:1188
msgid "The behavior is same as :meth:`http_response`."
msgstr ""

#: ../../library/urllib.request.rst:1194
msgid "Examples"
msgstr "範例"

#: ../../library/urllib.request.rst:1196
msgid ""
"In addition to the examples below, more examples are given in :ref:`urllib-"
"howto`."
msgstr ""

#: ../../library/urllib.request.rst:1199
msgid ""
"This example gets the python.org main page and displays the first 300 bytes "
"of it. ::"
msgstr ""

#: ../../library/urllib.request.rst:1202
msgid ""
">>> import urllib.request\n"
">>> with urllib.request.urlopen('http://www.python.org/') as f:\n"
"...     print(f.read(300))\n"
"...\n"
"b'<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"\n"
"\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\\n\\n\\n<html\n"
"xmlns=\"http://www.w3.org/1999/xhtml\" xml:lang=\"en\" "
"lang=\"en\">\\n\\n<head>\\n\n"
"<meta http-equiv=\"content-type\" content=\"text/html; charset=utf-8\" /"
">\\n\n"
"<title>Python Programming '"
msgstr ""
">>> import urllib.request\n"
">>> with urllib.request.urlopen('http://www.python.org/') as f:\n"
"...     print(f.read(300))\n"
"...\n"
"b'<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"\n"
"\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\\n\\n\\n<html\n"
"xmlns=\"http://www.w3.org/1999/xhtml\" xml:lang=\"en\" "
"lang=\"en\">\\n\\n<head>\\n\n"
"<meta http-equiv=\"content-type\" content=\"text/html; charset=utf-8\" /"
">\\n\n"
"<title>Python Programming '"

#: ../../library/urllib.request.rst:1212
msgid ""
"Note that urlopen returns a bytes object.  This is because there is no way "
"for urlopen to automatically determine the encoding of the byte stream it "
"receives from the HTTP server. In general, a program will decode the "
"returned bytes object to string once it determines or guesses the "
"appropriate encoding."
msgstr ""

#: ../../library/urllib.request.rst:1218
msgid ""
"The following W3C document, https://www.w3.org/International/O-charset\\ , "
"lists the various ways in which an (X)HTML or an XML document could have "
"specified its encoding information."
msgstr ""

#: ../../library/urllib.request.rst:1222
msgid ""
"As the python.org website uses *utf-8* encoding as specified in its meta "
"tag, we will use the same for decoding the bytes object. ::"
msgstr ""

#: ../../library/urllib.request.rst:1225
msgid ""
">>> with urllib.request.urlopen('http://www.python.org/') as f:\n"
"...     print(f.read(100).decode('utf-8'))\n"
"...\n"
"<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"\n"
"\"http://www.w3.org/TR/xhtml1/DTD/xhtm"
msgstr ""
">>> with urllib.request.urlopen('http://www.python.org/') as f:\n"
"...     print(f.read(100).decode('utf-8'))\n"
"...\n"
"<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"\n"
"\"http://www.w3.org/TR/xhtml1/DTD/xhtm"

#: ../../library/urllib.request.rst:1231
msgid ""
"It is also possible to achieve the same result without using the :term:"
"`context manager` approach. ::"
msgstr ""

#: ../../library/urllib.request.rst:1234
msgid ""
">>> import urllib.request\n"
">>> f = urllib.request.urlopen('http://www.python.org/')\n"
">>> print(f.read(100).decode('utf-8'))\n"
"<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"\n"
"\"http://www.w3.org/TR/xhtml1/DTD/xhtm"
msgstr ""
">>> import urllib.request\n"
">>> f = urllib.request.urlopen('http://www.python.org/')\n"
">>> print(f.read(100).decode('utf-8'))\n"
"<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"\n"
"\"http://www.w3.org/TR/xhtml1/DTD/xhtm"

#: ../../library/urllib.request.rst:1240
msgid ""
"In the following example, we are sending a data-stream to the stdin of a CGI "
"and reading the data it returns to us. Note that this example will only work "
"when the Python installation supports SSL. ::"
msgstr ""

#: ../../library/urllib.request.rst:1244
msgid ""
">>> import urllib.request\n"
">>> req = urllib.request.Request(url='https://localhost/cgi-bin/test.cgi',\n"
"...                       data=b'This data is passed to stdin of the CGI')\n"
">>> with urllib.request.urlopen(req) as f:\n"
"...     print(f.read().decode('utf-8'))\n"
"...\n"
"Got Data: \"This data is passed to stdin of the CGI\""
msgstr ""

#: ../../library/urllib.request.rst:1252
msgid "The code for the sample CGI used in the above example is::"
msgstr ""

#: ../../library/urllib.request.rst:1254
msgid ""
"#!/usr/bin/env python\n"
"import sys\n"
"data = sys.stdin.read()\n"
"print('Content-type: text/plain\\n\\nGot Data: \"%s\"' % data)"
msgstr ""
"#!/usr/bin/env python\n"
"import sys\n"
"data = sys.stdin.read()\n"
"print('Content-type: text/plain\\n\\nGot Data: \"%s\"' % data)"

#: ../../library/urllib.request.rst:1259
msgid "Here is an example of doing a ``PUT`` request using :class:`Request`::"
msgstr ""

#: ../../library/urllib.request.rst:1261
msgid ""
"import urllib.request\n"
"DATA = b'some data'\n"
"req = urllib.request.Request(url='http://localhost:8080', data=DATA, "
"method='PUT')\n"
"with urllib.request.urlopen(req) as f:\n"
"    pass\n"
"print(f.status)\n"
"print(f.reason)"
msgstr ""
"import urllib.request\n"
"DATA = b'some data'\n"
"req = urllib.request.Request(url='http://localhost:8080', data=DATA, "
"method='PUT')\n"
"with urllib.request.urlopen(req) as f:\n"
"    pass\n"
"print(f.status)\n"
"print(f.reason)"

#: ../../library/urllib.request.rst:1269
msgid "Use of Basic HTTP Authentication::"
msgstr ""

#: ../../library/urllib.request.rst:1271
msgid ""
"import urllib.request\n"
"# Create an OpenerDirector with support for Basic HTTP Authentication...\n"
"auth_handler = urllib.request.HTTPBasicAuthHandler()\n"
"auth_handler.add_password(realm='PDQ Application',\n"
"                          uri='https://mahler:8092/site-updates.py',\n"
"                          user='klem',\n"
"                          passwd='kadidd!ehopper')\n"
"opener = urllib.request.build_opener(auth_handler)\n"
"# ...and install it globally so it can be used with urlopen.\n"
"urllib.request.install_opener(opener)\n"
"urllib.request.urlopen('http://www.example.com/login.html')"
msgstr ""

#: ../../library/urllib.request.rst:1283
msgid ""
":func:`build_opener` provides many handlers by default, including a :class:"
"`ProxyHandler`.  By default, :class:`ProxyHandler` uses the environment "
"variables named ``<scheme>_proxy``, where ``<scheme>`` is the URL scheme "
"involved.  For example, the :envvar:`!http_proxy` environment variable is "
"read to obtain the HTTP proxy's URL."
msgstr ""

#: ../../library/urllib.request.rst:1289
msgid ""
"This example replaces the default :class:`ProxyHandler` with one that uses "
"programmatically supplied proxy URLs, and adds proxy authorization support "
"with :class:`ProxyBasicAuthHandler`. ::"
msgstr ""

#: ../../library/urllib.request.rst:1293
msgid ""
"proxy_handler = urllib.request.ProxyHandler({'http': 'http://www.example."
"com:3128/'})\n"
"proxy_auth_handler = urllib.request.ProxyBasicAuthHandler()\n"
"proxy_auth_handler.add_password('realm', 'host', 'username', 'password')\n"
"\n"
"opener = urllib.request.build_opener(proxy_handler, proxy_auth_handler)\n"
"# This time, rather than install the OpenerDirector, we use it directly:\n"
"opener.open('http://www.example.com/login.html')"
msgstr ""
"proxy_handler = urllib.request.ProxyHandler({'http': 'http://www.example."
"com:3128/'})\n"
"proxy_auth_handler = urllib.request.ProxyBasicAuthHandler()\n"
"proxy_auth_handler.add_password('realm', 'host', 'username', 'password')\n"
"\n"
"opener = urllib.request.build_opener(proxy_handler, proxy_auth_handler)\n"
"# 這次我們直接使用它而不安裝 OpenerDirector:\n"
"opener.open('http://www.example.com/login.html')"

#: ../../library/urllib.request.rst:1301
msgid "Adding HTTP headers:"
msgstr ""

#: ../../library/urllib.request.rst:1303
msgid "Use the *headers* argument to the :class:`Request` constructor, or::"
msgstr ""

#: ../../library/urllib.request.rst:1305
msgid ""
"import urllib.request\n"
"req = urllib.request.Request('http://www.example.com/')\n"
"req.add_header('Referer', 'http://www.python.org/')\n"
"# Customize the default User-Agent header value:\n"
"req.add_header('User-Agent', 'urllib-example/0.1 (Contact: . . .)')\n"
"r = urllib.request.urlopen(req)"
msgstr ""
"import urllib.request\n"
"req = urllib.request.Request('http://www.example.com/')\n"
"req.add_header('Referer', 'http://www.python.org/')\n"
"# Customize the default User-Agent header value:\n"
"req.add_header('User-Agent', 'urllib-example/0.1 (Contact: . . .)')\n"
"r = urllib.request.urlopen(req)"

#: ../../library/urllib.request.rst:1312
msgid ""
":class:`OpenerDirector` automatically adds a :mailheader:`User-Agent` header "
"to every :class:`Request`.  To change this::"
msgstr ""

#: ../../library/urllib.request.rst:1315
msgid ""
"import urllib.request\n"
"opener = urllib.request.build_opener()\n"
"opener.addheaders = [('User-agent', 'Mozilla/5.0')]\n"
"opener.open('http://www.example.com/')"
msgstr ""
"import urllib.request\n"
"opener = urllib.request.build_opener()\n"
"opener.addheaders = [('User-agent', 'Mozilla/5.0')]\n"
"opener.open('http://www.example.com/')"

#: ../../library/urllib.request.rst:1320
msgid ""
"Also, remember that a few standard headers (:mailheader:`Content-Length`, :"
"mailheader:`Content-Type` and :mailheader:`Host`) are added when the :class:"
"`Request` is passed to :func:`urlopen` (or :meth:`OpenerDirector.open`)."
msgstr ""

#: ../../library/urllib.request.rst:1327
msgid ""
"Here is an example session that uses the ``GET`` method to retrieve a URL "
"containing parameters::"
msgstr ""

#: ../../library/urllib.request.rst:1330
msgid ""
">>> import urllib.request\n"
">>> import urllib.parse\n"
">>> params = urllib.parse.urlencode({'spam': 1, 'eggs': 2, 'bacon': 0})\n"
">>> url = \"http://www.musi-cal.com/cgi-bin/query?%s\" % params\n"
">>> with urllib.request.urlopen(url) as f:\n"
"...     print(f.read().decode('utf-8'))\n"
"..."
msgstr ""
">>> import urllib.request\n"
">>> import urllib.parse\n"
">>> params = urllib.parse.urlencode({'spam': 1, 'eggs': 2, 'bacon': 0})\n"
">>> url = \"http://www.musi-cal.com/cgi-bin/query?%s\" % params\n"
">>> with urllib.request.urlopen(url) as f:\n"
"...     print(f.read().decode('utf-8'))\n"
"..."

#: ../../library/urllib.request.rst:1338
msgid ""
"The following example uses the ``POST`` method instead. Note that params "
"output from urlencode is encoded to bytes before it is sent to urlopen as "
"data::"
msgstr ""

#: ../../library/urllib.request.rst:1341
msgid ""
">>> import urllib.request\n"
">>> import urllib.parse\n"
">>> data = urllib.parse.urlencode({'spam': 1, 'eggs': 2, 'bacon': 0})\n"
">>> data = data.encode('ascii')\n"
">>> with urllib.request.urlopen(\"http://requestb.in/xrbl82xr\", data) as "
"f:\n"
"...     print(f.read().decode('utf-8'))\n"
"..."
msgstr ""
">>> import urllib.request\n"
">>> import urllib.parse\n"
">>> data = urllib.parse.urlencode({'spam': 1, 'eggs': 2, 'bacon': 0})\n"
">>> data = data.encode('ascii')\n"
">>> with urllib.request.urlopen(\"http://requestb.in/xrbl82xr\", data) as "
"f:\n"
"...     print(f.read().decode('utf-8'))\n"
"..."

#: ../../library/urllib.request.rst:1349
msgid ""
"The following example uses an explicitly specified HTTP proxy, overriding "
"environment settings::"
msgstr ""

#: ../../library/urllib.request.rst:1352
msgid ""
">>> import urllib.request\n"
">>> proxies = {'http': 'http://proxy.example.com:8080/'}\n"
">>> opener = urllib.request.FancyURLopener(proxies)\n"
">>> with opener.open(\"http://www.python.org\") as f:\n"
"...     f.read().decode('utf-8')\n"
"..."
msgstr ""
">>> import urllib.request\n"
">>> proxies = {'http': 'http://proxy.example.com:8080/'}\n"
">>> opener = urllib.request.FancyURLopener(proxies)\n"
">>> with opener.open(\"http://www.python.org\") as f:\n"
"...     f.read().decode('utf-8')\n"
"..."

#: ../../library/urllib.request.rst:1359
msgid ""
"The following example uses no proxies at all, overriding environment "
"settings::"
msgstr ""

#: ../../library/urllib.request.rst:1361
msgid ""
">>> import urllib.request\n"
">>> opener = urllib.request.FancyURLopener({})\n"
">>> with opener.open(\"http://www.python.org/\") as f:\n"
"...     f.read().decode('utf-8')\n"
"..."
msgstr ""
">>> import urllib.request\n"
">>> opener = urllib.request.FancyURLopener({})\n"
">>> with opener.open(\"http://www.python.org/\") as f:\n"
"...     f.read().decode('utf-8')\n"
"..."

#: ../../library/urllib.request.rst:1369
msgid "Legacy interface"
msgstr ""

#: ../../library/urllib.request.rst:1371
msgid ""
"The following functions and classes are ported from the Python 2 module "
"``urllib`` (as opposed to ``urllib2``).  They might become deprecated at "
"some point in the future."
msgstr ""

#: ../../library/urllib.request.rst:1377
msgid ""
"Copy a network object denoted by a URL to a local file. If the URL points to "
"a local file, the object will not be copied unless filename is supplied. "
"Return a tuple ``(filename, headers)`` where *filename* is the local file "
"name under which the object can be found, and *headers* is whatever the :"
"meth:`!info` method of the object returned by :func:`urlopen` returned (for "
"a remote object). Exceptions are the same as for :func:`urlopen`."
msgstr ""

#: ../../library/urllib.request.rst:1384
msgid ""
"The second argument, if present, specifies the file location to copy to (if "
"absent, the location will be a tempfile with a generated name). The third "
"argument, if present, is a callable that will be called once on "
"establishment of the network connection and once after each block read "
"thereafter.  The callable will be passed three arguments; a count of blocks "
"transferred so far, a block size in bytes, and the total size of the file.  "
"The third argument may be ``-1`` on older FTP servers which do not return a "
"file size in response to a retrieval request."
msgstr ""

#: ../../library/urllib.request.rst:1393
msgid "The following example illustrates the most common usage scenario::"
msgstr ""

#: ../../library/urllib.request.rst:1395
msgid ""
">>> import urllib.request\n"
">>> local_filename, headers = urllib.request.urlretrieve('http://python."
"org/')\n"
">>> html = open(local_filename)\n"
">>> html.close()"
msgstr ""
">>> import urllib.request\n"
">>> local_filename, headers = urllib.request.urlretrieve('http://python."
"org/')\n"
">>> html = open(local_filename)\n"
">>> html.close()"

#: ../../library/urllib.request.rst:1400
msgid ""
"If the *url* uses the :file:`http:` scheme identifier, the optional *data* "
"argument may be given to specify a ``POST`` request (normally the request "
"type is ``GET``).  The *data* argument must be a bytes object in standard :"
"mimetype:`application/x-www-form-urlencoded` format; see the :func:`urllib."
"parse.urlencode` function."
msgstr ""

#: ../../library/urllib.request.rst:1406
msgid ""
":func:`urlretrieve` will raise :exc:`~urllib.error.ContentTooShortError` "
"when it detects that the amount of data available  was less than the "
"expected amount (which is the size reported by a  *Content-Length* header). "
"This can occur, for example, when the  download is interrupted."
msgstr ""

#: ../../library/urllib.request.rst:1411
msgid ""
"The *Content-Length* is treated as a lower bound: if there's more data  to "
"read, urlretrieve reads more data, but if less data is available,  it raises "
"the exception."
msgstr ""

#: ../../library/urllib.request.rst:1415
msgid ""
"You can still retrieve the downloaded data in this case, it is stored in "
"the :attr:`!content` attribute of the exception instance."
msgstr ""

#: ../../library/urllib.request.rst:1418
msgid ""
"If no *Content-Length* header was supplied, urlretrieve can not check the "
"size of the data it has downloaded, and just returns it.  In this case you "
"just have to assume that the download was successful."
msgstr ""

#: ../../library/urllib.request.rst:1424
msgid ""
"Cleans up temporary files that may have been left behind by previous calls "
"to :func:`urlretrieve`."
msgstr ""

#: ../../library/urllib.request.rst:1431
msgid ""
"Base class for opening and reading URLs.  Unless you need to support opening "
"objects using schemes other than :file:`http:`, :file:`ftp:`, or :file:`file:"
"`, you probably want to use :class:`FancyURLopener`."
msgstr ""

#: ../../library/urllib.request.rst:1435
msgid ""
"By default, the :class:`URLopener` class sends a :mailheader:`User-Agent` "
"header of ``urllib/VVV``, where *VVV* is the :mod:`urllib` version number. "
"Applications can define their own :mailheader:`User-Agent` header by "
"subclassing :class:`URLopener` or :class:`FancyURLopener` and setting the "
"class attribute :attr:`version` to an appropriate string value in the "
"subclass definition."
msgstr ""

#: ../../library/urllib.request.rst:1441
msgid ""
"The optional *proxies* parameter should be a dictionary mapping scheme names "
"to proxy URLs, where an empty dictionary turns proxies off completely.  Its "
"default value is ``None``, in which case environmental proxy settings will "
"be used if present, as discussed in the definition of :func:`urlopen`, above."
msgstr ""

#: ../../library/urllib.request.rst:1446
msgid ""
"Additional keyword parameters, collected in *x509*, may be used for "
"authentication of the client when using the :file:`https:` scheme.  The "
"keywords *key_file* and *cert_file* are supported to provide an  SSL key and "
"certificate; both are needed to support client authentication."
msgstr ""

#: ../../library/urllib.request.rst:1451
msgid ""
":class:`URLopener` objects will raise an :exc:`OSError` exception if the "
"server returns an error code."
msgstr ""

#: ../../library/urllib.request.rst:1456
msgid ""
"Open *fullurl* using the appropriate protocol.  This method sets up cache "
"and proxy information, then calls the appropriate open method with its input "
"arguments.  If the scheme is not recognized, :meth:`open_unknown` is called. "
"The *data* argument has the same meaning as the *data* argument of :func:"
"`urlopen`."
msgstr ""

#: ../../library/urllib.request.rst:1462
msgid "This method always quotes *fullurl* using :func:`~urllib.parse.quote`."
msgstr ""

#: ../../library/urllib.request.rst:1466
msgid "Overridable interface to open unknown URL types."
msgstr ""

#: ../../library/urllib.request.rst:1471
msgid ""
"Retrieves the contents of *url* and places it in *filename*.  The return "
"value is a tuple consisting of a local filename and either an :class:`email."
"message.Message` object containing the response headers (for remote URLs) or "
"``None`` (for local URLs).  The caller must then open and read the contents "
"of *filename*.  If *filename* is not given and the URL refers to a local "
"file, the input filename is returned.  If the URL is non-local and "
"*filename* is not given, the filename is the output of :func:`tempfile."
"mktemp` with a suffix that matches the suffix of the last path component of "
"the input URL.  If *reporthook* is given, it must be a function accepting "
"three numeric parameters: A chunk number, the maximum size chunks are read "
"in and the total size of the download (-1 if unknown).  It will be called "
"once at the start and after each chunk of data is read from the network.  "
"*reporthook* is ignored for local URLs."
msgstr ""

#: ../../library/urllib.request.rst:1484
msgid ""
"If the *url* uses the :file:`http:` scheme identifier, the optional *data* "
"argument may be given to specify a ``POST`` request (normally the request "
"type is ``GET``).  The *data* argument must in standard :mimetype:"
"`application/x-www-form-urlencoded` format; see the :func:`urllib.parse."
"urlencode` function."
msgstr ""

#: ../../library/urllib.request.rst:1493
msgid ""
"Variable that specifies the user agent of the opener object.  To get :mod:"
"`urllib` to tell servers that it is a particular user agent, set this in a "
"subclass as a class variable or in the constructor before calling the base "
"constructor."
msgstr ""

#: ../../library/urllib.request.rst:1503
msgid ""
":class:`FancyURLopener` subclasses :class:`URLopener` providing default "
"handling for the following HTTP response codes: 301, 302, 303, 307 and 401.  "
"For the 30x response codes listed above, the :mailheader:`Location` header "
"is used to fetch the actual URL.  For 401 response codes (authentication "
"required), basic HTTP authentication is performed.  For the 30x response "
"codes, recursion is bounded by the value of the *maxtries* attribute, which "
"defaults to 10."
msgstr ""

#: ../../library/urllib.request.rst:1510
msgid ""
"For all other response codes, the method :meth:`~BaseHandler."
"http_error_default` is called which you can override in subclasses to handle "
"the error appropriately."
msgstr ""

#: ../../library/urllib.request.rst:1515
msgid ""
"According to the letter of :rfc:`2616`, 301 and 302 responses to POST "
"requests must not be automatically redirected without confirmation by the "
"user.  In reality, browsers do allow automatic redirection of these "
"responses, changing the POST to a GET, and :mod:`urllib` reproduces this "
"behaviour."
msgstr ""

#: ../../library/urllib.request.rst:1520
msgid ""
"The parameters to the constructor are the same as those for :class:"
"`URLopener`."
msgstr ""

#: ../../library/urllib.request.rst:1524
msgid ""
"When performing basic authentication, a :class:`FancyURLopener` instance "
"calls its :meth:`prompt_user_passwd` method.  The default implementation "
"asks the users for the required information on the controlling terminal.  A "
"subclass may override this method to support more appropriate behavior if "
"needed."
msgstr ""

#: ../../library/urllib.request.rst:1529
msgid ""
"The :class:`FancyURLopener` class offers one additional method that should "
"be overloaded to provide the appropriate behavior:"
msgstr ""

#: ../../library/urllib.request.rst:1534
msgid ""
"Return information needed to authenticate the user at the given host in the "
"specified security realm.  The return value should be a tuple, ``(user, "
"password)``, which can be used for basic authentication."
msgstr ""

#: ../../library/urllib.request.rst:1538
msgid ""
"The implementation prompts for this information on the terminal; an "
"application should override this method to use an appropriate interaction "
"model in the local environment."
msgstr ""

#: ../../library/urllib.request.rst:1544
msgid ":mod:`urllib.request` Restrictions"
msgstr ""

#: ../../library/urllib.request.rst:1550
msgid ""
"Currently, only the following protocols are supported: HTTP (versions 0.9 "
"and 1.0), FTP, local files, and data URLs."
msgstr ""

#: ../../library/urllib.request.rst:1553
msgid "Added support for data URLs."
msgstr ""

#: ../../library/urllib.request.rst:1555
msgid ""
"The caching feature of :func:`urlretrieve` has been disabled until someone "
"finds the time to hack proper processing of Expiration time headers."
msgstr ""

#: ../../library/urllib.request.rst:1558
msgid ""
"There should be a function to query whether a particular URL is in the cache."
msgstr ""

#: ../../library/urllib.request.rst:1560
msgid ""
"For backward compatibility, if a URL appears to point to a local file but "
"the file can't be opened, the URL is re-interpreted using the FTP protocol.  "
"This can sometimes cause confusing error messages."
msgstr ""

#: ../../library/urllib.request.rst:1564
msgid ""
"The :func:`urlopen` and :func:`urlretrieve` functions can cause arbitrarily "
"long delays while waiting for a network connection to be set up.  This means "
"that it is difficult to build an interactive web client using these "
"functions without using threads."
msgstr ""

#: ../../library/urllib.request.rst:1573
msgid ""
"The data returned by :func:`urlopen` or :func:`urlretrieve` is the raw data "
"returned by the server.  This may be binary data (such as an image), plain "
"text or (for example) HTML.  The HTTP protocol provides type information in "
"the reply header, which can be inspected by looking at the :mailheader:"
"`Content-Type` header.  If the returned data is HTML, you can use the "
"module :mod:`html.parser` to parse it."
msgstr ""

#: ../../library/urllib.request.rst:1582
msgid ""
"The code handling the FTP protocol cannot differentiate between a file and a "
"directory.  This can lead to unexpected behavior when attempting to read a "
"URL that points to a file that is not accessible.  If the URL ends in a ``/"
"``, it is assumed to refer to a directory and will be handled accordingly.  "
"But if an attempt to read a file leads to a 550 error (meaning the URL "
"cannot be found or is not accessible, often for permission reasons), then "
"the path is treated as a directory in order to handle the case when a "
"directory is specified by a URL but the trailing ``/`` has been left off.  "
"This can cause misleading results when you try to fetch a file whose read "
"permissions make it inaccessible; the FTP code will try to read it, fail "
"with a 550 error, and then perform a directory listing for the unreadable "
"file. If fine-grained control is needed, consider using the :mod:`ftplib` "
"module, subclassing :class:`FancyURLopener`, or changing *_urlopener* to "
"meet your needs."
msgstr ""

#: ../../library/urllib.request.rst:1599
msgid ":mod:`urllib.response` --- Response classes used by urllib"
msgstr ""

#: ../../library/urllib.request.rst:1604
msgid ""
"The :mod:`urllib.response` module defines functions and classes which define "
"a minimal file-like interface, including ``read()`` and ``readline()``. "
"Functions defined by this module are used internally by the :mod:`urllib."
"request` module. The typical response object is a :class:`urllib.response."
"addinfourl` instance:"
msgstr ""

#: ../../library/urllib.request.rst:1613
msgid ""
"URL of the resource retrieved, commonly used to determine if a redirect was "
"followed."
msgstr ""

#: ../../library/urllib.request.rst:1617
msgid ""
"Returns the headers of the response in the form of an :class:`~email.message."
"EmailMessage` instance."
msgstr ""

#: ../../library/urllib.request.rst:1623
msgid "Status code returned by server."
msgstr ""

#: ../../library/urllib.request.rst:1627
msgid "Deprecated in favor of :attr:`~addinfourl.url`."
msgstr ""

#: ../../library/urllib.request.rst:1632
msgid "Deprecated in favor of :attr:`~addinfourl.headers`."
msgstr ""

#: ../../library/urllib.request.rst:1637 ../../library/urllib.request.rst:1642
msgid "Deprecated in favor of :attr:`~addinfourl.status`."
msgstr ""

#: ../../library/urllib.request.rst:1546 ../../library/urllib.request.rst:1569
msgid "HTTP"
msgstr "HTTP"

#: ../../library/urllib.request.rst:1546 ../../library/urllib.request.rst:1569
msgid "protocol"
msgstr "protocol（協定）"

#: ../../library/urllib.request.rst:1546 ../../library/urllib.request.rst:1580
msgid "FTP"
msgstr "FTP"

#: ../../library/urllib.request.rst:1569
msgid "HTML"
msgstr "HTML"