<jupyter_start><jupyter_text>How_to_use_Python                   https://wikidocs.net/book/1 를 참고해서 작성 했습니다.211024~ 세세한 것 보단 중요한 것 위주로 정리합니다.<jupyter_code>from IPython.display import Image

Image('jump.png',width='90%')<jupyter_output><empty_output><jupyter_text>기초  사칙연산<jupyter_code>a = 3 
b = 4
print(a+b) # 더하기
print(a*b) # 곱하기
print(a/b) # 나누기
print(a**b) # 제곱
print(3%7) # 나눗셈 후 나머지를 반환하는 연산자
print(7%3)
7/4 # 나눗셈 후 몫을 반환하는 연산자<jupyter_output><empty_output><jupyter_text>문자열에 작은 따옴표 (') 포함시키기<jupyter_code>print("Python's favorite food is perl")
# 큰 따옴표로 감싸면 된다.<jupyter_output>Python's favorite food is perl<jupyter_text>백슬래시를 사용해서 작은따옴표와 큰따옴표를 문자열에 포함시키기<jupyter_code>print('python \'s favorite food is perl')<jupyter_output>python 's favorite food is perl<jupyter_text>여러 줄인 문자열을 변수에 대입하고 싶을 때<jupyter_code># 방법 1
print('Life is too short \nYou need Python')
# \n을 대입하면 된다.
# 방법 2 

multiline = '''

Life is too short 
You need Python

'''


print(multiline)<jupyter_output>Life is too short 
You need Python<jupyter_text>한 줄에 결괏값 출력하기<jupyter_code>for i in range(10):
    print(i, end=' ')<jupyter_output>0 1 2 3 4 5 6 7 8 9<jupyter_text>문자열 연산하기<jupyter_code># 문자열 더해서 연결하기

head = 'Python'
tail = ' is fun!'

head + tail
# 문자열 곱하기
a = 'python '
a*2
# 문자열 길이 구하기

a = 'Life is too short You need Python'

len(a)<jupyter_output><empty_output><jupyter_text>문자열 인덱싱과 슬라이싱<jupyter_code>a = "Life is too short You need Python"

a=a.split(' ')
print(a)
# 파이썬은 0부터 센다.
a = "Life is too short You need Python"
a[3] # L부터 0이다. 고로 e는 3
# 응용

a[0:4] + a[4:8] + a[8:]
# 응용2

a = '20010331Rainy'

Date = a[:8]
weather = a[8:]

print(Date) #날짜
print(weather) # 날씨<jupyter_output>20010331
Rainy<jupyter_text>Pithon 이라는 문자열을 Python 으로 바꾸기<jupyter_code># 방법1
a = 'Pithon'
a=a.replace('i','y')
print(a)
# 방법2
b = 'Pithon'
# b[1]='y'

#--> 에러가 뜬다. 문자열의 요솟값은 바꿀 수 없다.
#TypeError: 'str' object does not support item assignment

# 맞는 방법 
b=b[0]+'y'+b[2:]
b<jupyter_output><empty_output><jupyter_text>문자열 포맷팅  %s : 문자열 , %c : 문자한개, %d : 정수<jupyter_code>print("I eat %d apples" %3) # 숫자
print("I eat %s apples" %'three') # 문자열
# 숫자 값을 나타내는 변수로 대입
number = 3 
'I eat %d apples' %number
# 2개 이상의 값 넣기

number = 10 
day = 'three'
'I ate %d apples. so I was sick for %s' %(number,day)<jupyter_output><empty_output><jupyter_text>소수점 표현하기<jupyter_code># 소수점 넷째 자리까지 표현 
"%0.4f" %3.21415166 
y = 3.234145
"{0:0.4f}".format(y)<jupyter_output><empty_output><jupyter_text>바로 대입하기<jupyter_code>'I eat {} banana'.format(3) # 숫자
'I eat {} banana'.format('hansome') # 문자열
# 두개 이상의 값 넣기

'I eat {0} banana because I\'m {1}'.format(4,'hungry')<jupyter_output><empty_output><jupyter_text>문자 개수 세기<jupyter_code>a = 'hayeonKimm'
a.count('h') # h가 몇번 들어갔는지 세기
a.count('m') # m이 몇번 들어갔는지<jupyter_output><empty_output><jupyter_text>위치 알려주기<jupyter_code>a = 'Python is Very Good'
a.find('is') # 7에 처음 나온다.
a.find('P') # 0 자리에 나온다.<jupyter_output><empty_output><jupyter_text>문자열 삽입<jupyter_code># ,를 기준으로 문자열 삽입
",".join('abcd')<jupyter_output><empty_output><jupyter_text>소문자를 대문자로 바꾸기 (혹은 반대)<jupyter_code># 소 -> 대
a = 'hi'
a=a.upper()
a

# 대 -> 소

a = 'HI'
a=a.lower()
a<jupyter_output><empty_output><jupyter_text>공백지우기<jupyter_code>a= '  hi'
a.lstrip() # 왼쪽 공백들을 지운다.
# 지금부터 할당은 생략.
a= 'hi    '
a.rstrip() #  오른쪽 공백 제거<jupyter_output><empty_output><jupyter_text>문자열 바꾸기<jupyter_code>## 문자열 바꾸기 

a= "Life is too short"
a.replace("Life","Game")<jupyter_output><empty_output><jupyter_text>문자열 나누기<jupyter_code>a = "Life is too short"
a.split() # 공백을 기준으로 문자열 나눔

