깍돌이

재귀 함수 (Recursive Function)

재귀(Recursion) 에 따라서 내가 나를 호출하여 사용하는 함수라고 볼수 있다.

1개의 함수

void Recursive_fnc() 라는 함수에서 또 다시 자기 자신을 불러서 수행하는 방식을 말한다. 

그렇기 떄문에 재귀 함수 설계시에는 적절한 종료 조건을 만들어서 종료 할수 있도록 설계하고 구현 하여야 한다.

LISP 라는 언어는 재귀를 정말 밥먹듯이 쓴다고 한다. 여기서 따로 언급은 하지 않겠다.

필자는 이제까지 재귀 함수 는 왜 쓰는 걸까? 라고 하게 되면

C에서 속도가 빠르니까 ! 재귀가 속도가 빨라

하지만 Function Call 을 계속 해주기 때문에 아무리 Return 을 한다 해도 메모리상에 자꾸 참조되는 함수가 생기고 언제 

Seg Fault 가 날수 있기 때문에 매우 위험하다라는 생각을 가지고 있었다. 이건 단순한 자료조사가 아닌 카더라 통신과 

주관적인 생각이였을 뿐

갑자기 생각난 재귀함수에 대해서 어떠한 원리일까를 찾아 보던중 재미난 글을 발견 하였다. 

재귀의 가장 큰예는 팩토리얼 함수를 예로 들수가 있다. 1 ~ n 까지 곱하는 것

int factorial (int n)

{

if(n==0) return 1;

return (n*factorial(n-1));

}

정말 깔끔하며 가독성도 매우 높다. 하지만 이 재귀함수에는 문제점이 있습니다.

매번 함수마다 자기 자신을 호출한다는 점

1. 재귀적으로 함수를 지속적으로 호출시에 fac의 예를 들었을때 

return (n*factorial(n-1)); 이란느 부분이 있는데

만약에

100이라는 값이 들어오게 되면

factorial(100) * factorial(99) * factorial(98) ~.... 으로 1이 되어서 끝나기직전까지 호출만 이루어지는 상황이 발생하는데

함수 호출시 프로세스는 parameter, return values 등이 반환시에 되돌아갈 위치를 스택에 저장하게 되는데

지속적으로 많은 호출이 나타나게되면 스택에 부모함수부터 데이터들을 쌓아 놓게 되는데 스택같은 경우는 무한정으로 

존재하지 않기 때문애 넘치는 Stack OverFlow가 발생할수 있습니다.

팩토리얼같은 경우는 어차피 컴퓨터가 처리하는 수의 범위를 넘어 버리기 때문에 불가능합니다.

2. 또한 스택에 데이터를 자꾸 존재한다는 것은 메모리의 사용량이 증가 된다는 뜻이 되며 

스택에 데이터를 쌓을때 이 값을 복사하게 되는데 이 쯤에서 다시 문제가 생기게 된다. 

피보나치 수열을 예로 들어 보게 되면

F(n+2) = F(n+1) + F(n) 

unsigned int fibonacci(int n)

{

if(n==0) return 0;

else if(n==1) return 1;

else return (fibonacci(n-1)+ fibonacci(n-2));

}

// 재귀 함수의 호출 시간 스크랩 - http://www.nicklib.com/application/2953

보시는거와 같이 2개의 자식 함수를 재귀적으로 부르고 있으며 해당 함수에 대한 시간 입니다.

------------------------------------------------

 N        결과값            걸린시간

------------------------------------------------

10           55                      2마이크로초

20         6765                    225마이크로초

30       832040             34밀리 391마이크로초

40    102334155        3초 544밀리 659마이크로초

50  12586269025   7분 15초  68밀리 740마이크로초

60 1548008755920 14시간 40분 28초 531밀리 693마이크로초

N이 30일경우에는 1초도 걸리지 않기 때문에 괜찮지만 40부터는 눈에 띄게 계산에 대한 시간이 보여지는 것을 알 수 있습니다.

해당 참조하였던 블로거는 n이 50인 값부터 int64으로 변환하여서 돌렸다고 합니다.

