프로그래밍 시작하기 : 파이썬 입문 2.완전 기초~3.기초 자료형

프로그래밍 시작하기 : 파이썬 입문(inflearn Original)

2. 파이썬 완전 기초

 

 

2-1. 파이썬 Print 사용법 (1-1): 이것저것 출력해봐요.

 

 

print('Python Start!')
print("Python Start!")
print('''Python Start!''')
print("""Python Start!""")

# 주석

# separator 옵션
print('P', 'Y', 'T', 'H', 'O', 'N', sep = ' ')
print('P', 'Y', 'T', 'H', 'O', 'N', sep = '|')
# 원하는 옵션으로 출력할 경우

 

 

 

2-2. 파이썬 Print 사용법 (1-2)

 

# end 옵션
print()
print('Welcomt to', end=' ')
print('IT News', end='\n')
print('Web Site')

 

 

import라는 단어는 파이썬에서 이미 파이썬에서 쓰이기 때문에 이것을 변수로 지정할 수 없다.

 

# file 옵션
import sys
# print('Learn Python', file='test.txt')
print('Learn Python', file=sys.stdout)
print()

# format 사용(d : 숫자, s : 문자열, f : 실수)
print('%s %s' % ('one', 'two'))
print('{} {}'.format('one', 'two'))
print('{} {}'.format(1, 'two')) # format은 어떤 것이든 사용 가능.
# 좀 더 유용함.

print('{1} {0}'.format('one', 'two'))
# 들어가는 형식의 순서를 조정해줄 수 있음. two - one 순서대로.

 

 

 

 

2-3. 파이썬 Print 사용법 (1-3)

 

# %s
print('%10s' % ('nice')) # 자리수
print('{:>10}'.format('nice')) #왼쪽이라고 표시하고 10자리를 확보함

print('%-10s' % ('nice')) # 자리수
print('{:10}'.format('nice')) #오른쪽부터 정렬

print()

print('{:_>10}'.format('nice')) #오른쪽부터 정렬
print('{:$>10}'.format('nice')) #빈 곳에 채워줌

print('{:$^10}'.format('nice')) #중앙 정렬

print('%.5s' % ('pythonstudy')) #5글자까지만 공간절삭
print('{:10.5}'.format('pythonstudy')) #총 10글자의 공간을 확보하는데
                #5글자만 나와라.

# %d
print('%d %d' % (1, 2))
print('{}{}'.format(1, 2))
print('%4d' % (12434))
print('{:4d}'.format(42))

# %f
print('%f' % (3.12093483209))
print('%1.5f' % (341.32125312)) #정수부-소수부 자릿수 출력 지정 가능
print('{:f}'.format(3.2093494))

print('%06.2f' % (3.143151234))

 

 

 

 

2-4. 파이썬 변수(2-1) : 변수에 대한 이해는 정말 중요해요.

 

n = 700
print(n)

print(type(n))

 

#동시 선언
x = y = z = 700
print(x, y, z)

 

 

#선언
var = 75

#재선언
var = "Change Value" #덮어씀

#출력
print(var)
print(type(var))

 

 

 

 

 

# Object References
# 변수 값 할당 상태일 때

# 예1)
print(300)
# 할당이 안되어 있으므로
# 1. 타입에 맞는 오브젝트 생성(내부적으로 int())
# 2. 값 생성
# 3. 콘솔 출력
print(int(300))

#예2)
# ㅜ-> 777
n = 777
print(n, type(n))

 

내부적으로 알아서 type에 맞는 class object를 생성해 값을 할당받는다.

 

 

 

2-5. 파이썬 변수(2-2)

 

 

#id(identity) 확인 : 객체의 고유값 확인
m = 800
n = 655
print(id(m))
print(id(n))
print()
# id 값을 기본으로 해서 파이썬이 변수를 가져온다.
print(id(m) == id(n))
m = 800
n = 800
print(id(m))
print(id(n))
print(id(m) == id(n))

변수에 할당된 값이 같을 경우 id 값이 똑같아진다.

파이썬 엔진(인터프리터)이 똑같은 변수를 계속 복사해서 선언할 필요가 없으므로

하나의 오브젝트로 생성을 해 버린다.

자동으로 최적화를 해 버린다는 것이다. 같은 오브젝트로 참조된다!!

 

# 다양한 변수 선언
print()

# Calmel Case : numberOfCollegeGraduates -> Method를 선언할 떄 주로 사용함
# Pascal Case : NumberOfCollegeGraduates -> class를 선언할 때 주로 사용함
# Snake Case : number_of_college_graduates -> 변수를 선언할 때 주로 사용함

