o STACK
- Fist In Last Out 구조임
 

Stack=[]

Stack.append(5)
      .pop() --> 제일 오른쪽(뒤에) 삭제
      .remove(3) -> 왼쪽부터 시작해서 첫 3을 삭제
 
print(Stack[::-1]) --> 최상위단 즉 최근 입력된(first in)에 대한 출력
 
 
o QUEUE
- FIFO 구조
 
from collections import deque
 
q=deque()
 
q.append(3)
q.popleft() --> FIFO라서 왼쪽부터
q.pop() ==> q.popright()라는 의미임
q.reverse()

o sum, min, max, eval, sorted

 
arr=[1,2,3,4]
 
sum(arr)=10
min(arr)=1
max(arr)=4
eval("3+4+5")=12     
sorted(a)
sorted(arr, reverse=True)
sorted(arr, key=lambda x:x[], reverse=True)
a.count(str, start, end)
->a.count('k', 2, 5)
 
o import math
최대 공약수, 최소 공배수
math.gcd(arr)
math.lcm(arr)
 
o len(arr)=4

o 기본 입출력

input()
map(int, input().split()) or list(map(int, input().split()))
 
o if 
- res = 'success' if score >=90 else 'fail'
- if 0<x<20 ==> 가능함
 
o continue, break, pass
continue : 해당 loop 처음 부터 or 나머지 loop skip
break : 해당 loop out!
pass : just pass ==> else: 이후 사용 많이 함 (문법상으로)
 
o local, global 변수
 
def 함수안에서는 local이지만, 굳이 사용하고 싶으면
global count
--> 이런 식으로 사용함
 
o 함수 만들기 
def func():
  return a+b
==> 여러개 리턴값도 가능함.
==> 전역변수는 global cnt 이렇게 global로 붙여 사용함. 그냥 넣으면 지역변수 됨
 
o lambda
 
lambda x : x+1
lambda a,b : a+b
 
o arr[시작, 끝, 증/감]
 

arr=[1,2,3,4,5]

print(arr[-1])=5

print(arr[:-1])=1,2,3,4

print(arr[::-1])=5,4,3,2,1

 
o recursive
def recursive_func(a,b):
   if a < b
return recursive_func(a+1,b)
   else
      return
==> Recursive의 크기 증량
 
import sys
sys.setrecursionlimit(10**7)
 
o Ascii -> Integer (아스키 코드 -> 정수)
print( ord('a') ) = 97
print( chr(97) ) = 'a'
a~z => 97~123
 
o 알파벳, 숫자 확인
: return 값은 True/False
a.isalpha()
a.isdigit()
==> only alphabet or digit 이어야만 함 (띄어쓰기, 특수문자도 안됨)
 
a.isalnum() --> alphabet and digit 이어야만 함 (띄어쓰기, 특수문자도 안됨)
a.isdecimal() --> 양수만 가능, 나누기, 1,2, 이런거 안됨. 0, 제곱승은 가능
 
o abs
: 절대값
 
o 대소 변환/확인
- 변환
str.upper()
str.lower()
 
- 확인
str.isupper()
str.islower()
==> 모든 문자가 대/소이어야만 함. 특수문자 사이띄기 안됨
 
o 문자열 뒤집기
1) for
2) reverse
3) [ : : -1]
 
name='12345abc'
1) for -> skip
2) reverse
name_list=list(name)
name_list.reverse()
or
name_list=' '.join(name_list)
 
3) 배열로
name[시작 : 끝 : 규칙]
name=str(12345)
name1=name[ : : -1] --> 54321
name2=name[ : : 2] --> 135
name3=name[ : : -3] --> 52
 
o list 값 추가
a=([1,2,3,[4,5]])
a[3]=append(98,99)
--> [1,2,3,[4,5,98,99]]
 
