someone_3.log

[Python] 중급6. 깊은 복사와 얕은 복사

Thu, 30 May 2024 10:14:23 GMT

✍ 얕은 복사

변수는 객체의 메모리 주소를 저장하고, 이를 이용해서 객체를 참조함
얕은 복사란, 객체 주소를 복사하는 것으로 객체 자체가 복사되지 않음

class Robot:

    def __init__(self,color, height, weight):
        self.color = color
        self.height = height
        self.weight = weight

    def printRobotInfo(self):
        print(f'color:{self.color}')
        print(f'height:{self.height}')
        print(f'weight:{self.weight}')

# 얕은 복사
rb1= Robot('red', 200,80)
rb2= rb1   # 얕은 복사

rb1.printRobotInfo()
## color:red
## height:200
## weight:80

rb2.printRobotInfo()
## color:red
## height:200
## weight:80

rb1.color='gray'
rb1.height=250
rb1.weight=100

rb1.printRobotInfo()
## color:gray
## height:250
## weight:100

rb2.printRobotInfo()
## color:gray
## height:250
## weight:100

class TemCls:

    def __init__(self,n,s):
        self.number=n
        self.str= s

    def printClsInfo(self):
        print(f'self.number:{self.number} ')
        print(f'self.str:{self.str}')


tc1=TemCls(10,'Hello')
tc2=tc1

tc1.printClsInfo()
## self.number:10 
## elf.str:Hello

tc2.printClsInfo()
## self.number:10 
## self.str:Hello

# 얕은 복사
tc2.number=3.14
tc2.str='Bye'

tc1.printClsInfo()
## self.number:3.14 
## self.str:Bye

tc2.printClsInfo()
## self.number:3.14 
## self.str:Bye

scores = [9,8,5,7,6,10]
scoreCopy=[]

scoreCopy=scores
print(f'id(scores):{id(scores)}') #id 함수는 메모리 주소를 알아보는 함수
## id(scores):2237555615040

print(f'id(scoreCopy): {id(scoreCopy)}') # 얕은 복사이기 때문에 주소값이 같음
## id(scoreCopy): 2237555615040

✍ 깊은 복사

깊은 복사란, 객체 자체를 복사하는 것으로, 또 하나의 객체가 만들어짐

class TemCls:

    def __init__(self,n,s):
        self.number=n
        self.str= s

    def printClsInfo(self):
        print(f'self.number:{self.number} ')
        print(f'self.str:{self.str}')

# 깊은복사 방법 1
import copy 

tc1=TemCls(10,'Hello')
tc2=copy.copy(tc1)

tc2.number=3.14
tc2.str='Bye'

tc1.printClsInfo()
## self.number:10 
## self.str:Hello

tc2.printClsInfo()
## self.number:3.14 
## self.str:Bye

import copy
scores = [9,8,5,7,6,10]
scoreCopy=[]

# 깊은복사 방법 2
for s in scores: 
    scoreCopy.append(s)

print(f'id(scores):{id(scores)}')
## id(scores):2181381104960

print(f'id(scoresCopy): {id(scoreCopy)}') # 깊은 복사이기 때문에 주소값이 다름
## id(scoresCopy): 2181381048320

# 깊은복사 방법 3
scoreCopy.extend(scores)  

print(f'id(scores):{id(scores)}')
## id(scores):2838314766144

print(f'id(scoresCopy):{id(scoreCopy)}') # 깊은 복사이기 때문에 주소값이 다름
## id(scoresCopy):2838316217600


# 깊은복사 방법 4
scoresCopy=scores.copy() 

print(f'id(scores):{id(scores)}')
## id(scores):1875348049728

print(f'id(scoresCopy):{id(scoreCopy)}') # 깊은 복사이기 때문에 주소값이 다름
## id(scoresCopy):1875348124928

# 깊은복사 방법 5
scoresCopy=scores[:] 
print(f'id(scores):{id(scores)}')
## id(scores):2124338908992

print(f'id(scoresCopy):{id(scoreCopy)}') # 깊은 복사이기 때문에 주소값이 다름
## id(scoresCopy):2124338984192

✔ 실습

선수의 원본 점수를 이용해서 평균을 출력하고, 최고값과 최저값을 제외한 평균을 출력하는 프로그램 만들기

plaOriSco=[8.7, 9.1, 8.9, 9.0, 7.9, 9.5, 8.8, 8.3]
plaCopSco =plaOriSco.copy()

plaOriSco.sort()

plaCopSco.sort()
plaCopSco.pop(0) # plaCoSco에서 제일 첫번째에 있는 수를 뺀다 (제일 작은 수)
plaCopSco.pop() # plaCoSco에서 제일 마지막에 있는 수를 뺀다 (제일 큰 수)

print(f'plaCopSco.pop:{plaCopSco.pop}')
## plaCopSco.pop:

print(f'plaOriSco:{plaOriSco}')
## plaOriSco:[7.9, 8.3, 8.7, 8.8, 8.9, 9.0, 9.1, 9.5]

print(f'plaCopSco:{plaCopSco}')
## plaCopSco:[8.3, 8.7, 8.8, 8.9, 9.0, 9.1]

oriTot=round(sum(plaOriSco),2)
oriAvg=round((oriTot/len(plaOriSco)),2)

print(f'oriTot:{oriTot}')
## oriTot:70.2

print(f'oriAvg:{oriAvg}')
## oriAvg:8.78

copTot=round(sum(plaCopSco),2)
copAvg=round((copTot/len(plaCopSco)),2)

print(f'Copy Tot:{copTot}')
## Copy Tot:52.8

print(f'Copy Avg:{copAvg}')
## Copy Avg:8.8

print(f'oriAvg-copAvg:{oriAvg-copAvg}')
## oriAvg-copAvg:-0.02000000000000135

[Python] 중급5. 클래스와 객체

Wed, 29 May 2024 09:27:31 GMT

✍ 클래스

클래스는 class 키워드와 속성(변수) 그리고 기능(함수)를 이용해서 만듦

class Car:  # 클래스 선언

    def __init__(self, col, len): # 생성자, 속성
        self.color = col
        self.length = len

    def doStop(self): # 기능1: Car 라는 클래스 안에 doStop이라는 기능
        print ('Stop')

    def doStart(self):  # 기능2: Car 라는 클래스 안에 dostart라는 기능
            print('Start')

    def printCarInfo(self):  # 기능3: Car 라는 클래스 안에 printCarInfo라는 기능
        print(f'self.color:{self.color}')
        print(f'self.length:{self.length}')

car1 = Car('red', 200)
car2 = Car('blue', 300)

car1.printCarInfo()
# self.color:red
# self.length:200

car2.printCarInfo()
# self.color:blue
# self.length:300

car1.doStop()
# Stop

car1.doStart()
# Start

✔ 실습

비행기 클래스를 만들고 비행기 객체 3개를 생성하기

