파이썬 프로그래밍

class Person:

def init(self, name="noname"):

self.name = name

def printing(self):

print("상위 클래스의 메서드")

class Student(Person):

pass

student1=Student()

student1.printing()

print(student1.name) # noname (속성도 상속받을 수 있음)

1. 객체 지향 프로그래밍

• Encapsulation (캡슐화) : 관련 있는 또는 동일한 목적을 달성하기 위한 함수(method)와 데이터를 묶는 것
• Inheritance (상속) : 하위 클래스가 상위 클래스의 모든 속성을 물려받는 것 (밑에서 위로 가는 것, 하위 클래스에서 공통된 속성을 끄집어 올리는 거지)

Library : 이걸로 프로그램 만들 수 없음

Framework : 프로그램 만들 수 있음

Solution : 목적 지향 (학사 관리 프로그램)

• Polymorphism (다형성) : 동일한 메시지에 대하여 다르게 반응하는 성질 ex. GUI → 면접에서 잘 물어본다.
• Dynamic Binding (동적 바인딩) : 실행 중간에 변경할 수 있다.

2. 용어

• Object (객체) : 프로그래밍에서 사용되는 모든 것 → 요샌 이 용어 사용 잘 안 함, 왠만하면 Instance로 말하자.
• Class : 동일한 목적을 달성하기 위한 데이터와 기능의 묶음, Instance를 여러 개 만들기 위해 만듬
• Instance : Class를 기반으로 만들어진 객체, 사례, 실례 (전화번호 부 → class, 그 안에 있는 실제 전화번호 010~: Instance)
• Method : Class 안에 존재하는 기능 (부르는 애가 정해져 있는 게 method, 나만 쓸 수 있도록 접근 제한을 두는 것 → 기능을 class나 instance만 쓸 수 있는 것 : method)
• Attribute : Class 안에 존재하는 데이터 (변수랑 구분하는 편)

3. 클래스가 존재할 때 인스턴스를 생성하는 법

• 클래스이름(매개변수)

⇒ 이때 사용하는 메서드를 생성자라고 한다. ex. my_car = Car( )

⇒ 클래스를 기반으로 메모리 할당을 하고 할당된 메모리의 id를 리턴한다. (이때의 id는 순차적인게 x)

4. 클래스 생성

class 클래스이름:

내용

5. 클래스나 인스턴스가 자신의 속성에 접근하는 방법

• 클래스이름이나 인스턴스 다음에 .을 이용해서 접근

6. Method

• 클래스 안에 만들어서 클래스나 인스턴스가 호출할 수 있도록 해주는 기능(함수)
• 종류
  • 클래스를 가지고 호출할 수 있는 메서드
  • 인스턴스를 이용해서만 호출할 수 있는 메서드 ⇒ 생성하려면 매개변수는 무조건 1개 이상이어야 하고 첫 번째 매개변수는 호출하는 인스턴스의 id가 자동으로 대입된다. ⇒ 첫 번째 매개변수의 이름은 묵시적으로 self고 다른 언어에서는 this나 me라는 이름으로 숨겨져 있다.
  (인스턴스에는 메서드가 없다.)참고) [ ] : 생략 가능, * : 여러 개 넣어줘도 돼
• class - 데이터, 메서드 Instance - 데이터, 자신의 클래스 타입
• 호출
  • 클래스 내부에서는 self.메서드 이름(매개변수)
  • 클래스 외부에서는 두 가지 방법으로 호출 가능
    • 클래스이름.메서드이름(인스턴스, 매개변수) : Unbound 호출 → 권장 x
    • 인스턴스이름.메서드이름(매개변수) : Bound 호출 <인스턴스에서 호출할 땐 self는 자동 전달된다!>

  print(dir(str)) #-> 로 str 클래스에는 무슨 메서드가 있는지 보고
  name = str("adam") # name => 인스턴스
  
  # 이 방법 더 추천, 인스턴스를 이용해서 호출 : self에 데이터를 대입하지 않아도 됨
  print(name.upper()) # ADAM
  # 클래스를 이용해서 호출: self자리에 인스턴스를 대입 -> 권장 x
  print(str.upper(name)) # ADAM
  

7. 속성

: 클래스나 인스턴스 안에 데이터를 저장하기 위해 만든 변수

