码迷,mamicode.com
首页 > 编程语言 > 详细

Python基础4 函数

时间:2017-07-17 11:06:35      阅读:288      评论:0      收藏:0      [点我收藏+]

标签:import   装饰器   自身   ogg   维护   logging   --   传参数   break   

函数基本语法及特性

函数是什么?

定义:

函数是指将一组语句的集合通过一个名字(函数名)封装起来,要想执行这个函数,只需调用其函数名即可。

特性:

减少重复代码

使程序变的可扩展

使程序变的易维护

def sayhi():    # 函数名
    print(Hi, Im Jack!)

sayhi()    # 调用函数

函数也可以带参数

def test(x, y):
    print(x, y)

test(1,2)

 


函数参数与局部变量

形参:

变量只有在被调用时才分配内存单元,在调用结束时,即刻释放所分配的内存单元。因此,形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量。

实参:

可以是常量、变量、表达式、函数等,无论实参是何种类型的量,在进行函数调用时,它们都必须有确定的值,以便把这些值传送给形参。因此应预先用赋值,输入等办法使参数获得确定值。

def test(x, y):     # x, y为形式参数       
    print(x + y)    

test(1, 2)    # 1, 2为实际参数

默认参数:

def test(x, y, z=3):    # z为默认参数
    print(x + y + z)    

test(1, 2)      # 在函数调用时,可以不给z传值,如果不传则该参数的值为3

关键字参数:

正常情况下,给函数传参数要按顺序,不想按顺序就可以用关键参数,只需指定参数名即可,但记住一个要求就是,关键参数必须放在位置参数之后。

def test(x, y, z):
    print(x + y + z)

test(1, z=3, y=10)    # 这里调用test函数时,先将位置参数1赋值给x再将z、y以关键字参数形式传入函数中

非固定参数:

若你的函数在定义时不确定用户想传入多少个参数,就可以使用非固定参数,*args 会把多传入的参数变成一个元组形式。

def test(x, y, *args):
    print(x, y, *args, x, y, args)

test(1, 2, 3, 4)

>>> x, y, *args 1 2 (3, 4)

还可以有一个**kwargs,*kwargs 会把多传入的参数变成一个dict形式。

def test(x, y, *args, **kwargs):
    print(x, y, *args, **kwargs, x, y, args, kwargs)

test(1, 2, 3, 4, a=5, b=6, c=7)

>>>x, y, *args, **kwargs 1 2 (3, 4) {c: 7, a: 5, b: 6}

局部变量

name = Jack

def test(name):
    name = Tom
    print(My name is , name)

test(name)

函数会从自身查name变量去调用

全局变量与局部变量

在子程序中定义的变量称为局部变量,在程序的一开始定义的变量称为全局变量。
全局变量作用域是整个程序,局部变量作用域是定义该变量的子程序。
当全局变量与局部变量同名时:
在定义局部变量的子程序内,局部变量起作用;在其它地方全局变量起作用。
 

返回值

要想获取函数的执行结果,就可以用return语句把结果返回

注意:

函数在执行过程中只要遇到return语句,就会停止执行并返回结果,也可以理解为 return 语句代表着函数的结束

如果未在函数中指定return,那这个函数的返回值为None 

 


嵌套函数

name = Tom


def change_name1():
    name = Tom1
    def change_name2():
        name = Tom2
        print(name)
    change_name2()
    print(name)

change_name1()
print(name)

 


递归

递归特性:

必须有一个明确的结束条件

每次进入更深一层递归时,问题规模相比上次递归都应有所减少

递归效率不高,递归层次过多会导致栈溢出(在计算机中,函数调用是通过栈(stack)这种数据结构实现的,每当进入一个函数调用,栈就会加一层栈帧,每当函数返回,栈就会减一层栈帧。由于栈的大小不是无限的,所以,递归调用的次数过多,会导致栈溢出)

def calc(n):
    print(n)
    if int(n/2) == 0:
        return n
    print(----)
    return calc(int(n/2))

calc(10)

 


匿名函数

匿名函数就是不需要显式的指定函数

def calc(n):
    return n*n
print(calc(10))


# 匿名函数
calc = lambda n: n*n
print(calc(10))

 


高阶函数

变量可以指向函数,函数的参数能接收变量,那么一个函数就可以接收另一个函数作为参数,这种函数就称之为高阶函数。

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

res = add(-3, 4, abs)
print(res)

 


迭代器、生成器、装饰器

迭代器

凡是可作用与for循环的对象都是可迭代对象
凡是可作用于next()函数的对象都是迭代器类型,表示一个惰性计算的序列
集合数据类型是可迭代对象,但不是迭代器,可通过iter()函数获得一个迭代器对象
Python的for循环本质上是通过不断调用next()函数实现的

import time
 
def consumer(name):
    print ("%s 准备吃包子啦!" % name)
    while True:
        baozi = yield
        print ("包子[%s]来了,被[%s]吃了" % (baozi,name))
 
def producer():
    c1 = consumer("Jack")
    c2 = consumer("Tom")
    c1.__next__()
    c2.__next__()
    for i in range(1,11):
        time.sleep(1)
        print ("做好1个包子,分成两份!")
        c1.send(i)
        c2.send(i)
producer()

生成器

#列表生成式
list1 = [i*2 for i in range(1,11)]
list = (x*2 for x in range(1,1000000))

#函数生成器
def fib(max):
    n,a,b = 0,0,1
    while n < max:
        #print (b)
        yield b
        a,b = b,a+b
        n = n + 1
    #return异常的时候打印消息
    return "done"
 
g = fib(10)
while True:
    try:
        x = next(g)
        print ("g:",x)
    except StopIteration as e:
        print ("Generator return value:",e.value)
        break

装饰器

本身是函数,(装饰其他函数)就是为其他函数添加附加功能

原则:

不能修改被装饰的函数的源代码

不能修改被装饰的函数的调用方式

实现装饰器知识储备:

函数即“变量”

高阶函数

嵌套函数

高阶函数+嵌套函数=》装饰器

def logging(func):
    def warpper(*args,**kwargs):
        func(*args,**kwargs)
        print("logging...")
    return warpper
 
@logging
def test1(name,age):
    print("func in %s,%s" % (name,age))
 
@logging
def test2(name,age):
    print("func in %s,%s" % (name,age))

Python基础4 函数

标签:import   装饰器   自身   ogg   维护   logging   --   传参数   break   

原文地址:http://www.cnblogs.com/qiang8216/p/7193180.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!