区块链技术博客
www.b2bchain.cn

函数进阶使用练习求职学习资料

本文介绍了函数进阶使用练习求职学习资料,有助于帮助完成毕业设计以及求职,是一篇很好的资料。

对技术面试,学习经验等有一些体会,在此分享。

113 Python 查找变量遵守什么顺序? LEGB 规则是啥?

在学习 Python 函数时,我们经常会遇到变量作用域的问题,有全局变量,局部变量等,Python 查找变量的顺序遵守 LEGB 规则,即遇到某个变量时:

  • 优先从它所属的函数( local )内查找;
  • 若找不到,并且它位于一个内嵌函数中,就再到它的父函数( enclosing )中查找;
  • 如果还是找不到,再去全局作用域( global )查找;
  • 再找不到,最后去内置作用域 ( build-in ) 查找。
  • 若还是找不到,报错。

如下例子,变量 c 在局部作用域 ( local ) 被发现;变量 bparent 函数和 son 函数间( enclosing )被发现;变量 a 在全局作用域( global )被发现 ; min 函数属于 Python 中 内置函数 ,所以在搜寻完 LEG 三个区域后,最终在 build-in 域被找到。

a = 10 def parent():     b = 20     def son():         c = 30 # c: local          print(b + c) # b: enclosing         print(a + b + c ) # a: global         print(min(a,b,c)) # min : built-in       son()  In [72]: parent() 50 60 10

如下变量 d,在 LEGB 四个域都被搜寻一遍后,还是未找到,就会抛出 d 没有被发现的异常。

a = 10 def parent():     b = 20     def son():         c = 30 # c: local          print(b + c) # b: enclosing         print(a + b + c ) # a: global         print(min(a,b,c)) # min : built-in          print(d) # 在 LEGB 四个域都未找到后,报错!      son()  parent()  # NameError: name 'd' is not defined

114 可变对象与可哈希的关系?

可变对象英文名称 mutable,如 list, dict 都是不可哈希的(unhashable);只有不可变对象才是可哈希的。

115 什么是浅拷贝? Python 中列表对象怎么实现浅拷贝?

仅仅实现 list 对象中内嵌对象的一层拷贝,属于浅拷贝,英文: shallow copy.

lst2 = ['001','2019-11-11',['三文鱼','电烤箱']] sku_deep = lst2[2].copy() 

可视化图如下,拷贝 lst2[2] 后,sku_deep 位于栈帧中指向一块新的内存空间:

函数进阶使用练习

1574820818329

此时,再对 sku_deep 操作,便不会影响 lst2[2] 的值。

116 什么是深拷贝? Python 中怎么实现深拷贝?

要想实现深度拷贝,需要使用 copy 模块的 deepcopy 函数:

from copy import deepcopy  a = [1,2,[3,4,5]] ac = deepcopy(a) ac[0] = 10 ac[2][1] = 40 print(a[0] == ac[0]) print(a[2][1] == ac[2][1])

打印结果,都为 False,结合下图,也能看出内嵌的 list 全部完成复制,都指向了不同的内存区域。

函数进阶使用练习

image

117 Python 函数常见的有哪五类参数

  • 位置参数
  • 关键字参数
  • 默认参数
  • 可变位置参数
  • 可变关键字参数

118 Python 函数常见的五类参数案例

定义函数 f,只有一个参数 aa 既可能为位置参数,也可能为关键字参数,这取决于调用函数 f 的传参。

def f(a):   print(f'a:{a}')

下面这样调用 fa 就是位置参数,英文 positional argument ,并且 a 被赋值为 1

In [8]: f(1) a:1

如果这样调用 fa 就是关键字参数,英文 keyword argument,a 同样被赋值为1:

In [9]: f(a=1) a:1

如果函数 f 定义为如下,有一个默认值 0

def f(a=0):     print(f'a:{a}')

那么,a 就是默认参数,且默认值为 0.

有以下两种不同的调用方式:

  • 按照 a 的默认值调用
In [11]: f() a:0
  • 默认参数 a 值为 1
In [12]: f(1) a:1

如果函数 f 定义为,如下:

def f(a,*b,**c):     print(f'a:{a},b:{b},c:{c}')

函数 f 的参数稍显复杂,但也是最常用的函数参数定义结构。

出现带一个星号的参数 b,这是可变位置参数;

带两个星号的参数 c,这是可变关键字参数。

可变表示函数被赋值的变量个数是变化的

例如,可以这样调用函数:

f(1,2,3,w=4,h=5)

参数 b 被传递 2 个值,参数 c 也被传递 2 个值。

