Typiler

파이썬을 이용하여 마우스를 특정한 위치에 자동으로 클릭하는 프로그램을 만들어 보겠습니다. 특정 위치에 대한 정보를 얻고 그 위치에 마우스 포인터를 이동 시키고 몇초 간격으로 클릭을 실행하는 프로그램입니다. 프로그램은 GUI를 이용하여 만들어 볼 건데, 저도 처음 사용하는 라이브러리인 tkinter 를 사용해 보겠습니다. 간단한 설명 문서는 아래 사이트를 참조 하면 됩니다.

https://docs.python.org/ko/3/library/tkinter.html

마우스를 제어하기 위하여 키보드나 마우스를 제어할 수 있는 pyput 과 pyautogui 을 이용합니다. 관련 사이트는 아래를 참조하면 됩니다.

https://pypi.org/project/pynput/

https://pyautogui.readthedocs.io/en/latest/

위 이미지와 같이 tkinter를 사용하여 다이얼로그를 만들도록 하겠습니다. 우선 tkinter를 사용하기 위해서 import를 해줍니다. 그리고 아래와 같이 소스를 코딩하면 위와 같이 나타납니다.

from tkinter import *

root = Tk() # Tk클래스 객체 생성
root.title("마우스 자동 클릭") # 타이틀 이름 설정
root.geometry("550x180") # grid 형식으로 너비x높이 설정(픽셀단위)

root.mainloop() # Tk 클래스 객체의 mainloop 실행하여 다이얼로그 표시함함

빈 다이얼로그 창에 코드를 추가하여 버튼과 입력창을 만들어 보겠습니다. 

from tkinter import *

root = Tk() # Tk클래스 객체 생성
root.title("마우스 자동 클릭") # 타이틀 이름 설정
root.geometry("550x180") # grid 형식으로 너비x높이 설정(픽셀단위)

################
label1 = Label(root, text="X좌표")
label1.grid(row=1, column=1)

entry1 = Entry(root, width=10)
entry1.grid(row=1, column=2)

label2 = Label(root, text="Y좌표")
label2.grid(row=1, column=3)

entry2 = Entry(root, width=10)
entry2.grid(row=1, column=4)

button1 = Button(root, text="마우스위치")
button1.grid(row=1, column=5)

#################
label3 = Label(root, text="반복횟수")
label3.grid(row=2, column=1)

entry3 = Entry(root, width=10)
entry3.grid(row=2, column=2)
entry3.insert("end","120")

label4 = Label(root, text="인터벌(초)")
label4.grid(row=2, column=3)

entry4 = Entry(root, width=10)
entry4.grid(row=2, column=4)
entry4.insert("end","30")

##################
label5 = Label(root, text="* 120 회 * 30초 = 3600초(60분) 동안 동작")
label5.grid(row=3, column=2, columnspan=4)

##################
button2 = Button(root, text="클릭 시작")
button2.grid(row=4, column=3)
##################

root.mainloop() # Tk 클래스 객체의 mainloop 실행하여 다이얼로그 표시함함

위 소스로 실행되면 다이얼로그 창에 원하는 위치에 버튼과 입력창을 만들 수 있습니다.

이제 버튼이 클릭했을 때 동작하는 함수를 만들어 보겠습니다. 각 버튼에 아래와 같이 클릭시 실행하는 함수를 선언 할 수 있습니다.

button1 = Button(root, text="마우스위치", command=lambda: mousePointerPos())
# (중략)
button2 = Button(root, text="클릭 시작", command = lambda:startMacro())

위에서 실행될 함수를 작성하여 줍니다.

def mousePointerPos():
    with mouse.Listener(
        on_click=posClick
    ) as listener: listener.join()
    entry1.insert("end", x1)
    entry2.insert("end", y1)

def posClick(x, y, button, pressed):
    if pressed:
        global x1
        global y1
        x1 = x
        y1 = y

    if not pressed:
        return False