• 클래스 속성
  • 클래스 내부에 메서드 바깥에 변수를 만들면 클래스 속성이 된다.
  • 클래스 안에 만들어지고 클래스로 접근해서 읽기와 쓰기가 가능
  • 인스턴스를 이용해서는 읽기만 가능하고 쓰기를 하게 되면 인스턴스 안에 인스턴스 속성으로 다시 만들어진다. ⇒ 인스턴스를 이용해서 클래스 속성을 변경할 수 없음
  • 인스턴스와 클래스에 동일한 속성이 존재하는 경우, 인스턴스는 자신의 속성을 호출한다.
• 인스턴스 속성
  • 인스턴스 메서드 안에서 self.변수를 만들면 인스턴스만 접근이 가능한 인스턴스 속성
  • 메서드 안에서 self 없이 만들면 지역 변수가 된다.

class Student:
    # 클래스 속성 - 클래스와 인스턴스 모두 읽기 가능하지만 변경은 클래스를 이용해서만 가능
    schoolName = "우도초등학교"
     def insa(self):
        print("안녕하세요.")

    def printName(self, name):
        # 인스턴스 속성 만들기 - 단, printName을 호출해야만 만들어진다.
        self.num = 1
        print(f"이름은 {name}")
    
student = Student() # 일단은 instance 만들기

print(f"클래스로 접근: {Student.schoolName}, 인스턴스로 접근: {student.schoolName}")
# 클래스를 이용해서 변경 시도
Student.schoolName = "제일 중학교"
print(f"클래스로 접근: {Student.schoolName}, 인스턴스로 접근: {student.schoolName}")
# 인스턴스를 이용해서 변경 시도 -> 클래스로 접근할 땐 변경사항 x
student.schoolName = "최고 중학교"
print(f"클래스로 접근: {Student.schoolName}, 인스턴스로 접근: {student.schoolName}")

# 클래스로 접근: 우도초등학교, 인스턴스로 접근: 우도초등학교
# 클래스로 접근: 제일 중학교, 인스턴스로 접근: 제일 중학교
# 클래스로 접근: 제일 중학교, 인스턴스로 접근: **최고 중학교**

8. is

== 연산자 : 데이터를 비교하기 위한 연산자

is 연산자 : id를 비교하는 연산자

9. Accessor

• 객체 지향 언어에서는 속성에 직접 접근하는 것을 권장하지 않는다.
• 속성에 접근하는 메서드를 별도로 만들어서 사용하는 것을 권장한다.
  • 읽기 위한 메서드 : getter
  • 속성을 리턴한다.
  • 일반적으로 이름은 ‘get속성명’ 으로 하는데 속성명의 첫 글자는 대문자로 작성
  • 타입이 bool인 경우 get 대신에 is를 사용하기도 한다.
  • 속성의 타입이 데이터의 모임인 경우, 부분적으로 가져올 수 있는 메서드를 추가하기도 한다.
  • 로깅 작업을 수행하기도 한다. (어떤 데이터에 누가 접근했는지 기록하는 것)
  • 수정하기 위한 메서드 : setter
  • 일반적으로 이름은 ‘set속성명’ 으로 하는데 속성명의 첫 글자는 대문자
  • 매개변수는 속성과 동일한 데이터 타입으로 하나 추가하고 속성의 값을 수정하는 코드를 작성한다.
  • 특정한 조건을 만족하지 않는 경우, 수정하지 않도록 코드를 추가하기도 한다.
  • 속성의 타입이 데이터의 모임인 경우, 부분적으로 가져올 수 있는 메서드를 추가하기도 한다.
  • 로깅 작업을 수행하기도 한다.

class Student:
    # 클래스 속성 - 클래스와 인스턴스 모두 읽기 가능하지만 변경은 클래스를 이용해서만 가능
    schoolName = "우도초등학교"
    def insa(self):
        print("안녕하세요.")

    def getName(self):
        return self.name
        
    def setName(self, name):
        self.name = name
        
student = Student() # 일단은 instance 만들기
student.setName("김명준")
print(student.getName()) # 김명준

# score set하는 함수
def setScore(self, score):
    if 0 <= score <= 100: # 이런 식으로 예외를 잘 잡아주어야 한다.
        self.score = score
    else:
        print("점수를 잘못 입력하셨습니다.")

10. 특수 속성

: __로 시작하고 __로 끝나는 속성

ex. doc : 함수를 설명하는 속성

11. 초기화 메서드와 소멸자

초기화 메서드 : 생성자 (메모리 할당과 초기화)

• 파이썬에서 초기화 메서드의 이름은 init
• 인스턴스를 생성할 때 자동으로 호출되는 메서드
• 직접 작성하지 않으면 매개변수가 self 하나인 초기화 메서드가 자동으로 만들어진다.
• 작성하면 제공되는 초기화 메서드는 소멸된다.
• 초기화 작업을 편리하게 하기 위해서 생성한다.

