유무디

오늘 포스팅은 파이썬에서 함수를 선언하는 방법에 대하여 알아보도록 하겠습니다.

함수의 형태는 크게 12가지 정도의 형태로 선언할 수 있습니다.

1. 함수 기본형

def func01():
	print(1)
	print(2)
	print(3)

print("함수 기본형")
func01()

2. 함수 인수 전달

def func02(a):
	print(a)
	print(a * a)

func02(50)

3. 함수 return

def func03():
	print('func03')
	return (100)

func03()                                                # 3-1.return 을 줬는데 호출이 안받아준경우

a = func03()                                            # 3-2.함수를 변수로 받아서 출력하는 경우
print(a)

print(func03())                                         # 3-3. 직접적으로 사용하는 방법

print(func01())                                         # 주의 return 값이 없는것은 사용하면 X

print(func03() * 7)                                     # 3-3. return 값을 직접적으로 사용

여기서 중요한것은 함수에 값을 넣으면 계산된 값을 돌려주지만!

함수를 변수를 사용하여 선언하여야 return 값을 돌려줍니다.

3-1처럼 함수만 선언할 경우 호출을 받지 못해 return값을 출력할 수 없기 때문에 반환 값을 "변수"로 받아서 사용하도록 주의해야 합니다.

4. 인수 전달 + return

def func04(num):
	print('func04', num)
	return(777 + num)

func04(100)                                             # 1. return 값 X

a = func04(100)                                         # 2. 변수 받기 # 인수전달
print(a)

print(func04(100))                                      # 3. 직접적 대입

5. 인수 전달이 한개 이상인 경우

def func05(a, b, c):
	sum = a * b + c
	print(sum)
	print(a * a + b * b + c * c)

func05(2, 3, 4)
func05(3, 4, 5)

6. return; 함수 중단! break 역할

def func06():
	print('1')
	return;                                             # return; <- 함수는 여기서 중단된다 break
	print('2')                                          # unreached code

func06()

여기서 2는 break 후 코드이기 때문에 출력되지 않는다

break는 주로 조건문에서 사용이 많이 되며 단독으로는 의미가 없으니 return;의 의미를 알아두면 됩니다~!

7. type의 상관이 없는 함수 

def func07(a, b):
	print(a, b)
	print(type(a), type(b))

func07(10, 'YUJA')                                   # type 상관 X

8. 호출값 FIx!

def func08(a, b, c = 10, d = 20):                       # 함수 인수의 초기값 지정
	print(a, b, c, d)                                   # 주의 - 초기화시키는 것은 함수의 끝에서 부터 시켜야한다 ()

func08(1,2)                                             # (호출시, 지정이 안되있는 최소 2개는 정해야하며 뒷값은 default)
func08(1, 2, 3)
func08(1, 2, 3,4)

9. 가변 인수 전달

꼭 인수의 개수를 정하고 초기값을 지정하지 않고, 함수 인수 전달에 제약을 두지 않은 함수를 만들기도 가능합니다~!

def func09(*args):
  print('*'*30)
  for data in args:
    print(data)

func09()
func09(10, 20)
func09(10, 20, 'YUJA', 30)                               # 갯수제한없이 인수를 다 받아준다

10. 인수값이 불변 & 가변

인수값이 불변인 경우와 가변인 값을 둘 다 동시에 사용이 가능하다!

def func10(a, b, *args):
  print(a,b)
  for data in args:
    print(data)

func10(10, 20)
func10(10, 20, 30)
func10(10, 20, 30, 40)

11. 가독성을 위한 함수

코드의 가독성은 같은 결과를 출력해도 더 짧고 간결할수록 높습니다!

코드를 작성할때 가장 어려운 부분이며 중요한 부분 중 하나라고도하죠?

그래서 이번 함수 선언에서 살짝 가독성을 위한 부분을 다뤄보도록 하겠습니다!

그리고 이 함수는 ONLY Python에서만 가능하기 때문에 다른 프로그래밍에서 사용할 경우 에러가 생갈 수 있습니다

def func11(a, b, *, delay, time):                                  # * 뒤로는 함수안의 내용은 모르지만 인수를 적을떄 용이
	print(a, b, delay, time)

func11(1, 2, delay = 3, time = 4)                                  # *을 명시를 할때는 정확하게 해주어야 한다

자 이제 마지막 형태로 전 시간에 배운 "dictionary"를 사용한 함수입니다!

12. (** star)

def func12(**star):
  print(star)
  print(star.keys())
 
  for item in star.items():
    print(item)
    for value in star.values():
      print(value)
      for k, v in star.items():                                        # 동시에 key 값과 value 값을 불러올 수 있다
        print(k, v)

func12(a=10, b=20)

