객체지향 프로그래밍(Object-Oriented Programming, OOP)은 소프트웨어를 설계하고 구현하는 데 사용되는 중요한 프로그래밍 패러다임 중 하나입니다. 이 패러다임은 프로그램을 "객체"라고 불리는 독립적인 개체로 나누고, 이러한 객체들 간의 상호작용을 통해 프로그램을 구성하는 개발 방법론입니다.

• 절차지향프로그래밍은 프로그램을 작성할 때 일련의 절차 또는 단계에 따라 코드를 구성하는 방식입니다. 이러한 단계나 절차들은 주로 함수나 서브루틴으로 나누어져 있으며, 각각의 함수는 특정한 작업을 수행합니다. 주로 '입력 - 처리 - 출력'의 순차적인 절차를 따르며, 코드를 위에서부터 아래로 실행하면서 데이터를 처리하는 방식으로 동작합니다. C 언어와 같은 프로그래밍 언어는 주로 절차지향적인 스타일을 따릅니다.

2. 클래스 만들기

class 클래스이름:
    # 클래스 속성(멤버 변수) 정의
    속성1 = 초기값1
    속성2 = 초기값2

    # 생성자 메서드 (생략 가능)
    def __init__(self, 매개변수1, 매개변수2, ...):
        # 인스턴스 속성 초기화
        self.속성1 = 매개변수1
        self.속성2 = 매개변수2

    # 메서드(멤버 함수) 정의
    def 메서드1(self, 매개변수1, 매개변수2, ...):
        # 메서드 동작 정의
        pass

    def 메서드2(self, 매개변수1, 매개변수2, ...):
        # 메서드 동작 정의
        pass

3. 객체(인스턴스) 생성

Rucy = Dog() # Rucy라는 강아지이름에 Dog()클래스 이름을 작성
print(Rucy)
print(type(Rucy))

PPomi = Dog()
print(PPomi)
print(type(PPomi))

객체를 생성한 후에는 객체의 속성을 초기화할 수 있습니다. 이를 위해 . 연산자를 사용하여 객체의 속성에 접근하고 값을 할당합니다.

class Dog :
# 변수 초기화(기본값)
  name = ''
  age = 0
  family = ''

#메소드
#self는 자기자신을 나타내는 객체

  def eat(self) : # 첫 파라미터에는 self를 항상 넣어야함 // 파라미터가 없을때도 self를 넣어야함
      print('사료를 먹습니다.')
      
Rucy = Dog()
Rucy.name = '루시'
Rucy.age = 14
Rucy.family = '포메'


PPomi = Dog()
PPomi.name = '뽀미'
PPomi.age = 7
PPomi.family = '폼피츠'



print(Rucy.name)
print(Rucy.age)
print(Rucy.family)

print(PPomi.name)
print(PPomi.age)
print(PPomi.family)

루시
14
포메
뽀미
7
폼피츠

객체의 메서드를 호출하려면 객체와 메서드를 . 연산자를 사용하여 호출합니다.

Rucy.eat()
PPomi.eat()

사료를 먹습니다.
사료를 먹습니다.

6. 생성자

파이썬에서 생성자(Constructor)는 클래스의 인스턴스가 생성될 때 자동으로 호출되는 특별한 메서드입니다. 생성자는 객체의 초기화를 담당하며, 객체가 생성될 때 필요한 속성을 초기화하고 설정하는 역할을 합니다. 파이썬에서 생성자 메서드는 __init__라고 이름이 정해져 있습니다.

class 클래스이름:
    def __init__(self, 매개변수1, 매개변수2):
        self.속성1 = 매개변수1
        self.속성2 = 매개변수2

class Dog :
# 생성자 (메소드)
    def __init__(self): ## 첫 파라미터에는 self // self 자기자신
      print(self, 'init 호출!')
      
Rucy = Dog()

<__main__.Dog object at 0x7b56e7e651e0> init 호출!

class Dog:
  def __init__(self):
    self.name = ''
    self.age = 0
    #a = 10 # 일반 변수를 만들면 다른 메소드에서 가져다 쓸 수없다 
    # => self를 이용해 어디 출신의 속성인지 알기위해 사용

Rucy = Dog()
print(Rucy)
print(Rucy.name)
print(Rucy.age)

<__main__.Dog object at 0x7b56e7e65150>

0

class Dog:
  def __init__(self, name, age, family='족보 없음'): #생성자(self, 매개변수1, 매개변수2, ...)
    self.name = name
    self.age = age
    self.family = family
    
    
Rucy = Dog('루시', 14, '포메')
print(Rucy.name)
print(Rucy.age)
print(Rucy.family)    


PPomi = Dog('뽀미', 7)
print(PPomi.name)
print(PPomi.age)
print(PPomi.family)

루시
14
포메

뽀미
7
족보 없음

메서드(Method)는 객체지향 프로그래밍(OOP)에서 사용되는 함수와 비슷한 개념이지만, 클래스 내부에 정의되어 특정 객체에 연결된 함수입니다. 메서드는 해당 클래스의 모든 객체에서 공유되며, 객체의 동작을 정의하거나 특정 작업을 수행하는 데 사용됩니다.

7-1. 메서드 정의

class Counter:
  # 생성자
  def __init__(self) :
    self.num = 0
  # 메서드
  def increment(self):
    self.num += 1
  def decrement(self):
    self.num -= 1
  def current_value(self):
    return self.num
  def reset(self):
    self.num = 0

# 현재 num의 값을 출력 (단 num 출력시 method로 출력)
# num의 값을 1증가
# num의 값을 1증가
# num의 값을 1증가
# num의 값을 1감소    #메소드 생성
# 현재 num의 값을 출력 #메소드 생성

KBbank = Counter()  # 현재 값 = 0

KBbank.increment()  # num 1증가
KBbank.increment()
KBbank.increment()
KBbank.decrement()  # num 1감소


print(f'현재 대기인원 : {KBbank.current_value()}') # 출력

현재 대기인원 : 2

HanaBank = Counter() # 현재 값
print(f'현재 대기인원 : {HanaBank.current_value()}')

HanaBank.increment()  # num +1 증가
HanaBank.increment()  # num +1 증가
HanaBank.increment()  # num +1 증가
HanaBank.increment()  # num +1 증가
HanaBank.increment()  # num +1 증가
HanaBank.increment()  # num +1 증가
HanaBank.decrement()  # num -1 감소
print(f'현재 대기인원 : {HanaBank.current_value()}') #카운터 값 출력


HanaBank.reset() # 카운터값 리셋
print(f'현재 대기인원 : {HanaBank.current_value()}') # 출력 : 0

현재 대기인원 : 0
현재 대기인원 : 5
현재 대기인원 : 0

• 인스턴스 메서드(Instance Method) : 객체의 상태를 조작하거나 객체에 특정 작업을 수행하는 메서드입니다. 대부분의 클래스 내부의 메서드는 인스턴스 메서드입니다. 위의 예제에서 보여진 _init_ 메서드도 인스턴스 메서드입니다.
• 클래스 메서드(Class Method) : 클래스 레벨에서 동작하며, 모든 인스턴스가 공유하는 메서드입니다. 클래스 메서드는 @classmethod 데코레이터를 사용하여 정의하며, 첫 번째 매개변수로 cls를 사용합니다.
• 정적 메서드(Static Method) : 특정 클래스나 인스턴스와 관련이 없는 메서드로, 클래스 내부에 정의되어 있지만 클래스나 인스턴스와 독립적으로 호출될 수 있습니다. 정적 메서드는 @staticmethod 데코레이터를 사용하여 정의합니다.

class Math:
  def add(self, x, y):
    return x + y
  def multiply(self, x, y):
    return x * y
    

math = Math()

result1 = math.add(10, 3)
print(result1)
result2 = math.multiply(10, 3)
print(result2)

13
30

class Calculater:

  num = 1 # 클래스 변수 (클래스 내부에 들어있음) : 객체를 생성하지 않아도 메모리에 올라감

  def add(self, x, y):
    return x + y

  @classmethod
  def subtract(cls, x, y):
    return x - y - cls.num  # cls : 클래스 변수(num)을 가져다가 씀

  @staticmethod       #인스턴스 메소드 -> 객체생성 해야함
  def multiply(x, y):
    return x * y

# 인스턴스 메서드
# 인스턴스 메서드는 객체를 생성해야만 사용가능
calc = Calculater()   #객체 생성
result1 = calc.add(5, 3)
print(result1)

# 클래스 메서드
# 객체를 생성할 필요가 없음
# 클래스명으로 호출
result2 = Calculater.subtract(10, 4) # 10 - 4 - cls.num(클래스변수)
print(result2)

# 정적 메서드
# 클래스 명으로 호출가능
# 클래스 명으로 불러올 수 있으나 주변속성을 갖다 쓸 수 없음(독립적임)
result3 = Calculater.multiply(5, 3)
print(result3)

8
5
15

