81일차 2023-07-03

Python

 

list2.py

print('[리스트의 주요 메소드]')
print('1.append():마지막 요소 다음에 추가')
a=[1,(2),3]
a.append(4)
a.append(1)#중복 저장가능
a.append(['가','나'])
print(a)
a[len(a)-1]=['A','B']
print(a)
#print(a[len(a)])#IndexError: list index out of range
a[0]=10
print(a)
print(a[len(a):])#[] 수정시에는 out of range이나 인덱스 범위를 벗어나서 읽어올때는 []다
#a[len(a)]=10#index out of range
#a[len(a):]=10#TypeError: can only assign an iterable
a[len(a):]=[10,20]#정상.  -> 의미는 마지막방 다음에 새로운요소 추가. 구조분해되서 각 객체가 하나의 요소로 추가된다
print(a)
a.append([10,20])#리스트가 하나의 요소로 추가
print(a)
print('2.extend():리스트 확장')
b=[1,2,3]
b.extend([4,5])#기존 리스트를 확장한다 즉 이터러블한 객체의 하나의 요소가 하나의 요소가 된다.반드시 인자가 iterable 한 객체여야한다
print(b)
#b.extend(6)#TypeError: 'int' object is not iterable.append는 int형도 가능(즉 not iterable가능)
print('3.insert(인덱스,요소):기존 인덱스 위치에 요소 삽입')
c=[1,2,3]
c.insert(0,0)#0번 인덱스에 0요소 삽입
print(c)
c.insert(100,'가길동')#인덱스 범위를 벗어난 경우 무조건 마지막방 다음 즉 append()와 같다
print(c)
c.insert(2,(3.14,2.8))
print(c)
print('4.copy():리스트 복사')
'''
d=c
print(f'c의 주소:{id(c)},d의 주소:{id(d)}')
d[0]=100
print(c,d,sep=' : ')
'''
d=c.copy()
print(f'c의 주소:{id(c)},d의 주소:{id(d)}')
d[0]=100
print(c,d,sep=' : ')
print('5.remove(요소):요소 삭제')
e=[1,2,3,4,5,2]
print(e.remove(4))#반환값이 없다.None
print(e)
e.remove(2)#동일한 객체를 삭제하는 경우 인덱스가 작은 요소가 삭제됨
print(e)
print('------------------')
for element in e:
    if element ==5:
        e.remove(5)
print('순회하면서 요소 비교후 삭제:',e)

print('6.pop([요소]):요소 삭제')
#pop()는 리스트의 마지막 요소삭제.반환값은 삭제한 요소
#pop(인덱스) : 인덱스에 헤당하는 요소 삭제.
f=[1,2,3,4,5,2]
print(f.pop())
print(f)
print(f.pop(2))
print(f)
print('7.del 리스트객체[슬라이싱]:특정 구간의 요소들 삭제')
#변수 삭제시 : del 변수명
#del f #f라는 이름의 메모리 삭제
#print(f)#NameError: name 'f' is not defined
#del f[1:3]
#print(f)
#del f[:]#f.clear()와 같다
f.clear()
print(f)#[]

print('8.index(요소):해당 요소의 인덱스 반환')
g=['가','나','다','나']
print('---------')
print(g.index('나'))
#list객체에는 rindex()메소드가 없다
#print(g.rindex('나'))#AttributeError: 'list' object has no attribute 'rindex'. Did you mean: 'index'?
#g.index('바')#ValueError: '바' is not in list
print('-----------')
if '바' in g:
    print(g.index('바'))
print('9.count(요소):해당 요소의 빈도수 반환')
print(g.count('나'))
print('10.reverse():요소들을 거꾸로 재 배치')
g.reverse()#in place방식:원본이 변한다
print(g)
print('11.sort():요소들을 오름차순으로 정렬')
g.sort()#in place방식
print(g)#디폴트는 오름 차순
g.sort(reverse=True)#내림차순
print(g)
#리스트의 산술 연산 : +와 *만 가능
x=[1,2,3]
y=['가','나','다']
print(x+y)#원본은 변하지 않는다
print(x)
print(x.extend(y))#x가 확장되서 변한다
print(x)
print(y*3)
#in (not in)  연산자 : 리스트에 요소의 존재여부를 파악할 수 있다
z=[1,2,3]
print(4 not in z)
print(1 in z)

결과)

list3.py

