정규 표현식이란?


정규 표현식은 복잡한 문자열을 처리할 때 사용하는 기법이다. 특정 패턴을 찾기 위한 문자열 처리 방식이다. 문자열을 처리하는 모든 곳에서 사용된다.

 

장점

  • 짧고 간결한 코드로 복잡한 패턴을 쉽게 처리할 수 있음
  • 유지보수와 가독성이 좋음

 

 

Raw String


정규식을 배우기 전, Raw String을 알고가야 한다.(사용을 하지 않을 시 "\" 문자열을 많이사용해야되기 때문) 문자열을 사용할 때,

p = re.compile("\section") 

과 같은 "\" 문자를 이용해야 할 경우가 있다. 하지만 이와 같은 경우는 "\section"이 아닌 "\s" (white space) 로 인식을 하게 된다. 이를 백슬래시를 하나 더 넣어 방지할 수 있다.

p = re.compile("\\section") 

하지만 "\"가 많이 사용될 경우 매우 번거러워지고 복잡해질 수 있기 때문에 raw string을 사용하게된다. 사용법은 다음과 같다.

import re

p = re.compile(r"\section")

이렇게 문자열 앞에 r을 이용하면 \를 2개로 인식하게끔 도와준다.

 

 

특수 시퀀스 정리


표기법 정규 표현식 설명
\d [0-9] 모든 숫자와 일치
\D [^0-9] 숫자가 아닌 모든 문자와 일치 
\s [ \t\n\r\f\v] 모든 공백문자(White space) 와 일치
\S [^ \t\n\r\f\v] 공백문자(white space)가 아닌 모든 문자와 일치
\w [a-zA-Z0-9] 단어를 구성하는 모든 문자(알파벳, 숫자, 밑줄)와 일치
\W [^a-zA-Z0-9] 단어를 구성하지 않는 문자와 일치

 

 

정규식 메타문자 정리


표기법 설명
. 기본 문자에서는 줄바꿈 문자(\n)를 제외한 어떤 단일 문자와도 일치
^ 문자열 시작의 위치, MULTILINE 모드에서는 각 줄바꿈 후에도 일치  
$ 문자열의 끝의 위치, MULTILINE 모드에서는 줄바꿈 전에도 일치
* 바로 앞에 있는 패턴이 0회 이상 반복되는 것과 일치
+ 바로 앞에 있는 패턴이 1회 이상 반복되는 것과 일치
? 바로 앞에 있는 패턴이 0회 또는 1회 반복되는 것과 일치
{m} 바로 앞에 있는 패턴이 정확히 m회 일치
{m,n} 바로 앞에 있는 패턴이 정확히 m회에서 n회  일치
[   ] 문자열 집합을 나타내며, 예를 들어 [a,m,k]는 'a', 'm', 'k' 중 하나와 일치
| 선택을 의미하며 A|B 일 경우  A 또는 B 중 하나와 일치
( ) 괄호 안의 정규식을 그룹으로 일치
\b 텍스트에서 완전히 독립된 단어를 찾고자 할 때 특히 유용

 

주요 예시와 코드

"."

import re

p1 = re.compile('a.b')
p2 = re.compile('a..b')

test1 = p1.findall('ab asb afb adeb affb abgrdbnb')
test2 = p2.findall('ab asb afb adeb aasdb abgrdbnb')

print(test1) # ['asb', 'afb']
print(test2) # ['adeb', 'asdb']

"^"

import re

p1 = re.compile('^book')

test1 = p1.findall('book is good')
test2 = p1.findall('I like book')

print(test1) # ['book']
print(test2) # []

"$"

import re

p1 = re.compile('book$')

test1 = p1.findall('book is good')
test2 = p1.findall('I like book')

print(test1) # []
print(test2) # ['book']

"*"

import re

p = re.compile('go*gle')

test1 = p.findall('gle ggle gogle google goooogle gooog')

print(test1) # ['ggle', 'gogle', 'google', 'goooogle']

"+"

import re

p = re.compile('go+gle')

test1 = p.findall('gle ggle gogle google goooogle gooog')

print(test1) # ['gogle', 'google', 'goooogle']

"?"

import re

p = re.compile('go?gle')

test1 = p.findall('gle ggle gogle google goooogle gooog')

print(test1) # ['ggle','gogle']

{m}

import re

p = re.compile('go{2}gle')

test1 = p.findall('gle ggle gogle google goooogle gooog')

print(test1) # ['google']

{m,n}

import re

p = re.compile('go{2,4}gle') # m,n 사이에 띄어쓰기하지 말것

test1 = p.findall('gle ggle gogle google goooogle gooog')

print(test1) # ['google', 'goooogle']

[ ]

import re

p = re.compile('[abc]')

test1 = p.findall('a cds asdf qwer before')

print(test1) # ['a', 'c', 'a', 'b']

|

import re

p = re.compile('a|b')

test1 = p.findall('a cds asdf qwer before')

print(test1) # ['a', 'a', 'b']

\b

import re

p = re.compile(r'\bclass\b')

test1 = p.findall('my class')
test2 = p.findall('mfseclasseaa')

print(test1) # ['class']
print(test2) # []

 

 

이메일 검증 정규 표현식


사용자_이름@도메인.최상위_도메인

 

사용자_이름 규칙

  • @기호 앞에 위치
  • 알파벳 대소문자, 숫자, 밑줄(_), 점(.), 더하기(+), 빼기(-) 포함 가능
  • 사용자 이름은 하나의 문자 이상으로 구성

도메인 규칙

  • @기호 바로 뒤에 위치
  • 알파벳 대소문자, 숫자, 빼기(-) 포함 가능

최상위_도메인(TLD) 규칙

  • 알파벳 대소문자, 숫자, 점(.), 빼기(-) 포함 가능
  • 도메인 뒤에오는 '.com' 이 최상위 도메인

정규화 코드

import re

def validate_email(email):
    pattern = re.compile(r"^[a-zA-Z0-9_.+-]+[@][a-zA-Z0-9-]+[.][a-zA-Z0-9.-]+$")
    if pattern.match(email):
        print("Valid email address.")
    else:
        print("Invalid email address.")

user_email = input("Enter your email: ")
validate_email(user_email)

 

 

 

 

파일 오픈 함수: open()

파일 입출력을 위한 모드

  • 읽기모드(r): 파일을 읽기 전용으로 열기. 파일이 존재하지 않을 시 오류 발생
  • 쓰기모드(w): 파일을 쓰기 전용으로 열기. 파일이 존재할 경우 기존 파일에 덮어 쓰기
  • 추가모드(a): 파일을 쓰는것은 똑같지만 이미 파일이 존재할 경우 기존 파일에 덮는것이 아닌 데이터 끝에 추가를 하게됨

두가지 방법

  • open()
  • with open()

 

read(), open() 파일 입출력


open()

  • open("파일명", "옵션") 함수를 통해서 파일을 읽고 쓸 수 있다.
  • 한글 깨짐 방지: utf-8을 이용하려면 encoding 옵션을 주어야 한다.
  • open()을 진행한 뒤 반드시 close()를 진행해야 한다. 안해줄 시 계속 메모리에 남아있게 된다.
helloFile = open('hello.txt', 'w', encoding="utf-8")
helloFile.write("Hello, world!\n")

helloFile.close()

 

read()

  • read() 메소드를 통해서 파일을 읽고 하나의 문자열로 반환
helloFile = open('hello.txt', 'r', encoding="utf-8")
content = helloFile.read()
print(content)
helloFile.close()
hello.txt

Hello, World!

 

with read(), with open() 파일 입출력


with open()

  • with 문은 파일을 열고 작업한 후 자동으로 파일을 닫는 기능을 제공
  • close() 명령어가 따로 필요 없음
  • with 사용 시 코드가 간결해지고, 예외 발생 시에도 닫히도록 보장
  • open()보다 요즘은 with를 사용
with open('example.txt','w',encoding='utf-8') as file:
    file.write("line1: Hello, World!\n")
    file.write("line2: This is second line\n")

with open()

  • read() : 파일 전체를 문자열 형태로 읽는다.
  • readline() : 파일에서 한문장만 읽는다.
  • readlines(): 파일을 문장단위로 리스트에 삽입한다. 리스트형태로 출력된다.
with open('example.txt','r',encoding='utf-8') as file:
    content = file.read()
    print(content)
example.txt

line1: Hello, World!
line2: This is second line

 

 

디렉터리를 모니터링하여 추가, 삭제되는 파일 혹은 디렉터리가 있는지 감시한다.

 

  • 해당 디렉터리 내에 파일, 디렉터리가 추가될 때 파일, 디렉터리 명 출력
  • 해당 디렉터리 내에 파일, 디렉터리가 삭제될 때 파일, 디렉터리 명 출력

time.sleep(5)를 통해서 5초단위로 디렉터리 모니터링

모니터링할 디렉터리의 경로(DIR_PATH)를 지정해주고 무한 반복문을 통해서 5초 단위로 프로그램을 탐색하게 된다. 이때, 디렉터리 안에 초기 파일을 os.listdir() 함수를 통해서 pre_file에 작성해놓은다.

초기파일: {"file1.txt", "file2.txt", "dir1"} 

import os
import time
import re
DIR_PATH = '{YOUR_DIR_PATH}'

pre_file = set(os.listdir(DIR_PATH))
print(f"초기 파일: {pre_file}")

while True:
    #코드 작성
    time.sleep(5)

 

반복문으로 os.listdir() 함수를 통해서 5초단위로 디렉터리 내에 파일, 디렉터리를 탐색하게 된다.

result_file = current_file - prefile 은 현재 디렉터리에서 초기 디렉터리 파일을 빼서 추가가 되었는지 확인하게 된다.

[ ex) 현재 디렉터리에서 "file3.txt"가 추가되었을 경우  {"file1.txt", "file2.txt", "dir1", "file3.txt"}가 된다. 따라서  {"file1.txt", "file2.txt", "dir1", "file3.txt"}  - {"file1.txt", "file2.txt", "dir1"} = {"file3.txt"} 가 나오게 된다. ]  

