Python零基础速成班-第7讲-Python注释、算法基础、排序、查找、时间复杂度

Python零基础速成班-第7讲-Python注释、算法基础、排序、查找、时间复杂度 学习目标

1、注释
2、算法基础
3、排序、查找、时间复杂度
4、课后作业（4必做1挑战）

友情提示：将下文中代码拷贝到JupyterNotebook中直接执行即可，部分代码需要连续执行。

1、注释(note)介绍

1.注释就是对代码的解释和说明，其目的是让人们能够更加轻松地了解代码。
2.注释是编写程序时，写程序的人给一个语句、程序段、函数等的解释或提示，能提高程序代码的可读性。
3.在有处理逻辑的代码中，源程序有效注释量必须在20％以上。

代码注释分类 1.1 行注释：使用#号开头，在符号后那一行不会被编译（显示）

print("hello everyone!")    #向大家打招呼

hello everyone!

1.2 块注释：使用三个单引号 ’ 或者双引号 " 开头和结尾，被块注释符号中间的部分不会被编译

'''
这是使用三个单引号的多行注释
这是第二行
这是第三行
'''

'\n这是使用三个单引号的多行注释\n这是第二行\n这是第三行\n'

"""
这是使用三个双引号的多行注释
"""

'\n这是使用三个双引号的多行注释\n'

1.3 注释的使用，文档注释在函数中的应用

在函数体的第一行使用一对三个单引号 ‘’’ 或者一对三个双引号 “”" 来定义文档字符串。你可以使用 doc（注意双下划线）调用函数中的文档字符串属性。
编写示例如下：

def addfun(num1,num2):
    
    """ 完成传入的两个数之和
    :param num1: 加数1
    :param num2: 加数2
    :return: 求两个数的和
    """
    return num1 + num2

print( addfun.__doc__ )

 完成传入的两个数之和
    :param num1: 加数1
    :param num2: 加数2
    :return: 求两个数的和

1.4 文档注释常用编写风格

文档注释常用关键字：

①Parameters为函数传入参数
②Returns为函数返回结果
③Raises为函数可能会有的报错信息

1.4.1 这是现在流行的一种风格，reST风格，Sphinx的御用格式，比较紧凑。

“”"
This is a reST style.

:param param1: this is a first param
:param param2: this is a second param
:returns: this is a description of what is returned
:raises keyError: raises an exception
“”"

---

1.4.2 Google风格

“”"
This is a groups style docs.

Parameters:
param1 - this is the first param
param2 - this is a second param

Returns:
This is a description of what is returned\

Raises:
KeyError - raises an exception
“”"

---

1.4.3.Numpydoc (Numpy风格)

“”"
My numpydoc description of a kind
of very exhautive numpydoc format docstring.

Parameters

first : array_like
the 1st param name first
second :
the 2nd param
third : {‘value’, ‘other’}, optional
the 3rd param, by default ‘value’

Returns

string
a value in a string

Raises

KeyError
when a key error
OtherError
when an other error
“”"

1.5 一些注释经验

1. 注释不是越多越好。对于一目了然的代码，不需要添加注释。
2. 对于复杂的 *** 作，应该在 *** 作开始前写上相应的注释。
3. 对于不是一目了然的代码，应该在代码之后添加注释。
4. 绝对不要描述代码。一般阅读代码的人都了解Python的语法，只是不知道代码要干什么。

2、算法基础 Algorithm basis 2.1 我们以计算 π \pi π值为例子：可以使用下面公式 π 4 = 1 − 1 3 + 1 5 − 1 7 + 1 9 . . . \frac{\pi}{4}= 1-\frac{1}{3}+\frac{1}{5}-\frac{1}{7}+\frac{1}{9}... 4π​=1−31​+51​−71​+91​...

算法思路：

我们设计一个变量flag，当它为0时，做+法并设置为1，当他为1时，做-法并设置为0，反复循环形成+ - + - + -…

通过i%2有余数，求出奇数，得出1/i

pi=0
flag=0
for i in range(1,1000000):
    if i%2: #有余数 True
        if flag == 0:
            pi += 1/i
            flag=1
        else:
            pi -= 1/i
            flag=0
print(pi*4)    

3.141590653589692

2.2 我们还可以通过预估模型：蒙特卡洛模拟计算 π \pi π值

算法思路：

