Tarel_base

1. 입력

지금까지 우리는 print를 통해서 값을 출력하는 것만 해보았다.

이번엔 직접 입력해보자

number = input()

number라는 변수는 입력받은 값이다.

실제로 실행해보면 값을 입력하라는 말이 나온다.

근데 이대로 사용하면 아무런 말도 없이 컴퓨터가 그저 입력받기를 기다린다.

조금 다듬어보자

number = input('숫자를 입력해 주세요')

숫자를 입력해 달라는 메시지와 함께 입력을 기다리고 있는 모습을 볼 수 있다.

그리고 입력하고 엔터를 누르면 그대로 끝난다.

입력받고 뭔가 하라는 지시가 없으니 어찌보면 당연한 것

이번엔 입력받은 값을 어떻게 해든 사용해보자

number = input('숫자를 입력해 주세요 > ')

print(number * 5)

입력받은 값을 5를 곱한 값을 출력하도록 지시했다.

겸사겸사 내용도 살짝 바꾸어주었다.

그렇다면 10을 입력하면 50이 나올 것이다.

그러나 실제로 나오는건 10을 5번 출력한 것이 나왔다.

이는 입력받은 값을 숫자가 아닌 문자열로 인식했기 때문에 발생하는 문제다.

입력받은 값을 숫자로 해주자

number = int(input('숫자를 입력해 주세요 > '))

print(number * 5)

이제 정상적으로 나온다.

단, 숫자가 아닌 문자를 입력할 경우 에러가 발생하므로 주의하자

2. 다중입력

한 번에 두개의 값을 받아보자

a, b= input('두 영단어를 입력하세요 > ').split()

print(a)
print(b)

약간 편법을 사용해서 두개의 값을 받아보았다.

이것은 입력 받은 값을 공백을 기준으로 나누어서 각각 a와 b에 할당하는 방식이다.

그런데 이건 입력 받은 값에 공백이 없거나 2개 이상이면 에러가 난다.

이번엔 다중입력을 제대로 받아보자

inputs = list(map(str, input('뭐든지 입력해보거라 > ').split()))

print(inputs)

위 코드는 띄어쓰기를 기준으로 나누어서 입력받고 그렇게 받은 값을 리스트에 넣는 코드다

"가나 초콜릿 맛있어"를 입력하자 가나, 초콜릿, 맛있어 로 나뉘어서 값을 받은 것을 알 수 있다.

문자열이 아닌 정수를 얻고 싶다면 위 코드에서, str 대신 int를 받아주면 된다.

당연하겠지만 int로 바꿔준 상태에서 문자를 입력하면 에러가 난다.

3. 파일 입출력

코드만으로 txt 파일을 만들어보자

file = open('sample.txt', 'w', encoding='utf-8')

file.write('안녕하세요~')
file.write('첫번째 파일!!')

file.close()
print('sample.txt 파일이 만들어졌습니다')

만들고자 하는 파일의 이름은 sample.txt이며

파일을 새로 만들며

인코딩은 uft-8로 한다.

인코딩을 정해주지 않을 경우, 아스키코드로 인코딩 되는데

이러면 한글이 몽땅 다 깨져버리므로 반드시 utf-8로 해주자

open의 두번째 파라미터를 보면 w라고 되어 있는데

이는 새로 만드는 것을 의미한다.

만약 w가 아닌 a로 할 경우, 기존의 내용에 추가하는 형태로 작성된다.

즉, a로 하고 이 코드를 여러번 실행할 경우, "안녕하세요~ 첫번째 파일!!"이라는 문자열이 여러개 생긴 것을 볼 수 있다.

3-1. 파일 경로

그런데 파일이 생성되는 경로를 지정해 주지 않았다.

이 경우, 실행 경로에 파일이 생성되는데, 이번엔 내가 원하는 경로에다가 파일을 생성해 보자

file2 = open('C:/DEV/sample01.txt', 'w', encoding='utf-8')

file2.write('안녕하세요~\n')
file2.write('두번째 파일이다.\n')
file2.write('절대경로 파일\n')

file2.close()
print('sample01.txt가 생성되었습니다.')

DEV 폴더에 sample01 파일이 생성된 것을 확인할 수 있다.

그런데 이건 절대경로로 파일을 생성한 것이고 경우에 따라 상대경로로 파일을 만들어야할 필요가 있다.

상대경로를 만들기 전에, 잠시 디렉토리를 살펴보자

최상위 폴더는 STUDYPYTHON2023이고 그 안에 Day01, Day02, Day03, Day04, Day05 폴더가 있으며

파일 생성 코드는 Day05폴더의 code33_fileio.py에 있다.

그 파일에는 다음의 코드가 있다.

file3 = open('./Day05/../Day04/sample05', 'w', encoding='utf-8')

file3.write('안녕하세요~\n')
file3.write('두번째 파일이다.\n')
file3.write('상대경로 파일\n')

file3.close()
print('sample05.txt가 생성되었습니다.')

이 파일을 실행하면 sample05파일이 어디에 생성될까?

Day04 폴더에 생성된 것을 볼 수 있다.

./는 실행하는 지금의 위치인 STUDYPYTHON2023 폴더를 말하고 여기서 Day05에 들어갔다.

../는 현 경로에서 위로 올라가는 것을 말하는데 Day05폴더에서 ../를 했으므로 다시 STUDYPYTHON2023 폴더로

돌아왔다.

여기서 다시 Day04폴더로 들어가서 파일을 생성했으므로 Day04폴더에 파일이 생성되는 것이다.

3-1. 파일 읽기

바로 위에서 생성한 sample05.txt를 읽어와 보자

file = open('./Day04/sample05.txt', 'r', encoding='utf-8')

text = file.readline()
print(text)

while True:
    text = file.read()
    if not text: break
    print(text)

file.close()

# 실행결과
# 안녕하세요~
# 두번째 파일이다.
# 상대경로 파일

이번엔 open메소드의 파라미터에서 r을 사용한 것을 알 수 있다.

마지막의 file.close()는 꼭 해주어야 한다.

그나마 파이썬에선 해주지 않아도 알아서 닫아지는것 같으나 타 언어에선 그러지 않는 모양이며

닫지 않을 경우, 다음에 열 때 문제가 있을 수 있다고 한다.

고로 한 번 열었던 파일은 늘 닫아주자

1. 기본 모듈 가져오기

파이썬에는 기본적으로 지원하는 모듈이 있고

개발자가 직접 만들 수도 있다.

지금은 파이썬에서 지원하는 모듈을 가져와보자

1-1. math 모듈 가져오기

파이썬에선 수학적인 계산을 위해서, math라는 모듈을 지원한다.

