파이썬 테스트 내 메서드

Question

안녕 얘들 아 내 방법을 테스트에 대한 빠른 질문이 있습니다. 임 지난주 파이썬으로 새로운하지만 노력하고 있습니다. 나의 임무는 카드의 목록을 취하고 특정 방식으로 그들을 정렬하는 방법을 만드는 것이었다. 내가 파이썬 셸에서 테스트했기 때문에 모든 내 검사 및 if 문과 같은 작업을 알고 있지만 껍질에 모든 코드를 넣으면 인덱스 (올바른 들여 쓰기)가 부족할 것입니다. 그래서 사람들이 내 방법을 구현하는 방법에 대해 확신하지 못하는 것을 도울 수 있다면. 여기

내 방법 :

def play(list): 

    for k in list: 
     a,x,z = 0 
     #insert into the pile 
     pile = [] 
     pile = pile + [[list[k]]] 

     #check if the new card in the pile is compatible to the card 3 to the left 

     #check in terms if the first char of each card is compatible 
     if((((pile[a])[(len(pile[a]))-1])[0]) == ((((pile[a-3])[(len(pile[a-3]))-1])[0]))): 
      #add card to the top of the card 3 to left 
      pile[a-3] = pile[a-3] + [((pile[a])[(len(pile[a]))-1])] 
      if (len(pile[a])) == 1: 
       del pile[a] 
      else: 
       del (pile[a])[-1] 

     #check in terms if the last char of each card is compatible 
     elif((((pile[a])[(len(pile[a]))-1])[(len((((pile[a])[(len(pile[a]))-1]))))-1]) == (((pile[a-3])[(len(pile[a-3]))-1])[(len((((pile[a-3])[(len(pile[a-3]))-1]))))-1])): 
      #add card to the top of the card 3 to left 
      pile[a-3] = pile[a-3] + [((pile[a])[(len(pile[a]))-1])] 
      if (len(pile[a])) == 1: 
       del pile[a] 
      else: 
       del (pile[a])[-1] 

     #check if the new card in the pile is compatible to the card to the left 

     #check in terms if the first char of each card is compatible 
     elif((((pile[a])[(len(pile[a]))-1])[0]) == ((((pile[a-1])[(len(pile[a-1]))-1])[0]))): 
      pile[a-1] = pile[a-1] + [((pile[a])[(len(pile[a]))-1])] 
      if (len(pile[a])) == 1: 
       del pile[a] 
      else: 
       del (pile[a])[-1] 

     #check in terms if the last char of each card is compatible 
     elif((((pile[a])[(len(pile[a]))-1])[(len((((pile[a])[(len(pile[a]))-1]))))-1]) == (((pile[a-1])[(len(pile[a-1]))-1])[(len((((pile[a-1])[(len(pile[a-1]))-1]))))-1])): 
      pile[a-1] = pile[a-1] + [((pile[a])[(len(pile[a]))-1])] 
      if (len(pile[a])) == 1: 
       del pile[a] 
      else: 
       del (pile[a])[-1] 

     else: 
      a = a + 1 

     #now go through and look for additional moves 
     #(if any match the 1 to the left or 3rd) 

     while x < (len(pile)): 
      if((((pile[x])[(len(pile[x]))-1])[0]) == ((((pile[x-3])[(len(pile[x-3]))-1])[0]))): 
       pile[x-3] = pile[x-3] + [((pile[x])[(len(pile[x]))-1])] 
       if (len(pile[x])) == 1: 
        del (pile[x])[-1] 
        z = x + 1 
        while z < (len(pile)): 
         pile[z-1] = pile[z] 
         z = z + 1 
        del pile[(len(pile))-1] 
       else: 
        del (pile[x])[-1] 
       x = x + 1 

      elif((((pile[x])[(len(pile[x]))-1])[(len((((pile[x])[(len(pile[x]))-1]))))-1]) == (((pile[x-3])[(len(pile[x-3]))-1])[(len((((pile[x-3])[(len(pile[x-3]))-1]))))-1])): 
       pile[x-3] = pile[x-3] + [((pile[x])[(len(pile[x]))-1])] 
       if (len(pile[a])) == 1: 
        del (pile[x])[-1] 
        z = x + 1 
        while z < (len(pile)): 
         pile[z-1] = pile[z] 
         z = z + 1 
       else: 
        del (pile[a])[-1]   
       x = x + 1 

      elif((((pile[x])[(len(pile[x]))-1])[0]) == ((((pile[x-1])[(len(pile[x-1]))-1])[0]))): 
       pile[x-1] = pile[x-1] + [((pile[x])[(len(pile[x]))-1])] 
       if (len(pile[x])) == 1: 
        del (pile[x])[-1] 
        z = x + 1 
        while z < (len(pile)): 
         pile[z-1] = pile[z] 
         z = z + 1 
        del pile[(len(pile))-1] 
       else: 
        del (pile[x])[-1] 
       x = x + 1 

      elif((((pile[x])[(len(pile[x]))-1])[(len((((pile[x])[(len(pile[x]))-1]))))-1]) == (((pile[x-1])[(len(pile[x-1]))-1])[(len((((pile[x-1])[(len(pile[x-1]))-1]))))-1])): 
       pile[x-1] = pile[x-1] + [((pile[x])[(len(pile[x]))-1])] 
       if (len(pile[a])) == 1: 
        del (pile[x])[-1] 
        z = x + 1 
        while z < (len(pile)): 
         pile[z-1] = pile[z] 
         z = z + 1 
       else: 
        del (pile[x])[-1] 
       x = x + 1 

      else: 
       x = x + 1 

     #end while loop 
    #end of for loop 
    return pile 

