6 python--函数

一、函数的作用

#1、代码的组织结构不清晰，可读性差
#2、遇到重复的功能只能重复编写实现代码，代码冗余
#3、功能需要扩展时，需要找出所有实现该功能的地方修改之，无法统一管理且维护难度极大

 

二、函数的定义

#语法
def 函数名(参数1,参数2,参数3,...):
'''注释'''
函数体
return 返回的值

#函数名要能反映其意义

三元表达式
x = 10
y = 2
if x > y:
    print(x)
else:
    print(y)

res = x if x>y else y  # if条件成立返回x，else 返回y ，可自定义返回值
print(res)

定义有参函数:函数的功能的执行依赖于外部传入的参数，有参函数通常需要返回值

def my_max(x,y):
    res =x if x>y else y
    print(res)

空函数
def auth():
    """认证"""
    pass
auth()

 

#函数的参数

函数的参数按照定义和传递的情况时分为形式参数和实际参数。
　　1、形式参数：在定义函数时，函数名后面括号中的变量名称叫做形式参数，或者成为形参。

　　应用场景：仅仅执行一些操作，比如用户交互，打印等
　　2、实际参数：在调用函数时，函数名后面括号中的变量名称叫做实际参数，或者成为实参。

　　应用场景：需要提供外部传递的参数，才能执行相应的逻辑，比如统计长度等

def foo(x,y):  #x=1,y=2
    print(x)
    print(y)

foo(1,2)

import random
def check(n):
    code = ''
    for i in range(n):
        num = random.randint(1,9)
        s = chr(random.randint(65,90))
        add = random.choice([num,s])
        code +=str(add)

return code

print(check(3))

def foo(x,y,z): #位置参数，必须被传值的参数
    print(x,y,z)

foo(1,22,3)

关键字参数需要注意的问题：
1关键字参数必须在位置实参后面
2不能重复对一个形参传值
foo(1,z=3,y=5) 正确
foo(x=1,3,z=8) 错误

foo(1,x=1,y=3,z=5)

默认参数
1 默认参数必须跟在非默认参数后
def register(name,age,sex='male'): #形参：默认参数
    print(name,age,sex)

register('alex','aa')
2 默认参数在定义阶段已经赋值，而且只在定义阶段赋值一次
a.xml =10000000
def foo(x,y=a.xml):
    print(x,y)

a.xml=0
foo(1)

3 默认参数的值通常定义成不可变类型

可变长参数
def foo(x,y,*args): # *会把溢出的按位置定义的实参都接收，以元组的形式赋值给args
    print(x,y)
    print(args)

foo(1,2,3,4,5)

def add(*args):
    res = 0
    for i in args:
        res +=i
    return res
print(add(1,2,3,4))
print(add(1,2,3))

def foo(x,y,**kwargs): # **会把溢出的按关键字定义的实参接收，以字典的形式赋值给kwargs
    print(x,y)
    print(kwargs)

foo(1,2,a.xml=1,age=18)

def foo(name,age,**kwargs):
    print(name,age)
    if 'sex' in kwargs:
        print(kwargs['sex'])
    if 'height' in kwargs:
        print(kwargs['height'])

foo('egon',18,sex='male',height='185')
foo('egon',18,sex='male')

命名关键字参数(了解)

def foo(name,age,*,sex='male',height):
    print(name,age)
    print(sex)
    print(height)
#*后定义的参数为命名关键字参数，这类参数，必须被传值，而且必须以关键字实参的形式去传值
foo('egon',17,height='185')

def foo(*args):
    print(args)

foo(*['A','B','C','D'])  #*把列表值取出来，作为位置参数

def foo(**kwargs):
    print(kwargs)

foo(**{'y':2,'x':1})  #=foo(y=2,x=1）




def foo(x,y,z):
    print(x,y,z)
#
# foo(**{'z':3,'x':1,'y':2}) #foo(x=1,y=2,z=3

def wrapper(*args,**kwargs): #可以接收任意形式的参数
    print(args) #args=(1,2,3)
    print(kwargs) #kwargs={'a.xml':1,'b':2}
    # foo(**args,**kwargs) #foo(*(1,2,3),**{'a.xml':1,'b':2})

wrapper(1,2,3,a=1,b=2)

#1、位置参数：按照从左到右的顺序定义的参数
        位置形参：必选参数
        位置实参：按照位置给形参传值

#2、关键字参数：按照key=value的形式定义的实参
        无需按照位置为形参传值
        注意的问题：
                1. 关键字实参必须在位置实参右面
                2. 对同一个形参不能重复传值

#3、默认参数：形参在定义时就已经为其赋值
        可以传值也可以不传值，经常需要变得参数定义成位置形参，变化较小的参数定义成默认参数（形参）
        注意的问题：
                1. 只在定义时赋值一次
                2. 默认参数的定义应该在位置形参右面
                3. 默认参数通常应该定义成不可变类型


#4、可变长参数：
        可变长指的是实参值的个数不固定
        而实参有按位置和按关键字两种形式定义，针对这两种形式的可变长，形参对应有两种解决方案来完整地存放它们，分别是*args，**kwargs

        ===========*args===========
        def foo(x,y,*args):
            print(x,y)
            print(args)
        foo(1,2,3,4,5)

        def foo(x,y,*args):
            print(x,y)
            print(args)
        foo(1,2,*[3,4,5])


        def foo(x,y,z):
            print(x,y,z)
        foo(*[1,2,3])

        ===========**kwargs===========
        def foo(x,y,**kwargs):
            print(x,y)
            print(kwargs)
        foo(1,y=2,a=1,b=2,c=3)

        def foo(x,y,**kwargs):
            print(x,y)
            print(kwargs)
        foo(1,y=2,**{'a':1,'b':2,'c':3})


        def foo(x,y,z):
            print(x,y,z)
        foo(**{'z':1,'x':2,'y':3})

        ===========*args+**kwargs===========

        def foo(x,y):
            print(x,y)

        def wrapper(*args,**kwargs):
            print('====>')
            foo(*args,**kwargs)

