六、函数

函数

函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。

函数能提高应用的模块性,和代码的重复利用率。你已经知道Python提供了许多内建函数,比如print()。但你也可以自己创建函数,这被叫做用户自定义函数。

定义一个函数

  • 规则:

1.函数代码块以 def 关键词开头,后接函数标识符名称和圆括号 ()。 任何传入参数和自变量必须放在圆括号中间,圆括号之间可以用于定义参数。
2. 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。 函数内容以冒号起始,并且缩进。 return [表达式]
3.结束函数,选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

  • 语法
Python 定义函数使用 def 关键字,一般格式如下:
def 函数名(参数列表):
    函数体
默认情况下,参数值和参数名称是按函数声明中定义的的顺序匹配起来的。
  • 实例
## 输出"Hello World!":

def hello() :
   print("Hello World!")
---------
hello()
Hello World!

带上参数变量:

#!/usr/bin/python3

# 计算面积函数
def area(width, height):
    return width * height

def print_welcome(name):
    print("Welcome", name)

print_welcome("Runoob")
w = 4
h = 5
print("width =", w, " height =", h, " area =", area(w, h))
以上实例输出结果:

Welcome Runoob
width = 4  height = 5  area = 20

函数调用

定义一个函数:给了函数一个名称,指定了函数里包含的参数,和代码块结构。

这个函数的基本结构完成以后,你可以通过另一个函数调用执行,也可以直接从 Python 命令提示符执行。
如下实例调用了 printme() 函数:

#!/usr/bin/python3

# 定义函数
def printme( str ):
   "打印任何传入的字符串"
   print (str);
   return;

# 调用函数
printme("我要调用用户自定义函数!");
printme("再次调用同一函数");
以上实例输出结果:

我要调用用户自定义函数!
再次调用同一函数
参数传递
在 python 中,类型属于对象,变量是没有类型的:

a=[1,2,3]

a="Runoob"
以上代码中,[1,2,3] 是 List 类型,"Runoob" 是 String 类型,而变量 a 是没有类型,她仅仅是一个对象的引用(一个指针),可以是指向 List 类型对象,也可以是指向 String 类型对象。

Python的作用域一共有4种,分别是:

L (Local) 局部作用域
E (Enclosing) 闭包函数外的函数中
G (Global) 全局作用域
B (Built-in) 内建作用域
以 L –> E –> G –>B 的规则查找,即:在局部找不到,便会去局部外的局部找(例如闭包),再找不到就会去全局找,再者去内建中找。

迭代器

迭代是Python最强大的功能之一,是访问集合元素的一种方式。

迭代器是一个可以记住遍历的位置的对象。

迭代器对象从集合的第一个元素开始访问,直到所有的元素被访问完结束。迭代器只能往前不会后退。

迭代器有两个基本的方法:iter() 和 next()。

字符串,列表或元组对象都可用于创建迭代器:

实例(Python 3.0+)
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
print (next(it))   # 输出迭代器的下一个元素
1
print (next(it))
2

迭代器对象可以使用常规for语句进行遍历:
实例(Python 3.0+)
#!/usr/bin/python3

list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
for x in it:
    print (x, end=" ")
执行以上程序,输出结果如下:

1 2 3 4

也可以使用 next() 函数:

#!/usr/bin/python3

import sys         # 引入 sys 模块

list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象

while True:
    try:
        print (next(it))
    except StopIteration:
        sys.exit()
执行以上程序,输出结果如下:

1
2
3
4

生成器

在 Python 中,使用了 yield 的函数被称为生成器(generator)。

跟普通函数不同的是,生成器是一个返回迭代器的函数,只能用于迭代操作,更简单点理解生成器就是一个迭代器。

在调用生成器运行的过程中,每次遇到 yield 时函数会暂停并保存当前所有的运行信息,返回 yield 的值, 并在下一次执行 next()
方法时从当前位置继续运行。

调用一个生成器函数,返回的是一个迭代器对象。

以下实例使用 yield 实现斐波那契数列:

#!/usr/bin/python3

import sys

def fibonacci(n): # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n): 
            return
        yield a
        a, b = b, a + b
        counter += 1