type에 상관이 없으며 불변과 가변의 인수에 신경을 쓰지 않아도 되는 편리하고 쉬운 함수의 기본 형태 선언 법이었습니다~!

Day 4까지 따라오셨다면, 이번 포스팅에서는 중간중간 헷갈리거나 차이정에 대한 의문이 생길법한 문법에 대하여 집고 넘어가 보도록 하겠습니다.

우선, 첫번째로는 값을 추가하는 append와 extend에 대하여 알아보도록 하겠습니다

append / extend 차이

☆ 한개의 값만 추가할 수 있는지 vs 합성되어 여러 개의 값으로 추가할 수 있는지의 차이입니다.

a = [1, 2, 3]
a.append(4)
print(a)

a = [1, 2, 3]
a.append([4, 5])                                    # append 는 한개만 추가시킨다 (list 도 한개)
print(a)

a = [1, 2, 3]
a.extend([4])                                       # append 와 같은 결과값
print(a)

a = [1, 2, 3]
a.extend([4, 5, 6])                                 # append 는 한개지만 extend 는 합성을 시킨다
print(a)

a = [1, 2, 3]
a = a + [4, 5, 6]                                   # + 연산자를 통해 extend 시키는것
print(a)

tuple / list 차이

a = ( )                                              # console 에선는 a 만처도 바로 나온다
b = [ ]
print(a, b, type(a), type(b))

a = 10,                                             # tuple type BUT 실제 사용 X, () 생략
print(type(a))

b = (10,)                                           # ( ,)를사용하여 tuple 을 만든다 <- best
print(type(b))

c = 10
d = (10)                                            # ,에따라 tuple type int type 이다
print(type(c), type(d))

e = (10, 20, 30,)
print(e, type(e))

f = 10, 20, 30                                      # () 생략된 tuple
print(f, type(f))

a = (10, 20, 30)
b, c, d = a                                         # a 가 가지고 있는 요소를 한개씩 집어넣은것
print(a, b, c, d)

a = [10, 20, 30]
b, c, d = a                                         # list 도 된다
print(a, b, c, d)

a = 10
b = 20
a, b = b, a                                         # data 교환
print(a, b)

a = [10, 20, 30]
tuple(a)                                 # list 자료형 -> tuple 자료형 (UD를 못하게끔)
b = tuple(a)                             # type 은 그대로기 때문에 return 값이 있다 (b라는 return 값을 만들어, b는 튜블 a 다 )
print(type(b))

a = (10,) + (20, 30)                                # tuple 항목 연결
print(a)
print((10,) + (20, 30))                             # 출력코드에 바로 대입 연결

a = (1, 2, 3)
b = (1, 2, 3, 4)
print(a == b)
print(a <= b)                                       # 대소비교 -> 갯수가 크냐 작냐

for i in a:
    print(i)

a = (10, 20, 30)
b = [10, 20, 30]
# print(a(0)) 					#tuple 일고 tuple 타입으로 data 을 찾을 수 없다

print(a[0])
b[0] = 20

# a[0] = 20 						#'tuple' object does not support item assignment

a = [10, '호랑이', [20, 30], (40, '코끼리', [50, 60], [70, 80])]                # list 안에 tuple 도 당연히 들어갈수 있다
print(a)

a = []
b = list()                                          # list 라는 함수를 call = list
print(type(a), type(b))

c = ()
d = tuple()                                         # tuple 함수
print(type(c), type(d))

e = [10, 20]
f = list('apple')                                   # int X
print(type(e), type(f))

a = []
b = tuple(a)                                        # list -> tuple
c = list(b)                                         # tuple -> list
print(type(a), type(b), type(c))

split

a = '호 랑 이'
print(a)
b = a.split(' ')                             # 문자열을 분리를 시켜서 (split 은 항상 return 값이 있다)저장되는 타입이 list
print(b)

[offset]

· 기준점으로부터 상대적으로 떨어진 거리 ← 배열 index

a = [10, 20, 30]
print(a[0], a[-1])                           # [-]역으로 돈다 BUT [-3]이하, [3]이상 은 out of bound

Dictionary

dictionary를 쉽게 예로 들자면 a = {k: v, k: v, k: v,...} 일 때, 
{k <- key v <- value } 색인 번호, key 값은 중복 X, 배열을 이용한 index 문법 X

a = {}
print(type(a))

a = {1: 10, 2: 20, 5: 40}
print(a)

a = {10: '호랑이', 20: '코끼리', 30: '독수리'}
print(a)

a = {1: 10, 2: 20, 2: 30, 5: 40}                                    # key 가 중복일 경우 가장 최근의 값을로 갱신된다
print(a)

a = {1: [10, 20], 2: [30, 40], 3: [50, 60]}                         # key 값은 증첩해서 넣을 수 있다 list or tuple etc...
print(a)