class AirPlane:

    def __init__(self, color, length, weight):
        self.color = color
        self.length = length
        self.weight = weight

    def takeOff(self):
        print('take-off')

    def landing(self):
        print('landing')

    def printAriPlaneInfo(self):
        print(f'color: {self.color}')
        print(f'length: {self.length}')
        print(f'weight: {self.weight}')

airPlane1 = AirPlane('red', 200, 2000)
airPlane2 = AirPlane('blue', 150, 2200)
airPlane3 = AirPlane('green', 180, 2100)
airPlane4 = AirPlane('white', 220, 1900)
airPlane5 = AirPlane('black', 210, 2300)

airPlane1.printAriPlaneInfo()
# color: red
# length: 200
# weight: 2000

airPlane2.printAriPlaneInfo()
# color: blue
# length: 150
# weight: 2200

✍ 생성자

객체가 생성될 때 생성자를 호출하면 __init__()가 자동호출
__init__() 속성을 초기화
```
# 방법1
```

class Calculator:

def __init__(self,n1,n2):
    print('[Calculator] __init__() called!!')
    self.num1 = n1
    self.num2 = n2

cal= Calculator(10, 20) # 생성자 호출

[Calculator] init() called!!

print(f'cal.num1:{cal.num1}')

cal.num1:10

print(f'cal.num2:{cal.num2}')

cal.num2:20

방법2

class Calculator:

def __init__(self):
    print('[Calculator] __init__() called!!')
    self.num1 = 10
    self.num2 = 100

cal= Calculator()

[Calculator] init() called!!

print(f'cal.num1:{cal.num1}')

cal.num1:10

print(f'cal.num2:{cal.num2}')

cal.num2:100


- 상위 클래스의 속성을 초기화

class P_Class:

def __init__(self,pNum1, pNum2):
    print('[pClass]__init__()')

    self.pNum1=pNum1
    self.pNum2=pNum2

class C_Class(P_Class):

def __init__(self, cNum1, cNum2):
    print('[cClass]__init__()')
    super().__init__(100,200) #상위 클래스의 속성을 초기화 하기 위해서 super() 사용

    self.cNum1=cNum1
    self.cNum1=cNum1

cls=C_Class(10,2)

[cClass]init()

[pClass]init()

### ✔ 실습
- 중간고사 클래스와 기말고사 클래스를 상속관계로 만들고, 각각의 점수를 초기화
- 총점 및 평균을 반환하는 기능도 만들기

class MidExam:

def __init__(self,s1,s2,s3):
    print('[MidExam]__init__()')

    self.mid_kor_score=s1
    self.mid_eng_score=s2
    self.mid_mat_score=s3

def printScores(self):
    print(f'mid_kor_score:{self.mid_kor_score}')
    print(f'mid_eng_score:{self.mid_eng_score}')
    print(f'mid_mat_score:{self.mid_mat_score}')

class EndExam(MidExam):

def __init__(self,s1,s2,s3,s4,s5,s6):
    print('[EndExam] __init__()')

    super().__init__(s1,s2,s3) #중간고사 점수

    self.end_kor_score = s4
    self.end_eng_score = s5
    self.end_mat_score = s6

def printScores(self):
    super().printScores() # 중간고사 점수 출력
    print(f'end_kor_score:{self.end_kor_score}')
    print(f'end_eng_score:{self.end_eng_score}')
    print(f'end_mat_score:{self.end_mat_score}')

def totalScore(self):
    total=self.mid_kor_score + self.mid_eng_score + self.mid_mat_score
    total += self.end_kor_score + self.end_eng_score + self.end_mat_score

    return total

def aveScore(self):
    return self.totalScore () / 6

exam = EndExam(80,90,88,75,85,95)

[EndExam] init()

[MidExam]init()

exam.printScores()

mid_kor_score:80

mid_eng_score:90

mid_mat_score:88

end_kor_score:75

end_eng_score:85

end_mat_score:95

print(f'total:{exam.totalScore()}')

total:513

print(f'average:{round(exam.aveScore(),2)}')

average:85.5


------------