可变位置参数 b 被解析为元组,可变关键字参数 c 被解析为字典。

In [17]: f(1,2,3,w=4,h=5) a:1,b:(2, 3),c:{'w': 4, 'h': 5}

如果这样调用函数:

f(1,2,w=4)

参数 b 被传递 1 个值,参数 c 被传递 1 个值。

In [18]: f(1,2,w=4) a:1,b:(2,),c:{'w': 4}

所以,称带星号的变量为可变的。

119 Python 中如何查看参数的类型

借助 Python 的 inspect 模块查看参数的类型。

首先,导入 inspect 模块:

from inspect import signature

函数 f 定义为:

def f(a,*b):   print(f'a:{a},b:{b}')

查看参数类型:

In [24]: for name,val in signature(f).parameters.items():     ...:     print(name,val.kind)  a POSITIONAL_OR_KEYWORD b VAR_POSITIONAL

看到,参数 a 既可能是位置参数,也可能是关键字参数。

参数 b 为可变位置参数。

但是,如果函数 f 定义为:

def f(*,a,**b):   print(f'a:{a},b:{b}')

查看参数类型:

In [22]: for name,val in signature(f).parameters.items():     ...:     print(name,val.kind)     ...: a KEYWORD_ONLY b VAR_KEYWORD

看到参数 a 只可能为 KEYWORD_ONLY 关键字参数。

因为参数 a 前面有个星号,星号后面的参数 a 只可能是关键字参数,而不可能是位置参数。

不能使用如下方法调用 f

f(1, b=2, c=3)  TypeError: f() takes 0 positional arguments but 1 was given

120 Python 函数参数传值 6 大规则及常见错误解析

Python 强大多变,原因之一在于函数参数的多样化。

方便的同时,也要求开发者遵守更多的约束规则。

如果不了解这些规则,函数调用时,可能会出现各种各样的调用异常。

常见的有以下六类:

SyntaxError: positional argument follows keyword argument,位置参数位于关键字参数后面

TypeError: f() missing 1 required keyword-only argument: ‘b’,必须传递的关键字参数缺失

SyntaxError: keyword argument repeated,关键字参数重复

TypeError: f() missing 1 required positional argument: ‘b’,必须传递的位置参数缺失

TypeError: f() got an unexpected keyword argument ‘a’,没有这个关键字参数

TypeError: f() takes 0 positional arguments but 1 was given,不需要位置参数但却传递 1 个

下面总结, 6 个主要的参数使用规则。

规则 1:不带默认值的位置参数缺一不可

函数调用时,根据函数定义的参数位置来传递参数,是最常见的参数类型。

def f(a):   return a  f(1) # 这样传递值,参数 a 为位置参数

如下带有两个参数,传值时必须两个都赋值。

def f(a,b):     pass  In [107]: f(1)  TypeError: f() missing 1 required positional argument: 'b'

规则 2:关键字参数必须在位置参数右边

在调用 f 时,通过键–值方式为函数形参传值。

def f(a):   print(f'a:{a}')

参数 a 变为关键字参数

f(a=1)

但是,下面调用,就会出现:位置参数位于关键字参数后面的异常。

