🤍

코드 - 패캠 수업 코드 참고 (패캠 수업 정리)

<이전 글>

https://silvercoding.tistory.com/39

- 본 포스팅에서 다룰 내용 요약 

* 클래스 변수 & 인스턴스 변수 차이 (중요)

* 클래스 변수 : 직접 사용 가능, 객체보다 먼저 생성 

* 인스턴스 변수 : 객체 마다 별도로 존재, 인스턴스 생성 후 사용 

* 네임스페이스 : 객체를 인스턴스화 할 때 저장된 공간 ( (ex)이름, 주소, .... -> 독립적인 공간 )   

* 클래스 상속과 다중 상속 

* 클래스 선언

class 클래스명:

    함수

    함수

    함수 

 [클래스 기본 사용] 

- 예제 1 

class UserInfo:
    # 속성, 메소드 
    def __init__(self, name):
        self.name = name
        print("초기화", name)

    def user_info_p(self):
        print('Name : ', self.name)

초기에 name을 받는 클래스 UserInfo를 선언한다. user_info_p메소드를 호출하면 self.name이 출력된다. 

user1 = UserInfo('Silver')
print(user1.name)
user1.user_info_p()

 초기화 Silver 
 Silver 
 Name :  Silver 

user2 = UserInfo('Park')
print(user1.name)
user2.user_info_p()

 초기화 Park 
 Park 
 Name :  Park 

print(id(user1))
print(id(user2))

 2535817860096 
 2535817860544 

같은 클래스에서 나왔지만 user1과 user2 는 서로 다르다. id값이 다르다는 것으로 증명할 수 있다. 

* 네임스페이스 확인 

print(user1.__dict__)
print(user2.__dict__)

 {'name': 'Silver'} 
 {'name': 'Park'} 

 __dict__ 메서드를 사용하여 인스턴스의 네임스페이스를 확인할 수 있다. 저장된 변수와 값이 key, value형식인 dictionary로 출력된다. 

- 예제 2 

* self 의 이해 (클래스 메소드 vs 인스턴스 메소드) 

<참고 포스팅> 

https://silvercoding.tistory.com/20?category=957523 

class SelfTest():
    def function1():
        print('function1 called ! ')

    def function2(self):
        print(id(self))
        print('function2 called ! ')

메서드를 2개 생성해 준다. functionn1은 self를 인자로 받지 않고, function2는 self를 인자로 받는다. 이 경우에 각 두개의 메서드에 어떻게 접근하는지 실험해 본다. 

self_test = SelfTest()

self_test.function1()

 TypeError: function1() takes 0 positional arguments but 1 was given 

function1 함수에 인스턴스로 접근했더니 TypeError가 발생하게 된다. self를 인자로 받지 않기 때문에 클래스 메소드이고, 누구(어떤 인스턴스)의 function1 함수인지 모르는 것이다. 

SelfTest.function1() # 클래스 메소드

 function1 called ! 

따라서 이렇게 클래스 자체로 접근해 주어야 호출이 가능하다. 

self_test.function2() # 인스턴스 메소드 
print(id(self_test))

 1805035034104 
 function2 called ! 
 1805035034104 

반면 self를 인자로 받았던 function2 메소드는 인스턴스를 통해 호출 가능하다. self의 id를 출력하도록 생성 했었는데, self_test 인스턴스와 id값이 같은 것을 볼 수 있다. 따라서 self를 인자로 받는 클래스의 메소드의 인자인 self에는 인스턴스가 들어가게 되는 것이다. 

SelfTest.function2() # -> 예외

 TypeError: function2() missing 1 required positional argument: 'self' 

이처럼 인스턴스가 아닌 클래스 자체로 접근하면 똑같이 TypeError가 나게 된다. 오류 내용에 따르면 인스턴스를 인자에 넣어주면 실행될 것이다. 

SelfTest.function2(self_test)  # 인자에 인스턴스 넣어주면 클래스자체로 호출 가능

 2385469756864 
 function2 called ! 

- 예제 3 

: 클래스 변수 vs 인스턴스 변수 

<참고 포스팅> 

https://silvercoding.tistory.com/19?category=957523 

class WareHouse: 
    # 클래스 변수 
    stock_num = 0 
    def __init__(self, name): 
    	# 인스턴스 변수
        self.name = name 
        WareHouse.stock_num += 1 

    def __del__ (self):
        WareHouse.stock_num -= 1

클래스 변수와 인스턴스 변수를 각각 생성해 주었다. 

user1 = WareHouse('Kim')
user2 = WareHouse("Park")
user3 = WareHouse("Lee")

인스턴스를 3개 만들어 준다. 

* 인스턴스 네임스페이스, 클래스 변수 (모든 인스턴스에 공유) 

print(user1.__dict__)
print(user2.__dict__)
print(user3.__dict__)

 {'name': 'Kim'} 
 {'name': 'Park'} 
 {'name': 'Lee'} 

위와 같이 인스턴스의 네임스페이스를 출력하면 name이 제대로 나오는 것을 볼 수 있다. 

print(user1.name)
print(user2.name)
print(user3.name)

 Kim 
 Park 
 Lee 

* 클래스 네임스페이스, 클래스 변수 (모든 인스턴스에 공유) 

print(WareHouse.__dict__)  # ---> 클래스 자체의 네임 스페이스에서 클래스변수 확인 가능

 {'__module__': '__main__', 'stock_num': 3, '__init__': <function WareHouse.__init__  
 at 0x0000022B69124510>, '__del__': <function WareHouse.__del__ at 0x0000022B69124598>, '__dict__': <attribute  '__di ct__' of 'WareHouse' objects>, '__weakref__': <attribute '__weakref__' of 'WareHouse' objects>, '__doc__': None} 

이렇게 클래스 변수는 클래스의 네임스페이스를 찍어보면 확인할 수 있다. 

