지난 시간

지난 7월 17일 Google Adsense를 신청 했었고 일반적으로 3일 정도 걸린다는 안내와는 다르게 10일이나 걸렸습니다. 승인이 늦게 나는 이유에 대해서는 여러 추측들이 있는 것 같지만 저는 앞선 포스트에서 알려드렸던 설정 외에는 건드린 것이 없고 그저 그 후로도 계속해서 새로운 글을 작성했습니다. 아마 저의 경우 게시글 수가 조금 부족했던 것이 그 이유가 아니였나 하고 생각해봅니다.

Google Search Console이 2018년 1월에 리뉴얼 되었듯이 Google Adsense 또한 조금 새롭게 바뀐 것 같았습니다. 처음 등록해보는 거라 미흡한 부분들이 있을 수도 있지만 제가 사용하는 Hexo_Next_Theme 에 직접 적용하며 하나씩 알아가 보겠습니다.

기본 광고 설정

• 메일의 시작하기 버튼을 클릭하거나 직접 Google Adsense 웹페이지에 접속하게 되면 아래 창을 만나게 됩니다.

• 빠르게 광고 설정을 클릭하여 다음 화면으로 진행하도록 합니다.

• 이전에는 머신러닝을 활용한 자동 광고 생성이 없었던 것 같은데 사용자의 편의를 위해 새롭게 이 기능을 제공하는 것 같습니다.
  그보다 상단의 붉은 경고가 눈에 띄는군요.

• ads.txt 라는 파일에 대해 잘 모르기 때문에 자세히 알아보기 버튼을 클릭해 보겠습니다.

• 실공급원과 부정적인 공급원을 구분하고 광고 소스를 목록화 하여 손해를 보지 않게 도와주는 텍스트 파일인 것 같습니다. 권장사항이지만 한다고 손해볼 것도 없으니 등록하도록 하겠습니다.
  위 안내글에서 언급되었듯이 직접 애드센스용 ads.txt를 생성할 수도 있지만, 앞선 붉은 경고문에서 지금 해결하기 버튼을 클릭하고 쉽게 다운받으실 수도 있습니다.
  (직접 작성하실 경우, 게시자 ID 는 Adsense 홈페이지 -> 계정 -> 설정 -> 계정 정보에 있습니다.)

• 이렇게 직접 작성하거나 다운받은 ads.txt 파일을 블로그 테마의 source 폴더에 넣어 주시면 됩니다. (e.g hexo/themes/next/source)

• hexo g -d 를 통해 새롭게 추가한 파일을 블로그에 배포하시면 됩니다. 구글 크롤링 봇의 주기가 24시간이라고 하니, 아마 다음날 해당 문제는 해결될 것 같습니다.

자동 광고 설정

• 설명을 먼저 읽어보도록 하겠습니다.

• 사용자가 조금 더 콘텐츠에 집중할 수 있도록 항상 광고가 게시되는 것이 아니라 머신러닝 학습으로 최적의 순간(아마 조회수가 많은 포스트에 게시되지 않을까요?)에만 광고가 게시되는 것 같습니다.
• 아직 방문자도 없고…ㅠ 광고가 게시되는 것을 직접 확인하고 싶어서 자동 광고는 다음으로 미룰까 했었는데 아래의 내용을 보고 적용하기로 결심했습니다.

• 즉, 수동으로 광고를 게제한 것과는 별개로 작동하는 것 같아 우선 자동 광고를 적용해보겠습니다.

• 일단 기본값으로 모든 항목에 체크되어 있어서 그대로 진행하였습니다.

• 위 코드 역시 지난번 Google Adsense 등록할 때 google_adsense.ejs 파일을 생성하고 _layout.swig에 추가했던 내용과 동일한 것으로 너무 편하게(?) 완료를 누리시면 됩니다.

• 순식간에 끝나버렸습니다…ㅎ

광고 단위 설정

• 광고 단위 탭을 누르면 다음과 같은 화면이 나옵니다.

• 우선 저는 사이드바에 ‘디스플레이 광고’ 를 게제할 생각입니다.

디스플레이 광고에는 3가지 유형이 있습니다.

• 사각형

• 수평형

• 수직형

