search

Hướng dẫn how do you add a parameter to a url in python? - làm thế nào để bạn thêm một tham số vào một url trong python?

1 năms trước
Trả lời: 0
Lượt xem: 136

Tại sao

Tôi đã không hài lòng với tất cả các giải pháp trên trang này (thôi nào, nơi sao chép yêu thích của chúng tôi?) Vì vậy tôi đã viết dựa trên câu trả lời của riêng mình ở đây. Nó cố gắng để hoàn thành và nhiều pythonic hơn. Tôi đã thêm một trình xử lý cho các giá trị Dict và Bool trong các đối số để thân thiện với phía người tiêu dùng hơn (JS), nhưng chúng vẫn chưa tùy chọn, bạn có thể bỏ chúng.dict and bool values in arguments to be more consumer-side (JS) friendly, but they are yet optional, you can drop them.

Show

Làm thế nào nó hoạt động

Kiểm tra 1: Thêm đối số mới, mảng xử lý và giá trị bool: Adding new arguments, handling Arrays and Bool values:

url = 'http://stackoverflow.com/test'
new_params = {'answers': False, 'data': ['some','values']}

add_url_params(url, new_params) == \
    'http://stackoverflow.com/test?data=some&data=values&answers=false'

Kiểm tra 2: Viết lại ARG hiện tại, Xử lý các giá trị Dict: Rewriting existing args, handling DICT values:

url = 'http://stackoverflow.com/test/?question=false'
new_params = {'question': {'__X__':'__Y__'}}

add_url_params(url, new_params) == \
    'http://stackoverflow.com/test/?question=%7B%22__X__%22%3A+%22__Y__%22%7D'

Nói chuyện là rẻ. Cho tôi xem mã.

Mã hóa chính nó. Tôi đã cố gắng mô tả nó chi tiết:

from json import dumps

try:
    from urllib import urlencode, unquote
    from urlparse import urlparse, parse_qsl, ParseResult
except ImportError:
    # Python 3 fallback
    from urllib.parse import (
        urlencode, unquote, urlparse, parse_qsl, ParseResult
    )


def add_url_params(url, params):
    """ Add GET params to provided URL being aware of existing.

    :param url: string of target URL
    :param params: dict containing requested params to be added
    :return: string with updated URL

    >> url = 'http://stackoverflow.com/test?answers=true'
    >> new_params = {'answers': False, 'data': ['some','values']}
    >> add_url_params(url, new_params)
    'http://stackoverflow.com/test?data=some&data=values&answers=false'
    """
    # Unquoting URL first so we don't loose existing args
    url = unquote(url)
    # Extracting url info
    parsed_url = urlparse(url)
    # Extracting URL arguments from parsed URL
    get_args = parsed_url.query
    # Converting URL arguments to dict
    parsed_get_args = dict(parse_qsl(get_args))
    # Merging URL arguments dict with new params
    parsed_get_args.update(params)

    # Bool and Dict values should be converted to json-friendly values
    # you may throw this part away if you don't like it :)
    parsed_get_args.update(
        {k: dumps(v) for k, v in parsed_get_args.items()
         if isinstance(v, (bool, dict))}
    )

    # Converting URL argument to proper query string
    encoded_get_args = urlencode(parsed_get_args, doseq=True)
    # Creating new parsed result object based on provided with new
    # URL arguments. Same thing happens inside of urlparse.
    new_url = ParseResult(
        parsed_url.scheme, parsed_url.netloc, parsed_url.path,
        parsed_url.params, encoded_get_args, parsed_url.fragment
    ).geturl()

    return new_url

Xin lưu ý rằng có thể có một số vấn đề, nếu bạn tìm thấy một vấn đề, xin vui lòng cho tôi biết và chúng tôi sẽ làm cho điều này tốt hơn

Gần đây tôi đã cố gắng tự động hóa việc thêm một tham số truy vấn vào một loạt các URL và bắt gặp một cách tiếp cận gọn gàng một chặng đường dài xuống câu trả lời StackOverflow này, sử dụng lớp PreckerRequest từ thư viện yêu cầu.

Trước tiên, hãy để Lớp nhập vào lớp:

from requests.models import PreparedRequest
req = PreparedRequest()

Và bây giờ, hãy để sử dụng sử dụng lớp này để thêm tham số truy vấn vào URL. Chúng ta có thể làm điều này với mã sau:

url = "http://www.neo4j.com"
params = {'ref':"mark-blog"}
req.prepare_url(url, params)

Và sau đó chúng ta cần truy cập thuộc tính 

url = "https://www.youtube.com/watch?v=Y-Wqna-hC2Y&list=RDhlznpxNGFGQ&index=2"
params = {'ref':"mark-blog"}
req.prepare_url(url, params)
2 để xem URL mới của chúng ta:

>>> req.url
'http://www.neo4j.com/?ref=mark-blog'

Gọn gàng! Chúng tôi cũng có thể sử dụng phương pháp này để thêm các tham số vào các URL đã có các URL hiện có. Ví dụ: chúng tôi có thể cập nhật URL YouTube này:

url = "https://www.youtube.com/watch?v=Y-Wqna-hC2Y&list=RDhlznpxNGFGQ&index=2"
params = {'ref':"mark-blog"}
req.prepare_url(url, params)

Và hãy để xem URL được cập nhật trông như thế nào:

>>> req.url
'https://www.youtube.com/watch?v=Y-Wqna-hC2Y&list=RDhlznpxNGFGQ&index=2&ref=mark-blog'

Tôi chắc chắn rằng tôi sẽ sử dụng đoạn mã này trong tương lai!

Chuỗi truy vấn URL là gì?

Một URL điển hình trông rất giống một đường dẫn tệp hệ thống, ví dụ:

 http://www.example.com/index.html

Một chuỗi truy vấn là một quy ước để nối các cặp giá trị khóa vào URL. URL tiêu chuẩn cho trang web New York của New York Times là:query string is a convention for appending key-value pairs to a URL. The standard URL for the New York Times's website's New York section is this:

  http://www.nytimes.com/section/nyregion

Tuy nhiên, nếu bạn nhấp vào tab New York qua trang chủ của NYTimes.com, bạn sẽ nhận thấy rằng cả một loạt các ký tự được thêm vào URL:

url = 'http://stackoverflow.com/test/?question=false'
new_params = {'question': {'__X__':'__Y__'}}

add_url_params(url, new_params) == \
    'http://stackoverflow.com/test/?question=%7B%22__X__%22%3A+%22__Y__%22%7D'
0

Dấu câu hỏi 

url = "https://www.youtube.com/watch?v=Y-Wqna-hC2Y&list=RDhlznpxNGFGQ&index=2"
params = {'ref':"mark-blog"}
req.prepare_url(url, params)
3 biểu thị sự phân tách giữa URL tiêu chuẩn và chuỗi truy vấn. Tất cả mọi thứ sau đó là một cặp giá trị chính, với mỗi cặp được phân tách bằng một ampersand, 
url = "https://www.youtube.com/watch?v=Y-Wqna-hC2Y&list=RDhlznpxNGFGQ&index=2"
params = {'ref':"mark-blog"}
req.prepare_url(url, params)
4. Dấu hiệu bằng 
url = "https://www.youtube.com/watch?v=Y-Wqna-hC2Y&list=RDhlznpxNGFGQ&index=2"
params = {'ref':"mark-blog"}
req.prepare_url(url, params)
5 được sử dụng để tách khóa và giá trị.question mark 
url = "https://www.youtube.com/watch?v=Y-Wqna-hC2Y&list=RDhlznpxNGFGQ&index=2"
params = {'ref':"mark-blog"}
req.prepare_url(url, params)
3 denotes the separation between the standard URL and the query string. Everything after that is a key value pair, with each pair separated by an ampersand, 
url = "https://www.youtube.com/watch?v=Y-Wqna-hC2Y&list=RDhlznpxNGFGQ&index=2"
params = {'ref':"mark-blog"}
req.prepare_url(url, params)
4. The equals sign 
url = "https://www.youtube.com/watch?v=Y-Wqna-hC2Y&list=RDhlznpxNGFGQ&index=2"
params = {'ref':"mark-blog"}
req.prepare_url(url, params)
5 is used to separate key and value.

