函数

最新推荐文章于 2021-01-30 04:24:00 发布

黎京

最新推荐文章于 2021-01-30 04:24:00 发布

阅读量166

点赞数

文章标签： Python

本文链接：https://blog.csdn.net/qq_34636310/article/details/97035373

版权

函数

引子：

求1-15的和;

求23-36的和;

求55-68的和;

程序而言：函数就是对程序逻辑进行结构化或者过程化的一种编程方法。

built-in function内置函数 —>BIF

def sum_add(i1,i2):
    '''叠加'''
    result = 0
    for i in range(i1,i2+1):
        result += i
    return result
print(sum_add(1,15))
print(sum_add(23,35))
print(sum_add(55,67))
print(sum_add.__doc__)

#120
377
793
叠加

函数的定义

声明函数的一般形式：

def function_name(arg1,arg2,...,argn):
    '''statements'''
    func_statements
    return Valie

说明如下：

1.函数代码块以 def 关键词开头，后接函数标识符名称和小括号 ()。

2.任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。

3.函数的第一行语句可以选择性地使用文档字符串----用于存放函数说明。

4.函数内容以冒号起始，并且缩进。

5.return [表达式] 结束函数，选择性的返回一个值给调用方。不带表达式的return相当于返回 None。

其中参数列表和返回值不是必须的,return后也可以不跟返回值,甚至连 return也没有。

对于return后没有返回值的和没有return语句的函数都会返回None值

有些函数可能既不需要传递参数,也没有返回值。

没有参数时,包含参数的圆括号也必须写上,圆括号后也必须有“:”。

函数调用

函数文档说明

函数参数

不传参函数
参数函数
- 顺序

def test(x,y):
    print(x)
    print(y)
print('1'.center(10,'*'))
test(1,2)
print('2'.center(10,'*'))
test(x=1,y=2)
print('3'.center(10,'*'))
test(y=2,x=1)
print('4'.center(10,'*'))
test(1,y=2)

****1*****
1
2
****2*****
1
2
****3*****
1
2
****4*****
1
2

print('5'.center(10,'*'))
test(x=1,2)  # 错误关键字参数必须在后     4和5对比

函数返回值

函数参数种类

形参和实参

形参
- 只有在调用时才分配内存单元。调用解释后，即释放所分配的内存单元。因此形参只在内部有效，函数吊桶结束返回主调用函数后则不能再使用该形参变量。
实参
- 实参是一个确定的值，能够传递给形参
  - 作为位置参数或者关键字参数传递

def usr_manage(name,age,job,hobby):
    print("用户管理系统".center(16, '-'))
    print('\tName:\t',name)
    print('\tAge:\t', age)
    print('\tJob:\t', job)
    print('\tHobby:\t', hobby)
    print("用户管理系统".center(16, '-'))
usr_manage('Tom', 20, 'IT', 'Coding')

-----用户管理系统-----
	Name:	 Tom
	Age:	 20
	Job:	 IT
	Hobby:	 Coding
-----用户管理系统-----

只传递实参，位置一一对应—>位置参数

使用位置参数时和函数头定义的形参在顺序，个数以及类型上匹配

默认值参数

def usr_manage(name,age,job,hobby='eat'):
    print("用户管理系统".center(16, '-'))
    print('\tName:\t',name)
    print('\tAge:\t', age)
    print('\tJob:\t', job)
    print('\tHobby:\t', hobby)
    print("用户管理系统".center(16, '-'))
usr_manage('Tom', 18, job='IT', )    #job='IT'关键字参数    对应Hobby为空是默认值参数
-----用户管理系统-----
	Name:	 Tom
	Age:	 18
	Job:	 IT
	Hobby:	 eat
-----用户管理系统-----

默认值参数，关键字参数，必须放置在位置参数子后

不定参数

在Python中不定参数主要是指 *args 和 **kwargs 两个魔法变量。

他们俩主要是用于函数定义，我们可以将不定数量的参数传递给一个函数

*args 用来接收任意非键值对的任意数量的参数列表给函数

def a(para, para2, *args):
    print('普通位置参数', para, para2)
    print('不定参数', args)
    print(type(args))
a(1,2,3,4,5,6,7,8,9,'a')
a('[1,2,3]', 'a', 'b')
普通位置参数 1 2
不定参数 (3, 4, 5, 6, 7, 8, 9, 'a')
<class 'tuple'>
普通位置参数 [1,2,3] a
不定参数 ('b',)
<class 'tuple'>    #返回的是个元组

**kwargs