a = {1: (10, 20), 2: (20, 30), 5: (40, 50)}
print(a)

a = {1: 10, 2: '호랑이', 3: [10, 20], 4: (30, 40), 5: {1: 100}}      # key 값안에 key 중첩 사용 가능 (이중 중첩)
print(a)

a = {'호랑이': 10, '코끼리': 20, '독수리': 30}                          # key 값은 문자열도 가능
print(a)

a = {10: 1, 'apple': 2}                                            # key 값이 문자 숫자 가능하지만 가급적 같은 타입으로 통일
print(a)

a = {'name': '홍길동', 'age': 20, 'salary': 300}                    # key 값 = JSON 문법
print(a)

Dictionary의 활용 - CRUD

CRUD의 의미는 앞서 설명해서 아시죠~?

2021.04.28 - [Programming/Python 기초] - [Python 기초]파이썬 시작하기_Day 4(숫자/문자 변형, list 관리(CRUD)/활용)

a = {'name': '홍길동', 'age': 20, 'salary': 300}                     # key 값 = JSON 문법
print(a)

a['name'] = '이순신'                                               # data 갱신 방법
print(a)

print(a['name'], a['age'], a['salary'])                           # 배열의 틀을 이용하여 key 값 출력

a['height'] = 180                                                 # 찾는 key 값이 없을 경우, 속성이 자동으로 추가된다
print(a)

dictionary에서도 CRUD의 의미는 유용하게 사용됩니다.

1. Create

a = {}
a['name'] = '이순신'                                               # C)create
a['age'] = 20
print(a)

2. Reading

b = a['name']                                                     # R)reading
print(b, a['name'], a)                                            # 출력에서 바로 읽을수도 있고 함수로 지정해줄수도 있다

3. Update

a['name'] = '독수리'                                               # U)update
a['age'] = 100
print(a)

4. Delete

del(a['name'])                                                    # D)delete 1. del () <- 함수 사용
print(a)

del a['name']                                                     # 2. () 생략 가능 <- 예약어 사용
print(a)

Dictionary의 활용 - [], get(), key() 함수를 이용한 select

a = {'name': '홍길동', 'age': 20, 'salary': 300}
print(a)
b = a['name']
c = a.get('name')                                               # dict.get('key')
print(b, c)
print(a.keys())                                                 # 모든 key 출력

# a = range(0, 10)
print(a)
for i in a.keys():                                              # range 와 비슷하게 key 값을 돌릴수 있다
    print(i)

for items in a.items():
    # print('호랑이')
    print(items)                                                # ('name', '홍길동') <- 형식의 출력
# print(type(items))                                         # tuple type
print(items[0], items[1])                                   # name 홍길동 <- 형식의 출력

for values in a.values():
    print(values)                                                # items 과는 다르게 values 는 key 값 X, 값만 출력

Dictionary의 활용 - copy()

여기서 copy는 얕은 복사로 볼 수 있습니다.

a 복사를 20으로 갱신하면 a = 20 ← 메모리의 공유

deepcopy() 깊은 복사 ← 새로운 것을 갱신

a = [1, 2, 3]
b = a                                                # 대입 <- 얕은복사 ; 메모리 공유
print(id(a))
print(id(b))

a[0] = 4
b[2] = 5
print(a)
print(b)                                            # a를 변경시켜도 b를 변경시켜도 메모리를 공휴해서 같은 값
a.append(99)
print(a, b)                                         # 얕은 복사 결과값은 a b 둘다 같다

a = [1, 2, 3]
b = a[:]                                            # 슬라이스[0:3]전체 복사 <- 깊은 복사
print(id(a))
print(id(b))

a[0] = 4
b[2] = 5
print(a)
print(b)

a.append(99)
print(a, b)                                          # a와 b는 영향을 받지 않는다

a = {1: 100, 2: 200, 3: 300}
b = a
a[4] = 400
print(b) # b가 a를 포함해서 나타남 -> 얕은 복사

다음 포스팅에서는 함수 12가지 형태(function)에 대하여 인수 전달, return, break, 가변 인수 등 자세하게 알아보도록 하겠습니다.

오늘 포스팅에서는 파이썬을 활용하여 숫자와 문자의 변형과 list를 관리하는 법에 대하여 알아보도록 하겠습니다.

list 관리를 설명하기 전에 간단하게 숫자와 문자의 변형을 어떻게 하는지에 대하여 알아보도록 하겠습니다.

숫자/문자의 변형 chr(숫자)/ord('알파벳')

print(65)
# JAVA -> print((char)65) 강제 변형 = type casting
print(chr(65))                                      # chr 함수 사용
print(ord('B'))

list 관리 

앞서 언급된 단어 'CRUD'의 의미에 대하여 먼저 설명해드리도록 하겠습니다.

