파이썬에서 어떤 값을 더할 때 +를 사용하여 새로운 변수에 결과값을 담을 수도 있고 기존에 사용하던 변수에 +=로 값을 대체할 때가 있습니다. 더 나아가 각 리스트를 합칠 때도 사용됩니다. 아래는 리스트를 합치는 예시입니다.

a = [1,2]
b = [3,4]
c = a+b
print(c)
# [1, 2, 3, 4]




a += b
print(a)


# [1, 2, 3, 4]


위 결과만 봤을 때 +와 +=의 차이가 없는 것처럼 확인됩니다. 그러나 아래 예시를 보면 똑같다 라는 가정이 틀렸다는 것을 볼 수 있습니다.

a = [1,2]
b = (3,4)
c = a+b

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate list (not "tuple") to list


a += b
print(a)

# [1, 2, 3, 4]


리스트와 튜플로 선언 후 + 연산자로 결과를 새로운 변수 c에 담으려 하면 에러를 반환하는 반면, += 연산자를 사용하여 a 변수에 결과를 반영하면 의도한대로 합쳐진 리스트가 나오는 것을 볼 수 있습니다.


여기서 + 는 __add__ 함수를 호출하고 +=는 __iadd__ 함수를 호출하게 됩니다. 

여기서 + 연산자는 대칭입니다. 대칭이라는 의미는 a+b와 b+a는 항상 같은 결과를 가져와야 합니다. 위와 같이 타입이 다른 경우, 연산자의 좌변과 우변의 선언 순서에 따라 타입이 변경되기 때문에 오류를 발생시킵니다. 

반면 += 연산자는 비대칭입니다. 선언문 왼쪽의 변수타입에 의해 결정이 됩니다. 따라서 a+=b는 a 타입을 유지하게 됩니다.


만약 b+=a 일 경우면 아래와 같은 결과를 반환합니다.

a = [1,2]
b = (3,4)
b += a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate tuple (not "list") to tuple


이처럼 +와 +=는 비슷해 보이지만 동작하는 방식이 다르므로 사용할 때 유의하여 사용해야 합니다.

합칠 대상의 결과가 2개 이상인 경우

union()

union()를 사용해서 1개로 합칠 수 있습니다. union()의 2번째 인자는 중복을 허용할지에 대한 여부인데 기본값은 False로 중복을 허용하지 않습니다. (중복데이터일 경우 중복제거)

result = a.union(b, all=True)

결과가 쿼리셋 리스트 타입이기 때문에 ORM 형식을 그대로 사용할 수 있습니다.

| 연산자

| 연산자를 사용하여 손쉽게 쿼리셋 타입 리스트를 합칠 수 있습니다.

result = a | b

결과가 쿼리셋 리스트 타입이기 때문에 ORM 형식을 그대로 사용할 수 있습니다.

+ 연산자

+ 연산자를 사용하기 위해선 각 쿼리셋 리스트 타입을 일반 리스트 타입으로 변경한 후 합칩니다.

a = list(a)
b = list(b)
result = a + b

합칠 대상이 단일일 경우

합칠 대상이 2개 이상이 아닌 1개만 존재하는 경우, 위의 방법을 전부 사용하지 못합니다.

chain()

chain() 함수를 사용하면 대상이 단일 건이거나 복수개여도 언제든지 합칠 수 있습니다.

from itertools import chain
result = list(chain(a, b))

list 변환 후 병합

쿼리셋 리스트 타입을 리스트로 변환 후, 단일건을 해당 리스트에 추가하는 형식입니다.

a = list(a)
a.append(b)

limit이 걸려있는 쿼리셋 리스트일 경우

limit이 걸려있는 경우에는 | 연산자 방식을 제외하고 전부 사용할 수 있습니다.

결론

병합에는 여러 방법이 있지만 가장 좋은 방법은 ORM에서 제공하는 union()과 chain() 입니다. 쿼리 결과를 병합하는 것을 지양해야 하지만 어쩔 수 없이 사용해야 한다면 union()과 chain()을 상황에 맞게 사용하면 됩니다.

Django model ORM로 Where절에 or 문을 추가하고 싶다면 Q() 를 사용해야 합니다. 사용법은 아래와 같습니다.

사용하기

OR

from django.db.models import Q


