Step2_변수(Variable), 자료형(Data type)

[변수(Variable)]

- 프로그램에서 사용하기 위한 특정한 값을 저장하는 공간을 의미한다.

- 선언되는 순간 메모리 특정영역에 공간이 할당된다.

- 변수에는 값이 할당되고 해당 값은 메모리에 저장되는 구조이다.

 

* 컴퓨터의 구조 - 폰 노이만 아키텍쳐 

폰 노이만 아키텍쳐에서는 사용자가 컴퓨터에 값을 입력하거나 프로그램을 실행할 경우 그 정보를 먼저 메모리에 저장시키고 CPU가 순차적으로 그 값을 해석하고 계산하여 사용자에게 결과값을 전달한다.

 

a) 변수 표기법 

- 알파벳, 숫자, underbar로 선언이 가능하다.

     ex) data = 0, _a12 =2, _egg = 'afdf' 등

- 변수명은 의미있는 단어로 표기하는게 좋다.

     ex) engineer_name = 'emilia'

- 변수명은 대소문자가 구분된다.

     ex) ABC = 2, aBC = 3 → ABC =! aBC

- 예약어는 쓰지 않는다.

     ex) for, if, else 등 

 

 

 

 

---

[변수의 연산]

변수들끼리 사칙연산과 문자열처리가 가능하다.

 

a) 기본 자료형 

- 정수형(integer) : 양/음의 정수 

- 실수형(float) : 소수점이 포함된 숫자 

- 문자형(string) : 따옴표에 들어가 있는 문자형

- 논리/불린 자료형(boolean) : 참 또는 거짓

 

* type(변수) : 데이터의 타입을 tuple 값으로 반환해준다. (tuple은 아래에 정리되어 있음. 변할 수 없는 값을 주로 저장) 

*dynamic typing 이기 때문에 데이터 타입을 굳이 써주지 않아도 값만 보고 바로 데이터 타입을 결정해준다.

#####기본자료형 연습#####

a = 1.5		#integer
b = 1		#float
c = 'ABC'	#string
d = True	#boolean

print(type(a))
print(type(b))
print(type(c))
print(type(d))

 

 

b) 연산자와 피연산자

- + ,- ,* , / 과 같은 기호들을 '연산자' 라고 한다.

- 연산자에 의해 계산되는 숫자들을 '피연산자' 라고 한다.

- 연산의 순서도 수학과 같다.

- 문자간의 덧셈도 가능하다. (단어를 연결하는 것) 

 

* ' ** ' : 제곱승을 계한사는 연산자 

* '%' : 나머지를 구하는 연산자 

* '+=' : 증가연산자 ( '-=' 는 감소연산, 좌변은 할당받는 변수, 우변에는 기존 변수) 

#####연산자와 피연산자 연습#####

#제곱승
print(3**5) 	#243

#나누기/나머지/몫
print(7/2)		#3.5
print(7%2)		#1
print(7//2)		#3

#증가연산
a = 1		
a += 1
print(a) 		#2

#감소연산
a = 1
a -= 1
print(a)		#0

 

 

c) 데이터의 형변환 (정수형 ↔ 실수형) 

- float() 와 int() 함수를 사용해서 정수형과 실수형 간의 데이터 형변환이 가능하다.

- 함수이기 때문에 변환만해서 배출해 줄 뿐! 

- 다시 재할당을 해줘야지 변환값이 변수로써 저장이 되는 것이다.

 

- 실수형에서 정수형으로의 변환은 '내림' 처리 된다.

- 실수형끼리의 연산은 정수형을 만들 수 없다.

- 정수형끼리의 연산은 실수형을 만들 수 있다.

#####데이터의 형변환(정수형 <> 실수형) 연습#####

#정수형 -> 실수형
a = 10 
print(10)
float(a) 
print(type(a)) # 출력 : <class 'int'> , float()는 함수이기 때문에 배출만.
a = float(a) #재할당
print(type(a)) # 출력 : <class 'float'>


#실수형 -> 정수형
a = 1.2 
print(int(a)) # 출력 : 1 , 실수형에서 정수형으로의 변환은 '내림'

#실수형끼리의 연산은 정수형을 만들 수 없다.
a = 10.7
b = 10.3
print(a+b) # 출력 : 21.0 (실수형) 

#정수형끼리의 연산은 실수형을 만들 수 있다.
a = 3 
b = 2 
print(a/b) # 출력 : 1.5 (실수형)

 

d) 데이터의 형변환 (숫자형 ↔ 문자열)

- 문자열에서 선언된 값도 int(), float() 함수로 형변환이 가능하다.

- 똑같이 이들은 함수이기 때문에 변환만해서 배출해 줄 뿐!

