import unittest

class TestStringMethods(unittest.TestCase):

    def setUp(self):
        print ('setUp')

    def tearDown(self):
        print ('tearDown')

    def test_upper(self):
        self.assertEqual('foo'.upper(), 'FOO')

    def test_isupper(self):
        self.assertTrue('FOO'.isupper())
        self.assertFalse('Foo'.isupper())

    def test_split(self):
        s = 'hello world'
        self.assertEqual(s.split(), ['hello', 'world'])
        # check that s.split fails when the separator is not a string
        with self.assertRaises(TypeError):
            s.split(2)

if __name__ == '__main__':
    unittest.main()

@classmethod
def setUpClass(self):
    print ('setUpClass')

@classmethod
def tearDownClass(self):
    print ('tearDownClass')

import unittest

class TestMethods(unittest.TestCase):
    def test_assert_equal(self):
        self.assertEqual(1, 1)

    def test_assert_not_equal(self):
        self.assertNotEqual(1, 2)

    def test_assert_true(self):
        self.assertTrue(True)

    def test_assert_false(self):
        self.assertFalse(False)

if __name__ == '__main__':
    unittest.main()

import unittest

class TestStringMethods(unittest.TestCase):

    def test_upper(self):
        self.assertEqual('foo'.upper(), 'FOO')

    def test_isupper(self):
        self.assertTrue('FOO'.isupper())
        self.assertFalse('Foo'.isupper())

    def test_split(self):
        s = 'hello world'
        self.assertEqual(s.split(), ['hello', 'world'])
        # check that s.split fails when the separator is not a string
        with self.assertRaises(TypeError):
            s.split(2)


if __name__ == '__main__':
    unittest.main()

import unittest

class TestStringMethods(unittest.TestCase):

def test_upper(self):
...

if __name__ == '__main__':
    unittest.main()

def test_upper(self):
    self.assertEqual('foo'.upper(), 'FOOO')

from sklearn.datasets import load_iris
import numpy as np
iris = load_iris()
X = iris.data
from sklearn.decomposition import PCA
pca = PCA()
X_ = (X - X.mean(axis=0))/X.std(axis=0) # 標準化
X_new = pca.fit_transform(X_)
print (pca.explained_variance_)
print (pca.explained_variance_ratio_) # 寄与率
print (pca.components_)
print (X_new[0]) # 変換後データの先頭レコード

class MyPCA:
    def __init__(self):
        pass
    def fit_transform_eig(self, X):
        X = (X - X.mean(axis=0))/X.std(axis=0)
        cov = np.cov(X.T)
        l, v = np.linalg.eig(cov)
        self.explained_variance_ = l # 固有値
        self.explained_variance_ratio_ =  self.explained_variance_ / self.explained_variance_.sum()
        self.components_ = v # 固有ベクトル
        return X.dot(v)

pca = MyPCA()
X_new = pca.fit_transform_eig(X)
print (pca.explained_variance_) # 固有値に相当
print (pca.explained_variance_ratio_) # 寄与率
print (pca.components_) # 固有ベクトルに相当
print (X_new[0])

class MyPCA:
    def __init__(self):
        pass
    def fit_transform_svd(self, X):
        X = (X - X.mean(axis=0))/X.std(axis=0)
        cov = np.cov(X.T)
        U, s, V = np.linalg.svd(cov)
        self.explained_variance_ = s # 特異値
        self.explained_variance_ratio_ =  self.explained_variance_ / self.explained_variance_.sum()
        self.components_ = U # 左特異ベクトル（この場合V.Tも同じ）
        return X.dot(V.T)

pca = MyPCA()
X_new = pca.fit_transform_svd(X)
print (pca.explained_variance_) # 特異値に相当
print (pca.explained_variance_ratio_) # 寄与率
print (pca.components_) # 左特異ベクトルに相当
print (X_new[0])

import asyncio
async def f(n):
  print (n, "start")
  await asyncio.sleep(1)
  print (n, "end")

async def g(n):
  await f(n)

async def h(n):
    loop = asyncio.get_event_loop()
    task = loop.create_task(f(n))
    await task

loop = asyncio.get_event_loop() # イベントループの生成
loop.run_until_complete(f(1)) # コルーチンをイベントループに直接渡す
loop.run_until_complete(g(2)) # コルーチンの内部でawaitコルーチンとしてイベントループに渡す
loop.run_until_complete(h(3)) # タスクとしてイベントループに渡す

import asyncio
async def f(n):
  print (n, "start")
  await asyncio.sleep(1)
  print (n, "end")

async def g():
    loop = asyncio.get_event_loop()
    task1 = loop.create_task(f(1))
    task2 = loop.create_task(f(2))
    await task1
    await task2

loop = asyncio.get_event_loop() # イベントループの生成
loop.run_until_complete(g()) # コルーチンの内部でawaitコルーチンとしてイベントループに渡す