소멸자 메서드

• 인스턴스가 소멸될 때 호출되는 메서드
• del 로 만들어야 하고 매개변수는 self만 있어야 한다. (예외 처리할 때 소멸자가 중요해진다. ex. 자바로 file, database, network 서버 작업할 때 로그인을 안 시키고 나감 → 해당 리소스 다시 못 돌려받음. 따라서 반드시 예외 처리 해야 한다.)
• 외부 작업을 할 때는 정리하는 작업을 꼭 해줘야 한다!

인스턴스는 가리키는 애로 이름이 없으면 지워진다.

student = Student()
print(student.getName())
student = Student(name="주니") # -> student = Student() 는 없어진다.
print(student.getName())
student = None # -> 또 가리키는 애가 없어진다.

# 이름 없음
# 인스턴스가 소멸될 때 호출됨
# 주니
# 인스턴스가 소멸될 때 호출됨 -> 그래서 2번 불러지는 것

12. Garbage Collection

파이썬 내부에 Garbage Collection이 존재해서 자동으로 메모리 해제를 수행하기 때문에 사용자가 직접 메모리 정리할 필요 없다.

• 모든 데이터에 reference count를 부여해서 참조 횟수를 저장해 놓는데 참조 횟수가 0이면 해제 대상이 된다. ⇒ 데이터의 참조를 변수에 대입하면 카운트가 1 증가하고 가리키는 변수가 소멸되거나 다른 참조를 대입하면 1이 감소한다.
• 참조 횟수를 확인하는 방법은 sys모듈의 getrefcount 라는 함수에 객체를 대입하면 된다. (이 때 이 함수 자체가 인스턴스를 참조하기 때문에 값은 1 증가해서 나온다.)
• 특별한 경우가 아니면 instance의 참조는 다른 곳에서 하지 않는 게 좋다. (정리가 너무 늦게 될 수 있어서)

student1 = Student() # reference count 1 된다.
student2 = student1  # reference count 2 된다. # 되도록 또 다른 곳에 인스턴스 참조하지 말자.
student1 = None      # reference count 1 된다.
print("소멸되나?")

# 소멸되나?
# 인스턴스가 소멸될 때 호출됨

student1 = Student() # reference count 1 된다.
student2 = student1  # reference count 2 된다. # 이런 거 하지 말자! (또 다른 곳에 인스턴스 참조하는 것))
student1 = None      # reference count 1 된다.
student2 = None      # reference count 0 된다.
print("소멸되나?")

# 인스턴스가 소멸될 때 호출됨
# 소멸되나?

13. 클래스가 호출할 수 있는 메서드

static method

• @staticmethod 로 생성 (데코레이터 이용)
• self 매개변수가 필요 x
• self 가 없기 때문에 인스턴스 속성 사용할 수 x
• 인스턴스가 호출이 가능하지만 하지 x
• 클래스 속성의 초기화에 주로 이용함

class Student:
    @staticmethod # @로 시작: decorator (함수 만들 때 특별한 코드 삽입해서 기능을 추가하는 것)
    def smethod(): # 여기 self 안 써줘도 된다.
        print("static method")

Student.smethod() # static method
# or 인스턴스가 호출이 가능하지만 하지 x
stu = Student()
stu.smethod() # static method

Aspect of Programming (관점 지향 프로그래밍)

⇒ Business Logic 과 Common Concern의 분리 (업무와 공통 코드가 같이 들어가면 유지보수 할 때 굉장히 힘들어진다.)

class method

• @classmethod 라는 데코레이터를 이용해서 생성
• 클래스 자신을 가리키는 매개변수가 1개 있어야 한다. (관례적으로 cls라고 한다.)

14. slots

파이썬의 인스턴스는 클래스에 정의된 속성말고도 필요한 경우 생성이 가능하다.

⇒ 동일한 클래스로 만들어진 인스턴스라도 속성이 다르게 만들어 질 수 있다.

• slots 안에 사용가능한 속성을 저장하면 그 이외의 속성은 생성이 불가능

class Student:
    # 특정한 속성만 인스턴스가 소유하도록 할 때 사용
    __slots__ = ["num", "name"]
    def __init__(self):
        pass

stu=Student()
stu.num = 1
stu.name = "명준" # -> 에러 x

stu1.Student()
stu1.bunho = 1
stu1.irum = "명준" # -> 에러 o

