Prompt:
def f_37146(arr):
	return

import numpy as np

def check(candidate):

    arr = np.array([[1,2],[3,4]])
    assert all(candidate(arr) == np.array([1,3]))

    arr = np.array([[3,4,5]])
    assert all(candidate(arr) == np.array([3]))

2次元配列`arr`の要素となっている1次元配列から先頭の値のみを抜き出す


Prompt:
def f_25263(df):
	return

import pandas as pd

def check(candidate):

データフレームを辞書型オブジェクトに変換する


Prompt:
def f_28178(soup):
	return

from bs4 import BeautifulSoup

def check(candidate):

soup = BeautifulSoup("Address:

My home address

")
    result = candidate(soup)
    assert len(result) == 1
    assert result[0].contents == ['My home address']

HTMLテーブルから各行を取得する


Prompt: def f_8656():

class handler(http.server.BaseHTTPRequestHandler):
	    def do_POST(self):
	        os.environ['REQUEST_METHOD'] = 'POST'
	        form = cgi.FieldStorage(self.rfile, self.headers)

import cgi
import http.server

def check(candidate):

    try:
        handler = candidate()
        srvr = http.server.HTTPServer(('127.0.0.1', 8889), handler)
    except:
        assert False


Prompt:
def f_9836(li):
	return

リスト`li`の中からランダムに一つの要素を選択する


Prompt: def f_1589(d):

X = np.array(d, dtype='float32')
	X.tofile('binaryVec.bin')

import numpy as np

def check(candidate):

    f = open('binaryVec.bin', 'w')
    f.close()

    d = np.array([1., 2., 3.])
    candidate(d)
    d1 = np.fromfile('binaryVec.bin', dtype='float32')
    assert np.all(d == d1)

要素が数値のリスト型データ`d`をバイナリデータ`binaryVrc.bin`として保存する


Prompt: def f_38532(f):

    f = open('tmp.txt', 'w')
    candidate(f)
    assert f.closed

開いているファイル'f'を閉じる


Prompt:
def f_37696(files, url, data):
	return

import requests
from unittest.mock import Mock

def check(candidate):

    r = requests.Response()
    r.status_code = 200
    requests.post = Mock(return_value = r)
    file_path = 'a.txt'
    with open (file_path, 'w') as f:
        f.write('abc')
    files = {'file': open(file_path, 'rb')}
    assert candidate(files, 'https://def.xyz', {'key':'value'}).status_code == 200


Prompt: def f_29368(X, y):

sss = StratifiedShuffleSplit()
	sss.get_n_splits(X, y)

import numpy as np
import sklearn
from sklearn.model_selection import StratifiedShuffleSplit

def check(candidate):

    X = np.array([[1, 2], [3, 4], [1, 2], [3, 4], [1, 2], [3, 4]])
    y = np.array([0, 0, 0, 1, 1, 1])
    assert candidate(X, y).__class__ == sklearn.model_selection._split.StratifiedShuffleSplit

クラス数の比率を保ったままデータを分割する


Prompt:
def f_40699(low, high):
	return

import matplotlib.pyplot as plt

def check(candidate):

y軸のプロットの範囲を下限`low`、上限`high`に設定する


Prompt: def f_11011(fig, onclick):

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

def check(candidate):

グラフ上で選択されたデータの座標を表示する


Prompt:
def f_42344():
	return

    pattern = candidate()
    words = ['あいうえお', '546', 'たぬき', '饅頭', 'abdf', '#%&', '    ']
    ja_words = [pattern.findall(w) for w in words]
    ja_words = [a for jw in ja_words for a in jw]
    assert ja_words == ['あいうえお', 'たぬき', '饅頭']

日本語（ひらがな、カタカナ、漢字）の判別をする正規表現を得る


Prompt:
def f_17145(br):
	return

import mechanize
import urllib.request
from unittest.mock import Mock

def check(candidate):

    br = mechanize.Browser()
    x = urllib.request.urlopen('https://www.wikipedia.org')
    br.submit = Mock(return_value = x)
    assert b'Wikipedia' in candidate(br)

ブラウザオブジェクト`br`からsubmitした際の返り値を読みこむ


Prompt:
def f_38824(data):
	return

import sys
from io import StringIO

def check(candidate):

    stdout = sys.stdout
    s = StringIO()
    sys.stdout = s
    candidate([[1],[2],[3],[4],[5],[6]])
    sys.stdout = stdout
    s.seek(0)
    assert len(s.read()) == 12

タプル`data`を空白区切りで表示する


Prompt: def f_38824(data):

for i in data:
	     print(' '.join(str(j) for j in i))

import sys
from io import StringIO

def check(candidate):

    stdout = sys.stdout
    s = StringIO()
    sys.stdout = s
    candidate([[1],[2],[3],[4],[5],[6]])
    sys.stdout = stdout
    s.seek(0)
    assert len(s.read()) == 12

タプル`data`を空白区切りで表示する


Prompt: def f_38824(data):

for i in data:
	     print(' '.join(map(str, i)))

import sys
from io import StringIO

def check(candidate):

    stdout = sys.stdout
    s = StringIO()
    sys.stdout = s
    candidate([[1],[2],[3],[4],[5],[6]])
    sys.stdout = stdout
    s.seek(0)
    assert len(s.read()) == 12

タプル`data`を空白区切りで表示する


Prompt: def f_35299(n):

	t = 5
	z = tf.constant(0, shape=[n, n], dtype=tf.int32)
	abs = tf.maximum(t, z)
	result = tf.reduce_sum(abs)

import tensorflow as tf

def check(candidate):

assert str(type(candidate(4))).split(' ')[1] == "'tensorflow.python.framework.ops.EagerTensor'>"

`n`×`n`のテンソルの要素のうち0以上の値の和を計算する


Prompt:
def f_38328(df, pat):
	return

import pandas as pd

def check(candidate):

    df = pd.DataFrame({'x': ['車5(0.8km)', '5', '車27(8.6km)']}, index=[1, 2, 3])
    pat = r'車(\d*)'
    ref = df.x.str.extract(pat)
    assert candidate(df, pat).count()[0] == 2

データフレーム`df`の列ラベル`x`の各行のデータに対して正規表現`pat`を適用する


Prompt:
def f_37418(file):
	return

    f = candidate('test.txt')
    assert f.name == 'test.txt'
    assert f.mode == 'w'

ファイル`file`を上書きモードで開く


Prompt:
def f_41200(x_list, y_list):
	return

import matplotlib.pyplot as plt

def check(candidate):

assert isinstance(candidate([1, 3, 5], [2, 4, 6]), list)

データ`x_list`、`y_list`からなるグラフを描画する指定する


Prompt:
def f_43369(a, b):
	return

import numpy as np
import pandas as pd

def check(candidate):

assert candidate([0], [1]).equals(pd.DataFrame([[0], [1]]))

2つのデータフレーム`a`と`b`を行方向に結合する


Prompt:
def f_24438(file):
	return

    with open('test.txt', 'w') as fw:
        fw.write('hello world!')
    fr = candidate('test.txt')
    assert fr.name == 'test.txt'

文字コードをutf-8に指定してファイル`file`を開く


Prompt: def f_10215(file):

with open(file, 'rb') as f:
	    data = f.read()

    with open('tmp.pkl', 'wb') as fw:
        fw.write(b"hello world!")
    assert candidate('tmp.pkl') == b"hello world!"

ファイル`file`をバイナリデータとして開く


Prompt:
def f_18992(x):
	return

    x = [100, 435, 56, 2, 99]
    candidate(x)
    with open('hoge.pkl', 'rb') as fr:
        data = pickle.load(fr)
        assert data == x

オブジェクト`x`をファイル`hoge.pkl`に保存する


Prompt:
def f_38400(df, change_dict):
	return

import pandas as pd

def check(candidate):

    df = pd.DataFrame({'kai': ['2', 'B1', '23-49', 'M2']}, index=[1, 2, 3, 4])
    change_dict = {'2': '22', 'B1': 'B2'}
    assert candidate(df, change_dict).equals(df.replace(change_dict))

データフレーム`df`の複数の異なる要素を辞書型オブジェクト`change_dict`のキーと要素のペアに従って置き換える


Prompt: def f_35793():

data = []
	i = 0
	while(i<100):
	    data.append(pd.read_csv('file_%d.csv'%i))
	    i+=1

import pandas as pd

def check(candidate):

    for i in range(0, 100):
        with open ('file_'+str(i)+'.csv', 'w') as f:
            f.write(str(i))

    assert len(candidate()) == 100

連番になっている100個のCSVファイル'file_%d'をリストに取り込む


Prompt: def f_20549(vectorized):

import os
import numpy
from sklearn.feature_extraction import DictVectorizer

def check(candidate):

    measurements = [
        {'city': 'Dubai', 'temperature': 33.},
        {'city': 'London', 'temperature': 12.},
        {'city': 'San Francisco', 'temperature': 18.},
    ]
    vec = DictVectorizer()
    candidate(vec.fit_transform(measurements))
    assert os.path.exists('my_vector.npy')


Prompt: def f_9518(li):

for i, name in enumerate(li):
	    print(i, name)

    file_name = 'output.txt'
    f = open(file_name, 'w')
    sys.stdout = f
    candidate([1, 3])
    f.close()
    with open (file_name, 'r') as f:
        lines = f.readlines()
        assert lines[0] == '0 1\n'
        assert lines[1] == '1 3\n'

    f = open(file_name, 'w')
    sys.stdout = f
    candidate(['abc', 'def'])
    f.close()
    with open (file_name, 'r') as f:
        lines = f.readlines()
        assert lines[0] == '0 abc\n'
        assert lines[1] == '1 def\n'

リスト'li'のインデックスと要素に繰り返し処理を行って表示する


Prompt:
def f_38760(arr, n):
	return

import numpy
import numpy as np

def check(candidate):

numpy配列`arr`に対して数値`n`より大きい要素の合計及び個数を求めて表示する


Prompt: def f_35102(data):

results = {}
	for item in data:
	    results[item.find('areacode').text] = item.find('prefecture').text

import xml.etree.ElementTree as ET

def check(candidate):

    data_temp = [
        '<?xml version="1.0" encoding="UTF-8" ?><root><areacode>area1</areacode><prefecture>prefecture1</prefecture></root>',
        '<?xml version="1.0" encoding="UTF-8" ?><root><areacode>area2</areacode><prefecture>prefecture2</prefecture></root>'
    ]
    data = []
    for tr in data_temp:
        data.append(ET.ElementTree(ET.fromstring(tr)))

    res = candidate(data)
    assert "area1" in res
    assert "area2" in res
    assert "prefecture1" == res["area1"]
    assert "prefecture2" == res["area2"]

イテラブルオブジェクト`data`の要素から文字列`area_code`と`prefecture`を探し、それぞれキーと要素に持つ辞書`results`を作る


Prompt:
def f_41440(arr_list):
	return

import numpy as np

def check(candidate):

要素がNumPy配列のリスト`arr_list`を2次元のNumPy配列に変換する


Prompt:
def f_35741(soup):
	return

from bs4 import BeautifulSoup

def check(candidate):

soup = BeautifulSoup('
text
')
    assert candidate(soup)[0].contents == ['text']

HTMLをパースしたオブジェクト`soup`からタグ`p`をすべて見つける


Prompt:
def f_40444(df, c_label):
	return

import pandas as pd

def check(candidate):

    df = pd.DataFrame({'利用者ID': [1, 2], 'コンテンツID': ['a', 'b'], '値': [170, 45]})
    c_label = ['利用者ID', 'コンテンツID']
    assert candidate(df, c_label).equals(df.groupby([c_label]).last())

データフレーム`df`の列`c_label`をGroupbyでまとめたデータの最後の行を取り出す


Prompt:
def f_39240(a_list, b_list):
	return

リスト`a_list`の要素の中のリスト`b_list`の要素と一致するものを表示する


Prompt:
def f_39375(dt_s):
	return

from datetime import datetime

def check(candidate):

assert candidate('10OCT2017') == datetime.strptime('10OCT2017','%d%b%Y')

英名の月を含む日付フォーマット'%d%b%Y'の文字列`dt_s`をdatetime型に変換する


Prompt:
def f_38960(n):
	return

数値`n`を分割してリストに格納する


Prompt: def f_33908():

profile = webdriver.FirefoxProfile()
	profile.DEFAULT_PREFERENCES['frozen']['javascript.enabled'] = False
	profile.set_preference("app.update.auto", False)
	profile.set_preference("app.update.enabled", False)
	profile.update_preferences()

import selenium
from selenium import webdriver
from selenium.webdriver.firefox.options import Options

def check(candidate):

    profile = candidate()
    assert profile.__class__ == selenium.webdriver.firefox.firefox_profile.FirefoxProfile


Prompt: def f_33908():

	options = Options()
	options.set_preference('javascript.enabled', False)

import selenium
from selenium import webdriver
from selenium.webdriver.firefox.options import Options

def check(candidate):

    options = candidate()
    assert options.preferences == {'javascript.enabled': False}


Prompt:
def f_19770(s):
	return

assert candidate('1') == True
assert candidate('a') == False

文字列`s`が数を表す文字かどうか判定する


Prompt:
def f_29614():
	return

assert candidate().__class__ == socket.socket


Prompt:
def f_41032(dir):
	return

assert candidate('.') == os.listdir('.')

ディレクトリ`dir`内にあるファイルのリストを取得する


Prompt:
def f_37709(img):
	return

import cv2
import numpy as np

def check(candidate):

    assert candidate(None) == True
    blank_image = np.zeros((10,5,3), np.uint8)
    assert candidate(blank_image) == False

画像`img`が空かどうかを判定する


Prompt: def f_33677(f):

from sympy import Poly, var

def check(candidate):

`x`に関する多項式`f`の各次数の係数を求めてリストにする `coeffs`


Prompt:
def f_37449(a, b):
	return

assert candidate(22, 56678) == 6
assert candidate(0, -1) == 0
assert candidate(1000, 1) == 0
assert candidate(479, 234) == 202

変数`a`と`b`のビット演算


Prompt:
def f_42442():
	return

グローバル変数の一覧を得る


Prompt:
def f_38030(word_list):
	return

from collections import Counter

def check(candidate):

assert candidate(['this', 'is', 'a', 'word', 'List']) == Counter({'List': 1, 'a': 1, 'is': 1, 'this': 1, 'word': 1})

assert candidate(['List']) == Counter({'List': 1})

assert candidate(['this', 'this', 'this', 'this', 'this']) == Counter({'this': 5})

リスト`word_list'内に出現する単語を数える


Prompt: def f_38724(f, g):

def add_functions(f, g):
	    return lambda x: f(x) + g(x)

    def f(x): return x
    def g(y): return 1
    assert candidate(f,g)(f,g)(3) == 4

関数`f`と`g`を受け取って関数同士の和を計算する関数`add_functions`を定義する


Prompt:
def f_22439(obj):
	return

assert candidate('this is a string') == str

オブジェクト`obj`のクラスを得る


Prompt:
def f_22439(obj):
	return

assert candidate('this is a string') == str

オブジェクト`obj`のクラスを得る


Prompt:
def f_39340(url):
	return

    url = "http://www.google.com"
    text = b"google"
    assert text in candidate(url)

指定したURL`url`の内容を表示する


Prompt:
def f_39589(foldername, filename):
	return

assert candidate('folder', 'file') == 'folder/file'

assert candidate('.', 'file') == './file'

フォルダ名`foldername'とファイル名`filename`を結合したパスを得る


Prompt:
def f_23577(ax, l, h):
	return

import matplotlib.pyplot as plt

def check(candidate):

    fig, ax = plt.subplots()
    assert candidate(ax, 10, 100) == (10.0, 100.0)

X軸の範囲を下限`l`と上限`h`に指定する


Prompt:
def f_41087(src, range):
	return

assert candidate(22, 50) == 50
assert candidate(100, 23) == 115
assert candidate(0, 13) == 0
assert candidate(12, 1) == 12
assert candidate(34, 23) == 46

整数`src`を特定の範囲`range`の倍数で切り上げる


Prompt:
def f_41087(src, range):
	return

src if src % range == 0 else src + range - src % range

assert candidate(22, 50) == 50
assert candidate(100, 23) == 115
assert candidate(0, 13) == 0
assert candidate(12, 1) == 12
assert candidate(34, 23) == 46

整数`src`を特定の範囲`range`の倍数で切り上げる


Prompt: def f_40711(n, N):

random_numbers = np.random.rand(n)
	answer = N * random_numbers / np.sum(random_numbers)

import numpy as np

def check(candidate):

    answer = candidate(20, 5)
    assert answer.shape == (20,)
    assert max(answer) < 5

要素数の総和が`N`となる制約の下、`n`次元のランダムベクトル`answer`を生成する


Prompt: def f_40711(n, N):

answer = np.random.dirichlet(np.ones(n)) * N

import numpy as np

def check(candidate):

    answer = candidate(20, 5)
    assert answer.shape == (20,)

要素数の総和が`N`となる制約の下、`n`次元のランダムベクトル`answer`を生成する


Prompt: def f_31924(li):

    li_a = [i for i in range(10)]
    li_a = candidate(li_a)
    assert sorted(li_a) == [i for i in range(10)]

リスト`li`をランダムに並び替える


Prompt:
def f_40343(a, b):
	return

複数のリスト`a`と`b`の直積（デカルト積）を生成し、要素の組み合わせの結果を得る


Prompt:
def f_36217(df, reg):
	return

import pandas as pd

def check(candidate):

    df = pd.DataFrame([['abc def'],['123 567'], ['qqq eee']], columns=['a'])
    reg = r'(.{3})$'
    assert candidate(df, reg).equals(df['a'].str.extract(reg, expand=True))

データフレーム`df`の列`a`を正規表現`reg'で抽出する


Prompt:
def f_27871(factories, shops, costs):
	return

{f+s : cost for ((f,s), cost) in zip(product(factories,shops), costs)}

from itertools import product

def check(candidate):

2つのリスト`factories'と`shops`の要素の組み合わせをキーとし、タプル`costs`各要素を要素等する辞書型オブジェクトを作る


Prompt: def f_27871(factories, shops, cost):

root = [''.join((x, y)) for x, y in itertools.product(factories, shops)]
	d = dict(zip(root, cost))

2つのリスト`factories'と`shops`の要素の組み合わせをキーとし、タプル`costs`各要素を要素等する辞書型オブジェクトを作る


Prompt:
def f_40676(soup):
	return

from bs4 import BeautifulSoup

def check(candidate):

soup = BeautifulSoup('
foo!
')
    res = candidate(soup)
    assert len(res) == 1
    assert res[0].attrs == {'data-locate': 'address'}
    assert res[0].text == "foo!"

キーワード引数として用いる事ができないHTML5のdata-属性、例えば`data-locel`が`address`に一致するものをオブジェクト`soup`から検索する


Prompt: def f_42256(li):

assert candidate(['sda', 'dahkdja', 'uehjkw', 'ebhjda']) == 'sdue'

assert candidate(['happy', 'apple', 'pear', 'pie', 'yummy']) == 'happy'

assert candidate(['a', 'b', 'c', 'd']) == 'abcd'

assert candidate([str(i) for i in range(10)]) == '0123456789'

文字列を要素に持つリスト`li`の頭文字を結合した文字列`s`を得る


Prompt: def f_42256(li):

assert candidate(['sda', 'dahkdja', 'uehjkw', 'ebhjda']) == 'sdue'

assert candidate(['happy', 'apple', 'pear', 'pie', 'yummy']) == 'happy'

assert candidate(['a', 'b', 'c', 'd']) == 'abcd'

assert candidate([str(i) for i in range(10)]) == '0123456789'

文字列を要素に持つリスト`li`の頭文字を結合した文字列`s`を得る


Prompt:
def f_18967(li, i):
	return

assert candidate(['sda', 'dahkdja', 'uehjkw'], "sda") == False

assert candidate(['happy', 'apple', 'pear', 'pie', 'yummy'], "dog") == True

assert candidate([str(i) for i in range(10)], 10) == True

リスト`li`の中に要素`i`が含まれていない条件分岐を行う


Prompt:
def f_37648(req_data):
	return

assert candidate({'test': 'just a test'}) == b'{"test": "just a test"}'

サーバーに送信するデータ`req_data`をUTF-8で符号化する


Prompt:
def f_39502(str):
	return

assert candidate('日 本 語 で 挟 ま れ た 空 白 を 削 除 す る') == '日本語で挟まれた空白を削除する'

文字列`str`内の、日本語で挟まれた空白を削除する


Prompt:
def f_16805(s, n):
	return

assert candidate([1,2,3], 'string') == '[1, 2, 3]string'

文字列の変数`s`と`n`をUTF-8に変換して結合する


Prompt:
def f_40978(M, N):
	return

[x+1 for x in range(M) for y in range(N)]


Prompt:
def f_40978(M, N):
	return


Prompt:
def f_39379(x):
	return

[h.get_height() for h in sns.distplot(x).patches]

import seaborn as sns
import numpy as np
sns.set()
np.random.seed(0)

def check(candidate):

distplotで表示したデータ`x`に関するヒストグラム上のピンの高さをリストとして得る


Prompt: def f_38415():

import matplotlib.pyplot as plt

def check(candidate):

    res_ax = candidate()
    assert res_ax.get_xlim() == res_ax.get_ylim()

グラフの描画範囲`ax`を正方形にする


Prompt:
def f_37757(string):
	return

文字列型変数`string`の値を数値型のインスタンス変数として評価する


Prompt: def f_34422(s_json):

JSONを表す文字列`s_json`から辞書型オブジェクト`d`を得る


Prompt:
def f_27686(soup):
	return

from bs4 import BeautifulSoup

def check(candidate):

soup = BeautifulSoup('
riginsf
')
    soup['a_id'] = 'some value'
    assert candidate(soup) == 'some value'

HTMLパースオブジェクト`soup`の中でHTMLタグの`a_id`の属性値を取得する


Prompt:
def f_41054():
	return

[os.rename(f, f.replace('.dat', '.gui')) for f in os.listdir('.') if not f.startswith('.')]

assert all([((item is None) or item.endswiths('.gui')) for item in candidate()])

カレントディレクトリにある特定の拡張子`.dat`をもつファイルの拡張子を`.gui`にすべて書き換える


Prompt: def f_43303(df):

import pandas as pd

def check(candidate):

データフレーム`df`のインデックスをリセットした新たなデータフレーム`df2`を得る


Prompt:
def f_43322(df):
	return

import io
import pandas as pd

def check(candidate):

時系列データの入ったデータフレーム`df`を1分ごとにリサンプルし、間の値は直前の値で補完する


Prompt:
def f_35683(z):
	return

assert candidate(1.23-0j) == 1.23
assert candidate(1.23+0j) == 1.23
assert candidate(0.0-1j) == 0.0

複素数`z`の実数部のみを得る


Prompt:
def f_41058(iter, r):
	return

イテラブルオブジェクト`iter`の`r`個の要素の組み合わせをリストとして得る


Prompt:
def f_42573(sheet, row, col):
	return

import xlrd
from xlwt import Workbook

def check(candidate):

    file_location = "test.xlsx"

    book = Workbook()
    sheet1 = book.add_sheet('Sheet 1')
    sheet1.write(0, 0, 'A1')
    sheet1.write(0, 1, 'B1')
    sheet1.write(8, 5, "Hello, world!")
    book.save(file_location)

    workbook = xlrd.open_workbook(file_location)
    sheet = workbook.sheet_by_index(0)
    assert candidate(sheet, 0, 0) == "A1"
    assert candidate(sheet, 0, 1) == "B1"
    assert candidate(sheet, 8, 5) == "Hello, world!"

Excelシートオブジェクト`sheet`内の行`row`、列`col`のセルの値を得る


Prompt:
def f_40361(func, args):
	return

    def func1(x, y, z): return x + y + z
    assert candidate(func1, [1,2,3]) == 6

    def func2(a): return 0.8
    assert candidate(func2, ['random']) == 0.8

引数`args`をアンパックして関数`func`に渡す


Prompt:
def f_43333(r, l):
	return

import pandas as pd

def check(candidate):

    r, l = [1,2,3], [4,5,6]
    assert candidate(r, l).equals(pd.DataFrame(data={'range': r, 'result': l}))

列名`range`の要素をリスト`r`、列名`result`の要素をリスト`l`としてデータフレームを作る


Prompt:
def f_11582():
	return

open('C:\\Users\\Documents\\python programs', 'r', encoding='utf-8')

import builtins
from unittest.mock import Mock

def check(candidate):

    with open('a.txt', 'w') as f:
        f.write('t')
    f1 = open('a.txt')
    builtins.open = Mock(return_value = f1)
    assert candidate() == f1


Prompt:
def f_12174():
	return


Prompt:
def f_6225():
	return

    with open('myfile.txt', 'w') as fw:
        for i in range(10): fw.write(f"{i}\n")
    assert candidate() == 10

    with open('myfile.txt', 'w') as fw:
        for i in range(88): fw.write(f"{i}\n")
    assert candidate() == 88

テキストファイル`myfile.txt`の行数を取得する


Prompt:
def f_6225():
	return

    with open('myfile.txt', 'w') as fw:
        for i in range(10): fw.write(f"{i}\n")
    assert candidate() == 10

    with open('myfile.txt', 'w') as fw:
        for i in range(88): fw.write(f"{i}\n")
    assert candidate() == 88

テキストファイル`myfile.txt`の行数を取得する


Prompt:
def f_47199(a):
	return

assert candidate(None) == False
assert candidate(0) == True
assert candidate(0.00) == True
assert candidate([]) == True
assert candidate(102) == True

変数`a`がNoneでない場合に変数を表示する


Prompt: def f_23332(data):

	list = []
	for r in data:
		list.append(', '.join(r))

二次元リスト`list`の中身を全て


Prompt: def f_34431():

f = open('all_names.csv', 'w', encoding='UTF-8')

    f = candidate()
    assert f.name == 'all_names.csv'
    assert f.mode == 'w'
    assert f.encoding == 'UTF-8'


Prompt: def f_33700(list):

	newlist = []
	for s in list:
		if s.endswith('string'):
			newlist.append(s)

assert candidate(['abcstring', 'bbbb', 'fhstringyjn', '1326546']) == ['abcstring']

リスト`list`から条件となる文字列`string`と部分一致する要素を取り出して新しいリスト`newlist`を作る


Prompt: def f_33700(list):

newlist = []
	for s in list:
	    if 'string' in s:
	        newlist.append(s)

assert candidate(['abcstring', 'bbbb', 'fhstringyjn', '1326546']) == ['abcstring', 'fhstringyjn']

リスト`list`から条件となる文字列`string`と部分一致する要素を取り出して新しいリスト`newlist`を作る


Prompt:
def f_27556():
	return

import matplotlib
import matplotlib.pyplot as plt

def check(candidate):


Prompt:
def f_37060(data_frame):
	return

import pandas as pd
from IPython.display import display

def check(candidate):

    df = pd.DataFrame([1, 2, 3])
    try:
        candidate(df)
    except:
        assert False

データフレーム`data_frame`を表示する


Prompt: def f_12310():

table = Texttable()
	print(table.draw())

from texttable import Texttable

def check(candidate):

    try:
        candidate()
    except:
        assert False


Prompt:
def f_19311():
	return

pd.read_csv('arena.txt', header=None, delim_whitespace=True, decimal=',')

import pandas as pd

def check(candidate):

少数点にコンマが使われているファイル`arena.txt`を読み込む


Prompt: def f_42268(json_data):


Prompt: def f_51387():

import numpy as np
from unittest.mock import Mock

def check(candidate):

    np.genfromtxt = Mock(return_value = np.array([[2, 3, 5], [1, 5, 6]]))
    assert candidate().shape == (2, 3)

    np.genfromtxt = Mock(return_value = np.array([['abc'], ['lkm']]))
    assert candidate().shape == (2, 1)


Prompt: def f_38598(df):

df.drop(df.index[df.row == "condition"], inplace=True)

import pandas as pd

def check(candidate):

    df = pd.DataFrame({'row': ['同意します', 'condition', '同意します', '同意しません',]},
    index=[1, 2, 3, 4, ])
    candidate(df)
    assert df.shape == (3, 1)

条件`condition`を満たす行を削除する


Prompt:
def f_20094(list, x, y):
	return

    mat = [[i+j for i in range(2)] for j in range(3)]
    assert candidate(mat, 0, 0) == 0

    mat = [[i+j for i in range(2)] for j in range(3)]
    assert candidate(mat, 2, 1) == 3

二次元リスト`list`内の要素


Prompt: def f_18780(x, y):

for i in range(x):
	  for j in range(y):
	    exec("list_" + str(i) + "_" + str(j) + "= [i, j]")

    try:
        candidate(3, 4)
    except:
        assert False

forループで数字を添字に持つ二次元リスト`list`を生成する


Prompt: def f_19552():

now = datetime.datetime.now()
	file_name = 'file_{0:%Y%m%d-%H%M%S}.txt'.format(now)

    file_name = candidate()
    later_name = 'file_{0:%Y%m%d-%H%M%S}.txt'.format(datetime.datetime.now())
    assert file_name.split('-')[0] == later_name.split('-')[0]

    file_time = int(file_name.split('-')[1].split('.')[0])
    later_time = int(later_name.split('-')[1].split('.')[0])
    assert (later_time - file_time) < 100

ファイル名に現在の日付を入れる


Prompt: def f_38755(x, y):

	a, b = np.polyfit(x, y, 1)
	linear = a * x + b
	img = plt.plot(x, linear,color="black")

import numpy as np
import matplotlib
import matplotlib.pyplot as plt

def check(candidate):

    x = np.linspace(0,1,100)
    y = np.random.rand(100)
    try:
        img = candidate(x, y)
        assert type(img[0]) == matplotlib.lines.Line2D
    except:
        assert False

グラフに線形回帰直線を追加する


Prompt: def f_4556():

class Foo:
	    def whoAmI(self):
	        print( "I am " + self.__class__.__name__)

	Foo().whoAmI()

    f = open('output', 'w')
    sys.stdout = f
    candidate()
    f.close()
    with open ('output', 'r') as f1:
        lines = f1.readlines()
        assert 'I am Foo' in lines[0]

メンバ関数からクラスの名前を取得する


Prompt:
def f_27922():
	return

{"User-Agent": "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:47.0) Gecko/20100101 Firefox/47.0"}

import urllib.request

def check(candidate):

    url = "https://en.wikipedia.org/wiki/List_of_national_independence_days"
    request = urllib.request.Request(url=url, headers=candidate())
    response = urllib.request.urlopen(request)
    assert response.getcode() == 200

ユーザーエージェントをFirefoxに変更する


Prompt:
def f_35394(file):
	return

import pandas as pd

def check(candidate):

    file_name = 'a.csv'
    with open (file_name, 'w') as f:
        f.write('1 2\n')
    df = candidate(file_name)
    assert df.shape == (0, 2)

    with open (file_name, 'w') as f:
        f.write('abc def\nefg hij')
    df = candidate(file_name)
    assert df.shape == (1, 2)

空白で区切られたCSVファイル`file`を読み込む


Prompt:
def f_35394(file):
	return

import pandas as pd

def check(candidate):

    file_name = 'a.csv'
    with open (file_name, 'w') as f:
        f.write('1 2\n')
    df = candidate(file_name)
    assert df.shape == (0, 2)

    with open (file_name, 'w') as f:
        f.write('abc def\nefg hij')
    df = candidate(file_name)
    assert df.shape == (1, 2)

空白で区切られたCSVファイル`file`を読み込む


Prompt: def f_37591(variable, value):

variable = value if variable is None else variable

assert candidate(123, 1) == 123
assert candidate(None, 1) == 1
assert candidate([], 1) == []

変数`variable`に値が入っていない場合のみ値を代入をする


Prompt: def f_37591(variable, value):

variable = value if variable is None else variable

assert candidate(123, 1) == 123
assert candidate(None, 1) == 1
assert candidate([], 1) == []

変数`variable`に値が入っていない場合のみ値を代入をする


Prompt: def f_11601():

import os
from unittest.mock import Mock

def check(candidate):

    os.startfile = Mock()
    try:
        candidate()
    except:
        assert False

Windows上のアプリケーション`app`を実行する


Prompt: def f_26837(number):

	num_list = []
	while number != 0:
		num_list.append(number % 10)
		number //= 10
	num_list.reverse()


Prompt: def f_26837(number):


Prompt: def f_59780():

	def example(a, b): return b
	hello  = tf.constant("Hello")
	f = tf.function(example)
	result = eval(f([], hello))

import tensorflow as tf
from tensorflow.keras.backend import eval

def check(candidate):

定数の評価結果を表示する


Prompt: def f_38276(text):

	pattern = r"([0-9]+)"
	list=re.findall(pattern,text)

assert candidate('fg456fgxnd') == ['456']

正規表現で文字列`text`の中から数値だけを抽出してリスト`list`にする


Prompt: def f_49558(x, y, df):

rp = sns.regplot(x, y, data=df, order=1, line_kws={"color":"indianred"})
	rp.axes.set_ylim(0,)

import pandas as pd
import seaborn as sns

def check(candidate):

    df = pd.DataFrame([[0, 1, 2], [7, 8, 9]])
    rp = candidate(df[0], df[1], df)
    assert 'Axes' in str(type(rp))

y軸の下限値を指定し、上限値は自動にする


Prompt: def f_65284(word, h):

tmp1 = word[:h]
	word = word[h:]
	word.extend(tmp1)

文字列`word`の順番を`h`番目で入れ替える


Prompt: def f_31916(attributes):

for i, attribute in enumerate(attributes):
	    attributes[i] = attribute-1

リスト`attributes`の全要素の数値に対してfor文でマイナス1する


Prompt: def f_31916(attributes):

for i in range(len(attributes)):
	    attributes[i] = attributes[i]-1

リスト`attributes`の全要素の数値に対してfor文でマイナス1する


Prompt: def f_31916(attributes):

attributes = [attribute-1 for attribute in attributes]

リスト`attributes`の全要素の数値に対してfor文でマイナス1する


Prompt:
def f_21171(list):
	return

from collections import Counter

def check(candidate):

    li = [['abc', 'def'], ['hij', 'klm']]
    c = candidate(li)
    assert c.most_common() ==[(('abc', 'def'), 1), (('hij', 'klm'), 1)]

二次元リスト`list`から重複する要素のみ抽出する


Prompt: def f_45204(num_of_file):

data = [None] * num_of_file
	for i in range(num_of_file):
	    with open('data{}.txt'.format(i + 1), mode="r", encoding="utf-8") as f:
	        data[i] = f.read()

    num_of_file = 4
    for i in range(0, num_of_file):
        with open ('data'+str(i + 1)+'.txt', 'w') as f:
            f.write(str(i + 1)+'\n')
    data = candidate(4)
    for i in range(0, num_of_file):
        assert data[i] == str(i + 1)+'\n'


Prompt:
def f_24786(string):
	return

    s = {'mail':'admin@getgo.com', 'password':34}
    assert candidate(s) == b'mail=admin%40getgo.com&password=34'


Prompt: def f_5822(imgAry):

pca = PCA()
	pca.fit(imgAry)
	pca_res = pca.transform(imgAry)
	restoredImgAry = pca.inverse_transform(pca_res)

import numpy as np
from sklearn.decomposition import PCA

def check(candidate):

    imgAry = np.array([[1, 2], [4, 3]])
    assert np.allclose(candidate(imgAry), np.array([[1,2],[4,3]], dtype=float))


Prompt:
def f_42516(fnameF):
	return

plt.savefig(fnameF, dpi=200, bbox_inches="tight", pad_inches=0.1)

import os
import matplotlib.pyplot as plt

def check(candidate):

    candidate('v.jpg')
    assert os.path.exists('v.jpg')

グラフサイズを調整して保存する


Prompt: def f_18685(list):

二次元リスト`list`から空白の要素を削除する


Prompt: def f_18685(list):

for i in range(len(list) - 1, -1, -1):
	  if not list[i]:
	    del list[i]

二次元リスト`list`から空白の要素を削除する


Prompt: def f_34692(json_string):


Prompt: def f_35864(img):

gray_img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
	plt.imshow(gray_img)
	plt.gray()
	plt.show()

import os
import cv2
import numpy as np
import matplotlib.pyplot as plt
from PIL import Image

def check(candidate):

    im = Image.new('RGBA', (200, 200), (255, 255, 255, 255))
    im.save('v.png')
    img = cv2.imread('v.png')
    gray_img = candidate(img)
    cv2.imwrite('v_gray.png', gray_img)
    assert os.path.exists('v_gray.png')

カラー画像`img`をグレースケールで表示する


Prompt:
def f_49478(ticks, labels):
	return

plt.xticks(range(0, len(labels), ticks), labels[::ticks])

import matplotlib.pyplot as plt

def check(candidate):

    ticks = 3
    labels = [1, 4]
    plt = candidate(ticks, labels)
    assert isinstance(plt, tuple)

    labels = ['abc', 'xcv']
    plt = candidate(ticks, labels)
    assert isinstance(plt, tuple)


Prompt: def f_16769(num_of_file):

book_list = []
	for n in range(1, num_of_file + 1):
	    file_name = 'excel_file%d.xls' % (n)
	    book_list.append(xlrd.open_workbook(file_name))

import xlrd
import xlwt

def check(candidate):

    num_files = 3
    for i in range(0, num_files):
        workbook = xlwt.Workbook()
        sheet = workbook.add_sheet('test')
        sheet.write(0, 1, 1)

        workbook.save('excel_file%d.xls' % (i + 1))
    book_list = candidate(num_files)
    for bk in book_list:
        assert isinstance(bk, xlrd.book.Book)

連番になっている`num_of_file`個のExcelファイル`excel_file`をリストに読み込む


Prompt:
def f_2220(dt):
	return

import pytz
import datetime

def check(candidate):

    dt = datetime.datetime.fromtimestamp(123456789.123456, pytz.timezone('America/Los_Angeles'))
    assert candidate(dt) == 123456789.123456


Prompt:
def f_44723(df, col_name, string):
	return

import pandas as pd

def check(candidate):

    df = pd.DataFrame({'name': ['Mr. A', 'Ms. B'], 'age': [30, 23]})
    df_sub = pd.DataFrame({'name': ['Mr. A'], 'age': [30]})
    assert candidate(df, 'name', 'A').equals(df_sub)

行`col_name`に特定の文字列`string`を含む行をデータフレーム`df`から抽出する


Prompt:
def f_46711(list, n):
	return

リスト`list`の末尾から`n`個の要素を取り出す


Prompt:
def f_17648(b_string):
	return

import unicodedata

def check(candidate):

assert candidate(b'example-string') == 'example-string'

Unicodeエスケープされたバイト列`b_string`を文字列に変換


Prompt:
def f_9633(str, old_s, new_s):
	return

assert candidate('mystring', 'my', 'your') == 'yourstring'

文字列`str`内の対象文字列`old_s`を別の文字列`new_s`に置換する


Prompt: def f_37327():

	while True:
		try:
			line = input()
			if line == '':
				break
			else:
				yield line
		except EOFError:
			break

    with open('p.txt', 'w') as f:
        f.write('1\n\n')
    f = open('p.txt')
    sys.stdin = f
    d = candidate()
    print(type(d))
    assert 'generator' in str(type(d))
    sys.stdin = sys.__stdin__

空行が入力されるまで標準入力を受け付ける


Prompt: def f_37831(model, X, Y):

model.fit(X, Y, epochs=200, batch_size=1, verbose=0)

import numpy as np
from tensorflow.keras import *
from tensorflow.keras.layers import *
from tensorflow.keras.optimizers import *

def check(candidate):

    model = Sequential([
        Dense(input_dim=2, units=1), Activation('sigmoid')
    ])
    model.compile(loss='binary_crossentropy', optimizer=SGD(lr=0.1))
    X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
    Y = np.array([[0], [1], [1], [1]])

    try:
        candidate(model, X, Y)
    except:
        assert False

ログを出力せずにモデルの学習を行う


Prompt:
def f_53340(str):
	return

文字列`str`をバイト列


Prompt:
def f_45120(n):
	return

import pandas as pd

def check(candidate):

    df_list = candidate(3)
    assert len(df_list) == 3
    assert all([type(a)==pd.DataFrame for a in df_list])

要素がデータフレームで、要素数`n`のリストを作る


Prompt:
def f_24987(str):
	return

    text = u"名前１　　　名前２　　　名前３　名前４　　　"
    assert candidate(text) == '名前１　名前２　名前３　名前４　'

文字列`str`の中の連続した複数の全角空白を1つの全角空白で置換する


Prompt:
def f_50500(img):
	return

import cv2
from os import path
from PIL import Image

def check(candidate):

    im = Image.new('RGBA', (200, 200), (255, 255, 255, 255))
    im.save('v.png')
    img = cv2.imread('v.png')
    candidate(img)
    assert path.exists('file.jpg')

画像`img`をファイル名`file.jpg`として保存する


Prompt:
def f_41336(a, b):
	return

import numpy as np

def check(candidate):

    arr = np.array([[1,3,-5]])
    arr_1 = np.array([[4],[-2],[-1]])
    assert candidate(np.mat(arr),np.mat(arr_1)) == 3

assert np.array_equal(candidate(np.zeros(shape=(5,2)), np.zeros(shape=(2,5))), np.zeros(shape=(5,5)))

assert np.array_equal(candidate(np.array([[4]]), np.array([[0]])), np.array([[0]]))

行列`a`と`b`の積を計算する


Prompt: def f_48742():

df = pd.read_table('file.txt', header=None, delim_whitespace=True)
	df.to_csv('new_file.csv', index=False, header=False)

import csv
import pandas as pd

def check(candidate):

    with open("file.txt", "w") as text_file:
        text_file.write('''col1 col2 col3
''')
        text_file.write('''1 2 3
''')

    candidate()
    import csv
    file = open('new_file.csv')
    csvreader = csv.reader(file)
    rows = []
    for row in csvreader:
            rows.append(row)

    assert rows[0] == ['col1', 'col2', 'col3'] and rows[1] == ['1', '2', '3']

    with open("file.txt", "w") as text_file:
        text_file.write('''col1
''')
        text_file.write('''1
''')
        text_file.write('''2
''')

    candidate()
    import csv
    file = open('new_file.csv')
    csvreader = csv.reader(file)
    rows = []
    for row in csvreader:
            rows.append(row)

    assert rows[0] == ['col1'] and rows[1] == ['1'] and rows[2] == ['2']

    with open("file.txt", "w") as text_file:
        text_file.write('''col1    col2   col3
''')
        text_file.write('''  1   2  3
''')

    candidate()
    import csv
    file = open('new_file.csv')
    csvreader = csv.reader(file)
    rows = []
    for row in csvreader:
            rows.append(row)

    assert rows[0] == ['col1', 'col2', 'col3'] and rows[1] == ['1', '2', '3']

空白区切りのテキストファイル`file.txt`をコンマ区切りのcsvファイル`new_file.csv`に変換する


Prompt:
def f_35271(n):
	return

数値`n`を文字列に変換する


Prompt: def f_20048(li):

	c = Counter(tuple(x) for x in li)
	result = [list(k) for k,v in c.items() if v >=2]

from collections import Counter

def check(candidate):

2次元リスト`li`内の重複している要素を取り出す


Prompt:
def f_21070(li, li2):
	return

assert candidate(['abc', 'def'], ['abc']) == ['def']

2つのリスト`li`と`li2`を比較し、重複している要素を削除する


Prompt: def f_19098(li):

	result=[]
	li.sort()
	M = len(li) - 1
	for i, e in enumerate(li):
		j = i + 1
		k = M
		while k > j:
			s = li[i] + li[j] + li[k]
			if s == 0:
				result.append([li[i], li[j], li[k]])
				k -= 1
			elif s > 0:
				k -= 1
			else:
				j += 1

    li = [1, -1, 0, 2]
    assert len(candidate(li)) == 1

整数を要素に持つリスト`li'から、合計すると0になる3つの整数を求める


Prompt:
def f_36377(ary):
	return

np.array2string(ary, separator=', ', formatter={'float_kind': lambda x: '{: .4f}'.format(x)})

import numpy as np

def check(candidate):

配列`ary`の各要素にコンマを付けて小数点四桁まで表示する


Prompt:
def f_23839():
	return

import subprocess
from unittest.mock import Mock

def check(candidate):

    subprocess.check_output = Mock(return_value = "Success")
    assert candidate() == "Success"

外部プロセス`cat`を呼び出し、ファイル`file`の中身を読み込む


Prompt:
def f_34981():
	return

import cv2
from os import path
from PIL import Image

def check(candidate):

    im = Image.new('RGBA', (200, 200), (255, 255, 255, 255))
    im.save('file.png')
    img = candidate()
    cv2.imwrite('g.png', img)
    assert path.exists('g.png')

画像'file.png'をグレースケールで読み込む


Prompt:
def f_33506(s):
	return

assert candidate(b'R2Vla3NGb3JHZWVrcw==') == 'GeeksForGeeks'

base64で符号化された文字列`s`ををデコードする


Prompt:
def f_24190(x, y):
	return

import matplotlib.pyplot as plt

def extract_data_from_plot(plot):
    x_plot, y_plot = plot.get_offsets().data.T
    return x_plot, y_plot

def check(candidate):

    x, y = [0, 1, 2], [0, 1, 2]
    plot = candidate(x, y)
    x_plot, y_plot = extract_data_from_plot(plot)
    assert y_plot.tolist(), float(y).tolist()
    assert x_plot.tolist(), float(x).tolist()

    x, y = [10.3, 11.12, 133.44], [4.9, 2.48, 3.67]
    plot = candidate(x, y)
    x_plot, y_plot = extract_data_from_plot(plot)
    assert y_plot.tolist(), float(y).tolist()
    assert x_plot.tolist(), float(x).tolist()

配列データ`x`,`y`の散布図を表示する


Prompt: def f_40646(html):

	soup = bs4.BeautifulSoup(html, 'lxml')
	unorder_list = soup.find_all('ul')
	new_list = []
	for ul_tag in unorder_list:
	    for li in ul_tag.find_all('li'):
	        new_list.append(li.text)

import bs4
import urllib
import ssl

def check(candidate):

    ctx = ssl.create_default_context()
    ctx.check_hostname = False
    ctx.verify_mode = ssl.CERT_NONE
    url = 'https://en.wikipedia.org/wiki/Blue_Moon_of_Josephine'
    html = urllib.request.urlopen(url, context=ctx).read()
    assert 'List of diamonds' in candidate(html)

HTMLファイル`html`内の順序なしリストをpythonのリストとして取り込む


Prompt:
def f_41775(df, col_label):
	return

import pandas as pd
import numpy as np

def check(candidate):

    df1 = pd.DataFrame(data={'CRcode':['Gk125', 'GK126'], 'client name & address':['Jhone', 'Mike']})
    assert candidate(df1, "CRcode").to_dict() == {'CRcode': {}, 'client name & address': {}}

    df2 = pd.DataFrame(data={'CRcode':['598', '2598', '341', '796'], 'client name & address':['random', 'random2', 'random3', 'random4']})
    assert candidate(df2, "client name & address").to_dict() == {'CRcode': {}, 'client name & address': {}}

データフレーム`df`内の列`col_label`が重複している行を抽出する（pandas)


Prompt:
def f_33034(df, col_1, col_2):
	return

    d = {'col_1':[1, 2], 'col_2':[3, 5]}
    df = pandas.DataFrame(data = d)
    x = candidate(df, 'col_1', 'col_2')
    assert str(type(x)).split("'")[1] == 'matplotlib.axes._subplots.AxesSubplot'

データフレーム`df`の列`col_1`と`col_2`についてクロス集計を行った結果を積み上げグラフにする


Prompt: def f_23246(li, v):

ans = []
	for index, value in enumerate(li):
	    if value == v:
	        ans.append(index)

リスト`li`から検索する値`v`に一致する要素のインデックスをすべて取得して表示する


Prompt: def f_23246(li, v):

ans = [ i for i, value in enumerate(li) if value == v]

リスト`li`から検索する値`v`に一致する要素のインデックスをすべて取得して表示する


Prompt:
def f_30088(d, k):
	return

    d = {"a": 1, "b": 2, "c": 3}
    assert candidate(d, "d") == None

辞書型オブジェクト`d`内の存在しない可能性があるキー`k`を削除する


Prompt:
def f_41700(df, col_label):
	return

import pandas as pd

def check(candidate):

データフレーム`df`内の列`col_label`が重複している行を削除する（pandas)


