Python函数初学者指南

Python函数简介

在当今快节奏的IT世界中，就某种技术的深入了解而言，在其他方面拥有优势总是一种优势。Python是一种广泛使用的语言，它为热情的学习者提供了'n'个机会。学习正确使用Python中的函数是任何Python开发人员的一项显着技能。 

在此Python Functions博客中，目标是为您提供入门和使用Python进行函数工作所需的专业知识。我将在此Python Functions博客中介绍以下主题：

• 为什么需要Python函数？
• 什么是Python函数？
• Python函数类型
• Python中的内置函数
• Python递归函数
• Python Lambda函数
• Python中的用户定义函数

让我们通过首先检查为什么需要Python函数开始这个Python函数博客。

为什么我们需要Python函数？

函数管理计算机程序中的输入和输出。编程语言旨在处理数据，而功能则是管理和转换数据的有效方法。

通常进行修改以驱动诸如执行任务和查找结果之类的结果。并且，这样做所需的一组操作或指令来自可以独立于主程序重用的逻辑功能代码块。

实际上，主代码也是一个函数，只是一个非常重要的函数。所有其他函数在逻辑上都进行了对齐和维护，以从您的主代码执行功能。但是，如果该函数以前未定义，则只需要在使用它之前定义一个即可。这是因为该定义列出了其操作步骤。

您是要编写10次还是仅使用一次并使用10次，来编写一条代码？

因此，功能不过是用户想要执行的任务。但是，一次用名称定义它可以让您重用该功能，而又不会使您的主程序看起来太恐怖。这大大减少了代码行，甚至使调试更加容易。

我们很快就会讲到这一点，但是为什么使用一个函数的第一个原因是因为它的可重用性。甚至可以将复杂的操作组合为单项任务，而只需按其名称运行即可运行的事实，这也使当今的计算机代码变得更加清晰。

每种编程语言都可以让您创建并使用这些功能来执行各种任务，而只需一个调用。而且，您可以多次调用它，而不必担心每次都在逻辑上将其代码结构化为您的主代码。

让我们首先通过一个简单的示例来尝试了解他们的需求。

假设您有一台电视机，上面存储着许多频道，接收它们的数字广播，将它们转换为我们所观看的内容，同时还为我们提供了多种其他功能的其他选择。

但这并不意味着有人在逻辑上为每次打开电视或翻转频道时所观看的内容编写代码行。而是，在逻辑上定义了每个任务在工作中的功能，并根据您尝试使用的功能一次又一次地重复使用它们。

通过从正在运行的主函数中多次调用其不同的函数，可以实现所有这些功能。因此，即使您调高或调低音量，其定义的功能也会被反复调用。

而且，让系统运行主要代码来在需要时不断调用这些函数，这也使得在其上进行设计和创新变得更加容易。

需要注意的重要一点是，每当调用此函数时，它就会根据其中指定的指令执行其任务。

这就是机器可以具有不同功能的方式。计算器可能是最常见的例子。它具有加，减，乘，除和其他功能。它的所有功能都已经明确地预定义了，但是它仅执行您选择通过按其各自的按钮来调用的功能。

程序员通过使用功能减少了编码时间和调试时间，从而减少了总体开发时间。

接下来，在这个Python Functions博客上，让我们看一下Python Functions的实际含义。

什么是Python函数？

Python中的函数是此类可重用性的经典示例。因此，为了为从GUI和数学计算到Web开发和测试的广泛应用提供服务，Python的解释器已经配备了许多可随时使用的功能。而且，您还可以将其他包含易于使用的预定义功能的库或模块引入程序。

您真正需要做的就是下载所需的程序包，并根据其说明文件将其导入代码中以自由使用其所有有用的功能。

因此，一旦定义了一个函数，就可以在任何代码中的任意位置多次使用该函数。现在，这是因为Python符合软件工程的DRY原理，该原理旨在用抽象替换任何重复的软件模式或代码，以避免冗余，并确保可以自由使用它们而不会透露其实现的任何内部细节。 。

