파이썬코딩

상향식 상향식 상향식에서는 내장 데이터 유형에서 점점 더 큰 데이터 및 코드 구조를 구축하는 방식으로 발전해 왔습니다. 이 챕터에서는 마지막으로 파이썬에서 사실적이고 큰 프로그램을 작성하는 방법에 대해 알아보겠습니다.

Standalone Programs 

지금까지 Python의 대화형 인터프리터 내에서 다음과 같은 코드 조각을 작성하고 실행했습니다.

>>> print("This interactive snippet works.") This interactive snippet works. 

이제 첫 번째 독립 실행형 프로그램을 만들어 보겠습니다. 컴퓨터에서 Python 코드 한 줄이 포함된 test1.py이라는 파일을 만드십시오.

print("This standalone program works!")

>> 프롬프트는 없으며 Python 코드 한 줄만 표시됩니다. 다음 항목이 있는지 확인합니다.

인쇄 전에 라인에 자국이 없습니다.

텍스트 터미널 또는 터미널 창에서 Python을 실행하는 경우

Python 프로그램과 프로그램 파일 이름:

$ python test1.py
This standalone program works! 

지금까지 이 책에서 본 대화형 스니펫을 모두 파일로 저장하고 직접 실행할 수 있습니다. ▲를 잘라내어 붙여넣을 경우, 초기 >> 및 ...을(를) 삭제해야 합니다. (최종 공간을 확보합니다.)

Command-Line Arguments 

컴퓨터에서 다음 두 줄이 포함된 test2.py 파일을 만듭니다.

import sys 

print('Program arguments:', sys.argv)

이제 이 프로그램을 실행하려면 현재 버전의 Python을 사용하십시오. 이게 어떻게 보일지 알 수 있어요.

표준 셸 프로그램을 사용하는 Linux 또는 Mac OS X 터미널 창:

$ python test2.py
Program arguments: ['test2.py']
$ python test2.py tra la la
Program arguments: ['test2.py', 'tra', 'la', 'la'] 

Modules and the import Statement 

Python 코드를 두 개 이상의 파일에서 만들고 사용하는 한 단계 더 나아갈 것입니다. 모듈은 Python 코드의 파일일 뿐입니다.

이 책의 텍스트는 단어, 문장, 단락, 장 등의 계층 구조로 구성되어 있습니다. 그렇지 않으면 한두 페이지 후에 읽을 수 없습니다. 코드는 대략 비슷한 상향식 구성을 가지고 있습니다. 데이터 유형은 단어, 문장은 문장, 함수는 단락, 모듈은 장과 같습니다. 비유를 계속하자면, 이 책에서 제가 프로그래밍 8장에서 설명할 내용은 다른 모듈의 코드를 참조하는 것과 같습니다.

우리는 수입 명세서를 사용하여 다른 모듈의 코드를 참조합니다. 이렇게 하면 가져온 모듈의 코드와 변수를 프로그램에서 사용할 수 있습니다.

Import a Module 

가져오기 문을 가장 간단하게 사용하는 것은 가져오기 모듈입니다. 여기서 module은 .py 확장자가 없는 다른 Python 파일의 이름입니다. 기상 관측소를 시뮬레이션해서 기상 보고서를 출력해 봅시다. 하나의 메인 프로그램이 보고서를 인쇄하고, 단일 기능으로 별도의 모듈이 보고서에 사용된 날씨 설명을 반환합니다.

여기 메인 프로그램이 있습니다.py):

import report 

description = report.get_description() print("Today's weather:", description) 

다음은 모듈(report.py)입니다.

def get_description(): # see the docstring below? """Return random weather, just like the pros""" from random import choice 

possibilities = ['rain', 'snow', 'sleet', 'fog', 'sun', 'who knows'] return choice(possibilities) 

이 두 파일이 동일한 디렉토리에 있고 Python이 weather▲ man.py을 메인 프로그램으로 실행하도록 지시하면, Python은 보고서 모듈에 액세스하여 get_tription tion 함수를 실행합니다. 문자열 목록에서 임의의 결과를 반환하기 위해 이 버전의 get_description()을 작성했습니다. 따라서 기본 프로그램은 다음과 같이 반환되고 인쇄됩니다.

$ python weatherman.py Today's weather: who knows $ python weatherman.py Today's weather: sun
$ python weatherman.py Today's weather: sleet 

우리는 수입품을 두 곳에서 사용했습니다.

• 메인 프로그램 weatherman.py에서 모듈 보고서를 가져왔습니다.

• 모듈 파일 report.py에서 get_discription unction 함수가 Python의 표준 랜덤 모듈에서 choice 함수를 가져왔습니다.

우리는 또한 수입품을 두 가지 다른 방법으로 사용했습니다.

• 주요 프로그램이 import report를 호출한 후 report.get_descrip을 실행했습니다.

이온화

• 랜덤 가져오기에서 호출된 report.py의 get_discription function

선택 후 실행(가능성)했습니다.

첫 번째 경우 보고서 모듈 전체를 가져오지만 report.를 접두사로 사용해야 get_description()이(가) 가능합니다. report.py의 모든 내용은 보고서 이름 앞에 있는 보고서만 붙이면 주 프로그램에서 사용할 수 있습니다. 모듈의 내용을 모듈 이름으로 한정함으로써 이름 충돌이 발생하는 것을 방지할 수 있습니다. 다른 모듈에 get_description() 함수가 있을 수 있으며 실수로 호출하지는 않습니다.

두 번째 경우에는 함수 내에 있고 여기에 다른 명명된 선택 항목이 없으므로 임의 모듈에서 선택() 함수를 직접 가져왔습니다. 임의의 결과를 반환하는 다음과 같은 함수를 작성할 수 있었습니다.

def get_description(): import random 

possibilities = ['rain', 'snow', 'sleet', 'fog', 'sun', 'who knows'] return random.choice(possibilities) 

프로그래밍의 여러 가지 측면과 마찬가지로 자신에게 가장 명확해 보이는 스타일을 고르십시오. 모듈 인증 이름(랜덤).(선택)이 더 안전하지만 조금 더 입력해야 합니다.위의 get_description() 예제는 가져올 항목의 다양성을 보여 주었지만 가져올 위치의 다양성은 나타내지 않았습니다. 모두 함수 내부에서 가져오기라고 했습니다. 함수 외부에서 임의로 가져올 수 있었습니다.

>>> import random
>>> def get_description(): 

•     ...     possibilities = ['rain', 'snow', 'sleet', 'fog', 'sun', 'who knows']
•  
• ...  return random.choice(possibilities) ...
  >>> get_description()
  'who knows'
  >>> get_description()
  'rain'

가져온 코드를 둘 이상의 장소에서 사용할 수 있는 경우 기능 외부에서 가져오고, 사용이 제한되는 경우 내부에서 가져오기를 고려해야 합니다. 일부 사람들은 코드의 모든 종속성을 명확히 하기 위해 모든 가져오기를 파일 맨 위에 놓는 것을 선호합니다. 어느 쪽이든 통한다.

• mport a Module with Another Nam

우리의 주요 weatherman.py 프로그램에서 우리는 수입 보고서를 호출했습니다. 하지만 이름이 같은 다른 모듈이 있거나 더 니모닉하거나 더 짧은 이름을 사용하려는 경우 어떻게 해야 합니까? 이러한 경우 별칭을 사용하여 가져올 수 있습니다. 다음 별칭을 사용합니다.

• import report as wr
  description = wr.get_description() print("Today's weather:", description)
• Import Only What You Want from a Module

Python을 사용하면 모듈의 하나 이상의 부품을 가져올 수 있습니다. 각 부분은 원래 이름을 유지하거나 별칭을 지정할 수 있습니다. 먼저 보고서 모듈에서 원래 이름으로 get_description()을 가져오겠습니다.

• from report import get_description description = get_description() print("Today's weather:", description)

이제 do_it로 가져옵니다.

• from report import get_description as do_it description = do_it()
  print("Today's weather:", description)

Module Search Path 

이제 do_it로 가져옵니다.Python은 가져올 파일을 어디에서 찾습니까? 표준 sys 모듈에 저장된 디렉토리 이름과 ZIP 아카이브 파일 목록을 변수 경로로 사용합니다. 이 목록에 액세스하여 수정할 수 있습니다. 다음은 Mac에서 Python 3.3용 sys.path의 값입니다.

>>> import sys
>>> for place in sys.path: ... print(place)
... 

    /Library/Frameworks/Python.framework/Versions/3.3/lib/python33.zip

    /Library/Frameworks/Python.framework/Versions/3.3/lib/python3.3

    /Library/Frameworks/Python.framework/Versions/3.3/lib/python3.3/plat-darwin

    /Library/Frameworks/Python.framework/Versions/3.3/lib/python3.3/lib-dynload

    /Library/Frameworks/Python.framework/Versions/3.3/lib/python3.3/site-packages

초기 빈 출력 라인은 현재 디렉토리를 나타내는 빈 문자열 ''입니다. sys.path에서 '가 처음인 경우 Python은 무언가를 가져오려고 할 때 현재 디렉토리를 먼저 찾습니다. 가져오기 보고서는 report.py을 찾습니다.

첫 번째 매치가 사용됩니다. 즉, 랜덤이라는 모듈을 정의하고 표준 라이브러리 이전의 검색 경로에 있는 경우 표준 라이브러리의 랜덤에 액세스할 수 없습니다.

Packages 

코드 한 줄에서 여러 줄 기능, 독립 실행형 프로그램, 동일한 디렉토리에 있는 여러 모듈로 이동했습니다. Python 응용 프로그램을 더 많이 확장할 수 있도록 모듈을 패키지라는 파일 계층으로 구성할 수 있습니다.

아마도 우리는 다음 날과 다음 주에 각각 다른 유형의 문자 예보를 원하는 것 같습니다. 이를 구조화하는 한 가지 방법은 소스라는 이름의 디렉터리를 만들고 그 안에 daily.py과 weekly.py이라는 두 개의 모듈을 만드는 것입니다. 각각은 예측이라는 기능을 가지고 있다. 일별 버전은 문자열을 반환하고 주별 버전은 7개 문자열 목록을 반환합니다.

여기 메인 프로그램과 두 개의 모듈이 있습니다. (enumerate() 함수는 목록을 분해하여 목록의 각 항목을 for 루프에 공급하여 각 항목에 숫자를 조금 더 추가합니다.)

