def evens(start, end):
    even = start + (start%2)
    while even<end:
        yield even
        even+=2

if __name__ == "__main__":
    t = evens(2,10)
    for i in t:
        print(i)

def countdown(k):
    if k>0:
        yield k
        yield from countdown(k-1)
        '''
        等价于 
        for i in countdown(k-1):
            yield i
        '''
    else:
        yield 'Blast off'
if __name__ == "__main__":
    t = countdown(3)
    for i in t:
        print(i)

def prefixes(s):
    if s:
        yield from prefixes(s[:-1])
        yield s
def substrings(s):
    if s:
        yield from prefixes(s)
        yield from substrings(s[1:])
if __name__ == "__main__":
    print(list(prefixes("both")))
    print(list(substrings("top")))

def partitions(n,m):
    if n<0 or m==0:
        return []
    else:
        exact_match = []
        if n==m:
            exact_match = [str(m)]
        with_m = [p+'+'+str(m) for p in partitions(n-m,m)]
        without_m = partitions(n,m-1)
        return exact_match+with_m+without_m
if __name__ == "__main__":
    for p in partitions(6,4):
        print(p)

def partitions(n,m):
    if n>0 and m>0:
        if n==m:
            yield str(m)
        for p in partitions(n-m,m):
            yield p+'+'+str(m)
        yield from partitions(n,m-1)
if __name__ == "__main__":
    t = partitions(6,4)
    for p in range(5):
        print(next(t))

s = [[1,2],3,4,5]
t = iter(s)
u = iter(s)
print("t:",next(t))
print("u:",next(u))
print("t:",next(t))
list(t)
print(next(t))

d = {'one':1, 'two':2, 'three':3}
d['zero'] = 0
# 遍历键
k = iter(d.keys()) # iter(d)
print(next(k))
# 遍历值
v = iter(d.values())
print(next(v))
# 遍历键值对
i = iter(d.items()) # 以元组形式迭代
print(next(i))

r = range(3,6)
ri = iter(r)
for i in ri:
    print(i)
for i in ri:
    print(i)

bcd = ['b', 'c', 'd']
m = map(lambda x: x.upper(), bcd) # 返回一个迭代器
print(next(m))
print(next(m))
print(next(m))

def double(x):
    print(x, '=>',2*x)
    return 2*x
m = map(double, range(3,7))
f = lambda y: y>=10
t = filter(f,m) # 仅遍历满足f函数下的返回值
list(filter(f,m)) # 将所有可能的返回值存入列表

print(list(zip([1,2],[3,4])))

print(list(zip([1,2],[3,4,5])))

print(list(zip([1,2],[3,4,5], [6,7])))

def palindrome(s):
    # >>> palindrome([3,1,4,1,5])
    # False
    # >>> palindrome([3,1,4,1,3])
    # True
    # >>> palindrome('seveneves')
    # True
    return all([a==b for a,b in zip(s,reversed(s))])
if __name__ == '__main__':
    print(palindrome([3,1,4,1,3]))
    print(palindrome('seveneves'))

from urllib.parse import urlparse, parse_qs

# 示例URL
url = 'http://example.com/path/to/resource?name=John&age=30'

# 解析URL
parsed_url = urlparse(url)

# 获取路径
path = parsed_url.path
print("Path:", path)

# 解析查询参数
query_params = parse_qs(parsed_url.query)
print("Query Parameters:", query_params)

import requests

# 示例表单数据
form_data = {
    'username': 'john_doe',
    'password': 'securepassword'
}

# 发送POST请求
response = requests.post('https://www.baidu.com/', data=form_data)

# 查看响应
print("Response Status Code:", response.status_code)
print("Response Text:", response.text)

import requests
import json

# 示例JSON数据
json_data = {
    'name': 'John',
    'age': 30
}

# 发送POST请求
response = requests.post('https://www.baidu.com/', json=json_data)

# 查看响应
print("Response Status Code:", response.status_code)
print("Response JSON:", response.json())

import requests

# 打开文件
files = {'file': open('example.txt', 'rb')}

# 发送POST请求
response = requests.post('http://example.com/upload', files=files)

# 查看响应
print("Response Status Code:", response.status_code)
print("Response Text:", response.text)

from unicodedata import name, lookup
print(name('A')) # 查询字符集中的字符名称
print(lookup('BABY')) # 根据字符名称输出对应字符
print(lookup('BABY').encode()) # 查看该字符的字节编码