DRY扩展为“不要重复自己”，拥有可重复使用的代码块的概念对于在Python中实现抽象至关重要。因此，要使用一个函数，您真正需要的就是它的名称，用途，参数（如果需要）以及结果的类型（如果返回）。

这几乎就像在使用汽车或电话一样，您不必一定要了解其组件的工作原理才能使用它们。相反，它们已经被构建用于一般目的，您可以直接使用它们来实现目标，并花费宝贵的时间来实现应用程序的所有创新方面。而且，没有人真正想知道程序中的函数在内部如何工作，只要它能完成任务。

因此，使用Python，除非您必须编写一个新函数或更改现有函数的工作方式，否则您甚至不需要了解内部发生的一切，直到它按所需的方式工作为止。就像再次使用车辆或电话一样，您需要在其中了解其工作方式以制造或修理它。同样，一旦编写了工作功能，就可以重复使用它，而无需再次查看其内部内容。

一个函数可以被称为一次编写的程序的一部分，并且可以在程序中需要的任何时候执行，从而使代码具有可重用性。

该函数是处理数据并产生一些输出的子程序。

 要定义Python函数，您必须在函数名称前使用' def '关键字，并在其末尾添加括号，后跟冒号（:)。

Python使用缩进来表示块而不是括号，以使代码更具可读性。

Python中的函数可以包含任意数量的参数，也可以不包含任何参数。因此，在某些情况下，当您需要函数对其他代码块或主程序中的变量进行操作时，它可能会使用任意数量的参数并产生结果。

 Python函数还可以选择返回一个值。该值可能是函数执行所产生的结果，甚至可能是您在关键字“ return”之后指定的表达式或值。并且，在执行return语句后，程序流返回到函数调用旁边的状态，并从那里开始执行。

因此，要在代码中的任何位置调用Python函数，只需使用其名称并在括号中传递参数（如果有）。

命名函数的规则与命名变量的规则相同。它以AZ字母，大写和小写字母a或下划线（_）开头。其名称的其余部分可以包含下划线（_），数字（0-9），大写或小写字母。

1. 不能选择保留关键字作为标识符。
2. 良好地使用语法，以确保增强的代码可读性。

最好根据其功能命名Python函数。在函数声明的第一行下方使用文档字符串。这是一个文档字符串，它说明了该功能的作用。

接下来在这个Python函数博客中，让我们检查Python中可用的函数类型。

Python函数类型

有很多类型的Python函数。他们每个人都以自己的方式至关重要。以下是不同类型的Python函数：

• Python内置函数
• Python递归函数
• Python Lambda函数
• Python用户定义函数

让我们详细检查这些功能。从内置函数开始，因为它们非常易于理解和实现。

Python内置函数：

Python解释器具有许多始终可用的功能。这些功能称为内置功能。例如，print（）函数将给定的对象打印到标准输出设备（屏幕）或文本流文件中。

在Python 3.6中，有68个内置函数。但是为了简单起见，让我们考虑主要使用的功能，然后就可以在此基础上进行构建。

Python abs（）函数：

定义

abs（）方法返回给定数字的绝对值。如果该数字是复数，则abs（）返回其大小。

句法

abs（）方法的语法为：

它（是否）

参数

 abs（）方法采用一个参数：

• num  –要返回其绝对值的数字。该数字可以是：
  1. 整数
  2. 浮点数
  3. 复数

例子

# random integer
integer = -20
print('Absolute value of -20 is:', abs(integer))
 
#random floating number
floating = -30.33
print('Absolute value of -30.33 is:', abs(floating))

输出

-20的绝对值是：20 -30.33的绝对值是：30.33

Python all（）函数：

定义

当给定的iterable中的所有元素均为true时，all（）方法将返回True。如果不是，则返回False。

句法

all（）方法的语法为：

全部（可迭代）

