一、函数概述

函数就是执行特定任务完成特定功能的一段代码。可以在程序中将某一段代码定义成函数，并指定一个函数名和接收的输入（参数），这样就可以在程序的其他地方通过函数名多次调用并执行该段代码了。

每次调用执行后，都会根据特定参数执行特定任务完成特定功能从而生成相应的输出（返回值）。

二、函数的参数和返回值

1. 实参对象为可变类型和不可变类型

调用函数时把实参传递给形参从而用实参初始化形参，本质上执行了赋值语句：形参=实参对象，相当于给实参对象贴了一个标签，标签名就是形参名。

如果实参对象是不可变类型，在函数体内对形参对象的任何修改不会修改实参对象。
如果实参对象是可变类型，在函数体内对形参对象的任何修改其实就是对实参对象的修改。

用实际的代码进行演示：

def f(arg1,arg2):print('初始化形参：arg1 = ',arg1, 'arg2 = ',arg2)arg1 = arg1 *2arg2.append(4)print('修改形参后：arg1 = ',arg1, 'arg2 = ',arg2)
i = 10
L = [1,2,3]
print('调用函数前：i = ',i, 'L = ',L) # 调用函数前：i = 10 L = [1,2,3]
f(i,L)
print('调用函数后：i = ',i, 'L = ',L)

1）在调用函数之前：

调用函数前：i =  10  L =  [1, 2, 3]（i为不可变类型对象，L为可变类型对象）
初始化形参：arg1 =  10 arg2 =  [1, 2, 3]

修改形参后：arg1 =  20 arg2 =  [1, 2, 3, 4]

2）在调用函数之后：
调用函数后：i =  10 L =  [1, 2, 3, 4]

我们发现，i 的值没有被修改，L列表的内容被修改了；因为L列表是 “可变类型对象”。

在Python中，对象分为可变类型和不可变类型两种：

1. 可变类型对象（Mutable）：

   • 可变类型对象指的是在创建后可以被修改的对象。这意味着，当对可变类型对象进行操作时，其内部状态可以被改变，而不会创建一个新的对象。
   • 一些常见的可变类型对象包括列表（list）、字典（dict）和集合（set）等。例如，可以向列表中添加或删除元素，或者修改字典中的键值对。

2. 不可变类型对象（Immutable）：

   • 不可变类型对象指的是在创建后不能被修改的对象。这意味着，一旦创建了不可变类型对象，就无法再对其进行修改，任何修改操作都会生成一个新的对象。
   • 一些常见的不可变类型对象包括整数（int）、浮点数（float）、字符串（str）、元组（tuple）和冻结集合（frozenset）等。例如，对字符串进行操作时，原始字符串并不会改变，而是生成一个新的字符串。

在Python中，不可变类型的对象具有以下特点：

• 对象的值一旦确定就不能被修改，任何修改操作都会创建一个新的对象。
• 不可变类型的对象更容易缓存和共享，因为它们的值不会改变，可以安全地被多个变量引用。

而可变类型的对象则具有以下特点：

• 对象的值可以随时被修改，不会创建新的对象。
• 可变类型的对象更适合用于需要频繁修改值的场景，但在多线程环境下需要注意线程安全问题。

对于可变类型对象，在进行函数传参时，不想在函数体内部修改这个变量，可以将该可变类型对象的拷贝（如切片）作为参数进行传参。

2. 返回多个返回值

如果在调用函数后想要多个返回值，可以在定义函数时在函数体使用return，后面跟上要返回的返回值，就可以返回多个返回值了。

def find(numbers):if len(numbers) == 0:returnminV = numbers[0]maxV = numbers[0]for number in numbers[1:len(numbers)]:if number < minV:minV = numberelif number > maxV:maxV = numberreturn maxV, minVnumbers = [1, 2, 3, 4, 5]
print(find(numbers[:]))

3. 缺省值

如果给形参设置的默认值是可变类型的对象，并且前一次调用函数时在函数体内修改了形参的默认值，那么修改后的值将作为下一次调用函数时形参的默认值。