b= "a:b:c:d"
b.split(':') # :를 기준으로 나눔<jupyter_output><empty_output><jupyter_text>리스트<jupyter_code>odd = [1,3,5,7,9]
odd<jupyter_output><empty_output><jupyter_text>리스트의 인덱싱과 슬라이싱리스트도 문자열처럼 인덱싱과 슬라이싱이 가능하다.<jupyter_code>odd[0]
odd[0:]<jupyter_output><empty_output><jupyter_text>더하기도 가능하다.<jupyter_code>aX = [1,2,3,4,5]

aX[0]+aX[1]
ac = [1,2,3,['a','b','c']]

ac[0]
ac[3]
ac[-1]

ac[-1][0] # a 끄집어오기<jupyter_output><empty_output><jupyter_text>리스트 더하기<jupyter_code>a= [1,2,3]
b= [4,5,6]

a+b<jupyter_output><empty_output><jupyter_text>리스트 반복하기<jupyter_code>a = [1,2,3]
a*3<jupyter_output><empty_output><jupyter_text>리스트 길이 구하기<jupyter_code>len(a)<jupyter_output><empty_output><jupyter_text>리스트에서 값 수정하기<jupyter_code>a = [1,2,3]
a[2]=4

a<jupyter_output><empty_output><jupyter_text>del 함수 사용해서 리스트 요소 삭제하기<jupyter_code>del a[2]
a<jupyter_output><empty_output><jupyter_text>리스트 요소 제거 (remove)<jupyter_code>a = [1,2,3,1,2,3]
a.remove(3) # 첫 3을 제거하라.
a<jupyter_output><empty_output><jupyter_text>리스트에 요소 추가 (append)<jupyter_code>a.append(16)
a<jupyter_output><empty_output><jupyter_text>리스트에 다시 리스트 추가하기<jupyter_code>a.append([1,1,1,1])
a<jupyter_output><empty_output><jupyter_text>리스트 정렬 숫자 정렬<jupyter_code>a = [1,4,3,2]
a.sort()
a<jupyter_output><empty_output><jupyter_text>문자열 정렬<jupyter_code>a = ['b','c','a']
a.sort()
a<jupyter_output><empty_output><jupyter_text>리스트 뒤집기 reverse<jupyter_code>a = ['b','c','a']
a.reverse()
a<jupyter_output><empty_output><jupyter_text>위치 반환 (index)<jupyter_code>a = [3,4,5]
a.index(3)
a.index(5) # 5가 있는 위치를 반환한다.<jupyter_output><empty_output><jupyter_text>리스트에 요소 삽입(insert)<jupyter_code>a = [1,2,3]
a.insert(0,4) # 0의 자리에 4 삽입
a<jupyter_output><empty_output><jupyter_text>리스트 확장하기.(extend)<jupyter_code>a=[1,2,3]
a.extend([4,5,6]) # ==  a+=[4,5]
a<jupyter_output><empty_output><jupyter_text>튜플 (Tuple) 리스트는 그 값의 생성 삭제 수정이 가능하지만 튜플은 그 값을 바꿀 수 없다.  인덱싱<jupyter_code>t1 = (1,2,'a','b')
t1[2]<jupyter_output><empty_output><jupyter_text>슬라이싱<jupyter_code>t1 =(1,2,'a','b')
t1[1:]<jupyter_output><empty_output><jupyter_text>사칙연산<jupyter_code># 더하기
t2 = (3,4)
t1+t2
# 곱하기

t2*3<jupyter_output><empty_output><jupyter_text>길이 구하기<jupyter_code>t1 = (1,2,'a','b')
len(t1)<jupyter_output><empty_output><jupyter_text>딕셔너리 자료형 기본 딕셔너리 모습   {Key1:Value1, Key2:Value2, Key3:Value3, ...}  딕셔너리 만들기<jupyter_code>dic = {'name':'pey', 'phone':'011-999-2323', 'birth': '0720'}
dic
a = {1: 'hi'} # value 값에 문자열은 따옴표를 붙여서.
a = { 'a': [1,2,3]} # 리스트도 넣을 수 있다.
a<jupyter_output><empty_output><jupyter_text>딕셔너리에 쌍 추가하기<jupyter_code>a = {1: 'a'}
a[2] = 'b' # 2는 키값 'b'는 밸류값.
a
a['name'] = 'pey'
a['hayeon'] = 'imma'
a<jupyter_output><empty_output><jupyter_text>딕셔너리 요소 제거하기<jupyter_code>del a[1]
a<jupyter_output><empty_output><jupyter_text>딕셔너리 활용 사례 리스트나 문자열로는 표현하기가 상당히 까다로울 것이다.      하지만 파이썬의 딕셔너리를 사용한다면 이 상황을 표현하기가 정말 쉽다. 다음 예를 보자.<jupyter_code>house_price = {'gangnam':1000,'gyeonggi':90}
house_price['gangnam']
house_price['gyeonggi']<jupyter_output><empty_output><jupyter_text>딕셔너리 만들 때 주의할 사항      먼저 딕셔너리에서 Key는 고유한 값이므로 중복되는 Key 값을 설정해 놓으면 하나를 제외한 나머지 것들이 모두 무시된다는 점을 주의해야 한다.   다음 예에서 볼 수 있듯이 동일한 Key가 2개 존재할 경우 1:'a' 쌍이 무시된다.<jupyter_code># 반복문 활용사례

a = {'name': 'pey', 'phone': '0119993323', 'birth': '1118'}
a.keys()

