본문 바로가기
AI/AI 부트캠프

[AI 부트캠프] DAY 18 - 파이썬 프로젝트 3

by HOHHOH 2023. 8. 10.

[오늘의 일지]

파이썬 프로젝트 - 어제 만든 2차 완성 프로젝트 코드에 여러 가지 기능 첨가하기

오늘 한 작업 - 어제 만들어 놓은 계산 기능 첨가하기, 번역 기능 만들기, 게임 기능 만들기, 지금까지 만든 함수들 클래스화 해기, 부분 부분 에러 수정하기

[상세 내용]

파이썬 프로젝트

2차 완성본에 계산 기능 첨가하기

- 어제는 계산 기능의 함수까지는 어떻게 만들었습니다. 그런데 계산 기능에 STT를 접목해서 실행을 시키려고 하니까 소리로 숫자를 인식하는 과정에서 엄청나게 많은 오류들이 발생했습니다. 가장 쉬운 예시로 숫자 1이나 0은 소리로 입력을 받을 때 한글로 '일'과 '영'으로 출력되었습니다. 수많은 숫자를 입력해야 되는 상황에서 하나하나 오류들을 찾아 나서는 것이 엄두가 나지 않았기 때문에 저는 최종적으로 숫자를 키보드로 입력받고 입력받은 숫자를 소리로 다시 말해주는 형식으로 최대한 음성인식 시스템에 가까운 설정을 유지하도록 했습니다. 그리고 원래는 숫자 두 개 사이에 연산자를 넣어서 출력을 받으려고 했으나 이것 또한 연산자를 사용하는 상황에서 오류를 잡기 어려워서 숫자 두 개를 입력받고 연산자를 마지막에 사용한 것입니다. 그렇게 완성된 계산 기능 코드를 보여드리겠습니다.

class calcurator():
    def __init__(self) -> None:
        pass
    def cal_voice(self):
        speak('''
            계산 기능은 다음과 같습니다.
            첫번째 숫자와 두번째 숫자의 사이에 원하는 사칙연산이 가능합니다.
            ''')
        while True:
            try:            
                speak('첫번째 숫자를 적어주세요')
                first_num = float(input('첫번째 숫자 입력 : '))
                speak(f'첫번째 숫자는 + {first_num} 입니다')            
                speak('두번째 숫자를 적어주세요') 
                secound_num = float(input('두번째 숫자 입력 : '))
                speak(f'두번째 숫자는 + {secound_num} 입니다')  
            except ValueError:
                speak('잘못된 숫자입니다. 다시 처음으로 돌아갑니다.')
                continue
            try:
                with mic as source: # 마이크에 담긴 소리를 토대로 아래 코드 실행
                    speak('원하는 연산자를 말해주세요.(더하기,빼기,곱하기,나누기)') 
                    print('인식 중...')
                    audio = r.listen(source, timeout=3, phrase_time_limit=3)                        
                try:
                    operator = r.recognize_google(audio, language = "ko-KR")
                    print('명령어 인식 완료 : ' + operator) # 인식 결과 출력                                        
                    if operator == '더하기':
                        print(f'계산 결과 = {first_num + secound_num}')
                        return (f'계산 결과는 {first_num + secound_num} 입니다. 계산 기능을 종료합니다.')
                    elif operator == '빼기':
                        print(f'계산 결과 = {first_num - secound_num}')
                        return speak(f'계산 결과는 {first_num - secound_num} 입니다. 계산 기능을 종료합니다.')
                    elif operator == '곱하기':
                        print(f'계산 결과 = {first_num * secound_num}')
                        return speak(f'계산 결과는 {first_num * secound_num} 입니다. 계산 기능을 종료합니다.')
                    elif operator == '나누기' or operator == '=':
                        if secound_num == 0:
                            speak('분모에는 0을 넣을 수 없습니다. 다시 처음으로 돌아갑니다.')
                        else:
                            print(f'계산 결과 = {first_num / secound_num}')
                            return speak(f'계산 결과는 {first_num / secound_num} 입니다. 계산 기능을 종료합니다.')
                    else:
                        speak('잘못된 연산자 입니다. 다시 처음으로 돌아갑니다.')                
                except sr.UnknownValueError:
                    speak("음성 인식 실패! 다시 처음으로 돌아갑니다.")
                except sr.RequestError:
                    speak("서버 에러 발생! 다시 처음으로 돌아갑니다.")
                except sr.WaitTimeoutError:
                    speak("인식 실패! 다시 처음으로 돌아갑니다.")
                except TypeError:
                    speak("호출 에러 발생! 다시 처음으로 돌아갑니다.")
            except sr.exceptions.WaitTimeoutError:
                speak("시간 초과!")

 