print(user1.stock_num) # 자신의 네임스페이스에 없으면 클래스의 네임스페이스에서 찾고, 클래스의 네임스페이스에도 없으면 그때 에러가 난다. 
print(user2.stock_num)
print(user3.stock_num)

 3 
 3 
 3 

클래스 변수는 인스턴스를 통하여 접근할 수도 있다. 자기 자신의 인스턴스 네임스페이스에 찾는 변수가 없으면 클래스의 네임스페이스에서 찾고 , 클래스의 네임스페이스에도 해당 변수가 없으면 그때 오류가 나게 되는 것이다. 

del user1

del로 user1을 지우면, 위에 선언해 놓은 대로 sock_num 도 -1이 될 것이다. 

# print(user1.stock_num)
print(user2.stock_num)
print(user3.stock_num)

 2 
 2 

 [클래스 상속] 

- 예제 1 

* Car : 부모 클래스 

class Car: 
    """"Parent Class"""
    def __init__(self, tp, color):
        self.type = tp
        self.color = color

    def show(self):
        return 'Car Class "Show Method!"'

* BmwCar : 자식 클래스 1

class BmwCar(Car):
    """Sub Class"""
    def __init__(self, car_name, tp, color):
        super().__init__(tp, color)
        self.car_name = car_name

    def show_model(self) -> None:
        return "Your Car Name : %s" % self.car_name

* BenzCar : 자식 클래스 2

class BenzCar(Car):
    """Sub Class"""
    def __init__(self, car_name, tp, color):
        super().__init__(tp, color)
        self.car_name = car_name

    def show_model(self) -> None:
        return "Your Car Name : %s" % self.car_name

    def show(self):
        print(super().show())
        return 'Car Info: %s %s %s' % (self.car_name, self.type, self.color)

* 사용 

model1 = BmwCar('520d', 'sedan', 'red')

우선 객체를 생성해 준다. 

print(model1.color) # Super 
print(model1.type)  # Super
print(model1.car_name) # Sub
print(model1.show()) # Super    
print(model1.show_model()) # Sub
print(model1.__dict__)

 red 
 sedan 
 520d 
 Car Class "Show Method!" 
 Your Car Name : 520d 
 {'type': 'sedan', 'color': 'red', 'car_name': '520d'} 

부모클래스에서 선언해 놓았던 color, type변수와 show() 메소드가 정상적으로 출력된 것을 볼 수 있다. 인스턴스의 네임스페이스에도 변수가 들어 가 있다. 

# Method Overriding (오버라이드 : 올라타다)

model2 = BenzCar("220d", 'suv', 'black')
print(model2.show())

 Car Class "Show Method!" 
 Car Info: 220d suv black 

# Parent Method Call 
model3 = BenzCar('350s', 'sedan', 'silver')
print(model3.show())

 Car Class "Show Method!" 
 Car Info: 350s sedan silver 

BenzCar 클래스의 show() 메소드에서 super.show()를 사용하여 부모클래스의 메소드를 오버라이딩 하였다. 따라서 부모 클래스에서 선언하였던 내용도 함께 출력된 것을 볼 수 있다. 

# Inheritance Info (상속정보 리스트 형태로 나옴)

print(BmwCar.mro())  # 상속 관계를 보여준다. 
print(BenzCar.mro())
# 모든 클래스는 object를 상속받는다.

 [<class '__main__.BmwCar'>, <class '__main__.Car'>, <class 'object'>] 
 [<class '__main__.BenzCar'>, <class '__main__.Car'>, <class 'object'>] 

mro 함수를 사용하여 상속 관계를 리스트로 출력해볼 수 있다. 모든 클래스는 object를 상속 받는 것 또한 알아두기 ! 

- 예제 2 : 다중 상속 

class X:
    pass

class Y:
    pass

class Z:
    pass

class A(X, Y):
    pass

class B(Y, Z):
    pass

class M(B, A, Z):
    pass

우선 클래스 X, Y, Z를 선언하고, A는 X, Y를 , B는 Y, Z 를 , M은 B, A, Z 를 다중상속 받는다. 이 때의 Inheritance Info를 출력해 보자. 

print(M.mro())
print(A.mro())

 [<class '__main__.M'>, <class '__main__.B'>, <class '__main__.A'>, <class '__main__.X'>, <class '__main__.Y'>, <class '__main__.Z'>, <class 'object'>] 
 [<class '__main__.A'>, <class '__main__.X'>, <class '__main__.Y'>, <class 'object'>] 

이처럼 다중상속이 가능하지만 , 너무 많이 상속 받게 되면 코드를 해석하기 어렵게 만들어질 수도 있으므로 주의하여 사용하는 것이 권장된다. 

코드 - 패캠 수업 코드 참고 (패캠 수업 정리)

<이전 글>

https://silvercoding.tistory.com/38

* 함수 정의 방법 

def 함수명(parameter):

    code 

- 예제 1 : 출력(print) 

def hello(world):
    print('Hello', world)

hello('Silver !')
hello(77777)

 Hello Silver ! 
 Hello 77777 

함수명(parameter) 의 형태로 함수를 호출할 수 있다. 

- 예제 2 : 리턴(return) 

def hello_return(world):
    val = "Hello" + str(world)
    return val

str = hello_return("Silver !!!!!")
print(str)

 HelloSilver !!!!! 

함수 안에서 return하여 변수로 리턴값을 받아줄 수도 있다. 

- 예제 3 : 여러 값 리턴 

def func_mul(x):
    y1 = x * 100 
    y2 = x * 200 
    y3 = x * 300 
    return y1, y2, y3

val1, val2, val3 = func_mul(100)
print(type(val1), val1, val2, val3)

 <class 'int'> 10000 20000 30000 

여러 값을 리턴하여 각각의 변수에 값을 받아줄 수 있다. 

- 예제 4 : 리스트 리턴 

def func_mul2(x):
    y1 = x * 100 
    y2 = x * 200 
    y3 = x * 300 
    return [y1, y2, y3]

