大家好，我是讯享网，很高兴认识大家。

 

1 函数 function

1）什么是函数：

      函数是可以重复执行的代码块，可以重复使用

2）作用：

定义用户级的函数

3）语法：

def 函数名（参数列表）：

语句块·····

语法说明：

a)      函数名是语句块的名称

b)      函数名的命名规则与变量名相同（标识符）

c)       函数的名字是一个变量，是绑定代码块的名称

d)      函数有自己命名空间，要让函数处理外部数据需要用参数给函数传入一些数据，如果不需要传入参数，参数列表为空

e)      语句块部分不能为空，如果为空需要填充pass语句

示例：

def  say_hello():

   print("hello world")

   print("hello tarena")

   print(0 + 19)

 

say_hello()          #执行正常

say_hello = 10

print(say_hello)        #执行正常

say_hello()                   #执行错误

解释：函数名和变量名相同，可以随意赋值，但是一般情况不能修改函数名

示例：

a=1000

b=129

def  mysum(a,b):

   print("调用　mysum(%s ,%s)" %(a,b))

mysum(10,10000)  #’’’调用　mysum(10,10000)" 此时a，b是实参 ，对函数之上的全局变量不管’’’

          解释：函数有自己命名空间，要让函数处理外部数据需要用参数给函数传入一些数据

 

4）函数的调用

函数名（参数列表）

调用说明：

a)      函数调用是一个表达式

b)      如果没有return语句，函数执行完毕后返回None对象

c)       如果函数需要返回其它的值对象需要用return语句

 示例：

   >>>def  h():

...    print("调用",h())   #··· 是要保持和>>>匹配，提示可以#在此输入

...

>>>         #返回None对象

 

return 语句

语法：

  return [表达式]

  [] 可省略

作用：结束当前函数的执行，返回到调用该函数的地方，同时返回一个值对象的引用关系

语法说明：

a)      return 语句后跟的表达式可以省略，省略后相当于return None

b)      如果函数内没有return语句，则函数执行完最后一条语句后返回None（相当于在最后一条return None语句）

c)       函数的调用可以返回一个值或一组值

示例

defsummmer(a,b):

    print(a+b)

    return '调用　　'*(a+b)

 

_qiuhe_=summmer         #变量名一样使用

 

print(_qiuhe_(1,2))          # 3 有返回值时，打印内容

          示例2

                 deffun2():

                    return

                    print('最后一行')            

 

r = fun2()

print(r)               #None  注意return之后的函数语句不再执行

函数的参数传递

1）传递方式：

a)      位置传参

b)      *序列传参

c)       关键字传参

2）位置传参

     实际参数的对应关系与形式参数的对应关系是以位置来一次对应的

   示例1

          defsum3(a,b,c):

                 returna+b+c

          x= sum3(1,2,3)

          解释： 1实参 对应 a形参

位置传参说明：

          实参和形参通过位置进行对应和传递

          实参和形参的个数必须完全相同

3）序列传参

序列的元素个数必须与列表的个数相同

示例1

def myfun(a,b,c):

   print("a--->",a)

   print("b--->",b)

   print("c--->",c)

 

#位置传参

myfun(1,2,3)

 

#序列传参  字符串，列表，元组

#如果序列所含元素和函数参数个数不对应可以而切片

s1=[4,5,6]

myfun(*s1)

 

s2="ABC"

myfun(*s2)

4）关键字传参

   关键字传参是指传参时，按照形参的名称给形参赋值，实参和形参按照名称进行匹配

   数量必须对应

   defmyfun(a,b,c):

   print("a--->",a)

   print("b--->",b)

   print("c--->",c)

 

#位置传参

myfun(1,2,3)

 

#序列传参  字符串，列表，元组

#如果序列所含元素和函数参数个数不对应可以而切片

s1=[4,5,6]

myfun(*s1)

 

s2="ABC"

myfun(*s2)

 

#关键字传参：

myfun(b=100,a=200,c=700)

5)字典关键字传参

实参和形参通过字典进行传递和匹配，字典的值传递给键对应的形参

说明：

   字典传参的键名和形参名必须一致

   键名必须为字符串

   键名要在形参中存在

示例：

#字典关键字传参  dict

d = {'a':10,'b':20,'c':30}

myfun(d)

6)综合传参