class를 여러 개 만들기

- 위에 계산 기능 코드를 보면 클래스로 코드가 짜여 있는 것을 확인할 수 있으실 겁니다. 우선 어제까지 하나에 클래스에 모든 기능의 함수를 넣었던 코드를 싹 다 변경시켰습니다. 기능들을 모두 클래스화 했는데 그 이유가 사실 기능이 많아지면서 생길 오류들을 미리 방지하기 위해서입니다. 클래스로 기능을 만들어 놓은 다면 모듈화 해서 코드를 짧게 만들 수 있다는 것을 알게 되었습니다. 그래서 다른 기능의 클래스화도 코드를 보여드리겠습니다.

 

- 클래스화된 날씨 기능 코드

class weather():
    def __init__(self) -> None:
        pass
    def weather_voice(self):
        while True:
            try:
                with mic as source: # 마이크에 담긴 소리를 토대로 아래 코드 실행
                    speak('원하는 도시를 말해주세요.')
                    print('인식 중...')
                    audio = r.listen(source, timeout=3, phrase_time_limit=3) # 해당 소리를 오디오 파일 형태로 변환

                try:
                    result = r.recognize_google(audio, language = "ko-KR") # 오디오를 토대로 음성 인식
                    result_trans = trans_ko_en(result)
                    url = f'https://api.openweathermap.org/data/2.5/weather?q={result_trans}&appid={API키}'
                    response = requests.get(url)
                    json_data = json.loads(response.text)
                    print('명령어 인식 완료 : ' + result) # 인식 결과 출력            
                    speak('도시명' + result + '인식 완료')
                    print(f'''
                        오늘 {result} 날씨정보입니다.
                        전체적인 날씨의 특징은 {trans_en_ko(json_data['weather'][0]['description'])} 입니다.
                        현재 온도는 {k_to_c(json_data['main']['temp'])}°C 입니다.
                        현재 습도는 {json_data['main']['humidity']}% 입니다.
                        현재 풍속은 {json_data['wind']['speed']}m/s 입니다.
                        ''')
                    return speak(f'''
                        날씨정보를 말해드립니다.         
                        오늘 {result} 날씨정보입니다.
                        전체적인 날씨의 특징은 {trans_en_ko(json_data['weather'][0]['description'])} 입니다.
                        현재 온도는 {k_to_c(json_data['main']['temp'])}°C 입니다.
                        현재 습도는 {json_data['main']['humidity']}% 입니다.
                        현재 풍속은 {json_data['wind']['speed']}m/s 입니다.
                        날씨정보였습니다.
                        날씨 기능을 종료합니다.                    
                        ''')
                except sr.UnknownValueError:
                    speak("음성 인식 실패!")
                except sr.RequestError:
                    speak("서버 에러 발생!")
                except sr.WaitTimeoutError:
                    speak("인식 실패!")
                except TypeError:
                    speak("호출 에러 발생!")             
                except KeyError:
                    speak("죄송합니다. 도시명을 제대로 말해주세요.")
            except sr.exceptions.WaitTimeoutError:
                speak("시간 초과!")

 

- 클래스화 된 검색 기능 코드

