[파이썬] 복습 노트 - 7 | 함수와 메소드(method) / 컬렉션의 메소드

내 머리속 어딘가 2025. 1. 25. 23:33

함수와 메소드

함수

- 어떠한 기능을 하는 것
- 함수명 뒤에 ()
- 함수의 결과 값을 다른 변수에 대입할 수 있음
- 단독으로 사용할 수 있음

ex)
name = input("이름 입력 : ")
print("출력")

메소드

- 어떠한 기능을 하는 것
- 메소드명 뒤에 ()
- 객체(Object)와 함께 지정되어야 함
객체명.메소드명()
- 특정 객체에 속해있는 함수

ex) 
str1 = "abc"
str1.count("a") # => str1에서 "a"가 몇개 있는지 count

함수와 메소드의 차이점

- 함수는 단독으로 사용 가능
- 메소드는 객체명 뒤에 .(피리오드)를 붙여서 사용

** 나중에 클래스를 배우고 알게된 내용

메소드는 클래스 내부에 있는 함수라는 사실을 알게 되었다.

예를 들어서

Class라는 클래스를 만들고,

그 내부에 print_class()라는 함수를 넣었다고 가정해보자.

위와같이 클래스 내부에 있는 함수를 메소드라고 한다.

그리고 클래스의 메소드를 사용할 때도 클래스변수 뒤에 .(피리오드)메소드명() 이렇게 작성한다.

앞서 얘기한 메소드와 다른거 아닌가?

라는 생각이 든다면 클래스에 대해서 생각해보자!

클래스를 만드는 이유는 뭘까?

정답이 아닐 수 있지지만 내 생각에는

어떤 공통된 형식으로, 비슷한 형태의 변수들을 만들기 위해서라고 생각한다.

그렇다면 기본자료형들과 컬렉션들도 클래스와 같은 개념으로 볼 수 있지 않을까?

내장 클래스??같은 느낌?

나는 저런 것들도 넓은 의미에서 이들이 모두 클래스라고 생각하였다.

그렇게 생각하고나니 위에서 말하고있는 메소드가 어떤 개념인지,

왜 객체명 뒤에 붙어서 따라오는지가 이해가 더 잘되었다.

메소드는 그냥 함수이다. 그렇지만 특정 클래스(타입)에서만 사용할 수 있는!

그러니까 예를 들어 리스트에서 사용하는 메소드는

리스트라는 타입(클래스)에서 사용할 수 있는 함수라는 의미로 보면 될 것 같다.

컬렉션의 메소드

1. 리스트

.append(값)	리스트의 맨 끝에 값을 추가
.insert(idx, 값)	해당 인덱스 위치에 값을 추가
.extend(리스트)	리스트와 다른 리스트를 연결 ( + 연산자와 다름!! -> 앞에오는 리스트 원본이 변경됨 )
.remove(값)	리스트 안에서 값을 삭제 ( 값이 없으면 오류 발생 )
.pop(idx)	해당 idx 위치에 있는 값을 삭제 ( idx를 설절정하지 않으면 맨 뒤의 값 삭제 )
.sort() / .sort(reverse=True)	기본적으로 요소들을 오름차순 정렬. ( reverse = True --> 내림차순 정렬 )
.reverse()	요소들을 역순으로 정렬.
.clear()	리스트 요소를 전체 삭제.

.append(값)

: 값을 리스트의 맨 끝에 추가한다.

.insert(idx, 값)

: 값을 해당 idx 위치에 추가한다.

li1 = [1, 3, 5, 7, 9]

li1.append(10)
print(li1)
li1.append(11)
print(li1)

li1.insert(1, 2) # 인덱스1번 위치에 2를 추가
print(li1) # 기존에 인덱스1번 위치부터 나머지 값들은 뒤로 밀림

<출력 결과>
[1, 3, 5, 7, 9, 10]
[1, 3, 5, 7, 9, 10, 11]
[1, 2, 3, 5, 7, 9, 10, 11]

