Python 09일차 수업 정리_컬렉션의 메소드(세트set, 딕셔너리dict), 함수(내장함수, 문자열 내장함수)

- 08일차 복습

- 함수_숫자 내장함수

- 함수_시퀀스 내장함수

- 문자열 메소드

- 함수_사용자 정의 함수

 

 

---

- 08일차 복습

 

함수란 특정 기능을 실행하는 코드 or 코드의 모임

함수의 종류 : 

내장함수, 외장함수, 사용자 정의함수

 

내장 함수 : 파이썬에 내장되어 있어 항상 사용할 수 있는 함수

 

문자열 내장함수 : chr(), eval(), format(), str()

eval()	실행하고자 하는 표현식을 문자열로 전달하면 표현식의 결과값을 반환하는 함수
format()	전달받은 인수와 포맷코드에 따라 형식을 갖춘 문자열을 반환하는 함수 포맷코드는 전달하지 않을 수 있으며 이 경우 str()함수를 호출하는 것과 같다
str()	전달받은 인수를 문자열로 반환하는 함수
chr()	특정 문자의 유니코드 값을 전달하면 해당 유니코드 값을 가진 문자를 반환하는 함수 모든 문자는 자신만의 코드값을 가진다(문자코드 : 아스키코드, 유니코드 등)

 

 

---

- 함수_숫자 내장함수

정수, 실수 모두 포함

abs()	전달된 인수의 절대값을 반환하는 함수
int()	정수형 형변환 함수
max()	전달된 인수 중 가장 큰 값을 반환하는 함수
min()	전달된 인수 중 가장 작은 값을 반환하는 함수
pow()	전달된 두 인수의 거듭제곱을 반환하는 함수 (** 파워/거듭제곱 연산자와 동일)
sum()	합계 반환 함수, 숫자가 아닌 값 전달시 에러 발생
round()	전달된 인수를 이용해서 반올림 값을 반환하는 함수 전달된 인수가 1개이면 정수로 반올림한 값을 반환하는 함수 전달된 인수가 2개이면 두번째로 전달된 인수만큼 소수점을 남긴다

 

# abs() : 절대값 반환 함수
print(abs(10), type(abs(10)))
print(abs(-10), type(abs(-10)))
print(abs(3.14), type(abs(-3.14)))

# -------------------------------------------

# pow() : 거듭제곱 함수 (거듭제곱/파워 연산자)
#  10**2 == 100
print(pow(10, 2), type(pow(10,2)))
print(pow(10, 3), type(pow(10,3)))

# -------------------------------------------

# round() : 반올림값을 반환하는 함수 (이중에서 가장 자주 쓰는 함수)
print(round(1.5))
print(round(2.5)) # 앞의 자리수가 짝수일 때는 버림(오사오입 법칙)
print(round(3.14, 1)) # 전달된 인수가 두개일 때는 두번째 숫자는 자릿수를 표현 => 3.1

 

 

---

- 함수_시퀀스 내장함수

시퀀스란 값이 연속적으로 이어지는 인덱스를 가진 값

