(1) __name__

entry point (또는 main) : 프로그래밍 언어에서 프로그램의 진입점 ! 이러한 entry point (또는 main) 메인 내부에서의 name 은 "main"

(2) 모듈의 __name__

다른 스크립트에서 해당 모듈을 import하여 사용하는 경우, name 변수는 해당 모듈의 실제 이름으로 설정됩니다.

name 변수는 주로 모듈의 특정 코드 블록이 실행되어야 하는지, 임포트되었을 때는 실행되지 않아야 하는지를 결정하는 데 사용됩니다. 보통 if name == "main": 구문을 사용하여 스크립트 파일이 직접 실행될 때만 특정 코드 블록이 실행되도록 조건을 설정하는 용도로 활용됩니다.

(3)__name__ 활용하기

test_module.py 로 실행했을때 🔥

main.py 로 실행했을때 🔥

2️⃣ package

모듈(Module)과 패키지(Package)는 파이썬에서 코드를 구성하고 구성 요소를 구성하는 데 사용되는 개념입니다. 다음은 모듈과 패키지의 차이점을 설명해드리겠습니다:

모듈(Module) :

모듈은 _파이썬 코드가 포함된 파일_입니다. 확장자가 .py인 파일이 일반적인 모듈입니다. 모듈은 변수, 함수, 클래스 등의 정의와 코드를 포함할 수 있습니다. 코드 재사용과 구조화를 위해 모듈을 사용할 수 있습니다. 모듈은 다른 파이썬 스크립트에서 import 문을 사용하여 임포트(import)하여 사용할 수 있습니다. 예를 들어, math.py라는 모듈 파일에는 수학 관련 함수와 상수가 포함될 수 있습니다. 다른 스크립트에서 import math를 사용하여 해당 모듈을 임포트하여 함수와 상수를 사용할 수 있습니다.

패키지(Package) :

패키지는 관련된 모듈들의 집합을 담고 있는 디렉토리입니다. 일반적으로 디렉토리 안에 ```__init.py 파일```이 있으면 해당 디렉토리를 패키지로 인식합니다. 패키지는 모듈의 구조화된 조직화를 제공하여 코드를 논리적으로 그룹화할 수 있습니다. 패키지는 하위 패키지와 모듈을 포함할 수 있으며, 패키지 내에 다양한 모듈이 있을 수 있습니다. 패키지는 .(점)을 사용하여 하위 패키지 또는 모듈에 접근할 수 있습니다. 예를 들어, my_package라는 패키지 안에 utils.py와 sub_package라는 하위 패키지가 있다면 my_package.utils와 my_package.sub_package로 접근할 수 있습니다. 요약하자면, 모듈은 단일 파일로 코드를 구성하고, 패키지는 모듈들의 구조화된 집합으로 코드를 구성합니다. 패키지는 모듈을 논리적으로 그룹화하여 코드 구조를 조직화하고, 모듈은 코드의 재사용과 모듈화를 지원합니다.

😫 __init__.py

• package 를 읽을때 패키지 내부의 모듈들을 한꺼번에 가져오고 싶을때가 있습니다. 이럴때는 폴더내부에 __init__.py 파일을 만들어 사용합니다!

__init__.py 에서는 __all__ 이라는 이름의 리스트를 만드는데, 이 리스트에 지정한 모듈들이 from <packge 이름 > import *할때 전부 읽어집니다 !

나는 계속 "module_b is specified in all but is not present in module" 메시지가 나와서 (-_-) chat gpt 물어보니까

실행 중에 "module_b is specified in all but is not present in module"와 같은 오류 메시지가 나타나지 않고 코드가 정상적으로 실행된다면, 해당 오류 메시지는 무시해도 됩니다.

일반적으로, all 변수는 모듈이나 패키지에서 외부로 공개할 요소들의 목록을 정의합니다. all에 포함된 요소들은 외부에서 from module import * 형식으로 일괄적으로 가져올 수 있습니다.

라고 ... 하지만 이 경우에는 "module_b is specified in all but is not present in module"와 같은 오류 메시지가 나타나지 않으므로,(????) __all__에 지정된 모듈이 실제로 모듈에 존재한다고 가정할 수 있습니다. 따라서 코드가 정상적으로 실행되는 것은 예상대로입니다.

오류 메시지는 개발자에게 잘못된__all__ 설정을 알려주는 역할을 합니다. 그러나 오류가 실제로 나타나지 않는다면, 코드가 정상적으로 작동하는 것으로 간주할 수 있습니다.** (일단 넘어감 ㅎㅅㅎ)**

import random
print("#random module:")

# random(): 0.0<= x < 1.0 float를 return합니다.
print("- randpm():", random.random())

# uniform(min,max): 지정한 범위 사이의 float를 return합니다.
print("- uniform(10,20):", random.uniform(10, 20))

# randrange(): 지정한 범위의 int를 return합니다.
# -randrange(max): 0~max 사이의 값을 return합니다.
# -randrange(min,max): min~max 사이의 값을 return합니다.
# -randrange(min,max,step): min과 max 사이에서 step 크기만큼 증가하는 값을 return합니다.


def selectRandom(li):
    import random
    ln = len(li)
    r = random.randrange(0, ln)
    return li[r]


print("- randrange(10):", random.randrange(10))
print("- randrange(10,20):", random.randrange(10, 20))
print("- randrange(10,20,2):", random.randrange(10, 20, 2))

# choice(list): 리스트 내부에 있는 요소를 랜덤으로 선택합니다.
print('- choice(["감자","모찌","핑핑","초ㅏ"]):',
      random.choice(["감자", "모찌", "핑핑", "초ㅏ"]))

# shuffle(list): 리스트 요소들을 랜덤하게 섞습니다.
print('- shuffle(["감자","모찌","핑핑","초ㅏ"]):',
      random.shuffle(["감자", "모찌", "핑핑", "초ㅏ"]))

# sample(list,k=<숫자>): 리스트 요소 중에 k개를 뽑습니다.
print("- sample([0,1,2,3,4,5,6,7,8,9],k=3):",
      random.sample([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], k=3))

• random.random(): 0.0 이상 1.0 미만의 부동소수점(float) 값을 반환합니다. 이 메서드를 사용하여 0과 1 사이의 무작위한 부동소수점 값을 얻을 수 있습니다.

• random.uniform(min, max): 지정된 범위 사이의 부동소수점(float) 값을 반환합니다. min은 범위의 최소값이고, max는 범위의 최대값입니다. 예를 들어, random.uniform(10, 20)을 호출하면 10 이상 20 미만의 부동소수점 값을 반환합니다.

• random.randrange(start, stop, step]): 주어진 범위 내의 *정수(int) *값을 반환합니다. start 매개변수는 선택적으로 사용되며 범위의 시작값을 나타냅니다. stop은 범위의 종료값을 나타내며, step은 값들 간의 증가량을 나타냅니다. 예를 들어, random.randrange(10)은 0부터 10 사이의 값을 반환하고, random.randrange(10, 20)은 10부터 20 사이의 값을 반환합니다. randrange(0, 10, 2)는 0부터 10 사이에서 2씩 증가하는 값 중에서 무작위로 선택한 값을 반환합니다. (sequence)

• random.choice(seq): choice 함수는 주어진 시퀀스(seq)에서 임의의 요소를 선택하여 반환합니다. 시퀀스는 리스트, 튜플, 문자열 등과 같이 순서가 있는 자료형이 될 수 있습니다. 함수는 주어진 시퀀스에서 임의의 요소를 선택하고 반환합니다.

• random.shuffle(seq): shuffle 함수는 주어진 시퀀스(seq)의 요소를 임의의 순서로 섞습니다. 이 함수는 원본 시퀀스를 직접 변경하며 반환값은 없습니다. 따라서 섞은 결과를 확인하려면 원본 시퀀스를 따로 출력해야 합니다.

• random.sample(population, k): sample 함수는 주어진 집합(population)에서 k개의 요소를 임의로 선택하여 리스트로 반환합니다. 반환되는 리스트에는 중복되지 않는 요소들이 포함됩니다. population은 시퀀스 혹은 집합과 같이 반복 가능한 객체가 될 수 있습니다. 함수는 주어진 집합에서 중복되지 않는 k개의 요소를 무작위로 선택하여 리스트로 반환합니다.

2️⃣sys module

sys 모듈은 파이썬의 내장 모듈 중 하나로, 시스템 관련 기능에 접근하고 제어하는 데 사용됩니다. 이 모듈은 파이썬 인터프리터와 상호작용하며, 시스템과 관련된 정보에 접근하고 파이썬 프로그램의 실행을 제어하는 기능을 제공합니다.

sys 모듈의 몇 가지 주요 기능은 다음과 같습니다:

import sys

print(sys.argv)
print("--------")

# 컴퓨터 환경과 관련된 정보를 출력합니다 ( ･ิ ͜ʖ ･ิ)
print("getwindowsversion:()",sys.getwindowsversion())
print("--------")
print("copyright:",sys.copyright)
print("--------")
print("version:",sys.version)

# 프로그램을 강종합니다 ( ･ิ ͜ʖ ･ิ)
sys.exit()

• sys.argv: 이는 _명령줄에서 전달된 인자들을 담고 있는 리스트_입니다. 프로그램 실행 시 커맨드 라인에 전달된 인자들을 확인할 수 있습니다. 예를 들어, python script.py arg1 arg2와 같이 실행하면 sys.argv는 ['script.py', 'arg1', 'arg2']와 같은 리스트를 반환합니다.

• sys.getwindowsversion(): 이 함수는 현재 Windows 운영 체제의 버전 정보를 반환합니다. Windows 운영 체제에서만 사용 가능하며, sys.getwindowsversion().major, sys.getwindowsversion().minor, sys.getwindowsversion().build, sys.getwindowsversion().platform 등의 속성을 사용하여 세부 정보를 알 수 있습니다.

• sys.copyright: 이는 현재 사용 중인 파이썬 인터프리터의 저작권 정보를 나타냅니다. 일반적으로 파이썬 버전과 저작권 정보가 출력됩니다.

• sys.version: 이는 현재 사용 중인 파이썬 인터프리터의 버전 정보를 반환합니다. 버전 번호와 빌드 정보가 포함된 문자열로 출력됩니다.

• sys.exit(): 이 함수는 프로그램을 강제로 종료합니다. 일반적으로 프로그램 실행 중에 조건을 만족하는 경우에 사용됩니다. sys.exit()를 호출하면 프로그램이 즉시 종료됩니다.

3️⃣os module

os 모듈은 파이썬의 내장 모듈 중 하나로, 운영 체제와 상호작용하기 위한 기능을 제공합니다. 이 모듈을 사용하면 _파일 및 디렉토리 관리, 프로세스 제어, 환경 변수 액세스 등과 같은 운영 체제 관련 작업_을 수행할 수 있습니다.

os 모듈의 주요 기능은 다음과 같습니다:

import os

# 기본정보 ( ^∇^)✎
print("현재 운영체제:",os.name)
print("현재 폴더:",os.getcwd())
print("현재 폴더 내부요소:",os.listdir())

# 폴더를 만들고, 제거하기 
# 폴더가 '비어있을때만' 제거가능! ( ^∇^)✎
os.mkdir("hello")
os.rmdir("hello")

# 파일을 생성하고 + 파일 이름 변경하기 ( ^∇^)✎
with open("original.txt","w") as file:
    file.write("hello")
os.rename("original.txt","new.txt")


# 파일을 제거합니다 ( ^∇^)✎
os.remove("new.txt")
#os.unlink("new.txt")

# 시스템 명령어 실행 ( ^∇^)✎
os.system("dir")

• os.name: os.name은 현재 운영 체제의 이름을 반환합니다. 위의 코드에서는 os.name을 출력하여 현재 운영 체제를 확인할 수 있습니다.

• os.getcwd(): os.getcwd() 함수는 현재 작업 디렉토리의 경로를 반환합니다. 현재 실행 중인 스크립트 파일이 위치한 디렉토리를 확인할 수 있습니다.

• os.listdir(): os.listdir() 함수는 현재 폴더 내의 파일 및 폴더 목록을 반환합니다. 인자로 경로를 전달하지 않으면 기본적으로 현재 작업 디렉토리의 내용을 반환합니다.

• os.mkdir("hello"): os.mkdir() 함수는 새로운 폴더를 생성합니다. 위의 코드에서는 "hello"라는 이름의 폴더를 생성합니다.

• os.rmdir("hello"): os.rmdir() 함수는 비어 있는 폴더를 제거합니다. 위의 코드에서는 "hello" 폴더를 제거합니다.

• with open("original.txt","w") as file: file.write("hello"): "original.txt"라는 파일을 생성하고 "hello"라는 내용을 파일에 씁니다. with 문을 사용하여 파일을 자동으로 닫습니다.

• os.rename("original.txt","new.txt"): "original.txt" 파일의 이름을 "new.txt"로 변경합니다.

• os.remove("new.txt"): os.remove() 함수는 파일을 제거합니다. 위의 코드에서는 "new.txt" 파일을 제거합니다. 주석 처리된 os.unlink() 함수는 동일한 작업을 수행하는 다른 방법입니다.

• os.system("dir"): os.system() 함수를 사용하여 시스템 명령어를 실행합니다. 위의 코드에서는 "dir" 명령어를 실행하여 현재 디렉토리의 파일 목록을 출력합니다.

위의 코드 예시에서는 os 모듈을 사용하여 현재 운영 체제 정보, 작업 디렉토리, 파일 및 폴더 관리, 시스템 명령어 실행 등의 작업을 수행하는 방법을 보여주고 있습니다.

🐰💭 File/Directory 구분하기 ❗

import os

# 현재 폴더의 파일/폴더를 출력합니다.
output=os.listdir(".")
print("os.listdir():",output)
print()

# 현재 폴더의 파일/폴더를 구분합니다.
print("# 폴더와 파일 구분하기")
for path in output:
    if os.path.isdir(path):
        print("폴더:",path)
    else:
        print("파일",path)

output = os.listdir(".")은 현재 작업 디렉토리에서 파일과 디렉토리의 리스트를 가져와서 output 변수에 할당하는 코드입니다.

os.listdir(): 지정된 디렉토리 내의 파일과 디렉토리를 나타내는 리스트를 반환하는 함수입니다. ".": 현재** 작업 디렉토리를 나타내는 경로**입니다. "."은 현재 스크립트가 실행되고 있는 디렉토리를 가리킵니다.

4️⃣ datetime module

datetime 모듈은 파이썬의 내장 모듈 중 하나로, 날짜(date), 시간(time), 날짜 및 시간(datetime)에 관련된 작업을 수행하는 데 사용됩니다. 이 모듈은 날짜와 시간을 표현하고 조작하는 클래스와 함수를 제공하여 날짜 및 시간 관련 작업을 쉽게 처리할 수 있게 해줍니다.

datetime 모듈에서 자주 사용되는 클래스와 함수에는 다음과 같은 것들이 있습니다:

위의 클래스와 함수들을 사용하여 날짜와 시간을 _생성, 조작, 비교하거나 포맷팅_하는 등 다양한 작업을 수행할 수 있습니다. datetime 모듈은 날짜 및 시간 관련 작업을 처리하는데 유용한 도구이며, 파이썬에서 날짜와 시간을 다루는 일반적인 요구사항을 충족시켜줍니다.

(1)현재시간 구하기

import datetime

# 현재 시각 구하고 출력하기 ＿〆(。╹‿ ╹ 。)

print("# 현재 시각 출력하기")
now = datetime.datetime.now()
print(now.year, "년")
print(now.month, "월")
print(now.day, "일")
print(now.hour, "시")
print(now.minute, "분")
print(now.second, "초")
print()

# 시간 출력 방법 ＿〆(。╹‿ ╹ 。)

print("# 시간을 포맷에 맞춰 출력하기")
output_a = now.strftime("%Y.%m.%D, %H:%M:%S")
print(now.strftime("%Y.%m.%d, %H:%M:%S"))
output_b = "{}년 {}월 {}일 {}시 {}분 {}초".format(
    now.year, now.month, now.day, now.hour, now.minute, now.second)
output_c = now.strftime("%Y{} %m{} %d{}, %H{} %M{} %S{}").format(*"년월일시분초")
print(output_a)
print(output_b)
print(output_c)

now.strftime("%Y.%m.%d, %H:%M:%S"):strftime() 메서드를 사용하여 현재 시각을 지정된 포맷에 맞춰 출력합니다.** %Y, %m, %d, %H, %M, %S**와 같은 형식 지시자를 사용하여 날짜 및 시간 요소를 포맷팅합니다. 예시에서는 "연-월-일, 시:분:초" 형식으로 출력되도록 지정하였습니다.

output_b = "{}년 {}월 {}일 {}시 {}분 {}초".format(now.year, now.month, now.day, now.hour, now.minute, now.second): format() 메서드를 사용하여 형식화된 문자열을 생성합니다. 중괄호 {}를 사용하여 format()메서드에 전달된 인자들을 순서대로 삽입하여 문자열을 생성합니다.

output_c = now.strftime("%Y{} %m{} %d{}, %H{} %M{} %S{}").format(*"년월일시분초"): 위의 예시와 마찬가지로 strftime() 메서드를 사용하여 현재 시각을 형식에 맞춰 출력합니다. 이때 format() 메서드를 활용하여 포맷 문자열 내의 중괄호 {}에 인자들을 삽입합니다. format() 메서드의 *****을 사용하여 "년월일시분초" 문자열을 개별 문자들로 전달하였습니다.

🐰💭 %m 🆚 %M ❗

%m과 %M은 모두 strftime() 메서드에서 날짜와 시간을 포맷팅할 때 사용되는 형식 지시자입니다. 하지만 두 지시자는 서로 다른 의미를 가지고 있습니다.

%m: %m은 strftime() 메서드에서 월(month)을 나타내는 형식 지시자입니다. 0으로 패딩된 두 자리 숫자 형태로 월을 나타냅니다. 예를 들어, 06은 6월을 나타냅니다.

%M: %M은 strftime() 메서드에서 분(minute)을 나타내는 형식 지시자입니다. 0으로 패딩된 두 자리 숫자 형태로 분을 나타냅니다. 예를 들어, 09는 9분을 나타냅니다.