이것을 가져와서 사용해보자

import math as m        #수학모듈 사용하기, math를 m으로 줄인다.

print(m.pi)
print(m.tan(0))
print(m.ceil(3.78))
print(2 ** 10)
print(m.pow(2, 10))

# 실행결과
# 3.141592653589793
# 0.0
# 4
# 1024
# 1024.0

import 키워드를 통해서 math를 가져왔다.

그런데 math라는 이름이 길어서 마음에 들지 않아서 이를 m으로 줄였다.

만약 math라는 이름을 그대로 사용하고 싶다면 그냥 import math 라고만 적어주면 된다.

아무튼 여기선 math가 m이라는 키워드로 축약되었고 m에는 많은 메서드가 있다.

이 math에서 어떤 것들을 사용하는지 궁금하다면 math라는 글자를 ctrl 키를 누른체로 눌러보면 알 수 있다.

보시다시피 내부 문서가 꽤나 길다.

그리고 이 문서 내부 함수를 보면 acos, acosh 등이 있으며 사진에는 나오지 않았지만 이 아래에도 잔뜩 있다.

이 함수가 math가 지원하는 함수이므로 우리는 math를 통해 무엇을 할 수 있는지 알 수 있다.

math문서에 들어가서 알아보는 것이 귀찮다면 굳이 들어가보지 않아도 된다.

이렇게 축약된 키워드만 가져와도 자동완성에 사용할 수 있는 기능들이 나열된다.

1-2. random 모듈 가져오기

이번엔 random 모듈을 가져와서 간단한 로또번호 추첨기를 만들어보자

import random

numbers = [i for i in range(1, 46)]
lottery = []

for i in range(6):
    lottery.append(random.choice(numbers))

print(lottery)

# 실행결과
# [21, 38, 32, 23, 16, 1]

이 로또추첨기는 중복을 제외하지 못하는 등 여러 부실한 부분이 있지만

어디까지나 예시이므로 간단하게만 보고 넘어가자.

2. 내가 만든 모듈 가져오기

나는 code17_calculator.py (이하 code17)라는 계산기 코드를 만들었고 이걸 모듈로써 code_28_use_calculator.py파일(이하 code28)에서 사용하고자 한다.

우선 code17 계산기 코드부터 살펴보자

def calc (option, *args):
    result = 0
    if option == 'add':
        for i in args:
            result += i
    elif option =='sub':
        result = args[0]
        for i in args[1:]:
            result -= i
    elif option == 'mul':
        result = 1
        for i in args:
            result *= i
    elif option == 'div':
        result = args[0]
        for i in args[1:]:
            result /= i
    return result

def new_calc(x,y):
    return (x * y , x / y, x+y, x-y)

이 코드는 calc 함수에서 option 값이 add냐 sub냐 mul이나 div냐에 따라, 추가로 입력받은 값을 사칙연산하는 코드다.

이걸 code28에서 임포트 해서 사용해보자

from code17_calculator import *

print(calc('add',5,7,17))

# 실행결과
# 29

from에는 파일 이름을 넣는다.

그리고 import에는 불러올 함수를 적는데 만약 모든 함수를 가져오고 싶다면 위와 같이 *을 넣으면 된다.

이제 code17의 calc 함수와 new_calc 함수를 사용할 수 있게 된다.

3. 모듈

파이썬에는 메인에 해당하는 파일이 있다.

내 폴더 안의 수 많은 파이썬 파일 중, 실행 한 파일이 메인이 된다.

위 사진을 보면 Day05라는 폴더에 여러가지 파이썬 파일이 있다.

이때, code30_module_main.py를 실행하면 이 파일이 메인이 된다.

print(f'code30_module_name:{__name__}')

# 실행결과
# code30_module_name:__main__

code30_module_main.py의 내용이다.

실행하면 이 파일이 메인임을 나타내고 있다.

이번엔 code29에 같은 내용을 적고 code30에다 임포트를 하고 code30 파일을 실행해보자

# code29_module_main.py 파일의 내용
print(f'code29_module_name:{__name__}')

# code30_module_main.py 파일의 내용을 아래처럼 수정
import code29_module_main

print(f'code30_module_name:{__name__}')

이제 code30_module_main.py를 실행하면 다음과 같이 나온다.

# 실행결과
code29_module_name:code29_module_main
code30_module_name:__main__

실행한 파일인 code30_module_main.py가 main이 되고 29번 파일은 다른걸로 바뀐 것을 알 수 있다.

1. 객체지향

많은 언어가 객체지향 언어이며 다른 종류로는 절차지향 언어가 있고 절차지향 언어로 C가 있다.

절차지향에 대해선 해당 언어를 배울 때 다시 알아보도록 하고

Python은 객체지향이므로 객체지향에 대해 알아보자

객체를 한 마디로 요약하면 변수와 함수의 집합이라고 정의할 수 있다.

다시, 문과적감성으로 접근하자면 객체란 세상에 존재하는 모든 것은 객체라고 정의할 수 있고 프로그램상에서 사용되는 많은 것들이 객체라고 할 수 있다.

객체지향의 핵심은 캡슐화에 있다.

예를들어, 내가 회사의 사장이고 청소를 담당하는 직원이 있다고 가정해보자

이 직원은 내가 청소 장소와 시간, 도구를 입력(지시)하면 해당 장소를 청소하고 청소하기 전에 작업계획서를

작성해서 나에게 전달(반환)해야 한다.

여기서 직원은 객체다.

청소를 담당하는 직원은 한 명이 아닌 여러명일 수도 있다.

그리고 이러한 청소 담당 직원에게 청소도구와 청소 장소와 제한시간을 지시(입력)하면 해당 명령을 수행할 것이며

자신의 작업계획서를 작성해 나에게 줄 것이다.

이렇게 직원은 자신이 담당한 기능을 수행하는데 그것과는 별개로, 우리는 직원의 주민번호라던가

그 직원이 무슨생각을 하고있는가 등은 알 수 없으며 이는 직원들 간에도 마찬가지다.

직원은 오로지 명령을 입력받고 수행하고 결과물 나에게 줄 뿐이며 이를 수행하기 위해 구체적으로

마음속으로 어떠한 생각을 거쳐서 작업계획서를 작성하는지, 담당 파트의 어디부터 수행할 것인지 등을 떠벌리지 않는다.

직원뿐만 아니라 주변 사물의 모든 것이 다 포함된다.

우리는 자판기의 사용법을 알지만 그것의 구체적인 작동 순서나 원리는 모른다.

우리는 자동차의 운전법을 알지만 그것의 구체적인 작동 순서나 원리는 모른다.

