instruction
stringlengths 1
327k
| domain
stringclasses 6
values | __index_level_0__
int64 0
149k
|
|---|---|---|
์๋ง์กด ์จ๋น์ค๊ฐ ์ดํด๊ฐ ์๋ฉ๋๋ค...
๊ทธ๋ ๊ฒ ๋๋จํ ํ์ฌ๊ฐ...
์ด๋ ๊ฒ ๋ณต์กํ ๋จ๊ณ๋ฅผ ํตํด ์ ์ํ๊ณ , ์น์๋ฒ๋ฅผ ๋ง๋ค๊ฒ ํ๋ค๋ ๊ฒ์ด.....
puttygen์ผ๋ก ํคํ์ด๋ฅผ ๋ค์ ์๋ก์ด ํํ์ ํค๋ก ๋ง๋ค๊ณ , ๊ทธ๊ฑธ putty์ ๋ฃ์ด์ ์คํํ๊ณ ,
์ํ์น๋ฅผ ๋ฐ๋ก ์ค์นํ๊ณ , ๋ณต์กํ ๋ช
๋ น์ด๋ค์ ์
๋ ฅํ๊ณ ...
๊ทธ๋ฌ๊ณ ๋์์ผ.. ๊ฒจ์ฐ ์น์๋ฒ๊ฐ ๋ง๋ค์ด์ง๋ค๋...
๊ฑฐ๊ธฐ ๊ฐ๋ฐํ๋ค์ด ๋
ธ๋ ๊ฒ๋ ์๋ ํ
๋ฐ...
๊ทธ๋ฅ ํคํ์ด์ ์ฒ์ ํผ๋ธ๋ฆฌIP๋ก ์ธ์ฆํด์, web์๋ฒ๊ฐ ๋ง๋ค์ด์ง๊ฒ ๋ง๋ค์ง ๋ชปํ๋์??
21์ธ๊ธฐ GUI ์๋ํ๊ฒฝ, ํด๋ผ์ฐ๋ฉ ์ปดํจํ
์ ํ๋ ์ธ์์์
์์ง๋ ์ ๋์ค ์ปค๋งจ๋๋ก ๋ณต์กํ ์ค์น๊ณผ์ ์ผ๋ก, ๋ํ ์ค๊ฐ์ puttygen, putty๋ฅผ ๋ค์ด๋ฐ๊ณ ๋ณต์กํ ๋ฉ๋ด์์ ์ค์ ๋ฃ๊ณ , ์ํ์น ์ค์นํ๊ณ ๋ฑ๋ฑ...
์ดํด๊ฐ ์๊ฐ๋๋ค.
์ด๊ฒ๋ค์ ๊ทธ๋ฅ ํ๋์ ํ๋ก๊ทธ๋จ์์์, ํน์ ์๋ง์กด์นํ์ด์ง ํ๋ฉด์์์ ์ฝ๊ฒ ์ค์ ํ๋ ์ฑ๋ง๋๋ ๊ฒ์ด ๊ทธ๋ค์๊ฒ ๊ทธ๋ ๊ฒ ์ด๋ ค์ด ๊ฑด๊ฐ์?
|
code-web
| 0
|
๋ฆฌ๋ทฐ ์์ฑ ํ์ด์ง์์ ํน์ ์์ ์ถ๊ฐ ๋ฐฉ๋ฒ(์ฌ๊ธฐ์๋ ์์ ์ฌ์ง)์ ๋ณํํ๋ ๋ฐฉ๋ฒ์ ๋ํ ์ง๋ฌธ์
๋๋ค.
ํ์ฌ coplate ๋ฆฌ๋ทฐ์์ฑ ํผ์์ ์ฌ์ง ์ถ๊ฐ๋ ์ฌ์ง1 ~ ์ฌ์ง3 ์ถ๊ฐํ๋ ๊ณต๊ฐ๊ณผ ๋ฒํผ์ด ์ ํด์ ธ ์๋๋ฐ,
์ด๋ฌํ ๋ฐฉ์ ๋ง๊ณ
________________
์ฌ์ง 1 : ์ฐพ์๋ณด๊ธฐ
---------------------
์ฌ์ง ๋ ์ถ๊ฐํ๊ธฐ (+) --->๋ฒํผ
---------------------
________________
์ฌ์ง 1 : ์ฐพ์๋ณด๊ธฐ
---------------------
์ฌ์ง 2 : ์ฐพ์๋ณด๊ธฐ
---------------------
์ฌ์ง ๋ ์ถ๊ฐํ๊ธฐ (+) --->๋ฒํผ
---------------------
์ด๋ฐ ์์ผ๋ก ๋ ์
๋ ฅํ ์ ์๋ ๊ณต๊ฐ์ด ์๊ธฐ๋ ๋ฒํผ์ ๋ง๋๋ ค๋ฉด ์ด๋ป๊ฒ ํด์ผํ ๊น์?
```
์ฝ๋๋ ์ฌ๊ธฐ ์ฝ๋๋ธ๋ก์ ์
๋ ฅํด ์ฃผ์ธ์.
```
|
code-web
| 1
|
์ผ๋งค(?)๋ก ์ฝ๋ฉํ๋ ๋๋์ด ๋ค์ด ๊ฑฑ์ ์
๋๋ค... ์์ผ๋ก ๊ณต๋ถ๋ฐฉ๋ฒ์ ๋ํด ์กฐ์ธ ๋ถํ๋๋ ค์ ใ
ใ
์๋
ํ์ธ์.
์ฝ๋์์์ ์ค์ต์ ํ๋ค๋ณด๋ฉด ๋ญ๊ฐ ๊ฒฐ๊ณผ๋ ๋์ค๋๋ฐ ํญ์ ์ผ๋งค๋ก ํ๋ ๋ฏํ ๋๋์ด ๋ค์ด ๊ฑฑ์ ์
๋๋ค
์๋ฅผ ๋ค์ด, ์ด๋ฒ ์ค์ต์์๋ ๋ชจ๋ฒ๋ต์์ ๋จ์ด๊ธธ์ด๋ฅผ 2๋ก ๋๋๊ณ ๋์ ๊ทธ๊ฑธ ํตํด ๋ต์ ์ฐพ๋๋ค๋ ๋๋์ธ๋ฐ,
์ ๋ ๊ทธ๋ฐ ์์ด๋์ด๊ฐ ์ต์ํ์ง ์์ ์๋ ์ฝ๋์ ๊ฐ์ด ์์ ๊ทธ๋ฅ ์๋ก์ด ๋ฌธ์์ด์ ํต์งธ๋ก ๋ง๋ค๊ณ ๊ทธ๊ฑธ๋ก ๋ต์ ๋น๊ตํ๊ฑฐ๋ ์
์์ผ๋ก ๊ณต๋ถํ ๋, ์ผ๋จ ๊ฒฐ๊ณผ๊ฐ ๋์ค๋๊น ๋ค์ ํ ํฝ์ผ๋ก ๋น ๋ฅด๊ฒ ๋น ๋ฅด๊ฒ ๋์ด๊ฐ๋ ๊ฒ ๋ ๋์์ด ๋ ์ง,
์๋๋ฉด ๋ชจ๋ฒ๋ต์์ ๊ฑฐ์ ์ธ์ฐ๋ค ์ถํ ๋ณธ ๋ค์ ๋ค์ ํ ํฝ์ผ๋ก ๋์ด๊ฐ์ผ ๋ ๋์์ด ๋ ์ง ๊ณ ๋ฏผ์
๋๋ค... ใ
ใ
```
# ๋ชจ๋ฒ๋ต์
def is_palindrome(word):
for left in range(0, len(word)//2):
right = len(word) - 1 - left
if word[left] != word[right]:
return False
return True
```
```
# ๋ด ๋ต์
def is_palindrome(word):
new_word = ""
for i in range(len(word)):
temp = word[-(i + 1)]
new_word += temp
return word == new_word
```
|
code-web
| 2
|
UPDATE order SET is_cancelled = โYโ;
UPDATE order SET is_cancelled = โYโ;
์ด ์ฟผ๋ฆฌ์์๋... ์ด๋ค row๋ฅผ Y๋ก ๋ง๋ ๋ค๋ ๋ด์ฉ์ด ์๋๋ฐ....
์ด๋ป๊ฒ ํด๋น ๋ก์ฐ ๋ด์ฉ์ Y๋ก ๋ฐ๊พธ๋์??
```
SELECT * FROM WHERE is_cancelled != โYโ;
SELECT * FROM WHERE is_deleted != โYโ;
```
๊ทธ๋ฆฌ๊ณ ์ด ์ฟผ๋ฆฌ ์ญ์... ํ
์ด๋ธ์ ๋ช
์ํ์ง ์์๋๋ฐ... ์ ์ ๋ก ์กฐํ๊ฐ ๋๋ ๋ณด๋ค์.
๋ฌผ๋ก ์ด๋ ค ์๋ ํ
์ด๋ธ์์ ๋ช
๋ นํ๋ฉด ๋ ๊ฒ ๊ฐ์๋ฐ...
์ฌํ๊น์ง ๋ฐฐ์ด ๊ฒ์ผ๋ก๋ FROM ๋ค์ ํ
์ด๋ธ๋ช
์ ๊ณ์ ๋ฃ์๊ธฐ ๋๋ฌธ์ ๊ถ๊ธํด์ ๋ฌธ์๋๋ฆฝ๋๋ค.
```
์ฝ๋๋ ์ฌ๊ธฐ ์ฝ๋๋ธ๋ก์ ์
๋ ฅํด ์ฃผ์ธ์.
```
|
code-web
| 3
|
AS ๋ค์ select๋ฌธ์ ๊ดํธ๋ฅผ ํด๋ ๋๋ค์. ์ฐธ๊ณ ํ์ธ์.
```
create view v_emp as
(
select id, name, age, department, phone_num, hire_date
from employee
);
select * from v_emp
```
|
code-web
| 4
|
๊ฒฐ๊ณผ๊ฐ ๋ฆฌ์คํธ๋ก ๋์ต๋๋ค.
์ฝ๋์ ๊ฒฐ๊ณผ๊ฐ ๊ฐ๊ฐ ๋ฆฌ์คํธ๋ก ๋์ต๋๋ค.
```
[['707-514-0033'], ['070', '3460', '5076'], ['905-389-4463'], ['(02)', '6175', '8642'], ['07183', '30', '07', '96'], ['21-90-47700'], ['33', '36175334'], ['845-857-0825'], ['507-876-0713'], ['773-757-1932'], ['301-787-8206'], ['310-718-6212'], ['781-646-1715'], ['315-576-8242'], ['650-577-7537'], ['229-460-4970'], ['305-540-4990'], ['606-614-9190'], ['814-965-6502'], ['8134-191-6900'], ['914-933-3946'], ['801-927-7191'], ['736', '301', '706'], ['916-863-6154'], ['252-218-2526'], ['803-535-5627'], ['580-730-2253'], ['240-597-0099'], ['210-727-9560'], ['919-887-6912'], ['614-449-8617'], ['830-229-4983'], ['303-284-0638'], ['734-981-4470'], ['701-496-3125'], ['605-677-5038'], ['209-848-9572'], ['760-464-6831'], ['508-272-0114'], ['845-915-5076'], ['973-640-3581'], ['541-579-1559'], ['336-212-0408'], ['845-340-3808'], ['561-526-2625'], ['801-608-1332'], ['510-214-0266'], ['785-253-0084'], ['585-749-2163'], ['312-362-2484'], ['570-603-5788'], ['802-738-8477'], ['507-771-8684'], ['720-634-0176'], ['313-930-0331'], ['8188-165-7118'], ['02-455-1973']]
```
์ด๋์ ์ค์ํ ๊ฑธ๊น์,,?
```
import requests
from bs4 import BeautifulSoup
# ์ฝ๋๋ฅผ ์์ฑํ์ธ์
response = requests.get('https://workey.codeit.kr/orangebottle/index')
soup = BeautifulSoup(response.text,'html.parser')
tags = soup.select('.container .phoneNum')
phone_numbers = []
for cls in tags:
phone_numbers.append(cls.text.split())
# ๊ฒฐ๊ณผ ์ถ๋ ฅ
print(phone_numbers)
```
|
code-web
| 5
|
์ด ์ฝ๋์ ๋ฌธ์ ๊ฐ ์์ด๋ณด์ด๋๋ฐ ๋ต์ด ์๋์ต๋๋ค.
์๋์ ๊ฐ์ด ์ฝ๋๋ฅผ ์์ฑํ์์ต๋๋ค. ์๋ฌด๋ฆฌ ๋ณด์๋ ์ฝ๋์ ํ๋ฆฐ ๊ฒ์ด ์์ด๋ณด์ด๋๋ฐ
์ถ๋ ฅ์ ํ๊ฒ ๋๋ฉด [2, 3, 5, 7, 11, 13, 17, 19]๋ก ์ถ๋ ฅ๋ฉ๋๋ค.
์ด๋ ๋ถ๋ถ์ด ํ๋ฆฐ๊ฑธ๊น์? ใ
ใ
```
numbers = [2, 3, 5, 7, 11, 13, 17, 19]
for i in range(0, len(numbers)):
temp = numbers[i]
numbers[i] = numbers[len(numbers) - i - 1]
numbers[len(numbers) - i - 1] = temp
print(numbers)
```
|
code-web
| 6
|
stock.item_id = item_id ๊ฐ ์ดํด๊ฐ ์๊ฐ๋๋ค....
์ฌ๊ณ ๋ก ์๋ ์ํ๋ค์์ ์ํฉ์ stock ํ
์ด๋ธ์์ ๊ด๋ฆฌํ๋๋ฐ
stock ํ
์ด๋ธ์ ์๋ ์ํ๋ค์ item_id๋ ์ด์ฐจํผ
item_id ์ ๋์ผ ์์ด๋๋ฅผ ์ฌ์ฉํ ๊ฒ์ด ์์์.
๊ทธ๋ ๋ค๋ฉด, stock.item_id ์ item_id๊ฐ ๊ฐ์ ๊ฒ์ ์ฐพ์ ํ์๊ฐ ์๋์?
stock ํ
์ด๋ธ์ ์๋ ๋ชจ๋ ๋ฌผ๊ฑด๋ค์... ๋ชจ๋ item ํ
์ด๋ธ์ ์๋ ๊ฒ์ด๊ณ , id๊ฐ ์ฐ๊ณ๋์ด ๊ด๋ฆฌ๋๋ ๊ฑด๋ฐ์....
๋ง์ฝ ์ ์ฐฝ๊ณ ๊ฐ ๊ทธ ํ์ฌ์ ์๋ฅ๋ฅผ ์ทจ๊ธํ๋ ์ฐฝ๊ณ ๊ฐ ์๋๋ผ,
A ํ์ฌ์ ์๋ฅ, B ํ์ฌ์ ์๋ฅ๋ ์ทจ๊ธํ๋ ๊ฒ์ด๋ผ๋ฉด
Aํ์ฌ์ ์๋ฅ item_id ์ ์ผ์นํ๋ ๊ฒ(์ผ์นํ๋ stock.item_id) ๋ฅผ ์ฐพ๋๋ค๋ฉด ์ดํด๊ฐ ๊ฐ๋๋ค.
ํ์ง๋ง ์์์ ๋งํ๋ ๊ฒ์ ๊ทธ๊ฒ ์๋ ๊ฒ ๊ฐ์ต๋๋ค.
```
์ฝ๋๋ ์ฌ๊ธฐ ์ฝ๋๋ธ๋ก์ ์
๋ ฅํด ์ฃผ์ธ์.
```
|
code-web
| 7
|
์๋ฐ์คํฌ๋ฆฝํธ ์์ ๋ฌธ์ ์ฐ์ตํ ์ ์๋ ์ฌ์ดํธ?
์๋
ํ์ธ์
์ฝ๋์ ์๊ฐํ๋ฉด์ ์์ ๋ฌธ์ ๊ฐ ์ข ๋ถ์กฑํ๋ค๋ ๋๋์ด ๋๋๋ฐ
์๋ฐ์คํฌ๋ฆฝํธ๋ html, css ๋ฑ ์ฐ์ต์์ ๊ฐ ์๋ ์ฌ์ดํธ๊ฐ ์์๊น์???
|
code-web
| 8
|
feed_forward(x, parameter) ๋ถ๋ถ
cache = {'a0' : x} ์ด ๋ถ๋ถ์์ x๋ ์ด๋ค ๊ฒ์ ๋ฐ์์ 0๋ฒ์งธ ์ถ๋ ฅ์ ์ ์ฅํ ๊ฒ์ธ๊ฐ์?
```
import numpy as np
import pandas as pd
# numpy ์์์ฑ ์กฐ์
np.random.seed(42)
# ๋ฐ์ดํฐ ์
๊ฐ์ง๊ณ ์ค๊ธฐ
dataset = pd.read_csv('./data/MNIST_preprocessed.csv', sep=',', header=None).values
# ์
๋ ฅ, ๋ชฉํ ๋ณ์ ๋ฐ์ดํฐ ์
๋๋๊ธฐ
X = dataset[:, 0:784]
Y = dataset[:, 784:]
# training, testing ๋ฐ์ดํฐ ์
๋๋๊ธฐ
X_train, X_test = X[0:250,], X[250:,]
Y_train, Y_test = Y[0:250,], Y[250:,]
def sigmoid(x):
"""์๊ทธ๋ชจ์ด๋ ํจ์"""
return 1/(1 + np.exp(-x))
def initialize_parameters(nodes_per_layer):
"""์ ๊ฒฝ๋ง์ ๊ฐ์ค์น์ ํธํฅ์ ์ด๊ธฐํํด์ฃผ๋ ํจ์"""
L = len(nodes_per_layer) - 1 # ์ธต ๊ฐ์ ์ ์ฅ
parameters = {}
# 1์ธต ๋ถํฐ L์ธต๊น์ง ๋๋ฉด์ ๊ฐ์ค์น์ ํธํฅ ์ด๊ธฐํ
for l in range(1, L+1):
parameters['W' + str(l)] = np.random.randn(nodes_per_layer[l], nodes_per_layer[l-1]) * np.sqrt(1. / nodes_per_layer[l])
parameters['b' + str(l)] = np.random.randn(nodes_per_layer[l]) * np.sqrt(1. / nodes_per_layer[l])
return parameters
def feed_forward(x, parameters):
"""์์ ํ ํจ์"""
cache = {'a0': x} # 0๋ฒ์งธ ์ธต ์ถ๋ ฅ ์ ์ฅ
L = len(parameters) // 2 #์ธต ์ ์ ์ฅ
for l in range(1, L+1):
a_prev = cache['a' + str(l-1)]
W = parameters['W' + str(l)]
b = parameters['b' + str(l)]
# ๊ฐ์ง๊ณ ์จ ๋ฐ์ดํฐ๋ก z์ a๋ฅผ ๊ณ์ฐํ๋ค.
z = W @ a_prev + b
a = sigmoid(z)
# ๊ฒฐ๊ณผ ๊ฐ์ ์บ์์ ์ ์ฅํ๋ค.
cache['z' + str(l)] = z
cache['a' + str(l)] = a
return a, cache
```
|
code-web
| 9
|
ํจ์์ return๋ฌธ ์ฌ์ฉ
์๋
ํ์ธ์. ๊ฐ์ ์๊ฐ์ undefined๋ฅผ ์ถ๋ ฅํ๋ ๊ฒฝ์ฐ๋ก
๋ณ์์ ์ธํ๊ณ ๊ฐ์ ํ ๋นํ์ง ์์๋
ํธ์ถ์ ํด๋น ํจ์์ return๋ฌธ์ด ์์ฑ๋์ง ์์์๋
ํ๋ผ๋ฏธํฐ๊ฐ ์๋๋ฐ ์๋ฌด ๊ฐ๋ ์ ๋ฌํ์ง ์์๋์๋๋ฐ์.
3๋ฒ์ ํด๊ฒฐํ๊ธฐ ์ํด ์ต์
๋ ํ๋ผ๋ฏธํฐ๋ฅผ ์ฌ์ฉํ๊ธด ํ๋๋ฐ์
2๋ฒ์ ๋ด์ฉ๋๋ก ๋ผ๋ฉด console.log ์์ return์ ์ ์ธํด์ผํ๋๊ฒ ์๋๊ฐ์?
์คํ๊ธฐ์์๋ return์ ์ํ๋ฉด undefined๊ฐ ์ถ๋ ฅ๋ ์ค ์์๋๋ฐ ๊ทธ๊ฑด ๋ ์๋๊ฒ ๊ฐ์์์.
์๋ ์ฝ๋์ ํจ์๊ตฌ๋ฌธ์ return์ ์จ์ผํ๋์ง ๋ง์ผ์ผํ๋์ง ํท๊ฐ๋ฆฝ๋๋ค.
๋ฌผ๋ก ๋๋ค ์๊ด์๊ธด ํ์ง๋ง...ํด์ค์์๋ return์ ์ ์ธํ์ง ์์์์.
undefined 2๋ฒ ๊ด๋ จํ์ฌ ๋ต๋ณ ๋ถํ๋๋ฆฝ๋๋ค.
```
// ์ฌ๊ธฐ์ orderSetMenu ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์.
function orderSetMenu(sandwich,drink='์คํ๋ผ์ดํธ'){
return console.log(`์ฃผ๋ฌธํ์ ${sandwich}, ${drink} ์ธํธ๋ฉ๋ด ๋์์ต๋๋ค!`)
}
// ํ
์คํธ ์ฝ๋
orderSetMenu('์ฝ๋์จ์ ํด๋ฝ');
orderSetMenu('ํฐํค๋ฒ ์ด์ปจ ์๋ณด์นด๋', '์ฝ์นด์ฝ๋ผ');
orderSetMenu('์ฝ๋์จ์ ๋ฉํธ');
orderSetMenu('์ดํ๋ฆฌ์ ๋น์ ํฐ', '๋ฅํฐํํผ');
orderSetMenu('์๊ทธ๋ง์', 'ํํ ์ค๋ ์ง');
```
|
code-web
| 10
|
phoneNumber ์ธํ๊ฐ์ ๋ฌด์กฐ๊ฑด ๋ฌธ์์ด๋ก ๋ค์ด์ค๋ ๊ฑด๊ฐ์? (์ ๊ณง๋ด)
phoneNumber ์ธํ๊ฐ์ ๋ฌด์กฐ๊ฑด ๋ฌธ์์ด๋ก ๋ค์ด์ค๋ ๊ฑด๊ฐ์? (์ ๊ณง๋ด)
|
code-web
| 11
|
y_train = y_train.values.ravel() ํด๋ ๊ฒฝ๊ณ ๋ฉ์์ง๊ฐ ๋์ค๋ค์.
๊ฒฐ๊ณผ๊ฐ์ ์ ๋์์ต๋๋ค.
๊ทธ๋ฐ๋ฐ, ๊ฒฝ๊ณ ๋ฉ์์ง๊ฐ ๋์์ด์.
```
/opt/conda/lib/python3.6/site-packages/sklearn/linear_model/logistic.py:460: FutureWarning: Default multi_class will be changed to 'auto' in 0.22. Specify the multi_class option to silence this warning. "this warning.", FutureWarning)
```
|
code-web
| 12
|
str() ์๊ฐ ๋ณต์ก๋ ๋ก๊ทธ ๋ฐ ์ง๋ฌธ
์๋๋ ๋ค๋ฅธ ๋ถ๊ป์ ๋ต๋ณํด์ฃผ์ ๋ด์ฉ์
๋๋ค. ์ฌ๊ธฐ์ ์ง๋ฌธ์ด ์์ต๋๋ค.
๊ธฐ๋ณธ์ ์ผ๋ก O(lgn)์ O(\log_{2}n)๋ผ๊ณ ํ์
จ๋๋ฐ str์ O(\log_{10}n)๋ก ํ๊ธฐ ๋๋ ๊ฑธ๋ก ์ค๋ช
ํ์
จ๋๋ฐ ๋ก๊ทธ์ ๋ฐ์ด 2๋ 10์ ์๊ด์ด ์๋๊ฑด๊ฐ์?
$n$์ ์ ์ 257138์ ์๋ฏธํ๋๋ฐ์. ์ด ์ ์๋ ์ซ์๊ฐ 6๊ฐ๊ฐ ์์์์? str ํจ์๋ฅผ ์ด์ฉํด์ ์ ์๋ฅผ ๋ฌธ์์ด๋ก ๋ณํํ๋๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ 257138๋ผ๋ ์์ฒญ ํฐ ์ซ์์ ๋น๋กํ๋ ๊ฒ ์๋๋ผ ์๋ฆฟ์์ ๋น๋กํฉ๋๋ค. ์ด๊ฑธ $d$๋ฅผ ์จ์ ํํํ๋ฉด $O(d)$์ธ ๊ฑฐ์ฃ .
๊ทธ๋ฆฌ๊ณ 257138๋ 10์ง๋ฒ์ ์ด์ฉํ์์์? ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ 257138์ ์๋ฆฟ์๊ฐ ๋ช ๊ฐ์ธ์ง ๋ฐ์ ธ๋ณด๋ฉด $O(\log_{10}n)$๋ผ๊ณ ํ ์ ์์ต๋๋ค. ๊ทธ๋ฌ๋๊น $O(\log{n})$์ ์ ์ $n$์ ์๋ฆฟ์๋ฅผ ํํํ๋ ๊ฑฐ์ฃ . ์๋ฆฟ์ $d = O(log_{10}n)$์ด๊ธฐ ๋๋ฌธ์ $d$๊ฐ ์๋ $n$์ ์จ์ ์๊ฐ๋ณต์ก๋๋ฅผ ๋ํ๋ด๋ฉด $O(\log {n})$ ์ด๋ ๊ฒ ํํํ ์ ์๋ ๊ฑฐ์ฃ .
|
code-web
| 13
|
MySQL Server root์ํธ ์ญ์ or ์ฌ์ค์ ๋ฐฉ๋ฒ๋ฌธ์.
MySQL Server ์ต์ ๋ฒ์ ์ค์นํ ์ญ์ ํ๊ณ ๋ค์ ์ค์นํ๋๋ฐ root์ํธ๋ฅผ ๊ณ์ ๋ฌผ์ด๋ณด๋๋ฐ ์ด๋ค ๊ฒ์ผ๋ก ์ํธ๋ฅผ ๋ง๋ค์๋์ง ๊ธฐ์ต์ด ์๋์ ์ค์น๊ณผ์ ํ์ ์ค์ ์ ์งํํ์ง ๋ชปํ๊ณ ๋ค ๊ฑด๋๋ฐ์์ต๋๋ค. ์ด๋ป๊ฒ ํด์ผ root ์ํธ๋ฅผ ์ฌ์ค์ ํ๊ฑฐ๋ ์ ๊ฑฐํ๊ณ ์ฌ์ค์น ํด๋ณผ ์ ์์๊น์? ์ญ์ ํ๊ณ ์ฌ์ค์น๋ฅผ ๋ฐ๋ณตํด๋ ๋์ผํฉ๋๋ค.
|
code-web
| 14
|
์
๋ ฅ๋ณ์, ๋ชฉํ๋ณ์๋ฅผ ์ ํ ๋, ๋ฐ๋์ ํ๋ค์ค๋ฐ์ดํํ๋ ์์ผ๋ก ๋ณํ์ํค๊ณ ์ ํด์ผ ๋๋์?
boston_dataset ์์ data๋ง ๋ถ๋ฌ์ค๋ฉด, ์ ์ ๋ก target์ด ๋น ์ง ๊ฒ์ด ๋ถ๋ฌ์ ธ์ค๊ณ ,
target์ ๋ถ๋ฌ์ค๋ฉด target ๋ฐ์ดํฐ๋ง ๋ถ๋ฌ์ค๋ ๊ฒ์ ๋ณด๋ฉด
์ด๋ฏธ ์๋ฃ๊ฐ ๋ถ๋ฆฌ๋์ด ์๋ ๊ฒ์ธ๋ฐ...
๊ทธ๋ฅ ์
๋ ฅ๋ณ์ ์งํฉ X = boston_dataset.data, ๋ชฉํ๋ณ์ y = boston_dataset.target ํ๋ฉด ์๋๋์???
์ง๋๋ฒ์๋ ์
๋ ฅ๋ณ์๋ฅผ ํ ์นผ๋ผ์ผ๋ก ๋ง๋ค์ด์ผ ๋๋ฏ๋ก ์ด์ฉ ์ ์์ด ํ๋ค์ค๋ฐ์ดํํ๋ ์์ผ๋ก ํ์ปฌ๋ผ์ ์๋์ง๋ง,
์ง๊ธ์ ๋ฐ๋ก ํ ์ปฌ๋ผ์ ์๋ผ์ ์ฌ์ฉํ ํ์๊ฐ ์์ผ๋ ๊ทธ๋ฅ ์ฌ์ฉํด๋ ๋๋ ๊ฒ์ด ์๋๊ฐ ์ถ์ต๋๋ค.
|
code-web
| 15
|
๋ฆฌ๋ทฐ๋ฅผ ๋ฑ๋กํ๊ณ ๋๋ฉด ์๋์ ๊ฐ์ ์๋ฌ๋ฉ์์ง๊ฐ ์ถ๋ ฅ๋๋๋ฐ์,
```
AttributeError at /reviews/12/Generic detail view ReviewDetailView must be called with either an object pk or a slug in the URLconf.Request Method:GETRequest URL:http://127.0.0.1:8000/reviews/12/Django Version:2.2Exception Type:AttributeErrorException Value:Generic detail view ReviewDetailView must be called with either an object pk or a slug in the URLconf.Exception Location:/Users/jay/.pyenv/versions/coplate-env/lib/python3.7/site-packages/django/views/generic/detail.py in get_object, line 47Python Executable:/Users/jay/.pyenv/versions/coplate-env/bin/pythonPython Version:3.7.13Python Path:['/Users/jay/www/coplate_project',
'/Users/jay/.pyenv/versions/3.7.13/lib/python37.zip',
'/Users/jay/.pyenv/versions/3.7.13/lib/python3.7',
'/Users/jay/.pyenv/versions/3.7.13/lib/python3.7/lib-dynload',
'/Users/jay/.pyenv/versions/coplate-env/lib/python3.7/site-packages']Server time:ํ์์ผ, 27 9์ 2022 17:03:41 +0000
```
์์์ ๋์ค๋ ๊ทธ๋๋ก ๋ฐ๋ผ์ ์ฝ๋ฉ์ ์งํํ๋๋ฐ, ์ด๋ ๋ถ๋ถ์์ ์๋ชป๋๊ฒ์ผ๊น์...
|
code-web
| 16
|
url์์ ๋ฌผ์ํ๊ฐ ์๋ฏธํ๋๊ฒ์ ๋ฌด์์ธ๊ฐ์
host, path, query ๊ฐ ์๋๊ฑด ์ ์์์ต๋๋ค. ๊ทธ๋ผ ์ฟผ๋ฆฌ ์์ ์๋ ๋ฌผ์ํ์ ์ญํ์ ๋ฌด์์ธ๊ฐ์?
|
code-web
| 17
|
์ด์ํ ์ํ๋ฌธ์ ๋ค์ฌ์ฐ๊ธฐ ์ง๋ฌธ
์๋ ์ฝ๋์์์์
i += 1์ ์ธ if๋ฌธ ๋ฐ๊นฅ์ผ๋ก ๋์์ผํ๋์? ๊ณ์ ์คํ์ค์ด๋ผ๊ณ ๋ ์ ๋ค์ฌ์ฐ๊ธฐ ์๋ค๊ฐ๋คํด์ ๋ง์ถ๊ธด ํ๋๋ฐ ํด์ค์์๋ ๋ฌดํ๋ฃจํ์ ๊ฑธ๋ฆฌ๋ ์ฃผ์ํ๋ผ๊ณ ๋ง ๋์ค๊ณ ์ ๋ฌดํ ๋ฃจํ๊ฐ ๋๋์ง ์ค๋ช
์ด ์๋๊ฑฐ ๊ฐ์์์.
์ค๋๋ง์ ์ด์ด์ ํ๋๋ฐ ๋ฐ๋ก ์ค์ต์ด๋ผ ์์ ๊ฐ์์ ๋์๋์ง ๊ธฐ์ต์ด ์ ์๋๋ค์.
```
i = 1
total = 0
while i < 1000:
if i % 2 == 0 or i % 3 == 0:
total += i
i += 1
print(total)
```
|
code-web
| 18
|
์ด๊ฑด ํ๋ฆฐ ์ ๊ทผ ๋ฐฉ์์ธ๊ฐ์?
๋ณ์ totalCount ์ scoreObject๋ฅผ ๋ํด์ฃผ๊ณ console.log๋ก ์ถ๋ ฅ์ ํด๋ณด๋ ๋ฐธ๋ฅ๊ฐ๋ค์ด ์ญ ๋ฌธ์์ด๋ก ๋ํด์ ธ์ ๋์ค๋๋ผ๊ตฌ์.
๊ทธ๋์ ๋ฌธ์ํ์ด ์๋ ์ซ์ํ์ผ๋ก ๋ํด์ง๊ฒ ํ์์ต๋๋ค ๊ฒฐ๊ณผ๋ ๋ง๋ค๊ณ ๋์ค์ง๋ง ์๋ชป๋ ์ ๊ทผ ๋ฐฉ์์ผ๊น์?
```
let hyesoonScore = {
'๋ฐ์ดํฐ ๋ชจ๋ธ๋ง์ ์ดํด': 10,
'๋ฐ์ดํฐ ๋ชจ๋ธ๊ณผ ์ฑ๋ฅ': 8,
'SQL ๊ธฐ๋ณธ': 22,
'SQL ํ์ฉ': 18,
'SQL ์ต์ ํ ๊ธฐ๋ณธ ์๋ฆฌ': 20,
};
let minsoonScore = {
'๋ฐ์ดํฐ ๋ชจ๋ธ๋ง์ ์ดํด': 14,
'๋ฐ์ดํฐ ๋ชจ๋ธ๊ณผ ์ฑ๋ฅ': 8,
'SQL ๊ธฐ๋ณธ': 12,
'SQL ํ์ฉ': 4,
'SQL ์ต์ ํ ๊ธฐ๋ณธ ์๋ฆฌ': 16,
};
function passChecker(scoreObject) {
// ์ฌ๊ธฐ์ ์ฝ๋๋ฅผ ์์ฑํด ์ฃผ์ธ์.
let totalCount = '';
for(let key in scoreObject) {
totalCount = Number(totalCount) + Number(scoreObject[key]);
}
if (totalCount >= 60) {
console.log('์ถํํฉ๋๋ค! ํฉ๊ฒฉ์
๋๋ค!');
} else {
console.log('์์ฝ์ง๋ง ๋ถํฉ๊ฒฉ์
๋๋ค...');
}
}
passChecker(hyesoonScore);
passChecker(minsoonScore);
```
|
code-web
| 19
|
์ ๋ฐฉ์์ ์ข ์ด๋ค์ง ํ๊ฐ ์ข ๋ถํ๋๋ฆฝ๋๋ค.
๊ฐ๋จํ ์ค๋ช
ํ๋ฉด,
1. ์นด์นด์คํก ํ์ด์ค๋ถ ํ
์คํธ๋ฉ์ ์ ํด๋์ค์
self.sent_by, self.content... ์ธ์
self.message_max_len ์ธ์คํด์ค ๋ณ์๋ฅผ ์ค์ ํ๊ณ ๊ทธ ๊ฐ์ ๋์
ํ์ต๋๋ค.
2. (์นด์นด์คํก ํ์ด์ค๋ถ ๋ฑ์ ์๋) short_message()๋ฉ์๋๋ฅผ, ๋ฉ์์ง๊ด๋ฆฌ๋ฉ๋์ ํด๋์ค์ ๋์์ต๋๋ค.
๊ทธ๋ฐ๋ฐ, ์ฌ๊ธฐ์ ๋ฉ์์งํฌ๊ธฐ๋ฅผ ์ค์ด๋ ๊ณผ์ ์์,
๊ฐ๊ฐ(์นด์นด์คํก, ํ์ด์ค๋ถ ๋ฑ)์ ๋ฉ์์ง๊ธธ์ด์ ํ์ด ๋ค๋ฅด๋ฏ๋ก,
์์ ์นด์นด์คํก ๋ฑ์ ํด๋์ค์์ ์ค์ ํ self.message_max_len ์ผ๋ก ๋ฐ์์ค๊ฒ ํ์ต๋๋ค.
(์นด์นด์คํก์ message๊ฐ ๋ฉ์์ง๊ด๋ฆฌ๋ฉ๋์ ๋ก ๋์ด์ฌ ๋, sent_by, content, ๋ฑ์ ๋ฐ์ดํฐ๊ฐ ์ ์ ๋ก message์ ๋ด๊ฒจ์ ๋์ด์ค๋ฏ์ด, message_max_len๋ ๊ฐ์ด ์ค๊ฒ ๋ง๋ฌ)
์ฆ, message.message_max_len ์์ผ๋ก, ๊ฐ๊ฐ์ ๋ฉ์์ง์ต๋๊ธธ์ด๊ฐ ์กฐํ๋จ.
```
class MessageNotificationManager:
"""๋ฉ์์ง ์๋ฆผ ๊ด๋ฆฌ ํด๋์ค"""
def __init__(self):
self.message_notifications = []
self.message_max_len = 0
def add_new_message(self, new_message):
"""์๋ก ์จ ๋ฉ์์ง ์ถ๊ฐ"""
self.message_notifications.append(new_message)
def short_message(self): # <==== ๋งค๋์ ํด๋์ค์ short_message() ๋ฉ์๋ ๋ .
"""๋ฉ์์ง ์ ๋ณด์ ์ถ์ฝ๋ ๋ด์ฉ์ ๋ฆฌํดํจ"""
message_str = "{}\n{}\n".format(self.time, self.sent_by)
message_str += self.content if len(self.content) <= self.message_max_len else self.content[:self.message_max_len] + "..."
return message_str
# self.message_max_len ์ผ๋ก ๊ฐ๊ฐ์ ์ต๋๊ธ์์์ ํ์ ๋ด์
def display_message_notifications(self):
"""๋ชจ๋ ์ ๋ฉ์์ง ํ์ธ"""
print("์๋ก ์จ ๋ฉ์์ง๋ค:")
for message in self.message_notifications:
print(message.short_message() + "\n")
class KakaoTalkMessage(MessageNotificationManager):
"""์นด์นด์คํก ๋ฉ์์ง ํด๋์ค"""
def __init__(self, sent_by, time, content):
self.sent_by = sent_by
self.time = time
self.content = content
self.message_max_len = 10
# <=== self.message_max_len์ ์ค์ ํด์, ์นด์นด์คํก์ ๋ฉ์์ง๊ฐ ์ ๋ฌ๋ ๋
# sent_by ๋ฑ์ ์๋ฃ ์ธ์๋ message_max_len์ด ๊ฐ์ด ๊ฐ๋๋ก ํจ.
class FacebookMessage(MessageNotificationManager):
"""ํ์ด์ค๋ถ ๋ฉ์์ง ํด๋์ค"""
def __init__(self, sent_by, location, time, content):
self.sent_by = sent_by
self.location = location
self.time = time
self.content = content
self.message_max_len = 15
class TextMessage(MessageNotificationManager):
"""๋ฌธ์ ๋ฉ์์ง ํด๋์ค"""
def __init__(self, sent_by, time, content):
self.sent_by = sent_by
self.time = time
self.content = content
self.message_max_len = 12
```
|
code-web
| 20
|
์ฐ์ ์์ ํ max ๊ฐ ์ถ์ถ ๊ด๋ จ ์ง๋ฌธ์์ต๋๋ค.
์๋ ์ฝ๋ ๋ธ๋ก์ ์ฃผ์์ผ๋ก ์ง๋ฌธ ๋ฌ์ ๋์ต๋๋ค.
```
def extract_max(self):
"""์ต์ฐ์ ์์ ๋ฐ์ดํฐ ์ถ์ถ ๋ฉ์๋"""
# ์ฝ๋๋ฅผ ์ฐ์ธ์
swap(self.heap, 1, len(self.heap) -1)
temp = self.heap.pop()
heapify(self.heap, 1, len(self.heap)) // ์ ์ฌ๊ธฐ์๋ -1 ์ํด์ฃผ๋์?
return temp
```
|
code-web
| 21
|
ํด๋์ค๋ฅผ ๋ง๋๋ ๋ฐฉ๋ฒ์ด ํญ์ ์ ์๊ฐ๊ณผ ๋ค๋ฆ
๋๋ค....์ ๊ฐ ๋ฌธ์ ์ธ๊ฐ์?
MessageNotificationManager ํด๋์ค๊ฐ ์๊ณ ,
KaKaoTalkMessage ํด๋์ค๊ฐ ์๋ค๋ฉด,
์นด์นด์คํก๋ฉ์์ง ํด๋์ค๋ ๊ทธ๋ฅ, ๋ฐ์ดํฐ๋ง ์์งํ๊ณ ,
๋ฉ์์ง๋
ธํฐํผ์ผ์ด์
๋งค๋์ ํด๋์ค์์
์๋ก์ด ๋งค์์ง๋ฅผ ๋ฐ๊ณ , ์ถ๋ ฅํ๊ธฐ ์ ์ ๋ฉ์์ง๋ฅผ ์งง๊ฒ ๋ง๋ค๊ณ , ๊ทธํ ๋์คํ๋ ์ดํ๋ฉด ๋ ํ
๋ฐ...
์ ๋ณต์กํ๊ฒ, ์นด์นด์คํก๋ฉ์์ง ํด๋์ค์์ ๋ฉ์์ง๋ฅผ ์งง๊ฒ ๋ง๋๋ ๋ฉ์๋๋ฅผ ๋ง๋ค๊ณ ,
๊ทธ๊ฑธ ๋ค์ ๋ฉ๋์ ํด๋์ค์์ ๊ฐ์ ธ๋ค ์ฌ์ฉํ๋ ๊ฑฐ์ฃ ???
๊ทธ๋ ๊ฒ ํ๋๊น, ๋ฐ์ดํฐ์ ํ๋ฆ์ด ์ด๋ฆฌ ์ ๋ฆฌ ์ฝํ ๋ฒ๋ ค์ ๋จธ๋ฆฌ๊ฐ ๋ณต์กํด์ ธ์.
(๋ฌด์๋ณด๋ค, ์ผ๋จ ํด๋์ค๋ฅผ ์ ์ํ ๋๋ถํฐ... ๋ญ๊ฐ ์ฒด๊ณ์ ์ด์ง ๋ชปํ๋ค๋ ๋๋์
๋๋ค.
๋งค๋์ ํด๋์ค์ ๋ด๊ธธ '๋ฌธ์๋ฅผ ์งง๊ฒ ํ๋ ํ์'๊ฐ, ๋๋ฆฌ์ด ์นด์นด์ค๋ฉ์์ง ํด๋์ค์ ๋ค์ด๊ฐ ๋ฒ๋ฆฌ๋....)
์์์์ Keyboard ๊ด๋ จ ํด๋์ค์์๋ ๋ง์ฐฌ๊ฐ์ง์
๋๋ค.
Keyboard ํด๋์ค์ ์ถ์๋ฉ์๋ save_input, send_input์ ๊ทธ๋ฅ KeyboardManager์ ๋ฃ์ด ๋ฒ๋ฆฌ๊ณ ,
๊ฐ๋ฐ์๋ค์ด ๊ทธ๊ฑธ ์ฐธ์กฐํด์ ๊ฐ๋ฐํ๋๋ก ํ๋ฉด ๋ ๊ฒ์,
๋ฐ๋ก Keyboard์ถ์ํด๋์ค๋ฅผ ํ๋ ๋ ๋ง๋ค์ด ๋ฒ๋ฆฐ ๊ฒ ๊ฐ๋ค๋ ์๊ฐ์
๋๋ค.
์ฌ์ง์ด๋... send_input์ด๋ผ๋ ๋ฉ์๋๋ฅผ ๊ฐ๊ฐ์ ํค๋ณด๋ํด๋์ค(์ ํํค๋ณด๋, ์ผ์ฑํค๋ณด๋ ๋ฑ)์์ ๋ง๋ค ํ์๋ ์์ต๋๋ค.
ํค๋ณด๋๋ฉ๋์ ์์ getํจ์๋ก ๊ฐ์ ธ์ค๋ ๋ฉ์๋๋ง์ผ๋ก ๊ทธ๋ฅ ๊ฐ์ ธ์ ๋ฒ๋ฆฌ๋ฉด ๋๋๊น์.
์ด์ฐจํผ ๊ฐ๋ฐ์B๊ตฐ(๊ฐ๊ฐ์ ํค๋ณด๋๋ฅผ ๊ด๋ จ ํ๋ก๊ทธ๋จ์ ๋ง๋๋ ์ฌ๋๋ค)์ด, ๊ฐ์ด๋๋ก ์ ์ํ [์์์ ํด๋์ค]๋ฅผ ์ฐธ์กฐํด์ ๊ฐ๋ฐํ ๊ฒ์ด๊ธฐ ๋๋ฌธ์,
๊ทธ๊ฑธ ํค๋ณด๋ํด๋์ค๋ก ํ์ง ๋ง๊ณ , ํค๋ณด๋๋ฉ๋์ ๋ก ์ ์ํ๋ฉด, ํค๋ณด๋๋ฉ๋์ ์์ ์ ์ํ ๊ฐ์ด๋๋ผ์ธ์ ๋ฐ๋ฅผ ๊ฒ ์๋๋๊น?
๊ทธ๋์,
ํค๋ณด๋๋งค๋์ ์์,
get_keyboard_input(self): ์ ๋ด์ฉ์ return self.keyborad.send_input() ์ฒ๋ผ, send_input() ํจ์๋ฅผ ์ฌ์ฉํ ๊ฒ์ด ์๋๋ผ
return self.keyboard.data ๋ผ๋ ํ์์ผ๋ก (keyboard ์ธ์คํด์ค๋ณ์์ data๋ผ๋ ์๋ฃ๋ฅผ ๋ฃ์ผ๋ผ๊ณ ๊ฐ์ด๋๋ผ์ธ์ ์ ์ํ๋ฉด)
์ ํํค๋ณด๋๋ฅผ ๋ง๋๋ ๊ฐ๋ฐ์. ์ผ์ฑํค๋ณด๋๋ฅผ ๋ง๋๋ ๊ฐ๋ฐ์.๋ค์ด
```
def save_input(self, input):
self.data = input
```
์์ผ๋ก ๋ง๋ค๊ฒ ๋๊ณ , (์๋ฃ๋ฅผ ๋ด๋ณด๋ด๋ ํจ์๋ ๋ง๋ค ํ์ ์๊ณ ๊ทธ๋ฅ ์์ผ๋ฉด)
ํค๋ณด๋๋งค๋์ ๋ getํจ์์์ ๊ทธ๋ฅ ํด๋นํค๋ณด๋.data๋ง ๊ฐ์ ธ์ค๋ฉด ๋์์์.(return self.keyboard.data)
ํค๋ณด๋๋งค๋์ ํด๋์ค๋ผ๋ ์ด๋ฆ์ ๋ง๋ ์ด์ ๋, ๊ฐ๊ฐ์ ํค๋ณด๋์ ์ฐ๊ฒฐํด์, ์๋ฃ ๊ฐ์ ธ์ค๋ ค๋ ๊ฒ ์๋๊ฐ์?
๊ทธ๊ฒ์ ์ ๊ฐ๊ฐ์ ์ ํํค๋ณด๋, ์ผ์ฑํค๋ณด๋์์ ๋ ์ผ์ ํ๊ฒ ๋ง๋๋์? ์ด๋ฐ ๊ฐ๊ฐ์ ํค๋ณด๋์์ ์ค๋ณต๋๋ ์ผ์ ์ถ๊ฐ๋ก ํ๋,
์ฝ๋์ ๊ตฌ์กฐ๊ฐ ๋์ฑ ๋ณต์กํด์ง๋ ๊ฒ ๊ฐ์ต๋๋ค.
์ ์ด๋ ๊ฒ ๋๊ณ ๋๊ณ ๊ผฌ๋ฆฌ์ ๊ผฌ๋ฆฌ๋ฅผ ๋ฌด๋ ๋ณต์กํ ๊ตฌ์กฐ๋ก ์ฝ๋ฉ์ ํด์ผ ๋๋ ์ง ์ ๋ชจ๋ฅด๊ฒ ์ต๋๋ค....
|
code-web
| 22
|
ํ๋ผ๋ฏธํฐ ๊ฐ ๋ค๋ฅด๊ฒ ํ๋ฉด ์๋ฌ๊ฐ ๋์ต๋๋ค.
ํ๋ผ๋ฏธํฐ ์ค์ ์ด๋ฆ์ a, b, c๋ก ํ์ฌ
์๋ ๊ณ์ฐ ํ๋ผ๋ฏธํฐ ๊ฐ์ ๊ฐ๊ฒ ์ฃผ์ง ์์ผ๋ฉด ํ๋ฆฌ๊ฒ ๋์ค๋์??
1, 2, 3์ ๋ฃ์๋๋ ๊ณ์ ํ๋ ธ๋ค๊ณ ๋์์์
๋ฌธ์ ์ ๋ณด๋ฉด ๊ทธ๋ฅ ํจ์ ์์ฑํ๋ ๋ฌธ์ ์ธ ๊ฑฐ ๊ฐ์ ๋ณด์ด๋๋ฐ ์์ ๊ฐ๋ฅํ๋ฉด ๊ณ ์ณ์ฃผ์ธ์~
๋ฌธ์ ์ ํ๋ผ๋ฏธํฐ ๊ฐ์ ์์ฑํด ์ฃผ์๋์ง
ํ๋ผ๋ฏธํฐ ๊ฐ์ ๋ค๋ฅธ ๊ฐ์ ๋ฃ์ด๋ ๋ง๊ฒ ํด์ฃผ์๋์ง์ฉ
```
def multiply_three_numbers(num_1, num_2, num_3) :
print(num_1 * num_2 * num_3)
multiply_three_numbers(7, 3, 5)
multiply_three_numbers(21, 4, 9)
multiply_three_numbers(-7, 6, 3)
```
|
code-web
| 23
|
์ถ์ํด๋์ค Keyboard๋ฅผ ๋ฐ๋ก ๋ง๋ค์ง ๋ง๊ณ ... ๊ทธ ๋ด์ฉ์ KeyboardManager ํด๋์ค์ ํตํฉํ๋ ๊ฒ์ ์ด๋ค๊ฐ์?
์ถ์ํด๋์ค๋ฅผ ๋ง๋๋๊น ์คํ๋ ค ๋ ๋ณต์กํด์ง๋ ๊ฒ ๊ฐ์ต๋๋ค.
๊ทธ๋ฅ KeyboardManager ํด๋์ค ์์ Keyboard ํด๋์ค ๋ด์ฉ์ ๋ด์์
ํ๋์ ๋ณด๊ธฐ ์ข๊ฒ ํ๊ณ ,
๊ฐ์ ํ์ฌํค๋ณด๋ ๊ฐ๋ฐ์๋ค์ด ์ค๋ฒ๋ผ์ด๋ฉํ ๋ด์ฉ๋ง ์ถ์๋ฉ์๋๋ก ์ ์ํ๋ฉด ์๋๋์?
```
class KeyboardManager:
ย ย def __init__(self):
self.keyboard = None
@abstractmethod
def save_input(self, content:str) -> None:ย ย ย ย
"""ํค๋ณด๋ ์ธํ ์ ์ฅ๋ฉ์๋"""
ย ย ย ย pass
@abstractmethod
ย ย def send_input(self) -> str:
ย ย ย ย """ํค๋ณด๋ ์ธํ ์ ์ก ๋ฉ์๋"""
ย ย ย ย pass ย ย ย ย ย ย ย ย ย
ย ย def connect_to_keyboard(self, keyboard):
ย ย ย """ํค๋ณด๋ ๊ต์ฒด ๋ฉ์๋"""
ย ย ย ย self.keyboard = keyboard
ย ย def get_keyboard_input(self):
ย ย ย ย """์ ์ ๊ฐ ํค๋ณด๋๋ก ์
๋ ฅํ ๋ด์ฉ์ ๋ฐ์์ค๋ ๋ฉ์๋"""
ย ย ย ย return self.keyboard.send_input()
```
|
code-web
| 24
|
-> None, ->str ์ ์ฃผ์์ด์ฃ ?
๊ทธ๋ฐ๋ฐ ์ ๋ฐ ์ฃผ์์ ๋ฌ์ ์ด์ ๊ฐ ๊ถ๊ธํด์.
str์ ๋ฌธ์๋ก ์
๋ ฅํ๋ผ๋ ์ด์ผ๊ธฐ ๊ฐ์๋ฐ...
์ซ์๋ฅผ ์
๋ ฅํด๋ ์๊ด์์ ๊ฒ ๊ฐ๊ฑฐ๋ ์.
๊ทธ๋ฆฌ๊ณ None์ ์ ์ฃผ์์ ๋ฌ์ ๊ฑด์ง ๋ชจ๋ฅด๊ฒ ์ต๋๋ค...
```
class Keyboard(ABC):
ย ย """ํค๋ณด๋ ํด๋์ค"""ย ย
@abstractmethodย ย
def save_input(self, content:str) -> None:
ย ย ย ย """ํค๋ณด๋ ์ธํ ์ ์ฅ๋ฉ์๋"""
ย ย ย ย pass
ย ย @abstractmethod
ย ย def send_input(self) -> str:
ย ย ย ย """ํค๋ณด๋ ์ธํ ์ ์ก ๋ฉ์๋"""
ย ย ย ย pass
```
|
code-web
| 25
|
์ด๊ฒ๋ ์ค๋ฅ์ธ๊ฐ์? ํ๋ ธ๋ค๊ณ ๋์์..
```
change = payment - cost # ๊ฑฐ์ค๋ฆ๋ ์ด์ก
fifty = change // 50000 # 50,000์ ์งํ
ten = (change % 50000) // 10000 # 10,000์ ์งํ
five = (change % 10000) // 5000 # 5,000์ ์งํ
one = (change % 5000) // 1000 # 1,000์ ์งํ
# ๋ต ์ถ๋ ฅ
print("50000์ ์งํ: {}์ฅ".format(fifty))
print("10000์ ์งํ: {}์ฅ".format(ten))
print("5000์ ์งํ: {}์ฅ".format(five))
print("1000์ ์งํ: {}์ฅ".format(one))
# ํ
์คํธ
calculate_change(100000, 33000)
print(calculate_change)
calculate_change(500000, 378000)
print(calculate_change)
```
```
50000์ ์งํ: 1์ฅ
10000์ ์งํ: 1์ฅ
5000์ ์งํ: 1์ฅ
1000์ ์งํ: 2์ฅ
<function calculate_change at 0x7ff480dc5dc0>
50000์ ์งํ: 2์ฅ
10000์ ์งํ: 2์ฅ
5000์ ์งํ: 0์ฅ
1000์ ์งํ: 2์ฅ
<function calculate_change at 0x7ff480dc5dc0>
```
๊ฒฐ๊ณผ์
<function calculate_change at 0x7ff480dc5dc0>
์ด๋ฐ๊ฒ ๋ ์ ํ๋ ธ๋ค๊ณ ๋์ค๋๊ฑด์ง..
์ ๋์ค๋ ๊ฑด๊ฐ์?
|
code-web
| 26
|
ํ์ ํด๋์ค major์ class_year ์ง๋ฌธ
ํ์ ํด๋์ค์ ๋ํ ์ค๋ช
์์๋ ์ด๋ ๋ฉ์๋ ํ๋ผ๋ฏธํฐ๋ก major ๊ฐ ๋ค์ด๊ฐ ์์ต๋๋ค.
```
class Student:
"""์ฝ๋์ ๋ํ์์ ๋ํ๋ด๋ ํด๋์ค"""
def __init__(self, name, id, major):
self.profile = StudentProfile(name, id, major)
self.grades = []
self.gpa_manager = GPAManager(self.grades)
self.report_card_printer = ReportCardPrinter(self.profile, self.gpa_manager)
```
ํ์ง๋ง ๋ชจ๋ฒ ๋ต์์์๋ ํ์ ํด๋์ค์ ์ด๋ ๋ฉ์๋๋ก class_year๋ก ๋ค์ด๊ฐ ์๊ณ ์ด ์ฝ๋๋ก ์คํ๋์ด์ผ ์ ๋๋ก ์๋๋ฉ๋๋ค.
```
class Student:
"""์ฝ๋์ ๋ํ์์ ๋ํ๋ด๋ ํด๋์ค"""
def __init__(self, name, id, class_year):
self.profile = StudentProfile(name, id, class_year)
self.grades = []
self.gpa_manager = GPAManager(self.grades)
self.report_card_printer = ReportCardPrinter(self.profile, self.gpa_manager)
```
์ ํ์ ํด๋์ค ํ์ด์ ๋ชจ๋ฒ ๋ต์์ด ๋ค๋ฅธ๊ฐ์?
์๋๋ ๋ชจ๋ฒ ๋ต์์
๋๋ค.
```
class StudentProfile:
"""ํ์ ๊ธฐ๋ณธ ์ ๋ณด ํด๋์ค"""
def __init__(self, name, id, major):
self.name = name
self.id = id
self.major = major
def change_info(self, new_name, new_id, new_major):
"""ํ์ ๊ธฐ๋ณธ ์ ๋ณด ์์ ๋ฉ์๋"""
self.name = new_name
self.id = new_id
self.major = new_major
class GPAManager:
"""ํ์ ํ์ ๊ด๋ฆฌ ํด๋์ค"""
def __init__(self, grades):
self.grades = grades
def add_grade(self, grade):
"""ํ์ ์ถ๊ฐ ๋ฉ์๋"""
if 0 <= grade <= 4.3:
self.grades.append(grade)
else:
print("์์
ํ์ ์ 0๊ณผ 4.3 ์ฌ์ด์ฌ์ผ ํฉ๋๋ค!")
def get_average_gpa(self):
"""ํ๊ท ํ์ ๊ณ์ฐ"""
return sum(self.grades) / len(self.grades)
class ReportCardPrinter:
"""์ฑ์ ํ ์ถ๋ ฅ ํด๋์ค"""
def __init__(self, student_profile, gpa_manager):
self.student_profile = student_profile
self.gpa_manager = gpa_manager
def print(self):
"""ํ์ ์ฑ์ ํ ์ถ๋ ฅ ๋ฉ์๋"""
print("์ฝ๋์ ๋ํ ์ฑ์ ํ\n\nํ์ ์ด๋ฆ:{}\nํ์ ๋ฒํธ:{}\n์์ ํ๊ณผ:{}\nํ๊ท ํ์ :{}"\
.format(self.student_profile.name, self.student_profile.id,\
self.student_profile.major, self.gpa_manager.get_average_gpa()))
class Student:
"""์ฝ๋์ ๋ํ์์ ๋ํ๋ด๋ ํด๋์ค"""
def __init__(self, name, id, class_year):
self.profile = StudentProfile(name, id, class_year)
self.grades = []
self.gpa_manager = GPAManager(self.grades)
self.report_card_printer = ReportCardPrinter(self.profile, self.gpa_manager)
# ํ์ ์ธ์คํด์ค ์ ์
younghoon = Student("๊ฐ์ํ", 20120034, "ํต๊ณํ๊ณผ")
younghoon.profile.change_info("๊ฐ์ํ", 20130024, "์ปดํจํฐ ๊ณตํ๊ณผ")
# ํ์ ์ฑ์ ์ถ๊ฐ
younghoon.gpa_manager.add_grade(3.0)
younghoon.gpa_manager.add_grade(3.33)
younghoon.gpa_manager.add_grade(3.67)
younghoon.gpa_manager.add_grade(4.3)
# ํ์ ์ฑ์ ํ
younghoon.report_card_printer.print()
```
|
code-web
| 27
|
for๋ฌธ ์๋์์ ๋ฆฌ์คํธ ์ด๊ธฐํ์ ๋ฆฌ์คํธ ์ธ๋ฑ์ฑ?!
์๋
ํ์ธ์ ๋ฐ๋ก ์ง๋ฌธ์ ๊ตฌํ ๋๊ฐ ์์ด์ ์ฌ๊ธฐ์๋ค ์ง๋ฌธ์ ์ฌ๋ฆฝ๋๋ค.
์๊ฐ๊ด์ฐฎ์ผ์๋ฉด ๋ต๋ณ ํด ์ฃผ์๋ฉด ๊ฐ์ฌํ๊ฒ ์ต๋๋น
๋ฐ์ ์ฝ๋ ๋ณด์๋ฉด์ res = [70, 80] ์ธ๋ฐ ์ด๊ฒ์ ๋ค์ people๋ก ๋์
ํ๋ฉด์
people์ด [70,80] ์ด ๋์์์~
๊ทธ๋ฐ๋ฐ?!
for i in range(len(people): .. ==> ์ด ๋ถ๋ถ์์ i๊ฐ 0์ผ๋ก ์ด๊ธฐํ? ๋์ง ์๊ณ ๊ทธ๋๋ก~(i๊ฐ 3์ด์์..) ๊ฐ๋๋ฐ์
์ด์ ๋ people์ด๊ธฐํ๊ฐ for๋ฌธ ์๋์์? ์ ์ธ์ด ๋ฌ๊ธฐ ๋๋ฌธ์ธ๊ฐ์? ์.. ์ ํํ ์ด์ ๋ฅผ ์๊ณ ์ถ์ต๋๋น~
```
people = [70, 50, 80, 50]
limit = 100
remove_indices = []
answer = 0
for i in range(len(people)):
min_num = min(people)
min_index = people.index(min_num)
if i != min_index:
weights = people[min_index] + people[i]
if weights <= limit:
answer += 1
remove_indices.append(i)
remove_indices.append(min_index)
res = [i for j, i in enumerate(people) if j not in remove_indices]
# res = [70,80]
people = res
remove_indices = []
else:
continue
answer
```
|
code-web
| 28
|
์ธ๊ณต ์ ๊ฒฝ๋ง์ด ์ซ์๋ฅผ ์ธ์ํ๋ค๋ ๊ฒ์ด ์ด๋ฐ ์๋ฏธ์ธ๊ฐ์?
๊ฐ hidden layers๊ฐ output layer์์ ๋ ๋ฉ์ด์ง์๋ก ๋ ์์ ํจํด์ ์ธ์ํ๋ค๋ ๊ฒ์ ๋น์ ๋ก ํ์
จ๋๋ฐ,
๊ทธ๋ผ ์ต์ข
์ ์ผ๋ก ์ซ์๊ฐ 0~9๋ผ๋ ๊ฒ์ ๊ฒฐ๊ณผ์ ์ผ๋ก ์ธ์ํ๋ ๊ฒ์ด
์ธ๊ณต ์ ๊ฒฝ๋ง์ด ๋ง ๊ทธ๋๋ก ํ์ต์ ํด์ ์ด๊ฒ์ด 0~9๋ผ๋ ์ซ์๋ค ๋ผ๋ ๊ฒฐ๊ณผ๋ฅผ ๋ด๊ณ ์ด๋ฅผ
ํ๋ก๊ทธ๋๋จธ๊ฐ 0~1์ฌ์ด์ ๊ฐ์ผ๋ก ๋ฆฌํด๋๋ ๊ฒ์ ๋ณด๊ณ ์ด๋ฅผ ๋ฐ์ ธ์ weight์ bias๋ฅผ ์์ ํ์ฌ
๊ฒฐ๊ตญ ์ซ์๋ฅผ ๋ถ๋ฅํ๊ฒ ๋ง๋๋ ๊ฒ์ธ๊ฐ์?
|
code-web
| 29
|
pandas .๊ณผ _์ ์ฐจ์ด
pandas์ ์ฝ๋๋ฅผ ์
๋ ฅํ ๋
์ฌ์ด์ .๋ฅผ ๋ฃ๋๊ฒ ์๊ณ _๋ฅผ ๋ฃ๋๊ฒ ์๋๋ฐ
๋์ ์ฐจ์ด๋ ๋ฌด์์ธ๊ฐ์? ๋ฉ์๋์ ํจ์ ์ฌ์ฉ์ ์ฐจ์ด์ธ๊ฐ์?
|
code-web
| 30
|
WHERE price > AVG(price) ์ฒ๋ผ '์๋ธ์ฟผ๋ฆฌ'๋ฌธ์ ์ฌ์ฉํ์ง ์์๋ ๋๋ ๊ฑฐ์ฃ ??
WHERE price > (SELECT AVG(price) FROM item) ๋์ ์
WHERE price > AVG(price) ๋ฅผ ์ฌ์ฉํด๋ ๋์ง ์๋์?
```
์ฝ๋๋ ์ฌ๊ธฐ ์ฝ๋๋ธ๋ก์ ์
๋ ฅํด ์ฃผ์ธ์.
```
|
code-web
| 31
|
์ด๋ ๊ฒ ํด๋ ๋ฌด๊ดํ์ง ์ง๋ฌธ๋๋ ค์~
ํด์ค์ ์ดํดํ๋๋ฐ ์ด๋ฐ์์ผ๋ก ํ์ดํด์ ๋ฌด๊ดํ์ง ์ง๋ฌธ๋๋ฆฌ๊ณ ,
์ค๋ฌด์์ ํด์ค ๋ฐฉ๋ฒ๊ณผ ์๋ ๋ฐฉ๋ฒ ์ค ์ด๋ค๊ฒ ๋ ์ ์ฉํ๋ค๊ณ ์๊ฐํ์๋์ง ๊ถ๊ธํฉ๋๋ค.
```
// ์ฌ๊ธฐ์ expressMultiplication ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์.
function expressMultiplication(a,b){
let result = a * b
console.log(`${a} * ${b} = ${result}`)
}
// ํ
์คํธ ์ฝ๋
expressMultiplication(3, 4);
expressMultiplication(3, 2);
expressMultiplication(7, 5);
expressMultiplication(8, 9);
expressMultiplication(5, 5);
expressMultiplication(9, 9);
```
|
code-web
| 32
|
ERROR: connect ECONNREFUSED 127.0.0.1:3306
์ค๋ฅ๊ฐ ๋์ ์๋ ค๋๋ฆฝ๋๋ค.
```
npx sequelize db:create --env development
```
```
ERROR: connect ECONNREFUSED 127.0.0.1:3306
```
ํ๋ฉด ์ด๋ฌํ ์ค๋ฅ๊ฐ ๋ฉ๋๋ค
|
code-web
| 33
|
๊ธฐ์กด์ ์๋ ํจ์์ด๋ฆ(์์ฝ์ด)์ ์ฌ์ฉํ๋ฉด ์๋๋ ๊ฒ ์๋๊ฐ์? append()ํจ์๋ฅผ ์ ์ํ ๋...
๊ถ๊ธํฉ๋๋ค.
|
code-web
| 34
|
์ค์นผ๋ผ + ๋ฒกํฐ(์ค์นผ๋ผ์ ๋ฒกํฐ์ ๋ง์
) ์ฐ์ฐ์ด ๊ถ๊ธํฉ๋๋ค.
predictionํจ์์ ๊ฒฝ์ฐ, ๋ฆฌํด๊ฐ์ผ๋ก
theta_0 + theta_1*x ๋ฅผ ํ๋๋ฐ
์ฌ๊ธฐ์ theta_0, theta_1์ ์ค์นผ๋ผ๊ฐ(์ค์๊ฐ)์ด๊ณ ,
x๋ array ๋ก ๋ง๋ค์ด์ง ๋ฒกํฐ๊ฐ์
๋๋ค.
๋ฒกํฐ๋ผ๋ฆฌ์ ๊ณ์ฐ์ ๋ฐฐ์ ๊ณ , ๋ ์ค์นผ๋ผ*๋ฒกํฐ์ ๊ณ์ฐ๋ ๋ฐฐ์ ์ง๋ง....
์ค์นผ๋ผ์ ๋ฒกํฐ์ ๋ง์
, ๋บ์
์ ์ ๋ฐฐ์ ๋ ๊ฒ ๊ฐ์ต๋๋ค.
๊ทธ๋ฐ๋ฐ.. ๋ค์ ์ฐ์ต๋ฌธ์ (prediction ํจ์)๋ก ๋์๊ฐ๋ด์ ๊ฒฐ๊ณผ ๊ฐ์ ์ดํด๋ณด๋... ๋ฒกํฐ๊ฐ์ ๊ฐ ์์์ ์ค์นผ๋ผ๊ฐ์ ์ฐ์ฐํ๋ ๊ฑฐ์๋ค์.
(์ด๊ฒ ๊ฐ๋ฅํ ๊ฑด๊ฐ์??? ํ๋ ฌ์ด ๊ท๊ฒฉ์ด ์๋ง์ผ๋ฉด ์๋ก ๋ง์
๋บ์
๋ ์๋๋๋ฐ... ๊ท๊ฒฉ์ด ์๋ง์ ์ค์นผ๋ผ๋ ๊ฐ๋ฅํ ๊ฐ์???)
์ด๊ฒ์ ์์์ ํ๋ฒ์ฏค ์ธ๊ธํด์ฃผ์
์ผ ๊ฒ ์ต๋๋ค.
๊ทธ๋ฆฌ๊ณ error๋ฒกํฐ @ error๋ฒกํฐ์ ๊ฐ์ด ๊ฒฐ๊ตญ ์ค์นผ๋ผ๊ฐ์ด ๋์๊ธฐ์ cost ๊ฐ์ด ์ค์นผ๋ผ๊ฐ์ด ๋๋ค๋ ๊ฒ๋...
๊ทธ๋์ y์ถ ๊ฐ์ผ๋ก ๊ทธ๋ํ๋ฅผ ๊ทธ๋ฆด ์ ์๋ค๋ ๊ฒ.
๋ฏธ๋ฆฌ ์๋ถ๋ถ ๋ฒกํฐ๋ฅผ ์ค๋ช
ํ ๋, ์ด๋ ๋ค๋ ๊ฒ์ ์๋ ค์ฃผ์์ผ๋ฉด ๋ ์ข์์ ๊ฒ ๊ฐ์ต๋๋ค.
|
code-web
| 35
|
'์์ค(cost)'๋ 'ํ๊ท ์ ๊ณฑ์ค์ฐจ(MSE)'๋ฅผ ๊ฐ๋ฆฌํค๋ ๊ฒ ๋ง๋์?
๋ ์ง๋ฌธ๋๋ฆฌ๊ณ ์ถ์ ๊ฒ์
plt.plot(cost_list) ํ์์ ๋,
y์ถ์ ์์ค์ธ ๊ฒ์ ์๊ฒ ๋๋ฐ,,
x์ถ์ด ์คํํ์๋ก ๋์ค๋๋ฐ...
cost_list์ cost ์ ๋ณด๋ง ๋ด๊ฒผ์ ํ
๋ฐ... ์ด๋ป๊ฒ ์คํํ์๋ฅผ ์๊ณ ์ x์ถ์ผ๋ก ์ก์ ์ ์๋ ๊ฑด์ง ๊ถ๊ธํฉ๋๋ค.
๋ง๋์จ ๊น์ plt.show() ํจ์๋ ์ง๋ฌธ ๋๋ฆฌ๊ณ ์ถ์ด์.
์ plt.plot(cost_list)๋ plt.show() ํจ์๋ฅผ ๋ถ๋ฅด์ง ์์๋ ์์์ ์ ์ถ๋ ฅ๋๋๋ฐ
plt.scatter(....)
plt.plot(...) ํ ์ดํ์
๋ค์ plt.show()๋ฅผ ํ ๊ฒ์ธ๊ฐ์?
๋ ๊ทธ๋ํ๋ฅผ ํ๋๋ก ์ถ๋ ฅํ๋ผ๋ ์๋ฏธ์ธ๊ฐ์?
๋ง์ฝ ๊ทธ๋ ๋ค๋ฉด... ์คํ๋ ค, plt.show()๋ฅผ ๋จผ์ ๋งํ๊ณ ์, ๊ทธํ์ plt.scatter(), plt.plot()์ ํด์ผ ๋์ง ์์๊น์?
์ฝ๋๋ ์์์๋ถํฐ์๋๋ก ๋ด๋ ค ์ฝ์ด๊ฐ๋ฉด์ ์คํ๋๋๊น์.
|
code-web
| 36
|
print(theta_0, theta_1) ํ์ง ์๊ณ , ๋ณ์๋ง ์ ์๋๋ฐ๋ ์ถ๋ ฅ๋๋ ์ด์ ๊ฐ ๊ถ๊ธํฉ๋๋ค.
๊ทธ๋ฆฌ๊ณ ๋ ๋ณ์๊ฐ ๋ฐ๋ก ์ถ๋ ฅ๋์ง ์๊ณ ....
๊ดํธ์์ ๋ฆฌ์คํธ์ ์ ์ฌํ๊ฒ ์ถ๋ ฅ๋๋ ์ด์ ๋ ๊ถ๊ธํด์.
๊ทธ๋์ ์๋์ ๊ฐ์ด ์คํ์ ํด ๋ดค์ต๋๋ค.
theta_0 ๋ง ์ฐ๋ฉด ์ด ๊ฐ๋ง ์ถ๋ ฅ๋จ.
๋์ค ํํ๋ก
```
theta_0
theta_1
```
๋ก ํ๋ฉด theta_1์ ๊ฐ๋ง ์ถ๋ ฅ๋จ.
๋ค์๊ณผ ๊ฐ์ด ํ๋ฉด,๋ ๋ค ์ถ๋ ฅ๋จ.
```
print(theta_0)
theta_1
```
```
\- ์ถ๋ ฅ๊ฒฐ๊ณผ \-\-
0.168218014178
0.34380324023511988
```
|
code-web
| 37
|
๊ฒฝ์ฌํ๊ฐ๋ฒ์์ error ์ ์์คํจ์ ๊ธฐ์ธ๊ธฐ์ ๊ด๊ณ์ ๋ํ ์ง๋ฌธ์
๋๋ค.
๊ฐ์ ๋ด์ฉ์ ์ ์ฒด์ ์ผ๋ก ๋ค์ ์ดํด๋ณด๋,
๊ฒฝ์ฌํ๊ฐ๋ฒ์ ์ผ๋ฐํํ ๊ณต์์ ๋ณด๋ฉด,
์ธํ0 ์ ์
๋ฐ์ดํธ ํ ๋, ์ธํ0 - ์ํ * (์์คํจ์ํธ๋ฏธ๋ถ๊ฐ.์ฆ ๊ธฐ์ธ๊ธฐ)ํ์๋๋ฐ,
๋์ค์๋ ๊ธฐ์ธ๊ธฐ ๊ฐ๋
๋์ ์, ๋ฒกํฐerror์ ํ๊ท ๊ฐ( error.mean())์ ์ฌ์ฉํ๋ค์.
๊ทธ๋ฌ๋ฉด ์์คํจ์์ ํธ๋ฏธ๋ถ๊ฐ(์๊ฐ๊ธฐ์ธ๊ธฐ)์, ๋ฒกํฐerror์ ํ๊ท ๊ฐ๊ณผ ๊ฐ์ ์๋ฏธ์ธ๊ฐ์???
๊ทธ๋ฐ๋ฐ, ํํธ์ผ๋ก ๋ณด๋ฉด... ๊ทธ๋ ์ง ์์ ๊ฒ ๊ฐ๊ธฐ๋ ํฉ๋๋ค.
x๋ณ์์ ๊ฐ์ด ๋ถ๋ ์ธํ1์ ๊ฒฝ์ฐ์๋, ๋ฒกํฐerror์ ํ๊ท ๊ฐ์ x๋ฅผ ์ถ๊ฐ๋ก ๊ณฑํ ๊ฒ์ ์ฌ์ฉํ์์ผ๋,
์ด๋๋ ์์คํจ์์ ์ธํ1ํธ๋ฏธ๋ถ๊ฐ(๊ธฐ์ธ๊ธฐ) = ๋ฒกํฐerror์ ํ๊ท ๊ฐ * x ๊ฐ ๋๋ค์.
|
code-web
| 38
|
beautiful soup import ๊ด๋ จ ๋ฌธ์
๋ฐ์ดํฐ๋ง๋ค๊ธฐ ํ ํฝ์ ๋ค๋ฅธ import๋ค์ ๋ชจ๋ from ~ import ํ์์ด ์๋ import ~ ํ์์ผ๋ก ๋ถ๋ฌ์ค๋๋ฐ
์ beautifulsoup๋ง from bs4 import beautifulsoup์ผ๋ก ๋ถ๋ฌ์ค๋๊ฑด๊ฐ์?
|
code-web
| 39
|
๋ค๋ฅธ ๋ฐฉ์์ผ๋ก ์ฝ๋๋ฅผ ์ง๋ดค์ต๋๋ค. ์์ ํ ๋ถ๋ถ์ด ์๋ค๋ฉด์๋ ค์ฃผ์ธ์!
์ฝ๋๋ฅผ ์ง๋ค๋ณด๋ ๋งค์ฐ..์ด๋ ต๊ฒ ๋์๋๋ฐ ์กฐ๊ธ๋ ์ฝ๊ณ ๊ฐํธํ๊ฒ ๋ฐ๊ฟ ๋ฐฉ๋ฒ์ด ์์๊น์?
```
let lyrics = "[์ฌ์]๋์๊ฒ ๋ ํ๊ณ ์ถ์๋ ๋ง ๊ณ ๋ง์ ๋ฏธ์ํด ํจ๊ป ์์ด์ ํ ์ ์์ด์ ์์ ์ ์์ด[์คํ] ์ ๋ง ๊ณ ๋ง์ ์ด ๋ด ์์ ๋์ง ์์์ค์ ํ์ ๋ด๋ณผ๊ฒ ํจ๊ป ์๋ค๋ฉด ๋๋ ต์ง ์์[ํ์ฒ ] ๋ด๊ฐ ๋ ์์ผ๋๊น ๋ด๊ฐ ์ฐ์ต๋ ๋ด ํ์ง๋ง ์์ ๊ฑฐ์ผ ๋ ๋ณด๊ณ ์๋ ๋ ์ข์[๋ช
์] ์๊พธ๋ง ๋๋ง์น๊ณ ์ถ์๋ฐ ์ ํ๋ คํ ํฐ ๋ฌด๋ ์์ ์ค ์ ์์๊น? ์์ ์์ด..[ํํ] ์ง๊ธ๊น์ง ๊ฑธ์ด์จ ์ด ๊ธธ์ ์์ฌํ์ง๋ ๋ง ์๋ชป ๋ ๊ธธ์ด ๋๋ก ์ง๋๋ฅผ ๋ง๋ค์์์[ํ๋] ํผ์ ๊ฑท๋ ์ด ๊ธธ์ด ๋ง๋งํ๊ฒ ์ง๋ง ๋๋ฆฌ๊ฒ ๊ฑท๋ ๊ฑฐ์ผ ์ฒ์ฒํ ๋์ฐฉํด๋ ๋ผ[๊ธธ] ์ ํ ์ ํ์๋ ์น๊ตฌ์ ๋ง๋ ์๋ฏธ ์๋ ์ธ์ฌ์ฒ๋ผ ์ฌํ๊ฒ ๋ค๋ฆด ๋ ๋ ์ฐพ์์";
let hyungdon = null;
// ์ฝ๋๋ฅผ ์์ฑํด ์ฃผ์ธ์.
let lyricsSlice = []; // ๊ฐ ํํธ์ ๋ฐฐ์ด
let chooseMember = 'ํ๋'; // ์ ํํ ๋ฉค๋ฒ
//๋ฐฐ์ด์ ํํธ ๋ถ๋ฐฐ ๋ฐฉ๋ฒ
for(let i = lyrics.length; i > 0; i--){
if(lyrics.length > 0 && lyrics.lastIndexOf('[') !== -1){
let lyricsLastOfIndex = lyrics.lastIndexOf('[');
lyricsSlice.unshift(lyrics.slice(lyricsLastOfIndex));
lyrics = lyrics.slice(0, lyricsLastOfIndex);
}
}
// ๋ฐฐ์ด์์์ ํด๋น ๋ฉค๋ฒ์ ํํธ ์ฐพ๊ธฐ
for(let str of lyricsSlice){
if(str.indexOf(chooseMember) !== -1){
hyungdon = str;
}
}
// ํ
์คํธ ์ฝ๋
console.log(hyungdon);
```
|
code-web
| 40
|
์ฝ๋ ์์ฑ์ ์์ ๋ชปํ๊ฒ ์ด์
์ด๋ป๊ฒ ์์ํด์ผํ ์ง ๊ฐ์ด ์์กํ์
|
code-web
| 41
|
์ญ์ ๋ฌธ delete์ผ๋ก ์ปฌ๋ผ ์ญ์ ํ๊ธฐ
์ปฌ๋ผ ์ญ์ ๋ฅผ
ALTER TABLE (ํ
์ด๋ธ๋ช
) DROP COLUMN (์ปฌ๋ผ๋ช
) ์ผ๋ก ํ๋๋ฐ
DELETE๋ก๋ ์ปฌ๋ผ์ ์ญ์ ํ ์ ์๋์?
|
code-web
| 42
|
์ฐ์ ๊ฐ์ ํ์ธํ๊ณ ์ถ์๋ฐ ์ด์ ๋ฅผ ๋ชจ๋ฅด๊ฒ ์ต๋๋ค.
์ฐ์ ๊ฐ์ ํ์ธํ๋๋ฐ 980580667.5665213
์ด๋ผ๊ณ ๋์ต๋๋ค. ๋ฌธ์ ๊ฐ ๋ญ๊ฐ์ ใ
```
start = 50000000
year = 1988
resultbank = 5000000
interest = 0.12
while year < 2016:
resultbank = resultbank * (1 + interest)
year +=1
if resultbank > 1100000000:
print(resultbank-1100000000)
else:
print(1100000000-resultbank)
```
|
code-web
| 43
|
๋ฌธ์(๋จ์ด)๋ฅผ write ํ๋๋ฐ ์ ์ซ์๋ก ์ธ์ํ๋์ง ์ดํด๊ฐ ์๊ฐ์
์๋ ์ฝ๋๋ก ์คํ์ ํด๋ดค๋๋ฐ ์ ๋ถ๋ช
apple ์ด๋ผ๋ ๋จ์ด๋ฅผ ๋ฃ๊ณ ,
๊ทธ๊ฑธ eng ์ ์ง์ ํด์คฌ๋๋ฐ eng๋ฅผ print ํ๋ฉด 5๊ฐ ๋์ต๋๋ค.. apple ๋จ์ด ๊ฐฏ์๋ฅผ ์ธ์ค๊ฑฐ๊ฐ์๋ฐ
์ ์ด๋ฌ๋๊ฑธ๊น์?
```
with open('vocabulary.txt','w') as f:
eng = f.write("apple")
print (type(eng))
print (eng)
```
```
<class 'int'>
5
```
|
code-web
| 44
|
and ๋์ ์ &์ ์ฐ๋ฉด ์๋๋ ์ด์ ๊ฐ ๋ญ๊น์?
์ง๋๋ฒ ์ด๋ค ์ฝ๋์์๋
and๋ฅผ ์ฐ๋ฉด ์ค๋ฅ๊ฐ ๋์ค๊ณ &๋ฅผ ์จ์ผ ๋์๋๋ฐ...
์ฌ๊ธฐ์๋ ๋ฐ๋๋ก ํ๋ฉด ์ค๋ฅ๊ฐ ๋์ค๋ค์.
```
while i < len(list1) and j < len(list2): # <=== ์ฌ๊ธฐ์ &๋ฅผ ์ฌ์ฉํ๋๋ ์ค๋ฅ๊ฐ ๋์ค๋ค์. ๋ค๋ฅธ ๋ต์ด ๋์ต๋๋ค.
```
|
code-web
| 45
|
HTML ์์ฑ ๊ณผ์ ์์์ ์ค๋ฅ
```
C:\Users\Owner\PycharmProjects\pythonProject\lottoproject\venv\Scripts\python.exe "C:/Users/Owner/PycharmProjects/pythonProject/lottoproject/lottery_driver (1).py"
Traceback (most recent call last):
File "C:/Users/Owner/PycharmProjects/pythonProject/lottoproject/lottery_driver (1).py", line 251, in <module>
WINNING_NUMBERS = lottery.draw_winning_numbers()
TypeError: draw_winning_numbers() missing 1 required positional argument: 'n'
```
lottery_driver.py ์คํ์ํค๋ฉด ์ด๋ฐ ์ค๋ฅ๊ฐ ๋จ๋๋ฐ, (์ ๋จ๊ณ๋ณ code๋ ๋ชจ๋ ์ ์๋ํ์์ต๋๋ค.)
์์ธ์ด ๋ฌด์์ผ๊น์?
|
code-web
| 46
|
์ค๋ฅ๊ฐ ๋จ๋ ์ด์ ๋ ๋ฌด์์ผ๊น์
789๊น์ง๋ ๊ด๋์๋ฐ ๊ทธ ์ดํ๋ก ๋ด๋ ค๊ฐ๋ฉด ์๋ฌ๊ฐ ๋น๋๋ค. ์๊ทธ๋ฐ๊ฐ์ใ
ใ
ใ
ใ
ใ
```
import numpy as np
A = np.array([
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
[-1, 3, 2]
])
```
```
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-1-c738e529554f> in <module> 4 [4, 5, 6], 5 [7, 8, 9] ----> 6 [0, 1, 2] 7 ]) 8 TypeError: list indices must be integers or slices, not tuple
```
|
code-web
| 47
|
sign_up_day > '2019-01-01' ๋ '2019-01-01' ํฌํจ ์กฐํ๋๋์?
sign_up_day > '2019-01-01' ๋ '2019-01-01' ํฌํจ ์กฐํ๋๋์?
|
code-web
| 48
|
๋ด์ฉ๊ณผ๋ ๋ค๋ฅธ ์ง๋ฌธ ์
๋๋ค๋ง..๋ฆฌ์กํธ ์์ค ๊ณต์ , ์คํ์ ์ด๋ป๊ฒ ํด์ผ ํ ์ง ์กฐ์ธ ๋ถํ ๋๋ฆฝ๋๋ค.
๋ฆฌ์กํธ ๊ณต๋ถ๋ฅผ ํ๊ธฐ ์ํด ์ฐ์ตํ๊ณ ์๋ ์์ค๋ฅผ ํ๊ตฐ๋ฐ์ ๋๊ณ ..์คํ๋ ํด๋ณด๊ณ ์ถ์ต๋๋ค..
์๋ฅผ ๋ค์ด ์ฌ๋ฌด์ค์ ํ๋ ์์ค๋ฅผ ๊ทธ๋๋ก ์ง์์๋ ํ๊ณ ์ถ์ต๋๋ค.
๋ก์ปฌ๋ก ํ๋ค ๋ณด๋..์ฌ๋ฌด์ค๊ณผ ์ง์์ ๋ฆฌ์กํธ ์ค์น๋ ํ์ง๋ง ์์ค๊ณต์ ๊ฐ ๋์ง ์๋ค ๋ณด๋ ๋งค์ฐ ๋ถํธ ํฉ๋๋ค.
๊ตฌ๋ฆ IDE ๋ผ๋ ๊ฐ ํ๋ ์
์ฒด๋ฅผ ์ด์ฉ ํ๋ฉด..์ํ๋ ๊ฒ์ด ๊ฐ๋ฅ ํ๊ฒ ์ง๋ง..์ฒดํ์ ์๋๊ฐ ๋งค์ฐ ๋๋ฆฌ๊ณ ..์
๊ทธ๋ ์ด๋๋ฅผ ์ํด์๋
๋น์ฉ๋ ๋ค๊ณ ํด์..์ฌ์ฉ ํ๊ณ ์ถ์ง ์๊ณ ์..
ํน์ ์๋ฒํธ์คํ
์ ์ฌ์ฉ ์ ๊ฐ๋ฅ ํ๊ฐ์?
์๊ฐ ํด๋ณด๋ฉด..๋ฆฌ์กํธ ํ๊ฒฝ์ ์๋ฒ์ ์ค์น ํ๋ฉด ๋์ง๋ง.. npm start ์คํ ์ ๋ธ๋ผ์ฐ์ ์ฐฝ์ด ์ด๋ป๊ฒ ๋ฐ์ง ๋ชจ๋ฅด๊ฒ ์ต๋๋ค.
๊ทธ๋ฅ ์๋ฒ์์ ์คํ ํ ๋๋ฉ์ธ ์ฃผ์๋ก ์ ๊ทผ ํ๋ฉด ๋๋๊ฑธ๊น์?
๊ทธ๋ฌ๊ธฐ ์ํด์๋ ์๋ฒ์์ 3000 ๋ฒ ํฌํธ๋ฅผ ๊ฐ๋ฐฉํด์ผ ํ๋๊ฑด์ง..๋ ๋ชจ๋ฅด๊ฒ ๊ณ ์..
์๋๋ฉด ๋ค๋ฅธ ๋ฐฉ๋ฒ์ด ์์ผ๋ฉด ์กฐ์ธ ๋ถํ ๋๋ฆฝ๋๋ค.
|
code-web
| 49
|
ํ๋ ธ๋ค๊ณ ๋์ค๋๋ฐ ์ด์ ๋ฅผ ๋ชจ๋ฅด๊ฒ ๋ค์
lambda๋ก ํ๊ฑฐ๊ณผ ์๋ df.loc๋ก ํ๊ฑฐ ๋ชจ๋ ๊ฒฐ๊ณผ๊ฐ์ด
๋์ค๋๋ฐ ์ ํ๋ ธ๋ค๋๊ฑด์ง ๋ชจ๋ฅด๊ฒ ์ต๋๋ค
```
# df['๋ถ๋ฅ'] = df['์์ค๋ช
'].str.contains('๋ํ')
# df.head()
# df['๋ถ๋ฅ'] = df['๋ถ๋ฅ'].apply(lambda x: '๋ํ' if x == True else '์ผ๋ฐ')
# df.head()
# ์ฝ๋๋ฅผ ์์ฑํ์ธ์.
test = df['์์ค๋ช
'].str.contains('๋ํ')
df.loc[test,'๋ถ๋ฅ'] = '๋ํ'
df['๋ถ๋ฅ'] = df['๋ถ๋ฅ'].fillna('์ผ๋ฐ')
df.head(100)
```
|
code-web
| 50
|
while break ๋ฌธ ์ง๋ฌธ
while ๋ฌธ break ์กฐ๊ฑด ์ฑ๋ฆฝ ํ, ๋ค์ for๋ฌธ์ผ๋ก ๋์๊ฐ์ ์งํํ๊ณ ์ถ์๋ฐ,
break ์กฐ๊ฑด์ด ์ฑ๋ฆฝํ๋ฉด ์์ for๋ฌธ ๋ ๋ ์ด์ ์งํ ์๋๊ณ ๋๋๋๋ผ๊ณ ์,
์์ for๋ฌธ์ ๋ค์ ์ฌ์งํ ํด์ผ ํ ๊ฒ ๊ฐ์๋ฐ, ์ด ๋ถ๋ถ์ด ์ ์ดํด๊ฐ ๊ฐ์ง ์์ต๋๋ค.
```
for i in range(2010,2013):
for j in range(1,13):
while True:
response = requests.get(f"https://workey.codeit.kr/ratings/index?year={i}&month={j}&weekIndex=" + str(page_num), headers=headers)
soup = BeautifulSoup(response.text, 'html.parser')
if len(soup.select('.row td')) !=0:
rating_pages.append(soup)
print(f"{i}๋
{j}์" + str(page_num)+"๊ฐ์ ธ์ค๊ธฐ ์๋ฃ")
page_num +=1
time.sleep(3)
else:
break
```
|
code-web
| 51
|
HTML ์์์ ์ค๋ฅ๊ฐ ์์ด ์ง๋ฌธ๋๋ฆฝ๋๋ค.
๋ก๋ ์๋ฎฌ๋ ์ด์
์ฝ๋ ๊ฐ ์ง๋ฌธ์ด ์๊ฒจ ๊ธ ๋จ๊น๋๋ค.
HTML ์์ฑ ์ดํ ๊ณ์ ๊ฐ์ ์ซ์๋ง ํ๋ฉด์ ๋จ๊ณ ๋น์ฒจ๊ธ์ก์ด 0์์ผ๋ก ์ ์ ๋์ด ์ด์ํ๋ค ์ถ์ด
์ฝ๋์์์ ์ ๋ต์ด๋ผ๊ณ ๋งํ ์ฝ๋์ ์ผ์ผ์ด ๋น๊ต๋ฅผ ํด๋ณธ ๊ฒฐ๊ณผ ๋ค์๊ณผ ๊ฐ์ ์ฝ๋๋ง ๋ค๋ฅธ ๊ฒ์ ํ์ธํ์ต๋๋ค.
```
# ๋น์ฒจ๋ฒํธ ๋ฝ๊ธฐ ์์
์ค ์ ๊ฐ ๋ต์ผ๋ก ์์ฑํ ์ฝ๋์
๋๋ค.
from random import randint
def generate_numbers(n):
a = []
while len(a) < n:
num = randint(1,45)
if num not in a:
a.append(num)
return a
def draw_winning_numbers():
total = []
first_one = generate_numbers(6)
first_one.sort()
print(first_one)
total = first_one
print(total)
while True:
second_one = generate_numbers(1)
if second_one[0] not in total:
total.append(second_one[0])
print(total)
break return total
```
์ ๊ฐ ์์ฑํ ์ฝ๋์ ํด์ค ์ฝ๋๊ฐ ๋ฌด์์ด ๋ค๋ฅธ ์ง, ๋ ์ ๊ฐ ๋ฌด์์ ์๋ชป ์ธ์งํ๊ณ ์๋ ์ง ๋ชจ๋ฅด๊ฒ ์ต๋๋ค.
sortedํจ์์ sort๊ฐ ๋ค๋ฅด๋ค๋ ๊ฒ์ ๊ฒ์์ผ๋ก ์๊ฒ ๋ ์ดํ
print๋ฌธ์ผ๋ก ์ถ๋ ฅํด๋ณธ ๊ฒฐ๊ณผ , ์ ๊ฐ ์์ฑํ ์ฝ๋ ์ค total ์ถ๋ ฅ์์๋ ๋ฌธ์ ๊ฐ ๋ณด์ด์ง ์์
์ด๋ป๊ฒ ํด๊ฒฐํ ์ง ์ ๋ชจ๋ฅด๊ฒ ์ด ์ง๋ฌธ ๋จ๊น๋๋ค.
|
code-web
| 52
|
์ด์ ๋ฅผ ์ ์ ์๋ ์ค๋ฅ
๊ฐ์๋ด์ฉ๊ณผ ๋๊ฐ์ด ์ฝ๋๋ฅผ ์
๋ ฅํ๋๋ฐ ์น ๋ธ๋ผ์ฐ์ ๋ฅผ ๋์ ์ ๋ ์ ํ๋ฉด์ ์๋ฌด๊ฒ๋ ๋์ค์ง ์์ต๋๋ค..
๊ฐ๋ฐ์ ๋๊ตฌ์ ๋ค์ด๊ฐ๋ณด๋ฉด ํด๋น ์์ญ ํ์๋ ๋์ด์๋๋ฐ ์ ์์ด ๋ฐ์๋์ง์์๊น์?
```
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>multiple floats</title>
<style>
.body{
margin: 0px;
}
.col{
height: 200px;
}
.col-1{
width: 200px;
}
.col-2{
width: 400px;
}
.col-3{
width: 600px;
}
</style>
</head>
<body>
<div id="div1" class="col col-1" sytle="background-color: blue;"></div>
<div id="div2" class="col col-1" sytle="background-color: green;"></div>
<div id="div3" class="col col-1" sytle="background-color :yellow;"></div>
<div id="div4" class="col col-1" sytle="background-color: orange;"></div>
<div id="div5" class="col col-2" sytle="background-color: purple;"></div>
<div id="div6" class="col col-3" sytle="background-color: pink;"></div>
<div id="div7" class="col col-2" sytle="background-color: gray;"></div>
</body>
</html>
```
|
code-web
| 53
|
BeautifulSoup ์ฉ์ด ๋์ ์ BS๋ก ์ด๋ฆ์ ๋ถ์ฌ์ ์ฌ์ฉํด๋์ง ์๋์?
import pandas as pd
import seaborn as sns ํ๋ฏ์ด
from bs4 import BeautifulSoup as BS ํด์
๊ทธ ์ดํ๋ก BS๋ก ์ฐ๋ฉด ํธํ ๊ฒ ๊ฐ์๋ฐ์...
|
code-web
| 54
|
css ์ ํ์๋ก ํ๊ทธ๋ฅผ ์ ํํ์
จ๋๋ฐ์. ์ผ๋ฐ์ ์ผ๋ก ์ด๋ค ๋ฐฉ๋ฒ์ ๋ง์ด ์ฌ์ฉํ๋์?
์ด๋ฒ ๊ณผ์ ์์ ํ์ด๋ฅผ ๋ณด๋ฉด css ์ ํ์๋ก ํ๊ทธ๋ฅผ ์ ํํด์ ์ฌ์ฉํ๋๋ฐ์.
์ผ๋ฐ์ ์ผ๋ก css ์ ํ ๋ฐฉ์์ ๋ง์ด ์ฌ์ฉํ๋์?
๊ทธ๋ฆฌ๊ณ id ๋ class ๋ฅผ ์ด์ฉํ๋๊ฒ๋ ์๋๋ฐ ํ์ด๋ฅผ ๋ณด๋ฉด Tag ๋ฅผ ์ ํํ๋ ๋ถ๋ถ๋ง ๋์์๋๋ผ๊ณ ์..
์ง๊ธ ๊ฐ์ ๊ฒฝ์ฐ๋ ๊ตณ์ด TagName ์ผ๋ก ํ์ง ์๊ณ Id ๋ class ๋ก ํด๋ ์ข์๊ฒ ๊ฐ์๋ฐ....
css ์ ํ๋ฐฉ์์ด ๋ ๊ด๋ฆฌํ๊ธฐ๊ฐ ์ข๋ค๊ฑฐ๋ TagName ์ด ๋ ์ฌ๋ฐ๋ฅด๋ค๊ฑฐ๋ ์ด์ ๊ฐ ์๋์ง ๊ถ๊ธํฉ๋๋ค..
```
์ฝ๋๋ ์ฌ๊ธฐ ์ฝ๋๋ธ๋ก์ ์
๋ ฅํด ์ฃผ์ธ์.
document.querySelector('#grade');
document.querySelector('button');
document.querySelectorAll('button')[0];
document.getElementsByTagName('button')[0];
document.getElementById('grade'); // ์ถ๊ฐ
```
|
code-web
| 55
|
temp ๋ฅผ ์ด์ฉํด์ ๋ค์ง์ด ๋ณด๋ ค๊ณ ํ๋๋ฐ ์๋ฉ๋๋ค.
temp ๋ฆฌ์คํธ๋ฅผ ๋ง๋ค์ด์ numbers_temp = numbers ๋ก ์ง์ ํ
numbers_temp ์์ ์ฝ์ด์์ numbers ๋ก ์ง์ด ๋ฃ์ผ๋ ค๊ณ ํ์ผ๋,
๋ค์๊ณผ ๊ฐ์ด ๊ฒฐ๊ณผ๊ฐ ์ ๋๋ก ์๋์ค๋๋ฐ, numbers_temp ์ ๊ฐ์ ์ง์ ์ง์ด๋ฃ์ด์ฃผ๋ฉด ์ ๋๋ก ์ถ๋ ฅ์ด ๋ฉ๋๋ค.
๋ถ๋ช
numbers_temp=numbers ๋ for ๋ฌธ ๋ฐ์ ์์ด์ ์ต์ด ์คํ์ ํ๋ฒ ์คํ์ด ๋๋๊ฒ ์๋๊ฐ ์ถ์๋ฐ์.
์ ๋๋ก ์คํ์ด ๋์ง ์๋ ์ด์ ๊ฐ ๊ถ๊ธํฉ๋๋ค!!
์๋์ ๊ฐ์ด ์ถ๋ ฅ์ด ๋๋ฉด์ ์ ๋๋ก ์ถ๋ ฅ์ด ๋์ง ์์ต๋๋ค.
๋ค์ง์ด์ง ๋ฆฌ์คํธ: [19, 17, 13, 11, 11, 13, 17, 19]
```
numbers = [2, 3, 5, 7, 11, 13, 17, 19]
numbers_temp = [2, 3, 5, 7, 11, 13, 17, 19] #์ผ์ด์ค1
#numbers_temp=numbers #์ผ์ด์ค2
# ๋ฆฌ์คํธ ๋ค์ง๊ธฐ
# ์ฝ๋๋ฅผ ์
๋ ฅํ์ธ์.
for i in range(0,len(numbers_temp)):
#print(i,numbers[i],len(numbers_temp)-1-i,numbers_temp[len(numbers_temp)-1-i])
numbers[i]=numbers_temp[len(numbers_temp)-1-i]
print("๋ค์ง์ด์ง ๋ฆฌ์คํธ: " + str(numbers))
```
|
code-web
| 56
|
1๋ฒ ๋ฌธ์ ์ง๋ฌธ์
๋๋ค
```
let fruits = ['๋ ๋ชฌ', 'ํ ๋งํ ', '๋ธ๊ธฐ', '๋ฐ๋๋'];
// fruits ๋ฐฐ์ด์ 'ํ ๋งํ '๋ฅผ ์ญ์ ํ๊ณ ๊ทธ ์๋ฆฌ์ '์ฌ๊ณผ', '์ฒญํฌ๋' ๋ฅผ ์ถ๊ฐํด ์ฃผ์ธ์.
fruits.splice(1, 1, '์ฌ๊ณผ', '์ฒญํฌ๋');
```
์ผ๋ก ์์ฑ์ ํ์๋๋ฐ๋ ์คํ ๊ฒฐ๊ณผ ๊ฐ์ด ์ฌ๊ณผ๋ ๋ ๋ชฌ์ผ๋ก ๋์ค๋๋ฐ ์ ์ด๋ฌ๋ ๊ฑธ๊น์?
|
code-web
| 57
|
ํ์ ์ ๊ฑฐ ์ while ๋ฐ๋ณต๋ฌธ ๋ง๊ณ for ๋ฐ๋ณต๋ฌธ๋ ์ด์ฉ ๊ฐ๋ฅํ๊ฐ์?
์๋์ฒ๋ผ for ๋ฐ๋ณต๋ฌธ์ ๋ชป ์ฐ๋์?
์๋ฌ๊ฐ ๋ฉ๋๋ค....
```
# numbers์์ ํ์ ์ ๊ฑฐ
for i in range(0, len(numbers)):
if numbers[i] % 2 == 1:
del numbers[i]
else:
i += 1
print(numbers)
```
|
code-web
| 58
|
์ฝ๋๋ฅผ ์์ฑํํ์ ์๋ ์คํ์ด ์๋ผ๋์?
์ฝ๋๋ฅผ ์์ฑํํ์ ์๋ ์คํ์ด ์๋ผ๋์? ์คํ๋ฒํผ์ ๋๋ ๋๋ฐ ์ ์๋ง ๊ธฐ๋ค๋ฆฌ์ธ์๋ผ๊ณ ๋จ๊ณ ์๋ฌด๊ฒ๋ ์๋จ๋ค์
|
code-web
| 59
|
์ ๋ ์ข ๋ค๋ฅด๊ฒ ์์ฑํ๋๋ฐ์ ์ด๋ ๊ฒ ์์ฑํด๋ ๋๋์?
์ ๋ ๋ต์ ์ด๋ ๊ฒ ์ ์๋๋ฐ ์ด๋ ๊ฒ ์์ฑํด๋ ๋๋์?
๋ต์์ฒ๋ผ ํด์ผ 100์ ์ง๋ฆฌ ๋ต์ธ์ง ๊ถ๊ธํด์ ๋ฌผ์ด๋ด
๋๋ค.
```
let a = [];
let b = [];
for (let i = 0; i<groups.length; i++) {
a.push(groups[i][0]);
b.push(groups[i][1]);
}
teams = [a,b]
```
|
code-web
| 60
|
y = pd.DataFrame(cancer_data.target, columns = ['result']) ์์ class ๋์ result ์ฌ์ฉ ํด๋ ๊ฐ์ ๊ฐ์ด ๋์ค๋๋ฐ ์ด์ ๊ฐ ๋ญ๊ฐ์?
```
y = pd.DataFrame(cancer_data.target, columns = ['result'])
y = pd.DataFrame(cancer_data.target, columns = ['class'])
```
์ฐจ์ด์ ์ด ๋ญ๊ฐ์?
|
code-web
| 61
|
ํ๋ ธ๋ค๋๋ฐ ์ ํ๋ฆฐ์ง ๋ชจ๋ฅด๊ฒ ์ด์
์ ํ๋ฆฐ๊ฑด์ง ์ ๋ชจ๋ฅด๊ฒ ์ด์
```
// ์ซ์ํ๊ณผ ๋ฌธ์์ด ์ฌ๋ฃ
let material1 = 3;
let material2 = '3';
let material3 = 10;
let material4 = '4';
let material5 = 4;
// ์ฐ์ฐ ๊ฒฐ๊ณผ
let result1;
let result2;
// ์ฐ์ฐ์ ํตํด result1์ ๋ฌธ์์ด '34'๋ฅผ, result2์ ์ซ์ํ 34๋ฅผ ๋ง๋ค์ด ๋ฃ์ด์ฃผ์ธ์.
// ์ฝ๋๋ฅผ ์์ฑํด์ฃผ์ธ์.
result1 = material2 + material4;
result2 = String(material1) + String(material5)
// ํ
์คํธ ์ฝ๋
console.log(result1);
console.log(typeof result1);
console.log(result2);
console.log(typeof result2);
```
|
code-web
| 62
|
mysql-installer๊ฐ ์๊ณ .. ๊ทธ๋ฅ ์์ถํ์ผ(zip)ํํ๋ก ๋ฐ์์ง๊ณ , ์์ถ์ ํธ๋ ์ค์น๊ฐ ๋๋ฏํ ๋ชจ์ต์
๋๋ค....
window ์ฌ์ฉ์์ธ๋ฐ... MySQL ์ค์น๋ฅผ ๋ค์ด ๋ฐ์ผ๋...
์ธ์คํจ๋ฌ ํํ๊ฐ ์๋๋ผ... zipํ์ผ ํํ๋ก ๋ค์ด๋์๊ณ ...
์์ถ์ ํธ๋... ๊ทธ๋ฅ ์ค์น๊ฐ ๋ ๋ชจ์ต์ธ๋ฐ์.
์ด๋ฌ๋ฉด... installer์ ์ค์น๊ณผ์ ์์ ํ์ํ ์ฌ๋ฌ ์์
๋ค์ ์ํํ ์ ์์ต๋๋ค...
|
code-web
| 63
|
jupyter notebook ์ด ๊ฐํน ์๋์ด ์ ๋๋ก ์๋๋ ๋ฏํด์....
์ง๋๋ฒ์ ์ค์ตํ ๋๋ ์ ๋์๋๋ฐ....
์๋์ df.loc[2017].plot(kind = 'pie') ๋ฌธ์ฅ ๋์ ์
df.plot(kind = 'pie', y = 2017) ๋ ์คํํด ๋ณด๋ คํ๋... ์๋ฌ๊ฐ ๋์์,
๋ค์ ์๋์ ๋ฌธ์ฅ์ ์คํํด ๋ณด๋ ค ํ๋, ์ด๊ฒ์ด ์๋ฌ๊ฐ ๋์ต๋๋ค.
์ฒ ์๋ฑ ์๋ชป ์ด ๊ฒ์ ์๋ ๊ฒ ๊ฐ์๋ฐ....
```
import pandas as pd
import seaborn as sns
df = pd.read_csv('broadcast.csv')
df.loc[2017].plot(kind='pie')
```
์๋ฌ๋ด์ฉ.
```
ValueError
Traceback (most recent call last)
File ~\AppData\Local\Programs\Python\Python310\lib\site-packages\pandas\core\indexes\range.py:385, in RangeIndex.get_loc(self, key, method, tolerance)
384 try:
--> 385 return self._range.index(new_key)
386 except ValueError as err:
ValueError: 2017 is not in range
The above exception was the direct cause of the following exception:
KeyError Traceback (most recent call last)
Cell In [43], line 5
2 import seaborn as sns
4 df = pd.read_csv('broadcast.csv')
----> 5 df.loc[2017].plot(kind='pie')
File ~\AppData\Local\Programs\Python\Python310\lib\site-packages\pandas\core\indexing.py:967, in _LocationIndexer.__getitem__(self, key)
964 axis = self.axis or 0
966 maybe_callable = com.apply_if_callable(key, self.obj)
--> 967 return self._getitem_axis(maybe_callable, axis=axis)
File ~\AppData\Local\Programs\Python\Python310\lib\site-packages\pandas\core\indexing.py:1205, in _LocIndexer._getitem_axis(self, key, axis)
1203 # fall thru to straight lookup
1204 self._validate_key(key, axis)
-> 1205 return self._get_label(key, axis=axis)
File ~\AppData\Local\Programs\Python\Python310\lib\site-packages\pandas\core\indexing.py:1153, in _LocIndexer._get_label(self, label, axis)
1151 def _get_label(self, label, axis: int):
1152 # GH#5667 this will fail if the label is not present in the axis.
-> 1153 return self.obj.xs(label, axis=axis)
File ~\AppData\Local\Programs\Python\Python310\lib\site-packages\pandas\core\generic.py:3864, in NDFrame.xs(self, key, axis, level, drop_level)
3862 new_index = index[loc]
3863 else:
-> 3864 loc = index.get_loc(key)
3866 if isinstance(loc, np.ndarray):
3867 if loc.dtype == np.bool_:
File ~\AppData\Local\Programs\Python\Python310\lib\site-packages\pandas\core\indexes\range.py:387, in RangeIndex.get_loc(self, key, method, tolerance)
385 return self._range.index(new_key)
386 except ValueError as err:
--> 387 raise KeyError(key) from err
388 self._check_indexing_error(key)
389 raise KeyError(key)
KeyError: 2017
```
|
code-web
| 64
|
๋ก์ง์คํฑ ํ๊ท์์ ์์ฑ์ด 2๊ฐ ์ด์์ผ ๊ฒฝ์ฐ decision boundary์ ์ฐจ์
๋ก์ง์คํฑ ํ๊ท์์ ์์ฑ์ด 2๊ฐ ์ด์์ผ ๊ฒฝ์ฐ decision boundary๋ฅผ ๊ทธ๋ฆด ์ ์๋ค๊ณ ๋ฐฐ์ ๋๋ฐ์
์์ฑ์ด 3๊ฐ์ผ ๊ฒฝ์ฐ 2์ฐจ์ํ๋ฉด์์, 3๊ฐ์ผ ๊ฒฝ์ฐ 3์ฐจ์ ํ๋ฉด์์ ๊ทธ๋ฆด ์ ์์ํ
๋ฐ
๊ทธ decision boundary๋ ์์ธ์์ด ๊ฐ ์์ฑ์ ์ ํ ๊ฒฐํฉ์ธ๊ฐ์ ์๋๋ฉด ๋ค๋ฅธ ํจ์์ ํํ๋ ๋ ์๊ฐ ์๋๊ฑด๊ฐ์~?
๊ฐ์์๋ฃ์๋ ๋ชจ๋ ์ ํ๊ฒฐํฉ์ฒ๋ผ ํํ์ด ๋์ด ์์ด์์~
|
code-web
| 65
|
๋น๋๊ธฐ ์คํ ์์ ๊ด๋ จํด์ ์ง๋ฌธ
์ด ์ฝ๋์์ P ํ๋ก๋ฏธ์ค ๊ฐ์ฒด๋ฅผ ์์ฑํ ๋ setTimeout ํจ์๋ฅผ ์จ์ 1์ด ๋ค์ processedUserList ๊ฐ ๊ฐ์ฒด์ ๊ฐ์ผ๋ก ๋ฐํ๋๊ฒ ์ค์ ํ์์์?
setTimeout์ ๋น๋๊ธฐ๋ผ์ return p ๋ฅผ ํ ๋ undefined๋ฅผ ๋ฐํํ ์ค ์์๋๋ฐ processedUserList๋ฅผ ์ ์ ๋ฌํ๋๋ผ๊ตฌ์.
๊ทธ ์ด์ ๊ฐ setTimeout์ด ๋์์๋ฃ๋๊ธฐ ์ ๊น์ง๋ p ํ๋ก๋ฏธ์ค ๊ฐ์ฒด ์ ์ธ๋ฌธ์ด ๋๋์ง ์์๋ค๊ณ ํ๋จ๋์ ๊ทธ๋ฐ๊ฐ์?
์ ๊ฐ ์ ์ดํดํ๊ฑด์ง ๋ชจ๋ฅด๊ฒ ๋ค์.
```
function removeUnnecessaryInfo(users) {
const processedUserList = users.map((user) => {
const keys = Object.keys(user);
const processedUser = {};
keys.forEach((key) => {
if (key === 'name' || key === 'email') {
processedUser[key] = user[key];
}
});
return processedUser;
});
const p = new Promise((resolve) => {
setTimeout(() => { resolve(processedUserList); }, 1000);
});
return p;
}
```
|
code-web
| 66
|
์ ์ํ, ์์ํ, ์ฌ์น์ฐ์ฐ์ด ์ค์ ํ๋ก๊ทธ๋๋ฐ์์๋ ๋ง์ด ์ฌ์ฉ๋๋์?
์ฌ์น์ฐ์ฐ์ ์ฌ์ฉํ๊ฒ ๋๋ ์ผ์ด ์ค์ ์์๋ ๋ง์ด ์๋์?
๊ทธ๋ฆฌ๊ณ ๊ณ์ฐ๊ธฐ๋ฅผ ์ ์ธํ๊ณ ์ค์ํ์์ ์น์ํ๊ฒ ์ฌ์ฉ๋๋ ํ๋ก๊ทธ๋จ(๊ฒ์์ด๋ ์๋, ์์ฉํ๋ก๊ทธ๋จ ๋ฑ) ์ค์์ ์ฌ์น์ฐ์ฐ์ด๋ ์ ์ํ/์์ํ ๊ฐ๋
์ด ์ค์ํ๊ฒ ์ฌ์ฉ๋๋ ์์๊ฐ ์์๊น์?
|
code-web
| 67
|
throw new Error์ ๊ดํด์.
๋ง์ฝ url์ ์ฃผ์๊ฐ https://learn.codeit.r/8420/foods?${query} ์ ๊ฐ์ด ์๋ชป๋ url๋ฅผ ์์ฑํ๋ฉด
ํ๋ฉด์ ๋ ๋๋ง ๋๋ ์๋ฌ ๋ฉ์ธ์ง๊ฐ '๋ฐ์ดํฐ๋ฅผ ๋ถ๋ฌ์ค๋๋ฐ ์คํจํ์ต๋๋ค' ๊ฐ ์๋๋ผ 'failed to fetch' ๋ผ๊ณ ๋น๋๋ค.
๊ทธ๋ฐ๋ฐ https://learn.codeit.kr/8420abd/foods?${query} ์ ๊ฐ์ด ๋ค๋ฅธ ๋ถ๋ถ์ ๋ฐ๊พธ๋ฉด
'๋ฐ์ดํฐ๋ฅผ ๋ถ๋ฌ์ค๋๋ฐ ์คํจํ์ต๋๋ค.' ๋ผ๊ณ ์ ์์ ์ผ๋ก ๋น๋๋ค.
์ ์ด๋ฐ ์ฐจ์ด๊ฐ ๋ฐ์ํ๋์??
```
export async function getFoods({ order = "", cursor = "", limit = 10 }) {ย
const query = `order=${order}&cursor=${cursor}&limit=${limit}`;ย
const response = await fetch(`https://learn.codeit.kr/8420/foods?${query}`);ย
if (!response.ok) {
ย ย throw new Error("๋ฐ์ดํฐ๋ฅผ ๋ถ๋ฌ์ค๋๋ฐ ์คํจํ์ต๋๋ค.");
ย }ย
const body = await response.json();ย
return body;
}
```
|
code-web
| 68
|
์ฝ๋ฉํธ ๋จ์ถํค๊ฐ ๋๋ค๊ฐ ๋ค์ ํ๋ ค๋๊น ์๋ฉ๋๋ค.
์ฝ๋ฉํธ ๋จ์ถํค๊ฐ ์์จ์ง๋๋ค. ๊ทธ๋ฅ /์ผ๋ก ์์ฑ๋ฉ๋๋ค.
|
code-web
| 69
|
๋น ํ๋ผ๋ฏธํฐ ํจ์๋ฅผ ๋ณ์๋ก ๋ฐ์๋๋ฐ ํ๋ผ๋ฏธํฐ๊ฐ ์๋ ์ด์ ๊ฐ ๊ถ๊ธํฉ๋๋ค
useTranslate.js์ useTranslate()๋ฅผ ReviewList.js์์ const t๋ก ๋ฐ์ ํ
๋ฒํผ ์์์ ๊ธ ๋ถ๋ถ์ ์์ ํ ๋ t(KEY)์ ํํ๋ก ํ์
จ๋๋ฐ,
์ด๊ฒ ์ ๋ useTranslate() ๋ด๋ถ์
```
const translate = (key) => dict[locale][key] || "";
return translate;
```
์ด ์ฝ๋์ ์ฐ๊ดํ์ฌ key๋ฅผ ๋๊ฒจ์ฃผ๊ธฐ ์ํด t(KEY)์ ํํ๋ก ์์ฑ์ ํ๊ฑฐ๋ผ๊ณ ์ดํดํ๋๋ฐ ๋ง๋๊ฑด๊ฐ์?
๊ทธ๋ฆฌ๊ณ t(KEY)์ ๊ด๋ จํ์ฌ useTranslate.js ์์ ํจ์ ์ ์ธ์์ useTranslate(key)๋ผ๊ณ ํด๋ ์๊ด์๋ ๊ฒ์ธ๊ฐ์?
|
code-web
| 70
|
ํด์ฆ 2๋ฒ์ 4๋ฒ ๋์ค์ด ๋ณด๊ธฐ์ ๋ํ ์ง๋ฌธ์ด ์์ต๋๋ค.
๋ณด๊ธฐ 4๋ฒ์ ํด์ฆ ํด์ค์ ๋ํด ์๋ฌธ์ ์ด ์์ด์ ์ง๋ฌธ ๋๋ฆฝ๋๋ค.
'๋ชจ๋ ํ์ดํ ํจ์๋ ์ต๋ช
์ด๋ผ์ ๋ณ์์ ํ ๋นํ๊ฑฐ๋ ๋ค๋ฅธ ํจ์๋ฅผ ํธ์ถํ ๋ ์๊ท๋จผํธ๋ก ์ฌ์ฉ๋๋ค' ๋ผ๋ ๋ง์ด ๋ช
ํํ ์ดํด๊ฐ ์๋๋๋ฐ์.
์ ๊ฐ ์ด๋ ดํ์ด ์ดํดํ ๋ฐ๋ก๋ ํจ์ ์์ฒด์ ์ด๋ฆ์ด ์๊ธฐ ๋๋ฌธ์ ์๋ก์ฐ ํจ์๋ ํธ์ถ๋ ์๊ท๋จผํธ๋ฅผ ํ์ฉํด (argument1, argument2, ...); ์ฒ๋ผ ์ฐ๋ฉด ๋๋ค๋ ๊ฑด๊ฐ์?
```
const printArguments = (value) => console.log(value);
const example1 = (value); /* example1์ด๋ผ๋ ๋ณ์์ (value) ์ฆ, printArguments ํจ์ ํ ๋น */
```
๋๋
```
const addArguments = (value1, value2) => console.log(value1+value2);
const example2 = (value1, value2); /* example1์ด๋ผ๋ ๋ณ์์ (value1, value2) ์ฆ, printArguments ํจ์ ํ ๋น */
```
์ ๊ฐ ์ดํดํ ๊ฒ์ ๋ฐํ์ผ๋ก ํจ์ ์ ์ธ๊ณผ ๋ณ์ ํ ๋น ์ฝ๋๋ฅผ ์ ์ด๋ณด์๋๋ฐ ์์ ์๊ฐ ์ ํํ ์ดํดํ ๊ฒ์ธ์ง ์๊ณ ์ถ์ต๋๋ค. ์์งํ ์ ํํ ์ดํดํ์ง ๋ชปํ ๊ฒ ๊ฐ์์ ์ ํํ ํ๊ธฐ์ ์ฌ์ฉ์ด ์ด๋ป๊ฒ ๋๋ ์ง ์๊ณ ์ถ์ต๋๋ค.
|
code-web
| 71
|
const { reviews } ๋ก ํ๋ ์ด์
์ฌ๊ธฐ์ const reviews = await getReview(); ๊ฐ ์๋๋ผ ์ค๊ดํธ๋ฅผ ์ฌ์ฉํ๋ ์ด์ ๊ฐ getReview๊ฐ json ๊ฐ์ฒด๋ฅผ ๋ฆฌํดํด์ ๊ทธ๋ฐ๊ฑด๊ฐ์?? ๋ฐ๋ผ์ Destruturing ๋ฌธ๋ฒ์ ์ด๊ฑด๊ฐ์?
์ค๊ดํธ๋ฅผ ๋นผ๋ฉด ๋ถ๋ฌ์ค๊ธฐ ๊ธฐ๋ฅ์ด ๋จนํต์ด ๋๋๋ฐ reviews๊ฐ json ๊ฐ์ฒด๋ฅผ ์ ์ฅํ๋ค ์๊ฐํ๋ฉด ์ ์์ ์ผ๋ก ์๋๋์ผํ๋ค๊ณ ์๊ฐํ์ต๋๋ค... ์ด๋ค ์ ์ ๋์น๊ณ ์์๊น์? ใ
ใ
```
const handleLoadClick = async () => {ย ย
const { reviews } = await getReviews();ย ย
setItems(reviews);ย
};
```
|
code-web
| 72
|
formdata๋ฅผ ์ถ๊ฐํ์
จ๋๋ฐ
์ ๋ฆฌ๋ทฐ ๋ด์ฉ์ ์ถ๊ฐํ๊ณ , formdata.append ๋ ํ์
จ๋๋ฐ ์ ๋ฆฌ๋ทฐ๊ฐ ๋ง์ง๋ง ์์น๊ฐ ์๋๋ผ ์ ์ ์ผ ์ฒ์์ผ๋ก ์ค๊ฒ ๋๊ฑด๊ฐ์?
|
code-web
| 73
|
index ์๋ฃํ๊ณผ list์๋ฃํ์ด ๋ค๋ฅธ ๊ฑด๊ฐ์?
์๋ ๋ด์ฉ์ ๋ณด๋ฉด,
์ธ๋ฑ์ค ์๋ฃํ์ ๋ฆฌ์คํธ ์๋ฃํ์ผ๋ก ๋ณํ์์ผ์ ํ์ฉํ ๊ฒ ๊ฐ์ต๋๋ค.
๋๋ค ๋ฆฌ์คํธ์๋ฃํ [ , , , , , ] ํํ์ด๋๋ฐ... ๋ค๋ฅธ ๊ฑด๊ฐ ๋ณด์ฃ ?
```
course_counts[course_counts < 5].index
list(course_counts[course_counts < 5].index)
```
|
code-web
| 74
|
foreign key Textํ์์ผ๋ก๋ ๋ถ๊ฐ๋ฅ?
foreign key Textํ์์ผ๋ก๋ ๋ถ๊ฐ๋ฅํ๊ฐ์?
|
code-web
| 75
|
ํจ์๋ช
๊ท์น ์ค๋ช
๋ถํ๋๋ ค์ . vs _
ํจ์๋ช
๊ท์น ์ค๋ช
๋ถํ๋๋ ค์ .
data.shape vs. feature_name
ํจ์๋ช
์์ ์ธ์ .์ ์ฌ์ฉํ๊ณ ์ธ์ _๋ฅผ ์ฌ์ฉํ๋์?
๊ทธ๋ฅ ์์์ผ ํ๋ ๊ฑด๊ฐ์?
boston_dataset.data.shape
bost_dataset.feature_name
|
code-web
| 76
|
js - [ํฐ๋ฆฐ๋๋กฌ] ๋ฌธ์ ์์ return ๋ฌธ์ ์์น
์ฐ์ , ์ด ๋ฌธ์ ์ ์ ๋ต ์ฝ๋๊ฐ ๋ค์๊ณผ ๊ฐ์๋๋ฐ์,
```
function isPalindrome(word) {
let last = word.length;
for (i = 0; i <= Math.floor(last / 2); i++) {
if (word[i] !== word[last - i - 1]) {
return false;
}
}
return true;
}
```
์ ๋ ์ฝ๋๋ฅผ ๋ค์๊ณผ ๊ฐ์ด ์์ฑํ์์ด์.
```
function isPalindrome(word) {
let last = word.length;
for (i = 0; i <= Math.floor(last / 2); i++) {
if (word[i] !== word[last - i - 1]) {
return false;
} else {
return true;
}
}
}
```
์ด์ ๋ if๋ฌธ์ ์ธ ๋์๋ '~์ด๋ฉด' ๋ถ๋ถ์ if๋ก ์ฐ๊ณ '๊ทธ๋ ์ง ์์ผ๋ฉด~' ๋ถ๋ถ์ else ๋ก ์ฐ๋ผ๊ณ ๋ฐฐ์ ๊ธฐ ๋๋ฌธ์ด์์.
๊ทธ๋ฐ๋ฐ ์ ๋ต ์ฝ๋์๋ else ๋ถ๋ถ์ด ์๊ณ ๊ทธ๋ฅ if ๋ฌธ๊ณผ for ๋ฌธ ๋ฐ์ return true ๊ฐ ์์ด์
์ด๋ ๊ฒ ์จ์ผ ํ๋ ์ด์ ๊ฐ ๊ถ๊ธํฉ๋๋ค.
์ด์ ๋ํด์ ์์ ๋ค๋ฉด ์ค๋ช
ํด์ฃผ์๋ฉด ๊ฐ์ฌํ๊ฒ ์ต๋๋ค..!
|
code-web
| 77
|
def ์ while์ ์จ์ ํผ๋ณด๋์น๋ฅผ ์์ฑํ๊ณ ์ถ์ด์
50๊ฐ์ ํญ์ ์ถ๋ ฅํ๋
n์ด 2๋ณด๋ค ์์ ๋ 1์ ์ถ๋ ฅํ๊ณ
n์ด 2๋ณด๋ค ํด ๋๋ f(n) = f(n-2) + f(n-1) ๋ก ์ซ์๋ฅผ ์ถ๋ ฅํ๋ ์ฝ๋๋ฅผ ์ง๊ณ ์ถ์ด์.
์ด๋ ๋ถ๋ถ์ ์ด๋ป๊ฒ ์์ ํ๋ฉด ์ด ์ฝ๋๊ฐ ์ ๋๋ก ์คํ๋ ์ ์์๊น์?
```
i = 1
n = 1
def f(n):
while i <= 50:
if n < 2:
print(f(n))
elif:
f(n) = f(n-2) + f(n-1)
print(f(n))
n += 1
i += 1
```
|
code-web
| 78
|
ubuntu cal ์ด ์๋ผ์
date ๊น์ง๋ ์ ๋๋๋ฐ, cal ์ ์ฐ๋๊น
```
Command 'cal' not found, but can be installed with:
sudo apt install ncal
```
๋ผ๋ ๋ฌธ๊ตฌ๊ฐ ๋ ์ ์ฐ๋ถํฌ์ sudo apt install ncal ์ ์
๋ ฅํ๋๋ ncal ์ ์ฐพ์ ์ ์๋์.. ์ด๋ป๊ฒ ํด์ผํ์ฃ ?
|
code-web
| 79
|
์ฌ์ ๋ค์ง๊ธฐ reversed_vocab ๋ณ์ ์ฌ์ฉ ์ด์
ํ-์์ผ๋ก ๋ค์งํ ์ฌ์ ์ถ๋ ฅ ์
reverse_dict(vocab) ํจ์๋ฅผ reversed_vocab ๋ผ๋ ๋ณ์์ ์ง์ ํด์ฃผ๋ ์ด์ ๊ฐ ์๋์?
format ๋ฉ์๋๋ f-string ๋ฐฉ์ ๋ชจ๋ ๊ทธ๋ฅ ํจ์ ์์ฒด๋ฅผ ๋์
ํด๋ ๋ต์ด ๊ฐ๊ฒ ๋์ค๋ ๊ฒ ๊ฐ์๋ฐ
๋ณ์๋ฅผ ์ฌ์ฉํ ํน๋ณํ ์ด์ ๊ฐ ์๋์ง ๊ถ๊ธํฉ๋๋ค.
```
# ๋ณํ๋ ๋จ์ด์ฅ ์ถ๋ ฅ
print(โํ-์ ๋จ์ด์ฅ\n{}โ.format(reverse_dict(vocab)))
print(fโํ-์ ๋จ์ด์ฅ\n{reverse_dict(vocab)}โ)
```
|
code-web
| 80
|
for๋ฌธ ์์ //2 ๋ฅผ ๋ฃ๋ ์ด์
๋ค๋ฅธ ๋ต์๊ณผ ๋น๊ตํ์ ๋,
for๋ฌธ์ //2๋ฅผ ๊ตณ์ด ๋ฃ์ด์ ๋ต์ ์ถ๋ฆฌ๋ ์ด์ ๋ ๋ญ๊น์?ใ
//2๋ฅผ ๋ฃ์ ๊ฒฝ์ฐ ์ฝ๋๊ฐ ๋ ๊ธธ์ด์ง๊ฒ ๋๋๊ฒ ์๋๊ฐ์ฉ??
```
# ๋ด ๋ต์
def is_palindrome(word):
for i in range(len(word)):
if word[i] != word[-1-i]:
return False
return True
```
```
# ๋ค๋ฅธ ๋ต์
def is_palindrome(word):
for i in range(len(word)//2):
if word[i] != word[-1 -i]:
right = len(word) -1 -i
if word[i] != word[right]:
return False
return True
```
|
code-web
| 81
|
์๋ฐ์คํฌ๋ฆฝํธ ?? ์ฐ์ฐ์๊ฐ ์๋์ ..? ์ฒ์๋ณด๋๋ฐ..
https://www.codeit.kr/learn/4485 ์ด ๊ฐ์์ ์ฒจ๋ถ๋ ๊ณต์๋ฌธ์ ๋งํฌ(https://developer.mozilla.org/ko/docs/Web/JavaScript/Reference/Operators/Operator_Precedence)์์ ๋ค์๊ฐ์ ์ฝ๋๊ฐ ์๋๋ผ๊ตฌ์ .. and, or ์ฐ์ฐ์๋ ์๊ฒ ๋๋ฐ ๋ฐ์ ๋๊ฐ๋ ๋ญ๊ฐ์? ๊ฒ์ํด๋ ์๋์ค๋๊ฑฐ๊ฐ๋ค์ ..
```
a || (b * c); // `a`๋ฅผ ๋จผ์ ํ๊ฐํ๊ณ , `a`๊ฐ "truthy"๋ผ๋ฉด `a`๋ฅผ ์์ฑํฉ๋๋ค.
a && (b < c); // `a`๋ฅผ ๋จผ์ ํ๊ฐํ๊ณ , `a`๊ฐ "falsy"๋ผ๋ฉด `a`๋ฅผ ์์ฑํฉ๋๋ค.
a ?? (b || c); // `a`๋ฅผ ๋จผ์ ํ๊ฐํ๊ณ , `a`๊ฐ `null`๊ณผ `undefined`๊ฐ ์๋๋ผ๋ฉด `a`๋ฅผ ์์ฑํฉ๋๋ค.
a?.b.c; // `a`๋ฅผ ๋จผ์ ํ๊ฐํ๊ณ , `a`๊ฐ `null`๋๋ `undefined`๋ผ๋ฉด `undefined`๋ฅผ ์์ฑํฉ๋๋ค.
```
|
code-web
| 82
|
headers ์์ = {'':'',}๊ตฌ์กฐ๋ก ๋์ค๋๋ฐ, ์ ๋ค์ ,๊ฐ ๋ค์ด๊ฐ์ผ ํ๋ ๊ฒ์ผ๊น์?
์๋
ํ์ธ์. 11. ํ์ํ ํ์ด์ง๋ง ๊ฐ์ ธ์ค๊ธฐ ์์
์ = {'':'',}์ ๊ตฌ์กฐ์ ๋ค์ ,๊ฐ ๋์์ผ ํ๋์? ์ ๊ฐ ๋นผ๊ณ ์ฐ์ฐํ๋๋ฐ ์๋๊ฐ ์ข ๋๋ ค์ง๋๊ฑฐ ๊ฐ๊ธด ํ๋๋ผ๊ตฌ์...
์๊ณ ๊ณ์ ๋ถ ์๋ ค์ฃผ์ธ์.
```
headers = {
'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 11_2_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.114 Safari/537.36',
}
```
|
code-web
| 83
|
๋๋ฆ๋๋ก์ ์ฝ๋๋ฅผ ์ง๋ดค์ต๋๋ค.
์ข์ ๊ธฐํ๋ก ๊ณต๋ถํ๊ณ ์์ต๋๋ค.
๋ฐฐ์ ๋ ๊ฒ๋ค์ ๋ค์ ์ด์ด๋ณด๋ฉด์ ํ๋ฉด ์๊ฐ์ด ๊ฑธ๋ ค๋
์๊ธฐ ๊ฒ์ด ๋์ด์ ๋์์ด ๋ ๋๋ ๊ฒ ๊ฐ์ต๋๋ค.
```
with open ('vocabulary.txt', 'r', encoding="utf-8") as f:
word = ""
for data in f: # ํ์ผ(f)์ ์ฒซ์ค์ด data์ ์ ์ฅ
word = data.strip().split(": ")
koreanword = str(word[1])
englishword = str(word[0])
quiz = input(f'{koreanword}: ')
if quiz == englishword :
print('๋ง์์ต๋๋ค!')
else :
print(f'์์ฝ์ต๋๋ค. ์ ๋ต์ {englishword}์
๋๋ค.')
```
|
code-web
| 84
|
๊ฐ์ ์ ํ์๋ก ์ด๋ฏธ์ง๋ฅผ ์ ํํ ์ ์๋์?
์๋์ ๊ฐ์ด ๊ฐ์ ์ ํ์๋ฅผ img๋ก ์ง์ ํ์๋๋ ์ฝ๋๊ฐ ์ ์ฉ๋์ง ์๋๋ผ๊ตฌ์! ์ด์ ๊ฐ ์์๊น์?
```
.SNS img:first-child {
margin-right: 50px;
}
```
|
code-web
| 85
|
์ค๋ฅ๊ฐ ๋๋ ์ด์ ๋ฅผ ๋ชจ๋ฅด๊ฒ ์ด์
ํ๊ตญ์ด๋ก ์จ์ ์ค๋ฅ๊ฐ ๋๋๊ฑด๊ฐ์? ์ค๋ฅ๊ฐ ๋๋ ์ด์ ๋ฅผ ๋ชจ๋ฅด๊ฒ ์ด์
```
์ด์์จ = 0.12
2016๋
์๋ง์ํํธ = 1100000000
year = 1988
์ํ์๋ฃ์๋ = 50000000
while year < 2016:
์ํ์๋ฃ์๋ = ์ํ์๋ฃ์๋ * (1 + ์ด์์จ)
year += 1
if ์ํ์๋ฃ์๋ > 2016๋
์๋ง์ํํธ:
print("{}์ ์ฐจ์ด๋ก ๋์ผ ์์ ์จ ๋ง์์ด ๋ง์ต๋๋ค.".format(int(์ํ์๋ฃ์๋ - 2016๋
์๋ง์ํํธ))
else:
print("{}์ ์ฐจ์ด๋ก ๋ฏธ๋ ์์ฃผ๋จธ๋ ๋ง์์ด ๋ง์ต๋๋ค.".format.(int(2016๋
์๋ง์ํํธ - ์ํ์๋ฃ์๋)))
File "main.py", line 2
2016๋
์๋ง์ํํธ = 1100000000
^
SyntaxError: invalid syntax
```
|
code-web
| 86
|
์ด๋ ๊ฒ ํด๋ ์๊ด์๋์ /?
ํ์ค๋ก ๋๋ด๋๊น ํธํ๊ฑฐ ๊ฐ์๋
```
let lyrics = "[์ฌ์]๋์๊ฒ ๋ ํ๊ณ ์ถ์๋ ๋ง ๊ณ ๋ง์ ๋ฏธ์ํด ํจ๊ป ์์ด์ ํ ์ ์์ด์ ์์ ์ ์์ด[์คํ] ์ ๋ง ๊ณ ๋ง์ ์ด ๋ด ์์ ๋์ง ์์์ค์ ํ์ ๋ด๋ณผ๊ฒ ํจ๊ป ์๋ค๋ฉด ๋๋ ต์ง ์์[ํ์ฒ ] ๋ด๊ฐ ๋ ์์ผ๋๊น ๋ด๊ฐ ์ฐ์ต๋ ๋ด ํ์ง๋ง ์์ ๊ฑฐ์ผ ๋ ๋ณด๊ณ ์๋ ๋ ์ข์[๋ช
์] ์๊พธ๋ง ๋๋ง์น๊ณ ์ถ์๋ฐ ์ ํ๋ คํ ํฐ ๋ฌด๋ ์์ ์ค ์ ์์๊น? ์์ ์์ด..[ํํ] ์ง๊ธ๊น์ง ๊ฑธ์ด์จ ์ด ๊ธธ์ ์์ฌํ์ง๋ ๋ง ์๋ชป ๋ ๊ธธ์ด ๋๋ก ์ง๋๋ฅผ ๋ง๋ค์์์[ํ๋] ํผ์ ๊ฑท๋ ์ด ๊ธธ์ด ๋ง๋งํ๊ฒ ์ง๋ง ๋๋ฆฌ๊ฒ ๊ฑท๋ ๊ฑฐ์ผ ์ฒ์ฒํ ๋์ฐฉํด๋ ๋ผ[๊ธธ] ์ ํ ์ ํ์๋ ์น๊ตฌ์ ๋ง๋ ์๋ฏธ ์๋ ์ธ์ฌ์ฒ๋ผ ์ฌํ๊ฒ ๋ค๋ฆด ๋ ๋ ์ฐพ์์";
let hyungdon = null;
// ์ฝ๋๋ฅผ ์์ฑํด ์ฃผ์ธ์.
hyungdon = lyrics.slice(lyrics.indexOf('[ํ๋]'),(lyrics.indexOf('[๊ธธ]')));
// ํ
์คํธ ์ฝ๋
console.log(hyungdon);
```
|
code-web
| 87
|
body: JSON.stringify(newMembers) ์ง๋ฌธ
return newMembers๋ฅผ ํ๋ฉด ์๋์ ๊ฐ์ ๋ฐฐ์ด์ด ๋์ค๋ ๊ฒ์ ์๊ฒ ๋๋ฐ ๋ค์์ then ์ฝ๋๋ก ์๋ฒ์๋ค๊ฐ post์์ฒญํ์ฌ json๊ฐ์ฒด์๋ค๊ฐ stringifyํ์ฌ ๋ถ์ด๋ ๊ณผ์ ์ด ์ดํด๊ฐ ์๋ฉ๋๋ค.
json๊ฐ์ฒด๋ ๋๊ฐ์ ํํ์ธ ๋ฐฐ์ด์ธ ๊ฒ์ ์๊ฒ ๋๋ฐ ์ด๋ค ๋ก์ง์ ์ํด ์ ๊ฐ๋ค์ด ์ถ๊ฐ๊ฐ ๋๊ฑด๊ฐ์?
```
[
{ id: 1012, name: 'Chris', result: 'pass' },
{ id: 1049, name: 'Vivian', result: 'pass' },
{ id: 1103, name: 'Ellen', result: 'pass' }
]
```
```
.then((newMembers) => fetch('https://learn.codeit.kr/api/members', {
method: 'POST',
body: JSON.stringify(newMembers)
})) //(์์ ์ฝ๋๋ก ์ด๋ป๊ฒ json๊ฐ์ฒด์ ์ถ๊ฐํ๊ฑด์ง ๊ถ๊ธ)
```
|
code-web
| 88
|
ํ๋ก์ ํธ ๋ค์ด๋ก๋ ํ ์ ์ปด์์ ์คํํ๋ ค๋ฉด ์ด๋ป๊ฒ ํด์ผ ํ๋์?
ํ๋ก์ ํธ๋ฅผ ๋ค์ด๋ก๋ ํ ๋ค์ ์ด๋ป๊ฒ ํด์ผ ๋๋์ง ๋ชฐ๋ผ์์. VS CODE์์ ํด๋์ฑ๋ก ์ฎ๊ธฐ๋ ๊ฑด๊ฐ์?
|
code-web
| 89
|
๋ณธ๋ฌธ ์ฝ๋ ์ค์ ์ผํ๊ฐ ์๋ ๊ณณ์ด ์๊ณ ์๋ ๊ณณ์ด ์๋๋ฐ
1. latte ๊ฐ์ฒด ํ ๋น๋ถ๋ถ ๋ง์ง๋ง์๋ ์ผํ๊ฐ ์๋๋ฐ cafeMocha ๊ฐ์ฒด์ ๋ง์ง๋ง์๋ ์ผํ๊ฐ ์๋ ์ด์ .
2. latte ๊ฐ์ฒด ํ ๋น๋ถ๋ถ์๋ ์ฝ๋ก ์ด ์๋๋ฐ (ํํ์์ ์ฑ์ง์ ๊ฐ์ ธ์?) cafeMocha ๊ฐ์ฒด ํ ๋น๋ถ๋ถ์๋ ์ฝ๋ก ์ด ์๋ ์ด์ .
์๋ ค์ฃผ์๋ฉด ๊ฐ์ฌํ๊ฒ ์ต๋๋ค. ๊พธ๋ฒ
```
์ฝ๋๋ ์ฌ๊ธฐ ์ฝ๋๋ธ๋ก์ ์
๋ ฅํด ์ฃผ์ธ์.
const latte = {
esspresso: '30ml',
milk: '150ml'
};
const cafeMocha = {
...latte,
chocolate: '20ml',
}
```
|
code-web
| 90
|
ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ ์ข
๋ฅ์ ๋ํ์ฌ
์ง๋ฌธ ๋ด์ฉ์ ์
๋ ฅํด ์ฃผ์ธ์.
C ์๋ฐ ๋ฑ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ฅผ ์๊ฐ์์ผ ์ฃผ์
จ๋๋ฐ HTML ๊ด๋ จ ์ด์ผ๊ธฐ๋ ์๋๋ผ๊ตฌ์ HTML์ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ธ๊ฐ์? ์๋๋ฉด HTML์ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ ํฌํจ๋์ง ์๋์
```
์ฝ๋๋ ์ฌ๊ธฐ ์ฝ๋๋ธ๋ก์ ์
๋ ฅํด ์ฃผ์ธ์.
```
|
code-web
| 91
|
๋ฒ์ ๊ด๋ จ ์ง๋ฌธ - define ํ ์์ญ๊ฐ์ ๋ณ์๊ฐ ์ ๋ฌ
์๋์ ๊ฐ์ด define์ ๋๊ฐ๋ก ํด์ ์ฒ๋ฆฌ๋ฅผ ํ๋๋ฐ
print_change()๋ฅผ ์ํํ๋ฉด์ ๊ณ์ฐ๋ change๊ฐ calculate_change๋ก ๋๊ฒจ์ง์ง๋ฅผ ์์ต๋๋ค.
๋ญ๋ฅผ ์๋ชปํ๊ฑธ๊น์?
```
์ฝ๋๋ ์ฌ๊ธฐ ์ฝ๋๋ธ๋ก์ ์
๋ ฅํด ์ฃผ์ธ์.
change = 0
def calculate_change(payment, cost):
change = payment - cost
print_change(change, 50000)
print(change)
def print_change(change, change_unit):
i,j = divmod(change,change_unit)
change = j
print(change)
print('{}์ ์งํ: {}์ฅ'.format(change_unit, i))
# ํ
์คํธ
calculate_change(100000, 33000)
```
|
code-web
| 92
|
ํ๊ฐ๋ฆฌ๋ค์..๋๋ฌด ๊ถ๊ธํฉ๋๋ค
์ง๋ฌธ ๋ด์ฉ์ ์
๋ ฅํด ์ฃผ์ธ์.
*์ i๋งํผ ๊ณฑํด์ ์ถ๋ ฅํ๊ณ ์ถ์๋ฐ ์ด๋ค ๋ฐฉ์์ผ๋ก ํด์ผ ํ๋์? ๋ฐ์ ๋ฐฉ์์ผ๋ก ํ๋ฉด NaN ์ถ๋ ฅ์ด ๋์์.. ์ด๋ ๊ฒ ํ๋๊ฑด ๋ง๋ ์๋๋ ๊ฑด๊ฐ์?
```
์ฝ๋๋ ์ฌ๊ธฐ ์ฝ๋๋ธ๋ก์ ์
๋ ฅํด ์ฃผ์ธ์.
for(let i = 0; i < height; i++){
console.log('*' * i)
}
```
|
code-web
| 93
|
[JS - ํฐ๋ฆฐ๋๋กฌ ๋ฌธ์ ] ์ ์ฝ๋์์ ํ๋ฆฐ ์ ์ด ๋ญ๊น์
์ ๋ ์ด ๋ฌธ์ ์ ์ฝ๋๋ฅผ
```
function isPalindrome(word) {
let last = word.length;
for (i = 0; i <= Math.floor(last / 2); i++) {
if (word[i] === word[last - i - 1]) {
return true;
} else {
return false;
}
}
}
// ํ
์คํธ ์ฝ๋
console.log(isPalindrome("racecar"));
console.log(isPalindrome("stars"));
console.log(isPalindrome("๊ธฐ๋ฌ๊ธฐ"));
console.log(isPalindrome("123321"));
console.log(isPalindrome("hello"));
console.log(isPalindrome("kayak"));
```
๋ค์๊ณผ ๊ฐ์ด ์์ฑํ์ด์.
( [์ฐธ๊ณ 1] Math.floor(last / 2) ์ ์ฌ์ฉํ ์ด์ : ๋ง์ฝ 5์๋ฆฌ ๋จ์ด๋ผ๋ฉด 2๋ฒ์งธ ๋ฌธ์๊น์ง, 6์๋ฆฌ ๋จ์ด๋ผ๋ฉด 3๋ฒ์งธ ๋ฌธ์๊น์ง, 7๋ฒ์งธ ๋จ์ด์ฌ๋ 3๋ฒ์งธ ๋ฌธ์๊น์ง ๋น๊ตํด์ผ ํ๋ค๊ณ ์๊ฐํ๊ธฐ ๋๋ฌธ์
๋๋ค.
[์ฐธ๊ณ 2] if๋ฌธ์ ๋ํ ์ค๋ช
: ํด๋น ๋ฒ์ ๋ด์์ ๋ชจ๋ ๋ฌธ์ ํน์ ์ซ์๋ฅผ ๋น๊ตํ๋ฉฐ ์ ๋ถ ๋ค ๊ฐ๋ค๋ฉด true๋ฅผ ๋ฐํํ๊ณ ๊ทธ๊ฒ ์๋๋ฉด false๋ฅผ ๋ฐํํ๋ผ๋ ์๋ฏธ๋ก ์ ๋ ๊ฒ ์ผ์ต๋๋ค.)
๊ทธ๋ฐ๋ฐ ๋๋ฒ์งธ ๋จ์ด์ธ 'stars' ๋ง false ๊ฐ ์๋ true ๋ก ํ๋ฆฌ๊ฒ ๋์์ด์.
๊ทธ๋์ ์ ์ฝ๋ ์ค ์ด๋ ๋ถ๋ถ์ด ํ๋ ธ๋์ง ์ ๋งคํ๊ณ ๊ฐ์ด ์ ์์กํ์,, ์ง๋ฌธ์ ๋จ๊น๋๋ค.
ํน์ ์ด์ ๋ํด ์์ ๋ค๋ฉด ์๋ ค์ฃผ์๋ฉด ๊ฐ์ฌํ๊ฒ ์ต๋๋ค !
|
code-web
| 94
|
ํด๋์ค ์๊ณผ ํด๋์ค ๋ฐ์ ์๋ฏธ๊ฐ ๋ญ์ง ๋ชจ๋ฅด๊ฒ ์ด์. ๋๋ฌด ๊ธฐ์ด์ ์ธ ์ง๋ฌธ์ด์ง๋ง...
์บก์ํ์ ๋ํด์ ๋ฐฐ์ฐ๊ณ ์์ต๋๋ค.
Citizen ํด๋์ค๋ฅผ ๋ง๋ค๊ณ , age ๋ณ์์ ๋ํด ํด๋์ค ๋ฐ์์ ์ฌ์ฉํ์ง ๋ชปํ๋๋ก __age ๋ก ๋ง๋ค์๋๋ฐ์.
Citizen ํด๋์ค์ ๊ฒฝ์ฐ
ํด๋์ค๋ณ์ drinking_age
์ธ์คํด์ค ๋ณ์ self.name, self.age ์ ์ธต์ฐจ๋ ์๊ฒ ๋๋ฐ...
์๋ฅผ ๋ค์ด, Citizen.drinking_age, citizen1.name ์ด๋ฐ ์์ผ๋ก ๋ง์ด์ฃ .
๊ทธ๋ฐ๋ฐ, Citizen ํด๋์ค ๋ด์์ ์ ์๋ ํจ์(๋ฉ์๋) ๋ฐ ๋ณ์๋ฅผ ์ฌ์ฉํ๋ค๋ฉด
๊ทธ ๋ณ์์ ๋ฉ์๋๋, 'ํญ์' ๊ทธ๊ฒ์ ์ ์ํ Citizen ํด๋์ค ์์์ ์ฌ์ฉ๋๋ ๊ฒ์ด ์๋๊ฐ์???
ํด๋์ค ๋ฐ์์ ์ฌ์ฉํ๋ค๋ ์๋ฏธ๊ฐ ๋ฌด์์ด๊ณ ,
ํด๋์ค ์์์ ์ฌ์ฉํ๋ค๋ ์๋ฏธ๊ฐ ๋ฌด์์ธ์ง ๊ถ๊ธํฉ๋๋ค.
|
code-web
| 95
|
ํ์ด์ฌ์์ ๋ฌธ์์ด์ name์ผ๋ก ์ธ์ํ๋์?
1. name ์ด๋ผ๋ ๋ณ์๋ฅผ ์ค ์ ์ด ์๋๋ฐ ๊ธฐ๋ณธ์ ์ผ๋ก ํ์ด์ฌ ๋ด๋ถ์์ ๋ฌธ์์ด์ name์ด๋ผ๊ณ ์ธ์ํ ๊ฑด ๊ฐ์?
2. for๋ฌธ ์์ if๋ฌธ์์ if name not in vote_counter ์์ vote_counter ์๋ ์ง๊ธ ์๋ฌด ๋ฌธ์์ด์ด ์๋๋ฐ ์ votes ๊ฐ ์๋ vote_counter ์ธ์ง ์ดํด๊ฐ ์๋ฉ๋๋คใ
ใ
```
# ํฌํ ๊ฒฐ๊ณผ ๋ฆฌ์คํธ
votes = ['๊น์์', '๊ฐ์น๊ธฐ', '์ต๋ง์', '๊น์์', '๊ฐ์น๊ธฐ', '๊ฐ์น๊ธฐ', '์ต๋ง์', '๊น์์', \
'์ต๋ง์', '๊น์์', '์ต๋ง์', '๊น์์', '๊น์์', '์ต๋ง์', '์ต๋ง์', '์ต๋ง์', '๊ฐ์น๊ธฐ', \
'๊ฐ์น๊ธฐ', '๊น์์', '๊น์์', '์ต๋ง์', '๊น์์', '๊น์์', '๊ฐ์น๊ธฐ', '๊น์์']
# ํ๋ณด๋ณ ๋ํ์ ์ฌ์
vote_counter = {}
# ๋ฆฌ์คํธ votes๋ฅผ ์ด์ฉํด์ ์ฌ์ vote_counter๋ฅผ ์ ๋ฆฌํ๊ธฐ
for name in votes:
if name not in vote_counter:
vote_counter[name] = 1
else:
vote_counter[name] += 1
# ํ๋ณด๋ณ ๋ํ์ ์ถ๋ ฅ
print(vote_counter)
```
|
code-web
| 96
|
setter๋ฉ์๋ ์์ฑ์ ๋ฐ๋ฅธ ๊ธฐ์กด์ ํ๋กํผํฐ ์ญ์ ์ฌ๋ถ
(๊ฐ์ ๊ธฐ์ค)
setter ๋ฉ์๋๋ฅผ ์์ฑํ๋ฉด ๊ธฐ์กด์ email ํ๋กํผํฐ๋ ์ญ์ ๋๋ค๊ณ ์ดํดํ๋ฉด ๋๋๊ฑด๊ฐ์?
๊ธฐ์กด์ ํ๋กํผํฐ๋ช
(email)์ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ getter ๋ฉ์๋๋ฅผ ๊ผญ ์์ฑํด์ผํ๋๊ฑด์ง ๊ถ๊ธํฉ๋๋ค.
```
class User {
constructor(email, birthdate) {
this.email = email;
this.birthdate = birthdate;
}
buy(item) {
console.log(`${this.email} buys ${item.name}`);
}
set email(address) {
if (address.includes('@')) {
this._email = address;
} else {
throw new Error('Invalid email address')
}
}
};
```
|
code-web
| 97
|
len(word)//2 ๋ง๊ณ (len(word)-1)/2 ์ฐ๋ฉด ์๋๋ ์ด์
(len(word)-1)/2 ๋ฅผ ์ฌ์ฉํ๋ฉด ์ค๋ฅ๊ฐ ๋จ๋ค์
|
code-web
| 98
|
dictionary ์๋ฃํ์ ์ฌ์ฉํ์ฌ ๋ต์์ ์์ฑํด ๋ณด์์ต๋๋ค.
dictionary ์๋ฃํ์ ์ด์ฉํ์ฌ ๋ต์์ ์์ฑํด๋ณด์์ต๋๋ค.
์ฐธ๊ณ ํด์ฃผ์๊ฑฐ๋ ์๊ฒฌ ์ฃผ์๋ฉด ๊ฐ์ฌํ๊ฒ ์ต๋๋ค.
```
dict = {}
with open("vocabulary.txt", "r") as f:
for lines in f:
str = lines.strip().split(": ")
dict[str[0]] = str[1]
for vocab in dict.keys():
ans = input(f"{vocab}: ")
if ans == dict[vocab]:
print("๋ง์์ต๋๋ค!")
else:
print(f"์์ฝ์ต๋๋ค. ์ ๋ต์ {dict[vocab]}์
๋๋ค.")
```
|
code-web
| 99
|
End of preview. Expand
in Data Studio
README.md exists but content is empty.
- Downloads last month
- -