print('[리스트 표현식(축약,내포) 미 사용]')
#방법1 - for문 사용
a=[]
for k in range(5):
    a.append(k)
print(a)
#방법2 - list생성자 사용
#a=list(5)#TypeError: 'int' object is not iterable
#a=list(0,1,2,3,4)#TypeError: list expected at most 1 argument, got 5
#a=list((0,1,2,3,4))# 요소(int타입)가 5개인 리스트
a=list(range(5))# 요소(int타입)가 5개인 리스트
for e in a:
    print(e)
a=[range(5)]#[range(0, 5)] 요소(range타입)가 하나인 리스트
for e in a:
    #print(e)#range(0, 5)
    for r in e:
        print(r)
print(a)

print('[리스트 표현식(축약,내포) 첫번째 : [리스트 표현식]')
#순서:range(5) -> for문 안의 i -> for문 앞의 식 :i
#설명:숫자 0부터 4까지 생성(range(5))하여 for문 안의 i에 담고 그 i를 이용해서 식을 만들고
#그 식에 따라 리스트의 요소가 하나씩 생성된다
a=[i for i in range(5)]#list(range(5))와 동일하다
print(a)

a=[i+2 for i in range(5)]#list(range(5))로는 불가능.map을 사용해야 한다
print(a)
a= list(map(lambda x:x+2,range(5)))#[i+2 for i in range(5)]와 같다
print(a)
mask=[i % 2==0 for i in range(5)]#[True, False, True, False, True]
print(mask)
print([v for v,m in zip(a,mask) if m])#mask용 리스트를 사용해서 a의 요소중 짝수만으로 리스트 생성

print('[리스트 표현식(축약,내포) 두번째 : list(리스트 표현식)')
a=list(i+2 for i in range(5))
print(a)
mask=list(i % 2==0 for i in range(5))
print(list(v for v,m in zip(a,mask) if m))

print('[리스트 표현식(축약,내포) 세번째 : [식 for 변수 in 반복가능한객체 if 조건식]]')
#순서:range(10) -> for문 안의 i -> for문 다음의 if문 ->if문이 참인 경우 식이 실행되서
# 요소가 하나 만들어진다
#설명:숫자 0부터 9까지 생성하여 i에 저장하고 그 i가 2의 배수이면 for문 앞의
# 식이 실행되서 요소가 만들어진다
a=[i for i in range(10) if i % 2==0]#else문 불가
print(a)
a=[i for i in range(10) if i % 2==0 and i > 5]
print(a)

b=[]
for i in range(2,10):
    for k in range(1,10):
        b.append(i*k)
print(b)

#위를 리스트 표현식으로
#for i in range(2,10)는 바깥 for문 .for k in range(1,10)는 안쪽 for문이 된다
a=[i*k for i in range(2,10) for k in range(1,10)]
print(a)

#먼저 리스트 표현식부터 작성
a=[i * k for i in range(2,10) if i==9 for k in range(1,10) if k==9 ]
print(a)

#위 리스트 표현식을 for으로 풀면
a=[]
for i in range(2,10):
    if i == 9:
        for k in range(1, 10):
            if k == 9:
                a.append(i*k)
print(a)

결과)

list4.py

print('[리스트와 함께 쓰는 빌트인 함수(내장함수)]')
'''
min(반복가능한 객체(iterable)) : 요소중 최소값 반환
max(반복가능한 객체(iterable)): 요소중 최대값 반환
sum(반복가능한 객체(iterable)): 요소의 총합 반환
※위 함수들을 사용할때 반복가능한 객체의 요소들은 반드시 숫자 나 bool값 이어야한다
map(함수, 반복가능한객체):반복 가능한 객체의 요소를 첫번째 인자로 지정된 함수로 처리한 뒤 
map객체(이터레이터)를 반환
예) list(map(str, [1, 2]))는 ['1', '2']반환
'''
a=[10,5,15,50,True,False,-5.5]
print('[요소 중 최대값 구하기-방법1]')
max_ =a[0]
for e in a[1:]:
    if e > max_:
        max_ = e
print('최대값:',max_)
print('[요소 중 최대값 구하기-방법2]')
a.sort(reverse=True)
print('최대값:',a[0])
print('[요소 중 최대값 구하기-방법3]')
print('최대값:',max(a))
print('최소값:',min(a))
print('총합:',sum(a))

