Python World

아메리슬립 침대 구매 후기

nickas — Mon, 25 Nov 2024 21:58:39 +0900

7년전 아메리슬립 AS4 슈퍼싱글 매트리스를 잘 사용하고 있다가 퀸 사이즈 침대가 필요했다.

다른 브랜드도 살펴 보았지만 역시 아메리슬립이 가격도 좋고, 품질도 제일 좋아 구매 결정 고고씽!

개인적으로는 완전 푹신한 매트리스를 좋아하는데, Hybrid는 어떤 느낌일지 궁금하여 Hybrid AS5 최상위 모델로 구매 결정!!!! AS5 모델이 제일 푹신한 매트리스이다.

이번에도 후기를 작성하면 플렉스 베게를 준다길래 귀찮음을 뒤로하고 작성 ㅋ

퀸 사이즈는 무려 베게를 2개나 준다니 마다할 이유가 없잖음

이번에는 빨리 사용하고 싶은 마음에 박스 개봉 전 후 사진을 제대로 찍지 못했다.

메모리폼 매트리스는 압축된 형태로 택배 배달되고 포장을 풀면 위와 같은 형태로 부풀어 오른다. 포장을 풀고 최고 4시간 후에 사용해야 하기 때문에 개봉날에는 그냥 바닥에서 잠 ㅋ. 전에는 후기를 작성해야 매트리스 커버를 받을 수 있었는데, 이번에는 매트리스 커버가 기본 포함! 강남점에서 10% 할인 행사를 하길래 퇴근 후 부랴부랴 강남점을 찾아가 10% 할인을 받을 수 있었다.

이번에는 프레임도 같이 구매. 헤드가 필요 없기에 가장 저렴한 제품인 에이 파운데이션을 구매했다. 매트리스 아래 평평한 것이 프레임이다.아래에 다리를 결합해서 사용하거나, 저렇게 다리 없이 사용할 수도 있는데. 배송일에 나사가 같이 배송이 안되서 어쩔 수 없이 다리 없이 조립 ㅠㅠ

다리를 결합 할 경우 저 부품?을 프레임 중간에 붙여야 한다고 한다. 중간 지지대 역할을 하는 듯

중간 중간 스템플러가 박혀 있는데 하나가 잘 못 박혀 있었다ㅠ 사용에는 지장이 없을 것 같아 그냥 쓰기로.

프레임 다리들

문제의 나사들 ㅋ. 바로 배송해 주셨다

언제 다시 프레임 다리를 조립하지.....ㅋ.

확실히 슈퍼 싱글 보다는 많이 무겁다. 매트리스를 프레임 위에 올리는데 아이고 허리야 ㅋ

지금 보름? 정도 사용 중인데, 역시 만족도 최상. 매일 매일 숙면 중. 가격면에서 비싼감이 있지만 숙면을 중요하게 생각하기에 나에게 하는 가장 좋은 투자라고 생각한다.

약간 아쉬운 점은 프레임을 직접 조립해야 하는데 설명서가 없다는 것이다ㅠ. 조립이 어려운건 아니지만 완변한? 조립을 위해 홈페이지에라도 설명서를 올려 주면 좋을 듯 하다.

Scrapy 구조 알아보기

nickas — Sun, 17 May 2020 19:38:01 +0900

Scrapy를 잘 사용하기 위해 구조와 작동 순서를 아는것이 필요.

Components

Scrapy는 아래와 같은 component들로 구성되어 있다.

Scrapy Engine
각 component들에 데이터(Request, Response, Item)를 전달(Controller)하고 액션이 발생 했을 때 이벤트를 발생시키는 역활을 함.
Scheduler
엔진으로 부터 Request을 전달 받고 이 Request을 queue에 추가한 후 나중에 엔진이 Request를 요청할 때 다시 엔진에 전달.
Downloader
Request에 포함된 URL에서 웹 페이지를 가져와서 Response 오브젝트를 만들어 엔진에게 전달하는 역활을 한다. 엔진은 전달 받은 이 웹 페이지를 다시 스파이더에게 전달.
Spider
요청할 URL을 사용하여 Request 오브젝트를 만들고, callback 메서드를 사용하여 Response에서 원하는 데이터를 추출하거나 Response에 포함된 URL을 사용하여 새로운 Request를 만드는 역활을 함.
Item Pipeline
스파이더로 부터 추출된 아이템을 처리하는 역활을 함(정확히는 Item 오브젝트가 전달됨). 일반적으로 아이템을 cleansing, 검증 그리고 데이터베이스 같은 곳에 저장하는 일을 함.
Downloader middleware
엔진과 다운로더 사이에 위치한 hook으로 엔진으로 부터 다운로더로 전달되는 Request를 처리하고, 다운로더로 부터 엔진으로 전달 되는 Response를 처리.
아래와 같은 것이 필요할 경우 다운로더 미들웨어를 사용한다.
- Request가 다운로더로 전달되기 전에 처리하기 위해. 예를 들어 웹사이트로 request를 보내기 전에 문제가 없는지 확인하기 위해.
- Response를 스파이더로 전달되기 전에 변경하기 위해.
- Response를 스파이더로 전달하는 대신 새로운 Request를 요청하기 위해.
- 웹 페이지를 가져오지 않고 스파이더에 Response를 전달하기 위해.
- 몇몇 Request를 drop하기 위해.
Spider middleware
엔진과 스파이더 사이에 위치한 hook으로 스파이더의 input(Reponse)와 output(아이템과 Request)를 처리할 수 있다.
아래와 같은 경우가 필요할 때 사용
- 스파이더 콜백의 아웃풋인 Request와 아이템를 변경하거나 추가, 삭제.
- start_requests의 후처리
- 스파이터의 예외 처리
- Response을 기반으로 Request들 중 일부에 callback을 호출하는 대신 errback를 호출(예를들어 response가 정상(200)이 아닌 경우 callback을 호출하지 않고 errback를 호출하여 처리)

데이터 흐름

데이터(request, response, item)이 Scrapy 시스템 안에서 어떻게 흘러 가는지 아래 그림이 설명해 주고 있다.

Scrapy Data Flow

Scrapy에서 데이터는 엔진에 의해서 컨트롤 되고 아래와 같이 흘러 간다.

엔진은 스파이더로 부터 crawl을 하기 위한 초기 Request 오브젝트를 받음.
엔진은 이 Request를 스케줄러 안에 등록하고 crawl를 진행 할 다음 Request를 요청.
스케줄러는 엔진에게 다음으로 crawl을 진행 할 Request을 전달.
엔진은 이 Request를 다운로더에 전달하고, Request는 다운로더로 전달되면서 다운로더 미들웨어를 거쳐 감. 내부적으로는 미들웨어의 process_request()를 실행.
다운로더는 Request 오브젝트에 포함되어 있는 URL의 페이지를 가져(fetch) 온 후 이 페이지를 이용하여 Response 오브젝트를 생성하고 엔진에게 다시 전달. Response는 엔진으로 전달되면서 다시 다운로더 미들웨어를 거쳐 감. 내부적으로는 미들웨어의 process_response()를 실행.
엔진은 다운로더로 부터 Response를 전달 받고 이 Response를 스파이더에게 전달. Response는 스파이더로 전달되면서 스파이더 미들웨어를 거쳐 감. 내부적으로는 미들웨어의 process_spider_input()를 실행.
스파이더는 Response를 처리하고 스크랩한 아이템과 새로운 Request를 엔진에게 전달(Response에 포함된 링크를 따라 Request를 만들 경우). 스크랩과 새로운 Request는 엔진으로 전달되면서 스파이더 미들웨어를 거쳐 감. 내부적으로는 미들웨어의 process_spider_output()를 샐행.
엔진은 아이템을 Item Pipelines에 전달하고 새로운 Request는 스케쥴러에 전달하면서 다음으로 crawl 해야 하는 Request를 요청.
이 모든 프로세스는 스케쥴러로 부터 더 이상 Request가 없을 때 까지 1번 부터 반복적으로 진행.

위 절차를 요약 하자면,

내가 작성한 스파이더에서 Request 오브젝트를 만들어 리턴하면
다운로더가 페이지를 가져와서 Response 오브젝트를 만들어 스파이더로 전달해 주고
스파이더는 내가 작성한 callback를 실행해서 내가 원하는 아이템을 추출하고 파이프라인으로 전달.
내가 작성한 파이프라인이 있으면(데이터베이스로 저장 등) 파이프라인에서 아이템을 다시 처리하고 더 이상 Request가 없을 때 까지 반복.

Reqeust와 Response가 전달되는 과정에서 미들웨어들을 거쳐감.

Scrapy 간단 사용법

nickas — Sun, 10 May 2020 23:25:06 +0900

설치

$ pip install scrapy

프로젝트 생성

$ scrapy startproject project_name

아래와 같이 디렉토리와 파일들이 생성됨

$ tree project_name
project_name
├── scrapy.cfg
└── project_name
    ├── __init__.py
    ├── items.py
    ├── middlewares.py
    ├── pipelines.py
    ├── settings.py
    └── spiders
        └── __init__.py

간단 spider 생성

Spiders 디렉토리 안에 파이썬 파일 생성

$ cd project_name/project_name/spiders
$ touch example.py

scrapy.Spider를 상속하는 클래스를 생성

# example.py
import scrapy