def startMacro():
    click_num = int(entry3.get())
    intervalSec = int(entry4.get())

    ##반복시작
    for a in range(0, click_num):
        time.sleep(intervalSec)
        pyautogui.click(x1, y1)

아래는 전체 코드입니다.

from tkinter import *
from pynput import mouse
import pyautogui
import time

root = Tk() # Tk클래스 객체 생성
root.title("마우스 자동 클릭") # 타이틀 이름 설정
root.geometry("550x180") # grid 형식으로 너비x높이 설정(픽셀단위)

################
label1 = Label(root, text="X좌표")
label1.grid(row=1, column=1)

entry1 = Entry(root, width=10)
entry1.grid(row=1, column=2)

label2 = Label(root, text="Y좌표")
label2.grid(row=1, column=3)

entry2 = Entry(root, width=10)
entry2.grid(row=1, column=4)

button1 = Button(root, text="마우스위치", command=lambda: mousePointerPos())
button1.grid(row=1, column=5)

#################
label3 = Label(root, text="반복횟수")
label3.grid(row=2, column=1)

entry3 = Entry(root, width=10)
entry3.grid(row=2, column=2)
entry3.insert("end","120")

label4 = Label(root, text="인터벌(초)")
label4.grid(row=2, column=3)

entry4 = Entry(root, width=10)
entry4.grid(row=2, column=4)
entry4.insert("end","30")

# checkbutton1 = Checkbutton(root, text="무한")
# checkbutton1.grid(row=2, column=5)
##################
label5 = Label(root, text="* 120 회 * 30초 = 3600초(60분) 동안 동작")
label5.grid(row=3, column=2, columnspan=4)

##################
button2 = Button(root, text="클릭 시작", command = lambda:startMacro())
button2.grid(row=4, column=3)
##################


def mousePointerPos():
    with mouse.Listener(
        on_click=posClick
    ) as listener: listener.join()
    entry1.insert("end", x1)
    entry2.insert("end", y1)

def posClick(x, y, button, pressed):
    if pressed:
        global x1
        global y1
        x1 = x
        y1 = y

    if not pressed:
        return False

def startMacro():
    click_num = int(entry3.get())
    intervalSec = int(entry4.get())

    ##반복시작
    for a in range(0, click_num):
        time.sleep(intervalSec)
        pyautogui.click(x1, y1)

root.mainloop() # Tk 클래스 객체의 mainloop 실행하여 다이얼로그 표시함함

지금 까지 간단하게 다이얼로그에 버튼, 입력창을 만들고 이것을 마우스 위치를 알아내여 마우스 클릭을 자동으록 실행하는 프로그램을 만들어 보았습니다. 

프로그램을 만들다 보면 많은 오류를 만나게 됩니다. 이러한 오류에 대해 예외적으로 오류를 처리할 수 있는 방법을 알아보도록 하겠습니다.

예외처리

오류 예외 처리 기법

아래의 형식으로 예외처리를 어떻게 할 수 있는지 알아보겠습니다.

# 1. try, except만 쓰는 방법
try:
    ...
except:
    ...
# =>  오류 종류에 상관없이 오류가 발생하면 except 블록을 수행


# 2. 발생 오류만 포함한 except문
try:
    ...
except 발생 오류:
    ...
# => 이 경우는 오류가 발생했을 때 except문에 미리 정해 놓은 오류 이름과 일치할 때만 except 블록을 수행

# 3. 발생 오류와 오류 메시지 변수까지 포함한 except문
try:
    ...
except 발생 오류 as 오류 메시지 변수:
    ...
# => 이 경우는 두 번째 경우에서 오류 메시지의 내용까지 알고 싶을 때 사용하는 방법

try ... finally

finally 절은 try 수행 도중 예외 발생 여부와 상관없이 무조건 수행이 됩니다. 이는 파일을 열고 닫는 부분에서 많이 사용을 합니다.

f = open('c:\\dev\\new.txt', 'w')
try:
    # 수행
finally:
    f.close()

여러개의 오류처리하기

