python123自定义幂函数_Python基础教程-第6章-函数

6.1 自定义函数

函数执行特定的操作并返回一个值1，你可以调用它。一般而言，要判断某个对象是否可调用，可使用内置函数callable。

import math

x = 1

y = math.sqrt

callable(x)

# False

callable(y)

# True

使用def来定义函数。

def hello(name):

return 'Hello, ' + name + '!'

6.1.1 给函数编写文档

在有些地方，如def语句后面(以及模块和类的开 头，这将在第7章和第10章详细介绍)，添加这样的字符串很有用。放在函数开头的字符串称为 文档字符串(docstring)，将作为函数的一部分存储起来。

特殊的内置函数help很有用。在交互式解释器中，可使用它获取有关函数的信息，其中包含 函数的文档字符串。

def square(x):

'Calculates the square of the number x.'

return x * x

# 访问函数文档字符串

square.__doc__

# 'Calculates the square of the number x.'

help(square)

# Help on function square in module __main__:

# square(x)

# Calculates the square of the number x.

6.1.2 其实并不是函数的函数

在Python中，有些函数什么都不返回。什么都不返回的函数不包含return语句，或者包含return语句，但没 有在return后面指定值。

def test():

print('This is printed')

return

x = test()

# This is printed

print(x)

# None

由此可知，所有的函数都返回值。如果你没有告诉它们该返回 什么，将返回None。

6.2 参数魔法

在def语句中，位于函数名后面的变量通常称为形参，而调用函数时提供的值称为实参，在很重要的情况下，我会将实参称为值

6.2.1 我能修改参数吗

函数通过参数获得了一系列的值，你能对其进行修改吗?如果这样做，结果将如何?参数不过是变量而已，行为与你预期的完全相同。在函数内部给参数赋值对外部没有任何影响。

def try_to_change(n):

n = 'Mr. Gumby'

name = 'Mrs. Entity'

try_to_change(name)

name

# 'Mrs. Entity'

在try_to_change内，将新值赋给了参数n，但如你所见，这对变量name没有影响。在函数内部重新关联参数(即给它赋值)时，函数外部的变量不受影响。参数存储在局部作用域内.

但如果参数为可变的数据结构(如列表)呢?

def change(n):

n[0] = 'Mr. Gumby'

names = ['Mrs. Entity', 'Mrs. Thing']

change(names)

names

# ['Mr. Gumby', 'Mrs. Thing']

而在这个示例中，修改了变量关联到的列表。这是因为将同一个列表赋给两个变量时，这两个变量将同时指向这个列表。 就这么简单。下面这个示例说明了这种情况。

names = ['Mrs. Entity', 'Mrs. Thing']

n = names # 再次假装传递名字作为参数 >>>

n[0] = 'Mr. Gumby' # 修改列表

names

# ['Mr. Gumby', 'Mrs. Thing']

使用函数来修改数据结构(如列表或字典)是一种不错的方式

抽象的关键在于隐藏所有的更新细节，为此可使用函数。

def init(data):

data['first'] = {}

data['middle'] = {}

data['last'] = {}

storage = {}

init(storage)

# storage

# {'first': {}, 'middle': {}, 'last': {}}

6.2.3 关键字参数和默认值

有时候，参数的排列顺序可能难以记住，尤其是参数很多时。为了简化调用工作，可指定参 数的名称。 然而，关键字参数最大的优点在于，可以指定默认值。

def hello_1(greeting, name):

print('{}, {}!'.format(greeting, name))

hello_1(greeting='Hello', name='world')

def hello_3(greeting='Hello', name='world'):

print('{}, {}!'.format(greeting, name))

hello_3()

# Hello, world!

hello_3('Greetings', 'universe')

# Greetings, universe!

6.2.4 收集参数

有时候，允许用户提供任意数量的参数很有用。为此，应允许用户提供任意数量的姓名。实际上，这实现起来并不难。

请尝试使用下面这样的函数定义:

def print_params(*params):

print(params)

print_param('Testing')

# 'Testing',

print_param('Testing','Hello')

# 'Testing','Hello'

def print_params_2(title, *params): # 因此星号意味着收集余下的位置参数。

print(title)

print(params)

# Params:

# (1, 2, 3)

与赋值时一样，带星号的参数也可放在其他位置(而不是最后)，但不同的是，在这种情况 下你需要做些额外的工作:使用名称来指定后续参数。

def in_the_middle(x,*y,z):

print(x,y,z)

in_the_middle(1,2,3,4,z=6)

# 1 (2, 3, 4) 6

星号不会收集关键字参数。要收集关键字参数，可使用两个星号。

def print_params_3(**params):

print(params)

print_params_3(x=1,y=2,z=3)

# {'x': 1, 'y': 2, 'z': 3}

def print_params_4(x, y, z=3, *pospar, **keypar):

print(x, y, z)

print(pospar)

print(keypar)

print_params_4(1, 2, 3, 5, 6, 7, foo=1, bar=2)

# 1 2 3

# (5, 6, 7)

# {'foo': 1, 'bar': 2}

6.2.5 分配参数

def add(x, y):

return x + y

params = (1, 2)

add(*params)

# 3

def hello_3(greeting='Hello', name='world'):

print('{}, {}!'.format(greeting, name))

params = {'name': 'Sir Robin', 'greeting': 'Well met'}

hello_3(**params)

# Well met, Sir Robin!

6.3 作用域

在函数内使用的变量称为局部变量(与之相对的是全局变量)。参数类似于局部变量，因此参数与全局变量同名不会有任何问题。

如果有一个局部变量或参数与你要访问的全局变量同名，就无法直接访问全局变量，因为它被局部变量遮住了。必要时可使用globals()[‘parameter’]来访问它。

def combine(parameter):

print(parameter + globals()['parameter'])

parameter = 'berry'

combine('Shrub')

# Shrubberry

在函数内部给变量赋值时，该变量默认为 局部变量，除非你明确地告诉Python它是全局变量。那么如何将这一点告知Python呢?

x = 1

def change_global():

global x

x=x+1

change_global()

# x = 2

Python函数可以嵌套，即可将一个函数放在另一个函数内。

6.4 递归

通常递归包括两个部分：

基线条件(针对最小的问题):满足这种条件时函数将直接返回一个值。

递归条件:包含一个或多个调用，这些调用旨在解决问题的一部分。

# 阶乘的递归

def factorial(n):

if n == 1:

return 1

else:

return n * factorial(n-1)

# factorial(10) = 3628800

# 幂函数的递归

def power(x, n):

if n == 0:

return 1

else:

return x * power(x, n - 1)

# power(2,3) = 8

6.4.2 二分查找

这里的关键是，这种算法自然而然地引出了递归式定义和实现。先来回顾一下定义，确保你知道该如何做。

如果上限和下限相同，就说明它们都指向数字所在的位置，因此将这个数字返回。

否则，找出区间的中间位置(上限和下限的平均值)，再确定数字在左半部分还是右半部分。然后在继续在数字所在的那部分中查找。

def search(sequence, number, lower=0, upper=None):

if upper is None:

upper = len(sequence) - 1

if lower == upper:

assert number == sequence[upper]

return upper

else:

middle = (lower + upper) // 2

if number > sequence[middle]:

return search(sequence, number, middle + 1, upper)

else:

return search(sequence, number, lower, middle)

seq = [34, 67, 8, 123, 4, 100, 95]

seq.sort()

search(seq, 34)

# 2