파이썬의 특징

• 인터프린터 언어(한 줄씩 소스 코드를 해석하는 언어)
• 문법이 쉽고 빠르게 배울 수 있음
• 다른 언어로 만든 프로그램을 파이썬 프로그램에 포함시킬 수 있음
• 괄호문자가 없고, 들여쓰기를 이용하기 때문에 가독성이 좋음

파이썬 설치

http://www.python.org/downloads에서 다운로드 하되, 설치 시 Add python.exe to PATH(파이썬이 어느 곳에서든지 실행될 수 있게 해주는 것)을 반드시 선택해야함

파이썬 자료형

숫자형

정수형

• 정수를 뜻하는 자료형으로, 양의 정수, 음의 정수, 0이 있음.

a = 123
a = -123
a = 0

실수형

• 소수점이 포함된 숫자

a = 1.2
a = -3.45

8진수와 16진수

• 8진수 : 0o(숫자0+알파벳o)로 시작

a = 0o177

• 16진수 : 0x로 시작

a = 0x8ff
b = 0xABC

연산자

사칙연산

• +,0,*,/ 사용가능

제곱 연산자

3 ** 4 = 81
-> 3의 4제곱

나머지 연산자

• 나눈셈의 나머지 값을 리턴

7 % 3
-> 1
3 % 7
-> 3

몫 연산자

• 몫만을 반환하는 연산자

7 // 4
-> 1

문자열 자료형

• 문자열이란?
  문자, 단어 등으로 구성된 문자들의 집합

"Python is good"
"a"
"123"

문자열 입력 방법

기본 출력

print('Python Start!')
print("Python Start!") 
print("""Python Start!""") # 여러줄 입력 시
print('''Python Start!''') # 여러줄 입력 시

이스케이프 코드

\n 문자열 안에서 줄바꿈
\t 문자열 사이에 탭 간격
\\ 문자 \를 그대로 표현
\` 문자 `를 그대로 표현
\" 문자 "를 그대로 표현

문자열 연산

• 문자열 더해서 연결

>>> head = "Python"
>>> tail = " is fun!"
>>> head + tail
'Python is fun!'

• 문자열 곱하기

>>> a = "python"
>>> a * 2
'pythonpython'

• separator 옵션

print('P', 'Y', 'T', 'H','O','N', sep='')
print('010', '7777', '7777', sep='-')
print('python', 'google.com', sep='@')

슬라이싱

연속적인 객체들에(예: 리스트, 튜플, 문자열) 범위를 지정해 선택해서 객체들을 가져오는 방법 및 표기법을 의미

• 기본형태 : a[start : end : step]
  • 각각 start, end, step 모두 양수와 음수를 가질 수 있음
  • start: 슬라이싱을 시작할 시작위치
  • end: 슬라이싱을 끝낼 위치로 end는 포함하지 않음
  • step: stride(보폭)라고도 하며 몇개씩 끊어서 가져올지와 방향을 정함
• 인덱스 값들의 위치

  a = ['a', 'b', 'c', 'd', 'e']
  
  // Index References
  -------------------------------
  |  a  |  b  |  c  |  d  |  e  |
  -------------------------------
  |  0  |  1  |  2  |  3  |  4  |          // 양수의 경우
  -------------------------------
  | -5  | -4  | -3  | -2  | -1  |          // 음수의 경우
  -------------------------------

• a[ start : ] : 특정 시작위치부터 끝까지 가져오기

  >>> a = ['a', 'b', 'c', 'd', 'e']
  >>> a[ 1 :  ]
  ['b', 'c', 'd', 'e']
  
  >>> a = ['a', 'b', 'c', 'd', 'e']
  >>> a[ -3 :  ]
  ['c', 'd', 'e']

• a[ : end ] : 시작점부터 특정 위치직전까지 가져오기

  >>> a = ['a', 'b', 'c', 'd', 'e']
  >>> a[  : 2 ]
  ['a', 'b']
  
  >>> a = ['a', 'b', 'c', 'd', 'e']
  >>> a[  : -1 ]
  ['a', 'b', 'c', 'd']

• a[ start : end ] : 특정 위치부터 특정 위치직전까지 모두 가져오기

  >>> a = ['a', 'b', 'c', 'd', 'e']
  >>> a[ 2 : 4 ]
  ['c', 'd']
  
  >>> a = ['a', 'b', 'c', 'd', 'e']
  >>> a[ -4 : -2 ]
  ['b', 'c']

