The life of TB

OCI VM에 nginx 웹 서버 설치

techbard — Wed, 22 Apr 2026 17:15:45 +0900

OCI AMD VM (1GB RAM / 1 CPU) Nginx 설치 가이드

1. 사전 준비 — OCI 보안 그룹 설정

OCI 콘솔에서 인스턴스의 보안 목록(Security List)에 다음 규칙을 추가하세요:

방향	프로토콜	소스/대상	포트
Ingress	TCP	0.0.0.0/0	80
Ingress	TCP	0.0.0.0/0	443

OCI는 기본적으로 방화벽이 꽤 tight합니다. 이걸 안 하면 접속이 안 됩니다.

2. 시스템 업데이트

# Ubuntu/Debian 기준
sudo apt update && sudo apt upgrade -y

# Oracle Linux/RHEL 기준
sudo dnf update -y

3. Nginx 설치

Ubuntu/Debian

sudo apt install nginx -y

Oracle Linux

sudo dnf install nginx -y

4. 서비스 시작 및 자동 시작 설정

sudo systemctl start nginx
sudo systemctl enable nginx
sudo systemctl status nginx

정상이면 active (running) 이라고 나옵니다.

5. 방화벽 확인

Ubuntu (ufw)

sudo ufw allow 'Nginx Full'
sudo ufw status

Oracle Linux (firewalld)

sudo firewall-cmd --permanent --add-service=http
sudo firewall-cmd --permanent --add-service=https
sudo firewall-cmd --reload

6. 동작 확인

curl http://localhost

또는 브라우저에서 http://<공인IP> 접속 → Nginx 환영 페이지가 뜨면 성공.

7. 1GB RAM 최적화 (중요)

1GB 메모리는 빠듯하기 때문에 기본 설정을 조정해야 합니다:

sudo nano /etc/nginx/nginx.conf

worker_processes 1;          # CPU 1개이므로 1로 설정

events {
    worker_connections 256;  # 기본 1024 → 256으로 축소
}

http {
    # ... 기존 설정 유지 ...

    # 메모리 절약 설정
    client_body_buffer_size 8k;
    client_header_buffer_size 1k;
    large_client_header_buffers 2 8k;
    client_max_body_size 10m;

    # 버퍼 최적화
    output_buffers 1 32k;

    # Gzip 압축 (CPU vs 메모리 트레이드오프)
    gzip on;
    gzip_types text/plain text/css application/json application/javascript;
    gzip_min_length 256;
}

# 설정 문법 확인
sudo nginx -t

# 적용
sudo systemctl reload nginx

8. Swap 설정 (OOM 방지)

1GB RAM에서 메모리 부족 시 프로세스가 죽는 걸 방지:

sudo fallocate -l 1G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile

# 영구 적용
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab

# 확인
free -h

9. 기본 사이트 설정

sudo nano /etc/nginx/sites-available/default

server {
    listen 80;
    server_name _;

    root /var/www/html;
    index index.html;

    location / {
        try_files $uri $uri/ =404;
    }
}

sudo nginx -t
sudo systemctl reload nginx

