Python) 학습 - 기본4일차(comprehension, 문자열 처리, 함수 처리)

 

[ 13_comprehension ]

# 컴프리헨션(comprehension) : 한줄 포문
# 리스트 컴프리헨션 ( 가장많이 사용됨. )
# 세트 컴프리헨션
# 딕셔너리 컴프리헨션



# 1 ~ 10까지의 자연수에 대하여 각 값을 제곱한 결과를 원소로하는 리스트
# 필요한 답: l = [1,4,9,16,25,...]

# for 문을 사용하는 방법
l = []
for n in range(1,11): 
    l.append(n ** 2)
print(l)


# 리스트 comprehension(지능형 리스트): 수식과 반복문을 사용하여 리스트를 초기화하는 문법

l=[num**2 for num in range(1,11)]
print(l)

# 1 ~ 10까지의 자연수중 짝수 값을 제곱한 결과를 원소로하는 리스트
# 필요한 답: l = [4,16,...]

#  원소의 정의 #범위                # 짝수인경우만
l=[num**2 for num in range(1,11) if (num %2 == 0)]
print(l)

 

[ 14_문자열 처리 ]

#  1. 문자열분리
s = "apple banana cherry durian"
print (s.split(" ")) # 공백으로 분리

s = "apple, banana, cherry, durian"
print (s.split(", ")) # 쉼표와 공백으로 분리

a,b,c,d=s.split(", ")
print(a)
print(b)
print(c)
print(d)
# 단어사이의 특징을 파악 한뒤, split 처리.

s = "apple, banana, cherry, durian"
print (s.split(", ", maxsplit=2)) 

a,b,c=s.split(", ",maxsplit=2)
print(a)
print(b)
print(c)


s = "apple, banana,\n cherry,\t durian"
print (s.split(maxsplit=2))  # 규칙적이지 않을때는 구분자를 써주지 않아도 됨.

a,b,c=s.split(maxsplit=2)
print(a)
print(b)
print(c)


name= input("input name: ")
print(name)
last_name, first_name = name.split(" ")
print(last_name)
print(first_name)


#  2. 불필요한 문자 제거
print ("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@Python".lstrip("@")) # left 불필요 문자"@" 제거
print ("Python@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@".rstrip("@")) # right 불필요 문자"@" 제거
print ("@@@@@@@@@@@@@@@@@Python@@@@@@@@@@@@@@@".strip("@")) # l and r 불필요 문자"@" 제거


# 불필요한 문자가 여러개인 경우, 이를 나열해주면 됨.

s = "!@#$%^%^!@!@#!@$!@#! @$@#$#@$#@$Hello, Python!@#!@#!@#!@#!@#! @#!@#"
#                                          ^--- 문자가 일치하는문자 지우다가 일치하지 않는 문자를 만나면 멈춤. (중간 문자의 공백은 지우지 않음.)
# 일치하지 않는 문자가 나올때 까지 삭제 수행. (왼쪽수행후 오른쪽수행)                        
print(s.strip("!@#$!@#$%^ "))

  

# 문자열 연결하기
l = ["apple", "banana", "cherry", "durian"]

# 사용방법: "구분자문자열".join(문자열리스트)

print (" ".join(l))
print ("-->".join(l))
print ("".join(l))

# 문자열: 원소가 문자인 자료구조
# -> 문자열에도 index의 개념이 있음.
#   0123456789
s ="hello"
print(s[0])
print(s[-1])


# 검색 
# 1.find: 처음으로 일치하는 문자열의 시작 인덱스를 반환
#    0123456789abcd
s = "hello, python!"

print(s.find("python"))
print(s.find("o"))
print(s.find("A"))

print(s.find("n",2,3))
print(s.find("n",6))
print(s.find("n",0,13))

# 2. count: 해당문자열이 몇개 있는지 확인할때 사용
print(s.count("o"))
print(s.count("l",0,13))

# 특정 문자열로 시작 또는 끝나는지의 유무를 진리 값으로 반환
# startswith("문자열") : "문자열"로 시작하느냐? T/F
# endswith("문자열") : "문자열"로 끝나느냐? T/F
str_se = "Python is powerful. Python is easy to learn."
print("Python으로 시작?:", str_se.startswith("Python"))
print("is로 시작?:", str_se.startswith("is"))
print(".로 끝?:", str_se.endswith("."))
print("learn으로 끝?:", str_se.endswith("learn")) 

filename = "hello.pdf"
print(filename.endswith(".pdf"))

# 검색범위 추가 가능
str_se = "Python is powerful. Python is easy to learn."

