728x90
반응형

추가

- 딕셔너리는 키-값 쌍의 형태를 지닌 자료구조이다.

- 먼저 딕셔너리에서 가장 중요한 메서드 2개는 다음과 같다.

- setdefault : 키-값 쌍 추가(수정은 불가)
- update : 키-값 수정/추가(괄호 안에 들어가는 건 키가 문자열일때만 가능, 아닐 때는 전체 딕셔너리를 넣어야 함) 
# setdefault 메서드 -> 새로운 키-값 추가

x = {'a' : 10, 'b' : 20, 'c' : 30, 'd' : 40}
x.setdefault('e')		# 키만 추가
print(x)				# {'a': 10, 'b': 20, 'c': 30, 'd': 40, 'e': None}

x.setdefault('f', 100)	# 키와 값 추가
print(x)				# {'a': 10, 'b': 20, 'c': 30, 'd': 40, 'e': None, 'f': 100}


# update 메서드 -> 기존의 값 수정, 없으면 키-값 쌍 추가.
x = {'a' : 10, 'b' : 20, 'c' : 30, 'd' : 40}
x.update(a = 90)		# 키 a의 값을 90으로 변경
print(x)				# {'a': 90, 'b': 20, 'c': 30, 'd': 40}

x.update(e = 90)		# 없으면 키-값 추가
print(x)				# {'a': 90, 'b': 20, 'c': 30, 'd': 40, 'e': 90}

x.update(a = 900, f = 60)	# 여러 개를 한 번에 수정/추가할 수도 있음.
print(x)				# {'a': 900, 'b': 20, 'c': 30, 'd': 40, 'e': 90, 'f': 60}

 

- 여기서 주의할 점은, setdefault 메서드로는 수정이 불가능하며, update 메서드는 키의 형식이 문자열일 때만 괄호 안에 넣을 수 있다는 것이다. (그래서 괄호 안에 넣을 때 작은따옴표를 붙이지 않음.)

 

- 그래서 만약 키의 형식이 문자열이 아니라면, 다음과 같은 방법을 사용해야 한다.

# 1. 괄호 안에 딕셔너리를 넣기
y = {1 : 'one', 2 : 'two'}
y.update({1 : 'ONE', 3 : 'THREE'})	# 이처럼 딕셔너리를 update 메서드 안에 직접 넣는다.
print(y)					# {1: 'ONE', 2: 'two', 3: 'THREE'}

# 2. 리스트와 튜플 이용하기
# 리스트 -> [[key1, val1], [key2, val2]] 형식으로 [[키, 값], [키, 값]] 처럼 넣어줌.
# 튜플도 마찬가지이다.
y = {1 : 'one', 2 : 'two'}
y.update([[2 , 'TWO'], [4, 'FOUR']])
print(y)					# {1: 'one', 2: 'TWO', 4: 'FOUR'}

# 3. zip 객체와 같이 키-값 쌍으로 된 반복 가능한 객체
y = {1 : 'one', 2 : 'two'}
y.update(zip([1, 2], ['ONE', 'TWO']))
print(y)					# {1: 'ONE', 2: 'TWO'}

 


삭제

- 딕셔너리에서 키-값 쌍을 삭제하는 메서드는 다음 종류가 있다.

- pop 메서드 : 딕셔너리_이름.pop(키) 형태로 사용, 특정 키-값 쌍을 삭제한 뒤 그 값을 반환함.

- del 메서드 : del 딕셔너리_이름[키] 형태로 사용, 딕셔너리의 특정 키-값을 삭제함.

- popitem() 메서드 : 임의의 키-값 쌍을 삭제, 그 키-값 쌍을 반환함. pop메서드는 값만을 반환하지만 이 메서드는 키-값쌍을 튜플로 반환함.

- clear() 메서드 : 딕셔너리의 모든 키-값 쌍을 삭제함.

 

# pop 메서드
x = {'one' : 1, 'two' : 2, 'three' : 3}
x.pop('one')					# 1
print(x)						# {'two': 2, 'three': 3}

- ** 만약 내가 없애고자 한 키가 그 딕셔너리에 없을 경우, 오류가 난다. (리스트에서 범위 밖의 인덱스를 지정한 것과 비슷한 맥락으로 이해하면 될 것 같다)

