1.  for 반복문

👩🏻‍🚀  반복문 : 반복작업을 할 때 사용

자바스크립트 반복문 특징

    -  while문 자바와 거의 동일
    -  삼항 for문 존재
    -  for in, for of

 

(1) for 반복문

    

  ✏️  특정 횟수 만큼 반복하고 싶을 때 사용

<!-- 기본 형식 -->    
for(초기값, 조건식, 증감식) // 초기값에는 const 대신 let 사용
for (let i = 0; i < 반복 횟수; i++) {
    문장
}
<script>
    /* for 반복문 기본 */
    for (let i = 0; i < 5; i++) { // 0 부터 5미만 까지 반복
        console.log(`${i}번째 반복입니다.`);
    }

    /* 1부터 N까지 더하기 */
    let output = 0; // 합계에 사용할 변수. 복합 대입 연산자에 사용해야 되서 반드시 초기화.
    for (let i = 1; i <= 100; i++) {
        output += i; // 1부터 100까지 더함.
    }
    //console.log(i); // i is not defined -> 변수i가 효력을 가지는 범위는 for문 안쪽.
    console.log(`1~100까지 숫자를 모두 더하면 ${output}입니다.`);
</script>

 

for 반복문과 배열
  📁  배열을 출력할 경우 배열.length 사용 
<script>
    const todos = ['우유 구매', '업무 메일 확인하기', '필라테스 수업'];

    for (let i = 0; i < todos.length; i++) {
        console.log(`${i}번째 할 일: ${todos[i]}`);
    }

    /* for 반복문으로 배열을 반대로 출력하기 */
    /* 2번째 할 일: 필라테스 수업
       1번째 할 일: 업무 메일 확인하기
       0번째 할 일: 우유 구매  */

    for (let i = todos.length-1; i >= 0; i--) {
        console.log(`${i}번째 할 일: ${todos[i]}`);
    }

    for (const i in todos) { // i는 인덱스 번호를 가져옴
        const ii = todos.length - i - 1;
        console.log(`${ii}번째 할 일: ${todos[ii]}`); // 인덱스번호를 이용해 값에 접근.
    }

 


(2) for 요소 in 반복문

 

✏️  인덱스 기반으로 출력 배열 요소를 하나하나 꺼내서 특정 문장을 실행할 때 사용

<!-- 기본 형식 -->
for(const 반복변수(인덱스) in 배열 또는 객체) { 문장 }
<script>
    const todos = ['우유구매', '업무 메일 확인하기', '필라테스 수업'];
    const times = ['8시', '3시', '12시'];

    // 배열 출력을 위한 전통적인 방법
    for (let i = 0; i < todos.length; i++) {
        console.log(`${i}번 째 할 일: ${todos[i]}`);
        console.log(typeof i); // number
    }

    for (const i in todos) {
        console.log(`${i}번 째 할 일: ${todos[i]}`); // 인덱스 번호를 이용해 값에 접근.
        console.log(i); // 0 1 2
        console.log(typeof i); // string -> 인덱스 값이 문자열
    }

    // 시간과 같이 출력
    for (const i in todos) {
        console.log(`${i}번 째 할 일: ${times[i]} : ${todos[i]}`);
    }
</script>

 


(3) for of 반복문

 

✏️  반복문 내부의 반복변수에 인덱스 대신 요소의 값이 들어감
✏️  자바의 foreach, 파이썬의 for in과 유사

for(const 반복변수 of 배열 또는 객체) {
    문장
}
<script>
    const todos = ['우유구매', '업무 메일 확인하기', '필라테스 수업'];
    for (const todo of todos) { // todo에 요소의 값이 들어감
        console.log(`오늘의 할 일: ${todo}`);
    }
</script>

 


(4) 중첩 for문

 

✏️  for문 안에 다른 for문을 넣어 사용

✏️  안쪽 for문을 모두 실행한 후 바깥쪽 for문을 실행