클로저(Closure)는 프로그래밍 언어에서 중요한 개념 중 하나로, 함수와 그 함수가 참조하는 외부 변수(또는 자유 변수) 사이의 관계를 나타냅니다. 클로저는 함수의 내부에서 정의된 함수로, 내부 함수가 외부 함수의 변수에 접근할 수 있고, 외부 함수는 내부 함수를 반환할 수 있습니다. 이로 인해 함수와 그 함수가 참조하는 상태(변수)를 함께 저장하고 유지할 수 있습니다.

def mul2(n):
    return n * 2

print(mul2(10))
print(mul2(5))

20
10

def mul5(n):
    return n * 5

print(mul5(10))
print(mul5(5))

50
25

class Mul:
  def __init__(self, m):
    self.m = m
  def mul(self, n):
    return self.m * n
    
    
mul2 = Mul(2)
print(mul2.mul(10))
print(mul2.mul(5))

20
10

class Mul:
    def __init__(self, m):  # 객체를 생성할 때 자동으로 호출
        print('생성자 호출')
        self.m = m

    def __call__(self, n):  # 객체를 실행할 때 자동으로 호출
        print('call 호출')
        return self.m * n


mul2 = Mul(2)
mul2(10)

생성자 호출
call 호출
20

# 클로저 사용하기

#클로저 서용하기
def mul(m):       #외부함수
  def wrapper(n): #내부함수(클로저)
    return m * n
  return wrapper #함수안에 함수 바깥쪽 함수에 의해서 내부함수 리턴
  
  
mul2 = mul(2)   # m = 2인 wrapper 함수가 mul2에 저장
print(mul2(10)) # m = 2, n = 10인 wrapper 함수가 실행

mul5= mul(5)
print(mul5(10))

20
50

데코레이터(Decorator)는 파이썬에서 함수나 메서드의 동작을 수정하거나 확장하기 위한 강력한 도구입니다. 데코레이터는 함수나 메서드를 래핑하거나 감싸서 추가 기능을 제공하며, 코드 재사용성과 가독성을 향상시킵니다. 데코레이터는 @ 기호를 사용하여 함수나 메서드 위에 적용됩니다.

# 데코레이터 만들기
def func1(a,b):
    result = a + b
    return result

def func2(a, b):
    result = a * b
    return result

def elapsed(func):
    def wrapper(a, b):
          start = time.time()
          print('함수가 시작되었습니다.')

          result = func(a, b) # elapsed(func)에 전달 받은 함수의 결과를 전달

          end = time.time()
          print(f'함수 수행시간{end - start}')
          return result
    return wrapper    
    
    
deco1 = elapsed(func1)
result = deco1(10, 3)
print(result)


deco2 = elapsed(func2)
result = deco2(10, 3)
print(result)

함수가 시작되었습니다.
함수 수행시간8.082389831542969e-05
13
함수가 시작되었습니다.
함수 수행시간2.6702880859375e-05
30

@elapsed #클로저 이름
def func1(a,b):
    result = a + b
    return result

@elapsed
def func2(a, b):
    result = a * b
    return result

result = func1(10, 3)
print(result)

result = func2(10, 3)
print(result)

함수가 시작되었습니다.
함수 수행시간0.0002522468566894531
13
함수가 시작되었습니다.
함수 수행시간0.00047206878662109375
30

1. 콜백함수(callback function)

.

def callback_func(func):
  for i in range(5):
    func()

def print_hello():
    print('안녕!')

print_hello()

안녕!

callback_func(print_hello)

안녕!
안녕!
안녕!
안녕!
안녕!

def callback_func(func, num):
  for i in range(num):
    func(i)

def print_hello(num):
  print('푸바오', num)

def print_hi(num):
  print('대나무', num)

callback_func(print_hello , 5)
callback_func(print_hi, 3)

푸바오 0
푸바오 1
푸바오 2
푸바오 3
푸바오 4
대나무 0
대나무 1
대나무 2

2. 람다 함수(Lambda Function)

람다 함수는 파이썬에서 익명의 간단한 함수를 생성하기 위한 특별한 구문입니다. "익명의 함수"라는 것은 함수에 고유한 이름이 지정되지 않았음을 의미합니다. 람다 함수는 일반적인 함수(def를 사용하여 정의)와는 달리, 한 줄로 표현되는 짧고 간결한 함수를 생성할 때 주로 사용됩니다.

lambda arguments: expression

arguments: 람다 함수에 전달되는 인자들입니다.

expression: 반환할 표현식입니다. 이 표현식의 값이 람다 함수가 호출될 때 반환됩니다.

간결성: 람다 함수는 간단한 연산이나 작은 기능을 가진 함수를 간결하게 표현하는 데 유용합니다.

익명성: 람다 함수에는 명시적인 이름이 부여되지 않습니다. 그러나 필요에 따라 변수에 할당할 수 있습니다.

일회성: 일반적으로 특정 작업을 위한 일회성 함수로 사용됩니다.

def square(x):
  return x**2

print(square(4))

16

squre = lambda x : x**2 # x : 표현 // ex) 4 : 4**2
print(square(4))
print(square(5))
print((lambda x: x ** 2)(4))

16
25
16

비교

def return_age(x):
    return x['age'] # x의 age를 꺼내서 입력
    
people = [{'name': '푸바오', 'age': 3}, {'name': '후이바오', 'age': 1}, {'name': '루이바오', 'age': 1}]
sorted_people = sorted(people, key=return_age)
print(sorted_people)

people = [{'name': '푸바오', 'age': 3}, {'name': '후이바오', 'age': 1}, {'name': '루이바오', 'age': 1}]
sorted_people = sorted(people, key=lambda x: x['age']) # age 오름차순
print(sorted_people) # 람다는 메모리에 저장되지 않음

3. 람다가 유용하게 사용되는 대표적인 함수

3-1. filter 함수

filter()는 파이썬의 내장 함수로, 주어진 함수의 조건을 만족하는 항목만으로 이루어진 이터레이터를 반환합니다. 이 함수는 주로 리스트나 다른 순차적인 데이터 타입에서 특정 조건을 만족하는 항목들만을 필터링할 때 사용됩니다.

function: 각 항목에 적용되는 함수. 이 함수는 하나의 인자를 받아 참(True) 또는 거짓(False)을 반환합니다.

iterable: 필터링 될 이터러블 객체 (예: 리스트, 튜플, 문자열 등)

li = [2, 5, 7, 10, 15, 17, 20, 22, 25, 28]


def even(n):
    if n%2 == 0:
        return True
    else:
        return False
        
# filter(함수값, 데이터) True만 출력
result = list(filter(even, li)) #True일때만 필터에서 바깥으로 내보냄
print(result) # True값만 가진 요소만 라스트로 만들어냄

# 람다로 간결한 함수로 생성

li = [2, 5, 7, 10, 15, 17, 20, 22, 25, 28]
result2 = list(filter(lambda n : n%2==0, li)) #람다로 익명의 함수를 생성
print(result2)

3-2. map 함수

map(각각 어떻게 바꿀 것인가, [바꿀 입력 값])

• map()는 파이썬의 내장 함수로, 주어진 함수를 이터러블의 모든 항목에 적용하여 결과를 반환하는 이터레이터를 생성
• 이 함수는 주로 리스트나 다른 순차적인 데이터 타입의 항목 각각에 함수를 적용할 때 사용됩니다.
• map() 함수는 여러 개의 이터러블을 동시에 처리할 수 있습니다.

function: 각 항목에 적용될 함수.

iterable: function에 의해 처리될 이터러블 객체(예: 리스트, 튜플, 문자열 등). map() 함수는 여러 개의 이터러블을 동시에 처리할 수 있습니다.

numbers = [1, 2, 3, 4, 5]
squared_numbers = list(map(lambda x: x**2, numbers))
print(squared_numbers)

[1, 4, 9, 16, 25]

list1 = [1, 2, 3]
list2 = [4, 5, 6]
summed = list(map(lambda x, y : x + y, list1, list2)) #list1과 list2를 x y에 각각뽑아서 입력해줌
print(summed)

[5, 7, 9]

# map은 여러개의 이터러블을 동시에 처리
words = ["apple", "banana", "cherry"]
uppercase_words = list(map(str.upper, words)) # str.upper : 대문자 변환
print(uppercase_words)

['APPLE', 'BANANA', 'CHERRY']

1. 스코프(scope)

파이썬에서 변수의 범위(scope)는 해당 변수가 프로그램 내에서 참조되고 변경될 수 있는 영역을 의미합니다. 파이썬의 변수 범위는 크게 네 가지로 분류됩니다.

1-1. Local(지역): Local scope는 변수가 함수 내에서 정의될 때 해당 함수 내부를 의미합니다.

- 함수내에 저장된 변수

def local_example():
    local_var = "로컬 변수"
    print(local_var)

local_example()

로컬 변수

1-2. Enclosing(둘러싼 범위): Enclosing scope는 내부 함수에서 외부 함수의 변수를 참조할 때 해당 외부 함수 범위를 의미합니다.

