💝💝💝欢迎来到我的博客，很高兴能够在这里和您见面！希望您在这里可以感受到一份轻松愉快的氛围，不仅可以获得有趣的内容和知识，也可以畅所欲言、分享您的想法和见解。
推荐:Linux运维老纪的首页,持续学习,不断总结,共同进步,活到老学到老
导航剑指大厂系列:全面总结 运维核心技术:系统基础、数据库、网路技术、系统安全、自动化运维、容器技术、监控工具、脚本编程、云服务等。
常用运维工具系列:常用的运维开发工具, zabbix、nagios、docker、k8s、puppet、ansible等
数据库系列:详细总结了常用数据库 mysql、Redis、MongoDB、oracle 技术点,以及工作中遇到的 mysql 问题等
懒人运维系列:总结好用的命令,解放双手不香吗?能用一个命令完成绝不用两个操作
数据结构与算法系列:总结数据结构和算法,不同类型针对性训练,提升编程思维,剑指大厂
非常期待和您一起在这个小小的网络世界里共同探索、学习和成长。💝💝💝 ✨✨ 欢迎订阅本专栏 ✨✨
开发基础之
Python 函数
技能目标
- 掌握自定义函数
- 理解变量作用域
- 掌握 lambda 函数
- 掌握 Python 内建函数
3.1 函数
函数是一段可以重复使用的代码，通过传递的参数返回不同的结果，前面章节已经使用
了 Python 定义的函数如 range()、len()、input()等，本章讲解用户自定义的函数。
对于重复使用的代码，可以编写为自定义函数以便于重复使用代码，同时提高开发人员
的开发效率。函数可以分为无参函数和带参函数。
3.1.1 无参函数
Python 的自定义无参函数并不复杂，语法格式如下。
语法：
def 函数名称():
代码块
return [表达式]
以关键字 def 开始，后面跟函数名、小括号、冒号，最后使用 return 退出函数。用表达
式可以传递函数的返回值，如果没有返回值，则返回 None。
函数是以字母、数字和下划线组成的字符串，但是不能以数字开头。
无参函数的调用语法如下。
语法：
[变量] = 函数名称()
使用赋值运算符“=”可以获得函数的返回值，使用函数时必须先定义再调用，否则程序
会出现错误。
示例 1：使用无参函数实现两数相加并输出二者之和。
示例代码如下：
def add():
#定义函数
op1 = 10
op2 = 20
rt = op1+op2
print (op1,'+',op2,'=',rt)
return
add()
#调用函数
>>>
10 + 20 = 30
#输出结果
首先定义了无参函数 add()，它输出 10+20 的结果值，return 没有返回值，直接使用函
数名 add()进行了调用。
把上面的代码进行修改，用 return 返回结果值，代码如下：
def add():
op1 = 10
op2 = 20
rt = op1+op2
return rt
i = add()
#函数返回值赋值给 i
print ('结果是:',i)
>>>
结果是: 30
#输出结果
函数 add()使用 return 语句可以返回两数相加的结果值，变量 i 接收函数 add()返回的值。
Python 在处理返回值时，如果没有 return 语句，会默认返回 None，程序并不会报错。
示例 2：输出九九乘法表
示例代码如下：
def nineMultiTab():
#函数定义
op1 = (1,2,3,4,5,6,7,8,9)
op2 = (1,2,3,4,5,6,7,8,9)
for i in op1:
for j in op2:
print (i,"*", j,"=",i*j)
return
nineMultiTab()
#函数调用
定义函数 nineMultiTab()，用嵌套的 for 循环输出乘法表，最后返回空值。示例 2 中，
直接通过函数名调用和执行 nineMultiTab()，不需要用变量接收。
使用函数时经常会范围一些错误，总结如下：
函数的定义要先于函数的调用，否则会出错。
函数体的代码是一个整体，要注意缩进。
定义函数时要使用冒号，但调用时不可以使用冒号。
前面讲到函数是一段重复使用的代码，它也可以使程序的设计条理更加清晰、结构简单
易懂。下面对上一章使用菜单进行注册和登录的示例进行修改，首先是把 N、E 的功能编写
为函数，代码如下。
示例 3：定义并调用函数，实现用户登录功能。
kgc = {}
def newuser():
#注册新用户函数
prompt1 = 'login desired:'
while True:
name = input(prompt1)
if name in kgc:
prompt1 ='--name taken,try another:'
continue
else:
break
pwd = input('password:')
kgc[name] = pwd
def olduser():
#登录函数
name = input('login:')
pwd = input('password:')
password = kgc.get(name)
if password == pwd:
print ('--welcome back--',name)
else:
print ('--login incorrect--')
字符 N、E 对应的功能分别使用函数 newuser()和 olduser()实现，再就整个程序代码定
义为一个新的函数 showmenu()。在 showmenu()中分别调用这两个函数，代码如下：
def showmenu():
#定义菜单函数
prompt = '''
(N)ew User Login
(E)ntering User Login
(Q)uit
Enter choice:'''
while True:
choice = input(prompt).strip()[0].lower()
print ('\n--You picked : [%s]' % choice)
if choice not in 'neq':
print ('--invalid option,try again--')
else:
if choice=='n':
newuser()
#调用函数 newuser()
elif choice=='e':
olduser()
#调用函数 olduser()
else :
print ('quit')
break
此时，修改后的代码结构清晰易懂，只需要调用菜单函数 showmenu()就可以执行程
序 。整体代码如下：
kgc = {}
def newuser():
#注册
prompt1 = 'login desired:'
while True:
name = input(prompt1)
if name in kgc:
prompt1 ='--name taken,try another:'
continue
else:
break
pwd = input('password:')
kgc[name] = pwd
def olduser():
#登录
name = input('login:')
pwd = input('password:')
password = kgc.get(name)
if password == pwd:
print ('--welcome back--',name)
else:
print ('--login incorrect--')
def showmenu():
#菜单
prompt = '''
(N)ew User Login
(E)ntering User Login
(Q)uit
Enter choice:'''
while True:
choice = input(prompt).strip()[0].lower()
print ('\n--You picked : [%s]' % choice)
if choice not in 'neq':
print ('--invalid option,try again--')
else:
if choice=='n':
newuser()
elif choice=='e':
olduser()
else :
print ('quit')
break
if __name__ == '__main__':
# 程序入口
showmenu()
代码的最后使用“if __name__ == '__main__' :”作为一个判断，决定是否要执行函数
showmenu()，这和直接使用 showmenu()有什么不同呢？当直接执行这段代码时，Python
的内置变量__name__的值是”__main__”。如果是其它函数引用到这段代码，__name__的
值就会不同，也就是 showmenu()不会被执行，后面的章节会再介绍它的用法。
3.1.2 带参函数
Python 带参函数的语法格式如下。
语法：
def 函数名称（形式参数列表）:
代码块
return [表达式]
通过语法可以看出，带参函数与无参函数的区别是在函数名称后面的小括号中有形式参
数列表，简称形参列表。注意：形式参数列表实际上只是占位符，用于体现参数的个数，每
个参数都没有提供具体的数值。
带参函数的调用语法如下。
语法：
[变量] = 函数名称(实际参数列表)
调用带参函数时，需要为每个参数传递对应的实际数值，又称实参列表。示例 4 是完
成加法运算的函数代码。
示例 4：定义并调用带参函数完成两数相加的运算。
def add(x,y):
#带参函数定义
return x + y
print (add(1,2))
#带参函数调用
>>>
3
#结果
示例 4 中，定义的函数 add()有 2 个形式参数 x 和 y。在函数的语句块中，形式参数 x
和 y 的用法与变量很相似的。通过函数名 add()传入实际参数的值 1 和 2 进行调用执行，执
行后函数的返回值是 3。
上面定义的形式参数是普通的参数，又称为位置参数。当调用函数时，根据传递的实
际参数值出现位置与函数定义的形式参数列表进行匹配。
示例 5：使用位置参数方式或关键字参数方式调用带参函数。
示例代码如下：
def aa(x,y):
print (x,y)
aa(10,6)
aa(6,10)
>>>
10 6
#结果
6 10
#结果
在函数 aa(x,y)中，输出 x 和 y 值，x 在前面，y 在后面。调用 aa(10,6)时，x 的值是 10，
y 的值是 6。调用 aa(6,10)时，x 的值是 6，y 的值是 10。所以，两次调用函数 aa()得到的
输出结果是不同的。
当程序代码比较繁琐时，参数的顺序很难记住，可以使用关键字参数。关键字参数是在
调用函数时，明确指定参数值赋给指定的形参，语法格式如下。
语法：
函数名称（形参 1=实参 1，形参 2=实参 2，…）
示例代码如下：
def aa(x,y):
print (x,y)
aa(x=10,y=6)
aa(y=6,x=10)
>>>
10 6
#结果
10 6
#结果
代码中，aa(x=10,y=6)和 aa(y=6,x=10)语句在调用函数 aa(x,y)的同时，指定了参数的
名称和对应值(x=10,y=6)和(y=6,x=10)。这两个语句明确指定了实参和形参的对应关系，与
参数所在的位置无关，所以输出结果是相同的。
调用带参函数时，传入函数的参数个数必须和声明的参数个数一致。当函数包含有多个
参数时，一旦实参个数与形参个数不符，就可能出错。为了避免这样的错误发生，Python
在函数定义时允许为形式参数指定默认值，从而在调用参数时可以少写参数，省略的参数用
默认值为其赋值。
下面是使用参数默认值的代码示例：
def aa(x,y=6):
print (x,y)
aa(10)
aa(x=10)
aa(10,5)
aa(x=10,y=5)
>>>
10 6
#结果
10 6
#结果
10 5
#结果
10 5
#结果
函数定义时，参数 y 的默认值是 6。函数调用时，可以不传递 y 的值，只传递 x 的值。
直接传值或使用参数名并赋值的方式都可以，aa(10)和 aa(x=10)的结果是相同的。当传递 y
的值是 5 时，此时 y 的默认值不起作用，所以 aa(10,5)和 aa(x=10,y=5)输出时 y 的值都是 5。
定义参数默认值时，要注意：位置参数必须出现在有默认值参数之前。下面的函数定义
是错误的。
def aa(x=1,y):
print (x,y)
上面的代码中，位置参数 y 出现在有默认值的参数 x=1 的后面，此时，会产生语法错
误。
下面通过示例 6 加深对带参函数的理解。
示例 6：编码实现计算器功能
要求：用户输入两个数字和运算符，程序根据用户指定的运算符执行加、减、乘、除运
算。为了使程序结构清晰，需要编写 2 个函数，一个是用来处理加减乘除运算，一个是用
来处理字符串和数值转换。实现步骤如下：
（1）定义处理运算的函数 operator(op1,op2,opFu)，示例代码如下：
def operator(op1,op2,opFu):
1
if opFu not in '+-*/':
return -1
2
if opFu == '+':
result = op1+op2
elif opFu == '-':
result = op1-op2
elif opFu == '*':
result = op1*op2
elif opFu == '/':
3
if op2 == 0:
print ('错误，除数不能为 0！ /n')
result = None
else:
result = op1 / op2
return result
函数 operator(op1,op2,opFu)中，参数 op1 表示运算符前面的操作数，op2 表示运算
符后面的操作数，opFu 表示运算符。在代码的位置 1 处，判断 opFu 是不是“+-*/”运算符中
的一个。如果不是，返回值是-1，表示程序出错。位置 2 处，判断 opFu 如果是“+”，则进行
加法运算；否则向下依次判断 opFu 是否是“-“、 “*“或 “/“，这些运算的处理方式与“+”相同。
注意：在位置 3 处，当进行除法运算时，如果除数是 0 时，在数学上是没有意义的。需要
使用 if 语句判断 op2 的值是否等于 0。如果等于 0，需要做特殊的处理，返回的结果是 None
表示程序错误。在函数的最后，通过 return 语句返回运算结果。
（2）用户由键盘输入的是字符串类型，而程序是计算数值的运算，需要将字符串转为
数值型，所以，定义函数 convert(op)给予实现，示例代码如下：
def convert(op):
1
flag = True
2
for ch in op:
if ch not in '1234567890':
flag = False
break
3
if flag == True:
return int(op)
4
else:
return None
位置 1 处定义了一个布尔型变量 flag，用于判断数值的有效性。位置 2 处，对传入的字
符串类型的参数 op，使用 for 循环判断它的每一个字符是否在“1234567890”中。如果有一
个字符不在其中，就说明这个字符串不能转换为数值，flag 的值为 False，退出循环；否则
flag 的值不变，还是 True，说明字符串可以转换为数值型。位置 3 作了相应的判断，把参
数 op 转换为了整型，使用的是 int()函数。位置 4 表示如果参数 op 不能转为整型，返回的
是 None。
（3）定义了上面的 2 个函数后，开始编写程序的主体代码了。按数学运算的正常顺序
编写程序，由键盘输入第 1 个数值，然后输入运算符，最后再输入第 2 个数值，计算输出
结果。示例代码如下：
if __name__ == '__main__':
1
str1 = '请输入第 1 个数：\n'
strFu = '请输入一个算术运算符：\n'
str2 = '请输入第 2 个数：\n'
2
while True:
print ('需要退出程序，请输入字母 q')
3
opp1 = input(str1)
ch = opp1.strip()[0].lower()
if ch =='q':
break
4
op1 = convert(opp1)
#数值 1
if op1 == None:
print ('输入错误，请输入整数!/n')
continue
5
while True:
opFu= input(strFu)
#运算符
if opFu in '+-*/':
break
else:
print ('运算符输入错误')
continue
6
while True:
op2 = convert(input(str2))
#数值 2
if op2 == None:
print ("输入错误，请输入整数!\n")
continue
else:
break
7
result = operator(op1,op2,opFu)
if result != None:
print ("计算%d %s %d = %d\'n" %(op1,opFu,op2,result))
print ('程序退出了')
位置 1 定义了键盘输入 3 个字符串的提示文字。位置 2 是主体代码的无限循环操作，
可以进行多次计算操作。位置 3 是接受键盘输入，使用 if 语句判断如果输入字符是”q”时，
退出位置 2 的循环，结束程序的运行。位置 4 对输入的第一个字符串进行数据类型转换操
作，如果 convert()返回是 None 说明不能进行数据类型的转换，使用 continue 语句开始下
一次循环，即重新输入数据。位置 5 是循环接受键盘输入的运算符，如果是“+-*/”中的某一
个运算符，则使用 break 语句，结束位置 5 的循环，执行位置 6 的代码；如果不是“+-*/”中
的运算符，则执行 continue 语句，重新执行位置 5 的下一次循环，再次接收键盘输入的运
算符。位置 6 是输入第 2 个数值，同样需要做数据类型的转换操作，如果不能转换就需要
重新键盘输入。位置 7 是调用运算函数 operator()执行运算，如果 result 不等于 None，说
明运算是正常的，显示出运行的结果。
最终的示例 6 程序运行结果如下：>>>
需要退出程序，请输入字母 q
请输入第 1 个数：
11
请输入一个算术运算符：
*
请输入第 2 个数：
2
计算 11 * 2 = 22
需要退出程序，请输入字母 q
请输入第 1 个数：
q
程序退出了
输入第 1 个数是 11，运算符为*，第 2 个数是 2，程序的运行结果是输出 22。输入字符
“q”时，程序退出。程序运行中，如果输入错误的数据，程序会提示相应的错误信息，读者
可以自己动手进行尝试。
3.2 变量作用域
作用域是指变量在程序中的应用范围，而变量声明的位置决定它的作用域。Python 按
作用域区分有局部变量和全局变量。
全局变量是指在一个模块中最高级别的变量有全局作用域，除非被删除，否则存活到程
序运行结束，所有函数都能访问全局变量。
局部变量是指定义在函数内的变量有局部作用域，依赖于定义变量的函数现阶段是否处
于活动状态。调用函数时，局部变量产生，暂时存在。一旦函数执行完，局部变量将会被释
放。
局部变量的作用域仅限于定义它的函数，全局变量的作用域在整个模块内部都是可见
的。在同一个函数中，不允许有同名局部变量。在不同的函数中，可以有同名局部变量。在
同一个程序中，全局变量和局部变量同名时，局部变量具有更高的优先级。
下面通过代码演示局部变量和全局变量的使用情况。
示例 7：使用函数实现年龄的输出。
def addAge(age):
age += 1
#局部变量 age
print ('addAge(): _age=%d age=%d' %(_age,age)) #访问全局变量_age 和局部变量 age
return age
_age = int(input('输入年龄: \n'))
#全局变量_age
rt = addAge(_age)
print ('main(): _age =%d ' %_age)
print ('main(): rt=%d' %rt)
//结果
>>>
输入年龄:
11
addAge(): _age=11 age=12
main(): _age =11
main(): rt=12
在函数 addAge(age)中定义了局部变量 age，在全局范围定义了全局变量_age。_age
的值是由键盘输入，程序运行中，可被访问，直至程序结束，所以在 addAge(age)函数的代
码中也可以访问对它。当键盘输入是 11 时，_age 的值是 11，调用”rt=addAge(_age)”，把
全局变量_age 的值 11 传给了函数，此时 addAge（age)的局部变量 age 的值也是 11。执
行“age+=1”后，age 值变为 12，而全局变量_age 的值不发生变化，函数的返回值 age 的值
是 12，函数返回值通过“=”被变量 rt 接收，所以打印“_age=11 rt=12“。
在 Python 中尽量不使用全局变量，因为程序的任意代码都可以自由地访问和修改全局
变量的值，非常容易出现数据被意外修改的错误，而这种错误很难被发现。
局部变量只有在局部中才能使用，其他范围是访问不到的，如 age 是局部变量，在全
局范围就引用不到,比如在程序最后加上代码：
//省略内容
print 'main(): age=%d' %age
//结果>>>
Traceback (most recent call last):
File "D:\pythonTest\7\7-5.py", line 10, in <module>
print 'main(): age=%d' %age
NameError: name 'age' is not defined
从程序执行的结果，可以看到输出信息是“name 'age' is not defined”，说明在全局范围
内访问不到变量 age。这个问题可以使用 global 关键字解决，global 的作用是声明变量为全
局变量，即使变量定义在函数内部，加上 global 后，也可以在全局范围访问。
示例代码如下：
def addAge(num):
global age
age = num+1
print ('addAge(): _age=%d age=%d' %(_age,age))
return age
_age = int(input('输入年龄: \n'))
rt = addAge(_age)
print ('main(): _age =%d ' %_age)
print ('main(): rt=%d' %rt)
print ('main(): age=%d' %age)
//结果
>>>
输入年龄:
11
addAge(): _age=11 age=12
main(): _age =11
main(): rt=12
main(): age=12
对程序做了一些调整，在 addAge()代码中使用关键字 global 定义变量 age。这样，在
程序的任意位置都可以使用使用全局变量 age。
注意：在函数中，使用关键字 global 声明的全局变量名不能与其中的局部变量重名。
凡事都有两面性，使用关键字 global 定义的全局变量可以在程序的任意位置被修改数值，
所以要尽量避免在函数中使用 global 定义全局变量，减少程序的不可预知性。
3.3 lambda 函数
lambda 函数的作用是创建匿名函数，是一种声明函数的特殊方式。
lambda 函数的语法。
语法：
lambda params:expr
其中 params 相当于函数接收的参数列表，expr 是函数返回值的表达式。
示例 8：编写一个普通函数和一个 lambda 函数。
示例代码如下：
def sum1(x,y):
#普通函数
return x+y
sum2 = lambda x,y : x+y
#lambda 函数
print (sum1(3,4))
#调用执行普通函数
print (sum2(3,4))
#调用执行 lambda 函数
//结果
>>>
7
7
实现的是相同的功能，但 lambda 函数更加简洁，只需一条语句实现，所以 lambda 也
称为 lambda 表达式。使用 lambda 只能是表达式，不能包含 if、for 等条件循环语句。对于
不需要复用、简单的匿名函数，使用 lambda 能起到很好的效果。
3.4 内建函数
Python 除了本身的语法结构，还提供了常用的内建函数。内建函数是程序员经常使用到的方法，可以提高程序的编写效率。如 float()就是内建的函数。内建函数是自动加载的，
Python 的解释器可以识别。它不需要导入模块，不必做任何的操作，不需要引用就可以调
用 。下面开始介绍常用的内建函数。
1. abs()函数
abs()函数能够返回一个数字的绝对值，即正数。语法格式如下。
语法：
abs（x）
参数 x 可以是正数，也可以是负数，示例 9 代码如下：
>>> abs(10)
10
>>> abs(-10)
10
>>> bb = -3
>>> abs(bb)
3
参数是 10 或-10，返回的是绝对值，结果都是 10.
2. bool()函数
bool()函数返回值是 True 或 False，它是 Boolean（布尔值）的简写，语法格式如下。
语法：
bool( [ x ] )
将参数 x 转换为 Boolean 类型，当参数是数字时，0 返回 False，其他任何值都返回 True。
参数是字符串时，None 或空字符串返回 False；否则返回 True。参数是空的列表、元组或
字典返回 False；否则返回 True。
示例 10 代码如下：
>>> bool()
#无参时返回 False
False
>>> bool(0)
False
>>> bool(-3)
True
>>> bool(None)
False
>>> bool('')
False
>>> bool('xyz')
True
>>> bool([11,22])
True
3. float()函数
float()函数用于转换数据为 float 类型，语法格式如下。
语法：
float（[ x ]）
参数 x 可以是字符串或数字，示例 11 代码如下：
>>> float('25')
25.0
>>> float(3)
3.0
>>> float(999.586103)
999.586103
>>> float('999.586103')
999.586103
字符串和数字都可以转为 float 类型。如果不能转换，就会抛出异常。
4. int()
int()函数可以将数据转换为整数，语法结构如下。
语法：
int （[ x [，base]]）
第一个参数 x 是浮点数时，小数后面的数据将会丢失。
第二个参数是进制，默认为十进制。
如果参数是含有浮点数的字符串，将会产生语法错误。示例 12 代码如下：
>>> int(199.99)
#浮点数
199
>>> int('100')
#字符串
100
>>> int('99.9')
#字符串
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '99.9'
注意：当参数是字符串时，字符串中只能是整数格式。如果是浮点格式将有异常产生。
5. range()
range()函数可以生成一个迭代对象，语法结构如下。
语法：
range（[start],stop[,step]）
第一个参数 start 表示起始值，是可选参数，默认值是 0。
第二个参数 stop 表示终止值。
第三个参数表示步长，是可选参数，可以是正数或负数，默认值是 1。
从给定的第一个参数开始，到比第二个参数值小 1 的数字结束，常与 for 循环一起使用，
循环执行指定数字的次数。示例 13 代码如下：
>>> range(0,5)
range(0,5)
>>> list(range(0,5))
[0, 1, 2, 3, 4]
>>> range(0,30,3)
range(0,30,3)
>>> list(range(30,0,-3))
[30, 27, 24, 21, 18, 15, 12, 9, 6, 3]
>>> for i in range(0,5):
print (i)
0
1
2
3
4
6. sum()函数
sum()函数可以对列表中元素求和，语法结构如下。
语法：
sum（x[ ，start]）
第一个参数 x 是迭代器。
第二个参数是步长，是可选参数，默认值是 1。
示例 14 代码如下：
>>> num = list(range(0,500,50))
>>> num
[0, 50, 100, 150, 200, 250, 300, 350, 400, 450]
>>> print ((sum(num)))
2250使用 range()生成了一个列表，然后使用 sum()对列表中的数值进行累加求和。
7. max()函数
max()函数可以返回列表、元组或字符串中最大的元素，语法结构如下。
语法：
max（x）
如果元素是英文字母，那么字母是“大于”数字的，而小写字母“大于”大写字母，示例 15
代码如下：
>>> num = [6,2,12,7,65]
>>> max(num)
65
>>> string = 'd,u,a,n,g,D,U,A,N,G'
>>> max(string)
'u'
>>> max(1000,650,98,2678,9)
2678
8. min()函数
min()函数返回列表、元组、或字符串中最小的元素，语法结构如下。
语法：
min（x）
与 max()的使用方式相反，它取的是最小值，示例 16 代码如下：
>>> min([6,2,12,7,65])
2
9. dir()函数
dir()函数是 directory 的简写，可以返回关于任何值的相关信息，它可以用于任何对象，
包括字符串、数字、函数、模块、对象和类。当想要快速查找帮助信息时非常有用。语法格
式如下。
语法：
dir( [ object ] )
object 是可选参数，无参时返回当前范围内的变量、方法、和定义的类型列表。带参时
返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含
__dir__()，该方法将最大限度地收集参数信息。示例 17 代码如下：
>>> dir()
#获得当前模块的属性列表
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__',
'_age', 'addAge', 'age', 'bb', 'ch', 'convert', 'i', 'num', 'op1', 'op2', 'opFu', 'operator', 'opp1', 'result',
'rt', 'str1', 'str2', 'strFu', 'string', 'sum1', 'sum2']
>>> dir([])
#查看列表的方法
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__',
'__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__',
'__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__',
'__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__',
'__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy',
'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
10. eval()函数
eval()函数是 evaluate 的简写，可以计算表达式的值。语法格式如下。
语法：
eval（expression [，globals [，locals]]）
第一个参数 expression 只能是简单的表达式。一般情况下，对拆分成多行的表达式不
能运算，常用于把用户输入转换成 Python 表达式。示例 18 代码如下：
>>> eval('100*9')
900
>>> eval(input("请输入表达式："))
请输入表达式：8+9*2-3
23
eval()函数把字符串“100*9”解析成为了一个表达式，进行相应的计算，获得结果。
11. exec()函数
exec()函数可以运行较复杂的程序，与 eval()函数功能相近。二者的区别是 exec()没有
返回值，eval()有一个返回值。语法格式如下。
语法：
exec( object [ , globals [,locals]])
参数 object 只能是简单的表达式，一般对拆分成多行的表达式不能运算，常用于将用
户输入转换成 Python 表达式。示例 19 代码如下：
>>> exec('print("Hello World")')
#单行语句字符串
Hello World
>>> program = '''print('WoW')
#输出内容的多行字符串
print('duang')'''
>>> exec(program)
WoW
duang
定义单行、多行字符串或输出内容的打印字符串，都可以由 exec()函数执行，它与直接
执行 Python 的语句作用是相同的。
12. len()函数
len()函数返回一个对象的长度，语法格式如下。
语法：
len（s）
参数 s 是一个序列或字符串。示例 20 代码如下：
>>> len('duang')
#字符串
5
>>> language = ['python','java','c#','vb']
#列表
>>> len(language)
4
>>> person = {'张三':'100',"李四":'99',"王五":'88'}
#字典
>>> len(person)
3
对于字符串，len()是返回字符串的字符个数，元组、列表和字典返回的是元素的个数。