파이썬 (2) 강의노트 (조건문, 입출력, 클래스, 인스턴스, 메써드) (수정)

1
조건문(if)
2021-2 파이썬과머신러닝 이 대엽
2
if
 If 조건문
조건
정의
콜론
if <expr>:
<statement>
들여쓰기
 <expr>은 bool 컨텍스트(context)로 평가되는 표현식

 <statement>는 들여 쓰기가 필요한 유효한 Python 문
 <expr>이 true이면 ( "truthy"값으로 평가) <statement>가 실행
 <expr>이 false이면 <statement>를 건너 뛰고 실행하지 않음
 <expr> 뒤에 콜론 (:)이 필요
※ 일부 프로그래밍 언어에서는 <expr>을 괄호로 묶어야하지만
Python은 그렇지 않음
3
Python 조건문
 예제
>>> x = 0
>>> y = 5
>>> if x < y: # True >>> if x or y: # True

... print('yes') ... print('yes')
... ...
yes yes
>>> if y < x: # False >>> if x and y: # False
... ...
>>> if x: # False >>> if 'aul' in 'grault': # True

... ...
>>> if y: # True yes
... print('yes') >>> if 'quux' in ['foo', 'bar', 'baz']:
... # False
yes ... print('yes')
...
4
if
 그룹화 문 : 들여 쓰기 및 블록
 Python : 들여 쓰기에 관한 모든 것
 Python은 영국의 컴퓨터 과학자 Peter J. Landin이 만든 용어인
off-side rule이라는 규칙을 따름
 들여 쓰기는 복합 문이나 블록을 정의하는 데 사용
 Python 프로그램에서 동일한 수준으로 들여 쓰기된 연속 문은
동일한 블록의 일부로 간주
if <expr>:  일치하는 들여 쓰기 수준 (2 ~ 5 행)의 모든

<statement> 문은 동일한 블록의 일부로 간주
<statement>  <expr>이 참이면 전체 블록이 실행
...  <expr>이 거짓이면 건너 뜀
<statement>  어느 쪽이든 실행은 나중에
<following_statement> <following_statement> (6 행)으로 진행
5
if
 If 조건문
복합 if 문
 블록의 끝을 나타내는 토큰이 없음

 블록의 끝은 블록 자체의 행보다 적게 들여 쓰기된 행으로 표시
if 'foo' in ['bar', 'baz', 'qux']:

print('Expression was true')
print('Executing statement in suite')
print('...')
print('Done.')
print('After conditional') After conditional
6
if
 예제
# Does line execute? Yes No
# --- --
if 'foo' in ['foo', 'bar', 'baz']: # x
print('Outer condition is true') # x
if 10 > 20: # x
print('Inner condition 1') # x
print('Between inner conditions') # x
if 10 < 20: # x
print('Inner condition 2') # x
print('End of outer condition') # x

print('After outer condition') # x
Outer condition is true

Between inner conditions
Inner condition 2
End of outer condition
After outer condition
7
if
 else 및 elif 조항
 경우에 따라 조건을 평가하고 참이면 하나의 경로를 사용하고 그렇지
않으면 대체 경로를 지정else 절로 수행
if <expr>:
<statement(s)>
else:
<statement(s)>
 <expr>이 true이면 첫 번째 블록이 실행되고 두 번째 블록은 건너 뜀

 <expr>이 false이면 첫 번째 블록은 건너 뛰고 두 번째 블록을 실행
 어느 쪽이든 실행은 두 번째 블록 이후에 재개
 두 모음 모두 들여 쓰기로 정의
8
Python 조건문
 예제
x = 20
if x < 50:
print('(first suite)')
print('x is small')
else:
print('(second suite)')
print('x is large') (first suite)
x is small
x = 120
if x < 50:
print('(first suite)')
print('x is small')
else:
print('(second suite)')
print('x is large')
(second suite)
x is large
9
if
 분기 실행 구문
 하나 이상의 elif (else if의 줄임말) 절을 사용
 파이썬은 차례로 각 <expr>을 평가하고 참인 첫 번째에 해당하는
모음을 실행
 어떤 식도 참이 아니고 else 절이 지정되어 있으면 그 모음을 실행
if <expr>:
<statement(s)>
elif <expr>:
<statement(s)>
elif <expr>:
<statement(s)>  임의의 수의 elif 절을 지정할 수 있음
...
 else 절은 선택 사항
else:
 존재하는 경우 하나만 있을 수 있으며
<statement(s)>
마지막에 지정해야 함
10
if
name = 'Joe'
if name == 'Fred':
print('Hello Fred')
elif name == 'Xander':
print('Hello Xander')
elif name == 'Joe':
print('Hello Joe')
elif name == 'Arnold':
print('Hello Arnold')
else:
print("I don't know who you are!") Hello Joe
 많아야 지정된 코드 블록 중 하나를 실행

 else 절이 포함되지 않고 모든 조건이 거짓이면 어떤 블록도
실행되지 않음
11
if
 긴 if / elif / else 시리즈를 사용하는 것은 좋지는 않음

 특히 작업이 print ()와 같은 간단한 명령문인 경우 더욱
 많은 경우, 같은 일을 수행하는 더 파이썬적인 방법
 dict.get () 메써드를 사용한 예
names = {
'Fred': 'Hello Fred',
'Xander': 'Hello Xander',
'Joe': 'Hello Joe',
'Arnold': 'Hello Arnold'
}
print(names.get('Joe', "I don't know who you are!"))
Hello Joe
print(names.get('Rick', "I don't know who you are!"))
e!
I don't know who you are!
12
if
 elif 절이있는 if 문은 and 및 or 연산자와 유사한 단락 평가를 사용

 표현식 중 하나가 참인 것으로 확인되고 해당 블록이 실행되면 나
머지 표현식은 테스트되지 않음
if 'a' in 'bar':
print('foo')
elif 1/0:
print("This won't happen")
elif var:
print("This won't either") foo
 두 번째 표현식은 0으로 나누기를 포함하고 세 번째 표현식은

정의되지 않은 변수 var를 참조
 어느 쪽이든 오류가 발생하지만 지정된 첫 번째 조건이 참이
므로 둘 다 평가되지 않음
13
if
 한 줄 if 문
 한 줄에 <expr>을 쓰고 다음 줄에 <statement>를 들여 쓰면 다
음과 같이 쓰는 것이 일반적
if <expr>:
<statement>
 한 줄에 전체 if 문을 작성하는 것을 허용