Vì vậy, các cặp giá trị khóa trong chuỗi truy vấn trên là:

Chìa khóagiá trị
hoạt độngnhấp chuột
pgtypeTrang chủ

Hoặc, nhiều hơn cho mục đích của chúng tôi, đây là những gì các bàn phím đó sẽ trông như một từ điển:dictionary:

url = 'http://stackoverflow.com/test/?question=false'
new_params = {'question': {'__X__':'__Y__'}}

add_url_params(url, new_params) == \
    'http://stackoverflow.com/test/?question=%7B%22__X__%22%3A+%22__Y__%22%7D'
1

Những người thực sự làm gì? Đó thực sự là một câu hỏi mà chúng tôi không thể trả lời, trừ khi chúng tôi đang chạy các máy chủ NYTimes.com. Mặc dù có thể an toàn khi cho rằng NYT sử dụng chuỗi truy vấn trong các phân tích của nó, để có thể biết có bao nhiêu người đã truy cập 

url = "https://www.youtube.com/watch?v=Y-Wqna-hC2Y&list=RDhlznpxNGFGQ&index=2"
params = {'ref':"mark-blog"}
req.prepare_url(url, params)
6 thông qua trang chủ và bằng cách nhấp vào một số nút.

Các dịch vụ web khác có các chuỗi truy vấn phục vụ một mục đích rõ ràng hơn. Ví dụ, Duckduckgo, có điểm cuối URL này:DuckDuckGo, which has this URL endpoint:

url = 'http://stackoverflow.com/test/?question=false'
new_params = {'question': {'__X__':'__Y__'}}

add_url_params(url, new_params) == \
    'http://stackoverflow.com/test/?question=%7B%22__X__%22%3A+%22__Y__%22%7D'
2

Tuy nhiên, nếu chúng ta nối một giá trị cặp khóa là chuỗi truy vấn, với 

url = "https://www.youtube.com/watch?v=Y-Wqna-hC2Y&list=RDhlznpxNGFGQ&index=2"
params = {'ref':"mark-blog"}
req.prepare_url(url, params)
7 là chìa khóa (hãy nghĩ về nó như là một chữ viết tắt cho "truy vấn") và giá trị là thuật ngữ chúng ta muốn tìm kiếm, ví dụ: 
url = "https://www.youtube.com/watch?v=Y-Wqna-hC2Y&list=RDhlznpxNGFGQ&index=2"
params = {'ref':"mark-blog"}
req.prepare_url(url, params)
8, sau đó Duckduckgo sẽ trả về kết quả tìm kiếm cho 
url = "https://www.youtube.com/watch?v=Y-Wqna-hC2Y&list=RDhlznpxNGFGQ&index=2"
params = {'ref':"mark-blog"}
req.prepare_url(url, params)
8:key (think of it as an abbreviation for "query") and the value being the term we want to search for, e.g. 
url = "https://www.youtube.com/watch?v=Y-Wqna-hC2Y&list=RDhlznpxNGFGQ&index=2"
params = {'ref':"mark-blog"}
req.prepare_url(url, params)
8, then DuckDuckGo will return search results for 
url = "https://www.youtube.com/watch?v=Y-Wqna-hC2Y&list=RDhlznpxNGFGQ&index=2"
params = {'ref':"mark-blog"}
req.prepare_url(url, params)
8:

url = 'http://stackoverflow.com/test/?question=false'
new_params = {'question': {'__X__':'__Y__'}}

add_url_params(url, new_params) == \
    'http://stackoverflow.com/test/?question=%7B%22__X__%22%3A+%22__Y__%22%7D'
3

Ký tự không hợp lệ cho URL

Thật khó để nói những ngày này vì các trình duyệt web hiện đại cho phép chúng tôi gõ bất cứ thứ gì từ bàn phím. Trừ khi chúng tôi dành đầu vào với 

>>> req.url
'https://www.youtube.com/watch?v=Y-Wqna-hC2Y&list=RDhlznpxNGFGQ&index=2&ref=mark-blog'
0, văn bản chỉ được gửi như là Google hoặc Duckduckgo hoặc bất kỳ công cụ tìm kiếm mặc định nào của bạn.

Tuy nhiên, đây chỉ là một ảo ảnh thuận tiện. Khi chúng tôi nhập vào thanh trình duyệt của bạn, nói, một cái gì đó có ký tự khoảng trắng, ví dụ:

url = 'http://stackoverflow.com/test/?question=false'
new_params = {'question': {'__X__':'__Y__'}}

add_url_params(url, new_params) == \
    'http://stackoverflow.com/test/?question=%7B%22__X__%22%3A+%22__Y__%22%7D'
4

Trước khi gửi nó đến công cụ tìm kiếm, trình duyệt web sẽ thực sự tuần tự hóa nó như:

url = 'http://stackoverflow.com/test/?question=false'
new_params = {'question': {'__X__':'__Y__'}}

add_url_params(url, new_params) == \
    'http://stackoverflow.com/test/?question=%7B%22__X__%22%3A+%22__Y__%22%7D'
5

Điều này là do các ký tự khoảng trắng không được phép trong các URL, vì vậy mã thông báo 

>>> req.url
'https://www.youtube.com/watch?v=Y-Wqna-hC2Y&list=RDhlznpxNGFGQ&index=2&ref=mark-blog'
1 được sử dụng để đại diện cho nó. Về cơ bản, hầu hết mọi thứ không phải là một nhân vật chữ và số cần phải có mã hóa đặc biệt này.not allowed in URLs, so the token 
>>> req.url
'https://www.youtube.com/watch?v=Y-Wqna-hC2Y&list=RDhlznpxNGFGQ&index=2&ref=mark-blog'
1 is used to represent it. Basically, almost everything that is not an alphanumeric character needs to have this special encoding.

Vào thời xa xưa, bạn phải nhớ cách thực hiện các mã hóa này nếu không thì trình duyệt sẽ khiến bạn gặp lỗi. Bây giờ, trình duyệt chỉ sửa nó cho bạn, không giống như trình kiểm tra chính tả tự động.

Cách Urllib của Python xử lý các ký tự URL không hợp lệ

Tất nhiên, khi lập trình trong Python, mọi thứ vẫn hoạt động như thời xa xưa - tức là chúng ta buộc phải là _Explicit.

Đây là những gì xảy ra khi bạn sử dụng phương pháp 

>>> req.url
'https://www.youtube.com/watch?v=Y-Wqna-hC2Y&list=RDhlznpxNGFGQ&index=2&ref=mark-blog'
2 đi qua mô-đun tích hợp của Python 
>>> req.url
'https://www.youtube.com/watch?v=Y-Wqna-hC2Y&list=RDhlznpxNGFGQ&index=2&ref=mark-blog'
3:

url = 'http://stackoverflow.com/test/?question=false'
new_params = {'question': {'__X__':'__Y__'}}

add_url_params(url, new_params) == \
    'http://stackoverflow.com/test/?question=%7B%22__X__%22%3A+%22__Y__%22%7D'
6

Một lỗi được nêu ra:

url = 'http://stackoverflow.com/test/?question=false'
new_params = {'question': {'__X__':'__Y__'}}

add_url_params(url, new_params) == \
    'http://stackoverflow.com/test/?question=%7B%22__X__%22%3A+%22__Y__%22%7D'
7

Chúng ta phải tự mình ném vào 

>>> req.url
'https://www.youtube.com/watch?v=Y-Wqna-hC2Y&list=RDhlznpxNGFGQ&index=2&ref=mark-blog'
1 để tránh lỗi:

url = 'http://stackoverflow.com/test/?question=false'
new_params = {'question': {'__X__':'__Y__'}}

add_url_params(url, new_params) == \
    'http://stackoverflow.com/test/?question=%7B%22__X__%22%3A+%22__Y__%22%7D'
8

Sử dụng urllib.parse.quote để thoát khỏi các ký tự không hợp lệ