for i in a.keys():  # a.keys()를 통해서 key값만 불러올 수 있다.
    print(i)
# 다양한 도구들.
a.keys()
a.values()
a.items()
a.clear()<jupyter_output><empty_output><jupyter_text>key로 value 얻기 (get)<jupyter_code>a = {'python':10,'jave':'javajjang','c++':200}
a.get('python')<jupyter_output><empty_output><jupyter_text>get(x) 함수는 x라는 Key에 대응되는 Value를 돌려준다.   앞에서 살펴보았듯이 a.get('name')은 a['name']을 사용했을 때와 동일한 결괏값을 돌려받는다.   다만 다음 예제에서 볼 수 있듯이 a['nokey']처럼 존재하지 않는 키(nokey)로 값을 가져오려고 할 경우 a['nokey']는 Key 오류를 발생시키고 a.get('nokey')는 None을 돌려준다는 차이가 있다.       어떤것을 사용할지는 여러분의 선택이다.  해당 Key가 딕셔너리 안에 있는지 조사하기(in)<jupyter_code>a = {'python':10,'java':'javajjang','c++':200}

'python' in a
'java' in a
'django' in a<jupyter_output><empty_output><jupyter_text>집합 자료형 집합(set)은 파이썬 2.3부터 지원하기 시작한 자료형으로,   집합에 관련된 것을 쉽게 처리하기 위해 만든 자료형이다.<jupyter_code>set1 = set([1,2,3])
set1<jupyter_output><empty_output><jupyter_text>문자열을 넣어서 따로 분리시킬 수 있다.<jupyter_code>s2 = set("Hello")
s2<jupyter_output><empty_output><jupyter_text>집합 자료형의 특징중복을 허용하지 않는다.순서가 없다(Unordered).리스트나 튜플은 순서가 있기(ordered) 때문에 인덱싱을 통해 자료형의 값을 얻을 수 있지만 set 자료형은 순서가 없기(unordered) 때문에 인덱싱으로 값을 얻을 수 없다.        이는 마치 02-5에서 살펴본 딕셔너리와 비슷하다. 딕셔너리 역시 순서가 없는 자료형이라 인덱싱을 지원하지 않는다.      만약 set 자료형에 저장된 값을 인덱싱으로 접근하려면 다음과 같이 리스트나 튜플로 변환한후 해야 한다.  교집합, 합집합, 차집합 구하기<jupyter_code>>>> s1 = set([1, 2, 3, 4, 5, 6])
>>> s2 = set([4, 5, 6, 7, 8, 9])
# 교집합
s1 & s2
# 교집합 2
s1.intersection(s2)
# 합집합

s1|s2
s1.union(s2)
# 차집합
s1 - s2
s1.difference(s2)<jupyter_output><empty_output><jupyter_text>값 1개 추가하기 (add)<jupyter_code>s1 = set([1, 2, 3])
s1.add(4)
s1<jupyter_output><empty_output><jupyter_text>값 여러 개 추가하기(update)<jupyter_code>s1 = set([1,2,3])
s1.update([4,5,6])
s1<jupyter_output><empty_output><jupyter_text>특정 값 제거하기(remove)<jupyter_code>s1 = set([1,2,3])
s1.remove(2)
s1<jupyter_output><empty_output><jupyter_text>불 자료형  불 자료형은 간단히 요약하겠다.<jupyter_code># 값이 있으면 참 , 없으면 거짓

a = [1, 2, 3, 4]
while a: # 이 부분.
    print(a.pop())
# 이해에 도움되는 예시 
# []안에 값이 있으면 참 , 아니면 거짓
if []:
    print("참")
else:
    print("거짓")<jupyter_output>거짓<jupyter_text>if if 조건문에서 "조건문"이란 참과 거짓을 판단하는 문장을 말한다.  and, or, not조건을 판단하기 위해 사용하는 다른 연산자로는 and, or, not이 있다.   각각의 연산자는 다음처럼 동작한다.<jupyter_code>#돈이 3000원 이상 있거나 카드가 있다면 택시를 타고 그렇지 않으면 걸어가라.

money = 2000
card = True

if money>=3000 or card:
    print('택시를 타라')
    
else: 
    print('걸어가라')<jupyter_output>택시를 타라<jupyter_text>x in s, x not in s<jupyter_code>1 in [1,2,3]
1 not in [1,2,3]
# "만약 주머니에 돈이 있으면 택시를 타고, 없으면 걸어 가라."


pocket = ['paper','cellphone','money']

if 'money' in pocket:
    print('택시를 타자')
    
else: print('걸어가자...')<jupyter_output>택시를 타자<jupyter_text>[조건문에서 아무 일도 하지 않게 설정하고 싶다면?]가끔 조건문의 참, 거짓에 따라 실행할 행동을 정의할 때, 아무런 일도 하지 않도록 설정하고 싶을 때가 있다.<jupyter_code># "주머니에 돈이 있으면 가만히 있고 주머니에 돈이 없으면 카드를 꺼내라."


pocket = ['money','cellphone']

if 'money' in pocket:
    pass # pass 가 아무것도 안하는 코드다.

else: print('카드를 꺼내라~')<jupyter_output><empty_output><jupyter_text>다양한 조건을 판단하는 elif<jupyter_code># "주머니에 돈이 있으면 택시를 타고, 주머니에 돈은 없지만 카드가 있으면 택시를 타고, 돈도 없고 카드도 없으면 걸어 가라."