四种传参方式，打套组合拳

示例：

def myfun(a,b,c):

   print("a--->",a)

   print("b--->",b)

   print("c--->",c)

 

#综合传参

myfun(*[1], *(200,300))

print()

myfun(100, c=90, b=6)

print()

myfun(100, *(200, 300))

print()

myfun(100, {'b': 20,'c': 30})

print()

myfun(*(100,), {'b': 2, 'c': 3})

print()

myfun(*('A'),{'c': 7}, b=9)

以下是错误 

#位置参数之后不能跟关键字参数

# myfun(c=90,b=6,50)

函数的定义（创建函数或函数形参）

1）函数的缺省参数

（1）语法：

def 函数名（形参1=默认参数1，形参2=默认参数2······）

  语句块

（2）示例：

def  info(name,age=1, addr='不详'):

      print('姓名',name,'年龄',age,'住址',addr)

#调用

info("无所谓", addr="不管")

info("观世音", age=, addr="南海")

info("常侍")

（3）缺省参数说明：

a)    缺省参数必须从右之左依次存在，如果一个参数有缺省值，则其右侧的所有参数都必须有缺省参数（缺省值）

b)    缺省参数可以有0个或1个及以上，甚至全部是缺省参数

（4）错误缺省参数函数

def  fn(a, b=10,c): pass

def  fn(a=1,b, c=5): pass

2) 星号元组形参

（1）语法：

   def函数名（*元组形参名）：

          语句块

（2）示例：

 

  

def myfum(*args):     print("实参个数是", len(args))     print(args) for x in args:           print(x)     myfum(2, 5)   执行结果 实参个数是 2 (2, 5) 2 5

myfum("100", 200, "Tree", 4.4) 执行结果 实参个数是 4 ('100', 200, 'Tree', 4.4) 100 200 Tree 4.4

 

3) 命名关键字形参

（1）语法：

          def  函数名（*，命名关键字形参名）：

                  语句块

          或

          def  函数名（*args，命名关键字形参名）：

                 语句块

（2）示例：

          示例1：

          defmyfun1（a,b,*,c）: #c为命名关键字

                 print(a,b,c)

          myfun1（1,2，c=3）

          myfun1（11,12,33）#错误，必须指明关键字，不能位置传参

 

示例2

 

def myfun2（a,*args,b,c）:      #b,c是关键字形参，传参数是只能#按照关键字进行传参

myfun2(1,2,3,4)  #错误

myfun2（1,2，b=3,c=4） #（1，（2，），3,4）

4）双星号字典形参

 （1）语法

   def函数名（字典形参名）

          语句块

（2）示例

   defmyfun(kwargs):

      print("参数个数", len(kwargs))

     for k,v in kwargs.items():

       print(k, "--->", v)

 

 

# 调用

myfun(name="tarena", age=15) #与dict(kwagrs)生成非空字典相同

          注意：字典形参的格式，写入一个字典参数{}，会报错

执行结果参数个数 2

name ---> tarena

age ---> 15     

5) 函数的参数列表顺序：

   位置形参，缺省参数，星号元组形参，双星号字段形参，命名关键字参数可以混合使用

函数参数自左向右的顺序为

   位置形参，星号元组形参，命名关键字参数，双星号字典形参

例：

   deffn（a,b,*args,c,kwargs）:

          print(a,b,args,c,kwargs)

 fn(1,2,3,4,c=5,name=”tarena”,age=15)

可变/不可变的实参的参数传递区别

可变数据类型（关键在于可增加）

                list  dict set

不可变类型

         float int str ········

1)可变/不可变数据类型区别：

  不可变的类型的数据作为函数参数传入时，函数内部不会改变变量的元数据值，是安全的

  可变类型的数据作为参数穿入时，函数内部可以改变元数据，多用来返回更多数据结果

2）问题

函数只能通过返回值传回数据吗？

不是，还可以通过返回可变数据类型

示例

示例1

l = []

def fn(x):

   x.append(10)

fn(l)

print(l) #结果

讯享网

示例2

d = {}

def fn(x):

   x["name"] = 'tarena'

 

fn(d)

print(d)   #{'name': 'tarena'}

示例3

t = (1,2,3)

 

def fn(x):

   x[1] = 2.2

 

 

print[t]

fn(t)       #执行报错TypeError: 'tuple'object does not support #    item assignment