• 저는 수직형을 선택하여 진행하였습니다. 좌측 상단의 광고 단위 이름 을 지정하고 만들기를 누르시면 됩니다.

• 마지막으로 소스 코드를 블로그 layout에 추가해 주시면 되겠습니다.

• ejs 파일을 생성하는 방법과 swig 파일을 생성하는 방법 2가지가 있습니다. (두 파일의 차이점은 아직 잘 모르겠습니다.)
  ejs 템플릿 엔진으로 광고를 게제하는 방법은 이전에 구글 애드센스를 처음 신청할 때 했던 방법과 비슷합니다.
  adsense_side.ejs 파일을 생성하여 위 소스 코드를 넣어 놓고, \_marco 디렉토리 안의 _sidebar.swig 파일에(끝에 추가하시면 됩니다) 적용하시면 됩니다.

• 이번에는 색다르게 swig 파일을 생성하고 적용하여 보겠습니다.
  먼저 \_third-party 디렉토리에 \ad 라는 폴더를 생성하겠습니다. 생성한 폴더에 ads_side.swig 라는 파일을 생성하고 여기에 소스 코드를 복사/붙여넣기 하시면 됩니다.

• 앞선 ejs 방법과 똑같이 \_marco 디렉토리 안의 _sidebar.swig 파일에(끝에 추가하시면 됩니다) 아래 사진에 적힌 것 처럼 작성해 주시면 됩니다.

• hexo g -d 를 통해 블로그에 배포하시고 대략 30분 정도 지나면 적용된 것을 확인하실 수 있습니다.
  디스플레이 광고 이외에도 다른 광고들은 비슷한 방식으로 적용하시면 되겠습니다. 혹시 나중에 기회가 된다면 따로 포스팅 하겠습니다.

Reference

• Kaggle 홈페이지 - Kaggle
• 11강 ‘Strings and Dictionaries’ - Python Micro-Course Home Page

영어 실력이 부족하여 문맥이 이해가 가지 않는 부분은 원문을 참고하시길 바랍니다…
언젠가는 실력이 나아지기를…

이번 강에서는 파이썬의 필수적인 타입인 strings 와 dictionaries 에 대해 알아보겠습니다.

문자열(Strings)

파이썬의 장점이 빛나는 순간 중 하나는 문자열을 조작할 때 입니다. 이번 섹션에서 파이썬에 내장된 문자열 함수들과 포맷팅 작업들에 대해 알아보겠습니다.

문자열 조작 패턴들은 데이터 사이언스(데이터 분석/마이닝) 작업할 때 자주 등장하는데, 이런 맥락에서 볼 때 문자열 조작은 파이썬의 큰 장점 중 하나라고 할 수 있습니다.

문자열 문법(String syntax)

이전 수업들의 예제에서 많은 문자열들을 다루며 이미 아시겠지만, 간단히 요약하자면 파이썬의 문자열은 작은 따옴표나 큰 따옴표 중 하나를 사용하여 정의 할 수 있습니다. 둘은 기능적으로 동일합니다.

x = 'Pluto is a planet'
y = "Pluto is a planet"
x == y 

True 

문자열에 작은 따옴표가 들어가는 경우(e.g. apostrophe) 큰 따옴표를 사용하면 편리합니다.
마찬가지로 큰 따옴표가 포함된 문자열은 작은 따옴표로 묶으면 쉽게 만들 수 있습니다.

print("Pluto's a planet!")
print('My dog is named "Pluto"') 

Pluto's a planet!
My dog is named "Pluto" 

만약 작은 따옴표로 묶은 문자열에 작은 따옴표 문자를 넣으면 우리가 원하는 것과는 다르게 파이썬은 잘못 이해할 수 있습니다.

'Pluto's a planet!' 

File "<ipython-input-3-a43631749f52>", line 1
'Pluto's a planet!'
^
SyntaxError: invalid syntax

작은 따옴표 문자에 백슬래시로 “예외” 처리하여 이를 해결할 수는 있습니다.

'Pluto\'s a planet!' 

'Pluto's a planet!' 

아래의 표는 백슬래시 문자 사용법의 요약입니다.

표 마지막의 \n 은 개행 문자를 나타냅니다. 이를 통해 파이썬에서 줄 바꿈이 발생합니다.