class search():
    def __init__(self) -> None:
        pass
    def search_voice(self):
        while True:
            try:
                with mic as source: # 마이크에 담긴 소리를 토대로 아래 코드 실행
                    speak('원하는 검색어를 말해주세요.')
                    print('인식 중...')
                    audio = r.listen(source, timeout=4, phrase_time_limit=4) # 해당 소리를 오디오 파일 형태로 변환

                try:
                    result = r.recognize_google(audio, language = "ko-KR") # 오디오를 토대로 음성 인식
                    print('명령어 인식 완료 : ' + result) # 인식 결과 출력
                    speak('검색어' +result + '인식 완료')
                    speak('검색을 시작합니다.')
                    # 인식이 됐으니 검색 시작 (지난 시간 selenium 부분 코드와 동일)
                    driver = webdriver.Chrome()
                    driver.get('https://www.google.com/')
                    WebDriverWait(driver, 5).until(EC.presence_of_element_located((By.CSS_SELECTOR, '#APjFqb')))
                    search_input = driver.find_element(By.CSS_SELECTOR, '#APjFqb')
                    search_input.send_keys(result)
                    search_button = driver.find_element(By.CSS_SELECTOR, '.FPdoLc.lJ9FBc > center > input.gNO89b')
                    search_button.click()
                    time.sleep(5)
                    driver.quit()
                    return speak('검색 기능을 종료합니다.')
                except sr.UnknownValueError:
                    speak("음성 인식 실패!")
                except sr.RequestError:
                    speak("서버 에러 발생!")
                except sr.WaitTimeoutError:
                    speak("인식 실패!")
                except TypeError:
                    speak("호출 에러 발생!")
            except sr.exceptions.WaitTimeoutError:
                speak("시간 초과!")

 

while문의 복습(while문을 그냥 빠져나오는 상황)

- 지금까지 이론이나 실습을 통해서 while문에 대해서 익숙해졌다고 생각했는데 이번에 계속해서 사용하게 되면서 제대로 복습을 하게 된 거 같습니다. 음성인식 시스템의 코드를 짜고 실을 시킬 때마다 계속해서 가장 처음 부분인 명령받는 주체를 부르는 부분으로 돌아가는 것이 그냥 막연하게 당연하다고 생각하고 지나치려 했는데 실행을 계속하면 할수록 시간적인 부분에서 비효율적이라는 것을 깨닫게 되었습니다. 그러면 while문이 특정한 정지 코드가 없으면 무한 반복을 하기에 이 특징을 이용하면 원하는 기능에서 오류가 났을 때 맨 처음이 아닌 기능 안에서만 무한 반복을 실행할 수 있을 거라고 판단을 내렸습니다. 그렇게 while문을 사용해서 실행시켜서 오류가 났는데 그래도 처음으로 돌아가는 상황이 반복된 것입니다.

다시 정리해서 말하자면 while문 안에서 다시 while문을 사용할 때 두 번째 while문 안에서는 반복이 일어나지 않는 상황을 말하는 것입니다.

 

while문 안에서 다시 while문을 사용할 때 두 번째 while문 안에서는 반복이 일어나지 않는 상황 해결

저는 이러한 상황을 해결하기 위해서 클래스를 이용해서 기능의 함수를 따로 나오게 해 줬습니다. 그렇게 하니 기능을 사용할 때 오류가 발생해도 기능 안에서 무한 반복이 일어나는 것을 확인했습니다. 그런데 그렇게 해결하는 것은 while문 안에서 두 번째 while문을 사용했을 때 상황은 해결하는 것이 아니었기 때문에 검색을 통해서 알아보니 continue 문법을 사용하면 오류가 발생해서 처음으로 돌아갈 때 두 번째 while문 안에서 계속해서 무한 반복이 일어나는 것을 확인했습니다. 결론을 말하자면 while문 안에 두 번째 while문에서 반복이 일어나게 하는 방법은 오류 발생 시 오류코드를 넣고 다음에 continue 문법을 사용하면 해결된다는 점을 말하고 싶었습니다. 다음의 코드를 보시면 확인하실 수 있습니다.

