둔필승총

Fragment는 Activity의 파트를 나눈것들이다. Activity가 너무 길어지면 관리 포인트가 많아 관리가 어려워지기 때문에 Fragment를 사용해서 나누어 해결한다. Activity가 라이프사이클이 있는 것처럼 Fragment도 라이프사이클이 있다. 

Fragment 사용방법
1. XML에 ViewComponent로 추가한다
2. 코드로(동적)으로 추가한다

Fragment를 만들기 위해서 class를 만들어 fragment()를 상속받아 준다. (Activity 만들때는 AppCompatActivity()를 상속받은 것처럼)

class FragmentOne:Fragment()

override method를 통해서 onAttach(), onCreate(), onCreateView(), onViewCreated(), onActivityCreated(), onStart(), onResume(), onPause(), onStop(), onDestroyView(), onDetach()를 만들어주었다.

xml에서 Fragment를 사용해서 넣어주면 된다.

<fragment
        android:id="@+id/fragment_one"
        android:name="com.example.myapplication.FragmentOne"
        android:layout_width="match_parent"
        android:layout_height="300dp"/>

id와 name을 꼭 넣어주어야 한다. name은 fragment태그에 들어갈 내용을 의미한다. FragmentOne 클래스를 넣어준다.

FragmentOne에서 List를 그려야 한다. LifeCycle중에서 onCreateView()를 이용해서 그린다. onCreateView()는 fragment가 interface를 처음으로 그릴때 호출된다. Activity는 setContentView가 책임졌다면 fragment는 onCreateView()가 책임진다.

override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View? {
        Log.d("life_cycle","F onCreateView")
        // fragment 가 인터페이스를 처음으로 그릴 때 호출된다.
        // inflater -> 뷰를 그려주는 역할
        // container -> 부모뷰 달라붙을 곳
        return inflater.inflate(R.layout.fragment_one,container,false)
    }

fragment는 setContentView와는 달리 inflater와 container가 들어온다. inflater는 뷰를 그려주는 역할, container는 부모뷰를 의미한다. inflater중에 inflate함수가 있다. xml으로 fragment_one을 만들고 붙여주면 된다.

이번엔 Fragment를 동적으로 추가해보자. 버튼을 눌러서 fragment를 달아주는 모습을 보여주자. Fragment를 동적으로 추가하기 위해서는 FragmentManager의 도움을 받아야한다. supportFragmentManager는 Activity가 가지고 있다. supportFragmentManager를 가지고 와서 FragmentManager에 넣어준다.

 Transaction이라는 것도 만들어주어야 한다. Transaction은 작업의 단위이고 시작과 끝이 있다. fragmentTransaction에서 beginTransaction()을 실행해주고 할일(replace/add)를 입력해준다. 끝은 commit()이라는 것으로 명령해준다.

	val fragmentOne:FragmentOne= FragmentOne()
	val button:Button=findViewById(R.id.button)
        button.setOnClickListener {
            // fragment를 동적으로 작동하는 방법 -> 코드 입력
            // fragment 붙이는 방법 replace/add
            val fragmentManager:FragmentManager = supportFragmentManager

            // Transaction
            // 작업의 단위 -> 시작과 끝이 있다
            val fragmentTransaction=fragmentManager.beginTransaction()
            fragmentTransaction.replace(R.id.container,fragmentOne)

            fragmentTransaction.commit()
            // 끝을 내는 방법
            // commit -> 시간 될 때 해
            // commitnow -> 지금 당장해
        }

Fragment를 떼는 방법

	val fragmentOne:FragmentOne= FragmentOne()
	val button2:Button=findViewById(R.id.button2)
        button2.setOnClickListener {
            // fragment remove/detach 하는 방법
            val fragmentManager:FragmentManager=supportFragmentManager
            val fragmentTransaction=fragmentManager.beginTransaction()
            fragmentTransaction.detach(fragmentOne)
            fragmentTransaction.commit()
        }