- 다시 재할당을 해줘야지 변환값이 변수로써 저장이 된다.

 

- 문자열끼리의 연산이 가능하다.

- 피연산자들끼리 타입이 같아야 한다.

#####데이터의 형변환(숫자형<>문자형) 연습#####

#문자형>숫자형
a = "76.3"
b = float(a) 
print(type(a))	#출력 : <class 'str'>
print(type(b))	#출력 : <class 'float'>
print(a + b) #피연산자들의 타입이 다르므로 연산 불가.


#숫자형>문자형
a = float("76.3")
b = a
str(a) + str(b) #string끼리의 덧셈이 가능하다.

*컴퓨터의 반올림오차 : 

컴퓨터의 모든 값은 이진수로 변환되어 메모리에 저장된다.

단순한 실수도 이진수로 변환하면 무한소수가 된다.

반올림오차는 충분히 작아서 반올림한다고 일반적으로 문제가 되진 않는다.

 

 

 

 

 

 

 

---

[자료형(Data type)] 

- 특징이 있는 정보는 그에 따른 자료형이 필요하다.

- 검색, 저장 등의 작업에서 효율을 고려하여 메모리 사용량과 실행시간 등을 최소화한다.

- 파이썬에서는 list, stack, queue, tuple, set, dictionary 등의 기본 데이터 구조를 제공한다.

 

a) 리스트(List) 

- 리스트는 시퀀스 자료형으로 여러 데이터들의 집합이다.

- 선언시 [] 활용

- 여러 데이터를 한 번에 처리할 때 편리하다

- int, float와 같은 다양한 데이터 타입을 포함시킬 수 있다.

- 리스트 안에 리스트가 들어갈 수 있다.

 

*len(변수) : 리스트의 길이를 반환해준다.

 

 

너어어무 많은 리스트의 특성들! 

이 특성들이 다른 자료형들에서도 많이 사용이 되기 때문에 정리를 하고 넘어가자면! 

 

• 인덱싱(Indexing)

          - 리스트에 있는 값들은 '주소(offset)' 를 가진다.

          - 주소를 사용해 할당된 값을 호출하는 것을 '인덱싱(Indexing)' 이라고 한다.

 

#####인덱싱 연습##### 
colors = ['red','blue','green'] #리스트 선언
print(colors[0]) 	# 출력 : 'red'
print(len(colors)) 	# 출력 : 3

 

• 슬라이싱(Slicing) 

          - 인덱싱을 기준으로 데이터를 잘라 쓰는 것을 '슬라이싱(Slicing)' 이라고 한다. 

          - 주소값을 기반으로 부분값을 반환하는 것이다.

 

*list[a:b] : a 부터 b-1까지를 의미. 다음에 b부터 시작하도록 코드를 짤 수 있기 때문에 이렇게 한다고 함,, 흠,,

*list[a:b:c] : a - 시작점, b - 끝 바로 전, c - step

*list[:음수] : 맨 끝지점부터 카운트 

#####슬라이싱 예제#####

cities = ["서울","부산","인천","대구","대전"]

print(cities[0:2]) 		#출력 : ['서울','부산','인천'], [a:b] : a부터 b-1까지
print(cities[:]) 		#전체 출력
print(cities[-50:50]) 		#전체 출력
print(cities[ : :2])		#step 2 로 0부터 출력 
print(cities[ : : -1]) 		#거꾸로 뒤집힘

 

• 리스트의 연산

          - 리스트 값끼리 연산이 가능하다.

          -  특정 인덱스 자리에 있는 값을 재할당 해주면 값이 변환이 된다.

          -  데이터가 있는 지 없는 지 '데이터 in 리스트이름' 형태로 확인 가능하다.

#####리스트연산 연습##### 

#리스트 덧셈 
color1 = ['red','blue','green']
color2 = ['orange','black','white']
print(color1 + color2) 	
# 출력 : ['red','blue','green','orange','black','white'],  리스트 그냥 이어 붙임

#리스트 값 변환
color[0] = 'yellow' 	# 해당 인덱스 자리에 값 변환 
print(color*2) 		# 리스트 2회 반복 

#리스트 데이터 확인
'blue' in color2 	# 출력 : False , 해당 리스트에 값이 있는지 bool형 값 반환

 

• 추가 와 삭제

          - append() : 데이터 1개 추가/ list.append(data) 

          - extend() : 다른 리스트의 데이터들을 추가, 데이터 1개 이상이 든 리스트/ list1.extend(list2)

          - insert() :  index 자리에 데이터(or 리스트 자체)를 추가/ list.insert(index, data)

          - remove() : 데이터를 삭제/ list.remove(data) 

          - del() : 데이터를 삭제 or 리스트를 아예 삭제/ del list[index]

