파이썬 언어 문법을 마스터한 분들을 위한 문법요약입니다.
특히 다양한 언어를 사용해 문법이 헷갈리는 분들을 위해 제공합니다.
30분내 전체 문법을 훑어보실 수 있으며, 빠르게 문법을 리마인드할 수 있습니다.
출력하기 - print(출력값1, 출력값2, sep=' ', end='\n')
print(1, 2, 3) # 1 2 3 :공백추가되어 출력
print(1, 2, 3, sep=',') # 1,2,3 : sep값(,)추가되어 출력
print(1, end='') # end 기본값이 줄바꿈인데 원하는 값으로 처리가능
연산자
관계연산자:
> , >=, <, <=, ==, !=
논리연산자: 결과 - True, False
and, or, not
비트연산자:
&, |, ^, ~, <<, >> (쉬프트연산자)
증감연산자(++, --): 지원하지 않음
i+=1, i-=1 등 대신 사용
사칙연산자:
+, -, *, /, %(나머지)
bool 로 만들기: bool(1)
객체비교: is, is not
형변환:
a = int("10") # 정수형이 됨
a = float("10.5") # 실수형이 됨
a = str(10) # 문자열이 됨
복합연산자:
+=, -=, *=, /=, %=
조건연산자(3항연산자):
(a > b)? a: b
리스트 - [ ]로 생성. 배열대신 사용
a = []; b= list() # 빈리스트 생성
a = [1, 2, 'hello'] # 다른 타입들과 혼합 가능
a = list(range(3)) # [0, 1, 2] 리스트 생성
# range(시작, 끝(포함안됨), 간격)
range(2, 4) # 2,3
range(-2, 2, 2) # -2,0
range(3, 0, -1) # 2,3,1
튜플 - ( )로 생성. 내용변경불가(읽기전용) 리스트
a = (1, 5, 'abc')
a = 1, 5, 'abc' # ()없이도 가능
a = (5) # 한개만 하면 그냥 값이 됨. a =(5,) 또는 a = 5, 처럼 콤마 넣어줘야 함.
# 리스트처럼 range(시작,끝,간격) 으로 생성
a = [1, 2]; b=tuple(a) # 리스트를 튜플로
a = (1, 2); b=list(a) # 튜플을 리스트로
a = list('ab') # a = ['a','b'] 가 됨
a = tuple('ab') # a는 ('a', 'b') 가 됨.
a, b = [1,2]; a, b = (1, 2); #a,b 에 1,2값 들어감
시퀀스 자료형(값이 연속적으로 이어진 자료형) 공통 문법
- 리스트, 튜플, range, 문자열
a = [1, 2]
b = [3, 4]
2 in a # True. 값 존재여부
3 not in a # False . 값 미존재여부
a + b # [1, 2, 3, 4] : 배열이 합쳐짐
# 주의: range는 + 로 직접연결 불가능, 리스트나 튜플로 생성후 연결
'Hello' + str(10) # 문자열과 숫자 연결시 str 사용.
a * 3 # [1,2,1,2,1,2] : 배열이 반복되어 더해짐
'Ha '*3 # 'Ha Ha Ha' : 문자열이 반복되어 더해짐
len(a) # 길이,갯수
len('안녕'.encode('utf-8')) # 6 : 한글 바이트수. 한글한글자는 보통 3바이트
a[0] # 1 :첫번째 인덱스 요소값, 0부터 시작.
'abc'[1] # b :문자열은 해당위치 문자
a[-1] # 2 # 뒤에서 첫번째 인덱스요소값
a[1] = 3 # 리스트가능, 튜플은 불가능.
del a[1] # 두번째 요소제거. 튜플은 불가능.
슬라이스
객체[시작인덱스(0):끝인덱스(len):인덱스증가값(1)] # 생략시 ()안값이 기본값
a = [1, 2, 3, 4]
a[1:3] # [2, 3] #인덱스 1부터3까지 리턴
a[1:-1] # [2, 3] #인덱스 1부터 끝에 첫요소전.
a[1:4:2] # [2, 4] #인덱스1부터 2씩증가한 인덱스 요소값
슬라이스에 요소할당
객체[::] = 할당값
a[1,3] = ['a','b'] # 결과: a[1,'a','b',4] .값을 덮어씀
# 해당 인덱스조건을 제거하고 할당값을 추가.
# 단, 인덱스 증가값이 있을 경우 교체할 값하고 개수가 맞아야 함.
del a[1:3] #해당 인덱스를 제거함. 리스트만 가능.
딕셔너리 - { }로 생성. 키/값쌍 자료형
d = {'a': 10, 'b': 20} # 기본 형식, 키가 중복되면 나중것만 유효
x = {}; x = dict() # 빈딕셔너리 만들기
# dict 함수는 리스트, 튜플, 딕셔너리로 만들 때 사용.
dict(키1=값1, 키2=값2)
dict(zip([키1,키2],[값1,값2]))
dict([(키1,값1), (키2,값2)])
dict({키1:값1, 키2:값2})
d = {'a':10, 'b':20 }
d['a'] = 30 # 키값으로 접근하고, 할당
'a' in d # True : 키가 있는지 확인
len(d) # 2 :항목 갯수
딕셔너리 다루기 - 메서드, 출력
-키/값 쌍 추가
x = {'a':10, 'b':20}
-x.setdefault('c', 30)
-x.update(a=5, d=40) # 업데이트는 ' “ 따옴표 빼고 사용. 키값이 없으면 추가됨.
-x.update({1:'One', 2:'Tow'}) # 딕셔너리도 가능
-x.update([[3,'Three'],[4,'Four']]) # 리스트도 가능
x.pop('a') # 키에 해당하는 항목을 삭제하고 값을 리턴
x.pop('a', 0) # 키 a가 있으면 삭제후 해당값을 없으면 지정한값(0) 을 리턴.
x.popitem() # 마지막 항목을 삭제하고 튜플로 리턴.
x.clear() # 모두삭제
x.get('a', 0) # 키의 값 가져오기. 없으면 기본값(0) 반환.
x.items() # 키-값 쌍 모두 가져옴
x.keys() # 키값을 모두 가져옴
x.values() # 값을 모두 가져옴.
ks = ['a', 'b']
x = dict.fromkeys(ks) # 값이 None 인 딕셔너리를 생성
x = dict.fromkeys(ks, 100) # 값이 100 인 딕셔너리 생성
x = defaultdict(int) # 키값이 없을 경우 디폴트값 처리함수 int() 는 0을 리턴하므로 0이 리턴됨.
x = defaultdict(lambda: 'Default') # 람다표현식으로, 디폴트로 'Default' 리턴
키, 값 모두 출력
for 키, 값 in 딕셔너리.items():
반복할코드
for key in x.keys(): # 키값 가져와서 루프
for val in x.values(): # 값을 가져와서 루프
{키: 값 for 키, 값 in 딕셔너리}
x = {key: value for key, value in dict.fromkeys(keys).items()}
b = a.copy() # 복사
b = a.deepcopy() #a가 중첩 딕셔너리일 경우, 깊은 복사
세트(집합) - {} 로 생성
{} 안에 ,(콤마)구분으로 값을 저장
a = {'a', 'b'}
-세트는 순서가 정해져 있지 않고, 중복요소가 없다.
'orange' in fruits #세트에 orange 가 있는지 확인
set(반복가능객체) 로 생성가능. 세트안에 세트를 넣을 수는 없음.
a = set('abc') # 결과: {'b', 'c', 'a'} # 문자열 하나일 경우 각 문자로 만들어짐
a = set(range(3)) #range로 생성
a = frozenset(range(3)) #frozenset으로 생성하면 삭제할 수 없는 요소가 됨.
a | b , a & b, a - b, a ^ b # 합집합, 교집합, 차집합, 대칭차집합
|=, &=, -=, ^= 연산자 가능.
a |= b # a.update(b)
a &= b # a.inersection_update(b),
a -=b # a.difference_update(b)
a ^=b # a.symmetric_difference_update(b)
a <= b # a.issubset(b) 상위집합인지 여부
a == b # 같은지
a.isdisjoint(b) # 겹치는 요소 존재 여부
a.add(값); a.remove(값), a.discard(값) # 요소 추가, 삭제(없으면 에러), 제거(없으면 넘어감)
a.pop(); a.clear() #임의요소 삭제, 전체삭제
len(a) #갯수
b = a.copy() #복사
선택문 - if
if n == 1:
print('1')
elif n == 2:
print('2')
else:
pass # TODO나 빈코드 대신 넣음.
반복문 - for~in, while
for i in range(100):
print(i)
for 변수 in 시퀀스객체: # 리스트, 튜플, 문자열도 가능
반복할코드
i = 0 #초기식
while i < 100:
print(i) # 반복코드
i +=1 #변화식
반복문 분기
break #루프 한단계를 빠져나옴
continue #루프시작위치로 이동
리스트 다루기 할당과 복사, 표현식, 맵, 2차원리스트
리스트 조작:
a = [1, 3]
a.append(5) # 값하나 추가
a.append([7, 9]) # 결과: [1, 3, 5, [7, 9]] # 리스트 추가. 중첩리스트가 됨.
a = [1, 3]
a.extend([1, 2]) # 결과: a[1, 3, 1, 2] #리스트 값이 됨
a.insert(2,11) # 인덱스2 앞에 11 추가
a.inert(0,요소) # 맨처음에 추가
a.insert(len(a)) # 맨 마지막에 추가
a.pop() # 마지막값 삭제
a.remove(3) # 지정한 값을 찾아서 하나만 삭제
a.index(3) # 특정값의 인덱스값을 리턴
a.count(3) # 특정값의 갯수를 리턴
a.reverse() # 리스트 순서 뒤집기
a.sort() # 정렬
a.sorted() # 정렬된 새로운 리스트 리턴
a.clear() # 모두 삭제
리스트할당과 복사:
a = [1,2,3]
b = a # a, b는 같은 주소임
c = a.copy() # 별도 객체로 복사
a = [1,3,5]
for i, v in enumerate(a): # 인덱스값도 뽑아낼 경우 enumerate 사용.
print(i, v)
for i in range(len(a)): # 직접 i값을 만들어서 부를 수도 있음
print(i, a[i])
리스트 표현식( list comprehension )
[식 for 변수 in 리스트]
list(식 for 변수 in 리스트]
a = [i + 10 for i in range(10) if i % 2 == 0] # 0~9중 짝수+10 리스트 생성
for 여러번 사용. 구구단 리스트 예제.
a = [i * j for i in range(2, 10) for j in range(1, 10)]
리스트에 map 사용.
-map(fucntion, iterable) # iterable(반복가능한 자료형,리스트/튜플 등)
-리스트 요소를 지정된 함수로 처리, 원본 리스트를 변경하지 않고 새 리스트 생성
list(map(함수, 리스트))
tuple(map(함수, 튜플))
a = [1.1, 2.2, 3.3] #실수를 정수로 변환
for i in range(len(a)): # for 사용
a[i] = int(a[i]);
a = list(map(int, a)) # map 사용
a = list(map(str, range(10))) # 숫자를 문자열로 변환
a = map(int, input().split()) # 두수 입력받아서 맵객체로 처리.
튜플응용
a = (1, 3, 5)
a.index(3) # 1, 지정값이 있는 인덱스 리턴
a.count(3) # 1, 지정값의 개수
2차원리스트
a = [[1, 2], [3, 4]]
a = ((1, 2),(3, 4)) # 튜플안에 튜플 2차원. 변경불가
b = ([1, 2,],[3, 4]) # 튜플안에 리스트. 안쪽 리스트만 수정가능
c = [(1, 2),(3, 4)] # 리스트안에 튜플. 리스트만 수정가능
for 출력
a = [[1, 2],[3, 4]]
for x, y in a:
print(x, y)
for i in a:
for j in i:
print(j, end=' ')
print()
2차원 리스트 복사하려면 copy 대신 deepcopy 함수 사용
import copy # copy 모듈을 가져옴
a = [[1,2],[3,4]]
b = copy.deepcopy(a)
파일 다루기 - open, read, write, close, readlines, writelns,
f = open('hello.txt', 'w') # 쓰기모드로 열기
f.write('Hello world')
f.close()
f = open('hello.txt', 'r')
s = f.read()
f.close()
with open('hello.txt', 'r') as f: # close 안써도 닫힘.
s = f.read()
lines = ['안녕1\n', '안녕2\n']
with open('hello.txt', 'w') as f:
file.writelines(lines)
with open('hello.txt', 'r') as f:
lines = f.readlines() # 한줄씩 리스트로 넘겨줌
with open('hello.txt', 'r') as f:
line = None
while line != '':
line = f.readline() # 한줄씩 읽어옴
print(line)
with open('hello.txt', 'r') as f:
for line in f:
print(line)
f = open('hello.txt', 'r')
a, b, c = f # 파일객체는 이터레이터(반복가능자료형) 이므로 가능.
함수 - 함수정의, 재귀호출
def 함수이름():
코드
def hello():
print('Hello')
hello() # 함수 선언전에 호출하면 에러남.
def 함수이름(매개변수):
""""독스트링: 함수에 대한 설명을 넣는다. 이전에 다른코드가 오면 안됨"""
def add_(a, b):
return a+b # 결과값 리턴
def add_sub(a, b):
return a + b, a - b # 값1, 값2 # 반환값이 여러개일 경우 ,(콤마)로 구분해서 리턴, 튜플로 넘김
x, y = add_sub(20, 10) # x = 30, y = 10 # 두개의 반환값을 받음
z = add_sub(20, 10) # (30, 10) # 하나로 받으면 튜플로 받아짐.
return (1,2), return [1,2] # 직접 튜플이나 리스트로 리턴해도 됨.
위치인수(positional argument) - 인수 순서대로 넣기
def print_num(a, b, c):
print(a, b, c)
print_num(10, 20, 30) # 선언된 순서대로 들어감.
x = [10, 20, 30]
print_num(*x) # *+리스트나 튜플 을 넣으면 인수 순서대로 들어감.
가변인수 함수 - *변수를 인수로 해서 가변인수로 만듬.
def print_num(*args): # args 는 임의의 이름이어도 됨.
for arg in args:
print(arg)
def print_num(a, *args): # 고정인수와 가변인수를 같이 사용.
키워드 인수
함수(키워드=값) 형식으로 넣는다.
def personal_info(name, age):
print('이름: ', name)
print('나이: ', age)
persoanl_info('홍길동', 30) # 인수 순서대로 콜
personal_info(age=30, name='홍길동') #순서 상관없이 키워드 인수로 콜
딕셔너리 언패킹 - 딕셔너리앞에 ** 를 붙여서 언팩킹 인수로 사용
x = {'name': '홍길동', 'age': 30}
personal_info(**x) # *를 하나만 호출하면 name, age 출력됨. 그래서 **로 사용.
키워드 인수를 사용하는 가변인수 함수. **딕셔너리도 가능하지만 함수로 정의할 수도 있음.
def 함수이름(**매개변수):
코드
def personal_info(**kwargs): #keyword args 를 줄여서 kwargs 를 관행적으로 사용. 제한 없음.
for kw, arg in kwargs.items():
print(kw, ': ', arg, sep='')
초기값
def personal_info(name, age, address='비공개'): # 매개변수=값으로 초기값 설정
-초기값 지정한 인수 뒤에 초기값 없는 인수 올 수 없음.
재귀호출 - 종료조건 필수.
def factorial(n):
if n == 1: # 종료조건
return 1 # 재귀없이 빠져나감
return n * factorial(n - 1) # 재귀호출
print(factorial(5))
람다표현식 간단한 함수를 한줄로 작성할 수 있게 하는 문법
lambda 매개변수들: 식/반환값
def add_1(x):
return x + 1
람다표현식: lambda x: x + 1
익명으로 할 경우: add_1 = lambda x: x + 1
(lambda x: x + 1)(1) # 람다함수 만든 후 인수를 넣어 바로 호출가능
-람다표현식내에 새변수는 사용불가. 바깥에 있는 변수는 사용가능.
list(map(labda x: x + 1, [1,2])) # map 함수등에 사용하기 좋음.
람다에 조건부 표현식 사용하기
lambda 매개변수들: 식1 if 조건식 else 식2
a = [1,2,3]
list(map(lambda x: str(x) if x % 3 == 0 else x, a)) # 3의 배수는 문자열로.
# 람다식에서는 조건문에 : 를 사용하지 않음. ,else 필수, elif 사용불가 .
map 에 리스트객체 여러개 넣기
a = [1,2]
b = [3,4]
list(map(lambda x, y: x * y, a, b)) # a 요소*b 요소 값.
filter 사용하기 - 반환값이 True 일 경우에만 값을 가져옴
filter(함수, 반복가능객체)
list(filter(lambda x: x % 2 == 0, a)) # 짝수만 가져옴
클래스 - 객체지향 프로그래밍
class Person: #클래스명은 대문자로 시작 추천
def greet(self): #메소드는 self 매개변수 필수
print('Hello')
def hello(self):
self.greet() #클래스 메서드 호출시 self. 사용.
tom = Person() # 인스턴트 = 클래스()
top.greet()
isinstance(인스턴스, 클래스) # 클래스의 인스턴스인지 확인
isinstance(n, int)
속성 : __init__(slef) 메서드 안에 속성 설정. 생성자 함수.
class __init__(self):
self.hello = '안녕'
tom.hello2 = 'hello2' # 외부(인스턴스)를 통해 속성추가 가능.
속성제한을 우해서는 __slotes__ = ['속성1', '속성2'] 사용
__slots__ = ['name', 'age']
self.__속성 = 값 #비공개속성. 클래스내부에서만 접근. 인스턴스통해 속성에 직접 접근 불가.
class 클래스이름:
속성 = 값 # 클래스 속성. 모든 인스턴스에 공유(공통사용),
# 속성접근시 self(인스턴스이므로) 보다는 명확하게 클래스 이름을 사용해서 접근. 클래스이름.속성
__init__(self):
속성 = 값 # 인스턴스 속성
__속성 = 값 # 비공개 클래스 속성
정적메서드 (staticmethod) -정적이므로 인스턴스가 없으므로 self 를 지정하지 않는다.
class 클래스이름:
@staticmethod #데코레이터를 붙여준다.
def 메서드(매개변수1, 매개변수2): #self 를 지정하지 않는다.
코드
-정적메서드는 self(인스턴스)가 없기 때문에 인스턴스 속성/메서드에 접근할 수 없다.
클래스메서드
class 클래스이름:
@classmethod # 데코레이터 사용
def 메서드(cls, 매개변수1, 매개변수2):
코드
class Person:
count = 0 # 클래스 속성
def __init__(self):
Person.count += 1 # 클래스 속성 count 증가시킴
@classmethod # 클래스메서드 데코레이터
def print_count(cls): # 호출시 cls 매개변수 자동으로 받음
print('{0}명 생성됨'.format(cls.count) # cls로 속성접근
—
클래스 상속(inheritance)
class 기반클래스:
코드
class 파생클래스(기반클래스):
코드
class Person: # 기반클래스
def greet(self):
print('안녕')
class Student(Person): # Person 에서 상속
def study(self):
print('공부')
—
class Person:
def __init__(self):
self.hello = '안녕'
class Student(Person):
def __init__(self): # __init__ 가 선언 안되어 있다면 기반클래스 __init__가 실행됨.
self.school = '학교' #super()로 초기화 하지 않으면 기반클래스 __init__가 실행되지 않음.
tom = Student()
print(tom.hello) # 기반클래스에 있는 hello 가 초기화되지 않아 에러.
메서드 오버라이딩
-파생클래스에서 기반클래스의 메서드와 같은 이름으로 만들면 덮어씀.
다중상속
-기반클래스를 ,(콤마)로 구분해서 여러개 설정
class 기반클래스1:
코드
class 기반클래스2:
코드
class 파생클래스(기반클래스1, 기반클래스2)
코드
추상클래스(abstract class)
-메서드의 목록만 가진 클래스
-import abc (abstract base class) 모듈을 가져와야 함.
-파생클래스에서는 추상클래스의 모든 메서드를 구현해야 함.
from abc import *
class 추상클래스(metaclass=ABCMeta):
@abstractmethod
def 메서드이름(self):
pass
예외처리 - try: except: else: final:, rase, assert
try:
실행 코드
except:
예외처리 코드
else:
예외 미발생시 코드
finally:
예외 상관없이 항상 실행코드
raise 예외('에러메세지') #에러를 강제로 발생시킴
raise Exception('에바입니다')
assert 조건식, 에러메세지
assert x % 2 == 0, '2의 배수가 아님'
모듈 - 파일명이 모듈명
import 모듈 # 모듈 하나 import
import 모듈1, 모듈2 # 하나이상 import
import math
math.sqrt(4.0) # 모듈.모듈함수 사용
import math as m # 모듈명을 변경해서 사용
m.sqrt(4.0)
from 모듈 import 변수 # 모듈 일부만 가져오기
from math import pi, sqrt # 특정 함수만 가져옴
from math imort * # 모두 가져오기
from 모듈 import 변수 as 이름 # 변수나 함수를 이름으로 변경해서 가져오기
del 모듈 # 가져온 모듈 해제
패키지 모듈 가져오기:
import 패키지.모듈
import urllib.request
import ulrlib.request as r # r로 이름을 단축시켜서 가져오기
res = urllib.request.urlopen()
from 패키지.모듈 import 변수 as 이름
패키지 설치 - 파이썬 패키지인덱스 관리자 pip
>sudo pip install requests
모듈과 패키지 만들기
-모듈은 변수,함수,클래스 등을 모아 놓은 스크립트 파일,
-패키지는 여러 모듈을 묶어 놓은 것.
–예)myadd.py myadd 모듈
def myadd(a, b):
return a + b
—-사용예
import myadd
print(myadd(1, 2))
__name__ : 모듈이름이 들어있음. 최초시작하는 스크립트에서는 '__main__' 이 들어감.
모듈은 파일, 패키지는 폴더로 구성되어 있음.
-mypkg/md1.py , md2.py
패키지 모듈의 경우 __name__ 에 패키지.모듈( mypkg.md1) 처럼 들어간다.
터틀그래픽 - 간단하게 그래픽을 그릴 수 있는 모듈
import turtle as t
t.shape('turtle')
t.forward(100) # fd(100) 과 같음
t.right(90) # rt(90) 과 같음
# 수십개의 다양한 메서드가 지원됨.