编写高质量的python代码 -- 02. 函数

def divide(a, b):
    """求两个数相除"""
    try:
        return a / b
    except ZeroDivisionError as e:
        raise ValueError('Invalid inputs') from e
        
x, y = 5, 2
try:
    result = divide(x, y)
except ValueError:
    print('Invalid inputs')
else:
    print('Result is {}'.format(result))

numbers = [8, 3, 1, 2, 5, 4, 7, 6]
group = {2, 3, 5, 7}

def sort_priority(values, group):
    def helper(x):
        if x in group:
            return (0, x)
        return (1, x)
    values.sort(key=helper)
sort_priority(numbers, group)
>>> [2, 3, 5, 7, 1, 4, 6, 8]

# 这个山水能正常工作是因为
# 1. python 支持闭包：闭包是一种定义在某个作用域中的函数，这种函数引用了那个作用域里面的变量。helper 函数之所以能够访问 sort_priority 的 group 参数，原因就在于它是闭包
# 2. python 的函数是一级对象，也就是说，我们可以直接饮用函数，把函数赋给变量、把函数当成参数传递给其它函数，并通过表达式及 if 语句对其进行比较和判断，等待。于是，我们可以把 helper 这个闭包函数，传递个 sort 方法的 key 参数
# 3. python 使用特殊的规则来比较两个元组。它首先比较各元组中下标为0的对应元素，如果相等，在比较下表为1的对应元素，依次类推

numbers = [8, 3, 1, 2, 5, 4, 7, 6]
group = {2, 3, 5, 7}

def sort_priority(values, group):
    found = False
    def helper(x):
        if x in group:
            found = True    # 闭包里面的赋值，相当于定义了一个新的变量 found 
                            # 不会修改sort_priority函数中的 found 值
            return (0, x)
        return (1, x)
    values.sort(key=helper)
    return found
    
sort_priority(numbers, group)

>>> 
Found: False # 期望返回 True，返回了 False
[2, 3, 5, 7, 1, 4, 6, 8]

# 之所以出现上面的问题，是Python 语言故意这么设计的。这样做可以防止函数中的局部变量污染函数外面的那个模块。

def sort_priority(values, group):
    found = False
    def helper(x):
        nonlocal found
        if x in group:
            found = True
            return (0, x)
        return (1, x)
    values.sort(key=helper)
    return found

def sort_priority(numbers, group):
    found = [False]
    def helper(x):
        if x in group:
            found[0] = True
            return (0, x)
        return (1, x)
    numbers.sort(key=helper)
    return found[0]

class Sorter(object):
    def __init__(self, group):
        self.group = group
        self.found = False
    
    def __call__(self, x):
        if x in self.group:
            self.found = True
            return (0, x)
        return (1, x)

sorter = Sorter(group)
numbers.sort(key=sorter)
assert sorter.found is True

def index_words(text):
    result = []
    if text:
        result.append(0)
    for index, letter in enumerate(text):
        if letter == ' ':
            result.append(index + 1)
    return result
    
# 把这个函数改为生成器来写会更好。生成器是使用 yield 表达式的函数。调用生成器函数时，
# 它不会真的运行，而是会返回迭代器。每次在这个迭代器上面调用内置的 next 函数时，迭代
# 器会把生成器推进到下一个 yield 表达式那里。生成器传给 yield 的每一个值，都会由迭代
# 器返回给调用者

def index_words_iter(text):
    if text:
        yield 0
    for index, letter in enumerate(text):
        if letter == ' ':
            yield index + 1

result = list(index_words_iter(address))

# 下面定义一个生成器，从文件里面依次读入各行内容，然后逐个处理每行汇总的单词，并产生
# 相应结果。该函数执行时所耗的内存，由单行输入值的最大字符数来界定

def index_file(handle):
    offset = 0
    for line in handle:
        if line:
            yield offset
        for letter in line:
            offset += 1
            if letter == ' ':
                yield offset

with open('/tmp/address.txt', 'r') as f:
    it = index_file(f)
    results = islice(it, 0, 3)
    print(list(results)

def normalize_defensive(numbers):
    if iter(numbers) is iter(numbers):
        raise TypeError('Must supply a container')
    total = sum(numbers)
    result = []
    for value in numbers:
        percent = 100 * value / total
        result.append(percent)
    return result
    
# 使用迭代器协议（iterator protocol）的容器类
class ReadVisits(object):
    def __init__(self, data_path):
        self.data_path = data_path
        
    def __iter__(self):
        with open(self.data_path) as f:
            for line in f:
                yield int(line)
                
'''
/tmp/a.data 文件中包含三行数据
15
35
80
'''

# python 在 for 循环及相关表达式中遍历某中容器的内容时，就要依靠这个迭代协议。
# 在执行类似 for x in foo 这样的语句时，python 实际上会调动 iter(foo).内置的 iter 函数又会
# 调用 foo.__iter__ 这个特殊方法。该方法必须返回迭代器对象。

visits = [15, 35, 80]
normalize_defensive(visits) # No error
visits = ReadVisits('/tmp/a.data')
normalize_defensive(visits)

from datetime import datetime
from time import sleep
def log(message, when=datetime.now()):
    print('{}: {}'.format(when, message))

log('Hi there!')
sleep(0.1)
log('Hi again!')

# 上面的例子输出的时间是一样的，因为 datetime.now 只执行了一次。
# 在 python 若想正确实动态默认值，习惯上把默认值设置为 None,并在文档字符串里面把对None 对应的实际行为
# 描述出来。编写函数代码时，如果返现该参数的值是 None,那就将其设为实际的默认值

def log(message, when=None):
    """Log a message with a timestamp.
    
    Args:
        message: Message to print.
        when: datetime of when the message occurred.
            Defaults to the present time.
    """
    from datetime import datetime
    when = datetime.now() if when is None else when
    print('{}: {}'.format(when, message))

# python3 写法
def safe_division_c(number, divisor, *, ignore_overflow=False,ignore_zero_division=False):
    try:
        return number /divisor
    except OverflowError:
        if ignore_overflow:
            return 0
        else:
            raise
    except ZeroDivisionError:
        if ignore_zero_division:
            return float('inf')
        else:
            raise

# python2 写法
def safe_division_d(number, divisor, **kwargs):
    ignore_overflow = kwargs.pop('ignore_overflow', False)
    ignore_zero_division = kwargs.pip('ignore_zero_division', False)
    if kwargs:
        raise TypeError('Unexpected **kwargs: %r' % kwargs)
    try:
        return number /divisor
    except OverflowError:
        if ignore_overflow:
            return 0
        else:
            raise
    except ZeroDivisionError:
        if ignore_zero_division:
            return float('inf')
        else:
            raise