[TeamH4C_Python] 자료형의 비교와 문자열

안녕하세요!

이번에는 비교 연산자와 문자열에 대해 정리하려 합니다.

 

1. 불리언(boolean)과 비교, 논리 연산자

프로그래밍을 하다 보면 참(True)과 거짓(False)을 판단해야 할 때가 있는데 참(True)과 거짓(False)을 나타내는 것이 불(bool)입니다. 파이썬에서는 비교와 논리 연산자의 결과를 True와 False로 나타내는데 예로 부등호를 이용한 식에서 조건이 참이면 True, 거짓이면 False가 출력되는 것을 확인할 수 있습니다.

비교 연산에서 같음을 표시하는 연산은 ==(equal) 연산자이며, 서로 다름을 비교하는 연산은 !=(not equal)을 사용합니다. 같음을 비교하여 같으면 True, 다르면 False를 출력하며, 같지 않음을 비교하여 같으면 False, 다르면 True를 출력합니다. 
또한, 숫자뿐 아니라 문자열도 비교하여 대소문자를 구분하여 True, False를 출력합니다.

• 여기서 주의할 점은 앞에서 배운 =연산자는 할당하는 연산자로 같음을 비교하는 연산자가 아닙니다.

비교 연산하면 부등호일 텐데 부등호의 사용에서는 크다(초과), 작다(미만), 크거나 같다(이상), 작거나 같다(이하)를 판단하게 됩니다. 부등호는 아래의 주석과 같이 첫 번째 값이 기준이 되어 비교되어 불립니다.

# 10이 20보다 큰가?
>>>10 > 20
False

# 10이 20보다 작은가?
>>>10 < 20
True

# 20이 20보다 크거나 같은가?
>>>20 >= 20
True

# 20이 20보다 작거나 같은가?
>>>20 <= 20
True

 

객체의 비교 시에는 is와 is not을 사용합니다. is는 같다의 뜻이고, is not은 같지 않다의 뜻이지만 값의 비교에서의 같다(==)와 같지 않다(!=)와는 다릅니다. is와 is not은 값 자체를 비교하는 '==', '!='와는 다르게 객체(object)를 비교합니다.

예로 1과 1.0의 값은 정수(int)와 실수(float)의 차이점만 있을 뿐 값 자체는 같습니다. 하지만 객체의 비교에서는 정수의 객체와 실수의 객체는 서로 다르기 때문에 값의 비교에서는 같지만, 객체의 비교에서는 다른 형태입니다.

정수와 실수의 객체가 서로 다른지 확인하는 방법으로는 id함수를 사용하면 확인할 수 있습니다.

id함수는 객체의 고유 값(메모리 주소)을 구하는데 이 값은 한번 실행하면 계속 유지되고 다시 실행되면 값이 변하는 성질을 가지고 있습니다.

id함수로 정수와 실수의 '1'을 확인해보겠습니다. id(1)과 id(1.0)의 코드를 실행하였을 때, 서로 다른 객체의 고윳값을 확인할 수 있습니다. 그렇기에 정수와 실수의 1은 서로 다른 객체인 것을 확인 가능합니다.

그렇기에 값에서의 같다(==)와 다르다(!=)가 객체에서의 같다(is)와 다르다(is not)은 동작 방식이 다르다는 것을 알 수 있습니다.

여기서 변수와 값의 객체 비교 시에는 아래와 같이 변수의 값은 다른 값으로 할당되면 메모리의 주소가 달라질 수 있기에 변수와 값의 비교는 객체의 비교는 안 하는 것이 좋습니다.

>>>a = -5
>>>a is -5
True
>>>a = -6
>>>a is -6
False

 

2. 논리 연산자

논리 연산자에는 and, or, not연산자가 존재합니다. and는 모든 값이 참(True)이어야 참(True)이 되는 연산이고, or은 하나 이상의 값이 참(True)이면 결과가 참이 되는 연산이며 not은 반대로서 참(True)을 거짓(False)으로 거짓(False)을 참(True)으로 논리 값의 결과를 반대로 뒤집는 연산입니다.

연산의 우선순위로는 not, and, or 순서입니다. 아래의 예시를 확인하시면 이해하기 편리하실 것입니다.

>>>not True and False or not False
>>>((not True) and False) or (not False)
>>>(False and False) or True
>>>False or True
>>>True