if <expr>: <statement>
if <expr>: <statement_1>; <statement_2>; ...; <statement_n>
14
if
두가지 해석이 가능 :
(1) <expr>이 true이면 <statement_1>을 실행
 그런 다음 <expr>이 true인지 여부에 관계없이 <statement_2> ... -
<statement_n>을 무조건 실행
(2) <expr>이 true이면 모든 <statement_1> ... <statement_n>을 실행
그렇지 않으면 실행하지 않음
 파이썬은 후자의 해석을 취함
 <statements>를 구분하는 세미콜론은 <expr> 다음에 오는 콜론보
다 우선 순위가 높음
 컴퓨터 용어에서 세미콜론은 콜론보다 더 단단히 묶인다고 간주
 따라서 <statements>는 모음으로 처리되고 모두 실행되거나 모두
실행되지 않음
15
if
if 'f' in 'foo':
print('1')
print('2')
print('3')
1
...2
1
23
if 'z' in 'foo':
print('1')
print('2')
print('3')
16
if
 elif 또는 else 절과 같은 줄에 여러 문을 지정할 수도 있음

x=2
if x == 1: print('foo'); print('bar'); print('baz')
elif x == 2: print('qux'); print('quux')
else:
print('corge'); print('grault')
...
qux
qux
quux
quux
x=3
if x == 1: print('foo'); print('bar'); print('baz')
elif x == 2: print('qux'); print('quux')
else:
print('corge'); print('grault')
...
corge  복잡한 if 문의 경우
grault
grault 가독성이 좋지 않기 때
문에 일반적으로 권장
하지 않음
17
if
x=3
if x == 1:  이 방식이 시각적으로 더 이해하기 쉬움
print('foo')
print('bar')
print('baz')
elif x == 2:
print('qux')
print('quux')
else:
print('corge')
print('grault')
corge
corge
grault
grault
18
Python 조건문
 조건식 (Python의 삼항 연산자)

 Python은 조건식이라는 추가 의사 결정 엔티티(entity)를 지원
 파이썬 문서의 여러 곳에서 조건부 연산자 또는 삼항 연산자라고도 함
<expr1> if <conditional_expr> else <expr2>
 이것은 프로그램 실행의 흐름을 지시하는 제어 구조가 아니기

때문에 위에 나열된 if 문 형식과 다름
 표현식을 정의하는 연산자처럼 작동
 <conditional_expr>을 먼저 평가
 참이면 식은 <expr1>으로 평가
 거짓이면 식은 <expr2>로 평가
 명확하지 않은 순서에 유의
 중간 표현식이 먼저 평가되고 그 결과에 따라 끝에있는 표현식
중 하나가 반환
19
if
raining = False
print("Let's go to the", 'beach' if not raining else 'library')
Let's go to the beach
raining = True
print("Let's go to the", 'beach' if not raining else 'library')
Let's go
Let's go to
to the
the library
library
age = 12
s = 'minor' if age < 21 else 'adult‘
s
'minor'
'minor'
'yes' if ('qux' in ['foo', 'bar', 'baz']) else 'no'

'no‘
'no'
20
if
if a > b:
m=a m = a if a > b else b
else:
m=b
 조건식은 구문 상 표현식처럼 작동
x = y = 40
 더 긴 표현의 일부로 사용 가능
z = 1 + x if x > y else y + 2  조건식은 사실상 다른 모든 연산자보다 우
z 선 순위가 낮으므로 자체적으로 그룹화하

려면 괄호가 필요
42
 + 연산자는 조건식보다 더 밀접하게 바인
z = (1 + x) if x > y else (y + 2) 딩되므로 1 + x 및 y + 2를 먼저 평가
z  그 다음 조건식을 평가
42  두 번째 경우의 괄호는 불필요하며 결과
가 바뀌지 않음
21
if
 조건식을 먼저 평가하려면 그룹화 괄호로 묶어야 함

 (x> y이면 x)가 먼저 평가
 결과는 y (40)이므로 z에 1 + 40 + 2 = 43이 할당
x = y = 40
z = 1 + (x if x > y else y) + 2
z
43
22
if
 더 큰 표현식의 일부로 조건식을 사용하는 경우 필요하지 않더라도 설

명을 위해 그룹화 괄호를 사용하는 것이 좋음
 조건식은 복합 논리식과 같은 단락 평가도 사용
 조건식의 일부는 평가할 필요가 없는 경우 평가되지 않음
 표현식 <expr1> if <conditional_expr> else <expr2> :
 <conditional_expr>이 true이면 <expr1>이 반환되고 <expr2>는 평가
되지 않음
 <conditional_expr>이 false이면 <expr2>가 반환되고 <expr1>은 평가
되지 않음
23
입출력
(화면 입출력)
24
Print()
 모니터 화면에 결과물을 출력 하기 위해서 print() 함수를 사용
print(42) # <class 'int'>

print(3.14) # <class 'float'>
print(1+2j) # <class 'complex'>
print(True) # <class 'bool'>
print([1,2,3]) # <class 'list'>
print((1,2,3)) # <class 'tuple'>
print({'red','green','blue'}) # <class 'set'>
print({'name':'Alice','age':42}) # <class 'dict'>
print('hello') # <class 'str'>
print('Inha University')
print("Inha University")
25
Print()
 예
 문자열 속에 “ 기호가 있는 경우에는 ‘ ‘로(정정)
print('Inha "University"')
 ‘ 기호가 있는 경우에는 “ “를 사용 (정정)

print("Inha 'University'")
 콤마(,)로 문자열을 나열할 경우 공백(기본값)이 자동으로 추가

print('Inha','University')
 더하기(+) 기호로 문자열을 공백없이 연결

print('Inha'+'University')
 긴 문자열은 \ 기호로 사용하여 여러 줄에 작성할 수 있음

print('Inha \
University')
26
Print()
 예
 개행(줄바꿈), 공백, 특수기호(이스케이프 문자)를 포함하여
입력한 그대로 화면에 출력하기 위해서는 ‘’‘ ’‘’ 또는 “”“ ”“” 기호를 사용
print("""Inha
Univeristy""")
print('''Inha
University''')
 데이터형에 따른 프린트 포맷(자리수 맞춤)

i = 2020
f = 3.14
s = 'Inha’ # 오타 수정
print('i: %d, f: %f, s: %s' % (i, f, s)) i: 2020, f: 3.140000, s: Inha
print(' 0123456789 012345 01234567') 0123456789 012345 01234567