try 문 안에서 여러개의 오류를 처리하기 위해서는 다음과 같은 형식을 사용합니다.

try:
    ...
except 발생 오류1:
   ... 
except 발생 오류2:
   ...

만약 발생 오류1, 발생 오류2 를 동일하게 처리하기 위해서는 괄호로 묶어 except (발생 오류1, 발생 오류2) as e 와 같은 형식으로 사용을 합니다.

오류 발생시키기

파이썬에서는 raise 명령어를 사용해 오류를 강제로 발생시킬 수 있습니다. 아래와 같은 형식으로 사용합니다.

raise 발생오류

예외 만들기

예외는 직접 만들어서 사용할 수 있습니다. 바로 상속을 이용을 하는 것입니다. 이때 상속을 받을 부모는 Exception 클래스입니다.

class MyError(Exception):
    pass

직접 만든 예외를 이용한 프로그램 코드 입니다.

class MyError(Exception):
    pass


def say_nick(nick):
    if nick == '바보':
        raise MyError()
    print(nick)


try:
    say_nick("천사")
    say_nick("바보")
except MyError:
    print("허용되지 않는 별명입니다.")
    
    
### 결과
천사
허용되지 않는 별명입니다.

모듈이란 함수나 변수 또는 클래스를 모아 놓은 파일입니다. 모듈은 다른 파이썬 프로그램에서 불러와 사용할 수 있게끔 만든 파이썬 파일이라고 할 수 있습니다. 파이썬은 굉장히 많은 모듈을 사용합니다. 모듈에 대해서 알아보겠습니다.

모듈

모듈 만들기

파이썬으로 아래와같이 파일을 하나 만들어 보겠습니다.

# test.py

def printStr():
    return "test 입니다."

def add(a,b):
    return a+b

그리고 같은 위치에 아래와 같이 test를 import 하여 test에 작성한 함수를 호출하여 보도록 하겠습니다.

# test2.py

import test

print(test.printStr())
print(test.add(1,1))

### 결과
test 입니다.
2

만약에 바로 함수를 사용하고 싶다면 아래와 같이 사용하면 됩니다.

# test2.py

from test import printStr, add

print(printStr())
print(add(1,1))

### 결과
test 입니다.
2

improt 시 printStr, add 대신에 * 를 넣어 모든 함수를 불러서 사용할 수도 있습니다.

if __name__ == "__main__": 의미 

if __name__=="__main__": 를 사용하면 해당 파일을 직접 실행했을 경우에만 하위 코드가 실행이 됩니다. 만약 import를 하여 사용한다면 하위 코드는 실행이 되지 않습니다.

# test.py

def printStr():
    return "test 입니다."

def add(a,b):
    return a+b


if __name__ == "__main__":
    print(printStr())
    print(add(4, 2))
    
### test.py 실행시 결과
test 입니다.
6

파이썬에서도 클래스를 만들어 사용을 할 수 있습니다.  클래스를 어떻게 만들고 어떻게 사용을 하는 지 알아보겠습니다.

클래스

클래스는 무엇인가를 계속해서 만들어 낼 수 있는 설계 도면이고 객체란 클래스로 만들어진 피조물 입니다.

클래스 구조 만들기

클래스를 만들때는 class라는 예약어를 사용하여 만듭니다. 

class test:
    pass

a = test()
print(type(a))

위 코드는 test 라는 클래스 빈 클래스로 만들어 a는 test의 인스턴스 입니다. type(a)로 확인한 결과는 "<class '__main__.test'>" 와 같이 나타날 것 입니다.

클래스 함수 만들기

클래스에서 함수를 만드는 방식은 일반적인 함수를 만드는 방법과 유사하지만 매개변수 자리에 self가 첫번째로 들어가야합니다. 여기서 self는 객체자신이 됩니다. 함수를 호출할때는 "객체.함수(매개변수)" 이렇게 호출하고, 이때 객체가 바로 self가 됩니다. 아래의 예제 코드를 살펴봅시다.

class test:
    def set(self, a, b):
        self.a = a
        self.b = b

