variable

변수명 짓기

• variable: num_of_college_graduates: snake case
  - 전부 소문자이고 띄워쓰기에 under bar('_')
• method: numOfCollageGraduates: camel case
  - 첫 시작 소문자, 띄워쓰기 없고 구분은 대문자 시작
• class: NumOfCollageGraduates: Pascal case
  - 첫 시작 대문자, 띄워쓰기 없고 구분은 대문자 시작

Object

Object reference

1. class로 부터 타입에 맞는 오브젝트(객체) 생성
2. 값 생성
3. 콘솔 출력

print(300)
1. 내부적으로 타입에 맞는 class 오브젝트(객체) 생성
2. 오브젝트(객체)에 값 대입

n = 777
1. 내부적으로 타입에 맞는 class 오브젝트(객체) 생성
2. 오브젝트(객체)에 값 대입

id(identity): 객체의 고유값

• id(identity): 오브젝트(객체)의 고유 값
  • id( )에 넣어서 오브젝트(객체)의 고유 값을 알 수 있다.

is, is not

• ==, != 는 주어진 값의 비교
• is, is not은 객체 비교

n = 700
m = n

print(m == n)		# True, m과 n은 같은 700 값 가짐
print(m is n)		# True, m과 n은 같은 ID인 인스턴스임
print(m is not n)	# False

n = 900

print(m == n)		# False, m과 n은 각각 서로 다른 값 가짐
print(m is n)		# False, m과 n은 서로 다른 인스턴스임
print(m is not n)	# True

Copy

=

mutable의 =

• list는 Python의 대표적 mutable인데, 이 list 객체에 =를 통해 copy하면 Call-by-refernce
  • 즉 C 포인터처럼 사용된다.
  • 메모리 용량을 아끼고, 원본의 변경이 가능하다.
    • 하.지.만! copied list 객체를 수정하면 원본도 수정된다는 뜻이다.

origin_list=[ 1,2,3,4,5,6,7 ]
copy_list = origin_list
print(id(origin_list)) # 4310534464
print(id(copy_list))   # 4310534464

• Call-by-refernce의 장점은 메모리 사용 최소화할 수 있다.
  • C 처럼 설명을 하면..
  1. origin_list (int*) -> [ 1, 2, 3, 4, 5]
  2. copy_list = origin_list 시,
     진짜 value를 저장하기 위한 공간은 $int * 5Byte$

• Call-by-Value의 는 메모리 2배 쓴다. 하지만 copy 객체 따로 독립성을 유지할 수 있다.
  • C를 예로 들면
  1. origin_list (int*) -> [ 1, 2, 3, 4, 5]
  2. copy_list = origin_list 시, (만약 Call-by-Value Copy라면)
     진짜 value를 저장하기 위한 공간은 $(int * 5) *2Byte$

• 재귀 함수에서도 결국 하나만 본다.
  • 

• copy_list[3] 같이 element에 접근에 수정하면 원본도 같이 바뀐다.
  • 

• 이는 같은 mutable 객체는 똑.같.은 현상!!

• 물론 또다른 list를 =하면 또 가리키는게 바뀐다.

origin=[1,2,3,4,5]
copy_list=origin
new_list=[5,4,3,2,1]
copy_list=new_list

immutable의 =

• Python에서 <str>은 대표적인 immutable이다.

str1="Hello"
str1[0]="h"
----> Error Occured!

• 이러한 immutable 인 str을 =를 통해 copy하면 1차적으로는 같은 ptr(id)를 가진다.
  

• 이러한 immutable 객체도 똑같이 또다른 것을 =로 하면, 가리키는게 바뀐다.

shallow copy

• list의 slicing을 사용 하면, shallow copy !!!
• 그림으로 이해하는 것이 편하다.
  • b=a[:] 로 대입, a, b는 서로 다른 id를 가진다.
  • 하지만, 각 element는 같은 id를 가진다.
    • 그래도, b[0]=5 와같은 대입이 a[0]에 영향을 미치지 못한다.

• 그러나!! element가 list (mutable) 이라면!!!!!!
  • 
  1. b[0]=5 은 a[0]에게 영향을 주지 않지만
     
  2. b[0].append(5)는 애초에 b[0]와 a[0]가 같은 id를 가져서, a[0]에게 영향을 준다.
     

dict.copy() 메서드

• dict의 shallow copy: https://velog.io/@markyang92/python-Tuple-Dictionary-Set#dictcopy---shallow-copy

deep copy

• 모두 call by value 다.

import copy

a=[1,2,3,4,5]
b=copy.deepcopy(a)

print(b)

• deepcopy 를 사용 시, b[0]의 활동은 이제 a[0]와 완전 별개이다.
  

다중 논리 연산

• 흔히하는 실수
  • Python 에서 다중 논리 연산자는 in, not in 을 사용 할것!!!

if A[i] == 'b' or 'c' <-- (x)

1. if (A[i] == 'b') or (A[i] == 'c')

2. if A[i] in ['b', 'c']


not 사용 시

1. if not ((A[i] == 'b') or (A[i] == 'c'))

2. if A[i] not in ['b', 'c']

3. if not (A[i] in ['b', 'c'])

• 참고로 in도 순차로 탐색하기 때문에 시간이 많이 걸린다.

bit 연산

• bit 연산 출처: https://dojang.io/mod/page/view.php?id=2460

bit 연산자

• OR: |
• AND: &
• XOR: ^
• NOT: ~

print(3 | 6) 
#  |0011
#  |0110
# -------
# 0|0111 = 7
# ==== 출력 ==== #
7

10 -> 2

• bin(10진수) 사용

bit=bin(13)
print(bit)
print(type(bit))
# ==== 출력 ==== #
0b1101
<class 'str'>

2 -> 10

• 기본적으로 다른 진법으로 변환한 것은 'str'

int(0b1001, 2) # int형으로 바꾸되, base가 2진수이다.

bit=bin(13) # bit='0b1101'
print( int(bit, 2) ) 
# ==== 출력 ==== #
13

10 -> 16

• hex( 10진수 ) 사용

16 -> 10

• int( 16진수, 16 )

2진수 직접 사용

• 0b, -0b 사용

print( 0b1001)	# 9
print(-0b1001)	# -9
print(~0b1001)	# -10

print(0b1001 & 0b11)

# 1001 = 9
# 0011 = 3
# --------
# 0001 = 1

# ==== 출력 ==== #
1

X + Y = X | Y 검출기

• X가 주어 질 때, X+Y = X|Y가 되는 수식의 y 를 찾기
  
  • X ^ 1111 나온 결과 값에서, 0인 부분은 무조건 0을 'y'의 비트에 넣어야한다.
  • X ^ 1111 나온 결과 값에서, 1인 부분은 Don't Care로 'y'의 비트에 넣을 수 있다.
  • 오른쪽 부터 채우면 y의 값을 오름차순으로 구할 수 있다.

shift 연산

• 13<<1: 13을 '왼쪽'으로 1bit shift
  • 
• 13>>1: 13을 '오른쪽'으로 1bit shift
  • 

bit 만들기

• 0b11111을 만들고 싶다면, 이므로 $2^5-1$

print(bin(2**5-1))

# ========= 출력 ========= #

0b11111

bit 몇 개 필요?

• 5는 bit 몇 개가 있어야 표현할 수 있을 까?
  • $5<2^3$
  • $8<2^4$