<script>
    /* for문으로 5번 반복 */
    for (let i = 0; i < 30; i++) {
        document.write('*');
    }
    document.write('<br>');
    for (let i = 0; i < 30; i++) {
        document.write('*');
    }
    document.write('<br>');
    for (let i = 0; i < 30; i++) {
        document.write('*');
    }
    document.write('<br>');
    for (let i = 0; i < 30; i++) {
        document.write('*');
    }
    document.write('<br>');
    for (let i = 0; i < 30; i++) {
        document.write('*');
    }
    document.write('<br>');

    /* 중첩 for문으로 5번 반복 */
    for (let k = 0; k < 5; k++) {
        for (let i = 0; i < 30; i++) {
            document.write('*');
        }
        document.write('<br>');
    }
</script>

구구단 출력
<head>
    <style>
        div {
            display:inline-block;
            padding:0 20px 30px 20px;
            margin:15px;
            border:1px solid #ccc;
            line-height:2;
        }
        div h3 {
            text-align:center;
            font-weight:bold;
        }
    </style>
</head>
<body>
    <h1>구구단</h1>
    <script>
     for(let i = 2; i <= 9; i++) {
         document.write('<div>');
         document.write('<h3>' + i + '단</h3>');
         for (let j = 2; j <= 9; j++) {
             document.write(`${i} X ${j} = ${i * j} <br>`);
         }
         document.write('</div>');
     }
    </script>
</body>


2.  while 문

🐰  if 조건문과 형태가 비슷하지만 문장을 한 번만 실행하고 끝내는 것이 아니라 

      불 표현식이 true이면 계속해서 문장을 실행한다는 점이 다르다.
🐰  while 반복문의 경우 조건이 변하지 않는다면 무한히 반복 실행하므로 조건을 거짓으로 만들 수 있는 문장이 있어야 함
🐰  반복문이 무한 반복 되는 것을 무한 루프 infinite loop

<!-- 기본형식 -->
while (불 표현식) {
    문장
}
<script>
    /* while 반복문 기본 */
    let i = 1;
    // confirm() : 사용자가 [확인] 버튼을 클릭하면 true 반환. [취소]를 클릭하면 false 반환.
    while (confirm('계속 진행하시갰습니까?')) {
        alert(`${i}번째 반복입니다.`);
        i = i + 1;
    }
</script>

 

while 문으로 배열 출력하기
while 반복문과 for 반복문은 서로 대체해서 사용할 수 있음
보통 특정 횟수 반복할 때 for, 조건에 큰 비중이 있을 때는 while.
  예) 특정 시간동안 어떤 데이터를 받을 때 까지
<script>
    const array = [1, 2, 3, 4, 5];

    for(let i = 0; i < array.length; i++){
        console.log(`${i} : ${array[i]}`);
    }

    // 1. 인덱스 번호가 필요 : 0 ~ 4
    // 2. 반복문은 5번 반복
    let i = 0;
    while(i < array.length) {
        console.log(`${i} : ${array[i]}`);
        i++;
    }
</script>

 


3.  break 문

🐰  switch문이나 반복문을 벗어날 때 사용하는 키워드

while(true) {
    if(조건식) {
        break;
    }
}
<script>
    for (let i = 0; true; i++) { // 조건문이 true라서 무한 반복.
        alert(i + '번째 반복문입니다.');

        // 진행 여부를 물어봄
        const isContinue = confirm('계속하시겠습니까?'); // confirm()에서 취소를 누르면 반복을 종료.
        if(!isContinue) { // 취소를 누르면 false가 반환이 되므로 not연산자를 사용해서 true로 변경.
            break;
        }
    }
    alert('프로그램 종료'); // 프로그램의 종료를 확인.
</script>

 


4.  continue 문

🐰  반복문 안의 반복을 멈추고 반복문의 처음으로 돌아가 다음 반복 작업을 진행

<script>
    // alert() 명령문 위에 continue 키워드가 있어서 실행되지 않음.
    for(let i = 0; i < 5; i++) {
        console.log(i);
        // 현재 반복 작업을 중지하고 다음 반복 작업을 수행
        continue;
        alert(i); // 경고창이 출력되지 않음
    }
</script>

 

 

 

 

[ 내용 참고 : IT 학원 강의 및 책 'Do it HTML+CSS+자바스크립트 웹 표준의 정석' ]

 


 