c = test()
c.set(1,2)
print(c.a, c.b)

d = test()
d.set(4,5)
print(d.a, d.b)

e = test()
test.set(e, 6,7)
print(e.a, e.b)

c,d 객체에서 set 함수를 호출하는 방식과 e객체에서 set 함수를 호출하는 방식의 차이를 확인하여 주십시오.

생성자

클래스 생성자에 대해서 알아보겠습니다. 파이썬에서 생성자는 __init__ 를 사용하여 함수를 만들면 됩니다.

class test:
    def __init__(self, a, b):
        self.a = a
        self.b = b
    def set(self, a, b):
        self.a = a
        self.b = b

c = test(1,2)
print(c.a, c.b)

set 함수를 호출하지 않고 객체를 만들면서 a, b에 값을 전달하여 객체가 생성이되는 것을 확인 할수 있습니다.

클래스의 상속

상속이라는 것은 "물려받다" 입니다. 이것은 어떤 클래스를 만들 때 다른 클래스의 기능을 물려받을 수 있게 만드는 것입니다.

class test:
    def __init__(self, a, b):
        self.a = a
        self.b = b
    def add(self):
        return self.a + self.b

# test를 상속한다.
class test2(test):
    def mul(self):
        return self.a * self.b

# test2를 이용하여 객체를 만듬
c = test2(1,2)
print(c.add()) # test 의 add를 호출
print(c.mul()) # test2 의 mul를 호출

상속은 왜 필요할까요? 상속은 기존 클래스를 변경하지 않고 기능을 추가하거나 기존 기능을 변경하려고 할 때 사용합니다.

메서드 오버라이딩

자식 클래스에 부모 클래스의 함수와 동일한 이름으로 메서드를 다시작성하는 것을 의미합니다.

class test:
    def __init__(self, a, b):
        self.a = a
        self.b = b
    def add(self):
        return self.a + self.b

# test를 상속한다.
class test2(test):
    def mul(self):
        return self.a * self.b
    def add(self):
        if self.a == 1:
            return 0
        else:
            return self.a + self.b

# test2를 이용하여 객체를 만듬
c = test2(1,2)
print(c.add()) # test2 의 add 호출(오버라이딩)
print(c.mul()) # test2 함수의 mul를 호출

### 결과
0
2

클래스 변수

클래스에서 선언한 변수를 클래스 변수라고 합니다. 클래스 변수는 "클래스이름.클래스변수"로 사용할 수 있습니다.

클래스 변수의 특징은 클래스로 만든 모든 객체에 공유된다는 특징이 있습니다.

class test:
    name = "티파일러" # 클래스변수


c = test()
d = test()
print("c:",c.name, id(c.name))
print("d:",d.name, id(d.name))

# 클래스 변수 변경
test.name = "파이썬"

print("c:",c.name, id(c.name))
print("d:",d.name, id(d.name))

### 결과
c: 티파일러 2417809593808
d: 티파일러 2417809593808
c: 파이썬 2417809593712
d: 파이썬 2417809593712

파이썬에서 파일을 통한 입출력 방법에 대해서 알아보기로 하겠습니다.

파일 생성하기

파일을 생성하기 위해서는 내장함수 open을 사용합니다. 사용 방법은 아래와 같습니다.

파일 객체 = open(파일 이름, 파일 열기 모드)

파일 열기모드는 r, w, a 가 있는데, 각각 읽기모드, 쓰기모드, 추가모드 입니다.

f = open("C:\\dev\\new.txt",'w')
f.close()

파일에 내용 쓰기

파일에 내용을 쓰는 코드를 보도록 하겠습니다.

f = open("C:\\dev\\new1.txt",'w')
for i in range(1,11):
    line = "%d \n" % i
    f.write(line)
f.close()

new1.txt 파일을 열어보면 1부터 10까지 써져있는 것을 확인 할 수 있습니다.

파일을 읽는 여러 가지 방법

파이썬에서는 파일을 읽는 여러가지 방법이 있습니다. 아래 예제코드를 통해 살펴보도록 하겠습니다.

