1) 모듈

C++의 #include 와 비슷하다고 생각하면 된다.

같은 폴더 안에 있을 경우에는

간단하게

import TestJaeho

이렇게 import시켜 주면 된다.

TestJaeho.py

def sum ( a, b):
    if type(a) != type(b):
        print ("%s와 %s는 같은 타입이 아니라 더할 수 없습니다." % (a,b))
        return
    else:
        return a+b

Test.py

import TestJaeho

print(TestJaeho.sum(5,625))
print(TestJaeho.sum('a','g'))
print(TestJaeho.sum('a',5))

>>> 630
>>> ag
>>> a와 5는 같은 타입이 아니라 더할 수 없습니다.

단 사용할려면 TestJaeho.sum 이런식으로 해줘야 한다.

정말 귀차니즘 발동 시킨다.

그냥 sum으로만 사용하고 싶을 시에는

또는

from TestJaeho import sum 

이렇게 하면 되는데

그냥 import *가 편할 듯 싶다.

다른 폴더에 있는 파일을 임포트 하고 싶을 때!!

우선

import sys

을 하자

sys.path를 실행해 보면

['C:\\Python', 'C:\\Program Files\\PyScripter\\Lib\\rpyc.zip', 'C:\\Windows\\system32\\python32.zip', 'C:\\Python32\\DLLs', 'C:\\Python32\\lib', 'C:\\Python32', 'C:\\Python32\\lib\\site-packages']

이렇게 나온다.

이경로에 있는 것들은 그냥 import 모듈이름  하면 쓸 수 있다.

그러니 sys.path에 내가 쓰고 싶은 폴더를 넣어주면 된다.

이렇게!!

import sys
sys.path.append("C:\Python\TestJaeho")
print (sys.path)

import moduleTest

이렇게 추가한다음 사용하면 된다.

if __name__ == "__main__"

보통은 자신의 모듈의 이름을 가지지만 파이썬 인터프리터에 의해 첫번째 사용 되는 모듈은

__main__이라는 이름을 가지게 된다.

1) 클래스

함수	설명	예제 (X, Y는 인스턴스)
__init__	생성자(Constructor), 인스턴스가 만들어 질 때 호출
__del__	소멸자(Destructor) 인스턴스가 사라질 때 호출
__add__	연산자 "+"	X + Y
__or__	연산자 "|"	X | Y
__repr__	print	print X
__call__	함수호출 X()했을 때 호출
__getattr__	자격부여	X.메소드
__getitem__	인덱싱	X[i]
__setitem__	인덱스 치환	X[key] = value
__getslice__	슬라이싱	X[i:j]
__cmp__	비교	X > Y

class FourCal():
    def __del__(self):
        print ("클래스가 죽었습니다.\n")
    def setNum( self, a, b ):
        self.first = a
        self.second = b
    def sum( self ):
        print ("%s + %s = %s\n" % (self.first,self.second,self.first+self.second))
    def mul( self ):
        print ("%s * %s = %s\n" % (self.first,self.second,self.first*self.second))
    def sub( self ):
        print ("%s - %s = %s\n" % (self.first,self.second,self.first-self.second))
    def div( self ):
        print ("%s / %s = %s\n" % (self.first,self.second,self.first/self.second))

test = FourCal()

test.setNum(9,3)

test.sum()
test.sub()
test.mul()
test.div()

9 + 3 = 12

9 - 3 = 6

9 * 3 = 27

9 / 3 = 3.0

다른 언어와 마찬가지로 클래스 사용법은 비슷하니 금방 익숙해질 듯 싶다.

기억해야 할것은 클래스 내 함수 사용시에는 반드시 ( self ) self을 넣어줘야한다.

파이썬 언어 특징이니 그냥 기억하면 될 듯 싶다.

연산자 오버로딩

class ChoHouse:
    lastName= "조"
    def __init__(self, name):
        self.FullName = self.lastName + name
    def __del__(self):
        print ("%s가 파산했습니다.\n" % self.FullName)
    def setMoney( self, money ):
        self.Money = money
        print ("%s의 지갑에 들어 있는 돈은 %s입니다.\n" % (self.FullName, self.Money))
    def __add__( self, you):
        print("%s가 %s한테 돈을 빌렸다.\n" % (self.FullName,you.FullName))
    def __sub__( self, you):
        print("%s가 %s한테 돈을 빌렸다.\n" % (you.FullName,self.FullName))

def input_int():
    return int( input("숫자 입력하세요") )

a = input_int()
b = input_int()
jaeho(a,b)

input()