Cố gắng nhớ những nhân vật nào không hợp lệ, không bao giờ thoát khỏi chúng bằng tay với các dấu hiệu phần trăm, là một nhiệm vụ điên rồ. Đó là lý do tại sao có một mô-đun Python tích hợp-Urllib.parse-có chứa một phương pháp thích hợp: 

>>> req.url
'https://www.youtube.com/watch?v=Y-Wqna-hC2Y&list=RDhlznpxNGFGQ&index=2&ref=mark-blog'
5.

Hãy thử nó thông qua Python tương tác - Lưu ý rằng 

>>> req.url
'https://www.youtube.com/watch?v=Y-Wqna-hC2Y&list=RDhlznpxNGFGQ&index=2&ref=mark-blog'
6 không thực sự tự thực hiện bất kỳ URL nào - đó là một phương pháp làm một điều và một điều tốt: làm cho chuỗi an toàn cho URL:

url = 'http://stackoverflow.com/test/?question=false'
new_params = {'question': {'__X__':'__Y__'}}

add_url_params(url, new_params) == \
    'http://stackoverflow.com/test/?question=%7B%22__X__%22%3A+%22__Y__%22%7D'
9

Kết hợp với phương pháp URLRETREE đã được thử trước đó:

from json import dumps

try:
    from urllib import urlencode, unquote
    from urlparse import urlparse, parse_qsl, ParseResult
except ImportError:
    # Python 3 fallback
    from urllib.parse import (
        urlencode, unquote, urlparse, parse_qsl, ParseResult
    )


def add_url_params(url, params):
    """ Add GET params to provided URL being aware of existing.

    :param url: string of target URL
    :param params: dict containing requested params to be added
    :return: string with updated URL

    >> url = 'http://stackoverflow.com/test?answers=true'
    >> new_params = {'answers': False, 'data': ['some','values']}
    >> add_url_params(url, new_params)
    'http://stackoverflow.com/test?data=some&data=values&answers=false'
    """
    # Unquoting URL first so we don't loose existing args
    url = unquote(url)
    # Extracting url info
    parsed_url = urlparse(url)
    # Extracting URL arguments from parsed URL
    get_args = parsed_url.query
    # Converting URL arguments to dict
    parsed_get_args = dict(parse_qsl(get_args))
    # Merging URL arguments dict with new params
    parsed_get_args.update(params)

    # Bool and Dict values should be converted to json-friendly values
    # you may throw this part away if you don't like it :)
    parsed_get_args.update(
        {k: dumps(v) for k, v in parsed_get_args.items()
         if isinstance(v, (bool, dict))}
    )

    # Converting URL argument to proper query string
    encoded_get_args = urlencode(parsed_get_args, doseq=True)
    # Creating new parsed result object based on provided with new
    # URL arguments. Same thing happens inside of urlparse.
    new_url = ParseResult(
        parsed_url.scheme, parsed_url.netloc, parsed_url.path,
        parsed_url.params, encoded_get_args, parsed_url.fragment
    ).geturl()

    return new_url
0

Tuần tự hóa từ điển thành chuỗi truy vấn

Trong ví dụ trước, phải gõ rằng 

>>> req.url
'https://www.youtube.com/watch?v=Y-Wqna-hC2Y&list=RDhlznpxNGFGQ&index=2&ref=mark-blog'
7 cũng có vẻ tẻ nhạt đối với bạn. Một lần nữa, urllib.parse có một phương thức cho điều đó: urlencode.urlencode.

Hãy thử nó trong Python tương tác:

from json import dumps

try:
    from urllib import urlencode, unquote
    from urlparse import urlparse, parse_qsl, ParseResult
except ImportError:
    # Python 3 fallback
    from urllib.parse import (
        urlencode, unquote, urlparse, parse_qsl, ParseResult
    )


def add_url_params(url, params):
    """ Add GET params to provided URL being aware of existing.

    :param url: string of target URL
    :param params: dict containing requested params to be added
    :return: string with updated URL

    >> url = 'http://stackoverflow.com/test?answers=true'
    >> new_params = {'answers': False, 'data': ['some','values']}
    >> add_url_params(url, new_params)
    'http://stackoverflow.com/test?data=some&data=values&answers=false'
    """
    # Unquoting URL first so we don't loose existing args
    url = unquote(url)
    # Extracting url info
    parsed_url = urlparse(url)
    # Extracting URL arguments from parsed URL
    get_args = parsed_url.query
    # Converting URL arguments to dict
    parsed_get_args = dict(parse_qsl(get_args))
    # Merging URL arguments dict with new params
    parsed_get_args.update(params)

    # Bool and Dict values should be converted to json-friendly values
    # you may throw this part away if you don't like it :)
    parsed_get_args.update(
        {k: dumps(v) for k, v in parsed_get_args.items()
         if isinstance(v, (bool, dict))}
    )

    # Converting URL argument to proper query string
    encoded_get_args = urlencode(parsed_get_args, doseq=True)
    # Creating new parsed result object based on provided with new
    # URL arguments. Same thing happens inside of urlparse.
    new_url = ParseResult(
        parsed_url.scheme, parsed_url.netloc, parsed_url.path,
        parsed_url.params, encoded_get_args, parsed_url.fragment
    ).geturl()

    return new_url
1

Lưu ý rằng phương pháp 

>>> req.url
'https://www.youtube.com/watch?v=Y-Wqna-hC2Y&list=RDhlznpxNGFGQ&index=2&ref=mark-blog'
8 bao gồm chức năng của hàm 
>>> req.url
'https://www.youtube.com/watch?v=Y-Wqna-hC2Y&list=RDhlznpxNGFGQ&index=2&ref=mark-blog'
5, do đó, có lẽ bạn hiếm khi cần phải gọi 
>>> req.url
'https://www.youtube.com/watch?v=Y-Wqna-hC2Y&list=RDhlznpxNGFGQ&index=2&ref=mark-blog'
5. Cũng lưu ý rằng 
>>> req.url
'https://www.youtube.com/watch?v=Y-Wqna-hC2Y&list=RDhlznpxNGFGQ&index=2&ref=mark-blog'
8 sử dụng dấu 
 http://www.example.com/index.html
2 để mã hóa ký tự không gian trong URL, về cơ bản cũng hợp lệ như sử dụng 
>>> req.url
'https://www.youtube.com/watch?v=Y-Wqna-hC2Y&list=RDhlznpxNGFGQ&index=2&ref=mark-blog'
1. Một lần nữa, các quy tắc và tiêu chuẩn khó hiểu là một lý do khác để ủy thác phân tích chuỗi này cho các thư viện Python thích hợp.

Và, một lần nữa, 

>>> req.url
'https://www.youtube.com/watch?v=Y-Wqna-hC2Y&list=RDhlznpxNGFGQ&index=2&ref=mark-blog'
8 không thực sự tìm nạp URL. Chúng tôi vẫn phải sử dụng 
>>> req.url
'https://www.youtube.com/watch?v=Y-Wqna-hC2Y&list=RDhlznpxNGFGQ&index=2&ref=mark-blog'
2:

from json import dumps

try:
    from urllib import urlencode, unquote
    from urlparse import urlparse, parse_qsl, ParseResult
except ImportError:
    # Python 3 fallback
    from urllib.parse import (
        urlencode, unquote, urlparse, parse_qsl, ParseResult
    )


def add_url_params(url, params):
    """ Add GET params to provided URL being aware of existing.

    :param url: string of target URL
    :param params: dict containing requested params to be added
    :return: string with updated URL

    >> url = 'http://stackoverflow.com/test?answers=true'
    >> new_params = {'answers': False, 'data': ['some','values']}
    >> add_url_params(url, new_params)
    'http://stackoverflow.com/test?data=some&data=values&answers=false'
    """
    # Unquoting URL first so we don't loose existing args
    url = unquote(url)
    # Extracting url info
    parsed_url = urlparse(url)
    # Extracting URL arguments from parsed URL
    get_args = parsed_url.query
    # Converting URL arguments to dict
    parsed_get_args = dict(parse_qsl(get_args))
    # Merging URL arguments dict with new params
    parsed_get_args.update(params)

    # Bool and Dict values should be converted to json-friendly values
    # you may throw this part away if you don't like it :)
    parsed_get_args.update(
        {k: dumps(v) for k, v in parsed_get_args.items()
         if isinstance(v, (bool, dict))}
    )

    # Converting URL argument to proper query string
    encoded_get_args = urlencode(parsed_get_args, doseq=True)
    # Creating new parsed result object based on provided with new
    # URL arguments. Same thing happens inside of urlparse.
    new_url = ParseResult(
        parsed_url.scheme, parsed_url.netloc, parsed_url.path,
        parsed_url.params, encoded_get_args, parsed_url.fragment
    ).geturl()

    return new_url