10. SSL 인증서 (Let's Encrypt)

sudo apt install certbot python3-certbot-nginx -y   # Ubuntu
sudo certbot --nginx -d your-domain.com

자동 갱신 확인:

sudo systemctl status certbot.timer

빠른 점검 체크리스트

# 서비스 상태
systemctl is-active nginx

# 포트 리스닝 확인
ss -tlnp | grep nginx

# 메모리 사용량
ps aux | grep nginx

# 로그 확인
sudo tail -f /var/log/nginx/access.log
sudo tail -f /var/log/nginx/error.log

참고: OCI 무료 티어 AMD VM은 1GB RAM이라 트래픽이 많으면 금방 빡빡해집니다. 정적 사이트 위주로 운영하고, 동적 애플리케이션은 별도로 고려하세요.

OCI VM 공용 IP 할당하기

techbard — Wed, 22 Apr 2026 15:58:10 +0900

웹 서버 구축을 위해 OCI로 VM 생성 중에 있다.

공용 IP 할당한 것이 (임시)라고 나와서 다른 검색 결과 따라서 해보는데 다들 옛날 UI 기반으로 되어 있어서 안 된다.

그러나, 제미나이가 답을 주었으니

오라클 클라우드(OCI) 무료 티어에서 임시(Ephemeral) 공용 IP를 예약된(Reserved) 공용 IP로 전환하려면, 기존의 임시 IP를 바로 '고정' 상태로 바꾸는 것이 아니라 기존 임시 IP를 제거한 후 새 예약 IP를 할당하는 과정을 거쳐야 합니다.

다만, 최근 OCI 업데이트로 현재 사용 중인 임시 IP를 즉시 예약 IP로 승격(Reserve)시키는 기능이 추가되었습니다. 가장 간편한 방법부터 단계별로 안내해 드립니다.

방법 1: 현재 사용 중인 임시 IP를 즉시 예약하기 (추천)

가장 빠른 방법입니다. 현재 인스턴스에 할당된 IP 주소를 그대로 유지하면서 예약 상태로 변경할 수 있습니다.

OCI 콘솔에 로그인합니다.
네트워킹(Networking) > 가상 클라우드 네트워크(VCN)로 이동합니다.
해당 인스턴스가 속한 VCN을 클릭한 후, 왼쪽 메뉴에서 서브넷(Subnets)을 선택합니다.
인스턴스가 연결된 공용 서브넷을 클릭합니다.
왼쪽 리소스(Resources) 메뉴에서 IPv4 주소(IPv4 Addresses)를 클릭합니다.
목록에서 현재 인스턴스가 사용 중인 IP 주소 오른쪽의 작업(점 3개) 메뉴를 누릅니다.
공용 IP 주소 예약(Reserve IP address)을 선택하고 이름을 입력한 뒤 확인을 누릅니다.
- 이제 해당 IP는 인스턴스가 삭제되어도 사라지지 않는 '예약된 IP'가 됩니다.

방법 2: 새 예약 IP를 생성하여 할당하기 (전통적 방식)

만약 위 메뉴가 보이지 않거나 새로운 IP를 고정하고 싶을 때 사용합니다.

1단계: 임시 IP 제거 (No Public IP)

하나의 VNIC에는 하나의 공용 IP만 가질 수 있으므로 기존 것을 먼저 제거해야 합니다.

컴퓨트(Compute) > 인스턴스(Instances)에서 해당 인스턴스를 선택합니다.
하단 리소스 탭에서 연결된 VNIC(Attached VNICs)를 클릭합니다.
기본 VNIC 이름을 클릭한 후, 왼쪽 IP 주소(IP Addresses)를 선택합니다.
기본 전용 IP 오른쪽의 편집(Edit)을 누릅니다.
공용 IP 없음(No Public IP)을 선택하고 업데이트합니다.

2단계: 예약된 공용 IP 할당

다시 같은 위치에서 편집(Edit)을 누릅니다.
공용 IP 유형에서 예약된 공용 IP(Reserved public IP)를 선택합니다.
새 예약된 공용 IP 생성을 선택하고 이름을 입력합니다. (이미 만들어둔 예약 IP가 있다면 '기존 예약된 IP 주소 선택' 사용)
업데이트를 누르면 고정된 IP가 할당됩니다.

주의사항

무료 티어 제한: 오라클 무료 계정은 지역(Region)당 최대 2개의 예약된 공용 IP만 무료로 제공합니다. 초과 시 비용이 발생할 수 있으니 주의하세요.
인스턴스 설정: IP가 변경된 경우, 만약 도메인 연결(DNS)이나 화이트리스트 설정을 해두셨다면 새 IP로 업데이트해야 합니다.
유휴 리소스: 예약만 해두고 인스턴스에 할당하지 않은 IP는 유료로 전환될 가능성이 있으므로(정책에 따라 상이), 사용하지 않는 예약 IP는 반드시 삭제하시기 바랍니다.

Img2Html_v0.144

techbard — Tue, 21 Apr 2026 19:15:45 +0900

자체 사용으로 부족한 부분 채워서 버전업 했습니다.

LSP 사용

techbard — Mon, 20 Apr 2026 13:07:49 +0900

LSP(Language Server Protocol)

LSP 서버 사용의 주요 효과

1. 정확한 코드 이해

LSP는 단순 문자열 검색이 아니라 코드의 AST(Abstract Syntax Tree)와 타입 정보를 기반으로 분석합니다.
AI 에이전트가 함수, 변수, 클래스의 실제 정의와 참조를 구분할 수 있어 오탐을 줄이고 정확한 결과를 제공합니다.

2. IDE와 AI 에이전트의 분리

LSP는 원래 IDE와 언어 기능을 분리하기 위해 만들어졌습니다.
AI 코딩 에이전트도 LSP를 통해 특정 IDE에 종속되지 않고 다양한 환경에서 동일한 언어 지원을 받을 수 있습니다.
예: VS Code, Vim, Cursor 같은 에디터에서 동일한 “언어 두뇌”를 공유 가능.

3. 개발 생산성 향상

“자동 완성”, “에러 진단”, “리팩토링 지원” 같은 기능을 AI가 LSP 서버를 통해 활용할 수 있어 개발 속도와 품질이 개선됩니다.
특히 대규모 코드베이스에서 AI가 더 빠르고 정확하게 맥락을 파악할 수 있습니다.

4. 에이전트 교체 용이성

최근에는 Agent Client Protocol(ACP) 같은 확장 개념이 등장해, LSP처럼 AI 에이전트도 쉽게 교체할 수 있는 환경이 마련되고 있습니다.
이는 개발자가 IDE를 바꾸지 않고도 다양한 AI 코딩 에이전트를 손쉽게 전환할 수 있게 합니다.

VS Code 용으로는 PureBasic LSP가 마켓 플레이스에 존재한다. 이를 opencode에서 사용하는 방법을 안내한다.

동일 형식을 사용하므로 호환이 되며, opencode에서 json 등록하면 된다.

1. VS Code에 플러그인 설치

2. powershell로 LSP 설치 경로 확인

Get-ChildItem "$env:USERPROFILE\.vscode\extensions" -Directory |
  Where-Object { $_.Name -like "meimingqi222.vscode-purebasic-*" } |
  Select-Object -ExpandProperty FullName

3. 윈도우 기준 %USERPROFILE%\.config\opencode\opencode.json 편집

{
  "$schema": "https://opencode.ai/config.json",
  "lsp": {
    "purebasic": {
      "command": [
        "node",
        "C:\\Users\\<USER>\\.vscode\\extensions\\meimingqi222.vscode-purebasic-0.0.4\\out\\server\\server.js",
        "--stdio"
      ],
      "extensions": [".pb", ".pbi", ".pbp"]
    }
  }
}

4. opencode 재시작

5. 이제 *.pb 파일을 read 하고 나면 상단 "상태" 아이콘에서 LSP가 등록된 것을 볼 수 있다.

* 등록만 하면 안 된다, AGENTS.md에 지시를 하고 읽으라고 해야 한다.

img2html v0.132

techbard — Fri, 10 Apr 2026 22:37:18 +0900

스스로 쓰기 위해서 프로그램을 만들었습니다.

하위 폴더의 이미지 파일을 가지고 html을 생성해 이미지 갤러리로 사용할 수 있습니다.

img2html.exe CLI 프로그램

img2html-gui.exe 프론트 엔드 (GUI 프로그램)

README.* 가이드

LICENSE 라이선스

윈도우 10, 11을 타겟합니다.

ASCII art 타이틀 생성하기

techbard — Tue, 29 Jul 2025 12:07:55 +0900

개인적인 취미와 일부의 업무적 성격으로 윈도우 콘솔 프로그램을 많이 만들고 사용한다. 특히 윈도우 배치 파일도 자주 만들고 사용하는데 이것이 본디 콘솔 프로그램이다 보니 이과 감성의 출력을 보이는데 그나마 좀 있어 보이는 외관을 위해 배너를 출력하는데 사용한다.

이른바 Text to ASCII Art Generator 이다.

ANSI Shadow font

이런식으로 아스키 배너를 생성하기도 하고,

Modular font

이런 식으로 배치 파일에 출력해서 배너를 출력하기도 한다.

Class

techbard — Sat, 17 May 2025 16:05:30 +0900

- A class is like a form or questionnaire.
- An instance is like a form that has been filled out with information.
- Just like many people can fill out the same form with their own unique information,
many instances can be created from a single class.
- Python class names are written in CapitalizedWords notation by convention.
- Attributes created in .__init__() are called instance attributes.
- An instance attribute’s value is specific to a particular instance of the class.
- On the other hand, class attributes are attributes that have the same value for all class instances.
- You can define a class attribute by assigning a value to a variable name outside of .__init__().
- Use class attributes to define properties that should have the same value for every class instance.
- Use instance attributes for properties that vary from one instance to another.
- Instance methods are functions that are defined inside a class and can only be called from an instance of that class.
- Just like .__init__(), an instance method’s first parameter is always self.
- Methods like .__init__() and .__str__() are called dunder methods because they begin and end with double underscores.
- Inheritance is the process by which one class takes on the attributes and methods of another.
- Newly formed classes are called child classes, and the classes that child classes are derived from are called
parent classes.
- Inheritance is a way of creating a new class for using details of an existing class without modifying it.
- Encapsulation is one of the key features of object-oriented programming.
- Encapsulation refers to the bundling of attributes and methods inside a single class.
- Polymorphism is, the same entity (method or operator or object) can perform different operations in different scenarios.
- Uses of Inheritance:
- Since a child class can inherit all the functionalities of the parent's class, this allows code reusability.
- Once a functionality is developed, you can simply inherit it.
- No need to reinvent the wheel.
- This allows for cleaner code and easier to maintain.
- Since you can also add your own functionalities in the child class, you can inherit only the useful functionalities and define other required features.

# OOP
# Python uses classes to define new data types (objects).
# The Class composed of:
#
# Header statement +
# The class body which contain the nested def statement +
# define method that can be called on instances of the objects
# implemented by this class.

class MyClass():
    def show(self):
        print("Hi")

def check():
    x = MyClass()
    x.show()

check()

# Class attributes
# - The attribute defined in the class is called "class attributes"
class MyClass():
    age = 21

print(MyClass.age)

# Instance Attributes
# - The attributes defined in the function is called "instance attributes"
class YourClass():
    def age(self):
        age = 21
        return age

yc = YourClass()
print(yc.age())

# The constructor
# - A class can define methods with special names.
# - These names begin and end with a double underscore.
#
# - One important special names is __init__, it's the
# constructor for a class.
#
# - It's called each time an instance of the class is created
# and Implementing this method in a class gives us a change to
# initialize each instance of our class.

class UserData():
    def __init__(self, name: str, age: int):
        self.name = name
        self.age = age

    def __str__(self):
        return f"user name is {self.name} and has {self.age} years old."

    def __len__(self):
        return self.age

u1 = UserData("mike", 19)
u2 = UserData("anna", 21)

print(u1)
print(u2)

print(len(u1))
print(len(u2))

##outout
user name is mike and has 19 years old.
user name is anna and has 21 years old.
19
21

# Class Inheritance
class UserData():
    age = 0
    name = None

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

user_1 = UserData(age=40, name="David")

class PhoneNumber(UserData):
    def __init__(self, age, name, phone_num):
        super().__init__(age, name)
        self.phone_num = phone_num
    def __str__(self):
        return f"user_name is {self.name}, has {self.age} years old, the phone_num is {self.phone_num}"

user_1 = PhoneNumber(age=30, name="Sarah", phone_num=1234)
user_2 = PhoneNumber(age=20, name="Danny", phone_num=5678)

print(user_1)
print(user_2)

#output
user_name is Sarah, has 30 years old, the phone_num is 1234
user_name is Danny, has 20 years old, the phone_num is 5678

# what's the difference between regular and @classmethod?
# the difference that we can access class state and object instance or chcnge them
# in regular method.
# in the @classmethod we can access and use class state only but not the object instance.
# we use decorators to make our code easily readable.

class Fruit:
    def __init__(self, fruits):
        self.fruits = fruits

    def __repr__(self):
        return f"Fruit({self.fruits})"

    @classmethod
    def citrus(cls):
        return cls(['lemon', 'orange', 'tangerine'])

    @classmethod
    def grapes(cls):
        return cls(['green grapes', 'red grapes'])

    @staticmethod
    def season():
        return 'Citrus Fruites in winter, Grapes Fruits in summer'

f1 = Fruit.citrus()
f2 = Fruit.grapes()
f3 = Fruit.season()

print(f1)
print(f2)
print(f3)

#output
Fruit(['lemon', 'orange', 'tangerine'])
Fruit(['green grapes', 'red grapes'])
Citrus Fruites in winter, Grapes Fruits in summer

# 가장 간단한 클래스 구조
class Person:
    def __init__(self, fname: str, lname: str) -> None:
        self.fname = fname
        self.lname = lname

    def get_full_name(self) -> str:
        return self.fname + " " + self.lname
    
    def __repr__(self) -> str:
        return f"Person: {self.fname} {self.lname}"

p1 = Person("Bob", "Smith")
print(f"{p1.fname}")
print(f"{p1.lname}")
print(f"{p1.get_full_name()}")
print(p1)

# 결과
Bob
Smith
Bob Smith
Person: Bob Smith

class Car:
    def __init__(self, brand: str, wheels: int) -> None:
        self.brand = brand
        self.wheels = wheels
    def turn_on(self) -> None:
        print(f"Turning on: {self.brand}")
    def turn_off(self) -> None:
        print(f"Turning off: {self.brand}")
    def drive(self, km: float) -> None:
        print(f"Driving: {self.brand} for {km}km")
    def describe(self) -> None:
        print(f"{self.brand} is a car with {self.wheels} wheels")

def main() -> None:
    bmw: Car = Car("BMW", 4)
    bmw.turn_on()
    bmw.drive(10)
    bmw.describe()
    
    # It seems like we went through a lot of effort just for
    # a simple BMW.
    # Just like below, we created a whole new car that
    # has all the same functionality as that of the BMW
    # with some custom details.
    # So we don't have to rewrite any functionality for this Volvo
    # because we already created a blueprint that fits it quite nicely,
    # which means now we can also turn on the Volvo.
    # And that's why object oriented programming can be very appealing
    # also in Python.
    volvo: Car = Car("Volve", 6)
    volvo.turn_on()
    volvo.drive(100)
    volve.describe()

main()

# 결과
Turning on: BMW
Driving: BMW for 10km
BMW is a car with 4 wheels

Turning on: Volve
Driving: Volve for 100km
Volve is a car with 6 wheels

# 클래스 기초
class Dog:
    # 여기에는 클래스 공통의 속성이 온다. (class object attribute)
    # 어떤 인스턴스든 간에 모두 가지고 있는 속성 (same for any instance of a class)
    # self 키워드는 사용하지 않는다.
    # 이유는 self는 클래스의 특정한 인스턴스에 대한 참조이기 때문에
    species = 'mammal'
    
    def __init__(self, breed, name, spots): # 인스턴스 멤버 또는 속성의 정의
        self.breed = breed
        self.name = name
        self.spots = spots
    
    # 메서드: 클래스 바디에 정의된 함수
    # 인스턴스의 개별 속성을 사용하는 작업을 정의
    # 메서드는 클래스 내에 있는 함수로 인스턴스와 함께 작동
    # 메서드는 클래스와 연결되어 있지만, 함수는 클래스와 무관
    def bark(self, number): # 인스턴스 멤버로 초기화하지 않은 인자를 메서드에 넘길 수 있다.
        print(f"Woof! my name is {self.name}, the num is {number}")

my_dog = Dog(breed='lab', name='Sammy', spots=False)

# 속성과 메서드의 차이점은 호출하는 방법에 있다.
# 속성은 괄호가 없다. 무언가를 실행하는 것이 아니기 때문이다.
# 단순히 인스턴스의 속성을 호출하는 것
# 이에 반해, 메서드는 실행이 필요하다. 실행을 위해서는 함수와 마찬가지로
# 인자가 필요하다.
print(my_dog.breed)
my_dog.bark(100)

# 결과
lab
Woof! my name is Sammy, the num is 100

# Methods are functions bound to a class. (인스턴스 메서드의 이해)
# - Only Car objects can call the drive method. (with . notation)
# - Error if attempt to call drive function.
#
# self는 명시적으로 인스턴스를 전달한다는 표시를 남기도록 설계했다.
# 

class Car:
    def drive(self, miles):
        print(f"The car drove {miles} miles.")

c = Car()
c.drive(100)

# 결과
The car drove 100 miles.

# simple class & inheritance, method overriding
class Vehicle():
    def __init__(self, body_style):
        self.bodystyle = body_style

    def drive(self, speed):
        self.mode = "driving"
        self.speed = speed

class Car(Vehicle):
    def __init__(self, engine_type):
        super().__init__("Car")
        self.wheels = 4
        self.doors = 4
        self.engine_type = engine_type
        
    def drive(self, speed):
         super().drive(speed)
         print("Driving my", self.engine_type, "car at", self.speed)

class Motocycle(Vehicle):
    def __init__(self, engine_type, has_sidecar):
        super().__init__("Motocycle")
        if has_sidecar:
            self.wheels = 3
        else:
            self.wheels = 2
        self.door = 0
        self.engine_type = engine_type

    def drive(self, speed):
         super().drive(speed)
         print("Driving my", self.engine_type, "motocycle at", self.speed)

car1 = Car("gas")
car2 = Car("electric")
mc1 = Motocycle("gas", True)

print(mc1.wheels)
print(car1.engine_type)
print(car2.doors)

# 결과
3
gas
4
Driving my gas car at 30
Driving my electric car at 40
Driving my gas motocycle at 50

# Classes & Instances: Combine Methods & Data

class Point():
    def getX(self):
        return self.x

    # When we call this method p1.getX
    # then one of the differences
    # between methods and functions,
    # remember, methods belong to a class.
    # So whenever we call a method we have
    # a particular actually instance that
    # we're calling that method on.
    # So in this case we aren't just calling
    # getX(), we're saying p1.getX().
    # And so when we say p1.getX() what happens
    # is that we're automatically passing in this
    # instance p1 as self when we call getX().
    # So when we say p1.getX(), even if we have no
    # arguments here and what Pytghon does is it automatically
    # takes what's befor the dot or the instance that we're
    # calling this on and it passes it in, As the value of self.
    # If we had instead replace that code to say, Print p2.getX().
    # Then what would happen is, instead of passing in p1,
    # then we would be passing in p2.
    # So we would've said p2.getX() would pass in p2 as the value
    # for the self.  

p1 = Point()
p2 = Point()

p1.x = 5
p2.x = 10

print(p1)
print(f"Are p1 and p2 equals? {p1 == p2}")

print(p1.getX())
print(p2.getX())

# 결과
<__main__.Point object at 0x0000020C547C6900>
Are p1 and p2 equals? False
5
10

# Sorting Lists of Instances

class Fruit():
    def __init__(self, name, price):
        self.name = name
        self.price = price
    def getName(self):
        return self.name
    def getPrice(self):
        return self.price
    def __str__(self):
        return f'({self.name}, {self.price})'

L = [
    Fruit("cherry", 10),
    Fruit("apple", 5),
    Fruit("blueberry", 20)
    ]

# So we need to be able to tell sorted how to compare
# two fruit items by passing in a value for key.
# Now remember that key is expecting a function as it's argument,
# so what I want to pass into key is a function that tell us what
# we want to sort by.
# print(sorted(L, key=Fruit.getName))

# for f in sorted(L, key=Fruit.getName):
    # print(f)

# Or

for f in sorted(L, key=lambda x: x.getName()):
    print(f'sorted by name: {f}')

print("")

for f in sorted(L, key=lambda x: x.getPrice()):
    print(f'sorted by price: {f}')

# 결과
sorted by name: (apple, 5)
sorted by name: (blueberry, 20)
sorted by name: (cherry, 10)

sorted by price: (apple, 5)
sorted by price: (cherry, 10)
sorted by price: (blueberry, 20)

# Creating Instances from Data

city_names = ['Detroit', 'Ann Arbor', 'Pittsburgh',
            'Mars', 'New York']
populations = [680250, 117070, 304391, 1683, 8406000]
states = ['MI', 'MI', 'PA', 'PA', 'NY']

city_tuples = zip(city_names, populations, states)

# print(list(city_tuples))

class City:
    def __init__(self, n, p, s):
        self.name = n
        self.population = p
        self.state = s
    def __str__(self):
        return f'{self.name}, {self.state} (pop: {self.population})'

# cities = []
# for city_tup in city_tuples:
    # name, pop, state = city_tup
    # city = City(name, pop, state) # instance of the City class
    # cities.append(city)

cities = [City(n, p, s) for (n, p ,s) in city_tuples]
# or
# cities = [City(*tup) for tup in city_tuples]

for city in cities:
    print(city)

# 결과
Detroit, MI (pop: 680250)
Ann Arbor, MI (pop: 117070)
Pittsburgh, PA (pop: 304391)
Mars, PA (pop: 1683)
New York, NY (pop: 8406000)

class Point():
    def __init__(self, initX, initY):
        self.x = initX
        self.y = initY
    def getX(self):
        return self.x
    def getY(self):
        return self.y
    def __str__(self):
        return f'(Point: {self.x}, {self.y})'
    def __add__(self, otherPoint):
        return Point(self.x + otherPoint.x, self.y + otherPoint.y)
    def __sub__(self, otherPoint):
        return Point(self.x - otherPoint.x, self.y - otherPoint.y)
    def halfway(self, otherPoint):
        midX = (self.x + otherPoint.x)/2
        midY = (self.y + otherPoint.y)/2
        return Point(midX, midY)

p1 = Point(1, 1)
p2 = Point(2, 2)

print(p1 + p2)
print(p1 - p2)

mid = p1.halfway(p2)
print(mid)
print(mid.getX())
print(mid.getY())

# 결과
(Point: 3, 3)
(Point: -1, -1)
(Point: 1.5, 1.5)
1.5
1.5

# 샘플 클래스
# 거리, 기울기 구하는 공식 적용
class Line:
    def __init__(self, coord1, coord2):
        self.coord1 = coord1 # tuple
        self.coord2 = coord2
    
    def distance(self):
        (x1, y1) = self.coord1
        (x2, y2) = self.coord2
        return ((x2-x1)**2 + (y2-y1)**2)**0.5

    def slope(self):
        (x1, y1) = self.coord1
        (x2, y2) = self.coord2
        return (y2-y1)/(x2-x1)

c1 = (3, 2)
c2 = (8, 10)

li = Line(c1, c2)
print(li.distance())
print(li.slope())

# 결과
9.433981132056603
1.6

# 동일한 두 점 거리와 기울기 구하는 공식을 가지고
# 리스트로 좌표 두 개가 주어질 때
# 그런데 해보니 리스트로 던져도 언패킹이 된다.
# 또한 구현하기 나름인데, 사실 그냥 멤버 초기화 없이 메서드에 값을 넣어도 된다.
class Line:
    def __init__(self, coor1, coor2):
        self.coor1 = coor1
        self.coor2 = coor2

    def distance(self):
        x1 = self.coor1[0]
        y1 = self.coor1[1]
        x2 = self.coor2[0]
        y2 = self.coor2[1]
        return ((x2-x1)**2 + (y2-y1)**2)**0.5

    def slope(self):
        x1 = self.coor1[0]
        y1 = self.coor1[1]
        x2 = self.coor2[0]
        y2 = self.coor2[1]
        return (y2-y1)/(x2-x1)

c1 = [3, 2]
c2 = [8, 10]

li = Line(c1, c2)
print(li.distance())
print(li.slope())

# 결과
9.433981132056603
1.6

# 은행 계좌 예제 클래스
class Account:
    def __init__(self, owner, balance):
        self.owner = owner
        self.balance = balance
        
    def withdraw(self, amount):
        if amount < 0:
            print("not a negative one.")
        elif amount > self.balance:
            print("You don't have enough balance.")
        else:
            self.balance -= amount
    
    def deposit(self, amount):
        if amount < 0:
            print("not a negative one.")
        else:
            self.balance += amount
    
    def __str__(self):
        return f'Hello {self.owner}, your balance is {self.balance}'

ac1 = Account('Jose', 100)
print(ac1)
ac1.deposit(50)
print(ac1)
ac1.withdraw(75)
print(ac1)
ac1.withdraw(80)
print(ac1)

# 결과
Hello Jose, your balance is 100
Hello Jose, your balance is 150
Hello Jose, your balance is 75
You don't have enough balance.
Hello Jose, your balance is 75

# Creating New Types
# - class keyword followed by:
# -- the name of the type and a colon
# -- similar to user-defined functions
# - Create the Car type

class Car:
    pass

# 객체를 생성하지 않았기 때문에 'type' 이다.
print(type(Car))

# built-in 'type' 이다.
print(type(int))

# t는 'str' 클래스의 멤버이다.
t = 'text'
print(type(t))

# Creating a Car instance
# - Car is no an instance
# - Car is a constructor that construc new Car instances
# -- Just like int constructs new integers and str constructs new strings
# - Must call Car() to create an instances

# 일종의 factory 이다.
my_car = Car()

# Factories
# Think of Car as a factory that constructs new Car instances
# This one factory can create any number of instances

print(type(int(1)))

print(type(my_car))
# <class '__main__.Car'>
# __main__ 은 이 모듈의 이름이다.

# Terminology: my_car is an instance of the Car class
# -- We created an instance of the Car class.
# An instance is a single member of the class.
# Another way of saying it - "we instantiated the Car class by creating the my_car instance"
# "We constructed a new instance of the Car class"

# 결과
<class 'type'>
<class 'type'>
<class 'str'>
<class 'int'>
<class '__main__.Car'>

# What is the parameter self doing here?
# - The first parameter refers to the calling instances
# - Instance is implicitly passed the method.

class Car:
    def drive(self, kms):
        print(f'The car drove {kms} kilometers.')

# Create new instance and call drive method
# my_car instance가 Car 클래스의 self에 암시적으로 전달된다.
# 이렇게 self를 쓰는 이유는 클래스 내부에서만 접근 가능한 메서드와
# instance에서 접근 가능한 메서드를 구분하기 위함으로 생각된다.
my_car = Car()
my_car.drive(10)
# 실상은 my_car.drive(my_car, 10) 이다. 내부적으로 생략해 처리한다.
# 즉, 인스턴스 메서드에 인스턴스 자체를 함께 던지는 개념이다.
# 결국 여러 인스턴스가 존재하며 그 각각의 인스턴스를 클래스 내부의
# 메서드에 함께 던져서 각각의 메서드를 사용할 수 있다.

# 결과
The car drove 10 kilometers.

# Object-oriented Programming
# - Creating classes, instantiating them, calling methods and
# retrieving attributes are all part of a programming paradigm
# called object-oriented programming.
# - In Python, every variable name created is an object.
# - All objects have types that are defined by their classes.


# Initializing an instance
# - Initialize instances in a specific and customized way.
# - Like choosing a car's color, number or seats, horsepower, transmission, and
# any other features.
# - No customization for current Car class - all instances are the same

# Define __init__ method
# - Gets called implicitly when consteucted

# __init__ 메서드를 이용하는 것은 결국 클래스를 커스토마이징하는 것
# 동일한 클래스를 커스토마이징해서 원하는 목적에 맞게 사용한다.
class Car:
    def __init__(self, color, price, transmission, make, model, mileage):
        self.color = color
        self.price = price
        self.transmission = transmission
        self.make = make
        self.model = model
        self.mileage = mileage
    
    def drive(self, kms):
        print(f'The car drove {kms} kilometers.')

my_car = Car(color='Red', price=80_000, transmission='Manual',
            make='Tesla', model='S3', mileage=0)

print(my_car.color)
print(my_car.model)

# 결과
Red
S3

# Object-oriented Programming
# - Creating classes, instantiating them, calling methods and
# retrieving attributes are all part of a programming paradigm called
# object-oriented programming.
# - In Python, every variable name is an object.
# - All objects have types that are defined by their classes.

# Initializing an instance
# - Lnitialize instances in a specific and customized way.
# - No customization for current Car class - all instances are the same


# 클래스 멤버 사용, 인스턴스 멤버와 메서드 인자를 함께 사용
class Car:
    depreciation = 0.25
    
    def __init__(self, color, price, make, model, mileage):
        self.color = color
        self.price = price
        self.make = make.upper()
        self.model = model
        self.mileage = mileage
        
    def drive(self, miles):
        self.mileage += miles
        self.price -= miles * 0.5
        print(f"Your {self.make} {self.model} car drove {miles} miles.")
        print(f"It has {self.mileage} miles.")
        print(f"Its current price is {self.price}")
        
    def future_lifetime(self):
        return self.price / Car.depreciation

my_car = Car(color='silver', price=35000, mileage=0, make='Tesla', model='S3')
my_car.drive(10)
my_car.drive(100)
my_car.drive(10_000)
my_car.future_lifetime()

# 결과
Your TESLA S3 car drove 10 miles.
It has 10 miles.
Its current price is 34995.0
Your TESLA S3 car drove 100 miles.
It has 110 miles.
Its current price is 34945.0
Your TESLA S3 car drove 10000 miles.
It has 10110 miles.
Its current price is 29945.0

# Object composition
# - When instrances have attributes that refer to instances of other classes
# - Change Car class so that a Person instance created in constructor

class Person:
    def __init__(self, name):
        self.name = name
        
    def greet(self):
        print(f'Hello, my name is {self.name}')

class Car:
    def __init__(self, color, price, model, mileage, person_name):
        self.color = color
        self.price = price
        self.model = model
        self.mileage = mileage
        # Person class instantiated here
        self.driver = Person(person_name)
        self.depreciation = .5

    def drive(self, miles):
        self.mileage += miles
        self.price -= miles * self.depreciation
        print(f'Your {self.model} drove {miles} miles')
        print(f'Total miles driven: {self.mileage}')
        print(f'Current value of car: {self.price}')

    def future_lifetime(self):
        return self.price / self.depreciation

car1 = Car(color='silver', price=35_000, mileage=0, model='Tesla', person_name='Bob')

car1.drive(10000)
ret = car1.future_lifetime()
print(f'future lifetime: {ret}')
car1.driver.greet()

# 결과
Your Tesla drove 10000 miles
Total miles driven: 10000
Current value of car: 30000.0
future lifetime: 60000.0
Hello, my name is Bob

# 상속과 합성

class Book:
    def __init__(self, title, author):
        self.title = title
        self.author = author
    def __str__(self):
        return f'{self.title} by {self.author}'

class PaperBook(Book):
    def __init__(self, title, author, numPages):
        super().__init__(title, author)
        self.numPages = numPages
    def __str__(self):
        return f'{self.title} by {self.author} ({self.numPages}p)'

class Ebook(Book):
    def __init__(self, title, author, fileSize):
        super().__init__(title, author)
        self.fileSize = fileSize
    def __str__(self):
        return f'{self.title} by {self.author} ({self.fileSize}MB)'
# 여기는 상속

class Library:
    def __init__(self):
        self.books = []
    def addBook(self, book):
        self.books.append(book)
    def getNumBooks(self):
        return len(self.books)
# 여기는 composition (a library contains or is composed of a list of books.)

p1 = PaperBook('The Odyssey', 'Homer', 499)
print(p1)

p2 = Ebook('The Odyssey', 'Homer', 2)
print(p2)

aLibrary = Library()
aLibrary.addBook(p1)
aLibrary.addBook(p2)
print(f'There (is)are {aLibrary.getNumBooks()} book(s).')

# 결과
The Odyssey by Homer (499p)
The Odyssey by Homer (2MB)
There (is)are 2 book(s).

# 클래스 파라미터의 사용

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

    def display(self):
        print(f'Hi {self.name}')
        print(f'Your age: {self.age}')
        print(f'Your marks: {self.marks}')

name = input('enter your name -> ')
age = int(input('enter your age -> '))
marks = int(input('enter your marks -> '))

s1 = BaseStudent(name, age, marks)
s1.display()

class ParamStudent:
    def __init__(self, n, a, *m):
        self.n = n
        self.a = a
        self.m = m

    def display(self):
        print('Hi', self.n)
        print('Your age', self.a)
        print('Your marks', self.m)

s2 = ParamStudent('kelly', 22, 70, 65, 90)
s2.display()

class KeyValueStudent:
    def __init__(self, n, a, **m):
        self.n = n
        self.a = a
        self.m = m
    
    def display(self):
        print('Hi', self.n)
        print('Your age', self.a)
        print('Your marks', self.m)

s3 = KeyValueStudent('John', 19, scienc = 95, english = 70, maths = 88)
s3.display()

# 결과
enter your name -> mike
enter your age -> 20
enter your marks -> 88
Hi mike
Your age: 20
Your marks: 88
Hi kelly
Your age 22
Your marks (70, 65, 90)
Hi John
Your age 19
Your marks {'scienc': 95, 'english': 70, 'maths': 88}

import random

# Single Responsibility Principle
# - Why two methods roll and _roll
# - SRP each component of a program responsibility over one task
# - _roll completes one roll of all dice
# - roll rolls n number of times
# - encourages user to call roll

# 간단한 클래스
# public, private method
class Dice:
    def __init__(self, sides=6, num=2, verbose=False):
        self.sides = sides
        self.num = num
        self.verbose = verbose
        self.rolls = []
        self.sums = []
    
    # private method
    def _roll(self):
        '''
        One complete roll of all dice
        '''
        curr_roll = tuple(random.randint(1, self.sides) for i in range(self.num))
        self.rolls.append(curr_roll)
        self.sums.append(sum(curr_roll))
        if self.verbose:
            print(f'Rolling {self.num} {self.sides}-sided dice: {curr_roll}')

    # public method
    def roll(self, n=1):
        '''
        Roll all dice n number of times
        '''
        for i in range(n):
            self._roll()

dice = Dice(sides=6, num=4, verbose=True)
print(type(dice))
dice.roll(3)
print(dice.sums)

# 결과
<class '__main__.Dice'>
Rolling 4 6-sided dice: (5, 4, 5, 1)
Rolling 4 6-sided dice: (1, 3, 5, 3)
Rolling 4 6-sided dice: (2, 1, 5, 6)
[15, 12, 14]

# Another big benefit of classes is that we
# can reuse them. We've already used many
# built-in types, including the string, the list,
# the dictionary, and the various numeric types.
# Instead of reimplementing the functionality provided by these types,
# we could focus on creating our programs.

class Pokemon:
    def __init__(self, name: str, max_armor: int, max_hit: int):
        self.name = name
        self.armor = max_armor
        self.hit_points = max_hit
        
    def attack(self):
        print(f'{self.name} attacks')
    
    def defend(self):
        print(f'{self.name} defends itself')
 
 
pikachu = Pokemon('Pikachu', 100, 1000)
pikachu.attack()
pikachu.defend()

snolax = Pokemon('Snorlax', 75, 900)
snolax.attack()

# 결과
Pikachu attacks
Pikachu defends itself
Snorlax attacks

### 클래스 생성자, 클래스 메소드

class myClass:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def myMethod(self):
        print(f'This is myMethod -> x: {self.x}, y: {self.y}')

def main():
    mc = myClass(1, 2)
    mc.myMethod()
    pass

if __name__ == '__main__':
    main()

# 결과
This is myMethod -> x: 1, y: 2

class PrivateMemberExample:
    def __init__(self):
        self.x = 1
        self._y = 2
        self.__z = 3

c1 = PrivateMemberExample()
print(f'멤버에 언더스코어 없는 self.x 접근 가능: {c1.x}')

c2 = PrivateMemberExample()
print(f'멤버에 1개 언더스코어 있는 self._y 접근 가능: {c2._y}')

# 결과
멤버에 언더스코어 없는 self.x 접근 가능: 1
멤버에 1개 언더스코어 있는 self._y 접근 가능: 2

# c3 = PrivateMemberExample()
# print(f'멤버에 2개 언더스코어 있는 self.__z 접근 불가: {c3.__z}')

# 결과
AttributeError: 'PrivateMemberExample' object has no attribute '__z'

### 스태틱 필드의 사용 (사실 함수와 다를게 없다)

class UseStaticField:
    result = []

    def __init__(self, *args):
        ret = []
        c = random.randint(0, 1)
        for arg in args:
            if c == 0 and arg % 2 == 0:
                ret.append(arg)
            if c == 1 and arg % 2 == 1:
                ret.append(arg)
        UseStaticField.result = ret

    def getResult(self):
        return UseStaticField.result

def main():
    u1 = UseStaticField(1, 2, 3, 4, 5)
    print(u1.getResult())

    u2 = UseStaticField(0, 7, 10, 23)
    print(u2.getResult())

    pass

if __name__ == '__main__':
    main()

#결과 1
[2, 4]
[0, 10]

#결과 2
[1, 3, 5]
[7, 23]

### 클래스 메쏘드로 쪼갠 버전

import random

class ChoiceNums:
    inList = []
    outList = []

    def __init__(self, *args):
        ChoiceNums.inList.clear()
        for arg in args:
            ChoiceNums.inList.append(arg)

    def getEvens(self):
        ChoiceNums.outList.clear()
        for e in ChoiceNums.inList:
            if e % 2 == 0:
                ChoiceNums.outList.append(e)
        return ChoiceNums.outList

    def getOdds(self):
        ChoiceNums.outList.clear()
        for e in ChoiceNums.inList:
            if e % 2 == 1:
                ChoiceNums.outList.append(e)
        return ChoiceNums.outList

def main():
    u1 = ChoiceNums(1, 2, 3, 4, 5)
    print('even:', u1.getEvens())
    print('odd:', u1.getOdds())

    print('\t')

    u2 = ChoiceNums(0, 7, 10, 23)
    print('even:', u2.getEvens())
    print('odd:', u2.getOdds())

    pass

if __name__ == '__main__':
    main()

# 결과
even: [2, 4]
odd: [1, 3, 5]
	
even: [0, 10]
odd: [7, 23]

### 객체 안의 데이터를 사용한 버전

class selectNums:

    def __init__(self, *args):
        self.args = args
        self.ret = []

    def getEvens(self):
        self.ret.clear()
        for e in self.args:
            if e % 2 == 0:
                self.ret.append(e)
        return self.ret

    def getOdds(self):
        self.ret.clear()
        for e in self.args:
            if e % 2 == 1:
                self.ret.append(e)
        return self.ret

def main():
    u1 = selectNums(1, 2, 3, 4, 5)
    print('even:', u1.getEvens())
    print('odd:', u1.getOdds())

    print('\t')

    u2 = selectNums(0, 7, 10, 23)
    print('even:', u2.getEvens())
    print('odd:', u2.getOdds())

    pass

if __name__ == '__main__':
    main()

# 결과
even: [2, 4]
odd: [1, 3, 5]
	
even: [0, 10]
odd: [7, 23]

### 리스트 컴프리헨션으로 객체 내부에 리스트 유지 X

class selectNums:
    def __init__(self, *args):
        self.args = args

    def getEvens(self):
        return [e for e in self.args if e % 2 == 0]

    def getOdds(self):
        return [e for e in self.args if e % 2 == 1]

def main():
    u1 = selectNums(1, 2, 3, 4, 5)
    print('even:', u1.getEvens())
    print('odd:', u1.getOdds())

    print('\t')

    u2 = selectNums(0, 7, 10, 23)
    print('even:', u2.getEvens())
    print('odd:', u2.getOdds())

    pass

if __name__ == '__main__':
    main()

# 결과
even: [2, 4]
odd: [1, 3, 5]
	
even: [0, 10]
odd: [7, 23]

# 클래스 속성과 인스턴스 속성 구별
class SProperty:
    shared_ls = [] # 클래스 속성
    def __init__(self, n):
        self.shared_ls.append(n) # self로 지정해도 접근 가능

class PProperty:
    def __init__(self):
        self.private_ls = [] # 인스턴스 속성
    def put(self, n):
        self.private_ls.append(n)

def main():
    s1 = SProperty('1')
    s2 = SProperty('2')

    print('-> 클래스 속성은 모든 인스턴스에 공유')
    print('s1:', s1.shared_ls)
    print('s2:', s2.shared_ls)

    print('\t')

    p1 = PProperty()
    p1.put('3')
    p2 = PProperty()
    p2.put('4')

    print('-> 인스턴스 속성은 인스턴스별로 독립')
    print('p1:', p1.private_ls)
    print('p2:', p2.private_ls)

    pass

if __name__ == '__main__':
    main()

# 결과
-> 클래스 속성은 모든 인스턴스에 공유
s1: ['1', '2']
s2: ['1', '2']
	
-> 인스턴스 속성은 인스턴스별로 독립
p1: ['3']
p2: ['4']

class Book:
    book_count = 0 # keep track of how many books are created.
    def __init__(self, title, author, pages):
        self.title = title
        self.author = author
        self.pages = pages
        Book.book_count += 1

    # Instance Method
    def get_description(self):
        return f"'{self.title}' by {self.author}, {self.pages}"

    # Class Method
    @classmethod
    def get_book_count(cls):
        return cls.book_count
    
    # Static Method (Utility functions)
    @staticmethod
    def is_small_book(page_count) -> bool:
        return page_count < 200

book = Book(title='The book', author='John Doe', pages=200)
print(book.get_description())
print(Book.get_book_count())
print(Book.is_small_book(150))
print(Book.is_small_book(300))

# Output:
'The book' by John Doe, 200
1
True
False

# 기본적인 상속의 예
class Person():
    # 생성자
    def __init__(self, name):
        self.name = name

    # get name
    def getName(self):
        return self.name

    # employee 객체인지 체크
    def isEmployee(self):
        return False

class Employee(Person):
    def isEmployee(self):
        return  True

def main():
    e1 = Person('Big Boss')
    print(e1.getName(), e1.isEmployee())

    e2 = Employee('Ant worker')
    print(e2.getName(), e2.isEmployee())

if __name__ == '__main__':
    main()
 
 #결과
Big Boss False
Ant worker True

# Super - Sub class 상속 관계의 예
# Super에는 멤버와 setter / getter를 두고
# Sub에 메서드를 유지

class Polygon:
    __width = None
    __heigh = None
    
    def set_value(self, w, h):
        self.__width = w
        self.__heigh = h
    
    def get_width(self):
        return self.__width
    
    def get_height(self):
        return self.__heigh
    
class Square(Polygon):
    def area(self):
        return self.get_width() * self.get_height()

class Triangle(Polygon):
    def area(self):
        return self.get_width() * self.get_height() * 1/2

s1 = Square()
s1.set_value(8, 15)
print(s1.area())

t1 = Triangle()
t1.set_value(5, 10)
print(t1.area())

# 결과
120
25.0

# In Python, super() built-in has two major use cases:
# - Allows us to avoid using base class explicitly
# - Working with Multiple Ingeritance

# 상속 관계일 때 super class의 메서드 직접 호출
class SuperClass:
    def __init__(self, in_msg):
        print('super class __init__ called.', in_msg)

class SubClass(SuperClass):
    def __init__(self, msg):
        print('sub class __init__ called.')
        # SuperClass.__init__(self, msg)
        super().__init__(msg)
        # 수퍼 클래스를 명시해도 되지만,
        # super() 함수를 호출해도 된다.
        # 단, 이 경우 self 객체 전달은 하지 않는다.

sub1 = SubClass("I'm SUB")

# 결과
sub class __init__ called.
super class __init__ called. I'm SUB

# Composition

# content is part of container
# Salary is part of Employee
# - Employee is my container and Salary is my content.
# - Container are destroyed then the content will be of no use.
# - This is why composition has strong relationship.
# - Imply that means they are both depending on each other.

# 반면에 aggregation의 경우 약한 결합이며
# 아래의 예에서 객체를 생성할 때 Salary 객체를 생성해
# 그 객체를 Employee 객체를 만들 때 넘겨주면 된다.
# 다만, 그 경계와 구분은 모호하며 상황이나 문제에 따라 사용한다.
#
# self.final_salary = Salary(pay, reward) ->
# self.final_salary = salary_object

# salary_object = Salary(1000, 100))

# class Employee:
    # def __init__(self, name, position, salary_object)

class Salary:
    def __init__(self, pay, reward):
        self.pay = pay
        self.reward = reward
    
    def annual_salary(self):
        return self.pay * 12 + self.reward

class Employee:
    def __init__(self, name, position, pay, reward):
        self.name = name
        self.position = position
        self.final_salary = Salary(pay, reward)
        # self.final_salary가 객체임에 유의

    def get_final_salary(self):
        return self.final_salary.annual_salary()

emp = Employee("mike", "Py dev", 1000, 100)
print(emp.get_final_salary())

# 결과
12100

### 다형성 함수의 간단한 예
def myAdd(x, y, z = 0):
    return x + y + z

def main():
    print(myAdd(1, 2))
    print(myAdd(1, 2, 3))

if __name__ == '__main__':
    main()

#결과
3
6

### 클래스 메서드의 다형성
class hero():
    def say(self):
        print("I'm hero.")

class villain():
    def say(self):
        print("I'm villain!")

def main():
    h = hero()
    v = villain()

    for e in (h, v):
        e.say()

if __name__ == '__main__':
    main()

#결과
I'm hero.
I'm villain!

### 클래스 메서드와 스태틱 메서드의 사용
"""
1. We generally use the class method to create factory methods. Factory methods return class objects ( similar to a constructor ) for different use cases.
2. We generally use static methods to create utility functions.
"""
import datetime

class Person:
    staticVar = 0
    def __init__(self, name, age):
        Person.staticVar += 1
        self.name = name
        self.age = age

    def getName(self):
        return self.name

    @staticmethod
    def getObjCount():
        return Person.staticVar

    @classmethod
    def fromBirthYear(cls, name, year):
        return cls(name, datetime.date.today().year - year)

def main():
    p1 = Person('sally', 21)
    p2 = Person.fromBirthYear('sally', 1996)
    p3 = Person('danny', 30)

    print(p1.getName(), p1.age)
    print(p2.getName(), p2.age)
    print(p3.getName(), p3.age)

    print('\t')

    print('obj count:', Person.getObjCount())

if __name__ == '__main__':
    main()

#결과
sally 21
sally 27
danny 30
	
obj count: 3

# class method

class Car:
    LIMITER: int = 160
    # 인스턴스 메서드가 이 클래스 멤버를 변경해도 자신의 인스턴스
    # 내의 멤버만 변경되고 다른 객체의 클래스 멤버는 변경되지 않는다.
    # 그러나, 클래스 메서드가 클래스 멤버를 변경하면 모든 인스턴스의
    # 클래스 멤버가 동시에 변경된다. (공용 변수처럼)

    def __init__(self, brand: str, max_speed: int) -> None:
        self.brand = brand
        self.max_speed = max_speed
        
    @classmethod
    def change_limit(cls, new_limit: int) -> None:
        cls.LIMITER = new_limit

def main() -> None:
    c1: Car = Car("BMW", 160)
    c2: Car = Car("Porsche", 200)

    c1.change_limit(170)
    print(f"{c1.brand} limit: {c1.LIMITER} km")
    print(f"{c2.brand} limit: {c2.LIMITER} km")

    c2.change_limit(200)
    print(f"{c1.brand} limit: {c1.LIMITER} km")
    print(f"{c2.brand} limit: {c2.LIMITER} km")

main()

# 결과
BMW limit: 170 km
Porsche limit: 170 km
BMW limit: 200 km
Porsche limit: 200 km

# Doc Strings
# Sphinx Markup
# 기본적인 클래스 사용 예

class User:
    """
    Base class for creating user.
    """
    
    def __init__(self, user_id: int) -> None:
        self.user_id = user_id
    
    def show_id(self) -> None:
        """Print the user_id as an int"""
        print(self.user_id)

def user_exist(user: User, database: set[User]) -> bool:
    """
    Checks if a user is inside a database.
    :param user: the user to check for
    :param database: the database to check inside
    :return: bool
    """
    return user in database


def main() -> None:
    user: User = User(0)
    user.show_id()
    
    bob: User = User(0)
    anna: User = User(1)
    
    database: set[User] = {bob, anna}
    
    if user_exist(bob, database):
        print(f"User exists in database!")
    else:
        print("No user found...")

main()

# 결과
0
User exists in database!

# 간단 객체 관리
# 최대한 type hinting 사용
class Person:
    _counter:int = 0
    _instances: list[any] = []

    def __init__(self, name: str, age: int):
        self.name = name
        self.age = age
        self._instances.append(self)
        Person._counter += 1

    def __repr__(self) -> str:
        return f"{self.name}={self.age} old"

    @classmethod
    def get_instances(cls) -> list[any]:
        return cls._instances

    @classmethod
    def get_counter(cls) -> int:
        return cls._counter

def main() -> None:
    Bob: Person = Person('Bob', 29)
    Sally: Person = Person('Sally', 19)
    John: Person = Person('John', 39)
    Mike: Person = Person('Mike', 49)

    person_dict: dict[str, int] = {}
    for person in Person.get_instances():
        person_dict[person.name] = person.age
    print(person_dict)
    print(f"The count of Person object: {Person.get_counter()}")

main()

# 결과
{'Bob': 29, 'Sally': 19, 'John': 39, 'Mike': 49}
The count of Person object: 4

# @dataclass
# In Pyhton, a data class is a class that is designed to only old data values.
# They aren't different from regular classes, but they usually
# don't have any other methods.
# They are typically used to store information that will
# be passed between different parts of a program of a system

# However, when creating classes to work only as data containers,
# writing the __init__ method repeatedly can generate a great
# amount of work and potential errors.

# The dataclasses module, a feature introduced in Python 3.7,
# provides a way to create data classes in a simpler manner
# without the need to write methods.

# Using a data class can save us a lot of trouble
# when we just want to create classes that contain data.
from dataclasses import dataclass

@dataclass
class Coin:
    name: str
    value: float
    id: str

def main():
    bitcoin1: Coin = Coin("Bitcoin", 10_000, "BTC")
    bitcoin2: Coin = Coin("Bitcoin", 10_000, "BTC")
    ripple: Coin = Coin("Ripple", 200, "XRP")
    
    print(bitcoin1)
    print(ripple)
    
    print(f"(bitcoin1 == ripple): {bitcoin1 == ripple}")
    print(f"(bitcoin1 == bitcoin2): {(bitcoin1 == bitcoin2)}")
    

main()

# 결과
Coin(name='Bitcoin', value=10000, id='BTC')
Coin(name='Ripple', value=200, id='XRP')
(bitcoin1 == ripple): False
(bitcoin1 == bitcoin2): True

from dataclasses import dataclass, field

@dataclass
class Fruit:
    name: str
    grams: float
    price_per_kg: float
    edible: bool = True
    related_fruits: list[str] = field(default_factory=list)

def main():
    apple: Fruit = Fruit('apple', 100, 5)
    pear: Fruit = Fruit('Pear', 250, 10, related_fruits=['Apple', 'Orange'])
    print(apple)
    print(pear)
    print(pear.related_fruits)

main()

# 결과
Fruit(name='apple', grams=100, price_per_kg=5, edible=True, related_fruits=[])
Fruit(name='Pear', grams=250, price_per_kg=10, edible=True, related_fruits=['Apple', 'Orange'])
['Apple', 'Orange']

itertools

techbard — Sat, 26 Apr 2025 18:32:49 +0900

# Sequence comparisons

import itertools

# define some lists
seq_1 = [1, 2, 3, 6, 10, 15, 34, 56]
seq_2 = [1, 2, 5, 7, 9, 18, 22, 38, 91]

# define a tuple
seq_3 = (1, 2, 3, 6, 10, 15, 34, 56)

# compare the sequences
# seq_1 vs seq_2
print(f"Is seq_1 is equal to seq_2: {seq_1 == seq_2}") # two sequences are obviously different.
print(f"Is seq_1 is greater than seq_2: {seq_1 > seq_2}") # third valus of seq_1 is not greater than seq_2.
print(f"Is seq_1 is less than seq_2: {seq_1 < seq_2}") # necause 3 is less than the 5.

# output
Is seq_1 is equal to seq_2: False
Is seq_1 is greater than seq_2: False
Is seq_1 is less than seq_2: True


# sequences that have equal values but different number of items.
seq_4 = [10, 20, 30]
seq_5 = [10, 20, 30, 40, 50]
print(f"Is seq_4 is less than seq_5: {seq_4 < seq_5}")

# output
Is seq_4 is less than seq_5: True

# Sequences must be of the same type to be compared
print(f"Is the same type of seq_1 and seq_3: {seq_1 == seq_3}") # that's different types.
print(f"Is the same type of seq_1 and seq_3: {tuple(seq_1) == seq_3}") # these are tuples.

# use the all() funtion to compare two arbitrary sequences
result = all(x == y for x, y in itertools.zip_longest(seq_1, seq_3))
print(result)

# output
Is the same type of seq_1 and seq_3: False
Is the same type of seq_1 and seq_3: True
True

import itertools

names = ["Joe", "Jane", "Jim"]

# cycle iterator can be used to cycle over a collection infinitely
cycler = itertools.cycle(names)
print(next(cycler))
print(next(cycler))
print(next(cycler))
print(next(cycler))

# output
Joe
Jane
Jim
Joe

#  use count to create a simple counter
counter = itertools.count(100, 10)
print(next(counter))
print(next(counter))
print(next(counter))

# output
100
110
120

# accumulate creates an iterator that accumulates values
vals = [10, 20, 30, 40, 50, 40, 30]
acc = itertools.accumulate(vals)
print(list(acc))

# output
[10, 30, 60, 100, 150, 190, 220] # it's running total.

# amortize a loan over a set number of payments for a 2000 loan at 4%
payments = [100, 125, 200, 105, 100, 120, 110, 130, 150, 100, 110, 120]
update = lambda balance, payment: round(balance * 1.04) - payment
balances = itertools.accumulate(payments, update, initial=2_000)
print(list(balances))

# output
[2000, 1980, 1934, 1811, 1778, 1749, 1699, 1657, 1593, 1507, 1467, 1416, 1353]

# Itertools: chain, chain.from_iterable

import itertools

# chain() creates a single iterable from multiple
chained = itertools.chain("abcd", "1234")
print(list(chained))

# output
['a', 'b', 'c', 'd', '1', '2', '3', '4']

# Using chain() for build a flat list
list_1 = [[1, 2, 3, 4], [5]]
list_2 = [6, 7]

flat_list = itertools.chain(list_1, list_2)
print(list(flat_list))

# output
[[1, 2, 3, 4], [5], 6, 7]

flat_list = itertools.chain(list_1, list_2)
flat_int = [inner for outer in flat_list for inner in (outer if isinstance(outer, list) else [outer])] # flatten
print(flat_int)

# output
[1, 2, 3, 4, 5, 6, 7]


# chain.from_iterable is an alternate usage of chain
s1 = "abcdefg"
s2 = [1, 2, 3, 4, 5]
s3 = ['$', '%', '@', '&']

result = itertools.chain.from_iterable([s1, s2, s3])
print(list(result))

# output
['a', 'b', 'c', 'd', 'e', 'f', 'g', 1, 2, 3, 4, 5, '$', '%', '@', '&']

# Itertools: dropwhile, takewhile, filterfalse
import itertools
import pprint
from dataclasses import dataclass

vals = [10, 20, 30, 40, 50, 40, 30, 25, 55, 45, 40, 30]

# dropwhile and takewhile will return values until
# a certain conditions is met that stops them.

def condition_func(n):
    return n < 40

# dropwhile() drops values until the predicate expression is True.
print(list(itertools.dropwhile(condition_func, vals)))

# takewhile() is the oppsite of dropwhile() - it returns values from
# the iterable while the predicate is True, then stops.
print(list(itertools.takewhile(condition_func, vals)))

# output
[40, 50, 40, 30, 25, 55, 45, 40, 30]
[10, 20, 30]


# filterfalse() returns elements from the iterable for which the predicate
# function returns False.
result = list(itertools.filterfalse(lambda x: x % 2 == 0, vals))
print(result)

# output
[25, 55, 45]

# These functions can work on complex objects.
@dataclass
class wcdata:
    game: str
    attendance: int
    team1: str
    team2: str
    score: str

world_cup_data = [
    wcdata("Final", 88966, "Argentina", "France", "3 (4) -- 3 (2)"),
    wcdata("3rd Place", 44137, "Croatia", "Moroco", "2 -- 1"),
    wcdata("Semi final", 68294, "France", "Moroco", "2 -- 0"),
    wcdata("Semi final", 88966, "Argentina", "Croatia", "3 -- 0"),
]

result = list(itertools.filterfalse(lambda x: x.attendance < 80_000, world_cup_data))
pprint.pp(result)

# output
[wcdata(game='Final',
        attendance=88966,
        team1='Argentina',
        team2='France',
        score='3 (4) -- 3 (2)'),
 wcdata(game='Semi final',
        attendance=88966,
        team1='Argentina',
        team2='Croatia',
        score='3 -- 0')]

# Itertools: combinations and permutatios

import itertools
import pprint

# product() produces the cartesian product of input iterables
cards = "A23456789TJQK" # cards of Ace to King.
suits = "SCHD"

deck = list(itertools.product(cards, suits))
print(len(deck), "cards")
pprint.pp(deck)

# output
52 cards
[('A', 'S'),
 ('A', 'C'),
 ('A', 'H'),
 ('A', 'D'),
 ('2', 'S'),
 ('2', 'C'),
 ('2', 'H'),
 ('2', 'D'),
 ('3', 'S'),
 ('3', 'C'),
 ('3', 'H'),
 ('3', 'D'),
 ('4', 'S'),
 ('4', 'C'),
 ('4', 'H'),
 ('4', 'D'),
 ('5', 'S'),
 ('5', 'C'),
 ('5', 'H'),
 ('5', 'D'),
 ('6', 'S'),
 ('6', 'C'),
 ('6', 'H'),
 ('6', 'D'),
 ('7', 'S'),
 ('7', 'C'),
 ('7', 'H'),
 ('7', 'D'),
 ('8', 'S'),
 ('8', 'C'),
 ('8', 'H'),
 ('8', 'D'),
 ('9', 'S'),
 ('9', 'C'),
 ('9', 'H'),
 ('9', 'D'),
 ('T', 'S'),
 ('T', 'C'),
 ('T', 'H'),
 ('T', 'D'),
 ('J', 'S'),
 ('J', 'C'),
 ('J', 'H'),
 ('J', 'D'),
 ('Q', 'S'),
 ('Q', 'C'),
 ('Q', 'H'),
 ('Q', 'D'),
 ('K', 'S'),
 ('K', 'C'),
 ('K', 'H'),
 ('K', 'D')]

# permutations() creates tuples of a given length with no repeated elements
# 4개의 팀이 있고 각각 홈 - 원정 두 번씩 경기를 치른다. (each of the permutations to have two elements.)
# 총 경기 조합은?
teams = ("A", "B", "C", "D")
result = list(itertools.permutations(teams, 2))
print(result)

# output
[('A', 'B'), ('A', 'C'), ('A', 'D'), ('B', 'A'), ('B', 'C'), ('B', 'D'), ('C', 'A'), ('C', 'B'), ('C', 'D'), ('D', 'A'), ('D', 'B'), ('D', 'C')]

# combinations() will create combinations of a given length with no repeats
result = list(itertools.combinations("ABCD", 3)) # using combinations, the order doesn't matter.
# A, B, C and C, B, A would be considered the same, so it only appears once.
print(result)

# output
[('A', 'B', 'C'), ('A', 'B', 'D'), ('A', 'C', 'D'), ('B', 'C', 'D')]

# combinations_with_replacement() will create combinations of a given length with repeats.
result = list(itertools.combinations_with_replacement("ABCD", 3))
print(result)

# output
[('A', 'A', 'A'), ('A', 'A', 'B'), ('A', 'A', 'C'), ('A', 'A', 'D'), ('A', 'B', 'B'), ('A', 'B', 'C'), ('A', 'B', 'D'), ('A', 'C', 'C'), ('A', 'C', 'D'), ('A', 'D', 'D'), ('B', 'B', 'B'), ('B', 'B', 'C'), ('B', 'B', 'D'), ('B', 'C', 'C'), ('B', 'C', 'D'), ('B', 'D', 'D'), ('C', 'C', 'C'), ('C', 'C', 'D'), ('C', 'D', 'D'), ('D', 'D', 'D')]

from itertools import product, permutations

for p in product((1, 2), (3, 4)):
    print(p) # Cartesian product

#output
(1, 3)
(1, 4)
(2, 3)
(2, 4)

for p in permutations([1, 2, 3]):
    print(p) # Order permutations
#output
(1, 2, 3)
(1, 3, 2)
(2, 1, 3)
(2, 3, 1)
(3, 1, 2)
(3, 2, 1)

list

techbard — Sat, 26 Apr 2025 18:18:57 +0900

empty_list = [] # 빈 리스트를 만든다.
print(type(empty_list)) # 리스트인가?
# 결과
<class 'list'>

print(len(empty_list)) # 방금 생성한 리스트에는 아무것도 들어있지 않다.
# 결과
0

list_is_Container = []
list_is_Container[0:1] = '1' # 리스트의 첫째 자리에 1이라는 스트링을 넣는다.
print(list_is_Container)
# 결과
['1']

one_list = []
another_list = [2]
one_list.append(another_list) # 리스트 안에 또 다른 리스트를 넣는다.
print(one_list)
# 결과
[[2]]

# 리스트 요소의 삭제

planets = ['pluto', 'mars', 'earth', 'venus']
del planets[0] # 원본 리스트에서 삭제하는 방법 #1
print(planets)

print('')

planets = ['pluto', 'mars', 'earth', 'venus']
planets.remove('pluto') # 원본 리스트에서 삭제하는 방법 #2
print(planets)

# ==> del은 index 요소로 삭제 / remove 메서드는 요소 이름으로 삭제

# 결과
['mars', 'earth', 'venus']

['mars', 'earth', 'venus']

리스트의 할당과 복사

def main():

    l1 = [1, 2, 3]
    l2 = l1

    # 두 객체는 같은 객체이다.
    print('addr of id1: ', id(l1))
    print('addr of id2: ', id(l2))
    if id(l1) == id(l2):
        print('[l1 is l2] - same object')
    else:
        print('[l1 is not l2]')

    print('\t')

    one = list(range(1, 4))
    another = one.copy()

    # 두 객체는 다른 객체이다.
    print('addr of one: ', id(one))
    print('addr of another: ', id(another))
    if id(one) == id(another):
        print('[one is another]')
    else:
        print('[one is not another] - diff. object')

    pass

if __name__ == '__main__':
    main()

# 결과

addr of id1:  2531229270592
addr of id2:  2531229270592
[l1 is l2] - same object
	
addr of one:  2531230033536
addr of another:  2531229270208
[one is not another] - diff. object

# deep copy (cf. shallow copy)
# mutable 객체는 복사에 레퍼런스 참조 사용
# 객체를 직접 복사하려면 copy 모듈 사용
import copy

org_list = [1, 1, 1]
cpy_list = copy.deepcopy(org_list)

print(f'original list: {org_list}')
print(f'copied list: {cpy_list}')

cpy_list[0] = 0
print(f'still original list: {org_list}')
print(f'modify copied list: {cpy_list}')

# 결과
original list: [1, 1, 1]
copied list: [1, 1, 1]
still original list: [1, 1, 1]
modify copied list: [0, 1, 1]

# 중첩 리스트의 인덱싱
nested_list = [[1, 2, 3], ['x', 'y'], ['apple', 'banana']]

print("before: ", end='')
print(f'{nested_list}, length: {len(nested_list)}')

nested_list[0].append(4)
nested_list[1].append('z')
nested_list[2].append('cherry')

print("after: ", end='')
print(f'{nested_list}, length: {len(nested_list)}')

# 각 내부 리스트에 요소를 추가했지만 내부 리스트 전체 개수의 변화는 없다.
before: [[1, 2, 3], ['x', 'y'], ['apple', 'banana']], length: 3
after: [[1, 2, 3, 4], ['x', 'y', 'z'], ['apple', 'banana', 'cherry']], length: 3

# 리스트의 더블 인덱싱
in_list = [1, 2, 3]
l = []

for i in range(len(in_list)):
    l.append(in_list[i])

print(l)

print([1, 2, 3][0], end=' ')
print([1, 2, 3][1], end=' ')
print([1, 2, 3][2])

# 결과
[1, 2, 3]
1 2 3

# 중첩 리스트의 변경
nested_list = [[1, 2, 3], ['x', 'y'], ['apple', 'banana']]

nested_list[1] = ['x', 'y', 'z']
nested_list[2][1] = 'cherry'

print(nested_list)

# 결과
[[1, 2, 3], ['x', 'y', 'z'], ['apple', 'cherry']]

# 연속 중첩 리스트의 인덱싱
data_list = ['a', [1, 2, []], [['apple', 'banana'], 'cherry']]

fruits = data_list[2][0][0]

print(fruits)

# 결과
apple

# 중첩 리스트를 가지고 kv dict를 생성해 데이터 정리
# isinstance(x, (int, float, complex)) and not isinstance(x, bool)

key_data = ['nums', 'alphas', 'fruits']
nl_dict = { k : [] for k in key_data} # {'nums': [], 'alphas': [], 'fruits': []}

nested_list = [[1, 2, 3], ['x', 'y', 'z'], ['apple', 'cherry']]

for nl in nested_list:
    if isinstance(nl[0], int):
        nl_dict['nums'] = nl
    elif isinstance(nl[0], str) and len(nl[0]) == 1:
        nl_dict['alphas'] = nl
    else:
        nl_dict['fruits'] = nl

print(nl_dict)

# 결과
{'nums': [1, 2, 3], 'alphas': ['x', 'y', 'z'], 'fruits': ['apple', 'cherry']}

# Nested Iteration
info = [['1', 10], ['2', 20], ['3', 30]]

values = []

for vl in info:
    values.append(vl[1])

print(values)

# 결과
[10, 20, 30]

# Having this mixture is going to make it hard to traverse
# the Nested Data structure.
# (TypeError: 'int' object is not itrerable.)
#
# The solution when we are in control of the data structure
# is to make it very regular with always the same kinds of items
# in the same level of nesting.
# In other words, dont mix integers, lists and dictionaries as items
# in a single list.
#
# Sometimes however, we arent in control of the data structure.

mixture_of_nested_list = [1, 2, ['a', 'b'], ['c'], ['d', 'e', 'f']]

for e in mixture_of_nested_list:
    print("level1: ")
    if type(e) is list:
        print(f"\tlevel2: {e}")
    else:
        print(e)

# 결과
level1: 
1
level1: 
2
level1: 
	level2: ['a', 'b']
level1: 
	level2: ['c']
level1: 
	level2: ['d', 'e', 'f']

# shallow copy
original = [[1, 2], ['1', '2']]
copied1 = original
copied2 = original[:]

print(f"Is copied1 equals original? {copied1 is original}")
print(f"Is copied2 equals original? {copied2 is original}")
print("")

original.append([3])

print(f"Now original is {original}")
print(f"Now copied1 is {copied1}")
print(f"Now copied2 is {copied2}")
print("")
# shallow copy (= copied2)는 추가 요소에 대해서는 구별되나
# 기존 요소는 copied1 = copied2 이다.

# 그러면 기존 요소를 바꾸는 경우 두 개가 달라질까?
# 먼저 리스트 요소 자체를 바꾸는 경우
del original[-1]
copied1[0] = ['x']

print(copied1)
print(copied2)
print("")
# ==> 정상이다.

# 그러면 리스트 내의 요소를 바꾸는 경우
copied1 = original
copied2 = original[:]

copied1[0][0] = 'x'
print(copied1)
print(copied2)
# => 안된다. 리스트 요소를 바꾸는 경우 두 객체가 같아지는 문제가 있고, 이것이 shallow copy의 문제이다.

# 결과
Is copied1 equals original? True
Is copied2 equals original? False

Now original is [[1, 2], ['1', '2'], [3]]
Now copied1 is [[1, 2], ['1', '2'], [3]]
Now copied2 is [[1, 2], ['1', '2']]

[['x'], ['1', '2']]
[[1, 2], ['1', '2']]

[['x'], ['1', '2']]
[['x'], ['1', '2']]

# list null check

empty_list = []

if not empty_list: # The pretty simple pythonic way.
    print("[1] null list")

if len(empty_list) == 0: # A much explicit way.
    print("[2] null list")

if empty_list == []: # Comparing it to an anonymous empty list.
    print("[3] null list")

if not bool(empty_list): # less readable surely
    print("[4] null list")

# 결과
[1] null list
[2] null list
[3] null list
[4] null list

# Reverse the list

ll = [list(), [1], 100]
print(f"original list: {ll}")

reversed_list_by_slice = ll[::-1]
print(f"reversed_list_by_slice: {reversed_list_by_slice}")

ll.reverse()
print(f"reversed_list_by_fx: {ll}")
# sort, sorted의 예를 보듯이
# 함수는 리턴을 하고, 메서드는 리턴을 하지 않고 해당 인스턴스를 변경한다.

# 결과
original list: [[], [1], 100]
reversed_list_by_slice: [100, [1], []]
reversed_list_by_fx: [100, [1], []]

# Confirm that the ojects are the same with the id function

list1 = [1, 2, 3]
list2 = list1

list3 = [1, 2, 3]

print(f"id(list1) == id(list2): {id(list1) == id(list2)}")
print(f"list1 is list2: {list1 is list2}")
print(f"list1 == list3: {list1 == list3}", end=' ')
print("* list1 and list3 are different object, but have same values.")

# 결과
id(list1) == id(list2): True
list1 is list2: True
list1 == list3: True * list1 and list3 are different object, but have same values.

lst_idx = [1, 2, 3]
lst_idx_len = len(lst_idx)

idx = 0
for idx in range(len(lst_idx)):
    out = lst_idx.pop(0)
    print(f"{out} is popped.")
    idx += 1
    # index로 돌며 무조건 1st를 pop하는 경우는 원하는대로 된다.

print("")

lst_in = [1, 2, 3]

for e in lst_in:
    out = lst_in.pop(0)
    print(f"{out} is popped.")
    # 이건 stop이 변하기 때문에 원하는 결과가 나오지 않는다.

# 결과
1 is popped.
2 is popped.
3 is popped.

1 is popped.
2 is popped.

# 리스트 안의 int를 int형으로 변환하기

number: list[int] = [1]

# 리스트 내 int를 int형으로 변환 방법 1
for num in number:
    print(type(num), num)

# 리스트 내 int를 int형으로 변환 방법 2
int_result = int(''.join(map(str, number)))
print(type(int_result), int_result)

# 리스트 내 int를 int형으로 변환 방법 3
ints = int(''.join(str(n) for n in number))
print(type(ints), ints)

# 결과
<class 'int'> 1
<class 'int'> 1
<class 'int'> 1

# If you're looping through a list, a good rule of thumb is to
# never modify that list while you're looping through it,
# because it will often lead to unwanted or unexpected behavior
# in your program.
# And in general, you will always want to use a temporary list
# if you decide to make any changes while you're looping through
# the original list, and then transfer the changes from that
# temporary list to the original.

# 간략히 말하면 list 중 요소를 제거하고 싶으면
# looping 중인 list를 변경(제거)하지 말고, 그것을 제외한 나머지를 새로운 list에
# 담는 방식으로 구현하자.

# string 처리가 복잡할 때는 list로 변환해서
# 가공 후에 다시 텍스트로 바꾸는 방법도 쉽다.
from string import whitespace, punctuation

title: str = "Section 5: Rewriting an Immutable String"
title_list: list[str] = list(title)
colon_position: int = title_list.index(':')
del title_list[:colon_position+1]

for i in range(len(title_list)):
    if title_list[i] in whitespace+punctuation:
        title_list[i] = '_'

title: str = ''.join(title_list)
print(title)
title = 'prefix' + title
print(title)

# 결과
_Rewriting_an_Immutable_String
prefix_Rewriting_an_Immutable_String

# 임의로 리스트 데이터를 가공하는 구현
person_marks: list[str, int] = \
[
    ['Bob', 75],
    ['Sally', 83],
    ['John', 91],
    ['Dave', 77]
]

marks_avg: int = sum([mark for (person, mark) in person_marks]) / len(person_marks)
print("=====" * 5)
print(f"marks avg: {marks_avg}")
print("=====" * 5)
person_marks_evaluation: dict[str, list[int, float]] = \
{person: [mark, "above avg or equal" if mark >= marks_avg else "below avg"] for (person, mark) in person_marks}
for (person, markeval) in person_marks_evaluation.items():
    print(f"{person:<5}, mark:{markeval[0]}, eval:{markeval[1]}")

# 결과
=========================
marks avg: 81.5
=========================
Bob  , mark:75, eval:below avg
Sally, mark:83, eval:above avg or equal
John , mark:91, eval:above avg or equal
Dave , mark:77, eval:below avg

# The valueof None is equivalent to "null" in other languages.
# The following values are falsy:
#   - None, 0, False, Empty sequence or mapping, Zero-length String

nums: list[int] = [1, 2, 3, 4, 5]
nums_stats: dict[str, int|float] = {'sum': 0, 'min': 0, 'max': 0, 'avg': 0, 'len': 0}

nums_sum: int = sum(nums)
nums_max: int = max(nums)
nums_min: int = min(nums)
nums_len: int = len(nums)
nums_avg: float = round(nums_sum/nums_len, 2)

nums_stats['avg'] = nums_avg
nums_stats['len'] = nums_len
nums_stats['max'] = nums_max
nums_stats['min'] = nums_min
nums_stats['sum'] = nums_sum

print(f"{nums_stats=}")

# 결과
nums_stats={'sum': 15, 'min': 1, 'max': 5, 'avg': 3.0, 'len': 5}

# find longest name (색다르게 구현한 버전)
names: list[str] = ['Cecilia', 'Lise', 'Marie']
names_sorted: list[str] = sorted(names, key=lambda name: len(name), reverse=True)
print(f"longest name: {names_sorted[0]}, len: {len(names_sorted[0])}")

# 결과
longest name: Cecilia, len: 7

# 랜덤으로 숫자와 알파벳을 생성해 zip으로 묶고
# dict를 조회하며 min, max, sum, avg 추출

import random
# 97 - 122, min, max, sum, avg

nums: list[int] = random.choices(range(100), k=10)
chrs: list[str] = list(map(chr, random.choices(range(97, 123), k=10)))
num_chr_pairs: dict[str, int] = {chr: num for chr, num in list(zip(chrs, nums))}

def get_avg(d: dict[str, int]) -> float:
    keys: list[str] = list(d.keys())
    total: int = sum([d[k]for k in keys])
    return round(total/len(keys), 2)

# 결과
{'p': 11, 'm': 57, 's': 86, 'u': 21, 'l': 99, 'd': 59}
min key: p, min value: 11
max key: l, max value: 99
sum: 333
avg: 55.5

def get_sum(d: dict[str, int]) -> int:
    keys: list[str] = list(d.keys())
    return sum([d[k]for k in keys])

def get_max(d: dict[str, int]) -> str:
    keys: list[str] = list(d.keys())
    max_key: str = keys[0]

    for k, v in d.items():
        if d[k] >= d[max_key]:
            max_key = k
    return max_key

def get_min(d: dict[str, int]) -> str:
    keys: list[str] = list(d.keys())
    min_key: str = keys[0]

    for k, v in d.items():
        if d[k] <= d[min_key]:
            min_key = k
    return min_key

print(num_chr_pairs)
min_key: str = get_min(num_chr_pairs)
print(f"min key: {min_key}, min value: {num_chr_pairs[min_key]}")

max_key: str = get_max(num_chr_pairs)
print(f"max key: {max_key}, max value: {num_chr_pairs[max_key]}")

sum_keys: str = get_sum(num_chr_pairs)
print(f"sum: {sum_keys}")

avg_keys: str = get_avg(num_chr_pairs)
print(f"avg: {avg_keys}")

# To access a member of a sequence type, use []

text: str = "hello"
list_str: list[str] = ['Bob', 'Sally', 'John']

extract_first_two: slice = slice(None, 2)

print(text[extract_first_two])
print(list_str[extract_first_two])

# 결과
he
['Bob', 'Sally']

# 조회하는 리스트에서 요소를 제거할 경우
# 조회 대상 자체가 변경되기 때문에 원하는 결과가 나오지 않는다.

# 회피 방법 #1
nums = [1, 2, 3, 4, 5]
pos = 0
result = []

while pos != len(nums):
    n = nums[pos]
    if n % 2 == 0:
        result.append(n)
    nums.remove(nums[0])

print(result)

# 회피 방법 #2 (제거하지 않고 index를 증가한다.)
nums = [1, 2, 3, 4, 5]
pos = 0
result = []

while pos < len(nums):
    if nums[pos] % 2 == 0:
        result.append(nums[pos])
    pos += 1

print(result)

# 결과
[2, 4]
[2, 4]

# Count the X's in a matrix

matrix = [["X", "O", "O"], ["O", "X", "O"], ["O", "O", "X"]]
flat = [item for sublist in matrix for item in sublist]
count_of_x = flat.count("X")
print(f"{count_of_x=}")

# 결과
count_of_x=3

data = [4, 5, 104, 105, 110, 120, 130, 130, 150,
        160, 170, 183, 185, 187, 188, 191, 350, 360]

min_valid = 100
max_valid = 200
result = [d for d in data if min_valid < d < max_valid]
print(result)

# 또 다른 방법: 인덱스를 얻어 원 데이터에서 삭제하는 방법
# 그러나, 이렇게 하면 안 된다. 의도한 결과가 나오지 않음
# 즉, target 데이터를 조회하며 제거할 때는 원본을 건드리지 말고
# 또 다른 리스트를 생성하는 것이 올바른 방법이다.

for idx, d in enumerate(data):
    if (d < min_valid) or (d > max_valid):
        del data[idx]
print(data)

# Output:
[104, 105, 110, 120, 130, 130, 150, 160, 170, 183, 185, 187, 188, 191]
[5, 104, 105, 110, 120, 130, 130, 150, 160, 170, 183, 185, 187, 188, 191, 360]

# Removing Items from a List Backwards (Safety Solution)
data = [104, 101, 4, 105, 308, 103, 5,
        107, 100, 306, 106, 102, 108]

min_valid = 100
max_valid = 200

print("Original:                    ", end='')
print(data)

for idx in range(len(data) - 1, -1, -1):
    if (data[idx] < min_valid) or (data[idx] > max_valid):
        del data[idx]

print("Safety removing of list item:", end='')
print(data)

# Output:
Original:                    [104, 101, 4, 105, 308, 103, 5, 107, 100, 306, 106, 102, 108]
Safety removing of list item:[104, 101, 105, 103, 107, 100, 106, 102, 108]

# another way of flatten list 

my_int_list = [[1, 2], [3, 4], [5, 6]]

# # 방법 1 - sum 함수
answer = sum(my_int_list, [])
print(answer)

my_str_list = [["apple", "banana"], ["cherry", "durian"]]
flat_list = sum(my_str_list, [])
print(flat_list)

# # 방법 2 - itertools.chain.from_iterable
import itertools
result = list(itertools.chain.from_iterable(my_str_list))
print(result)

# output
[1, 2, 3, 4, 5, 6]
['apple', 'banana', 'cherry', 'durian']
['apple', 'banana', 'cherry', 'durian']

# flatten list method #1

my_list = [["apple", "banana"], ["cherry"], ["durian", "elderberry"]]

flat_list_1 = sum(my_list, [])
print(flat_list_1)

# flatten list method #2
import itertools
flat_list_2 = itertools.chain.from_iterable(my_list)
print(list(flat_list_2))

# flatten list method #3
flat_list_3 = [inner for outer in my_list for inner in outer]
print(flat_list_3)

# output
['apple', 'banana', 'cherry', 'durian', 'elderberry']
['apple', 'banana', 'cherry', 'durian', 'elderberry']
['apple', 'banana', 'cherry', 'durian', 'elderberry']

# list 평탄화, 이종의 리스트를 한 개의 리스트로 변환

my_list = [["apple", "banana"], ["cherry"], "durian"]

### Using list conprehension
flat_list_using_comprehension = \
[inner for outer in my_list for inner in (outer if isinstance(outer, list) else [outer])]
print(flat_list_using_comprehension)

# output
['apple', 'banana', 'cherry', 'durian']

### Using sum(), 하지만 리스트가 요소가 모두 균일해야 한다.
for e in my_list:
    if isinstance(e, list):
        continue
    else:
        idx = my_list.index(e)
        my_list[idx] = [e]
flat_list_using_sum_func = sum(my_list, [])
print(flat_list_using_sum_func)

# output
['apple', 'banana', 'cherry', 'durian']

### Using for - in - list comprehension
### list index를 건드리는 건 위험할 수 있어서 별도의 리스트를 생성한다.
processed_list = []
for e in my_list:
    if isinstance(e, list):
        processed_list.extend(e)
    else:
        processed_list.append(e)
print(processed_list)

# output
['apple', 'banana', 'cherry', 'durian']

two_d_list = [["apple", "banana"], ["cherry"], "durian", "citrus"]

### Using for-in list comprehension for build flat_list
fruit_list = [inner for outer in two_d_list for inner in (outer if isinstance(outer, list) else [outer])]
print(fruit_list)

### Make fruit dict by first letter
group_alpha = {}
for fruit in fruit_list:
    key = fruit[0]
    (group_alpha.setdefault(key, [])).append(fruit)
print(group_alpha)

### output
['apple', 'banana', 'cherry', 'durian', 'citrus']
{'a': ['apple'], 'b': ['banana'], 'c': ['cherry', 'citrus'], 'd': ['durian']}

# make matrix to flat-list
two_d_fruits = [["apple", "banana"], ["cherry"], "durian", "cranberry"]

group_fruit = {}
fruits = [inner for outer in two_d_fruits for inner in (outer if isinstance(outer, list) else [outer])]

for fruit in fruits:
    key = fruit[0]
    (group_fruit.setdefault(key, [])).append(fruit)
# output
{'a': ['apple'], 'b': ['banana'], 'c': ['cherry', 'cranberry'], 'd': ['durian']}

# make fruits dict based on first letter and count them
for key in group_fruit:
    group_fruit[key].insert(0, f"len: {len(group_fruit[key])}")

print(group_fruit)

# output
{'a': ['len: 1', 'apple'], 'b': ['len: 1', 'banana'], 'c': ['len: 2', 'cherry', 'cranberry'], 'd': ['len: 1', 'durian']}

##############################################################
# 리스트 요소 중 특정 요소만 추출하기
# :요소 타입이 다른 리스트를 string 변환하고 특정 요소만 제거
##############################################################
mixed_list = [1, None, '2', None, 3]
filtered_list = [m for m in mixed_list if m != None]
output = '/'.join(map(str, filtered_list))
print(f"{mixed_list} -> {output}")

##output
[1, None, '2', None, 3] -> 1/2/3

#-------------------------------------------------------------------------------
# * 주의 *
#-------------------------------------------------------------------------------
# for-loop안에서 요소 삭제를 하면 index가 증가하면서 요소를 삭제하기 때문에
# 첫번째는 요소 1을 삭제하고 index는 0 -> 1로 증가
# 두번째 index가 1로 증가한 요소는 3이 된다.
# 이유는 index 0 -> 1로 증가한 뒤, 1 요소를 삭제했기 때문에
# index 1이 지금은 3이 된다.
# 다시 요소 3을 삭제한 뒤 index는 2로 증가하지만 총 4개 요소 중에
# 남은 요소는 3, 4 밖에 없으므로 index 2 요소는 존재하지 않는다.

values = [1, 2, 3, 4]
for v in values:
    values.remove(v)
print(values)
##output
[2, 4]
#-------------------------------------------------------------------------------

#-------------------------------------------------------------------------------
# 모든 리스트 요소를 지우려면 값을 일일이 꺼내서 for-loop 사용한다.
values = [1, 2, 3, 4]
for v in values[:]:
    values.remove(v)
print(values)
##output
[]
#-------------------------------------------------------------------------------

#-------------------------------------------------------------------------------
# 아래 코드 내용으로 볼 때 for-loop에서는 index를 자동으로 꺼내 사용한다.
# 왜냐하면 뒤에서부터 삭제하면 모든 요소 삭제가 정상이므로
# (앞에서 부터 index 삭제하면, 하나씩 밀리면서 원하는 삭제가 안 되고 남는다.)
values = [1, 2, 3, 4]
for v in reversed(values):
    values.remove(v)
print(values)
##output
[]
#-------------------------------------------------------------------------------

String Manipulation - example

techbard — Thu, 24 Apr 2025 13:06:06 +0900

# text 파일의 내용을 리버스
# 1. 단어 내용을 리버스
# 2. 단어 순서를 리버스

# reverse words in a text file
import os
# os.path.join은 운영체제에 관계 없이 경로를 만들어 준다.
file_path = os.path.join('2025-03-10', '5 - example.txt')

reversed_words_letter = []
reversed_words_sequence = []

with open(file_path, 'r') as file:
    text = file.read()
    words = text.split()

    for word in words:
        reversed_words_letter.append(word[::-1])
    reversed_words_sequence = words[::-1]
        
print(reversed_words_letter)
print("=====================================")
print(reversed_words_sequence)

# Output
['stseroF', 'era', 'lativ',
=====================================
['generations.', 'future', 'for', 'ecosystems',

# Built-in string constants

# String processing is one of the more common tasks
# that today's programmers have to deal with.

import string

built-in constants for a variety of needs (pre-defined constants)
print(string.ascii_letters)
print(string.ascii_lowercase)
print(string.ascii_uppercase)
print(string.digits)
print(string.hexdigits)
print(string.punctuation)

# output
abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
abcdefghijklmnopqrstuvwxyz
ABCDEFGHIJKLMNOPQRSTUVWXYZ
0123456789
0123456789abcdefABCDEF
!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~

# # Define a test string
# test_string = "The quick brown fox jumps OVER the laze dog."

# use an iterator to see if a string contains any punctuation
if any(c in string.punctuation for c in test_string):
    print("The string contains punctuation.")
else:
    print("No punctuation found.")

# output
The string contains punctuation.

# generate a secure random password
alphabet = string.ascii_letters + string.digits + string.punctuation
import secrets
password = ''.join(secrets.choice(alphabet) for i in range(10))
print(password)

# output
%%o'?T%nw5

# Check the strength of a password
def check_password_strength(password):
    """ To keep things simple,
        we'll just assume that a password that
        has more than or equal to 10 letters,
        and has at least one character each of punctuation digits,
        and lower and uppercase letters is string. """
    if (len(password) >= 10 and
        any(char in string.punctuation for char in password) and
        any(char in string.digits for char in password) and
        any(char in string.ascii_letters for char in password)):
        return f"{password} is a string password."
    else:
        return f"{password} is a weak password."

print(check_password_strength("MyTestPa$$123!"))
print(check_password_strength("password"))
print(check_password_strength("pa$$w0rd!"))

# output
MyTestPa$$123! is a string password.
password is a weak password.
pa$$w0rd! is a weak password.

test_string = "The quick brown fox jumps OVER the lazy dog."

# Using find() to find the first occurrence of a substring. (remind: it's case sensitive)
print("First occurrence of 'the':", test_string.find('the'))

# Using index() to find the first occurrence of a substring (raises ValueError if not)
print("First occurrence of 'the':", test_string.index('the'))
try:
    print("First occurrence of 'fax':", test_string.index('fax'))
except ValueError as e:
    print(e)

# The 'in' operator can be used for Boolean testing.
print("Is 'fox' present:", "fox" in test_string)

# Using rfind() to find the last occeuuence of a substring.
print("Last occurrence of 'the':", test_string.rfind('the'))

# Using rindex() to find the last occeuuence of a substring (raises ValueError if not)
print("Last occurrence of 'jump':", test_string.rindex('jump'))

# replace() function will find content in the string and replace it.
# Now, one of the things to keep in mind is that, in Python,
# strings are immutable.
result = test_string.replace("lazy", "tired")
print(result)

# output
First occurrence of 'the': 31
First occurrence of 'the': 31
substring not found
Is 'fox' present: True
Last occurrence of 'the': 31
Last occurrence of 'jump': 20
The quick brown fox jumps OVER the tired dog.

# Manipulating string content

test_string = "The quick brown fox jumps OVER the lazy dog."

# upper, lower, title
print(test_string.upper())
print(test_string.lower())
print(test_string.title())

# output
THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG.
the quick brown fox jumps over the lazy dog.
The Quick Brown Fox Jumps Over The Lazy Dog.

# strip, lstrip, rstrip
test_string2 = "   This string has whitespace   "

all_stripped_str = test_string2.strip()
print(test_string2.strip(), "len:", len(all_stripped_str))

left_stripped_str = test_string2.lstrip()
print(test_string2.lstrip(), "len:", len(left_stripped_str))

right_strriped_str = test_string2.rstrip()
print(test_string2.rstrip(), "len:", len(right_strriped_str))

# output
This string has whitespace len: 26
This string has whitespace    len: 29
   This string has whitespace len: 29

# split creates a sequence from a single string
words = test_string.split()
print(words)

# join concatenates ab iterable into a single string
say_hello = ["Hello", "world", "from", "Python"]
separator = " "
print(separator.join(say_hello))

# output
['The', 'quick', 'brown', 'fox', 'jumps', 'OVER', 'the', 'lazy', 'dog.']
Hello world from Python

# Formatting output strings

# Basic formatting - center(), ljust(), rjust()
# Python took care of the calculations of how long the string was
# and where to center it, or left, or right justify it in each one.
# width = 40

print("center".center(width, '-'))
print("left".ljust(width, '-'))
print("right".rjust(width, '-'))

# output
-----------------center-----------------
left------------------------------------
-----------------------------------right

# Formatting strings with format specification codes
val_1 = 1234.5678
val_2 = 10987.65
val_3 = 12.99
val_4 = -280.7

print(f"{val_1:.2f}")
print(f"{val_2:.2f}")
print(f"{val_3:.2f}")
print(f"{val_4:.2f}")

# output
1234.57
10987.65
12.99
-280.70


# Use alignment and width and leading zeros
print(f"{val_1:>10.2f}") # right align within 10 spaces
print(f"{val_2:>10.2f}")
print(f"{val_3:>10.2f}")
print(f"{val_4:>10.2f}")

# output
   1234.57
  10987.65
     12.99
   -280.70

# Use a grouping option and +/- signs
print(f"{val_1:>-10,.2f}")
print(f"{val_2:>-10,.2f}")
print(f"{val_3:>-10,.2f}")
print(f"{val_4:>-10,.2f}")

# ouput
  1,234.57
 10,987.65
     12.99
   -280.70

# Insert a fill character
print(f"{val_1:_>-10,.2f}")
print(f"{val_2:_>-10,.2f}")
print(f"{val_3:_>-10,.2f}")
print(f"{val_4:_>-10,.2f}")

# output
__1,234.57
_10,987.65
_____12.99
___-280.70

# Create format specifiers dynamically
format_spec = "{val:{width}.{precision}f}".format(val=val_2, width=10, precision=2)
print(format_spec)

# output
  10987.65

# String processing example

import string

def process_string(the_str, term):
    result = {
        "Punctuation": 0,
        "Whitespace": 0,
        "Uppercase": 0,
        "Lowercase": 0,
        "Found": False,
        "Index": -1
    }

    for char in the_str:
        if char in string.punctuation:
            result["Punctuation"] += 1
        elif char in string.whitespace:
            result["Whitespace"] += 1
        elif char in string.ascii_uppercase:
            result["Uppercase"] += 1
        elif char in string.ascii_lowercase:
            result["Lowercase"] += 1
    
    result["Index"] = the_str.upper().find(term.upper())
    result["Found"] = result["Index"] >= 0

    return result

test_string = "The quick, brows 'fox' jumps OVER the lazy dog."
search_term = "Fox"

result = process_string(test_string, search_term)
print(result)


# output
{'Punctuation': 4, 'Whitespace': 8, 'Uppercase': 5, 'Lowercase': 30, 'Found': True, 'Index': 18}

# 대소문자 카운트
text = 'Hello Mr. Rogers, how are you this fine Tuesday?'

def count_lower_upper(strings):
    upper_case, lower_case, other_case = (0, 0, 0)
    for t in text:
        if t.isupper():
            upper_case += 1
        elif t.islower():
            lower_case += 1
        elif t.isspace():
            continue
        else:
            other_case += 1

    return {"lower_case": lower_case, "upper_case": upper_case, "other_case": other_case, "original": strings}

print(count_lower_upper(text))
##output
{'lower_case': 33, 'upper_case': 4, 'other_case': 3, 'original': 'Hello Mr. Rogers, how are you this fine Tuesday?'}