모든 프로그램 언어를 사용하기위해서는 딱 4가지만 기억하고 다룰 줄만 아시면! 기본기는 단단하다고 보시면 됩니다

Create Read Upload Delete 데이터를 어떻게 생성하고, 불러오고, 추가하고, 삭제할 수 있는지 입니다!

이제 list로 데이터를 관리해보도록 하겠습니다~!

CRUD - Create

# list 라는 자료형 자체가 존재 -> [] or {} or ()
a = [10, 20, 30, 40]
print(a)                                            # 출력결과 -> [숫자들] <- list type
b = ['강아지', '호랑이', '코끼리']                       # 요소 -> 숫자 문자 다 허용
print(b)
c = [10, '호랑이', 3.14, True]                       # 서로다른 타입의 항목으로 넣어 맴버들의 설정이 가능 (Only Python)
print(c)

CRUD - Read

a = [10, 20, 30, 40]

1. 통짜로 a전체 출력

print(a)

2. 필요한 인덱스 번호만 출력

print(a[0], a[1], a[2], a[3])           # print(a[4]) <- out of bound / list index out of range

3. for i in 문장

for i in a:
    print(i, end=' ')
print()

for i in [1, 2, 3, 4]:                              # i 는 반복 카운팅용(looping)
    print(i, end=' ')
print()

for value in a:                                     # BUT 여기서는 내용을 꺼내기 떄문에 i 보다는 value, i10, data 를 더 선호
    print(value, end=' ')
print()

CRUD - Update

# 내부적으로 숫자를 대입하는 단순 과정이 아닌 삭제후 추가
a = [10, 20, 30, 40]
a[0] = 50
print(a)

print(id(a[0]), id(a[1]))                           # 고유민증번호

a[0] = 60
print(id(a[0]), id(a[1]))                           # 기존의 들어있는 data 를 삭제시키고 생성했다는것을 보여주는것

CRUD - Delete

a = [10, 20, 30, 40]
del(a[0])                                           # del, remove, erase (depends on language)
print(a)
print(len(a))                                       # a 의 길이를 보여준다 length or size (depends on language)

list 활용 - 내부 list( 1차원, 2차원, 3차원)

a = [10, '호랑이', [20, '코끼리', [30, '독수리']]]

print(a)                                            # list 포함 출력
print(a[2])                                         # 내부 list 만 출력
print(a[2][0], a[2][1])                             # 내부 list 의 선택적 출력
print(a[2][2][0], a[2][2][1])                       # 내부 list 속 내부 list 의 선택적 출력

a = 'Apple'
b = ['A', 'p', 'p', 'l', 'e']
print(a)
print(b)                                            # list 속 알파벳 요소
print(a[0], b[0])

a[0] = 'B' # err>> 문자열은 갱신 X

b[0] = 'B'                                          # list 로 관리된 문자는 갱신 가능
print(b)

a = [인덱스0, 인덱스 1, 인덱스 2] ← a = [10, '호랑이', [20, '코끼리', [30, '독수리']]]

index [0] : int

index [1] : str

index [2] : list

list 활용 - Update & Delete 활용

a = ['a', 'b', 'c', 'd', 'e']
print(a[1:3])                                       # 인덱스 번호 1 ~ 3앞 (3-1)개를 가져오기

a[1:3] = ['F', 'G']                                 # index 1, 3 삭제후, 'F''G'가 새로 갱신
print(a)

a[1:3] = ['H', 'I', 'J', 'K', 'L']                  # index 1, 2가 삭제 됬다고 2개만 갱신할수있는것이 아닌 그 자리로 여러개 대입
print(a)

a = ['a', 'b', 'c', 'd', 'e']
a[1:3] = []                                         # 특정부분만 delete 하고 싶을때 사용
print(a)

a = ['a', 'b', 'c', 'd', 'e']                       # 순수하게 삭제만 한다 (추가라는 개념자체가 없다)
del(a[1:3])
print(a)

list 활용 - append (항목 추가), insert (원하는 항목에 추가), pop (제거)

a = ['o', 'r', 'a', 'n', 'g', 'e']

1. append

print(a)

a.append('f')                                       # list 안에 항목을 추가 시키고 싶을때 append -> 맨뒤 추가
print(a)

a.append(10)                                        # type 상관없이 추가 가능
print(a)

2. insert

a.insert(1, 10)                                     # insert 함수는 원하는 인덱스 번호앞에 추가된다
print(a)

3. pop

a.pop()                                             # 무조건 맨 마지막에 있는 data 를 제거한다
print(a)

a.pop(3)                                            # 원하는 특정 위치의 data 를 제거
print(a)                                            # pop 은 인덱스를 지정해서 제거 , del 은 list 구간 지정 제거

Exception 처리 remove, index(찾고자 하는 인덱스 번호 찾기)