参数

all（）方法采用一个参数：

• 可迭代 –包含元素的任何可迭代（列表， 元组， 字典等）

例子

# all values true
l = [1, 3, 4, 5]
print(all(l))
 
# all values false
l = [0, False]
print(all(l))
 
# one false value
l = [1, 3, 4, 0]
print(all(l))
 
# one true value
l = [0, False, 5]
print(all(l))
 
# empty iterable
l = []
print(all(l))

输出

真
假
假
假
真

Python ascii（）函数：

定义

ascii（）方法返回一个字符串，其中包含对象的可打印表示形式。它使用x，u或U转义符转义字符串中的非ASCII字符。

句法

ascii（）方法的语法为：

ascii（对象）

参数

ascii（）方法采用一个对象（如 字符串， 列表 等）。

例子

normalText = 'Python is interesting'
print(ascii(normalText))
 
otherText = 'Pythön is interesting'
print(ascii(otherText))
 
print('Pythn is interesting')

输出

“ Python很有趣” 
“ Pythn很有趣” 
Pythön很有趣

Python bin（）函数：

定义

bin（）方法转换并返回给定整数的等效二进制字符串。如果参数不是整数，则必须实现__index __（）方法以返回整数。

句法

bin（）方法的语法为：

bin（数字）

参数

bin（）方法采用一个参数：

• num  –要计算其二进制当量的整数。
  如果不是整数，则应实现返回整数的方法。 __index__() 

例子

number = 5
print('The binary equivalent of 5 is:', bin(number))

输出

5的二进制等效项是：0b101

bool（[值]）

test = []
print(test,'is',bool(test))
 
test = [0]
print(test,'is',bool(test))
 
test = 0.0
print(test,'is',bool(test))
 
test = None
print(test,'is',bool(test))
 
test = True
print(test,'is',bool(test))
 
test = 'Easy string'
print(test,'is',bool(test))

[]是False 
[0]是True 
0.0是False 
None是False 
True是True 
Easy字符串是True

Python compile（）函数：

定义

compile（）方法从源返回Python代码对象（正常字符串，字节字符串或AST对象）。

句法

compile（）方法的语法为：

编译（源，文件名，模式，标志= 0，dont_inherit = False，优化= -1）

参数

• source –普通字符串，字节字符串或AST对象
• filename –从中读取代码的文件。如果不是从文件中读取，则可以自己命名
• mode –或或。 exec  eval  single
  • eval –仅接受单个表达式。
  • exec –它可能需要一个包含Python语句，类和函数等的代码块。
  • single –如果它包含单个交互式语句
• flags （可选）和（可选）–控制将来的哪些语句会影响源代码的编译。默认值：0 dont_inherit 
• optimize （可选）–编译器的优化级别。默认值-1。

例子

codeInString = 'a = 5
b=6
sum=a+b
print("sum =",sum)'
codeObejct = compile(codeInString, 'sumstring', 'exec')
 
exec(codeObejct)

输出

总和= 11

Python dict（）函数：

定义

句法

dict（）构造函数的不同形式是：

class dict（** kwarg）
class dict（mapping，** kwarg）
class dict（iterable，** kwarg）

例子

numbers = dict(x=5, y=0)
print('numbers = ',numbers)
print(type(numbers))
 
empty = dict()
print('empty = ',empty)
print(type(empty))

输出

空= dict（）
打印（'空='，空）
打印（类型（空））

Python enumerate（）函数：

定义

enumerate（）方法向可迭代对象添加计数器，然后将其返回（枚举对象）。

句法

enumerate（）方法的语法为：

枚举（可迭代，开始= 0）

参数

enumerate（）方法采用两个参数：

• 可迭代 –支持迭代的序列，迭代器或对象
• start （可选）– enumerate（）从该数字开始计数。如果省略开始，则将0作为开始。  

例子

grocery = ['bread', 'milk', 'butter']
enumerateGrocery = enumerate(grocery)
 
