1. 파이썬 종료
1) ctrl+d
2) ctrl+Z Enter
3)
import sys
sys.exit()
2. 사칙연산
1) + - * /
2.7 버전 이하는 실수 자동형변환 하지않음
a/(b*1.0)
2) 제곱 : x**y => x의 y제곱
3) 나머지 : %
4) 몫 : //
3. 변수
: 타입지정 없어도 가능.
: ';' 없음
print(변수) : 변수 출력
4. 조건문 if
if 조건문:
실행문
5. 반복문 for
for a in [1,2,3]:
a관련 실행문
6. 함수
def 함수명(매개변수1, ..):
실행문
return 반환값
7. 주석
1) 한줄 주석 : #
2) 여러줄 주석: """, '''
""", '''
8. 확장자
.py
9. 도스창 실행
cd 경로 설정
python 파일명.py
10. 숫자형
1) 정수
2) 실수
4.1E9
4.1E-9
4.1e-9
3) 8진수
0o
0O
4) 16진수
0x
0X
5) 복소수
a = 2+3j
2+3J
* real : 실수부 리턴
ex) a.real
* image : 허수부 리턴
ex) a.image
* conjugate() : 켤레 복소수 리턴
ex) a.conjugate()
* abc(복소수) : 복소수 절대값 리턴
ex) abs(a) -> 루트(실수부 제곱 + 허수부 제곱)
11. 문자열 : "", '', """ """, ''' ''',
1) 큰따옴표 출력 : '"', \"
2) 작은 따옴표 출력 : "'", \'
3) 줄바꾸기 : \n
4) 여러줄 문자열 출력
'''
''',
"""
""",
5) 문자열 더하기
문자열1+문자열2 =>문자열1문자열2
6) 문자열 곱하기
문자열*2 => 문자열문자열
7) 문자열 인덱싱
a="문자열"
a[index] : index번째 문자 추출. 0부터 시작
a[0] : 첫번째 문자
a[-1] : 마지막 문자
8) 문자열 슬라이싱
a="문자열"
a[index1:index2] : index1번째 문자부터 index2-1까지 문자열 추출.
a[0:4] : 0~3까지 문자열
a[index1:] : 끝문자까지
a[:index2] : 첫문자부터
a[:] : 전체문자
a[1] = 2 : error. 문자열을 바꿀수 없다.
9) formating
1)
"문자열%d" %숫자 =>"문자열숫자"
"문자열1%s" %"문자열2" =>"문자열1문자열2"
%d %s %c %f %o %x %%
"%2s" %a => " a"
"%-2s" %a => "a "
"%6.2f" %1.122 => " 1.12"
2)
"{0}{1}".format(a,b) => "ab"
"{0}{a}".format(c,a=1) => "c1"
"{0:<3}".format(a) => "a " 왼쪽 정렬 및 공백추가
"{0:>3}".format(a) => " a" 오른쪽 정렬 및 공백추가
"{0:^3}".format(a) => " a " 가운데 정렬 및 공백추가
"{0:=^3".format(a) => "=a=" 공백 =로 채우기
"{0:!^3".format(a) => "=a=" 공백 !로 채우기
"{0:6.2f}.format(1.23) => " 1.23"
"{{}}".format() => "{}"
10) 함수
a.count('b') # 문자열 a에서 'b' 문자 개수 리턴
a.find('b') => a문자열에서 처음 나온 'b'문자 위치 리턴. 0부터 시작. 없으면 -1 리턴
a.index('b') => a문자열에서 처음 나온 'b'문자 위치 리턴. 0부터 시작. 없으면 error
a.join('abcd') => a=.이면 'abcd'문자 사이에 . 포함하여 리턴. 'a.b.c.d'
a.upper() => a문자열 대문자로 변경하여 리턴.
a.lower() => a문자열 소문자로 변경하여 리턴.
a.lstrip() => a문자열에서 왼쪽 공백 제거하여 리턴.
a.rstrip() => a문자열에서 오른쪽 공백 제거하여 리턴.
a.strip() => a문자열에서 양쪽 공백 제거하여 리턴.
a.replace(바뀌게 될 문자열b, 바꿀 문자열c) => a문자열에 존재하는 b문자열을 c문자열로 변경하여 리턴.
a.split() => a문자열에 공백 기준으로 문자를 나눠 리스트로 반환. a="a b c" => a.split() => ['a','b','c']
a.split('기준문자') => a문자열에 '기준문자'를 기준으로 문자를 나눠 리스트로 반환. a="a;b;c" => a.split(';') => ['a','b','c']
12. 리스트(=배열)
1) a=[1,2,[3,4]]
2) a[index] : 인덱싱
a[0] => 1
a[-1] => [3,4]
a[-1][0] => [3]
3) 슬라이싱
a[2:5]
a[2][:3]
4) 연산
a=[1,2]
b=[3,4]
a+b=[1,2,3,4]
a*2=[1,2,1,2]
a[1]+"1" => Type error
str(a[1]) + "1"=> "21"
* str(a) => 정수 or 실수인 a를 형변환 하여 문자열로 변경한다.["1","2"]
5) 값 변경
a=[1,2,3]
a[1]=4 => a=[1,4,3]
a=[1,2,3]
a[1:2]=[4,5,6] => a=[1,4,5,6,3]
a=[1,2,3]
a[1]=[4,5,6] => a=[1,[4,5,6],3]
6) 값 삭제
a[1:2] = []
del a[1]
* del 객체 : 객체 삭제
7) 함수
a.append(b) : a의 마지막에 b 추가. a에 변경 값을 넣는다.
a=[1,2,3]
a.append(4) => a=[1,2,3,4]
a=[1,2,3]
a.append([4,5]) => a=[1,2,3,[4,5]]
a.sort() => a를 오름 차순 정렬하여 a에 변경 값을 넣는다.
a = sorted(a, reverse=True)
a.reverse() => a의 순서를 반대로 뒤집어 a에 변경 값을 넣는다.
a.index(3) => a의 3의 위치를 리턴. 0부터 시작. 값이 없으면 error 발생.
a.insert(b,c) => a의 b번째 위치에 c를 삽입하여 리턴.
a.remove(b) => a에서 첫번째 나오는 b 삭제하여 리턴.
a.pop() => a의 마지막 요소 리턴. 마지막 요소 삭제하여 그 값을 a에 넣는다.
a.pop(b) => a의 b위치의 값 리턴. b위치 값 삭제하여 그 값을 a에 넣는다.
a.count(b) => a에서 b 개수 리턴.
a.expend(리스트) => a에 리스트를 더한다.
13. 튜플 : 값 수정 불가. 시도시 error.
1) ()
(1,)
(1,2)
1,2,3
(1,2,(3,4))
2) 인덱싱, 슬라이싱, 더하기, 곱하기
14. 딕셔너리( = map) : 순서 없음
: 중복 시 하나를 제외한 나머지 무시. 어떤것이 될지 알수없음.
: key에 리스트 사용불가.
1) {'key':'value','key2':'value2'}
a={1:a,2:b}
a[3]=c => {1:a, 2:b, 3:c}
del a[3]
a[3] => c
a.key() => dict_keys([key1,key2]) => a에서 key만 추출하여 dict_keys객체 리턴.
a.value() => dict_values([key1,key2]) => a에서 key만 추출하여 dict_values객체 리턴.
list(dict_keys()) => 리스트로 변환
a.items() => dict_items([(key1:value2),(key2:value2)]) => a에서 key만 추출하여 dict_items객체 리턴.
a.clear()
a.get(key) => 없으면 none 리턴.
a.get(key,default) => 없으면 none 리턴.
key in a => 딕셔너리 안에 key값이 있는 지확인. true, false 리턴.
15. 집합(set) : 중복 허용 X, 순서 X, 인덱싱X
* set() : 집합 생성
set(list) => {1,2,3}
set("문자열") => {'문','자','열'}
* tuple() : 튜플로 변환.
1) 교집합 : s1&s2
s1.intersection(s2) : 교집합
2) 합집합 : s1|s2
* s1.union(s2) : 합집합
3) 차집합 : s1-s2
s1.difference(s2) : s1-s2
s1.add(4) : s1집합에 4를 추가.
s1.update([4,5,6]) : s1집합에 여러 값 추가.
s1.remove(4) : s1집합에 4 제거.
16. 객체 : 모든것
변수 : 메모리 위치, 레퍼런스
type(a) : 타입 반환
a is b : 동일한 객체인지 확인
17. 레퍼런스 카운트
import sys
sys.getrefcount(3)
a,b = ('c', 'd')
(a,b) = 'c', 'd'
[a,b] = ['c', 'd']
a,b = b,a
레퍼런스 카운트가 0이 되면 가비지 컬렉터가 객체 제거
b = a[:] # 다른객체
b = copy(a)
b is a # False
18. if
if 조건문:
elseif 실행문:
else:연산자
x or y
x and y
not x
x in s
x not in s
pass19. while
while 조건문:
실행문input()
raw_input()
#-*-coding:utf-8-*-
break
continue20. for
for 변수 in 리스트:
range(10) : 0 ~ 9
range(1, 10) : 1~10
len(a)
result = [num * 3 for num in a if num%2 ==0]21. 함수
def sum(a, b):
return a+b
return a,b # (a,b)
def sum(a, b = 1) # 맨마지막 자리만 가능
global a = 0
a = input("~")
print(,) # 띄어쓰기
print(i, end = ' ')
f = open("name.txt",'w') # 'r', 'a'
f.close
line = f.readline() # 첫줄 출력
lines = f.readlines() # 리스트 리턴
data = f.read() # 전체 내용
with open("a.txt", "w") as f:
f.write("")
22. 클래스
class Service:
def sum(self, a, b):
self.a = a
def __init__(self, name):
self.name = name
# 인스턴스 생성 시 실행
pey = Service('0')
매서드 오버라이딩 : 이름은 같으나 인자 타입이나 개수가 다른 함수를 생성
상속 : class 자식(부모):
연산자 오버로딩 : def __add__(self, other):
__sub__
__mul__
__truediv__
23. 모듈
import mod1
mod1.sum(1,2)
from mod1 import sum, div
sum(1,2)
from mod1 import*
if __name__ == "__main__" # import시 실행안됨
python mod1.py # 직접 실행시 실행됨
set PYTHONPATH = C:\Python\aa
24. 패키지
__init__.py : 해당 디렉터리가 패키지 일부임 알려줌
__all__ : __all__ = ['파일명']
from .. graphic.render import render_test
25. 예외처리
FileNotFoundError, ZeroDivisionError, IndexError
try:
except FileNotFoundError as e:
except FileNotFoundError, e:
finally:
f.close
else:
raise error명
26. 내장함수
abs(x) : x의 절대값
all(x) : 반복가능 x에 bool 리턴. 모두 참 T
any(x) : 반복가능 x에 bool 리턴. 모두 거짓 F
chr(i) : 아스키코드 -> 문자열
dir(x) : 변수, 함수 출력(내장)
divmode(a, b) : a/b = (몫, 나머지)
enumerate(x) : index 및 value 반환
eval('') : 실행. 동적실행을 원할 경우
filter(함수, x) : x -> 함수 실행 후 참값 모음
hex(x) : 정수 -> 16진수
id(객체) : 주소값 리턴
input()
int(x) : 문자열(실수) -> 정수
int(x, 진수)
isinstance(객체, 클래스) : 객체가 클래스의 객체 인지 확인
lambda 인수1...:인수를 이용한 식
# def와 유사. 한줄함수
list = [lambda, lambda]
list[0](1,2)
len(x) : 길이
list(x) : 리스트
map(함수, 반복가능) : 함수 실행결과 모음
max(반복가능) : 최대값
min(반복가능) : 최소값
oct(x) : 정수 -> 8진수
open('파일이름', 읽기방법) : w, r, a, b, default = r
ord(x) : 문자 -> 아스키코드
pow(x,y) : 제곱
range(m,n) : 인자 1 0에서 시작, 인자 3 간격 명시
sorted(반복) : 정렬 후 리스트 리턴
a.sort() : 정렬
str(객체) : 문자열로 변경
tuple(반복) : 튜플로 변경
type(객체) : 자료형
zip(반복) : n번째 인자끼리27. 외장함수
import sys
sys.argv
cmd -> python 파일명 argument
sys.exit()
sys.pathimport pickle
pickle.dump(data, f)
data = pickle.load(f)import os
os.environ
os.chdir("경로") : 디렉토리 변경
os.getcwd() : 현재 디렉토리
os.system("명령어") : 시스템 명령어 실행
os.popen("명령어") : 읽기모드로 파일객체 리턴
os.mkdir(디렉토리) : 디렉 생성
os.rmdir(디렉토리) : 디렉 삭제
os.unlink(파일이름) : 파일삭제
os.rename(src, dst) : 파일명 src -> dst로 변경import shutil
shutil.copy("src 파일명", "dst 파일명") : 파일복사import glob
glob.glob("경로/q*) : q이름 리스트 출력import temp file
filename = tempfile.mktemp() : 임시파일이름 생성
f = tempfile.TemporaryFile() : 임시 공간 파일객체 리턴import time : 1970.1.1 ~
time.time() : 지난 시간
time.localtime(time.time()) : 로컬시간
time.asctime() : 알기쉽게
time.ctime() : time.asctime(time.localtime(time.time()))
time.strftime('', time.localtime(time.time())
time.sleep(초)import calender
calender.calender(연도)
calender.prcal(연도)
calender.prmonth(연도, 월)
calender.weekday(연도, 월, 일) : 요일, 월 = 0
calender.monthrange(연도, 월) : 1일의 요일, 마지막 일import random
random.random() : 0 ~ 1 사이 난수
random.randint(1, 10) : 1 ~ 10 사이 정수 난수
random.choise(data) : 리스트 무작위
random.shuttle(data) : 섞기import webbrowser
webbrowser.open('사이트 주소')
webbrowser.open_new('사이트 주소') : 새창import threading
t = threading.Thread(targer = 함수명, args = 입력변수(리스트))
t.deamon = True : 메인 종료시 스레드도 종료
t.start() : 스레드 실행
class MyThread(threading.Thread):
def __init__(self,msg):
threading.Thread.__init__(self)
def run(self):os.listdir('경로') : 경로 포함 리스트
os.path.join('경로', '파일명') : 경로 + 파일명
os.path.splitext('파일명') : 확장자와 파일명 분리
os.path.isdir('파일명') : 디렉토리인지 파일인지 구분
os.walk("c:/) : (경로, 디렉, 파일) 검색import re
p = re.compile('ab*')28. 정규식
[abc]
\d
\D
\s
\S
\w
\W
a.b
a[.]b
a*b
a+b
a{m,n}
a?m = p.match("") : none or m
m = p.search("") : 아닌게 있어도
result = p.findall("") : List 리턴
result = p.finditer("") : 반복가능 객체
m.group() : 문자열
m.start() : 시작위치
m.end() : 끝위치
m.span() : 시작 끝, 튜플
m = re.match('형식', "문자열")re.DOTALL S \n
re.IGNORECASE I 각 라인 ^p, p$, space 가능, 주석 가능
re.MUKTILINE M
re.VERBOSE X
p = re.complie('형식', re.option)
^p : 처음 p
p$ : 마지막 p
\\ : \
\\\\ : \\
r'\\' : \\
소모가 없는 메타문자
| or
^ 처음
$ 끝
\A ^
\z $
\b 구분자(space) 있어야함
\B 구분자(space) 없어야함
[^] \^
re.M 적용X29. Group : 문자열이 계속 반복되는 지 조사
(ABC)+ (\w+) (\d+)
group(0) : 전체
group(n) : n번째
\1 : 동일단어 연속
\2 : 두번째 그룹
(?P<name> ) (?p=name)
(?=...)
(?!...)
p = re.compile('a')
p.sub('b', 'c' count=n) : c에서 a를 b로 변경
p.subn( )
('결과', n번 바꿈)
\g<그룹명> 정규식 그룹명 참조
\g<|>
Greedy30. Element Tree
from xml.etree.ElementTree import parse, ElementTree, SubElement, Element, dump
Tag = Element("Tag") => <Tag></Tag>
Tag.text = "내용1"
SubElement(Tag, "subTag").text = "내용2"
<Tag>내용1
<subTag>내용2</subTag>
</Tag>
Tag.insert(1, sub2Tag)
Tag.remove(1, sub2Tag)
Tag.attrib["속성"] = "속성내용"
Tag.Element("Tag", 속성명 = "속성내용")
indent(Tag)
ElementTree(Tag).write("파일명")
tree = parse("파일명")
note = tree.getroot()
note.get("검색어", "default")
note.keys()
note.item()
note.find("subTag") : 첫번째 태그
note.findall("subTag") : 모든 태그
note.findtext("subTag") : 모든 태그의 Text
note.getiterator()
note.getchildren()# 알고리즘 수행시간 측정 (보통 1초 128MB)
import time
start_time=time.time()
end_time=time.time()
print("수행시간: ",end_time-start_time)
#단축키
ctrl +/ => 주석
pypy3
* ord('문자') : 아스키코드값 리턴
* stack : pop(), append() 사용
* queue : queue = deque() / queue.popleft(), append()
* array[::-1] : 처음 부터 끝까지 역순으로 한칸씩
* array[A:B:C] : A부터 B까지 C 간격으로
1. 그리디 greedy
2. 구현 implementation
3. 탐색
4. 정렬 sorting
1) 선택 정렬
* swap
array[i],array[j] = array[j],array[i]
2) 삽입 정렬
* range(a,b,1) : a ~ (b-1)까지 1간격
* range(a,b,-1) : a ~(b+1)까지 -1간격
3) 퀵 정렬
* print(a,end=' ') : a 끝에 ' '문자 출력