python算法初步

算法的概念：

算法是计算机处理信息的本质，因为计算机程序本质上是一个算法来告诉计算机确切的步骤来执行一定的指令的任务。一般地，当算法在处理信息时，会输入设备或数据的存储地址读取数据，把结果写入输出设备或者某个存储地址提供以后再调用。

算法是独立存在的一种解决问题的方法和思想。

对于算法而言，实现的语言并不重要，重要的思想。算法可以有不同的语言描述现实版本，如c描述，C++描述，Python描述，我们现在是用Python语言进行描述实现。

算法的五大特性：

1，输入：算法具有0个或者多个输入。

2，输出：算法至少有一个或者多个输出

3，有穷性：算法在有限的步骤之后会自动结束而不会无限循环，并且每一个步骤可以在可接收的时间内完成

4，确定性：算法中的每一步都有确定的含义，不会出现二义性

5，可行性：算法的每一步都是可以的，也即是说每一步都能够执行有限的次数完成

注意代码第一次尝试：

import time

start_time = time.time()

for a in range(0, 1001):
    for b in range(0, 1001):
        for c in range(0, 1001):
            if a**2 + b**2 == c**2 and a+b+c ==1000:
                print(a, b, c)

end_time = time.time()

print(end_time-start_time)

注意执行结果和运行的时间：

0 500 500
200 375 425
375 200 425
500 0 500
254.58334787476848

第二次尝试代码：

import time

start_time = time.time()

for a in range(0, 1001):
    for b in range(0, 1001-a):
        c = 1000 - a - b
        if a**2 + b**2 == c**2:
            print(a, b, c)

end_time = time.time()

print(end_time - start_time)

第二次尝试结果：

0 500 500
200 375 425
375 200 425
500 0 500
0.5997700691223145

算法效率衡量：

对于上面的同一个问题，我们给出了两种解决算法，在两种算法的实现中，我们对程序执行对时间进行了测算，两端程序执行对时间相差悬殊，由此我们得出结论：实现算法程序对执行时间可以反应出算法对效率，即算法对优劣。

单靠时间值绝对可信吗？

加入我们将第二次尝试的算法程序运行在一台配置古老，性能地下的计算机中，情况会如何？，很可能运行的时间并不会比在我们的电脑中运行算法一的254秒快多少。

单纯依靠运行的时间来比较算法的优劣并不一定是客观准确的！程序的运行离不开计算机环境（包括硬件和操作系统），这些客观原因会影响程序运行的速度并反映在程序的执行时间上，那么如何才能客观评判一个算法的优劣呢？

时间复杂度与‘大O记法’

我们假定计算机执行算法的每一个基本操作的时间是固定的一个时间单位，那么有多少个基本操作就代表会花费多少时间单位。算法对于不同的机器环境而言，确切的单位时间是不同的，但是对于算法进行多少个基本操作（即花费多少时间单位）在规模数量级上却是相同的，由此可以忽略机器环境的影响而客观的反应算法的时间效率。

对于算法的时间效率，我们可以用大“O”记法来表示。大O记法：

    对于单调的整数函数f，如果存在一个整数函数g和实常数c>0,使得对于充分大于n总有f(n)<=c*g(n),就说函数g是f的一个渐近函数（忽略常数），记为f（n）=O（g（n）），也就是说，在趋向无穷的极限意义下，函数f的增长速度受到函数g的约束，也就是说函数f与函数g的特征相似。

时间复杂度：

假设存在函数g，使得算法A处理规模为n的问题示例所用时间为T（n）=O（g（n）），则称O（g（n））为算法A的渐进时间复杂度，建成时间复杂度，记为T（n）

如何理解‘大O记法’

对于算法进行特别具体的细致分析虽然很好，但在实践中的实际价值有限，对于算法的时间性质和空间性质，最重要的是其数量级和趋势，这些分析算法效率的主要部分。而计量算法基本操作数量的规模函数中哪些常量因子可以忽略不计。例如，可以认为3n2和100n2属于同一个量级，如果两个算法处理同样规模实例的代价分别为这两个函数，就认为他们的效率‘差不多’，都为n2级

最坏时间复杂度

分析算法时，存在几种可能的考虑：

～算法完成工作最少需要多少基本操作，即最优时间复杂度

～算法完成工作做多需要多少基本操作，即最坏时间复杂度

～算法完成工作平均需要多少基本操作，即平均时间复杂度

对于最优时间复杂度，其价值不大，因为它没有提供什么有用的信息，其反映的只是最乐观最理想的情况，没有参考价值。

最坏时间复杂度，提供了一种保证，表明算法在此种程度的基本操作中一定能完成工作。

对于平均时间复杂度，是对算法的一个全面评价，因次它完整全面的反映了这个算法的性质。但另一方面，这种衡量并没有保证，不是每个计算都在这个基本操作内完成，而且，对于平均情况的计算，也会因此应用算法的实例分布可能并不均匀而难以计算。因此，我们主要关注算法的最坏情况，也就是最坏时间复杂度。

时间复杂度的几条基本计算规则

1，基本操作，即只有常数项，认为其时间复杂度为O（1）

2，顺序结构，时间复杂度按加法进行计算

3，循环结构，时间复杂度按乘法进行计算

4，分支结构，时间复杂度取最大值

5，判断一个算法的效率时，往往只需要关注操作数量的最高次项，其他次要项和常数项可以忽略。

6，在没有特殊说明时，我们锁分析的算法时间复杂度都是最坏时间复杂度

算法分析：

1·第一次尝试的算法核心部分：

for a in range(0, 1001):
    for b in range(0, 1001):
        for c in range(0, 1001):
            if a**2 + b**2 == c**2 and a+b+c ==1000:
                print(a, b, c)

1·时间复杂度：

T（n）=O（n*n*n）=O（n的3次方）

2·第二次尝试的算法核心部分：

for a in range(0, 1001):
    for b in range(0, 1001-a):
        c = 1000 - a - b
        if a**2 + b**2 == c**2:
            print(a, b, c)

2·时间复杂度：

T（n）=O（n*n*（1+1））=O（n的2次方）

由此可见，我们尝试的第二种算法要比第一种算法的时间复杂度好多了。

常见时间复杂度：

执行次数函数举例	阶	非正式术语
12	O（1）	常数阶
2n+3	O(n）	线性阶
3n2+2n+1	O(n2)	平方阶
5log2n+20	O(logn)	对数阶
2n+3nlog2n+19	O(nlogn)	nlogn阶
6n3+2n2+3n+4	O(n3)	立方阶
2n	O(2n)	指数阶

常见时间复杂度之间的关系

所消耗的时间从小到大：

O(1) < O(logn) < O(n) < O(nlogn) < O(n2) < O(n3) < O(2n) < O(n!) < O(nn

python内置类型性能分析：

timeit模块是可以用来测试一小段python代码的执行速度。

语法：class timeit.Timer(stmt='pass',setup='pass',timer=<timer function>)

Timer是测量小段代码执行速度的类。

stmt参数是要测试的代码语句（statment）；

setup参数是运行代码时需要的设置；

timer参数是一个定时器函数，与平台有关。

timeit.Timer.timeit(number=1000000)

Timer类中测试语句执行速度的对象方法。

number参数是测试代码时的测试次数，默认是100万次

方法返回执行代码的平均耗时，一个float类型的秒数。