burningrizen

[gui] tkinter 로 다중 option menu 구현

burningrizen — Sun, 29 Nov 2020 19:48:42 +0900

import tkinter as tk


class OptionMenu:
    width = 90
    font = ("Ubuntu", 12)
    side = "top"

    label = None
    menus = list()

    @classmethod
    def create_menus(cls, win, menus):
        cls.menus = [{"menu": OptionMenu(option_list=menu, win=win, index=i), "text": menu[0]} for i, menu in enumerate(menus)]
        OptionMenu.add_label()

    def __init__(self, option_list=None, win=None, index=None):
        self.option_list = option_list
        self.var = tk.StringVar(win)
        self.var.set(self.option_list[0])
        self.var.trace("w", self.callback)

        self.index = index
        self.menu = tk.OptionMenu(win, self.var, *self.option_list)
        self.menu.config(width=OptionMenu.width, font=OptionMenu.font)
        self.menu.pack(side=OptionMenu.side)

    def callback(self, *args):
        OptionMenu.menus[self.index]["text"] = self.var.get()
        OptionMenu.set_label()

    @classmethod
    def add_label(cls):
        cls.label = tk.Label(text="", font=cls.font, fg='blue')
        cls.label.pack(side="top")

    @classmethod
    def set_label(cls):
        texts = [menu["text"] for menu in cls.menus]
        dress = Fashion.get_dress(texts)
        cls.label.configure(text=dress)


class Fashion:
    season = None
    temperature = None
    is_accessories = None
    is_comfortable = None
    is_outer = None

    options = [
        ("봄", "여름", "가을", "겨울"),
        ("따뜻한", "시원한"),
        ("악세사리 착용", "악세사리 없음"),
        ("편안한 신발", "편안하지 않은 신발"),
        ("겉옷 착용", "겉옷 없음"),
    ]

    tops = {
        "봄": {"따뜻한": "빨간색 긴팔", "시원한": "흰색 긴팔"},
        "여름": {"따뜻한": "빨간색 반팔", "시원한": "흰색 반팔"},
        "가을": {"따뜻한": "빨간색 니트", "시원한": "파란색 니트"},
        "겨울": {"따뜻한": "빨간색 목폴라", "시원한": "파란색 니트"},
    }
    bottoms = {
        "봄": {"따뜻한": "진한 청바지", "시원한": "연한 청치마"},
        "여름": {"따뜻한": "베이지 면치마", "시원한": "연한 숏 청바지"},
        "가을": {"따뜻한": "베이지 긴바지", "시원한": "하늘색 원피스"},
        "겨울": {"따뜻한": "베이지 긴바지", "시원한": "체크무늬 롱셔츠"},
    }
    accessories = {
        "봄": {"따뜻한": "검정 에코백", "시원한": "네이비 캡"},
        "여름": {"따뜻한": "흰색 캡", "시원한": "하늘색 팔찌"},
        "가을": {"따뜻한": "갈색 머플러", "시원한": "베이지 머플러"},
        "겨울": {"따뜻한": "갈색 머플러", "시원한": "검정 머플러"},
    }
    outers = {
        "봄": "트렌치코트",
        "여름": "흰색 롱셔츠",
        "가을": "트렌치코트",
        "겨울": "베이지울코트",
    }
    shoes = {
        "봄": {"따뜻한": {"편안한 신발": "흰색 캔버스", "편안하지 않은 신발": "갈색워커"},
              "시원한": {"편안한 신발": "검정 캔버스", "편안하지 않은 신발": "검정 로퍼"}, },

        "여름": {"따뜻한": {"편안한 신발": "흰색 캔버스", "편안하지 않은 신발": "검정 구두"},
               "시원한": {"편안한 신발": "흰색 샌들", "편안하지 않은 신발": "흰색 워커"}, },

        "가을": {"따뜻한": {"편안한 신발": "검정 캔버스", "편안하지 않은 신발": "검정 구두"},
               "시원한": {"편안한 신발": "흰색 캔버스", "편안하지 않은 신발": "검정 로퍼"}, },

        "겨울": {"따뜻한": {"편안한 신발": "검정 캔버스", "편안하지 않은 신발": "검정 구두"},
               "시원한": {"편안한 신발": "흰색 캔버스", "편안하지 않은 신발": "검정 워커"}, },
    }

    @classmethod
    def convert(cls, words):
        cls.season, cls.temperature, cls.is_accessories, cls.is_comfortable, cls.is_outer = words

    @classmethod
    def get_dress(cls, words):
        cls.convert(words)
        top = cls.tops[cls.season][cls.temperature]
        bottom = cls.bottoms[cls.season][cls.temperature]
        accessory = cls.accessories[cls.season][cls.temperature] if "없음" not in cls.is_accessories else "없음"
        outer = cls.outers[cls.season] if "없음" not in cls.is_outer else "없음"
        shoe = cls.shoes[cls.season][cls.temperature][cls.is_comfortable]

        return f"상의: {top}\n하의: {bottom}\n악세사리: {accessory}\n겉옷: {outer}\n신발: {shoe}"