hello = "hello\nworld"
print(hello) 

hello
world 

또 다른 방법으로, 파이썬에서 문자열에 따옴표 세 개(triple quote syntax for strings)를 사용하면 입력하는 문자 그대로 개행 문자도 포함 할 수 있습니다.(즉, ‘\n’ 시퀀스를 사용하지 않고 키보드에서 ‘Enter’키를 치는 것만으로 줄 바꿈이 일어납니다). 우리는 함수를 문서화하는 데 사용하는 docstrings 을 배우면서 이것을 한번 본적이 있는데 사실 문자열을 정의하고자 하는 곳이면 어디에서나 사용할 수 있습니다.

triplequoted_hello = """hello
world"""
print(triplequoted_hello)
print(triplequoted_hello == hello) 

hello
world
True 

print() 함수는 end 키워드 인자에 특별한 값을 지정하지 않는한 기본값으로 '\n' 을 가지기 때문에 자동으로 개행 문자를 추가합니다.

print("hello")
print("world")
print("hello", end='')
print("pluto", end='') 

hello
world
hellopluto 

Strings are sequences

문자열(string)은 연속된 문자들(characters)로 생각할 수 있습니다. 우리가 list로 할 수 있는 거의 모든 것을 문자열에서도 할 수 있습니다.

# Indexing

planet = 'Pluto'
planet[0] 

'P' 

# Slicing

planet[-3:] 

'uto' 

# How long is this string?

len(planet) 

5 

# Yes, we can even loop over them

[char+'! ' for char in planet] 

['P! ', 'l! ', 'u! ', 't! ', 'o! '] 

하지만 list와 가장 큰 차이점은 문자열은 불변(immutable)이라는 점입니다. 우리는 문자열을 수정할 수 없습니다.

planet[0] = 'B'

# planet.append doesn't work either 

문자열 메소드(String methods)

list 처럼, str 타입에는 매우 유용한 메소드들일 많이 있습니다. 몇 가지 예시를 보여드리겠습니다.

claim = "Pluto is a planet!"

# 모두 대문자

claim.upper() 

'PLUTO IS A PLANET!' 

# 모두 소문자

claim.lower() 

'pluto is a planet!' 

# substring의 첫번째 인덱스 값

claim.index('plan') 

11 

claim.startswith(planet) 

True 

claim.endswith('dwarf planet') 

False 

Going between strings and lists: .split() and .join()

str.split() 은 하나의 문자열을 공백 문자를 기준으로 분리한 작은 문자들로 이루어진 list로 바꿔 줍니다. 이는 하나의 큰 문자열을 단어 하나하나로 나눈 list로 바꾸는데 매우 유용합니다.

words = claim.split()
words 

['Pluto', 'is', 'a', 'planet!'] 

datestr = '1956-01-31'
year, month, day = datestr.split('-') 

str.join() 은 반대의 기능을 한다고 보시면 됩니다, seperator(분리자)로 분리되었던 문자(열) list를 하나의 긴 문자열로 묶어줍니다.

'/'.join([month, day, year]) 

'01/31/1956' 

' 👏 '.join([word.upper() for word in words]) 

'PLUTO 👏 IS 👏 A 👏 PLANET!' 

Building strings with .format()

파이썬에서는 + 연산자를 사용해서 문자열을 합칠 수 있습니다.

planet + ', we miss you.' 

'Pluto, we miss you.' 

position = 9
planet + ", you'll always be the " + position + "th planet to me." 

---

TypeError Traceback (most recent call last)
<ipython-input-23-73295f9638cc> in <module>()
1 position = 9
----> 2 planet + ", you'll always be the " + position + "th planet to me."

TypeError: must be str, not int 

planet + ", you'll always be the " + str(position) + "th planet to me." 

"Pluto, you'll always be the 9th planet to me." 

가독성이 떨어지고 일일이 타입을 확인하며 바꿔줘야하는게 귀찮을 것 같습니다. str.format() 을 사용하면 이를 해결할 수 있습니다.

"{}, you'll always be the {}th planet to me.".format(planet, position) 

"Pluto, you'll always be the 9th planet to me." 