• a[ start : end : step ] : step값으로 이동하면서 가져오기
  • step이 양수일 때: 오른쪽으로 step만큼 이동하면서 가져옴
  • step이 음수일 때: 왼쪽으로 step만큼 이동하면서 가져옴

    >>> a = ['a', 'b', 'c', 'd', 'e']
    # 2칸씩 이동하면서 가져옵니다.
    >>> a[ : : 2 ]
    ['a', 'c', 'e']
    
    >>> a = ['a', 'b', 'c', 'd', 'e']
    # 3칸씩 이동하면서 가져옵니다.
    >>> a[ -5 : : 3 ]
    ['a', 'd']
    
    >>> a = ['a', 'b', 'c', 'd', 'e']
    # 전체를 거꾸로 가져옵니다.
    >>> a[ : : -1 ]
    ['e', 'd', 'c', 'b', 'a']
    
    >>> a = ['a', 'b', 'c', 'd', 'e']
    >>> a[ 3 : : -1 ]
    ['d', 'c', 'b', 'a']

문자열 포맷

방법1) %

%s 문자열(String)
%c 문자 1개(character)
%d 정수(Integer)
%f 부동소수(floating-point)

방법2) . format()

문자열 내에 중괄호 { } 를 집어 넣고 뒤에서 .format(값1, 값2, ...) 을 입력하면 이 값들이 문자열 내의 중괄호 부분에 들어가게 됩니다( 문자열 안 중괄호에 인덱스값 사용가능)

방법3) .format(name = “value”)

마치 변수를 사용하는 것처럼 .format 내에서 이름과 값을 정의해두고 문자열 안 중괄호에 name을 넣어 할당한다(인덱스 값 X)

#방법1
print("나는 %d살입니다." % 20) # %d 정수를 받음
print("나는 %s을 좋아해요" %"파이썬") # %s 문자열 받음
print("Apple은 %c 로 시작해요" %"A") # %c 한글자만 받음 
print("나는 %s살입니다" %20) 
print("나는 %s색과 %s색을 좋아해요" %("파란","빨간")) # 두개의 값을 받음

#방법2
print("나는 {}살입니다.".format(20))
print("나는 {}색과 {}색을 좋아해요".format("파란","빨간"))
print("나는 {1}색과 {0}색을 좋아해요".format("파란","빨간")) #숫자로 순서변경

#방법3
print("나는 {age}살이며, {color}색을 좋아해요".format(age = 20, color = "빨간"))
print("나는 {color}살이며, {age}색을 좋아해요".format(age = 20, color = "빨간"))

#방법4 (v3.6 이상~) f-string
age = 20
color = "빨간"
print(f"나는 {age}살이며, {color}색을 좋아해요.")

자리수 설정

print('%10s' % ('nice')) # %10s로 총 자리수 정함
>      nice
print('{:>10}'.format('nice'))  # {:>10}열자리수 확보하겠다고 선언/ string만 s생략 가능
>      nice
print('%-10s' % ('nice')) #음수일 때 왼쪽 정렬
>nice
print('{:10}'.format('nice'))  #왼쪽 정렬
>nice
print('{:_>10}'.format('nice')) # 공백/ 글자 설정
>______nice
print('{:^10}'.format('nice')) #중앙 정렬
>   nice
print('%.5s' % ('nicepPython')) #기준 이상 삭제
>nicep
print('{:10.5}'.format('pythonstrudy')) # 10개의 공간 확보 5개만 출력
>pytho
print('%f' % (3.15125125151))
>3.151251
print('%1.2f' % (3.15125125151)) # 1개 정수 2개 소수
>3.15
print('%06.2f' % (3.14159293185)) # 총6자리지만 안되면 0으로 채움 소수 2자리
>003.14
print("{:06.2f}".format(3.14159293185))  # 003.14
>003.14

문자열 관련 함수

• count() 문자 갯수 세기

>>> a = "hobby"
>>> a.count('b')
2

• find() 위치 알려주기
  해당 문자가 처음으로 나온 위치 반환, 존재하지 않으면 -1

>>> a = "Python is the best choice"
>>> a.find('b')
14
>>> a.find('k')
-1

• index() 위치 알려주기
  find와 같지만, 존재하지 않을 경우 오류발생시킴

>>> a = "Life is too short"
>>> a.index('t')
8
>>> a.index('k')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: substring not found

• join() 문자열 삽입
  문자 사이에 삽입

>>> ",".join('abcd')
'a,b,c,d'

• upper() 소문자->대문자 변경

>>> a = "hi"
>>> a.upper()
'HI'

• lower() 대문자->소문자 변경

>>> a = "HI"
>>> a.lower()
'hi'

• lstrip() 왼쪽공백 지우기

