task_id
int64 19.3k
41.9M
| prompt
stringlengths 17
68
| suffix
stringclasses 37
values | canonical_solution
stringlengths 6
153
| test_start
stringlengths 22
198
| test
sequencelengths 1
7
| entry_point
stringlengths 7
10
| intent
stringlengths 19
200
| library
sequencelengths 0
3
| docs
listlengths 0
3
|
|---|---|---|---|---|---|---|---|---|---|
638,048 | def f_638048(list_of_pairs):
return | sum([pair[0] for pair in list_of_pairs]) |
def check(candidate): | [
"\n assert candidate([(5, 9), (-1, -2), (4, 2)]) == 8\n"
] | f_638048 | sum the first value in each tuple in a list of tuples `list_of_pairs` in python | [] | [] |
|
14,950,260 | def f_14950260():
return | ast.literal_eval("{'code1':1,'code2':1}") |
import ast
def check(candidate): | [
"\n d = candidate()\n exp_result = {'code1' : 1, 'code2': 1}\n for key in d:\n if key not in exp_result:\n assert False\n else:\n assert d[key] == exp_result[key]\n"
] | f_14950260 | convert unicode string u"{'code1':1,'code2':1}" into dictionary | [
"ast"
] | [
{
"function": "ast.literal_eval",
"text": "ast.literal_eval(node_or_string) \nSafely evaluate an expression node or a string containing a Python literal or container display. The string or node provided may only consist of the following Python literal structures: strings, bytes, numbers, tuples, lists, dicts, sets, booleans, and None. This can be used for safely evaluating strings containing Python values from untrusted sources without the need to parse the values oneself. It is not capable of evaluating arbitrarily complex expressions, for example involving operators or indexing. Warning It is possible to crash the Python interpreter with a sufficiently large/complex string due to stack depth limitations in Python’s AST compiler. Changed in version 3.2: Now allows bytes and set literals. Changed in version 3.9: Now supports creating empty sets with 'set()'.",
"title": "python.library.ast#ast.literal_eval"
}
] |
|
11,416,772 | def f_11416772(mystring):
return | [word for word in mystring.split() if word.startswith('$')] |
def check(candidate): | [
"\n str = \"$abc def $efg $hij klm $\"\n exp_result = ['$abc', '$efg', '$hij', '$']\n assert sorted(candidate(str)) == sorted(exp_result)\n"
] | f_11416772 | find all words in a string `mystring` that start with the `$` sign | [] | [] |
|
11,331,982 | def f_11331982(text):
|
return text | text = re.sub('^https?:\\/\\/.*[\\r\\n]*', '', text, flags=re.MULTILINE) |
import re
def check(candidate): | [
"\n assert candidate(\"https://www.wikipedia.org/ click at\") == \"\"\n"
] | f_11331982 | remove any url within string `text` | [
"re"
] | [
{
"function": "re.sub",
"text": "re.sub(pattern, repl, string, count=0, flags=0) \nReturn the string obtained by replacing the leftmost non-overlapping occurrences of pattern in string by the replacement repl. If the pattern isn’t found, string is returned unchanged. repl can be a string or a function; if it is a string, any backslash escapes in it are processed. That is, \\n is converted to a single newline character, \\r is converted to a carriage return, and so forth. Unknown escapes of ASCII letters are reserved for future use and treated as errors. Other unknown escapes such as \\& are left alone. Backreferences, such as \\6, are replaced with the substring matched by group 6 in the pattern. For example: >>> re.sub(r'def\\s+([a-zA-Z_][a-zA-Z_0-9]*)\\s*\\(\\s*\\):',\n... r'static PyObject*\\npy_\\1(void)\\n{',\n... 'def myfunc():')\n'static PyObject*\\npy_myfunc(void)\\n{'\n If repl is a function, it is called for every non-overlapping occurrence of pattern. The function takes a single match object argument, and returns the replacement string. For example: >>> def dashrepl(matchobj):\n... if matchobj.group(0) == '-': return ' '\n... else: return '-'",
"title": "python.library.re#re.sub"
}
] |
34,945,274 | def f_34945274(A):
return | np.where(np.in1d(A, [1, 3, 4]).reshape(A.shape), A, 0) |
import numpy as np
def check(candidate): | [
"\n A = np.array([[6, 8, 1, 3, 4], [-1, 0, 3, 5, 1]])\n B = np.array([[0, 0, 1, 3, 4], [0, 0, 3, 0, 1]])\n assert np.array_equal(candidate(A), B)\n"
] | f_34945274 | replace all elements in array `A` that are not present in array `[1, 3, 4]` with zeros | [
"numpy"
] | [
{
"function": "numpy.where",
"text": "numpy.where numpy.where(condition, [x, y, ]/)\n \nReturn elements chosen from x or y depending on condition. Note When only condition is provided, this function is a shorthand for np.asarray(condition).nonzero(). Using nonzero directly should be preferred, as it behaves correctly for subclasses. The rest of this documentation covers only the case where all three arguments are provided. Parameters ",
"title": "numpy.reference.generated.numpy.where"
},
{
"function": "numpy.in1d",
"text": "numpy.in1d numpy.in1d(ar1, ar2, assume_unique=False, invert=False)[source]\n \nTest whether each element of a 1-D array is also present in a second array. Returns a boolean array the same length as ar1 that is True where an element of ar1 is in ar2 and False otherwise. We recommend using isin instead of in1d for new code. Parameters ",
"title": "numpy.reference.generated.numpy.in1d"
}
] |
|
15,819,980 | def f_15819980(a):
return | np.mean(a, axis=1) |
import numpy as np
def check(candidate): | [
"\n A = np.array([[6, 8, 1, 3, 4], [-1, 0, 3, 5, 1]])\n B = np.array([4.4, 1.6])\n assert np.array_equal(candidate(A), B)\n"
] | f_15819980 | calculate mean across dimension in a 2d array `a` | [
"numpy"
] | [
{
"function": "numpy.mean",
"text": "numpy.mean numpy.mean(a, axis=None, dtype=None, out=None, keepdims=<no value>, *, where=<no value>)[source]\n \nCompute the arithmetic mean along the specified axis. Returns the average of the array elements. The average is taken over the flattened array by default, otherwise over the specified axis. float64 intermediate and return values are used for integer inputs. Parameters ",
"title": "numpy.reference.generated.numpy.mean"
}
] |
|
19,894,365 | def f_19894365():
return | subprocess.call(['/usr/bin/Rscript', '--vanilla', '/pathto/MyrScript.r']) |
from unittest.mock import Mock
import subprocess
def check(candidate): | [
"\n subprocess.call = Mock(return_value = 0)\n assert candidate() == 0\n"
] | f_19894365 | running r script '/pathto/MyrScript.r' from python | [
"subprocess"
] | [
{
"function": "subprocess.call",
"text": "subprocess.call(args, *, stdin=None, stdout=None, stderr=None, shell=False, cwd=None, timeout=None, **other_popen_kwargs) \nRun the command described by args. Wait for command to complete, then return the returncode attribute. Code needing to capture stdout or stderr should use run() instead: run(...).returncode\n To suppress stdout or stderr, supply a value of DEVNULL. The arguments shown above are merely some common ones. The full function signature is the same as that of the Popen constructor - this function passes all supplied arguments other than timeout directly through to that interface. Note Do not use stdout=PIPE or stderr=PIPE with this function. The child process will block if it generates enough output to a pipe to fill up the OS pipe buffer as the pipes are not being read from. Changed in version 3.3: timeout was added.",
"title": "python.library.subprocess#subprocess.call"
}
] |
|
19,894,365 | def f_19894365():
return | subprocess.call('/usr/bin/Rscript --vanilla /pathto/MyrScript.r', shell=True) |
from unittest.mock import Mock
import subprocess
def check(candidate): | [
"\n subprocess.call = Mock(return_value = 0)\n assert candidate() == 0\n"
] | f_19894365 | run r script '/usr/bin/Rscript --vanilla /pathto/MyrScript.r' | [
"subprocess"
] | [
{
"function": "subprocess.call",
"text": "subprocess.call(args, *, stdin=None, stdout=None, stderr=None, shell=False, cwd=None, timeout=None, **other_popen_kwargs) \nRun the command described by args. Wait for command to complete, then return the returncode attribute. Code needing to capture stdout or stderr should use run() instead: run(...).returncode\n To suppress stdout or stderr, supply a value of DEVNULL. The arguments shown above are merely some common ones. The full function signature is the same as that of the Popen constructor - this function passes all supplied arguments other than timeout directly through to that interface. Note Do not use stdout=PIPE or stderr=PIPE with this function. The child process will block if it generates enough output to a pipe to fill up the OS pipe buffer as the pipes are not being read from. Changed in version 3.3: timeout was added.",
"title": "python.library.subprocess#subprocess.call"
}
] |
|
33,058,590 | def f_33058590(df):
return | df.fillna(df.mean(axis=0)) |
import pandas as pd
import numpy as np
def check(candidate): | [
"\n df = pd.DataFrame([[1,2,3],[4,5,6],[7.0,np.nan,9.0]], columns=[\"c1\",\"c2\",\"c3\"]) \n res = pd.DataFrame([[1,2,3],[4,5,6],[7.0,3.5,9.0]], columns=[\"c1\",\"c2\",\"c3\"])\n assert candidate(df).equals(res)\n"
] | f_33058590 | replacing nan in the dataframe `df` with row average | [
"numpy",
"pandas"
] | [
{
"function": "df.fillna",
"text": "pandas.DataFrame.fillna DataFrame.fillna(value=None, method=None, axis=None, inplace=False, limit=None, downcast=None)[source]\n \nFill NA/NaN values using the specified method. Parameters ",
"title": "pandas.reference.api.pandas.dataframe.fillna"
},
{
"function": "pandas.dataframe.mean",
"text": "pandas.DataFrame.mean DataFrame.mean(axis=NoDefault.no_default, skipna=True, level=None, numeric_only=None, **kwargs)[source]\n \nReturn the mean of the values over the requested axis. Parameters ",
"title": "pandas.reference.api.pandas.dataframe.mean"
}
] |
|
12,400,256 | def f_12400256():
return | time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(1347517370)) |
import time
def check(candidate): | [
"\n assert candidate() == \"2012-09-13 06:22:50\"\n"
] | f_12400256 | Convert unix timestamp '1347517370' to formatted string '%Y-%m-%d %H:%M:%S' | [
"time"
] | [
{
"function": "time.strftime",
"text": "time.strftime(format[, t]) \nConvert a tuple or struct_time representing a time as returned by gmtime() or localtime() to a string as specified by the format argument. If t is not provided, the current time as returned by localtime() is used. format must be a string. ValueError is raised if any field in t is outside of the allowed range. 0 is a legal argument for any position in the time tuple; if it is normally illegal the value is forced to a correct one. The following directives can be embedded in the format string. They are shown without the optional field width and precision specification, and are replaced by the indicated characters in the strftime() result: \nDirective Meaning Notes ",
"title": "python.library.time#time.strftime"
}
] |
|
23,359,886 | def f_23359886(a):
return | a[np.where((a[:, (0)] == 0) * (a[:, (1)] == 1))] |
import numpy as np
def check(candidate): | [
"\n a = np.array([[ 0, 1, 2], [ 3, 4, 5], [ 6, 7, 8], [ 9, 10, 11], [12, 13, 14]])\n res = np.array([[0, 1, 2]])\n assert np.array_equal(candidate(a), res)\n"
] | f_23359886 | selecting rows in Numpy ndarray 'a', where the value in the first column is 0 and value in the second column is 1 | [
"numpy"
] | [
{
"function": "numpy.where",
"text": "numpy.where numpy.where(condition, [x, y, ]/)\n \nReturn elements chosen from x or y depending on condition. Note When only condition is provided, this function is a shorthand for np.asarray(condition).nonzero(). Using nonzero directly should be preferred, as it behaves correctly for subclasses. The rest of this documentation covers only the case where all three arguments are provided. Parameters ",
"title": "numpy.reference.generated.numpy.where"
}
] |
|
4,383,082 | def f_4383082(words):
return | re.split(' +', words) |
import regex as re
def check(candidate): | [
"\n s = \"hello world sample text\"\n res = [\"hello\", \"world\", \"sample\", \"text\"]\n assert candidate(s) == res\n"
] | f_4383082 | separate words delimited by one or more spaces into a list | [
"regex"
] | [
{
"function": "re.split",
"text": "re.split(pattern, string, maxsplit=0, flags=0) \nSplit string by the occurrences of pattern. If capturing parentheses are used in pattern, then the text of all groups in the pattern are also returned as part of the resulting list. If maxsplit is nonzero, at most maxsplit splits occur, and the remainder of the string is returned as the final element of the list. >>> re.split(r'\\W+', 'Words, words, words.')\n['Words', 'words', 'words', '']",
"title": "python.library.re#re.split"
}
] |
|
14,637,696 | def f_14637696(words):
return | len(max(words, key=len)) |
def check(candidate): | [
"\n assert candidate([\"hello\", \"world\", \"sample\", \"text\", \"superballer\"]) == 11\n"
] | f_14637696 | length of longest element in list `words` | [] | [] |
|
3,933,478 | def f_3933478(result):
return | result[0]['from_user'] |
def check(candidate): | [
"\n Contents = [{\"hi\": 7, \"bye\": 4, \"from_user\": 0}, {1: 2, 3: 4, 5: 6}]\n assert candidate(Contents) == 0\n"
] | f_3933478 | get the value associated with unicode key 'from_user' of first dictionary in list `result` | [] | [] |
|
39,112,645 | def f_39112645():
return | [line.split() for line in open('File.txt')] |
def check(candidate): | [
"\n with open('File.txt','w') as fw:\n fw.write(\"hi hello cat dog\")\n assert candidate() == [['hi', 'hello', 'cat', 'dog']]\n"
] | f_39112645 | Retrieve each line from a file 'File.txt' as a list | [] | [] |
|
1,031,851 | def f_1031851(a):
return | dict((v, k) for k, v in a.items()) |
def check(candidate): | [
"\n a = {\"one\": 1, \"two\": 2}\n assert candidate(a) == {1: \"one\", 2: \"two\"}\n"
] | f_1031851 | swap keys with values in a dictionary `a` | [] | [] |
|
8,577,137 | def f_8577137():
return | open('path/to/FILE_NAME.ext', 'w') |
import os
def check(candidate): | [
"\n path1 = os.path.join(\"\", \"path\")\n os.mkdir(path1)\n path2 = os.path.join(\"path\", \"to\")\n os.mkdir(path2)\n candidate()\n assert os.path.exists('path/to/FILE_NAME.ext')\n"
] | f_8577137 | Open a file `path/to/FILE_NAME.ext` in write mode | [
"os"
] | [
{
"function": "open",
"text": "os.open(path, flags, mode=0o777, *, dir_fd=None) \nOpen the file path and set various flags according to flags and possibly its mode according to mode. When computing mode, the current umask value is first masked out. Return the file descriptor for the newly opened file. The new file descriptor is non-inheritable. For a description of the flag and mode values, see the C run-time documentation; flag constants (like O_RDONLY and O_WRONLY) are defined in the os module. In particular, on Windows adding O_BINARY is needed to open files in binary mode. This function can support paths relative to directory descriptors with the dir_fd parameter. Raises an auditing event open with arguments path, mode, flags. Changed in version 3.4: The new file descriptor is now non-inheritable. Note This function is intended for low-level I/O. For normal usage, use the built-in function open(), which returns a file object with read() and write() methods (and many more). To wrap a file descriptor in a file object, use fdopen(). New in version 3.3: The dir_fd argument. Changed in version 3.5: If the system call is interrupted and the signal handler does not raise an exception, the function now retries the system call instead of raising an InterruptedError exception (see PEP 475 for the rationale). Changed in version 3.6: Accepts a path-like object.",
"title": "python.library.os#os.open"
}
] |
|
17,926,273 | def f_17926273(df):
return | df.groupby(['col1', 'col2'])['col3'].nunique().reset_index() |
import pandas as pd
def check(candidate): | [
"\n data = [[1, 1, 1], [1, 1, 1], [1, 1, 2], [1, 2, 3], [1, 2, 3], [1, 2, 3], \n [2, 1, 1], [2, 1, 2], [2, 1, 3], [2, 2, 3], [2, 2, 3], [2, 2, 3]]\n expected = [[1, 1, 2], [1, 2, 1], [2, 1, 3], [2, 2, 1]]\n df = pd.DataFrame(data, columns = ['col1', 'col2', 'col3'])\n expected_df = pd.DataFrame(expected, columns = ['col1', 'col2', 'col3'])\n df1 = candidate(df)\n assert pd.DataFrame.equals(expected_df, df1)\n"
] | f_17926273 | count distinct values in a column 'col3' of a pandas dataframe `df` group by objects in 'col1' and 'col2' | [
"pandas"
] | [
{
"function": "pandas.dataframe.groupby",
"text": "pandas.DataFrame.groupby DataFrame.groupby(by=None, axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=NoDefault.no_default, observed=False, dropna=True)[source]\n \nGroup DataFrame using a mapper or by a Series of columns. A groupby operation involves some combination of splitting the object, applying a function, and combining the results. This can be used to group large amounts of data and compute operations on these groups. Parameters ",
"title": "pandas.reference.api.pandas.dataframe.groupby"
},
{
"function": "nunique",
"text": "pandas.core.groupby.DataFrameGroupBy.nunique DataFrameGroupBy.nunique(dropna=True)[source]\n \nReturn DataFrame with counts of unique elements in each position. Parameters \n \ndropna:bool, default True\n\n\nDon’t include NaN in the counts. Returns \n nunique: DataFrame\n Examples ",
"title": "pandas.reference.api.pandas.core.groupby.dataframegroupby.nunique"
},
{
"function": "reset_index",
"text": "pandas.DataFrame.reset_index DataFrame.reset_index(level=None, drop=False, inplace=False, col_level=0, col_fill='')[source]\n \nReset the index, or a level of it. Reset the index of the DataFrame, and use the default one instead. If the DataFrame has a MultiIndex, this method can remove one or more levels. Parameters ",
"title": "pandas.reference.api.pandas.dataframe.reset_index"
}
] |
|
3,735,814 | def f_3735814(dict1):
return | any(key.startswith('EMP$$') for key in dict1) |
def check(candidate): | [
"\n assert candidate({'EMP$$': 1, 'EMP$$112': 4}) == True\n",
"\n assert candidate({'EMP$$': 1, 'EM$$112': 4}) == True\n",
"\n assert candidate({'EMP$33': 0}) == False\n"
] | f_3735814 | Check if any key in the dictionary `dict1` starts with the string `EMP$$` | [] | [] |
|
3,735,814 | def f_3735814(dict1):
return | [value for key, value in list(dict1.items()) if key.startswith('EMP$$')] |
def check(candidate): | [
"\n assert sorted(candidate({'EMP$$': 1, 'EMP$$112': 4})) == [1, 4]\n",
"\n assert sorted(candidate({'EMP$$': 1, 'EM$$112': 4})) == [1]\n",
"\n assert sorted(candidate({'EMP$33': 0})) == []\n"
] | f_3735814 | create list of values from dictionary `dict1` that have a key that starts with 'EMP$$' | [] | [] |
|
26,097,916 | def f_26097916(sf):
|
return df | df = pd.DataFrame({'email': sf.index, 'list': sf.values}) |
import pandas as pd
def check(candidate): | [
"\n dict = {'email1': [1.0, 5.0, 7.0], 'email2': [4.2, 3.6, -0.9]}\n sf = pd.Series(dict)\n k = [['email1', [1.0, 5.0, 7.0]], ['email2', [4.2, 3.6, -0.9]]]\n df1 = pd.DataFrame(k, columns=['email', 'list'])\n df2 = candidate(sf)\n assert pd.DataFrame.equals(df1, df2)\n"
] | f_26097916 | convert a pandas series `sf` into a pandas dataframe `df` with columns `email` and `list` | [
"pandas"
] | [] |
4,048,964 | def f_4048964(list):
return | '\t'.join(map(str, list)) |
def check(candidate): | [
"\n assert candidate(['hello', 'world', '!']) == 'hello\\tworld\\t!'\n",
"\n assert candidate([]) == \"\"\n",
"\n assert candidate([\"mconala\"]) == \"mconala\"\n",
"\n assert candidate([\"MCoNaLa\"]) == \"MCoNaLa\"\n"
] | f_4048964 | concatenate elements of list `list` by tabs ` ` | [] | [] |
|
3,182,716 | def f_3182716():
return | '\xd0\xbf\xd1\x80\xd0\xb8'.encode('raw_unicode_escape') |
def check(candidate): | [
"\n assert candidate() == b'\\xd0\\xbf\\xd1\\x80\\xd0\\xb8'\n"
] | f_3182716 | print unicode string '\xd0\xbf\xd1\x80\xd0\xb8' with utf-8 | [] | [] |
|
3,182,716 | def f_3182716():
return | 'Sopet\xc3\xb3n'.encode('latin-1').decode('utf-8') |
def check(candidate): | [
"\n assert candidate() == \"Sopetón\"\n"
] | f_3182716 | Encode a latin character in string `Sopet\xc3\xb3n` properly | [] | [] |
|
35,622,945 | def f_35622945(s):
return | re.findall('n(?<=[^n]n)n+(?=[^n])(?i)', s) |
import re
def check(candidate): | [
"\n assert candidate(\"ncnnnne\") == ['nnnn']\n",
"\n assert candidate(\"nn\") == []\n",
"\n assert candidate(\"ask\") == []\n"
] | f_35622945 | regex, find "n"s only in the middle of string `s` | [
"re"
] | [
{
"function": "re.findall",
"text": "re.findall(pattern, string, flags=0) \nReturn all non-overlapping matches of pattern in string, as a list of strings. The string is scanned left-to-right, and matches are returned in the order found. If one or more groups are present in the pattern, return a list of groups; this will be a list of tuples if the pattern has more than one group. Empty matches are included in the result. Changed in version 3.7: Non-empty matches can now start just after a previous empty match.",
"title": "python.library.re#re.findall"
}
] |
|
5,306,756 | def f_5306756():
return | '{0:.0f}%'.format(1.0 / 3 * 100) |
def check(candidate): | [
"\n assert(candidate() == \"33%\")\n"
] | f_5306756 | display the float `1/3*100` as a percentage | [] | [] |
|
2,878,084 | def f_2878084(mylist):
|
return mylist | mylist.sort(key=lambda x: x['title']) |
def check(candidate): | [
"\n input = [\n {'title':'New York Times', 'title_url':'New_York_Times','id':4}, \n {'title':'USA Today','title_url':'USA_Today','id':6}, \n {'title':'Apple News','title_url':'Apple_News','id':2}\n ]\n res = [\n {'title': 'Apple News', 'title_url': 'Apple_News', 'id': 2}, \n {'title': 'New York Times', 'title_url': 'New_York_Times', 'id': 4},\n {'title': 'USA Today', 'title_url': 'USA_Today', 'id': 6}\n ]\n assert candidate(input) == res\n"
] | f_2878084 | sort a list of dictionary `mylist` by the key `title` | [] | [] |
2,878,084 | def f_2878084(l):
|
return l | l.sort(key=lambda x: x['title']) |
def check(candidate): | [
"\n input = [\n {'title':'New York Times', 'title_url':'New_York_Times','id':4}, \n {'title':'USA Today','title_url':'USA_Today','id':6}, \n {'title':'Apple News','title_url':'Apple_News','id':2}\n ]\n res = [\n {'title': 'Apple News', 'title_url': 'Apple_News', 'id': 2}, \n {'title': 'New York Times', 'title_url': 'New_York_Times', 'id': 4},\n {'title': 'USA Today', 'title_url': 'USA_Today', 'id': 6}\n ]\n assert candidate(input) == res\n"
] | f_2878084 | sort a list `l` of dicts by dict value 'title' | [] | [] |
2,878,084 | def f_2878084(l):
|
return l | l.sort(key=lambda x: (x['title'], x['title_url'], x['id'])) |
def check(candidate): | [
"\n input = [\n {'title':'New York Times', 'title_url':'New_York_Times','id':4}, \n {'title':'USA Today','title_url':'USA_Today','id':6}, \n {'title':'Apple News','title_url':'Apple_News','id':2}\n ]\n res = [\n {'title': 'Apple News', 'title_url': 'Apple_News', 'id': 2}, \n {'title': 'New York Times', 'title_url': 'New_York_Times', 'id': 4},\n {'title': 'USA Today', 'title_url': 'USA_Today', 'id': 6}\n ]\n assert candidate(input) == res\n"
] | f_2878084 | sort a list of dictionaries by the value of keys 'title', 'title_url', 'id' in ascending order. | [] | [] |
9,323,159 | def f_9323159(l1, l2):
return | heapq.nlargest(10, range(len(l1)), key=lambda i: abs(l1[i] - l2[i])) |
import heapq
def check(candidate): | [
"\n l1 = [99, 86, 90, 70, 86, 95, 56, 98, 80, 81]\n l2 = [21, 11, 21, 1, 26, 40, 4, 50, 34, 37]\n res = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n assert candidate(l1, l2) == res\n"
] | f_9323159 | find 10 largest differences between each respective elements of list `l1` and list `l2` | [
"heapq"
] | [
{
"function": "heapq.nlargest",
"text": "heapq.nlargest(n, iterable, key=None) \nReturn a list with the n largest elements from the dataset defined by iterable. key, if provided, specifies a function of one argument that is used to extract a comparison key from each element in iterable (for example, key=str.lower). Equivalent to: sorted(iterable, key=key,\nreverse=True)[:n].",
"title": "python.library.heapq#heapq.nlargest"
}
] |
|
29,877,663 | def f_29877663(soup):
return | soup.find_all('span', {'class': 'starGryB sp'}) |
import bs4
def check(candidate): | [
"\n html = '''<span class=\"starBig sp\">4.1</span>\n <span class=\"starGryB sp\">2.9</span>\n <span class=\"sp starGryB\">2.9</span>\n <span class=\"sp starBig\">22</span>'''\n soup = bs4.BeautifulSoup(html, features=\"html5lib\")\n res = '''[<span class=\"starGryB sp\">2.9</span>]'''\n assert(str(candidate(soup)) == res)\n"
] | f_29877663 | BeautifulSoup find all 'span' elements in HTML string `soup` with class of 'starGryB sp' | [
"bs4"
] | [] |
|
24,189,150 | def f_24189150(df, engine):
|
return | df.to_sql('test', engine) |
import pandas as pd
from sqlalchemy import create_engine
def check(candidate): | [
"\n engine = create_engine('sqlite://', echo=False)\n df = pd.DataFrame({'name' : ['User 1', 'User 2', 'User 3']})\n candidate(df, engine)\n result = pd.read_sql('SELECT name FROM test', engine)\n assert result.equals(df)\n"
] | f_24189150 | write records in dataframe `df` to table 'test' in schema 'a_schema' with `engine` | [
"pandas",
"sqlalchemy"
] | [
{
"function": "df.to_sql",
"text": "pandas.DataFrame.to_sql DataFrame.to_sql(name, con, schema=None, if_exists='fail', index=True, index_label=None, chunksize=None, dtype=None, method=None)[source]\n \nWrite records stored in a DataFrame to a SQL database. Databases supported by SQLAlchemy [1] are supported. Tables can be newly created, appended to, or overwritten. Parameters ",
"title": "pandas.reference.api.pandas.dataframe.to_sql"
}
] |
30,766,151 | def f_30766151(s):
return | re.sub('[^(){}[\]]', '', s) |
import re
def check(candidate): | [
"\n assert candidate(\"(a(vdwvndw){}]\") == \"((){}]\"\n",
"\n assert candidate(\"12345\") == \"\"\n"
] | f_30766151 | Extract brackets from string `s` | [
"re"
] | [
{
"function": "re.sub",
"text": "re.sub(pattern, repl, string, count=0, flags=0) \nReturn the string obtained by replacing the leftmost non-overlapping occurrences of pattern in string by the replacement repl. If the pattern isn’t found, string is returned unchanged. repl can be a string or a function; if it is a string, any backslash escapes in it are processed. That is, \\n is converted to a single newline character, \\r is converted to a carriage return, and so forth. Unknown escapes of ASCII letters are reserved for future use and treated as errors. Other unknown escapes such as \\& are left alone. Backreferences, such as \\6, are replaced with the substring matched by group 6 in the pattern. For example: >>> re.sub(r'def\\s+([a-zA-Z_][a-zA-Z_0-9]*)\\s*\\(\\s*\\):',\n... r'static PyObject*\\npy_\\1(void)\\n{',\n... 'def myfunc():')\n'static PyObject*\\npy_myfunc(void)\\n{'\n If repl is a function, it is called for every non-overlapping occurrence of pattern. The function takes a single match object argument, and returns the replacement string. For example: >>> def dashrepl(matchobj):\n... if matchobj.group(0) == '-': return ' '\n... else: return '-'",
"title": "python.library.re#re.sub"
}
] |
|
1,143,379 | def f_1143379(L):
return | list(dict((x[0], x) for x in L).values()) |
def check(candidate): | [
"\n L = [['14', '65', 76], ['2', '5', 6], ['7', '12', 33], ['14', '22', 46]]\n res = [['14', '22', 46], ['2', '5', 6], ['7', '12', 33]]\n assert(candidate(L) == res)\n",
"\n assert candidate([\"a\", \"aa\", \"abc\", \"bac\"]) == [\"abc\", \"bac\"]\n"
] | f_1143379 | remove duplicate elements from list 'L' | [] | [] |
|
12,330,522 | def f_12330522(file):
return | [line.rstrip('\n') for line in file] |
def check(candidate): | [
"\n res = ['1', '2', '3']\n f = open(\"myfile.txt\", \"a\")\n f.write(\"1\\n2\\n3\")\n f.close()\n f = open(\"myfile.txt\", \"r\")\n assert candidate(f) == res\n"
] | f_12330522 | read a file `file` without newlines | [] | [] |
|
364,621 | def f_364621(testlist):
return | [i for (i, x) in enumerate(testlist) if (x == 1)] |
def check(candidate): | [
"\n testlist = [1,2,3,5,3,1,2,1,6]\n assert candidate(testlist) == [0, 5, 7]\n",
"\n testlist = [0, -1]\n assert candidate(testlist) == []\n"
] | f_364621 | get the position of item 1 in `testlist` | [] | [] |
|
364,621 | def f_364621(testlist):
return | [i for (i, x) in enumerate(testlist) if (x == 1)] |
def check(candidate): | [
"\n testlist = [1,2,3,5,3,1,2,1,6]\n assert candidate(testlist) == [0, 5, 7]\n",
"\n testlist = [0, -1]\n assert candidate(testlist) == []\n"
] | f_364621 | get the position of item 1 in `testlist` | [] | [] |
|
364,621 | def f_364621(testlist, element):
return | testlist.index(element) |
def check(candidate): | [
"\n testlist = [1,2,3,5,3,1,2,1,6]\n assert candidate(testlist, 1) == 0\n",
"\n testlist = [1,2,3,5,3,1,2,1,6]\n try:\n candidate(testlist, 14)\n except:\n assert True\n"
] | f_364621 | get the position of item `element` in list `testlist` | [] | [] |
|
13,145,368 | def f_13145368(lis):
return | max(lis, key=lambda item: item[1])[0] |
def check(candidate): | [
"\n lis = [(101, 153), (255, 827), (361, 961)]\n assert candidate(lis) == 361\n"
] | f_13145368 | find the first element of the tuple with the maximum second element in a list of tuples `lis` | [] | [] |
|
13,145,368 | def f_13145368(lis):
return | max(lis, key=itemgetter(1))[0] |
from operator import itemgetter
def check(candidate): | [
"\n lis = [(101, 153), (255, 827), (361, 961)]\n assert candidate(lis) == 361\n"
] | f_13145368 | get the item at index 0 from the tuple that has maximum value at index 1 in list `lis` | [
"operator"
] | [
{
"function": "operator.itemgetter",
"text": "operator.itemgetter(item) \noperator.itemgetter(*items) \nReturn a callable object that fetches item from its operand using the operand’s __getitem__() method. If multiple items are specified, returns a tuple of lookup values. For example: After f = itemgetter(2), the call f(r) returns r[2]. After g = itemgetter(2, 5, 3), the call g(r) returns (r[2], r[5], r[3]). Equivalent to: def itemgetter(*items):",
"title": "python.library.operator#operator.itemgetter"
}
] |
|
2,689,189 | def f_2689189():
|
return | time.sleep(1) |
import time
def check(candidate): | [
"\n t1 = time.time()\n candidate()\n t2 = time.time()\n assert t2 - t1 > 1\n"
] | f_2689189 | Make a delay of 1 second | [
"time"
] | [
{
"function": "time.sleep",
"text": "time.sleep(secs) \nSuspend execution of the calling thread for the given number of seconds. The argument may be a floating point number to indicate a more precise sleep time. The actual suspension time may be less than that requested because any caught signal will terminate the sleep() following execution of that signal’s catching routine. Also, the suspension time may be longer than requested by an arbitrary amount because of the scheduling of other activity in the system. Changed in version 3.5: The function now sleeps at least secs even if the sleep is interrupted by a signal, except if the signal handler raises an exception (see PEP 475 for the rationale).",
"title": "python.library.time#time.sleep"
}
] |
12,485,244 | def f_12485244(L):
return | """, """.join('(' + ', '.join(i) + ')' for i in L) |
def check(candidate): | [
"\n L = [(\"abc\", \"def\"), (\"hij\", \"klm\")]\n assert candidate(L) == '(abc, def), (hij, klm)'\n"
] | f_12485244 | convert list of tuples `L` to a string | [] | [] |
|
755,857 | def f_755857():
|
return b | b = models.CharField(max_length=7, default='0000000', editable=False) |
from django.db import models
def check(candidate): | [
"\n assert candidate().get_default() == '0000000'\n"
] | f_755857 | Django set default value of field `b` equal to '0000000' | [
"django"
] | [
{
"function": "models.CharField",
"text": "class CharField(max_length=None, **options)",
"title": "django.ref.models.fields#django.db.models.CharField"
}
] |
16,193,578 | def f_16193578(list5):
return | sorted(list5, key = lambda x: (degrees(x), x)) |
from math import degrees
def check(candidate): | [
"\n list5 = [4, 1, 2, 3, 9, 5]\n assert candidate(list5) == [1, 2, 3, 4, 5, 9]\n"
] | f_16193578 | Sort lis `list5` in ascending order based on the degrees value of its elements | [
"math"
] | [
{
"function": "math.degrees",
"text": "math.degrees(x) \nConvert angle x from radians to degrees.",
"title": "python.library.math#math.degrees"
}
] |
|
16,041,405 | def f_16041405(l):
return | (n for n in l) |
def check(candidate): | [
"\n generator = candidate([1,2,3,5])\n assert str(type(generator)) == \"<class 'generator'>\"\n assert [x for x in generator] == [1, 2, 3, 5]\n"
] | f_16041405 | convert a list `l` into a generator object | [] | [] |
|
18,837,607 | def f_18837607(oldlist, removelist):
return | [v for i, v in enumerate(oldlist) if i not in removelist] |
def check(candidate): | [
"\n assert candidate([\"asdf\",\"ghjk\",\"qwer\",\"tyui\"], [1,3]) == ['asdf', 'qwer']\n",
"\n assert candidate([1,2,3,4,5], [0,4]) == [2,3,4]\n"
] | f_18837607 | remove elements from list `oldlist` that have an index number mentioned in list `removelist` | [] | [] |
|
4,710,067 | def f_4710067():
return | open('yourfile.txt', 'w') |
def check(candidate): | [
"\n fw = candidate()\n assert fw.name == \"yourfile.txt\"\n assert fw.mode == 'w'\n"
] | f_4710067 | Open a file `yourfile.txt` in write mode | [] | [] |
|
7,373,219 | def f_7373219(obj, attr):
return | getattr(obj, attr) |
def check(candidate): | [
"\n class Student:\n student_id = \"\"\n student_name = \"\"\n\n def __init__(self, student_id=101, student_name=\"Adam\"):\n self.student_id = student_id\n self.student_name = student_name\n\n student = Student()\n\n assert(candidate(student, 'student_name') == \"Adam\")\n assert(candidate(student, 'student_id') == 101)\n",
"\n class Student:\n student_id = \"\"\n student_name = \"\"\n\n def __init__(self, student_id=101, student_name=\"Adam\"):\n self.student_id = student_id\n self.student_name = student_name\n\n student = Student()\n\n try:\n value = candidate(student, 'student_none')\n except: \n assert True\n"
] | f_7373219 | get attribute 'attr' from object `obj` | [] | [] |
|
8,171,751 | def f_8171751():
return | reduce(lambda a, b: a + b, (('aa',), ('bb',), ('cc',))) |
from functools import reduce
def check(candidate): | [
"\n assert candidate() == ('aa', 'bb', 'cc')\n"
] | f_8171751 | convert tuple of tuples `(('aa',), ('bb',), ('cc',))` to tuple | [
"functools"
] | [
{
"function": "reduce",
"text": "functools.reduce(function, iterable[, initializer]) \nApply function of two arguments cumulatively to the items of iterable, from left to right, so as to reduce the iterable to a single value. For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates ((((1+2)+3)+4)+5). The left argument, x, is the accumulated value and the right argument, y, is the update value from the iterable. If the optional initializer is present, it is placed before the items of the iterable in the calculation, and serves as a default when the iterable is empty. If initializer is not given and iterable contains only one item, the first item is returned. Roughly equivalent to: def reduce(function, iterable, initializer=None):\n it = iter(iterable)",
"title": "python.library.functools#functools.reduce"
}
] |
|
8,171,751 | def f_8171751():
return | list(map(lambda a: a[0], (('aa',), ('bb',), ('cc',)))) |
def check(candidate): | [
"\n assert candidate() == ['aa', 'bb', 'cc']\n"
] | f_8171751 | convert tuple of tuples `(('aa',), ('bb',), ('cc',))` to list in one line | [] | [] |
|
28,986,489 | def f_28986489(df):
|
return df | df['range'].replace(',', '-', inplace=True) |
import pandas as pd
def check(candidate): | [
"\n df = pd.DataFrame({'range' : [\",\", \"(50,290)\", \",,,\"]})\n res = pd.DataFrame({'range' : [\"-\", \"(50,290)\", \",,,\"]})\n assert candidate(df).equals(res)\n"
] | f_28986489 | replace a characters in a column of a dataframe `df` | [
"pandas"
] | [
{
"function": "pandas.dataframe.replace",
"text": "pandas.DataFrame.replace DataFrame.replace(to_replace=None, value=NoDefault.no_default, inplace=False, limit=None, regex=False, method=NoDefault.no_default)[source]\n \nReplace values given in to_replace with value. Values of the DataFrame are replaced with other values dynamically. This differs from updating with .loc or .iloc, which require you to specify a location to update with some value. Parameters ",
"title": "pandas.reference.api.pandas.dataframe.replace"
}
] |
19,339 | def f_19339():
return | zip(*[('a', 1), ('b', 2), ('c', 3), ('d', 4)]) |
def check(candidate): | [
"\n assert [a for a in candidate()] == [('a', 'b', 'c', 'd'), (1, 2, 3, 4)]\n"
] | f_19339 | unzip the list `[('a', 1), ('b', 2), ('c', 3), ('d', 4)]` | [] | [] |
|
19,339 | def f_19339(original):
return | ([a for (a, b) in original], [b for (a, b) in original]) |
def check(candidate): | [
"\n original = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]\n assert candidate(original) == (['a', 'b', 'c', 'd'], [1, 2, 3, 4])\n",
"\n original2 = [([], 1), ([], 2), (5, 3), (6, 4)]\n assert candidate(original2) == ([[], [], 5, 6], [1, 2, 3, 4])\n"
] | f_19339 | unzip list `original` | [] | [] |
|
19,339 | def f_19339(original):
return | ((a for (a, b) in original), (b for (a, b) in original)) |
def check(candidate): | [
"\n original = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]\n result = candidate(original)\n assert [a for gen in result for a in gen] == ['a','b','c','d',1,2,3,4]\n",
"\n original2 = [([], 1), ([], 2), (5, 3), (6, 4)]\n result2 = candidate(original2)\n assert [a for gen in result2 for a in gen] == [[], [], 5, 6, 1, 2, 3, 4]\n"
] | f_19339 | unzip list `original` and return a generator | [] | [] |
|
19,339 | def f_19339():
return | zip(*[('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e',)]) |
def check(candidate): | [
"\n assert list(candidate()) == [('a', 'b', 'c', 'd', 'e')]\n"
] | f_19339 | unzip list `[('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', )]` | [] | [] |
|
19,339 | def f_19339():
return | list(zip_longest(('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e',))) |
from itertools import zip_longest
def check(candidate): | [
"\n assert(candidate() == [('a', 'b', 'c', 'd', 'e'), (1, 2, 3, 4, None)])\n"
] | f_19339 | unzip list `[('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', )]` and fill empty results with None | [
"itertools"
] | [
{
"function": "itertools.zip_longest",
"text": "itertools.zip_longest(*iterables, fillvalue=None) \nMake an iterator that aggregates elements from each of the iterables. If the iterables are of uneven length, missing values are filled-in with fillvalue. Iteration continues until the longest iterable is exhausted. Roughly equivalent to: def zip_longest(*args, fillvalue=None):\n # zip_longest('ABCD', 'xy', fillvalue='-') --> Ax By C- D-",
"title": "python.library.itertools#itertools.zip_longest"
}
] |
|
1,960,516 | def f_1960516():
return | json.dumps('3.9') |
import json
def check(candidate): | [
"\n data = candidate()\n assert json.loads(data) == '3.9'\n"
] | f_1960516 | encode `Decimal('3.9')` to a JSON string | [
"json"
] | [
{
"function": "json.dumps",
"text": "json.dumps(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw) \nSerialize obj to a JSON formatted str using this conversion table. The arguments have the same meaning as in dump(). Note Keys in key/value pairs of JSON are always of the type str. When a dictionary is converted into JSON, all the keys of the dictionary are coerced to strings. As a result of this, if a dictionary is converted into JSON and then back into a dictionary, the dictionary may not equal the original one. That is, loads(dumps(x)) != x if x has non-string keys.",
"title": "python.library.json#json.dumps"
}
] |
|
1,024,847 | def f_1024847(d):
|
return d | d['mynewkey'] = 'mynewvalue' |
def check(candidate): | [
"\n assert candidate({'key': 'value'}) == {'key': 'value', 'mynewkey': 'mynewvalue'}\n"
] | f_1024847 | Add key "mynewkey" to dictionary `d` with value "mynewvalue" | [] | [] |
1,024,847 | def f_1024847(data):
|
return data | data.update({'a': 1, }) |
def check(candidate): | [
"\n assert candidate({'key': 'value'}) == {'key': 'value', 'a': 1}\n",
"\n assert candidate({'key': 'value', 'a' : 2}) == {'key': 'value', 'a': 1}\n"
] | f_1024847 | Add key 'a' to dictionary `data` with value 1 | [] | [] |
1,024,847 | def f_1024847(data):
|
return data | data.update(dict(a=1)) |
def check(candidate): | [
"\n assert candidate({'key': 'value'}) == {'key': 'value', 'a': 1}\n",
"\n assert candidate({'key': 'value', 'a' : 2}) == {'key': 'value', 'a': 1}\n"
] | f_1024847 | Add key 'a' to dictionary `data` with value 1 | [] | [] |
1,024,847 | def f_1024847(data):
|
return data | data.update(a=1) |
def check(candidate): | [
"\n assert candidate({'key': 'value'}) == {'key': 'value', 'a': 1}\n",
"\n assert candidate({'key': 'value', 'a' : 2}) == {'key': 'value', 'a': 1}\n"
] | f_1024847 | Add key 'a' to dictionary `data` with value 1 | [] | [] |
35,837,346 | def f_35837346(matrix):
return | max([max(i) for i in matrix]) |
def check(candidate): | [
"\n assert candidate([[1,2,3],[4,5,6],[7,8,9]]) == 9\n",
"\n assert candidate([[1.3,2.8],[4.2,10],[7.9,8.1,5]]) == 10\n"
] | f_35837346 | find maximal value in matrix `matrix` | [] | [] |
|
20,457,038 | def f_20457038(answer):
|
return answer | answer = str(round(answer, 2)) |
def check(candidate): | [
"\n assert candidate(2.34351) == \"2.34\"\n",
"\n assert candidate(99.375) == \"99.38\"\n",
"\n assert candidate(4.1) == \"4.1\"\n",
"\n assert candidate(3) == \"3\"\n"
] | f_20457038 | Round number `answer` to 2 precision after the decimal point | [] | [] |
2,890,896 | def f_2890896(s):
|
return ip | ip = re.findall('[0-9]+(?:\\.[0-9]+){3}', s) |
import re
def check(candidate): | [
"\n assert candidate(\"<html><head><title>Current IP Check</title></head><body>Current IP Address: 165.91.15.131</body></html>\") == [\"165.91.15.131\"]\n",
"\n assert candidate(\"<html><head><title>Current IP Check</title></head><body>Current IP Address: 165.91.15.131 and this is not a IP Address: 165.91.15</body></html>\") == [\"165.91.15.131\"]\n",
"\n assert candidate(\"<html><head><title>Current IP Check</title></head><body>Current IP Address: 192.168.1.1 & this is another IP address: 192.168.1.2</body></html>\") == [\"192.168.1.1\", \"192.168.1.2\"]\n"
] | f_2890896 | extract ip address `ip` from an html string `s` | [
"re"
] | [
{
"function": "re.findall",
"text": "re.findall(pattern, string, flags=0) \nReturn all non-overlapping matches of pattern in string, as a list of strings. The string is scanned left-to-right, and matches are returned in the order found. If one or more groups are present in the pattern, return a list of groups; this will be a list of tuples if the pattern has more than one group. Empty matches are included in the result. Changed in version 3.7: Non-empty matches can now start just after a previous empty match.",
"title": "python.library.re#re.findall"
}
] |
29,836,836 | def f_29836836(df):
return | df.groupby('A').filter(lambda x: len(x) > 1) |
import pandas as pd
def check(candidate): | [
"\n assert candidate(pd.DataFrame([[1, 2], [1, 4], [5, 6]], columns=['A', 'B'])).equals(pd.DataFrame([[1, 2], [1, 4]], columns=['A', 'B'])) is True\n",
"\n assert candidate(pd.DataFrame([[1, 2], [1, 4], [1, 6]], columns=['A', 'B'])).equals(pd.DataFrame([[1, 2], [1, 4], [1, 6]], columns=['A', 'B'])) is True\n"
] | f_29836836 | filter dataframe `df` by values in column `A` that appear more than once | [
"pandas"
] | [
{
"function": "pandas.dataframe.groupby",
"text": "pandas.DataFrame.groupby DataFrame.groupby(by=None, axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=NoDefault.no_default, observed=False, dropna=True)[source]\n \nGroup DataFrame using a mapper or by a Series of columns. A groupby operation involves some combination of splitting the object, applying a function, and combining the results. This can be used to group large amounts of data and compute operations on these groups. Parameters ",
"title": "pandas.reference.api.pandas.dataframe.groupby"
},
{
"function": "dataframegroupby.filter",
"text": "pandas.core.groupby.DataFrameGroupBy.filter DataFrameGroupBy.filter(func, dropna=True, *args, **kwargs)[source]\n \nReturn a copy of a DataFrame excluding filtered elements. Elements from groups are filtered if they do not satisfy the boolean criterion specified by func. Parameters ",
"title": "pandas.reference.api.pandas.core.groupby.dataframegroupby.filter"
}
] |
|
2,545,397 | def f_2545397(myfile):
return | [x for x in myfile if x != ''] |
def check(candidate): | [
"\n with open('./tmp.txt', 'w') as fw: \n for s in [\"hello\", \"world\", \"!!!\"]:\n fw.write(f\"{s}\\n\")\n\n with open('./tmp.txt', 'r') as myfile:\n lines = candidate(myfile)\n assert isinstance(lines, list)\n assert len(lines) == 3\n assert lines[0].strip() == \"hello\"\n"
] | f_2545397 | append each line in file `myfile` into a list | [] | [] |
|
2,545,397 | def f_2545397():
|
return lst | lst = list(map(int, open('filename.txt').readlines())) |
import pandas as pd
def check(candidate): | [
"\n with open('./filename.txt', 'w') as fw: \n for s in [\"1\", \"2\", \"100\"]:\n fw.write(f\"{s}\\n\")\n\n assert candidate() == [1, 2, 100]\n"
] | f_2545397 | Get a list of integers `lst` from a file `filename.txt` | [
"pandas"
] | [] |
35,420,052 | def f_35420052(plt, mappable, ax3):
|
return plt | plt.colorbar(mappable=mappable, cax=ax3) |
import numpy as np
import matplotlib.pyplot as plt
from obspy.core.trace import Trace
from obspy.imaging.spectrogram import spectrogram
def check(candidate): | [
"\n spl1 = Trace(data=np.arange(0, 10))\n fig = plt.figure()\n ax1 = fig.add_axes([0.1, 0.75, 0.7, 0.2]) #[left bottom width height]\n ax2 = fig.add_axes([0.1, 0.1, 0.7, 0.60], sharex=ax1)\n ax3 = fig.add_axes([0.83, 0.1, 0.03, 0.6])\n\n #make time vector\n t = np.arange(spl1.stats.npts) / spl1.stats.sampling_rate\n\n #plot waveform (top subfigure) \n ax1.plot(t, spl1.data, 'k')\n\n #plot spectrogram (bottom subfigure)\n spl2 = spl1\n fig = spl2.spectrogram(show=False, axes=ax2, wlen=10)\n mappable = ax2.images[0]\n candidate(plt, mappable, ax3)\n \n im=ax2.images\n assert im[-1].colorbar is not None\n"
] | f_35420052 | add color bar with image `mappable` to plot `plt` | [
"matplotlib",
"numpy",
"obspy"
] | [
{
"function": "plt.colorbar",
"text": "matplotlib.pyplot.colorbar matplotlib.pyplot.colorbar(mappable=None, cax=None, ax=None, **kw)[source]\n \nAdd a colorbar to a plot. Parameters ",
"title": "matplotlib._as_gen.matplotlib.pyplot.colorbar"
}
] |
29,903,025 | def f_29903025(df):
return | Counter(' '.join(df['text']).split()).most_common(100) |
import pandas as pd
from collections import Counter
def check(candidate): | [
"\n df = pd.DataFrame({\"text\": [\n 'Python is a high-level, general-purpose programming language.', \n 'Its design philosophy emphasizes code readability with the use of significant indentation. Python is dynamically-typed and garbage-collected.'\n ]})\n assert candidate(df) == [('Python', 2),('is', 2),('a', 1),('high-level,', 1),('general-purpose', 1),\n ('programming', 1),('language.', 1),('Its', 1),('design', 1),('philosophy', 1),('emphasizes', 1),\n ('code', 1),('readability', 1),('with', 1), ('the', 1),('use', 1),('of', 1),('significant', 1),\n ('indentation.', 1),('dynamically-typed', 1),('and', 1),('garbage-collected.', 1)]\n"
] | f_29903025 | count most frequent 100 words in column 'text' of dataframe `df` | [
"collections",
"pandas"
] | [
{
"function": "Counter.most_common",
"text": "most_common([n]) \nReturn a list of the n most common elements and their counts from the most common to the least. If n is omitted or None, most_common() returns all elements in the counter. Elements with equal counts are ordered in the order first encountered: >>> Counter('abracadabra').most_common(3)\n[('a', 5), ('b', 2), ('r', 2)]",
"title": "python.library.collections#collections.Counter.most_common"
}
] |
|
7,378,180 | def f_7378180():
return | list(itertools.combinations((1, 2, 3), 2)) |
import itertools
def check(candidate): | [
"\n assert candidate() == [(1, 2), (1, 3), (2, 3)]\n"
] | f_7378180 | generate all 2-element subsets of tuple `(1, 2, 3)` | [
"itertools"
] | [
{
"function": "itertools.combinations",
"text": "itertools.combinations(iterable, r) \nReturn r length subsequences of elements from the input iterable. The combination tuples are emitted in lexicographic ordering according to the order of the input iterable. So, if the input iterable is sorted, the combination tuples will be produced in sorted order. Elements are treated as unique based on their position, not on their value. So if the input elements are unique, there will be no repeat values in each combination. Roughly equivalent to: def combinations(iterable, r):\n # combinations('ABCD', 2) --> AB AC AD BC BD CD",
"title": "python.library.itertools#itertools.combinations"
}
] |
|
4,530,069 | def f_4530069():
return | datetime.now(pytz.utc) |
import pytz
import time
from datetime import datetime, timezone
def check(candidate): | [
"\n assert (candidate() - datetime(1970, 1, 1).replace(tzinfo=timezone.utc)).total_seconds() - time.time() <= 1\n"
] | f_4530069 | get a value of datetime.today() in the UTC time zone | [
"datetime",
"pytz",
"time"
] | [
{
"function": "datetime.now",
"text": "classmethod datetime.now(tz=None) \nReturn the current local date and time. If optional argument tz is None or not specified, this is like today(), but, if possible, supplies more precision than can be gotten from going through a time.time() timestamp (for example, this may be possible on platforms supplying the C gettimeofday() function). If tz is not None, it must be an instance of a tzinfo subclass, and the current date and time are converted to tz’s time zone. This function is preferred over today() and utcnow().",
"title": "python.library.datetime#datetime.datetime.now"
}
] |
|
4,842,956 | def f_4842956(list1):
|
return list2 | list2 = [x for x in list1 if x != []] |
def check(candidate): | [
"\n assert candidate([[\"a\"], [], [\"b\"]]) == [[\"a\"], [\"b\"]]\n",
"\n assert candidate([[], [1,2,3], [], [\"b\"]]) == [[1,2,3], [\"b\"]]\n"
] | f_4842956 | Get a new list `list2`by removing empty list from a list of lists `list1` | [] | [] |
4,842,956 | def f_4842956(list1):
|
return list2 | list2 = [x for x in list1 if x] |
def check(candidate): | [
"\n assert candidate([[\"a\"], [], [\"b\"]]) == [[\"a\"], [\"b\"]]\n",
"\n assert candidate([[], [1,2,3], [], [\"b\"]]) == [[1,2,3], [\"b\"]]\n"
] | f_4842956 | Create `list2` to contain the lists from list `list1` excluding the empty lists from `list1` | [] | [] |
9,262,278 | def f_9262278(data):
return | HttpResponse(data, content_type='application/json') |
import os
import json
from django.http import HttpResponse
from django.conf import settings
if not settings.configured:
settings.configure(DEBUG=True)
def check(candidate): | [
"\n if settings.DEBUG:\n assert candidate(json.dumps({\"Sample-Key\": \"Sample-Value\"})).content == b'{\"Sample-Key\": \"Sample-Value\"}'\n",
"\n if settings.DEBUG:\n assert candidate(json.dumps({\"Sample-Key\": \"Sample-Value\"}))['content-type'] == 'application/json'\n"
] | f_9262278 | Django response with JSON `data` | [
"django",
"json",
"os"
] | [
{
"function": "HttpResponse",
"text": "class HttpResponse",
"title": "django.ref.request-response#django.http.HttpResponse"
}
] |
|
17,284,947 | def f_17284947(example_str):
return | re.findall('(.*?)\\[.*?\\]', example_str) |
import re
def check(candidate): | [
"\n list_elems = candidate(\"Josie Smith [3996 COLLEGE AVENUE, SOMETOWN, MD 21003]Mugsy Dog Smith [2560 OAK ST, GLENMEADE, WI 14098]\")\n assert \"\".join(list_elems).strip() == 'Josie Smith Mugsy Dog Smith'\n"
] | f_17284947 | get all text that is not enclosed within square brackets in string `example_str` | [
"re"
] | [
{
"function": "re.findall",
"text": "re.findall(pattern, string, flags=0) \nReturn all non-overlapping matches of pattern in string, as a list of strings. The string is scanned left-to-right, and matches are returned in the order found. If one or more groups are present in the pattern, return a list of groups; this will be a list of tuples if the pattern has more than one group. Empty matches are included in the result. Changed in version 3.7: Non-empty matches can now start just after a previous empty match.",
"title": "python.library.re#re.findall"
}
] |
|
17,284,947 | def f_17284947(example_str):
return | re.findall('(.*?)(?:\\[.*?\\]|$)', example_str) |
import re
def check(candidate): | [
"\n list_elems = candidate(\"Josie Smith [3996 COLLEGE AVENUE, SOMETOWN, MD 21003]Mugsy Dog Smith [2560 OAK ST, GLENMEADE, WI 14098]\")\n assert \"\".join(list_elems).strip() == 'Josie Smith Mugsy Dog Smith'\n"
] | f_17284947 | Use a regex to get all text in a string `example_str` that is not surrounded by square brackets | [
"re"
] | [
{
"function": "re.findall",
"text": "re.findall(pattern, string, flags=0) \nReturn all non-overlapping matches of pattern in string, as a list of strings. The string is scanned left-to-right, and matches are returned in the order found. If one or more groups are present in the pattern, return a list of groups; this will be a list of tuples if the pattern has more than one group. Empty matches are included in the result. Changed in version 3.7: Non-empty matches can now start just after a previous empty match.",
"title": "python.library.re#re.findall"
}
] |
|
14,182,339 | def f_14182339():
return | re.findall('\\(.+?\\)|\\w', '(zyx)bc') |
import re
def check(candidate): | [
"\n assert candidate() == ['(zyx)', 'b', 'c']\n"
] | f_14182339 | get whatever is between parentheses as a single match, and any char outside as an individual match in string '(zyx)bc' | [
"re"
] | [
{
"function": "re.findall",
"text": "re.findall(pattern, string, flags=0) \nReturn all non-overlapping matches of pattern in string, as a list of strings. The string is scanned left-to-right, and matches are returned in the order found. If one or more groups are present in the pattern, return a list of groups; this will be a list of tuples if the pattern has more than one group. Empty matches are included in the result. Changed in version 3.7: Non-empty matches can now start just after a previous empty match.",
"title": "python.library.re#re.findall"
}
] |
|
14,182,339 | def f_14182339():
return | re.findall('\\((.*?)\\)|(\\w)', '(zyx)bc') |
import re
def check(candidate): | [
"\n assert candidate() == [('zyx', ''), ('', 'b'), ('', 'c')]\n"
] | f_14182339 | match regex '\\((.*?)\\)|(\\w)' with string '(zyx)bc' | [
"re"
] | [
{
"function": "re.findall",
"text": "re.findall(pattern, string, flags=0) \nReturn all non-overlapping matches of pattern in string, as a list of strings. The string is scanned left-to-right, and matches are returned in the order found. If one or more groups are present in the pattern, return a list of groups; this will be a list of tuples if the pattern has more than one group. Empty matches are included in the result. Changed in version 3.7: Non-empty matches can now start just after a previous empty match.",
"title": "python.library.re#re.findall"
}
] |
|
14,182,339 | def f_14182339():
return | re.findall('\\(.*?\\)|\\w', '(zyx)bc') |
import re
def check(candidate): | [
"\n assert candidate() == ['(zyx)', 'b', 'c']\n"
] | f_14182339 | match multiple regex patterns with the alternation operator `|` in a string `(zyx)bc` | [
"re"
] | [
{
"function": "re.findall",
"text": "re.findall(pattern, string, flags=0) \nReturn all non-overlapping matches of pattern in string, as a list of strings. The string is scanned left-to-right, and matches are returned in the order found. If one or more groups are present in the pattern, return a list of groups; this will be a list of tuples if the pattern has more than one group. Empty matches are included in the result. Changed in version 3.7: Non-empty matches can now start just after a previous empty match.",
"title": "python.library.re#re.findall"
}
] |
|
7,126,916 | def f_7126916(elements):
|
return elements | elements = ['%{0}%'.format(element) for element in elements] |
def check(candidate): | [
"\n elements = ['abc', 'def', 'ijk', 'mno']\n assert candidate(elements) == ['%abc%', '%def%', '%ijk%', '%mno%']\n",
"\n elements = [1, 2, 3, 4, 500]\n assert candidate(elements) == ['%1%', '%2%', '%3%', '%4%', '%500%']\n"
] | f_7126916 | formate each string cin list `elements` into pattern '%{0}%' | [] | [] |
3,595,685 | def f_3595685():
return | subprocess.Popen(['background-process', 'arguments']) |
import subprocess
from unittest.mock import Mock
def check(candidate): | [
"\n subprocess.Popen = Mock(return_value = 0)\n assert candidate() == 0\n"
] | f_3595685 | Open a background process 'background-process' with arguments 'arguments' | [
"subprocess"
] | [
{
"function": "subprocess.Popen",
"text": "class subprocess.Popen(args, bufsize=-1, executable=None, stdin=None, stdout=None, stderr=None, preexec_fn=None, close_fds=True, shell=False, cwd=None, env=None, universal_newlines=None, startupinfo=None, creationflags=0, restore_signals=True, start_new_session=False, pass_fds=(), *, group=None, extra_groups=None, user=None, umask=-1, encoding=None, errors=None, text=None) \nExecute a child program in a new process. On POSIX, the class uses os.execvp()-like behavior to execute the child program. On Windows, the class uses the Windows CreateProcess() function. The arguments to Popen are as follows. args should be a sequence of program arguments or else a single string or path-like object. By default, the program to execute is the first item in args if args is a sequence. If args is a string, the interpretation is platform-dependent and described below. See the shell and executable arguments for additional differences from the default behavior. Unless otherwise stated, it is recommended to pass args as a sequence. An example of passing some arguments to an external program as a sequence is: Popen([\"/usr/bin/git\", \"commit\", \"-m\", \"Fixes a bug.\"])\n On POSIX, if args is a string, the string is interpreted as the name or path of the program to execute. However, this can only be done if not passing arguments to the program. Note It may not be obvious how to break a shell command into a sequence of arguments, especially in complex cases. shlex.split() can illustrate how to determine the correct tokenization for args: >>> import shlex, subprocess",
"title": "python.library.subprocess#subprocess.Popen"
}
] |
|
18,453,566 | def f_18453566(mydict, mykeys):
return | [mydict[x] for x in mykeys] |
def check(candidate): | [
"\n mydict = {'one': 1, 'two': 2, 'three': 3}\n mykeys = ['three', 'one']\n assert candidate(mydict, mykeys) == [3, 1]\n",
"\n mydict = {'one': 1.0, 'two': 2.0, 'three': 3.0}\n mykeys = ['one']\n assert candidate(mydict, mykeys) == [1.0]\n"
] | f_18453566 | get list of values from dictionary 'mydict' w.r.t. list of keys 'mykeys' | [] | [] |
|
12,692,135 | def f_12692135():
return | dict([('Name', 'Joe'), ('Age', 22)]) |
def check(candidate): | [
"\n assert candidate() == {'Name': 'Joe', 'Age': 22}\n"
] | f_12692135 | convert list `[('Name', 'Joe'), ('Age', 22)]` into a dictionary | [] | [] |
|
14,401,047 | def f_14401047(data):
return | data.mean(axis=1).reshape(data.shape[0], -1) |
import numpy as np
def check(candidate): | [
"\n data = np.array([[1, 2, 3, 4, 4, 3, 7, 1], [6, 2, 3, 4, 3, 4, 4, 1]])\n expected_res = np.array([[3.125], [3.375]])\n assert np.array_equal(candidate(data), expected_res)\n"
] | f_14401047 | average each two columns of array `data` | [
"numpy"
] | [
{
"function": "numpy.ndarray.mean",
"text": "numpy.ndarray.mean method ndarray.mean(axis=None, dtype=None, out=None, keepdims=False, *, where=True)\n \nReturns the average of the array elements along given axis. Refer to numpy.mean for full documentation. See also numpy.mean\n\nequivalent function",
"title": "numpy.reference.generated.numpy.ndarray.mean"
},
{
"function": "numpy.ndarray.reshape",
"text": "numpy.ndarray.reshape method ndarray.reshape(shape, order='C')\n \nReturns an array containing the same data with a new shape. Refer to numpy.reshape for full documentation. See also numpy.reshape\n\nequivalent function Notes Unlike the free function numpy.reshape, this method on ndarray allows the elements of the shape parameter to be passed in as separate arguments. For example, a.reshape(10, 11) is equivalent to a.reshape((10, 11)).",
"title": "numpy.reference.generated.numpy.ndarray.reshape"
}
] |
|
18,886,596 | def f_18886596(s):
return | s.replace('"', '\"') |
def check(candidate): | [
"\n s = 'This sentence has some \"quotes\" in it'\n assert candidate(s) == 'This sentence has some \\\"quotes\\\" in it'\n"
] | f_18886596 | double backslash escape all double quotes in string `s` | [] | [] |
|
5,932,059 | def f_5932059(s):
return | re.split('(\\W+)', s) |
import re
def check(candidate): | [
"\n s = \"this is a\\nsentence\"\n assert candidate(s) == ['this', ' ', 'is', ' ', 'a', '\\n', 'sentence']\n"
] | f_5932059 | split a string `s` into a list of words and whitespace | [
"re"
] | [
{
"function": "re.split",
"text": "re.split(pattern, string, maxsplit=0, flags=0) \nSplit string by the occurrences of pattern. If capturing parentheses are used in pattern, then the text of all groups in the pattern are also returned as part of the resulting list. If maxsplit is nonzero, at most maxsplit splits occur, and the remainder of the string is returned as the final element of the list. >>> re.split(r'\\W+', 'Words, words, words.')\n['Words', 'words', 'words', '']",
"title": "python.library.re#re.split"
}
] |
|
9,938,130 | def f_9938130(df):
return | df.plot(kind='barh', stacked=True) |
import pandas as pd
def check(candidate): | [
"\n data = [[1, 3], [2, 5], [4, 8]]\n df = pd.DataFrame(data, columns = ['a', 'b'])\n assert str(candidate(df)).split('(')[0] == 'AxesSubplot'\n"
] | f_9938130 | plotting stacked barplots on a panda data frame `df` | [
"pandas"
] | [
{
"function": "df.plot",
"text": "pandas.DataFrame.plot DataFrame.plot(*args, **kwargs)[source]\n \nMake plots of Series or DataFrame. Uses the backend specified by the option plotting.backend. By default, matplotlib is used. Parameters ",
"title": "pandas.reference.api.pandas.dataframe.plot"
}
] |
|
35,945,473 | def f_35945473(myDictionary):
return | {i[1]: i[0] for i in list(myDictionary.items())} |
def check(candidate): | [
"\n assert candidate({'a' : 'b', 'c' : 'd'}) == {'b': 'a', 'd': 'c'}\n"
] | f_35945473 | reverse the keys and values in a dictionary `myDictionary` | [] | [] |
|
30,729,735 | def f_30729735(myList):
return | [i for i, j in enumerate(myList) if 'how' in j.lower() or 'what' in j.lower()] |
def check(candidate): | [
"\n assert candidate(['abc', 'how', 'what', 'def']) == [1, 2]\n"
] | f_30729735 | finding the index of elements containing substring 'how' and 'what' in a list of strings 'myList'. | [] | [] |
|
1,303,243 | def f_1303243(obj):
return | isinstance(obj, str) |
def check(candidate): | [
"\n assert candidate('python3') == True\n",
"\n assert candidate(1.23) == False\n"
] | f_1303243 | check if object `obj` is a string | [] | [] |
|
1,303,243 | def f_1303243(o):
return | isinstance(o, str) |
def check(candidate): | [
"\n assert candidate(\"hello\") == True\n",
"\n assert candidate(123) == False\n",
"\n assert candidate([]) == False\n",
"\n assert candidate({\"aa\", \"v\"}) == False\n",
"\n assert candidate(\"123\") == True\n"
] | f_1303243 | check if object `o` is a string | [] | [] |
|
1,303,243 | def f_1303243(o):
return | (type(o) is str) |
def check(candidate): | [
"\n assert candidate(\"hello\") == True\n",
"\n assert candidate(123) == False\n",
"\n assert candidate([]) == False\n",
"\n assert candidate({\"aa\", \"v\"}) == False\n",
"\n assert candidate(\"123\") == True\n"
] | f_1303243 | check if object `o` is a string | [] | [] |
|
1,303,243 | def f_1303243(obj_to_test):
return | isinstance(obj_to_test, str) |
def check(candidate): | [
"\n assert candidate(\"hello\") == True\n",
"\n assert candidate(123) == False\n",
"\n assert candidate([]) == False\n",
"\n assert candidate({\"aa\", \"v\"}) == False\n",
"\n assert candidate(\"123\") == True\n"
] | f_1303243 | check if `obj_to_test` is a string | [] | [] |
|
8,177,079 | def f_8177079(list1, list2):
|
return | list2.extend(list1) |
def check(candidate): | [
"\n a, b = [1, 2, 3], [4, 5, 6]\n candidate(a, b)\n assert b == [4, 5, 6, 1, 2, 3]\n",
"\n a, c = [1, 2, 3], [7, 8, 9]\n candidate(a, c)\n assert c == [7, 8, 9, 1, 2, 3] \n",
"\n b = [4, 5, 6, 1, 2, 3]\n c = [7, 8, 9, 1, 2, 3] \n candidate(b, c)\n assert c == [7, 8, 9, 1, 2, 3, 4, 5, 6, 1, 2, 3]\n"
] | f_8177079 | append list `list1` to `list2` | [] | [] |
8,177,079 | def f_8177079(mylog, list1):
|
return | list1.extend(mylog) |
def check(candidate): | [
"\n a, b = [1, 2, 3], [4, 5, 6]\n candidate(a, b)\n assert b == [4, 5, 6, 1, 2, 3]\n",
"\n a, c = [1, 2, 3], [7, 8, 9]\n candidate(a, c)\n assert c == [7, 8, 9, 1, 2, 3] \n",
"\n b = [4, 5, 6, 1, 2, 3]\n c = [7, 8, 9, 1, 2, 3] \n candidate(b, c)\n assert c == [7, 8, 9, 1, 2, 3, 4, 5, 6, 1, 2, 3]\n"
] | f_8177079 | append list `mylog` to `list1` | [] | [] |
8,177,079 | def f_8177079(a, c):
|
return | c.extend(a) |
def check(candidate): | [
"\n a, b = [1, 2, 3], [4, 5, 6]\n candidate(a, b)\n assert b == [4, 5, 6, 1, 2, 3]\n",
"\n a, c = [1, 2, 3], [7, 8, 9]\n candidate(a, c)\n assert c == [7, 8, 9, 1, 2, 3] \n",
"\n b = [4, 5, 6, 1, 2, 3]\n c = [7, 8, 9, 1, 2, 3] \n candidate(b, c)\n assert c == [7, 8, 9, 1, 2, 3, 4, 5, 6, 1, 2, 3]\n"
] | f_8177079 | append list `a` to `c` | [] | [] |
8,177,079 | def f_8177079(mylog, list1):
|
return | for line in mylog:
list1.append(line) |
def check(candidate): | [
"\n a, b = [1, 2, 3], [4, 5, 6]\n candidate(a, b)\n assert b == [4, 5, 6, 1, 2, 3]\n",
"\n a, c = [1, 2, 3], [7, 8, 9]\n candidate(a, c)\n assert c == [7, 8, 9, 1, 2, 3] \n",
"\n b = [4, 5, 6, 1, 2, 3]\n c = [7, 8, 9, 1, 2, 3] \n candidate(b, c)\n assert c == [7, 8, 9, 1, 2, 3, 4, 5, 6, 1, 2, 3]\n"
] | f_8177079 | append items in list `mylog` to `list1` | [] | [] |
4,126,227 | def f_4126227(a, b):
|
return | b.append((a[0][0], a[0][2])) |
def check(candidate): | [
"\n a = [(1,2,3),(4,5,6)]\n b = [(0,0)]\n candidate(a, b)\n assert(b == [(0, 0), (1, 3)])\n"
] | f_4126227 | append a tuple of elements from list `a` with indexes '[0][0] [0][2]' to list `b` | [] | [] |
34,902,378 | def f_34902378(app):
|
return | app.config['SECRET_KEY'] = 'Your_secret_string' |
from flask import Flask
def check(candidate): | [
"\n app = Flask(\"test\")\n candidate(app)\n assert app.config['SECRET_KEY'] == 'Your_secret_string'\n"
] | f_34902378 | Initialize `SECRET_KEY` in flask config with `Your_secret_string ` | [
"flask"
] | [
{
"function": "flask.Flask.config",
"text": "config \nThe configuration dictionary as Config. This behaves exactly like a regular dictionary but supports additional methods to load a config from files.",
"title": "flask.api.index#flask.Flask.config"
}
] |
22,799,300 | def f_22799300(out):
return | pd.DataFrame(out.tolist(), columns=['out-1', 'out-2'], index=out.index) |
import numpy as np
import pandas as pd
from scipy import stats
def check(candidate): | [
"\n df = pd.DataFrame(dict(x=np.random.randn(100), y=np.repeat(list(\"abcd\"), 25)))\n out = df.groupby(\"y\").x.apply(stats.ttest_1samp, 0)\n test = pd.DataFrame(out.tolist())\n test.columns = ['out-1', 'out-2']\n test.index = out.index\n res = candidate(out)\n assert(test.equals(res))\n"
] | f_22799300 | unpack a series of tuples in pandas `out` into a DataFrame with column names 'out-1' and 'out-2' | [
"numpy",
"pandas",
"scipy"
] | [
{
"function": "pandas.dataframe",
"text": "pandas.DataFrame classpandas.DataFrame(data=None, index=None, columns=None, dtype=None, copy=None)[source]\n \nTwo-dimensional, size-mutable, potentially heterogeneous tabular data. Data structure also contains labeled axes (rows and columns). Arithmetic operations align on both row and column labels. Can be thought of as a dict-like container for Series objects. The primary pandas data structure. Parameters ",
"title": "pandas.reference.api.pandas.dataframe"
}
] |