函数的参数与全局局部作用域

函数参数的传递

传递方式：＃给的过程
位置传参
　　序列传参
关键字传参
　　字典关键字传参

位置传参

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

示意图：
def mymin(a, b, c):
　　pass

mymin( 1, 2, 3)
例见：

#此事例示意位置传参，　此函数以后不会改变代码
def myfun(a, b, c):
    print("a 的值：", a)
    print("b 的值：", b)
    print("c 的值：", c)
    
myfun(1, 2, 3)

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

序列传参

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

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

例：

def myfun(a,b,c):
　　　"""此函数不会变化"""
print("a=",a)
print("b=",b)
print("c=",c)
s="ABC" 参数个数要和(a,b,c)个数相同
l=[4,5,6]
t=(1.1,2.2,3.3)
#myfun(s[0],s[1],s[2]) 按位置传参
myfun(*s)
myfun(*l)
myfun(*t)

#序列传参
def myfun1(a, b, c):
    print("a 的值：", a)
    print("b 的值：", b)
    print("c 的值：", c)


s1 = [11, 22, 33]
# myfun1(s1)　错
myfun1(s1[0], s1[1], s1[2])
myfun1(*s1)#相当于拆myfun1(11, 22, 33)
t1 = (44, 55, 66)#元组
myfun1(*t1)
myfun1(*'ABC')

关键字传参

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

例：
def myfun(a,b,c):
　　　"""此函数不会变化"""
print("a=",a)
print("b=",b)
print("c=",c)

myfun(b=2,c=3,a=1)
myfun(c=333,b=222,a=111)

#关键字传参
def myfun1(a, b, c):
    print("a 的值：", a)
    print("b 的值：", b)
    print("c 的值：", c)

myfun1(b=22, c=33, a=11)#给
myfun1(c=66, b=555, a=444)

字典关键字传参

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

例：
示例：
def myfun(a,b,c):
"""此函数不会变化"""
print("a=",a)
print("b=",b)
print("c=",c)

d={'a':111,'c':333,'b':22}
myfun(**d) # 等同于myfun(a=111,c=333,b=222)

>>> def myfun(a,b,c):
... """此函数不会变化"""
... print("a=",a)
... print("b=",b)
... print("c=",c)
...
>>> d={'a':111,'c':333,'b':22}
>>> myfun(**d)
a= 111
b= 22
c= 333

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

>>> def myfun1(a, b, c):
... print("a 的值：", a)
... print("b 的值：", b)
... print("c 的值：", c)
...
>>> myfun1(100, c=300, b=200)
a 的值： 100
b 的值： 200
c 的值： 300
>>>
>>>
>>> print(1, 2, 3, 4, sep="#")
1#2#3#4

函数的综合传参：
函数的传参方式在能确定形参能唯一匹配到相应实参的情况下可以任意组合

说明：
位置传参（序列传参）要在关键字传参（字典关键字传参）的左侧

例：

#关键字传参
def myfun1(a, b, c):
    print("a 的值：", a)
    print("b 的值：", b)
    print("c 的值：", c)

myfun1(b=22, c=33, a=11)#给
myfun1(c=66, b=555, a=444)

#当调用时
myfun1(100, *[200, 300])
myfun1(*(100, 200), 300)
myfun1(*[100], 200, *(300,))
myfun1(100, c=300, b=200)#正确
myfun1(c=300, b=200, 100)#错误
myfun1(100, **['c':300, 'b':200])

练习：
写一个函数minmax(a, b, c)　有三个参数，　这回这三个参数中的最小和最大值，
要求，　形成元组，　最小值在前，　最大值在后，　如：
def minmax(a, b, c):
...
t = minmax(11, 33, 22)
print(t)#{11, 33}
xiao, da = mimmax(6, 5, 4)
print('最大值：', da, '最小值：', xiao)

def minmax(a, b, c):
    da = max(a, b, c)
    xiao = min(a, b, c)
    return(xiao, da)
    