suits = ['coin', 'string', 'myriad']
original_suits = suits
print(suits.pop()) # 弹出一个元素（默认最后一个）
suits.remove('string') # 移除指定元素
print(suits)
suits.append('cup') # 在尾部增加一个元素
suits.extend(['sword', 'club']) # 添加序列中的多个元素来拓展列表
print(suits)
suits[2] = 'spade'
suits[0:2] = ['heart', 'diamond']
print(original_suits)

def mystery(s):
    s.pop()
    s.pop()
four = [1,2,3,4]
mystery(four)

x = [1,2]
print(x+x)
x.append(3)
print(x+x)

s = ([1,2],3)
s[0][0]=4
print(s)

a = [10]
b = a
print(a==b)
a.append(20)
print(a==b)

a = [10]
b = [10]
print(a==b)
b.append(20)
print(a==b)

a = [10]
b = [10]
c = b
print(a is b)
print(b is c)

def f(s=[]):
    s.append(3)
    return len(s)
for i in range(3):
    print(f())

def make_withdraw_list(balance):
    b = [balance]
    def withdraw(amount):
        if amount > b[0]:
            return 'Insufficient funds'
        b[0] = b[0] - amount
        return b[0]
    return withdraw

withdraw = make_withdraw_list(100)
print(withdraw(25))
print(withdraw(25))
withdraw(100)

def tree(label, branches=[]):
    for branch in branches:
        assert is_tree(branch), "branches must be trees" # 确保构造的是一棵树
    return [label] +list(branches) # 将同一层的分支节点放在一个列表中

def label(tree):
    return tree[0]

def branches(tree):
    return tree[1:]

def is_tree(tree):
    """判断是不是一棵树"""
    if type(tree) != list or len(tree) <1: # 确保树的分支是树，以及存在一个值
        return False
    for branch in branches(tree): # 确保树的分支的分支都是树
        if not is_tree(branch):
            return False
    return True

def is_leaf(tree): 
    """判断树本身是不是叶子节点"""
    return not branches(tree)


if __name__ == "__main__":
    t = tree(1, [tree(5, [tree(7)]), tree(6)])
    print(t)
    print(label(t))
    print(branches(t))
    print(label(branches(t)[0]))

def count_leaves(t):
    """Count the leaves of tree T"""
    if is_leaf(t):
        return 1
    else:
        return sum([count_leaves(b) for b in branches(t)])

if __name__ == "__main__":
    t = tree(1, [tree(5, [tree(7)]), tree(6)])
    print(count_leaves(t))

def leaves(tree):
    """return a list containing the leaf labels of tree"""
    if is_leaf(tree):
        return [label(tree)]
    else:
        return sum([leaves(b) for b in branches(tree)], [])

if __name__ == "__main__":
    t = tree(1, [tree(5, [tree(7)]), tree(6)])
    print(leaves(t))

def increment_leaves(t):
    """return a tree like t but with leaf labels incremented"""
    if is_leaf(t):
        return tree(label(t)+1)
    else:
        bs = [increment_leaves(b) for b in branches(t)]
        return tree(label(t), bs)

def increment(t):
    """return a tree like t but with all labels incremented"""
    return tree(label(t)+1, [increment(b) for b in branches(t)])

if __name__ == "__main__":
    t = tree(1, [tree(5, [tree(7)]), tree(6)])
    print(leaves(t))
    print(increment_leaves(t))
    print(increment(t))

def print_tree(t, indent = 0):
    print(' '*indent + str(label(t)))
    for b in branches(t):
        print_tree(b, indent+1)

if __name__ == "__main__":
    t = tree(1, [tree(5, [tree(7)]), tree(6)])
    print(print_tree(t))

def print_sums(t, so_far):
    so_far = so_far +label(t)
    if is_leaf(t):
        print(so_far)
    else:
        for b in branches(t):
            print_sums(b,so_far)

if __name__ == "__main__":
    t = tree(1, [tree(5, [tree(7)]), tree(6)])
    print(print_sums(t, 0))

def divide(quotients, divisors):
    """Return a dictonary in which each quotient q is a key for the list of
    divisors that it divides evenly.

    >>> divide([3, 4, 5], [8, 9, 10, 11, 12])
    {3: [9, 12], 4: [8, 12], 5: [10]}
    >>> divide(range(1, 5), range(20, 25))
    {1: [20, 21, 22, 23, 24], 2: [20, 22, 24], 3: [21, 24], 4: [20, 24]}
    """
    return {i: [x for x in divisors if x%i==0] for i in quotients}