아래는 각각의 형식 지시자를 사용하여 현재 시각을 포맷팅하는 예시 코드입니다:

import datetime

now = datetime.datetime.now()

# 월 포맷팅 (%m)
month_formatted = now.strftime("%m")
print("월:", month_formatted)  # 출력: 월: 06

# 분 포맷팅 (%M)
minute_formatted = now.strftime("%M")
print("분:", minute_formatted)  # 출력: 분: 09

위의 코드에서는 strftime() 메서드를 사용하여 현재 시각을 %m과 %M의 형식 지시자에 맞춰 포맷팅한 결과를 출력하고 있습니다. 06은 현재 월을, 09는 현재 분을 나타냅니다. %m과 %M은 각각 월과 분을 나타내며, 두 지시자는 출력 형식이 다르므로 주의하여 사용해야 합니다.

🐰💭 %d 🆚 %D ❗

%d와 %D는 날짜를 포맷팅할 때 사용되는 형식 지시자입니다. 하지만 두 지시자는 서로 다른 의미와 출력 형식을 가지고 있습니다.

%d: %d는 strftime() 메서드에서 일(day)을 나타내는 형식 지시자입니다. 0으로 패딩된 두 자리 숫자 형태로 일을 나타냅니다. 예를 들어, 05는 5일을 나타냅니다.

%D: %D는 %m/%d/%y와 같은 날짜의 단축 형식을 나타내는 형식 지시자입니다. %m은 월을, %d는 일을, %y는 연도의 끝 두 자리를 나타냅니다. 예를 들어, 06/05/21은 2021년 6월 5일을 나타냅니다.

아래는 각각의 형식 지시자를 사용하여 현재 날짜를 포맷팅하는 예시 코드입니다:

import datetime

now = datetime.datetime.now()

# 일 포맷팅 (%d)
day_formatted = now.strftime("%d")
print("일:", day_formatted)  # 출력: 일: 19

# 날짜 단축 형식 포맷팅 (%D)
date_formatted = now.strftime("%D")
print("날짜:", date_formatted)  # 출력: 날짜: 06/19/23

🐰💭 .format(*"년월일시분초") :

.format(*"년월일시분초") : 문자열, 리스트 등 앞에 *****을 붙이면 요소 하나하나가 매개변수로 지정됩니다!

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

formatted_string = "{} + {} + {} + {} + {} = {}".format(*values, sum(values))
print(formatted_string)

(2)특정 시간 요소를 교체하기

import datetime
now = datetime.datetime.now()

# 특정 시간 이후의 시간 구하기
print("# datetime.timedelta로 시간 더하기")
after = now+datetime.timedelta(weeks=1, days=1, hours=1, minutes=1, seconds=1)
print(after.strftime("%Y{} %m{} %d{} %H{} %M{} %S{}").format(*"년월일시분초"))
print()

# 특정 시간 요소 교체하기
print("#now.replace()로 1년 더하기")
output = now.replace(year=(now.year+1))
print(output.strftime("%Y{} %m{} %d{} %H{} %M{} %S{}").format(*"년월일시분초"))

• datetime.timedelta(): datetime.timedelta() 함수는 두 날짜 또는 시간 간격을 나타내는 클래스인 timedelta 객체를 생성합니다. timedelta 객체는_ 일(day), 시간(hour), 분(minute), 초(second), 마이크로초(microsecond)_ 등의 시간 간격을 다룰 수 있습니다. timedelta 객체를 사용하여 날짜나 시간에 특정 시간 간격을 더하거나 빼는 등의 연산을 수행할 수 있습니다. 1년후,2년 후 등의 몇년 후를 구하는 기능은 없습니당. 1년후를 구할 때는 replace()함수를 사용하여 아예 날짜 값을 교체하는 것이 일반적입니다!

import datetime

# 현재 시간
now = datetime.datetime.now()

# 1주일, 1일, 1시간, 1분, 1초를 더한 시간 구하기
after = now + datetime.timedelta(weeks=1, days=1, hours=1, minutes=1, seconds=1)
print(after)  # 예시 출력: 2023-06-27 19:42:08.288347

위의 예시 코드에서는 datetime.timedelta() 함수를 사용하여 현재 시간 now에 1주일, 1일, 1시간, 1분, 1초를 더한 after 변수를 계산하고 출력합니다. timedelta() 함수의 인수로 시간 간격을 지정하여 더할 수 있으며, 이를 통해 특정 시간 이후 또는 이전의 시간을 계산할 수 있습니다.

• replace() 메서드는 datetime 객체의 특정 시간 요소를 교체한 새로운 datetime 객체를 반환합니다. 교체할 시간 요소를 인수로 전달하여, 해당 시간 요소만 변경된 객체를 생성합니다. 다른 시간 요소는 유지됩니다. .replace() 메서드는 연도(year), 월(month), 일(day), 시(hour), 분(minute), 초(second), 마이크로초(microsecond) 등의 시간 요소를 변경할 수 있습니다.

예시 코드:

import datetime

# 현재 시간
now = datetime.datetime.now()

# 연도를 1년 뒤로 변경
output = now.replace(year=now.year + 1)
print(output)  # 예시 출력: 2024-06-19 18:41:23.615268

5️⃣ time module

time 모듈은 파이썬의 내장 모듈 중 하나로, 시간과 관련된 기능을 제공합니다. 이 모듈은 시간을 측정하고 제어하는 함수와 클래스를 포함하고 있으며, 시간 기반의 작업을 수행하는 데 유용합니다.

자주 사용되는 time 모듈의 클래스와 함수에는 다음과 같은 것들이 있습니다:

위의 함수들은 time 모듈에서 자주 사용되는 함수 중 일부입니다. 이외에도 더 다양한 함수와 기능이 제공되며, 시간 관련 작업에 유용하게 사용할 수 있습니다.

🐰💭 datetime 모듈🆚time 모듈 ❗

datetime 모듈과 time 모듈은 모두 파이썬의 내장 모듈이며, 시간과 관련된 작업을 처리하는 데 사용됩니다. 두 모듈은 비슷한 기능을 가지고 있지만 _목적_과 _사용법_에서 약간의 차이가 있습니다.

• 날짜와 시간 표현:
  • datetime 모듈: datetime 모듈은 날짜(date)와 시간(time)을 함께 표현하는 datetime 클래스를 제공합니다. 이 클래스는 날짜와 시간을 조작하고 비교하는 메서드를 포함하고 있습니다. datetime 클래스는 년, 월, 일, 시, 분, 초, 마이크로초 등의 시간 구성 요소를 다룰 수 있습니다.
  • time 모듈: time 모듈은 시간(time)을 주로 다루는 함수와 클래스를 제공합니다. time 모듈에서는 시간을 초(second) 단위로 표현하며, 시, 분, 초를 다루는 메서드를 제공합니다.

• 시간 정보의 표현 방식:

  • datetime 모듈: datetime 모듈에서는 날짜와 시간을 각각의 클래스로 나타내고 조작합니다. 날짜와 시간을 함께 다루는 datetime 클래스를 사용하여 표현하고 조작합니다.
  • time 모듈: time 모듈에서는 주로 시간을 초 단위로 표현하고 다룹니다. 시, 분, 초를 각각의 메서드로 다루며, 시간 간격을 나타내는 timedelta 클래스를 사용하여 표현하고 조작합니다.

• 용도:

  • datetime 모듈: datetime 모듈은 주로 날짜와 시간을 다루는 작업에 사용됩니다. 날짜와 시간의 생성, 조작, 포맷팅, 비교 등에 유용합니다.
  • time 모듈: time 모듈은 주로 시간 관련 작업에 사용됩니다. 시간 측정, 지연, 형식화, 로컬 및 UTC 시간 변환 등을 다룹니다. 요약하자면, _datetime 모듈은 날짜와 시간을 함께 다루는 데 사용되고, time 모듈은 시간을 초 단위로 다루는 데 사용_됩니다. 두 모듈은 비슷한 작업을 수행하지만 목적과 사용법에서 약간의 차이가 있으므로 적절한 모듈을 선택하여 시간 관련 작업을 수행하면 됩니다.

import time

print("지금부터 5초동안 정지합니다!")
time.sleep(5)
print("프로그램을 종료합니다")

import time

print("지금부터 5초동안 정지합니다!")

for second in range(1, 6):
    time.sleep(1)
    print(second, "초")



print("프로그램을 종료합니다!!")

6️⃣ urllib module

urllib 모듈은 파이썬에서 URL(Uniform Resource Locator)을 다루는 데 사용되는 라이브러리입니다. 이 모듈은 HTTP, HTTPS, FTP 등의 프로토콜을 사용하여 웹 서버와 통신하고 데이터를 다운로드하거나 업로드하는 기능을 제공합니다. urllib 모듈은 파이썬의 표준 라이브러리로 제공되며, urllib.request, urllib.parse, urllib.error, urllib.robotparser 등의 모듈로 구성됩니다.

urllib 모듈의 주요 기능은 다음과 같습니다:

urllib 모듈은 웹 스크래핑, 웹 데이터 수집, 웹 API와의 상호 작용 등 다양한 웹 관련 작업에 유용하게 사용될 수 있습니다.

from urllib import request

target=request.urlopen("http://google.com")
output=target.read()

print(output)

실행결과를 보면 앞에 "b"라는 글자는 binary data를 의미하는 것입니다.

💛(1) read()

f=open('/Users/choa/Desktop/5674-734/stockcode.txt','r',encoding='cp949')
data=f.read()
print(data)
f.close()

💛(2) readline()

f=open('/Users/choa/Desktop/5674-734/stockcode.txt','r',encoding='cp949')
line_num=1
line=f.readline()
while line:
    print("%d %s"%(line_num,line),end='')
    line=f.readline()
    line_num+=1

f.close()

💛(3) readlines()

f=open('/Users/choa/Desktop/5674-734/stockcode.txt','r',encoding='cp949')
lines=f.readlines()
for line_num,line in enumerate(lines):
    print('%d_%s'%(line_num+1,line))
f.close()

readline() 🆚 readlines()

• 🐰💭 readline(): readline() 함수는 파일에서 한 줄씩 읽어옵니다. 읽어온 줄은 문자열로 반환됩니다. 읽어온 줄에는 개행 문자 \n이 포함되어 있으며, 반환된 문자열도 개행 문자를 포함합니다. 따라서, readline() 함수로 한 줄을 읽을 때 개행 문자까지 포함하여 출력됩니다.
• 🐰💭readlines(): readlines() 함수는 파일의 모든 줄을 읽어와 리스트로 반환합니다. 각 줄은 리스트의 요소로 저장되며, 개행 문자 \n은 각 요소의 끝에 포함됩니다. 따라서, readlines() 함수로 모든 줄을 읽을 때 개행 문자까지 포함하여 출력됩니다. 예를 들어, 다음과 같은 파일이 있다고 가정합니다:

  Hello
  World

readline() 함수로 한 줄을 읽으면 개행 문자를 포함한 문자열이 반환됩니다❗:

f = open('file.txt', 'r')
line = f.readline()
print(line)  # 'Hello\n'
f.close()

readlines()함수로 모든 줄을 읽으면 개행 문자를 포함한 리스트가 반환됩니다❗:

f = open('file.txt', 'r')
lines = f.readlines()
print(lines)  # ['Hello\n', 'World\n']
f.close()

개행 문자를 포함하여 출력되는 것은 readline() 함수와 readlines() 함수의 동작 방식에 따른 결과입니다.

2️⃣write()/writelines()

💛(1) write()

text=input("파일에 저장할 내용을 입력하세요@^@")
f=open('mydata.txt','w')
f.write(text)
f.close()

💛(2) writelines()

count=1
data=[]
print('파일에 내용을 저장하려면 내용을 입력하지 말고 [Enter]키를 누르세요')
while True:
    text=input("[%d]파일에 저장할 내용을 입력하세요."%count)
    if text=='':
        break
    data.append(text+'\n')
    count+=1

f=open('mydata.txt','w')
f.writelines(data)
f.close()

write()와 writelines()는 모두 파일에 데이터를 쓰는 함수입니다. 그러나 사용 방식과 동작에 차이가 있습니다.

write() 🆚 writelines()

• 🐰💭write(): write() 함수는 인자로 전달된 문자열을 파일에 씁니다. 이 함수는단일한 문자열만을 받을 수 있으며, 개행 문자를 자동으로 추가하지 않습니다. 따라서, 개행 문자를 직접 추가해주어야 합니다.

예시:

f = open('file.txt', 'w')
f.write('Hello')
f.write('World')
f.close()

위의 코드는 'file.txt' 파일에 "HelloWorld"라는 내용을 씁니다.

• 🐰💭writelines(): writelines() 함수는여러 줄의 문자열을 파일에 씁니다. 인자로 전달된 문자열의 리스트나 이터러블 객체를 받아들여 각 요소를 파일에 씁니다. writelines() 함수는 개행 문자를 추가하지 않으므로, 각 문자열 요소가 개행 문자로 구분된다면 개행 문자도 직접 포함해야 합니다.

예시:

f = open('file.txt', 'w')
lines = ['Hello\n', 'World\n']
f.writelines(lines)
f.close()

위의 코드는 'file.txt' 파일에 "Hello"와 "World"를 개행하여 씁니다.

따라서, write() 함수는 _단일 문자열_을 파일에 쓸 때 사용하고, writelines() 함수는 _여러 줄의 문자열_을 파일에 쓸 때 사용합니다.

3️⃣텍스트 파일/바이너리 파일 복사하기

💛(1) 텍스트 파일 복사하기

f=open('/Users/choa/Desktop/5674-734/stockcode.txt','r',encoding='cp949')
h=open('/Users/choa/Documents/python/stockcode_copy.txt','w')

data=f.read()
h.write(data)

f.close()
h.close()

💛(2) 바이너리 파일 복사하기

bufsize=1024
f=open('/Users/choa/Desktop/5674-734/img_sample.jpg','rb')
h=open('img_sample_copy.jpg','wb')

data=f.read(bufsize)
while data:
    h.write(data)
    data=f.read(bufsize)

f.close()
h.close()

바이너리 파일은 텍스트 파일과 달리 인코딩을 지정할 필요가 없습니다. 바이너리 파일은 텍스트가 아닌 이진 데이터로 구성되어 있기 때문에 인코딩이나 디코딩 과정이 필요하지 않습니다.

바이너리 파일을 열 때는 파일을 바이너리 모드('rb' 또는 'wb')로 열어야 합니다. 'rb' 모드는 바이너리 파일을 읽기 모드로 열고, 'wb' 모드는 바이너리 파일을 쓰기 모드로 엽니다.

예를 들어, 바이너리 파일을 읽고 복사하는 코드는 다음과 같습니다:

with open('input.bin', 'rb') as f:
    data = f.read()

with open('output.bin', 'wb') as h:
    h.write(data)

위의 코드에서 'input.bin'은 읽을 바이너리 파일의 경로이고, 'output.bin'은 쓸 바이너리 파일의 경로입니다. rb 모드로 파일을 열어 데이터를 읽고, wb 모드로 파일을 열어 데이터를 씁니다. 인코딩 매개변수를 사용하지 않는 것에 유의해 주세요.

• 🐰💭 컴퓨터에서 파일 크기를 표현하는 단위인 킬로바이트(KB)는 1024 바이트를 의미합니다. 따라서, 1KB는 1024 바이트를 의미합니다.

만약 파일을 256KB 단위로 읽고 싶은경우에는 _bufsize를 256*1024로 정의_하면 됩니다!

4️⃣ 파일을 열고 자동으로 닫기 (with~as)

with open('/Users/choa/Desktop/5674-734/stockcode.txt','r',encoding='cp949')as f:
    for line_num,line in enumerate(f.readlines()):
        print("%d_%s"%(line_num,line),end='')

• 🐰💭with~as문은 파일이나 리소스와 같은 객체를 사용한 후에 자동으로 정리(clean-up)하기 위해 사용되는 구문입니다. with문을 사용하면 파일을 열거나 다른 리소스를 사용한 후에 별도의 close() 함수를 호출하지 않아도 됩니다.

일반적으로 파일을 다룰 때 open() 함수로 파일을 열고, 작업을 마친 후에 close() 함수로 파일을 닫아야 합니다. 그러나 with문을 사용하면 파일을 열고 사용한 후에 자동으로 파일을 닫아줍니다. 이렇게 함으로써 파일을 열고 닫는 과정을 명시적으로 처리하지 않아도 되므로 코드가 더 간결해집니다.

with문은 다음과 같은 구문으로 사용됩니다:

with open('파일경로', '모드') as 파일객체:
    # 파일을 사용하는 코드
    # 파일객체를 통해 파일을 읽거나 쓰는 작업을 수행

with문은 파일객체를 생성하고 해당 블록 내에서 사용한 후에 자동으로 파일을 닫아줍니다. 파일 객체를 파일객체라는 변수에 할당하고, 해당 변수를 통해 파일을 읽거나 쓰는 작업을 수행합니다. with문을 빠져나오면 파일 객체가 자동으로 닫힙니다.

5️⃣ㅍㅏ일의 특정 부분만 복사하기(seek,read,write)

spos=105
size=500

f=open('/Users/choa/Desktop/5674-734/stockcode.txt','r',encoding='cp949')
h=open('/Users/choa/Documents/python/stockcode_2.txt','w')

f.seek(spos)
data=f.read(size) # ?? 
h.write(data)

h.close()
f.close()

🐰💭 특정 위치에서부터 일정 크기만큼 데이터를 읽어와서 다른 파일에 쓰는 예시

1. spos 변수는 파일에서 데이터를 _읽을 시작 위치를 지정하는 변수_입니다. 이 값은 파일 내에서의 오프셋(offset)을 나타냅니다.
2. size 변수는 읽어올 데이터의 _크기를 지정하는 변수_입니다. 이 값은 바이트 단위로 지정됩니다.

f.seek(spos)
data = f.read(size)