f = fibonacci(10) # f 是一个迭代器,由生成器返回生成

while True:
    try:
        print (next(f), end=" ")
    except StopIteration:
        sys.exit()
执行以上程序,输出结果如下:

0 1 1 2 3 5 8 13 21 34 55

高阶函数

把函数作为参数传入,这样的函数称为高阶函数,函数式编程就是指这种高度抽象的编程范式。
变量可以指向函数,函数的参数能接收变量,那么一个函数就可以接收另一个函数作为参数,这种函数就称之为高阶函数。

abs()

abs()方法/函数返回x的绝对值 - x和零之间的(正)的距离。

def add(x, y, f):
    return f(x) + f(y)
##当我们调用add(-5, 6, abs)时,参数x,y和f分别接收-5,6和abs,根据函数定义
add(-5, 6, abs)
11

map()

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

  • 实例
def f(x):
     return x * x
print(list(map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])))
[1, 4, 9, 16, 25, 36, 49, 64, 81]

python3想得到列表,得用list() 转换否者得到是map对象

map()作为高阶函数,事实上它把运算规则抽象了,因此,我们不但可以计算简单的f(x)=x2,还可以计算任意复杂的函数,比如,把这个list所有数字转为字符串:

print(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
['1', '2', '3', '4', '5', '6', '7', '8', '9']

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]))
-------------- 
25
  • 把序列[1, 3, 5, 7, 9]变换成整数13579
from functools import reduce

def fn(x, y):
  return x * 10 + y
print(reduce(fn, [1, 3, 5, 7, 9]))
-------------
13579
  • 把str转换为int的函数
def fn(x, y):
    return x * 10 + y
def char2num(s):
    return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
print(reduce(fn, map(char2num, '13579')))
---------
13579

filter()

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

  • 保留奇数
def add(n):
    return n % 2 == 1
print(list(filter(add, [1,2,3,4,5,6,7,8,9])))
--------
[1, 3, 5, 7, 9]
  • 去空格
def dellnone(s):
    return s and  s.strip()
print(list(filter(dellnone, ['A','',None,'C','','BA'])))

sorted

sorted() 函数对所有可迭代的对象进行排序操作。

sort 与 sorted 区别:

sort 是应用在 list 上的方法,sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作,而内建函数 sorted 方法返回的是一个新的
list,而不是在原来的基础上进行的操作。

  • 语法

## sorted 语法:
sorted(iterable, key=None, reverse=False)  
##  参数说明:
iterable -- 可迭代对象。
key -- 主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序。
reverse -- 排序规则,reverse = True 降序 , reverse = False 升序(默认)。
返回值
返回重新排序的列表。
  • 实例

sorted([5, 2, 3, 1, 4])
[1, 2, 3, 4, 5]                      # 默认为升序
  • 利用key进行倒序排序
example_list = [5, 0, 6, 1, 2, 7, 3, 4]
result_list = sorted(example_list, key=lambda x: x*-1)
print(result_list)
------------------------
[7, 6, 5, 4, 3, 2, 1, 0]
  • 要进行反向排序,也通过传入第三个参数 reverse=True:
example_list = [5, 0, 6, 1, 2, 7, 3, 4]
sorted(example_list, reverse=True)
[7, 6, 5, 4, 3, 2, 1, 0]
  • 字符串排序
print(sorted(['bob', 'about', 'Zoo', 'Credit']))
['Credit', 'Zoo', 'about', 'bob']

默认情况下,对字符串排序,是按照ASCII的大小比较的,由于’Z’ < ‘a’,结果,大写字母Z会排在小写字母a的前面。

匿名函数

当我们在传入函数时,有些时候,不需要显式地定义函数,直接传入匿名函数更方便。

  • 直接传入匿名函数
print(list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9])))
----------
[1, 4, 9, 16, 25, 36, 49, 64, 81]
##实际上就是:
def f(x):
    return x * x
  • 也可以把匿名函数赋值给一个变量,再利用变量来调用该函数
f = lambda x:x*x
print(f(5))
  • 也可以把匿名函数作为返回值返回
def build(x, y):
    return lambda: x * x + y * y
阅读更多
个人分类: python
上一篇五、文件操作
下一篇七、考试题目
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