x = 10 # int
y = 10.0 # float
w = '문자열' # str
z = True # bool
■ python 자료형
1. list
- 데이터 목록을 다루는 자료형
- 1차원 배열
- 서로 다른 데이터 타입을 가질 수 있는 자료형
- 중첩할 수 있다.
- []
- list()
x1 = []
type(x1) # list
x2 = list()
type(x2) # list
x = [10,20,30]
x
type(x)
len(x) # 3 : 리스트 변수에 입력된 값의 수
# Indexing 인덱싱
x[0] # 10
x[1] # 20
x[2] # 30
x[-1] # 30
x[-2] # 20
x[-3] # 10
# slicing 슬라이싱
x[0:2] # [10, 20]
x[1:] # [20, 30]
x[:-1] # [10, 20]
# 리스트 값 수정
x[0] = 100
x # [100, 20, 30]
x[1:3] = [200,300]
x # [100, 200, 300]
# append() : 리스트 값 추가(바로적용)
x.append(400)
x # [100, 200, 300, 400]
# extend() : 기존 리스트 변수에 다른 리스트 변수를 이어 붙이는 함수(바로적용)
y = [600,700]
x.extend(y)
x # [100, 200, 300, 400, 600, 700]
# insert(위치,값) : 인덱스를 이용해서 새로운 값을 입력하는 함수(바로적용)
x[4] # 600
x.insert(4,500)
x[4] # 500
x # [100, 200, 300, 400, 500, 600, 700]
# 서로 다른 리스트 변수를 이어 붙이는 방법(미리보기)
z = [800,900,1000]
x + z # [100, 200, 300, 400, 500, 600, 700, 800, 900, 1000]
w = x + z
# 리스트 변수에 있는 값 중에 마지막 값을 제거하는 방법
w[:-1] # 미리보기
del w[-1] # 리스트에서 특정한 인덱스 값을 제거(바로적용)
w # [100, 200, 300, 400, 500, 600, 700, 800, 900]
w.pop() # 리스트 내 마지막 값 제거(바로적용)
w # [100, 200, 300, 400, 500, 600, 700, 800]
# 특정한 인덱스에 있는 값을 제거하는 방법(바로적용)
del w[2] # [100, 200, 400, 500, 600, 700, 800]
w
w.pop(2) # 400
w # [100, 200, 500, 600, 700, 800]
subject = ['SQL','PLSQL','SQL','PYTHON','LINUX','SQL']
len(subject) # 6
subject.count('SQL') # 3 : 리스트 안에 있는 값의 수를 리턴하는 함수
# 리스트 변수안의 값을 찾아 위치값을 리턴하는 함수, 없으면 오류 발생
list(찾을값,시작위치인덱스(0 기본값))
subject.find('SQL') # 오류 : 리스트 변수에서는 find 함수를 사용할 수 없다.
subject.index('SQL',0) # 0
subject.index('SQL',1) # 2
subject.index('SQL',3) # 5
subject.index('SQL',6) # 에러 : SQL' is not in list
# 리스트 변수에 있는 값을 찾아 제거하는 방법
subject = ['SQL','PLSQL','SQL','PYTHON','LINUX','SQL']
subject.index('SQL') # 0
subject[subject.index('SQL')] # 'SQL'
del subject[subject.index('SQL')]
del subject[subject.index('SQL')]
del subject[subject.index('SQL')]
subject # ['PLSQL', 'PYTHON', 'LINUX']
subject.pop(subject.index('SQL'))
subject.pop(subject.index('SQL'))
subject.pop(subject.index('SQL'))
subject # ['PLSQL', 'PYTHON', 'LINUX']
subject.remove('SQL')
subject.remove('SQL')
subject.remove('SQL')
subject # ['PLSQL', 'PYTHON', 'LINUX']
# 중첩리스트
x = [1,2,3,['a','b','c'],4,5]
len(x) # 6
type(x) # list
type(x[0]) # int
len(x[3]) # 3
type(x[3]) # list
x[3] # ['a', 'b', 'c']
x[3][0] # 'a'
type(x[3][0]) # str
x[3][:2] # ['a', 'b']
x[3].append('d')
x[3] # ['a', 'b', 'c', 'd']
x[3].pop()
x # [1, 2, 3, ['a', 'b', 'c'], 4, 5]
x.append(6)
x # [1, 2, 3, ['a', 'b', 'c'], 4, 5, 6]
x.pop()
x # [1, 2, 3, ['a', 'b', 'c'], 4, 5]
x[3][0] = x[3][0].upper()
x # [1, 2, 3, ['A', 'b', 'c'], 4, 5]
x[3][1] = 'B'
x # [1, 2, 3, ['A', 'B', 'c'], 4, 5]
# 리스트 내 변수값을 지우는 함수
x.clear()
x # []
x.append(1)
x.append(2)
x # [1, 2]
dir() # 메모리 내 객체 확인
id(x) # 1725758293056 : 메모리 주소
del x # 변수 삭제
x # NameError: name 'x' is not defined
# 리스트 변수안에 값을 기준으로 오름차순 정렬(바로적용)
x = [1,5,2,4,3]
x.sort() # reverse = False : 기본값
x # [1, 2, 3, 4, 5]
# 리스트 변수안에 값을 기준으로 내림차순 정렬(바로적용)
x = [1,5,2,4,3]
x.sort(reverse=True)
x # [5, 4, 3, 2, 1]
# 리스트 변수안에 값을 기준으로 오름차순 정렬(미리보기)
x = [1,5,2,4,3]
sorted(x) # [1, 2, 3, 4, 5]
x # [1, 5, 2, 4, 3]
y = sorted(x)
y # [1, 2, 3, 4, 5]
# 리스트 변수안에 값을 기준으로 내림차순 정렬(미리보기)
x = [1,5,2,4,3]
sorted(x,reverse=True) # [5, 4, 3, 2, 1]
x # [1, 5, 2, 4, 3]
y = sorted(x,reverse=True)
y # [5, 4, 3, 2, 1]
# 리스트 변수안에 값을 역순으로 출력(미리보기)
x = [1,5,2,4,3]
x[::-1] # [3, 4, 2, 5, 1]
y = x[::-1]
y # [3, 4, 2, 5, 1]
# 리스트 변수안에 값을 역순으로 출력(바로적용)
x = [1,5,2,4,3]
x.reverse()
x # [3, 4, 2, 5, 1]
x = 13//2
y = 13%2
↓
x, y = divmod(13,2)
type(divmod(13,2)) # tuple
2. tuple 튜플
- 리스트 자료형과 유사하다.
- 리스트와 차이점은 추가, 수정, 삭제를 할 수 없다.
- 리스트는 변수로 사용하고, 튜플은 상수처럼 사용한다.
- 변수는 변하는 값들을 사용하고, 상수는 한번 입력받은 값만 사용해야 한다.
- 중첩할 수 있다.
- 서로 다른 데이터 타입을 가질 수 있다.
- ()
lst = []
type(lst) # list
lst = ()
type(lst) # tuple
tuple_1 = ()
type(tuple_1) # tuple
tuple_2 = (10,20,30)
tuple_2 # (10, 20, 30)
tuple_3 = 10,20,30
tuple_3 # (10, 20, 30)
type(tuple_3) # tuple
x = (10)
x # 10
type(x) # int
y = (10,)
y # (10,)
type(y) # tuple
len(y) # 1
x = ('a','b',('ab','bc'))
x # ('a', 'b', ('ab', 'bc'))
x[0] # 'a'
x[1] # 'b'
x[2] # ('ab', 'bc')
x[2][0] # 'ab'
x[2][1] # 'bc'
x = ('a','b',1,2)
x # ('a', 'b', 1, 2)
x[0] # 'a'
x[1] # 'b'
x[2] # 1
type(x[2]) # int
x = (1,2,3)
y = (4,5,6)
# 여러 튜플을 하나로 결합하는 방법
z = x + y
z # (1, 2, 3, 4, 5, 6)
type(z) # tuple
z[0] # 1
x[0] = 10 # 오류 : 튜플은 수정할 수 없다.
del z[0] # 오류 : 튜플은 삭제 할 수 없다.
z.pop() # 오류 : 튜플은 삭제 할 수 없다.
z.remove(1) # 오류 : 튜플은 삭제 할 수 없다.
z.extend(2) # 오류 : 튜플은 새로운 값을 추가할 수 없다.
z.srot() # 오류 : 튜플은 수정할 수 없다.
sorted(z) # [1, 2, 3, 4, 5, 6] : list로 변환, 미리보기
type(sorted(z)) # list
sorted(z,reverse=True) # [6, 5, 4, 3, 2, 1] : list로 변환, 미리보기
z.reverse() # 오류 : 튜플은 수정할 수 없다.
# 튜플에서 역순으로 출력하는 방법 : 슬라이싱 활용
z = z[::-1] # (6, 5, 4, 3, 2, 1)
z.index(1) # 5
z.index(5) # 1
z.count(1) # 1
# 값을 각 변수에 분할
x = 1,2,3
one,two,three = x
one # 1
two # 2
three # 3
y = [1,2,3]
one,two,three = y
one # 1
two # 2
three # 3
y = [1,2,3]
one,two = y[0:2]
one # 1
two # 2
3. dictionary 딕셔너리
- key, value 값을 가지는 자료형
- {}
- {key1:value1, key2:value2, ...}
dic = { }
type(dic) # dict
dic = {'이름':'홍길동','전화번호':'010-1000-0001','주소':'서울'}
dic
dic.keys() # dict_keys(['이름', '전화번호', '주소'])
dic.values() # dict_values(['홍길동', '010-1000-0001', '서울'])
dic.items() # dict_items([('이름', '홍길동'), ('전화번호', '010-1000-0001'), ('주소', '서울')])
dba = {'db':'oracle','개발자':'sql','성능':'sql튜닝'}
dba
dba['db'] # 'oracle'
# 키 : 값 추가
dba['관리'] = '백업&복구'
dba
dba['관리'] = ['객체관리','유저관리','메모리관리','스토리지관리','백업&복구']
dba['관리'] # ['객체관리', '유저관리', '메모리관리', '스토리지관리', '백업&복구']
dba.get('관리') # ['객체관리', '유저관리', '메모리관리', '스토리지관리', '백업&복구']
dba['진단'] # 키가 없으면 오류
dba.get('진단') # 키가 없으면 None(null) 리턴한다.
dba.keys() # dict_keys(['db', '개발자', '성능', '관리'])
# 키 체크
'개발자' in dba.keys() # True
'진단' in dba.keys() # False
# 값 체크
'sql' in dba.values() # True
'plsql' in dba.values() # False
'객체관리' in dba.values() # False ???
['객체관리', '유저관리', '메모리관리', '스토리지관리', '백업&복구'] in dba.values() # True
'객체관리' in dba['관리'] # True
v = dba.values()
type(v) # dict_values
list(v) # 리스트로 형 변환
type(list(v)) # list
list(dba.values()) # ['oracle', 'sql', 'sql튜닝', ['객체관리', '유저관리', '메모리관리', '스토리지관리', '백업&복구']]
list(dba.keys()) # ['db', '개발자', '성능', '관리']
list(dba.items())
''' [('db', 'oracle'),
('개발자', 'sql'),
('성능', 'sql튜닝'),
('관리', ['객체관리', '유저관리', '메모리관리', '스토리지관리', '백업&복구'])] '''
4. SET 집합
- 리스트와 비슷하다.
- 인덱스가 없다.
- 중복을 허용하지 않는다. 유일한 값만 저장된다.
- {value}
- set()
s = {1,1,1,2,3,4,2,3,4,5}
s # {1, 2, 3, 4, 5}
type(s) # set
s[0] # 오류 : 집합 자료형은 인덱스가 없다
lst = {1,1,1,2,3,4,2,3,4,5}
lst
# 집합 자료형으로 변환 미리보기
set(lst) # {1, 2, 3, 4, 5}
tuple_1 = {1,1,1,2,3,4,2,3,4,5}
set(tuple_1) # {1, 2, 3, 4, 5}
z = set(tuple_1)
z
type(z) # set
x = [1,2,3,6]
y = [1,2,3,4,5]
x.extend(y) # union all
x # [1, 2, 3, 6, 1, 2, 3, 4, 5]
set(x) # {1, 2, 3, 4, 5, 6}
# 합집합
x = [1,2,3,6] # list
y = [1,2,3,4,5] # list
x.union(y) # 오류 : union함수는 집합 자료형에서 사용하는 함수
set(x).union(set(y)) # {1, 2, 3, 4, 5, 6}
x = {1,2,3,6} # set
y = {1,2,3,4,5} # set
x.union(y) # {1, 2, 3, 4, 5, 6}
y.union(x) # {1, 2, 3, 4, 5, 6}
x | y # {1, 2, 3, 4, 5, 6}
# 교집합
x = {1,2,3,6} # set
y = {1,2,3,4,5} # set
x.intersection(y) # {1, 2, 3}
y.intersection(x) # {1, 2, 3}
x & y # {1, 2, 3}
# 차집합
x = {1,2,3,6} # set
y = {1,2,3,4,5} # set
x.difference(y) # {6}
x - y # {6}
y.difference(x) # {4, 5}
y - x # {4, 5}
# 대칭차집합 symmetric difference // not exists
x = {1,2,3,6} # set
y = {1,2,3,4,5} # set
(x-y)|(y-x) # {4, 5, 6}
(x-y).union(y-x) # {4, 5, 6}
x.symmetric_difference(y) # {4, 5, 6}
x ^ y # {4, 5, 6}
# 서로소 집합 disjoint set : 두 집합에 공통된 원소가 '없는' 집합
{1,2,3}.isdisjoint({1,2,3}) # False
{1,2,3}.isdisjoint({4,5,6}) # True
# 부분집합 subset, ⊂,
x = {1,2,3}
y = {1,3}
y⊂x이면 집합 y는 x의 부분집합이다.
y <= x # True
y.issubset(x) # True
x.issubset(y) # False
# 상위집합인지 확인하는 함수
x.issuperset(y) # True
x[0] # 집합은 인덱스를 사용할 수 없다.
# 집합에 있는 원소를 하나씩 삭제
x.remove(1)
x # {2, 3}
# 집합에 하나의 값을 추가
x.add(5)
x # {2, 3, 5}
# 집합에 여러개의 값을 추가
x.update([6,7,8])
x # {2, 3, 5, 6, 7, 8}
# 집합에서는 수정은 할 수 없다. -> 삭제 후 추가하면 된다.
5. bool
- 참(True), 거짓(False)를 나타내는 자료형
x = True
y = False
type(x) # bool
type(y) # bool
# 조건제어문에서 True 표현 방법
1
bool(1) # True
bool(100)
bool(-1)
bool('홍길동')
bool('python')
bool([1,2,3])
not 0
not None
# 조건제어문에서 False 표현 방법
0
bool(0) # False
bool(None)
bool([])
bool(())
bool({})
bool('')
bool("")
not 1
not -100
■ 파이썬 변수 복제 주의!!
- x변수와 y변수는 동일한 메모리 공간을 사용하여 서로 영향을 준다.
x = [1,2,3]
y = x
x # [1, 2, 3]
y # [1, 2, 3]
x[0] = 10
x # [10, 2, 3]
y # [10, 2, 3]
y[0] = 5
x # [5, 2, 3]
y # [5, 2, 3]
id(x) # 1725759020928
id(y) # 1725759020928
# 변수를 복제할 때 슬라이싱을 이용하여 복제하면 다른 메모리 공간을 사용한다.
x = [1,2,3]
z = x[:]
x[0] = 10
x # [10, 2, 3]
z # [1, 2, 3]
id(x) # 1725759019072
id(z) # 1725758748608
import copy
x = [1,2,3]
w = copy.deepcopy(x)
id(x) # 1725759019776
id(w) # 1725758664320
■ 조건제어문
1. if 문
if 조건1:
조건1이 참값을 수행하는 부분
elif 조건2:
조건2가 참값을 수행하는 부분
...
else:
기본값 : 조건에 걸리는 부분이 업을 경우 수행하는 부분
if 10:
print('오늘 하루도 많이 웃자!!')
if True:
print('오늘 하루도 많이 웃자!!')
if 'oracle'
print('오늘 하루도 많이 웃자!!')
if False:
print('오늘 하루도 많이 웃자!!')
else:
print('내일도 많이 웃자!!')
x = 20
if x == 10:
print('오늘 하루도 {}배 행복하자!!'.format(x))
else:
print('내일도 {}배 행복하자!!'.format(x))
x = 12
if x>10 and x%2 == 0 :
print('참')
else:
print('거짓')
x = 11
if x>10 or x%2 == 0 :
print('참')
else:
print('거짓')
| [문제] 숫자를 입력값으로 받아서 그 값이 짝수면 짝수, 홀수면 홀수를 출력 |
| num = int(input('숫자 입력 : ')) if num % 2 == 0 : print('짝수') else: print('홀수') |
| num = int(input('점수 입력 : ')) if 90 <= num <= 100: grade = 'A' elif 80 <= num < 90: grade = 'B' elif 70 <= num < 80: grade = 'C' else: grade = 'F' print('점수 :',num,' 학점 :',grade) |
★ 변수의 빈문자열 비교 : '' 공백 ≠ None(null)
num = ''
num == '' # True
num == "" # True
num == None # False
x = None
type(x) # NoneType
x == None # True
x == '' # False
x = '1'
type(x) # str
x.isnumeric() # True
x = 1
type(x) # int
x.isnumeric() # 오류 : 문자값이 숫자형인지 체크하는 함수. x는 이미 숫자
# isinstance : 변수의 타입을 체크하는 함수
isinstance(값,타입)
x = 1
isinstance(x,int) # True
x = 1.2
isinstance(x,int) # False
isinstance(x,float) # True
isinstance(x,str) # False
x = True
isinstance(x,int) # True
isinstance(x,float) # False
isinstance(x,str) # False
isinstance(x,bool) # True
x = False
isinstance(x,int) # True
isinstance(x,float) # False
isinstance(x,str) # False
isinstance(x,bool) # True
| sal = 1000 comm = None |
|
| sal * 12 + comm # 오류 : None은 계산을 할 수 없다. | |
| if comm == None: annual = sal * 12 else: annual = sal * 12 + comm print(annual) |
if comm is None: annual = sal * 12 else: annual = sal * 12 + comm print(annual) |
# 1줄 if 문
저장변수 = 참값 if 조건 else 거짓
annual = sal * 12 if comm == None else sal * 12 + comm
print(annual)
annual = sal * 12 if comm is None else sal * 12 + comm
print(annual)
■ 반복문
1. while 문
- 조건이 True 인 동안에 반복을 수행한다.
while 조건문:
반복 수행할 문장
i = 1
while i <= 10:
print(i)
i += 1
| [문제] 1부터 100까지 합을 구하세요. |
| i = 1 num = 0 while i <= 100: num += i i += 1 print('1부터 100까지 합 :',num) |
| 1부터 100까지 합 : 5050 |
| [문제] 1부터 10까지 홀수만 출력 |
| i = 1 while i <= 10: if i % 2 != 0: print(i) i += 1 |
# continue 문 : 만나는 순간 다음 반복을 수행한다.
| i = 0 while i < 10: i += 1 if i % 2 == 0: continue print(i) |
# break 문 : 만나는 순간 반복문을 종료 // SQL : EXIT
| i = 0 while True: if i == 0: i = 1 elif i > 10: break print(i) i += 2 |
list( ) : 1차원 배열
x = [10,20,30]
x[2] # 30
x[-1] # 30
x[1:] # [20, 30]
x[:-1] # [10, 20]
len(x) # 리스트 변수에 입력된 값의 수
append() : 리스트 값 추가(바로적용)
extend() : 기존 리스트 변수에 다른 리스트 변수를 이어 붙이는 함수(바로적용)
insert(위치,값) : 인덱스를 이용해서 새로운 값을 입력하는 함수(바로적용)
# 리스트 변수에 있는 값 중에 마지막 값을 제거하는 방법
x[:-1] # 미리보기
del x[-1] # 리스트에서 특정한 인덱스 값을 제거(바로적용)
x.pop() # 리스트 내 마지막 값 제거(바로적용)
# 특정한 인덱스에 있는 값을 제거하는 방법(바로적용)
del w[2]
w.pop(2)
list(찾을값,시작위치인덱스(0 기본값))
index('SQL',1)
리스트 변수에서는 find 함수를 사용할 수 없다.
# 리스트 변수에 있는 값을 찾아 제거하는 방법
del x[x.index('SQL')]
x.pop(x.index('SQL'))
x.remove('SQL')
x = [1,2,3,['a','b','c'],4,5] # 중첩리스트
x[3] # ['a', 'b', 'c']
x[3][0] # 'a'
x[3][:2] # ['a', 'b']
x.clear() # 리스트 내 변수값을 지우는 함수
del x # 변수 삭제
x.sort() # 오름차순 정렬(바로적용)
x.sort(reverse=True) # 내림차순 정렬(바로적용)
sorted(x) # 오름차순 정렬(미리보기)
sorted(x,reverse=True) # 내림차순 정렬(미리보기)
x[::-1] # 역순으로 출력(미리보기)
x.reverse() # 역순으로 출력(바로적용)
tuple 튜플 : 상수처럼 사용한다. 수정할 수 없다.
x = ( )
x = (10, 20, 30)
x = 10, 20, 30
x = ('a','b',('ab','bc'))
x[2] # ('ab', 'bc')
x[2][0] # 'ab'
sorted(x) # list로 변환하여 오름차순 정렬(미리보기)
sorted(z,reverse=True) # # list로 변환하여 내림차순 정렬(미리보기)
# 튜플에서 역순으로 출력하는 방법 : 슬라이싱 활용
x[::-1]
x.index(1)
# 값을 각 변수에 분할 : 리스트, 튜플 다 가
x = 1,2,3
one, two, three = x
one, two = x[0:2]
dictionary 딕셔너리
{key1:value1, key2:value2, ...}
dic.keys()
dic.values()
dic.items()
# 키 : 값 추가
dba['key명'] = 'value'
x.get('진단') # 키가 없으면 None(null) 리턴한다.
SET 집합
인덱스가 없다. 유일한 값만 저장된다.
set( )
s = {1,1,1,2,3} # {1,2,3}
| 합집합 | x.union(y) | x | y == y | x | UNION |
| 교집합 | x.intersection(y) | x & y == y & x | INTERSECT |
| 차집합 | x.difference(y) |
x - y != y - x | MINUS |
| 대칭차집합 symmetric difference |
x.symmetric_difference(y) | x ^ y | NOT EXISTS |
| 서로소 집합 disjoint set |
{1,2,3}.isdisjoint({1,2,3}) # False |
두 집합에 공통된 원소가 '없는' 집합 | |
| 부분집합 subset |
y.issubset(x) | y⊂x y는 x의 부분집합이다. |
# 상위집합인지 확인하는 함수
x.issuperset(y) # True
# 집합에 있는 원소를 하나씩 삭제
x.remove(1)
# 집합에 하나의 값을 추가
x.add(5)
# 집합에 여러개의 값을 추가
x.update([6,7,8])
# 조건제어문에서 False 표현 방법
0
bool(0)
bool(None)
bool([])
bool('')
...
■ 파이썬 변수 복제 주의!!
- x변수와 y변수는 동일한 메모리 공간을 사용하여 서로 영향을 준다.
# 변수를 복제할 때 슬라이싱을 이용하여 복제하면 다른 메모리 공간을 사용한다.
z = x[:]
z = copy.deepcopy(x)
if 조건1:
조건1이 참값을 수행하는 부분
elif 조건2:
조건2가 참값을 수행하는 부분
...
else:
기본값
'' 공백 ≠ None(null)
isinstance(값,타입) : 변수의 타입을 체크하는 함수
# 1줄 if 문
저장변수 = 참값 if 조건 else 거짓
while 조건문:
반복 수행할 문장
# continue 문 : 만나는 순간 다음 반복을 수행한다.
# break 문 : 만나는 순간 반복문을 종료 // SQL : EXIT
'PYTHON 3.11' 카테고리의 다른 글
| 31 PYTHON isin, null, apply, str, 그룹함수, MERGE (1) | 2023.11.20 |
|---|---|
| 30 PYTHON WITH, CSV, Lambda, PANDAS, SERIES, DATAFRAME (0) | 2023.11.17 |
| 29 PYTHON Global Variable, Module, DATETIME, FILE (0) | 2023.11.16 |
| 28 PYTHON FOR, List Comprehension, FUNCTION (0) | 2023.11.15 |
| 26 PYTHON 설치, 문자열, 문자함수 (1) | 2023.11.13 |