이처럼 어디까지나 입출력(또는 사용)은 자유롭게 하 되, 그 내부에서 뭔 일이 벌어지는지는 알기 힘들고

무엇보다 함부로 거기에 간섭하지 못한다.

이것이 객체지향에서 중요시하는 캡슐화라고 할 수 있다.

2. 클래스

게임으로 비교해보자

오버워치에 등장하는 라인하르트는 그 자체로 객체이다.

라인하르트는 로켓헤머라는 무기를 가지며 625의 체력을 가지며 1200내구도의 방패를 가지고 탱커라는 포지션에 해당한다.

이를 파이썬으로 표현하면 대충 다음과 같이 나온다.

class Rein:
    name = '라인하르트'
    weapon = '로켓헤머'
    position = 'Tanker'
    hp = 625
    shield = 1200

    def move():
        print('이동')
    def attack(option):
        if option == '공격1':
            print('로켓헤머')
        elif option == '공격2':
            print('화염강타')
        elif option == '공격3':
            print('망치나가신다.')
    def defence():
        print('방벽 활성화')

그런데 오버워치에는 라인하르트만 있는 것이 아니다.

고로 모든 캐릭터를 만들기 위해 나름 범용성있게 클래스를 구성해보자

class character:
    name = ''
    position = ''
    max_hp = 200

    def attack1(self, option):
        print(f'{self.name} 은 {option}을 시전!')
    def attack2(self, option):
        print(f'{self.name} 은 {option}을 시전!')
    def attack3(self, option):
        print(f'{self.name} 은 {option}을 시전!')
    def attack4(self, option):
        print(f'{self.name} 은 {option}을 시전!')
        
Rein = character()
Rein.name = '라인하르트'
Rein.position = ''
Rein.max_hp = 625

이제 character라는 클래스는 여러가지 캐릭터를 만드는 것에 사용할 수 있다. 

3. 마법함수(매직 메서드)

함수를 만들 때, 우리가 함수를 새로 만들어 줄 수도 있지만 파이썬에서 기본적으로 지원해주는 함수가 있다.

이 매직 메서드는 공통적으로, 특정 단어 앞 뒤로 언더바가 2개씩 붙어있다.

이러한 매직 메서드는 20개 정도 있다.

def를 입력하고 언더바를 두 번 입력하면 어떠한 마법함수가 있는지 알 수 있다.

당연하겠지만 전부 다 익힐 필요는 없지만 대부분이 파이썬에 내장함수와 같은 기능을 개발자가 클래스에서 다시 정의하여 쓸 수 있게 해주는 메서드이다.

__init__은 객체 초기화 동작을 정해줄 때 사용한다.

예를들어서 아래 person이라는 클래스가 있다.

# 클래스 생성
class Person:
    name = '익명'
    height = ''
    gender = ''
    blood_type = 'A'

    def __init__(self, name, height, gender, blood_type):
        self.name = '홍길동'
        self.height = '170'
        self.gender = 'male'
        self.blood_type = 'A'
       
    def walk(self):
        print('걷기')
    def run(self, option):
        if option == 'Fast':
            print(f'{self.name}은 전속력으로 달립니다!')
        else:
            print(f'{self.name}은 천천히 달립니다!')
    def stop(self):
        print(f'{self.name}멈춰!')

__init__ 함수에 이름과 키, 성별과 혈액형에 대한 기본 값이 정해져 있다.

이 함수를 사용해보자

Tarel = Person()
# Tarel.name = 'Tarel'
Tarel.height = 170
Tarel.gender = 'male'
Tarel.blood_type = 'B'


print(f'{Tarel.name}의 혈액형은 {Tarel.blood_type} 입니다.')

먼저 Tarel이라는 함수가 Person이라는 클래스를 사용한다고 선언해주자

그런 다음, 키와 성별, 혈액형을 정해주고 이름은 빼보자

이럴 경우, 출력결과는 홍길동이라고 나온다.

홍길동이라는 이름이 기본값으로 되어 있기 때문이다.

3-2. 매직메서드 예시

위의 예시는 난해하므로 새로운 예시를 가져와 보자

# 자동차 클래스
class Car:
    number = '12나 1234'

    def __init__(self) -> None:
        print('__init__')

    def __new__(cls):
        print('__new__')
        return super().__new__(cls)

    def __str__(self) -> str:
        return f'내 차번호는 {self.number} 입니다.'

    def get_number(self) -> str:
        return self.number

mycar = Car()
print(mycar)
print(f'제 차는요 아반떼고 번호가 {mycar.get_number()} 입니다.')

# 실행결과
# __new__
# __init__
# 내 차번호는 12나 1234 입니다.
# 제 차는요 아반떼고 번호가 12나 1234 입니다.

이번엔 Car라는 클래스를 만들었다.

__init__은 초기화에 사용된다.

__new__는 초기화 전에 생성할 때 사용한다. 실행결과 보면 __new__가 먼저 실행된 것을 알 수 있다.

단, __new__는 잘 사용하지 않으며 특수한 경우에만 사용한다.

이제 클래스 안의 number를 바꾸어보자

__new__는 필요 없으므로 지우자

class Car:
    __number = '12나 1234'

    def get_number(self):
        return self.__number

    def set_number(self, number):
        self.__number = number
        
    def __init__(self, number = '12나 1234') -> None:
        self.__number = number
        print('__init__')

    def __str__(self) -> str:
        return f'내 차번호는 {self.__number} 입니다.'

yourcar = Car('88호 8888')
print(yourcar)
yourcar.__number = '바뀐번호 1111' #외부에서는 값을 바꿀 수 없음
print(yourcar)
print('클래스 내부함수 사용!')
yourcar.set_number('셋넘버로 바꿈 2222')
print(yourcar)

# 실행결과
# __init__
# 내 차번호는 88호 8888 입니다.
# 내 차번호는 88호 8888 입니다.
# 클래스 내부함수 사용!
# 내 차번호는 셋넘버로 바꿈 2222 입니다.

yourcar 변수에서 __number에 직접 접근해서 값 변경을 시도하자 전혀 먹히지 않았다.

그러나 내부 함수인 set_number 함수를 통해서 접근하자 __number의 값이 바뀐 것을 알 수 있다.

이렇게 클래스는 내부의 값이 외부에서 간섭을 받지 않으며 오직 내부 함수를 통해서만 접근 및 변경할 수 있다.

이 또한 캡슐화라고 할 수 있다.

1. 가상환경

파이썬에서는 pip라는 패키지 관리자를 통해서 필요한 패키지(라이브러리)를 설치하고 관리한다.

pip란 파이썬 패키지 관리자로 Node.js의 npm과 유사하고 C#의 NuGet패키지와 같은 역할을 한다.