# 허용하는 변수 선언법
age = 1
Age = 2
aGe = 3
AGE = 4
a_g_e = 5
__age = 5
age_ = 7
_AGE_ = 8

# 특수문자나 숫자로 시작하는 변수는 안 된다.(예외 : _, $)

 

예약어는 변수명으로 불가능

False, def if, raise, None, del import, return, true, elif, in, try,

and else, is, while, as, except, lambda, with

assert, finally, nonlocal, yeild, break

for, not, clss, from, or, continue, global, pass 등

 

 

 

3. 파이썬 기초 자료형

 

3-1. 숫자형(1-1) : 계산의 기본은 숫자형

 

#숫자형

# 파이썬 지원 자료형
"""
int : 정수
float : 실수
complex : 복소수
bool : 불린
str : 문자열(시퀀스)
list : 리스트(시퀀스)
tuple : 튜플(시퀀스) # 시퀀스는 순서가 있고 반복적으로 처리 가능
set : 집합
dict : 사전
"""

# 데이터 타입
str1 = "Python"
bool1 = True
bool2 = True
str2 = 'Anaconda'
float1 = 10.0 # 컴퓨터에선 10과(정수) 10.0(실수)는 다르게 인식된다.
int1 = 7

list = [str1, str2]
print(list)

dict = {
"name" : "Machine Learning",
"version" : 2.0
}
# key - value 형태
print(dict)

# 데이터 타입 출력
print(type(str1))
print(type(list))
print(type(dict))

tuple = (7, 8, 9)   # tupe = 7, 8, 9 로 선언도 가능
set = {7, 8, 9}
print(tuple);
print(set);



# 숫자형 연산자
"""
+
-
*
/
// : 몫
% 나머지
abs(x) : 절대값
pow(x, y)  x**y -> 2**3
"""

#정수 선언
i = 77
i2= -14
big_int = 235324665675677567567567567

# 정수 출력
print(i)
print(i2)
print(big_int)
print()

#실수 출력
f = 0.99999
f2 = 3.149023
f3 = -3.9
f4 = 3/9

print(f)
print(f2)
print(f3)
print(f4)


#연산 실습
i1 = 39
i2 = 939
big_int1 = 8888888888888888888888888
bit_int2 = 9329233333333333333333333
f1 = 1.235324665675677567567567567
f2 = 3.9329233333333333333333333

# 정수 + 실수 = 실수

 

 

 

3-2. 숫자형(1-2)

 

# 형 변환 실습
a = 3.
b = 6
c = .7
d = 12.7
#여기서 b만 정수이다. 나머지는 실수

# 형 변환
print(float(b))
print(int(c))
print(int(True)) # True : 1, False : 0
print(complex(3))
print(complex('2'))
print(complex(False))

#수치 연산 함수
print(abs(-7))
x, y = divmod(100, 8) #저절로 몫과 나머지를 나눠서 할당해줌.
print(x, y)
print(pow(5, 3), 5**3)

#외부 모듈
import math

print(math.pi)
print(math.ceil(5.1)) # 가우스 []

 

 

 

3-3. 문자형(2-1) : 텍스트 출력도 중요하겠죠?

 

 

#문자열 생성
str1 = "I am Python"
str2 = 'Python'
str3 = """How are you?"""
str4 = '''Thank you!'''

print(type(str1), type(str2), type(str3), type(str4))
print(len(str4))

#빈 문자
str1_t1 = ''
str1_t2 = ""
# 고급 표현
str2_t2 = str() # str Object를 호출해서 생성하는 것

print(type(str1_t2), len(str1_t2))

# 이스케이프 문자 사용
print('I''m Boy') #생략된다.
print('I\'m Boy') #앞에 \를 서 주어야 정상적으로 작동된다.
print('a \t b')
print('a \"\" b')

"""
Escape 코드
\n : 개행
\t : 탭
\000 : 널
"""

# 탭, 줄 바꿈
t_s1 = "Click \t Start!"
t_s2 = "New Line\n Check!"
print(t_s1)
print(t_s2)

# Raw String
raw_s1 = r'D:\python\test'
print(raw_s1)
# 날것 그대로의 문자열을 사용할 수 있다.

# 멀티라인 입력

multi_str = '''
String
Multi line
Test
'''

print(multi_str)

# \가 바인딩 표시로 작동, 없을 경우 에러
multi_str2 =\
'''
String
Multi line
Test
'''

