[CodingDojang] Python 공부 1, 2일 - 여러 자료형 이용하는 방법

코딩 도장으로 공부하면서 스리슬쩍 끄적여 보는 내용이다.

계산하기

사칙연산자

“//” 연산자 - 나눗셈 후 소수점 이하를 버림

“” 연산자 - 거듭제곱 연산 ex) 2^10 = 210

몫과 나머지를 함께 구하는 방법도 있는데,

divmod(5, 2) → (2, 1)

자료형

int(3.3) → 3

int(5/2) → 2

int(’10’) → 10

숫자, 계산식, 문자열(숫자로 된)등을 괄호 앞에 붙은 자료형으로 바뀌어 출력된다.

 

+) 객체의 자료형을 알아보려면

type(10) → <class ‘int’>

위와 같은 type 명령어를 사용하면 된다.

변수 만들기

변수를 여러 개 만들 때에는 아래와 같은 방법을 사용할 수 있다.

ex) x, y, z = 10, 20, 30

x = y = z = 10

 

cf) 두 변수의 값을 바꿀 때에는

ex) x, y = 10, 20

x, y = y, x → x = 20, y = 10

 

cf2) 변수를 삭제할 때에는

ex) x = 10 → del x

 

cf3) 빈 변수를 만들 때에는

ex) x = None → print(x) ⇒ None

입력 값을 변수에 저장하기

input() 함수를 사용한다.

ex) x = input() → Hello, world! 입력 → x ⇒ Hello, world!

 

다만, 다음과 같은 문제가 발생한다.

ex) a = input() → 10 입력 → type(a) ⇒ <class ‘str’>

 

그래서 아래와 같은 방법으로 정수를 입력받아준다.

ex) a = int(input())

 

그리고 한 번에 여러 값을 입력받으려면 다음과 같은 명령어를 사용한다.

• 변수1, 변수2 = input().split()
• 변수1, 변수2 = input().split(’기준문자열’)
• 변수1, 변수2 = input(’문자열’).split()
• 변수1, 변수2 = input(’문자열’).split(’기준문자열’)

ex1) a, b = input(’숫자 두 개를 입력하세요: ‘).split(’,’) #’숫자 두 개를 입력하세요:’ 라는 문자열 뒤에, 입력받은 값을 콤마를 기준으로 분리하는 입력

마찬가지로 한번에 입력받은 숫자들을 한번에 정수형으로 입력받으려면 map 함수를 이용해준다.

ex) a, b = map(int, input().split())

값 출력하기

값을 여러 개 출력하기

• print(값1, 값2, ...)

ex) print(1, 2, 3) → 1 2 3

• print(변수1, 변수2, ...)

ex) print(’Hello’, ‘Python’) → Hello Python

 

값 사이에 문자 넣기

• print(값1, 값2, sep=’문자 또는 문자열’)

ex) print(1, 2, 3, sep=’, ‘) → 1, 2, 3

• print(변수1, 변수2, sep=’문자 또는 문자열’)

ex) print(’Hello’, ‘Python’, sep=’’) → HelloPython

 

cf) 줄바꿈 활용하기

print(1, 2, 3, sep=’\n’)

1

2

3

end 사용하기

• print(값(변수), end=’문자 또는 문자열’)

ex) print(1, end=’’)

print(2, end=’’)

print(3)

→ 123

비교, 논리 연산자

불 연산자 참은 True, 거짓은 False

문자열 비교

문자열은 비교할 때 대소문자를 구분한다. 이때, 단어가 같아도 대소문자가 다르면 다른문자열로 판단한다.

‘Python’ == ‘Python’

→ True

‘Python’ == ‘python’

→ False

‘Python’ ! = ‘python’

→ True

객체 비교

객체에 대해서는 클래스를 사용할 때, 더 첨가해놓겠다.

1 == 1.0

→ True

1 is 1.0

→ False

1 is not 1.0

→ True

논리연산자

and, or, not 연산자

만약 세 논리 연산자가 하나의 식에 들어가 있으면 not, and, or의 순으로 판단한다.

만약 비교 연산자와 논리 연산자가 함께 있는 경우,

비교 연산자를 먼저 판단하고, 논리 연산자를 판단하게 된다.

문자열 사용하기

문자열을 사용할 때에는 다음과 같은 세 방법을 사용할 수 있다.

 

1. 작은 따옴표로 묶기

>>> hello = 'Hello, World!'
>>> hello
'Hello, World!'

2. 큰 따옴표로 묶기

