3. 수치 자료형과 연산자¶

01 수치 자료형¶

1-1 정수형 상수¶

In [1]:

a = 23      # 10진 정수
b = 023     # 8진 정수
c = 0x23    # 16진 정수
print type(a), type(b), type(c)
print a, b, c

<type 'int'> <type 'int'> <type 'int'>
23 19 35

In [8]:

import sys
sys.maxint  # 최대 정수 값 확인

Out[8]:

9223372036854775807

1-2 실수형 상수¶

In [2]:

a = 1.2
b = 3.5e3
c = -0.2e-4
print type(a), type(b), type(c)
print a, b, c

<type 'float'> <type 'float'> <type 'float'>
1.2 3500.0 -2e-05

In [11]:

e, f, g = 3.14, 2.16e-9, 3E220
print e, f, g

3.14 2.16e-09 3e+220

1-3 롱형 상수¶

메모리가 허용하는 한 유효자리수는 무한대

In [2]:

h1 = 123456789012345678901234567890L    # 마지막에 L을 붙여서 명시적으로 long 형이라고 알려도 되고
print type(h1)
print h1 * h1
print

h2 = 123456789012345678901234567890     # L을 붙이지 않아도 int형이 담을 수 있는 수치를 초과하면 자동으로 long형이 된다.    
print type(h2)
print h2 * h2
print

h3 = 123L
print type(h3)
print

h4 = 123
print type(h4)

<type 'long'>
15241578753238836750495351562536198787501905199875019052100

<type 'long'>
15241578753238836750495351562536198787501905199875019052100

<type 'long'>

<type 'int'>

In [14]:

octal = 01234L   # 8진법 long형
print octal
octal

Out[14]:

668L

In [18]:

hexa = 0x123456789L   # 16진법 long형
hexa

Out[18]:

4886718345L

In [15]:

123456789012345678890  # 자동 long형 변환

Out[15]:

123456789012345678890L

In [16]:

2 ** 3 ** 4    # print 없이 출력할 때에는 L를 함께 표기함

Out[16]:

2417851639229258349412352L

In [22]:

print 2 ** 3 ** 4   # print와 함께 출력할 때에는 L 표기 하지 않음

2417851639229258349412352

1-4 복소수형 상수¶

생략

1-5 Decimal 자료형¶

컴퓨터의 부동소수점 (Floating point)에 의한 실수 표현은 매우 미미한 오차를 동반함
그러한 오차를 최대한 줄이고 최대한 정확한 결과 값을 얻어내기 위해 사용할 수 있는 모듈 -> decimal 모듈
다음 두 개의 클래스를 제공
- Decimal: 숫자 자체를 표현
- Context: 정확도나 반올림 방법 등과 같은 환경 설정

In [20]:

1.1

Out[20]:

1.1

정수 리터럴로 부터 정수 Decimal 객체 생성

In [3]:

from decimal import *
Decimal(1234)

Out[3]:

Decimal('1234')

문자 리터럴로 부터 정수 Decimal 객체 생성

In [4]:

Decimal('1234')

Out[4]:

Decimal('1234')

실수 리터럴로 부터 실수 Decimal 객체 생성
- 이전 python 버전에서는 에러 발생
- 최근 python 버전에서는 에러 발생하지 않지만 추천하지 않음
  - 이유: 이미 실수 리터럴 자체가 오차를 포함하고 있기 때문

In [47]:

from decimal import *
Decimal(1.1)

Out[47]:

Decimal('1.100000000000000088817841970012523233890533447265625')

문자열 리터럴로 부터 실수 Decimal 객체 생성

In [37]:

Decimal('1.1')

Out[37]:

Decimal('1.1')

In [28]:

from decimal import *
Decimal('Infinity')  # 양의 무한대 표현

Out[28]:

Decimal('Infinity')

In [29]:

Decimal('-Infinity') # 음의 무한대 표현

Out[29]:

Decimal('-Infinity')

In [30]:

Decimal("NaN")  # Not a number 표현   

Out[30]:

Decimal('NaN')