print("Python으로 시작?:", str_se.startswith("Python",20,40))
print("Python으로 시작?:", str_se.startswith("Python",10,20))
print(".로 끝?:", str_se.endswith(".",10,20))
print(".로 끝?:", str_se.endswith(".",40,100))
print(".로 끝?:", str_se.endswith(".",40))

# 문자열 치환
str_a = 'Python is fast. Python is friendly. Python is open.'

print(str_a.replace('Python', 'IPython'))
#                     ^--기존    ^--새문자열
                                
print(str_a.replace('Python', 'IPython',     2)) 
#                     ^--기존    ^--새문자열  ^-- 치환할 최대 개수

# 사용자로부터 구구단의 단을 받아 해당단을 입력하는 프로그램 구현

# 문자열 패턴을 조사해주는 함수 제공
dan = input("구구단 입력(2~9): ")


if not dan.isdigit(): #문자열이 숫자로만 이뤄졌는지 판단 = T/F
    print("숫자를 입력해줘")
else: 
    print(f"< {dan}단 >")    

# 유효성 검사    
#isalpha() 문자열이 숫자, 특수 문자, 공백이 아닌 문자로 구성돼 있을 때만 True, 그 밖에는 False 반환      str.isalpha()
#isdigit() 문자열이 모두 숫자로 구성돼 있을 때만 True, 그 밖에는 False 반환                            str.isdigit() 
#isalnum() 문자열이 특수 문자나 공백이 아닌 문자와 숫자로 구성돼 있을 때만True, 그 밖에는 False 반환     str.isalnum()
#isspace() 문자열이 모두 공백 문자로 구성돼 있을 때만 True, 그 밖에는 False반환                         str.isspace()
#isupper() 문자열이 모두 로마자 대문자로 구성돼 있을 때만 True, 그 밖에는 False 반환                    str.isupper()
#islower() 문자열이 모두 로마자 소문자로 구성돼 있을 때만 True, 그 밖에는 False 반환                    str.islower()


# 대소문자 변경
s = "HeLLo"
print(s.upper())
print(s.lower())

 

[ 15_함수 ]

# 함수: 특정 기능이 구현되어 있는 코드 덩어리

# 함수 정의: 함수를 만든다는 의미

# def 함수명 ( 변수, ... ): 콜론으로 끝나야함.
# ....함수코드
# ....함수코드
# 기존코드와 함수코드를 구분하기 위해 들여쓰기 해야함.


# 사용자로부터 횟수를 입력받아 그횟수만큼 hello 문자열을 출력하는 함수

def print_hello(count): # 함수 정의시, 괄호 안의 변수를 매개변수(parameter)라고 함.
    for _ in range(count):
        print("hello")


# 함수 호출: 함수를 사용한다는 의미
# 함수 호출 방법: 함수명(값, ...)
#                     ^--함수 호출인자                


print_hello(3) # 함수 호출시, 괄호 안의 값을 인자(argument)라고 함.



#연습문제1. 구구단 함수 사용 
#display_dan(2)

def display_dan(num1):
    print(f"< {num1}단 >")    
    for num2 in range(1,9+1,1):
        print(f"{num1} x {num2} = {num1*num2}")    

display_dan(2)

# 함수의 반환: 함수가 호출된 곳으로 값을 전달하는 기능.
def add(a,b):
    return a+b # 사용방법: return 값

result = add(1,1) # 값을 반환하는 함수를 호출하면, 호출된 자리에는 반환된 값으로 치환됨.   
print(result)

a = 5
b = 3

q = a//b
r = a%b
print(q,r)

q, r = divmod(a,b)
print(q,r)

# 참고! 함수에서 다수의 값을 반환하고 싶다면, 튜플로 반환한 다음 언패킹을 사용하면 됩니다.
def my_divmod(a,b):
    return a//b, a%b # 튜플의 언팩킹 사용.
q, r = my_divmod(7,4)
print(q,r)

# DL에서 많이 쓰임 - unpacking

# 참고! return은 값을 반환하는 용도 뿐만아니라 함수를 즉시 종료할때도 사용됨.

def print_age(age):
    if (age <0):
        print("잘못입력했음.")
        return # 함수를 그냥 빠져나가는 용도로도 사용됨.
    print(f"당신은 {age}세 입니다.")

print_age(15)
print_age(-1)

# 값을 반환하지 않는 함수에 대하여 대입을 하면 그변수에는 None으로 설정됨.
ret = print_age(15)
print(ret) # None : 변수에 어떤값도 없다는 것을 알려주기 위해 제공된 키워드