2

Lưu ý rằng chúng tôi cũng phải bao gồm 

url = "https://www.youtube.com/watch?v=Y-Wqna-hC2Y&list=RDhlznpxNGFGQ&index=2"
params = {'ref':"mark-blog"}
req.prepare_url(url, params)
3, luôn được sử dụng để đặt chuỗi truy vấn từ phần đầu tiên của URL.

Cũng lưu ý rằng việc tìm kiếm các truy vấn tìm kiếm theo chương trình qua Duckduckgo (hoặc Google, vì vấn đề đó) không hiệu quả lắm. Tôi chỉ sử dụng nó làm ví dụ để bạn có thể thấy URL hóa ra là gì và kiểm tra nó trong trình duyệt của bạn.

Yêu cầu giải cứu

Thế còn thư viện yêu cầu mà chúng tôi đã sử dụng để tìm nạp URL cho hầu hết các phần? Vâng, đúng với khẩu hiệu của nó là "HTTP cho con người", thư viện yêu cầu kết thúc một cách gọn gàng tất cả các chức năng 

 http://www.example.com/index.html
7 cho chúng tôi.

Chỉ cần sử dụng phương thức 

 http://www.example.com/index.html
8 với đối số thứ hai (tên của đối số là 
 http://www.example.com/index.html
9):

from json import dumps

try:
    from urllib import urlencode, unquote
    from urlparse import urlparse, parse_qsl, ParseResult
except ImportError:
    # Python 3 fallback
    from urllib.parse import (
        urlencode, unquote, urlparse, parse_qsl, ParseResult
    )


def add_url_params(url, params):
    """ Add GET params to provided URL being aware of existing.

    :param url: string of target URL
    :param params: dict containing requested params to be added
    :return: string with updated URL

    >> url = 'http://stackoverflow.com/test?answers=true'
    >> new_params = {'answers': False, 'data': ['some','values']}
    >> add_url_params(url, new_params)
    'http://stackoverflow.com/test?data=some&data=values&answers=false'
    """
    # Unquoting URL first so we don't loose existing args
    url = unquote(url)
    # Extracting url info
    parsed_url = urlparse(url)
    # Extracting URL arguments from parsed URL
    get_args = parsed_url.query
    # Converting URL arguments to dict
    parsed_get_args = dict(parse_qsl(get_args))
    # Merging URL arguments dict with new params
    parsed_get_args.update(params)

    # Bool and Dict values should be converted to json-friendly values
    # you may throw this part away if you don't like it :)
    parsed_get_args.update(
        {k: dumps(v) for k, v in parsed_get_args.items()
         if isinstance(v, (bool, dict))}
    )

    # Converting URL argument to proper query string
    encoded_get_args = urlencode(parsed_get_args, doseq=True)
    # Creating new parsed result object based on provided with new
    # URL arguments. Same thing happens inside of urlparse.
    new_url = ParseResult(
        parsed_url.scheme, parsed_url.netloc, parsed_url.path,
        parsed_url.params, encoded_get_args, parsed_url.fragment
    ).geturl()

    return new_url
3

Thử bản đồ tĩnh Google

Hãy làm việc với API trực quan, thú vị hơn: API bản đồ tĩnh Google

