Python 입문

파이썬

1. 파이썬이란? 
• 1991년 프로그래머 귀도 반로섬이 발표한 고급 프로그래밍 언어로 플랫폼에 독립적인 인터프리터식, 객체지향적, 동적 타이핑 대화형 언어이다. 
2. 파이썬의 특징
• 가독성 - 간결하고 가독성이 좋으며, 코드블럭을 들여쓰기로 구분
• 풍부한 라이브러리 - 광범위한 라이브러리가 기본 포함되어있고, 외부 라이브러리가 풍부하며 확장이 쉬움
• 접착성 - 쉽게 라이브러리 추가 가능
• 유니코드 - 문자열은 모두 유니코드로 되어 있어 나라별 언어코드 변경을 신경쓰지 않아도 됨
• 동적타이핑 - 런타임 시에 타입 체크를 하는 동적타이핑을 지원하고 메모리 관리를 자동으로 함
3. 파이썬 설치 방법
• 파이썬 홈페이지(http://python.org/download)
• 맥에서 파이썬 설치 방법 (https://medium.com/@psychet_learn/python-기초-2장-python-설치-및-환경설정-mac-os-x-ver-9e7e6d46eb2c)
4. 파이썬 2.x, 3.x 차이 정리
• 링크 : 파이썬 2.x, 3.x 차이
5. 파이썬 자료형과 연산자
1. 수치
1. Int - 정수형 숫자이며, 기본은 10진법을 따르고 숫자 앞에 코드명에 따라서 2진법, 8진법, 16진법이 가능
2. Float - 실수형 숫자
3. Complex - 복소수
4. 연산자 : +, -, *, /, %, =, **(지수승), // (정수 나눗셈)
2. 문자
1. 작은 따옴표, 큰 따옴표를 이용하여 문자를 표시
2. 입력한 문자를 그대로 사용 시에는  """, """ 로 실행
3. Escape 문자
1. \n : 개행(줄바꿈)
2. \t : 탭
3. \r : 캐리지 리턴
4. \0 : 널(Null)
5. \\ : 문자 \
6. \' : 단일 인용부호(작은 따옴표)
7. \" : 이중인용 부호(큰 따옴표)
4. 연산자 : +(생략가능), *(입력문자를 몇 번 반복할 때 사용)
5. 인덱싱과 슬라이싱
1. 인덱싱 : 문자형에서 입력된 문자의 특정 문자가 몇 번쨰 위치하는지 표시
2. 슬라이싱 : 문자형에서 입력된 문자를 얼마나 표시할지 또는 뒤에서 몇번쨰 위치부터 출력할지 등을 결정
3. 리스트
1. 값들의 나열로 문자처럼 인덱싱과 슬라이싱이 가능
2. [] 안에 값들을 나열
3. 연산자: append(뒤에 이어서 삽입), insert(특정 위치에 삽입), extend(특정 리스트를 뒤에 이어서 삽입), +, count(리스트 값 개수), pop(끝 값출력 후 삭제), remove(삭제), sort(정렬)
4. 세트
1. 집합과 동일
2. {} 안에 값들을 나열
3. 연산자 : 리스트에서 지원하는 연산자에 intersection(교집합), union(합집합)
5. 튜플
1. 리스트와 유사하나 읽기 전용
2. () 안에 값들을 나열
3. 읽기 전용이라 제공되는 함수는 리스트에 비해 적지만 속도는 빠르다.
4. 연산자 : count, index
6. 딕셔너리
1. 키와 값의 쌍으로 이루어짐
2. 표시는 키 : 값 형태로 저장
3. 인덱스는 지원하지 않음
4. 연산자 : items(키와 값 반환), keys(키만 반환), values(값만 반환), del(특정 키와 그 값을 삭제), clear(저장된 딕셔너리 키와 값 모두 삭제)
7. 부울
1. 참과 거짓을 나타냄
2. True, False만 있음
3. 별도의 연산자 없이 논리연산이나 비교연산의 결과로 사용
8. 변수에 대한 자료형 확인
1. type() 함수로 현재 변수의 자료형을 확인
2. 사용법 : type(<변수>) -> 변수에 대한 자료형을 <class '자료형'>의 형태로 보여줌
6. 얕은 복사와 깊은 복사
1. 얕은 복사 - 주소가 복사되어 객체를 공유하는 경우로 원본이나 복사본 둘 중에 하나만 바뀌어도 모두 바뀜
   예) a = [1,2,3]이고, a = b로 설정하여 얕은 복사를 실행한 상태에서 a[0] = 40을 넣어 결과를 확인하면 a = [40, 2, 3], b = [40, 2, 3]으로 모두 바뀜
2. 깊은 복사 - 객체를 공유하지 않는 경우로 원본이나 복사본 둘 중에 하나만 바뀌면 바꾼 대상만 변경되고, 나머지는 이전 상태를 유지
   예) a = [1,2,3]이고, b = a[:]로 설정하여 깊은 복사를 실행한 상태에서 a[0] = 40을 넣어 결과를 확인하면 a = [40, 2, 3], b = [1, 2, 3]으로 바꾼 쪽만 변경
7. 함수
1. 정의 : 여러 개의 문장을 하나로 묶어주어 한 번 혹은 여러 번 호출하여 프로그램을 구조적, 논리적으로 만들어 준다.
2. 함수 선언 방법
   def<함수명>(인수1, 인수2, ... 인수N):
    <구문>
    return <반환값>
