아이스베어의 개발 일기

list1 = [10, 20, 30, 40, 50]
list1 = list(map(lambda x: x*10,list1))
print(list1)

def myFunc(x):
    return x*12
list3= list(map(myFunc,list1)) #list1=[100, 200, 300, 400, 500]
print(list3)

myFunc 함수는 들어오는 값마다 12를 곱해준다. 이것을 map을 이용하여 list1의 값들을 myFunc 함수에 적용한다.

def myFuncBool(x):
    return x%8==0
list4 = list(filter(myFuncBool, list1))  #list1=[100, 200, 300, 400, 500]
print(list4)

myFunBool 함수는 8의 배수를 반환 한다. 이것을 filter를 이용하여 list1의 값들을 myFunBool 함수에 적용한다.

* 본 포스팅은 주피터 노트북을 사용하였다.

list에 sort()를 이용해보자 sort는 정렬이다!

a_list는 [12, 56, 11, 34] 배열을 가지고 있다 sort()를 적용하면

a_list안에 있던 값들이 오름차순으로 정렬된 것을 확인할 수 있다.

여기서 index() 를 이용하면 몇번에 위치하는지 알 수 있는데

오름차순한 a_list에서 11은 0번째에 있으므로 0이 떴고

sort를 reverse로 하여 반대로 정렬하고 난 후 11의 값이 3번째에 있다는 것을 알려준다.

다음은 insert()를 이용하는데 insert는 몇번째에 어떤 값을 넣을지 지정할 수 있다.

여기서 pop()를 이용하면 끝에있는 값을 가져온다.

문제) pop을 이용하여 데이터를 역순으로 정렬하기

a_list = [12, 56, 11, 34]
result=[]
list=len(a_list)
for i in range(0, list):
    result.append(a_list.pop())
print(result)

문제) pop 대신 remove를 이용하여 마지막 데이터 삭제하기

a_list = [12, 56, 11, 34]
a_list.remove(a_list[-1])
print(a_list)

* 리스트의 내용 갱신하기 -> 각각 10을 곱한 값으로 갱신!

list1 = [10, 20, 30, 40, 50]
i=0
for n in list1:
    list1[i] = n*10
    i=i+1
print(list1)

문제 ) 위의 값을 list comprehension으로 바꿔보기

[i*10 for i in list1]

* 본 포스팅은 주피터 노트북을 이용하였다. 차이는 print문이므로 파이참에 적용하려면 print를 붙여주면 된다!

멤버 연산자인 in, not in을 확인해 보자

사진처럼 in 을 이용해 내가 찾고 싶은 값이 있으면 True, 없으면 False를 반환한다.

if 문을 이용하여 이 해당 값이 있을 경우 문자열 배열에 삭제하도록 해보자

12가 사라진 것을 확인할 수 있다.

문제 ) a_list에 있는 값과 b_list에 있는 값들 중 겹치는 값을 출력해보자

[10, 16]이 나오면 되고 방법은 2가지가 있다.

1)

result =[]
for i in a_list:
    for j in b_list:
        if(i==j):
            result.append(i)
print(result)

2)

c_list=[]
for i in b_list:
    if i in a_list:
        c_list.append(i)
print(c_list)

* 본 포스팅은 주피터 노트북을 이용하였다.

list()로 묶으면 알아서 슬라이싱 해준다!

문제 ) 문자열을 리스트로 변환하고 그 문자열의 갯수가 몇개인지 알기

str22="대한민국의 국민이 되는 요건은 법률로 정한다. 헌법개정안은 국회가 의결한 후 30일 이내에 국민투표에 붙여 국회의원선거권자 과반수의 투표와 투표자 과반수의 찬성을 얻어야 한다."

list1=list(str22)
len(list1)

리스트 안에 for문을 이용하여 값을 생성할 수 있다.

list[-2]는 뒤에서 2번째를 의미한다.

* append와 extend 

a_list가 ['a', 'b', 'c', 'd', 'e', 'f'] 인 상태에서 append와 extend를 사용해보자

append를 사용하면 [ ]도 생성되지만 extend는 문자열이 추가되었다.

* 중복 제거하기

a_list의 값이 [12, 56, 11, 'f', 'r', 't', 'f', 'r', 't'] 일때 중복을 제거해보자

distinct=set(a_list)
print(distinct)

* 해당되는 값 삭제

a_list.remove('c') #해당되는 값 삭제
print(a_list)

abs() : 절대값을 반환

min() : 가장 작은 값 반환

max() : 가장 큰 값 반환

abs(-100) #절대값을 반환 #100

min(100, 100, 10, 7, 1000) #7

max(100, 100, 10, 7, 1000) #1000

def div(a,b=2):
    return a/b
div(4)		#2.0

type

eval("100+200+300") #문자열을 수치값과 연산자로 변환하여 계산(평가/evaluation)
#600