# ✍ 객체
### 객체란 무엇인가?
- 객체는 속성과 기능으로 구성
- 객체는 클래스에서 생성
- 객체를 사용하면 코드 재사용 및 모듈화가 용이함
![](https://velog.velcdn.com/images/someone_3/post/04aef767-b53c-4ef9-b01c-333bb57e03df/image.png)


### 객체의 속성 변경

클래스 선언

class NewGenrationPC:

def __init__(self,name,cpu, memory, ssd):
    self.name=name
    self.cpu=cpu
    self.memory=memory
    self.ssd=ssd

def doExcel(self):
    print('EXCEL RUN')

def doPhotoshop(self):
    print('Photoshop run!!')

def printPCInfo(self):
    print(f'self.name:{self.name}')
    print(f'self.cpu:{self.cpu}')
    print(f'self.memory:{self.memory}')
    print(f'self.ssd:{self.ssd}')

객체 생성

myPC= NewGenrationPC('myPC','i5','16G','256G') myPC.printPCInfo()

self.name:myPC

self.cpu:i5

self.memory:16G

self.ssd:256G

객체의 속성 변경

myPC.cpu= 'i9' myPC.memory= '64G' myPC.ssd= '1T' myPC.printPCInfo()

self.name:myPC

self.cpu:i9

self.memory:64G

self.ssd:1T


#### ✔실습
- 계산기 클래스를 만들고 사칙연산 실행

class Calculator:

def __init__(self):
    self.n1 =0
    self.n2 =0
    self.result =0

def add(self):
    self.result= self.n1+ self.n2
    return self.result

def sub(self):
    self.result= self.n1- self.n2
    return self.result

def mul(self):
    self.result= self.n1* self.n2
    return self.result

def div(self):
    self.result= self.n1/ self.n2
    return self.result

calculator = Calculator() calculator.n1 = 10 calculator.n2 = 20

print(f'calculator.add(): {calculator.add()}')

calculator.add(): 30

print(f'calculator.sub(): {calculator.sub()}')

calculator.sub(): -10

print(f'calculator.mul(): {calculator.mul()}')

calculator.mul(): 200

print(f'calculator.div(): {calculator.div()}')

calculator.div(): 0.5

```

[Python] 중급4. 패키지

Sun, 19 May 2024 08:47:02 GMT

✍ 패키지

패키지는 모듈을 그룹으로 관리할 수 있음

예시 1. CalculatorForInt 패키지

모듈파일

# 1. CalculatorForInt

# 1-1. addCal
def add (n1, n2):
    return int(n1 + n2)

if __name__ == '__main__':
    print(add(3.14, 1.2))


# 1-2. subCal
def sub (n1, n2):
    return int(n1 - n2)

if __name__ == '__main__':
    print(sub(3.14, 1.2))

# 1-3. divCal
def div (n1, n2):
    return int(n1 / n2)

if __name__ == '__main__':
    print(div(3.14, 1.2))

# 1-4. mulCal
def mul (n1, n2):
    return int(n1 * n2)

if __name__ == '__main__':
    print(mul(3.14, 1.2))

실행파일

from CalculatorForInt import addCal
from CalculatorForInt import divCal
from CalculatorForInt import subCal
from CalculatorForInt import mulCal

print(addCal.add(10,20))
print(subCal.sub(10,20))
print(divCal.div(10,20))
print(mulCal.mul(10,20))

결과

예시 2. CalculatorForFloat 패키지

모듈파일

# 2. CalculatorForFloat

# 2-1. addCal
def add (n1, n2):
    return float(n1 + n2)

if __name__ == '__main__':
    print(add(3.14, 1.2))


# 2-2. subCal
def sub (n1, n2):
    return float(n1 - n2)

if __name__ == '__main__':
    print(sub(3.14, 1.2))


# 2-3. divCal
def div (n1, n2):
    return float(n1 / n2)

if __name__ == '__main__':
    print(div(3.14, 1.2))


# 2-4. mulCal
def mul (n1, n2):
    return float(n1 * n2)

if __name__ == '__main__':
    print(mul(3.14, 1.2))

실행파일

from CalculatorForFloat import addCal
from CalculatorForFloat import divCal
from CalculatorForFloat import subCal
from CalculatorForFloat import mulCal

print(addCal.add(10,20))
print(subCal.sub(10,20))
print(divCal.div(10,20))
print(mulCal.mul(10,20))

결과

30.0
-10.0
0.5
200.0

✍ site-packages

site-packages에 있는 모듈은 어디서나 사용 가능

예시1

모듈파일

실행파일

결과

✔ 실습1

site-packages에 약수와 소수를 리스트로 반환하는 모듈 만들기

모듈파일

실행파일

결과

[Python] 중급 3-1. 자주 사용하는 모듈

Sun, 19 May 2024 08:44:44 GMT

✍ math 모듈

수학 관련 모듈

1. 절대값

import math
print(f'math.fabs(-10):{math.fabs(-10)}')
print(f'math.fabs(-0.12895):{math.fabs(-0.12895)}')

# math.fabs(-10):10.0
# math.fabs(-0.12895):0.12895

2. 올림

import math
print(f'math.ceil(5.21):{math.ceil(5.21)}')
print(f'math.ceil(-5.21):{math.ceil(-5.21)}')

# math.ceil(5.21):6
# math.ceil(-5.21):-5

3. 내림

import math
print(f'math.floor(5.21):{math.floor(5.21)}')
print(f'math.floor(-5.21):{math.floor(-5.21)}')

# math.floor(5.21):5
# math.floor(-5.21):-6

4. 버림

import math
print(f'math.trunc(5.21):{math.trunc(5.21)}')
print(f'math.trunc(-5.21):{math.trunc(-5.21)}')

# math.trunc(5.21):5
# math.trunc(-5.21):-5

5. 최대공약수

import math
print(f'math.gcd(14,21):{math.gcd(14,21)}')

# math.gcd(14,21):7

6. 팩토리얼

import math
print(f'math.factorial(10):{math.factorial(10)}')

# math.factorial(10):3628800

7. 제곱근

import math
print(f'math.sqrt(4):{math.sqrt(4)}')
print(f'math.sqrt(12):{math.sqrt(12)}')

# math.sqrt(4):2.0
# math.sqrt(12):3.4641016151377544

✍ time 모듈

시간 관련 모듈

1. 현재 시간

import time
lt=time.localtime()
print(f'time.localtime(): {lt}')

# time.localtime(): time.struct_time(tm_year=2024, tm_mon=5, tm_mday=19, tm_hour=17, tm_min=30, tm_sec=20, tm_wday=6, tm_yday=140, tm_isdst=0)

2. 현재의 날짜(Year)

import time
print(f'lt.tm_year: {lt.tm_year}')

# lt.tm_year: 2024

3. 현재의 날짜(Month)

import time
print(f'lt.tm_mon: {lt.tm_mon}')

# lt.tm_mon: 5

4. 현재의 날짜(Day)

import time
print(f'lt.tm_mday: {lt.tm_mday}')

# lt.tm_mday: 19

5. 현재의 날짜(요일)

import time
print(f'lt.tm_wday: {lt.tm_wday}')

# lt.tm_wday: 6

6. 현재의 시간(시)

import time
print(f'lt.tm_hour: {lt.tm_hour}')

# lt.tm_hour: 17

7. 현재의 시간(분)

import time
print(f'lt.tm_min: {lt.tm_min}')

# lt.tm_min: 30

8. 현재의 시간(초)

import time
print(f'lt.tm_sec: {lt.tm_sec}')

# lt.tm_sec: 20

[Python] 중급3. 모듈

Sat, 18 May 2024 07:14:56 GMT

✍ 모듈

모듈이란, 이미 만들어진 훌륭한 기능
모듈 종류 1) 내부 모듈: 파이썬 설치 시 기본적으로 사용할 수 있는 모듈 2) 외부 모듈: 별도 설치 후 사용할 수 있는 모듈 3) 사용자 모듈: 사용자가 직접 만든 모듈

✔ 실습1

random 모듈을 이용하여 1부터 10까지 정수 중 난수 1개 발생

✔ 실습2

random 모듈을 이용하여 0부터 100까지 정수 중 난수 10개 발생

✍ 모듈 만들기

모듈은 특정 기능을 가지고 있는 파이썬 파일

✔ 실습1

로또 번호 6개를 출력하는 모듈 만들기

✔ 실습2

문자열을 거꾸로 반환하는 모듈 만들기

모듈파일

def reverseStr(str):
    reversedString=''
    for c in str:
        reversedString= c + reversedString

    return reversedString

실행파일

import reverseStr

userInputStr= input('문자열 입력: ')
reversedString= reverseStr.reverseStr(userInputStr)
print(f'reversedString:{reversedString}')

결과

문자열 입력: 파이썬 공부를 하고 있습니다.
reversedString:.다니습있 고하 를부공 썬이파

✍ 모듈 사용

1. import 키워드 사용

import 키워드를 이용하여 모듈을 임포트함

2. as 키워드 사용

as 키워드를 이용하여 모듈 이름을 단축

3. from 키워드 사용

from 키워드를 이용해서 모듈의 특정 기능만 사용
import 뒤에 *을 사용하면 해당 모듈의 모든 함수 호츌

✔ 실습1

국어, 영어, 수학 점수를 입력하면 총점, 평균을 출력하는 모듈 만들기

모듈파일

scores= []
def addScore(s):
    scores.append(s) #append는 괄호( ) 안에 값을 입력하면 새로운 요소를 array 맨 끝에 객체로 추가
def getScore():
    return scores
def getTotalScore():
    total = 0
    for s in scores:
        total += s
    return total
def getAvgScore():
    avg= (getTotalScore() / len(scores))
    return avg

실행파일

import scores as sc

korScore = int(input('국어점수: '))
engScore = int(input('영어점수: '))
matScore = int(input('수학점수: '))

sc.addScore(korScore)
sc.addScore(engScore)
sc.addScore(matScore)

print(sc.getScore())
print(sc.getTotalScore())
print(sc.getAvgScore())

결과

국어점수: 75
영어점수: 90
수학점수: 86
[75, 90, 86]
251
83.66666666666667

✍ 실행(메인) 파일

1. name 전역변수

name에는 모듈 이름이 저장되거나 'main'이 저장됨

✔ 실습

단위 환산 모듈을 만들고 cm를 mm, inch, m, ft로 변환하기

모듈파일

def cmToMm (n):
    return round (n*10, 3)

def cmToInch (n):
    return round (n*0.393, 3)

def cmToM (n):
    return round (n*0.01, 3)

def cmToFt (n):
    return round (n*0.032, 3)

실행파일

import unitConversion as uc

if __name__ == '__main__':
    inputNum= int(input('길이(cm)입력: '))
    returnValue= uc.cmToMm(inputNum)
    print(f'returnValue: {returnValue}mm')

    returnValue=uc.cmToInch(inputNum)
    print(f'returnValue: {returnValue}inch')

    returnValue=uc.cmToM(inputNum)
    print(f'returnValue: {returnValue}m')

    returnValue=uc.cmToFt(inputNum)
    print(f'returnValue: {returnValue}ft')

결과값1

길이(cm)입력: 10
returnValue: 100mm
returnValue: 3.93inch
returnValue: 0.1m
returnValue: 0.32ft

결과값2

길이(cm)입력: 35
returnValue: 350mm
returnValue: 13.755inch
returnValue: 0.35m
returnValue: 1.12ft

[Python] 중급2. 인수와 매개변수

Wed, 15 May 2024 16:13:48 GMT

✍ 인수와 매개변수

함수 호출 시 함수에 데이터를 전달할 수 있음

def greet (customer):
    print(f'{customer} 고객님 안녕하세요')

greet('홍길동')
greet('박찬호')
# 홍길동 고객님 안녕하세요
# 박찬호 고객님 안녕하세요

def greet (customer1, customer2):
    print(f'{customer1}, {customer2} 고객님 안녕하세요')

greet('홍길동', '박찬호')
# 홍길동, 박찬호 고객님 안녕하세요

✍ 인수와 매개변수의 개수

매개변수 개수가 정해지지 않은 경우: '*' 사용

def printNumber (*numbers): 
    for numer in numbers:
        print(numer, end='')
    print()

printNumber()
# (아무것도 없는 공란 출력)
printNumber(10)
# 10
printNumber(10,20)
# 1020
printNumber(10,20,30)
# 102030

✔ 실습 1

국어, 영어, 수학 점수를 입력받고, 입력받은 점수를 이용해서 총점과 평균을 출력하는 함수 만들기

✍ 지역변수와 전역변수

1. 전역변수

함수 밖에 선언된 변수로 어디에서나 사용은 가능
하지만, 함수 안에서 수정할 수 없음

# 전역변수
num_out=10 
print(f'num_out:{num_out}') # num_out:10

num_out=10
def printNum():
    print(f'num_out:{num_out}')

printNum() # num_out:10

2. 지역변수

함수 안에 선언된 변수로 함수 안에서만 사용가능

# 지역변수
def printNum(): 
    num_out=20
    print(f'num_out:{num_out}')

printNum() # num_out:20

# 아래의 경우, 호출 불가 
# num_in은 지역변수이기 때문에, 함수 밖에서는 호출이 불가함
def printNum_in():
    num_in=20
    print(f'num_in:{num_in}')

print(f'num_in: {num_in}') 
# NameError: name 'num_in' is not defined

3. global 키워드

global을 사용하면 함수 안에서도 전역 변수의 값을 수정할 수 있음.

num_out=10

def printNum():
    global num_out # global로 인해 지역변수가 전역변수로 바뀜
    num_out = 20
    print(f'num_out:{num_out}')

printNum() # num_out:20
print(f'num_out:{num_out}') # num_out:20

✔ 실습 1

사용자가 가로, 세로 길이를 입력하면 삼각형과 사각혀의 넓이를 출력하는 함수 만들기

✔ 실습 2

방문객 수를 카운트하는 함수 만들기

[Python] 중급1-2. 중첩함수, lambda함수

Wed, 15 May 2024 16:09:53 GMT

✍ 중첩함수

함수안에 또 다른 함수가 있는 형태

# 함수 내에, 'in_fuction'이라는 중첩함수 설정
def out_fuction():
    print('out_fuction called!!')

    def in_fuction():
        print('in_fuction called!!')
    in_fuction()

out_fuction()

# out_fuction called!!
# in_fuction called!!

중첨함수 중 내부함수는 함수 밖으로 호출 불가

def out_fuction():
  print('out_fuction called!!')

  def in_fuction():
      print('in_fuction called!!')
  in_fuction()

in_fuction()

NameError: name 'in_fuction' is not defined.


### ✔ 실습
- calculator()함수를 선언하고, calculator() 안에 덧셈, 뺄셈, 곱셈, 나눗셈 함수를 선언하기

def calculator(n1,n2,operator):

def addCal():
    print(f'덧셈: {round(n1+n2,2)}')

def subCal():
    print(f'뺄셈: {round(n1-n2,2)}')

def divCal():
    print(f'나눗셈: {round(n1/n2,2)}')

def mulCal():
    print(f'곱셈: {round(n1*n2,2)}')

if operator ==1:
    addCal()
elif operator ==2:
    subCal()
elif operator == 3:
    divCal()
elif operator == 4:
    mulCal()

while True: num1 = float (input('실수 n1: ')) num2 = float (input('실수 n2: ')) operatorNum= int(input('1. 덧셈, 2. 뺄셈, 3. 나눗셈, 4. 곱셈, 5. 종료 '))

if operatorNum ==5:
    print('Bye')
    break

calculator(num1, num2, operatorNum)

덧셈 결과

실수 n1: 3

실수 n2: 5

#1. 덧셈, 2. 뺄셈, 3. 나눗셈, 4. 곱셈, 5. 종료 1

덧셈: 8.0

뺄셈 결과

실수 n1: 10

실수 n2: 20

1. 덧셈, 2. 뺄셈, 3. 나눗셈, 4. 곱셈, 5. 종료 2

뺄셈: -10.0

나눗셈 결과

실수 n1: 20

실수 n2: 5

1. 덧셈, 2. 뺄셈, 3. 나눗셈, 4. 곱셈, 5. 종료 3

나눗셈: 4.0

곱셈 결과

실수 n1: 25

실수 n2: 6

1. 덧셈, 2. 뺄셈, 3. 나눗셈, 4. 곱셈, 5. 종료 4

곱셈: 150.0

종료

실수 n1: 0

실수 n2: 0

1. 덧셈, 2. 뺄셈, 3. 나눗셈, 4. 곱셈, 5. 종료 5

Bye


--------

# ✍ lambda 함수
- lambda 키워드를 사용하면 함수 선언을 간단하게 할 수 있음

calculator= lambda n1,n2: n1+n2 returnValue=calculator(10,20) print(f'returnValue:{returnValue}') # returnValue:30

### ✔ 실습
- 삼각형, 사각형, 원의 넓이를 반환하는 lambda함수 만들기
![](https://velog.velcdn.com/images/someone_3/post/a93d0ad1-e3bb-4e61-baf5-67e9478cec00/image.png)
![](https://velog.velcdn.com/images/someone_3/post/be271972-0725-4139-9cb2-31d54056706e/image.png)

[Python] 중급1-1. 함수

Wed, 15 May 2024 14:15:36 GMT

✍ 함수

1. 함수란?

파이썬의 함수는 수학의 함수와 동일
```
def addFun(x,y):
  return x+y
```

print(addFun(4,3)) #7

-----------
### 2. 파이썬의 함수 종류
#### 1) 내장 함수
- 파이썬에서 기본으로 제공하는 함수

str= input() print (f'str:{str}')

str:오늘은 파이썬을 공부하는 날입니다.

print (f'str length: {len(str)}')

str length: 19

numbers=[1,2,3,4,5] numbers.sort() print(f'numbers:{numbers}')

numbers:[1, 2, 3, 4, 5]

numbers.reverse() print(f'numbers:{numbers}')

numbers:[5, 4, 3, 2, 1]

numbers.clear() print(f'numbers:{numbers}')

numbers:[]

#### 2) 사용자 함수
- 사용자가 직접 선언하는 함수

def printUserName(name): print(f'{name}고객님, 안녕하세요')

def addCal(n1, n2): result = n1 + n2 print(f'n1+n2={result}')

-----------

### 3. 함수를 사용하는 이유
- 특정 기능을 재사용하기 위해서 사용

def addCal(n1, n2): print(f'n1 + n2 ={n1 + n2}')

addCal(3,4) addCal(15,27) addCal(197,3589)

#n1 + n2 =7 #n1 + n2 =42 #n1 + n2 =3786


-----------

### 4. 함수의 선언과 호출
#### 1) 함수 선언
- 함수는 def 키워드, 함수명, : , 들여쓰기를 이용하여 선언
![](https://velog.velcdn.com/images/someone_3/post/ae553bbb-69b8-4ec3-8396-3c39da605f95/image.png)

#### 2) 함수 호출
- 함수명과 '()'를 이용해서 함수 호출

![](https://velog.velcdn.com/images/someone_3/post/964efa16-9ba5-414e-bece-01c020e2bc5e/image.png)

def addCal(): n1= int(input('n1: ')) n2= int(input('n2: ')) print(f'n1+n2={n1+n2}')

addCal()

n1: 10

n2: 20

n1+n2=30


#### ✔ 실습 1
- 오늘 날씨를 출력하는 함수를 선언학 3번 호출

def printWeatherInfo (): print('오늘 날씨는 맑습니다. 기온은 25도 입니다.')

printWeatherInfo() printWeatherInfo() printWeatherInfo()

오늘 날씨는 맑습니다. 기온은 25도 입니다.


#### ✔ 실습 2
- 정수 두 개를 입력하면 곱셈과 나눗셈 연산 결과를 출력하는 함수를 만들고 호출해보자
![](https://velog.velcdn.com/images/someone_3/post/a33a796a-5b82-46cd-b1eb-821e69f1a702/image.png)

-----

### 5. 함수 내에서 또 다른 함수 호출
- 함수 내에서 또 다른 함수 호출
![](https://velog.velcdn.com/images/someone_3/post/0a831e2d-30e4-42c2-a8e0-c21988b64fba/image.png)

def fun1(): print('fun1 호출!') fun2() print('fun2를 실행 후에 마지막에 출력!')

def fun2(): print('fun2 호출!') fun3()

def fun3(): print('fun3 호출!')

fun1()

fun1 호출!

fun2 호출!

fun3 호출!

fun2를 실행 후에 마지막에 출력!


#### ✔ 실습
- 구구단 출력 함수가 연쇄적으로 호출되도록 함수 선언
![](https://velog.velcdn.com/images/someone_3/post/2c7a1d68-e886-4bd4-b7fe-31e14e36a760/image.png)



-------

### 6. 함수 실행결과 반환

- return 키워드를 이용하면 함수 실행결과를 호출부로 반환
![](https://velog.velcdn.com/images/someone_3/post/0e96e61d-cf5f-4e59-bf0b-45c5a813754f/image.png)

return 함수 없이 ()를 사용하여 그냥 함수 호출

def calculator(n1,n2): print(n1+n2)

calculator(10,20) #30

return함수 사용방법 1

def calculator(n1,n2): result=n1+n2

return result

print(calculator(10,20))

30 return함수 사용방법 2

def calculator(n1,n2): result=n1+n2

return result

returnValue=calculator(10,20) print(f'returnValue:{returnValue}')

returnValue:30


- 함수가 return을 만나면 실행 종료
![](https://velog.velcdn.com/images/someone_3/post/58b27d72-051f-43eb-8ed4-91b39bfc246b/image.png)

def divideNumber(n):

if n % 2 ==0:
    return '짝수'
else:
    return '홀수'

returnValue= divideNumber((5)) print(f'returnValue:{ returnValue}')

returnValue:홀수


#### ✔ 실습 1
- 사용자가 길이(cm)를 입력하면 mm로 환산하는 값을 변환하는 함수 만들기
![](https://velog.velcdn.com/images/someone_3/post/f18f9a8b-c39b-48a8-a2a3-db7a7b86053d/image.png)

#### ✔ 실습 2
- 1부터 100까지의 정수 중에서 홀수인 난수를 반환
![](https://velog.velcdn.com/images/someone_3/post/799aed05-ed86-42b3-b383-b916c3a2642f/image.png)
![](https://velog.velcdn.com/images/someone_3/post/803e5432-d1f8-4426-8e52-dad0536a8a5a/image.png)

[Python] 스터디 노트 목록

Mon, 13 May 2024 11:26:50 GMT

PART 1. Python

chapter 01. 파이썬 기초

chapter 02. 파이썬 중급

🔶 중급 1. 함수

중급1-1. 함수 중급1-2. 중첩함수, lambda함수

🔶 중급 2. 인수와 매개변수

중급 2. 인수와 매개변수

[Python] 기초 6-3. 중첩 반복문

Mon, 13 May 2024 11:19:26 GMT

✍ 중첩 반복문

반복문 안에 또 다른 반복문 선언

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

# *
# **
# ***
# ****
# *****
# ******
# *******
# ********
# *********

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

# **********
# *********
# ********
# *******
# ******
# *****
# ****
# ***
# **
# *

✔ 실습

구구단 전체를 출력

[Python] 기초 6-2. 조건에 의한 반복문

Mon, 13 May 2024 11:18:45 GMT

✍ 조건에 의한 반복문

조건에 만족하면 반복 실행, 그렇지 않으면 반복 중단
ex) 매일 아침 기상 알람, 게임 반복 실행, 타이머
조건에 의한 반복은 while 문 주로 사용

1. while문

# n이 10 이하이면 반복 실행
endNum=10
n=0

while n <= endNum:
    print(n)
    n+=1

# 7단 구구단 출력

i=1
while i <10:
    result= 7 * i
    print('{} * {} = {}' .format(7, i, result))
    i +=1

# 7 * 1 = 7
# 7 * 2 = 14
# 7 * 3 = 21
# 7 * 4 = 28
# 7 * 5 = 35
# 7 * 6 = 42
# 7 * 7 = 49
# 7 * 8 = 56
# 7 * 9 = 63

✔ 실습 1

1부터 100까지의 정수 중 2의 배수와 3의 배수를 구분해서 출력

✔ 실습 2

while문을 이용해서 사용자가 입력한 구구단 출력

✔ 실습 3

자동차 바퀴가 한번 구를 때마다 0.15mm씩 마모된다고 한다.
현대의 바퀴 두께가 30mm
최소 운행 가능 바퀴 두께가 20mm

앞으로 구를 수 있는 횟수는?

currentThickness=30
rotationCount=0
## removeThickness= 0.15

while currentThickness >= 20: rotationCount += 1 currentThickness-= removeThickness

safeRotationCount=rotationCount-1 print('운행 가능 횟수: {}' .format(safeRotationCount))

운행 가능 횟수: 66

--------

### 2. 무한루프
- 반복문을 빠져나올 수 없는 경우를 무한 루프라고 함
- while문에서 조건식의 결과가 항상 True인 경우

무한루프

n=1 while n < 10: print('Hello')

9번만 실행하는 경우

n=1 while n < 10: print('Hello') n += 1


#### 1) 논리형 데이터에서 무한루프

무한루프

flag= True num=0 sum=0

while flag: num+=1 sum += num print('{}까지의 합은 {}입니다'.format(num,sum))

위의 무한 루프를 중단하기 위해, while문에 if문 추가

flag= True num=0 sum=0

while flag: num+=1 sum += num print('{}까지의 합은 {}입니다'.format(num,sum))

if sum>=1000:
    flag=False


#### ✔ 실습 
- 하루에 독감으로 병원에 내방하는 환자수가 50명에서 100명 사이일 때, 누적 독감 환자 수가 최초 10,000명을 넘는 날짜를 구해보자

![](https://velog.velcdn.com/images/someone_3/post/b7c67176-3b6a-4989-afe7-bf4e93e1a4bc/image.png)

--------------

### 3. 반복문 제어

#### 1) continue 키워드
- 반복 실행 중 continue를 만나면 실행을 생략하고, 다음 반복 실행문으로 넘어감
![](https://velog.velcdn.com/images/someone_3/post/f4125551-3903-4490-85ed-d3b75aa9af89/image.png)
![](https://velog.velcdn.com/images/someone_3/post/88af8a21-adec-44b5-96ab-6e25981cc62a/image.png)

#### 2) else 키워드
- else의 실행문은 반복문이 종료된 후 실행
![](https://velog.velcdn.com/images/someone_3/post/61a9550f-1254-4c88-b0ef-f604e34db95f/image.png)
![](https://velog.velcdn.com/images/someone_3/post/9c815f7b-2c34-4c9c-a90e-c1cb927b46f9/image.png)


#### ✔ 실습
- 1부터 100까지의 정수 중 3과 7의 공배수와 최소 공배수 출력
![](https://velog.velcdn.com/images/someone_3/post/14b9eafc-5f38-4bea-b11c-d803728cdccd/image.png)

#### 3) break 키워드
- 반복 실행 중 break를 만나면 반복문을 빠져나옴
![](https://velog.velcdn.com/images/someone_3/post/db0775a1-387b-4c4e-991b-f25de2e5ae1a/image.png)

num=0

while True: print('Hello') num+=1 if num>=5: break print('The End')

Hello

The End


#### ✔ 실습 1
- 1부터 100까지 정수를 더할 때, 합계가 넘는 최최의 정수 찾기

sum=0 searchNum=0

for i in range (100): sum += i

if sum >100:
    searchNum = i
    break

print('searchNum: {}' .format(searchNum))

searchNum: 14


#### ✔ 실습 2
- 10의 팩터리얼 (10!)을 계산하는 과정에서 결과값이 50을 넘을 때의 숫자 구하기

result=1 num=0

for i in range(1,10): result *= i

if result>50:
    num = i
    break

print('num: {}, result:{}' .format(num, result))

num: 5, result:120


#### ✔ 실습 3
- 새끼 강아지 체중이 2.2kg가 넘으면 이유식 중단
- 한번 이유식을 먹을 때 체중이 70g 증가
- 현재 체중은 800g
- 예상되는 이유식 날짜를 구하자

nowWeight=800 maxWeight=2200 addWeight=70

date=1

while True: if nowWeight >= maxWeight: break

date+=1
nowWeight += addWeight

print('이유식 중단날짜: {}' .format(date))

이유식 중단날짜: 21

```

[Python] 기초6-1. 횟수에 의한 반복문

Mon, 13 May 2024 11:16:37 GMT

✍ 반복문이란?

반복문이란 특정 실행을 반복하는 것
반복문을 사용하면 프로그래밍이 간결하고 유지 보수가 쉬움
ex) 대량 메일 또는 문자 발송, 인사말 반복, 구구다 출력, 팩토리얼 (4!=24), 매일 아침 기상 알림, 게임 반복 실행, 타이머 등
반복문의 종류 1) 횟수에 의한 반복 2) 조건에 의한 반복

