elex/python-examples
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

2025-01-09T14:30:26

Browse Source
This commit is contained in:
Elex
2025-01-09 14:30:26 +09:00
parent 90d9816ea2
commit a6be4b4c30
18 changed files with 941 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
doc/00_intro.md Normal file
View File

@@ -0,0 +1 @@
https://www.tutorialspoint.com/python/python_hello_world.htm

55
doc/01_install.md Normal file
View File

@@ -0,0 +1,55 @@
# Python
```bash
sudo apt install python2 # python2를 설치합니다.
sudo apt install python3 # python3를 설치합니다.
sudo apt install python-is-python2 # /usr/bin/python에 대한 링크를 Python 2.x로 지정합니다.
sudo apt install python-is-python3 # /usr/bin/python에 대한 링크를 Python 3.x로 지정합니다.
```
```bash
python2 --version
python3 --version
```
## PIP
Package Installer for Python
```bash
sudo apt install python3-pip
```
```bash
pip install xxx
pip search xxx
pip list
pip show xxx
pip uninstall xxx
pip freeze > requirements.txt # 의존성 목록을 파일로 저장합니다.
pip install -r requirements.txt # 의존성 목록을 설치합니다.
```
## VENV
가상 실행환경
```bash
sudo apt install python3-venv
```
프로젝트 디렉토리로 이동해서 가상 환경을 생성합니다. 일반적으로 `.venv` 디렉토리를 사용합니다.
```bash
cd project-dir
python -m venv .venv
```
가상 환경을 시작합니다. 프롬프트 앞에 가상환경 이름이 표시됩니다.
```bash
source .venv/bin/activate #또는
. .venv/bin/activate
deactivate # 가상 환경을 종료합니다.
```

25
doc/02_helloworld.md Normal file
View File

@@ -0,0 +1,25 @@
# Hello, World!
```python
#!/usr/bin/env python3
s = 'Hello, World!'
print(s) # print()는 화면에 출력하는 함수입니다.
```
- 스크립트 파일의 확장자는 *.py*를 사용하며, 파일 인코딩은 UTF-8을 사용하는 것이 원칙입니다.
- C 계열의 프로그래밍 언어들과는 달리 줄 끝에 세미콜론(;)을 붙이지 않습니다. 다만, 여러 구문들을 한 줄에 붙여서 쓰려는 경우에는 세미콜론을 사용해서 구분해줍니다.
- C 계열의 프로그래밍 언어들과는 달리 중괄호(`{`)는 사용하지 않으며, 대신 들여쓰기를 사용합니다. 같은 블록은 들여쓴 칸 수가 동일해야 하며, 공백문자와 탭을 섞어서 사용하면 안됩니다.
- 주석은 `#`로 시작합니다.
## 메인 함수를 사용한 Hello, World!
```python
#!/usr/bin/env python3
def hello():
print("Hello, World!")
if __name__ == "__main__":
hello()
```

191
doc/03_data_types.md Normal file
View File