이 내 교사가 테스트 케이스처럼, 내게 준 것 같다 :

import unittest 
import solitaire 

class Test(unittest.TestCase): 

def test1(self): 
    actual = solitaire.play(['AC','2C','3C','4C','5C','6C','7C','8C','9C','TC','JC','QC','KC', 
           'AD','2D','3D','4D','5D','6D','7D','8D','9D','TD','JD','QD','KD', 
           'AH','2H','3H','4H','5H','6H','7H','8H','9H','TH','JH','QH','KH', 
           'AS','2S','3S','4S','5S','6S','7S','8S','9S','TS','JS','QS','KS']) 
    expected = [['AS','2S','3S','4S','5S','6S','7S','8S','9S','TS','JS','QS','KS','KH','QH','JH','TH','9H','8H','7H','6H','5H','4H','3H','2H','AH','AD','2D','3D','4D','5D','6D','7D','8D','9D','TD','JD','QD','KD','KC','QC','JC','TC','9C','8C','7C','6C','5C','4C','3C','2C','AC']] 
    self.assertEqual (len(expected), len(actual), 'Incorrect result') 
    self.assertListEqual( expected,  actual, 'Incorrect result') 
    pass 

def test2(self): 
    actual = solitaire.play(['QS','5D','4S','8D','8H','3C','3H','5C','9H','6S','QD','2S','2C', 
           'KS','QC','7C','JC','4H','3D','5S','6C','KD','JS','9C','TS','2D', 
           '4D','AS','AC','7H','TC','AH','KH','6D','4C','8C','TD','AD','8S', 
           '3S','JH','KC','QH','TH','6H','7S','5H','2H','9S','7D','JD','9D']) 
    expected = [['8D','8H','3H','3C','JC','7C','QC','QD','4D','4S','6S','KS','KD','5D','5C','2C','2S','QS'], 
       ['9C','4C','4H','9H'], 
       ['6D','2D','3D'], 
       ['JS','TS','TC','6C','AC','AS','5S'], 
       ['KH','AH','7H'], 
       ['8C'], 
       ['AD','TD'], 
       ['3S','8S'], 
       ['6H','TH','JH'], 
       ['KC'], 
       ['2H','QH'], 
       ['9D','JD','7D','7S'], 
       ['5H'], 
       ['9S']] 
    self.assertEqual (len(expected), len(actual), 'Incorrect result') 
    self.assertListEqual( expected,  actual, 'Incorrect result') 
    pass 

def test3(self): 
    actual = solitaire.play(['5S','9H','QH','2H','8H','6H','3S','3H','AS','5H','JH','3C','KH', 
           '4H','6S','8S','8D','2D','JD','AH','KC','TD','TC','3D','6D','2C', 
           'AD','QS','9C','7C','6C','QD','JS','7H','7S','7D','KD','TS','5D', 
           'KS','9S','9D','4C','5C','8C','QC','JC','TH','4S','4D','2S','AC']) 
    expected = [['4D','5D','5C','8C','QC','JC','4C','4S','TS','AS','AH','4H','5H','7H','7S','JS','QS','QD','AD','6D','3D','TD','JD','2D','8D','8S','6S','KS','KD','7D','9D','9C','7C','6C','2C','TC','3C','KC','KH','JH','9H','QH','2H','8H','6H','3H','3S','5S'], 
       ['9S'], 
       ['TH'], 
       ['2S'], 
       ['AC']] 
    self.assertEqual (len(expected), len(actual), 'Incorrect result') 
    self.assertListEqual( expected,  actual, 'Incorrect result') 
    pass 

def test4(self): 
    actual = solitaire.play(['7C','9S','QC','4H','9D','3S','AD','9C','8H','AC','2D','9H','AH', 
           '5D','6C','QD','3H','TC','QS','2S','8D','7D','QH','6H','4C','3C', 
           'JS','JD','7H','TS','4S','TD','5H','KD','8C','KS','JC','6D','2H', 
           '5C','3D','KH','8S','JH','TH','KC','2C','5S','AS','4D','7S','6S']) 
    expected = [['3S','9S','9D','AD','AC','7C'], 
       ['QD','8D','7D','2D','5D','5H','8H','4H','9H','9C','QC'], 
       ['AH'], 
       ['TC','6C'], 
       ['6H','3H'], 
       ['JD','JS','2S','QS'], 
       ['QH'], 
       ['5C','JC','8C','3C','4C'], 
       ['7H'], 
       ['6D','TD','KD','KS','4S','TS'], 
       ['2H'], 
       ['3D'], 
       ['TH','KH'], 
       ['AS','5S','8S'], 
       ['JH'], 
       ['2C','KC'], 
       ['4D'], 
       ['6S','7S']] 
    self.assertEqual (len(expected), len(actual), 'Incorrect result') 
    self.assertListEqual( expected,  actual, 'Incorrect result') 
    pass 