Decimal 활용의 좋은 예

In [41]:

e = 0.0                   # 기본 자료형인 float형 변수 e 생성 및 0.0 값으로 초기화
for k in range(10000):    # 0부터 9999 까지 만번 반복
    e += 0.0001           # 0.0001을 누적  
    
print e                   # print로는 1.0이 출력됨

1.0

In [36]:

e                         # 하지만, 실제 저장되어 있는 값에는 오차 존재

Out[36]:

0.9999999999999062

In [5]:

from decimal import *
e2 = Decimal('0.0')        # 기본 자료형인 float형 변수 e 생성 및 0.0 값으로 초기화
delta = Decimal('0.0001') # 누적하려고 하는 0.0001 값을 Decimal 객체인 delta 변수로 생성

for k in range(10000):    # 0부터 9999 까지 만번 반복
    e2 += delta            # delta를 누적  
    
print e2                   # print로는 1.0이 출력됨

1.0000

In [6]:

e2                         # 실제 저장되어 있는 것은 오차 없이 1.0 값을 지닌 Decimal 객체

Out[6]:

Decimal('1.0000')

a = Decimal('35.72') b = Decimal('1.73')

print a + b print a - b print a * b print a / b

최근 python 버전에서는 실수에 대한 지수승 지원 (decimal이 아니어도 실수에 대한 지수승 가능)

In [45]:

print a ** 2
a ** b

1275.9184

Out[45]:

Decimal('485.8887109649886451686600498')

Decimal 타입과 기본 정수형에 대한 사칙연산 지원

In [48]:

a = Decimal("1.2")

print a + 2
print 2 + a

3.2
3.2

Decimal 타입과 기본 실수형에 대한 사칙연산은 에러 발생

In [49]:

a = Decimal("1.2")
a + 1.5

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-49-fc666f5507a3> in <module>()
      1 a = Decimal("1.2")
----> 2 a + 1.5

TypeError: unsupported operand type(s) for +: 'Decimal' and 'float'

In [52]:

import math, cmath

d = Decimal('123.456789012345')

print math.sqrt(d)
print cmath.sqrt(-d)

print d.sqrt()            # Decimal 객체 자체가 sqrt() 함수 지니고 있음
print d.quantize(Decimal('.01'), rounding = ROUND_DOWN)  # 해당 자리수 미만 내림 (제거)

11.1111110611
11.1111110611j
11.11111106111108044305541755
123.45

튜플 리터럴로 Decimal 객체 생성
- 다음과 같은 인자 3개 필요
  - 부호: 0 - 양수, 1 - 음수
  - 값
  - 소수점의 위치

In [57]:

a1 = Decimal((1, (1, 4, 7, 5), 0))
a2 = Decimal((1, (1, 4, 7, 5), -1))
a3 = Decimal((1, (1, 4, 7, 5), -2))
a4 = Decimal((1, (1, 4, 7, 5), -3))

print a1
print a2
print a3
print a4
print

b1 = Decimal((0, (1, 4, 7, 5), 0))
b2 = Decimal((0, (1, 4, 7, 5), -1))
b3 = Decimal((0, (1, 4, 7, 5), -2))
b4 = Decimal((0, (1, 4, 7, 5), -3))

print b1
print b2
print b3
print b4

In [26]:

getcontext()

Out[26]:

Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999999, Emax=999999999, capitals=1, flags=[Inexact, Rounded], traps=[DivisionByZero, Overflow, InvalidOperation])

In [35]:

Decimal(1) / Decimal(7)

Out[35]:

Decimal('0.1428571428571428571428571429')

In [29]:

getcontext().prec = 9
Decimal(1) / Decimal(7)

Out[29]:

Decimal('0.142857143')

In [30]:

ExtendedContext

Out[30]:

Context(prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999999, Emax=999999999, capitals=1, flags=[], traps=[])

In [31]:

BasicContext

Out[31]:

Context(prec=9, rounding=ROUND_HALF_UP, Emin=-999999999, Emax=999999999, capitals=1, flags=[], traps=[Clamped, DivisionByZero, Underflow, Overflow, InvalidOperation])

