python函数基础

python函数基础

1.函数的定义

函数就是对代码进行一个封装。把实现，某一功能的相同代码，进行封装到一起。下次需要使用时，就不需要再进行代码编写，直接调用即可。
好处:
增加代码的复用性，增加代码可读性，减少代码的编写量，降低维护成本 
函数可以看成，解决某类问题的 '工具'
定义方法：
def function_name(a)：
    print(a)

2.python中函数的参数详解

1.必备参数：参数没有默认值
2.默认参数：参数有默认值，调用函数是可以传参也可以不传参，不传参时，参数是默认值
3.不定长参数： 可在定义时定义，也可在传入时传入
    定义方法： def function_name(*args,**kwargs):
    *args 将传入参数包装成元组
    **kwargs将传入参数包装成字典

3.return

return有两个作用：
1.用来返回函数的运行结果，或者调用另外一个函数。比如max()函数
2.函数结束的标志。只要运行了return，就强制结束了函数。return后面的程序都不会被执行。           
如果函数中没有写return，其实函数运行结束时，默认执行了 return None
return语句的位置是可选的，不是固定出现再函数的最后，可以自定义在函数中的任何地方。                 

4.lambda匿名函数

没有函数名的函数
g = lambda x:x+1
lambda简化了函数定义的书写形式。是代码更为简洁，但是使用函数的定义方式更为直观，易理解 
lambda的应用场景：
1.有些函数如果只是临时一用，而且它的业务逻辑也很简单时，就没必要用def 来定义，这个时候就可以用lambda。
2.函数都支持函数作为参数，lambda 函数就可以应用

练习与总结：

###函数基础

def iterfun(a):
     for i in a:
          print(i)
iterfun([1,2,3,4])      
#函数的定义  命名：驼峰规则

##参数形式
#1不传参
def fun1():
     print('不能传参数')
fun1()
#2必备参数
def fun2(a):
     print('必须传参数:',a)
fun2(2)
#3默认参数
def fun3(b=2):
     print('默认参数：',b)  #可传可不传
fun3(b=3)
fun3()
#可选参数
def fun4(*arg):  
     print('可传0个到多个：',arg)#可传0个到多个 包装成元组
#fun4(*[1,2])    加个* ，就把里面的壳去掉（解包）
fun4(1,2)
fun4(*[1,2])
#关键字参数
def fun5(a,b):    #定义的时候是跟必备参数一样的
     print(a,b)   #必须放到最后
fun5(a=1,b=2)
fun5(1,2)
def fun6(**kwarg):
     print('关键字参数',kwarg)# 可传0个到多个 包装成字典
fun6(a=1,b=2)  #遵循变量命名规则
fun6(**{'a':1})   #必须是字符串
##参数混合的时候   关键字参数放最后 根据定义的顺序 确保必备参数只能拿到值，并且只能一个
#必备参数+默认参数
def fun7(a,b=1):   #默认参数必须在必备参数的后面
     print(a,b)

def fun8(b,m=1,*a):
     print(b)
     print(m)
     print(a)

def fun8(*a,b,m):
     print(a,b,m)
     print(b)

def fun9(*a,b,m=1):
     print(a,b,m)
     print(b)

###      return的作用  用来返回函数的运行结果

def fun13(a,b):
    if a>b:
        return a

a=fun13(2,1) #  a=2

def fun11(a,b):
    if a>b:
        print(a)
b=fun11(2,1)   #b=none
print(b)
def fun10(a,b):
     #return('我不下去了')  #函数结束的标志 可以放在任何地方
     if a>b:
          print(a)
          return('我不下去了')  #函数结束的标志
fun10(2,1)
def fun12(a,b):
     #return('我不下去了')  #函数结束的标志 可以放在任何地方
     if a>b:
          print(a)
          #return('我不下去了')  #函数结束的标志
##lambda  匿名函数

def fun0(x):
     return(x+1) 
fun0(5)
g = lambda x,y:x*y
#g 跟fun0 都是函数体  调用需加（）
#  ：后面的相当于return
print(g(1,2))

输出结果：

==========
1
2
3
4
不能传参数
必须传参数: 2
默认参数： 3
默认参数： 2
可传0个到多个： (1, 2)
可传0个到多个： (1, 2)
1 2
1 2
关键字参数 {'a': 1, 'b': 2}
关键字参数 {'a': 1}
2
None
2
2
>>> 

问题解答：