def fun1(L = []):L.append(18)print(L)
fun1() # [18]
fun1() # [18, 18]
fun1() # [18, 18, 18]

但是，我们想要这个函数完成的任务是，每次调用这个函数时，L都为一个空列表，然后在这个空列表后追加一个值，并打印出来。但是 L 是一个可变类型的对象，上一次函数调用更改列表的内容会被保存到下一次调用函数。解决方案就是，不使用一个可变类型的对象作为缺省值：

def fun1(L = None):if L is None:L = []L.append(18)print(L)
fun1() # [18]
fun1() # [18]
fun1() # [18]

4. 定义位置参数

位置参数（Positional Argument）是指在调用函数时，根据参数在括号内出现的顺序来确定参数值对应哪个形参（形式参数）。换句话说，函数调用时传递的实参（实际参数）是通过它们的位置来匹配到函数定义中的形参。

def f(a,b,c):print('a =',a,'b =',b,'c =',c)f(2,5,8)

重要的是要注意，如果在调用函数时没有按照形参定义的顺序提供位置实参，或者提供的位置实参数目与函数定义不匹配，Python将会抛出错误。

总结来说，位置实参使得函数调用时必须保持实参顺序与函数定义中的形参顺序严格一致。

5. 使用 * 定义关键字形参

关键字实参（Keyword Argument）是在调用Python函数时，明确指定每个参数名及对应的值。这种方式允许调用者不必遵循函数定义中参数的顺序，从而提高了代码的可读性和灵活性。

当使用关键字实参时，你可以按任意顺序传递参数，因为它们是根据参数名而不是位置来匹配的。这对于具有多个参数的函数尤其有用，可以让代码意图更加清晰。

关键字实参还可以与位置实参混合使用，但所有位置实参必须出现在所有关键字实参之前。

关键字形参只能接收关键字实参，不能使用位置实参进行传参。

def f(a, b, *, c, d):print(f'a = {a}, b = {b}, c = {c}, d = {d}')
f(1, 2, c = 3, d = 4)

这里的c、d形参被定义为关键字形参。如果使用位置实参3，4传递给c，d就会报错：

def f(a, b, *, c, d):print(f'a = {a}, b = {b}, c = {c}, d = {d}')
f(1, 2, 3, 4)

6. 使用 * 定义数量可变的位置形参

数量可变的位置形参（Variable-Length Positional Arguments）允许你在调用函数时传入不确定数量的位置参数。这种机制通过在形参前添加一个星号（*）来实现，通常习惯性地将这样的形参命名为args（代表arguments的缩写），但你也可以使用其他合法的变量名。

当你定义了一个带有可变位置形参的函数时，所有额外的位置参数会被收集到一个元组（tuple）中。这样，你就可以在函数体内通过这个元组来访问和处理这些参数，即使你事先并不知道会有多少这样的参数被传入。

def f(*args):print(args)
f() # ()
f(1) # (1,)
f(1, 2, 3) # (1, 2, 3)

注意：在定义函数时，只能定义一个 个数可变的 位置形参。

这个语法在内置函数也被大量应用，如print函数：

def print(self, *args, sep='', end='\n', file=None):

通常会把函数的最后一个参数设置为个数可变的位置形参，以便接收剩余的位置实参。

def fun1(a,b,*c):print('a =',a,'b =',b,'c =',c)
fun1(0, 1, 2, 3, 4, 5)
# a = 0 b = 1 c = (2, 3, 4, 5)

如果个数可变的位置形参不是最后一个形参，那么其后面的所有形参都被定义为只能接收关键字实参的关键字形参。

def fun2(a, *b, c, d):print('a=',a, 'b=',b,'c=',c,'d=',d)
fun2(1,2,3,4,c=5,d=6)
# a= 1 b= (2, 3, 4) c= 5 d= 6

如果，以这样的形式传参，就会出现错误：

