Life is Egg

Date :  2023-07-26

Topic :  SELECT, WHERE, LIMIT, DISTINCT

Note

데이터 기초 상식

• 데이터베이스란? 데이터를 관리하기 위한 시스템으로, 여러 사람들이 같이 사용할 목적으로 '데이터를 담는 통'이라고 생각하면 쉽다.
  원하는대로 데이터를 저장하고 사용하기 위한 통상적인 기능으로 CRUD를 지원한다.
  • C (Create):데이터 생성
  • R (Read):저장된 데이터 읽어오기
  • U (Update):저장된 데이터를 변경(업데이트)
  • D (Delete):저장된 데이터를 삭제
• SQL(Structured Query Language) :
  DB에서 원하는 데이터를 불러오기 위해 요청(Query)을 날리는 언어
• Select, Where절과 자주 쓰는 문법 연습해보기
  👉데이터를 불러오고 (Select), 조건에 맞게 필터링 하는 것 (Where) !
  SQL을 잘 하기 위해서는 원하는 정보가 어느 테이블에 담겨있는지 잘 찾는 것이 매우 중요하다.

기초 Select, Where절 예시

• ex1 ) orders 테이블에서 결제수단이 카카오페이인 데이터만 가져와줘!

select * from orders
where payment_method = "kakaopay";

※ kakaopay가 아닌 "kakaopay"라고 쓰는 이유 👉 필드명이나 테이블명이 아닌 문자열로 인식시키기 위해!
kakaopay라고 쓴다면? 👉 syntax error가 난다.
[Unknown column 'kakaopay' in 'where clause'] 라는 문구가 뜨는데, [where절에는 kakaopay라는 칼럼(필드명)이 없다]라는 의미!

• ex2 ) 조건을 여러 개 걸어줄 땐 AND 사용

select * from orders
where course_title = "앱개발 종합반" and payment_method = "kakaopay";

-> orders 테이블에서 수강 과목이 앱개발 종합반이고 결제 수단이 카카오페이인 데이터

• ex3 ) point_users 테이블에서 포인트가 5000점 이상인 데이터만 가져와줘!

select * from point_users
where point >= 5000;

• ex4 ) orders 테이블에서 주문한 강의가 웹개발 종합반이면서, 결제수단이 카드인 데이터만 가져와줘!

select * from orders
where course_title = "웹개발 종합반" and payment_method = "CARD";

• ex5 ) 포인트가 20000점보다 많은 유저만 추출

select * from point_users
where point > 20000;

• ex6 ) 성이 박씨인 유저만 추출

select * from users
where name = "박**";

Where절과 자주 같이 쓰는 문법

• != : 같지 않음
  ex) 주문 테이블에서 웹개발 종합반을 제외한 데이터 추출

select * from orders
where course_title != '웹개발 종합반';

• between A and B : 범위
  ex) 7월 13일, 7월 14일의 주문데이터만 추출

select * from orders
where created_at between "2020-07-13" and "2020-07-15";

• in : 포함
  ex) 1, 3주차 사람들의 '오늘의 다짐' 데이터만 추출

select * from checkins 
where week in (1, 3);

• like : 패턴(문자열 규칙)
  ex) 다음 (daum) 이메일을 사용하는 유저만 추출

select * from users 
where email like '%daum.net';

• where email like 'a%' : email 필드값이 a로 시작하는 모든 데이터
• where email like '%a' : email 필드값이 a로 끝나는 모든 데이터
• where email like '%co%' : email 필드값에 co를 포함하는 모든 데이터
• where email like 'a%o' : email 필드값이 a로 시작하고 o로 끝나는 모든 데이터

일부 데이터만 가져오기 : Limit

테이블에 방대한 양의 데이터가 담겨져 있다면, 간단한 조회 혹은 소수의 결과물만 뽑으려 하는데도 시간이 오래 걸릴 수 있다.(당연하다. 조회할 데이터가 많으니까.) 그런 경우를 대비해 limit(제한)를 걸어 일부만 가져올 수 있다.

select * from orders 
where payment_method = "kakaopay"
limit 5;

맨 뒤 limit 숫자 작성 시 숫자만큼만 출력된다!

중복 데이터는 제외하고 가져오기 : Distinct

결제 수단의 가짓수를 알기 위해 distinct(구별되는, 별개의)를 이용하여 중복 데이터를 지워준다.

select distinct(payment_method) from orders;

-예상 정답: 4개(kakaopay, CARD, TAXBILL, MONEY)
 dbeaver에서 해볼 것.

몇 개인지 숫자 세보기 : Count

주문 테이블에서 결제 건수를 세고 싶을 때

select count(*) from orders

⭐응용 문제1
성씨 별 개수가 궁금하다면?

select count(distinct(name)) from orders

중복된 성이 제외 되고(하나씩만 남음) count로 세어준다.

⭐응용 문제2
Gmail을 사용하는 2020/07/12~13에 가입한 유저를 추출하기

select * from users
where email like '%gmail.com'
and created_at between '2020-07-12' and '2020-07-14';

새로 배운 내용

• '!=' 에서 !(느낌표)는 부정(not)을 의미
• 범위(between) 사용에서 7월 13, 14일 데이터를 추출한다 했을 때, 지나치듯 between 2020-07-13 and 2020-07-14 라고 생각할 수 있는데 실수하기 쉬운 부분 같다. (13일 0시부터) 14일 24시까지의 데이터를 원하니(=15일 0시 이후부터 제외해야 하므로) between 2020-07-13 and 2020-07-15로 작성해야 한다.
• 같은 패턴이 반복되는 데이터에서(ex:이메일 형식) %를 기준으로 작성해준다.
• 문자열은 ' ' 쓰고 숫자열은 X

참고할 만한 레퍼런스들

like(패턴) 다양한 문법으로 이용되니 그때그때 필요한 것을 찾아서 쓴다!
('how to use like in sql' 이런 식으로 구글링!)

아이디어 메모

[꿀팁🍯] 이렇게 쿼리를 작성하면 편하다

1. show tables로 어떤 테이블이 있는지 살펴보기
2. 제일 원하는 정보가 있을 것 같은 테이블에 select * from 테이블명 쿼리 날려보기
3. 원하는 정보가 없으면 다른 테이블에도 2)를 해보기
4. 테이블을 찾았다! 조건을 걸 필드를 찾기
5. select * from 테이블명 where 조건 이렇게 쿼리 완성!

회고

• 해봤던 공부인데도 오랜만에 본 문법이라 그런지 까먹은 것들이 여럿 있었다. 프리코스 과정에 있던 강의라 실습은 다른 파일로 했는데 괜찮겠지...👉👈
• 문자열일 때(또는 like문법 '%a'에서) 작은 따옴표 붙이는 걸 자꾸 까먹어서 에러가 뜬다. 에러 문장 자체가 익숙하지 않으니 어떤 에러인지, 어디서 잘못 된건지 뜯어 고치면서 보니까 간단한 쿼리인데도 오래 걸릴 때가 있다. 강사님께서 삽질 해봐야 한다고 하셨는데, 확실히 맨땅에 헤딩으로 혼자 고민하고 해결하는 시간을 가지니 기억에도 잘 남고 스스로 더 깨닫는 부분도 생긴다. 문제는 복잡한 쿼리를 보면 얼마나 더 난해할지..^^ 더 빨리 더 꼼꼼히 작성할 수 있도록 많이 연습해야 겠다.
• 아래 쿼리가 왜 에러가 뜨는지 이해가 안됐다.

select * from users
where created_at between "2020-07-12" and "2020-07-14"
and email like "%gmail.com";

왜냐면 2020-07-12(14)라는 필드가 숫자로만 이뤄져 있으니 숫자열, 따라서 따옴표를 안붙여도 된다.라고 너무 굳건히 생각해버려서.. 이런 저런 시도를 계속 하다가 결국 정답을 확인하고 나서야 아차 싶었다. 날짜는 2020년 7월 12일(14일)이니까 사실상 데이터 타입이 timestamp이므로 ' '를 붙여야 한다. 보이는 것에 현혹되지 말고 본질을 꿰뚫어 봐야 답이 보인다...!

Date : 2023-07-13

Topic : 파이썬 시각화 실습(Numpy, Pandas, Matplotlib, Seaborn)

Note

Numpy

: 다차원 배열을 쉽고 효율적으로 계산, 데이터 분석을 할 때 Pandas 와 거의 항상 함께 연계해 사용

1. 데이터란 이미지, 오디오, 텍스트, 숫자 등 다양한 형태와 크기로 존재
2. 모든 데이터는 결국, 숫자의 배열 형태로 해석
3. Numpy 는 Python 에서 모든 데이터 자료형을 분석하고 계산하기 위한 라이브러리

• library install : 라이브러리가 없다면 설치

# !pip install [library name]
!pip install numpy
!pip install pandas
!pip install matplotlip.pyplot
!pip install seaborn

• import library : 설치된 라이브러리를 불러오기

# import [library name] (as alias 생략 가능)
import numpy as np
import pandas as pd
import matplotlib as plt
import seaborn as sns

# 리스트와 비슷해보이지만 type 명령으로 자료형을 보면 ndarray임.
ar=np.array([0,1,2,3,4,5,6,7,8,9])
print(ar)	# [0 1 2 3 4 5 6 7 8 9]
print(type(ar))	# <class 'numpy.ndarray'>​

• list와 ndarray 차이점
  • ndarray : N-Dimensional Array의 약자. 말 그대로 N차원의 다차원 배열 자료 구조

# List
data=[0,1,2,3,4,5,6,7,8,9]
data=list(range(10))
data		# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 2의 배수를 리스트로 만드려면 반복문을 사용해야 한다.
answer=[]

for di in data:
    answer.append(2*di)
answer		# [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

# 그냥 data에 2배를 하면
print(data*2)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 물리적으로 2배가 나온다.

# ndarray
x=np.array(data)
x		# array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

# ndarray는 벡터화 연산으로 list와 차이점이 있다.
x*2		# array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18])

a=np.array([1,2,3])
b=np.array([10,20,30])

# 벡터 연산
a*2+b		# array([12, 24, 36])

• 논리 연산

(a==2)&(b>10)   # and 논리연산
# array([False,  True, False])

(a==2)|(b>10)   # or 논리연산
# array([False,  True,  True])

Array(배열)

: 같은 타입을 가지는 데이터가 나열된 집합

1. 축(axis)의 수에 따라 N차원으로 나타낼 수 있다.
2. 다중 리스트 구조와 다른 점은, 배열은 같은 데이터 타입 으로 이루어져 있다

• N차원 array

# 1D array
array1 = np.array([1,2,3])
np.shape(array1)

• 2차원 배열 = matrix (행렬), 리스트의 리스트(list of list)를 이용하면 생성할 수 있다.
  • 가로줄: 행(row)
  • 세로줄: 열(column)

# 2D array
array2 = np.array([[1,2,3],
                   [4,5,6]])
np.shape(array2)

• 2차원 배열의 행과 열의 개수 구하기

c=np.array([[0,1,2],[3,4,5]])
print(c)

# [[0 1 2]
# [3 4 5]]

# 행의 개수
len(c)  	# 2

# 열의 개수
print(c[0])	# [0 1 2]
len(c[0])	# 3

# 3D array
array3 = np.array([[[1,2,3],
                    [4,5,6]],
                    [[7,8,9],
                    [10,11,12]]])
np.shape(array3)

d=np.array([[[1,2,3,4],
             [5,6,7,8],
             [9,10,11,12]],
            [13,14,15,16],
            [17,18,19,20],
            [21,22,23,24]])
            
# <ipython-input-72-86e10f7e6312>:1: VisibleDeprecationWarning:
# Creating an ndarray from ragged nested sequences
# (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated.
# If you meant to do this, you must specify 'dtype=object' when creating the ndarray.

• Numpy 배열 생성하는 방법
  • 리스트 자료형에서 numpy 로 변환
  • numpy 자체 생성 함수 활용
  • 파일(이미지 등) 기반 배열 생성
• 리스트 자료형에서 numpy 변환

mylist = [1,2,3]
np.array(mylist)	# array([1, 2, 3])

mylist = [[1,2,3], [4,5,6]]
np.array(mylist)

'''op:
array([[1, 2, 3],
       [4, 5, 6]])
'''

• 데이터 타입(type) 지정

# 정수
np.array([1,2,3], dtype=int)	# array([1, 2, 3])

# 실수
np.array([1,2,3], dtype=float)	# array([1., 2., 3.])

# 유니코드 문자열
np.array(['1','2','3'])		# array(['1', '2', '3'], dtype='<U1')

# 문자열에서 정수형으로
np.array(['1','2','3'], dtype=int)	# array([1, 2, 3])

• 자체 생성 함수등간격 배열 생성

# np.arrange
np.arange(10)		# array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

np.arange(2,10)		# array([2, 3, 4, 5, 6, 7, 8, 9])

np.arange(2, 10, 2)	# array([2, 4, 6, 8])

# np.linspace -> 그래프 그릴 때 유용
np.linspace(1, 10, 5)	# array([ 1.  ,  3.25,  5.5 ,  7.75, 10.  ])

np.linspace(1, 10, 4)	# array([ 1.,  4.,  7., 10.])

• 축(axis) 을 따라 자르듯이 배열을 조작하는 방법 (원하는 부분만 추출하거나, 형태 변환)
• 슬라이싱 기준

arr [ 행(row) 인덱스, 열(column) 인덱스, ... N축 인덱스]

arr = np.array([[1, 2, 3, 4], 
                [5, 6, 7, 8], 
                [9, 10, 11, 12], 
                [13, 14, 15, 16]])

위 배열을 슬라이싱↓

# 행 기준으로 슬라이싱
arr[0]		# array([1, 2, 3, 4])

arr[0,:]	# array([1, 2, 3, 4])

# 열 기준으로 슬라이싱
arr[:,0]	# array([ 1,  5,  9, 13])

# 간격을 지정해서 슬라이싱
arr[::2]

'''
array([[ 1,  2,  3,  4],
       [ 9, 10, 11, 12]])
'''

