기루 기룩 기록

## 변수 선언 부분
money = 0

## main 부분
money = int(input("교환할 돈은 얼마?"))

c50000 = money // 50000
money %= 50000 # 50000으로 나눈 나머지

c10000 = money // 10000
money %= 10000 # 10000으로 나눈 나머지

c5000 = money // 5000
money %= 5000 # 5000으로 나눈 나머지

c1000 = money // 1000
money %= 1000 # 1000으로 나눈 나머지

c500 = money // 500
money %= 500 # 500으로 나눈 나머지

c100 = money // 100
money %= 100 # 100으로 나눈 나머지

print('\n오만원\t==> %d 개'%c50000)
print('만원\t==> %d 개'%c10000)
print('오천원\t==> %d 개'%c5000)
print('천원\t==> %d 개'%c1000)
print('오백원\t==> %d 개'%c500)
print('백원\t==> %d 개'%c100)
print('잔돈\t==> %d 원'%money)

거듭 제곱

파이썬에서의 거듭 제곱은 a ** b 의 형태로 작성합니다.

ex)

10 ** 10 = 10 ^ 10 입니다

코드를 통해 확인해 보도록 하겠습니다.

a = 10**10 # 거듭 제곱
print(a) # int의 크기 제한이 없어 아주 큰 수를 사용 가능

진수 표현 방식

16진수 = 0x**

8진수 = 0o**

2진수 = 0b**

a = 0xFF # 16진수 표현 방법 0x, 0X
print(a)

b = 0o77 # 8진수 표현 방법 0o, 0O(알파벳 오)
print(b)

c = 0b1111 #2진수 표현 방법 0b, 0B
print(c)

A(숫자)e5는 A(숫자) * 10^5 를 의미합니다.

a = 3.14
b = 3.14e5 # 3.14 * 10^5를 의미한다
print(a, b)

파이썬에서의 나머지와 몫을 구하는 방법

- a%b : a를 b로 나눈 나머지

- a//2 : a를 b로 나눈 몫

