Development Project

[ 2021 NIPA AI - 기본 ] 1. 핵심 파이썬 기초 프로그래밍 (01~05) + α 본문

AI/Edu

[ 2021 NIPA AI - 기본 ] 1. 핵심 파이썬 기초 프로그래밍 (01~05) + α

나를 위한 시간 2021. 10. 19. 22:47

01 파이썬 활용을 위한 기초적인 재료

ㆍ 입력 『 input( ) 』 => ex) 「 받을 문자 형식( input("문장")) 」

  • 하나 
    • num = int(input("숫자 입력 : "))		#int없이(형변환없이) 받아오면 문자열
print(num)
  •  여러
    • 한 변수에 전체저장
      • 리스트 
        • num = input("숫자 입력 : ").split()	#숫자 입력 : 3 4 5
print(num)	#['3', '4', '5']
      • 문자열 
        • b = input("국어, 영어, 수학 : ")		#국어, 영어, 수학 : 80 85 70
print(b)		#80 85 70
print(type(b))	#<class 'str'>
    • 각 변수에 따로저장
      • split( 구분할 문자 ) 
        • a, b, c = input("숫자 입력 : ").split()	#숫자 입력 : 3 4 5
print(int(a))	#3
print(int(b))	#4
print(int(c))	#5
      • eval( 분리할 문자열 ) 
        • b = input("국어, 영어, 수학 : ")	#80, 70, 60
k1, k2, k3 = eval(b)
print(k1)	#80
print(k2)	#70
print(k3)	#60

 

ㆍ 출력 『 print("문장") 』  

  • 문장은 큰/작은 따옴표 안에 작성해야함
    print("문장")	#문장
print('문장')	#문장

 

  • 출력할 문장에 따옴표(' ', " ")가 있는 경우, 
    • 큰 따옴표로 출력할 전체 문장을 감싸고 있다면, 작은 따옴표에 문장을 넣기 
      • print("Hello 'World'!")   #Hello 'World'!
    • 작은 따옴표로 출력할 전체 문장을 감싸고 있다면, 큰 따옴표에 문장을 넣기
      • print('Hello "World"!')   #Hello "World"!
    • 출력할 따옴표 앞에 \ 넣기 
      • print("Hello \"World\"!")   #Hello "World"

 

  • 다른 문자열사이 공백 O / 한줄에 출력 / 다른 문자형 가능 ) 콤마[ , ] 사용 
    • print(3, "Hello", 45)	#3 Hello 45
  • 다른 문자열사이 문자열을 넣을 수 있는 sep 속성 
    • print(3, "Hello", 45, sep="")   		#3Hello45
print(3, "Hello", 45, sep=" ^-^ ")	#3 ^-^ Hello ^-^ 45
  • print() 이후 커서위치를 조정할 수 있는 end 속성 
    • print(3, "Hello", 45, end="")		# ① Interactive Mode : #3 Hello 45>>> ② 그 외 : #3 Hello 45

print(3, "Hello", end="")
print(5, "World")				#3 Hello 5 World

 

  • 다른 문자열사이 공백 X / 한줄에 출력 / 다른 문자형 불가능 ) 더하기[ + ] 사용 
    • print("Hello"+"World")	#HelloWorld

 

  • 다른 문자열사이 공백 X / 한줄에 출력 / 다른 문자형 가능 ) 문자열 형식화
    • % 이용 
      • print("오늘은 %d일입니다."%18)   			#오늘은 18일입니다.
print("저는 %s 입니다!"%"\"나를 위한 시간\"")	#저는 "나를 위한 시간" 입니다!
    • format() 메서드 이용 
      • print("저는 {}입니다.".format("나를 위한 시간"))		#저는 나를 위한 시간입니다.
print("저는 {{{}}}입니다.".format("나를 위한 시간"))	#저는 {나를 위한 시간}입니다.
print("오늘은 {1}월 {2}일이고, {0}년입니다.".format(2021, 10, 19))	#오늘은 10월 19일이고, 2021년입니다.

 

