05-1 클래스

클래스는 도대체 왜 필요한가?

In [1]:
# 계산기의 "더하기" 기능을 구현

result = 0

def adder(num):
    global result # 결과값을 유지하기 위해 전역 변수 사용
    result += num

    return result

print(adder(3))
print(adder(5))
3
8
In [2]:
# 한 프로그램에서 2개의 계산기가 필요한 경우 함수를 따로 만들어야 한다.

result1 = 0
result2 = 0

def adder1(num):
    global result1
    result1 += num
    
    return result1

def adder2(num):
    global result2
    result2 += num
    
    return result2

print(adder1(3))
print(adder1(4))

print(adder2(3))
print(adder2(7))
3
7
3
10
In [3]:
# 같은 함수를 반복해서 만드는 대신 클래스를 이용해서 구현

class Calculator:
    def __init__(self):
        self.result = 0
        
    def adder(self, num):
        self.result += num
        
        return self.result
    
cal1 = Calculator()
cal2 = Calculator()

print(cal1.adder(3))
print(cal1.adder(4))

print(cal2.adder(3))
print(cal2.adder(7))
        
3
7
3
10
  • 빼기 기능을 더한다고 해도 Calculator 클래스에 다음과 같은 함수를 추가해 주면 된다.
def sub(self, num):
    self.result -= num
    return self.result

클래스와 객체

과자틀과 과자

  • 과자틀: 클래스(class)
  • 과자틀로 만든 과자들: 객체(object)
In [4]:
# 파이썬 클래스의 가장 간단한 예

class Programmer:
    pass

# Programmer 클래스의 객체를 만드는 방법

kim = Programmer()
park = Programmer()

[객체와 인스턴스의 차이]

클래스에 의해서 만들어진 객체를 인스턴스라고도 한다. 객체와 인스턴스의 차이는 무엇일까? kim = Programmer() 에서 kim 은 객체이다. 그리고 kim 이라는 객체는 Programmer 의 인스턴스이다. 즉, 인스턴스라는 말은 특정 객체(kim)가 어떤 클래스(Programmer)의 객체인지를 관계 위주로 설명할 때 사용한다. 즉, "kim은 인스턴스" 보다는 "kim은 객체다"라는 표현이 어울리며, "kim은 Programmer의 객체" 보다는 "kim은 Programmer의 인스턴스"라는 표현이 잘 어울린다.

클래스 기초 쌓기

클래스 변수

In [1]:
class Service:
    secret = "영구는 외계인이다."
    
pey = Service()
In [2]:
pey.secret
Out[2]:
'영구는 외계인이다.'
In [3]:
juhoi = Service()
In [4]:
juhoi.secret
Out[4]:
'영구는 외계인이다.'
In [5]:
juhoi.secret = "나는 외계인이다."
In [6]:
pey.secret
Out[6]:
'영구는 외계인이다.'
In [7]:
# 클래스 변수 직접 접근하기

Service.secret
Out[7]:
'영구는 외계인이다.'
In [8]:
Service.secret = "영구는 도깨비이다."
In [9]:
Service.secret
Out[9]:
'영구는 도깨비이다.'
In [10]:
pey.secret
Out[10]:
'영구는 도깨비이다.'
In [11]:
juhoi.secret
Out[11]:
'나는 외계인이다.'
In [12]:
duckbabys = Service()

duckbabys.secret
Out[12]:
'영구는 도깨비이다.'
In [13]:
Service.secret = "도깨비 OST"

print(pey.secret)
print(juhoi.secret)
print(duckbabys.secret)
도깨비 OST
나는 외계인이다.
도깨비 OST

클래스 내부의 함수(메서드)

In [1]:
class Service:
    secret = "영구는 외계인이다."
    
    def sum(self, a, b):
        result = a + b
        
        print("%s + %s = %s 입니다" % (a, b, result))
        

pey = Service()

pey.sum(1, 1)
1 + 1 = 2 입니다

self 살펴보기

메서드 self 파라미터

  • 파이썬만의 특징: 객체를 통해 클래스의 함수를 호출할 때 호출한 객체 자신이 호출한 클래스 함수의 첫번째 입력 인수로 전될된다.
  • 다음과 같이 클래스를 통해 함수를 호출할 수도 있다. 이때는 객체가 자동으로 전달되지 않기 때문에 명시적으로 넘겨줘야 한다.
pey = Service()
Service.sum(pey, 1, 1)

객체 변수

In [2]:
class Service:
    secret = "영구는 외계인이다"
    
    def setname(self, name):
        self.name = name
        
    def sum(self, a, b):
        result = a + b
        
        print("%s%s + %s = %s 입니다." % (self.name, a, b, result))
        

pey = Service()
pey.setname("홍길동")

pey.sum(1, 1)
홍길동 님  1 + 1 = 2 입니다.

__init__ 이란 무엇인가?

In [3]:
babo = Service()
babo.sum(1,1)
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-3-31e65386a5d0> in <module>()
      1 babo = Service()
----> 2 babo.sum(1,1)

<ipython-input-2-3c68828fdad9> in sum(self, a, b)
      8         result = a + b
      9 
---> 10         print("%s 님  %s + %s = %s 입니다." % (self.name, a, b, result))
     11 
     12 

AttributeError: 'Service' object has no attribute 'name'
In [4]:
class Service:
    secret = "영구는 외계인이다"
    
    def __init__(self, name): # 객체를 만들 때 항상 실행된다.
        self.name = name
        
    def sum(self, a, b):
        result = a + b
        
        print("%s%s + %s = %s 입니다." % (self.name, a, b, result))

        
pey = Service("홍길동")

pey.sum(1, 1)
홍길동 님  1 + 1 = 2 입니다.

클래스 자세히 알기

클래스의 구조

class 클래스이름[(상속 클래스명)]:
    <클래스 변수1>
    <클래스 변수2>
    ...

    def 메서드1(self[, 인수1, 인수2,,,]):
        <수행할 문장1>
        <수행할 문장2>
        ...

    def 메서드2(self[, 인수1, 인수2,,,]):
        <수행할 문장1>
        <수행할 문장2>
        ...

    ...

사칙연산 클래스 만들기

클래스를 어떻게 만들지 먼저 구상하기

  • 클래스명: FourCal
  • 피연산자를 설정해주는 메서드: setdata
  • 사칙연산을 해주는 메서드: sum, mul, sub, div
In [5]:
class FourCal:
    def setdata(self, first, second):
        self.first = first
        self.second = second
    def sum(self):
        result = self.first + self.second
        return result
    def sub(self):
        result = self.first - self.second
        return result
    def mul(self):
        result = self.first * self.second
        return result
    def div(self):
        result = self.first / self.second
        return result
    
    
a = FourCal()
b = FourCal()