class project():
    def __init__(self) -> None:
        pass
    def command(self):
        while True:
            try:
                with mic as source: # 마이크에 담긴 소리를 토대로 아래 코드 실행
                    speak('프로그램을 시작합니다. 시리를 불러주세요.')
                    print('인식 중...')
                    audio = r.listen(source, timeout=3, phrase_time_limit=3) # 해당 소리를 오디오 파일 형태로 변환
                try:
                    command_1 = r.recognize_google(audio, language = "ko-KR") # 오디오를 토대로 음성 인식
                    print('명령어 인식 완료 : ' + command_1) # 인식 결과 출력
                    if command_1 == '시리야' or command_1 == '시리':
                        speak('안녕하세요. 시리입니다. 부르셨습니까?')
                        while True:
                            try:
                                with mic as source: # 마이크에 담긴 소리를 토대로 아래 코드 실행
                                    speak('명령어를 말해주세요.(검색, 날씨, 계산, 종료)')
                                    print('인식 중...')
                                    audio = r.listen(source, timeout=3, phrase_time_limit=3) # 해당 소리를 오디오 파일 형태로 변환  
                                try:
                                    command_2 = r.recognize_google(audio, language = "ko-KR") # 오디오를 토대로 음성 인식
                                    print('명령어 인식 완료 : ' + command_2) # 인식 결과 출력                                          
                                    if command_2 == '검색':
                                        speak('검색 기능을 시작합니다.')
                                        search().search_voice()
                                    elif command_2 == '날씨':
                                        speak('날씨 기능을 시작합니다.')
                                        weather().weather_voice()
                                    elif command_2 == '계산':
                                        speak('계산 기능을 시작합니다.')
                                        calcurator().cal_voice()
                                    elif command_2 == '종료':
                                        return speak('프로그램을 종료합니다.')
                                    else:
                                        speak('제대로 명령어를 말해주세요. 다시 처음으로 돌아갑니다.')
                                except sr.UnknownValueError:
                                    speak("음성 인식 실패!")
                                    continue
                                except sr.RequestError:
                                    speak("서버 에러 발생!")
                                    continue
                                except sr.WaitTimeoutError:
                                    speak("인식 실패!")
                                    continue
                                except TypeError:
                                    speak("호출 에러 발생!")
                                    continue
                            except sr.exceptions.WaitTimeoutError:
                                speak("시간 초과!")
                                continue                             
                    elif command_1 == '종료':
                        return speak('프로그램을 종료합니다.')                                                 
                    else:
                        speak('시리의 이름을 제대로 불러주세요')
                except sr.UnknownValueError:
                    speak("음성 인식 실패!")
                except sr.RequestError:
                    speak("서버 에러 발생!")
                except sr.WaitTimeoutError:
                    speak("인식 실패!")
                except TypeError:
                    speak("호출 에러 발생!")  
            except sr.exceptions.WaitTimeoutError:
                speak("시간 초과!")

 

while문 복습(while문에서 빠져나오는 방법)

- 사실 이 부분은 크게 어렵지 않습니다. break 문법이나 함수를 사용했다면 함수에 return 값을 주면 빠져나올  수 있습니다.

 

음성 인식을 반복해서 실행시키면서 발견한 에러

- 어제 음성인식 코드를 사용할 때는 한 번도 발생하지 않았던 에러가 발생했는데 에러명은 다음과 같았습니다.

speech_recognition.exceptions.WaitTimeoutError:

위에 나온 내용의 에러였는데 내용을 살펴보면 with문 다음에 오는 audio = r.listen(source, timeout=3, phrase_time_limit=3)  이 부분에서 timeout=3에 에러를 표시하면서 대충 입력이 없었다는 내용이었던 거 같습니다. 그 상황이 제가 어떠한 입력을 하지 않고 있는 상황이긴 했는데 기존에 에러 코드들과 중복이 있다고 생각했지만 그냥 except 문법을 사용해서 해결했습니다. 그래서 위와 같은  except 문법의 들여 쓰기 같은 상황이 나온 것입니다. audio = r.listen가 있는 부분이 아래 try 문법 전에 등장하기 때문에 with문 전에 try를 다시 쓴 것입니다. 

 

계산 기능을 추가하고 기존 기능들을 모두 클래스화 한 3차 완성 프로젝트 코드