#데이터 타입 알려줌
type(123) 	#int

type('123')	#str

type(123.7) 	#float

type([100,200,300]) #list

* 본 포스팅은 주피터 노트북을 이용하였다. 파이참으로 실행해 보려면 이렇게

a란 변수를 추가하고 print(a)를 해줘야 볼 수 있을 것이다!

[ 대문자 소문자 변경 함수 ]

'hello'.upper() #'HELLO'

'HELLOW'.lower() #'hellow'

'hello'.capitalize() #'Hello'

[ 문자열 나누기(split), 결합하기(join), 세기(count), 교체하기(replace) ]

red = '안녕하세요,홍길동,바보'
result=red.split(',')
result				# ['안녕하세요', '홍길동', '바보']

#배열에 저장된 문자열을 하나의 문자열로 결합
','.join(result)	# '안녕하세요,홍길동,바보'

s1="aaaa"
s1.count('a')		# 4

s1="aaaabbb"
s1.count('b')		# 3

s1='Long Live the King'
s1.replace('King','홍길동')	# 'Long Live the 홍길동'

s2="X:Y:Z"
s2.split(":")	# ['X', 'Y', 'Z']

[ 문자열 format하기 ]

'I like {1} and {0}'.format('Python','java')
# 'I like java and Python'

'I like {} and {}'.format('Python','java')
# 'I like Python and java'

for i in range(2,15,2):
    print('{0:3d} {1:4d} {2:5d}'.format(i,i*i,i*i*i))
#  2    4     8
#  4   16    64
#  6   36   216
#  8   64   512
# 10  100  1000
# 12  144  1728
# 14  196  2744

print('소수점 두자리 {0:3.2f}'.format(3.141592)) #소수점 두자리 3.14

[ 문자열 find(찾기), strip(공백제거)하기 ]

'hobby'.find('o')		# 1

'             hello    '.rstrip() #오른쪽 공백제거
# '             hello'

'             hello    '.lstrip() #왼쪽 공백제거
# 'hello    '

'             hello    '.strip() #공백제거
# 'hello'

* 본 포스팅은 주피터 노트북을 이용하였다. 이 코드로는 파이참에서도 실행이 가능하다.

펙토리얼을 구현하는 방법은 크게 반복문을 이용하는 것과 재귀함수를 이용하는 것이 있다.

오늘 이 두가지 방법을 구현해 보았다!

1. 반복문 이용하기

def factorial1(n):
    fact = 1
    for i in range(1, n+1):
        fact = fact*i
    return fact
n=5    
print('{}! = {}'.format(n,factorial1(5)))

2. 재귀함수 이용하기

def factorial2(n):
    if n<=1: # 종료조건
        return 1
    else :
        return n* factorial2(n-1) #n*(n-1)!
n=5
print('{}! = {}'.format(n,factorial2(5)))

* 본 포스팅은 주피터 노트북을 이용하였다. 이 코드로는 파이참에서도 실행이 가능하다.

가변 인자를 가지는 함수에 대해 알아보자

def foo(*args):
    print('인자의 갯수 : ',len(args))
    print('인자들 : ',args)

foo(10,20,30)

가변 인자를 가지는 함수를 이용한 합계 구하기

def sum_nums(*numbers):
    result=0
    for n in numbers:
        result+=n
    return result

sum_nums(10,20,30) # 60
sum_nums(10,20,30,70,11) #141

* 주피터 노트북으로 실행하였다!

직사각형과 원의 면적을 구하는 함수

def func(shape, width=1, height=1, radius=1):
    if shape==0: # shape값이 0이면 사각형의 면적을 반환
        return width * height
    elif shape ==1: # shape값이 0이면 원의 면적을 반환
        return 3.14 * radius **2

추가 문제로  shape이 2가 들어오면 근의 공식의 결과를 반환하는 기능도  추가 하였다!

def func(shape, width=1, height=1, radius=1,a=1,b=1,c=1):
    if shape==0: # shape값이 0이면 사각형의 면적을 반환
        return width * height
    elif shape ==1: # shape값이 0이면 원의 면적을 반환
        return 3.14 * radius **2
    elif shape==2:
        r1= (-b + (b**2-4*a*c)**0.5)/(2*a)
        r2 = (-b - (b**2-4*a*c)**0.5)/(2*a)
        print("{} 또는 {} 입니다.".format(r1,r2))

* 주피터 노트북에서 실행하였다.

def get_root(a,b,c):
    r1=(-b +(b**2 - 4*a*c)**0.5)/(2*a)
    r2=(-b -(b**2 - 4*a*c)**0.5)/(2*a)
    return r1,r2
    
result1, result2 = get_root(a=7, b=13, c=6)
print(result1) #-0.8571428571428571

result1, result2 = get_root(a=7, c=6,b=13)
print(result1) #-0.8571428571428571