60에서 14시간이 걸린것을 보면 오래걸린건지 아닌지 분간이 잘 되지않지만 이 계산법에 대한 코드를

비재귀 함수로 구현하였을때의 속도를 비교하게 되면 재귀의 문제점을 파악할 수 있습니다.

비재귀 함수인

unsigned int fibonacci2(int n)

{

unsigned int a =1, b=1, c=1;

int (n==0) return 0;

for(;n;2;n--)

{

c=a+b;

a=b;

b=c;

}

return c;

}

재귀에 비하여 확실히 복잡하긴 합니다.  해당 소스에 대한 재귀 결과입니다.

------------------------------------------------

 N               결과값            걸린시간

------------------------------------------------

10                    55             0초

20                  6765             0초

30                832040             0초

40             102334155             0초

50           12586269025             0초

60         1548008755920             0초

70       190392490709135             0초

80     23416728348467685             0초

90   2880067194370816120             0초

100  3736710778780434371             0초

-----------------------------------------------

재귀함수에 대한 문제점을 파악할수 가 있는 결과입니다. 해당 테스트 블로거의 PC의 CPU 사양은 듀얼코어 1.8인 것을 감안하면(고사양은 아님)

엄청난 차이라고 할수 있습니다.

언제나 재귀함수에 대해 검색하면 스택 오버플로우 메모리문제, 속도 문제 등이 나타나는데 절대 안좋은점만이 있는 것은 아닙니다. 

안좋기만한 함수가 왜구현되고 왜 사용되고 재귀함수라는 말이 생겨나고 꼭 프로그래밍 책에 나오는 이유가 있습니다.

보시면 알겠지만 가독성이 매우 뛰어나게 됩니다. 재귀에 대한 다른 이야기는 다음에 찾아서 써보도록 하겠습니다.

# 세미나 자료를 위한 프로그램 제작
# 0,0 1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9
#  0   1   2   3   4   5   6   7   8   9


# 입력된 문자열 에 a-z 가 포함이 되지 않음을 체크한다. 포함이 되었을 경우 -1 을 반환하며 잘못된 문자열임을 알려준다.
# 0~ 9 가 정상적으로 포함되어있을시에는 해당 문자열열 그대로 반환 한다.
# 알파벳 유효성 검사
def rrn_parsing(rrn):
    alpha_sum = 0
    parsing = "qwertyuiopasdfghjklzxcvbnm"
    alphabet_list = []
    i = 0
    j = 0
    z = 0
    # 알파벳 리스트 추가
    while i < 26:
        alphabet_list.append(parsing[i].lower())
        i = i + 1
    # 알파벳 소문자 서칭
    alphabet_list.sort()

    # print("alphabet_list {0}".format(alphabet_list))
    # parsing before
    print("Input RRN ", rrn)
    while j < 26:
        alpha_sum = alpha_sum + rrn.count(alphabet_list[j])
    # print("InPut RRN {0} counting alpha {1}".format(rrn, alphabet_list[j]))
        j = j + 1
    # print("print alpha_sum {0}".format(alpha_sum))

    # 알파벳 대문자 서칭 ( 알파벳 리스트 전부 제거 )
    i = 0
    j = 0
    while i < 26:
        alphabet_list.pop()
        i = i + 1

    i = 0
    # 대문자 셋팅
    while i < 26:
        alphabet_list.append(parsing[i].upper())
        i = i + 1
    # 대문자 서칭
    while j < 26:
        alpha_sum = alpha_sum + rrn.count(alphabet_list[j])
        j = j + 1

    if alpha_sum > 0:
        return 0
    if alpha_sum == 0:
        return 1