반대로 remove_file = pre_file - current_file을 하게 되면 삭제된 파일이 나오게 된다.

current_file = set(os.listdir(DIR_PATH))
    
# 차집합
result_file = current_file - pre_file
remove_file = pre_file - current_file
for i in result_file:
        print(f"새로운 탐지 파일: {i}")
    for i in remove_file:
        print(f"삭제된 탐지 파일: {i}")

 

current_file을 초기화를 안해주면 이미 추가된 파일이 계속 출력되기 때문에 새롭게 추가된 파일이 한번 출력되고 안되게 해야한다. 그러므로 current_file을 마지막에 현재 디렉터리로 초기화 해주어야한다.

pre_file = current_file

 

 

<전체코드>

import os
import time
import re
DIR_PATH = '{YOUR_DIR_PATH}'

pre_file = set(os.listdir(DIR_PATH))
print(f"초기 파일: {pre_file}")

while True:
    current_file = set(os.listdir(DIR_PATH))
    #print(f"실시간 파일: {current_file}")
    
    # 차집합
    result_file = current_file - pre_file
    remove_file = pre_file - current_file
    for i in result_file:
        print(f"새로운 탐지 파일: {i}")
    for i in remove_file:
        print(f"삭제된 탐지 파일: {i}")
    
    print("-"*30)
    # 파일 업데이트
    pre_file = current_file
    time.sleep(5)