detach/remove : remove는 다시 붙일 수 있고 detach는 안됨.

Fragment에 data를 넣어주는 방법

데이터 전달 방법
- Activity -> Fragment : argument 와 bundle
- Fragment -> Activity : 자체 구현(리스너 구현)

budle이라는 것을 만들어서 Fragment에 끼워 넣어줘야 한다.

	// fragment 에 data 를 넣어주는 방법
        val bundle:Bundle = Bundle()
        bundle.putString("hello","hello")
        fragmentOne.arguments=bundle

(bundle은 type을 고려해주어야 한다)

putString 해주었으면 FragmentOne에서 꺼내주면 된다.

 override fun onActivityCreated(savedInstanceState: Bundle?) {
        Log.d("life_cycle","F onActivityCreated")
        val data = arguments?.getString("hello")
        // Log.d("data",data)
        super.onActivityCreated(savedInstanceState)
    }

Fragment -> Activity 데이터 전달은 리스너를 만들어서 구현한다.

    interface OnDataPassListener{
        fun onDataPass(data:String?)
    }
    lateinit var dataPassListener:OnDataPassListener
    override fun onAttach(context: Context) {
        super.onAttach(context)
        dataPassListener = context as OnDataPassListener
    }

override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        Log.d("life_cycle","F onViewCreated")
        super.onViewCreated(view, savedInstanceState)
        // Activity의 OnCreate에서 했던 작업을 여기에서 한다
        val pass:Button=findViewById(R.id.pass)
        pass.setOnClickListener {
            dataPassListener.onDataPass("Good Bye")
        }
    }

이렇게 하고 FragmentActivity에 달아주면 된다.

class FragmentActivity : AppCompatActivity(),FragmentOne.OnDataPassListener {

