88bifa必发唯一官网 10

Python函数基础

函数的定义def

一 为何要有函数?

函数:指将一组语句的集合通过一个名字(函数名)封装起来,要想执行这个函数,只需调用其函数名即可。

def 函数名(参数):

不加区分地将所有功能的代码垒到一起,问题是:

def sayhi( ):  # 函数名

    pass(函数体)

  代码可读性差
  代码冗余
  代码可扩展差

    print(‘hello world’)

    return

如何解决?
  函数即工具,事先准备工具的过程是定义函数,拿来就用指的就是函数调用

sayhi( ) #调用函数 ,
调用函数时要加上括号(), 不加的话调用的是定义函数名的那个内存地址 

注,如果函数没有return,则返回none.同时也要注意顺序,要先定义再引用。return后的所有语句都不会被执行。当返回多个值时,直接用逗号隔开。如return
x,y,z

  结论:函数使用必须是:先定义,后调用

示例:

参数有形参,实参.
 在函数的使用中,有默认参数与指定参数。默认参数在定义函数时就已经给定了,但在引用时可对默认参数进行覆盖,有默认参数的函数在引用时也可不给参数。指定参数是在函数引用时对定义的参数给指定参数,此时顺序不一定和定义时的参数顺序一至。 

python中函数定义方法:

#普通代码:

 

    def test(x):
    ”The function definitions”
    x+=1
    return x

a,b = 5,8  # 这句话的意思是给两个变量a,b 分别赋值5和8, 即 a= 8, b=8

函数返回多值实例

  def:定义函数的关键字
  test:函数名
  ():内可定义形参
  ””:文档描述(非必要,但是强烈建议为你的函数添加描述信息)
  x+=1:泛指代码块或程序处理逻辑
  return:定义返回值

c= a**b

def tngh(x,y):

调用运行:可以带参数也可以不带
函数名()

print(c)

    a=x*9+6

 

#改成用函数写:

    b=y+61-8

二:函数的分类

def calc(x,y) :

    return a,b

  1.内置函数:built-in
  2.自定义函数:
    def 函数名(参数1,参数2,…):
      ”’注释”’
      函数体

    res = x**y

restngh=tngh(6,9)      此句也可写为res1_tngh,res2_tngh=tngh(6,9)      
       此处restngh,res1_tngh,res2_tngh为任一变量名         

函数的使用:先定义,后调用
如何定义函数之定义函数的三种形式
1
定义无参函数
:函数的执行不依赖于调用者传入的参数就能执行时,需要定义为无参函数

    return res #返回函数执行结果

print(restngh[0],restngh[1])  同上   print(res1_tngh,res2_tngh)

def print_tag():
print(‘*************************’)

c= calc(a,b)  #结果赋值给c变量

def main():
print_tag(‘*’,20,3)
print_msg(‘hello world’)
print_tag(‘*’,20,3)

print(c)

main()

 

2
定义有参数
:函数的执行需要依赖于调用者传入的参数才能执行时,需要定义为有参函数

特性:

def print_tag(tag,count,line_num):
for i in range(line_num):
print(tag*count)

  1. 减少重复代码

  2. 使程序变得可扩展

  3. 使程序变得易维护

3 定义空函数:函数体为pass

 

def func(x,y,z):
pass

函数参数:

三:函数的使用原则
  函数的使用必须遵循:先定义后使用的原则
  函数的定义,与变量的定义是相似的,如果没有事先定义函数而直接引用就相当于在引用一个不存在变量名  

参数能让你的函数更灵活,还可以根据调用时传参的不同来决定函数内部的执行流程

#定义阶段:只检测语法,不执行代码

形参变量:

def func():
if 1>2
print(‘hahahahahahah’)
def func():
      #语法没问题,逻辑有问题,引用一个不存在的变量名
asdfasdfasdfasdfasdf

只有在被调用时才分配内存单元,在调用结束时,即可释放所分配的内存单元。因此,形参只在函数内部有效。函数调用结束返回主调函数后则不能再使用该形参变量。

#调用阶段

实参:

foo()

可以是常量、变量、表达式、函数等,无论实参是何种类型的量,在进行函数调用时,他们都必须有确定的值,以便把这些值传送给形参,因此应预先用赋值、输入等办法使参数获得确定值。

返回值:可以返回任意类型

如:

没有return:None
return value: value
return val1,val2,val3 :(val1,val2,val3)