print('i: %9d, f: %5.2f, s: %7s' % (i, f, s)) i: 2020, f: 3.14, s: Inha
print(' 012345678 01234 01234567') 012345678 01234 01234567

print('i: %09d, f: %05.2f, s: %07s' % (i, f, s)) i: 000002020, f: 03.14, s: Inha
27
Print()
 예
 데이터형에 따른 프린트 포맷(자리수 맞춤)
i = 2020
f = 3.14
s = 'Inha‘ #오타 수정
print('i: {}, f: {}, s: {}'.format(i, f, s)) i: 2020, f: 3.14, s: Inha
print('{}, {}, {}'.format(i, f, s)) 2020, 3.14, Inha
print('f: {1}, i: {0}, s: {2}'.format(i, f, s)) f: 3.14, i: 2020, s: Inha

print('f: {0}, i: {2}, s: {1}'.format(i, f, s)) f: 2020, i: Inha, s: 3.14
print('f: {ff}, i: {ii}, s: {ss}'.format(ii=i, ff=f, ss=s)) f: 3.14, i: 2020, s: Inha
a = 'Inha'
b = 'University‘
print('a is {0[a]}, b is {0[b]}'.format(locals())) a is Inha, b is University

print('{0[a]}, {0[b]}'.format(locals())) Inha, University
print('a is {a}, b is {b}'.format(**locals())) a is Inha, b is University

print('{a}, {b}'.format(**locals())) Inha, University
28
Print()
 예문자열 객체의 메소드(함수)를 이용하여 출력 모양을 변경
 print('Inha University'.center(20))
Inha University
print('Inha University'.rjust(20)) #오타 수정

Inha University
print('Inha University'.ljust(20))
Inha University
print('Inha University'.zfill(20))
00000Inha University
print('Inha University'.upper())
INHA UNIVERSITY
print('Inha University'.capitalize()) print(list(range(1, 10)))

Inha university [1, 2, 3, 4, 5, 6, 7, 8, 9]
29
입출력
(파일 입출력)
30
파이썬에서 파일 읽고 쓰기
 학습목표
(1) 파일 생성하기
(2) 파일을 쓰기 모드로 열어 내용을 쓰기
(3) 프로그램의 외부에 저장된 파일을 읽는 여러 가지 방법
 readline() 함수 이용하기
 readlines 함수 사용하기
 read 함수 사용하기
 파일에 새로운 내용 추가하기
 with문과 함께 사용하기
 sys 모듈로 매개변수 전달
31
 파일 생성하기
 test.txt 파일을 생성
 파일 객체=open(파일 이름, 파일 열기 모드)
※ test0.txt와 test1.txt의 내용이 같은 것을 확인할 것
f = open("test1.txt", 'w')
f.close()
 파일이 존재할 때는 원래 내용이 지워짐

※ 내용이 있던 ‘test1.txt’ 파일의 내용이 실행후 사라지는 것을 확인할 것
 파일 열기 모드 설명
r 읽기 모드 – 파일을 읽기만 할 때 사용
W 쓰기 모드 _ 파일에 내용을 쓰 때 사용
a 추가 모드 – 내용을 추가할 때 사용
32
 파일을 읽기 모드로 열어 내용을 쓰기

 파일의 내용을 읽어서 화면에 출력
f = open("test0.txt",'r') read_file.ipynb
while True:
line=f.readline()
if not line:break
print(line)
f.close()
33
 readlines 함수를 사용하는 방법
Read_lines_file.ipynb
f = open("c:/users/SPL/test0.txt",'r')
contents=f.readlines()
for line in contents:
print(line)
f.close() contents는 list

 read 함수를 사용하는 방법
f = open("c:/users/SPL/test0.txt",'r') Read_line_file.ipynb
data = f.read()
print(data)
f.close()
Data는 파일 전체 내용
34
 파일에 새로운 내용 추가 하기
 쓰기 모드(‘w’)로 파일을 열면 기존 내용을 사라짐
 추가 모드(‘a’)로 열면 내용의 추가가 가능
f = open("c:/users/SPL/test0.txt", 'a') add_data.ipynb
for i in range(11,15):
data = "%d 번째 줄\n" % i
f.write(data)
f.close()
 With 문과 함께 사용하기
 f = open( ) 대신에 with를 사용하여 파일 사용
