파이썬코딩

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?