>>> a = " hi "
>>> a.lstrip()
'hi '

• rstrip() 오른쪽공백 지우기

>>> a= " hi "
>>> a.rstrip()
' hi'

• strip() 양쪽공백 지우기

>>> a = " hi "
>>> a.strip()
'hi'

• replace() 문자열 바꾸기
  replace(바뀌게 될 문자열, 바꿀 문자열)처럼 사용해서 문자열 안의 특정한 값을 다른 값으로 변경

>>> a = "Life is too short"
>>> a.replace("Life", "Your leg")
'Your leg is too short'

• split() 문자열 나누기

>>> a = "Life is too short"
>>> a.split()
['Life', 'is', 'too', 'short']
>>> b = "a:b:c:d"
>>> b.split(':')
['a', 'b', 'c', 'd']

a.split()처럼 괄호 안에 아무 값도 넣어 주지 않으면 공백(스페이스, 탭, 엔터 등)을 기준으로 문자열을 나누어 준다. 만약 b.split(':')처럼 괄호 안에 특정 값이 있을 경우에는 괄호 안의 값을 구분자로 해서 문자열을 나누어 준다. 이렇게 나눈 값은 리스트에 하나씩 들어가게 된다.

리스트 자료형

>>> odd = [1, 3, 5, 7, 9]

리스트를 만들 때는 위에서 보는 것과 같이 대괄호[]로 감싸 주고 각 요솟값은 쉼표(,)로 구분해 준다.

리스트 만들기

>>> a = []
>>> b = [1, 2, 3]
>>> c = ['Life', 'is', 'too', 'short']
>>> d = [1, 2, 'Life', 'is']
>>> e = [1, 2, ['Life', 'is']]
>>> f = list()

리스트 안에는 어떠한 자료형도 포함시킬 수 있다.

리스트의 인덱싱과 슬라이싱

리스트 인덱싱

>>> a = [1, 2, 3]
>>> a[0]
1
>>> a[-1]
3
>>> a = [1, 2, ['a', 'b', ['Life', 'is']]]
>>> a[2][2][0]
'Life'

인덱스 번호로 리스트 인덱싱 가능

리스트 슬라이싱

위에서 설명한 것과 동일

리스트 연산

리스트 더하기

>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> a + b
[1, 2, 3, 4, 5, 6]

2개의 리스트를 합침

리스트 곱하기

>>> a = [1, 2, 3]
>>> a * 3
[1, 2, 3, 1, 2, 3, 1, 2, 3]

리스트 관련 함수

• len() 길이 구하기

>>> a = [1, 2, 3]
>>> len(a)
3

• del 요소 삭제

>>> a = [1, 2, 3]
>>> del a[1]
>>> a
[1, 3]

• append() 리스트에 요소 추가

>>> a = [1, 2, 3]
>>> a.append(4)
>>> a
[1, 2, 3, 4]
>>> a.append([5,6])
>>> a
[1, 2, 3, 4, [5, 6]]

• sort() 리스트 정렬

>>> a = [1, 4, 3, 2]
>>> a.sort()
>>> a
[1, 2, 3, 4]

• reverse() 뒤집기

>>> a = ['a', 'c', 'b']
>>> a.reverse()
>>> a
['b', 'c', 'a']

• index() 인덱스 반환

>>> a = [1,2,3]
>>> a.index(3)
2
>>> a.index(1)
0

• insert() 요소 삽입

>>> a = [1, 2, 3]
>>> a.insert(0, 4)
>>> a
[4, 1, 2, 3]

insert(a, b)는 리스트의 a번째 위치에 b를 삽입하는 함수로, 위 예는 0번째 자리, 즉 첫 번째 요소(a[0]) 위치에 값 4를 삽입하라는 뜻이다.

• remove() 요소 제거

>>> a = [1, 2, 3, 1, 2, 3]
>>> a.remove(3)
>>> a
[1, 2, 1, 2, 3]

첫 번째로 나오는 값 삭제, 여러 개 있으면 제일 앞에 것만 삭제함

• pop() 리스트 요소 끄집어내기

>>> a = [1,2,3]
>>> a.pop()
3
>>> a
[1, 2]

맨 마지막 요소를 리턴하고 해당 요소 삭제, ()안에 번호를 쓰면 해당 인덱스 번호의 요소를 리턴하고 삭제함

• count() 갯수 새기

>>> a = [1,2,3,1]
>>> a.count(1)
2

count(x)는 리스트 안에 x가 몇 개 있는지 조사하여 그 개수를 리턴

• extend() 리스트 확장