15. private 멤버 명명 규칙

private : 클래스 내부에서 선언해서 클래스 내부에서만 사용 가능하도록 해주는 멤버

• 속성을 생성할 때 두 개의 밑줄을 추가하고 이름을 설정하면 Class 외부에서는 접근이 불가능

class Student:
    def __init__(self, name="noname", age=0):
        self.name = name
        # __붙은 속성 -> 클래스 내부에서는 사용 o, 외부에서는 x
        self.__age = age
    
student1 = Student()
print(student1.name)
print(student1.__age) 
# AttributeError: 'Student' object has no attribute '__age'

class Student:
    def __init__(self, name="noname", age=0):
        # __속성명 -> 클래스 내부에서는 사용 o, 외부에서는 x
        self.__name = name
        self.__age = age

    def setName(self, name):
        self.__name = name
    def getName(self):
        return self.__name
    
student1 = Student()
student1.setName("명준")
print(student1.getName()) # 명준

16. property

변수를 사용하는 것처럼 메서드를 호출하는 문법

• 변수명 = property(fget=None, fset=None, fdel=None, doc=None) fget : getter 지정, fset : setter 지정, fdel : 삭제할 때 호출되는 메서드, doc : 문서화에 사용할 내용

class Student:
    def setName(self, name):
        print("setter 호출")
        self.__name = name
    def getName(self):
        print("getter 호출")
        return self.__name
    name = property(fget=getName, fset=setName)
    
student1 = Student()
student1.name = "명준"
print(student1.name)

# 속성을 이용한 것 같지만 실제로는 함수를 이용한 것
# setter 호출
# getter 호출
# 명준

17. Inheritance

: 하위 클래스가 상위 클래스의 모든 것을 물려받는 것

• 상위 클래스 : supper, base class / 하위 클래스 : sub, derived class
• 하나의 클래스로부터 상속 받는 경우를 단일 상속이라 하고 여러 개의 클래스로부터 상속 받는 것을 다중 상속이라고 한다.
• 목적
  • 프로그래밍 언어 차원에서는 여러 클래스에 공통된 내용이 있어서 이를 하나의 클래스에 정의하고 물려받아서 사용하기 위해서 → 코드가 간결해지고 유지 보수 편리해짐
  • 프레임워크 차원에서는 제공되는 클래스의 기능이 부족해서 필요한 기능을 추가하기 위해서 상속을 사용
• 상속 형식 class 클래스이름(상위 클래스 이름): 내용

class Person:
    def __init__(self, name="noname"):
        self.name = name
    def printing(self):
        print("상위 클래스의 메서드")

class Student(Person):  # Student 클래스가 Person 클래스 상속받음
    pass

student1 = Student()
student1.printing() # 상위 클래스의 메서드
print(student1.name) # noname (속성도 상속받을 수 있음)

• method overriding : 상위 클래스에 존재하는 메서드를 하위 클래스에서 다시 정의
  • 상위 클래스의 기능이 부족해서 추가하는 것이 목적으로 특별한 경우가 아니라면 하위 클래스에서 메서드를 다시 정의할 때는 상위 클래스의 메서드를 호출하고 코드를 추가해야 한다. (파괴를 할 땐 반대로)
  • 상위 클래스 호출할 때
    • 하나의 클래스로부터 상속받는 경우 : super( ).메서드이름( )
    • 여러 개의 클래스로부터 상속받는 경우 : super(클래스이름, self).메서드 이름( )

class Student(Person):
    def printing(self):
        print("하위 클래스의 메서드")
        
student1 = Student()
student1.printing() # 하위 클래스의 메서드

class Person:
    def printing(self):
        print("상위 클래스의 메서드")

class Student(Person):
    def printing(self):
        super().printing()
        print("하위 클래스의 메서드")

student1 = Student()
student1.printing() 
# 상위 클래스의 메서드 
# 하위 클래스의 메서드

• 다중 상속 : 여러 개의 클래스로부터 상속 받는 것 (괄호 안에 여러 개의 클래스를 나열)

class Base1:
    def method(self):
        print("Base1의 메서드")
class Base2:
    def method(self):
        print("Base2의 메서드")

class Derived(Base1, **Base2**):
    def method(self):
        super().method() # Base1의 메서드
        **super(Base1, self).method() # Base1 다음에 존재하는 클래스의 메서드 호출**

instance = Derived()
instance.method() 

# Base1의 메서드
# Base2의 메서드

