*교재는 혼자 공부하는 SQL

A. DBMS의 정의

• 데이터베이스에는 다양한 데이터가 저장되어 있다.
• 이러한 데이터베이스를 관리하고 운영하는 소프트웨어가 DBMS(Database Mamagement System)
• 여러 명의 사용자나 응용 프로그램과 실시간으로 공유하고 동시에 접근이 가능해야 한다.
• 예금 계좌 주인, 은행 직원, 인터넷 뱅킹, ATM 기기 등에서 모두 동시에 접근이 가능해야 한다.

DBMS의 종류

MySQL, 오라클, SQL 서버, MariaDB 등

DBMS의 분류

계층형, 망형, 관계형, 객체지향형, 객체관계형

a. 계층형

• 은행업무에 아주 최적화
• 요즘은 잘 안쓴다.
• 트리 형태

b. 관계형 (RDB)

• 테이블, 열, 행
• 2차원구조 (격자구조, 모눈형식)

1. 데이터베이스 서비스명

2. 데이터베이스 계정명

3. 데이터베이스 설치 도메인과 포트

B. 데이터베이스 모델링

• 테이블의 구조를 미리 설게, 건출 설계도 그리는 과정 -
• 세상에서 사용되는 사물이나 작업을 DBMS의 데이터베이스 개체로 옮기기 위한 과정
• 폭포수 모델의 업무 분석과 시스템 설계 단계에 해당한다.
• 여기서가장 중요한 데이터베이스 개체인 테이블 구조가 결정된다.
• 물론 테이블이 나오기 위해서는 다소 복잡한 절차를 거쳐야 한다. (정규화)

• 테이블이 나오기 위해서는 다소 복잡한 절차를 거쳐야 한다. (정규화)

용어

• 데이터(data): 하나하나의 단편적인 정보
• 테이블(table): 회원이나 제품의 데이터를 입력하기 위해 표 형태로 표현한 것.
• 데이터베이스(Database): 테이블이 ㅉ저장되는 저장소. 데이터를 저장하는 곳. 
• DBMS: 데이터베이스 관리 시스템 또는 소프트웨어.  (ex.  MySQL)
• 열/컬럼/필드(column): 테이블의 세로. 각 테이블은 여러 개의 열로 구성된다.
• 열 이름: 각 열을 구분하기 위한 이름. 열 이름은 각 테이블 내에서는 서로 달라야 한다.
• 데이터 형식: 열에 저장된 데이터 형식. 숫자형, 문자형. 데이블을 생성할 때 열 이름과 함께 지정해준다. 
• 행/로우/레코드(row): 실질적인 진짜 데이터. 즉 행의 개수가 데이터의 개수다.  
• 기본 키/주키: 각 행을 구분하는 유일한 열. 중복되어서도 안 되고, 비어 있어서도 안 된다.
• SQL: DBMS가 알아듣는, 구조화된 질의 언어

데이터베이스 구축 절차

데이터베이스 만들기 → 테이블 만들기 → 데이터 입력/수정/삭제하기 → 데이터 조회 →활용하기

CRUD

• 테이블은 2차원의 표 형태로 이루어져 있으며, 각 열에 해당하는 데이터를 한 행씩 입력(C)할 수 있다.
• 필요하다면 행에 입력된 데이터를 수정(U)하거나 삭제(D)할 수 있다. 
• 마지막으로 입력이 완료된 데이터를 조회(R)에서 활용할 수 있다.

DB 만들기

Table 만들기

데이터 입력하기

데이터 입력

INSERT INTO 'shop_db'.'member' ('member_id', 'member_name', 'member_addr') VALUES('carry', '머라이어', '미국 텍사스 사막');

데이터 수정

UPDATE 'shop_db'.'member' SET 'member_addr' = '영국 런던 먹자골목' WHERE ('member_id' = 'carry');

데이터 삭제

DELETE FROM 'shop_db'.'member' WHERE ('member_id' = 'carry');

데이터 활용

SELECT 열_이름 FROM 테이블_이름 [WHERE 조건]

SELECT  member_name, member_addr FROM member;

SELECT  * FROM member WHERE member_name ='아이유';

데이터베이스 개체

• 인덱스, 뷰, 스토어드 프로시저, 트리거, 함수, 커서 등의 개체는 모두 테이블과 연관이 있다.

인덱스

• CREATE INDEX idx_member_name ON member(member_name);
• 찾아보기 시간을 단축한다.

뷰

create view member_view
as 
select * from member;