# 방법1
f = open("C:\\dev\\new.txt",'r')
while True:
    line = f.readline()
    if not line:
        break
    print(line, end='')
f.close()


# 방법2
f = open("C:\\dev\\new.txt",'r')
lines = f.readlines()
for line in lines:
    print(line, end='')
f.close()

# 방법3
f = open("C:\\dev\\new.txt",'r')
data = f.read()
print(data)
f.close()

파일에 새로운 내용 추가하기

이번에는 기존의 파일에 새로운 내용을 추가해 보도록 하겠습니다.

# 추가
f = open("C:\\dev\\new.txt",'a')
for i in range(11,21):
    line = "%d \n" % i
    f.write(line)
f.close()


# 읽기
f = open("C:\\dev\\new.txt",'r')
lines = f.readlines()
for line in lines:
    print(line, end='')
f.close()

with 문과 함께 사용하기

위와 같이 사용하는 방식을 간단하게 해주는 코드를 살펴보겠습니다. 아래의 코드는 파일을 쓰기모드로 파일에 내용을 쓰는 코드입니다.

# 쓰기
f = open("C:\\taeyoung\\dev\\new1.txt",'w')
f.write("파이썬 파일 입출력 예시 완료!!")
f.close()


# with 코드 사용
with open("C:\\taeyoung\\dev\\new1.txt",'w') as f:
    f.write("파이썬 파일 입출력 예시 완료!!")

위에 기본적으로 쓰는 코드와 아래 with 코드를 사용해서 쓰는 코드의 내용은 같은 것 입니다.

함수

함수는 입력값을 가지고 어떤 작업을 수행하고 결과물을 내어놓는 역할을 합니다. 함수는 같은 내용의 반복적 작성을 줄일 수 있고, 프로그램의 흐름을 일목요연하게 볼 수 있습니다.

입력값 --> 함수 --> 결과값

함수의 구조

파이썬에서 함수는 아래와 같은 구조를 가지고 있습니다.

def 함수명(매개변수):
    <수행할 문장1>
    <수행할 문장2>
    ...

코드를 작성하여 보도록 하겠습니다.

def add(a, b):  # a, b는 매개변수
    return a+b

print(add(3, 4))  # 3, 4는 인수

함수는 일반적으로 입력값과 결과값을 가지고 있습니다. 하지만 경우에 따라서 입력값이 없는 경우, 결과값이 없는 경우, 입력값도 결과값도 없는 경우도 있습니다.

매개변수 지정하여 호출

함수를 호출할 때 매개변수를 지정할 수도 있습니다.

def add(a, b):  # a, b는 매개변수
    return a+b

def add_1(a=2, b=6):  # a, b는 매개변수를 지정
    return a+b

print(add(3, 4))  # 결과는 7
print(add_1())  # 결과는 8
print(add_1(4,0)) #  결과는 4

입력값이 몇 개가 될지 모르는 경우

입력값이 몇 개가 될지 모르는 경우에는 매개변수앞에 *를 붙여줍니다. 구조는 아래와 같습니다.

def 함수이름(*매개변수): 
    <수행할 문장>
    ...

예제를 살펴보겠습니다.

def add(*args):
    result = 0
    for i in args:
        result += i
    return result

print(add(3, 4)) #결과 7
print(add(1,2,3,4)) #결과 10
print(add(1,2,3,4,5,6,7,8,9,10)) #결과 55

lambda

lambda는 함수를 생상할 때 사용하는 예약어로 def와 동일한 역할을 합니다. 보통은 함수를 간결하게 한줄로 표현할때 사용합니다. lambda는 return 명령어가 없어도 결과값을 돌려줍니다.

사용법은 아래와 같습니다.

lambda 매개변수1, 매개변수2, ...: 매개변수를 이용한 표현식

add = lambda a,b:a+b
print(add(3,4)) # 결과 7

이번 글에서는 제어문 if, while, for 등의 제어문에 대해서 알아보려 합니다.