a.setdata(4, 2)
b.setdata(3, 7)
In [6]:
a.sum()
Out[6]:
6
In [7]:
a.sub()
Out[7]:
2
In [8]:
a.mul()
Out[8]:
8
In [9]:
a.div()
Out[9]:
2.0
In [10]:
b.sum()
Out[10]:
10
In [11]:
b.sub()
Out[11]:
-4
In [12]:
b.mul()
Out[12]:
21
In [13]:
b.div()
Out[13]:
0.42857142857142855

"박씨네 집" 클래스 만들기

클래스 구상하기

  • 클래스 이름은 HousePark 으로 하자. pey = HousePark()
  • pey.lastname 을 출력하면 "박"이라는 성을 출력하자.
  • 이름을 설정하면 pey.fullname 이 성을 포함한 값을 가지도록 하자.
  • 여행가고 싶은 장소를 입력하면 출력해 주는 travel 메서드로 만들어 보자. pey.travel("부산")
In [14]:
class HousePark:
    lastname = "박"
    
    def __init__(self, name):
        self.fullname = self.lastname + name
        
    def travel(self, where):
        print("%s, %s 여행을 가다." % (self.fullname, where))
In [15]:
pey = HousePark()
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-15-22c18c13dd20> in <module>()
----> 1 pey = HousePark()

TypeError: __init__() missing 1 required positional argument: 'name'
In [16]:
pey = HousePark("응용")
In [17]:
pey.travel("태국")
박응용, 태국 여행을 가다.

클래스의 상속

class 상속받을 클래스명(상속할 클래스명)

In [18]:
class HouseKim(HousePark):
    lastname = "김"
In [19]:
juliet = HouseKim("줄리엣")
juliet.travel("독도")
김줄리엣, 독도 여행을 가다.

메서드 오버라이딩

In [20]:
class HouseKim(HousePark):
    lastname = "김"
    
    def travel(self, where):
        print("%s%s 로 여행합니다." % (self.fullname, where))
In [21]:
juliet = HouseKim("줄리엣")
juliet.travel("독도")
김줄리엣 은 독도 로 여행합니다.

연산자 오버로딩

  • 연산자(+, -, *, /)를 객체끼리 사용할 수 있게 하는 기법
In [22]:
class HousePark:
    lastname = "박"
    def __init__(self, name):
        self.fullname = self.lastname + name
    def travel(self, where):
        print("%s, %s여행을 가다." % (self.fullname, where))
    def __add__(self, other):
        print("%s, %s 결혼했네" % (self.fullname, other.fullname))


class HouseKim(HousePark):
    lastname = "김"
    def travel(self, where):
        print("%s%s로 여행합니다." % (self.fullname, where))

pey = HousePark("응용")
juliet = HouseKim("줄리엣")
pey + juliet
박응용, 김줄리엣 결혼했네

05-2 모듈

  • 모듈이란 함수나 변수 또는 클래스들을 모아 놓은 파일이다.
  • 다른 파이썬 프로그램에서 불러와 사용할 수 있게끔 만들어진 파일이라고도 할 수 있다.

모듈 만들고 불러 보기

In [23]:
%%writefile mod1.py
def sum(a, b):
    return a + b
Writing mod1.py
In [24]:
!ls
01장 파이썬이란 무엇인가?.ipynb
02장 파이썬 프로그래밍의 기초, 자료형.ipynb
03장 프로그램의 구조를 쌓는다! 제어문.ipynb
04-sys1.py
04-sys2.py
04-새파일.txt
04장 프로그램의 입력과 출력은 어떻게 해야 할까?.ipynb
05장 파이썬 날개달기.ipynb
mod1.py
In [25]:
import mod1

print(mod1.sum(3, 4))
7
  • import 는 이미 만들어진 파이썬 모듈을 사용할 수 있게 해주는 명령어
  • import 는 현재 디렉터리에 있는 파일이나 파이썬 라이브러리가 저장된 디렉터리에 있는 모듈만 불러올 수 있다.
In [1]:
%%writefile mod1.py
def sum(a, b):
    return a + b

def safe_sum(a, b): 
    if type(a) != type(b): 
        print("더할수 있는 것이 아닙니다.")
        return 
    else: 
        result = sum(a, b) 
    return result
Overwriting mod1.py
In [2]:
!ls
01장 파이썬이란 무엇인가?.ipynb
02장 파이썬 프로그래밍의 기초, 자료형.ipynb
03장 프로그램의 구조를 쌓는다! 제어문.ipynb
04-sys1.py
04-sys2.py
04-새파일.txt
04장 프로그램의 입력과 출력은 어떻게 해야 할까?.ipynb
05장 파이썬 날개달기.ipynb
__pycache__
mod1.py
In [3]:
import mod1

print(mod1.safe_sum(3, 4))
print(mod1.safe_sum(1, 'a'))
7
더할수 있는 것이 아닙니다.
None

[모듈 함수를 사용하는 또 다른 방법]

from 모듈이름 import 모듈함수

In [4]:
from mod1 import sum

sum(3, 4)
Out[4]:
7
In [5]:
from mod1 import sum, safe_sum
In [6]:
from mod1 import *

if __name__ == "__main__": 의 의미

In [7]:
%%writefile mod1.py
def sum(a, b): 
    return a+b

def safe_sum(a, b): 
    if type(a) != type(b): 
        print("더할수 있는 것이 아닙니다.")
        return 
    else: 
        result = sum(a, b) 
    return result 

print(safe_sum('a', 1))
print(safe_sum(1, 4))
print(sum(10, 10.4))
Overwriting mod1.py
In [8]:
%run mod1.py
더할수 있는 것이 아닙니다.
None
5
20.4
In [9]:
import mod1
if __name__ == "__main__
    print(safe_sum('a', 1))
    print(safe_sum(1, 4))
    print(sum(10, 10.4))

알아두기

  • 파이썬의 __name__ 변수는 파이썬이 내부적으로 사용하는 특별한 변수명이다.
  • 직접 mod1.py 파일을 실행시킬 경우 mod1.py 의 __name__ 변수에는 __main__ 이라는 값이 저장된다.
  • 하지만, 모듈 mod1 을 import 할 셩우에는 mod1.py 의 __name__ 변수에는 "mod1" 이라는 값이 저장된다.

[모듈을 불러오는 또 다른 방법]

  • sys.path.append(모듈을 저장한 디렉터리) 사용하기
    • sys.path 는 파이썬 라이브러리들이 설치되어 있는 디렉터리들을 보여준다.
In [10]:
import sys
sys.path
Out[10]:
['',
 '/usr/lib/python3.4',
 '/usr/lib/python3.4/plat-x86_64-linux-gnu',
 '/usr/lib/python3.4/lib-dynload',
 '/usr/local/lib/python3.4/dist-packages',
 '/usr/lib/python3/dist-packages',
 '/usr/local/lib/python3.4/dist-packages/IPython/extensions',
 '/root/.ipython']
  • PYTHONPATH 환경 변수 사용하기

