.. _tut-informal:
************************************** ***** ***************
Python에 대한 비공식 소개 Python 요약 소개
************ ******** *************************************
다음 예에서 입력과 출력은
프롬프트(``>>>`` 및 ``...``)의 유무로 구분됩니다. 예를 반복하려면, 프롬프트가 나타날 때
프롬프트 뒤의 모든 내용을 입력해야 합니다. 프롬프트로 시작하지 않는
줄은 인터프리터에서 출력됩니다.
예제에서 줄 자체는 빈 줄을 입력해야 함을 의미합니다. 이는
여러 줄 명령을 종료하는 데 사용됩니다.
다음 예에서는 입력 및 출력이 프롬프트됩니다. 보다 큼 기호와 마침표(``> >>`` 및
```...```) 주석을 사용합니다. 이러한 예제를 재현하려면 인터프리터 프롬프트 뒤(프롬프트
문자 뒤)에 프롬프트를 포함하지 않는 코드 줄을 입력하세요. 연습에서 만난 슬레이브 프롬프트는
을 의미하므로 통역사가 이것이 여러 줄 명령의 끝임을 알 수 있도록 끝에 추가로 빈 줄을 입력해야 합니다.
대화형 프롬프트에서 입력한 내용을 포함하여 이 매뉴얼의 많은 예
Python의 주석은 해시 문자
``#`로 시작합니다. `, 실제 줄의 끝까지 확장됩니다.
줄 시작 부분이나 공백 또는 코드 뒤에 주석이 나타날 수 있지만 문자열
리터럴 안에는 표시되지 않습니다. 문자열 리터럴 내의 문자는 단지 해시 문자일 뿐입니다.
주석은 코드를 명확하게 하기 위한 것이며 Python에서 해석되지 않으므로
예제에서 입력할 때 생략될 수 있습니다.
대화형 프롬프트가 있는 예제를 포함하여 이 매뉴얼의 많은 예제에는 설명이 포함되어 있습니다.
Python의 주석은 # 문자로 시작하여 실제 줄 끝으로 이동합니다. (번역 - 원저자는 편집이 아닌 실제 줄바꿈을 표시하기 위해
``물리적 줄``을 사용했습니다. 브라우저의 자동 줄 바꿈). 주석은
줄의 시작 부분이나 공백 또는 코드 뒤에서 시작할 수 있지만 문자열에는 나타나지 않습니다. 텍스트 문자열의 #
문자는 단순히 # 을 나타냅니다. 코드의 주석은 Python에서 해석되지 않습니다.
예제를 입력할 때 무시할 수 있습니다.
몇 가지 예::
# 첫 번째 댓글입니다
SPAM = 1/3!
STRING = "# 이것은 댓글이 아닙니다. "
.. _tut-calculator:
Python을 계산기로 사용 Python을 계산기로 사용
=============== ================================ =
몇 가지 간단한 Python 명령을 실행해 보겠습니다. 그리고
기본 프롬프트인 ``>>>``를 기다립니다. (오래 걸리지는 않습니다.)
몇 가지 간단한 Python 명령을 시도해 보겠습니다. 통역사를 시작하고 메인 프롬프트 ``>>>``
가 나타날 때까지 기다립니다(오래 걸리지 않습니다).
.. _tut-numbers:
숫자 숫자 값
------------
통역사는 간단한 계산기: 표현식을 입력하면
값이 기록됩니다. 표현식 구문은 간단합니다.
연산자 ``+``, ``-``, `` * `` 및 ``/``는 대부분의 다른 언어에서와 마찬가지로 작동합니다.
(예: Pascal 또는 C) 그룹화에는 괄호를 사용할 수 있습니다. 인터프리터 표현은 간단한 계산기와 같습니다. 표현식을 입력하면
값이 반환됩니다. 표현식 구문은 간단합니다. 연산자 ``+``, ``-``, ``*`` 및 ``/``는 다른 언어(예: Pascal 또는 C)와 동일합니다. 대괄호가 사용됩니다. 그룹화를 위해. 예::
>>> 2+2
4
>>> # 댓글입니다
. . 2+2
4
>>> 2+2 # 코드와 같은 줄에 주석 추가
4
> ;>> (50-5*6)/4
5
>>> # 정수 나누기는 바닥을 반환합니다:
... 7 /3
2
>>> 7/-3
-3
등호(``'='` ` )는 변수에 값을 할당하는 데 사용됩니다. 이후에는 다음 대화형 프롬프트 전에
결과가 표시되지 않습니다.:
등호(``'='``)는 다음과 같습니다. 변수 할당에 사용됨:
>>> width = 20
>>> height = 5*9
>>> ; 너비 * 높이
900
한 값을 여러 변수에 동시에 할당할 수 있습니다::
한 값을 여러 변수에 동시에 할당할 수 있습니다::
> >> x = y = z = 0 # x, y 및 z가 0입니다
>>>
0
변수를 사용하려면 먼저 "정의"(값 할당)해야 합니다. 그렇지 않으면
오류가 발생합니다. ::
변수 사용하기 전에 "정의"(할당)해야 합니다. 그렇지 않으면 오류가 발생합니다.:
>>> # 정의되지 않은 변수에 액세스하려고 합니다.
... n
역추적(가장 최근 호출 마지막):
파일 "
NameError : 이름 'n'이 정의되지 않았습니다
혼합 유형 피연산자를 사용하는 연산자를 완벽하게 지원합니다
정수 피연산자를 부동 소수점으로 변환::
부동 소수점 숫자는 완벽하게 지원됩니다. 혼합 유형 피연산자를 사용하는 연산자는 자동으로 부동 소수점 숫자로 변환됩니다::
>>> 3 * 3.75 / 1.5
7.5
> ;>> 7.0 / 2
3.5
허수는 ``j`` 또는 ``J' 접미사
로 작성됩니다. ``. 실수 성분이 0이 아닌 복소수는
``(real+imagj)``로 작성하거나 ``complex(real, imag)`` 함수로 생성할 수 있습니다.
::
복수 또한 지원됩니다. 접미사 ``j`` 또는 ``J``가 있는 숫자는 허수로 처리됩니다. 0이 아닌 실수 부분이 있는 복소수
수는 ``(real+imagj)``로 작성되거나 ``complex(real, imag)`` 함수를 사용하여 생성할 수 있습니다::
>>> 1j * 1J
(-1+0j)
>>> 1j * 복합(0,1)
(-1 +0j)
>>> 3+1j*3
(3+3j)
>>> 1j)*3
(9+3j)
>>> (1+2j)/(1+1j)
(1.5+0.5j)
복소수는 항상 실수
와 허수부라는 두 개의 부동 소수점 숫자로 표현됩니다. 복소수 *z*에서 이러한 부분을 추출하려면
``을 사용하세요. z.real` ` 및 ``z.imag`` ::
복소수의 실수부와 허수부는 항상 두 개의 부동 소수점 숫자로 기록됩니다. 복소수 *z*에서 실수부와 허수부를 추출하려면 ``z.real`` 및 ``z.imag``를 사용하세요. ::
>>> a=1.5+0.5j
>>> >> a.imag
0.5
부동 소수점 및 정수로의 변환 기능(:func:`float`,
:func:`int` 및: func:`long`)은 복소수에는 작동하지 않습니다 --- 복소수를 실수로 변환하는 올바른 방법은 없습니다.
``abs(z)``를 사용하여
실수 부분을 얻기 위한 크기(부동 소수점) 또는 ``z.real`` ::부동 소수점 숫자와 정수 사이의 변환 함수( :func:`float` 및 :func:`int` 및 :func:`long` )은 복소수에 사용할 수 없습니다. 복소수를 실제 숫자로 변환하는 올바른 방법은 없습니다. ``abs(z)`` 함수는 모듈러스(부동 소수점 수)를 가져오거나 실수 부분을 가져오기 위해 ``z.real``을 사용합니다:: >>> 3.0+4.0j >>> float(a) 역추적(가장 최근 호출 마지막): 파일 "> >> 가격 = 100.50 >>> 가격 * 세금 12.5625 >>> 113.0625 >>> round(_, 2) 113.06 이 변수는 사용자가 명시적으로 읽기 전용으로 처리해야 합니다.값을 할당합니다 --- 마법 같은 동작으로 내장 변수를 가리는같은 이름의 독립적인 지역 변수를 생성합니다.이 변수는 사용자에게는 읽기 전용입니다. 여기에 값을 할당하려고 하지 마십시오. 동일한 이름을 가진 별도의 지역 변수를 생성하면 시스템 내장 변수의 마법 효과가 차단됩니다. .. _tut-strings:
문자열 문자열
---------------
파이썬은 숫자 외에도 문자열을 조작할 수 있는데, 이는
여러 가지 방법으로 작은 따옴표나 큰 따옴표로 묶을 수 있습니다::
숫자에 비해 Python은 여러 가지 방법으로 전달할 수 있는 문자열도 제공합니다.
작은따옴표 또는 큰따옴표::
>>> '스팸 달걀'
'스팸 달걀'
> ;>> '하지 않음'
"하지 않음"
>>> "하지 않음"
"하지 않음"
>>> '그렇습니다.'
'그렇습니다.'
>>> ,/" 그가 말했다."
'그렇다'고 말했다.'
>>> '그렇지 않다'고 말했다.
'"Isn/'t"라고 말했습니다.'
문자열 리터럴은 여러 가지 방법으로 여러 줄에 걸쳐 사용할 수 있습니다.
백슬래시를 마지막 문자로 사용하면 됩니다.
다음 줄이 줄의 논리적 연속임을 나타내는 줄::
문자열 리터럴을 줄로 나누는 방법에는 여러 가지가 있습니다. 백슬래시를 줄 끝의 연속 문자열로 사용할 수 있습니다. 이는 다음
줄이 논리적으로 이 줄의 연속임을 나타냅니다.
hello = "이것은 C./n/
에서와 마찬가지로 /n/
여러 줄의 텍스트를 포함하는 다소 긴 문자열입니다. 줄의 시작은 /
important입니다."
print hello
줄 바꿈은 여전히 ``/n``을 사용하여 문자열에 포함되어야 합니다.
후행 백슬래시 다음에 오는 새 줄은 삭제됩니다.
다음이 인쇄됩니다.
문자열에 ``/를 써야 한다는 점에 유의하세요. n`` - 후행 백슬래시가 무시됩니다. 이전
정기 모임은 다음과 같이 인쇄됩니다.
.. code-block:: text
이것은
여러 줄을 포함하는 다소 긴 문자열입니다.
줄 시작 부분의 공백이 중요하다는 점에 유의하세요.
또는 문자열을 일치하는 삼중따옴표 쌍으로 묶을 수도 있습니다. ` `" ""`` 또는
``'''``. 삼중따옴표를 사용할 때 줄 끝을 이스케이프할 필요는 없지만
문자열에 포함됩니다. . ::
또한 문자열은 삼중따옴표(``"""`` 또는 ``'''``)로 식별할 수 있습니다. 삼중 따옴표에서
에는 줄 속성 이스케이프가 필요하지 않으며 이미 문자열에 포함되어 있습니다::
print """
사용법: thingy [OPTIONS]
> | >-h -H 이 사용법 메시지 표시
-H 호스트 이름 연결할 호스트 이름
문자열 리터럴을 "원시" 문자열로 만들면 ``/n`` 시퀀스는 다음과 같습니다. 줄바꿈으로 변환되지 않았지만
줄 끝의 백슬래시와 소스의 줄바꿈 문자
는 모두 문자열에 데이터로 포함됩니다.
"원시" 문자열을 생성하는 경우 ``/ n`` 시퀀스는 이스케이프되지 않으며 줄 끝의 백슬래시
막대와 줄 바꿈 문자 소스 코드는 문자열 데이터의 일부가 되므로 다음 예는:
hello = r"이것은 /n/
여러 줄의 텍스트를 포함하는 다소 긴 문자열입니다. C로 할 것입니다."
print hello
인쇄:
인쇄:
.. code-block:: text
이는 C에서와 마찬가지로 /n/
여러 줄의 텍스트를 포함하는 다소 긴 문자열입니다.
인터프리터는 문자열 연산의 결과를 인터프리터와 동일한 방식으로 인쇄합니다.
입력용으로 입력됩니다. 따옴표 안에, 따옴표 및 기타 재미있는 문자를 포함합니다
정확한 값을 표시하기 위해 백슬래시로 이스케이프 처리됩니다. 문자열은
큰따옴표로 묶입니다. 문자열에 작은따옴표가 있고 큰따옴표가 없으면
작은따옴표로 묶입니다. (설명된 :keyword:`print` 문
나중에 따옴표나 이스케이프 없이 문자열을 작성하는 데 사용할 수 있습니다.)
인터프리터는 문자열 작업의 결과를 입력된 대로 정확하게 인쇄합니다. 백슬래시를 포함한 괄호 안에
바 이스케이프 정확한 값을 표시하는 흥미로운 문자. 문자열에 작은따옴표가 포함되어 있고 큰따옴표
가 포함되어 있지 않으면 큰따옴표로 식별됩니다. 그렇지 않으면 작은따옴표로 식별됩니다. (나중에 소개되는
:keyword:`print` 문은 식별 및 이스케이프 없이 문자열을 출력할 수 있습니다.)
문자열은 ``+` ` 연산자를 사용하여 연결(접착)할 수 있으며,
``*``::
문자열은 ``+`` 연산자로 연결(접착)할 수 있고 ``*를 사용하여 연결(접착)할 수 있습니다. `` 반복::
>>> 단어 = '도움말' + 'A'
>>> 단어
'HelpA'
>>> '<' + 단어*5 + '>'
'
서로 옆에 있는 두 문자열 리터럴은 자동으로 연결; 위의 첫 번째
줄은 ``word = 'Help' 'A'``로 작성될 수도 있습니다. 이는 임의의 문자열 표현식이 아닌 두 개의 리터럴에서만 작동합니다.
두 개의 인접한 문자열 텍스트는 자동으로 함께 연결됩니다. 이전 코드 줄은
``word ='Help' 'A'``로 작성할 수도 있으며 이는 두 개에만 사용됩니다. 문자열 리터럴은 문자열 표현식에 사용할 수 없습니다.
>>> 'str' 'ing' # <- 괜찮습니다
'string'
'str'. ' # <- 괜찮습니다
'string'
>>> 'str'.strip() 'ing' # <- 유효하지 않습니다
파일 "& lt; stdin & gt;", 1 행 >
문자열은 C에서처럼 첨자화(색인화)될 수 있습니다.첨자(색인) 0이 있습니다. 문자 유형은 별도로 없습니다.단순히 크기가 1인 문자열입니다. Icon과 마찬가지로 하위 문자열은*슬라이스 표기법*으로 지정할 수 있습니다. :: 문자열을 가로채는 것도 가능합니다. 검색됨). C 와 마찬가지로 문자열의 첫 번째 문자는 0 인덱싱됩니다. 에는 독립적인 문자 유형이 없으며 문자는 길이가 1인 문자열입니다. Icon과 마찬가지로 *슬라이싱 주석* 메서드를 사용하여 문자열을 가로챌 수 있습니다. 복사본은 두 개의 인덱스로 분할됩니다. :: >>> 단어[4] 'A' >>> 단어[0:2] 'He' >>> word[2:4] 'lp'슬라이스 인덱스에는 유용한 기본값이 있습니다. 생략된 첫 번째 인덱스는 기본값이 0입니다. , 생략된 두 번째 인덱스의 기본값은 슬라이스되는 문자열의 크기입니다. ::인덱스 슬라이스는 슬라이싱 시 첫 번째 인덱스를 무시할 경우 기본값은 0입니다. . 두 번째 인덱스는 무시되고 기본값은 문자열 길이입니다. (실제로 슬라이싱 단계 크기를 나타내는 세 번째 매개변수가 있습니다. 기본값은 1이고, 전체 슬라이싱 작업은 word[2:4:1]입니다. - 번역기) ::>>> word[:2] # 처음 두 문자 'He' >>> # 첫 번째 문자를 제외한 모든 문자 두 문자 'lpA'C 문자열과 달리 Python 문자열은 문자열에서 색인화된위치에 할당하면 오류가 발생합니다.:C 문자열과 달리 Python 문자열은 변경할 수 없습니다. 문자열 리터럴의 인덱스에 값을 할당하면 에서 오류가 발생합니다:: >>> word[0] = 'x' 역추적(가장 최근 호출 마지막): 파일 "
'SplatA'
다음은 유용한 슬라이스 연산 불변입니다: ``s[:i] + s[i:]``는 ``s``와 같습니다.
::
슬라이싱 작업에는 유용한 불변이 있습니다: ``s[:i] + s[i:]``는 ``s``와 같습니다. ::
>>> 단어[:2] + 단어[2:]
'HelpA'
>>> ] + word[3:]
'HelpA'
퇴화된 슬라이스 인덱스는 우아하게 처리됩니다. 너무 큰 인덱스는
문자열 크기로 대체되고, 상위 하한보다 작은 경계는
빈 문자열을 반환합니다. ::
퇴화 컷 검색은 매우 우아합니다. 상한이 너무 크면 텍스트 길이로 대체됩니다. 상한이 하한보다 작고 비어 있습니다
문자열입니다. ::
>>> 단어[1:100]
'elpA'
>>> 단어[10:]
''
>>> word[2:1]
''
인덱스는 오른쪽부터 계산하기 위해 음수일 수 있습니다. 예::
지수는 음수일 수 있으며, 이 경우 측정은 오른쪽 끝에서 시작됩니다. 예::
>>> word[-1] # 마지막 문자
'A'
>>> ] # 마지막 1개 문자
'p'
>>> word[-2:] # 마지막 2개 문자
'pA'
>>> word[:-2] # 마지막 두 문자를 제외한 모든 것
'Hel'
그러나 -0은 실제로 0 이므로 오른쪽부터 세지 않습니다!
::
그러나 -0 은 실제로 0이므로 오른쪽부터 세지 않는다는 점에 유의해야 합니다!
>>> word[-0] # (-0은 0이므로)
'H'
범위를 벗어난 음수 슬라이스 인덱스는 잘립니다. , 그러나
단일 요소(슬라이스 없음) 인덱스에는 이 방법을 사용하지 마세요::
음수 인덱스 슬라이스는 경계를 벗어나 잘립니다. 단일 요소에 사용하지 마세요. -요소(슬라이스 없음) ) 검색::
>>> 단어[-100:]
'HelpA'
>>> word[-10] # error
역추적(가장 최근 호출 마지막):
파일 "
IndexError: 문자열 인덱스 범위를 벗어남
슬라이스의 작동 방식을 기억하는 한 가지 방법은 인덱스가
*문자 사이를 가리키는 것으로 생각하는 것입니다. 첫 번째 문자의 왼쪽 가장자리는 0입니다.
그런 다음 *n* 문자로 구성된 문자열의 마지막 문자 오른쪽 가장자리에는
인덱스 *n*이 있습니다. 예::
슬라이싱 작동 방식을 쉽게 기억할 수 있는 방법이 있습니다. : 슬라이싱 시 인덱스는
* 두 문자 사이에 있습니다. 왼쪽 첫 번째 문자의 인덱스는 0이고 길이가 *n*인 문자열의 마지막 문자
문자의 오른쪽 바인딩 인덱스는 *n*입니다. 예::
+---+---+---+---+---+
| H | >
+---+---+---+---+---+ 0 1 2 3 4 5 -5 -4 -3 - 2 -1숫자의 첫 번째 행은 문자열에서 인덱스 0~5의 위치를 제공합니다.두 번째 행은 해당 음수 인덱스를 제공합니다. *i*의 조각. to *j*는 각각 *i*와 *j*로 표시된 가장자리 사이의 모든 문자로 구성됩니다. 텍스트의 첫 번째 숫자 줄은 문자열 인덱스 포인트 0...5 in . 두 번째 줄은 해당 음수 인덱스를 제공합니다. 슬라이스는 *i*에서 *j*까지 두 숫자 경계 사이의 모든 문자입니다. 음수가 아닌 인덱스의 경우 슬라이스 길이는두 인덱스가 모두 범위 내에 있는 경우 두 인덱스의 차이입니다. 예를 들어 ``단어[1:3]의 길이입니다. `` is2.음수가 아닌 인덱스의 경우 상한과 하한이 모두 범위 내에 있으면 슬라이스 길이가 인덱스와 다릅니다. 예를 들어 ``word[1:3]``은 2 입니다. 내장 함수 :func:`len`은 문자열의 길이를 반환합니다::내장 함수 :func:`len`은 문자열의 길이를 반환합니다:: >>> s = 'supercalifragilisticexpialidocious' >>> len 34.. 참조: : :ref:`typesseq` 문자열과 다음 섹션에서 설명하는 유니코드 문자열은 *시퀀스 유형*의 예이며 일반적인 작업을 지원합니다. 이러한 유형은 지원됩니다. :ref:`string-methods` 문자열과 유니코드 문자열 모두 기본에 대한 다양한 메서드를 지원합니다. 변환 및 검색.:ref:`new-string-formatting`
:meth:`str.format`을 사용한 문자열 형식 지정에 대한 정보는
여기
:ref에 설명되어 있습니다. :`string-formatting`
문자열 및 유니코드 문자열이
``%`` 연산자의 왼쪽 피연산자일 때 호출되는 이전 형식 지정 연산은 여기에서 더 자세히 설명됩니다.
.. _tut-unicodestrings:
유니코드 문자열 유니코드 文本
------------------------- ---
.. sectionauthor:: Marc-Andre Lemburg
Python 2.0부터 텍스트 데이터를 저장하기 위한 새로운 데이터 유형을 사용할 수 있습니다
프로그래머: 유니코드 객체.
유니코드 데이터(http://www.unicode.org/ 참조)를 저장하고 조작하는 데 사용할 수 있으며 기존
문자열 개체와 잘 통합되어 필요한 경우 자동 변환을 제공합니다. .
Python 2.0 起,程序员们有了一个새로운，용来存储文数据적类型：유니코드
对象。它可以用于存储화维护유니코드 数据（参见
http://www.unicode.org/ ) ，并且与现有的字符串对象有良好的集成，必要
时提供自动转换
유니코드에는 현대 및 고대 텍스트에 사용되는 모든
스크립트의 모든 문자에 대해 하나의 서수를 제공하는 이점. 이전에는 스크립트 문자에 사용할 수 있는 서수가 256
개뿐이었습니다. 텍스트는 일반적으로 서수를 스크립트 문자에 매핑하는 코드
페이지에 바인딩되었습니다. 이로 인해
특히 국제화와 관련하여 혼란이 발생합니다(일반적으로
``i18n`` --- ``'i'`` + 18자 + ``'n으로 작성됨). '``) 소프트웨어입니다. 유니코드는
모든 스크립트에 대해 하나의 코드 페이지를 정의하여 이러한 문제를 해결합니다.
유니코드 的先进之处在于为每一种现代或古代使用的文字系统中 Out现的每一个字符都
解决了为所有的文字系统设置一个独立代码页的难题。
Python에서 유니코드 문자열을 생성하는 것은 일반
문자열::
을 생성하는 것만큼 간단합니다. u'Hello World !'따옴표 앞의 작은 ``'u'``는 유니코드 문자열이 임을 나타냅니다. 생성된다고 합니다. 문자열에 특수 문자를 포함하려면Python *Unicode-Escape* 인코딩을 사용하면 됩니다. 다음예에서는 방법을 보여줍니다.:引号前的 ``'u'`` 表示这会创建一个 Unicode 字符串。如果想要在字符串中包含特殊字符，可以使用 Python 的 *Unicode-Escape* （Unicode 转义——译者）。请看下면적例子 :: >>> u'Hello/u0020World !' u'Hello World !'전문가를 위한 일반 문자열과 같은 원시 모드도 있습니다. 고르지 못한 Python이*Raw-Unicode-Escape* 인코딩을 사용하도록 하려면 시작 인용 앞에 'ur'를 붙여야 합니다. 작은'u' 앞에 백슬래시 개수가 홀수인 경우에만 위의 ``/uXXXX``변환이 적용됩니다. ::특이한, 和普字符串一样， Unicode 字符串也有原始模式。可以在引号前加“ur”，Python 会采用 *Raw-Unicode-communication* 编码（원리 유니코드 转义——译자）.如果有前缀为 '/u' 的数值，它也只会显示为 ``/uXXXX`` 。 :: > ;>> ur'Hello/u0020World !' u'Hello World !' >>> ur'Hello//u0020World !' u'Hello////u0020World !'raw 모드는 가능한 한 많은 백슬래시를 입력해야 할 때 가장 유용합니다정규 표현식에 필요합니다.如果你需要大weight输入反斜杠，原始模式不常有，这则表达式中几乎是必须적。이러한 표준 인코딩 외에도 Python은 알려진 인코딩을 기반으로 유니코드 문자열을 생성하는다른 방법 전체를 제공합니다.所为这些编码标准的一分，Python 提供了基于已知编码来创建 Unicode 字符串的整套方法。.. index:: 내장: unicode내장 함수 :func:`unicode `는 등록된 모든 유니코드코덱(COder 및 DECoder)에 대한 액세스를 제공합니다.
더 잘 알려진 인코딩 중 일부
변환할 수 있는 코덱은 *Latin-1*, *ASCII*, *UTF-8* 및 *UTF-16*입니다. 후자의 두 가지
는 각 유니코드 문자를 저장하는 가변 길이 인코딩입니다. 하나 이상의
바이트. 기본 인코딩은 일반적으로 ASCII로 설정되어
0~127 범위의 문자를 통과하고 오류가 있는 다른 문자는 거부됩니다.
유니코드 문자열이 인쇄되거나, 파일에 기록되거나
:func:`str`로 변환되면 다음 기본 인코딩을 사용하여 변환이 수행됩니다. ::
내장 함수: func: `unicode`는 등록된 모든 유니코드 인코딩(COder 및
DECoder)을 사용할 수 있습니다. 우리 모두 알고 있듯이 *Latin-1*, *ASCII*, *UTF-8* 및 *UTF-16*의
클래스 인코딩은 서로 변환될 수 있습니다(Latin-1은 작은 문자를 나타냄). ASCII 기반
과 일치하는 라틴어 기호 집합은 실제로 거대한 동양 언어 문자 집합(번역기)을 나타내는 데 사용할 수 없습니다. 마지막 두 개는 가변 길이 인코딩
코드로, 각 Uniocde 문자를 하나 이상의 바이트로 저장합니다. 기본 인코딩은 일반적으로 ASCII입니다. 이
인코딩은 0~127 범위의 인코딩을 허용합니다. 그렇지 않으면 오류가 보고됩니다. 유니코드 문자열
을 인쇄하거나 파일에 쓰거나 :func:`str`을 사용하여 변환할 때 변환 작업에서는 이를 기본 인코딩으로 사용합니다. ::
>>> u"abc"
u'abc'
>>> str(u"abc")
'abc'
>>> u"ü"
u'/xe4/xf6/xfc'
>>> (u"ü")
역추적(가장 최근 호출 마지막):
파일 "
UnicodeEncodeError: 'ascii' 코덱은 0-2 위치의 문자를 인코딩할 수 없습니다: 범위(128)에 없는 서수
특정 인코딩을 사용하여 유니코드 문자열을 8비트 문자열로 변환하려면
유니코드 개체는 다음을 제공합니다. 하나의 인수를 취하는 :func:`encode` 메소드,
인코딩 이름. ::
유니코드 문자열을 사용하려면 8 -특정 인코딩에 대한 비트 문자열 유니코드 객체는 인코딩 이름을 매개변수로 받아들이는
:func:`encode` 메서드를 제공합니다. 인코딩 이름은 소문자여야 합니다. ::
>>> u"ü".encode('utf-8')
'/xc3/xa4/xc3/xb6/xc3/xbc'
특정 인코딩의 데이터가 있고 해당
유니코드 문자열을 생성하려는 경우
인코딩 이름과 함께 :func:`unicode` 함수를 사용할 수 있습니다. ::
다른 인코딩의 데이터가 있고 그로부터 유니코드 문자열을 생성하려는 경우, 인코딩 이름을 두 번째 매개변수. ::
>>> 유니코드('/xc3/xa4/xc3/xb6/xc3/xbc', 'utf-8')
u'/xe4/xf6/ xfc'
.. _tut-lists:
목록 목록
----------
Python은 *의 수를 알고 있습니다. 다른
값을 함께 그룹화하는 데 사용되는 복합* 데이터 유형입니다. 가장 다재다능한 것은 *list*로,
쉼표로 구분된 값(항목) 목록으로 작성할 수 있습니다. 목록 항목은 모두
동일한 유형을 가질 필요는 없습니다. ::
Python에는 다른 값을 괄호로 묶기 위한 여러 가지 *복합* 데이터 유형이 있습니다. 가장 일반적인 것은 *list*(열 목록
)이며 대괄호 사이에 쉼표로 구분된 값의 목록으로 작성할 수 있습니다. 목록의 요소는 동일한 유형일 필요는 없습니다. ::
>>> a = ['스팸', '계란', 100, 1234]
>>> spam', 'eggs', 100, 1234]
문자열 인덱스와 마찬가지로 목록 인덱스는 0에서 시작하며 목록은 슬라이싱,
연결 등이 가능합니다::
문자열 인덱싱과 마찬가지로 목록은 0부터 검색됩니다. 목록을 분할하고 연결할 수 있습니다::
>>> a[0]
'스팸'
>>> ]
1234
>>>a[-2]
100
>>> ]
['계란', 100]
>>> a[:2] + ['베이컨', 2*2]
['스팸 ', '계란', '베이컨', 4]
>>> 3*a[:3] + ['부!']
['스팸', ' egg' , 100, 'spam', 'eggs', 100, 'spam', 'eggs', 100, 'Boo!']
모든 슬라이스 작업은 요청된 요소가 포함된 새 목록을 반환합니다. 🎜>
다음 슬라이스가 목록의 얕은 복사본을 반환한다는 의미 *a*::모든 슬라이싱 작업은 계산된 요소가 포함된 새 목록을 반환합니다. 이는 다음 슬라이싱 작업 이 목록 *a* ::의 얕은 복사본을 반환함을 의미합니다.
>>> a[:]
['spam', 'eggs', 100, 1234]
*불변*인 문자열과 달리 가능합니다. 목록의 개별
요소 변경::
*불변* 문자열과 달리 목록은 요소 수정을 허용합니다::
>>>
['스팸', '계란', 100, 1234] >>> a[2] = a[2] + 23 >> ; a ['spam', 'eggs', 123, 1234]슬라이스에 할당하는 것도 가능하며, 이는목록의 크기도 변경할 수 있습니다. 또는 완전히 지울 수도 있습니다::조각에 값을 할당할 수도 있습니다. 이 작업은 목록의 크기를 변경하거나 지울 수 있습니다:: >>> 일부 항목 : ... a[0:2] = [1, 12] >>> a [1, 12, 123, 1234] >>> # 일부 제거: ... a[0:2] = [] >>> 🎜>[123, 1234]
>>> # 일부 삽입:
... a[1:1] = ['bletch', 'xyzzy' ]
>>> a
[123, 'bletch', 'xyzzy', 1234]
>>> of) 자체
>>> a[:0] = a
>>> a
[123, 'bletch' , ' xyzzy', 1234, 123, 'bletch', 'xyzzy', 1234]
>>> # 목록 지우기: 모든 항목을 빈 목록으로 대체
> ;> ;> a[:] = []
>>> a
[]
내장 함수 :func:`len` 목록에도 적용됩니다::
내장 함수: func:`len`은 목록에도 사용할 수 있습니다::
>>> b', 'c ', 'd']
>>> len(a)
4
목록을 중첩할 수 있습니다(다음을 포함하는 목록 생성). 다른 목록),
예::
에서는 중첩된 목록을 허용합니다(다른 목록을 포함하는 목록 생성). 예::
>>> [2, 3 ]
>>> p = [1, q, 4]
>>> len(p)
3
>>> p[1]
[2, 3]
>>> p[1][0]
2
>>> p[1].append('xtra') # 섹션 5.1 참조
>>> p
[1 , [2, 3, 'xtra'], 4]
>>> q
[2, 3, 'xtra']
마지막 예인 ``p[1]``과 ``q``는 실제로 동일한
객체를 참조합니다! 나중에 *객체 의미*에 대해 다시 다루겠습니다.
참고 마지막 예에서 ``p[1]``과 ``q``는 실제로 동일한 객체를 가리킵니다!
뒤에 *객체 의미론*에 대한 논의를 계속하겠습니다.
.. _tut-firststeps:
프로그래밍을 향한 첫 단계 프로그래밍의 첫 번째 단계
================= ==========================
물론 2개와 2개를 더하는 것보다 더 복잡한 작업에는 Python을 사용할 수 있습니다
예를 들어, *Fibonacci*
시리즈의 초기 하위 시퀀스를 다음과 같이 작성할 수 있습니다.:
물론 Python을 사용하여 비율을 완성할 수 있습니다. 2개 더하기 2개 더 복잡한 작업. 예를 들어, 다음과 같이 *Fibonacci* 부분 수열을 생성하는
프로그램을 작성할 수 있습니다::
>>> # 피보나치 수열:
... # 두 요소의 합은 다음을 정의합니다
... a, b = 0, 1
>>> b < . 인쇄 b
... a, b = b, a+b
...
1
1
2
3
5
8
이 예에서는 몇 가지 새로운 기능을 소개합니다.
이 예에서는 몇 가지 새로운 기능을 소개합니다.
* 첫 번째 줄에는 *다중 할당*이 포함되어 있습니다. 변수 ``a`` 및 ``b``
는 동시에 새 값 0과 1을 가져옵니다. 마지막에 이 줄은 다시 사용됩니다.
오른쪽 표현식이 모두 평가됨을 보여줍니다
오른쪽 표현식이 발생하기 전에
은 왼쪽에서 오른쪽으로 평가됩니다.
첫 번째 줄에는 *다중 할당*이 포함됩니다. 변수 ``a`` 및 ``b``는 모두 새 값 0을 얻습니다
그리고 1 . 마지막 줄이 다시 사용됩니다. 이 데모에서는 변수 할당 전 오른쪽에서
계산이 먼저 완료됩니다. 오른쪽의 표현식은 왼쪽에서 오른쪽으로 평가됩니다.
* :keyword:`while` 루프는 조건(여기서: ``b < 10``)
이 유지되는 동안 실행됩니다. Python에서는 C와 마찬가지로 모든 조건이 충족됩니다. 0이 아닌 정수 값은 true입니다. 0은
false입니다. 조건은 문자열 또는 목록 값일 수도 있으며 실제로는 모든 시퀀스입니다.
길이가 0이 아닌 것은 모두 true입니다. 빈 시퀀스는 거짓입니다. 예제에 사용된 테스트
는 간단한 비교입니다. 표준 비교 연산자
는 C와 동일하게 작성됩니다: ``<``(보다 작음) , ``>``(보다 큼), ``==``
(같음), ``<=``(보다 작거나 같음), ``>=` `(크거나 같음)
및 ``!=``(같지 않음).
조건(여기에서는 ``b < 10`` )이 true인 경우 , :keyword:`while` 루프 실행.
Python에서는 C와 유사하게 0이 아닌 모든 정수가 참입니다. 조건은 문자열이나 목록일 수도 있습니다. 실제로 임의의 시퀀스일 수 있습니다. 길이가 0이 아닌 모든 항목은 true이고, 빈 시퀀스
는 false입니다. 예제의 테스트는 간단한 비교입니다. 표준 비교 연산자는 C와 동일합니다:
``<``(보다 작음), ``>``(보다 큼), ``==``(같음), ``<=` `(
이하), ``>=``(이상) 및 ``!=``(같지 않음).
* 루프의 *본문*은 *들여쓰기*되어 있습니다. 들여쓰기는 Python의
명령문 그룹화 방식입니다. Python은 (아직!) 지능적인 입력 줄 편집 기능을 제공하지 않습니다
기능을 사용하므로 들여쓰기한 각 줄에 탭이나 공백을 입력해야 합니다.
연습에서는 텍스트 편집기를 사용하여 Python에 대한 더 복잡한 입력을 준비합니다.
대부분의 텍스트 편집기에는 자동 들여쓰기 기능이 있습니다.
대화식으로 입력된 경우
완료를 나타내기 위해 빈 줄이 와야 합니다(파서는 사용자가 입력한 시점을 추측할 수 없기 때문입니다). 마지막 줄).
기본 블록 내의 각 줄은 같은 양만큼 들여쓰기되어야 합니다.
루프의 본문은 *들여쓰기*입니다. 들여쓰기는 Python is Python 조직 설명 방법입니다. .
Python은 (아직) 통합 줄 편집 기능을 제공하지 않으므로 들여쓰기한 줄마다 TAB
또는 공백을 입력해야 합니다. 실제로 복잡한 Python 프로그램을 입력하려면 텍스트 편집기를 찾는 것이 좋습니다. 대부분의 텍스트
편집기는 자동 들여쓰기 기능을 제공합니다. 복합문을 대화식으로 입력할 때에는
의 끝을 표시하기 위해 마지막에 빈 줄을 입력해야 합니다(통역사는 입력한 줄이 마지막 줄인지 추측할 수 없기 때문입니다).
동일한 명령문 블록 내의 명령문 블록은 동일한 양의 공백으로 들여쓰기되어야 합니다. * :keyword:`print` 문은 주어진 표현식의 값을 씁니다 이는 단지 작성하고 싶은 표현식을 작성하는 것과 다릅니다(저희가 그랬듯이 앞부분의 계산기 예시) 여러 표현식과 문자열을 처리하는 방식입니다. 문자열은 따옴표 없이 인쇄되며 항목 사이에 공백이 삽입됩니다. 다음과 같이 형식을 적절하게 지정하세요:: 키워드:키워드:`print` 문은 주어진 표현식의 값을 출력합니다. 여러 표현식과 문자열이 원하는 문자열로 출력되도록 제어합니다(이전 계산기 예제에서 했던 것처럼). 문자열을 인쇄할 때 따옴표로 묶을 필요가 없으며 각 두 하위 항목 사이에 공백이 삽입되므로 다음과 같이 형식을 매우 아름답게 만들 수 있습니다. : >>> i = 256*256 >>> print 'i의 값은', i i의 값 is 65536 후행 쉼표는 출력 후 개행을 방지합니다:: 끝에 쉼표를 사용하여 개행 출력을 금지합니다:: >>> , b = 0, 1 |...
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
참고 인터프리터는
마지막 줄이 완료되지 않은 경우 다음 프롬프트를 인쇄하기 전에 개행을 삽입합니다.
여기서 마지막 줄이 완전히 출력되지 않으면 인터프리터
다음 프롬프트를 인쇄하기 전에 개행 문자를 삽입합니다.
위 내용은 Python 2.7의 기본 튜토리얼을 요약한 것입니다. 더 많은 관련 내용은 PHP 중국어 홈페이지(www.php.cn)를 참고해주세요!
![[웹 프런트엔드] Node.js 빠른 시작](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
