python 函数(function)、函数(def)、函数(return)

函数  function

什么是函数：
　　函数是能够重复执行的语句块，能够重复使用
　　函数是面向过程编程的最小单位

函数的做用：
　　1.用于封装语句块，提升代码的重用性
　　2.定义用户级别的函数

def 语句  （把编码打包） call（调用）

语法：
　　def函数名（形参列表）：
　　语句块（代码块）
说明：
　　1.函数的名字就是语句块的名称
　　2.函数名的命名规则与变是一名相同（函数名必须为标识符）
　　3.函数名是一个变量（不要轻易对其赋值）
　　4.函数有本身的名字空间，在函数外部不能够访问函数内部的变量（注意）在函数内部能够访问函数外部的变量，要让函数处理外部的数据须要传入一些数据
　　5.函数若是不须要传入参数，则参数列表能够为空
　　6.语句部分不能为空，若是为空须要填充pass语句
做用：
　　用于建立函数，用函数名这个变量绑定这个函数

# 示例见：
# 此示例示意用def语句定义一个没有参数的函数
def say_hello():
    print("hello world!")
    print("hello china!")
    print("hello tarena!")

函数的调用表达式：
　　函数名（实际调用传递参数）

说明：
　　函数调用是一个表达式
　　若是没有return语句，函数执行完毕后返回None对象

# 示例见：
# 此示例示意用def语句来定义带有参数的函数
# 此函数名为mymax，有两个形式参数a，b 用于接收实参的传递
# 此函数计算两个参数的最大值并打印
def mymax(a,b):
    print("a=",a)
    print
    ("b=",b)
    if a>b:
        print(a,"大于",b)
    else:
        print(a,"小于",b)
mymax(100,200)    #函数调用

练习：

# 3 写一个函数myadd，此函数中的参数列表里有两个参数x，y此函数的功能是打印 x+y的和
# 如：
#    def myadd(...):
#        ...# ... 部分本身实现
#    myadd(100,200)   #打印300
#    myadd（"ABC","123"）  #打印 ABC123

def myadd(x,y):
    z = x +y
    print("和是",z)
myadd(100,200)   # 打印 300
myadd("ABC","123")   # 打印ABC123




# 写一个函数print_event,传入一个参数n表明终止的整数，打印0~n 之间全部的偶数
# 如：
#　　def print_event(n):
#　　　　....此处本身完成
#　　print_even(10)
#　　打印：
#　　0 2 4 6 8


# 方法1
def print_event(n):
for x in range(n):
　　if x % 2==0:
　　　　print(x)
print_event(10)

# 方法2
def print_event(n): 
for x in range(0,n+1,2):
　　print(x)
print_event(10)

return 语句：

语法：
　　return[表达式]
　　注：[]表明其中的内容可省略
做用：
　　用于函数中，结果当前函数的执行，返回到调用该函数的地方，同时返回
一个对象的引用关系
说明：
　　1.return 语句先执行右侧的表达式，再将表达式的执行结果送回给当前函数的调用者
　　2.return 语句右侧的表达式能够省略，省略后至关于 return None
　　3.若是函数内没有return语句，则函数执行完最后一条语句后返回None）
　　（至关于在最后加了一条return None语句）

# 示例见：
# 此示例示意return语句在函数中的应用
def say_hello2():
    print("hello aaa")
    print("hello bbb")
    #return 1+ 2  #等同于 return None
    return [1,2,3,4,5]
    print("hello ccc")
v = say_hello2()
print("v=",v)

v2 = say_hello2()
print("v2=",v2)

练习：

# 1.写一个函数mymax，实现返回两个数的最大值：
#    如：
#        def mymax(a,b):
#             ...
#    print(mymax(100,200))#200
#    print(mymax(100,200))#ABCD

# 方法1
def mymax(a,b):
    s = max(a,b)
    return s
print(mymax(100,200))
print(mymax("ABC","ABCD"))


# 方法2
def mymax(a,b):
    zuida = a
    if b > zuida:
        zuida = b
        return zuida
print(mymax(100,200))
print(mymax("ABC","ABCD"))


# 2.写一个函数myadd，实现给出两个数，返回这个两个数的和
# 如：
#    def myadd(x,y):
        ....
#    a = int(input("请输入第一个数："）
#    b = int(input("请输入第二个数："）
#    print("你输入的两个数的和是：",myadd(a,b))


def myadd(x,y):
    return x+y
a = int(input("请输入第一个数："))
b = int(input("请输入第二个数："))
print("你输入的两个数的和是：",myadd(a,b))