[

 

 

파일 vs 변수


변수는 프로그램을 실행할 때 데이터를 저장하기 좋은 방법

프로그램 종료 후에도 데이터를 유지하고 싶다면 파일 형태로 저장이 필요

파이썬 os 모듈을 통해서 파일 및 디렉터리 관리 가능

 

절대경로와 상대경로


절대경로

C:\Users\username\python_ex\example.txt
#최상위 폴더에서부터 파일 탐색

 

상대경로

./example.txt
../example.txt 
#현재 위치 기준으로 파일 탐색

 

 

 

지정된 경로가 파일인지 폴더인지 판단


  • os.file.isfile(path) 함수는 지정된 경로가 파일인 경우 True 반환
  • os.file.isdir(path) 함수는 지정된 경로가 폴더인 경우 True 반환
import os

file_path = "example.txt"
if os.path.isfile(file_path):
	print(f"{file_path} is a file")
elif os.path.isdir(file_path):
	print(f"{file_path} is a directory")

 

지정된 경로 내 파일, 디렉터리 조회


  • os.listdir(path) 함수를 통해서 경로의 디레거리 내 모든 파일과 디렉터리 목록을 리스트로 반환
  • os.path.isfile(path) 함수를 이용하여 파일 여부 확인
import os

entries = os.listdir('.') #현재 디렉터리의 모든 파일 및 디렉터리 목록을 검색
print(entries) # 리스트 형태로 반환

for name in entries:
	if os.path.isfile(name):
    	print(name) # file 이름들을 출력

 

 

 

디렉터리 트리 탐색


  • os.walk()를 이용하여 디렉터리 트리를 위에서 아래로 순회하며 각 디렉터리에 대한 정보 제공
  • os.walk() 메서드 종류
    • dirpath: 현재 디렉터리 경로
    • dirnames: dirpath 아래에 있는 서브디렉터리의 리스트
    • filenames: dirpath 아래에 있는 파일 리스트
import os

for dirpath, dirnames, filenames in os.walk(r"C:\Users\username\Documents\python_ex"):
	# 현재 탐색 중인 디렉터리 경로 출력
	print(f"found directory: {dirpath}")
    
    # 현재 디렉터리 안에 있는 서브디렉터리 목록 출력
	print(f"found sub directory: {dirnames}")
    
    # 현재 디렉터리 안에 있는 파일 목록 출력
	print(f"found directory: {filenmaes}")

 

여러 경로를 결합하여 하나의 경로 형성


  • os.path.join() 여러 개의 경로 구성 요소를 적절하게 결합하여 하나의 경로로 형성
  • 윈도의 경우 "\", UNIX/Linux의 경우 "/" 로 자동 처리
import os

full_path = os.path.join('folder', 'subfolder', 'file.txt')
print("full path:", full_path)

 

파일, 디렉터리 개수를 확인하는 프로그램 예제


  • 사용자로부터 경로를 입력받아 파일 및 디렉터리 개수를 확인하는 프로그램
import os
file_name = []
dir_name = []
def count_files_and_directories(path):
    total_dir = 0
    total_file = 0
    for dirpath, dirnames, filenames in os.walk(path):
        total_file = len(filenames) + total_file
        total_dir = len(dirnames) + total_dir

    result1 = total_file
    result2 = total_dir
    return result1, result2

search_dir = r"C:\python_ex"

result1, result2 = count_files_and_directories(search_dir)
print(f"전체 파일의 개수: {result1}")
print(f"전체 서브디렉터리의 개수: {result2}")

 

리스트


  • 파이썬에서 가장 자주 사용된느 데이터 구조 중 하나
  • 여러 값들을 순서대로 저장하는데 사용

특징

  • 순서가 있는 컬렉션
  • 요소의 추가, 삭제, 수정이 자유로움
  • 동일한 요소의 중복 저장 가능
  • 다양한 데이터 타입을 하나의 리스트에 저장할 수 있음

리스트 생성

  • 리스트는 대괄호 [] 를 사용하여 생성
numbers = [1, 2, 3, 4, 5]
print(numbers) # 출력: [1,2,3,4,5]

 

문자열 나누기 - 리스트 변환

  • split() 메서드는 문자열을 특정 구분자로 나누어 리스트로 반환
  • 구분자를 지정하지 않으면 공백을 기준으로 반환
string = "Hello, world, Python"
print(string.split()) #split(조건) 에서 조건에 아무값이 안들었을 경우 default로 ' '공백 단위로 나눔
#출력: ['Hello,', 'world,', 'Python']
#string.split(',')으로 출력할 경우 ['Hello', ' world', ' Python']

 

리스트 인덱싱과 슬라이싱

  • 리스트의 특정 위치에 접근하려면 인덱스를 사용
  • 슬라이스를 사용하여 여러 요소를 선택
numbers = [1, 2, 3, 4, 5]

print(numbers[0])  # 첫 번째 요소

print(numbers[-1]) # 마지막 요소

print(numbers[2:4]) # 인덱스 2부터 3까지 요소

 

리스트 요소 추가 및 삭제

numbers = [1, 2, 3, 4, 5]

numbers.append(6)  # 리스트 끝에 6 추가
print(numbers)

numbers.insert(1, 9)  # 인덱스 1에 9 삽입
print(numbers)

numbers.remove(9)  # 값 9 삭제
print(numbers)

result = numbers.pop(2) # 요소 삭제 및 값 반환

del numbers[0]  # 첫 번째 요소 삭제
print(numbers)

 

리스트에서 특정 요소 위치 찾기

  • index() 메서드는 리스트에서 특정 요소의 위치를 찾는데 사용
  • list.index(element) 형태로 사용되며, 여기서 element는 리스트에서 찾고자 하는 요소
# 리스트 생성
my_list = [10, 20, 30, 40, 50]

# 특정 요소의 위치 찾기
element = 30
index = my_list.index(element)
print(f"{element}의 위치는 {index}입니다.")
# 30의 위치는 2입니다.

 

 

 

튜플


  • 튜플은 리스트와 비슷하지만 한 번 생성하면 수정할 수 없는 불변의 속성을 가짐.

특징

  • 순서가 있는 컬렉션
  • 불변(immutable)하여 생성 후 요소의 변경 불가
  • 메모리 사용이 리스트보다 효율적
  • 튜플 내의 데이터가 변경되지 않을 것임을 코드를 통해 보장

튜플 생성

  • 튜플은 소괄호 ()를 사용하여 생성하거나, 괄호 없이 요소를 나열 가능 (리스트는 대괄호 [])
my_tuple = (1, 2, 3)
print(my_tuple)

another_tuple = 4, 5, 6
print(another_tuple)

 

튜플 요소 수정 - 에러

  • 튜플은 수정할 수 없는 불변의 속성을 가지기 때문에 에러 발생
my_tuple = (1, 2, 3)
my_tuple[1] = 4 # 에러 발생

 

튜플 내에 리스트 포함

  • 튜플 내에 리스트를 포함하여 생성
  • 튜플은 리스트 외의 숫자와 문자열도 포함 가능
  • 튜플 자체는 수정할 수 없지만, 튜플 내의 리스트는 수정 및 추가 등 가능
mixed_tuple = (1, "apple", [2, 4, 6])

print("Original Tuple:", mixed_tuple)
#출력: Original Tuple: (1, 'apple', [2, 4, 6])

mixed_tuple[2][0] = 3
print("Modified Tuple:", mixed_tuple)
#출력: Modified Tuple: (1, 'apple', [3, 4, 6])

mixed_tuple[2].append(8)
print("Modified Tuple:", mixed_tuple)
#출력: Modified Tuple: (1, 'apple', [2, 4, 6, 8])

 

 

리스트(List) & 튜플(Tuple) 변환


  • list() 와 tuple() 함수는 다른 데이터 구조를 각각 리스트와 튜플로 변환하는 데 사용된다.
  • 이러한 변환 기능은데이터 구조 간 호환성을 높이고, 특정 데이터 처리 작업을 용이하게 하기 위해 매우 유용하다. 

list() 함수

  • 튜플을 리스트로 변환하여, 요소의 추가, 삭제, 수정이 필요할 때 사용할 수 있게 해준다.
my_tuple = (1, 2, 3)
my_list = list(my_tuple)
print(my_list) # 출력: [1, 2, 3]

tuple() 함수

  • list를 튜플로 변환하여 데이터의 안전성을 보장받을 수 있다. 주로 데이터가 변경될 필요가 없고, 읽기 전용으로 사용될 때 유용 
my_list = [1, 2, 3]
my_tuple = tuple(my_list)
print(my_tuple) # 출력: (1, 2, 3)

 

딕셔너리


  • [키] - [값] 쌍으로 데이터를 저장한다. (예: {"name": "John", "age": 25})
  • 이는 JSON 형식과 유사하며, 데이터를 효율적으로 저장하고 검색할때 유용하다.
  • [키] 값은 변경 불가능한 타입이어야 하며 (문자열, 숫자, 튜플), 값은 어떤 타입이든 가능하다.(리스트의 인덱스에서는 정수만 가능)
  • 빠른 검색, 수정, 삭제를 위한 최적화된 데이터 구조
person = {
	"name": "John", 
	"age": 30, 
	"city": "New York"
}
print(person) 
#출력: {'name': 'John', 'age': 30, 'city': 'New York'}

key 중복

  • 딕셔너리에서 키는 유일해야한다.
  • 만약 동일한 키로 여러 값을 지정하려고 하면, 마지막에 지정된 값만 저장되고 이전 값들은 덮어쓰여진다.
  • 이는 데이터 손실로 이어질 수 있으므로 키의 중복은 피해야 한다.
person = {
	"name": "John", 
	"age": 30, 
	"name": "Alice" # name의 키 중복
}
print(person) 
#출력: {'name': 'Alice', 'age': 30}

딕셔너리 value 얻기

  • 딕셔너리의 값에 접근하는 두 가지 주요 방법
  • 직접 인덱싱을 사용하는 방법과 get() 메서드 사용 
person = {
	"name": "John", 
	"age": 30, 
	"city": "New York"
}
print(person["name"])
print(person.get["name"])
#출력: John

딕셔너리 요소 추가, 수정 및 삭제

  • 딕셔너리의 특정 키에 대한 값을 접근하거나 수정할 때는 키를 사용 
person = {
	"name": "John", 
	"age": 30,
}
person["name"] = "Alice" # 요소 변경
person["city"] = "New York" #새로운 요소 추가
print(person) 
#출력: {'name': 'Alice', 'age': 30, 'city': 'New York'}

 

  • 제거를 할 때는 del 키워드, pop() 메서드, 또는 popitem() 메서드를 사용하여 딕셔너리에서 요소를 제거
person = {
	"name": "John", 
	"age": 30, 
	"city": "New York"
}
# del 키워드를 사용하여 키-값 쌍 제거 
del person["city"]

# pop() 메서드를 사용하여 키-값 쌍 제거 및 값 변환
age = person.pop("age")
print("Removed age:", age)

# popitem() 메서드는 마지막 키-값 쌍을 제거하고 반환
item = person.popitem()
print("Removed item: ", item)

 

 

집합


  • 중복을 허용하지 않고 순서가 없는 요소들의 모임
  • 집합은 주로 데이터의 중복을 제거하거나 항목의 존재 여부를 효율적으로 확인할 때 사용(합집합, 교집합 차집합)

집합 생성

  • 집합은 중괄호로( { } ) 사용하여 생성
my_set = (1, 2, 3, 4, 5}
print(my_set) # 출력: {1, 2, 3, 4, 5}

집합 요소 추가 및 삭제

  • add() 를 이용하여 요소 추가, remove를 이용하여 요소 삭제
my_set = (1, 2, 3, 4, 5}
my_set.add(6)
my_set.remove(1)
print(my_set) # 출력: {2, 3, 4, 5, 6}
my_set[0] # 이 문장 실행 시 TypeError 발생 순서가 없기 때문

 

합집합, 교집합

  • 합집합은 ( | ), 교집합은 (&), 차집합은 (-)을 사용
A = {1, 2, 3}
B = {3, 4, 5}

# 합집합
result_union = A | B
print(result_union) # 출력: {1, 2, 3, 4, 5}

# 교집합
result_intersection = A & B
print(result_intersection) # 출력: {3}

# 차집합
result_intersection = A - B
print(result_intersection) # 출력: {1, 2}

 

 

기본 조건문


  • if 문은 주어진 조건이 참(True)일 때 코드 블록을 실행
  • 여기서 조건은 True 또는 False를 결과로 가지는 포현식
if 조건문:
	# 조건이 참일 때 실행되는 코드

예시)