In [32]:

DefaultContext

Out[32]:

Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999999, Emax=999999999, capitals=1, flags=[], traps=[DivisionByZero, Overflow, InvalidOperation])

In [60]:

setcontext(ExtendedContext)
Decimal(1)/ Decimal(7)

Out[60]:

Decimal('0.142857143')

In [34]:

setcontext(DefaultContext)
Decimal(1)/ Decimal(7)

Out[34]:

Decimal('0.1428571428571428571428571429')

ROUND_HALF_UP vs. ROUND_HALF_EVEN
- ROUND_HALF_UP:
  - 2.44 -> 2.4
  - *2.45 -> 2.5*
  - 2.46 -> 2.5
  - ...
  - 2.54 -> 2.5
  - *2.55 -> 2.6*
  - 2.56 -> 2.6
- ROUND_HALF_EVEN은 거리가 같은 경우에 마지막의 숫자가 짝수를 유지하도록 함
- ROUND_HALF_EVEN:
  - 2.44 -> 2.4
  - *2.45 -> 2.4*
  - 2.46 -> 2.5
  - ...
  - 2.54 -> 2.5
  - *2.55 -> 2.6*
  - 2.56 -> 2.6
Rounding에 대한 참고자료
- https://docs.python.org/2/library/decimal.html#context-objects
- http://www-01.ibm.com/support/knowledgecenter/SSEPGG_9.7.0/com.ibm.db2.luw.admin.config.doc/doc/r0052298.html?cp=SSEPGG_9.7.0%2F2-2-6-7-29&lang=ko

02 파이썬 연산자¶

2-1 산술 연산자¶

연산자	우선순위	설명	결합순서
+, -	1	단항 연산자	-
**	2	지수 연산자	왼쪽 <- 오른쪽
*,/,%,//	3	곱하기,나누기,나머지,몫	왼쪽 -> 오른쪽
+, -	4	더하기,빼기	왼쪽 -> 오른쪽

In [38]:

print 2 ** 3
print 2 ** 3 ** 2
print (2 ** 3) ** 2
print 5 % 2
print -5 % 2

In [39]:

5 ** -2.0

Out[39]:

0.04

In [63]:

print 3+5
print 3+5.0  # 정수 + 실수의 결과는 실수

8
8.0

In [64]:

print 5 / 2.0   # 정수 / 실수의 결과는 실수
print 5 / 2

2.5
2

In [44]:

a = 5 / 3
b = 5 % 3

print a, b

print divmod(5,3)

1 2
(1, 2)

In [45]:

print 5 % 3
print 5 % -3
print -5 % 3
print -5 % -3

2
-1
1
-2

In [46]:

print 5 / 3
print 5 / -3
print -5 / 3
print -5 / -3

1
-2
-2
1

In [47]:

print 3 // 4
print 3.0 // 4.0
print -3 // 4
print -3 // 4.0    

0
0.0
-1
-1.0

In [48]:

print 3 / 4
print 3.0 / 4.0
print -3 / 4
print -3 / 4.0    

0
0.75
-1
-0.75

In [66]:

print -7/4     #단항 연산자(-)의 우선순위가 이항 연산자(/)의 우선순위보다 높다 (-7을 4로 나눈다).
print -(7/4)   #7/4의 결과에 단항 연산을 수행함

-2
-1

In [49]:

4 * -5

Out[49]:

-20

In [51]:

print 2 + 3 * 4
print (2 + 3) * 4

14
20

In [52]:

print ++3
print --3
print -+3
print +-3

3
3
-3
-3

In [53]:

print 4 / 2 * 2

In [54]:

print 2 ** 3 ** 4     # ** 연산자의 결합순서는 오른쪽에서 왼쪽으로!
print (2 ** 3) ** 4

2417851639229258349412352
4096

2-2 관계 연산자¶

객체가 지닌 값의 크기(대소)를 비교함

In [57]:

print 6 == 9
print 6 != 9
print 1 > 3
print 4 <= 5