“`
def f(a,b):
pass

In [111]: f(a=1,20.)

113 Python 查找变量遵守什么顺序? LEGB 规则是啥?

在学习 Python 函数时,我们经常会遇到变量作用域的问题,有全局变量,局部变量等,Python 查找变量的顺序遵守 LEGB 规则,即遇到某个变量时:

  • 优先从它所属的函数( local )内查找;
  • 若找不到,并且它位于一个内嵌函数中,就再到它的父函数( enclosing )中查找;
  • 如果还是找不到,再去全局作用域( global )查找;
  • 再找不到,最后去内置作用域 ( build-in ) 查找。
  • 若还是找不到,报错。

如下例子,变量 c 在局部作用域 ( local ) 被发现;变量 bparent 函数和 son 函数间( enclosing )被发现;变量 a 在全局作用域( global )被发现 ; min 函数属于 Python 中 内置函数 ,所以在搜寻完 LEG 三个区域后,最终在 build-in 域被找到。

a = 10 def parent():     b = 20     def son():         c = 30 # c: local          print(b + c) # b: enclosing         print(a + b + c ) # a: global         print(min(a,b,c)) # min : built-in       son()  In [72]: parent() 50 60 10

如下变量 d,在 LEGB 四个域都被搜寻一遍后,还是未找到,就会抛出 d 没有被发现的异常。

a = 10 def parent():     b = 20     def son():         c = 30 # c: local          print(b + c) # b: enclosing         print(a + b + c ) # a: global         print(min(a,b,c)) # min : built-in          print(d) # 在 LEGB 四个域都未找到后,报错!      son()  parent()  # NameError: name 'd' is not defined

114 可变对象与可哈希的关系?

可变对象英文名称 mutable,如 list, dict 都是不可哈希的(unhashable);只有不可变对象才是可哈希的。

115 什么是浅拷贝? Python 中列表对象怎么实现浅拷贝?

仅仅实现 list 对象中内嵌对象的一层拷贝,属于浅拷贝,英文: shallow copy.

lst2 = ['001','2019-11-11',['三文鱼','电烤箱']] sku_deep = lst2[2].copy() 

可视化图如下,拷贝 lst2[2] 后,sku_deep 位于栈帧中指向一块新的内存空间:

函数进阶使用练习

1574820818329

此时,再对 sku_deep 操作,便不会影响 lst2[2] 的值。

116 什么是深拷贝? Python 中怎么实现深拷贝?

要想实现深度拷贝,需要使用 copy 模块的 deepcopy 函数:

from copy import deepcopy  a = [1,2,[3,4,5]] ac = deepcopy(a) ac[0] = 10 ac[2][1] = 40 print(a[0] == ac[0]) print(a[2][1] == ac[2][1])

打印结果,都为 False,结合下图,也能看出内嵌的 list 全部完成复制,都指向了不同的内存区域。

函数进阶使用练习

image

117 Python 函数常见的有哪五类参数

  • 位置参数
  • 关键字参数
  • 默认参数
  • 可变位置参数
  • 可变关键字参数

118 Python 函数常见的五类参数案例

定义函数 f,只有一个参数 aa 既可能为位置参数,也可能为关键字参数,这取决于调用函数 f 的传参。

def f(a):   print(f'a:{a}')

下面这样调用 fa 就是位置参数,英文 positional argument ,并且 a 被赋值为 1

In [8]: f(1) a:1

如果这样调用 fa 就是关键字参数,英文 keyword argument,a 同样被赋值为1:

In [9]: f(a=1) a:1

如果函数 f 定义为如下,有一个默认值 0

def f(a=0):     print(f'a:{a}')

那么,a 就是默认参数,且默认值为 0.

有以下两种不同的调用方式:

  • 按照 a 的默认值调用
In [11]: f() a:0
  • 默认参数 a 值为 1
In [12]: f(1) a:1

如果函数 f 定义为,如下:

def f(a,*b,**c):     print(f'a:{a},b:{b},c:{c}')

函数 f 的参数稍显复杂,但也是最常用的函数参数定义结构。

出现带一个星号的参数 b,这是可变位置参数;

带两个星号的参数 c,这是可变关键字参数。

可变表示函数被赋值的变量个数是变化的

例如,可以这样调用函数:

f(1,2,3,w=4,h=5)

参数 b 被传递 2 个值,参数 c 也被传递 2 个值。

可变位置参数 b 被解析为元组,可变关键字参数 c 被解析为字典。

In [17]: f(1,2,3,w=4,h=5) a:1,b:(2, 3),c:{'w': 4, 'h': 5}

如果这样调用函数:

f(1,2,w=4)

参数 b 被传递 1 个值,参数 c 被传递 1 个值。

In [18]: f(1,2,w=4) a:1,b:(2,),c:{'w': 4}

所以,称带星号的变量为可变的。

119 Python 中如何查看参数的类型

借助 Python 的 inspect 模块查看参数的类型。

首先,导入 inspect 模块:

from inspect import signature

函数 f 定义为:

def f(a,*b):   print(f'a:{a},b:{b}')

查看参数类型:

In [24]: for name,val in signature(f).parameters.items():     ...:     print(name,val.kind)  a POSITIONAL_OR_KEYWORD b VAR_POSITIONAL

看到,参数 a 既可能是位置参数,也可能是关键字参数。

参数 b 为可变位置参数。

但是,如果函数 f 定义为:

def f(*,a,**b):   print(f'a:{a},b:{b}')

查看参数类型:

In [22]: for name,val in signature(f).parameters.items():     ...:     print(name,val.kind)     ...: a KEYWORD_ONLY b VAR_KEYWORD

看到参数 a 只可能为 KEYWORD_ONLY 关键字参数。

因为参数 a 前面有个星号,星号后面的参数 a 只可能是关键字参数,而不可能是位置参数。

不能使用如下方法调用 f

f(1, b=2, c=3)  TypeError: f() takes 0 positional arguments but 1 was given

120 Python 函数参数传值 6 大规则及常见错误解析

Python 强大多变,原因之一在于函数参数的多样化。

方便的同时,也要求开发者遵守更多的约束规则。

如果不了解这些规则,函数调用时,可能会出现各种各样的调用异常。

常见的有以下六类:

SyntaxError: positional argument follows keyword argument,位置参数位于关键字参数后面

TypeError: f() missing 1 required keyword-only argument: ‘b’,必须传递的关键字参数缺失

SyntaxError: keyword argument repeated,关键字参数重复

TypeError: f() missing 1 required positional argument: ‘b’,必须传递的位置参数缺失

TypeError: f() got an unexpected keyword argument ‘a’,没有这个关键字参数

TypeError: f() takes 0 positional arguments but 1 was given,不需要位置参数但却传递 1 个

下面总结, 6 个主要的参数使用规则。

规则 1:不带默认值的位置参数缺一不可

函数调用时,根据函数定义的参数位置来传递参数,是最常见的参数类型。

def f(a):   return a  f(1) # 这样传递值,参数 a 为位置参数

如下带有两个参数,传值时必须两个都赋值。

def f(a,b):     pass  In [107]: f(1)  TypeError: f() missing 1 required positional argument: 'b'

规则 2:关键字参数必须在位置参数右边

在调用 f 时,通过键–值方式为函数形参传值。

def f(a):   print(f'a:{a}')

参数 a 变为关键字参数

f(a=1)

但是,下面调用,就会出现:位置参数位于关键字参数后面的异常。

“`
def f(a,b):
pass