>>> hello = "Hello, World!"
>>> hello
'Hello, World!'

 

3. 위의 기호를 세 번 입력하여 묶기

>>> hello = '''Hello, Python!'''
>>> hello
'Hello, Python!'
>>> python = """Python Programming"""
>>> python
'Python Programming'

여러 줄로 된 문자열을 사용하려면 다음과 같이 세 따옴표로 사용한다.

>>> hello = '''Hello, world!
안녕하세요.
Python입니다.'''
>>> print(hello)
Hello, world!
안녕하세요.
Python입니다.

문자열 안에 작은 따옴표나 큰 따옴표를 포함하려면 반대되는 기호로 문자열을 묶어주면 된다.

>>> say1 = "Python isn't difficult"
>>> say1
"Python isn't difficult"
>>> say2 = 'He said "Python is easy"'
>>> say2
'He said "Python is easy"'

또는 역슬래시(\)를 사용할 수도 있다.

>>> 'Python isn\\'t difficult'
"Python isn't difficult"

리스트와 튜플

리스트

리스트는 C언어에서의 배열과 같으며, 변수에 값을 저장할 때, 대괄호([ ])로 묶어주면 리스트가 되며 각 값은 콤마(,)로 구분한다.

• 리스트 = [값, 값, 값 ... ]

>>> a = [38, 21, 53, 62, 19]
>>> a
[38, 21, 53, 62, 19]

다만 배열과 리스트의 다른 점은 리스트에는 문자열, 정수, 실수, 불 등 모든 자료형을 저장할 수 있으며, 이를 섞어서 저장해도 상관이 없다는 것이다.

>>> person = ['james', 17, 175.3, True]
>>> person
['james', 17, 175.3, True]

빈 리스트를 만들 때에는 [ ]만 지정하거나 list를 사용한다.

>>> a = []
>>> a
[]
>>> b = list()
>>> b
[]

range를 사용하여 리스트 만들기

range는 연속된 숫자를 생성하는 함수이다. range에 10을 지정하면 0부터 9까지 숫자를 생성한다. 즉, 지정한 횟수 숫자는 생성되는 숫자에 포함되지 않는다.

range 함수를 이용하여 지정한 범위의 숫자를 포함하는 리스트를 만들 수 있다.

• range(시작, 끝)의 방식으로 사용하면, 시작부터 끝-1까지 들어있는 숫자가 생성된다.
• 그리고 range(시작, 끝, 증가폭)의 방식으로 사용하면, 해당 증가폭만큼 증가하며 숫자를 생성한다.

>>> range(10)
range(0, 10)

>>> a = list(range(10))
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> b = list(range(5, 12))
>>> b
[5, 6, 7, 8, 9, 10, 11]

>>> c = list(range(-4, 10, 2))
>>> c
[-4, -2, 0, 2, 4, 6, 8]

>>> d= list(range(10, 0, -1))
>>> d
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

튜플

쉽게말해 읽기 전용 리스트로, 리스트처럼 요소를 일렬로 저장하지만, 안에 저장된 요소를 변경, 추가, 삭제할 수 없다.

이 외에 리스트적인 요소는 같다고 볼 수 있다.

튜플을 만들 때에는 리스트와는 다르게 소괄호(( ))로 묶어주고, 값은 콤마(,)로 구분해준다.

리스트와 튜플

리스트와 튜플을 서로 바꾸어 저장할 수도 있는데 다음과 같이 바꿀 수도 있다.

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

>>> b = (4, 5, 6)
>>> list(b)
[4, 5, 6]

시퀀스 자료형

파이썬에서는 리스트, 튜플, range, 문자열처럼 값이 연속적으로 이어진 자료형을 **시퀀스 자료형(sequence types)**라고 한다.

시퀀스 자료형으로 만든 객체를 시퀀스 객체라고 하며, 시퀀스 객체에 들어있는 값을 요소(element)라고 한다.

시퀀스의 객체 조회

방법1. 값 in 시퀀스객체

방법2. 값 not in 시퀀스객체

>>> a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
>>> 30 in a
True
>>> 100 in a
False

>>> a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
>>> 100 not in a
True
>>> 30 not in a
False

>>> 43 in (38, 76, 43, 62, 19)
True

시퀀스 객체 연결

시퀀스 객체는 + 연산자를 사용하여 객체를 서로 연결해 새 객체를 만들 수 있다.

>>> a = [0, 10, 20, 30]
>>> b = [9, 8, 7, 6]
>>> a + b
[0, 10 ,20 ,30, 9, 8, 7, 6]