# 3.写一个函数，input_number
#    def input_number():
#    ...# 此处本身实现，此函数返回列表
#    此函数用来获取用户循环输入往返整数，当用户输入负数时结束输入
#    将用户输入的数字以列表的形式返回，再用内建函数max，min，sum
#    求出用户输入的最大值，最小值以及和

#   L = input_number()
#   print("用户输入的最大数是：",max(L))
#   print("用户输入的最小数是：",min(L))
#   print("用户输入的所有数的和是：",sum(L))

def input_number():
    # 1.建立空列表
    l = []
    # 2.循环读取用户输入的正整数，存入在述列表
    while True:
        n = int(input("请输入用户数字："))
        if n<0:
            break# 此处本身实现，此函数返回列表
        l.append(n)
    # 3.返回上述列表的引用关系
    return l
L = input_number()
print("用户输入的最大数是：",max(L))
print("用户输入的最小数是：",min(L))
print("用户输入的所有数的和是：",sum(L))

 python函数的参数传递（把数据给函数）

传递方式：
　　位置传参
　　序列传参
　　关键字传参
　　字典关键字传参

位置传参：
　　实际参数（实参）的对应关系与形式参数（形参）的对应关系是按位置来依次对应的
示意：

def mymin（a，b，c）
    pass
mymin（1,2,3）

说明：
　　实际参数和形式参数经过位置进行传递和匹配
　　实际参数的个数必须与形式参数的个数相同

# 示例：
# 此示例示意位置传参
def myfunl(a,b,c):
    "这是一个函数的传参的示例"
    print("a的值是：",a)
    print("b的值是：",b)
    print("c的值是：",c)

myfunl(1,2,3)  # 1 --- a  2 ----b  3----c
myfunl(4,5,6)

序列传参
　　序列传参是指在函数调用过程当中，用*将序列拆解后按位置进行传递的
传参方式

# 示例见：
# 此示例示意序列传参
def myfunl(a,b,c):
    "这是一个函数的传参的示例"
    print("a的值是：",a)
    print("b的值是：",b)
    print("c的值是：",c)

l1=[11,22,33]
t2=(100,200,300)
s3="ABC"
myfunl(l1[0],l1[1],l1[2])  # li[0](将11)---> a, L1[1]
myfunl(*l1) # 等同于myfunl(l1[0],l1[1],l1[2]) 
myfunl(*t2)
myfunl(s3[0],s3[1],s3[2])
myfunl(*s3)

# 说明：
　　# 序列传参时，序列拆解的位置将与形参一一对应

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

# 示例见；
# 此示例示意关键字传参
def myfunl(a,b,c):
    "这是一个函数的传参的示例"
    print("a的值是：",a)
    print("b的值是：",b)
    print("c的值是：",c)
myfunl(c=3,a=1,b=2)
myfunl(c=33,a=11,b=22+3)

# 说明：
#    实参和形参接形参名进行匹配，能够不接位置进行匹配

字典关键字传参：
　　是指实参为字典，将字典用**拆解后进行关键字传参的传参方式

# 示例见；
def myfunl(a,b,c):
    "这是一个函数的传参的示例"
    print("a的值是：",a)
    print("b的值是：",b)
    print("c的值是：",c)
d1 = {"c":33,"a":11,"b":22}
myfunl(c=d1["c"],a=d1["a"],b=d1["b"])   #33---->c,11---->a
myfunl(**d1)  #拆解字典，在按关键字传参方式传递

# 说明：
#    字典的键名和形参名必须一致
#    字典的键名必须为符合标识符命名规则的字符串
#    字典的键名要在形参中存在

练习：

# 已知有列表：
    L = [1,2,True,None,3.14]
    # 调用print函数，打印用“#”号分隔的文字信息到终端上
    print(...)  #打印  1#2#True#None#3.14
     
l = [1,2,True,None,3.14]
print(*l,sep="#")# 打印 1#2#True#None#3.14

函数的综合传参：
　　1.函数的传参方式，在能肯定形参能惟一匹配到相应实参的状况
下能够任意组合
　　2.函数的位置传参要先于关键字传参

# 示例：
def myfun1(a,b,c)
    pass
myfun1(100,c=300,b=200) #正确
myfun1(c=300,b=200,100) #错的
myfun1(100,*[200,300]) #正确
myfun1(*[100,200],300) #正确
myfun1(100,*[200],300) #正确
myfun1(100,**{"c":300,"b":200}) #正确
myfun1(**{"c":300,"b":200},a=100) #正确