pip 명령어로 파일을 설치, 관리한다.

pip install [옵션] <요구사항파일> [패키지 인덱스 옵션]
pip install [옵션] -r <요구사항파일> [패키지 인덱스 옵션]
pip install [옵션] [-e] <vcs 프로젝트 URL>
pip install [옵션] <아카이브 URL/경로>

삭제는 install 대신 uninstall 하면 된다.

예를 들어 django 패키지를 설치한다면

pip install django

를 입력해 설치할 수 있다.

여기서 문제가 발생할 수 있다.

예를 들어 a라는 패키지는 버전이 3.0이고 이걸로 dev01을 개발했다고 가정해보자

이어서 dev03을 개발하려고 하는데 패키지의 버전이 5.0으로 업그레이드가 되었다.

그런데 a패키지는 3.0과 5.0의 차이가 많아서 호환이 안 된다.

이 경우 dev01은 어떻게 될까?

당연히 사용할 수 없게 된다.

이러면 굉장히 난감해질 수 밖에 없다.

이러한 버전 충돌 문제는 개발자가 해결하기 굉장히 난해할 수 있는데

이를 위해서 나타난 것이 바로 가상개발환경(virtual Environment)이다.

가상환경은 개발자가 필요한 개발 영역마다 파이썬 실행을 위한 가상환경을 다시 재창조 함으로써 이 문제를 한번에 해결할 수 있게 된다.

위 그림을 보자, 가상환경이 총 3개가 있는데 저마다 파이썬의 버전이 다르다.

또한 안의 라이브러리도 재각각이다.

이렇게 필요한 환경이 여러개가 있고 그 환경들을 스위칭해서 사용할 수 있게 해주는 것이 가상환경이다.

가상환경을 설치해보자

CMD를 실행하고 설치하고자 하는 폴더로 이동하고 파이썬 가상환경을 설치해보자

나는 C:\Source\studyPython2023 위치에 설치할 것이다.

cd C:\Source\studyPython2023

경로를 바꾸어 주고

pip install virtualenv

virtualenv를 설치하자

virtualenv venv

이 명령으로 환경을 스위칭 할 수 있다.

자 이쯤되서 파일을 살펴보자

왼쪽은 글로벌환경, 즉 파이썬이 설치된 폴더의 Lib 폴더 내부 모습이다.

오른쪽은 가상환경을 설치한 폴더의 venv 폴더의 Lib 폴더 내부의 모습이다.

즉, 다른환경이 만들어진 것이다.

이제 가상환경을 실행해보자

windows 10등에서 가상환경이 실행되지 않을 수 있다.

이는 OS의 관리자 권한에서 사용이 막혀있기 때문이다.

cmd 대신 windows PowerShell을 실행해보자

cmd랑 비슷한데 마이크로소프트에서 cmd를 업그레이드를 한 것이다.

단, 이것을 관리자권한으로 실행해야 한다.

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned

정책을 바꿔서 실행할 수 있다.

이제 VS-CODE로 넘어가서

venv폴더의 Scripts 폴더로 들어간 다음, 다음을 입력해주자

.\activate.bat
.\activate.ps1

이 사진처럼 왼쪽에 (venv)가 나타나면 가상환경이 성공적으로 실행된 것이다.

만약 안된다면 터미널을 모두 정리하고 새로운 터미널을 열어서 해보자

자, 이제 가상환경 전용 파이썬을 설치해 주자

python
import.sys
sys.executable

이로써 가상환경에 사용할 전용 python이 생겼다.

이제 이 경로에서 pip를 통해 패키지를 설치하면 이 가상환경에서만 설치가 된다.

여기에 django를 설치하고 파이썬 전역폴더와 이 가상환경을 비교해보자

python311 폴더의 Lib 폴더의 site-packages폴더와

내 작업 폴더의 venv 폴더의 Lib 폴더의 site-packages 폴더를 비교해보자

왼쪽이 글로벌 폴더, 오른쪽이 가상환경이다.

가상환경부분에는 Django 폴더가 있지만 글로벌 폴더에는 없는 것을 볼 수 있다.

1. 함수

함수는 일종의 기능을 가진 장치라고 할 수 있다.

예를 들어, 토스트기에 빵을 넣고 시간을 입력하면 구워진 빵을 만들어낸다.

토스트기에 뻥튀기를 넣으면 구워진(?) 뻥튀기가 만들어질 것이다.

여기서 토스트기가 함수

토스트기에 넣은 빵이나 뻥튀기, 구울 시간은 파라미터(매개변수)

토스트기가 내놓은 결과물인 구워진 빵이나 구워진 뻥튀기는 리턴값(반환값)이라고 할 수 있다.

파이썬에서 함수를 선언할 때는 def라는 키워드를 사용한다.

역시나 다른언어들과는 다르게 중괄호를 사용하지 않는다.

def add(x,y):
    result = x + y
    return result

add 라는 이름의 함수를 선언했다.

그리고 이 함수는 x와 y를 매개변수로 받는다.

그렇게 받은 x값과 y값을 더해서 result로 정의한다.

그리고 그렇게 만들어진 result를 결과로써 내놓는다.

즉, add 함수는 입력받은 값을 더해주는 함수이다.

자, 함수를 만들었으니 이제 사용해 보자.

def add(x,y):
    result = x + y
    return result

val = add(1024, 5)
print(val)

# 실행결과
# 1029

add 함수에 1024와 5를 넣어서 얻은 값을 val이라는 변수에 넣는다.

그리고 그것을 출력해보면 1029가 나오는 것을 알 수 있다.

함수에 파라미터와 리턴은 필수가 아니다.

즉 파라미터가 없는 함수가 있을 수 있고 리턴이 없는 함수가 있을 수 있다.

2. 매개변수의 수가 일정치 않은 함수

매개변수를 몇개나 받을지 알 수 없는 경우, 다음과 같이 사용할 수 있다.

def add(*args):
    result = 0
    for i in args:
        result += i
    return result
   
print(add(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15))
print(add(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35))

# 실행결과
# 120
# 630

add 함수는 받은 파라미터 값을 전부 더하는 함수다

아래 print에서 add 함수를 호출하고 있는데 보시다시피 파라미터를 잔뜩 넣는 것을 알 수 있다.

그러나 얼마나 많은 파라미터를 넣든, 받은 파라미터를 전부 더해서 그 결과를 출력하는 것을 볼 수 있다.

3. 간단한 계산기 만들기

위 함수기능과 조건문을 활용해 계산기를 만들어 보자