# 2, 3행 슬라이싱
arr[1:3]

'''
array([[ 2,  3],
       [ 6,  7],
       [10, 11],
       [14, 15]])
'''

# 4 열 슬라이싱
arr[:, -1]		# array([ 4,  8, 12, 16])

# 1,2행, 2,3열 슬라이싱
arr[0:2, 1:3]

'''
array([[2, 3],
       [6, 7]])
'''

r=range(1,21)
x=np.array(r)
x

# 3의 배수
x[x%3==0]		# array([ 3,  6,  9, 12, 15, 18])

# 4로 나누면 나머지 1
x[x%4==1]		# array([ 1,  5,  9, 13, 17])

# 3으로 나누어지고, 4로 나누면 1이 남는 수 (합집합)
x[(x%3==0)&(x%4==1)]	# array([9])

Pandas

: 시리즈(Series) 클래스와 데이터 프레임(Data Frame) 클래스를 제공한다.

• Series = Value + Index
• Series의 인덱스는 index 속성으로 접근할 수 있다.
• (추가 예정)

import pandas as pd

s=pd.Series([9904312, 3448737, 2890451, 2466052],
            index=["서울", "부산", "인천", "대구"])
s

'''op:
서울    9904312
부산    3448737
인천    2890451
대구    2466052
dtype: int64
'''

s.name='인구'
s.index.name='도시'
s

'''op:
도시
서울    9904312
부산    3448737
인천    2890451
대구    2466052
Name: 인구, dtype: int64
'''

# 넘파이처럼 벡터화 연산 가능(시리즈 값만 적용되고 인덱스값은 변경X)
s/1000000

'''op:
도시
서울    9.904312
부산    3.448737
인천    2.890451
대구    2.466052
Name: 인구, dtype: float64
'''

• 시리즈 인덱싱

s
'''
도시
서울    9904312
부산    3448737
인천    2890451
대구    2466052
Name: 인구, dtype: int64
'''

s[1]		# 3448737

s['부산']	# 3448737

s[3], s['대구']	# (2466052, 2466052)

• 딕셔너리 원소는 순서를 가지지 않으므로 시리즈의 데이터도 순서가 보장되지 않는다. 만약 순서를 정하고 싶다면 인덳를 리스트로 지정해야 한다.

s2=pd.Series({'서울':9631492, '부산':3393191, '인천':2632035, '대전':1490158},
             index=['부산', '서울', '인천', '대전'])	# 인덱스로 순서 지정
s2

'''op: 
부산    3393191
서울    9631492
인천    2632035
대전    1490158
dtype: int64
'''

# index 기반 연산
ds=s-s2 	# key값이 같은 것끼리 연산
ds

'''op:
대구         NaN	# 대구와 대전의 경우 각각 2010년 자료, 2015년 자료가 모두 존재X
대전         NaN	# Not a Number라는 값을 가지게 된다.
부산     55546.0
서울    272820.0
인천    258416.0
dtype: float64
'''

ds.notnull()	# Null이 아닌 위치에 True

'''op:
대구    False
대전    False 
부산     True
서울     True
인천     True
dtype: bool
'''

데이터 갱신, 추가, 삭제

: 인덱싱을 이용하여 딕셔너리처럼 데이터를 update or add

데이터프레임 클래스

• 데이터프레임에서 열 라벨로 시리즈를 인덱싱하면 시리즈가 된다. 이 시리즈를 다시 행 라벨로 인덱싱하면 개별 데이터가 나온다.

data = {
    "2015": [9904312, 3448737, 2890451, 2466052],
    "2010": [9631482, 3393191, 2632035, 2431774],
    "2005": [9762546, 3512547, 2517680, 2456016],
    "2000": [9853972, 3655437, 2466338, 2473990],
    "지역": ["수도권", "경상권", "수도권", "경상권"],
    "2010-2015 증가율": [0.0283, 0.0163, 0.0982, 0.0141]
}   # 딕셔너리
columns = ["지역", "2015", "2010", "2005", "2000", "2010-2015 증가율"] # LIST
index = ["서울", "부산", "인천", "대구"] # LIST

# data:딕셔너리, index/columns: 리스트
df=pd.DataFrame(data, index=index, columns=columns)
print(df)
df

Date : 2023-07-11

Topic : Lambda 표현식, closure, 파일 입출력

Note

람다 표현식(Lambda Expression)

: lambda에 매개변수를 지정 후 :(콜론) 뒤에 반환값(return value)으로 사용할 식을 지정

lambda 매개변수들: 식

• 람다 표현식으로 만들면 함수 객체가 나오는데, 이 상태로는 함수 호출X
• 람다 표현식은 이름이 없는 함수를 만들기 때문임. (익명 함수라고도 함. Anonymous function)

# 함수 정의
def plus_ten(x):
    return x+10

plus_ten(1)

• lambda로 만든 익명 함수를 호출하려면 다음과 같이 람다 표현식을 변수에 할당

# 위 함수를 람다 표현식으로
plus_ten=lambda x: x+10
plus_ten(1)

• 람다 표현식은 변수에 할당하지 않고 람다 표현식 자체를 바로 호출할 수 있음.
  • 람다 표현식을 ()(괄호)로 묶은 뒤, 다시 ()를 붙이고 인수를 넣어서 호출

(lambda 매개변수들: 식)(인수들)

(lambda x: x + 10)(1)	# 11

• 람다 표현식 안에서는 변수를 만들 수 없다.
  • 변수 없이 식 한 줄로 표현할 수 있어야 함.
  • 변수가 필요한 코드일 경우 def로 함수를 작성하는 것이 좋음.

(lambda x:y=10; x+y)(1)
>>> syntaxerror: invalid syntax

• 람다 표현식 바깥에 있는 변수는 사용할 수 있음.
  • 매개변수 x와 람다 표현식 바깥에 있는 y를 더해서 반환.

y=10
(lambda x: x+y)(1)	# 11

• 람다 표현식을 인수로 사용하기

# 1.이렇게 정의된 함수 plus_ten을
def plus_ten(x):
    return x+10

list(map(plus_ten, [1,2,3]))	# [11,12,13]

# 2.plus_ten 대신 람다 표현식을 직접 대입
list(map(lambda x:x+10, [1,2,3]))	# [11,12,13]

• 람다 표현식에 조건부 표현식 사용하기
  • if, else 사용 시 :(콜론) 사용X
  • elif 사용X - 조건식을 연속으로 사용해줘야 함

lambda 매개변수들: 식1 if 조건식 else 식2

True면 if 조건식 실행, 아닐 경우 else 식2 실행

lambda 매개변수들: 식1 if 조건식1 else 식2 if 조건식2 else 식3

                   elif 대신 조건식을 연속으로 ( ↑ elif와 같은 기능 )

• 그러나 어렵지 않은 코드를 lambda로 표현하여 복잡하고 가독성이 떨어진다면 def 함수 권장

map, filter, reduce

• map에 여러 객체 넣기 : 람다 표현식에 매개변수에 개수에 맞게 반복 가능한 객체도 콤마로 구분해서 넣어주면 됨.

a=[1,2,3,4,5,6,7,8,9,10]
list(map(lambda x: str(x) if x % 3 == 0 else x, a))	# 3의 배수를 문자열로 출력, 아니면 그대로x
# [1,2,'3',4,5,'6',7,8,'9',10]

a=[1,2,3,4,5]			# 2.반복 가능한 객체도 콤마로 구분해서 넣어줌
b=[2,4,6,8,10]
list(map(lambda x,y: x*y,a,b))	# 1.표현식의 매개변수 개수(x,y 2개)에 맞게
# [2, 8, 18, 32, 50]

• filter 사용하기 : 반복 가능 객체에서 특정 조건에 맞는 요소만 가져오는데, filter에 지정한 함수의 반환값이 True일 때만 해당 요소를 가져옴

filter(함수, 반복 가능한 객체)

# 1.함수 f를
def f(x):
    return x>5 and x<10	# 5보다 크고 10보다 작은 x

a=[8,3,2,10,15,7,1,9,0,11]
list(filter(f,a))	# [8,7,9]	# 참인 요소만 출력

# 2.람다 표현식으로 만들어서 filter에 넣기
list(filter(lambda x: x>5 and x<10, a))	# [8,7,9]

• reduce : 반복 가능한 객체의 각 요소를 지정된 함수로 처리한 뒤 이전 결과와 누적해서 반환하는 함수

reduce(함수, 반복 가능한 객체)

def f(x, y):
	return x + y

a = [1, 2, 3, 4, 5]
from functools import reduce
reduce(f, a)	# 15

# 저장된 요소를 순서대로 더한 뒤 누적된 결과를 반환
a=[1,2,3,4,5]
from functools import reduce	# 내장함수X, functools에서 reduce를 불러와야 함
reduce(lambda x,y: x+y, a)	# 지정된 함수 x+y를 a의 요소로 누적

※ 그러나 reduce는 코드가 조금만 복잡해져도 가독성이 안좋아지기 때문에, 반복문으로 처리할 수 있는 경우라면 for, while문으로 처리하는 것이 좋다. ↓

#의미하는 바를 한 눈에 알아볼 수 있다.
a = [1, 2, 3, 4, 5]
x = a[0]
for i in range(len(a) - 1):	# len(a)=5이므로 range(4)
     x = x + a[i + 1]		# a[0] + (a[1]+a[2]+a[3]+a[4])

x	# 15

클로저 (closure) 사용하기

• 변수 사용 범위
  • 전역 변수(global variable): 함수 포함하여 스크립트 전체에서 접근할 수 있는 변수
  • 전역 범위(global scope): 전역 변수에 접근할 수 있는 범위

x=10    	# 전역 변수
def foo():
    print(x)    # 전역 변수 출력	## 10

foo()
print(x)    	# 전역 변수 출력	## 10

• 지역 변수(local variable): 변수를 만든 함수 안에서만 접근 가능(함수 바깥에서 접근X)
• 지역 범위(local scope): 지역 변수를 접근할 수 있는 범위

def foo():
	x=10	# foo의 지역 변수
    print(x)    # foo의 지역 변수 출력

foo()
print(x)    	# 에러. foo의 지역 변수 출력 불가

x=10    	# 전역 변수
def foo():
    x=20    	# x는 foo의 지역 변수
    print(x)    # foo의 지역 변수 출력

foo()
print(x)    	# 전역 변수 출력

'''op
20
10
'''

# 이때 지역 변수x와 전역 변수x는 서로 다른 x

• global 키워드 : 함수 안에서 전역 변수의 값을 변경하려면 global 전역변수 사용.
  • 함수 안에서 변수를 global로 지정하면 전역 변수를 사용
  • 전역 변수가 없을 때, 함수 안에서 global을 사용하면 해당 변수는 전역 변수

x=10    	# 전역 변수
def foo():
    global x    # 전역 변수x를 사용하겠다고 설정
    x=20    	# x는 전역 변수
    print(x)    # 전역 변수 출력

foo()
print(x)    	# 전역 변수 출력

'''op
20
20
'''

# 전역변수x가 없는 상태
def foo():
    global x    # x를 전역 변수로 만듦
    x=20    	# x는 전역 변수
    print(x)    # 전역 변수 출력

foo()
print(x)    	# 전역 변수 출력

• 함수 안에서 함수 만들기

def 함수이름1():
	코드
    def 함수이름2():
    	코드

# 동작 순서chk
# print_hello > print_message 순으로 실행
def print_hello():		#2
    hello='Hello, world!'	#3
    def print_message():	#5
        print(hello)		#6
    print_message()		#4

print_hello()			#1(함수 호출), 7

• 지역 변수 변경하기

# 안쪽 함수B에서 바깥쪽 함수A의 지역 변수x를 변경해보기
def A():
    x=10    	# A의 지역 변수x
    def B():
        x=20    # x에 20 할당(B의 지역 변수x)

    B()
    print(x)    # A의 지역 변수x 출력

A()		# 10

• 현재 함수 바깥쪽에 있는 지역 변수의 값을 변경하려면 nonlocal 키워드 사용
  • nonlocal 지역변수
  • nonlocal: 현재 함수의 지역 변수가 아니라는 뜻(바깥쪽 함수의 지역 함수 사용)
    - 현재 함수의 바깥쪽에 있는 지역 변수를 찾을 때 가장 가까운 함수부터 먼저 찾는다.

def A():
    x=10            # A의 지역 변수x
    def B():
        nonlocal x  # 현재 함수 바깥쪽에 있는 지역 변수 사용
        x=20        # A의 지역 변수 x에 20 할당

    B()
    print(x)        # A의 지역 변수x 출력

A()			# 20

# 실행 순서 이해하고 주석 달기
def A():
    x=10
    y=100
    def B():
        x=20
        def C():
            nonlocal x	# 가장 가까운 함수의 변수 x 사용 (x=20)
            nonlocal y	# 가장 가까운 함수의 변수 y 사용 (y=100)
            x=x+30
            y=y+300
            print(x)
            print(y)
        C()
    B()

A()

# 50	## print(x)
# 400	## print(y)

• global로 전역 변수 사용하기 : 함수가 몇 단계든 상관 없이 global 키워드를 사용하면 무조건 전역 변수를 사용하게 됨

- 파이썬에서 global을 제공하지만 함수에서 값을 주고받을 때는 매개변수와 반환값을 사용하는 것이 좋다. 특히 전역 변수는 코드가 복잡해졌을 때 변수의 값을 어디서 바꾸는지 알기가 힘드므로 전역 변수는 가급적이면 사용하지 않는 것을 권장

x = 1
def A():
    x = 10
    def B():
        x = 20
        def C():
            global x    # 전역 변수 x = 1을 사용
            x = x + 30
            print(x)
        C()
    B()
 
A()	# 31

• 클로저(closure) 사용하기 : 함수를 둘러싼 환경(지역 변수, 코드 등)을 계속 유지하다가, 함수를 호출할 때 다시 꺼내서 사용하는 함수
  
  • 프로그램의 흐름을 변수에 저장할 수 있음
    • 지역 변수와 코드를 묶어서 사용하고 싶을 때 활용
    • 클로저에 속한 지역 변수는 바깥에서 직접 접근할 수 없으므로 데이터를 숨기고 싶을 때 활용
  • 함수를 반환할 때는 함수 이름만 반환해야 하며 ()(괄호)를 붙이면 안됨 (↓return mul_add)

