Python) 학습 - 기본3일차(자료구조: list, tuple, dictionary, set)

 

[ 9_list ]

# 자료 구조
# 데이터와 데이터에 적용할 수 있는 함수나 명령의 모음. -> 장바구니

# 파이썬이 기본으로 제공하는 자료구조
# 1. 리스트
# 2. 튜플
# 3. 딕셔너리
# 4. 셋



# 리스트: 데이터의 추가된 순서가 유지되고 중복을 허용하는 선형 자료구조

# 리스트 생성 방법:
# [값1,값2,값3,...]
#   ^--- 원소, 요소, 항목

# 1. 생성
# - 비어있는 리스트를 생성
l = []
print(type(l), l)

# - 초기값을 사용하여 리스트를 생성
l = [1,2,3,4] # 리스트 안의 값을 원소, 요소, 항목 이라고 함.
print(type(l), l)

# 리스트 안에서 공백이나 개행 또는 탭은 무시됨.
print([1,2,3,4])
print([1, 2, 3 , 4])
print([1,
       2,
       3,
       4])

print([4,2,3,1]) # 추가된 순서가 유지 됨.
print([1,1,1,1]) # 중복 허용.

# 파이썬이 제공하는 모든 타입의 값을 저장할수 있음.
print([10,3.14,"hello",True,[1,2,3]])

# 인덱싱(indexing): 인덱스를 사용하여  특정원소를 참조하는 방법

#    0  1  2  3  4  5  6  7 <- 인덱스(index) : 첫번째 원소로부터의 거리를 나타냄.
l = [11,22,33,44,55,66,77,88] 

# 사용방법: 리스트명[인덱스]
print(l[0])
print(l[7])

# 주의! 존재하지 않는 원소에 대하여 인덱싱을 수행하면 오류가 발생
#print(l[10])






# 마지막 원소의 참조

#   -8 -7 -6 -5 -4 -3 -2 -1 <- 음수 인덱스: 원소에 대하여 역순으로 접근
#    0  1  2  3  4  5  6  7 
l = [11,22,33,44,55,66,77,88] 

print(l[7])

# len(): 자료구조 안의 원소의 개수를 돌려주는 함수
print(len(l))

# 리스트의 길이또는 원소의 개수가 N일때, 마지막 원소의 인덱스 N-1 (zero base)
print(l[len(l)-1])
print(l[-1])

# 주의! 존재하지 않는 원소에 대하여 인덱싱을 수행하면 오류가 발생
# print(l[10])
# print(l[-10])

# 슬라이싱(slicing): 인덱스를 사용하여 일부 연속된 구간이나 일정간격의 원소를 참조하는 문법

#    0  1  2  3  4  5  6  7   8
l = [11,22,33,44,55,66,77,88] 

# 사용방법: 리스트명[시작인덱스:마지막인덱스:간격]
#                              ^--------마지막 인덱스는 포함되지 않음.

print(l[1:5+1:1])
print(l[1:5+1:2])
print(l[1:-1:1])

# 리스트의 마지막 원소를 포함할겨우, 마지막 인덱스의 다음 인덱스를 사용하는 것은 안전하다.
print(l[5:8:1]) # 일반적
print(l[5:100:1]) # 더 큰값을 사용할수는 있지만, 굳이...





#    0  1  2  3  4  5  6  7   8
l = [11,22,33,44,55,66,77,88] 

#리스트 전체 구간의 slicing
print(l[0:8:1])
print(l[0:8:]) # 만약 간격이 1이면 생략가능.
print(l[0:8]) # 만약 간격이 1이면 생략가능.
print(l[0:]) # 마지막 인덱스가 list의 마지막 원소의 인덱스보다 크면 생략가능.
#print(l[0]) # 주의! 마지막 인덱스 앞의 콜론은 생략할수 없음.
print(l[:]) # 시작 인덱스가 0이라면 이를 생략할 수 있다.

#생략시의 순서는 없다.
print(l[::2]) # 인덱스 0~7+1 까지 2의 간격
print(l[5:]) # 인덱스 5~7+1 까지 1의 간격
print(l[:2]) # 인덱스 0~2 까지 1의 간격
print(l[5:0:2]) # Error ? : 비어있는 list 로 구현됨.


# 음수에 대한 슬라이싱도 가능.

#   -8 -7 -6 -5 -4 -3 -2 -1 
#    0  1  2  3  4  5  6  7 
l = [11,22,33,44,55,66,77,88] 

print(l[-1:-6:-2]) 

# 리스트 전체에 대하여 역순으로 슬라이싱하는 방법
print(l[::-1])  # l[0:8:-1] -> 예외적으로 구현됨.
print(l[-1:-9:-1])
print(l[7:-1:-1]) # Error - 비어있는 list로 나옴.


# 원소의 갱신

l =[11,22,33,44]
print(l)

# 사용방법: 인덱싱을 사용
l[0] = 0
l[-1] = 0
print(l)