async def g():
    loop = asyncio.get_event_loop()
    task1 = loop.create_task(f(1))
    await task1
    task2 = loop.create_task(f(2))
    await task2

import queue
q = queue.Queue()
for i in range(1,10):
    q.put(i)
K = int(input())
for k in range(K):
    x =q.get()
    last = x % 10
    if last != 0:
        q.put(10*x + last - 1)
    q.put(10*x + last)
    if last != 9:
        q.put(10*x + last + 1)
print (x)

N,K = map(int,input().split())
N = N % K
print (min(N,K-N))

sg.popup('popup')  # Shows OK button
sg.popup_ok('popup_ok')  # Shows OK button
sg.popup_yes_no('popup_yes_no')  # Shows Yes and No buttons
sg.popup_cancel('popup_cancel')  # Shows Cancelled button
sg.popup_ok_cancel('popup_ok_cancel')  # Shows OK and Cancel buttons
sg.popup_error('popup_error')  # Shows red error button
sg.popup_timed('popup_timed')  # Automatically closes
sg.popup_auto_close('popup_auto_close')  # Same as PopupTimed

sg.popup('マスに対する操作を選択してください',custom_text=('open', 'flag'),title='')

layout =  [[sg.Button('0'),sg.Button('1')]]

import PySimpleGUI as sg
from random import randint
import numpy as np
from scipy import signal
MAX_ROWS = MAX_COL = 10
board = [[randint(0,1) for j in range(MAX_COL)] for i in range(MAX_ROWS)]
board = np.zeros(MAX_ROWS*MAX_COL).astype(np.int)
idx = np.random.choice(len(board), 3, replace=False) # 爆弾をランダムに3箇所設置
board[idx] = 1
board = board.reshape(MAX_ROWS, MAX_COL).tolist()
filter = np.array([ # 二次元畳み込みで爆弾の数をカウント
    [1,1,1],
    [1,0,1],
    [1,1,1]
    ])
counter = signal.convolve2d(board, filter, 'full') # 畳み込みとサイズが大きくなるので、
board = counter[1:-1,1:-1] - board　# スライスする。ここでboardを引くことで、爆弾マスは-1になる
print (board)
board = board.tolist()
layout =  [[sg.Button('?', size=(4, 2), key=(i,j), pad=(0,0)) for j in range(MAX_COL)] for i in range(MAX_ROWS)]
window = sg.Window('Minesweeper', layout)
while True:
    event, values = window.read()
    print (event,values)
    if event in (None, 'Exit'):
        break
    select = sg.popup('マスに対する操作を選択してください',custom_text=('open', 'flag'),title='')
    print('select', select)
    if select is 'open':
        window[event].update(board[event[0]][event[1]], button_color=('white','black'))
        if board[event[0]][event[1]]==-1:
            sg.popup("You Lose")
            break
    elif select is 'flag':
        state = window[event].GetText()
        if state == '?':
            window[event].update('F', button_color=('red',None))
        elif state == 'F':
            window[event].update('?', button_color=('white',None))
window.close()

state = window[event].GetText()
if state == '?':
    window[event].update('F', button_color=('red',None))
elif state == 'F':
    window[event].update('?', button_color=('white',None))

from concurrent.futures import ThreadPoolExecutor
import time
def func():
    time.sleep(1)
start = time.time()
with ThreadPoolExecutor(max_workers=4) as e:
    for i in range(8):
        e.submit(func)    
print (time.time()-start)

from concurrent.futures import ProcessPoolExecutor
import time
def func():
    time.sleep(1)
start = time.time()
with ProcessPoolExecutor(max_workers=4) as e:
    for i in range(8):
        e.submit(func)    
print (time.time()-start)

from concurrent.futures import ThreadPoolExecutor
import time
def func():
    s = 0
    for i in range(10000000):
        s += 1
# 逐次処理
start = time.time()
for i in range(8):
    func()   
print (time.time()-start)

# マルチスレッド
start = time.time()
with ThreadPoolExecutor(max_workers=4) as e:
    for i in range(8):
        e.submit(func)    
print (time.time()-start)

# マルチプロセス
start = time.time()
with ProcessPoolExecutor(max_workers=4) as e:
    for i in range(8):
        e.submit(func)    
print (time.time()-start)

from sklearn.datasets import load_iris
import numpy as np
iris = load_iris()
X_org = iris.data
y_org = iris.target
# 問題の簡単化（前回記事を参照）
idx = [y_org != 2] 
X = X_org[idx][:,:2]
y = y_org[idx]

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.2)

from sklearn.linear_model import LogisticRegression
lr = LogisticRegression()
lr.fit(X_train, y_train) # 学習
pred = lr.predict(X_test) # 予測と評価
print (np.mean(pred == y_test)) # 平均正解率