python基础-day10

函数的参数:
    1.函数调用实际传递参数(把数据给函数)
    2.函数的形式参数(从调用者拿来的数据)

函数的实际调用参数传递
    传递方式:
        1.位置传参
            1.1 序列传参
        2.关键字传参
            2.2　关键字传参
    位置传参:
        实际参数(实参)的对应关系与形式参数(形参)的对应关系是按位置来依次对应的
        示意:
            def mymin(a,b,c):
                pass
            #         ^ ^ ^
            mymin(    1,2,3)
            说明:实参个数必须与形参个数相同
            示例:
                def myfun1(a,b,c):
                    print('a的值是',a)
                    print('b的值是',b)
                    print('c的值是',c)
                myfun1(1,2,3)
                myfun1(4,5,6)
    序列传参:
        序列:字符串，列表，元组
        序列传参是指在函数调用过程中，用*（星号）将序列拆解后按位置进行传递的传参方式
        示例:
            def myfun1(a,b,c):
                print('a的值是',a)
                print('b的值是',b)
                print('c的值是',c)
            s1=[11,22,33]
            s2=(44,55,66)
            s3='ABC'
            myfun1(*s1)
            myfun1(*s2)
            myfun1(*s3)
            
            说明:序列传参时,序列拆解的位置将与形参一一对应
            序列的位置信息对应相应的参数位置
    
    关键字传参:
        关键字传参是指传参时,按着形参的名称给形参赋值
        实参和形参按名称进行匹配
        示例:
            def myfun1(a,b,c):
                print('a的值是',a)
                print('b的值是',b)
                print('c的值是',c)
            myfun1(c=300,b=200,a=100)
            myfun1(b=200,c=300,a=100)

        说明:实参和形参可以不按位置进行匹配
    
    字典关键字传参:
        是指实参为字典　将字典用**(双星号)拆解后进行关键字传参的传参方式
        示例:
            def myfun1(a,b,c):
                print('a的值是',a)
                print('b的值是',b)
                print('c的值是',c)
            d1={'c':33,'b':22,'a':11}
            myfun1(**d1)
        说明:
            字典的键名和形参必须一致
            字典的键名必须是字符串，且必须为标识符的命名规则
            字典的键名要在形参中存在

    混合传参(函数综合传参):
        函数的传参方式,在能确定形参能唯一匹配到相应实参的情况下可以任意组合
        函数的位置传参要先于关键字传参
            1.函数的位置传参和序列传参可以混合使用，且可以顺序颠倒
                myfun1(100,*[200,300])
                myfun1(*[100,200],300)
                myfun1(*[100],200,*[300])函数的形式参数
            2.函数位置传参和关键字传参可以混合使用
                myfun1(100,c=300,b=200)
                myfun1(100,**{'c':300},b=200)

------------以下讲的是函数的定义以及函数的形参-----------------------
函数的缺省参数
    语法:
        def 函数名(形参名1=默认实参1,形参名2=默认实参2,...):
            语句块
    示例:
        def info(name,age=1,address='不详'):
            print(name,'今年',age,'岁','家庭住址:',address)
        info('魏明择',35,'北京市朝阳区')
        info('tarena',16)
        info('张飞')

    说明:
        1.缺省参数必须自右至左依次存在，如果一个参数有缺省参数，则其右侧
        所有参数都必须有缺省参数
        2.缺省参数可以有0,1,2,甚至全部都是缺省参数
        示例:
            def fn(a,b=10,c):   错！
            def fn(a=0,b=10,c=20) 对
    练习:
        写一个函数myadd,此函数可以计算两个数,三个数,以及四个数的和.
            def myadd(a,b,c=0,d=0):
                print(a+b+c+d)
            myadd(1,2,3,4)
            myadd(1,2,3)
            myadd(1,2)

函数形参的定义形式:
    位置形参
    星号元组形参
    命名关键字形参
    双星号字典形参

位置形参
    语法:
        def 函数名(形参名1,形参名2,...)
            语句块
星号元组形参:
    语法:
        def 函数名(*元组形参名)
    作用:
        收集多余的位置传参
    说明:
        元组形参名一般命名为'args'
    示例:
        def func(*args):
            print('用户传入的参数个数是:',len(args))
            print('args=',args)
        func()   #无参调用
        func(1,2,3)
        func(1,2,3,'AAA','BBB','CCC')
    
    练习:
        写一个函数,mysum,可以传入任意个数的实参，此函数调用返回实参的和
            def mysum(*args):
                return sum(args)
            print(mysum())
            print(mysum(1,2,3))
        
        写一个函数min_max()函数,此函数至少要传一个参数,并返回这些数的最小值，
        最大值(形成元组，最小在前，最大在后)调用此函数，打印最小值和最大值
        
            def min_max(*args):
                return (min(args),max(args))
            print(min_max(10,20,30))           
            x,y=min_max(8,6,4,3,9,2,1)      
            print('最小值是:',x)
            print("最大值是",y)

