์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | 2 | 3 | 4 | 5 | 6 | 7 |
8 | 9 | 10 | 11 | 12 | 13 | 14 |
15 | 16 | 17 | 18 | 19 | 20 | 21 |
22 | 23 | 24 | 25 | 26 | 27 | 28 |
29 | 30 | 31 |
- Absolute
- AGI
- ai
- AI agents
- AI engineer
- AI researcher
- ajax
- algorithm
- Algorithms
- aliases
- Array ๊ฐ์ฒด
- ASI
- bayes' theorem
- Bit
- Blur
- BOM
- bootstrap
- canva
- challenges
- ChatGPT
- Today
- In Total
A Joyful AI Research Journey๐ณ๐
[41] 230224 Ch. 3 ๋ผ์ฆ๋ฒ ๋ฆฌ ํ์ด๋ฅผ ์ํ ํ์ด์ฌ ๊ธฐ์ด ๋ฐฐ์ฐ๊ธฐ: 3. ํ์ด์ฌ ์ ์ด๋ฌธ, 4. ํ์ด์ฌ ํจ์ ์ฌ์ฉ๋ฒ [K-๋์งํธ ํธ๋ ์ด๋ 41์ผ] ๋ณธ๋ฌธ
[41] 230224 Ch. 3 ๋ผ์ฆ๋ฒ ๋ฆฌ ํ์ด๋ฅผ ์ํ ํ์ด์ฌ ๊ธฐ์ด ๋ฐฐ์ฐ๊ธฐ: 3. ํ์ด์ฌ ์ ์ด๋ฌธ, 4. ํ์ด์ฌ ํจ์ ์ฌ์ฉ๋ฒ [K-๋์งํธ ํธ๋ ์ด๋ 41์ผ]
yjyuwisely 2023. 2. 24. 12:48230223 Fri 41st class
Ch. 3 ๋ผ์ฆ๋ฒ ๋ฆฌ ํ์ด๋ฅผ ์ํ ํ์ด์ฌ ๊ธฐ์ด ๋ฐฐ์ฐ๊ธฐ
์ง๋: p. 93 ~ (๊ต์ฌ: IoT ์ฌ๋ฌผ์ธํฐ๋ท์ ์ํ ๋ผ์ฆ๋ฒ ๋ฆฌํ์ด 4 ์ ์, ์ ์: ์ต์ฃผํธ , ๊น์ฌ๋ฒ , ์ ๋์ง)
์ฐธ๊ณ ๊ฐ๋ฅ ์ฑ
: ์์ด๋ณด๋ฅผ ์ํ Python: ์ฝ๊ฒ ํ์ด ์ด ๊ธฐ์ด ๋ฌธ๋ฒ๊ณผ ์ค์ต
๊ต์ฌ ์ฝ๋ ๊นํ๋ธ: https://github.com/codingspecialist/RaspberryPi4-Book-Example
๊ต์ฌ ์์ค ๋ฐ PPT: http://jspstudy.co.kr/main/main.jsp
์ ์ ์นดํ: https://cafe.naver.com/metacoding
์ค๋ ๋ฐฐ์ด ๊ฒ ์ค ๊ธฐ์ตํ ๊ฒ์ ์ ๋ฆฌํ๋ค.
๋ด๊ฐ ๋ชฐ๋๋ ๊ฒ
ํ์ด์ฌ์ ์ํฐ๊ฐ ๊ธฐ๋ณธ์ ์ผ๋ก ๋ถ๋๋ค.
ํ์ด์ฌ์ print = ์๋ฐ์ System.print.outln()
end="" indicates that the end character has to be identified by whitespace and not a newline.
In computer science, control flow is the order in which individual statements, instructions or function calls of an imperative program are executed or evaluated.
In computer science, imperative programming is a programming paradigm of software that uses statements that change a program's state.
The range() function returns a sequence of numbers, starting from 0 by default, and increments by 1 (by default), and stops before a specified number.
range(start, stop, step)
Parameter | Description |
start | Optional. An integer number specifying at which position to start. Default is 0 |
stop | Required. An integer number specifying at which position to stop (not included). |
step | Optional. An integer number specifying the incrementation. Default is 1 |
def () ์ด์ ์ print๊ฐ ์์ผ๋ฉด ํจ์ ์ธ์ถ print๋์ด์ ๋์จ๋ค.
Ch. 3 ๋ผ์ฆ๋ฒ ๋ฆฌ ํ์ด๋ฅผ ์ํ ํ์ด์ฌ ๊ธฐ์ด ๋ฐฐ์ฐ๊ธฐ
์ฑ ์ ๋ชฉ์ฐจ
01 _ ํ์ด์ฌ ์์ํ๊ธฐ
01-1 ํ์ด์ฌ ๊ฐ์
01-2 ํ์ด์ฌ Windows ์ค์นํ๊ธฐ
01-3 ํ์ด์ฌ์ ์ฃผ์
02 _ ํ์ด์ฌ ์๋ฃํ
02-1 ์ซ์ํ
02-2 ๋ฌธ์ํ
02-3 ๋ฆฌ์คํธ
02-4 ํํ
02-5 ๋์ ๋๋ฆฌ
03 _ ํ์ด์ฌ ์ ์ด๋ฌธ
03-1 if๋ฌธ
03-2 for๋ฌธ
03-3 whie๋ฌธ
03-4 break๋ฌธ
04 _ ํ์ด์ฌ ํจ์ ์ฌ์ฉ๋ฒ
04-1 ํจ์ ์ ์ธํ๊ธฐ
04-2 ํจ์ ์ธ์ ์ฌ์ฉํ๊ธฐ
05 _ ํ์ด์ฌ ํด๋์ค์ ๋ชจ๋
05-1 ํด๋์ค
05-2 ๋ชจ๋
05-3 ๋ผ์ด๋ธ๋ฌ๋ฆฌ
3 ํ์ด์ฌ ์ ์ด๋ฌธ (Control flow) p. 95
์ ์ด๋ฌธ์ ํ๋ก๊ทธ๋จ์ ์คํ์ฌ๋ถ, ์์, ๋ฐฉ์์ ์ ์ดํ๋ ๋ฌธ์ฅ์ด๋ค.
3.1 if๋ฌธ
"๋ง์ฝ ์ง์ ํ ์กฐ๊ฑด์ ๋ง์ ๋จ์ด์ง๋ฉด ์ง์ ํ ์ฝ๋๋ฅผ ์คํํ๋ผ"์ ๋ป์ด๋ค.
ํ์ด์ฌ์์๋ ๋ค์ฌ์ฐ๊ธฐ๊ฐ ์ค์ํ๋ค.
์์ ) if๋ฌธ, else๋ฌธ, elif๋ฌธ ์ค๋ช ์ ์ํ ์์
a = 23
if a < 50:
print('50๋ณด๋ค ์๊ตฐ์')
#if else๋ฌธ
if a < 20:
print('20๋ณด๋ค ์๊ตฐ์')
else:
print('20๋ณด๋ค ํฌ๊ตฐ์')
#elif๋ฌธ
age = int(input('ํ์ฌ ๋์ด๋ฅผ ์
๋ ฅํฉ๋๋ค.'))
if age < 10:
print('์ ๋
์ธต ์
๋๋ค.')
elif age < 20:
print('10๋์
๋๋ค.')
elif age < 30:
print('20๋์
๋๋ค.')
elif age < 40:
print('30๋์
๋๋ค.')
else:
print('์ฅ๋
์ธต์
๋๋ค')
์๋๋ ์์ ๊ฐ์ ์๋ฐ์ ์ฝ๋์ด๋ค.
class If01{
public static void main(String[] args){
int a = 23;
if (a < 50){
System.out.println("50๋ณด๋ค ์๊ตฐ์");
}
if(a < 20){
System.out.println("20๋ณด๋ค ์๊ตฐ์");
}else{
System.out.println("50๋ณด๋ค ์๊ตฐ์");
}
}
Scanner scanner = new Scanner(System.in);
int age = Integer.parseInt(scanner.next())
if(age < 10){
System.out.println("์ ๋
์ธต ์
๋๋ค.");
}else if(age < 20){
System.out.println("10๋ ์
๋๋ค.");
}else if(age < 30){
System.out.println("20๋ ์
๋๋ค.");
}else if(age < 40){
System.out.println("30๋ ์
๋๋ค.");
}else{
System.out.println("์ฅ๋
์ธต์
๋๋ค.");
}
}
}
๊ฒฐ๊ณผ)
50๋ณด๋ค ์๊ตฐ์
20๋ณด๋ค ํฌ๊ตฐ์
ํ์ฌ ๋์ด๋ฅผ ์
๋ ฅํฉ๋๋ค.23
20๋์
๋๋ค.
3.2 for๋ฌธ
for๋ฌธ์ ํน์ ์ฝ๋๋ฅผ ์ง์ ํ ํ์๋งํผ ๋ฐ๋ณตํ๋ ๋ฌธ์ฅ์ด๋ค.
๋ฐ๋ณตํ๋ ๊ธฐ์ค์ ๋ณ์์ ํฌ๊ธฐ๋ ์ซ์, ๋ฌธ์์ด์ ๊ธธ์ด ๋ฑ ๋ค์ํ ๊ธฐ์ค์ด ์ฌ์ฉ๋ ์ ์๋ค.
์์ 1) for๋ฌธ์ ๋ค์ํ ํํ๋ก ์ ์ธํ ์์
# 0 ~ 4 ์ถ๋ ฅ
# for(int i = 0; i < 5; i++)
# ์ด๊ธฐํ ์กฐ๊ฑด์ ์ฆ๊ฐ๊ฐ
for i in range(0, 5, 1): #for๋ฌธ ์ ์ธ ๋ณ์ i์ ์ด๊ธฐ๊ฐ์ 0์ด๊ณ ๋ฒ์๋ 5์ด๊ณ 1์ฉ ์ฆ๊ฐ
print(i) #for๋ฌธ ์กฐ๊ฑด์ด ๋ง์ผ๋ฉด ๋ฐ๋ณต๋๋ ์ฝ๋
print("--------------------")
#๋๊ดํธ: ๋ฆฌ์คํธ
for j in[1, 3, 5, 7, 9]: #for๋ฌธ ์ฒ๋ฆฌํ ๋ชฉ๋ก์๋ ๋ฆฌ์คํธ ๋ณ์ ์ ์ธ
print(j)
print("--------------------")
for k in range(0, 3, 1):
print("๊ฟ์ ์ด๋ฃจ์ด ์ง๋ค.")
์๋๋ ์๋ฐ์ ์ฝ๋์ด๋ค.
class For01{
public static void main(String[] args){
for(int i = 0; i < 5; i++){
System.out.println(i);
}
int[] odd = {1,3,5,7,9}
for (int j : odd){
System.out.println(j);
}
}
}
๊ฒฐ๊ณผ)
0
1
2
3
4
--------------------
1
3
5
7
9
--------------------
๊ฟ์ ์ด๋ฃจ์ด ์ง๋ค.
๊ฟ์ ์ด๋ฃจ์ด ์ง๋ค.
๊ฟ์ ์ด๋ฃจ์ด ์ง๋ค.
์์ 2) for๋ฌธ์ ์ด์ฉํ์ฌ ์ฌ๋ฌ ๊ฐ์ง ์ง๋ฌธ์ ๋ํ ๋ต๋ณ์ ๊ตฌํ๋ค.
ํ์ด์ฌ์ ์ํฐ๊ฐ ๊ธฐ๋ณธ์ ์ผ๋ก ๋ถ๋๋ค.
ํ์ด์ฌ์ print = ์๋ฐ์ System.print.outln()
end="" indicates that the end character has to be identified by whitespace and not a newline.
#for๋ฌธ์ ์ด์ฉํ์ฌ 1์์ 10๊น์ง์ ํฉ ๊ตฌํ๊ธฐ
sum = 0
for i in range(1, 11, 1):
sum+=i
print("sum : %d" % sum)
print("-----------------")
#for๋ฌธ์ ์ด์ฉํ์ฌ 1์์ 10๊น์ง ์๊ณผ ํฉ ๊ตฌํ๊ธฐ
sum = 0
for j in range(1, 11, 1):
if j<10:
print("%d + " % j, end="")
elif j==10:
print("%d = " % j, end="")
sum+=j
print("%d" % sum)
์๋ฐ์ ์ฝ๋๋ ์๋๊ณผ ๊ฐ๋ค.
The Java printf function helps simplify the task of printing formatted output to the console, terminal window or log files.
class For02{
public static void main(String[] args){
int sum1 = 0;
for(int i = 1; i < 11; i++){
sum1 += i //sum1 = sum1 + i
}
System.out.printf("sum1: %d", sum1)
}
int sum2 = 0;
for(int i = 1; i < 11; i++){
//j๊ฐ์ด 1~9๊น์ง "+"๋ฌธ์์ด์ ์ฐ๊ฒฐํ๊ณ ,
if(j < 10){
System.out.printf("%d + ", j)
}else if(j==10){
System.out.printf("%d = ", j)
}
//j๊ฐ์ด 10์ด๋ฉด "=" ๋ฌธ์์ด์ ์ฐ๊ฒฐ
sum2 += i //sum2 = sum2 + i
}
System.out.printf("sum2: %d", sum2)
}
}
๊ฒฐ๊ณผ)
sum : 55
-----------------
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = 55
3.3 while๋ฌธ
์กฐ๊ฑด๋ถ ๋ฐ๋ณต๋ฌธ์ด๋ค. if๋ฌธ์ ๋ฐ๋ณต๋ฌธ ํํ์ด๋ค. ์กฐ๊ฑด์ ์ง์ ํ๊ณ ์กฐ๊ฑด์ด true์ผ ๋ ์คํ๋๋ฉฐ, ์กฐ๊ฑด์ด false๊ฐ ๋ ๋๊น์ง ๋ฐ๋ณตํ๋ค. ์กฐ๊ฑด์ด false๊ฐ ๋์ง ์์ผ๋ฉด ๋ฌดํ๋ฃจํ(๋ฌดํ๋ฐ๋ณต)์ด ๋ฐ์ํ๋ค.
ํ์ด์ฌ์์ ์กฐ๊ฑด์ด ์๋ ๋ฐ๋ณต๋ฌธ์ for๋ฌธ
์กฐ๊ฑด์ด ์๋ ๋ฐ๋ณต๋ฌธ์ while๋ฌธ์ด๋ค.
์๋ฐ: for, while, do-while
์์ )
str = "๊ฟ์ ์ด๋ฃจ์ด ์ง๋ค"
i = 0
while i < 3:
print(str)
i = i + 1
print("-------------------------------")
#while๋ฌธ์ผ๋ก ์
๋ ฅํ ์ซ์๋งํผ str์ ๋ฐ๋ณต ์ถ๋ ฅํ์์ค.
i = int(input("๋ฐ๋ณต ํ์ ์ซ์๋ฅผ ์
๋ ฅํฉ๋๋ค.")) #์ฌ์ฉ์๊ฐ ์
๋ ฅํ ๊ฐ์ ์ ์๋ก ๋ฆฌํด
j = 1
flag = True
while flag:
j = j + 1 #j๊ฐ์ 1์ฉ ์ฆ๊ฐ
if i < j: #๋ง์ฝ j๊ฐ i๋ณด๋ค ํฌ๋ค๋ ์กฐ๊ฑด์ if๋ฌธ ์ ์ธ
flag = False #flag ๋ณ์์ False๊ฐ ๋์
print(str)
์์ ์ฝ๋๋ ์๋์ ์๋ฐ ์ฝ๋์ ๊ฐ๋ค.
import java.util.Scanner;
public class While01 {
public static void main(String[] args){
String str = "๊ฟ์ ์ด๋ฃจ์ด ์ง๋ค";
int i = 0;
while (i < 3){
System.out.println(str);
i = i + 1;
System.out.println("---------------------");
Scanner scanner = new Scanner(System.in);
i = Integer.parseInt(scanner.next());
int j = 1;
boolean flag = true;
while flag{
j = j + 1;
if (i < j){
flag = false;
}
System.out.println(str);
}
}
}
}
๊ฒฐ๊ณผ)
๊ฟ์ ์ด๋ฃจ์ด ์ง๋ค
๊ฟ์ ์ด๋ฃจ์ด ์ง๋ค
๊ฟ์ ์ด๋ฃจ์ด ์ง๋ค
-------------------------------
๋ฐ๋ณต ํ์ ์ซ์๋ฅผ ์
๋ ฅํฉ๋๋ค.5
๊ฟ์ ์ด๋ฃจ์ด ์ง๋ค
๊ฟ์ ์ด๋ฃจ์ด ์ง๋ค
๊ฟ์ ์ด๋ฃจ์ด ์ง๋ค
๊ฟ์ ์ด๋ฃจ์ด ์ง๋ค
๊ฟ์ ์ด๋ฃจ์ด ์ง๋ค
3.4 break๋ฌธ
break๋ฌธ์ ๋ฐ๋ณต๋ฌธ์ ์ข
๋ฃ์ํจ๋ค. ๋ฐ๋ณต๋ฌธ์ break๋ฅผ ๊ธฐ์ ํ ๊ฒฝ์ฐ ํด๋น ๋ฐ๋ณต๋ฌธ์ ์ฝ๋๋ ์คํ๋์ง ์๊ณ ๋ฐ๋ณต๋ฌธ์ ๋น ์ ธ ๋์ค๊ฒ ๋๋ค.
range(1, 21, 1): ์ด๊ธฐ๊ฐ 1, 20๊น์ง, ์ฆ๊ฐ๊ฐ: 1
์์ )
#for๋ฌธ๊ณผ break๋ฌธ์ ์ด์ฉํ์ฌ 1์์ 20๊น์ง ํฉ์ด 100๋ณด๋ค ๊ฐ์ฅ ๊ฐ๊น๊ณ ์์ ํฉ์ ๊ตฌํ๋ค.
sum, i = 0, 0 #sum๊ณผ i์ ๋ณ์๋ฅผ ๊ฐ๊ฐ ์ ์ธ
for i in range(1, 21, 1): #์ด๊ธฐ๊ฐ์ด 1์ด๊ณ ์ฆ๊ฐ๊ฐ์ด 1์ด๋ฉด 20๊น์ง ๋ฐ๋ณต
sum+=i #sum = sum + 1
if sum > 100:
break; #break ๋ค์ ;์ ์ฌ์ฉ
sum-=i #ํ์ฌ์ i๊ฐ์ ๋ง์ด๋์ค
print("%d" % sum)
print("----------------------")
#while๋ฌธ๊ณผ break๋ฌธ์ ์ด์ฉํ์ฌ ์
๋ ฅํ 1์์ ์ซ์๋งํผ ํฉ์ ๊ตฌํ์์ค.
sum, i = 0, 0
j = int(input("์ซ์๋ฅผ ์
๋ ฅํฉ๋๋ค. ")) #์ฌ์ฉ์๊ฐ ์
๋ ฅํ ๊ฐ์ ์ ์๋ก ๋ฆฌํด
while True:
if i<j:
i = i+1
sum+=i;
elif i==j:
break;
print("1์์ %d๊น์ง์ ํฉ์ %d์
๋๋ค." % (j, sum))
๊ฒฐ๊ณผ)
91
----------------------
์ซ์๋ฅผ ์
๋ ฅํฉ๋๋ค. 20
1์์ 20๊น์ง์ ํฉ์ 210์
๋๋ค.
๋ฌธ์ ํ์ด๋ณด๊ธฐ)
Q1. ์๋ ์ฝ๋์ ์ถ๋ ฅ ๊ฒฐ๊ณผ๋ฅผ ์์ํ๋ผ
if True:
print("1") #True์ผ ๊ฒฝ์ฐ ์คํ
print("2") #True์ผ ๊ฒฝ์ฐ ์คํ
else:
print("3") #False์ผ ๊ฒฝ์ฐ ์คํ
print("4") #True์ผ ๊ฒฝ์ฐ ์คํ (๋ค์ฌ์ฐ๊ธฐ ๋๋ฌธ์ if๋ฌธ๊ณผ ์๊ด์์ผ๋ฏ๋ก)
# == ๊ฒฐ๊ณผ ==
True์ผ ๊ฒฝ์ฐ 1,2,4 ์ถ๋ ฅ
if True:
if False:
print("1")
print("2")
else:
print("3")
else:
print("4")
print("5")
# == ๊ฒฐ๊ณผ ==
True์ผ ๊ฒฝ์ฐ 3, 5 ์ถ๋ ฅ
Q2. ์ ์ ๊ตฌ๊ฐ์ ํด๋นํ๋ ํ์ ์ด ์๋์ ๊ฐ์ด ์ ์๋์๋ค. ์ฌ์ฉ์๋ก๋ถํฐ score์ ์
๋ ฅ๋ฐ์ ํ์ ์ ์ถ๋ ฅํ๋ผ.
์ ์ ํ์
81~100 A
61~80 B
41~60 C
21~40 D
0~20 E
score: 83
grade is A
์ฝ๋)
score = int(input("ํ์ ์ ์
๋ ฅํฉ๋๋ค."))
if (81 <= score <= 100):
print("grade is A.")
elif (61 <= score <= 80):
print("grade is B.")
elif (41 <= score <= 60):
print("grade is C.")
elif (21 <= score <= 40):
print("grade is D.")
else:
print("grade is E.")
๊ฒฐ๊ณผ)
ํ์ ์ ์
๋ ฅํฉ๋๋ค.83
grade is A.
Q3. for๋ฌธ์ ์คํ๊ฒฐ๊ณผ๋ฅผ ์์ธกํ๋ผ.
fruits = ["์ฌ๊ณผ", "๊ทค", "์๋ฐ"]
for fruit in fruits:
print(fruit)
๊ฒฐ๊ณผ)
์ฌ๊ณผ
๊ทค
์๋ฐ
์ฝ๋2)
fruits = ["์ฌ๊ณผ", "๊ทค", "์๋ฐ"]
for fruit in fruits:
print(fruit, end=" ")
๊ฒฐ๊ณผ)
์ฌ๊ณผ ๊ทค ์๋ฐ
Q4. for๋ฌธ์ ์ฌ์ฉํด์ ๋ฆฌ์คํธ์ ์ ์ฅ๋ ๊ฐ์ ๋ค์๊ณผ ๊ฐ์ด ์ถ๋ ฅํ๋ผ.
menu = ["๊น๋ฐฅ", "๋ผ๋ฉด", "ํ๊น"]
์ค๋์ ๋ฉ๋ด: ๊น๋ฐฅ
์ค๋์ ๋ฉ๋ด: ๋ผ๋ฉด
์ค๋์ ๋ฉ๋ด: ํ๊น
์ฝ๋)
menu = ["๊น๋ฐฅ", "๋ผ๋ฉด", "ํ๊น"]
for i in range(0, 3, 1):
print("์ค๋์ ๋ฉ๋ด: %s" %menu[i])
๊ฒฐ๊ณผ)
์ค๋์ ๋ฉ๋ด: ๊น๋ฐฅ
์ค๋์ ๋ฉ๋ด: ๋ผ๋ฉด
์ค๋์ ๋ฉ๋ด: ํ๊น
๊ฐ์ฌ๋์ ์ฝ๋) ๋ ๊ฐ๋จํ๋ค! :0
menu = ["๊น๋ฐฅ", "๋ผ๋ฉด", "ํ๊น"]
for i in menu:
print("์ค๋์ ๋ฉ๋ด: " + i)
๊ฒฐ๊ณผ)
์ค๋์ ๋ฉ๋ด: ๊น๋ฐฅ
์ค๋์ ๋ฉ๋ด: ๋ผ๋ฉด
์ค๋์ ๋ฉ๋ด: ํ๊น
Q5. ๋ฆฌ์คํธ์๋ ๋ค ๊ฐ์ ์ ์๊ฐ ์ ์ฅ๋ผ ์๋ค.
number = [3, -20, -3, 44]
for๋ฌธ๊ณผ if๋ฌธ์ ์ฌ์ฉํด์ ๋ฆฌ์คํธ์ ์์๋ฅผ ์ถ๋ ฅํ๋ผ.
-20
-3
์ฝ๋)
number = [3, -20, -3, 44]
for i in range(0, 4, 1):
if(number[i] < 0):
print(number[i])
๊ฒฐ๊ณผ)
-20
-3
4 ํ์ด์ฌ ํจ์ ์ฌ์ฉ๋ฒ p. 99
ํจ์๋ ์์ฐจ์ ์ผ๋ก ์งํ๋๋ ํ๋ก๊ทธ๋จ์์ ์ผ์ข
์ ์ค๊ฐ ํ๋ก๊ทธ๋จ ๊ฐ์ ์ญํ ์ ํ๋ค. ๋๋ถ๋ถ์ด ์
๋ ฅ ๊ฐ์ ๋ํ ์ด๋ ํ ์ฒ๋ฆฌ๋ฅผ ์งํํ๊ณ ๊ฒฐ๊ณผ ๊ฐ์ ์ ๊ณตํ๋ค.
ํ์ด์ฌ์ ๋ด์ฅ ํจ์๋ก๋ ์ ๊ณต์ด ๋๊ณ (ex. print)
๋ ์ฌ์ฉ์๊ฐ ํจ์๋ฅผ ์ ์ธํด์ ์ฌ์ฉ ํ ์ ์๋ค.
4.1 ํจ์ ์ ์ธํ๊ธฐ
def ํจ์๋ช
(๋งค๊ฐ๋ณ์1, ...):
์คํํ ์ฝ๋1
์คํํ ์ฝ๋2
โฆ
def mydef()
def: ์ ์ธ ํค์๋
mydef: ํจ์๋ช
(): ๋งค๊ฐ ๋ณ์
์ด๋ ๊ฒ ์ ์ธ๋ ํจ์๋ ๋ค์๊ณผ ๊ฐ์ ๋ฐฉ์์ผ๋ก ํธ์ถํ ์ ์๋ค.
ํจ์๋ช
(์ธ์, ...)
์์ ) ๊ธฐ๋ณธ์ ์ธ ํจ์๋ฅผ ์ ์ธํ๊ณ ๊ฐ๋จํ๊ฒ ํจ์๋ฅผ ํธ์ถํ๋ค.
mydef01(), mydef02()๋ ํจ์๋ฅผ ํธ์ถํ๋ ๊ฒ์ด๋ค.
() ์์ print๊ฐ ์์ผ๋ฉด ํจ์ ์ธ์ถ print๋์ด์ ๋์จ๋ค.
def mydef01(): #์ธ์ ์๋ ํจ์ ์ ์ธ
print("ํจ์๋ฅผ ์ ์ธํฉ๋๋ค.") #๋ค์ฌ์ฐ๊ธฐ๋ฅผ ํตํด ํจ์ ๊ตฌํ ๋ถ๋ถ
mydef01() #ํจ์๋ฅผ ํธ์ถ: ํจ์๋ฅผ ์ ์ธํฉ๋๋ค.
def mydef02(str="์ธ์ํจ์๋ฅผ ์ ์ธํฉ๋๋ค."): #์ธ์ ์๋ ํจ์ ์ ์ธ, str๋ ์ธ์๋ก์จ ๊ธฐ๋ณธ ๊ฐ์ ๊ฐ์ง๊ณ ์๋ ๋ฌธ์์ด ๋ณ์์
๋๋ค.
print(str) #์ธ์๋ก ๋ฐ์ ๋ณ์๋ฅผ ์ถ๋ ฅ
mydef02() #ํจ์๋ฅผ ํธ์ถ: ์ธ์ํจ์๋ฅผ ์ ์ธํฉ๋๋ค.
mydef02("์ธ์๋ฅผ ๋ฃ์ต๋๋ค.") #๋ฌธ์์ด ์ธ์๋ฅผ ๋ฃ์ด์ mydef02 ํจ์๋ฅผ ํธ์ถํ๋ค. ์ธ์๋ str ๋ณ์์ ๋์
๋๋ค.:์ธ์๋ฅผ ๋ฃ์ต๋๋ค.
๊ฒฐ๊ณผ)
str๋ ์ธ์๋ก์จ ๊ธฐ๋ณธ ๊ฐ์ ๊ฐ์ง๊ณ ์๋ ๋ฌธ์์ด ๋ณ์์ด๋ค.
mydef01(): ํจ์๋ฅผ ์ ์ธํฉ๋๋ค.
mydef02(): ์ธ์ํจ์๋ฅผ ์ ์ธํฉ๋๋ค.
mydef02("์ธ์๋ฅผ ๋ฃ์ต๋๋ค."): ์ธ์๋ฅผ ๋ฃ์ต๋๋ค.
ํจ์๋ฅผ ์ ์ธํฉ๋๋ค.
์ธ์ํจ์๋ฅผ ์ ์ธํฉ๋๋ค.
์ธ์๋ฅผ ๋ฃ์ต๋๋ค.
์์ 2) ์ฐธ๊ณ : https://www.w3schools.com/python/python_functions.asp
def my_function():
print("Hello from a function")
my_function()
๊ฒฐ๊ณผ)
Hello from a function
4.2 ํจ์ ์ธ์ ์ฌ์ฉํ๊ธฐ
์์ ) ์ฌ๋ฌ ๊ฐ์ ์ธ์๋ฅผ ์ ๋ ฅ๋ฐ์์ ๊ณ์ฐ์ ํ๋ ํจ์๋ฅผ ์ ์ธํ๋ค.
#mydef01 ํจ์ ์ ์ธ(์ธ์๊ฐ ์๋ ํจ์ ์ ์ธ)
def mydef01():
i = 10
j = 20
print(i+j)
#mydef01 ํจ์ ํธ์ถ
mydef01()
#mydef02 ํจ์ ์ ์ธ(์ธ์๊ฐ ๋ ๊ฐ ์๋ ํจ์ ์ ์ธ)
def mydef02(i, j):
print(i+j)
#mydef02 ํจ์ ํธ์ถ
mydef02(10, 20)
#๊ณ์ฐํ ์ซ์๋ฅผ ๋ ๊ฐ ์
๋ ฅํฉ๋๋ค.
def mydef03(i, j, p): #์ธ ๊ฐ์ ์ธ์๋ฅผ ๋ฐ๋ ํจ์ ์ ์ธ
if p == '+':
print(i + j)
elif p == '-':
print(i - j)
elif p == '*':
print(i*j)
elif p == '/':
print(i/j)
n = int(input("์ฒซ ๋ฒ์งธ ์ซ์๋ฅผ ์
๋ ฅํฉ๋๋ค.")) #์ฌ์ฉ์๊ฐ ์ฒซ ๋ฒ์งธ ์ซ์๋ฅผ ์
๋ ฅ
m = int(input("๋ ๋ฒ์งธ ์ซ์๋ฅผ ์
๋ ฅํฉ๋๋ค.")) #์ฌ์ฉ์๊ฐ ๋ ๋ฒ์งธ ์ซ์๋ฅผ ์
๋ ฅ
p = input("์ฐ์ฐ์๋ฅผ ์
๋ ฅํ์ธ์(+, -, *, /)") #์ฌ์ฉ์๊ฐ ์ฐ์ฐ์๋ฅผ ์
๋ ฅ
mydef03(n, m, p) #์ฒซ ๋ฒ์งธ, ๋ ๋ฒ์งธ, ์ฐ์ฐ์๋ฅผ ์
๋ ฅ ๋ฐ์์ ํจ์ ํธ์ถ
๊ฒฐ๊ณผ)
int()๋ String์ Integer๋ก ๋ฐ๊พผ๋ค.
The int() function converts a number or a string to its equivalent integer.
30
30
์ฒซ ๋ฒ์งธ ์ซ์๋ฅผ ์
๋ ฅํฉ๋๋ค.10
๋ ๋ฒ์งธ ์ซ์๋ฅผ ์
๋ ฅํฉ๋๋ค.20
์ฐ์ฐ์๋ฅผ ์
๋ ฅํ์ธ์(+, -, *, /)*
200
๋ฌธ์ ํ์ด๋ณด๊ธฐ)
Q1. ์๋์ ์๋ฌ๊ฐ ๋ฐ์ํ๋ ์ด์ ์ ๋ํด ์ค๋ช
ํ๋ผ
hello()
def hello():
print("Hi")
"hello" is not defined
์ด์ : ์ ์ธ ์ ์ ๋จผ์ ํธ์ถ๋์๋ค.
์์ ๋ ์ฝ๋)
def hello():
print("Hi")
hello()
๊ฒฐ๊ณผ)
Hi
Q2. ์๋ ์ฝ๋๋ฅผ ์คํํ ๊ฒฐ๊ณผ๋ฅผ ์์ํ๋ผ
์ฝ๋ 1)
def message():
print("A")
print("B")
message()
print("C")
message()
๊ฒฐ๊ณผ)
A
B
C
A
B
์ฝ๋ 2)
range(start, stop, step)
def message1():
print("A")
def message2():
print("B")
def message3():
for i in range(3):
message2()
print("C")
message1()
message3()
๊ฒฐ๊ณผ)
C
A
B
B
B
Q3. ๋ฆฌ์คํธ์๋ ๋ค ๊ฐ์ ์ ์๊ฐ ์ ์ฅ๋ผ ์๋ค.
number = [3, -20, -3, 44]
for๋ฌธ, if๋ฌธ๊ณผ negative()ํจ์๋ฅผ ํธ์ถํด์ ๋ฆฌ์คํธ์ ์์๋ฅผ ์ถ๋ ฅํ๋ผ.
-20
-3
์ฝ๋)
number = [3, -20, -3, 44]
for i in number:
if i < 0:
print(i)
๊ฒฐ๊ณผ)
-20
-3
์ฝ๋ 2) negative() ์ด์ฉ
number = [3, -20, -3, 44]
def negative():
for i in number:
if i<0:
print(i)
negative()
๊ฒฐ๊ณผ)
-20
-3