pocket = ['money','card','cellphone']

if 'money' in pocket:
    print('Take a taxi')
    
elif 'card' in pocket:
    print('Take a taxi')
    
else: print('걸어가라')<jupyter_output>Take a taxi<jupyter_text>조건부 표현식<jupyter_code>score=70

if score >= 60:
    message = 'success'
else:
    message ='failure'
    
print(message)
# 위의 코드를 한 줄로 표현 할 수도 있다.
message = "success" if score >= 60 else "failure"
message<jupyter_output><empty_output><jupyter_text>while문 반복해서 문장을 수행해야 할 경우 while문을 사용한다.   그래서 while문을 반복문이라고도 부른다.<jupyter_code># 예시1

treeHit=0
while treeHit <10: # treeHit이 10 이하 일 때 작동.
    treeHit+=1
    print('나무를 %d번 찍었습니다.'%treeHit)
    
    if treeHit==10:
        print("나무 넘어갑니다.")<jupyter_output>나무를 1번 찍었습니다.
나무를 2번 찍었습니다.
나무를 3번 찍었습니다.
나무를 4번 찍었습니다.
나무를 5번 찍었습니다.
나무를 6번 찍었습니다.
나무를 7번 찍었습니다.
나무를 8번 찍었습니다.
나무를 9번 찍었습니다.
나무를 10번 찍었습니다.
나무 넘어갑니다.<jupyter_text>위 예에서 while문의 조건문은 treeHit < 10이다.    즉 treeHit가 10보다 작은 동안에 while문 안의 문장을 계속 수행한다.       whlie문 안의 문장을 보면 제일 먼저 treeHit = treeHit + 1로 treeHit 값이 계속 1씩 증가한다.       그리고 나무를 treeHit번만큼 찍었음을 알리는 문장을 출력하고 treeHit가 10이 되면 "나무 넘어갑니다."라는 문장을 출력한다.그러고 나면 treeHit < 10 조건문이 거짓이 되므로 while문을 빠져나가게 된다.<jupyter_code># 예시2

prompt = """

1. Add
2. Del
3. List
4. Quit

Enter number: """<jupyter_output><empty_output><jupyter_text>while문을 보면 number가 4가 아닌 동안 prompt를 출력하고 사용자로부터 번호를 입력받는다.       다음 결과 화면처럼 사용자가 값 4를 입력하지 않으면 계속해서 prompt를 출력한다.<jupyter_code>number = 0
while number!=4:
    print(prompt)
    number=int(input())
# while문 강제로 빠져나가기 (break)


coffee = 10
money = 300

while money:
    print('돈을 받았으니 커피를 줍니다.')
    coffee = coffee -1
    print('남은 커피의 양은 %d개입니다.'%coffee)
    
    if coffee == 0:
        print('커피가 다 떨어졌습니다. 판매를 중지합니다.')
        break
#예시3 (자판기 실제 작동 과정과 비슷함.)

coffee = 10
while True:
    money = int(input("돈을 넣어 주세요: "))
    if money == 300:
        print("커피를 줍니다.")
        coffee = coffee -1
    elif money > 300:
        print("거스름돈 %d를 주고 커피를 줍니다." % (money -300))
        coffee = coffee -1
    else:
        print("돈을 다시 돌려주고 커피를 주지 않습니다.")
        print("남은 커피의 양은 %d개 입니다." % coffee)
    if coffee == 0:
        print("커피가 다 떨어졌습니다. 판매를 중지 합니다.")
        break
# while문의 맨 처음으로 돌아가기


a = 0

while a <10:
    a+=1
    
    if a %2 ==0: continue  # continue는 while문으로 다시 돌아가게 한다.
    print(a) # 이 부분은 띄어쓰기를 안한다.<jupyter_output>1
3
5
7
9<jupyter_text>무한 루프 무한 루프란 무한히 반복한다는 의미이다.   우리가 사용하는 일반 프로그램 중에서 무한 루프 개념을 사용하지 않는 프로그램은 거의 없다.   그만큼 자주 사용한다는 뜻이다. while문의 조건문이 True이므로 항상 참이 된다.      따라서 while문 안에 있는 문장들은 무한하게 수행될 것이다.   다음의 무한 루프 예이다.<jupyter_code># while True:
#     print("Ctrl+C를 눌러야 while문을 빠져나갈 수 있습니다.")<jupyter_output><empty_output><jupyter_text>함수 함수는 들어온 입력값을 받아 어떤 처리를 하여 적절한 결괏값을 돌려준다. 파이썬 함수의 구조def 함수명(매개변수):                     ...<jupyter_code># 예시

def add(a, b): 
    return a + b

add(1,3)<jupyter_output><empty_output><jupyter_text>매개변수와 인수 매개변수(parameter)와 인수(arguments)는 혼용해서 사용되는 헷갈리는 용어이므로 잘 기억해 두자.   매개변수는 함수에 입력으로 전달된 값을 받는 변수를 의미하고 인수는 함수를 호출할 때 전달하는 입력값을 의미한다.<jupyter_code>def add(a, b):  # a, b는 매개변수
    return a+b

print(add(3, 4))  # 3, 4는 인수<jupyter_output>7<jupyter_text>입력값이 없는 함수<jupyter_code>def say():
    return 'Hi'
say()
def add(a, b): 
    print("%d, %d의 합은 %d입니다." % (a, b, a+b))