# 주민 등록번호 유효성 검사
def rrn_len(rrn):
    true_or_false = 0
    check_num=['0','1','2','3','4','5','6','7','8','9']
    check_sum = 0
    # parsing before
    # print("parsing before ", rrn)
    rrn_parsing = rrn.replace(" ", "")
    # print("parsing after ",rrn_parsing)
    # parsing after
    i=0
    while i<10:
        #  0   =   0 + 0 갯수
        check_sum = check_sum + rrn.count(check_num[i])
        i = i + 1
    if check_sum == 13:
        print("RRN is Success ", check_sum)
        true_or_false = 1
    if check_sum < 13:
        print("RRN is Failed ", check_sum)
        true_or_false = 0
    return true_or_false


# 유효성 검사 반환값에 대한 Split 함수
def rrn_regular_expression_parsing_msg(rrn):
    return rrn


# 유효성 검사
def rrn_regular_expression(rrn):
    # char_checksum
    if rrn_parsing(rrn) == 0:
        return "문자열이 포함되어있습니다."
    if rrn_len(rrn) == 0 :
        return "숫자가 13장이 넘습니다."
    return rrn


# 12개
RRN_true = "11111111111111"
RRN_false = "90 1 0 2 7 1 1 5 6 0 2 5"
RRN_char = "abcde"
RRN_Upper = "ABCDEF"
RRN_Count = 13
i = 0
# 0~ 12 까지  11번까지가 11
# print(RRN_false[12]) 5가 반환 됩니다.

print("*"*60)
print("*"*24 + "Python Start" + "*"*24 )
print("*"*60)


# a-z 문자열 삽입
print(rrn_regular_expression(RRN_Upper))
# 성공
#print(rrn_regular_expression(RRN_false))
# 14자
#print(rrn_regular_expression(RRN_true))

일반적인 문자열 포매팅에 대해서 확인 해보았는데

"Hello World %d" % 5

Hello World 5 

가되는데 이런 방식이 아닌

"Hello World {0}".format(5)

Hello World 5 가 된다.

"Hello World %s" %"Five"

"Hello World {0}".format("Five") 

num =5

format ="Five"

"Hello World {0} is {1}".format(num,format)

a = "Hello World"

라고 되어있을때 Hello World의 값을  바꿀수가 없다. 5장에서 말했듯이 immutable 형이라고 도 한다고 한다.

a[0] = 은 지금 H값이 되겠지만

a[0] = "A"로 바꿀수는 없는 것이다.

하지만 조금 주먹 구구식으로 말하자면

a="String Format"

print(a[:1])
# S t r i n g
# 0 1 2
# 0 <= a < 1
# S 가 출력

# S t r i n g
# 0 1 2
#  2 < = a <
# r 부터 출력되게 된다.
print(a[2:])
b = a[:1] + 'T'  + a[2:]
print("formatting a -> ",b)
# 새로운 문자를 출력하기 위해서 일단 주먹 구구식으로  변환이 가능 하다 

결과

S

ring Format

formatting a ->  STring Format

현재 보여진것은 문자열 포매팅은 아니고 기본적인 변화와 문자열이 선언후에는 변하지 않는 점을 알수 있도록 하였다.

format="Hello %d World " % 3
print(format)

결과

Hello 3 World 

format="Hello %s" % "World"
print(format)

결과

Hello World

숫자와 문자열도 포매팅이 되는 법을 알수가 있다. !!    %d %s 는 C언어에서도 자주 보아왔던 포매팅 방식이다.

var을 이용한 포매팅

위에 예제에서 숫자만 변수로 따로 선언 해주면 된다.

number =3
format = "Hello %d World " % number

print(format)

결과

Hello 3 World 

두개이상의 포매팅을 해주는 경우 방법

format = "World"
number = 3

second_format = "Hello %s is %d" % (format,number)

print(second_format)

결과

Hello World is 3

, 로 구분하여서 넣으면 된다.  printf("",a,b)와 비슷한 맥락 

파이썬 문자열 포맷 

1.       %s        문자열(string)

2.       %c        문자 1개(character)

3.       %d        정수(Integer)

4.       %f        부동 소수(floating-point)

5.       %o        8진수

6.       %x        16진수

7.       %%       '%' 문자 자체

&& "%50s" -> 전체 50자의 문자열 공간에서 우측으로 정렬 하고 나머지는 공백으로 놓게된다.