with open(test1.txt", "w") as f: with_file.ipynb

f.write("Life is too short, you need python")
35
객체(object), 클래스(class)
인스턴스(instance), 메써드(method)
36
학습 목표
1. Class의 정의
2. Class를 만드는 방법
3. 메서드(method)의 정의
4. object instantiation
5. instance attribute을 만드는 방법
37
참고 - Circular definitions
파이썬은 객체
지향 언어이다
객체는 클래스를
이용하여 데이터 객체는 클래스를
를 인스턴스화 하 인스턴스화 한 것?
는 것이다.
지금까지는 파이썬
언어의 기초적인
내용을 공부
이제는 Object의
이해가 중요
38
Class의 정의
 Python은 객체 지향 프로그래밍 언어
 Python의 거의 모든 것은 속성과 메서드가 있는 객체
 클래스는 객체를 만들기위한 코드 템플릿
 객체에는 멤버 변수가 있으며 연관된 동작(메써드)이 있음
 파이썬에서 클래스는 class 키워드로 생성
 객체는 클래스의 생성자를 사용하여 생성
 객체는 클래스의 ‘instance’로 호출 됨
 인스턴스를 만드는 방법
Instance = class(arguments)
39
Class의 정의
 Class
 객체를 만들기 위한 코드 template(청사진, 틀, 금형)
A class is like a blueprint while an instance is a

copy of the class with actual values.
40
Class의 정의
 클래스는 해당 객체의 청사진

 클래스를 집의 스케치 (시제품)로 생각
 여기에는 바닥, 문, 창문 등에 대한 모든 세부 정보를 포함
 이러한 설명을 바탕으로 집을 건축하는 것이 목적
 따라서 집이 대상
 집의 청사진으로 많은 집을 만들 수 있기 때문에 클래스에서 많은
객체를 만들 수 있음
 객체는 클래스의 인스턴스(instance)
 클래스를 통해서 만든 객체가 인스턴스
 이렇게 개체를 만드는 프로세스가 인스턴스화
41
Python에서 객체(Object)
 Object, Attribute, Fuction
자동차 굴삭기 엔진
객체
(Object)
모양(shape) 출력(power)
속성 토크(torque)
색상(color) 색상(color)
(Attribute) 출력(power)
크기(size) 크기(size)
기능 이동(speed) 굴삭(dig)
(Function 회전(rotation)
/method) 정원(capacity) 적재(load)
객체(Object)=속성(Attribure)+기능(Fuction(Method))
속성(Attribure).기능(Fuction(Method)(실제 구현)
42
 Object, Attribute, Fuction
 객체는 다음으로 구성
 상태(state) : 객체의 속성(특성, property)으로 표현
 행동(behavior) : 객체의 메써드(method)로 표현. 다른 객체와의 반
응을 나타냄
 정체(identity) :
43
 Class, Object, Attribute, Fuction
44
 Object oriented programming(OOP)

 (instance)변수는 메모리의 다른 곳에 있는 객체에 대한 레이블, 포인터
또는 참조
 중요한 점은, 객체와 (instance)변수가 각자 존재

 여러 변수가 동일한 객체를 참조 할 수 있음
45
Object and Instance variable
46
Object and Instance variable
 Object and Instance variable
 객체와 인스턴스 변수를 다른 위치에 저장이 됨
Object
(0x48397a69
70)
name = Name()
Instance
Variable
(0x4839797a
60)
An Object is an
Instance of a Class.
47
속성(attribute)과 메써드(Method)
 클래스와 관련된 기능이 없는 한 클래스 자체는 의미가

없음
 기능은 해당 속성(attribute)과 관련된 데이터 및 함수의
컨테이너(container) 역할을하는 속성을 설정하여 정의
 이러한 기능(function)을 메써드라고 함
 메써드를 클래스에서 정의한 함수라고도 함
 클래스에 "속하는“ 속성이 있으면 클래스 속성에 엑세스
할 함수를 정의 할 수 있음
 이러한 함수를 메써드라고 함
48
 메써드를 정의 할 때 항상 self를 사용하여 메서드에 첫 번

째 인수를 제공해야 함
※ self는 키워드(예약어)가 아니기 때문에 다른 기호를 사용
해도 됨. 그러나 가독성을 높이기 위해서 사용하는 것이
좋음
49
클래스(Class)와 메써드(Method)
50
Class
 Class
 Sonnata와 Grandeur의 공통점은 car
 Car를 운전하는 사람은 driver
 이러한 관계를 class(클래스, 부류)라고 함
ex) apple은 클래스
내가 먹은 것이라고 지정을 하면 instance(실체)
ex)
class Car : # 자동차를 정의

def owner(self) : # 차주 method(메서드)
return “Lee Daeyup"
mycar = Car() # 내 자동차를 만듬
mycar.owner() # 내 자동차를 실행
Lee Daeyup
51
Class 변수와 instance 변수
 Class variable
 클래스 정의에서 메서드 밖에 존재하는 변수를 클래스 변수(class variable)
 이는 해당 클래스를 사용하는 모두에게 공용으로 사용되는 변수
 클래스 변수는 클래스 내외부에서 "클래스명.변수명" 으로 엑세스 가능
 Instance variable
 메서드 안에서 사용되면서 "self.변수명"처럼 사용되는 변수
 하나의 클래스로부터 여러 객체 인스턴스를 생성해서 사용할 수 있음
 클래스 변수가 하나의 클래스에 하나만 존재하는 반면, 인스턴스 변수는 각
객체 인스턴스마다 별도로 존재
 객체별로 서로 다른 값을 갖는 변수
 클래스 내부에서는 self.width 과 같이 "self." 로 사용하여 엑세스하고, 클래스
밖에서는 "객체변수.인스턴스변수"와 같이 엑세스
52
 인스턴스 속성과 init 메써드

 속성(attribute)에 값을 직접 줄 수 있다.
 init 메써드 안에 속성을 정의를 하면 된다.
 다른 object에 대하여 다른 속성을 직접 정의할 수 있다.
 두 변수를 인스턴스화
53
Class의 초기자(생성자)
 Initializer(초기(생성)자)
 클래스로부터 새 객체를 생성할 때마다 실행되는 특별한 메서드
 __init__()
 클래스로부터 객체를 만들 때, 인스턴스 변수를 초기화하거나 객체의 초기
상태를 만들기 위한 문장들을 실행하는 곳
 예제(다음 페이지)를 보면, width와 height라는 입력 파라미터들을 각각
self.width와 self.height라는 인스턴스변수에 할당하여 객체 내에서 계속
사용할 수 있도록 준비
 Class instance의 생성과 사용
 클래스를 사용하기 위해서는 먼저 클래스로부터 인스턴스(객체)를 생성
 인스턴스를 생성하기 위해서는 "객체변수명 = 클래스명()"과 같이 클래스
명을 함수 호출하는 것처럼 사용
 입력 파라미터들이 지정되어 있다면, "클래스명(입력파라미터들)"과 같이
파라미터를 괄호 안에 전달
54
Class의 초기자(생성자)
55
객체 변수와 instance 변수
 클래스로부터 생성된 클래스 인스턴스(객체)로부터 클래스 멤버들을

호출하거나 엑세스
 인스턴스 메써드는 "객체변수.메써드명()"과 같이 호출
 인스턴스 변수는 "객체변수.인스턴스변수" 으로 표현
 클래스 변수를 엑세스할 때, "클래스명.클래스변수명" 혹은 "객체명.클
래스변수명"을 둘 다 허용하기 때문에 혼란스러울 수 있음
 파이썬에서 한 객체의 attribute를 읽을 경우에는 먼저 그 객체에서
attribute를 찾아보고, 없으면 그 객체의 소속 클래스에서 찾고, 다시
없으며 상위 Base 클래스에서 찾고, 그래도 없으면 에러를 발생
 혼돈을 피하기 위해 클래스 변수를 엑세스할 때는 클래스명을 사용하
는 것이 좋음
56
57
58
59
60
Class variable and Instance variable
 Class variable and Instance variable

# Python program to show that the variables with a value
# assigned in class declaration, are class variables
# Class for Mechnical Engineering Student

class Mech_Student:
dept = ‘mech' # Class Variable
def __init__(self,name,roll):
self.name = name # Instance Variable
self.roll = roll # Instance Variable
# Objects of Mech_Student class

