Python函数

函数基础

# 定义函数
def function_name(arg1 [,arg2,...]): # arg1,arg2为形参，形参可以0个或多个
    '''函数描述信息'''
    # 函数体
    ...
    # 返回值，不写 默认 return None
    # 可返还一个或多个值，多个值时以元组返回
    return return_val[, return_val2...] 
# 调用函数
function_name(val1) # 实参参数根据函数定义的形参个数来传递

参数

def foo(x, y):
    print(x)
    print(y)
"""根据实参角度分析"""    
# 1. 按照位置传值
foo(1, 2)
# 2. 按照关键字传值
foo(x = 1, y = 2)
foo(y = 2, x = 1) # 两种传值结果一致
# 3. 混合用
'按位置传值必须在按关键字传值的前面'
foo(1, y=2) # 打印：1 2
"""从形参的角度分析"""
# 1. 位置参数: 必须传值的参数
def foo(x, y):
    print(x)
    print(y)
foo(1, 2) # 定义两个参数，就必须传两个值
# 2. 默认参数：
'默认参数必须放在位置参数的后面'
def foo(x, y=1):
    print(x)
    print(y)
foo(1) # 默认参数可以不用传值
foo(1, 2) # 也可以传值

可变参数

'*args'
# *args 放在位置参数后面
def foo(x, *args):
    print(x)
    print(args)
foo(1,2,3,4,5,'b','c') #x:1 args:(2,3,4,5,'b','c')
'**kwargs'
def foo(x, **kwargs):
    print(x)
    print(kwargs)
foo(1, a=2, b=3, c=4) # x=1, kwargs={'a':2, 'b':3, 'c':4}

闭包

• 必须是内部定义的函数
• 该函数包含对外部作用域而不是全局作用域的引用

def f1(x):
    def f2():
        print(x)
    return f2

装饰器

import time
from functools import wraps
# 无参装饰器
def timmer(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        """wrapper func"""
        start_time = time.time()
        res = func(*args, **kwargs)
        end_time = time.time()
        print('start time %ss' % (end_time - start_time))
        return res
@timmer  # 相对于 index = timmer(index) == wrapper
def index():
    """index func"""
    print('index page')
index() # wrapper()
# 打印函数说明
print(index.__doc__) # 不加@wraps时 'wrapper func' 加@wraps时 'index func'

# 有参装饰器
def auth(auth_type):
    def wrapper(func):
        def inner(*args, **kwargs):
            if auth_type == 'file':
                # file类型的操作
            else auth_type == 'sql':
                # sql类型的操作
            res = func(*args, **kwargs)
            return res
        return inner
    return wrapper
@auth('file') # @auth('file') => @wrapper => index = wrapper(index) => inner
def index():
    print('index page')
index() # inner()
@timmer  # 后执行
@auth('file')  # 下面先执行
def home():
    print('home page')

迭代器

可迭代对象：对象本身有iter方法，iter方法得到迭代器
迭代器：对象.iter()得到的结果就是迭代器，对象有next方法
迭代器的iter方法得到的是迭代器本身

l = [1,2,3,4,5]
i = iter(l)  # => i = l.__iter__()  迭代器
while True:
    try:
        print(next(i)) # => i.__next__(
    except StopIteration:
        break
# for 使用迭代器实现
for i in l: # l.__iter__()
    print(i)

优点：

1. 迭代器提供了一种不依赖索引的取值方式，这样就可以遍历那些没有索引的可迭代对象(字典、集合、文件)
2. 迭代器与列表比较，迭代器是惰性计算的，更节省内存

缺点：

1. 无法获取迭代器的长度，使用不如列表索引取值的灵活
2. 一次性的，只能往后取值，不能倒着取值

查看可迭代对象与迭代器对象

from collections import Iterable,Iterator
s = "hello"
f = open('1.txt', 'r')
isinstance(s, Iterable) # True 可迭代的对象
isinstance(f, Iterable) # True 可迭代的对象
isinstance(s, Iterator) # False 不是迭代器
isinstance(f, Iterator) # True 是迭代器

生成器

生成器就是一个函数，这个函数内含有yield这个关键字；这个行数执行的结果就是生成器

生成器本质就是迭代器

yield功能：

1. 相当于把iter和next方法封装到函数内部
2. 与return比，return只能返回一次，而yield能返回多次
3. 函数暂停已经继续运行的状态是通过yield保存的

def countdown(n):
    print('start countdown')
    while n > 0:
        yield n
        n -= 1
    print('done')
g = countdown(5) # 生成器就是迭代器
# next(g)  
# next()函数执行，遇到yield返回yield的值并停止执行，等待下一次next()调用
for i in g:
    print(i)
'''
start countdown
5
4
3
2
1
done
'''

yield表达式形式

def eater(name):
    print('%s start to eat' % name)
    while True:
        food = yield
        print('%s eat %s' % (name, food))
e = eater('zhangsan')
next(e)
e.send('包子')

列表解析和生成器表达式

# 列表解析
l = [expression for item1 in iterable1 if condition1
                for item2 in iterable2 if condition2
                ...
                for itemN in iterableN if conditionN
]
# 生成器表达式
g = (expression for item1 in iterable1 if condition1
                for item2 in iterable2 if condition2
                ...
                for itemN in iterableN if conditionN
)

面向过程编程

流水线式的编程思想，在设计程序时，需要把整个流程设计出来

优点：

1. 体系结构更加清晰
2. 简化程序的复杂度

缺点：

1. 可扩展性极其差

内置函数

# 匿名函数
lambda 参数1 [,参数2 [...,参数N]] : 返回表达式

# min 和 max 的高级用法
dic = {'a': 3, 'b': 1, 'c': 5, 'd': 2}
def get_value(key):
    return dic[key]
print(max(dic)) # d
print(max(dic, key = get_value)) # c
# 用匿名函数
print(max(dic, key = lambda k: dic[k]))
# sorted 排序
dic = {'a': 3, 'b': 1, 'c': 5, 'd': 2}
print(sorted(dic)) # ['a', 'b', 'c', 'd']
print(sorted(dic, key = lambda k: dic[k])) # ['b', 'd', 'a', 'c']
# map 映射
l = [1,2,4,6,8]
m = map(lambda item: item+1, l)
print(list(m)) # [2, 3, 5, 7, 9]
# reduce 合并
# reduce(函数, 序列, 初始值=0)
from functools import reduce # python3需要导入
l = range(100)
print(reduce(lambda x,y: x+y, l)) # 4950
# filter 过滤
goods = [
    {'name':'iPhone', 'price': 8000},
    {'name': 'coffee', 'price': 60},
    {'name': 'tea', 'price': 260}
]
f = filter(lambda dic: dic['price'] > 100, goods)
print(list[f]) # [{'name': 'iPhone', 'price': 8000}, {'name': 'tea', 'price': 260}]
# __import__()
# 通过字符串导入模块
s = 'time'
time = __import__(s)  # 等同 import time