class ExampleSpider(scrapy.Spider):
    name = 'example'

    def start_requests(self):
        urls = [
            'http://www.example.com/'
        ]

        return [scrapy.Request(url=url, callback=self.parse) for url in urls]
        # 또는
        #for url in urls
        #    yield scrapy.Reqest(url=url, callback=self.parse

    def parse(self, response):
        url = response.url
        title = response.css('h1::text').get()
        print(f'URL is: {url}')
        print(f'Title is: {title}')

name (필수)
spider 이름을 지정. 프로젝트 안에서 유일한 이름이어야 함.
start_requests(self) (필수)
- spider 시작 시 실행되는 메서드로 scrapy.Request()를 사용하여 Request 오브젝트를 만들어 리턴하면 Scrapy 스케쥴러에(queue) 등록되고 순서가 되면 Scrapy downloader가 파라미터로 전달된 url을 사용하여 페이지를 요청.
- callback 파라미터를 사용하여 downloader가 전달해 주는 Response 오브젝트를 처리할 메서드를 지정.
- 이 메서드는 spider 시작 시 한번만 실행되기 때문에 위와 같이 Request 오브젝트를 리스트 형식으로 만들어 리턴하거나 yield를 사용하여 generator 형식으로 사용
scrapy.Request()
Request 오브젝트를 만들기 위해 사용.
- url
  요청할 사이트 주소 http 형식
- callback
  Response 오브젝트를 처리할 메서드를 지정