app = tk.Tk()
app.title("Fashion")
app.geometry('400x250')
OptionMenu.create_menus(app, Fashion.options)
app.mainloop()

구글크롬원격

burningrizen — Wed, 25 Nov 2020 20:05:53 +0900

remotedesktop.google.com/support/

[python] 호텔 평점 프로젝트

burningrizen — Sun, 8 Nov 2020 21:40:21 +0900

[Python] Pillow 영상처리 이미지 회전

burningrizen — Wed, 14 Oct 2020 23:09:04 +0900

import math
from PIL import Image


def rotate(x, y, theta, pi=3.14):
    radian = theta * pi / 180
    sin = math.sin(radian)
    cos = math.cos(radian)
    new_x = cos*x - sin*y
    new_y = sin*x + cos*y
    return new_x, new_y


def rotate_img(ori, theta):
    dst = Image.new("RGB", ori.size, (0, 0, 0))
    width, height = ori.size
    pixels_dst = dst.load()
    pixels_ori = ori.load()
    for y in range(height):
        for x in range(width):
            rotate_x, rotate_y = rotate(x, y, theta)
            if 0 <= rotate_x < width and 0 <= rotate_y < height:
                pixels_dst[rotate_x, rotate_y] = pixels_ori[x, y]
    return dst


img = Image.open("./img/rirak.jpg")
dst = rotate_img(img, 5)
img.show()
dst.show()

이차원 좌표에서 이미지 회전 공식

파이썬에서 각세타가 아니라 라디안으로 math 함수에 인자를 넣어야함

라디안 = 세타 * pi / 180

[python] 은행프로그램

burningrizen — Thu, 2 Jul 2020 22:13:19 +0900

1. 계좌생성

> 예금주 계좌번호 입금액

2. 입금

> 계좌번호 입금액

3. 출금

> 계좌번호 출금액

4. 이체

> 출금계좌번호 입금계좌번호 액수

5. 조회

> 계좌번호

6. 저장

> 파일로 일괄저장

> 계좌번호.txt
> 계좌번호 파일에 통장이력은 아래와 같음

(기록시간, 입금 혹은 출금, 액수, 잔액)

import datetime


class Log:
    def __init__(self, add=0, sub=0, balance=0):
        self.now = datetime.datetime.now()
        if add:
            self.add = add
        if sub:
            self.sub = sub
        self.balance = balance

    def __str__(self):
        return f"{','.join(map(str, self.__dict__.items()))}"


class Account:
    def __init__(self, name, number):
        self.name = name
        self.number = number
        self.logs = list()
        self.balance = 0

    def add(self, add=0, sub=0):
        if add:
            self.balance += add
        if sub:
            self.balance -= sub
        log = Log(add=add, sub=sub, balance=self.balance)
        self.logs.append(log)

    def send(self, other, amount):
        self.add(sub=amount)
        other.add(add=amount)

    def __get_logs(self):
        return "\n".join(map(str, self.logs))

    def write(self):
        with open(f"./out/{self.number}.txt", "w") as f:
            f.writelines(self.__get_logs())

    def __str__(self):
        head = f"name={self.name} number={self.number}\n"
        body = self.__get_logs()
        return head + body


class Bank:
    def __init__(self):
        self.accounts = list()

    def find_account(self, number):
        accounts = list(filter(lambda account: account.number == number, self.accounts))
        return accounts[0] if accounts else None

    def create(self, name, number, amount):
        if not self.find_account(number):
            account = Account(name, number)
            account.add(add=amount)
            self.accounts.append(account)
            print(account)

    def deposit(self, number, amount):
        account = self.find_account(number)
        if account:
            account.add(add=amount)
            print(account)

    def withdrawal(self, number, amount):
        account = self.find_account(number)
        if account:
            account.add(sub=amount)
            print(account)

    def remittance(self, start_number, target_number, amount):
        start_account = self.find_account(start_number)
        target_account = self.find_account(target_number)
        if start_number and target_number:
            start_account.send(target_account, amount)
            print(start_account)
            print(target_account)

    def show_account(self, number):
        account = self.find_account(number)
        if account:
            print(account)

    def write(self):
        for account in self.accounts:
            account.write()


class CmdManager:
    def __init__(self):
        pass