b= [True,100,5,'5']
#print(sum(b))#TypeError: unsupported operand type(s) for +: 'int' and 'str'
#c=[int(i) for i in b]
c=map(int,b)
print(sum(c))
#1부터 100까지 숫자 중 짝수의 갯수는?
d=list(range(1,101))
mask = [i % 2==0 for i in d]
print('짝수의 갯수:',sum(mask))

f=[3.14,5.99,8.88,1.24]
#리스트의 모든 요소를 정수로 변환하기
#for문 시용 첫번째-원본 불 변경.새로운 리스트 생성
'''
e=[]
for element in f:
    e.append(int(element))
print(e)
'''
'''
#for문 시용 두번째-원본 변경
for index,element in enumerate(f):
    f[index]=int(element)
print(f)
'''
#리스트 축약-원본 불변.새로운 리스트 생성
g=[int(ele) for ele in f]
print(g)
#map함수 사용-원본 불변.새로운 리스트 생성
g=list(map(int,f))
print(g)

#세개의 숫자를  공백을 기준으로 input()함수로 입력받고,
s=input('세 개의 숫자를 입력(공백구분)?')
#각각의 입력받은 값을 공백을 기준으로  split(구분자)한다,
k=s.split()
#그리고 리스트의 각 요소를 int로 변환하고 list로 만들어,
k=list(map(int,k))
#언패킹을 이용해서 세개의 변수(x,y,z)에 저장하고,
x,y,z =k
#세 숫자의 합을 출력하여라
print('세 숫자의 합:',x+y+z)

print('세 숫자의 합:',sum(list(map(int,input('세 개의 숫자를 입력(공백구분)?').split()))))

결과)

 

list5.py

print('[2차원 리스트]')
#바깥쪽 []는 리스트를 의미
#안쪽 []의 수: 행의 수
#안쪽 []의 값(요소)의 수 :열의 수
a=[
    [1,2],[3,4],[5,6]
]#3행 2열 리스트
print('value:{},type:{}'.format(a,type(a)))

#행의 수: len(리스트객체) 즉 요소 수
#열의 수: len(리스트객체[행인덱스]) 즉 요소인 리스트의 요소수
print(f'행의 수:{len(a)}')
print(f'0행의 수:{len(a[0])}')
print(f'1행의 수:{len(a[1])}')
print(f'2행의 수:{len(a[2])}')

print('[2차원 리스트의 각 요소 읽기(인덱싱)]')
print('0행 0열:',a[0][0])
print('0행 1열:',a[0][1])
print('2행 1열:',a[2][0])
print('2행 1열:',a[2][1])
print('[2차원 리스트의 각 요소 수정]')
a[0][0]=10
a[2][1]=60
print(a)
print('[2차원 리스트의 각 요소 읽기-for문 사용 첫번째]')
#각 행의 열의 수가 같을때(언패킹-요소수와 변수의 수가 같아야 한다)
for x,y in a:
    print(x,y)
print('[2차원 리스트의 각 요소 읽기-for문 사용 두번째]')
#각 행의 열의 수가 다를때
b=[[1,2],[3,4,5,6],[5,6,7]]
for x in b:
    for y in x:
        print(y,end=' ')
    print()
print('[2차원 리스트의 각 요소 읽기-for문 사용 세번째]')
#각 행의 열의 수가 다를때
for i in range(len(b)):#i는 행번호
    for k in range(len(b[i])):#k는 열번호
        print(f'{i}행{k}열:{b[i][k]}',end = ' ')
    print()
#문]위 2차원 리스트를 while문으로 출력하여라.

print(['while문-열의 수가 같을때(a)'])
i=0
while i < len(a):
    x,y = a[i]
    print(x,y)
    i+=1

print(['while문-열의 수가 다를때(b)'])
i=0
while i < len(b):
    j=0
    while j < len(b[i]):
        print(b[i][j],end=' ')
        j+=1
    i+=1
    print()

 

결과)

 

tuple1.py

def pprint(obj):
    #bool타입은 int타입으로도 체크 가능
    end = '\n' if isinstance(obj,int) or isinstance(obj,float) else ''
    print(f"값:{obj},타입:{type(obj)}",end=end)
    if not isinstance(obj,int) and not isinstance(obj,float):
        print(f',요소 수:{len(obj)}')

