【Python基础】函数及常用的内置函数

本章目标

• 掌握函数的定义及调用
• 掌握函数的参数传递
• 掌握函数的返回值
• 掌握变量的作用域
• 熟悉匿名函数lambda的使用
• 熟悉常用的内置函数

一、函数的定义及调用

函数定义：
函数是将一段实现功能的完整代码，使用函数名进行封装，通过函数名称进行调用，以此达到一次编写，多次调用的目的。

内置函数：

• 输出函数print()
• 输入函数input()
• 列表定义函数list()

自定义函数：

def 函数名称(参数列表):
	函数体
	[return返回值列表]

函数调用：
函数名(参数列表)

实例代码：

def get_sum(num):
    s=0
    for i in range(1,num+1):
        s+=i
    print(f'1到{num}之间的累加和为:{s}')
#函数的调用
get_sum(10) #1-10之间的累加和
get_sum(100) #1-100之间的累加和
get_sum(1000) get_sum(100) #1-1000之间的累加和

函数的使用总结：

函数定义：

• 使用关键字def
• 确定函数名称、参数名称、参数个数、编写函数体（用于实现函数功能的代码）

函数调用：

• 通过函数名称进行调用函数
• 对函数的参数进行实际的赋值

函数执行：

• 使用实际函数参与函数功能的实现

函数返回结果：

• 函数执行结束后，如果使用 return 进行返回结果，则结果被返回到函数的调用处

二、函数的参数传递

位置参数：

• 是指调用时的参数个数和顺序必须与定义的参数个数和顺序相同

def happy_birthday(name,age):
    print('祝'+name+'生日快乐')
    print(str(age)+'生日快乐')
#调用函数
happy_birthday('cmm',20)

关键字参数：

• 是在调用时，使用 “形参名称=值” 的方式进行传参，传递参数顺序可以与定义时参数顺序不同
• 既有位置参数又有关键字参数传参，就要遵循 位置传参在前，关键字传参在后

def happy_birthday(name,age):
    print('祝'+name+'生日快乐')
    print(str(age)+'生日快乐')
#关键字传参
happy_birthday(age=18,name='cmm')
#happy_birthday(age=18,name1='cmm') #定义的形参为name TypeError: happy_birthday() got an unexpected keyword argument 'name1'

happy_birthday('cmm',age=18) #正常执行，位置传参，也可以使用关键字传参

#语法错误，违反了一个位置参数在前，关键字参数在后的一个规则
happy_birthday(name='cmm',18) SyntaxError: positional argument follows keyword argument

默认值参数：

• 是在函数定义时，直接对形式参数进行赋值，在调用时如果该参数不传值，将使用默认值，如果该参数传值，则使用传递的值
• 当位置参数和关键字值参数同时存在的时候，应该遵循 位置参数在前，默认值参数在后

def happy_birthday(name='cmm',age=18):
    print('祝'+name+'生日快乐')
    print(str(age)+'生日快乐')

#调用函数
happy_birthday() #不用传参，使用默认值参数
happy_birthday('章邯') #位置传参
happy_birthday(age=19) #关键字传参,name采用默认值

#当位置参数和关键字值参数同时存在的时候，应该遵循 位置参数在前，默认值参数在后
def fun(a,b=20): #a作为位置参数，b默认参数
    pass
#当位置参数和默认值参数同时存在的时候，位置参数在后会被报错
def fun2(a=20,b): #语法错误  SyntaxError: non-default argument follows default argument
    pass

可变参数：
可变参数又分为个数可变的位置参数和个数可变的关键字参数两种。

个数可变的位置参数：

• 个数可变的位置参数是在参数前加一颗星（*para），para形式参数的名称，函数调用时可接受任意个数的实际参数，并放到一个元组中。

#个数可变的位置参数
def fun(*para):
    print(type(para))
    for item in para:
        print(item)

#调用
fun(10,20,30,40)
fun(10)
fun(20,30)
fun([11,22,33,44])  #实际上传递的是一个参数。
#在调用时，参数前面加一颗星，会将列表进行解包
fun(*[11,22,33,44])

个数可变的关键字参数：

• 个数可变的关键字参数是在参数前加两颗星(**para),在函数调用时可接收任意多个 “参数=值” 形式的参数，并放到一个字典中。

#个数可变的关键字参数
def fun2(**kwpara):
    print(type(kwpara))
    for key,value in kwpara.items():
        print(key,'-------',value)