o find(char, start, end)  ==> return값은 왼쪽부터 몇번째 index를 반환, 없으면 -1, str만 해당 (int, float 등은 안됨)
str = 'abcd blog'
res1=str.find('a')
res2=str.find('1',5,11)
res3=str.strip() --> 공백 지우기
res4=str.lstrip() --> 왼쪽 공백 지우기
res5=str.rstrip() --> 오른쪽 공백 지우기
 
res0=str.replace(" ",'') 공백 지우기
 
str.replace(old, new)
 
o sort, sorted
 
a.sort(reverse=True)
a1=sorted(a, keys, reverse=True)
 
ofilter(func, iterator)
->return은 T/F
-> filter는 fuction조건으로 filtering하고 list로 저장
ex) 
res = list(filter(lambda n:n>0, arr)
res2 = list(filter(is_even, range(1,11))
==> lambda를 쓰는 경우 더 효율적임
 
 
o print관련
"Hello 'world'"
==> print(" \"Hello \'world\'\"")
'와 "를 print할때는 \를 꼭 앞에 넣는다.
 
end=" ", end="", end=','
print("abc", sep='*)
--> a*b*c
 
 
o range(최소, 최대, 규칙)
range(5) -> 0,1,2,3,4,5
range(3,7) -> 3,4,5,6
range(2,12,3) -> 2,5,8,11
 
o split 문자열 나누기
str.split(구분자, maxsplite=반복횟수)
 
o bool
 
return 1 -> True
return 0 -> False
return -1 -> True
 
o string Method
1) count
2) find, rfind
3) upper, lower, swapcase
4) capitalize, title
5) lstrip, rstrip, strip
6) replace
7) 문자열 자르기
 
1) str.count(str, start, end)
str.count('a',1,11)
1~11까지 'a'의 개수
 
2) str.find(str,start, end)
str.find('a',2,12)
==> 문자가 없으면 -1, 처음 찾은 'a'의 index값
 
str.rfind(str, start, end)
맨오른쪽(마지막)에 찾은 문자열의 index값
 
3) str.upper()
  str.lower()
  str.swapcase()
 
모든 문자를 대문자, 소문자, 대소바꾸기로 변경
 
4) str.capitalize() : 문장이 첫 문자만 대문자
   str.title() : 띄어쓰기 구간의 첫문자가 대문자
 
5) rstrip, lstrip, strip
str.strip() -> 띄어쓰기 제거
str.rstrip() -> 왼쪽 띄어쓰기 제거
str.lstrip() -> 오른쪽 띄어쓰기 제거
 
6) replace
str.replace(old, new, count)
old 문자를 new 문자로 count만큼 변경
 
7) 문자열 자르기
str[start:end:rule]
 
 
o 값 변환
a=hex(int)
 
print(hex(10)) => 0xA
print(oct(10)) => 0o12
print(bin(10)) => 0b1010
 
c=int(a,b) --> b진수 형태의 a 값은? 
ex) print(int(A,16)) = 10 
mutable 변경 가능한 값
-> list, set, dict
immutable 변경 불가능한 값 
-> str, int, float, type
 
o 리스트 자료형
- 초기화 [ , , ]
- list() or list[]
- index는 0부터
- indexing 양의 정수 + -> 왼쪽 부터
            음의 정수 - -> 오른쪽 부터
 
ex) a = [1,2,3,4,5,6,7]
a[3]=4, a[-1]=7, a[1:3]=(2,3)
 
o 배열 초기화
1차원 n, arr[] => arr=[0]*(n+1)
2차원 n*m, arr[][] => arr=[[0]*m for _ in range(n)]
 
o 리스트 추가
a.append(c)
a,sort(reverse=True)
a.reverse
a.remove('a') ==> 리턴값은 가까운 index
a.count('a') ==> 'a'의 개수 
 
a.add(c)
a.update(c)
a.index('a') ==> 리턴값은 가까운 index
 
- list를 문자열로
arr=['a','b',1,2]
str1=' '.join(arr) -> a b 1 2
str2='\'.join(arr) -> a/b/1/2
 
if arr1=['a','b',1,2,3]
   str3=' '.join(str(s) for s in arr1)
==> 모든 값을 스트링으로
 