def calc (option, *args):
    result = 0
    if option == 'add':
        for i in args:
            result += i
    elif option =='sub':
        result = args[0]
        for i in args[1:]:
            result -= i
    elif option == 'mul':
        result = 1
        for i in args:
            result *= i
    elif option == 'div':
        result = args[0]
        for i in args[1:]:
            result /= i
    return result

더하기, 빼기, 곱하기, 나누기 기능을 갖춘 계산기가 완성되었다.

calc 함수에서 option에 무엇을 사용할지 작성하고 계산하고자 하는 인자를 넣어주면 된다.

위 함수는 아래 처럼 사용할 수 있다.

print(calc('add', 4, 3, 7))
print(calc('mul', 42, 128))
print(calc('sub', 8, 7, 17))
print(calc('div', 5, 32))

# 실행결과
# 14
# 5376
# -16
# 0.15625

단, 이 계산기는 0으로 나누면 에러가 발생한다.

이런건 예외처리를 해주어야 하는데 이는 다음에 알아보자

4. 여러개 리턴하기

파라미터와는 다르게 리턴값의 수는 가변형이 될 수 없지만 여러개를 리턴하는 것은 가능하다.

이 기능을 사용하여 위 계산기의 복잡한 코드를 훨씬 간결하게 줄일 수 있다.

아래 코드를 참조하자

def new_calc(x,y):
    return (x * y , x / y, x+y, x-y)

res1, res2, res3, res4 = new_calc(42,128)
print(res1,res2, res3, res4)

이 mul_and_div 함수는 값을 두 개 입력받으면 그 두 수를 곱한 값과 나눈 값과 더한 값, 뺀 값 4 개를 반환한다.

그리고 res1, res2, res3, res4 변수에 그 값들을 각각 할당하고

print를 통해서 출력한다.

아까 만든 계산기 코드보다 훨씬 간결한 것을 볼 수 있다.

5. 지역변수와 전역변수

변수는 그 변수가 영향을 끼치는 범위가 있다. 아래 코드를 보자

a = 1

def vartest(a):
    a = a + 1
    return a

a = vartest(a)
print(a)

# 실행결과
# 2

여기서는 a라는 변수만 사용되었다.

그런데 a 변수가 이름만 같을 분 vartest 함수 내의 a는 함수 밖의 a와는 별개의 변수다.

a변수는 1이라고 정의했다.

그리고 그 a 변수는 vartest함수에서 내놓은 값을 새로 받기로 했다.

vartest 함수는 1이라는 값을 받았다.

그리고 내부 코드에 의해 1이 증가되었고 그렇게 증가된 값 2를 리턴한다.

고로 a변수는 2가 된다.

찬찬히 읽어봤으면 알겠지만 함수 내의 a와 밖의 a는 별개의 변수라는 것을 알 수 있다.

이렇게 함수 내에서만 사용하는 변수가 지역변수, 밖에서 사용되는 것을 전역변수라고 한다.

그렇다면 함수 안에서 함수 밖의 a를 쓰고자 한다면 어떻게 할까?

a = 1

def vartest():
    global a
    a = a + 1
    return a

a = vartest()
print(a)

파라미터의 a를 없애주고 global 키워드를 사용해서 함수 밖의 a값을 가져왔다.

이제 vartest안의 a값은 함수 밖의 a값을 가져와서 사용한다.

만약 파라미터의 a를 없애주지 않을 경우, 컴퓨터가 어느쪽이 메인 a값인지 알지 못해 에러가 발생한다.

6. 람다 함수

한 번 쓰고 버릴 함수를 람다 함수라고 한다.

굳이 왜 쓰는지는 모르겠지만 일단 알아두자

# 일반함수
def add(x,y):
    return x+y

print(add(7,4))

# 람다함수
print((lambda x,y: x+y)(7,4))

위 코드에서, 일반함수나 람다함수나 기능은 똑같다.

물론 람다함수는 저 프린트 문 안에서 사용하고 그대로 끝이다.

굳이 이런게 필요한지는 모르겠으나 만약 코드가 길어지면서 함수가 많아지거든 이런 람다 함수를 써야할 경우가 있을 수도 있으리라 본다.

7. 내장함수

파이썬 공식 홈페이지에 들어가면 파이썬에서 지원하는 내장함수의 종류에 대해서 알 수 있다.

https://docs.python.org/3/library/functions.html

P항목에 print()가 있는 것을 볼 수 있는데 이를 통해, print도 엄연히 함수라는 것을 알 수 있다.

이 많은 것들을 다 다루지는 않고 필요할 때마다 하나씩 학습하면 된다.

이 부분은 다음에 기회가 되면 다루어 보자

1. if 문

모든 프로그래밍 언어에서 공통적으로 지원하는 조건문부터 시작하자

name = 'Tarel'

if name == 'Tarel':
    print('이름이 Tarel 입니다.')
elif name == 'Tom':
    print('톰과 제리')
else:
    print('이름이 not Tarel 입니다.')

    
# 출력결과
# 이름이 Tarel 입니다.

많은 언어들이 조건문 작성시, 소괄호와 중괄호를 사용하지만 파이썬은 괄호를 사용하지 않고

콜론과 들여쓰기를 활용한다.

만약 들여쓰기를 지울 경우, 바로 에러가 발생하므로 주의할 것

else if 문은 줄여서 elif 라고 쓴다는 점을 주의하자

if는 조건을 말하고 elif는 바로 위의 조건이 아닐때 다른 조건을 제시하여 판별하고

else는 어떤 조건도 만족하지 않을 때 사용하는 부분이다.

2. for 문

마찬가지로 거의 모든 언어가 지원하는 반복문의 기본이다.

arr = [1,2,3,4,5]

for item in arr:
    print(f'{item: 2.2f}')

# 출력결과
# 1.00
# 2.00
# 3.00
# 4.00
# 5.00

여기서 print문은 item의 값을 소숫점 2번째 자리까지 표시한다는 의미다.

여기서 for문은 arr의 값들을 순차적으로 받아와서 item이라는 변수에 넣는다고 생각할 수 있다.

arr = [1,2,3,4,5]
sum = 0

for item in arr:
    sum = sum + item
    print(sum)
    
# 출력결과
# 1
# 3 
# 6
# 10
# 15

arr의 값을 받아와서 sum에다가 넣어서 더해주는 식이다.

처음에는 0에다 1을 받아왔으므로 1이 출력되고

그 다음은 1 에다가 2를 받아왔으므로 3이 출력된다.

참고로 sum = sum + item은 sum += item으로 줄여서 쓸 수 있다.

for문은 다음과 같이 사용할 수 있다.

vals = [1,2,3,4,5,6,7,8,9,10]
vals = [i for i in range(1,11)]