t = minmax(11, 33, 22)
print(t)#(11, 33)
xiao, da = minmax(6, 5, 4)
print('最大值：', da, '最小值：', xiao)


def minmax(a, b, c):
    zuida = a
    if b > zuida:
        zuida = b
    if c > zuida :
        zuida = c

    zuixiao = a
    if b < zuixiao:
        zuixiao = b
    if c < zuixiao:
        zuixiao = c
    return (zuixiao, zuida)
      
t = minmax(1, 2, 3)
rint(t)#(11, 33)
xiao, da = minmax(6, 5, 4)
print('最大值：', da, '最小值：', xiao)

缺省参数

函数形参的定义
函数形参的定义
函数的缺省参数：
语句：
def 函数名(形参名=默认实参１，　形参名２＝默认实参２，　...):
语句块

例：

def info(name, age=1, address='未填写'):
    print('我叫', name, '我今年', age, '岁，　我家住址：', address)

info("宋梓鸿", 20, '广东梅州')
info('tarena', 15)
info('张飞')
# info()#不可以
info('小张', age=20)

说明：
缺省参数必须自右至左依次存在，　如果一个参数有缺省参数，　则其右侧的所有参数都必须有缺省参数

如：
def fe (a, b=10, c)#错误
pass
def fe(a=1, b=5, c=10):
pass

fe(100, c=300)#(a=100, b=5, c=300)

练习：
myadd

print_odd
# 练习：
# 　写一个函数　myadd,此函数可以计算两个数的和，也可以计算三个数的和

# def myadd(a,b,c=0):
# # return a+b+c
# return sum((a,b,c))

# print(myadd(10,20)) # 30
# print(myadd(100,200,300)) # 600
# 用sum怎么做？sum用于可迭代对象

def myadd(a, b=0, c=0):
    s = a + b + c
    return(s)
print(myadd(50))
print(myadd(10, 20))
print(myadd(100, 200, 300))

# ２．写一个函数，print_odd，此函数可以传递一个实参，也可以传递两个，
当传递一个实参时，代表结束值，当传递两个实参时，第一个实参代表
起始值，第二个实参代表结束值
打印出在此区间内的全部奇数，不包含结束数：

def print_odd(a,b=0):
    if b == 0:
        for x in range(1,a,2):
            print(x,end=' ')
        else:
            print()
    else:
        if a % 2 == 0:
            a += 1
        for x in range(a,b,2):
            print(x,end=' ')
        else:
            print()
-------------------------
def print_odd(a,b=0):
    if b ==0:
        b = a
        a = 0
    while a < b:
        if a % 2 ==1:
            print(a,end=' ')
            a += 2
        else:
            a +=1
    print()
----------------------------
def print_odd(a,b=None):
    if b is None:
        start = 1
        end = a
    else:
        start = a
        end = b
    #如果开始是偶数，做校正
    if start % 2 ==0:
        start += 1
    for x in range(start,end,2):
        print(x,end=' ')
    print()

print_odd(10) # 1,3,5,7,9
print_odd(11,20) # 11,13,15,17,19
print_odd(30,40)
print_odd(5,0)

def print_odd(a, b = 0):
    if b == 0:
        l = []
        for x in range(0, a):
            if x % 2 == 1:
                l +=[x]
    else:
        l = []
        for i in range(a, b):
            if i % 2 ==1:
                l +=[i]
    print(l)       

print_odd(10)
print_odd(11, 20)


def print_odd(a, b = 0):
    if b == 0:
        for x in range(1, a, 2):
            print(x, end= ' ')
        else:
            print()
    else:
        if a % 2 == 0:#如果是奇数
            a +=1
        for x in range(a, b, 2):
            print(x, end=' ')
        else:
            print()
print_odd(10)
print_odd(11, 20)
print_odd(5, 0)