if문

if 문은 조건을 판단하고 그 상황에 맞게 처리를 하는 경우 사용을 합니다. 기본 구조는 아래와 같습니다.

주의 해야할 점은 수행할 문장은 if 문에서 들여쓰기를 해야한다는 것 입니다. 이것을 지키지 않으면 에러가 발생합니다. 보통 스페이스 4개로 들여쓰기를 하거나 tab 키를 이용합니다. 그리고 조건문이 끝나고 콜론(:)을 잊지 말아야 합니다.

if <조건문>:
    <수행할 문장1> 
    <수행할 문장2>
    ...
elif <조건문>:
    <수행할 문장1>
    <수행할 문장2>
    ...
elif <조건문>:
    <수행할 문장1>
    <수행할 문장2>
    ...
...
else:
   <수행할 문장1>
   <수행할 문장2>
   ... 

if문은 조건부 표현식으로 표현을 할 수 있으며 아래와 같습니다.

if a= 10 :
    s = "OK"
else:
    s = "NO"

위 조건문을 조건부 표현식으로 표현해 보겠습니다.

s = "OK" if a=10 else "NO"
=====================================
조건문이 참인 경우  if  조건문  else 조건문이 거짓인 경우

while 문

while 문은 반복해서 문장을 수행해야 하는 경우에 사용을 합니다. 기본 구조는 다음과 같습니다.

while <조건문>:
    <수행할 문장1>
    <수행할 문장2>
    <수행할 문장3>
    ...

while 문과 위에서 배운 if문을 사용하여 특정조건이 되면 while 문을 빠져나오게 할 수도 있으며(break), 수행문장 아래부분을 통과하고 처음으로 돌아가게 할 수(continue)도 있습니다.

for 문

for 문도 while 문과 같은 반복문입니다. 기본 구조는 다음과 같습니다.

for 변수 in 리스트(또는 튜플, 문자열):
    수행할 문장1
    수행할 문장2
    ...

for 문은 리스트나 튜플, 문자열의 길이만큼 반복할때 많이 사용합니다.  for 문은 range함수와 자주 사용하는데 아래의 예를 통해서 보도록 하겠습니다.

[코드]

a = 0
print(a)
for i in range(1,5):
    print("    i:", i)
    a = a + i
print(a)

[출력]

0
    i: 1
    i: 2
    i: 3
    i: 4
10

range(시작숫자:끝숫자) 를 사용하면 시작숫자부터 끝숫자-1까지의 숫자입니다. (끝숫자는 포함되지 않음)

리스트 내포 사용하기

리스트 안에 for 문을 포함하는 리스트 내포를 사용하면 편리하고 직관적인 프로그램을 만들 수 있습니다.

a = [1,2,3,4]
result = []
for num in a:
    result.append(num*3)
print(result)

# 위 for문을 리스트 내포를 사용해서 표현하기
# for 1개인 경우
# [표현식 for 항목 in 반복가능객체 if 조건문]
a1 = [1,2,3,4]
result1 = [num*3 for num in a1]
print(result1)

# for 2개 이상일때도 다음과 같이 표현이 가능하다
#[표현식 for 항목1 in 반복가능객체1 if 조건문1
#        for 항목2 in 반복가능객체2 if 조건문2
#        ...
#        for 항목n in 반복가능객체n if 조건문n]

프로그램에는 자료형이라는 것이 있습니다. 숫자, 문자열 등 자료의 형태로 사용하는 것을 이야기합니다. 이것은 프로그램의 기본이자 핵심입니다. 자료형을 알지 못하면 프로그램을 짤 수 없으며, 각 언어마다 비슷하지만 조금씩 다른 방식으로 연산을 합니다. 이러한 자료형에 대해 알아보겠습니다.

불(bool) 자료형

불 자료형은 True 와 False 를 나타내는 자료형으로 2가지 값만 가지고 있습니다. 첫문자는 대문자로 사용을 합니다.

• True - 참
• False - 거짓