a=add(3,4)
print(a)<jupyter_output>3, 4의 합은 7입니다.
None<jupyter_text>아마도 여러분은 ‘3, 4의 합은 7입니다.’라는 문장을 출력해 주었는데 왜 결괏값이 없다는 것인지 의아하게 생각할 것이다.   이 부분이 초보자들이 혼란스러워하는 부분이기도 한데 print문은 함수의 구성 요소 중 하나인 에 해당하는 부분일 뿐이다.   결괏값은 당연히 없다. 결괏값은 오직 return 명령어로만 돌려받을 수 있다.  *여러 개의 입력값을 받는 함수 만들기<jupyter_code>def add_many(*args):
    result=0
    for i in args:
        result+=i
    return result

add_many(1,2,3)<jupyter_output><empty_output><jupyter_text>키워드 파라미터 kwargs 입력값 a=1 또는 name='foo', age=3이 모두 딕셔너리로 만들어져서 출력된다는 것을 확인할 수 있다. 즉 **kwargs처럼 매개변수 이름 앞에 **을 붙이면 매개변수 kwargs는 딕셔너리가 되고 모든 key=value 형태의 결괏값이 그 딕셔너리에 저장된다.<jupyter_code>def print_kwargs(**kwargs):
    print(kwargs)<jupyter_output><empty_output><jupyter_text>[return의 또 다른 쓰임새] 특별한 상황일 때 함수를 빠져나가고 싶다면 return을 단독으로 써서 함수를 즉시 빠져나갈 수 있다. 다음 예를 보자.<jupyter_code>def say_nick(nick):
    if nick == '바보':
        return
    
    print('나의 별명은 %s 입니다.'%nick)
    
say_nick('바보')<jupyter_output><empty_output><jupyter_text>매개변수에 초깃값 미리 설정하기<jupyter_code>def say_myself(name,old,man=True):
    
    # man이 바로 초기값이다.
    
    print('나의 이름은 %s입니다.'%name)
    print('나이는 %d살입니다.'%old)
    
    if man:
        print('남자입니다.')
    
    else:
        print('여자입니다.')
say_myself('하연',28)
say_myself('하연',28,False)<jupyter_output>나의 이름은 하연입니다.
나이는 28살입니다.
여자입니다.<jupyter_text>함수 안에서 함수 밖의 변수를 변경하는 방법<jupyter_code>return 사용하기

def vartest(a): 
    a = a +1 
    return a

a = vartest(a) 
print(a)
global 명령어 사용하기

a = 1 
def vartest(): 
    global a 
    a = a+1

vartest() 
print(a)<jupyter_output><empty_output><jupyter_text>lambda 보통 함수를 한줄로 간결하게 만들 때 사용한다. 우리말로는 "람다"라고 읽고 def를 사용해야 할 정도로 복잡하지 않거나 def를 사용할 수 없는 곳에 주로 쓰인다.<jupyter_code>add = lambda a,b :a+b
result = add(3,4)

print(result)<jupyter_output>7<jupyter_text>사례1원하는 결과가 각 요소의 번호 순 정렬이 아닌 그 뒤의 문자 순 정렬을 원하며, 문자가 동일한 경우에만 그 앞 번호순으로 정렬되는 형태를 희망할 때<jupyter_code>s.sort(key=lambda x: (x.split()[1], x.split()[0]))<jupyter_output><empty_output><jupyter_text>파일 읽고 쓰기 파일 생성하기 다음 소스 코드를 에디터로 작성해서 저장한 후 실행해 보자. 프로그램을 실행한 디렉터리에 새로운 파일이 하나 생성된 것을 확인할 수 있을 것이다.<jupyter_code>f = open("새파일.txt", 'w')
f.close()<jupyter_output><empty_output><jupyter_text>r	읽기모드 - 파일을 읽기만 할 때 사용   w	쓰기모드 - 파일에 내용을 쓸 때 사용   a	추가모드 - 파일의 마지막에 새로운 내용을 추가 시킬 때 사용 파일을 쓰기 모드로 열면 해당 파일이 이미 존재할 경우 원래 있던 내용이 모두 사라지고, 해당 파일이 존재하지 않으면 새로운 파일이 생성된다. 위 예에서는 디렉터리에 파일이 없는 상태에서 새파일.txt를 쓰기 모드인 'w'로 열었기 때문에 새파일.txt라는 이름의 새로운 파일이 현재 디렉터리에 생성되는 것이다. 만약 새파일.txt 파일을 C:/doit 디렉터리에 생성하고 싶다면 다음과 같이 작성해야 한다.f = open("C:/doit/새파일.txt", 'w')   f.close()<jupyter_code># 파일을 쓰기 모드로 열어 출력값 적기

f = open("새파일.txt",'w')

for i in range(1,11):
    data = '%d번째 줄입니다.\n'%i
    f.write(data)
f.close()
readline 함수 이용하기
첫 번째 방법은 readline 함수를 사용하는 방법이다. 

# readline_test.py
f = open("C:/doit/새파일.txt", 'r')
line = f.readline()
print(line)
f.close()
만약 모든 줄을 읽어서 화면에 출력하고 싶다면 다음과 같이 작성하면 된다.

# readline_all.py
f = open("C:/doit/새파일.txt", 'r')
while True:
    line = f.readline()
    if not line: break
    print(line)
f.close()
read 함수 사용하기
세 번째 방법은 read 함수를 사용하는 방법이다. 다음 예를 보자.

f = open("C:/doit/새파일.txt", 'r')
data = f.read()
print(data)
f.close()
# 파일에 새로운 내용 추가하기