def print_odd(a, b = None):
    if b is None:
        start = 1
        end = a 
    else:
        start = a
        end = b
    #如果开始的偶数，　做校正
    if start % 2 == 0:
        start += 1
    for x in range(start, end, 2):
        print(x, end=' ')
    print()

print_odd(10)
print_odd(11, 20)
print_odd(5, 0)

---

函数形参的定义方式

#拿的过程
１．位置形参
２．星号元组形参
３．命名关键字形参
４.　双星号字典形参

位置形参

语法：
def 函数名(形参名１，　形参名２，...):
语句块

星号元组形参

语法：
def 函数名(*元组形参名)：
语句块

作用：
收集多余的位置传参

示例：
def fa(a,b,c): # 最多只能传递三个实参
pass

def fb(*args):
'''args绑定一个元组'''
print("实参的个数是：",len(args))
print("args=",args)

fb()
fb(1,2,3,4) 实参个数是：4 args=(1,2,3,4)

# 星号元组形参
def func(*ages):
    print('参数的个数是：', len(ages))
    print('ages',ages)

func()#无参
func(1, 2, 3,4 )
func(*"ABC", 1, 2, 3, None, False)

def fa (a, b, *args):
    print(a)
    print(b)
    print(args)

fa(1, 2, 3, 4, 5, 6,7 ,8 9)

练习：
写一个函数，　mysum可以传入任意个实参的数字，　返回所有实参的和
def mysum(*args):
...
print(mysum(1, 2, 3, 4))#10
print(mysum(10, 20, 30))#60

def mysum(*args):
    s = 0
    for x in args:
        s +=x
    return s

print(mysum(1, 2, 3, 4))
print(mysum(10, 20, 30))

命名关键字形参

语法：
def 函数名(*, 命名关键字形参)：
语句块
或
def 函数名(*aegs, 命名关键字形参(传参))：

例；
1. print(1, 2, 3, 4, sep="#")
2. l = [2, 4, 6, 8, 10]
sorted(l, reverse=True)

作用：
强制所有的参数都必须用关键字传参或字典关键字传参
>>> print(1, 2, 3, 4, sep="#")
1#2#3#4
>>> p = ['1', '2', '3']
>>> '#'.join(p)
'1#2#3'

# 命名关键字形参
def fa(*, a, b):
    print('a=', a)
    print('b=', b)

fa(b=1, a=2)

fa(**{'b': 200, 'a': 100})#关键字传参，明确参数的含义reverse

def fb(*args, a, b):
    print('a=', a)
    print('b=', b)
    print("args=", args)

fb(1, 2, 3, 4, b=200, a=100)

双星号字典形参

语法：
def 函数名（**字典形参名）:
语句块

作用：
收集多余的关键字传参
说明：
字典形参名通常命名为'kwargs'

例
>>> dict (a=100, b=200)
{'b': 200, 'a': 100}

>>> max([7, 5, 3, 9, 3])
9
#一个实参
>>> max(5,4,8)
8
＃三个实参
>>> max(9)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable
＃一个错实参

def fa(**kwargs):
    print("调用时关键字传参的个数是：", len(kwargs))
    print('kwargs', kwargs)
fa(name='tarena', age=15)
fa(a=1, b='BBB', c=[2, 3, 4], d=True)

练习：
写一个函数，mymax类似于内键的函数max
详见：
>>> help(max)

仿照　max 写一个mymax函数，　功能与max完全相同（要求不允许调用max函数）
print(mymax([6, 8, 3, 5]))#8
print(mymax(100, 200))#200
print(mymax(1, 3, 5, 9, 7))#9

def mymax(a, *args):
    if len(args)==0:
        zuida = a[0]
        for x in a:
            if x > zuida:
                zuida = x
        return zuida
    else:#实参个数大于１时
        zuida = a
        for x in args:
            if x > zuida:
                zuida = x

        return zuida

print(mymax([6, 8, 3, 5]))#8
print(mymax(100, 200))#200
print(mymax(1, 3, 5, 9, 7))#9