• 실제 데이터를 가지고 있지 않고, 진짜 테이블에 링크된 개념
• 보안에 도움이 된다.
• 긴 SQL문을 간략하게 만들 수 있다.

스토어드 프로시저

DELIMITER //
CREATE PROCEDURE myProc()
BEGIN
SELECT * FROM member WHERE member_name = '나훈아';
SELECT * FROM product  WHERE product_name = '삼각김밥' ;
END//
DELIMITER ;

CALL myProc();

A. 함수의 정의와 호출

함수는 한마디로 호출의 집합이다.

def 함수 이름():
    문장

def print_n_times(value, n):
    for i in range(n):
        print(value)
        
print_n_times("안녕하세요", 5)

안녕하세요
안녕하세요
안녕하세요
안녕하세요
안녕하세요

가변 매개변수

• 매개변수를 원하는 만큼 입력할 수 있는 함수 (매개변수의 개수가 변할 수 있다.)
• 가변 매개변수 뒤에는 일반 매개변수가 올 수 없다.
• 가변 매개변수는 하나만 사용할 수 있다.

def print_n_times(n, *values):
    #n번 반복합니다.
    for i in range(n):
        #values는 리스트처럼 활용합니다.
        for value in values:
            print(value)
            print()
            
print_n_times(2, "안녕하세요", "뚱쌤", "배고파요")

안녕하세요

뚱쌤

배고파요

안녕하세요

뚱쌤

배고파요

기본 매개변수

• 일반 매개변수(n), 기본 매개변수(n=2)
• 기본 매개변수 뒤에는 일반 매개변수가 올 수 없다.

def print_n_times(value, n=2):
    for i in range(n):
        print(value)
        
print_n_times("안녕하세요", 3)

안녕하세요

안녕하세요

안녕하세요

가변 매개변수가 기본 매개변수보다 앞에 오면, 어디까지가 values에 해당하는지 알 수가 없다.

def print_n_times(*values, n=2):
    for i in range(n):
        for value in values:
            print(value)
        print()        
print_n_times("오늘", "점심은", "마라탕", 3)

오늘
점심은
마라탕
3

오늘
점심은
마라탕
3

키워드 매개변수

• 이러한 문제를 해결하기 위해 등장
• 매개변수 이름을 직접적으로 지정해서 값을 입력한다.
• ex. end=""

def print_n_times(*values, n=2):
    for i in range(n):
        for value in values:
            print(value)
        print()        
print_n_times("오늘", "점심은", "마라탕", n=3)

기본 매개변수 중에서 필요한 값만 입력하기

def test(a, b=10, c=100): #함수헤더
    print(a+b+c) #함수 바디

#기본형태
test(10, 20, 30)
#키워드 매개변수로 모든 매개변수를 지정한 상태
test(a=10, b=100, c=200)
# 키워드 매개변수로 모든 매개변수를 마구잡이로 지정한 형태
test(c=10, a=100, b=200)
# 키워드 매개변수로 일부 매개변수만 지정한 형태
test(10, c=200)

60
310
310
220

리턴 return

def 함수 이름():   #함수 헤더
    문장                 #함수 바디

• 함수를 호출한 부분에 함수 바디에서 작업한 부분을 반환하는 장치
• 함수의 바디 부분에 [ return + 식 ]을 써주면 바디에서 수행된 결과를 호출한 곳으로 반환시킨다.

def return_test():
    print("A 위치입니다.")
    return
    print("B 위치입니다.")

print(return_test())

A 위치입니다.
None

• return이 시행되면 호출한 곳으로 돌아간다.
• 따라서 5번 문장은 시행되지 않는다. 이것을 사문이라고 한다. (필요없는 사족 문장)

자료와 함께 리턴하기

def return_test():
    return 100       #얘도 식이다. 상수 100.

value = return_test()
print(value)

100

def return_test():
    return 100+100

value = return_test()
print(value)

200

def return_test(num1, num2):
    return num1 + 100

value = return_test(10, 20)
print(value)

• return num1 + 100이 수행됐을 때
• 호출한 지점인 return_test(10, 20)에 return 식의 결과가 호출되고
• value에 이 결과가 할당되는 메커니즘!

아무것도 리턴하지 않기

def return_test():
    return 

value = return_test()
print(value)

None

• None은 없다는 뜻!

기본적인 함수의 활용

def 함수(매개변수):   
      변수=초깃값   
       # 여러가지 처리   
       # 여러가지 처리   
       # 여러가지 처리   
       return 변수

def sum_all(start, end):
    output = 0
    for i in range(start, end+1):
        output += i
    return output
    