훨씬 깔끔한 것 같습니다! “format string”에 .format() 을 호출하고, 우리가 삽입하고자 하는 파이썬 값은 {} 로 표현되는 placeholder에 들어갈 것 입니다.
우리가 int형인 position 을 변환하기 위해 str() 을 호출 할 필요가 없었던 점에 주목하십시오. format() 에서 이를 알아서 처리합니다.
이게 format() 이 하는 일의 전부라해도 우리는 이를 매우 유용하게 사용할 것 입니다. 하지만 알아갈 수록 이 함수로 할 수 있는게 훨씬 더 많다는 것을 깨닫게 될 것 입니다. 조금만 더 알아보겠습니다.

pluto_mass = 1.303 _ 10\*\*22
earth_mass = 5.9722 _ 10\*\*24
population = 52910390

# 2 decimal points 3 decimal points, format as percent separate with commas

"{} weighs about {:.2} kilograms ({:.3%} of Earth's mass). It is home to {:,} Plutonians.".format(
planet, pluto_mass, pluto_mass / earth_mass, population,
) 

"Pluto weighs about 1.3e+22 kilograms (0.218% of Earth's mass). It is home to 52,910,390 Plutonians." 

# Referring to format() arguments by index, starting from 0

s = """Pluto's a {0}.
No, it's a {1}.
{0}!
{1}!""".format('planet', 'dwarf planet')
print(s) 

Pluto's a planet.
No, it's a dwarf planet.
planet!
dwarf planet! 

조금 과장하자면 str.format 에 대한 설명과 내용으로 짧은 책을 쓸 수도 있기 때문에 가볍게 알아보는 본 강의에서는 이쯤에서 멈추겠습니다.
더 자세히 알고 싶으신 분은 pyformat.info와 the offical docs 를 읽어 보시길 바랍니다.

딕셔너리(Dictionaries)

딕셔너리(Dictionary)는 키(Key)를 값(Value)에 매핑(mapping)하기 위한 파이썬에 내장된 데이터 구조입니다.

numbers = {'one':1, 'two':2, 'three':3} 

numbers['one'] 

1 

numbers['eleven'] = 11
numbers 

{'one': 1, 'two': 2, 'three': 3, 'eleven': 11} 

numbers['one'] = 'Pluto'
numbers 

{'one': 'Pluto', 'two': 2, 'three': 3, 'eleven': 11} 

이전 강좌에서 봤던 list 내포처럼 파이썬은 dictionary 내포를 지원합니다.

planets = ['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune']
planet_to_initial = {planet: planet[0] for planet in planets}
planet_to_initial 

{'Mercury': 'M',
'Venus': 'V',
'Earth': 'E',
'Mars': 'M',
'Jupiter': 'J',
'Saturn': 'S',
'Uranus': 'U',
'Neptune': 'N'} 

in 연산자를 사용하여 우리는 dicionary에 어떠한 key가 존재하는지 알아볼 수 있습니다.

'Saturn' in planet_to_initial
'Betelgeuse' in planet_to_initial 

True
False 

dictionary 에서의 for 반복문은 해당 key들을 반복합니다.

for k in numbers:
print("{} = {}".format(k, numbers[k])) 

one = Pluto
two = 2
three = 3
eleven = 11 

dict.keys() 및 dict.values​​() 를 사용하여 모든 key 또는 모든 value들에 각각 액세스 할 수 있습니다.

# 각 행성의 초성을 가져와, 알파벳순으로 정렬하고, 각 사이에 빈칸을 넣은 string

' '.join(sorted(planet_to_initial.values())) 

'E J M M N S U V' 

보다 유용한 dict.items() 메소드는 dictionary의 key와 value를 동시에 반복 할 수있게 해줍니다. (파이썬에서는 item 은 곧 key와 value 쌍을 뜻합니다)

for planet, initial in planet_to_initial.items():
print("{} begins with \"{}\"".format(planet.rjust(10), initial)) 

Mercury begins with "M"
Venus begins with "V"
Earth begins with "E"
Mars begins with "M"
Jupiter begins with "J"
Saturn begins with "S"
Uranus begins with "U"
Neptune begins with "N" 

dictionary의 method 전체 목록이 궁금하시면 아래의 “help(dict)”버튼을 클릭하여 전체 도움말 페이지를 읽거나 공식 온라인 문서를 확인하십시오.