- list 합치기
1) +
2) extend 
3) sum
 
1) + 
a+b
2) extend
a=extend(b) -> a+b
b=extend(a) -> b+a
3) sum
k=[[1,2],[3,4]],[5,6]]
sum(k, []) = [1,2,3,4,5,6]
 
o tuple 자료형
- list와 유사
- 내부 변수는 변경 안됨
- list=[], tuple=()
- 값에따라...
 tuple=()
 tuple=(5,) --> 하나면 꼭 뒤에 ,를 넣는다
 tuple=(3,4,5)
- 중복 안됨
 
==> list에 비해 공간 효율적이나, 기능이 제한됨
==> 최단 경로 찾을 때, Tuple 사용 ( Memory 최적화시, Hashing Key 사용시)
 
- tuple 관리
1) indexing --> 출력때 사용
tuple(start : end: rule)
2) len(tuple) : 길이
3) t1+t2
4) t1*2
   t1*10
5) if 'a' in tuple
6) t.count('a')
7) 괄호 생략 가능 ({ })
 a=3,4,5
8) 값을 swap
a1, a2 = (1,2)
b2, b1=a1, a2 =(2,1)
9) type 변환
a1 ={'kim : 1','lee: 2','park:3}
 
t1= tuple(d1)
->('kim,'lee','park')
t2=tuple(d1.values)
-> (1,2,3) 
 
 
 
o dict 자료형
: key와 value로 구성되어 있음 {'사과':'Apple', '바나나':'Banana'}
dict={key:value}
data= dict()으로 먼저 선언
 
key_list=data.keys()
value_list=data.values()
 
dict.items()
dict.keys()
dict.values()
 
- dict value로 정렬하기 
key=lambda item : item[0]
sorted_dict=sorted(my_dict.items())
==>
=sorted(my_dict.items(), key=lambda item : item[0], reverse=True)
 
*key는 sorted(dict.keys())로 가능함
 
==> key는 중복이 안되므로 신중하게! ex) score의 경우, key에 이름을 넣어야함. 점수를 넣으면 안됨
 
- del dict['a'] => 'a' key와 value값 모두 페어로 지움 
 
 
o Set(집합) 자료형
- 중복 허용 x
- set() or set{()}
- list, tuple의 index값이 사용안됨
-> 중복이 안되는 장점에 list를 set으로 바꾸면 중복 없어짐......
a=[1,2,2,3,4,5,5,7,7,7]
set(a)=>(1,2,3,4,5,7)
 
1) 교집합
print(a1&a2) 
2) 합집합
print(a|b)
3) 차집합
print(a1-a2)
4) 집합이 같은지
a1.isdisjoint(a2)
5) 부분집합여부
a1=issubset(a2)
 
- set 관련 함수
1) s.add('ab')
2) s.update(val) --> val을 배열로 만들어 한번에 처리 가능
3) s.remove('a') -> 리턴은 'a'가 있으면 삭제, 없으면 오류!!!!
4) s.discard(3) --> 리턴값은 3이 있으면 삭제 없으면 no action!!
5) s.pop() ->오른쪽부터 사라짐
  s.popleft() -> 왼쪽부터 사라짐
6) s.clear() -> 모두 사라짐
7) in : 내부 요소 확인
if 1 in str:
8) 
set(a1) -> 중복 제거
tuple(a1) -> 다시 tuple 형으로
 
 

o Big O Notation

 
o 자료형
- 정수, 실수, 복소수형, 문자열, list, tuple, dict
 
o 주석
#
"""
"""
 
o INF = 10의9승 = 10e9 (무한)
 
o round(9,8765, 2) = 9.88 (2자리 반올림)
 
o 수 자료형
a/b -> 실수
a//b -> 몫
a%b -> 나머지
a**b -> 거듭제곱
 
코드업 풀때 repl it을 함께 사용하여 푸는 것이 매우 효율적이다.
 
 

https://replit.com/

 
 
 
답은 하기 참고..

+ Recent posts