a = 5
b = 10
print a < b

False
True
False
True
True

In [58]:

0 < a < b

Out[58]:

True

In [59]:

0 < a and a < b

Out[59]:

True

In [68]:

print 'abcd' > 'abd'             # 문자열, 튜플, 리스트의 관계 연산 비교는 일반 사전 순서. 사전에서 앞에 나오는 값이 작은 값으로 평가됨
print (1, 2, 4) < (2, 1, 0)     
print [1, 3, 2] == [1, 2, 3]

False
True
False

서로 다른 자료형간의 크기 관계
- 숫자 < 사전 < 리스트 < 문자열 < 튜플

In [64]:

print 9999999999999999999999L < 'abc'
print {3:2} < [1,2,3] < (1,2,3)

True
True

In [68]:

L = [1,2,3, 'abc', 'a', 'z', (1,2,3), [1,2,3], {1:2}, ['abc']]
L.sort()
L

Out[68]:

[1, 2, 3, {1: 2}, [1, 2, 3], ['abc'], 'a', 'abc', 'z', (1, 2, 3)]

In [3]:

x = [1,2,3]
y = [1,2,3]
z = y

print x == y
print x == z
print x is y
print x is z
print y is z

True
True
False
False
True

In [2]:

Y[1] = 100
print X
print Y
print Z

[1, 2, 3]
[1, 100, 3]
[1, 100, 3]

2-3 논리 연산자 (or 부울 연산자)¶

피연산자의 값으로 진리값인 True 또는 False을 취하여 논리 적인 계산을 수행하는 연산자
- and
- or
- not
논리 연산자 자체가 값을 반환하지는 않는다.
논리 연산을 따라 최종적으로 평가(Evaluation)되어진 값이 반환된다.

In [73]:

a = 20
b = 30

a > 10 and b < 50

Out[73]:

True

진리값에 해당하는 True와 False는 다른 사칙연산자를 만나면 다음과 같이 평가됨
- True: 1
- False: 0

In [77]:

print True + 1
print False + 1
print False * 75
print True * 75

bool() 내장 함수를 이용해서 수치 값을 진리 값으로 교환 가능

In [82]:

print bool(0) # 정수 0은 거짓
print bool(1)
print bool(100)
print bool(-100)
print
print bool(0.0) # 실수 0.0은 거짓
print bool(0.1)

False
True
True
True

False
True

값이 없는 빈 객체나 None 객체는 False로 평가됨

In [81]:

print bool('abc')
print bool('')
print
print bool([]) # 공 리스트는 거짓
print bool([1,2,3])
print 
print bool(()) # 공 튜플은 거짓
print bool((1,2,3))
print 
print bool({}) # 공 사전은 거짓
print bool({1:2})
print
print bool(None) # None 객체는 거짓

True
False

False
True

False
True

False
True

False

In [85]:

print 1 and 1
print 1 and 0
print 0 or 0 
print 1 or 0
print 
print [] or 1 # [] 거짓
print [] or () # [], () 거짓
print [] and 1 # [] 거짓이므로 1은 참조할 필요 없음

1
0
0
1

1
()
[]

In [86]:

print 1 and 2 
print 1 or 2
print 
print [[]] or 1        # [[]] 참으로 간주
print [{}] or 1        # [)] 참으로 간주
print '' or 1          # 빈 문자열('')은 거짓

2
1

[[]]
[{}]
1

In [3]:

print not(True)
print not(1 and 2)
print not('' or 1)

False
False
False

2-4 비트 단위 연산자¶

비트 단위 조작 지원
비트 단위 연산자
~ : 비트 반전 (보수)
<<: 왼쪽으로 비트 이동
>>: 오른쪽으로 비트 이동
& : 비트 단위 AND
^ : 비트 단위 XOR
| : 비트 단위 OR

참고: 음수의 표현 (2의 보수 표현법)¶