def buy(required_fruits, prices, total_amount):
    """Print ways to buy some of each fruit so that the sum of prices is amount.

    >>> prices = {'oranges': 4, 'apples': 3, 'bananas': 2, 'kiwis': 9}
    >>> buy(['apples', 'oranges', 'bananas'], prices, 12)
    [2 apples][1 orange][1 banana]
    >>> buy(['apples', 'oranges', 'bananas'], prices, 16)
    [2 apples][1 orange][3 bananas]
    [2 apples][2 oranges][1 banana]
    >>> buy(['apples', 'kiwis'], prices, 36)
    [3 apples][3 kiwis]
    [6 apples][2 kiwis]
    [9 apples][1 kiwi]
    """
    def add(fruits, amount, cart):
        if fruits == [] and amount == 0:
            print(cart)
        elif fruits and amount > 0:
            fruit = fruits[0]
            price = prices[fruit]
            for k in range(1,amount//price+1):
                add(fruits[1:], amount-k*price, cart+display(fruit,k))
    add(required_fruits, total_amount, '')

def display(fruit, count):
    """Display a count of a fruit in square brackets.

    >>> display('apples', 3)
    '[3 apples]'
    >>> display('apples', 1)
    '[1 apple]'
    """
    assert count >= 1 and fruit[-1] == 's'
    if count == 1:
        fruit = fruit[:-1]  # get rid of the plural s
    return '[' + str(count) + ' ' + fruit + ']'

from math import sqrt
def distance(city_a, city_b):
    """
    >>> city_a = make_city('city_a', 0, 1)
    >>> city_b = make_city('city_b', 0, 2)
    >>> distance(city_a, city_b)
    1.0
    >>> city_c = make_city('city_c', 6.5, 12)
    >>> city_d = make_city('city_d', 2.5, 15)
    >>> distance(city_c, city_d)
    5.0
    """
    return sqrt(abs(get_lat(city_a)-get_lat(city_b))**2+abs(get_lon(city_a)-get_lon(city_b))**2)

def closer_city(lat, lon, city_a, city_b):
    """
    Returns the name of either city_a or city_b, whichever is closest to
    coordinate (lat, lon). If the two cities are the same distance away
    from the coordinate, consider city_b to be the closer city.

    >>> berkeley = make_city('Berkeley', 37.87, 112.26)
    >>> stanford = make_city('Stanford', 34.05, 118.25)
    >>> closer_city(38.33, 121.44, berkeley, stanford)
    'Stanford'
    >>> bucharest = make_city('Bucharest', 44.43, 26.10)
    >>> vienna = make_city('Vienna', 48.20, 16.37)
    >>> closer_city(41.29, 174.78, bucharest, vienna)
    'Bucharest'
    """
    fake_city = make_city('fake', lat, lon)
    if distance(fake_city,city_a)<distance(fake_city,city_b):
        return get_name(city_a)
    else:
        return get_name(city_b)

def mul_rational(x,y):
    return rational(numer(x)*numer(y),denom(x)*denom(y))

def add_rational(x,y):
    nx, dx = numer(x), denom(y)
    ny, dy = numer(y), denom(y)
    return rational(nx*dy+ny*dx, dx*dy)

def equal_rational(x,y):
    return numer(x)*denom(y)==numer(y)*denom(x)

add_rational([1,2],[1,4])

def divide_rational(x,y):
    return [x[0]*y[1], x[1]*y[0]]

>>> pair = [1,2]
>>> pair
[1,2]

>>> x,y=pair
>>> x
1
>>> y
2
>>> pair[0]
1

>>> getitem(pair, 0)
1
>>> getitem(pair, 1)
2

def rational(n,d):
    """Construct a rational number that represents N/D"""
    return [n, d]

def numer(x):
    """Return the numerator of rational number x"""
    return x[0]

def denom(x):
    """Return the denominator of rational number x"""
    return x[1]

from fractions import gcd
def rational(n,d):
    g = gcd(n,d)
    return [n//g, d//g]

def rational(n,d):
    def select(name):
        if name == 'n':
            return n
        elif name == 'd':
            return d
    return select
def numer(x):
    """Return the numerator of rational number x"""
    return x('n')

def denom(x):
    """Return the denominator of rational number x"""
    return x('d')