3. 함수 선언 시에는 시작과 끝을 명시하진 않지만 반드시 들여쓰기로 구분해주어야 한다.
4. 스코핑 룰(Scoping rule)
1. 이름 공간(Name Space)
1. 변수의 이름이 저장되어 있는 장소
2. 함수 내부의 이름 공간, 지역 영역(Local scope)
3. 함수 밖의 영역, 전역 영역(Global scope)
4. 파이썬 자체에서 정의한 내용에 대한 영역, 내장 영역(Built-in scope)
2. LGB 규칙
1. 지역 영역(Local scope) -> 전역영역(Global scope) -> 내장영역(Built-in scope)
2. 만약 지역 영역에서 전역영역의 이름을 접근 시 global 키워드를 사용
5. 인수모드
1. 인수를 지정하지 않아도 기본 값이 할당
   >>> def Times(a = 10, b = 20) :
           return a*b
   >>> Times() => 200이 출력
2. 변수의 이름으로 특정 인수를 전달
   >> def connectURL(server, port) :
              str = "http://"+server+":"+port
              return str
   >>> connectURL(port="8080",server="test.com")이 가능
3. 인수의 개수가 정해지지 않은 가변 인수를 전달
   >>> def union2(*ar):...
4. 정의되지 않은 인수를 딕셔너리(key, value) 형식으로 전달
   >>> def userURIBuilder(server, port, **user):...
6. 람다(Lambda)함수
1. 이름이 없는 1줄 짜리 함수
2. 형식 : Lambda 인수 : <구문> -> lambda x, y : x + y
3. 프로그램의 가독성을 위해서 사용
7. 재귀적 함수 호출
1. 함수 내부에서 자기 자신을 계속 호출하는 방법
2. 변수를 조금씩 변경 하면서 연속적으로 반복된 연산 시 사용
8. Pass 구문
1. 아무일도 하지 않음
2. 형식
   >>> def sample():
                pass
9. __doc__속성과 Help 함수
1. Help 함수로 함수에 대한 설명을 볼 수 있다.
2. 더 자세한 설명을 추가하려면 __doc__속성을 이용
3. 형식 : 함수명.__doc__ = "함수에 대한 설명"
10. 이터레이터(Iterater)
1. 순회 가능한 객체의 요소를 순서대로 접근하게 하는 객체
2. 내부 반복문을 관리
3. 호출 방법 : iter(순회 가능 객체)
4. next 함수를 이용하여 순회 가능 객체의 요소를 하나씩 접근
11. 제너레이터(Generator)
1. 함수 마지막에 return 대신 yield로 함수 객체를 유지한 상태에서 값을 호출자에 넘겨줌
2. 함수의 상태를 그대로 유지하고 다시 호출해서 순회가능한 객체를 만들 떄 매우 편리
3. 생성방법
   >>> def copy(data):
                for index in range(1,len(data)-1):
                     yield data[index]
8. 제어문
1. 파이썬은 기본적으로 순차적으로 실행
2. 제어문을 이용하여 특정 조건일 때 실행하지 않도록 하거나 여러번 반복해야할 작업을 간단히 표현할 수 있도록 함
3. IF 문
1. 조건식을 평가하고 참인 경우만 구문이 수행
2. 2개 이상의 구문은 들여쓰기로 블록을 지정
1. 형식 if <조건식>:
3. 2개 이상의 조건을 처리하는 경우는 elif 구문을 사용
1. 형식
   if <조건식1>:
     <구문1>
   elif <조건식2>:
     <구문2>
   else:
     <구문3>
4. 단축평가
1. 정의 : 조건식 전체를 판단하지 않고 순차적으로 진행 중에 식 전체가 자명한 경우, 더 이상 평가를 하지 않는 방법
2. A and B 조건의 경우 A 조건이 거짓이면 B 조건이 참일지라도 전체 조건이 거짓이라 B 조건을 평가하지 않음
3. A or B 조건의 경우 A 조건이 참이면 B 조건이 참, 거짓에 상관없이 전체 조건이 참이라 B 조건을 평가하지 않음
5. 반복문
1. While 문
1. 형식
   while<조건식>:
     <구문>
2. 조건식이 참인 동안은 내부 구문을 반복해서 수행
3. 조건식이 거짓이면 While 문 구조를 벗어남
4. 조건식이 항상 참이 나와서 무한 루프에 빠지지 않도록 주의가 필요하다.
2. For 문
1. 형식
   for<아이템 I> in <시퀀스형 객체 S>:
     <구문>
2. 시퀀스형 객체(문자열, 리스트, 튜플, 딕셔너리, 이터레이터 등)를 순차적으로 순회
3. 시퀀스형 객체 S의 각 아이템을 아이템 I 에 할당
4. 모든 아이템을 순회하거나 break 문을 만나면 for문 종료
6.  리스트 내장
1. 기존 시퀀스 객체를 이용하여 추가적인 연산으로 새로운 시퀀스 객체를 생성
2. 형식 : [<표현식> for<아이템> in <시퀀스 객체> (if<조건식>)]
7. Filter
1. 함수의 결과 값이 참인 시퀀스 객체의 이터레이터를 반환
2. 형식 : filter(<function>|None, 시퀀스 객체)
8. Range
1. 수열을 순회하는 이터레이터 객체를 반환
2. 형식 : range('시작값','종료값'[, '증가값'])
9. Map
1. 시퀀스 객체를 순회하면 fuction의 연산을 수행
2. 형식 : map(<function>, 시퀀스 객체1 , 시퀀스 객체2, ...)
3. 시퀀스 객체 중에서 가장 갯수가 작은 시퀀스 객체에 맞추어서 fuction에 대한 연산
4. 시퀀스 객체1, 시퀀스 객체2 에 대해서 Map 연산으로 매칭되는 값을 더할 경우, 시퀀스 객체1은 2개, 시퀀스 객체2가 4개일 경우, 연산의 결과는 2개까지만 나옴
9. 클래스
1. 정의 : 데이터와 데이터를 변형하는 함수를 같은 공간으로 작성
2. 특징 : 메서드(Method), 인스턴스(Instance), 정보 은닉(Information Hiding), 추상화(Abstraction)
3. 생성자와 소멸자
1. 생성자
1. 정의 : 클래스 생성 시 초기화 작업을 수행
2. 형식 : __init__()
2. 소멸자
1. 정의 : 소멸 시 종료 작업을 수행
2. 형식 : __del__()
4. 상속
1. 부모 클래스의 모든 속성(데이터, 메소드)를 자식 클래스로 물려줌
2. 클래스의 공통된 속성을 부모 클래스에 정의
   예) 삼각형 클래스, 사각형 클래스 -> 부모 클래스 : 도형 클래스에서 삼각형 클래스, 사각형 클래스 의 공통된 데이터, 메소드를 정의 후 자식 클래스인 삼각형 클래스, 사각형 클래스에서 상속받아서 사용