def calc(x,y):    #x和y 就是形参

return的效果:只能返回一次值,终止函数的执行

    res = x**y

返回值:

    return res

   返回值数=0:返回None

c= calc(a,b)   #a和b就是实参

   返回值数=1:返回object

print(c)

   返回值数>1:返回tuple

 

四:函数参数

默认参数:

88bifa必发唯一官网 1

如下面的程序:

1.形参变量只有在被调用时才分配内存单元,在调用结束时,即刻释放所分配的内存单元。因此,形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量

88bifa必发唯一官网 2

2.实参可以是常量、变量、表达式、函数等,无论实参是何种类型的量,在进行函数调用时,它们都必须有确定的值,以便把这些值传送给形参。因此应预先用赋值,输入等办法使参数获得确定值

发现country这个参数
基本都是“CN”,我们可以把country设置成默认参数,默认成CN。
这样,这个参数在调用时你不指定,那就默认是CN,你指定了的话,就用你指定的值。

3.位置参数和关键字(标准调用:实参与形参位置一一对应;关键字调用:位置无需固定)

如:

4.默认参数

88bifa必发唯一官网 3

5.参数组

注:默认参数的位置要放到位置参数(按顺序的参数)后面,避免它影响其他的位置参数。

函数参数分类:

 

 1、位置参数(形参、实参)

关键参数:

位置参数:按照从左到右的顺序依次定义的参数
  def foo(x,y):
  print(x)
  print(y)
按位置定义的形参,必须被传值,多一个不行,少一个也不行
  foo(1,2,3)===>报错
按位置定义的实参,与形参一一对应
  foo(2,10)

正常情况下,给函数传参数要按顺序,不想按顺序就可以用关键参数,只需在调用时指定参数名即可(指定了参数名的参数就叫关键参数),但有一个要求,关键参数必须放在位置参数(以位置顺序确定对应关系的参数)之后。

2、关键字参数 (实参)

如下面的程序:

关键字参数:实参在定义时,按照key=value形式定义
  def foo(x,y):
  print(x)
  print(y)
  # foo(y=10,x=1)
  foo(y=10,x=1)
#关键字参数可以不用像位置实参一样与形参一一对应,指名道姓地传值

88bifa必发唯一官网 4

  #  foo(1,z=20,10)  
===>报错

调用时可以这样:

  # foo(1,y=2,z=10)
 
===>报错**

88bifa必发唯一官网 5

注意的问题一:位置实参必须在关键字实参的前面
注意的问题二:实参的形式既可以用位置实参又可以是关键字实参,但是一个形参不能重复传值

在调用时course、age、country都指定了,他们就是关键参数。指定了之后就可以按照关键参数指定的内容来调用函数,而不需要再根据位置来给形参赋值。

 3、默认参数(形参)

 

默认参数:在定义函数阶段,就已经为形参赋值,定义阶段有值,调用阶段可以不用传值

但调用时不能这样:

定义:

88bifa必发唯一官网 6

# def func(x,y=10):
# print(x)
# print(y)

因为‘PY’指定了参数名course,而22没有指定参数名,它还是位置参数,关键参数必须放在位置参数后面。

调用:

也不能这样:

# func(1,20)
# func(1)

88bifa必发唯一官网 7

# def func(y=10,x):
# print(x)
# print(y)

因为22已经按照位置参数给age赋值成了22,
但后面的age=25又给age赋值了25,不能给同一个参数赋多个值

 形参的应用:值经常变化的需要定义成位置形参,值大多数情况下都一样,需要定义成默认参数

 

默认参数需要注意的问题一:必须放在位置形参后面
默认参数需要注意的问题二:默认参数通常要定义成不可变类型
默认参数需要注意的问题三:默认参数只在定义阶段被赋值一次

88bifa必发唯一官网,非固定参数:

4、可变长参数

如果你的函数在定义时不确定用户想传入多少个参数,就可以使用非固定参数。

可变长参数:可变长指的是实参的个数不固定

def stu_register(name,age,*args):  # *args会把传入的参数变成一个tuple(元祖)形式
    print(name,age,args)

stu_register('alex',22) # 输出结果: # alex 22 () #后面这个()就是args,只是因为没传值,所以为空  stu_register('jack',32,'CN','Python') # 输出结果: # jack 32 ('CN', 'Python')

# 以上是传递方式1。


