Python语法进阶——函数

Python程序不需要主函数也可以执行。

一、内置函数

不需要使用前缀就可以使用的函数。

数据类型转换函数、数学函数、迭代器操作函数以及其他函数。

一、数据类型转换函数

dict(sequence)将续了转换成字典类型。

二、常用的数学函数

round()只有一个参数，四舍五入保留到整数

三、常用的迭代器操作函数

all() 迭代器对象中的元素都为True时，才为True

any()迭代器对象中的元素有一歌True时，就为True

注意，reversed()、zip()、enumerate()、filter()、map()返回的都是迭代器对象，需要转换成序列类型才能看到值。

lst=[54,56,77,4,567,34]
#(1)
asc_lst=sorted(lst)
desc_lst=sorted(lst,reverse=True)
#(2)
new_lst=reversed(lst)#返回迭代器对象
print(type(new_lst))
print(list(new_lst))
#(3)zip
x=['a','b','c','d']
y=[10,20,30,40,50]
zip_obj=zip(x,y)#返回迭代器对象
print(type(zip_obj))
#print(dict(zip_obj))
'''

[34, 567, 4, 77, 56, 54]

{'a': 10, 'b': 20, 'c': 30, 'd': 40}
'''
#(4)enumerate
enum=enumerate(y,1)
print(type(enum))
#(5)all、any
lst2=[1,2,3,'',50]
print(all(lst2))
print(any(lst2))
#(6)next 一个一个取，取了就没了
print(next(zip_obj))
print(next(zip_obj))
print(next(zip_obj))
'''
('a', 10)
('b', 20)
('c', 30)
'''

#filter和map的第一个参数都是函数，可以是内置函数，也可以是自定义函数
def fun(num):
    return num%2==1

#按照指定条件筛选，True的留下
obj=filter(fun,range(10))  #将range(10)产生的序列0~9的整数,每个整数都执行一次fun操作
print(list(obj))



def upper(x):
    return x.upper()
new_lst2=['hello','world','co']
obj2=map(upper,new_lst2)
print(list(obj2))
#map的引入可以让序列中的每一个元素都执行同一个操作。  好像对字典没啥用

四、其他内置函数

dir(obj) 获取对象的所有方法和属性。

print(format(3.14,'20'))#数值型默认右对齐
print(format('Yorelee','20'))#字符串默认左对齐
print(format('Yorelee','*>20'))#*填充符，<是左对齐，>是右对齐，^是居中对齐，20是宽度
print(format('Yorelee','*^20'))
'''
                3.14
Yorelee             
*************Yorelee
******Yorelee*******
'''

print(format(3.178,'.2f'))
print(format(20,'b'))#二进制
print(format(20,'o'))#八进制
print(format(20,'x'))#十六机制 也可以是大写'X'
'''
3.18
10100
24
14
'''

二、函数的定义

def 函数名(参数列表):
    函数体
    [return 返回值]#return可以没有

①在Python3.11中引入了一个新特性，函数被调用的位置和次数，可以在函数名上看到n usages并且可以找到位置。

②按住ctrl点击调用时的函数名，可以找到函数的定义处。点击变量名也能找到其定义处，以及调用处。（点击定义的名就是显示调用处，点击调用的名跳转到定义处。）

一、函数的参数传递

（1）位置参数：

就是那种普普通通的函数定义，对于参数名，没有指定类型，也没有其他限定。那么在传入时必须传递的实参个数和形参个数一样，由于没有指定参数的类型，按理来说任何类型的参数都能传进去，虽然传参可能成功，但是在函数体中运用该类型时把它当做了某个类型处理，可能导致其他类型传入报错。

def Happy_Birthday(name,age):
    print('祝'+name+age+'岁生日快乐')#函数体要求传入的两个参数都得是字符串类型

Happy_Birthday('Yorelee','21')
Happy_Birthday('Yorelee',21)#参数类型不对报错
Happy_Birthday('Yorelee')#参数不够报错

（2）关键字参数

传递实参时，可以将形参名显示写出来指明赋值给哪个形参。

①此时实参顺序可以和形参不一样。