print("0 to 100:", sum_all(0, 100))
print("0 to 1000:", sum_all(0, 1000))
print("50 to 100:", sum_all(50, 100))
print("500 to 1000:", sum_all(500, 1000))

0 to 100: 5050
0 to 1000: 500500
50 to 100: 3825
500 to 1000: 375750

기본 매개변수 사용하기

def sum_all(start=0, end=100, step=1):
    output = 0
    for i in range(start, end+1, step):
        output += i
    return output
    
print("A:", sum_all(0, 100, 10))
print("B:", sum_all(end=100))
print("C:", sum_all(end=100, step=2))

A: 550
B: 5050
C: 2550

B. 함수의 활용

재귀함수

팩토리얼 구하기

• n! = n * (n-1) * (n-2) * ... * 1
• 반복문으로 구하기

def factorial(n):
    output = 1
    for i in range(1, n+1):
        output *= i
    return output

print("1!:", factorial(1))
print("2!:", factorial(2))
print("3!:", factorial(3))
print("4!:", factorial(4))
print("5!:", factorial(5))

1!: 1
2!: 2
3!: 6
4!: 24
5!: 120

• 재귀함수로 구하기

def factorial(n):
    if n==0:
        return 1
    else:
        return n * factorial(n-1) #함수호출

print("1!:", factorial(1))
print("2!:", factorial(2))
print("3!:", factorial(3))
print("4!:", factorial(4))
print("5!:", factorial(5))

1!: 1
2!: 2
3!: 6
4!: 24
5!: 120

• n=2일 때, return식에서는
  • 2 * factorial(2-1)
  • = 2 * factorial(1)
  • = 2 * 1
• 따라서 2가 반환된다.

조기 리턴

• return은 원래 함수 흐름의 끝에 써줘야 한다는 암묵적 룰이 있었는데
• 요즘은 필요할 때 사용하면 된다는 주의. 옳고 그름은 없고 융통성 있게!
• 이렇게 흐름중간에 return 키워드를 사용하는 것을 조기 리턴이라고 한다.

리스트 평탄화

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

p.310

가독성은 프로그래밍에 굉장히 중요한 요소다.

주석을 잘 사용하는 사람이 프로그래밍을 잘하는 사람이다.

C. 함수 고급

튜플

(데이터, 데이터, 데이터, ...)

#튜플 선언
tuple_test = (10, 20, 30)

print(tuple_test[0]) #10
print(tuple_test[1]) #20
print(tuple_test[2]) #30

tuple_test[0] = 1 #오류!!

• 튜플은 내부 요소 변경이 불가능하기 때문에 오류 발생

#괄호가 없는 튜플
tuple_test = 10, 20, 30, 40
print("tuple_test:", tuple_test)
print("type(tuple_test):", type(tuple_test))
print()

#괄호가 없는 튜플 활용
a, b, c = 10, 20, 30
print("a:", a)
print("b:", b)
print("c:", c)

tuple_test: (10, 20, 30, 40)
type(tuple_test): <class 'tuple'>

a: 10
b: 20
c: 30

튜플 할당

https://ko.from-locals.com/python-multi-variables-values/

# a, b = 100, 200, 300
# ValueError: too many values to unpack (expected 2)

# a, b, c = 100, 200
# ValueError: not enough values to unpack (expected 3, got 2)

a, *b = 100, 200, 300

print(a) # 100
print(type(a)) # <class 'int'>

print(b) # [200, 300]
print(type(b)) # <class 'list'>

• 리스트로 저장이 가능하다.

*a, b = 100, 200, 300

print(a) # [100, 200] 
print(type(a)) # <class 'list'>

print(b) # 300
print(type(b)) # <class 'int'>

튜플 값 맞바꿈

a, b = 10, 20

print("# 교환 전 값")
print("a:", a)
print("b:", b)
print()

a, b, = b, a

print("# 교환 후 값")
print("a:", a)
print("b:", b)
print()

# 교환 전 값
a: 10
b: 20

# 교환 후 값
a: 20
b: 10

튜플과 함수

#함수 선언
def test():
    return (10, 20)

a, b = test()

print("a:", a)
print("b:", b)

a: 10
b: 20

#함수 선언
def test():
    return (10, 20)

a, b = test()

print("a:", a)
print(type(a))
print("b:", b)
print(type(b))

a: 10
<class 'int'>
b: 20
<class 'int'>

#함수 선언
def test():
    return (10, 20)

num = test()
print(type(num))

print("a:", num[0])
print("b:", num[1])

<class 'tuple'>
a: 10
b: 20

• num = test() 이 문장은 
• num = (10, 20) 과 같다.