여기서 논리 연산자와 비교 연산자를 함께 사용 시 비교 연산자(is, is not, ==, !=, <, >, <=, >=)를 먼저 판단하고 논리 연산자(not, and, or)를 판단하여 계산하면 됩니다.

 

이제 정수와 실수, 문자열을 불(bool)로 만들어보겠습니다. 직접 불(bool)로 만들기 위해서는 bool함수를 이용하면 됩니다. 불은 참과 거짓을 나타내는 것이므로 숫자와, 실수, 문자열을 확인하여 참과 거짓을 표현할 수 있습니다.

정수에서는 0을 빼고 모든 수가 True이며, 0은 False가 됩니다. 실수 또한 마찬가지로 0.0을 제외한 모든 실수는 True이고, 0.0은 False입니다. 여기서 문자열은 아래의 그림과 같이 문자열이 'False'라 할지라도 True가 나올 것입니다. 문자열은 내용 자체를 판단하지 않고 내용의 유무를 판단하여 내용이 없으면 False 있으면 True를 출력하기 때문입니다.

>>>bool('True')
True
>>>bool('False')
True
>>>bool('Python')
True
>>>bool(' ')
True
>>>bool('')
False
>>>bool("")
False

 

마지막으로 논리 연산에는 단락 평가(short-circuit evaluation)가 존재합니다. 단락 평가는 첫 번째 값이 결과에 확실한 영향을 줄 때 두 번째 값을 확인하지 않는 방법입니다. 예로 and 연산과 or연산이 있는데 and는 둘 중 하나가 False면 결과가 False이기 때문에 첫 번째 값을 확인하여 False면 두 번째 값은 확인하지 않고 앞에 값인 False를 출력하는 것이고, or은 둘 중 하나가 True면 결과가 True이기 때문에 첫 번째가 True면 두 번째 값은 확인하지 않고 앞의 값 True를 출력하는 것입니다.

파이썬에서의 논리 연산자는 단락 평가에 의해 반환하는 값이 결정됩니다. and 연산에서 True가 먼저 나오면 뒤의 결과에 따라 출력이 다르게 되기 때문에 뒤의 값에 초점을 두어 출력하게 됩니다. 아래의 코드에서 True가 아닌 'Python'이 출력된 이유도 뒤의 값에 초점이 맞춰져 있기에 뒤에 값이 출력된 것이고 반대로 앞의 값이 False일 때는 앞에 있는 내용이 반환되는 것을 볼 수 있습니다. or연산에서는 True가 하나라도 나오면 True이기에 앞에 값이 True면 더 이상 비교할 필요가 없다 판단되어 앞의 내용을 출력하게 되는 것이고 앞이 False면 뒤에 있는 내용이 반환되어 출력되는 것을 볼 수 있습니다.

>>>True and 'Python'
'Python'
>>>False and 'Python'
False
>>>'' and True
''

>>>True or 'Python'
True
>>>1 or 'Python'
1
>>>'' or 'Python'
'Python'

# 논리 연산은 무조건 불(bool)을 반환하지 않고 마지막으로 단락평가를 실시한 값이 불(bool)이면 불(bool)로 반환합니다.
# 마지막으로 단락평가를 실시한 값이 불(bool)이 아닌 값이면 값을 그대로 반환합니다.

 

3. 문자열의 사용

문자열을 변수에 저장하여 사용하는 방법에 대해 정리하겠습니다.