#调用
fun2(name='cmm',age=18,height=170)  #关键字参数
d={'name':'cmm','age':18,'height':170}
#fun2(d)   #TypeError: fun2() takes 0 positional arguments but 1 was given
fun2(**d)  #在调用时，参数前面加一颗星，会将列表进行解包

三、函数的反回值

返回值return：

• 如果函数的运行结果需要在其他函数中使用，那么这个函数就应该被定义为带返回值的函数。
• 函数的运行结果使用return关键字进行返回
• return可以出现在函数中的任意一个位置，用于结束函数。
• 返回值可以是一个值，或多个值，如果返回的值是多个，结果是一个元组类型。

def calc(a,b):
    print(a+b)
calc(10,20)
print(calc(1,2)) #没有定义返回值，则输出结果就是None

def calc2(a,b):
    s=a+b
    return s #将s返回给函数的调用去处理

print('-'*10)
get_s=calc2(1,2)
print(get_s)

#返回值可以是多个
def get_sum(num):
    s=0 #累加和
    odd_sum=0 #奇数和
    ever_sum=0 #偶数和
    for i in range(1,num+1):
        if i%2!=0: #说明是奇数
            odd_sum+=i
        else:
            ever_sum+=i
        s+=i
    return odd_sum,ever_sum,s  #返回三个值，返回值是一个元组
result=get_sum(10)
print(type(result))
print(result)

#解包赋值
a,b,c=get_sum(10)  #返回3个值，元组类型
print(a)
print(b)
print(c)

四、变量的作用域

变量的作用域是指变量起作用的范围，根据范围作用的大小可分为局部变量和全局变量

局部变量：

• 定义：在函数定义处的参数和函数内部定义的变量
• 作用范围：仅在函数内部，函数执行结束，局部变量的生命周期也结束

全局变量：

• 定义：在函数外定义的变量或函数内部使用global关键字修饰的变量
• 作用范围：整个程序，程序运行结束，全局变量的生命周期才结束

a=100 #全局变量
def calc(x,y):
    return a+x+y
print(a)
print(calc(10,20))
print('-'*40)

def calc2(x,y):
    a=200  #局部变量，局部变量的名称和全局变量的名称相同
    return a+x+y  #a是局部变量还是全局变量呢？ 当全局变量和局部变量的名称相同时，局部变量的优先级高。
print(calc2(10,20))

def calc3(x,y):
    global s #s是在函数中定义的变量，但是使用了global关键字声明，这个变量s变成了全局变量
    s=300 #声明和赋值，必须是分开执行
    return a+x+y
print(calc3(20,30))
print(s)  #全局变量

五、匿名函数lambda

• lambda: 是指没有名字的函数，这种函数只能使用一次，一般是在函数的函数体只有一句代码且只有一个返回值时，可以使用匿名函数来简化
• 语法结构：result = lambda 参数列表：表达式

def calc(a,b):
    return a+b
print(calc(10,20))

#匿名函数
s=lambda a,b:a+b #表示就是一个匿名函数
print(type(s))  #<class 'function'>
#调用匿名函数
print(s(10,20))
print('-'*40)

#列表的正常取值操作
lst=[10,20,30,40,50]
for i in range(len(lst)):
    print(lst[i])
print()
#匿名函数的列表取值
for i in range(len(lst)):
    result=lambda x:x[i]  #根据索引取值，result的类型是function, x是形式参数
    print(result(lst)) #lst是实际参数

student_scores=[
    {'name':'cmm','score':98},
    {'name':'wyy','score':95},
    {'name':'ztl','score':100},
    {'name':'bxr','score':60}
]
#对列表进行排序，排序的规则是字典中的成绩
student_scores.sort(key=lambda x:x.get('score'),reverse=True) #降序
print(student_scores)

递归函数：

递归:

• 在一个函数的函数体内调用该函数本身，该函数就是递归函数
• 一个完整的递归操作由两部分组成，一部分是递归调用，一部分是递归终止条件，一般可使用 if-else 结构来判断递归的调用和递归的终止。

使用递归计算N的阶乘：

def fac(n): #n的阶乘，N！=N*(n-1)!....1!=1
    if n==1:
        return 1
    else:
        return n*fac(n-1)  #自己调用自己
print(fac(5))  #5!=5*4*3*2*1=120

六、常用的内置函数

数据类型转换函数：

函数名称	描述说明
bool(obj)	获取指定对象obj的布尔值
str(obj)	将指定对象obj转换成字符串类型
int(x)	将x转成int类型
float(x)	将x转成float类型
list(sequence)	将序列转成列表类型
tuple(sequence)	将序列转成元组类型
set(sequence)	将序列转成集合类型