C언어에서 50자를 띄워쓰기를 하는 경우와 다른 점을 인지한다.

"%-50s" -> 전체 50자의 문자열 공간을 잡고 좌측으로 정렬후 나머지 우측은 공백으로 놓게 된다.

%0.3f = 소수점 세 번째 자리 까지 나타낸다.

앞에 0 대신에 숫자가 들어오게 되면 양수일 경우에는 위와같이 문자열 공간의 개수를 잡고 공백을 넣는다.

%10.3f 

문자열 공간을 10칸을 잡고 우측 정렬을 하게된다. ex: "%10.3f" % 3.1452452

 ㅁ ㅁ ㅁ ㅁ ㅁ ㅁ ㅁ ㅁ ㅁ ㅁ 

                     3  .   1  4  5 

로 잡히게 된다. 

문자열 관련 내부 함수 

temp="Hello World"
print("Hello World  'l' count",temp.count('l'))
print("Hello World  'd' find ",temp.find('d'))

find 

count

index

결과

Hello World  'l' count 3

Hello World  'd' find  10

find의 경우 찾는 문자열이 없다면 -1을 반환하게 된다. d의 문자열이 처음 나오는 위치인 10을 반환하게 된다.

index의 경우도 find와 같은 기능을 한다. 하지만 찾는 문자열이 없는 경우에 대해서는 오류를 발생 시킨다.

uppder 함수 

temp ="hello world"

print(temp.upper())

결과 

HELLO WORLD

lower 함수

temp = "HELLO WORLD"

temp.lower()

결과

hello world

join 함수 (해당 함수와 같이 split 함수에 대해서는 따로 작성) 해당함수에 대해서 는 이해를 돕다 보니

작성할 내용이 많아져서 해당에 대해 따로 작성 하도록 함 

lstrip(왼쪽 공백 지우기)

rstrip(오른쪽 공백 지우기)

strip(양쪽 공백 지우기)

replace(바뀌게 될 문자열, 바꿀 문자열) 문자열을 바꿈

오해하지 말아야 할 부분은

temp ="Hello World Start to Start"
print(temp.replace("Start","End"))
print(temp);

결과는

Hello World End to End

Hello World Start to Start

가 나오게 된다. 변환을 하기는 하지만 파이썬에서는 immutable 에 대해서 절대로 까먹지 말아야 한다.

temp를 Hello World Start to Start로 선언을 했을시에 절대로 이 값에 대해서는 변화가 이루어지지 않는다.

문자열 (string)문자,단어 등으로 구성된 집합 !!

"Hello world"

"a"

"123"

1. 큰따옴표

"Hello world"

2. 작은 따옴표

'Hello world'

3. 큰따옴표 3개

"""Hello World"""

4. 작은따옴표 3개

'''Hello World'''

출력결과로

Apple's favorite fruit 를 보고 싶을때

fruit = "Apple's favorite fruit"  와 같이 " 로 묶어 주어야 한다. 

해당을

fruit = 'Apple's favorite fruit' 라고 했을시  Syntax Error 가 발생한다.

    food = 'Apple's favorite fruit'

                  ^

SyntaxError: invalid syntax

Apple"s favorite fruit 를 보고 싶을 때는 반대로

fruit = 'Apple"s favorite fruit' 로   ' 로 묶어 주어야 한다. 

\(백슬래시)를 이용해서 작은 따옴표와 큰따옴표도 인식이 가능 

\" 를 입력하게 되면 \앞에 "는 문자열을 묶는것이 아닌 자체로 인식

\' 도 마찬가지 

back =" \" Apple is very good \" he said."
print("food ",back)

결과

food   " Apple is very good " he said.

!!!!! 여러 줄 처리하기 

Apple is Good

Good is Apple

fruit = "Apple is good \n Good is Apple"

print(fruit)

' \n' 코드가 핵심  하지만 가독성이 매우 떨어지기 때문에 다른방법을 사용해야 한다.

"""문자열""" 로 묶어서 사용