print('[튜플 생성 첫번째 : 빈 튜플]')#동적으로 요소 추가시 주로 사용
#방법1-()list1.py
a=()
pprint(a)
#방법2-tuple():tuple클래스의 생성자
a=tuple()
pprint(a)
print('[튜플 생성 두번째 : 요소가 하나인 튜플]')
b=(1)
pprint(b)
b=(1,)#혹은 1,
pprint(b)
print('[튜플 생성 세번째 : 같은 타입의 객체(요소) 저장]')
b=1,2,3,4,5#혹은 b=(1,2,3,4,5) 즉 ()생략 가능.변수 하나에 여러개 데이타 설정:패킹
pprint(b)
print('[튜플 생성 네번째 : 다른 타입의 객체(요소) 저장]')
c='가길동',20,3.14,True
pprint(c)
print('[튜플 언 패킹(구조분해)]')
#튜플의 각 요소를 여러 변수에 나눠 담는 것:언패킹(구조분해)
#단, 변수의 개수가 요소의 개수와 정확히 일치해야 한다
c1,c2,c3,c4 = c
pprint(c1)
pprint(c2)
pprint(c3)
pprint(c4)#isinstance(a,int) int타입으로도 처리된다
print('[튜플 생성 다섯번째 : tuple(str객체)]')
tuple_=tuple('PYTHON')
pprint(tuple_)
print('[튜플 생성 여섯번째 : tuple(range객체)]')
tuple_ = tuple(range(5))
pprint(tuple_)

#c[0]=100#TypeError: 'tuple' object does not support item assignment

print('[인덱싱:튜플객체[인덱스]]')
print(f'b[0]:{b[0]},b[1]:{b[1]},b[2]:{b[2]}')
print(f'요소 수 얻기:{len(b)}')
print('[슬라이싱:인덱스를 사용해서 특정 범위의 요소들 추출]')
#[시작인덱스:끝인덱스] - 시작인덱스부터  끝인덱스-1까지
print(b[1:1])#빈 튜플.슬라이싱 방향이 왼쪽임으로(1부터 0으로)
print(b[1:3])#(1,2)
print(b[1:-3])#빈 튜플
print(b[-1:-3])#빈 튜플
#[:끝인덱스] -  처음부터 끝인덱스-1까지
print(b[:0])#빈 튜플
print(b[:-1])#(1,2,3,4)
#[시작인덱스:] -  시작인덱스부터 끝까지
print(b[0:])#(1,2,3,4,5)
print(b[-len(b):])#(1,2,3,4,5)
#[:] -  모든 요소 슬라이싱
print(b[:])#(1,2,3,4,5)

f='가','나','다','라'
for e in f:
    print(e)

for index in range(len(f)):
    print(f'인덱스:{index},요소:{f[index]}')
print('-'*30)
for index,ele in enumerate(f):
    print(f'인덱스:{index},요소:{ele}')

 

결과)

tuple2.py

print('[튜플의 주요 메소드]')

c=1,2,3
print('1.copy():튜플 복사')
'''
d=c
print(f'c의 주소:{id(c)},d의 주소:{id(d)}')
print(c,d,sep=' : ')
'''
#d=c.copy()#tuple에는 copy()없다
print('2.index(요소):해당 요소의 인덱스 반환')
g='가','나','다','나'
print(g.index('나'))
if '바' in g:
    print(g.index('바'))
print('3.count(요소):해당 요소의 빈도수 반환')
print(g.count('나'))
#튜플에 없는 메소드 사용시에는 tuple을 리스트로 변경후 사용하자
g=list(g)#리스트로 변경
g.sort()#리스트의 메소드 적용
print('리스트로 변경후 정렬:',g)
#튜플의 산술 연산 : +와 *만 가능
x=1,2,3
y='가','나','다'
print(x+y)#원본은 변하지 않는다
print(x)
print(y*3)
print(y)
#in (not in)  연산자 : 튜플에 요소의 존재여부를 파악할 수 있다
z=1,2,3
print(4 not in z)
print(1 in z)

 

결과)

 

tuple3.py

#리스트는  a=[표현식] 혹은 a=list(표현식)
#튜플은   a=tuple(표현식)형식으로 하자
#a=(표현식)은 튜플이 아니고 <generator object <genexpr> at 0x00D15DB0>즉 제너레이터객체 반환
print('[튜플 표현식(축약,내포) 첫번째 : tuple(표현식)')
a=(i for i in range(5))
print(f'value:{a},type:{type(a)}')