ㆍ 기본 자료형

  => 무슨 자료형인지 모를땐 『type(변수이름)』 / 형변환 : 『원하는자료형(변수이름)』

  • int
    • 형 변환시 int( )는 소숫점 밑의 자리를 버림 ( 반올림 X )
  • float
    • 참고) 실수+실수는 반올림 오차 존재
      print(0.1+0.2)   #0.30000000000000004
      (원래는 InteractiveMode만 원본이고 나머진 반올림한 0.3을 보여줘야 하는데 PyCharm도 위와 같이 출력함 ? )
  • str
  • bool
  • list (여러 자료형 가능 / 순서 존재)
  • tuple
  • dic
  • set
  • 주석
    • 한줄 : #
    • 여러줄 : """ """, ''' '''

 

ㆍ 변수

  • 변수 = 자료형의 값을 저장하는 공간
  • 변수 생성 규칙
    • 영어, 한글 등 각 나라 문자와 숫자를 사용할 수 있다.
    • 대소문자를 구분한다.
    • 문자부터 시작해야 하며 숫자부터 시작하면 안된다.
    • 특수 문자(+, -, *, /, $, @, &, %등)는 사용할 수 없다.
    • 예약어는 사용할 수 없다.
      => 즉, 영어와 한글, 각 나라 언어, 숫자, 언더바는 사용가능하지만 숫자로 시작은 불가능하다!

 

02 특정 조건에 따라 작업을 수행하는 조건문

ㆍ 논리자료형과 비교연산

  • bool (논리 자료형)
    • True(참) or False(거짓)
  • 비교 연산자
    • ==(같다), !=(다르다), >, <, >=, <=

 

ㆍ 논리자료형을 활용한 연산

  • and == 전부 True면, 결과값 True 
    • print(3==3 and 4<=5 and 6>2)   #True
  • or == 하나라도 True면, 결과값 True 
    • print(3==3 or 4<=5 or 6>2)   #True
  • not == False에 붙으면 True, True에 붙으면 False 
    • print(not 3==4)   #True

 

ㆍ 조건문

if 조건 1:		# 조건 1 True 이면
    do A		# A 실행 
elif 조건 2:		# 조건 1 False and 조건2 True 이면
    do B		# B 실행
elif 조건 3:		# 조건 1 False and 조건2 False and 조건3 True 이면
    do C		# C 실행
. . .	
else:			# 모든 조건이 False 이면
    do Z		# Z 실행

예시)

number = int(input("숫자를 입력 하세요 : "))
if number >= 1000:
    print("세 자릿수 이상")
elif number >= 100:
    print("세 자릿수")
elif number >= 10:
    print("두 자릿수")
elif number >= 1:
    print("한 자릿수")
else:
    print("자연수를 입력 하세요.")

 

03 반복되는 명령을 줄여주는 반복문

ㆍ for문

  • 문자열 사용
    • for letter in “Hi there”:
      print (letter, end=" ")	#H i   t h e r e
  • 리스트 사용 
    • for i in [1,3,5,7,9]:
	print(i, end =" ")	#1 3 5 7 9
    
for almond_taste in ["corn", "injeolmi", "honeyButter"]:
	print(almond_taste, "taste", end = ", ")	#corn taste, injeolmi taste, honeyButter taste,
  • range(처음숫자, ~까지[*결과값과 일치 X], 간격) 함수 사용 
    • for i in range(1, 10, 2):	
	print(i, end =" ")		#1 3 5 7 9

 

ㆍ while문

num = int(input("지나가던 행인에게 빌려줄 돈의 액수를 입력 : "))
while num>0:	#조건 만족시 반복문 수행
	print("점점 거지가 되어가고 있습니다.")
    num = int(input("지나가던 행인에게 빌려줄 돈의 액수를 입력 : "))
print("거지를 면했습니다")

 