(Để biết thêm thông tin về API Google Static Map

Đánh giá các tham số bản đồ tĩnh

Như với hầu hết các API, Google Static Maps bắt đầu với điểm cuối URL:

from json import dumps

try:
    from urllib import urlencode, unquote
    from urlparse import urlparse, parse_qsl, ParseResult
except ImportError:
    # Python 3 fallback
    from urllib.parse import (
        urlencode, unquote, urlparse, parse_qsl, ParseResult
    )


def add_url_params(url, params):
    """ Add GET params to provided URL being aware of existing.

    :param url: string of target URL
    :param params: dict containing requested params to be added
    :return: string with updated URL

    >> url = 'http://stackoverflow.com/test?answers=true'
    >> new_params = {'answers': False, 'data': ['some','values']}
    >> add_url_params(url, new_params)
    'http://stackoverflow.com/test?data=some&data=values&answers=false'
    """
    # Unquoting URL first so we don't loose existing args
    url = unquote(url)
    # Extracting url info
    parsed_url = urlparse(url)
    # Extracting URL arguments from parsed URL
    get_args = parsed_url.query
    # Converting URL arguments to dict
    parsed_get_args = dict(parse_qsl(get_args))
    # Merging URL arguments dict with new params
    parsed_get_args.update(params)

    # Bool and Dict values should be converted to json-friendly values
    # you may throw this part away if you don't like it :)
    parsed_get_args.update(
        {k: dumps(v) for k, v in parsed_get_args.items()
         if isinstance(v, (bool, dict))}
    )

    # Converting URL argument to proper query string
    encoded_get_args = urlencode(parsed_get_args, doseq=True)
    # Creating new parsed result object based on provided with new
    # URL arguments. Same thing happens inside of urlparse.
    new_url = ParseResult(
        parsed_url.scheme, parsed_url.netloc, parsed_url.path,
        parsed_url.params, encoded_get_args, parsed_url.fragment
    ).geturl()

    return new_url
4

Ở mức tối thiểu, nó yêu cầu tham số kích thước, với giá trị ở định dạng 

  http://www.nytimes.com/section/nyregion
0:size parameter, with a value in the format of 
  http://www.nytimes.com/section/nyregion
0:

from json import dumps

try:
    from urllib import urlencode, unquote
    from urlparse import urlparse, parse_qsl, ParseResult
except ImportError:
    # Python 3 fallback
    from urllib.parse import (
        urlencode, unquote, urlparse, parse_qsl, ParseResult
    )


def add_url_params(url, params):
    """ Add GET params to provided URL being aware of existing.

    :param url: string of target URL
    :param params: dict containing requested params to be added
    :return: string with updated URL

    >> url = 'http://stackoverflow.com/test?answers=true'
    >> new_params = {'answers': False, 'data': ['some','values']}
    >> add_url_params(url, new_params)
    'http://stackoverflow.com/test?data=some&data=values&answers=false'
    """
    # Unquoting URL first so we don't loose existing args
    url = unquote(url)
    # Extracting url info
    parsed_url = urlparse(url)
    # Extracting URL arguments from parsed URL
    get_args = parsed_url.query
    # Converting URL arguments to dict
    parsed_get_args = dict(parse_qsl(get_args))
    # Merging URL arguments dict with new params
    parsed_get_args.update(params)

    # Bool and Dict values should be converted to json-friendly values
    # you may throw this part away if you don't like it :)
    parsed_get_args.update(
        {k: dumps(v) for k, v in parsed_get_args.items()
         if isinstance(v, (bool, dict))}
    )

    # Converting URL argument to proper query string
    encoded_get_args = urlencode(parsed_get_args, doseq=True)
    # Creating new parsed result object based on provided with new
    # URL arguments. Same thing happens inside of urlparse.
    new_url = ParseResult(
        parsed_url.scheme, parsed_url.netloc, parsed_url.path,
        parsed_url.params, encoded_get_args, parsed_url.fragment
    ).geturl()

    return new_url
5

Đây là những gì bản đồ trông giống như:

Hãy thêm một tham số khác: Zoomzoom

from json import dumps

try:
    from urllib import urlencode, unquote
    from urlparse import urlparse, parse_qsl, ParseResult
except ImportError:
    # Python 3 fallback
    from urllib.parse import (
        urlencode, unquote, urlparse, parse_qsl, ParseResult
    )


def add_url_params(url, params):
    """ Add GET params to provided URL being aware of existing.

    :param url: string of target URL
    :param params: dict containing requested params to be added
    :return: string with updated URL

    >> url = 'http://stackoverflow.com/test?answers=true'
    >> new_params = {'answers': False, 'data': ['some','values']}
    >> add_url_params(url, new_params)
    'http://stackoverflow.com/test?data=some&data=values&answers=false'
    """
    # Unquoting URL first so we don't loose existing args
    url = unquote(url)
    # Extracting url info
    parsed_url = urlparse(url)
    # Extracting URL arguments from parsed URL
    get_args = parsed_url.query
    # Converting URL arguments to dict
    parsed_get_args = dict(parse_qsl(get_args))
    # Merging URL arguments dict with new params
    parsed_get_args.update(params)

    # Bool and Dict values should be converted to json-friendly values
    # you may throw this part away if you don't like it :)
    parsed_get_args.update(
        {k: dumps(v) for k, v in parsed_get_args.items()
         if isinstance(v, (bool, dict))}
    )

    # Converting URL argument to proper query string
    encoded_get_args = urlencode(parsed_get_args, doseq=True)
    # Creating new parsed result object based on provided with new
    # URL arguments. Same thing happens inside of urlparse.
    new_url = ParseResult(
        parsed_url.scheme, parsed_url.netloc, parsed_url.path,
        parsed_url.params, encoded_get_args, parsed_url.fragment
    ).geturl()

    return new_url
6

Và hãy thay đổi nơi bản đồ được tập trung xung quanh với tham số trung tâm, lấy bất kỳ chuỗi nào mô tả vị trí có thể đọc được của con người:center parameter, which takes any string that describes a human-readable location:

from json import dumps

try:
    from urllib import urlencode, unquote
    from urlparse import urlparse, parse_qsl, ParseResult
except ImportError:
    # Python 3 fallback
    from urllib.parse import (
        urlencode, unquote, urlparse, parse_qsl, ParseResult
    )


def add_url_params(url, params):
    """ Add GET params to provided URL being aware of existing.

    :param url: string of target URL
    :param params: dict containing requested params to be added
    :return: string with updated URL

    >> url = 'http://stackoverflow.com/test?answers=true'
    >> new_params = {'answers': False, 'data': ['some','values']}
    >> add_url_params(url, new_params)
    'http://stackoverflow.com/test?data=some&data=values&answers=false'
    """
    # Unquoting URL first so we don't loose existing args
    url = unquote(url)
    # Extracting url info
    parsed_url = urlparse(url)
    # Extracting URL arguments from parsed URL
    get_args = parsed_url.query
    # Converting URL arguments to dict
    parsed_get_args = dict(parse_qsl(get_args))
    # Merging URL arguments dict with new params
    parsed_get_args.update(params)

    # Bool and Dict values should be converted to json-friendly values
    # you may throw this part away if you don't like it :)
    parsed_get_args.update(
        {k: dumps(v) for k, v in parsed_get_args.items()
         if isinstance(v, (bool, dict))}
    )

    # Converting URL argument to proper query string
    encoded_get_args = urlencode(parsed_get_args, doseq=True)
    # Creating new parsed result object based on provided with new
    # URL arguments. Same thing happens inside of urlparse.
    new_url = ParseResult(
        parsed_url.scheme, parsed_url.netloc, parsed_url.path,
        parsed_url.params, encoded_get_args, parsed_url.fragment
    ).geturl()

    return new_url
7

Hoặc, chúng ta có thể vượt qua trong một cặp vĩ độ/kinh độ:

from json import dumps

try:
    from urllib import urlencode, unquote
    from urlparse import urlparse, parse_qsl, ParseResult
except ImportError:
    # Python 3 fallback
    from urllib.parse import (
        urlencode, unquote, urlparse, parse_qsl, ParseResult
    )


def add_url_params(url, params):
    """ Add GET params to provided URL being aware of existing.

    :param url: string of target URL
    :param params: dict containing requested params to be added
    :return: string with updated URL

    >> url = 'http://stackoverflow.com/test?answers=true'
    >> new_params = {'answers': False, 'data': ['some','values']}
    >> add_url_params(url, new_params)
    'http://stackoverflow.com/test?data=some&data=values&answers=false'
    """
    # Unquoting URL first so we don't loose existing args
    url = unquote(url)
    # Extracting url info
    parsed_url = urlparse(url)
    # Extracting URL arguments from parsed URL
    get_args = parsed_url.query
    # Converting URL arguments to dict
    parsed_get_args = dict(parse_qsl(get_args))
    # Merging URL arguments dict with new params
    parsed_get_args.update(params)

    # Bool and Dict values should be converted to json-friendly values
    # you may throw this part away if you don't like it :)
    parsed_get_args.update(
        {k: dumps(v) for k, v in parsed_get_args.items()
         if isinstance(v, (bool, dict))}
    )

    # Converting URL argument to proper query string
    encoded_get_args = urlencode(parsed_get_args, doseq=True)
    # Creating new parsed result object based on provided with new
    # URL arguments. Same thing happens inside of urlparse.
    new_url = ParseResult(
        parsed_url.scheme, parsed_url.netloc, parsed_url.path,
        parsed_url.params, encoded_get_args, parsed_url.fragment
    ).geturl()

    return new_url
8

Thêm điểm đánh dấu

Có lẽ bạn đang nghĩ: Điều này thật dễ dàng, mã hóa các tham số URL. Hãy làm điều gì đó khó khăn. Tham số đánh dấu cho phép chúng tôi thêm các điểm đánh dấu vào bản đồ. Nó lấy một chuỗi vị trí (giống như trung tâm):markers parameter lets us add markers to the map. It takes a location string (just like center):

from json import dumps

try:
    from urllib import urlencode, unquote
    from urlparse import urlparse, parse_qsl, ParseResult
except ImportError:
    # Python 3 fallback
    from urllib.parse import (
        urlencode, unquote, urlparse, parse_qsl, ParseResult
    )


def add_url_params(url, params):
    """ Add GET params to provided URL being aware of existing.

    :param url: string of target URL
    :param params: dict containing requested params to be added
    :return: string with updated URL

    >> url = 'http://stackoverflow.com/test?answers=true'
    >> new_params = {'answers': False, 'data': ['some','values']}
    >> add_url_params(url, new_params)
    'http://stackoverflow.com/test?data=some&data=values&answers=false'
    """
    # Unquoting URL first so we don't loose existing args
    url = unquote(url)
    # Extracting url info
    parsed_url = urlparse(url)
    # Extracting URL arguments from parsed URL
    get_args = parsed_url.query
    # Converting URL arguments to dict
    parsed_get_args = dict(parse_qsl(get_args))
    # Merging URL arguments dict with new params
    parsed_get_args.update(params)

    # Bool and Dict values should be converted to json-friendly values
    # you may throw this part away if you don't like it :)
    parsed_get_args.update(
        {k: dumps(v) for k, v in parsed_get_args.items()
         if isinstance(v, (bool, dict))}
    )

    # Converting URL argument to proper query string
    encoded_get_args = urlencode(parsed_get_args, doseq=True)
    # Creating new parsed result object based on provided with new
    # URL arguments. Same thing happens inside of urlparse.
    new_url = ParseResult(
        parsed_url.scheme, parsed_url.netloc, parsed_url.path,
        parsed_url.params, encoded_get_args, parsed_url.fragment
    ).geturl()

    return new_url
9

Hướng dẫn how do you add a parameter to a url in python? - làm thế nào để bạn thêm một tham số vào một url trong python?

Tuy nhiên, API cho phép đánh dấu nhiều điểm (do đó, tên số nhiều tham số của "điểm đánh dấu"). Tiêu chuẩn cho các chuỗi truy vấn URL Khi nhiều giá trị có cùng một khóa là lặp lại khóa, nói cách khác, hiển thị 

  http://www.nytimes.com/section/nyregion
1 cho cả 
  http://www.nytimes.com/section/nyregion
2 và 
  http://www.nytimes.com/section/nyregion
3, chúng tôi bao gồm điều này trong chuỗi truy vấn:

from requests.models import PreparedRequest
req = PreparedRequest()
0

e.g.

from requests.models import PreparedRequest
req = PreparedRequest()
1

Tùy chỉnh phong cách của các điểm đánh dấu

Bởi vì cả thông tin phong cách và thông tin vị trí đều được phân định thông qua ký tự ống, thông tin kiểu phải xuất hiện đầu tiên trong bất kỳ mô tả đánh dấu nào. Khi máy chủ API của Google Static Maps sẽ gặp một vị trí trong bộ mô tả điểm đánh dấu, tất cả các tham số đánh dấu khác cũng được coi là vị trí.

Theo mặc định, các điểm đánh dấu bản đồ có màu đỏ. Để tạo màu xanh lá cây đánh dấu, đây là những gì giá trị 

  http://www.nytimes.com/section/nyregion
1 được đặt thành:red. To make a marker green, this is what the 
  http://www.nytimes.com/section/nyregion
1 value is set to:

from requests.models import PreparedRequest
req = PreparedRequest()
2

e.g.

from requests.models import PreparedRequest
req = PreparedRequest()
3
!]Chicago] (https://maps.googleapis.com/maps/api/staticmap?size=600x400&markers=Color:GreenChicago)

Chúng ta cũng có thể thay đổi kích thước của biểu tượng. Và cho nó một lá thư. Đây là giá trị cho một biểu tượng màu xanh cho Chicago, với một nhãn bao gồm chữ "X":

from requests.models import PreparedRequest
req = PreparedRequest()
4
!]Nhãn: xChicago] (https://maps.googleapis.com/maps/api/staticmap?size=600x400&markers=Color:BlueNhãn: xChicago)

Chúng ta cũng có thể thay đổi kích thước của biểu tượng. Và cho nó một lá thư. Đây là giá trị cho một biểu tượng màu xanh cho Chicago, với một nhãn bao gồm chữ "X":

from requests.models import PreparedRequest
req = PreparedRequest()
5

from requests.models import PreparedRequest
req = PreparedRequest()
4

from requests.models import PreparedRequest
req = PreparedRequest()
6

!]