实参是给　形参是接（拿）
　　函数的参数说明：
位置形参，　缺省形参，　星号元组形参，　双星号字典形参可以混合使用

函数形参自左至右的顺序为：
位置形参
星号形参
命名关键字形参
双星号字典形参

例： 可以*
def fx(a, b, *args, c, **kwargs):
　　print(fx)
fx(1, 2, 3, 4, c="C", d="D", e="E")

函数的不定长参数：
　星号元组形参，双星号字典形参

说明：
　可以接收任意的位置传参和关键字传参

示例：
def fn(*args,**kwargs):
　　pass

fn(1,2,3,4,a=100,b=200,c=300)
fn()
fn(1,2,3)

查看　>>>help(print) 猜想print函数的参数列表是如何定义的？

def print(*args,sep=' ',end=' ',file=sys.stdout,flush=False):
　　pass

print(1,2,3,4,end=' ',sep='#')

全局变量和局部变量

局部变量：local varible
１．定义在函数内部的变量称为局部变量（函数的形参也是局部变量）
２．局部变量只能在函数内部使用
３．局部变量只有在函数调用时才能被创建，　在函数调用结束后会自动销毁

全局变量 global variable
定义在函数外部，模块内部的变量称为全局变量
全局变量所有函数都可以直接访问(但函数内不能将其直接赋值)
示例

a = 100
b = 200
def fx(c):
    d = 400
    a = 100000
    print(a, b, c, d)

fx(300)
print("全局内的",a, b, c, d)
# fx, a, b 为全局变量　　c, d 局部变量

练习：
创建一个全局变量　L= []
写一个函数：
def input_number():
...
此函数每次调用将从键盘读入一些数追加到列表L中
如：
L = []
def input_number():
...
input_number()
print(L)#[..........这些是您从键盘输入的数...]

L = []
def input_number():
    while True:
        x = int(input("qingshuru, 按0退出:"))
        if x == 0:
            break
        L.append(x)
    return(L)


input_number()
print(L)

>>> L（变量） = [1, 2, 3]（对象)
>>>
>>> def fx(n):
...　　 L.append(n)
...　　 L = [n]

 

练习：
１．写一个函数isprime(x)判断x是否为素数。如果是素数，　返回True, 否则返回False

def isprime(x):
    if x < 2:
        print(True) 

    else:
        for i in range(2, x):
            if x % i == 0:
                print(False)
                break
        else:
            print(True)

isprime(10)
isprime(11)
isprime(6523166)
isprime(11111)

2.写一个函数prime_m2n(m,n)返回从m 开始，　到n结束(不包含n)范围内的素数，　返回这些素数的列表并打印
如：L = prime_m2n(5, 10)
print(L) [5, 7]

def prime_m2n(m, n):
    L = []
    for x in range(m, n):
        if x < 2:
            continue
        else:
            for i in range(2, x):
                if x % i == 0:
                    break
            else:
                L +=[x]
    return L

L = prime_m2n(5, 10)
print(L)  

L = prime_m2n(0, 20)
print(L)

3．写一个函数pimes(n)返回小于n的全部素数的列表，　并打印这些素数
如：

L = primes(10)
　　print(L)
#[2,, 3, 5, 7]
1) 打印１００以内的全部素数
２）打印２００以内的全部素数的和

def primes(n):
    L = []
    for x in range(n):
        if x >= 2:
            for h in range(2, x):
                if x % h == 0:
                    break
            else:
                L.append(x)
    print(L)
    print(sum(L))

L = primes(100)
L = primes(200)

４．编写函数fn()此函数返回下列级数的和
fn(n) = 1/(1*2) + 1/(2*3) +...+1/(n*(n-1))的和

print(fn(100))

def fn(n):
    l = []
    for x in range(1, n):
        s = 1/(x*(x+1))
        l.append(s)
    he = sum(l)
    return he
print(fn(100))