a = Mech_Student('Lee', 101)
b = Mech_Student('Kim', 102)
a
<__main__.Mech_Student at 0x6ed3d05748>
b
<__main__.Mech_Student at 0x6ed3d05708>
61
 Object and Instance variable

 변수값과 변수의 메모리 내 위치를 알아야 함
Object
(instance)
Instance
Variable
a = Mech_Student('Lee', 101) 0x6ed3d05
748
b = Mech_Student('Kim', 102)
Object
(instance)
Instance
Variable
An Object is an 0x6ed3d05
Instance of a Class. 708
62
 Class variable and Instance variable

print(a.dept) # prints “mech"
print(b.dept) # prints “mech"
print(a.name) # prints "Lee"
print(b.name) # prints "Kim"
print(a.roll) # prints "101" )
print(b.roll) # prints "201"
# Class variables can be accessed using class

# name also
print(Mech_Student.dept) # prints “mech"
mech 객체변수.클래스변수명
mech 객체변수.클래스변수명
Lee 객체변수.인스탄스변수명
Kim 객체변수.인스탄스변수명
101 객체변수.인스탄스변수명
102 객체변수.인스탄스변수명
mech 클래스명.클래스변수명
63
 Class variable and Instance variable(1/2)

class Dog:
# Class Variable
animal = 'dog'
 인스턴스 변수는 각 인스턴스에 고
# The init method or constructor
def __init__(self, breed, color): 유 한 데이터를 위한 것
 클래스 변수는 클래스의 모든 인스
# Instance Variable
self.breed = breed 턴스가 공유하는 속성 및 메서드를
self.color = color
위한 것
Rodger = Dog("Pug", "brown")  인스턴스 변수는 생성자 또는 메서
Buzo = Dog("Bulldog", "black")
드 내에 self가 있는 값이 변수
 클래스 변수는 값이 클래스에 할당
된 변수
 생성자를 사용하여 인스턴스 변수를
정의한 예
64
 Class variable and Instance variable(2/2)

print('Rodger details:')
print('Rodger is a', Rodger.animal)
print('Breed: ', Rodger.breed)
print('Color: ', Rodger.color)
print('\nBuzo details:')
print('Buzo is a', Rodger.animal)
print('Breed: ', Buzo.breed)
print('Color: ', Buzo.color)
# Class variables can be accessed using class

# name also
print("\nAccessing class variable using class name")
print(Dog.animal)
Rodger details: Buzo details:

Rodger is a dog Buzo is a dog
Breed: Pug Breed: Bulldog
Color: brown Color: black
Accessing class variable using class name dog

65
 절차 지향 프로그래밍과 객체 지향 프로그램 :
PROCEDURAL ORIENTED OBJECT ORIENTED
Function과 같은 부분으로 구성 Object로 구성
위에서 아래로 흐름 밑에서 위로 흐름
Access specifier가 없음 Access specifier(modifier)가 있어 안전
새로운 데이터와 Function의 추가가 쉽지

새로운 데이터와 Function의 추가가 용이
않음
데이터를 감출 수 있는 기능이 없어 안전
데이터를 감출 수 있어 안전
하지 않음
Overloading이 불가능 Overloading이 가능
기능이 데이터보다 중요 테이터가 Function보다 중요
가상적인 세계를 기반으로 구성 실제 세계를 기반으로 구성
C, FORTRAN, Pascal, Basic etc. C++, Java, Python, C# etc.
66
 객체 지향 프로그래밍을 하는 이유
1. 코드의 재사용이 쉽다
 기존에 사용한 틀(class)를 이용하면 속성과 기능만 변경해서 빠르고
쉽게 프로그램을 개발 할 수 있다.
2. 프로그램 관리(유지 보수)가 쉽다
 프로그램의 수정, 삭제와 같은 유지 보수 발생시 코드 변경이
편리하다.
3. 프로그램을 모듈화할 수 있다.
 프로그램을 모듈화할 수 있어 하드웨어 부품처럼 필요에 따라 다른
프로그램에 쉽게 이식할 수 있고 반대로 제거할 수도 있다(객체간의
결합도가 낮음)
4. 데이터의 추상화(abstraction), 상속(inheritance), 다형성(polymorphism),
캡슐화(capsulation)가 가능
67
참고 – 파이썬의 OOP 특성(1/2)
 Access specifier(modifier)(액세스 지정자 또는 수정자)
 상속 개념을 구현하는 동안 클래스 외부의 클래스 변수 및 클래스
메서드에 대한 액세스를 제한하는 데 사용
 Public, Private 및 Protected 키워드로 달성
 Overloading(오버라이딩)
 연산자의 기본 동작을 변경할 수 있고 이것이 "연산자 오버로딩“
 함수가 정의된 방식에 따라 0, 1, 2 또는 여러 매개변수를 사용하여
호출하는 것이 "함수 오버로딩“
 Inheritance(상속)
 부모 클래스에서 모든 기능을 가져오고 더 추가하여 클래스를 정의
하는 것
68
참고 – 파이썬의 OOP 특성(2/2)
 Abstraction(추상화)
 사용자에게 함수의 내부 기능을 숨기는 데 사용
 복잡성을 줄이기 위해 관련 없는 데이터/클래스를 숨기는 데 사용
 Capsulation(캡슐화)
 클래스를 정의할 때 내부의 속성과 메서드를 묶어서 하나의 단위로
처리하는 것
 변수와 메서드에 직접 액세스하는 것이 제한되고 우발적인 데이터
수정의 방지가 가능
 Polymorphism(다형성)
 다른 유형의 동일한 함수 이름을 사용할 수 있게 하는 기능
 프로그래밍을 보다 직관적이고 쉽게 만들기위한 것
69
 Object oriented programming(OOP)

 Python의 제일 큰 특징 중의 하나가 OOP인 점
 C++도 OOP이지만, Python이 더 OOP 특성을 가짐
 OOP는 대규모의 프로그래밍에서 중요하지만, 기존 프로그램(OOP)를
이해하는 것이 중요한 본 수업에서 Python의 OOP 특성을 이해하는 것
이 필요
 In Python, variables are references to objects and any variable can
reference any object (파이썬에서 변수는 객체(memory)에 대한 참조이
며 모든 변수는 모든 객체를 참조 할 수 있다).
 Variables in Python are dynamic, untyped and are references to