1. 想象一个圆形靶子，我们不停地向靶面射击，命名圆内的我们算是"击中" 也就是 x 2 + y 2 = 1 x^2+y^2=1 x2+y2=1。假如我们不停地射击，直到我们把这个方形的靶子全部覆盖"打成筛子"。
2. 圆的面积应该是 S c i r c l e = π r 2 S_{circle}={\pi}r^2 Scircle​=πr2
3. 方形的面积应该是 S s q u a r e = a 2 S_{square}=a^2 Ssquare​=a2
4. 也就是说 S c i r c l e / S s q u a r e = π r 2 / a 2 r = 1 , a = 2 {S_{circle}/S_{square}={\pi}r^2/a^2}_{r=1,a=2} Scircle​/Ssquare​=πr2/a2r=1,a=2​
5. S c i r c l e / S s q u a r e = π / 4 S_{circle}/S_{square}={\pi}/4 Scircle​/Ssquare​=π/4
6. π = 4 ∗ ( S c i r c l e / S s q u a r e ) {\pi}= 4 * (S_{circle}/S_{square}) π=4∗(Scircle​/Ssquare​)
   

在程序中trys 变量为我们尝试的次数，次数越多，越精确
hits 变量为命中数量
x = -1+2 * random()表明x轴在-1到1之间；y = -1+2 * random()表明y轴在-1到1之间
x ** 2 + y ** 2 <=1 表明击中⚪内

from random import random
trys =800000
hits =0
for i in range(trys):
    x = -1+2*random()
    y = -1+2*random()
    if x**2 + y**2 <=1:
        hits+=1
print("Estimate for pi={}".format(4*hits/trys))

Estimate for pi=3.140415

2.3 举例:从 0~100 中猜数字，有哪些算法，时间复杂度是多少？

1. 我们可以遍历0-100，时间复杂度 O ( n ) O(n) O(n)
2. 我们可以不断取中数，不断逼近答案，时间复杂度 O l o g 2 100 Olog_2^{100} Olog2100​
3. 哪种时间复杂度更低，不断取中数最多几次能取中？
4. 答案是7次，不断取中效率最高，时间复杂度最低。

2.4 完成一个计算机求平方根的算法： 提示：

①x>1，求x的平方根y，0 ②假设 guess是(low+high)/2，如果guess的平方非常接近x，那么y=guess
③若 g u e s s 2 guess^2 guess2 ④若 g u e s s 2 guess^2 guess2>x，high设定为guess，然后重复第二步
在程序中，trys为迭代次数，次数越多，越精准。

trys =10000
x =int(input("请输入需要求平方根的数字>>>\n"))
low,high=0,x
for i in range(trys):
    guess = (low+high)/2
    if guess**2 < x:
        low = guess
    else:
        high = guess
print(guess)

请输入需要求平方根的数字>>>
5
2.23606797749979

3、排序、查找、时间复杂度 3.1 我们简单介绍冒泡、插入、归并三种排序

1. Bubble Sort 多次遍历数组，每次遍历相邻元素，如果没有按照顺序排列，则互换他们。
2. Insertion Sort 重复地将新元素插入到一个排好序的子线性表中，直到整个线性表排好序。
3. Merge Sort 将数组分为两半，对每部分递归地应用归并排序，在两部分都排好序后，对它们进行归并。

1.冒泡排序Bubble Sort示例：因为是双循环嵌套，所以时间复杂度是O( n 2 n^2 n2)

①295481 259481 254981 254891 254819

②254819 245819 245189

③245189 241589

④241589 214589

⑤124589

import random  #冒泡排序
def bubbleSort(list:"需要排序的数组")->"输出排好序的数组":
    for i in range(1,len(list)):
        for j in range(0,len(list)-i):
            if list[j] > list[j+1]:
                list[j],list[j+1]=list[j+1],list[j]
    return list
bubbleSort(random.sample(range(0,100),8))

[32, 40, 42, 69, 80, 86, 91, 96]

2.插入排序Insertion Sort示例：将Current不断与之前的元素进行比较，如小于前一个元素则互换位置，时间复杂度介于 O(n) and O( n 2 n^2 n2)之间

①295481 Current=9

②295481 >>259481 Current=5

③259481 >>245981 Current=4

④245981 >>245891 Current=8

⑤245891 >>124589 Current=1

def insertionSort(list:list)->"sortedlist":
    for i in range(1,len(list)):
        current =list[i]
        k= i-1 #从左边第一个开始循环
        while k>=0 and list[k] > current: #左边大于current值时，向右移一位，直到不大于current
            list[k+1] = list[k]
            k-=1
        list[k+1] = current  #把current相应的位置赋值current
    return list
insertionSort([3,7,10,5,8,12,4,6])

[3, 4, 5, 6, 7, 8, 10, 12]