#####리스트 추가와 삭제 연습##### 

#append - list.append(data)
color.append('white')
color.append('white','black') 	# 에러발생

#extend - list1.extend(list2)
color.extend(['black','purple'])

#insert - list.insert(index, data) 
color.insert(0,'orange')
color.insert(0,['white','black']

#remove - list.remove(data) 
color.remove('white') 

#del - del list[index]
del color[0]
del color 		# 변수를 아예 삭제

 

• 패킹(Packing) 과 언패킹(Unpacking) 

          - 패킹(Packing) : 한 변수에 여러 개의 데이터를 넣는 것을 의미한다.

          - 언패킹(Unpacking) : 한 변수의 데이터를 각각의 변수로 반환한다.

#####패킹과 언패킹 연습#####

t =[1,2,3]	# packing
a,b,c = t 	# uppacking	

print(a)	# 출력 : 1
print(b)	# 출력 : 2
print(c)	# 출력 : 3

 

• 이차원 리스트(2-dimensional list) 

          - 리스트 안에 리스트를 만들면 '행렬(matrix)' 가 생성이 된다. 

          - 2차원이 아니더라도 3차원, 4차원 등 multi-dimensional list 생성 가능하다.

*다차원에서의 인덱싱 : 

2차원 - list[a][b] : (a,b)에 해당하는 데이터 출력.

3차원 - list[a][b][c] : (a,b,c)에 해당하는 데이터 출력.

#####이차원 리스트 연습#####
kor_score = [12,35,21,15,30]
math_score = [52,54,25,23,58]
midterm_score =[kor_score, math_score] 	# 2X5 matrix 생성

print(midterm_score) 		# matrix전체 출력
print(midterm_score[0][2]) 	# 출력 : 21, (0,2)원소 출력

 

 

 

 

 

b) 스택(Stack) 

- 나중에 넣은 데이터를 먼저 반환하도록 설계된 메모리 구조 

- Last In First Out(LIFO)

- 데이터의 입력을 push, 출력을 pop 이라 한다.

- push는 append() 함수를, pop는 pop() 함수를 활용한다.

- 리스트를 사용하여 스택 구조를 활용한다.

 

#####스택 연습#####

a = [1,2,3,4,5] # 리스트와 똑같이 선언

#Last In First Out
a.append(10) 	# 출력 : [1,2,3,4,5,10], 맨 마지막에 삽입
a.pop() 	# 출력 : 5, 마지막 값을 return 해주면서 제거

#####추가#####

word_list = list('eunjeong')
# 출력 : ['e','u','n','j','e','o','n','g']

for _ in range(len(word_list)): 
	print(word_list.pop())
	print(word_list) 

# 뒤에 값 return 하고 삭제되면서 
# 리스트 값 줄여나가진다.
# for 문 '_' 는 일종의 convention, 의미없는 변수를 받을 때

 

 

 

 

c) 큐(Queue)

- 먼저 넣은 데이터를 먼저 반환하도록 설계된 메모리 구조

- First In First Out(FIFO)

- 스택과 조금 다른 개념 

- 데이터의 입력을 put, 출력을 get 이라 한다.

- put 은 append() 함수를 , get 은 pop(0) 함수를 활용한다.

- 리스트를 사용하여 큐 구조를 활용한다.

 

#####큐 연습#####

a = [1,2,3,4,5]	 #리스트와 똑같이 선언

#First In First Out
a.append(10) 	# 출력 : [1,2,3,4,5,10]
a.pop(0)		# 출력 : [2,3,4,5,10]
print(a)

 

 

 

d) 튜플(Tuple) 

- 값 변경이 불가능한 리스트를 의미한다.

- 프로그램이 작동하는 동안 변경되지 않는 데이터의 저장으로 가능하다.

- 선언시 () 활용 

- 리스트의 연산, 인덱싱, 슬라이싱 모두 사용 가능하다.

- 하지만, 덧셈(+) 과 반복(*) 만 가능하다.

 

#####튜플 연습#####

t= (1,2,3)	#리스트와 다른 선언 방식

#튜플 연산 
print(t+t) 	#출력 : (1,2,3,1,2,3) , 덧셈연산 +
print(t*2) 	#출력 : (1,2,3,1,2,3) , 반복연산 *

tuple1 = (1,2,3) 
tuple2 = (3,4,5)
tuple1 - tuple2 	#에러발생, 뺄셈불가


#튜플 인덱싱
t = (1,2,3)
t[1] 	# 출력 : 2


#튜플 슬라이싱 
t[1:3] 	# 출력 (2, 3)

#####추가#####