• 추상 클래스 : 인스턴스를 만들 수 없는 클래스 ⇒ 상속을 통해서만 사용하는 클래스
  • 하위 클래스에서 필요한 내용을 구현해서 사용한다.
  • 생성 방법 : abc Module을 가져와서 클래스의 괄호 안에 metaclass = ABCMeta를 지정하면 된다.
• 추상 메서드 : 내용이 없는 메서드
  • 추상 클래스에 존재해야 하고, 하위 클래스에서 반드시 구현해서 사용해야 한다.
• 추상 사용하는 이유:
• 템플릿 메서드 패턴(인터페이스)을 구현하기 위해서 사용(굳이 내용을 보여줄 필요 없는 것), Polymorphism 구현을 위해서 사용

import abc

# 추상 클래스 만들기 -> 상속을 통해서만 사용
class Starcraft(metaclass=abc.ABCMeta):
    # 추상 메서드 만들기
    @abc.abstractmethod
    def attack(self):
        pass # 추상 메서드는 내용이 없어야 하니까

star = Starcraft() # 추상 클래스는 인스턴스 못 만드니까 TypeError: Can't instantiate abstract class Starcraft without an implementation for abstract method 'attack' 에러 나옴

import abc

# 추상 클래스 만들기 -> 상속을 통해서만 사용
class Starcraft(metaclass=abc.ABCMeta):
    # 추상 메서드 만들기
    @abc.abstractmethod
    def attack(self): # 하위 클래스에서 반드시 다시 정의해야 한다.
        pass # 추상 메서드는 내용이 없어야 하니까

class Protoss(Starcraft):
    def attack(self): # 추상 메서드 하위 클래스에서 다시 정의하기
        print("Protoss 의 공격")

star = Protoss()
star.attack() # Protoss 의 공격

Module

1. 개요

모듈 : 독자적인 기능을 갖는 구성 요소

• 파이썬에서는 하나의 파일을 모듈이라고 한다.

2. 사용 방법

다른 파일에 있는 내용을 가져다 사용할 때는 import 명령어 사용

• import 파일명 : 파일명으로 모듈의 내용을 가져와서 파일명.멤버의 형태로 사용 (다 가져와서 쓰기)
• from 파일명 import 속성명 : 파일에서 속성만 현재 모듈로 가져와서 사용 (일부분만 가져와서 쓰기)
• from 파일명 import * : 파일에 있는 모든 속성을 현재 모듈에 포함시켜 사용 (왠만하면 쓰기 말기)
• import 파일명 as 새로운 이름 ex. import pandas as pd, import numpy as np
• from 파일명 import 속성명 as 새로운 이름 ex. from pandas import dataframe as df

import는 한 번만 적용된다.

# sys 모듈의 path라는 속성을 호출하면 현재 파이썬의 모듈 가져오기 순서를 확인할 수 있다.
from sys import path
print(path)
# or 
import sys
print(sys.path)

# ['C:\\\\Users\\\\kimmy\\\\Documents\\\\python\\\\0430', 'C:\\\\Users\\\\kimmy\\\\AppData\\\\Local\\\\Programs\\\\Python\\\\Python313\\\\python313.zip', 'C:\\\\Users\\\\kimmy\\\\AppData\\\\Local\\\\Programs\\\\Python\\\\Python313\\\\DLLs', 'C:\\\\Users\\\\kimmy\\\\AppData\\\\Local\\\\Programs\\\\Python\\\\Python313\\\\Lib', 'C:\\\\Users\\\\kimmy\\\\AppData\\\\Local\\\\Programs\\\\Python\\\\Python313', 'C:\\\\Users\\\\kimmy\\\\Documents\\\\python\\\\0430', 'C:\\\\Users\\\\kimmy\\\\Documents\\\\python\\\\0430\\\\Lib\\\\site-packages']

3. package

: 모듈을 모아 놓은 디렉토리

• 패키지를 만들기 위해서는 모듈을 하나의 디렉토리에 모으고 init.py 파일을 만들어주면 된다. (내용은 없어도 됨)
• 패키지에서 모듈을 가져올 때 : from 패키지이름 import 모듈이름

Data Type

1. sequential type

: 데이터를 순서대로 저장하는 자료형

종류

