Python函数详解
我的图书馆
Python函数详解
在介绍Python的函数之前我们先来回顾一下，我们平常写代码是不是需要什么功能就写什么功能，但是到后面深入你会发现在写代码的过程中，有好多代码是重叠的，就是一个功能块在不同的地方都被使用，但是每次都得重新写一遍，这样就造成了写程序的效率问题，而Python中的函数就可以很好的解决这么一点。例如一个登陆代码快的代码，你比如刚登陆的时候需要验证用户名密码，你执行他事件比如购物、结算等逻辑的时候也需要做验证，那如果我们把这个验证的逻辑封装成一个函数，然后用到的地方，想怎么调就怎么调用，所以减少代码的重复性是函数的特性之一。&同时在过去的十年间，大家广为熟知的编程方法无非两种：面向对象和面向过程，其实，无论哪种，都是一种编程的规范或者是如何编程的方法论。而如今，一种更为古老的编程方式：函数式编程，以其不保存状态，不修改变量等特性重新进入人们的视野。下面我们就来依次了解这一传统的编程理念，下面我们介绍一些Python中函数的概念。&面向过程：根据业务逻辑从上到下写垒代码函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可函数是什么?在我们的初中书写中我们应该知道3x &= 4y 这就是一个简单的函数，而x、y就是两个变量，如果x确定为一个值，那y的值就是确定的，我们把x叫做自变量，而把y叫做应变量，y是x的函数，当然也可以反过来说。这里就是y会随着x的值变化而变化。而这个自变量x的取值范围我们就叫做这个函数的定义域。&函数一词虽源于数学，但编程中的「函数」概念，与数学中的函数是有很大不同的，具体区别，我们后面会讲，编程中的函数在英文中也有很多不同的叫法。在BASIC中叫做subroutine(子过程或子程序)，在Pascal中叫做procedure(过程)和function，在C中只有function，在Java里面叫做method。&定义: 函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名的方法即可函数的特性：减少重复代码使程序变的可扩展（装饰器本质是函数）使程序变得易维护&语法定义：def test(x):
& &'The function definitions'
& &return x
******************************************************************
def:定义函数的关键字
test：函数名
（）：内可定义形参
'':文档描述（非必要，但是强烈建议为你的函数添加描述信息）
x =1：泛指代码块或程序处理逻辑
return：定义返回值**编程语言中函数定义：函数是逻辑结构化和过程化的一种编程方法，函数式编程就是先定义一个数学函数，然后按照这个数学模型用编程语言去实现它。&一个栗子：#!/usr/bin/env python3
# _*_coding:utf-8_*_
# Author: Lucky.chen
# 常规码代码
a, b = 5, 8
print('我是分割线'.center(30, '*'))
# 函数方法
def calc(x, y):
& &res = x * y
& &return res &# 返回函数执行结果
c = calc(a, b) & # 结果赋值给c变量
print(c)Result:40
************我是分割线*************
40这不是功能一样吗，看起来并没有什么卵用！！！嘿嘿！函数参数与局部变量形参:形式参数，不是实际存在，是虚拟变量。在定义函数和函数体的时候使用形参，目的是在函数调用时接收实参（实参个数，类型应与实参一一对应）。实参：实际参数，调用函数时传给函数的参数，可以是常量，变量，表达式，函数，传给形参。区别：形参是虚拟的，不占用内存空间，形参变量只有在被调用时才分配内存单元，实参是一个变量，占用内存空间，数据传送单向，实参传给形参，不能形参传给实参。实参就是函数执行的时候用户调用函数实际传输的参数简称为实参，实参又分为位置参数和关键参数。&位置参数实例如下：def test(x, y): & & # x, y是形参
& &print('x is %d, y is %d' % (x, y))
& &calc_age = x * y
& &return calc_age
# 3在前,6在后 那么传给函数的形参就是按照位置 x = 3 , y = 6
print(test(3, 6))
print('我是分割线'.center(30, '*'))
# 如果调用的时候6在前,3在后,那么 x = 6, y = 3
print(test(6, 3))结果如下：x is 3, y is 6
************我是分割线*************
x is 6, y is 3
18关键参数实例如下：def test(x, y, z): & & # x, y是形参
& &print('x is %d, y is %d, z is %d' % (x, y, z))
& &calc_age = x * y * z
& &return calc_age
# 指定y和z的值而x的值就是默认出入位置为第个的实参
print(test(3, y=2, z=3))
print('我是分割线'.center(30, '*'))
# 指定y和z的值,但是y和z的位置对调
print(test(3, z=2, y=3))结果如下：x is 3, y is 2, z is 3
************我是分割线*************
x is 3, y is 3, z is 2
18如果这样呢？def test(x, y, z): & & # x, y是形参
& &print('x is %d, y is %d, z is %d' % (x, y, z))
& &calc_age = x * y * z
& &return calc_age
# 我指定第一个实参的数值,而不指定y和z的呢?
print(test(x=3, 2, 3))结果如下报错了： &File '/Users/crh/PycharmProjects/app/test.py', line 12
& &print(test(x=3, 2, 3))
& & & & & & & & & ^
SyntaxError: positional argument follows keyword argument如上实例介绍可以得出如下结论：正常情况下，给函数传参数要按顺序，不想按顺序就可以用关键参数，只需指定参数名即可，但记住一个要求就是，关键参数必须放在位置参数之后。&默认参数实例如下：def test(x, y=3, z): & & # x, y是形参
& &print('x is %d, y is %d, z is %d' % (x, y, z))
& &calc_age = x * y * z
& &return calc_age
# 只传两个参数,按照正常逻辑 x=1, y=3, z=3
print(test(1, 3))
# 但是报错了报错如下： &File '/Users/crh/PycharmProjects/app/test.py', line 6
& &def test(x, y=3, z): & & # x, y是形参
& & & & & &^
SyntaxError: non-default argument follows default argumentdef test(x, y, z=3): & & # x, y是形参
& &print('x is %d, y is %d, z is %d' % (x, y, z))
& &calc_age = x * y * z
& &return calc_age
# 只传两个参数,按照正常逻辑 x=1, y=3, z=3
print(test(1, 6))结果如下：x is 1, y is 6, z is 3
18def test(x, z, y=3): & & # x, y是形参
& &print('x is %d, y is %d, z is %d' % (x, y, z))
& &calc_age = x * y * z
& &return calc_age
# 只传两个参数,按照正常逻辑 x=1, y=3, z=3
print(test(3, 2))结果如下：x is 3, y is 3, z is 2
18如上实例可以知道，函数的形参设置默认参数的时候，默认参数应该放到非默认参数后面，否则按照位置参数传入则就会报错，除非传入实参都设置位置参数！上面实例报错分析：&动态参数实例如下：动态参数也称为非固定参数，若你的函数在定义时不确定用户想传入多少个参数，就可以使用动态参数，使用了动态参数你就可以动态扩展，想传入多少参数都行！&1、argsdef test(x, y, *args):
& &print('x is %d, y is %d, z is %s' % (x, y, args))
test(1, 2, 3, 4, 5, 6)结果如下：x is 1, y is 2, z is (3, 4, 5, 6)&def test(x, y, *args):
& &print('x is %d, y is %d, z is %s' % (x, y, args))
& &print(type(args))
test(1, 2) &# 不传入args的值
test(1, 2, (3, 4, 5)) &# 传入一个元组
test(1, 2, [3, 4, 5]) &# 传入一个列表
test(1, 2, {3, 4, 5}) &# 传入一个集合
test(1, 2, {1: 'lucky', 2: 'jack'}) &# 传入一个字典结果如下:x is 1, y is 2, z is ()
&class 'tuple'&
x is 1, y is 2, z is ((3, 4, 5),)
&class 'tuple'&
x is 1, y is 2, z is ([3, 4, 5],)
&class 'tuple'&
x is 1, y is 2, z is ({3, 4, 5},)
&class 'tuple'&
x is 1, y is 2, z is ({1: 'lucky', 2: 'jack'},)
&class 'tuple'&总结：由上面代码可以看出，*args会把多传入的实参变成一个元组的类型；传入其他数据类型也一样，成为元组中的一个元素；另函数中有*args与其他形参的时候，*args一定要写到其他形参的后面，否则传入的实参都会被传入到*args当中打印成元组；还有如果没有多出传入的实参即*args没有值的时候，*args为空，不会报错。&2、kwargsdef test(x, y, **kwargs):
& &print('x is %d, y is %d, z is %s' % (x, y, kwargs))
& &print(type(kwargs))
test(1, 2) &# 不传入kwargs的值
test(1, 2, 3, 4, 5)结果如下：Traceback (most recent call last):
x is 1, y is 2, z is {}
&File '/Users/crh/PycharmProjects/app/test.py', line 11, in &module&
&class 'dict'&
& &test(1, 2, 3, 4, 5)
TypeError: test() takes 2 positional arguments but 5 were givendef test(x, y, **kwargs):
& &print('x is %d, y is %d, z is %s' % (x, y, kwargs))
& &print(type(kwargs))
test(1, 2, name='lucky', age=18, job='IT')结果如下：x is 1, y is 2, z is {'job': 'IT', 'name': 'lucky', 'age': 18}
&class 'dict'&**kwargs会把多出的a=b这种类型的实参打印成字典的类型（要区分开与关键参数的区别，关键参数的实参有对应的形参）test_list = [8, 9, 10, 11]
test_dict = {'name': 'lucky', 'age': '18', 'job': 'it'}
def test(x, y, *args, **kwargs):
& &print('x is %d, y is %d, args is %s, kwargs is %s' % (x, y, args, kwargs))
test(1, 2, test_list, test_dict)结果如下：x is 1, y is 2, args is ([8, 9, 10, 11], {'job': 'it', 'name': 'lucky', 'age': '18'}), kwargs is {}如上所示为什么把把字典传入函数后，打印的**kwargs为空值呢？! &是这样的，传入的字典会被当成一个元素传入函数，所有被当成多余的实参传入到了*args里面，所以**kwargs的值才为空；那么有什么办法可以把字典传入到**kwargs呢？test_list = [8, 9, 10, 11]
test_dict = {'name': 'lucky', 'age': '18', 'job': 'it'}
def test(x, y, *args, **kwargs):
& &print('x is %d, y is %d, args is %s, kwargs is %s' % (x, y, args, kwargs))
test(1, 2, *test_list, **test_dict)结果如下：x is 1, y is 2, args is (8, 9, 10, 11), kwargs is {'name': 'lucky', 'job': 'it', 'age': '18'}这下结果就是我想要的了，所以如果要把列表或者字典放到函数中，指定关键符号就好。&3、局部变量def change_name(name):
& &print('before change:', name)
& &name = '采菊篱下'
& &print('after change', name)
change_name(name)
print('在外面看看name改了么?', name)结果如下：before change: Lucky chen
after change 采菊篱下
在外面看看name改了么? Lucky chen全局与局部变量：在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量；全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序；当全局变量与局部变量同名时，在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。返回值要想获取函数的执行结果，就可以用return语句把结果返回，可以返回任何你想得到的东西，多返回值返回的是一个元组。def test(x, y, z, name):
& &calc_age = x * y * z
& &print(name)
& &return calc_age, name
age = test(3, 2, 3, 'lucky')
print(age, type(age))结果如下：lucky
(18, 'lucky') &class 'tuple'&总结：函数在执行过程中只要遇到return语句，就会停止执行并返回结果，所以&return 语句代表着函数的结束，跟循环中的break一样。如果未在函数中指定return,那这个函数的返回值为None&&递归函数在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。就是把函数体处理的结果，再次传到本函数再次执行。递归特性:必须有一个明确的结束条件每次进入更深一层递归时，问题规模相比上次递归都应有所减少递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）&def calc(n):
& &print(n)
& &if int(n/2) == 0:
& & & &return n
& &return calc(int(n/2))
1下面我们再来看一个斐波那契数列的例子：def func(count, n1, n2): & & & &# 获取斐波那契数列第200个数字并返回给调用者
& &if count == 200:
& & & &return n1
& &n3 = n1 n2
& &r = func(count 1, n2, n3)
& &return r
ret = func(1, 0, 1)
print(ret)
044301函数的作用域再看一个例子：name2 = 'chenronghua'
def say():
& &name = 'lucky'
& &print(name)
& &print(name2)
say()结果为：lucky
chenronghua总结：函数的作用域就是在函数里定义的变量不能被外面使用！但是外部全局定义的全局变量在函数内是可以使用的。
举个例子来说：你在房子里可以看到屋内的东西和房子外的东西，但是你在房子外面就只能看到房子外的东西不能看到房子内的东西！
原因防止在函数调用的时候防止变量冲突！那问题来了，我在外面定义的全局变量在函数内可以改他吗，例子如下：name2 = 'chenronghua'
def say():
& &name = 'lucky'
& &name2 = 'crh'
& &print(name)
& &print('function inside name2 value %s' % name2)
print('function outside name value %s' % name2)结果如下：lucky
function inside name2 value crh
function outside name value chenronghua从上面的例子可以看出函数里面把name2的值改了，但是在外部打印还是没有发生改变，这就是函数作用域的诠释。&如果我就是想改，怎么办呢，可以吗？如下例子所示：name2 = 'chenronghua'
def say():
& &global name2
& &name = 'lucky'
& &name2 = 'crh'
& &print(name)
& &print('function inside name2 value %s' % name2)
print('function outside name value %s' % name2)结果如下：lucky
function inside name2 value crh
function outside name value crh可以看出，是可以做到的，你需要在函数体内利用内置函数global来声明你想作为全局变量的变量。郭德纲坚持分享的人最可爱，转起!我为开源技术社区「带盐」，每天收获一小点，快乐生活一整天！
馆藏&10527
TA的最新馆藏
喜欢该文的人也喜欢编程大神一道题带你搞定Python函数中形参和实参问题编程大神一道题带你搞定Python函数中形参和实参问题情深宝百家号昨天在Python学习群里有位路人甲问了个Python函数中关于形参和实参一个很基础的问题，虽然很基础，但是对于很多小白来说不一定简单，反而会被搞得稀里糊涂。人生苦短，我用Python。人生苦短，我用Python为了解答大家的这个疑惑，小编在此举个栗子，希望大家能够彻底的理解实参和形参在Python中的用法。首先，大家一起看个栗子。不可更改的对象这个函数的输出值是多少？很多人会回答7，其实程序运行之后，其答案是6，点解呢？为什么在这里形参的数值并不改变实参的数值？这里需要给大家普及一个Python中的基础，在python中，string（字符串）, tuples（元组）, 和number（数值）是不可更改的对象，而list（列表）,dict（字典）等则是可以修改的对象。也就是说，这里形参的数值对于外部的实参的数值（number类型，不可变）来说是没有任何关系的，他们虽然是同一个名字，但是其指向对象是不一样的。所以当在程序最后进行打印a输出值的时候，其输出仍然是6。下面这个栗子我们来看看可变的对象，以list（列表）作为实验对象。可更改的对象这个函数的输出值是多少？很多人会回答[1,2]，其实程序运行之后，其答案是[2,1]。与第一个栗子刚刚相反，这里形参的数值调用把实参改变了。因为本例中参数传递的是列表，其是可更改的对象，在函数内部经过系列赋值变化之后，所以在程序运行之后其输出值产生了变化。山重水复疑无路，柳暗花明又一村。这道题经常会被招聘公司和企业拿去作为面试题，考察面试狗的Python基础知识，希望大家好好参详，日后碰到类似的问题加以注意，少走弯路！最后感谢在Python群中积极提问的好学者，然我们大家一起为学好Python而奋斗吧！本文仅代表作者观点，不代表百度立场。系作者授权百家号发表，未经许可不得转载。情深宝百家号最近更新：简介:传承中华五千年历史文化。作者最新文章相关文章在 SegmentFault，学习技能、解决问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。
问题对人有帮助，内容完整，我也想知道答案
问题没有实际价值，缺少关键内容，没有改进余地
包含被调用函数的文件db.py：
import pymysql
conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='asdasd',db='db0')
cur = conn.cursor()
def mysql_insert(date,high,low):
param=[date,high,low]
sql="INSERT INTO au_day (date,high,low) VALUES(%s,%s,%s)"
cur.execute(sql,param)
mysql_insert('',33,44)
#在文件下函数可以正常使用
conn.commit()
cur.close()
conn.close()
调用函数的文件a.py:
import database as db
for line in open("C:\\Users\hang\Desktop\\a.txt"):
# a.txt每一行都是这种格式
# ,230.950,230.990,221.880,223.300,10334
l=line.split(",")
db.mysql_insert(x,y,z) //这里运行后没有向数据库插入任何数据，参数传递单引号什么的我也弄乱了理不清
初次使用python，麻烦大家帮忙看一看怎么改能将a.txt每一行的某些数据插入到数据库中
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
因为库文件名为db.py。所以应该是import db
分享到微博？
关闭理由：
删除理由：
忽略理由：
推广（招聘、广告、SEO 等）方面的内容
与已有问题重复（请编辑该提问指向已有相同问题）
答非所问，不符合答题要求
宜作评论而非答案
带有人身攻击、辱骂、仇恨等违反条款的内容
无法获得确切结果的问题
非开发直接相关的问题
非技术提问的讨论型问题
其他原因（请补充说明）
我要该，理由是：
在 SegmentFault，学习技能、解决问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。在 SegmentFault，学习技能、解决问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。
问题对人有帮助，内容完整，我也想知道答案
问题没有实际价值，缺少关键内容，没有改进余地
def createPlot():
fig = plt.figure(1, facecolor = 'white')
createPlot.ax1 = plt.subplot(111, frameon = False)
plotNode('nonLeafNode', (0.2, 0.1), (0.4, 0.8), nonLeafNodes)
plotNode('LeafNode', (0.8, 0.1), (0.6, 0.8), leafNodes)
plt.show()
createPlot()
代码里的createPlot.ax1是什么意思？之前没见过这么用过，请教了！
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
python中一切皆对象
相当于给这个对象加了一个attr
分享到微博？
关闭理由：
删除理由：
忽略理由：
推广（招聘、广告、SEO 等）方面的内容
与已有问题重复（请编辑该提问指向已有相同问题）
答非所问，不符合答题要求
宜作评论而非答案
带有人身攻击、辱骂、仇恨等违反条款的内容
无法获得确切结果的问题
非开发直接相关的问题
非技术提问的讨论型问题
其他原因（请补充说明）
我要该，理由是：
在 SegmentFault，学习技能、解决问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。