#방법1 - tuple생성자 사용
a=tuple(i for i in range(5))#tuple(range(5))와 같다
print(f'value:{a},type:{type(a)}')


a=tuple(i+2 for i in range(5))#tuple(range(5))로는 불가능.map을 사용해야 한다
print(a)
a= tuple(map(lambda x:x+2,range(5)))#tuple(i+2 for i in range(5))와 같다
print(a)
mask=tuple(i % 2==0 for i in range(5))#(True, False, True, False, True)
print(mask)
print(tuple(v for v,m in zip(a,mask) if m))#mask용 튜플을 사용해서 a의 요소중 짝수만으로 튜플 생성

print('[튜플 표현식(축약,내포) 두번째 : tuple(식 for 변수 in 반복가능한객체 if 조건식)]')

a=tuple(i for i in range(10) if i % 2==0)#else문 불가
print(a)
a=tuple(i for i in range(10) if i % 2==0 and i > 5)
print(a)

b=[]
for i in range(2,10):
    for k in range(1,10):
        b.append(i*k)
print(tuple(b))

#위를 튜플 표현식으로
#for i in range(2,10)는 바깥 for문 .for k in range(1,10)는 안쪽 for문이 된다
a=tuple(i*k for i in range(2,10) for k in range(1,10))
print(a)

#먼저 튜플 표현식부터 작성
a=tuple(i * k for i in range(2,10) if i==9 for k in range(1,10) if k==9)
print(a)

#위 튜플 표현식을 for으로 풀면
a=[]
for i in range(2,10):
    if i == 9:
        for k in range(1, 10):
            if k == 9:
                a.append(i*k)
print(tuple(a))

 

결과)

 

tuple4.py

print('[튜플과 함께 쓰는 빌트인 함수(내장함수)]')
'''
min(반복가능한 객체(iterable)) : 요소중 최소값 반환
max(반복가능한 객체(iterable)): 요소중 최대값 반환
sum(반복가능한 객체(iterable)): 요소의 총합 반환
※위 함수들을 사용할때 반복가능한 객체의 요소들은 반드시 숫자 나 bool값 이어야한다
map(함수, 반복가능한객체):반복 가능한 객체의 요소를 첫번째 인자로 지정된 함수로 처리한 뒤 
map객체(이터레이터)를 반환
예) tuple(map(str, (1, 2)))는 ('1', '2')반환
'''
a=10,5,15,50,True,False,-5.5
print('[요소 중 최대값 구하기-방법1]')
max_ =a[0]
for e in a[1:]:
    if e > max_:
        max_ = e
print('최대값:',max_)
print('[요소 중 최대값 구하기-방법2]')
b = list(a)
b.sort(reverse=True)
print('최대값:',b[0])
print('[요소 중 최대값 구하기-방법3]')
print('최대값:',max(a))
print('최소값:',min(a))
print('총합:',sum(a))

b= True,100,5,'5'
#print(sum(b))#TypeError: unsupported operand type(s) for +: 'int' and 'str'
#c=tuple(int(i) for i in b)
c=map(int,b)
print(sum(c))
#1부터 100까지 숫자 중 짝수의 갯수는?
d=tuple(range(1,101))
mask = tuple(i % 2==0 for i in d)
print('짝수의 갯수:',sum(mask))

f=3.14,5.99,8.88,1.24
#튜플의 모든 요소를 정수로 변환하기-원본 튜플은 불변(immutable)
#for문 시용 첫번째-원본 불 변경.새로운 리스트 생성
'''
e=[]
for element in f:
    e.append(int(element))
print(tuple(e))
'''

#튜플 축약-원본 불변.새로운 튜플 생성
g=tuple(int(ele) for ele in f)
print(g)
#map함수 사용-원본 불변.새로운 리스트 생성
g=tuple(map(int,f))
print(g)

#세개의 숫자를  공백을 기준으로 input()함수로 입력받고,
s=input('세 개의 숫자를 입력(공백구분)?')
#각각의 입력받은 값을 공백을 기준으로  split(구분자)한다,
k=s.split()
#그리고 리스트의 각 요소를 int로 변환하고 tuple로 만들어,
k=tuple(map(int,k))
#언패킹을 이용해서 세개의 변수(x,y,z)에 저장하고,
x,y,z =k
#세 숫자의 합을 출력하여라
print('세 숫자의 합:',x+y+z)