1. while 반복문


🚀  do while문이 없음
🚀  특정 조건을 만족하는 동안 반복해서 수행해야 하는 코드를 작성할 때 사용

while 조건식 :
    반복실행문

 

# while 반복문 사용
n = 1
while n <= 10:
    print(n)
    n += 1   # n = n + 1
print(n)

# 1부터 10 사이의 모든 정수를 역순으로 출력
n = 10
while n >= 1:
    print(n)
    n -= 1  # n = n - 1


# 100부터 50 사이의 짝수를 출력
n = 100
while n >= 50:
    if n % 2 == 0:
        print(n)
    n -= 1

n = 100
while n >= 50:
    print(n)
    n -= 2

 


1) 리스트 사용한 while 반복문

'''
사용자로부터 임의의 정수를 입력받아 모두 리스트에 보관.
단 사용자가 0을 입력하면 프로그램을 종료. 이 때 입력받은 0은 리스트에 보관하지 않음.
'''

my_list = []  # 빈 리스트 생성

# 방법 1)
n = int(input('정수를 입력하세요(종료는 0입니다.) >>> '))  # 한 번만 실행

while n != 0:  # n이 0이 아니면 계속 실행
    my_list.append(n)
    n = int(input('정수를 입력하세요(종료는 0입니다.) >>> '))

print(my_list)
print()

# 방법 2)
n = 1  # 0이 아닌 초깃값을 주면 반복문이 실행됩니다.

while n != 0:
    n = int(input('정수를 입력하세요(종료는 0입니다.) >>> '))
    my_list.append(n)

my_list.pop()  # my_list의 마지막 요소는 언제나 0이므로 제거합니다.
print(my_list)

 


 

2) 시간을 기반으로 반복 

🚀  유닉스 타임 Unix Time : 세계 표준시로 1970년 1월 1일 0시 0분 0초를 기준으로 몇 초가 지났는지를 정수로 나타낸 것 

# 유닉스 타임 구하는 법
import time
time.time()
# 시간 모듈
import time

# 변수 선언
number = 0

# 5초 동안 반복
target = time.time() + 5
while time.time() < target:
    number += 1
    
# 출력
print("5초 동안 {}번 반복했습니다.".format(number))
# 5초 동안 65488529번 반복했습니다.

 


 

2. break/continue 키워드

 

👩🏻‍💻  break문 : while문이나 for문과 같은 반복문을 강제로 종료하고자 할 때 사용하는 제어문
                         반복문 내에 break문이 나타나면 곧바로 break문이 포함된 반복문은 종료

n = 1
while True:
    print(n)
    if n == 10:
        break  # if문에서 break문을 작성 했지만 실제로 종료되는 것은 while문
    n += 1
print(n)  # 10

while True:  # 무한 루프
    city = input('대한민국의 수도는 어디인가요? >>> ')
    city = city.strip()  # 문자열의 양쪽끝에서 공백을 없앰
    if city == '서울' or city == 'seoul' or city == 'SEOUL':  # 대소문자 모두 정답처리
        print('정답입니다.')
        break  # 정답을 맞춰야 종료
    else:
        print('오답입니다. 다시 시도하세요.')


# 종료 조건이 2가지인 경우 : 5개까지 입력이 가능 혹은 그전에 그만두려면 q 입력

hobbies = []  # 빈 리스트 생성
while True:  # 무한루프
    hobby = input('취미를 입력하세요(종료는 그냥 q) >> ')
    if hobby == 'q':
        print('입력된 취미가 모두 저장되었습니다.')
        break
    else:
        hobbies.append(hobby)

    if len(hobbies) >= 5:
        print('5개 입력!')
        break
print(hobbies) # 전체 요소 출력

 


 

👩🏻‍💻  continue 문반복문의 시작 지점으로 제어의 흐름을 옮기는 역할
                                 반복에서 제외하거나 생략하고 싶은 코드가 존재할 때 사용

# 1에서 100사이의 모든 정수를 합하는데 3의 배수는 제외
total = 0
for a in range(1,101):
    if a % 3 == 0:  # 3의 배수인지 검사합니다.
        continue
    total += a
