python --葵花宝典

1.python 函数 定义 ---def()

      def  fun()：

            print（“我是小甲鱼！！”）

      调用函数 

      a =fun（）

     print （a）

    即可  ，注：函数调用是由上而下；

2.python 函数的参数  def（a,b）

   def fun(name):

     print(name+"wo ai ni" )

  c =int（input（“输入：”））

   fun(c)

  即可调用；

3.python 函数返回值  关键字：return

    def fun(name1+name2):

           return (name1+name2 )

  c =int（input（“输入：”））

  d =int（input（“输入：”））

   fun（c，d)

即可得到返回值

4.python 形参 -- 函数-->内部调用的 参数和实参-->传入函数的参数

def fun(name):

        "函数文档"

     print(name+"wo ai ni" )

  c =int（input（“输入：”））

   fun(c)

  不能打印出“函数文档”

 fun.__doc__  函数属性即可打印“函数文档”

help（print）介绍函数用法

5.  python  关键字参数

    def  fun（name ，words）：

         print（name +“-->”+words）

      调用fun（“小甲鱼”，“让加”）

     即可打印

   调用fun （“让加”，“小甲鱼”）

    则输出的结果是反的

    解决办法：指定传入的参数

   fun（words=“让加”，name=“小甲鱼”）

 6.python 默认参数

   def  fun（name=“小甲鱼” ，words=“让加”）：       

           print（name +“-->”+words）

      fun（）

      即可打印

   fun（“苍井空”）

  打印出 ：苍井空-->让加

7.python  收集参数  别名 ———可变参数

   def fun（*params）：

          print（“参数的长度：”，len(params)）

        pint （“第二个参数：”，params[1]）

   fun(1,"小甲鱼"，2，34，5，45，5)

即可打印  参数长度：7 第二个参数：小甲鱼

注：传的参数打包为一个元祖

8.def fun（*params，erp）：

          print（“参数的长度：”，len(params)，erp）

          pint （“第二个参数：”，params[1]）

    fun(1,"小甲鱼"，2，34，5，45，5)

    调用默认给收集参数，会出错，给erp定义默认值:“小甲鱼”

    则不会出错

9.  python  函数与过程

    有返回值 --函数  无返回值---过程

    def  fun()：

            print（“我是小甲鱼！！”）

      a =fun（）

     print（a）

     返回值  none

      动态确定内存；

     可以返回多个值

      def back（）：

           return（1，“小甲鱼”，3，454）

   back（）

打印出一个列表

[1,"小甲鱼"，3，454]包含不同类型的值

  def back（）：

           return 1，“小甲鱼”，3，454

   back（）

打印出元祖

（1，“小甲鱼”，3，454）

10. python   函数变量作用域--变量可见性   局部变量无法影响全局变量   ，在函数内部可以访问全局变量，用关键字global修改全局变量

   def  fun（a，b）：

         xiangcheng   =a*b

        # print （c)全局变量

           golbal c

           c= 45

         return（  xiangcheng）

  c =int（input（“输入：”））

  d =int（input（“输入：”））

  new =fun(c,d)全局变量

  print(new)

11. python  内嵌函数

     def  fun1（） ：

             print（“1”）

              def fun2（）：

                       print（"2")

                fun2()    

        注：内部函数作用域都在外部函数之内的

调用fun1（）

打印：

1

2

12.python  闭包  

 def  funX（x） ：

             print（“1”）

              def funY（y）：

                     return x * y

                funY()    

i= funX(8)

调用函数：funX（5）（8）

输出：40

13. python 函数 产生闭包

   def  fun1（） ：

            x =5

              def fun2（y）：

                     x*=x

                     return x

调用 函数 fun1（）报错；x在fun2函数中无定义；在fun1函数中定义的x ，无法影响fun2函数

修改后python 2

def  fun1（） ：

            x =[5]

              def fun2（y）：

                     x[0]*=x[0]

                     return x[0]

               retrun fun2()

  即可

修改后 python3利用关键字nonlocal

def  fun1（） ：

            x =5

              def fun2（y）：

                   nonlocal x

                   x*=x

                   return x

                return fun2（）

即可调用fun1（）

14.python 匿名函数 --->lambda表达式

   

 def  funX（x） ：

          reurn 2* x+1

funX（5）

lambda表达式：

g= lambda x：2*x+1

调用 ：g（5）

自动删除申请的内存

例:  g= lambda x,y :x+y

       g (3,5)即可 

15. python  两个BIF 函数     filter（）函数，map（）函数

   （1）.filter（）函数

filter（None，[1,0,False,Ture]）

list(filter(None,[1,0,False,Ture]))

即可输出：[1,Ture]

 def add(x):

        return x %2

temp = range(10)

show = filter (add,temp)

list(show)

输出：[1,3,5,7,9]

list（filter（lambda x：x%2，range（10））)即可输出

（2）.map（）函数：

list（map（lambda x：x*2，range（10））））即可输出

[0,2,4,6,10,12,16,18]---> 利用lambda函数 生成一个数据返回生成一个列表；

16. python  ---递归

     网络爬虫时设置递归的深度；

import sys

sys.setrecursionlimit(1000000)

===============================================================================

def fun（）：
        return fun（）

执行函数fun（）即可，测试

===============================================================================

递归求阶乘：

非递归版:

def fun(n):

        result =n

        for i in range(1,n):

                 result * =1

         return result

num =int(input(“输入正数：”))

result= fun（num）

priint("%d的阶乘是 %d "，（num ，result）)

递归版:

def fun （n）：

      if n== 1:

             return 1

      else:

              return n=fun (n-1)

num =int(input(“输入正数：”))

result= fun（num）

print("%d的阶乘是 %d "，（num ，result）)

17. python  ---斐波拉契数列：比例-->0.618：1

      def fun(n):

              n1=1

             n2=1

             n3= 1

            if n<0:

                   print("输入有误")

                   return -1

             else：

                   n3 =n2+n1

                   n1 = n2

                   n2 =n3

                    n =1

               return n3

  result =fun (20)

if result !=1:

print ("共有多少对小甲鱼："%result)

运行即可输出：

递归版：

def fun （n）:

         if n<1:

               print("输入有误：")

          if n==1 or  n ==2：

                 return 1

            else：

                    return fun（n -1）+fun（n-2）

result =fun （20）

if result ！=1：

        print（“共有多少小甲鱼：”% result）

运行即可；

18.python --->汉诺塔

def hanoi(n,x,y,z)

      if n == 1：

               print（x，“---->”z）

         else:

                hanoi(n-1,x,z,y)#将前n-1个盘子从x移动到y上

                 print(x,"-->",z)# 将最底下的盘子从x移到z上

                 hanoi(n-1,y,x,z)#将y上的n-1个盘子移动到z上

num =int(input("输入正数："))

result= hanoi（num，‘X’，‘Y’，‘Z’）

即可运行

 

 

     

     

 

转载于:https://www.cnblogs.com/dpf-learn/p/7977915.html