위의 코드는seek() 메서드를 사용하여 파일 포인터를 spos 위치로 이동시킵니다. 파일 포인터는 파일 내에서 현재의 위치를 가리키는 역할을 합니다. seek() 메서드를 사용하여 파일 포인터를 이동시킨 후,해당 위치에서부터 size만큼의 데이터를 읽어옵니다. _ _read() 메서드를 사용하여 읽어온 데이터는 data 변수에 저장됩니다.

h.write(data)

어온 데이터인 data를 다른 파일에 씁니다. write()메서드를 사용하여 데이터를 파일에 씁니다.

마지막으로 h.close()와 f.close()를 사용하여 파일 객체를 닫아줍니다. 파일을 사용한 후에는 항상 파일을 닫아 리소스를 해제하는 것이 좋습니다.

따라서, 주어진 코드는 stockcode.txt 파일에서 spos 위치부터 size 크기만큼의 데이터를 읽어와서 stockcode_2.txt 파일에 쓰는 기능을 수행합니다.

6️⃣파일 크기 구하기

from os.path import getsize

file1='/Users/choa/Desktop/5674-734/stockcode.txt'
file2='/Users/choa/Desktop/5674-734/img_sample.jpg'
file_size1=getsize(file1)
file_size2=getsize(file2)

print('File Name:%s\tFile Size:%d'%(file1,file_size1))
print('File Name:%s\tFile Size:%d'%(file2,file_size2))

os.path 모듈의 getsize() 함수를 사용하여 파일의 크기를 가져옵니다.

os.path 모듈은 파일 경로와 관련된 작업을 수행하기 위한 함수들을 제공하는 파이썬 내장 모듈입니다. 몇 가지 os.path 모듈의 주요 함수와 속성을 살펴보겠습니다:

7️⃣파일삭제하기 os.remove

from os import remove

target_file='/Users/choa/Documents/python/stockcode_2.txt'
k=input('[%s]파일을 삭제하겠습니까?(y/n)'%target_file)
if k=='y':
    remove(target_file)
    print('[%s]를 삭제했습니다'%target_file)

os 모듈은 파이썬의 표준 라이브러리 중 하나로, 운영 체제와 상호 작용하기 위한 다양한 기능을 제공합니다. 몇 가지 주요한 os 모듈의 기능은 다음과 같습니다:

1️⃣ 포맷문자열(%x)(%02x)

포맷 문자열 %x와 %02x는 모두 정수를 16진수로 표현하는 데 사용됩니다. 그러나 이들의 차이점은 출력 결과의 형식입니다.

%x는 주어진 정수를 16진수로 변환하고 출력하는데, 만약 변환된 16진수가 한 자리 수라면 그대로 출력됩니다. 예를 들어, 정수 10은 16진수로 'a'로 표현되며, %x 포맷 문자열을 사용하면 'a'가 출력됩니다.

반면에 %02x는 주어진 정수를 16진수로 변환하고 출력하는데, 변환된 16진수가 한 자리 수라면 앞에 0을 붙여 두 자리로 표현합니다. 따라서, 정수 10은 16진수로 '0a'로 표현되며, %02x 포맷 문자열을 사용하면 '0a'가 출력됩니다.

• example

  number = 10
  print("%x" % number)   # 출력: a
  print("%02x" % number) # 출력: 0a

  따라서, %x와 %02x는 동일한 값을 16진수로 표현하지만 _출력 결과의 자릿수가 다르다는 점에서 차이_가 있습니다.

b1=bin(97)
b2=bin(98)
ret1=b1+b2
print(ret1)
print(type(ret1))


a=int(b1,2)
b=int(b2,2)
ret2=a+b
print(ret2)
print(bin(ret2))

🧡 a=int(b1,2) 가뭐야 ?

a=int(b1,2)는 문자열로 표현된 이진수인 b1을 십진수로 변환하는 과정입니다.

bin(97)은 정수 97을 이진수로 표현한 문자열을 반환합니다. 따라서 b1의 값은 '0b1100001'입니다. 여기서 '0b'는 이진수를 나타내는 접두사입니다.

int(b1, 2)는 문자열 b1을 이진수로 해석하여 해당하는 십진수 값을 반환합니다. 두 번째 인자로 2를 전달하여 이진수임을 명시합니다. 이 경우 int(b1, 2)는 문자열 '0b1100001'을 이진수로 해석하여 정수 값 97을 반환합니다.

따라서, a=int(b1,2)는 이진수 문자열인 b1을 십진수로 변환하여 변수 a에 할당하는 것을 의미합니다.

bnum = 0b11110000  # 이진수 (2진수)
bstr = '0b111100000'  # 이진수 문자열 (2진수)

onum = 0o360  # 8진수
ostr = '0o360'  # 8진수 문자열

hnum = 0xf0  # 16진수
hstr = '0xf0'  # 16진수 문자열

b1 = int(bnum)  # 이진수를 십진수로 변환
b2 = int(bstr, 2)  # 이진수 문자열을 십진수로 변환

o1 = int(onum)  # 8진수를 십진수로 변환
o2 = int(ostr, 8)  # 8진수 문자열을 십진수로 변환

h1 = int(hnum)  # 16진수를 십진수로 변환
h2 = int(hstr, 16)  # 16진수 문자열을 십진수로 변환

print(b1)  # 출력: 240
print(b2)  # 출력: 480
print(o1)  # 출력: 240
print(o2)  # 출력: 240
print(h1)  # 출력: 240
print(h2)  # 출력: 240

각 변수에 할당된 값을 int() 함수를 사용하여 해당 진법에 맞게 십진수로 변환할 수 있습니다. int() 함수의 두 번째 인자로 진법을 지정하면 해당 진법으로 해석됩니다. 예를 들어, int(bstr, 2)에서 두 번째 인자로 2를 전달하여 이진수임을 명시했습니다. 따라서 '0b111100000'은 이진수로 해석되어 십진수 값 480을 반환합니다.

마지막으로, 각 변수의 값을 출력하면 해당 값을 십진수로 변환한 결과가 출력됩니다.

2️⃣filter()

🧡소수 구하기(1)

def getPrime(x):
    if x % 2 == 0:
        return

    for i in range(3, int(x/2), 2):
        if x % i == 0:
            break
    else:
        return x

listdata = [117, 119, 1113, 11113, 11119]
ret = filter(getPrime, listdata)
print(list(ret))  # 출력: [11113, 11119]

getPrime 함수는 주어진 숫자 x가 _소수인지 확인하는 함수_입니다. 함수 내부에서는 다음과 같은 절차를 따릅니다:

x가 짝수인 경우, 즉 x % 2 == 0인 경우 함수에서 바로 리턴합니다. 짝수는 소수가 될 수 없기 때문입니다. x가 홀수인 경우, for 루프를 사용하여_ 3부터 x/2까지 홀수만 확인_합니다. 이 범위에서 숫자를 나누어 나머지가 0인지 확인합니다. 만약 어떤 숫자 i로 x를 나누었을 때 나머지가 0인 경우, x는 소수가 아니므로 루프를 중단합니다. 소수인 경우, 루프를 모두 거치고 else 절에 도달하여 x를 반환합니다. listdata 리스트의 각 요소에 대해 getPrime 함수를 적용하여 소수인 요소만 필터링하여 결과 리스트를 생성합니다. filter()함수를 사용하여 getPrime 함수를 listdata의 각 요소에 적용하고, list() 함수를 사용하여 필터링된 결과를 리스트로 변환합니다.

최종적으로, listdata에서 소수인 요소들만 출력합니다.

output:

[11113, 11119]

🧡소수 구하기(2)

def getPrime(n):
    ret=[2]
    if n<=2:
        return ret

    for i in range(3,n+1,2):
        for k in range(3,int(i/2),2):
            a=i%k
            if a==0:
                break
        else:
            ret.append(i)
    return ret

ret=getPrime(10)
print(ret)

3부터 n까지의 홀수에 대해 소수를 판별하는 for 루프입니다. range(3, n + 1, 2)는 3부터 n까지 2씩 증가하는 홀수 범위를 나타냅니다. 내부 for 루프에서는 3부터 i/2까지의 홀수에 대해 i를 나누어 나머지를 계산합니다. a가 0인 경우, 즉 i가 k로 나누어 떨어진다면 i는 소수가 아니므로 내부 for 루프를 break하여 종료합니다. 내부 for 루프가 정상적으로 종료되었다면, i는 소수로 판별되어 ret.append(i)를 통해 ret 리스트에 i 값을 추가합니다.

🧡 짝수 확인하기

def is_even(n):
    return n % 2 == 0

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

filtered_numbers = filter(is_even, numbers)
even_numbers = list(filtered_numbers)

print(even_numbers)

위의 예시 코드에서 is_even 함수는 주어진 숫자가 짝수인지 확인하는 함수입니다. filter()함수를 사용하여 is_even 함수를 numbers 리스트의 각 요소에 적용합니다. filter() 함수는 is_even 함수의 결과가 True인 요소들로 이루어진 이터레이터를 반환합니다.

filter() 함수의 결과를 리스트로 변환하기 위해 list() 함수를 사용하여 filtered_numbers를 리스트인 even_numbers로 변환합니다.

output:

[2, 4, 6, 8, 10]

3️⃣ & 연산자

a=107
b=a&0x0f
print(b)

c=(a>>4)&0x0f
print(c)

& 연산자를 사용하여 a와 0x0f (16진수로 표현된 15)를 비트 단위로 논리 AND 연산합니다. 0x0f는 4비트에서 하위 4비트가 1로 설정된 값입니다. a의 이진 표현과 0x0f의 이진 표현에서 같은 위치의 비트를 비교하고, 둘 다 1인 경우에만 결과의 해당 비트는 1이 됩니다. 따라서, b는 a의 하위 4비트에 해당하는 값이 됩니다.

a 변수를 오른쪽으로 4비트 시프트하여 값을 계산합니다. 연산자는 이진수를 오른쪽으로 지정된 비트 수만큼 이동시킵니다. 이동된 비트는 버려지고, 왼쪽에는 0이 추가됩니다. (a >> 4)는 a의 이진 표현을 오른쪽으로 4비트 이동시킨 값을 나타냅니다. 그 다음, & 연산자를 사용하여 이동된 결과와 0x0f를 비트 단위로 논리 AND 연산합니다. 결과적으로 c는 a의 상위 4비트에 해당하는 값이 됩니다. c를 출력합니다.

따라서, 위의 코드는 107를 이진수로 표현했을 때의 하위 4비트인 11을 b에 저장하고 출력하며, 상위 4비트인 0110을 c에 저장하고 출력합니다.

4️⃣ 문자열 슬라이싱

🧡 [::2]vs[:2]

문자열의 슬라이싱에서 ::2와 :2는 서로 다른 동작을 합니다.

::2: 이 표현은 문자열의 처음부터 끝까지 전체 문자열을 선택하되, 스텝(step) 값을 2로 설정하여 2칸씩 건너뛰며 선택하는 것을 의미합니다. 즉, 문자열에서 홀수 인덱스(0을 기준으로 홀수 번째)에 해당하는 문자들만 선택하여 반환합니다. :2: 이 표현은 문자열의 시작부터 1번 인덱스(두 번째 문자)까지 선택하는 것을 의미합니다. 슬라이싱의 끝 인덱스가 포함되지 않으므로, 0번 인덱스와 1번 인덱스에 해당하는 두 개의 문자가 선택되어 반환됩니다.

예를 들어, 문자열이 'Hello, World!'인 경우:

'Hello, World!'[::2]는 'Hlo ol!'를 반환합니다. 시작부터 끝까지 스텝 2로 선택하므로 홀수 인덱스에 해당하는 문자들이 선택됩니다. 'Hello, World!'[:2]는 'He'를 반환합니다. 시작부터 1번 인덱스까지 선택하므로 0번 인덱스와 1번 인덱스에 해당하는 'H'와 'e'가 선택됩니다. 따라서, ::2와 :2는 문자열의 슬라이싱 동작에서 서로 다른 결과를 반환합니다.

🧡[::-1]

txt = 'abcdefghikklmnop'
ret = txt[::-1]

txt[::-1]은 문자열을 뒤집는 슬라이싱 기법을 사용합니다. [::-1]은 문자열의 처음부터 끝까지 전체 문자열을 선택하되, 스텝(step) 값을 -1로 설정하여 역순으로 선택하는 것을 의미합니다.

output:

'ponmlkkikjhgfedcba'

🧡[::-2]

txt = 'abcdefghikklmnop'
ret = txt[::-1]

txt[::-2]는 문자열을 역순으로 선택하되, 스텝(step) 값을 -2로 설정하여 2칸씩 건너뛰며 선택하는 것을 의미합니다. 따라서, txt의 모든 문자를 역순으로 선택하면서 2칸씩 건너뛰어 선택합니다.

output:

'pomkmigeca'

🧡[-2::-2]

txt = 'abcdefghikklmnop'
ret = txt[::-1]

txt[-2::-2]는 문자열을 뒤에서 2번째 문자부터 역순으로 선택하되, 스텝(step) 값을 -2로 설정하여 2칸씩 건너뛰며 선택하는 것을 의미합니다. 즉, -2 인덱스부터 시작하여 문자열을 뒤로 이동하면서 2칸씩 건너뛰어 선택합니다.

output:

'oljifdb'

5️⃣ 문자열 공백 지우기: lstrip(),rstrip(),strip()

txt = " 양쪽에 공백이 있는 문자열입니다. "
ret1 = txt.lstrip()
ret2 = txt.rstrip()
ret3 = txt.strip()

print('<' + ret1 + '>')
print('<' + ret2 + '>')
print('<' + ret3 + '>')

lstrip() 메서드를 사용하여 문자열의** 왼쪽에 있는 공백을 제거합니다. rstrip() 메서드를 사용하여 문자열의 **오른쪽에 있는 공백을 제거합니다. strip()메서드를 사용하여 문자열 양쪽에 있는 공백을 제거합니다.

output:

<양쪽에 공백이 있는 문자열입니다. >
< 양쪽에 공백이 있는 문자열입니다.>
<양쪽에 공백이 있는 문자열입니다.>

각 결과 문자열 앞 뒤에 <, >가 추가되었고, lstrip()는 왼쪽의 공백을 제거하고, rstrip()는 오른쪽의 공백을 제거하며, strip()은 양쪽의 공백을 제거한 것을 확인할 수 있습니다.

문자열의 모든 공백을 없애기 위해서는 replace() 메서드를 사용할 수 있습니다. replace() 메서드는 문자열 내의 특정 패턴을 다른 문자열로 대체하는 역할을 합니다.

🧡 문자열 모든 공백을 없애려면?~?

txt = " 양쪽에 공백이 있는 문자열입니다. "
ret = txt.replace(" ", "")

print(ret)

output:

"양쪽에공백이있는문자열입니다."

replace(" ", "")에서 첫 번째 인자로는 대체할 패턴을 지정하고, 두 번째 인자로는 대체할 문자열을 지정합니다. 위의 예시에서는 공백을 빈 문자열 ""로 대체하였습니다.

따라서, replace() 메서드를 활용하여 모든 공백을 제거할 수 있습니다.

6️⃣ 문자열 조합하기

🧡 분리하기 : split()

url = "http://www.naver.com/news/today=20230524"
log = 'name:이감자 age:8 sex:남자 nation:한국'

ret1 = url.split('/')
print(ret1)

ret2 = log.split()
print(type(ret2))
for data in ret2:
    d1, d2 = data.split(':')
    print('%s -> %s' % (d1, d2))

split() 메서드를 사용하여 url 문자열을 /을 기준으로 분리한 결과를 ret1 변수에 할당합니다. ret1은 분리된 문자열들을 원소로 갖는 리스트가 됩니다. print(ret1)을 통해 ret1 리스트를 출력하면 분리된 각 부분은 _리스트의 원소로 출력_됩니다.

output:

['http:', '', 'www.naver.com', 'news', 'today=20230524']
<class 'list'>
name -> 이감자
age -> 8
sex -> 남자
nation -> 한국

🧡 결합하기 :join()

loglist = ["2023/05/24 14:43:??", '500', "no", '이 또한 지나가리라~_~']
bond = ';'
log = bond.join(loglist)
print(log)
print(type(log))

join() 메서드를 사용하여 loglist의 각 요소들을 bond 구분자로 결합한 결과를 log 변수에 할당합니다.

output:

2023/05/24 14:43:??;500;no;이 또한 지나가리라~_~
<class 'str'>

log 변수에는 loglist의 요소들이 ";"로 구분되어 결합된 문자열이 저장되어 있습니다. type(log)를 통해 log의 데이터 타입을 확인하면 <class 'str'>로 문자열임을 알 수 있습니다.

7️⃣ encode()

a_txt = "I love Gamja"
b_txt = a_txt.encode()

print(a_txt)
print(b_txt)
print(type(b_txt))
ret1 = 'I' == a_txt[0]
ret2 = 'I' == b_txt[0]
print(ret1)
print(ret2)

encode() 메서드를 사용하여 a_txt 문자열을 바이트로 인코딩한 결과를 b_txt 변수에 할당합니다. print(type(b_txt))를 통해 b_txt의 데이터 타입을 출력합니다. b_txt는 바이트 객체이므로 <class 'bytes'> 가 출력됩니다.

output:

I love Gamja
b'I love Gamja'
<class 'bytes'>
True
False

'I' == b_txt[0]는 b_txt의 첫 번째 바이트가 'I'인지를 비교하여 False를 반환합니다. 이는 'I'가 바이트 형태로 인코딩되었기 때문입니다.

8️⃣ 문자열 정렬하기

🧡 sorted()

strdata=input("정렬할 문자를 입력하세요>")
ret1=sorted(strdata)
ret2=sorted(strdata,reverse=True)

print(ret1)
print(ret2)

ret1=''.join(ret1)
ret2=''.join(ret2)
print("오름차순으로 정렬된 문자열은 <"+ret1+"> 입니다.")
print("내림차순으로 정렬된 문자열은 <"+ret2+"> 입니다.") 

sorted() 함수를 사용하여 strdata 문자열을 _오름차순_으로 정렬한 결과를 ret1 변수에 저장합니다. 이때, sorted() 함수의 reverse 매개변수를 기본값인 False로 설정하여 오름차순 정렬을 수행합니다. sorted() 함수를 사용하여 strdata 문자열을 _내림차순_으로 정렬한 결과를 ret2 변수에 저장합니다. 이때, reverse 매개변수를 True로 설정하여 내림차순 정렬을 수행합니다.