True 와 False는 조건문 혹은 반복문에서 많이 사용을 하기 때문에 어떠한 값이 True이고 False인지 잘 알아 둘어야 합니다. 예를 들어 "", [], (), {}, 0, None 등은 False를 반환합니다.

불 자료형은 조건문과 반복문을 통해서 연습을 하도록 하겠습니다.

여기까지 파이썬에서 사용하는 가장 기본이되는 자료형에 대해 알아보았습니다. 자료형은 프로그램의 근간이 되기 때문에 확실히 알아 두어야 합니다. 다음으로 는 제어문(반복문, 조건문)에 대해서 알아보겠습니다.

프로그램에는 자료형이라는 것이 있습니다. 숫자, 문자열 등 자료의 형태로 사용하는 것을 이야기합니다. 이것은 프로그램의 기본이자 핵심입니다. 자료형을 알지 못하면 프로그램을 짤 수 없으며, 각 언어마다 비슷하지만 조금씩 다른 방식으로 연산을 합니다. 이러한 자료형에 대해 알아보겠습니다.

집합 자료형

집합 자료형 만들기

집합(set)은 파이썬 2.3부터 지원하기 시작한 자료형입니다. 집합에 관련되는 것을 처리하기 위해 만든 자료형입니다.

집합 자료형은 다음과 같이 만들 수 있습니다.

s1 = set([1,2,3])
s2 = set("hi")
s3 = set()

집합 자료형 특징

집합 자료형에는 2가지 특징이 있습니다.

• 중복을 허용하지 않는다.
• 순서가 없다.

set 자료형은 순서가 없어 인덱싱으로 값을 얻을 수 없습니다. 이것은 앞에서 살펴본 딕셔너리 자료형과 같습니다.

교집합, 합집합, 차집합 구하기

set 자료형을 유용하게 사용하는 경우는 교집합, 합집합, 차집합을 구할 때 입니다. 아래 코드를 통해서 확이내보도록 하겠습니다.

[코드]

s1 = set([1,2,3,4])
s2 = set([3,4,5,6,7,8,9])

#교집합
print("교집합1 : ", s1 & s2)
print("교집합2 : ", s1.intersection(s2))

#합집합
print("합집합1 : ", s1 | s2)
print("합집합2 : ", s1.union(s2))

# 차집합
print("차집합 s1-s2 : ", s1 - s2)
print("차집합 s2-s1 : ", s2 - s1)
print("차집합 s1-s2 : ", s1.difference(s2))
print("차집합 s2-s1 : ", s2.difference(s1))

[출력]

교집합1 :  {3, 4}
교집합2 :  {3, 4}
합집합1 :  {1, 2, 3, 4, 5, 6, 7, 8, 9}
합집합2 :  {1, 2, 3, 4, 5, 6, 7, 8, 9}
차집합 s1-s2 :  {1, 2}
차집합 s2-s1 :  {5, 6, 7, 8, 9}
차집합 s1-s2 :  {1, 2}
차집합 s2-s1 :  {5, 6, 7, 8, 9}

집합 자료형 함수

집합 자료형에 관련된 함수를 아래 코드를 통해서 알아보겠습니다.

[코드]

s1 = set([1,2,3])
s2 = set([4,5,6])

# 값추가하기
print("추가전:",s1)
s1.add(4)
print("추가후:",s1)

print("추가전:",s1)
s1.update(s2)
print("추가후:",s1)

# 값 제거하기
print("제거전:",s1)
s1.remove(2)
print("제거후:",s1)

[출력]

추가전: {1, 2, 3}
추가후: {1, 2, 3, 4}
추가전: {1, 2, 3, 4}
추가후: {1, 2, 3, 4, 5, 6}
제거전: {1, 2, 3, 4, 5, 6}
제거후: {1, 3, 4, 5, 6}