enumerate()	리스트와 함께 사용할 수 있다 저장된 요소와 해당 요소의 인덱스를 튜플 형태로 함께 출력
range(0	전달된 인수값에 따라서 시퀀스 자료형의 데이터를 생성하는 함수 특정 범위의 값을 생성하기 때문에 => 범위 생성자 rang() => 다른 자료형으로 형변환이 가능함
len()	전달된 객체의 길이(항목수)를 반환하는 함수 len("hello") => 5 / len([1, 2, 3, 4]) => 4
sorted()	전달된 반복가능 객체의 오름차순 정렬 결과를 추출 ** 반복 가능 객체란 == 시퀀스 자료형, 문자열, 리스트 등,..
sorted(반복가능객체, reverse=True)	내림차순 정렬과 결과를 반환하는 함수  li1.sort() => 메소드 이므로 이것과 다름
zip()	전달된 여러개의 반복 가능 객체의 각 요소를 튜플로 묶어 반환하는 함수 전달된 반복 가능 객체의 길이가 서로 다르면 길이가 짧은 것을 기준으로 동작

 

# enumerate() : 리스트가 있을 때 (idx, 값)

li1 = ['가위', '바위', '보']

for i in enumerate(li1) : 
    # 변수를 1개 만들어서 (idx, 값) 튜플 형태로 출력
    print(i, type(i))

for idx, element in enumerate(li1) : 
    # 변수를 2개 만들어서 각각 idx, element값을 대입시킴(튜플의 언패킹 사용)
    print(f"idx : {idx}, element : {element}")
    
# -----------------------------------------------

# range() : 

print(range(1, 10, 2), type(range(1, 10, 20))) # range(1, 10, 2) => 1, 3, 5, 7, 9
# 다른 자료형으로 형변환 가능함
print(list(range(1, 10, 2)), type(list(range(1, 10, 2))))
print(tuple(range(1, 20, 2)), type(tuple(range(1, 20, 2))))

# 비어있는 리스트 생성
li1 = []
li1 = list()

print(list(range(0))) # 빈 리스트 만듦

# -----------------------------------------------

# len()
li1 = ['a', 'b', 'c', 'd']
di1 = {'a':'apple', 'b':'banana'}

print(len(li1))
print(len(li1) == 4) # 같니? 결과는 True or False 논리형으로 나옴
print(len(di1)) # 딕셔너리는 key와 value 가 항상 한쌍이기 때문에 , (콤마)를 기준으로 개수를 count

print(len(range(100))) # range(100) => 0 ~ 99 => 100개

# -----------------------------------------------

# sorted : 오름차순 정렬된 복사본을 반환하는 함수 (원본 바뀌지 않음)
li2 = [5, 2, 7, 1, 8, 2, 3]
print(li2, type(li2))
print(sorted(li2))
print(li2)
li2.sort() # sort() 메소드는 원본이 변경됨
print(li2)
print(sorted(li2, reverse = True)) # 잠깐 바꿔줌

# -----------------------------------------------

# zip()
name = ["짱구", "철수", "유리", "맹구"]
score = [74, 100, 80, 60]

print(f"{name[0]}의 점수는 {score[0]}점 입니다")
print(f"{name[1]}의 점수는 {score[1]}점 입니다")
print(f"{name[2]}의 점수는 {score[2]}점 입니다")
print(f"{name[3]}의 점수는 {score[3]}점 입니다")

for student in zip(name, score) : 
    print(student, type(student))
    
for student, point in zip(name, score) : # 각각의 변수에 저장함(튜플의 언패킹 사용)
    print(f"{student}의 점수는 {point}입니다.")

 

 

---

- 문자열 메소드

.format()메소드	문자열 정렬하는 방법 "{} {}".format(값1, 값2)	옵션	의미
		< > ^	지정된 공간 내에서 왼쪽 정렬 지정된 공간 내에서 오른쪽 정렬 지정된 공간 내에서 가운데 정렬
.split()	하나의 문자열을 여러개의 문자열로 분리하여 저장한 리스트를 반환하는 메소드 기본적으로 공백문자를 기준으로 분리하지만 특정 문자열을 기준으로 분리 가능
.replace()	문자열의 일부 문자열을 다른 문자열로 바꾼 결과를 반환하는 메소드 전달된 2개의 인수 중에서 첫번째 인수를 두번째 인수로 바꾼 문자열을 반환하는 메소드
불필요한 문자열 제거 메소드 / 문자열의 양 끝에 있는 불필요한 문자열을 제거하는 메소드 / 문자열 중간에 있는 것은 제거 X
.strip()	양 끝에 있는 불필요한 문자열을 제거한 결과값를 반환하는 메소드
.lstrip()	왼쪽 끝에 있는 불필요한 문자열을 제거한 결과값를 반환하는 메소드
.rstrip()	오른쪽 끝에 있는 불필요한 문자열을 제거한 결과값을 반환하는 메소드

 

# .format()
print("10자리 폭 왼쪽 정렬 : '{:<10d}'".format(123))
print("10자리 폭 오른쪽 정렬 : '{:>10d}'".format(123))
print("10자리 폭 가운데 정렬 : '{:^10d}'".format(123))

print("10자리 폭 왼쪽 정렬 : '{:*<10d}'".format(123))
print("10자리 폭 오른쪽 정렬 : '{:0>10d}'".format(123))
print("10자리 폭 가운데 정렬 : '{:-^10d}'".format(123))

#-----------------

# .split()
data = "Life is too short"
print(data, type(data))

print(data.split())
print(data.split('o'))

#-----------------

# .replace()
data = "Life is too short"
print(data.replace("short", "long")) # 첫번째 인수를 두번째 인수로 바꾼 값을 반환

#-----------------

# 불필요한 문자열 제거 메소드
st1 = "1**2**3****************************"
st2 = "********************1**2**3"
st3 = "****************1**2**3***************"

print(st1.rstrip('*')) # 오른쪽에서부터 * 제거하다 *이 아닌것을 만나면 끝남
print(st2.lstrip('*'))
print(st3.strip('*'))

# 공백 or 특정 문자열을 넣었을 때 제거 후 남은 값만 출력
# 중간 공백 or 특정 문자열이 있을 때는 제거되지 않음
# 제거하는 값을 정확히 파악하고 맞는 메소드를 사용해야함

 

 

---

- 함수_사용자 정의 함수

사용자 정의 함수란 사용자가 직접 만든 함수 => 반복되는 코드, 행위, 기능들을 쉽게 관리하기 위해 선언해 사용

 

함수(function) : 주어진 값에 정해진 처리를 하여 그 결과를 반환하는 기능.

==> 특정 기능을 실행하는 코드, 코드의 모임

f	(x)	= x+2
함수이름	매개변수	리턴값

 

1) 함수의 정의 및 호출