@@ -0,0 +1,191 @@
# 자료형
## 변수
### 변수의 선언 및 할당
```python
a = 100
b = 'Hello'
c = None # 할당없이 선언만 하려면 None을 사용합니다. None은 다른 프로그래밍 언어의 null에 해당합니다.
x, y, z = 100, 200, 300 # x=100, y=200, z=300
i = j = k = 10 # i=10, j=10, k=10
```
### 객체의 자료형 확인
```python
type(a) # type() 함수는 자료형을 반환합니다.
```
### 형변환
```python
int(3.3) # 3
int('100') # 100
float(3) # 3.0
```
### 변수 삭제
```python
x = 100
del x
```
### 스왑
```python
x, y = 10, 20
x, y = y, z
```
## 자료형
### 숫자
- int
정수형
- float
부동소수형
- complex
복소수형. 허수부 뒤에 j를 붙입니다(`1.2+1.3j`).
```python
a = 100
b = 3.14
c = 0o34
d = 0xff
e = 1.28e-10
```
#### 숫자의 연산
```python
print(1 + 1) # 2
print(1 - 2) # -1
print(3 * 7) # 21
print(4 / 2) # 2.0
print(4 // 2) # 2
print(4 % 3) # 1
print(2 ** 4) # 16
```
- Python3 에서는 다른 프로그래밍 언어와는 달리, 정수 끼리의 나눗셈 결과가 실수(float)로 반환됩니다. 나눗셈의 결과를 정수로 받으려면 버림 나눗셈 연산자(`//`)를 사용해야 합니다.
나눗셈의 몫과 나머지를 함께 구하려면 `divmod()` 함수를 사용하면 됩니다.
- `**`는 거듭제곱 연산자입니다.
### 부울
- bool
`True` 또는 `False`값을 가질 수 있습니다. True와 False는 대문자로 시작합니다.
#### 형변환
`0`과 `0.0` 이외의 모든 숫자는 `True`입니다. 또 빈 문자열 이외의 모든 문자열은 `True`입니다.
```python
bool(0.0) # False
bool('False') # True
```
#### 비교 연산
```python
1 == 1.0 # True
1 is 1.0 # False
1 is not 1.0 # True
```
- 객체를 비교할 때에는 `is`와 `is not` 연산자를 사용합니다.
#### 논리 연산
- `and`, `or`, `not` 연산자를 사용합니다.
### 문자
- str
문자열은 홑따옴표 또는 쌍따옴표로 묶어서 표현합니다. 삼중 따옴표(홑따옴표 또는 쌍따옴표)로 여러 줄 문자열을 표현할 수 있습니다.
```python
a = 'Hello'
b = "Hello"
c = '''Hello,
여러 줄 문자열.'''
d = "It's me."
```
### 집합
- list
리스트는 각 항목을 콤마로 구분하고, 대괄호(`[`, `]`)로 묶어서 표현합니다.
```python
a = [1, 2, 3]
b = [10, 'Hello', True] # 여러 자료형을 혼용해도 됩니다.
c = [] # 빈 리스트 자료형을 반듭니다. 또는,
d = list() # list() 함수를 사용해서 빈 리스트 자료형을 만듭니다.
e = list('Hello') # 문자열을 리스트로 변환하면 ['H', 'e', 'l', 'l', 'o']
```
- tuple
튜플은 괄호(`(`, `)`)로 묶어서 표현합니다. 튜플은 리스트와 비슷하지만 항목을 추가, 변경, 삭제할 수 없습니다.
```python
a = (1, 2, 3)
# 또는, 괄호를 생략해도 됩니다.
b = 1, 2, 3
```
```python
a = (10) # 10 => 튜플의 아이템이 하나인 경우, 튜플이 아니라 그냥 숫자값이 됩니다.
# 아이템이 하나인 튜플을 만들려면 끝에 콤마를 붙여야 합니다.
b = (10,) # (10,)
c = 10, # 또는, 튜플은 괄호를 생략할 수 있으므로
```
- dict
딕셔너리는 키/값 형식의 자료형입니다. 중괄호(`{`, `}`)를 사용해서 표현합니다.
```python
a = {'name': 'Charlie', 'age': 14}
b = dict(name='Steve', age=37) # dict()를 사용할 때에는 키를 따옴표로 묶지 않습니다.
c = {} # 빈 딕셔너리를 만듭니다. 또는,
d = dict()
e = dict(zip(['name', 'age'], ['Jane', 24])) # zip()을 사용해서 키와 값을 묶을 수도 있습니다.
f = dict([('name', 'Olaf'), ('age', 7)]) # 리스트 안에 튜플을 사용해서 생성할 수도 있습니다.
g = dict({'name': 'Charlie', 'age': 14}) # dict() 안에 중괄호를 한 번 더 사용해도 됩니다.
```
- set
세트의 아이템은 중복될 수 없으며, 순서도 없습니다. 중괄호(`{`, `}`)를 사용해서 표현합니다.
```python
a = {'apple', 'orange', 'banana'}
b = set('apple', 'orange', 'banana')
# 불변 세트를 만들려면 frozenset()를 사용합니다.
c = frozenset('apple', 'orange', 'banana') # Immutable 세트는 값을 수정할 수 없습니다.
```

518
doc/04_sequence_types.md Normal file
View File