주 프로그램: box/weather.py.

from sources import daily, weekly 

print("Daily forecast:", daily.forecast()) print("Weekly forecast:")
for number, outlook in enumerate(weekly.forecast(), 1): 

print(number, outlook) 

모듈 1: box/box/daily.py.

def forecast():
'fake daily forecast' return 'like yesterday' 

모듈 2: box/box/weekly.py.

def forecast():
"""Fake weekly forecast"""
return ['snow', 'more snow', 'sleet', 

'freezing rain', 'rain', 'fog', 'hail']

원본 디렉토리에 __init_.py라는 파일이 하나 더 필요합니다. 이 캔

비어 있지만 Python은 이 디렉터리를 패키지로 처리하려면 이 디렉터리가 필요합니다. 메인 weather.py 프로그램을 실행하여 다음 작업을 확인합니다.

$ python weather.py
Daily forecast: like yesterday Weekly forecast:
1 snow
2 more snow
3 sleet
4 freezing rain
5 rain
6 fog
7 hail 

The Python Standard Library 

Python의 주요 주장 중 하나는 Python이 많은 유용한 작업을 수행하는 대규모 표준 모듈 라이브러리인 "배터리 포함"을 가지고 있으며 핵심 언어가 과장되지 않도록 별도로 보관하고 있다는 것입니다. 일부 Python 코드를 작성하려고 할 때 먼저 원하는 작업을 이미 수행하는 표준 모듈이 있는지 확인하는 것이 좋습니다. 표준 도서관에서 작은 보석들을 자주 접하는 것은 놀라운 일입니다. Python은 또한 튜토리얼과 함께 모듈에 대한 권위 있는 설명서를 제공합니다. Doug Hellmann의 웹 사이트 Python Module of the Week와 그의 저서 The Python Standard Li bybrary by 예제(Addison-Wesley Professional)도 매우 유용한 가이드입니다.

이 책의 다음 장에서는 웹, 시스템, 데이터베이스 등과 관련된 많은 표준 모듈을 다룹니다. 이 섹션에서는 일반적인 용도가 있는 몇 가지 표준 모듈에 대해 설명하겠습니다.

Closures 

내부 기능이 폐쇄 역할을 할 수 있습니다. 다른 함수에 의해 동적으로 생성되는 함수로, 함수 외부에서 생성된 변수의 값을 변경하고 기억할 수 있습니다.

다음 예제는 이전 기사() 예제를 기반으로 합니다. 우리는 상상력이 없기 때문에 새로운 기사2()라고 부르고, 내부() 기능을 내부2()라고 하는 폐쇄 기능으로 바꾸자. 차이점은 다음과 같습니다.

• inner2는 외부말 매개변수를 인수로 얻는 대신 직접 사용합니다.

• nights2px는 내부 2 함수 이름을 호출하는 대신 반환합니다.

>>> def knights2(saying): 

def inner2():
return "We are the knights who say: '%s'" % saying 

return inner2 

내부2() 함수는 전달된 말의 가치를 알고 기억합니다. line return inner2는 inner2 함수의 이 특수 복사본을 반환합니다(하지만 호출하지는 않음). 이것은 폐쇄입니다. 어디서 왔는지 기억하는 동적으로 만들어진 함수입니다.

다른 인수를 사용하여 기사 2()를 두 번 호출합니다.

>>> a = knights2('Duck') 

>>> b = knights2('Hasenpfeffer') 

좋아, 그럼 A와 B는 뭐야?

>>> type(a) <class 'function'> >>> type(b) <class 'function'> 

기능이지만 폐쇄이기도 합니다.

 >>> a

    <function knights2.<locals>.inner2 at 0x10193e158>

    >>> b

    <function knights2.<locals>.inner2 at 0x10193e1e0>

우리가 그들을 부른다면, 그들은 그들이 기사2에 의해 창조되었을 때 사용되었던 속담을 기억한다:

 >>> a()

    "We are the knights who say: 'Duck'"

    >>> b()

    "We are the knights who say: 'Hasenpfeffer'"

Anonymous Functions: the lambda() Function 

Python에서 람다 함수는 단일 문장으로 표현되는 익명 함수입니다. 일반적인 작은 기능 대신 사용할 수 있습니다.

이를 설명하기 위해 먼저 정규 함수를 사용하는 예를 만들어 보겠습니다. 먼저 edit_story() 함수를 정의하겠습니다. 그 주장은 다음과 같다.

• 단어—단어 목록

• func—단어의 각 단어에 적용하는 기능

>>> def edit_story(words, func): ... for word in words:
... print(func(word)) 

이제 단어 목록과 각 단어에 적용할 기능이 필요합니다. 여기 제 고양이가 계단 하나를 놓쳤을 때 내는 (가정적인) 소리 목록이 있습니다.

>>> stairs = ['thud', 'meow', 'thud', 'hiss']

그리고 함수의 경우, 각 단어를 대문자로 쓰고 느낌표를 붙입니다.

고양이 타블로이드 신문 헤드라인에 적합:

>>> def enliven(word): # give that prose more punch ... return word.capitalize() + '!' 

재료 혼합:

 >>> edit_story(stairs, enliven)

    Thud!

    Meow!

    Thud!

Hiss!

드디어 람다에 도착했군. 활성화() 기능이 너무 짧아서 대체할 수 있었습니다.

람다와 함께:

>>>
>>> edit_story(stairs, lambda word: word.capitalize() + '!') Thud!
Meow!
Thud!
Hiss!
>>> 

람다는 하나의 주장을 받아들입니다. 여기서 우리는 그것을 단어라고 부릅니다. 대장과 끝 괄호 사이의 모든 것이 함수의 정의입니다.

종종 람다를 사용하는 것보다 활력()과 같은 실제 기능을 사용하는 것이 훨씬 더 명확합니다. 람다는 그렇지 않으면 많은 작은 함수들을 정의해야 할 경우에 가장 유용합니다. 그리고 그것들을 모두 기억해야 합니다. 특히 그래픽 사용자 인터페이스에서 람다를 사용하여 콜백 함수를 정의할 수 있습니다. 예는 부록 A를 참조하십시오.

Generators 

생성기는 Python 시퀀스 생성 개체입니다. 이 기능을 사용하면 전체 시퀀스를 한 번에 만들고 메모리에 저장하지 않고도 잠재적으로 큰 시퀀스를 반복할 수 있습니다. 생성기는 반복측정기의 데이터 원본인 경우가 많습니다. 이전 코드 예제에서는 이미 범위()라는 이름을 사용하여 일련의 정수를 생성했습니다. Python 2에서 range()는 목록을 반환하여 메모리에 맞도록 제한합니다. Python 2에는 생성기 xrange()도 있으며, 이는 Python 3에서 일반 범위()가 되었다. 이 예제에서는 1에서 100까지의 모든 정수를 추가합니다.

    >>> sum(range(1, 101))

    5050

생성기를 통해 반복할 때마다 마지막으로 호출된 시간을 추적하고 다음 값을 반환합니다. 이는 이전 통화에 대한 메모리가 없고 항상 동일한 상태의 첫 회선에서 시작되는 일반 함수와는 다릅니다.

잠재적으로 큰 시퀀스를 만들고 코드가 너무 커서 제너레이터를 이해할 수 없는 경우 제너레이터 함수를 작성합니다. 정상 함수이지만 반환이 아닌 항복문으로 값을 반환합니다. 고유한 범위 버전()을 작성해 보겠습니다.

>>> def my_range(first=0, last=10, step=1): 

number = first while number < last: 

yield number number += step 

정상적인 기능입니다.

    >>> my_range

    <function my_range at 0x10193e268>

생성기 개체를 반환합니다.

  >>> ranger = my_range(1, 5)

    >>> ranger

    <generator object my_range at 0x101a0a168>

이 생성기 개체에 대해 반복할 수 있습니다.

>>> for x in ranger: ... print(x) ...
1 

2 3 4 

Decorators 

경우에 따라 소스 코드를 변경하지 않고 기존 함수를 수정하려고 할 수 있습니다. 일반적인 예는 전달된 인수를 확인하기 위해 디버깅 문을 추가하는 것입니다.

데코레이터는 한 함수를 입력으로 사용하고 다른 함수를 반환하는 함수입니다. Python 트릭 백을 자세히 살펴보고 다음을 사용합니다.

• *병력 및 **왜성

• 내부 기능

• 인수로서의 함수

document_it() 함수는 다음 작업을 수행할 장식자를 정의합니다.

• 함수의 이름과 인수 값을 인쇄합니다.

• 인수를 사용하여 함수 실행

• 결과 인쇄

• 수정된 기능을 사용할 수 있도록 반환

코드는 다음과 같습니다.

• >>> def document_it(func): 

document_it()에 전달하는 함수는 document_it()가 추가하는 추가 문을 포함하는 새 함수를 제공합니다. 데코레이터는 실제로 func에서 코드를 실행할 필요가 없지만 document_it()는 func를 호출하여 func뿐만 아니라 모든 추가 결과를 얻을 수 있도록 합니다.

그래서 이걸 어떻게 사용하죠? 장식자를 수동으로 적용할 수 있습니다

• >>> def add_ints(a, b):
• ... returna+b ...
  >>> add_ints(3, 5)
  8
  >>> cooler_add_ints = document_it(add_ints) # manual decorator assignment >>> cooler_add_ints(3, 5)
  Running function: add_ints
   Positional arguments: (3, 5)
•     Keyword arguments: {}
•     Result: 8
•     8
• 위의 수동 데코레이터 할당 대신, 꾸미려는 함수 앞에 @decorator_name을 추가하십시오.

>>> @document_it
... def add_ints(a, b):
... returna+b
...
>>> add_ints(3, 5)
Start function add_ints Positional arguments: (3, 5) Keyword arguments: {} Result: 8
8 

기능별로 둘 이상의 데코레이터를 둘 수 있습니다. 결과를 제곱하는 square_it()라는 다른 장식가를 작성해 보겠습니다.

...

...

...

...

...

def new_function(*args, **kwargs): result = func(*args, **kwargs) return result * result 

return new_function 