#5、命名关键字参数：*后定义的参数，必须被传值（有默认值的除外），且必须按照关键字实参的形式传递
可以保证，传入的参数中一定包含某些关键字
        def foo(x,y,*args,a=1,b,**kwargs):
            print(x,y)
            print(args)
            print(a)
            print(b)
            print(kwargs)

        foo(1,2,3,4,5,b=3,c=4,d=5)
        结果：
            2
            (3, 4, 5)
            3
            {'c': 4, 'd': 5}

此乃重点知识！！！

 

#函数的返回值

def foo():
    print('from foo')
    return None
res=foo()
print(res)

'''
以三种情况返回值都为None：
没有return
return 什么都不写
return None
'''

def foo():
    print('from foo')
    x=1
    return x
res=foo()
print(res)

# return 一个值  函数调用返回的结果就是这个值


def foo():
    print('from foo')
    x=1
    return 1,[2,3],(4,5),{}
# res=foo()
# print(res) #打印结果：(1,[2,3],(4,5),{})
# a,b,c,d=foo()
# print(d)



#return 值1,值2，值3,...   返回结果:(值1,值2，值3,...)

# t=(1,2,3)
# a,_,_=t
# print(a)

# t=(1,2,3,4,5,6,7,8,9)
# a,*_,c=t
# print(a)
# print(c)

#匿名函数，一些仅使用一次的函数可供使用

lambda x,y,z=1:x+y+z #与函数有相同的作用域，但是匿名意味着引用计数为0，使用一次就释放，除非让其有名字
func=lambda x,y,z=1:x+y+z 
func(1,2,3)

#内置函数

abs()  # 计算绝对值,abs(-10),接收number，返回一个number
  
max() # 求序列的的最大值（可迭代的），同时也可以比较一些数字
  
min() # 求序列的最小值（可迭代的），同时也可以比较一些数字
  
len() # 求序列的长度，（字典也可以，求index的个数）
  
divmod(x,y)    # 求x,y的商和余数，存放在元组中
  
pow(x,y,z) # 求x的y次方，如果有第三个参数，那么把前面的结果和第三个参数求余
  
round(number) # 用来四折五入，后面可以跟精度（先把number编程浮点数，然后看保留几位）把12.45转换成float，那么就不是12.45了，而可能是12.4999999了
  
callable() # 判断一个对象是否是可调用的，比如函数，类都是可以调用的，但是变量无法调用
  
type（） # 查看对象的类型
  
isinstance（对象，类型） # 判断一个对象是否是给定类型。类型可以是多个，只要是其中1个即可(类型1，类型2)
  
cmp（x,y） # 比较两个对象的大小，x大于y返回1，x等于y返回-1，x小于y返回-1，字符串也可以比较，是按单个字符的大小开始比对。
  
str() # 可以把任何数据转换成字符串（字典，元组，也会直接输出）
  
hex(10) # 把10进制转换为8进制
  
eval() # 把字符串当做一个有效的表达式来求值
# eval('1+2') 返回3
# eval("[1,2,3]") 返回[1,2,3]
  
oct() # 把10进制转换为8进制
  
chr(i) # i的范围是0~255，求i对应的acsii码值
  
ord(i） # i的范围是ascii的值，求对应的值
  
filter（函数或空，序列） # 用来过滤，把序列的每一个元素，交给函数来处理。如果为None，则什么也不做，直接输出（序列），如果有函数，那么只有函数的返回值为True才打印序列中的元素
例子：
def even(n):
    if n % 2 == 0:
        return True
    filter(even,xrange(10))
    [0, 2, 4, 6, 8]
高级写法：
    filter(lambda x: x%2 ==0,xrange(10)
  
zip(seq1，seq2,seqN...) # 把seq1和seq2组合成1个大的列表，每个序列取1个组成元组，存放在整合后的列表中，如果序列的长度不同，那么就以最小的序列的长度为基准。
  
map(func,seq1,seq2) # 返回也是一个列表，func可以是一个函数也可以是个None，如果为None，那么返回的列表长度以当前最长列表为基准，依旧是依次去每个列表中去取，只不过没有的，用none补充
例子：
l1 = [1, 2, 3]
l2 = ['a', 'b', 'c', 'd']
l3 = ['I', 'II', 'III', 'IV', 'V', 'VI']
map(None,l1,l2,l3)
[(1, 'a', 'I'),
(2, 'b', 'II'),
(3, 'c', 'III'),
(None, 'd', 'IV'),
(None, None, 'V'),
(None, None, 'VI')]
# 如果函数位上是一个函数，那么如果只有1列表，那么就需要这个函数定义1个参数，然后每次把列表中的1个元素交给函数进行处理，并打印，或者保存在迭代器中去
# 如果需要处理两个序列，那么函数就必须定义2个参数，去接受这两个序列的元素。
# 高级应用：
map(lambda x,y:x+y,l1,l4)
  
reduce(func,seq) # 只能定义1个序列，然后传递给func进行处理。（lambda函数求累加）