프로그램에는 자료형이라는 것이 있습니다. 숫자, 문자열 등 자료의 형태로 사용하는 것을 이야기합니다. 이것은 프로그램의 기본이자 핵심입니다. 자료형을 알지 못하면 프로그램을 짤 수 없으며, 각 언어마다 비슷하지만 조금씩 다른 방식으로 연산을 합니다. 이러한 자료형에 대해 알아보겠습니다.

딕셔너리 자료형

파이썬의 딕셔너리 형은 Java의 Hash와 같습니다. key에 저장된 value를 한쌍으로 가지는 형태를 이야기합니다. 예를 들어, 저에 대해서 생각을 할때, "이름(key)"= "티파일러(value)", "나이(key)"="40(value)",... 와 같이 나타낼수 있도록 구현된 것이 딕셔너리 입니다. 구하고자 하는 Key를 입력하면 value를 알수 있습니다.

딕셔너리의 생성

{key1:value1, key2:value2, key3:value3 ....}

Key와 Value 의 쌍 여러개가 {}로 둘러싸여 있습니다. 그리고 쉼표(,)로 구분이 되어 있습니다. value에는 리스트도 넣을 수 있습니다.

딕셔너리 쌍 추가, 삭제

딕셔너리를 이용하여 추가, 삭제하는 방법은 다음과 같습니다. 문자형, 리스트, 튜플과 다르게 [] 안에 있는 값은 index가 아닌 key 입니다.

[코드]

a = {1:'a', 2:'b',3:'c'}
print("a:",a)
a[4] = 'd'
print("a[4] = 'd' 실행후:",a)
a['x'] = 123
print("a['x'] = 123 실행후:",a)

del a[3]
print("del a[3] 실행후:",a)

[출력]

a: {1: 'a', 2: 'b', 3: 'c'}
a[4] = 'd' 실행후: {1: 'a', 2: 'b', 3: 'c', 4: 'd'}
a['x'] = 123 실행후: {1: 'a', 2: 'b', 3: 'c', 4: 'd', 'x': 123}
del a[3] 실행후: {1: 'a', 2: 'b', 4: 'd', 'x': 123}

딕셔너리 주의사항

딘겨너리에서 Key는 고유한 값으로 중복되는 Key값을 설정해 놓으면 나중에 입력한 값만 가지게 됩니다. 그리고 Key에 리스트는 사용할 수 없습니다. 

딕셔너리 함수

딕셔너리 관련 함수를 아래와 같이 살펴봅시다.

[코드]

a = {'name': '티파일러', 'phone': '010XXXXYYYY', 'birth': '0709'}
print("a의 key:",a.keys()) #dict_keys 객체로 반환됨

print("반복문 for를 이용한 key 값 출력")
for k in a.keys():
    print(k)

print("리스트로 key반환하기:",list(a.keys()))

print()
print("a의 value:",a.values()) #dict_values 객체로 반환됨

print()
print("a의 item:",a.items()) #dict_items 객체로 반환됨

print()
print("get 함수를 이용한 value얻기:", a.get("name"))
print("get 함수를 이용한 value얻기:", a.get("abc")) # key가 없으면 None
print("get 함수를 이용한 value얻기(없으면 디폴값으로 출력):", a.get("abc","12345"))

print()
print("'name'키가 있는지 조회:", 'name' in a)
print("'x'키가 있는지 조회:", 'x' in a)

print()
a.clear()
print("a 내용을 모두 지운 후:", a.items())

[출력]

a의 key: dict_keys(['name', 'phone', 'birth'])
반복문 for를 이용한 key 값 출력
name
phone
birth
리스트로 key반환하기: ['name', 'phone', 'birth']

a의 value: dict_values(['티파일러', '010XXXXYYYY', '0709'])

a의 item: dict_items([('name', '티파일러'), ('phone', '010XXXXYYYY'), ('birth', '0709')])

get 함수를 이용한 value얻기: 티파일러
get 함수를 이용한 value얻기: None
get 함수를 이용한 value얻기(없으면 디폴값으로 출력): 12345

'name'키가 있는지 조회: True
'x'키가 있는지 조회: False

a 내용을 모두 지운 후: dict_items([])