함수에 가장 근접하게 사용된 데코레이터(decorator, 정의 바로 위)가 먼저 실행된 다음 그 위에 있는 데코레이터가 실행됩니다. 두 순서 모두 동일한 최종 결과를 제공하지만 중간 단계가 어떻게 변하는지 확인할 수 있습니다.

>>> @document_it
... @square_it
... def add_ints(a, b):
... returna+b
...
>>> add_ints(3, 5)
Running function: new_function Positional arguments: (3, 5) Keyword arguments: {}
Result: 64
64 

데코레이터 순서를 반대로 해 보겠습니다.

>>> @square_it
... @document_it
... def add_ints(a, b): ... returna+b
...
>>> add_ints(3, 5) Running function: add_ints 

Positional arguments: (3, 5)

    Keyword arguments: {}

    Result: 8

    64

Namespaces and Scope 

이름은 어디에 쓰이느냐에 따라 다른 것을 가리킬 수 있다. Python 프로그램에는 특정 이름이 고유하고 다른 네임스페이스의 동일한 이름과 관련이 없는 섹션 등 다양한 네임스페이스가 있습니다.

각 함수는 고유한 네임스페이스를 정의합니다. 주 프로그램에서 x라는 변수를 정의하고 함수에서 x라는 다른 변수를 정의하면 다른 변수를 나타냅니다. 그러나 벽을 뚫을 수 있습니다. 필요한 경우 다양한 방법으로 다른 네임스페이스의 이름에 액세스할 수 있습니다.

프로그램의 주요 부분은 글로벌 네임스페이스를 정의하므로 해당 네임스페이스의 변수는 글로벌 변수입니다.

함수 내에서 전역 변수의 값을 가져올 수 있습니다.

>>> animal = 'fruitbat'
>>> def print_global():
... print('inside print_global:', animal) ...
>>> print('at the top level:', animal)
at the top level: fruitbat
>>> print_global()
inside print_global: fruitbat 

그러나 전역 변수의 값을 가져와 함수 내에서 변경하려고 하면 다음 오류가 발생합니다.

>>> def change_and_print_global(): 

• ...  print('inside change_and_print_global:', animal)
•     ...      animal = 'wombat'
•  
• ...  print('after the change:', animal) ...
  >>> change_and_print_global()
  Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in change_and_report_it
  UnboundLocalError: local variable 'animal' referenced before assignment

이 변수를 변경하면 이름이 동물인 다른 변수도 변경되지만 이 변수는 함수 내부에 있습니다.

• >>> def change_local(): 

  >>> change_local()

    inside change_local: wombat 4330406160

    >>> animal

    'fruitbat'

    >>> id(animal)

    4330390832

이게 어찌된 일이냐? 첫 번째 줄은 동물이라는 글로벌 변수에 '과일배트' 문자열을 할당했습니다. change_local() 함수에도 animal이라는 변수가 있지만, 이 변수는 로컬 네임스페이스에 있습니다.

여기서는 Python 함수 ID()를 사용하여 각 객체에 대한 고유한 값을 인쇄하고 change_local() 내부의 변수 동물이 프로그램의 메인 레벨에서 동물과 같지 않음을 증명했습니다.

함수 내의 로컬 변수가 아닌 전역 변수에 액세스하려면 글로벌 키워드를 사용해야 합니다(이것이 올 것임을 알고 있었음: expiritive is been implicit):

>>> animal = 'fruitbat'
>>> def change_and_print_global(): 

• ...  global animal
•     ...      animal = 'wombat'
•  
• ...  print('inside change_and_print_global:', animal) ...
  >>> animal
  'fruitbat'
  >>> change_and_print_global()
  inside change_and_print_global: wombat
  >>> animal
  'wombat' 

함수 내에서 전역이라고 말하지 않으면 Python은 로컬 네임스페이스를 사용하며 변수는 로컬입니다. 기능이 완료되면 사라집니다.

Python은 네임스페이스의 내용에 액세스할 수 있는 두 가지 기능을 제공합니다. • locals()는 로컬 네임스페이스의 콘텐츠 사전을 반환합니다.

• globalsyspace는 글로벌 네임스페이스의 내용에 대한 사전을 반환합니다. 그리고 여기서 사용되고 있습니다.

• >>> animal = 'fruitbat' >>> def change_local():

>>> print('globals:', globals()) # reformatted a little for presentation globals: {'animal': 'fruitbat',
'__doc__': None,
'change_local': <function change_it at 0x1006c0170>, 

'__package__': None,
'__name__': '__main__',
'__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__builtins__': <module 'builtins'>}
>>> animal
'fruitbat' 

change_local() 내의 로컬 네임스페이스에는 로컬 변수 동물만 포함되어 있습니다. 글로벌 네임스페이스에는 별도의 글로벌 변수 동물과 여러 가지가 포함되어 있습니다.

Uses of _ and __ in Names 

두 개의 밑줄(__)로 시작하고 끝나는 이름은 Python 내에서 사용할 수 있도록 예약되어 있으므로 자신의 변수와 함께 사용하면 안 됩니다. 이 이름 지정 패턴은 응용 프로그램 개발자가 자체 변수에 대해 선택할 가능성이 낮기 때문에 선택되었습니다.

예를 들어, 함수의 이름은 시스템 변수 함수 ._name__에 있으며 문서화 문자열은 함수입니다.__doc__:

>>> def amazing(): 

•     ...      '''This is the amazing function.
•  
•     ...      Want to see it again?'''
•  
• ...  print('This function is named:', amazing.__name__)
• ...  print('And its docstring is:', amazing.__doc__) ...
  >>> amazing()
  This function is named: amazing
  And its docstring is: This is the amazing function.
  Want to see it again?
  
  

앞서 글로벌 인쇄물에서 보셨듯이, 메인 프로그램에는 특별 프로그램이 할당되어 있습니다.

이름 __main_.

• Handle Errors with try and except 
• 일부 언어에서는 오류가 특수 함수 반환 값으로 표시됩니다. Python은 관련 오류가 발생할 때 실행되는 코드: 예외를 사용합니다.
  위치를 벗어난 목록이나 튜플 또는 존재하지 않는 키를 가진 사전 액세스와 같은 일부 항목이 이미 있습니다. 경우에 따라 실패할 수 있는 코드를 실행하는 경우 잠재적인 오류를 차단하기 위해 적절한 예외 처리기도 필요합니다.
• 예외가 발생할 수 있는 모든 위치에 예외 처리를 추가하여 사용자에게 상황을 알리는 것이 좋습니다. 문제를 해결하지 못할 수도 있지만 최소한 상황을 확인하고 프로그램을 정상적으로 종료할 수는 있습니다. 일부 기능에서 예외가 발생했지만 해당 기능에서 잡히지 않으면 일부 호출 기능에서 일치하는 핸들러에 잡힐 때까지 거품이 발생합니다. 사용자 고유의 예외 처리기를 제공하지 않는 경우 Python은 오류 메시지와 오류가 발생한 위치에 대한 일부 정보를 인쇄한 후 프로그램을 종료합니다.
•   >>> short_list = [1, 2, 3]
•     >>> position = 5
•     >>> short_list[position]
•     Traceback (most recent call last):
• File "<stdin>", line 1, in <module> IndexError: list index out of range 

코드를 운에 맡기지 말고 코드를 래핑해 보십시오. 오류 처리 기능은 예외입니다.

>>> short_list = [1, 2, 3] >>> position = 5
>>> try:
... short_list[position] ... except: 

... print('Need a position between 0 and', len(short_list)-1, ' but got', ... position)
...
Need a position between 0 and 2 but got 5 

시도 블록 내부의 코드가 실행됩니다. 오류가 발생하면 예외가 발생하고 예외 블록 내부의 코드가 실행됩니다. 오류가 없으면 예외 블록을 건너뜁니다.

여기서처럼 인수가 없는 경우를 제외하고 평면을 지정하는 것은 모든 예외 유형에 대한 캐치올입니다. 둘 이상의 예외 유형이 발생할 수 있는 경우 각 예외 처리기를 별도로 제공하는 것이 가장 좋습니다. 이렇게 하도록 강요하는 사람은 없습니다. 모든 예외를 포착하는 것 외에는 베어(Bare)를 사용할 수 있지만 이러한 예외에 대한 처리가 일반적일 수 있습니다(일부 인쇄 오류가 발생했습니다). 원하는 수의 특정 예외 처리기를 사용할 수 있습니다.

때로는 유형을 벗어난 예외 세부 정보를 원할 수 있습니다. 다음 형식을 사용하는 경우 변수 이름에 전체 예외 개체가 표시됩니다.

except exceptiontype as name 

다음 예제에서는 시퀀스에 잘못된 위치를 제공할 때 IndexError가 발생하는 예외 유형이기 때문에 먼저 IndexError를 찾습니다. IndexError 예외는 변수에 저장하고 다른 예외는 변수에 저장합니다. 이 예에서는 다른 항목에 저장된 모든 내용을 인쇄하여 해당 개체에 있는 내용을 보여 줍니다.

>>> short_list = [1, 2, 3] >>> while True: 

...
...
...
... try: 

value = input('Position [q to quit]? ') if value == 'q': 

break 

    ...

    ...

    ...

    ...

    ...

    ...

    ...

    Position [q to quit]? 1

    2

    Position [q to quit]? 0

    1

    Position [q to quit]? 2

    3

    Position [q to quit]? 3

    Bad index: 3

    Position [q to quit]? 2

    3

Position [q to quit]? two
Something else broke: invalid literal for int() with base 10: 'two' Position [q to quit]? q 

위치 3을 입력하면 예상대로 인덱스 오류가 발생했습니다. 두 개를 입력하면 두 번째에 처리한 int() 함수가 코드만 제외하고 모두 잡힙니다.

Make Your Own Exceptions 

이전 섹션에서는 처리 예외에 대해 설명했지만, 모든 예외(예: IndexError)는 Python 또는 표준 라이브러리에 미리 정의되어 있습니다. 원하는 용도로 사용할 수 있습니다. 또한 프로그램에서 발생할 수 있는 특수한 상황을 처리하기 위해 고유한 예외 유형을 정의할 수도 있습니다.

예외는 수업이다. 예외 클래스의 하위 항목입니다. 대문자라는 예외를 만들자.문자열에 대문자가 있을 경우 예외로 올리고 대문자로 표시합니다.