- 이때 pop 메서드 안에 기본값을 지정해 주면 키가 없을 경우 기본값을 반환한다.

pop 기본값 지정

# del 메서드
x = {'one' : 1, 'two' : 2, 'three' : 3}
del x['one']
print(x)					# {'two': 2, 'three': 3}

- 또한 마찬가지로 del도 존재하지 않는 키를 입력하면 오류가 난다. 

del 키 오류

 


가져오기

- get() 메서드 : 딕셔너리에서 특정 키의 값을 가져온다.

- items() 메서드 : 딕셔너리의 키-값 쌍을 '모두' 가져온다.

- keys() 메서드 : 딕셔너리의 키를 '모두' 가져온다.

- values() 메서드 : 딕셔너리의 값을 '모두' 가져온다.

- items, keys, values 메서드는 for 반복문과 조합해서 사용한다고 한다.

# get 메서드
x = {'one' : 1, 'two' : 2, 'three' : 3}
x.get('one')					# 1

# 이렇게 할 수도 있다.
x['one']						# 1

- 여기서도 pop메서드처럼 기본값을 설정하면, 만약 키가 없을 경우 기본값을 반환한다.

# items 메서드
x = {'one' : 1, 'two' : 2, 'three' : 3, 'four' : 4}
x.items()					# dict_items([('one', 1), ('two', 2), ('three', 3), ('four', 4)])

# keys 메서드
x.keys()					# dict_keys(['one', 'two', 'three', 'four'])

# values 메서드
x.values()					# dict_values([1, 2, 3, 4])

- 혹시나 해서 각 메서드들의 반환값의 표현형을 type() 메서드를 이용해 봤는데 다음과 같다.

 


만들기

- 리스트/튜플로도 딕셔너리를 만들 수 있다.

- dict.fromkeys() 메서드를 이용해 키 리스트로 딕셔너리를 만들 수 있다.

- 이때, 값을 지정하지 않으면 값은 모두 None이 된다.

# 리스트로 딕셔너리 만들기
keys = ['one', 'two', 'three', 'four']
x = dict.fromkeys(keys)
print(x)					# {'one': None, 'two': None, 'three': None, 'four': None}


# 값을 지정했을 때
x = dict.fromkeys(keys, 100)
print(x)					# {'one': 100, 'two': 100, 'three': 100, 'four': 100}

 


반복문 이용하기

- for 반복문 이용하기

# 모든 키 출력하기
x = {'one' : 1, 'two' : 2, 'three' : 3, 'four' : 4}
for i in x:
	print(i, end = ' ')
							# one two three four , 키만 출력됨.

# 키와 값 모두 출력하기
for key, value in x.items():
	print(key, value)
    						# one 1
                            # two 2
                            # three 3
                            # four 4

# 같은 방법으로, 키만 출력하기
for key in x.keys():
	print(key, end = ' ')	# one two three four 


# 값만 출력하기
for value in x.values():
	print(value, end = ' ')	# 1 2 3 4

 


딕셔너리 표현식

- 이 부분은 아직 이해가 필요해 이후에 추가하도록 하겠다.

728x90
반응형
LIST
728x90
반응형

- 문자열 일부 바꾸기

- s.replace('arr1', 'arr2')로 사용.
word = 'python is great'
word.replace('python', 'c')
print(word) 				#c is great

- 만약 문자열이 일치하지 않는 경우 -> 

word.replace('bython', 'c')
print(word)			# python is great

=> 바꿀 문자를 찾지 못하고 그대로 출력된다.

응용 => 문자열 A가 있을시에 A를 문자열 B로 바꾸는 프로그램을 만들 때 A가 있는지부터 검사할 필요 없이 바로. replace('A', 'B') 하면 된다.

 


 

- 문자 바꾸기

- translate(str.maketrans('aeiou', '12345'))으로 사용.
- table = str.maketrans('aeiou', '12345')), apple.translate(table) 으로도 사용 가능.
word = 'python is great'
word.translate(str.maketrans('pt', '12'))
print(word)		# 1y2hon is grea2

 


 

- 문자열 분리하기

'arr1'.split() 사용

