学习笔记之Python的函数

一、定义函数

def 函数名称(参数1,参数2):
	函数内语句块
	return 返回值

当参数个数不确定时，可以使用(*参数1)或(**参数1)

一个*的参数：

# 定义函数
def function_name (x,*y):
    print("x = ",x)
    print("y = ",y)
# 调用函数
function_name(1,2,3,4)
>>>
x =  1
y =  (2, 3, 4)

二个*的参数：

# 定义函数
def function_name (x,**y):
    print("x = ",x)
    print("y = ",y)
# 调用函数
function_name(1,a=2,b=3)
>>>
x =  1
y =  {'a': 2, 'b': 3}

二、函数的使用

python 函数的参数传递：

不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun(a)，传递的只是a的值，没有影响a对象本身。比如在 fun(a)内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。

可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun(la)，则是将 la 真正的传过去，修改后fun外部的la也会受影响

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

2.1 global和nonlocal区别:

在Python中，global和nonlocal的作用都是可以实现代码块内变量使用外部的同名变量，但其中是有很明显的区别的。

• global： 很明显就是声明代码块中的变量使用外部全局的同名变量
• nolocal： 的使用场景就比较单一，它是使用在闭包中的，使变量使用外层的同名变量

2.2 嵌套函数的使用

当一个参数不需要经常更改且反复使用时，可以使用嵌套函数。这样可以先传一个参数，类似于一个常量，之后再传其他的参数就行。

def weight(g):
    def cal_mg(m):
        return m*g
    return cal_mg

f = weight(10)
# 这是的f()已替换为上面的cal_mg函数
g = f(50)
print(g)
>>>
500

2.3 装饰器

可以理解为对函数的一个扩展

#coding:utf-8
import time
from functools import wraps
# 定义装饰器
def timethis(func): 
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        func(*args, **kwargs) 
        end = time.time() 
        print(func.__name__, end - start) 
    return wrapper
# 定义函数
@timethis
def countdown(n):
    while n>0:
        n -= 1

@timethis
def test_list_append():
    lst = []
    for i in range(1000000):
        lst.append(i)

@timethis
def test_list_compre():
    [i for i in range(1000000)]
# 调用函数
countdown(1000000)
countdown(100000000)

test_list_append()
test_list_compre()

2.4 特殊函数

特殊函数： 在调用方法、实现功能、性能方面与其他函数有所差别。

2.4.1 lambda

有些时候，不需要显式地定义函数，直接传入匿名函数更方便。以map()函数为例，计算f(x)=x2时，除了定义一个f(x)的函数外，还可以直接传入匿名函数：

list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))

关键字lambda表示匿名函数，冒号前面的x表示函数参数。
匿名函数的限制： 就是只能有一个表达式，不用写return，返回值就是该表达式的结果。
匿名函数的好处： 因为函数没有名字，不必担心函数名冲突。

2.4.2 map：

语法：
map(function, iterable, …)

• function - 针对每一个迭代调用的函数
• iterable - 支持迭代的一个或者多个对象。在 Python 中大部分内建对象，例如 lists, dictionaries, 和 tuples 都是可迭代的

第一个参数 function 以 参数序列中的 每一个元素调用 function 函数，返回 包含每次 function 函数返回值的 新列表。假如我们有一个字符串列表，我们想要将每一个元素都转换成大写字母。想要实现这个目的的一种方式是，使用传统的for循环:

for循环：

# 定义列表
directions = ["north", "east", "south", "west"]
directions_upper = []
# 转换
for direction in directions:
    d = direction.upper()
    directions_upper.append(d)
# 打印
print(directions_upper)
>>>
['NORTH', 'EAST', 'SOUTH', 'WEST']

map函数：

# 定义列表
directions = ["north", "east", "south", "west"]
# 借助lambda函数转换
directions_upper = map(lambda s: s.upper(), directions)
# 打印
print(list(directions_upper))
>>>
['NORTH', 'EAST', 'SOUTH', 'WEST']

2.4.3 filter

n = range(-5,5)
# filter：过滤函数
f = filter(lambda x: x>0,n)
print(list(f))
>>>
[1, 2, 3, 4]