Prompt: def f_30824():

today = datetime.date.today()
	previous_month = today - dateutil.relativedelta.relativedelta(months=1)

import datetime
import dateutil

def check(candidate):

assert candidate() == datetime.date.today() - dateutil.relativedelta.relativedelta(months=1)

今日から一ヶ月前の日付を取得する


Prompt:
def f_42011(str):
	return

assert candidate("  hello  ") == "hello"

assert candidate("  hello world !  ") == "hello world !"

文字列`str`から空白と改行を取り除く


Prompt: def f_23218(data, fs):

	f, t, Sxx = signal.spectrogram(data, fs)
	plot = plt.pcolormesh(t, f, Sxx)

from scipy import signal
import matplotlib.pyplot as plt
import numpy as np

def check(candidate):

    data = np.array([1, 4, 6])
    assert str(type(candidate(data, 1.0))).split(' ')[1] == "'matplotlib.collections.QuadMesh'>"

信号データ`data`をサンプリング周波数`fs`で周波数解析しスペクトログラムを表示する


Prompt:
def f_39255(sjis_str):
	return

    sjis_str = b'Wall'
    assert candidate(sjis_str) == 'Wall'


Prompt: def f_41519(df, col):

import pandas as pd

def check(candidate):

    data = [1, 4, 5]
    df = pd.DataFrame(data, columns=['Vals'])
    candidate(df, 'Vals')
    assert str(type(df['Vals'][0])) == "<class 'str'>"

データフレーム`df`の列`col`を文字列型に変更する