计算机的发展遵循摩尔定律

静态语言编译过程
脚本语言解释过程

程序编写原则：IPO

1. 分析问题
2. 划分边界
3. 设计算法
   4.编写程序
   5.调试测试
   6.升级维护
   两种编程方式：交互式（适合语法练习）和文件式（主要方式）

函数

函数的定义

#由def关键字、函数名字以及扩号、括号里的参数与冒号组成

def square_of_sum(L): # square_of_sum是函数名，也可以命名成别的
    sum = 0
    for x in L:
        sum = sum + x * x
    return sum
print square_of_sum([1, 2, 3, 4, 5])
print square_of_sum([-5, 0, 5, 15, 25])

# 函数体内部的语句在执行时，一旦执行到return时，函数就执行完毕，并将结果返回。

函数的返回多值和递归

import math  # math包提供了多种函数，我们先用import引用它：
def quadratic_equation(a, b, c):
    x1=(-b+math.sqrt(b*b-4*a*c))/(2*a) #写的时候也要加上math.funtion name
    x2=(-b-math.sqrt(b*b-4*a*c))/(2*a)
    return x1,x2   #Python的函数返回多值其实就是返回一个tuple，但写起来更方便。
print quadratic_equation(2, 3, 0)
print quadratic_equation(1, -6, 5)

• 在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。
• 使用递归函数需要注意防止栈溢出。

# 第一个例子 fact(n) = n! = 1 * 2 * 3 * ... * (n-1) * n = (n-1)! * n = fact(n-1) * n
def fact(n): 
    if n==1:
        return 1
    return n * fact(n - 1)

# 第二个例子
def move(n, a, b, c):  #定义move函数
   if n ==1:                # 如果只有1个圆盘
       print a, '-->', c  #圆盘路径直接从A到C就可以了
       return              #结束
   move(n-1, a, c, b)  #如果不是一个圆盘，那首先应该将n-1个圆盘从A移动到B
   print a, '-->', c      #将A柱上最后一个圆盘从A移动到C就
   move(n-1, b, a, c) #将B上的n-1个圆盘移动到C
move(4, 'A', 'B', 'C') 

python之定义默认默认参数和可变参数

• 函数的默认参数的作用是简化调用
• 由于函数的参数按从左到右的顺序匹配，所以默认参数只能定义在必需参数的后面
• 可变参数的名字前面有个 * 号，我们可以传入0个、1个或多个参数给可变参数

>>> int('123') # 默认十进制
123
>>> int('123', 8) # 八进制下的123等于1*64+2*8+3
83

# 第二个例子
def greet(name='world'):
    print 'Hello, ' + name + '.' 
greet()#没有传入，为默认
greet('Bart') #传入输出其他

# 第三个例子
# OK:
def fn1(a, b=1, c=2):
    pass 
# Error:
def fn2(a=1, b): #默认参数a=1，应该在后面
    pass 

#实操：编写接受可变参数的平均函数
def average(*args):
    sum = 0.0
    if len(args) == 0:
        return sum
    for x in args:
        sum = sum + x
    return sum / len(args)

对list、tuple以及字符串切片

• 取前n个数： L[0:n]第一个索引为0可以省略，写成L[:n],可以得出这些结果里不包括L(n)；
• L[:]表示从头到尾
• 取第a到b-1个索引的数：L[a:b]，结果不包括L[b]，列表里有b-a个数
• 从第a到b-1个索引的数，每隔n取一次：L[a:b-1:n]，a=0是可省略，从头到尾每隔n取一次：L(::n)
• 同时支持倒序切片，但也是从左到右的序列。记住倒数第一个元素的索引是-1。
• tips:切片包含起始索引，不包含结束索引。
• 字符串切片也是同样的原理，字符串的初始索引也是0

# 实际操作1
L = range(1, 101) #从0开始101停止，步长为1
print L[:10] #取前10个数
print L[2::3] # 3的倍数
print L[4:50:5] #50以内包括50的5的倍数
print L[-10:] #取出后10个数
print L[-46::5] #取出后10个5的倍数，确定起始数为L[-1-5*9] 

#练习2：首字母大写，而其他字幕不受影响
def firstCharUpper(s):
    return s[0].upper()+s[1:]
print firstCharUpper('hello') # 输出为Hello

迭代

• 在python中，用for...in来迭代，从而取出有序和无序集合中的每一个元素
• Python 的 for循环不仅可以用在list或tuple上，还可以作用在其他任何可迭代对象上。
• 迭代永远是取出元素本身，而非元素的索引
• enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。语法为enumerate(sequence, [start=0])
• zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。语法为 zip([iterable, ...])
• dictionary的values() 方法实际上把一个 dict 转换成了包含 value 的list， 但是 itervalues() 方法不会转换，它会在迭代过程中依次从 dict 中取出 value，所以 itervalues() 方法比 values() 方法节省了生成 list 所需的内存。
• items() 方法把dict对象转换成了包含tuple的list，我们对这个list进行迭代，可以同时获得key和value。但iteritems() 不把dict转换成list，而是在迭代过程中不断给出 tuple，所以， iteritems() 不占用额外的内存。
• for 循环可作用的迭代对象远不止 list，tuple，str，unicode，dict等，任何可迭代对象都可以作用于for循环，而内部如何迭代我们通常并不用关心。
• 如果一个对象说自己可迭代，那我们就直接用 for 循环去迭代它，可见，迭代是一种抽象的数据操作，它不对迭代对象内部的数据有任何要求。

练习1：用for循环迭代数列 1-100 并打印出7的倍数。
for i in range(1,101):
    if i%7==0:
        print i

练习2 ：给定一个dict，计算所有同学的平均分。
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59, 'Paul': 74 }
sum = 0.0
for v in d.itervalues():
    sum+=v
print sum/len(d)

练习3：请根据dict，打印出 name : score，最后再打印出平均分 average : score。
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59, 'Paul': 74 }
sum = 0.0
for k, v in d.iteritems():
    sum = sum + v
    print k,":",v
print 'average', ':', sum/len(d)

生成列表

写列表生成式时，把要生成的元素 x * x 放到前面，后面跟 for 循环，就可以把list创建出来
列表生成式的 for 循环后面还可以加上 if 判断
for循环可以嵌套，因此，在列表生成式中，也可以用多层 for 循环来生成列表。

练习1：
print [x*(x+1) for x in range(1,100,2)]
练习题2：
def capital_letter(L):
  return [x.upper() for x in L if isinstance(x,str)]  #变成大写的，且排除掉不是字符串的
print capital_letter(['hello','world',123])
练习3：
对于字符串 'ABC' 和 '123'，可以使用两层循环，生成全排列：
L = []
for m in 'ABC':
    for n in '123':
        L.append(m + n)
练习4：找到从左到右倒过来一样的三位数
L=[]
for a in range(1,10):
    for b in range(0,10):
        for c in range(0,10):
            if a==c:
                L.append(100*a+10*b+c)
print (L)

需要注意区分，形参和实参；全局变量和局部变量