ㆍ 반복문 조절 명령어

  • continue 
    • for dayOfWeek in range(1,6):			#난 숫자 1 싫어!
    if dayOfWeek == 3:				#난 숫자 2 싫어!
        print("난 숫자 3이 좋아!")			#난 숫자 3이 좋아!
        continue						#난 숫자 4 싫어!
    print("난 숫자", dayOfWeek, "싫어!")		#난 숫자 5 싫어!
  • break 
    • print("오늘은 운동장을 5바퀴 뛰쟈!")		
for finishing in range(1,6):		
    if finishing == 4:			
        print("띵동댕동~~")		
        print("앗 종이 쳤네.. 다음에 다시 뛰어야겠다 \n어서 교실로 돌아가쟈!")	
        break;	
    print("오예~!", finishing, "바퀴 완주했어~")	
    
#오늘은 운동장을 5바퀴 뛰쟈!
#오예~! 1 바퀴 완주했어~
#오예~! 2 바퀴 완주했어~
#오예~! 3 바퀴 완주했어~
#띵동댕동~~
#앗 종이 쳤네.. 다음에 다시 뛰어야겠다 
#어서 교실로 돌아가쟈!

 

04 파이썬에서 자료를 담는 여러가지 방식

ㆍ List(리스트) == [ 항목, ... ]

  • 짝꿍 X / 순서 O / 중복 O / 수정 O 항목들의 모임
  • 리스트 생성
    • 직접 
      • a = [1, 2, 3]
print(a)	#[1, 2, 3]
    • 문자열
      • print(list("Python"))	#['P', 'y', 't', 'h', 'o', 'n']
         
    • range( 처음숫자, 가까운 숫자, 차이 )  
      • print(list(range(1,50,5)))	#[1, 6, 11, 16, 21, 26, 31, 36, 41, 46]
  • 리스트 조작
    • 추출 (원본 유지)
      • <시퀸스의 특징> 인덱싱 == 리스트이름[ 자리 ] 
        • a = ["A", "BC", 1, 3.5]
print(a[0])				#A
print(a[-1])			#3.5
print(a[0] + str(a[3]))	#A3.5
print(a[0]*3 + str(a[2]))	#AAA1
      • <시퀸스의 특징> 슬라이싱 == 리스트이름[ 추출한 처음 자리 : 마지막 자리 -1 ] 
        • a = ["Apple", "Banana", "Peach", "Melon"]
print(a[1:3])		#['Banana', 'Peach']
print(a[-1:1])		#[]

# 숫자 X == 전부
print(a[1:])		#['Banana', 'Peach', 'Melon']
print(a[-3:])		#['Banana', 'Peach', 'Melon']
print(a[:3])		#['Apple', 'Banana', 'Peach']
print(a[:-3])		#['Apple']
      • <시퀸스의 특징> 값 확인 
        • a = [1, 2, 3, 4, 5]
print(3 in a)		#True
print(6 in a)		#False
print(6 not in a)		#True
      • index( 추출할 자료 ) == 자료의 처음 위치 < 인덱싱과 반대 > 
        • a = ["a", "b", "c", "d", "c"]
print(a.index("c"))	#2
      • <시퀸스의 특징> len( 리스트 ) == 리스트 요소의 수 
        • a = ["a", "b", "c", "d", "c"]
print(len(a))	#5
      • count( 추출할 자료 ) == 자료의 개수 
        • a = ["a", "b", "c", "d", "c"]
print(a.count("c"))	#2
print(a.count("f"))	#0
    • 변경 (원본 훼손)
      • 수정
        • 인덱싱 활용 
          • a = ["a", "b", "c", "d", "e"]
a[0] = 0
print(a)	#[0, 'b', 'c', 'd', 'e']
        • 슬라이싱 활용 
          • a = ["a", "b", "c", "d", "e"]
a[1:3] = [1, 2, 3, 4]
print(a)	#['a', 1, 2, 3, 4, 'd', 'e']
        • sort( ) == 오름차순 정렬 < *원본을 변경 / 반환값 X > 
          • a = [10, 5, 4, 9, 27]