join() 메서드를 사용하여 정렬된 문자열 리스트를 다시 하나의 문자열로 결합합니다.

output:

예시 입력: "openai"
['a', 'e', 'i', 'n', 'o', 'p']
['p', 'o', 'n', 'i', 'e', 'a']
오름차순으로 정렬된 문자열은 <aeinop> 입니다.
내림차순으로 정렬된 문자열은 <poniea> 입니다.

9️⃣ index()

solarsys=["화성",'태양',"지구",'금성',"목성",'토성']
planet="지구"
pos=solarsys.index(planet)
solarsys[pos]="천왕성"
print(solarsys)

index() 메서드를 사용하여 solarsys 리스트에서 "지구"의 위치를 찾습니다. index() 메서드는 해당 원소가 리스트에서 처음으로 등장하는 인덱스를 반환합니다. 이 인덱스를 pos 변수에 저장합니다. pos 변수를 사용하여 solarsys 리스트에서 "지구"를 "천왕성"으로 _변경_합니다. 리스트의 해당 위치에 새로운 값을 대입하여 변경합니다.

output:

  ['화성', '태양', '천왕성', '금성', '목성', '토성']

🔟 리스트 슬라이싱

🧡 리스트[1::2]

🧡 리스트[1:2]

listdata=list(range(1,21))
evenlist=listdata[1::2]
eeeelist=listdata[1:2]
print(evenlist)
print(eeeelist)

listdata는_ 1부터 20까지의 숫자로 구성된 리스트_입니다. evenlist는 listdata에서 짝수 인덱스에 해당하는 원소들로 이루어진 새로운 리스트입니다. 이를 위해 슬라이싱을 활용하였는데, listdata[1::2]는 인덱스 1부터 끝까지의 원소들을 2의 간격으로 선택하는 것을 의미합니다. 따라서 evenlist에는 listdata의 1, 3, 5, ..., 19번 인덱스에 해당하는 원소들이 저장됩니다. eeeelist는 listdata에서 인덱스 1부터 2까지의 원소들로 이루어진 새로운 리스트입니다. 슬라이싱을 활용하여 listdata[1:2]를 선택하였는데, 이는 인덱스 1부터 1번 인덱스까지의 원소를 선택하는 것입니다. 따라서 eeeelist에는 listdata의 1번 인덱스에 해당하는 원소가 저장됩니다.

output:

[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
[2]

evenlist에는 listdata의 짝수 번째 원소들이 저장되어 있고, eeeelist에는 listdata의 1번 인덱스에 해당하는 원소만 저장되어 있음을 확인할 수 있습니다.

🔟 + 1️⃣ 리스트 순서 뒤집기

🧡 reverse 🆚 reversed

reverse와 reversed는 리스트의 순서를 뒤집는 데에 사용되는 기능이지만 사용 방식과 동작 방식에서 차이가 있습니다.

reverse는 리스트의 메서드로, 리스트를** 원본을 변경**하며 역순으로 뒤집습니다. reverse 메서드는 리스트를 직접 수정하여 뒤집는 것이기 때문에 원본 리스트가 변경됩니다. 따라서 reverse 메서드를 호출한 후에는 해당 리스트의 원소들이 역순으로 변경되며 반환값은 없습니다.

• 예시: list.reverse()

reversed는 내장 함수로, 리스트를 변경하지 않고 새로운 이터레이터를 반환합니다. 이 이터레이터는 원본 리스트의 역순으로 순회할 수 있도록 합니다. reversed 함수를 사용하여 리스트를 역순으로 순회하려면 list 함수로 변환하여 사용하거나, for 루프 등에서 직접 이터레이터를 활용해야 합니다.

• 예시: reversed_list = list(reversed(my_list)) 또는 for item in reversed(my_list):

요약하면, reverse는 원본 리스트를 직접 변경하고 반환값이 없으며, reversed는 원본 리스트를 변경하지 않고 역순으로 순회할 수 있는 이터레이터를 반환합니다. 따라서 사용 목적과 상황에 맞게 선택하여 사용해야 합니다.

listdata1=list(range(5))
listdata1.reverse()

listdata2=list(range(5))
ret1=reversed(listdata2)
print("원본 리스트",end="")
print(listdata2)
print("역순 리스트",end='');print(list(ret1))

ret2=listdata2[::-1]
print('슬라이싱 이용',end='');print(ret2)

listdata1은_ 0부터 4까지의 숫자로 구성된 리스트_입니다. reverse()메서드를 사용하여 원본 리스트를 역순으로 뒤집습니다. listdata1.reverse()를 호출하면 listdata1 리스트가 원본을 변경하며 역순으로 저장됩니다. listdata2는 0부터 4까지의 숫자로 구성된 리스트입니다. reversed() 함수를 사용하여 리스트를 역순으로 순회하는 이터레이터를 반환합니다. 이를 ret1 변수에 저장합니다. list(ret1)을 사용하여 이터레이터를 리스트로 변환합니다. 이때 역순으로 뒤집힌 리스트가 생성됩니다.

🧡 리스트[::-1]

ret2는 슬라이싱을 사용하여 리스트를 역순으로 뒤집은 결과입니다. listdata2[::-1]을 사용하여 리스트의 모든 원소를 역순으로 선택합니다. 이를 ret2 변수에 저장합니다.

output:

원본 리스트[0, 1, 2, 3, 4]
역순 리스트[4, 3, 2, 1, 0]
슬라이싱 이용[4, 3, 2, 1, 0]

• reverse() 메서드, reversed() 함수, 슬라이싱을 이용한 방법 모두 원본 리스트의 순서를 역순으로 바꾸는 역할을 수행합니다.

  ---

🔟 + 2️⃣ 리스트 값 추가하기

🧡 append()

listdata=[]
for i in range(3):
    txt=input('리스트에 추가할 값을 입력하세요[%d/3]:'%(i+1))
    listdata.append(txt)
    print(listdata)

listdata는 빈 리스트로 초기화됩니다. 반복문을 통해 3번의 입력을 받습니다. input() 함수를 사용하여 사용자로부터 값을 입력받습니다. 입력된 값은 txt 변수에 저장됩니다. listdata.append(txt)를 사용하여 입력받은 값을 리스트에 추가합니다. 현재까지의 리스트 상태를 출력하기 위해 print(listdata)를 사용하여 리스트를 출력합니다.

output:

리스트에 추가할 값을 입력하세요[1/3]:Hello
['Hello']
리스트에 추가할 값을 입력하세요[2/3]:World
['Hello', 'World']
리스트에 추가할 값을 입력하세요[3/3]:OpenAI
['Hello', 'World', 'OpenAI']

반복문을 통해 사용자로부터 입력받은 값들이 순차적으로 리스트에 추가되는 것을 확인할 수 있습니다.

🧡 index()

solarsys=["지구",'태양','금성',"목성",'화성',"해왕성"]
pos=solarsys.index('목성')
solarsys.insert(pos,"소행성")
print(solarsys)

index()메서드를 사용하여 '목성' 원소의 위치를 찾습니다. pos 변수에 해당 위치가 저장됩니다. insert() 메서드를 사용하여 '목성' 원소의 위치에 '소행성'을 삽입합니다. solarsys.insert(pos, "소행성")을 호출하면 '목성' 앞에 '소행성'이 추가됩니다.

output:

  ['지구', '태양', '금성', '소행성', '목성', '화성', '해왕성']

🔟 + 3️⃣ 리스트 값 빼기

🧡 del()

solarsys=["지구",'태양','금성',"목성",'화성',"해왕성"]
del solarsys[0]
print(solarsys)
del solarsys[-2]
print(solarsys)


solarsys=["지구",'태양','금성',"목성",'화성',"해왕성"]
solarsys.remove("지구")
print(solarsys)

del 키워드를 사용하여 인덱스를 지정하여 원소를 제거하는 방법: del solarsys[0]를 호출하여 첫 번째 원소를 삭제합니다. 결과를 출력합니다. del 키워하여드를 사용 음수 인덱스를 지정하여 원소를 제거하는 방법: del solarsys[-2]를 호출하여 뒤에서 두 번째 원소를 삭제합니다. 결과를 출력합니다.

🧡 remove()

remove() 메서드를 사용하여 값을 기준으로 원소를 제거하는 방법: solarsys.remove("지구")를 호출하여 "지구" 원소를 삭제합니다. 결과를 출력합니다.

output:

['태양', '금성', '목성', '화성', '해왕성']
['태양', '금성', '목성', '화성']
['태양', '금성', '목성', '화성', '해왕성']

세 가지 방법을 사용하여 리스트에서 원소를 제거한 결과를 확인할 수 있습니다. 첫 번째 방법과 두 번째 방법은 인덱스를 기준으로 원소를 삭제하고, 세 번째 방법은 값을 기준으로 원소를 삭제합니다.

1️⃣ 클래스(Class)

class MyClass:
    var="hi"
    def sayHello(self):
        print(self.var)

obj=MyClass()
print(obj.var)
obj.sayHello()

MyClass 클래스의 생성자를 사용하여 obj라는 객체를 생성합니다. obj.var을 사용하여 obj의 var 속성에 접근하고 출력합니다. 마지막으로 obj.sayHello()를 호출하여 obj의 sayHello() 메서드를 실행하면 "hi"가 콘솔에 출력됩니다.

위 코드를 실행하면 다음과 같은 결과가 출력됩니다:

output :

hi
hi

2️⃣ 클래스 멤버 vs 인스턴스 멤버

클래스 멤버와 인스턴스 멤버는 클래스 내에서 사용되는 변수 **또는 속성**을 나타냅니다.

💛클래스 멤버(Class Member):

클래스 멤버는 클래스 자체에 속하는 변수이며, 모든 인스턴스에서 공유됩니다. 클래스 정의 _내부에서 선언_되며, 모든 인스턴스에 의해 공유되어 동일한 값을 가지게 됩니다. 클래스 멤버는 클래스명.멤버명으로 접근할 수 있습니다.

예시:

class MyClass:
    class_variable = "I am a class variable"

obj1 = MyClass()
obj2 = MyClass()

print(obj1.class_variable)  # 출력: I am a class variable
print(obj2.class_variable)  # 출력: I am a class variable

💛인스턴스 멤버(Instance Member):

인스턴스 멤버는 클래스의 각 인스턴스마다 개별적으로 소유하는 변수입니다. 즉, 인스턴스마다 고유한 값을 가질 수 있습니다. 인스턴스 멤버는 인스턴스 생성 후 self.멤버명으로 접근할 수 있습니다.

예시:

class MyClass:
    def __init__(self):
        self.instance_variable = "I am an instance variable"

obj1 = MyClass()
obj2 = MyClass()

print(obj1.instance_variable)  # 출력: I am an instance variable
print(obj2.instance_variable)  # 출력: I am an instance variable

클래스는 특정 속성(attribute)과** 메서드(method)**를 가지며, 이러한 속성과 메서드는 해당 클래스의 인스턴스에 의해 공유됩니다. 클래스의 인스턴스를 생성하면 해당 인스턴스는 클래스의 속성과 메서드를 갖게 되고, 이를 통해 데이터를 저장하고 기능을 실행할 수 있습니다.

예를 들어, MyClass라는 클래스를 정의하면 MyClass는 특정 속성과 메서드를 가지게 됩니다. 이후 obj = MyClass()와 같이 클래스의 인스턴스를 생성하면 obj는 MyClass의 속성과 메서드를 가진 개별 객체가 됩니다. 이 인스턴스는 클래스의 정의에 따라 데이터를 저장하고 메서드를 실행할 수 있습니다.

따라서, 클래스는 객체를 생성하기 위한 템플릿이며, 인스턴스는 실제로 생성된 개별 객체를 의미합니다. 인스턴스는 클래스의 속성과 메서드를 공유하면서 독립적인 데이터와 상태를 가질 수 있습니다.

class MyClass:
    var="hi"
    def sayHello(self):
        print(self.var)

obj=MyClass()
print(obj.var)
obj.sayHello()

• self 가 뭐야 ?

self는 파이썬에서 인스턴스 메서드를 정의할 때 사용되는 특별한 매개변수입니다. self는 현재 객체(인스턴스) 자신을 참조하는데 사용되며, 해당 객체의 속성이나 메서드에 접근할 수 있게 해줍니다.

예를 들어, MyClass 클래스의 sayHello 메서드에서 self.var을 사용하면 해당 메서드를 호출한 인스턴스의 var 속성에 접근할 수 있습니다. self는 호출된 인스턴스를 가리키므로, 각 인스턴스마다 고유한 var 값을 사용할 수 있습니다.

따라서, obj=MyClass()으로 인스턴스를 생성하고 obj.sayHello()를 호출하면 sayHello 메서드 내에서 self.var은 obj의 var 속성을 의미하게 됩니다.

output:

hi
hi

class MyClass:
    def sayHello():
        print("안녕하세요!")

    def sayBye(name):
        print("%s! 다음에 또 보자!!"%name)

obj=MyClass()
obj.sayHello()
obj.sayBye(묭시리)

• 에러가 난 이유

위의 코드에서 오류가 발생하는 이유는 메서드 정의 시 첫 번째 매개변수로 self를 명시하지 않았기 때문입니다. 파이썬에서 클래스의 메서드는 첫 번째 매개변수로 항상 self를 가지는데, 이를 통해 메서드가 호출된 인스턴스를 참조할 수 있습니다.

올바른 코드는 다음과 같이 self를 사용하여 메서드를 정의해야 합니다:

class MyClass:
    def sayHello(self):
        print("안녕하세요!")

    def sayBye(self, name):
        print("%s! 다음에 또 보자!!" % name)

obj = MyClass()
obj.sayHello()
obj.sayBye("묭시리")

output:

안녕하세요!
묭시리! 다음에 또 보자!!

class MyClass:
    def __init__(self):
        self.var="안뇽"
        print('MyClass 인스턴스 객체가 생성됨 ~_~')

obj=MyClass()
print(obj.var) 

__init__ 메서드는 파이썬에서 클래스의 생성자로 사용되며, 인스턴스가 생성될 때 자동으로 호출됩니다. 위 코드에서 MyClass 클래스의 init 메서드는 인스턴스가 생성될 때 실행되어 self.var 속성을 "안뇽"으로 초기화하고, "MyClass 인스턴스 객체가 생성됨 _"을 출력합니다.

다음으로 obj=MyClass()을 통해 MyClass의 인스턴스인 obj를 생성하고, obj.var을 출력합니다. 이때 obj.var은 MyClass 인스턴스의 var 속성에 접근하는 것이며, init 메서드에서 초기화된 "안뇽"이 출력됩니다.

output:

MyClass 인스턴스 객체가 생성됨 ~_~
안뇽

3️⃣ 클래스 생성자(__init__())

클래스의 생성자는 클래스의 인스턴스가 생성될 때 호출되는 특별한 메서드입니다. 생성자 메서드는 init()으로 정의되며, 클래스 내부에서 정의됩니다.

생성자는 인스턴스가 생성될 때 초기화 작업을 수행하는 역할을 합니다. 주로 인스턴스의 속성(attribute)을 초기화하거나, 필요한 설정을 수행하는 등의 작업을 담당합니다. 생성자는 인스턴스 객체가 생성될 때 자동으로 호출되며, 인스턴스를 초기화하는데 사용됩니다.

일반적으로 생성자는 다음과 같이 정의됩니다:

def __init__(self, 매개변수1, 매개변수2, ...):
    # 초기화 작업 수행
    # self를 통해 인스턴스의 속성을 설정

self는 생성되는 인스턴스 자체를 나타내는 매개변수입니다. 이를 통해 생성자 내부에서 인스턴스의 속성을 설정하거나, 다른 메서드를 호출할 수 있습니다. 생성자에서 정의된 속성은 인스턴스의 다른 메서드에서도 접근할 수 있습니다.

예를 들어, 다음과 같이 MyClass 클래스에 생성자를 정의할 수 있습니다:

class MyClass:
    def __init__(self, name):
        self.name = name
        print("인스턴스가 생성되었습니다.")

# MyClass의 인스턴스 생성
obj = MyClass("John")

위 코드에서 init 메서드는 self와 name이라는 매개변수를 가지고 있습니다. 이 생성자는 인스턴스 객체가 생성될 때 호출되어 self.name 속성을 name 매개변수로 초기화합니다. 마지막으로 "인스턴스가 생성되었습니다."라는 메시지가 출력됩니다.

이렇게 생성자를 사용하면 인스턴스를 생성할 때 필요한 초기화 작업을 수행할 수 있습니다. 생성자를 통해 인스턴스의 속성을 초기화하고, 인스턴스가 생성될 때 자동으로 실행되는 과정을 제어할 수 있습니다.

클래스의 인스턴스 생성이란, 클래스를 기반으로하여 실제로 객체를 만드는 과정을 말합니다. 클래스는 객체를 생성하기 위한 템플릿이라고 생각할 수 있고, 인스턴스는 이 템플릿을 기반으로 구체적인 개별 객체를 만드는 것입니다.

예를 들어, 다음과 같이 Person이라는 클래스를 정의합니다:

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

위의 코드에서 Person 클래스는 name과 age라는 속성을 가지고 있습니다. 이제 이 클래스를 기반으로하여 인스턴스를 생성해보겠습니다:

person1 = Person("John", 25)
person2 = Person("Jane", 30)

위 코드에서 person1과 person2는 Person 클래스의 인스턴스입니다. Person 클래스의 생성자(init 메서드)를 호출하여 인스턴스를 생성하고, 해당 인스턴스는 name과 age라는 속성을 가지게 됩니다.

이제 각 인스턴스는 독립적인 데이터를 가지며, 해당 인스턴스의 속성에 접근할 수 있습니다. 예를 들어, person1.name은 "John"을 반환하고, person2.age는 30을 반환합니다.

클래스의 인스턴스 생성을 통해 동일한 클래스를 기반으로 여러 개의 개별 객체를 만들 수 있습니다. 각 인스턴스는 클래스의 속성과 메서드를 공유하면서 독립적인 데이터와 상태를 가질 수 있습니다.

4️⃣ 클래스 소멸자(__del__())

클래스 소멸자는 객체가 메모리에서 제거되기 전에 호출되는 특별한 메서드입니다. 소멸자 메서드는 __del__()로 정의되며, 클래스 내부에서 정의됩니다.

소멸자는 객체가 더 이상 필요하지 않을 때 수행해야 할 정리 작업을 처리하는 데 사용됩니다. 예를 들어, 파일이나 네트워크 연결과 같은 외부 자원을 사용하는 경우, 소멸자를 활용하여 해당 자원을 안전하게 종료하거나 해제할 수 있습니다.

일반적으로 소멸자는 다음과 같이 정의됩니다:

def __del__(self):
    # 정리 작업 수행
    # 메모리 해제, 파일 닫기 등

소멸자는 객체가 메모리에서 제거될 때 자동으로 호출되며, 개발자가 직접 호출하지 않습니다. 객체의 수명이 끝나면 파이썬 인터프리터가 자동으로 소멸자를 호출합니다.

다음은 소멸자의 예시입니다:

class MyClass:
    def __init__(self, name):
        self.name = name

    def __del__(self):
        print(f"인스턴스 {self.name}이(가) 소멸되었습니다.")

# MyClass의 인스턴스 생성
obj1 = MyClass("인스턴스 1")
obj2 = MyClass("인스턴스 2")

# obj1과 obj2의 참조를 제거하여 메모리에서 제거
del obj1
del obj2

위 코드에서 __del__ 메서드는 인스턴스가 소멸될 때 호출되어 인스턴스의 이름을 출력합니다. del 키워드를 사용하여 obj1과 obj2의 참조를 제거하면, 이후 파이썬 인터프리터가 해당 인스턴스들의 소멸자를 자동으로 호출합니다.

소멸자를 사용하면 객체가 소멸될 때 필요한 추가 작업을 수행할 수 있으며, 메모리 누수 등의 문제를 방지할 수 있습니다. 그러나 일반적으로는 소멸자를 직접 사용할 필요가 없으며, 파이썬의 가비지 컬렉터가 자동으로 메모리 관리를 처리해주기 때문에 명시적으로 메모리를 해제해야 할 때에만 사용하는 것이 좋습니다.

class Add:
    def add(self,n1,n2):
        return n1+n2

class Calculator(Add):
    def sub(self,n1,n2):
        return n1-n2

obj=Calculator()
print(obj.add(1,2))
print(obj.sub(1,2))

• self 가 없으면 ?

self는 현재 객체를 가리키는 참조입니다. 클래스의 인스턴스 메서드를 호출할 때 self 매개변수를 통해 객체 자체를 전달합니다. self를 사용하여 클래스 내부의 속성이나 다른 메서드에 접근할 수 있습니다.

만약 self가 없는 경우, 해당 메서드는 인스턴스 메서드가 아닌 클래스 메서드(static method)로 간주됩니다. 클래스 메서드는 특정 객체에 바인딩되지 않고 클래스 자체에 속해 있으며, self를 통한 객체 참조가 없습니다. 클래스 메서드는 @staticmethod 데코레이터를 사용하여 정의되며, 클래스의 모든 인스턴스가 공유하는 동작을 수행합니다.

따라서, 위의 예제에서 self가 없는 add 메서드는 클래스 메서드로 간주됩니다. 이 경우, obj.add(1, 2)와 같이 인스턴스를 통해 호출하면 오류가 발생할 수 있습니다. obj 객체를 통해 클래스 메서드를 호출하려면 클래스 이름을 사용해야 합니다.

아래는 add 메서드를 클래스 메서드로 수정한 예시입니다:

class Add:
    @staticmethod
    def add(n1, n2):
        return n1 + n2

class Calculator(Add):
    def sub(self, n1, n2):
        return n1 - n2

obj = Calculator()
print(Calculator.add(1, 2))  # 클래스 메서드 호출
print(obj.sub(1, 2))

add 메서드를 @staticmethod로 데코레이팅하고, obj.add(1, 2) 대신 Calculator.add(1, 2)와 같이 클래스를 통해 호출하면 올바르게 동작합니다. sub 메서드는 여전히 인스턴스 메서드이므로 obj.sub(1, 2)와 같이 인스턴스를 통해 호출할 수 있습니다.

5️⃣ 상속

상속은 객체 지향 프로그래밍에서 클래스 간의 관계를 나타내는 개념입니다. 한 클래스가 다른 클래스의 특성과 동작을 상속받아 사용할 수 있도록 해줍니다. 상속은 코드 재사용성을 높이고 클래스 간의 계층 구조를 형성하여 코드를 구조화하는 데 도움을 줍니다.

예를 들어, "동물"이라는 클래스가 있다고 가정해봅시다. 이 클래스는 모든 동물의 공통 특성과 동작을 포함할 수 있습니다. 그리고 "개"라는 클래스와 "고양이"라는 클래스가 있을 때, 이 두 클래스는 "동물" 클래스를 상속받을 수 있습니다. 이렇게 상속을 받은 클래스들은 "동물" 클래스의 특성과 동작을 자동으로 상속받아 사용할 수 있습니다.

다중 상속은 한 클래스가 두 개 이상의 클래스로부터 상속받는 것을 의미합니다. 예를 들어, "개" 클래스가 "포유류" 클래스와 "애완동물" 클래스로부터 다중 상속을 받을 수 있습니다. 이 경우 "개" 클래스는 "포유류" 클래스의 특성과 동작, 그리고 "애완동물" 클래스의 특성과 동작을 모두 상속받아 사용할 수 있습니다.

다중 상속은 유용한 기능이지만 클래스 간의 복잡한 관계를 만들 수 있고 충돌이 발생할 수도 있으므로 주의해야 합니다. 충돌이 발생하는 경우 메서드나 속성의 우선순위를 결정해야 할 필요가 있습니다. 이러한 경우에는메서드 해상도 순서(Method Resolution Order, MRO)라는 규칙을 따라 _우선순위를 결정_합니다.

다중 상속의 예시는 다음과 같습니다:

class Mammal:
    def walk(self):
        print("Walking")

class Pet:
    def play(self):
        print("Playing")

class Dog(Mammal, Pet):
    pass

dog = Dog()
dog.walk()  # "Walking" 출력
dog.play()  # "Playing" 출력

위의 예시에서 "Dog" 클래스는 "Mammal" 클래스와 "Pet" 클래스로부터 다중 상속을 받습니다. 그래서 "Dog" 객체는 "walk()" 메서드와 "play()" 메서드를 모두 사용할 수 있습니다.

class Add:
    def add(self,n1,n2):
        return n1+n2

class Multiply:
    def multiply(self,n1,n2):
        return n1*n2

class Calculator(Add,Multiply):
    def sub(self,n1,n2):
        return n1-n2

obj=Calculator()
print(obj.add(1,2))
print(obj.multiply(2,3))

💛 다중상속

위의 예시 코드는 다중 상속을 보여줍니다. "Add" 클래스와 "Multiply" 클래스는 각각 덧셈과 곱셈 기능을 제공합니다. 그리고 "Calculator" 클래스는 "Add" 클래스와 "Multiply" 클래스를 다중 상속받습니다. 이렇게 "Calculator" 클래스는 덧셈과 곱셈, 그리고 뺄셈 기능을 모두 가지고 있습니다.

output:

3
6

첫 번째 줄은 "add()" 메서드를 호출하여 1과 2를 더한 결과인 3을 출력합니다. 두 번째 줄은 "multiply()" 메서드를 호출하여 2와 3을 곱한 결과인 6을 출력합니다.

이처럼 다중 상속을 사용하면 여러 개의 클래스로부터 특성과 동작을 상속받아 하나의 클래스에서 모든 기능을 사용할 수 있습니다.

1️⃣ 예외 객체 (Exception object)

예외 객체 (Exception object)는 파이썬에서 예외가 발생할 때 생성되는 객체입니다. 예외가 발생하면 해당 예외의 종류에 따라 예외 객체가 생성되고 예외 정보를 담고 있습니다. 이 예외 객체에는 예외의 유형, 메시지, 발생 위치 등과 같은 정보가 포함됩니다.

예외 객체는 try-except 블록에서 예외 처리를 위해 사용될 수 있습니다. 예외가 발생하면 프로그램 흐름이 try 블록에서 except 블록으로 이동하게 되고, 이때 예외 객체가 except 블록의 매개변수로 전달됩니다. 이를 통해 개발자는 예외 객체를 사용하여 예외 정보를 확인하고 적절한 조치를 취할 수 있습니다.

예를 들어, ValueError 예외가 발생한 경우 except ValueError as e:와 같이 as 키워드를 사용하여 예외 객체를 e와 같은 변수에 할당할 수 있습니다. 그러면 e 변수를 통해 예외 객체의 속성에 접근하고 예외 정보를 확인할 수 있습니다. 일반적으로 예외 객체의 속성으로는 예외 메시지를 나타내는 args, 예외가 발생한 파일과 라인 정보를 담고 있는 filename 및 lineno 등이 있습니다.

예외 객체를 사용하면 예외 처리 과정에서 발생한 문제를 진단하고 디버깅하는 데 도움이 됩니다. 예외 객체의 속성을 검사하거나 예외 객체를 다시 발생시키는 등의 작업을 수행할 수 있습니다.

🟡예외가 발생하면 예외 정보가 생기고 예외 정보는 예외 객체에 저장된다❗

🟡Exception object

try: 
    number_input_a=int(input("정수 입력>"))

    print("원의 반지름:",number_input_a)
    print("원의 둘레:",number_input_a*3.14*2)
    print("원의 넓이:",number_input_a**2*3.14)
except Exception as exception:

    print("type(exception):",type(exception))
    print("exception:",exception)

except Exception as exception: : 예외가 발생했을 때 처리하기 위한 except 블록을 시작합니다. Exception은 모든 예외 클래스의 기본 클래스이며, 모든 예외를 처리할 수 있습니다. as exception은 발생한 예외 객체를 exception 변수에 할당합니다. print("type(exception):", type(exception)) : 예외 객체의 타입을 출력합니다. 이는 어떤 종류의 예외가 발생했는지를 확인하는 데 도움이 됩니다. print("exception:", exception) : 예외 객체의 내용을 출력합니다. 이는 예외에 관련된 메시지 또는 정보를 확인하는 데 도움이 됩니다. invalid literal for int() with base 10은 int() 함수에 잘못된 형식의 문자열이 전달되었을 때 발생하는 예외 메시지입니다.

2️⃣ 예외 구분하기

예외 객체를 ㅅ ㅏ용하면 except 구문을 if 조건문처럼 사용해서 예외를 구분할 수 있습니다.

🟡 여러가지 예외가 발생할 수 있는 code

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

try:
    number_input=int(input("정수 입력:"))
    print("{}번째 요소:{}".format(number_input,list_number[number_input]))
except Exception as exception:
    print("type(exception):",type(exception))
    print("exception:",exception)

정상적으로 정수를 입력한 경우:

정수로 변환될 수 없는 값을 입력한 경우:

정수를 입력했지만, 리스트 길이를 넘는 경우:

🟡 예외 구분하기

list_number=[52,273,13,62,803]

try:
    number_input=int(input("정수 입력:"))

    print("{}번째 요소: {}".format(number_input,list_number[number_input]))
except ValueError:
    print("정수를 입력하세요!!")
except IndexError:
    print("리스트 인덱스를 벗어 났어요!!")

예외 객체는 except 블록에서 예외가 발생하면 생성되는 객체입니다. except 키워드 뒤에 예외의 종류를 지정한 후 as 키워드를 사용하여 예외 객체를 받을 변수를 지정할 수 있습니다.

try:
    number_input=int(input("정수 입력:"))

    print("{}번째 요소: {}".format(number_input,list_number[number_input]))
except ValueError as ve:
    print("정수를 입력하세요!!")
    print("exception:",ve)
except IndexError as ie:
    print("리스트 인덱스를 벗어 났어요!!")
    print("exception:",ie)

3️⃣ 모든 예외 잡기

 list_number=[52,273,13,62,803]

try:
    number_input=int(input("정수 입력:"))

    print("{}번째 요소: {}".format(number_input,list_number[number_input]))
    예외.발생()
except ValueError as exception:
    print("정수를 입력하세요!!")
    print(type(exception),exception)
except IndexError as exception:
    print("리스트 인덱스를 벗어 났어요!!")
    print(type(exception),exception)
except Exception as exception:
    print("미리 파악하지 못한 예외발생!")
    print(type(exception),exception)

🟡 raise 구문

number=input("정수 입력:")
number=int(number)

if number>0:
    raise NotImplementedError
else:
    raise NotImplementedError

파이썬에서 raise 구문은 예외를 발생시키는 데 사용됩니다. 예외는 프로그램 실행 중에 발생하는 오류나 예외적인 상황을 나타냅니다. raise 구문은 개발자가 명시적으로 예외를 발생시켜 특정 상황에 대한 처리를 수행하거나, 오류를 전파하여 예외 처리 메커니즘을 통해 오류를 처리할 수 있도록 합니다.

def divide(a, b):
    if b == 0:
        raise ValueError("0으로 나눌 수 없습니다.")
    return a / b

try:
    result = divide(10, 0)
except ValueError as e:
    print(e)

위의 예제에서 divide 함수는_ b가 0일 때 ValueError 예외를 발생_시킵니다. 호출자는 try-except 구문을 사용하여 이 예외를 처리하고, 해당 예외의 메시지를 출력합니다.

try:
    file=open('info','w')
    예외.발생해라()
    file.close()

except Exception as e:
    print(e)

print("#파일이 제대로 닫혔는지 확인하기")
print("file.close:",file.closed)

결과

🌊🌊🌊 except Exception as e: 구문은 예외 처리를 위해 사용되는 구문입니다. 이 구문은 다음과 같은 의미를 가지고 있습니다. try 블록 안에서 예외가 발생하면, 해당 예외를 Exception 클래스의 인스턴스로 생성합니다. as e는 생성된 예외 인스턴스를 변수 e에 할당합니다. except 블록 안의 코드가 실행되며, 예외 처리 로직이 구현됩니다.예외 처리가 완료되면 프로그램의 흐름은 except 블록 다음의 코드로 이동합니다. 따라서, except Exception as e: 구문은 예외가 발생했을 때 해당 예외를 잡고, e라는 변수에 할당하여 추가적인 처리를 수행할 수 있도록 합니다. 이 변수를 활용하여 예외의 정보를 출력하거나 처리하는 등의 작업을 수행할 수 있습니다.

2️⃣ finally 구문 사용해서 파일 닫기

try:
    file=open('infp.txt','w')
    예외.발생해라()

except Exception as e:
    print(e)
finally:
    file.close()

print("#파일이 제대로 닫혔는지 확인하기")
print("file.close:",file.closed)

결과

3️⃣try 구문 내부에서 return 키워드 사용하는 경우

def test():
    print("test() 함수의 첫 줄입니다.")
    try:
        print("try 구문이 실행되었습니다.")
        return
        print("try 구문의 return 키워드 뒤입니다.")
    except:
        print("except 구문이 실행되었습니다.")
    else:
        print("else 구문이 실행되었습니다.")
    finally:
        print("finally 구문이 실행되었습니다.")
    print("test() 함수의 마지막 줄입니다.")

test()    

결과

finally 구문이 실행됩니다. finally 블록은 예외 발생 여부에 상관없이 항상 실행됩니다. 따라서 "finally 구문이 실행되었습니다."라는 문자열을 출력합니다. "test() 함수의 마지막 줄입니다."라는 문자열은 출력되지 않습니다. 이미 return 문에 의해 함수가 종료되었기 때문입니다. ㄟ( ▔, ▔ )ㄏ

def write_text_file(filename,text):
    try:
        file=open(filename,"w")
        return
        file.write(text)
    except Exception as e:
        print(e)
    finally:
        file.close()

write_text_file("test.txt","hi!")

finally 구문에 close() 함수를 호출하도록 코드를 작성하면 코드가 깔끄매집니다. ㄟ( ▔, ▔ )ㄏ

4️⃣반복문과 함께 사용하는 경우

finally 구문은 무조건 실행됩니다. 따라서 반복문에서 break로 빠져나갈 때도 마찬가지입니당.

while True:
    try:
        print("try 구문이 실행되었습니다.")
        break
        print("try 구문의 break 키워드 뒤입니다.")
    except:
        print("excep 구문이 실행되었습니다.")
    finally:
        print("finally 구문이 실행되었습니다.")
    print("while 반복문의 마지막 줄입니다.")
print("프로그램이 종료 되었습니다.")

결과

finally 구문이 실행됩니다.** finally 블록은 예외 발생 여부에 상관없이 항상 실행됩니다.** 따라서 "finally 구문이 실행되었습니다."라는 문자열을 출력합니다. "while 반복문의 마지막 줄입니다."라는 문자열은 출력되지 않습니다. 이미 break 문에 의해 while 반복문이 종료되었기 때문입니다. "프로그램이 종료되었습니다."라는 문자열이 출력됩니다.

5️⃣ index()함수

number=[52,373,4,62,845,91,20]
print(number.index(52))   #결과 0
print(number.index(4))    #결과 2

index() 함수는 문자열이나 리스트와 같은 _시퀀스 타입_에서 특정 요소의 인덱스를 반환하는 함수입니다.ㄟ( ▔, ▔ )ㄏ

문자열에서 index() 함수를 사용하면 특정 문자열 또는 문자의 인덱스를 반환합니다. 예를 들어, "Hello, World!".index("o")와 같이 호출하면 문자열 "Hello, World!"에서 첫 번째로 나타나는 문자 'o'의 인덱스인 4를 반환합니다.

리스트에서 index() 함수를 사용하면 특정 요소의 인덱스를 반환합니다. 예를 들어, my_list = [1, 2, 3, 4, 5]라는 리스트가 있다고 가정하면, my_list.index(3)과 같이 호출하면 요소 3의 인덱스인 2를 반환합니다.

index() 함수는 찾고자 하는 요소가 시퀀스에 없을 경우** ValueError** 예외를 발생시킵니다. 따라서, index() 함수를 사용할 때는 예외 처리를 고려해야 합니다.

my_string = "Hello, World!"
index = my_string.index("o")
print(index)  # 출력: 4

my_list = [1, 2, 3, 4, 5]
index = my_list.index(3)
print(index)  # 출력: 2

# 예외 처리
try:
    index = my_string.index("z")
    print(index)
except ValueError:
    print("찾는 요소가 시퀀스에 없습니다.")

💜 오류는 크게 실행 전에 발생하는 '구문 오류(syntax error)'와 실행 후에 발생하는 '예외(exception)'로 구분할 수 있습니당. 이때 예외는 프로그램이 정상적으로 실행되는 것처럼 보이다가 중간에 프로그램을 죽게 만들어 버립니다! 따라서 "예외 처리 (exception handling)"로 예외를 처리해야합니다 ❗

프로그래밍에서 오류(Error)는 크게 두 가지 종류가 있습니당.

• 프로그램 실행 전에 발생하는 오류 : 구문 오류(syntax error)
• 프로그램 실행 중에 발생하는 오류 : 예외(exception) 또는 런타임 오류(Runtime Error)

구문 오류는 코드가 컴파일되는 과정에서 발견되며, 보통 컴파일러나 인터프리터가 이를 바로 알려줍니다. 이러한 오류는 프로그래머가 코드를 작성하는 중에 발생하며, 코드의 오타, 잘못된 문법 등으로 인해 발생합니다.

반면, 실행 시간 오류는 코드가 실행되는 과정에서 발생합니다. 이러한 오류는 보통 예상치 못한 입력값이나 연산 등으로 인해 발생합니다. 예를 들어, 0으로 나누기 오류(Division by Zero Error), 인덱스 범위 초과(Index Out of Range Error) 등이 있습니다.

예외(Exception)는 오류와는 다른 개념으로, 실행 시간에 예기치 않은 상황이 발생하여 프로그램이 중단되는 것을 말합니다. 예를 들어, 파일을 열고 읽는 도중 파일이 없거나 접근 권한이 없는 경우 등이 있습니다. 이러한 예외 상황은 프로그램에서 적절히 처리되지 않으면 프로그램이 강제 종료될 수 있습니다.

파이썬에서는 예외 처리를 위해 try-except문을 제공합니다. try 블록 안에는 예외가 발생할 가능성이 있는 코드를 넣고, except 블록 안에는 예외를 처리하는 코드를 넣습니다. 만약 try 블록 안에서 예외가 발생하면, 해당 예외를 처리하기 위해 except 블록이 실행됩니다.

예를 들어, 다음 코드에서는 try 블록 안에서 1/0이라는 연산을 수행하면 ZeroDivisionError 예외가 발생합니다. 이 예외는 except 블록에서 처리되어 프로그램이 강제 종료되지 않습니다.

try:
    result = 1/0
except ZeroDivisionError:
    print("0으로 나눌 수 없습니다.")

또한, except 블록에서 예외를 처리한 후에는 finally 블록이 실행됩니다. finally 블록 안에는 예외와 상관없이 반드시 실행되어야 하는 코드를 넣습니다.

try:
    result = 1/0
except ZeroDivisionError:
    print("0으로 나눌 수 없습니다.")
finally:
    print("프로그램 종료")

1️⃣ 구문 오류(Syntax error)

구문 오류는 괄호의 개수, 들여쓰기 문제 등으로 인해 프로그램 실행되기도 전에 발생하는 오류입니다.

print("안녕하세요)

2️⃣ 예외(exception) or 런타임 오류(Runtime Error)

실행 중에 발생하는 오류

3️⃣ 예외 처리(exception handling)

• 조건문을 사용하는 방법 (= 기본 예외 처리)
• try except 구문을 사용하는 방법

💜 조건문으로 예외 처리하기

user_input_a=input("정수입력>")

if user_input_a.isdigit():
    number_input_a=int(user_input_a)

    print("원의 반지름:",number_input_a)
    print("원의 둘레:",number_input_a*3.14*2)
    print("원의 넓이:",number_input_a**2*3.14)
else:
    print("정수를 입력하지 않았습니당~ ")

isdigit()은 문자열이 숫자인지 아닌지를 판별하는 파이썬 내장 함수입니다. 문자열의 모든 문자가 숫자인 경우에만 True를 반환하며, 아니면 False를 반환합니다.isdigit() 함수는** 문자열이 숫자로 이루어져 있는지 검사할 때 자주 사용**되며, 예를 들어 사용자로부터 입력받은 값이 숫자인지 아닌지를 판별할 때 유용하게 사용할 수 있습니다.

💜 try except 구문을 사용하는 방법

1. try -except

   try:
    number_input_a=int(input("정수입력>"))
    print("원의 반지름:",number_input_a)
    print("원의 둘레:",number_input_a*3.14*2)
    print("원의 넓이:",number_input_a**2*3.14)
   except:
    print("무언가 잘못되어잇움")

2. try -except pass

   list_input_a=["23","4","666","감자","쿠키","111"]
   

list_number=[] for item in list_input_a: try: float(item) list_number.append(item) except: pass

print("{} 내부에 있는 숫자는".format(list_input_a)) print("{} 입니다.".format(list_number))

```pass```는 파이썬에서 **아무런 동작도 하지 않는 구문**입니다. 일반적으로 아무런 작업을 하지 않아야 하지만, 문법적으로 구문이 필요하다면 pass 구문을 사용합니다.

try-except 구문에서 pass를 함께 사용하는 경우는, 예외가 발생했을 때 처리해야 할 작업이 없는 경우입니다. 이런 경우 except 블록에서 pass 구문을 사용하여 아무런 작업을 하지 않고 그냥 넘어갈 수 있습니다.


3. ```try -except -else```

try: number_input_a=int(input("정수입력>")) except: print("정수를 입력하지 않았습니다/") else: print("원의 반지름:",number_input_a) print("원의 둘레:",number_input_a3.142) print("원의 넓이:",number_input_a*23.14)

 ![](https://velog.velcdn.com/images/gamja-kawaii/post/12f58f7f-5ec1-46ef-b610-14452b33dfd5/image.JPG)

4. ```try- except -else -finally```

try: number_input_a=int(input("정수입력>")) print("원의 반지름:",number_input_a) print("원의 둘레:",number_input_a3.142) print("원의 넓이:",number_input_a*23.14) except : print("정수를 입력하지 않앗움") else: print("예외가 발생하지 않앗움") finally: print("일단 프로그램이 끝낫움")

![](https://velog.velcdn.com/images/gamja-kawaii/post/2ae5a745-4572-445e-a86a-e77ba428970f/image.JPG)


---------
### 4️⃣ close()
```closed```는 파일 객체의 속성 중 하나로, 파일 객체가 현재 닫혀있는지 여부를 나타냅니다.

파일 객체를 열었다면, 이 파일 객체는 반드시 언젠가는 닫혀야 합니다. 만약 파일 객체가 닫혀있지 않으면, 파일을 계속 사용할 수 없게 됩니다.

closed 속성은 True나 False 값을 가지며, 파일 객체가 닫혀있을 경우 True, 닫혀있지 않을 경우 False를 반환합니다. 파일 객체를 닫을 때는```close()``` 메서드를 호출하여 닫을 수 있으며, 파일 객체를 닫은 후에는 closed 속성 값이 True가 됩니다.

아래는 파일 객체를 생성하고, 파일을 닫은 후 closed 속성 값을 출력하는 예시 코드입니다.

f = open('example.txt', 'r')

파일 작업 수행

f.close() print(f.closed) # True

_파일이 제대로 닫혔는지 확인하기 ❗_

try: file=open("info,txt","w",encoding="utf-8") file.close() except Exception as e: print(e)

print("# 파일이 제대로 닫혔는지 확인하기") print("file.closed:",file.closed)

except Exception as e``` : 구문은 예외 처리를 위한 파이썬의 문법 중 하나입니다. 이 구문은 try 블록에서 예외가 발생했을 때, 발생한 예외의 종류에 상관없이 모든 예외를 처리합니다.

Exception은 모든 예외의 부모 클래스입니다. 즉, 모든 예외 클래스들은 Exception 클래스를 상속받으므로, except Exception 구문은 모든 예외를 처리할 수 있습니다.

as e는 예외 객체를 변수 e에 할당하는 것을 의미합니다. 이를 통해 예외 객체의 속성을 확인하거나 출력할 수 있습니다. 이를 이용하면 예외 처리 과정에서 발생한 오류를 정확하게 파악하고, 디버깅할 수 있습니다.

💜 항상 켜져 있는 프로그램을 데몬(demon) 또는 서비스(service)라고 부릅니다. 예를들어, 컴퓨터의 성능을 감시하는 프로그램, 파일의 변경을 감시하는 프로그램, 사용자에게 웹 페이지를 제공해 주는 웹 서버 등

💛 텍스트 한줄씩 읽기

텍스트를 사용해 데이터를 구조적으로 표현할 수 있는 방법으로 CSV,XML,JSON등이 있습니당!

1. CSV: CSV는 쉼표로 구분된 값(Comma Separated Values)을 의미합니다. 이는 표 형식으로 데이터를 저장하기 위한 파일 형식입니다. CSV 파일에서 각 줄은 하나의 레코드를 나타내며, 쉼표로 구분된 각 열은 해당 레코드의 속성을 나타냅니다. 예를 들어, 이름, 성별, 나이와 같은 정보를 각 열에 저장하여 CSV 파일에 저장할 수 있습니다.

첫 번째 줄에 header를 넣어 각 데이터가 무엇을 나타내는지 설명해 줄 수 있습니다! 🔥 최근 기계 학습등에는 이러한 형태로 수십만 명의 데이터를 저장하고 활용하는 경우가 많습니다.

2. XML: XML은 확장 가능한 마크업 언어(Extensible Markup Language)를 의미합니다. 이는 데이터를 구조화하고 전송하기 위한 파일 형식입니다. XML 파일에서 각 요소는 해당 데이터의 속성을 나타내며, 중첩된 요소는 데이터의 계층 구조를 나타냅니다. XML은 데이터를 사람이 이해하기 쉽게 표현할 수 있으며, 다양한 용도로 사용됩니다.

3. JSON: JSON은 JavaScript 객체 표기법(JavaScript Object Notation)을 의미합니다. 이는 데이터를 저장하고 전송하기 위한 파일 형식으로, JavaScript 객체와 유사한 구조를 가지고 있습니다. JSON 파일에서 데이터는 중괄호로 묶인 키-값 쌍으로 표현됩니다. 이러한 구조는 데이터를 효율적으로 전송하고 해석할 수 있으며, 웹 애플리케이션에서 자주 사용됩니다.

#💛 랜덤하게 1000명의 키와 몸무게 만들기

import random
hanguls=list("가나다라마바사아자차카타파하")
with open("info.txt","w",encoding='utf-8') as file:
    for i in range(1000):
        name=random.choice(hanguls)+random.choice(hanguls)
        weight=random.randrange(40,100)
        height=random.randrange(140,200)

        file.write("{},{},{}\n".format(name,weight,height))

import random은 파이썬에서 무작위 숫자를 생성하기 위한 모듈인 random을 가져오는 구문입니다. random 모듈은 난수 생성 및 무작위 선택과 같은 다양한 기능을 제공합니다.

예를 들어, random 모듈을 사용하여 0부터 1 사이의 난수를 생성하려면 random.random()을 호출합니다. 이 외에도, random.randint(a, b)를 사용하여 a와 b 사이의 정수 난수를 생성하거나, random.choice(seq)를 사용하여 시퀀스(seq) 중에서 무작위로 하나의 요소를 선택할 수 있습니다.

따라서 import random 구문을 사용하면 이러한 무작위 숫자 생성 함수를 사용할 수 있습니다.

위 코드를 실행하면 0부터 9까지의 임의의 정수가 출력됩니다 ❗ random.randint(a, b) 함수는 a와 b 사이의 정수를 무작위로 선택하여 반환합니다.

위 코드를 실행하면 my_list에서 임의로 하나의 요소가 선택되어 출력됩니다. random.choice(seq) 함수는 시퀀스(seq)에서 임의의 요소를 선택하여 반환합니다.

🍓 파일에 쓰는 데이터가 한글이 포함된 경우, 파일을 작성할 때 인코딩 방식을 지정해야 합니다. 예를 들어, 파일을 UTF-8 인코딩으로 작성하려면 다음과 같이 코드를 수정할 수 있습니다.

with open('output.txt', 'w', encoding='utf-8') as file:
    file.write("{},{},{}\n".format(name,weight,height))

위 코드에서 encoding='utf-8' 매개변수를 사용하여 파일을 UTF-8 인코딩으로 작성하도록 설정하였습니다. 따라서 한글 데이터가 포함되어 있어도 파일을 정상적으로 작성할 수 있습니다.

💛 join()

join()은 문자열 메서드 중 하나로, 문자열 리스트를 하나의 문자열로_ 결합_하는 기능을 제공합니다.

.join()메서드는 문자열을 구성하는 리스트에 적용되며, 각 문자열 사이에 구분자(delimiter)를 추가하여 하나의 문자열로 결합합니다!

fruits = ["apple", "banana", "cherry"]
result = ", ".join(fruits)
print(result)        # 結果 ：  "apple, banana, cherry"

number=[1,2,3,4,5,6]
print("::".join(str(num) for num in number))

• complex 함수를 사용하여 직접 생성하기:

 a = complex(2, 3)  # 2 + 3j
 b = complex(0, -1) # -j

• 수식으로 생성하기:

  c = 1 + 2j
  d = 4j - 3

  복소수형 자료는 실수부와 허수부로 이루어져 있으며, 허수부 뒤에 " j " 를 붙여서 나타냅니다. 예를 들어, 2 + 3j는 실수부가 2이고 허수부가 3인 복소수형 자료입니다. 복소수형 자료는 산술 연산도 가능합니다.

real과 imag은 파이썬 복소수형 자료의 속성(attribute)으로, 각각 해당 복소수형 자료의 실수부(real part)와 허수부(imaginary part)를 반환합니다.

예를 들어, z = 2 + 3j라는 복소수형 자료가 있을 때, z.real은 2를 반환하고, z.imag은 3을 반환합니다.

z = 2 + 3j
print(z.real) # 출력 결과: 2.0
print(z.imag) # 출력 결과: 3.0

🙄💭 true and false

a=True
b=False
print(a==1)  # 출력 결과: True
print(a!=1)  # 출력 결과: False
print(b==0)  # 출력 결과: True
print(b!=0)  # 출력 결과: False

• true and false:코드에 무한루프 로직 구현할때 🙄💭

while True:
    (무한반복 실행코드)
    ...
    if 조건==True:
        break

💘 문자열 관계연산자

str1='chips';str2='orange'
print(str1<str2)        # 출력 결과: True


if len("apple") < len("banana"):
    print("apple is shorter than banana")
else:
    print("banana is shorter than apple")

print("chips"<"apple")  # 출력 결과: False
print('Age'<'age')      # 출력 결과: True
print('age'<'Bag')      # 출력 결과: False
print('alle'<='alla')   # 출력 결과: False
print('한글'>'english')  # 출력 결과: True

Python에서 문자열 크기 비교 연산자는 일반적으로 문자열의 사전 순서를 기반으로 :알파벳 순서(사전에서 단어가 정렬되는 순서) 비교를 수행합니다. 즉, 두 문자열이 사전에서 어떻게 정렬되는지를 비교하여 크기를 결정합니다. 예를 들어, "apple"은 "banana"보다 작지만 "ant"는 "apple"보다 크다는 것입니다. ant < apple < banana

사전순서는 알파벳의 순서에 따라 단어를 정렬합니다. 알파벳 순서는 A, B, C, ..., Z의 순서로 구성되어 있으며, 대문자와 소문자를 구분합니다. 따라서, 대문자 A는 소문자 a보다 앞서며, Z는 a보다 앞서게 됩니다. 예를 들어, "Apple"은 "apple"보다 앞서게 됩니당.

⚠ 문자열의 길이만을 기준으로 비교하는 것은 아닙니다. 문자열 길이를 비교하려면 Python의 len() 함수를 사용하여 각 문자열의 길이를 비교할 수 있습니다. 예를 들어, "apple"과 "banana"의 길이를 비교하려면 다음과 같이 하면 됩니다:

if len("apple") < len("banana"):
    print("apple is shorter than banana")
else:
    print("banana is shorter than apple")

💖 비트 연산자 (&,|,~,^,>>,<<)

#(&,|,~,^,>>,<<)
bit1=0x61  
bit2=0x62
print(hex(bit1&bit2))  # 출력 결과: 0x60
print(hex(bit1|bit2))  # 출력 결과: 0x63
print(hex(~bit1))      # 출력 결과: -0x62
print(hex(bit1^bit2))  # 출력 결과: 0x3
print(hex(bit1>>1))    # 출력 결과: 0x30
print(hex(bit1<<2))    # 출력 결과: 0x184

파이썬에서 비트 연산자는 다양한 상황에서 사용될 수 있습니다. 주로 아래와 같은 경우에 사용합니다.

• 비트 단위로 데이터를 처리해야 하는 경우:

  이진수로 표현된 데이터를 비트 연산자를 사용하여 처리할 수 있습니다. 예를 들어, 비트 AND(&) 연산자를 사용하여 두 이진수의 각 자릿수에서 1이 모두 있는 경우에만 1을 반환하고, 그 외에는 0을 반환할 수 있습니다.

• 암호화와 보안 분야에서 사용: 암호화와 보안 분야에서 비트 연산자는 데이터를 암호화하고, 보안을 강화하는 데 사용됩니다. 예를 들어, 데이터를 XOR 연산자로 암호화하거나, 암호화된 데이터를 다시 복호화할 때 비트 연산자를 사용할 수 있습니다.

• 하드웨어 제어: 하드웨어를 제어할 때 비트 연산자를 사용하는 경우가 있습니다. 예를 들어, 특정 비트를 ON 또는 OFF 상태로 설정하여 하드웨어를 제어할 수 있습니다.

• 게임 프로그래밍: 게임 프로그래밍에서는 비트 연산자를 사용하여 게임 오브젝트의 위치와 상태 등을 처리할 수 있습니다. 예를 들어, 게임 오브젝트의 이동 방향을 비트 연산자를 사용하여 결정할 수 있습니다.

파이썬에서 사용하는 비트 연산자의 종류와 사용 방법은 다음과 같습니다.

(1) 비트 AND(&) 연산자: 두 비트가 모두 1인 경우에만 1을 반환합니다.

a = 0b1101
b = 0b1011
c = a & b
print(bin(c))  # 출력값: 0b1001

(2) 비트 OR(|) 연산자: 두 비트 중에 하나 이상이 1인 경우에 1을 반환합니다.

a = 0b1101
b = 0b1011
c = a | b
print(bin(c))  # 출력값: 0b1111

(3) 비트 XOR(^) 연산자: 두 비트가 서로 다른 경우에만 1을 반환합니다.

a = 0b1101
b = 0b1011
c = a ^ b
print(bin(c))  # 출력값: 0b0110

(4) 비트 NOT(~) 연산자: 모든 비트를 반전합니다. 0은 1로, 1은 0으로 변환됩니다.

a = 0b1101
b = ~a
print(bin(b))  # 출력값: -0b1110

(5) 왼쪽 시프트(<<) 연산자: 모든 비트를 왼쪽으로 이동시킵니다. 이동한 빈 자리는 0으로 채워집니다.

a = 0b1101
b = a << 2
print(bin(b))  # 출력값: 0b110100

(6) 오른쪽 시프트(>>) 연산자: 모든 비트를 오른쪽으로 이동시킵니다. 이동한 빈 자리는 원래 비트 값과 동일한 값으로 채워집니다.

a = 0b1101
b = a >> 2
print(bin(b))  # 출력값: 0b0011

비트 연산자는 주로 이진수로 표현된 데이터를 다룰 때 사용됩니다. 이진수를 다룰 때는 0b 접두어를 사용하여 이진수임을 나타냅니다. 예를 들어, 0b1101은 이진수로 13을 나타냅니다.

🙄💭 비트 연산자 <<와 >>

<<는 왼쪽 시프트(Left Shift) 연산자이며, 모든 비트를 왼쪽으로 이동시킵니다. 이동한 빈 자리는 0으로 채워집니다. 예를 들어, 0b0010 << 1 연산을 수행하면 0b0100이 됩니다.

>>는 오른쪽 시프트(Right Shift) 연산자이며, 모든 비트를 오른쪽으로 이동시킵니다. 이동한 빈 자리는 원래 비트 값과 동일한 값으로 채워집니다. 예를 들어, 0b0100 >> 1 연산을 수행하면 0b0010이 됩니다.

즉, <<와 >>의 차이점은 이동 방향과 이동한 빈 자리를 채우는 값입니다 ❗❗

💖 시퀀스 자료형

파이썬에서 시퀀스(Sequence) 자료형은 데이터 요소들을 일렬로 나열한 형태의 자료형입니다. 시퀀스 자료형은 다음과 같은 특징을 가집니다.

• 인덱싱(Indexing): 각 요소에 대해 인덱스를 통해 접근할 수 있습니다. 인덱스는 0부터 시작하며, 음수 인덱스를 사용하여 끝에서부터 요소에 접근할 수 있습니다.
• 슬라이싱(Slicing): 일부 요소들을 잘라서 가져올 수 있습니다. 슬라이싱은 시작 인덱스, 끝 인덱스, 그리고 스텝(step) 값으로 구성됩니다.
• 연결(Concatenation): 두 개 이상의 시퀀스 자료형을 연결할 수 있습니다.+연산자 이용 반복(Repetition): 시퀀스 자료형의 요소들을 여러 번 반복할 수 있습니다. *연산자 사용
• 멤버체크 : in 키워드 사용 ->특정값이 시퀀스자료의 요소로 속해 있는지 확인 할수있다.
• 길이 확인: 시퀀스 자료형의 길이(요소의 개수)를 확인할 수 있습니다. [ len()이용 시퀀스자료형 크기는 문자열의 경우 문자의 개수, 리스트와 튜플의 경우에는 멤버의 개수 ]

< 파이썬에서의 시퀀스 자료형>

문자열(String): 문자들의 시퀀스입니다. 리스트(List): 임의의 객체들의 시퀀스입니다. 튜플(Tuple): 리스트와 유사하지만 변경이 불가능한(immutable) 시퀀스입니다. range: 정수들의 시퀀스입니다. range() 함수를 사용하여 생성할 수 있습니다. 바이트(Byte): 0부터 255까지의 정수들의 시퀀스입니다. 바이트 리터럴(b'hello')이나 bytes() 함수를 사용하여 생성할 수 있습니다. 바이트 배열(Bytearray): 바이트와 유사하지만 변경이 가능한(mutable) 시퀀스입니다. bytearray() 함수를 사용하여 생성할 수 있습니다. 문자열 포맷팅(String Formatting)은 문자열 안에 변수나 값의 정보를 삽입하기 위해 사용되는 기술입니다. 문자열 포맷팅은 파이썬에서 간편하게 사용할 수 있습니다.

strdata='abcde'  # 문자열 
listdata=[1,[2,3],"hi"] # 리슽
tupledata=(100,200,300) # 튶플

(1) 기호를 사용하는 방법

가장 간단한 문자열 포맷팅 방법은 % 기호를 사용하는 것입니다. 이 방법은 C 언어에서 사용되는 방법과 유사합니다.

• 정수 값 포맷팅

  x = 10
  print("x 값은 %d 입니다." % x)

• 문자열 포맷팅

  name = "Alice"
  print("내 이름은 %s 입니다." % name)

• 믹수 포맷팅

  age = 25
  print("%s의 나이는 %d살입니다." % (name, age))

txt1="java";txt2='Python'
num1=5;num2=10
print("나는%s보다%s이 더 좋!"%(txt1,txt2))
print("내 기준 : %s가 %s보다 %d배 어려운거같엉 ㅠㅠ.."%(txt1,txt2,num1))
print('%d + %d = %d'%(num1,num2,num1+num2))
print("작년 세계 경재 성장률은 전년에 비해 %d%%포인트 증가했다"%num1)

(2) format() 함수를 사용하는 방법

format() 함수를 사용하여 문자열 포맷팅을 할 수도 있습니다. 이 방법은 % 기호를 사용하는 방법보다 더 유연하고 가독성이 좋습니다.

• 정수 값 포맷팅

  x = 10
  print("x 값은 {} 입니다.".format(x))

• 문자열 포맷팅

  name = "Alice"
  print("내 이름은 {} 입니다.".format(name))

• 여러 값 포맷팅

  age = 25
  print("{}의 나이는 {}살입니다.".format(name, age))

  (3) f-string을 사용하는 방법

  f-string을 사용하여 문자열 포맷팅을 할 수도 있습니다.

• 정수 값 포맷팅

  x = 10
  print(f"x 값은 {x} 입니다.")

• 문자열 포맷팅

  name = "Alice"
  print(f"내 이름은 {name} 입니다.")

• 여러 값 포맷팅

  age = 25
  print(f"{name}의 나이는 {age}살입니다.")

💚 시퀀스 자료형 : indexing

strdata="I want money!"
listdata=[1,[2,3],4,5]
print(strdata[5])
print(strdata[-2])
print(listdata[0])
print(listdata[-3])
print(listdata[1][-1])

💚 시퀀스 자료형 : 슬라이싱

strdata="우리집_고양이_이감자"
print(strdata[1:5])
print(strdata[:7])
print(strdata[9:])
print(strdata[:-3])
print(strdata[-3:])
print(strdata[:])
print(strdata[::2])

💚 시퀀스 자료형 : 연결

strdata1='diamond';strdata2="ruby"
strdata3='gold'
listdata1=[1,2,3];listdata2=[2,3,4,5]
print(strdata1+strdata2)
print(strdata1+strdata3)
print(listdata1+listdata2)
print(listdata2+listdata1)

💚 시퀀스 자료형 : 반복

a='감자'
b="차오츄르"
data=a+"가 외칩니다:"+b*3
print(data)

💚 시퀀스 자료형 : 크기

strdata1="I Love You~"
strdata2="You Love Me!"
listdata=["choco",'vanilla',"peanut",strdata1,strdata2]
print(len(strdata1))
print(len(strdata2))
print(len(listdata))
print(len(listdata[3]))

💚 멤버체크 in

listdata=[1,2,3,4]
ret1=5 in listdata;ret2=4 in listdata
print(ret1);print(ret2)
strdata='abcde'
ret3="c" in strdata
ret4="f" in strdata
print(ret3);print(ret4)

🙄💭🙄💭🙄💭🙄💭🙄💭🙄💭🙄💭🙄💭🙄💭🙄💭🙄💭🙄💭🙄💭🙄💭🙄💭🙄💭

from time import sleep은 time 모듈에서 sleep 함수를 import하는 구문입니다. sleep 함수는 프로그램을 일정 시간 동안 멈추게 해주는 함수입니다.

sleep 함수는 float 또는 int 형태의 인자를 받아 프로그램을 해당 시간 동안 멈춥니다. 예를 들어, sleep(2)를 실행하면 프로그램이 2초 동안 멈추게 됩니다. 이 함수는 주로 프로그램이나 스크립트를 실행하는 도중 특정한 시간 간격을 두고 작업을 수행하도록 할 때 사용됩니다.

아래는 sleep 함수를 사용한 간단한 예시 코드입니다.

from time import sleep

print("작업 시작")
sleep(5) # 5초 동안 멈춤
print("5초 후에 이 문장이 출력됩니다.")

위 코드에서 sleep(5) 구문이 실행되면 프로그램이 5초 동안 멈추고, 이후 다음 문장이 출력됩니다.

from time import sleep
for i in range(100):
    msg="\r 진행률 %d%%"%(i+1)
    print(" "*len(msg),end="")
    print(msg,end='')
    sleep(0.1)

해당 코드는 0부터 99까지 반복하는 for 루프 안에서 진행률을 출력하는 코드입니다.

"\r"은 커서를 해당 줄의 맨 앞으로 이동시키는 이스케이프 시퀀스입니다. 따라서 매 반복마다 진행률을 출력하기 위해 커서를 맨 앞으로 이동시키고, 진행률 정보를 출력합니다. end=""는 print 함수가 출력한 내용의 끝에 아무것도 출력하지 않도록 하는 인자입니다.

" "*len(msg) 구문은 진행률 정보를 출력하기 전에 해당 줄을 지우기 위해 진행률 정보 출력 문자열의 길이만큼 공백을 출력합니다. 이를 통해 이전에 출력한 진행률 정보가 지워지고, 새로운 진행률 정보가 출력됩니다.

sleep(0.1) 구문은 0.1초 동안 대기하는 함수입니다. 이를 통해 각각의 진행률 정보가 출력된 후 0.1초 동안 대기하고, 다음 진행률 정보를 출력합니다.

따라서 위 코드를 실행하면 총 100개의 진행률 정보가 출력되며, 각각의 정보는 0.1초 간격으로 출력됩니다. 모든 진행률 정보는 한 줄에 출력되며, 이전에 출력한 진행률 정보는 공백을 출력하여 지워지고, 새로운 진행률 정보가 출력됩니다.

💝파이썬 예약어 확인하는 방법 💝

파이썬 프롬프트에서

import keyword
keyword.kwlist 

파이썬에서 주로 다루게 되는 자료형은 5가지입니다!~! 1️⃣ 수치형 자료 2️⃣ 문자열 자료 3️⃣ 리스트 자료 4️⃣ 튜플 자료 5️⃣ 사전(dict)자료

💟 수치형 자료

• 정수형 상수:-1,0,1,등등
• 실수형 상수: 무리수를 포함하는 실수
• 복소수형 상수: 실수부+허수부로 구성 (파이썬에서 허수부는 j로 표현하는것에 주의의으ㅣ!)

  complex_data=1+5j

  💟 리스트 자료

  list_data=[1,2,3]

  💟 튜플 자료 리스트와 비슷하지만 요소 값을 변경 할 수 없당!

  tuple_data=(1,2,3)

  💟 사전(dict) 자료 {"키:값",...}으로 된 쌍이 요소로 구성된 순서가 없는 자료형

  dict_data={0:'false',1:'true'}

  dict_data={'a':97,'b':98}
  print(dict_data['a'])        #output: 97

🤍end="" print("#") print("#")

print('#',end="") print("#")

listdata=[1,2,3,4,5,'a']
"""
if 'a' in listdata:
    print("'a'가 리스트 안에 있습니다.")
else:
    print("'a'가 리스트 안에 없습니다.")
"""

💜#indentation 들여쓰기 spacebar (or) tab으로 가능

실행코드가 한 라인일 경우는 💜if 'a' in listdata:print('"a"가 리스트 안에 있습니') 이렇게 쓸 수 있습니당.근데 실행코드는 한 라인 이상인 경우가 대부분이라서 콜론(:)다음에 enter를 눌러 들여쓰기를 해야합니다_

if '1' in listdata:print('1이 리스트 안에 있습니')

if '2' in listdata:
    print('2가 리스트 안에 있습니다')

• binary file은 컴퓨터에서 사용되는 데이터를 이진(binary) 형태로 저장하는 파일입니다. 즉, 이진 형태로 데이터가 저장되어 있기 때문에, 일반적인 텍스트 파일과는 다르게 사람이 직접 읽을 수 없습니다.binary file은 이미지 파일, 음악 파일, 동영상 파일 등과 같이, 비문자 데이터를 저장하는 데 사용됩니다. 이러한 파일들은 일반적으로 텍스트 파일과는 달리, 특정 형식으로 구성되어 있으며, 파일 내부에 있는 데이터가 특정한 규칙을 따라 구성되어 있습니다.

지금은 text file 과 관련된 내용만 적겠숩니당 ..❗❗

file=open("basic.txt","w")
file.write("hello Python Prigrammming T,T")
file.close()

파이썬을 사용하여 파일을 다루는 방법에는 여러 가지가 있지만, 가장 기본적인 방법은 내장 함수 open()을 사용하여 파일 객체를 생성하고, 이 객체를 사용하여 파일을 읽고 쓰는 것입니다.

아래는 파일 처리의 기본적인 방법을 설명하는 예시입니다.

🧡 파일 열기

파일을 열 때에는 open() 함수를 사용합니다. 이 함수는 _파일 경로와 파일 모드(mode)_를 인자로 받습니다. 파일 모드에는** 읽기 모드('r'), 쓰기 모드('w'), 추가 모드=뒤에 이어서 쓰기 모드 ('a') 등**이 있습니다.

f = open('file.txt', 'r') # 파일 읽기 모드로 열기

💚 파일 읽기

파일 객체를 생성한 후, read() 메서드를 사용하여 파일을 읽을 수 있습니다. read() 메서드는 파일 내용 전체를 문자열로 반환합니다.

contents = f.read() # 파일 내용 전체 읽기

with open("basic.txt","r") as file:
    contents=file.read()
print(contents)                      #output : hello Python Prigrammming T,T

💚텍스트 한줄 씩 읽기

💜 파일 쓰기

파일 객체를 생성한 후, write() 메서드를 사용하여 파일에 데이터를 쓸 수 있습니다. write() 메서드는 인자로 전달된 문자열을 파일에 씁니다.

f.write('Hello, World!') # 파일에 문자열 쓰기

🖤 파일 닫기

파일 처리가 끝나면, close() 메서드를 사용하여 파일을 닫아줘야 합니다.

f.close() # 파일 닫기

open()함수로 파일을 열면 close()함수로 파일을 닫아 주여야 합니당. 파일을 닫지 않으면, 다른 프로그램이나 프로세스에서 해당 파일을 사용할 수 없습니다. 파일 처리를 할 때에는, 파일을 열고 처리한 후에 반드시 파일을 닫아주는 것이 좋습니다. 또한, 파일 객체를 생성할 때 with 구문을 사용하여, 파일 객체를 사용한 후 자동으로 파일을 닫을 수도 있습니다. 🖤with 키워드는 파일 처리에 매우 유용하게 사용됩니다. with 문을 사용하면 파일을 열 때 자동으로 닫아주므로, 파일을 열고 닫는 일을 개발자가 직접 처리할 필요가 없습니다. 아래는 with 키워드를 사용한 파일 처리의 예시입니다:

with open('file.txt', 'r') as f:
    data = f.read()
    # 파일 내용 처리

# with 블록을 빠져나오면 파일은 자동으로 닫힘

위 코드에서 with 키워드를 사용하여 file.txt 파일을 열었습니다. 이후 with 블록 내에서 파일을 읽거나 쓰는 작업을 수행하고, with 블록을 빠져나오면 파일이 자동으로 닫힙니다. 이렇게 함으로써 파일을 처리하는 도중 예외가 발생하더라도 파일을 안전하게 닫을 수 있습니다.

file=open("basic.txt","w")
file.write("hello Python Prigrammming T,T")
file.close()

을 with 키워드로 사용하면 👇👇

with open("basic.txt","w") as  file:
    file.write("hello Python Prigrammming T,T")

람다(lambda)는 파이썬에서 함수를 간단하게 정의하는 방법 중 하나입니다. 일반적으로 람다는 이름이 없는 익명 함수로 사용되며, 함수의 입력과 출력을 정의할 수 있습니다.

람다 함수는 lambda 키워드를 사용하여 정의합니다. 일반적으로 다음과 같은 구문으로 작성됩니다:

lambda arguments: expression

여기서 arguments는 함수의 입력 인수를 나타내며, expression은 함수의 반환값을 계산하는 식입니다.

예를 들어, 다음은 lambda 함수를 사용하여 두 개의 숫자를 더하는 예제입니다:

result = sum(3, 4)
print(result)  # 7

위 예제에서 lambda 함수는 x와 y라는 두 개의 입력 인수를 받으며, x + y를 계산하여 반환합니다. 이후 sum 변수에 람다 함수를 할당하고, sum 함수를 호출하여 결과를 출력합니다.

    for i in range(10):
        func()

def print_hello():
    print("안녕하세여")

call_10_times(print_hello)  # 매개변수로 함수를 전달합니다.

💛func()는 함수를 호출하는 방법 중 하나입니다. 함수를 정의한 후에는 func()와 같이 괄호를 사용하여 함수를 호출할 수 있습니다. 함수 호출은 함수 내의 코드 블록을 실행하는 것을 의미합니다.

함수를 호출할 때 인수(argument)를 전달할 수도 있습니다. 인수는 함수의 정의에서 지정한 매개변수(parameter)에 전달됩니다. 예를 들어, 다음과 같은 함수를 정의하고 호출할 수 있습니다:

(✿◡‿◡)❤

💛greet() 함수는 name 매개변수를 받아서 "Hello, "와 name을 조합하여 출력합니다. 이후 greet() 함수를 "Alice"와 "Bob" 인수와 함께 호출하여 각각 "Hello, Alice!"와 "Hello, Bob!"을 출력합니다.

def greet(name):
    print("Hello, " + name + "!")
greet("Alice")
greet("Bob")

filter()함수와 map()함수는 파이썬의 내장 함수(=표준함수)로, 리스트 등의 시퀀스 자료형에 대해 특정한 연산을 적용하는 함수입니다.

filter(function, iterable)

💙filter() 함수는 시퀀스 자료형의 각 요소를 순회하면서, 특정 조건을 만족하는 요소들만 걸러내어 새로운 리스트를 반환합니다. function은 시퀀스 자료형의 각 요소에 대해_ 적용할 함수_를 나타내며, iterable은 _순회할 시퀀스 자료형_을 나타냅니다. function 함수는 각 요소를 인수로 받아, True 또는 False 값을 반환해야 합니다.

numbers = [1, 2, 3, 4, 5, 6]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # [2, 4, 6]

💙map() 함수는 시퀀스 자료형의 각 요소에 대해 특정 함수를 적용한 결과를 새로운 리스트로 반환합니다.

map(function, iterable)

numbers = [1, 2, 3, 4, 5, 6]
squared_numbers = list(map(lambda x: x ** 2, numbers))
print(squared_numbers)  # [1, 4, 9, 16, 25, 36]

def power(item):
    return item*item
def under_3(item):
    return item<3

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

output_a=map(power,list_input)
print(output_a)
output_b=list(map(power,list_input))
print(output_b)

output_c=filter(under_3,list_input)
print(output_c)
output_d=list(filter(under_3,list_input))
print(output_d)

def power(item):
    return item*item
def under_3(item):
    return item<3

# 위의  def 로 선언했던 함수를 lamda로 바꾸고, return 키워드를 따로  쓰지 않았다는 차이가 있습니다. 
power=lambda x:x*x
under=lambda x:x<3  

🤎 인라인 람다 함수를 한 줄로 간단하게 작성하는 것을 의미합니다. 인라인 람다 함수는 주로 map(), filter(), reduce()와 같은 함수와 함께 사용되며, 간단한 함수를 한 줄로 작성할 때 유용합니다.

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

output_a=list(map(lambda x:x*x,list_input_a))
print(output_a)
output_b=list(filter(lambda x:x<3,list_input_a))
print(output_b)

• <dl> : 정의 목록을 감싸는 태그입니다.
• <dt> : 용어(단어)를 정의할 때 사용되는 태그입니다. 일반적으로 용어를 강조하기 위해 굵은 글씨체(bold)를 사용합니다.
• <dd> : 용어에 대한 정의를 나타내는 태그입니다. 일반적으로 <dt>태그 바로 아래 위치하여 새로운 단락으로 표시됩니다.

<body>
    <dl>
        <dt>HTML</dt>
        <dd>웹 페이지를 만드는 데 사용되는 마크업 언어</dd>

        <dt>CSS</dt>
        <dd>HTML 문서의 스타일을 꾸며주는 스타일 시트 언어</dd>
    </dl>
</body>

<dl> 🆚 <dfn> <dl> 요소는 용어와 그에 대한 정의가 한 쌍으로 구성되는 목록(List)을 정의할 때 사용됩니다.<dt> 요소는 용어(Definition Term)를 나타내고,<dd> 요소는 그에 대한 정의(Definition Description)를 나타냅니다. <dfn> 요소는 용어와 그에 대한 정의를 표시할 때 사용됩니다. <dfn> 요소는 브라우저에서 이탤릭체로 표시됩니다. 아래는 <dfn> 요소를 사용하여 용어와 정의를 정의하는 예시입니다.

<body>
    <p>
        <dfn>HTML</dfn>은 웹 페이지를 만들기 위한 마크업 언어입니다.
    </p>
</body>

2️⃣ <ins>와 <del>은 HTML에서 새로운 내용을 추가하거나 기존 내용을 삭제할 때 사용되는 태그입니다.

<ins> : 새롭게 추가된 내용을 나타내는 태그입니다. 일반적으로 밑줄로 표시됩니다. <del> : 삭제된 내용을 나타내는 태그입니다. 일반적으로 가운데 선으로 표시됩니다. 예를 들어, 다음과 같은 코드를 작성하면 "HTML5"라는 내용이 추가되고 "XHTML"라는 내용이 삭제된 것을 표시할 수 있습니다.

<body>
    <p>웹 표준 문서 형식: <del>XHTML</del> <ins>HTML5</ins></p>
</body>

3️⃣ <title> 태그는 HTML 문서의 제목을 정의하는 태그입니다. 이 태그는 웹 브라우저에서 문서의 제목을 표시하는 데 사용됩니다. <title> 태그는 일반적으로 <head> 태그 안에 위치하며, 웹 페이지의 탭 제목이나 검색 엔진에서 검색 결과의 제목으로 사용됩니다. 예를 들어, 다음과 같은 코드를 작성하면 "potato_lee"라는 제목을 가진 HTML 문서가 생성됩니다.

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>potato_lee</title>
</head>

<body>
    <h1>감자는 고양이</h1>
    <p>8세</p>
</body>

</html>

4️⃣ HTML 엔티티 코드는 HTML에서 사용되는 특수 기호를 나타내기 위해 사용되는 코드입니다. 이러한 코드를 사용하면 특수 기호를 HTML에서 사용할 수 있습니다. 일부 자주 사용되는 HTML 엔티티 코드는 다음과 같습니다.

• align = left / mille =center / right

<body>
    <!-- align = left / mille =center / right -->
    <h1 align="middle">h1 : align=middle</h1>
    <h2 align="center">h2 : align=center</h2>
    <h3 align="right">h3 : align=right</h3>
    <h4 align="left">h4 : align=left</h4>
    <h5>h5</h5>
    <h6>h6</h6>
    그냥 글씨

</body>

2️⃣ <font> : HTML 코드에서 사용되는 태그로, 텍스트의 색상, 크기, 글꼴 등을 변경하는 데 사용됩니다. size, color , face(글자체) 선택할 수 있습니다. ex <font color="red">이 텍스트는 빨간색으로 표시됩니다. <font color="sky blue">이 텍스트는 하늘색+밑줄로 표시됩니다. <font color="deepblue" backcolor="black">이 텍스트는 파란색+이탤릭체로 표시됩니다.

• <b> 태그는 텍스트를 굵게 표시(bold)합니다.

• <sub>태그는 텍스트를 아래 첨자로 표시합니다. 예를 들어, H<sub>2</sub>O H₂O와 같이 사용할 수 있습니다.

• <sup> 태그는 텍스트를 위 첨자로 표시합니다. 예를 들어, x<sup>2</sup> x²와 같이 사용할 수 있습니다.

💚<font>vs<h1>💚 <font>와 <h1>은 모두 HTML 코드에서 사용되는 태그입니다. <font> 태그는 텍스트의 색상, 크기 및 글꼴 등을 변경하는 데 사용됩니다. 예를 들어, <font color="red">이 텍스트는 빨간색으로 표시됩니다.</font>와 같이 사용할 수 있습니다. 그러나 이 태그는 더 이상 권장되지 않으며, CSS 스타일 시트를 사용하여 스타일을 적용하는 것이 좋습니다. <h1> 태그는 문서의 제목을 정의하는 데 사용됩니다. 웹 페이지에서 가장 중요한 제목으로 간주되며, 일반적으로 한 페이지에서 한 번만 사용됩니다. <h1> 태그를 사용하여 제목을 정의하면 검색 엔진에서 페이지의 내용을 인덱싱하는 데 도움이 됩니다. 또한, 이 태그는 CSS 스타일 시트를 사용하여 제목의 스타일을 변경할 수 있습니다. 예를 들어, <h1 style="color: blue;">

이 텍스트는 파란색으로 표시됩니다.

3️⃣ <ruby> 태그는 일본어와 같이 다른 언어의 문자를 표시할 때 사용됩니다. 이 태그를 사용하면 병렬적으로 다른 언어의 발음이나 뜻을 표시할 수 있습니다.

<body>
    <ruby>
        <!--
        <rb>주요텍스트</rb>
        <rt>발음 또는 뜻</rt>
         -->
        <rb> 東京 </rb>
        <rt> とうきょう</rt>
    </ruby>
</body>

4️⃣ <span> 태그는 인라인 요소로, 텍스트나 이미지 등을 감싸 특정 스타일을 적용하거나, 자바스크립트를 사용하여 동적으로 변경할 때 사용됩니다.

<span> 태그에는 class, id, style 속성이 있습니다. 이들 속성은 각각 아래와 같은 역할을 합니다.

• class: 여러 개의 HTML 요소에 대해 동일한 스타일을 적용하고자 할 때 사용합니다. 즉, 동일한 스타일을 적용할 요소들을 하나의 클래스로 묶어놓고, CSS에서 그 클래스를 선택하여 스타일을 적용할 수 있습니다.

• id: HTML 요소 중에서 단 하나의 요소에 대해서만 스타일을 적용하거나, 자바스크립트를 사용하여 해당 요소를 선택하고 조작하고자 할 때 사용합니다. id는 중복해서 사용할 수 없습니다.

• style: 해당 요소에 직접 스타일을 적용하고자 할 때 사용합니다. 즉, 해당 요소에 대해 개별적으로 스타일을 적용할 때 사용합니다.

이들 속성은 서로 독립적으로 사용될 수 있지만, 같이 사용될 수도 있습니다. 예를 들어, <span> 태그에 class 속성과 style 속성을 함께 사용하여 특정 스타일을 적용할 수 있습니다.

<span class="highlight" style="color: red;">이 텍스트는 빨간색으로 스타일링되었으며, highlight 클래스를 가지고 있습니다.

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <style>
        .test {
            color: blueviolet;
        }
    </style>
</head>

<body>
    오늘날짜 :<span class="test">2023/03/27</span> HTML공부 <br>
    내일날짜 :<span class="test">2023/03/28</span> HTML공부
</body>

5️⃣ <ul> 태그는 HTML에서 "unordered list"를 의미하는 태그로, 순서가 없는 목록을 생성할 때 사용됩니다.

<body>
    다이어트 후 먹고싶은 음식
    <ul>
        <li>훠맥</li>
        <li>피맥</li>
        <li>치맥</li>
    </ul>
</body>

<ol> 태그는 HTML에서** "ordered list"**를 의미하는 태그로, 순서가 있는 목록을 생성할 때 사용됩니다.

<body>
    내가 좋아하는 동물은
    <ol type="1" start="4">
        <li>고양이</li>
        <li>호랭이</li>
        <li>감자둥이</li>
    </ol>
</body>

<body>
    내가 좋아하는 음식은
    <ol type="A">
        <li>훠궈</li>
        <li>과일</li>
        <li>쳐컬랫</li>
    </ol>
</body>

🤍🖤🖤❓

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <p>This is the first paragraph_</p>
    <p>This is the second paragraph_</p>
    <p>This is the third paragraph_<br>
        동해물과 백두산이 마르고 닳도록<br>
        하느님이 보우하사 우리나라만세~~<br>
        무궁화아 삼천리이 화려가앙산</p>
</body>

</html>

🖤<blockquote>,<pre>텍스트 형식을 변경하거나 인용문을 나타내는 데 사용되는 요소입니다. <blockquote> 요소는 인용문을 나타내며, 일반적으로 인용문 안에는 다른 소스나 작업물에서 발췌한 텍스트가 들어갑니다. <pre> 요소는 서식이 지정된(preformatted) 텍스트를 나타냅니다. 이 요소는 텍스트가 어떻게 표시되는지에 대한 공백과 줄 바꿈을 유지합니다. <pre> 요소는 일반적으로 소스 코드나 텍스트 문서를 포함한 블록 요소를 표시하는 데 사용됩니다.

🖤 HTML에서 <hr>은 문서 내에 수평선(horizontal line)을 삽입하는 데 사용되는 요소입니다. <hr>요소는 단독으로 사용하며, 시작 태그와 종료 태그를 사용하지 않습니다. 기본적으로 수평선은 문서의 가로폭 전체에 걸쳐 그려지며, 색상은 브라우저 또는 문서 스타일 시트에서 정의한 값으로 표시됩니다. color, size, width, align 등의 속성을 사용하여 수평선의 색상, 높이, 너비 및 정렬 등을 변경할 수 있습니다.

<body>
    <blockquote>
        blockquote 단락은 앞에 공간이 띄워져 있다~~
    </blockquote>
    <blockquote>
        보통 인용문 2 (다른 소스, 작업물)
    </blockquote>
    <p> 이건 p입니다 </p>
    <p> 이것도 마찬가지 입니다. </p>
    <hr>
    <hr>
    <pre>
            세칸_띄우고_쓰기
          두칸_띄우고_6쓰기
         한칸_띄우고_쓰기
    </pre>
</body>

<body>
 <!--align 따로 안적으면 가운데에 표시됨
    width = 가로 "% 나 숫자로 표현가능"  
    size = 세로 .-->
 <hr color="pink" align="left" width="60%" size="40">
 <hr color="pink" align="left" width="600" size="40">
 <hr color="sky blue"  width="50%" size="40">
 <hr color="#0099ff" align="right" width="50%" size="20">
</body>

주석 <!----> 을 사용합니다

✔🧡💛🤍🖤

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <header>
        <h1>우리집 고양이 : 감자</h1>
    </header>
    <nav>
        <ul>
            <li><a href="poem.html">2023년의 감자</a></li>
            <li><a href="poem.html">2022년의 감자</a></li>
            <li><a href="poem.html">2021년의 감자</a></li>
        </ul>
    </nav>
    <article>
        <p> 이것은 내용입니다~ 오늘 비가 많이 오고 번개가 치고 밖이 굉장히 소란스러웠다.
            그래서 오늘 감자가 많이 긴장한거같다. 지금은 내 무릎위에서 고롱고롱거리는중. 
            굉장히 딷뜻행 사랑해 감자둥잉 </p>
    </article>
    <footer>
        <p><small>2023/3/25 지구 어느곳에서 </small></p>
    </footer>
</body>

</html>

결과 :

nav 요소

문서 내비게이션 역할을 하는 요소로, 일반적으로 웹 페이지 상단에 위치하여 사용자가 사이트 내에서 필요한 정보를 쉽게 찾을 수 있도록 합니다. ex 웹 사이트의 메뉴 부분

article 요소

독립적인 콘텐츠 블록을 나타내며, 뉴스 기사, 블로그 게시물 등과 같이 하나의 주제에 대한 내용을 담고 있는 구성 요소입니다. ex 해당 메뉴에서 선택된 항목의 내용

section 요소

문서의 구획을 나타내는 요소입니다. 이 요소는 문서의 구성 요소 중 하나로, 동일한 주제나 목적을 가진 콘텐츠 블록을 그룹화합니다. 보통 section 요소는 헤딩 요소(h1 ~ h6)로 시작하여, 해당 섹션의 제목을 나타냅니다. 그리고 이어서 해당 섹션에 포함될 콘텐츠를 추가합니다.

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <section>
        <p> 츄르 종류별 링크</p>
        <nav>
            <ul>
                <li><a href="site01.html">가다랑어맛 구매처</a></li>
                <li><a href="site02.html">닥찌찌맛 구매처</a></li>
                <li><a href="site03.html">연어맛 구매처</a></li>
                <!--다른 링크도 계속 추가가능-->
            </ul>
        </nav>
    </section>
    <section>
        <p>템테이션 종류별</p>
        <!--이 곳은 템테이션 종류별 링크-->
    </section>
</body>

</html>

결과 :

HTML5의 설계 원칙은 다음과 같습니다.

1.호환성: HTML5은 이전 버전의 HTML과 호환됩니다. 기존의 HTML 문서는 HTML5로 업그레이드할 수 있습니다.

2.유연성: HTML5은 다양한 종류의 콘텐츠와 기기에서 작동할 수 있도록 설계되었습니다. 예를 들어 모바일 기기에서도 웹 페이지가 잘 작동하도록 최적화되었습니다.

3.접근성: HTML5은 웹 콘텐츠에 대한 접근성을 높이기 위한 다양한 기능을 제공합니다. 예를 들어, 시각 장애인이 화면 낭독기를 사용하여 콘텐츠를 이해할 수 있도록 alt 속성을 사용하여 이미지에 대한 설명을 제공할 수 있습니다.

4.통일성: HTML5은 새로운 요소와 표준을 추가하여 웹 페이지를 일관되게 작성할 수 있도록 하였습니다. 예를 들어, 헤더, 푸터, 내비게이션 등의 요소를 새로 추가하여 일관된 구조를 만들 수 있습니다.

5.성능: HTML5은 더 나은 성능을 위해 다양한 기능을 제공합니다. 예를 들어, 브라우저에서 동영상을 쉽게 재생할 수 있도록 video 요소를 제공하며, 로컬 스토리지를 사용하여 브라우저 캐시를 효과적으로 관리할 수 있습니다.

6.개방성: HTML5은 개방적인 표준으로 개발되었습니다. 이는 누구나 HTML5을 사용하여 웹 콘텐츠를 개발할 수 있고, 다양한 브라우저에서 작동할 수 있도록 합니다.

HTML5 의 기본 구성은 DOCTYPE, HEADER, BODY등 3부분으로 나뉩니다.

HTML Tag list : https://www.w3schools.com/tags/ Online editors for learning computer language : http://www.tutorialspoint.com/codingground.htm HTML / CSS / JS 같이 연습할 수 있는 링크! CodePen : https://codepen.io/pen/ Jsfiddle : https://jsfiddle.net/