def main():
    bank = Bank()
    while True:
        menu = input("메뉴를 입력 하시오\n")
        if menu == "1":
            cmd = input("개설할 계좌 예금주, 계좌번호, 입금금액을 입력하시오\n").split()
            name, number, amount = cmd[0], cmd[1], int(cmd[2])
            bank.create(name=name, number=number, amount=amount)

        elif menu == "2":
            cmd = input("입글할 계좌번호와 금액을 입력하시오\n").split()
            if len(cmd) == 2:
                number, amount = cmd[0], int(cmd[1])
                bank.deposit(number=number, amount=amount)

        elif menu == "3":
            cmd = input("출금할 계좌번호와 금액을 입력하시오\n").split()
            if len(cmd) == 2:
                number, amount = cmd[0], int(cmd[1])
                bank.withdrawal(number=number, amount=amount)

        elif menu == "4":
            cmd = input("이체할 계좌번호, 입금할 계좌번호, 금액을 입력하시오\n").split()
            if len(cmd) == 3:
                start_number, target_number, amount = cmd[0], cmd[1], int(cmd[2])
                bank.remittance(start_number=start_number, target_number=target_number, amount=amount)

        elif menu == "5":
            cmd = input("조회할 계좌번호를 입력하시오\n").split()
            if len(cmd) == 1:
                number = cmd[0]
                bank.show_account(number)

        elif menu == "6":
            bank.write()
            exit("수업종료")
        else:
            print("잘못된 명령어 입니다.")


main()

[python] inner 함수, 이너 함수

burningrizen — Tue, 30 Jun 2020 00:10:45 +0900

1. inner 를 리턴해서 메모리에서 inner 가 해제되지 않는다.

2. 변수 a 가 해제되지 않는다.

3. 함수형 프로그래밍에서 상태값을 유지할 수 있다.

def wrapper():
    a = 0

    def inner():
        nonlocal a
        a += 1
        return a
    return inner


f = wrapper()
for _ in range(10):
    print(f())

[python] 지하철 승하차 기록 조회

burningrizen — Sun, 7 Jun 2020 15:08:08 +0900

승하차기록파일

metro.zip.001

4.02MB

1. 년월, 역이름 으로 필터

2. 필터된 승하차 총합을 구함

3. plotly 설치후 그래프로 표시

def read_file(path):
    with open(path, "r") as f:
        return f.readlines()


class Log:
    def __init__(self, date=None, line=None, station=None, in_outs=None):
        self.date = date
        self.line = line
        self.station = station
        self.in_outs = in_outs

    def __str__(self):
        return f"{self.__dict__}"

    @classmethod
    def line_to_list(cls, line):
        line = line.replace('"', "").replace("\n", "")
        line = line.split(",")
        return line

    @classmethod
    def __get_times(cls, times):
        in_outs = {}
        time_stamp = 4
        for i, in_out in enumerate(times):
            if i + 1 < len(times):
                key = f"{'0'+str(time_stamp) if time_stamp < 10 else time_stamp}" \
                      f"{'0'+str(time_stamp+1) if time_stamp+1 < 10 else time_stamp+1}"
                in_outs[key] = (times[i], times[i+1])
                time_stamp += 1
        return in_outs

    @classmethod
    def line_to_ins(cls, line):
        line = cls.line_to_list(line)
        params = list()
        params.append(line[0])
        params.append(line[1])
        params.append(line[2])
        params.append(cls.__get_times(line[3:]))
        return params


class LogManager:
    def __init__(self, path):
        self.lines = read_file(path)
        self.logs = list()

    def import_logs(self, start, stop):
        for line in self.lines[start:] if stop == -1 else self.lines[start:stop]:
            log = Log(*Log.line_to_ins(line))
            self.__add(log)

    def __add(self, item):
        self.logs.append(item)

    def get_logs(self):
        return self.logs

    @classmethod
    def __filter_station(cls, logs, station):
        return list(filter(lambda log: log.station == station, logs))

    @classmethod
    def __filter_date(cls, logs, date):
        return list(filter(lambda log: log.date == date, logs))

    @classmethod
    def __get_summary_in_outs(cls, logs):
        in_outs = [0, 0]
        for log in logs:
            for in_val, out_val in log.in_outs.values():
                in_outs[0] += int(in_val)
                in_outs[1] += int(out_val)
        return in_outs

    def __get_in_outs_from_date_station(self, station, date):
        logs = LogManager.__filter_station(self.logs, station)
        logs = LogManager.__filter_date(logs, date)
        for log in logs:
            print(log)
        return LogManager.__get_summary_in_outs(logs)

    def draw_in_outs_from_date_station(self, station, date):
        in_outs = self.__get_in_outs_from_date_station(station=station, date=date)
        print(in_outs)
        import plotly.express as px
        df = px.data.tips()
        fig = px.histogram(df, title=f"station={station} date={date}", x=["in", "out"], y=in_outs)
        fig.show()