lt = func_mul2(100)
print(lt, type(lt))

 [10000, 20000, 30000] <class 'list'> 

- 예제 5 : 가변 인자 받기 (*args / **kwargs) 

(1) *args 

: 튜플 형태로 받음 ( 가변 튜플 ) 

def args_func(*args):
    print(args)

def args_func2(*args):
    for t in args:
        print(t)

def args_func3(*args):
    for i, v in enumerate(args):
        print(i, v)

args_func('Kim')
args_func('Kim', 'Park')
args_func2('Kim', 'Park', 'Lee')
args_func3('Kim', 'Park', 'Lee')

 ('Kim',) 

 ('Kim', 'Park') 

위와 같이 파라미터에 입력한 개수 만큼  튜플안의 값이 생성되는 것을 볼 수 있다. 
 Kim 
 Park 

 Lee 

튜플이므로 반복문에서 사용해줄 수도 있다. 
 0 Kim 
 1 Park 
 2 Lee 

인덱스와 값을 모두 iterable 하게 반환해주는 enumerate를 사용하여 반복문을 사용한 코드이다. 

(2) **kwargs

: dictionary로 받음 ( 가변 딕셔너리 ) 

def kwargs_func(**kwargs):
    print(kwargs)

def kwargs_func2(**kwargs):
    for k, v in kwargs.items():
        print(k, v)

kwargs_func(name1='Kim')
kwargs_func(name1='Kim', name2='Park', name3='Lee')
kwargs_func2(name1='Kim', name2='Park', name3='Lee')

 {'name1': 'Kim'} 
 {'name1': 'Kim', 'name2': 'Park', 'name3': 'Lee'} 

인자에 key = value 형태로 넣어주면 그 개수 대로 딕셔너리 값이 생성되는 것을 볼 수 있다. 
 name1 Kim 
 name2 Park 
 name3 Lee 

dictionary 객체이므로 반복문도 사용 가능하다. 

(3) 전체 혼합 

def example_mul(arg1, arg2, *args, **kwargs):
    print(arg1, arg2, args, kwargs)

일반, 가변 튜플, 가변 딕셔너리를 모두 받는 함수를 선언한다.  

example_mul(10, 20)
example_mul(10, 20, 'park', 'kim')
example_mul(10, 20, 'park', 'kim', age1=24, age2=35)

 10 20 () {} 
 10 20 ('park', 'kim') {} 
 10 20 ('park', 'kim') {'age1': 24, 'age2': 35} 

- 예제 6 : 충첩합수 (클로저) - 효율적인 메모리 관리 가능 

def nested_func(num):
    def func_in_func(num):
        print('>>>', num)
    print('in func')
    func_in_func(num + 10000)

nested_func(10000)

 in func 
 >>> 20000 

nested_fun(10000)으로 함수를 호출하면 print문이 실행되고, func_in_func(10000 + 10000)이 호출이 되어 func_in_func안의 print문이 실행되는 것이다. 

<참고 : 클로저 포스팅>

https://silvercoding.tistory.com/26?category=957523 

- 예제 7 : hint -> 인자 타입과 리턴 타입 명시해주기 

def func_mul3(x: int) -> list:
    y1 = x * 100 
    y2 = x * 200 
    y3 = x * 300 
    return [y1, y2, y3]

print(func_mul3(5))

 [500, 1000, 1500] 

인자 x는 int, 리턴타입은 list라고 기입해주어 명확히 사용할 수 있다. 

- 예제 8 : lambda 

* 람다식 : 메모리 절약, 가독성 향상, 코드 간결 

* 함수 : 객체 생성 -> 리소스 (메모리) 할당 vs 람다 : 즉시 실행 (Heap 초기화) -> 메모리 초기화 

(1) 일반적 함수 : 변수 할당 

def mul_10(num: int) -> int:
    return num * 10

val_func = mul_10   # ---> 객체 생성 -> 메모리 할당 
print(val_func) 
print(type(val_func))

print(val_func(10))

 <function mul_10 at 0x00000212CEA148C8> 
 <class 'function'> 
 100 

(2) 람다식 

lambda_mul_10 = lambda num : num * 10 
print(">>>", lambda_mul_10(10))

 >>> 100 

* 함수의 인자에 함수 넣기 

def func_final(x, y, func):
    print(x * y * func(10))

인자에 함수를 넣는 함수를 선언한다. 

func_final(10, 10, lambda_mul_10)

 10000 

print(func_final(10, 10, lambda x: x * 1000))

 1000000 
 None 

이렇게 바로 lambda 함수를 사용해주어도 된다. 

코드 - 패캠 수업 코드 참고 (패캠 수업 정리)

<이전 글>

https://silvercoding.tistory.com/37

(1) while 문 

- 예제 1

v1 = 1
while v1 < 11:
    print("v1 is : ", v1)
    v1 += 1

 v1 is :  1 
 v1 is :  2 
 v1 is :  3 
 v1 is :  4 
 v1 is :  5 
 v1 is :  6 
 v1 is :  7 
 v1 is :  8 
 v1 is :  9 
 v1 is :  10 

while문은 조건이 참일 동안 계속 반복한다. 이 예제에서는 11보다 작을 때, 즉 10까지 반복한다. 

- 예제 2 

sum1 = 0 
cnt1 = 1

while cnt1 <= 100: 
    sum1 += cnt1
    cnt1 += 1

print('1 ~ 100: ', sum1)

 1 ~ 100:  5050 

cnt1이 100 이하일 동안 반복문을 실행하게 된다. sum1에 1씩 증가하는 cnt1을 계속 더해줌으로써 1부터 100까지의 합을 구하는 코드이다. 

* 참고 - 같은 결과를 낼 수 있는 함수 sum(), range()이용

print('1 ~ 100: ', sum(range(1, 101)))
print('1 ~ 100: ', sum(range(1, 101, 2)))

 1 ~ 100:  5050 
 1 ~ 100:  2500 