3. 하위 클래스에서는 각 하위 클래스에 대한 특화된 메소드와 데이터를 정의
4. 다중 상속
1. 2개 이상의 클래스를 상속받아서 사용 (자바에서는 단일 상속만 가능하나 인터페이스를 이용하여 다중 상속 가능)
2. 상속 받은 클래스에 모든 속성(데이터, 메소드)를 전달 받아서 사용 가능
10. 모듈
1. 정의 : 여러 코드를 한 데 묶어서 다른 곳에서도 사용할 수 있도록 함
2. 장점
1. 코드의 재 사용성
2. 코드릴 이름공간으로 구분하고 관리 할 수 있음
3. 복잡하고 어려운 기능을 포함하는 프로그램을 간단하게 만들 수 있음
3. 사용 방법
1. import <모듈> : 기본적인 임포트 방법
2. from <모듈> import <어트리뷰트>
3. from <모듈> import * : 모듈 전체를 사용
4. import <모듈> as <별칭> : 모듈 이름이 길 때 별칭을 주어서 사용
4. 모듈의 경로
1. 모듈 임포트 시 모듈의 위치는 sys.path에 저장된 디렉토리를 검색
2. 모듈 경로 밖의 모듈은 임포트 할 수 없음
3. 모듈 경로 탐색 순서
1. 프로그램이 실행된 디렉터리
2. PYTHOBPATH 환결 변수에 등록된 위치
3. 표준 라이브러리 디렉터리
5. 패키지
1. 정의 : 모듈의 모음
2. 생성 방법
1. 패키지명으로 할 디렉토리를 만들어서 포함할 모듈들을 디렉토리에 넣음
2. 접근은 import 디렉토리.모듈 또는 from 디렉토리 import 모듈
3. 예) 모듈1.py, 모듈2.py 가 packagetest 폴더에 있을 때 모듈1 접근 방법
1.  import packagetest.모듈1
2. from packagetest import 모듈1 로 접근
3. 패키지는 모듈 파일을 가지고 있는 디렉토리
4. 참고 사이트 : https://wikidocs.net/1418
6. 외부 모듈 설치 방법
1. 파이썬에서 제공하는 기본 모듈을 이외에 확장하여 외부에서 개발된 모듈을 설치해서 사용 가능
2. 설치 명령어 : pip install 외부 모듈명
11. 예외 처리
1. 정의 : 프로그램의 제어 흐름을 조정하기 위해 사용하는 이벤트로 프로그램 작동 중에 이상현상 발생 시 처리하는 것을 의미
2. 종류 : 선언하지 않은 변수를 호출 시 발생, 0으로 나누는 연산 실행, 리스트에 접근 가능한 인덱스를 넘김, 지원하지 않는 연산 수행 등 
3. 처리 방법
1. try - except
   

   try:   <예외 발생 가능성이 있는 문장> except: <예외종류>:   <예외 처리 문장> except: (예외1,예외2):   <예외 처리 문장> except: <예외종류> as 인자:   <예외 처리 문장>

2. try ~ except ~ else ~ finally
   

   try:   <예외 발생 가능성이 있는 문장> except: <예외종류>:   <예외 처리 문장> except: (예외1,예외2):   <예외 처리 문장> except: <예외종류> as 인자:   <예외 처리 문장> else:   <예외가 발생하지 않은 경우, 수행할 문장> finally:   <예외 발생 유무에 상관없이 try 블록 이후 수행할 문장>

3. raise [Exception(data)]
   

   raise <발생 시킬 에러 명시> 예) raise NameError

4. assert <조건식>, <관련 데이터>
   

   assert <조건식>, <조건식이 만족하지 않을 떄, 관련 데이터>

5. sys.exc_info() 이용
   

   exc, value, tb = sys.exc_info() print(exc, value, tb) -> exc (어떤 에러인지), value(에러 발생 값), tb(Traceback ~) traceback.print_exc()

   
   
4. 예외 처리 시에 좁은 범위에서 넓은 범위로 확인하도록 함
12. 입출력
1. 화면 입출력
1. 출력
1. 화면으로 사용자가 원하는 내용을 나타냄
2. 사용 인자/함수 : print
1. 2.x 버전 : print "출력할 내용" 으로 인자로 사용
2. 3.x 버전 : print("출력할 내용") 으로 함수로 사용
3. print만으로 출력할 때 불편하여 format() 함수를 지원
1. "apple is red"를 출력하는 방법
2. 기본 사용법 : print("{0} is {1}".format("apple", "red"))
3. dictionary를 입력으로 사용
1. print("{item} is {color}".format(item="apple", color="red"))
2. dic = {"item":"apple", "color":"red"}
   print("{0[item]} is {0[color]}".format(dic))
3. dic = {"item":"apple", "color":"red"}
   print("{item} is {color}".format(**dic))