3.归并排序Merge Sort示例：不断向下拆分后比较，最后合并，时间复杂度O(n log n)

---

        29548167
    2954         8167
 29     54     81    67
2   9  5  4  8   1  6   7
 29     45     18    67
   2459          1678
        12456789    

---

merge sort 时间复杂度

          64         log n
        32  32         O(n)
      16      16       O(n)
     8          8      O(n)

import random
def mergeSort(list):
    n = len(list)#获取长度
    if n <=1:#如果列表长度1，直接返回
        return list
    mid = n//2 #取中间值，把数组拆分
    left = mergeSort(list[:mid])#取左半部分
    right = mergeSort(list[mid:])#取右半部分
    leftp = 0 #左半指针从0开始
    rightp = 0 #右半指针从0开始
    result =[]#定义空数组存储每次归并好的列表
    while leftp < len(left) and rightp < len(right):#当左右指针分别小于长度时
        if left[leftp] <= right[rightp]:
            result.append(left[leftp])
            leftp +=1
        else:
            result.append(right[rightp])
            rightp +=1
    result += left[leftp:]#考虑数组为奇数，把最后元素添加进来
    result += right[rightp:]
    return result
mergeSort(random.sample(range(0,100),20))

[0, 4, 8, 14, 16, 24, 35, 38, 49, 56, 62, 68, 75, 77, 78, 81, 87, 88, 89, 97]

3.2 Python系统排序采用归并排序MergeSort和插入排序InsertionSort相结合 例如对128位长度的数组进行排序，前期均采用归并排序，当长度到达16时，则采用插入排序

         128          Merge
        64  64        Merge
      32      32      Merge
     16         16    Insertion

3.3 查找及时间复杂度 O(1)时间复杂度为1的情况

def square(x):
    return x*x
square(100)

10000

查找数组中的最大值，需要遍历数组，时间复杂度为O(n)

def findmax(list):
    max = list[0]
    for i in range(1,len(list)):
        if list[i] > max:
            max = list[i]
    return max
findmax([1,4,0,8,4,9,3])

9

查找数组中重复的数字，需要双循环嵌套，时间复杂度为 O( n 2 n^2 n2)

def findduplicate(list):
    dupli=[]
    for i in range(len(list)):
        for j in range(i+1,len(list)):
            if list[i] == list[j]:
                dupli.append(list[i])
                break
    return dupli
findduplicate([1,3,5,7,9,2,3,6,8,0,7])

[3, 7]

二分法查找Binary Search，又称折半检索，时间复杂度为 O( l o g 2 n log_2n log2​n)

二分法查找思路：

1. 首先将给定值key与字典中间位置上元素的关键码(key)比较，如果相等，则检索成功。
2. 否则，若key小，则在字典前半部分中继续进行二分法检索。
3. 若key大，则在字典后半部分中继续进行二分法检索。
4. 这样，经过一次比较就缩小一半的检索区间，如此进行下去，直到检索成功或检索失败，失败返回-1。
5. 二分法检索是一种效率较高的检索方法。

进阶提示：
二分法查找需要先对数组进行排序。

def binarySearch(list,value):
    low=0
    high=len(list)
    while(low <= high):
        mid = (low + high) // 2
        if (list[mid]==value):
            return mid
        elif (value > list[mid]):
            low = mid + 1
        else:
            high = mid - 1
    return -1
print(binarySearch([1,2,3,4,5,6,7],5))

4

4、课后作业，答案在下一讲 1、完成一个包含文档注释的函数(函数功能为两个数相除)，注释风格为主流reST Style，包含param，return，raise，design by，createdate等关键字。

您的代码：

2、请统计"Hello, have you tried our turorial section yet?" 中每个元音字母各出现了多少次？

您的代码：

3、根据公式$n X X X (n-1)$，生成一个100个数组的列表，例如：

[0,2,6,12,20,30,42…]

您的代码：

4、制作一个Length Uint Converter，通过dict快速实现①选择转换类型②参数输入③结果输出 1英寸inch=25.4毫米 1英尺feet=30.5厘米 1英里mile=1.61公里 1码yard=0.914米 1浪wave=204米

您的代码：

*(挑战) 5、编程实践项目 大数据下：比较两种排序的效率情况 随机从0~100000中，取1000个整数，填入数组，分别进行冒泡排序和归并排序(两种方法可参考上文书写)，比较它们的效率(执行耗时)。再取10000个整数，再试试执行效率。将程序写进class，分别通过class+函数名调用方法。

tips:函数运行时间可以使用下列函数