def outer_function():
    enclosing_var = "둘러싼 범위 변수"
    def inner_function():
        print(enclosing_var)
    
    inner_function()

outer_function()

둘러싼 범위 변수

#inner_function()
outer_function() # 외부함수는 내부함수를 부를 수 있음

둘러싼 범위 변수

1-3. Global(전역 범위): Global scope는 변수가 스크립트의 최상위 수준에서 정의될 때 전체 스크립트 파일 내에서 해당 변수를 의미합니다.

global_var = '글로벌 변수'

def test_global_scope():
    print(global_var)

test_global_scope()

글로벌 변수

global_var = 10
def modify_global():
  global_var = 20     # 지역변수 우선
  print(global_var)

modify_global()   # 20
print(global_var) # 10

global_var = 10
def modify_global():
  global global_var # 글로벌변수를 수정하려면 global로 전역변수와 같은 변수를 불러옴
  global_var = 20   # 글로벌 값을 수정
  print(global_var)

modify_global()   # 20
print(global_var) # 20

1-4. Built-in(내장 범위):

Built-in scope는 파이썬의 내장 함수와 모듈들이 속하는 범위입니다. 예를 들어, print(), len() 같은 함수들이 여기에 해당됩니다.

# 빌트인 함수
print(print)
print(len)
print(sum)

<built-in function print>
<built-in function len>
<built-in function sum>

2. 변수의 범위 탐색 순서

1. Local scope

2. Enclosing scope

3. Global scope

4. Built-in scope

따라서 지역 범위에 동일한 이름의 변수가 없으면 파이썬은 둘러싼 범위를 확인하고, 그 다음으로 전역 범위, 마지막으로 내장 범위를 확인합니다.

이렇게 변수의 범위를 이해하고 관리하는 것은 코드의 가독성과 유지 보수성을 높이고, 예기치 않은 오류를 방지하는 데 중요합니다.

사용자 정의 함수란 사용자가 특정 작업을 수행하기 위해 직접 작성한 함수를 의미합니다. 파이썬에는 많은 내장 함수들이 있지만, 때로는 우리의 요구사항에 맞게 동작하는 함수를 직접 만들어야 할 때가 있습니다. 이때 사용자 정의 함수를 작성하게 됩니다. 기본적인 구조는 아래와 같습니다.

def 함수명(매개변수1, 매개변수2, ...):
    # 함수 내용
    return 결과값

2. 매개변수와 반환 값이 없는 함수

def func1(): #함수만 불러주면 알아서 호출
    print('처음으로 만드는 함수')
func1() #메모리를 차지하고 있고 호출하면 불러올 수 있다.

처음으로 만드는 함수

for i in range(5):
  func1()

처음으로 만드는 함수
처음으로 만드는 함수
처음으로 만드는 함수
처음으로 만드는 함수
처음으로 만드는 함수

3. 매개변수가 있고 반환 값이 없는 함수

def func2(num):
  print(f'입력받은 숫자 {num}')
  
func2(10)
func2(5)

입력받은 숫자 10
입력받은 숫자 5

def func3(start, end):
  sum = 0
  for i in range(start, end + 1):
      sum = sum + i
  print(f'{start}부터 {end}까지의 합 : {sum}')
  
func3(1, 100)

1부터 100까지의 합 : 5050

4. 반환 값이 있는 함수

def func4():
  print('안녕') # return이 없기때문에 아무 값도 줄 수없어 변수에 아무것도 담기지 않음.

>> 출력 값 없음

a = func4()
print(f'a에 저장된 값: {a}')

안녕
a에 저장된 값: None

def func5():
 '★'
a= func5()
print(a)

None

def func5():
  return '★' # return을 이용해 변수에 값을 담음 func5()는 출력에만 사용하고 저장은 되지않음

star = func5()
print(f'star에 저장된 값 : {star}')

star에 저장된 값 : ★

def func6(num1, num2):
  sum = num1 + num2
  return sum #sum 값을 result에 담음
  
result = func6(10, 5)
print(result)

15

• None은 파이썬에서 특별한 값으로, 아무런 값이 없음을 표현하는 데 사용됩니다. 다른 언어에서의 null 또는 nil과 유사한 개념입니다.
• None은 파이썬의 내장 상수이며, 그 자체로 데이터 타입이 NoneType입니다. 모든 None은 동일하므로, 두 개의 None 값을 비교할 때 항상 True를 반환합니다.

1. 기본 초기값 설정: 변수를 초기화할 때 아무런 값이 할당되지 않았음을 나타내기 위해 None을 사용할 수 있습니다.

variable = None

2. 함수의 반환 값으로 사용: 함수에서 특정 조건에서 아무런 값도 반환하지 않아야 할 때 None을 사용합니다. 사실, 함수에서 return 문이 생략되거나 없으면 기본적으로 None을 반환합니다.

def my_function(x): # x값에 값이 들어가게 되면
  if x > 10 :       # 10과 비교해서
    return x        # 조건에 맞으면 반환값이 나옴
# x가 10 이하일 때는 아무런 값도 반환하지 않습니다. 
#실제로는 None이 반환됩니다.

my_function(11)
my_function(2)  # 리턴이 없어 반환값이 안나옴

11

# 처음 코드 수정
def my_function(x):
  if x > 10 :
    return x
  else:
    return None # 조건이 안맞을 경우의 리턴값도 만들어야 반환값이 나옴

a = my_function(15)
print(a)

a = my_function(1)
print(a)

15
None

3. 선택적 매개변수의 기본값: 함수의 매개변수에 기본값으로 None을 할당하여 선택적으로 인자를 전달받을 수 있게 만들 수 있습니다.

# 선택적 매개변수의 기본값
def hello(message = None):
  if message is None:
    print('Hello') # None이면 Hello 출력
  else:
    print(message)
    
    
    
hello('안녕하세요')
hello()

안녕하세요
Hello

4. 값의 존재 여부 확인: None을 사용하여 값의 존재 여부를 확인할 수 있습니다.

None을 검사할 때는 == 대신 is 연산자를 사용하는 것이 좋습니다.

is는 객체의 동일성을 검사하는 반면, ==는 객체의 동등성을 검사하기 때문입니다.

# 값의 존재 여부 확인: None을 사용하여 값의 존재 여부를 확인할 수 있습니다.
def get_data_from_database():
  pass                        # pass를 사용하면 나중에 이것을 채우던가 넘어가는 용도

data = get_data_from_database()
print(data)

if data is None :
  print('데이터 수신 못함')
else :
  print('데이터 수신 받음')

None
데이터 수신 못함

li1 = [1, 2, 3, 4, 5]
li2 = [1, 2, 3, 4, 5]
li3 = li1

# 서로 다른 개체(객체 비교).  is는 객체의 동일성을 검사
result1 = li1 is li2
print(result1)                  # False

result2 = li1 is li3            # True
print(result2)

# 값이 같은 객체(값 비교).  ==는 객체의 동등성을 검사
result3 = li1 == li2
print(result3)                  # True

6. 기본값이 설정된 매개변수

def func6(num1, num2):
  sum = num1 + num2
  return sum
  
print(func6(10, 3))

13

def func6(num1=1, num2=1):
  sum = num1 + num2
  return sum

print(func6())
#출력: 2

print(func6(10)) # num1에 10이 들어가고 , num2 = 1이 그대로 출력됨 
#출력: 11

print(func6(10, 3)) # num1에 10이 들어가고, num2에 3이 들어감
#출력: 13

print(func6(num2=10)) # num1을 비우고 num2에만 값을 넣고 싶을때
#출력: 11

7. 가변 매개변수

7-1 . 패킹과 언패킹

-  언패킹(Unpacking) : 값을 풀어서 적는것

def get_Total(number1, number2, number3):
     return number1 + number2 + number3

- 패킹(Packing) : 값을 묶어서 적는것

1. * 을 사용하면 get_total이 튜플형태로 한번에 들어간다. => 튜플 형태로 저장

2.  자동으로 여러개의 값을  받기 때문에 리스트로 받아짐 

3. 여러개의 값을 하나로 묶어서 전달하게 되면, packing으로 인해 첫번째 방에 통채로 들어가게 된다.
4. 즉, 결과는 다음과 같다 ([1, 2, 3, 4, 5],) 튜플 안 첫번째 방

def get_total(*numbers): # *이 있다면 패킹 : 여러개 선언해야 하는것을 한번에 묶어서 받음
    # 외부에서 전달받은 값들이 numbers(튜플)에 튜플형태로 저장된다.
    print(type(numbers))
    total = 0
    for number in numbers:
        total += number

    return total
    
    
# *을 사용하면 get_total이 튜플형태로 한번에 들어간다
numbers = [1, 2, 3, 4, 5]
total = get_total(numbers)
print(total) # TypeError: unsupported operand type(s) for +=: 'int' and 'list'

- 따라서 내부의 요소는 각각 전달하고 싶다면, 앞에 *을 작성해야한다.

- 데이터가 묶어서 왔을때 *을 사용