fruit = "Apple is good \n Good is Apple"
multi = """Apple is good
Good is Apple
"""
print(fruit)
print(multi)

결과

Apple is good 

 Good is Apple

Apple is good

Good is Apple

물론 ''' 문자열''' 로 작은따옴표도 사용이 가능하다.

***** 파이썬 이스케이프 코드

\n     문자열 안에서 줄을 바꿀 때 사용

\t        문자열 사이에 탭 간격을 줄 때 사용

\\        문자\을 그대로 표현할 때 사용

\'            작은따옴표(')를 그대로 표현

\"            큰따옴표(")를 그대로 표현

\r            캐리지 리턴(줄바꿈후 현재 커서를 가장 앞으로 이동)

\f            폼 피드(줄바꿈 후 현재 커서를 다음 줄로 이동)

\a            벨 소리(출력시 PC스피커에서 삑소리)

\b            백 스페이스

\000         널 문자

&&&& 문자열 연산 

1. 문자열 더해서 연결 

start = "Start is "
End = "End "

print(start+End)

결과

Start is End

2. 문자열 곱셈

Start ="Product String\t"

print(Start*2)

결과

Product String Product String

곱셈 (2)

sp = "*"


print(sp*60)
print(sp*26,"Start",sp*26)
print(sp*60)

결과

************************************************************

************************** Start **************************

************************************************************

>>> 문자열 인덱싱과 슬라이싱 

1. 인덱싱

문자열 꺼내기 (1)

Index ="Apple is Very good"


print(Index[6],Index[7],Index[8],Index[0],Index[1],Index[2],Index[3])

결과

i s   A p p l

인덱싱은 0부터 시작된다. 

문자열 꺼내기 (2)

Index ="Apple is Very good"


print(Index[-6],Index[-7],Index[-8],Index[-0],Index[-1],Index[-2],Index[-3])

print(Index[-0])

결과

y r e A d o o

A

-1 은 맨뒤에 첫번 째 숫자 부터 가리키게 된다. 

0 과 -0은 같은 숫자이기 때문에 0은 -0으로 표시하여도 첫번째 숫자가 표시됨을 확인 할수 있다. 

2. 슬라이싱

slice ="Apple is Very Good"
print(slice[0:6])

결과

Apple

slice의 0~5까지의 문자열을 하나씩 꺼내서 출력 한다. 

주의할점 : ************* slice[0:6] 의 뜻은 slice 의 0<=slice <6으로 해석이 되기때문에 0~ 5까지의 문자열이 출력된다. 오해하면 안된다.

꼭 시작점과 끝점을 표시안해도 상관은 없다.

slice[4:] 으로 표시시 시작번호부터 끝까지 출력 한다. 4~끝까지 출력 

slice[:7] 시에는 0~7까지 출력

slice의 예

#  테스트 파이썬

a="20160725HotSummer"
date=a[:8]
weather =a[8:]
print("date is ",date)
print("weather ",weather)

결과

date is  20160725

weather  HotSummer

1번째 줄 a[:8] 이면 0~7까지  0 <= a < 8 로 표현이 되기때문에 0 ~ 7까지의 문자열들이 보여지게 된다.

2번째 줄 a[8:] 이게 되면  8< = a < ~ 이기 때문에 8부터 끝 문자열까지 모두 표현 을 해준다.

문자열의 값들을 인덱싱을 이용하여서 꺼낼순 있지만 문자열의 요소값은 바꿀수 있는 값이 아니다.

문자열,튜플 등의 자료값은 변경이 불가능하다 (immutable한 자료형이라고도 한다. )

 C++에 mutable 이라는키워드가있는데 클래스 변수가 mutable int m_int;로 선언시

void show() const

{

// const으로 되어있기 때문에 변경이 불가능하지만 mutable변수에 대해서는 변경이 가능

}

mutable 선언은 멤버 변수의 조작이 가능한 변수로 선언을 하겠다는 의미를 가지고있는데

많이 사용하는것을 보지못했지만 이 의미와 상반되는 의미의 immutable 한 자료형이라고 하는거같다.