@@ -0,0 +1,518 @@
# ㅁㅁㅁ
## 시퀀스 자료형
리스트, 튜플, 레인지, 그리고 문자열은 모두 어떤 값들의 연속체라는 공통점이 있습니다. 이들을 시퀀스 자료형이라고 부릅니다. 그 외에 `bytes`, `bytearray`라는 자료형도 있습니다.
### 레인지 객체 (range)
`range()`는 일련의 숫자를 만드는데 사용되며, Python3에서는 `range` 타입이 반환됩니다.
- range(끝값)
시작 값이 주어지지 않으면 0부터 시작하며, 끝값은 포함되지 않습니다.
- range(시작값, 끝값)
- range(시작값, 끝값, 증분)
```python
a = list(range(10)) # [0,1,2,3,4,5,6,7,8,9]
b = list(range(5, 10)) # [5,6,7,8,9]
c = list(range(1, 10, 2)) # [1,3,5,7,9]
d = list(range(5, -5, -2)) # [5,3,1,-1,-3]
```
### 특정 아이템을 포함하고 있는지 확인
```python
a = [1, 3, 5, 7, 9]
b = 2 in a # False
c = 2 not in a # True
```
### 연결
시퀀스 자료형은 `+` 연산자를 사용해서 이어 붙일 수 있습니다. 단, `range`는 안됩니다.
```python
a = [1, 3, 5, 7, 9] + [2, 4, 6, 8, 10] # [1,3,5,7,9,2,4,6,8,10]
```
```python
a = 'Hello, ' str(100) # 문자열에 숫자를 연결할 때에는 숫자를 문자열로 변환해 주어야 합니다.
```
### 반복
`*` 연산자는 반복에 사용됩니다. 단, `range`는 안됩니다.
```python
a = [1, 2, 3] * 3 # [1,2,3,1,2,3,1,2,3]
```
### 갯수
```python
a = len([1, 2, 3]) # 3
```
```python
hello = '안녕하시오!'
a = len(hello) # 문자열의 길이는 6입니다. Python2에서는 문자열의 바이트 길이를 반환합니다.
b = len(hello.encode('utf-8')) # 문자열의 바이트 길이는 16
```
### 인덱스를 통한 접근
다른 프로그래밍 언어들과 마찬가지로 인덱스는 대괄호를 사용해서 표현하며, 인덱스는 0부터 시작합니다.
```python
a = [1, 2, 3]
print(a[0]) # 1
# 내부적으로는 객체의 __getitem__() 메서드를 호출합니다. 따라서,
print(a.__getitem__(0))
# 음수 인덱스를 사용하면 맨 마지막 항목부터 셉니다.
print(a[-1]) # 3
```
### 인덱스를 통한 항목 값의 변경
튜플, 문자열, 레인지의 경우에는 값을 변경할 수 없는 타입이므로 오류가 발생합니다.
```python
a = [1, 2, 3]
a[1] = 4 # [1,4,3]
a[5] = 5 # Error. 리스트의 범위를 벗어났으므로 오류입니다.
```
### 항목의 삭제
`del`을 사용해서 항목을 삭제합니다. 튜플, 문자열, 레인지의 경우에는 값을 변경할 수 없는 타입이므로 오류가 발생합니다.
```python
a = [1, 2, 3]
del a[1] # [1,3]
```
### 부분 시퀀스
시작 인덱스와 끝 인덱스를 사용해서 어떤 시퀀스의 부분을 가져올 수 있습니다. 끝 인덱스는 포함되지 않습니다.
```python
a = [1, 2, 3, 4, 5]
b = a[0:2] # [1,2]
c = a[0:5:2] # [1,3,5] => 시작과 끝 인덱스에 덧붙여 증분도 사용할 수 있습니다.
d = a[:5] # 시작 인덱스를 생략하면 0번 인덱스부터 가져옵니다.
e = a[2:] # 끝 인덱스가 생략되면 마지막 요소까지 가져옵니다.
```
### 반전
```python
reversed(range(5))
```
### 슬라이스 객체 (slice)
`slice()`는 `range()`와 사용법이 같으며, `slice` 타입이 반환됩니다.
- slice(끝값)
시작 값이 주어지지 않으면 0부터 시작하며, 끝값은 포함되지 않습니다.
- slice(시작값, 끝값)
- slice(시작값, 끝값, 증분)
```python
a = [1, 2, 3, 4, 5]
s = slice(0, 2)
a[s] # [1,2] 대괄호 안에 슬라이스 객체를 넣어서 사용합니다.
```
### 슬라이스 객체를 이용한 할당
```python
a = [1, 2, 3, 4, 5]
a[0:2] = ['a', 'b'] # ['a', 'b', 3, 4, 5]
```
만약 슬라이스의 범위와 할당할 값의 길이가 서로 다르다면
```python
a = [1, 2, 3, 4, 5]
a[0:2] = ['a'] # ['a', 3, 4, 5] => a[0]은 할당되고, a[1]은 사라집니다.
a = [1, 2, 3, 4, 5]
a[0:2] = ['a', 'b', 'c'] # ['a', 'b', 'c', 3, 4, 5]
```
## 리스트의 메서드
- append()
리스트의 맨 뒤에 아이템을 하나 추가합니다.
- extend()
리스트를 연결해서 확장합니다.
- insert()
특정 인덱스에 아이템을 추가합니다.
```python
a = [1, 2, 3]
a.append(4) # [1,2,3,4]
a.extend([5, 6]) # [1,2,3,4,5,6]
a.insert(2, 'a') # [1,2,'a',3,4,5,6]
```
- pop()
마지막 아이템 또는 특정 아이템을 반환하며 리스트에서 제거합니다.
- remove()
특정 값을 삭제합니다. `pop()`이 인덱스를 사용하는 반면 `remove()`는 리스트에서 특정 값을 제거합니다. 만일, 리스트에 같은 값이 여러 개인 경우에는 처음 찾은 값이 제거됩니다.
```python
a = [1, 2, 3, 4, 5]
b = a.pop() # b=5 a=[1,2,3,4]
b= a.pop(2) # b=3 a=[1,2,4]
a.remove(4) # a=[1,2]
```
- index()
특정 값의 인덱스를 반환합니다.
- count()
특정 값의 갯수를 반환합니다.
- reverse()
아이템의 순서를 반대로 뒤집습니다.
- sort(reverse=False)
아이템을 정렬합니다.
- sorted()
`sort()`와 비슷하지만, 리스트를 수정하지 않고 새로운 리스트를 반환합니다.
- clear()
리스트의 모든 아이템을 삭제합니다.
- copy()
리스트를 복제합니다.
## 리스트 컴프리핸션
리스트 구문 안에 반복문이나 조건문을 사용할 수 있습니다.
이 방식으로 튜플을 만들 때에는 `tuple()`을 사용해야 합니다. 괄호를 사용하면 튜플이 아니라 제너레이터가 만들어집니다.
```python
a = [i for i in range(5)] # [0,1,2,3,4]
b = [i * 2 for i in range(5)] # [0,2,4,6,8]
# 반복문 뒤에 조건문을 이어 붙일 수 있습니다.
c = [i for i in range(5) if i % 2 == 0] # [0,2,4]
# 반복문을 여러 개 사용할 수도 있습니다. 이 때 처리 순서는 뒤에서부터 앞으로 처리됩니다.
d = [i * J for j in range(2,10) for i in range(1,10)]
```
## 맵
- map(함수, 리스트)
리스트 또는 튜플 등 반복 가능한 객체의 아이템을 지정된 함수로 처리한 다음 새로운 리스트 또는 튜플을 생성할 떄 사용됩니다.
```python
a = ['1', '2', '3']
b = list(map(int, a))
```
## 다차원 리스트
리스트 안에 리스트를 넣으면 다차원 리스트가 됩니다. 튜플도 마찬가지입니다.
```python
a = [[1,2], [3,4], [5,6]]
```
다차원 리스트를 복제하려면 `deepcopy()`를 사용해야 합니다.
```python
import copy
b = copy.deepcopy(a)
```
## 문자열 메서드
- replace(바꿀문자열, 새문자열)
- translate()
문자열 내의 문자를 치환합니다.
```python
table = str.maketrans('aeiou', 'AEIOU')
a = 'i like an apple'.translate(table) # I lIkE An ApplE
```
- split()
공백을 기준으로 문자열을 분리합니다. 구분 문자열을 지정할 수도 있습니다.
```python
a = 'apple,orange,mango,banana'.split(',')
```
- join(리스트)
리스트를 결합하여 문자열을 만듭니다.
```python
'-'.join(['apple','orange','mango','banana'])
```
- upper(), lower()
대소문자 변환
- strip(), lstrip(), rstrip()
문자열의 왼쪽, 오른쪽, 또는 양쪽의 공백을 제거합니다. 매개변수에 제거할 문자목록 지정할 수도 있습니다.
```python
'...hello'.strip('.')
```
- ljust(길이), rjust(길이), center(길이)
정렬
```python
'apple'.ljust(10) # 'apple '
```
- zfill(길이)
지정된 길이 맞춰서 0으로 채웁니다.
- find(찾을문자열), rfind()
주어진 문자열이 처음 나타나는 인덱스를 반환하며, 찾는 문자열이 없으면 -1을 반환합니다.
- index(), rindex()
`find()`와 마찬가지로 찾는 문자열의 인덱스를 반환하지만, 문자열을 찾지 목한 떄에는 오류가 발생됩니다.
- count(문자열)
주어진 문자열의 갯수를 셉니다.
## 형식화 문자열
```python
name = 'Charlie'
a = 'Hello, %s.' % name
age = 14
b = "I'm %d years old." % age
value = 3.3
c = 'The price is %f dollars.' % value
c = 'The price is %.2f dollars.' % value # 소수점 이하 자릿수를 지정
d = '%s is %d years old.' % (name, age) # 여러 개일 떄에는 괄호로 묶습니다.
```
문자열의 `format()` 메서드를 사용하면 더 쉽습니다.
```python
'Hello, {0}.'.format('Charlie')
'{1} is {0} years old.'.format(14, 'Charlie')
'{} is {} years old.'.format('Charlie', 14) # 인덱스가 생략되면 순서대로 삽입됩니다.
'{name} is {age} years old.'.format(name='Charlie', age=14) # 숫자 인덱스 대신 이름을 지정할 수도 있습니다.
# Python 3.6이상에서는 변수명을 그대로 사용할 수 있으며, 문자열 앞에 포맷 지시자('f')를 붙여주면 됩니다.
name = 'Charlie'
age = 14
s = f'{name} is {age} years old.'
```
## 딕셔너리
딕셔너리의 키에 대괄호를 사용해서 아이템에 접근하거나 변경할 수 있습니다.
```python
a = {'name': 'Charlie', 'age': 14}
a['name'] # 'Charlie'
a.get('name') # get() 메서드를 사용할 수도 있습니다.
```
`in` 연산자를 사용해서 딕셔너리에 해당 키가 존재하는지 확인할 수 있습니다.
```python
a = {'name': 'Charlie', 'age': 14}
b = 'name' in a # True
```
키의 갯수를 알고 싶으면 `len()`을 사용합니다.
```python
len({'name': 'Charlie', 'age': 14}) # 2
```
키를 제거하려면 `del`을 사용합니다.
```python
del a['name']
```
딕셔너리를 복제하려면 `deepcopy()`를 사용해야 합니다.
```python
import copy
y = deepcopy(a)
```
## 딕셔너리의 메서드
- setdefault(키, 값)
키에 대한 기본값을 지정합니다. `update()`와 달리 해당 키가 이미 정의되어 있다면 값이 변경되지 않습니다.
- update(키, 값)
키에 대한 값을 변경합니다. 키가 정의되어 있지 않다면 새로운 키가 등록됩니다.
- pop(키, 기본값)
키에 대한 값을 반환하며, 딕셔너리에서는 제거됩니다. 매개변수에 기본값을 주면 해당 키가 없을 때에 그 값을 반환합니다.
- popitem()
마지막 키/값 쌍을 튜플로 반환하고 삭제합니다. Python 3.5 이하에서는 임의의 키/값 쌍을 반환합니다.
- clear()
모든 키/값 쌍을 삭제합니다.
- get(키)
- items()
- keys()
- values()
```python
for key, value in {'a':100, 'b':200, 'c':300}.items():
print(key, value)
```
## 멀티 레벨 딕셔너리
딕셔너리 안에 딕셔너리를 넣으면 계층형 데이터 구조를 만들 수 있습니다.
```python
a = {
'charlie': {'name': 'Charlie', 'age': 14},
'steve': {'name': 'Steve', 'age': 37},
'jane': {'name': 'Jane', 'age': 22}
}
```
## 세트
리스트와 달리 순서가 없으므로 대괄호 안에 인덱스를 사용해서 요소에 접근할 수 없습니다.
세트 안에 중첩된 세트를 넣을 수도 없습니다.
세트 안에 어떤 값이 있는지 확인하려면 `in`을 사용합니다.
```python
a = {'apple', 'orange', 'banana'}
'orange' in a # True
```
논리 연산자 또는 set의 메서드를 사용해서 집합 연산을 할 수 있습니다.
```python
a = {1, 2, 3}
b = {3, 4, 5, 6}
a | b # 합집합 {1,2,3,4,5,6}
set.union(a, b)
a & b # 교집합 {3}
set.intersection(a, b)
a - b # 차집합 {1,2}
set.difference(a, b)
a ^ b # 대칭 차집합
set.symmetric_difference(a, b)
```
- set,union()
- set,intersection()
- set,difference()
- set,symmetric_difference()
- update(세트)
`|=`
- intersection_update(세트)
`&=`
- difference_update(세트)
`-=`
- symmetric_update(세트)
`^=`
비교 연산자를 사용해서 포함 관계를 확인할 수 있습니다.
```python
{1,2,3} <= {1,2,3,4,5} # 다른 집합의 부분집합인지 여부
{1,2,3}.issubset({1,2,3,4,5})
{1,2,3} < {1,2,3,4,5} # 다른 집합의 진부분집합인지 여부
{1,2,3} >= {1,2,3,4,5} # 다른 집합의 상위집합인지 여부
{1,2,3}.issuperset({1,2,3,4,5})
{1,2,3} > {1,2,3,4,5} # 다른 집합의 진상위집합인지 여부
{1,2,3} == {1,2,3,4,5} # 서로 같은지 여부
{1,2,3} != {1,2,3,4,5}
{1,2,3}.isdisjoint({1,2,3,4,5}) # 서로 겹치는 요소가 없으면 True가 반환됩니다.
```

