函数基础
函数就是一堆代码，然后使用的时候来调用这堆代码 不使用函数的缺点： 冗余，可读性差，维护性太差 把多行代码封装成一个整体（函数）
在python里面，使用关键字def 来声明一个函数
def 函数名（参数）：
函数要执行的操作
# 函数定义好了之后并不会自动执行，需要调用才会被执行
函数命名规范
- 函数名也是一个标识符
- 由数字、字符下划线组成，不能以数字开头，严格区分大小写，不能使用关键字
- 遵守命名规范，使用下划线连接，顾名思义
def tell_story():
print('春眠不觉晓')
print('处处闻啼鸟')
print('夜来风雨声')
print('花落知多少')
tell_story()
- 函数声明时，括号里的参数我们称之为形式参数，简称形参
- 形参的值是不确定的，只是用来占位的
def hello(person1,person2):
print(person1 + '对' + person2 + '说："hello！"')
# 调用函数时传递数据
# 函数调用时传入的参数，才是真正参与运算的数据，我们称之为实参，
hello('张三',"李四") # 会把实参一一对应的传递，交给形参处理
# 还可以通过定义变量名的形式给形参赋值
hello(person1="李四",person2="张三")
函数的返回值
函数的返回值就是函数执行的结果，并不是所有的函数都必须要有返回值
def add(a,b):
c = a + b # 变量c在外部是不可见的，只能在函数内部使用
return c # return 表示一个函数的执行结果
# 获取到add函数的结果，然后再求结果的4次方
result = add(1,2)
print(result ** 4)
# print 就是一个内置函数
x = print("hello")
print(x) #None
函数的注释
def add(a,b):
"""
这个函数用来将两个数字相加
"""
return a + b
print(add(1,3))
help(add) #
def add(a:int,b:int): #函数不限制参数类型，只给参数建议类型
return a + b
z = add('hello','world' )
print(z)
函数调用函数
def test1():
print('test1开始了')
print('test1结束了')
def test2():
print('test2开始了')
test1()
print('test2结束了')
test2()
- 定义函数求[n,m]直接所有整数之和
def add(n,m):
x = 0
for i in range(n,m):
x += i
return x
result = add(0,101)
print(result)
- 求一个N的阶乘
def fac(n):
x = 1
for i in range(1,n+1):
x *= i
return x
print(fac(5))
- 计算m阶乘的和 m = 6 ==> 1!+2!+3!+4!+5!+6!
# def fac_sum(m):
# x = 0
# y = 1
# for i in range(1,m+1):
# y *= i
# x += y
# return x
# print(fac_sum(5))
def fac_sum(m):
x = 0
for i in range(1,m+1):
x += fac(i)
return x
print(fac_sum(5))
默认参数的使用
def say_hello(name,age,city="北京"): # 缺省参数要写到最后，形参xity设置了一个默认值
print('大家好，我是{},我今年{}岁了，我来自{}'.format(name,age,city))
say_hello('jack',19) # 如果没有传递city的参数，使用默认值"北京"
say_hello(name = 'tony',age = 23)
# 如果有位置参数和关键字参数的话，关键字参数一定要放到位置参数的后面，
say_hello('jerry',age=24) # jerry要写到前面，不然报错
# 有些函数的参数是，如果你传递了参数就使用传递的参数，如果没有传递参数，就使用默认的值
# print函数里end就是一个缺省参数，
print('hello world',end="---")
print('hi')
print('hello','nihao',sep="****")
print('hjiijjk')
可变参数的使用
# *args 表示可变位置参数 ，最低需要两个参数，**kwargs 表示可变的关键字参数
def add(a,b,*args):
print('a = {},b = {}'.format(a,b))
print('args = {}'.format(args)) # 多出来的可变参数会以元组的形式保存到args里
c = a + b
for i in args:
c += i
return c
print(add(1,3,4,9,8,2))
def add(a,b,*args,mul = 1,**kwargs):
print(kwargs) #kwagrs是以字典的方式存放
add(1,2,3,4,5,c = 1,d = 2)
可变数据类型和不可变数据类型的传参
def test(a):
a = 100
def demo(nums):
nums[0] = 10
x = 1
test(x)
print(x)
y = [3,4,5,6,2]
demo(y)
print(y)
函数的注意事项
- 函数的三要素： 函数名，参数和返回值
- 在有一些编程语言里，允许函数重名，python里不允许函数的重名，如果函数重名了，后一个函数会覆盖前一个函数
- python里函数名也可以理解成为一个变量名
# def test(x): # test ==一个函数
# print('good,x={}'.format(x))
# test = 5 # 重新赋值5给test了
# test(3) # 5不能作为函数来调用
# TypeError: 'int' object is not callable
递归函数的使用
count = 0
def test():
print('test')
global count
count += 1
if count < 5:
test()
test()
- 求1~n的和
def get_num(n):
if n == 0:
return 0
return get_num(n-1) + n
print(get_num(6))
- 使用递归求n!
def fac(n):
if n == 1:
return 1
return fac(n - 1) * n
print(fac(6))
- 使用递归求斐波那契数列的第N个数字
def fib(n):
if n ==2 or n == 1:
return 1
return fib(n-1) + fib(n -2)
print(fib(4))
匿名函数
# 用lambda 关键词可以创建一个小型匿名函数，省去使用def声明函数的操作
#lambda函数的语法只包含一个语句，如下：
# lambda 参数列表：运算表达式
def add(a,b):
return a + b
x = add(4,5)
print(x)
fn = add # 相当于给函数起了一个别名
print(fn(6,5))
# 除了使用def关键字定义一个函数外，还能使用lambda表达式定义一个函数
lambda a,b : a + b #匿名函数，用来表达一个简单的函数，函数的调用次数很少，基本就是调用一次
# 调用匿名函数的两种方法：
# 给他定义一个名字,很少这样使用
# 把这个函数当做参数传给另一个函数来使用，这样的场景比较多
mul = lambda a,b : a + b
print(mul(4,5))
def calc(a,b,fn):
c = fn(a,b)
return c
def add(x,y):
return x + y
def minus(x,y):
return x - y
print(calc(5,6,add))
print(calc(10,5,minus))
x3 = calc(5,7,lambda x,y: x + y)
print(x3)
x3 = calc(5,7,lambda x,y: x * y)
print(x3)
x3 = calc(5,7,lambda x,y: x - y)
print(x3)
x3 = calc(5,7,lambda x,y: x / y)
print(x3)