#1.找到1-100内的质数，用while和for来做，结束之后打印“搜索结束”.
#(质数：只能被1和自己整除，如2，只有除以1和2才能整除)
#解答：
from math import sqrt
def BuildPrime(n):
    cnt = 0
    print('1-100内的素数是：')
    for i in range(2,n+1):
        ok =True
        k = int(sqrt(i + 1))  
        for j in range(2,k+1):
            if (i%j == 0):
                ok = False
                break
        if ok:
            cnt += 1
            print('%2d'%i,end=' ')
    print('\n搜索结束！！！！\n')
def BuildPrime1(n):
    print('1-100内的素数是：')
    i=2
    while i<(n+1):
        for j in range(2,i):
            if (i%j == 0):
                break
        else:
            print('%2d'%i,end=' ')
        i+=1
    print('\n搜索结束！！！！\n')
#函数调用
BuildPrime(100)
BuildPrime1(100)
#判断一个数是不是质数
def IsPrime(n):
    k = int(sqrt(n + 1))  
    for j in range(2,k+1):
        if (n%j == 0):
            return False
    return True
def show():
    while True:
        a = input('请输入一个数整数：\n')
        if a.isdigit():
            a = int(a)
            if IsPrime(a):
                print('%d是质数!!!'%a)
            else:
                print('%d不是质数!!!'%a)

        else:
                print('不是整数请重新输入-----')
        if input('任意键继续|退出请按q:!!!!\n') =='q':
            print('判断完毕！！')
            break
##函数调用        
show()
#2.定义一个函数，能够输入字典和元组。将字典的值(value) 和 元组的值交换，交换结束后，打印并且返回 字典和元祖。
#解答：
def exchange(*args,**kwargs):
    tu = list(args)
    dic = kwargs
    print(tu,dic)
    j=0 #元组的索引值
    if len(dic) <= len(tu): # 字典len小于或者等于tu时
        for i in dic: # 遍历字典的key（键）–》i
            print(i,dic[i],tu[j])
            dic[i],tu[j] = tu[j],dic[i]
            j+=1
        for k in range(j,len(tu)):
            dic.setdefault(tu[k],'')
    else: #当字典元素多于元组时
        k=0
        while k < len(tu):
            for i in dic:
                dic[i],tu[k] = tu[k],dic[i]
            k+=1
    tu = tuple(tu)
    print(tu,dic)
exchange(1,2,3,4,5,6,a=111,b=222,c=333,d=444)
exchange(1,2,3,a=111,b=222,c=333,d=444)
#3.定义一个函数，必须包含4种参数形式，然后打印这4个参数，最后返回'OK'。
#解答：
def fun(a,*b,c=1,**d):
    print(a)
    print(b)
    print(c)
    print(d)
    return 'OK'
show = fun(1,*[1,2,3],c=2,**{'key':123})
print(show)
def fun1(*args,b,m=2,**kwargs):
    print('必备参数',b)
    print('默认参数',m)
    print('arg:',args)
    print('kwargs:',kwargs)
    return 'OK'
fun1(1,2,3,4,5,m=6,b=7,c=1)

输出结果：

1-100内的素数是：
 2  3  5  7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 
搜索结束！！！！

请输入一个数整数：
3
3是质数!!!
任意键继续|退出请按q:!!!!

请输入一个数整数：
6
6不是质数!!!
任意键继续|退出请按q:!!!!

请输入一个数整数：
97
97是质数!!!
任意键继续|退出请按q:!!!!

请输入一个数整数：
73
73是质数!!!
任意键继续|退出请按q:!!!!

请输入一个数整数：
8
8不是质数!!!
任意键继续|退出请按q:!!!!
q
判断完毕！！
[1, 2, 3, 4, 5, 6] {'a': 111, 'b': 222, 'c': 333, 'd': 444}
a 111 1
b 222 2
c 333 3
d 444 4
(111, 222, 333, 444, 5, 6) {'a': 1, 'b': 2, 'c': 3, 'd': 4, 5: '', 6: ''}
[1, 2, 3] {'a': 111, 'b': 222, 'c': 333, 'd': 444}
a 111 1
b 222 111
c 333 222
d 444 333
a 1 2
b 111 1
c 222 111
d 333 222
a 2 3
b 1 2
c 111 1
d 222 111
(444, 333, 222) {'a': 3, 'b': 2, 'c': 1, 'd': 111}
1
(1, 2, 3)
2
{'key': 123}
OK
必备参数 7
默认参数 6
arg: (1, 2, 3, 4, 5)
kwargs: {'c': 1}
>>>