<basejoinFunction in the urllib Pack may be what You re-see for.

basejoin = urljoin(base, url, allow_fragments=True)
    Join a base URL and a possibly relative URL to form an absolute
    interpretation of the latter.

Edit:我以前曾发出过通知,但还是文盲。 该基地似乎直接绘制了图,以图ur鲁拉林,使后者更愿意。

使用呋喃,pip安装了furl。

 furl.furl( /media/path/ ).add(path= js/foo.js )

我知道,这比禁止化学武器组织要求的要多一点,但我有几处 pieces,并且正在寻找一种简单的方式加入:

>>> url =  https://api.foo.com/orders/bartag?spamStatus=awaiting_spam&page=1&pageSize=250 

探讨:

>>> split = urlparse.urlsplit(url)
>>> split
SplitResult(scheme= https , netloc= api.foo.com , path= /orders/bartag , query= spamStatus=awaiting_spam&page=1&pageSize=250 , fragment=  )
>>> type(split)
<class  urlparse.SplitResult >
>>> dir(split)
[ __add__ ,  __class__ ,  __contains__ ,  __delattr__ ,  __dict__ ,  __doc__ ,  __eq__ ,  __format__ ,  __ge__ ,  __getattribute__ ,  __getitem__ ,  __getnewargs__ ,  __getslice__ ,  __getstate__ ,  __gt__ ,  __hash__ ,  __init__ ,  __iter__ ,  __le__ ,  __len__ ,  __lt__ ,  __module__ ,  __mul__ ,  __ne__ ,  __new__ ,  __reduce__ ,  __reduce_ex__ ,  __repr__ ,  __rmul__ ,  __setattr__ ,  __sizeof__ ,  __slots__ ,  __str__ ,  __subclasshook__ ,  __weakref__ ,  _asdict ,  _fields ,  _make ,  _replace ,  count ,  fragment ,  geturl ,  hostname ,  index ,  netloc ,  password ,  path ,  port ,  query ,  scheme ,  username ]
>>> split[0]
 https 
>>> split = (split[:])
>>> type(split)
<type  tuple >

因此,除了其他答复中已经解答的走路外, 为了了解我所期待的情况:。

>>> split
( https ,  api.foo.com ,  /orders/bartag ,  spamStatus=awaiting_spam&page=1&pageSize=250 ,   )
>>> unsplit = urlparse.urlunsplit(split)
>>> unsplit
 https://api.foo.com/orders/bartag?spamStatus=awaiting_spam&page=1&pageSize=250 

根据,文件。 只读5门。

采用以下图表:

URL计划计有虚构的空插图

净额 1个网络地点部分空洞

第2条

问题3

碎片 4 零散标识

鲁恩·卡高德为我提供了一份出色和细致的解决办法,我扩大了这一解决办法:

def urljoin(*args):
    trailing_slash =  /  if args[-1].endswith( / ) else   
    return "/".join(map(lambda x: str(x).strip( / ), args)) + trailing_slash

这使所有论点都能得到采纳,而不管有线索和结束冲突,同时如果存在的话,保留最后的鞭.。

为了略微改进Alex Martelli的反应,以下措施不仅将清理额外的冲突,而且还将保持(即将)的闪lash,有时可能有用:

>>> items = ["http://www.website.com", "/api", "v2/"]
>>> url = "/".join([(u.strip("/") if index + 1 < len(items) else u.lstrip("/")) for index, u in enumerate(items)])
>>> print(url)
http://www.website.com/api/v2/

它不容易阅读,并赢得多处外线的清理。

How about this: It is Somewhat Efficient & Somewhat Simple. Only need to join 2 parts of url path:

def UrlJoin(a , b):
    a, b = a.strip(), b.strip()
    a = a if a.endswith( / ) else a +  / 
    b = b if not b.startswith( / ) else b[1:]
    return a + b

OR: 更具常规性,但如果仅加入一条道路的2个半部分,则效率不高。

def UrlJoin(*parts):
    return  / .join([p.strip().strip( / ) for p in parts])

测试案例:

>>> UrlJoin( https://example.com/ ,  /TestURL_1 )
 https://example.com/TestURL_1 

>>> UrlJoin( https://example.com ,  TestURL_2 )
 https://example.com/TestURL_2 

注:我可以在此分头发,但至少是良好做法,而且可能更容易读。

Using furl regex (第3页)

>>> import re
>>> import furl
>>> p = re.compile(r (/)+ )
>>> url = furl.furl( /media/path ).add(path= /js/foo.js ).url
>>> url
 /media/path/js/foo.js 
>>> p.sub(r"1", url)
 /media/path/js/foo.js 
>>> url = furl.furl( /media/path ).add(path= js/foo.js ).url
>>> url
 /media/path/js/foo.js 
>>> p.sub(r"1", url)
 /media/path/js/foo.js 
>>> url = furl.furl( /media/path/ ).add(path= js/foo.js ).url
>>> url
 /media/path/js/foo.js 
>>> p.sub(r"1", url)
 /media/path/js/foo.js 
>>> url = furl.furl( /media///path/// ).add(path= //js///foo.js ).url
>>> url
 /media///path/////js///foo.js 
>>> p.sub(r"1", url)
 /media/path/js/foo.js 

一行:

from functools import reduce
reduce(lambda x,y:  {}/{} .format(x,y), parts) 

[https://api.somecompany.com/v1 , climate , Rain]

这里有安全版本,Im使用。 它照顾着预设装置和拖.。 终端“URI”的拖拉线单独处理。

def safe_urljoin(*uris) -> str:
    """
    Joins the URIs carefully considering the prefixes and trailing slashes.
    The trailing slash for the end URI is handled separately.
    """
    if len(uris) == 1:
        return uris[0]

    safe_urls = [
        f"{url.lstrip( / )}/" if not url.endswith("/") else url.lstrip("/")
        for url in uris[:-1]
    ]
    safe_urls.append(uris[-1].lstrip("/"))
    return "".join(safe_urls)

产出

>>> safe_urljoin("https://a.com/", "adunits/", "/both/", "/left")
>>>  https://a.com/adunits/both/left 

>>> safe_urljoin("https://a.com/", "adunits/", "/both/", "right/")
>>>  https://a.com/adunits/both/right/ 

>>> safe_urljoin("https://a.com/", "adunits/", "/both/", "right/", "none")
>>>  https://a.com/adunits/both/right/none 

>>> safe_urljoin("https://a.com/", "adunits/", "/both/", "right/", "none/")
>>>  https://a.com/adunits/both/right/none/ 

具有独特特征的另一变:

def urljoin(base:str, *parts:str) -> str:
    for part in filter(None, parts):
        base =  {}/{} .format(base.rstrip( / ), part.lstrip( / ))
    return base

• Preserve trailing slash in base or last part
• Empty parts are ignored
• For each non-empty part, remove trailing from base and leading from part and join with a single /

urljoin( http://a.com/api ,    )  ->  http://a.com/api 
urljoin( http://a.com/api ,   / ) ->  http://a.com/api/ 
urljoin( http://a.com/api/ ,   )  ->  http://a.com/api/ 
urljoin( http://a.com/api/ ,  / ) ->  http://a.com/api/ 
urljoin( http://a.com/api/ ,  /a/ ,  /b ,  c ,  d/ ) ->  http://a.com/api/a/b/c/d/ 

奥基,这是我所做的,因为我需要完全独立于预先确定的根源:

def url_join(base: str, *components: str, slash_left=True, slash_right=True) -> str:
    """Join two or more url components, inserting  /  as needed.
    Optionally, a slash can be added to the left or right side of the URL.
    """
    base = base.lstrip( / ).rstrip( / )
    components = [component.lstrip( / ).rstrip( / ) for component in components]
    url = f"/{base}" if slash_left else base
    for component in components:
        url = f"{url}/{component}" 
    return f"{url}/" if slash_right else url

url_join("http://whoops.io", "foo/", "/bar", "foo", slash_left=False)
# "http://whoops.io/foo/bar/foo/"
url_join("foo", "bar")
# "/foo/bar/""