각 반복에서 목록의 두 개의 연속 값 사용

Question

아래 코드 중 일부를 게시했습니다. Newton() 함수는 Bezier() 함수를 호출합니다. Bezier() 함수에는 p0과 p3을 얻을 수있는 곳의 목록이 있습니다. 내가하려는 것은 첫 번째 반복에서 프로그램은 plist에서 첫 번째와 두 번째 항목을 p0 및 p3으로 가져와야합니다. 두 번째 반복에서 p0와 p3은 두 번째와 세 번째 항목입니다. 반복 할 때마다 p0 및 p3 값이 변경되어야합니다. 새로운 p0는 오래된 p3과 같습니다. 이 코드를 제대로 삽입 할 수 없습니다. 고맙습니다. 그것은

import math 

w = 1.0 

def Newton(poly): 
    """ Returns a root of the polynomial""" 
    x = 0.5 # initial guess value 
    counter = 0 
    epsilon = 0.000000000001 
    poly_diff = poly_differentiate(poly) 

    while True: 
     x_n = x - (float(poly_substitute(poly, x))/float(poly_substitute(poly_diff, x))) 
     counter += 1 
     if abs(x_n - x) < epsilon : 
      break 
     x = x_n 
     print "\tIteration " , counter , " : ", x_n 

    print "u: ", x_n 
    Bezier(x_n) 

def Bezier(x_n) : 
    """ Calculating sampling points using rational bezier curve equation""" 
    u = x_n 
    plist = [0.5, 0.1, 0.4, 0.35, 0.8, 0.6, 1.0, 0.2, 0.7, 0.9] # list of parameter values of the phonemes 

    for i in range(len(plist) - 1) : 
     p0 = plist[i] 
     p3 = plist[i + 1] 
     p1 = p0 
     p2 = p3 
     print p0, p3 
     p_u = math.pow(1 - u, 3) * p0 + 3 * u * math.pow(1 - u, 2) * p1 \ 
      + 3 * (1 - u) * math.pow(u, 2) * p2 + math.pow(u, 3) * p3 
     p_u = p_u * w 
     d = math.pow(1 - u, 3) * w + 3 * u * w * math.pow(1 - u, 2) + 3 * (1 - u) * w * math.pow(u, 2) + math.pow(u, 3) * w 
     p_u = p_u/d 

    print "p(u): ", p_u 
    return plist 

if __name__ == "__main__" : 

Answer 1

변경하여 Bezier 기능의 상단이

def Bezier(x_n, p0, p3) : 
    """ Calculating sampling points using rational bezier curve equation""" 
    u = x_n 
    p1 = p0 
    p2 = p3 

같이하기

해당 루프를 제거하고 plist을 완전히 제거하십시오.

그런 다음 time 함수에서처럼 보이도록 변경 (내 대답에서 이전 질문 getting a boundary of an item from another list에) :

def time() : 
    tlist = [0.0, 0.12, 0.16, 0.2, 0.31, 0.34, 0.38, 0.46, 0.51] # list of start time for the phonemes 
    plist = [0.5, 0.1, 0.4, 0.35, 0.8, 0.6, 1.0, 0.2, 0.7, 0.9] # list of parameter values of the phonemes 

    total_frames = math.floor(tlist[-1]/0.04) 
    t_u = 0.0 
    i = 0 
    while i < len(tlist) - 1: 
     # if the number is in the range 
     # do the calculations and move to the next number 
     if t_u > tlist[i] and t_u < tlist[i + 1] : 
      print "\n The t_u value:", t_u, 'is between', 
      print "start:", tlist[i], " and end: ", tlist[i+1] 
      poly = poly_coeff(tlist[i], tlist[i + 1], t_u) 
      Newton(poly, plist[i], plist[i+1]) 
      t_u = t_u + 0.04 # regular time interval 

     # if the number is at the lower boundary of the range no need of calculation as u = 0 
     elif t_u == tlist[i] : 
      print "\n The t_u value:", t_u, 'is on the boundary of', 
      print "start:", tlist[i], " and end: ", tlist[i+1] 
      print "u : 0" 
      Bezier(0, plist[i], plist[i+1]) 
      t_u = t_u + 0.04 # regular time interval 

     # if the number is at the upper boundary of the range no need of calculation as u = 1 
     elif t_u == tlist[i + 1] : 
      print "\n The t_u value:", t_u, 'is on the boundary of', 
      print "start:", tlist[i], " and end: ", tlist[i+1] 
      print " u : 1" 
      Bezier(1, plist[i], plist[i+1]) 
      t_u = t_u + 0.04 # regular time interval 

     # if the number isn't in the range, move to the next range 
     else : 
      i += 1 

유일한 변화는 거기 plist을 넣고 Newton에 plist 값을 전달하고, Bezier. 당신 Newton 기능

유일한 변화는 내 코드가 비슷한 것 같다

Bezier(x_n, p0, p3) 

Answer 2

>>> p = [1, 2, 3, 4, 5] 
>>> for p1, p2 in zip(p, p[1:]): 
...  print p1, p2 
... 
1 2 
2 3 
3 4 
4 5 

도움이됩니까?

Answer 3

아마 pairwise 반복자 itertools recipes에서 도움이 될까요?

발전기는 아마 이것에 대한 선택의 나의 방법이 될 것입니다

from itertools import izip, tee 
def pairwise(iterable): 
    "s -> (s0,s1), (s1,s2), (s2, s3), ..." 
    a, b = tee(iterable) 
    next(b, None) 
    return izip(a, b) 

Answer 4

, 그들은 간단하고 쉽습니다, 다음이 수 싸서 및 루프

>>> def solution_pairs(list): 
...  for p0, p3 in zip(list, list[1:]): 
...   yield (p0, p3) 

을 위해 내장 된보다 더 모듈화 할 수있다 루프

>>> list = [1, 2, 3, 4, 5] 
>>> for p0, p3 in solution_pairs(list): 
...  print p0, p3 
1 2 
2 3 
3 4 
4 5 

의에 sussinctly 사용자 코드에서 사용할 수 당신은 현재 발전기에 있고 당신이 그렇게 경사 인 경우는 p_u를 얻을 수있는 루프 전체를 포장 할 수있다.

Answer 5

실제로, 얼마 전에 itertools 조리법에 존재 창 슬라이딩 라고 요구하는 알고리즘은

:

이

from itertools import islice 

def window(seq, n=2): 
    "Returns a sliding window (of width n) over data from the iterable" 
    " s -> (s0,s1,...s[n-1]), (s1,s2,...,sn), ...     " 
    it = iter(seq) 
    result = tuple(islice(it, n)) 
    if len(result) == n: 
     yield result  
    for elem in it: 
     result = result[1:] + (elem,) 
     yield result