Python四级考试笔记

Python四级考试笔记【源源老师】

四级标准

一、 理解函数及过程、函数的参数、函数的返回值、变量作用域等概念。

二、 能够创建简单的自定义函数。

三、 理解算法以及算法性能、效率的概念，初步认识算法优化 效率的方法。

四、 理解基本算法中递归的概念。

五、 掌握自定义函数及调用，实现基本算法中的递归方法。

六、 掌握基本算法中由递归变递推的方法。

七、 理解基本算法中的分治算法，能够用分治算法实现简单的 Python程序。

八、 掌握第三方库（模块）的功能、获取、安装、调用等。

函数

1. 定义

• 函数：是组织好的，可重复使用的，用来实现特定功能的代码段。例如：

  res = len('I like python')
  print(res) #13
  

  • 为什么我们随时可以使用len函数？因为len函数是python的内置函数，已经提前写好了，可以重复被使用，len函数的作用就是用来统计长度的。我们使用过的：input()、print()、str()、int()等都是Python的内置函数。

    函数主要有两大作用：

    • 将功能封装在函数内，可供随时随地重复利用
    • 提高代码的复用性，减少重复代码，提升效率

    2. 语法

    def 函数名(参数):
    	函数体
    	return 返回值
    

    注意： ① 参数如不需要，可以省略 ② 返回值如不需要，可以省略 ③ 函数必须先定义后使用

    举例：

    def fn():
    	print('我喜欢python')
    #调用函数，也就是让fn函数执行
    fn()
    

    3. 参数

    参数的作用是：在函数进行计算的时候，接受外部（调用时）提供的数据

    有如下代码，完成了2个数字相加的功能：

    def add():
        sum = 1+2
        print(sum)
        
    #调用函数    
    add()
    

    这个函数的功能非常局限，只能计算1 + 2。有没有可能实现：每一次使用函数，用户给出任意两个数字，都能进行相加呢？可以的，使用函数的传入参数功能，即可实现。

    def add(x, y):
        sum = x+y
        print(sum)
        
    add(1,2) #每次调用函数时，可以传入想要的参数
    add(3,4) #每次调用函数时，可以传入想要的参数
    

    • 形参：函数定义中，提供的x和y，称之为 形式参数（形参），表示函数声明将要使用2个参数，参数之间使用逗号进行分隔。
    • 实参：函数调用中，提供的1和2，称之为 实际参数（实参），表示函数执行时真正使用的参数值。传入的时候，按照顺序传入数据，使用逗号分隔。

      【注意】：在Python中，如果一个方法定义时声明了某个参数，那么在调用这个方法时就必须提供这个参数的值，否则程序会报错。

      4. 返回值

      • 返回值：就是程序中函数完成事情后，最后给调用者的结果

        def add(x, y):
            sum = x+y
            return sum
            
        res = add(1,2)
        print(res) #3
        

        以上add函数用来对两个数进行相加，最后，会将相加的结果sum返回给函数调用者res

        所以，变量res接收到了函数的执行结果，也就是res = 3.

        • 【扩展】：思考以下问题

          5. 函数的嵌套

          • 函数嵌套：指的是一个函数里面又调用了另外一个函数

            def fn():
                print('I like python')
                
            def add(x, y):
                sum = x+y
                print(sum)
                fn()
                  
            add(1,2)
            

            6. 变量作用域

            • 变量作用域指的是变量的作用范围（即变量在哪里可用，在哪里不可用）。变量作用域主要分为两类：局部变量和全局变量。

              （1）局部变量

              • 局部变量：定义在函数体内部的变量，即只在函数体内部生效

                变量num是定义在testA函数内部的变量，在函数内部访问不会报错，但在函数外部访问会报错。

                （2）全局变量

                • 全局变量：在函数体内、函数体外都能访问的变量

                  思考：如果有一个数据，在函数A和函数B中都要使用，该怎么办？

                  答：将这个数据存储在一个全局变量里面

                  7. 递归函数

                  • 递归：即函数自己调用自己的特殊写法。

                    （1）计算n的阶乘

                    def fact(n):
                        if n==1:
                            return 1
                        return n * fact(n - 1)
                    res = fact(5)
                    print(res) #120
                    

                    我们可以拆解fact(5)计算的详细逻辑:

                    ===> fact(5)

                    ===> 5 * fact(4)

                    ===> 5 * (4 * fact(3))

                    ===> 5 * (4 * (3 * fact(2)))

                    ===> 5 * (4 * (3 * (2 * fact(1))))

                    ===> 5 * (4 * (3 * (2 * 1)))

                    ===> 5 * (4 * (3 * 2))

                    ===> 5 * (4 * 6)

                    ===> 5 * 24

                    ===> 120

                    8. 递推算法

                    • 递推算法：通常是通过循环来实现，直接从边界出发，直到求出函数值。

                      （1）斐波那契数

                      • 斐波那契数 ：该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。例如：0 1 1 2 3 5 8…

                      n = input('please input number: ')
                      n = int(n)
                      def fn(n):
                          if n==0:
                              return 0;
                          list = [0,1]
                          for i in range(2,n+1):
                              list.append(list[i-1]+list[i-2]);
                          return list[-1]
                      print(fn(n))
                      

                      9. 分治算法

                      • 分治算法：将一个问题分成多个和原问题相似的小问题，递归解决小问题，再将结果合并以解决原来的问题。常见的分治算法：快速排序、归并排序、二分搜索。

                        分治算法的基本步骤包括：

                        • 分解：将原问题分解为若干个规模较小，相互独立，与原问题形式相同的子问题。
                        • 解决：若子问题规模较小而容易被解决则直接解，否则递归地解各个子问题。
                        • 合并：将各个子问题的解合并为原问题的解。

                        10. 算法复杂度

                        • 时间复杂度：描述了一个算法执行所需的时间，随输入数据量的增长而增长的量级。通常用大O符号（O）来表示。时间复杂度越高，意味着算法运行所需的时间越长。因此，在选择算法时，我们希望选择时间复杂度较低的算法以提高效率。

                        • 空间复杂度：对一个算法在运行过程中临时占用存储空间大小的量度。空间复杂度越高，意味着算法运行所需的额外空间越大。因此，在选择算法时，我们也需要考虑其空间复杂度，以确保算法在运行时不会占用过多的空间资源。

                          11. python第三方库

                          Python使用import语句导入一个模块，导入官方模块，不需要考虑路径的问题，例如，导入系统自带的模块 math，直接导入即可。

                          import math
                          

                          导入以后，你就可以认为math是一个指向已导入模块的变量，通过该变量，我们可以访问math模块中所定义的所有公开的函数、变量和类：

                          # 属性：圆周率
                          import math
                          print(math.pi) # 3.141592653589793
                          # 函数：次方
                          print(math.pow(2, 3)) # 8.0
                          

                          如果希望导入模块的指定部分属性或函数，比如我们希望导入math模块的圆周率pi，那么可以使用from…import…语句。

                          # 属性：圆周率
                          from math import pi
                          print(pi) # 3.141592653589793
                          

                          这个时候，由于pow()函数没有导入，所以是不能使用pow()函数的。如果希望导入模块里面的所有内容，那么使用from …import *语句。

                          from math import *
                          print(pi) # 3.141592653589793
                          print(pow(2, 3)) # 8.0