# 可变 和 不可变的类型的容器做为实参传递的区别：
    # 可变类型的实参做为参数传递时，在函数内部能够改变容器内的数据


# 示例见：
# 此示例示意，当函数的实参为可变数据类型时，在函数内部能够改成容器的内容
l = [1,2,3,4]
t = (1.1,2.2,3.3,4.4)
def append_5(x):
　　# x.append(5)
　　x += (5,)#新的x元组
append_5(l)
print(l)
append_5(t) #不存在 
print(t)

练习

# 写一个函数，此函数读取用户输入的数据，最后保存于全局变量的列表
# l中，当用户输入小于零的数时结束输入
l=[]
def input_number(l1):
    while True:
        x = int(input("请输入："))
        if x<0:
            break
        l1.append(x)
input_number(l)
print(l)
input_number(l)
print(l)

 如下讲函数的定义（建立函数的def语句的形参列表）

# 函数的缺省参数：
    # 语法：
# def 函数名（形参名1 = 默认实参1，形参2=默认实参2，...）：
    # 语句块

# 示例见：
def info(name,age=1,address="不详"):
    print(name,"今年",age,"岁.家庭住址",address)
info("路飞",35,"北京市朝阳区")
info("tarena",15)
info("小飞")

说明：
　　缺省参数必须自右至左依次存在，若是一个参数有缺省参数，则其
　　右侧的全部参数都必须有缺省参数，如：
　　　　def test_fn(a,b=10,c): 是错的
　　缺省参数能够有0个，1个或多个，甚至所有都有缺省参数

# 示例：
def fn(a,b=10,c):# 错误
    pass
def fn（a=0,b=10,c=20） # 这是对的
    pass

练习：

# 写一个函数myadd，此函数能够计算两个数，三个数及四个数的和
def myadd（...）：
....
    print(myadd(10,20))#30
    print(myadd(100,200,300))#600
    print(myadd(1,2,3,4))#10

def myadd(a,b,c=0,d=0):
    return a + b+ c +d 
print(myadd(10,20))
print(myadd(100,200,300))
print(myadd(1,2,3,4,))

函数形参的定义方式：

　　1.位置形参
　　2.型号的元组形参
　　3.命名关键字形参
　　4.双星号字典形参

# 位置形参
    # 语法：
# def 函数名（形参名1，形参名2...）：
    # 语句块
# 星号无组形参：
    # 语法：
# def 函数名（*元组形参名）：
    # 语句块
# 做用：
    # 收集多余的位置传参
# 说明：
    # 在一个函数定义中元组形参名最多只能有一个，通常命名为"args"


# 示例见：
# 此示例示意星号元组形参的定义和使用
def func(*args):
    print("实参个数是",len(args))
    print("args=",args)
func(1,2,3,4)
func(5,6,7,8,"A","B","C","D")
func()

 练习：

# 写一个函数 mysun 能够传入任意个数字实参，返回全部实参的和
# def mysum(*args):
    # ...
# print(mysum(1,2,3,4))
# print(mysum(,1,3,5,7,9))

# 方法1
def mysum(*args):
    s = 0
    for x in args:
        s +=x
    return s
print(mysum(1,2,3,4))
print(mysum(1,3,5,7,9))

# 方法2
def mysum(*args):
    return sum(args)
print(mysum(1,2,3,4))
print(mysum(1,3,5,7,9))

命名关键字形参

# 语法：
   # def 函数名（*，命名关键字形参1，命名关键字形参2，...）：
       # 语句块
   # 或
   # def 函数名（*args，命名关键字形参1，命名关键字形参2，..）
       # 语句块
# 做用：
   # 强制全部的参数都必须用关键字传参或字典关键了传参
# 示例见：
   # named_keyword_args.py

# 此示例示意在函数形参中定义命名关键字形参，强制让函数调用使用命名# 关键字传参：
def funcl(a,b,*,c,d):
    print(a,b,c,d)
funcl(1,2,3,4)  # 报错
funcl(1,2,c=30,d=40)
funcl(a=10,b=20,c=30,d=40)

def funcl(a,b,*args,c,d):
    print(a,b,args,c,d)
funcl(1,2,3,4)  # 报错
funcl(1,2,c=30,d=40)
funcl(a=10,b=20,c=30,d=40)
funcl(1,2,3,4,d=400,c=300)
funcl(*"ABCDEFG",**{"c":999,"d":888})

双星号字典形参