numbers = [1, 2, 3, 4, 5]
total = get_total(*numbers)# 데이터가 묶어서 왔을때 *을 사용
print(total)
# # 튜플로 한번에 값을 받음

- 함수를 호출할 때 *를 사용하면 시퀀스(리스트, 튜플 등)의 요소를 개별적인 위치 인자로 풀어서 전달할 수 있습니다.

# 함수 내부에서는 매개변수를 튜플로 처리
def func7(*args):	# *를 써서 데이터를 입력하면 튜플로 입력된다.
    result = 0
    # print(args)
    for i in args:
        result += i
    return result
    
print(func7())
print(func7(10, 30, 20, 70))
print(func7(10))

def add(a, b, c):
    return a + b + c

numbers = [1, 2, 3]
print(add(*numbers))  # 출력: 6

- 반드시 받아야하는 매개변수는 패킹앞에 작성하기

# 국어 영어 수학 점수를 전달받은 뒤 총점을 출력하는 함수
packing으로 제작하기
def get_total(name, *scores): # 반드시 받아야하는 매개변수는 packing앞에 작성한다
    print(name + '님')
    total = 0
    for score in scores:
        total += score
    return total

scores= [100,40,50]
print(get_total('류니', 100, 40, 50))

kwargs (keyword arguments)

# # keyword arguments
#
# def introduce(**intro): #딕셔너리
#     print(type(intro))
#     print(f'name : {intro["name"]}')
#
#
# introduce(name="이정륜") # 딕셔너리로 보내려면 위에서 **kwargs
# introduce(**{'name':'이정륜'}) # 딕셔너리를 통채로 보내려면 딕셔너리 앞에 **

kwargs 예제 문제1) 

국어 영어 수학 점수의 평균 구하기
# kwargs로 선언


def score_av(**kwargs):
    all = sum(kwargs.values())
    av = all/3
    return av

print(score_av(**{'kor':80 , 'eng':90 , 'math': 70}))
def score_av(**kwargs):
    kor = kwargs['kor']
    eng = kwargs['eng']
    math = kwargs['math']
    return (kor+eng+math)/3

print(score_av(kor=80,eng=90,math=70))

kwargs 예제 문제 2)

 국어 영어 수학 점수의 평균 구하기
# 사용자가 원하는 자리수(round)에서 반올림해준다.
# 자리수를 받지 않았다면, 기본값을 리턴한다.
# 국어 영어 수학 점수의 평균 구하기
# kwargs로 선언

def average(**kwarg):
    if "round" in kwarg:
        kor, eng, math = kwarg.get('kor'), kwarg.get('eng'), kwarg.get('math')
        total = kor + eng + math
        ave = total/3
        if "round" in kwarg:
            return round(ave, kwarg['round'])
        return ave


print(average(kor=100, eng=30, math=22, round= 2))

8. 키워드 매개변수

def func8(id, name, age):
    print(f'아이디: {id}')
    print(f'이름: {name}')
    print(f'나이: {age}')

func8('Fubao', '푸바오', 3)
func8(id = 'apple', age=20, name='푸바오') # 값을 입력할때 변수 이름을 써주면 함수 호출순서가 달라도 됨

아이디 : Fubao
이름 : 푸바오
나이 : 3

아이디 : apple
이름 : 푸바오
나이 : 20

dic1 = {'id' : 'apple', 'name' : '푸바오', 'age' : 3}
func8(**dic1) # ** 값이 입력 // key값이 func8 함수의 데이터 입력값과 동일해야 값을 출력
func8(*dic1) # *를 key 입력

아이디 : apple
이름 : 푸바오
나이 : 3
아이디 : id
이름 : name
나이 : age

def func9(**args):
  #print(args)
  for i in args: # i에 키가 저장
    if i == 'id': # id값 뽑기
      userid = args[i]
  return userid
  
user = func9(id = 'apple', name = '푸바오', age = 20)
user

apple

9.여러개의 반환값

def func10(num1, num2):
  return num1 + num2
  
result1 = func10(10,3)
print(result1)

13

def func10(num1, num2):
  return num1 + num2, num1 - num2, num1 * num2, num1 / num2

