函数

 

                                                                              函数基本内容

 if __name__=='__main__'的简单理解

 if __name__ == '__main__' 我们简单的理解就是： 如果模块是被直接运行的，则代码块被运行，如果模块是被导入的，则代码块不被运行。（不运行被导入模块里面的函数）

一、语法定义：

       def sayhi( ):   #()函数名

              逻辑值

              返回值

       sayhi(）  #（调用函数名）

二、参数

          def calc (x,y）  #（x,y为形参）

          c = calc(5,6)   #(5,6传入函数内的就是实参）

（ 1）默认参数：

         def calc(name,age,course,country = 'CN')   

          #(在不输入国籍的时候默认都为CN，如果输入则为其他的。默认参数都放在最后，如果以前不在最后变陈默认参数 后也在最后）                                      

（2）关键参数：

          给函数传参数要按照顺序，不想按照顺序就可以传参数就可以用关键参数，在调用的时候指定参数名

           def calc(name,age,course,country = 'CN')

           calc ("yisa',course='py',age = 22)  (在没有标明是哪一个的参数名的时候不能改变顺序，且，关键参数必须放在最后的位置)

            最后的结果还是按照函数只管参数顺序出来的

（3）非固定参数：

           不确定用户有多少个参数要传入的时候 

           def calc (name,age,*arges)   #(多传入的参数会变成一个元祖）  (*arges 一般放在最后因为会把后面所用的值默认组成一个元祖）

             print( name,age,arges)

           1)、calc ('yisa',22,'CN','py')

                   输出   yisa  22  ('CN','py')

          2）、calc ('yisa',22,['CN','py'])              calc ('yisa',22,*['CN','py'])     （加*号去掉元祖符号）

                    输出  yisa  22 (['CN','py'])             输出  yisa  22   ['CN','py']

           3)、 def calc (name,age,*arges，**kwargs)   **kwarge  (把传入的参数默认组成一个字典）

                     calc ('yisa',22,'CN','py',sex='male',province = 'sichuan')

                     yisa  22 ('CN'，'py')  {'sex':'male','province' :'sichuan'}

 

三、返回值：

                 

                   1.return的作用:结束一个函数的执行

                 2.首先返回值可以是任意的数据类型。

                 3.函数可以有返回值：如果有返回值，必须要用变量接收才有效果

                 4.也可以没有返回值：没有返回值，函数返回为None

                 

 def calc(x):

        a=111
        b=[1,2,3]
        c={'a':15,'b':6}
        if  ------              #(函数在执行过程中遇到return语句，就会停止执行并返回结果，后面的语句都不执行)

           return a       #(未在函数中指定return,函数返回值为None)
       else -----

           return  a,b,c   #(返回多个值，变量之间按照逗号隔开，以元祖的形式返回)

 

 

 

 四、 全局与局部变量

 

        name =  'Alex li'
        def c_name():
           global name     (定义了全局变量）
           name = ''alex'  
           print(name)

    

 五、 嵌套函数

              就是函数里面套函数

         def  name ()
             name=‘Alex’
             def   age()
                age= 22
                print(age)
            age()
        name()                   变量要由里往外找

 

 六、匿名函数

             calc = lambda x,y:x**y  (声明一个函数）

             map( func,data)     (函数，数据） 就是把data里面的数都付给函数，取算值

             res = map(lambda x:x**2,[1,2,3,4,5]

 

七、高阶函数

               一个函数可以接受另外一个函数作为参数

       def add(x,y,f)
            return  f(x）+f(y)    returen 是返回另外一个函数
       res = add(3,-6,abs)        abs(是绝对值的意思）

 

八、递归

               如果一个函数在内部调用函数本身，这个函数就是递归函数

                  必须有一个明确的结束条件

       def calc（n）：
            v = int(n/2）
            print（v）
            if v ==0
               renturn'done'
            calc(v)
           print（v）
 
     输出    5
            2
            1
            0
            1
            2
            5
           10

 

九、内置函数

                   只写一个不容易记得

                     zip   a=[1,2,3,4]

                      b=['a','b','c']     list(zip(a,b))   [(1,'a'),(2,’b'),(3,'c')]  一一对应多余的丢弃

 

 函数进阶

  一、名称空间

                    x=1 (名称空间就是存放名字x与1绑定关系的地方）

                  locals :是函数内的名称空间，包括局部变量和形参

                  globals: 全局变量

                   buitins:内置模块的名字空间

  二、闭包

   

           1.闭 ：内部的函数 
　　　2.包 ：包含了对外部函数作用域中变量的引用

          两个原则，开放封闭原则

          对扩展是开放的

          对修改是封闭的

def outer():
     name='alex'   #（这里定义是给让内层函数一起使用）
     def inner():
            name='yisa'  #(如果这里再定义name,那么就不是一个闭包，只是嵌套函数）
            print("在inner里打印外层函数变量；name)
     return inner  (这里只是返回inner 的内存地址）
f= outer()
f()（ 执行inner()）

 

 

 

 三、装饰器

    

         装饰器的功能：在不修改原函数及其调用方式的情况下对原函数功能进行扩展

　　装饰器的本质：就是一个闭包函数

 

def login(auth_type):
            user_name = 'yisa'
            password = 'a123'
            global user_status
                        if user_status == False:
                _user_name = input('Name:')
                _password = input('Password:')
                if _user_name == user_name and _password == password:
                    print("登陆成功")
                    user_status = True
                else:
                    print("wrong name or password")
            if user_status ==True:
               func()   #(这里通过了验证，就调用相应功能）

@login
def home():    #(原函数不带参数的类型）
    print("------首页--------")
def america():
    print("-------欧美专区----")

def japan():
    print("--------日本专区-----")

@login
def henan(style):     #（原函数第一个参数的类型）
    print("--------河南专区------",style)


  (1)   home()
        #henan()
        login(henan)   (用户之前只需要调用henan()  这里相当于改变了调用方式）这种方法不可取，因为每一个的调用方式都会改变

 

 

 

       在调用前进行认证（qq\weixin）  那就只能在外面多定义一层函数   

 

user_status = False
def login(auth_type):
   def outer(func):
      def inner(*arge,**kwargs):
         if auth_type=="weixin"    #(这里还要验证一次登录方式）
            user_name = 'yisa'
            password = 'a123'
            global user_status
            if user_status == False:
                _user_name = input('Name:')
                _password = input('Password:')
                if _user_name == user_name and _password == password:
                    print("登陆成功")
                    user_status = True
                else:
                    print("wrong name or password")
            if user_status ==True:
                func(*arge,**kwargs)
          else：
             print('只能使用微信登录‘）
        return inner
    return outer
def home():
    print("------首页--------")
def america():
    print("-------欧美专区----")
@login('weixin')
def japan():
    print("--------日本专区-----")
             # @login #(这个功能和henan = login(henan）一样）这个就是装饰器  加了之后自动进入函数第一层
             #@login('qq') #相当于退两层，先是login('qq'),然后是out('henan).  加了参数又自己进去下一层
             # 一个login不加括号是return一层，带一个参数是两个return， 就是要定义三次去调用
def henan(style):
    print("--------河南专区------",style)
# henan = login(henan)
henan('aaa')
japan()

 

 

 

 3.2 带参数的装饰

           带参数的装饰器：就是给装饰器传参

　　　用处：就是当加了很多装饰器的时候，现在忽然又不想加装饰器了，想把装饰器给去掉了，但是那么多的代码，一个一个的去闲的麻烦，那么，我们可以利用带参数的装饰器去装饰它，这就他就像一个开关一样，要的时候就调用了，不用的时候就去掉了。

     

带参数的装饰器：（相当于开关）为了给装饰器传参
  # F=True#为True时就把装饰器给加上了
  F=False#为False时就把装饰器给去掉了
 def outer(flag):
      def wrapper(func):
          def inner(*args,**kwargs):
              if flag:
                  print('before')
                  ret=func(*args,**kwargs)
                 print('after')
             else:
                 ret = func(*args, **kwargs)
             return ret
         return inner
     return wrapper
 
 @outer(F)#@wrapper
 def hahaha():
     print('hahaha')
 
 @outer(F)
 def shuangwaiwai():
     print('shuangwaiwai')
 
 hahaha()
 shuangwaiwai()

 

 

 

　　3.3多个装饰器装饰一个函数

         

def qqqxing(fun):
    def inner(*args,**kwargs):
        print('in qqxing: before')        #第一个执行
        ret = fun(*args,**kwargs)
        print('in qqxing: after')         #第五个执行
        return ret
    return inner

def pipixia(fun):
    def inner(*args,**kwargs):
        print('in qqxing: before')        #第二个执行
        ret = fun(*args,**kwargs)     #第三个执行
        print('in qqxing: after')          #第四个执行
        return ret
    return inner
@qqqxing
@pipixia
def dapangxie():
    print('饿了吗')
dapangxie()

'''
@qqqxing和@pipixia的执行顺序：先执行qqqxing里面的 print('in qqxing: before')，然后跳到了pipixia里面的
        print('in qqxing: before')
        ret = fun(*args,**kwargs)
        print('in qqxing: after')，完了又回到了qqqxing里面的 print('in qqxing: after')。所以就如下面的运行结果截图一样
'''

多个装饰器装饰一个函数

 

 

 

 

 四、生成器和迭代器

       4.1列表生成器：（  只能写到列表、元祖，但不能是字典）

            a = [i+1  for i in range(10)]     把后面的  i  值赋给前面  （列表生成式）

               a = [i  if i <5 else i*i for i iin b]  这里的b 是字典、列表、字符串

      生成器：generator

         a = [i+1  for i in range(10)]   

          g = ( i+1 for i in range(10））把[ ]  改为（  ）就创建了一个生成器

          可以通过next( )获得generator的一个返回值     

next（）
  >>>  1
next()
>>> 2
next()        因为太麻烦了，所以我么基本不用next()来调用函数
>>>3

           因为一般用  for 循环

         如果推算的算法比较复杂，用for 循环不能实现时，还可以用函数来实现

          Fibonacci 函数  除了第一个和第二个数外，任意一个数可由前两个数相加的到。

 def  fib(max):     (max  表示多少位）
       n, a,b = 0,0,1
       while n <max :
                print(b)
                 a,b= b,a+b
                n = n+1

      fib 函数和generator 仅一步之遥   要把 fib 变成generator 只需要把print(b) 改为 yieldb

def  fib(max):     (max  表示多少位）
       n, a,b = 0,0,1
       while n <max :
                #print(b)
                yield  b      (相当于函数停在了这里,程序也停在了这里（把函数的执行过程冻结在这一步，并且把b的值返回给外面的 next(),
                          next()唤醒冻结的函数，直到遇到下一个yield ）
                 a,b= b,a+b
                n = n+1
        return 'done'

      (1) print(    )
             yield  b   （第一次到这里就停止了）
       (2) print(   )
            
         第二次输出（2）的内容再输出（1）的内容 然后遇到yield 就再一次停止
      send 的作用
       1、唤醒函数并继续进行（如果函数有被yield 中止了，可以继续进行）
       2、发送一个信息到生成器内部

         4.2迭代器

                 可以用于for 循环的数据类型有以下几种：

                 1、数据集合：list  tuple dict  set str 

                 2、一类是生成器generator, 包括生成器带yield 的generator function

                    可直接用作于for循环额对象统称为可迭代对象：iterable

        可以使用isinstance()  判断一个对象是否是interable 对象

        生成器不但可以被用作for 循环，还可以被next()函数不断调用把那个返回下一个值，知道最后抛出stopinteration错误表示无法返回下一个值了

         可以被next()函数不断调用把那个返回下一个值的对象成为迭代器：interator  （生成器是迭代器的一种）

         生成器都是可迭代对象， 但list dict str 虽然都是可以迭代（interable）但是却不是迭代器（iterator）

         

          filter 过滤函数的使用

               例如：筛选出偶数

               date=[1,2,3,4,5,6,7,8]

                 def calc(n):

                       if n%2==0:

                      return True

               oushu=filter( calc,data)