상상 속 개발자를 꿈꾸는 사람

카이사르 암호 만들기

함수 만들기

def greet(name):
    print(f"안녕하세요 {name}님")
    print("지금은 함수로 출력되고 있습니다.")
    print(f"{name}님 오늘도 좋은 하루 보내시고 열심히 공부해 보세요.")

print("파이썬 함수")
print("아래는 함수를 실행한 결과입니다. ")
print()
user_name = input("당신은 이름이 무엇인가요? :")
greet(user_name)

다중 인자 함수

def greet(name, location):
    print(f"안녕하세요 {name}님")
    print(f"지금 {location}의 날씨는 어떤가요? ")
    print(f"{location}의 날씨에 상관없이 {name}님 오늘도 좋은 하루 보내시고 열심히 공부해 보세요.")

print("파이썬 함수")
print("아래는 함수를 실행한 결과입니다. ")
print()
user_name = input("당신은 이름이 무엇인가요? :")
user_location = input("당신이 살고 있는 도시는 어디인가요?")
greet(user_name, user_location)

위치 인자와 키워드 인자

def greet(name, location):
    print(f"안녕하세요 {name}님")
    print(f"지금 {location}의 날씨는 어떤가요? ")
    print(f"{location}의 날씨에 상관없이 {name}님 오늘도 좋은 하루 보내시고 열심히 공부해 보세요.")

print("파이썬 함수")
print("아래는 함수를 실행한 결과입니다. ")
print()
user_name = input("당신은 이름이 무엇인가요? :")
user_location = input("당신이 살고 있는 도시는 어디인가요?")
greet(user_location, user_name)  #위치 인자
greet(name = user_name, location = user_location)  #키워드 인자

페인트 칠에 들어가는 캔의 갯수 구하기

import math

def paint_calc(height, width, user_paint):
    total_paint = (height * width) / 5 #페인트 1통당 5제곱미터를 칠할 수 있다고 가정할 때 벽을 칠하기 위해 들어갈 페인트 갯수 구하기
    # total_paint = round(total_paint, 2)
    result = round(total_paint - user_paint, 2)

    print(f"현재 벽을 칠하기 위해서는 페인트가 총 {total_paint}통이 필요합니다.")

    if result > 0 :
        print(f"당신이 {input_paint}통을 가지고 있기 때문에 페인트가 {result}통 더 필요합니다.")
    elif result == 0 :
        print("페인트가 딱 맞습니다.")
    else :
        print(f"페인트가 {abs(result)}통 남습니다.")

    return

input_height = int(input("페인트를 칠한 벽의 높이를 입력해주세요. (단위: m) "))
input_width = int(input("벽의 가로 길이를 입력해 주세요."))
input_paint = int(input("당신이 가지고 있는 페인트 통의 갯수를 입력해 주세요."))

paint_calc(height = input_height, width=input_width, user_paint=input_paint)

소수 체크 프로그램



def prime_checker(number):
    n_check = True
    for n in range(2, number): #1과 자신을 제외한 숫자의 나눗셈에서 나머지가 나오는지 확인
        if number % n == 0 : #나누어 떨어지면 소수가 아니다.
            n_check = False

    if n_check == True :  # True 이면 즉 나누어 떨어지지 않으면
        print(f"당신이 입력한 {number}는 소수입니다.")
    else:
        print(f"당신이 입력한 {number}는 소수가 아닙니다.")

    return

num = int(input("소수 여부를 판단하고 싶은 숫자를 입력해 주세요. : "))

prime_checker(num)

카이사르 암호

# 알파벳 뽑기
import string
low_letter_list = list(string.ascii_lowercase)

# logo
logo = '''
  ### #     #####  ### ##    #####     ##### ## ###              ### #    ##  #  ## ###   ###       ### ##  ## ###
 ## ##     ## ##  ##  ##   ##   #     ## ##   ##  ##            ## ##    # ###    ##  ##   ## ##   ##  ##    ##  ##
###       ##  ##   ##       ####     ##  ##   #   ##           ###         ##     #   ##   ### ##   ##       #   ##
 ##       ######   ####        ###   ######   ##  ##            ##         ##     ##  ##  ###  ##   ####     ##  ##
###  #    ##  ##   ##         # ##   ##  ##   ## ##            ###  #      ##     ## ##    ##  #    ##       ## ##
 ##  ##   ##  ##  ###  ##  ### ###   ##  ##   ## #              ##  ##    ###     ##      ##   #   ###  ##   ## #
  ####   ##    ## # ####   # ###    ##    ## ###  ##             ####    #   ##  ## ##    ##  #### # ####   ###  ##
                                                   ##                                                             ##

'''

# print(low_letter_list)

# logo 출력
print(logo)

# 사용자에게 묻기
direction = input("암호화를 하려면 'encode' 를 입력하고, 암호를 해제하려면 'decode'를 입력해 주세요. ")
user_text = input("암호화 또는 복호화 할 당신의 메세지를 입력해 주세요. : ").lower()
key_shift = int(input("암호화 또는 복호화 키를 숫자로 입력해 주세요. "))
encode_text = ""
decode_text = ""