# 함수 바깥쪽 지역 변수 a,b를 사용하여 a*x+b를 계산하는 함수 mul_add를 만든 뒤
# 함수 mul_add 자체를 반환함
def calc():
    a=3
    b=5
    def mul_add(x):
        return a*x+b    # 함수 바깥쪽 지역 변수 a,b를 사용하여 계산
    return mul_add	# mul_add 함수를 반환

c=calc()		# calc() 함수 호출 후 반환값을 c에 저장
print(c(1),c(2),c(3),c(4),c(5))	# 8 11 14 17 20

• lambda로 클로저 만들기 ( 함께 사용하는 경우 多 )

def calc():
    a=3
    b=5
    return lambda x: a*x+b  # mul_add 함수를 람다 표현식으로 변경 후 그 자체를 반환
 
c=calc()
print(c(1),c(2),c(3),c(4),c(5))

파일의 입출력 과정

표준입력장치(키보드 등) input() → print() 표준출력장치(모니터)

이 둘을 합쳐서 콘솔(Console)

• read() / readline() / readlines()는 파일 내용을 읽음
• write() / writelines()는 파일 내용을 쓰기

파일 입출력 기본 과정

1. file open
   • open() 함수에서 파일명을 지정하고 읽기인지, 쓰기인지 지정
   • open() 함수의 마지막 매개변수를 모드(Mode)라고 함
     • 읽기용: 변수명=open("파일명", "r")
     • 쓰기용: 변수명=open("파일명", "w")
2. file read & write
3. file close

# 파일 경로 찾아서 열기
#inFp=open("C:\Users\bb2_b\data1.txt", "r", encoding="utf-8")
inFp=open("data1.txt", "r", encoding="utf-8")
inStr=inFp.readline()
print(inStr, end="")
inStr=inFp.readline()
print(inStr, end="")
inStr=inFp.readline()
print(inStr, end="")
inStr=inFp.readline()
print(inStr, end="")
inFp.close()

'''op: 저장된 txt파일 내용이 입력됨
박우정
파이썬
python
'''

inFp=None
inStr=""
inFp=open("data1.txt", "r", encoding="utf-8")
while True:			# 무한 루프를 통해 텍스트가 몇 줄인지 몰라도 사용 가능
    inStr=inFp.readline()	# 한 줄 읽고 다시 루프
    if inStr=="":		# 더 이상 읽을 내용이 없으면(EOF) break
        break
    print(inStr, end="")

inFp.close()

inFp=None
inList=[]

inFp=open("data1.txt", "r", encoding="utf-8")
inList=inFp.readlines()
print(inList)
inFp.close()
# ['박우정\n', '파이썬\n', 'python']

< 실습 >

• 파일명으로 파일 읽기

inFp=None
inList=[]
inStr=""
strName=input("file name: ")	# 확장자까지 입력! data1.txt
inFp=open(strName, "r", encoding="utf-8")
inList=inFp.readlines()
for inStr in inList:
    print(inStr, end="")
    
inFp.close()

'''op:
file name: data1.txt
박우정
파이썬
python
'''

• 파일에 출력해보기

outFp=None
outStr=""

outFp=open("data1.txt", "w", encoding="utf-8")

while True:
    outStr=input("내용 입력: ")
    if outStr != "":			# 공백이 아닌 내용이 입력되면 써짐
        outFp.write(outStr+'\n')
    else:				# 공백+'\n' 시 종료
        break
        
outFp.close()
print("--- 정상적으로 파일에 써졌음 ---")	# data1.txt 파일을 열어보면 입력한 내용이 출력됨

Tkinter 라이브러리

: GUI 프로그램을 만들기 위해 -

• 메인 창(Tk 객체) 생성
• 위젯 생성하고 창에 배치
• 메인 루프 실행

• Tkinter 라이브러리 맛보기 - 코랩 안되고 내 GUI를 사용하는 프로그램 사용해야함!! (ex:주피터 노트북)

import tkinter as tk
root=tk.Tk()

lbl=tk.Label(root, text="Educoding", underline=3)
lbl.pack()

txt=tk.Entry(root)
txt.pack()

btn=tk.Button(root, text="OK", activebackground="red", width=5)
btn.pack()

root.mainloop()

• 버튼 만들기

# coding: uft-8

# Tkinter 라이브러리 임포트
import tkinter as tk
# tk 객체 인스턴스 생성
root=tk.Tk()

def func():
    print('Pushed')

txt=tk.Entry(root)
txt.pack()

# 버튼 생성
btn=tk.Button(root, text="Push!", command=func)
# 버튼 배치
btn.pack()

print("실행 준비")	# 코드를 실행하면 출력창에 "실행 준비"가 프린트 되고
# 루트 표시
root.mainloop()		# 'Push!' 버튼을 누르면 'Pushed'가 출력된다.
print("실행 종료")	# 창을 닫으면 실행 종료가 뜬다.

'''op:
실행 준비	# 코드 실행
Pushed		# 버튼을 다섯 번 눌렀다.
Pushed
Pushed
Pushed
Pushed
실행 완료	# 창 닫음
'''

• if 조건문으로 버튼을 스위치처럼 사용하기 ( 클릭할 때마다 표시된 메시지가 반복해서 달라진다.)

# coding: uft-8

# Tkinter 라이브러리 임포트
import tkinter as tk
# tk 객체 인스턴스 생성
root=tk.Tk()

bAct=False
print(type(bAct))	# boolean인지 타입 체크

# 버튼 눌렀을 때 처리
def func():
    global bAct
    # Label 표시 변경
    if bAct:		# 조건문 설정으로 switch 역할
        label.config(text='Apple')
    else:
        label.config(text='Orange')
    bAct=not(bAct)

# 레이블 생성
label=tk.Label(root, text="Apple")

# 레이블 배치
label.pack()

# 버튼 생성
btn=tk.Button(root, text="Push!", command=func)	# command
# 버튼 배치
btn.pack()

print("실행 준비")
# 루트 표시
root.mainloop()
print("실행 완료")

• 버튼을 누른 다음 특정 동작을 하면 표시가 돌아오도록 프로그램을 변경

# coding: uft-8

# Tkinter 라이브러리 임포트
import tkinter as tk
# tk 객체 인스턴스 생성
root=tk.Tk()

# 버튼을 눌렀을 때 처리
def func():
    # Label 표시 변경
    label.config(text="Pushed")

# 마우스 커서가 버튼을 벗어났을 때 이벤트 추가
def func_event(ev):
    # Label 표시 변경
    label.config(text="Pushed")

# 레이블 생성
label=tk.Label(root, text="Push Button")

# 레이블 배치
label.pack()

# 버튼 생성
btn=tk.Button(root, text="Push!", command=func) #command

# 버튼 배치
btn.pack()

# 마우스 커서가 버튼을 벗어났을 때 이벤트 추가
btn.bind('<Leave>', func_event)

print("실행 준비")
# 루트 표시
root.mainloop()
print("실행 완료")

• 버튼 만들기 - event object

import tkinter as tk
root=tk.Tk()
def func():
    label.config(text='Pushed')
    
def func_event_click(ev):
    disp=str(ev.x)+'/'+str(ev.y)
    label.config(text=disp)
    
label=tk.Label(root, text="Push Button")
label.pack()
button=tk.Button(root, text='Push', command=func)
button.pack()

button.bind('<Button-1>', func_event_click)

root.mainloop()

• 라디오 버튼 만들기

# radio button
import tkinter as tk
def Action1():
    lbl.config(text='Option 1')
def Action2():
    lbl.config(text='Option 2')

root=tk.Tk()
    
lbl=tk.Label(root, text="EduCoding", underline=3)
lbl.pack()

rbvar=""
rb1=tk.Radiobutton(root, text='Option 1', variable=rbvar, value='a', indicatoron=0, command=Action1)
rb1.pack()
rb2=tk.Radiobutton(root, text='Option 2', variable=rbvar, value='b', indicatoron=0, command=Action2)
rb2.pack()
# indicatoron이 0이면 버튼 형태, 1이면 단추 형태 (형식은 라디오버튼이다)

root.mainloop()

Date : 2023-07-10

Topic : 리스트 튜플 응용, 서식 formatting, 함수 / + small project (자판기 프로그램) 개발 계획서 작성

Note

리스트 끝에 요소 하나 추가 : append

a=[10,20,30]
a.append(500)
a	# [10,20,30,500]
len(a)	# 4

# append를 사용해서 빈 리스트에 0~9 요소 추가
a=[]

for i in range(10):
    a.append(i)

print(a)	# [0,1,2,3,4,5,6,7,8,9]

#1~100 사이 짝수를 요소로 가지는 리스트 만들기
a=[]

for i in range(50):
    a.append((i+1)*2)

print(a)

a=[]

for i in range(10):
    a.append((i+1)*10)

print(a)

리스트 끝에 다른 리스트 연결하여 확장 : extend

a=[10,20,30]
a.extend([500,600])
a	# [10, 20, 30, 500, 600] '연장'되었다.
len(a)	# 5

리스트 특정 인덱스에 요소 추가 : insert(인덱스, 요소)

a=[10,20,30]
a.insert(2,500)
a	# [10, 20, 500, 30]
len(a)	# 4

리스트 요소 삭제 : pop, remove

• pop: 마지막 요소 또는 특정 인덱스의 요소를 삭제
• remove: 특정 값을 찾아서 삭제

a=[10,20,30]
print(a.pop())	# 30 (반환된 값)
a	# [10, 20] (요소가 삭제된 뒤 리스트)

# pop() 괄호 아무 것도 없으면 마지막 값 삭제
# 괄호 사이 인덱스 입력->해당 인덱스 요소 삭제한 뒤 삭제한 요소 반환

# pop 대신 del 가능
a = [10, 20, 30]
del a[0]
a	# [20, 30]

# pop과 for문을 사용해서 빈 리스트로 만들기
a=[0,1,2,3,4,5]

for i in range(len(a)):	# range(상수) 보다 len() 사용이 더 good
    a.pop()

print(a)	# []

# remove(값)은 리스트에서 특정 값을 찾아서 삭제
a=[10,20,30]
a.remove(10)
a   # [20, 30]

# 리스트에 같은 값이 여러 개 있을 경우 처음 찾은 값을 삭제

a = [10, 20, 30, 20]
a.remove(20)
a	# [10, 30, 20]
	#리스트 a에 20이 2개 있지만 가장 처음 찾은 인덱스 1의 20만 삭제

스택(stack) : LIFO(Last In First Out) 구조

or FILO (First In Last Out, 굴러 들어온 돌이 박힌 돌 뺀다)

큐(queue) : LILO(Last In Last Out) 구조

or FIFO (First In First Out, 선입선출)

리스트 할당과 변수

# 먼저 리스트를 만든 뒤 다른 변수에 할당
a=[0,0,0,0,0]
b=a	# 이때 리스트가 두 개가 된 것이 아님. a is b >>> True 확인해보기

a is b	# True

a=[i for i in range(10)]
print(a)
b=list(i for i in range(10))
print(b)
a==b	# True / 단순하게 값을 비교, 값의 내용이 같다면 True, 그렇지 않다면 False
a is b	# False / is연산자는 같은 '객체'인지 비교. a와 b는 메모리의 다른 영역에 위치한 서로 다른 객체

# a와 b는 같으므로 b[2]=99와 같이 리스트 b의 요소를 할당해주면
# a와 b 모두 반영됨
a=[0,0,0,0,0]
b=a
print(a is b)
b[2]=99
print(a)
print(b)

'''op
True
[0, 0, 99, 0, 0]
[0, 0, 99, 0, 0]
'''

a=[0,0,0,0,0]
b=a.copy()
b	# [0, 0, 0, 0, 0]

리스트 표현식 사용하기

• [식 for 변수 in 리스트]
• list(식 for 변수 in 리스트)

a=[i for i in range(10)]
print(a)	# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
b=list(i for i in range(10))
print(b)	# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# range(10)으로 0~9까지 생성하여 변수 i에 숫자를 꺼내고,
# 최종적으로 i를 이용하여 리스트를 만든다는 뜻

# 0~9 중 2의 배수
a=[i for i in range(10) if i%2==0]	# if -> 필터
print(a)				# [0, 2, 4, 6, 8]

# 0~9 중 홀수에 5를 더해서 리스트 만들기
a=[i+5 for i in range(10) if i%2==1]	# 위 사진을 보고 동작 순서 이해하기
print(a)				# [6, 8, 10, 12, 14]

서식 지정자(format specifier)와 formatting사용하기

: 문자열 혹은 숫자 안에서 특정 부분을 원하는 값으로 바꿀 때 서식 지정자 또는 포매팅을 사용

• 문자열 넣기

# '%s' % '문자열' -> string의 s
'I am %s.' % 'james'    # 'I am james.'

# 문자열 대신 변수 지정
name='maria'
'I am %s.' % name   # 'I am maria.'

• 숫자 넣기

# 소수점 이하 자릿수 지정 -> f앞에 .(점)자릿수 지정
fD=3.141592
'%.2f' %fD	# 3.14

# 서식 지정자로 숫자 넣기
# '%d' % 숫자 -> 10진 정수 decimal integer의 d
nAge=25
"I'm %d years old." %nAge	# I'm 25 years old.

number1, number2=map(int,input("입력: ").split())	# 입력: 3 7
total=number1+number2					# 2개의 입력 변수, 결과 변수 사용
print('%d+%d=%d' %(number1, number2, total))		# 3+7=10
							# 여러 변수 넣을 땐 ,(콤마) 구분

# 소수점 이하 자릿수 지정 -> f앞에 .(점)자릿수 지정
# f는 fixed point
fD=3.141592
'%.2f' %fD	# '3.14'
print(type(fD))	# <class 'float'> 실수인 것 확인

• 여러 값 넣기 (🔢인덱스 순서 주의!)