x = 20
if x > 10:
	print("x는 10보다 큽니다.") # x는 20 이므로 10보다 크다는 조건에 충족해 출력이 된다.
  • else 문은 if문이 거짓이면 else 문 코드 블록 실행
  • elif (else if 의 줄임말)을 사용하여 if문이 거짓일 때 검사하는 추가 조건을 제공
if 조건1:
	# 조건1이 참일 때 실행할 코드 
elif 조건2:
	# 조건1이 거짓이고 조건2가 참일 때 실행할 코드
else:
	#모든 조건이 거짓일 때 실행할 코드

 

비교 연산자

비교연산자 의미
== 같다  a == b a와 b가 같으면 참
!= 같지 않다  a != b a와 b가 다르면 참
> 보다 크다  a > b a가 더 크면 참
< 코다 작다  a < b b가 더 크면 참
>= 보다 크거나 같다  a >= b a가 b보다 크거나 같으면 참
<= 보다 작거나 같다  a <= b b가 a보다 크거나 같으면 참

 

논리 연산자

  • and (&): 둘다 참일경우 참
  • or (|): 둘 중 하나라도 참이면 참
  • not (!): 반대로 전환

and (&)

조건1 조건2 and (&)
True True True
True False False
False True False
False False False

 

or (|)

조건1 조건2 or (|)
True True True
True False True
False True True
False False False

 