음수는 leading one 으로 시작함 (양수는 leading zero)
만약 정수가 8비트로 이루진다면 "0000 0000"에서 "0111 1111" 숫자는 0에서 127을 나타냄
만약 정수가 8비트로 이루진다면 "1000 0000"에서 "1111 1111" 숫자는 -128에서 -1을 나타냄
- *[약속] 음수인 -x는 (x - 1)에 대한 1의 보수로 표현 (2의 보수 표현법)*
  - -x = 1's complement of (x - 1)
- -1 = (1 - 1)에 대한 1의 보수 = 0에 대한 1의 보수 = "0000 0000"에 대한 1의 보수 = "1111 1111"
- -10 = (10 - 1)에 대한 1의 보수 = 9에 대한 1의 보수 = "0000 1001"에 대한 1의 보수 = "1111 0110"
- -128 = (128 - 1)에 대한 1의 보수 = 127에 대한 1의 보수 = "0111 1111"에 대한 1의 보수 = "1000 0000"
- "1111 1010" = "0000 0101"에 대한 1의 보수 = 5에 대한 1의 보수 = (6 - 1)에 대한 1의 보수 = -6
- "1111 1110" = "0000 0001"에 대한 1의 보수 = 1에 대한 1의 보수 = (2 - 1)에 대한 1의 보수 = -2
참고
- http://www.ecogwiki.com/2%EC%9D%98_%EB%B3%B4%EC%88%98%EB%B2%95%EC%9C%BC%EB%A1%9C_%EC%9D%8C%EC%88%98_%ED%91%9C%ED%98%84%ED%95%98%EA%B8%B0
- http://multithread.tistory.com/entry/%EC%A0%95%EC%88%98%EC%9D%98-2%EC%9D%98%EB%B3%B4%EC%88%98-%ED%91%9C%ED%98%84

In [4]:

print ~5     #"0000 0101" -> "1111 1010"
print ~-1    #"1111 1111" -> "0000 0000"
print ~-128  #"1000 0000" -> "0111 1111"

-6
0
127

In [5]:

a = 3            # "0000 0011"
print a << 2     # "0000 1100", 오른쪽에는 0으로 채워짐 (a * 2 ** 2 와 동일)
print 1 << 128   # 롱형으로 자동변환 (1 * 2 ** 128 과 동일)

12
340282366920938463463374607431768211456

In [13]:

a = 4            # "0000 0100"
print a >> 1     # "0000 0010", 왼쪽에도 0으로 채워짐

a = -4           # "1111 1100"  
print a >> 1     # "1111 1110", 음수의 경우 왼쪽에는 1로 채워짐

2
-2

In [6]:

a = 3
print a & 2 #0000 0011 bit_and 0000 0010
print a | 8 #0000 0011 bit_or 0000 1000
print 0x0f ^ 0x06 #0000 1111 exclusive_or 0000 0110

2
11
9

2-5 연산자 우선 순위 표¶

교재 137페이지
참고: https://wikidocs.net/1165

03 파이썬 수치 연산 함수¶

3-1 내장 수치 연산 함수¶

In [105]:

print abs(-3)
print int(3.141592)
print int(-3.1415)
print long(3)
print float(5)
print complex(3.4, 5)
print complex(6)

3
3
-3
3
5.0
(3.4+5j)
(6+0j)

In [1]:

print divmod(5, 2)
print
print pow (2, 3)
print pow(2.3, 3.5)

(2, 1)

8
18.4521691056

3-2 math 모듈의 수치 연산 함수¶

In [109]:

import math

print math.pi
print math.e
print math.sin(1.0) # 1.0 라디안에 대한 사인 값
print math.sqrt(2) # 제곱근

3.14159265359
2.71828182846
0.841470984808
1.41421356237

In [111]:

r = 5.0 # 반지름
a = math.pi * r * r # 면적

degree = 60.0
rad = math.pi * degree / 180.0 # 각도를 라디안으로 변환
print math.sin(rad), math.cos(rad), math.tan(rad) #sin, cos, tan

0.866025403784 0.5 1.73205080757

In [113]:

import math
print math.pi
print math.sin(0.1)

3.14159265359
0.0998334166468