# 그냥 빈칸만 있을 때 구분
'apple pear grape pineapple orange'.split()
# ['apple', 'pear', ..., 'orange']

# 컴마도 있을 때 구분
'apple, pear, grape, pineappple, orange'.split(', ')
# ['apple, 'pear', ..., 'orange']

 

- 문자열 연결하기

'문자열 사이 들어갈문자'.join(['arr1', 'arr2', ...]) 형태로 사용.

# 그냥 문자열을 합칠 때
' '.join(['apple', 'pear', 'grape', 'pineapple', 'orange'])
# 'apple pear grape pineapple orange'

# 문자열 사이에 특정 문자를 넣을 때
'-'.join(['apple', ..., 'orange'])
# 'apple-pear-grape-pineapple-orange'

 


- 소문자 -> 대문자 (모든 소문자는 대문자로, 대문자는 그대로)

.upper() 사용

'python'.upper()
# PYTHON

- 대문자 -> 소문자  (위의 규칙과 동일)

.lower() 사용

'PYTHON'.lower()
# python

 


 

- 좌우 특정 문자 삭제하기

# 문자 왼쪽에 있는 특정 문자 삭제
'     python     '.lstrip()
# 'python     ', 왼쪽 공백만 삭제

# 문자 오른쪽 삭제
'     python     '.rstrip()
# '     python', 오른쪽 공백만 삭제

# 양쪽 문자 삭제
'     python     '.strip()
# 'python', 양쪽 공백 삭제

# 괄호 안에 특정 문자 넣어주면 해당 문자 삭제
# '문자열1'.strip(',.') 이면
# 문자열 양쪽에서 ','와 '.' 문자 삭제

 


 

- 문자열 정렬하기

ljust(길이) -> 좌측 정렬, 남는 공간 공백으로, 만약 길이가 현재 문자열 길이보다 짧으면 실행 x

rjust(길이) -> 우측 정렬

center(길이) -> 가운데 정렬, 남는 공백 길이가 홀수면 왼쪽에 공백 한 칸이 더 들어감

# 우측정렬
'python'.rjust(10)
# '    python'

# 좌측정렬
'python'.ljust(10)
# 'python    '

# 가운데정렬
'python'.center(10)
# '  python  '

 


 

- 문자열 왼쪽에 0 채우기

zfill(길이) 형태로 사용

# 자릿수 앞에 0을 채워야 할 때
'35'.zfill(4)
# '0035'

# 그냥 문자열도 가능(당연하지만)
'hello'.zfill(10)
# '0000hello'

 


 

- 문자열 위치 찾기

특정 문자열의 인덱스를 찾을 때(왼쪽에서부터 찾음)

-> find('찾을 문자열')

오른쪽에서부터 찾을 때

-> rfind('찾을 문자열')

* 없을 시 -1 반환

 

또는

-> index('특정 문자열')

-> rindex('특정 문자열')

* 없을 시 에러 발생

 

- 문자열 개수 세기

count('특정 문자열')

 


 

- 문자열 만들기

1. 문자열 서식 지정자

2. 문자열 포메팅(f-string)

 

1 - 문자열 서식 지정자

# 문자열 넣기
'I am %s' % 'james'		# 'I am james'

# 숫자 넣기
'This watch is %d dollars'		# 'This watch is 5 dollars'

# 소숫점 표현하기
'%f' % 3.5			# '3.500000', 소숫점 이하 6자리까지 표현
'%.2f' % 3.5		# '3.50', .nf 형태 -> n자리까지 표현

# 문자열 정렬하기
'%10s' % 'python'	# '    python'

# 왼쪽 정렬
'%-10s' % 'python' 	# 'python    '

# 정수 자릿수 맞추기
'%5d' % 15			# '   15'
'%5d' % 100 		# '  100'

# 소숫점으로 자릿수와 소숫점 이하 자릿수 표현하기
'%10.2f' % 2000.3	# '   2000.30'

# 한 번에 여러 개 서식 지정자 사용하기
'Today is %d %s' % (3, 'April')		# 'Today is 3 April'

 

2 - 문자열 포매팅

 

- 서식 지정자보다 더 간단한 방법이라는 문자열 포매팅이다.

- {} 안에 포매팅을 지정하고, format메서드로 값을 넣는다.

