웹 파이선 프로그래밍

FDR 처리했는데 아직도 많이 미숙한 것 같아서...

10/17에 배웠던 list 일부 사용하고 while for 문도 조금조금 사용해 보았는데

파이썬 공부하시는 분들 피드백 해주시면 감사하겠습니다.

""" 프로그램의 기준은 10진법

    10진 -> 2진 / 역 포함

    10진 -> 8진 / 역 포함

    10진 -> 16진 / 역 포함

    의 6개의 함수가 정의 될시

    나머지 6개의 함수는 위의 6가지 함수로 간략히 구현가능

"""

def Return_Decimal_Binary(Enter_Number):

    """(int) -> str

    사용자에 의해 Enter_Number을 받아왔고

    Enter_Number을 Number_1, Number_2 지역변수로 지정

    while 반복문을 통하여 Enter_Number을 2로 나누고 나머지들을 나열하는 10진법 -> 2진법 변환법 사용.

    Ex) Enter_Number <- 10

        Change_Number -> 1010

    """

    Number_1 = Enter_Number

    Number_2 = Enter_Number

    list_Change_Number = []

    while Number_1 != 0:

        Number_1 = Enter_Number // 2             # 나눈 몫 정수값 저장 -> 계속 나누어야함

        Number_2 = Enter_Number % 2              # 나누고 난 나머지 저장 -> 계속 더해주어야함(str or list)

        Enter_Number = Number_1                  #반복문을 통하여 얻은 '0' '1' '0' '1' 을 얻음

        list_Change_Number.append(str(Number_2)) #반복문을 통하여 얻은 '0' '1' '0' '1'을 리스트로 저장

    list_Change_Number.reverse()                 # 0101 -> 1010으로 바뀌기 위하여 reverse method 사용

    Change_Number = "".join(list_Change_Number)  #list 형식을 str로 바꾸면서 서로 사이에 여백이 없도록 붙임

    return Change_Number                        #출력

def Return_Binary_Decimal(Enter_Number):

    """(int) -> str

    function Return_Binary_Decimal의 정반대 구현

    Enter_Number을 정수(int)로 받은 후 바로 문자열(str)로 변환

    이유(리스트를 만들기위한 목적)는 이진수의 특정상 

    1010101010(2) = 682(10)로

    변환 할때를 예를 들면 뒤에서 부터 0 1 2 3 4 5 6 7 8 9의 인덱스를 매겨주는게 이해하기 쉬움.

    반복문을 돌리게 될 시 입력한 수를 변환할때 뒷자리부터 찍혔던 Return_Decimal_Binary함수를 생각하면 다시 돌려 표현한다고 생각하면됨.

    이렇게 문자열(str)로 분해한 수를 리스트로 각 인덱스에 저장.

    각 저장한 수들을 정수(int)로 다시 분해 후 계산식(2^x 승을 곱하는) 부여

    그 계산의 결과들을 반복문을 통하여 모두 더 할시 2진수에서 10진수 변환이 가능

    Ex) Enter_Number <- 1010

        Change_Number -> 10

    """

    Str_Enter_Number = str(Enter_Number)                       # 사용자에게 받은 정수(int)를 str type 변환 후 임의로 지정

    Enter_Number = list(Str_Enter_Number)                      # 받았던 2진수를 list로 지정 ex) 1010 -> ['1', '0', '1', '0']

    Enter_Number.reverse()                                     # list method인 reverse 사용 ex) ['1', '0', '1', '0'] -> ['0', '1', '0', '1']

    Sum_Number = 0                                             # 반복문에서 사용할 Sum_Number 초기화 총합을 구하기 위한 정수 Sum_Number

    for i in range(0, len(Str_Enter_Number)):                 # for문의 개념 중 범위 부분 1010와 같은 이진수는 총 4자리의 str므로 0 ~ 3까지 반복해야함.

        if (Enter_Number[i] != '0') and (Enter_Number[i] != '1'):          # 이진수는 0 과 1만 포함하므로 다른 수는 배제 숫자가 잘못됬다는 문구 출력.

            return 'A number that does not fit into the system.'

        else:

            Sum_Number = Sum_Number + (int(Enter_Number[i]) * (2 ** i))     # 이진수가 맞다면 각 인덱스의 위치에 맞는 2^i 값들을 곱해주어 원래 그전 수에 더해줌

    return (Sum_Number)                                                     # 위의 수와 동일하게 총합 출력

def Return_Decimal_Octal(Enter_Number):

    """(int) -> str

    Return_Decimal_Binary 함수와 다른 점이 없음. 구현은 똑같으며 각 나눠주는 수가 2였는거에 반해 8으로 변경한 것 뿐

    """

    Number_1 = Enter_Number

    Number_2 = Enter_Number

    list_Change_Number = []

    while Number_1 != 0:

        Number_1 = Enter_Number // 8

        Number_2 = Enter_Number % 8

        Enter_Number = Number_1

        list_Change_Number.append(str(Number_2))

    list_Change_Number.reverse()

    Change_Number = "".join(list_Change_Number)

    return Change_Number    