print(total)  # 3367


# 과일 이름 5개를 fruits 리스트에 저장.
# 2개는 미리 저장됨.
# 중복된 과일 이름은 저장이 안됨.

fruits = ['사과', '감귤']
count = 3  # 입력가능한 횟수

while count > 0:
    fruit = input('어떤 과일을 저장할까요? >>> ')

    if fruit in fruits:  # fruits 리스트에 fruit 변수에 있는 값이 있다면
        print('동일한 과일이 있습니다.')
        continue  # while문의 시작 지점으로 돌아가서 다시 과일 이름을 입력

    fruits.append(fruit)  # 입력된 과일 이름을 리스트에 저장
    count -= 1  # 입력 가능 횟수가 줄어듦.
    print(f'입력이 {count}번 남았습니다.')

print(f'5개 과일은 {fruits}입니다.')

 

 

 

 

 

[ 내용 참고 : IT 학원 강의 자료 및 책 '혼자 공부하는 파이썬' ]


 

1. 딕셔너리  dictionary

 

👾  키 key 를 기반으로 값 value을 저장하는 것

       ➡️  '단어'와 '단어의 의미'처럼 사용

👾  딕셔너리는 인덱스가 존재하지 않는 대신 키를 인덱스처럼 사용
       ➡️  키 값을 알면 저장된 값을 확인할 수 있는 구조

 


 

1) 딕셔너리 선언

  ⚡️ 딕셔너리는 중괄호 {} 로 선언하며, 키:값 형태를 쉼표로 연결해서 만든다.

  ⚡️ 키는 문자열, 숫자, 불 등으로 선언 가능

# 딕셔너리 선언 방법
변수 = {
    키:값,
    키:값,
    ...
    키:값
}

# 키값의 자료형이 문자열(str) 이라면 dict() 함수를 이용해서 생성 가능
d = dict(a='apple', b='banana')
print(d)  # {'a': 'apple', 'b': 'banana'}

 

 

💡 딕셔너리 문자열 키와 관련된 오류

    - 키를 문자열로 사용할 때 따옴표를 붙이지 않으면 NameError가 발생한다

dict_key = {
    name : "망고",
    type : "절임"
}
# 이렇게 실행하면 NameError가 발생
# key에 따옴표("")를 붙여줘야 한다

 

2) 딕셔너리 요소 접근

  ⚡️ 리스트처럼 딕셔너리 뒤에 대괄호 []를 입력하고 내부에 인덱스처럼 키를 입력

  ⚡️ 주의할 점은 딕셔너리 선언할 때는 중괄호 {} 사용하지만, 요소에 접근할 때는 대괄호[] 사용

d = {'a': 'apple', 'b': 'banana'}
print(d)  # {'a': 'apple', 'b': 'banana'}
print(type(d))  # <class 'dict'>
print(d['a'])  # apple 
print(d['b'])  # banana

 


 

3) 딕셔너리에 값 추가/제거

 

  ⚡️  딕셔너리에 값을 추가할 때는 키를 기반으로 값을 입력

  ⚡️  setdefault() 메소드를 이용해 추가할 경우 동일한 키가 있는 경우 수정 x

  ⚡️  update() 메소드를 이용해 추가할 경우 동일한 키가 있으면 수정 o

딕셔너리[새로운키] = 새로운 값
dic['watermelon'] = '멜론'
print(dic)  # {'apple': '사과', 'watermelon': '멜론'}

# 존재하는 키값을 이용해서 정의하면, value 수정으로 인식
dic['watermelon'] = '수박'
print(dic)  # {'apple': '사과', 'watermelon': '수박'}

# setdefault() 메소드를 이용한 추가
me = {'name': 'james'}
me.setdefault('age', 20)
print(me)  # {'name': 'james', 'age': 20}
me.setdefault('age', 30) # 동일한 키가 있는 경우에 무시
print(me)  # {'name': 'james', 'age': 20}

# update() 메소드의 경우 존재하는 키값이면 수정
me.update(age=25)
print(me)  # {'name': 'james', 'age': 25}