# 암호화 함수
def encrypt(text, shift, encode_word):
    text = list(text)
    for t in text :
        a = low_letter_list.index(t) #철자별로 알파벳 리스트의 인덱스 값을 찾는다.
        new_index = a + shift
        if new_index > 26: #알파벳의 끝에 가까울 경우 인덱스 범위를 초과하는 경우가 발생하므로, 알파벳 총 갯수에서 다시 앞의 인덱스에서 알파벳을 찾도록 연산과정 입력
            new_index = shift - (26-a)
        encode_word += low_letter_list[new_index] #encode_word 변수에 알파벳 리스트에서 키 값을 더한 인덱스 위치의 알파벳을 찾아 더한다.
    print(f"암호 글자 : {encode_word} , 암호키 : {shift}")
    return

# 복호화 함수
def decrypt(text, shift, decode_word):
    text = list(text)
    for i in text :
        b = low_letter_list.index(i)
        new_index = b - shift
        decode_word += low_letter_list[new_index]
    print(f"암호를 푼 글자 : {decode_word}")
    return

# 사용자 설정에 따른 프로그램 실행
if direction == "encode" :
    encrypt(text= user_text, shift= key_shift, encode_word=encode_text)
elif direction == "decode" :
    decrypt(text= user_text, shift= key_shift, decode_word=decode_text)
else:
    print("encode 와 decode를 다시 선택해 주시기 바랍니다. ")

카이사르 암호 코드 재구성

 # 알파벳 뽑기
import string
low_letter_list = list(string.ascii_lowercase)

# logo
logo = '''
  ### #     #####  ### ##    #####     ##### ## ###              ### #    ##  #  ## ###   ###       ### ##  ## ###
 ## ##     ## ##  ##  ##   ##   #     ## ##   ##  ##            ## ##    # ###    ##  ##   ## ##   ##  ##    ##  ##
###       ##  ##   ##       ####     ##  ##   #   ##           ###         ##     #   ##   ### ##   ##       #   ##
 ##       ######   ####        ###   ######   ##  ##            ##         ##     ##  ##  ###  ##   ####     ##  ##
###  #    ##  ##   ##         # ##   ##  ##   ## ##            ###  #      ##     ## ##    ##  #    ##       ## ##
 ##  ##   ##  ##  ###  ##  ### ###   ##  ##   ## #              ##  ##    ###     ##      ##   #   ###  ##   ## #
  ####   ##    ## # ####   # ###    ##    ## ###  ##             ####    #   ##  ## ##    ##  #### # ####   ###  ##
                                                   ##                                                             ##

'''

# print(low_letter_list)

# logo 출력
print(logo)

# 프로그램 실행
restart_q = "yes"

# 암호화 함수
def caesar(text, shift, direction):
    s_text = text
    text = list(text)
    new_word = ""
    f_shift = shift % 26  # 26이상의 큰수를 입력해도 나머지를 처리하여 알맞은 인수값을 처리할 수 있음.

    if direction != "encode" and direction != "decode":
        print("encode 또는 decode를 정확히 입력해 주세요")
        return

    if direction == "decode" :
        f_shift = f_shift * -1

    for letter in text :
        start_index = low_letter_list.index(letter) #철자별로 알파벳 리스트의 인덱스 값을 찾는다.
        new_index = start_index + f_shift
        if new_index > 26: #알파벳의 끝에 가까울 경우 인덱스 범위를 초과하는 경우가 발생하므로, 알파벳 총 갯수에서 다시 앞의 인덱스에서 알파벳을 찾도록 연산과정 입력
            new_index = f_shift - (26 - start_index)
        new_word += low_letter_list[new_index] #new_word 변수에 알파벳 리스트에서 키 값을 더한 인덱스 위치의 알파벳을 찾아 더한다.
    print(f"입력한 글자 : {s_text} , {direction} 글자 : {new_word} , 암호키 : {abs(shift)}")
    return

# 프로그램 실행
while restart_q == "yes" :
    user_direction = input("암호화를 하려면 'encode' 를 입력하고, 암호를 해제하려면 'decode'를 입력해 주세요. ").lower()
    user_text = input("암호화 또는 복호화 할 당신의 메세지를 입력해 주세요. : ").lower()
    key_shift = int(input("암호화 또는 복호화 키를 숫자로 입력해 주세요. "))

    caesar(text=user_text, shift=key_shift, direction=user_direction)

    restart_q = input("프로그램을 다시 실행하길 원하시면 'yes'를 입력하고 그렇지 않으면 'no'를 입력해 주세요.").lower()

print("Good Bye")

 ### #     #####  ### ##    #####     ##### ## ###              ### #    ##  #  ## ###   ###       ### ##  ## ###
## ##     ## ##  ##  ##   ##   #     ## ##   ##  ##            ## ##    # ###    ##  ##   ## ##   ##  ##    ##  ##
###       ##  ##   ##       ####     ##  ##   #   ##           ###         ##     #   ##   ### ##   ##       #   ##
##       ######   ####        ###   ######   ##  ##            ##         ##     ##  ##  ###  ##   ####     ##  ##
###  #    ##  ##   ##         # ##   ##  ##   ## ##            ###  #      ##     ## ##    ##  #    ##       ## ##
##  ##   ##  ##  ###  ##  ### ###   ##  ##   ## #              ##  ##    ###     ##      ##   #   ###  ##   ## #
 ####   ##    ## # ####   # ###    ##    ## ###  ##             ####    #   ##  ## ##    ##  #### # ####   ###  ##
                                                  ##                                                             ##


입력한 글자 : hello , encode 글자 : czggj , 암호키 : 47
입력한 글자 : czggj , decode 글자 : hello , 암호키 : 47
Good Bye

참고