05-3 패키지

  • 패키지(Packages)는 도트(.)를 이용하여 파이썬 모듈을 계층적으로 관리할 수 있게 한다.
  • 모듈명이 A.B 인 경우 A 는 패키지명이고 B 는 A 패키지의 B 모듈이 된다.

가상의 game 패키지 예

game/
    __init__.py
    sound/
        __init__.py
        echo.py
        wav.py
    graphic/
        __init__.py
        screen.py
        render.py
    play/
        __init__.py
        run.py
        test.py
  • game 디렉터리가 이 패키지의 루트 디렉터리이고 sound, graphic, play 는 서브 디렉터리이다.
  • .py 확장자를 가지는 파일은 파이썬 모듈이다.

패키지 만들기

기본 구성요소 준비하기

  • game 및 기타 서브 디렉터리를 생성하고 .py 파일을 만들어 보자
In [1]:
!mkdir game game/sound game/graphic
In [2]:
!ls
01장 파이썬이란 무엇인가?.ipynb
02장 파이썬 프로그래밍의 기초, 자료형.ipynb
03장 프로그램의 구조를 쌓는다! 제어문.ipynb
04-sys1.py
04-sys2.py
04-새파일.txt
04장 프로그램의 입력과 출력은 어떻게 해야 할까?.ipynb
05장 파이썬 날개달기.ipynb
__pycache__
game
mod1.py
In [3]:
!touch game/__init__.py game/sound/__init__.py gamd/graphic/__init__.py
touch: `gamd/graphic/__init__.py'를 touch할 수 없음: 그런 파일이나 디렉터리가 없습니다
In [4]:
!touch game/graphic/__init__.py
In [5]:
%%writefile game/sound/echo.py
def echo_test():
    print("echo")
Writing game/sound/echo.py
In [6]:
%%writefile game/graphic/render.py
def render_test():
    print("render")
Writing game/graphic/render.py

패키지 안의 함수 실행하기

In [7]:
import game.sound.echo
game.sound.echo.echo_test()
echo
In [8]:
from game.sound import echo
echo.echo_test()
echo
In [9]:
from game.sound.echo import echo_test
echo_test()
echo

__init__.py 의 용도

  • __init__.py 파일은 해당 디렉터리가 패키지의 일부임을 알려주는 역할을 한다.(python3.3 버전부터는 없어도 인식된다)

all 의 용도

In [10]:
from game.sound import *
echo.echo_test()
echo
  • 특정 디렉터리의 모듈을 * 를 이용하여 import 할 때에는 다음과 같이 해당 디렉터리의 __init__.py 파일에 __all__ 이라는 변수를 설정하고 import 할수 있는 모듈을 정의해 주어야 한다.
In [11]:
!echo "__all__ = ['echo']" >> game/sound/echo.py
In [12]:
!more game/sound/echo.py
def echo_test():
    print("echo")__all__ = ['echo']
In [13]:
!more game/sound/echo.py
def echo_test():
    print("echo")
In [14]:
!more game/sound/__init__.py
__all__ = ['echo']

05-4 예외 처리

  • 프로그램을 만들다 보면 수많은 오류를 만나게 된다.
  • 때때로 이러한 오류를 무시하거나 별도로 처리하고 싶을때가 있다.
  • 파이썬은 try, except 를 이용해서 이러한 오류를 예외 처리한다.

오류는 어떤 때 발생하는가?

In [1]:
# 디렉터리 안에 없는 파일을 열려고 시도했을때 - FileNotFoundError

f = open("없는파일", 'r')
---------------------------------------------------------------------------
FileNotFoundError                         Traceback (most recent call last)
<ipython-input-1-017cc5335a6d> in <module>()
      1 # 디렉터리 안에 없는 파일을 열려고 시도했을때 - FileNotFoundError
      2 
----> 3 f = open("없는파일", 'r')

FileNotFoundError: [Errno 2] No such file or directory: '없는파일'
In [2]:
# 0으로 다른 숫자를 나누는 경우 - ZeroDivisionError

4 / 0
---------------------------------------------------------------------------
ZeroDivisionError                         Traceback (most recent call last)
<ipython-input-2-6a687db7d11d> in <module>()
      1 # 0으로 다른 숫자를 나누는 경우 - ZeroDivisionError
      2 
----> 3 4 / 0

ZeroDivisionError: division by zero
In [3]:
# 리스트에서 얻을 없는 index 값 - IndexError

a = [1, 2, 3]

a[4]
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-3-4862fae32f59> in <module>()
      3 a = [1, 2, 3]
      4 
----> 5 a[4]

IndexError: list index out of range

오류 예외 처리 기법

try, except 문

  • 기본구조
try:
    ...
except [발생 오류[as 오류 메시지 변수]]:
    ...
  • try 블록 수행 중 오류가 발생하면 except 블록이 수행된다.
  • except 구문은 다음의 3가지 방법으로 사용할 수 있다.
  1. try, except만 쓰는 방법: 오류 발생 시 종류에 상관없이 except 블록을 수행

    try:
     ...
    except:
     ...
  2. 발생 오류만 포함한 except문: except문에 미리 정해 놓은 오류만 except 블록을 수행

    try:
     ...
    except 발생 오류:
     ...
  3. 발생 오류와 오류 메시지 변수까지 포함한 except문

    try
     ...
    except 발생 오류 as 오류 메시지 변수:
     ...
In [1]:
try:
    4 / 0
except ZeroDivisionError as e:
    print(e)
division by zero

try .. else

  • else 절은 예외가 발생하지 않은 경우에 실행
  • 반드시 except 절 바로 다음에 위치
In [1]:
try:
    f = open("foo.txt", 'r')
except FileNotFoundError as e:
    print(str(e))
else:
    data = f.read()
    f.close()
[Errno 2] No such file or directory: 'foo.txt'

try .. finally

  • finally 절은 try 문 수행 도중 예외 발생 여부에 상관없이 항상 실행
  • 사용한 리소스를 close 해야 할 경우에 주로 사용
In [3]:
f = open("foo.txt", 'w')

try:
    # 무언가를 수행한다.
    pass
finally:
    f.close()

여러개의 오류 처리하기

  • try 문 내에서 여러개의 오류를 처리하기 위해서는 다음과 같은 구문을 이용한다.
try:
    ...
except 발생 오류1:
    ...
except 발행 오류2:
    ...
In [4]:
try:
    a = [1, 2]
    print(a[3])
    4/0
except ZeroDivisionError:
    print("0으로 나눌 수 없습니다.")
except IndexError:
    print("인덱싱 할 수 없습니다.")
인덱싱 할 수 없습니다.
In [5]:
# 다음과 같이 2개 이상의 오류를 동시에 처리하기 위해서는 함께 묶어주어 처리하면 된다.

try:
    a = [1, 2]
    print(a[3])
    4/0
except (ZeroDivisionError, IndexError) as e:
    print(e)
list index out of range

오류 회피하기

  • 특정 오류가 발생할 경우 그냥 통과시켜야 할 때 사용
In [1]:
try:
    f = open("없는 파일", 'r')
except FileNotFoundError:
    pass

오류 일부러 발생시키기

  • raise 를 사용하여 오류를 강제로 발생시킬 수 있다.
  • 예를 들어 Bird 라는 클래스를 상속받는 자식 클래스는 반드시 fly 하는 함수를 구현하도록 만들고 싶은 경우
class Bird:
    def fly(self):
        raise NotImplementedError

NotImplementedError 는 파이썬 내장 오류로, 꼭 작성해야 하는 부분이 구현되지 않았을 경우 일부러 오류를 발생시키고자 사용한다.

class Eagle(Bird):
    pass

eagle = Eagle()
eagle.fly()

오류 만들기

  • 특수한 경우에만 예외 처리를 하기 위해서 종종 오류를 만들어서 사용할 수도 있다.
  • 파이썬 내장 클래스인 Exception 블래스를 상속하여 만든다.
In [2]:
class MyError(Exception):
    pass
In [3]:
def say_nick(nick):
    if nick == '바보':
        raise MyError()
    print(nick)
In [4]:
say_nick('천사')
say_nick('바보')
천사
---------------------------------------------------------------------------
MyError                                   Traceback (most recent call last)
<ipython-input-4-47d90292dcbe> in <module>()
      1 say_nick('천사')
----> 2 say_nick('바보')

<ipython-input-3-1b9fee73a580> in say_nick(nick)
      1 def say_nick(nick):
      2     if nick == '바보':
----> 3         raise MyError()
      4     print(nick)

MyError: 
In [5]:
try:
    say_nick('천사')
    say_nick('바보')
except MyError:
    print("허용되지 않는 별명입니다.")
천사
허용되지 않는 별명입니다.
In [6]:
try:
    say_nick('천사')
    say_nick('바보')
except MyError as e:
    print(e)
천사

  • 오류 클래스에 __str__ 메서드를 구현해야 한다.
In [9]:
class MyError(Exception):
    def __init__(self, msg):
        self.msg = msg

    def __str__(self):
        return self.msg


def say_nick(nick):
    if nick == '바보':
        raise MyError("허용되지 않는 별명입니다.")
    print(nick)

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

05-5 내장 함수

In [10]:
# abs: 어떤 숫자를 입력 받았을 때, 그 숫자의 절대값을 돌려주는 함수
abs(3)
Out[10]:
3
In [11]:
abs(-3)
Out[11]:
3
In [13]:
abs(-1.2)
Out[13]:
1.2
In [14]:
# all: 반복 가능한(iterable), 자료형(리스트, 튜플, 문자열, 딕셔너리, 집합 등) x가 모두 참이면 True, 아니면 False 를 리턴
all([1, 2, 3])
Out[14]:
True
In [15]:
all([1, 2, 3, 0])
Out[15]:
False
In [16]:
# any: x 중 하나라도 참이면 True, x 가 모두 거짓일 경우에민 False 를 리턴, all(x) 의 반대 경우
any([1, 2, 3, 0])
Out[16]:
True
In [17]:
any([0, ''])
Out[17]:
False
In [1]:
# chr: 아스키(ascii) 코드값을 입력받아 그 코드에 해당하는 문자를 출력
chr(97)
Out[1]:
'a'
In [2]:
chr(48)
Out[2]:
'0'
In [3]:
# dir: 객체가 자체적으로 가지고 있는 변수나 함수(메서드)를 출력
dir([1, 2, 3])
Out[3]:
['__add__',
 '__class__',
 '__contains__',
 '__delattr__',
 '__delitem__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__getitem__',
 '__gt__',
 '__hash__',
 '__iadd__',
 '__imul__',
 '__init__',
 '__iter__',
 '__le__',
 '__len__',
 '__lt__',
 '__mul__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__reversed__',
 '__rmul__',
 '__setattr__',
 '__setitem__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 'append',
 'clear',
 'copy',
 'count',
 'extend',
 'index',
 'insert',
 'pop',
 'remove',
 'reverse',
 'sort']
In [4]:
dir({'1': 'a'})
Out[4]:
['__class__',
 '__contains__',
 '__delattr__',
 '__delitem__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__getitem__',
 '__gt__',
 '__hash__',
 '__init__',
 '__iter__',
 '__le__',
 '__len__',
 '__lt__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__setattr__',
 '__setitem__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 'clear',
 'copy',
 'fromkeys',
 'get',
 'items',
 'keys',
 'pop',
 'popitem',
 'setdefault',
 'update',
 'values']
In [5]:
# divmod(a, b): a를 b로 나눈 몫과 나머지를 튜플 형태로 리턴
divmod(7, 3)
Out[5]:
(2, 1)
In [6]:
divmod(1.3, 0.2)
Out[6]:
(6.0, 0.09999999999999998)
In [8]:
# enumerate: 순서가 있는 자료형(리스트, 튜플, 문자형)을 입력받아 인덱스 값을 포함하는 enumerate 객체를 리턴
enumerate(['body', 'far', 'bar'])
<enumerate object at 0x7fa880980a68>
In [9]:
for i, name in enumerate(['body', 'far', 'bar']):
    print(i, name)
0 body
1 far
2 bar
In [10]:
# eval: 실행 가능한 문자열을 입력받아 문자열을 실행한 결과값을 리턴
eval('1+2')
Out[10]:
3
In [12]:
eval("'hi' + 'a'")
Out[12]:
'hia'
In [13]:
eval("divmod(4, 3)")
Out[13]:
(1, 1)
In [14]:
# filter: 첫번째 인자로 함수 이름을, 두번째 인자로 앞 함수에 차례로 넘길 반복 가능한 자료형을 넣는다.
# 두번째 인자가 차례로 첫번째 인자인 함수에 입력되어 참인 경우에만 다시 묶어서 반환한다.

# 양수값만 리턴
def positive(l): 
    result = [] 
    for i in l: 
        if i > 0: 
            result.append(i) 
    return result

print(positive([1,-3,2,0,-5,6]))
[1, 2, 6]
In [16]:
# fileter 함수로 구현
def positive(x):
    return x > 0

print(list(filter(positive, [1,-3,2,0,-5,6])))
[1, 2, 6]
In [17]:
print(list(filter(lambda x: x>0, [1, -3, 2, 0, -5, 6])))
[1, 2, 6]
In [18]:
# hex: 정수를 입력받아 16진수로 변화하여 리턴
hex(234)
Out[18]:
'0xea'
In [19]:
hex(3)
Out[19]:
'0x3'
In [20]:
# id(object): 객체를 입력받아 객체의 고유 주소값(레퍼런스)을 리턴

a = 3
id(3)
Out[20]:
10055616
In [21]:
id(a)
Out[21]:
10055616
In [22]:
b = a
id(b)
Out[22]:
10055616
In [23]:
id(4)
Out[23]:
10055648
In [24]:
# input: 사용자 입력을 받는 함수
a = input()
hi
In [25]:
print(a)
hi
In [26]:
b = input("Enter: ")
Enter: hi
In [27]:
b
Out[27]:
'hi'
In [28]:
# int: 숫자 형태의 문자열이나 소수점이 있는 숫자등을 입력받아 정수를 리턴
int('3')
Out[28]:
3
In [29]:
int(3.4)
Out[29]:
3
In [30]:
# 2진수로 표현된 '11'을 10진수로 반환
int('11', 2)
Out[30]:
3
In [31]:
# 16진수로 표현된 '1A'를 10진수로 반환
int('1A', 16)
Out[31]:
26
In [32]:
# isinstance(object, class): 첫 번째 인수로 인스턴스, 두 번째 인수로 클래스 이름을 받는다.
# 입력받은 인스턴스가 그 클래스의 인스턴스인지를 판단하여 참이면 True, 거짓이면 False를 리턴한다.
class Person: pass

a = Person()

isinstance(a, Person)
Out[32]:
True
In [33]:
b = 3
isinstance(b, Person)
Out[33]:
False

lambda

  • def와 동일한 역할
  • 함수를 한줄로 간결하게 만들 때 사용
  • def를 사용해야 할 정도로 복잡하지 않거나 def를 사용할 수 없는 곳에 주로 사용

lambda 인수1, 인수2, ... : 인수를 이용한 표현식

In [35]:
sum = lambda a, b: a+b
    
sum(3, 4)
Out[35]:
7
In [36]:
myList = [lambda a,b: a+b, lambda a,b: a*b]
myList
Out[36]:
[<function __main__.<lambda>>, <function __main__.<lambda>>]
In [37]:
myList[0](3, 4)
Out[37]:
7
In [38]:
myList[1](5, 3)
Out[38]:
15
In [39]:
# len: 입력값의 길이(요소의 전체 개수)를 리턴
len('Python')
Out[39]:
6
In [40]:
len([1, 2, 3])
Out[40]:
3
In [41]:
len([1, 'a'])
Out[41]:
2
In [42]:
# list: 반복 가능한 자료형dmf 입력받아 리스트로 만들어 리턴
list('Python')
Out[42]:
['P', 'y', 't', 'h', 'o', 'n']
In [43]:
list((1,2,3))
Out[43]:
[1, 2, 3]
In [44]:
# map(f, iterable): 함수(f)와 반복 가능한(iterable) 자료형을 입력으로 받는다. 
# map은 입력받은 자료형의 각 요소가 함수 f에 의해 수행된 결과를 묶어서 리턴하는 함수
def two_times(numberList):
    result = [ ]
    for number in numberList:
        result.append(number*2)
    return result

result = two_times([1, 2, 3, 4])
print(result)
[2, 4, 6, 8]
In [45]:
# map 으로 구현
def two_times(x): return x*2

list(map(two_times, [1, 2, 3, 4]))
Out[45]:
[2, 4, 6, 8]
In [46]:
# lambda 함수까지 사용하면

list(map(lambda x: x*2, [1,2,3,4]))
Out[46]:
[2, 4, 6, 8]
In [47]:
# max(iterable): 인수로 반복 가능한 자료형을 입력받아 그 최대값을 리턴
max([1,2,3])
Out[47]:
3
In [48]:
max('Python')
Out[48]:
'y'
In [49]:
# min(iterable): max 함수와 반대로, 인수로 반복 가능한 자료형을 입력받아 그 최소값을 리턴
min([1,2,3])
Out[49]:
1
In [50]:
min('Python')
Out[50]:
'P'
In [51]:
min('python')
Out[51]:
'h'
In [53]:
# oct(x): 정수 형태의 숫자를 8진수 문자열로 바꾸어 리턴
oct(34)
Out[53]:
'0o42'
In [54]:
oct(12345)
Out[54]:
'0o30071'
In [55]:
# open(filename, [mode]): "파일 이름"과 "읽기 방법"을 입력받아 파일 객체를 리턴하는 함수
# 읽기 방법(mode)이 생략되면 기본값인 읽기 전용 모드(r)로 파일 객체를 만들어 리턴

# [04-3 파일 읽고 쓰기] 참조
In [56]:
# ord(c): 문자의 아스키 코드값을 리턴
# ord 함수는 chr 함수와 반대이다.
ord('a')
Out[56]:
97
In [57]:
ord('0')
Out[57]:
48
In [58]:
# pow(x, y): x의 y 제곱한 결과값을 리턴
pow(2, 4)
Out[58]:
16
In [59]:
pow(3, 3)
Out[59]:
27
In [60]:
# range([start,] stop [,step]): for문과 함께 자주 사용되는 함수
# 입력받은 숫자에 해당되는 범위의 값을 반복 가능한 객체로 만들어 리턴

# 인수가 하나일 경우
list(range(5))
Out[60]:
[0, 1, 2, 3, 4]
In [61]:
# 인수가 둘일 경우
list(range(5, 10))
Out[61]:
[5, 6, 7, 8, 9]
In [62]:
# 인수가 셋인 경우
list(range(1, 10, 2))
Out[62]:
[1, 3, 5, 7, 9]
In [63]:
list(range(0, -10, -1))
Out[63]:
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
In [65]:
# sorted(iterable): 입력값을 정렬한 후 그 결과를 리스트로 리턴
sorted([3, 1, 2])
Out[65]:
[1, 2, 3]
In [67]:
sorted(['a', 'c', 'b'])
Out[67]:
['a', 'b', 'c']
In [68]:
sorted("zero")
Out[68]:
['e', 'o', 'r', 'z']
In [69]:
sorted((3, 2, 1))
Out[69]:
[1, 2, 3]
In [72]:
a = [3, 1, 2]
result = a.sort()
print(result)
None
In [73]:
a
Out[73]:
[1, 2, 3]
In [74]:
# str(object): 문자열 형태로 객체를 변환하여 리턴
str(3)
Out[74]:
'3'
In [75]:
str('hi')
Out[75]:
'hi'
In [76]:
'hi'
Out[76]:
'hi'
In [77]:
str('hi'.upper())
Out[77]:
'HI'
In [78]:
'hi'.upper()
Out[78]:
'HI'
In [79]:
# tuple(iterable): 반복 가능한 자료형을 입력받아 튜플 형태로 바꾸어 리턴
tuple('abc')
Out[79]:
('a', 'b', 'c')
In [80]:
tuple([1,2,3])
Out[80]:
(1, 2, 3)
In [81]:
tuple((1,2,3))
Out[81]:
(1, 2, 3)
In [82]:
# type(object): 입력값의 자료형이 무엇인지 알려주는 함수
type("abc")
Out[82]:
str
In [83]:
type([ ])
Out[83]:
list
In [84]:
type(open("test", 'w'))
Out[84]:
_io.TextIOWrapper
In [85]:
# zip(iterable*): 동일한 개수로 이루어진 자료형을 묶어 주는 역할을 하는 함수
zip([1, 2, 3], [4, 5, 6])
Out[85]:
<zip at 0x7fa8800b9b88>
In [86]:
list(zip([1, 2, 3], [4, 5, 6]))
Out[86]:
[(1, 4), (2, 5), (3, 6)]
In [87]:
list(zip([1, 2, 3], [4, 5, 6], [7, 8, 9]))
Out[87]:
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
In [88]:
list(zip("abc", "def"))
Out[88]:
[('a', 'd'), ('b', 'e'), ('c', 'f')]

05-6 외장함수

sys

  • sys 모듈은 파이썬 인터프리터가 제공하는 변수들과 함수들을 직접 제어할 수 있게 해주는 모듈

명령행에서 인수 전달하기 - sys.argv

C:/User/home>python test.py abc pey guido

  • 위와 같이 명령행에서 abc, pey, guido 라는 인수를 전달하면 sys.argv 라는 리스트 변수에 전달된다.
In [1]:
%%writefile argv_test.py
import sys

print(sys.argv)
Writing argv_test.py
In [2]:
!ls
01장 파이썬이란 무엇인가?.ipynb
02장 파이썬 프로그래밍의 기초, 자료형.ipynb
03장 프로그램의 구조를 쌓는다! 제어문.ipynb
04-sys1.py
04-sys2.py
04-새파일.txt
04장 프로그램의 입력과 출력은 어떻게 해야 할까?.ipynb
05장 파이썬 날개달기.ipynb
__pycache__
argv_test.py
foo.txt
game
mod1.py
test
In [3]:
%run argv_test.py you need Python
['argv_test.py', 'you', 'need', 'Python']

강제로 스크립트 종료하기 - sys.exit

sys.exit()

자신이 만든 모듈 불러와 사용하기 - sys.path

  • sys.path 는 파이썬 모듈들이 저장되어 있는 위치를 나타낸다.
  • 모듈 저장 위치를 추가하기 위해서는 sys.path.append() 를 사용한다.
In [2]:
import sys

print(sys.path)
['', '/usr/lib/python3.4', '/usr/lib/python3.4/plat-x86_64-linux-gnu', '/usr/lib/python3.4/lib-dynload', '/usr/local/lib/python3.4/dist-packages', '/usr/lib/python3/dist-packages', '/usr/local/lib/python3.4/dist-packages/IPython/extensions', '/root/.ipython']

pickle

  • 객체의 형태를 그대로 유지하면서 파일에 저장하고 불러올 수 있게 하는 모듈
  • pickle 모듈의 dump 함수를 이용하여 객체를 파일에 저장하고
  • load 함수를 이용하여 파일에서 객체를 불러온다.
In [3]:
import pickle

f = open("test.txt", "wb")
data = {"1": "python", "2": "you need"}
pickle.dump(data, f)
f.close()
In [4]:
!ls
01장 파이썬이란 무엇인가?.ipynb			       __pycache__
02장 파이썬 프로그래밍의 기초, 자료형.ipynb	       argv_test.py
03장 프로그램의 구조를 쌓는다! 제어문.ipynb	       foo.txt
04-sys1.py					       game
04-sys2.py					       mod1.py
04-새파일.txt					       test
04장 프로그램의 입력과 출력은 어떻게 해야 할까?.ipynb  test.txt
05장 파이썬 날개달기.ipynb
In [5]:
!more test.txt
�}q
In [6]:
import pickle

f = open("test.txt", "rb")
data = pickle.load(f)
print(data)
{'2': 'you need', '1': 'python'}

OS 모듈

  • 환경 변수나 디렉터리, 파일 등의 OS 자원을 제어할 수 있게 해주는 모듈

내 시스템의 환경 변수값을 알고 싶을 때 - os.environ

  • 시스템은 제각기 다른 환경 변수값을 가지고 있는데, os.environ은 현재 시스템의 환경 변수 값들을 보여 준다.
In [1]:
import os

os.environ
Out[1]:
environ({'USER': 'root', 'PAGER': 'cat', 'PS1': '<bg$>', 'LD_PRELOAD': '/usr/lib/coreutils/libstdbuf.so', 'LOGNAME': 'root', 'SHLVL': '2', 'LESSOPEN': '| /usr/bin/lesspipe %s', 'LESSCLOSE': '/usr/bin/lesspipe %s %s', 'MPLBACKEND': 'module://ipykernel.pylab.backend_inline', 'JPY_PARENT_PID': '441', 'SSH_TTY': '/dev/pts/2', 'SSH_CLIENT': '172.17.0.1 38904 22', 'LANG': 'ko_KR.UTF-8', 'LS_COLORS': 'rs=0:di=01;34:ln=01;36:mh=00:pi=40;33:so=01;35:do=01;35:bd=40;33;01:cd=40;33;01:or=40;31;01:su=37;41:sg=30;43:ca=30;41:tw=30;42:ow=34;42:st=37;44:ex=01;32:*.tar=01;31:*.tgz=01;31:*.arj=01;31:*.taz=01;31:*.lzh=01;31:*.lzma=01;31:*.tlz=01;31:*.txz=01;31:*.zip=01;31:*.z=01;31:*.Z=01;31:*.dz=01;31:*.gz=01;31:*.lz=01;31:*.xz=01;31:*.bz2=01;31:*.bz=01;31:*.tbz=01;31:*.tbz2=01;31:*.tz=01;31:*.deb=01;31:*.rpm=01;31:*.jar=01;31:*.war=01;31:*.ear=01;31:*.sar=01;31:*.rar=01;31:*.ace=01;31:*.zoo=01;31:*.cpio=01;31:*.7z=01;31:*.rz=01;31:*.jpg=01;35:*.jpeg=01;35:*.gif=01;35:*.bmp=01;35:*.pbm=01;35:*.pgm=01;35:*.ppm=01;35:*.tga=01;35:*.xbm=01;35:*.xpm=01;35:*.tif=01;35:*.tiff=01;35:*.png=01;35:*.svg=01;35:*.svgz=01;35:*.mng=01;35:*.pcx=01;35:*.mov=01;35:*.mpg=01;35:*.mpeg=01;35:*.m2v=01;35:*.mkv=01;35:*.webm=01;35:*.ogm=01;35:*.mp4=01;35:*.m4v=01;35:*.mp4v=01;35:*.vob=01;35:*.qt=01;35:*.nuv=01;35:*.wmv=01;35:*.asf=01;35:*.rm=01;35:*.rmvb=01;35:*.flc=01;35:*.avi=01;35:*.fli=01;35:*.flv=01;35:*.gl=01;35:*.dl=01;35:*.xcf=01;35:*.xwd=01;35:*.yuv=01;35:*.cgm=01;35:*.emf=01;35:*.axv=01;35:*.anx=01;35:*.ogv=01;35:*.ogx=01;35:*.aac=00;36:*.au=00;36:*.flac=00;36:*.mid=00;36:*.midi=00;36:*.mka=00;36:*.mp3=00;36:*.mpc=00;36:*.ogg=00;36:*.ra=00;36:*.wav=00;36:*.axa=00;36:*.oga=00;36:*.spx=00;36:*.xspf=00;36:', 'SSH_CONNECTION': '172.17.0.1 38904 172.17.0.13 22', 'HOME': '/root', 'OLDPWD': '/root', 'TERM': 'xterm-color', 'GIT_PAGER': 'cat', 'PATH': '/usr/local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games', '_': '/usr/bin/stdbuf', 'SHELL': '/bin/bash', 'CLICOLOR': '1', 'PWD': '/workspace/myNotebook', 'MAIL': '/var/mail/root', '_STDBUF_O': '0'})
  • 리턴받은 객체가 딕셔너리이기 때문에 다음과 같이 호출할 수 있다.
In [2]:
os.environ["path"]
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-2-44c42c2e5d86> in <module>()
----> 1 os.environ["path"]

/usr/lib/python3.4/os.py in __getitem__(self, key)
    631         except KeyError:
    632             # raise KeyError with the original key value
--> 633             raise KeyError(key) from None
    634         return self.decodevalue(value)
    635 

KeyError: 'path'
In [3]:
os.environ['PATH']
Out[3]:
'/usr/local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games'

디렉터리 위치 변경하기 - os.chdir

os.chdir("C:WINDOWS")

디렉터리 위치 리턴받기 - os.getcwd

os.getcwd()

In [4]:
os.getcwd()
Out[4]:
'/workspace/myNotebook/점프 투 파이썬'

시스템 명령어 호출하기 - os.system

In [5]:
os.system('dir')
Out[5]:
0
In [2]:
import os
print(os.system('ls'))
0

실행한 시스템 명령어의 결과값 리턴받기 - os.popen

  • 시스템 명령어를 실행시킨 결과값을 읽기 모드 파일 객체로 리턴

f = os.popen("dir")

In [3]:
f = os.popen("ls")
In [4]:
print(f.read())
01장 파이썬이란 무엇인가?.ipynb
02장 파이썬 프로그래밍의 기초, 자료형.ipynb
03장 프로그램의 구조를 쌓는다! 제어문.ipynb
04-sys1.py
04-sys2.py
04-새파일.txt
04장 프로그램의 입력과 출력은 어떻게 해야 할까?.ipynb
05장 파이썬 날개달기.ipynb
__pycache__
argv_test.py
foo.txt
game
mod1.py
test
test.txt

기타 유용한 os 관련 함수

함수 설명
os.mkdir() 디렉터리 생성
os.rmdir() 디렉터리 삭제, 단 디렉터리가 비어있어야 함
os.unlink() 파일을 지운다.
os.rename(src, dst) 파일명 변경

shutil

  • 파일을 복사해 주는 파이썬 모듈

파일 복사하기 - shutil.copy(src, dst)

  • src 파일을 dst 라는 이름으로 복사
  • dst 가 디렉터리라면 dst 디렉터리 안에 src 이름으로 복사
  • 동일한 dst 파일이 존재하면 덮어 씀
In [5]:
!ls
01장 파이썬이란 무엇인가?.ipynb			       __pycache__
02장 파이썬 프로그래밍의 기초, 자료형.ipynb	       argv_test.py
03장 프로그램의 구조를 쌓는다! 제어문.ipynb	       foo.txt
04-sys1.py					       game
04-sys2.py					       mod1.py
04-새파일.txt					       test
04장 프로그램의 입력과 출력은 어떻게 해야 할까?.ipynb  test.txt
05장 파이썬 날개달기.ipynb
In [6]:
!more foo.txt
In [7]:
!more test
In [8]:
!more argv_test.py
import sys

print(sys.argv)
In [9]:
import shutil
shutil.copy("argv_test.py", "argv_test2.py")
Out[9]:
'argv_test2.py'
In [10]:
!ls
01장 파이썬이란 무엇인가?.ipynb			       __pycache__
02장 파이썬 프로그래밍의 기초, 자료형.ipynb	       argv_test.py
03장 프로그램의 구조를 쌓는다! 제어문.ipynb	       argv_test2.py
04-sys1.py					       foo.txt
04-sys2.py					       game
04-새파일.txt					       mod1.py
04장 프로그램의 입력과 출력은 어떻게 해야 할까?.ipynb  test
05장 파이썬 날개달기.ipynb			       test.txt
In [11]:
!more argv_test2.py
import sys

print(sys.argv)

glob

  • 특정 디렉터리 안의 파일 이름 모두를 알아야 할 때 사용하는 모듈

디렉터리에 있는 파일들을 리스트로 만들기 - glob(pathname)

  • 디렉터리 내의 파일들을 읽어서 리턴
  • *, ? 등의 메타 문자 사용 가능
In [12]:
import glob

glob.glob("./04*")
Out[12]:
['./04-sys2.py',
 './04장 프로그램의 입력과 출력은 어떻게 해야 할까?.ipynb',
 './04-sys1.py',
 './04-새파일.txt']

tempfile

  • 파일을 임시로 만들어서 사용할 때 유용한 모듈
  • mktemp()는 중복되지 않는 임시 파일의 이름을 무작위로 생성해서 리턴
  • TemporaryFile()은 임시 저장 공간으로 사용될 파일 객체를 리턴
  • 기본적으로 바이너리 쓰기 모드(wb)이며, close()가 호출되면 이 파일 객체는 사라진다.
In [13]:
import tempfile
filename = tempfile.mktemp()
filename
Out[13]:
'/tmp/tmp2wexrlak'
In [14]:
f = tempfile.TemporaryFile()
print(f)
f.close()
<_io.BufferedRandom name=58>

time

  • 시간과 관련된 유용한 함수 포함
In [15]:
# time.time : 현재 시간을 실수 형태로 리턴, 1970년 1월 1일 기준으로 지난 시간을 초 단위로 리턴
import time

time.time()
Out[15]:
1506492100.01737
In [16]:
# time.localtime : time.time()에 의해서 반환된 실수값을 이용해서 연도, 월, 일, 시, 분, 초 의 형태로 바꾸어 주는 함수
time.localtime(time.time)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-16-fb4b177d66f3> in <module>()
      1 # time.localtime : time.time()에 의해서 반환된 실수값을 이용해서 연도, 월, 일, 시, 분, 초 의 형태로 바꾸어 주는 함수
----> 2 time.localtime(time.time)

TypeError: an integer is required (got type builtin_function_or_method)
In [17]:
time.localtime(time.time())
Out[17]:
time.struct_time(tm_year=2017, tm_mon=9, tm_mday=27, tm_hour=6, tm_min=2, tm_sec=55, tm_wday=2, tm_yday=270, tm_isdst=0)
In [18]:
time.localtime(time.time()).tm_year
Out[18]:
2017
In [20]:
# time.asctime : time.localtime에 의해서 반환된 튜플 형태의 값을 알아보기 쉬운 형태로 리턴
time.asctime(time.localtime(time.time()))
Out[20]:
'Wed Sep 27 06:05:05 2017'
In [21]:
# time.ctime : 위와 같은 결과이나 항상 현재 시간만을 리턴
time.ctime()
Out[21]:
'Wed Sep 27 06:05:52 2017'

time.strftime

time.strftime('출력할 형식 포맷 코드', time.localtime(time.time()))

포맷 코드

포맷코드 설명
%a 요일 줄임말 Mon
%A 요일 Monday
%b 달 줄임말 Jan
%B January
%c 날짜와 시간을 출력함 06/01/01 17:22:21
%d 날(day) [00, 31]
%H 시간 - 24시간 출력 형태 [00, 23]
%I 시간 - 12시간 출력 형태 [01, 12]
%j 1년 중 누적 날짜 [001, 366]
%m [01, 12]
%M [01, 59]
%p AM or PM AM
%S [00, 61]
%U 1년 중 누적 주-일요일을 시작으로 [00, 53]
%w 숫자로 된 요일 [0(일요일), 6 ]
%W 1년 중 누적 주-월요일을 시작으로 [00, 53]
%x 현재 설정된 로케일에 기반한 날짜 출력 06/01/01
%X 현재 설정된 로케일에 기반한 시간 출력 17:22:21
%Y 년도 출력 2001
%Z 시간대 출력 대한민국 표준시
%% 문자 %
%y 세기부분을 제외한 년도 출력 01
In [22]:
import time
time.strftime('%x', time.localtime(time.time()))
Out[22]:
'09/27/17'
In [23]:
time.strftime('%c', time.localtime(time.time()))
Out[23]:
'Wed Sep 27 06:28:49 2017'
In [24]:
# time.sleep : 주로 루프 안에서 사용하여 일정한 시간 간격을 두고 루프를 실행

import time

for i in range(10):
    print(i)
    time.sleep(1)
0
1
2
3
4
5
6
7
8
9

calendar

  • 파이썬에서 달력을 볼 수 있게 해주는 모듈
In [25]:
import calendar
print(calendar.calendar(2017)) # calendar.prcal(2017)
                                  2017

      January                   February                   March
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
                   1             1  2  3  4  5             1  2  3  4  5
 2  3  4  5  6  7  8       6  7  8  9 10 11 12       6  7  8  9 10 11 12
 9 10 11 12 13 14 15      13 14 15 16 17 18 19      13 14 15 16 17 18 19
16 17 18 19 20 21 22      20 21 22 23 24 25 26      20 21 22 23 24 25 26
23 24 25 26 27 28 29      27 28                     27 28 29 30 31
30 31

       April                      May                       June
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
                1  2       1  2  3  4  5  6  7                1  2  3  4
 3  4  5  6  7  8  9       8  9 10 11 12 13 14       5  6  7  8  9 10 11
10 11 12 13 14 15 16      15 16 17 18 19 20 21      12 13 14 15 16 17 18
17 18 19 20 21 22 23      22 23 24 25 26 27 28      19 20 21 22 23 24 25
24 25 26 27 28 29 30      29 30 31                  26 27 28 29 30

        July                     August                  September
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
                1  2          1  2  3  4  5  6                   1  2  3
 3  4  5  6  7  8  9       7  8  9 10 11 12 13       4  5  6  7  8  9 10
10 11 12 13 14 15 16      14 15 16 17 18 19 20      11 12 13 14 15 16 17
17 18 19 20 21 22 23      21 22 23 24 25 26 27      18 19 20 21 22 23 24
24 25 26 27 28 29 30      28 29 30 31               25 26 27 28 29 30
31

      October                   November                  December
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
                   1             1  2  3  4  5                   1  2  3
 2  3  4  5  6  7  8       6  7  8  9 10 11 12       4  5  6  7  8  9 10
 9 10 11 12 13 14 15      13 14 15 16 17 18 19      11 12 13 14 15 16 17
16 17 18 19 20 21 22      20 21 22 23 24 25 26      18 19 20 21 22 23 24
23 24 25 26 27 28 29      27 28 29 30               25 26 27 28 29 30 31
30 31

In [26]:
calendar.prmonth(2017, 10)
    October 2017
Mo Tu We Th Fr Sa Su
                   1
 2  3  4  5  6  7  8
 9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25 26 27 28 29
30 31
 
In [27]:
# calendar.weekday : 그 날짜에 해당하는 요일 정보를 리턴, 0 - 6
calendar.weekday(2017, 9, 27)
Out[27]:
2
In [28]:
# calendar.monthrange : 입력받은 달의 1일이 무슨 요일인지와 그 달이 며칠까지 있는지를 튜플 형태로 리턴
calendar.monthrange(2017, 9)
Out[28]:
(4, 30)

random

  • 난수를 발생시키는 모듈
In [29]:
# random.random : 0.0 에서 1.0 사이의 실수 중에서 난수값을 리턴
import random
random.random()
Out[29]:
0.33541440698496394
In [30]:
random.random()
Out[30]:
0.6925208291425975
In [31]:
# random.randint : 주어진 정수 중에서 난수값을 리턴
random.randint(1, 10)
Out[31]:
9
In [32]:
random.randint(1, 55)
Out[32]:
47
In [34]:
import random

def random_pop(data):
    number = random.randint(0, len(data)-1)
    return data.pop(number)

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


while data:
    print(random_pop(data))
1
3
4
2
5
In [35]:
# random 모듈의 choice 함수를 사용하여 더 직관적으로 표현

def random_pop(data):
    number = random.choice(data)
    data.remove(number)
    return number

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

while data: print(random_pop(data))
4
3
1
5
2
In [36]:
# random.shuffle : 리스트의 항목을 무작위로 섞어주는 함수
data = [1, 2, 3, 4, 5]
random.shuffle(data)

data
Out[36]:
[2, 4, 3, 5, 1]

webbrowser

  • 기본 웹 브라우저가 자동으로 실행되게 하는 모듈
import webbrowser
webbrowser.open("http://google.com")

webbrowser.open_new("http://google.com")