지금 vals가 두 번 선언되어 있는데 위의 vals나 아래의 vals나 똑같다.

즉 1, 2, 3.... 이렇게 일일히 적어주지 말고 for를 사용하여 1부터 10까지 수를 만들어줄 수 있다.

여기서 주의할 점은 1부터 10까지 만들고자 할 경우, 10이 아닌 11을 써주어야 한다는 점이다.

vals = [i for i in range(1,1001)]

#출력결과는 너무 기므로 생략

이 기능을 사용해 이렇게 엄청나게 긴 리스트를 만들어 줄 수도 있다.

2-1 continue, break

반복문을 수행할 때, 특정 조건을 만족하면 반복을 중단하거나 한 단계 건너뛰거나 할 수 있다.

vals = [1,2,3,4,5,6,7,8,9,10]
num = 0

for item in vals:
    num += item
    if num % 2 == 0:
        continue
    else:
        print(num, '번 수는', item, '입니다.')
        
# 1 번 수는 1 입니다.
# 3 번 수는 2 입니다.
# 15 번 수는 5 입니다.
# 21 번 수는 6 입니다.
# 45 번 수는 9 입니다.
# 55 번 수는 10 입니다.

vals의 값을 하나씩 받아와서 num에다가 더하는 반복문이다.

그런데 이때, num의 값이 짝수가 되면 for문의 나머지부분을 스킵하고 다음 반복 단계로 넘어간다.

만약 짝수가 아니라면 print문을 실행한다.

출력결과를 보면 오직 홀수일 때만 print문이 실행된 것을 볼 수 있다.

즉, continue는 반복문 중간 단계 중 몇몇을 넘어갈 때 사용한다.

break는 반복문을 아예 중단할 때 사용한다.

vals = [1,2,3,4,5,6,7,8,9,10]
num = 0

for item in vals:
    num += item
    if num % 2 == 0:
        print('반복문을 중단합니다!')
        break
    else:
        print(num, '번 수는', item, '입니다.')

# 출력결과
# 1 번 수는 1 입니다.
# 3 번 수는 2 입니다.
# 반복문을 중단합니다!

num값이 짝수가 되는 순간 break를 만나서 반복문이 종료되고

그대로 끝나는 것을 알 수 있다.

2-2 간단한 실습, 구구단 만들기

for문을 사용해서 간단한 구구단을 만들어보자

for x in range(1, 10):
    for y in range(1, 10):
        print(f'{x} x {y} = {x * y}')
        
# 실행결과는 생략

1단부터 9단까지 구구단이 나타나는 것을 알 수 있다.

코드를 조금더 개선해 보자

for x in range(1, 10):
    for y in range(1, 10):
        print(f'{x} x {y} = {x * y :>2}', end ='    ')    
    print()
    

# 출력결과
# 1 x 1 =  1    1 x 2 =  2    1 x 3 =  3    1 x 4 =  4    1 x 5 =  5    1 x 6 =  6    1 x 7 =  7    1 x 8 =  8    1 x 9 =  9    
# 2 x 1 =  2    2 x 2 =  4    2 x 3 =  6    2 x 4 =  8    2 x 5 = 10    2 x 6 = 12    2 x 7 = 14    2 x 8 = 16    2 x 9 = 18    
# 3 x 1 =  3    3 x 2 =  6    3 x 3 =  9    3 x 4 = 12    3 x 5 = 15    3 x 6 = 18    3 x 7 = 21    3 x 8 = 24    3 x 9 = 27        
# 4 x 1 =  4    4 x 2 =  8    4 x 3 = 12    4 x 4 = 16    4 x 5 = 20    4 x 6 = 24    4 x 7 = 28    4 x 8 = 32    4 x 9 = 36        
# 5 x 1 =  5    5 x 2 = 10    5 x 3 = 15    5 x 4 = 20    5 x 5 = 25    5 x 6 = 30    5 x 7 = 35    5 x 8 = 40    5 x 9 = 45        
# 6 x 1 =  6    6 x 2 = 12    6 x 3 = 18    6 x 4 = 24    6 x 5 = 30    6 x 6 = 36    6 x 7 = 42    6 x 8 = 48    6 x 9 = 54        
# 7 x 1 =  7    7 x 2 = 14    7 x 3 = 21    7 x 4 = 28    7 x 5 = 35    7 x 6 = 42    7 x 7 = 49    7 x 8 = 56    7 x 9 = 63        
# 8 x 1 =  8    8 x 2 = 16    8 x 3 = 24    8 x 4 = 32    8 x 5 = 40    8 x 6 = 48    8 x 7 = 56    8 x 8 = 64    8 x 9 = 72        
# 9 x 1 =  9    9 x 2 = 18    9 x 3 = 27    9 x 4 = 36    9 x 5 = 45    9 x 6 = 54    9 x 7 = 63    9 x 8 = 72    9 x 9 = 81

기존코드는 구구단이 새로로만 잔뜩 표시되는 반면

이 코드는 가로로 표시될 것이다.

print 부분을 보면 콜론이 추가되어 있는데 이는 우측정렬, 2칸씩 하라는 의미이다.

end에 공백을 넣어줌으로써 줄바꿈을 없앤다.

그리고 for문 밖에 print를 넣어줌으로써 줄바꿈을 넣어준다.

가로로 되어 있는게 싫다면 x와 y를 바꿔줌으로써 새로로 바꿔줄 수 있다.

for x in range(1, 10):
    for y in range(1, 10):
        print(f'{y} x {x} = {x * y :>2}', end ='    ')    
    print()

# 실행결과
# 1 x 1 =  1    2 x 1 =  2    3 x 1 =  3    4 x 1 =  4    5 x 1 =  5    6 x 1 =  6    7 x 1 =  7    8 x 1 =  8    9 x 1 =  9    
# 1 x 2 =  2    2 x 2 =  4    3 x 2 =  6    4 x 2 =  8    5 x 2 = 10    6 x 2 = 12    7 x 2 = 14    8 x 2 = 16    9 x 2 = 18        
# 1 x 3 =  3    2 x 3 =  6    3 x 3 =  9    4 x 3 = 12    5 x 3 = 15    6 x 3 = 18    7 x 3 = 21    8 x 3 = 24    9 x 3 = 27        
# 1 x 4 =  4    2 x 4 =  8    3 x 4 = 12    4 x 4 = 16    5 x 4 = 20    6 x 4 = 24    7 x 4 = 28    8 x 4 = 32    9 x 4 = 36        
# 1 x 5 =  5    2 x 5 = 10    3 x 5 = 15    4 x 5 = 20    5 x 5 = 25    6 x 5 = 30    7 x 5 = 35    8 x 5 = 40    9 x 5 = 45        
# 1 x 6 =  6    2 x 6 = 12    3 x 6 = 18    4 x 6 = 24    5 x 6 = 30    6 x 6 = 36    7 x 6 = 42    8 x 6 = 48    9 x 6 = 54        
# 1 x 7 =  7    2 x 7 = 14    3 x 7 = 21    4 x 7 = 28    5 x 7 = 35    6 x 7 = 42    7 x 7 = 49    8 x 7 = 56    9 x 7 = 63        
# 1 x 8 =  8    2 x 8 = 16    3 x 8 = 24    4 x 8 = 32    5 x 8 = 40    6 x 8 = 48    7 x 8 = 56    8 x 8 = 64    9 x 8 = 72        
# 1 x 9 =  9    2 x 9 = 18    3 x 9 = 27    4 x 9 = 36    5 x 9 = 45    6 x 9 = 54    7 x 9 = 63    8 x 9 = 72    9 x 9 = 81