not (!)

조건 not (!)
True False
False True

 

반복문


반복문의 필요성: 데이터처리 작업을 반복적으로 실행 할때 효율적이고 간결하게 관리가 가능하기 때문에 반복문을 사용해야한다.

 

for 반복문


  • for 반복문은 특정 코드 블록을 정해진 횟수나 조건에 따라 반복 실행하고자 할 때 사용
  • for 반복문은 리스트, 문자열, 튜플 등과 같이 여러 요소를가진 데이터에서 하나씩 요소를 꺼내와서 변수에 대입하고, 지정된 코드 블록을 반복해서 실행
    • for .. in .. 구문에서는 반복(iteration)을 위해 in 이 사용
    • in의역할은 리스트, 튜플, 문자열 등의 각 요소를 하나씩 가져와 반복문 내부에서 사용 가능하게 함   
for 변수 in 리스트나 문자열 등:
	#실행할 코드

예시)

for ch in "Hello, Python":
	print(ch) # 출력: Hello, Python

 

range() 함수의 사용법

  • range() 함수는 숫자 시퀀스를 생성하는 데 사용되며, 주로 for 문에서 반복의 횟수를 지정하기 위해 사용
  • range() 함수는 시작값, 끝값, 스텝(증가량) 을 지정
range(시작, 끝, 스텝)

 