print('세 숫자의 합:',sum(tuple(map(int,input('세 개의 숫자를 입력(공백구분)?').split()))))

 

결과)

 

tuple5.py

print('[2차원 튜플]')
#바깥쪽 ()는 튜플을 의미
#안쪽 ()의 수: 행의 수
#안쪽 ()의 값(요소)의 수 :열의 수
a=(
    (1,2),(3,4),[5,6]
)#3행 2열 리스트
print('value:{},type:{}'.format(a,type(a)))

#행의 수: len(튜플객체) 즉 요소 수
#열의 수: len(튜플객체[행인덱스]) 즉 요소인 튜플의 요소수
print(f'행의 수:{len(a)}')
print(f'0행의 수:{len(a[0])}')
print(f'1행의 수:{len(a[1])}')
print(f'2행의 수:{len(a[2])}')

print('[2차원 튜플의 각 요소 읽기(인덱싱)]')
print('0행 0열:',a[0][0])
print('0행 1열:',a[0][1])
print('2행 1열:',a[2][0])
print('2행 1열:',a[2][1])
print('[2차원 튜플의 각 요소 수정]')
#a[0][0]=10  요소가 튜플이니까
a[2][1]=60
print(a)
print('[2차원 튜플의 각 요소 읽기-for문 사용 첫번째]')
#각 행의 열의 수가 같을때(언패킹-요소수와 변수의 수가 같아야 한다)
for x,y in a:
    print(x,y)
print('[2차원 튜플의 각 요소 읽기-for문 사용 두번째]')
#각 행의 열의 수가 다를때
b=((1,2),(3,4,5,6),(5,6,7))
for x in b:
    for y in x:
        print(y,end=' ')
    print()
print('[2차원 튜플의 각 요소 읽기-for문 사용 세번째]')
#각 행의 열의 수가 다를때
for i in range(len(b)):#i는 행번호
    for k in range(len(b[i])):#k는 열번호
        print(f'{i}행{k}열:{b[i][k]}',end = ' ')
    print()
#문]위 2차원 튜플를 while문으로 출력하여라.

print(['while문-열의 수가 같을때(a)'])
i=0
while i < len(a):
    x,y = a[i]
    print(x,y)
    i+=1

print(['while문-열의 수가 다를때(b)'])
i=0
while i < len(b):
    j=0
    while j < len(b[i]):
        print(b[i][j],end=' ')
        j+=1
    i+=1
    print()

 

결과)

 

dict1.py

#{key:value}를 사용해서 딕션너리 만들때는
#키가 문자열인 경우에는 반드시 ' 나 "로 키를 감싼다
import pprint


#dict(key=value)를(생성자) 사용해서 딕션너리 만들때는
#키가 문자열인 경우라도 ' 나 "로 키를 감싸면 안된다

def pprint(obj):
    print(f'value:{obj},type:{type(obj)},len:{len(obj)}')