Base.objects.filter(
    Q(name='qwer') | Q(no=152124)
# 동일한 결과
# SELECT * FROM base WHERE no=152124 OR name='qwer'

Q() 조건 연결

from django.db.models import Q



q = Q()

q.add(Q(no=12121), q.OR)
q.add(Q(name=lee)|Q(name=kim), q.AND)
q.add(Q(142411), q.OR)

Base.objects.filter(q)
# 동일한 결과
# SELECT * FROM base WHERE (no=12121 AND (name='lee' OR name='kim')) OR no=142411

NOT 구문 표현하기

from django.db.models import Q


q = Q()
q.add(Q(no=12121), q.OR)
q.add(Q(name=lee) & ~Q(name=kim), q.AND)
Base.objects.filter(q)
# 동일한 결과
# SELECT & FROM base WHERE no=12121 AND name='lee' AND NOT (name='kim')

주의사항

Q()를 사용할 때 조심할 점은 첫 Q() 선언 이후 .add()로 추가할 때, 2번째 인자값은 어떤 쿼리로 연결할지를 나타내는데 여기에 선언된 값으로 앞의 조건과 연결이 됩니다.

q = Q(no=1)
q.add(name='lee', q.OR)
# no=1 or name='lee'


Q를 선언한 이후, 해당 인스턴스에서 .OR이나 .AND.connector를 볼 수 있습니다. 여기서 OR나 AND는 조건문과 동일한 연결문입니다. .connector는 바로 이전에 사용한 연결문을 뜻합니다. 아무것도 선언되지 않았을 때, 기본 값은 AND 입니다.

OR 나 AND는 클래스 변수로 선언되어 있기 때문에 q = Q(); q.AND 나 Q.AND나 동일합니다.

q = Q(item_no=123123123)
print(q.connector)
q.add(Q(gs_item_no=0), q.OR)
print(q.connector)
# AND
# OR


Selenium은 웹앱을 테스트 하는데 주로 사용하는 프레임워크입니다. webdriver API를 통해 브라우저를 제어하게 할 수 있습니다. JavaScript를 이용해 비동기적으로 컨텐츠를 호출할 수 있으므로 브라우저에서 보이는 컨텐츠라면 전부 가져올 수 있다는 것을 의미합니다. 한마디로 Selenium은 실제 웹 브라우저가 동작하기 때문에 JS로 렌더링이 완료된 후의 DOM 결과물에 대한 접근이 가능합니다.

설치

파이썬

브라우저의 업데이트 마다 새로운 드라이버를 잡기 때문에 최신버전을 유지하는 것이 좋습니다.

pip3 install selenium

webdriver

아래에서는 chrome을 설치하여 사용합니다.

https://sites.google.com/a/chromium.org/chromedriver/downloads 에서 가장 최신인 드라이버 버전을 선택한 후, OS에 맞는 드라이버를 다운받습니다. 



설치 받은 압축파일을 해제하면 chromedriver 파일이 나오는데 해당 파일을 향후 사용하기 쉬운 장소로 변경합니다.

PhantomJS webdriver

PhantomJS는 화면이 존재하지 않은 브라우저입니다. CLI서버 환경에서 테스트를 진행할 예정이면 PhantomJS를 사용하는 것이 좋습니다. PhantomJS에 대한 설명은 https://brownbears.tistory.com/363 에서 확인할 수 있습니다.

http://phantomjs.org/download.html 에서 현재 OS 환경에 맞는 압축파일을 받은 후 압축을 풀어줍니다. 향후 사용할 파일의 위치는 bin폴더의 phantomjs 파일 입니다.

현재 PhantomJS는 개발이 진행되고 있지 않기 때문에 현재 브라우저가 최신이라면 크롬의 headless 모드를 사용하는 것이 좋습니다.

사용하기

아래와 같이 위에서 설치한 파일 위치를 입력합니다.

from selenium import webdriver


chrome_driver = webdriver.Chrome('chromedriver 파일 위치')
phantom_driver = webdriver.phantomjs('phantomjs 파일 위치')


selenium은 실행하기 위한 자원들이 전부 로드될 때까지 기다려 줍니다. 만약 이 시간을 지정하고 싶다면 implicitly_wait(초) 를 작성합니다. 아래는 implicitly_wait()을 사용하고 https://naver.com을 호출하는 예제입니다.

from selenium import webdriver


chrome_driver = webdriver.Chrome('/Users/user/Documents/chromedriver')

# 로드를 위해 5초 대기
chrome_driver.implicitly_wait(5)

chrome_driver.get('https://naver.com')


만약 정상적으로 호출이 되었다면 새로운 chrome 브라우저에 네이버가 떠 있는 것을 볼 수 있습니다.

예시

위 https://naver.com에서 로그인을 시도해 봅니다.

  1. 먼저 네이버의 로그인 화면 url인 https://nid.naver.com/nidlogin.login 를 입력합니다.
  2. 네이버 로그인의 화면에서 아이디 입력 태그의 id명은 id, 비밀번호 입력태그의 id명은 pw로 되어 있으므로 아래처럼 해당 태그에 값을 세팅합니다.
  3. 로그인 버튼을 클릭합니다.
from selenium import webdriver


chrome_driver = webdriver.Chrome('/Users/user/Documents/chromedriver')

# 로드를 위해 5초 대기
chrome_driver.implicitly_wait(5)

# 네이버 로그인페이지
chrome_driver.get('https://nid.naver.com/nidlogin.login')

# 아이디 비밀번호 입력
chrome_driver.find_element_by_id('id').send_keys('naver')
chrome_driver.find_element_by_id('pw').send_keys('naver')

# 로그인 버튼 클릭
chrome_driver.find_element_by_xpath('//*[@id="frmNIDLogin"]/fieldset/input').click()


계정정보가 올바르다면 정상적으로 로그인이 되는 것을 확인할 수 있습니다.


로그인이 필요한 페이지의 경우 로그인을 한 다음, 호출하고자 하는 페이지를 다시 불러와 사용할 수 있습니다. 아래는 로그인 후, BeautifulSoup을 함께 사용한 예시입니다.

from selenium import webdriver
from bs4 import BeautifulSoup


chrome_driver = webdriver.Chrome('/Users/user/Documents/chromedriver')

# 로드를 위해 5초 대기
chrome_driver.implicitly_wait(5)

# 네이버 로그인페이지
chrome_driver.get('https://nid.naver.com/nidlogin.login')

# 아이디 비밀번호 입력
chrome_driver.find_element_by_id('id').send_keys('id')
chrome_driver.find_element_by_id('pw').send_keys('password')

# 로그인 버튼 클릭
chrome_driver.find_element_by_xpath('//*[@id="frmNIDLogin"]/fieldset/input').click()


# 네이버 내정보
chrome_driver.get('https://nid.naver.com/user2/help/myInfo.nhn')
# html 로드
html = chrome_driver.page_source
bs = BeautifulSoup(html, 'html.parser')
notices = bs.find_all('div', class_='form')



테스트를 진행할 때, 네이버는 적절하지 않을 수 있습니다. 그놈의 자동입력방지문자

WHERE 절의 subquery

item = Item.objects.all()
base = Base.objects.filter(no__in=Subquery(item.values('no')))
== 동일 쿼리
SELECT *
FROM base
WHERE no IN (SELECT no FROM item)

SELECT 절의 subquery

item = Item.objects.all()
base = Base.objects.annotate(no=Subquery(item.values('no')))

== 동일 쿼리
SELECT *, (SELECT no FROM item) AS "no"
FROM base


더 복잡하게

먼저 위에서 그냥 예시를 들었던 모델은 아래와 같이 정의되었다고 가정합니다.

class Base(models.Model):
    no = models.BigAutoField(primary_key=True)
	cnt = models.IntegerField()
    name = models.CharField(max_length=100)


class Items(models.Model):
    no = models.BigAutoField(primary_key=True)
    name = models.CharField(max_length=100)
    base_no = models.ForeignKey(Base, db_column='base_no')


subquery 안에서 외부 테이블의 pk를 비교하여 같을 때만 반환해주는 예시는 아래와 같이 표현할 수 있습니다.

from django.db.models import OuterRef, Subquery


item_qs = Items.objects.filter(
    base_no=OuterRef('pk')
)
qs = Base.objects.annotate(
    item_name=Subquery(
        item_qs.values('name')[:1]
    )
)


위의 결과를 쿼리로 변환하면 아래와 같이 의도한대로 나옵니다.

SELECT "item_base"."no",
       "item_base"."name",

  (SELECT U0."name"
   FROM "item_items" U0
   WHERE U0."base_no" = ("item_base"."no")
   LIMIT 1) AS "item_name"
FROM "item_base"


만약 비교하고 싶은 컬럼이 pk가 아닌 일반 컬럼일 경우, 일반 컬럼을 작성하여 비교할 수 있습니다.

from item.models.base import Items, Base
from django.db.models import OuterRef, Subquery


item_qs = Items.objects.filter(
    base_no=OuterRef('cnt')
)
qs = Base.objects.annotate(
    item_name=Subquery(
        item_qs.values('name')[:1]
    )
)


-- 동일 쿼리
SELECT "item_base"."no",
       "item_base"."cnt",
       "item_base"."name",

  (SELECT U0."name"
   FROM "item_items" U0
   WHERE U0."base_no" = ("item_base"."cnt")
   LIMIT 1) AS "item_name"
FROM "item_base"


파이썬에서 문자열 포맷팅 방식은 다양합니다. 아래에서 다양한 방법과 사용법을 설명하겠습니다.

% operator (오래된 방식)

C에서 prinf 스타일로 사용한 적이 있으면 익숙한 방식입니다. python3 이전의 방식으로 편리하지만 타입을 정확하게 알고 작성해야 한다는 단점이 있습니다.

test = 'Hello %s' % 'Bob'
print(test)
# Hello Bob


만약 데이터 타입이 integer일 경우 아래와 같이 %s로 추가합니다.

test = 'age: %i' % 111
print(test)

# age: 111


만약 포맷팅하고자 하는 데이터 타입이 다를 경우, 아래와 같이 에러를 뱉게 됩니다.

test = 'age: %i' % '111'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: %i format: a number is required, not str

왜 좋지 않다고 할까?

바로 위에서 설명한 것과 같이 타입을 정확하게 알고 사용해야 한다는 단점도 있지만 포맷팅할 문자열이 길어지면 곧바로 더러워지는 것을 볼 수 있습니다.

first_name = 'Eric'
last_name = 'Idle'
age = 74
profession = 'comedian'
affiliation = 'Monty Python'
'Hello, %s %s. You are %s. You are a %s. You were a member of %s.' % (first_name, last_name, age, profession, affiliation)
# Hello, Eric Idle. You are 74. You are a comedian. You were a member of Monty Python.

str.format

파이썬3 이후부터 새로운 포맷팅을 제시합니다.

test = 'Hello {}'.format('Bob')
print(test)
# Hello Bob


파이썬3 에서도 % operator를 지원하지만 공식문서에서는 권장하지 않는다고 나와 있습니다. (새로나온 str.format이 너무 좋아서..)

format 메소드는 아래와 같이 여러 형태로 지원됩니다.

test = 'Hello {name}. count: {count}'
test.format(name='Bob', count=5)
# 'Hello Bob. count: 5'


test = 'Hello {1}. count: {0}'
test.format(10, 'Jim')

# 'Hello Jim. count: 10'

왜 좋지 않을까?

% operator보다는 읽기 좋지만 여러 매개변수와 긴 문자열을 처리할 때 장황하다는 것을 확인할 수 있습니다.

first_name = 'Eric'
last_name = 'Idle'
age = 74
profession = 'comedian'
affiliation = 'Monty Python'
print(('Hello, {first_name} {last_name}. You are {age}. ' + 
       'You are a {profession}. You were a member of {affiliation}.') \
       .format(first_name=first_name, last_name=last_name, age=age, \
               profession=profession, affiliation=affiliation))

# Hello, Eric Idle. You are 74. You are a comedian. You were a member of Monty Python.


.format()에 전달할 변수가 길다면 dictionary 형태로 담아서 .format(**some_dict)로 압축해서 전달할 수 있습니다. 파이썬 3.6이상에서는 이러한 문제를 해결하기 위해 좀 더 직관적인 방법을 제시합니다.

f-string

f-string은 파이썬 3.6 이상 버전에서만 지원하는 문법입니다. str.format이 % operator에 비해 강력하고 사용하기 쉽지만 f-string은 더욱더 간편해졌습니다.

name = 'Bob'
test = f'Hello {name}'
print(test)


# Hello Bob


str.format과 다르게 정수끼리의 산술 연산도 지원합니다.

a = 2
b = 3
test = f'sum: {a+b}'
print(test)

# sum: 5


f-string 선언을 먼저 한 후, 변수를 나중에 선언하는 형식 또한 가능합니다.

test = f'Hi {name}'
name = 'Bob'
print(test)


# Hi Bob

속도

아래 예시와 같이 f-string이 가장 빠른 것으로 확인할 수 있습니다. f-striing은 상수 값이 아닌 런타임에서 계산이 되는 표현식입니다. https://www.python.org/dev/peps/pep-0498/#abstract에서 f-string에 대한 자세한 내용을 확인할 수 있습니다.

% operator

>>> import timeit
>>> timeit.timeit("""name = "Eric"
... age = 74
... '%s is %s.' % (name, age)""", number = 10000)

0.003324444866599663

str.format

>>> timeit.timeit("""name = "Eric"
... age = 74
... '{} is {}.'.format(name, age)""", number = 10000)
0.004242089427570761

f-string

>>> timeit.timeit("""name = "Eric"
... age = 74
... f'{name} is {age}.'""", number = 10000)
0.0024820892040722242


+ Random Posts