python笔记-函数
1、函数
- 使用关键字 def
- 确定函数名称、参数名称、参数个数、编写函数体（用于实现函数功能的代码）
- 通过函数名称进行调用函数
- 定义好函数之后，只表示这个函数封装了一段代码而已
- 如果不调用函数，这个函数不会主动执行的
- 函数示例
def func():
print("welcom to start python")
func()
- 形参：就是函数定义时，小括号里的参数，是用来接收参数用的，在函数内部作为变量使用
- 实参：函数调用的时候，小括号里的参数，是用来把数据传递到函数内部用的
- 函数可以没有形参和实参
2、返回值 - 返回值 是函数 完成工作后，最后给调用者的一个结果
- 在函数中使用return 关键字可以返回结果
- 调用函数一方，可以使用变量来 接收 函数的返回结果
- 返回值示例
点击查看代码
def sum_num(n1,n2):
*****对2个数求和*****
return n1 + n2
#调用函数，并使用变量result接收函数返回值
result = sum_num(10,20)
print("计算的结果是 %d" % result)
3、函数的参数类型
- 位置参数
- 要求实参顺序必须和形参顺序完全一致，由形参顺序决定实参顺序
- 代码示例
点击查看代码
def sum_num(a,b): #形式参数，行参
return a+b
result = sum_num(10,65) #实际赋值的参数，实参
print(result)
- 缺省参数
- 定义函数时，可以给某个参数指定一个默认值，具有默认值的参数就叫做缺省参数
- 示例代码
点击查看代码
def power(x,n=2):
return x**n
result = power(2)
print(result)
result1 = power(5,3)
print(result1)
a = int('16',8)
print(a)
#编写一个自我介绍的函数
def info(name,age=18,gender='女', interests='sport'):
return '我叫 %s，今年%d岁，我是一个%s生，我的兴趣爱好是%s' %(name,age,gender,interests)
miya = info('miya') #默认参数都不写
jake = info('jake',24,'男') #按顺序更新部分默认参数
tom = info('tom',20,interests='swiming') #不按顺序更新部分默认参数
print(miya)
print(jake)
print(tom)
点击查看代码
def total(*args): #使用可变参数
result = 0
for i in args:
result += i*i
return result
result = total(4,2,3,4,77,7,33,9,10)
print(result)
result1 = total(1,2,3,4,5,6)
print(result1)
def f(**kwargs): #可变参数，接收字典
for key, value in kwargs.items():
print(key,value)
d = {'name':'xiaomi','age':18,'titel':'test'}
f(**d)
4、变量的作用域
- 局部变量 是在函数内部定义的变量，只能在函数内部使用
- 全局变量 是在函数外部定义的变量，所有函数内部都可以使用这个变量
- 不可变数据类型 的 全局变量在函数中更新，需要通过global进行声明
- 可变数据类型 的全局变量在函数中更新，不需要通过global进行声明
- 示例代码
点击查看代码
#全局变量和局部变量
num1 = 10 #不可变数据类型
list1 = [1,2,3,4,5] #可变数据类型
def f1():
global num1 #通过global声明该变量就是全局变量，在该函数中对该变量操作会影响全局变量的值
num2= 20 #局部变量，只在f1()函数中生效
num1 = 21 #此处的num1只是和全局变量同名，并未修改全局变量的值
list1[2] = 8
print('函数f1打印全局变量mun1 %d' % num1)
print('函数f1打印局部变量num2 %d' % num2)
print('函数f1打印局部变量list1',list1)
f1()
print('在函数外面打印全局变量num1%d' % num1)
print('在函数外面打印全局变量list1',list1)
5、匿名函数
- lambda函数时一种快速定义单行的最小函数，可以用在任何需要函数的地方
- 优点：让代码更加精简，不需要考虑命名的问题
- 匿名函数与map映射函数结合示例
点击查看代码
#匿名函数和其他函数结合使用
a = [1,2,3,4,5,7,8,9]
# def f(x):
# return x*2
result = map(lambda x:x**3,a) #映射，将a列表中的每个元素按照前面lambda函数做操作
print(list(result))
- 匿名函数与reduce累积函数结合示例
点击查看代码
from functools import reduce
result = reduce(lambda x,y:x*y,a)
print(result)
# 等同于以下操作
result = 1
for i in a:
result *= i
print(result)
- 匿名函数与filter过滤函数结合示例
点击查看代码
#filter 过滤函数,筛选出列表中模2为0 的数
result = filter(lambda x:x%2==0,a)
print(list(result))
#筛选出列表中不为0的数生成新的列表
list1 = [1,2,3,4,0,53,2,1,34,5,6,7,0,43,2,1,0,1,34,5,0]
result = list(filter(lambda x:x!=0,list1))
print(list(result))
--提高示例，将列表中的元素组成一个整数
点击查看代码
#将列表中的元素组成一个数字1234053213456704321013450
list1 = [1,2,3,4,0,53,2,1,34,5,6,7,0,43,2,1,0,1,34,5,0]
#传统的实现方案
result = 0
mul = 1
for i in list1[::-1]:
result += i * mul
mul = mul*10**len(str(i))
print(result)
#传统正序实现
result = 0
for i in list1:
result = result * (10**len(str(i))) +i
print(result)
#通过匿名函数和reduce累积函数实现
result = reduce(lambda x,y:x*10**(len(str(y)))+y,list1)
print(result)
#字符串拼接实现
result_str = ""
for i in list1:
result_str += str(i)
result = int(result_str)
print("结果:%d,类型是：%s" % (result,type(result)))
#列表推导式实现
result = int(''.join(str(num) for num in list1))
print(result)
6、内置函数
- abs() 对传入的参数求绝对值
- bool() 对传入的参数取布尔值，None，0，""，[],{},()这些参数传入bool后，返回False
- all() 所有传入的参数为真，才为真
- any() 任何一个传入的参数为真，就为真
- ascii() 自动执行传入参数的_repr_方法（将对象转换为字符串）
- bin() 接收一个十进制，转换为二进制
- oct() 接收一个十进制，转换为八进制
- hex() 接收一个十进制，转换为十六进制
- bytes() 字符串转换成字节，第一个传入参数是要转换的字符串，第二个参数按照什么编码转换为字节
- str() 字节转换成字符串，第一个传入参数是要转换的字节，第二个参数按照什么编码转换为字符串
- chr(65) 数字转字母或字符，查看ASCII码表
- ord('A') 字母转数字，查看ASCII码表
- compile() 接收.py文件或字符串作为传入参数，将其编译成python字节码
- eval() 执行python代码，并返回其执行结果
- exec() 执行python代码（可以是编译过的，也可以是未编译的），没有返回结果（返回None）
- dir() 接收对象作为参数，返回该对象的所有属性和方法
- help() 接收对象作为参数，更详细地返回该对象的所有属性和方法
- divmod(100,10) 返回一个元组(10,0),第一个元素是100/10的商，第二个元素是100/10的余数
- enumerate() 接收序列化类型的数据，返回一个迭代器（对象）
- isinstance（object,class） 判断对象是否是某个类别的实例
-filter() 对可迭代对象中的每一个元素，将其作为实参传入函数（或lambda表达式），如果函数返回False，将该元素丢弃，如果函数返回True，将该元素添加到filter的返回列值中，注意filter返回的是一个filter对象，实际应用中往往需要用list或tuple将其转换为列表或元组类型 - map() 对可迭代的每一个元素，将其作为实参传入函数，将每一次调用函数返回的结果都添加到map的返回值中
- format() 字符串格式化
- forzenset() 转换为不可变的集合
- globals() 返回一个字典，包括所有的全局变量与它的值所组成的键值对
- locals() 返回一个字典，包括所有的局部变量与它的值所组成的键值对
- hash() 对传入参数取哈希值并返回
- id（） 返回内存地址，可用于查看两个变量是否指向相同一块内存地址
- imput() 提示用户输入，返回用户输入的内容（不论输入什么，都转换成字符串类型）
- issubclass(subclass,class) 查看这个类是否是另一个类的派生类，如果是返回True，否则返回False
- len() 返回长度
- max() 接收序列化类型数据，返回其中值最大的元素
- min() 接收序列化类型数据，返回其中值最小的元素
- memoryview() 查看内存地址
- next()
- iter()
- object()
- pow(x,y) 求次方，返回x**y的结果
- pow(x,y,z) 返回x**y%z的结果
- peoperty() 获取对象的所有属性
- range() 获取随机数或随机字符eg.range(0,10)从0到10的随机数
- repr() 执行传入对象的_repr_方法
- reversed() 对序列化类型数据反向排序，返回一个新的对象。注意与对象的reverse方法区别，后者是就地改变对象
- sorted() 对序列化类型数据正向排序，返回一个新的对象。注意与对象的sort方法区别，后者是就地改变对象
- silce() 对序列化类型数据切片，返回一个新的对象
- round() 返回四舍五入后的结果
- int() 转换为整型
- list() 转换为列表类型
- set() 转换为集合类型
- str() 转换为字符串类型
- tuple() 转换为元组类型
- type() 返回对象类型
- staticmethod() 返回静态方法
- super() 返回基类
- vars() 返回当前模块中的所有变量
- zip() 接收多个序列化类型的数据，对各序列化数据中的元素，按索引位置分类成一个个元组
7、递归函数
- 一个函数调用自身成为递归调用
- 一个会调用自身的函数成为递归函数
- 递归过程有三个步骤
- 步骤1：写出临界条件
- 步骤2：找这一次和上一次的关系
- 步骤3：假设当前函数已经能用，调用自身计算上一次结果，再求出本次结果当参数满足一个条件时，函数不再执行
- 示例1：计算上台阶方法
点击查看代码
#n（10）阶楼梯，每次上1个台阶或每次上2个台阶，问一共有多少种走法
#假如3阶楼梯
# 1 1 1
# 1 2
# 2 1
#f(n+1) = f(n) +f(n-1)
#f(n) = f(n-1) + f(n-2)
#n=0 f(n)=0
#n=1 f(n)=1
#n=2 f(n)=2
#n=3 f(n)=3
def f(n): #计算出n阶楼梯，一共有多少种走法
if n ==0:
return 0
elif n ==1:
return 1
elif n ==2:
return 2
return f(n-1) + f(n-2)
print(f'当楼梯是 {5} 阶时，一共有 {f(5)} 中走法')
# for i in range(10):
# print(f'当楼梯是 {i} 阶时，一共有 {f(i)} 中走法')
#通过循环实现
list1 = [0,1,2]
for i in range(3,11):
list1.append(list1[i-1] + list1[i-2] )
print('当楼梯是 %d 阶时，一共有 %d 中走法' % (i,list1[-1]))
print(list1)
- 示例2：计算斐波那契数列
点击查看代码
def feibonacci(n):
'''
使用递归计算斐波那契数列的第 n 项（从 0 开始计数）
:param n:非负整数
:return:第N项的值
'''
if n < 0 :
return ValueError("输入必须是非负整数")
elif n <= 1:
return n
return feibonacci(n-1) + feibonacci(n-2)
print(feibonacci(-1))
for i in range(0,20):
print('当n为 %d 时，斐波那契数列的值为%d' %(i,feibonacci(i)))
浙公网安备 33010602011771号