함수의 매개변수로 함수 전달하기

# 매개변수로 받은 함수를 10번 호출하는 함수
def call_10_times(func):
    print(type(func))
    for i in range(3):
        func()
        
# 간단한 출력하는 함수
def print_hello():
    print("안녕하세요")
    
# 조합하기
call_10_times(print_hello)

print(type(print_hello))

• func 함수는 정의되지 않았다. 
• print_hello 함수를 인수로 사용했더니
• 매개변수에 선언한 func가 이 형식을 할당받았다.
• func = print_hello
• 이걸 오버라이드라고 한다!

안녕하세요
안녕하세요
안녕하세요

<class 'function'>

filter() 함수와 map() 함수

함수를 매개변수로 사용하는 대표적인 표준 함수

map(함수, 리스트)
filter(함수, 리스트)

def power(item):
    return item * item
def under_3(item):
    return item < 3

list_input_a = [1, 2, 3, 4, 5]

output_a = map(power, list_input_a)
print("# map() 함수의 실행결과")
print("map(power, list_input_a):", output_a)
print("map(power, list_input_a):", list(output_a))

output_b = filter(under_3, list_input_a)
print("# filter() 함수의 실행결과")
print("filter(power, list_input_a):", output_b)
print("filter(power, list_input_a):", list(output_b))

# map() 함수의 실행결과
map(power, list_input_a): <map object at 0x0000028F61ECAB00>      
map(power, list_input_a): [1, 4, 9, 16, 25]
# filter() 함수의 실행결과
filter(power, list_input_a): <filter object at 0x0000028F61ECAC80>
filter(power, list_input_a): [1, 2]

• 3이상이면 False, 3미만이면 Flase
• 결과로 나오는 <map object>와 <filter object>는 제너레이터다. 

람다

• lambda 매개변수: 리턴값

#일반 함수 사용
def power(item):
    return item * item
def under_3(item):
    return item < 3

#람다 함수 정의할 때 사용
power = lambda x: x * x
under_3 = lambda x: x < 3

#람다 함수 호출할 때 사용
output_a = map(lambda x: x*x)
output_b = filter(lambda x: x<3, list_input_a)

파일 열고 닫기

open() 함수

• 파일 열기
• 파일 객체 = open(문자열: 파일 경로, 문자열: 읽기 모드)
• 첫 번째 인수에는 파일 경로 입력, 두 번째 인수에는 모드를 지정

* write모드: 존재하지 않는 파일을 새로 만들 때

* append모드: 존재하는 파일에 add on할 떄

close() 함수

• 파일을 닫을 때 

file = open("basic.txt", "w")

file.write("baedalsikyo")

file.close()

with 키워드

• 파일을 열고 닫지 않는 실수를 방지하기 위해 사용
• with 구문이 종료될 때 자동으로 파일이 닫힌다.

텍스트 읽기

read() 함수

with open("basic.txt", "r") as file:
    contents = file.read()
print(contents)

랜덤으로 1000명 키와 몸무게 만들기

# 랜덤한 숫자를 만들기 위해 가져온다.
import random

#간단한 한글 리스트를 만든다.
hanguls = list("가나다라마바사아자차카타파하")

#파일을 쓰기 모드로 연다.
with open("info.txt", "w") as file:
    for i in range(1000):
        #랜덥한 값으로 변수를 생성한다.
        name = random.choice(hanguls) + random.choice(hanguls)
        weight = random.randrange(40, 100)
        height = random.randrange(140, 200)
        #텍스트를 쓴다. 
        file.write("{}, {}, {}\n".format(name, weight, height))

A. 딕셔너리

• 리스트가 '인덱스'를 기반으로 값을 저장하는 것이라면, 
• 딕셔너리는 '키(Key)'를 기반으로 값을 저장하는 것이다.
• 대괄호[ ]를 입력하고 내부에 인덱스처럼 키를 입력한다.

• 참조할 때 리스트와 딕셔너리 차이

• 모든 연속형 자료형의 중추는 리스트, 딕셔너리는 편집 가능한 리스트다.

in 키워드

딕셔너리 내부에 키가 있는지 없는지 확인한다. 

dictionary = {
    "name": "야채", 
    "age": 24, 
    "character": "활달함", 
    "nation": "한국"
}

#입력
key = input("접근하려는 키: ")

if key in dictionary:
    print(dictionary[key])
else:
    print("존재하지 않는 키에 접근하고 있다.")

접근하려는 키: 야채

>> 존재하지 않는 키에 접근하고 있다.

get() 함수