1. remove

a.remove('r')                                       # r을 검색을해서 검색된 r을 제거 시키고 한번을 제거 시키면 중단되기 때문에 뒤에는 지워지지 않는다
print(a)

try:                                                # 예외가 발생하면 try 로 exception 을 잡아준다
    a.remove('t')                                   # 검색에 실패하면 error 발생 (검색에서 반드시 있다고 판단될떄 사용)
except:                                             # 프로그램에서 못찾을 경우 exception 처리를 한다
    print('예외가 발생하였습니다')
    pass
print('호랑이')

2. index

a = ['o', 'r', 'a', 'n', 'r', 'e']

b = a.index('r')                                    # 찾은곳의 인덱스 번호를 알려준다
print(b)

try:
    a.index('t')                                    # index 는 return 값이 있다
except:
    print('예외가 발생하였습니다')
    pass
print('호랑이')

sort 함수 - 비용이 많이 든다 (메모리와 시간 둘중 하나를 선택)

a = ['a', 'c', 'e', 'f', 'd', 'b']
a.sort()                                            # 알파벳 순서대로 정렬을 시켜준다 (sort default )
print(a)                                            # sort 함수는 비용이 많이 든다 -> 1. 시간이 오래걸림 2. 메모리를 많이 사용

reverse() - 역순행이 아니라, 앞과 뒤의 data를 교환

a = ['a', 'c', 'e', 'f', 'd', 'b']
# 이미 정렬이 되어있는 배열을 쓰면 빠르다
a.reverse()                                         # 앞과 뒤의 data 를 swap 시켜준다
print(a)

지금까지 list를 활용한 CRUD에 대하여 알아보았습니다.

다음 포스팅으로는 append와 extend 차이, tuple과 list를 다루는 법등 많이 헷갈리는 함수와 dictionary의 CRUD에 대하여 알아보도록 하겠습니다~!

이번 포스팅에서는 참일 때 실행될 문장의 참/거짓 조건으로 변환하는 연산자인 삼항 연산과 list(range())를 사용하여 숫자를 증가시키는 방법과 마지막으로 for문에 대하여 알아보도록 하겠습니다.

삼항 연산

num = 23
while True:
    print(num)
    num = num // 2 if num % 2 == 0 else (num * 3) + 1     # = 참일떄 실행 될 문장 if 참 조건 else 거짓 조건
    if num == 1:
        print(num)
        print('프로그램을 종료합니다')
        break

list(range(시작 숫자, 마지막 숫자 +1, step증가))

print(range(0, 10), type(range(0, 10)))              # range 는 단독 사용 X
                                                     # 0 < = x < 10 -> 첫번쨰 숫자부터 시작하여 마지막 숫자 앞까지 출력
a = list(range(0, 10))                               # 단독으로 사용 못하고 list 이용 -> 연속된 데이터를 관리하고싶을떄 사용
print(a)
print(list(range(5, 10)))                            # (linked 생략된 단어) list = []
print(list(range(3, 20, 2)))                         # 3 부터 19까지 step 증가를 2씩 출력

for 문

조건문 사용 시에는 tab(들여 쓰기)에 주의해야 합니다~!!

for i in [0, 1, 2, 3, 4]:
    print(i)

for i in [0, 1, 2, 3, 4]:
    print(i, end=' ')
print()                                             # 다음출력을 위해서 줄바꿈해주는 것은 for 문 밖에서 출력

for i in ['월, 화, 수, 목, 금, 토, 일']:
    print(i, end=' ')
print()

for i in ['강아지, 고양이, 햄스터']:
    print(i, end=' ')
print()

for i in range(0, 10):                              # For 문의 정석 코드
    print(i, end=' ')
print()

예제. 1) 구구단 5단 출력

for i in range(1, 10):
    print('5 *', i, '=', i * 5)

예제. 2) 1-10까지의 합

sum = 0
for i in range(1, 11):
    sum += i
    print(sum)

중첩 For 문

for i in range(0, 3):
    for j in range(0, 4):
        print('[', i, j, ']', end=' ')
print()

중첩 for 문 예제) 결과값 두 자리 숫자로 나타내기 (00, 01, 02...)

k = 0
for i in range(3):                                  # 0은 생략 가능
    for j in range(0, 4):
        print('%02d' % k, end=' ')
        k += 1
print()

다음 포스팅에서는 이어서 숫자/문자 변형, list 관리(CRUD)등 리스트 활용에 대하여 알아보도록 하겠습니다

지난 포스팅에 이어 파이썬 초급 기초에 대하여 알아보도록 하겠습니다.

소수점 나타내기 round

print(round(3.145, 2))                         # 소수점 두자리까지 반올림/버림
print(round(3.14, 2))

배열