Help on class dict in module builtins:

class dict(object)
| dict() -> new empty dictionary
| dict(mapping) -> new dictionary initialized from a mapping object's
| (key, value) pairs
| dict(iterable) -> new dictionary initialized as if via:
| d = {}
| for k, v in iterable:
| d[k] = v
| dict(**kwargs) -> new dictionary initialized with the name=value pairs
| in the keyword argument list. For example: dict(one=1, two=2)
|  
 | Methods defined here:
|  
 | **contains**(self, key, /)
| True if D has a key k, else False.
|  
 | **delitem**(self, key, /)
| Delete self[key].
|  
 | **eq**(self, value, /)
| Return self==value.
|  
 | **ge**(self, value, /)
| Return self>=value.
|  
 | **getattribute**(self, name, /)
| Return getattr(self, name).
|  
 | **getitem**(...)
| x.**getitem**(y) <==> x[y]
|  
 | **gt**(self, value, /)
| Return self>value.
|  
 | **init**(self, /, \*args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|  
 | **iter**(self, /)
| Implement iter(self).
|  
 | **le**(self, value, /)
| Return self<=value.
|  
 | **len**(self, /)
| Return len(self).
|  
 | **lt**(self, value, /)
| Return self<value.
|  
 | **ne**(self, value, /)
| Return self!=value.
|  
 | **new**(\*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|  
 | **repr**(self, /)
| Return repr(self).
|  
 | **setitem**(self, key, value, /)
| Set self[key] to value.
|  
 | **sizeof**(...)
| D.**sizeof**() -> size of D in memory, in bytes
|  
 | clear(...)
| D.clear() -> None. Remove all items from D.
|  
 | copy(...)
| D.copy() -> a shallow copy of D
|  
 | fromkeys(iterable, value=None, /) from builtins.type
| Returns a new dict with keys from iterable and values equal to value.
|  
 | get(...)
| D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None.
|  
 | items(...)
| D.items() -> a set-like object providing a view on D's items
|  
 | keys(...)
| D.keys() -> a set-like object providing a view on D's keys
|  
 | pop(...)
| D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
| If key is not found, d is returned if given, otherwise KeyError is raised
|  
 | popitem(...)
| D.popitem() -> (k, v), remove and return some (key, value) pair as a
| 2-tuple; but raise KeyError if D is empty.
|  
 | setdefault(...)
| D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
|  
 | update(...)
| D.update([E, ]**F) -> None. Update D from dict/iterable E and F.
| If E is present and has a .keys() method, then does: for k in E: D[k] = E[k]
| If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v
| In either case, this is followed by: for k in F: D[k] = F[k]
|  
 | values(...)
| D.values() -> an object providing a view on D's values
|  
 | ----------------------------------------------------------------------
| Data and other attributes defined here:
|  
 | **hash** = None

연습문제(Your Turn)

strings and dictionaries 예제

Reference

• Kaggle 홈페이지 - Kaggle
• 9강 ‘Loops and List Comprehensions’ - Python Micro-Course Home Page

영어 실력이 부족하여 문맥이 이해가 가지 않는 부분은 원문을 참고하시길 바랍니다…
언젠가는 실력이 나아지기를…

반복문(Loops)

Loop는 반복적으로 코드를 실행해야 할 때 사용됩니다. 아래는 예제입니다:

planets = ['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune']
for planet in planets:
print(planet, end=' ') # 같은 줄에 출력합니다. 

Mercury Venus Earth Mars Jupiter Saturn Uranus Neptune 

for 반복문에는

• 사용할 변수 이름 (이 경우 planet)
• 반복할 값들의 집합 (이 경우 planets)

“in“ 이라는 단어를 사용하여 함께 연결합니다.

“in“의 오른쪽에는 반복에 사용될 수 있다면 어떠한 객체라도 올 수 있습니다. 대체적으로 어떠한 그룹으로 생각될 수만 있다면 반복문에 사용될 수 있습니다.

multiplicands = (2, 2, 2, 3, 3, 5)
product = 1
for mult in multiplicands:
product = product \* mult
product 

360 

s = 'steganograpHy is the practicE of conceaLing a file, message, image, or video within another fiLe, message, image, Or video.'
msg = ''

# s 문자열의 대문자들을 출력. 한번에 하나씩

for char in s:
if char.isupper():
print(char, end='') 

HELLO 

range()

range() 는 일련의 연속적인 숫자들을 반환하는 함수입니다. 이는 반복문을 작성하는데 매우 유용합니다.
예를 들어, 우리가 어떤 행동을 5번 반복하고자 한다면 아래와 같이 작성하면 됩니다:

for i in range(5):
print("Doing important work. i =", i) 

Doing important work. i = 0
Doing important work. i = 1
Doing important work. i = 2
Doing important work. i = 3
Doing important work. i = 4 

while loops

파이썬에는 또 다른 반복문으로 특정 조건을 만족할 때까지 반복하는 while 이 있습니다.

i = 0
while i < 10:
print(i, end=' ')
i += 1 

0 1 2 3 4 5 6 7 8 9 

while 반복문의 인자는 boolean 문으로 평가되고, False로 평가 될 때까지 반복문이 실행됩니다.

리스트 내포(List Comprehensions)

리스트 컴프리핸션 이라고 영문 그대로 읽는 경우가 더 많은 것 같습니다…

리스트 내포는 파이썬에서 가장 사랑받고 독특한 특징 중 하나입니다. 자잘한 설명보다는 그냥 몇 가지 예제들을 보는 것이 보다 이해하기 쉬울 것 같습니다.

squares = [n**2 for n in range(10)]
squares 

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81] 

squares = []
for n in range(10):
squares.append(n\*\*2)
squares 

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81] 