import speech_recognition as sr
import time
import requests
import json
from tts import speak
from googletrans import Translator
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

# 켈빈온도를 섭씨온도로 변환
def k_to_c(x):
    return round(x - 273)
# 단어 번역 함수
def trans_ko_en(x):
    translator = Translator()
    return translator.translate(x, src='ko', dest='en').text
def trans_en_ko(x):
    translator = Translator()
    return translator.translate(x, src='en', dest='ko').text

# 인식을 위한 객체 생성
r = sr.Recognizer()
# 마이크 사용을 위한 객체 생성
mic = sr.Microphone()

class project():
    def __init__(self) -> None:
        pass
    def command(self):
        while True:
            try:
                with mic as source: # 마이크에 담긴 소리를 토대로 아래 코드 실행
                    speak('프로그램을 시작합니다. 시리를 불러주세요.')
                    print('인식 중...')
                    audio = r.listen(source, timeout=3, phrase_time_limit=3) # 해당 소리를 오디오 파일 형태로 변환
                try:
                    command_1 = r.recognize_google(audio, language = "ko-KR") # 오디오를 토대로 음성 인식
                    print('명령어 인식 완료 : ' + command_1) # 인식 결과 출력
                    if command_1 == '시리야' or command_1 == '시리':
                        speak('안녕하세요. 시리입니다. 부르셨습니까?')
                        while True:
                            try:
                                with mic as source: # 마이크에 담긴 소리를 토대로 아래 코드 실행
                                    speak('명령어를 말해주세요.(검색, 날씨, 계산, 종료)')
                                    print('인식 중...')
                                    audio = r.listen(source, timeout=3, phrase_time_limit=3) # 해당 소리를 오디오 파일 형태로 변환  
                                try:
                                    command_2 = r.recognize_google(audio, language = "ko-KR") # 오디오를 토대로 음성 인식
                                    print('명령어 인식 완료 : ' + command_2) # 인식 결과 출력                                          
                                    if command_2 == '검색':
                                        speak('검색 기능을 시작합니다.')
                                        search().search_voice()
                                    elif command_2 == '날씨':
                                        speak('날씨 기능을 시작합니다.')
                                        weather().weather_voice()
                                    elif command_2 == '계산':
                                        speak('계산 기능을 시작합니다.')
                                        calcurator().cal_voice()
                                    elif command_2 == '종료':
                                        return speak('프로그램을 종료합니다.')
                                    else:
                                        speak('제대로 명령어를 말해주세요. 다시 처음으로 돌아갑니다.')
                                except sr.UnknownValueError:
                                    speak("음성 인식 실패!")
                                    continue
                                except sr.RequestError:
                                    speak("서버 에러 발생!")
                                    continue
                                except sr.WaitTimeoutError:
                                    speak("인식 실패!")
                                    continue
                                except TypeError:
                                    speak("호출 에러 발생!")
                                    continue
                            except sr.exceptions.WaitTimeoutError:
                                speak("시간 초과!")
                                continue                             
                    elif command_1 == '종료':
                        return speak('프로그램을 종료합니다.')                                                 
                    else:
                        speak('시리의 이름을 제대로 불러주세요')
                except sr.UnknownValueError:
                    speak("음성 인식 실패!")
                except sr.RequestError:
                    speak("서버 에러 발생!")
                except sr.WaitTimeoutError:
                    speak("인식 실패!")
                except TypeError:
                    speak("호출 에러 발생!")  
            except sr.exceptions.WaitTimeoutError:
                speak("시간 초과!")                    