print(multi_str2)

print()
# 문자열 연산
str_o1 = "python"
str_o2 = "Apple"
str_o3 = "How are u"
str_o4 = "Seoul Incheon"

print(str_o1 * 3)
print(str_o1+str_o2)
print('y' in str_o1)
print('S' not in str_o4)

print()
# 문자열 형 변환
print(str(66), type(str(66)))

#문자열 함수(upper, isalnum, startswitch, count, endswitch, isalpha)

print("Capitalize : ", str_o1.capitalize()) #첫 글자를 대문자로
print("endswith?: ", str_o2.endswith("e")) #마지막 글자 확인
print("replace : ", str_o1.replace("on", "Good"))
print("sorted: ", sorted(str_o2))  # 정렬해서 리스트 형태로 반환
print("split: ", str_o4.split(' '))

#반복 (시퀀스)
im_str = "Bood Boy!"
print(dir(im_str))  # 속성을 나열할 수 있다.
#__iter__가 있다면 반복을 할 수 있다는 것(sequence)

#출력
for i in im_str:
    print(i)

 

3-4. 문자형(2-3)

 

 

#슬라이싱 연습
print()
str_s1 = "Nice Python"

print(str_s1[0:3])  # index로 출력, 0부터 2까지 출력
print(str_s1[0:0]) # 이렇게는 아무것도 나오지 않음
print(str_s1[5:])  # 마지막까지
print(str_s1[:4]) # 처음부터
print(str_s1[:len(str_s1)-1])

print(str_s1[1:9:2]) # Skip 하면서 가져올 수 있음

print(str_s1[-5:])
print(str_s1[1:-2])
print(str_s1[::2])
print(str_s1[::-1])  #역출력


#아스키 코드(또는 유니코드)
a = 'z'
print(ord(a))

print(chr(122))  #아스키 코드를 대문자로

 

 

 

3-5. 리스트(3-1) : 집합 구조의 첫 걸음은 리스트 자료형

 

#자료구조에서 중요
#리스트 자료형(순서O, 중복O, 수정O, 삭제O)

# 선언
a =[]
print(type(a))
b = list()
c = [70, 75, 80, 85]
print(len(c))
d = [1000, 10000, 'Ace', 'Base', 'Captine']
# 서로 다른 자료형을 담을 수 있음.
e = [1000, 10000, ['Ace', 'Base', 'Captine']]
# 리스트 안의 리스트
f = [21.42, 'foobar', 3, 4, False, 3.141592]

# 인덱싱
print('>>>>>>')
print('d - ', type(d), d)
print('d - ', d[1])
print('d - ', d[0] + d[1] + d[1])
print('d - ', d[-1])
print('e - ', e[-1][1])
print('e - ', list(e[-1][1]))
# element를 list해 줌

#슬라이싱
print('>>>>')
print('d - ', d[0:3])
print('d - ', d[2:])
print('e - ', e[-1][1:3])
#리스트 연산
print('>>>>>')
print('c + d', c + d)
print('c * 3', c * 3)
print("'Test' + c[0]", 'Test' + str(c[0]))
# 형변환 꼭 해줘야 함.

 

 

 

 

3-6. 리스트(3-2)

 

#자료구조에서 중요
#리스트 자료형(순서O, 중복O, 수정O, 삭제O)

# 선언
a =[]
print(type(a))
b = list()
c = [70, 75, 80, 85]
print(len(c))
d = [1000, 10000, 'Ace', 'Base', 'Captine']
# 서로 다른 자료형을 담을 수 있음.
e = [1000, 10000, ['Ace', 'Base', 'Captine']]
# 리스트 안의 리스트
f = [21.42, 'foobar', 3, 4, False, 3.141592]

# 인덱싱
print('>>>>>>')
print('d - ', type(d), d)
print('d - ', d[1])
print('d - ', d[0] + d[1] + d[1])
print('d - ', d[-1])
print('e - ', e[-1][1])
print('e - ', list(e[-1][1]))
# element를 list해 줌

#슬라이싱
print('>>>>')
print('d - ', d[0:3])
print('d - ', d[2:])
print('e - ', e[-1][1:3])
#리스트 연산
print('>>>>>')
print('c + d', c + d)
print('c * 3', c * 3)
print("'Test' + c[0]", 'Test' + str(c[0]))
# 형변환 꼭 해줘야 함.

print()
print()

# 값 비교
print(c== c[:3] + c[3:])

# Identity(id)
temp = c
print()
print(temp, c)
print(id(temp), id(c)) # 같은 ID