# format method로 값을 여러 개 넣기
# 인덱스 순서와 format에 지정된 값의 순서를 주목
'Hello, {0} {2} {1}' .format('Python','Script',3.6)
# Hello, Python 3.6 Script

'{0} {0} {1} {1}' .format('Python','Script')
# Python Python Script Script

# format methon에서 {}에 인덱스 대신 이름 지정하기
'Hello, {language} {version}'.format(language='Python', version=3.6)
# Hello, Python 3.6 -> 딕셔너리 같은 개념

# f포매팅 -> 변수에 값을 넣고 {}에 변수 이름 지정
language='Python'
version=3.6
f'Hello, {language} {version}' # 문자열 앞에 f

name="Park"
age=25

formatted_string=f"이름:{name}, 나이:{age}"	# 문자열 앞 f formatting, 그리고 변수 할당
print(formatted_string)				# 이름:Park, 나이:25

↑위 아래↓ fomatting check

strName = 'Hong'
nAge = 20
print("이름=%s, 나이=%d" % (strName, nAge)) # 문자열은 '한 줄로' 따옴표
# 이름=Hong, 나이=20

함수 사용하기

: function, 파이썬은 특정 용도 코드를 한 곳에 모아 놓음

ex) print, input 등 미리 만들어 둔 파이썬 내장함수

• 함수 장점
  1. 코드 용도를 구분
  2. 코드 재사용 가능
  3. 실수(mistake)를 줄일 수 있다.
• def에 함수 이름을 지정하고 ()(괄호)와 :(콜론)을 붙인 뒤 다음 줄에 원하는 코드를 작성(들여쓰기 주의)

def 함수이름():

     code

def hello():
    print("Hello, World!")	# 1.우선 함수 정의

hello()				# 2.함수 호출(function call)
# Hello, World!

# 함수 여러 번 호출하기
for i in range(10):
    hello()

'''op
Hello, World! 0
Hello, World! 1
Hello, World! 2
...
Hello, World! 9
'''	# 0~9까지 총 10줄 생성

parameter:매개변수, argument:인수

def 함수이름(매개변수1, 매개변수2):

코드

def add(a,b):		# 값을 받으려는 변수:parameter(매개변수)
    print(a+b)

add(10,20)	# 30	## function call 넣는 값:argument(인수)

def 함수이름(매개변수):

return 반환값

• return을 사용하면 값을 함수 바깥으로 반환
• return에 값을 지정하지 않으면 None 반환

def add(a,b):	# parameter:a,b
    return a+b

x=add(10,20)	# argument:10,20
x		# 30

def x(a,b,c):
    x=a*b*c
    return x

a,b,c=map(int,input("input_num: ").split())	# input_num: 5 6 4
print(x(a,b,c))					# 120

• 함수에서 값을 여러 개 반환
• return에 값이나 변수를 ,(콤마)로 구분해서 지정

def add_sub(a,b):
    return a+b, a-b	# a+b와 a-b를 ,로 구분

x,y=add_sub(10,20)	# 반환값을 각 x와 y에 할당한다고 했을 때
x   # 30		## x는 a+b이므로 10+20을 한 반환값 30 출력
y   # -10		## y는 a-b이므로 10-20을 한 반환값 -10 출력

• 값을 하나의 변수에 저장하면 튜플이 unpacking

def add_sub(a,b):
    return a+b, a-b

x=add_sub(10,20)	#값을 하나의 변수에 저장하면 튜플이 반환(unpacking)
x   			# (30, -10)

< 실습 >

• 함수를 이용하여 두 개의 정수를 입력 받아 각각 +, -, *, / 한 뒤 값을 formatting하여 출력. (각 출력값은 소수점 이하 두 자리까지 나오게 한다.)

def x(a,b):
    return a+b, a-b, a*b, a/b

a,b=map(int,input("input_num: ").split())
result1,result2,result3,result4 = x(a,b)    # 위에 정의한 함수를 사용할 것!
print("+= %.2f, -= %.2f, *= %.2f, /= %.2f" %(result1,result2,result3,result4))	# 소수점 이하 두 자리
# input_num: 10 20
# += 30.00, -= -10.00, *= 200.00, /= 0.50

• 세 정수를 입력 받은 후 각각 곱과 합을 출력

def add_multi(a,b,c):
    return a*b*c,a+b+c

a,b,c=map(int,input("input_num: ").split())
result1, result2 = add_multi(a,b,c)		# return 순서대로 result1이 곱, result2가 합
print("곱은 %d, 합은 %d" %(result1,result2))	# 여러 개의 %format 형식을 괄호로 묶어준다.
print(f"곱은 {result1}, 합은 {result2}")		# f포매팅은 각 format 형식에 {}을 씌운다.

'''op
input_num: 2 3 4
곱은 24, 합은 9
곱은 24, 합은 9
'''

• 계산기 프로그램 만들기

def add(a,b):
    return a+b
def minus(a,b):
    return a-b
def multi(a,b):
    return a*b
def div(a,b):
    return a/b
def rest(a,b):
    return a%b

print('='*30)
print('1. 더하기')
print('2. 빼기')
print('3. 곱하기')
print('4. 나누기')
print('5. 나머지 구하기')
print('6. 나가기')
print('='*30)

while True:
    a=int(input("원하는 연산자를 입력하세요:"))
    if a<=5:
        b=int(input("첫번째 숫자를 입력하세요:"))
        c=int(input("두번째 숫자를 입력하세요:"))
        if a==1:
            x = add(b,c)
            print("결과는 %d 입니다"%x)
        elif a==2:
            x = minus(b,c)
            print("결과는 %d 입니다"%x)
        elif a==3:
            x = multi(b,c)
            print("결과는 %d 입니다"%x)
        elif a==4:
            x = div(b,c)
            print("결과는 %d 입니다"%x)
        elif a==5:
            x = rest(b,c)
            print("결과는 %d 입니다"%x)
    elif a==6:
        print("계산기 프로그램을 종료합니다.")
        break
    else:
        print("잘못입력하셨습니다. 다시 입력해 주세요.")

: ↑ 분석해보고 주석 달기. 더 간략하게 줄여보기

1. 상기 코드에서 여러 번 정의된 함수를 def cal(a,b) return 여러 반환값으로 한 줄 표시↓
   • 따라서 while문 안에 if도 코드 변수를 변경해줘야 함
2. 연산자 입력을 여러 번 입력하지 않고 \n 개행으로 한 줄 표시
3. 각 cal 함수는 순서대로 +-*/% ( 변수와 반환값 순서를 잘 생각)
4. 연산자 이외 나가기 기능 elif, 지정된 기능 이외 숫자 입력 시 (1~6 제외) 오류 표시 및 처음부터 재실행
   • 무한루프이므로 break가 걸리기 전까지 반복.
   • 조건 충족되면 계속 값을 출력, 충족되지 않으면 처음으로 돌아가서 재실행

def cal(a,b):
    return a+b, a-b, a*b, a/b, a%b
    # 반환값 여러 개를 변수 여러 개에 저장

print("="*30)
# print 여러 줄 대신 \n 개행으로 기능 한 줄 입력
print("1.더하기\n""2.빼기""\n""3.곱하기""\n""4.나누기""\n""5.나머지구하기""\n""6.나가기")
print("="*30)

# 6.나가기 기능을 쓸 때까지 무한 루프.
while True:
    func_in=int(input("원하는 연산자를 입력하세요:"))   # func_in : 사용할 계산기 기능(+-*/%) 입력
    
    # 계산기의 기능은 1~5까지 5가지이므로 <=5
    if func_in <= 5:
        x=int(input("첫번째 숫자를 입력하세요:"))
        y=int(input("두번째 숫자를 입력하세요:"))
        if func_in==1:
            cal = add(x,y)  # 저장된 변수의 값을 순서대로 반환(+)
            print("결과는 %d 입니다" %cal)  # %formatting
        elif func_in==2:
            cal = minus(x,y)    # (-)
            print("결과는 %d 입니다" %cal)
        elif func_in==3:
            cal = multi(x,y)    # (*)
            print("결과는 %d 입니다" %cal)
        elif func_in==4:
            cal = div(x,y)  # (/)
            print("결과는 %d 입니다" %cal)
        elif func_in==5:
            cal = rest(x,y) # (%)
            print("결과는 %d 입니다" %cal)
    elif func_in==6:
        print("계산기 프로그램을 종료합니다.")
        break   # 6.나가기 기능
    else:
        print("잘못입력하셨습니다. 다시 입력해 주세요.")
        # 계산기 1~6까지 기능 이외의 숫자 입력 시 재입력 문구 표시 후 처음으로 돌아가기(무한루프니까)

최대한 분석하고 주석 달면서 복습하고 있다. 하지만 아직도 문법이 미숙한건지, 문제 이해가 어려운건지, 작성할 코드에 어떤 기능을 사용할지 바로바로 감이 오지 않아서 아직도 코드를 짤 때 시간이 오래 걸린다. 오로지 연습뿐🥲 매일 복습하고 단계적으로 문제를 풀어보면서 감을 익히도록 해야겠다.

Date : 2023-07-07

Topic : 반복문 (for, while), 디버깅

Note

for 반복문

nStart=int(input("시작 숫자:"))
nEnd=int(input("끝 숫자: "))
nInterval=int(input("간격: "))

if (nStart>nEnd) and nInterval <0:
    nEnd=nEnd+1
    for i in range(nStart, nEnd, nInterval):
        print(i)
elif (nStart<nEnd) and nInterval >0:
    for i in range(nStart, nEnd, nInterval):
        print(i)
else:
    print("입력된 내용이 적절하지 않습니다.")

• 리스트를 반복

a=[10,20,30,40,50]
for i in a:
    print(i)

'''output	#세로로 출력. (반복문이라?🧐) 
10
20
30
40
50
'''

• 문자열을 반복

a='hello, python!'  #문자열도 시퀀스 객체
for i in a:
    print(i, end=" ")	# end=' ' 활용, 공백으로 줄바꿈 삭제
    			# print()에는 \n(줄바꿈 default)

'''output
h e l l o ,   p y t h o n ! 
'''

디버깅

• pdb 모듈은 파이썬 프로그램을 위한 대화형 소스코드 디버거
• breakpoint(중단점) 및 단계 실행(single stepping) 설정, 스택 프레임 검사, 소스 코드 목록, 그리고 모든 스택 프레임의 컨텍스트에서 임의의 파이썬 코드 평가를 지원.

#디버깅 해보기
import pdb
pdv.set_trace() #이곳에서 프로그램 중단
total=0
number=int(input("숫자 입력: "))
for i in range(nunmber+1):
    total=total+1
print(total)

# 복습하다보니 이해 안간다. 질문✅

< 실습 >

- ex1) 리스트 요소에 10을 곱하고 공백으로 구분하여 한 줄 출력

x=[49,-17,25,102,8,62,21]   #list, 시퀀스 자료형

for i in x:
    print(i*10, end=" ")    #공백으로 구분하여 한 줄 출력
    
# output: 490 -170 250 1020 80 620 210

-ex2) 구구단 만들기

int_num=int(input("입력: "))	# 

for i in range(1,10):
    print(int_num,"*",i,"=",int_num*i)  #'숫자*숫자=값' 형태로 출력

-ex3) 정수 입력, 0부터 입력값까지의 합을 구하기

total=0
num=int(input("입력: "))

for i in range(num+1):
    total=total+i   # 변수 i를 더해줘야 함
print(total)

-ex4) 학생 수를 입력하고, 점수를 입력 받아 평균 구하기

s=int(input("학생 수: "))
total=0 #누적합 변수 선언

for i in range(s):
    print(i+1,"번 학생 점수: ", end='') #s수만큼 반복(i+1)
    score=int(input())
    total+= score   # total=total+score (a+=1 -> a=a+1)

avg=total/s
print() #줄 띄어쓰기용 (</br>)
print('평균: ', avg,'점')  #계산한 평균을 출력

-ex5) 학생 수를 입력하고, 점수를 입력 받아 평균 구하기

nCnt=int(input('학생 수: '))
nTotal=0

for i in range(nCnt):	# 학생의 수가 반복 범위
    nScore=int(input(str(i+1)+'번 학생의 점수: '))	# 학생 수에 +1 (0~N-1 아니고, 1~N번 학생이란 뜻)
    nTotal += nScore		# nTotal=nTotal+nScore 누적합(총합=+순차적으로 입력한 학생의 점수)

fAvr=nTotal/nCnt		# 평균=점수 총합/학생 수
print()	# 띄어쓰기용
print('평균: ', fAvr, '점')	# 계산한 평균을 출력

while 반복문

• 초기식부터 시작하여 조건식 판별
•  조건식
  • True - 반복할 코드와 변화식을 함께 수행
  • False - 반복문 끝낸 뒤 다음 코드 실행

i = 0                     # 초기식
while i < 10:            # while 조건식
     print('Hello, world!')    # 반복할 코드
     i += 1                    # 변화식

• 초기값 감소시키기 (위 코드와 비교해보기)

#Hello, world!를 10부터 1까지 감소하도록 cnt 출력
i = 10                    # 감소하므로 큰->작은 값
while i > 0:              # while 조건식
     print('Hello, world!', 1)  # 반복할 코드
     i -= 1                     # 증감식 (감소하므로 + 대신 - 입력)

- ex1) 입력값만큼 증감식 만들기 (증가/감소 각각 코드 짜기)

cnt=int(input('반복할 횟수를 입력: '))

i=0
while i < cnt:
    print('Hello, world!', i)
    i += 1  #증가식

cnt=int(input('반복할 횟수를 입력: '))

while cnt > 0:
    print('Hello, world!', cnt)
    cnt -= 1    #감소식

🧐코드 분석하고 비교해보기

- ex2) 1~10까지 순서대로 칸 바꾸지 않고 공백으로 구분하여 출력.

num=1
while num<=10:
    print(num, end=' ')
    num += 1

- ex3) -50~1까지 구하고 5번째 수마다 줄바꿈하기. (숫자 사이 간격은 tab1=\t)

i= -50
cnt=1
i=int(input())