a.sort()	#"print(a.sort())" and "b=a.sort()" don't work properly. 
print(a)	#[4, 5, 9, 10, 27]
        • reverse( ) == 내림차순 정렬 < *원본을 변경 / 반환값 X > 
          • a = [10, 5, 4, 9, 27]
a.reverse()	#"print(a.reverse())" and "b=a.reverse()" don't work properly.
print(a)		#[27, 9, 4, 5, 10]
      • 추가
        • append( 자료 ) == 단 한개의 자료만을 마지막 원소 뒤에 추가  
          • a = ["a", "b", "c"]
a.append("f")
print(a)	#['a', 'b', 'c', 'f']
a.append([1, 2, 3, 4])
print(a)	#['a', 'b', 'c', 'f', [1, 2, 3, 4]]
a.append("Hello")
print(a)	#['a', 'b', 'c', 'f', [1, 2, 3, 4], 'Hello']
        • insert( 위치, 자료 ) == 단 한개의 자료만을 원하는 위치에 추가 
          • a = ["a", "b", "c"]
a.insert(1, "f")
print(a)	#['a', 'f', 'b', 'c']
a.insert(3, [1, 2, 3, 4])
print(a)	#['a', 'f', 'b', [1, 2, 3, 4], 'c']
a.insert(15, "Hello")
print(a)	#['a', 'f', 'b', [1, 2, 3, 4], 'c', 'Hello']
        • extend( 자료 ) == 새로운 리스트를 마지막 원소 뒤에 추가 
          • a = ["a", "b", "c"]
a.extend("f")
print(a)	#['a', 'b', 'c', 'f']
a.extend([1, 2, 3, 4])
print(a)	#['a', 'b', 'c', 'f', 1, 2, 3, 4]
a.extend("hello")
print(a)	#['a', 'b', 'c', 'f', 1, 2, 3, 4, 'h', 'e', 'l', 'l', 'o']
      • 삭제
        • remove( ) == 같은 값이 존재한다면, 앞의 값을 지움 
          • a = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'a', 'b', 'c']
a.remove('a')
print(a)	#['b', 'c', 'd', 'e', 'f', 'g', 'a', 'b', 'c']
        • del 명령어 == 해당 위치의 값을 지움 
          • a = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'a', 'b', 'c']
del a[0]
print(a)	#['b', 'c', 'd', 'e', 'f', 'g', 'a', 'b', 'c']
del a[0:3]
print(a)	#['e', 'f', 'g', 'a', 'b', 'c']
        • 슬라이싱 
          • a = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'a', 'b', 'c']
a[1:4] = []
print(a)	#['a', 'e', 'f', 'g', 'a', 'b', 'c']
        •  * 리스트 안에 리스트는 가능하므로 인덱싱으로 삭제 불가 
          • a = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'a', 'b', 'c']
a[0] = []
print(a)	#[[], 'b', 'c', 'd', 'e', 'f', 'g', 'a', 'b', 'c']

ㆍ Tuple(튜플) == ( 항목, ... )

  • 짝꿍 X / 순서 O / 중복 O / 수정 X 항목들의 모임
  • 튜플 생성
    • 직접 
      • a = (1, 2, 3)
print(a)	#(1, 2, 3)
    • 문자열 
      • print(tuple("Python"))		#('P', 'y', 't', 'h', 'o', 'n')
    • range() 
      • print(tuple(range(1, 50, 5)))	#(1, 6, 11, 16, 21, 26, 31, 36, 41, 46)
    • 리스트 
      • a = [1, "가", 2, "나"]
b = tuple(a)
print(b)	#(1, '가', 2, '나')
  • 튜플 조작
    • 추출 (원본 유지) == 튜플은 원본훼손 불가능
      • <시퀸스의 특징> 인덱싱 == 튜플이름[ 자리 ]
        • a = ("A", "BC", 1, 3.5)