def test5(self): 
    actual = solitaire.play(['6C','AC','7C','7D','KC','6S','9H','5C','JS','3S','TS','9D','JH', 
           'QD','2D','8H','QS','8D','8C','2S','TC','9C','9S','5H','4D','3C', 
           'JD','QC','AS','3H','TD','7H','KS','KH','AD','TH','KD','4C','2C', 
           'QH','3D','5D','7S','4S','6D','2H','AH','JC','8S','4H','5S','6H']) 
    expected = [['JC','QC','2C','2H','QH','AH','4H','6H','6D','3D','5D','JD','TD','TH','7H','7S','4S','4C','TC','3C','3H','5H','KH','KS','KD','8D','4D','AD','AS','9S','9C','KC','5C','8C','8H','9H','JH','JS','TS','3S','6S','QS','2S','2D','QD','9D','7D','7C','AC','6C'], 
       ['5S','8S']] 
    self.assertEqual (len(expected), len(actual), 'Incorrect result') 
    self.assertListEqual( expected,  actual, 'Incorrect result') 
    pass 

def test6(self): 
    actual = solitaire.play(['8S','7C','AS','5H','7H','9D','8C','8H','3H','TC','AH','KH','JH', 
           'JC','AD','9C','AC','QS','6H','KC','KS','5C','TS','3C','9H','7D', 
           '3S','4D','TD','QD','5D','9S','3D','6S','6D','8D','JS','2S','4C', 
           '4S','5S','6C','2D','4H','7S','2H','KD','TH','JD','QH','QC','2C']) 
    expected = [['5S','7S','JS','2S','4S','4C','4H','TH','QH','QC','6C','9C','AC','KC','KS','QS','3S','3C','5C','5D','QD','7D','4D','TD','TS','9S','6S','6D','3D','8D','2D','2H','KH','6H','9H','9D','AD','AS','AH','3H','5H','JH','JC','8C','TC','7C','7H','8H','8S'], 
       ['JD','KD'], 
       ['2C']] 
    self.assertEqual (len(expected), len(actual), 'Incorrect result') 
    self.assertListEqual( expected,  actual, 'Incorrect result') 
    pass 

if __name__ == "__main__": 
#import sys;sys.argv = ['', 'Test.testName'] 
unittest.main() 

난 그냥 파이썬을 알게하기 때문에하는 것은 그렇게 많이하지만 메신저 그냥 나도 몰라 그 테스트를 '클래스'라고 사용하는 방법을 알아 냈습니다.

아이디어가 있으십니까?

감사합니다.

Answer 1

play 함수가 가져 오는 solitaire 모듈에 있어야합니다. 이 값이 가변 actual에 할당되는 것을 의미

actual = solitaire.play() 

가 play pile 함수의 변수에 저장된 결과이다. 그런 다음 테스트 함수는 예상 결과를 변수 expected에 저장합니다.

python test.py 

를하고 그것은 당신에게 어떤 피드백을 제공한다 : 당신이 다음 solitaire 모듈과 같은 디렉토리에 테스트 스크립트를해야한다, 그래서 그냥 실행합니다. 당신이 가지고있는 것을 달리게하면 약간의 실수가 생깁니다. 인터프리터를 통해 play 함수를 실행하면 오류가있는 위치에 대한 피드백을 얻을 수 있습니다.

편집 : OP의 코멘트 후

편집.

play 함수에서 pile이라고하는 것이 중요하지 않습니다. 함수에 의해 반환됩니다. actual = solitaire.play() 같은 것을하면 이 파일을 반환하고 실제에 할당합니다.

한 걸음 뒤로 물러나려면 play 함수와 클래스 Test의 두 가지 코드가 있어야합니다. 코드가 설정되는 방식은 두 개의 개별 파일에 있어야하며, solitaire.py와 test.py라고 부르 자. play 함수는 solitaire.py 파일에 있어야하고 Test 클래스는 test.py에 있어야합니다. test.py 스크립트는이 등의 작업을 수행 할 수 있습니다

import solitaire

라인으로 solitaire.py 파일의 기능을 가져 오는 중입니다.

이 라인은 기본적으로 말하는 금액

actual = solitaire.play()

"솔리테어 모듈에서의 재생 기능을 사용하고 변수 실제에 반환하는 데이터를 할당 할 수 있습니다." 스크립트를 실행하려면 solitaire와 test 파일이 같은 디렉토리에 있고 그 디렉토리가 터미널의 작업 디렉토리인지 확인하십시오. 그런 다음 터미널에 python test.py을 입력하고 실행하십시오.

파이썬을 이해하고 스크립트를 실행하는 등의 도움이 필요하면 Learn Python the Hard Way과 같은 것을보십시오.