# 리스트의 끝에 원소를 추가 : append(값)

l =[11,22,33,44]
print(l)
l.append(100)
print(l)

# 임의의 위치에 삽입: insert(인덱스, 값)
#    0  1  2  3
l =[11,22,33,44]
print(l)
l.insert(2,100)
print(l)

# 기존 리스트에 새로운 리스트를 추가 : extend(리스트)
l =[1,2,3]
print(l)
l2 =[11,22,33,44]
print(l2)
l.extend(l2)
print(l)


# 참고 ! "hello"

# 문자열과 마찬가지로 덧셈과 곱셈연산을 수행할 수 있음.
print([1,2,3] + [4,5,6])
print([1,2,3] * 2)

# 삭제

# 1. 인덱스를 사용한 삭제
l=[1,2,3,4]
print(l)
del l[0]
print(l)
del l[-1]
print(l)

# 2. 값을 사용한 삭제
l=["apple","banana","cherry","durian"]
print(l)
l.remove("apple")
print(l)

l=[1,2,3,4]
print(l)
l.remove(1)
print(l)

# 2. 값을 사용한 삭제 (동일한 값이 여러개인 경우)
l=["apple","banana","cherry","durian","apple","apple"]
print(l)
l.remove("apple") #  - 처음에 일치하는 1개만 삭제.
print(l)



# 추출: pop(인덱스)

l=["apple","banana","cherry","durian"]
print(l)

removed=l.pop(0) 
print(removed,l)

# 인덱스를 생략하면 마지막 원소부터 추출됨.
removed=l.pop()
print(removed,l)


# 리스트의 검색을 가장많이 사용.
# 검색

l=["apple","banana","cherry","durian","apple","apple"]
print(l)

# 1. count(값) : 전달된 값과 일치하는 모든 원소의 개수를 반환 
print(l.count("apple"))
print(l.count("cherry"))
print(l.count("orange")) # 리스트에 없는 경우, 0




l=["apple","banana","cherry","durian","apple","apple"]
print(l)

# 2. index(값) : 전달된 값과 처음으로 일치하는 원소의 인덱스가 반환 
print(l.index("apple"))
print(l.index("cherry"))
# print(l.index("orange")) # 리스트에 없는 경우, error



l=["apple","banana","cherry","durian","apple","apple"]
print(l)

# 위 리스트에 대하여 체리라는 값의 유무를 확인하는 코드.
if(l.count("cherry") > 0): 
    print(f"존재")
else:
    print(f"not 존재")     

# 멤버십 연산자: 자료구조 내에 특정값의 유무를 진리값으로 변환하는 연산자
# 사용방법: 값 in 자료구조
if "cherry" in l : 
    print(f"존재")
else:
    print(f"not 존재")       

# && , ||,   ! -> 상징적 기호는 코드는 간결해지지만, 의미가 함축적이라 가독성이 떨어짐. 이런 기호가 코드의 간결성을 떨어뜨린다고 생각함.
# and, or, not



# 정렬
l = [1,3,5,7,9,2,4,6,8]
print(l)

l.sort() # 오름차순 정렬.
print(l)

l.sort(reverse=True) # 내림차순 정렬.
print(l)

# 역순으로 재배치

l = [1,3,5,7,9,2,4,6,8]
print(l)

l.reverse() 
print(l)

 

[ 10_tuple ]

# 튜플(Tuple): 수정이 불가능한 리스트 -> 불변 리스트
# 한번 초기화되면 수정을 할 수 없는 리스트


# 비어있는 튜플 생성 소괄호: ()
t =()
print(type(t),t)

# 초기값을 사용한 생성
t = (1,2,3,4)
print(type(t),t)

print((4,2,3,1)) # 추가된 순서가 유지됨.
print((1,1,1,1)) # 중복을 허용




# 리스트와 별반 다를게 없음. # Tuple은 수정이 안됨.
# 인덱싱과 슬라이싱도 가능함.

t = (1,2,3,4)
print(t[-1])
print(t[:])


# 리스트와 다르게 튜플은 삭제나 수정딩이 불가능 
t =(1,2,3,4)
# del t[0] # Error
# t.append(100) # Error
# t[-1] = 0 # Error




# 원소가 1개인 리스트를 생각해 보자   
l = [0] 
print(type(l),l)

# int로 인식함, 이걸 Tuple로 인식해버리면, 연산자를 가지는 변수를 못만듦.(기존의 수체계가 무너짐.)
t = (0) # 사용못함.
print(type(t),t)



# 예외: 원소가 1개인 튜플을 생성하려면 원소 뒤에 쉼표를 사용해여함.
t = (0,)  # 1개인 튜플을 만들려면 원소뒤에 반드시 ,를 사용해야함.
print(type(t),t)

# t = ("A",)
# print(type(t),t)

# 쉽표로 인하여 튜플이라는것을 식별할수 있으므로 소괄호를 생략할수 있다.
t = 0,
print(type(t),t)

