python迭代演算法編程

⑴ python中什麼是迭代

如果給定一個list或tuple，我們可以通過for循環來遍歷這個list或tuple，這種遍歷我們稱為迭代（Iteration）。

在Python中，迭代是通過for ... in來完成的，而很多語言比如C或者Java，迭代list是通過下標完成的，比如Java代碼：

for (i=0; i<list.length; i++) { n = list[i];
}

可以看出，Python的for循環抽象程度要高於Java的for循環，因為Python的for循環不僅可以用在list或tuple上，還可以作用在其他可迭代對象上。

list這種數據類型雖然有下標，但很多其他數據類型是沒有下標的，但是，只要是可迭代對象，無論有無下標，都可以迭代，比如dict就可以迭代：

>>> d = {'a': 1, 'b': 2, 'c': 3}>>> for key in d:... print(key)
...
a
c
b

因為dict的存儲不是按照list的方式順序排列，所以，迭代出的結果順序很可能不一樣。

默認情況下，dict迭代的是key。如果要迭代value，可以用for value in d.values()，如果要同時迭代key和value，可以用for k, v in d.items()。

由於字元串也是可迭代對象，因此，也可以作用於for循環：

>>> for ch in 'ABC':... print(ch)
...
A
B
C

所以，當我們使用for循環時，只要作用於一個可迭代對象，for循環就可以正常運行，而我們不太關心該對象究竟是list還是其他數據類型。

這個網站有很多Python的系統、基礎教程，可以看看。網頁鏈接

⑵ 求解答Python中一個簡單的迭代

首先這是個遞歸函數，功能是將一個10進制數，轉換成一個其他進制的數，這里轉換只是將結果列印出來。
遞歸這么調用foo(126,2)->foo(63,2),0->foo(31,2)，1，0->foo(15,2)，1，1，0->foo(7,2),1，1，1，0->foo(3,2)，1，1，1，1，0->foo(1,2)，1，1，1，1，1，0->1,1,1,1,1,0(共5個1，這個程序寫的其實並不對。)有函數表示前面的先算出來，後面才能列印。所以雖然0是最先要列印的，但是卻在最後一位，那是因為print放在函數調用的後面。
這個函數的應該在print後面加一句elif num>0:print num這句和if縮進相同，這個程序的功能才正常，否則最高位會缺失。
不明白可追問。

⑶ 牛頓迭代法的Python代碼

