Python（IT峰）笔记03-函数，普通参数，默认参数，手机参数，命名关键字参数，关键字参数手机，返回值，变量作用域，nonlocal关键字，递归函数，回调函数，闭包函数，匿名函数，迭代器

最新推荐文章于 2021-09-23 07:24:15 发布

心湖中的石子

最新推荐文章于 2021-09-23 07:24:15 发布

阅读量202

点赞数

分类专栏： python 文章标签： python pycharm

本文链接：https://blog.youkuaiyun.com/weixin_43745804/article/details/120121396

版权

python 专栏收录该内容

22 篇文章

订阅专栏

1、模块化编程

把程序进行封装（函数封装，对象，文件。。。）

2、函数

定义函数
def 函数名（参数列表）：
函数体

调用函数
函数名()

def sayhi(name):
    print(f'hi {name} morning')

sayhi('zhangsan')

3、普通参数与默认参数、收集参数

普通参数就是必须传递的参数，是最常见的参数
默认参数在普通参数上直接赋值，同es6

def sayhi(name,age,address='beijing'):
    print(f'hi {name} is {age} old,live at {address}')

sayhi('zhangsan',34)

收集参数（同一个专门收集多余的实参，实际上就是不确定形参类似于es6的…扩展符号）
收集参数使用*args表示，注意有个星星

def sayhi(name,age,address='beijing',*args):
    print(f'hi {name} is {age} old,live at {address}')
    for item in args:
        print(item)

sayhi('zhangsan',34,'beijing','xiamen','shenzhen','guangzhou')

4、命名关键字参数

要赋值的：关键字参数，默认参数
不用赋值，普通参数，收集参数

在星号参数后面的参数，她是不被收集参数囊括的，
也就是说收集参数一般来说都是放在最后面
但是这个命名关键字参数放在了星号参数的后面
调用时关键字参数必须需要通过赋值对的形式传入该实参

def sayhi(name,age,address='beijing',*args,gender):
    print(f'hi {name} is {age} old,live at {address}')
    for item in args:
        print(item)
    print(gender)
sayhi('zhangsan',34,'beijing','xiamen','shenzhen','guangzhou',gender='female')#传入关键字参数需要使用赋值的方式

5、关键字参数收集

使用两个星来表示关键字参数收集
前面必须要有个收集参数，后面才可能有关键字收集
收集参数通常用arg，关键字收集用kwarg，当然这个命名不是强制的

def mytest(a, b, c, *args, **kwargs):
    print(a, b, c)
    for item in args:
        print(item)
    for item in kwargs:
        print(item)
mytest(100, 299, 399, 'zhangsan', 'lisi', 'wanger', age=23, address='beijing')

6、函数返回值

def myfun(n1, n2):
    return n1 + n2


a = myfun(3, 5)
print(a)

7、变量作用域

全局
局部
大致同java及其他语言

#全局
n1=20
n2=30

def myfun(n1, n2):
    return n1 + n2


a = myfun(n1, n2)
print(a)

#局部
n1=20
n2=30

def myfun(n1, n2):
    n3 = 20
    n4 = 30

    return n1 + n2+n3+n4


a = myfun(n1, n2)
print(a)

函数外定义的变量，函数可以访问，但是不能更改
变量分两种：
可变数据类型（列表和字典）：在函数外定义的变量，在函数内可以使用（访问及修改）
不可变数据类型，在函数外定义的变量，在函数内，只能访问，不能使用其他操作

此外，在函数内部，使用global关键字定义的变量为全局变量
在函数外定义的变量，函数内使用global进行引用

n1 = 20
n5 = 30


def myfun(n1, n2):
    n3 = 20
    global n5
    n5 = 1
    global n6
    n6 = 100

    return n1 + n2 + n3 + n5


a = myfun(n1, 2)
print(a)
print(n5)
print(n6)

globals（）函数获取全局数据
locals（）函数获取当前作用域的数据

n1 = 20
n5 = 30
def myfun(n1, n2):
    n3 = 20
    global n5
    n5 = 1
    global n6
    n6 = 100

    return locals()
