56가지 기본 개념
- 객체지향형 프로그래밍
- 기계어
- 데이터
- 디코딩 오류
- 랜덤(Random)
- 램 메모리
- 마크업 언어
- 메서드
- 모듈
- 무한루프
- 문자열(String)
- 바이트(Byte)
- 반복문
- 변수
- 비트(Bit)
- 빌드(Build)
- 상속(Extend)
- 생성자
- 소프트웨어 개발 도구(SDK)
- 스레드(thread)
- 스크립트 언어
- 슬라이싱
- 시퀀스
- 아스키(ASCII)
- 어셈블리어
- 예외처리
- 오버라이드(Override)
- 유니코드(UNICODE)
- 이벤트(Event)
- 인덱스
- 인덱싱
- 인스턴스
- 저장 메모리
- 조건문
- 캐시 메모리
- 컴파일러
- 코드(Code)
- 코멘트(주석)
- 클래스
- 통합 개발 환경(IDE)
- 판다스
- 패키지(Package)
- 프로그래밍 언어
- 함수
- \n
- 10진법
- elif문
- for문
- if문
- immutable
- input ()
- mutable
- print ()
- sleep
- UTF-16
- while문
| bit (비트) | 0 또는 1 중 하나의 정보를 가지는 최소 정보 단위 |
| code (코드) | 0, 1 로 만들어진 부호 |
| Byte (바이트) | 비트 8개 |
| Decoding Error (디코딩 오류) | 인코딩 시, 다른 코드로 정의된 비트를 입력하면 생기는 해석 오류 |
| ASCII (American Standard Code For Information Interchange) (아스키) | 8비트 단위, 영문자를 위한 코드 |
| UNICODE (유니코드) | 16비트 단위, 모든 언어를 위한 코드 한글 유니코드 : (http://www.unicode.org/charts/PDF/UAC00.pdf) |
| UTF-8 (Unicode Transformation Format) (유니코드 변환 양식) | 숫자는 전달되는 정보의 최소 비트 의미, 대부분에 쓰여짐 |
| UTF-16 ((Unicode Transformation Format) (유니코드 변환 양식) | 숫자는 전달되는 정보의 최소 비트 의미 |
| 프로그래밍 언어 | 사람의 언어를 기계어로 번역해서 알려주는 수단 |
| Compile (컴파일) | 프로그래밍 언어를 컴퓨터가 이해하는 언어로 변환하는 작업 |
| Compiler (컴파일러) | 컴파일 편집기, 번역기 |
| Machine Code (기계어) | 0, 1 만 쓰는 2진수 사용 |
| Assembly Language (어셈블리어) (Low-Level Language) | 0, 1 의 조합을 영문자로 기호화해 변환한 것 |
| High-Level Language (하이레벨 언어) | C언어 / 자바 / 파이썬 등 |
| Script Language (스크립트 언어) (인터프리터) | 기계어로 미리 번역하지 않고, 실행할 때마다 한 줄씩 번역 JavaScript (자바 스크립트)가 대표적 |
| Mark-up (마크업 언어) | 정보를 전달하기 위한 틀 제공 HTML (Hyper Text Markup Language)이 대표적 |
| .py | 파이썬이 저장될 때의 파일 확장 형식 |
| . 점 | 어떤 단어의 상하관계를 표현한다. ~의 / ~의 안에 |
| : 콜론 | 1. 부연설명 (들여쓰기 전 글을 부연설명 : 들여쓰기는 spacebar나 tab 2. 범위 표현 ~대신 쓴다. 3. = 기호 : 오른쪽 값을 왼쪽에 전달 |
| = | 오른쪽의 값을 왼쪽에 입력 |
| == | 같다는 표현 |
| \n or ￦n | 줄넘김 |
| 7진법 | 0-1-2-3-4-5-6 /-10-11-12-13-14-15-16 /-20-21-22-23-24-25-26/... |
| 8진법 | 0-1-2-3-4-5-6-7 /-10-11-12-13-14-15-16-17/... |
| 16진법 | 0-1-2-3-4-5-6-7-8-9-A-B-C-D-E-F /-10... |
| CPU (Central Process Unit) (중앙처리장치) | Bit : 자료의 크기를 표현하는 단위 (32bit, 64bit...) Hz : 컴퓨터의 빠름을 표현하는 단위 (2GHz=about 2,000MHz) |
| Variable (변수) | 메모리 공간 |
| Function (함수) | 행동 공간 |
| Memory (메모리) | 1. Storage Memory : 저장 메모리 2. Random Access Memory : RAM, 임의 접근 메모리, 작업 공간 3. Cache Memory : 캐시 메모리, 계산 공간 CPU 프로세서 캐시 메모리+메인 메모리 램 메모리+저장장치 SSD |
| GB > MB > KB | 1GB = 1,024MB = 1,048,576KB |
| 변수 선언 | String = "안녕하세요" |
| 변수끼리 값 전달하는 방법 | A = 5 B= A *B는 A의 복사본이지만, 값이 연결되어 있지 않은 독립체이다. a = 9 *A의 값이 9로 변하더라도 B의 값은 여전히 5이다. |
| 변수 이름의 규칙 | 1. 빈칸대신 밑줄 쓰기 2. 첫 글자는 숫자여선 안된다. 수의 연산에 혼동을 줄 수 있기 때문. 3. 소문자와 대문자를 구분지어야 한다. 4. 프로그래밍 언어로 사용되는 키워드는 사용 불가 (예 : def, if, else, for, while 등) |
| Index (색인) | 문자열 내용에 숫자를 부여하면 특정 단어만 추출하여 사용 가능 예 : 인사 = '안녕하세요' 0 / 1 / 2 / 3 / 4 부여 인사 [2] /*'하'만 추출한 것*/ 인덱스 뒤로 감기 '안녕하세요'에 -5 / -4 / -3 / -2 / -1 부여 인사 [-1] 뒤로 감기 됨 |
| Sliing (슬라이싱) | 변수 내용에 범위를 지정하여 사용 인사 [2:4] 일 경우, '하세'만 추출 /* 2번째부터 4번째 '전'까지 잘라서 가져오라는 의미 */ *인덱싱과 슬라이싱은 한줄로 연결된 변수가 아닌 독립된 변수로써 존재하는 형식에는 사용할 수 없다. (예 : 정수형) 예 : 서양식인사 = '좋은 아침입니다!' print (서양식인사) 짧은서양인사 = 서양식인사 [0:5] + 서양식인사 [-1] print (짧은서양인사) 출력 결과 : 좋은 아침입니다! 좋은 아침! ''' 리스트에서만 사용하는 슬라이싱 ''' 구간 설정없이 콜론 : 만 사용하는 경우이다. 예) pointA = [60, 'bump', 60, 70] pointB = pointA[:] print(pointB[2]) pointA[2] = 100 print(pointB[2]) 출력 결과 60 60 ''' pointA의 값을 바꿔도 pointB의 값이 바뀌지 않게 한다 ''' 슬라이싱으로 pointA의 값이 pointB의 참조가 아닌 복사가 되었기 때문이다. 여기서 pointB = pointA[:] 를 써놓지 않으면, 등호(=)를 통해 값이 연결되어 버린다. 출력 결과 60 100 ''' pointA의 값이 100으로 변경된 것에 영향을 받은 pointB ''' |
| * (연산자) | 파이썬에서는 문자형 변수에 *연산자*를 사용할 수 있다. 예 : 인사 = '안녕' 인사3번 = 인사 * 3 print (인사3번) 출력 결과 : 안녕안녕안녕 |
| Function (함수) | /*어떤 기능을 수행하는 공간*/ [1] 함수를 정의 : def 함수 이름 + 콜론(:) 다음줄에 spacebar 4칸 또는 tab 1칸으로 들여쓴 내용은 함수에 대한 설명 [2] 외부 값 가져오기 : def 함수 이름 (외부값, 외부값) : [3] 함수의 결과물 돌려주기 (리턴) : return 결과값 이름 /*리턴 명령은 필수 사항 아님*/ [4] 함수 사용하기 : def 함수 이름 (외부값) : 함수값 = 내용(식) return 함수값 이름 사용 이름 = 함수 이름 (내용(식)에 대입할 자료 입력) /*함수값 이름이 사용 이름으로 바뀜*/ /*함수 선언 먼저 한 후 호출*/ /*하나의 코드에 여러 함수를 만들어서 사용 가능 def 함수선언1 () : def 함수선언2 () : //함수호출 함수선언1 () 함수선언2 () 함수선언1 () */ |
| print (내장함수) | /*출력하기*/ [1] print ('출력할변수내용'] [2] 하나 이상의 값 출력 : +기호 사용 개수 = '20' print ('사과'+'개수'(변수)+'개'(문자열)) //출력 결과 사과20개 만약 개수 = 20 (따옴표 생략)일 때에는, 형변환 변수인 str( )이라는 내장 함수를 써야 한다. 개수 = 20 print('사과'+str(개수)='개' //출력 결과 사과20개 [2*] 하나 이상의 값 출력 : +대신 ,기호를 사용하면 형변환을 하지 않아도 되지만 입력값 사이에 무조건 빈칸이 함께 출력된다. [2**] 하나 이상의 값 출력 : 가장 빈번하게 쓰이는 방법으로, '따옴표' 안에 내용을 적은 후>>변수로 값을 받아야 하는 부분만 {} 기호를 적고>>끝에 .format(변수 이름)을 추가 개수 = 20 print('사과 {}개'.format(개수)) //출력 결과 사과 20개 |
| 형변환 혹은 캐스팅 함수 | 변수값의 형태를 변환시키는 함수 int ( ) / float ( ) / str ( ) |
| Resource | 자원 |
| library, package | 자원의 모음 |
| Build | 자가 작업 코드와 공급 받은 코드의 결합 작업 |
| SDK (Software Development Kit) | 컴파일러와 라이브러리 등을 제공하는 도구의 통칭 |
| IDE (Integrated Development Enviroment) | SDK를 사용하기에 편리한 환경 'Run'만 실행하면 컴파일, 빌드, 실행을 모두 처리해준다. |
| Pycharm | 파이참 : 파이썬에 최적화된 IDE |
| Visual Studio | 다양한 프로그래밍 언어를 지원하는 IDE |
| Machine learning | 머신러닝, 기계학습 : 게임 방법을 알려주고 그때로 따라하게 만든다. |
| Deep learning | 딥러닝, 심층학습 : 컴퓨터가 자가 반복학습을 통해 스스로 알아내게 한다. |
| if / while + True | /*True or False를 사용한 조건문 : 무한루프 없음*/ A = True if A : print('APPLE') /*True or False를 사용한 반복문 : 무한루프*/ while(True) : print('Infinite Loop') |
| comment | 주석 : # 내용 ''' 내용 ''' |
| in | /*메모리 안에 별개값의 키워드 호출*/ 예시 : A = 01234 ''' A 안에 01234가 있고 따로 분리 할 수 없다. ''' A = 'APPLE' ''' A 안에 값 P가 있다. ''' # 정수형 특징은 하나의 값이 메모리에 들어가는 구조 # 문자열 특징은 여러개의 메모리 값이 연결된 구조 |
| Array | 그룹 코드 (배열) : 문자열처럼 인덱스가 0으로 시작한다. [변수, 변수]로 묶은 후 반복문을 함께 사용한다. 예시 : point = [0.0] * 5 for num in range(5) : point[num] = float(input('Please enter point of number{} : ' . format(num))) print('--- value entered ---') for num in range(5) : print('point of number{} : {}' . format(num, point[num])) |
| sequence 자료형 | # 문자열, 리스트, 튜플처럼 메모리를 길게 연결한 형태의 자료형의 명칭, 딕셔너리는 하나의 쌍과 다른 쌍이 연속적이지 않기 때문에 해당 없음 |
| set 자료형 | 자료 사이에 순서와 중복값이 없게 된다. 리스트 자료형을 통해서만 만들 수 있다. 인덱싱, 슬라이싱 불가능 예) A = set(['a', 'p', 'p', 'l', 'e']) for contents in A : print(contents) 출력 결과 a p l e ''' 중복된 p 하나는 출력되지 않는다. ''' ''' 중복된 값을 다 없애고, 순서를 없앤 후, 집합 자료형이라는 새로운 형태로 저장된다 ''' 따라서 순서가 있어야만 가능한 인덱싱, 슬라이싱도 불가능하다. |
| mutable / immutable 값의 변경이 가능 / 불가능한 | mutable : 변할 수 있는 change의 어원과도 같음 immutable : 변할 수 없는 mutable 자료형 : 리스트, 딕셔너리, 집합 immutable 자료형 : 튜플, 정수형, 실수형, 문자열 *** 파이썬 안에 쓰레기 수집가 Garbage Collector라는 도구가 있다. immutable 자료형에서 변경된 값의 기존값을 자동으로 지운다. *** |
| id( ) | 변수가 immutable인지 mutable인지 확인해준다. 여러개 연결된 변수의 경우, 처음 메모리의 주소 값을 알려준다. 예) A = 1 print(id(A)) A = 2 print(id(A)) /* immutable의 경우 메모리 주소가 다르게 나온다. */ list = [1, 2, 3] print(list) print(id(list)) list[2] = 6 print(list) print(id(list)) 출력 결과 [1, 2, 3] 140182914363976 [1, 2, 6] 140182914363976 /* 리스트는 mutable 자료형이라서 메모리 주소가 동일하게 나온다. */ /* 정수 자료를 입력했을 때와 달리, 변수 'list'의 값을 수정해도 메모리 주소가 변경되지 않는다. */ |
| Constructor 생성자 | __Initialize__ 초기 내용을 설정한다. 코드의 반복을 방지하기 위하여 클래스를 선언할 때 생성자를 추가한다. 파이썬은 변수를 따로 선언하지 않고 생성자로 변수를 만드는 것을 선호한다. immutable 형태의 변수들로 인한 특이 현상 때문이다. |
| 상속 | 클래스 확장 : 기존 클래스를 리뉴얼하여 새로운 클래스를 만드는 것 |
| Super Class 슈퍼클래스 | 확장을 해주는 상위클래스 class AA(A) : 확장 받는 하위클래스=서브클래스 (확장 해주는 상위클래스=슈퍼클래스) : AA클래스 안에 A클래스가 포함된다. |
| Override 오버라이드 | 슈퍼클래스에서 정의된 메서드를 서브클래스에서 같은 이름의 메서드로 다시 정의하는 것 |
| modularization 모듈화 | 코드를 별도의 파일로 저장한 후, 필요할 때마다 가져오는 작업 |
| module 모듈 | 분리되어 저장되는 각각의 코드 파일 |
| Package 패키지 | 모듈의 묶음 (폴더 개념) |
| type ( ) | 변수의 자료형을 알 수 있는 파이썬의 내장 함수 anything = 2022 print(type(anything)) 출력 결과 <class 'int'> #class가 나오는 이유 : 파이썬이 모든 자료형을 클래스로 만들기 때문 '문자열'이나 ['a', 'b', 2022] 처럼 문자열과 리스트로 해도 마찬가지로 <class 'str'> <class 'list'> 로 클래스의 형태로 나온다. |
| 문자열, 리스트, 튜플에서 사용 가능한 메서드 | ''' 문자열 ''' 인사 = '안녕하세요' 저장형태 → 안 녕 하 세 요 | 0 1 2 3 4 ''' 리스트 ''' 성적 = [60, '결석', 60, 70] 저장형태 → 60 '결석' 60 70 | 0 1 2 3 ''' 튜플 ''' 성적 = (60, '결석', 60, 70) 저장형태 → 60 '결석' 60 70 | [0] [1] [2] [3] # 변수의 메모리들이 이어진 형태이다. 5가지 기능을 하는 메서드 #1 원하는 값이 몇 번째 메모리에 있는지 알려주기 #2 원하는 값이 몇 개의 메모리에 있는지 알려주기 #3 메모리 추가하기 ← immutable (튜플, 문자열 불가) #4 메모리 삭제하기 ← immutable (튜플, 문자열 불가) #5 메모리 위치 바꾸기 ← immutable (튜플, 문자열 불가) |
| #1 원하는 값이 몇 번째 메모리에 있는지 알려주기 | index(찾고 싶은 값) 메서드 사용 문자열 = '사과가 좋아, 사과 좋아' print(문자열.index(좋아)) # 사0-과1-가2- 3-좋4-아5 출력 결과 4 리스트 = ['포도', '포도', '바나나'] print(리스트.index('포도')) 출력 결과 0 튜플 = ('서울', '부산', '부산') print(튜플.index('부산')) 출력 결과 1 # 문자열은 찾는 문자 중 첫 번째 문자의 위치를 출력한다. # 리스트와 튜플은 처음 나오는 메모리 인덱스를 출력한다. |
| #2 원하는 값이 몇 개의 메모리에 있는지 알려주기 | .count : 값이 몇 개 있는지 찾아주는 메서드 문자열 = '사과가 좋아, 사과 좋아' print(문자열.count('좋아')) 출력 결과 2 리스트 = ['포도', '포도', '바나나'] print(리스트.count('포도')) 출력 결과 2 튜플 = ('서울', '부산', '부산) print(튜플.count('부산')) 출력 결과 2 |
| #3 메모리 추가하기 | # 이 기능은 리스트만 가능 # 맨 뒤에 값 붙이기 함수 | .append(붙일 값) 영어단어 뜻 | 덧붙이다 # 맨 뒤에 값 여러 개 붙이기 함수 | .extend ([붙일 값]) 영어단어 뜻 | 길게 만들다 # 중간에 값 붙이기 함수 | .insert(위치, 붙일 값) 영어단어 뜻 | 끼워 넣다 예) 리스트 = ['포도', '바나나'] 리스트.append('딸기') print(리스트) 출력 결과 ['포도', '바나나', '딸기'] ____________________* 리스트 = ['포도', '바나나'] 리스트.insert(1, '귤') # 인덱스 1에 '귤'을 끼워 넣으라는 뜻 print(리스트) 출력 결과 ['포도', '귤', '바나나'] ____________________* 리스트 = ['포도', '바나나'] 리스트.extend(['키위', '수박']) print(리스트) 출력 결과 ['포도', '바나나', '키위', '수박'] ____________________* # 다차원 형태 | append와 insert에 리스트 값을 넣으면, 리스트 = ['포도', '바나나'] 리스트.append(['딸기', '망고']) print(리스트) 출력 결과 ['포도', '바나나', ['딸기', '망고']] ************************ # 다차원 형태 insert의 경우 리스트 = ['포도', '바나나'] 리스트.insert(1, ['귤', '레몬']) print(리스트) 출력 결과 ['포도', ['귤', '레몬'], '바나나'] # 대괄호 안에 대괄호가 하나 더 들어가는 형태로 입력된다. |
| #4 메모리 삭제하기 | # 리스트만 가능 (1) 원하는 '값'을 찾아 삭제 | 함수 | .remove (삭제할 값) 뜻 | 제거하다. (2) '인덱스' 를 기준으로 삭제 | 함수 | .pop (인덱스) 뜻 | (풍선을) 펑 터뜨리다. _____________________* 리스트 = ['포도', '딸기', '사과', '키위'] 리스트.remove('딸기') print(리스트) 출력 결과 ['포도', '사과', '키위'] ************************* 리스트 = ['포도', '딸기', '사과', '키위'] 리스트.pop(2) print(리스트) 출력 결과 ['포도', '딸기', '키위'] # remove로 '딸기' 제거, pop으로 인덱스 2의 값인 '사과' 제거 |
| #5 메모리 위치 바꾸기 | # 리스트만 가능 (1) 순서를 반대로 변경하기 | 함수 | .reverse( ) 뜻 | 순서를 뒤집다. (2) 글자 순서대로 정리하기 | 함수 | .sort( ) 뜻 | 정리하다. ______________________* 리스트 = ['포도', '망고', '사과', '바나나] 리스트.reserve( ) print(리스트) 출력 결과 ['바나나', '사과', '망고', '포도'] ************************** 리스트 = ['포도', '망고', '사과', '바나나'] 리스트.sort( ) print(리스트) 출력 결과 ['망고', '바나나', '사과', '포도'] |
| IDE (Integrated Development Environment)(통합 개발 환경) | 1. 속성 클래스 또는 인스턴스 다음에 점(.)을 찍으면, 해당 클래스의 속성을 드롭다운 메뉴로 보여준다. 2. 클래스 클래스의 생성자 및 클래스와 관련된 다양한 메서드를 자동으로 만든다. 3. 자주 쓰는 문장 문장을 자동으로 완성해준다. |
| try ~ except (예외처리) | 프로그래밍에서 간혹 예외적으로 발생할 수 있는 오류를 처리하는 구문 |
| sleep | 컴퓨터의 반응 속도를 의도적으로 늦추는 것. sleep 함수가 있는 time 패키지를 import 한다. import time print('Next sentence will be printed after 5 seconds') time.sleep(5) # 소수점 단위로 멈추기도 가능 (예 : 0.05) print('Bye!') *____ randint 같이 간단하게 쓰기도 가능 ____* from time import * print('Next sentence will be printed after 5 seconds') sleep(5) print('Bye!') |
| thread | 스레딩 : 조각조각 나눠서 따로 사용하는 것 멀티스레딩 : 번갈아 가면서 하는 작업이 동시에 이뤄지는 것처럼 보임 사용하는 방법 : threading 패키지 안의 thread 클래스를 상속 import threading #threading 패키지 불러오기 class 숫자세기(threading.Thread): #Thread 클래스 상속받기 def __init__(self, 나의이름): threading.Thread.__init__(self) self.나의이름 = 나의이름 def run(self): #호출하는 이름 변경 for 숫자 in range(0, 5): print(self.나의이름, 숫자) 첫번째 = 숫자세기('첫번째') 두번째 = 숫자세기('두번째') 첫번째.start( ) ''' 메서드 두번째.start( ) 이름변경 ''' ''' 1. threading 패키지를 import 2. threading 패키지 안에 있는 Thread 클래스를 상속 3. 생성자의 초기화 __init__에도 상속받은 클래스 추가 4. 기존 메서드의 이름을 run으로 변경 5. 기존 메서드를 호출하는 대신 start ( ) 메서드 호출 ''' ____* 출력 결과 첫번째0 두번째0 두번째1 첫번째1 두번째2 첫번째2 첫번째3 두번째3 두번째4 첫번째4 ''' 온라인 컴파일러에서 실행 시, 프로세스 지연으로 스레드 효과가 나타나지 않으면, run( )메서드에 sleep( ) 사용한다. ''' # 상속받은 threading.Thread 클래스는 start( )메서드를 실행하면 클래스의 메서드 중 run( ) 메서드를 찾아 실행하도록 코딩되어 있다. 이 run( )메서드를 그냥 실행하지 않고 스레딩한 후 실행한다. |
| Multi-Threading / Multi-Tasking 차이점 | 멀티태스킹 | 여러 앱을 동시에 돌리는 것 멀티스레딩 | 하나의 앱 안에서 여러가지 작업이 동시에 진행 |
| Row 데이터 / Column 데이터 | Row : 가로줄, 행 Column : 세로줄, 열 # 각 Column의 맨 위에는 해당 Column의 특징을 나타내는 Column Name이 있다. # 각 Row 데이터를 구분할 수 있는 중복되지 않는 구분 값을 식별자 (ID, Identifier) 또는 인덱스 (index)라고 한다. |
| GUI (Graphical User Interface)(그래픽) | 사용자 친화적인 윈도우 화면 구성 |
| Event (이벤트) | 사용자가 무엇인가 실행했을 때 행동할 함수를 코드로 정의해둔 것 |
| Pixel (픽셀) | 그래픽 화면을 이루는 단위 읽는 방향 : 좌 → 우 / 아래 ↑ 위 |
| GUI 패키지 | '버튼'이나 '글자' 같은 그래픽 요소들을 만드는 코드를 저장해 둔 패키지 자주 사용되는 패키지 (1) tkinter 패키지 (2) PyQT |
| Lambda (람다) | def 함수를 사용하지 못하는 공간에 함수의 기능을 넣기 위해 사용 (예) # command처럼 인자 값을 전달할 수 없는 공간에 인자를 포함한 함수 결과를 전달 할 수 있다. 버튼1 = tk.Button( master = 게임화면, text = '묵', font = ('Arial', 10), command = 컴퓨터선택 ) # 람다를 사용한 버전 버튼1 = tk.Button( master = 게임화면, text = '묵', font = ('Arial', 10), commnad = lambda : 컴퓨터선택(1) ) # def 이름없는람다함수( ): return 컴퓨터의선택(1) lambda는 inline function(줄 속의 함수)라고도 불린다. 코드 속 이름 없는 함수이다. |
| Widget (위젯) | 버튼, 글자 등의 요소들 # tkinter 패키지의 클래스로 저장되어 있다. [가장 많이 사용하는 위젯 클래스] # 레이블(Label) | 글자를 표현한다. # 엔트리(Entry) | 값을 입력받을 수 있다. # 버튼 (Button) | 버튼을 만든다. |
| Label 클래스 위젯 기본형 예시 | 레이블예시 = tk.Label(위젯 생성자 변수) # 위젯 인스턴스 만들기 레이블예시.place(메서드 변수) # 만들어진 위젯의 위치와 크기 정하기 |
| Button 클래스 위젯 | 버튼예시 = tk.Button(위젯 생성자 변수) # 위젯 인스턴스 만들기 버튼예시.place(메서드 변수) # 만들어진 위젯의 위치와 크기 정하기 |
| 위(예시)의 구체적인 위젯 생성자 변수와 메서드 place도 입력하는 방법 | 레이블예시 = tk.Label( master = 게임화면, # 위젯이 놓일 컨테이너 text = '컴퓨터', # 위젯에 입력할 글자 font = ('Arial', 15), # 글꼴과 글자 크기 command = lambda: 출력( ) # 클릭했을 때 실행할 함수 ) 레이블예시.place( x = 0, ''' 위젯의 맨 왼쪽, y = 0, 위쪽 위치(픽셀) ''' width = 150, ''' 위젯의 가로, height = 50 세로 크기(픽셀) ''' ) ____* 버튼예시 = tk.Button( master = 게임화면, text = '묵', font = ('Arial', 15), command = lamdba: 선택(1) ) 버튼예시.place( x = 200, y = 50, width = 150, height = 50 ) |
| global | 키워드 : 함수 또는 메서드 밖에서 선언된 변수를 함수 또는 메서드 안에서 사용 |
| mainloop( ) | tkinter GUI 코딩의 필수 마감 처리 작업 (예) 게임화면.mainloop( ) 사용자가 입력할 때까지 계속 순환하면서 대기하게 만드는 명령어 이 코드가 없으면 tkinter의 GUI가 실행되지 못한다. |
| String | 문자열 변수 : '작은따옴표' 혹은 "큰따옴표"를 뒤에 붙인다. |
| def (definition) | [1] 함수를 정의 : def 함수 이름 + 콜론(:) |
| print ( ) | 내장함수 혹은 빌트인 함수 |
| int ( ) | 정수(integer)형으로 변환 // int('123')>>123 |
| float ( ) | 실수(float)형으로 변환 // float('123.456'>>123.456 |
| str ( ) | 문자(string)형으로 변환 // str(123)>>'123' |
| input ( ) | 사용자가 입력하는 값을 받는 함수 입력값 = input('질문 문장') 무조건 문자열로 저장 : 변수1 = input ('문자값 입력') 정수형으로 변환 : 변수2 = int(input('정수값 입력') 실수형으로 변환 : 변수3 = float(input'실수값 입력') |
| if, else | 조건문의 참, 거짓 if 대상 = 조건 : 참일 때 해야 하는 행동 else : 거짓일 때 해야 하는 행동 a가 10과 같을 때 : a ==10 a가 10보다 클 때 : a > 10 a가 10보다 작을 때 : a < 10 a가 10과 같거나 클 때(이상일 때) : a >= 10 a가 10과 같거나 작을 때(이하일 때) : a <= 10 a가 10이 아닐 때 a != 10 |
| elif | if+else : OO = input (' (Yes or No') @@ = input (' (Yes or No') if OO == 'Yes' : print(' ') elif @@ == 'Yes' : print(' ') else : (' ') |
| while | 기본 반복문 day = 1 while day <= 100 : 반복할 행동 day = day + 1 |
| for | 조건을 포함한 반복문 for day in range (1, 100, 1) : 반복할 행동 |
| range (in range) | range(1, 100, 1) 1부터 100에 도달하기 전까지 (99까지) 1씩 진행 range(시작값, 목표의 직전값, 진행값) /*파이썬의 특징 : 종료값을 포함하지 않는다.*/ range에 3개의 숫자를 쓰지 않고 일부를 생략하면 생략된 값은 자동으로 기본값이 입력된다. 예시 range(1, 100, 1)에서 진행값을 생략하면 range(1, 100)는 자동적으로 range(1, 100, 1)을 의미하며, 범위는 1, 2, 3, 4... 99 까지 이다. range(1, 100, 1)에서 시작값과 진행값을 생략하면 range(100)은 자동적으로 range(0, 100, 1)을 의미하며, 범위는 0, 1, 2, 3...99 까지 이다. |
| 2*1=2 2*2=4 2*3=6 2*4=8 .......... 9*6=54 9*7=63 9*8=72 9*9=81 | 출력값 =' ' for 앞수 in range(2, 10) : for 뒷수 in range(1, 10) : 지금값 = '{}*{}={}/n' .format(앞수, 뒷수, 앞수 * 뒷수) 출력값 = 출력값 + 지금값 print(출력값) |
| \ | \b ￦b : backspace 뒤로가기 \n ￦n : newline 다음 줄로 넘기기 \s ￦s : space 한 칸 띄우기 \t ￦t : tab 일정 간격 띄우기 *2개의 문자로 표현되더라도, 하나의 문자로 인식한다. |
| 구구단 시작 단을 입력하세요(1~9) : 3 구구단 끝 단을 입력하세요(1~9) : 5 3*1=3 3*2=6 ... 3*9=27 ********** 4*1=4 4*2=8 ... 4*8=32 4*9=36 ********** 5*1=5 ... 5*8=40 5*9=45 | 시작단 = int(input('구구단 시작 단을 입력하세요(1~9) : ')) 끝단 = int(input('구구단 끝 단을 입력하세요(1~9) : ')) 출력값 = ' ' for 앞수 in range(시작단, 끝단 + 1) : for 뒷수 in range(1, 10) : 지금값 = '{}*{}={}\n' . format(앞수, 뒷수, 앞수*뒷수) 출력값 = 출력값 + 지금값 if 앞수 == 끝단 : pass else : 출력값 = 출력값 + '**********/n' print(출력값) |
| 시작단 = int(input('구구단 시작 단을 입력하세요(1~9) : ')) 끝단 = int(input('구구단 끝 단을 입력하세요(1~9) : ')) 출력값 = ' ' for 앞수 in range(시작단, 끝단 + 1) : for 뒷수 in range(1, 10) : 지금값 = '{}*{}={}\n' . format(앞수, 뒷수, 앞수*뒷수) 출력값 = 출력값 + 지금값 if 앞수 != 끝단 : 출력값 = 출력값 + '**********\n' print(출력값) | /*출력값 = 출력값 + '**********\n' 을 출력값 += '**********\n' 으로 간편하게 바꿀 수 있다.*/ 시작단 = int(input('구구단 시작 단을 입력하세요(1~9) : ')) 끝단 = int(input('구구단 끝 단을 입력하세요(1~9) : ')) 출력값 = ' ' for 앞수 in range(시작단, 끝단 + 1) : for 뒷수 in range(1, 10) : 지금값 = '{}*{}={}\n' . format(앞수, 뒷수, 앞수*뒷수) 출력값 += 지금값 if 앞수 != 끝단 : 출력값 += '**********\n' print(출력값) |
| break | 반복문 자체를 중지 |
| continue | 반복문은 유지하되, 현재 반복을 생략하고 다음 반복으로 넘어감 |
| for X in range(4) : if X == 2 : print(X) | 출력 결과 0 1 3 |
| for X in range(4) : if X == 2 : break print(X) | 출력 결과 0 1 |
| break 로 무한루프 깨기 | while(True) : ← Starting Infinite Loop A = input('Answer the code : ') if (A == 'APPLE') : print('Is Red.') break print('That Not The Answer What I Want.') |
| # 키워드 in 을 사용한 조건문 A = APPLE if 'A' in A : print('True') else : print('False') | # 키워드 in 을 사용한 반복문 A = 'APPLE' for each_word in A : print(each_word) ''' 출력 결과 ''' A P P L E |
| sentence = input('Please enter any text : ') noc = 0 ''' number of characters ''' for aw in sentence : ''' a word ''' if aw != ' ' : noc += 1 print(sentence * noc) | 결과 Please enter any text : An apple An apple An apple An apple An apple An apple An apple An apple ''' 빈칸을 빼고 7글자이기 때문에 'An apple'이 7번 복사되어 출력 ''' |
| 자료형 변수 List [ ] Tuple ( ) Dictionary { } | 인덱싱할 때는 모두 [대괄호]를 사용 |
| list와 Tuple 차이 | 인덱싱 (하나의 자료), 슬라이싱 (여러자료) 다 가능 리스트만 인덱싱 후 값 변경 가능 예) point = [60, 'bump', 60, 70] #list point[2] = 95 ''' O ''' point = (60, 'bump', 60, 70) #tuple point[2] = 95 ''' X ''' |
| ''' List ''' [ ] 인덱싱 O 인덱싱 후 값 변경 O 슬라이싱 O in 키워드 | ''' tuple ''' ( ) 인덱싱 O 인덱싱 후 값 변경 X 슬라이싱 O in 키워드 O |
| Dictionary | Key : value 문자, 정수, 실수 모두 가능 예) point = {'A':60, 'B':'bump', 'C':60, 'D':70} # 리스트, 튜플과 달리 숫자로 인덱싱하지 않고, key로 인덱싱 한다. point = {'A':60, 'B':'bump', 'C':60, 'D':70} print(point[C]) 출력 결과 60 |
| Class (classification) | 프로그래밍에 쓰이는 여러 기능을 작게 구분하는 단위 |
| Object Oriented Programming 객체지향형 프로그래밍 | 클래스를 사용해서 코딩하는 것 object와 instance는 혼용되기 쉬우나, object는 세트로 생성된 명령어 자체를 의미하고, instance는 명령어의 다양한 명칭을 말한다. |
| 클래스 기본형 | class A : a = 0 b = 0 c = 0 |
| instance 인스턴스 | 클래스를 사용하여 만들어진 세트 # 클래스를 먼저 선언하고 인스턴스를 생성해야 한다. |
| 클래스로 인스턴스 생성하는 방법 | red = A( ) ''' 인스턴스이름 = 클래스이름( ) ''' |
| 인스턴스에 값 넣는 방법 | red = A( ) red.a = 1 red.b = 2 red.c = 3 |
| 인스턴스에 값 넣는 방법 (한 가지만 들어간) | ㄱㄷㅇ = A( ) red.a = 3 red.b = 0 red.c = 0 |
| Method 메서드 | 클래스에서 만들어진 함수 |
| self 클래스 자신의 키워드 | 예) class A( ) : a = 0 b = 0 c = 0 def total(self, name) : plus = self.a + self.b + self.c #total 이라는 이름의 메서드 return name + str(plus) 파이썬에서는 self 라는 호출값이 존재한다. 예시처럼 self.a는 클래스 안에서 선언된 변수 'a'를 의미한다. 메서드 밖에서 선언된 변수를 사용하기 위해서, 메서드 괄호 안에 self를 적어야 하고, 메서드 내용에서도 self.a와 같은 식으로 적어야 한다. |
| 메서드 사용하기 | class A( ) : a = 0 b = 0 c = 0 def total(self, name) : plus = self.a + self.b + self.c return name + str(plus) ''' 'total' 메서드 생성 ''' red = A( ) red.a = 1 red.b = 2 red.c = 3 출력값 = red.total('A red contents : ') # 결과값이 담길 변수 이름 = 인스턴스 이름 . 메서드 이름( ) print(출력값) 출력 결과 A red contents : 6 ''' self는 클래스 안에서 선언된 변수를 호출하는 기호일 뿐, 메서드를 사용할 때는 '없는 값'으로 처리한다. ''' |
| 리턴값이 없는 메서드의 경우 | class A( ) : a = 0 b = 0 c = 0 def 출력(self, name) : print('**', name, '**') print('a : ', self.a) print('b : ', self.b) print('c : ', self.c) ''' '출력' 메서드 선언한 것 ''' red = A( ) red.a = 1 red.b = 2 red.c = 3 red.출력('A red contents') ''' 인스턴스 이름 . 메서드 이름( ) 출력 결과 ** A red contents ** a : 1 b : 2 c : 3 |
| self로 메서드도 호출하는 방법 | ''' self로 변수뿐만 아니라 클래스 안에서 선언된 다른 메서드도 호출할 수 있다. ''' 예) class A( ) : a = 0 b = 0 c = 0 def 출력(self, name) : print('**', name, '**') print('a : ', self.a) print('b : ', self.b) print('c : ', self.c) def 출력2(self) : self.출력('A') ''' '출력' 메서드를 포함한 '출력2' 메서드 선언 ''' red = A( ) red.a = 1 red.b = 2 red.c = 3 red.출력2 출력 결과 ** A ** a : 1 b : 2 c : 3 ''' '출력2( )' 메서드는 위에서 사용한 '출력( )' 메서드를 self로 호출해 사용하고 있다. ''' |
| 생성자가 있을 때 인스턴스 | 생성자가 없을 때 인스턴스 |
| red = A( ) red.1=1 red.2=2 red.3=3 | red = A(1, 2, 3) # 각각의 값이 어느 변수에 저장되어야 하는지 생성자를 만들어야 한다 |
| 생성자를 코드로 작성하는 방법 | class A( ) : a = 0 b = 0 c = 0 def__init__(self, a, b, c) : self.a = a self.b = b self.c = c ''' __init__는 생성자를 뜻한다. ''' |
| ''' 생성자 ''' class A( ) : a=0 b=0 c=0 def __init__(self, a, b, c) : ''' 생성자 ''' self.a = a self.b = b self.c = c | ''' 인스턴스 생성 ''' class A( ) : a=0 b=0 c=0 def __init__(self, a, b, c) : self.a = a self.b = b self.c = c red = A(1, 2, 3) ''' 인스턴스 ''' |
| 변수 선언 없이 인스턴스 만들기 | class A( ) : def __init__(self, a, b, c) : self.a = a self.b = b self.c = c |
| PEP (Python Enhancement Proposal)(파이썬 향상을 위한 제안) | 권장사항으로 통용되는 내용을 정리해서 제안하는 문서 작성 스타일에 대한 제안은 PEP 8에 정의되어 있다. www.python.org/dev/peps/pep-0008 |
| 클래스 첫 이니셜은 영문 대문자, 인스턴스 첫 이니셜은 영문 소문자 | class TunaCanSet( ) : # 클래스 이름은 대문자로 시작 def __init__(self, normal, veg, pepper) : self.normal = normal self.veg = veg self.pepper = pepper def content_show(self, name) : print('****', name, '****') print('Normal Tuna : ', self.normal) print('Vegitable Tuna : ', self.veg) print('Pepper Tuna : ', self.pepper) tunaset01 = TunaCanSet(12, 5, 6) tunaset01.content_show('Tuna GiftSet 01') # 인스턴스 이름은 소문자로 시작 |
| 클래스 상속 사용 방법 | class A( ): def __init__(self, a, b, c) : self.a = a self.b = b self.c = c def 출력(self, name) : print('**', name, 'conten **') print('a : ', self.a) print('b : ', self.b) print('c : ', self.c) # 여기까지 'A' 클래스 class AA(A) : # 여기부터 'AA' 클래스 def __init__(self, a, h, k) : super( ) . __init__(a,, 0, 0) # A(a, 0, 0)를 가리킨다. self.h = h self.k = k ''' super.b 코드는 슈퍼클래스의 'b'를 호출한다. ''' |
| 오버라이드 : 슈퍼클래스로 정의된 메서드를 서브클래스에서 덮어쓰기 | class A( ) : #생성자 생략 def 출력(self, name) : print('**', name, 'content **') print('a : ', self.a) print('b : ', self.b) print('c : ', self.c) # 슈퍼클래스의 '출력' 메서드 class AA(A) : # 클래스 선언 생략 def 출력(self, name) : super( ).출력(name) ''' 상속받은 '출력' 메서드 호출 ''' print('h : ', self, h) print('k : ', self.k) # 이름은 같지만 내용이 다른 '출력' 메서드 A01 = AA(1, 2, 3) A01.출력('AA 01') 출력 결과 ** AA 01 content ** a : 1 b : 0 c : 0 h : 2 k : 3 |
| import 파일명 | # 별도로 저장된 코드 파일을 불러오는 용도 # 파일명 뒤에 점(.)을 찍고 해당 파일에서 불러올 클래스 이름을 적으면 더 정확하게 호출 할 수 있다. # 클래스, 함수, 변수 등 다양하게 모듈로 이용 할 수 있다. |
| 모듈을 import 하는 방법 [1] | 방법 [1] 모듈의 별명 만들기 import Abcdefgsijklmn as An import Intro as Int Int.인사말출력( ) print('l was born in { }.' . format(Int.year)) red01 = An.A(1, 2, 3) red01.출력('A 01') #An, Int 처럼 짧은 별명을 만드는 방식 |
| 모듈을 import 하는 방법 [2] | 방법 [2] 모듈 안의 클래스/함수/변수 바로 가져오기 from Abcdefghijklmn import A from Intro import 인사말출력, year ''' 이후 코드에서는 모듈 이름을 추가로 부를 필요가 없어진다. ''' 인사말출력( ) print ('I was born in { }.' . format(year)) red01 = A(1, 2, 3) red.출력('A 01') |
| * 모든 값을 의미하는 기호 | from Abcdefghijklmn import * from Intro import * 인사말출력( ) print ('I was born in { }.' . format(year)) red01 = A(1, 2, 3) red01.출력('A 01') |
| Package 패키지 쓰는 방법 | # 패키지 이름 . 모듈 이름 형식으로 import 한다. 예) import matplotlib.pyplot as plt '''import 패키지 . 모듈 as 별명 ''' |
| ord( ) | # 영문글자는 아스키 코드 / 한글 글자는 유니코드 값 출력 예) print(ord('망'), ord('바'), ord('사'), ord('포')) 출력 결과 47581 48148 49324 54252 ______________________* # '첫 글자의 유니코드 값'의 반대 방향으로 정렬하기 reverse = True 이용 리스트 = ['포도', '망고', '사과', '바나나'] 리스트.sort(reverse = True) print(리스트) 출력 결과 ['포도', '사과', '바나나', '망고'] |
| 딕셔너리 자료형 | key : value (1) key 값만 뽑아내기 (2) value 값만 뽑아내기 (3) key 값으로 찾아서 삭제하기 (4) key-value 쌍 추가하기 |
| 딕셔너리 | (1) key 값만 뽑아내기 | .kyes( ) dict_keys라는 형태로 저장된다. (예) 딕셔너리 = {'name' : 'A', 'birth' : 1988, 'from' : 'korea'} 키값만 = 딕셔너리.keys( ) print(키값만) 리스트로 = list(키값만) # key 값을 리스트로! print(리스트로) 튜플로 = tuple(키값만) # key 값을 튜플로! print(튜플로) 출력 결과 dict_keys(['from', 'name', 'birth']) ['from', 'name', 'birth'] ('from', 'name', 'birth') # 딕셔너리에는 순서가 없다. 따라서 임의의 순서로 출력된다. ____* # key 값만 뽑아내 출력하는 반복문 딕셔너리 = {'name' : 'A', 'birth' : 1988, 'from' : 'korea'} for 키값 in 딕셔너리.keys( ): print(키값) 출력 결과 birth from name |
| 딕셔너리 | (2) value 값만 뽑아내기 | .values( ) dict_values라는 형태로 저장된다. (예) 딕셔너리 = {'name' : 'A', 'birth' : 1988, 'from' : 'korea'} 벨류만 = 딕셔너리.values( ) print(벨류만) 리스트로 = list(벨류만) # value 값을 리스트로 print(리스트로) 튜플로 = tuple(벨류만) # value 값을 튜플로 print(튜플로) 출력 결과 dict_values(['A', 1988, 'korea']) ['A', 1988, 'korea'] ('A', 1988, 'korea') ____* .values( ) 메서드를 반복문과 결합해 사용하기 (예) 딕셔너리 = {'name':'A', 'birth':1988, 'from':'korea'} for 벨류값 in 딕셔너리.values( ): print(벨류값) 출력 결과 A 1988 korea |
| 딕셔너리 | (3) key 값으로 찾아서 삭제하기 | .pop( ) 메서드를 사용하여, 괄호 안에 인덱스 값이 아닌 key 값을 입력 (예) 딕셔너리 = {'name':'A', 'birth':1988, 'from':'korea'} 딕셔너리.pop('birth') print(딕셔너리) 출력 결과 {'name':'A', 'from':'korea'} |
| 딕셔너리 | (4) key-value 쌍 추가하기 | 딕셔너리는 순서가 없다. 따라서 새로운 짝을 간단히 추가한다. (예) 딕셔너리 = {'name':'A', 'birth':1988, 'from':'korea'} 딕셔너리['O7']='OOO OOOO' print(딕셔너리) 출력 결과 {'from':'korea', 'name':'A', 'birth':1988, 'O7':'OOO OOOO'} |
| % | 나머지를 구하는 기본 수식 (예) 5%4 =1 #5를 4로 나누었을 때의 나머지는 1 |
| Kernel (커널) | 핵심이 되는 기능 파이썬 컴파일러를 파이썬 커널이라고 부른다. |
| Shell (셸) | 커널의 상반된 의미 커널을 작동하기 위해 코드를 입력하는 껍데기 |
| Terminal (터미널) | 마지막에 사용자를 만나게 되는 무엇 (중심) // 커널 // 셸 // 터미널 // (끝) 자동차의 조종을 운전석에서 한다면 운전석은 셸 or 터미널 원격으로 조종되는 자동차라면 자동차를 조종하는 통제실은 터미널 |
게임 만들기
# 베라 31
1부터 시작해서 1~3개의 연속된 숫자를 부르며 게임 진행, 마지막 숫자 31을 부르는 사람이 지는 게임
- 스케치
- 게임시작 ▷ 1부터 31까지 3개씩 ▷ 31인가? (네 / 아니오) ▷ 네 : 벌칙 당첨 / 아니오 : 반복
- 반복문, 조건문 사용 / '게임수'라는 변수가 31에 도달할 때까지 반복해서 숫자를 호출, 31에 '벌칙 당첨!' 문자 출력
- 숫자를 몇 개 호출할지 숫자로 입력받아 그 전 값에 더해 주는 방식 사용
- 입력값 출력
- '게임수'보다 1 큰 수부터 시작하여 '입력값의 개수'만큼 연이어 출력하는 반복문을 사용한다.
- '입력값'으로 3을 입력했다면, for문의 '숫자'에서 처음에는 0, 두 번째 반복에선 1, 세 번째 반복에선 2가 .format( )으로 출력
- 참가자 추가
- 첫 번째 참가자의 행동 복사해서 붙여넣기
- 단, 입력을 받을 때 누구의 순서인지 알 수 있게 input( )출력문을 보강한다.
| 1. 스케치 | print('게임 시작!') 게임수 = 0 while True: 입력값= int(input('숫자 몇 개를 부를 건가요? (1~3) : ')) 게임수 = 게임수 + 입력값 if(게임수 >= 31): break print('벌칙 당첨!') |
| 출력 결과 | 게임 시작! 숫자 몇 개를 부를 건가요? (1~3) :3 숫자 몇 개를 부를 건가요? (1~3) :2 숫자 몇 개를 부를 건가요? (1~3) :3 ... 벌칙 당첨! |
| 2. 입력값 출력 | prin('게임 시작!') 게임수 = 0 while True: 입력값= int(input('숫자 몇 개를 부를 건가요? (1~3) : ')) for 숫자 in range(입력값): print('{}!' .format(게임수 + 1 + 숫자)) 게임수 = 게임수 + 입력값 if(게임수 >= 31): break print('벌칙 당첨!') |
| 출력 결과 | 게임 시작! 숫자 몇 개를 부를 건가요? (1~3) :3 1! 2! 3! 숫자 몇 개를 부를 건가요? (1~3) :2 4! 5! ... |
| 3. 참가자 추가 | print('게임 시작!') 게임수 = 0 while True: 입력값= int(input('[참가자1] 숫자 몇 개를 부를 건가요? (1~3) : ')) for 숫자 in range(입력값): print ('{} !' .format(게임수 + 1 + 숫자)) 게임수 = 게임수 + 입력값 if(게임수 >= 31): break 입력값= int(input('[참가자2] 숫자 몇 개를 부를 건가요? (1~3): ')) for 숫자 in range(입력값): print ('{}!'.format(게임수 + 1 + 숫자)) 게임수 = 게임수 + 입력값 if(게임수 >= 31): break print('벌칙 당첨!') |
| 출력 결과 | 게임 시작! [참가자1] 숫자 몇 개를 부를 건가요? (1~3) :3 1! 2! 3! [참가자2] 숫자 몇 개를 부를 건가요? (1~3) :2 4! 5! ... [참가자3] 숫자 몇 개를 부를 건가요? (1~3) :1 31! 벌칙 당첨! |
# 랜덤
0 < random < 1
랜덤숫자를 이용하는 원리 | x개의 가능성을 택1하게 만드는 것
1. 랜덤 숫자를 정수로 만든다.
2. x로 나눈다.
3. 나머지 값을 사용한다.
% : 프로그래밍에서 나머지를 구하는 기본 수식
- 베라 31 게임에 컴퓨터 참가자 추가
- random 패키지와 randint( ) 함수를 같이 사용하는 방법
- random.randint( ) 대신에 randint( )만 사용하는 방법
- 패키지를 불러오는 import 명령 ← 코드의 맨위
- randint( ) 함수 ← 두번째 참가자의 '입력값' 대신에 입력
- 컴퓨터 차례라는 것을 정확히 보여주기 위해 출력문을 하나 더 입력
| random 패키지 + randint( ) | import random print(random.randint(1, 3)) |
| randint( )만 사용 | from random import * # random 패키지의 모든 것 불러오기 print(randint(1, 3)) |
| 베라 31 코드에 추가 (import 명령은 패키지를 사용하기 전에만 입력하면 되지만, 보통 코드의 맨 위에 넣는다.) | from random import * print('게임 시작!') 게임수 = 0 while True: 입력값 = int(input('[참가자1] 숫자 몇 개를 부를 건가요? (1~3) : ')) for 숫자 in range(입력값): print('{}!' .format(게임수 + 1 + 숫자)) 게임수 = 게임수 + 입력값 if(게임수 >= 31): break 입력값= randint(1, 3) print('[컴퓨터] 숫자 몇 개를 부를 건가요? (1~3) : {}' .format(입력값) for 숫자 in range(입력값): print('{}!' .format(게임수 + 1 + 숫자) ) 게임수 = 게임수 + 입력값 if(게임수 >= 31): break print('벌칙 당첨!') |
| 출력 결과 | 게임 시작! [참가자1] 숫자 몇 개를 부를 건가요? (1~3) : 3 1! 2! 3! [컴퓨터] 숫자 몇 개를 부를 건가요? (1~3) : 2 4! 5! ... |
# try ~ except 예외처리
- 베라 31 게임에서 예외처리가 필요한 코드 찾기
- 첫 번째 경우 : 1, 2, 3 숫자가 아닌 다른 숫자를 입력한 경우
- 조건문을 사용해 미리 예외적인 경우를 막아야 한다.
- 두 번째 경우 : 1, 2, 3 숫자가 아닌 문자를 입력한 경우
- try ~ except 를 사용해서 오류에 대처해야 한다.
- 첫 번째 경우 : 1, 2, 3 숫자가 아닌 다른 숫자를 입력한 경우
- 예외처리를 위해 감싸주기
- 정상 값을 입력받을 때까지 예외처리 계속하기
- try 안에 반복문을 사용해서 값을 정상적으로 받을 때까지 input( )을 실행한다.
- 참가자가 정상값을 입력하면 input( )이 실행되고 break가 실행되어, 반복문 밖으로 나간다.
- 참가자가 정상값을 입력하지 않으면 input( )이 실행되지 않고 excep로 넘어가서 무한루프 반복
- 입력값이 1~3 사이의 값인지도 한 번 더 검사하는 조건문을 추가한다.
- 함수를 사용해서 본문 코드 단순화
- 내부 반복문을 def 함수로 만든다.
| 베라 31 게임에 예외처리를 한 전체 코드 | from random import * print('게임 시작!') 게임수 = 0 while True: # 여기부터 예외처리 while True: try: 입력값 = int(input('[참가자1] 숫자 몇 개를 부를 건가요? (1~3): ')) if 입력값 >= and 입력값 <=3: break else: print('1에서 3사이의 숫자만 입력하세요') except: print('잘못 입력했습니다. 숫자를 입력하세요') for 숫자 in range(입력값): print('{}!' .format(게임수 + 1 + 숫자)) 게임수 = 게임수 + 입력값 if(게임수 >= 31): break 입력값 = randint(1, 3) print('[컴퓨터] 숫자 몇 개를 부를 건가요? (1~3):{}' .format(입력값)) for 숫자 in range(입력값): print('{}!' .format(게임수 + 1 + 숫자)) 게임수 = 게임수 + 입력값 if(게임수 >= 31): break print('벌칙 당첨!') |
| 출력 결과 | 게임 시작! [참가자1] 숫자 몇 개를 부를 건가요? (1~3): 몰라 잘못 입력했습니다. 숫자를 입력하세요 [참가자1] 숫자 몇 개를 부를 건가요? (1~3): 5 1에서 3사이의 숫자만 입력하세요 [참가자1] 숫자 몇 개를 부를 건가요? (1~3): 2 1! 2! [컴퓨터] 숫자 몇 개를 부를 건가요? (1~3): 2 3! 4! [참가자1] 숫자 몇 개를 부를 건가요? (1~3): ... |
| 본문 코드 단순화 | from random import * # 여기부터 예외처리를 위해 만든 함수 def 원하는정수값받기(질문) while True: try: 입력값= int(input(질문)) if 입력값 >= 1 and 입력값 <= 3: break else: print('1에서 3사이의 숫자만 입력하세요') except: print('잘못 입력했습니다. 숫자를 입력하세요') return 입력값 # 여기까지 예외처리를 위해 만든 함수 print('게임 시작!') 게임수 = 0 while True: 입력값 = 원하는정수값받기('[참가자] 숫자 몇 개를 부를 건가요? (1~3): ') for 숫자 in range(입력값): print('{}!' .format(게임수 + 1 + 숫자)) 게임수 = 게임수 + 입력값 if(게임수 >= 31) break 입력값= randint(1, 3) print('[컴퓨터] 숫자 몇 개를 부를 건가요? (1~3):{}' .format(입력값)) for 숫자 in range(1, 3) print('{}!' .format(게임수 + 1 + 숫자)) 게임수 = 게임수 + 입력값 if(게임수 >= 31): break print('벌칙 당첨!') |
# sleep
베라 31 게임에서 컴퓨터 반응 속도 늦추기
| 컴퓨터의 선택 2초 지연 | from random import * import time # time 패키지 불러오기 def 원하는정수값받기(질문): while True: try: 입력값= int(input(질문)) if 입력값 >= 1 and 입력값 <= 3: break else: print('1에서 3사이의 숫자만 입력하세요.') excep: print('입력값이 잘못되었습니다. 다시 입력하세요') return 입력값 print('게임 시작!') 게임수 = 0 while True: 입력값 = 원하는정수값받기('[참가자] 숫자 몇 개를 부를 건가요? (1~3): ') for 숫자 in range(입력값): print('{}!' .format(게임수 + 1 + 숫자)) 게임수 = 게임수 + 입력값 if(게임수 >= 31): break time.sleep(2) 입력값= randint(1, 3) print('[컴퓨터]' 숫자 몇 개를 부를 건가요? (1~3): {}' .format(입력값)) for 숫자 in range(입력값): print('{}!' .format(게임수 + 1 + 숫자)) 게임수 = 게임수 + 입력값 if(게임수 >= 31): break print('벌칙 당첨!') |
| 출력 결과 | 게임 시작! [참가자] 숫자 몇 개를 부를 건가요? (1~3): 2 1! 2! [컴퓨터] 숫자 몇 개를 부를 건가요? (1~3): 3 # 2초 3! 4! 5! [참가자] 숫자 몇 개를 부를 건가요? (1~3): ... |
| 개발 환경 1 | 개발 환경 2 | 개발 환경 3 | |
| 코드 작성기 (에디터) | 파이썬 기본 에디터 | 통합 개발 환경(IDE) | 통합 개발 환경(IDE) |
| 컴파일러 | 파이썬 컴파일러 | 파이썬 컴파일러 | 파이썬 컴파일러 |
| 컴퓨터 환경 | 내 컴퓨터 | 내 컴퓨터 | 가상 환경 |
- 에디터 = Control
- 컴파일러 = Engine(Core devices)
- 컴퓨터 환경 = Field(Environment)
-1-
개발 환경 ① 가장 기본적인 환경
파이썬 컴파일러를 설치하는 가장 단순한 방법 : 파이썬 공식 웹페이지
http://www.python.org/downloads
Download Python
The official home of the Python Programming Language
www.python.org
IDLE (Integrated Development and Learning Environment) : 기본 에디터, 파이썬에서 만든 통합 개발 환경(IDE)
-2-
개발 환경 ② 전용 에디터
- 파이참 PyCharm
- 비주얼 스튜디오 코드 Visual Studio Code
- 주피터 노트북 Jupyter Notebook
파이썬 컴파일러를 설치한 후 추가로 설치해서 사용
개발 환경 ③ 가상의 컴퓨터 환경
아나콘다 Anaconda : 컴파일러부터 에디터까지 설치 한 번에 가능
| 1단계 | 아나콘다 설치하기 | 1. www.anaconda.com 접속 2. [Products - Individaul Edition] 클릭 [Download] 3. 컴퓨터에 맞는 버전을 클릭하면 설치 파일 다운로드 시작 4. [Next] 클릭 설치 계속 진행 # Install for (사용자) 선택 화면에서 [All users (모든 사용자)] 권장, [Just Me]는 한글 로그인 정보로 인해 실행되지 않을 수 있다. |
| 2단계 | 주피터 노트북 실행하기 | # 설치된 아나콘다 앱으로 에디터인 주피터 노트북 실행 가능 1. [Anaconda Navigator] 실행 2. 주피터 노트북의 [Launch] 클릭 3. 우측 상단 [New ▶ Python 3] 클릭 # 검은색 창이 한 개 뜬다. 닫지 말고 그대로 둔다. 4. 빈칸에 코드를 입력하고 [Run] |
아나콘다 설치
http://www.anaconda.com
Anaconda | The World’s Most Popular Data Science Platform
Anaconda is the birthplace of Python data science. We are a movement of data scientists, data-driven enterprises, and open source communities.
www.anaconda.com
[1 단계] Pandas (판다스) 패키지 불러오기
아나콘다를 설치하면 판다스가 자동으로 설치된다.
판다스 불러오기
import pandas as pd
[2 단계] Series, DataFrame
판다스의 두 가지 클래스
시리즈 Series : 하나의 칼럼이 있는 데이터
# 인덱스 칼럼이 무조건 있어야 하기 때문에 실제로는 2개의 칼럼으로 구성
데이터프레임 DataFrame : 여러 개의 칼럼 (데이터의 틀 Frame을 만드는 클래스)
| Series (시리즈) 클래스 | # series 클래스의 인스턴스는 딕셔너리 자료를 생성자로 입력 (예) 딕_성별 = {'01' : '남', '02' : '여', '03' : ' ', '04' : '남'} 성별 = pd.Serie(딕_성별) # 위 코드의 시리즈 클래스 생성자에 바로 딕셔너리 변수 값을 입력해서 바꾸기 가능 (예) 성별 = pd.Series({'01' : '남', '02' : '여', '03' : ' ', '04' : '남'}) # 보기 편하게 입력 성별시리즈 = pd.Series({ '01' : '남', '02' : '여', '03' : ' ', '04' : '남' }) ''' '성별시리즈' Series 클래스 선언 ''' 이름시리즈 = pd.Series({ '01' : 'A', '02' : 'B', '03' : 'C', '04' : 'D' }) ''' '이름시리즈' Series 클래스 선언 |
| DataFrame (데이터프레임) 클래스 | # Series 클래스 인스턴스 묶어서 DataFrame 만들기 (예) 딕_member = {'성별' : 성별시리즈, '이름' : 이름시리즈} ourmember = pd.DataFrame(딕_member) (원리 이해) 01 남 02 여 03 04 남 01 A 02 B 03 C 04 D 01 남 A 02 여 B 03 C 04 남 D |
| import pandas as pd # 판다스 패키지 불러오기 성별시리즈 = pd.Series({ ''' Series 인스턴스 생성 시작 ''' '01' : '남', '02' : '여', '03' : ' ', '04' : '남' }) 이름시리즈 = pd.Series({ '01' : 'A', '02' : 'B', '03' : 'C', '04' : 'D' }) ''' Series 인스턴스 생성 끝 ''' 딕_member = {'성별' : 성별시리즈, '이름' : 이름시리즈} ourmember = pd.DataFrame(딕_member) # DataFrame 생성 print(ourmember) | 출력 결과 성별 이름 01 남 A 02 여 B 03 C 04 남 D |
| # 칼럼 이름을 딕셔너리의 키key로 사용, 각 키의 값value을 리스트로 나열하는 방법 import pandas as pd ourmember2 = pd.DataFrame({ 'membernom' : ['01', '02', '03', '04], '성별' : ['남', '여', ' ', '남'], '이름' : ['A', 'B', 'C', 'D'] }) print(ourmember2) | # Series 클래스 없이 DataFrame을 만든 모습 출력 결과 성별 이름 0 01 남 A 1 02 여 B 2 03 C 3 04 남 D # DataFrame 클래스에서 자동으로 인덱스를 자동으로 만들었다. |
| # Series 클래스 없이 DataFrame을 만들고 인덱스 칼럼을 추가 import pandas as pd ourmember2 = pd.DataFrame({ 'membernom' : ['01', '02', '03', '04', '05'], '성별' : ['남', '여', ' ', '남'], '이름' : ['A', 'B', 'C', 'D'] }) ourmember3 = ourmember2.set_index('membernom') # 인덱스 칼럼의 이름 추가 print(ourmember3) | 출력 결과 성별 이름 membernom 01 남 A 02 여 B 03 남 C 04 남 D # 인덱스인 것을 구분하기 위해 위와 같이 인덱스 칼럼의 이름 'membernom'은 한 칸 밑에 표현된다. # 묶여있는 Series 에서 값이 없어서 항목이 일치하지 않는 경우, 없는 값의 자리에 NaN (Not a Number : 해당 데이터가 존재하지 않는다) 는 표시가 나타난다. |
| # 칼럼 단위로 DataFrame의 자료를 부르는 방법 import panda as pd 성별시리즈 = pd. Series({ '01' : '남', '02' : '여', '03' : ' ', '04' : ' ' }) 이름시리즈 = pd.Series({ '01' : 'A', '02' : 'B', '03' : 'C', '04' : 'D' }) # Series 인스턴스 생성 딕_member = {'성별' : 성별시리즈, '이름' : 이름시리즈} ourmember = pd.DataFrame(딕_member) # DataFrame 생성 print(ourmember['성별']) # '성별'만 출력 | # '성별'만 출력 출력 결과 01 남 02 여 03 04 남 |
| # 여러 개의 칼럼을 리스트 형태로 전달해서 선택 출력하기 ... print(ourmember[['이름', '성별']] # 리스트 형태로 칼럼 이름 전달 | 출력 결과 이름 성별 01 A 남 02 B 여 03 C 04 D 남 |
| # 조건문 추가하기 ... print(ourmember[ourmember['성별'] == '남']) | 출력 결과 이름 성별 01 A 남 04 D 남 |
| loc[ ] : Location의 약자 / DataFrame 안의 저장된 값을 찾아서 변경 # 인덱스 값과 칼럼 이름을 적으면 값을 바꿀 수 있다. | (예) '03'의 이름을 'E'로 변경하는 코드 ourmember.loc['03']['이름'] = 'E' |
| iloc[ ] : Integer location의 약자 / 인덱스 값, 칼럼 이름 대신 숫자 입 # 바꾸고 싶은 자료의 위치를 위에서 몇 번째, 왼쪽에서 몇 번째 인지 숫자 두 개로 지정하여 값을 바꾼다. (순서는 0부터 시작한다.) | (예) ourmember.iloc[2][1] = 'E' |
| 엑셀에서 데이터 불러오기 | .csv : (Comma Separated Value / 쉼표로 구분된 값) # 메모장에서도 열수 있는 텍스트 파일 # 판다스에서는 xls와 xlsx 파일도 열고 닫을 수 있으나 CSV를 더 자주 이용한다. # 'memberlist.csv' 파일을 판다스에서 불러오기 ourmember = pd.read_csv('memberlist.csv', encoding = 'ANSI', index_col = 0, header = 0) ''' (파일 이름, 인코딩 방식 = ' ', 인덱스가 있는 칼럼의 순서, 칼럼의 이름이 있는 순서) ''' |
| 저장 환경 : (1) 윈도우 (2) 주피터 노트북 | 인코딩 방식 기본값 : (1) ANSI (2) UTF-8 |
| DataFrame 에 csv 파일 인스턴스 저장하는 방법 | ourmember.to_csv('memberlist.csv') |
| matplotlib | 데이터를 그래픽으로 표현하는 패키지 |
| numpy | 숫자을 주로 판다스보다 훨씬 빠른 처리 속도를 구현하는 패키지 |
게임 만들기
묵찌빠 게임 법칙
게임 참가자가 묵(바위), 찌(가위), 빠(보) 중 하나를 선택할 때 상대방도 동시에 묵, 찌, 빠 중 하나를 선택한다.
상대방이 동일한 패(묵, 찌, 빠 중)를 선택하면 게임 참가자 승리! 승부가 나지 않으면 계속해서 게임을 진행한다.
컴퓨터가 선택하는 순간에 사용자가 선택하기는 어렵기 때문에, 사용자가 이길 때까지 게임을 진행한다.
1단계 | 게임 화면과 동작 순서 설계
- 화면을 설계한다.
- 이벤트를 정한다.
- 예) 사용자가 오른쪽 세 개의 버튼 중 하나를 클릭
- 컴퓨터도 묵, 찌, 빠 중 하나를 랜덤으로 선택하고 왼쪽 칸에 표시
2단계 | 위젯의 기본형 이해
- 그래픽 요소 만들기
- 바탕이 될 윈도우 + 버튼, 글자 등 화면 속 요소
- tkinter 패키지 이용, '묵찌빠 게임'이라는 이름의 350×200px 빈 윈도우 바탕 생성
- import tkinter as tk # GUI 코딩을 위한 tkinter 패키지
- from random import * # 랜덤 변수 사용을 위한 random 패키지
- 게임화면 = tk.Tk( ) # 윈도우 만들기
- 게임화면.title('묵찌빠 게임') # 윈도우 타이틀 입력
- 게임화면.geometry("350×200") # 윈도우 크기 정의
# 묵찌빠 게임 코드에서는 메인 창 자체가 컨테이너 역할을 한다.
3단계 | 묵찌빠 게임 위젯 만들기
| 묵지빠 게임 | - | ㅁ | x | 50px | ||
| 컴퓨터 레이블1 | 나 레이블2 | |||||
| - 레이블3 | vs 레이블4 | 묵 버튼1 | 150px | 200px | ||
| 찌 버튼2 | ||||||
| 빠 버튼3 | ||||||
| 150px | 50px | 150px | ||||
| 350px | ||||||
- 레이블1 = tk.Label(master = 게임화면, text = '컴퓨터', font = ('Arial', 15))
- 레이블1.place(x = 0, y = 0, width = 150, height =50)
- 레이블2 = tk.Label(master = 게임화면, text = '나', font = ('Arial', 15))
- 레이블2.place(x = 200, y = 0, width = 150, heigh = 50)
- 레이블3 = tk.Label(master = 게임화면, text = '-', font = ('Arial, 30))
- 레이블3.place(x = 0, y = 50, width = 150, heigh =150)
- 레이블4 = tk.Label(master = 게임화면, text = 'vs', font = ('Arial', 20))
- 레이블4.place(x = 150, y = 50, width =50, heigh = 150)
- 버튼1 = tk.Button(master = 게임화면, text = '묵', font = ('Arial', 10))
- 버튼1.place(x = 200, y = 50, width = 150, heigh = 50)
- 버튼2 = tk.Button(master = 게임화면, text = '찌', font = ('Arial', 10))
- 버튼2.place(x = 200, y = 100, width = 150, height = 50)
- 버튼3 = tk.Button(master = 게임화면, text = '빠', font = ('Arial', 10))
- 버튼3.place(x = 200, y = 150, width = 150, height = 50)
4단계 | 이벤트 함수 연결
- 버튼 3개 중 하나를 클릭했을 때, 컴퓨터의 선택이 랜덤으로 정해지고 이것을 화면(레이블3)에 표현
- 사용자의 선택을 전달, 사용자의 선택 = 컴퓨터의 선택 의 경우, 사용자의 승리라는 메시지 표시
- 메시지를 띄울 때 '메시지 박스'라는 알림 창 사용
[메시지 박스 알림 창 자료 : 출처 아래 링크]
http://docs.python.org
3.11.3 Documentation
Python 3.11.3 documentation Welcome! This is the official documentation for Python 3.11.3. Parts of the documentation: What's new in Python 3.11? or all "What's new" documents since 2.0 Tutorial start here Library Reference keep this under your pillow Lang
docs.python.org
알림창 표시 | tkinter 안에 있는 messagebox 클래스를 별도로 호출 한다.
- from tkinter import messagebox as mb
- mb.showinfo(title = '결과', message = '당신이 이겼습니다!')
| 결과 |
| 당신이 이겼습니다! |
| 확인 |
4. 컴퓨터와 사용자의 선택이 같은 경우, 사용자의 승리를 알리고, 컴퓨터의 선택을 초기화
5. config 메서드 사용, 랜덤으로 선택된 1('묵'), 2('찌'), 3('빠') 중에서 랜덤의 결과를 '레이블3'의 값으로 변경 : 위젯 클래스 생성자 변경
6. global과 함께 변수 이름을 입력, 호출 : 함수 밖에서 이미 선언된 '레이블3' 변수를 호출
7. 각 버튼의 생성자에 들어가는 command 변수에 '컴퓨터선택( )' 함수를 입력
| 전체 코드 |
- import tkinter as tk
- from random import *
- 게임화면 = tk.Tk( )
- 게임화면.title('묵찌빠 게임')
- 게임화면.geometry("350×200")
# 윈도우 준비
- 레이블1 = tk.Label(master = 게임화면, text = '컴퓨터', font = ('Arial', 15))
- 레이블1.place(x = 0, y = 0, width = 150, heigh = 50)
- 레이블2 = tk.Label(master = 게임화면, text = '나', font = ('Arial', 15))
- 레이블2.place(x = 200, y = 0, width = 150, height = 50)
- 레이블3 = tk.Label(master = 게임화면, text = '-', font = ('Arial', 30))
- 레이블3.place(x = 0, y = 50, width = 150, height = 150)
- 레이블4 = tk.Label(master = 게임화면, text = 'vs', font = ('Arial', 20))
- 레이블4.place(x = 150, y = 50, width = 50, height = 150)
- 버튼1 = tk.Button(master = 게임화면, text = '묵', font = ('Arial', 10), command = lambda:컴퓨터선택(1))
- 버튼1.place(x = 200, y = 50, width = 150, height = 50)
- 버튼2 = tk.Button(master = 게임화면, text = '찌', font = ('Arial', 10), command = lambda:컴퓨터선택(2))
- 버튼2.place(x = 200, y = 100, width = 150, height = 50)
- 버튼3 = tk.Button(master = 게임화면, text = '빠', font = ('Arial', 10), command = lambda:컴퓨터선택(3))
- 버튼3.place(x = 200, y = 150, width = 150, height = 50)
- from tkinter import messagebox as mb
- def 컴퓨터선택(사용자의선택): # '컴퓨터선택( )' 메서드
- global 레이블3
- 묵찌빠 = {1 : '묵', 2 : '찌', 3 : '빠'}
- 컴퓨터의선택 = randint(1, 3)
- 레이블3.config(text = 묵찌빠[컴퓨터의선택])
- if 컴퓨터의선택 == 사용자의선택:
- mb.showinfo(title = '결과', message = '당신이 이겼습니다!')
- 레이블3.config(text = '-')
- 게임화면.mainloop( )
5단계 | 최종 매듭 짓기
게임화면.mainloop( )
사용자가 입력할 때까지 계속 순환하면서 대기하게 만드는 명령어 mainloop( )
이 코드가 있어야만 tkinter의 GUI 가 실행된다.
6단계 | 게임 결과 확인하기
코딩 실습 준비
1. 웹사이트 접속 : 구글 크롬 > OnlineGDB 접속 > 우측 상단 [Language]에서 Python 선택
2. 검은 화면에 초록색 글자를 지우기 > 비어진 화면에서 코딩 연습 하기 > print ('내용') 이라고 쓰고 [Run] 버튼 클릭
사이트 주소 : onlinegdb.com 혹은 repl.it 이 있다. [Run] 또는 [Execute] 로 출력한다.
반응형
'문화 기록' 카테고리의 다른 글
| 서울 식물원 | 카카두 (2) | 2024.02.10 |
|---|---|
| 도서관 in 제주 | 제주 어린이 도서관, ‘별이 내리는 숲’ (0) | 2022.03.10 |
| 제주 산책 | 에코랜드 (0) | 2022.01.01 |
| 언박싱 | 모나미 153 독도 (DOKDO) 에디션 (0) | 2021.12.27 |
| 제주 산책 | 새별오름 (0) | 2021.12.20 |