t = 1,2,3,4,
print(type(t),t)

# 만약 원소의 개수가 2개 이상이면 마지막 원소 다음의 쉼표는 생략할수 있음.
t = 1,2,3,4
print(type(t),t)

t = (1,2,3,4)
print(type(t),t)


t = (1,2,3,4,5)
l = [1,2,3,4,5] 

# a=t[0]
# b=t[1]
# c=t[2]
# d=t[3]
# e=t[4]

a,b,c,d,e = t # unpacking - 튜플 가능.
print(a,b,c,d,e)

a,b,c,d,e = l # unpacking  - 리스트도 가능함.
print(a,b,c,d,e)



# 주의! 원소의 개수와 변수의 개수가 일치하지 않으면 오류가 발생함.

t = (1,2,3,4,5)
#a,b,c = t #Error -  unpacking 안됨.
#print(a,b,c)
a,b,c = t[0:3] # unpacking : 변수와 원소의 개수가 동일.
print(a,b,c)

# 예외! 왼쪽의 변수가 1개인 경우 가능. (대입- 이건 uppacking이 아니라 대입 임.)
a = 1,2,3,4,5

print(a)

 

[ 11_dictionary ]

# 딕셔너리(dict): 검색에 특화된 자료구조 (영한사전 검색하는것 처럼...)
# 추가된 순서가 유지되지 않고, 중복을 허용하지 않음.

# 영한사전 : apple -> 사과
# 딕셔너리 : 키    -> 밸류

# 딕셔너리는 키-밸류를 원소로 하는 자료구조



# []: 리스트
# (): 튜플
# {}: 딕셔너리

# 비어있는 딕셔너리를 생성
d ={}
print(type(d),d)

# 초기값을 가지고 생성- 키:밸류
# 키: 주로 문자열을 사용(# 키로 정수를 쓸꺼면, 리스트나 튜플을 쓰면됨.)
# 리스트,튜플은 정수를 인덱스로 사용함. 
d ={"kor":10, "eng":20, "math":30}
#    ^-key ^--value
print(type(d),d)

# 딕셔너리는 파이썬에서 제공하는 모든 타입의 값을 저장할수 있음.
d ={"name":"daniel", "age":20, "is_adult":True, "friends":["susan","monica"]}
print(type(d),d)

# 검색
scores ={"kor":10, "eng":20, "math":30}
#scores ={"Student1":{"kor":10, "eng":20, "math":30},
#         "Student2":{"kor":11, "eng":21, "math":31},
#         "Student3":{"kor":12, "eng":22, "math":32},}
# 키를 사용하여 인덱싱을 사용
print(scores["kor"])
print(scores["eng"])

# 주의! 존재하지 않는 키에 대해서 검색을 수행하면 오류가 발생함.

# 이중 검색?
student1_scores ={"kor":10, "eng":20, "math":30}
student2_scores ={"kor":11, "eng":21, "math":31}
student3_scores ={"kor":12, "eng":22, "math":32}

all_scores={"AAA":student1_scores,"BBB":student2_scores,"CCC":student3_scores,}

# 키를 사용하여 인덱싱을 사용
print(student1_scores["kor"])
print(student2_scores["eng"])
print(all_scores["AAA"]["kor"])


# 키를 확인하는 방법
scores ={"kor":10, "eng":20, "math":30}

for key in scores:
    print(key,scores[key])

# 키값을 한번에 보는방법
print(scores.keys())
# 밸류를 한번에 보는방법
print(scores.values())
# 키와 밸류를 Tuple로 묶어서 한번에 보는방법
print(scores.items())

 

[ 12_set ]

# 셋(set): 수학의 집합의 개념을 제공하는 자료구조
# 중복을 허용하지 않고 추가된 순서도 유지되지 않음


# []:리스트
# ():튜플
# {}:딕셔너리
# 셋은 자신을 표현하는 기호가 없음

# 비어있는 셋을 생성
s = set()
print(type(s),s)

# 초기값을 가지고 생성 
s = {1,2,3,4} # 셋은 딕셔너리의 기호를 공유합니다. (: 이 없기 때문에 가능.)
print(s)

print({4,2,1,3}) # 추가된 순서가 유지 되지 않음 - 오름차순으로 정렬됨.
print({1,1,1,1}) # 중복도 허용하지 않음.

# 파이썬이 제공하는 모든 타입의 값을 저장할수 있음.
print({10,3.14,"hello",True})

# 추가된 순서가 유지되지 않기 때문에 인덱싱이 불가능
s = {1,2,3,4}
# print(s[0]) # Error


# 데이터 집합이 있는데, 중복을 제거할때 사용.
s = "hello, world"
print(set(s))

# 집합 연산
# 1. 교집합
# 2. 합집합
# 3. 차집합
a = {1,2,3,4}
b = {3,4,5,6}

print (a & b) #교집합
print (a | b) #합집합
print (a - b) #차집합