while i <= 1:
    if cnt%5==0:
        print(i, end='\t')
        print()
    else:
        print(i, end="\t")
    i += 1
    cnt += 1

- ex4) 하나의 정수를 입력 받고 1부터 입력값까지 더하는 프로그램 (while, for문 각각 작성)

nData=int(input("총합을 구할 숫자: "))
nTotal=0

while nData>0:		# 입력한 값부터 -1씩 줄어서 1이 될 때까지 반복할 동안
    nTotal += nData	# 반복문에 의해 1부터 순서대로 값이 저장(+nTotal에 다시 값을 더해서 할당되게)
    nData -= 1

print('총합:', nTotal) 	# 10 입력 시 55 출력, 100 입력 시 5050 출력(검증해보기)

nData=int(input("총합을 구할 숫자: "))
nTotal=0

for i in range(1,nData+1):	# range(0<=i<N 이니까 각 항에 +1하면 1부터 입력값까지 구할 수 있음)
    nTotal += i			# i는 [1,2,3, ... ,nData] -> 누적합

print('총합:', nTotal)

- ex5) 60점을 커트라인으로 불합 여부 출력하기(리스트 순서는 학생의 번호)

marks=[90,25,67,45,80]

for i in range(len(marks)):
    if marks[i]>=60:				# i는 0부터
        print(i+1, "번 학생은 합격입니다.")	# i+1 -> 0+1=1(번), 1+1=2(번), ..., 4+1=5(번) 학생
    else:
        print(i+1, "번 학생은 불합격입니다.")

'''op:
1 번 학생은 합격입니다.
2 번 학생은 불합격입니다.
3 번 학생은 합격입니다.
4 번 학생은 불합격입니다.
5 번 학생은 합격입니다.
'''

marks=[90,25,67,45,80]
count=1

for i in marks: # marks 리스트의 길이는 요소의 개수이므로 그냥 marks 써도 OK
    if i >=60:
        print(count, "번 학생은 합격입니다.")
    else:
        print(count, "번 학생은 불합격입니다.")
    count += 1  # 리스트 요소는 5개, count가 1부터므로 5번의 반복 -> (1~5)

'''op:
1 번 학생은 합격입니다.
2 번 학생은 불합격입니다.
3 번 학생은 합격입니다.
4 번 학생은 불합격입니다.
5 번 학생은 합격입니다.
'''

반복 횟수가 정해지지 않은 경우

• random 모듈
• import random
• module: 파이썬 코드를 논리적으로 묶어서 관리 (.py)
• 모듈 안에는 함수, 클래스, 변수들이 정의될 수 있고 실행 코드를 포함
• 파이썬은 많은 표준 라이브러리 모듈 제공

#random 모듈 찾기
import random
import inspect
print(inspect.getfile(random))

#0~100 총합 구하기
tot=0
i=0
while True:
    i+=1    	#순서1	(바뀌면 값 달라짐)
    tot += i	#주의2
    if i==100:
        break
print(tot)

이 날 수업이 제일 어려웠어서 개념 익히고 감 잡는데 오래 걸렸다... 아직도 많이 헷갈리지만🫢 그래서 제일 늦게 올리는 14일차 학습일지^_^ 거의 매 일지마다 쓰는 것 같지만 정말 꾸준히 풀어보는게 정답.. 이제 슬슬 문제 이해도 잘 되고 분석도 할만한데 여전히 직접 코드를 짜는 부분이 힘들다. for문은 그래도 좀 할만한데 while문이 왜이렇게 어려운지..! 간단한 문제는 금방 푸는데 조금만 머리 써야 하면 while문은 바로 막혀버린다. 그래도 계속 주석 표시하면서 문제 반복적으로 보기!

Date : 2023-07-05

Topic : 시퀀스 자료형(⭐리스트, 튜플, 딕셔너리 etc), if 조건문

Note

딕셔너리 만들기

• ex1) "영문 이름"을 입력하면 "한글 이름"이 출력되도록

fruits={'apple':['사과',1000], 'banana':['바나나',700],'orange':['오렌지',1500],'pineapple':['파인애플',2000]}
sel=input("과일 이름을 입력하세요: ")
print("선택한",fruits[sel][0],"의 가격은",fruits[sel][1],"원입니다.")

#output:

• ex2) 사과 가격을 입력 받은 금액으로 변경해보기

fruits={'apple':['사과',1000], 'banana':['바나나',700],'orange':['오렌지',1500],'pineapple':['파인애플',2000]}
sel=int(input("변경된 사과 가격을 입력하세요: ")) #input()은 문자열로 출력되므로 int() 사용
fruits['apple']=sel
print("변경된 사과 가격은",fruits,"입니다.")

#output:

# map(func, input().split()) 자주 사용

# map(func, sequence) : 시퀀스 자료형의 요소를 지정된 함수로 처리해주는 함수.
#원본 리스트를 변경하지 않고 새 리스트를 형성

list(map(func, list))
tuple(map(func, tuple))

# map object는 iterable -> 변수 여러 개에 저장하는 unpacking이 가능.
# ex)
a,b = map(int, input().split())

# 아래처럼 풀어서 쓸 수 있다.
x = input().split()    # input().split()의 결과는 문자열 리스트
m = map(int, x)        # 리스트의 요소를 int로 변환, 결과는 맵 객체
a, b = m               # 맵 객체는 변수 여러 개에 저장할 수 있음

• ex3) 과일 가격 입력하

fruits={'apple':0, 'banana':0,'orange':0,'pineapple':0}
ai,bi,oi,pi=map(int,input("과일 가격을 사과, 바나나, 오렌지, 파인애플 순으로 입력(/구분): ").split('/'))
fruits['apple']=ai
fruits['banana']=bi
fruits['orange']=oi
fruits['pineapple']=pi
print(fruits)

'''output
과일 가격을 사과, 바나나, 오렌지, 파인애플 순으로 입력(/구분): 700/600/800/1000
{'apple': 700, 'banana': 600, 'orange': 800, 'pineapple': 1000}
'''

If 조건문

: 특정 조건일 때 코드 실행

num=int(input())
if num==7:
    print("행운")

num=int(input())
if num>=10:
    print("크다")

• 중첩 if 조건

x=15
if x>=10:
    print('10 이상입니다.')
    if x==15:
        print('15입니다.')
    if x==20:
        print('20입니다.')

'''output
10 이상입니다.
15입니다.
'''
# 중접if문에 'x==' 조건이 성립하지 않으면 상위 if만 출력
# x=18일 경우
'''output
10 이상입니다.
'''

< 실습 >

• ex1) 정수값을 입력하고 홀수인지 짝수인지 판별하기

int_num=int(input('값(정수):'))

if int_num%2==0:	# 자주 사용함
    print("짝수")
if int_num%2==1:
    print("홀수")

#or

int_num=int(input('값(정수):'))

if int_num%2==0:
    print("짝수")
else:
    print("홀수")

• ex2) 정수값을 입력하고 10보다 큰지 작은지, 같은지 판별하기

int_num=int(input('값(정수):'))

if int_num>10:
    print('10보다 크다.')
if int_num==10:
    print('10과 같다.')
if int_num<10:
    print('10보다 작다.')
    
#or

int_num=int(input('값(정수):'))

if int_num>10:
    print('10보다 크다.')
elif int_num==10:
    print('10과 같다.')
else:
    print('10보다 작다.')

• else 사용하기

int_num=int(input('값(정수):'))

if int_num==10:
    print('10입니다.')
else:
    print('10이 아닙니다.')

• if 조건문의 동작 방식 : True는 if 코드 실행, False는 else 코드 실행
• if 조건문에 숫자 지정 : 정수, 실수, 2,8,16진수 상관 없이 0이면 거짓

if 0:
    print('참') #거짓
else:
    print('거짓')
    
if 1:
    print('참') #참
else:
    print('거짓')
    
if 0x1F:
    print('참') #16진수 / 참
else:
    print('거짓')
    
if 0b1000:
    print('참') #2진수 / 참
else:
    print('거짓')
    
if 13.5:
    print('참') #실수 / 참
else:
    print('거짓')

• if 조건문에 문자열 지정 : 어떤 문자열이든 값이 있으면 참, 빈 값은 거짓
• if 조건식을 여러 개 지정 : 논리 연산자 사용(and, or, not)

x=10
y=20
if x==10 and y==20:
    print('True')
else:
    print('False')

• 중접 if 조건문과 논리 연산자

if x>0:
    if x<20:
        print('20보다 작은 양수입니다.')
        
#or

if x>0 and x<20:
    print('20보다 작은 양수입니다.') #파이썬 권장 코드
    
#or

if 0<x<20:
    print('20보다 작은 양수입니다.')

< 실습 >

• ex0) 쿠폰 적용하여 할인 받기

nMoney=int(input('값 입력:'))
strCp=input('쿠폰 입력:')
# 'Cash3000'은 3000원 할인, 'Cash5000'은 5000원 할인

if strCp=='Cash3000':
    if nMoney>=3000:
        print(nMoney-3000)
    else:
        print('금액이 부족합니다.')
if strCp=='Cash5000':
    if nMoney>=5000:
        print(nMoney-5000)
    else:
        print('금액이 부족합니다.')

• ex1) 필기 커트라인 80 이상, 코딩테스트 합/불 (True/False), "합격", "불합격"이 출력되도록 소스 코드 작성하기

written_test=75
coding_test=True

if written_test>=80 and coding_test==True:
    print("합격")
    
else:
    print("불합격")
    
#op: 불합격 (필기가 75점이어서 and 연산자 X)

result_wri=int(input("필기 점수: "))
coding_test=input("합격 / 불합격: ")

if result_wri>=80 and coding_test=='합격':
    print("합격")

else:
    print("불합격")

• ex2) 과목 점수를 입력하고 과목 평균이 80 이상이면 합격, 그렇지 않으면 불합격으로 출력.
  (단, 각 과목은 0~100 범위로만 입력할 수 있고 이외의 점수를 입력하면 잘못된 점수로 출력할 것.)

kor=int(input("국어: "))
eng=int(input("영어: "))
math=int(input("수학: "))
sci=int(input("과학: "))
avg=(kor+eng+math+sci)/4

if(0<=kor<=100 and 0<=eng<=100 and 0<=math<=100 and 0<=sci<=100):
    if avg>=80:
        print("합격")
    else:
        print("불합격")
else:
    print("잘못된 점수")

• ex3) 음료수 뽑기

button=int(input('음료수 번호를 입력하세요(1.콜라, 2.사이다, 3.환타) : '))

if button==1:
    print('콜라')
elif button==2:
    print('사이다')
elif button==3:
    print('환타')
else:
    print('제공하지 않는 메뉴')

• ex4) 학생인지 아닌지 체크

# 중첩 조건문 if (if 안에 if)
stu=int(input("학생:1/학생 아님:0 입력 : "))

if stu==1:
    myStr="학생이며"
    w_class=int(input("초등학생:1/중학생:2/고등학생:3 : "))
    if w_class==1:
        print(myStr, '초등학생입니다.')
    elif w_class==2:
        print(myStr, '중학생입니다.')
    elif w_class==3:
        print(myStr, '고등학생입니다.')	# elif, else는 생략 가능. 고등학생 조건을 넣어주기 위해 elif 사용
else:
    print("학생이 아닙니다.")

• ex5) 자판기 음료 뽑기

money=int(input("금액 입력 : "))
button=int(input("음료선택 1.콜라/600원, 2.사이다/700원, 3.환타/800원 : "))

if button==1:
    if money>=600:
        print("콜라", "/ 잔액 :", money-600)
    else:
        print("금액 부족")
elif button==2:
    if money>=700:
        print("사이다", "/ 잔액 :", money-700)
    else:
        print("금액 부족")
elif button==3:
    if money>=800:
        print("환타", "/ 잔액 :", money-800)
    else:
        print("금액 부족")
else:
    print("잘못된 선택")

• ex6) 변수 x가 11과 20 사이면 '11~20', 21과 30 사이면 '21~30', 아무것도 해당하지 않으면 '아무 것도 해당하지 않음' 출력

x=int(input())

if 11<=x<=20:
    print('11~20')
elif 21<=x<=30:
    print('21~30')
else:
    print('아무것도 해당하지 않음')

• ex7) 교통카드 잔액

age=int(input('나이: '))
balance=9000    #교통카드 잔액

if (7<=age<=12):
    balance=balance-650
elif (8<=age<=18):
    balance=balance-1050
elif (age>=19):
    balance=balance-1250
else:
    balance=balance    # 7세 미만은 무료를 의미
print(balance)         # 잔액 출력

• ex8) 한 점을 구정하는 x,y 좌표를 입력 받고 몇 사분면에 있는지 판별하는 프로그램을 작성

# 내가 작성한 코드
x=int(input('x좌표:'))
y=int(input('y좌표:'))

if x>0 and y>0:
    print('1사분면')
elif x<0 and y>0:
    print('2사분면')
elif x<0 and y<0:
    print('3사분면')
elif x>0 and y<0:
    print('4사분면')
else:
    print('사분면에 해당하는 data가 아닙니다.)

# map함수, 리스트 인덱스 활용한 코드
xy=list(map(int,input('x,y값을 입력(","로 구분) : ').split(',')))
# 입력값을 map함수로 정수형으로 변환 뒤 리스트로 출력

if 0<xy[0] and 0<xy[1]:   #xy=[x,y], xy[0]은 x좌표, xy[1]은 y좌표. 
    print('1사분면에 있습니다.')
elif 0>xy[0] and 0<xy[1]:
    print('2사분면에 있습니다.')
elif 0>xy[0] and 0>xy[1]:
    print('3사분면에 있습니다.')
elif 0<xy[0] and 0>xy[1]:
    print('4사분면에 있습니다.')
else:
    print('사분면에 존재하지 않는 data입니다.')

• ex9) 사각형 안의 한 점 판단
  • 한 점을 구성하는 x,y 좌표를 입력 받고, 이 점이 (50,40), (50,80), (100,40), (100,80)을 꼭짓점으로 갖는 사각형 안에 있는지 판별하는 프로그램 작성하기 (hint: 좌표 위에 사각형을 그려본다.)