더 간단한 방법으로 합을 구해줄 수 있다. 1부터 100까지 홀수의 합만을 구하려면 range(1, 101, 2) 를 사용하면 된다. 

(2) for 문 

* 시퀀스 (순서가 있는) 자료형 반복 : 문자열, 리스트, 튜플, 집합, 사전 

* iterable 리턴 함수 : range. reversed, enumerate, filter, map, zip 

- 예제1 - range() 

for v3 in range(1, 11):
    print('v3 is : ', v3)

 v3 is :  1 
 v3 is :  2 
 v3 is :  3 
 v3 is :  4 
 v3 is :  5 
 v3 is :  6 
 v3 is :  7 
 v3 is :  8 
 v3 is :  9 
 v3 is :  10 

시퀀스 자료형을 반복한다. 위와 같은 경우에서는 1부터 10까지 차례대로 v3에 들어가는 것을 반복하며 출력해 준다. 

- 예제2 - 리스트 (ilst)

names = ['Kim', 'Park', 'Cho', 'Choi', 'Yoo']

for v in names: 
    print('You are: ', v)

 You are:  Kim 
 You are:  Park 
 You are:  Cho 
 You are:  Choi 
 You are:  Yoo 

리스트 자료형을 넣어주어도 반복이 가능하다! 

- 예제3 - 문자열 (str)

word = "dreams"

for s in word:
    print("Word: ", s)

 Word:  d 
 Word:  r 
 Word:  e 
 Word:  a 
 Word:  m 
 Word:  s 

문자열도 반복이 가능하다. 

- 예제4 - 딕셔너리 (dictionary) 

my_info = {
    'name' : 'kim',
    'age' : 33, 
    'city' : 'Seoul'
}

우선 딕셔너리 선언하기 

(1) 기본 : key

for key in my_info:
    print('my_info', key)

 my_info name 
 my_info age 
 my_info city 
딕셔너리 자체를 반복문에 넣으면 기본적으로 키가 반복된다. 

(2) values

for key in my_info.values():
    print('my_info', key)

 my_info kim 
 my_info 33 
 my_info Seoul 

(3) keys

for key in my_info.keys():
    print('my_info', key)

 my_info name 
 my_info age 
 my_info city 

(4) items 

for key, value in my_info.items():
    print('my_info', key, value)

 my_info name kim 
 my_info age 33 
 my_info city Seoul 

- 예제5 : 반복문 + 조건문 

name = 'KennRY'
name2 = ""

KennRY 에서 대문자는 소문자로, 소문자는 대문자로 바꾸고, 최종적으로 name2에 바뀐 문자열을 저장하는 코드를 생성한다. 

for n in name:
    if n.isupper():
        print(n.lower())
        name2+=n.lower()
    else:
        print(n.upper())
        name2+=n.upper()

 k 
 E 
 N 
 N 
 r 
 y 

print(name2)

 kENNry 

문자열을 반복하여, 글자가 대문자면 소문자로 바꾸고 name2에 글자를 더해준다. 그 반대의 경우도 동일하게 해준다. 그럼 이처럼 원하는 결과가 나오는 것을 볼 수 있다. 

- 예제6 : break

numbers = [14, 3, 4, 7, 10, 24, 17, 2, 33, 35, 36, 38]
numbers2 = [14, 3, 4, 7, 10, 24, 17, 2, 37, 35, 36, 38]

for num in numbers: 
    if num == 33:
        print('found : 33 !')
        break
    else:
        print('not found : 33!')

 not found : 33! 
 not found : 33! 
 not found : 33! 
 not found : 33! 
 not found : 33! 
 not found : 33! 
 not found : 33! 
 not found : 33! 
 found : 33 ! 

33을 발견하면 break를 사용하여 반복문을 탈출하는 코드이다. 실제로 33 차례가 왔을 때, found : 33 ! 이 출력되고, 그 이후로는 아무것도 출력되지 않는 것을 볼 수 있다. 

- 예제7 : for-else 구문 
: 반복문이 정상적으로 수행(모든 값 순회 ) 된 경우 else 블럭 수행 

for num in numbers2: 
    if num == 33:
        print('found : 33 !')
        break
    else:
        print('not found : 33!')
else:
    print('Not found 33 ...........')

 not found : 33! 
 not found : 33! 
 not found : 33! 
 not found : 33! 
 not found : 33! 
 not found : 33! 
 not found : 33! 
 not found : 33! 
 not found : 33! 
 not found : 33! 
 not found : 33! 
 not found : 33! 
 Not found 33 ........... 

break문 등으로 인하여 반복문이 정상적으로 모든 값을 순회하지 못할 경우 else블럭은 수행되지 않는다. 예제7과 같은 경우에는 33이 리스트에 존재하지 않기 때문에 정상적으로 모든 값을 순회하여 else블럭이 수행되었다. 

- 예제8 : continue

lt = ['1', 2, 5, True, 4.3, complex(4)]

for v in lt: 
    if type(v) is float:
        continue
    print('타입 : ', type(v))

 타입 :  <class 'str'> 
 타입 :  <class 'int'>
 타입 :  <class 'int'> 
 타입 :  <class 'bool'> 
 타입 :  <class 'complex'> 

continue를 만나면 그 다음 코드를 실행하지 않고 곧바로 for문의 첫번째로 되돌아 가 반복을 그대로 수행한다. 예제8에서는 float타입이면 continue를 실행한다. float 타입인 4.3을 중간에 넣어놓았더니 그 후의 print문은 실행되지 않고 complex타입은 정상적으로 출력된 것을 볼 수 있다.

- 예제9 : reversed 함수 

name = 'Niceman'
print(reversed(name))
print(list(reversed(name)))
print(tuple(reversed(name)))

 <reversed object at 0x000001C1CC70D898> 
 ['n', 'a', 'm', 'e', 'c', 'i', 'N'] 
 ('n', 'a', 'm', 'e', 'c', 'i', 'N') 