.extend(리스트)

: 리스트와 다른 리스트를 연결해준다.
(+ 연산자와 다름)

li2 = [10, 30]
li3 = [50, 70, 90]

print(li2 + li3) # 리스트 + 리스트 => 연결
print(li2) # 원본이 변경되지 않음

li2.extend(li3) # 복합대입연산자와 유사
print(li2) # 원본이 변경됨

<출력 결과>
[10, 30, 50, 70, 90]
[10, 30]
[10, 30, 50, 70, 90]

.remove(값)

: 리스트 안에서 값을 삭제, 값이 없으면 오류 발생

.pop(idx)

: 해당 idx 위치에 있는 값을 삭제
idx 를 설정하지 않으면 맨 마지막 요소 삭제

li = [1, 2, 1, 3, 5, 7]

li.remove(1)
print(li)
li.remove(1)
print(li)
# li.remove(1) # -> 없는 값을 삭제하려고하면 오류 발생

# pop(idx)
li.pop(0) # 0번 위치 값 삭제
print(li)
li.pop() # 인덱스번호를 지정하지 않으면 맨 뒤의 요소를 삭제함
print(li)

<출력 결과>
[2, 1, 3, 5, 7]
[2, 3, 5, 7]
[3, 5, 7]
[3, 5]

.sort()

: 요소들을 오름차순 정렬한다.

.sort(reverse=True)

: 요소들을 내림차순 정렬한다.

li1 = [1, 3, 2, 5, 4, 6]

li1.sort() # 리스트 요소 오름차순 정렬
print(li1)

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

# li2 = ["a", "b", "c", 1, 2, 3]
# li2.sort() 
# 정렬을 사용하려면 요소의 타입이 동일해야함

<출력 결과>
[1, 2, 3, 4, 5, 6]
[6, 5, 4, 3, 2, 1]

.reverse()

: 요소를 역순으로 정렬한다.(거꾸로 정렬한다.)

li2 = ["a", "b", "c", 1, 2, 3]
li2.reverse()
print(li2)

<출력 결과>
['a', 'b', 'c', 1, 2, 3]

.clear()

: 리스트 요소들을 전체 삭제 => 빈 리스트로 만든다

li1 = ['봄', '여름', '가을', '겨울']
li1.clear()
print(li1)

<출력 결과>
[]

2. 튜플(tuple)

.count(값)	해당하는 값이 몇개 있는지 반환
.index(값)	해당 값이 위치한 인덱스 번호를 반환

.count(값)

: 해당하는 값이 몇개 있는지 반환

.index(값)

: 해당 값이 위치한 인덱스 번호를 반환
튜플 내에 값이 여러개 있다면 맨 앞의 값의 인덱스 번호를 반환

tu = 1, 1, 2, 3, 4, 5, 5, 5
print(tu)

print(tu.count(1)) # tu에서 1이라는 값이 몇개 있어?
print(tu.index(1)) # tu에서 1이라는 값이 몇번 인덱스 번호에 있어? => 0번 (가장 앞에있는 것)

3. 세트(set)

.add(값)	세트에 값을 추가. 중복된 값은 추가되지 않음
.remove(값)	값을 삭제. 없는 값을 넣게 되면 오류 발생
.discard(값)	값을 삭제. 없는 값을 넣어도 오류가 발생하지 않음
.pop()	요소 1개를 삭제한다. 인덱스 번호는 사용 불가
.intersection(세트)	두 세트의 교집합을 반환.
.union(세트)	두 세트의 합집합을 반환.
.difference(세트)	앞의 세트에서 뒤의 세트를 뺀 차집합을 반환

.add(값)

: 세트에 값을 추가한다. 중복된 값은 추가되지 않음

.remove(값)

: 값을 삭제한다. 없는 값을 넣게 되면 오류 발생

.discard(값)