In [111]: f(a=1,20.)

113 Python 查找变量遵守什么顺序? LEGB 规则是啥?

在学习 Python 函数时,我们经常会遇到变量作用域的问题,有全局变量,局部变量等,Python 查找变量的顺序遵守 LEGB 规则,即遇到某个变量时:

  • 优先从它所属的函数( local )内查找;
  • 若找不到,并且它位于一个内嵌函数中,就再到它的父函数( enclosing )中查找;
  • 如果还是找不到,再去全局作用域( global )查找;
  • 再找不到,最后去内置作用域 ( build-in ) 查找。
  • 若还是找不到,报错。

如下例子,变量 c 在局部作用域 ( local ) 被发现;变量 bparent 函数和 son 函数间( enclosing )被发现;变量 a 在全局作用域( global )被发现 ; min 函数属于 Python 中 内置函数 ,所以在搜寻完 LEG 三个区域后,最终在 build-in 域被找到。

a = 10 def parent():     b = 20     def son():         c = 30 # c: local          print(b + c) # b: enclosing         print(a + b + c ) # a: global         print(min(a,b,c)) # min : built-in       son()  In [72]: parent() 50 60 10

如下变量 d,在 LEGB 四个域都被搜寻一遍后,还是未找到,就会抛出 d 没有被发现的异常。

a = 10 def parent():     b = 20     def son():         c = 30 # c: local          print(b + c) # b: enclosing         print(a + b + c ) # a: global         print(min(a,b,c)) # min : built-in          print(d) # 在 LEGB 四个域都未找到后,报错!      son()  parent()  # NameError: name 'd' is not defined

114 可变对象与可哈希的关系?

可变对象英文名称 mutable,如 list, dict 都是不可哈希的(unhashable);只有不可变对象才是可哈希的。

115 什么是浅拷贝? Python 中列表对象怎么实现浅拷贝?

仅仅实现 list 对象中内嵌对象的一层拷贝,属于浅拷贝,英文: shallow copy.

lst2 = ['001','2019-11-11',['三文鱼','电烤箱']] sku_deep = lst2[2].copy() 

可视化图如下,拷贝 lst2[2] 后,sku_deep 位于栈帧中指向一块新的内存空间:

函数进阶使用练习

1574820818329

此时,再对 sku_deep 操作,便不会影响 lst2[2] 的值。

116 什么是深拷贝? Python 中怎么实现深拷贝?

要想实现深度拷贝,需要使用 copy 模块的 deepcopy 函数:

from copy import deepcopy  a = [1,2,[3,4,5]] ac = deepcopy(a) ac[0] = 10 ac[2][1] = 40 print(a[0] == ac[0]) print(a[2][1] == ac[2][1])

打印结果,都为 False,结合下图,也能看出内嵌的 list 全部完成复制,都指向了不同的内存区域。

函数进阶使用练习

image

117 Python 函数常见的有哪五类参数

  • 位置参数
  • 关键字参数
  • 默认参数
  • 可变位置参数
  • 可变关键字参数

118 Python 函数常见的五类参数案例

定义函数 f,只有一个参数 aa 既可能为位置参数,也可能为关键字参数,这取决于调用函数 f 的传参。