# 내가 짠 코드
xy=list(map(int,input('x,y값을 입력(","로 구분) : ').split(',')))

if 50<=xy[0]<=100 and 40<=xy[1]<=80:
    print('사각형 안에 있습니다.')
else:
    print('사각형 안에 없습니다.')

#아래처럼 짤 수도 있다.

nx, ny=map(int,input("'x,y' 형태로 좌표 입력: "))

if (nx>=50 and nx<=100) and (ny>40 and ny<80):
    print("사각형 안에 있습니다.")
else:
    print("사각형 안에 없습니다.")

< 예제 >

• ex1) 입력한 색상이 리스트에 포함되었는지 확인
  • colors라는 색상표 리스트가 다음과 같이 선언되었음

colors = ['red', 'orange', 'blue', 'green', 'white', 'black', 'dark blue', 'purple']

colors=['red', 'orange', 'blue', 'green', 'white', 'black', 'dark blue', 'purple']
color=input('색상 입력: ')

if color in colors: #리스트에 포함되는지 확인 in
    print('중복')
else:
    print('신규')

• ex2) 입력한 값에서 20을 더하여 출력. 단, 20을 더한 출력값이 225를 초과하는 값은 225로 출력한다.

num=int(input("값 입력:"))

if num+20>225:
    num=225
else:
    num=num+20		# 입력값+20이 225를 넘지 않을 경우
print("출력값:", num)

• ex3) 입력한 값에서 20을 빼서 출력. 단, 20을 뺀 출력값이 음수일 경우는 0으로 출력, 225를 초과하는 값은 225로 출력한다.

num=int(input("값 입력:"))

if num-20<0:
    num=0
elif num-20>225:
    num=225
else:
    num=num-20
print("출력값:", num)

• ex4) 시간을 입력하여 정각인지 아닌지 판별하기
  • if문 활용
  • list 활용
  • slice 활용

# if문 활용하기
hour,min=input("시간 입력(hh:mm): ").split(':')
    # ':'를 기준으로 각각 hour, min으로 문자열이 분리

if min=='00':
    print("정각입니다.")
else:
    print("정각이 아닙니다.")

# list 활용하기
time=list(map(int,input("시간 입력(hh:mm): ").split(':')))
print(time[0],"시",time[1],"분")

if time[1]==00:
    print('정각입니다.')
else:
    print('정각이 아닙니다.')

# slice 활용하기
t=input("시간 입력(hh:mm): ")

    # hh:mm에서 3번째 인덱스부터 구하면 mm만 슬라이싱
    # 문자열이므로 숫자 0 이 아닌 '00'으로 정확히 입력
if t[3:]=='00':
    print("정각입니다.")
else:
    print("정각이 아닙니다")

• ex5) 나이를 입력하고 성년/미성년 판별하기. 단, 나이는 10세부터 99세만 입력한다.

# 처음 짠 코드 : 길고 번잡하다. 순서를 생각해서 다시 짜보기
age=int(input("나이 입력: "))

if 10<=age<=99:
    if age>=19:
        print("성년입니다.")
    elif age<19:
        print("미성년입니다.")
    else:
        print("입력 범위를 벗어난 값입니다")
else:
    print("입력 범위를 벗어난 값입니다")
    
# 다시 짠 코드 : 정상 작동.
age=int(input("나이 입력: "))

if age<10 or age>99:	#하나라도 범위를 벗어나면 안되니까 'or'
    print("입력 범위를 벗어난 값입니다")
elif age>=19:
    print("성년입니다.")
elif age<19:
    print("미성년입니다.")
    
# elif, else는 생략 가능하다.
# 1. if문은 먼저 조건을 만족하면 이후 조건은 모두 무시한다.
# 2. 따라서 입력값의 요구사항을 if문으로 먼저 작성한 뒤,
# 3. 입력값이 10~99라는 값을 만족하면 이후에 elif문으로 성년/미성년을 판별하도록 작성한다.

# slice 활용1
age=input("나이 입력:")
print(age,"세")

age=int(age[:3])	#나이가 세 자리(100->[0],[1],[2])일 수 있으므로 [0:3]으로 슬라이싱해준다.
if age<10 or age>99:
    print("입력 범위를 벗어난 값입니다")
elif age>=19:
    print("성년")
else:
    print("미성년")
    
# slice 활용2 - 내 기준 제일 직관적이다.
age=input("나이 입력(세):")
age=int(age[:3])

if 19<=age<=99:
    print("성년")
elif 10<=age<=18 :
    print("미성년")
else:
    print("입력 범위를 벗어난 값입니다")
    
# 슬라이싱을 len()으로
age=input("나이 입력(00세): ") #'00세'로 입력
n_age=int(age[:len(age)-1]) #글자수 '세'에 해당하는 -1 해주면 '00' 나이만 길이 구해짐.

if n_age>99 or n_age<10:
    myStr="잘못된 입력입니다."
elif 10<=n_age<=19:
    myStr="미성년입니다."
else:
    myStr="성년입니다"
print(myStr)	#만족 조건을 변수로 설정하고 print(변수)로 출력

• ex6) 주민번호 뒷자리 맨 앞 번호를 입력 받아 여자인지 남자인지 확인하는 코드 작성하기
  7자리 자릿수가 틀렸다면 오류 메시지를 표시하고 종료한다. 
  • 여자는 2,4
  • 남자는 1,3

Id=input("주민번호 뒤 7자리: ") #변수 주의 id(x), Id(o)

if len(Id)!=7:	#주민번호 뒷자리는 7자리이므로 아닐 경우(!=) 오류 표시.
    print("잘못된 자릿수입니다.")
else:
    Id=int(Id[0])	#input 출력값은 문자형이므로 int 사용. Id[0]은 주민번호 뒷자리 맨 앞 번호.
    if Id==1 or Id==3:
        print("남자")
    elif Id==2 or Id==4:
        print("여자")
    else:
        print("잘못된 입력입니다")

• ex7) 자판기 음료 뽑기. 단, 입금 최대 금액은 10000원이며 선택 음료보다 금액 부족 시 메시지 표시.
  
  1. 사이다 700원
  2. 콜라 600원
  3. 오렌지주스 800원

price = int(input("금액을 입력하세요(최대 1만원):"))
drink = int(input("음료선택 1.사이다 700원, 2.콜라 600원, 3.오렌지쥬스 800원 : "))

if price>10000:
    print("최대 금액 초과")	#1만원이 넘는다면 금액 초과 오류 메시지
else:
    if drink==1:
        if price<700:		#음료값보다 넣은 금액이 적으면 잔액 부족 메시지
            print("잔액 부족")
        else:			#상위 조건을 모두 만족하면 결제 비용 제외 후 잔액 반환
            print("잔액:",price-700)
    elif drink==2:
        if price<600:
            print("잔액 부족")
        else:
            print("잔액:",price-600)
    elif drink==3:
        if price<800:
            print("잔액 부족")
        else:
            print("잔액:",price-800)
    else:
        print("잘못된 선택")	#3가지 음료 외 다른 입력 시 오류 메시지
        
#들여쓰기와 같은 level의 구문 체크 주의하기

✅고민해보고 수정하기!!

input_money=int(input("금액을 입력하세요: "))
menu_dict={"1":700, "2":600, "3":800}

if input_money>10000:
    print("최대 금액 초과")
else:
    input_menu=input("음료 선택: ")
    if input_money-menu_dict[input_menu]<0:
        print("금액 부족")
  # elif menu_dict.keys():
  #	print("잘못된 선택") <- 어떻게 작성해야 하지?
    else:
        return_money=input_money-menu_dict[input_menu]
        print("잔액은",return_money,"원입니다.")

for 반복문

for 변수 in sequence자료형

#for반복문으로 'Hello, World!' 100번 출력
for i in range(100):
    print('Hello, world!')

nStart=int(input("시작 숫자:"))
nEnd=int(input("끝 숫자: "))
nInterval=int(input("간격: "))

if (nStart>nEnd) and nInterval <0:
    nEnd=nEnd+1
    for i in range(nStart, nEnd, nInterval):
        print(i)
elif (nStart<nEnd) and nInterval >0:
    for i in range(nStart, nEnd, nInterval):
        print(i)
else:
    print("입력된 내용이 적절하지 않습니다.")

이론 같은 그 날 배운 개념을 따로 작성해두는 것도 좋지만, 파이썬 수업은 실습 위주인 만큼 코드를 직접 작성하는 것이 복습 겸 개념 정리에 좋은 것 같다. 특히 코드를 입력해두고 #주석 처리를 하면 자주 헷갈리는 것이나 중요한 핵, 실수한 코드에 대한 오답노트처럼 표기할 수 있어서 당분간 학습일지는 이렇게 작성할 듯 싶다. 아직도 기초가 제대로 안잡혀서 문제 이해도 오래 걸리고 코드 짜는데도 억겁의 시간이 필요하지만 하나 하나 분석해서 이해하다 보니 개념 정리가 되고 있는 것 같다. 파이썬 수업 시작 이후로 수업 따라가는 것만으로도 벅차서 하루 일과에 정규 수업 시간을 빼면 하루 종일 문제만 붙잡고 풀고 있다. 특히 프로그래밍 특성상 여러 방식으로 시도해볼 수 있어서 더 시간이 오래 걸리는 것 같다. 아직 너무 힘든 단계이긴 하지만, 힘겹게나마 문제를 풀고 나면 생기는 그 성취감이 지금 나를 이끌어 주고 있다. 빨리 파이썬에 더 익숙해져서 한껏 더 재미 붙일 수 있으면 좋겠다.

Date: 2023-07-04

TOPIC: 연산자, 조건문, 반복문, 자료형, 함수

기초 문법

• 파이썬
  • 대소문자 구분O
  • 들여쓰기 민감 (암묵적으로 tab 1=space 4)
  • python 및 대부분 프로그래밍 언어는 인덱스 시작 0
• 연산자
  • 몫(//)
  • 나머지(%)
  • 한번에 구하기( divmod (a,b) )

divmod(10,3)
#op: (3, 1)

1. •  거듭제곱(**)

• 조건문 if

a=10
if a > 1 :
	print('a는 1보다 크다')
#output: a는 1보다 크다

• 반복문 for : 정확히 N번, 횟수로 반복하고 싶을 때

for a in [1,2,3] :
    print(a)
'''
1
2
3
'''

• 반복문 while : 몇 번째일지는 몰라도 특정 조건을 만족할 때까지

a=0
while a < 3:
    a=a+1
    print(a)
'''
1
2
3
'''

• 함수
  : def와 return을 통한 함수 선언

def sum(a,b):
    c=a+b
    return c
sum(1,2)
#op: 3

자료형

• 숫자형(int, float)
• 문자형(str)
• 참/거짓(bool)
• 리스트(list)
• 튜플(tuple)
• 딕셔너리(dict)
• 집합(set)

• 변수명 규칙
  • 대체적으로 알파벳 소문자 + 숫자(혹은 언더바 _ )
  • 숫자로 시작X
  • 언더바 외 특수문자X
  • 공백X
• 문자형(str)

#여러 줄 표현하기 (따옴표(큰 or 작은) 3개)
a="""Life is too short,
you need Python.
My life would be so long!
"""
type(a)
#op: str

#문자열 더하기
a='Python'
b=' is fun!'
a+b
#op: Python is fun!

#문자열 곱하기
a='python'
a*3
#op: pythonpythonpython

#문자열 나누기
a="Life is too short, You need Python"
split_a=a.split(' ')
print(split_a)
split_a[0]
#op: ['Life', 'is', 'too', 'short,', 'You', 'need', 'Python']
#     'Life'

• 리스트형(list)
  • 대괄호 [ ]

a=[1,2,3]
print(a[0])
print(a[0]+a[1])
print(a[0:2]) # 끝자리-1
b=a,4
print(b) #([1,2,3], 4)
print(b[0][-1]) # 출력값: 3, b[0]은 [1,2,3], 그 중 [-1]이니까 3

#op:

#리스트 더하기
a=[1,2,3]
b=['d','e','f']
a+b
#op: [1,2,3,'d','e','f']

#리스트 곱하기
a=[1,2,3]
a*3
#op: [1, 2, 3, 1, 2, 3, 1, 2, 3]

#리스트 값 변경
a=[1,2,3]
a[0]=4
a
#op: [4, 2, 3]

#리스트 요소 추가
a=[1,2,3]
a.append(4)
a
#op: [1, 2, 3, 4]

#리스트 요소 제거
a=[1,2,3]
a.remove(3)
a
#op: [1, 2]

#리스트 요소 추가
a=[1,2,3]
a.insert(1,4)	#insert(index, element)
a
#op: [1, 4, 2, 3]	# index 1 자리에 '4' 삽입

#리스트 정렬
a.sort()
a
#op: [1, 2, 3, 4]

a.sort(reverse=True)
a
#op: [4, 3, 2, 1]

#리스트 위치 반환
a=[12,45,38]
a.index(38)
#op: 2

#리스트 개수 세기
a=[10,10,20,30]
a.count(10)
#op: 2

#리스트 길이 파악
a=[1,2,3,4]
len(a) #length
#op: 4

• 튜플형(tuple)
  • 리스트형과 거의 비슷하지만 변수를 읽기 전용으로 만들 때 사용
  • 튜플 값은 삭제, 수정 불가능 (append, remove 등 사용 시 에러)
  • 괄호 ( ) 사용
• 딕셔너리형(dict)
  • 키(key): 값(value) → 사전(dictionary) 형태의 자료형
  • 리스트나 튜플과 다르게 순서 없음
  • 값을 찾을 때 매우 빠르게O
  • 모든 자료형 담을 수 있음
  • 중괄호 { }

a={'bulldog':'dog','munchikin':'cat'}

#키 검색
a.keys()
#op: dict_keys(['bulldog', 'munchikin'])

#값 검색
a['bulldog']
#op: dog

#값 추가
a['poodle']='dog'
a
#op: {'bulldog': 'dog', 'munchikin': 'cat', 'poodle': 'dog'}

#값 변경
a['bulldog']='cat'
a
#op: {'bulldog': 'cat', 'munchikin': 'cat', 'poodle': 'dog'}

#요소 삭제
del a['bulldog']
a
#op: {'munchikin': 'cat', 'poodle': 'dog'}

#모두 삭제
a.clear()
a
#op: {}

• 집합형(set)
  • 순서가 없고, 중복 허용X
  • 묶고 싶은 요소들을 { } (중괄호)로 감싸주어 사용
    • 집합명 = {요소1, 요소2, 요소3, ... }

a={1,2,3,}
type(a)
#op: set

#중복 허용X
a={1,1,2,3}
a
#op: {1,2,3}

#순서 없고 중복 허용X
b={'H','E','L','L','O'}
b
#op: {'E','H','L','O'}

#교집합 &
a={1,2,3,4}
b={4,5,6,7}
a&b
#op: {4}

#합집합 |
a={1,2,3,4}
b={4,5,6,7}
a|b
#op: {1, 2, 3, 4, 5, 6, 7}

#차집합 -
a={1,2,3,4}
b={4,5,6,7}
a-b
#op: {1, 2, 3}

#다른 자료형으로 변환
a={1,2,3,4,5}
print(type(a))
a=list(a)
print(type(a))
#op:<class 'set'>
#   <class 'list'>

연산자

• (일반적으로) 비교 연산자를 기준으로 참/거짓 판단
• 조건문 안에 있는 동작문을 순차적 실행

• 비교 연산자 : 값끼리 비교 ( >, <, >=, <=, ==(같다), !=(같지 않다) )
• 논리 연산자 : 논리 연산을 이용한 참/거짓 판정 ( and, or, not )
  • A and B : A와 B가 모두 참이다.
  • A or B : A와 B 중 적어도 하나는 참이다.
  • not A : A가 거짓일 때 참이다.
• in, not in :

a=[1,2,3]
1 in a
#op: True

b='python'
'z' in b
#op: False

조건문

• if, else문
• ex1)