'hello, {0}'.format('world!')		# 'hello, world!' 출력
# 이처럼 문자열 안에 {}을 넣고, 인덱스를 지정한다. 
# format()부분에는 {}부분에 넣을 값을 지정한다.

# 값 여러 개 넣기
'Hello, {0} {2} {1}'.format('Python', 'Script', 3.6)		# 'Hello, Python 3.6 Script'

'{0} {0} {1} {1}'.format('Python', 'Script')		# 'Python Python Script Script'

# 인덱스 생략 -> 지정한 순서대로 값이 들어감
'Hello, {} {} {}'.format('Python', 'Script', 3.6)	# 'Hello, Python Script 3.6'

# 또는 이름 지정 가능.
'Hello, {language} {version}'.format(language = 'Python', version = 3.6)	# 'Hello, Python 3.6'

# Python 3.6부터는 앞에 f를 붙이고 중괄호 안에 바로 변수 입력 가능
language = 'Python'
version = 3.6
print(f'Hello, {language} {version}')		# Hello, Python 3.6


# 문자열 정렬하기
print('{0:<10}'.format('Python'))		# Python

# '{인덱스 : 방향 길이}'.format() 형식으로 작성
# 인덱스는 없을 시 생략 가능

# 숫자 개수 맞추기
# 1. 서식 지정자
print('%03d' % 15)		# '015' ,  문자열로 나옴

# 2. format메서드
print('{:03d}'.format(15))		# 015, 정수로 나옴
# 실수
print('{0:08.2f}'.format(150.37))	# 00150.37


# 결론 : format은 '{인덱스 : 채우기 정렬 길이 .자릿수}'.format 형식으로 사용.
print('{:0<10}'.format(15))		# 1500000000


# 팁, 금액에서 천 단위로 ','을 넣는 것을 format함수를 이용해 할 수 있다.
print(format(1493500, ','))		# 1,493,500
728x90
반응형
LIST
728x90
반응형
  • 파일 입출력을 하기 위해서는 여러 방법이 있다.
  • 먼저, 가장 기본적인 open()을 이용한 방법이 있다. (open('이름', '용도')로 사용)
  • 같은 폴더 내에 'hello.txt'파일을 만든 후, 그 파일에 'hello, world!'를 쓰는 프로그램은 다음과 같다.
    file = open('hello.txt', 'w')
    file.write('hello, world!')
    file.close()​
  • 이때 file.close()를 해줘야 메모리가 낭비되지 않고, 사소한 실수가 중대한 피해로 이어지는 걸 막을 수 있다.
  • 'w'의 의미는 파일을 쓰는 용도로 열겠다는 뜻이다.
  • write()를 하게 되면 파일에 기존에 있던 내용은 삭제되고, 새로운 내용이 적힌다.
  • 이제 파일의 내용을 읽는 법을 알아보자.
  • file = open('hello.txt', 'r')
    s = file.read()
    print(s)
    file.close()
  • 마찬가지로 'hello.txt'에서 내용을 읽는 코드이다. 내용을 읽고 s에 저장한 다음, s를 출력하고 file을 닫는다.
  • 이때도 file.close()를 꼭 해줘야 한다.
  • 마지막으로 with as 구문을 살펴보자.
  • with~ as구문은 file.close를 해줄 필요 없이 자동으로 파일을 닫아줘서 실수를 예방할 수 있다.
    with open('hello.txt', 'w') as file:
        file.write('abcde')
    
    with open('hello.txt', 'r') as file:
        s = file.read()
        print(s)​
  • 다음 내용은 file에 'abcde'를 쓰고, 그걸 출력하는 코드이다.
  • with open('이름', '용도') as 변수: 형태로 사용하며, 마지막에 close()를 붙일 필요는 없다.

 

  • 클래스는 객체를 표현하기 위한 문법이다.
  • 먼저 클래스에서 사용할 수 있는 기초적인 속성과 메서드를 배웠다.
  • 메서드는 다음과 같이 만든다.
  • class Person:
    	def greeting(self):
        	print('hello')
            
    steve = Person()
    steve.greeting()				# 'hello'
  • 이때 주의해야 할 점은 들여쓰기와 메서드의 첫 번재 매개변수는 반드시 self로 지정해야 한다는 것이다.
  • 매우 중요하다고 한다.
  • 그리고 steve = Person()처럼 클래스를 사용하려면 클래스의 인스턴스를 생성해야 한다.
  • 이때 steve.greeting()처럼 인스턴스를 통해 호출하는 메서드를 인스턴스 메서드라고 한다.
  • 속성은 다음과 같이 쓴다.
  • class Person:
    	def __init__(self):
        	self.hello = '안녕하세요'
        
        def greeting(self):
        	print(self.hello)
            
    steve = Person()
    steve.greeting()		# '안녕하세요'
  • Person 클래스의 __init__메서드에서 self.hello에 '안녕하세요' 라는 인사말을 넣는다.
  • __init__메서드는 인스턴스를 만들 때 호출되는 특별한 메서드로, 인스턴스를 초기화한다.
  • 이처럼 앞뒤로 __이 붙은 메서드는 파이썬이 자동으로 호출해주는 '스페셜 메서드'이다.
  • __init__메서드 안에서 클래스의 속성을 만들 수 있다.

 

