URL Parsing in Python

URL parsing is a fundamental skill in web development and data processing. This challenge asks you to implement a basic URL parser in Python, extracting key components like scheme, netloc (network location), path, and query parameters. This is useful for tasks like web scraping, building APIs, and analyzing website traffic.

Problem Description

You are tasked with creating a function parse_url(url_string) that takes a URL string as input and returns a dictionary containing the following keys:

• scheme: The URL scheme (e.g., "http", "https", "ftp").
• netloc: The network location (e.g., "www.example.com").
• path: The path component (e.g., "/path/to/resource").
• query: A dictionary of query parameters (e.g., {'param1': 'value1', 'param2': 'value2'}). If there are no query parameters, this should be an empty dictionary.
• fragment: The fragment identifier (e.g., "#section1"). If there is no fragment, this should be an empty string.

The function should handle URLs with and without query parameters and fragments. It should also correctly parse URLs with different schemes.

Key Requirements:

• The function must handle URLs with and without query parameters.
• The function must handle URLs with and without fragments.
• The function must correctly identify the scheme, netloc, path, query parameters, and fragment.
• Query parameters should be parsed into a dictionary where the key is the parameter name and the value is the parameter value.
• The function should return an empty dictionary for query if no query parameters are present.
• The function should return an empty string for fragment if no fragment is present.

Expected Behavior:

The function should return a dictionary with the specified keys and values. If a component is not present in the URL, the corresponding value in the dictionary should be an empty string or an empty dictionary as described above.

Edge Cases to Consider:

• URLs with no scheme (e.g., "www.example.com/path?param=value"). Assume the scheme is "http" in this case.
• URLs with only a scheme (e.g., "http://").
• URLs with empty components (e.g., "http://www.example.com/").
• URLs with multiple query parameters.
• URLs with special characters in the path, query parameters, or fragment.
• URLs with encoded characters in the query parameters (e.g., %20). You do not need to decode these.

Examples

Example 1:

Input: "https://www.example.com/path/to/resource?param1=value1&param2=value2#section1"
Output: {
    'scheme': 'https',
    'netloc': 'www.example.com',
    'path': '/path/to/resource',
    'query': {'param1': 'value1', 'param2': 'value2'},
    'fragment': 'section1'
}
Explanation: The URL is parsed into its components, and the query parameters are extracted into a dictionary.

Example 2:

Input: "http://www.example.com/path"
Output: {
    'scheme': 'http',
    'netloc': 'www.example.com',
    'path': '/path',
    'query': {},
    'fragment': ''
}
Explanation: The URL is parsed, and the absence of query parameters and fragments results in empty values for those keys.

Example 3:

Input: "www.example.com/path?param1=value1&param2=value2"
Output: {
    'scheme': 'http',
    'netloc': 'www.example.com',
    'path': '/path',
    'query': {'param1': 'value1', 'param2': 'value2'},
    'fragment': ''
}
Explanation: The URL lacks a scheme, so "http" is assumed.

Constraints

• The input url_string will be a string.
• The length of the url_string will be between 1 and 2048 characters.
• The function must return a dictionary.
• The function should be reasonably efficient; avoid unnecessary iterations or complex data structures.

Notes

Consider using string splitting and regular expressions to parse the URL. The urllib.parse module is not allowed for this challenge; the goal is to implement the parsing logic yourself. Focus on correctly identifying the different components of the URL and extracting the query parameters into a dictionary. Remember to handle edge cases gracefully.