if __name__ == '__main__':
    log_manager = LogManager("out/metro.csv")
    log_manager.import_logs(1, -1)
    print("파일 임포트 완료되었습니다.")
    while True:
        cmd = input("[역이름] [년월] 입력하세요\n").split(" ")
        if len(cmd) == 2:
            log_manager.draw_in_outs_from_date_station(*cmd)
        else:
            print("잘못된 명령어 입니다.")

[python] n 진수 바꾸기

burningrizen — Wed, 3 Jun 2020 22:51:07 +0900

십진수 를 n 진수로 변경하기

def foo(r, base):
    tokens = "0123456789ABCDEF"
    result = ""
    q = r
    while q:
        q, r = divmod(q, base)
        n = tokens[r]
        result = n + result
    return result


print(foo(23, 5))

[python] 시간변환

burningrizen — Wed, 27 May 2020 12:38:38 +0900

시간 데이타 파일

22 25 0
5 30 195
17 40 200
17 15 210
0 40 -50
8 40 -200
22 10 -50
2 15 910
23 20 100
10 50 -20
8 40 200

data.txt

0.00MB

결과

22:25
8:45
21:0
20:45
23:50
5:20
21:20
17:25
1:0
10:30
12:0

output.txt

0.00MB

def read_file(path):
    with open(path, "r") as f:
        return f.readlines()


def write_file(path, lines):
    with open(path, "w") as f:
        f.writelines(lines)


def lines_to_rows(lines):
    rows = list(map(lambda x: x.replace("\n", "").split(" "), lines))
    for i, row in enumerate(rows):
        rows[i] = list(map(int, rows[i]))
    return rows


def row_to_time(row):
    hours, mins = row[0], row[1]+row[2]
    final_hours = mins // 60 + hours
    final_mins = mins % 60
    if final_hours > 24:
        final_hours -= 24
    if final_hours < 0:
        final_hours += 24
    return final_hours, final_mins


def convert(rows):
    times = []
    for i, row in enumerate(rows):
        time = row_to_time(row)
        times.append(f"{i+1}: time={time[0]}:{time[1]}")
    return "\n".join(times)


lines = read_file("data.txt")
rows = lines_to_rows(lines)
times = convert(rows)
write_file("reuslt.txt", times)

[python] 스테가노그래피

burningrizen — Mon, 25 May 2020 23:33:03 +0900

원본, 히든 이미지

Pillow 라이브러리 설치

from PIL import Image as image


def encoding(dec, data):
    val = bin(dec)[:-1] + ("1" if data else "0")
    return int(val, 2)


def decoding(dec):
    return 255 if int(bin(dec)[-1]) else 0


def encoding_pixel(color_ori, color_data):
    r = encoding(color_ori[0], color_data[0] if isinstance(color_data, tuple) else color_data)
    g = encoding(color_ori[1], color_data[1] if isinstance(color_data, tuple) else color_data)
    b = encoding(color_ori[2], color_data[2] if isinstance(color_data, tuple) else color_data)
    return r, g, b


def decoding_pixel(color_ori):
    return decoding(color_ori[0]), decoding(color_ori[1]), decoding(color_ori[2])


def insert(ori_img, data_img):
    if ori_img.size != data_img.size:
        raise ValueError("Image size is difference")
    dst = image.new("RGB", ori_img.size, (0, 0, 0))
    width, height = ori_img.size
    pixels_ori = ori_img.load()
    pixels_dst = dst.load()
    pixels_data = data_img.load()
    for y in range(height):
        for x in range(width):
            color_ori = pixels_ori[x, y]
            color_data = pixels_data[x, y]
            encoding_pixel(color_ori, color_data)
            pixels_dst[x, y] = encoding_pixel(color_ori, color_data)
    return dst


def extract(ori):
    dst = image.new("RGB", ori.size, (0, 0, 0))
    width, height = ori.size
    pixels_dst = dst.load()
    pixels_ori = ori.load()
    for y in range(height):
        for x in range(width):
            color = pixels_ori[x, y]
            pixels_dst[x, y] = decoding_pixel(color)
    return dst


if __name__ == '__main__':
    ori = image.open("./img/dog.jpg")
    data = image.open("./img/hidden.png")
    ori.show()
    data.show()
    input("press and start encoding")
    new_img = insert(ori, data)
    new_img.save("./img/encoding.png")
    new_img.show()
    input("encoding is done\npress and start decoding")
    decoding_img = extract(new_img)
    decoding_img.show()
    decoding_img.save("./img/decoding.png")
    input("decoding is done")