62일차 시작....

📌 Python 출력 서식

• format() 함수

print(format(123.45678, '10.3f'))
# 출력 : 123.456
print(format(123.45678, '10.3'))
# 출력 : 1.23e+2
print(format(123, '10d'))
# 출력 : 123
print('{0:.3f}'.format(1.0/3))
# 출력 : 0.333
print('{0:_^10}'.format('hello'))
# 출력 : __hello___
print('{name} wrote {book}'.format(name='Swaroop', book='A Byte of Python'))
# 출력 : Swaroop wrote A Byte of Python

print('이름: {0}, 가격: {1}'.format('aa', 10000))
# 출력 : 이름: aa, 가격: 10000
print('이름: {1}, 가격: {0}'.format('aa', 10000))
# 출력 : 이름: 10000, 가격: aa
print('이름: {0}, 가격: {1}, 가격: {1}'.format('aa', 10000))
# 출력 : 이름: aa, 가격: 10000, 가격: 10000

• % 참조

print('나는 나이가 %d 이다.'%23)
# 출력 : 나는 나이가 23 이다.
print('나는 나이가 %s 이다.'%'스물셋')
# 출력 : 나는 나이가 스물셋 이다.
print('나는 나이가 %d 이고 이름은 %s이다.'%(23, '홍길동'))
# 출력 : 나는 나이가 23 이고 이름은 홍길동이다.
print('나는 나이가 %s 이고 이름은 %s이다.'%(23, '홍길동'))
# 출력 : 나는 나이가 23 이고 이름은 홍길동이다.
print('나는 키가 %f이고, 에너지가 %d%%.'%(177.7, 100))
# 출력 : 나는 키가 177.700000이고, 에너지가 100%.

• end 속성

# end 속성으로 개행하지 않을 수 있음
print('a1', end=" ")
print('a2')
# 출력 : a1 a2

---

📌 Python Row String

• Row String
  - 문자열 내부의 문자들을 문자로써 인식하기 위해 사용한다.

# Row String을 선행하면 이스케이프 기능 해제
print('aa\tbb')
# 출력 : aa	bb
print(r'aa\tbb')
# 출력 : aa\tbb
print(r"c:\aa\a1\a2.txt")
# 출력 : c:\aa\a1\a2.txt

---

📌 Python 문자열 str

• 문자열 함수
  - type(str) : 타입 확인
  - len(str) : 길이 확인
  - str.find('문자') : 처음 나오는 문자의 인덱스를 찾는 함수
  - str.find('문자', 시작인덱스) : 시작 인덱스부터 시작하여 특정 문자의 인덱스를 찾는 함수
  - str.rfind('문자') : 문자열 뒤에서부터 시작하여 특정 문자의 인덱스를 찾는 함수

s = 'sequence'
print(s, type(s), len(s))
# 출력 : sequence <class 'str'> 8
print(s.count('e'))
# 출력 : 3
print(s.find('e'))
# 출력 : 1
print(s.find('e', 3))
# 출력 : 4
print(s.rfind('e'))
# 출력 : 7

• 문자열 특징 : 수정 불가

s1 = 'a1'
print(s1, id(s1))
# 출력 : a1 2529911521648

s1 = 'aaaa'
print(s1, id(s1))
# 출력 : aaaa 2529911522352
# 수정이 아니라 참조 대상이 바뀐 것이다.

• 인덱싱, 슬라이싱
  - 인덱싱 형식 : 문자열[0]
  - 슬라이싱 형식 : 문자열[start:stop:step]

# 인덱싱
print(s[0], s[3])       # s[8] : index out of range 에러
print(s[-1], s[-3])

# 슬라이싱 [start:stop:step]
print(s[0:3], s[:3])
print(s[3:8], s[3:])
print(s[:])
print(s[1:5:2])         # 증가치 추가
print(s[::2])

print(s[-4:-1], s[-3:])
print('fre' + s[2:])

---

📌 Python 문자열 중요 함수

• strip() 함수
  - 처음, 끝 공백 제거