reversed 함수는 그대로 출력해서 보기 위해 list나 tuple객체로 변환해주어야 한다. 

for i in reversed(name):
    print(i)

 n 
 a 
 m 
 e 
 c 
 i 
 N 

하지만 iterable을 반환해주는 함수이기 때문에 for문에서는 곧바로 사용할 수 있다. 

코드 - 패캠 수업 코드 참고 (패캠 수업 정리)

<이전 글>

https://silvercoding.tistory.com/36

* 조건문을 사용하기 위한 배경지식 & 기초 if문 작성해보기

- 참(True) , 거짓(False) 종류 

(1) 참 : "내용", [내용], (내용), {내용}, 1, True

(2) 거짓 : "", [], (), {}, 0, False 

기본적으로 여러 데이터 타입에서 내용이 채워져 있으면 참, 비어 있으면 거짓이다. 

# 예 1
if True:
    print('Yes')

# 예 2
if False:
    print('No')

# 예 3
if False:
    print('No')
else:
    print('Yes2')

 Yes 
 Yes2 

우선 이처럼 if문은 True일 때 실행되고, False일 때 실행되지 않는다. 이를 이용하여 위에서 배운 참과 거짓을 사용하여 if문을 활용한다. 

city = ""

if city:
    print('>>>>True')
else:
    print('>>>>False')

 >>>>False 

이처럼 비어있는 문자열일 경우 False로 인식하여 else로 넘어가 else의 부분이 실행 되는 것이다. 

- 관계 연산자 

: >, >=, <, <=, ==, != 

a = 10 
b = 0

print(a == b)
print(a != b)
print(a > b)
print(a >= b)
print(a < b)
print(a <= b)

 False 
 True 
 True 

 True 

 False 
 False 

- 논리 연산자 

: and, or, not

a = 100 
b = 60 
c = 15

print('and: ', a > b and b > c)
print('or: ', a > b or c > b)
print('not: ', not a > b)
print(not True)
print(not False)

 and:  True 
 or:  True 
 not:  False 
 False 
 True 

* 산술, 관계 , 논리 연산자 적용 순서 

: 산술 > 관계 > 논리 

print('ex1: ', 5 + 10 > 0 and not 7 + 3 == 10)

 ex1:  False 

* if 문 사용 

score1 = 90
score2 = 'A'

if score1 >= 90 and score2 == 'A':
    print('합격하셨습니다. ')
else:
    print('더 공부하세요. 불합격입니다. ')

 합격하셨습니다. 

score1이 90이상이면서 score2가 A이므로 (True & True = True) if문이 실행된다. 

- 다중 조건문 

num = 82

if num >= 90:
    print("num 등급 A", num)
elif num >= 80:
    print("num 등급 B", num)
elif num >= 70:
    print("num 등급 C", num)
else:
    print("꽝")

 num 등급 B 82 

num 이 82 이므로 등급 B가 출력된다. elif는 else if 의 줄임말이다. if가 실행되지 않으면 elif로 가게 된다. 만약 위의 경우에서 elif 대신 if를 쓴다면 ,

 num 등급 B 82 
 num 등급 C 82 

이와 같은 결과가 나올 것이다. 윗줄의 if문이 실행이 되든 안되든 모든 if문을 검사하기 때문이다. 이것이 elif가 필요한 이유다. 

- 중첩 조건문 

age = 27 
height = 175

if age >= 20: 
    if height >= 170:
        print('A 지망 지원 가능')
    elif height > 160:
        print('B 지망 지원 가능')
    else:
        print('지원 불가')

else:
    print('20세 이상 지원 가능')

 A 지망 지원 가능 

이처럼 if문 안에 if문을 사용할 수 있다. age가 20 이상일 때 , height 를 검사하는 중첩 조건문이다.  

코드 - 패캠 수업 코드 참고 (패캠 수업 정리)

<이전 글>

https://silvercoding.tistory.com/35

1. 딕셔너리 (Dictionary) 

: 순서 X, 중복 X, 수정 O, 삭제 O 

: Key, Value 형식으로 되어 있음. (Json/ MongoDB) 

- 선언 

a = {'name': 'kIM', 'Phone': '010-7777-7777', 'birth': 990101}
b = {0: 'Hello Python', 1: 'Hello Coding'}
c = {'arr': [1, 2, 3, 4, 5]}

print(type(a))

 <class 'dict'> 

딕셔너리 객체를 선언해 준다. 

- 출력 

print(a['name'])
print(a.get('name'))
print(a.get('adress'))  # 안전한 코딩 방식 : 이거 쓰는 것을 권장. 에러가 안나기 때문 
print(c['arr'][1:3])

 kIM 
 kIM 
 None 
 [2, 3] 

딕셔너리에서 값을 가져오기 위한 2가지 방법이 있다. 1. 키에 직접 접근 , 2. get() 사용 

1번 방법이 편리하지만, 없는 키 값을 사용하면 오류가 나게 된다. 2번 방법을 사용하면 없는 키 값을 넣더라도 None을 반환해주기 때문에 더 안전한 코딩이 가능하다. 

- 딕셔너리 추가 

a['adress'] = 'Seoul'
print(a)
a['rank'] = [1, 3, 4]
a['rank2'] = (1, 2, 3)
print(a)

 {'name': 'kIM', 'Phone': '010-7777-7777', 'birth': 990101, 'adress': 'Seoul'} 
 {'name': 'kIM', 'Phone': '010-7777-7777', 'birth': 990101, 'adress': 'Seoul', 'rank': [1, 3, 4], 'rank2': (1, 2, 3)} 

key와 value를 직접 적어주면 된다. 리스트와 튜플 또한 추가가 가능하다. 

- keys, values, items 