# 함수의 종류
# 1. 매개변수(o), 반환값(o)
def add(a,b): return a+b

# 2. 매개변수(o), 반환값(x)
print("hello")

# 3. 매개변수(x), 반환값(o)
def pi(): return 3.141592

# 4. 매개변수(x), 반환값(x) : 유지보수가 편해짐, bug 확률줄어듦.
def display_menu():
    print("메뉴")
    print("1.짜장")
    print("2.짬뽕")

display_menu()


# 스코프(scope): 어떤 이름(심볼, 식별자)을 참조할 수 있는 영역

# 1. 전역 스코프: 함수나 클래스 외부 영역
# -> 코드 어디서나 참조 가능한 영역
g = "global" # 전역변수: 전역 스코프에서 생성된 변수

# 2. 지역 스코프: 함수 내부 영역
# -> 함수 내부에서만 사용 가능한 영역
def foo():
    l="local" #지역변수: 지역 스코프에서 생성된 변수
    print(g)

print(g)
foo()
# print(l) # Error - 지역변수라서 함수 안에서만 참조할수 있음.




# 스코핑 룰: 사용된 이름을 찾는 순서
# 지역(Local) 스코프 -> 전역(Global) 스코프 -> 파이썬 내부(Built-in) ==> LGB Rule

x = "global"

def goo():
    print(x) # 가장가까이에(지역스코프) 있는 x를 먼저 찾음 -> 없으면 전역 스코프로 감. -> 전역에도 없으면 파이썬 내부로 감.(print)

goo()    


# script 언어의 방식(x=global) (C언어같은 걸들은 x="lobal"로 나옴.- global is evil )

x = "global" #전역변수 
def bar():
    x="local" # 지역변수

bar()
print(x) # 전역에서 x를 찾음.

# 함수내에서 global 변수를 사용하는 방법:

x = "global" #전역변수 
def bar():
    # x="local" # 지역변수

    global x # 지역변수 x를 전역변수로 해석해 달라는 의미
    x="local" # 전역변수
bar()
print(x) # 전역에서 x를 찾음.


# 람다(lambda) 함수 : 이름이 없는 함수이고 반드시 한줄로 정의 해야하며 값을 꼭 반환해야함.(기존 함수와 동일.)

# 정의 방법: lambda 매개변수,...: 반환값
# 주의! return 키워드를 사용할 필요가 없으며 사용하셔도 안됨.

# 일반함수
def square(x):
    return x**2
# 람다함수
lambda x: x**2    


# 함수 호출

# 일반함수
def square(x):
    return x**2

result = square(2)    
print(result)

# 람다함수
# lambda x: x**2    

result =(lambda x: x**2)(2) # 즉시호출: 람다함수를 만들자 마자 호출한것.
#       ^-- 함수호출할때 () 가 필요. 
print(result)


result =(lambda x: x**2)(2) 
result =(lambda a, b: a+b)(1,1)
result =(lambda :3.14)()
print(result)

#            차이점
# 일반 함수 : 이름이 있음. 프로그램이 종료될때 까지 존재.
# 람다 함수 : 이름이 없음. 문장의 끝을 만나면 파괴됨.

# 일반 함수
def square(x): return x**2
# 람다 함수
lambda x: x**2 


# 만약 람다 함수의 수명을 늘리려면 변수에 대입
# 이경우, 람다 함수의 수명은 변수의 수명과 같아짐.
sqr = lambda x: x**2
print(sqr(2))


maths = [10,20,30,40,50,60]

for math in maths:
# 반복만 안에가 엄청복잡한 경우...    
    if math <= 30:
        print(math,"failed!")



# filter(): 자료구조의 원소들 중 조건이 참인 원소만 걸러내는 함수

maths = [10,20,30,40,50,60]

def bypass(item):
    return True

# for math in filter(bypass,maths): 
#          print(math,"failed!")


def is_failed(item):
    return item <= 30

for math in filter(is_failed,maths): 
#                               ^-maths의 list를 꺼내서
#                   ^------------- is_failed함수의 item에 넣어서 T/F를 return  함. (이런식으로 함수안에 넣을때 계산식이 필요할때 많이 씀.)
         print(math,"failed!")



maths = [10,20,30,40,50,60]

for math in filter(lambda x: x<=30,maths): 
         print(math,"failed!")


# bigdata 전처리할때, lambda 함수를 많이 씀.

#함수를 사용하는데 잠깐 쓰고 버리는 용도로 사용해도 됨.
#일반 함수 여러개를 쓰는것 보다 lambda가 더 쉽다.
# 어떤 함수에 변수를 집어넣을때 lambda를 많이 씀.