print('非空字符串的布尔值:',bool('hello'))
print('空字符串的布尔值:','') #空字符串不是空格字符串
print('空列表的布尔值:',bool([]))
print('空列表的布尔值:',bool())
print('空元组的布尔值:',bool(tuple()))
print('空集合的布尔值:',bool(set()))
print('空字典的布尔值:',bool({}))
print('空字典的布尔值:',bool(dict()))
print('-'*30)
print('非0整数型的布尔值:',bool(123))
print('整数0的布尔值:',bool(0))
print('浮点数0.0的布尔值:',bool(0.0))

#将其他类型转成字符串类型
lst=[10,20,30]
print(type(lst),lst)

s=str(lst)
print(type(s),s)

print('-'*20,'float类型和str类型转换成int类型','-'*20)
print(int(98.7)+int('90'))
#注意事项:
#print(int('98.7'))  #ValueError: invalid literal for int() with base 10: '98.7'

print('-'*20,'int,str类型转换成float类型','-'*20)
print(float(90)+float('3.14'))

s='hello'
print(list(s))

seq=range(1,10)
print(tuple(seq))
print(set(seq))
print(list(seq))

常用的数学函数：

函数名称	描述说明
abs(x)	获取x的绝对值
divmod(x,y)	获取x与y的商和余数
max(sequence)	获取sequence的最大值
min(sequence)	获取sequence的最小值
sum(iter)	对可迭代对象进行求和运算
pow(x,y)	获取x的y次幂
round(x,d)	对x进行保留d位小数，结果四舍五入

常用的迭代器操作函数：

函数名称	描述说明
sorted(iter)	对可迭代对像进行排序
reversed(sequence)	反转序列生成新的迭代器对象
zip(iter1,iter2)	将iter1与iter2打包成元组并返回一个可迭代的zip对象
enumerate(iter)	根据iter对象创建一个enumerate对象
all(iter)	判断可迭代对象iter中所有元素的布尔值是否都为True
any(iter)	判断可迭代对象的iter中所有元素的布尔值是否都为False
next(iter)	获取迭代器的下一个元素
filter(function,iter)	通过指定条件过滤序列并返回一个迭代器对象
map(function,iter)	通过函数function对可迭代对象iter的操作返回一个迭代器对象

lst=[54,56,77,45,67,34]
#(1)排序操作
asc_lst=sorted(lst)  #升序
desc_lst=sorted(lst,reverse=True)  #降序
print('原列表:',lst)
print('升序:',asc_lst)
print('降序:',desc_lst)

#(2)reversed 反向
new_lst=reversed(lst)
print(type(new_lst))   #<class 'list_reverseiterator'> 迭代器对象
print(list(new_lst))

#(3)zip
x=['a','b','c','d']
y=[10,20,30,40,50]
zipobj=zip(x,y)
print(type(zipobj))  #<class 'zip'>
print(list(zipobj))

#(4)enumeraete
enum=enumerate(y,start=1)
print(type(enum))  #<class 'enumerate'>
print(tuple(enum))

#(5)all
lst2=[10,10,'',30]
print(all(lst2))  #False,空字符串的布尔值是False
print(all(lst))  #True

#(6)any
print(any(lst2))  #True

#(7)
#print(next(zipobj))

def fun(num):
    return num%2==1  #可能是True,False
obj=filter(fun,range(10)) #将range(10),0-9的整数，都执行一次fun操作
print(list(obj))  # [1, 3, 5, 7, 9]

def upper(x):
    return x.upper()
new_lst2=['hello','world','python']
obj2=map(upper,new_lst2)
print(list(obj2))

常用的其他内置函数

函数名称	描述说明
format(value,format_apec	将value以format_space格式进行显示
len(s)	获取s的长度或s元素的个数
id(obj)	获取对象的内存地址
type(x)	获取x的数据类型
eval(s)	执行s这个字符串所代表的Python代码

#format()
print(format(3.14,'20')) #数值型默认右对齐
print(format('hello','20'))  #字符串默认左对齐
print(format('hello','*<20')) #<左对齐，*表示的填充符，20表示的是显示的宽度
print(format('hello','*>20'))
print(format('hello','*^20'))

print(format(3.1415926,'.2f'))  #3.14
print(format(20,'b'))
print(format(20,'o'))
print(format(20,'x'))
print(format(20,'X'))

print('-'*40)
print(len('helloworld'))
print(len([10,20,30,40,50]))

print('-'*40)
print(id(10))
print(id('helloworld'))
print(type('hello'),type(10))

print(eval('10+30'))
print(eval('10>30'))