# adddata.py
f = open("C:/doit/새파일.txt",'a')
for i in range(11, 20):
    data = "%d번째 줄입니다.\n" % i
    f.write(data)
f.close()<jupyter_output><empty_output><jupyter_text>자동저장 with<jupyter_code>with open("foo.txt", "w") as f:
    f.write("Life is too short, you need python")<jupyter_output><empty_output><jupyter_text>Numpy  조건식<jupyter_code>df2['Age_gr'] = np.where(df2.Age<20,'10',
                         np.where(df2.Age<30,'20',
                         np.where(df2.Age<40,'30',
                         np.where(df2.Age<50,'40',
                         np.where(df2.Age<60,'50','60'<jupyter_output><empty_output><jupyter_text>클래스 계산기 1의 결괏값이 계산기 2에 아무 영향을 끼치지 않음을 확인할 수 있다.      하지만 계산기가 3개, 5개, 10개로 점점 더 많이 필요해진다면 어떻게 해야 할까? 그때마다 전역 변수와 함수를 추가할 것인가? 여기에 빼기나 곱하기 등의 기능을 추가해야 한다면 상황은 점점 더 어려워질 것이다.아직 클래스에 대해 배우지 않았지만, 위와 같은 경우에 클래스를 사용하면 다음과 같이 간단하게 해결할 수 있다.<jupyter_code>class Calculator:
    def __init__(self):
        self.result = 0

    def add(self, num):
        self.result += num
        return self.result

cal1 = Calculator()
cal2 = Calculator()

print(cal1.add(3))
print(cal1.add(4))
print(cal2.add(3))
print(cal2.add(7))
from IPython.display import Image
 
Image("class설명.png") 
from IPython.display import Image
 
Image("class설명2.png")<jupyter_output><empty_output><jupyter_text>a 객체의 first 값은 b 객체의 first 값에 영향받지 않고 원래 값을 유지하고 있음을 확인할 수 있다.         이 예제를 통해 여러분에게 강조하고 싶은 점이 바로 이것이다. 클래스로 만든 객체의 객체변수는 다른 객체의 객체변수에 상관없이 독립적인 값을 유지한다.  더하기 기능 만들기 (class)<jupyter_code>class Fourcal:
    
    def setdata(self, first , second):
        self.first = first
        self.second = second
    
    def add(self):
        result = self.first + self.second
        return result
a = Fourcal()
a.setdata(5,6)
a.add()
from IPython.display import Image
 
Image("class설명3.png") 
# 곱하기, 빼기, 나누기 기능 만들기 --> 요건 나중에.<jupyter_output><empty_output><jupyter_text>생성자 (Constructor) 객체에 초깃값을 설정해야 할 필요가 있을 때는 setdata와 같은 메서드를 호출하여 초깃값을 설정하기보다는 생성자를 구현하는 것이 안전한 방법이다.   생성자(Constructor)란 객체가 생성될 때 자동으로 호출되는 메서드를 의미한다.  데이터프레임 만들기<jupyter_code>import pandas as pd
df = pd.DataFrame({'size':[100055,21512,25252] ,'bottom':[8882828,12525,12322]},index=['a','b','c'])
class FourCal:
    
    def __init__(self, first, second):
        
        self.first = first
        self.second = second
    
    def setdata(self, first, second):
    
        self.first = first
        self.second = second
        
    def add(self):
        result = self.first + self.second
        return result
    
    def mul(self):
        result = self.first * self.second
        return result
    
    def sub(self):
        result = self.first - self.second
        return result
    
    def div(self):
        result = self.first / self.second
        return result
abc=FourCal(4,2)

abc.add()
abc.mul()<jupyter_output><empty_output><jupyter_text>클래스의 상속 앞에서 FourCal 클래스는 이미 만들어 놓았으므로 FourCal 클래스를 상속하는 MoreFourCal 클래스는 다음과 같이 간단하게 만들 수 있다.<jupyter_code>class MoreFourCal(FourCal):
    pass
a = MoreFourCal(4,2)
a.add()
a.mul()
a.sub()
a.div()<jupyter_output><empty_output><jupyter_text>왜 상속을 해야 할까?보통 상속은 기존 클래스를 변경하지 않고 기능을 추가하거나 기존 기능을 변경하려고 할 때 사용한다."클래스에 기능을 추가하고 싶으면 기존 클래스를 수정하면 되는데 왜 굳이 상속을 받아서 처리해야 하지?" 라는 의문이 들 수도 있다. 하지만 기존 클래스가 라이브러리 형태로 제공되거나 수정이 허용되지 않는 상황이라면 상속을 사용해야 한다.  상속 후 메서드 추가<jupyter_code>class MoreFourCal(FourCal):
    def pow(self):
        result = self.first ** self.second
        return result
a = MoreFourCal(4,2)

a.pow()<jupyter_output><empty_output><jupyter_text>메서드 오버라이딩 FourCal 클래스의 객체 a에 4와 0 값을 설정하고 div 메서드를 호출하면 4를 0으로 나누려고 하기 때문에 위와 같은 ZeroDivisionError 오류가 발생한다. 하지만 0으로 나눌 때 오류가 아닌 0을 돌려주도록 만들고 싶다면 어떻게 해야 할까?다음과 같이 FourCal 클래스를 상속하는 SafeFourCal 클래스를 만들어 보자.<jupyter_code>class SafeFourCal(FourCal):
    
    def div(self):
        
        if self.second==0:
            return 0
        else:
            return self.first / self.second<jupyter_output><empty_output><jupyter_text>SafeFourCal 클래스는 FourCal 클래스에 있는 div 메서드를 동일한 이름으로 다시 작성하였다. 이렇게 부모 클래스(상속한 클래스)에 있는 메서드를 동일한 이름으로 다시 만드는 것을 메서드 오버라이딩(Overriding, 덮어쓰기)이라고 한다. 이렇게 메서드를 오버라이딩하면 부모클래스의 메서드 대신 오버라이딩한 메서드가 호출된다.<jupyter_code>b=FourCal(4,0)
b.div()
# 확인체크

a=SafeFourCal(4,0)
a.div()

# b=FourCal(4,0)
# b.div()<jupyter_output><empty_output><jupyter_text>클래스 변수<jupyter_code>class Family:
    
    lastname = "김"
    
    
# lastname이 바로 클래스 변수이다.
print(Family.lastname)
a = Family()
a.lastname<jupyter_output><empty_output><jupyter_text>모듈 모듈이란 함수나 변수 또는 클래스를 모아 놓은 파일이다.        모듈은 다른 파이썬 프로그램에서 불러와 사용할 수 있게끔 만든 파이썬 파일이라고도 할 수 있다.<jupyter_code># mod1.py 로 저장

f1 = open('mod1.py','w')

f1.write("""

def add(a,b):
    return a+b

def sub(a,b):
    return a-b    
    
""")

f1.close()
f2=open('mod1.py','r')
print(f2.read())
f2.close()
import mod1
print(mod1.add(3,4))
print(mod1.sub(4,2))
from mod1 import add
add(3,4)<jupyter_output><empty_output><jupyter_text>if __name__ == "__main__": 의 의미 if __name__ == "__main__"을 사용하면 C:\doit>python mod1.py처럼 직접 이 파일을 실행했을 때는 __name__ == "__main__"이 참이 되어 if문 다음 문장이 수행된다.반대로 대화형 인터프리터나 다른 파일에서 이 모듈을 불러서 사용할 때는 __name__ == "__main__"이 거짓이 되어 if문 다음 문장이 수행되지 않는다.  __name__ 변수란?파이썬의 __name__ 변수는 파이썬이 내부적으로 사용하는 특별한 변수 이름이다.만약 C:\doit>python mod1.py처럼 직접 mod1.py 파일을 실행할 경우 mod1.py의 __name__ 변수에는 __main__ 값이 저장된다. 하지만 파이썬 셸이나 다른 파이썬 모듈에서 mod1을 import 할 경우에는 mod1.py의 __name__ 변수에는 mod1.py의 모듈 이름 값 mod1이 저장된다. 2. PYTHONPATH 환경 변수 사용하기모듈을 불러와서 사용하는 또 다른 방법으로는 PYTHONPATH 환경 변수를 사용하는 방법이 있다.다음과 같이 따라 해 보자.<jupyter_code>C:\doit>set PYTHONPATH=C:\doit\mymod
C:\doit>python
>>> import mod2
>>> print(mod2.add(3,4))
7<jupyter_output><empty_output><jupyter_text>패키지란 무엇인가?  pickle<jupyter_code>>>> import pickle
>>> f = open("test.txt", 'wb')
>>> data = {1: 'python', 2: 'you need'}
>>> pickle.dump(data, f)
>>> f.close()
# 다음은 pickle.dump로 저장한 파일을 pickle.load를 사용해서 원래 있던 딕셔너리 객체(data) 상태 그대로 불러오는 예이다.

>>> import pickle
>>> f = open("test.txt", 'rb')
>>> data = pickle.load(f)
>>> print(data)
{2:'you need', 1:'python'}<jupyter_output><empty_output><jupyter_text>OS OS 모듈은 환경 변수나 디렉터리, 파일 등의 OS 자원을 제어할 수 있게 해주는 모듈이다.  shutilshutil은 파일을 복사해 주는 파이썬 모듈이다.다음 예시는 src라는 이름의 파일을 dst로 복사한다. 만약 dst가 디렉터리 이름이라면 src라는 파일 이름으로 dst 디렉터리에 복사하고 동일한 파일 이름이 있을 경우에는 덮어쓴다.import shutil   shutil.copy("src.txt", "dst.txt")   위 예를 실행해 보면 src.txt 파일과 동일한 내용의 파일이 dst.txt로 복사되는 것을 확인할 수 있다.  glob   가끔 파일을 읽고 쓰는 기능이 있는 프로그램을 만들다 보면 특정 디렉터리에 있는 파일 이름 모두를 알아야 할 때가 있다. 이럴 때 사용하는 모듈이 바로 glob이다.   디렉터리에 있는 파일들을 리스트로 만들기 - glob(pathname)   glob 모듈은 디렉터리 안의 파일들을 읽어서 돌려준다. *, ? 등 메타 문자를 써서 원하는 파일만 읽어 들일 수도 있다.   다음은 C:/doit 디렉터리에 있는 파일 중 이름이 mark로 시작하는 파일을 모두 찾아서 읽어들이는 예이다.   import glob   glob.glob("c:/doit/mark*")   ['c:/doit\\marks1.py', 'c:/doit\\marks2.py', 'c:/doit\\marks3.py'] 추가 라이브러리 = https://wikidocs.net/33  ***random random은 난수(규칙이 없는 임의의 수)를 발생시키는 모듈이다. random과 randint에 대해 알아보자.<jupyter_code>import random
random.random()

# 0.0에서 1.0 사이의 실수 중에서 난수 값을 돌려준다.
random.randint(1, 10)
random.randint(1, 55)
# 1과 10 사이에서 난수 값.
# 1과 55<jupyter_output><empty_output><jupyter_text>randrange 0이상 2미만 수 중 임의로 출력<jupyter_code>import random

print(random.randrange(0,2))

# 0이상 2미만 수 중 임의로 출력
# 예제

import random

def random_pop(data):
    
    number = random.randint(0, len(data)-1)
    return data.pop(number)


if __name__ == "__main__":
    data = [1,2,3,4,5]
    while data:
        print(random_pop(data))
data=[1,2,3,4,5]
random.shuffle(data)
data<jupyter_output><empty_output><jupyter_text>기타  모듈, 함수 불러오는 법<jupyter_code>import user.cal # user= 폴더, cal 모듈

from user.cal import plus # 함수/변수 사용시.를 써주지 않아도 된다. plus=함수
#예시

from random import randrange


import math



var1 = randrange(1,11) # random. 을 쓸 필요가 없다.

var2 = math.log(72**5184)<jupyter_output><empty_output><jupyter_text>urllib (python)<jupyter_code># crawling

from urllib.request import urlopen


webpage = urlopen('https://en.wikipedia.org/wiki/Lorem_ipsum').read().decode('utf-8')


print(webpage)<jupyter_output><!DOCTYPE html>
<html class="client-nojs" lang="en" dir="ltr">
<head>
<meta charset="UTF-8"/>
<title>Lorem ipsum - Wikipedia</title>
<script>document.documentElement.className="client-js";RLCONF={"wgBreakFrames":!1,"wgSeparatorTransformTable":["",""],"wgDigitTransformTable":["",""],"wgDefaultDateFormat":"dmy","wgMonthNames":["","January","February","March","April","May","June","July","August","September","October","November","December"],"wgRequestId":"25d3c6d4-5436-42f2-9f05-7efe065d82f2","wgCSPNonce":!1,"wgCanonicalNamespace":"","wgCanonicalSpecialPageName":!1,"wgNamespaceNumber":0,"wgPageName":"Lorem_ipsum","wgTitle":"Lorem ipsum","wgCurRevisionId":1053152702,"wgRevisionId":1053152702,"wgArticleId":190246,"wgIsArticle":!0,"wgIsRedirect":!1,"wgAction":"view","wgUserName":null,"wgUserGroups":["*"],"wgCategories":["CS1 maint: unfit URL","CS1 Latin-language sources (la)","Articles with short description","Short description is different from Wikidata","Articles containing Latin-language t[...]<jupyter_text>배열의 기초(size,shape,dim)<jupyter_code>import numpy as np

print("2차원 array")
#1부터 15까지 들어있는 (3,5)짜리 배열을 만듭니다.
matrix = np.array(range(1,16))
matrix.shape = 3,5
print(matrix)


# 1. matrix의 자료형을 출력해보세요.

print(type(matrix))


# 2. matrix의 차원을 출력해보세요.


matrix.ndim


# 3. matrix의 모양을 출력해보세요.

matrix.shape


# 4. matrix의 크기를 출력해보세요.

matrix.size


# 5. matrix의 dtype(data type)을 출력해보세요.


matrix.dtype


# 6. matrix의 dtype을 str로 변경하여 출력해보세요.


print(str(matrix))


# 7. matrix의 (2,3) 인덱스의 요소를 출력해보세요.

print(matrix[2,3])

# 8. matrix의 행은 인덱스 0부터 인덱스 1까지, 열은 인덱스 1부터 인덱스 3까지 출력해보세요.

print(matrix[0:2,1:4])<jupyter_output><empty_output><jupyter_text>인덱싱, 슬라이싱, 팬시, 불린<jupyter_code>import numpy as np

matrix = np.arange(1, 13, 1).reshape(3, 4)
print(matrix)

# 1. Indexing을 통해 값 2를 출력해보세요.
answer1 = matrix[0,1]

# 2. Slicing을 통해 매트릭스 일부인 9, 10을 가져와 출력해보세요.
answer2 = matrix[2,:2]

# 3. Boolean indexing을 통해 5보다 작은 수를 찾아 출력해보세요.
answer3 = matrix[matrix<5]

# 4. Fancy indexing을 통해 두 번째 행만 추출하여 출력해보세요.
answer4 = matrix[[1]]

# 위에서 구한 정답을 출력해봅시다.
print(answer1)
print(answer2)
print(answer3)
print(answer4)<jupyter_output><empty_output><jupyter_text>ord ord — ord(c)는 문자의 유니코드 값을 돌려주는 함수이다  random choice<jupyter_code>choices = np.random.choice(ids, len(x_train_pos)) # ids에서 x_train_pos 값만큼 뽑기<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.1399462182327766, 'fraction_numerical': 0.029163352649320153, 'mean_word_length': 4.189465408805032, 'pattern_counts': {'":': 23, '<': 382, '<?xml version=': 0, '>': 423, 'https://': 3, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 2, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '95', 'dir': 'jupyter-structured-clean-dedup', 'id': '537806', 'license': 'MIT', 'n_tokens_mistral': 16603, 'n_tokens_neox': 19268, 'n_words': 2982, 'path': '.ipynb_checkpoints/HowtousePython-checkpoint.ipynb', 'repo_name': 'HayeonKimm/HowToUse_X', 'size': '26403'}