def timer(f):
    def _f(*args):
        t0=time.time()
        f(*args)
        return time.time()-t0
    return _f

您的代码：

5、Python零基础速成班-第6讲-Python异常处理Exception，try&except，raise，assert，输入模块pyinputplus 课后作业及答案 1、计算银行带来的回报，假设你存银行一笔钱是10000，年利率是5%，则计算20年后，变成了多少钱？打印每一年的变化

rate=5.00
balance =10000.00
bal_list = []
for year in range(1,21):
    balance += balance*rate/100
    print("%4d %10.2f" %(year,balance))
    bal_list.append(balance)

   1   10500.00
   2   11025.00
   3   11576.25
   4   12155.06
   5   12762.82
   6   13400.96
   7   14071.00
   8   14774.55
   9   15513.28
  10   16288.95
  11   17103.39
  12   17958.56
  13   18856.49
  14   19799.32
  15   20789.28
  16   21828.75
  17   22920.18
  18   24066.19
  19   25269.50
  20   26532.98

2、(扩展)在第一题的基础上通过matplotlib绘制一张x(金额)/y(年)的曲线图(收益表)

import matplotlib.pyplot as plt
fig,ax =plt.subplots()
ax.plot([i for i in range(1,21)],bal_list)
ax.set(xlabel="n th year",ylabel="Money",title="How much I got")
ax.grid()
plt.show()

3、安装并使用输入模块pyinputplus，完成age输入验证(数字0~110，最多输入2次)，性别输入(男、女，限时10秒钟内)，输出年龄，性别

import pyinputplus as pi
age = pi.inputInt("Please enter age：",min=0,max=110,limit=2)
gender = pi.inputChoice(['Male','Female'],timeout=10)
print("age={} gender={}".format(age,gender))

Please enter age：20
Please select one of: Male, Female
Male
age=20 gender=Male

4、制作一个菜单，其中包括小吃、饮料、主食等分类，每个分类下包含多种食物，左边是名字右边是价格，请尽量美观的把菜单打印出来。

menu_dict={
    "1.主食":{"1.面条":6,"2.米饭":2,"3.抄手":8,"4.馒头":1},
    "2.饮料":{"1.芬达":3,"2.无糖可乐":4,"3.面汤":1,"4.酸梅汁":2},
    "3.小吃":{"1.甩饼":4,"2.糍粑":7,"3.小油条":8,"4.金银馒头":6},
}

menu_dict={
    "1.主食":{"1.面条":6,"2.米饭":2,"3.抄手":8,"4.馒头":1},
    "2.饮料":{"1.芬达":3,"2.无糖可乐":4,"3.面汤":1,"4.酸梅汁":2},
    "3.小吃":{"1.甩饼":4,"2.糍粑":7,"3.小油条":8,"4.金银馒头":6},
}
for k,v in menu_dict.items():
    print("{}".center(20,"-").format(k))
    for k1,v1 in v.items():
        print("{}".ljust(6," ").format(k1),"价格:{}".rjust(15-len(k1.encode("GBK"))," ").format(v1))

---------1.主食---------
1.面条         价格:6
2.米饭         价格:2
3.抄手         价格:8
4.馒头         价格:1
---------2.饮料---------
1.芬达         价格:3
2.无糖可乐     价格:4
3.面汤         价格:1
4.酸梅汁       价格:2
---------3.小吃---------
1.甩饼         价格:4
2.糍粑         价格:7
3.小油条       价格:8
4.金银馒头     价格:6

*(挑战)5、编程实践项目 判卷问题：设计一个自动判卷程序 我们帮助数学老师判卷子，本次数学题一共10题，每题10分。已经知道正确答案分别是"adbdcacbda"，要求输入学生结果能找出错误并指出最终分数。

correct_answers = "adbdcacbda"
correct_list = list(correct_answers)
done =False
while not done:
    user_answers = input("Enter your exam answers!\n>>>")
    if len(user_answers)== len(correct_answers):
        user_list =list(user_answers)
        done = True
    else:
        print("length is not equal")
judge_list= list(map(lambda user,corr:"Y" if user ==corr else "X",user_list,correct_list))
judge_dict={i: judge_list.count(i)for i in set(judge_list)}
total= judge_dict["Y"]*10
print("user_answers={}\njudgement={}\nfinallytotal={}".format(judge_list,judge_dict,total))

Enter your exam answers!
>>>abbdaccdda
user_answers=['Y', 'X', 'Y', 'Y', 'X', 'X', 'Y', 'X', 'Y', 'Y']
judgement={'X': 4, 'Y': 6}
finallytotal=60