1.函数

python3.6内置函数(built-in),函数名是一个指向函数对象的引用,可赋值一个变量使用

1.1,函数定义

#保存在lizi.py中
def 函数名(参数):
    函数体
    return

#空函数--pass可以看作占位符,可以不写东西,先让函数运行起来
def 函数名:
    pass

1.2,函数调用

#调用zili中的指定函数
from zili import 函数名

1.3,函数传参

1.3.1,位置参数

#计算a的平方
def calu(a):
    return a*a
#指定次方
def calu(a,x):
    s = 1
    while x> 0:
        x -= 1
        s *= a
    return s

1.3.2,默认参数

定义默认参数必须指向不变对象

def calu(a,x=2):
s = 1
while x> 0:
    x -= 1
    s *= a
return s
#如果定义L=[],当使用默认参数时L的内容会被叠加输出
def add_end(L=None):
    if L is None:
        L = []
    L.append('END')
    return L

1.3.3,可变参数

在参数定义前加个*,传入参数会自动组装成一个元组

def test(*a):
    print (a)

结果:

1.3.4,关键字参数

在参数定义前加**,传入参数会自动组装成一个字典

2.高级特性

dfdafd

2.1,切片

L = list(rang(100))
# 访问下标为0到10的元素
L[0:10]
# 前十个
L[:10]
# 后十个
L[-10:]
# 前10个数,每两个取一个
L[:10:2]
# 所有数,每5个取一个
L[::5]

2.2,迭代

for key in list:
    print key

2.3,列表生成式

[x*x for x in range(1,11)]

[x * x for x in range(1, 11) if x % 2 == 0]

[m + n for m in 'ABC' for n in 'XYZ']

d = {'x': 'A', 'y': 'B', 'z': 'C' }
[k + '=' + v for k, v in d.items()]

2.4,生成器

如直接创建一个列表会受内存限制,使用生成器不用创建完整的列表--在循环过程中推断后续元素

2.4.1,第一种:将列表的[]改成()

g = (x * x for x in range(10))

2.4.2,第二种:

如果一个函数定义中包含yield关键字,那么这个函数就不再是一个普通函数,而是一个generator

def fib(max):
n, a, b = 0, 0, 1
while n < max:
    yield b
    a, b = b, a + b
    n = n + 1
return 'done'

生成器函数的执行

遇到yield语句返回,再次执行时从上次返回的yield语句处继续执行

def gene():
    print('step 1')
    yield 1
    print('step 2')
    yield(3)
    print('step 3')
    yield(5)

o = gene()
next(o)
next(o)
next(o)

2.5,迭代器

凡是可作用于next()函数的对象都是Iterator类型

3.函数式编程

3.1,高阶函数

变量可以指向函数,一个变量指向一个函数,可以通过变量来调用函数

一个函数就可以接收另一个函数作为参数,这种函数就称之为高阶函数

x = abs
x(-1)=1

def add(x, y, f):
    return f(x) + f(y)

print(add(-5, 6, abs))

3.1.1,map()

map()函数接收两个参数,一个是函数,一个是Iterable,map将传入的函数依次作用到序列的每个元素,并把结果作为新的Iterator返回。

def comput(a):
    print (a+9)
s = map(comput,[1,2,3,4,5,6])
list(s)

3.1.2,reduce()

reduce把一个函数作用在一个序列[x1, x2, x3, ...]上,这个函数必须接收两个参数,reduce把结果继续和序列的下一个元素做累积计算

reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
from functools import reduce
def add(x, y):
    return x + y
print (reduce(add, [1, 3, 5, 7, 9]))

3.1.3,filter()

filter()把传入的函数依次作用于每个元素,然后根据返回值是True还是False决定保留还是丢弃该元素

def is_odd(n):
    return n % 2 == 1

list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))

3.1.4,sorted()

列表排序

3.2,匿名函数

lambda x: x * x

def f(x):
    return x * x

3.3,装饰器

在代码运行期间增加功能的方式,decorator是一个返回函数的高阶函数

3.3.1,对象的内置属性

输出函数名:__name__

3.3.2,test

@log相当执行了 now = log(now)

import functools
def log(func):
    @functools.wraps(func)
    def wrapper(*args,**kw):
        print ('call %s():'% func.__name__)
        return func(*args,**kw)
    return wrapper

@log
def now(a):
    print (str(a)+'hello')

now(1)

@log('execute')--> now = log('execute')(now)

先执行log('execute'),返回一个decorator然后再执行log(now)

import functools
#如果装饰器本身需要参数
def log(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator

@log('execute')
def now():
    print('2015-3-25')

now()