2. 입력
1. 화면으로 사용자가 원하는 내용을 넣고 싶을 때 사용
2. 사용 함수 : input() 함수
3. 사용법 : <저장할 변수> = input("입력인자로 화면에 출력할 프롬프트")
2. 파일 입출력
1. 파일 입출력 시에 세밀한 제어를 위해서 open() 함수로 파일을 열고, 파일 전용 함수들을 이용해서 작업
2. 기본형 : 파일객체 = open(file 경로, mode)
3. open() 함수에 마지막 인자인 Mode 속성
1. r : 읽기 모드(디폴트)
2. w : 쓰기 모드
3. a : 쓰기 + 이어쓰기 모드
4. + : 읽기 + 쓰기 모드
5. b : 바이너리 모드
6. t : 텍스트 모드(디폴트)
4. 출력
1. 파일에 저장되어 있는 내용을 화면에 나타냄
2. 사용 함수
1. read() 함수 : 파일에 입력된 내용을 문자열로 반환
2. readline() 함수 : 파일에 입력된 내용을 한 줄씩 문자열로 반환 
3. readlines() 함수 : 파일의 모든 내용을 줄 단위로 잘라서 리스트를 반환
4. tell() 함수 : 현재 파일에서 어디까지 읽고 썼는지 위치를 반환
5. seek() 함수 : 사용자가 원하는 위치로 파일 포인터를 이동
5. 입력
1. 사용자가 입력한 내용을 파일에 저장
2. 사용 함수 : write() 함수
3. 사용법 : open() 함수에서 Mode를 쓰기 모드인 "w"로 설정 후에 write("파일에 쓸 내용") 으로 파일에 저장
6. close() 함수
1. 파일을 open() 함수로 열어서 입력 또는 출력을 한 후에는 반드시 파일을 닫는 close() 함수를 사용하도록 함
7. with ~ as 구문
1. 파일을 open() 함수로 열고 파일을 닫아주는 close() 함수를 한 쌍으로 사용해야 하지만, with ~ as 를 통해서 open() 함수로 열고 따로 close() 함수를 호출하지 않아도 자동으로 close() 함수를 호출한 효과를 내는 구문
2. 사용법 : with open() as 파일 객체 이름:
3. 구문이 끝나면 바로 close() 함수를 호출한 효과를 냄
13. 문자열
1. 정의 : 문자열을 다루는 기본 클래스로 특별한 모듈을 import할 필요 없는 내장 클래스
2. 문자열 함수 종류
1. 문자의 대소문자 변경 함수
1. capitalize()
1. 가장 첫 글자만 대문자로 변경하고 나머지는 소문자로 변경
2. "python".capitalize() -> "Python"
2. lower()
1. 문자열 중에 알파벳 문자가 있는 경우 모두 소문자로 변경
2. "PYthon".lower() -> "python"
3. swapcase()
1. 문자열 중에 대문자가 있다면 소문자로 소문자가 있다면 대문자로 변경
2. "PyThOn Is PoWeRfUl".swapcase() -> "pYtHoN iS pOwErFuL"
4. title()
1. 문자열 중에 첫 글자 또는 스페이스나 개행, 탭 이후의 첫 글자를 모두 대문자로 변경하고 나머지는 소문자로 변경
2. "python is powerful".title() -> "Python Is Powerful"
5. upper()
1. 문자열 중에 알파벳 문자가 있는 경우 모두 대문자로 변경
2. "PYthon".upper() -> "PYTHON"
2. 문자열의 특정 문자의 개수를 파악하는 함수
1. count(keyword, [start [,end]])
1. keyword에 있는 문자가 몇 번 나오는지 횟수를 반환
2. "python is powerful".count('p') -> 2 ('p' 가 두 번 나옴)
3. 문자열의 인코딩 변환 함수
1. encode([encoding, [errors])
1. 입력된 문자의 인코딩을 변경하고, 에러가 발생하면 그 에러를 어떻게 표현하는지 나타냄
2. "가나다".encode('cp949') -> b'\xb0\xa1\xb3\xaa\xb4\xd9' -> cp949 인코딩으로 변환
4. 문자열 내에 특정 문자가 있는지 확인 함수
1. endswith(postfix, [start [,end]])
1. postfix가 문자열 끝에 포함되어 있으면, True 반환하고, 없으면 False 반환
2. "python is powerful".endswith('ful') -> True
2. isalnum()
1. 전체 문자열이 알파벳, 숫자만 있는지 확인
2. "python3000".isalnum() -> True
3. "python 3.2".isalnum() -> False
3. isalpha()
1. 전체 문자열이 알파벳만 있는지 확인
2. "python".isalpha() -> True
3. "python3000".isalpha() -> False
4. islower()
1. 전체 문자열이 소문자인지 확인
2. "python3.2".islower() -> True
3. "Python".islower -> False
5. isspace()
1. 전체 문자열 스페이스 문자인지 확인
2. "python ".isspace() -> True
3. "python".isspace() -> False
6. istitle()
1. 문자열 내에 문자가 가장 처음 또는 띄어쓰기 후 처음 나오는 문자가 대문자이고 나머지는 소문자인 타이틀 형식을 따르는지 확인
2. "Python Is Powerful".istitle() -> True
3. "python is powerful".istitle() -> False
7. isupper()
1. 전체 문자열이 대문자인지 확인
2. "PYTHON3.2".isupper() -> True
3. "Python".isupper() -> False
8. isdecimal(), isdigit(), isnumeric()
1. 전체 문자열이 숫자만 있는지 확인
2. "2580".isdecimal() or "2580".isdigit() -> True
3. "\u00bc".isdecimal() -> False ("\u00bc"는 1/4를 유니코드로 나타내며, 문자가 포함되어 False)
4. "\u00bc".isnumeric() -> True
9. startswith(prefix [, start [,end]])
1. prestfix가 문자열 처음에 포함되어 있으면, True 반환하고, 없으면 False 반환
2. "python is powerful".startswith('py') -> True
5. 문자열 내에 특정 문자 삽입하거나 제거하는 함수
1. expandtabs([tabsize])
1. 문자열 내에 '\t' 문자가 있으면 나타내지 않음
2. "python\tis\tpowerful".expandtabs() -> "python is powerful"
2. join(sequence)
1. 문자열 내에 문자 사이에 sequence를 입력할 때 사용
2. ".".join("HOT") -> H.O.T
3. lstrip([chars])
1. 문자열 내에서 왼쪽에 chars 를 제거, 빈 값인 경우 스페이스나 개행 문자 등을 제거
2. "\t python".lstrip() -> "python"
3. ">>> python".lstrip("> ") -> "python"
4. maketrans(x [, y [,z]])
1. 문자열 내에 x 가 발견되면 y 로 변경하고, z 가 발견되면 제거하며 translate() 함수 내에 인자로 사용
2. "python is powerful".translate(str.maketrans("po", "P0") -> "Pyth0n is P0werful" ('p' 문자는 'P'로, 'o' 문자는 '0' 로 매칭되어 변경)
5. replace(old, new, [count])
1. 문자열 내에서 old 의 문자가 검색되면 new 로 교체하며, count는 몇 번할지 횟수를 결정
2. "python is powerful".replace("p", "P", 1) -> "Python is powerful"
6. rstrip([chars])
1. 문자열 내에서 왼쪽의 chars 를 제거, 빈 값인 경우 스페이스나 개행 문자 등을 제거
2. "\t python".lstrip() -> "python"
3. ">>> python <<<".lstrip("< ") -> ">>> python"
7. strip([chars])
1. 문자열 내에서 chars 를 제거, lstrip() 함수와 rstrip() 함수를 합침
2. "\t python \t".strip() -> "python"
3. ">>> python <<<".strip("<> ") -> "python"
6. 문자열 내에 특정 문자의 위치를 확인하는 함수
1. find(keyword, [start [,end]])
1. 문자열 내에서 keyword가 어느 위치에서 처음에 나오는 위치 반환
2. "python is powerful".find('p') -> 0 ('p'가 처음 나온 위치는 가장 처음인 0)
3. 문자열 내에서 keyword 를 찾지 못하면 -1 값을 반환
2. index(keyword, [start [,end]])
1. 문자열 내에서 keyword가 어느 위치에서 처음에 나오는지 반환
2. "python is powerful".find('p') -> 0 ('p'가 처음 나온 위치는 가장 처음인 0)
3. 문자열 내에서 keyword 를 찾지 못하면 에러 발생
3. rfind(keyword, [start [, end]])
1. 문자열 내에서 keyword가 어느 위치에 있는지 끝에서부터 확인해서 처음에 나오는 위치 반환
2. "python is powerful".find('p') -> 10 ('p'가 끝에서 처음 나온 위치는 10)
3. 문자열 내에서 keyword 를 찾지 못하면 -1 값을 반환
4. rindex(keywork, [start [, end]])
1. 문자열 내에서 keyword가 어느 위치에 있는지 끝에서부터 확인해서 처음에 나오는 위치 반환
2. "python is powerful".find('p') -> 10 ('p'가 끝에서 처음 나온 위치는 10)
3. 문자열 내에서 keyword 를 찾지 못하면 에러 발생
7. 문자열을 나누는 함수
1. partition(seperator)
1. 문자열을 seperator 기준으로 쪼갬
2. "python is powerful".partition("is") -> ("python", "is", "powerful")
2. rpartition(seperator)
1. 문자열을 seperator 기준으로 쪼개는데 오른쪽부터 확인
2. "python is powerful".rpartition("p") -> "python is ", "p", "owerful")
3. rsplit([seperator [, maxsplit]])
1. 문자열 내에서 seperator 기준으로 쪼개는데 오른쪽부터 확인하며 seperator 값이 없다면 스페이스, 개행, 탭 문자로 쪼갬
2. "python is powerful".rsplit(' ', 1) -> ("python is", "powerful")
4. split([seperator [, maxsplit]])
1. 문자열 내에서 seperator 기준으로 쪼개는데 처음부터 확인하며 seperator 값이 없다면 스페이스, 개행, 탭 문자로 쪼갬
2. "python is powerful".split(' ', 1) -> ("python", "is powerful")
5. splitlines([keep])
1. 문자열 내에 개행 문자를 기준으로 쪼갬
2. "python\r\nis\npowerful".splitlinex() -> ["python", "is", "powerful"]
3. "python\r\nis\npowerful".splitlinex(True) -> ["python\r\n", "is\n", "powerful"]
14. 정규표현식
1. 정의 : 문자나 문자의 패턴을 나타내기 위한 특수 문자
2. 문법
   

   문법	의미
   .	개행 문자를 제외한 1자를 의미
   ^	문자열의 시작
   $	문자열의 종료
   []	문자의 집합
   |	OR
   ()	괄호 안의 정규식을 그룹으로 만듦
   *	문자가 0회 이상 반복
   +	문자가 1회 이상 반복
   ?	문자가 0 혹은 1회 반복
   {m}	문자가 m회 반복
   {m,n}	문자가 m회부터 n회까지 반복되는 모든 경우
   {m,}	문자가 m회부터 무한 반복되는 모든 경우

   
   
3. Escapse 문자열
   

   종류	설명
   \w	밑줄과 표현 가능한 문자 [a-zA-Z0-9_]
   \W	밑줄과 표현 가능한 문자를 제외한 나머지 문자 [^a-zA-Z0-9_]
   \d	0-9를 포함하는 모든 숫자 [0-9]
   \D	숫자를 제외한 모든 문자 [^0-9]
   \s	공백문자 [\t\n\r]
   \S	공백문자를 제외한 모든 문자 [^\t\n\r]
   \\	역슬래쉬(\) 문자 자체를 의미

   
   
15. 날짜 다루기
1. 컴퓨터에서 시간을 표현하는 방법
1. 타임스탬프(Time Stamp)
2. UTC(Universal Time Coordinated, 협정세계시)
3. 그리니치 평균시
4. LST(Local Standard Time, 지방표준시)
5. 일광절약 시간제(Daylight Saving Time, DTS)
2. 시간을 다루는 객체
1. struct_time 시퀀스 객체
1. 시간을 표현하는데 사용
2. tm_year : 년도 (1999, 2018, ...)
3. tm_mon : 월 (1 ~ 12)
4. tm_mday : 일 (1 ~ 31)
5. tm_hour : 시 (0 ~ 23)
6. tm_min : 분 (0 ~ 59)
7. tm_sec : 초 (0 ~ 61)
8. tm_wday : 요일 (0 ~ 7 이며, 월요일은 0으로 표현)
9. tm_yday : 누적날짜
2. time 모듈
1. 시간을 표현하는데 사용
2. time.time() : 1970년 1월 1일 자정 이후로 누적된 초를 float 단위로 반환
3. time.sleep(seconds) : 현재 동작 중인 프로세스를 주어진 초만큼 정지
4. time.gmtime([seconds]) : 입력된 초를 변환하여, UTC 기준의 struct_time 시퀀스 객체를 반환
5. time.localtime([seconds]) : 입력된 초를 변환하여, 지방표준시 기준의 struct_time 시퀀스 객체를 반환
6. time.asctime([t]) : struct_time 시퀀스 객체로 받아서 'Sun Mar 15 18:50:20 2009' 형태로 반환
7. time.mktime(t) : struct_time 시퀀스 객체로 받아서 누적된 초로 반환
3. strptime, strftime
1. 사용자가 직접 형식을 지정하여 출력
2. 사용법
1. strptime : time.strptime(string [, format])
2. strftime : time.strftime(format [. t]) t는 struct_time 시퀀스 객체
3. %y : 연도를 축약해서 표시 1999 -> 99
4. %Y : 연도를 축약하지 않고 표시 1999
5. %b : 축약된 월 이름 March -> Mar
6. %B : 축약되지 않은 월 이름
7. %m : 숫자로 표현한 월 (01 ~ 12)
8. %d : 일 (01 ~ 31)
9. %H : 24시를 기준으로 한 시 (00 ~ 23)
10. %l : 12시를 기준으로 한 시 (00 ~ 12)
11. %M : 분 (00 ~ 59)
12. %S : 초 (00 ~ 61)
13. %p : AM/PM
14. %a : 축약된 요일 이름 Friday -> Fri
15. %A : 축약되지 않은 요일 이름 Friday
16. %w : 요일을 숫자로 표시 (0 ~ 7, 월요일은 0)
17. %j : 1월 1일부터 누적된 날짜 (001 ~ 366)
4. datetime
1. 날짜, 시간 연산을 위해 사용
2. 주요 클래스
1. datetime.date : 일반적으로 사용하는 그레고리안 달력(Gregorian Calendar)의 년, 월, 일을 표현
1. data 클래스 생성자 : date(year, month, day)
2. datetime.time : 시간을 시, 분, 초, 마이크로 초, 시간대(Time zone)로 표현
1. time 클래스 생성자 : time(hour [, minute [, second [, microsecond [, time zone info]]]])
3. datetime.datetime : date 클래스와 time 클래스의 조합으로 구성
1. data 클래스 생성자 : date(year, month, day)
2. time 클래스 생성자 : time(hour [, minute [, second [, microsecond [, time zone info]]]])
4. datetime.timedelta : 두 날짜 혹은 시간 사이의 기간을 표현
1. timedelta 클래스 생성자 : timedelta([days [, seconds [, microseconds [, milliseconds [, minutes [, hours [, weeks]]]]]])
2. timedelta 클래스에 일, 시, 분, 초, 밀리 세컨드, 마이크로 세컨드, 주 단위로 지정 날짜의 이전/이후의 날짜를 계산할 때 사용
3. 2019-04-20 에 대해 5일 후를 알고 싶으면 timedelta(days=5)로 해서 더해주면 2019-04-20의 5일 후인 2019-04-25 출력
16. 숫자 다루기
1. 특별한 모듈 임포트 없이 사용 가능한 함수
1. sum(iterable [, start]) : 순회 가능한(iterable) 객체의 총 합계를 반환
2. max(iterable) : 순회 가능한 객체의 최대값을 반환
3. min(iterable) : 순회 가능한 객체의 최소값을 반환
4. abs(x) : x의 절대값을 반환 abs(-1) -> 1
5. pow(x, y [, z]) : x의 y 제곱 값을 반환
6. round(x, [, n]) : x의 반올림 결과를 반환
7. divmod(a, b) : 'a/b'의 몫과 나머지를 튜플 형태로 반환
2. math 클래스에서 사용 가능한 함수
1. 지수, 로그 연산
1. math.pow(x, y) : x의 y 제곱한 결과를 반환
2. math.sqrt(x) : x의 제곱근(square root)한 결과를 반환
3. math.exp(x) : 'e^x' 의 결과를 반환
4. math.log(x [, base]) : 밑을 base로 하는 log x의 결과를 반환
2. 삼각함수 연산
1. math.degrees(x) : 라디안으로 표현된 각도를 60분법으로 변환
2. math.radians(x) : 60분법으로 표현된 각도를 라디안으로 변환
3. math.sin(x) : x의 Sin 값을 반환
4. math.cos(x) : x의 Cos 값을 반환
5. math.tan(x) : x의 Tan 값을 반환
3. fraction 클래스로 분수 표현
1. 분수를 나타내는 모듈
1. 생성자
1. Fraction(분자 = 0, 분모 = 1) -> Fraction(1, 2)
2. Fraction(Fraction 객체) -> Fraction(3) -> Fraction(3, 1)
3. Fraction(문자열) -> Fraction('3.14') -> Fraction(157, 50)
4. random 클래스로 임의의 수를 표현
1. 여러가지 random 함수
1. random.seed([x]) : 임의 숫자 생성기의 초기화 작업을 함
2. random.random() : 0.0 <= F <= 1.0 사이의 임의의 float 숫자 F 반환
3. random.uniform(a, b) : a.0 <= F <= b.0 사이의 임의의 float 숫자 F 반환
4. random.randrange([start], stop [, step]) : 내장 함수인 range()의 아이템 중에서 임의로 선택하여 반환
5. random.randint(a, b) : a <= N <= b 임의의 정수 N 반환
6. random.choice(seq) : 입력받은 시퀸스 객체의 임의의 아이템 반환
7. random.shuffle(x [, random]) : 입력받은 시퀀스 객체를 섞음
17. 파일 시스템
1. 파일 경로에 대한 정보를 확인하는 모듈과 파일 경로 내에 존재하는 모든 파일에 대한 목록을 확인하는 모듈
2. os.path 모듈
1. 파일에 대해서 절대 경로 반환, 파일인지 디렉토리인지 확인 등에 대한 파일 경로에 대한 정보를 확인하는 모듈
2. 함수목록
1. abspath('기본 이름') : 절대 경로를 반환 -> abspath('tmp') : 'C:\\aaa\\tmp'
2. basename('경로') : 입력받은 경로의 기본 이름을 반환하며, 경로에 있는 파일을 확인하지 않음 -> basename('C:\\aaa\\tmp') : 'tmp'
3. dirname('경로') : 입력받은 파일/디렉토리를 포함하는 디렉토리 경로를 반환
4. exist('경로') : 입력받은 경로가 존재하는지 확인, 존재하면 True, 존재하지 않으면 False 반환
5. expanduser('경로') : 입력받은 경로 안에 '~'를 현재 사용자 디렉토리의 절대 경로로 대체하여 반환 -> expanduser('~\\test') : 'C:\\Users\\Administrator\\test'
6. expandvars('경로') : 입력받은 경로 안에 환경변수가 있다면 확인하여 반환 -> expandvar('$JAVA_HOME\\bin') : 'C:\\ProgramFiles(x64)\\java\\bin' 
7. 파일에 대한 수정, 생성, 접근 시간 관련 함수
1. getatime('경로') : 입력받은 경로에 최근 접근 시간을 반환
2. getmtime('경로') : 입력받은 경로에 최근 변경 시간을 반환
3. getctime('경로') : 입력받은 경로에 최근 생성 시간을 반환
8. getsize('경로') : 입력받은 경로에 대한 바이트 단위의 파일 크기를 반환
9. isabs('경로') : 입력받은 경로가 절대 경로면 True, 그외는 False 반환
10. isfile('경로') : 입력받은 경로가 파일이면 True, 그외는 False 반환
11. isdir('경로') : 입력받은 경로가 디렉토리면 True, 그외는 False 반환
12. join('경로 1' [, '경로 2' [, ...]]) : OS 형식에 맞게 입력받은 경로를 연결
1. join('C:\\abc', 'bbb', 'test.text') -> 'C:\\abc\\bbb\\test.text'
2. join('C:\\abc', 'D:\\aaa', 'test.text') -> 'D:\\aaa\\test.text'
13. normpath('경로') : 입력받은 경로를 정규화하는 함수로, 현재 경로를 나타내는 '.'이나 상위 경로인 '..'을 주로 처리
1. normpath('C\\aaa\\bbb\.\test.text') : 'C:\\aaa\\bbb\\test.text'
2. normpath('C\\aaa\\bbb\..\test.text') : 'C:\\aaa\\test.text'
14. 입력 받은 경로에 대해서 특정 부분을 나누는 함수
1. split('경로') : 디렉토리 부분과 파일 부분을 나눔
2. splitdrive('경로') : 드라이브 부분과 나머지 부분을 나눔
3. splitext('경로') : 확장자 부분과 그 외의 부분으로 나눔
3. glob 모듈
1. 경로에 대응되는 모든 파일 및 디렉토리의 리스트를 반환
2. glob.glob('경로') : 입력 받은 경로에 대응되는 모든 파일 및 디렉토리의 리스트를 반환
3. glob.iglob('경로') : 입력받은 경로에 대응되는 모든 파일 및 디렉토리의 이터레이터를 반환
18. 데이터베이스
1. 파이썬에서는 SQLite3을 지원하여 사용
1. SQLite3 ?
1. 디스크 기반의 가벼운 데이터베이스 라이브러리
2. 서버가 필요하지 않음
3. 모바일 디바이스(Android, IOS 등)에서 기본적으로 사용
2. SQLite3 모듈 함수
1. sqlite3.connect(database [timeout, isolation_level, detect_types, factory]) : SQLite3 DB에 연결
2. sqlite3.register_adapter(type, callable) : 파이썬 자료형을 SQLite3에서 사용하게 등록
3. sqlite3.register_converter(typename, callable) : SQLite3에 저장된 자료를 파이썬 자료형으로 변환하는 함수 등록
3. Connection 클래스
1. sqlite3.connect() 함수의 리턴된 객체
2. 함수
1. Connection.cursor() : Cursor 객체 생성
2. Connection.commit() : 현재 트랜젝션의 변경 내역을 DB에 반영
3. Connection.rollback() : 가장 최근의 commit() 이후 지금까지 작업한 내용에 대해서 되돌림
4. Connection.close() : DB 연결 종료, sqlite3.connect() 함수 사용 시 반드시 사용해야하는 함수
5. Connection.iterdrump() : 연결된 DB의 내용을 SQL 질의 형태로 출력
4. Cursor 클래스
1. Connection.cursor() 함수의 리턴된 객체
2. 함수
1. Cursor.execute(sql [, parameters]) : SQL 문장을 실행, Connection.execute(sql [, parameters]) 와 같이 사용가능
2. Cursor.executemany(sql, seq_of_parameters) : 동일한 SQL문장을 파라미터만 변경하며 수행, Connection.executemany(sql [, parameters]) 와 같이 사용 가능
3. Cursor.executescript(sql_script) : 세미콜론으로 구분된 연속된 SQL 문장 수행, Connection.executescript(sql_script) 와 같이 사용가능
4. Cursor.fetchone() : 조회된 결과로 부터 데이터 1개를 반환
5. Cursor.fetchmany([size=cursor.arraysize]) : 조회된 결과로부터 입력받은 size 만큼의 데이터를 리스트 형태로 반환
6. Cursor.fetchall() : 조회된 결과 모두를 리스트 형태로 반환
5. 사용방법
1. 데이터베이스 연결
1. 실제 파일을 이용 : con = sqlite3.connect("test.db")
2. 메모리를 이용 : con = sqlite3.connect(":memory:")
2. SQL 문 수행
1. Connection 클래스의 Connection.cursor()로 Cursor 클래스에 연결
2. Cursor.execute() 함수를 이용해서 SQL 문 수행 : cursor.execute("CREATE TABLE PhoneBook(index, Name, Phone Number);")
3. 레코드 조회
1. Cursor 클래스에서 직접 확인 : Cursor.execute("SELECT * FROM PhoneBook;")
2. Cursor 클래스에서 fetch() 함수를 이용해서 확인 : Cursor.execute("SELECT * FROM PhoneBook;")
   Cursor.fetchone()
4. 트랜젝션 처리
1. Cursor.execute() 함수로 연결된 DB 수정 이후에 Connect.commit() 함수로 연결된 DB에 수정한 내용을 반영해주어야 함
5. 자료형
1. SQLite3 자료형과 그에 대응하는 파이썬의 자료형
   

   SQLite3 자료형	파이썬 자료형
   NULL	None
   INTEGER	int
   REAL	float
   TEXT	str
   BLOB	buffer

   
   
19. 운영체제 관련 기능
1. os 모듈
1. 운영체제에서 제공되는 기능을 함수로 정의한 모듈
2. 임포트 방법 : from os import *
3. 함수
1. chdir(path) : 현재 작업 디렉토리에서 path 경로로 이동
2. getcwd() : 현재 작업 디렉토리의 위치 반환
3. access(path, mode) : path 경로의 파일 또는 디렉토리가 mode 로 설정한 작업이 가능하면 True 반환, 아니면 False 반환
1. mode : F_OK - path에 파일 또는 디렉토리가 있는지 확인
2. mode : R_OK - path에 파일 또는 디렉토리가 읽기 가능한지 확인
3. mode : W_OK - path에 파일 또는 디렉토리가 쓰기 가능한지 확인
4. mode : X_OK - path에 파일 또는 디렉토리가 실행 가능한지 확인
4. listdir(path) : path에 존재하는 파일과 디렉토리를 리스트로 반환
5. mkdir(path [, mode]) : path에 해당하는 디렉토리 생성
6. makedirs(path [, mode]) : 인자로 전달된 디렉토리를 재귀적으로 생성, makedirs('test1/test2/test3') 이면, test1 -> test2 -> test3 순으로 생성
7. remove(path), unlink(path) : path에 해당하는 파일를 삭제
8. rmdir(path) : path에 해당하는 디렉토리를 삭제
9. removedirs(path) : 디렉토리를 역순차적으로 삭제, removedirs('test1/test2/test3') 이면, test3 삭제 성공 -> test2 삭제 성공 -> test1 삭제
10. rename(src, dst) : src를 dst로 이름을 변경하거나 이동
11. utime(path, times) : path에 해당하는 파일에 대해서 액세스 시간과 수정 시간 등을 times로 수정
12. system(command) : command를 실행, 성공하면 0을 반환
2. sys 모듈
1. system에서 제공되는 기능을 함수로 정의한 모듈
2. 임포트 방법 : import sys
3. 함수
1. exc_info() : 현재 발생한 예외 정보를 튜플로 반환
2. exit([arg]) : 프로세스를 종료
4. 모듈
1. sys.path : 모듈을 찾을 떄 참조하는 경로를 나타냄
3. threading 모듈
1. thread 란? 프로세스 내에서 실행되는 흐름의 단위를 의미하며 하나의 프로세스 내에 여러 개의 Thread가 동작할 수 있으며, 프로세스 내에는 반드시 한 개 이상의 Thread 가 동작하고 있음
2. Thread 객체
1. Thread를 사용하기 위해서 정의하는 객체
2. 임포트 방법 : from threading import Thread
3. 함수
1. start() : Thread를 시작할 때 사용
2. run() : Thread의 주요 동작을 정의, Thread 동작 시 실행되는 부분
3. join([timeout]) : Thread가 종료되기를 기다림
3. Lock 객체
1. Thread 가 여러 개일 경우, 어느 Thread 가 먼저 실행되고 나중에 실행되는지 알 수 없어서 동작 전 Lock을 걸어 다른 Thread 가 동작하지 못하게 함
2. 임포트 방법 : from threading import Lock
3. 함수
1. acquire() : Locked 상태로 바뀜, 다른 Thread 가 실행하지 못하게 함
2. release() : Unlocked 상태로 바뀜, 다른 Thread 가 실행 가능

출처 : https://tacademy.skplanet.com/