• 컨테이너 시퀀스 : 모든 자료형의 데이터를 저장할 수 있는 시퀀스 ex. list, tuple, collections, deque 등
• 균일 시퀀스 : 동일한 자료형의 데이터를 저장할 수 있는 시퀀스 ex. str, bytes, bytearray, memoryview, array.array 등
• 동일한 자료형의 데이터를 저장하기 때문에 아이디 대신에 실제 데이터를 저장하고 메모리 측면에서는 굿
• 가변 시퀀스 : list, collections.deque (코테에서 속도 줄일 수 있다. 양쪽에서 접근 가능, 시간 복잡도도 낮음)
• 불변 시퀀스 : tuple, str, bytes
• range를 이용해서 일정한 패턴을 갖는 숫자 시퀀스 생성 가능

⇒ 공통된 연산

• indexing: [ ]를 이용해서 데이터의 일부분을 접근하는 것으로 실제로는 __getitem__이라는 메서드를 호출한다. 맨 앞은 0부터 시작하고 뒤에서부터 접근하고자 할 때는 -1부터 시작한다.
• +를 이용해서 연결해서 리턴받을 수 있다
• *숫자를 이용해서 숫자만큼 반복 가능
• in 데이터를 이용해서 데이터의 존재 여부를 확인하는 것이 가능하다.
• len(데이터)을 이용해서 데이터의 개수를 리턴 받을 수 있다.
• slicing: 특정 범위의 데이터를 가져오는 것으로 [start:end:interval] 을 이용하는데 start 번째부터 end-1 번째까지 interval 단위로 가져온다.

⇒ str 클래스

• 문자열 클래스
• 크기 비교 가능
• 부분 수정은 안됨
• 문자열을 리턴하는 메서드가 존재하는데 이 경우는 메서드를 연쇄적으로 호출할 수 있다.

# msg의 좌우 공백 제거하고 모두 대문자로 치환
msg = " HelloWorld "
print(msg.strip().upper())

⇒ list 클래스

• 순서를 갖는 객체의 집합
• [ ]를 이용해서 표현
• 크기는 동적으로 변경 가능
• 생성 방법
  • [ ]
  • [데이터 나열]
  • list(__iter__가 구현된 인스턴스)
• 데이터의 id를 기억 (내부에서 데이터를 수정하면 연결된 데이터가 있다면 같이 수정된다.)
• list 클래스의 sort 메서드는 list 내부의 데이터를 정렬하지만 sorted 파이썬 내장 함수는 정렬을 해서 결과를 리턴한다.

ar = [100, 200, 300]
doublearray = [ar, 300, 400]
print(doublearray) # [[100, 200, 300], 300, 400]
doublearray[0][0] = 20000
print(doublearray) # [[20000, 200, 300], 300, 400]

datas = ["Hi", "hello", "Morning", "afternoon"]
print(dir(datas)) # sort 함수 있구나!
help(datas.sort)
datas.sort()
print(datas) # ['Hi', 'Morning', 'afternoon', 'hello'] # 기본은 오름차순 (소문자는 65, 대문자는 90~)
datas.sort(key=str.upper, reverse=True) # 대소문자 구분 없이 내림차순으로! key에 설정된 함수를 가지고 데이타 변환해서 정렬
print(datas) # ['Morning', 'Hi', 'hello', 'afternoon']

• list 대안
  • deque : 삽입과 삭제가 양방향 모두에서 가능한 양방향 큐, 양쪽 끝에 계속 추가하거나 삭제하면서 FIFO 구조나 LIFO 구조를 구현할 때 사용하면 효율적
  • collections 모듈에 존재
  • 데이터 개수를 설정해서 특정한 데이터의 개수를 유지하는 기능도 있음
  • queue : queue 모듈에서는 동기화된 Queue, LifoQueue(stack), PriorityQueue 를 제공하는데 이 큐들은 thread 간에 안전하게 통신할 때 사용

from time import time
li = []
start = time()
for i in range(10**7):
    li.append(i)
end = time()

print(f"list를 이용한 경우: {end-start}")

from collections import deque
deq = deque()
start = time()
for i in range(10**7):
    deq.append(i)
end = time()

print(f"deque를 이용한 경우: {end-start}") # 일반적으로 deque가 더 빠르다.

history = deque(maxlen=3)
history.append("축구")
history.append("야구")
history.append("배구")
history.append("농구")
for imsi in history:
    print(imsi) # 야구, 배구, 농구
print(history) # deque(['야구', '배구', '농구'], maxlen=3)

• tuple
  • 리스트와 유사한 구조로 데이터를 순서대로 저장하는 자료구조
  • 내부 데이터의 변경이 불가능
  • 데이터를 나열해도 튜플로 간주, 하나의 데이터를 가지고 튜플을 만들 때는 데이터,