# update() 메소드의 경우 존재하지 않는 키값이면 추가
me.update(address = 'seoul')
print(me)  # {'name': 'james', 'age': 25, 'address': 'seoul'}

 

 

  ⚡️  del 키워드 or  pop() 메소드를 사용하여 특정 키를 지정하면 해당 요소가 제거

# del 키워드 사용
dic = {'apple' : '사과', 'watermelon' : '수박'}
del dic['apple']  # {'watermelon': '수박'}


# pop() 메소드 사용
dic = {'apple' : '사과', 'watermelon' : '수박'}
dic.pop('watermelon')  # {'apple': '사과'}

 


💡  KeyError 예외

   - 존재하지 않는 키에 접근하면 발생

dic = {}
dic['key']
# -> 존재하지 않는 키이므로 KeyError 발생

 

 


4) 딕셔너리 내부에 키가 있는지 확인

  ⚡️ in 키워드나 get() 함수를 사용해 딕셔너리 내부에 키가 있는지 확인할 수 있다.

# in 키워드 사용
dic = {'a': 'apple', 'b': 'banana', 'c': 'carrot'}
if 'a' in dic:
    print(dic['a'])
else:
    print("존재하지 않는 키에 접근하고 있습니다.)
    
# 실행결과: apple

 

# get() 함수 사용
dic = {'a': 'apple', 'b': 'banana', 'c': 'carrot'}
value = dic.get('b')
print('값 = ', value)  # 값 =  banana

# 존재하지 않는 키 접근
value = dic.get('d')
print('값 = ', value)  
if value == None:
    print('존재하지 않는 키에 접근했습니다.')  
# 실행결과) 
# 값 =  None
# 존재하지 않는 키에 접근했습니다.

 

 

 

 

[ 내용 참고 : IT학원 강의 및 책 '혼자 공부하는 파이썬' ]


 

1. for 반복문

 

🚀   값의 범위나 횟수가 정해져 있을 때 사용하면 편리한 반복문

🚀  for 반복문은 리스트에 있는 요소 하나하나가 변수에 들어가며 차례차례 반복하게 됨

       ➡️  print() 함수로 출력하게 되면 리스트 요소가 차례차례 출력됨
🚀   반복가능객체 ?
        a. 시퀀스 sequence 자료형 : 순서를 가지고 있는 자료형 ( 문자열, 리스트, 튜플, range )
        b. 비시퀀스 non-sequence 자료형 : 순서를 가지고 있지 않은 자료형 ( 세트, 딕셔너리 )

# 기본 구조 
for 변수 in 반복가능객체 :
    반복실행문

 

1) 문자열

for ch in 'Hello':  # 문자열 내부의 문자를 하나씩 꺼내서 사용할 수 있음
    print(ch)
    
'''    
실행결과)
H
e
l
l
o
'''

 


 

2) 리스트

for item in ['가위', '바위', '보']:
    print(item)

# 인덱스 번호 사용 1) 변수생성. 비추천
n = 0
for item in ['가위', '바위', '보']:
    print(f'{n} {item}')
    n += 1

# 인덱스 번호 사용 2) enumerate() 사용. 추천
li = ['가위', '바위', '보']
for i, v in enumerate(li):  # i:index, v:요소의 값 value
    print(f'{i} {v}')

실행 결과

 


 

3) 리스트 내포

# 기본형식
리스트 = [표현식 for 변수 in 반복가능객체]
li = [n * 2 for n in [1, 2, 3]]
print(li)  # [2, 4, 6]

# 조건에 맞는 데이터만 추출 가능
# 리스트 = [표현식 for 변수 in 반복가능객체 if 조건식]
li = [n * 2 for n in [1, 2, 3, 4, 5]]
print(li)  # [2, 4, 6, 8, 10]

li = [n * 2 for n in [1, 2, 3, 4, 5] if n % 2 == 1]  # 1, 3, 5만 추출
print(li)  # [2, 6, 10]

# 리스트 내포를 사용하지 않으면
li = []
for n in [1, 2, 3, 4, 5]:
    if n % 2 == 1:
        li.append(n * 2)
print(li)

 


 

4) 세트 set