def un_key(**kwargs):
    print(kwargs)
    print(type(kwargs))
un_key(a=1, b=2, c=3, d=5)

{'a': 1, 'b': 2, 'c': 3, 'd': 5}
<class 'dict'>

def un_key(x, y, *z, **kwargs):
    print(x,y,z)
    print(type(z))
    print(kwargs)
    print(type(kwargs))
un_key(1, 2, 3, 4, 'a', 'b', a=1, b=2, c=3, d=5)

1 2 (3, 4, 'a', 'b')
<class 'tuple'>
{'a': 1, 'b': 2, 'c': 3, 'd': 5}
<class 'dict'>

函数引用

你可以获得每个 pyhon 模块，类，和函数中任意的名字空间。你可以在模块 foo 和 bar 里都有名为 x 的一个变量,，但是在将这两个模块导入你的程序后，仍然可以使用这两个变量。所以，即使在两个模块中使用了相同的变量名字，这也是安全的，因为句点属性标识对于两个模块意味了不同的命名空间，比如说，在这段代码中没有名字冲突：

函数属性

函数的属性是Python中另外一个使用了句点属性标识并拥有名字空间的领域

内嵌函数

—>作用域

bar()整个函数都处于外部foo()函数的作用域里，foo()是我们可以从外部访问的一个对象区域。除了在foo()内部，其他地方无法进行对bar()的调用

def foo():
    def bar():
        print('in bar()')
    print('in foo')
    bar()
foo()

in foo
in bar()

变量作用域

作用域的产生

只有变量在module， Class，函数中定义的时候，才会有作用域的概念

def foo():
    def bar():
        print('in bar()')
    print('in foo')
    bar()
foo()   #调用foo() 输出in foo并调用内部的bar() 输出in bar
bar()   #没定义

in foo
in bar()
NameError: name 'bar' is not defined

作用域的类型

Python中，变量不需要预先声明，但使用时，必须绑定某个内存对象(被定义，赋值)。这种变量名的绑定将在当前作用域引入新的变量，同时，屏蔽外层作用域中的同门变量。

局部作用域(locale—L)：包含在def关键字定义的语句块中，即在函数中定义的变量。每当函数被调用时都会创建一个新的局部作用域。Python中也有递归，即自己调用自己，每次调用都会创建一个新的局部命名空间。在函数内部的变量声明，除非特别的声明为全局变量，否则均默认为局部变量。有些情况需要在函数内部定义全局变量，这时可以使用global关键字来声明变量的作用域为全局。局部变量域就像一个栈，仅仅是暂时的存在，依赖创建该局部作用域的函数是否处于活动的状态。所以，一般建议尽量少定义全局变量，因为全局变量在模块文件运行的过程中会一直存在，占用内存空间。
注意：如果需要在函数内部对全局变量赋值，需要在函数内部通过global语句声明该变量为全局变量。
嵌套作用域(enclosing—E)
- E 也包含在def 官字子中，E和L是相对的， E相对于跟上层的函数而言也是L。与L的区别在于，对于一个函数而言，L是定义在定义在在此函数内部的局部作用域。
- 主要是为了实现Python的闭包，而增加的实现。
全局作用域(Gloval —G)

即在模块层次中定义的变量。模块顶层申明的变量具有全局作用域。从外部来看，模块的全局变量就是一个模块对象的属性。

内置作用域(built-in—B)
- 系统固定模块中定义的变量

搜索变量名的优先级：局部作用域>嵌套作用域>全局作用域>内置作用域

全局变量和局部变量

gbl_str = 'foo'
def foo():
    loc_str = 'bar'
    return  gbl_str+loc_str
print(foo())
print(gbl_str)
print(loc_str)

foobar
foo
NameError: name 'loc_str' is not defined  局部变量

a = 6688
def foo():
    print('foo(), a:\t', a)
    a = 888       若之后print 调用a  则 888
def bar():
    print("bar(),a:\t", a)    调用全局
foo()
bar()
#报错   局部Print时 内部存在同名a且 运行print时 未定义，若改为b = 888,则内部无定义a 取全局变量6688

def foo():
    a = 666
    print('foo(),修改前:\t', a)                    先局部再全局
    a = 888                      
    print('foo(),修改后:\t', a)
def bar():                        
    a = 6688
    print("bar(),a:\t", a)
foo()
bar()
foo(),修改前:	 666              局部调用前 定义了 a = 666
foo(),修改后:	 888              局部调用前 定义了 a = 888
bar(),a:	 6688                 局部调用前 定义了 a = 6688