def f(a):   print(f'a:{a}')

下面这样调用 fa 就是位置参数,英文 positional argument ,并且 a 被赋值为 1

In [8]: f(1) a:1

如果这样调用 fa 就是关键字参数,英文 keyword argument,a 同样被赋值为1:

In [9]: f(a=1) a:1

如果函数 f 定义为如下,有一个默认值 0

def f(a=0):     print(f'a:{a}')

那么,a 就是默认参数,且默认值为 0.

有以下两种不同的调用方式:

  • 按照 a 的默认值调用
In [11]: f() a:0
  • 默认参数 a 值为 1
In [12]: f(1) a:1

如果函数 f 定义为,如下:

def f(a,*b,**c):     print(f'a:{a},b:{b},c:{c}')

函数 f 的参数稍显复杂,但也是最常用的函数参数定义结构。

出现带一个星号的参数 b,这是可变位置参数;

带两个星号的参数 c,这是可变关键字参数。

可变表示函数被赋值的变量个数是变化的

例如,可以这样调用函数:

f(1,2,3,w=4,h=5)

参数 b 被传递 2 个值,参数 c 也被传递 2 个值。

可变位置参数 b 被解析为元组,可变关键字参数 c 被解析为字典。

In [17]: f(1,2,3,w=4,h=5) a:1,b:(2, 3),c:{'w': 4, 'h': 5}

如果这样调用函数:

f(1,2,w=4)

参数 b 被传递 1 个值,参数 c 被传递 1 个值。

In [18]: f(1,2,w=4) a:1,b:(2,),c:{'w': 4}

所以,称带星号的变量为可变的。

119 Python 中如何查看参数的类型

借助 Python 的 inspect 模块查看参数的类型。

首先,导入 inspect 模块:

from inspect import signature

函数 f 定义为:

def f(a,*b):   print(f'a:{a},b:{b}')

查看参数类型:

In [24]: for name,val in signature(f).parameters.items():     ...:     print(name,val.kind)  a POSITIONAL_OR_KEYWORD b VAR_POSITIONAL

看到,参数 a 既可能是位置参数,也可能是关键字参数。

参数 b 为可变位置参数。

但是,如果函数 f 定义为:

def f(*,a,**b):   print(f'a:{a},b:{b}')

查看参数类型:

In [22]: for name,val in signature(f).parameters.items():     ...:     print(name,val.kind)     ...: a KEYWORD_ONLY b VAR_KEYWORD

看到参数 a 只可能为 KEYWORD_ONLY 关键字参数。

因为参数 a 前面有个星号,星号后面的参数 a 只可能是关键字参数,而不可能是位置参数。

不能使用如下方法调用 f

f(1, b=2, c=3)  TypeError: f() takes 0 positional arguments but 1 was given

120 Python 函数参数传值 6 大规则及常见错误解析

Python 强大多变,原因之一在于函数参数的多样化。

方便的同时,也要求开发者遵守更多的约束规则。

如果不了解这些规则,函数调用时,可能会出现各种各样的调用异常。

常见的有以下六类:

SyntaxError: positional argument follows keyword argument,位置参数位于关键字参数后面

TypeError: f() missing 1 required keyword-only argument: ‘b’,必须传递的关键字参数缺失

SyntaxError: keyword argument repeated,关键字参数重复

TypeError: f() missing 1 required positional argument: ‘b’,必须传递的位置参数缺失

TypeError: f() got an unexpected keyword argument ‘a’,没有这个关键字参数

TypeError: f() takes 0 positional arguments but 1 was given,不需要位置参数但却传递 1 个

下面总结, 6 个主要的参数使用规则。

规则 1:不带默认值的位置参数缺一不可

函数调用时,根据函数定义的参数位置来传递参数,是最常见的参数类型。

def f(a):   return a  f(1) # 这样传递值,参数 a 为位置参数

如下带有两个参数,传值时必须两个都赋值。

def f(a,b):     pass  In [107]: f(1)  TypeError: f() missing 1 required positional argument: 'b'

规则 2:关键字参数必须在位置参数右边

在调用 f 时,通过键–值方式为函数形参传值。

def f(a):   print(f'a:{a}')

参数 a 变为关键字参数

f(a=1)

但是,下面调用,就会出现:位置参数位于关键字参数后面的异常。

“`
def f(a,b):
pass

In [111]: f(a=1,20.)

部分转自互联网,侵权删除联系

赞(0) 打赏
部分文章转自网络,侵权联系删除b2bchain区块链学习技术社区 » 函数进阶使用练习求职学习资料
分享到: 更多 (0)

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

b2b链

联系我们联系我们