728x90
반응형
LIST
728x90
반응형
python 리스트 comprehension 표현식
  • arr = [i for i in range(10)]   ->   [0 1, 2, 3, 4, 5, 6, 7, 8, 9] 생성.
  • 이때 range대신 시퀀스 들어가도 가능.
  • 뒤에 if문 붙여서 [i for i in range(10) if i % 2 == 0] -> [0, 2, 4, 6, 8] 생성.
  • for문 여러 개 중첩 가능. 예) 2단 ~ 9단 리스트 만들 시 [i * j for i in range(2, 10) for j in range(1, 10)] 하면 i가 2부터 9까지 반복될 때 각각 j 가 1부터 9까지 반복됨. 인셉션처럼 갈수록 반복문이 깊어지는 것.
문자열 응용하기
  • .replace()
  • '문자열'. replace('원래 문자열', '나중 문자열') -> 원래 문자열에서 나중 문자열로 (부분 수정 가능) 바뀐 문자열 반환
  • 새롭게 바뀐 결과를 이용하려면 다시 변수에 저장 필요.
  • < 변수 이용 예시 >
  • .translate()
  • 문자열 안의 문자를 다른 문자로 치환. 
  • 1) table = str.maketrans('원래 문자', '새로운 문자')로 변환 테이블 생성
  • 2) translate(table)로 문자 바꿈
  • < translate 사용 예시 >
몰랐던 기능들
  • 이외에도 '문자열'.split()등을 통해 공백을 분리하거나
  • ' '. join('문자열 1', '문자열 2',...)을 통해 문자열 사이에 공백을 넣으며 문자열 연결 가능.
  • '문자열'.upper() -> 모두 대문자로 바꿈
  • '문자열'.lower() -> 모두 소문자로 바꿈
  • 공백 삭제 -> '문자열'.lstrip() -> 문자열 왼쪽에서 문자 삭제, rstrip() -> 오른쪽에서 삭제, strip() -> 양쪽에서 삭제
  • 이를 이용해 특정 문자 삭제도 가능.
  • < strip 함수 이용예시 >
백준 2869
 

2869번: 달팽이는 올라가고 싶다

첫째 줄에 세 정수 A, B, V가 공백으로 구분되어서 주어진다. (1 ≤ B < A ≤ V ≤ 1,000,000,000)

www.acmicpc.net

  • # 달팽이가 나무를 올라가는 데 며칠이 걸리는지 구하는 프로그램.
    # A, B, V가 첫줄에 입력, 며칠이 걸리는지를 출력.
    
    # 입력부
    a, b, v = list(map(int, input().split()))
    
    # 연산부
    # ver.2 ** while로 무지성 반복 돌리니 v = 1억일때 시간이 너무 걸림.
    # 최적화가 필요하다고 생각해 공식으로 다시 작성하니 훨씬 빠름.
    v -= a
    day = v // (a-b)
    if v / (a-b) > v// (a-b):
        day += 1
    day += 1
    # 출력부
    print(day)
  • 처음에는 while로 단순 반복으로 처리하려 했으나, 1억 번 반복에서 시간이 좀 걸렸고, 반복문이 아닌 공식이 있을 거라 생각해 다시 생각해보니 나눗셈과 나머지를 이용해 처리할 수 있던 문제였다.
  • 더 알게 된 점:
  • math.ceil함수를 통해 올림을 할 수 있고, 이를 이용해 식을 더 간단히 할 수 있다.

 