cf) 문자열에 숫자를 연결하려면 숫자를 str() 함수로 형 변환 시켜주어야 한다.

>>> 'Hello, ' + str(10)
'Hello, 10'
>>> 'Hello, ' + str(1.5)
'Hello, 1.5'

시퀀스 객체 반복

>>> [0, 10, 20, 30] * 3
[0, 10, 20, 30, 0, 10, 20, 30, 0, 10, 20, 30]

리스트와 튜플의 요소 개수를 구하는 방법은 다음과 같다.

>>> a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
>>> len(a)
10

>>> b = (38, 76, 43, 62, 19)
>>> len(b)
5

문자열의 길이를 구하려면 len() 함수를 사용한다.

>>> hello = 'Hello, world!'
>>> len(hello)
13

인덱스 사용하기

인덱스는 0부터 시퀀스 객체에 배정되고 나머지도 순서대로 배정된다.

인덱스의 객체를 조회하려면, 대괄호([ ])를 사용하여 객체에 접근하는 방법도 있지만, 실제로는 __ getitem __ 메서드를 호출하여 요소를 가져온다. 그래서 __ getitem __ 을 직접 호출하는 방법도 있다.

>>> a = [38, 21, 53, 62, 19]
>>> a[0]
38
>>> a[2]
53

>>> b = (38, 21, 53, 62, 19)
>>> b[0]
38

>>> r = range(0, 10, 2)
>>> r[2]
4

>>> hello = 'Hello, world!'
>>> hello[7]
'w'

>>> a = [38, 2, 53, 62, 19]
>>> a.__getitem__(1)
21

또한, 음수의 인덱스를 지정하면 ‘뒤에서’ n번째라는 의미를 지니게 된다.

>>> a = [38, 21, 53, 62, 19]
>>> a[-1]
19
>>> a[-5]
38

>>> b = (38, 21, 53, 62, 19)
>>> b[-1]
19

>>> r = range(0, 10, 2)
>>> r[-3]
4

>>> hello = 'Hello, world!'
>>> hello[-4]
'r'

요소의 값을 할당하려면 인덱스를 통해 각 요소에 접근한 후에, 값을 할당해주면 된다.

>>> a = [0, 0, 0, 0, 0]
>>> a[0] = 38
>>> a[1] = 21
>>> a[2] = 53
>>> a[3] = 62
>>> a[4] = 19
>>> a
[38, 21, 53, 62, 19]
>>> a[0]
38
>>> a[4]
19

그리고 시퀀스객체를 삭제하려면 del() 함수를 이용하면 된다.

>>> a = [38, 21, 53, 62, 19]
>>> del a[2]
>>> a
[38, 21, 62, 19]

슬라이스 사용하기

슬라이스는 보통 시퀀스 슬라이스를 의미하는데, 말 그대로 시퀀스 객체의 일부를 잘라낸다는 의미이다.

• 시퀀스객체[시작인덱스:끝인덱스]

의 문법으로 사용해준다.

 

시작인덱스부터 끝인덱스에 표시된 인덱스 직전 인덱스까지 불러온다. ([0:4]라고 하면 0번째 인덱스에서 시작해서 3번 인덱스까지 불러온다.)

>>> a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
>>> a[0:4]
[0, 10, 20, 30]

그렇다면 음수 인덱스의 경우에는 어떨까?

>>> a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
>>> a[4:-1]  # 인덱스 4부터 -2까지 요소 5개를 가져옴
[40, 50, 60, 70, 80]

슬라이스에도 증가폭을 사용할 수 있다.

아래와 같은 방법으로 사용하면 된다.

• 시퀀스객체[시작인덱스:끝인덱스:인덱스증가폭]

>>> a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
>>> a[2:8:3]  
[20, 50]

또한 슬라이스에서 원하는만큼, 인덱스를 생략하는 방법 또한 존재한다.

처음부터 원하는 곳까지 가져오는 방법(끝인덱스 - 1까지 가져옴)

• 시퀀스객체[:끝인덱스]

원하는 곳부터 끝까지 가져오는 방법

• 시퀀스객체[시작인덱스:]

시퀀스 전체를 가져오는 방법

• 시퀀스객체[:]

>>> a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
>>> a[:7]
[0, 10, 20, 30, 40, 50, 60]
>>> a[7:]
[70, 80, 90]
>>> a[:]
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]

또한 생략하는 방법대로 증가폭 또한 설정할 수 있다.