기본적인 연산자가 있는데 순서대로 확인해본다.

1. ** 연산자 

a=3
b=4
a**b
# 3 * 3 * 3* 3    9 27 81 
print(a**b)

결과

81 

3**4 가되어서 3을 4번 곱하는 형식이 된다. x의 y제곱을 나타낸다. 

2. % 연산자

print("print 7%3 " ,7%3)

print("print 3%7 ", 3%7)

결과

print 7%3  1

print 3%7  3

%연산자는 나머지 값을 반환 한다. 

7을 3으로 나눴을시에 몫이 2 이고 나머지가 1이기 때문에 결과는 1이 된다. 

3을 7로 나눴을시에는 몫이 0이고 나머지가 3이 기때문에 결과는 3이 된다.

3. / 연산자 

7/4

결과

1.75

7나누기 4를 하고 결과는 1.75

4. // 연산자 

7//4

결과

1

나눗셈 결과에 대한 몫의 소수점을 버리는 연산자 

기본 중의 기본 으로 숫자형으로 볼수 있다.

C,C++에서는

int, short, long, unsigned int , double 등 엄청 많고

JAVA 에서는 동일하지만 Wrapper클래스라고

Integer등등 존재한다.  파이썬에서는 딱히 자료형에 대한 선언은 하지않고 들어가는 방식이다.

기본적인 숫자형 테이블에 대해 보면

정수 : 123, -345, 0

실수 123.45, -1234.5, 3.4e10

복소수 1+2j, -3j

8진수 0o(알파벳o 혹은 O)12 0O12 0o12

16진수 0x1A,0xFF

1. 정수형 

정수형이란 양의정수와 음의 정수 와 숫자 0을 대입하는 것을 말한다.

a = 1 

a = -1

a = 0 

2. 실수형

실수형이란 소수점이  포함된 숫자를 말한다.

a= 1.2

a = -1.2

a= 4.24E10

a = 42.4e-10

4.24E10 = 4.24*10(10승)

4.24e-10은 = 4.24*10(-10승)

3. 8진수와 16진수

8진수(Octal) 숫자 0O 혹은 0o(숫자 0 + 알파벳 o 대문자 혹은 소문자 )

16진수(Hexadecimal) 0x로 시작하면된다.

복소수 : a = 1+2j

***** 복소수의 경우에는 내장함수가 있다. 

a = 1+2j

a.real = 실수 부분을 리턴 한다.

a.imag 는 허수 부분을 리턴 한다. 

a.conjugate() 는 켤레 복소수를 리턴 한다.

abs(복소수) 복소수의 절댓값을 리턴 

print(a)
print("a.real function")
print("a.real",a.real)
print("a.imag function")
print("a.imag",a.imag)
print("a.conjugate function")
print("a.conjugate",a.conjugate())
print("a.abs function")
print("a.abs",abs(a))

결과 

(1+2j)
a.real function
a.real 1.0
a.imag function
a.imag 2.0
a.conjugate function
a.conjugate (1-2j)
a.abs function
a.abs 2.23606797749979

**** 파이썬 2.7에서 3/4를 사용시

0.75가 아닌 0이 출력된다.  파이썬 2x에서는 정수형/ 정수형 시에는 정수형이 리턴된다. 

파이썬을 사용하기 위한 에디터로는 아직 아무것도 모르는 초창기이기에 만인이 사용하는 것을 사용하도록 한다.

파이참이다.

파이참의 다운로드 주소는

http://www.jetbrains.com/pycharm/download/ 에서 다운로드 받도록 한다.

일단 필자는 Community Edition 버전으로 받았다.  Pro버전은 30일 트라이얼 버전이고  여러가지 프레임워크를 지원하며 기능이 많겠지만 아직은 필요가 없다고 느껴지기 때문이다.

설치시에 나오는 .py 체크  *.py 에 대한 자동으로 pycharm 으로 연결하겠다는 조건이며 체크 해줘도 되고 안해도 된다. 

keymap scheme : visual studio 

IDE theme: Darcula

Editor colors and fonts : Darcula 