3. while 문

while문은 for문과 비슷한 반복문이다.

hit = 0

while hit < 1000:
    hit += 1
    print(f"나무를 {hit}번 찍었습니다")
    if hit == 4:
        print('나무가 박살났습니다!')
        break
    else: 
        print("도끼의 내구도가 감소하였습니다.")
print("목재를 흭득하였습니다.")

# 실행결과
# 나무를 1번 찍었습니다
# 도끼의 내구도가 감소하였습니다.
# 나무를 2번 찍었습니다
# 도끼의 내구도가 감소하였습니다.
# 나무를 3번 찍었습니다
# 도끼의 내구도가 감소하였습니다.
# 나무를 4번 찍었습니다
# 나무가 박살났습니다!
# 목재를 흭득하였습니다.

for 문과 다르게 조건을 만족하면 반복 실행하도록 되어 있다.

때문에 조건을 무조건 참으로 만들어 놓으면 무한 반복을 할 수 있다.

1. 연산자

많은 프로그래밍 언어에 사용되는 연산이다.

= 는 할당연산자로 왼쪽에 오른쪽의 것을 넣는다.

== 는 왼쪽과 오른쪽이 같은지 묻는 내용이다.

val = 1
print(val == 1)

# 출력결과
# True

위 내용의 첫 줄은 val 변수에 1을 넣으라는 뜻이고

2번째 줄의  val == 1 은 val이 1이 맞는지를 출력하라는 뜻이다.

val은 1이 맞고 고로 출력시 True가 나온다.

이제 사칙연산을 살펴보자