if 조건을 추가 할 수도 있습니다:

short_planets = [planet for planet in planets if len(planet) < 6]
short_planets 

['Venus', 'Earth', 'Mars'] 

(SQL에 익숙하신 분이라면, “WHERE” 절과 비슷하다고 느끼셨을 겁니다.)
다음은 if 조건으로 필터링하고 loop 변수에 일부 변환을 적용하는 예제입니다:

# str.upper() 은 모두 대문자로 변환한 string을 반환합니다

loud_short_planets = [planet.upper() + '!' for planet in planets if len(planet) < 6]
loud_short_planets 

['VENUS!', 'EARTH!', 'MARS!'] 

[
planet.upper() + '!'
for planet in planets
if len(planet) < 6
] 

['VENUS!', 'EARTH!', 'MARS!'] 

표현식의 왼쪽에는 꼭 반복문의 변수를 포함할 필요가 없습니다(하지만 이런 경우는 매우 드뭅니다). 아래의 표현식이 어떤 결과를 출력할까요? “output” 탭을 눌러서 확인해 보세요.

[32 for planet in planets] 

[32, 32, 32, 32, 32, 32, 32, 32] 

min, max 및 sum 과 같은 기능과 LC가 함께 사용되면 여러 줄로 작성된 코드를 한 줄의 매우 인상적인 코드로 표현할 수 있습니다.

def count_negatives(nums):
"""Return the number of negative numbers in the given list.

    >>> count_negatives([5, -1, -2, 0, 3])
    2
    """
    n_negative = 0
    for num in nums:
        if num < 0:
            n_negative = n_negative + 1
    return n_negative 

def count_negatives(nums):
return len([num for num in nums if num < 0]) 

def count_negatives(nums): # 기억하기: "booleans and conditionals" 연습문제에서, 파이썬의 별난 특징으로 # True + True + False + True 는 3으로 계산한다는 점을 응용.
return sum([num < 0 for num in nums]) 

위 3가지 방법 중 어떤 것이 “최고의” 방법인지는 매우 주관적입니다. 보다 적은 코드로 문제를 해결하는 것이 항상 좋은 일이지만, The Zen of Python에 적힌 다음 내용을 기억해 두는 것이 좋습니다.

• Readability counts. 가독성이 중요합니다.
• Explicit is better than implicit. 명확한 것이 암시적인 것보다 낫습니다.

이러한 도구들을 사용하여 읽기 쉽고 간결한 프로그램을 짜도록 합시다. 하지만 둘 중 하나를 골라야하는 상황이 온다면, 다른 사람들이 읽고 이해하기 쉬운 코드를 짜는 것을 선호하도록 합시다.

연습문제(Your Turn)

loops and list comprehensions 예제