"잠이 오면 커피를 마시고, 그렇지 않으면 차를 마셔라"

조건문 if : 잠이 오면     동작문A : 커피를 마시고 (True)             동작문B : 차를 마셔라 (False)

#코드를 입력
sleepy=True

if sleepy == True:
    print("drink coffee") #동작문A

else:
    print("drink tea") #동작문B
#op: drink coffee (졸린 코드를 입력했으므로. False를 입력하면 else구문(drink tea)이 출력된다.)

• elif문 (else if) : 여러 개의 조건
• ex2) "잠이 오면 커피를 마시고, 잠이 오진 않지만 화가 나면 차를 마시고, 잠도 안오고 화도 안나면 물을 마셔라"
  1. 잠O (True) → 커피
  2. 잠X / 화O (else if) → 차
  3. 잠X / 화X (False) → 물

status = ['happy', 'angry', 'sleepy']

if 'sleepy' in status:
    print("drink coffee")  #동작문A
elif 'angry' in status:
    print("drink tea")  #동작문B
else:
    print("drink water")  #동작문C

- elif는 여러 개 사용 가능

hobby = ['dance']

if 'tennis' in hobby:
    print("아침에 그걸 어떻게 해")
elif 'swim' in hobby:
    print("점심 수영이면 하루에 몇번을 샤워해")
elif 'dance' in hobby:
    print("아 배고파")
else:
    print("골프는 노잼이야")
    
#op: 아 배고파

반복문

• 조건문이 거짓(False)일 때까지 반복을 명령하는 구문
• python에서는
  • for문을 통해 변수를 받아 반복하거나
  • while문을 통해 일정 조건까지 반복O
• ex1) while문 : "잠이 오지 않을 때까지 커피를 마셔라"
  1. 시작
  2. 조건식 : 잠이 오는가?
     
     • True : print("drink coffee")
       • while : 잠이 오지 않을 때까지 반복
       • 잠이 깨는 시점 = 커피 10잔
     • False : print("not sleepy anymore")
  3. 종료

sleepy=True
awake_point=10  #잠이 깨는 시점

num_coffee=0

while sleepy==True:                 #조건1: 잠이 오면, 아래 실행
    num_coffee=num_coffee+1
    print("I have drunk {} cup(s) of coffee.".format(num_coffee))
    #.format: 중괄호 안의 변수의 값을 프린트하는 기능. 변수에 어떤 값이 들어있는지 보고 싶을 때 편리

    if num_coffee >= awake_point:   #조건2: 잠이 깨는 시점이 되면, 아래 실행
        sleepy=False
        print("I'm not sleepy anymore.")

- num_coffee에 0 입력 시 출력값 (10번 반복)

- num_coffee에 12 입력 시 (커피를 10잔 이상 마셔(awake_point) 더이상 졸리지 않을 때)

ex2) while문 : 반복문에서 중간에 빠져나오고 싶을 때? 명령어 break
"잠이 오지 않을 때까지 커피를 마시지만, 커피가 떨어지면 멈춰라"

sleepy=True
awake_point=10  #잠이 깨는 시점
max_coffee=5

num_coffee=0

while sleepy==True:                 #조건1: 잠이 오면, 아래 실행
    num_coffee=num_coffee+1
    print("I have drunk {} cup(s) of coffee.".format(num_coffee))

    if num_coffee >= awake_point:   #조건2: 잠이 깨는 시점이 되면, 아래 실행
        sleepy=False
        print("I'm not sleepy anymore.")
        
    if num_coffee >= max_coffee:    #조건3: 커피가 떨어지면, 아래 실행
        print("It's out of coffee.")
        break
        #break 실행으로 특정 조건 달성 시 반복문 중지

- num_coffee=0 → 커피 5잔 마시기를 반복하면 커피가 다 떨어진다(max_coffee=5)

• 무한 루프 : 조건식에 참을 넣으면 됨

#무한 루프
num_coffee=0

while True:
    num_coffee=num_coffee+1
    print('I have drunk {} cup(s) of coffee.'.format(num_coffee))

• for문
  • python에서 가장 직관적이고 많이 쓰는 반복문
  • 리스트나 튜플, 문자열의 첫 번째 요소부터 마지막 요소까지 차례로 변수를 받아서 동작문이 반복
  • 기본 문법
    • for 받아올 변수 in [변수1, 변수2, 변수3, ...]:
• ex1) "커피, 차, 물을 차례로 마셔라"
  1. 시작
  2. ['커피', '차', '물'] 첫 번째 요소부터 전달
     • True : print("I have drunk { }.") (동작문)
  3. 요소가 남아 있는가? 반복(for) → 다음 요소 반복 동작
  4. False : 종료

drink=['coffee', 'tea', 'water']

for item in drink:
    print("I have drunk {}.".format(item))

#output:

• 동작문 Skip 하기 : 명령어 continue

#동작문 skip 하기
drink=['coffee', 'tea', 'water']

for item in drink:
    if item=='tea':
        continue
    print("I have drunk {}.".format(item))

#output:

• range 함수 사용하기
  : range(N) → 0~N-1까지

#range 함수 사용하기
for I in range(10):
    print("I have drunk {}.".format(I))

#op:

drink=['coffee', 'tea', 'water']

for I in range(len(drink)):		#len(drink)는 3과 동일(요소가 3개이므로) 따라서 range(3)과 같다
    item=drink[I]			#drink에 인덱싱하면 item에 커피,차,물이 나옴
    print("I have drunk {}".format(item))

#op:

함수 (function)

• 입력값을 받아서 일정한 처리를 진행하고 출력값을 반환
• 반복되는 작업을 묶어서 재사용⭐
• 기본 문법
  
  • def 함수명(입력인수):
    return 출력인수

#함수 정의
def sum(a,b):
    return a+b

a=2
b=6
sum(a,b)  #op: 8

• ex) 똑같은 구문이 반복되는 아래 코드를

#똑같은 구문이 반복
drink=['coffee', 'tea', 'water']

for item in drink:
    print('I have drunk {}.'.format(item))

drink=['coke', 'soda', 'milk']

for item in drink:
    print('I have drunk {}.'.format(item))
    
''' op:
I have drunk coffee.
I have drunk tea.
I have drunk water.
I have drunk coke.
I have drunk soda.
I have drunk milk.
'''

아래와 같이 함수를 정의해서 단 두 줄의 코드로( drink_beverage( ) ) 간결하게 작성할 수 있다. (출력값은 동일)

def drink_beverage(drink):
    for item in drink:
        print("I have drunk {}.".format(item))

drink_beverage(['coffee','tea','water'])
drink_beverage(['coke','soda','milk'])

''' op:
I have drunk coffee.
I have drunk tea.
I have drunk water.
I have drunk coke.
I have drunk soda.
I have drunk milk.
'''

• 출력값 활용하기
• ex) 출력값이 하나일 경우

def drink_beverage(drink):
    for item in drink:
        print('I have drunk {}'.format(item))
    return len(drink)	#len(drink)를 출력값으로 받음

num_drink=drink_beverage(['coffee','tea','water'])
print('I drank a total of {} cups.'.format(num_drink))  #return값을 받아서 num_drink에 3이 들어간 것

''' op:
I have drunk coffee
I have drunk tea
I have drunk water
I drank a total of 3 cups.	#출력값1
'''

#출력값이 여러 개일 때
def drink_beverage(drink):
    for item in drink:
        print('I have drunk {}'.format(item))
    return len(drink), drink[-1]	#두 개의 변수, 두 개의 함수

num_drink,last_drink=drink_beverage(['coffee','tea','water'])	#리턴값이 두 개, 따라서 출력값도 두 개
print('I drank a total of {} cups.'.format(num_drink))
print('I drank {} last.'.format(last_drink))

''' op:
I have drunk coffee
I have drunk tea
I have drunk water
I drank a total of 3 cups.	#출력값1
I drank water last.		#출력값2
'''

• 다중 입력값 사용하기
• ex)

def drink_beverage(drink1, drink2, drink3):	#입력값이 3개
    drink=[drink1, drink2, drink3]
    for item in drink:
        print('I have drunk {}.'.format(item))

drink1='coffee'	#3개의 변수에 각각 요소를 할당
drink2='tea'
drink3='water'

drink_beverage(drink1, drink2, drink3)	#출력 시 각 3개의 출력값이 나옴

''' op:
I have drunk coffee.
I have drunk tea.
I have drunk water.
'''

• 함수를 쓸 땐 꼭 함수를 먼저 정의해준 뒤 코드를 실행할 것. (에러남)
• 코드는 무조건 직접 스스로 작성해보기. (언어는 문법)
• 구조를 이해하기.
• 문제 많이 풀어보기.
• 기본적인 특징은 빨리 외우기
  • 리스트 [ ], 튜플 ( ), 딕셔너리 { }, 집합 { }, 인덱스 시작0

Date : 2023-07-03

Topic :  연산자, 리스트, 튜플, 딕셔너리

Note

map을 사용할 정수로 변화하기

split 결과로 int로 매번 변환해주어야 하나?

한꺼번에 정수로 변환하기 위해서는 map을 함께 사용

map에 int와 input().split()을 넣으면 split의 결과를 한꺼번에 변환

• 5개의 숫자를 입력 받아 더하기(map과 split 사용)

#map을 사용하여 정수로 변환하기
i1,i2,i3,i4,i5=map(int,input("5개의 값입력: ").split())
print("합은 ", i1+i2+i3+i4+i5)

#output:

• 국어,영어,수학,과학 점수 입력하여 점수 평균 구하기

#평균 점수를 출력하는 프로그램(input에서 안내 문자열 출력)
#단 평균 점수 출력은 실수로 출력
국어,영어,수학,과학=map(int,input("과목 점수 입력: ").split())
print("과목 평균: ", ((국어+영어+수학+과학)/4))

#output:

가독성 좋게 다시 짜기

kor,eng,mat,sci=map(int,input("과목 점수 입력: ").split())
total=kor+eng+mat+sci
avg=total/4
print(avg)
#(값이 실수로 출력되므로 정수형으로 변환하려면 avg에 int() 사용)

나누기(/)는 자동으로 실수(float)로 출력된다!

 sep(로 값 사이에 문자 넣기)

: sep = separator

• print(값1, 값2, sep='문자 또는 문자열')
• print(변수1, 변수2, sep='문자 또는 문자열')
  • 콤마(,), 슬래쉬(/), 공백( ), 기호(+,-), 문자열(x) 등

print(1,2,3,sep=', ')
print('hello','python', sep=' ')

#output:

줄 바꾸기(개행)

역슬래쉬(\)

\n

< 실습 >

kor,eng,mat,sci=map(int,input("과목 점수 입력: ").split())
total=kor+eng+mat+sci
print(kor,eng,mat,sci, sep='+')
print('총합은',total,'입니다')

#output:

print 줄 바꾸기 금지

• print(값, end='문자 또는 문자열')
• print(변수, end='문자 또는 문자열')

*기본적으로 print의 end에 '\n'이 지정된 상태인데 빈 문자열을 지정하면 강제로 '\n'을 지워주기 때문

print('a', end='')
print('b', end='')
print('c')
print(1, end='')
print(2, end='')
print(3)

#output:

< 실습 >

year=2019
month=1
day=31
hour=10
minute=33
second=57
print(year,month,day, sep='/')
print(hour,minute,second, sep=':')

#output:

year=2019
month=1
day=31
hour=10
minute=33
second=57
print(year,month,day, sep='/', end=' ')
print(hour,minute,second, sep=':')

#output:

연산자

• 참/거짓(Boolean, 불연산자)
  : 값의 일종으로 참(True), 거짓(False) 표현

print(3>1) #True
print(3<1) #False
10==10 #True
10!=5 #True
'Python'=='python' #True
'Python'!='python' #True
10 >= 10  #True

• 논리 연산자
  • and : 모두 참일 때
  • or : 둘중 하나가 거짓
  • not : 반대로 변환

(10==10) and (10!=5) #True and True
(10>5) or (10<3) #True or False
not(10>5) #not True
not(1 is 1.0) #not False

