📌객체지향(OOP)
✔️ 파이썬은 모든 것이 객체이다.
행동 및 기능을 미리 정의해두고 필요할 때마다 쓰는
클래스로 인하여 생성되는 것들을 객체라고 할 수 있다.
변수(속성) + 함수(행동)
class Person:
def __init__(self, name, gender):
self.name = name
self.gender = gender
def greeting(self):
print(f'안녕하세요 {self.name}입니다.')
jin = Person('진', '남')
iu = Person('아이유', '여')
jin.greeting() '안녕하세요 진입니다.'
iu.greeting() '안녕하세요 아이유입니다.'✏️함수정의(def)
import math
def get_area(radius):
"""반지름을 입력 받아서 원의 넓이를 반환하는 get_area() 함수"""
area = math.pi * math.pow(radius, 2)
return area
radius = 1.5
print(radius)✔️get_area() 함수 호출 결과를 area 변수에 저장
area = get_area(radius)
print(area)
print(get_area.__doc__) # Docstring 확인✏️변수(variable)
어떤 데이터를 저장하고자 할때 사용하는 메모리 저장소.
변수명 규칙
- 영문,한글,숫자,밑줄_로 구성된다.
- 특수문자!@$%&*()-+ 사용할 수 없다.
- 대문자와 소문자를 구분한다.
- 변수명의 첫 글자를 숫자로 사용할 수 없다.
- 키워드(list,dict,if,for,and 등)는 사용할 수 없다.
2mybar = 'Python1'
my-bar = 'Python2'
my bar = 'Python3'
multi-line string
name = 'Alice'
print(name)
age = 25
print(age)
address = '''우편번호 12345
서울시 영등포구 여의도동 1234-5'''
print(address)변수당 하나씩
x = "피카츄"
y = "라이츄"
z = "파이리"여러변수에 동일한 값 할당
x = y = z = '꼬부기'✏️자료형(type)
Python 변수는 다른 유형의 데이터를 저장할 수 있으며 다른 유형은 다른 작업을 수행할 수 있다.
내장 데이터 유형 🔻
텍스트 유형 str
숫자 유형 int, float, complex
시퀀스 유형 list, tuple, rage
매핑 유형 dict
세트 유형 set
논리 유형 bool
바이너리 유형 bytes, bytearray
없음 유형 NoneType
✔️str
x = "Hello World"
a = "안녕 세상아!"
print(type(x+a))
✔️int
x = 20
print(type(x))
✔️float
x = 20.5
print(type(x))
✔️complex
x = 1j
print(type(x))
✔️list
x = ["피카츄", "라이츄", "파이리"]
print(type(x))
✔️tuple
x = ("피카츄", "라이츄", "파이리")
print(type(x))
✔️range
x = range(6)
print(type(x))
✔️dict
x = {"name": "피카츄", "기술": "백만볼트!"}
print(type(x))
✔️set
x = {"피카츄", "라이츄", "파이리"}
print(type(x))
✔️bool
x = True
print(type(x))
✔️None
d = None
print(type(d))🗝 문자열(String)
하나이상 연속된 문자(character)들의 나열.
파이썬에서 문자열 자료형은 큰 따옴표(" ")
또는 작은 따옴표(' ')사이에 위치.
# 'Hello' 와 "Hello" 동일`
print('Hello' == "Hello")
# 변수에 문자열 할당
a = "Hello"
print(a)
# 여러줄 문자열 할당
a = """피카츄, 라이츄, 파이리, 꼬부기,
버터플, 야도란, 피존투, 또가스
"""
print(a)✔️문자열 배열
문자열 인덱싱(indexing)
H e l l o <== 문자열
0 1 2 3 4 <== 인덱스
-5 -4 -3 -2 -1 <== 마이너스 인덱스
-----------------------------------------
a = "Hello"
print(a[1])
print(a[1] == a[-4])문자열 슬라이싱(slicing)
#슬라이스 구문을 사용하여 문자범위를 반환할 수 있다.
#문자열의 일부를 반환하려면 시작(인덱스)과 끝(인덱스)을 콜론으로 구분하여 지정한다.
b = "Hello,World"
print(b[2:5]) # llo
print(b[:5]) # Hello
print(b[2:]) # llo,World대문자
print(a.upper())소문자
print(a.lower())✔️문자열 바꾸기
a = "Hello, World"
print(a.replace("H", "J"))✔️문자열 연결
a = "Hello"
b = "World"
c = a + b
print(c)
c = a + " " + b
print(c)🗝 리스트(List)
단일 변수에 여러 항목을 저장하는데 사용된다.
List 항목은 순서가 변경 가능하며 중복값 허용
List에는 다양한 데이터 유형이 포함될 수 있다.
thislist = ["피카츄", "라이츄", "꼬부기"]
print(thislist)
print(thislist[0])
# List 길이
print(len(thislist))
# List 데이터 유형
list1 = ["피카츄", "라이츄", "꼬부기"]
list2 = [1, 2, 3, 4, 5]
list3 = [True, False, False]
# 다양한 유형 포함 가능
list4 = ["abc", 34, False, 40]항목접근
thislist = ["피카츄", "라이츄", "꼬부기"]
print(thislist[1])항목변경
thislist = ["피카츄", "라이츄", "꼬부기"]
thislist[1] = "잠만보"
print(thislist)항목변경 2개
thislist = ["피카츄", "라이츄", "꼬부기", "파이리", "버터블", "야도란"]
thislist[1:3] = ["울먹이", "메타몽"]
print(thislist)두번째,세번째 값을 하나의 값으로 변경
thislist = ["피카츄", "라이츄", "꼬부기", "파이리", "버터블", "야도란"]
thislist[1:3] = ["울먹이"]
print(thislist)항목추가
thislist = ["피카츄", "라이츄", "파이리"]
thislist.append("꼬부기")
print(thislist)인덱스번호로 항목추가
thislist = ["피카츄", "라이츄", "파이리"]
thislist.insert(1, "잠만보")
print(thislist)항목값으로 제거
thislist = ["피카츄", "라이츄", "파이리"]
thislist.remove("라이츄")
print(thislist)항목을 지정된 인덱스로 제거
thislist = ["피카츄", "라이츄", "파이리"]
thislist.pop(2)
print(thislist)마지막 값 제거
thislist = ["피카츄", "라이츄", "파이리"]
thislist.pop()
print(thislist)목록 삭제
thislist = ["피카츄", "라이츄", "파이리"]
thislist.clear()
print(thislist)확장(합집합)
thislist = ["피카츄", "라이츄", "파이리"]
thislist.extend(["버터플", "야도란"])
print(thislist)객체 삭제
del thislist[1]
del thislist[1:2]
print(thislist)🗝 튜플(Tuple)
단일 변수에 여러 항목을 저장하는데 사용된다.
순서가 있고, 변경할 수 없는 List
thistuple = ("피카츄", "라이츄", "파이리")
print(thistuple)튜플 길이
print(len(thistuple))슬라이싱
print(thistuple[1])
print(thistuple[-1])
print(thistuple[1:3])튜플값 변경방법
thistuple = ("피카츄", "라이츄", "파이리")
thiscast = list(thistuple)
thiscast[1] = "잠만보"
thistuple = tuple(thiscast)
print(thistuple)튜플 압축풀기
thistuple = ("피카츄", "라이츄", "파이리", "꼬부기")
(p1, p2, p3, p4) = thistuple
print(type(p1))
print(p2)
print(p3)
print(p4)두개 튜플 조인
thistuple1 = ("피카츄", "라이츄", "파이리", "꼬부기")
thistuple2 = ("버터플", "야도란", "피존투", "또가스")
thistuple3 = thistuple1 + thistuple2
print(thistuple3)🗝 세트(Set)
(중복값 없음)
순서가 없다
변경할 수 없다
인덱싱 되지 않는 컬렉션
thisset = {"피카츄", "라이츄", "파이리"}
# 실행할 때마다 순서가 변경
print(thisset)항목 가져오기
for x in thisset:
print(x)값이 있는지 확인
thisset = {"피카츄", "라이츄", "파이리"}
print("피카츄" in thisset)
print("꼬부기" in thisset)항목 추가하기
thisset.add("꼬부기")
print(thisset)다른 Set 항목추가
thisset1 = {"피카츄", "라이츄", "파이리"}
thisset2 = {"꼬부기", "잠만보", "뮤츠"}
thisset1.update(thisset2)
print(thisset1)항목제거
thisset = {"피카츄", "라이츄", "파이리"}
thisset.remove("피카츄")
print(thisset)
# 똑같은 내용 여러번 제거=>Error 난다.
# thisset.remove("피카츄")
# print(thisset)항목제거(무작위)
thisset.pop()비우기
thisset.clear()🗝 딕셔너리
key : value로 이루어져 쌍으로 데이터 값을 지정하는데 사용
thisdict = {
"brand": "구찌",
"model": "g001",
"year": 2022
}
print(thisdict)✔️ 키 이름을 사용하여 참조할 수 있다.
값 가져오기
print(thisdict["brand"])
print(thisdict.get("model"))키 목록 가져오기
print(thisdict.keys())
#[“brand” , “model” , “year”]thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}추가하기
thisdict["color"] = "red"
print(thisdict)
thisdict.update({"bgColor": "black"})
print(thisdict)변경하기
thisdict["color"] = "yellow"
thisdict.update({"bgColor": "blue"})
print(thisdict)제거하기
thisdict.pop("model")
print(thisdict)마지막 삽입된 항목 제거하기
thisdict.popitem()
print(thisdict)항목 삭제
del thisdict[2] # 인덱싱
del thisdict['year']▲📝mutable
메모리 값을 변경 가능 객체
리스트(list) - 세트(set) - 딕셔너리(dict)
me = [1, 2, 3]
print(id(me))
me.append(4)
print(id(me))📝immutable
메모리 값 변경 불가
정수(int) - 실수(float)
문자열(str) - 튜플(tuple)
me = 10
print(id(me))
me += 1 # me = me + 1
print(id(me))✏️escape문자
\n -> 개행문자
\r -> 줄 바꿈, 커서 앞으로 이동
\f -> 줄 바꿈, 커서를 다음줄로 이동
\t -> 탭
\b -> 백스페이스
\\ -> \
\' -> 작은따옴표
\" -> 큰따옴표
\a -> 벨소리
\v -> 수직탭
print('Hello \'World\'')
print("Hello \"World\"")
print('*\n**\n***')
print('이름\t연락처')
print('제시카\t02-123-4567')✏️print() 함수
sep: 출력할 value의 구분문자
end: value 출력 후 출력할 문자기본값'\n'
file: 출력 방향 지정
print("재미있는", "파이썬")
print("Python", "Java", "C", sep=",")
-------------------------------------
print("안녕", end='\n')
print("하세요")
▲▲▲▲▲▲default▲▲▲▲▲▲
print("안녕", end='')
print("하세요")메모리에 임시저장
fos = open('sample.py', mode='wt')
print('print("Hello World")', file=fos)
fos.close()✏️{ }.format()
{ }를 활용하여 데이터 종류에 상관없이
print문으로 표현이 가능.
print("올해는 {}년 입니다.".format(2022))
print("올해는 {}년, 내년은 {}년 입니다.".format(2022, 2023))
print("나는 {}을 공부 합니다".format('Python'))
print("나는 {}과 {}를 탑니다.".format('지하철', '버스'))address = '''서울특별시 강남구
테헤란로 123
'''
print('주소 : {addr}'.format(addr=address))✏️input('>>>')
데이터 입력함수
name = input('이름을 입력하세요 >>>')
age = input('나이를 입력하세요 >>>')
print('입력된 이름은 {}입니다.'.format(name))
print('입력된 나이는 {}입니다.'.format(age))✏️Casting
변수에 유형을 지정하려는 경우 캐스팅으로 가능.
✔️정수형
x = int(1)
print(x)
y = int(2.8)
print(y)
z = int("3")
print(z)
print(type(z))
print(x+z)
✔️실수형
x = float(1)
print(x)
x = float("3")
print(x)
✔️문자형
x = str(1)
y = str(2)
print(x)
print(x+y)
✔️문자를 아스키코드 값으로 변환
a = ord('A')
print(a)
✔️아스키코드 값을 문자로 변환
b = chr(65)
print(b)✏️연산자
특정한 작업을 수행하기 위해서 사용하는 기호를 의미
🗝 산술 연산자
+ - * ** / // %
a = 7
b = 2
# 덧셈
print('{} + {} = {}'.format(a, b, a + b))
# 뺄셈
print('{} - {} = {}'.format(a, b, a - b))
# 곱셈
print('{} * {} = {}'.format(a, b, a * b))
# 거듭 제곱
print('{} ** {} = {}'.format(a, b, a ** b))
# 나누기
print('{} / {} = {}'.format(a, b, a / b))
# 몫
print('{} // {} = {}'.format(a, b, a // b))
# 나머지
print('{} % {} = {}'.format(a, b, a % b))🗝 대입 연산자
변수에 값을 저장하기 위해 사용하는 연산자
💡print 형식문자
%d : 숫자 데이터
%f : 실수 데이터
%o : 8진수 데이터
%x : 16진수 데이터
%s : 문자열 데이터
%c : 문자 하나 데이터
💡복합 대입연산자
+=ex) x += 3 과 x = x + 3 같다
-=ex) x -= 3 과 x = x - 3 같다
a, b = 10, 20
print('a = %d, b = %d' % (a, b))
a, b = b, a
print('a = %d, b = %d' % (a, b))
piggy_bank = 0
money = 10000
piggy_bank += money
print('저금통에 용돈 {}원을 넣었습니다.'.format(money))
print('지금 저금통에는 {}원이 있습니다.'.format(piggy_bank))
snack = 2000
piggy_bank -= snack
print('저금통에서 스낵 구입비 {}원을 뺐습니다.'.format(snack))
print('지금 저금통에는 {}원이 있습니다.'.format(piggy_bank))🗝 관계 연산자
2개 항을 비교하여 그 결과를 논리(bool) 자료형으로 반환
> >= < <= == !=
a = 15
print('{} > 10 : {}'.format(a, a > 10))
print('{} < 10 : {}'.format(a, a < 10))
print('{} >= 10 : {}'.format(a, a >= 10))
print('{} <= 10 : {}'.format(a, a <= 10))
print('{} == 10 : {}'.format(a, a == 10))
print('{} != 10 : {}'.format(a, a != 10))Alt+Shift+Ins 동시선택 & 붙여넣기
🗝 논리 연산자
관계 연산자와 함께 사용되는 연산자로,
2개이상의 항을 논리적으로 연결할 때 사용한다.
and or not True / False
a = 10
b = 0
print('{} > 0 and {} > 0 : {}'.format(a, b, a > 0 and b > 0))
print('{} > 0 and {} > 0 : {}'.format(a, b, a > 0 or b > 0))
print('not {} : {}'.format(a, not a))
print('not {} : {}'.format(b, not b))🗝 비트 연산자
어떤 변수의 값을 0과 1의 조합인 2진수,
즉 비트로 변환한 뒤에 비트단위로 연산 수행
&(AND) : 입력이 모두 1이면 1, 아니면 0
|(OR) : 입력중 하나라도 1이면 1, 아니면 0
^(XOR) : 입력이 서로 다르면 1, 아니면 0
~(NOT) : 입력이 0이면 1, 입력이 1이면 0
<<(왼쪽 SHIFT) : 비트 단위로 왼쪽으로 N비트 이동하며 2의 N 거듭제곱 만큼 곱셈
>>(오른쪽 SHIFT) : 비트 단위로 오른쪽으로 N비트 이동하며 2의 N 거듭제곱 만큼 나눗셈
a = 3 # 0011
b = 5 # 0101
print('a & b : {}'.format(a & b)) # 0001
print('a | b : {}'.format(a | b)) # 0111
print('a ^ b : {}'.format(a ^ b)) # 0110
print('~ a : {}'.format(~ a)) # (-/1)100
print('a << 1 : {}'.format(a << 1))
print('a >> 1 : {}'.format(a >> 1))🗝 조건 연산자
조건식 결과에 따라 참 또는 거짓의 결과를 반환 한다.
♻ 삼항 연산자 ♻ : 참 if 조건식 else 거짓
a = 10 # a = 20
b = 20 # b = 10
result = (a - b) if (a >= b) else (b - a)
print('{}과 {}의 차이는 {}입니다.'.format(a, b, result))💡 if문
특정 조건을 만족하는지 여부에 따라
실행하는 코드가 달라야 할 때 사용한다.
들여쓰기를 사용하여 코드의 범위 정의if(조건식): (조건식 참)실행할 코드 ------------------------- if(조건식): (조건식 참)실행할 코드 else: (조건식 거짓)실행할 코드 -------------------------- if(조건식1): (조건식1 참)실행할 코드 elif(조건식2): (조건식2 참)실행할 코드 else: (조건식 거짓)실행할 코드
💡 if(조건식)
a = 200
b = 100
if b > a:
print("b는 a보다 크다.")
-------------------------------
💡 if(조건식) else
a = 7
b = 4
if b >= a:
print("b는 a보다 크거나 같다.")
else:
print("b는 a보다 작다.")
-------------------------------
💡 if(조건식1) elif(조건식2) else
a = 20
b = 3
if b == 1:
print("1")
elif b == 2:
print("2")
elif b == 3:
print("3")
else:
print("1,2,3 아니다.")💡 while문
특정 조건을 만족하는 동안 반복해서 수행하는 코드
while 조건식: 반복 실행코드
# n = 10
# while n >= 1:
# print(n)
# n -= 1
def autoDoor(isPerson):
time = 10
while isPerson:
print("문이 열려요")
if time < 1:
break
time -= 1
print("문이 닫혀요")
autoDoor(True)my_list = []
n = int(input('정수를 입력하세요(종료는 0입니다.)>>>'))
while n != 0:
my_list.append(n)
n = int(input('정수를 입력하세요(종료는 0입니다.)>>>'))
print(my_list)
--------------------------------------------------
my_list = []
n = 1 #초기화
while n != 0:
n = int(input('정수를 입력하세요(종료는 0입니다.)>>>'))
my_list.append(n)
my_list.pop() # 0은 필요없으니까
print(my_list)dan = 2
while dan <= 9:
n = 1
while n <= 9:
print('{}*{}={}'.format(dan, n, dan*n), end='|')
n += 1
dan += 1
print()💡 for문
값의 범위나 횟수가 정해져 있을 때 사용하면 편리한 반복문
(while문 보다 자주 사용된다.)
for변수in반복가능한 객체:
반복 실행문a="HELLO" for n in a: print(n) ---------------- for n in ['가위','바위','보'] print(n) ---------------------------- for n in ('가위','바위','보') print(n) -------------------------------------------- person={'1':'유재석','2':'김종국','3':'이광수'} for n in person: print(n,':',person[n])
✔️문자와 숫자의 조합으로 이루어진 비밀번호
pwd = input('비밀번호를 입력하세요 >>>')
ch_count = 0
num_count = 0
for ch in pwd:
if ch.isalpha():
ch_count += 1
elif ch.isnumeric():
num_count += 1
if ch_count > 0 and num_count > 0:
print('가능한 비밀번호 입니다.')
else:
print('불가능한 비밀번호 입니다.')🗝 for문과 range
dan = int(input('출력할 구구단을 입력하세요.>>>'))
for n in range(10): # 0~9 range(stop)
print('{} x {} = {}'.format(dan, n, dan*n))
print('\n')
for n in range(1, 10): # 1~9 range(start,stop)
print('{} x {} = {}'.format(dan, n, dan*n))
print('\n')
for n in range(1, 10, 2): # start,stop,step
print('{} x {} = {}'.format(dan, n, dan*n))
-----------------------------------------------
for i in range(1,6): 5
for j in range(1,6-i): 4 5
print(' ',end=' ') 3 4 5
for j in range(6-i,6): 2 3 4 5
print(j,end=' ') 1 2 3 4 5
print() 🗝 for문과 dict
eng_dict = {
'sun': '태양',
'moon': '달',
'star': '별',
'space': '우주'
} # key : value파이썬은 key값을 구하는 과정생략
eng_dict_keys = eng_dict.keys()
print(eng_dict_keys)
for word in eng_dict_keys:
print('{}의 뜻 : {}'.format(word, eng_dict.get(word)))
✔️곧바로
for word in eng_dict:
print('{}의 뜻 : {}'.format(word, eng_dict.get(word)))💡 break문
while문이나 for문과 같은 반복을 강제로 종료하는 제어문
n = 1
while True:
print(n)
n += 1
print("while End")💡 continue
while문이나 for문과 같은 반복문을 강제로 건너뛰기 (아래코드 실행하지 않는다)
total = 0
for a in range(1, 101):
if a % 3 == 0: # 3의 배수
continue
print('a : {}, total {}'.format(a, total))
total += a
print(total)✏️내장함수
result = format(10000) # str(10000)과 같다
print(type(result))
result = format(10000, ',') # 천단위 쉼표
print(result)🗝 eval()
매개변수로 받은 expression(=식)을 문자열로 받아서 실행하는 함수
expr = input('계산식을 입력하세요 >>>')
result = eval(expr) # 연산자를 이용
print(expr + "=" + str(result))🗝 divmod()
두 숫자를 인자로 전달받아
첫번째 인자를두번째 인자로
나눈 몫과나머지를 tuple형식으로 반환한다.
money = 10000
price = 3000
result = divmod(money, price)
print('빵을 {}개 사고 {}원이 남았습니다.'
.format(result[0], result[1]))🗝 enumerate()
List, Tuple, String 등 자료형을 입력 받으면,인덱스 값을 포함하는 enumerate 객체를 돌려준다.
month = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
# print(type(enumerate(month)))
for month, day in enumerate(month):
print('{}월 = {}일'.format(month+1, day))🗝 abs()
result = abs(10)
print(result)
result = abs(-10)
print(result)result = max(1, 100)
print(result)
🗝 max()
li = [5, 3, 4, 2, 1]
result = max(li)
print(result)🗝 min()
result = min(li)
print(result)🗝 pow()
거듭제곱
result = pow(10, 2)
print(result)🗝 sorted()
my_li = [5, 6, 3, 4, 1, 2]
print(my_li)
print(my_li[0])
result = sorted(my_li)
print(result) #오름차순
print(result[0])
result = sorted(my_li, reverse=True)
print(result) #내림차순🗝 zip()
같은 인덱스 번호끼리 튜플로 묶어준다.
names = ['james', 'emily', 'amanda']
scores = [60, 70, 80]
for student in zip(names, scores):
print(student)
======================================
names = ['james', 'emily', 'amanda']
scores = [60, 70, 80]
for name, score in zip(names, scores):
print('{}의 점수는 {}점 입니다.'
.format(name, score))✏️메소드
🗝 format()
print("10자리 폭 왼쪽정렬 '{:<10d}'".format(123))
print("10자리 폭 오른쪽정렬 '{:>10d}'".format(123))
print("10자리 폭 가운데정렬 '{:^10d}'".format(123))
print("10자리 폭 왼쪽정렬 채움문자 {:*<10d}".format(123))
print("10자리 폭 오른쪽정렬 채움문자 {:*>10d}".format(123))
print("10자리 폭 가운데정렬 채움문자 {:*^10d}".format(123))🗝 count()
s = '내가 그린 기린 그림은 목이 긴 기린 그림이고,네가 그린 기린 그림은 목 짧은 기린 그림이다.'
result = s.count('기린')
print(result)
s = 'best of best'
result = s.count('best', 5)
print(result)
result = s.count('best', -7)
print(result)🗝 find()
✔️위치한 첫번째 인덱스 번호 반환
s = 'apple'
result = s.find('p')
print(result)✔️없는값 find -1
존재하지 않는 문자 입니다.
s = 'apple'
result = s.find('z')
if result == -1:
print('존재하지 않는 문자 입니다.')
print(result)
s = 'best of best'
result = s.find('best', 5)
print(result)
result = s.find('best', -7)
print(result)🗝 index()
✔️위치한 첫번째 인덱스 번호 반환
s = 'apple'
result = s.index('p')
print(result)
result = s.index('z')
print(result)❌문자열이 존재하지 않을 경우 Error!
🗝 join()
s = '-'.join('python')
print(s) # p-y-t-h-o-n
s = '+'.join(['a', 'b', 'c', 'd', 'e'])
print(s) # a+b+c+d+e
s = ''.join(['a', 'b', 'c', 'd', 'd', 'e'])
print(s) # abcde🗝 split()
s = 'Life is too short'
result = s.split()
print(result)
s = '010-1234-5678'
result = s.split('-')
print(result)
name = '김태호|39|프로그래머'
result = s.split('|')
print(result)
print('이름 : {}'.format(result[0]))✔️공백제거
🗝 strip()
s = ' apple'
print(s)
result = s.lstrip() # 왼쪽 공백제거
print(result)🗝 lstrip()
s = 'apple '
print(s)
result = s.rstrip() # 오른쪽 공백제거
print(result)🗝 rstrip()
s = ' apple '
print(s)
result = s.strip() # 양쪽 공백제거
print(result)🗝 replace()
all = s.replace(' ', '') ✔️ 전체 공백제거
s = 'Life is too short'
result = s.replace('short', 'long')
print(result)✔️set메소드
🗝 교집합
intersection()
s1 = {'apple', 'banana', 'cherry'}
s2 = {'apple', 'banana', 'orange'}
print(s1 & s2)
result = s1.intersection(s2)
print(result)🗝 합집합
union
s1 = {'banana', 'apple', 'cherry'}
s2 = {'banana', 'apple', 'orange'}
print(s1 | s2)
plus = s1.union(s2)
print(plus)🗝 차집합
difference
s1 = {'banana', 'apple', 'cherry'}
s2 = {'banana', 'apple', 'orange'}
print(s1 - s2)
minus = s1.difference(s2)
print(minus)✏️함수
하나의 특별한 목적의 작업을 수행하기 위해 독립적으로 설계된 프로그램 코드의 집합.
def 함수이름(매개변수) 코드 실행문 return 반환값
welcome() 함수 정의(실행 x)
def welcome(): # 매개변수 x 리턴 x
print('Hello Python')
print('Nice to meet you')welcome() # 함수 호출(실행)
def introduce(name, age): # 매개변수 0 , 리턴 0
print('내 이름은 {}이고,나이는 {}살 입니다.'.format(name, age))
introduce('james', 25)가변 매개변수 함수
def show(*args):
print(type(args))
for item in args:
print(item)
show('python')
show('python', 'happy', 'birthday')반환(return)값이 있는 함수
def address():
str = '우편번호 12345\n'
str += '서울시 영등포구 여의도동'
return str
result = address()
print(result)매개변수 0 리턴 0
def plus(num1, num2):
return num1 + num2
print(plus(1, 3))
print(plus(2, 5))✔️다른언어는 그냥 선언 , but 파이썬
전역변수 사용시 함수안에서 global
area = 0
def move():
global area
area += 1 # 파이썬에는 증++감--연산자 없음!
return area
result = move() # 매번 호출하고 다시 출력해야 증감효과
print('유닛이 오른쪽으로 {}칸 이동했습니다'.format(result))
result = move() # 매번 호출하고 다시 출력해야 증감효과
print('유닛이 오른쪽으로 {}칸 이동했습니다'.format(result))
result = move() # 매번 호출하고 다시 출력해야 증감효과
print('유닛이 오른쪽으로 {}칸 이동했습니다'.format(result))
result = move() # 매번 호출하고 다시 출력해야 증감효과
print('유닛이 오른쪽으로 {}칸 이동했습니다'.format(result))
result = move() # 매번 호출하고 다시 출력해야 증감효과
print('유닛이 오른쪽으로 {}칸 이동했습니다'.format(result))🗝 지역변수
함수 내부선언 : 함수 내부에서만 사용가능
🗝 전역변수
함수 외부선언 : 함수 내부/외부 모두 사용가능
gVar = '전역'
def globalAndLocal():
lVar = '지역'
print(gVar, '변수 입니다.') #전역변수 참조만 하고있다.
print(lVar, '변수 입니다')
globalAndLocal()
~~전역변수 입니다.~~
~~지역변수 입니다.~~
------------------------------------------------------
gVar = '전역'
def globalAndLocal():
lVar = '지역'
gVar <= '변경된 전역이 아닌 새로운 지역'
print(gVar, '변수 입니다.')
print(lVar, '변수 입니다')
globalAndLocal( )
~~변경된 전역이 아닌 새로운 지역변수 입니다.~~
~~지역변수 입니다.~~
print(gVar)
~~전역~~전역변수 선언
total = 0
def gift(dic, who, money):
global total # 전역변수 total를 사용하겠다
total += money
dic[who] = money
wedding = {} # dictionary 변수선언
gift(wedding, '영희', 5) # {'영희': 5}
gift(wedding, '철수', 10) # {'영희': 5, '철수': 10}
gift(wedding, '이모', 10) # {'영희': 5, '철수': 10, '이모': 10}
# format은 한꺼번에 쓰고 골라서 넣을수 있다.
print('축의금 명단: {}'.format(wedding))
print('전체 축의금: {}'.format(total))평균점수 구하기
def get_average(marks):
total = 0
for subject in marks:
#1.subject: 국어
#2.subject: 영어
#3.subject: 수학
total += marks[subject]
#1. total+=mark['국어']
#total 값 90
#2. total+=mark['영어']
#total 값 170
#3. total+=mark['수학']
#total 값 255
l_average = total/len(marks)
#l_average = 255/3
return l_average
marks = {'국어': 90, '영어': 80, '수학':85}
average = get_average(marks)
print('평균은 {}점 입니다.'.format(average))📁모듈
module이란 한마디로 파이썬 파일(.py)입니다.
조금더 자세히 말하면 언제든지 사용할 수 있도록
변수나 함수 또는 클래스를 모아 놓은 파일을 모듈이라고 합니다.
모든 파이썬 파일은 모듈이 될 수 있습니다.
📁converter.py
MILES = 0.621371
POUND = 0.00220462
def kilometer_to_miles(kilometer):
return kilometer * MILES
def gram_to_pounds(gram):
return gram * POUND📁module.py
✔️ import 모듈
import converter
# import 모듈명.포함된 함수명으로 호출!!
miles = converter.kilometer_to_miles(150)
print('150km = {}miles'.format(miles))
pounds = converter.gram_to_pounds(1000)
print('1000g = {}pounds'.format(pounds))✔️ from 모듈 import 함수
from converter import kilometer_to_miles
miles = kilometer_to_miles(150)
print('150km = {}miles'.format(miles))✔️ from 모듈 import 함수1,함수2
✔️ from 모듈 import*애스터리스크
from converter import *
miles = kilometer_to_miles(150)
print('150km={}miles'.format(miles))
pounds = gram_to_pounds(1000)
print('1000g={}pounds'.format(pounds))✔️ import 모듈 as 별명
import converter as cvt
miles = cvt.kilometer_to_miles(150)
print('150km = {}miles'.format(miles))
pounds = cvt.gram_to_pounds(1000)
print('1000g = {}pounds'.format(pounds))✔️ import 모듈 import 함수 as 별명
from converter import kilometer_to_miles as k_to_m
miles = k_to_m(150)
print('150km = {}miles'.format(miles))🗝 math
🗝 random
random() 함수
randint() 함수
randrange() 함수
choice() 함수
sample() 함수
shuffle() 함수
🗝 time
time() 함수
ctime() 함수
strftime() 함수
sleep() 함수
🗝 datetime
now() 메소드
date() 함수
time() 함수
날짜/시간 필드값
timedelta() 함수
total_seconds() 메소드
📦패키지
모듈 상위 개념 (모듈의 집합을 의미한다.)
패키지 설치
console > pip instal package명
패키지 삭제
console > pip uninstal package명
📦행렬기반
import numpy as np 1차원 행렬 만들기
[ [ 1 2 3 4 ]
[ 5 6 7 8 ]
[ 9 10 11 12 ]
[ 13 14 15 16 ] ][ 1 , 2 , 3 , 4 , 5 ]
a = np .
array( list )
a = np . array ([ 1 , 2 , 3 ])b = np .
array( list )
b = np . array ([ 4 , 5 , 6 ])
c = a + b
c = a - b
c = a * b
c = a / b
EverySingleDay