#range(5)는 0, 1, 2, 3, 4 를 생성
for i in range(5):
	print(i) # 출력: 0 1 2 3 4

#2부터 시작해서 10 바로 전까지 2씩 증가하는숫자(2, 4, 6, 8)을 생성
for i in range(2, 10, 2):
	print(i) # 출력: 2 4 6 8

 

for 반복문과 enumerate() 내장 함수

  • for 반복문은여러 내장 함수와 함께 사용될 때 더욱 강력하다.
  • enumerate() 함수는 반복중인 요소의 인덱스와 값을 동시에 얻고 싶을 때 유용  
for index, char in enumerate("Hello"):
    print(f"Index {index}: {char}") 
"""
Index 0: H
Index 1: e
Index 2: l
Index 3: l
Index 4: 0
"""

 

 

while 반복문


  • while 문은 조건이 참인 동안만 반복해서 코드 블록을 실행하는 코드 반복문
  • '조건'은 매 반복마다 평가되며, 조건이 참일 경우 '실행할 코드'가 계속 실행
  • 조건이 거짓이 되면 반복문 종료
while 조건:
	실행할 코드

조건 중요성과 예제

  • while 반복문에서 조건은 반복의 계속 여부를 결정짓기 때문에 매우 중요
  • 조건이 항상 참으로 평가되면 무한 루프에 빠질 수 있으므로, 반복문 내에서 조건이 언젠가는 거짓이 될 수 있도록 설계 필요
count = 0
while count < 5: # count <5 만족할동안 반복
    print("현재 카운트:", count)
    count += 1  # count를 1씩 증가시켜 조건이 거짓이 된다.
#출려기 0 1 2 3 4

 

반복문 제어


break

  • break 명령어는 for 또는 while 반복문의 실행을 즉시 중단하고, 루프 바깥의 다음 코드 블록을 제어를 이동시키는 역할
  • 주로 루프 내에서 특정 조건이 만족될 때 루프를 탈출하는 데 사용

예제)

while True:  # 무한 루프
    user_input = input("종료하려면 'exit'를 입력하세요: ")
    if user_input == "exit":
        break  # 'exit' 입력 시 루프 탈출
    print(f"입력된 문자열은 {user_input}입니다.")
print("while문이 종료되었습니다.")

 

+ Recent posts