print('[딕셔너리 생성 첫번째 : 빈 딕셔너리]')
a=dict()#혹은 {}
pprint(a)
print('[딕셔너리 생성 두번째 : {키:값,....}]')
#키 혹은 값이 문자열이면 반드시 ''나 ""로 감싸야 한다
a={'name':'가길동','age':20,'addr':'가산동',1:'1강의실'}
pprint(a)
#키값이 중복되는 경우 나중에 지정한 키값이 저장된다.
a={'name':'가길동','age':20,'addr':'가산동',1:'1강의실','age':30}
pprint(a)
print('[딕셔너리 생성 세번째 : {키:값,....}]')
#키는 리스트와 딕셔너리를 제외한 모든 자료형이 키가 될 수있다
a={1:'one',(2,):'two',False:0,3.14:['파이','PI']}
pprint(a)
#{['PI']:3.14}#TypeError: unhashable type: 'list'
print('[딕셔너리 생성 네번째 : dict(키=값,키1=값1,...)]')
#dict(키 = 값)함수 사용시 키는 '',""로 감싸면 에러
#또한 이때 int/float/bool타입은 키로 사용 불가
#dict(1='one')#SyntaxError
a=dict(name='가길동',age=20,addr='가산동')
pprint(a)
print('[딕셔너리 생성 다섯번째 : dict([[요소1,요소2],[요소1,요소2],..])]')
#리스트[]나 튜플()를 딕셔너리로 만들때는 dict([(),[],()...]) 혹은dict(([],(),[]...))
#단, 바깥 딕션너리의 안의 []나()의 요소수는 반드시 두 개여야한다(2 is required)
#왜냐하면 하나는 키가 되고 하나는 밸류가 되어야 하니까
#리스트를 딕션너리로 변환
a=dict([('name','가길동'),('age',20),('addr','부산'),('tel','010')])
#튜플을 딕션너리로 변환
a=dict((('name','가길동'),['age',20],('addr','부산'),['tel','010']))
pprint(a)
print('[딕셔너리 생성 여섯번째 : dict(zip())]')
#zip함수를 이용해서 dict만들때 zip함수의 인자는 반드시 반복가능한 객체가 2개가 와야 한다
#첫번째는 키가 되고 두번째는 밸류가 된다
#반복가능한 객체의 요소수가 동일하지 않으면, 적은 요소를 가진 객체를 기준으로
#딕션너리가 만들어진다
'''
zip([키1,키2,키3,...],[값1,값2,값3,...]):(키1,값1),(키2,값2),(키3,값3),..를 요소로 갖는 zip객체 반환
dict(zip((키1,키2,키3,...),(값1,값2,값3,...))):키값들을 키로 값들을 값으로 갖는 딕셔너리 생성
dict([[요소1,요소2],[요소1,요소2],[요소1,요소2],...]):요소1을 키로 요소2를 값으로 갖는 딕셔너리 생성
'''
d = dict(zip(('name','age','addr'),['다길동',30,'청담동']))
pprint(d)
d = dict(zip(('name',),['다길동',30,'청담동']))
pprint(d)
print('[딕셔너리 읽기 - 딕셔너리객체[키] 혹은 딕셔너리객체.get(키,[기본값])]')
f=dict(zip((3.14,1,False,'과목'),(['파이','PI'],'일','거짓','파이썬')))
print(f)
print(f[3.14])
print(f[1])
print(f[False])
print(f['과목'])
#print(f['파이'])#KeyError: '파이'
print(f.get('파이'))#None
print(f.get('파이',3.14))
print('[딕셔너리 값 할당하기 - 딕셔너리객체[키]=값]')
#딕셔너리는 리스트처럼 mutabble하다
f[3.14]='파이',
f[1]='하나'
f['코스모']='한소인'#없는 키는 키가 새롭게 추가됨
pprint(f)

 

결과)

 

dict2.py

print('[딕셔너리의 주요 메소드]')
print('1. setdefault("키") 혹은 setdefault("키",기본값): 키 추가 메소드')
a={'name':'가길동','age':20,'addr':'천호동'}
a.setdefault('tall')#a['tall']=None와 같다
a.setdefault('weight',45)#a['weight']=45
#a.setdefault('age',30)#기존 키가 존재하는 경우 의미 없다(변화 없다)
a['age']=30#기존 키 존재하는 경우 수정시에는 setdefault('age',30)가 아니고 [기존 키]= 수정값
print(a)
print('2. update(키=수정값):값 수정용 메소드')
a.update(age=45)#a['age']=45와 같다
a.update(tel='010-1234-5678')#a['tel']='010-1234-5678'와 같다.즉 없는 키일때는 추가된다
print(a)
print('3. pop("키") 혹은 pop("키",기본값):키에 해당 하는 요소 삭제 메소드')
#삭제한 키의 밸류값 반환
#pop(키) : 키에 해당하는 요소 삭제 만약 키가 없다면 에러발생(KeyError)
#pop(키,기본값):키가 없으면 에러 발생하지 않고 그냥 기본값 반환
print(a.pop('weight'))#del a['weight']
del a['tel']
print(a)
#print(a.pop('weight'))#KeyError: 'weight'
print(a.pop('weight','키가 없어요'))
print('4. popitem():마지막 요소 삭제')
#삭제된 요소를 튜플로 반환:(키,값)
print(a.popitem())#('tall', None)
print('5.clear():전체 요소 삭제')
a.clear()
print(a)#{}
b=dict(institue='한국 소프트웨어 인재개발원',loc='가산디지털단지역',course='AI')
print(b)
print('6. copy() : 딕셔너리 복제')
c = b.copy()
print(f'b의 주소:{id(b)},c의 주소:{id(c)}')
print(c)
print('7.get(키) 혹은 get(키,기본값) : 키로 값 가져오기')
print(b.get('loc'))
print(b.get('location'))#None반환
print(b.get('location','키가 없어요'))
print('8. items()/keys()/values() 함수')
print(type(b.items()))#<class 'dict_items'>
print(b.items())
print(list(b.items()))
for key,value in b.items():
    print(key,value,sep=':')