>>> class UppercaseException(Exception): ... pass
>>> words = ['eeenie', 'meenie', 'miny', 'MO'] >>> for word in words:
... if word.isupper():
... raise UppercaseException(word) ... 

Traceback (most recent call last): File "<stdin>", line 3, in <module> 

    __main__.UppercaseException: MO

대문자에 대한 동작도 정의하지 않았습니다.예외(방금 통과를 사용함)를 통해 상위 클래스인 예외(Exception)가 예외가 발생했을 때 인쇄할 내용을 파악할 수 있습니다.

예외 개체 자체에 액세스하여 인쇄할 수 있습니다.

>>> try:
... raise OopsException('panic') ... except OopsException as exc: ... print(exc)
...
panic 

Things to Do 

4.1 guess_me 변수에 값 7을 할당합니다. 그런 다음 guess_me가 7보다 작으면 'too low', 7보다 크면 'too high', 7보다 크면 'just right' 문자열을 인쇄하는 조건부 테스트(if, elif)를 작성합니다.

4.2 변수 guess_me에 값 7을, 변수 시작에 값 1을 할당합니다. guess_me와 시작을 비교하는 시간 루프를 작성합니다. 시작이 내 짐작보다 작으면 너무 낮게 인쇄합니다. 시작이 guess_me이면 '찾았다!'를 인쇄하고 루프를 종료합니다. 시작할 경우

루프가 더 크죠

4.3 4.4 사용

4.5 반품 시 a 사용

4.6 사용

4.9 범위(10)에서 홀수를 반환하는 get_odds라는 생성기 함수를 정의합니다. 반환된 세 번째 값을 찾아 인쇄하려면 for 루프를 사용하십시오.

than guess_me, 'oops'를 인쇄하고 루프를 종료합니다. 끝에서 시작 증분

루프에서 목록 값을 인쇄합니다 [3, 2, 1, 0].

(10) 범위의 짝수 목록을 작성하기 위해 이해 목록을 작성합니다.

사전 정사각형을 만들기 위한 사전 이해. 범위(10) 키를 사용하고 각 키의 정사각형을 값으로 사용합니다.

범위(10)의 홀수에서 홀수 집합을 생성하도록 이해를 설정합니다. 발생기 이해는 문자열 'Got'을 반환하고, 값은 값을 반환합니다.

범위(10). for 루프를 사용하여 이 과정을 반복합니다.