👩🏻‍💻  수학의 집합 개념을 구현한 자료형
👩🏻‍💻  저장된 값들은 순서가 없기 때문에 인덱싱과 슬라이싱을 사용할 수 없음
👩🏻‍💻  대신 중복된 값의 저장이 불가능해서 중복 제거용으로 사용

 

    ⚡️  특징
        a. 중복된 값을 저장할 수 없음
        b. 저장되는 순서가 없음

# 중괄호({}) 또는 set() 함수를 이용하여 생성
li = [1, 1, 2, 2, 3, 3]
print(li)  # [1, 1, 2, 2, 3, 3]
print(set(li)) # {1, 2, 3}
li = list(set(li))  #중복된 값을 제거
print(li) # [1, 2, 3]
# 추가를 할 때 add() 메소드 사용
s = {10, 20, 30}
s.add(40) # 세트에 40을 추가
print(s) #{40, 10, 20, 30} / 저장된는 요소들은 순서가 없음

# 삭제를 할 때는 remove()나 discard() 메소드 사용
s.remove(20) # 세트에서 20을 제거. 20이 없으면 오류가 발생
print(s) # {40, 10, 30}

s.discard(30) # 세트에서 30을 제거. 30이 없어도 오류가 발생하지 않음
print(s) # {40, 10}

 

📌  for 반복문과 세트

# 기본형식
for 요소 in {세트}:
    반복실행문
for item in {'가위', '바위', '보'}:  # 순서가 지켜지지 않음
    print(item)

# 실행결과
# 바위
# 보
# 가위

 


 

5)  딕셔너리  

  👾  key와 value의 조합이라 다른 자료형과 다른 방식으로 사용을 함 (키만 출력)

person = {'name': '에밀리', 'age': 20}
for item in person:
    print(item)  # name age

# value 출력
for key, value in person.items():
    print(f'{key}:{value}')

for key in person:
    print(person[key])  # 에밀리 20

for key in person:  # get() 메소드를 이용해서 해당 key에 해당하는 value를 가져옴
    print(person.get(key))  # 에밀리 20

# 영어사전을 딕셔너리 자료형으로 구현하고
# 영어 사전에 등록된 모든 단어와 그 단어의 의미를 출력
eng_dict = {
    'sun': '태양',
    'moon': '달',
    'star': '별',
    'space': '우주'
}
for word in eng_dict:
    print(f'{word}의 뜻: {eng_dict.get(word)}')
    print(f'{word}의 뜻: {eng_dict[word]}')

 


 

2. 중첩 리스트와 중첩 반복문

 

🚀  반복문을 여러 겹 중첩해 사용하면 중첩 반복문

🚀  [1,2,3] 처럼 리스트가 한 겹으로 감싸진 리스트를 1차원 리스트

🚀  [[1,2,3], [4,5,6], [7,8,9]] 처럼 두 겹으로 감싸진 리스트를 2차원 리스트

 

# 2차원 리스트 반복문 한 번 사용
list_of_list = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8]
]

for items in list_of_list:
    print(items)
    
'''
실행결과)
[1, 2, 3]
[4, 5, 6]
[7, 8]
'''
# 2차원 리스트 반복문 두 번 사용
list_of_list = [
    [1, 2, 3]
    [4, 5, 6]
    [7, 8]
]

for items in list_of_list:
    for item in itmes:
        print(item)
'''
실행결과)
1
2
3
4
5
6
7
8
'''

 


 

3. 전개 연산자

 

🚀  전개 연산자를 사용하면 리스트 내용을 전개해서 입력할 수 있다.

🚀  리스트 내부와 함수의 매개변수 위치에 사용

# 리스트 내부에 사용하는 경우
a = [1, 2, 3, 4]
b = [*a]  # [1, 2, 3, 4]
c = [*b, 5]  # [1, 2, 3, 4, 5]
# -> b 내용에 어떠한 영향도 없이 새로운 리스트 c가 만들어짐

# 함수 매개변수 위치에 사용하는 경우
a = [1, 2, 3, 4]
print(*a)  # 1 2 3 4

 

 

 

 

 

[ 내용 참고 : IT 학원 강의 및 책 '혼자 공부하는 파이썬' ]

+ Recent posts