调用python内置函数

• 函数名(参数) 即可调用python内置函数
• help(函数名) 返回python对于函数的帮助文件
• 函数别名
• 我们可以把一个变量指向一个函数，其意义就是给函数起了一个别名

>>>a=abs
>>>abs(-1)
>>>1
>>>a(-1)
>>>1

• 数据类型转换
• Python数据类型主要分为4类
  • 整数/浮点数/字符/布鲁尔
  • 转整数 ->int('123')->123 int('0xa',16)->10(16进制转10进制)
  • 转浮点数 ->float(12)->12.0
  • 转字符串 ->str(123)->'123'
    -转布鲁尔 ->bool(2)->'True' bool('')->'False'

定义函数

def my_abs(x):
    if x>=0:
        return x
    else：
        return -x
>>>my_abs(5)
>>>5
>>>my_abs(-2)
>>>2

• 定义的函数保存 放在 Lib\site-packages\mytest.py
  • from mytest import my_abs 即可直接调用我们自定义的函数
• 定义函数中 pass 即与 return 相反， 不返回任何值

def nop():
    pass#不返回任何值

• 定义函数的错误检查

def my_abs(x):
    if isinstance(x,(int,float)):#判断x是否为元组(int,float)的数据类型
        raise TypeError('bad operand type')# raise 引发TypeError
    if x>=0:
        return x
    else：
        return -x

• 调用函数返回多个值

def my_chiose(x,y):
    list1=[x,y]
    for ls in list1:
        if not isinstance(ls,(int,float)):
            raise TypeError('Bad operand Type')
    
    if x+y>=0:
        return x+y,'非负数'
    else:
        return x+y,'负数'
#返回结果是一个元组
>>>my_chiose(-1,0)
>>>(-1, '负数')
>>>my_chiose(1,0)
>>>1, '非负数')

函数参数

• 位置参数

def l(x,y):
    print(x,y)
>>>l(1,2)
>>>1,2

• 在位置参数中，调用函数需要在制定位置放入参数，不能省略
• 默认参数
  • 在默认参数中，给某个参数一个指定值，当调用函数的时候如果不给默认参数赋值，那么函数将使用默认参数的指定对象

def l(x,y=1):
    print(x,y)
>>>l(1)
>>>1,2
>>>l(1,3)
>>>1,3

• 如果默认参数指定的对象可变，在函数内部改变参数的指向对象时候，下一次调用默认参数的时候，默认参数会调用最新的对象

def l(l1=[]):
    l1.append('end')
>>>    return l1
>>>l
>>>('end')
>>>l
>>>('end','end')

• 可变参数
• 当参数数量不确定的时候，在参数前面加*号代表可变参数，可变参数的实质是一个元组,使用函数的时候在参数前面加上*,意思把参数作为可变参数传递给函数，而不是一个

def l(*z):
  return z
>>>l(1)
>>>(1,)
>>>l(1,2,3)
>>>(1,2,3)
#
>>>num=(1,2)
>>>l(num)
>>>((1,2),)
#
>>>l(*num)
>>>(1,2)

• 关键字参数
• 类似于可变参数，但是参数的实质是一个dict，可以接受多个参数，但是参数的形式需要写为 key=value,在使用函数的时候把dict加上**，意思把参数作为关键字参数传递给函数

def l(**z):
    return(z)
>>>l()
>>>{}
>>>l(a=1)
>>>{'a':1}
>>>l(a=1,b=2)
>>>{'a':1,'b':2}
>>>l(**{'a':1,'b':2})
>>>{'a':1,'b':2}

• 命名关键字参数
• 如果使用函数的的时候需要指定参数名就需要在参数前面加上*,如果有可变参数可以用可变参数代替*的位置

def l(x,*,y)
  print(x,y)
>>>l(1,2)
>>>TypeError: l() takes 1 positional argument but 2 were given
>>>l(1)
>>>TypeError: l() missing 1 required keyword-only argument: 'y'
>>>l(1,y=2)
>>>1,2
def l(x,*z,y)
  print(x,y=1)

• 组合参数
  • 顺序 必选参数，默认参数，可变参数(元组)，命名关键字参数，关键字参数{dict}

def l(a,b=1,*c,d,**e):
    return(a,b,c,d,e)
>>>l(2,d=3)
>>>(2, 1, (), 3, {})

递归函数

• 如果一个函数在内部调用自己本身，这个函数就是递归函数
• 例如:fact(n)=n!=1*2*3*1*……*n=fact
  (n-1)*n

def fact(n):
    if n==1:
        return 1
    else:
        return n*fact(n-1)

• 使用递归函数需要防止栈溢出，在递归的时候如果要完成当前结果，就需要调用下次结果才能实现，就会一直镶嵌调用，直到调用到最后一个不需要递归的时候，然后反向一层一层的反馈结果，返回包含表达式
  • 例如fact(5)=5*(4*(3*(2*fact(1))))
• 尾递归优化
  • 尾递归优化就是就是把return里面没有直接表达式，把计算放进函数的参数里面

def fact(n,rs=1):
    if n==1:
        return rs
    else:
        return fact(n-1,n*rs)```