函数
函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。
函数能提高应用的模块性,和代码的重复利用率。你已经知道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