• 연산자가 복합적으로 쓰였을 때
  : ①비교 연산자(is, is not, ==, !=, <, >, 등)를 먼저 판단하고 ②논리 연산자(and, or, not)를 판단
• 비교 연산자 + 논리 연산자

bool(1) #True
bool(0) #False
bool(1.5) #True
bool('False') #True
bool('') #False
bool(' ') #True

< 실습 >

: 국 영 수 과/ 한 과목이라도 50점 미만이면 불합격
합격이면 True, 불합격이면 False로 출력

kor=92
eng=47
math=86
sci=81
print(kor>=50 and eng>=50 and math>=50 and sci >= 50) #output: False

모두 50점 이상이어야 합격(True)인데 영어 한 과목이 과락이므로 불합격 처리가 된다. 따라서 연산자 >=, and를 사용해주면 출력값을 알 수 있다.

< 실습 >

표준 입력으로 국/영/수/과 점수 입력. 국어는 90점 이상, 영어는 80점 초과, 수학은 85점 초과, 과학은 80점 이상일 때 합격이라고 하면(한 과목이라도 조건에 만족하지 않으면 불합격), 다음 소스 코드를 완성하여 합격이면 True, 불합격이면 False가 출력되게 만들기(input에서 안내 문자열은 출력X)

kor, eng, math, sci=map(int, input().split())
print(kor>=90 and eng>80 and math>85 and sci>=80)

또는

kor, eng, math, sci=map(int, input().split())
PASS = kor>=90 and eng>80 and math>85 and sci>=80
print(PASS)
#pass는 파이썬 문법에서 사용되는 단어라서 PASS(소문자->대문자)로 할당

문자열

작은 따옴표(' ')와 큰 따옴표(" ") 구분 必

single quote = ' ' ' "안녕하세요."

'파이썬'입니다. ' ' '

double quote1 = """"Hello"

'Python' """

double quote2 = """"Hello",'python' """ #한 줄로 작성

single_quote = '''"안녕하세요."
'파이썬'입니다.'''
double_quote1 = """"Hello"
'Python' """
double_quote2 = """"Hello", 'python' """ #한 줄로 작성
print(single_quote)
print(double_quote1)
print(double_quote2)

#output:

리스트(list)

: data를 관리하기 편리하도록 묶어서 순서를 정하고 사용하는 data type

• 변수에 값을 저장할 때 [ ] (대괄호)로 묶어줌. 각 값은 ,(콤마)로 구분
• 리스트에 저장된 각 값 → 요소(element)

리스트 = [값1, 값2, 값3]

a=[38,21,53,62,19]
a
#out: [38, 21, 53, 62, 19]

• 리스트는 문자열, 정수, 실수, 불 등 모든 자료형을 저장할 수 있으며 자료형을 섞어서 저장해도 됨

person=['David', 49, 173.3, True]
person
#out: ['David', 49, 173.3, True]

• 빈 리스트 만들어 보기
  • 리스트=[]
  • 리스트=list()

a=[]
a
b=list()
b
#out: []

range : 연속된 숫자를 생성. range에 10을 지정하면 0~9 생성함.

즉, 지정한 숫자는 생성되는 숫자에 포함X, (default=0, 생략하면 0부터 생성)

리스트 = list(range(시작, 끝))

a=list(range(10))
print(a)
#out: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

a=list(range(3,12))
print(a)
#out: [3, 4, 5, 6, 7, 8, 9, 10, 11]

리스트 = list(range(시작, 끝, 증가폭))

a=list(range(-4,20, 2))
print(a)
#out: [-4, -2, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

a=list(range(10, 0, -1))
print(a)
#out: [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

튜플(tuple)

: 리스트처럼 요소를 일렬로 저장하지만, 안에 저장된 요소를 변경, 추가, 삭제가 불가능 (읽기 전용 리스트)

• 변수에 값을 저장할 때 ( ) (괄호)로 묶어주면 튜플이 되며, 값은 ,(콤마)로 구분. 또는 괄호로 묶지 않고 값만 콤마로 구분해도 튜플이 됨

a=(38,21,53,62,19)
print(a)
#out: (38, 21, 53, 62, 19)

b=38,21,53,62,19
print(b)
#out: (38, 21, 53, 62, 19)

• 저장된 요소를 변경, 추가, 삭제할 수도 없는 튜플을 만들어 놓은 이유
  1. 파이썬 프로그래밍에서 튜플 사용이 더 유리한 경우도 있음.
  2. 보통 요소가 절대 변경되지 않고 유지되어야 할 경우
  3. 요소를 실수로 변경하는 상황 방지 (튜플은 변경 시 에러 발생)

• 요소가 한 개인 튜플을 만들 때는 ( ) 안에 값 한 개를 넣고, ,(콤마)를 사용

a=(38, )
print(a)
#out: (38,)

• 형변환

b=(4,5,6)
list(b)
#out: [4, 5, 6]
#리스트를 생설할 때는 대괄호 [ ]

a=[1,2,3]
tuple(a)
#out: (1, 2, 3)
#튜플을 생설할 때는 괄호 ( )

• list와 tuple 안에 문자열을 넣으면?

list('Hello')
#out: ['H', 'e', 'l', 'l', 'o']
tuple('Hello')
#out: ('H', 'e', 'l', 'l', 'o')

• list, tuple로 변수 만들기
  : 변수의 개수와 리스트(튜플)의 요소 개수가 같아야 함

a,b,c=[1,2,3]
print(a,b,c)
#out: 1 2 3

x=[1,2,3]
a,b,c=x
print(a,b,c)
#out: 1 2 3

y=(4,5,6)
d,e,f=y
print(d,e,f)
#out: 4 5 6

• 입력 값을 변수 두 개에 저장하기 위해 사용한 input().split()은 리스트를 반환. 따라서 리스트 언패킹 형식으로 입력값을 변수 여러 개에 저장할 수 있음

x=input().split()
print(x)
a,b=x
print(a,b)
print(a+b)

#output:

< 실습 >

a=list(range(5, -10, -2))
print(a)

#output:

시퀀스 자료형 활용

• 시퀀스 자료형 4가지
  1. 리스트
  2. 튜플
  3. range
  4. 문자열

• 공통점: 연속적
• 특징: 공통 동작과 기능
• 시퀀스 객체: 시퀀스 자료형으로 만든 객체
• 요소(element): 시퀀스 객체에 들어있는 각 값

• 특정 값이 있는지 확인하기
  • 시퀀스 객체에 (not) in 연산자
  • 튜플, range, 문자열도 같은 방법으로 사용 가능

a=[0,10,20,30,40,50,60,70,80,90]
30 in a #output: True
100 in a #op: False

43 not in (38,76,43,62,19) #op: False
1 not in range(10) #op: False
'P' not in 'Hello, Python' #op: False

< 실습 >

0~20 사이 홀수 값을 요소로 가지는 리스트를 만들고 표준 입력 값을 받아들여서 그 값이 리스트에 없는지 확인

a=list(range(1, 20, 2))
inData=input('정수 값을 입력:')
print(int(inData) not in a)

#output: 

< 실습 >

['사과', '배', '귤', '오렌지']와 ['토마토', '바나나', '수박', '딸기'] 두 개의 list 중 '사과'가 있는 지 확인

1) 연결하기로 작성

2) 연결하지 않고 논리 연산자로 작성해서 결과 확인

a=['사과','배','귤','오렌지']
b=['토마토','바나나','수박','딸기']
fruit=a+b
print('사과' in fruit)
print(('사과' in a) or ('사과 in b'))
#op: True

※ 시퀀스 자료형 중 range는 + 연산자로 객체를 연결할 수 없음 (마찬가지로 * 연산자 불가능.)
→ 사용하려면 unpacking 해야함

len( ) (=length)

• 리스트와 튜플의 요소 개수 구하기

a=[0,10,20,30,40,50,60,70,80,90]
len(a)
#output: 10

• 문자열의 길이도 구할 수 있다
  • 공백까지 포함O, 따옴표는 포함X
• 인덱스
  • 각 요소는 순서가 정해져 있음
  • 시퀀스 객체에 [ ]를 붙이고 [ ] 안에 각 요소의 인덱스를 지정하면 해당 요소에 접근 가능
  • 대부분 프로그래밍 언어는 인덱스가 0부터 시작

a=[38,21,53,62,19]
print(a[0])
print(a[2])
print(a[4])

#output:
38
53
19

• range도 인덱스로 접근 가능

- 1~20까지 정수 중 홀수를 요소로 가지는 리스트를 만들고, 이중 세 번째 홀수를 찾아내어 그 값을 표시하는 표시

a=list(range(1, 20, 2))
print(a[2])
#output: 5
#a=[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

• 음수 인덱스 지정하기

- 1~100 정수 중 짝수 리스트, 마지막 세 번째 짝수를 찾아내어 표시

a=list(range(2, 101, 2))
print(a[-3])
#output: 96
#인덱스를 음수로 설정해 마지막 숫자부터 3번째를 출력

• 시퀀스 객체는 [ ]로 요소에 접근한 뒤 =로 값을 할당

시퀀스 객체[인덱스] = 값

a=[0,0,0]
a[0]=38
a[1]=52
a[2]=46
#op: [38,52,46]

• del로 시퀀스 객체의 요소를 삭제하기

del 시퀀스객체[인덱스]

a=[38,21,53,62,19]
del a[2]
a
#op: [38,21,62,19]

• 시퀀스 슬라이스: 시퀀스 객체의 일부를 잘라서 새 리스트로 만듦
  • 실제로 가져오는 요소는 시작 인덱스부터 끝 인덱스-1까지임
    ex) a[0:5] -> 0부터 4까지!
  • 중간부터 가져올 수 있음.
    ex) a[4:9] -> 4부터 8까지!

시퀀스객체[시작 인덱스:끝 인덱스]

a=[38,21,53,62,19]
a[0:3] #인덱스 0부터 2까지 잘라서 새 리스트로 작성
#output: [38,21,53]

• 인덱스 증가폭 사용하기
  • 슬라이스는 증가폭을 지정하여 범위 내 인덱스를 건너뛰며 요소를 가져올 수 있음

a=[-10,-9,-8,-7,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7,8,9,10]
print(a[10:21:2])
print(a[13:20:2])
print(a[2:19:2])
print(a[5:16:5])
#양수가 뒤쪽에 있으니 인덱스를 음수로 접근해도 됨

#output:

• 슬라이스에 요소 할당하기 : 시퀀스 객체는 슬라이스로 범위를 지정하여 여러 요소에 값을 할당할 수 있음
  • 범위를 지정해서 요소를 할당했을 경우, 원래 있던 리스트가 변경되며 새 리스트는 생성되지 않음.

시퀀스객체[시작 인덱스:끝 인덱스] = 시퀀스객체

a=[0,10,20,30,40,50,60,70,80,90]
a[2:5]=['a','b','c'] #인덱스 2부터 4까지
print(a)
#output: [0, 10, 'a', 'b', 'c', 50, 60, 70, 80, 90]

• a[2:5] = ['a', 'b', 'c']는 슬라이스 범위와 할당 리스트 요소 개수를 정확히 맞추었지만 사실 개수를 맞추지 않아도 상관없음.
  • 요소 개수를 맞추지 않아도 알아서 할당됨
  • 할당할 요소 개수가 적으면 그만큼 리스트의 요소 개수도 줄어듦⭐

a=[0,10,20,30,40,50,60,70,80,90]
a[2:5]=['a'] #인덱스 2부터 4까지 값 1개 할당
print(a)
#output: [0, 10, 'a', 50, 60, 70, 80, 90]

< 실습 >

- 최근 3년 결과 출력 (hint: '최근 3년' - 마지막 요소부터 3개를 출력하면 된다는 뜻)

year = [2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018]
population = [10249679, 10195318, 10143645, 10103233, 10022181, 9930616, 9857426, 9838892]
print(year[-3::])
print(population[-3::])
# or
print(year[5:8])
print(population[5:8])
# or
print(year[5:])
print(population[5:])

#output:

[2016, 2017, 2018]
[9930616, 9857426, 9838892]
#세 개 모두 같은 출력값

- 표준 입력으로 숫자 또는 문자열 여러 개가 입력되어 리스트 x에 저장

마지막 요소 5개를 삭제한 뒤 튜플로 출력

x=input().split()
del x[-5:]
print(tuple(x))

- 표준 입력으로 문자열 두 개가 각 줄에 입력

첫 번째 문자열에서 인덱스가 홀수인 문자와 두 번째 문자열에서 인덱스가 짝수인 문자를 연결하여 출력

• input에서 안내 문자열 출력 안해도 됨
• 연결 순서는 첫 번째 문자열, 두 번째 문자열 순
• 0은 짝수 처리

x=input()
y=input()
print(x[1::2])
print(y[::2])
z=x[1::2]+y[::2] #z=x[1:len(x):2]+y[0:len(y):2]
print(z)

12345
abcde
24
ace
24ace

딕셔너리 사용하기

• 값마다 이름을 붙여서 저장하는 방식
• 사전이라는 뜻과 같이 단어 찾듯 값을 가져올 수 있음

fruit={'apple':1000, 'banana':700, 'orange':1500, 'pineapple':2000}
print(fruit)
#output: {'apple': 1000, 'banana': 700, 'orange': 1500, 'pineapple': 2000}

x = { 키 : 값 }

• 딕셔너리를 만들 때 키 이름이 중복되면 가장 뒤에 있는 값만 적용됨
• 키는 문자열뿐만 아니라 정수, 실수, 불도 사용 가능(섞어서 가능)
• 빈 딕셔너리 (빈 리스트랑 동일!)

lux=dict(zip(['health', 'mana', 'melee', 'armor'], [490,334,550,18.72]))
print(lux)
#output: {'health': 490, 'mana': 334, 'melee': 550, 'armor': 18.72}

- 원하는 과일(키)을 입력하면 이름과 가격이 출력되는 프로그램

fruit={'apple':1000, 'banana':700, 'orange':1500, 'pineapple':2000}
sel=input("과일 이름을 입력하세요: ")
print("선택한",sel,"의 가격은",fruit[sel],"원입니다")

#output:

soon