: 값을 삭제한다. 없는 값을 넣어도 오류가 발생하지 않음

.pop()

: 요소 1개를 삭제한다. 인덱스 번호는 사용 불가

se1 = {'사과', '참외', '파인애플', '멜론'}
print(se1, type(se1)) # 세트는 인덱스 개념이 없음(순서가 없음)
	=> {'참외', '파인애플', '사과', '멜론'} <class 'set'>

# 요소 추가
se1.add('포도') # se1에 '포도' 추가
print(se1)
	=> {'사과', '포도', '멜론', '참외', '파인애플'}

se1.add('사과') # 중복값을 추가하려고 하면 코드가 무시됨
print(se1)
	=> {'사과', '포도', '멜론', '참외', '파인애플'}


# 요소 삭제
se1.remove('멜론')
print(se1)
	=> {'사과', '포도', '참외', '파인애플'}

# se1.remove('망고') # 없는 값을 삭제하려고 하면 오류 발생

se1.discard('포도')
print(se1)
	=> {'사과', '참외', '파인애플'}

se1.discard('망고') # 없는 값을 삭제하려고 해도 오류 발생하지 않음
print(se1)
	=> {'사과', '참외', '파인애플'}

se1.pop() # 세트 요소 1개 삭제
print(se1)
	=> {'참외', '파인애플'}

.intersection() / 세트1 & 세트2

: 교집합

.union() / 세트1 | 세트2

: 합집합

.difference() / 세트1 - 세트2
: 차집합

# 세트의 집합 연산
se1 = {1, 2, 3, 4, 5}
se2 = {3, 4, 5, 6, 7}

# 1) 교집합
print(se1 & se2)
print(se1.intersection(se2))
	=> {3, 4, 5}
	   {3, 4, 5}

# 2) 합집합
print(se1 | se2)
print(se1.union(se2))
	=> {1, 2, 3, 4, 5, 6, 7}
	   {1, 2, 3, 4, 5, 6, 7}

# 3) 차집합
print(se1 - se2)
print(se1.difference(se2))
	=> {1, 2}
	   {1, 2}

4. 딕셔너리

.keys()	key값들만 모여있는 새로운 컬렉션 반환 <class 'dict_keys'>
.values()	value값들만 모여있는 새로운 컬렉션 <class 'dict_values'>
.items()	(key, value) 튜플들이 모여있는 새로운 컬렉션 <class 'dict_items'>
.get(key)	key에 해당하는 value값 반환
.pop(key)	key와 해당하는 value 삭제

.keys()

: key값들만 모여있는 새로운 컬렉션

.values()

: value값들만 모여있는 새로운 컬렉션

.items()

: (key, value) 튜플들이 모여있는 새로운 컬렉션

cities = {"korea" : "서울", "japan" : "일본", "china": "베이징"}
print(cities, type(cities))
	=> {'korea': '서울', 'japan': '일본', 'china': '베이징'}

# 1) keys() : key 값들만 모아준다
print(cities.keys())
	=> dict_keys(['korea', 'japan', 'china'])

# 2) values() : value값들만 묶어준다
print(cities.values())
	=> dict_values(['서울', '일본', '베이징'])

# 3) items() : (key, value) 튜플들이 모여있다.
print(cities.items())
	=> dict_items([('korea', '서울'), ('japan', '일본'), ('china', '베이징')])

# .items() 메소드와 튜플의 언패킹 활용
for key, value in cities.items():
    print(f"key : {key}, value : {value}")
	=> key : korea, value : 서울
	   key : japan, value : 일본
	   key : china, value : 베이징

.get(key)

: key에 해당하는 value값 반환

.pop(key)

: key와 해당하는 value 삭제

di = {'a' : "apple", 'b' : "banana", 'c' : "car"}

print(di.get('a'))
	=> apple
    
di.pop('b')
print(di)
	=> {'a': 'apple', 'c': 'car'}