print(b.keys())
for key in b.keys():
    print(key)
print(b.values())
for value in b.values():
    print(value)

print('9. dict.fromkeys(리스트나 튜플) 혹은 dict.fromkeys(리스트나 튜플,값)')
#리스트나 튜플의 요소를 키로 사용하여 딕셔너리를 만드는 함수(클래스 메소드)
#dict.fromkeys(리스트나 튜플)는 키에따른 값은 모두 None
#dict.fromkeys(리스트나 튜플,값)는 키에따른 값은 모두 두번째 인자에 지정한 값
print(dict.fromkeys(list(range(1,6))))
print(dict.fromkeys(list(range(1,6)),100))

 

결과)

dict3.py

#in (not in)  연산자 : 딕션너리에 적용시 딕션너리에 [키의 존재여부]를 파악할 수 있다
print('[딕셔너리에 in/not in연산자 적용]')
a=dict(zip(('name','age','addr','tel'),['홍길동',20,'가산동','010']))
print(a)
print('tall' in a)
print('tall' not in a)
print('name' in a)
print(True if 'age' in a else False)
print('[for문에 딕셔너리 객체 적용]')
for key in a:#a.keys()와 같다 즉 무조건 키를 추출
    print(key)
    value = a.get(key)
    print(key,value,sep=':')

for key,value in a.items():
    print(key, value, sep=':')
# for문으로 값을 찾아서 딕셔너리 요소 삭제하면 에러가 발생
# 즉 iteration하는동안 요소를 삭제하면 크기가 변하기때문에..
'''
for key,value in a.items():
    if value== '홍길동':
        #del a[key]#RuntimeError: dictionary changed size during iteration
        a.pop(key)#RuntimeError: dictionary changed size during iteration
'''
#딕셔너리에서 값으로 찾아서 요소 삭제
#요소 하나 삭제시
'''
key_ = None
for key,value in a.items():
    if value== '홍길동':
        key_= key
#iteration 끝난 후 삭제
del a[key_]
print(a)
'''
#여러 요소 삭제시
#문]키가 'tel'인 요소만 제외하고 모든 요소를 삭제하시오

keys=[]
for key,value in a.items():
    if key != 'tel':
        keys.append(key)
for key in keys:
    del a[key]
print(a)

결과)

 

dict4.py

#딕션너리 표현식:기존 딕션너리 객체로 새로운 딕션너리 객체를 생성할때 주로 사용한다
'''
{키:값  for 키[, 값 ] 혹은 [키,]값    in 기존딕션너리객체.items() }
{키:값  for 키[, 값] 혹은 [키,]값   in 기존딕션너리객체.items() if 조건식}

dict({키:값  for 키[, 값 ] 혹은 [키,]값  in 기존딕션너리객체..items()})
dict({키:값  for 키[, 값 ] 혹은 [키,]값  in 기존딕션너리객체..items() if 조건식})
※딕션너리 표현식으로
특정 값을 기준으로 딕션너리를 다시 생성하는 방식으로 삭제 효과를 구현할 수 있다
'''
print('[딕셔너리 표현식 첫번째 - {표현식}')
keys=list('ABCD')#['A', 'B', 'C', 'D']와 같다
a=dict(zip(keys,['Able','Banana','Card','Danger']))
print(a)
#무조건 모든 값을 'python으로 변경
b={key:'python' for key in a}
print(b)
#모든 값을 소문자_로 변경
b={key:value.lower() for key,value in a.items()}
print(b)
#값을 키로 사용하고 기존 값은 소문자로 변경해서 다시 값으로 사용
print({value:value.lower() for value in a.values()})
print('[딕셔너리 표현식 두번째 - dict({표현식})')
b=dict({key:value.lower() for key,value in a.items()})
print(b)
c=dict(zip(['name','age','addr','tel'],['홍길동',20,'가산동','010']))
#딕셔너리 표현식으로 삭제효과 구현하기(원본이 변경이 안됨)
#dict3.py의 여러 요소 삭제를 딕셔너리 표현식으로 똑같이 구현
print({key:value for key,value in c.items() if key =='tel'})

 

결과)