# 사칙연산
print(1 + 1)
print(1 - 1)
print(10 * 10)
print(1024 / 3) #소수 나누기
print(1024 // 3) #정수 나누기
print(17 % 3)
print(2**10)    #2의 10승

# 출력결과
# 2
# 0
# 100
# 341.3333333333333
# 341
# 2
# 1024

프로그래밍 공부를 해보면 다 알 수 있는 내용이다.

단, 한가지 특이한 부분이 있는데 바로 정수나누기로 이건 쉽게 말해 소숫점을 버린다고 생각하면 편하다.

2. 문자열 연산

문자열에 연산자를 사용해보자

더하기와 곱하기만 지원한다.

first = 'Hello'
second = 'World'
print(first + ' ' + second)

# 출력결과
# Hello World

결과적으로 문자열 이어붙인다.

first = 'Hello'
print(first * 4)

# 출력결과
# HelloHelloHelloHello

Hello라는 문자열을 4번 출력한다.

first = 'Hello'
print(len(first))
print(first[0])

# 출력결과
# 5
# H

len은 length의 약자로 길이를 출력한다.

문자열 변수에 리스트를 붙이면 해당 번째 글자를 출력한다.

즉 first라는 변수는 Hello 라는 문자열을 가지고 있고 이 변수의 0번째 글자는 H이다.

참고로 문자열 길이보다 큰 인덱스를 입력하면 에러가 난다.

first = 'Hello'
print(first[-1])

# 출력결과
# o

음수를 넣으면 마지막 글자 순서대로 간다.

특정 글자를 잘라서 가져올 수도 있다.

아래처럼 현재 시간을 나타낸 변수 current를 시용해 현 시간을 표기하고자 한다면

아래처럼 작성할 수 있다.

current = '2023-01-31 15:14:02' # 현 시간

print(current[0:4]+'년'+current[5:7]+'월'+current[8:10]+'일'+current[11:13]+
		'시'+current[14:16]+'분'+current[17:]+'초')
        

# 출력결과
# 2023년01월31일15시14분02초

3. 리스트 연산

리스트에서 특정 값을 바꾸거나 새로운 값을 추가하거나 없앨 수 있다.

que = [1, 2, 3, 4, 5, 6, 7]
print(que)

que[0] = 7
print(que)

que.append(8)
print(que)

que.insert(0, 0)
print(que)

que.remove(7)
print(que)

# 출력결과
# [1, 2, 3, 4, 5, 6, 7]
# [7, 2, 3, 4, 5, 6, 7]
# [7, 2, 3, 4, 5, 6, 7, 8]
# [0, 7, 2, 3, 4, 5, 6, 7, 8]
# [0, 2, 3, 4, 5, 6, 7, 8]

append는 마지막 칸에 새로운 값을 넣는다.

insert(0,0)은 0번 칸의 값에 0을 넣고 다 오른쪽으로 밀어버린다.

remove(5)는 7값을 가진 가장 왼쪽의 것을 지운다.

4. 문자열 포맷팅

print("I'm so happy {0} you!! {1}".format('to', 'LOVE YOU'))

# 출력결과
# I'm so happy to you!! LOVE YOU

위 방식은 다소 구식이다.

최신식 문자열 포맷팅은 다음과 같다.

print(f"I'm so happy {'to'} you!! {'LOVE YOU'}")

# 출력결과
# I'm so happy to you!! LOVE YOU

이제 변수를 활용해서 바꾸어 보자

text_a = 'PYTHON'
print(f"I'm so happy {text_a} you!! {'LOVE YOU'}")

# 출력결과
# I'm so happy PYTHON you!! LOVE YOU

이렇게 변수를 대신 넣어서 사용할 수 있다.

이번엔 다른 기능을 써보자

pi = 3.141592
print(f"파이값은 {pi} 입니다.")
print(f"파이값은 {pi: 0.02f} 입니다.")
print(f"파이값은 {pi: 10.3f} 입니다.")

# 출력결과
# 파이값은 3.141592 입니다.
# 파이값은  3.14 입니다.
# 파이값은      3.142 입니다.

2번째 print는 소숫점 둘째자리까지 출력하며

3번째 print의 10은 총 10글자로 만들라는 의미이다.

때문에 남는 글자수 만큼 공백이 되어 앞부분을 체운 것이다.

4-1 split, replace

이번엔 split이나 replace를 사용해 문자열 포멧팅을 해보자

full_name = "Hugo MG. Sung"
vals = full_name.split()
print(vals)

vals = full_name.split('.')
print(vals)

print(full_name.replace('Hugo MG.', 'Ashely'))

# 출력결과
# ['Hugo', 'MG.', 'Sung']
# ['Hugo MG', ' Sung']
# Ashely Sung

split는 글자를 잘라서 리스트로 만들어주는 역할을 한다.

이때, 자르는 기준점은 없어지는 것을 볼 수 있다.

replace는 대체하는 역할을 한다.

때문에 Hugo MG가 Ashely로 대체된 결과가 나오는 것을 볼 수 있다.

4-2 공백지우기

lstrip, rstrip, strip 명령으로 공백을 지울 수 있다.

hi = '              AABB            '
print(hi.lstrip()+'|')
print(hi.rstrip()+'|')
print(hi.strip()+'|')

# 출력결과
# AABB            |
#               AABB|
# AABB|

| 를 더하도록 되어 있는데 이는 어디까지나 글자의 끝이 어딘지 표기하기 위한 용도이다.

lstrip은 왼쪽의 공백을, rstrip은 오른쪽의 공백을, strip은 양쪽 모두를 없애는 기능을 한다.

4-3 그 외 find, count, upper, lower

특정 문자열에서, 특정 문자의 위치나 문자의 숫자 등을 출력할 수 있다.

예를 들어, full_name 변수는 "Hugo MG. Sung" 인데 여기서 M은 5번에 위치해 있고

Z는 존재하지 않는다.

이를 코드로 작성하면 아래와 같다.

# 문자열에서 값 찾기
print(full_name)
print(full_name.find('M'))      # find는 해당 단어(문자)의 위치가 어딘지 출력
print(full_name.find('Z'))      # 없을 경우, -1이 출력 됌

print(full_name.count('u'))     # count는 찾는 단어의 갯수를 출력

# 모든 단어를 대소문자로 변경
print(full_name.upper())
print(full_name.lower())


# 출력결과
# Hugo MG. Sung
# 5
# -1
# 2
# HUGO MG. SUNG
# hugo mg. sung

존재하지 않을 경우, -1 이 출력된다.

upper와 lower는 모든 문자를 대문자로, 또는 소문자로 바꾸어주는 명령이다.

1. 변수와 자료형

타 언어와 달리 어떠한 선언자나 자료형 없이 자유롭게 선언한다.

a = "Hello World"
b = 128
c = 3.141592
d = 10/2.6
e = [1,2,3]
f = 0b1010

순서대로 문자열, 정수, 소수, 소수(식으로 작성), 리스트(배열), 정수(이진수) 이다.

print(type(   ))을 사용하여 해당 변수의 자료형이 무엇인지 확인할 수 있다.

val = 'Hello World!'
print(type(val))

# 출력 값
# <class 'str'>

모든 변수에는 id값이 부여되어 있다.

이 값은 실행할 때마다 바뀌는데 값을 print(id(   ))를 사용해서 확인할 수 있다.

val = 'Hello World!'
print(id(val))

# 출력 값
# 2753358083712

출력값은 매번 바뀌기 때문에 알아봤지 큰 의미는 없다.

2. 리스트와 튜플 (배열)

C 계열 언어는 리스트와 배열이 따로 있지만 파이썬에서는 같은 개념이며 배열이라는 말을 안 쓰고 리스트라고 한다.

리스트와 튜플은 거의 비슷하나 상수와 변수와 같은 차이가 있다.

둘 다 배열과 같은 느낌이지만 리스트는 얼마든지 안의 값이 바뀔 수 있지만 튜플은 한 번 정해진 값이 변하지 않는다.

arr1 = [1,2,3]
arr2 = [1.1, 2.2, 3.3]
arr3 = ['Hello', 13, 'World', True]

어떤 값이든 자유롭게 넣는다.

arr4 = []
arr5 = list()

빈 리스트를 선언할 때는 위 처럼 작성한다.

arr4.append(4)
print(arr4)

# 출력결과
# [4]

append를 사용해 새로운 값을 넣어줄 수 있다.

tuple1 = (1,2,3,4)
print(tuple1)

# 출력결과
# (1, 2, 3, 4)

튜플은 소괄호를 사용해서 선언한다.

3. 딕셔너리

여타 언어에도 있는 사전형 자료형이다.

spiderman = {'name' : 'Peter Parker',
              'age' : 18,
           'weapon' : 'Web Shooter'}

spiderman이라는 변수는 각각 name, age, weapon이라는 키를 가지고 있고

각각의 키는 Peter Parker, 18, Web Shooter라는 값을 가지고 있다.

키가 있으면 값도 있으며, 그 수에는 제한이 없다.

참고로 아래처럼 한 줄로 작성해도 된다. 그러나 보기 안 좋기 때문에 위처럼 작성하는 것이다.

spiderman = {'name' : 'Peter Parker', 'age' : 18, 'weapon' : 'Web Shooter'}

이렇게 만들어진 딕셔너리는 다양하게 출력할 수 있다.

print(spiderman)
print(spiderman['weapon'])
print(spiderman['age'])

# 출력결과
# {'name': 'Peter Parker', 'age': 18, 'weapon': 'Web Shooter'}
# Web Shooter
# 18

전체 값을 출력할 수도 있고 특정 키 값만 출력할 수도 있다.

참고로 키 값을 입력할 때, ctrl + spacebar 를 입력하면 해당 변수가 어떤 키를 가지고 있는지 보여준다.

4. 집합

수학의 집합을 처리하기 위해 만든 자료형으로 set이라는 키워드를 사용한다.

set1 = set([1,2,3,4])
set2 = set("Hello World")
print(set1)
print(set2)

# 출력결과
# {1, 2, 3, 4}
# {'d', 'H', 'e', 'W', 'o', ' ', 'r', 'l'}

출력결과가 다소 특이하다.

집합의 특징은 중복을 허용하지 않는다는 것이다.

때문에 Hello World에서 중복되는 값들이 사라졌으며 값이 이리저리 얽힌 것을 볼 수 있다.

실제로 출력값은 매번 시도할 때마다 위치가 바뀐다.

리스트, 튜플, 딕셔너리, 셋은 각각 다른 용도로 사용하나 값을 출력하면

튜플은 소괄호, 딕셔너리와 셋은 중괄호, 리스트는 대괄호를 사용한다는 차이점이 있다.