4.8 목록을 반환하는 good라는 함수를 정의합니다 ['해리', '론', '헤르미온느'.

4.7 숫자 사용

4.10 함수를 호출할 때 '시작'을 인쇄하고 종료할 때 '끝'을 인쇄하는 테스트라는 데코레이터를 정의합니다.

4.11 OopsException이라는 예외를 정의합니다. 무슨 일이 일어나는지 보려면 이 예외를 제기하십시오. 그런 다음 이 예외를 잡기 위한 코드를 작성하고 'Caught a oops'를 인쇄합니다.

4.12 zipcope을 사용하여 제목 = [습관의 창조물', [크루웰 페이트] 및 플롯 = [수녀가 괴물로 변한다', [유령 실 가게] 목록과 짝을 이루는 영화라는 사전을 만듭니다.

Functions 

지금까지 Python 코드 예는 모두 작은 조각이었습니다. 이러한 기능은 소규모 작업에 유용하지만 항상 조각을 다시 입력하려는 사람은 없습니다. 우리는 더 큰 코드를 관리할 수 있는 조각으로 정리할 수 있는 방법이 필요합니다.

코드 재사용을 위한 첫 번째 단계는 다른 모든 코드와 별도로 명명된 코드 조각입니다. 함수는 임의의 숫자와 유형의 입력 매개 변수를 사용하고 임의의 숫자와 유형의 출력 결과를 반환할 수 있습니다.

기능을 사용하여 두 가지 작업을 수행할 수 있습니다.

• Defineit • Callit 

Python 함수를 정의하려면 함수에 대한 입력 매개 변수를 포함하는 함수 이름인 def를 입력하고 마지막으로 콜론(:)을 입력합니다. 함수 이름은 변수 이름과 동일한 규칙을 가집니다(문자 또는 _로 시작하고 문자, 숫자 또는 _만 포함해야 함).

한 번에 한 단계씩 진행하고 먼저 파라미터가 없는 함수를 정의하고 호출합니다. 가장 간단한 Python 함수는 다음과 같습니다.

>>> def do_nothing(): ... pass 

이러한 매개변수가 없는 함수의 경우에도 정의에 괄호와 콜론이 필요합니다. if 문장으로 코드를 들여쓰는 것처럼 다음 줄을 들여써야 합니다. Python은 이 기능이 아무것도 하지 않는다는 것을 보여주기 위해 패스 문이 필요합니다. 이 페이지는 더 이상 표시되지 않더라도 일부러 비워둔 페이지와 같습니다.

이름과 괄호를 입력하기만 하면 이 기능을 호출할 수 있습니다. 광고된 대로 작동하며 제대로 작동하는 것은 없습니다.

  >>> do_nothing()

    >>>

이제 매개 변수는 없지만 단어 하나를 인쇄하는 다른 함수를 정의하여 호출하겠습니다.

>>> def make_a_sound(): ... print('quack') ...
>>> make_a_sound() quack 

make_a_sound() 함수를 호출했을 때, Python은 정의 내에서 코드를 실행했습니다. 이 경우, 한 단어를 인쇄하고 메인 프로그램으로 돌아갑니다.

매개 변수는 없지만 값을 반환하는 함수를 시도해 보겠습니다.

>>> def agree(): ... return True ... 

다음과 같은 경우 이 함수를 호출하고 반환된 값을 테스트할 수 있습니다.

>>> if agree():
... print('Splendid!')
... else:
... print('That was unexpected.') ...
Splendid! 

당신은 방금 큰 발걸음을 내디뎠어요. if 및 loop과 같은 테스트와 함수의 조합은 이전에 할 수 없었던 것을 가능하게 합니다.

이쯤에서 괄호 사이에 무언가를 넣어야 할 때입니다. echo() 함수를 anything 매개 변수 하나로 정의하겠습니다. 반환 문을 사용하여 호출자에게 다음 사이의 공백을 사용하여 값을 두 번 보냅니다.

>>> def echo(anything):
... return anything + ' ' + anything ...
>>> 

이제 'Rumplestiltskin' 문자열로 echo()를 호출하겠습니다.

>>> echo('Rumplestiltskin') 

    'Rumplestiltskin Rumplestiltskin'

함수를 호출할 때 함수에 전달되는 값을 인수라고 합니다. 인수를 사용하여 함수를 호출하면 해당 인수 값이 함수 내부의 해당 매개 변수에 복사됩니다. 이전 예에서는 echo() 함수를 'Rumplestiltskin' 인수 문자열로 호출했습니다. 이 값은 echo() 내에서 매개 변수에 복사된 다음 호출자에게 (이 경우 공백이 두 배로) 반환되었습니다.

이러한 기능 예는 매우 기초적이었다. 입력 인수를 사용하여 실제로 수행하는 함수를 작성해 보겠습니다. 색상에 대한 코멘트가 있는 이전 코드 조각을 수정하겠습니다. 주석이라고 하고 color라는 입력 문자열 매개변수를 사용하도록 합니다. 문자열 설명을 호출자에게 반환하고 호출자는 문자열로 수행할 작업을 결정합니다.

>>> def commentary(color): 

...
...
...
...
...
...
... else:
... return "I've never heard of the color " + color + "." ... 

>>> 

문자열 인수가 'blue'인 함수 주석()을 호출합니다.

>>> comment = commentary('blue') 

이 기능은 다음을 수행합니다.

• 함수의 내부 색상 매개변수에 '파란색' 값을 할당합니다

• if-elife-elife 논리 체인을 통해 실행

• 문자열을 반환합니다.

• 변수 설명에 문자열을 할당합니다. 무엇을 다시 얻을 수 있습니까?

>>> print(comment)
I've never heard of the color blue. 

함수는 모든 유형의 입력 인수(0 포함)를 수에 제한 없이 사용할 수 있습니다. 모든 유형의 출력 결과(0 포함)를 원하는 수만큼 반환할 수 있습니다. 함수가 명시적으로 호출되지 않으면 호출자는 없음 결과를 얻습니다.

>>> print(do_nothing()) None 

None Is Useful 

None은 할 말이 없을 때 자리를 유지하는 특별한 Python 값입니다. 부울 값으로 평가하면 거짓으로 표시되지만 부울 값 False와 동일하지는 않습니다. 예는 다음과 같습니다.

>>> thing = None
>>> if thing:
... print("It's some thing") ... else:
... print("It's no thing") ...
It's no thing 

없음과 부울 False 값을 구분하려면 Python의 is 연산자를 사용합니다.

>>> if thing is None:
... print("It's nothing") ... else:
... print("It's something") ...
It's nothing 

이것은 미묘한 구별처럼 보이지만 Python에서는 중요합니다. 결측값과 빈 값을 구분하려면 없음을 입력해야 합니다. 0 값 정수 또는 부동 소수, 빈 문자열(''), 목록([]), 튜플( (, )), 사전({}) 및 집합( )은 모두 False이지만 없음과 같지는 않습니다.

해당 인수가 없음인지 여부를 인쇄하는 빠른 함수를 작성하겠습니다.

 >>> is_none(None)

      It's None

      >>> is_none(True)

      It's True

      >>> is_none(False)

      It's False

      >>> is_none(0)

      It's False

      >>> is_none(0.0)

      It's False

      >>> is_none(())

      It's False

      >>> is_none([])

      It's False

      >>> is_none({})

      It's False

      >>> is_none(set())

      It's False

위치 인수

Python은 많은 언어에 비해 매우 유연한 방식으로 함수 인수를 처리합니다. 가장 친숙한 인수 유형은 위치 인수이며, 위치 인수의 값은 순서대로 해당 매개 변수에 복사됩니다.

이 함수는 위치 입력 인수를 사용하여 사전을 만들고 다음을 반환합니다.

>>> def menu(wine, entree, dessert):
... return {'wine': wine, 'entree': entree, 'dessert': dessert} ...
>>> menu('chardonnay', 'chicken', 'cake')
{'dessert': 'cake', 'wine': 'chardonnay', 'entree': 'chicken'} 

매우 흔하지만, 위치 논쟁의 단점은 각 위치의 의미를 다시 기억할 필요가 있다는 것입니다. 만약 우리가 잊고 와인과 함께 메뉴()를 첫 번째가 아닌 마지막 논쟁으로 부른다면, 식사는 매우 달라질 것이다.

  >>> menu('beef', 'bagel', 'bordeaux')

    {'dessert': 'bordeaux', 'wine': 'beef', 'entree': 'bagel'}

키워드 인수

위치 인수의 혼동을 방지하기 위해 함수의 정의와 다른 순서로 인수를 해당 매개 변수의 이름으로 지정할 수 있습니다.

  >>> menu(entree='beef', dessert='bagel', wine='bordeaux')

    {'dessert': 'bagel', 'wine': 'bordeaux', 'entree': 'beef'}

위치 인수와 키워드 인수를 혼합할 수 있습니다. 와인을 먼저 지정하고, 메뉴와 디저트에 키워드 인수를 사용합니다.

  >>> menu('frontenac', dessert='flan', entree='fish')

    {'entree': 'fish', 'dessert': 'flan', 'wine': 'frontenac'}

위치 인수와 키워드 인수가 모두 포함된 함수를 호출할 경우 위치 인수가 먼저 와야 합니다.

기본 매개변수 값 지정

매개변수에 대한 기본값을 지정할 수 있습니다. 호출자가 해당 인수를 제공하지 않는 경우 기본값이 사용됩니다. 이 싱겁게 들리는 기능은 실제로 매우 유용할 수 있습니다. 이전 예제를 사용하여:

>>> def menu(wine, entree, dessert='pudding'):
... return {'wine': wine, 'entree': entree, 'dessert': dessert} 

이번에는 디저트 인수 없이 메뉴()를 호출해 보십시오.

>>> menu('chardonnay', 'chicken') 

{'dessert': 'pudding', 'wine': 'chardonnay', 'entree': 'chicken'} 

인수를 제공하면 기본값 대신 사용됩니다.

  >>> menu('dunkelfelder', 'duck', 'doughnut')

    {'dessert': 'doughnut', 'wine': 'dunkelfelder', 'entree': 'duck'}

기본 인수 값은 함수를 실행할 때가 아니라 함수를 정의할 때 계산됩니다. 새로운 Python 프로그래머의 일반적인 오류는 목록이나 사전과 같은 가변 데이터 유형을 기본 인수로 사용하는 것입니다.

다음 테스트에서 buggy() 함수는 매번 빈 결과 목록과 함께 실행되고 arg 인수를 추가한 다음 단일 항목 목록을 인쇄해야 합니다. 하지만 버그가 있습니다. 처음 호출했을 때만 비어 있습니다. 두 번째로, 결과는 여전히 이전 통화의 항목 하나를 가지고 있습니다.

>>> def buggy(arg, result=[]): ... result.append(arg) ... print(result)
... 

>>> buggy('a')
['a']
>>> buggy('b') # expect ['b'] ['a', 'b'] 

다음과 같이 작성되었더라면 작동했을 것입니다.

>>> def works(arg):
... result = []
... result.append(arg) ... return result
...
>>> works('a')
['a']
>>> works('b')
['b'] 

수정 사항은 다른 정보를 전달하여 첫 번째 통화를 나타내는 것입니다.

>>> def nonbuggy(arg, result=None): ... if result is None:
... result = []
... result.append(arg) 

... print(result) ...
>>> nonbuggy('a') ['a'] 

    >>> nonbuggy('b')

    ['b']

*를 사용하여 위치 인수 수집

C 또는 C++에서 프로그래밍한 경우 Python 프로그램의 별표(*)가 포인터와 관련이 있다고 가정할 수 있습니다. 아니요, Python은 포인터가 없습니다.

함수 내부에서 매개변수와 함께 사용할 경우 별표는 변수 개수의 위치 인수를 매개변수 값의 튜플로 그룹화합니다. 다음 예에서 args는 print_args() 함수에 전달된 인수에서 비롯된 매개 변수 튜플입니다.

>>> def print_args(*args):
... print('Positional argument tuple:', args) ... 

인수를 사용하지 않고 호출하면 *args에서 아무 것도 얻을 수 없습니다.

>>> print_args() 

Positional argument tuple: ()

무엇을 주든 인수 튜플로 인쇄됩니다.

  >>> print_args(3, 2, 1, 'wait!', 'uh...')

    Positional argument tuple: (3, 2, 1, 'wait!', 'uh...')

이는 변수 개수의 인수를 허용하는 print()와 같은 함수를 작성할 때 유용합니다. 함수에 필요한 위치 인수도 있는 경우 *args는 끝에 가서 나머지 항목을 모두 잡습니다.

>>> def print_more(required1, required2, *args): ... print('Need this one:', required1) 

• ...  print('Need this one too:', required2)
• ...  print('All the rest:', args)
  ...
  >>> print_more('cap', 'gloves', 'scarf', 'monocle', 'mustache wax') Need this one: cap
      Need this one too: gloves
•     All the rest: ('scarf', 'monocle', 'mustache wax')
•  

*를 사용할 때 tuple 매개 변수 args를 호출할 필요는 없지만 Python에서는 일반적인 관용어입니다.

**를 사용하여 키워드 인수 수집

두 개의 별표(**)를 사용하여 키워드 인수를 사전으로 그룹화할 수 있습니다. 여기서 인수 이름은 키이고 값은 해당 사전 값입니다. 다음은 키워드 인수를 인쇄하는 print_kwargs() 함수를 정의하는 예제입니다.

• >>> def print_kwargs(**kwargs):
• ... print('Keyword arguments:', kwargs) ...

이제 키워드 인수를 사용하여 호출해 보십시오.

  >>> print_kwargs(wine='merlot', entree='mutton', dessert='macaroon')

    Keyword arguments: {'dessert': 'macaroon', 'wine': 'merlot', 'entree': 'mutton'}

함수에 들어 있는 콰르그스는 사전입니다.

위치 매개변수를 *args 및 **kwargs와 혼합할 경우 해당 순서에 따라 발생해야 합니다. args와 마찬가지로 이 키워드 매개 변수를 kwargs라고 할 필요는 없지만 일반적으로 사용됩니다.

문서 문자열

Python의 Zen은 가독성이 중요하다고 말합니다. 함수 본문 시작 부분에 문자열을 포함시켜 설명서를 함수 정의에 첨부할 수 있습니다. 다음은 함수의 docstring입니다.

>>> def echo(anything): 

•     ...      'echo returns its input argument'
•  
• ...  return anything

원하는 경우 다음과 같이 문서 문자열을 상당히 길게 만들고 리치 형식을 추가할 수도 있습니다.

• def print_if_true(thing, check): '''
          Prints the first argument if a second argument is true.
•         The operation is:
• 
              1. Check whether the *second* argument is true.

    2. If it is, print the *first* argument.

        '''

if check: print(thing) 

함수의 docstring을 인쇄하려면 Python help() 함수를 호출합니다. 함수의 이름을 전달하여 멋진 형식의 docstring과 함께 인수 목록을 가져옵니다.

>>> help(echo)
Help on function echo in module __main__: 

    echo(anything)

        echo returns its input argument

형식을 사용하지 않고 원시 문서 문자열만 보려면:

>>> print(echo.__doc__)
echo returns its input argument 

이상하게 생긴 __doc__은(는) 함수 내에서 변수로서 docstring의 내부 이름입니다. 103페이지의 "이름에서 _ 및 __의 사용"은 이 모든 밑줄 뒤에 숨겨진 이유를 설명합니다.

Functions Are First-Class Citizens 

파이썬의 모토를 언급했는데, 모든 것은 객체입니다. 여기에는 숫자, 문자열, 튜플, 목록, 사전 및 함수가 포함됩니다. 함수는 Python의 일급 시민권입니다. 변수를 변수에 할당하고 다른 함수에 인수로 사용하고 함수에서 반환할 수 있습니다. 이를 통해 다른 많은 언어로 수행하기가 어려운 Python에서 몇 가지 작업을 수행할 수 있습니다.

이를 테스트하기 위해 인수 없이 42만 인쇄하는 answer()라는 간단한 함수를 정의하겠습니다.

>>> def answer(): ... print(42) 

이 기능을 실행하면 다음과 같은 결과를 얻을 수 있습니다.

  >>> answer()

    42

이제 run_something이라는 다른 함수를 정의하겠습니다. 실행할 함수인 func라는 인수가 하나 있습니다. 일단 안으로 들어가면, 기능을 호출할 뿐입니다.

>>> def run_something(func): ... func() 

run_something()에 대한 답변을 전달하면 다른 thing와 마찬가지로 함수를 데이터로 사용합니다.

  >>> run_something(answer)

    42

답변()이 아닌 답변을 전달했습니다. Python에서 이 괄호는 이 함수를 호출하는 것을 의미합니다. 괄호 없이 Python은 다른 객체처럼 함수를 처리합니다. 다른 모든 Python과 마찬가지로 Python도 객체이기 때문입니다.

>>> type(run_something) <class 'function'> 

인수를 사용하여 함수를 실행해 보겠습니다. arg1과 arg2 두 숫자 인수의 합을 인쇄하는 add_args() 함수를 정의합니다.

>>> def add_args(arg1, arg2): ... print(arg1 + arg2) 

add_args()는 무엇입니까?

>>> type(add_args) 

<class 'function'>

이 시점에서 run_something_with_args()라는 함수를 정의하자.

인수:

• 기능—실행 기능

• arg1—펑크의 첫 번째 인수

• arg2—함수에 대한 두 번째 인수

>>> def run_something_with_args(func, arg1, arg2): ... func(arg1, arg2) 

run_something_with_args()를 호출할 때 호출자가 전달한 함수는 func 매개 변수에 할당되고 arg1과 arg2는 인수 목록에 이어지는 값을 가져옵니다. 그런 다음 괄호가 Python에게 명령했기 때문에 실행 중인 func(arg1, arg2)는 이러한 인수를 사용하여 해당 함수를 실행합니다.

function name add_args와 un_something_with_args() 인수 5와 9를 전달하여 테스트해 봅시다.

  >>> run_something_with_args(add_args, 5, 9)

    14

run_something_with_args() 함수 내에서 add_args 함수는 func 매개 변수에 할당되었고, 5는 arg1에 할당되었으며, 9는 arg2에 할당되었습니다. 이 작업은 실행되었습니다.

add_args(5, 9)

이를 *args 및 **kwargs 기법과 결합할 수 있습니다.

임의의 수의 위치 인수를 사용하고 합() 함수를 사용하여 합계를 계산한 다음 합계를 반환하는 검정 함수를 정의하겠습니다.

>>> def sum_args(*args): ... return sum(args) 

나는 이전에 합계를 언급한 적이 없다. 이 함수는 기본 제공 Python 함수로, int 또는 float 인수의 값 합계를 계산합니다.

함수와 이 함수에 전달하기 위한 임의의 수의 위치 인수를 사용하는 새 함수 run_with_positional_args()를 정의합니다.

>>> def run_with_positional_args(func, *args): ... return func(*args) 

자, 어서 불러봐:

 >>> run_with_positional_args(sum_args, 1, 2, 3, 4)

    10

Inner Functions 

다른 함수 내에서 함수를 정의할 수 있습니다.

>>> def outer(a, b): 

...

...

...

...

>>>

>>> outer(4, 7)

11

내부 기능은 루프 또는 코드 중복을 방지하기 위해 다른 기능 내에서 복잡한 작업을 두 번 이상 수행할 때 유용합니다. 문자열 예제의 경우 이 내부 함수는 인수에 일부 텍스트를 추가합니다.

Iterate Multiple Sequences with zip() 

zip() 함수를 사용하여 여러 시퀀스에 걸쳐 병렬로 반복하는 멋진 반복 트릭이 하나 더 있습니다

.>>> days = ['Monday', 'Tuesday', 'Wednesday']
>>> fruits = ['banana', 'orange', 'peach']
>>> drinks = ['coffee', 'tea', 'beer']
>>> desserts = ['tiramisu', 'ice cream', 'pie', 'pudding']
>>> for day, fruit, drink, dessert in zip(days, fruits, drinks, desserts): ... print(day, ": drink", drink, "- eat", fruit, "- enjoy", dessert) ... 

    Monday : drink coffee - eat banana - enjoy tiramisu

    Tuesday : drink tea - eat orange - enjoy ice cream

    Wednesday : drink beer - eat peach - enjoy pie

최단 시퀀스가 완료되면 zip이 중지됩니다. 목록(후식) 중 하나가 다른 목록보다 길어서 다른 목록을 확장하지 않으면 푸딩을 받을 수 없습니다.

이전포스팅의 "사전"은 딕트() 함수가 튜플, 목록 또는 문자열과 같은 두 항목 시퀀스에서 사전을 작성하는 방법을 보여줍니다. zip()을 사용하여 여러 시퀀스를 거닐고 동일한 간격띄우기에 있는 항목에서 튜플을 만들 수 있습니다. 해당하는 영어 단어와 프랑스어 단어 두 튜플을 만들어 봅시다.

    >>> english = 'Monday', 'Tuesday', 'Wednesday'

    >>> french = 'Lundi', 'Mardi', 'Mercredi'

이제 zip()을 사용하여 이 튜플을 페어링합니다. zip()으로 반환되는 값 자체는 튜플이나 목록이 아니라 다음 중 하나로 변환될 수 있는 테이블 값입니다.

    >>> list( zip(english, french) )

    [('Monday', 'Lundi'), ('Tuesday', 'Mardi'), ('Wednesday', 'Mercredi')]

zip()의 결과를 dict()에 직접 입력하고 voilà: 작은 영어-프랑스어 사전!

>>> dict( zip(english, french) ) 

{'Monday': 'Lundi', 'Tuesday': 'Mardi', 'Wednesday': 'Mercredi'} 

Generate Number Sequences with range() 

range() 함수는 지정된 범위 내의 숫자 스트림을 반환합니다. 먼저 목록이나 튜플과 같은 큰 데이터 구조를 만들고 저장할 필요가 없습니다. 이렇게 하면 컴퓨터의 모든 메모리를 사용하지 않고 프로그램을 손상시키지 않고도 큰 범위를 만들 수 있습니다.

범위()는 슬라이스를 사용하는 방법과 유사하게 사용합니다. 범위(시작, 중지, 단계) 시작을 생략하면 범위는 0에서 시작됩니다. 필요한 값은 중지뿐이며, 슬라이스와 마찬가지로 마지막으로 생성된 값은 중지 직전입니다. 스텝의 기본값은 1이지만 -1로 뒤로 돌아갈 수 있습니다.

zip()과 마찬가지로 range()는 테이블 가능한 개체를 반환하므로 ...에 대한 값을 단계별로 이동하거나 개체를 목록과 같은 시퀀스로 변환해야 합니다. 범위를 0, 1, 2로 설정합니다.

>>> for x in range(0,3): ... print(x)
...
0 

    1

    2

    >>> list( range(0, 3) )

    [0, 1, 2]

다음은 2 ~ 0 범위를 만드는 방법입니다.

>>> for x in range(2, -1, -1): ... print(x)
...
2 

1 

    0

    >>> list( range(2, -1, -1) )

    [2, 1, 0]

다음은 스텝 크기 2를 사용하여 0에서 10 사이의 짝수를 가져옵니다.

>>> list( range(0, 11, 2) ) 

[0,2,4,6,8,10] 

Other Iterators 

다음포스팅에서는 파일에 대한 반복을 보여줍니다. 이전포스팅에서는 사용자가 직접 정의한 객체 위에 반복을 설정하는 방법을 볼 수 있습니다.

Comprehensions 

이해는 한 명 이상의 반복기에서 Python 데이터 구조를 만드는 간단한 방법입니다. 이해를 통해 루프와 조건부 테스트를 세부 구문을 적게 조합할 수 있습니다. 이해력을 사용하는 것은 때때로 당신이 파이썬을 초보자 이상 알고 있다는 신호로 받아들여집니다. 다시 말해, 피토닉에 가깝죠.

List Comprehensions 

이렇게 한 번에 한 항목씩 1부터 5까지의 정수 목록을 작성할 수 있습니다.

>>> number_list = []
>>> number_list.append(1) >>> number_list.append(2) >>> number_list.append(3) >>> number_list.append(4) >>> number_list.append(5) >>> number_list [1,2,3,4,5] 

또는 반복기와 범위() 함수를 사용할 수도 있습니다.

>>> number_list = []
>>> for number in range(1, 6): ... number_list.append(number) ...
>>> number_list
[1,2,3,4,5] 

또는 범위()의 출력을 목록으로 직접 변환할 수 있습니다.

>>> number_list = list(range(1, 6)) >>> number_list
[1,2,3,4,5] 

이러한 접근 방식은 모두 유효한 Python 코드이며 동일한 결과를 생성합니다. 그러나 목록을 작성하는 더 많은 피토닉 방법은 목록 이해를 사용하는 것입니다. 목록 이해의 가장 간단한 형태는 다음과 같습니다.

[ 아이템에 대한 식을(를) 반복할 수 없습니다.

다음은 목록 이해에서 정수 목록을 작성하는 방법입니다.

>>> number_list = [number for number in range(1,6)] >>> number_list
[1,2,3,4,5] 

첫 번째 행에서 목록의 값을 생성하기 위한 첫 번째 숫자 변수가 필요합니다. 즉, 루프 결과를 number_list에 넣습니다. 두 번째 숫자는 for 루프의 일부입니다. 첫 번째 숫자가 식임을 표시하려면 다음 변형을 시도해 보십시오.

>>> number_list = [number-1 for number in range(1,6)] >>> number_list
[0,1,2,3,4] 

목록 이해에 따라 대괄호 안의 루프가 이동합니다. 이 이해 예시는 이전 예보다 간단하지 않지만, 더 있습니다. list comà 이해에는 다음과 같은 조건식이 포함될 수 있습니다.

[ 조건일 경우 반복할 수 없는 항목에 대한 표현식 ]

1과 5 사이의 홀수 목록만 작성하는 새로운 이해를 만들어 봅시다(홀수일 경우 %2이 참이고 짝수일 경우 거짓임을 기억하십시오.

>>> a_list = [number for number in range(1,6) if number % 2 == 1] >>> a_list
[1, 3, 5] 

이제, 이해는 전통적인 이해 방식보다 조금 더 좁습니다.

>>> a_list = []
>>> for number in range(1,6): ... ifnumber%2==1: 

...

...

>>>  a_list

[1, 3, 5]

a_list.append(number)

마지막으로, 내포된 루프가 있을 수 있는 것처럼, 해당 이해에 ...용 절이 두 개 이상 있을 수 있습니다. 먼저 일반 중첩 루프를 사용해 결과를 인쇄해 보겠습니다.

>>> rows = range(1,4) >>> cols = range(1,3) >>> for row in rows: 

• ...  for col in cols:
• ...  print(row, col)

... 

11 12 21 22 31 32 

이제 이해를 사용하여 변수 셀에 할당하여 (행, 콜) 튜플 목록을 만듭니다.

>>> rows = range(1,4)
>>> cols = range(1,3)
>>> cells = [(row, col) for row in rows for col in cols] >>> for cell in cells:
... print(cell)
...
(1, 1)
(1, 2)
(2, 1)
(2, 2)
(3, 1)
(3, 2) 

또한 튜플 언팩을 사용하여 셀 목록에서 반복하면서 각 튜플의 행 및 col 값을 유크할 수 있습니다.

>>> for row, col in cells: ... print(row, col) ...
11 

12 21 22 31 32 

앞줄과 뒷줄에 대한 이해도의 파편도 만약 테스트를 했다면 그들만의 파편을 가질 수 있었을 것이다.

Dictionary Comprehensions 

단순히 목록만으로 뒤지지 않기 위해 사전도 이해력이 있다. 가장 간단한 양식은 친숙해 보입니다.

{key_expression : interitable 식에 대한 value_expression}

목록 이해와 마찬가지로 사전 이해도 테스트와 사전 이해도 함께 가질 수 있습니다.

절의 경우 다중:

>>> word = 'letters' 

>>> letter_counts = {letter: word.count(letter) for letter in word} 

  >>> letter_counts

    {'l': 1, 'e': 2, 't': 2, 'r': 1, 's': 1}

우리는 '문자' 문자열의 일곱 글자 각각에 루프를 돌리고 그 글자가 몇 번 표시되는지 세고 있습니다. 우리가 사용하는 단어 중 두 개는 모든 e와 모든 t를 두 번 세야 하기 때문에 시간 낭비입니다. 하지만, 우리가 e를 두 번째로 셀 때, 우리는 이미 있던 사전의 항목을 교체하기 때문에 해를 끼치지 않습니다; t를 셀 때도 마찬가지입니다. 그래서, 다음은 조금 더 피토닉했을 것이다.

>>> word = 'letters'
>>> letter_counts = {letter: word.count(letter) for letter in set(word)} >>> letter_counts
{'t': 2, 'l': 1, 'e': 2, 'r': 1, 's': 1} 

집합(워드)을 반복하면 문자열 단어를 반복하는 순서와 다른 순서로 문자가 반환되기 때문에 사전의 키는 이전 예와 다른 순서로 정렬됩니다.

Set Comprehensions 

누구도 소외되고 싶어하지 않기 때문에 세트도 이해력이 있다. 가장 간단한 버전은 방금 본 목록과 사전 이해도처럼 보입니다.

{식 interitable}

긴 버전(테스트의 경우 절에 대해 여러 개)도 다음 집합에 대해 유효합니다.

>>> a_set = {number for number in range(1,6) if number % 3 == 1} >>> a_set
{1, 4} 

Generator Comprehensions 

튜플은 이해력이 없습니다! 목록 이해의 대괄호를 괄호로 변경하면 튜플 이해가 생성된다고 생각했을 수 있습니다. 그리고 다음과 같이 입력하면 예외가 없기 때문에 작동하는 것으로 보입니다.

>>> number_thing = (number for number in range(1, 6))

괄호 사이에 있는 것은 발전기 이해이며, 그것은 gen‐를 반환한다.

연산자 객체:

>>> type(number_thing) 

<class 'generator'>

발전기에 대해 더 자세히 알아보겠습니다(98페이지의 "발전기"). 발전기는 한 가지 방법이다.

반복자에게 데이터를 제공합니다.

다음 그림과 같이 이 생성기 개체에 대해 직접 반복할 수 있습니다.

>>> for number in number_thing: ... print(number)
...
1 

2 3 4 5 

또는 생성기 이해에 목록() 통화를 줄여서 목록 이해처럼 작동할 수 있습니다.

>>> number_list = list(number_thing) >>> number_list
[1,2,3,4,5] 

생성기는 한 번만 실행할 수 있습니다. 목록, 세트, 문자열 및 사전은 메모리에 존재하지만 생성기는 즉시 값을 생성하여 반복기를 통해 한 번에 하나씩 전달합니다. 이러한 구성 요소를 기억하지 못하므로 생성기를 다시 시작하거나 백업할 수 없습니다.

이 제너레이터를 다시 반복하려고 하면 다음과 같이 탭이 되어 있습니다.

   >>> try_again = list(number_thing)

    >>> try_again

    []

여기서와 같이 발전기를 이해하거나 발전기 기능을 통해 발전기를 만들 수 있습니다. 먼저 일반적인 기능에 대해 이야기한 후 발전기 기능의 특수한 사례에 대해 알아보겠습니다.

대부분의 코드 예제는 대화형 인터프리터를 사용했으며 짧았습니다. 이제 데이터뿐만 아니라 Python 코드 구조화 방법에 대해 알아보겠습니다.

많은 컴퓨터 언어는 코드 섹션을 표시하기 위해 중괄호({ 및 })와 같은 문자 또는 시작 및 끝과 같은 키워드를 사용합니다. 이러한 언어에서는 일관된 들여쓰기를 사용하여 자신과 다른 사용자가 프로그램을 더 잘 읽을 수 있도록 하는 것이 좋습니다. 코드 라인업을 깔끔하게 할 수 있는 도구도 있습니다.

그가 파이썬이 된 언어를 디자인할 때 Guido van Rossum은 들여쓰기 자체만으로도 프로그램의 구조를 정의하기에 충분하다고 판단하고 모든 괄호와 곱슬곱슬한 중괄호를 입력하는 것을 피했다. Python은 프로그램 구조를 정의하기 위해 이렇게 공간을 사용하는 경우는 흔하지 않습니다. 신입들이 가장 먼저 주목하는 부분 중 하나이며, 다른 언어를 접해본 경험이 있는 사람들에게는 이상하게 보일 수 있다. 알고 보니 Python을 잠시 쓰고 나면 자연스럽고 더 이상 눈치채지 못하게 된다. 더 적게 타이핑하면서 더 많은 것을 하는 것에 익숙해지기도 합니다.

Comment with # 

주석은 프로그램에서 Python 해석기에서 무시되는 텍스트입니다. 주석을 사용하여 근처의 Python 코드를 명확히 하거나, 언젠가 수정하기 위해 스스로 메모를 하거나, 원하는 목적을 위해 메모를 할 수 있습니다. # 문자를 사용하여 설명을 표시하면 해당 시점부터 현재 줄 끝까지 모두 설명의 일부입니다. 일반적으로 다음과 같이 줄 자체에 설명이 표시됩니다.

>>> # 60 sec/min * 60 min/hr * 24 hr/day 

>>> seconds_per_day = 86400 

또는 코드와 같은 줄에 다음과 같이 언급합니다.

>>> seconds_per_day = 86400 # 60 sec/min * 60 min/hr * 24 hr/day 

 캐릭터는 해시, 샤프, 파운드 또는 사악한 옥토 소프의 여러 이름을 가집니다.1 당신이 뭐라고 부르든, 2의 효과는 그것이 나타나는 선의 끝까지만 지속됩니다.

Python에는 여러 줄의 설명이 없습니다. #로 각 주석 줄 또는 섹션을 명시적으로 시작해야 합니다.

>>> # I can say anything here, even if Python doesn't like it, ... # because I'm protected by the awesome
... # octothorpe.
... 

>>> 

그러나 텍스트 문자열에 있는 경우 강력한 옥토소프는 일반 # 문자 역할로 돌아갑니다.

>>> print("No comment: quotes make the # harmless.") No comment: quotes make the # harmless. 

Continue Lines with \ 

줄이 상당히 짧을 때 프로그램을 더 잘 읽을 수 있습니다. 권장(필수는 아님) 최대 행 길이는 80자입니다. 하고 싶은 말을 다 할 수 없는 경우에는 연속 문자 \(백슬래시)를 사용할 수 있습니다. 줄 끝에 \를 붙이면 Python이 갑자기 같은 줄에 서 있는 것처럼 행동합니다.

예를 들어, 작은 문자열로 긴 문자열을 작성하려면 다음과 같은 단계를 거치면 됩니다.

 >>> alphabet = ''

    >>> alphabet += 'abcdefg'

    >>> alphabet += 'hijklmnop'

    >>> alphabet += 'qrstuv'

    >>> alphabet += 'wxyz'

또는 연속 문자를 사용하여 한 번에 수행할 수 있습니다.

  >>> alphabet = 'abcdefg' + \

•     ...       'hijklmnop' + \
•     ...       'qrstuv' + \
•     ...      'wxyz'
•  

Python 식이 여러 줄로 확장되는 경우에도 줄 연속성이 필요합니다.

>>>1+2+
File "<stdin>", line 1 

1+2+ ^ 

SyntaxError: invalid syntax >>>1+2+\
... 3
6 

>>> 

Compare with if, elif, and else 

지금까지 포스팅에서 우리는 거의 전적으로 데이터 구조에 대해 이야기했습니다. 이제 데이터를 프로그램으로 엮는 코드 구조에 첫 발을 내디뎠습니다(세트에 관한 이전 장의 섹션에서 이러한 내용을 미리 볼 수 있습니다). 지속적인 피해가 없었으면 좋겠다.) 첫 번째 예는 부울 변수 재해의 값을 확인하고 적절한 주석을 인쇄하는 작은 Python 프로그램입니다.

>>> disaster = True >>> if disaster:
... print("Woe!") ... else: 

... print("Whee!") ...
Woe!
>>> 

if 및 else 행은 조건(여기서 재해 값)이 True인지 여부를 확인하는 Python 문입니다. Print()는 일반적으로 화면에 인쇄하는 Python의 내장 기능입니다.

다른 언어로 프로그래밍한 경우에는 if 테스트에 괄호가 필요하지 않습니다. 만약(재앙 == 진실) 같은 말은 하지 마라. 끝에 콜론(:)이 필요합니다. 나처럼 가끔 콜론을 입력하지 않으면 Python이 오류 메시지를 표시합니다.

각 인쇄() 라인은 테스트 아래에 들여씁니다. 네 칸을 이용해서 각 부문을 들여보냈지 원하는 모든 들여쓰기를 사용할 수 있지만 Python은 섹션 내의 코드에 일관성을 유지해야 합니다. 왼쪽 줄에 있는 줄에 같은 양을 들여써야 합니다. PEP-8이라고 불리는 권장 스타일은 네 개의 공간을 사용하는 것입니다. 탭을 사용하거나 탭과 공백을 섞지 마십시오. 들여쓰기 카운트를 망칩니다.

여기서는 여러 가지 작업을 수행했습니다. 챕터가 진행됨에 따라 자세히 설명하겠습니다.

• Disaster라는 변수에 True 부울 값 할당

• 재해의 가치에 따라 다른 코드를 실행하고 if와 other를 사용하여 조건부 비교 수행

• 일부 텍스트를 인쇄하기 위해 인쇄() 함수 호출

필요한 만큼 깊이 있는 테스트를 테스트 내에서 수행할 수 있습니다.

• >>> furry = True
  >>> small = True
  >>> if furry:
  ... if small:
  ... print("It's a cat.") ... else:
• ... print("It's a bear!") ... else:
  ... if small:
  ... print("It's a skink!") ... else:
  ... print("It's a human. Or a hairless bear.") ...
  It's a cat.

Python에서 들여쓰기는 if 섹션과 다른 섹션의 쌍을 지정하는 방법을 결정합니다. 우리의 첫 번째 테스트는 털을 확인하는 것이었다. 털북숭이가 사실이기 때문에, Python은 작으면 움푹 들어간 곳으로 간다. 작으면 True로 설정했기 때문에 작으면 True로 평가됩니다. 그래서 Python은 다음 줄을 실행시켜서 인쇄하게 됩니다. 고양이입니다.

테스트할 수 있는 가능성이 세 개 이상인 경우, elif(다른 경우 의미) 및 다음을 사용합니다.를 사용합니다.

>>> color = "puce"
>>> if color == "red":
... print("It's a tomato")
... elif color == "green":
... print("It's a green pepper")
... elif color == "bee purple":
... print("I don't know what it is, but only bees can see it") ... else:
... print("I've never heard of the color", color)
...
I've never heard of the color puce 

앞의 예에서는 == 연산자와 동일한지 테스트했습니다. Python의 비교 연산자는 다음과 같습니다.

equality == inequality != less than < 

less than or equal <= greater than > greater than or equal >= membership in ... 

그러면 부울 값이 True 또는 False로 반환됩니다. 이 모든 기능이 어떻게 작동하는지 살펴보겠습니다. 먼저 x에 값을 할당합니다.

>>>x=7

이제 몇 가지 테스트를 해보겠습니다.

>>>x==5 False >>>x==7 True >>>5<x True >>>x<10 True 

동일성을 검정하는 데 두 등호(==)가 사용됩니다. 단일 등호(=)는 변수에 값을 할당하는 데 사용됩니다.

동시에 여러 번 비교해야 하는 경우 부울 연산자를 사용하고 최종 부울 결과를 결정하지 않습니다.

부울 연산자는 비교 중인 코드 청크보다 우선 순위가 낮습니다. 즉, 덩어리를 먼저 계산한 다음 비교한다는 뜻입니다. 이 예에서는 xx를 7,5 < x로 설정하고 x < 10도 True로 계산하기 때문에 최종적으로 True와 True를 사용합니다.

>>>5<xandx<10 True 

이전내용의 "우선 순위"가 지적하듯이, 우선순위에 대한 혼란을 피하는 가장 쉬운 방법은 괄호를 추가하는 것입니다.

>>>(5<x)and(x<10) True 

다음은 몇 가지 다른 테스트입니다.

>>>5<xorx<10 True >>>5<xandx>10 False >>>5<xandnotx>10 True 

하나의 변수를 사용하여 다중 비교를 수행하는 경우 Python을 사용하면 다음과 같은 작업을 수행할 수 있습니다.

>>>5<x<10 True 

5<x>와 10<x>와 같습니다. 더 긴 비교를 작성할 수도 있습니다.

>>>5<x<10<999 

True 

무엇이 진실인가?

우리가 검사하는 요소가 부울이 아니라면요? Python에서 True와 False로 간주하는 것은 무엇입니까?

거짓 값이 반드시 False일 필요는 없습니다. 예를 들어, 다음 항목은 모두 False로 간주됩니다.

boolean False null None zero integer 0
zero float 0.0 empty string '' empty list [] empty tuple () empty dict {} empty set set() 

다른 모든 것은 사실로 간주됩니다. Python 프로그램은 이 "truthiness"(또는 이 경우 "false") 정의를 사용하여 빈 데이터 구조와 False 조건을 확인합니다.

>>> some_list = []
>>> if some_list:
... print("There's something in here") ... else:
... print("Hey, it's empty!")
...
Hey, it's empty! 

테스트하는 것이 단순 변수가 아닌 표현식인 경우 Python은 표현식을 평가하고 부울 결과를 반환합니다. 따라서 다음을 입력하면 됩니다.

if color == "red":

Python은 색상 == "빨간색"을 평가합니다. 이 예에서는 puce라는 문자열을

color == "red"는 False이고 Python은 다음 테스트로 이동합니다.

elif color == "green": 

Repeat with while 

위에서 아래로 실행되는지, 엘프 또는 다른지를 사용하여 테스트합니다. 가끔, 우리는 한 번 이상 무언가를 해야 합니다. 우리는 루프가 필요합니다. 파이썬의 가장 간단한 루핑 메커니즘은 while입니다. 대화형 인터프리터를 사용하여 다음 예제를 시도해 보십시오. 1에서 5까지의 숫자를 인쇄하는 간단한 루프입니다.

>>> count = 1
>>> while count <= 5: ... print(count) ... count += 1 ...
1
2
3
4
5
>>> 

우리는 먼저 셀 값 1을 할당했습니다. 반면 루프는 카운트의 값을 5와 비교하고 카운트가 5보다 작거나 같으면 계속했습니다. 루프 내부에서 count 값을 출력한 다음 count + = 1 문장으로 값을 1씩 증가시켰습니다. Python은 루프의 맨 위로 돌아가서 카운트를 다시 5와 비교합니다. count 값이 2가 되므로 while loop의 내용이 다시 실행되어 count가 3으로 증가합니다.

이는 루프 하단에서 카운트가 5에서 6으로 증가할 때까지 계속됩니다. 다음 번에 맨 위로 이동할 때 카운트 = 5가 이제 False가 되고 while 루프가 종료됩니다. Python은 다음 행으로 넘어갑니다.

Cancel with break 

문제가 발생할 때까지 루프를 수행하려고 하지만 언제 발생할지 확신할 수 없는 경우 중단 문과 함께 무한 루프를 사용할 수 있습니다. 이번에는 Python의 입력() 함수를 통해 키보드의 입력 줄을 읽고 첫 글자를 대문자로 인쇄하겠습니다. 문자 q만 포함된 줄을 입력하면 루프가 해제됩니다.

>>> while True: 

… stuff = input(“string to capitalize [Type q quit]: “)

... it stuff == “q” :

... brake

... print(stuff.capitalize()) 

String to capitalize [type q to quit]: test

Test

String to capitalize [type q to quit]: hey, it works

Hey, it works

String to capitalize [type q to quit]: q

>>>

stuff = input("String to capitalize [type q to quit]: ") 

Skip Ahead with continue 

때로는 루프에서 벗어나고 싶지 않고 어떤 이유로든 다음 반복으로 건너뛰고 싶을 때가 있습니다. 다음은 계획된 예입니다. 정수를 읽고, 정사각형이 홀수이면 인쇄하고, 짝수이면 건너뜁시다. 댓글 몇 개 달았어요. 다시 q를 사용하여 루프를 중지합니다.

>>> while True:
Integer, please [q to quit]: 1 1 squared is 1 

value = input("Integer, please [q to quit]: ") if value == 'q': # quit 

break 

number = int(value)
if number % 2 == 0: # an even number 

continue
print(number, "squared is", number*number) 

Integer, please [q to quit]: 2 Integer, please [q to quit]: 3 3 squared is 9
Integer, please [q to quit]: 4 Integer, please [q to quit]: 5 5 squared is 25 

    Integer, please [q to quit]: q

    >>>

Iterate with for 

Python은 그럴듯한 이유로 반복기를 자주 사용합니다. 데이터 구조의 크기나 구현 방법을 알지 못한 채 데이터 구조를 이동할 수 있습니다. 즉석에서 생성된 데이터 위에 반복할 수도 있으므로, 그렇지 않으면 컴퓨터 메모리에 맞지 않는 데이터 스트림을 한 번에 처리할 수 있습니다.

다음과 같은 시퀀스를 밟는 것은 합법적인 Python입니다.

>>> rabbits = ['Flopsy', 'Mopsy', 'Cottontail', 'Peter'] >>> current = 0
>>> while current < len(rabbits):
... print(rabbits[current]) 

    ...     current += 1

    ...

    Flopsy

    Mopsy

    Cottontail

    Peter

하지만 더 좋은, 더 피토닉한 방법이 있다.

>>> for rabbit in rabbits: ... print(rabbit)
...
Flopsy 

    Mopsy

    Cottontail

    Peter

토끼와 같은 목록은 문자열, 튜플, 사전, 세트 및 기타 일부 요소와 함께 Python에서 쉽게 사용할 수 있는 개체 중 하나입니다. 튜플 또는 목록 반복은 한 번에 항목을 생성합니다. 문자열 반복은 다음과 같이 한 번에 문자를 생성합니다.

>>> word = 'cat'
>>> for letter in word: ... print(letter) ...
c
a
t 

사전(또는 해당 키() 함수) 위에 반복하면 키가 반환됩니다. 이 예제에서 키는 보드 게임 Clou(북미 이외의 클루도)에 있는 카드 유형입니다.

 >>> accusation = {'room': 'ballroom', 'weapon': 'lead pipe',

                      'person': 'Col. Mustard'}

>>> for card in accusation: # or, for card in accusation.keys(): ... print(card)
...
room 

    weapon

    person

키 대신 값을 반복하려면 사전의 값() 함수를 사용합니다.

>>> for value in accusation.values(): ... print(value)
...
ballroom 

    lead pipe

    Col. Mustard

튜플의 키와 값을 모두 반환하려면 다음과 같은 항목() 함수를 사용합니다.

>>> for item in accusation.items(): ... print(item)
...
('room', 'ballroom') 

    ('weapon', 'lead pipe')

    ('person', 'Col. Mustard')

한 번에 튜플에 할당할 수 있습니다. 항목()으로 반환되는 각 튜플에 대해 첫 번째 값(키)을 카드에 할당하고 두 번째 값(값)을 내용에 할당합니다.

>>> for card, contents in accusation.items():
... print('Card', card, 'has the contents', contents) ...
Card weapon has the contents lead pipe
Card person has the contents Col. Mustard
Card room has the contents ballroom 

Cancel with break 

잠시 동안처럼 a 루프의 중단이 루프를 벗어나게 됩니다.

Skip with continue 

for 루프에 계속을 삽입하면 잠시 동안처럼 루프의 다음 반복으로 점프합니다.

Check break Use with else 

 for에는  정상적으로 완료되었는지 여부를 확인하는 다른 옵션이 있습니다. break가 호출되지 않은 경우 다른 문이 실행됩니다.

이 기능은 루프의 이전 항목이 중단으로 조기에 중지되는 대신 완료로 실행되었는지 확인하려는 경우에 유용합니다. 다음 예제의 for 루프에는 치즈의 이름이 인쇄되어 있으며 치즈 가게에서 치즈가 발견되면 파손됩니다.

>>> cheeses = []
>>> for cheese in cheeses:
... print('This shop has some lovely', cheese)
... break
... else: # no break means no cheese
... print('This is not much of a cheese shop, is it?') ...
This is not much of a cheese shop, is it?