# 语法：
    # def 函数名（**字典形参名）
        # 语句块
# 做用：
        # 收集多余的关键字传参
# 说明：
    # 字典形参名通常命名"kwargs"
    # 一个函数内字典形参最多只能有一个

# 示例见：
# 此示例示意用双星号字典形参接收多余的关键字传参
def func(**kwargs):
    print("关键字传参的个数是：",len(kwargs))
    print("kwargs=",kwargs)
func(name="weimingze",age=35,address="北京时朝阳区")
func(a=1,b=2)

def func(a,b,**kwargs):
    print("关键字传参的个数是：",len(kwargs))
    print("kwargs=",kwargs)
func(a=1,b=2,c=3)


# 函数的参数说明：
    # 位置形参，缺省参数，星号元组形参，双星号字典形参能够混合使用

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

# 1.位置形参
# 2.星号元组形参
# 3.命名关键字形参
# 4.双星号字典形参

# 示例：
def fn(a,b=20,*args,c=30,d=40,**kwargs):
    pass
fn(1)
fn(100,200,300,400,c="C",d="D",e="E")

练习：

# 已知内建函数max帮助文档为：
# max（...）
# max（iterable）  -> value
# max(arg1,arg2,*args) -> value
# 仿造 max写一个mymax函数，功能与max彻底相同
   #（要求不容许调用max'）
# 测试程序以下：
# print(mymax([6,8,3,5]))  #8
# print(mymax(100,200))    #200
# print(mymax(1,3,5,7,9)） #9

# 方法1
def mymax(*args):
　　if len(args)==1: #判断是不是一个可迭代参数的状况
　　　　l = args[0] #必定绑定一个可迭代对象
　　　　zuida = l[0]
　　　　for x in l:
　　　　　　if x >zuida:
　　　　　　　　zuida = x
　　　　　　return zuida 
　　else: #不然有多个参数的状况
　　　　zuida = args[0]
　　　　for x in args:
　　　　　　if x>zuida:
　　　　　　　　zuida = x
　　　　　　return zuida 
print(mymax([1,3,5,7,9]))
print(mymax(100,200))
print(mymax(6,8,3,5))

# 方法2
def mymax(a,*args):
　　if len(args)==0: #判断是不是一个可迭代参数的状况
　　　　l = a #必定绑定一个可迭代对象
　　　　zuida = l[0]
　　　　for x in l:
　　　　　　if x >zuida:
　　　　　　　　zuida = x
　　　　return zuida 
　　else: #不然有多个参数的状况
　　　　zuida = a
　　　　for x in args:
　　　　　　if x>zuida:
　　　　　　　　zuida = x
　　　　return zuida

全局变量和局部变量

　　局部变量：local varible:
　　定义在函数内部的变量称为局部的变量（函数的形参也是局部变量）
　　局部变量只能在函数内部使用
　　局部变量在函数调用时才可以被建立，在函数调用以后会自动销毁
　　当有同名的全局变量和局部变量时，优先访问局部变量

　　全局变量：global variable:
　　定义在函数外部，模块内部的变量称为全局变量
　　全局变量，全部函数均可以直接访问（但函数内不能将其直接赋值）

局部变量说明：
　　在函数内部赋值语句不会对全局变量形成影响
　　局部变量只能在其被声明的函数内部访问，而全局变量能够在整数模块范围内访问

# 示例见：
# global_local.py
# 此示例示意全局变量的定义和局部变量的定义
a = 100
b = 200
c = 999999
def fx(c):
    a = 1 # 建立局部变量，并无改变全局变量
    d = 400
    print(a,b,c,d)
fx(300)
print("a=",a)
print("b=",b)
print("c=",c) 


# globals 和 locals 函数：
    # globals()  返回当前全局做用域内变量的字典
    # locals（） 返回当前局部做用域内变量的字典



# 示例见：
# globals_and_locals.py
# 此示例示意全局变量的定义和局部变量的定义
a = 100
b = 200
c = 999999
def fx(c):
　　a = 1 # 建立局部变量，并无改变全局变量
　　d = 400
　　print(a,b,c,d)
fx(300)
print("a=",a)
print("b=",b)
print("c=",c) 
# 此示例示意globals 和 locals 函数的使用方法
a = 1
b = 2
c = 3
def fn(c,d):
　　e = 300
　　# 此处有多少个局部变量？
　　print("locals()返回：",locals())
　　# 此处有多少个全局变量？
　　print("locals()返回：",globals())
　　print(c)
　　print(globals()["c"])
fn (100,200)