s2 = 'a1 a2'
s2 = ' ' + s2[:2] + 'a3' + s2[3:] + ' '
print(s2, len(s2))
# 출력 : ' a1a3a2 ' 8
print(s2.strip(), len(s2.strip()))
# 출력 : 'a1a3a2' 6
print(s2.lstrip())
# 출력 : 'a1a3a2 '
print(s2.rstrip())
# 출력 : ' a1a3a2'

• split() 함수
  - 문자열 자르기 함수

s2 = 'a1 a2'
s3 = s2.split(' ')
print(s3)
# 출력 : ['a1', 'a2']

• join() 함수
  - 문자열 합치기 함수

s3 = ['a1', 'a2']
print(' '.join(s3))
# 출력 : 'a1 a2'

• replace() 함수
  - 특정 문자열 변경

s2 = ' a1a3a2 '
print(s2.replace('a3', ' '))
# 출력 : ' a1 a2 '

---

📌 Python list

• list
  - 순서 있음 : 인덱싱, 슬라이싱
  - 수정 가능
  - 여러 자료형 저장 가능

a = [1, 2, 3]
b = [10, a, 12.5, True, '문자열']
print(a, type(a))
# 출력 : [1, 2, 3] <class 'list'>
print(b, type(b))
# 출력 : [10, [1, 2, 3], 12.5, True, '문자열'] <class 'list'>

• 중첩 리스트

a1 = [1, 2, 3, ['a1', 'a2'], 4, 5]
print(a1)
# 출력 : [1, 2, 3, ['a1', 'a2'], 4, 5]
print(a1[0])
# 출력 : 1
print(a1[3])
# 출력 : ['a1', 'a2']
print(a1[3][0])
# 출력 : a1

• 인덱싱, 슬라이싱

family = ['엄마', '아빠', '나', '여동생']
print(family[3])        # 리스트 인덱싱
# 출력 : 여동생
print(family[:2])       # 리스트 슬라이싱
# 출력 : ['엄마', '아빠']

• 리스트 요소 추가
  - list.append(요소) : 리스트 맨 뒤에 요소 추가
  - list.insert(idx, 요소) : idx 인덱스에 요소 추가
  - list.extend(iterator) : 다른 list를 해당 리스트 뒤에 붙이기

family.append('남동생')            # 리스트 요소 추가
family.insert(0, '할머니')         # 리스트 요소 추가(인덱스)
family.extend(['삼촌', '조카'])     # 리스트에 리스트 붙이기
family += ['이모', '친척 누나']      # 리스트에 리스트 붙이기
print(family)
# 출력 : ['할머니', '엄마', '아빠', '나', '여동생', '남동생', '삼촌', '조카', '이모', '친척 누나']

• 리스트 요소 수정

family[0] = '외할머니'
print(family)
# 출력 : ['외할머니', '엄마', '아빠', '나', '여동생', '남동생', '삼촌', '조카', '이모', '친척 누나']

• 리스트 요소 삭제
  - list.remove(요소) : 값을 지정해 해당 값을 리스트에서 삭제
  - del list[idx] : 인덱스를 지정해 해당 인덱스의 값을 리스트에서 삭제

family.remove('남동생')    # 값으로 삭제
del family[-4]           # 인덱스로 삭제
print(family)
# 출력 : ['할머니', '엄마', '아빠', '나', '여동생', '조카', '이모', '친척 누나']

• 리스트에서 특정 요소 인덱스 찾기
  - list.index(요소) : 지정한 요소의 인덱스를 반환

print(family.index('여동생'))
# 출력 : 4

• 리스트에서 특정 요소 존재 여부

print('엄마' in family)
# 출력 : True

• 리스트 변수 삭제

del family

• sort() 함수
  - list.sort(key=키값, reverse=반전여부) : key와 reverse 값을 기준으로 list를 정렬

a2 = ['123', '34', '234', '1234']
a2.sort()   # sort() 만 사용해도 적용된다.
print(a2)
# 출력 : ['123', '1234', '234', '34']
a2.sort(key=int, reverse=True)
print(a2)
# 출력 : ['1234', '234', '123', '34']