objects (파이썬의 변수는 동적이고 형식화되지 않았으며 객체에 대한
참조이다).
70
 Object, Attribute, Fuction(Method)
 먼저 틀(class)을 만들고 이를 이용하여 메모리에 원하는 만큼 객체를
만듬
 Class
 클래스는 데이타를 표현하는 속성(attribute)과 행위를 표현하는 메서드
(method)를 포함하는 논리적인 컨테이너
 메서드(method), 프로퍼티(property), 클래스 변수(class variable), 인스
턴스 변수(instance variable), 초기자(initializer), 소멸자(destructor) 등
다양한 종류의 멤버들로 구분
 클래스는 전통적으로 크게 속성(attribute)과 메서드(method)를 갖는 논
리적 단위이지만, 메서드를 특히 callable attribute로 볼 수도 있기 때문
에 속성과 메서드 모두를 그 클래스의 attribute 라고 생각할 수도 있음
 새로운 attribute를 실행 중 동적(dynamic)으로 추가할 수 있음
71
객체 지향 프로그래밍(Object oriented programming)
 Python은 객체 지향 프로그래밍 언어
 절차 지향 프로그래밍은 함수에 중점
 객체 지향 프로그래밍은 객체에 중점을 둠
 객체는 단순히 데이터 (변수)와 해당 데이터에 대해 작동하는 메서
드 (함수)의 모음
 클래스는 해당 객체의 청사진
 클래스를 집의 스케치 (시제품)로 생각
 여기에는 바닥, 문, 창문 등에 대한 모든 세부 정보가 포함
 집의 청사진으로 많은 집을 만들 수 있기 때문에 클래스에서 많은
객체를 만들 수 있음
 객체를 클래스의 인스턴스
 객체를 만드는 프로세스를 인스턴스화 라고 합니다.
72
 OOP 주요 용어
1. Class
 클래스의 모든 객체를 특성화하는 속성 집합을 정의하는 객체에
대한 사용자 정의 프로토 타입
 속성은 점(dot) 표기법을 통해 액세스되는 데이터 범버(클래스 변
수 및 인스턴스 변수) 및 메써드
2. 클래스 변수
 클래스의 모든 인스턴스가 공유하는 변수
 클래스 변수는 클래스 내에서 정의되지만 클래스의 메써드 외부에
서 정의
 클래스 변수는 인스턴스 변수만큼 자주 사용되지 않음
73
3. Data member
 클래스 및 그 객체와 관련된 데이터를 보유하는 클래스 변수 또는
인스턴스 변수
4. Function overloading
 특정 기능에 둘 이상의 동작을 할당하는 것
 수행되는 작업은 관련된 객체 또는 인수의 유형에 따라 다름
5. Instance variable
 메써드 내부에서 정의되고 클래스의 현재 인스턴스에만
속하는 변수
6. 상속(Inheritance)
 클래스에서 파생 된 다른 클래스에 클래스의 특성을 전송
74
7. Instance
 클래스의 개별 객체
 예를 들어 클래스 A에 속하는 객체 obj는 클래스 A의 인스
턴스
8. Instantiation
 클래스의 인스턴스 생성
9. Method
 클래스 정의로 정의 된 함수의 하나
75
10. Object
 클래스에 의해 정의 된 데이터 구조의 고유 한 인스턴스
 객체는 데이터 멤버 (클래스 변수 및 인스턴스 변수)와 메써드로 구
성
11. Operator overloading
 사전 정의된 작동 의미를 넘어 확장된 의미를 부여하는 것
76
참고 - namespace
 네임스페이스(namespace)
 프로그래밍 언어에서 특정한 객체(Object)를 이름에 따라 구분할 수 있는 범
위를 의미
 파이썬 내부의 모든것은 객체로 구성
 이들 각각은 특정 이름과의 매핑 관계를 갖게 되는데 이 매핑을 포함하고 있
는 공간을 네임스페이스라고 함
 전역 네임스페이스: 모듈별로 존재하며, 모듈 전체에서 통용될 수 있는
이름들이 소속
 지역 네임스페이스: 함수 및 메써드 별로 존재하며, 함수 내의 지역 변수들의
이름들이 소속
 빌트인 네임스페이스: 기본 내장 함수 및 기본 예외들의 이름들이 소속.
파이썬으로 작성된 모든 코드 범위가 포함
77
참고 - namespace
78
참고 - namespace
 네임스페이스는 딕셔너리 형태로 구현
 모든 이름 자체는 문자열로 되어있고 각각은 해당 네임스페이스의
범위에서 실제 객체를 가리킴
 이름과 실제 객체 사이의 매핑은 가변적(Mutable)이므로 런타임동안
새로운 이름이 추가될 수 있음
 다만, 빌트인 네임스페이스는 함부로 추가하거나 삭제할 수 없음
79
참고 - namespace
 파이썬에서 name(변수명)의 의미
 파이썬에서는 name 에 값을 줄 수 있고, function 과 같은 형태도
name 을 줄 수 있다. 동일한 name을 재사용할 수 있다.
 namespace 와 module
 namespace 는 name을 담을 수 있는 공간
 파이썬에서 module 은 파이썬 코드를 담고 있는 파일
 해당 파일에는 파이썬 클래스, 함수 또는 단순하게 name의 리스트가
들어있을 수 있다.
 각 모듈은 자신만의 유일한 namespace 를 갖는다.
 모듈의 namespace 이름은 보통 모듈의 파일이름과 같다.
 따라서 동일한 모듈내에서 동일한 이름을 가지는 클래스나 함수를 정
의할 수 없다.
 또한 모듈은 각각 완벽하게 독립적(namespace가 다르다)이기 때문에,
두 모듈은 동일한 이름을 갖는 클래스나 함수를 정의할 수 있다.
80
참고 - namespace
 import 와 namespace 관계
 module 을 import 하는 방법에 따라 namespace 가 달라진다.
1. import <module_name>
 모듈을 import 하는 가장 일반적인 방법
 이렇게 import 를 하면 module 의 name 을 접두사로 사용하여
모듈의 namespace 에 접근
 (예제) 다음 예제에서 sys 는 모듈 이름이고, path 는 sys 모듈의
namespace 에 담겨있는 name
 path 에 접근을 하기 위해서는 모듈 이름인 sys 를 접두사로 붙여서
sys 모듈의 namespace 에 접근하여 이용
import sys
sys.path
81
참고 - namespace
2. from <module_name> import <name>

 모듈의 namespace 에서 import 에 지정된 name 들을 직접 가져오
