python笔记（一）

课程地址：http://v.163.com/special/opencourse/bianchengdaolun.html

1~3节可略

第四节：

def solve(numlegs,numheads):
    for numchicken in range(0,numheads+1):  ##numchicken可以取值：0~numheads
        numpigs=numheads-numchicken
        ##print numpigs,numchicken
        tolleg=4*numpigs+2*numchicken
        if(tolleg==numlegs):
            return [numpigs,numchicken]
    return [None,None]  ##缩进->嵌套，可以返回多个参数

def bb():
    heads=int(input("input "))
    legs=int(input("input "))
    pigs,chicken=solve(legs,heads)
    if pigs==None:
        print "no"
    else:
        print 'pig',pigs
        print 'chicken',chicken

bb()  ##函数调用
        

第五节：

def sqrtBit(x,epsilon):
	assert x>=0,'x<0'
	assert epsilon>0,'epsilon<=0'
	low=0
	high=max(x,1.0)  ##注意小数，它的平方根不在区间[0，x]之间，而在[0,1]之间
	quess=(low+high)/2.0
	ctr=1
	while abs(quess**2-x)>epsilon and ctr<=100:
		print quess**2
		if quess**2<=x:
			low=quess
		else:
			high=quess
		quess=(low+high)/2.0
		ctr+=1
	assert ctr<=100,'迭代次数太多，计算失败！'
	print '迭代次数：',ctr,'结果：',quess
	return quess

运行结果：

第六节：   二分法，牛顿，拉复生方法，对于数组的简介

元组：元组和列表十分类似，只不过元组和字符串一样是 不可变的 即你不能修改元组。元组通过圆括号中用逗号分割的项目定义。元组通常用在使语句或用户定义的函数能够安全地采用一组值的时候，即被使用的元组的值不会改变。

百科：元组

1）牛顿切线法：

guess(i+1)=guess(i)-f(guess(i))/2*guess(i)
例如：f(x)=x^2-16,x=guess(i)
f(3)=9-16=-7
guess(i+1)=3-f(3)/2*3=4.1666

def SqrtBitNR(x,eplision):
    assert x>=0,'x<0'
    assert eplision>0,'eplision>0'
    x=float(x)
    guess=x/2.0
    diff=guess**2-x  ##f(x)
    ctr=1
    while abs(diff)>eplision and ctr<=100:
        ##print 'f(x):',diff,'guess:',guess
        guess=guess-diff/(2.0*guess)
        diff=guess**2-x
        ctr+=1
    assert ctr<=100,'迭代次数太多'
    print 'NR method:'
    print 'guess:',guess,'iterator:',Sqctr
    return guess

2）LIST：

def showLists():
    Techs=['MIT','CCLTAH']
    print Techs
    raw_input()  ##相当于readline()，读取换行符继续
    Iuys=['Hacuccd','Ycle','Bccn']
    print Iuys  ##把整个list都添加到了list中，得到了一个包含list的list
    raw_input()
    Univs=[]
    Univs.append(Techs)
    print Univs
    raw_input()
    Univs.append(Iuys)  ##Univs变成了包含两个list的list
    print Univs
    raw_input()
    for e in Univs:
        print e
        for c in e:print c 
    raw_input()
    Univs=Techs+Iuys
    print Univs
    raw_input()
    Iuys.remove('Ycle')
    print Iuys
    Iuys[1]=-1
    print Iuys
    raw_input()
    L=[3,'liy',9.9,['a']]
    print L
    L.remove(9.9)
    print L
    print L[0]

运行结果：

第七节：    数组以及可变性，字典，伪码，对于代码运行效率的简 介

def Test():
    L1=[1,2,3]
    print 'L1:',L1
    ##L1[3]=5
    L2=L1
    print 'L2:',L2
    L1[0]=4
    print 'L1:',L1
    print 'L2:',L2
    L1=[]
    print 'L1:',L1
    print 'L2:',L2

def showDicts():
    EtoF={'one':'ggg','soccer':'football','op':'lufei'}
    print EtoF['soccer']
    raw_input()
    ##print EtoF[0]
    print EtoF
    raw_input()
    NtoS={1:'one','2':'two','3':'three'}
    print NtoS
    print NtoS.keys()
    raw_input()

def Temp():
    inputOK=False
    while not inputOK:
        base=input('INput:')
        if type(base)==type(1.0):inputOK=True
        else: print('Error,input is not a floating:')
    

第八节：   算法的复杂度：对数级，线性级，平方级，指数级 

1）汉诺塔递归（算法复杂度推导）：
T(n)=1+2*T(n-1)
=1+2*1+4*T(n-2)
=1+2*1+4*1+8*T(n-3)
=(1+2+4+…+2^(k-1))+(2^k)*(n-k)
=2^(k+1)-1
=2^n-1
其中，n-k=1,k=n-1

def Tower(size, fromStack, toStack, spareStack):

    if size == 1:

        print "move disk from ", fromStack, " to ", toStack

    else:

        Tower(size - 1, fromStack, spareStack, toStack)

        Tower(1, fromStack, toStack, spareStack)

        Tower(size - 1, spareStack, toStack, fromStack)

2）递归计算幂

def exp(a,b):
    if b==1:
        return a
    if (b%2)==0:
        return exp(a*a,b/2)
    else: return a*exp(a,b-1)

3）对有序查找的比较（普通--二分）

def search(s,e):
    ##s=range(i)
    answer=None
    i=0
    numCompare=0
    while i<len(s) and answer==None:
        numCompare+=1
        if e==s[i]:
            answer=True
        elif e<s[i]:
            answer=False
        i+=1
    print numCompare    
    return answer

def bsearch(s,e,first,last):
    ##s=range(i)
    if last-first<2:
        return s[first]==e or s[last]==e
    mid=first+(last-first)/2
    if s[mid]==e:
        return True
    if s[mid]>e:
        return bsearch(i,e,first,mid-1)
    return bsearch(i,e,mid+1,last)