이게 제일 맘에 든다. 

처음 실행하게 되면  Location 지정하는게 나오는데 이클립스와 조금 비슷한 개념으로 설정되는거같다. 저같은 경우는

Desktop\Python 으로 지정하고 실행

실행하고 나서 해당 프로젝트에 python 파일을 만들어야 파이썬 코딩을 할 수 있다.

그리고 작성해본다.  헬로우 월드

# hello world.py

print("Hello world")

하고 저장하게되면

Desktop\Python\.idea\에 hello.py 가 생성된다.

cmd창을 킨후에 해당 경로로 이동해서 python hello.py 를 입력하게 되면 해당 파이썬이 실행된다.

실행결과 확인 이로써 기본 에디터 준비까지 마쳤다.

아 파이참은 IDE이기 때문에 파이참에서도 실행 할수 있다.

Alt + Shift + F10 으로 Run 할수 있다. 

파이썬에 대한 이야기는 너무 많은 자료들이 있어서 그냥 생략 하도록 한다.

어차피 이걸 보거나 들어오게 되는 사람은 파이썬에 대한 생각을 가지고 올테니 그냥 시작하면 될거 같다.

나 또한 지금 파이썬을 처음 켜보았다. 

그리고 현재부터 작성되는 글은 모두 윈도우에서 작업 합니다. 

우선 파이썬을 다운로드 해보자 http://www.python.org/downloads 에서 윈도우용 파이썬을 다운로드 할수 있다.

들어가게되면

좌측에 3.x 버전과 우측에 2.x 버전이 있는데 마음에 드는걸로 하면 된다.

* 2.x 프로그램은 3.x에서 지원되지 않는점 잊지 말아야 한다. 

설치파일 실행시 Install Now 로 실행하면 된다. (이걸 쓰는 순간은 이미 설치가되어있어서 이미지 생략)

그리고 밑 부분에 Add_Python 3.5 to PATH 를 체크 해주고 설치한다.

설치가 완료 되었다면 시작 - 모든 프로그램 - Python3.5 폴더가 생성된다.

해당 보이시는 파일에 Python 3.5 (32-bit)을 클릭해서 실행하면 된다 저같은 경우는 마우스 우클릭 보내기-> 바탕화면 보내기로  바로가기를 만들어서 사용 중

Python3.5 (32 -bit)을 키고 간단한 실습 정도를 해보자

>>> 는 프롬프트(prompt)라고 한다. 

일단 종료는 Ctrl +Z  -> Enter 를 치게 되면 종료가 된다.

또한 >>> 옆에다가 

>>> import sys

>>> sys.exit() 하고 엔터를 처도 종료가 된다.

기초 연산 

>>> 1 + 2 

3

>>> 5/3

1.66666~7

변수 선언도 역시

>>>a=1

>>>b=2

>>>a+b 

3

신기한점 복소수도 된다.

a =5+9j

b = 3

a *b

(15+27j) 가 출력이 된다.

if 문의 경우에 특이한점을 보았다.

>>>a=3

>>>if a>1:

. . . print("a is greater than 1")   (if a>1: 하고 엔터를 치게되면 자동적으로 옆에 ... 이 생기게 되는데 

이 상태에서 바로 print("a is grater than 1") 이라고 입력하게 되면

IndentationError : expected an indented block 이라는 에러가 발생한다. (들여쓰기를 해주지 않아서이다.)

스페이스바를 4번 넣고나서 print~ 를 입력하게 되면

한번더 ... 이 생기게 된다.

... 이 있다는 것은 아직 문장이 끝나지 않았음을 의미한다.

이상태에서 엔터를 한번더 치게되면

a is greater than 1 이라는 결과가 나타난다.

반복문 for 

4의 스페이스바로 공백을 넣어 주어야 한다.  혹은 Tab키를 이용 

반복문 while

함수 def

gugu 함수 

def gugu(a,b):

i=0

while i<b:

i=i+1

print(a*i)

a숫자의 b단까지 출력

gugu(3,7) 3의 7단까지 출력