문자열은 작은따옴표(')로 묶어 문자열로 만들게 되며, 영문뿐 아니라 한글 문자열도 사용할 수 있습니다.

파이썬에서는 작은따옴표(')로 묶는 방법 이외에도 문자열을 만드는 방법은 아래의 방식과 같습니다.

• 작은따옴표(')로 묶는 방법
• 큰 따옴표(")로 묶는 방법
• 작은따옴표 3개(''')로 묶는 방법
• 큰 따옴표 3개(""")로 묶는 방법

여기서 작은따옴표(')와 큰 따옴표(")로 나뉘는 이유는 다음과 같습니다. 문자열을 사용할 때 문자열 안에 작은따옴표나 큰 따옴표를 넣어야 할 상황이 생기는데 문자열을 묶은 따옴표로 문자열 안에 넣게 된다면 구문 오류가 발생하여 문자열을 묶지 않은 따옴표가 필요하게 되어 작은따옴표와 큰 따옴표로 나뉘게 된 것입니다. 단, 따옴표 3개로 묶인 문자열은 어느 따옴표라도 묶을 때 간섭만 없으면 따옴표를 입력하여도 에러가 발생하지 않습니다.

>>>hello = 'hello, 안녕하세요!'
>>>hello
'hello, 안녕하세요!'
>>>hello = "hello, 안녕하세요!"
>>>hello
'hello, 안녕하세요!'
>>>hello = 'hello, "안녕하세요!"'
>>>hello
'hello, "안녕하세요!"'
>>>hello = "hello, '안녕하세요!'"
>>>hello
"hello, '안녕하세요!'"
>>>hello = '''hello, 안녕하세요!'''
>>>hello
'hello, 안녕하세요!'
>>>hello = """hello, 안녕하세요!"""
>>>hello
'hello, 안녕하세요!'

# 소스코드(스크립트)로 작성시 인코딩 방식은 UTF-8로 저장하여 실행

 

문자열 안에 따옴표를 넣는 또 다른 방법으로는 문자열 안에 제어 문자를 넣어 따옴표를 넣을 수 있는 방법이 있습니다. 작은따옴표(')로 문자열을 묶었을 때 작은따옴표를 사용하고 싶다면 문자열 안에 있는 작은따옴표 앞에 역슬래시(\)를 붙여 작은따옴표를 출력할 수 있습니다. 반대의 경우인 큰 따옴표도 역슬래시(\)를 넣어 큰 따옴표를 출력을 할 수 있습니다. 이런 특수문자를 포함하기 위해 앞에 역슬래시(\)를 붙이는 방법을 이스케이프(escape)이라고 부릅니다.

 

여러 줄로 된 문자열(multiline string)을 출력하는 방법으로는 작은따옴표 3개(''')나 큰 따옴표 3개(""")를 이용하면 됩니다. 이러한 따옴표로 묶어주면 enter을 눌러 다음 줄로 넘어가도 명령이 끝나지 않고 계속 문자열을 입력할 수 있어 따옴표로 닫아주기까지는 입력이 가능하여 줄 바꿈을 쉽게 할 수 있습니다.

따옴표 3개로 묶지 않고 여러 줄로 출력하는 방법은 변수와 데이터 게시물에서의 sep함수 추가 설명 부분과 비슷한데 개행 문자(\n)를 문자열 자체에 추가하여 여러 줄로 된 문자열을 만들 수 있습니다.

>>>hello = '''hello,
안녕하세요!
Python'''
>>>print(hello)
hello,
안녕하세요!
Python

>>>hello = """hello,
안녕하세요!
Python"""
>>>print(hello)
hello,
안녕하세요!
Python

>>>hello = 'hello,\n안녕하세요!\nPython'
>>>print(hello)
hello,
안녕하세요!
Python

 

4. 리스트와 튜플

변수에 하나의 값을 저장해왔지만 값을 여러 개를 저장해야 한다면 변수 여러 개 값 여러 개를 써야 하는데 개수가 너무 많으면 직접 하기에는 무리가 있습니다. 그렇기에 이럴 때는 리스트와 튜플을 사용하는 방법이 있습니다.

리스트는 목록이라는 뜻으로 값을 일렬로 늘어놓은 형태이며 리스트의 값은 코드로 생성하는 경우가 많아 일일이 타이핑할 일이 적습니다.

리스트(list)를 만들기 위해서는 변수에 값을 저장할 때 대괄호([])로 묶어주면 리스트가 되며 각 값은 콤마(,)로 구분하며 다음과 같습니다.

>>>리스트 변수 = [값1, 값2, 값3]

리스트에 저장된 각 값은 요소(element)라고 불립니다. 리스트에 저장된 요소는 여러 가지 자료형이 올 수 있으며 문자열, 정수, 실수, 불(bool) 등 모든 자료형을 섞어 저장할 수 있습니다. 이러하듯 여러 자료형을 사용하면 값과 관련 정보를 하나로 묶기 좋습니다.

빈 리스트를 만들 수도 있는데 빈 리스트는 새 값을 추가하는 방식으로 사용되기 때문에 필요한 경우도 있습니다. 만드는 방법은 아래와 같습니다.

>>>리스트 = []
>>>리스트 = list()

 

범위(range) 함수를 이용하여 리스트의 내용을 추가할 수 있는데 range는 연속된 정수(int)를 생성하는 함수입니다. range함수에 숫자를 넣어 지정하면 0부터 숫자에 1을 뺀 만큼 숫자를 생성하게 됩니다. 지정한 숫자는 생성되는 숫자에 포함되지 않게 되는 것입니다.

range함수를 사용하는 법은 아래와 같습니다. 

>>>range(지정횟수)
(0, 지정횟수)
>>>range(0, 10)
range(0, 10)

# range(10)을 입력하였다면 0부터 9까지의 숫자를 생성할 것입니다.

이런 반복성을 이용하여 list에 range함수를 넣어보면 0부터 지정 횟수까지 들어있는 리스트가 생성되며 리스트 = list(range(횟수))와 같은 형식으로 사용해야 할 것입니다.

range는 0부터 시작하는 것뿐만 아니라 시작 위치를 정할 수도 있고, 증가폭을 설정하여 숫자의 규칙을 정할 수 있습니다. 사용의 예는 아래와 같습니다.

>>>a = list(range(5,10))
>>>b = list(range(5,10,2))
>>>print(a, b, sep = ' & ')
[5, 6, 7, 8, 9] & [5, 7, 9]

# 리스트 = list(range(시작, 끝))
# 리스트 = list(range(시작, 끝, 증가폭))
# 위의 형식들로서 5부터 9까지 출력하는 list를 만들어 봤습니다.
# 시작을 정한 range는 시작을 정한 숫자부터 시작하는 것을 볼 수 있습니다.
# 증가폭은 해당 값만큼 증가하는 것을 볼 수 있습니다.

 

이제 튜플에 대해 알아보겠습니다. 튜플은 리스트처럼 요소(element)를 일렬로 저장하지만 안에 저장된 요소를 변경, 추가, 삭제를 할 수 없으므로 읽기 전용 리스트라고 할 수 있습니다.

튜플(tuple)을 만들기 위해서는 변수에 값을 저장할 때 괄호(())로 묶어주면 튜플 형식이 됩니다. 각 값은 콤마(,)로 구분해주며 괄호로 묶지 않고도 값만 콤마로 구분해주어도 튜플이 만들어집니다.

>>>튜플 = (값1, 값2, 값3)
>>>튜플 = 값1, 값2, 값3

튜플도 리스트처럼 여러 자료형을 섞어 저장하여도 저장이 가능합니다. 튜플이 읽기 전용으로 만들어진 이유는 프로그래밍에서 값이 변경되지 않고 유지되어야 할 경우가 있기에 파이썬에는 튜플이 있게 된 것입니다. 튜플을 만든 상태에서 요소를 변경하거나 추가, 삭제 시 에러가 발생하여 실수로 변경하는 상황을 방지할 수 있습니다. 요소를 변경해야 되는 작업이 있으면 리스트(list)를 사용하면 되고, 실무에서는 값이 자주 변하는 작업이 많기에 리스트를 튜플보다 더 사용합니다.

튜플에서도 요소로 하나를 생성할 수 있는데 튜플은 값 하나를 괄호로 묶으면 튜플이 아니라 일반적인 값이 되기에 요소가 하나인 튜플을 만들 때는 값을 넣고 콤마(,)를 붙여 튜플인 것을 표현해야 합니다.

>>>튜플 = (값,)
>>>튜플 = 값,

하나뿐인 값을 사용하는 이유는 함수(class)에서는 값이 아닌 튜플을 넣어야 할 경우가 있기 때문입니다.

range를 이용하여 튜플에 값을 넣을 수 있는데 리스트(list)에서 했던 것처럼 list대신 tuple을 넣어 선언하면 됩니다.

>>>a = tuple(range(10))
>>>b = tuple(range(5, 10))
>>>c = tuple(range(5, 10, 2))
>>>print(a, b, c, sep=' & ')
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9) & (5, 6, 7, 8, 9) & (5, 7, 9)

# 튜플 = tuple(range(횟수))
# 튜플 = tuple(range(시작, 끝))
# 튜플 = tuple(range(시작, 끝, 증가폭))

튜플과 리스트는 변경, 추가, 삭제의 가능만 다르고 서로 기능과 형태는 같으므로 튜플은 리스트로 리스트는 튜플로 만들 수도 있습니다. tuple안에 리스트를 넣으면 새 튜플이 생기고 list안에 튜플을 넣으면 새 리스트가 생성됩니다.

>>>tuple(리스트)
>>>list(튜플)

 

5. 시퀀스의 활용

시퀀스는 리스트, 튜플, range, 문자열의 공통점으로 모든 값들이 연속적(sequence)으로 이루어져 있다는 것입니다. 이렇게 연속적으로 이루어진 자료형을 시퀀스 자료형(sequence types)라고 부릅니다.

시퀀스 자료형에는 list, tuple, range, str, bytes, bytearray라는 자료형들이 존재하고 있습니다. 시퀀스 자료형의 특징은 공통 동작과 기능을 제공하여 어떠한 시퀀스 자료형을 접하더라도 큰 문제점 없이 사용이 가능합니다. 이러한 시퀀스 자료형으로 만든 객체들을 시퀀스 객체라고 하며 시퀀스 객체에 들어있는 각 값들을 요소(element)라는 명칭을 쓰고 있습니다.

시퀀스 객체 안에 특정 값이 있는지 찾아야 하는 상황이 있는데 확인하는 방법으로는 in 연산자를 이용하여 찾을 수 있습니다. 반대인 특정 값이 없는지 판단하는 것은 not in 연산자를 이용하여 확인할 수 있습니다.

>>>a = list(range(10))
>>>5 in a
True
>>>10 in a
False
>>>5 not in a
False
>>>10 not in a
True

# 값 in 시퀀스 객체
# 값 not in 시퀀스 객체
# 위의 형식으로 값이 시퀀스 객체에 존재하는지 찾거나 존재하지 않는가를 판단
# 연속적인 형태는 모두 시퀀스 객체입니다.

시퀀스 객체를 연결할 수도 있는데 + 연산자를 이용하여 두 객체를 연결해 새 객체를 만들 수 있습니다.

변수를 따로 만들지 않고 시퀀스 객체 여러 개를 직접 연결하여 사용이 가능하지만, 시퀀스 객체 중 range는 + 연산자로 객체를 연결할 수 없습니다. 그렇기에 range는 연결을 하고자 하면 다른 시퀀스 객체의 도움을 받아 연결을 해야 합니다.

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

# 시퀀스 객체 + 시퀀스 객체
# 위의 형식이며 range는 시퀀스 객체의 도움을 받아 연결할 수 있습니다.

시퀀스는 연결 말고도 값을 반복할 수 있습니다.

시퀀스 객체의 반복 사용에서는 * 연산자를 사용하면 되며, 시퀀스 객체를 특정 횟수만큼 반복하여 새 시퀀스 객체를 만드는 형식입니다. 여기에서도 range는 직접 * 연산자를 사용하여 반복할 수 없습니다.

>>>a = tuple(range(5))
>>>a * 2
(0, 1, 2, 3, 4, 0, 1, 2, 3, 4)

# 시퀀스 객체 * 정수(int)
# 정수(int) * 시퀀스 객체
# 0또는 음수를 곱하면 빈 객체가 나오며 실수는 곱할 수 없습니다.

시퀀스 객체의 요소 개수(길이)를 구하기 위해서는 len함수를 이용하면 됩니다. len함수는 길이(length)라는 뜻으로 요소의 개수를 구합니다.

len을 이용하여 range의 숫자 생성 개수를 구할 수도 있으며, 문자열의 길이 또한 구할 수 있습니다. 문자열에서는 공백도 개수로 포함됩니다.

>>>a = ('hello', 'python')
>>>len(a)
2
>>>len('hello, python')
13

# len(시퀀스 객체)
# len(a)에서 개수가 2개가 나온 이유는 요소가 2개이기 때문입니다.
# len('hello, python')에서 개수가 13개가 나온 이유는 공백을 포함하였기 때문입니다.

이러한 시퀀스 객체에 들어있는 요소에 접근하기 위해서는 인덱스를 사용하여야 합니다.

인덱스(index, 색인)이란 위치 값을 뜻하며, 시퀀스 객체의 각 요소에 순서가 정해져 있는데 이 순서를 인덱스라고 부릅니다. 각 요소의 인덱스에 접근하기 위해서는 대괄호([])를 붙이고 대괄호에 각 요소의 인덱스를 지정하면 접근할 수 있습니다.

>>>a = ('hello', 'world', 'python')
>>>a[1]
'world'

# 시퀀스 객체[인덱스]
# 앞에 hello부터 0번 인덱스, 1번 인덱스, 2번 인덱스 순으로 올라갑니다.
# a[1]을 입력하면 1번 인덱스의 내용을 호출하여 world를 표시합니다.

위의 주석의 설명과 같이 인덱스는 항상 0부터 시작합니다.

음수 인덱스를 사용할 수 있는데 음수 인덱스를 지정할 경우 뒤에서부터의 요소에 접근하게 됩니다.

인덱스의 범위는 0부터 시작하여 마지막 요소의 인덱스는 시퀀스 객체의 요소 개수보다 1이 작다는 것을 이용하여 요소 접근방법에 활용할 수 있습니다.

len의 함수를 이용하여 시퀀스 객체[len(시퀀스 객체)-1]의 형식으로도 마지막 요소의 인덱스에 접근할 수 있습니다.

이러한 요소들에 접근하여 값을 할당할 수도 있습니다.

요소에 값을 할당하기 위해 시퀀스 객체는 대괄호([])로 요소에 접근한 뒤 = 연산자를 통해 값을 할당합니다. 여기서 튜플과 같이 읽기 전용 시퀀스 객체들은 값을 수정할 수 없기 때문에 한 번 생성된 객체를 변경할 수 없습니다.

읽기 전용 시퀀스 자료형에는 튜플, range, 문자열이 있습니다.

요소의 값을 삭제하는 것도 읽기 전용 시퀀스 자료형은 불가능하며 요소 삭제는 del함수를 이용하면 삭제가 가능합니다.

>>>a = list(range(1,10,2))
>>>a[3] = 7.5
>>>a
[1, 3, 5, 7.5, 9]

>>>del a[3]
>>>a
[1, 3, 5, 9]

# 시퀀스 객체[인덱스] = 값
# del 시퀀스 객체[인덱스]
# 인덱스의 범위에서 벗어나면 에러가 발생합니다.

시퀀스 자료형은 슬라이스 기능을 자주 사용하는데 시퀀스 슬라이스는 시퀀스 객체의 일부를 잘라내는 것을 말합니다.

시퀀스 슬라이스의 사용으로 시퀀스 객체의 일부를 잘라 새로운 시퀀스 객체를 만들 수 있습니다. 시퀀스 객체[시작 인덱스: 끝 인덱스] 형식의 사용으로 다음의 그림과 같이 선언하면 되는데 끝 인덱스에서 하나를 뺀 만큼의 인덱스 요소를 가져옵니다.

요소를 처음부터 끝까지 가져오려면 시퀀스 객체[0:6]와 같이 인덱스의 범위를 하나 벗어나게 설정하여야 합니다. 그렇기에 시작 인덱스와 끝 인덱스를 같은 숫자로 지정하면 아무것도 가져오지 않기에 끝 인덱스를 하나 더 크게 지정해야 요소를 가져오게 됩니다.

시작 인덱스는 꼭 요소의 처음일 필요가 없으며 중간 요소부터 가져올 수 있습니다. 인덱스에 음수도 지정할 수 있는데 음수를 지정하면 위에 있던 음수 인덱스 그림과 같이 뒤에서부터 -1의 값을 가져 다음 코드와 같이 가져올 수 있습니다.

>>>a = tuple(range(1, 10, 2))
>>>a
(1, 3, 5, 7, 9)
>>>a[2:-1]
(5, 7)

# -1의 인덱스의 값이 9이지만 9부터 출력이 안되고 9값의 전인 인덱스가 출력되는 것을 볼 수 있습니다.

인덱스에 증가폭을 사용하여 요소를 가져올 수 있는데 인덱스 숫자에 규칙을 정하여 가져오게 되는 것이며, 시퀀스 객체[시작 인덱스:끝 인덱스:인덱스 증가폭]로 가져올 수 있습니다.

또한, 인덱스가 처음부터 시작하거나 마지막까지 가져올 때 인덱스를 생략할 수 있습니다. 모두 생략([:])하면 모든 인덱스를 가져와 데이터 전체를 보여주게 됩니다. 코드로 정리해보겠습니다.

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

# 시퀀스 객체[시작 인덱스:끝 인덱스:증가폭 인덱스]
# 시작 인덱스를 생략하였을 시, 처음부터 끝 인덱스에서 하나를 뺀 인덱스까지 증가폭에 따라 출력되었습니다.
# 끝 인덱스를 생략하였을 시, 시작 인덱스부터 마지막 인덱스까지 증가폭에 따라 출력되었습니다.
# 모두 생략하였을 때, 모두 출력되었습니다.

len함수를 이용하여 시퀀스 객체의 값들을 가져올 수 있는 방법도 있습니다. 시퀀스 객체[0:len(시퀀스 객체)] or 시퀀스 객체[:len(시퀀스 객체)]의 형식을 사용하면 시퀀스 객체의 전체를 가져올 수 있습니다.

시퀀스 객체는 이러한 슬라이스로 범위를 지정하여 여러 요소들에 값을 할당할 수 있습니다.

슬라이스로 범위를 지정하여 값을 할당하는 방식은 시퀀스 객체[시작 인덱스:끝 인덱스] = 시퀀스 객체의 형식으로 할당할 수 있습니다. 특정 범위에 값을 할당하는 방법은 다음과 같습니다.

>>>a = list(range(1,10))
>>>b = tuple(range(10,15))
>>>a
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>a[2:5] = ['a','b','c']
>>>a
[1, 2, 'a', 'b', 'c', 6, 7, 8, 9]
>>>a[1:2] = b
>>>a
[1, 10, 11, 12, 13, 14, 'a', 'b', 'c', 6, 7, 8, 9]

# 인덱스 2부터 4까지 값을 'a', 'b', 'c'로 할당한 것입니다.
# 할당할 개수는 맞추지 않아도 되며 할당할 요소의 개수가 모자르면 그만큼 요소의 개수가 줄어들고 많으면 늘어납니다.
# 증가폭을 설정하면 할당할 요소와 증가폭 범위의 개수가 일치해야합니다.
# 원래있던 시퀀스 객체가 변경되는 것이기에 읽기전용 시퀀스 객체는 범위할당이 불가능합니다.

슬라이스를 이용하여 삭제하기 위해서는 del함수를 사용하면 됩니다. del뒤에 삭제할 범위를 지정해주면 됩니다.

del 시퀀스 객체[시작 인덱스:끝 인덱스] 형식으로 사용되며, 증가폭을 설정할 수 있습니다. 여기서도 읽기 전용 시퀀스 객체는 요소의 삭제가 불가능합니다.

 

6. 딕셔너리의 사용

데이터를 리스트에 저장할 때, 숫자만 나열되어 있어 각 값이 어떤 목적을 가지고 있는지 쉽게 알 수 없었습니다. 그래서 파이썬에서는 연관된 값을 묶어 저장하는 용도로 딕셔너리라는 자료형을 제공합니다.

딕셔너리는 사전(dictionary)에서 단어를 찾듯이 값을 가져올 수 있다고 하여 딕셔너리라고 합니다. 그렇기에 이러한 딕셔너리를 보면 어떤 값이 어떤 이름을 가져 저장되는지 쉽게 볼 수 있습니다.

딕셔너리는 다음과 같은 형식으로 저장되어 활용됩니다. 중괄호({})안에 키: 값의 형식으로 저장되며 각 키와 값은 콤마(,)로 구분됩니다. 딕셔너리는 키를 지정후 콜론(:)을 붙여 값을 표현하며, 키에는 값 하나만 지정할 수 있어 키-값 쌍(key-value pair)이라 합니다.(키-값은 1:1 대응)

# 아래와 같은 형식입니다.
# dictionary = {'키1': 값1, '키2': 값2}

키의 이름이 중복되면 중복되는 키는 가장 뒤에 있는 값을 사용하고 중복되는 키는 저장되지 않습니다. 키 값 확인은 딕셔너리[키]를 하면 확인이 가능합니다.

딕셔너리 키의 자료형에는 문자열, 정수, 실수, 불(bool)도 사용할 수 있으며 자료형을 섞어 사용이 가능합니다. 값에는 리스트, 딕셔너리 등을 포함한 모든 자료형을 사용할 수 있습니다. 키에만 리스트와 딕셔너리를 사용할 수 없습니다.

빈 딕셔너리를 만드는 것도 가능한데 딕셔너리={}, 딕셔너리=dict()와 같이 입력하면 생성할 수 있습니다.

dict로 딕셔너리를 만드는 방법은 아래와 같습니다. dict는 키와 값을 연결하거나 리스트, 튜플, 딕셔너리로 딕셔너리를 만들 때 사용됩니다.

# 딕셔너리 = dict(키1 = 값1, 키2 = 값2)
# 위의 딕셔너리는 키가 문자열이여도 따옴표를 하면 안됩니다.
# 딕셔너리 = dict(zip([키1, 키2], [값1, 값2]))
# 위의 딕셔너리는 리스트대신 튜플을 사용해도 됩니다.
# 딕셔너리 = dict([(키1, 값1),(키2, 값2)])
# 위의 딕셔너리는 키와 값의 형태는 튜플이어야 됩니다.
# 딕셔너리 = dict({키1: 값1, 키2: 값2})
# 위의 딕셔너리는 dict안에서 중괄호({})로 딕셔너리를 생성합니다.

딕셔너리의 키에 접근하고 값을 할당하는 방법으로는 키 값을 확인 후 값을 바꾸고자 하는 키에 접근을 하여 값을 할당하는 방식으로 값을 할당합니다.

>>>a = {'key1': 8080, 'key2': 443}
>>>a['key1']
8080
>>>a['key1'] = 80
>>>a['key1']
80

# 딕셔너리[키] # 키 값 확인
# 딕셔너리[키] = 값 # 키 값의 값을 할당

여기서 없는 키에 값을 할당하면 해당 키와 값이 추가되고, 없는 키를 가져오려 하면 에러가 발생됩니다.

딕셔너리에 키가 있는지 확인하기 위해서 in 연산자를 사용해 확인할 수 있으며 반대인 경우는 not in 연산자를 이용하여 키가 없는지 확인할 수 있습니다.

키의 개수 확인은 len함수를 이용하여 len(딕셔너리)의 형태로 키의 개수를 구할 수 있습니다.

 

7. 정리

파이썬에서의 값이 같다는 등호는 ==입니다.

객체의 비교에서는 값은 같더라도 자료형이 같지 않으면 다른 것입니다.

비교 연산자와 논리 연산자가 같은 식에 있으면 비교 연산자부터 판단 후 논리 연산자를 판단해야 됩니다.

논리 연산자 중 결과를 뒤집는 연산자는 not연산자입니다.

국어, 영어, 수학, 과학의 과목 중 한 과목이 50점 미만이면 불합격일 때, 합격을 True, 불합격을 False가 출력되는 코드

korea, english, math, science = map(int, input().split())

print(korea >= 50 and english >= 50 and math >= 50 and science >= 50)

문자열을 표현하기 위해서는 따옴표(', ", ''', """)가 있습니다.

여러 줄로 문자열을 표현하기 위해 따옴표 3개(''', """)를 사용해야 합니다.

문자열 안에 따옴표를 넣기 위해 문자열을 묶은 따옴표와 반대되거나 따옴표 3개를 아용하여 문자열을 묶어줘야 합니다.

변수에 여러 줄을 출력하는 문자열을 넣어 출력하는 코드

a = '''안녕하세요

문자열입니다.'''

print(a)

리스트를 만드는 방법은 대괄호([])로 값을 묶거나 list()를 이용하여 리스트를 생성합니다.

튜플을 만드는 방법은 괄호(())로 묶거나 쉼표를 이용하여 값들을 구분하거나, tuple()을 이용합니다.

range를 이용하는 방법에는 증가폭을 활용하여 원하는 범위에 원하는 숫자의 규칙을 넣어 사용할 수 있습니다.

[5, 3, 1, -1, -3, -5, -7, -9] 리스트가 출력되기 위한 코드

print(list(range(5,-10,-2)))

시퀀스 자료형은 in, not in, *, +, len 등을 활용할 수 있습니다.

시퀀스 객체에서의 인덱스 값은 0부터 시작합니다.

증가폭은 사용한 요소 추출에서의 끝 인덱스에서 -1 한 만큼의 인덱스까지 참조합니다.

읽기 전용 시퀀스 객체를 구분할 수 있어야 합니다.(range, 튜플, 문자열)

리스트 year에 연도, population에 서울시 인구수가 입력될 때, 최근 3년간 연도와 인구수가 리스트로 출력되는 코드

year = map(int, input().split())

population = map(int, input().split())

print(year[-3:], population[-3:])

딕셔너리의 생성은 중괄호({})를 이용하거나 dict함수를 사용합니다.

딕셔너리의 키를 출력하기 위해 딕셔너리[키]의 형태를 사용합니다.

딕셔너리에 없는 키를 할당하면 해당 키와 값이 추가됩니다.

키의 개수를 확인하기 위해 len을 사용합니다.

딕셔너리를 이용해 게임 캐릭터 체력(health)과 속도(speed)가 출력되는 코드

game={'health': 500, 'mana': 300, 'speed': 300}

print(game['health'], game['speed'])