8. 객체와 클래스
생성자는 init(self)를 사용 ( __init__ )
생성자 역할은 인스턴스 변수(객체 내부의변수)를 초기화 하는데 사용하며
통상, 첫 인스턴스 변수는 (self,)사용하는데 java에서 this와 유사하다
함수에 인자가 없어도 self 무조건 사용
인스턴스 변수
: 생성자에서 초기화 되면 self.변수 형태
python에서 class는 namespace와 유사하다/ 이때 x.a는 인스턴스의 변수이다
# 원을 클래스로 표현
# 원을 초기화하는 생성자, 원은 반지름을 속성으로 가짐,
# 원의 넓이와 둘레를 반환하는 getArea()와 getPerimeter()를 메소드로 정의
import math
# Circle 클래스를 정의
class Circle:
def __init__(self, radius = 0):
self.radius = radius
def getArea(self):
return math.pi * self.radius * self.radius
def getPerimeter(self):
return 2 * math.pi * self.radius
c = Circle(10) # Circle 객체를 생성한다.
print("원의 면적", c.getArea())
print("원의 둘레", c.getPerimeter())
파이썬에서 인스턴스 변수를 private로 정의하려면 변수 이름 앞에 '__' 를 붙이기
private로 정의된 변수는 클래스 내부에서만 접근 가능
ex) self.__name = name
dir(obj)는 class 내부에 있는 변수 함수등을 보여준다.
- 인스턴스 변수값을 반환하는 접근자 getter : 값 참조하기 위해 사용
- 인스턴스 변수값을 설정하는 설정자 setter : 값 수정하기 위해 사용
# 은행 계좌를 클래스로 모델링
# 은행 계좌는 현재 잔액만을 인스턴스 변수로
# 생성자와 인출 메소드 withdraw()와 저축 메소드 deposit() 가정
# 은행 계좌 잔액은 외부에서 접근 불가능
class BankAccount:
def __init__(self):
self.balance = 0
def deposit(self, amount):
self.balance += amount
print(f"{amount}원 입금, 현재 잔액 = {self.balance}원")
def withdraw(self, amount):
if self.balance < amount:
print("잔액이 부족합니다.")
return
else:
self.balance = amount
print(f"{amount}원 출금, 현재 잔액 = {self.balance}원")
a = BankAccount()
a.deposit(100)
a.withdraw(10)
a.withdraw(100)
# 로켓을 나타내는 Rocket 클래스
# 위치 x,y 인스턴스 변수, x,y를 초기화 시키고
# __init__(self, x, y) : 생성자 함수
# __str__(self) : 로켓 정보를 문자열로 변환
# moveUp(self) : 로켓 y좌표가 1 만큼 증가
# goto(self, x, y) : 로켓을 특정 위치로 jump
class Rocket:
def __init__(self, x = 0, y = 0):
self.x = x
self.y = x
def __str__(self):
return f"로켓의 위치 = ({self.x}, {self.y})"
def moveUp(self):
self.y += 1
def goto(self, x, y):
self.x = x
self.y = y
myRocket = Rocket()
print(myRocket)
myRocket.moveUp()
print(myRocket)
myRocket.goto(100, 200)
print(myRocket)
# 상자를 나타내는 Box 클래스 생성
# Box 클래스는 가로, 세로, 높이를 나타내는 private 인스턴스 변수를 가짐
# 인스턴스 변수 : length, height, depth
# __init__(self, l, h, d) : 생성자 함수
# __str__() : 상자 정보를 문자열로 변환하는 함수
# setter 함수들 : 3개의 변수에 대한 setter 함수
# getter 함수들 : 3개의 변수에 대한 getter 함수
class Box:
def __init__(self, l, h, d):
self.__l = l
self.__h = h
self.__d = d
def __str__(self):
return f"박스의 크기 = ({self.__l} * {self.__h} * {self.__d})"
# getter
def getLength(self):
return self.__l
def getHeight(self):
return self.__h
def getDepth(self):
return self.__d
# setter
def setLength(self, l):
self.__l = l
def setHeight(self, h):
self.__h = h
def setDepth(self, d):
self.__d = d
b1 = Box(100, 200, 300)
print(b1)
print("상자의 부피 =", b1.getLength() * b1.getHeight() * b1.getDepth())
b1.setHeight(20)
print(b1)
print("상자의 부피 =", b1.getLength() * b1.getHeight() * b1.getDepth())
# Stack을 클래스로 구현
# __data : 데이터를 저장하는 리스트
# __init__(self) : 생성자 함수
# push(self, e) : 스택에 원소 e 추가
# pop(self) : 가장 나중에 추가한 원소를 삭제하고 반환(Stack Empty면 None 반환)
# top(self) : Stack top 의 원소를 반환(삭제 x)
# __len__(self) : 스택원소 수를 반환
class Stack:
def __init__(self):
self.__data = []
def push(self, e):
self.__data.append(e)
def pop(self):
if len(self.__data) == 0:
raise Exception('Stack Empty')
#return None
else:
return self.__data.pop()
def top(self):
if len(self.__data) == 0:
return None
else:
return self.__data[-1]
def __len__(self):
return len(self.__data)
S= Stack()
S.push(1)
S.push(5)
S.push(3)
print(len(S))
print(S.pop())
print(S.top())
2개의 변수가 동일한 객체를 참조하고 있는지 검사하는 연산자
is, is not
: 변수가 가리키는 객체를 비교 (id 같은지)
(== 는 변수의 값을 비교)
변수가 현재 아무 값도 가리키지 않고 있다면 None으로 설정
None : 아무것도 참조하고 있지 않다는 것을 나타내는 특별한 값
클래스 변수 : 모든 클래스의 인스턴스들이 공유하는 변수
# 벡터는 2차원 공간에서 2개의 실수로 표현
# (a, b) + (c, d) = (a + c, b + d)
# (a, b) - (c, d) = (a - c, b - d)
# 특수 메소드를 이용하여 + 연산과 - 연산, str() 메소드를 구현
class Vector2D:
def __init__(self, x, y):
self.x = x
self.y = y
def __add__(self, other):
return Vector2D(self.x + other.x, self.y + other.y)
def __sub__(self, other):
return Vector2D(self.x - other.x, self.y - other.y)
def __eq__(self, other):
return self.x == other.x and self.y == other.y
def __str__(self):
return f"({self.x}, {self.y})"
u = Vector2D(0,1)
v = Vector2D(1,0)
w = Vector2D(1,1)
a = u + v
print(a)
정렬까지 하는 경우
# 벡터는 2차원 공간에서 2개의 실수로 표현
# (a, b) + (c, d) = (a + c, b + d)
# (a, b) - (c, d) = (a - c, b - d)
# 특수 메소드를 이용하여 + 연산과 - 연산, str() 메소드를 구현
class Vector2D:
def __init__(self, x, y):
self.x = x
self.y = y
def __add__(self, other):
return Vector2D(self.x + other.x, self.y + other.y)
def __sub__(self, other):
return Vector2D(self.x - other.x, self.y - other.y)
def __eq__(self, other):
return self.x == other.x and self.y == other.y
def __str__(self):
return f"({self.x}, {self.y})"
def __repr__(self):
return f"({self.x}, {self.y})"
def __gt__(self, other):
return self.x **2 + self.y **2 > other.x**2 + other.y**2
u = Vector2D(0,1)
v = Vector2D(1,0)
w = Vector2D(1,1)
a = u + v
print(a)
w = Vector2D(2,0)
A = [w, u, v, u+w, a, a+w, a+w+a]
A.sort()
print(A)
# 사각형을 나타내는 Rectangle 클래스
# x, y : 사각형의 좌측 하다느이 좌표, width, height : 사각형의 너비와 높이
# __init(self, x, y, w, h) : 생성자 함수
# __str__() : 사각형 정보를 문자열로 변환하는 함수
# __gt__(self, other) : 사각형의 면적이 크면 True, 아니면 False
# overlap(self, other) : 현재 사각형과 인자로 넘어온 사각형이 곂치면 True, 아니면 False
class Rectangle:
def __init__(self, x, y, w, h):
self.x = x
self.y = y
self.w = w
self.h = h
def __str__(self):
return f"좌측 하단: ({self.x}, {self.y}), 너비와 높이: ({self.w},{self.h})"
def __gt__(self, other):
return self.w * self.h > other.w * other.h
def overlap(self, other):
if self.x + self.w <= other.x + other.w <= self.x:
return False
if self.y + self.h <= other.y + other.h < self.x:
return False
return True
r1 = Rectangle(0, 10, 10, 10)
r2 = Rectangle(5, 5, 10, 5)
print(r1)
print(r2)
print("r1 > r2 ? ", r1>r2)
print("r1과 r2가 곂치는가?", "네" if r1.overlap(r2) else "아니오")
# 사람들의 연락처를 저장하는 PhoneBook 클래스는 사전을 이용하여 연락처를 저장
# contact : 연라거를 저장하는 dictionary, 연락처는 {이름: (전화번호, 이메일)}로 구성
# __init__(self) : 생성자 함수
# __str__(self) : 연락처 정보를 문자열로 변화하는 함수
# add(self, name, phone = None, email = None) : 한 사람의 연락처를 추가하는 함수
# get(self, name) : 이름을 입력받아, 전화번호와 이메일을 반환
class PhoneBook:
def __init__(self):
self.contact = {}
def __str__(self):
msg = ""
for key, value in self.contact.items():
msg += f"{key}\n전화번호:{value[0]}\n이메일:{value[1]}\n"
return msg
def add(self, name, phone = None, email = None):
self.contact[name] = (phone, email)
def get(self, name):
if name in self.contact:
return self.contact[name]
else:
return None
pb = PhoneBook()
pb.add("Cho", phone = "010-1234-5678")
pb.add("Kim", phone = "010-2345-6789")
print(pb)
print("Cho의 주소록 = ", pb.get("Cho"))
10. 상속
- 기존 코드의 재사용
- 코드 중복을 최소화
상속을 받게되면 super를 이용하여 부모클래스에 대해 생성자를 작성 해야 하지만
다중 상속인 경우 super 대신 클래스 이름을 사용 이때 "self"를 작성해야함.
또한, 다중 상속인 경우, 부모 클래스가 여러개 있으므로 super().__init__() 방식 불가능
따라서 클래스이름.__init__() 방식 사용
isinstance() : 특정 클래스의 인스턴스인지 체크해주는 함수
메소드 오버라이딩
: 자식 클래스의 메소드가 부모 클래스의 메소드를 오버라이드(재정의) 한다.
ex) super().draw() -> 부모의 메소드 호출시 super. 을 붙임
# 2차원 공간의 한 점(x,y)를 나타내는 클래스 Pointer를 정의
# __init__() 메소드는 self, x, y를 받아서 멤버변수에 할당
# __str__() 메소드를 정의하여 "(x,y)" 형태의 문자열을 반환
# Point를 상속 받아서 3차원 공간의 한 점(x,y,z)를 나타내는 Point3D 클래스를 정의
class Point:
def __init__(self,x,y):
self.x = x
self.y = y
def __str__(self):
return f"({self.x},{self.y})"
class Point3D(Point):
def __init__(self,x,y,z):
super().__init__(x,y)
self.z = z
def __str__(self):
return f"({self.x},{self.y},{self.z})"
p1 = Point(20, 30)
print(p1)
p2 = Point3D(20, 30, 40)
print(p2)
# 일반적인 함수를 나타내는 Function 클래스
# value(x) : x를 입력받아 f(x)를 반환하는 메소드
# Function의 자식클래스로 2차 방정식을 나타내는 Quadratic 클래스 정의
# __init__(self, a,b,c) <- ax^2+bx+c 를 의미
# value(x) : x를 입력받아 f(x) 반환
# get_roots() : 2차 방정식의 근을 계산하여 반환
import math
class Function:
def value(self):
pass
class Quadratic(Function):
def __init__(self, a, b, c):
self.a = a
self.b = b
self.c = c
def value(self, x):
return self.a *x **2 + self.b *x + self.c
def get_roots(self):
D = self.b **2 -4 *self.a * self.c
first = -self.b / (2*self.a)
if D == 0:
return f"중근: {first}"
elif D > 0:
second = math.sqrt(D) / (2 * self.a)
return f"실근: {first + second},{first - second}"
else:
second = math.sqrt(-D) / (2 * self.a)
return f"허근: {complex(first, second)},{complex(first, -second)}"
f1 = Quadratic(1, -4, 4)
print(f1.value(5))
print(f1.get_roots())
f2 = Quadratic(1, -4, 3)
print(f2.get_roots())
f3 = Quadratic(1, -4, 5)
print(f3.get_roots())
# Animal 클래스는 age를 속성으로 하는 클래스 : __init__()에서 age만 초기화
# Cat은 Animal의 자식 클래스이며, name과 breed를 추가로 가짐
# init과 str 외에 __gt__(self, other) 메소드를 구현하여 나이를 비교
# get_oldest_cat(*args)는 여러 개의 Cat을 입력받아, 나이가 젤 많은 고양이 객체를 반환
class Animal:
def __init__(self, age):
self.age = age
class Cat(Animal):
def __init__(self, age, name, breed):
super().__init__(age)
self.name = name
self.breed = breed
def __str__(self):
return f"이름:{self.name}, 나이:{self.age}, 종:{self.breed}"
def __gt__(self, other):
return self.age > other.age
def get_oldest_cat(*args):
return max(args)
c1 = Cat("야옹이", 4, "페르시안")
c2 = Cat("나비", 2, "아바시니안")
c3 = Cat("프린센스", 5, "러시안블루")
print("가장 나이 많은 고양이:",get_oldest_cat(c1, c2, c3))
for item in sorted([c1, c2, c3]):
print(item)
다형성(polymorphism)
: 하나의 식별자로 다양한 타입(클래스)를 처리
__repr__() : 애매모호하지않게 객체를 설명 (타입은 제약 x)
__str__() : return 타입 str로 제약
print(obj)에서 obj.__repr__()만 있을 경우에는 이를 실행. obj.__str__이 있을 경우에는 이를 실행
# Turtle 그래픽에서는 한 화면에 여러 개의 도형들을 그릴 수 있다.
# Shape를 부모 클래스로 하는 Rectangle과 Circle 클래스
# Rectangle의 생성자는 (x, y, 변의 길이, 펜의 색깔) 을 인자로 받으며,
# Circle의 생성자는 (x, y, 반지름의 길이, 펜의 색깔) 을 인자로 받음
# 모두 draw() 메소드에 의해 그림을 그림
import turtle
class Shape:
def __init__(self, x, y, color):
self.t = turtle.Turtle()
self.t.color(color)
self.t.up()
self.t.goto(x, y)
self.t.down()
self.t.width(4)
def draw(self):
pass
class Rectangle(Shape):
def __init__(self, x, y, length, color):
super().__init__(x, y, color)
self.length = length
def draw(self):
for _ in range(4):
self.t.fd(self.length)
self.t.left(90)
class Circle(Shape):
def __init__(self, x, y, r, color):
super().__init__(x, y, color)
self.r = r
def draw(self):
self.t.circle(self.r)
r1 = Rectangle(-50,-50,200,'red')
r2 = Rectangle(160,120,200,'Blue')
c1 = Circle(-120,-100,120,'green')
r1.draw()
r2.draw()
c1.draw()
turtle.mainloop()
turtle.bye()
# 대학에는 학과(Department), 과목(Course), 학생(Student) 가 존재
# 학과에는 많은 과목이 개설되며, 한 과목에는 여러 학생들이 등록 가능
# has-a 관계를 염두에 두고 아래와 같은 결과가 나오도록 프로그래밍
class Course():
def __init__(self, name, grade):
self.name = name
self.grade = grade
def __repr__(self): # str로 하면 안됨
return f"({self.name}, {self.grade})"
class Department():
def __init__(self, name):
self.name = name
self.courses = []
def __str__(self):
return f"(학과 이름 = {self.name}, 개설 과목 = {self.courses})"
def add_course(self, cname, grade):
c = Course(cname, grade)
self.courses.append(c)
return c
class Student():
def __init__(self, name, sid):
self.name = name
self.id = sid
self.courses = []
def enroll(self, courses):
self.courses.append(courses)
def __str__(self):
return f"(학생 이름 = {self.name}, 학번 = {self.id}), 수강과목 = {self.courses}"
dept = Department("컴퓨터공학과")
c1 = dept.add_course("대학생활의설계", 1)
c2 = dept.add_course("인공지능", 3)
c3 = dept.add_course("파이썬프로그래밍", 3)
print(dept)
st = Student("홍길동", 2020001)
st.enroll(c2)
st.enroll(c3)
print(st)
9. GUI 프로그래밍
tkinter 사용
from tkinter import * 로 tkinter 모듈을 포함
window = Tk() 로 가져올 수 있다.
from tkinter import *
window = Tk()
b1 = Button(window, text="박스 #1", bg="red", fg="white")
b2 = Button(window, text="박스 #2", bg="green", fg="white")
b3 = Button(window, text="박스 #3", bg="orange", fg="white")
b4 = Button(window, text="박스 #4", bg="pink", fg="white")
b1.grid(row=0, column=0) # 0행 0열
b2.grid(row=0, column=1) # 0행 1열
b3.grid(row=1, column=0) # 1행 0열
b4.grid(row=1, column=1) # 1행 1열
window.mainloop()
from tkinter import *
window = Tk()
f = Frame(window)
b1 = Button(f, text="박스 #1", bg="red", fg="white")
b2 = Button(f, text="박스 #2", bg="green", fg="black")
b3 = Button(f, text="박스 #3", bg="orange", fg="white")
b1.pack(side=LEFT)
b2.pack(side=LEFT)
b3.pack(side=LEFT)
l = Label(window, text="이 레이블은 버튼들 위에 배치된다.")
l.pack()
f.pack()
window.mainloop()
↘ 컨테이너 중 가장 대표적인게 frame
frame 하나 생성하고 버튼이 frame에 포함되니 frame id 써주기
레이블 밑에 frame이 쌓이고 frame 밑에 버튼이 쌓임
버튼 이벤트 처리
버튼 속성에 command-함수속성 주기
# 클릭하세요 버튼 선택시 터미널 창에 버튼이 클릭되었습니다 뜨게
from tkinter import *
def process():
print("버튼이 클릭되었습니다.")
window = Tk()
button = Button(window, text="클릭하세요!", command=process)
button.pack()
window.mainloop()
# 증가 버튼을 누르면 버튼 클릭 횟수가 증가되고 리셋 버튼으로 리셋 가능하게
from tkinter import *
window = Tk()
counter = 0
def clicked():
global counter
counter += 1
label['text'] = '버튼 클릭 횟수: ' + str(counter)
def reset():
global counter
counter = 0
label['text'] = '버튼 클릭 횟수: ' + str(counter)
label = Label(window, text="아직 눌려지지 않음")
label.pack()
button = Button(window, text="증가", command=clicked).pack()
button = Button(window, text="리셋", command=reset).pack()
window.mainloop()
화씨->섭씨, 섭씨->화씨, 리셋 버튼 만들기
##
# 온도 변환 프로그램을 GUI 기반으로 구현한다.
#
from tkinter import *
# 이벤트 처리 함수를 정의한다.
def ftof():
tf = float(e1.get()) # e1에서 문자열을 읽어서 부동소수점형으로 변경
tc = (tf-32.0)*5.0/9.0 # 화씨 온도를 섭씨 온도로 변환한다.
e2.delete(0, END) # 처음부터 끝까지 지운다.
e2.insert(0, str(tc)) # tc 변수의 값을 문자열로 변환하여 추가한다.
def ctof():
tc = float(e2.get())
tf = tc * 1.8 +32
e1.delete(0, END)
e1.insert(0, str(round(tf, 2)))
def reset():
e1.delete(0, END)
e2.delete(0, END)
e1.focus_set() # 리셋 후 커서 위치 E1으로 지정
window = Tk()
Label(window , text="화씨").grid(row=0, column=0)
Label(window, text="섭씨").grid(row=1, column=0)
e1 = Entry(window)
e2 = Entry(window)
e1.grid(row=0, column=1)
e2.grid(row=1, column=1)
Button(window, text="화씨->섭씨", command=ftof).grid(row=2, column=0, sticky=W+E)
Button(window, text="섭씨->화씨", command=ctof).grid(row=2, column=1, sticky=W+E)
Button(window, text="reset", command=reset).grid(row=3, column=0, sticky=W+E, columnspan=2)
window.mainloop()
-> Entry는 입력의 역할도 하면서 출력해주는 역할도 함
Widget의 속성 변경 방법
- label["text"] = 변경된 텍스트
- label.config(text = "또 다른 텍스트")
************* 밑 예제 text="1" 말고 다른거로 수정******
주사위 굴리기 시뮬레이션
"굴리기" 버튼을 클릭하면 1부터 6사이의 정수가 랜덤하게 표시
정수 폰트 : ("Arial", 100, "bold")
버튼 폰트 : ("Arial", 20, "bold")
window.geometry("300x300")
from tkinter import *
import random
def run():
Label["text"] = str(random.randint(1, 6))
window = Tk()
window.geometry("300x300")
window.title("주사위 굴리기")
label = Label(window, text="1", font=("Arial", 100, "bold"), fg="red")
label.pack(side=LEFT)
Button(window, text="굴리기", font=("Arial", 28, "bold"), fg="blue", command=run).pack(side=RIGHT)
number = random.randint(1, 6)
window.mainloop()
데이터 입력 시뮬레이션
데이터를 입력받아 이름, 직업 나이를 입력 받고 "처리" 버튼을 누르면 터미널에 뜨게,
"다시 입력" 버튼을 누르면 리셋
from tkinter import *
def process():
for x in range(3):
print(f"{labels[x]} = {entries[x].get()}", end=" ")
print()
def reset():
for x in range(3):
entries[x].delete(0, END)
entries[0].focus_set()
window = Tk()
labels = ["name", "job", "age"]
entries = []
for x in range(3):
Label(window, text=labels[x]).grid(row=x, column=0)
entries.append(Entry(window))
entries[x].grid(row=x, column=1)
frame = Frame(window)
frame.grid(row=3, column=1)
Button(frame, text="처리", command=process).pack(side=LEFT)
Button(frame, text="다시 입력", command=reset).pack(side=RIGHT)
window.mainloop()
화면에 그림 그리기
캔버스(Canvas) 위젯을 생성한 후, 캔버스에 다양한 그림(사각형, 원, 선 등)을 그릴 수 있다.
캔버스에 추가된 도형들의 속성 변경 메소드
- Canvas.coords(obj_id, x1, y1, x2, y2) : 객체의 위치와 크기를 변경
- Canvas.itemconfig(obj_id, fill="blue") : 객체의 속성을 변경
- Canvas.move(obj_id, deltaX, deltaY) : 객체를 이동 (위치 변경)
버튼이 눌리면 해당 도형, 텍스트를 캔버스에 그리기
draw.py 프로그램을 확장하여 아래 그림과 같이 "Image"와 "Text" 버튼을 추가하라.
Image 버튼을 클릭하면 "starship.png" 파일이 왼쪽 상단에 출력된다.
"Text" 버튼을 클릭하면, "안녕하세요. 좋은 하루 되세요~~"라는 메시지가 화면의 중앙에 출력된다.
##
# 이 프로그램은 버튼이 눌리면 해당 도형을 캔버스에 그린다.
#
from tkinter import *
WIDTH = 600
HEIGHT = 200
def displayRect():
canvas.create_rectangle(10,10,WIDTH-10,HEIGHT-10)
def displayOval():
canvas.create_oval(10,10,WIDTH-10,HEIGHT-10, fill="yellow")
def displayArc():
canvas.create_arc(10,10,WIDTH-10,HEIGHT-10,start=0,
extent=120,width=10,fill='blue')
def displayPolygon():
canvas.create_polygon(10,10,WIDTH-10,HEIGHT-10,200,90,300, 160)
def displayLine():
canvas.create_line(10,10,WIDTH-10,HEIGHT-10,fill='green')
def clearCanvas(): # 캔버스 모든 객체 지우기
canvas.delete(ALL)
def displayImage():
canvas.create_image(20,20, anchow=NW, image=img)
def displayText():
canvas.create_text(WIDTH//2, HEIGHT//2, text="안녕하세요. 좋은 하루 되세요~", font=("Arial", 20), fill='green')
window=Tk()
canvas=Canvas(window, width=WIDTH, height=HEIGHT, bg='white')
canvas.pack()
frame=Frame(window)
frame.pack()
img=PhotoImage(file="starship.png")
btRectangle=Button(frame, text="Rectangle", command=displayRect).grid(row=1,column=2)
btOval=Button(frame,text="Oval",command=displayOval).grid(row=1,column=3)
btArc=Button(frame, text="Arc",command=displayArc).grid(row=1,column=5)
btPolygon=Button(frame, text="Polygon",command=displayPolygon).grid(row=1,column=4)
btLine=Button(frame, text="Line",command=displayLine).grid(row=1,column=1)
btImage=Button(frame,text="Image",command=displayImage).grid(row=1,column=7)
btText=Button(frame,text="Text",command=displayText).grid(row=1,column=8)
btClear=Button(frame,text="Clear",command=clearCanvas).grid(row=1,column=9)
window.mainloop()
'파이썬 & 머신러닝과 딥러닝' 카테고리의 다른 글
| 6일차 - 다양한 Numpy 관련 기초 내용 및 Numpy를 활용한 기상데이터 분석 학습 (1) | 2024.01.11 |
|---|---|
| 5일차 - MySQL, pymysql, tkinter와 pymysql 연동, 기상청 데이터 분석, 인구 현황 분석 (1) | 2024.01.10 |
| 4일차 - 파일과 예외처리, 내장함수, 람다식, 모듈, Top-K 텍스트 분석, CF기반 추천 시스템 (1) | 2024.01.09 |
| 2일차 파이썬 - 리스트, 튜플, 집합, 사전, 문자열 (1) | 2024.01.05 |
| 1일차 파이썬 - 입력과 출력, 변수와 수식, 조건문, 반복문, 함수 (2) | 2024.01.04 |