print(a[0])		#A
print(a[0] + str(a[3]))	#A3.5
print(a[0]*3 + str(a[2]))	#AAA1
      • <시퀸스의 특징> 슬라이싱 == 튜플이름[ 추출한 처음 자리 : 마지막 자리 -1 ] 
        • a = ("Apple", "Banana", "Peach", "Melon")
print(a[1:3])       #('Banana', 'Peach')

# 숫자 X == 전부
print(a[1:])        #('Banana', 'Peach', 'Melon')
print(a[:3])        #('Apple', 'Banana', 'Peach')
      • <시퀸스의 특징> 값 확인 
        • a = (1, 2, 3, 4, 5)
print(3 in a)	#True
print(6 in a)	#False
print(6 not in a)	#True
      • index( 추출할 자료 ) == 자료의 처음 위치 < 인덱싱과 반대 > 
        • a = ["a", "b", "c", "d", "c"]
print(a.index("c"))	#2
      • <시퀸스의 특징> len( 튜플 ) == 리스트 요소의 수 
        • a = ("a", "b", "c", "d", "c")
print(len(a))	#5
      • count( 추출할 자료 ) == 자료의 개수 
        • a = ("a", "b", "c", "d", "c")
print(a.count("c"))	#1
print(a.count("f"))	#0
      • Packing, Unpacking (튜플만) == 여러 값을 묶고, 풀기 
        • pack = 1, 2, 3, 4, 5, "A", "B"	#Packing
a, b, *c = pack				#Unpacking, 나머지를 리스트로 묶을땐 <*변수>
print("a = %d, b = %d,"%(a, b),"c =", c)	#a = 1, b = 2, c = [3, 4, 5, 'A', 'B']

ㆍ Dictionary(딕셔너리) == { Key0 : Value0, ... }

  • 짝꿍 O / 순서 X / Key 중복 X / 수정 O 항목들의 모임
  • *Key는 변할 수 없는 자료형! (변수 또는 튜플 가능, 리스트 불가)
  • 딕셔너리 생성
    • 직접 
      • person = {'name':'Michael', 'age':10}
print(person)	#{'name':'Michael', 'age':10}
  • 딕셔너리 조작
    • 추출 (원본 유지)
      • 하나
        • 하나의 Key => 하나의 Value 
          • a = {"Key": "Value", 1: "one", 2.22: 2.22, (3, 4): 34, 3: [1, 2]}
print(a["Key"])		#Value
print(a[1])			#one
print(a[2.22])		#2.22
print(a[(3, 4)])		#34
print(a[3])			#[1, 2]
        • Key 여부 확인 
          • a = {"Key": "Value", 1: "one", 2.22: 2.22, (3, 4): 34, 3: [1, 2]}
print("Key" in a)		#True
print("Value" in a)	#False
print((3,4) in a)		#True
print(1 not in a)		#False
        • Value 여부 확인 
          • a = {"Key": "Value", 1: "one", 2.22: 2.22, (3, 4): 34, 3: [1, 2]}
print(a.get("Key"))		#Value
print(a.get("Value"))		#None
print(a.get((3, 4)))		#34
      • 전체
        • Key만 
          • a = {"Key": "Value", 1: "one", 2.22: 2.22, (3, 4): 34, 3: [1, 2]}
print(a.keys())		#dict_keys(['Key', 1, 2.22, (3, 4), 3])
        • Value만 
          • a = {"Key": "Value", 1: "one", 2.22: 2.22, (3, 4): 34, 3: [1, 2]}
print(a.values())	#dict_values(['Value', 'one', 2.22, 34, [1, 2]])
        • Key, Value 같이 
          • a = {"Key": "Value", 1: "one", 2.22: 2.22, (3, 4): 34, 3: [1, 2]}
print(a.items())		#dict_items([('Key', 'Value'), (1, 'one'), (2.22, 2.22), ((3, 4), 34), (3, [1, 2])])
    • 변경 (원본 훼손)
      • 수정
        •  
      • 추가 
        • a = {"Key0": "Value0", "Key1": "Value2"}