>>> a = [1,2,3]
>>> a.extend([4,5])
>>> a
[1, 2, 3, 4, 5]
>>> b = [6, 7]
>>> a.extend(b)
>>> a
[1, 2, 3, 4, 5, 6, 7]

extend(x)에서 x에는 리스트만 올 수 있으며 원래의 a 리스트에 x 리스트를 더하게 됨, a.extend([4, 5])과 a += [4, 5]은 동일함.

튜플 자료형

• 몇가지 점을 제외하곤 리스트와 거의 비슷함.
• 리스트는 []로 생성하지만 튜플은 ()으로 생성
• 리스트는 요소 값의 생성, 삭제, 수정이 가능하지만 튜플은 요소 값을 변경 불가능.
• 프로그램이 실행되는 동안 요솟값이 항상 변하지 않아야 하는 것은 튜플을 사용해야 한다.

튜플의 예시

>>> t1 = ()
>>> t2 = (1,)
>>> t3 = (1, 2, 3)
>>> t4 = 1, 2, 3
>>> t5 = ('a', 'b', ('ab', 'cd'))

• t2 = (1,)처럼 1개의 요소만을 가질 때는 요소 뒤에 콤마(,)를 반드시 붙여야 함
• t4 = 1, 2, 3처럼 괄호( )를 생략해도 된다

튜플 다루기

• 인덱싱, 슬라이싱, len()은 리스트와 동일
• 요솟값 변경이 불가능하기 때문에 sort,insert,remove,pop등 사용불가

튜플 더하기

>>> t1 = (1, 2, 'a', 'b')
>>> t2 = (3, 4)
>>> t3 = t1 + t2
>>> t3
(1, 2, 'a', 'b', 3, 4)

t1, t2 요솟값이 바뀌는 게 아닌, 새로운 튜플 t3를 생성

튜플 곱하기

>>> t2 = (3, 4)
>>> t3 = t2 * 3
>>> t3
(3, 4, 3, 4, 3, 4)

더하기와 마찬가지로 새로운 튜플 생성

딕셔너리 자료형

• 대응관계를 나타내는 자료형으로, 연관 배열(Associative array) 또는 해쉬(Hash)라고 함
• 리스트나 튜플과 다르게 순서가 없고, Key를 통해 Value를 얻음
• 순차적으로 검색하지 않고, 해당 key값만 바로 검색함

딕셔너리 자료형 기본모습

>>> dic = {'name':'pey', 'phone':'010-9999-1234', 'birth': '1118'}
>>> a = {1: 'hi'}
>>> b = { 'a': [1,2,3]}

value값에 리스트도 넣을 수 있음.

딕셔너리에 값 추가하기

>>> a = {1: 'a'}
>>> a[2] = 'b'
>>> a
{1: 'a', 2: 'b'}

a[2] = 'b'와 같이 입력하면 딕셔너리 a에 Key와 Value가 각각 2와 'b'인 {2 : 'b'} 딕셔너리 쌍이 추가됨.

>>> a['name'] = 'pey'
>>> a
{1: 'a', 2: 'b', 'name': 'pey'}

딕셔너리 값 삭제

>>> del a[1]
>>> a
{2: 'b', 'name': 'pey', 3: [1, 2, 3]}

del a[key]처럼 입력하면 지정한 Key에 해당하는 {key : value} 쌍이 삭제된다.

딕셔너리 사용법

>>> grade = {'pey': 10, 'julliet': 99}
>>> grade['pey']
10
>>> grade['julliet']
99
>>> a = {1:'a', 2:'b'}
>>> a[1]
'a'
>>> a[2]
'b'

딕셔너리이름['key'] 명령어를 사용하면 value값을 불러옴

딕셔너리 주의사항

>>> a = {1:'a', 1:'b'}
>>> a
{1: 'b'}

• key값은 고유한 값으로만 설정, 중복될 경우 하나 빼고 나머지는 모두 무시 됨
• Key값에 리스트는 사용불가, 튜플은 사용가능(변하지 않는 값만 사용 가능)

딕셔너리 관련 함수

• keys() Key 리스트 만들기

>>> a = {'name': 'pey', 'phone': '010-9999-1234', 'birth': '1118'}
>>> a.keys()
dict_keys(['name', 'phone', 'birth'])

딕셔너리 a의 Key만을 모아서 dict_keys 객체를 리턴

• valeus() 밸류 리스트 만들기

>>> a.values()
dict_values(['pey', '010-9999-1234', '1118'])

• items() Key, Value 쌍 얻기

>>> a.items()
dict_items([('name', 'pey'), ('phone', '010-9999-1234'), ('birth', '1118')])

• clear() key, value 모두 지우기