• 얕은 복사 AND 깊은 복사
  - 얕은 복사 : 동일한 객체 주소만 복사
  - 깊은 복사 : 새로운 객체로 생성

name = ['a1', 'a2', 'a3', 'a4']
print(name)
name2 = name    # 얕은 복사 : 주소 치환
print(id(name) == id(name2))
# 출력 : True

import copy
name3 = copy.deepcopy(name)     # 깊은 복사 : 새로운 객체로 생성
print(id(name) == id(name3))
# 출력 : False

---

📌 Python tuple

• tuple
  - list와 유사하나 읽기 전용(list보다 속도가 빠름)
  - 순서 있음(인덱싱, 슬라이싱)
  - 수정 불가

t = ('a', 'b', 'c', 'a')
# t = 'a', 'b', 'c', 'a'
print(t, type(t), len(t), t.count('a'), t.index('a'))
# 출력 : ('a', 'b', 'c', 'a') <class 'tuple'> 4 2 0

• 인덱싱, 슬라이싱

# 인덱싱
print(t[0])
# 출력 : 'a'

# 슬라이싱
print(t[0:2])
# 출력 : ('a', 'b')

• 형 변환

t = ('a', 'b', 'c', 'a')
# 형 변환 tuple -> list
a = list(t)
a[1] = 'a2'

# 형 변환 list -> tuple
t = tuple(a)
print(t)
# 출력 : ('a', 'a2', 'c', 'a')

• ,를 붙여야 tuple 이다.

# tuple은 반드시 요소가 하나일 때 , 를 붙여야 한다.
print((1), type((1)))
# 출력 : 1 <class 'int'>
print((1,), type((1,)))
# 출력 : (1,) <class 'tuple'>

---

📌 Python set

• set
  - 순서 없음
  - 중복 불가

s1 = {1, 2, 3, 1}
print(s1, type(s1), len(s1))
# 출력 : {1, 2, 3} <class 'set'> 3

• 합집합 함수
  - set1.union(set2) : 합집합을 수행

s1 = {1, 2, 3, 1}
s2 = {3, 4}

print(s1.union(s2))
# 출력 : {1, 2, 3, 4}

• 교집합 함수
  - set1.intersection(set2) : 교집합을 수행

s1 = {1, 2, 3, 1}
s2 = {3, 4}

print(s1.intersection(s2))
# 출력 : {3}

• _합집합 연산

s1 = {1, 2, 3, 1}
s2 = {3, 4}

print(s1 | s2)
# 출력 : {1, 2, 3, 4}

• 교집합 연산

s1 = {1, 2, 3, 1}
s2 = {3, 4}

print(s1 & s2)
# 출력 : {3}

• 차집합 연산

s1 = {1, 2, 3, 1}
s2 = {3, 4}

print(s1 - s2)
# 출력 : {1, 2}

• 함수를 이용한 추가 가능
  - set.update(iterator) : 묶음형 데이터를 set 뒤에 추가한다.

s1 = {1, 2, 3}
s1.update({4, 5})
s1.update([6, 7, 8])
s1.update((9, ))
print(s1)
# 출력 : {1, 2, 3, 4, 5, 6, 7, 8, 9}

• 함수를 이용한 삭제 가능
  - discard() : 데이터 삭제, 지정한 값이 없으면 skip
  - remove() : 데이터 삭제, 지정한 값이 없으면 에러

s1.discard(9)
s1.remove(8)
print(s1)
# 출력 : {1, 2, 3, 4, 5, 6, 7}

• set 데이터 전체 삭제

s1.clear()

• 리스트 중복 없애기

li = [1, 2, 3, 1, 2, 3]
li_a = set(li)
li = list(li_a)
print(li)
# 출력 : [1, 2, 3]

---

📌 Python dict

• dict
  - {'key' : 'value'}
  - 순서 없음
  - key value 형식

my = dict(k1=1, k2='aa', k3=3.4)
print(my, type(my))
# 출력 : {'k1': 1, 'k2': 'aa', 'k3': 3.4} <class 'dict'>