def Return_Octal_Decimal(Enter_Number):

    """(int) -> int

    Return_Decimal_Binary의 역이라고 생각.

    변2진수 -> 10진수 함수와 다른 점이 존재한다면 8진법이므로 8이상의 수들은 포함할수 없으므로 똑같이 구현

    """

    Str_Enter_Number = str(Enter_Number)

    Enter_Number = list(Str_Enter_Number)

    Enter_Number.reverse()

    Sum_Number = 0

    for i in range(0, len(Str_Enter_Number)):

        if (int(Enter_Number[i]) > 8):                             # 8이상의 수 사용 금지 (2진법->10진법과 동일한 개념)

            return 'A number that does not fit into the system.'

        else:

            Sum_Number = Sum_Number + (int(Enter_Number[i]) * (8 ** i))

    return (Sum_Number)

def Return_Decimal_Hexadecimal(Enter_Number):

    """(int) -> str

    10진법 -> 16진법 변환 함수는 다른 함수들과 다르게 16진수 특징상 A B C D E F와 같이 문자열을 포함하는 수라는 것인데 

    앞에 만든 2진-> 10진 / 8진 - > 16진과 같은 개념

    단지 10~15까지들의 수를 문자열로 바꿔주어 표현.

    나머지 함수들 구현은 동일함.

    """

    Number_1 = Enter_Number

    Number_2 = Enter_Number

    list_Change_Number = []

    while Number_1 != 0:

        Number_1 = Enter_Number // 16

        Number_2 = Enter_Number % 16

        if (Number_2 == 10):

            Number_2 = 'A'

        elif (Number_2 == 11):

            Number_2 = 'B'

        elif (Number_2 == 12):

            Number_2 = 'C'

        elif (Number_2 == 13):

            Number_2 = 'D'

        elif (Number_2 == 14):

            Number_2 = 'E'

        elif (Number_2 == 15):

            Number_2 = 'F'

        else:

            Number_2 = Number_2

        Enter_Number = Number_1

        list_Change_Number.append(str(Number_2))

    list_Change_Number.reverse()

    Change_Number = "".join(list_Change_Number)

    return Change_Number

def Return_Hexadecimal_Decimal(Enter_Number):

    """ 

    10진 -> 16진의 역개념 다른함수와 개념 동일함

    """

    Str_Enter_Number = str(Enter_Number)

    Enter_Number = list(Str_Enter_Number)

    Enter_Number.reverse()

    Sum_Number = 0

    for i in range(0, len(Str_Enter_Number)):

        if int(Enter_Number[i] == 'A'):

            Enter_Number[i] = 10

        elif int(Enter_Number[i] == 'B'):

            Enter_Number[i] = 11

        elif int(Enter_Number[i] == 'C'):

            Enter_Number[i] = 12

        elif int(Enter_Number[i] == 'D'):

            Enter_Number[i] = 13

        elif int(Enter_Number[i] == 'E'):

            Enter_Number[i] = 14

        elif int(Enter_Number[i] == 'F'):

            Enter_Number[i] = 15

        else:

            Enter_Number[i] = Enter_Number[i]

        Sum_Number = Sum_Number + (int(Enter_Number[i]) * (16 ** i))

    return (Sum_Number)

"""

    10진 -> 2진 / 역 포함

    10진 -> 8진 / 역 포함

    10진 -> 16진 / 역 포함

    6개의 함수 정의가 끝났으므로

    2진 -> 8진 / 16진 -> 2진과 같은 계산은

    2진 -> 10진 -> 8진 / 16진 -> 10진 -> 2진으로 구현가능 

"""

def Return_Binary_Octal(Enter_Number):

    Enter_Number = Return_Binary_Decimal(Enter_Number)

    return Return_Decimal_Octal(Enter_Number)

def Return_Octal_Binary(Enter_Number):

    Enter_Number = Return_Octal_Decimal(Enter_Number)

    return Return_Decimal_Binary(Enter_Number)

def Return_Binary_Hexadecimal(Enter_Number):

    Enter_Number = Return_Binary_Decimal(Enter_Number)

    return Return_Decimal_Hexadecimal(Enter_Number)

def Return_Hexadecimal_Binary(Enter_Number):

    Enter_Number = Return_Hexadecimal_Decimal(Enter_Number)

    return Return_Decimal_Binary(Enter_Number)

def Return_Octal_Hexadecimal(Enter_Number):

    Enter_Number = Return_Octal_Hexadecimal(Enter_Number)

    return Return_Decimal_Hexadecimal(Enter_Number)