def 함수명(매개변수,...) :

        실행할 기능

        return 리턴값

 

용어

함수 정의	사용자 함수를 새로 만드는 것을 의미
인수	함수에 전달할 입력(input)을 의미, argument
매개변수	인수를 받아서 저장하는 변수를 의미, parameter
반환값	사용자 함수의 출력(output)을 의미
함수 호출	들어진 사용자 함수를 실제로 사용하는 것을 의미

 

2-1) 함수정의

=> 함수를 만드는 것을 의미 / def 키워드 사용

def 함수명(매개변수,...) :

        실행할 기능 / 본문 

        return 리턴값/반환값 (필수 X)

 

함수의 이름은 개발자 마음이며 매개변수는 함수에 전달되는 인수가 저장될 변수이다.

함수 본문은 들여쓰기 필수 문법을 사용한다. 

# welcome() 함수 정의
# def 함수명(매개변수,...) :
#   실행할 기능
#   return 리턴 값

def welcome() : 
    print("안녕")
    print("hello")

# welcome() 함수 호출
# 함수명(인수)

welcome()

#--------------

# 어떤 숫자가 들어오면 +10을 하는 함수 정의
# add() 함수 정의
def add(num) : 
    result = num + 10 # 기능
    return result # 결과 반환

# 함수 호출
print(add(5))

 

 

2-2) 인수와 매개변수

함수로 전달되는 인수를 저장하는 변수를 ==> 매개변수

디폴트 매개변수	전달되는 인수가 없는 경우 사용할 수 있도록 매개변수에 기본값을 설정하는 것 매개변수가 여러개 있을 때는 맨 뒤에 있는 매개변수부터 디폴트 값을 설정!
가변 매개변수	전달되는 모든 인수를 하나의 튜플로 만들어줌. (만드는 키워드 * )

# 디폴트 매개변수
# greet() 함수정의
def greet(str1, str2) :
  print(str1)
  print(str2)

# 함수호출
greet('hello', '안녕')
# greet('hello') 짝이 안맞으면 오류? 

#----------

# 디폴트 매개변수
def add(num1, num2, num3 = 3, num4 = 10) : 
    return num1 + num2 + num3 + num4

print(add(10, 5)) # 1, 2에는 제대로 들어가고 3, 4는 정하지 않으면 알아서 수가 들어가 있음
print(add(10, 5, 10))

#----------

# 가변 매개변수 : 몇개의 인수가 들어올 지 모를 때 주로 사용
# show() 함수 정의

def show(*args) : 
    print(f"args : {args}")
    print(f"args의 타입 : {type(args)}")