print(type(enumerateGrocery))
 
# converting to list
print(list(enumerateGrocery))
 
# changing the default counter
enumerateGrocery = enumerate(grocery, 10)
print(list(enumerateGrocery))

输出

<class'enumerate'> 
[[0，'面包'），（1，'牛奶'），（2，'黄油'）] 
[（10，'面包'），（11，'牛奶'），（12 ， '黄油'）]

Python eval（）函数：

定义

eval（）方法解析传递给此方法的表达式，并在程序中运行python表达式（代码）。

句法

eval（）方法的语法为：

eval（表达式，全局变量=无，本地变量=无）

参数

eval（）具有三个参数：

• 表达式 –该字符串被解析并评估为Python表达式
• 全局变量 （可选）–字典
• locals （可选）-映射对象。字典是Python中标准且常用的映射类型。

例子

x = 1
print(eval('x + 1'))

输出

总和= 11

Python filter（）函数：

定义

filter（）方法从可迭代的元素构造一个迭代器，函数针对该迭代器返回true。

句法

filter（）方法的语法为：

过滤器（函数，可迭代）

参数

filter（）方法采用两个参数：

• 函数 –测试可迭代元素是否返回true或false
  的函数如果为None，则该函数默认为Identity函数–如果任何元素为false则返回false
• 可迭代 –要过滤的可迭代，可以是 集合， 列表， 元组或任何迭代器的容器

例子

# list of alphabets
alphabets = ['a', 'b', 'd', 'e', 'i', 'j', 'o']
 
# function that filters vowels
def filterVowels(alphabet):
    vowels = ['a', 'e', 'i', 'o', 'u']
 
    if(alphabet in vowels):
        return True
    else:
        return False
 
filteredVowels = filter(filterVowels, alphabets)
 
print('The filtered vowels are:')
for vowel in filteredVowels:
    print(vowel)

输出

过滤后的元音为：
a 
e 
i 
o

Python getattr（）函数：

定义

getattr（）方法返回对象的命名属性的值。如果找不到，它将返回提供给该函数的默认值。

句法

getattr（）方法的语法为：

getattr（object，name [，默认]）

参数

getattr（）方法采用多个参数：

• 对象 –要返回其命名属性值的对象
• name  –包含属性名称的字符串
• 默认值（可选）  –找不到命名属性时返回的值

例子

class Person:
    age = 23
    name = "Adam"
 
person = Person()
print('The age is:', getattr(person, "age"))
print('The age is:', person.age)

输出

年龄是：23
年龄是：23

Python help（）函数：

定义

help（）方法的语法为：

帮助（对象）

参数

help（）方法最多使用一个参数。

• 对象 （可选）–您要生成给定的帮助 object

例子

>>> help('print')

Python id（）函数：

定义

句法

id（）方法的语法为：

id（对象）

参数

id（）函数采用单个参数object。 

例子

class Foo:
    b = 5
 
dummyFoo = Foo()
print('id of dummyFoo =',id(dummyFoo))

输出

dummyFoo的ID = 140343867415240

Python len（）函数：

定义

句法

len（）方法的语法为：

镜片）

参数

s  –序列（字符串，字节，元组，列表或范围）或集合（字典，集合或冻结集合）

例子

testList = []
print(testList, 'length is', len(testList))
 
testList = [1, 2, 3]
print(testList, 'length is', len(testList))
 
testTuple = (1, 2, 3)
print(testTuple, 'length is', len(testTuple))
 
testRange = range(1, 10)
print('Length of', testRange, 'is', len(testRange))

输出

[]长度为0 
[1、2、3]长度为3 
（1、2、3）长度为3 
range（1，10 ）的长度为9

Python max（）函数：

定义

句法

max（）方法的语法为：

max（iterable，* iterables [，key，default]）
max（arg1，arg2，* args [，key]）

参数

max（）有两种形式的参数可以使用。

1. max(iterable, *iterables[, key, default])
   • 可迭代 –序列（元组， 字符串），集合（集合， 字典）或要查找其最大元素的迭代器对象
   • * iterables（可选）  –数量最多的可迭代对象
   • key（可选）  –传递可迭代对象并根据其返回值执行比较的键函数
   • 默认值（可选）  –如果给定的iterable为空，则为默认值
2. max(arg1, arg2, *args[, key])
   • arg1  –强制比较的第一个对象（可以是数字，字符串或其他对象）
   • arg2  –用于比较的必需第二个对象（可以是数字，字符串或其他对象）
   • * args（可选）  –其他要比较的对象
   • key  –传递每个参数并根据其返回值执行比较的键函数

例子

# using max(arg1, arg2, *args)
print('Maximum is:', max(1, 3, 2, 5, 4))
 
# using max(iterable)
num = [1, 3, 2, 8, 5, 10, 6]
print('Maximum is:', max(num))

输出

最大值为：5
最大值为：10

Python min（）函数：

定义

min（）方法的语法为：

min（iterable，* iterables [，key，默认]）
min（arg1，arg2，* args [，key]）

参数

min（）有两种形式的参数可以使用。

1. min(iterable, *iterables[, key, default])
   • 可迭代 –序列（元组， 字符串），集合（集合， 字典）或一个迭代器对象，其最小元素将被找到
   • * iterables（可选）  –数量最小的可迭代项
   • key（可选）  –传递可迭代对象并根据其返回值执行比较的键函数
   • 默认值（可选）  –如果给定的iterable为空，则为默认值
2. min(arg1, arg2, *args[, key])
   • arg1  –强制比较的第一个对象（可以是数字，字符串或其他对象）
   • arg2  –用于比较的必需第二个对象（可以是数字，字符串或其他对象）
   • * args（可选）  –其他要比较的对象
   • key  –传递每个参数并根据其返回值执行比较的键函数

例子

# using min(arg1, arg2, *args)
print('Minimum is:', min(1, 3, 2, 5, 4))
 
# using min(iterable)
num = [3, 2, 8, 5, 10, 6]
print('Minimum is:', min(num))

输出

最小值为：1
最小值为：2

Python oct（）函数：

定义

oct（）方法的语法为：

oct（x）

参数

oct（）方法采用单个参数 x。

该参数可以是：

• 整数（二进制，十进制或十六进制）
• 如果不是整数，则必须实现返回整数的方法 __index__() 

例子

# decimal number
print('oct(10) is:', oct(10))
 
# binary number
print('oct(0b101) is:', oct(0b101))
 
# hexadecimal number
print('oct(0XA) is:', oct(0XA))

输出

oct（10）是：0o12 
oct（0b101）是：0o5 
oct（0XA）是：0o12

Python pow（）函数：

定义

pow（）方法的语法为：

pow（x，y [，z]）

参数

pow（）方法采用三个参数：

• x  –要供电的数字
• y  –用x供电的数字
• z（可选）  –用于模运算的数字

例子

# positive x, positive y (x**y)
print(pow(2, 2))
 
# negative x, positive y
print(pow(-2, 2))
 
# positive x, negative y (x**-y)
print(pow(2, -2))
 
# negative x, negative y
print(pow(-2, -2))

输出

4
4
0.25
0.25

Python reversed（）函数：

定义

反转（seq）

参数

reversed（）方法采用一个参数：

• seq  –应该反转的序列
  可能是支持序列协议（__len __（）和__getitem __（）方法）为 元组， 字符串， 列表 或 范围
  的对象可能是已实现__reversed __（）的对象

例子

# for string
seqString = 'Python'
print(list(reversed(seqString)))
 
# for tuple
seqTuple = ('P', 'y', 't', 'h', 'o', 'n')
print(list(reversed(seqTuple)))
 
# for range
seqRange = range(5, 9)
print(list(reversed(seqRange)))
 
# for list
seqList = [1, 2, 4, 3, 5]
print(list(reversed(seqList)))

输出

['n'，'o'，'h'，'t'，'y'，'P'] 
['n'，'o'，'h'，'t'，'y'，'P'] 
[8、7、6、5] 
[5、3、4、2、1]

Python sum（）函数：

定义

总和（可迭代，开始）

参数

• 可迭代 –可迭代（列表，元组，字典等），其项的总和将被找到。通常，可迭代项应为数字。
• 开始 （可选）–此值被添加到可迭代项的总和中。start的默认值为0（如果省略）  

例子

numbers = [2.5, 3, 4, -5]
 
# start parameter is not provided
numbersSum = sum(numbers)
print(numbersSum)
 
# start = 10
numbersSum = sum(numbers, 10)
print(numbersSum)

输出

4.5
14.5

Python type（）函数：

定义

类型（对象）
类型（名称，基数，字典）

参数

• 如果将单个 对象 参数传递给type（），则它将返回给定对象的类型。

例子

numberList = [1, 2]
print(type(numberList))
 
numberDict = {1: 'one', 2: 'two'}
print(type(numberDict))
 
class Foo:
    a = 0
 
InstanceOfFoo = Foo()
print(type(InstanceOfFoo))

输出

<class'dict'> 
<class'Foo'>

接下来在这个Python Functions博客上，让我们看看Python中的递归函数。

Python递归函数

什么是Python中的递归？

递归是根据自身定义某些内容的过程。

一个物理世界的例子是放置两个相互面对的平行反射镜。它们之间的任何对象都将递归地反映出来。

Python递归函数

我们知道在Python中，一个 函数 可以调用其他函数。函数甚至可能会自行调用。这些类型的构造称为递归函数。

以下是查找整数的阶乘的递归函数的示例。

数字的阶乘是从1到该数字的所有整数的乘积。例如，阶乘5（表示为5！）为1 * 2 * 3 * 4 * 5 = 120。

例子：

# An example of a recursive function to
# find the factorial of a number
 
def calc_factorial(x):
    <em>"""This is a recursive function
    to find the factorial of an integer"""
 
    </em>if x == 1:
        return 1
    else:
        return (x * calc_factorial(x-1))
 
num = 4
print("The factorial of", num, "is", calc_factorial(num))

在上面的示例中，calc_factorial（） 是一个递归函数，因为它调用了它自己。 

当我们使用正整数调用此函数时，它将通过减少数量来递归调用自身。

每个函数调用将数字乘以1的阶乘，直到数字等于1。

当数字减少到1时，递归结束。这称为基本条件。每个递归函数必须具有停止递归的基本条件，否则该函数将无限调用自身。

递归的优点

1. 递归函数使代码看起来干净整洁。
2. 可以使用递归将复杂的任务分解为更简单的子问题。
3. 递归序列生成比使用嵌套嵌套迭代更容易。

递归的缺点

1. 有时，递归背后的逻辑很难遵循。
2. 递归调用很昂贵（效率低​​），因为它们占用大量内存和时间。
3. 递归函数很难调试。

接下来在这个Python函数博客上，让我们看看Python中的Lambda函数。

Python Lambda函数

什么是Lambda函数？

在Python中，匿名函数是没有名称定义的 函数 。

虽然通常的功能是使用关键字定义的，但在Python中，匿名功能是使用关键字定义的。 def  lambda 

因此，匿名函数也称为lambda函数。

如何在Python中使用Lambda函数？

python中的Lambda函数具有以下语法：

lambda参数：表达式

Lambda函数可以具有任意数量的参数，但只能有一个表达式。该表达式将被求值并返回。Lambda函数可在需要函数对象的任何地方使用。

例子

# Program to show the use of lambda functions
 
double = lambda x: x * 2
 
# Output: 10
print(double(5))

输出

10

在[1]中：

在上面的程序中，是Lambda函数。这里X是参数，是被评估，返回的表达。 lambda x: x * 2    x * 2 

此功能没有名称。它返回一个分配给标识符的函数对象，double我们现在可以将其称为普通函数。该声明

double = lambda x：x * 2

几乎与

def double（x）：
   返回x * 2

接下来在这个Python Functions博客上，让我们看看如何在Python中使用用户定义的函数

Python用户定义函数

Python中用户定义的函数是什么？

我们将自己定义为执行某些特定任务的功能称为用户定义功能。我们 已经讨论了在Python中定义和调用函数的方式。

Python附带的函数称为内置函数。如果我们使用他人以库的形式编写的函数，则可以将其称为库函数。

我们自己编写的所有其他函数都属于用户定义的函数。因此，我们的用户定义函数可能是其他人的库函数。

用户定义功能的优点

1. 用户定义的函数有助于将大型程序分解为小段，从而使程序易于理解，维护和调试。
2. 如果程序中出现重复的代码。该函数可用于包含这些代码，并在需要时通过调用该函数执行。
3. 从事大型项目的程序员可以通过执行不同的功能来划分工作量。

句法

def function_name（argument1，arguments2，...）：
      statement_1 
      statement_2 
      ....

例子

# Program to illustrate
# the use of user-defined functions
 
def add_numbers(x,y):
   sum = x + y
   return sum
 
num1 = 5
num2 = 6
 
print("The sum is", add_numbers(num1, num2))

输出

输入一个数字：2.4
输入另一个数字：6.5
总和为8.9

接下来在这个Python Functions博客上，让我们看看如何使用Python创建一个简单的应用程序。

使用Python程序创建一个简单的计算器应用程序

在此示例中，您将学习创建一个简单的计算器，该计算器可以根据用户的输入进行加，减，乘或除。

代码

# Program make a simple calculator that can add, subtract, multiply and divide using functions
 
# This function adds two numbers 
def add(x, y):
   return x + y
 
# This function subtracts two numbers 
def subtract(x, y):
   return x - y
 
# This function multiplies two numbers
def multiply(x, y):
   return x * y
 
# This function divides two numbers
def divide(x, y):
   return x / y
 
print("Select operation.")
print("1.Add")
print("2.Subtract")
print("3.Multiply")
print("4.Divide")
 
# Take input from the user 
choice = input("Enter choice(1/2/3/4):")
 
num1 = int(input("Enter first number: "))
num2 = int(input("Enter second number: "))
 
if choice == '1':
   print(num1,"+",num2,"=", add(num1,num2))
 
elif choice == '2':
   print(num1,"-",num2,"=", subtract(num1,num2))
 
elif choice == '3':
   print(num1,"*",num2,"=", multiply(num1,num2))
 
elif choice == '4':
   print(num1,"/",num2,"=", divide(num1,num2))
else:
   print("Invalid input")

输出

选择操作。
1.增加
2.Subtract 
3.Multiply 
4.Divide
输入选择（1/2/3/4）：3
输入第一数目：15
输入第二个数字：14 
15 * 14 = 210

在此程序中，我们要求用户选择所需的操作。选项1、2、3和4有效。取两个数字，并使用一个 if...elif...else 分支来执行特定的部分。用户定义的函数 add()，  subtract()， multiply() 和 divide() 评估各自的操作。 

结论

本教程中讨论的概念应通过向Python添加功能和可操作性来帮助您使用Python构建自己的函数。

当您尝试通过简化过程并使其适合您的个人需求来创建应用程序时，这将非常方便。现在，您还应该能够直接在Python的帮助下使用这些Python函数轻松地开发应用程序。

在阅读了有关Python函数的博客之后，我很确定您想了解有关Python的更多信息。要了解有关Python的更多信息，可以参考以下博客：

1. Python教程–适用于初学者的Python编程
2. 数据科学用Python
3. 为什么要学习Python的十大理由
4. Python请求教程