def Return_Hexadecimal_Octal(Enter_Number):

    Enter_Number = Return_Hexadecimal_Decimal(Enter_Number)

    return Return_Decimal_Octal(Enter_Number)

def Start_Final_System(Enter_Start_System, Enter_Final_System, Enter_Number):

    """(str, str, str) -> str or int

    사용자에 의해 

    Enter_Start_System <- 바꿀 숫자의 진법 입력

    Enter_Final_System <- 바꾼 숫자의 진법 입력

    Enter_Number <- 바꾸고 싶은 숫자 입력

    input 을 받을 경우 type은 str이므로 16진수를 제외한 나머지 수들은 반환값을 type을 int로 변경 후 반환

    16진법일 경우 A B C D E F 문자열을 받아야 하므로 str 받고 나서 Enter_Hexadecimal_******** 에서 int 변경을 추가적으로 처리

    """

    if (Enter_Start_System == 'Binary') and (Enter_Final_System == 'Octal'):

        return Return_Binary_Octal(int(Enter_Number))

    elif (Enter_Start_System == 'Binary') and (Enter_Final_System == 'Decimal'):

        return Return_Binary_Decimal(int(Enter_Number))

    elif (Enter_Start_System == 'Binary') and (Enter_Final_System == 'Hexadecimal'):

        return Return_Binary_Hexadecimal(int(Enter_Number))

    elif (Enter_Start_System == 'Octal') and (Enter_Final_System == 'Binary'):

        return Return_Octal_Binary(int(Enter_Number))

    elif (Enter_Start_System == 'Octal') and (Enter_Final_System == 'Decimal'):

        return Return_Octal_Decimal(int(Enter_Number))

    elif (Enter_Start_System == 'Octal') and (Enter_Final_System == 'Hexadecimal'):

        return Return_Octal_Hexadecimal(int(Enter_Number))

    elif (Enter_Start_System == 'Decimal') and (Enter_Final_System == 'Binary'):

        return Return_Decimal_Binary(int(Enter_Number))

    elif (Enter_Start_System == 'Decimal') and (Enter_Final_System == 'Octal'):

        return Return_Decimal_Octal(int(Enter_Number))

    elif (Enter_Start_System == 'Decimal') and (Enter_Final_System == 'Hexadecimal'):

        return Return_Decimal_Hexadecimal(int(Enter_Number))

    elif (Enter_Start_System == 'Hexadecimal') and (Enter_Final_System == 'Binary'):    # 나머지와 다르게 반환값 str

        return Return_Hexadecimal_Binary(Enter_Number)

    elif (Enter_Start_System == 'Hexadecimal') and (Enter_Final_System == 'Octal'):     # 나머지와 다르게 반환값 str

        return Return_Hexadecimal_Octal(Enter_Number)

    elif (Enter_Start_System == 'Hexadecimal') and (Enter_Final_System == 'Decimal'):   # 나머지와 다르게 반환값 str

        return Return_Hexadecimal_Decimal(Enter_Number)

    else:

        return 'The number was not changed because the conversion system was set incorrectly.'

print('The following systems are supported by the converter.'.center(55))

print('Binary'.center(55))

print('Octal'.center(55))

print('Decimal'.center(55))

print('Hexadecimal'.center(55))

print('-------------------------------------------------------')

Enter_Start_System = input('Enter the system of numbers to enter : ')

Enter_Final_System = input('Enter the system of numbers to be output : ')

Enter_Number = input('Enter the number to change : ')

print('-------------------------------------------------------')

print('Start_Number = ' + Enter_Number)

print('Change_Number = ', Start_Final_System(Enter_Start_System, Enter_Final_System, Enter_Number))

Quiz 코드안입니다.

shape = input()

width = int(input())

rain = input()

def makeTree(shape, width, rain):

    if (rain == 'True'):

        Tree = (('/' * width) + 'n')

        Tree += ((shape * 1).center(width, '/')) + 'n'

        Tree += ((shape * 3).center(width, '/')) + 'n'

        Tree += ((shape * 5).center(width, '/')) + 'n'

        Tree += ((shape * 7).center(width, '/')) + 'n'

        Tree += ((shape * 9).center(width, '/')) + 'n'

        Tree += ((shape * 11).center(width, '/')) + 'n'

        Tree += ('    |||    '.center(width, '/')) + 'n'

        Tree += '=' * width

    else:

        Tree = ('' + 'n')

        Tree += ((shape * 1).center(width)) + 'n'

        Tree += ((shape * 3).center(width)) + 'n'

        Tree += ((shape * 5).center(width)) + 'n'

        Tree += ((shape * 7).center(width)) + 'n'

        Tree += ((shape * 9).center(width)) + 'n'

        Tree += ((shape * 11).center(width)) + 'n'

        Tree += ('|||'.center(width) + 'n')

        Tree += '=' * width        

    return Tree

print(makeTree(shape, width, rain))