print(t)

示例4

t = (1,2,3)

 

def fn2(x):

    x= (4,5,6)

   return x

 

print(t)

 

print(fn2(t))

print(t)

 

函数执行结果：

(1, 2, 3)

(4, 5, 6)

(1, 2, 3)

 

示例5

t = (1,2,3)

 

def fn2(x):

    x= (4,5,6)

 

print(t)

 

print(fn2(t))

print(t) 

执行结果：

(1, 2, 3)

None

(1, 2, 3)

示例6

t = (1, 2, 3)     def fn2(x):     x += (4, 5, 6)     return x     print(t)   print(fn2(t)) print(t) 执行结果 (1, 2, 3) (1, 2, 3, 4, 5, 6) (1, 2, 3)	l = [1,2,3]   def fn2(x):     x += [4,5,6]     x.append([4,5,6])     return x   print(l)   print(fn2(l)) print(l) 执行结果 [1, 2, 3] [1, 2, 3, 4, 5, 6, [4, 5, 6]] [1, 2, 3, 4, 5, 6, [4, 5, 6]]
l = [1,2,3]   def fn2(x):     x = [4,5,6]     x.append([4,5,6] )     x+=[4]     return x   print(l) print(fn2(l)) print(l) 执行结果 [1, 2, 3] [4, 5, 6, [4, 5, 6], 4] [1, 2, 3]

 

函数嵌套

1）定义

函数嵌套

是指一个函数里用语句来创建其它函数的情况

函数变量

   函数名是变量，它是创建函数时绑定一个函数

2）函数变量示例：

def fn():

    print("hello")

 

dn = fn

dn()                       #结果 hello

3）嵌套示例：

def fn_order():

   print("外部函数")

 

   def cn_inner():

       print("fn_inner被调用")

 

   cn_inner()

 

 

fn_order()

注意：函数只有调用时才能被执行，如果把cn_inner()这句代码去掉则不会执行内部函数

6函数作为函数的返回值

示例：

def getfn():

   def print_hello():

       print("Hello")

   return print_hello

 

fn=getfn() #fn =print_hello地址 <functiongetfn.<locals>.print_hello at 0x7f45e6747c80> 

fn()                         #fn()    函数名是变量

执行结果

hello

 

 

def getfn():

   def print_hello():

       print("Hello")

   return print_hello()

 

fn=getfn()                      

执行结果：

  Hello

None

 

 

 

 

 

 

 

 

 

 

 

 

 

7函数作为函数的参数传递

   示例

def tab(x, y): return "|"+x.center(13)+"|"+\ y.center(13)+"|"     def stri(x, y):     return "姓名："+str(x)+'  age:'+str(y)     def myprint(fx, x, y):     print(fx(x, y))     myprint(tab, "tarena", "15") myprint(tab, "abc", "19") myprint(stri,"def","24") myprint(stri,"good","65") 执行结果 |    tarena   |      15     | |     abc     |      19     | 姓名：def  年龄:24 姓名：good  年龄:65

全局变量和局部变量

1）局部变量:

定义在函数内部的变量（包含函数参数）

函数执行时存在，函数执行完后即销毁

2）全局变量:

定义在函数外部，模块内部的变量

一直存在，除非调用del函数

3）示例

v = 100    #全局变量     def fn():     v =200  局部变量     print(v) fn() print(v)   执行结果 200 100	v = 100      def fn(v):     v +=200     print(v) fn(v) print(v)     执行结果 300 100
def func():     global v     v=100 func() print(v)   注意先后顺序 执行结果： 100

python作用域

1）作用域定义

也叫名字空间，是变量访问的时候查找变量名的范围空间

2）示例

v = 100      def fn():     print(v) fn() print(v) 执行结果 100 100 先从里面找，找不到往外扩散找

3）四种作用域

局部作用域（函数内） Local  L

外部嵌套函数作用域  Enclosing function locals E

函数定义所在模块（文件）的作用域 全局作用域 Global(module) G

python内置模块的作用域   Builtin（python）B

4）变量名的查找规则

在访问变量时，先查找本地变量，然后是包裹此函数的外部函数的函数内部的变量，之后是全局变量，最后是内置变量

L -------->  E -----------> G  ---------->B

示例

v = 100         #全局作用域G   查找