# show 함수 호출
show(1, 'python', 40)
show("안녕")

 

 

2-3) 함수 종류

매개변수	리턴
X	X
O	X
X	O
O	O

# 매개변수 X, 리턴 X
# welcome()

def welcome() :
    print("안녕하세요")

# welcome 함수 호출
welcome()

#------------

# 매개변수 O, 리턴 X
# printName() 함수정의
def printName(name) :
    print(name)

def printInfo(name, age, gender = '남') :
    print(name, age, gender)

# 함수호출
printName("홍길동")

printInfo("홍길동", 20)

#------------

# 매개변수 X, 리턴 O
def get_my_name() :
    name = "짱구"
    return name # 리턴값

my_name = get_my_name() # 함수의 결과를 값처럼 사용 가능
print(my_name)
print(get_my_name())

#------------

# 매개변수 O, 리턴 O
def addNum(num1, num2) :
    return num1 + num2

# 함수 호출
print(addNum(10, 20))

# 리턴값 있는 함수의 결과는 값처럼 사용 가능
num = addNum(1, 2)
print(num)
print(addNum(1,2) + 10)

 

 

2-4) 반환값(return value)

함수 호출의 결과를 return value, 즉 함수 종료를 의미한다.

반환값이 있을 때 함수 내부에 return문을 통해 값을 반환할 수 있다.

단, 반환값이 없으면 함수 내부에 return문을 작성할 필요가 없다. 

반환값을 사용할 때	- 함수내에서 모든 작업이 완료되지 않았을 때 - 사용하는 부분에서 해야할 작업이 남았을 때 - 사용하는 부분에 함수 내의 작업 결과를 알려줘야할 때
반환값을 사용하지 않을 때	함수내에서 출력까지 모든 작업이 완료되었을 때

 

# return : 함수 결과, 함수 종료

def printValue(num) :
    return num # 반환값을 의미

print(printValue(10))

# 함수종료

def exit() :
    print("hello")
    return           # 함수 종료
    print("안녕")

exit()

10

hello

 

---

<과제>

# 과제 / 내일까지
# 1. 지정한 개수의 *표시를 하는 사용자 함수 만들기
# (키보드로 입력한 지정 개수가 *로 표시할 수 있도록 작성)

# 함수명 : star()

# [출력결과]
# 개수입력 : 5
# *****

# 사용자 정희 함수 선언
# 매개변수 O, 리턴 X

def star(cnt) :
    print("*"*cnt) #시퀀스 연산자 문자열 * int(반복)

# 개수 입력 변수 선언
cnt = int(input("개수 입력 : "))
star(cnt)

# 1번 문제 다른 방법
# 매개변수 O, 리턴 O

def star(cnt) :
    return f"{'*'*cnt}"

cnt = int(input("개수 입력 : "))
print(star(cnt))

 

# 2. 두 정수를 입력받아 덧셈, 뺄셈, 곱셈의 결과를 리턴하는 사용자 함수 정의하기
# 호출까지
# 함수명 add(), sub(), mul()

num1 = int(input("첫번째 정수 입력 : "))
num2 = int(input("두번째 정수 입력 : "))
# 사용자 정의 함수 덧셈
def add(num1, num2):
    return num1 + num2
# 뺄셈 함수 정의
def sub( num1, num2) :
    # 조건문 사용 : 큰 숫자 - 작은 숫자
    if num1 >= num2 :
        return num1-num2 
    else :
        return num2-num1
# 곱셈 함수 정의
def mul(num1, num2) :
    return num1 * num2

print(add(num1, num2))
print(sub(num1, num2))
print(mul(num1, num2))

 

# 3. 문자열 뒤집는 함수 만들기
# 문자열을 입력받아 입력 받은 문자열을 거꾸로 출력하게 하는 함수 정의하기
# 함수 호출까지

# 함수 정의

str1 = (input("문자열 입력 : "))

def reverse_str(str1) :
    return str1[::-1] # 슬라이싱 역순으로

# 함수 호출 및 결과 출력
result = reverse_str(str1) # 리턴 값이 있는 함수의 결과는 값처럼 사용 가능
print(result)

 

 

2024.02.06