dictionary = {
    "name": "야채", 
    "age": 24, 
    "character": ["활달함", "호기심 많음"],
    "nation": "한국"
}

#입력
value = dictionary.get("name")
print("값:", value)
value2 = dictionary.get("health age")
print("값:", value2)

#None 확인 방법
if value or value2 == None:
    print("존재하지 않는 키에 접근했었습니다.")

값: 야채
값: None
존재하지 않는 키에 접근했었습니다.

값 추가 / 제거

• dictionary['새로운 키"] = 새로운 값
• del dictionary["이름"]

B. 딕셔너리 실습 오답노트

1. 자릿수를 구하는 방법

numbers = [123, 45, 63, 234, 352,123]

#My Answer
for number in numbers:
    if 100<= number<1000:
        print("{}는 3자릿수입니다.".format(number))
    elif 10<=number< 100:
        print("{}는 2자릿수입니다.".format(number))
    elif 0<number< 10:
        print("{}는 1자릿수입니다.".format(number))
    else:
        pass
        
 #Teacher's
for number in numbers:
    print("{}는 {}자릿수입니다.".format(number, len(str(number))))

2. 짝수 번째 요소를 제곱

#My Answer
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]

for i in range(0, len(numbers) // 2):
#My Answer : j = i+(i+1)
    #Teacher's
    j = i * 2 + 1
    print(f"i = {i}, j={j}")
    numbers[j] = numbers[j] **2
    
print(numbers)

C. 반복문

range() 범위

1. 숫자를 한 개 넣는 방법

• range(n)
• 0부터 n-1까지의 정수로 범위

2. 숫자를 두 개 넣는 방법

• range(n1, n2)
• n1부터 n2-1까지의 정수로 범위

3. 숫자를 두 개 넣는 방법 

• range(n1, n2 , n3)
• n1부터 n2-1까지의 정수로 범위를 만드는데, 간격이 n3

for i in range(4, 0-1, -1): #4부터, 마지막까지, -1에서 증감한 값 0
    print("현재 반복 변수: {}".format(i))

reversed() 

• 함수와 반복문을 조합할 때는 함수의 결과를 여러 번 사용하지 않고 for 구문 내부에 reversed() 함수를 곧바로 넣어서 사용한다.

for i in reversed(range(5)):
    print("현재 반복 변수: {}".format(i))

현재 반복 변수: 4
현재 반복 변수: 3
현재 반복 변수: 2
현재 반복 변수: 1
현재 반복 변수: 0

enumerate()

• 함수와 반복문 조합하기
• for와 in 사이에 반복 변수를 두개 넣어서
• index와 value를 각각 가져올 수 있다.

exapme_list = ["요소A", "요소B", "요소C"]

print("# enumerate() 함수 적용")
print(enumerate(exapme_list))
print()

print("# list() 함수로 강제 변환 출력")
print(list(enumerate(exapme_list)))
print()

print("# 반복문과 조합하기")
for i, value in enumerate(exapme_list): #반복설계구문
    print("{}번째 요소는 {}입니다.".format(i, value))

# enumerate() 함수 적용
<enumerate object at 0x000002569F183880>

# list() 함수로 강제 변환 출력
[(0, '요소A'), (1, '요소B'), (2, '요소C')]

# 반복문과 조합하기
0번째 요소는 요소A입니다.
1번째 요소는 요소B입니다.
2번째 요소는 요소C입니다.

튜플

• (0, '요소A') 같은 것들
• 수정 불가능한 리스트
• 같은 요소여도 메모리가 적다.

itmes()

example_dictionary = {
    "키A": "값A", 
    "키B": "값B",
    "키C": "값C",
}

print("#딕셔너리의 items() 함수")
print("items():", example_dictionary.items())
print()

print("#딕셔너리의 items() 함수와 반복문 조합하기")

for key, element in example_dictionary.items():
    print("dictionary[{}] = {}".format(key, element))

#딕셔너리의 items() 함수
items(): dict_items([('키A', '값A'), ('키B', '값B'), ('키C', '값C')])

#딕셔너리의 items() 함수와 반복문 조합하기
dictionary[키A] = 값A
dictionary[키B] = 값B
dictionary[키C] = 값C

리스트 내포

• 리스트 이름= [표현식 for 반복자 in 반복할 수 있는 것]
• 리스트 이름 = [ 표현식 for  반복자 in 반복할 수 있는 것 if 조건문]

array = [i * i for i in range(0, 20, 2)]

print(array)

[0, 4, 16, 36, 64, 100, 144, 196, 256, 324]

array = ["사과", "자두", "초콜릿", "바나나", "체리"]
output = [fruit for fruit in array if fruit != "초콜릿"]

print(output)

['사과', '자두', '바나나', '체리']

이터레이터

• 이터러블: 반복할 수 있는 것
• 이터레이터: next() 함수를 적용해 하나하나 꺼낼 수 있는 요소
• 필요한 요소만 꺼내 쓰기 때문에 메모리의 효율성을 높인다.

for 반복자 in 반복할 수 있는 것

• reversed() 함수의 리턴값이 이터레이터

numbers = [1, 2, 3, 4, 5, 6]
r_num = reversed(numbers)

print("reversed_numbers:", r_num)
print(next(r_num))
print(next(r_num))
print(next(r_num))
print(next(r_num))
print(next(r_num))

6
5
4
3
2

기타

min(): 리스트 내부에서 최솟값을 찾는다.

max(): 리스트 내부에서 최댓값을 찾는다.

sum(): 리스트 내부에서 값을 모두 더한다.

* 새롭게 배운 내용만 적었습니다. 교재는 '혼자 공부하는 파이썬

A. If 조건문

끝자리로 짝수와 홀수 구분

number = input("정수 입력> ")

last_character = number[-1]

last_number = int(last_character)

if last_number == 0 \
    or last_number == 2 \
    or last_number == 4 \
    or last_number == 6 \
    or last_number == 8:
    print("짝수입니다")
    
if last_number == 1 \
    or last_number == 3 \
    or last_number == 5 \
    or last_number == 7 \
    or last_number == 9:
    print("홀수입니다")

If문에서 코드가 너무 길면, \를 쓰고 다음 줄에 쓰면 된다!

위 코드를 더 단축시키면

num = int(input("정수를 입력해주세요: "))

if not(num % 2):
    print("{}은 2로 나누어 떨어지는 숫자입니다.".format(num))
else:
    print("{}은 2로 나누어 떨어지는 숫자가 아닙니다.".format(num))

Fals로 전환되는 값은 None, 숫자 0과 0.0, 빈 컨테이너(빈 문자열, 빈 바이트열, 빈 리스트, 빈 튜플, 빈 딕셔너리 등)이다. 

이 외에는 모두 True로 변환된다!

pass 키워드

아직 구현이 안된 종속문 대신 사용해준다.

B. 리스트

리스트

• 대괄호[ ] 내부에 여러 종류의 자료를 넣어 선언한다.

array = [123, 45, "문자열", True]

• 내부에 들어가는 자료를 요소·원소(element)라고 한다.
• 접근 연산자를 이중으로 사용할 수 있다. 

list_a = [123, 45, "문자열", True, False]
print(list_a[3]) #True
print(list_a[2][0])#문

요소 추가 (단일)

append() : 리스트 뒤에 요소 추가

insert() : 리스트 중간에 요소 추가

list_a = [1, 2, 3]

print("#리스트 뒤에 요소 추가하기")
list_a.append(4)
list_a.append(5)
print(list_a) #[1, 2, 3, 4, 5]
print()

print("#리스트 중간에 요소 추가하기")
list_a.insert(0, 10)
print(list_a) #[10, 1, 2, 3, 4, 5]

요소 추가 (복수)

extend(): 리스트 뒤에 새로운 리스트 요소 모두 추가 (파괴적 처리)

list_a = [1, 2, 3]
list_b = [4, 5, 6]

print(list_a + list_b) #[1, 2, 3, 4, 5, 6]
print(list_a) #[1, 2, 3]

list_a.extend(list_b) 
print(list_a) #[1, 2, 3, 4, 5, 6]

요소 삭제 

• 인덱스로 제거: del, pop()
• 값으로 제거: remove()
• 모두 제거: clear()

list_a = [0, 1, 2, 3, 4, 5]
print("#리스트의 요소 하나 제거하기")

# 인덱스로 제거
del list_a[1]
print(list_a) # [0, 2, 3, 4, 5]

list_a.pop(2)
print(list_a) # [0, 2, 4, 5]

# 값으로 제거
list_b = [1, 2, 1, 2]
list_b.remove(2)
print(list_b) # [1, 1, 2]

#모두 제거
list_c = [0, 1, 2, 3, 4, 5]
list_c.clear()
print(list_c) # [ ]

sort():  리스트 정렬하기 

• 기본 오름차순 정렬
• 내림차순 정렬 sort(reverse=True)

list_a = [24, 593, 5,103, 60, 920]
list_a.sort()
print(list_a) # [5, 24, 60, 103, 593, 920]

list_a.sort(reverse=True)
print(list_a) # [920, 593, 103, 60, 24, 5]

의문점) 파괴적 함수는 print() 안에서 출력되지 않는데?