a, b = 9, 2
print(a ** b, a%b, a//2) # **: 제곱, %: 나머지, //: 몫

boolean 타입

선언

- a = True

- b = False

타입 확인하기

print(type(a))

a = True # boolean 타입
print(type(a))

a = (100 == 100) # boolean 타입
b = (10>100)
print(a, b)
print(type(a))

문자열

선언

- a = "파이썬 만세"

- b = '파이썬 만세'

- c = "프로그래밍 언어 '파이썬' 만세" # "안에 '를 넣게되면 문자로 처리된다. 반대의 경우도 마찬가지.

- d = """<-이것을

사용하면

여러줄을

저장할 수 있다"""

a = "파이썬 만세"
a
print(a)
print(type(a))

a = """이것은
파이썬"""

print(a)

sel = int(input("입력진수 결정(16/10/8/2):"))

num = input("값 입력:")

if sel ==16:

  num10 = int(num, 16) # 16진수 값을 10진수로 변환

if sel == 10:

  num10 = int(num, 10) # 10진수 값을 10진수

if sel == 8:

  num10 = int(num,8) # 8진수 값을 10진수로 변환

if sel == 2:

  num10 = int(num,2) # 2진수 값을 10진수로 변환



print("16 진수 ==>", hex(num10)) # 10진수를 16진수로 변환

print("10 진수 ==>", (num10))

print("8 진수 ==>", oct(num10)) # 10진수를 8진수로 변환

print("2 진수 ==>", bin(num10)) # 10진수를 2진수로 변환

tkinter 라이브러리

# 그림판 프로그램1

from tkinter import * 

## 변수 

window = None 
canvas = None 

# 함수 
x1, y1, x2, y2 = None,None,None,None 

def mouseClick(event): 
    global x1, y1, x2, y2 
    x1 = event.x 
    y1 = event.y 

def mouseDrop(event): 
    global x2, y2 
    x2 = event.x 
    y2 = event.y 
    canvas.create_line(x1,y1,x2,y2, width = 5, fill = "red") 

# 메인 코드 
window = Tk() 
window.title("그림판 비슷한 프로그램") 

canvas = Canvas(window, height = 300, width = 300) 
canvas.bind("<Button=1>", mouseClick)  # 마우스 버튼을 클릭하는 이벤트
canvas.bind("<ButtonRelease-1>", mouseDrop) # 마우스를 드롭하는 이벤트


canvas.pack() 
window.mainloop() 

# 그림판 프로그램 2

from tkinter import *

## 변수

window = None
canvas = None

# 함수
x1, y1, = None,None

def mouseMove(event):
    global x1, y1
    x1 = event.x
    y1 = event.y
    canvas.create_line(x1,y1, x1+1, y1+1, width=5, fill = "blue")
    
# 메인 코드
window = Tk()
window.title("그림판2")

canvas = Canvas(window, height = 300, width = 300)
canvas.bind("<B1-Motion>", mouseMove)


canvas.pack()
window.mainloop()

sort(): 행렬을 정렬

- np.sort(): 정렬된 행렬을 반환

- ndarray.sort(): 행렬을 정렬 inplace

argsort(): 정렬된 행렬의 인덱스를 반환

test = np.array([3, 1, 9, 5])
print('원본 행렬:', test)

# np.sort()로 정렬
sort_test1 = np.sort(test)
print('np.sort() 결과: ', sort_test1)
print('np.sort() 수행 후 원본', test)

# ndarray.sort()로 정렬
sort_test2 = test.sort()
print('ndarray.sort() 결과: ', sort_test2)
print('ndarray.sort() 수행 후 원본', test)

# 내림차순 정렬
sort_test3 = np.sort(test)[::-1]
print('내림차순으로 정렬: ', sort_test3)

# argsort()로 정렬
sort_test4 = np.argsort(test)
print(sort_test4)

2차원 행렬의 정렬

- 작성예정

1. 특정한 데이터만 추출

  원하는 위치의 인덱스 값을 지정하면 해당 위치의 데이터가 반환된다.

# 1에서 부터 9 까지의 1차원 ndarray 생성 
array1 = np.arange(start=1, stop=10)
print('array1:',array1)
# index는 0 부터 시작하므로 array1[2]는 3번째 index 위치의 데이터 값을 의미
value = array1[2]
print('value:',value)
print(type(value))

2. 슬라이싱(Slicing)

  슬라이싱은 연속된 인덱스상의 ndarray를 추출하는 방식

array1 = np.arange(start=1, stop=10)
array3 = array1[0:3]
print(array3)
print(type(array3))

array1d = np.arange(start=1, stop=10)
array2d = array1d.reshape(3,3)
print('array2d:\n',array2d)

# ':' 기호 앞에 시작 인덱스를 생략하면 자동으로 맨 처음 인덱스인 0으로 간주
# ':' 기호 뒤에 종료 인덱스를 생략하면 자동으로 맨 마지막 인덱스로 간주
# ':' 기호 앞/뒤에 시작/종료 인덱스를 생략하면 자동으로 처음/맨 마지막 인덱스로 간주
print('array2d[0:2, 0:2] \n', array2d[0:2, 0:2])
print('array2d[1:3, 0:3] \n', array2d[1:3, 0:3])
print('array2d[1:3, :] \n', array2d[1:3, :])
print('array2d[:, :] \n', array2d[:, :])
print('array2d[:2, 1:] \n', array2d[:2, 1:])
print('array2d[:2, 0] \n', array2d[:2, 0])

3. 팬시 인덱싱(Fancy Indexing)

  일정한 인덱싱 집합을 리스트 또는 ndarray 형태로 지정해 해당 위치에 있는 데이터의 ndarray를 반환된다.

array1d = np.arange(start=1, stop=10)
array2d = array1d.reshape(3,3)
print("array2d => \n",array2d)


arraytt = array2d[[0,1],]
print("array2d[[0,1]] => \n",arraytt.tolist())

array3 = array2d[[0,1], 2]
print('array2d[[0,1], 2] => ',array3.tolist())


array4 = array2d[[0,1], 0:2]
print('array2d[[0,1], 0:2] =>\n',array4)

array5 = array2d[[0,1]]
print('array2d[[0,1]] => ',array5.tolist())
"""
"""
[[1,2],[4,5]]

4. 불린 인덱싱(Boolean Indexing)

  특정 조건에 해당하는지 여부인 True/False 값 인덱싱 집합을 기반으로 True 에 해당하는 인덱스 위치에 있는

  데이터의 ndarray를 반환한다.

array1d = np.arange(start=1, stop=10)
# [ ] 안에 array1d > 5 Boolean indexing을 적용 
array3 = array1d[array1d > 5]
print('array1d > 5 불린 인덱싱 결과 값 :', array3)

ㅇ