이 함수를 사용하면 입력 받을 수 있는 창이 뜬다.

대신 모든 입력 받은건 문자형으로 받는다.

그래서 형변환이 필수!!!!!

3) 파일 읽고 쓰기

f = open("jaeho.txt",'w')
data=""
for i in range(1,11):
    data = data + "%d 번 째 줄입니다\n" % i

f.write(data)
f.close()

tell 과 seek
>>> f = open("test.txt", 'w')
>>> f.write("this is one line\n")
>>> f.write("two line\n")
>>> f.write("three line\n")
>>> f.close()
우선 test.txt라는 파일을 쓰기 모드로 열어서 파일 객체를 생성한후
write함수를 이용하여 총 세 개의 줄을 test.txt파일에 입력하고 파일 객체를 닫는다.

test.txt파일은 다음과 같을 것이다.
this is one line
two line
three line

다음의 예를 계속해서 따라해 보자.
>>> f = open("test.txt", 'r')
>>> f.tell()
0

처음에 파일을 읽기 모드로 열었고, 그 파일 포인터 값을 알기 위해서 tell을 호출하였다.
물론 파일의 맨 처음이기 때문에 0을 반환했다.
>>> f.readline()
'this is one line\n'
>>> f.tell()
17

다음에 한 줄을 읽는다. 그 다음의 파일 포인터는 그 줄의 바이트 수만큼 포인터가 증가한다.
따라서 다시 tell을 호출했을 때 17이 된 것이다.
>>> f.readline()
'two line\n'
>>> f.tell()
26

마찬가지로 다시 한 줄을 읽었더니 파일 포인터의 위치는 26이 되었다.
>>> f.seek(0)
>>> f.readline()
'this is one line\n'
>>>
파일 포인터의 값을 변화시키기 위해서 seek를 사용하였다.
f.seek(0)는 파일 포인터의 위치를 0으로 하라는 것이다.
따라서 다음에 다시 한 줄을 읽었을 때는 그 파일의 맨 처음 줄을 읽게 되는 것이다.

readline()

f = open("새파일.txt", 'r')

while 1:
    line = f.readline()
    if not line: break
    print line


f.close()

readlines()

f = open("새파일.txt", 'r')
lines = f.readlines()


for line in lines:
    print line

f.close()

read()

f = open("새파일.txt", 'r')
data = f.read()

print data

f.close()

- 함수

>>> def 함수명 ( 인자 )

파이썬은 함수선언 할 때 꼭 def을 붙혀 주면된다.

- 인자 여러가지 받을 방법

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

입력변수 앞에 *을 붙혀주면 만사 오키~~

def jaeho(*test):
    u = 0
    for i in test:
        print (i + u)
        u = i + u

jaeho(5,3,4,5)

5
8
12
17

>>> def sum_mul(choice, *args):
...     if choice == "sum":
...         result = 0
...         for i in args:
...             result = result + i
...     elif choice == "mul":
...         result = 1
...         for i in args:
...             result = result * i
...     return result
...
>>>

>>> result = sum_mul('sum', 1,2,3,4,5)
>>> print result

15
>>> result = sum_mul('mul', 1,2,3,4,5)
>>> print result
120

리턴값을 여러개 받는 방법

>>> def ab( i,o):
...     return i + o, o * i, i * i, o *o
...
>>> ab(2,5)
(7, 10, 4, 25)
>>> a,b,c,d = ab(3,6)
>>> a
9
>>> b
18
>>> c
9
>>> d
36
>>>

함수 내에서 선언된 변수의 효력 범위

a = 1 
def vartest(a): 
    a = a +1 

vartest(a) 
print a

def vartest(b): 
    b = b + 1

def vartest(a): 
    a = a + 1 

vartest(3) 
print a

a = 1 
def vartest(a): 
    a = a +1 
    return a 

a = vartest(a) 
print a

a = 1 
def vartest(): 
    global a 
    a = a+1 

vartest() 
print a

공부 참조 싸이트 : http://codejob.co.kr/docs/view/2/

 

[1] if문

and, or, not

c++ 생각하면

and 는 &&

or   는 ||

not 는 !

이렇게 생각하면 된다.

 

 

x in s, x not in s

>>> 1 in [1, 2, 3]
True
>>> 1 not in [1, 2, 3]
False

다중 조건 문은 elif 로 사용된다.

>>> pocket = ['paper', 'handphone']
>>> watch = 1
>>> if 'money' in pocket:
...      print "택시를 타고가라"
... elif watch: 
...      print "택시를 타고가라"
... else:
...      print "걸어가라"
...
택시를 타고가라