class search():
    def __init__(self) -> None:
        pass
    def search_voice(self):
        while True:
            try:
                with mic as source: # 마이크에 담긴 소리를 토대로 아래 코드 실행
                    speak('원하는 검색어를 말해주세요.')
                    print('인식 중...')
                    audio = r.listen(source, timeout=4, phrase_time_limit=4) # 해당 소리를 오디오 파일 형태로 변환

                try:
                    result = r.recognize_google(audio, language = "ko-KR") # 오디오를 토대로 음성 인식
                    print('명령어 인식 완료 : ' + result) # 인식 결과 출력
                    speak('검색어' +result + '인식 완료')
                    speak('검색을 시작합니다.')
                    # 인식이 됐으니 검색 시작 (지난 시간 selenium 부분 코드와 동일)
                    driver = webdriver.Chrome()
                    driver.get('https://www.google.com/')
                    WebDriverWait(driver, 5).until(EC.presence_of_element_located((By.CSS_SELECTOR, '#APjFqb')))
                    search_input = driver.find_element(By.CSS_SELECTOR, '#APjFqb')
                    search_input.send_keys(result)
                    search_button = driver.find_element(By.CSS_SELECTOR, '.FPdoLc.lJ9FBc > center > input.gNO89b')
                    search_button.click()
                    time.sleep(5)
                    driver.quit()
                    return speak('검색 기능을 종료합니다.')
                except sr.UnknownValueError:
                    speak("음성 인식 실패!")
                except sr.RequestError:
                    speak("서버 에러 발생!")
                except sr.WaitTimeoutError:
                    speak("인식 실패!")
                except TypeError:
                    speak("호출 에러 발생!")
            except sr.exceptions.WaitTimeoutError:
                speak("시간 초과!")     

class weather():
    def __init__(self) -> None:
        pass
    def weather_voice(self):
        while True:
            try:
                with mic as source: # 마이크에 담긴 소리를 토대로 아래 코드 실행
                    speak('원하는 도시를 말해주세요.')
                    print('인식 중...')
                    audio = r.listen(source, timeout=3, phrase_time_limit=3) # 해당 소리를 오디오 파일 형태로 변환

                try:
                    result = r.recognize_google(audio, language = "ko-KR") # 오디오를 토대로 음성 인식
                    result_trans = trans_ko_en(result)
                    url = f'https://api.openweathermap.org/data/2.5/weather?q={result_trans}&appid={API키}'
                    response = requests.get(url)
                    json_data = json.loads(response.text)
                    print('명령어 인식 완료 : ' + result) # 인식 결과 출력            
                    speak('도시명' + result + '인식 완료')
                    print(f'''
                        오늘 {result} 날씨정보입니다.
                        전체적인 날씨의 특징은 {trans_en_ko(json_data['weather'][0]['description'])} 입니다.
                        현재 온도는 {k_to_c(json_data['main']['temp'])}°C 입니다.
                        현재 습도는 {json_data['main']['humidity']}% 입니다.
                        현재 풍속은 {json_data['wind']['speed']}m/s 입니다.
                        ''')
                    return speak(f'''
                        날씨정보를 말해드립니다.         
                        오늘 {result} 날씨정보입니다.
                        전체적인 날씨의 특징은 {trans_en_ko(json_data['weather'][0]['description'])} 입니다.
                        현재 온도는 {k_to_c(json_data['main']['temp'])}°C 입니다.
                        현재 습도는 {json_data['main']['humidity']}% 입니다.
                        현재 풍속은 {json_data['wind']['speed']}m/s 입니다.
                        날씨정보였습니다.
                        날씨 기능을 종료합니다.                    
                        ''')
                except sr.UnknownValueError:
                    speak("음성 인식 실패!")
                except sr.RequestError:
                    speak("서버 에러 발생!")
                except sr.WaitTimeoutError:
                    speak("인식 실패!")
                except TypeError:
                    speak("호출 에러 발생!")             
                except KeyError:
                    speak("죄송합니다. 도시명을 제대로 말해주세요.")
            except sr.exceptions.WaitTimeoutError:
                speak("시간 초과!") 