②但是每个形参只能显示传递一次。

③并且使用关键字参数时 也可以使用位置传参，但是必须位置参数在前，关键字参数在后。并且位置参数必须和形参一一对应，只有后面的关键字参数可以不对应。

def Happy_Birthday(name,age):
    print('祝'+name+age+'岁生日快乐')#函数体要求传入的两个参数都得是字符串类型

Happy_Birthday(age='Yorelee',name='21')
Happy_Birthday('Yorelee',age='21')#right!
#Happy_Birthday(name='Yorelee',21')#wrong!
#Happy_Birthday(age='Yorelee',name='21',name='21')#wrong!


def happy_birthday(name,age,date):
    print('祝'+name+age+'岁生日快乐--->'+date)#函数体要求传入的两个参数都得是字符串类型

happy_birthday('Yorelee',date='2024.01.06',age='21') #right

（3）默认值参数

如果传递了值，用传递的值，如果没有传递值则用默认值。

①没默认值的参数必须在前。

②在传参时没默认值的参数必须传参，也可以用关键字传参，前提是所有参数没有歧义的被赋值，比如全都有默认值，比如没有默认值的参数已经按位置传参传入了。

def Happy_Birthday(name='Yorelee',age='21'):
    print('祝'+name+age+'岁生日快乐')#函数体要求传入的两个参数都得是字符串类型

Happy_Birthday()
Happy_Birthday(age='22')

def happy_birthday(date,name='Yorelee',age='21'):
    print('祝'+name+age+'岁生日快乐--->'+date)#函数体要求传入的两个参数都得是字符串类型

happy_birthday('2024.11.25',age='22')

（4）可变参数

它的引入，导致其他参数必须是关键字参数，或者默认值参数。并且可变参数有且仅有一个。

①加一颗星的参数，参数类型为元组类型

可以为其传入一个元组类型的参数。

def fun(*para,name):
    print(type(para))
    for i in para:
        print(i,end='')
    print()

fun(1,2,3,4,5,8,7,name='yore')
fun(*[1,2,3,4,5,8,7],name='yore')
fun(*tuple([1,2,3,4,5,8,7]),name='yore')
fun(name='yore',*tuple([1,2,3,4,5,8,7]))#*号代表了这一串给para，这也是关键字参数
'''

1234587
'''
fun([1,2,3,4,5,8,7],name='yore')#该序列作为元组的一个元素传给para

②加两颗星的参数，参数类型为字典类型

def fun(**para):
    print(type(para))
    for key,value in para.items():
        print(key,value,end='')
    print()

fun(name=12,word=123,ass=4)
fun(**dict(name=12,wodr=123))
fun(**{'name':12,'word':123,'as':4})

二、函数的返回值

无返回值的函数，返回值默认是None

def Add(a,b):
    return a+b
print(Add(10,20))#输出：30

def Sub(a,b):
    return a,'-',b,'=',a-b
print(type(Sub(1,1))) #
t=Sub(20,10)
for i in t:
    print(i,end='')#20-10=10


def Get():
    return 1,2,3
a,b,c=Get()#将返回结果 解包赋值

三、在函数中定义全局变量

def fun():
    global s#在函数中定义了全局变量，这个声明和定义不能同时进行
    s=300
    return 0
print(s)

四、匿名函数lambda

r=lambda a,b,c:a*b*c
print(r(1,2,3)) 

lst=[
    {'name':'李泽滨','score':94.4}
    {'name':'何帧秩','score':97.9}
    {'name':'唐陆答','score':93.7}
    {'name':'郭雨豪','score':96.5}
]

lst.sort(key=lambda x:x.get('score'),reverse=True) #lst的元素作为实参传入，返回值作为排序值
print(lst)
#[{'name': '何帧秩', 'score': 97.9}, {'name': '郭雨豪', 'score': 96.5}, {'name': '李泽滨', 'score': 94.4}, {'name': '唐陆答', 'score': 93.7}]

五、递归函数

函数的递归调用~

def f(n):
    if(n==1 or n==2): return 1
    return f(n-1)+f(n-2)
print(f(5))