도록
 이렇게 하게 되면 import 이후에 지정한 name 들은 module 의
name을 접두사로 지정하지 않고도 접근이 가능
 그러나 이 경우에 module 에서 import 된 이름과 main script 에서
지정된 이름이 동일한 경우, 나중에 정의되는 이름으로 대체되어서
이전 것에 접근이 불가능
몇개의 name 만 필요한 경우에 유용
from sys import path
path
82
참고 - namespace
3. from <module_name> import *

 2 와 동일하지만, module 에 있는 모든 name 을 직접 현재
namespace 로 가져옴
 이렇게 되면 namespace 가 섞이게 되어서 일반적으로 사용을 권장하
지 않음. 첫번째 타입(1번)의 import 를 사용하는 것이 좋음
 __main__ namespace
 import 가 아니고 파이썬 인터프리터가 최초에 실행하는 경우
 인터프리터는 소스파일을 읽고 실행하기 전에 특정한 변수값을 정의
 __name__ 이라는 변수를 __main__ 으로 설정
if __name__ == "__main__"
 의미 : 만일 이 파일이 인터프리터에 의해서 실행되는 경우라면
83
참고 - namespace
# test_name.py test_name.py
if __name__ == '__main__':
print 'This program is being run by itself'
else:
print 'I am being imported from another module'
import test_name test_main.py
84
파이썬의 Class
 Class : 객체 지향 프로그래밍(Object oriented programming)

 절차지향 프로그래밍 방식과 달리 객체지향 프로그래밍은 객체를 정의하
는 것에서 시작
(예제)
 먼저 명함은 이름, 이메일, 주소 데이터로 구성
 명함과 관련된 함수를 생각해보면 기본 명함을 출력하는 함수와 고급 명
함을 출력하는 함수를 생각할 수 있음
 객체지향 프로그래밍은 명함을 구성하는 데이터와 명함과 관련된 함수를
묶어서 명함이라는 새로운 객체(타입)를 만들고 이를 사용해 프로그래밍
하는 방식
85
파이썬의 Class
 Class: 객체 지향 프로그래밍(Object oriented programming)

(예제)
86
Python

 명함이라는 객체를 만들어 두면 명함 객체가 정수, 실수, 문자열과 마찬가
지로 하나의 타입으로 인식
 여러 명의 명함 정보도 쉽게 관리할 수 있음
 마치 다섯 개의 정숫값을 변수로 바인딩하는 것처럼 다섯 개의 명함 값을
변수로 바인딩하거나 리스트에 명함이라는 객체를 저장하고 있으면 됨
87
Python
 Class
 명함 출력에 사용된 이름, 이메일, 주소 등을 효과적으로 관리하기 위해
보통 각 데이터에 대해 별도의 리스트 자료구조를 사용
 첫 번째 회원에 대한 개인 정보를 얻기 위해서는 name_list[0],
email_list[0], address_list[0]과 같이 각 리스트별로 인덱싱을 수행
 데이터와 데이터를 처리하는 함수가 분리돼 있고 함수를 순차적으로 호
출함으로써 데이터를 조작하는 것이 절차지향 프로그래밍
88
Python

 Class를 정의한다는 것은 새로운 데이터 타입을 정의한 것이기 때문에 이
를 실제로 사용하려면 instance(인스턴스)를 생성해야 함
 클래스와 인스턴스의 관계를 금형으로 생각해보면 클래스를 정의하는 것
은 금형을 제작하는 것에 해당
 제품을 만드려면 금형에 플라스틱을 넣고 제품을 만들어야 함
 이처럼 금형에 플라스틱을 넣어서 만들어진 제품이 인스턴스
 클래스를 이용해 인스턴스를 생성하려면 클래스 이름 뒤에 ()를 넣으면
됨
 인스턴스를 생성하는 과정은 함수를 호출하는 것과 유사
89
Class

 클래스 내부에 정의돼 있는 함수를 method(메써드)라고 함
 메서드를 정의할 때도 함수를 정의할 때와 마찬가지로 def 키워드를 사용
(예제)
(일반적으로) 대문자로 시작
class CutomerCard:
def set_info(self, name, email, addr):
self.name = name
self.email = email
self.addr = addr
90
Class
“Lee Daeyup”
“dylee@inha.ac.kr”
“Incheon”
Binding(바인딩)
= 변수에 대입
91
Class