# 리스트 수정, 삭제
print('>>>>>')
c[0] = 4
print('c - ', c) # 인덱스 번호로 바로 접근해 수정 가능
c[1:2] = ['a', 'b', 'c']
print('c -', c)
c[0] = [['a','b','c']]  # 중첩 리스트
print(c)
c[1:3] = []
print('c -', c)
del c[2]  #삭제
print()



# 리스트 함수
a = [5, 2, 3, 1, 4]
print('a - ', a)

a.append(10)   # 맨 끝에 원소 추가
print('a - ', a)
a.sort()
print('a - ', a)
a.reverse()
print('a - ', a)
print('a - ', a.index(3), a[3])
a.insert(2, 7) #위치, 추가할 값. 원래 있던 애들은 뒤로 싹 밀림
print('a - ', a)
a.reverse()
print('a - ', a)
# del a[6]   #del은 index로 지움
# print('a - ', a)
a.remove(10) #원소 그 자체로 지움
print('a - ', a)
print('a - ', a.pop()) #마지막 인덱스의 원소를 호출하고 리스트에서 제거함.
print('a - ', a)
# last-in, first out = stack
print('a - ', a.count(1))  # 해당 원소가 몇개 있는지.
ex = [8, 9]
a.extend(ex)
print('a - ', a)  #연장

 

 

 

 

 

3-7. 튜플(4-1) : 튜플은 리스트와 거의 비슷해요.

 

튜플은 리스트와 단 두가지 특징을 제외하면 거의 비슷함.

# 파이썬 튜플

# 리스트와 비교 중요
# 튜플 자료형(순서 o, 중복 o,수정 x, 삭제 x)
# 불면하는 자료형

# 선언
a = ()
b = (1, 2)
b_1 = (1)
print(type(a), type(b_1))
# 맨 끝에 콤마를 붙여야 튜플로 인식됨
b_1 = (1, )
print(type(b_1))
c = (11, 12, 13, 14)
d = (100, 1000, 'Ace', 'Base', 'Captine')
e = (100, 1000, ('Ace', 'Base', 'Captine'))

# 인덱싱
print('>>>>')
print('d - ', d[1])
print('d - ', d[0] + d[1] + d[1])
print('d - ', d[-1])
print('e - ', e[-1])
print('e - ', e[-1][-1])
print('d - ', list(e[-1][1]))

# 수정, 삭제 불가
#d[0] = 1500


print('>>>>')
#슬라이싱
print('d - ', d[0:3])
print('d - ', d[2:])
print('d - ', e[2][1:3])

# 튜플 연산
print('>>>>')
print('c + d', c+d)
print('c * 3', c*3)

# 튜플 함수
a = (5, 2, 2, 1, 4)
print('a - ', a)
print('a - ', a.index(2))
print('a - ', a.count(2))

# 패킹 & 언팩킹(Packing, un-packing)

# 팩킹
t = ('foo', 'bar', 'baz', 'qux')
# 여러 원소를 묶은 위와 같은 값, 튜플 선언이나 마찬가지
print(t)
print(t[0])

# 언팩킹
(x1, x2, x3, x4) = t
print(type(x1),  type(x2), type(x3), type(x4))
# 변수 하나하나에 팩킹했던 원소를 하나하나 할당하는 것.
print(x1, x2, x3, x4)

t2 = 1, 2, 3  # 괄호가 없어도 튜플 선언 가능
t3 = 4,    # 이것도 튜플
x1, x2, x3 = t2 #언팩킹
x4, x5, x6 = 4, 5, 6 # 언팩킹

print(x4, x5, x6)

 

 

 

 

 

3-8. 딕셔너리(5-1) : 딕셔너리는 유용하게 자주 사용해요.

 

# 파이썬 딕셔너리
# 범용적으로 가장 많이 사용
# 딕셔너리 자료형, 순서는 중요하지 않고 키는 중복을 허용하지 않음
# 수정도 삭제도 가능.

# 선언
a = {'name' : 'Kim', 'phone': '01033337777', 'birth': '870514'}   # 키 : 값
b = {0: 'Hello python'}
c = {'arr': [1, 2, 3, 4]}
d = {
'Name' : 'Niceman',
'City' : 'Seoul',
'Age' : 33,
'Grade': 'A',
'Status' : True
}
e = dict([
('Name' , 'Niceman'),
('City' ,'Seoul'),
('Age', 33),
('Grade', 'A'),
('Status',True)
])
# 튜플 형태 선언도 가능