list_b = [1, 2, 1, 2]
print(list_c.remove(2)) #None​

중첩된 함수는 내부에서부터 외부로 풀어나간다.
list_c.remove(2)는 list를 지우고 난 결과가 아니라 '지웠음' 그 자체이기 때문에, 반환값이 None이다.
일반적으로 None은 '성공했다'는 의미다. 

* 새롭게 배운 내용만 적었습니다. 교재는 '혼자 공부하는 파이썬'

A. 변수

변수: 값을 지정할 때 사용하는 식별자

• 명시적 변수 선언방식: C, JAVA
• 묵시적(할당형) 변수 선언방식: python

변수 참조: 변수 안에 있는 값을 사용하는 것

• 읽기 참조: 값을 출력    #print(참조)
• 쓰기 참조: 값을 할당    #변수 = 값

복합대입 연산자: 사칙연산자 + 할당

매개변수(parameter)와 인자·인수(argument)의 차이
- 매개변수: 함수의 정의

function(x, y): #x, y가 매개변수
	ruturn x + y

- 인자(인수): 함수의 호출

a = function(2, 3) #2, 3이 인수!​

B. 함수

python 내장함수

https://docs.python.org/ko/3.9/library/functions.html?highlight=format

Input()

• 입력 자료형 

type()

• 함수를 통해 입력한 자료형을 알아볼 수 있다.