728x90
반응형
LIST
728x90
반응형
  • 몰랐던 기능들
  • ord()    -> 문자 => 아스키코드 변환
  • chrd()   -> 아스키코드 => 문자 변환
  • .isalpha() -> 알파벳으로만 구성되었는지 확인
  • find() 함수 -> index()와 동일한 기능. 대신 값이 없으면 -1을 반환하고(index는 ValueError뜸), index와는 다르게 리스트, 튜플에서 사용 불가. 문자열에서만 사용가능함. (https://ooyoung.tistory.com/78 참고함)

 

  • 주의할 점들
  • input = sys.stdin.readline().split() -> .split() 넣어줘야 뒤에 개행 문자 사라짐(안하고 str쓰려하면 개행문자 오류남)
  • 대신 sys.stdin.readline()은 무조건 리스트 안에 문자열이 들어감.
  • reversed()는 기존 변수는 그대로 두고 새로운 reversed객체를 만들어 거기에 시퀀스를 반대로 해 놓는다.
  • 객체로 나와 따로 리스트 등으로 변환해줘야함.
  • ** if - continue else~로 하지 말고 if not - if ~로 바로 가자. 그게 더 간결하다.

 

  • 알아두면 유용한 정보들
  • 아스키코드에서 'A' 는 65, 'a'는 97이다. 알파벳은 26개이므로 여기서 0~25를 더해서 쓰면 대소문자 전체를 표현할 수 있다.

 

** 백준 1316번

< 수정 전 >

여기서 if - :

              continue 를 할거면

그냥 != 일때 다음 if 문으로 들어가는 것이 낫다.

 

if - :

    continue

else:

----

 

 

if not -:

    if :

        ----

로 더 간결하게 쓸 수 있음을 기억하자.

< 수정 후>

 

728x90
반응형
LIST
728x90
반응형
  • 몰랐던 점들
  • arr.append(a) -> 가장 많이 쓰는 방법, 리스트에 a요소 하나를 추가할 때 사용.
  • arr.extend(arr_1) -> arr에 다른 리스트 추가함. 리스트에 리스트를 추가할 때 사용.
  • arr.insert(a, b) ->arr의 a 인덱스에 b를 추가함. 리스트 중간에 요소 하나를 추가할 때 사용.
  • ** 또는 arr[3:3] = [1, ..., 10]과 같이 슬라이싱을 이용해 리스트 중간에 리스트를 끼워 넣을 수 있음. 인덱스를 조작해 일부분을 대체하는 것도 가능.
  • *** arr[len(arr):] = [1, ..., 10] -> extend와 동일한 기능. 
  • -> 슬라이싱을 이용해 다양한 작업 가능.

 

  • 기타 다양한 기능들
  • arr.count(a) -> 리스트 안에 요소가 얼마나 들어있는지 개수를 세줌.
  • sorted(arr) -> 정렬된 새로운 리스트 생성. 기존의 리스트는 유지.
  • clear(arr) -> 리스트 내 모든 요소 삭제.
  • sum(arr) -> 리스트 내 모든 요소 합계
  • * if arr : -> 리스트 내 요소가 있는지 확인할때 사용. arr [-1] 같은 작업은 리스트에 요소가 없을 때 오류가 나므로 이를 방지하기 위함임.

 

  • 리스트의 할당과 복사
  • a = [1, ..., 10]
  • b = a                             #이러면 할당. 두 변수가 하나의 리스트 공유.
  • b = a.copy()                     #이러면 복사. 두 변수가 독립된 리스트를 사용.

 

  • 원하는 소숫점 아래 자릿수까지 표현하는 방법 f-string 형식 사용
  • print(f'{ans:.3f}'
  • 처럼 사용하면
  • 소수점 아래 3 자릿수까지 표현이 된다.
  • n자릿수까지 표현하고 싶다면
  • print(f'{var:.nf}'
  • 처럼 사용하면 된다.
728x90
반응형
LIST

+ Recent posts