40
doc/05_std_io.md Normal file
View File

@@ -0,0 +1,40 @@
# 표준 입출력
## input()
표준 입력으로부터 한 줄을 입력 받습니다.
```python
x = input() # 표준 입력으로부터 한 줄을 입력 받습니다.
y = input('문자열을 입력하시오: ')
a, b = input().split() # 공백을 기준으로 분리합니다.
a, b = input().split(',') # 콤마를 기준으로 분리합니다.
```
입력받은 값을 숫자 형태로 바꾸려면, `int()` 또는 `float()`을 사용해야 합니다.
```python
a = int(input('A? '))
b = int(input('B? '))
print(a + a)
```
또는, `map()`함수를 사용할 수도 있습니다.
```python
a, b = map(int, input().split())
```
## print()
표준 출력으로 한 줄을 출력합니다.
```python
print('Hello')
print(1, 2, 3) # 나열된 값이 공백으로 구분되어 출력됩니다.
print(1, 2, 3, sep=',') # sep으로 구분자를 지정할 수 있습니다. 기본값은 ' '입니다.
print(1, 2, 3, end='') # end로 줄 끝 문자를 지정할 수 있습니다. 기본값은 '\n'입니다.
```

75
doc/06_flow_controls.md Normal file
View File

@@ -0,0 +1,75 @@
# 흐름 제어
## 조건문
`if`문의 조건식 뒤에 콜론(`:`)을 붙이고 `if` 블록은 들여쓰기를 합니다.
```python
if 조건식:
실행문
```
```python
if 조건식:
실행문
else:
실행문
```
```python
if 조건식:
실행문
elif 조건식:
실행문
else:
실행문
```
## 반복문
```python
for 변수 in range(횟수):
실행문
```
`range`외에 리스트, 튜플, 문자열 등의 시퀀스 타입을 사용해도 됩니다.
```python
a = [1, 2, 3, 4, 5]
for i in a:
print(i)
for i in range(len(a)):
print(a[i])
# 리스트의 인덱스도 필요한 때에는 enumerate()를 사용하면 됩니다.
for idx, val in enumerate(a):
print(idx, val)
```
```python
while 조건식:
실행문
```
```python
i = 0
while i <= len(a):
print(a[i])
i += 1
```
## 그 외
### break
### continue
### pass
써 넣을 실행문이 없을 경우에 사용합니다. Python의 들여쓰기 문법 때문에 사용되는 키워드입니다.
```python
for i in range(10):
pass # 아무 것도 실행되지 않습니다.
```