# print(a.keys()[0]) # 리스트 인덱스로 접근 불가 
temp = list(a.keys()) # ---> 형변환 해주어야 함 
print(temp)
print(temp[1:3])

 ['name', 'Phone', 'birth', 'adress', 'rank', 'rank2'] 
 ['Phone', 'birth'] 

a.keys() 를 사용하면 딕셔너리 a의 key값들만 모아서 나오게 된다. 언뜻 보면 리스트처럼 생겼지만 리스트를 사용하는 것 처럼 인덱싱이나 슬라이싱을 할 수 없다. 따라서 list()를 이용하여 형변환을 해주면 키 값들이 담긴 리스트를 생성할 수 있다. 

print(a.values())
print(list(a.values()))

print(a.items())
print(list(a.items()))

 dict_values(['kIM', '010-7777-7777', 990101, 'Seoul', [1, 3, 4], (1, 2, 3)]) 
 ['kIM', '010-7777-7777', 990101, 'Seoul', [1, 3, 4], (1, 2, 3)] 

 dict_items([('name', 'kIM'), ('Phone', '010-7777- 7777'), ('birth', 990101), ('adress', 'Seoul'), ('rank', [1, 3, 4]), ('rank2', (1, 2, 3))]) 
 [('name', 'kIM'), ('Phone', '010-7777-7777'), ('birth', 990101), ('adress', 'Seoul'), ('rank', [1, 3, 4]), ('rank2', (1, 2, 3))] 

values()와 items()도 마찬가지다! 

- 키 존재 여부 

print(1 in b)
print(2 in b)
print('name' in a)

 True 
 False 
 True 

위와 같이 딕셔너리에서 in을 이용하면 key값이 존재하는지에 대한 여부를 boolean 타입으로 반환해 준다. 

2. 집합 (Set) 

: 순서 X, 중복 X 

- 선언 

a = set()
b = set([1, 2, 3, 4])
c = set([1, 4, 6, 6, 6])

* 주의할 점은 a = { } 와 같이 선언하면 딕셔너리 객체가 만들어 지므로 빈 집합을 만들 경우엔 a = set() 의 형태로 선언해 주어야 한다. 

print(type(a))
print(c)

 <class 'set'> 
 {1, 4, 6} 

위와 같이 중복을 허용하지 않는다! 

- 형변환 

: Set 자료형은 주로 변환하여 사용한다. 

t = tuple(b)
print(t)
l = list(b)
print(l)

 (1, 2, 3, 4) 
 [1, 2, 3, 4] 

중복 값이 들어가지 않도록 set을 생성한 후 튜플이나 리스트 등으로 변환하여 사용하는 일이 많다고 한다.  

* 집합 연산 (교집합, 합집합, 차집합) 

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

연산을 수행하기 위한 집합을 선언한다. 

- 교집합 : intersection / &

print(s1.intersection(s2))
print(s1 & s2)

 {4, 5, 6} 
 {4, 5, 6} 

- 합집합 : union / |

print(s1.union(s2))
print(s1 | s2)

 {1, 2, 3, 4, 5, 6, 7, 8, 9} 
 {1, 2, 3, 4, 5, 6, 7, 8, 9} 

- 차집합 : difference / -

print(s1.difference(s2))
print(s1 - s2)

 {1, 2, 3, 4, 5, 6, 7, 8, 9} 
 {1, 2, 3} 
 {1, 2, 3} 

- 추가 & 제거 

s3 = set([7, 8, 10, 15])

s3.add(18)
s3.add(7)

print(s3)

 {7, 8, 10, 15, 18} 

add함수를 이용하여 값을 추가할 수 있다. 

s3.remove(15)
print(s3)

 {7, 8, 10, 18} 

remove함수를 이용하여 값 제거까지 가능하다. 

코드 - 패캠 수업 코드 참고 (패캠 수업 정리)

<이전 글>

https://silvercoding.tistory.com/34

1. 리스트 (list) 

: 순서 O, 중복 O, 삭제 O 

- 선언 

a = []
b = list()
c = [1, 2, 3, 4]
d = [10, 100, 'Pen', 'Banana', 'Orange']
e = [10, 100, ['Pen', 'Banana', 'Orange']]

여러 방법으로 리스트를 선언 해 줄 수 있다. 

- 인덱싱

print(d[3])
print(d[-2])
print(d[0] + d[1])
print(e[2][1])
print(e[-1][-2])

 Banana 
 Banana 
 110 
 Banana 
 Banana 

- 슬라이싱 

print(d[0:3])
print(e[2][1:3])

 [10, 100, 'Pen'] 
 ['Banana', 'Orange'] 

- 연산 

print(c + d)
print(c * 3)
print(str(c[0]) + 'hi')

 [1, 2, 3, 4, 10, 100, 'Pen', 'Banana', 'Orange'] 
 [1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4] 
 1hi 

- 리스트 수정, 삭제 

c[0] = 77
print(c)

 [77, 2, 3, 4] 

0번쨰 인덱스에 값 넣어주기 

c[1:2] = [100, 1000, 10000]
print(c) # 원소가 들어감

 [77, 100, 1000, 10000, 3, 4] 

슬라이싱을 이용하여 여러 값을 넣어줄 수 있다.

c[1] = ['a', 'b', 'c']
print(c) # 리스트가 들어감

 [77, ['a', 'b', 'c'], 1000, 10000, 3, 4] 

리스트 자체를 넣어주려면 인덱싱을 사용하면 된다. 

del c[1]
print(c)

 [77, 1000, 10000, 3, 4] 

del을 이용하여 리스트의 값을 삭제할 수 있다. 

del c[-1]
print(c)

 [77, 1000, 10000, 3] 

-리스트 관련 함수 

(1) append 

y = [5, 2, 3, 1, 4]
print(y)
y.append(6) # 끝에 추가 
print(y)

 [5, 2, 3, 1, 4] 
 [5, 2, 3, 1, 4, 6] 

리스트의 가장 끝에 값을 추가해 준다. 