f = dict(
 Name = 'Niceman',
 City = 'Seoul',
 Age = 33,
 Grade = 'A',
 Status = True
)
# 개선된 방식의 선언
# a = [f, f2, f3...]

print('a - ', type(a), a)
print('b - ', type(b), b)
print('c - ', type(c), c)
print('d - ', type(d), d)
print('e - ', type(e), e)
print('f - ', type(f), f)

# 출력
print('a - ', a['name'])
print('a - ', a.get('name'))
# get으로 사용하면 해당 키에 해당하는 밸류가 없을 경우 None을 리턴,
# 프로그램의 흐름이 끊기지 않아 get이 선호됨.
# key로 직접 가져오는 건 에러 발생 가능성이 큼.
print('b - ', b[0])
print('b - ', b.get(0))

print()
print('f - ', f.get('City'))
print('f - ', f.get('Age'))

 

 

3-9. 딕셔너리(5-2)

# 딕셔너리 추가
a['address'] = 'seoul'
print('a - ', a) # 동적 추가 가능.
a['rank'] = [1, 2, 3]
print('a - ', a)

# 딕셔너리 추가
print('a - ', len(a))

# dict_keys, dict_values, dict_items : 반복문(__iter___)에서 사용 가능
print('a - ', a.keys())
print('b - ', b.keys())
print('c - ', c.keys())
print('d - ', d.keys())

print('a - ', list(a.keys()))

print()

print('a - ', list(a.values()))
print('b - ', b.values())
print('c - ', c.values())
print('d - ', d.values())

print()

print('a - ', a.items())  # 튜플 쌍 형태로 변환.
print('a - ', list(a.items()))

print()
print('a - ', a.pop('name'))
print('a - ', a)

print('c - ', c.pop('arr'))
print('c - ', c)
print()
print('f - ', f.popitem())  #랜덤으로 아이템 꺼내옴.
print('f - ', f)
print('f - ', f.popitem())
print('f - ', f)
print('f - ', f.popitem())
print('f - ', f)
print('f - ', f.popitem())
print('f - ', f)

print()

# in 연산자
print('a - ', a)
print('a - ', 'birth' in a) # key가 a에 존재하는지
#대소문자 구분함 key는

#수정
a['test'] = 'test_dict'

print('a - ', a)
a['test'] = 'tt'
print('a - ', a)

a.update(birth='991214')
print('a -', a)
temp = {'phone': 'Busan'}
a.update(temp)
print('a -', a)

 

 

 

 

 

 

3-10. 집합(6-1) : 알고 나면 강력한 집합 자료형

 

# 집합(Set)은 순서가 없고, 중복을 허용하지 않음. 순서도 없음.
# 수정이나 삭제 가능

# 선언
a = set()
print(a)
print(type(a))

b = set([1, 2, 3, 4])
c = set([1, 4, 5, 6])
d = set([1, 2, 'Pen', 'Cap', 'Plate']) #문법적으로 정확
e = {'foo', 'bar', 'baz', 'foo', 'qux'}
f = {42, 'foo', (1, 2, 3), 3.14159}

print('a -', type(a), a)
print('b - ', b)
print('c - ', c)
print('d - ', d)
print('e - ', e)

# 튜플 변환
t = tuple(b)
print('t - ', type(t), t)
print('t - ', t[0])

# 리스트 변환
l = list(c)
l2 = list(d)
print('l - ', l)
print('l2 - ', l2)

#길이
print(len(f))

#집합 자료형 활용
s1 = set([1, 2, 3, 4, 5, 6])
s2 = set([4, 5, 6, 7, 8, 9])
print('s1 & s2 : ', s1 & s2) # 교집합
print('s1 & s2 : ', s1.intersection(s2))
print('s1 | s2 : ', s1 | s2) # 합집합
print('s1 | s2 : ', s1.union(s2))

print('s1 - s2 : ', s1 - s2)
print('s1 - s2 : ', s1.difference(s2))

# 중복 원소 확인
print('s1 & s2 : ', s1.isdisjoint(s2))
#교집합이 있으면 false

# 부분 집합 확인
print()
print(s1.issubset(s2))
print(s1.issuperset(s2))

# 추가 & 제거
print()
s1 = set([1, 2, 3, 4])
s1.add(5)
print('s1 - ', s1)
s1.remove(2)
print('s1 - ', s1)
s1.discard(3)
print('s1 - ', s1) #discard는 제거하려는 원소가 없어도 예외가 안 일어남

s1.clear() #전부 다 지움