(예제)
member1 = CustomerCard()
member1.set_info(“Lee Daeyup", “dylee@inha.ac.kr”, “Incheon")
member2.set_info(“Kim Kyungsoo", "kyoungsu0415@nate.com", "Kyunggi")
customer1
“Lee Daeyup”
“dylee@inha.ac.kr”
“Incheon”
customer2
“Chun Wonil”
“wjsdnjsdlf95@naver.com”
“Kyunggi”
92
Class methd
 Method
 클래스의 행위를 표현하는 것으로 클래스 내의 함수
 인스턴스 메써드(instance method), 클래스 메서드(class method), 정적
메서드(static method)
 인스턴스 메써드는 인스턴스 변수에 엑세스할 수 있도록 메써드의 첫
번째 파라미터에 항상 객체 자신을 의미하는 "self＂를 파라미터로 함
class Rectangle:
count = 0 # 클래스 변수
# 초기(생성)자(initializer) 정적메소드는 클래스에

def __init__(self, width, height): 서 직접 접근할 수 있
# self.* : 인스턴스변수
self.width = width 는 메소드
self.height = height
Rectangle.count += 1
# 메서드
def calcArea(self):
area = self.width * self.height
return area
93
Python
 Class
 클래스를 이용하여 데이터와 데이터를 조작하는 함수를 하나의 묶음으로
관리할 수 있어 복잡한 프로그램도 더욱 쉽게 작성
(예제) 고객 관리 자료 작성
 고객 정보(이름, 이메일 주소, 근무지 주소)를 입력 및 저장
name = "Lee Daeyup"
email = "dylee@inha.ac.kr"
addr = "Incheon"
def print_customer_card(name, email, addr):

print("-------------------------")
print("Name: %s" % name)
print("E-mail: %s" % email)
print("Address: %s" % addr) 고객 수가 증가하면?
print("-------------------------")
customer1=print_customer_card(name, email, addr)

print(customer1) https://wikidocs.net/774
94
Python

def print_customer_card(name, email, addr): class CustomerCard:
print("-------------------------") def set_info(self, name, email, addr):
print("Name: %s" % name) self.name = name
print("E-mail: %s" % email) self.email = email
print("Address: %s" % addr) self.addr = addr
print("-------------------------")
name = "Lee Daeyup" member1.set_info("Lee Daeyup", "dylee@inha.ac.kr",
email = "dylee@inha.ac.kr" "Incheon")
addr = "Incheon“ print(member1.name)
customer1=print_customer_card(name, email, addr) print(member1.email)
print(customer1) print(member1.addr)
name = "Chun Wonil" member2 = CustomerCard()

email = "wjsdnjsdlf95@naver.com" member2.set_info("Chun Wonil",
addr = "Kyunggi" "wjsdnjsdlf95@naver.com", "Kyunggi")
customer2=print_customer_card(name, email, addr) print(member2.name)
print(customer2) print(member2.email)
print(member2.addr)
<함수를 사용>
<클래스를 사용>
95
Python
class CustomerCard: class CustomerCard:
def set_info(self, name, email, addr): def __init__(self, name, email, addr):
self.name = name self.name = name
self.email = email self.email = email
self.addr = addr self.addr = addr
def print_info(self): def print_info(self):
print("--------------------") print("--------------------")
print("Name: ", self.name) print("Name: ", self.name)
print("E-mail: ", self.email) print("E-mail: ", self.email)
print("Address: ", self.addr) print("Address: ", self.addr)
print("--------------------") print("--------------------")
member1 = CustomerCard() member1 = CustomerCard("Lee Daeyup",

member1.set_info("Lee Daeyup", "dylee@inha.ac.kr", "dylee@inha.ac.kr", "Incheon")
"Incheon") print(member1.print_info())
print(member1.print_info())
member2 = CustomerCard("Chun Wonil",
member2 = CustomerCard() "wjsdnjsdlf95@naver.com", "Kyunggi")
member2.set_info("Chun Wonil", print(member2.print_info())
"wjsdnjsdlf95@naver.com", "Kyunggi")
print(member2.print_info()) <클래스+생성자를 사용하여 데이
<클래스를 사용하여 데이터를 간편하게 처리> 터를 더욱 간편하게처리>

파이썬 (2) 강의노트 (조건문, 입출력, 클래스, 인스턴스, 메써드) (수정)

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

파이썬 (2) 강의노트 (조건문, 입출력, 클래스, 인스턴스, 메써드) (수정)

Uploaded by

Copyright:

Available Formats

1

 <expr>은 bool 컨텍스트(context)로 평가되는 표현식

>>> if x < y: # True >>> if x or y: # True

>>> if x: # False >>> if 'aul' in 'grault': # True

if <expr>:  일치하는 들여 쓰기 수준 (2 ~ 5 행)의 모든

 블록의 끝을 나타내는 토큰이 없음

if 'foo' in ['bar', 'baz', 'qux']:

print('Between inner conditions') # x

print('End of outer condition') # x

Outer condition is true

 <expr>이 true이면 첫 번째 블록이 실행되고 두 번째 블록은 건너 뜀

 많아야 지정된 코드 블록 중 하나를 실행

 긴 if / elif / else 시리즈를 사용하는 것은 좋지는 않음

 elif 절이있는 if 문은 and 및 or 연산자와 유사한 단락 평가를 사용

 두 번째 표현식은 0으로 나누기를 포함하고 세 번째 표현식은

if <expr>: <statement_1>; <statement_2>; ...; <statement_n>

 elif 또는 else 절과 같은 줄에 여러 문을 지정할 수도 있음

 조건식 (Python의 삼항 연산자)

<expr1> if <conditional_expr> else <expr2>

 이것은 프로그램 실행의 흐름을 지시하는 제어 구조가 아니기

Let's go to the beach

'yes' if ('qux' in ['foo', 'bar', 'baz']) else 'no'

z = 1 + x if x > y else y + 2  조건식은 사실상 다른 모든 연산자보다 우

z 선 순위가 낮으므로 자체적으로 그룹화하

 조건식을 먼저 평가하려면 그룹화 괄호로 묶어야 함

 더 큰 표현식의 일부로 조건식을 사용하는 경우 필요하지 않더라도 설

print(42) # <class 'int'>

 ‘ 기호가 있는 경우에는 “ “를 사용 (정정)

 콤마(,)로 문자열을 나열할 경우 공백(기본값)이 자동으로 추가

 더하기(+) 기호로 문자열을 공백없이 연결

 긴 문자열은 \ 기호로 사용하여 여러 줄에 작성할 수 있음

 데이터형에 따른 프린트 포맷(자리수 맞춤)

print(' 0123456789 012345 01234567') 0123456789 012345 01234567

print(' 012345678 01234 01234567') 012345678 01234 01234567

print('f: {1}, i: {0}, s: {2}'.format(i, f, s)) f: 3.14, i: 2020, s: Inha

print('f: {ff}, i: {ii}, s: {ss}'.format(ii=i, ff=f, ss=s)) f: 3.14, i: 2020, s: Inha

print('a is {0[a]}, b is {0[b]}'.format(locals())) a is Inha, b is University

print('a is {a}, b is {b}'.format(**locals())) a is Inha, b is University

print('Inha University'.rjust(20)) #오타 수정

print('Inha University'.capitalize()) print(list(range(1, 10)))

 파일이 존재할 때는 원래 내용이 지워짐

 파일을 읽기 모드로 열어 내용을 쓰기

 파일을 읽기 모드로 열어 내용을 쓰기

with open(test1.txt", "w") as f: with_file.ipynb

A class is like a blueprint while an instance is a

 클래스는 해당 객체의 청사진

 Object, Attribute, Fuction

 Object, Attribute, Fuction

 Class, Object, Attribute, Fuction

 Object oriented programming(OOP)

 중요한 점은, 객체와 (instance)변수가 각자 존재

 클래스와 관련된 기능이 없는 한 클래스 자체는 의미가

 메써드를 정의 할 때 항상 self를 사용하여 메서드에 첫 번

class Car : # 자동차를 정의

 인스턴스 속성과 init 메써드

 클래스로부터 생성된 클래스 인스턴스(객체)로부터 클래스 멤버들을

 Class variable and Instance variable

# Class for Mechnical Engineering Student

# Objects of Mech_Student class

 Object and Instance variable

 Class variable and Instance variable

# Class variables can be accessed using class

 Class variable and Instance variable(1/2)