print(myfun(2,3))
print(globals())

函数内定义的函数，称之为局部函数（函数嵌套）

8、nonlocal关键字

变量和函数都有作用域
nonlocal再次声明的关键字可以在内函数使用上一层函数中的局部变量

def outer():
    num = 10

    def inner():
        nonlocal num
        num+=1#如果不使用nonlocal再次申明，则修改num报错，但直接引用不报错
        print(num)

    inner()
outer()

9、递归函数

在函数内自己调用自己
递归体里面一定要有个判断语句及判断变量以便停止递归
执行下一层递归的时候，上一层暂停等待，一层层进入，再一层层返回

def myp(num):
	print(num)
	if (num > 0):
		myp(num - 1)

myp(5)

10、回调函数

函数作为一个参数，传入主函数中，并在主函数中使用了传递进来的函数，那么这个函数可以称为一个回调函数

def sayhello(name):
	print('hello'+' '+name)

def myp(fun):
	fun('zhangsan')
	print('---')

myp(sayhello)#注意是传入函数名即可

另一案例
可以在主函数中把参数传递给回调函数

def add(x, y):
	print(x + y)


def myp(x, y, fun):
	fun(x, y)


myp(2, 3, add)#5

11、闭包函数

如果在一个函数中，如果返回了一个函数（内函数），并且返回的内函数还使用了外函数中的局部变量，该内函数则为闭包函数

def myp():
	num = 10

	def fun(a, b):
		print(a + b + num)

	return fun

myp()(2,4)

闭包会锁定被闭包应用的变量，防止在内函数外部修改值

12、使用lambda表达式创建匿名函数

可以不使用def定义函数，而是使用lambd表达式来封装

myfun=lambda x,y,z:x+y+z#实际是return 了一个表达式的结果
print(myfun(4,6,3))

lambda表达式封装分支结构

myfun=lambda sex:'男的' if sex=='male' else '女的'

print(myfun('female'))

13、迭代器

迭代器是一个可以记住访问遍历的位置的对象
只能从前向后遍历
能被next（）函数调用，并不断返回下一个值的对象

Iter（）方法：把可迭代的对象转换为一个迭代器对象，参数可以是字符串，元祖，列表，字典，集合，range
返回值是一个迭代器对象

next（迭代器对象）来使用迭代器

mytierate1=range(1,5)
mytierate2=['zhangsan','lisi','wanger']
res1=iter(mytierate1)#返回一个可迭代的对象
res2=iter(mytierate2)#返回一个可迭代的对象

#使用迭代器对象
result=next(res1)
print(result)#1
print(next(res1))#2
print(next(res1))#3

print(next(res2))#zhangsan
print(next(res2))#lisi
print(next(res2))#wanger

list（迭代器对象）直接取出迭代器中的所有数据
for循环获取迭代器所有数据

mytierate1=range(1,5)
mytierate2=['zhangsan','lisi','wanger']
res1=iter(mytierate1)#返回一个可迭代的对象
res2=iter(mytierate2)#返回一个可迭代的对象

result1=list(res1)
result2=list(res2)
print(result1)
print(result2)
for item in result1:
	print(item)
for item in result2:
	print(item)

打印结果
[1, 2, 3, 4]
[‘zhangsan’, ‘lisi’, ‘wanger’]
1
2
3
4
zhangsan
lisi
wanger

type（）函数：返回当前数据的类型
isinstance(对象实例，对象类型）函数：返回当前对象是不是指定类型的实例
需要导入collections.abc

from collections.abc import Iterator,Iterable
mytierate1=range(1,5)
mytierate2=['zhangsan','lisi','wanger']
res1=iter(mytierate1)#返回一个可迭代的对象
res2=iter(mytierate2)#返回一个可迭代的对象

istype=isinstance(res2,Iterator)#是一个迭代器
istype2=isinstance(res2,Iterable)#是一个可迭代对象
print(istype)#True
print(istype2)#True