(2) sort

y.sort() # 정렬 
print(y)

 [1, 2, 3, 4, 5, 6] 

리스트를 정렬해 준다. 

(3) reverse

y.reverse()
print(y)

 [6, 5, 4, 3, 2, 1] 

리스트를 뒤집어 준다. 

(4) insert

y.insert(2, 7)
print(y)

 [6, 5, 7, 4, 3, 2, 1] 

append와는 다르게 원하는 인덱스에 값을 추가해줄 수 있다. 

(5) remove

y.remove(2)
y.remove(7)
print(y) # 원소 값을 지운다.

 [6, 5, 4, 3, 1] 

del은 인덱스를 이용하여 지워주었는데, remove함수는 값을 넣으면 그 값을 지워준다. 

(7) pop

y.pop()
print(y) # LIFO 스택 자료구조

 [6, 5, 4, 3]  

pop을 사용하면 가장 끝에 있는 값을 지워준다. LIFO(Last In First Out) 의 자료구조로 사용된다. 

(8) extend

ex = [88, 77]
# y.append(ex) # 리스트 자체를 추가
y.extend(ex) # 값을 추가 
print(y)

 [6, 5, 4, 3, 88, 77] 

리스트 안에 리스트를 추가하는 것이 아니라, 리스트 안에 여러 값을 한 번에 넣어주고 싶을 때 extend함수를 사용한다. 

* 리스트 삭제 총정리 

del, remove, pop ( : 예외 발생 주의) 

2. 튜플 (tuple) 

: 순서 O, 중복 O, 수정 X, 삭제 X 

- 선언 

a = ()
b = (1,)
c = (1, 2, 3, 4)
d = (10, 100, ('a', 'b', 'c'))

이와 같이 여러 방법으로 튜플을 선언할 수 있다. 

- 삭제 : 불가 

del c[2] # -> 삭제 불가

 TypeError: 'tuple' object doesn't support item deletion 

튜플은 수정이나 삭제를 할 수 없다. 

- 인덱싱 

print(c[2])
print(c[3])
print(d[2][2])

 3 
 4 
 c 

- 슬라이싱 

print(d[2:])
print(d[2][0:2])

 (('a', 'b', 'c'),) 
 ('a', 'b') 

- 연산 

print(c + d)
print(c * 3)

 (1, 2, 3, 4, 10, 100, ('a', 'b', 'c')) 
 (1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4) 

- 튜플 관련 함수 

z = (5, 2, 1, 3, 1)
print(z)
print(3 in z)
print(z.index(5))  # 인덱스 값을 반환 
print(z.count(1))  # 1 이 몇개가 있냐

 (5, 2, 1, 3, 1) 
 True 
 0 
 2 

코드 - 패캠 수업 코드 참고 (패캠 수업 정리)

<이전 글>

https://silvercoding.tistory.com/33

* 데이터 타입 한눈에 보기 

v_str = "Niceman"
v_bool = True
v_str2 = "Goodboy"
v_float = 10.3
v_int = 7
v_dict = {
    "name" : "Kim", 
    "age" : 25
}
v_list = [3, 5, 7]
v_tuple = 3, 5, 7
v_set = {7, 8, 9}

print(type(v_str))
print(type(v_bool))
print(type(v_str2))
print(type(v_float))
print(type(v_int))
print(type(v_dict))
print(type(v_list))
print(type(v_tuple))
print(type(v_set))

 <class 'str'> 
 <class 'bool'> 
 <class 'str'>  
 <class 'float'> 
 <class 'int'> 
 <class 'dict'> 
 <class 'list'> 
 <class 'tuple'> 
 <class 'set'> 

1. 숫자형 

<숫자형 연산자 참고> 

 https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex

i1 = 39 
i2 = 939 
big_int1 = 999999999999999999999999999999999999999
big_int2 = 777777777777777777777777777777777777777
f1 = 1.234 
f2 = 3.1415
f3 = .5
f4 = 10.

print(i1 * i2)
print(big_int1 * big_int2)
print(f1 ** f2)
print(f3 + i2)

 36621 
 777777777777777777777777777777777777776222222222222222222222222222222222222223       
 1.93582713947248 
 939.5 

result = f3 + i2 
print(result, type(result))

 939.5 <class 'float'> 

int + float를 하면 자동적으로 float 타입이 된다. 

a = 5. 
b = 4
c = 10

print(type(a), type(b))
result2 = a + b 
print(result2)

 <class 'float'> <class 'int'> 
 9.0 

- 숫자형 형변환 (유연한 형변환 가능) 

* int, float, complex(복소수 : 잘 안씀) 

print(int(result2))
print(float(c))
print(complex(3))
print(int(True))
print(int(False))
print(int('3'))
print(complex(False))

 9 
 10.0 
 (3+0j) 
 1 
 0 

True, False는 각각 정수형으로 변환하면 1, 0 이 된다. 
 3 
 0j 

이처럼 파이썬은 유연한 형변환을 지원한다 .

y = 100 
y += 100 
print(y)

 200 

<수치 연산 함수 참고> 

https://docs.python.org/3/library/math.html

print(abs(-7))
n, m = divmod(100, 8)  # 몫, 나머지 
print(n, m)

 7 

abs() 함수는 절댓값을 씌워주는 함수이다. 
 12 4 

divmod()함수는 몫과 나머지를 동시에 반환해 준다. 

import math
print(math.ceil(5.1))  # 이 숫자보다 크면서 가장 작은 정수 
print(math.floor(3.874))  # 이 숫자보다 작으면서 가장 큰 정수

 6 
 3 

math.ceil() : 인자에 들어간 숫자보다 크면서 가장 작은 정수 

math.floor : 인자에 들어간 숫자보다 작으면서 가장 큰 정수 

2. 문자열 

str1 = "I am a geak!"
str2 = "NiceGirl"
str3 = ""
str4 = str()