#传递方式2:
stu_register('jack',32,*['CN','Python'])   # 直接把要传递的元素放在一个列表(或者元祖)里面,列表(或元祖)前面加 * , 这样列表(或元祖)中的元素就会传给*args,并成为*args这个元祖中的元素。

# 输出结果:
# jack 32 ('CN', 'Python')

# 这种方法有个需要注意的地方: 列表(或元祖)前面没有加*。 以下分析这种情况:

stu_register('jack',32,['CN','Python'])   # 列表前面没有加*, 这个列表传递给*args的时候,会被当成*args这个元祖中的第一个元素。这显然不是我们想要的,我们想要的是这个列表中的每个元素成为*args这个元祖中的元素。

# 输出结果:
# jack 32 (['CN', 'Python'],)    #  列表变成了元祖中的第一个元素。

按位置定义的非关键字可变长度的实参:*     *args

 

按关键字定义的可变长度的实参:**        **kwargs

还有一个是 **kwargs

非关键字可变长度的实参:*

def stu_register(name,age,*args,**kwargs):  # **kwargs会把传入的多个参数变成一个字典形式
    print(name,age,args,kwargs)

stu_register('jack',32,'CN','Python')

# 输出结果:
# jack 32 ('CN', 'Python') {}   # 后面这个{}就是kwargs,只是因为没有传值,所以为空

stu_register('jack',32,'CN','Python',gender='Male',province='Shandong')

# 输出结果:
# jack 32 ('CN', 'Python') {'gender': 'Male', 'province': 'Shandong'}

定义一个函数的时候,必须要预先定义这个函数需要多少个参数(或者说可以接受多少个参数)。一般情况下这是没问题的,但是也有在定义函数的时候,不能知道参数个数的情况(想一想C语言里的printf函数),在Python里,带*的参数就是用来接受可变数量参数的。看一个例子

注: agrs: arguments ; kwargs: key word arguments。 
如果形参中前面出现了 *,就变成元祖; 如果形参前面出现了 **
,这个形参就变成了字典,也可以把一个字典(如:info)直接传到kwargs里面,
不过要在函数调用时在字典前面加上 **(如 **info)

def funcD(a, b, *c):
  print a
  print b
  print “length of c is: %d ” % len(c)
  print c
调用funcD(1, 2, 3, 4, 5, 6)结果是
1
2
length of c is: 4
(3, 4, 5, 6)

另外,位置参数不能放在非固定参数后面,但关键参数可以位于*args这种非固定参数后面。

  前面两个参数被a、b接受了,剩下的4个参数,全部被c接受了,c在这里是一个tuple。我们在调用funcD的时候,至少要传递2个参数,2个以上的参数,都放到c里了,如果只有两个参数,那么c就是一个empty
tuple。

def stu_register(name,age,*args,gender):
    print(name,age,args,gender)

stu_register('jack',32,'CN','Python',gender='male')

# 输出结果:
# jack 32 ('CN', 'Python') male

 

 

 关键字定义的可变长度的实参:**

 

  如果一个函数定义中的最后一个形参有 **
(双星号)前缀,所有正常形参之外的其他的关键字参数都将被放置在一个字典中传递给函数,比如:

函数返回值:

def funcF(a, **b):
  print a
  for x in b:
    print x + “: ” + str(b[x])
调用funcF(100, c=’你好’, b=200),执行结果
100
c: 你好
b: 200

函数外部的代码要想获取函数的执行结果,就可以在函数里用return语句把执行结果返回。(谁调用它就返回给谁)

  大家可以看到,b是一个dict对象实例,它接受了关键字参数b和c。

如:

结合一起使用:

def stu_register(name,age,course='Python',country='CN'):
    print('学员信息表'.center(50,'-'))
    print('Name:',name)
    print('Age:',age)
    print('Course:',course)
    print('Country:',country)
    if age >= 18:
        return True
    else:
        return False

status = stu_register('王山炮',22,course='Python全栈开发',country='JP')   #程序在调用完函数stu_register之后会把True或者False的执行结果返回给这个调用函数并赋值给给变量status

if status:
    print('注册成功')
else:
    print('年龄太小')

# def wrapper(*args,**kwargs): #可以接受任意形式,任意长度的参数
# print(args)
# print(kwargs)
#
#
# wrapper(1,2,3,3,3,3,3,x=1,y=2,z=3)  
===>(1,2,3,3,3,3,3,)   {‘x’:1,’y’=2,’z’=3}

注:

命名关键字参数:定义在*后的形参,必须被传值,而且要求实参必须是以关键字的形式来传值

  • 函数在执行过程中只要遇到return语句,就会停止执行并返回结果,so
    也可以理解为 return 语句代表着函数的结束

  • 如果未在函数中指定return,那这个函数的返回值为None

  • return 只能返回一个值,如果想返回多个值,可以在中间加逗号(,),
    但返回的值都在一个元祖中(所以说还是返回一个值),如果return的是一个列表,那返回的结果就是一个列表形式(不再是元祖),元祖return的直接就是元祖

即:

 

  形参:  *args,z=10

 局部变量:

或:

  •  在函数中定义的变量称为局部变量,在程序一开始定义的变量称为全局变量
  • 全局变量的作用域是整个程序,局部变量的作用域是定义该变量的函数
  • 当全局变量和局部变量重名时,在定义局部变量的函数内,局部变量起作用;在其他地方全局变量起作用。
    如果局部变量跟你全局变量重名并且在函数内这个变量没有赋值,那么这个局部变量可以调用全局变量的值,也就是说局部变量在函数内的优先级先于全局变量。但是全局变量不能调用局部变量

  实参:z=10

假如全局变量是
字典、列表、集合,如果在函数内的重名的局部变量有被重新赋值,那么在函数内部这个局部变量使用在函数内被赋的值,并且不会对函数外的这个全局变量的值有影响;如果在函数内这个局部变量没有被赋值,并且在函数内对它进行了增、删、修改,那么在函数外部这个全局变量也会被增、删、修改。但是全局变量如果是字符串、数字,那么就不能通过修改局部变量的方式来改变全局变量。

# def func(x,y=1,*args,z,**kwargs):
# print(x)
# print(y)
# print(args)
# print(z)
# print(kwargs)
#
# func(1,2,3,4,5,z=10,a=1,b=2)

如果必须想修改全局变量,就用 global, 如:

 结果:

name= 'alexander'

def change_name():
    global name   # global 在函数内部声明全局变量
    name = 'alex'
    print(name)

change_name()
print(name)

# 输出结果: 
#alex
#alex

88bifa必发唯一官网 8

 

 

注:实际项目中尽量不要用global这种方式去声明全局变量。

# def func(x,*args,z=1,**kwargs):
# print(x)
# print(args)
# print(z)
# print(kwargs)
#
# func(1,2,3,4,5,a=1,b=2,c=3)

 

 结果:

88bifa必发唯一官网 9

 

 总结:形参:位置形参,默认参数,*args,命名关键字参数,**kwargs

 五、函数嵌套

#函数的嵌套调用
#
# def max2(x,y):
# if x > y:
# return x
# else:
# return y
#
# def max4(a,b,c,d):
# res1=max2(a,b) #23
# res2=max2(res1,c) #23
# res3=max2(res2,d) #31
# return res3
#
#
# print(max4(11,23,-7,31))

#函数的嵌套定义
def f1():
def f2():
def f3():
print(‘from f3’)
print(‘from f2’)
f3()
print(‘from f1’)
f2()
# print(f1)
f1()

”’
from f1
from f2
from f3

”’

函数对象:

88bifa必发唯一官网 10

 

 六、命名空间

名字空间:存放名字与值的绑定关系

名称空间分为三种

  内置名称空间:python解释器自带的名字,python解释器启动就会生成

  全局名称空间:文件级别定义的名字都会存放与全局名称空间,执行python文件时会产生

  局部名称空间:定义在函数内部的名字,局部名称空间只有在调用函数时才会生效,函数调用结束则失效

三者的加载顺序:内置名称空间->全局名称空间->局部名称空间

三者的取值顺序:局部名称空间->全局名称空间->内置名称空间

七、作用域

作用域:

作用范围:

全局作用域:内置名称空间与全局名称空间的名字属于全局范围,
        #在整个文件的任意位置都能被引用,全局有效
局部作用域:局部名称空间的名字属于局部范围,
        #只在函数内部可以被引用,局部有效

作用域在定义函数时就已经固定住了,不会随着调用位置的改变而改变

 1 name='alex'
 2 def foo():
 3     name='lhf'
 4     def bar():
 5         name='wupeiqi'
 6         print(name)
 7         def tt():
 8             name='hedeyong'
 9             print(name)
10         return tt
11     return bar
12 
13 func=foo()
14 func()()       #==> bar()() ==>tt()
  '''
  hedeyong
  '''