t = (1)
print(type(t)) 	# 출력 : <class 'int'>, 일반 정수로 인식 

t = (1,) 
print(type(t)) 	# 출력 : <class 'tuple'>, 값이 하나인 튜플로 인식

 

 

e) 집합(Set) 

- 값을 순서없이 저장하는데 중복이 불허하는 자료형이다.

- 선언시 set() 활용

- 출력시 {} 활용

- 수학에서의 집합의 성질(교집합,합집합,여집합,차집합) 이용 가능하다.

 

*set.add(data) : set에 데이터 1개 추가 

*set.remove(data) : set에 데이터 1개 삭제 , 해당 데이터 없으면 에러 발생 

*set.update(list) : set에 새로운 리스트 값들(최소 한 개의 데이터) 업데이트

*set.discard(data) : set에 데이터 1개 삭제 , 해당 데이터 없어도 통과

#####집합(set) 연습#####

s = set([1,2,3,1,2,3]) 	#선언시 set(리스트) 형태 
print(s) 		# 출력 : {1,2,3}, 반복 값 제거 및 {}중괄호 형태로 반환

#set 데이터 추가 - s.add(data) 
s.add(1)
print(s) # 출력 : {1,2,3}

#set 리스트 업데이트 - s.update(list) 
s.update([3,5,7,4,2])
print(s) 	# 출력 : {1,2,3,4,5,7}

#set 데이터 삭제 - s.remove(data) , s.discard(data) 
s.remove(10)	#에러발생ㅇ, 해당 데이터 없으면 에러 
s.discard(10) 	#에러발생x, 해당 데이터 없어도 유지

#set 모든 원소 삭제 - s.clear() 
s.clear()

 

*set1.union(set2) : 합집합

*set1|set2 : 합집합(or연산)

*set1.intersection(set2) : 교집합

*set1&set2 : 교집합(and연산) 

*set1.difference(set2) : 차집합 

*set1-set2 : 차집합

*(set1|set2)-(set1&set2) : 교집합의 여집합 

#####집합의 연산 연습#####

s1 = set([1,2,3])
s2 = set([3,4,5,6])

#합집합
s1.union(s2) # 출력 : {1,2,3,4,5,6}
s1|s2 		# 출력 : {1,2,3,4,5,6}

#교집합
s1.intersection(s2) 	# 출력 : {4, 6}
s1&s2 #출력 : {4, 6}

#차집합
s1.difference(s2) 	# 출력 : {1,2}
s1-s2 	# 출력 : {1,2}

#교집합의 여집합
(s1|s2)-(s1&s2)		# 출력 : {1, 2, 4, 5, 6}

 

 

 

f) 사전(Dictionary) 

- 데이터를 저장할 때는 구분 지을 수 있는 값과 함께 저장하는 자료형이다.

- 구분을 위한 데이터 고유의 값을 'key'

- key 값을 활용하여 관리되는 데이터를 'value'

- 선언시 {} 활용 

- key로 value 탐색이 가능하다. key는 value를 대표한다! 

- 다른 언어에서 'hash table' 이라는 용어를 사용한다.

 

*dict[key] = value 

*dict.items() : 딕셔너리의 모든 key와 value 반환 - dict_items([key: value])

*dict.keys() : 딕셔너리의 모든 key 반환 - dict_keys([keys])

*dict.values() : 딕셔너리의 모든 value 반환 - dict_values([values])

#####사전(dict) 연습#####

student_info = {1:'blog', 2:'study', 3:'emilia'}
type(student_info) 	# 출력 : dict

#key 와 value 추가
student_info[4] = 'python'
student_info 	# 출력 : {1: 'blog', 2: 'study', 3: 'emilia', 4: 'python'}

#key에 해당하는 value 변경 
student_info[1] = 'coding'
studnet_info 	# 출력 : {1: 'coding', 2: 'study', 3: 'emilia', 4: 'python'}

#모든 key와 value 반환
student_info.items()
# 출력 : dict_items([(1, 'coding'), (2, 'study'), (3, 'emilia'), (4, 'python')])

#모든 key 반환	
student_info.keys() 	# 출력 : dict_keys([1, 2, 3, 4])

#모든 value 반환 
student_info.values() 	# 출력 : dict_values(['coding', 'study', 'emilia', 'python'])

#####추가#####

#모든 items 반환
for k,v  in student_info.items(): 
  print(k,v) 		
  
#모든 value 반환
for key in student_info.keys(): 
  print(student_info[key])		
  
#데이터 존재 확인
'emilia' in student_info.values() 	# 출력 : True

 

길고 길었던 자료형 정리도 끝! 

다음은 파이썬에서 매우매우 중요한 함수 정리로!