format()

• 숫자를 문자열로 변환한다.

string_a = "{}".format(10)

print(string_a)
print(type(string_a))

• 다양한 기능이 있다.

#정수
output_a = "{:d}".format(52)

#특정 칸에 출력하기
output_b = "{:5d}".format(52)
output_c = "{:10d}".format(52)

#빈칸을 0으로 채우기
output_d = "{:5d}".format(52)
output_e = "{:5d}".format(-52)

print("#기본\n", output_a)
print("#특정 칸에 출력하기\n", output_b, "\n", output_c)
print("#빈칸을 0으로 채우기\n", output_d, "\n", output_e)

#정수
output_f = "{:+ d}".format(52)
output_g = "{:+ d}".format(-52)
output_h = "{:5d}".format(52) #5칸 안에 채워넣어
output_i = "{:+5d}".format(-52)
output_j = "{:=+5d}".format(52)
output_k = "{:=+5d}".format(-52)
output_l = "{:+05d}".format(52)
output_m = "{:+05d}".format(-52)

print("#조합하기")
print(output_h)
print(output_i)
print(output_j)
print(output_k)
print(output_l)
print(output_m)

#부동소수점
output_n = "{:f}".format(52.273)
output_o = "{:5.3f}".format(52.273)

print(output_n)
print(output_o)

52.273000

52.273

문자열 함수

비파괴적 함수

• 원본은 변하지 않는 함수
• upper(): 알파벳 대문자변경
• lower(): 알파벳 소문자변경 

string = "hello"

string.upper()
print("A 지점:", string)

print("B 지점:", string.lower())

A 지점: hello

B 지점: hello

strip(): 문자열 양옆 공백 제거

• lstrip(): 왼쪽 공백 제거
• rstrip(): 오른쪽 공백 제거 

islnum(): 문자열이 알파벳 또는 숫자로만 구성되어있는지 확인

isalpha(): 문자열이 알파벳으로만 구성되어있는지 확인

isidentifier(): 문자열이 식별자로 사용할 수 있는 것인지 확인

isdecimal(): 문자열이 정수 형태인지 확인

isdigit(): 문자열이 숫자로 인식될 수 있는지 확인

isspace(): 문자열이 공백으로만 구성되어 있는지 확인

islower(): 문자열이 소문자로만 구성되어 있는지 확인

isupper(): 문자열이 대문자로만 구성되어 있는지 확인

출력은 True of False!

find(): 왼쪽부터 찾아서 처음 등장하는 위치를 찾는다.

rfind(): 오른쪽부터 찾아서 처음 등장하는 위치를 찾는다.

in 연산자: 문자열 내부에 어떤 문자열이 있는지 확인

print("안녕" in "안녕하세요")

결과: True

split(): 문자열 자르기. 문자열 안의 글자를 인수 기준으로 잘라서 리스트로 만든다.

a = "10 20 30 40 50".split(" ")
print(a)

결과: ['10', '20', '30', '40', '50']

C. 연산자

not 연산자: 단항 연산자, 참과 거짓을 바꿀 때 사용

print(not True)

결과: False