    override fun onDataPass(data: String?) {
        Log.d("pass",""+data)
    }

Intent 라는 단어의 사전적 의미는 의도, 요구, 의사 전달, 요청 이라는 뜻이다. 

안드로이드 앱 프로그래밍에서 Intent는 Activity와 Activity , Android System과 내 App(전화 ex.배달앱에서 전화바로 연결하는 것) , 다른 App과 내 App 연결(ex. 결제할 때 pay화면 연결) 할 때 사용한다. 예를 들어 버튼을 누르면 다른 새로운 화면(새로운 Activity)가 나오는 것을 intent로 처리를 할 수 있다. 요청의 종류에는 두 가지가 있다. 전달만 하는 요청이 있고 리턴을 받는 요청이 있다.

Intent는 지금 화면이 사라지고 새로운 화면을 불러오는 것이다. Intent를 코드 상으로 활용하려면 intent라는 클래스를 만들어주면 된다. 

var intent = Intent(this@Intent1, Intent2::class.java)

1. activity를 전환하려면 Intent에는 처음 변수에는 context(여기서는 Intent1), 두 번째 변수에는 이동할 대상 여기서는 Intent2가 된다.

- Context : context는 문맥을 의미한다. Activity가 가지고 있는 주변 정보라고 생각하면 된다. class가 가지고 있는 정보랑 유사하다. 여기서 this@Intent1이 아닌 this만 입력하여도 상관없다. 여기서는 가능하지만 다른 곳에서는 에러가 날 수 도 있으므로 context를 넣어야 하는 곳에는 this@(현재 Activity)를 넣어주자.

- ::class.java를 꼭 넣어줘야 Intent2라는 것을 알 수 있다.

2. Intent를 만들었으면 Intent를 보내야 한다. 만든 변수를 startActivity안에 넣어주자.

startActivity(intent)

Intent에 정보를 담아 보내는 방법 (Key, Value 방식으로 전달)

Intent1에서 보내주므로 Intent1에 putExtra를 해서 보내고, Intent2에서 getExtra함수를 통해 받으면 된다.

intent.putExtra("number",1)

val number1 = intent.getIntExtra("number1",0)

getIntExtra는 첫번째 파라미터는 찾는 key값, 두번째는 없을때 대비해서 default값을 넣어준다.

Intent2에 putExtra를 apply를 사용해 묶어서 사용할 수 있다.

intent2.apply
{
    this.putExtra("number1",1)
    this.putExtra("number2",2)
}

Intent2에서 Intent1으로 돌려보내기

1. Intent에 결과를 담는다.

val resultIntent= Intent()
resultIntent.putExtra("result",result)

setResult(Activity.RESULT_OK,resultIntent)

setResult에는 RESULT_OK랑 전달해줄 값을 순서대로 넣는다. RESULT_OK는 잘 전송한다는 뜻이다(숫자 적어주면 됨)

Activity를 종료하려면 finish()함수를 사용하면 된다. Intent2를 종료시켜 Intent1을 보여주면 된다.

2. Intent1에서 결과 받기

onActivityResult 함수를 override해준다. 

전달만 하는 요청은 startActivity()로 요청하고, 리턴을 받는 요청은 startActivityForResult이다.

startActivityForResult(intent2,200)

파라미터를 intent 넣어주고 requestcode를 넣어줘야 된다. Intent에 요청하는 것이 여러개 일수도 있기 때문에 구별하기 위해서 requestCode를 넣어준다. 이름을 숫자로 적어준다.

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {

        if(requestCode==200){
            Log.d("number",""+requestCode)
            Log.d("number",""+resultCode)
            var result = data?.getIntExtra("result",0)
            Log.d("number",""+result)
        }

        super.onActivityResult(requestCode, resultCode, data)
    }

https://www.acmicpc.net/problem/2178

[문제 풀이]

(1,1)에서 출발하여 (N,M)까지 가는 길 중 최소의 칸 수를 가야하는 길을 구해야 한다. 이 문제는 1인 영역만 일단 지나도록 설계한다. 1인 지역을 지나갈때 그 전의 지역의 graph 수에서 1을 추가해준다. 그렇게 하면 graph의 (N,M) 좌표를 출력하면 몇게의 길을 지나왔는지 알 수 있다. 나는 BFS를 통해 풀었다.

from collections import deque
n,m = map(int,input().split())
graph=[]
for i in range(n):
    graph.append(list(map(int,input())))
def bfs(a,b):
    q=deque()
    q.append((a,b))
    dx=[-1,1,0,0]
    dy=[0,0,1,-1]
    while q:
        x,y = q.popleft()
        for i in range(4):
            nx=x+dx[i]
            ny=y+dy[i]
            if nx>=0 and nx<n and ny>=0 and ny<m and graph[nx][ny]==1:
                q.append((nx,ny))
                graph[nx][ny]=graph[x][y]+1
bfs(0,0)
print(graph[n-1][m-1])

https://www.acmicpc.net/problem/10845

from collections import deque
import sys
input = sys.stdin.readline
q=deque()
n= int(input())
for i in range(n):
    question = input().split()
    if len(question)==2:
        order = question[0]
        number = int(question[1])
        q.append(number)
    else:
        if question[0]=='pop':
            if len(q)==0:
                print(-1)
            else:
                print(q.popleft())
        elif question[0]=='size':
            print(len(q))
        elif question[0]=='empty':
            if len(q)==0:
                print(1)
            else:print(0)
        elif question[0]=='front':
            if len(q)==0:
                print(-1)
            else:
                print(q[0])
        elif question[0]=='back':
            if len(q)==0:
                print(-1)
            else:
                print(q[-1])

기본적으로 큐를 구현하여 푸는 문제이다. 큐의 다양한 기능들을 조건문을 통하여 해결하였다.

https://www.acmicpc.net/problem/10866

import sys
input = sys.stdin.readline
from collections import deque

q=deque()
n=int(input())
for i in range(n):
    question = input().split()
    if len(question)==2:
        order=question[0]
        number=question[1]
        if order=='push_front':
            q.appendleft(number)
        elif order=='push_back':
            q.append(number)
    else:
        if question[0]=='pop_front':
            if q:
                print(q.popleft())
            else:
                print(-1)
        elif question[0]=='pop_back':
            if q:
                print(q.pop())
            else:
                print(-1)
        elif question[0]=='size':
            print(len(q))
        elif question[0]=='empty':
            if q:
                print(0)
            else:
                print(1)
        elif question[0]=='front':
            if q:
                print(q[0])
            else:
                print(-1)
        elif question[0]=='back':
            if q:
                print(q[-1])
            else:
                print(-1)

10845와 같이 deque를 사용하여서 문제를 해결하였다.

위에 두 문제에서 핵심은 input()대신 sys.stdin.readline()을 사용하여야 된다는 것이다.

반복문으로 여러줄을 입력 받아야 할 때 input()은 시간초과를 일으킬 수 있다.

# ) sys.stdin.readline()은 한줄 단위로 입력받기 때문에, enter가 같이 입력이된다.

# ) strip()은 문자열 맨 앞과 맨 끝의 공백문자를 제거한다.

https://www.acmicpc.net/problem/1406

[문제 풀이]

이 문제는 위에 두 문제와 비슷하다고 생각하고 쉽게 풀려고 했는데 잘 풀리지 않았다. 먼저 위에 두 문제처럼 풀었다.

from collections import deque
import sys
input = sys.stdin.readline
q=deque()
str = input()
for i in range(len(str)):
    q.append(str[i])
m=int(input())
cursor=len(q)
for i in range(m):
    question=input().split()
    if len(question)==2:
        number=question[1]
        q.insert(cursor,number)
        cursor+=1
    else:
        if question[0]=='L':
            if cursor!=0:
                cursor-=1
        elif question[0]=='D':
            if cursor!=len(q):
                cursor+=1
        elif question[0]=='B':
            if cursor!=0:
                q = list(q)
                q.pop(cursor-1)
                q=deque(q)
                cursor-=1
for i in range(len(q)):
    print(q[i],end='')

위에 방식대로 풀려고 했는데 시간초과, 런타임에러(TypeError)같은 에러가 계속 났다. 시간 초과를 해결하는 것이 이 문제의 핵심이라 생각했다. 문제를 보면 시간제한이 다른 문제보다 적다.

input도 sys.stdin.readline으로 바꿔도 보고, 내가 할 수 있는 일들을 해봤지만 시간초과는 계속 났다. 그리고 입력 부분을 다시 봤다.

내가 푼 방식으로는 문자열의 길이가 N일때 O(N)의 시간복잡도가 발생한다. 그렇다면 최악의 경우 100,000길이인 문자열을 500,000번 다루면 100,000 X 500,000 번의 연산이 필요하게 된다. M을 줄이기보다 문자열 통째로 연산하는 것을 부분적으로 할 수 있도록 줄여봐야 된다고 생각했다.

https://bnzn2426.tistory.com/112

여기서 많은 도움을 받게 되었다. 

두 개의 스택을 이용해 커서의 앞 부분과 커서의 뒷 부분을 구분하여 생각한다.

먼저 첫번째 스택에 모두 들어가고 두번째 스택은 비어있다. 만약 L을 입력받아 커서가 왼쪽으로 움직인다면 첫번째 스택은 pop을 통해 꺼내고 두번째 스택에 push되는 것이다. 

반대로 D를 입력받으면 첫번째 스택에 push, 두번째 스택에서 pop을 하는 것이다. 

from sys import stdin
input = stdin.readline
first = list(stdin.readline().strip())
second = []
m= int(input())
for i in range(m):
    question=input().split()
    if question[0]=='L':
        if first: #첫번째 스택이 존재할때 (없으면 더 왼쪽으로 커서가 못가니까)
            second.append(first.pop())
    elif question[0]=='D':
        if second:
            first.append(second.pop())
    elif question[0]=='B':
        if first:
            first.pop()
    elif question[0]=='P':
        first.append(question[1])
print("".join(first+list(reversed(second))))

https://www.acmicpc.net/problem/7569

문제

철수의 토마토 농장에서는 토마토를 보관하는 큰 창고를 가지고 있다. 토마토는 아래의 그림과 같이 격자모양 상자의 칸에 하나씩 넣은 다음, 상자들을 수직으로 쌓아 올려서 창고에 보관한다.

창고에 보관되는 토마토들 중에는 잘 익은 것도 있지만, 아직 익지 않은 토마토들도 있을 수 있다. 보관 후 하루가 지나면, 익은 토마토들의 인접한 곳에 있는 익지 않은 토마토들은 익은 토마토의 영향을 받아 익게 된다. 하나의 토마토에 인접한 곳은 위, 아래, 왼쪽, 오른쪽, 앞, 뒤 여섯 방향에 있는 토마토를 의미한다. 대각선 방향에 있는 토마토들에게는 영향을 주지 못하며, 토마토가 혼자 저절로 익는 경우는 없다고 가정한다. 철수는 창고에 보관된 토마토들이 며칠이 지나면 다 익게 되는지 그 최소 일수를 알고 싶어 한다.

토마토를 창고에 보관하는 격자모양의 상자들의 크기와 익은 토마토들과 익지 않은 토마토들의 정보가 주어졌을 때, 며칠이 지나면 토마토들이 모두 익는지, 그 최소 일수를 구하는 프로그램을 작성하라. 단, 상자의 일부 칸에는 토마토가 들어있지 않을 수도 있다.

입력

첫 줄에는 상자의 크기를 나타내는 두 정수 M,N과 쌓아올려지는 상자의 수를 나타내는 H가 주어진다. M은 상자의 가로 칸의 수, N은 상자의 세로 칸의 수를 나타낸다. 단, 2 ≤ M ≤ 100, 2 ≤ N ≤ 100, 1 ≤ H ≤ 100 이다. 둘째 줄부터는 가장 밑의 상자부터 가장 위의 상자까지에 저장된 토마토들의 정보가 주어진다. 즉, 둘째 줄부터 N개의 줄에는 하나의 상자에 담긴 토마토의 정보가 주어진다. 각 줄에는 상자 가로줄에 들어있는 토마토들의 상태가 M개의 정수로 주어진다. 정수 1은 익은 토마토, 정수 0 은 익지 않은 토마토, 정수 -1은 토마토가 들어있지 않은 칸을 나타낸다. 이러한 N개의 줄이 H번 반복하여 주어진다.

토마토가 하나 이상 있는 경우만 입력으로 주어진다.

출력

여러분은 토마토가 모두 익을 때까지 최소 며칠이 걸리는지를 계산해서 출력해야 한다. 만약, 저장될 때부터 모든 토마토가 익어있는 상태이면 0을 출력해야 하고, 토마토가 모두 익지는 못하는 상황이면 -1을 출력해야 한다.

예제 입력 1 

5 3 1
0 -1 0 0 0
-1 -1 0 1 1
0 0 0 1 1

예제 출력 1 

-1

예제 입력 2 

5 3 2
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 1 0 0
0 0 0 0 0

예제 출력 2 

4

예제 입력 3 

4 3 2
1 1 1 1
1 1 1 1
1 1 1 1
1 1 1 1
-1 -1 -1 -1
1 1 1 -1

예제 출력 3 

0

[문제 풀이]

먼저 이전에 풀었던 토마토 2차원 문제에서 이 문제는 3차원 문제로 업그레이드 되었다. 3차원 배열을 입력받는 부분은 예제의 입력에서 힌트를 얻었다. h만큼 덩어리가 생기므로 m은 list로 해서 입력받고 그 입력 받은 리스트를 range(n)으로 for문 한 번, range(h)로 for문 한 번 사용해서 입력받는다. (입력받은걸 확인하기 위해 매번 print()사용한다..)

데큐를 사용해서 bfs를 이용하겠다. 일단 익은 것들이 하루에 다른 덜익은 토마토를 익히는 건 범위의 한계가 있다. 하루에 상하좌우해서 1칸씩 밖에 안된다. 우리가 원래 사용하던 bfs를 변형시키면 된다. 

먼저 처음에 주어진 토마토 박스에서 익은 것들을 q에 저장해준다.(q는 deque()로 만든 것이다) 그리고 q에 들어간 값들의 개수를 count에 저장한다. (count=len(q)) 그리고 dx,dy,dz를 count만큼만 해주면 그날 하루하루 익은 것들만 0에서 1로 바꿀 수 있다.

나머지 조건들도 (처음부터 다익은 경우, 시간이 아무리 지나도 안익는 것 존재하는 경우)들도 처리해준다.

from collections import deque
m,n,h = map(int,input().split())
#tomato[h][n][m]
tomato=[[list(map(int,input().split())) for _ in range(n)] for _ in range(h)]
#print(tomato)
q=deque()
for i in range(h):
    for j in range(n):
        for k in range(m):
            if tomato[i][j][k]==1:
                q.append((i,j,k))
day=0
while q:
    count=len(q)
    dx=[-1,1,0,0,0,0]
    dy=[0,0,-1,1,0,0]
    dz=[0,0,0,0,-1,1]
    day += 1
    for _ in range(count):
        z, y, x = q.popleft()
        for i in range(6):
            nx = x+dx[i]
            ny = y+dy[i]
            nz = z+dz[i]
            if 0<=nz<h and 0<=ny<n and 0<=nx<m and tomato[nz][ny][nx]==0:
                q.append((nz,ny,nx))
                tomato[nz][ny][nx]=1
            else:
                continue
for i in range(h):
    for j in range(n):
        for k in range(m):
            if tomato[i][j][k]==0:
                print(-1)
                exit(0)
print(day-1)

다른 파이썬 프로그램에서 사용할 수 있는 파이썬 코드를 모듈이라고 한다.

예를 들어 calculation.py 파일을 만들었다고 가정하자

def add(x,y):
    return x+y

def subtract(x,y):
    return x-y

def multiply(x,y):
    return x*y

def divide(x,y):
    return x/y

이 calculation.py를 사용하기 위해 아래에 함수를 호출하면 코드가 너무 길어진다. 그래서 다른 파이썬 파일에서 calculation.py를 사용할 수 있도록 할 수 있다.

run.py 파일에서 calculation.py를 사용해보도록 하겠다.

import calculation

print(calculation.add(2,5))
print(calculation.multiply(3,4))

위와 같이 import를 통해서 calculation.py의 함수들을 사용할 수 있다.

calculation이라는 이름이 너무 길다고 생각될 경우 import calculation as (원하는 이름) 을 통해 사용할 수도 있다.

import calculation as calc

print(calc.add(2,5))
print(calc.multiply(3,4))

모듈이름을 쓰고 점을 찍고 함수이름을 쓰는 방법을 배웠다. 그런데 모듈이름을 계속 쓰기가 귀찮을수도 있다. 

calculation 함수에서 add와 multiply함수만 불러올 수도 있다.

from calculation import add,multiply

print(add(2,5))
print(multiply(3,4))

불러온 함수만 쓸 수 있다. 모든 함수를 쓰려고 하면 from calculation import * 방법으로 쓰면 되는데 출처가 불분명해지기 때문에 잘 쓰지 않는다고 한다.

개발자들이 자주 쓸법한 파일들은 이미 만들어져 있다. 파이썬을 설치하면 standard library라는 것이 같이 따라온다.

1. math 모듈

# standard library (표준 라이브러리)
import math

print(math.log10(100))
print(math.cos(0))
print(math.pi)

2.random 모듈

import random

print(random.random())#0.0과 1.0 사이의 random한 값이 출력됨

randint 함수 : 두 수 사이의 어떤 랜덤한 정수를 리턴하는 함수

randint(a,b)를 하면, a<=N<=b를 만족하는 어떤 랜덤한 정수 N을 리턴한다.

uniform 함수 : 두 수 사이의 랜덤한 소수를 리턴한다.

uniform(a,b)를 하면, a<=N<=b를 만족하는 어떤 랜덤한 소수 N을 리턴한다.

3. os 모듈

import os
print(os.getlogin())#어떤 계정으로 login 되어있는지 알 수 있음
print(os.getcwd())#현재 이 파일이 있는 경로를 알 수 있음

4. datetime 모듈

datetime 모듈은 '날짜'와 '시간'을 다루기 위한 다양한 '클래스'를 갖추고 있다. 

import datetime
#datetime 값 생성
yesterday=datetime.datetime(2021,5,28)
print(yesterday)#2021-05-29 00:00:00

#오늘 날짜
today = datetime.datetime.now()
print(today)

#timedelta - 두 datetime 값 사이의 기간을 알고 싶을때
today = datetime.datetime.now()
pi_day=datetime.datetime(2020,3,14,13,6,15)
print(today-pi_day)#441 days, 7:34:40.480029
today = datetime.datetime.now()
my_timedelta = datetime.timedelta(days=5, hours=3, minutes=10, seconds=50)
print(today)
print(today + my_timedelta)

#datetime 해부하기
today = datetime.datetime.now()
print(today)
print(today.year)  # 연도
print(today.month)  # 월
print(today.day)  # 일
print(today.hour)  # 시
print(today.minute)  # 분
print(today.second)  # 초
print(today.microsecond)  # 마이크로초

#datetime 포맷팅
today = datetime.datetime.now()
print(today)
print(today.strftime("%A, %B %dth %Y"))

key - value pair (키 - 값)

my_dictionary={
    5: 25,#key:5, value:25
    2: 4,
    3:9
}
print(type(my_dictionary))#<class 'dict'>
print(my_dictionary[3])#9
my_dictionary[7]=81
print(my_dictionary[7])#81

사전에는 순서라는 개념이 없고 index는 굳이 정수가 아니더라도 된다. 이러한 점 때문에 리스트, 사전 둘 다 사용 가치가 있다.

사전활용법

my_family={
    '아빠': '김동식',
    '엄마': '이윤경',
    '아들': '김태헌',
    '딸': '김주영'
}
#value 값들이 필요할 때
print(my_family.values())#dict_values(['김동식', '이윤경', '김태헌', '김주영'])
#값이 있는지 확인
print('김태헌' in my_family.values())#True
#이 값들로 반복문을 돌고 싶을 때
for value in my_family.values():
    print(value)
#키 값을 받고 싶을 때
print(my_family.keys())#dict_keys(['아빠', '엄마', '아들', '딸'])
#key와 value 모두 같이 받아오려고 할 때
for key,value in my_family.items():
    print(key,value)

파라미터에게 '기본값(default value)'을 설정할 수 있다. 기본값을 설정해 두면, 함수를 호출할 때 꼭 파라미터에 값을 안 넘겨 줘도 된다. 이런 파라미터를 '옵셔널 파라미터(optional parameter)'라고 한다. 

def myself(name, age, nationality="한국"):
    print("내 이름은 {}".format(name))
    print("나이는 {}살".format(age))
    print("국적은 {}".format(nationality))


myself("김태헌", 24, "미국")  # 옵셔널 파라미터를 제공하는 경우
print()
myself("김태헌", 1)  # 옵셔널 파라미터를 제공하지 않는 경우

Optional Parameter는 모두 마지막에 있어야 한다. 중간에 Optional Parameter를 넣으면 오류가 난다.