✍ 횟수에 의한 반복문

횟수 지정 -> 횟수 만큼 반복 실행
ex) 회원 100명에게 메일 발송, MP3 반복 재생 등

1. for문 사용

for ~ in 키워드 작성

for i in range(100):
  print ('i' -> {}' .format(i))

for j in range(10):
  result= 7 * j
  print( '{} * {} = {}' .format(7,j,result))

7 * 0 = 0

7 * 1 = 7

7 * 2 = 14

7 * 3 = 21

7 * 4 = 28

7 * 5 = 35

7 * 6 = 42

7 * 7 = 49

7 * 8 = 56

7 * 9 = 63

for h in range(5): print('hi',end='') print(' loop statement')

hi loop statement


### 2. range() 함수
- 반복의 범위를 설정하는 함수
![](https://velog.velcdn.com/images/someone_3/post/4938154d-588d-499e-9d30-b68aa34ac9e1/image.png)

0부터 9까지 2씩 증가하면서 반복

for i in range (0,10,2): print(i)

5부터 9까지 1씩 증가하면서 반복

for i in range (5,10,1): print(i)


- 단계가 1인 경우, 단계 매개변수 생략 가능

1부터 10까지 1씩 증가하면서 반복

for i in range (1,11): print(i)


- 시작이 0인 경우, 시작매개변수 생략 가능

0부터 10까지 1씩 증가하면서 반복

for i in range (11): print(i)


✔ 실습 1
- 사용자가 반복의 시작과 끝을 입력하면, 1씩 증가하는 반복문 만들기
![](https://velog.velcdn.com/images/someone_3/post/7c351156-a979-4a16-98c0-1f813c6e716c/image.png)

✔ 실습 2
- 실습1에서 작성한 반복문을 이용해서, 2씩 증가하는 반복문 만들기
![](https://velog.velcdn.com/images/someone_3/post/09b99fb9-878f-4527-b24f-9c4ddfddb70e/image.png)

[Python] 기초5-4. 중첩 조건문

Sun, 12 May 2024 09:48:05 GMT

✍ 중첩 조건문

조건문 안에 또 다른 조건문을 선언

examScore=int(input('점수: '))
minScore = 60

if examScore < minScore:
    print('재시험')
else:
    if examScore>=90:
        print('A')
    elif examScore>=80:
        print('B')
    elif examScore>=70:
        print('C')
    elif examScore>=60:
        print('D')

# 점수: 59
# 재시험

# 점수: 65
# D

# 점수: 100
# A

✔ 실습

출퇴근 시 이용하는 교통수단에 따라 세금을 감면해 주는 정책을 세우려고 한다. 다음 내용에 맞는 코드를 작성해라

[Python] 기초5-3. IF ~ ELIF 조건문

Sun, 12 May 2024 09:43:24 GMT

✍ if ~ elif 문 (다자택일 조건문)

여러 가지 조건식 결과에 따라 실행문이 결정
다자택일 사용시 주의할 점
1. 조건식의 순서가 중요함
2. 조건 범위를 명시

✔ 실습 1

점수에 맞는 학점을 출력

방법1: A,B,C,D,F 학점 코드를 순서대로 작성

점수에 맞는 학점이 제대로 출력⭕

방법2: C학점 코드를 먼저 작성 후에, A,B,D,F학점 코드 작성

80점 이상도 모두 C학점으로 출력
점수에 맞는 학점이 제대로 출력되지 않음❌

방법3: C학점 코드를 먼저하되, C학점의 조건 범위를 정확하게 명시 후에, A,B,D,F 학점 코드 작성

C학점의 상한 점수를 설정함
점수에 맞는 학점이 제대로 출력⭕

✔ 실습2

계절을 입력하면 영어로 변역되는 프로그램 작성

✔ 실습3

키오스크에서 메뉴를 선택하면 영수증이 출력되는 프로그램 작성

[Python] 기초5-2. IF ~ ELSE 조건문

Sun, 12 May 2024 09:22:51 GMT

✍ if ~ else 문 (양자택일 조건문)

조건식 결과에 따라 둘 중에 하나가 실행됨

passScore=80
myScore=int(input('점수입력:'))

if myScore>=passScore:
    print('Pass')
else:
    print('Fail')

# 점수입력: 93 
# Pass

# 점수입력: 75
# Fail

pass 키워드 : 나중에 코딩하겠다는 의미
```
passScore=80
myScore=int(input('점수입력:'))
```

if myScore>=passScore: pass else: pass

어떠한 점수를 입력해도, 이후에 아무것도 출력되지 않음


### ✔ 실습1
- 나이가 65세 이상이면 교통 요금 무료를 적용하는 프로그램을 만들기
![](https://velog.velcdn.com/images/someone_3/post/0851e2ec-bf92-45bd-98a4-b27bde9ab692/image.png)
![](https://velog.velcdn.com/images/someone_3/post/3779a36c-0d0b-40a9-bf16-a8eefeb56657/image.png)
![](https://velog.velcdn.com/images/someone_3/post/865cc346-d9d5-4d62-a77d-62978c810574/image.png)


### ✔ 실습2
- 소수점 첫 번째 자리에서 반올림하는 프로그램을 만들어 보자
![](https://velog.velcdn.com/images/someone_3/post/19a54783-8934-4d6a-9fac-a79a87439044/image.png)
![](https://velog.velcdn.com/images/someone_3/post/2fd6fb48-b39a-4ead-a1b0-aff725a81a14/image.png)


### ✔ 실습3
- 비올 확률을 입력하고, 
- 비올 확률이 55% 이상이면 '우산을 챙기세요' 츨력
- 그렇지 않으면, '양산을 챙기세요' 츨력

** 방법 1) 조건식으로 작성**
- ![](https://velog.velcdn.com/images/someone_3/post/5975dab2-7d33-4e1a-80b1-b237af6b2817/image.png)
- ![](https://velog.velcdn.com/images/someone_3/post/0c2861e4-3d0b-4090-ac13-618f8d0ee360/image.png)

** 방법 2) 'if ~ else 문'으로 작성**
- ![](https://velog.velcdn.com/images/someone_3/post/15a12a79-6c63-494f-b6ee-e5c7b888360b/image.png)
- ![](https://velog.velcdn.com/images/someone_3/post/2c529594-2930-4e08-810b-21dc40eec275/image.png)

[Python] 기초5-1. IF 조건문

Sun, 12 May 2024 07:36:04 GMT

✍ 조건문이란?

특정 조건에 따라 프로그램을 분기
조건문의 종류 if 문 -> 단일 조건 if ~ else 문 -> 양자택일 if ~ elif 문 -> 다자택일 (다중조건)

✍ if 문

조건식이 True 이면 실행문 작동 O
조건식이 False 이면 실행문 작동 X

if 10>5:
    print('10은 5보다 크다.')
# 결과값: 10은 5보다 크다.

✔ 실습1

국어, 영어, 수학 점수를 입력하고 평균아 90점 이상이면 '참 잘했어요.'를 출력하는 코드 작성

✔ 실습2

실내 온도를 입력하고 온도가 28도 이상이면 '냉방작동!' 출력
20도 이하이면, '난방작동!' 출력

[Python] 기초5. 조건식

Tue, 07 May 2024 14:27:32 GMT

✍ 조건식

조건식이란, 어떤 조건에 따라 실행되는 식
A if 조건식 else B: 조건식의 결과가 True 이면 A실행, 그렇지 않으면 B실행

num1=10
num2=100
numresult = True if num1>num2 else False

print('num1>num2: {}' .format(numresult))
# num1>num2: False
print('num1은 num2보다 크다') if numresult else print('num1은 num2보다 크지 않다')
# num1은 num2보다 크지 않다

✔ 실습1

적설량을 입력하고 적설량이 30mm 이상이면 대설 경보를 발령, 그렇지 않으면 대설 경보를 해제하는 코드 작성

✔ 실습2

국어, 영어, 수학 점수를 입력하면 조건식을 이용해서 과목별 결과와 전체결과를 출력하는 코드 작성

[Python] 기초4. operator 모듈

Tue, 07 May 2024 14:10:17 GMT

✍ 모듈

모듈이란, 누군가 이미 만들어놓은 기능 ex1) 수학 연산 관련 모듈 ex2) 난수 관련 모듈 ex3) 연산자 관련 모듈

✍ operator 모듈

1. 산술 연산자 관련 함수

import operator

num1=8
num2=3

print('{}+{}: {}' .format(num1,num2,operator.add(num1,num2)))
# 8+3: 11
print('{}-{}: {}' .format(num1,num2,operator.sub(num1,num2)))
# 8-3: 5
print('{}*{}: {}' .format(num1,num2,operator.mul(num1,num2)))
# 8*3: 24
print('{}/{}: {}' .format(num1,num2,operator.truediv(num1,num2)))
# 8/3: 2.6666666666666665
print('{}%{}: {}' .format(num1,num2,operator.mod(num1,num2)))
# 8%3: 2
print('{}//{}: {}' .format(num1,num2,operator.floordiv(num1,num2)))
# 8//3: 2
print('{}**{}: {}' .format(num1,num2,operator.pow(num1,num2)))
# 8**3: 512

2. 비교 연산자 관련 함수

import operator

num1=8
num2=3

print('{}={}: {}' .format(num1,num2,operator.eq(num1,num2)))
# 8=3: False
print('{}!={}: {}' .format(num1,num2,operator.ne(num1,num2)))
# 8!=3: True
print('{}>{}: {}' .format(num1,num2,operator.gt(num1,num2)))
# 8>3: True
print('{}>={}: {}' .format(num1,num2,operator.ge(num1,num2)))
# 8>=3: True
print('{}<{}: {}' .format(num1,num2,operator.lt(num1,num2)))
# 8<3: False
print('{}<={}: {}' .format(num1,num2,operator.le(num1,num2)))
# 8<=3: False

3. 논리 연산자 관련 함수

import operator

flag1=True
flag2=False

print('{} and {}: {}' .format(flag1,flag2,operator.and_(flag1,flag2)))
# True and False: False
print('{} or {}: {}' .format(flag1,flag2,operator.or_(flag1,flag2)))
# True or False: True
print('not {}: {}' .format(flag1,operator.not_(flag1)))
# not True: False

✔ 실습1

"백신 접종 대상자는 20세 미만 또는 65세 이상자에 한합니다"를 operator 모듈을 이용하여 만들어 보자

✔ 실습2

random과 operator 모듈을 사용하여 10부터 100사이의 난수 중 십의 자리와 일의 자리가 각각 3의 배수인지 판단하는 코드를 작성

[Python] 기초 3-4. 논리연산자

Tue, 07 May 2024 13:47:58 GMT

✍ 논리연산자

피연산자의 논리(True, False)를 이용한 연산

1. and 연산자

A and B : A와 B 모두 True인 경우만 결과값이 True

print('{} and {}: {}'.format(True,True,(True and True)))
# True and True: True
print('{} and {}: {}'.format(True,False,(True and False)))
# True and False: False
print('{} and {}: {}'.format(False,True,(False and True)))
# False and True: False
print('{} and {}: {}'.format(False,False,(False and False)))
# False and False: False

2. or 연산자

A or B: A와 B중 어느 하느만 True이면 결과 값은 True

print('{} or {}: {}'.format(True,True,(True or True)))
# True or True: True
print('{} or {}: {}'.format(True,False,(True or False)))
# True or False: True
print('{} or {}: {}'.format(False,True,(False or True)))
# False or True: True
print('{} or {}: {}'.format(False,False,(False or False)))
# False or False: False

3. not 연산자

not A: A의 상태를 부정하는 결과를 나타냄

print('not {}: {}'.format(True,(not True)))
# not True: False
print('not {}: {}'.format(False,(not False)))
# not False: True

✔ 실습1

'백신 접종 대상자는 20세 미만 또는 65세 이상자에 한합니다.'를 논리연산자를 이용해서 코딩

✔ 실습2

국어, 영어, 수학 점수를 입력하고 평균이 70점 이상이면 True를 출력
단, 과목별 점수가 최소 60 이상인 경우에 True를 출력

[Python] 기초 3-3. 비교연산자

Mon, 06 May 2024 14:34:28 GMT

✍ 비교 연산자

연산 결과는 bool이므로, True / False로만 출력

1. 숫자 비교

num1=10 ; num2=20

result=num1num2
print('num1>num2: {}' .format(result))
# num1>num2: False

result=num1>=num2
print('num1>=num2: {}' .format(result))
# num1>=num2: False

result=num1==num2
print('num1==num2: {}' .format(result))
# num1==num2: False

result=num1!=num2
print('num1!=num2: {}' .format(result))
# num1!=num2: True

✔ 실습1

숫자 2개를 입력한 후 비교 연산 결과를 출력하는 코드 작성

✔ 실습2

자동차의 전장과 전폭을 입력하면, 자동차 기계 세차 가능여부를 출력하는 코드 작성
최대 전장길이: 5200mm
최대 전폭길이: 1985mm
코드
결과값1
결과값 2
결과값3

2. 문자 비교

- 아스키 코드를 사용

cha1='A' # 아스키코드 65
cha2='S' # 아스키코드 83

print('\'{}\'>\'{}\' : {}'.format(cha1,cha2,(cha1>cha2)))
# 'A'>'S' : False
print('\'{}\'>=\'{}\' : {}'.format(cha1,cha2,(cha1>=cha2)))
# 'A'>='S' : False
print('\'{}\'<=\'{}\' : {}'.format(cha1,cha2,(cha1

`1) 문자에서 아스키코드 변환`



ord() 함수 사용

print('\'A\'->{}' .format(ord('A')))
# 'A'->65
print('\'a\'->{}' .format(ord('a')))
# 'a'->97
print('\'s\'->{}' .format(ord('s')))
# 's'->115
2) 아스키 코드를 문자로 변환

chr() 함수 사용

print('65->\'{}\''.format(chr(65)))
# 65->'A'
print('97->\'{}\''.format(chr(97)))
# 97->'a'
print('115->\'{}\''.format(chr(115)))
# 115->'s'
3) 문자열 자체 비교
str1= 'Hello'
str2= 'hello'

print('{}=={} : {}' .format(str1,str2,str1==str2))
# Hello==hello : False
print('{}!={} : {}' .format(str1,str2,str1!=str2))
# Hello!=hello : True
✔ 실습1

알파벳을 입력하면 아스키 코드를 출력하는 코드 작성




✔ 실습2

아스키코드를 입력하면 문자를 출력하는 코드 작성