str = 'Apple'
print(str[4])

str = "무궁화꽃이피었습니다"
print(str[4])

str = "무궁화꽃이피었습니다"
print(str[-2])                          # 끝에서 2번째 (only in Python)

print(str[2:5])                         # 2는 가져올곳의 시작 : 뒤는 5번 앞까지
										# 인덱스 번호 2번부터 시작해서 5-2개 (3개)를 가져온다

str = "무궁화꽃이피었습니다"
print(str[:5])                          # 처음부터 5개 출력
print(str[5:])                          # 5번부터 끝까지 출력

print(str)                              # 전체 출력
print(str[:])                           # 전체 출력

문자열 대입 (컴파일 에러)

str = 'Apple'
a = str[0]                                      # A 출력
print(a)

b = str[ :2]
print(b)                                        # Ap 출력

Error

str [0]='B'                                                            # B는 글자 (문법 허용 X) => 문자열은 대입되는 순간부터 상수화. 즉, 대입을 못 받는다.

c = 'B' + str[1:]                               # 배열을 지정해서 대입
print(c)

값을 대입하는 3가지 방법 (%, {자릿수} , s =")

1. %를 사용

print('호%d 랑%s 이' % (10, '집'))
print('호%d 랑이' % 10)                          # 짝이 1개일때는 ()의 생략이 가능

2. {}를 사용 

{0번째: 10}{1번째: 호랑이}

print('무궁화{0}꽃이{1} 피었습니다'.format(10, '호랑이'))
print('%s 집에 %d가고 싶다' % ('나중에', 82))
print('{0} {1}자고 싶다'.format('지금', 82))

3. 함수="사용

s = '무궁화{0} 꽃이 {1}피었습니다'
print(s)                                       # {} 포함한 결과값
s.format(10, '호랑이')
print(s)                                       # 무궁화{0} 꽃이 {1}피었습니다 와 같은 결과값
t = s.format(10, '호랑이')                      # 함수를 이용한 변경
print(t)
s = s.format(10, '호랑이')                      # s 자체를 변경
print(s)

워드 카운트 (문자열의 길이와 개수, 인덱스 번호)

s = '무궁화꽃이피었습니다'
print(len(s))                                       # 문자열의 갯수

s = '무궁화꽃이무궁회피었무궁화습니다무궁화'
print(s.count('무궁화'))                              # 찾고자는 문자열의 갯수
print('무궁화꽃이무궁회피었무궁화습니다무궁화'.count('무궁화'))  # 직접 대입도 가능

s = '무궁화꽃이꽃이피었습니다'
print(s.find('피았'))                           
# 찾고자하는 문자열의 인덱스(번째수) 번호 / find 검색 실패 경우 항상 -1 return

문자열 출력 결과 대소문자 + 대치

s = 'Apple'                                     # 문자열을 관리하는 객체 생성
t = s + 'Orange'
s = s + 'Banana'
print(t, s)

print(s.lower())                                # 출력 결과를 소문자로
print(s)                                        # s 자체는 변경X

t = s.lower()                                   # 원본데이터는 변경시키지 않는 것이 원친 return 값 으로
print(t)

print(s.upper())                               # 출력 결과를 대문자로
print(s.replace('Banana', 'Orange'))           # 바나나 -> 오렌지
print(s)                                       # s 값이 변경이 안됬다는것은 대치결과를 return 값으로 받아준것

print(s.replace('banana', 'Orange'))           # 대소문자 구분하여 찾아야한다

list 크기, 관리, 분리

s = '무궁화 꽃이 피었습니다'
print(s.split())                              # 스페이스를 기준값으로 글자를 분리
# ['무궁화', '꽃이', '피었습니다'] -> 대괄호 list type(1개 이상의 결과값)
t = s.split()
print(t)                                      # s 자체의 변경 X

print(len(t))                                 # 배열의 크기 리스트의 크기

print(t[0], t[1]*3, t[2])                     # 문자열 자체가 배열로 되어있기떄문에 배열로 관리 + 반복횟수 출력

s = '무궁화:꽃:이:피었:습:니다'
print(s.split(':'))                           # default 는 스페이스며 :를대상으로 구분 (특글자 중심으로 분리)

산술 연산

print(16 + 3)
print(16 - 3)
print(16 * 3)
print(16 / 3)  # 몫
print(16//3)   # 몫 (정수)
print(16 % 3)
print(16 ** 3)

관계 (비교) 연산

print(3 > 2)
print(3 < 2)
print(3 >= 3)
print(3 <= 3)
print(3 == 3)
print(3 != 3)

논리 연산

# AND Java && 거짓이 하나라도 있으면 무조건 거짓

print("-----------")
print(False and False)
print(False and True)
print(True and False)
print(True and True)
# OR Java || 참이 하나라도 있으면 무조건 참
print("-----------")
print(False or False)
print(False or True)
print(True or False)
print(True or True)
# 부정 연산 Java ! 안에있는 결과를 변경시키지 않고 사용하려는때 사용
print("-----------")
print(not(3 > 2))

print(3 + 2 > 4 and 6 < 2 * 4)                  # 해석이 항상 산술 연산 부처
print(5 > 4 and 6 < 8)                          # 산술이 먼저 일어나기에 위의 문제와 동격
print(True and True)

print(((3 + 2) > 4) and (6 < (2 * 4)))          # 위의 모든 출력이 이러한 논리

랜덤 데이터 random과 randint (모사 데이터; 사물 레이션)

from random import* -> random number로부터 제공되는 random 모듈을 사용 

(randint, rnadom, uniform, randrange)

print(random())                                 # 0.0부터 1.0 사이의 값을 랜덤하게 출력
# 3 <= x <= 5 -> 3과 5를 포함
print(randint(3, 5))                            # 3-5 사이의 수를 랜덤 출력
print(randint(10, 100))                         # 10 -100 사이의 수를 랜덤 출력

 - 숫자 2부터 시작해서 20 사이에 있는 숫자를 3씩 증가를 했을 때

print(randrange(2, 20, 3))                      # 2 5 8 11 14 17 20 중 한개를 랜덤하게 뽑아준다

압력 값 (= java print scanner)

a = input('입력하세요:')                          # 숫자를 입력 받기를 원할떄
print(a, type(a))                              
print('----------------')					   # string -> int 로 출력하는 3가지 방법

1. 

print(int(a)*int(a))

2. 

print(int(a)**2)

3. 

a = int (input('입력: '))
print(type(a), a**2)

제어문 (if, while)

1. if 제어문

if (제어문)에 열고 닫아도 되지만 정석은 아니다. () 생략이 정석!

if 3 > 2:                                   # 2. 제어문에 끝에는 :이 붙는다
    print(1)                                    # 3. 조건이 만족할때의 실행 문장은 tab 처리 (하지않을경우 에러 )
    print('----------------')

if 3 > 4:
    print(1)
else:
    print(2)

if 3 > 4:
    print(1)
else:
    print(2)
    print(3)                                    # 위와의 구분이 없으면 enter 를 3번정도 두고 거리를 둔다 if else 상관없이 출력

if 3 > 4:
    print(1)
else:
    print(2)
	print(3) 									# else 문에 들어가 있는 출력값으로 뜬다

2. while 제어문

a = 0
while a < 10:
    a += 1
    print(a)
    print('호랑이')

a = 0
while a < 10:
    a += 1
    if a == 3:
        continue
    if a == 6:
        break
        print(a)
    print('집')

다음 포스팅에서는 이번 포스팅과 연관된 간단한 예제를 풀어보도록 하겠습니다.

이번 포스팅에서는 파이썬을 배우기에 가장 기초적인 단계를 시작으로 차근차근 설명을 해보도록 하겠습니다.

파이썬 파일 생성하기

이전 포스팅으로 파이썬과 파이참을 설치하셨다면, new project를 생성해주시면 됩니다~! (저는 Day1으로 설정했습니다)

다음 새로운 파이썬 파일을 만들기 위해 Python_Study 디렉토리를 생성하고 Day1의 파이썬 파일을 생성하여 시작합니다

주석 # (코드의 의미 설명 또는 메모에 요긴하게 사용)

shift F10 = 실행의 단축키

코드를 실행할때, 실행할 파일명을 확인해줍니다. (main일 경우, day1은 실행되지 않기 때문에 주의!!!)

숫자 / 문자 출력

print('호랑이')
print(10, '호랑이', 20, '독수리')  # 콤마가 자동으로 출력에 한칸을 띄어준다
print(3.14)                    # 부동 소수 타입
print(True, False)             # 첫 대문자를 사용해야한다
print(10) ; print(20)          # 한줄 처리를 하고 싶을떄 ; 사용
print(10, end='\n')            # 자동으로 줄바꿈 end='\n' (carriage return)이 생략되어있다
print(10, end=' ')             # 출력값이 한줄 default

구분선과 입력

print('--------------------------------')      # Separate = 구분선
print('-'*50)                                   # 50개의 '-'로 구분선 생성가능
print(''*50)                                   # 출력하고자하는 문자열 반복
print('%d %d %s' %(10, 20, '호랑이'))            # 숫자 혹은 문자열 %d %s 입력값은 %()안에 입력
print('코%d 끼%d 리%s' %(10, 20, '호랑이'))       # %앞에 입력가능

Default 값의 활용 sep, end

print(10, 20, 30, 40)
print(10, 20, 30, 40, sep=' ')
print(10, 20, 30, 40, sep=',')                  # default -> sep(띄어쓰기 스페이스 또는 콤마로 나타내기)
print(10, 20, 30, 40, sep=',', end='\n')        # default -> end(default 값으로 줄바꿈도 제어가능)

변수 Type 확인

print(type(10), type('호랑이'), type(3.14), type(True))      # 변수의 type 정보를 알려준다
print( type([ ]), 	  type(( )),       type({ }))
# 숫자 10, 문자 '호랑이', 숫자 3.14, True 값
# [list], (Tuple), {Dictionary}

숫자 문자 연산

print(10 + 20)
print(10 + '호랑이')               # 문법이 성립하지 않음
print('호랑이' + 10)               # 마찬가지
print('호랑이' + '독수리')
print(10 + int('123'))           # 문자열 -> 숫자 int('문자열')
print('호랑이' + str(10))          # 숫자 -> 문자열 str(숫자)

변수 선언 방법의 유형

1. Python은 변수를 선언하는 타입은 없다.

java의 경우, 변수를 선언해 주어야 한다

int a = 10;
int b = 20;

Python의 경우, 변수 선언이 생략된다.

a = 10
b = 20
print(a, b)

2. 중복 변수를 선언할 경우, 과거의 변수는 사라지고 새로만든 변수가 적용된다.

- 가장 마지막 변수만 적용

a = 10
b = 20
a = 30; b = 40;
print(a, b)

3. 변수를 2-3개 동시에 사용할 수 있다.

a, b = 50, 60
print(a, b)
a, b, c = 1, 2, 3
print(a, b, c)

4. 두 변수의 값을 동시에 대입할 수 있다.

a = b = 70
print(a, b)

※ Error

a = 10; b = 20 # ;을 사용하여 두 변수를 한줄에 입력할 수 있다
a = 10, b = 20 # Error

Python의 SWAP

a = 10
b = 20
b, a = a, b
print(a, b)

a++

a++ 코드는 유일하게 Python에서만 작용이 되지않기때문에 2가지 방법으로 표기할 수 있다.

a = 100
a = a + 1			# 첫번째 방법
a += 1				# 두번째 방법
print(a)

고유 식별 번호

a = 10
b = 20
c = 10
print(id(a), id(b), id(c))     # a와 b의 고유 번호 BUT c(a의 고유번호와 같음) 경우, 같은 id를 가진다 (only in Python)
a = '호랑이'
b = '코끼리'
c = '호랑이'
print(a, b, c)

16 진수 표현

a = 0x20
print(a)
b = 0o0376                          # 0x or 0o를 사용하여 표현한다
print(b)

복소수의 연산

a = 1 + 2j                       # language j 복소수 i 의미
b = 3 + 4j
print(a + b)

나누기

a = 10
b = 3
print(a/b, a%b, a//b)                           # 몫, 나머지 , 몫의 정수

pow 제곱

print(2**8)

지금까지 파이썬은 기본 입출력에 대하여 알아보았습니다.

다음 포스팅에서는 문자열, list, 산술/비교 연산, 논리연산, 랜덤 데이터, 제어문 등에 대하여 기초 day2로 알아보도록 합시다.

Python 설치하는 방법

https://www.python.org/

파이썬 공식 링크를 들어가면

저의 경우, Windows 환경에서 설치하기 위해 python releases for window 3.9.0 버전을 선택해 주었습니다.

그런 다음, add python 3.9 to path check (경로설정)후, Custonmize installation 하고

next를 누른 뒤, C:\Python\Python39으로 install location을 바꿔줍니다. (나중에 라이브러리들을 설치하기에 편하도록 하기 위한 것이기 때문에 Custimize installation을 굳이 해줄 필요는 없습니다, 단지 "추천"인 거죠~!)

이렇게 하면, python설치는 간단하게 완료되었습니다.

python 3.9(64-bit)를 실행할 경우 바로 terminal mode 입장을 합니다.

터미널로 사용하지 않으실 분들은 다음 tool 설치를 위해 ctrl + z로 종료하고 Pycharm을 설치해보도록 합시다!

PyCharm 설치

https://www.jetbrains.com/ko-kr/pycharm/download/#section=windows

홈페이지를 들어가서 (도구 - IDE - PyCharm - 다운로드 - Community 설치) 순으로 들어가서 위의 화면이 뜨면 다운로드해주세요!

이번에는 따로 커스텀하지 않고 종료 창 전까지 next를 선택한 후, 설치를 완료합니다.

오늘 포스팅은 파이썬 기초를 시작하기 전, 설치방법에 대하여 간단하게 설명해 보았습니다. 

다운을 받고 설치를 하셨다면, 다음 포스팅부터는 파이썬 초급이자 가장 기초적인 입력과 출력에 대하여 설명하겠습니다.