result1, result2, result3, result4 = func10(10,3)
print(f'덧셈: {result1}, 뺄셈: {result2}, 곱셈: {result3}, 나눗셈: {result4}'

덧셈: 13, 뺄셈: 7, 곱셈: 30, 나눗셈: 3.3333333333333335

_, _, result3, _ = func10(10,3)  # 곱셈의 결과만 필요할때  '_' 이용하면 원하는 값만 출력
print(result3)

30

1. 리스트와 for 문

li1 = ['푸바오', '아이바오', '러바오', '루이바오', '후이바오']

for i in li1:
  print(i, end = " ")

푸바오 아이바오 러바오 루이바오 후이바오

# score 리스트에 저장된 점수가 60점 이상인 학생이 몇명인지 확인
score = [90, 30, 50, 60, 80, 70, 100, 40, 20, 10]
count = 0
for i in score:
  if i >= 60 :
    count = count + 1
    print(f'{i}점')
print(f'60점 이상인 학생의 수는 {count}명 입니다.')

90점
60점
80점
70점
100점
60점 이상인 학생의 수는 5명 입니다.

2. 딕셔너리와 for 문

dic1 = {'no':1, 'userid':'apple', 'name':'푸바오', 'hp':'010-1111-1111'}

for i in dic1:
    print(i, end=' ') # 키만 가져옴
    
for i in dic1.keys():
    print(i, end=' ') # 키만 가져옴

for i in dic1.values():
    print(i, end=' ') # 값만 가져옴

for i in dic1:
    print(dic1[i], end=' ') # 값만 가져옴

for i in dic1:
    print(dic1.get(i), end=' ') # 값만 가져옴

'''
.items() 메서드는 딕셔너리에서 사용되는 메서드입니다.
이 메서드는 딕셔너리의 키와 값을 쌍으로 하는 튜플들을 반환합니다.
일반적으로 이 메서드는 딕셔너리의 키와 값을 동시에 반복(iterate)하고자 할 때 사용됩니다.

'''

person = {'name' : '푸바오', 'age' : 3, 'city' : '용인'}

for key, value in person.items():
  print(key, ':', value) #튜플을 key와 value로 나누었다고 할 수있음.

name : 푸바오
age : 3
city : 용인

3. 컴프리헨션(Comprehension)

컴프리헨션(Comprehension)은 파이썬에서 리스트, 세트, 딕셔너리 등의 컬렉션을 간단하게 생성하거나 변형하는 방법 중 하나입니다. 컴프리헨션은 반복문과 조건문을 사용하여 간결하게 컬렉션을 생성하는 기법으로, 코드를 더 간단하고 가독성 좋게 작성할 수 있도록 도와줍니다.

3-1. 리스트 컴프리헨션

리스트 컴프리헨션은 새로운 리스트를 생성하는데 사용됩니다. 기존 리스트의 각 요소를 반복하면서 조건을 적용하여 새로운 리스트를 생성할 수 있습니다.

n = 10
result = [0 for i in range(n)]
print(result)

result = [i for i in range(n)]
print(result)
#arr 리스트에서 n을 뽑아 n을 출력

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
result = [n for n in arr]
print(result)

result = [n*n for n in arr]
print(result)
#arr 리스트에서 n을 뽑아 n 요소들끼리 서로 곱하여 출력

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

arr = ['푸바오', '아이바오', '러바오', '죽순']
result = [len(string) for string in arr]
print(result)
#arr 리스트에서 string을 뽑아 string의 len출력

[3, 4, 3, 2]

result = [n for n in range(10) if  n%2 == 0]
print(result)
# range(10) 에서 만약 2로 나누었을때 0으로 떨어지는 값을 n으로 뽑아 출력
# 조건식 n%2 ==0 가 앞으로 갈 경우 False일때 값을 내보낼 수가 없음.

[0, 2, 4, 6, 8]

# 양수는 리스트에 그대로 저장하고, 음수는 0으로 변환해서 저장하기
arr = [-1, 0, -4, 24, 5, -10, 2]
result = [n if n>0 else 0 for n in arr]
print(result)

[0, 0, 0, 24, 5, 0, 2]

arr = []
for i in range(1, 4):
  for j in range(1,3):
    arr.append(f'{i} * {j} = {i*j}')
print(arr)

['1 * 1 = 1', '1 * 2 = 2', '2 * 1 = 2', '2 * 2 = 4', '3 * 1 = 3', '3 * 2 = 6']

# 1.아래의 list에서 양수만 추출한 뒤 새로운 리스트에 담기
number_list = [10, 20, 30, -20, -3, 50, -70]
result_list = []
result_list = [number for number in number_list if number >0]
print(result_list)
# 
# number을 가져올건데 in number_list에서 가져올 것이다.
# 양수만 가져올 조건은 맨 뒤 입력 if 만약에 number>0보다 큰가?


#2. n개의 0으로만 채워진 list
message = '생성할 리스트의 칸 수 입력 : '
n = int(input(message))
zero_list = [0 for _ in range(n)]
print(zero_list)

# zero_list = [0] * n

#3. 제곱의 결과가 10보다 큰 결과만 담은 list
number_list = [1, -2, 3, -4, 5]
sq_list = [number for number in number_list if number**2> 10]
print(sq_list)
# number_list에서 number에 값을 하나하나 담고 number를 제곱했을때 10보다 크면 그때 number을 가져옴


#4.  0~9까지 중 3의 배수만 담은 list
number_list4 = [num for num in range(10) if num % 3 == 0]
print(number_list4)
# range(10)에서 num에 값을 담고 num을 3으로 나누었을때 0 이 나오는 값을 num에 담음

'''
arr = []
for i in range(1, 4):
  for j in range(1,3):
    arr.append(f'{i} * {j} = {i*j}')
print(arr)
'''

# 위의 식을 리스트 컴프리헨션으로 만들기
result = [i*j for i in range(1, 4) for j in range(1, 3)]
print(result)

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

3-2. 세트 컴프리헨션

numbers = [1, 2, 3, 4, 5, 2, 3, 4]
unique_numbers = {x for x in numbers} #세트는 중복 제거
print(unique_numbers)

{1, 2, 3, 4, 5}

3-3 딕셔너리 컴프리헨션

names = ['푸바오', '아이바오', '러바오']
name_lengths = {name : len(name) for name in names} # 딕셔너리 키:값 처럼 출력 names에서 요소를 가져온 후 조건에 맞게 출력
print(name_lengths)

{'푸바오': 3, '아이바오': 4, '러바오': 3}

반복문은 동일한 작업을 여러 번 실행하기 위해 사용되는 제어 구조입니다. 주로 for 문과 while 문이 사용되며, 각각의 반복문은 다른 상황에 적합한 방식으로 사용됩니다.

while 문은 특정 조건이 참인 동안 반복적으로 코드 블록을 실행하는 제어 구조입니다. while 문은 주어진 조건이 참인 동안 반복적으로 코드를 실행하며, 조건이 거짓이 되면 반복을 멈춥니다.

while 조건:
    # 조건이 참인 동안 실행될 코드

# while 문을 사용할 때 주의 사항

• 무한 루프: 만약 while 문의 조건이 항상 참이라면 코드가 무한 루프에 빠질 수 있습니다. 프로그램이 의도대로 종료되지 않는 상황을 방지하기 위해 조건을 제대로 설정해야 합니다.
• 조건 변경: while 문 내에서 조건을 변경해야 루프가 종료되는 경우도 있습니다. 그렇지 않으면 무한 루프에 빠질 수 있습니다.
• 끝 조건: 반복이 더 이상 필요하지 않을 때 while 문을 종료하는 조건을 명확하게 설정해야 합니다.
• 적절한 초기화: 반복 변수나 조건을 사용하기 전에 적절하게 초기화해야 합니다.

i = 1

while i <= 5:
  print('Hello Python')  # 무한 루프

i = 1

while i <= 5:
  print('Hello Python')
  i += 1

Hello Python
Hello Python
Hello Python
Hello Python
Hello Python

# 1부터 10까지 총합
i = 1
sum = 0
while i <= 10 :
  sum += i
  '''
  sum + i = sum
    0 += 1 -> 1
    1 += 2 -> 3
    3 += 3 -> 6
    6 += 4 -> 10
    10 += 5 -> 15
    15 += 6 -> 21
    21 += 7 -> 28
    28 += 8 -> 36
    36 += 9 -> 45
    45 += 10 -> 55
  '''
  i += 1
print(f'1부터 10까지의 합 : {sum}')

# 1부터 100까지 짝수의 합 #1
i = 0
sum = 0

while i <= 100:
  sum += i
  i = i + 2
print(f'1 부터 100까지의 짝수 합 : {sum}')



# 1부터 100까지 짝수의 합 #2
i = 1
sum = 0

while i <= 100:
  if  i % 2 == 0 :
    sum += i
  i += 1
print(f'1 부터 100까지의 짝수 합 : {sum}')

1 부터 100까지의 짝수 합 : 2550
1 부터 100까지의 짝수 합 : 2550

# 원하는 구구단을 입력받아 해당 단의 구구단을 출력
dan = int(input('원하는 단을 입력하세요 : '))
print(f'{dan} 단')

# 6 * 1 = 6
# 6 * 2 = 12
i = 1
while i <= 9:
  print(f'{dan} * {i} = {dan * i}')
  i += 1

원하는 단을 입력하세요 : 9
9 단
9 * 1 = 9
9 * 2 = 18
9 * 3 = 27
9 * 4 = 36
9 * 5 = 45
9 * 6 = 54
9 * 7 = 63
9 * 8 = 72
9 * 9 = 81

for 요소 in 시퀀스:
    # 요소에 대한 작업 수행

list1 = [10, 20, 30, 40]

for li in list1 :
  print(li)

10
20
30
40

range() 함수는 파이썬에서 순차적인 정수의 시퀀스를 생성하는 데 사용되는 내장 함수입니다. 주로 for 문과 함께 사용되며, 일정한 범위 내에서 반복 작업을 수행할 때 유용하게 활용됩니다. range() 함수의 결과로 생성되는 순차적인 정수 시퀀스는 실제로 메모리에 저장되지 않고 필요할 때마다 생성되므로, 큰 범위의 반복문에도 효율적으로 사용할 수 있습니다.

range([start], stop, [step])

start (선택 사항): 순차적인 범위의 시작 값을 지정합니다. 기본값은 0입니다.
stop: 순차적인 범위의 끝 값을 지정합니다. 생성된 시퀀스는 stop 값 직전까지의 정수를 포함합니다.
step (선택 사항): 순차적인 값을 증가시키는 간격을 지정합니다. 기본값은 1입니다.

num = range(0, 10, 1)
print(num)

for i in num:
  print( i, end = ' ')

range(0, 10)
0 1 2 3 4 5 6 7 8 9

for i in range(0, 10, 1):
    print(i, end=' ')
    
for i in range(0, 10):
    print(i, end=' ')

for i in range(10):
    print(i, end=' ')
    
for i in range(1, 10, 2):
    print(i, end=' ')

0 1 2 3 4 5 6 7 8 9 
0 1 2 3 4 5 6 7 8 9 
0 1 2 3 4 5 6 7 8 9 
2 4 6 8

# for문을 이용하여 1부터 100까지 짝수의 총합 구하기
sum = 0
for i in range(0,101,2):
  sum += i
print(f'1부터 100까지의 짝수의 총합 : {sum}')

1부터 100까지의 짝수의 총합 : 2550

enumerate() 함수는 파이썬에서 반복문을 사용할 때 인덱스와 값을 함께 가져오기 위해 사용되는 내장 함수입니다. 주로 for 문과 함께 사용되며, 반복문 내에서 순서를 추적하면서 값과 해당 값의 인덱스를 함께 사용할 때 유용합니다. enumerate() 함수는 (인덱스, 값)의 튜플을 반환하는 이터레이터(iterator)를 생성합니다.

enumerate(iterable, start=0)

iterable: 반복 가능한 객체(리스트, 튜플, 문자열 등)를 지정합니다.
start (선택 사항): 인덱스의 시작 값을 지정합니다. 기본값은 0입니다.
enumerate() 함수는 (인덱스, 값) 형태의 튜플을 생성하여 이터레이터를 반환합니다. 이를 for 문과 함께 사용하여 인덱스와 값을 동시에 가져와 처리할 수 있습니다.

li1 = [10, 20, 30, 40, 50]
for e in enumerate(li1):
  print(e)

(0, 10)
(1, 20)
(2, 30)
(3, 40)
(4, 50)

li1 = [10, 20, 30, 40, 50]
for i, v in enumerate(li1):
  print(f'index:{i}, value:{v}')

index:0, value:10
index:1, value:20
index:2, value:30
index:3, value:40
index:4, value:50

zip() 함수는 파이썬에서 여러 개의 반복 가능한(iterable) 객체를 병렬적으로 묶어주는 내장 함수입니다. 각 객체로부터 순서대로 하나의 요소씩 가져와 튜플로 묶어주는 이터레이터를 반환합니다. 주로 여러 개의 리스트나 튜플을 병렬적으로 처리하고자 할 때 사용됩니다.

zip(iterable1, iterable2, ...)

iterable1, iterable2, ...: 병렬적으로 묶을 반복 가능한 객체들을 지정합니다. 여러 개의 인자로 전달할 수 있습니다.

#len은 쌍 개수가 맞지 않을 경우 오류가 발생
li1 = [10, 20, 30]
li2 = ['apple', 'banana', 'orange']

for i in range(len(li1)):
    print(li1[i], li2[i])

10 apple
20 banana
30 orange

li1 = [10, 20, 30]
li2 = ['apple', 'banana', 'orange']

for l1, l2 in zip(li1, li2):
  print(l1, l2)

10 apple
20 banana
30 orange

li1 = [10, 20, 30, 40] #4개
li2 = ['apple', 'banana', 'orange'] #3개

# 반복 3바퀴만 실행 : 돌 수 있는 만큼만 돔
for l1, l2 in zip(li1, li2):
    print(l1, l2)

10 apple
20 banana
30 orange

li1 = [10, 20, 30]
li2 = ['apple', 'banana', 'orange']

for li in zip(li1, li2):
    print(li)

(10, 'apple')
(20, 'banana')
(30, 'orange')

for n, A, a in zip('12345','ABCDE','abcde'):
  print(n,A,a)

1 A a
2 B b
3 C c
4 D d
5 E e

파이썬에서 중첩된 반복문은 하나의 반복문 안에 다른 반복문이 포함된 구조를 의미합니다. 중첩 반복문은 외부 반복문의 각 반복마다 내부 반복문이 모두 실행되는 방식으로 작동합니다. 이를 통해 다차원의 데이터를 처리하거나 복잡한 작업을 수행할 수 있습니다.

for 외부_변수 in 외부_시퀀스:
    for 내부_변수 in 내부_시퀀스:
        # 내부 반복문 코드
    # 외부 반복문 코드

• 외부_변수: 외부 반복문의 현재 요소를 나타내는 변수입니다.
• 외부_시퀀스: 외부 반복문에서 순회할 반복 가능한 객체(리스트, 튜플 등)입니다.
• 내부_변수: 내부 반복문의 현재 요소를 나타내는 변수입니다.
• 내부_시퀀스: 내부 반복문에서 순회할 반복 가능한 객체입니다.

for i in range(1, 4):
  print(f'푸바오 i : {i}')
  for j in range(1, 4):
    print(f'🐼 j : {j}')

푸바오 i : 1
🐼 j : 1
🐼 j : 2
🐼 j : 3
푸바오 i : 2
🐼 j : 1
🐼 j : 2
🐼 j : 3
푸바오 i : 3
🐼 j : 1
🐼 j : 2
🐼 j : 3

for i in range(5):
  print('가')
  for j in range(i, 5): #step생략
    print('🐼', end = "")
  print()

# '🐼'를 이용하여 아래와 같은 도형을 만들어보자
'''
🐼🐼🐼🐼🐼
🐼🐼🐼🐼🐼
🐼🐼🐼🐼🐼
🐼🐼🐼🐼🐼
🐼🐼🐼🐼🐼
'''

for i in range(5):
  for j in range(5):
    print('🐼', end = '')
  print()

# '🐼'를 이용하여 아래와 같은 도형을 만들어보자
'''
🐼🐼🐼🐼🐼
🐼🐼🐼🐼
🐼🐼🐼
🐼🐼
🐼
'''

for i in range(5):
  for j in range(i, 5): #i가 하나씩 커지므로 출력되는 🐼가 하나씩 줄어듬
    print('🐼', end = '')
  print()

# '🐼'를 이용하여 아래와 같은 도형을 만들어보자
'''
🐼
🐼🐼
🐼🐼🐼
🐼🐼🐼🐼
🐼🐼🐼🐼🐼
'''

for i in range(1,6):
  for j in range(i):
    print('🐼', end = '')
  print()
  
  
for i in range(5):
  for j in range(0, i+1):
    print('🐼', end = '')
  print()

### 문제
#* 2단부터 9단까지 구구단을 출력하는 프로그램을 작성
for i in range(1, 10):
  print(f'{i}단')
  for j in range(1, 10):
   print(f'{i} * {j} = {i*j}')

#while문
i = 2
j = 1

while i <= 9:
  print(f'{i} 단')
  while j <= 9:
    print(f'{i} * {j} = {i*j}')
    j += 1
  i += 1
  j = 1 # j = 1 이라는 세팅을 해주어야 반복문이 다시 돌때 j가 초기화 됨

조건문은 코드의 실행 흐름을 제어하기 위해 사용하는 구문입니다. 이 조건문은 주어진 조건이 참인지 거짓인지에 따라 다른 코드를 실행하게 합니다.

가장 기본적인 조건문입니다. 특정 조건이 참(True)일 경우에만 해당 블록 내의 코드가 실행됩니다.

if 조건:
    실행할 코드

bool1 = True

if bool1 :
    print('결과는 참입니다.')
print('프로그램을 종료합니다.')

결과는 참입니다.
프로그램을 종료합니다.

bool2 = False

if bool2:
    print('결과는 참입니다.')
print('프로그램을 종료합니다.')

프로그램을 종료합니다

age = int(input('나이를 입력하세요 '))

if age > 19 :
  print("성인입니다")
print("입력한 나이 : ", age)

나이를 입력하세요 2
입력한 나이 :  2

age = int(input('나이를 입력하세요 '))

if age > 19 :
  print("성인입니다")
  print("성인 영화 감상 가능")
print("입력한 나이 : ", age)

나이를 입력하세요 20
성인입니다
성인 영화 감상 가능
입력한 나이 :  20

else는 파이썬의 조건문 구조에서 if와 elif 조건들이 모두 거짓으로 평가될 경우 실행되는 부분을 정의하는 데 사용됩니다. else는 선택적으로 사용될 수 있으며, 그 자체로는 어떤 조건을 갖지 않습니다. 다시 말해, else 블록은 위의 if와 elif 조건들이 모두 만족되지 않는 경우에만 실행됩니다.

if 조건1:
    코드 블록1
elif 조걸2:
    코드 블록2
else:
    코드 블록3

age = int(input('나이를 입력하세요: '))

if age > 19:
    print('성인입니다.')
else:
    print('미성년입니다.')

print('입력한 나이: ', age)

나이를 입력하세요: 20
성인입니다.
입력한 나이:  20

age = int(input('나이를 입력하세요: '))

if age > 19:
    print('성인입니다.')
    print('성인영화 감상가능')
else:
    print('미성년입니다.')
    print("잠이나 자세영")

print('입력한 나이: ', age)

나이를 입력하세요: 20
성인입니다.
성인영화 감상가능
입력한 나이:  20

elif는 if-else 구조에서 추가적인 조건을 검사하기 위해 사용되는 키워드입니다. elif는 "else if"의 줄임말이며, 주어진 여러 조건 중에서 하나만 참일 때 실행되는 코드 블록을 정의합니다.

if 조건1:
    코드 블록1
elif. 조건2:
    코드 블록2
elif. 조건3:
    코드 블록3
else:
    코드 블록4

• elif는 if 없이 단독으로 사용될 수 없습니다.
• elif는 필요에 따라 여러 번 사용될 수 있습니다.
• else는 선택적입니다. 사용될 경우, 항상 if나 elif 뒤에 나타나야 합니다.

age = int(input('나이를 입력하세요: '))

if age > 19:
    print('성인')
elif age > 14:
    print('청소년')
elif age > 6:
    print('어린이')
elif age > 0:
    print('유아')
else:
    print('입력 확인')

print('입력한 나이: ', age)

나이를 입력하세요: 21
성인
입력한 나이:  21

조건부 표현식은 파이썬에서 삼항연산자라고도 불립니다. 간단한 if-else 구문을 더 간결하게 표현할 수 있는 방법을 제공합니다.

조건이 참인 경우 값 if condition else 조건이 거짓인 경우 값

num = int(input('숫자를 입력하세요: '))

if num % 2 == 0:
    print('짝수')
else:
    print('홀수')

숫자를 입력하세요 : 20
짝수

num = int(input('숫자를 입력하세요: '))

print('짝수') if num % 2 == 0 else print('홀수')

숫자를 입력하세요 : 20
짝수

# 로그인 프로그램 만들기

# 아이디 : admin, 비밀번호 : 1234

# 로그인 프로그램 만들기
# 아이디 : admin, 비밀번호 : 1234
userid = input('아이디를 입력하세요 : ')
userpw = input('비밀번호를 입력하세요 : ')

if userid == 'admin' and userpw == '1234':
    print('로그인 되었습니다.')
else:
    print('아이디 또는 비밀번호를 확인하세요.')

#  주민등록번호에 의한 성별을 판별하는 프로그램 만들기
# 0010113068518

# 주민등록번호에 의한 성별을 판별하는 프로그램 만들기
# 0010113068518
userid = input('주민등록번호를 입력하세요 :')

if userid[7] == '1' or  userid[7] == '3' or userid[7] == '5' or  userid[7] =='7' or  userid[7] =='9' :
  print('남자')
else:
  print('여자')

• 국어, 영어, 수학점수를 입력받아 총점, 평균, 학점을 구하는 프로그램을 작성해보자
• 단, 학점은 평균 기준으로 90점 이상은 A, 80점 이상은B, 70점이상은 C, 60점 이상은 D, 나머지는 F

kor, eng, math = input('국어 영어 수학').split('/')
all = (f'총점: {int(kor) + int(eng) + int(math)}')
av = (int(kor) + int(eng) + int(math))/3

if av >= 90:
  grade = ('A')
elif av >= 80:
  grade = ('B')
elif av >= 70:
  grade = ('C')
elif av >= 60:
  grade = ('D')
else:
  grade = ('F')

print('총점 : ', all, '평균 : ', av, '학점 : ', grade)

산술 연산자는 주로 수치 데이터 유형에 대한 기본 산술 연산을 수행하기 위해 사용됩니다.

• + : 더하기
• - : 빼기
• : 곱하기
• / : 나누기
• //: 몫 (정수 나누기)
• % : 나머지
• **: 지수 (거듭제곱)

print(10 + 3)
print(10 - 3)
print(10 * 3)
print(10 / 3)
print(10 // 3)
print(10 % 3)
print(10 ** 3)

13
7
30
3.3333333333333335
3
1
1000

비교 연산자는 주로 두 값을 비교하는 데 사용되며, 그 결과는 항상 불리언(True 또는 False) 값입니다.

• ==: 동등
• !=: 동등하지 않음
• < : 작다
• <=: 작거나 같다
• > : 크다
• >=: 크거나 같다

print(10 > 5)
print(10 < 5)
print(10 >= 5)
print(10 <= 5)
print(10 == 5)
print(10 != 5)

True
False
True
False
False
True

변수에 값을 할당하는데 사용됩니다. 파이썬에서는 기본 할당 연산자 외에도 복합 할당 연산자를 제공하여 코드를 간결하게 작성할 수 있게 도와줍니다.

• = : 할당
• += : 더하기 후 할당
• -= : 빼기 후 할당
• *= : 곱하기 후 할당
• /= : 나누기 후 할당
• //=: 몫 후 할당
• %= : 나머지 후 할당
• **=: 지수 후 할당

num = 10

num += 1 #num = num + 1
print(num)

num -= 1
print(num) # num = num - 1

num *= 10
print(num)

num /= 10
print(num)

num %= 2
print(num)

11

10

100

10.0

0.0

4. 비트 연산자

비트 연산자는 정수를 이진 비트로 표현했을 때 사용하는 연산자들입니다. 각 연산자는 정수의 비트 단위로 동작합니다.

• & : 비트 단위 AND
• | : 비트 단위 OR
• ^ : 비트 단위 XOR
• ~ : 비트 단위 NOT
• << : 왼쪽 시프트
• >> : 오른쪽 시프트

a = 60  # 111100
b = 13  # 001101
print(a & b)  # 12, 즉 1100

print(a | b)  # 61, 즉 111101

print(a ^ b)  # 49, 즉 110001

print(~a)  # -61, 이 결과는 2의 보수 방식 때문입니다.

print(a << 2)  # 240, 즉 11110000

print(a >> 2)  # 15, 즉 1111

12
61
49
-61
240
15

print(a & b) # and)
print(a | b) # or
print(a ^ b) # XOR

12
61
49

5. 논리 연산자

파이썬에서의 논리 연산자는 주로 불린(Boolean) 값을 조작하기 위해 사용됩니다. 그러나 파이썬의 논리 연산자는 다른 언어와는 다르게, 연산의 결과로 항상 True 또는 False만을 반환하는 것은 아닙니다. 대신 마지막으로 평가된 피연산자의 값을 반환합니다.

• and: 논리 AND
• or : 논리 OR
• not: 논리 NOT

# and
print(True and 3)       # 3
print(3 and 5)         # 5
print(0 and 5)         # 0

# or
print(False or 3)      # 3
print(3 or 5)          # 3
print(0 or 5)          # 5

# not
print(not True)        # False
print(not 0)           # True
print(not 3)           # False

3
5
0
3
3
5
False
True
False

6. 멤버 연산자

좌항이 우항에 포함되었다면 True 아니면 False

print("a" in "abc")	#True
print(2 in [1, 2, 3])	#True

좌항이 우항에 포함되어 있지 않다면 True 포함되면 False

print("a" not in "abc") #False
print(2 not in [1, 2, 3]) #False

7. 식별 연산자

두 객체 모두 같은 주소일 경우 True 아니면 False

#두 객체 모두 같은 주소일 경우 True 아니면 False
a = 10
b = a
print(a is b) #True

두 객체 모두 같은 주소일 경우 True 아니면 False

# 두 객체 모두 같은 주소일 경우 True 아니면 False
a = [1, 2, 3]
b = [1, 2, 3]
print(a is not b) #True

# a와 b는 주소가 다르다.
# is not을 사용하여 True가 발생

※ 데이터의 크기를 나타내는 용량 단위

• Bit: 가장 기본적인 데이터 단위로, 0 또는 1의 값을 가질 수 있습니다.
• Byte (B): 8 bits와 동일합니다.
• Kilobyte (KB): 1 KB = 1,024 Bytes
• Megabyte (MB): 1 MB = 1,024 KB 
• Gigabyte (GB): 1 GB = 1,024 MB
• Terabyte (TB): 1 TB = 1,024 GB

※ 파이썬에서 불린(Boolean)으로 평가되는 주요 값

1. True로 평가되는 주요 값

• Boolean: True
• 모든 음이 아닌 숫자: 예를 들어, -1, 1, 3.5 등 (단, 0 제외)
• 문자열과 바이트 문자열: 예를 들어, 'hello', "world", b'hello' (단, 빈 문자열 '' 및 b'' 제외)
• 모든 리스트, 튜플, 세트, 딕셔너리: 예를 들어, [1, 2], {'key': 'value'} 등 (단, 빈 컨테이너 제외)

2. False로 평가되는 주요 값

• Boolean: False
• 숫자: 0 (정수, 부동 소수점, 복소수 포함)
• 문자열: 빈 문자열 '' 및 빈 바이트 문자열 b''
• 리스트, 튜플, 세트: 빈 리스트 [], 빈 튜플 (), 빈 세트 set()
• 딕셔너리: 빈 딕셔너리 {}
• None: 파이썬의 None 객체도 False로 평가됩니다.

1. 딕셔너리

파이썬의 딕셔너리는 키-값 쌍을 저장하는 변경 가능한(mutable) 컬렉션입니다.

요약

dict(딕셔너리)
        한 쌍으로 저장되어 관리한다.
        len()를 사용하면 한 쌍을 1로 카운트한다.
        * 키 -  중복 불가능
        * 값 - 중복 가능
        키 값을 주면 그 키의 값을 가지고 온다.

        # 키  해시테이블 값
        # 키로 정보를 요청하면 해시테이블이 값을 찾아와준다.

dict 선언
        dict명{키: 값, 키: 값, 키: 값, ...}

dict 사용
        -추가, 수정
            : 추가와 수정이 동일한 코드이다.
            dict명[키] = 값
            키 값이 기존에 있으면 수정이고, 기존에 없으면 추가이다.
        -삭제
            del dict명[키]

        -검사
            키 in dict명 : 키가 있으면 참
            키 not in dict명 : 키가 없으면 참

1. 생성

딕셔너리는 중괄호 {}를 사용하여 생성하고, 키-값 쌍들은 쉼표 ,로 구분됩니다. 각 키-값 쌍은 콜론 :으로 구분됩니다.

• 키는 중복 불가능 (set)와 비슷
• 값은 중복 가능 (dict)과 비슷

dict 선언
        dict명{키: 값, 키: 값, 키: 값, ...}

dic1 = {}
print(dic1)
print(type(dic1))

dic2 = {1: '푸바오', 2: '아이바오', 3: '러바오', 4: '루이바오'}
print(dic2)
print(dic2[2]) # 딕셔너리에서는 대괄호 안에는 키가 들어가야함 => 값(value) 출력
print(dic2[3])

dic3 = {'no':1, 'userid':'apple', 'name':'푸바오', 'hp':'010-1111-1111'} # 키는 중복x 문자 및 숫자도 가능
print(dic3)
print(dic3['no'])
print(dic3['name'])

2. 추가 및 수정 (변경가능)

• 딕셔너리는 변경 가능합니다. 
• 따라서, 딕셔너리에 키-값 쌍을 추가하거나 제거하거나, 기존의 키의 값을 변경할 수 있습니다.

dict 사용
-추가, 수정
** 추가와 수정이 동일한 코드이다.
            
            dict명[키] = 값 
            키 값이 기존에 있으면 수정이고, 기존에 없으면 추가이다.

# 데이터에 없는 키 값을 대괄호에 넣고 값을 입력하면 데이터가 추가된다. (데이터에 순서가 없다)

# 데이터에 없는 키 값을 대괄호에 넣고 값을 입력하면 데이터가 추가된다. (데이터에 순서가 없다)
dic4 = {1:'apple'}
print(dic4)

dic4[100] = 'banana'
print(dic4)

dic4[50] = 'orange'
print(dic4)

del dic4[100]
print(dic4)

# 존재하는 키 값에 새로운 값을 넣어주면 값이 대체된다.(수정된다)

# 존재하는 키 값에 새로운 값을 넣어주면 값이 대체된다.(수정된다)
dic5 = {'no':1, 'userid':'apple', 'name':'푸바오', 'hp':'010-1111-1111'}
dic5['no'] = 2
print(dic5)

3. 키, 값의 제약

• 딕셔너리의 키는 변경 불가능한(immutable) 타입이어야 합니다.
• 예를 들어, 문자열, 정수, 튜플은 딕셔너리의 키로 사용할 수 있지만, 리스트는 딕셔너리의 키로 사용할 수 없습니다. 하지만 딕셔너리의 값은 어떤 타입이든 상관없습니다.

dic3 = {'no':1, 'userid':'apple', 'name':'푸바오', 'hp':'010-1111-1111'} # 키는 중복x 문자 및 숫자도 가능
dic5['no'] = 2
print(dic5)

dic3['점수'] = [90, 100, 50] # 값에 리스트 추가
print(dic3)

dic3[(1,2,3)] = ('가','나','다') # 키(튜플) : 값(튜플 추가)
print(dic3)

#dic3[[1, 2, 3]] = ['라', '마', '바'] #키는 변경 불가능한(immutable) 타입. 리스트가 될 수 없다
#print(dic3)

dic3['과일'] = {'사과':'🍎', '딸기':'🍓', '앵두':'🍒'} # '과일' 키에 값:딕셔너리도 추가 가능
print(dic3)

4. 함수와 메서드

딕셔너리는 여러 함수와 메소드를 가지고 있습니다.

# len(): 딕셔너리의 길이(키-값 쌍의 개수)를 구할 수 있는 함수

# len(): 딕셔너리의 길이(키-값 쌍의 개수)를 구할 수 있는 함수
dic3 = {'no':1, 'userid':'apple', 'name':'푸바오', 'hp':'010-1111-1111'}
print(len(dic3)) # 키와 값이 하나의 쌍

# keys(): 딕셔너리의 모든 키를 반환하는 메서드

# keys(): 딕셔너리의 모든 키를 반환하는 메서드
dic3 = {'no':1, 'userid':'apple', 'name':'푸바오', 'hp':'010-1111-1111'}
print(dic3.keys()) # 키만 뽑아서 리스트로 출력

# values(): 딕셔너리의 모든 값을 반환하는 메서드

# values(): 딕셔너리의 모든 값을 반환하는 메서드
dic3 = {'no':1, 'userid':'apple', 'name':'푸바오', 'hp':'010-1111-1111'}
print(dic3.values())

# items(): 딕셔너리의 모든 키-값 쌍을 반환하는 메서드 (튜플로 반환)

# items(): 딕셔너리의 모든 키-값 쌍을 반환하는 메서드 (튜플로 반환)
dic3 = {'no':1, 'userid':'apple', 'name':'푸바오', 'hp':'010-1111-1111'}
print(dic3.items())

# get(): 특정 키의 값을 반환. 만약 그 키가 딕셔너리에 없으면, None을 반환하는 메서드

# get(): 특정 키의 값을 반환. 만약 그 키가 딕셔너리에 없으면, None을 반환하는 메서드
print(dic3.get('userid'))
print(dic3.get('age'))
print(dic3.get('userid', '알 수 없음'))
print(dic3.get('age', '알 수 없음')) # get 사용시 존재하지 않는 키에 값을 입력하면 입력한 값이 출력


dic3 = {'no':1, 'userid':'apple', 'name':'푸바오', 'hp':'010-1111-1111'}
print(dic3['userid'])
#print(dic3['age']) # 딕셔너리에 존재하지 않는 키를 입력하면 에러 KeyError: 'age'

# pop(): 특정 키의 값을 제거하고 반환. 만약 그 키가 딕셔너리에 없으면, KeyError가 발생하는 메서드

# pop(): 특정 키의 값을 제거하고 반환. 만약 그 키가 딕셔너리에 없으면, KeyError가 발생하는 메서드
dic3 = {'no':1, 'userid':'apple', 'name':'푸바오', 'hp':'010-1111-1111'}
print(dic3.pop('hp'))
print(dic3)

5. 멤버십 테스트

in 연산자를 사용하여 딕셔너리에 특정 키가 있는지 확인할 수 있습니다.

# in : 딕셔너리 안에 키 존재 여부 확인
dic3 = {'no':1, 'userid':'apple', 'name':'푸바오', 'hp':'010-1111-1111'}
print('hp' in dic3)
print('age' in dic3)

• 세트(set)는 중복되지 않는 항목들의 컬렉션입니다.
• 순서가 없다
• 세트는 중괄호 {}를 사용 or set() 생성자를 사용
• 중복을 제거할 때 효과적이다.

# 중복이 없고, 순서가 없다.
# 값이 있는지 없는지 검사
world_set = {'korea', 'america', 'japan', 'china'} # 중괄호에 값이 하나씩 연결되어 있으면 set

print(type(world_set)) # <class 'set'>
print(len(world_set)) # 4

#print(world_set[1]) # 오류 -> 순서가 없기때문에 데이터를 가져올 수 없다.

world_set.add('korea') # 중복된 값은 데이터에 추가되지 않는다.
print(world_set)    #{'china', 'korea', 'japan', 'america'}

# set의 데이터를 가져오는 방법
# 다른 구조로 형변환을 시킴
# print로 출력했을때 나오는 데이터 값은 set을 다른 자료구조로 가져온 다음 {}로 닫아준 것.

대부분 set은 중복제거 할 때 사용한다.

data = [1, 2, 3, 1, 1, 4, 4, 5]
print(list(set(data))) #[1, 2, 3, 4, 5]

1. 생성

세트는 중괄호 {}를 사용하여 생성하거나 set() 생성자를 사용할 수 있습니다.

s1 = {} #빈 괄호를 넣으면 딕셔너리로 인식 따라서 값을 넣어야함 => 딕셔너리는 {키 : 값} 값을 쌍으로 저장
print(s1)
print(type(s1))

s1 = {1, 3, 5, 7} # 딕셔너리와 달리 값을 하나만 넣으면 세트
print(s1)
print(type(s1))

li1 = [1, 3, 5, 7]
s2 = set(li1)
print(s2)
type(s2)

{1, 3, 5, 7}

set

s3 = {1, 3, 5, 3, 7, 9, 1}
print(s3) # 세트는 중복된 데이터가 제거된 채로 출력

2. 메소드

세트는 여러 메소드를 가지고 있습니다.

# add(): 세트에 항목을 추가하는 메서드

# add(): 세트에 항목을 추가하는 메서드
s1 = {100, 200}
s1.add(150) # set에 데이터 추가
print(s1)

s1.add(50) # set는 패턴생각 x 순서가 마음대로 지정됨
print(s1) # set는 순서가 없는 집합

# update(): 세트에 여러 항목을 한번에 추가하는 메서드

# update(): 세트에 여러 항목을 한번에 추가하는 메서드
s1 = {100, 200}
s1.update([40,50,60,20])
print(s1) # 순서에 관계없이 데이터가 들어감

# remove():  세트의 항목을 제거. 만약 그 항목이 세트에 없으면, KeyError가 발생

# remove():  세트의 항목을 제거. 만약 그 항목이 세트에 없으면, KeyError가 발생
s1 = {10, 20, 30}
s1.remove(20)
print(s1)
#s1.remove(20) #없는 데이터를 지우면 KeyEroor: 20

# discard(): 세트의 항목을 제거. 제거할 항목이 없어도 에러가 발생하지 않음

# discard(): 세트의 항목을 제거. 제거할 항목이 없어도 에러가 발생하지 않음
s1 = {10, 20, 30}
print(s1)
s1.discard(30)
print(s1)

# copy(): 세트를 복사
# s1과 s2의 메모리 주소는 다름

# copy(): 세트를 복사
# s1과 s2의 메모리 주소는 다름
s1 = {10, 20, 30}
s2 = s1.copy() # s2 = s1(X)
print(s1)
print(s2)
print(id(s1))
print(id(s2))

# union(): 두 세트의 합집합을 반환

# s1|s2 

# union(): 두 세트의 합집합을 반환
s1 = {10, 20, 30, 40, 50}
s2 = {30, 40, 50, 60, 70}

#result1 = s1.union(s2) # s1 | s2
result1 = s1 | s2
print(result1)

# intersection(): 두 세트의 교집합을 반환

# s1 & s2

# intersection(): 두 세트의 교집합을 반환
s1 = {10, 20, 30, 40, 50}
s2 = {30, 40, 50, 60, 70}
#result2 = s1.intersection(s2)
result2 = s1 & s2
print(result2)

# difference(): 두 세트의 차집합을 반환

# s1 - s2

# difference(): 두 세트의 차집합을 반환
s1 = {10, 20, 30, 40, 50}
s2 = {30, 40, 50, 60, 70}
#result3 = s1.difference(s2)
result3 = s1 - s2
print(result3)

# 대칭차집합 (합집합 - 교집합)

# s1 ^ s2

# 대칭차집합 (합집합 - 교집합)
s1 = {10, 20, 30, 40, 50}
s2 = {30, 40, 50, 60, 70}
#result4 = s1.symmetric_difference(s2)
result4 = s1 ^ s2
print(result4)