pass의 사용

가끔 조건문을 판단하고 참 거짓에 따라 행동을 정의 할 때 아무런 일도 하지 않게끔 설정을 하고 싶을 때가 생기게 된다. 다음의 예를 보자.

 

"지갑에 돈이 있으면 가만히 있고 지갑에 돈이 없으면 시계를 끌러라“  

위의 예를 pass를 적용해서 구현해 보자.

>>> pocket = ['paper', 'money', 'handphone']
>>> if 'money' in pocket:
...     pass 
... else:
...     print "시계를 끌른다"
...

pocket이라는 리스트 안에 'money'란 문자열이 있기 때문에 if문 다음문장인 pass가 수행되었고 아무런 결과값도 보여주지 않는 것을 확인 할 수 있다.

[2] while문
while문은 C++문법과 다른게 없어서 그냥 넘어간다.
 
 
[3] for문
for문의 기본구조

for 문의 기본적인 구조는 다음과 같다.
for 변수 in 리스트(또는 터플, 문자열):
    <수행할 문장1>
    <수행할 문장2>
 
>>> jaeho_for_List = ['f','u','a']
>>> for i in jaeho_for_List:
...    print i
...
f
u
a
 
C++에서 for each 문하고 비슷하다고 생각하면 이해가 된다.
 
 
range함수
 
>>> a = range(10) 
>>> a 
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]  
>>> a = range(1, 11) 
>>> a 
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 
 
 
다양한 for문의 사용
>>> a = [(1,2), (3,4), (5,6)] 
>>> for (first, last) in a: 
. . .     print first + last 
. . . 
3 
7 
11
 
>>> for i in range(2,10): 
...     for j in range(1, 10): 
...         print i*j, 
...     print '\n' 
... 
2 4 6 8 10 12 14 16 18 
3 6 9 12 15 18 21 24 27 
4 8 12 16 20 24 28 32 36
5 10 15 20 25 30 35 40 45
6 12 18 24 30 36 42 48 54 
7 14 21 28 35 42 49 56 63 
8 16 24 32 40 48 56 64 72 
9 18 27 36 45 54 63 72 81

공부 참조 싸이트 : http://codejob.co.kr/docs/view/2/

[3] 리스트 (List)

여러 가지 리스트의 생김새를 살펴보면 다음과 같다.

>>> a = []
>>> b = [1, 2, 3]
>>> c = ['Life', 'is', 'too', 'short']
>>> d = [1, 2, 'Life', 'is']
>>> e = [1, 2, ['Life', 'is']]

a 처럼 리스트는 아무 것도 포함하지 않는 빈 리스트([])일 수도 있고 b처럼 숫자를 그 요소 값으로 가질 수도 있고, c처럼 문자열을 요소값으로 가질 수 있고 d처럼 숫자와 문자열을 함께 요소값으로 가질 수 있으며 또한 e처럼 리스트 자체를 그 요소 값으로 가질 수 도 있다. 즉, 리스트 내에는 어떠한 자료형도 포함시킬 수 있다.

>>> a = [1, 2, 3, ['a', 'b', 'c']]

>>> a[0]
1
>>> a[-1]
['a', 'b', 'c']
>>> a[3]
['a', 'b', 'c']

이차원으로 생각하면 편할듯!!

>>> a[-1][1]
'b'
>>> a[-1][2]
'c'

>>> a = [1, 2, ['a', 'b', ['Life', 'is']]]

삼차원으로 생각하면 편할듯!!

>>> a[2][2][0]
'Life'

리스트의 슬라이싱

>>> a = [1, 2, 3, 4, 5]
>>> a[0:2]
[1, 2]

어제 했던 문자열의 슬라이싱하고 사용방법이 똑같다.

[5] 딕셔너리 (Dictionary)

>>> dic = {'name':'pey', 'phone':'0119993323', 'birth': '1118'}

>>> a = 3 
>>> b = 3
>>> del(a)
>>> del(b)

>>> a, b = 'python', 'life'

>>> (a, b) = ('python', 'life')

>>> [a,b] = ['python', 'life']

>>> a = b = 'python'

>>> a = [1,2,3]
>>> b = a
>>> a[1] = 4
>>> a 
[1, 4, 3]
>>> b
[1, 4, 3]

>>> a = [1, 2, 3] 
>>> b = a[:]
>>> a[1] = 4
>>> a[1, 4, 3]
>>> b[1, 2, 3]

>>> from copy import copy 
>>> b = copy(a)

>>> b is a
False