命名关键字形参:
    语法:
        def 函数名:(*,命名关键字形参1,命名关键字形参2，...)
            语句块
        #或
        def 函数名(*args,命名关键字形参1,命名关键字形参2,...)
            语句块
    作用:
        强制所有的命名关键字形参都必须使用关键字传参或字典关键字传参
    示例:
            def f1(*,c,d):
                print('c=',c)
                print('d=',d)
            #f1(3,4)        #报错
            f1(d=4,c=3)     #正确
            d1={'c':30,'d':40}
            f1(**d1)


                #def f2(a,b,*args,c,d):
                #     print(a,b)
                #     print(args)
                #     print(c,d)
                # f2(1,2,3,4,d=200,c=100)
                # f2(11,22,33,**{'c':11,'d':44})


双星号字典传参:
    语法:
        def 函数名(**字典形参名)
            语句块
    作用:
        收集多余的关键字传参
    说明:
        字典形参名一般命名为'kwargs'
            def fun(**kwargs):
            print('关键字传参个数是',len(kwargs))
            print('kwargs=',kwargs)
            fun(a=1,b='BBBB',c=[2,3,4])

函数的参数说明:
    位置形参,星号元组形参，命名关键字心形参，双星号字典形参，缺省参数可以混合使用

函数参数自左至右的顺序为:
    位置形参
    星号元组形参
    命名关键字形参
    双星号字典形参
示例:
    def fx(a,b,*args,c,d,**kwargs):
        pass
    fx=(1,2,3,4,5,c='C',d='D',e='E')

可以接收任意的位置传参和关键字传参的函数:
    def fn(*args,**kwargs):
        pass

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

    查看>>>range()函数，猜想它的形参列表是如何定义的?

练习:
    写一个myrange函数,参数可以传入1~3个，实际含义与range函数相同
    此函数返回符合range(...)函数列表,
    如:
        L=myrange(4)
        print(L)    #[0,1,2,3]
----------------------------------------------------
            def myrange(a,b=None,c=None):
                pass
                if b is None:
                    start=0
                    stop=a
                else:
                    start=a
                    stop=b
                if c is None:
                    step=1
                else:
                    step=c
                return list(range(start,stop,step))
            L=myrange(1,10,3)
            print(L)

-----------------------------------------------------

全局变量和局部变量:
    局部变量:
        定义在函数内部的变量成为局部变量（函数的形参也是局部变量）
        局部变量只能在函数内部使用
        局部变量在函数调用时才能够被创建，在函数调用后自动销毁
    全局变量:
        定义在函数外部，模块文件内部的变量成为全局变量
        全局变量，所有的函数都可以直接访问（但不能直接将其赋值）

    示例:
            a=100
            b=200
            def fx(c):
                d=400
                print(a,b,c,d)
            fx(300)
            print('a=',a)
            print('b=',b)
说明:
    在函数内部的赋值语句会创建局部变量，不会对全局变量造成影响
    局部变量只能在其被声明的函数内部访问，而全局变量可以在整个模块内访问

        globals()和locals()函数
                globals()返回当前全局作用域内变量的字典
                locals()返回当前局部作用域内变量的字典
            a=1
        b=2
        c=3
        def fn(c,d):
            e=300
            print('locals返回局部变量:',locals())
        fn(100,200)
        print('globals返回全局变量:',globals())

练习:
    素数／质数
    2,3,5,7,11,13
    1.写一个函数isprime(x),判断x是否是素数,如果是素数返回True，否则返回False
        def isprime(x)
        ...
        print(isprime(4))    #False
        print(isprime(5))    #Ture
    
    2写一个函数prime_m2n(m,n)返回从m开始，到n结束的范围内的素数(不包含n)，返回这些素数的列表，打印


    ３写一个函数primes(n),返回指定范围n以内的素数(不包含n)的全部素数的列表，打印素数
    １）打印100以内的素数
    ２）打印200以内素数的和

    ４改写之前的学生信息管理程序:
    改为用两个函数实现
        １）写函数input_student(L)将上述函数得到的打印成为表格显示