class calcurator():
    def __init__(self) -> None:
        pass
    def cal_voice(self):
        speak('''
            계산 기능은 다음과 같습니다.
            첫번째 숫자와 두번째 숫자의 사이에 원하는 사칙연산이 가능합니다.
            ''')
        while True:
            try:            
                speak('첫번째 숫자를 적어주세요')
                first_num = float(input('첫번째 숫자 입력 : '))
                speak(f'첫번째 숫자는 + {first_num} 입니다')            
                speak('두번째 숫자를 적어주세요') 
                secound_num = float(input('두번째 숫자 입력 : '))
                speak(f'두번째 숫자는 + {secound_num} 입니다')  
            except ValueError:
                speak('잘못된 숫자입니다. 다시 처음으로 돌아갑니다.')
                continue
            try:
                with mic as source: # 마이크에 담긴 소리를 토대로 아래 코드 실행
                    speak('원하는 연산자를 말해주세요.(더하기,빼기,곱하기,나누기)') 
                    print('인식 중...')
                    audio = r.listen(source, timeout=3, phrase_time_limit=3)                        
                try:
                    operator = r.recognize_google(audio, language = "ko-KR")
                    print('명령어 인식 완료 : ' + operator) # 인식 결과 출력                                        
                    if operator == '더하기':
                        print(f'계산 결과 = {first_num + secound_num}')
                        return (f'계산 결과는 {first_num + secound_num} 입니다. 계산 기능을 종료합니다.')
                    elif operator == '빼기':
                        print(f'계산 결과 = {first_num - secound_num}')
                        return speak(f'계산 결과는 {first_num - secound_num} 입니다. 계산 기능을 종료합니다.')
                    elif operator == '곱하기':
                        print(f'계산 결과 = {first_num * secound_num}')
                        return speak(f'계산 결과는 {first_num * secound_num} 입니다. 계산 기능을 종료합니다.')
                    elif operator == '나누기' or operator == '=':
                        if secound_num == 0:
                            speak('분모에는 0을 넣을 수 없습니다. 다시 처음으로 돌아갑니다.')
                        else:
                            print(f'계산 결과 = {first_num / secound_num}')
                            return speak(f'계산 결과는 {first_num / secound_num} 입니다. 계산 기능을 종료합니다.')
                    else:
                        speak('잘못된 연산자 입니다. 다시 처음으로 돌아갑니다.')                
                except sr.UnknownValueError:
                    speak("음성 인식 실패! 다시 처음으로 돌아갑니다.")
                except sr.RequestError:
                    speak("서버 에러 발생! 다시 처음으로 돌아갑니다.")
                except sr.WaitTimeoutError:
                    speak("인식 실패! 다시 처음으로 돌아갑니다.")
                except TypeError:
                    speak("호출 에러 발생! 다시 처음으로 돌아갑니다.")
            except sr.exceptions.WaitTimeoutError:
                speak("시간 초과!")

 

번역 기능 만들기

- 사실 이 부분은 기존에 만든 영한, 한영 함수를 사용하면 편하게 만들 수 있을 거라고 생각하고 시작했는데 여기서도 STT를 접목하는 상황에서 원하는 문장이나 단어의 번역을 하기 위해 입력을 받는 과정에서 오류가 많이 났고 직접 음성을 입력받아서 번역을 하는 것은 힘들다고 판단하여 택스트로 입력을 받는 것으로 마무리를 했습니다. 세밀한 부분은 내일 처리하고 오늘은 번역 기능 함수를 보여드리고 마무리하겠습니다. 사실 함수도 googletrans 번역 패키지를 이용해서 만든 것입니다.

from googletrans import Translator

def trans_ko_en(x):
    translator = Translator()
    return translator.translate(x, src='ko', dest='en').text
def trans_en_ko(x):
    translator = Translator()
    return translator.translate(x, src='en', dest='ko').text

 

[마무리]

 오늘은 어제 만든 계산 기능을 추가하고 프로젝트의 임시 완성본 안에 기능들을 모두 클래스화 하는 작업을 했습니다. 오늘은 기존 파이썬 기초에서 배운 내용들을 더 확고하게 복습할 수 있었던 시간들이 많았던 거 같습니다. 내일은 마지막으로 끝말잇기 게임을 만들고 기능을 추가해서 최종 완성본까지 만드는 것을 목표로 하겠습니다. 마지막인 만큼 끝말잇기 게임이 생각보다 코드를 짜는 것이 더 어려울 것으로 예상됩니다. 

반응형

댓글