Python 기본편
https://www.youtube.com/watch?v=kWiCuklohdY&list=WL&index=10
유명한 나도 코딩님의 강의를 듣고 내 나름대로 다른 언어들과 다른 점을 적는 글이다. 취업 전까지는 C++, Java처럼 백엔드에만 관련 있는 언어만을 보고 Python은 내가 인공지능 쪽의 뜻을 가져 대학원을 가거나 새롭게 공부하기 전까지는 볼 일이 없을거라 생각했는데 놀랍게도 학부 수강신청을 할 게 없어서 인공지능 수업을 듣게되어 Python을 공부하게 되었다.
수업 중에 Python을 따로 가르쳐주시며 진행 하는 줄 알았는데... 아니다. 완전히 Python을 기본으로 깔고 응용하는 레벨로 수업을 시작하셨다. 급하게 기본 문법이라도 알아두어야 했고 감사하게도 무료 강의가 있어 이렇게 공부한다. 기본적으로 목표는 이번주 안으로 기본편의 공부를 마칠 예정이다. 하루 1시간씩 공부해서 포스팅을 나눌까 고민했는데 그냥 이 글을 계속 수정하여 하나의 글로 묶어 나중에 내가 보기 편하게 하기로 했다.
이 밑으로는 다른 언어와 다른 점에 대해서 내가 정리한 것이다.
print(not True)
// False 출력
1. 기본적으로 True, False의 첫 글자가 대문자다. 또 !True가 아닌 not을 사용하여 부정한다.
print("ㅋ"*9)
// ㅋㅋㅋㅋㅋㅋㅋㅋㅋ 출력
2. 문자열과의 연산도 가능하다. Java나 C++과는 신기하게 다르다.
animal = "강아지"
name = "연탄이"
age = 4
hobby = "산책"
is_adult = age >= 3
print("우리집 " + animal + "의 이름은 " + name + "예요")
print(name + "는" + str(age)+ "살이며, 산책을 아주 좋아해요.")
print(animal + "는 어른일까요? " + str(is_adult))
3. 세미콜론(;)이 없이 행을 마구 바꾼다.
4. 변수형이 없이 선언하고 초기화한다.
5. boolean형에 age >= 3과 같은 것으로 조건을 제시한다.
6. print내부에서 +연산으로 문장을 이을 때는 str()로 묶어 주어야한다. (문자형으로 변환해야 한다.)7. +연산말고 , 을 사용할 수 있다. 참고로 , 뒤에는 무조건 띄어쓰기가 들어가야 한다.
8. 주석처리를 //가 아니라 #으로 한다. /**/ 대신 ''' '''으로 한다.
print(2**3) # 2^3 = 8
print(5//3) # 몫을 구함. 1
print((3 > 0) and (3 < 5)) # True
print((3 > 0) & (3 < 5)) # True
print((3 > 0) or (3 < 5)) # True
print((3 > 0) | (3 < 5)) # True
print(5 > 4 > 3) # True
print(5 > 4 > 7) # False
9. **을 두개 사용하면 제곱승을 계산할 수 있다. 다른 언어에서 pow(x,y)를 썼는데 굉장히 편리하다..
10. //을 쓰면 몫을 구할 수 있다. //가 주석처리가 아니였던 이유가 바로 이것이다.
11. and, or 연산자는 말 그대로 and 혹은 or을 넣어서 사용할 수 있고, 다른 언어에서 &&, ||로 사용했던 것을 하나로 &, |만 써서 가능하다.
12. 굳이 and, or 없이 연속된 부등호로도 가능하다.
print(abs(-5)) #5
print(pow(4,2)) # 4^2 = 16
print(max(5,12)) # 12
print(min(5, 12)) # 5
print(round(3.14)) # 반올림 3
print(round(4.99)) # 5
from math import *
print(floor(4.99)) # 내림. 4
print(ceil(3.14)) # 올림. 4
print(sqrt(16)) # 제곱근. 4- from math import * : math 라이브러리의 모든 기능을 사용한다.
13. abs는 절대값이고 그 이외에도 여러 math 함수가 있다. 대충은 다 아는 건데 abs, max, min, floor, ceil은 처음본다. sqrt도 매개변수의 개수가 알던 것과 다르다.
from random import *
print(random()) # [0.0 ~ 1.0) 임의의 값 생성
print(random() * 10)
print(int(random()*10)) # [0, 10) 임의의 값 생성
print(randrange(1,46)) # [1, 46) 임의의 값 생성.
print(randint(1,45)) # [1, 45] 임의의 값 생성.
14. random() 함수는 알고 있다. 다만 java에서는 math.random()으로 호출된다.
15. 형변환의 경우 (int)가 아니라 뒤에 변환 시키고 싶은 것에 괄호를 씌워준다. int(random()*10) 이렇게 말이다.
16. randrange()로 정수를 범위에 따라 임의로 생성할 수 있다.
17. randint()로 범위를 [ )가 아닌 [ ]로 할 수 있다.
sentence = '나는 소년입니다'
print(sentence)
sentence2 = "파이썬은 쉬워요"
print(sentence2)
sentence3 = """
나는 소년이고,
파이썬은 쉬워요
"""
print(sentence3)
18. """ """으로 여러 문장을 행바꿈을 하면서 입력할 수도 있다. 또, ' ' 와 " "가 구분이 없다.
jumin = "990120-1234567"
print("성별 : " + jumin[7])
print("연 : " + jumin[0:2]) # 0 ~ 2 직전까지 즉, 0과 1만 [0,1) # 99
print("월 : " + jumin[2:4]) # 01
print("일 : " + jumin[4:6]) # 20
print("생년월일 : " + jumin[:6]) # 처음부터 6 직전까지 #990120
print("뒤 7자리 : " + jumin[7:]) # 8번째부터 끝까지 #1234567
print("뒤 7자리 (뒤에부터) : " + jumin[-7:]) # 맨 뒤에서 7번째 끝까지 #1234567
19. 문자열을 배열처럼 요소로 참조하는 것은 같다. 하지만 :을 이용해 범위를 설정해서 print 해줄 수 있다. 마찬가지로 범위는 [ , )이다. 추가로 처음부터 이거나 끝까지의 범위를 가진 경우 공백으로 남겨 놓을 수 있으며 -7처럼 음의 부호를 붙여서 행하면 뒤에서부터라는 표현을 가지게 된다.
python = "Python is Amazing"
print(python.lower()) # 모두 소문자로 출력
print(python.upper()) # 모두 대문자로 출력
print(python[0].isupper()) # python 문자열의 첫 문자가 대문자인지
print(len(python)) # python의 길이 반환
print(python.replace("Python", "Java")) # 문장에서 Python을 찾아서 Java로 교체
index = python.index("n") # 괄호안의 어느 요소에 있는지 반환
print(index)
index = python.index("n", index + 1) # index + 1의 위치에서부터 n이 나오는 곳을 찾음
print(index)
print(python.find("Java")) # 찾는 것이 없으면 -1 반환
print(python.index("Java")) # 오류가 나면서 여기서 프로그램 종료
print(python.count("n")) # n이 총 몇번 등장하는지 카운트 해줌. 2
20. 위의 코드의 설명을 참고하자. 사실 find를 제외하고는 모드 처음 보는 함수들이다. 하지만 생각보다 직관적이다. find와 index의 차이점을 잘 알아두자.
# print("a"+"b")
# print("a", "b")
# 방법 1
# print("나는 %d살입니다." % 20)
# print("나는 %s을 좋아해요." % "파이썬")
# print("Apple 은 %c로 시작해요." % "A")
# %s만 사용해도 다 가능함.
# print("나는 %s살입니다." % 20)
# print("나는 %s색과 %s색을 좋아해요." % ("파란", "빨간"))
# 방법 2
# print("나는 {}살입니다." .format(20))
# print("나는 {}색과 {}색을 좋아해요." .format("파란", "빨간"))
# print("나는 {0}색과 {1}색을 좋아해요." .format("파란", "빨간")) # format뒤를 각각 0과 1로 봄.
# 그래서 순서를 반대로 {1} {0} 으로 하면 빨간색과 파란색을 좋아해요로 출력.
# 방법 3
# print("나는 {age}살이며, {color}색을 좋아해요." .format(age=20, color="빨간"))
# print("나는 {age}살이며, {color}색을 좋아해요." .format(color="빨간", age=20))
# 방법 4 (v3.6 이상~)
age = 20
color = "빨간"
print(f"나는 {age}살이며, {color}색을 좋아해요.") # f을 입력하고 들어가면 뒤에 중괄호는
# 실제 변수를 사용하여 입력할 수 있다.
21. 방법 1은 printf의 형식과 같다. 방법 2는 .format을 이용해서 넣는 것이다.
22. 방법 3은 마찬가지로 { }와 .format을 이용하는데 안에 변수를 선언하듯이 이용하는 것이다. 이것은 당연히 순서에 구애를 받지 않는다.
23. 방법4는 print괄호 바로 뒤에 f를 붙여서 사용하는 것을 말하는데 이 경우 중괄호 안에 실제 변수를 사용하여 입력할 수 있다.
# \n : 줄바꿈
print("백문이 불여일견 \n백견이 불여일타")
# \" \' : 문장 내에서 따옴표 출력
# 저는 "나도코딩"입니다.
# print("저는 '나도코딩' 입니다.")
# print('저는 "나도코딩"입니다.')
print("저는 \"나도코딩\"입니다.")
print("저는 \'나도코딩\'입니다.")
# \\ : 문장 내에서 \
# print("C:\\Users\\Seo\\Desktop\\PythonWorkspace>")
# \r : 커서를 맨 앞으로 이동
# print("Red Apple\rPine") #pineApple 출력
# \b : 백스페이스 (한 글자 삭제)
# print("Redd\bApple") # RedApple
# \t : 탭
print("Red\tApple")
24. 자바에서 배웠었던 특수문자를 문자열에서 사용하는 방법과 똑같다. 다만 \r, \b의 경우 내가 잊은건지 기능이 없는건지 기억이 나지 않는데 이참에 알아두고 넘어가자. 설명은 주석에 다 되어 있다. \r은 커서를 맨 앞으로 이동하기 때문에 거기서부터 다시 Pine이 입력되는 것이다.
# 리스트 []
# 지하철 칸별로 10명, 20명, 30명
subway1 = 10
subway2 = 20
subway3 = 30
subway = [10, 20, 30]
print(subway) # 10, 20, 30 출력
subway = ["유재석", "조세호", "박명수"]
print(subway)
# 조세호씨가 몇 번째 칸에 타고 있는가?
print(subway.index("조세호"))
# 하하씨가 다음 정류장에서 다음 칸에 탐
subway.append("하하")
print(subway)
# 정형돈씨를 유재석 / 조세호 사이에 태워봄
subway.insert(1, "정형돈")
print(subway)
# 지하철에 있는 사람을 한 명씩 뒤에서 꺼냄
print(subway.pop())
print(subway)
# print(subway.pop())
# print(subway)
# print(subway.pop())
# print(subway)
# 같은 이름의 사람이 몇 명 있는 확인
subway.append("유재석")
print(subway)
print(subway.count("유재석"))
# 정렬도 가능
num_list = [5,2,4,3,1]
num_list.sort()
print(num_list) # 오름차순
# 순서 뒤집기 가능
num_list.reverse()
print(num_list)
# 모두 지우기
num_list.clear()
print(num_list)25. 리스트의 등장. 당연히 내가 알고있는 자료구조에서의 list는 아니다. 자료구조들의... 혼합형태??
26. '.index()'로 어떤 요소에 있는지 찾을 수 있다. '.append()'는 그냥 하나를 뒤에 삽입하는 것이며 그 이외의 insert, pop, sort, reverse, clear와 같은 내가 아는 함수들은 그냥 사용할 수 있다.
27. 파이썬이 아무래도 자료형을 그냥 컴파일러가 자동으로 할당을 해주는 구조인 것 같다. 그러다보니 하나의 리스트에 다양한 자료형을 함께 사용할 수 있다.
28. 기존에 있던 리스트를 확장해서 이어붙일 수 있다. '.extend()'를 이용한다.
cabinet = {3:"유재석", 100 : "김태호"} # key와 value
print(cabinet[3])
print(cabinet[100])
print(cabinet.get(3))
# print(cabinet[5]) # 5라는 키가 없으므로 프로그램 종료.
print(cabinet.get(5)) # 키가 없어도 none출력 후 프로그램 계속 이어 나감.
print(cabinet.get(5, "사용 가능")) # 이렇게 값을 넣어줄 수 있음
print("hi")
# in을 이용해 boolean형 반환
print(3 in cabinet) # True
print(5 in cabinet) # False
cabinet = {"A-3":"유재석", "B-100" : "김태호"}
print(cabinet["A-3"])
print(cabinet["B-100"])
# 새 손님
print(cabinet)
cabinet["A-3"] = "김종국"
cabinet["C-20"] = "조세호"
print(cabinet)
# 간 손님
del cabinet["A-3"]
print(cabinet)
# key들만 출력
print(cabinet.keys())
# value들만 출력
print(cabinet.values())
# key, value 쌍으로 출력
print(cabinet.items())
# 목욕탕 폐점
cabinet.clear()
print(cabinet) # {} 출력
29. 이번에는 map과 굉장히 유사한 '사전'이라는 기능이 나왔다. 똑같이 key - value가 쌍을 이루고 있는데 마찬가지로 딱히 자료형이 정해져있는 것은 아니다. 또, insert와 같이 특별한 메서드를 사용해 넣는 것도 아니고 배열처럼 초기화할 수 있다. clear()은 여전히 사용가능한 메서드이다.
30. 다만 map에서 key에 해당하는 value값을 변경하는 것처럼 [key] = value를 통해 변경 가능하다. 추가적으로 del [key]로 삭제도 가능하다.
31. in을 통해 True, False의 boolean형을 반환할 수 있다.
32. 출력은 앞서 소개했던 [key]를 통해 참조할 수 있으나 '.keys()', 'values()', 'items()'로 각각 키만 값만 둘 모두 쌍으로 출력할 수도 있다.
menu = ("돈까스", "치즈까스")
print(menu[0]) # 돈까스
print(menu[1]) # 치즈까스
# 튜플은 값을 추가하거나 변경 불가능
# name = "김종국"
# age = 20
# hobby = "코딩"
# print(name, age, hobby)
(name, age, hobby) = ("김종국", 20, "코딩")
print(name, age, hobby) # 똑같이 출력
33. 튜플이라는 이름으로 배웠는데 내가 아는 tuple과는 또 다르다. 그냥 파이썬에서는 왠만하면 내가 익힌 언어랑 비슷한 점이 없는 것 같다... 더 편한 것 같긴한데 낯설다. 어쨌든 튜플은 값을 추가하거나 변경이 불가능한 리스트와 같은 것이라고 보면 된다. 여기서 리스트는 당연히 앞서 말했던 파이썬의 리스트이다.
# 집합(set)
# 중복 안됨, 순서 없음
my_set = {1,2,3,3,3}
print(my_set) # {1, 2, 3}
java = {"유재석", "김태호", "양세형"}
python = set(["유재석", "박명수"])
# 교집합 (java 와 python을 모두 할 수 있는 개발자)
print(java & python)
print(java.intersection(python)) # 같은 기능
# 합집합 (java 도 할 수 있거나 python 할 수 있는 개발자)
print(java | python)
print(java.union(python))
# 차집합 (java는 할 수 있는데 python 할 수 없는 개발자)
print(java-python)
print(java.difference(python))
# python 할 줄 아는 사람이 늘어남
python.add("김태호")
print(python)
# java를 까먹었어요
java.remove("김태호")
print(java)
34. set 당연히 내가 알던 것과는 다른데... 중복이 없게 된다는 것은 똑같다! 자동으로 정렬해주는 것은 없다.
35. 교집합, 합집합, 차집합은 참 신기한데 &, |, -기호로 내가 아는 수학식이 구현된다. 혹은 각각의 intersection(), union(), difference()함수로도 가능하긴하다.
36. 리스트, 사전, 튜플, 집합을 구분해보자. 리스트는 = [ ]로 초기화. 사전은 = { }로 초기화인데 key : value로 들어있고, set 은 = ( ), 셋은 사전과 같이 = { }이지만 key : value의 쌍이 아니라 그냥 하나씩 들어있다.
# 자료구조의 변경
# 커피숍
menu = {"커피", "우유", "주스"}
print(menu, type(menu)) # <class 'set'>
menu = list(menu)
print(menu, type(menu)) # <class 'list'>
menu = tuple(menu)
print(menu, type(menu)) # <class 'tuple'>
menu = set(menu)
print(menu, type(menu)) # <class 'set'>
37. 믿을 수 없을만큼 형변환 마냥 자료구조가 변환된다. 너무 쉽게되서 어이가 없다.
weather = input("오늘 날씨는 어때요? ")
if weather == "비" or weather == "눈":
print("우산을 챙기세요")
elif weather == "미세먼지":
print("마스크를 챙기세요")
else:
print("준비물 필요 없어요.")
38. if문도 java와 C++과는 약간 다르다. 괄호가 없다. else if도 elif로 바뀌고 행바꿈이 아닌 :으로 분기를 설정한다. or and를 통해 조건문을 자세하게 설정할 수도 있다.
39. input( )은 문장을 입력받는다.
for waiting_no in [0, 1, 2, 3, 4]:
print("대기번호 : {0}".format(waiting_no))
for waiting_no in range(5): # 0, 1, 2, 3, 4 (순차적인 경우) range(1,6)도 같은 결과가 나옴.
print("대기번호 : {0}".format(waiting_no))
starbucks = ["아이언맨", "토르", "아이엠 그루트"]
for customer in starbucks:
print("{0}, 커피가 준비되었습니다." . format(customer))
40. for문도 많이 다르다. for( )가 아니라 for 변수 in 공간: 으로 반복문을 시행한다.
customer = "토르"
index = 5
while index >= 1:
print("{0}, 커피가 준비되었습니다. {1} 번 남았어요.".format(customer, index))
index -= 1
if index == 0:
print("커피는 폐기처분되었습니다.")41. while문도 많이 다르다. while 조건 : 으로 반복문을 시행한다.
absent = [2, 5] # 결석
no_book = [7] # 책을 깜빡했음
for student in range(1, 11): # 1,2,3,4,5,6,7,8,9,10
if student in absent:
continue
elif student in no_book:
print("오늘 수업 여기까지. {0}는 교무실로 따라와".format(student))
break
print("{0}, 책을 읽어봐".format(student))continue와 break가 쓰이는 것을 보자. 사실 별 다른 차이는 없다.
# # 출석번호가 1,2,3,4, 앞에 100을 붙이기로 함 -> 101, 102, 103, 104.
# student = [1,2,3,4,5]
# print(student)
# student= [i+100 for i in student]
# print(student)
# # 학생 이름을 길이로 변환
# student = ["Iron man", "Thor", "I am groot"]
# student = [len(i) for i in student]
# print(student)
# 학생 이름을 대문자로 변환
student = ["Iron man", "Thor", "I am groot"]
student = [i.upper() for i in student]
print(student)42. 한 줄 for문이 사용되는 모습이다. 참 신기하다 이게 너무 편리해보이긴하는데 C++, java랑 너무 다르니까 오히려 햇갈린다..
def open_account():
print("새로운 계좌가 생성되었습니다.")
open_account()
def deposit(balance, money):
print("입금이 완료되었습니다. 잔액은 {0} 원입니다.".format(balance+money))
return balance+money
balance = 0
balance = deposit(balance, 1000)
print(balance)
def withdraw(balance, money):
if balance >= money:
print("출금이 완료되었습니다. 잔액은 {0}원입니다.".format(balance-money))
return balance-money
else:
print("출금이 완료되지 않았습니다. 잔액은 {0}원입니다.".format(balance))
return balance
def withdraw_night(balance, money):
commission = 100
return commission, balance - money - commission # 튜플형식으로 여러 개의 값을 반환.
balance = 0 # 잔액
balance = deposit(balance, 1000)
balance = withdraw(balance, 2000)
commission, balance = withdraw_night(balance, 500)
print("수수료 {0}원이며, 잔액은 {1}원입니다.".format(commission, balance))43. 함수는 똑같다! 다만, 중괄호 대신에 :가 사용되고 함수의 선언부에서 def 함수이름으로 선언하는게 다르다. 또한 return 값으로 ,를 통해 여러개를 동시에 반환하는 것도 가능하다.
# def profile(name, age, main_lang): # \사용으로 줄바꿈 가능.
# print("이름 : {0}\t나이: {1}\t주 사용 언어 {2}"\
# .format(name,age,main_lang))
# profile("유재석", 20, "파이썬")
# profile("김태호", 25, "자바")
# 같은 학교 같은 학년 같은 반 같은 수업 -> 기본값 사용
def profile(name, age = 17, main_lang="파이썬"):
print("이름 : {0}\t나이: {1}\t주 사용 언어 {2}"\
.format(name,age,main_lang))
profile("유재석")
profile("김태호")
def profile(name, age, main_lang): # \사용으로 줄바꿈 가능.
print(name, age, main_lang)
profile(name="유재석", main_lang="파이썬", age=20)
profile(main_lang="자바", age=25, name="김태호")44. 다행히 기본값을 설정하는 방법은 다른 언어에서 사용하는 것과 똑같다.
45. \을 이용해 줄 바꾸는 것은 알아두자.
46. 함수를 호출할 때 키워드(매개변수)에 값을 할당해서 호출하는 경우 순서가 달라고 제대로 호출되는 것을 확인할 수 있다.
# def profile(name, age, lang1, lang2, lang3, lang4, lang5):
# print("이름 : {0}\t나이 : {1}\t".format(name,age), end=" ") # end = " "를 사용하여 줄바꿈없이 이어서 출력
# print(lang1, lang2, lang3, lang4, lang5)
def profile(name, age, *language):
print("이름 : {0}\t나이 : {1}\t".format(name,age), end=" ") # end = " "를 사용하여 줄바꿈없이 이어서 출력
for lang in language:
print(lang, end=" ")
print()
profile("유재석", 20, "python", "Java", "C", "C++", "C#", "JavaScript")
profile("김태호", 25, "Kotlin", "Swift")47. 가변인자 함수 매개변수 타입 안에 *와 함께 들어가 있는 구문이다. C++이랑 Java에는 없고 이렇게 변수 이름앞에 *처리해줌으로써 인자를 개수 관계없이 마음껏 끌어다 써도 상관없다. 다만 끌어다 쓰는 과정에서 for문 통한 루프문을 돌아서 사용해야 한다.
gun = 10
def checkPoint(soldiers):
global gun # 전역 공간에 있는 gun 사용
gun = gun - soldiers
print("[함수 내] 남은 총 : {0}".format(gun))
print("전체 총 : {0}".format(gun))
checkPoint(2)
print("남은 총 : {0}".format(gun))48. 변수가 지역변수인지 전역 변수인지에 대한 개념은 똑같다. 다만 전역 변수를 global 변수이름으로 선언할 수 있다는 것을 알아두자.
print("Python", "Java", sep= ",", end = "?") # end : 문장의 끝부분을 ?로해줘라
print("무엇이 더 재밌을까요?")
import sys
print("Python", "Java", file = sys.stdout) # 표준 출력
print("Python", "Java", file = sys.stderr) # 표준 에러
scores = {"수학":0, "영어":50, "코딩":100}
for subject, score in scores.items():
# print(subject, score)
print(subject.ljust(8), str(score).rjust(4), sep = ":")
# 왼쪽으로 정렬을 하는데 8칸을 확보하고 정렬, score는 오른쪽으로 정렬 4칸 확보
# 은행 대기순번표
# 001, 002, 003, ...
for num in range(1,21):
print("대기번호 : "+ str(num).zfill(3)) #3칸에 값이 없는 곳은 0으로 채우기
answer = input("아무 값이나 입력하세요 : ")
print("입력하신 값은 " + answer + "입니다.") # input은 항상 string으로 처리된다.49. print문장에서 , 는 자연스럽게 띄어쓰기를 해주었다. 이때 sep = 으로 그 값을 변경하면 띄어쓰기 자리에 다른게 쓰이게 되는 것이다. 예시에서는 ","를 할당했으니 Python , Java가 출력된다. end의 경우에는 default값이 행바꿈인데 문장의 끝부분을 지칭한다. 여기서는 ?로했으니 Python , Java?무엇이 더 재밌을까요? <- 이런식으로 행바꿈없이 문장이 붙어서 출력된다.
50. sys.stdout은 표준 출력, sys.stderr은 표준 에러에 대한 출력이다. 이 부분은 일단 그런게 있다고 알아두자.
51. ljust( ), rjust( )는 각각 몇 칸을 확보하고 어느 방향으로 정렬하는지에 대한 것이다.
52. zfill( )의 경우 칸을 확보하고 값이 없는 나머지 자리를 모두 0으로 채운다.
53. input으로 입력받은 유저의 input값은 그 타입이 항상 string으로 처리된다.
# 빈 자리는 빈공간으로 두고, 오른쪽 정렬을 하되, 총 10자리 공간을 확보
print("{0: >10}".format(500)) # 500을 제외하고 빈공간(총 10칸)
# 양수일 땐 +로 표시, 음수일 땐 -로 표시
print("{0: >+10}".format(500))
print("{0: >+10}".format(-500))
# 왼쪽 정렬하고, 빈칸으로 _로 채움
print("{0:_<+10}".format(500))
# 3자리마다 콤마를 찍어주기
print("{0:,}".format(10000000000000))
# 3자리마다 콤마를 찍어주기, +- 부호도 붙이기
print("{0:+,}".format(10000000000000))
print("{0:+,}".format(-10000000000000))
# 3자리 마다 콤마를 찍어주기, 부호도 붙이고, 자릿수 확보하기
# 돈이 많으면 행복하니까 빈 자리는 ^로 채워주기
print("{0:^<+30,}".format(10000000000))
# 소수점 출력
print("{0:f}".format(5/3))
# 소수점 특정 자리수까지만 표시 (소수점 셋째 자리에서 반올림)
print("{0:.2f}".format(5/3))54. 예시를 보고 확인하는것이 좀 더 쉬울 것이다. 기본적인 포맷은 {0:(채워주고싶은것) ?? (부호)(공간확보)} 이렇게 보면된다. 그 이외에 다른점도 많아서 한번 살펴보길 바란다.
score_file = open("score.txt", "w", encoding = "utf8") #utf8은 한글을 위해서
print("수학 : 0", file=score_file)
print("영어 : 50", file=score_file)
score_file.close() # score.txt라는 파일이 생기고 print부분에 내용이 담김
score_file = open("score.txt", "a", encoding = "utf8") # a는 덮어쓰기
score_file.write("과학 : 80")
score_file.write("\n코딩 : 100")
score_file.close()
score_file = open("score.txt", "r", encoding="utf8")
print(score_file.read()) # file 출력
score_file.close()
score_file = open("score.txt", "r", encoding="utf8")
print(score_file.readline()) # 한 줄 읽고, 커서 다음 줄로 이동 (gdb n??)
print(score_file.readline())
print(score_file.readline())
print(score_file.readline())
score_file.close()
score_file = open("score.txt", "r", encoding="utf8")
while True:
line = score_file.readline()
if not line:
break
print(line, end="") #별도의 줄바꿈없이 출력
score_file.close() # 파일이 총 몇줄일지 모를 때 이런식으로 출력
score_file = open("score.txt", "r", encoding="utf8")
lines = score_file.readlines() # 파일의 모든 문장을 list 형태로 저장
for line in lines:
print(line, end="")
score_file.close()55. 이번엔 리눅스랑 비슷한 기능이 등장했다. 참고로 "score.txt"는 파일이름인데 파일이 없다면 새로 생성해준다. 예시를 읽어보면 어떤 흐름인지 알 것이다.
import pickle
profile_file = open("profile.pickle", "wb")
profile = {"이름":"박명수", "나이":30, "취미":["축구", "골프", "코딩"]}
print(profile)
pickle.dump(profile, profile_file) # profile에 있는 정보를 file에 저장
profile_file.close() #profile.picle이라는 파일 생김.
# 파일에 있는 내용을 load를 통해서 불러와서 변수에 저장하고 계속 쓸 수 있게 해줌.
profile_file = open("profile.pickle", "rb")
profile = pickle.load(profile_file) # file에 있는 정보를 profile에 불러오기
print(profile)
profile_file.close()56. pickle이라는 개념이다. 어렵게 생각하지말고 예시처럼 정의해서 pickle를 저장하는데 이를 load 메서드로 불러와 변수에 저장하고 계속 쓸 수 있는 편리한 기능이다.
import pickle
with open("profile.pickle", "rb") as profile_file: # file을 열어서 profile_file에 저장
print(pickle.load(profile_file)) # load를 통해서 불러와서 출력
with open("study.txt", "w", encoding="utf8") as study_file:
study_file.write("파이썬을 열심히 공부하고 있어요")
with open("study.txt", "r", encoding="utf8") as study_file:
print(study_file.read())57. pickle의 확장인데 with을 통해서 위에 56번에서 썻던 문장들을 조금 더 쉽게 간략하게 처리할 수 있는 것이다. 일일히 file을 close해줄 필요도 없고 할당에 대한 문장도 딱히 없기 때문에 with을 통해서 사용하는 것이 편하다.
class Unit:
def __init__(self, name, hp, damage): # __init__ 은 파이썬의 생성자!
self.name = name
self.hp = hp
self.damage = damage
print("{0} 유닛이 생성되었습니다.".format(self.name))
print("체력 {0}, 공격력 {1}\n".format(self.hp, self.damage))
# marine1 = Unit("마린", 40, 5)
# marine2 = Unit("마린", 40, 5)
# tank = Unit("탱크", 150, 35)
# 레이스 : 공중 유닛, 비행기. 클로킹(상대방에게 안보임)
wraith1 = Unit("레이스", 80, 5)
print("유닛 이름 : {0}, 공격력 : {1}".format(wraith1.name, wraith1.damage)) # 멤버 변수 외부에서 씀.
# 마인드 컨트롤 : 상대방 유닛을 내 것으로 만드는 것 (빼앗음)
wraith2 = Unit("빼앗은 레이스", 80, 5)
wraith2.clocking = True # 클로킹에대한 변수는 없는데 외부에서 추가로 파이썬은 추가로 할당 가능함
#다만 레이스1에서는 없기때문에 wraith1.clocking은 사용불가능하다.
if wraith2.clocking == True:
print("{0}는 현재 클로킹 상태입니다.".format(wraith2.name))58. 사실 파이썬에는 클래스가 없는 줄 알았다. 왜냐하면 객체지향 프로그래밍이 아니니까..?? 근데 있다 기능도 똑같다. 설계도로서 인스턴스를 찍어내는 역할을 한다. 다만 한가지 파이썬은 멤머 변수를 외부에서 추가로 할당이 가능하다!! 다만 그 객체(인스턴스)에 한에서만 가능하다. 지금 에시를 보면 레이스2에는 클로킹 멤버변수를 새로 할당해서 사용할 수 있는데 그대로 레이스1에다가 클로킹 변수를 사용하려고하면 에러가 뜬다.
59. self를 보자. class의 메소드에서는 반드시 self를 앞에 붙여준다. (self, name, hp, damage)
60. __init__은 파이썬의 생성자이다.
class Unit:
def __init__(self, name, hp, damage): # __init__ 은 파이썬의 생성자!
self.name = name
self.hp = hp
self.damage = damage
print("{0} 유닛이 생성되었습니다.".format(self.name))
print("체력 {0}, 공격력 {1}\n".format(self.hp, self.damage))
class AttackUnit:
def __init__(self, name, hp, damage): # __init__ 은 파이썬의 생성자!
self.name = name
self.hp = hp
self.damage = damage
print("{0} 유닛이 생성되었습니다.".format(self.name))
print("체력 {0}, 공격력 {1}\n".format(self.hp, self.damage))
def attack(self, location):
print("{0} : {1} 방향으로 적군을 공격 합니다. [공격력 {2}]"\
.format(self.name, location, self.damage))
def damaged(self, damage):
print("{0} : {1} 데미지를 입었습니다.".format(self.name, damage))
self.hp -= damage
print("{0} : 현재 체력은 {1} 입니다.".format(self.name, self.hp))
if self.hp <= 0:
print("{0} : 파괴되었습니다.".format(self.name))
firebat1 = AttackUnit("파이어뱃", 50, 16)
firebat1.attack("5시")
firebat1.damaged(25)
firebat1.damaged(25)61. 클래스 메소드를 좀 더 잘 보여준다.
# 일반 유닛
class Unit:
def __init__(self, name, hp):
self.name = name
self.hp = hp
# 공격 유닛
class AttackUnit(Unit):
def __init__(self, name, hp, damage):
Unit.__init__(self, name, hp) # damage를 제외한 나머지는 상속.
self.damage = damage
def attack(self, location):
print("{0} : {1} 방향으로 적군을 공격 합니다. [공격력 {2}]"\
.format(self.name, location, self.damage))
def damaged(self, damage):
print("{0} : {1} 데미지를 입었습니다.".format(self.name, damage))
self.hp -= damage
print("{0} : 현재 체력은 {1} 입니다.".format(self.name, self.hp))
if self.hp <= 0:
print("{0} : 파괴되었습니다.".format(self.name))
firebat1 = AttackUnit("파이어뱃", 50, 16)
firebat1.attack("5시")
firebat1.damaged(25)
firebat1.damaged(25)62. 이전과 같은 예시처럼 보이지만 AttackUnit을 보면 Unit 클래스를 '상속'하고 있다. 이 상속하는 법에 대해서 잘 확인하자. 또, __init__의 생성자 안도 잘 확인하자.
# 일반 유닛
class Unit:
def __init__(self, name, hp):
self.name = name
self.hp = hp
# 공격 유닛
class AttackUnit(Unit):
def __init__(self, name, hp, damage):
Unit.__init__(self, name, hp) # damage를 제외한 나머지는 상속.
self.damage = damage
def attack(self, location):
print("{0} : {1} 방향으로 적군을 공격 합니다. [공격력 {2}]"\
.format(self.name, location, self.damage))
def damaged(self, damage):
print("{0} : {1} 데미지를 입었습니다.".format(self.name, damage))
self.hp -= damage
print("{0} : 현재 체력은 {1} 입니다.".format(self.name, self.hp))
if self.hp <= 0:
print("{0} : 파괴되었습니다.".format(self.name))
# 드랍쉽 : 공중 유닛, 수송기. 마린 / 파이어뱃 / 탱크 등을 수송. 공격 불가.
# 날 수 있는 기능을 가진 클래스
class Flyable:
def __init__(self, flying_speed):
self.flying_speed = flying_speed
def fly(self, name, location):
print("{0} : {1} 방향으로 날아갑니다. [속도 {2}]"\
.format(name, location, self.flying_speed))
# 공중 공격 유닛 클래스
class FlyableAttackUnit(AttackUnit, Flyable):
def __init__(self, name, hp, damage, flying_speed):
AttackUnit.__init__(self, name, hp, damage)
Flyable.__init__(self, flying_speed)
valkyrie = FlyableAttackUnit("발키리", 200, 6, 5)
valkyrie.fly(valkyrie.name, "3시")63. 다른 부분은 같으니까 밑에 추가된 Flyable, FlyableAttackUnit을 보자. FlyableAttackUnit은 다중상속을 받고 있다. 사실 상속에 대한 개념은 지금 Java랑 똑같기 때문에 상속하는 방법에 대해서만 잘 알아두자. 참고로 Java는 단일상속을 원칙으로 하고 있다.
# 일반 유닛
class Unit:
def __init__(self, name, hp, speed):
self.name = name
self.hp = hp
self.speed = speed
def move(self, location):
print("[지상 유닛 이동]")
print("{0} : {1} 방향으로 이동합니다. [속도 {2}]"\
.format(self.name, location, self.speed))
# 공격 유닛
class AttackUnit(Unit):
def __init__(self, name, hp, speed, damage):
Unit.__init__(self, name, hp, speed) # damage를 제외한 나머지는 상속.
self.damage = damage
def attack(self, location):
print("{0} : {1} 방향으로 적군을 공격 합니다. [공격력 {2}]"\
.format(self.name, location, self.damage))
def damaged(self, damage):
print("{0} : {1} 데미지를 입었습니다.".format(self.name, damage))
self.hp -= damage
print("{0} : 현재 체력은 {1} 입니다.".format(self.name, self.hp))
if self.hp <= 0:
print("{0} : 파괴되었습니다.".format(self.name))
# 드랍쉽 : 공중 유닛, 수송기. 마린 / 파이어뱃 / 탱크 등을 수송. 공격 불가.
# 날 수 있는 기능을 가진 클래스
class Flyable:
def __init__(self, flying_speed):
self.flying_speed = flying_speed
def fly(self, name, location):
print("{0} : {1} 방향으로 날아갑니다. [속도 {2}]"\
.format(name, location, self.flying_speed))
# 공중 공격 유닛 클래스
class FlyableAttackUnit(AttackUnit, Flyable):
def __init__(self, name, hp, damage, flying_speed):
AttackUnit.__init__(self, name, hp, 0, damage) # 지상 speed 0
Flyable.__init__(self, flying_speed)
def move(self, location):
print("[공중 유닛 이동]")
self.fly(self.name, location)
# 벌쳐 : 지상 유닛, 기동성 좋음
vulture = AttackUnit("벌쳐", 80, 10, 20)
# 배틀크루저 : 공중 유닛, 체력도 좋음, 공격력도 좋음
battlecruiser = FlyableAttackUnit("배틀크루저", 500, 25, 3)
vulture.move("11시")
# battlecruiser.fly(battlecruiser.name, "9시") # move와 fly를 통일해보자 -> 메소드 오버라이딩
battlecruiser.move("9시")64. move를 메서드 오버라이딩을 통해서 공중유닛 지상유닛 이동을 구분지었다. 다른 언어에서의 오버라이딩과 마찬가지로 선언부는 완전히 동일하며 그 내용만 다른 것을 확인할 수 있다.
# 건물
class BuildingUnit(Unit):
def __init__(self, name, hp, location):
pass # 아무것도 안하고 일단 넘어간다. (완성된 것처럼 그냥 작동한다)
# 서플라이 디폿 : 건물, 1개 건물 = 8 유닛.
supply_depot = BuildingUnit("서플라이 디폿", 500, "7시")
def game_start():
print("[알림] 새로운 게임을 시작합니다.")
def game_over():
pass
game_start()
game_over()65. 완전 새로운 기능인 pass 한마디로 pass의 기능을 가진다. 이 부분이 완성되었다고 생각하고 넘어가자는 것이다. 그래서 실행시 어떤 오류도 발생하지 않는다. 미구현 부분에 대해서 pass로 두고 나중에 구현하는 면에서 유용하다.
class Unit:
def __init__(self):
print("Unit 생성자")
class Flyable:
def __init__(self):
print("Flyable 생성자")
class FlyableUnit(Unit, Flyable):
def __init__(self):
super().__init__()
dropship = FlyableUnit() # Unit 생성자만 호출됨. super()를 사용하면66. super()도 내가 아는 그 기능이 맞다. 다만, 다중 상속의 경우 먼저 상속받은 것을 super()가 지칭하기 때문에 다중상속의 경우에는 super를 쓰지않고 Unit.__init__(self)로 수행한다.
*강의 내용에 스타크래프트 전반전과 후반전은 스킵한다. 지금은 인공지능 응용에 사용하기 위해 기본문법 공부를 하기 때문
try:
print("나누기 전용 계산기입니다.")
nums = []
nums.append(int(input("첫 번째 숫자를 입력하세요 : ")))
nums.append(int(input("두 번째 숫자를 입력하세요 : ")))
# nums.append(int(nums[0] / nums[1])) 만약 이걸 안넣어서 nums[2]가 없다면
print("{0} / {1} = {2}".format(nums[0], nums[1], nums[2]))
except ValueError:
print("에러! 잘못된 값을 입력하였습니다.")
except ZeroDivisionError as err: # err은 어떤 err인지 확인할 수 있다.
print(err) # division by zero
except Exception as err: # 위의 두 종류의 에러를 제외한 모든 종류의 에러
print("알 수 없는 에러가 발생하였습니다.")
print(err)66. 설마하니 예외처리에 관한 부분을... java나 c++이 아닌 python에서 먼저 배우게 될 줄은 몰랐다. 물론 try catch에 대한 어법은 어느정도 알고있긴 하지만 어쨌든. try는 수행하다가 무언가 문제가 생기면 아래에 except를 찾으며 어떤 문제에 해당하는지 확인 후 그에 따른 { }를 실행하면 된다. value error인지 zerodivisionerror인지 혹은 그 밖에 알 수 없는 에러인지 확인할 수 있고 err를 사용하면 어떤 error인지 print( )와 함께 사용하여 에러 문장을 출력할 수 있다.
try:
print("한 자리 숫자 나누기 전용 계산기입니다.")
num1 = int(input("첫 번째 숫자를 입력하세요 : "))
num2 = int(input("두 번째 숫자를 입력하세요 : "))
if num1 >= 10 or num2 >= 10:
raise ValueError
print("{0} / {1} = {2}".format(num1, num2, int(num1/ num2)))
except ValueError:
print("잘못된 값을 입력하였습니다. 한 자리 숫자만 입력하세요.")67. 사실 어느정도 우리가 예외를 처리하면서 코드를 짜긴한다. 이 경우 if문의 조건식이 예외의 경우인데 이때 raise를 사용하여 Error 변수(???) ValueError로 이동하게 되고 이때가 except ValueError로 이동하여 print문장을 출력하게 되는 것이다.
class BigNumberError(Exception):
def __init__(self, msg):
self.msg = msg
def __str__(self):
return self.msg
try:
print("한 자리 숫자 나누기 전용 계산기입니다.")
num1 = int(input("첫 번째 숫자를 입력하세요 : "))
num2 = int(input("두 번째 숫자를 입력하세요 : "))
if num1 >= 10 or num2 >= 10:
raise BigNumberError("입력값 : {0}, {1}".format(num1, num2))
print("{0} / {1} = {2}".format(num1, num2, int(num1/ num2)))
except ValueError:
print("잘못된 값을 입력하였습니다. 한 자리 숫자만 입력하세요.")
except BigNumberError as err:
print("에러가 발생하였습니다. 한 자리 숫자만 입력하세요.")
print(err)68. class로 내가 직접 예외를 설정해줄 수도 있다. 이때 message를 받고 싶은 형태가 있다면 class 내부 메서드로 설정해주면 되고 except BinNumberError as err를 통해서 raise로 넘겨받은 err을 직접 출력할 수 있다.
class BigNumberError(Exception):
def __init__(self, msg):
self.msg = msg
def __str__(self):
return self.msg
try:
print("한 자리 숫자 나누기 전용 계산기입니다.")
num1 = int(input("첫 번째 숫자를 입력하세요 : "))
num2 = int(input("두 번째 숫자를 입력하세요 : "))
if num1 >= 10 or num2 >= 10:
raise BigNumberError("입력값 : {0}, {1}".format(num1, num2))
print("{0} / {1} = {2}".format(num1, num2, int(num1/ num2)))
except ValueError:
print("잘못된 값을 입력하였습니다. 한 자리 숫자만 입력하세요.")
except BigNumberError as err:
print("에러가 발생하였습니다. 한 자리 숫자만 입력하세요.")
print(err)
finally:
print("계산기를 이용해 주셔서 감사합니다.")69. 똑같은 예시다. 마지막의 finally부분만 보자. finally처리를 하면 try구문이 정상 작동을 하든 에러가 발생하든 어떤 상황에서도 finally 구문은 수행된다.
# theater_module.py에 구현
# 일반 가격
def price(people):
print("{0}명 가격은 {1}원 입니다.".format(people, people * 10000))
# 조조할인 가격
def price_morning(people):
print("{0}명 조조 할인 가격은 {1}원 입니다.".format(people, people*6000))
def price_soldier(people):
print("{0}명 군인 할인 가격은 {1}원 입니다.".format(people, people*4000))
# practice.py
# 1
import theater_module
theater_module.price(3) # 3명이서 영화 보러 갔을 때 가격
theater_module.price_morning(4) # 4명이서 조조 할인 영화 보러 갔을 때
theater_module.price_soldier(5) # 5명의 군인이 영화 보러 갔을 때
# 2
import theater_module as mv # 별명
mv.price(3)
mv.price_morning(4)
mv.price_soldier(5)
# 3
from theater_module import *
# from random import *
price(3)
price_morning(4)
price_soldier(5)
# 4
from theater_module import price, price_morning # 특정 함수만 뽑아오기
price(5)
price_morning(6)
price_soldier(7) # error
# 5
from theater_module import price_soldier as price # 메서드의 별명
price(5) # 실제로는 price_soldier함수 내용 출력70. module로 따로 py 파일을 만들어 메서드들을 정의한다음에 import로 본 코드에서 불러올 수 있다. 예시는 4가지의 방법을 모두 보이고 있는데 전체를 뽑아와서 별명을 설정해서 간편하게 사용하거나 from ~ import를 이용해서 특정 함수만 뽑아 별명을 붙이는 것도 가능하다. 주의깊게 봐야할 것은 #5인데 만약 price로 기존 메서드와 같은 별명을 사용하더라도 딱히 문제없이 별명대로 메서드가 실행된다.
# travel 폴더 안
# __init__.py : 비어있음
# thailand.py
class ThailandPackage:
def detail(self):
print("[태국 패키지 3박 5일] 방콕, 파타야 여행 (야시장 투어) 50만원")
# vietnam
class VientnamPackage:
def detail(self):
print("[베트남 패키지 3박 5일] 다낭 효도 여행 60만원")
# practice.py
# 1
import travel.thailand
trip_to = travel.thailand.ThailandPackage()
trip_to.detail()
# 2
from travel.thailand import ThailandPackage # from ~ import에서는 모듈이나 패키지 모두 가능
trip_to = ThailandPackage()
trip_to.detail()
# 3
from travel import vietnam
trip_to = vietnam.VientnamPackage()
trip_to.detail()71. 패키지를 import로 참고하는 모습이다. 다만 주의해야할 점이 # 1에서 import travel.thailand.ThailandPackage()는 안된다는 것이다. 하지만 # 2에서 from ~ import 구문으로 가능하다.
# __init__.py
__all__ = ["vietnam", "thailand"]
# pratice.py
# from random import *
from travel import * # 이걸로 모두 참고가 안된다. 범위를 설정해야함 -> __init__ -> all 설정
trip_to = vietnam.VientnamPackage()
trip_to.detail()
# thailand 추가
trip_to = thailand.ThailandPackage()
trip_to.detail()72. 우리가 random import *로 random을 모두 사용했었던 것을 위쪽에서 했었다. 그러면 같은 논리로 from travel import *는 travel에 있는 모든 것을 사용할 수 있어야하는데 그렇지 못한다. 이것은 __init__에서 범위를 설정해주어야 하기 때문이다. __all__을 이용해서 범위를 설정하고 ["vietnam", "thailand"]로 추가하여 둘의 패키지를 참조할 수 있게 된다.
# thailand.py을 수정한다.
class ThailandPackage:
def detail(self):
print("[태국 패키지 3박 5일] 방콕, 파타야 여행 (야시장 투어) 50만원")
if __name__ == "__main__":
print("Thailand 모듈을 직접 실행")
print("이 문장은 모듈을 직접 실행할 때만 실행돼요")
trip_to = ThailandPackage()
trip_to.detail()
else:
print("Thailand 외부에서 모듈 호출")
# 실행시 모듈을 직접실행 구문 출력
# practice.py
from travel import *
trip_to = thailand.ThailandPackage()
trip_to.detail()
# 실행시 모듈 외부에서 호출 구문 출력73. 이와 같이 모듈을 수정해서 모듈을 직접 실행하는지 외부에서 호출에서 실행하는지 확인할 수 있다. 구분해서 필요한 코드를 작성할 수 있게 된다.
# from random import *
from travel import *
trip_to = thailand.ThailandPackage()
trip_to.detail()
import inspect
import random
print(inspect.getfile(random)) # random이 어디에 있는지 경로 알려줌.
print(inspect.getfile(thailand))74. 아래 문단을 통해 경로의 위치를 알려줄 수 있다. 이때 원래 C 드라이브에 만들었던 폴더 travel을 random이 존재하는 D드라이브의 경로로 옮기면 위쪽 문단에서 from random import *로 random을 사용했던 것처럼 from travel import*로 travel또한 사용할 수 있게된다. 추후 코드를 짜게되면 여기다가 넣어서 이렇게 자유롭게 사용할 수 있게 되는 것이다.
75. 획기적인 PyPI
PyPI · The Python Package Index
The Python Package Index (PyPI) is a repository of software for the Python programming language.
pypi.org
엄청나게 많은 패키지를 그냥 다운 받을 수 있다. 찾는 것이 있다면 들어가서 복사한 다음 vscode의 터미널에 붙여넣기 하면 다운이 완료되고 이를 그대로 사용할 수 있다.
- pip list : 설치된 pip 리스트 볼 수 있음
- pip show 이름 : 구체적인 정보 표시
- pip install --upgrade 이름 : 최신버전으로 업그레이드 해줌
- pip uninstall 이름 : 삭제해줌
# input : 사용자 입력을 받는 함수
language = input("무슨 언어를 좋아하세요?")
print("{0}은 아주 좋은 언어입니다!".fromat(language))
# dir : 어떤 객체를 넘겨줬을 때 그 객체가 어떤 변수와 함수를 가지고 있는지 표시
print(dir())
import random # 외장 함수
print(dir())
import pickle
print(dir())
print(dir(random)) # random에서 사용할 수 있는 것 표시
lst = [1,2,3]
print(dir(lst)) # list에서 사용할 수 있는거 표시
name = "Jim"
print(dir(name)) # string에서 사용할 수 있는 모든 것 표시76. 내장함수는 별다른 것없이 바로 사용할 수 있는 함수를 말한다. input이 그 예이고 dir을 이용해서 사용할 수 있는 변수와 함수를 확인할 수 있다. 예를들어 dir(list)라면 sort 등의 함수가 나오는 것이다.
https://docs.python.org/ko/3/library/functions.html
Built-in Functions
The Python interpreter has a number of functions and types built into it that are always available. They are listed here in alphabetical order.,,,, Built-in Functions,,, A, abs(), aiter(), all(), a...
docs.python.org
여러가지 파이썬의 내장함수를 살펴볼 수 있는 사이트이다.
77. https://docs.python.org/ko/3/py-modindex.html
Python 모듈 목록 — Python 3.11.2 문서
numbers Numeric abstract base classes (Complex, Real, Integral, etc.).
docs.python.org
마찬가지로 외장함수를 볼 수 있는 사이트이다. 적절히 가져와서 사용하면 된다!
# glob : 경로 내의 폴더 / 파일 목록 조회
import glob
print(glob.glob("*.py")) # 확장자가 py인 모든 파일
# # os : 운영체제에서 제공하는 기본 기능
import os
print(os.getcwd()) # 현재 directory 출력
folder = "sample_dir"
if os.path.exists(folder):
print("이미 존재하는 폴더입니다.")
os.rmdir(folder)
print(folder, "폴더를 삭제하였습니다.")
else:
os.makedirs(folder) # 폴더 생성
print(folder, "폴더를 생성하였습니다.")
print(os.listdir())
# time : 시간 관련 함수
import time
print(time.localtime())
print(time.strftime("%Y-%m-%d %H:%H:%S")) # 2023-04-06 22:22:07
import datetime
print("오늘 날짜는 ", datetime.date.today())
# timedelta : 두 날짜 사이의 간격
today = datetime.date.today() # 오늘 날짜 저장
td = datetime.timedelta(days = 100) # 100일 저장
print("우리가 만난지 100일은", today + td) # 오늘부터 100일 후몇가지 외장함수의 예시이다. 한번 예시를 쭉 살펴보자. 신기한건 cmd 명령어(리눅스명령어)와 비슷한 부분이 꽤나 있다.
완강!! 다음은 활용편7의 머신러닝 시스템을 먼저 공부해보겠다! 이것도 6시간짜리다... 아 그 전에 먼저 지금까지 파이썬을 몰라서 이해를 못했던 학부 내용부터 업로드가 이루어질 수 있다.