dic = {'파이썬':'snake', '자바':'coffee', '스프링':'spring'}
print(dic)
# 출력 : {'파이썬': 'snake', '자바': 'coffee', '스프링': 'spring'}

• value 값 얻기

print(dic['파이썬'])
# 출력 : 'snake'

• value 값 추가

dic['오라클'] = '예언자'
print(dic)
# 출력 : {'파이썬': 'snake', '자바': 'coffee', '스프링': 'spring', '오라클': '예언자'}

• value 값 삭제

del dic['오라클']
dic.pop('스프링')
print(dic)
# 출력 : {'파이썬': 'snake', '자바': 'coffee'}

• value 값 수정

dic['자바'] = 'java'
print(dic)
# 출력 : {'파이썬': 'snake', '자바': 'java'}

• keys 출력

print(dic.keys())
# 출력 : dict_keys(['파이썬', '자바'])

• values 출력

print(dic.values())
# 출력 : dict_values(['snake', 'java'])

---

📌 Python Regular Expression

• re
  - 사용 목적 : 대량의 데이터에서 원하는 데이터만 선택해서 처리할 때 효과적이다.
  - 직접 사용법 : re.findall(r'패턴', 문자열)
  - 간접 사용법
  p = re.compile(r'패턴')
  p.findall(문자열)

import re

s1 = "1234 abc가나다abcABC_123555_6'Python is fun'"
print(s1)

print(re.findall(r'1234\s\w{1,5}', s1))
# 출력 : ['1234 abc가나']

print(re.findall(r'1', s1))
# 출력 : ['1', '1']

print(re.findall(r'(1|2)', s1))
# 출력 : ['1', '2', '1', '2']

print(re.findall(r'[1-2]', s1))
# 출력 : ['1', '2', '1', '2']

print(re.findall(r'[1-9]+', s1))
# 출력 : ['1234', '123555', '6']

print(re.findall(r'[1-9]{2}', s1))
# 출력 : ['12', '34', '12', '35', '55']

print(re.findall(r'[1-9]{2,3}', s1))
# 출력 : ['123', '123', '555']

print(re.findall(r'[a-zA-Z]+', s1))
# 출력 : ['abc', 'abcABC', 'Python', 'is', 'fun']

print(re.findall(r'[가-힣]+', s1))
# 출력 : ['가나다']

print(re.findall(r'[^가-힣]+', s1))
# 출력 : ['1234 abc', "abcABC_123555_6'Python is fun'"]

print(re.findall(r'(12|34)', s1))
# 출력 : ['12', '34', '12']

print(re.findall(r'.bc', s1))
# 출력 : ['abc', 'abc']

print(re.findall(r'...', s1))
# 출력 : ['123', '4 a', 'bc가', '나다a', 'bcA', 'BC_', '123', '555', "_6'", 'Pyt', 'hon', ' is', ' fu']

print(re.findall(r'[^1]+', s1))
# 출력 : ['234 abc가나다abcABC_', "23555_6'Python is fun'"]

print(re.findall(r'^1+', s1))
# 출력 : ['1']

print(re.findall(r'\d+', s1))
# 출력 : ['1234', '123555', '6']

print(re.findall(r'\s+', s1))
# 출력 : [' ', ' ', ' ']

print(re.findall(r'\w+', s1))
# 출력 : ['1234', 'abc가나다abcABC_123555_6', 'Python', 'is', 'fun']

---

📌 Python if 문

• if 문
  - 조건문에 ()를 사용하지 않아도 된다.
  - {} 로 실행문을 묶는 것이 아닌 :로 실행문 시작을 알린다.
  - else if() 문 대신 elif 문을 사용한다.
  
  
• 한 줄 표현식

a = 'abc'
b = 1 if a == 'abc' else 0
print(b)
# 출력 : 1

a = 10
b = 'true' if a == 10 else 'false'
print(b)
# 출력 : 'true'

---

📌 Python while 문

• while 문

print('3의 배수의 합 출력')
i = 1; hap = 0
while i <= 100:
    if (i % 3 == 0):
        print(f'{hap} + {i} = {hap+i}')
        hap += i
    i += 1

print(f'합은 {hap}이다.')

---