from requests.models import PreparedRequest
req = PreparedRequest()
7

Nhãn: x

Chicago] (https://maps.googleapis.com/maps/api/staticmap?size=600x400&markers=Color:Blue

Về mặt kỹ thuật, trong khi các ví dụ URL ở trên sẽ hoạt động trong một trình duyệt hiện đại, các ký tự ống không được phép vào URL. Họ nên được trốn thoát với 

  http://www.nytimes.com/section/nyregion
5:

from requests.models import PreparedRequest
req = PreparedRequest()
8

Nếu điều đó không bị phức tạp/đủ xấu cho bạn, API Google Maps cho phép bạn sử dụng các biểu tượng tùy chỉnh. Đây là cách tạo điểm đánh dấu bằng khuôn mặt của Tổng thống Obama (được tìm thấy ở URL sau:

Hướng dẫn how do you add a parameter to a url in python? - làm thế nào để bạn thêm một tham số vào một url trong python?

Giá trị http://www.nytimes.com/section/nyregion 1 tương ứng:

Tuy nhiên, như bạn có thể tưởng tượng, một số ký tự trong URL không được phép như trong chuỗi truy vấn. Nghĩ về nó; Chúng ta đang đặt một URL bên trong một URL khác, làm thế nào một trình duyệt nguyên thủy dễ dàng phân tích lại điều đó? Ví dụ URL ở trên khá đơn giản, nhưng vì các URL có thể chứa bất kỳ số lượng ký tự lạ nào, chúng ta nên cho rằng nhiều nhân vật đó sẽ phải được mã hóa theo phần trăm thời trang đó. Từ lời giải thích của Google API:

Lưu ý: Nhiều cấp độ thoát ở trên có thể gây nhầm lẫn. API biểu đồ Google sử dụng ký tự ống (

  http://www.nytimes.com/section/nyregion
7) để phân định chuỗi trong các tham số URL của nó. Vì ký tự này không hợp pháp trong URL (xem ghi chú ở trên), khi tạo URL biểu đồ hoàn toàn hợp lệ, nó được thoát tới %7C. Bây giờ kết quả được nhúng như một chuỗi trong một đặc tả biểu tượng, nhưng nó chứa một ký tự %(từ %7C được đề cập ở trên), không thể được đưa trực tiếp dưới dạng dữ liệu trong URL và phải được thoát tới %25. Kết quả là URL chứa %257C, đại diện cho hai lớp mã hóa. Tương tự, URL biểu đồ chứa một & ký tự, không thể được bao gồm trực tiếp mà không bị nhầm lẫn như một dấu phân cách cho các tham số URL API của Google Static Maps, do đó, nó cũng phải được mã hóa.

from requests.models import PreparedRequest
req = PreparedRequest()
9

Đây là những gì URL kết thúc:

url = "http://www.neo4j.com"
params = {'ref':"mark-blog"}
req.prepare_url(url, params)
0

Và đây là đầu của Obama, nổi trên Chicago:

Lập trình tạo chuỗi truy vấn cho API Google Static Maps

OK, bây giờ chúng ta đã thấy cách làm mọi thứ theo cách đau đớn và lỗi thời, hãy sử dụng phương pháp http://www.nytimes.com/section/nyregion 8 để thực hiện công việc đau đớn trong việc tạo ra các chuỗi truy vấn URL.

Đầu tiên, hãy nhập 

>>> req.url
'https://www.youtube.com/watch?v=Y-Wqna-hC2Y&list=RDhlznpxNGFGQ&index=2&ref=mark-blog'
8 và thiết lập các hằng số, tức là các biến không thay đổi:

url = "http://www.neo4j.com"
params = {'ref':"mark-blog"}
req.prepare_url(url, params)
1

Nhập url = 'http://stackoverflow.com/test/?question=false' new_params = {'question': {'__X__':'__Y__'}} add_url_params(url, new_params) == \ 'http://stackoverflow.com/test/?question=%7B%22__X__%22%3A+%22__Y__%22%7D' 00 là tùy chọn. Nhưng nó cho phép bạn kiểm tra thuận tiện các URL từ mã Python của bạn:

(Bạn nên làm điều này trong Python tương tác)

url = "http://www.neo4j.com"
params = {'ref':"mark-blog"}
req.prepare_url(url, params)
2

Ở đây chúng tôi đi.

URL API bản đồ tĩnh cơ bản của Google

url = "http://www.neo4j.com"
params = {'ref':"mark-blog"}
req.prepare_url(url, params)
3

Chỉ cần chỉ định tham số url = 'http://stackoverflow.com/test/?question=false' new_params = {'question': {'__X__':'__Y__'}} add_url_params(url, new_params) == \ 'http://stackoverflow.com/test/?question=%7B%22__X__%22%3A+%22__Y__%22%7D' 01:

Thêm zoom

Đây chỉ đơn giản là một cặp giá trị khóa khác trong từ điển:

url = "http://www.neo4j.com"
params = {'ref':"mark-blog"}
req.prepare_url(url, params)
4

Thêm trung tâm

Một lần nữa, chỉ là một cặp giá trị khóa kháclist of strings:

url = "http://www.neo4j.com"
params = {'ref':"mark-blog"}
req.prepare_url(url, params)
5

Thêm điểm đánh dấu

url = "http://www.neo4j.com"
params = {'ref':"mark-blog"}
req.prepare_url(url, params)
6

  http://www.nytimes.com/section/nyregion
1 chỉ là một cặp giá trị khóa khác, khi chúng tôi chỉ thêm một điểm đánh dấu:

url = "http://www.neo4j.com"
params = {'ref':"mark-blog"}
req.prepare_url(url, params)
7

.

Ánh xạ động đất

Đó không phải là nhiều niềm vui khi tạo ra danh sách bằng tay. Vì vậy, chúng ta hãy sử dụng một danh sách từ một nguồn chính thức của chính phủ: Chương trình nguy cơ động đất USGS.

Ví dụ dưới đây là một minh chứng của mô -đun 

url = 'http://stackoverflow.com/test/?question=false'
new_params = {'question': {'__X__':'__Y__'}}

add_url_params(url, new_params) == \
    'http://stackoverflow.com/test/?question=%7B%22__X__%22%3A+%22__Y__%22%7D'
07 và hàm 
url = 'http://stackoverflow.com/test/?question=false'
new_params = {'question': {'__X__':'__Y__'}}

add_url_params(url, new_params) == \
    'http://stackoverflow.com/test/?question=%7B%22__X__%22%3A+%22__Y__%22%7D'
08, có thể được sử dụng để tạo danh sách các từ điển từ tệp CSV.

url = "http://www.neo4j.com"
params = {'ref':"mark-blog"}
req.prepare_url(url, params)
8

Đây là URL kết quả (tính đến ngày 9 tháng 2 năm 2016):

Dưới đây là phiên bản được làm sạch hơn một chút của mã sử dụng thư viện yêu cầu để "chuẩn bị" URL:

url = "http://www.neo4j.com"
params = {'ref':"mark-blog"}
req.prepare_url(url, params)
9

Hãy tạo một chức năng để ánh xạ các điểm đánh dấu

Trước khi chúng ta tham gia vào công việc khó khăn trong việc tạo kiểu cho các điểm đánh dấu, hãy kết thúc chức năng mà chúng ta đã sử dụng để tạo URL bản đồ tĩnh Google Static thích hợp thành một chức năng:

(Giả sử bạn đã đọc hướng dẫn ngắn về các chức năng: Các nguyên tắc cơ bản trong Python)

Đây là triển khai xương trần, trong đó người dùng chỉ phải chỉ định danh sách (hoặc chỉ là một chuỗi, nếu chỉ có một vị trí) vị trí và, tùy chọn, chiều rộng và chiều cao. Hàm 

url = 'http://stackoverflow.com/test/?question=false'
new_params = {'question': {'__X__':'__Y__'}}

add_url_params(url, new_params) == \
    'http://stackoverflow.com/test/?question=%7B%22__X__%22%3A+%22__Y__%22%7D'
09 thực hiện công việc tuần tự hóa đầu vào thành định dạng API bản đồ tĩnh của Google.list (or just a string, if there's only one location) of locations and, optionally, width and height. The 
url = 'http://stackoverflow.com/test/?question=false'
new_params = {'question': {'__X__':'__Y__'}}

add_url_params(url, new_params) == \
    'http://stackoverflow.com/test/?question=%7B%22__X__%22%3A+%22__Y__%22%7D'
09 function does the work of serializing the input into proper Google Static Maps API format.

Cuối cùng, nó trả về URL dưới dạng đối tượng chuỗi:

>>> req.url
'http://www.neo4j.com/?ref=mark-blog'
0

Đây là cách bạn sẽ sử dụng nó, tương tác:

>>> req.url
'http://www.neo4j.com/?ref=mark-blog'
1

Kiểm tra các URL đó bằng cách dán chúng vào trình duyệt web rất tốn thời gian. Vì vậy, hãy tạo một chức năng khác. Cái này không trả lại bất cứ điều gì. Thay vào đó, nó có các tham số tương tự như 

url = 'http://stackoverflow.com/test/?question=false'
new_params = {'question': {'__X__':'__Y__'}}

add_url_params(url, new_params) == \
    'http://stackoverflow.com/test/?question=%7B%22__X__%22%3A+%22__Y__%22%7D'
10, nhưng chuyển chúng trực tiếp vào 
url = 'http://stackoverflow.com/test/?question=false'
new_params = {'question': {'__X__':'__Y__'}}

add_url_params(url, new_params) == \
    'http://stackoverflow.com/test/?question=%7B%22__X__%22%3A+%22__Y__%22%7D'
10, sau đó chuyển kết quả của điều đó vào 
url = 'http://stackoverflow.com/test/?question=false'
new_params = {'question': {'__X__':'__Y__'}}

add_url_params(url, new_params) == \
    'http://stackoverflow.com/test/?question=%7B%22__X__%22%3A+%22__Y__%22%7D'
12, thực hiện hành động mở Webbrowser:

(Lưu ý rằng định nghĩa này giả định rằng 

url = 'http://stackoverflow.com/test/?question=false'
new_params = {'question': {'__X__':'__Y__'}}

add_url_params(url, new_params) == \
    'http://stackoverflow.com/test/?question=%7B%22__X__%22%3A+%22__Y__%22%7D'
10 đã được xác định trước đó)

>>> req.url
'http://www.neo4j.com/?ref=mark-blog'
2

Điểm đánh dấu kiểu dáng

.

Đây là nơi nó trở nên khó khăn. Một cách nhắc nhở, 

  http://www.nytimes.com/section/nyregion
1 lấy một chuỗi phân loại đường ống để tách cấu hình kiểu, ví dụ:

>>> req.url
'http://www.neo4j.com/?ref=mark-blog'
3

Tuy nhiên, đó là một quy ước về việc tạo ra của Google, bởi vì họ cần một cách để thực hiện các cặp giá trị khóa (ví dụ: 

url = 'http://stackoverflow.com/test/?question=false'
new_params = {'question': {'__X__':'__Y__'}}

add_url_params(url, new_params) == \
    'http://stackoverflow.com/test/?question=%7B%22__X__%22%3A+%22__Y__%22%7D'
15 = 
url = 'http://stackoverflow.com/test/?question=false'
new_params = {'question': {'__X__':'__Y__'}}

add_url_params(url, new_params) == \
    'http://stackoverflow.com/test/?question=%7B%22__X__%22%3A+%22__Y__%22%7D'
16) độc lập (hay đúng hơn là lồng nhau) theo cách mà các cặp có giá trị khóa được thực hiện trong chuỗi truy vấn URL .

Về cơ bản, chúng ta phải tự tạo ra chuỗi:

>>> req.url
'http://www.neo4j.com/?ref=mark-blog'
4

Kết quả của mã trên sẽ dẫn đến biến 

url = 'http://stackoverflow.com/test/?question=false'
new_params = {'question': {'__X__':'__Y__'}}

add_url_params(url, new_params) == \
    'http://stackoverflow.com/test/?question=%7B%22__X__%22%3A+%22__Y__%22%7D'
17 trỏ đến một chuỗi như thế này:

>>> req.url
'http://www.neo4j.com/?ref=mark-blog'
5

Mà sau đó chúng ta có thể chuyển vào đối số 

url = 'http://stackoverflow.com/test/?question=false'
new_params = {'question': {'__X__':'__Y__'}}

add_url_params(url, new_params) == \
    'http://stackoverflow.com/test/?question=%7B%22__X__%22%3A+%22__Y__%22%7D'
18 của hàm 
url = 'http://stackoverflow.com/test/?question=false'
new_params = {'question': {'__X__':'__Y__'}}

add_url_params(url, new_params) == \
    'http://stackoverflow.com/test/?question=%7B%22__X__%22%3A+%22__Y__%22%7D'
10 được xác định trước đó của chúng tôi:

>>> req.url
'http://www.neo4j.com/?ref=mark-blog'
6

Tạo ra một URL như thế này:

>>> req.url
'http://www.neo4j.com/?ref=mark-blog'
7

Xác định phong cách đánh dấu chắc chắn đã phức tạp, nó phức tạp đến mức nó có thể xứng đáng với phương pháp riêng của nó.

Tạo hàm created_styled_marker ()

Tôi sẽ bỏ qua lời giải thích đầy đủ, hoặc thậm chí bận tâm tạo ra những gì tôi coi là triển khai trong thế giới thực tốt nhất của chức năng 

url = 'http://stackoverflow.com/test/?question=false'
new_params = {'question': {'__X__':'__Y__'}}

add_url_params(url, new_params) == \
    'http://stackoverflow.com/test/?question=%7B%22__X__%22%3A+%22__Y__%22%7D'
20. Chúng ta có thể bao gồm nó trong một bài học khác, nhưng điểm chính là: Hãy xem cách chúng ta có thể sử dụng các chức năng và cấu trúc dữ liệu Python, như danh sách và từ điển, để tạo chuỗi văn bản hữu ích để liên lạc với các dịch vụ khác.lists and dictionaries, to create text strings useful for communicating with other services.

Không cần xây dựng thêm, đây là cách biến mã ánh xạ biểu tượng trước đó thành một hàm có thể tái sử dụng:

>>> req.url
'http://www.neo4j.com/?ref=mark-blog'
8

Lưu ý: Nếu danh sách và từ điển là chiếc mũ cũ cho bạn và bạn hiểu danh sách toàn diện, cũng như định dạng chuỗi, đây là một chiếc quần pythony-phiên bản ưa thích:

>>> req.url
'http://www.neo4j.com/?ref=mark-blog'
9

Dưới đây là tất cả các mã có liên quan để tạo ra một trình bao bọc tiện lợi Quickie-Let-a-Google-static-maps-API, như một kịch bản lớn:

Lưu ý rằng tôi đã sửa đổi đáng kể 

url = 'http://stackoverflow.com/test/?question=false'
new_params = {'question': {'__X__':'__Y__'}}

add_url_params(url, new_params) == \
    'http://stackoverflow.com/test/?question=%7B%22__X__%22%3A+%22__Y__%22%7D'
10 từ cuộc biểu tình trước đó. Xem liệu bạn có thể gỡ rối lý do không, nhưng nó không đáng để giải thích đầy đủ vì đây không phải là một bài học về thiết kế ứng dụng

url = "https://www.youtube.com/watch?v=Y-Wqna-hC2Y&list=RDhlznpxNGFGQ&index=2"
params = {'ref':"mark-blog"}
req.prepare_url(url, params)
0

Và khi các chức năng được xác định và tải vào trình thông dịch, đây là cách chúng tôi gọi các chức năng:

url = "https://www.youtube.com/watch?v=Y-Wqna-hC2Y&list=RDhlznpxNGFGQ&index=2"
params = {'ref':"mark-blog"}
req.prepare_url(url, params)
1

Làm thế nào để bạn cung cấp một tham số cho một URL?

Hãy ghi nhớ những điều sau khi thêm tham số trực tiếp vào URL trang đích:..
Đảm bảo tham số đầu tiên được đi trước? ....
Tách phân tách thứ hai, thứ ba và bất kỳ tham số tiếp theo nào với & ..
Không bao gồm các khoảng trống trong chuỗi truy vấn ..
Không sử dụng bất kỳ tham số dành riêng nào làm tên của một tham số ..

Làm thế nào để bạn thêm một chuỗi vào một url trong python?

từ Urllib.Yêu cầu nhập URLOPEN từ BS4 Nhập đẹpSoup dưới dạng bs url = "https://www.imdb.com/chart/top?ref_=nv_mv_250" html = urlopen (url) url_list = bs (html, 'all_links = url_list.find_all ('a', href = re.

Làm thế nào để bạn tạo một tham số truy vấn trong URL?

Cách xây dựng một URL và các tham số tìm kiếm của nó với JavaScript..
const myurl = url mới ("https://www.valentinog.com");....
const myurl = url mới ("www.valentinog.com");// typeerror: www.valentinog.com không phải là một URL hợp lệ.....
const otherUrl = url mới ("https: // w");....
const khácBảng điều khiển ..

Làm cách nào để tạo một URL tùy chỉnh trong Python?

Khoa học dữ liệu thực tế bằng cách sử dụng Python Mô -đun yêu cầu có thể giúp chúng tôi xây dựng URL và thao tác với giá trị URL một cách linh hoạt.Bất kỳ thư mục phụ nào của URL đều có thể được tìm nạp theo chương trình và sau đó một phần của nó có thể được thay thế bằng các giá trị mới để xây dựng các URL mới.The requests module can help us build the URLS and manipulate the URL value dynamically. Any sub-directory of the URL can be fetched programmatically and then some part of it can be substituted with new values to build new URLs.

programming python Urlsearchparams Python Request get Python Parse_qs Python query string

Bài Viết Liên Quan

Hướng dẫn table border css - đường viền bảng css
Hướng dẫn table border css - đường viền bảng css

Hướng dẫn how can i show uploaded files in php? - Làm cách nào để hiển thị các tệp đã tải lên trong php?
Hướng dẫn how can i show uploaded files in php? - Làm cách nào để hiển thị các tệp đã tải lên trong php?

Xe air blade 2023 màu vàng đồng
Xe air blade 2023 màu vàng đồng

Hướng dẫn exam cheat sheet - bảng gian lận thi
Hướng dẫn exam cheat sheet - bảng gian lận thi

Hướng dẫn invoke meaning javascript - gọi ý nghĩa javascript
Hướng dẫn invoke meaning javascript - gọi ý nghĩa javascript

Hướng dẫn python check if all elements in two lists are the same - python kiểm tra xem tất cả các phần tử trong hai danh sách có giống nhau không
Hướng dẫn python check if all elements in two lists are the same - python kiểm tra xem tất cả các phần tử trong hai danh sách có giống nhau không

Hướng dẫn month calendar in javascript - lịch tháng trong javascript
Hướng dẫn month calendar in javascript - lịch tháng trong javascript

Những chương trình cơ bản về tệp trong turbo pascal
Những chương trình cơ bản về tệp trong turbo pascal

2023 Challenger
2023 Challenger

Hướng dẫn how do you call a string in a list in python? - làm thế nào để bạn gọi một chuỗi trong một danh sách trong python?
Hướng dẫn how do you call a string in a list in python? - làm thế nào để bạn gọi một chuỗi trong một danh sách trong python?

MỚI CẬP NHẬP

Ngày 10 tháng 3 là cung hoàng đạo gì năm 2024
21 phúts trước . bởi StrenuousIndecency
Sổ tay người học tiếng hoa trương văn giới năm 2024
24 phúts trước . bởi PrevalentSperm
Hình nào không có mặt phẳng đối xứng năm 2024
37 phúts trước . bởi IntercontinentalSnead
Sách bài tập hóa 10 cơ bản pdf năm 2024
58 phúts trước . bởi AggressiveReviewer
Nhất lưỡi nhì râu là gì năm 2024
1 giờs trước . bởi DerisiveBasis
Môi trên giật liên tục là bệnh gì năm 2024
1 giờs trước . bởi NeutralPullman
Cách giải các bài toán chứng minh của lớp 6 năm 2024
1 giờs trước . bởi DesiredParadox
226 38 lê văn sỹ f1 qtân bình năm 2024
1 giờs trước . bởi FavoriteEnvironment
Bài tập tự luận unit 12 tiếng anh 8 năm 2024
2 giờs trước . bởi Ten-yearCross-examination
Take something into consideration là gì năm 2024
2 giờs trước . bởi UnrestrictedDeliverance

Xem Nhiều

On the weekend là thì gì năm 2024
1 tuầns trước . bởi FierceCovering
Co số điện thoại di động nào 9 đó năm 2024
5 ngàys trước . bởi SilverTo-day
Himax premium lub ts40 là gì năm 2024
5 ngàys trước . bởi DeepeningMirth
81 2 nguyễn văn giai quận 1 f dakao năm 2024
5 ngàys trước . bởi First-rateMedics
Cách mạng công nghiệp 4.0 cơ hội nào cho startup năm 2024
3 ngàys trước . bởi SinfulBoldness
Các dạng toán chương 1 kinh tế vĩ mô năm 2024
1 ngàys trước . bởi HeathenPolling
Cấu trúc tiếng anh là con nghiện của cái gì năm 2024
1 tuầns trước . bởi AspiringBooty
Hoạt động văn hóa văn nghệ là một năm 2024
1 tuầns trước . bởi OutdatedScenery
Khắc phục lỗi phần mềm fot làm bị out game năm 2024
4 ngàys trước . bởi OvercastOutfield
Bài tập tự luận unit 12 tiếng anh 8 năm 2024
2 giờs trước . bởi Ten-yearCross-examination

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội

Bản quyền © 2024 Inc.