Python代碼以實例展示求解f(x) = (x-3）**3，f(x) = 0 的根。def f(x):
return (x-3）**3 』''定義f(x) = (x-3）**3'''
def fd(x):
return 3*((x-3）**2） 』''定義f'(x) = 3*((x-3）**2）
def newtonMethod(n,assum):
time = n
x = assum
Next = 0
A = f(x)
B = fd(x)
print('A = ' + str(A) + ',B = ' + str(B) + ',time = ' + str(time))
if f(x) == 0.0:
return time,x
else:
Next = x - A/B
print('Next x = '+ str(Next))
if A == f(Next): print('Meet f(x) = 0,x = ' + str(Next)) 』''設置迭代跳出條件，同時輸出滿足f(x) = 0的x值'''
else:
returnnewtonMethod(n+1,Next)
newtonMethod(0,4.0) 』''設置從0開始計數，x0 = 4.0'''

⑷ 什麼是迭代，Python入門教程

迭代就是把迭代得到的值作為下一次迭代的初始值

舉個栗子,求Fibonaci的數列第n項,這個就是最簡單的迭代

#FibonaciSequence
#f(1)=1
#f(2)=1
#f(n)=f(n-1)+f(n-2)when(n>2)

a=1
b=1
n=8
sum=0
foriinrange(n-2):
sum=a+b
a=b
b=sum

printsum

⑸ python中的迭代式什麼意思

數學上面的定義:迭代公式就是指用現在的值，代到一個公式裡面，算出下一個值，再用下一個值代入公式，如此往復地代。比如:x=(x+2/x)/2 你隨便拿一個x=10代入，得x=(10+2/10)/2=5.1，再代進去x=(5.1+2/5.1)/2=2.746，再代入得1.737，以此類推。

在python中，迭代式也可以是遞歸的調用，下面給你舉個例子:

def f(n):

if n == 0 or n == 1 or n == 2: return 1

else: return f(n-1) + f(n-2)

這就是一個簡單的第n項斐波那契數的求法，這里就用的是迭代式。另外的例子就是牛頓迭代法，採用逐次漸進的效果求出n的開方數，下面是例子:

def f(guess):

return guess ** 2

def fd(guess):

return 2 * guess

def SquareRootNR(x， epsilon):

guess = x / 2.0

diff = f(guess) - x

ctr = 1

while abs(diff) > epsilon and ctr <= 100:

guess = guess - diff / fd(guess)

diff = f(guess) - x

ctr += 1。

⑹ python演算法設計的步驟有三步分別是

1. 弄清楚題目的意思，列出題目的輸入、輸出、約束條件
其中又一道題目是這樣的：「有一個mxn的矩陣，每一行從左到右是升序的，每一列從上到下是升序的。請實現一個函數，在矩陣中查找元素elem，找到則返回elem的位置。」題設只說了行和列是升序的，我在草稿紙上畫了一個3x4的矩陣，裡面的元素是1~12，於是我就想當然的認為矩陣的左上角是最小的元素，右下角是最大的元素。於是整個題目的思考方向就錯了。
2. 思考怎樣讓演算法的時間復雜度盡可能的小
繼續以上面的題目為例子。可以有如下幾種演算法：
a. 遍歷整個矩陣進行查找，那麼復雜度為O(m*n)；
b. 因為每一行是有序的，所以可以對每一行進行二分查找，復雜度為O(m*logn)。但是這樣只用到了行有序的性質。
c. 網上查了一下，最優的演算法是從矩陣的左下角開始，比較左下角的元素（假設為X）與elem的大小，如果elem比X大，那麼X所在的那一列元素就都被排除了，因為X是該列中最大的了，比X還大，那麼肯定比X上面的都大；如果elem比X小，那麼X所在的那一行就可以排除了，因為X是這一行里最小的了，比X還小那麼肯定比X右邊的都小。每迭代一次，矩陣的尺寸就縮小一行或一列。復雜度為O(max(m,n))。
可以先從復雜度較高的實現方法入手，然後再考慮如何利用題目的特定條件來降低復雜度。
3. 編寫偽代碼或代碼

⑺ 用python寫程序，用用迭代法求x=a**(1/2)（a的平方根）

def sqrt_newton(num):
x=sqrt(num)
y=num/2.0
count=1
while abs(y-x)>0.00001:
print count,y
count+=1
y=((y*1.0)+(1.0*num)/y)/2.0000
return y
希望 是你想要的結果。

⑻ python解決jacob迭代法求解線性方程組

題主好. 經典的 Jacobi 迭代演算法如下:

設 A = D - E, 則 x = D^{-1}*b + D^{-1}*E*x = C + T*x

可以參考如下代碼(復制代碼後請注意縮進):

import numpy as np

def linalg_solve_jacobi(A, b, x0, max_it, tol=1.0e-7):

# 判斷 A, b 的維數是否正確

if A.shape[0]!=A.shape[1] or A.shape[0]!= b.shape[0]:

raise Exception('A must be square or A and b must be compatible!')

D = np.diag(A)

# 判斷對角元素是否含零

if np.amin(np.absolute(D)) < 1e-14:

raise Exception('Diagonal elements of A must not be zeros!')

# 設置初始迭代步數為0

n = 0

#

# Jacobi 演算法:

# 設 A = D - E, 則 x = D^{-1}*b + D^{-1}*E*x = C + T*x

#

invD = np.diag(1.0/D) # invD is inv(D)

C = np.dot(invD,b) # C is inv(D)*b

T = np.dot(invD, np.diag(D)-A) # T is inv(D)*E

while n < max_it:

x = C + np.dot(T, x0)

if np.linalg.norm(x-x0)<tol:

break

x0[:] = x

n+=1

# 如果超過最大迭代步數, 迭代失敗

if n>max_it:

raise Exception('Failed to converge within {} steps!'.format(max_it))

# 成功, 返回

return x, n

if __name__ == "__main__":

A = np.array([[10, -1, 2, 0],[-1, 11, -1, 3],

[2, -1, 10, -1], [0, 3, -1, 8]], dtype=np.float64)

b = np.array([6, 25, -11, 15], dtype=np.float64)

x0 = np.array([0,0,0,0], dtype=np.float64)

max_it = 100

tol = 1.0e-7

x,n=linalg_solve_jacobi(A, b, x0, max_it, tol)

print(x,n)