and 연산자

or 연산자

종속문장: 조건식의 연산결과가 참일 때  수행하는 문장

datetime 모듈

import datetime

now = datetime.datetime.now()

print("{}년 {}월 {}일 {}시 {}분 {}초".format(
    now.year, 
    now.month, 
    now.day,
    now.hour,
    now.minute,
    now.second
))

1 월
3 일
17 시
5 분
16 초

A. 파이썬 시작하기

프로그램 

- Pro + Gram

- 미리 작성된 것을 의미한다. 

컴퓨터 프로그램

- 컴퓨터가 무엇을 해야 할지 미리 작성한 진행 계획이다.

프로그래밍 언어

- 컴퓨터는 0과 1로 이루어진 이진 숫자만 이해한다. 

- 이런 숫자로 이루어진 코드를 이진 코드라고 한다. 

- 사람이 이해하기 쉬운 언어로 프로그램을 만들기 위해 프로그래밍 언어를 만들었다.

*컴파일러 방식: 소스코드 한번에, 인터프리터 방식: 소스코드 한줄씩

Python 장단점

1. 쉽다
2. 다양한 분야에서 사용 : 웹 서버, 해킹 도구, IoT, 인공지능
3. 대부분의 운영체제에서 동일하게 사용

• 그러나 느리다.

B.  PowerShell

폴더에 Shift + 우클릭

python 파일명.py

처음에 안돼서 찾아보니까 파일 이름에 확장명이 없었다.
ls : 폴더에 어떤 파일이 있는지 목록으로 확인

C. 파이썬 용어

- 문장: 실행할 수 있는 코드의 최소 단위다.

-표현식: 어떠한 값을 만들어 내는 간단한 코드다.

-키워드: (=예약어) 변수명·함수명·클래스명으로 쓸 수 없다.

['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 
'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 
'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 
'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

-식별자: 이름을 붙일 때, 주로 변수 또는 함수 이름 등으로 사용한다.

• 키워드 사용 불가
• 특수 문자는 언더바(_)만 허용
• 숫자로 시작 불가
• 공백 불가

• 스네이크 케이스(snake_case) : 함수(), 변수
• 캐멀 케이스 (CamelCase): 클래스

-출력: print()

• 인수: 괄호 안에 있는 것
  • 인수가 여러개인 출력도 가능 (2024, "year", "입니다")
• 줄바꿈: 괄호 안에 인수가 없을 때 그냥 줄바꿈됨!

D. 자료형

문자열 (String)

• 큰따옴표나 작은따옴표나 상관없다.
• 문자열 내부에 따옴표를 사용할 경우, 작은따옴표를 사용해야한다.
• 혹은 이스케이프 문자를 사용한다.

print(""안녕하세요"라고 말했습니다") #오류
print("'안녕하세요'라고 말했습니다") #가능
print("\"안녕하세요\"라고 말했습니다") #가능

더보기

> 이스케이프 문자

print("GURUM\t3\tGANGSEO")
print("GURUM1\t3\tGANGSEO")
print("GURUM12\t3\tGANGSEO")
print("GURUM123\t3\tGANGSEO")

print("""자동으로
줄바꿈됨""")

 

[인덱싱]

print("안녕하세요"[0]) #안
print("안녕하세요"[-1]) #요
print("안녕하세요"[-5]) #안

[슬라:이싱]

print("안녕하세요"[0:2]) #안녕
print("안녕하세요"[1:4]) #녕하세

숫자형

정수 나누기 연산자 //

print("3//2= ", 3//2) #3//2= 1

print("2**2= ", 2**2) #2**2= 4

데이터 분류

mutable: 변경 가능한 데이터 (variable)

• 동시성 제어가 안됨. 
• 2002년 한게임 포커 돈복사 버그 사태
• 그래서 메소드를 통해 제어한다. (접근자 메소드)

immutable: 변경 불가능한 데이터 (constant + literal)

*literal: 우리가 직접 작성한 값

• 동시에 작업이 가능.

scala data: 1개의 데이터. 참조 자체가 데이터 (value type)

vector data: 0개 이상의 데이터 모임. 참조가 데이터의 시작 위치를 의미하며 index나 key를 이용해서 접근 (reference type)

정형 데이터: 모양이 동일한 데이터, 테이블 형태의 데잍

비정형 데이터: 모양이 일정하지 않은 데이터 (ex.텍스트나 음성)

반정형 데이터: 대부분의 경우 텍스트인데 메타 데이터를 확인하면 정형 데이터로 변경 가능한 데이터 (ex. csv, json, txt, xml, yaml)