parse(self, response) (필수)
- Response오브젝트를 처리하는 callback 메서드로 argument로Response` 오브젝트를 받음.
- 위 코드와 같이 Request 오브젝트를 만들 때 callback를 사용자가 지정하기 때문에 parse란 이름 대신 다른 이름으로 사용해도 됨.
response.css('h1::text').get()
css selector를 사용하여 h1 태그를 찾고 텍스트를 반환

$ scrapy genspider [template_name] <spider_name> <domain_name> 명령을 사용하면 템플릿을 사용하여 자동으로 템플릿에 맞는 클래스가 작성된 spider_name으로된 파이썬 파일을 spiders 폴더 안에 만듬.
클래스는 아래에 있는 코드가 줄여진 형태.
$ scrapy genspider -l 명령으로 사용할 수 있는 템플릿을 확인할 수 있음.

Scrapy 실행

위에서 정의한 spider를 실행하고 start_requests 메서드를 실행함.

$ scrapy runspider example.py
# 또는 
# scrapy crawl <spider name>

Spider 코드 줄이기

# example.py
import scrapy

class ExampleSpider(scrapy.Spider):
    name = 'example'
    start_urls = [
        'http://www.example.com/'
    ]

    def parse(self, response):
        url = response.url
        title = response.css('h1::text').get()
        print(f'URL is: {url}')
        print(f'Title is: {title}')

start_requests 메서드 대신 start_urls를 사용하면 spider가 시작 될 때 알아서 작성된 URL을 사용하여 Request 오브젝트를 생성하고 리턴.
callback으로 self.parse 메서드를 사용하기 때문에 이름을 변경하면 안됨.

Item 사용하기

Crawl한 페이지에서 원하는 데이터를 추출한 후 구조적으로 저장하기 위해 사용.
Item이라는 오브젝트에 attribute 형태로 데이터가 저장되고 원할 경우 이 데이터를 JSON이나 CSV 같이 파일로 저장할 수 있음.

물론 파이썬에서 제공하는 open 모듈을 사용하여 parsing 단계에서 파일 형태로 저장할 수 있지만 이런 수고로움 없이 Scrapy에서 편리하게 사용할 수 있는 방법을 제공. 또한 많은 양의 데이터를 파일로 저장할 경우 I/O 병목이나 오버헤드 또는 쓰레드 처리 등등 여러가지 문제들이 발생할 수 있기 때문에 심신의 안정과 평안을 얻기 위해서도 Scrapy에서 제공하는 방법을 사용. 근본적으로 framework를 사용하는 이유이기도……

보통 items.py에 클래스를 정의(그냥 spyder가 정의된 파일에 같이 사용해도 되나 편의상 구분하여 정의)

클래스는 scrapy.Item을 상속해야 하고 데이터들을 저장할 필드를 scrapy.Filed 오브젝트로 만듬.

example 스파이더를 item을 사용하게 변경 하면

# items.py
import scrapy

class ExampleItem(scrapy.Item):
    url = scrapy.Field()
    title = scrapy.Field()

# example.py
import scrapy
from ..items import ExampleItem  # 위에서 정의한 클래스 import

class ExampleSpider(scrapy.Spider):
    name = 'example'
    start_urls = [
        'http://www.example.com/'
    ]

    def parse(self, response):
        example_item = ExampleItem()        # Item 오브젝트 생성
        example_item['url'] = response.url  # 데이터 저장
        example_item['title'] = response.css('h1::text').get()

        return example_item

처음 작성한 코드와 다른 점은 Item 오브젝트는 반드시 리턴되어야 한다는 것이다.
처음 작성한 코드는 명시적으로 데이터를 출력하게 한것이고, 여기서는 오브젝트를 리턴해야 로그에 데이터가 출력도 되고 나중에 파일로 저장될 때 사용되어 진다.

Django를 경험해 본 사람은 item이 Django의 Model과 비슷한걸 느낄 것이다. 실제로 Scrapy 문서에도 유사하다고 나와 있다.

Item 파일로 저장하기

$ scrapy runspider examle.py -o example.csv -t csv
$ scrapy runspider examle.py -o example.json -t json
$ scrapy runspider examle.py -o example.xml -t xml

-t 옵션을 사용하지 않아도 Scrapy가 파일 확장자를 보고 자동으로 확장자에 맞게 저장 해줌.

Logging 사용하기

CLI에서 Scrapy를 실행하면 실행되는 내용이 출력되는데 내용이 길 경우(보통은 긴 내용이 출력됨) 확인하기가 어렵기 때문에 출력 내용을 파일로 저장해서 확인하면 편함.

아래와 같이 settings.py에서 로깅을 설정할 수 있음(CLI에 출력 안됨).

LOG_FILE = 'spider.log'  # log 파일 위치
LOG_LEVEL = 'INFO'       # 기본은 DEBUG 임

또는 Scrapy를 실행 할 때 설정

$ scrapy runspider example.py -s LOG_FILE=spider.log

팁

사이트 제한으로 crawling이 안되는 경우

Scrapy를 실행 할 경우 간혹 사이트에서 제한을 걸어 crawling을 못하는 경우가 발생. 왜냐하면 Scrapy는 실행 시 robots.txt 파일을 확인해서 제한이 걸려 있는 페이지를 crawling 하지 않기 때문.
이 문제를 해결할려면 settings.py에서 ROBOTSTXT_OBEY = True을 False로 수정하면 됨.

(주의)그러나 과도하게 사이트에 부하(crawling)를 주면 IP가 차단될 수도 있음.

과도한 요청으로 인한 차단을 피하는 방법

과도하게 사이트를 crawling 할 경우 사이트에서(관리가 잘되는 곳)에서 IP를 차단 할 수도 있다. 이를 예방하기 위해 DOWNLOAD_DELAY와 CONCURRENT_REQUESTS 수정해 요청(request)을 조절할 수 있다.

# settings.py
DOWNLOAD_DELAY = 0.25    # 250ms 기다림, 기본값은 안기다림
CONCURRENT_REQUESTS = 1  # 기본값은 16

위 설정은 한 개의 request 후 0.25초를 기다림

DOWNLOAD_DELAY은 request 후 얼마를 기다릴 지 설정
CONCURRENT_REQUESTS은 한번 request 할 때 동시에 몇개의 request를 할지 설정. 예를 들어 총 100개의 페이지(url)를 요청(request)해야 한다면, 한번 요청할 때 20개 씩 나눠서 요청 할 수 있음.

HTTP cache를 사용

아래와 같이 settings.py에 설정을 하면 cache 기능을 사용할 수 있다.

# settings.py
HTTPCACHE_ENABLED = True  # 기본 값은 False

위와 같이 설정을 하면 한번 request한 페이지 정보들이 프로젝트 디렉토리의 .scrapy 안에 저장(cache)되고 다음에 같은 페이지를 request 할 때 cache를 사용하여 속도를 향상 시킬 수 있다.

파이썬 조건문 그리고 반복문

nickas — Sun, 26 Apr 2020 17:02:15 +0900

조건문은 어떤 조건이 참일 때 수행되는 구문이고 반복문은 구문을 반복적으로 수행하기 위해 사용
조건문을 만들기 위해서는 if를 사용하고 반복문은 for와 while을 사용.

if

if는 영어가 의미하는 대로 만약(if) 조건이 참(True)이면 if문(들여쓴문) 아래 행동을 실행.

if 1:  # 여기서 1은 True를 의미
    print('True')

# output
'True'

`elif` 문 사용

조건을 여러 개 추가 할 수 있다.

a = 0

if a == 1:
    print('a는 1이다')
elif a == 2:
    print('a는 2이다')
elif a == 0:
    print('a는 0이다')

# output
'a는 0이다'

membership 확인

list 같은 데이터 모음에 주어진 아이템이 존재하는지 확인

a = [1, 2, 3, 4, 5]
if 1 in a:  # 1이 존재하면 True 반환
    print('true')

for

for는 조건에 iterable(반복 가능한)가 주어지고 iterable에서 값을 가져와 주어진 행동을 반복적으로 실행.

iterable이란 굳이 번역하자면 반복 가능한 객체 정로도 번역할 수 있는데 이게 사전에는 없는 프로그래밍 영역에서 만들어진(프로그래머들 사이에서 쓰이는) 단어이다(이렇게 사전에는 없는 새로 만들어진 단어들이 존재). iteration(반복)이라는 단어를 형용사 형태로 만들어 사용하는 듯.
파이썬에서 말하는(다른 프로그램 언어에서도 이 단어를 사용) iterable를 이해 할려면 generator 부분을 보면 됨.

for i in [1, 2, 3, 4, 5]:  # i는 loop 변수라 불림
    print(i)

# output
1
2
3
4
5

Dictionary 사용

d = {1: 'a', 2: 'b', 3: 'c'}
for key in d:  # key 값이 반환 됨. d.keys()와 같음
    print(key)

# output
1
2
3

for value in d.values():  # .value() 메서드를 사용하여 value 값을 반환
    print(value)

# output 
'a'
'b'
'c'

for key, value in d.items():  # .items() 메서드를 사용하여 key와 value 값을 반환
    print(key, value)

# output
1 'a'
2 'b'
3 'c'

확장된 loop 변수 할당 사용법

nested된 list가 iterable로 주어 졌을 때 처리 방법
예를 들어, [(1, 2, 3), (4, 5, 6)] 이와 같이 list 안에 tuple로 정의된 아이템이 있고 tuple이 아닌 각각의 아이템을 구하고? 싶을 때

for a, b, c in [(1, 2, 3), (4, 5, 6)]:
    print(a, b, c)

# output
1 2 3
4 5 6

nested for loop

for 문 안에 for 문을 사용 할 수 있음.

a = ['a', 'b', 'c', 'd']
for i in a:
    for x in a:
        print(i + x)

for문 안에 for문 사용은 제한이 없으나 대부분의 경우는 2개의 for문 사용으로 문제를 해결할 수 있다.

필터로써 if 사용

if를 사용하여 내가 원하는 값만 획득하거나 원하지 않는 값을 제외할 수 있다.

# list a에서 짝수 인 값을 구하기
a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for i in a:
    if i % 2 == 0:  # 2로 나눈 나머지가 0이면 짝수
        print(i, '는 짝수')

# list a에서 짝수인 값과 홀수인 값 구별하기
for i in a:
    if i % 2 == 0:
        print(i, '는 짝수')
    else:
        print(i, '는 홀수')

while

영어 단어 그대로 조건이 참일 동안(while) 주어진 행동을 반복적으로 수행

while True:
    print('True')

for와 다른 점은 for는 주어진 값(iterable한 값)이 존재하는 동안 실행되는 반면, while은 주어진 조건이 참(True)일 동안(거짓(False)으로 바뀌지 않으면 무한 실행) 반복적으로 특정 행동을 실행할 필요가 있을 때 사용.

a = 10
while a:  # 0은 거짓(False)을 의미하기 때문에 a가 0이 되면 실행 안됨.
    print(a)
    a -= 1

`else` 문 사용

if와 함께 사용 시 조건이 거짓(False) 일 때 다른 행동을 하게 하고 싶을 때 사용

if not 1:  # 1(True(참))이 아닌 것은 False(거짓)이다.
    print('True')
else:
    print('False')

# output
'False'

while와 함께 사용 시 조건이 거짓일 될 때만 else 문이 실행됨(한번).

a = 10
while a:
    print(a)
    a -= 1
else:
    print(a)

for와 함께 사용 시 for 구문이 끝나고(더 이상 가지고 올 값이 없을 때) else 구문이 실행 됨.

for i in (1, 2, 3, 4):
    print(i)
else:
    print('done')

# output
1
2
3
4
'done'

`break` 문 사용

반복문(for, while) 실행 중 break를 만나면 반복문이 종료됨

x = 10
while True:
    x = x -1
    if x % 2 != 0:  # x를 2로 나눈 나머지가 0일 경우
        break
    print(x)

for i in (1, 2, 3, 4, 5):
    if i % 2 == 0:
        break
    print(i)

else와 함께 사용 시 break를 만나면 else는 실행 되지 않고 반복문이 종료됨

x = 10
while x:
    if x % 2 == 0:
        break
    x -= 1
else:
    print(x, '는 0')

for i in (1, 2, 3, 4, 5):
    if i % 2 == 0:
        break
    print(i)
else:
    print('done')

`continue` 문 사용

반복문 실행 중 continue를 만나면 반복문 시작으로 돌아가 실행.

x = 10
while x:           # 숫자가 0이 아닐 경우 참(True).
    x = x - 1
    if x % 2 == 0:
        continue   # 다시 while 문으로 돌아가 실행
    print(x)

for i in (1, 2, 3, 4, 5, 6, 7, 8, 9, 10):
    if i % 2 == 0:
        continue
    print(i)

`pass` 문 사용

pass는 단어 그대로 아무것도 하지 않음.

x = 10
while x:
    if x % 2 == 0:
        pass
    print(x)
    x -= 1

for i in (1, 2, 3, 4, 5, 6, 7, 8, 9, 10):
    if i % 2 == 0:
        pass
    print(i)

Set

nickas — Sat, 25 Apr 2020 09:53:46 +0900

Set

특징

Set은 중복을 허용하지 않음(중복제거, unique한 값을 가짐)
Set은 순서가 없음

Set 만들기

>>> s1 = set()  # 빈 set 만듬
>>> s1
set()
>>> s2 = set([1, 2, 1, 3])
>>> s2
{1, 2, 3}
# 또는
>>> s2 = set(range(1, 4))

>>> s3 = {1, 2, 1, 3}
>>> s3
{1, 2, 3}

아이템 추가

>>> s = set()
>>> s.add(1)
>>> s.add(2)
>>> s.add(1)
>>> s
{1, 2}

여러 아이템 추가 한번에 추가

>>> s = set()
>>> s.update([1, 2, 3])
>>> s
{1, 2, 3}

아이템 가져오기

.pop()을 사용하면 맨 왼쪽의 아이템이 반환되고 지워짐
set은 순서가 없기 때문에 index를 사용하여 아이템을 가져 올 수 없음

>>> s = {1, 2, 3, 4}
>>> s.pop()
1
>>> s
{2, 3, 4}

아이템 제거

`.remove()` 사용

>>> s = set([1, 2, 3])
>>> s.remove(1)
>>> s
{2, 3}
>>> s.remove(1)  # key error 발생
KeyError: 1

`.discard()` 사용

>>> s = {1, 2, 3}
>>> s.discard(1)
>>> s
{2, 3}
>>> s.discard(1)  # 아이템이 없어도 에러 발생 안함

`.clear()` 사용

전체 아이템을 삭제

>>> s = {1, 2, 3}
>>> s.clear()
>>> s
set()

연산

>>> 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}
>>> s2.intersection(s1)
{4, 5, 6}

>>> s1 &= s2  # 교집한 후 s1에 대입
>>> s1
{4, 5, 6}

합집합

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

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

>>> s1 |= s2  # 합집합 후 s1에 대입
>>> s1
{1, 2, 3, 4, 5, 6, 7, 8, 9}

차집합

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

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

>>> s1 -= s2  # 차집합 후 s1에 대입
>>> s1
{1, 2, 3}

대칭차집함

합집합과 교집합을 따로 실행 후 합집합에서 교집합 빼기(합집합 - 교집합)

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

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

>>> s1 ^= s2  # 대칭차집합 후 s1에 대입
>>> s1
{1, 2, 3, 7, 8, 9}

Set 메서드

`.issubset()`

부분 집합 여부 확인

>>> s1 = {1, 2, 3, 4, 5}
>>> s2 = {1, 2, 3}
>>> s1.issubset(s2)
False
>>> s2.issubset(s1)
True

`.issuperset()`

.issubset()의 반대(포함 여부 판단)

>>> s1 = {1, 2, 3, 4, 5}
>>> s2 = {1, 2, 3}
>>> s1.issuperset(s2)
True
>>> s2.issuperset(s1)
False

`.isdisjoint()`

교집합이 없으면 True, 있으면 False

>>> s1 = {1, 2, 3, 4, 5}
>>> s2 = {1, 2, 3}
>>> s1.isdisjoint(s2)
True
>>> s2.isdisjoint(s1)
True

>>> s1 = {1, 2, 3}
>>> s2 = {4, 5, 6}
>>> s1.isdisjoint(s2)
False
>>> s2.isdisjoint(s1)
False

Set 복사

>>> s = {1, 2, 3}
>>> c = s.copy()
>>> s
{1, 2, 3}
>>> c
{1, 2, 3}
>>> id(s)
4554012032
>>> id{c}
4554012704

>>> s = set(1, 2, 3)
>>> c = set(s)
>>> s
{1, 2, 3}
>>> c
{1, 2, 3}
>>> id(s)
4554012032
>>> id(c)
4554012928

Comprehensions

>>> l = [1, 2, 3, 4, 5]
>>> {i for i in l}
{1, 2, 3, 4, 5}

frozenset

한번 만들어 지면 변경할 수 없는 set(immutable)
아이템을 추가하거나 변경하는 메서드를 제공하지 않음(add, remove, pop, clear, update)

>>> s = frozenset()  # 빈 set
>>> s = frozenset([1, 2, 3])
>>> s = frozenset(range(1, 4))

연산

set의 연산법과 같음

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

# 교집합
>>> s1 & s2
frozenset({4, 5})
>>> s1.intersection(s2)

# 합집합
>>> s1 | s2
frozenset({1, 2, 3, 4, 5, 6, 7, 8})
>>> s1.union(s2)
frozenset({1, 2, 3, 4, 5, 6, 7, 8})

# 차집합
>>> s1 - s2
frozenset({1, 2, 3})
>>> s1.difference(s2)
frozenset({1, 2, 3})

# 대칭차집합
>>> s1 ^ s2
frozenset({1, 2, 3, 6, 7, 8})
>>> s1.symmetric_difference(s2)
frozenset({1, 2, 3, 6, 7, 8})

메서드

`.issubset()`

부분 집합 여부 확인

>>> s1 = frozenset([1, 2, 3, 4, 5])
>>> s2 = frozenset([1, 2, 3])
>>> s1.issubset(s2)
False
>>> s2.issubset(s1)
True

`.issuperset()`

.issubset()의 반대(포함 여부 판단)

>>> s1 = frozenset([1, 2, 3, 4, 5])
>>> s2 = frozenset([1, 2, 3])
>>> s1.issuperset(s2)
True
>>> s2.issuperset(s1)
False

`.isdisjoint()`

교집합이 없으면 True, 있으면 False

>>> s1 = frozenset([1, 2, 3, 4, 5])
>>> s2 = frozenset([1, 2, 3])
>>> s1.isdisjoint(s2)
True
>>> s2.isdisjoint(s1)
True

>>> s1 = frozenset([1, 2, 3])
>>> s2 = frozenset([4, 5, 6])
>>> s1.isdisjoint(s2)
False
>>> s2.isdisjoint(s1)
False

복사

>>> s = frozenset([1, 2, 3])
>>> c = s.copy()
>>> s
frozenset({1, 2, 3})
>>> c
frozenset({1, 2, 3})
>>> id(s)
4581973344
>>> id(c)
4581973344

파이썬 Tuple

nickas — Sun, 19 Apr 2020 22:00:38 +0900

Tuple은 list나 dictionary와 다른게 한번 만들어 지면 변경될 수 없음(immutable).
데이터 모음이 변경되지 않는 것을 보장해야 할 때 사용.
()를 사용하여 만듬.

Tuple 만들기

>>> t = ()       # 빈 tuple 
>>> t = tuple()  # tuple() 빌트인 함수 사용

아이템 추가

한번 만들어진 tuple은 아이템을 추가하거나 변경 할 수 없기 때문에 사실상 아이템을 추가 할 수 있는 방법이 없고 tuple을 만들면서 아이템을 추가하여야 함.

>>> t = (0,)
>>> t = 0, 'spam', 1.2
>>> t = tuple('spam')
('s', 'p', 'a', 'm')

>>> t = tuple(0)  # iterable한 아이템만 사용가능
TypeError: 'int' object is not iterable

(주의) t = (0) 이렇게 ,(콤마) 없이 사용하면 그냥 integer 타입이 됨. 반드시 콤마를 사용해야 함.

아이템 가져오기

list와 같이 index를 사용.

>>> t = (0, 1, 2, 3)
>>> t[0]
0

netsted 아이템 가져오기

사용법은 list와 같음

>>> t = (1, [2, 3], 4)
>>> t[1][0]
2

아이템 변경하기

한번 만들어지 tuple은 아이템을 변경 할 수 없음.

>>> t = (0, 1, 2, 3)
>>> t[0] = 4
TypeError: 'tuple' object does not support item assignment

그러나 nested 아이템이 list 같이 mutable 아이템이면 변경가능.

>>> t = (0, [1, 2], 3)
>>> t[1][0] = 'a'
>>> t
(0, ['a', 2], 3)

Nested된 mutable 아이템을 사용할 때 주의사항

>>> l = [0, 1]
>>> t = (0, l, 2)
>>> t
(0, [0, 1], 2)

>>> l[0] = 3  # list 아이템을 변경 시 tuple에서 사용한 list도 같이 변경 됨
>>> t
(0, [3, 1], 2)

연산

>>> (1, 2) + (3, 4)
(1, 2, 3, 4)
>>> (1, 2) * 4
(1, 2, 1, 2, 1, 2, 1, 2)

Slicing

사용법은 list와 같음

>>> t = 0, 1, 2, 3
>>> t[1:3]
(1, 2)

정렬하기

# list로 변환 후 .sort() 메서드 사용
>>> t = (3, 2, 1, 0)
>>> l = list(t)
>>> l.sort()
>>> l
[0, 1, 2, 3]
>>> t = tuple(l)
>>> t
(0, 1, 2, 3)

# sorted() 빌트인 함수 사용
>>> t = (3, 2, 1, 0)
>>> sorted(t)
[0, 1, 2, 3)

Tuple 메서드

`.index()`

아이템의 index 위치를 반환

>>> t = ('a', 'b', 'c')
>>> t.index('a)
0

# 중복된 아이템이 있을 경우 사용
>>> t = ('a', 'b', 'a', 'c')
>>> t.index('a', 2)  # 두 번째 a의 위치를 반환
2

`.count()`

아이템 갯수를 반환

>>> t = (1, 2, 3, 2, 3, 2)
>>> t.count(2)
3

`namedtuple`

Dictionary 비스므리하게 사용하기 위해 사용.
tuple/class/dictionary의 하이브리드 형태.

>>> from collections import namedtuple
# 레코드 이름과 필드 설정
>>> rec = namedtuple('rec', ['name', 'age', 'jobs'])
>>> john = rec('John', age=50, jobs=['dev', 'mgr'])
>>> john
rec(name='John', age=50, jobs=['dev', 'mgr'])
>>> john[0]
'John'
>>> john.name
'John'

>>> john._asdict()  # Dictionary로 만들어 줌.
{'name': 'John', 'age': 50, 'jobs': ['dev', 'mgr']}
>>> john._asdict()['name']
'John'

파이썬 Dictionary

nickas — Sun, 19 Apr 2020 00:42:55 +0900

Dictionary은 말 그대로 사전처럼 인덱스(Key)를 기준으로 원하는 값을 찾기위해 사용.
다른 프로그램 언어(예: 자바스크립트)에서는 map이라고도 함.

{}를 사용하여 만들며 {키: 값} 형식으로 데이터를 저장. dict() Built-in 함수를 사용하여 만들 수도 있음.

key에는 mutable(예: list)한 타입은 사용할 수 없음(예: tuple은 사용가능)
value(값)에는 모든 type(예: list, dictionary, tuple) 사용 가능.

List와 다르게 데이터의 순서(sequence) 없음(list는 데이터를 넣은 순서대로 정렬되고 index를 이용하여 값을 찾음. Dictionary는 키를 이용하여 값을 찾기에 순서가 필요 없음)

Dictionary 만들기

>>> a = {}  # 빈 Dictionary 만들기
>>> a
{}
>>> type(a)
dict

>>> b = dict()  # 빑트인 함수를 사용하영 빈 Dictionary 만들기
>>> b
{}
>>> type(a)
dict

Dictionary 생성과 함께 아이템 추가하기

>>> fruits = {'a': 'apple'}  # Dictionary 생성과 함께 아이템 추가하기
>>> fruits
{'a': 'apple'}

>>> animals = dict(d='dogs', m='monkey')  # dict() 사용
>>> animals
{'d': 'dogs', 'm': 'monkey'}

# 다른 방법 들
>>> animals = dict([('d', 'dogs'), ('m', 'monkey')])

>>> keys = ['a', 'b', 'c', 'd']
>>> values = [1, 2, 3, 4]
>>> dict(zip(keys, values))
{'a': 1, 'b': 2, 'c': 3, 'd': 4}

>>> dict.fromkeys(['a', 'b'], 0)
{'a': 0, 'b': 0}
>>> dict.formkyes(['a', 'b'])  # 값을 정의하지 않으면 None
{'a': None, 'b': None}

Dictionary nesting

Dictionary 값에는 모든 오브젝트들(예: List, instance 등)이 들어갈 수 있음

>>> me = {'name': {'first': 'John', 'last': 'Doe'}, 'jobs': ['dev', 'mgr'], 'age': 50}

Dictionary에 아이템 추가하기

>>> fruits = {}
>>> fruites['a'] = 'apple'

Dictionary 값 가져오기

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

값이 없을 경우

KeyError를 발생

>>> D = {'a': 1, 'b': 2, 'c': 3}
>>> D['d']
KeyError: 'f'

Nested Dictionary에서 값 가져 오기

>>> me = {'name': {'first': 'John', 'last': 'Doe'}, 'jobs': ['dev', 'mgr'], 'age': 50}
>>> me['name']
{'first': 'John', 'last': 'Doe'}  # 값이 Dictionary이기 때문에 Dictionary 반환
>>> me['name']['first']           # first name 반환
'John'
>>> me['jobs']                    # 값이 List이기 때문에 list 반환
['dev', 'mgr']
>>> me['jobs'][0]                 # 첫 번째 직업 반환
'dev'

Dictionary 값 변경

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

Dictionary 아이템 제거

>>> D = {'a': 1, 'b': 1, 'c': 1}
>>> del D['a']
>>> D
{'b': 1, 'c': 1}

Dictionary 값 연산

# Integer 값 연산
>>> D = {'a': 1}
>>> D['a'] += 1
>>> D
{'a': 2}

# list 값 연산
>>> numeric = {'decimal': [1, 2, 3, 4, 5], 'float': [1.0, 2.0, 3.0, 4.0, 5.0]}
>>> numeric['decimal'].append(6)
>>> numeric
{'decimal': [1, 2, 3, 4, 5, 6], 'float': [1.0, 2.0, 3.0, 4.0, 5.0]}

Dictionary 키 `set` 연산

Dictionary 값은 set 연산을 할 수 없음

>>> D = {'a': 1, 'b': 2, 'c': 3}
>>> D.keys() | {'d': 4}         # 합집합
{'a', 'b', 'c', 'd'}
>>> D.keys() & {'b': 1}         # 교집합
{'b'}
>>> D.keys() | {'b', 'c', 'd'}
{'b', 'c', 'a', 'd'}

>>> D.items() | {('c', 3), ('d', 4)}
{('a', 1), ('b', 2), ('c', 3), ('d', 4)}
>>> dict(D.items() | {('c', 3), ('d', 4)})
{'d': 4, 'c': 3, 'b': 2, 'a': 1}

Dictionary 메소드

`.keys()`

키를 반환.

>>> D = {'a': 1, 'b': 1, 'c': 1}
>>> D.keys()
dict_keys(['a', 'b', 'c'])  # 인스턴스를 반환
>>> list(D.keys())          # list()를 이용하여 list로 생성
['a', 'b', 'c']

`.values()`

값을 반환

>>> D = {'a': 1, 'b': 1, 'c': 1}
>>> D.values()
dict_values([1, 1, 1])  # 인스턴스를 반환
>>> list(D.values())    # list()를 이용하여 list로 생성
[1, 1, 1]
>>> tuple(D.values())   # tuple()을 이용하여 tuple로 생성

`.items()`

키와 값을 반환

>>> D = {'a': 1, 'b': 1, 'c': 1}
>>> D.items()
dict_items([('a', 1), ('b', 1), ('c', 1)])  # 인스턴스를 반환
>>> list(D.items())                         # list()을 이용하여 list로 생성
[('a', 1), ('b', 1), ('c', 1)]

`.get()`

키에 해당하는 값을 반환하고, 키가 없을 경우 None을 반환하거나 정의한 값을 반환

>>> D = {'a': 1, 'b': 1, 'c': 1}
>>> D.get('a')
1
>>> print(D.get('d'))
None
>>> D.get('d', 0)
0

`.update()`

A Dictionary에 B Dictionary를 update 할 때 사용.

>>> D = {'a': 1, 'b': 1, 'c': 1}
>>> D2 = {'d': 1, 'e': 1}
>>> D.update(D2)
>>> D
{'a': 1, 'b': 1, 'c': 1, 'd': 1, 'e': 1}

(주의) B Dictionary에 A Dictionary와 같은 키가 있을 경우 B Dictionary에 있는 값으로 변경 됨.

>>> D = {'a': 1, 'b': 1, 'c': 1}
>>> D2 = {'a': 2, 'b': 2}
>>> D.update(D2)
>>> D
{'a': 2, 'b': 2, 'c': 1}

`.pop()`

키에 해당하는 값을 반환하고 아이템을 제거. list의 pop() 메서드와 같음

>>> D = {'a': 1, 'b': 1, 'c': 1}
>>> D.pop('a')
1
>>> D
{'b': 1, 'c': 1}

Key 정렬하기(Sort)

어떤 경우 Dictionary의 키를 정렬할 필요가 있음(예를들어 사전 같은 경우 a~z 순으로 정렬).

>>> D = {'a': 1, 'c': 1, 'b': 1}
>>> keys = list(D.keys())
['a', 'c', 'b']
>>> keys.sort()            # list의 sort() 메서드 이용
['a', 'b', 'c']

>>> sorted(D):  # sorted() 빌트인 함수 이용
['a', 'b', 'c']

`OrderedDict`

list와 같이 아이템(키)을 넣은 순서대로 사용하고 싶을 때 사용.
사용법은 기본 dictionary와 같음

(주의) a~z와 같이 오름차순이나 내림차순으로 정렬하는 것이 아니라 Dictionary에 아이템을 넣은 순서를 기억하는 것임. 왜냐하면 dict()은 아이템을 넣은 순서를 기억하지 못하기 때문에 아이템이 들어간 순서를 기억하였다가 사용하고 싶을 때 사용.
오버헤드(성능저하) 있음.

>>> from collections import OrderedDict  # 빌트인이 아니기 때문에 import
>>> D = OrderedDict()  # OrderedDict 인스턴스 생성
>>> D 
OrderedDict()

또는
>>> D = OrderedDict(a=1)
>>> D
OrderedDict([('a', 1)])

# 아이템 추가
>>> D['b'] = 1
>>> D['a'] = 1
>>> D['c'] = 1
>>> D
OrderedDict([('b', 1), ('a', 1), ('c', 1)])

# 값 구하기
>>> D['b']
1

# 값 변경
>>> D['b'] = 2
>>> D
OrderedDict([('b', 2), ('a', 1), ('c', 1)])

# 아이템 제거
>>> del D['b']
>>> D
OrderedDict([('a', 1), ('c', 1)])

아이템을 정렬하여 넣고 싶을 때는 sorted()를 사용하면 됨.

>>> from collections import OrderedDict
>>> D = {'A': 2, 'C': 3, 'B': 1, 'E': 1, 'F': 2}
>>> OrderedDict(sorted(D.items())
OrderedDict([('A', 2), ('B', 1), ('C', 3), ('E', 1), ('F', 2)])  # key가 알파벳 순으로 정렬됨

Dictionary comprehensions

사용법은 list나 set comprehension과 같고 {}를 사용

>>> D = {k: v for (k, v) in zip(['a', 'b', 'c'], [1, 2, 3])}

>>> D = {x: x ** 2 for x in range(5)}

>>> D = {x: x * 4 for x in 'PIZZA'}

>>> D = {x.lower(): x + '!' for x in ['PIZZA', 'HAMBURGER', 'TOAST]}

값에 해당하는 키 찾는 방법

>>> D = {1: 'a', 2: 'b', 3: 'c'}
>>> [key for (key, value) in D.items() if value == 'a']

`KeyError` 대비하기

`if`문 사용

if 'd' in D 구문을 사용하여 해당 키(d) 유무 확인.
키가 있으면 True, 없으면 False를 반환

if 'd' in D:
    print(D['d'])
else:
    print(0)

`try`문 사용

예외처리 하면 된다.

try:
    print(D['d'])
except KeyError:
    print(0)

`.get()` 메소드 사용

KeyError를 발생시키지 않음

>>> value = D.get('d')  # 키가 없으면 None을 리턴
>>> value
None

>>> D.get('d', 0)  # 키가 없으면 대체 값을 리턴
0

`for`문과 사용

for문을 사용하면 키나 값을 가져올 때 list로 변환 할 필요 없음.

>>> D = {'a': 1, 'b': 2, 'c': 3}
>>> for key in D:  # 키가 사용됨. D.keys()와 같음.
        print(key)

>>> for value in D.values():
        print(value)

>>> for item in D.items():  # item은 Tuple 형태
        print(item)

>>> for key, value in D.items():
        print(key, value)

>>> for key in D:
        print(key, D[key])

파이썬 List

nickas — Sun, 12 Apr 2020 15:23:37 +0900

파이썬 자료구조 형태의 하나로 시퀀스 데이터를 가지고 있음.
시퀀스는 데이터의 순서를 정하는 것을 의미 하므로 순서를 가지고 있고 index를 사용하여 값을 가져 올 수 있음.

보통 list는 원하는 데이터를 하나의 변수로 정의하여 사용하기 위해 사용.

예를 들어

>>> animal = ['dog', 'cat', 'monkey']
>>> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

와 같이 의미가 같은 값들을 하나의 변수로 묶어 사용할 수 있다.

List 만들기

>>> a = []      # 빈 list 생성 
>>> b = list()  # built-in 함수를 사용
>>> c = [1, 2, 3, 4]
>>> c
[1, 2, 3, 4]
>>> d = ['a', 'b', 'c', 'd']
>>> d
['a', 'b', 'c', 'd']
>>> type(d)
list

>>> e = [1, 'a', 2, 'b']  # 다른 타입을 혼합할 수 있음.
>>> e
[1, 'a', 2, 'b']

List 안의 값 사용하기

indexing

indexing 값을 이용하여 값을 추출 할 수 있음.

>>> a = [1, 2, 3, 4]
>>> a[0]
1
>>> a[-1]  # 마직막 값을 반환
4

slicing

[start:end:step] 형식을 사용

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

List 연산

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

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

중첩 리스트 만들기

리스트 내에 리스트를 만들 수 있음.
중첩 갯수는 거의 제한이 없음.(많은 수의 중첩은 거의 사용하지 않음, 계산하기 어려우니까)

>>> a = [[]]
>>> b = [1, [2, 3]]
>>> c = [{}]
>>> d = [1, {1: 'a', 2: 'b'}]  # List 안에 Dictionary를 삽입할 수 있음.
>>> e = [1, [2, [3, 4]]]

중첩 리스트 안의 값 사용하기

>>> a = [1, [2, 3]]
>>> a  
[1, [2, 3]]  # 첫 번째 리스트의 index 0, 1에 값이 들어 있는 형태
>>> a[1]
[2, 3]       # 첫 번째 리스트의 index 1에 있는 값 추출
>>> a[1][0]  # 첫 번째 리스트의 index 1에 있는 값 추출 후 두 번째 리스트의 index 0에 있는 값 추출.
2

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

List에 값 추가하기

`.append()`

List의 맨 뒤부터 값을 추가

>>> a = []
>>> a.append(1)
>>> a
[1]

`.insert()`

원하는 위치에 값 삽입

>>> a = [1, 2, 4]
>>> a.insert(2, 3)  # .insert(index, value)
>>> a
[1, 2, 3, 4]

slicing 사용하여 추가

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

`.extend()`

list를 list에 추가 할 때 중첩된 list 형태로 추가하지 않기 위해 사용

>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> a.append(b)
>>> a
[1, 2, 3, [4, 5, 6]]  # 중첩되어 추가됨

>>> a = [1, 2, 3]
>>> a.extend(b)
>>> a
[1, 2, 3, 4, 5, 6]  # 중첩되지 않음

>>> a + b           # 같은 결과
[1, 2, 3, 4, 5, 6, 4, 5, 6]

List 값 교체하기

indexing 사용하여 교체

>>> a = [1, 2, 3]
>>> a[0] = 4
>>> a
[4, 2, 3]

slicing 사용하여 교체

>>> a = [1, 2, 3, 4]
>>> a[1:3] = [5, 6, 7]
>>> a
[1, 5, 6, 7, 4]

List의 값 지우기

`.pop()`

.pop() 메서드를 사용하면 값이 추출되고 리스트에서 삭제가 됨.

>>> a = [1, 2, 3, 4]
>>> a.pop()   # 마지막 값이 추출 됨
4
>>> a
[1, 2, 3]
>>> a.pop(0)  # index 사용
1

List의 특정 값 지우기

.remove() 메서드 사용

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

>>> b = [1, 2, 3, 4, 1]
>>> b.remove(1)  # 값이 하나 이상일 경우, 첫 번째 값이 삭제됨 
>>> b
[2, 3, 4, 1]

`del` 사용하여 지우기

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

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

slicing 사용하여 지우기

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

List의 모든 값 지우기

.clear() 메서드 사용

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

List membership 확인

>>> a = [1, 2, 3, 4]
>>> 1 in a
True
>>> 5 in a
False

List Iteration

>>> a = [1, 2, 3, 4]
>>> for i in a:
        print(i, end=' ')
1 2 3 4

다른 List 메서드

`.count()`

list 값의 갯수를 반환

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

`.index()`

list 값의 인덱스를 확인하기 위해 사용

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

`.reverse()`

list 값을 거꾸로 나열

>>> a = [1, 2, 3]
>>> a.reverse()
>>> a
[3, 2, 1]              # list 값의 위치가 변함

>>> a = [1, 2, 3]
>>> list(reversed(L))  # reversed() built-in 함수를 이용
[3, 2, 1]
>>> a
[1, 2, 3]              # list 값의 위치가 변하지 않음

`.sort()`

list 값을 정렬

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

>>> a = [4, 7, 9, 1]
>>> a.sort()
>>> a
[1, 4, 7, 9]

>>> a = ['a', 'A', 'b' 'B']  # 대문자 먼저
>>> a.sort()
>>> a 
['A', 'B', 'a', 'b']

.sort()에 정렬 기준 주기

>>> a = ['a', 'b', 'A', 'B']
>>> a.sort(key=str.lower)  # 문자를 소문자로 변환 후 정렬
>>>a
['a', 'A', 'b', 'B']

>>> a = ['a', 'b', 'A', 'B']
>>> a.sort(key=str.lower, reverse=True)  # 거꾸로 정렬
['b', 'B', 'a', 'A']

sorted() built-in 함수를 사용할 수 있음.

>>> a = ['a', 'b', 'A', 'B']
>>> sorted(a, key=str.lower, reverse=True)
['b', 'B', 'a', 'A']

>>> sorted([x.lower() for x in a], reverse=True)  # List Comprehension를 이용하여 새로운 list를 만들어 사용
['b', 'b', 'a', 'a']

더 알아보기

List를 만드는 다른 방법

range() built-in 함수를 사용하여 연속된 숫자로 List 생성

>>> a = list(range(5)  
>>> a
[0, 1, 2, 3, 4]

map() built-in 함수를 사용하여 기존 list와 다른 새로운 list를 생성

>>> list(map(abs, [-1, -2, 0, 1, 2]))
[1, 2, 0, 1, 2]

Stack 만들기

LIFO(Last-in-first-out) stack 구조를 만들 수 있음.

>>> L = []
>>> L.append(1)  # stack에 값 넣기
>>> L.append(2)
>>> L
[1, 2]
>>> L.pop().     # 마지막으로 입력된 값 꺼내기
2
>>> L
[1]

List Copy

용어 그대로 list를 복사하는 방법

잘못된 사용(주의)

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

위와 같이 변수 a를 변수 b에 대입하면 같은 값을 가져오는 것 처럼 보여 복사된거 처럼 보이지만 사실은 위의 그림에서 보는 것과 같이 같은 객체 정보를 참조하는 것으로 list의 값이 변경될 경우 변수 b의 값도 같이 변경되서 보임.

>>> id(a)
4501679424
>>> id(b)
4501679424  # 같은 메모리 주소를 가짐
>>> a.append(4)
>>> a
[1, 2, 3, 4]
>>> b
[1, 2, 3, 4]

위의 예시 처럼 변수 a와 b는 같은 객체를 참조하기 때문에 의도적으로 같은 값을 가지는 것이 아닌 각각 별개의 값을 가지길 원할 때 위와 같은 방법을 사용 시 프로그램에 심각한 오류를 초래할 수 있음.

파이썬에서 대입(=)이란 변수에 값을 저장하는 것이 아닌 오브젝트의 메모리 주소를 저장하는 것을 의미

바른 사용

얕은 복사(Shallow copy)

>>> a = [1, 2, 3, 4]
>>> b = a[:]      # 얕은 복사
>>> c = list(a)   # 다른 방법
>>> d = a.copy()  # 또 다른 방법
>>> id(a)
4497110784
>>> id(b)
4501298944  # 메모리 주소가 다름
>>> id(c)
4498557632
>>> id(d)
4501296640
>>> a.append(5)
>>> a
[1, 2, 3, 4, 5]
>>> b
[1, 2, 3, 4]  # 값 변하지 않음
>>> c
[1, 2, 3, 4]
>>> d
[1, 2, 3, 4]

주의사항

위의 방법으로 복사가 되었지만 주의사항이 있음. 리스트 값 중에 mutable(가변) 값이 있고 그 값이 변경되면 복사된 모든 리스트에 적용됨. 예를들어 위의 예시를 보면 복사를 통해서 리스트가 새로 만들어 졌지만 위 그림을 보면 각 리스트의 같은 index 값들은 같은 int 클래스의 인스턴스 오브젝트 주소 정보를 참조하고 있음. 그러나 integer나 string은 immutable(불변)의 값 이기 때문에 아래와 같이 변수 a 리스트에서 값을 변경해도 다른 리스트에는 영향이 없음

>>> a[0] = 5  # 새로운 int 인스턴스가 만들어지고 index 0이 새로운 인스턴스 주소 값을 가짐.
>>> a
[5, 2, 3, 4]  
>>> b 
[1, 2, 3, 4]  # 변경되지 않음
>>> c
[1, 2, 3, 4]
>>> d 
[1, 2, 3, 4]

그러나 아래와 같이 리스트안에 리스트(중첩 리스트)가 존재할 경우 리스트는 mutable이기 때문에 값이 변경되면 복사된 모든 리스트에 적용이 됨.

>>> a = [1, [2, 3]]
>>> b = a[:]
>>> c = list(a]
>>> d = a.copy()
>>> a
[1, [2, 3]]
>>> b
[1, [2, 3]]
>>> c
[1, [2, 3]]
>>> d
[1, [2, 3]]

>>> a[1].append(4)  # 중첩된 리스트 값 변경
>>> a
[1, [2, 3, 4]]
>>> b 
[1, [2, 3, 4]]  # 다른 리스트에 영향 받음
>>> c
[1, [2, 3, 4]]
>>> d
[1, [2, 3, 4]]

즉 얕은 복사라는 단어 답게 표면적인 부분만 복사가 이루어 지고 내부는 복사가 안됨. 이러한 문제를 해결하기 위해 깊은 복사를 사용.

깊은 복사(Deep copy)

copy 모듈의 deepcopy를 사용.

>>> import copy
>>> a = [1, [2, 3]]
>>> b = copy.deepcopy(a)
>>> id(a)
4493449024
>>> id(b)
4497513408
>>> a
[1, [2, 3]]
>>> b
[1, [2, 3]]
>>> a[1].append(4)
>>> a
[1, [2, 3, 4]
>>>b
[1, [2, 3]]

위 그림 처럼 깊은 복사를 사용하면 중첩된 리스트도 새로운 리스트가 만들어 지면서 복사가 되고 복사된 리스트 끼리 영향을 주지 않은다.

List comprehensions

List comprehension을 이용하면 코드 한줄로 list를 생성할 수 있고, 생성 속도도 더 빠르기 때문에 큰 데이터를 사용하여 list를 생성 시 사용하면 이점을 얻을 수 있음.

>>> res = [c for c in 'spam']
>>> res
['s', 'p', 'a', 'm']

# list를 만드는 같은 방법
>>> res = []
>>> for c in 'spam':
        res.append(c)
>>> res
['s', 'p', 'a', 'm']

파이썬 String

nickas — Sat, 11 Apr 2020 20:31:30 +0900

String 변수 만들기

>>> a = ''  # 빈 string 만들기
>>> a
''
>>> type(a)
str
>>> b = str()
>>> b
''
>>> type(b)
str

>>> a = 'String'
>>> a
'String'
>>> type(a)
str

숫자로 만들어진 `String`은 `Integer`가 아님

>>> a = '1'
>>> a
'1'
>>> type(a)
str

>>> b = 1
>>> b
1  # (주의) ''(작은 따옴표)가 없으면 integer 임
>>> type(b)
int

Apostrophe 사용하기

>>> a = "String's"  # Apostrophe를 사용하기 위해서는 큰 따옴표를 사용.
>>> a
"String's"

String 변수를 만들 때 큰 따옴표(“”)와 작은 따옴표(‘’) 둘 중 아무거나 사용해도 상관 없으나 PEP8 권고 사항에서는 큰 따옴표를 사용하라고 함.

그러나 아래와 같이 문자열 안에 큰 따옴표를 사용해야 할 경우는 작은 따옴표를 사용

>>> a = 'I told "I like you"'
>>> a
'I told "I like you"'

>>> a = "I told \"I like you\""  # \(backslash)를 사용하면 escape 됨
>>> 'I told "I like you"'

Escape 문자 사용하기

>>> a = 'String\ntab\t'  # Escape 문자 사용하기
>>> a
'String\ntab\ttab'
>>> print(a)  # 내장 IDE에서는 escape 문자를 처리하지 못하기 때문에 print() 사용
String
tab    tab

multiline 사용하기

>>> a = """multiline
multiline 
multiline"""
>>> a
'multiline\nmultiline\nmultiline'
>>> print(a)
multiline
multiline
multiline

>>> b = '''multiline
multiline
multiline'''
>>> print(b)
multiline
multiline
multiline

mulitline을 사용하는 예시 중 하나는 HTML 태그를 변수에 저장하기 위함.

>>> a = """<html>
<body>
HTML code
</body>
</html>"""

Raw string 사용하기

>>> a = r'String\ntab\t'
>>> a
'String\ntab\t'

String 연산하기

>>> a = 'Ham'
>>> b = 'burger'
>>> a + b  # Concatenate
'Hamburger'

>>> c = 1
>>> a + b + c
TypeError: can only concatenate str (not "int") to str

>>> a * 3  # Repeat
'HamHamHam'

>>> a = "I" ' like' " hamburger"  # 이렇게 사용할 수 있으나 잘 사용하지 않음(가독성이 떨어지니까 ㅋ)
>>> a
>>> 'I like hamburger

String 변수는 다른 타입(예: Integer)의 변수와 연산될 수 없음

아래와 같이 형 변환을 하여 연산

>>> s = '42'
>>> i = 1
>>> int(s) + i
43
>>> s = str(i)
'421'

String indexing and slicing

Indexing

>>> a = 'Hello'
>>> a[0]  # []을 사용하여 Indexing
'H'
>>> a[1]
'e'
>>> a[-1]
'o'
>>> a[-2]
'l'

첫 글자부터 indexing하여 가져 올려면 0부터 시작하고 마지막 글자부터 가져 올려면 -1부터 시작함 .

Slicing

>>> a = 'Hamburger'
>>> a[:]    # 모든 글자 포함
'Hamburger'
>>> a[:3]   # 앞 3글자만 포함
'Ham'
>>> a[3:]   # 앞 3글자 제외
'burger'
>>> a[1:]   # 첫 글자 제외
'amburger'
>>> a[:-1]  # 마지막 글자 제외
'Hamburge'
>>> a[1:3]
'am'
>>> a[1:-1] # 첫 글자와 마지막 글자를 제외
'amburge'
>>> a[0:-1] # 마지막 글자 제외
'Hamburge]

[start:end] 이와 같이 처음 자를 곳과 마지막으로 자를 곳을 지정.
[strat:] 마지막 자를 곳을 지정하지 않으면 문자열 마지막을 의미.
[:end] 처음 자를 곳을 지정하지 않으면 문자열 처음(0)을 의미.
[0:-1] 0은 문자열 첫 문자 앞을 의미하고, -1은 문자열 마지막 문자 앞을 의미.

[start:end:step] 이와 같이 step을 지정하여 지정한 숫자 만큼 건너뛰고 문자를 가져 올 수 있음.

>>> a = 'sliceofspam'
>>> a[1:-1:2]
'lcosa'
>>> a[::2]
'siefpm'
>>> a[::1]
'sliceofspam'
>>> a[::-1]  # reversing
'mapsfoecils'
>>> a[5:1:-1]
'oeci'

a[5:1:-1]의 경우 -1로 인해서 slicing을 거꾸로 함. 즉 5번 부터 거꾸로 4글자를 가져옴.(예를들어 a[1:5] 같은 경우 1번 부터 시작하여 4글자를 가져옴.). 헷갈림 ㅋ

`slice()` 사용

>>> 'spam'[slice(1, 3)]
'pa'
>>> 'sapm'[slice(None, None, -1)]
'maps'

String formatting

String formatting expressions

'...%s...' % (값) 형식을 사용.

>>> a = 'hamburger'
>>> 'I like a %s' % a  # %s는 string을 의미
'I like a hamburger'

%d는 Decimal을 의미하고 숫자 관련 출력 형식을 조절할 수 있음.

>>> x = 1234
>>> 'integers: %d, %06d' % (x, x)
'integers: 1234, 001234'

Dictionary-Based formatting expressions

>>> '%(qty)d more %(food)s' % {'qty': 1, 'food': 'spam'}
'1 more spam'

String formatting method call

'...{}...'.format(값) 형식을 사용.

# 위치에 따른 치환
>>> a = 'hamburger'
>>> b = 'sandwich'
>>> 'I like a {} and {}'.format(a, b)
'I like a hamburger and sandwich'
>>> 'I like a {0} and {1}'.format(a, b)
'I like a hamburger and sandwich'
>>> 'I like a {1} and {0}'.format(a, b)
'I like a sandwich and hamburger'

# 키워드 치환
>>> template = 'I like a {hamburger} and {sandwich}'
>>> template.format(hamburger='Cheese burger', sandwich='Ham sandwich'
'I like a Cheese burger and Ham sandwich'

# 위 두개 동시 사용
>>> template = 'I like a {0} and {sandwich}'
>>> template.format('Cheese burger', sandwich='Ham sandwich')
'I like a Cheese burger and Ham sandwich'

`f-string` formatting

파이썬3.6 부터 지원.
위의 formatting 방식들과 비교 했을 때 가독성이 뛰어남.

string formatting

>>> a = 'hamburger'
>>> b = 'sandwich'
>>> f'I like a {a} and {b}'
'I like a hamburger and sandwich'
>>> f'I like a {b} and {a}'
'I like a sandwich and hamburger'

Dictionary 방식

>>> food = {'hamburger': 'Cheese burger', 'sandwich': 'Ham sandwich'}
>>> f'I like a {food['hamburger']} and {food['sandwich'])'
'I like a Cheese burger and Ham sandwich'

multiline

>>> name = 'John Doe'
>>> age = 32
>>> occupation = 'software engineer'
>>> msg = (
f'Name: {name}\n'
f'Age: {age}\n'
f'Occupation: {occupation}'
)
>>> print(msg)
Name: John Doe
Age: 32
Occupation: software engineer

calling function

>>> def add(x, y):
        return x + y
>>> a = 3
>>> b = 4
>>> f'{a} + {b} = {add(a, b)}'
'3 + 4 = 7'

숫자 길이

>>> a = 123
>>> f'{a}, {a:04}, {a:05}'
'123, 0123, 00123'

들여쓰기

기본으로 왼쪽 열에 맞춤이고 설정을 할 수 있음.

>>> a = 123
>>> f'{a:>10}'
'       123'

String 메서드

a = 'string'를 선언 시 변수 a는 str() 클래스의 인스턴스가 되기 때문에 str() 클래스의 메서드를 사용할 수 있음.

2020/04/05 - [Basic] - 변수

변수

변수 선언 파이썬은 아래와 같이 변수 선언 >>> a = 1 # int 형 선언 >>> type(a) # type() 빌트인 함수를 사용하여 형 확인 int >>> a 1 >>> a = '1' # ''를 사용하면 str 형이 선언 >>> type(a) str >>> a '1'..

python-world.tistory.com

`.find()`

문자열에서 주어진 값의 인덱스를 반환. (예: hello 같이 l이 두개 인 경우 처음 인덱스를 반환). 없으면 -1을 반환.

>>> a = 'hello'
>>> a.find('he')
1
>>> a.find('o')
4

>>> a = 'String'
>>> a.find('St')

>>> a = '  String  '
>>> a.rstrip()
'  String'
>>> a.lstrip()
'String  '
>>> a.strip()
'String'
>>> a
'  String  '

`.strip()`

공백을 제거하여 반환.

>>> a = '  String  '
>>> a.rstrip()
'  String'
>>> a.lstrip()
'String  '
>>> a.strip()
'String'
>>> a
'  String  '

.rstrip()는 오르쪽 공백만 제거.
.lstrip()는 왼쪽 공백만 제거.
.strip()는 양쪽 공백을 제거.

`.replace()`

문자열을 주어진 값으로 변환하여 반환.

>>> a = 'String....String....String'
>>> a.replace('St', 'b')  # 전체를 변환
'bring....bring....bring'
>>> a.replace('St', 'b', 1)  # 처음 하나만 변환
'bring....String....String'
>>> a
'String....String....String'

`.join()`

주어진 값을 구분자로 사용하여 list안의 값들을 하나의 문자열로 합친 후 반환

>>> ','.join(['eggs', 'sausage', 'ham', 'toast'])
'eggs,sausage,ham,toast'

`.split()`

주어진 값을 구분자로 사용하여 하나의 문자열을 list로 분리 후 반환

>>> a = 'eggs,sausage,ham,toast'
>>> a.split(',')
['eggs', 'sausage', 'ham', 'toast']

`.isdigit()`

String 변수가 1 같은 숫자 이면 True 반환, 아니면 False 반환

>>> a = '1'
>>> a.isdigit()
True

>>> a = 'String'
>>> a.isdigit()
False

`.isalpha()`

String 변수가 abc 같은 문자 이면 True 반환. 아니면 False 반환

>>> a = 'String'
>>> a.isalpha()
True

>>> a = '1'
>>> a.isalpha()
False

`.upper()`

문자열을 대문자로 반환

>>> a = 'string'
>>> a.upper()
'STRING'

`.lower()`

문자열을 소문자로 반환

>>> a = 'STRING'
>>> a.lower()
'string'

`.startswith()`

문자열이 주어진 값으로 시작하면 True 반환. 아니면 False 반환.

>>> a = 'String'
>>> a.startswith('S')
True
>>> a.startswith('s')
False

`.endswith()`

문자열이 주어진 값으로 끝나면 True 반환. 아니면 False 반환

>>> a = 'String'
>>> a.endswith('ng')
True

더 알아보기

파이썬3부터 string은 Unicode임.
String은 불변(변경할 수 없음) 타입임. 예를들어 .replace() 메서드로 원하는 값을 변경 시 원래의 문자열은 변경되지 않고 변경된 형태의 문자열이 반환됨. 즉 변경된 문자열을 사용하고 싶으면 별도의 변수에 저장.

파이썬 변수

nickas — Sun, 5 Apr 2020 00:28:58 +0900

변수 선언

파이썬은 아래와 같이 변수 선언

>>> a = 1         # int 형 선언
>>> type(a)       # type() 빌트인 함수를 사용하여 형 확인
int
>>> a
1

>>> a = '1'       # ''를 사용하면 str 형이 선언
>>> type(a)
str
>>> a
'1'
>>> a.isdigit()   # isdigit()를 사용하여 str형이 정수형 str인지 확인 가능
True

>>> a = 'string'  # str 형 선언
>>> type(a)
str
>>> a
'string'

>>> a = 1.23      # floating 형 선언
>>> type(a)
float
>>> a
1.23

>>> a = [1, 2, 3] # list 형 선언
>>> type(a)
list
>>> a
[1, 2, 3]

>>> a = {'a': 1, 'b': 1, 'c': 1}  # dictionary 형 선언
>>> type(a)
dict
>>> a
{'a': 1, 'b': 1, 'c': 1}

def func():
    pass

>>> a = func  # func()를 할당하면 함수가 실행되어 값이 할당 됨.
>>> type(a)
function
>>> a
<function __main__.func()>

파이썬은 다른 프로그래밍 언어와 다르게 변수 선언 시 형(type)을 지정하지 않음.
변수에 어떤 형이 할당되는지에 따라 변수형이 결정됨.

프로그래밍 언어에서 = 기호는 수학기호에서 말하는 똑같다는 의미가 아니고 왼쪽의 값을 오른쪽에 할당하라는 의미. ==이 기호가 똑같다는 의미. 모든 프로그래밍 언어에서 이와 같이 사용.

사실 파이썬은 변수에 어떤 값을 할당할 때 그 값이 할당되는 것이 아니라 값이 실제 저장되어 있는 메모리 주소 정보를 가지고 있음. 즉, a = 1이라고 선언하면 숫자 1은 int()클래스의 인스턴스(인스턴스 오브젝트(객체))가 되고 아래 그림과 같이 변수 a는 int() 인스턴스의 메모리 주소 정보를 가지게 됨.(C에서는 이것을 pointer라고 부름)

파이썬은 변수 선언 시 형 정의를 하지 않기 때문에 사용 시 주의 필요. 즉, 다른 프로그래밍 언어에서는 int형으로 선언된 변수에 str형을 할당하면 에러를 발생하지만 파이썬은 에러를 발생하지 않을뿐만 아니라 int형 변수가 str형 변수가 됨. 이것을 Dynamic Type이라고 함.
형 검증을 위해 isinstance()라는 빌트인 함수를 사용할 수 있음. isinstance(a, str) 변수 a가 str형일 경우 True를 반환하고, 아닐경우 False를 반환.

그래서 파이썬은 모든 것이 객체라고 하는 것임.

`is` vs `==`

==는 두 변수가 같은 값을 가지고 있는지 확인할 때 사용

>>> a = 1
>>> b = 1
>>> a == b
True

>>> a = 1
>>> b = 2
>>> a == b
False

is는 두 변수가 같은 객체인지 확인할 때 사용

>>> a = 1
>>> b = a  # 변수 b에 1의 값이 할당되는 것이 아니라 1의 메모리 주소(위치)가 할당 됨.
>>> a is b
True

>>> a = 1
>>> b = 2
>>> a is b
False

특이한 경우

>>> a = 1
>>> b = 1
>>> a == b
True
>>> a is b
True

a = 1과 b = 1은 각각 선언되었기 때문에 각각 별도의 int() 클래스의 인스턴스가 생성됨.
그러나 a is b 리턴 값이 True인 이유는 파이썬 인터프리터가 한번 생성된 인스턴스 오브젝트를 캐싱하고 있다가 다른 변수가 사용 시 재 사용함. 즉, a = 1이 선언될 때 1의 값을 가지고 있는 int() 클래스의 인스턴스가 생성 및 캐싱되고, b = 1 이 선언될 때 이미 만들어진 1의 값을 가지고 있는 int()의 인스턴스를 재 사용함. 그러나 Garbage collection으로 사라진 인스턴스는 재사용할 수 없음.

Garbage collection은 heap 메모리에 생성되어 사용되지 않는 오브젝트를 감지하여 메모리 상에서 지워버리는 CPython의 기능?이고, JAVA의 Garbage collection와 비슷한 기능?이다. 자세한 사항은 어려운 내용이기에 관심 있으면 Google 검색.

Python World

아메리슬립 침대 구매 후기

Scrapy 구조 알아보기

Components

데이터 흐름

Scrapy 간단 사용법

설치

프로젝트 생성

간단 spider 생성

Scrapy 실행

Spider 코드 줄이기

Item 사용하기

Item 파일로 저장하기

Logging 사용하기

팁

사이트 제한으로 crawling이 안되는 경우

과도한 요청으로 인한 차단을 피하는 방법

HTTP cache를 사용

파이썬 조건문 그리고 반복문

if

elif 문 사용

membership 확인

for

Dictionary 사용

확장된 loop 변수 할당 사용법

nested for loop

필터로써 if 사용

while

else 문 사용

break 문 사용

continue 문 사용

pass 문 사용

Set

Set

특징

Set 만들기

아이템 추가

여러 아이템 추가 한번에 추가

아이템 가져오기

아이템 제거

.remove() 사용

.discard() 사용

.clear() 사용

연산

교집합

합집합

차집합

대칭차집함

Set 메서드

.issubset()

.issuperset()

.isdisjoint()

Set 복사

Comprehensions

frozenset

연산

메서드

.issubset()

.issuperset()

.isdisjoint()

복사

파이썬 Tuple

Tuple 만들기

아이템 추가

아이템 가져오기

netsted 아이템 가져오기

아이템 변경하기

연산

Slicing

정렬하기

Tuple 메서드

.index()

.count()

namedtuple

파이썬 Dictionary

Dictionary 만들기

Dictionary 생성과 함께 아이템 추가하기

Dictionary nesting

Dictionary에 아이템 추가하기

Dictionary 값 가져오기

`elif` 문 사용

`else` 문 사용

`break` 문 사용

`continue` 문 사용

`pass` 문 사용

`.remove()` 사용

`.discard()` 사용

`.clear()` 사용

`.issubset()`

`.issuperset()`

`.isdisjoint()`

`.issubset()`

`.issuperset()`

`.isdisjoint()`

`.index()`

`.count()`

`namedtuple`

Dictionary 키 `set` 연산

`.keys()`

`.values()`

`.items()`

`.get()`

`.update()`

`.pop()`

`OrderedDict`

`KeyError` 대비하기

`if`문 사용

`try`문 사용

`.get()` 메소드 사용

`for`문과 사용

`.append()`

`.insert()`

`.extend()`

`.pop()`

`del` 사용하여 지우기

`.count()`

`.index()`

`.reverse()`

`.sort()`

숫자로 만들어진 `String`은 `Integer`가 아님