튜플, range 문자열에도 슬라이스를 적용할 수 있다.

파이썬에서는 위의 방법 말고도 slice() 객체를 이용해서 시퀀스 객체를 잘라낼 수도 있다.

• 슬라이스객체 = slice(끝인덱스)
• 슬라이스객체 = slice(시작인덱스, 끝인덱스)
• 슬라이스객체 = slice(시작인덱스, 끝인덱스, 인덱스증가폭)
• 시퀀스객체[슬라이스객체]
• 시퀀스객체.__ getitem__(슬라이스객체)

슬라이스를 통해 시퀀스 객체들에 접근할 수 있는만큼, 객체들에게 접근하여 새로운 요소로 할당할 수도 있다.

또한, del() 메서드를 이용하여 슬라이스 형태로 객체들을 삭제할 수 있다.

 

딕셔너리 사용하기

파이썬은 연관된 값을 묶어서 저장하는 용도로 딕셔너리 자료형을 제공한다.

예를 들어, 다음과 같은 방식으로 데이터들을 정리할 수 있다.

lux = {'health': 490, 'mana': 334, 'melee': 550, 'armor': 18.72}

이때, 딕셔너리의 각 원소를 ‘키’라고 한다.

 

만약 딕셔너리를 만들 때 키 이름이 중복되면 가장 뒤에 있는 값만 사용한다.

딕셔너리 키의 자료형은 문자열 뿐만 아니라 정수, 실수, 불 자료형을 섞어서 사용해도 무관하다.

단, 키에는 리스트와 작은 딕셔너리를 사용할 수는 없다.

>>> x = {100: 'hundred', False: 0, 3.5: [3.5, 3.5]}
>>> x
{100: 'hundred', False: 0, 3.5: [3.5, 3.5]}

빈 딕셔너리를 만들 때에는 아래와 같은 방법을 사용한다.

• 딕셔너리 = {}
• 딕셔너리 = dict()

dict{} 메서드를 이용하여 딕셔너리를 만드려면 다음과 같다.

• 딕셔너리 = dict(키1=값1, 키2=값2, ...) 
  키 = 값 형식으로 딕셔너리를 만들 때에는 키에 따옴표를 사용하지 않아야 한다. 키는 딕셔너리를 만들고 나면 문자열로 바뀐다.

  >>> lux1 = dict(health=490, mana=334, melee=550, armor=18.72)
  >>> lux1
  {'health': 490, 'mana': 334, 'melee': 550, 'armor': 18.72}

• 딕셔너리 = dict(zip([키1, 키2], [값1, 값2], ...))
  dict에서 zip 함수를 이용할 때에는 키가 들어있는 리스트와 값이 들어있는 리스트를 zip에 넣은 뒤 dict에 넣어주면 된다.
  

  >>> lux2 = dict(zip(['health', 'mana', 'melee', 'armor'], [490, 334, 550, 18.72]))
  >>> lux2                                                          
  {'health': 490, 'mana': 334, 'melee': 550, 'armor': 18.72

• 딕셔너리 = dict([(키1, 값1), (키2, 값2), ...])
  리스트 안에 (키, 값) 형식의 튜플을 나열하는 방법도 있다.

  >>> lux3 = dict([('health', 490), ('mana', 334), ('melee', 550), ('armor', 18.72)])
  >>> lux3    
  {'health': 490, 'mana': 334, 'melee': 550, 'armor': 18.72}​

• 딕셔너리 = dict({키1: 값1, 키2: 값2, ... })
  마지막 방법은 dict 안에서 중괄호로 딕셔너리를 생성하는 방법이 있다.

  >>> lux4 = dict({'health': 490, 'mana': 334, 'melee': 550, 'armor': 18.72}) 
  >>> lux4                                                       
  {'health': 490, 'mana': 334, 'melee': 550, 'armor': 18.72}​

딕셔너리 키 조회하기

딕셔너리 키에 접근할 때는 딕셔너리 뒤에 대괄호([ ])를 사용하며 그 안에 키를 지정해주면 된다.

>>> lux = {'health': 490, 'mana': 334, 'melee': 550, 'armor': 18.72}
>>> lux['health']
490
>>> lux['armor']
18.72

위에서 키를 조회하는 방법을 바탕으로 새로운 값을 할당할 수도 있다.

마찬가지로 in, not in 연산자를 통해 원하는 키가 있는지 또한 조회할 수 있다.

딕셔너리에 저장되어 있는 키의 개수를 알아보려면 len(딕셔너리)의 방법을 사용하면 된다.