>>> a.clear()
>>> a
{}

• get() key로 value 얻기

>>> a = {'name':'pey', 'phone':'010-9999-1234', 'birth': '1118'}
>>> a.get('name')
'pey'
>>> a.get('phone')
'010-9999-1234'

a['name'] 과 동일한 결과값을 리턴
딕셔너리에 존재하지 않는 키로 값을 가져오려고 할 경우 a['nokey'] 방식은 오류를 발생시키고 a.get('nokey') 방식은 None을 리턴한다는 차이가 있다.

• in 해당 key가 있는지 조사하기

>>> a = {'name':'pey', 'phone':'010-9999-1234', 'birth': '1118'}
>>> 'name' in a
True
>>> 'email' in a
False

집합 자료형

집합 자료형 기본 형식

>>> s1 = set([1,2,3])
>>> s1
{1, 2, 3}
>>> s2 = set("Hello")
>>> s2
{'e', 'H', 'l', 'o'}

집합 자료형의 특징

• 중복을 허용하지 않음.
  -> 자료형의 중복을 제거하기 위한 필터로 종종 사용됨.
• 순서가 없음.
  ->인덱싱으로 접근하려면 리스트나 튜플로 변환후 해야함

>>> s1 = set([1,2,3])
>>> l1 = list(s1)
>>> l1
[1, 2, 3]
>>> l1[0]
1
>>> t1 = tuple(s1)
>>> t1
(1, 2, 3)
>>> t1[0]
1

교집합, 합집합, 차집합 구하기

>>> s1 = set([1, 2, 3, 4, 5, 6])
>>> s2 = set([4, 5, 6, 7, 8, 9])

교집합

>>> s1 & s2
{4, 5, 6}

'&' 기호를 이용해 교집합 구하기 가능

>>> s1.intersection(s2)
{4, 5, 6}

intersection() 함수도 동일

합집합

>>> s1 | s2
{1, 2, 3, 4, 5, 6, 7, 8, 9}

'|' 기호로 합집합 구하기 가능

>>> s1.union(s2)
{1, 2, 3, 4, 5, 6, 7, 8, 9}

union함수도 동일

차집합

>>> s1 - s2
{1, 2, 3}
>>> s2 - s1
{8, 9, 7}

>>> s1.difference(s2)
{1, 2, 3}
>>> s2.difference(s1)
{8, 9, 7}

집합 관련 함수

• add() : 값 1개 추가

>>> s1 = set([1, 2, 3])
>>> s1.add(4)
>>> s1
{1, 2, 3, 4}

• update() : 값 여러 개 추가

>>> s1 = set([1, 2, 3])
>>> s1.update([4, 5, 6])
>>> s1
{1, 2, 3, 4, 5, 6}

• remove() : 특정 값 제거

>>> s1 = set([1, 2, 3])
>>> s1.remove(2)
>>> s1
{1, 3}

불 자료형

• 참(True), 거짓(False) 2가지 값만을 가질 수 있는 자료형

자료형의 참과 거짓

"python" : 참
"" : 거짓
[1, 2, 3] : 참
[] : 거짓
(1, 2, 3) : 참
() : 거짓
{'a': 1} : 참
{} : 거짓
1 : 참
0 : 거짓
None : 거짓

• 문자열, 리스트, 튜플, 딕셔너리 등의 값이 비어 있으면(" ", [ ], ( ), { }) 거짓
• 숫자에서는 그 값이 0일 때 거짓

불 연산

>>> bool([1,2,3])
True
>>> bool([])
False
>>> bool(0)
False
>>> bool(3)
True

변수

• 다른 프로그래밍 언어는 변수 생성 시 자료형의 타입을 지정해야 하지만, 파이썬은 스스로 자료형의 타입을 지정함
• 변수를 생성하면 해당 변수명이 해당 값을 갖게 되는 게 아닌, 변수명과 이름이 같은 메모리의 주소를 가르키는 것.

>>> a = [1,2,3]
>>> b = a
>>> id(a)
4303029896
>>> id(b)
4303029896
>>> a is b  # a와 b가 가리키는 객체는 동일한가?
True

• a를 변경하면 b도 변경됨

>>> a[1] = 4
>>> a
[1, 4, 3]
>>> b
[1, 4, 3]

변수 복사하기

[:] 이용

>>> a = [1, 2, 3]
>>> b = a[:]
>>> a[1] = 4
>>> a
[1, 4, 3]
>>> b
[1, 2, 3]

copy 모듈 이용

>>> from copy import copy
>>> a = [1, 2, 3]
>>> b = copy(a)
>>> b is a
False