def fun2(a, *b, c, d):print('a=',a, 'b=',b,'c=',c,'d=',d)
fun2(1,2,3,4,5,6)

因为，2，3，4，5，6会被当做 b 的实参，此时c，d没有被初始化。

7. 使用*将序列中的每个元素都转换为位置实参

def f(a,b,c):print('a =',a,'b =',b,'c =',c)L = [1,2,3]
# 列表L整体作为一个位置实参
f(L)
# f() missing 2 required positional arguments:'b'and 'c'

这里产生报错的原因是将L作为一个列表参数传递给a，而b，c没有传参。

正确的传参方式应该为：

f(L[0],L[1],L[2]) #a = 1, b = 2, c = 3f(*L)
#相当于：f(L[0],L[1],L[2])

注意和个数可变的位置形参进行区分。

个数可变的位置形参是在定义函数时使用，使用*将序列中的每个元素都转换为位置实参是在调用函数时使用。

def fun(*args):print(args)#列表L整体作为一个位置实参
fun(L）# ([1,2,3],)#先将序列中的每个元素都转换为一个单独的位置实参
#再用这些位置实参将个数可变的位置形参初始化为一个元组
fun(*L）# (1,2,3)

8. 使用**定义个数可变的关键字形参

定义函数时，可能无法事先确定传递的关键字实参的个数，在这种情况下，可以在形参前添加两个*，将形参定义为个数可变的关键字形参，从而可以接收0个或任意多个关键字实参。这些关键字实参会将个数可变的关键字形参初始化为一个字典。

def f(**kwargs)print(kwargs)f() # {}
f(a = 1) # f{'a':1}
f(a=1,b=2,C=3) # {'a':1,'b':2,'c':3}

定义函数时，最多只能定义一个个数可变的关键字形参。

很多内置函数都定义了个数可变的关键字形参。例如，内置函数sorted()的定义为：
 

# def sorted(*args,**kwargs):L = ['Python','Java','Swift']
print(sorted(L)) # ['Java','Python','Swift']
print(sorted(L,key = len)) # ['Java','Swift','Python']
print(sorted(L, key = len,reverse = True)) #['Python','Swift','Java']

因为调用函数时位置实参必须位于关键字实参之前，所以个数可变的位置形参必须位于个数可变的关键字形参之前。

9. 使用**将字典中的每个键值对都转换为关键字实参

def f(a,b,c):print('a =',a,'b =',b,'c =',c)
f(a=1,b=2,c=3) # a = 1,b = 2,c = 3d={'a':1,'b':2,'c':3}
#字典d整体作为一个位置实参
#f(d)   f()missing 2 required positional arguments:'b'and 'c'
f(a=d['a'],b=d['b'],c=d['c']) # a = 1, b = 2, c = 3

比较合理的调用函数的方法为：

f(**d) # a = 1, b = 2, c = 3
#相当于：f(a=d['a'],b=d['b'],c=d['c'])

小结一下：

三、Lambda表达式

在Python中，lambda 是一个用于创建匿名函数的关键字。匿名函数是指那些没有名字的函数，它们主要用于一次性使用的小型、简单的功能实现，通常在需要函数对象的地方作为参数传递。下面是对 lambda 函数的详细介绍：

基本概念

lambda 函数允许你在不定义完整函数结构的情况下创建一个简短的、即时的函数。它的语法非常紧凑，只包含一个表达式，而不能包含复杂的逻辑或多条语句。

语法结构

lambda 函数的基本语法如下：

lambda 参数列表: 表达式

• lambda 是关键字，用来声明这是一个匿名函数。
• 参数列表 可以包含任意数量的参数，多个参数之间使用逗号分隔。
• 冒号 : 用来分隔参数列表和表达式。
• 表达式 是 lambda 函数唯一的执行体，它会被计算并作为函数的返回值。这个表达式不能包含赋值、条件控制等多行语句。

示例

假设我们要创建一个简单的函数，用于计算两个数的和。使用常规函数定义可能是这样的：

def add(a, b):return a + b

使用 lambda 函数，则可以写成：

add = lambda a, b: a + b

应用场景

lambda 函数常用于以下情境：

1. 排序操作：当对列表进行排序时，可以使用 lambda 函数作为 sorted() 函数的 key 参数来指定排序依据。

   data = [('apple', 2), ('banana', 1), ('cherry', 3)]
   sorted_data = sorted(data, key=lambda x: x[1])  # 按元组中的第二个元素排序

2. 高阶函数：作为 map()、filter()、reduce() 等函数的参数，用于处理集合中的每个元素。

   numbers = [1, 2, 3, 4]
   doubled = map(lambda x: x * 2, numbers)  # 将每个元素乘以2

3. 事件驱动编程：在某些GUI库中，快速定义简单的事件处理器。

注意事项

• 简洁性：由于 lambda 函数只能包含一个表达式，它不适合用于实现复杂的逻辑。
• 命名：虽然 lambda 函数本身没有名字，但你可以将它赋值给一个变量，从而间接地“命名”它。
• 作用域：lambda 函数可以访问外部作用域的变量，但需要注意变量捕获规则，尤其是闭包效应。

四、文档字符串

文档字符串（Docstrings）是Python程序中用于描述模块、类、函数或方法的用途、参数、返回值等信息的字符串。它们是Python中一种重要的文档编写约定，遵循PEP 257标准，有助于提高代码的可读性和可维护性。文档字符串应该易于人类阅读，并且能够被诸如 Sphinx 或 pydoc 这样的工具抽取，生成自动化文档。

基本规则：

1. 位置：文档字符串位于函数、方法、模块或其他可被文档化的实体的开头，紧跟着定义之下，且在任何其他语句之前。
2. 格式：文档字符串通常由三个引号（单引号或双引号，但需成对匹配）包围，即 '''文档内容''' 或 """文档内容"""。
3. 结构：
   • 第一行是一个简短的总结，以大写字母开头，以句号结束。
   • 第二行是空行。
   • 从第三行开始，是详细描述，可以有多行，用于提供更多的说明、参数列表、返回值信息、示例等。

示例：

def add(a, b):"""Add two numbers together and return the sum.Parameters:a (int): The first number to add.b (int): The second number to add.Returns:int: The sum of the two input numbers."""return a + b

特性：

• 自动关联：在交互式环境中，如IPython或Jupyter Notebook，可以直接通过对象的__doc__属性查看文档字符串。
• 易于提取：许多工具（如Sphinx）可以自动生成API文档，直接从源代码的文档字符串中提取信息。
• 代码自解释：良好的文档字符串使得代码自我解释，降低了阅读和理解代码的难度。

在Python中，有几种常见的方式来查看文档字符串（docstrings）：

1. 使用内置的help()函数： 这是最直接的方法，可以用来查看函数、类、模块等的文档字符串。在交互式Python环境（如IDLE、Python shell、Jupyter Notebook）中，只需输入 help(对象) 即可。例如，要查看 print 函数的文档字符串，你可以输入：

   help(print)

2. 访问__doc__属性： 每个具有文档字符串的对象（如函数、类、模块）都有一个 __doc__ 属性，直接访问这个属性可以获取文档字符串的内容。例如：

   print(add.__doc__)  # 假设add是上面示例中的函数

3. 使用第三方库： 一些第三方库，如Sphinx，可以用来更系统地生成和查看文档，尤其是对于大型项目。这些工具通常会从源代码的文档字符串中提取信息，生成HTML或其他格式的文档。

4. IDE和代码编辑器集成： 大多数现代的集成开发环境（IDE）和代码编辑器（如PyCharm、VS Code等）都支持查看文档字符串的功能。通常，将鼠标悬停在函数名或类名上，或者按下特定的快捷键，就可以直接在弹出窗口中查看文档字符串。

五、有关函数的一些题目

Python中的round()函数是一个内置函数，用于对数字进行四舍五入操作。它可以根据提供的参数，将浮点数或整数四舍五入到指定的小数位数或最接近的整数。以下是round()函数的基本使用方法和特点：

基本语法

round(number, ndigits=None)

• number: 需要四舍五入的数字（可以是浮点数或整数）。
• ndigits（可选）: 指定要保留的小数位数。如果省略或设为0，则将数字四舍五入到最接近的整数。如果ndigits为正数，则四舍五入到指定位数的小数；如果为负数，则四舍五入到小数点左侧的相应位数。

特点和注意事项

1. 四舍五入规则：Python的round()函数在处理末尾为0.5的情况时，采用“银行家舍入”规则，即当舍弃部分为0.5时，会选择最接近的偶数方向进行四舍五入。例如，round(2.5)得到2，而round(3.5)得到4。

2. 返回类型：即使输入的是整数，round()函数返回的也是浮点数，除非结果本身为整数。

3. 负数的ndigits：当ndigits为负数时，会对整数部分进行四舍五入，返回值依然是浮点数。

4. 性能考量：对于大量数据的四舍五入操作，虽然round()函数使用方便，但其性能可能不如直接进行数学运算或使用numpy等库中的优化函数。

示例

• 四舍五入到最近的整数：

  round(2.7)  # 输出: 3
  round(2.4)  # 输出: 2

• 四舍五入到特定小数位：

  round(3.14159, 2)  # 输出: 3.14
  round(2.3456, 1)   # 输出: 2.3

• 四舍五入到小数点左侧的位数：

  round(9876, -1)  # 输出: 9900
  round(9876, -2)  # 输出: 9800

根据给定的函数定义 def area(r, pi=3.14): return round(pi*r*r, 2)，当调用 area(3.14, 4) 时，实际上覆盖了默认的 pi 值，使用了传入的 4 作为 π 的值。

所以，计算过程变为计算圆的面积公式 A = πr²，其中 r = 3.14 和 π = 4。

代入公式得：A = 4 * 3.14 * 3.14，然后使用 round() 函数将结果四舍五入到小数点后两位。

计算结果为：round(4 * 3.14 * 3.14, 2)。

计算这个表达式的值：round(39.4384, 2)，得到 39.44。

因此，area(3.14, 4) 的值为 39.44。

---

当你定义了一个带有可变位置形参的函数时，所有额外的位置参数会被收集到一个元组（tuple）

---

在Python中，lambda 表达式是用来创建匿名函数的简洁方式，它主要用于需要一个简单函数的地方，而不需要用 def 关键字定义一个完整的函数。lambda 表达式的语法结构如下：

lambda 参数列表: 表达式

注意，lambda 表达式中，冒号后面直接跟一个计算表达式，而不使用 return 语句。这是因为lambda 自动返回表达式的计算结果。

---

• 定义了一个find函数，它接收一个位置参数a和任意数量的关键字参数，这些关键字参数被收集到名为B的字典中，使用**语法实现。
• 函数内部打印B的类型，运行时会显示出B是一个字典类型，因为B负责收集额外的关键字参数。
• 调用find函数时，'letters'作为位置参数a传入，而A='1'和B='2'作为关键字参数，它们会被放入字典B中。

---

所有位置实参必须出现在所有关键字实参之前。

---

生成长度为n的验证码，由小写字母和数字构成，其中n由输入指定,如'b9ih', 'j2dkf8'。

import random
import stringdef generate_captcha(n):"""生成一个长度为n的验证码，包含小写字母和数字"""characters = string.ascii_lowercase + string.digits  # 包含小写字母和数字captcha = ''.join(random.choice(characters) for _ in range(n))return captcha# 示例：生成长度为6的验证码
captcha_example = generate_captcha(6)
print(captcha_example)

1. characters = string.ascii_lowercase + string.digits:

   • string.ascii_lowercase 是一个预定义的字符串，包含了所有的小写字母（'abcdefghijklmnopqrstuvwxyz'）。
   • string.digits 同样是预定义的，包含了所有的阿拉伯数字（'0123456789'）。
   • + 运算符用于将两个字符串连接起来，因此 characters 变量现在包含了所有可能用于构建验证码的字符，即小写字母和数字。

2. random.choice(characters):

   • random.choice() 是 Python 的 random 模块中的一个函数，它从给定的非空序列（在这个例子中是 characters 字符串）中随机选择一个元素。
   • 在每次调用 random.choice(characters) 时，都会从 characters 中随机选取一个字符（小写字母或数字）。

3. for _ in range(n):

   • range(n) 生成一个包含从0到n-1的整数序列，这里的 n 是用户指定的验证码长度。
   • _ 是一个常见的占位符，在Python中用来表示我们不关心循环变量的实际值，只关注循环执行的次数。因此，这段代码会执行 n 次循环。

4. ''.join(...):

   • join() 是字符串的方法，用于将一个字符串列表（或任何可迭代的字符串对象）合并成一个单独的字符串。
   • 在这里，''.join(...) 将前面循环中每次 random.choice(characters) 产生的字符连接起来，形成一个连续的字符串，即最终的验证码。
   • 每次循环选择的字符被当作一个元素添加到一个隐式的列表中，然后通过无间隔（空字符串 ''）将这些字符合并成一个整体。

综上所述，这行代码的作用是通过循环 n 次，每次循环都从包含小写字母和数字的 characters 集合中随机选择一个字符，最后将这些字符连接起来形成一个长度为 n 的验证码字符串。

---

使用random库中的randint函数生成500个[1,100]的随机数，找出其中的众数。众数即为序列中出现次数最多的数。

输入 随机数种子；

输出 众数及出现次数构成的元组，如(18,10)意为数字18出现了10次.

import random
from collections import Counterdef rnd_mod():# 生成500个[1,100]范围内的随机数random_numbers = [random.randint(1, 100) for _ in range(500)]# 使用Counter计算每个数字出现的次数counts = Counter(random_numbers)# 找到出现次数最多的数字及其计数mode, count = counts.most_common(1)[0]print(f"({mode}, {count})")
random.seed(input())
rnd_mod()

Counter 是 Python 的 collections 模块中提供的一个非常实用的类，主要用于统计可迭代对象中元素出现的次数。它是一个字典的子类，因此继承了字典的所有特性，并且增加了一些额外的方法来方便地处理计数相关的问题。下面是关于 Counter 的一些详细信息和用法介绍：

• 创建 Counter 对象

要使用 Counter，首先需要从 collections 模块中导入它，然后通过传递一个可迭代对象（如列表、元组、字符串等）给 Counter 构造函数来创建一个计数器对象。

from collections import Counter# 使用列表创建 Counter
list_example = ['apple', 'banana', 'apple', 'orange', 'banana', 'banana']
counter_example = Counter(list_example)

在这个例子中，counter_example 将会记录 'apple'、'banana' 和 'orange' 分别出现的次数。

访问计数

一旦创建了 Counter 对象，你可以像访问字典一样访问各个元素的计数：

print(counter_example['apple'])  # 输出 'apple' 的计数

• 常用方法

• elements(): 返回一个迭代器，每个元素重复其计数的次数。这对于重新创建原始数据集很有用，尤其是当需要保持元素的频率时。

• most_common([n]): 返回一个列表，提供 n 个频率最高的元素及其计数。如果没有提供 n 或者是 None，则返回计数器中的所有元素。如果有多个元素出现次数相同，则它们的顺序是不确定的。

• subtract(): 从另一个计数器中减去元素的计数，对于不存在的元素不改变计数（不会出现负数计数）。

• update(): 更新计数器，可以用一个字典或另一个计数器来更新当前计数器的值。

• copy(): 返回一个新的 Counter 对象，包含原计数器的浅复制。

特点与优势

Counter 的主要优势在于其简洁性和高效性，它使得统计和分析大量数据中的元素频率变得简单快捷。此外，它提供的方法直接支持了许多常见的数据分析任务，比如找出最频繁出现的项、计算元素的频率分布等。

总之，Counter 是处理计数问题时的一个强大工具，无论是文本分析、数据挖掘还是简单的统计需求，它都能提供便捷且高效的支持。

也可以使用另外一种方法：

import randomdef rnd_mod():nums = [random.randint(1,100) for i in range(500)]setNums = set(nums)num_count = {}for num in setNums:num_count[num] = nums.count(num)print(max(num_count.items(), key = lambda item: item[1]))random.seed(input())
rnd_mod()

1. 生成随机数列表：首先，通过导入random模块，并设置一个随机种子（用户输入），保证每次运行时生成的随机数序列是相同的。然后，使用列表推导式生成一个包含500个在1到100之间的随机整数的列表nums。

2. 去重并计数：接着，将这个列表转换为一个集合setNums以去除重复的元素。之后，定义一个字典num_count来存储每个不同数字出现的次数。通过遍历集合setNums中的每个元素，并利用count()方法计算该元素在原始列表nums中出现的次数，以此填充字典num_count。

3. 找出出现次数最多的数字及其频率：最后，使用max()函数结合lambda表达式从字典num_count的项中找到键值对（即数字和其出现次数），其中item[1]表示取每一对中的第二个元素，即出现次数。max()函数会返回出现次数最多的那个键值对，即最大频率及其对应的数字。此结果被直接打印出来。

---

参考官方文档中math库中各函数的文档注释要求，完成程序模板中绝对值、最大公约数、阶乘三个函数定义，使自定义的函数的输入、输出和异常尽可能与math库中的函数一致。用户输入函数命令，代码调用函数执行对应功能：
若输入命令为'poW',则输入一个数值和一个整数n,并调用pow0函数计算并输出x的n次方。
若输入指令为'lcm',则在一行内输入两个正整数a,b,并调用lcm0函数计算并输出这两个正整数的最小公倍数。
若输入指令为'cei',则输入一个数值x,并调用ceil0函数计算并输出不小于该数的最小整数。
若输入指令为'floor',则输入一个数值x,并调用fIoo0函数计算并输出不大于该数的最大整数。
若输入其他指令，则直接输出'undefined'。

def choose_function(no):"""接收一个字符串为参数，根据参数值判断问题类型，调用合适的函数进行操作。"""if no == 'pow':  # 调用pow()函数，并输出其返回值x,n = eval(input())print(pow(x, n))elif no == 'lcm':  # 调用lcm()函数，并输出其返回值a, b = eval(input())print(lcm(a, b))elif no == 'ceil':  # 调用ceil()函数，并输出其返回值x = eval(input())print(ceil(x))elif no == 'floor':  # 调用floor()函数，并输出其返回值x = eval(input())print(floor(x))else:print('undefined')def pow(x, n):  # 幂运算函数"""接收一个数字x和一个整数n为参数,返回x的n次幂的结果的浮点数类型要求使pow(1.0, x) 和 pow(x, 0.0) 总是返回 1.0"""result = 1.0for i in range(n):result = result * xreturn resultdef lcm(a, b):"""接收两个正整数为参数，以整数类型返回两个数的最小公倍数"""s = a * bwhile a % b != 0:a, b = b, (a % b)return s // bdef ceil(x):"""接受一个浮点数或整数，返回大于或等于该数的最小整数"""if int(x) == x or x < 0:return int(x)else:return int(x + 1)def floor(x):"""接受一个浮点数或整数，返回不大于该数的最大整数"""if int(x) == x or x > 0:return int(x)else:return int(x - 1)if __name__ == '__main__':func_name = input()choose_function(func_name)

---

 本文参考以下资料，在此对该作者表示感谢：

《图解Python》学习路径：图解Python视频教程_Python学习路线-51CTO学堂

---

今天的分享就到这里了，如果，你感觉这篇博客对你有帮助的话，就点个赞吧！感谢感谢……