print(len(str1), len(str2), len(str3), len(str4))  # 공백 포함

 12 8 0 0 

공백을 포함하여 문자열의 개수를 세는 len() 함수

escape_str1 = "Do you have a \"big collection\"?"
print(escape_str1)
escape_str2 = "Tab\tTab\tTab"
print(escape_str2)

 Do you have a "big collection"? 

같은 종류 따옴표를 안에 넣기 위하여 이스케이프 문자를 사용한다. 

 Tab     Tab     Tab 

- Raw String

raw_s1 = r'C:\Programs\Test\Bin'
print(raw_s1)
raw_s2 = r"\\a\\a"
print(raw_s2)

 C:\Programs\Test\Bin 
 \\a\\a 

rwa string으로 이스케이프문 없이 그대로 출력이 가능하다. 

- 멀티라인 : 다음줄과 이어진다. 

multi = \
"""
문자열 
멀티라인 
테스트
"""
print(multi)

 문자열 
 멀티라인 
 테스트 

- 문자열 연산 

str_o1 = '*'
str_o2 = 'abc'
str_o3 = 'def'
str_o4 = 'Niceman'

print(str_o1 * 100)
print(str_o2 + str_o3)
print(str_o1 * 3)
print('a' in str_o4)
print('f' in str_o4)
print('z' not in str_o4)

 **************************************************************************************************** 
 abcdef 
 *** 
 True 
 False 
 True 

문자열에 숫자를 곱하거나, 문자열끼리 더하는 연산이 가능하다. 

- 문자열 형변환 

print(str(77) + 'a')
print(str(10.4))

 77a 
 10.4 

- 문자열 함수

<문자열 함수 참고> 

https://www.w3schools.com/python/python_ref_string.asp

a = 'niceman'
b = 'orange'

print(a.islower())  # 소문자인지 : Bool 반환
print(b.endswith('e'))  # e로 끝나는지 : Bool 반환
print(a.capitalize())  # 첫 글자를 대문자로 
print(a.replace('nice', 'good'))  # nice를 good으로 대체해라
print(list(reversed(b)))  # 뒤집어서 리스트로 반환하라

 True 

 True 
 Niceman 
 goodman 
 ['e', 'g', 'n', 'a', 'r', 'o'] 

- 문자열 슬라이싱 

a = 'niceman'
b = 'orange'

print(a[0:3])
print(a[0:4])
print(a[0:len(a)])
print(a[:4])
print(b[0:4:2])
print(b[1:-2])
print(b[::-1])

 nic 
 nice 
 niceman 
 nice 
 oa 
 ran 
 egnaro 

 a[0:n] 일 때 0번째 글자부터 n-1번째 글자까지를 반환한다. 

코드 - 패캠 수업 코드 참고 (패캠 수업 정리)

<참고 링크>

https://www.python-course.eu/python3_formatted_output.php

1. 기본 출력 

print('Hello Python!')
print("Hello Python!")
print("""Hello Python!""")
print('''Hello Python!''')

 Hello Python! 
 Hello Python! 
 Hello Python! 
 Hello Python! 

작은따옴표, 큰따옴표 1개 혹은 3개로 감싸준다. 

2. seperator 옵션 사용 

print('T', 'E', 'S', 'T', sep='')
print('2019', '02', '19', sep='-')
print('niceman', 'google.com', sep="@")

 TEST 
 2019-02-19 
 niceman@google.com 

print함수의 인자에 sep= 옵션을 넣어주면 sep에 들어가는 문자가 중간에 들어 가 문자열을 이어 준다. 

3. end 옵션 사용 

print('Welcom To', end=' ')
print('the black prade', end=' ')
print('piano notes')

 Welcom To the black prade piano notes 

end옵션은 defalut가 \n으로 들어 가 있어 사용하지 않으면 자동으로 줄바꿈이 됐었다. end=' ' 를 사용하면 위와 같이 그 다음 줄이 호출될 때 띄어 쓰기 한 번 후 출력이 된다. 

4. format 사용  { }. ( ) 

print('{} and {}'.format('You', 'Me'))
print("{0} and {1} and {0}".format('You', 'Me'))
print('{a} and {b}'.format(a='You', b='Me'))

 You and Me 
 You and Me and You 
 You and Me 

format 함수로 문자열에 값을 넣어줄 수 있다. 

print("%s favorite number is %d" % ('Silver', 7))
print("Test1: %5d, Price: %4.2f" % (776, 6534.123))

 Silver favorite number is 7 
 Test1:   776, Price: 6534.12 

* %s : 문자, %d : 정수, %f : 실수

%를 사용하여 글자수나, type에 대해 명시적으로 기입해 놓을 수 있다. 

print("Test1: {0: 5d}, Price: {1: 4.2f}".format(776, 6534.123))
print('Test1: {a: 5d}, Price: {b: 4.2f}'.format(a=776, b=6534.123))

 Test1:   776, Price:  6534.12 
 Test1:   776, Price:  6534.12 

위와 같이 format을 사용하여 글자수와 type을 지정해줄 수도 있다. 

5. 이스케이프 문자 

print("'you'")
print('\'you\'')
print('"you"')
print("""'you'""")
print('\\you\\\n')
print('\t\t\ttest')

 'you' 

종류가 다른 따옴표를 사용하면 이처럼 안에 있는 따옴표로 나오도록 할 수 있다. 

 'you' 

종류가 같은 따옴표를 사용하려면 이스케이프 문자를 사용하여 출력한다. 

 "you" 
 'you' 

 \you\ 

                              
                        test 

\\, \n, \t 을 사용하여 \, 줄바꿈, 탭을 실행할 수도 있따. 

* 이스케이프 문자 

\n : 개행

\t : 탭

\\ : 문자

\' : 문자

\" : 문자

\r : 캐리지 리턴

\f : 폼 피드

\a : 벨 소리

\b : 백 스페이스

\000 : 널 문자

...