a['Key2'] = "Value2"
print(a)	#{'Key0': 'Value0', 'Key1': 'Value2', 'Key2': 'Value2'}
      • 삭제
        • del 명령어 
          • a = {"Key": "Value", 1: "one", 2.22: 2.22, (3, 4): 34, 3: [1, 2]}
del a[3,4]
print(a)	#{'Key': 'Value', 1: 'one', 2.22: 2.22, 3: [1, 2]}
        • pop( Key값 ) == 값 추출 후에 딕셔너리에서 해당 값 삭제 
          • a = {"Key": "Value", 1: "one", 2.22: 2.22, (3, 4): 34, 3: [1, 2]}
b = a.pop(3)
print(a)	#{'Key': 'Value', 1: 'one', 2.22: 2.22, (3, 4): 34}
print(b)	#[1, 2]
        • clear( 딕셔너리 ) == 초기화 
          • a = {"Key": "Value", 1: "one", 2.22: 2.22, (3, 4): 34, 3: [1, 2]}
a.clear()
print(a)	#{}

ㆍ Set(집합) == { 항목, ... }

  • 짝꿍 X / 순서 X / 중복 key X / 수정 O 항목들의 모임
  • 집합 생성
    • 직접 
      • a = {1, 2, 3, 2, 3, 4}
print(a)	#{1, 2, 3, 4}
    • 문자열 
      • print(set("Python"))		#{'t', 'n', 'y', 'P', 'o', 'h'}
    • range( 처음숫자, 가까운 숫자, 차이 )
      • print(set(range(1,50,5)))   	#{1, 36, 6, 41, 11, 46, 16, 21, 26, 31}
  • 집합 조작
    • 집합 명령어 (나머지는 생략)

 

05 같은 듯 다른 함수와 메서드

ㆍ 함수 vs 메서드

  •  함수
    • 특징 
      • 결과 값을 변수에 대입 O
      • 독립적으로 정의되므로 이름으로만 호출이 가능!
      • 함수가 메소드보다 더 포괄적인 의미
    • 구조
      • 입력값을 주면 이를 처리하여 결과 값을 리턴
    • 종류
      • 내장함수
        • input( )
        • print( )
        • max( )
        • min( )
        • sum( )
        • len( )
        • ...
      • 사용자 지정 함수 ( 입력 == 매개변수 / 처리 == 함수내용 / 결과 == 반환값 ) 
        • def 함수이름(매개변수):
    <수행할 명령>	#들여쓰기 필수!
    ...				#들여쓰기 필수!
    return 반환값		#들여쓰기 필수!
  • 메서드
    • 특징 
      • 결과 값을 변수에 대입 X
      • 객체와 연관되어 사용됨 => .(점)으로 연결!
      • 클래스 및 객체에 연결되어있는 함수 == 클래스 내에 선언된 함수
      • 이름으로만 호출되지 않고, 정의된 클래스의 참조에 의해 클래스를 호출해야함!

'AI > Edu' 카테고리의 다른 글

[ 2021 NIPA AI - 기본 ] 3. 공공데이터를 활용한 파이썬 데이터분석 프로젝트 - 2. 지하철 승하차 인원 정보를 활용한 역별 혼잡도 분석  (0) 2021.12.16
[ 2021 NIPA AI - 기본 ] 3. 공공데이터를 활용한 파이썬 데이터분석 프로젝트 - 1. 코로나 데이터 분석하기  (0) 2021.12.16
[ 2021 NIPA AI - 응용 ] 2. 딥러닝 시작하기 (01~05) + α  (0) 2021.12.13
[ 2021 NIPA AI - 응용 ] 1. 머신러닝 시작하기 (01~05) + α  (0) 2021.12.11
[ 2021 NIPA AI - 기본 ] 2. 데이터 분석을 위한 라이브러리 (01~05) + α  (0) 2021.10.22
'AI/Edu' Related Articles more
Comments