| message,message_type,message_id,conversation_id |
| Concatenate elements of a list 'x' of multiple integers to a single integer,instruction,0,0 |
| "```sum(d * 10 ** i for i, d in enumerate(x[::-1]))```",output,1,0 |
| convert a list of integers into a single integer,instruction,0,1 |
| "```r = int(''.join(map(str, x)))```",output,1,1 |
| convert a DateTime string back to a DateTime object of format '%Y-%m-%d %H:%M:%S.%f',instruction,0,2 |
| "```datetime.strptime('2010-11-13 10:33:54.227806', '%Y-%m-%d %H:%M:%S.%f')```",output,1,2 |
| get the average of a list values for each key in dictionary `d`),instruction,0,3 |
| "```[(i, sum(j) / len(j)) for i, j in list(d.items())]```",output,1,3 |
| "zip two lists `[1, 2]` and `[3, 4]` into a list of two tuples containing elements at the same index in each list",instruction,0,4 |
| "```zip([1, 2], [3, 4])```",output,1,4 |
| prepend string 'hello' to all items in list 'a',instruction,0,5 |
| ```['hello{0}'.format(i) for i in a]```,output,1,5 |
| regex for repeating words in a string `s`,instruction,0,6 |
| "```re.sub('(?<!\\S)((\\S+)(?:\\s+\\2))(?:\\s+\\2)+(?!\\S)', '\\1', s)```",output,1,6 |
| normalize a pandas dataframe `df` by row,instruction,0,7 |
| "```df.div(df.sum(axis=1), axis=0)```",output,1,7 |
| swap values in a tuple/list inside a list `mylist`,instruction,0,8 |
| "```map(lambda t: (t[1], t[0]), mylist)```",output,1,8 |
| Swap values in a tuple/list in list `mylist`,instruction,0,9 |
| "```[(t[1], t[0]) for t in mylist]```",output,1,9 |
| ,instruction,0,10 |
| "```driver.find_element_by_xpath(""//p[@id, 'one']/following-sibling::p"")```",output,1,10 |
| "find all occurrences of the pattern '\\[[^\\]]*\\]|\\([^\\)]*\\)|""[^""]*""|\\S+' within `strs`",instruction,0,11 |
| "```re.findall('\\[[^\\]]*\\]|\\([^\\)]*\\)|""[^""]*""|\\S+', strs)```",output,1,11 |
| "generate the combinations of 3 from a set `{1, 2, 3, 4}`",instruction,0,12 |
| "```print(list(itertools.combinations({1, 2, 3, 4}, 3)))```",output,1,12 |
| "add multiple columns `hour`, `weekday`, `weeknum` to pandas data frame `df` from lambda function `lambdafunc`",instruction,0,13 |
| "```df[['hour', 'weekday', 'weeknum']] = df.apply(lambdafunc, axis=1)```",output,1,13 |
| BeautifulSoup search string 'Elsie' inside tag 'a',instruction,0,14 |
| "```soup.find_all('a', string='Elsie')```",output,1,14 |
| "Convert a datetime object `my_datetime` into readable format `%B %d, %Y`",instruction,0,15 |
| "```my_datetime.strftime('%B %d, %Y')```",output,1,15 |
| parse string `s` to int when string contains a number,instruction,0,16 |
| ```int(''.join(c for c in s if c.isdigit()))```,output,1,16 |
| add dictionary `{'class': {'section': 5}}` to key 'Test' of dictionary `dic`,instruction,0,17 |
| ```dic['Test'].update({'class': {'section': 5}})```,output,1,17 |
| transforming the string `s` into dictionary,instruction,0,18 |
| "```dict(map(int, x.split(':')) for x in s.split(','))```",output,1,18 |
| ,instruction,0,19 |
| "```driver.find_element_by_xpath(""//div[@id='a']//a[@class='click']"")```",output,1,19 |
| "find rows matching `(0,1)` in a 2 dimensional numpy array `vals`",instruction,0,20 |
| "```np.where((vals == (0, 1)).all(axis=1))```",output,1,20 |
| ,instruction,0,21 |
| ```SomeModel.objects.filter(id=id).delete()```,output,1,21 |
| "build a dictionary containing the conversion of each list in list `[['two', 2], ['one', 1]]` to a key/value pair as its items",instruction,0,22 |
| "```dict([['two', 2], ['one', 1]])```",output,1,22 |
| convert list `l` to dictionary having each two adjacent elements as key/value pair,instruction,0,23 |
| "```dict(zip(l[::2], l[1::2]))```",output,1,23 |
| assign float 9.8 to variable `GRAVITY`,instruction,0,24 |
| ```GRAVITY = 9.8```,output,1,24 |
| "separate numbers from characters in string ""30m1000n20m""",instruction,0,25 |
| "```re.findall('(([0-9]+)([A-Z]))', '20M10000N80M')```",output,1,25 |
| separate numbers and characters in string '20M10000N80M',instruction,0,26 |
| "```re.findall('([0-9]+|[A-Z])', '20M10000N80M')```",output,1,26 |
| separate numbers and characters in string '20M10000N80M',instruction,0,27 |
| "```re.findall('([0-9]+)([A-Z])', '20M10000N80M')```",output,1,27 |
| "Get a list of words from a string `Hello world, my name is...James the 2nd!` removing punctuation",instruction,0,28 |
| "```re.compile('\\w+').findall('Hello world, my name is...James the 2nd!')```",output,1,28 |
| Convert string '03:55' into datetime.time object,instruction,0,29 |
| "```datetime.datetime.strptime('03:55', '%H:%M').time()```",output,1,29 |
| request url 'https://www.reporo.com/' without verifying SSL certificates,instruction,0,30 |
| "```requests.get('https://www.reporo.com/', verify=False)```",output,1,30 |
| Extract values not equal to 0 from numpy array `a`,instruction,0,31 |
| ```a[a != 0]```,output,1,31 |
| map two lists `keys` and `values` into a dictionary,instruction,0,32 |
| "```new_dict = {k: v for k, v in zip(keys, values)}```",output,1,32 |
| map two lists `keys` and `values` into a dictionary,instruction,0,33 |
| "```dict((k, v) for k, v in zip(keys, values))```",output,1,33 |
| map two lists `keys` and `values` into a dictionary,instruction,0,34 |
| "```dict([(k, v) for k, v in zip(keys, values)])```",output,1,34 |
| find the string matches within parenthesis from a string `s` using regex,instruction,0,35 |
| "```m = re.search('\\[(\\w+)\\]', s)```",output,1,35 |
| Enable the SO_REUSEADDR socket option in socket object `s` to fix the error `only one usage of each socket address is normally permitted`,instruction,0,36 |
| "```s.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)```",output,1,36 |
| append the sum of each tuple pair in the grouped list `list1` and list `list2` elements to list `list3`,instruction,0,37 |
| "```list3 = [(a + b) for a, b in zip(list1, list2)]```",output,1,37 |
| converting hex string `s` to its integer representations,instruction,0,38 |
| ```[ord(c) for c in s.decode('hex')]```,output,1,38 |
| sort list `student_tuples` by second element of each tuple in ascending and third element of each tuple in descending,instruction,0,39 |
| "```print(sorted(student_tuples, key=lambda t: (-t[2], t[0])))```",output,1,39 |
| get list of duplicated elements in range of 3,instruction,0,40 |
| "```[y for x in range(3) for y in [x, x]]```",output,1,40 |
| read the contents of the file 'file.txt' into `txt`,instruction,0,41 |
| ```txt = open('file.txt').read()```,output,1,41 |
| divide each element in list `myList` by integer `myInt`,instruction,0,42 |
| ```myList[:] = [(x / myInt) for x in myList]```,output,1,42 |
| ,instruction,0,43 |
| "```""""""Name: {0[person.name]}"""""".format({'person.name': 'Joe'})```",output,1,43 |
| replace white spaces in dataframe `df` with '_',instruction,0,44 |
| "```df.replace(' ', '_', regex=True)```",output,1,44 |
| convert date `my_date` to datetime,instruction,0,45 |
| "```datetime.datetime.combine(my_date, datetime.time.min)```",output,1,45 |
| convert tuple `tst` to string `tst2`,instruction,0,46 |
| ```tst2 = str(tst)```,output,1,46 |
| get modified time of file `file`,instruction,0,47 |
| ```time.ctime(os.path.getmtime(file))```,output,1,47 |
| get creation time of file `file`,instruction,0,48 |
| ```time.ctime(os.path.getctime(file))```,output,1,48 |
| get modification time of file `filename`,instruction,0,49 |
| ```t = os.path.getmtime(filename)```,output,1,49 |
| get modification time of file `path`,instruction,0,50 |
| ```os.path.getmtime(path)```,output,1,50 |
| get modified time of file `file`,instruction,0,51 |
| ```print(('last modified: %s' % time.ctime(os.path.getmtime(file))))```,output,1,51 |
| get the creation time of file `file`,instruction,0,52 |
| ```print(('created: %s' % time.ctime(os.path.getctime(file))))```,output,1,52 |
| get the creation time of file `path_to_file`,instruction,0,53 |
| ```return os.path.getctime(path_to_file)```,output,1,53 |
| execute os command ''TASKKILL /F /IM firefox.exe'',instruction,0,54 |
| ```os.system('TASKKILL /F /IM firefox.exe')```,output,1,54 |
| split string `string` on whitespaces using a generator,instruction,0,55 |
| "```return (x.group(0) for x in re.finditer(""[A-Za-z']+"", string))```",output,1,55 |
| Unpack each value in list `x` to its placeholder '%' in string '%.2f',instruction,0,56 |
| "```"""""", """""".join(['%.2f'] * len(x))```",output,1,56 |
| match regex pattern '(\\d+(\\.\\d+)?)' with string '3434.35353',instruction,0,57 |
| "```print(re.match('(\\d+(\\.\\d+)?)', '3434.35353').group(1))```",output,1,57 |
| replace parentheses and all data within it with empty string '' in column 'name' of dataframe `df`,instruction,0,58 |
| "```df['name'].str.replace('\\(.*\\)', '')```",output,1,58 |
| create a list `result` containing elements form list `list_a` if first element of list `list_a` is in list `list_b`,instruction,0,59 |
| ```result = [x for x in list_a if x[0] in list_b]```,output,1,59 |
| "generate all possible string permutations of each two elements in list `['hel', 'lo', 'bye']`",instruction,0,60 |
| "```print([''.join(a) for a in combinations(['hel', 'lo', 'bye'], 2)])```",output,1,60 |
| get a list of items form nested list `li` where third element of each item contains string 'ar',instruction,0,61 |
| ```[x for x in li if 'ar' in x[2]]```,output,1,61 |
| Sort lists in the list `unsorted_list` by the element at index 3 of each list,instruction,0,62 |
| ```unsorted_list.sort(key=lambda x: x[3])```,output,1,62 |
| Log message 'test' on the root logger.,instruction,0,63 |
| ```logging.info('test')```,output,1,63 |
| "Return a subplot axes positioned by the grid definition `1,1,1` using matpotlib",instruction,0,64 |
| "```fig.add_subplot(1, 1, 1)```",output,1,64 |
| Sort dictionary `x` by value in ascending order,instruction,0,65 |
| "```sorted(list(x.items()), key=operator.itemgetter(1))```",output,1,65 |
| Sort dictionary `dict1` by value in ascending order,instruction,0,66 |
| "```sorted(dict1, key=dict1.get)```",output,1,66 |
| Sort dictionary `d` by value in descending order,instruction,0,67 |
| "```sorted(d, key=d.get, reverse=True)```",output,1,67 |
| Sort dictionary `d` by value in ascending order,instruction,0,68 |
| "```sorted(list(d.items()), key=(lambda x: x[1]))```",output,1,68 |
| elementwise product of 3d arrays `A` and `B`,instruction,0,69 |
| "```np.einsum('ijk,ikl->ijl', A, B)```",output,1,69 |
| Print a string `card` with string formatting,instruction,0,70 |
| ```print('I have: {0.price}'.format(card))```,output,1,70 |
| Write a comment `# Data for Class A\n` to a file object `f`,instruction,0,71 |
| ```f.write('# Data for Class A\n')```,output,1,71 |
| move the last item in list `a` to the beginning,instruction,0,72 |
| ```a = a[-1:] + a[:-1]```,output,1,72 |
| Parse DateTime object `datetimevariable` using format '%Y-%m-%d',instruction,0,73 |
| ```datetimevariable.strftime('%Y-%m-%d')```,output,1,73 |
| Normalize line ends in a string 'mixed',instruction,0,74 |
| "```mixed.replace('\r\n', '\n').replace('\r', '\n')```",output,1,74 |
| find the real user home directory using python,instruction,0,75 |
| ```os.path.expanduser('~user')```,output,1,75 |
| index a list `L` with another list `Idx`,instruction,0,76 |
| ```T = [L[i] for i in Idx]```,output,1,76 |
| get a list of words `words` of a file 'myfile',instruction,0,77 |
| ```words = open('myfile').read().split()```,output,1,77 |
| Get a list of lists with summing the values of the second element from each list of lists `data`,instruction,0,78 |
| ```[[sum([x[1] for x in i])] for i in data]```,output,1,78 |
| summing the second item in a list of lists of lists,instruction,0,79 |
| ```[sum([x[1] for x in i]) for i in data]```,output,1,79 |
| sort objects in `Articles` in descending order of counts of `likes`,instruction,0,80 |
| ```Article.objects.annotate(like_count=Count('likes')).order_by('-like_count')```,output,1,80 |
| return a DateTime object with the current UTC date,instruction,0,81 |
| ```today = datetime.datetime.utcnow().date()```,output,1,81 |
| create a list containing the multiplication of each elements at the same index of list `lista` and list `listb`,instruction,0,82 |
| "```[(a * b) for a, b in zip(lista, listb)]```",output,1,82 |
| fetch smilies matching regex pattern '(?::|;|=)(?:-)?(?:\\)|\\(|D|P)' in string `s`,instruction,0,83 |
| "```re.findall('(?::|;|=)(?:-)?(?:\\)|\\(|D|P)', s)```",output,1,83 |
| match the pattern '[:;][)(](?![)(])' to the string `str`,instruction,0,84 |
| "```re.match('[:;][)(](?![)(])', str)```",output,1,84 |
| convert a list of objects `list_name` to json string `json_string`,instruction,0,85 |
| ```json_string = json.dumps([ob.__dict__ for ob in list_name])```,output,1,85 |
| create a list `listofzeros` of `n` zeros,instruction,0,86 |
| ```listofzeros = [0] * n```,output,1,86 |
| decode the string 'stringnamehere' to UTF-8,instruction,0,87 |
| "```stringnamehere.decode('utf-8', 'ignore')```",output,1,87 |
| Match regex pattern '((?:A|B|C)D)' on string 'BDE',instruction,0,88 |
| "```re.findall('((?:A|B|C)D)', 'BDE')```",output,1,88 |
| Create a key `key` if it does not exist in dict `dic` and append element `value` to value.,instruction,0,89 |
| "```dic.setdefault(key, []).append(value)```",output,1,89 |
| Get the value of the minimum element in the second column of array `a`,instruction,0,90 |
| "```a[np.argmin(a[:, (1)])]```",output,1,90 |
| extend dictionary `a` with key/value pairs of dictionary `b`,instruction,0,91 |
| ```a.update(b)```,output,1,91 |
| removing key values pairs with key 'mykey1' from a list of dictionaries `mylist`,instruction,0,92 |
| "```[{k: v for k, v in d.items() if k != 'mykey1'} for d in mylist]```",output,1,92 |
| ,instruction,0,93 |
| "```[dict((k, v) for k, v in d.items() if k != 'mykey1') for d in mylist]```",output,1,93 |
| create 3 by 3 matrix of random numbers,instruction,0,94 |
| "```numpy.random.random((3, 3))```",output,1,94 |
| make new column 'C' in panda dataframe by adding values from other columns 'A' and 'B',instruction,0,95 |
| ```df['C'] = df['A'] + df['B']```,output,1,95 |
| create a list of values from the dictionary `programs` that have a key with a case insensitive match to 'new york',instruction,0,96 |
| "```[value for key, value in list(programs.items()) if 'new york' in key.lower()]```",output,1,96 |
| append a path `/path/to/main_folder` in system path,instruction,0,97 |
| ```sys.path.append('/path/to/main_folder')```,output,1,97 |
| get all digits in a string `s` after a '[' character,instruction,0,98 |
| "```re.findall('\\d+(?=[^[]+$)', s)```",output,1,98 |
| python pickle/unpickle a list to/from a file 'afile',instruction,0,99 |
| "```pickle.load(open('afile', 'rb'))```",output,1,99 |
| ,instruction,0,100 |
| ```driver.find_element_by_xpath('xpath').click()```,output,1,100 |
| count unique index values in column 'A' in pandas dataframe `ex`,instruction,0,101 |
| ```ex.groupby(level='A').agg(lambda x: x.index.get_level_values(1).nunique())```,output,1,101 |
| Create a pandas dataframe of values from a dictionary `d` which contains dictionaries of dictionaries,instruction,0,102 |
| "```pd.concat(map(pd.DataFrame, iter(d.values())), keys=list(d.keys())).stack().unstack(0)```",output,1,102 |
| find out the number of non-matched elements at the same index of list `a` and list `b`,instruction,0,103 |
| "```sum(1 for i, j in zip(a, b) if i != j)```",output,1,103 |
| make all keys lowercase in dictionary `d`,instruction,0,104 |
| "```d = {(a.lower(), b): v for (a, b), v in list(d.items())}```",output,1,104 |
| sort list `list_` based on first element of each tuple and by the length of the second element of each tuple,instruction,0,105 |
| "```list_.sort(key=lambda x: [x[0], len(x[1]), x[1]])```",output,1,105 |
| trim whitespace in string `s`,instruction,0,106 |
| ```s.strip()```,output,1,106 |
| trim whitespace (including tabs) in `s` on the left side,instruction,0,107 |
| ```s = s.lstrip()```,output,1,107 |
| trim whitespace (including tabs) in `s` on the right side,instruction,0,108 |
| ```s = s.rstrip()```,output,1,108 |
| trim characters ' \t\n\r' in `s`,instruction,0,109 |
| ```s = s.strip(' \t\n\r')```,output,1,109 |
| trim whitespaces (including tabs) in string `s`,instruction,0,110 |
| "```print(re.sub('[\\s+]', '', s))```",output,1,110 |
| "In Django, filter `Task.objects` based on all entities in ['A', 'P', 'F']",instruction,0,111 |
| "```Task.objects.exclude(prerequisites__status__in=['A', 'P', 'F'])```",output,1,111 |
| Change background color in Tkinter,instruction,0,112 |
| ```root.configure(background='black')```,output,1,112 |
| convert dict `result` to numpy structured array,instruction,0,113 |
| "```numpy.array([(key, val) for key, val in result.items()], dtype)```",output,1,113 |
| Concatenate dataframe `df_1` to dataframe `df_2` sorted by values of the column 'y',instruction,0,114 |
| "```pd.concat([df_1, df_2.sort_values('y')])```",output,1,114 |
| replace the last occurence of an expression '</div>' with '</bad>' in a string `s`,instruction,0,115 |
| "```re.sub('(.*)</div>', '\\1</bad>', s)```",output,1,115 |
| get the maximum of 'salary' and 'bonus' values in a dictionary,instruction,0,116 |
| "```print(max(d, key=lambda x: (d[x]['salary'], d[x]['bonus'])))```",output,1,116 |
| Filter Django objects by `author` with ids `1` and `2`,instruction,0,117 |
| ```Book.objects.filter(author__id=1).filter(author__id=2)```,output,1,117 |
| split string 'fooxyzbar' based on case-insensitive matching using string 'XYZ',instruction,0,118 |
| "```re.compile('XYZ', re.IGNORECASE).split('fooxyzbar')```",output,1,118 |
| get list of sums of neighboring integers in string `example`,instruction,0,119 |
| "```[sum(map(int, s)) for s in example.split()]```",output,1,119 |
| Get all the keys from dictionary `y` whose value is `1`,instruction,0,120 |
| ```[i for i in y if y[i] == 1]```,output,1,120 |
| converting byte string `c` in unicode string,instruction,0,121 |
| ```c.decode('unicode_escape')```,output,1,121 |
| unpivot first 2 columns into new columns 'year' and 'value' from a pandas dataframe `x`,instruction,0,122 |
| "```pd.melt(x, id_vars=['farm', 'fruit'], var_name='year', value_name='value')```",output,1,122 |
| "add key ""item3"" and value ""3"" to dictionary `default_data `",instruction,0,123 |
| ```default_data['item3'] = 3```,output,1,123 |
| "add key ""item3"" and value ""3"" to dictionary `default_data `",instruction,0,124 |
| "```default_data.update({'item3': 3, })```",output,1,124 |
| "add key value pairs 'item4' , 4 and 'item5' , 5 to dictionary `default_data`",instruction,0,125 |
| "```default_data.update({'item4': 4, 'item5': 5, })```",output,1,125 |
| Get the first and last 3 elements of list `l`,instruction,0,126 |
| ```l[:3] + l[-3:]```,output,1,126 |
| reset index to default in dataframe `df`,instruction,0,127 |
| ```df = df.reset_index(drop=True)```,output,1,127 |
| "For each index `x` from 0 to 3, append the element at index `x` of list `b` to the list at index `x` of list a.",instruction,0,128 |
| ```[a[x].append(b[x]) for x in range(3)]```,output,1,128 |
| get canonical path of the filename `path`,instruction,0,129 |
| ```os.path.realpath(path)```,output,1,129 |
| check if dictionary `L[0].f.items()` is in dictionary `a3.f.items()`,instruction,0,130 |
| ```set(L[0].f.items()).issubset(set(a3.f.items()))```,output,1,130 |
| find all the indexes in a Numpy 2D array where the value is 1,instruction,0,131 |
| ```zip(*np.where(a == 1))```,output,1,131 |
| ,instruction,0,132 |
| ```np.where(a == 1)```,output,1,132 |
| Collapse hierarchical column index to level 0 in dataframe `df`,instruction,0,133 |
| ```df.columns = df.columns.get_level_values(0)```,output,1,133 |
| "create a matrix from a list `[1, 2, 3]`",instruction,0,134 |
| "```x = scipy.matrix([1, 2, 3]).transpose()```",output,1,134 |
| add character '@' after word 'get' in string `text`,instruction,0,135 |
| "```text = re.sub('(\\bget\\b)', '\\1@', text)```",output,1,135 |
| get a numpy array that contains the element wise minimum of three 3x1 arrays,instruction,0,136 |
| "```np.array([np.arange(3), np.arange(2, -1, -1), np.ones((3,))]).min(axis=0)```",output,1,136 |
| add a column 'new_col' to dataframe `df` for index in range,instruction,0,137 |
| "```df['new_col'] = list(range(1, len(df) + 1))```",output,1,137 |
| set environment variable 'DEBUSSY' equal to 1,instruction,0,138 |
| ```os.environ['DEBUSSY'] = '1'```,output,1,138 |
| Get a environment variable `DEBUSSY`,instruction,0,139 |
| ```print(os.environ['DEBUSSY'])```,output,1,139 |
| set environment variable 'DEBUSSY' to '1',instruction,0,140 |
| ```os.environ['DEBUSSY'] = '1'```,output,1,140 |
| "update dictionary `b`, overwriting values where keys are identical, with contents of dictionary `d`",instruction,0,141 |
| ```b.update(d)```,output,1,141 |
| get all the values in column `b` from pandas data frame `df`,instruction,0,142 |
| ```df['b']```,output,1,142 |
| "make a line plot with errorbars, `ebar`, from data `x, y, err` and set color of the errorbars to `y` (yellow)",instruction,0,143 |
| "```ebar = plt.errorbar(x, y, yerr=err, ecolor='y')```",output,1,143 |
| find all files with extension '.c' in directory `folder`,instruction,0,144 |
| ```results += [each for each in os.listdir(folder) if each.endswith('.c')]```,output,1,144 |
| add unicode string '1' to UTF-8 decoded string '\xc2\xa3',instruction,0,145 |
| ```print('\xc2\xa3'.decode('utf8') + '1')```,output,1,145 |
| lower-case the string obtained by replacing the occurrences of regex pattern '(?<=[a-z])([A-Z])' in string `s` with eplacement '-\\1',instruction,0,146 |
| "```re.sub('(?<=[a-z])([A-Z])', '-\\1', s).lower()```",output,1,146 |
| ,instruction,0,147 |
| ```os.system('ulimit -s unlimited; some_executable')```,output,1,147 |
| format a string `num` using string formatting,instruction,0,148 |
| "```""""""{0:.3g}"""""".format(num)```",output,1,148 |
| append the first element of array `a` to array `a`,instruction,0,149 |
| "```numpy.append(a, a[0])```",output,1,149 |
| return the column for value 38.15 in dataframe `df`,instruction,0,150 |
| "```df.ix[:, (df.loc[0] == 38.15)].columns```",output,1,150 |
| merge 2 dataframes `df1` and `df2` with same values in a column 'revenue' with and index 'date',instruction,0,151 |
| ```df2['revenue'] = df2.CET.map(df1.set_index('date')['revenue'])```,output,1,151 |
| load a json data `json_string` into variable `json_data`,instruction,0,152 |
| ```json_data = json.loads(json_string)```,output,1,152 |
| convert radians 1 to degrees,instruction,0,153 |
| ```math.cos(math.radians(1))```,output,1,153 |
| count the number of integers in list `a`,instruction,0,154 |
| "```sum(isinstance(x, int) for x in a)```",output,1,154 |
| replacing '\u200b' with '*' in a string using regular expressions,instruction,0,155 |
| "```'used\u200b'.replace('\u200b', '*')```",output,1,155 |
| run function 'SudsMove' simultaneously,instruction,0,156 |
| ```threading.Thread(target=SudsMove).start()```,output,1,156 |
| sum of squares values in a list `l`,instruction,0,157 |
| ```sum(i * i for i in l)```,output,1,157 |
| calculate the sum of the squares of each value in list `l`,instruction,0,158 |
| "```sum(map(lambda x: x * x, l))```",output,1,158 |
| Create a dictionary `d` from list `iterable`,instruction,0,159 |
| "```d = dict(((key, value) for (key, value) in iterable))```",output,1,159 |
| Create a dictionary `d` from list `iterable`,instruction,0,160 |
| "```d = {key: value for (key, value) in iterable}```",output,1,160 |
| Create a dictionary `d` from list of key value pairs `iterable`,instruction,0,161 |
| "```d = {k: v for (k, v) in iterable}```",output,1,161 |
| "round off entries in dataframe `df` column `Alabama_exp` to two decimal places, and entries in column `Credit_exp` to three decimal places",instruction,0,162 |
| "```df.round({'Alabama_exp': 2, 'Credit_exp': 3})```",output,1,162 |
| Make function `WRITEFUNCTION` output nothing in curl `p`,instruction,0,163 |
| "```p.setopt(pycurl.WRITEFUNCTION, lambda x: None)```",output,1,163 |
| return a random word from a word list 'words',instruction,0,164 |
| ```print(random.choice(words))```,output,1,164 |
| Find a max value of the key `count` in a nested dictionary `d`,instruction,0,165 |
| "```max(d, key=lambda x: d[x]['count'])```",output,1,165 |
| "get list of string elements in string `data` delimited by commas, putting `0` in place of empty strings",instruction,0,166 |
| "```[(int(x) if x else 0) for x in data.split(',')]```",output,1,166 |
| "split string `s` into a list of strings based on ',' then replace empty strings with zero",instruction,0,167 |
| "```"""""","""""".join(x or '0' for x in s.split(','))```",output,1,167 |
| regular expression match nothing,instruction,0,168 |
| ```re.compile('$^')```,output,1,168 |
| regular expression syntax for not to match anything,instruction,0,169 |
| ```re.compile('.\\A|.\\A*|.\\A+')```,output,1,169 |
| create a regular expression object with a pattern that will match nothing,instruction,0,170 |
| ```re.compile('a^')```,output,1,170 |
| drop all columns in dataframe `df` that holds a maximum value bigger than 0,instruction,0,171 |
| ```df.columns[df.max() > 0]```,output,1,171 |
| check if date `yourdatetime` is equal to today's date,instruction,0,172 |
| ```yourdatetime.date() == datetime.today().date()```,output,1,172 |
| print bold text 'Hello',instruction,0,173 |
| ```print('\x1b[1m' + 'Hello')```,output,1,173 |
| remove 20 symbols in front of '.' in string 'unique12345678901234567890.mkv',instruction,0,174 |
| "```re.sub('.{20}(.mkv)', '\\1', 'unique12345678901234567890.mkv')```",output,1,174 |
| "Define a list with string values `['a', 'c', 'b', 'obj']`",instruction,0,175 |
| "```['a', 'c', 'b', 'obj']```",output,1,175 |
| substitute multiple whitespace with single whitespace in string `mystring`,instruction,0,176 |
| "```"""""" """""".join(mystring.split())```",output,1,176 |
| print a floating point number 2.345e-67 without any truncation,instruction,0,177 |
| ```print('{:.100f}'.format(2.345e-67))```,output,1,177 |
| Check if key 'key1' in `dict`,instruction,0,178 |
| ```('key1' in dict)```,output,1,178 |
| Check if key 'a' in `d`,instruction,0,179 |
| ```('a' in d)```,output,1,179 |
| Check if key 'c' in `d`,instruction,0,180 |
| ```('c' in d)```,output,1,180 |
| Check if a given key 'key1' exists in dictionary `dict`,instruction,0,181 |
| "```if ('key1' in dict): |
| pass```",output,1,181 |
| Check if a given key `key` exists in dictionary `d`,instruction,0,182 |
| "```if (key in d): |
| pass```",output,1,182 |
| "create a django query for a list of values `1, 4, 7`",instruction,0,183 |
| "```Blog.objects.filter(pk__in=[1, 4, 7])```",output,1,183 |
| read a binary file 'test/test.pdf',instruction,0,184 |
| "```f = open('test/test.pdf', 'rb')```",output,1,184 |
| "insert ' ' between every three digit before '.' and replace ',' with '.' in 12345678.46",instruction,0,185 |
| "```format(12345678.46, ',').replace(',', ' ').replace('.', ',')```",output,1,185 |
| Join pandas data frame `frame_1` and `frame_2` with left join by `county_ID` and right join by `countyid`,instruction,0,186 |
| "```pd.merge(frame_1, frame_2, left_on='county_ID', right_on='countyid')```",output,1,186 |
| calculate ratio of sparsity in a numpy array `a`,instruction,0,187 |
| ```np.isnan(a).sum() / np.prod(a.shape)```,output,1,187 |
| reverse sort items in default dictionary `cityPopulation` by the third item in each key's list of values,instruction,0,188 |
| "```sorted(iter(cityPopulation.items()), key=lambda k_v: k_v[1][2], reverse=True)```",output,1,188 |
| Sort dictionary `u` in ascending order based on second elements of its values,instruction,0,189 |
| "```sorted(list(u.items()), key=lambda v: v[1])```",output,1,189 |
| reverse sort dictionary `d` based on its values,instruction,0,190 |
| "```sorted(list(d.items()), key=lambda k_v: k_v[1], reverse=True)```",output,1,190 |
| sorting a defaultdict `d` by value,instruction,0,191 |
| "```sorted(list(d.items()), key=lambda k_v: k_v[1])```",output,1,191 |
| open a file 'bundled-resource.jpg' in the same directory as a python script,instruction,0,192 |
| "```f = open(os.path.join(__location__, 'bundled-resource.jpg'))```",output,1,192 |
| open the file 'words.txt' in 'rU' mode,instruction,0,193 |
| "```f = open('words.txt', 'rU')```",output,1,193 |
| divide the values with same keys of two dictionary `d1` and `d2`,instruction,0,194 |
| ```{k: (float(d2[k]) / d1[k]) for k in d2}```,output,1,194 |
| divide the value for each key `k` in dict `d2` by the value for the same key `k` in dict `d1`,instruction,0,195 |
| ```{k: (d2[k] / d1[k]) for k in list(d1.keys()) & d2}```,output,1,195 |
| divide values associated with each key in dictionary `d1` from values associated with the same key in dictionary `d2`,instruction,0,196 |
| "```dict((k, float(d2[k]) / d1[k]) for k in d2)```",output,1,196 |
| write dataframe `df` to csv file `filename` with dates formatted as yearmonthday `%Y%m%d`,instruction,0,197 |
| "```df.to_csv(filename, date_format='%Y%m%d')```",output,1,197 |
| remove a key 'key' from a dictionary `my_dict`,instruction,0,198 |
| "```my_dict.pop('key', None)```",output,1,198 |
| replace NaN values in array `a` with zeros,instruction,0,199 |
| "```b = np.where(np.isnan(a), 0, a)```",output,1,199 |
| subprocess run command 'start command -flags arguments' through the shell,instruction,0,200 |
| "```subprocess.call('start command -flags arguments', shell=True)```",output,1,200 |
| run command 'command -flags arguments &' on command line tools as separate processes,instruction,0,201 |
| "```subprocess.call('command -flags arguments &', shell=True)```",output,1,201 |
| replace percent-encoded code in request `f` to their single-character equivalent,instruction,0,202 |
| "```f = urllib.request.urlopen(url, urllib.parse.unquote(urllib.parse.urlencode(params)))```",output,1,202 |
| "remove white spaces from the end of string "" xyz """,instruction,0,203 |
| "```"""""" xyz """""".rstrip()```",output,1,203 |
| Replace special characters in utf-8 encoded string `s` using the %xx escape,instruction,0,204 |
| ```urllib.parse.quote(s.encode('utf-8'))```,output,1,204 |
| ,instruction,0,205 |
| ```urllib.parse.quote_plus('a b')```,output,1,205 |
| Create an array containing the conversion of string '100110' into separate elements,instruction,0,206 |
| "```np.array(map(int, '100110'))```",output,1,206 |
| convert a string 'mystr' to numpy array of integer values,instruction,0,207 |
| "```print(np.array(list(mystr), dtype=int))```",output,1,207 |
| convert an rgb image 'messi5.jpg' into grayscale `img`,instruction,0,208 |
| "```img = cv2.imread('messi5.jpg', 0)```",output,1,208 |
| sort list `lst` in descending order based on the second item of each tuple in it,instruction,0,209 |
| "```lst.sort(key=lambda x: x[2], reverse=True)```",output,1,209 |
| ,instruction,0,210 |
| "```indices = [i for i, x in enumerate(my_list) if x == 'whatever']```",output,1,210 |
| execute shell command 'grep -r PASSED *.log | sort -u | wc -l' with a | pipe in it,instruction,0,211 |
| "```subprocess.call('grep -r PASSED *.log | sort -u | wc -l', shell=True)```",output,1,211 |
| count the number of trailing question marks in string `my_text`,instruction,0,212 |
| ```len(my_text) - len(my_text.rstrip('?'))```,output,1,212 |
| remove dollar sign '$' from second to last column data in dataframe 'df' and convert the data into floats,instruction,0,213 |
| "```df[df.columns[1:]].replace('[\\$,]', '', regex=True).astype(float)```",output,1,213 |
| Merge column 'word' in dataframe `df2` with column 'word' on dataframe `df1`,instruction,0,214 |
| "```df1.merge(df2, how='left', on='word')```",output,1,214 |
| switch positions of each two adjacent characters in string `a`,instruction,0,215 |
| "```print(''.join(''.join(i) for i in zip(a2, a1)) + a[-1] if len(a) % 2 else '')```",output,1,215 |
| make a window `root` jump to the front,instruction,0,216 |
| "```root.attributes('-topmost', True)```",output,1,216 |
| make a window `root` jump to the front,instruction,0,217 |
| ```root.lift()```,output,1,217 |
| Convert list of booleans `walls` into a hex string,instruction,0,218 |
| "```hex(int(''.join([str(int(b)) for b in walls]), 2))```",output,1,218 |
| convert the sum of list `walls` into a hex presentation,instruction,0,219 |
| "```hex(sum(b << i for i, b in enumerate(reversed(walls))))```",output,1,219 |
| "print the string `Total score for`, the value of the variable `name`, the string `is` and the value of the variable `score` in one print call.",instruction,0,220 |
| "```print(('Total score for', name, 'is', score))```",output,1,220 |
| print multiple arguments 'name' and 'score'.,instruction,0,221 |
| "```print('Total score for {} is {}'.format(name, score))```",output,1,221 |
| print a string using multiple strings `name` and `score`,instruction,0,222 |
| "```print('Total score for %s is %s ' % (name, score))```",output,1,222 |
| print string including multiple variables `name` and `score`,instruction,0,223 |
| "```print(('Total score for', name, 'is', score))```",output,1,223 |
| serve a static html page 'your_template.html' at the root of a django project,instruction,0,224 |
| "```url('^$', TemplateView.as_view(template_name='your_template.html'))```",output,1,224 |
| "use a list of values `[3,6]` to select rows from a pandas dataframe `df`'s column 'A'",instruction,0,225 |
| "```df[df['A'].isin([3, 6])]```",output,1,225 |
| ,instruction,0,226 |
| ```instance.__class__.__name__```,output,1,226 |
| execute python code `myscript.py` in a virtualenv `/path/to/my/venv` from matlab,instruction,0,227 |
| ```system('/path/to/my/venv/bin/python myscript.py')```,output,1,227 |
| django return a QuerySet list containing the values of field 'eng_name' in model `Employees`,instruction,0,228 |
| "```Employees.objects.values_list('eng_name', flat=True)```",output,1,228 |
| "find all digits in string '6,7)' and put them to a list",instruction,0,229 |
| "```re.findall('\\d|\\d,\\d\\)', '6,7)')```",output,1,229 |
| prompt string 'Press Enter to continue...' to the console,instruction,0,230 |
| ```input('Press Enter to continue...')```,output,1,230 |
| "print string ""ABC"" as hex literal",instruction,0,231 |
| "```""""""ABC"""""".encode('hex')```",output,1,231 |
| insert a new field 'geolocCountry' on an existing document 'b' using pymongo,instruction,0,232 |
| "```db.Doc.update({'_id': b['_id']}, {'$set': {'geolocCountry': myGeolocCountry}})```",output,1,232 |
| Write a regex statement to match 'lol' to 'lolllll'.,instruction,0,233 |
| "```re.sub('l+', 'l', 'lollll')```",output,1,233 |
| BeautifulSoup find all 'tr' elements in HTML string `soup` at the five stride starting from the fourth element,instruction,0,234 |
| ```rows = soup.findAll('tr')[4::5]```,output,1,234 |
| reverse all x-axis points in pyplot,instruction,0,235 |
| ```plt.gca().invert_xaxis()```,output,1,235 |
| reverse y-axis in pyplot,instruction,0,236 |
| ```plt.gca().invert_yaxis()```,output,1,236 |
| stack two dataframes next to each other in pandas,instruction,0,237 |
| "```pd.concat([GOOG, AAPL], keys=['GOOG', 'AAPL'], axis=1)```",output,1,237 |
| create a json response `response_data`,instruction,0,238 |
| "```return HttpResponse(json.dumps(response_data), content_type='application/json')```",output,1,238 |
| decode escape sequences in string `myString`,instruction,0,239 |
| ```myString.decode('string_escape')```,output,1,239 |
| calculate the md5 checksum of a file named 'filename.exe',instruction,0,240 |
| "```hashlib.md5(open('filename.exe', 'rb').read()).hexdigest()```",output,1,240 |
| Find all keys from a dictionary `d` whose values are `desired_value`,instruction,0,241 |
| "```[k for k, v in d.items() if v == desired_value]```",output,1,241 |
| create a set containing all keys' names from dictionary `LoD`,instruction,0,242 |
| ```{k for d in LoD for k in list(d.keys())}```,output,1,242 |
| create a set containing all keys names from list of dictionaries `LoD`,instruction,0,243 |
| ```set([i for s in [list(d.keys()) for d in LoD] for i in s])```,output,1,243 |
| extract all keys from a list of dictionaries `LoD`,instruction,0,244 |
| ```[i for s in [list(d.keys()) for d in LoD] for i in s]```,output,1,244 |
| unpack keys and values of a dictionary `d` into two lists,instruction,0,245 |
| "```keys, values = zip(*list(d.items()))```",output,1,245 |
| convert a string `s` containing a decimal to an integer,instruction,0,246 |
| ```int(Decimal(s))```,output,1,246 |
| ,instruction,0,247 |
| ```int(s.split('.')[0])```,output,1,247 |
| check if array `b` contains all elements of array `a`,instruction,0,248 |
| "```numpy.in1d(b, a).all()```",output,1,248 |
| numpy: check if array 'a' contains all the numbers in array 'b'.,instruction,0,249 |
| ```numpy.array([(x in a) for x in b])```,output,1,249 |
| Draw node labels `labels` on networkx graph `G ` at position `pos`,instruction,0,250 |
| "```networkx.draw_networkx_labels(G, pos, labels)```",output,1,250 |
| make a row-by-row copy `y` of array `x`,instruction,0,251 |
| ```y = [row[:] for row in x]```,output,1,251 |
| Create 2D numpy array from the data provided in 'somefile.csv' with each row in the file having same number of values,instruction,0,252 |
| "```X = numpy.loadtxt('somefile.csv', delimiter=',')```",output,1,252 |
| get a list of items from the list `some_list` that contain string 'abc',instruction,0,253 |
| ```matching = [s for s in some_list if 'abc' in s]```,output,1,253 |
| export a pandas data frame `df` to a file `mydf.tsv` and retain the indices,instruction,0,254 |
| "```df.to_csv('mydf.tsv', sep='\t')```",output,1,254 |
| ,instruction,0,255 |
| "```random.sample(list(range(100)), 10)```",output,1,255 |
| split a string `s` on last delimiter,instruction,0,256 |
| "```s.rsplit(',', 1)```",output,1,256 |
| Check if all elements in list `lst` are tupples of long and int,instruction,0,257 |
| "```all(isinstance(x, int) for x in lst)```",output,1,257 |
| check if all elements in a list 'lst' are the same type 'int',instruction,0,258 |
| "```all(isinstance(x, int) for x in lst)```",output,1,258 |
| strip a string `line` of all carriage returns and newlines,instruction,0,259 |
| ```line.strip()```,output,1,259 |
| scroll to the bottom of a web page using selenium webdriver,instruction,0,260 |
| "```driver.execute_script('window.scrollTo(0, Y)')```",output,1,260 |
| scroll a to the bottom of a web page using selenium webdriver,instruction,0,261 |
| "```driver.execute_script('window.scrollTo(0, document.body.scrollHeight);')```",output,1,261 |
| convert Date object `dateobject` into a DateTime object,instruction,0,262 |
| "```datetime.datetime.combine(dateobject, datetime.time())```",output,1,262 |
| check if any item from list `b` is in list `a`,instruction,0,263 |
| ```print(any(x in a for x in b))```,output,1,263 |
| save a numpy array `image_array` as an image 'outfile.jpg',instruction,0,264 |
| "```scipy.misc.imsave('outfile.jpg', image_array)```",output,1,264 |
| Remove anything in parenthesis from string `item` with a regex,instruction,0,265 |
| "```item = re.sub(' ?\\([^)]+\\)', '', item)```",output,1,265 |
| Remove word characters in parenthesis from string `item` with a regex,instruction,0,266 |
| "```item = re.sub(' ?\\(\\w+\\)', '', item)```",output,1,266 |
| Remove all data inside parenthesis in string `item`,instruction,0,267 |
| "```item = re.sub(' \\(\\w+\\)', '', item)```",output,1,267 |
| check if any elements in one list `list1` are in another list `list2`,instruction,0,268 |
| ```len(set(list1).intersection(list2)) > 0```,output,1,268 |
| convert hex string `s` to decimal,instruction,0,269 |
| "```i = int(s, 16)```",output,1,269 |
| "convert hex string ""0xff"" to decimal",instruction,0,270 |
| "```int('0xff', 16)```",output,1,270 |
| "convert hex string ""FFFF"" to decimal",instruction,0,271 |
| "```int('FFFF', 16)```",output,1,271 |
| convert hex string '0xdeadbeef' to decimal,instruction,0,272 |
| ```ast.literal_eval('0xdeadbeef')```,output,1,272 |
| convert hex string 'deadbeef' to decimal,instruction,0,273 |
| "```int('deadbeef', 16)```",output,1,273 |
| take screenshot 'screen.png' on mac os x,instruction,0,274 |
| ```os.system('screencapture screen.png')```,output,1,274 |
| "Set a window size to `1400, 1000` using selenium webdriver",instruction,0,275 |
| "```driver.set_window_size(1400, 1000)```",output,1,275 |
| replace non-ascii chars from a unicode string u'm\xfasica',instruction,0,276 |
| "```unicodedata.normalize('NFKD', 'm\xfasica').encode('ascii', 'ignore')```",output,1,276 |
| concatenate dataframe `df1` with `df2` whilst removing duplicates,instruction,0,277 |
| "```pandas.concat([df1, df2]).drop_duplicates().reset_index(drop=True)```",output,1,277 |
| Construct an array with data type float32 `a` from data in binary file 'filename',instruction,0,278 |
| "```a = numpy.fromfile('filename', dtype=numpy.float32)```",output,1,278 |
| execute a mv command `mv /home/somedir/subdir/* somedir/` in subprocess,instruction,0,279 |
| "```subprocess.call('mv /home/somedir/subdir/* somedir/', shell=True)```",output,1,279 |
| ,instruction,0,280 |
| "```subprocess.call('mv /home/somedir/subdir/* somedir/', shell=True)```",output,1,280 |
| print a character that has unicode value `\u25b2`,instruction,0,281 |
| ```print('\u25b2'.encode('utf-8'))```,output,1,281 |
| compare contents at filehandles `file1` and `file2` using difflib,instruction,0,282 |
| "```difflib.SequenceMatcher(None, file1.read(), file2.read())```",output,1,282 |
| "Create a dictionary from string `e` separated by `-` and `,`",instruction,0,283 |
| "```dict((k, int(v)) for k, v in (e.split(' - ') for e in s.split(',')))```",output,1,283 |
| "check if all elements in a tuple `(1, 6)` are in another `(1, 2, 3, 4, 5)`",instruction,0,284 |
| "```all(i in (1, 2, 3, 4, 5) for i in (1, 6))```",output,1,284 |
| extract unique dates from time series 'Date' in dataframe `df`,instruction,0,285 |
| ```df['Date'].map(lambda t: t.date()).unique()```,output,1,285 |
| right align string `mystring` with a width of 7,instruction,0,286 |
| "```""""""{:>7s}"""""".format(mystring)```",output,1,286 |
| read an excel file 'ComponentReport-DJI.xls',instruction,0,287 |
| "```open('ComponentReport-DJI.xls', 'rb').read(200)```",output,1,287 |
| sort dataframe `df` based on column 'b' in ascending and column 'c' in descending,instruction,0,288 |
| "```df.sort_values(['b', 'c'], ascending=[True, False], inplace=True)```",output,1,288 |
| sort dataframe `df` based on column 'a' in ascending and column 'b' in descending,instruction,0,289 |
| "```df.sort_values(['a', 'b'], ascending=[True, False])```",output,1,289 |
| sort a pandas data frame with column `a` in ascending and `b` in descending order,instruction,0,290 |
| "```df1.sort(['a', 'b'], ascending=[True, False], inplace=True)```",output,1,290 |
| "sort a pandas data frame by column `a` in ascending, and by column `b` in descending order",instruction,0,291 |
| "```df.sort(['a', 'b'], ascending=[True, False])```",output,1,291 |
| django redirect to view 'Home.views.index',instruction,0,292 |
| ```redirect('Home.views.index')```,output,1,292 |
| "remove all values within one list `[2, 3, 7]` from another list `a`",instruction,0,293 |
| "```[x for x in a if x not in [2, 3, 7]]```",output,1,293 |
| "remove the punctuation '!', '.', ':' from a string `asking`",instruction,0,294 |
| "```out = ''.join(c for c in asking if c not in ('!', '.', ':'))```",output,1,294 |
| BeautifulSoup get value associated with attribute 'content' where attribute 'name' is equal to 'City' in tag 'meta' in HTML parsed string `soup`,instruction,0,295 |
| "```soup.find('meta', {'name': 'City'})['content']```",output,1,295 |
| unquote a urlencoded unicode string '%0a',instruction,0,296 |
| ```urllib.parse.unquote('%0a')```,output,1,296 |
| decode url `url` from UTF-16 code to UTF-8 code,instruction,0,297 |
| ```urllib.parse.unquote(url).decode('utf8')```,output,1,297 |
| empty a list `lst`,instruction,0,298 |
| ```del lst[:]```,output,1,298 |
| empty a list `lst`,instruction,0,299 |
| ```del lst1[:]```,output,1,299 |
| empty a list `lst`,instruction,0,300 |
| ```lst[:] = []```,output,1,300 |
| empty a list `alist`,instruction,0,301 |
| ```alist[:] = []```,output,1,301 |
| reset index of series `s`,instruction,0,302 |
| ```s.reset_index(0).reset_index(drop=True)```,output,1,302 |
| convert unicode text from list `elems` with index 0 to normal text 'utf-8',instruction,0,303 |
| ```elems[0].getText().encode('utf-8')```,output,1,303 |
| create a list containing the subtraction of each item in list `L` from the item prior to it,instruction,0,304 |
| "```[(y - x) for x, y in zip(L, L[1:])]```",output,1,304 |
| get value in string `line` matched by regex pattern '\\bLOG_ADDR\\s+(\\S+)',instruction,0,305 |
| "```print(re.search('\\bLOG_ADDR\\s+(\\S+)', line).group(1))```",output,1,305 |
| import all classes from module `some.package`,instruction,0,306 |
| ```globals().update(importlib.import_module('some.package').__dict__)```,output,1,306 |
| "convert a list of characters `['a', 'b', 'c', 'd']` into a string",instruction,0,307 |
| "```"""""""""""".join(['a', 'b', 'c', 'd'])```",output,1,307 |
| "Slice `url` with '&' as delimiter to get ""http://www.domainname.com/page?CONTENT_ITEM_ID=1234"" from url ""http://www.domainname.com/page?CONTENT_ITEM_ID=1234¶m2¶m3 |
| """,instruction,0,308 |
| ```url.split('&')```,output,1,308 |
| sort dictionary `d` by key,instruction,0,309 |
| ```od = collections.OrderedDict(sorted(d.items()))```,output,1,309 |
| sort a dictionary `d` by key,instruction,0,310 |
| "```OrderedDict(sorted(list(d.items()), key=(lambda t: t[0])))```",output,1,310 |
| Execute a put request to the url `url`,instruction,0,311 |
| "```response = requests.put(url, data=json.dumps(data), headers=headers)```",output,1,311 |
| replace everything that is not an alphabet or a digit with '' in 's'.,instruction,0,312 |
| "```re.sub('[\\W_]+', '', s)```",output,1,312 |
| create a list of aggregation of each element from list `l2` to all elements of list `l1`,instruction,0,313 |
| ```[(x + y) for x in l2 for y in l1]```,output,1,313 |
| convert string `x' to dictionary splitted by `=` using list comprehension,instruction,0,314 |
| ```dict([x.split('=') for x in s.split()])```,output,1,314 |
| remove index 2 element from a list `my_list`,instruction,0,315 |
| ```my_list.pop(2)```,output,1,315 |
| "Delete character ""M"" from a string `s` using python",instruction,0,316 |
| "```s = s.replace('M', '')```",output,1,316 |
| ,instruction,0,317 |
| "```newstr = oldstr.replace('M', '')```",output,1,317 |
| get the sum of the products of each pair of corresponding elements in lists `a` and `b`,instruction,0,318 |
| "```sum(x * y for x, y in zip(a, b))```",output,1,318 |
| sum the products of each two elements at the same index of list `a` and list `b`,instruction,0,319 |
| "```list(x * y for x, y in list(zip(a, b)))```",output,1,319 |
| sum the product of each two items at the same index of list `a` and list `b`,instruction,0,320 |
| "```sum(i * j for i, j in zip(a, b))```",output,1,320 |
| sum the product of elements of two lists named `a` and `b`,instruction,0,321 |
| "```sum(x * y for x, y in list(zip(a, b)))```",output,1,321 |
| write the content of file `xxx.mp4` to file `f`,instruction,0,322 |
| "```f.write(open('xxx.mp4', 'rb').read())```",output,1,322 |
| Add 1 to each integer value in list `my_list`,instruction,0,323 |
| ```new_list = [(x + 1) for x in my_list]```,output,1,323 |
| get a list of all items in list `j` with values greater than `5`,instruction,0,324 |
| ```[x for x in j if x >= 5]```,output,1,324 |
| set color marker styles `--bo` in matplotlib,instruction,0,325 |
| "```plt.plot(list(range(10)), '--bo')```",output,1,325 |
| "set circle markers on plot for individual points defined in list `[1,2,3,4,5,6,7,8,9,10]` created by range(10)",instruction,0,326 |
| "```plt.plot(list(range(10)), linestyle='--', marker='o', color='b')```",output,1,326 |
| split strings in list `l` on the first occurring tab `\t` and enter only the first resulting substring in a new list,instruction,0,327 |
| "```[i.split('\t', 1)[0] for i in l]```",output,1,327 |
| Split each string in list `myList` on the tab character,instruction,0,328 |
| ```myList = [i.split('\t')[0] for i in myList]```,output,1,328 |
| Sum numbers in a list 'your_list',instruction,0,329 |
| ```sum(your_list)```,output,1,329 |
| attach debugger pdb to class `ForkedPdb`,instruction,0,330 |
| ```ForkedPdb().set_trace()```,output,1,330 |
| Compose keys from dictionary `d1` with respective values in dictionary `d2`,instruction,0,331 |
| "```result = {k: d2.get(v) for k, v in list(d1.items())}```",output,1,331 |
| add one day and three hours to the present time from datetime.now(),instruction,0,332 |
| "```datetime.datetime.now() + datetime.timedelta(days=1, hours=3)```",output,1,332 |
| ,instruction,0,333 |
| "```[int(s[i:i + 3], 2) for i in range(0, len(s), 3)]```",output,1,333 |
| switch keys and values in a dictionary `my_dict`,instruction,0,334 |
| "```dict((v, k) for k, v in my_dict.items())```",output,1,334 |
| sort a list `L` by number after second '.',instruction,0,335 |
| "```print(sorted(L, key=lambda x: int(x.split('.')[2])))```",output,1,335 |
| "Check if the value of the key ""name"" is ""Test"" in a list of dictionaries `label`",instruction,0,336 |
| ```any(d['name'] == 'Test' for d in label)```,output,1,336 |
| "remove all instances of [1, 1] from list `a`",instruction,0,337 |
| "```a[:] = [x for x in a if x != [1, 1]]```",output,1,337 |
| "remove all instances of `[1, 1]` from a list `a`",instruction,0,338 |
| "```[x for x in a if x != [1, 1]]```",output,1,338 |
| "convert a list 'a' to a dictionary where each even element represents the key to the dictionary, and the following odd element is the value",instruction,0,339 |
| "```b = {a[i]: a[i + 1] for i in range(0, len(a), 2)}```",output,1,339 |
| check whether elements in list `a` appear only once,instruction,0,340 |
| ```len(set(a)) == len(a)```,output,1,340 |
| Generate MD5 checksum of file in the path `full_path` in hashlib,instruction,0,341 |
| "```print(hashlib.md5(open(full_path, 'rb').read()).hexdigest())```",output,1,341 |
| ,instruction,0,342 |
| "```sorted(list(data.items()), key=lambda x: x[1][0])```",output,1,342 |
| randomly switch letters' cases in string `s`,instruction,0,343 |
| "```"""""""""""".join(x.upper() if random.randint(0, 1) else x for x in s)```",output,1,343 |
| force bash interpreter '/bin/bash' to be used instead of shell,instruction,0,344 |
| "```os.system('GREPDB=""echo 123""; /bin/bash -c ""$GREPDB""')```",output,1,344 |
| Run a command `echo hello world` in bash instead of shell,instruction,0,345 |
| "```os.system('/bin/bash -c ""echo hello world""')```",output,1,345 |
| access the class variable `a_string` from a class object `test`,instruction,0,346 |
| "```getattr(test, a_string)```",output,1,346 |
| Display a image file `pathToFile`,instruction,0,347 |
| ```Image.open('pathToFile').show()```,output,1,347 |
| "replace single quote character in string ""didn't"" with empty string ''",instruction,0,348 |
| "```""""""didn't"""""".replace(""'"", '')```",output,1,348 |
| sort list `files` based on variable `file_number`,instruction,0,349 |
| ```files.sort(key=file_number)```,output,1,349 |
| remove all whitespace in a string `sentence`,instruction,0,350 |
| "```sentence.replace(' ', '')```",output,1,350 |
| remove all whitespace in a string `sentence`,instruction,0,351 |
| "```pattern = re.compile('\\s+') |
| sentence = re.sub(pattern, '', sentence)```",output,1,351 |
| remove whitespace in string `sentence` from beginning and end,instruction,0,352 |
| ```sentence.strip()```,output,1,352 |
| remove all whitespaces in string `sentence`,instruction,0,353 |
| "```sentence = re.sub('\\s+', '', sentence, flags=re.UNICODE)```",output,1,353 |
| remove all whitespaces in a string `sentence`,instruction,0,354 |
| ```sentence = ''.join(sentence.split())```,output,1,354 |
| sum all the values in a counter variable `my_counter`,instruction,0,355 |
| ```sum(my_counter.values())```,output,1,355 |
| find the euclidean distance between two 3-d arrays `A` and `B`,instruction,0,356 |
| ```np.sqrt(((A - B) ** 2).sum(-1))```,output,1,356 |
| create list `levels` containing 3 empty dictionaries,instruction,0,357 |
| "```levels = [{}, {}, {}]```",output,1,357 |
| find the sums of length 7 subsets of a list `daily`,instruction,0,358 |
| "```weekly = [sum(visitors[x:x + 7]) for x in range(0, len(daily), 7)]```",output,1,358 |
| Delete an element `key` from a dictionary `d`,instruction,0,359 |
| ```del d[key]```,output,1,359 |
| Delete an element 0 from a dictionary `a`,instruction,0,360 |
| ```{i: a[i] for i in a if (i != 0)}```,output,1,360 |
| "Delete an element ""hello"" from a dictionary `lol`",instruction,0,361 |
| ```lol.pop('hello')```,output,1,361 |
| Delete an element with key `key` dictionary `r`,instruction,0,362 |
| ```del r[key]```,output,1,362 |
| solve for the least squares' solution of matrices `a` and `b`,instruction,0,363 |
| "```np.linalg.solve(np.dot(a.T, a), np.dot(a.T, b))```",output,1,363 |
| split dictionary/list inside a pandas column 'b' into separate columns in dataframe `df`,instruction,0,364 |
| "```pd.concat([df.drop('b', axis=1), pd.DataFrame(df['b'].tolist())], axis=1)```",output,1,364 |
| loop through 0 to 10 with step 2,instruction,0,365 |
| "```for i in range(0, 10, 2): |
| pass```",output,1,365 |
| loop through `mylist` with step 2,instruction,0,366 |
| "```for i in mylist[::2]: |
| pass```",output,1,366 |
| lowercase string values with key 'content' in a list of dictionaries `messages`,instruction,0,367 |
| ```[{'content': x['content'].lower()} for x in messages]```,output,1,367 |
| convert a list `my_list` into string with values separated by spaces,instruction,0,368 |
| "```"""""" """""".join(my_list)```",output,1,368 |
| replace each occurrence of the pattern '(http: |
| "```re.sub('(http://\\S+|\\S*[^\\w\\s]\\S*)', '', a)```",output,1,369 |
| check if string `str` is palindrome,instruction,0,370 |
| ```str(n) == str(n)[::-1]```,output,1,370 |
| upload binary file `myfile.txt` with ftplib,instruction,0,371 |
| "```ftp.storbinary('STOR myfile.txt', open('myfile.txt', 'rb'))```",output,1,371 |
| remove all characters from string `stri` upto character 'I',instruction,0,372 |
| "```re.sub('.*I', 'I', stri)```",output,1,372 |
| "parse a comma-separated string number '1,000,000' into int",instruction,0,373 |
| "```int('1,000,000'.replace(',', ''))```",output,1,373 |
| combine dataframe `df1` and dataframe `df2` by index number,instruction,0,374 |
| "```pd.merge(df1, df2, left_index=True, right_index=True, how='outer')```",output,1,374 |
| ,instruction,0,375 |
| "```pandas.concat([df1, df2], axis=1)```",output,1,375 |
| check if all boolean values in a python dictionary `dict` are true,instruction,0,376 |
| ```all(dict.values())```,output,1,376 |
| use regex pattern '^12(?=.{4}$)' to remove digit 12 if followed by 4 other digits in column `c_contofficeID` of dataframe `df`,instruction,0,377 |
| "```df.c_contofficeID.str.replace('^12(?=.{4}$)', '')```",output,1,377 |
| reverse a list `L`,instruction,0,378 |
| ```L[::(-1)]```,output,1,378 |
| reverse a list `array`,instruction,0,379 |
| ```reversed(array)```,output,1,379 |
| reverse a list `L`,instruction,0,380 |
| ```L.reverse()```,output,1,380 |
| reverse a list `array`,instruction,0,381 |
| ```list(reversed(array))```,output,1,381 |
| get first element of each tuple in list `A`,instruction,0,382 |
| ```[tup[0] for tup in A]```,output,1,382 |
| replace character 'a' with character 'e' and character 's' with character '3' in file `contents`,instruction,0,383 |
| "```newcontents = contents.replace('a', 'e').replace('s', '3')```",output,1,383 |
| serialise SqlAlchemy RowProxy object `row` to a json object,instruction,0,384 |
| ```json.dumps([dict(list(row.items())) for row in rs])```,output,1,384 |
| get file '~/foo.ini',instruction,0,385 |
| ```config_file = os.path.expanduser('~/foo.ini')```,output,1,385 |
| get multiple parameters with same name from a url in pylons,instruction,0,386 |
| ```request.params.getall('c')```,output,1,386 |
| Convert array `x` into a correlation matrix,instruction,0,387 |
| ```np.corrcoef(x)```,output,1,387 |
| "Find the greatest number in set `(1, 2, 3)`",instruction,0,388 |
| "```print(max(1, 2, 3))```",output,1,388 |
| Retrieve parameter 'var_name' from a GET request.,instruction,0,389 |
| ```self.request.get('var_name')```,output,1,389 |
| "Add 100 to each element of column ""x"" in dataframe `a`",instruction,0,390 |
| "```a['x'].apply(lambda x, y: x + y, args=(100,))```",output,1,390 |
| Django get first 10 records of model `User` ordered by criteria 'age' of model 'pet',instruction,0,391 |
| ```User.objects.order_by('-pet__age')[:10]```,output,1,391 |
| "delay for ""5"" seconds",instruction,0,392 |
| ```time.sleep(5)```,output,1,392 |
| make a 60 seconds time delay,instruction,0,393 |
| ```time.sleep(60)```,output,1,393 |
| make a 0.1 seconds time delay,instruction,0,394 |
| ```sleep(0.1)```,output,1,394 |
| make a 60 seconds time delay,instruction,0,395 |
| ```time.sleep(60)```,output,1,395 |
| make a 0.1 seconds time delay,instruction,0,396 |
| ```time.sleep(0.1)```,output,1,396 |
| "From a list of strings `my_list`, remove the values that contains numbers.",instruction,0,397 |
| ```[x for x in my_list if not any(c.isdigit() for c in x)]```,output,1,397 |
| get the middle two characters of a string 'state' in a pandas dataframe `df`,instruction,0,398 |
| ```df['state'].apply(lambda x: x[len(x) / 2 - 1:len(x) / 2 + 1])```,output,1,398 |
| draw a grid line on every tick of plot `plt`,instruction,0,399 |
| ```plt.grid(True)```,output,1,399 |
| sort list `lst` based on each element's number of occurrences,instruction,0,400 |
| "```sorted(lst, key=lambda x: (-1 * c[x], lst.index(x)))```",output,1,400 |
| Get the value with the maximum length in each column in array `foo`,instruction,0,401 |
| ```[max(len(str(x)) for x in line) for line in zip(*foo)]```,output,1,401 |
| get the count of each unique value in column `Country` of dataframe `df` and store in column `Sum of Accidents`,instruction,0,402 |
| ```df.Country.value_counts().reset_index(name='Sum of Accidents')```,output,1,402 |
| calculat the difference between each row and the row previous to it in dataframe `data`,instruction,0,403 |
| ```data.set_index('Date').diff()```,output,1,403 |
| "append values `[3, 4]` to a set `a`",instruction,0,404 |
| "```a.update([3, 4])```",output,1,404 |
| set every two-stride far element to -1 starting from second element in array `a`,instruction,0,405 |
| ```a[1::2] = -1```,output,1,405 |
| "Get rank of rows from highest to lowest of dataframe `df`, grouped by value in column `group`, according to value in column `value`",instruction,0,406 |
| ```df.groupby('group')['value'].rank(ascending=False)```,output,1,406 |
| "convert js date object 'Tue, 22 Nov 2011 06:00:00 GMT' to python datetime",instruction,0,407 |
| "```datetime.strptime('Tue, 22 Nov 2011 06:00:00 GMT', '%a, %d %b %Y %H:%M:%S %Z')```",output,1,407 |
| Convert a binary value '1633837924' to string,instruction,0,408 |
| "```struct.pack('<I', 1633837924)```",output,1,408 |
| append string `foo` to list `list`,instruction,0,409 |
| ```list.append('foo')```,output,1,409 |
| insert string `foo` at position `0` of list `list`,instruction,0,410 |
| "```list.insert(0, 'foo')```",output,1,410 |
| convert keys in dictionary `thedict` into case insensitive,instruction,0,411 |
| ```theset = set(k.lower() for k in thedict)```,output,1,411 |
| pad 'dog' up to a length of 5 characters with 'x',instruction,0,412 |
| "```""""""{s:{c}^{n}}"""""".format(s='dog', n=5, c='x')```",output,1,412 |
| check if type of variable `s` is a string,instruction,0,413 |
| "```isinstance(s, str)```",output,1,413 |
| check if type of a variable `s` is string,instruction,0,414 |
| "```isinstance(s, str)```",output,1,414 |
| Convert list of dictionaries `L` into a flat dictionary,instruction,0,415 |
| ```dict(pair for d in L for pair in list(d.items()))```,output,1,415 |
| merge a list of dictionaries in list `L` into a single dict,instruction,0,416 |
| "```{k: v for d in L for k, v in list(d.items())}```",output,1,416 |
| sort a pandas data frame according to column `Peak` in ascending and `Weeks` in descending order,instruction,0,417 |
| "```df.sort_values(['Peak', 'Weeks'], ascending=[True, False], inplace=True)```",output,1,417 |
| sort a pandas data frame by column `Peak` in ascending and `Weeks` in descending order,instruction,0,418 |
| "```df.sort(['Peak', 'Weeks'], ascending=[True, False], inplace=True)```",output,1,418 |
| "run the code contained in string ""print('Hello')""",instruction,0,419 |
| "```eval(""print('Hello')"")```",output,1,419 |
| "creating a list of dictionaries [{'A': 1, 'C': 4, 'B': 2, 'D': 4}, {'A': 1, 'C': 4, 'B': 1, 'D': 5}]",instruction,0,420 |
| "```[{'A': 1, 'C': 4, 'B': 2, 'D': 4}, {'A': 1, 'C': 4, 'B': 1, 'D': 5}]```",output,1,420 |
| ,instruction,0,421 |
| "```[{'A': 1, 'C': 4, 'B': 2, 'D': 4}, {'A': 1, 'C': 4, 'B': 1, 'D': 5}]```",output,1,421 |
| get all possible combination of items from 2-dimensional list `a`,instruction,0,422 |
| ```list(itertools.product(*a))```,output,1,422 |
| "Get sum of values of columns 'Y1961', 'Y1962', 'Y1963' after group by on columns ""Country"" and ""Item_code"" in dataframe `df`.",instruction,0,423 |
| "```df.groupby(['Country', 'Item_Code'])[['Y1961', 'Y1962', 'Y1963']].sum()```",output,1,423 |
| "create list `done` containing permutations of each element in list `[a, b, c, d]` with variable `x` as tuples",instruction,0,424 |
| "```done = [(el, x) for el in [a, b, c, d]]```",output,1,424 |
| remove Nan values from array `x`,instruction,0,425 |
| ```x = x[numpy.logical_not(numpy.isnan(x))]```,output,1,425 |
| remove first directory from path '/First/Second/Third/Fourth/Fifth',instruction,0,426 |
| ```os.path.join(*x.split(os.path.sep)[2:])```,output,1,426 |
| Replace `;` with `:` in a string `line`,instruction,0,427 |
| "```line = line.replace(';', ':')```",output,1,427 |
| call bash command 'tar c my_dir | md5sum' with pipe,instruction,0,428 |
| "```subprocess.call('tar c my_dir | md5sum', shell=True)```",output,1,428 |
| Convert a hex string `437c2123 ` according to ascii value.,instruction,0,429 |
| "```""""""437c2123"""""".decode('hex')```",output,1,429 |
| Get a list of all fields in class `User` that are marked `required`,instruction,0,430 |
| "```[k for k, v in User._fields.items() if v.required]```",output,1,430 |
| "remove column by index `[:, 0:2]` in dataframe `df`",instruction,0,431 |
| "```df = df.ix[:, 0:2]```",output,1,431 |
| change a string of integers `x` separated by spaces to a list of int,instruction,0,432 |
| "```x = map(int, x.split())```",output,1,432 |
| convert a string of integers `x` separated by spaces to a list of integers,instruction,0,433 |
| ```x = [int(i) for i in x.split()]```,output,1,433 |
| "find element by css selector ""input[onclick*='1 Bedroom Deluxe']""",instruction,0,434 |
| "```driver.find_element_by_css_selector(""input[onclick*='1 Bedroom Deluxe']"")```",output,1,434 |
| ,instruction,0,435 |
| "```re.sub('[^a-zA-Z0-9-_*.]', '', my_string)```",output,1,435 |
| display a pdf file that has been downloaded as `my_pdf.pdf`,instruction,0,436 |
| ```webbrowser.open('file: |
| replace backslashes in string `result` with empty string '',instruction,0,437 |
| "```result = result.replace('\\', '')```",output,1,437 |
| remove backslashes from string `result`,instruction,0,438 |
| "```result.replace('\\', '')```",output,1,438 |
| "replace value '-' in any column of pandas dataframe to ""NaN""",instruction,0,439 |
| "```df.replace('-', 'NaN')```",output,1,439 |
| convert datetime object to date object in python,instruction,0,440 |
| ```datetime.datetime.now().date()```,output,1,440 |
| ,instruction,0,441 |
| ```datetime.datetime.now().date()```,output,1,441 |
| get all sub-elements of an element `a` in an elementtree,instruction,0,442 |
| ```[elem.tag for elem in a.iter()]```,output,1,442 |
| get all sub-elements of an element tree `a` excluding the root element,instruction,0,443 |
| ```[elem.tag for elem in a.iter() if elem is not a]```,output,1,443 |
| ,instruction,0,444 |
| "```""""""2.7.0_bf4fda703454"""""".split('_')```",output,1,444 |
| move dictionaries in list `lst` to the end of the list if value of key 'language' in each dictionary is not equal to 'en',instruction,0,445 |
| "```sorted(lst, key=lambda x: x['language'] != 'en')```",output,1,445 |
| check if all values of a dictionary `your_dict` are zero `0`,instruction,0,446 |
| ```all(value == 0 for value in list(your_dict.values()))```,output,1,446 |
| produce a pivot table as dataframe using column 'Y' in datafram `df` to form the axes of the resulting dataframe,instruction,0,447 |
| "```df.pivot_table('Y', rows='X', cols='X2')```",output,1,447 |
| call `doSomething()` in a try-except without handling the exception,instruction,0,448 |
| "```try: |
| doSomething() |
| except: |
| pass```",output,1,448 |
| call `doSomething()` in a try-except without handling the exception,instruction,0,449 |
| "```try: |
| doSomething() |
| except Exception: |
| pass```",output,1,449 |
| get a sum of 4d array `M`,instruction,0,450 |
| ```M.sum(axis=0).sum(axis=0)```,output,1,450 |
| Convert a datetime object `dt` to microtime,instruction,0,451 |
| ```time.mktime(dt.timetuple()) + dt.microsecond / 1000000.0```,output,1,451 |
| select all rows in dataframe `df` where the values of column 'columnX' is bigger than or equal to `x` and smaller than or equal to `y`,instruction,0,452 |
| ```df[(x <= df['columnX']) & (df['columnX'] <= y)]```,output,1,452 |
| sort a list of lists `L` by index 2 of the inner list,instruction,0,453 |
| "```sorted(L, key=itemgetter(2))```",output,1,453 |
| sort a list of lists `l` by index 2 of the inner list,instruction,0,454 |
| ```l.sort(key=(lambda x: x[2]))```,output,1,454 |
| sort list `l` by index 2 of the item,instruction,0,455 |
| "```sorted(l, key=(lambda x: x[2]))```",output,1,455 |
| "sort a list of lists `list_to_sort` by indices 2,0,1 of the inner list",instruction,0,456 |
| "```sorted_list = sorted(list_to_sort, key=itemgetter(2, 0, 1))```",output,1,456 |
| "find rows of 2d array in 3d numpy array 'arr' if the row has value '[[0, 3], [3, 0]]'",instruction,0,457 |
| "```np.argwhere(np.all(arr == [[0, 3], [3, 0]], axis=(1, 2)))```",output,1,457 |
| From multiIndexed dataframe `data` select columns `a` and `c` within each higher order column `one` and `two`,instruction,0,458 |
| "```data.loc[:, (list(itertools.product(['one', 'two'], ['a', 'c'])))]```",output,1,458 |
| select only specific columns 'a' and 'c' from a dataframe 'data' with multiindex columns,instruction,0,459 |
| "```data.loc[:, ([('one', 'a'), ('one', 'c'), ('two', 'a'), ('two', 'c')])]```",output,1,459 |
| "match a sharp, followed by letters (including accent characters) in string `str1` using a regex",instruction,0,460 |
| "```hashtags = re.findall('#(\\w+)', str1, re.UNICODE)```",output,1,460 |
| Rename file from `src` to `dst`,instruction,0,461 |
| "```os.rename(src, dst)```",output,1,461 |
| Get all texts and tags from a tag `strong` from etree tag `some_tag` using lxml,instruction,0,462 |
| ```print(etree.tostring(some_tag.find('strong')))```,output,1,462 |
| Serialize dictionary `data` and its keys to a JSON formatted string,instruction,0,463 |
| "```json.dumps({str(k): v for k, v in data.items()})```",output,1,463 |
| parse UTF-8 encoded HTML response `response` to BeautifulSoup object,instruction,0,464 |
| ```soup = BeautifulSoup(response.read().decode('utf-8'))```,output,1,464 |
| delete file `filename`,instruction,0,465 |
| ```os.remove(filename)```,output,1,465 |
| get the next value greatest to `2` from a list of numbers `num_list`,instruction,0,466 |
| ```min([x for x in num_list if x > 2])```,output,1,466 |
| Replace each value in column 'prod_type' of dataframe `df` with string 'responsive',instruction,0,467 |
| ```df['prod_type'] = 'responsive'```,output,1,467 |
| sort list `lst` with positives coming before negatives with values sorted respectively,instruction,0,468 |
| "```sorted(lst, key=lambda x: (x < 0, x))```",output,1,468 |
| get the date 6 months from today,instruction,0,469 |
| ```six_months = (date.today() + relativedelta(months=(+ 6)))```,output,1,469 |
| get the date 1 month from today,instruction,0,470 |
| "```(date(2010, 12, 31) + relativedelta(months=(+ 1)))```",output,1,470 |
| get the date 2 months from today,instruction,0,471 |
| "```(date(2010, 12, 31) + relativedelta(months=(+ 2)))```",output,1,471 |
| calculate the date six months from the current date,instruction,0,472 |
| ```print((datetime.date.today() + datetime.timedelta(((6 * 365) / 12))).isoformat())```,output,1,472 |
| get a list of keys of dictionary `things` sorted by the value of nested dictionary key 'weight',instruction,0,473 |
| "```sorted(list(things.keys()), key=lambda x: things[x]['weight'], reverse=True)```",output,1,473 |
| get all the values from a numpy array `a` excluding index 3,instruction,0,474 |
| ```a[np.arange(len(a)) != 3]```,output,1,474 |
| delete all elements from a list `x` if a function `fn` taking value as parameter returns `0`,instruction,0,475 |
| ```[x for x in lst if fn(x) != 0]```,output,1,475 |
| set dataframe `df` index using column 'month',instruction,0,476 |
| ```df.set_index('month')```,output,1,476 |
| read lines from a csv file `./urls-eu.csv` into a list of lists `arr`,instruction,0,477 |
| "```arr = [line.split(',') for line in open('./urls-eu.csv')]```",output,1,477 |
| list comprehension that produces integers between 11 and 19,instruction,0,478 |
| ```[i for i in range(100) if i > 10 if i < 20]```,output,1,478 |
| Get only digits from a string `strs`,instruction,0,479 |
| "```"""""""""""".join([c for c in strs if c.isdigit()])```",output,1,479 |
| split a string `yas` based on tab '\t',instruction,0,480 |
| "```re.split('\\t+', yas.rstrip('\t'))```",output,1,480 |
| scalar multiply matrix `a` by `b`,instruction,0,481 |
| ```(a.T * b).T```,output,1,481 |
| "remove trailing newline in string ""test string\n""",instruction,0,482 |
| ```'test string\n'.rstrip()```,output,1,482 |
| remove trailing newline in string 'test string \n\n',instruction,0,483 |
| ```'test string \n\n'.rstrip('\n')```,output,1,483 |
| remove newline in string `s`,instruction,0,484 |
| ```s.strip()```,output,1,484 |
| remove newline in string `s` on the right side,instruction,0,485 |
| ```s.rstrip()```,output,1,485 |
| remove newline in string `s` on the left side,instruction,0,486 |
| ```s.lstrip()```,output,1,486 |
| remove newline in string 'Mac EOL\r',instruction,0,487 |
| ```'Mac EOL\r'.rstrip('\r\n')```,output,1,487 |
| remove newline in string 'Windows EOL\r\n' on the right side,instruction,0,488 |
| ```'Windows EOL\r\n'.rstrip('\r\n')```,output,1,488 |
| remove newline in string 'Unix EOL\n' on the right side,instruction,0,489 |
| ```'Unix EOL\n'.rstrip('\r\n')```,output,1,489 |
| "remove newline in string ""Hello\n\n\n"" on the right side",instruction,0,490 |
| ```'Hello\n\n\n'.rstrip('\n')```,output,1,490 |
| split string `text` into chunks of 16 characters each,instruction,0,491 |
| "```re.findall('.{,16}\\b', text)```",output,1,491 |
| Get a list comprehension in list of lists `X`,instruction,0,492 |
| ```[[X[i][j] for j in range(len(X[i]))] for i in range(len(X))]```,output,1,492 |
| convert unicode string '\xd0\xbc\xd0\xb0\xd1\x80\xd0\xba\xd0\xb0' to byte string,instruction,0,493 |
| ```'\xd0\xbc\xd0\xb0\xd1\x80\xd0\xba\xd0\xb0'.encode('latin-1')```,output,1,493 |
| split dataframe `df` where the value of column `a` is equal to 'B',instruction,0,494 |
| ```df.groupby((df.a == 'B').shift(1).fillna(0).cumsum())```,output,1,494 |
| save json output from a url ‘http: |
| "```urllib.request.urlretrieve('http://search.twitter.com/search.json?q=hi', 'hi.json')```",output,1,495 |
| Find indices of elements equal to zero from numpy array `x`,instruction,0,496 |
| ```numpy.where((x == 0))[0]```,output,1,496 |
| flush output of python print,instruction,0,497 |
| ```sys.stdout.flush()```,output,1,497 |
| convert `i` to string,instruction,0,498 |
| ```str(i)```,output,1,498 |
| convert `a` to string,instruction,0,499 |
| ```a.__str__()```,output,1,499 |
| convert `a` to string,instruction,0,500 |
| ```str(a)```,output,1,500 |
| sort list of lists `L` by the second item in each list,instruction,0,501 |
| ```L.sort(key=operator.itemgetter(1))```,output,1,501 |
| Print variable `count` and variable `conv` with space string ' ' in between,instruction,0,502 |
| ```print(str(count) + ' ' + str(conv))```,output,1,502 |
| change NaN values in dataframe `df` using preceding values in the frame,instruction,0,503 |
| "```df.fillna(method='ffill', inplace=True)```",output,1,503 |
| change the state of the Tkinter `Text` widget to read only i.e. `disabled`,instruction,0,504 |
| ```text.config(state=DISABLED)```,output,1,504 |
| python sum of ascii values of all characters in a string `string`,instruction,0,505 |
| "```sum(map(ord, string))```",output,1,505 |
| apply itertools.product to elements of a list of lists `arrays`,instruction,0,506 |
| ```list(itertools.product(*arrays))```,output,1,506 |
| print number `value` as thousands separators,instruction,0,507 |
| "```'{:,}'.format(value)```",output,1,507 |
| print number 1255000 as thousands separators,instruction,0,508 |
| "```locale.setlocale(locale.LC_ALL, 'en_US') |
| locale.format('%d', 1255000, grouping=True)```",output,1,508 |
| "get rows of dataframe `df` where column `Col1` has values `['men', 'rocks', 'mountains']`",instruction,0,509 |
| "```df[df.Col1.isin(['men', 'rocks', 'mountains'])]```",output,1,509 |
| get the value at index 1 for each tuple in the list of tuples `L`,instruction,0,510 |
| ```[x[1] for x in L]```,output,1,510 |
| "split unicode string ""раз два три"" into words",instruction,0,511 |
| ```'\u0440\u0430\u0437 \u0434\u0432\u0430 \u0442\u0440\u0438'.split()```,output,1,511 |
| sort query set by number of characters in a field `length` in django model `MyModel`,instruction,0,512 |
| ```MyModel.objects.extra(select={'length': 'Length(name)'}).order_by('length')```,output,1,512 |
| get a dictionary in list `dicts` which key 'ratio' is closer to a global value 1.77672955975,instruction,0,513 |
| "```min(dicts, key=lambda x: (abs(1.77672955975 - x['ratio']), -x['pixels']))```",output,1,513 |
| get the non-masked values of array `m`,instruction,0,514 |
| ```m[~m.mask]```,output,1,514 |
| Find all words containing letters between A and Z in string `formula`,instruction,0,515 |
| "```re.findall('\\b[A-Z]', formula)```",output,1,515 |
| "create a list `matrix` containing 5 lists, each of 5 items all set to 0",instruction,0,516 |
| ```matrix = [([0] * 5) for i in range(5)]```,output,1,516 |
| "creating a numpy array of 3d coordinates from three 1d arrays `x_p`, `y_p` and `z_p`",instruction,0,517 |
| "```np.vstack(np.meshgrid(x_p, y_p, z_p)).reshape(3, -1).T```",output,1,517 |
| find the minimum value in a numpy array `arr` excluding 0,instruction,0,518 |
| ```arr[arr != 0].min()```,output,1,518 |
| "get the text of multiple elements found by xpath ""//*[@type='submit']/@value""",instruction,0,519 |
| "```browser.find_elements_by_xpath(""//*[@type='submit']/@value"").text```",output,1,519 |
| find all the values in attribute `value` for the tags whose `type` attribute is `submit` in selenium,instruction,0,520 |
| "```browser.find_elements_by_xpath(""//*[@type='submit']"").get_attribute('value')```",output,1,520 |
| "parse a YAML file ""example.yaml""",instruction,0,521 |
| "```with open('example.yaml', 'r') as stream: |
| try: |
| print((yaml.load(stream))) |
| except yaml.YAMLError as exc: |
| print(exc)```",output,1,521 |
| "parse a YAML file ""example.yaml""",instruction,0,522 |
| "```with open('example.yaml') as stream: |
| try: |
| print((yaml.load(stream))) |
| except yaml.YAMLError as exc: |
| print(exc)```",output,1,522 |
| Sort the values of the dataframe `df` and align the columns accordingly based on the obtained indices after np.argsort.,instruction,0,523 |
| "```pd.DataFrame(df.columns[np.argsort(df.values)], df.index, np.unique(df.values))```",output,1,523 |
| Getting today's date in YYYY-MM-DD,instruction,0,524 |
| ```datetime.datetime.today().strftime('%Y-%m-%d')```,output,1,524 |
| urlencode a querystring 'string_of_characters_like_these:$#@=?%^Q^$' in python 2,instruction,0,525 |
| ```urllib.parse.quote_plus('string_of_characters_like_these:$#@=?%^Q^$')```,output,1,525 |
| sort a dictionary `d` by length of its values and print as string,instruction,0,526 |
| "```print(' '.join(sorted(d, key=lambda k: len(d[k]), reverse=True)))```",output,1,526 |
| "convert tuple elements in list `[(1,2),(3,4),(5,6),]` into lists",instruction,0,527 |
| "```map(list, zip(*[(1, 2), (3, 4), (5, 6)]))```",output,1,527 |
| ,instruction,0,528 |
| "```map(list, zip(*[(1, 2), (3, 4), (5, 6)]))```",output,1,528 |
| ,instruction,0,529 |
| "```zip(*[(1, 2), (3, 4), (5, 6)])```",output,1,529 |
| "create a list of tuples which contains number 9 and the number before it, for each occurrence of 9 in the list 'myList'",instruction,0,530 |
| "```[(x, y) for x, y in zip(myList, myList[1:]) if y == 9]```",output,1,530 |
| navigate to webpage given by url `http: |
| ```driver.get('http://www.google.com.br')```,output,1,531 |
| reverse a UTF-8 string 'a',instruction,0,532 |
| ```b = a.decode('utf8')[::-1].encode('utf8')```,output,1,532 |
| extract date from a string 'monkey 2010-07-32 love banana',instruction,0,533 |
| "```dparser.parse('monkey 2010-07-32 love banana', fuzzy=True)```",output,1,533 |
| extract date from a string 'monkey 20/01/1980 love banana',instruction,0,534 |
| "```dparser.parse('monkey 20/01/1980 love banana', fuzzy=True)```",output,1,534 |
| extract date from a string `monkey 10/01/1980 love banana`,instruction,0,535 |
| "```dparser.parse('monkey 10/01/1980 love banana', fuzzy=True)```",output,1,535 |
| "Convert a list `['A:1', 'B:2', 'C:3', 'D:4']` to dictionary",instruction,0,536 |
| "```dict(map(lambda s: s.split(':'), ['A:1', 'B:2', 'C:3', 'D:4']))```",output,1,536 |
| check if string `the_string` contains any upper or lower-case ASCII letters,instruction,0,537 |
| "```re.search('[a-zA-Z]', the_string)```",output,1,537 |
| convert a pandas `df1` groupby object to dataframe,instruction,0,538 |
| "```DataFrame({'count': df1.groupby(['Name', 'City']).size()}).reset_index()```",output,1,538 |
| remove all non-numeric characters from string `sdkjh987978asd098as0980a98sd `,instruction,0,539 |
| "```re.sub('[^0-9]', '', 'sdkjh987978asd098as0980a98sd')```",output,1,539 |
| get items from list `a` that don't appear in list `b`,instruction,0,540 |
| ```[y for y in a if y not in b]```,output,1,540 |
| extract the first four rows of the column `ID` from a pandas dataframe `df`,instruction,0,541 |
| ```df.groupby('ID').head(4)```,output,1,541 |
| Unzip a list of tuples `l` into a list of lists,instruction,0,542 |
| ```zip(*l)```,output,1,542 |
| "combine two lists `[1, 2, 3, 4]` and `['a', 'b', 'c', 'd']` into a dictionary",instruction,0,543 |
| "```dict(zip([1, 2, 3, 4], ['a', 'b', 'c', 'd']))```",output,1,543 |
| "combine two lists `[1, 2, 3, 4]` and `['a', 'b', 'c', 'd']` into a dictionary",instruction,0,544 |
| "```dict(zip([1, 2, 3, 4], ['a', 'b', 'c', 'd']))```",output,1,544 |
| retrieve the path from a Flask request,instruction,0,545 |
| ```request.url```,output,1,545 |
| replace carriage return in string `somestring` with empty string '',instruction,0,546 |
| "```somestring.replace('\\r', '')```",output,1,546 |
| "serialize dictionary `d` as a JSON formatted string with each key formatted to pattern '%d,%d'",instruction,0,547 |
| "```simplejson.dumps(dict([('%d,%d' % k, v) for k, v in list(d.items())]))```",output,1,547 |
| "parse string ""Jun 1 2005 1:33PM"" into datetime by format ""%b %d %Y %I:%M%p""",instruction,0,548 |
| "```datetime.strptime('Jun 1 2005 1:33PM', '%b %d %Y %I:%M%p')```",output,1,548 |
| "parse string ""Aug 28 1999 12:00AM"" into datetime",instruction,0,549 |
| ```parser.parse('Aug 28 1999 12:00AM')```,output,1,549 |
| Get absolute folder path and filename for file `existGDBPath `,instruction,0,550 |
| ```os.path.split(os.path.abspath(existGDBPath))```,output,1,550 |
| extract folder path from file path,instruction,0,551 |
| ```os.path.dirname(os.path.abspath(existGDBPath))```,output,1,551 |
| Execute a post request to url `http://httpbin.org/post` with json data `{'test': 'cheers'}`,instruction,0,552 |
| "```requests.post('http: |
| remove dictionary from list `a` if the value associated with its key 'link' is in list `b`,instruction,0,553 |
| ```a = [x for x in a if x['link'] not in b]```,output,1,553 |
| get a request parameter `a` in jinja2,instruction,0,554 |
| ```{{request.args.get('a')}}```,output,1,554 |
| create a list of integers between 2 values `11` and `17`,instruction,0,555 |
| "```list(range(11, 17))```",output,1,555 |
| Change data type of data in column 'grade' of dataframe `data_df` into float and then to int,instruction,0,556 |
| ```data_df['grade'] = data_df['grade'].astype(float).astype(int)```,output,1,556 |
| Find the list in a list of lists `alkaline_earth_values` with the max value of the second element.,instruction,0,557 |
| "```max(alkaline_earth_values, key=lambda x: x[1])```",output,1,557 |
| remove leading and trailing zeros in the string 'your_Strip',instruction,0,558 |
| ```your_string.strip('0')```,output,1,558 |
| generate a list of all unique pairs of integers in `range(9)`,instruction,0,559 |
| "```list(permutations(list(range(9)), 2))```",output,1,559 |
| create a regular expression that matches the pattern '^(.+)(?:\\n|\\r\\n?)((?:(?:\\n|\\r\\n?).+)+)' over multiple lines of text,instruction,0,560 |
| "```re.compile('^(.+)(?:\\n|\\r\\n?)((?:(?:\\n|\\r\\n?).+)+)', re.MULTILINE)```",output,1,560 |
| "regular expression ""^(.+)\\n((?:\\n.+)+)"" matching a multiline block of text",instruction,0,561 |
| "```re.compile('^(.+)\\n((?:\\n.+)+)', re.MULTILINE)```",output,1,561 |
| Run 'test2.py' file with python location 'path/to/python' and arguments 'neededArgumetGoHere' as a subprocess,instruction,0,562 |
| "```call(['path/to/python', 'test2.py', 'neededArgumetGoHere'])```",output,1,562 |
| sort a multidimensional list `a` by second and third column,instruction,0,563 |
| "```a.sort(key=operator.itemgetter(2, 3))```",output,1,563 |
| Add a tuple with value `another_choice` to a tuple `my_choices`,instruction,0,564 |
| "```final_choices = ((another_choice,) + my_choices)```",output,1,564 |
| Add a tuple with value `another_choice` to a tuple `my_choices`,instruction,0,565 |
| "```final_choices = ((another_choice,) + my_choices)```",output,1,565 |
| find the current directory,instruction,0,566 |
| ```os.getcwd()```,output,1,566 |
| find the current directory,instruction,0,567 |
| ```os.path.realpath(__file__)```,output,1,567 |
| get the directory name of `path`,instruction,0,568 |
| ```os.path.dirname(path)```,output,1,568 |
| get the canonical path of file `path`,instruction,0,569 |
| ```os.path.realpath(path)```,output,1,569 |
| Find name of current directory,instruction,0,570 |
| ```dir_path = os.path.dirname(os.path.realpath(__file__))```,output,1,570 |
| Find current directory,instruction,0,571 |
| ```cwd = os.getcwd()```,output,1,571 |
| Find the full path of current directory,instruction,0,572 |
| ```full_path = os.path.realpath(__file__)```,output,1,572 |
| sort array `arr` in ascending order by values of the 3rd column,instruction,0,573 |
| "```arr[arr[:, (2)].argsort()]```",output,1,573 |
| sort rows of numpy matrix `arr` in ascending order according to all column values,instruction,0,574 |
| "```numpy.sort(arr, axis=0)```",output,1,574 |
| "split string 'a b.c' on space "" "" and dot character "".""",instruction,0,575 |
| "```re.split('[ .]', 'a b.c')```",output,1,575 |
| copy the content of file 'file.txt' to file 'file2.txt',instruction,0,576 |
| "```shutil.copy('file.txt', 'file2.txt')```",output,1,576 |
| generate random upper-case ascii string of 12 characters length,instruction,0,577 |
| ```print(''.join(choice(ascii_uppercase) for i in range(12)))```,output,1,577 |
| merge the elements in a list `lst` sequentially,instruction,0,578 |
| "```[''.join(seq) for seq in zip(lst, lst[1:])]```",output,1,578 |
| rename column 'gdp' in dataframe `data` to 'log(gdp)',instruction,0,579 |
| "```data.rename(columns={'gdp': 'log(gdp)'}, inplace=True)```",output,1,579 |
| convert a beautiful soup html `soup` to text,instruction,0,580 |
| ```print(soup.get_text())```,output,1,580 |
| Sort list `li` in descending order based on the second element of each list inside list`li`,instruction,0,581 |
| "```sorted(li, key=operator.itemgetter(1), reverse=True)```",output,1,581 |
| replace value 0 with 'Female' and value 1 with 'Male' in column 'sex' of dataframe `data`,instruction,0,582 |
| "```data['sex'].replace([0, 1], ['Female', 'Male'], inplace=True)```",output,1,582 |
| "split string 'Words, words, words.' on punctuation",instruction,0,583 |
| "```re.split('\\W+', 'Words, words, words.')```",output,1,583 |
| "Extract first two substrings in string `phrase` that end in `.`, `?` or `!`",instruction,0,584 |
| "```re.match('(.*?[.?!](?:\\s+.*?[.?!]){0,1})', phrase).group(1)```",output,1,584 |
| split string `s` into strings of repeating elements,instruction,0,585 |
| "```print([a for a, b in re.findall('((\\w)\\2*)', s)])```",output,1,585 |
| Create new string with unique characters from `s` seperated by ' ',instruction,0,586 |
| ```print(' '.join(OrderedDict.fromkeys(s)))```,output,1,586 |
| create a set from string `s` to remove duplicate characters,instruction,0,587 |
| ```print(' '.join(set(s)))```,output,1,587 |
| list folders in zip file 'file' that ends with '/',instruction,0,588 |
| ```[x for x in file.namelist() if x.endswith('/')]```,output,1,588 |
| find the count of a word 'Hello' in a string `input_string`,instruction,0,589 |
| ```input_string.count('Hello')```,output,1,589 |
| "reduce the first element of list of strings `data` to a string, separated by '.'",instruction,0,590 |
| ```print('.'.join([item[0] for item in data]))```,output,1,590 |
| Move the cursor of file pointer `fh1` at the end of the file.,instruction,0,591 |
| ```fh1.seek(2)```,output,1,591 |
| "convert a flat list into a list of tuples of every two items in the list, in order",instruction,0,592 |
| "```print(zip(my_list[0::2], my_list[1::2]))```",output,1,592 |
| group a list of ints into a list of tuples of each 2 elements,instruction,0,593 |
| "```my_new_list = zip(my_list[0::2], my_list[1::2])```",output,1,593 |
| set the default encoding to 'utf-8',instruction,0,594 |
| ```sys.setdefaultencoding('utf8')```,output,1,594 |
| Formate current date and time to a string using pattern '%Y-%m-%d %H:%M:%S',instruction,0,595 |
| ```datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')```,output,1,595 |
| retrieve arabic texts from string `my_string`,instruction,0,596 |
| "```print(re.findall('[\\u0600-\\u06FF]+', my_string))```",output,1,596 |
| group dataframe `df` based on minute interval,instruction,0,597 |
| ```df.groupby(df.index.map(lambda t: t.minute))```,output,1,597 |
| access value associated with key 'American' of key 'Apple' from dictionary `dict`,instruction,0,598 |
| ```dict['Apple']['American']```,output,1,598 |
| "remove all null values from columns 'three', 'four' and 'five' of dataframe `df2`",instruction,0,599 |
| "```df2.dropna(subset=['three', 'four', 'five'], how='all')```",output,1,599 |
| insert a list `k` at the front of list `a`,instruction,0,600 |
| "```a.insert(0, k)```",output,1,600 |
| insert elements of list `k` into list `a` at position `n`,instruction,0,601 |
| ```a = a[:n] + k + a[n:]```,output,1,601 |
| calculate the mean of the nonzero values' indices of dataframe `df`,instruction,0,602 |
| ```np.flatnonzero(x).mean()```,output,1,602 |
| get date from dataframe `df` column 'dates' to column 'just_date',instruction,0,603 |
| ```df['just_date'] = df['dates'].dt.date```,output,1,603 |
| remove elements in list `b` from list `a`,instruction,0,604 |
| ```[x for x in a if x not in b]```,output,1,604 |
| join elements of each tuple in list `a` into one string,instruction,0,605 |
| ```[''.join(x) for x in a]```,output,1,605 |
| join items of each tuple in list of tuples `a` into a list of strings,instruction,0,606 |
| "```list(map(''.join, a))```",output,1,606 |
| match blank lines in `s` with regular expressions,instruction,0,607 |
| "```re.split('\n\\s*\n', s)```",output,1,607 |
| "merge a list of integers `[1, 2, 3, 4, 5]` into a single integer",instruction,0,608 |
| "```from functools import reduce |
| reduce(lambda x, y: 10 * x + y, [1, 2, 3, 4, 5])```",output,1,608 |
| Convert float 24322.34 to comma-separated string,instruction,0,609 |
| "```""""""{0:,.2f}"""""".format(24322.34)```",output,1,609 |
| pass dictionary items `data` as keyword arguments in function `my_function`,instruction,0,610 |
| ```my_function(**data)```,output,1,610 |
| get line count of file 'myfile.txt',instruction,0,611 |
| ```sum((1 for line in open('myfile.txt')))```,output,1,611 |
| get line count of file `filename`,instruction,0,612 |
| "```def bufcount(filename): |
| f = open(filename) |
| lines = 0 |
| buf_size = (1024 * 1024) |
| read_f = f.read |
| buf = read_f(buf_size) |
| while buf: |
| lines += buf.count('\n') |
| buf = read_f(buf_size) |
| return lines```",output,1,612 |
| round 1123.456789 to be an integer,instruction,0,613 |
| "```print(round(1123.456789, -1))```",output,1,613 |
| sort list `X` based on values from another list `Y`,instruction,0,614 |
| "```[x for y, x in sorted(zip(Y, X))]```",output,1,614 |
| sorting list 'X' based on values from another list 'Y',instruction,0,615 |
| "```[x for y, x in sorted(zip(Y, X))]```",output,1,615 |
| get equivalent week number from a date `2010/6/16` using isocalendar,instruction,0,616 |
| "```datetime.date(2010, 6, 16).isocalendar()[1]```",output,1,616 |
| "select multiple ranges of columns 1-10, 15, 17, and 50-100 in pandas dataframe `df`",instruction,0,617 |
| "```df.iloc[:, (np.r_[1:10, (15), (17), 50:100])]```",output,1,617 |
| apply two different aggregating functions `mean` and `sum` to the same column `dummy` in pandas data frame `df`,instruction,0,618 |
| "```df.groupby('dummy').agg({'returns': [np.mean, np.sum]})```",output,1,618 |
| convert string `s` to lowercase,instruction,0,619 |
| ```s.lower()```,output,1,619 |
| convert utf-8 string `s` to lowercase,instruction,0,620 |
| ```s.decode('utf-8').lower()```,output,1,620 |
| ,instruction,0,621 |
| "```ftp.retrbinary('RETR %s' % filename, file.write)```",output,1,621 |
| handle the `urlfetch_errors ` exception for imaplib request to url `url`,instruction,0,622 |
| "```urlfetch.fetch(url, deadline=10 * 60)```",output,1,622 |
| output first 100 characters in a string `my_string`,instruction,0,623 |
| ```print(my_string[0:100])```,output,1,623 |
| make matplotlib plot legend put marker in legend only once,instruction,0,624 |
| ```legend(numpoints=1)```,output,1,624 |
| get set intersection between dictionaries `d1` and `d2`,instruction,0,625 |
| "```dict((x, set(y) & set(d1.get(x, ()))) for x, y in d2.items())```",output,1,625 |
| convert csv file 'test.csv' into two-dimensional matrix,instruction,0,626 |
| "```numpy.loadtxt(open('test.csv', 'rb'), delimiter=',', skiprows=1)```",output,1,626 |
| filter the objects in django model 'Sample' between date range `2011-01-01` and `2011-01-31`,instruction,0,627 |
| "```Sample.objects.filter(date__range=['2011-01-01', '2011-01-31'])```",output,1,627 |
| filter objects month wise in django model `Sample` for year `2011`,instruction,0,628 |
| "```Sample.objects.filter(date__year='2011', date__month='01')```",output,1,628 |
| "create a dictionary `{'spam': 5, 'ham': 6}` into another dictionary `d` field 'dict3'",instruction,0,629 |
| "```d['dict3'] = {'spam': 5, 'ham': 6}```",output,1,629 |
| apply `numpy.linalg.norm` to each row of a matrix `a`,instruction,0,630 |
| "```numpy.apply_along_axis(numpy.linalg.norm, 1, a)```",output,1,630 |
| merge dictionaries form array `dicts` in a single expression,instruction,0,631 |
| "```dict((k, v) for d in dicts for k, v in list(d.items()))```",output,1,631 |
| Convert escaped utf string to utf string in `your string`,instruction,0,632 |
| ```print('your string'.decode('string_escape'))```,output,1,632 |
| "counting the number of true booleans in a python list `[True, True, False, False, False, True]`",instruction,0,633 |
| "```sum([True, True, False, False, False, True])```",output,1,633 |
| "set the size of figure `fig` in inches to width height of `w`, `h`",instruction,0,634 |
| "```fig.set_size_inches(w, h, forward=True)```",output,1,634 |
| format string with dict `{'5': 'you'}` with integer keys,instruction,0,635 |
| ```'hello there %(5)s' % {'5': 'you'}```,output,1,635 |
| "Convert a string of numbers `example_string` separated by `,` into a list of integers",instruction,0,636 |
| "```map(int, example_string.split(','))```",output,1,636 |
| Convert a string of numbers 'example_string' separated by comma into a list of numbers,instruction,0,637 |
| "```[int(s) for s in example_string.split(',')]```",output,1,637 |
| Flatten list `x`,instruction,0,638 |
| ```x = [i[0] for i in x]```,output,1,638 |
| convert list `x` into a flat list,instruction,0,639 |
| "```y = map(operator.itemgetter(0), x)```",output,1,639 |
| get a list `y` of the first element of every tuple in list `x`,instruction,0,640 |
| ```y = [i[0] for i in x]```,output,1,640 |
| extract all the values of a specific key named 'values' from a list of dictionaries,instruction,0,641 |
| ```results = [item['value'] for item in test_data]```,output,1,641 |
| get current datetime in ISO format,instruction,0,642 |
| ```datetime.datetime.now().isoformat()```,output,1,642 |
| get UTC datetime in ISO format,instruction,0,643 |
| ```datetime.datetime.utcnow().isoformat()```,output,1,643 |
| Merge all columns in dataframe `df` into one column,instruction,0,644 |
| "```df.apply(' '.join, axis=0)```",output,1,644 |
| pandas subtract a row from dataframe `df2` from dataframe `df`,instruction,0,645 |
| "```pd.DataFrame(df.values - df2.values, columns=df.columns)```",output,1,645 |
| read file 'myfile.txt' using universal newline mode 'U',instruction,0,646 |
| "```print(open('myfile.txt', 'U').read())```",output,1,646 |
| print line `line` from text file with 'utf-16-le' format,instruction,0,647 |
| ```print(line.decode('utf-16-le').split())```,output,1,647 |
| open a text file `data.txt` in io module with encoding `utf-16-le`,instruction,0,648 |
| "```file = io.open('data.txt', 'r', encoding='utf-16-le')```",output,1,648 |
| Join data of dataframe `df1` with data in dataframe `df2` based on similar values of column 'user_id' in both dataframes,instruction,0,649 |
| "```s1 = pd.merge(df1, df2, how='inner', on=['user_id'])```",output,1,649 |
| check if string `foo` is UTF-8 encoded,instruction,0,650 |
| ```foo.decode('utf8').encode('utf8')```,output,1,650 |
| get the dimensions of numpy array `a`,instruction,0,651 |
| ```a.shape```,output,1,651 |
| get the dimensions of numpy array `a`,instruction,0,652 |
| ```N.shape(a)```,output,1,652 |
| get the dimensions of array `a`,instruction,0,653 |
| ```N.shape(a)```,output,1,653 |
| get the dimensions of numpy array `a`,instruction,0,654 |
| ```a.shape```,output,1,654 |
| get the indices of tuples in list of tuples `L` where the first value is 53,instruction,0,655 |
| "```[i for i, v in enumerate(L) if v[0] == 53]```",output,1,655 |
| convert string of bytes `y\xcc\xa6\xbb` into an int,instruction,0,656 |
| "```struct.unpack('<L', 'y\xcc\xa6\xbb')[0]```",output,1,656 |
| "get the first row, second column; second row, first column, and first row third column values of numpy array `arr`",instruction,0,657 |
| "```arr[[0, 1, 1], [1, 0, 2]]```",output,1,657 |
| create a list with permutations of string 'abcd',instruction,0,658 |
| ```list(powerset('abcd'))```,output,1,658 |
| Convert string to boolean from defined set of strings,instruction,0,659 |
| "```s in ['true', '1', 't', 'y', 'yes', 'yeah', 'yup', 'certainly', 'uh-huh']```",output,1,659 |
| replace special characters in url 'http: |
| ```urllib.parse.quote('http://spam.com/go/')```,output,1,660 |
| Save plot `plt` as svg file 'test.svg',instruction,0,661 |
| ```plt.savefig('test.svg')```,output,1,661 |
| count the number of elements in array `myArray`,instruction,0,662 |
| ```len(myArray)```,output,1,662 |
| insert directory './path/to/your/modules/' to current directory,instruction,0,663 |
| "```sys.path.insert(0, './path/to/your/modules/')```",output,1,663 |
| ,instruction,0,664 |
| ```ax.xaxis.set_ticks_position('top')```,output,1,664 |
| "Insert records in bulk from ""table1"" of ""master"" DB to ""table1"" of sqlite3 `cursor` object",instruction,0,665 |
| ```cursor.execute('INSERT OR REPLACE INTO master.table1 SELECT * FROM table1')```,output,1,665 |
| Match regex '[a-zA-Z][\\w-]*\\Z' on string 'A\n',instruction,0,666 |
| "```re.match('[a-zA-Z][\\w-]*\\Z', 'A\n')```",output,1,666 |
| match regex '[a-zA-Z][\\w-]*$' on string '!A_B',instruction,0,667 |
| "```re.match('[a-zA-Z][\\w-]*$', '!A_B')```",output,1,667 |
| "Convert hex string ""deadbeef"" to integer",instruction,0,668 |
| "```int('deadbeef', 16)```",output,1,668 |
| "Convert hex string ""a"" to integer",instruction,0,669 |
| "```int('a', 16)```",output,1,669 |
| "Convert hex string ""0xa"" to integer",instruction,0,670 |
| "```int('0xa', 16)```",output,1,670 |
| Convert hex string `s` to integer,instruction,0,671 |
| "```int(s, 16)```",output,1,671 |
| Convert hex string `hexString` to int,instruction,0,672 |
| "```int(hexString, 16)```",output,1,672 |
| print variable `value ` without spaces,instruction,0,673 |
| "```print('Value is ""' + str(value) + '""')```",output,1,673 |
| Print a string `value` with string formatting,instruction,0,674 |
| "```print('Value is ""{}""'.format(value))```",output,1,674 |
| Jinja join elements of array `tags` with space string ' ',instruction,0,675 |
| ```{{tags | join(' ')}}```,output,1,675 |
| get a list of locally installed Python modules,instruction,0,676 |
| ```help('modules')```,output,1,676 |
| Get only first element in each of the innermost of the multidimensional list `listD`,instruction,0,677 |
| ```[[[x[0]] for x in listD[i]] for i in range(len(listD))]```,output,1,677 |
| Sort a string `s` in lexicographic order,instruction,0,678 |
| "```sorted(s, key=str.upper)```",output,1,678 |
| sort string `s` in lexicographic order,instruction,0,679 |
| "```sorted(sorted(s), key=str.upper)```",output,1,679 |
| "get a sorted list of the characters of string `s` in lexicographic order, with lowercase letters first",instruction,0,680 |
| "```sorted(s, key=str.lower)```",output,1,680 |
| "find all the rows in Dataframe 'df2' that are also present in Dataframe 'df1', for the columns 'A', 'B', 'C' and 'D'.",instruction,0,681 |
| "```pd.merge(df1, df2, on=['A', 'B', 'C', 'D'], how='inner')```",output,1,681 |
| Reverse key-value pairs in a dictionary `map`,instruction,0,682 |
| "```dict((v, k) for k, v in map.items())```",output,1,682 |
| decode unicode string `s` into a readable unicode literal,instruction,0,683 |
| ```s.decode('unicode_escape')```,output,1,683 |
| convert list of strings `str_list` into list of integers,instruction,0,684 |
| ```[int(i) for i in str_list]```,output,1,684 |
| "convert a list with string `['1', '2', '3']` into list with integers",instruction,0,685 |
| "```map(int, ['1', '2', '3'])```",output,1,685 |
| convert list with str into list with int,instruction,0,686 |
| "```list(map(int, ['1', '2', '3']))```",output,1,686 |
| find all anchor tags in html `soup` whose url begins with `http: |
| "```soup.find_all('a', href=re.compile('http://www\\.iwashere\\.com/'))```",output,1,687 |
| find all anchors with a hyperlink that matches the pattern '^(?!(?:[a-zA-Z][a-zA-Z0-9+.-]*:|//))',instruction,0,688 |
| "```soup.find_all('a', href=re.compile('^(?!(?:[a-zA-Z][a-zA-Z0-9+.-]*:|//))'))```",output,1,688 |
| execute a jar file 'Blender.jar' using subprocess,instruction,0,689 |
| "```subprocess.call(['java', '-jar', 'Blender.jar'])```",output,1,689 |
| insert row into mysql database with column 'column1' set to the value `value`,instruction,0,690 |
| "```cursor.execute('INSERT INTO table (`column1`) VALUES (%s)', (value,))```",output,1,690 |
| "remove a substring "".com"" from the end of string `url`",instruction,0,691 |
| "```if url.endswith('.com'): |
| url = url[:(-4)]```",output,1,691 |
| "remove a substring "".com"" from the end of string `url`",instruction,0,692 |
| "```url = re.sub('\\.com$', '', url)```",output,1,692 |
| "remove a substring "".com"" from the end of string `url`",instruction,0,693 |
| "```print(url.replace('.com', ''))```",output,1,693 |
| remove a substring `suffix` from the end of string `text`,instruction,0,694 |
| "```if (not text.endswith(suffix)): |
| return text |
| return text[:(len(text) - len(suffix))]```",output,1,694 |
| print each first value from a list of tuples `mytuple` with string formatting,instruction,0,695 |
| "```print(', ,'.join([str(i[0]) for i in mytuple]))```",output,1,695 |
| clamping floating number `my_value` to be between `min_value` and `max_value`,instruction,0,696 |
| "```max(min(my_value, max_value), min_value)```",output,1,696 |
| split a unicode string `text` into a list of words and punctuation characters with a regex,instruction,0,697 |
| "```re.findall('\\w+|[^\\w\\s]', text, re.UNICODE)```",output,1,697 |
| execute raw sql queue '<sql here>' in database `db` in sqlalchemy-flask app,instruction,0,698 |
| ```result = db.engine.execute('<sql here>')```,output,1,698 |
| quit program,instruction,0,699 |
| ```sys.exit(0)```,output,1,699 |
| get digits in string `my_string`,instruction,0,700 |
| "```"""""""""""".join(c for c in my_string if c.isdigit())```",output,1,700 |
| split string `str1` on one or more spaces with a regular expression,instruction,0,701 |
| "```re.split(' +', str1)```",output,1,701 |
| ,instruction,0,702 |
| "```re.findall('\\S+', str1)```",output,1,702 |
| Evaluate a nested dictionary `myobject.id.number` to get `number` if `myobject` is present with getattr,instruction,0,703 |
| "```getattr(getattr(myobject, 'id', None), 'number', None)```",output,1,703 |
| convert generator object to a dictionary,instruction,0,704 |
| ```{i: (i * 2) for i in range(10)}```,output,1,704 |
| convert generator object to a dictionary,instruction,0,705 |
| "```dict((i, i * 2) for i in range(10))```",output,1,705 |
| Matplotlib clear the current axes.,instruction,0,706 |
| ```plt.cla()```,output,1,706 |
| split string `s` into float values and write sum to `total`,instruction,0,707 |
| "```total = sum(float(item) for item in s.split(','))```",output,1,707 |
| Convert ascii value 'P' to binary,instruction,0,708 |
| ```bin(ord('P'))```,output,1,708 |
| "print a string after a specific substring ', ' in string `my_string `",instruction,0,709 |
| "```print(my_string.split(', ', 1)[1])```",output,1,709 |
| get value of key `post code` associated with first index of key `places` of dictionary `data`,instruction,0,710 |
| ```print(data['places'][0]['post code'])```,output,1,710 |
| remove colon character surrounded by vowels letters in string `word`,instruction,0,711 |
| "```word = re.sub('([aeiou]):(([aeiou][^aeiou]*){3})$', '\\1\\2', word)```",output,1,711 |
| extract data field 'bar' from json object,instruction,0,712 |
| "```json.loads('{""foo"": 42, ""bar"": ""baz""}')['bar']```",output,1,712 |
| Convert JSON array `array` to Python object,instruction,0,713 |
| ```data = json.loads(array)```,output,1,713 |
| Convert JSON array `array` to Python object,instruction,0,714 |
| ```data = json.loads(array)```,output,1,714 |
| pars a string 'http://example.org/#comments' to extract hashtags into an array,instruction,0,715 |
| "```re.findall('#(\\w+)', 'http://example.org/#comments')```",output,1,715 |
| do a boolean check if a string `lestring` contains any of the items in list `lelist`,instruction,0,716 |
| ```any(e in lestring for e in lelist)```,output,1,716 |
| ,instruction,0,717 |
| "```df.plot(x='col_name_1', y='col_name_2', style='o')```",output,1,717 |
| Parsing HTML string `html` using BeautifulSoup,instruction,0,718 |
| "```parsed_html = BeautifulSoup(html) |
| print(parsed_html.body.find('div', attrs={'class': 'container', }).text)```",output,1,718 |
| Parsing webpage 'http://www.google.com/' using BeautifulSoup,instruction,0,719 |
| "```page = urllib.request.urlopen('http://www.google.com/') |
| soup = BeautifulSoup(page)```",output,1,719 |
| change figure size to 3 by 4 in matplotlib,instruction,0,720 |
| "```plt.figure(figsize=(3, 4))```",output,1,720 |
| Strip punctuation from string `s`,instruction,0,721 |
| "```s.translate(None, string.punctuation)```",output,1,721 |
| django urlsafe base64 decode string `uenc` with decryption,instruction,0,722 |
| ```base64.urlsafe_b64decode(uenc.encode('ascii'))```,output,1,722 |
| get the number of all keys in the nested dictionary `dict_list`,instruction,0,723 |
| ```len(dict_test) + sum(len(v) for v in dict_test.values())```,output,1,723 |
| return the conversion of decimal `d` to hex without the '0x' prefix,instruction,0,724 |
| ```hex(d).split('x')[1]```,output,1,724 |
| create a list containing digits of number 123 as its elements,instruction,0,725 |
| ```list(str(123))```,output,1,725 |
| converting integer `num` to list,instruction,0,726 |
| ```[int(x) for x in str(num)]```,output,1,726 |
| select a first form with no name in mechanize,instruction,0,727 |
| ```br.select_form(nr=0)```,output,1,727 |
| Open file 'sample.json' in read mode with encoding of 'utf-8-sig',instruction,0,728 |
| "```json.load(codecs.open('sample.json', 'r', 'utf-8-sig'))```",output,1,728 |
| load json file 'sample.json' with utf-8 bom header,instruction,0,729 |
| ```json.loads(open('sample.json').read().decode('utf-8-sig'))```,output,1,729 |
| setup a smtp mail server to `smtp.gmail.com` with port `587`,instruction,0,730 |
| "```server = smtplib.SMTP('smtp.gmail.com', 587)```",output,1,730 |
| revers correlating bits of integer `n`,instruction,0,731 |
| "```int('{:08b}'.format(n)[::-1], 2)```",output,1,731 |
| add column `d` to index of dataframe `df`,instruction,0,732 |
| "```df.set_index(['d'], append=True)```",output,1,732 |
| Iterating over a dictionary `d` using for loops,instruction,0,733 |
| "```for (key, value) in d.items(): |
| pass```",output,1,733 |
| Iterating over a dictionary `d` using for loops,instruction,0,734 |
| "```for (key, value) in list(d.items()): |
| pass```",output,1,734 |
| Iterating key and items over dictionary `d`,instruction,0,735 |
| "```for (letter, number) in list(d.items()): |
| pass```",output,1,735 |
| Iterating key and items over dictionary `d`,instruction,0,736 |
| "```for (k, v) in list(d.items()): |
| pass```",output,1,736 |
| get keys and items of dictionary `d`,instruction,0,737 |
| ```list(d.items())```,output,1,737 |
| get keys and items of dictionary `d` as a list,instruction,0,738 |
| ```list(d.items())```,output,1,738 |
| Iterating key and items over dictionary `d`,instruction,0,739 |
| "```for (k, v) in list(d.items()): |
| pass```",output,1,739 |
| Iterating key and items over dictionary `d`,instruction,0,740 |
| "```for (letter, number) in list(d.items()): |
| pass```",output,1,740 |
| Iterating key and items over dictionary `d`,instruction,0,741 |
| "```for (letter, number) in list(d.items()): |
| pass```",output,1,741 |
| query all data from table `Task` where the value of column `time_spent` is bigger than 3 hours,instruction,0,742 |
| ```session.query(Task).filter(Task.time_spent > timedelta(hours=3)).all()```,output,1,742 |
| compile Visual Studio project `project.sln` from the command line through python,instruction,0,743 |
| ```os.system('msbuild project.sln /p:Configuration=Debug')```,output,1,743 |
| get max key in dictionary `MyCount`,instruction,0,744 |
| "```max(list(MyCount.keys()), key=int)```",output,1,744 |
| execute command 'source .bashrc; shopt -s expand_aliases; nuke -x scriptPath' from python script,instruction,0,745 |
| ```os.system('source .bashrc; shopt -s expand_aliases; nuke -x scriptPath')```,output,1,745 |
| get a name of function `my_function` as a string,instruction,0,746 |
| ```my_function.__name__```,output,1,746 |
| ,instruction,0,747 |
| ```my_function.__name__```,output,1,747 |
| check if all values in the columns of a numpy matrix `a` are same,instruction,0,748 |
| "```np.all(a == a[(0), :], axis=0)```",output,1,748 |
| sort list `a` in ascending order based on the addition of the second and third elements of each tuple in it,instruction,0,749 |
| "```sorted(a, key=lambda x: (sum(x[1:3]), x[0]))```",output,1,749 |
| sort a list of tuples `a` by the sum of second and third element of each tuple,instruction,0,750 |
| "```sorted(a, key=lambda x: (sum(x[1:3]), x[0]), reverse=True)```",output,1,750 |
| "sorting a list of tuples `lst` by the sum of the second elements onwards, and third element of the tuple",instruction,0,751 |
| "```sorted(lst, key=lambda x: (sum(x[1:]), x[0]))```",output,1,751 |
| sort the list of tuples `lst` by the sum of every value except the first and by the first value in reverse order,instruction,0,752 |
| "```sorted(lst, key=lambda x: (sum(x[1:]), x[0]), reverse=True)```",output,1,752 |
| "add header 'WWWAuthenticate' in a flask app with value 'Basic realm=""test""'",instruction,0,753 |
| "```response.headers['WWW-Authenticate'] = 'Basic realm=""test""'```",output,1,753 |
| clear session key 'mykey',instruction,0,754 |
| ```del request.session['mykey']```,output,1,754 |
| convert date string '24052010' to date object in format '%d%m%Y',instruction,0,755 |
| "```datetime.datetime.strptime('24052010', '%d%m%Y').date()```",output,1,755 |
| Replace non-ASCII characters in string `text` with a single space,instruction,0,756 |
| "```re.sub('[^\\x00-\\x7F]+', ' ', text)```",output,1,756 |
| ,instruction,0,757 |
| "```numpy.array([[1, 2], [3, 4]])```",output,1,757 |
| Get a list `myList` from 1 to 10,instruction,0,758 |
| ```myList = [i for i in range(10)]```,output,1,758 |
| use regex pattern '((.+?)\\2+)' to split string '44442(2)2(2)44',instruction,0,759 |
| ```[m[0] for m in re.compile('((.+?)\\2+)').findall('44442(2)2(2)44')]```,output,1,759 |
| use regular expression '((\\d)(?:[()]*\\2*[()]*)*)' to split string `s`,instruction,0,760 |
| "```[i[0] for i in re.findall('((\\d)(?:[()]*\\2*[()]*)*)', s)]```",output,1,760 |
| remove the space between subplots in matplotlib.pyplot,instruction,0,761 |
| "```fig.subplots_adjust(wspace=0, hspace=0)```",output,1,761 |
| Reverse list `x`,instruction,0,762 |
| ```x[::-1]```,output,1,762 |
| ,instruction,0,763 |
| "```json.dumps({'apple': 'cat', 'banana': 'dog', 'pear': 'fish'})```",output,1,763 |
| write a list of strings `row` to csv object `csvwriter`,instruction,0,764 |
| ```csvwriter.writerow(row)```,output,1,764 |
| Jinja2 formate date `item.date` accorto pattern 'Y M d',instruction,0,765 |
| ```{{(item.date | date): 'Y M d'}}```,output,1,765 |
| "Split a string `text` with comma, question mark or exclamation by non-consuming regex using look-behind",instruction,0,766 |
| "```re.split('(?<=[\\.\\?!]) ', text)```",output,1,766 |
| create a regular expression object with the pattern '\xe2\x80\x93',instruction,0,767 |
| ```re.compile('\xe2\x80\x93')```,output,1,767 |
| declare an array `variable`,instruction,0,768 |
| ```variable = []```,output,1,768 |
| declare an array with element 'i',instruction,0,769 |
| ```intarray = array('i')```,output,1,769 |
| "given list `to_reverse`, reverse the all sublists and the list itself",instruction,0,770 |
| ```[sublist[::-1] for sublist in to_reverse[::-1]]```,output,1,770 |
| ,instruction,0,771 |
| "```re.sub('[^0-9a-zA-Z]+', '*', 'h^&ell`.,|o w]{+orld')```",output,1,771 |
| "unescape special characters without splitting data in array of strings `['I ', u'<', '3s U ', u'&', ' you luvz me']`",instruction,0,772 |
| "```"""""""""""".join(['I ', '<', '3s U ', '&', ' you luvz me'])```",output,1,772 |
| disable logging while running unit tests in python django,instruction,0,773 |
| ```logging.disable(logging.CRITICAL)```,output,1,773 |
| adding url `url` to mysql row,instruction,0,774 |
| "```cursor.execute('INSERT INTO index(url) VALUES(%s)', (url,))```",output,1,774 |
| convert column of date objects 'DateObj' in pandas dataframe `df` to strings in new column 'DateStr',instruction,0,775 |
| ```df['DateStr'] = df['DateObj'].dt.strftime('%d%m%Y')```,output,1,775 |
| split string `s` by '@' and get the first element,instruction,0,776 |
| ```s.split('@')[0]```,output,1,776 |
| drop rows of dataframe `df` whose index is smaller than the value of `start_remove` or bigger than the value of`end_remove`,instruction,0,777 |
| ```df.query('index < @start_remove or index > @end_remove')```,output,1,777 |
| Drop the rows in pandas timeseries `df` from the row containing index `start_remove` to the row containing index `end_remove`,instruction,0,778 |
| ```df.loc[(df.index < start_remove) | (df.index > end_remove)]```,output,1,778 |
| Get the number of NaN values in each column of dataframe `df`,instruction,0,779 |
| ```df.isnull().sum()```,output,1,779 |
| reset index of dataframe `df`so that existing index values are transferred into `df`as columns,instruction,0,780 |
| ```df.reset_index(inplace=True)```,output,1,780 |
| generate a list containing values associated with the key 'value' of each dictionary inside list `list_of_dicts`,instruction,0,781 |
| ```[x['value'] for x in list_of_dicts]```,output,1,781 |
| ,instruction,0,782 |
| ```[d['value'] for d in l]```,output,1,782 |
| ,instruction,0,783 |
| ```[d['value'] for d in l if 'value' in d]```,output,1,783 |
| convert numpy array into python list structure,instruction,0,784 |
| "```np.array([[1, 2, 3], [4, 5, 6]]).tolist()```",output,1,784 |
| "converting string '(1,2,3,4)' to a tuple",instruction,0,785 |
| "```ast.literal_eval('(1,2,3,4)')```",output,1,785 |
| keep a list `dataList` of lists sorted as it is created by second element,instruction,0,786 |
| ```dataList.sort(key=lambda x: x[1])```,output,1,786 |
| remove duplicated items from list of lists `testdata`,instruction,0,787 |
| "```list(map(list, set(map(lambda i: tuple(i), testdata))))```",output,1,787 |
| uniqueness for list of lists `testdata`,instruction,0,788 |
| ```[list(i) for i in set(tuple(i) for i in testdata)]```,output,1,788 |
| "in django, check if a user is in a group 'Member'",instruction,0,789 |
| ```return user.groups.filter(name='Member').exists()```,output,1,789 |
| "check if a user `user` is in a group from list of groups `['group1', 'group2']`",instruction,0,790 |
| "```return user.groups.filter(name__in=['group1', 'group2']).exists()```",output,1,790 |
| Change log level dynamically to 'DEBUG' without restarting the application,instruction,0,791 |
| ```logging.getLogger().setLevel(logging.DEBUG)```,output,1,791 |
| "Concat each values in a tuple `(34.2424, -64.2344, 76.3534, 45.2344)` to get a string",instruction,0,792 |
| "```"""""""""""".join(str(i) for i in (34.2424, -64.2344, 76.3534, 45.2344))```",output,1,792 |
| swap each pair of characters in string `s`,instruction,0,793 |
| "```"""""""""""".join([s[x:x + 2][::-1] for x in range(0, len(s), 2)])```",output,1,793 |
| save current figure to file 'graph.png' with resolution of 1000 dpi,instruction,0,794 |
| "```plt.savefig('graph.png', dpi=1000)```",output,1,794 |
| delete items from list `my_list` if the item exist in list `to_dell`,instruction,0,795 |
| ```my_list = [[x for x in sublist if x not in to_del] for sublist in my_list]```,output,1,795 |
| find all the elements that consists value '1' in a list of tuples 'a',instruction,0,796 |
| ```[item for item in a if 1 in item]```,output,1,796 |
| find all elements in a list of tuples `a` where the first element of each tuple equals 1,instruction,0,797 |
| ```[item for item in a if item[0] == 1]```,output,1,797 |
| Get the index value in list `p_list` using enumerate in list comprehension,instruction,0,798 |
| "```{p.id: {'id': p.id, 'position': ind} for ind, p in enumerate(p_list)}```",output,1,798 |
| ,instruction,0,799 |
| ```[dict(y) for y in set(tuple(x.items()) for x in d)]```,output,1,799 |
| load a file `file.py` into the python console,instruction,0,800 |
| "```exec(compile(open('file.py').read(), 'file.py', 'exec'))```",output,1,800 |
| SQLAlchemy count the number of rows in table `Congress`,instruction,0,801 |
| ```rows = session.query(Congress).count()```,output,1,801 |
| ,instruction,0,802 |
| "```subprocess.call(['test.sh', str(domid)])```",output,1,802 |
| read excel file `file_name` using pandas,instruction,0,803 |
| "```dfs = pd.read_excel(file_name, sheetname=None)```",output,1,803 |
| unpack the binary data represented by the hexadecimal string '4081637ef7d0424a' to a float,instruction,0,804 |
| "```struct.unpack('d', binascii.unhexlify('4081637ef7d0424a'))```",output,1,804 |
| Get index of numpy array `a` with another numpy array `b`,instruction,0,805 |
| ```a[tuple(b)]```,output,1,805 |
| "find all possible sequences of elements in a list `[2, 3, 4]`",instruction,0,806 |
| "```map(list, permutations([2, 3, 4]))```",output,1,806 |
| sort a list `unsorted_list` based on another sorted list `presorted_list`,instruction,0,807 |
| "```sorted(unsorted_list, key=presorted_list.index)```",output,1,807 |
| ,instruction,0,808 |
| ```datetime.datetime.now() - datetime.timedelta(days=1)```,output,1,808 |
| create a dataframe `d` filled with zeros with indices from 0 to length of `data` and column names from `feature_list`,instruction,0,809 |
| "```d = pd.DataFrame(0, index=np.arange(len(data)), columns=feature_list)```",output,1,809 |
| find the index of sub string 'World' in `x`,instruction,0,810 |
| ```x.find('World')```,output,1,810 |
| find the index of sub string 'Aloha' in `x`,instruction,0,811 |
| ```x.find('Aloha')```,output,1,811 |
| find the index of sub string 'cc' in string 'sdfasdf',instruction,0,812 |
| ```'sdfasdf'.index('cc')```,output,1,812 |
| find the index of sub string 'df' in string 'sdfasdf',instruction,0,813 |
| ```'sdfasdf'.index('df')```,output,1,813 |
| find the index of sub string 'a' in string `str`,instruction,0,814 |
| ```str.find('a')```,output,1,814 |
| find the index of sub string 'g' in string `str`,instruction,0,815 |
| ```str.find('g')```,output,1,815 |
| find the index of sub string 's' in string `str` starting from index 11,instruction,0,816 |
| "```str.find('s', 11)```",output,1,816 |
| find the index of sub string 's' in string `str` starting from index 15,instruction,0,817 |
| "```str.find('s', 15)```",output,1,817 |
| find the index of sub string 's' in string `str` starting from index 16,instruction,0,818 |
| "```str.find('s', 16)```",output,1,818 |
| find the index of sub string 's' in string `str` starting from index 11 and ending at index 14,instruction,0,819 |
| "```str.find('s', 11, 14)```",output,1,819 |
| sort list of date strings 'd',instruction,0,820 |
| "```sorted(d, key=lambda x: datetime.datetime.strptime(x, '%m-%Y'))```",output,1,820 |
| Get all the sentences from a string `text` using regex,instruction,0,821 |
| "```re.split('\\.\\s', text)```",output,1,821 |
| ,instruction,0,822 |
| "```re.split('\\.\\s', re.sub('\\.\\s*$', '', text))```",output,1,822 |
| get all characters in string 'foobar' up to the fourth index,instruction,0,823 |
| "```""""""foobar""""""[:4]```",output,1,823 |
| cut a string by delimiter '&',instruction,0,824 |
| ```s.rfind('&')```,output,1,824 |
| cut a string using delimiter '&',instruction,0,825 |
| ```s[:s.rfind('&')]```,output,1,825 |
| find a tag `option` whose `value` attribute is `state` in selenium,instruction,0,826 |
| "```driver.find_element_by_xpath(""//option[@value='"" + state + ""']"").click()```",output,1,826 |
| "append line ""appended text"" to file ""test.txt""",instruction,0,827 |
| "```with open('test.txt', 'a') as myfile: |
| myfile.write('appended text')```",output,1,827 |
| "append line ""cool beans..."" to file ""foo""",instruction,0,828 |
| "```with open('foo', 'a') as f: |
| f.write('cool beans...')```",output,1,828 |
| append to file 'test1' content 'koko',instruction,0,829 |
| "```with open('test1', 'ab') as f: |
| pass```",output,1,829 |
| append to file 'test' content 'koko',instruction,0,830 |
| "```open('test', 'a+b').write('koko')```",output,1,830 |
| split string 'x+13.5*10x-4e1' into tokens,instruction,0,831 |
| "```print([i for i in re.split('([\\d.]+|\\W+)', 'x+13.5*10x-4e1') if i])```",output,1,831 |
| Find all Chinese characters in string `ipath`,instruction,0,832 |
| "```re.findall('[\u4e00-\u9fff]+', ipath)```",output,1,832 |
| split string `s` by letter 's',instruction,0,833 |
| ```s.split('s')```,output,1,833 |
| run shell command 'rm -r some.file' in the background,instruction,0,834 |
| "```subprocess.Popen(['rm', '-r', 'some.file'])```",output,1,834 |
| convert a list of dictionaries `listofdict into a dictionary of dictionaries,instruction,0,835 |
| "```dict((d['name'], d) for d in listofdict)```",output,1,835 |
| print current date and time in a regular format,instruction,0,836 |
| ```datetime.datetime.now().strftime('%Y-%m-%d %H:%M')```,output,1,836 |
| print current date and time in a regular format,instruction,0,837 |
| ```time.strftime('%Y-%m-%d %H:%M')```,output,1,837 |
| find consecutive consonants in a word `CONCENTRATION` using regex,instruction,0,838 |
| "```re.findall('[bcdfghjklmnpqrstvwxyz]+', 'CONCERTATION', re.IGNORECASE)```",output,1,838 |
| get a list of indices of non zero elements in a list `a`,instruction,0,839 |
| "```[i for i, e in enumerate(a) if e != 0]```",output,1,839 |
| get multiple integer values from a string 'string1',instruction,0,840 |
| "```map(int, re.findall('\\d+', string1))```",output,1,840 |
| get the path of Python executable under windows,instruction,0,841 |
| ```os.path.dirname(sys.executable)```,output,1,841 |
| move an x-axis label to the top of a plot `ax` in matplotlib,instruction,0,842 |
| ```ax.xaxis.set_label_position('top')```,output,1,842 |
| move x-axis to the top of a plot `ax`,instruction,0,843 |
| ```ax.xaxis.tick_top()```,output,1,843 |
| Move x-axis of the pyplot object `ax` to the top of a plot in matplotlib,instruction,0,844 |
| ```ax.xaxis.set_ticks_position('top')```,output,1,844 |
| parse string '2015/01/01 12:12am' to DateTime object using format '%Y/%m/%d %I:%M%p',instruction,0,845 |
| "```datetime.strptime('2015/01/01 12:12am', '%Y/%m/%d %I:%M%p')```",output,1,845 |
| Open image 'picture.jpg',instruction,0,846 |
| "```img = Image.open('picture.jpg') |
| img.show()```",output,1,846 |
| "Open image ""picture.jpg""",instruction,0,847 |
| "```img = Image.open('picture.jpg') |
| Img.show```",output,1,847 |
| terminate the script using status value 0,instruction,0,848 |
| ```sys.exit(0)```,output,1,848 |
| abort the execution of the script using message 'aa! errors!',instruction,0,849 |
| ```sys.exit('aa! errors!')```,output,1,849 |
| abort the execution of a python script,instruction,0,850 |
| ```sys.exit()```,output,1,850 |
| find maximum with lookahead = 4 in a list `arr`,instruction,0,851 |
| "```[max(abs(x) for x in arr[i:i + 4]) for i in range(0, len(arr), 4)]```",output,1,851 |
| set the current working directory to 'c:\\Users\\uname\\desktop\\python',instruction,0,852 |
| ```os.chdir('c:\\Users\\uname\\desktop\\python')```,output,1,852 |
| set the current working directory to path `path`,instruction,0,853 |
| ```os.chdir(path)```,output,1,853 |
| get a list `no_integers` of all the items in list `mylist` that are not of type `int`,instruction,0,854 |
| "```no_integers = [x for x in mylist if not isinstance(x, int)]```",output,1,854 |
| match contents of an element to 'Example' in xpath (lxml),instruction,0,855 |
| "```tree.xpath("".//a[text()='Example']"")[0].tag```",output,1,855 |
| "concatenate key/value pairs in dictionary `a` with string ', ' into a single string",instruction,0,856 |
| "```"""""", """""".join([(str(k) + ' ' + str(v)) for k, v in list(a.items())])```",output,1,856 |
| "Strip all non-ASCII characters from a unicode string, `\xa3\u20ac\xa3\u20ac`",instruction,0,857 |
| "```print(set(re.sub('[\x00-\x7f]', '', '\xa3\u20ac\xa3\u20ac')))```",output,1,857 |
| Get all non-ascii characters in a unicode string `\xa3100 is worth more than \u20ac100`,instruction,0,858 |
| "```print(re.sub('[\x00-\x7f]', '', '\xa3100 is worth more than \u20ac100'))```",output,1,858 |
| "build a dict of key:value pairs from a string representation of a dict, `{'muffin' : 'lolz', 'foo' : 'kitty'}`",instruction,0,859 |
| "```ast.literal_eval(""{'muffin' : 'lolz', 'foo' : 'kitty'}"")```",output,1,859 |
| Print string `t` with proper unicode representations,instruction,0,860 |
| ```print(t.decode('unicode_escape'))```,output,1,860 |
| Normalize string `str` from 'cp1252' code to 'utf-8' code,instruction,0,861 |
| ```print(str.encode('cp1252').decode('utf-8').encode('cp1252').decode('utf-8'))```,output,1,861 |
| merge lists `list_a` and `list_b` into a list of tuples,instruction,0,862 |
| "```zip(list_a, list_b)```",output,1,862 |
| merge lists `a` and `a` into a list of tuples,instruction,0,863 |
| "```list(zip(a, b))```",output,1,863 |
| convert pandas DataFrame `df` to a dictionary using `id` field as the key,instruction,0,864 |
| ```df.set_index('id').to_dict()```,output,1,864 |
| "convert pandas dataframe `df` with fields 'id', 'value' to dictionary",instruction,0,865 |
| ```df.set_index('id')['value'].to_dict()```,output,1,865 |
| ,instruction,0,866 |
| "```sorted(list(mydict.items()), key=lambda a: map(int, a[0].split('.')))```",output,1,866 |
| remove parentheses and text within it in string `filename`,instruction,0,867 |
| "```re.sub('\\([^)]*\\)', '', filename)```",output,1,867 |
| Check if string 'a b' only contains letters and spaces,instruction,0,868 |
| "```""""""a b"""""".replace(' ', '').isalpha()```",output,1,868 |
| sum each element `x` in list `first` with element `y` at the same index in list `second`.,instruction,0,869 |
| "```[(x + y) for x, y in zip(first, second)]```",output,1,869 |
| sort a python dictionary `a_dict` by element `1` of the value,instruction,0,870 |
| "```sorted(list(a_dict.items()), key=lambda item: item[1][1])```",output,1,870 |
| ,instruction,0,871 |
| ```re.compile('[^a-zA-Z0-9-]+')```,output,1,871 |
| get index of the biggest 2 values of a list `a`,instruction,0,872 |
| "```sorted(list(range(len(a))), key=lambda i: a[i])[-2:]```",output,1,872 |
| get indexes of the largest `2` values from a list `a` using itemgetter,instruction,0,873 |
| "```zip(*sorted(enumerate(a), key=operator.itemgetter(1)))[0][-2:]```",output,1,873 |
| get the indexes of the largest `2` values from a list of integers `a`,instruction,0,874 |
| "```sorted(list(range(len(a))), key=lambda i: a[i], reverse=True)[:2]```",output,1,874 |
| get index of key 'c' in dictionary `x`,instruction,0,875 |
| ```list(x.keys()).index('c')```,output,1,875 |
| Print +1 using format '{0:+d}',instruction,0,876 |
| ```print('{0:+d}'.format(score))```,output,1,876 |
| "remove adjacent duplicate elements from a list `[1, 2, 2, 3, 2, 2, 4]`",instruction,0,877 |
| "```[k for k, g in itertools.groupby([1, 2, 2, 3, 2, 2, 4])]```",output,1,877 |
| "split string ""0,1,2"" based on delimiter ','",instruction,0,878 |
| "```""""""0,1,2"""""".split(',')```",output,1,878 |
| "convert the string '0,1,2' to a list of integers",instruction,0,879 |
| "```[int(x) for x in '0,1,2'.split(',')]```",output,1,879 |
| "convert list of key-value tuples `[('A', 1), ('B', 2), ('C', 3)]` into dictionary",instruction,0,880 |
| "```dict([('A', 1), ('B', 2), ('C', 3)])```",output,1,880 |
| save numpy array `x` into text file 'test.txt',instruction,0,881 |
| "```np.savetxt('test.txt', x)```",output,1,881 |
| store the output of command 'ls' in variable `direct_output`,instruction,0,882 |
| "```direct_output = subprocess.check_output('ls', shell=True)```",output,1,882 |
| get all column name of dataframe `df` except for column 'T1_V6',instruction,0,883 |
| ```df[df.columns - ['T1_V6']]```,output,1,883 |
| get count of values in numpy array `a` that are between values `25` and `100`,instruction,0,884 |
| ```((25 < a) & (a < 100)).sum()```,output,1,884 |
| Get day name from a datetime object,instruction,0,885 |
| ```date.today().strftime('%A')```,output,1,885 |
| ,instruction,0,886 |
| "```re.search('\\bis\\b', your_string)```",output,1,886 |
| Jinja parse datetime object `car.date_of_manufacture` to use format pattern `datetime`,instruction,0,887 |
| ```{{car.date_of_manufacture | datetime}}```,output,1,887 |
| Get the date object `date_of_manufacture` of object `car` in string format '%Y-%m-%d',instruction,0,888 |
| ```{{car.date_of_manufacture.strftime('%Y-%m-%d')}}```,output,1,888 |
| make a flat list from list of lists `sublist`,instruction,0,889 |
| ```[item for sublist in l for item in sublist]```,output,1,889 |
| make a flat list from list of lists `list2d`,instruction,0,890 |
| ```list(itertools.chain(*list2d))```,output,1,890 |
| make a flat list from list of lists `list2d`,instruction,0,891 |
| ```list(itertools.chain.from_iterable(list2d))```,output,1,891 |
| convert ascii value 'a' to int,instruction,0,892 |
| ```ord('a')```,output,1,892 |
| replace white spaces in string ' a\n b\n c\nd e' with empty string '',instruction,0,893 |
| "```re.sub('(?m)^[^\\S\\n]+', '', ' a\n b\n c\nd e')```",output,1,893 |
| remove white spaces from all the lines using a regular expression in string 'a\n b\n c',instruction,0,894 |
| "```re.sub('(?m)^\\s+', '', 'a\n b\n c')```",output,1,894 |
| "destruct elements of list `[1, 2, 3]` to variables `a`, `b` and `c`",instruction,0,895 |
| "```a, b, c = [1, 2, 3]```",output,1,895 |
| split list `mylist` into a list of lists whose elements have the same first five characters,instruction,0,896 |
| "```[list(v) for k, v in itertools.groupby(mylist, key=lambda x: x[:5])]```",output,1,896 |
| remove all instances of parenthesesis containing text beginning with `as ` from string `line`,instruction,0,897 |
| "```line = re.sub('\\(+as .*?\\) ', '', line)```",output,1,897 |
| skip the newline while printing `line`,instruction,0,898 |
| ```print(line.rstrip('\n'))```,output,1,898 |
| get index values of pandas dataframe `df` as list,instruction,0,899 |
| ```df.index.values.tolist()```,output,1,899 |
| check if list `a` is empty,instruction,0,900 |
| "```if (not a): |
| pass```",output,1,900 |
| check if list `seq` is empty,instruction,0,901 |
| "```if (not seq): |
| pass```",output,1,901 |
| check if list `li` is empty,instruction,0,902 |
| "```if (len(li) == 0): |
| pass```",output,1,902 |
| create a list containing the indices of elements greater than 4 in list `a`,instruction,0,903 |
| "```[i for i, v in enumerate(a) if v > 4]```",output,1,903 |
| reverse list `yourdata`,instruction,0,904 |
| "```sorted(yourdata, reverse=True)```",output,1,904 |
| sort list of nested dictionaries `yourdata` in reverse based on values associated with each dictionary's key 'subkey',instruction,0,905 |
| "```sorted(yourdata, key=lambda d: d.get('key', {}).get('subkey'), reverse=True)```",output,1,905 |
| sort list of nested dictionaries `yourdata` in reverse order of 'key' and 'subkey',instruction,0,906 |
| "```yourdata.sort(key=lambda e: e['key']['subkey'], reverse=True)```",output,1,906 |
| remove decimal points in pandas data frame using round,instruction,0,907 |
| ```df.round()```,output,1,907 |
| Get data from matplotlib plot,instruction,0,908 |
| ```gca().get_lines()[n].get_xydata()```,output,1,908 |
| get the maximum 2 values per row in array `A`,instruction,0,909 |
| "```A[:, -2:]```",output,1,909 |
| "Get value for ""username"" parameter in GET request in Django",instruction,0,910 |
| "```request.GET.get('username', '')```",output,1,910 |
| pretty-print ordered dictionary `o`,instruction,0,911 |
| ```pprint(dict(list(o.items())))```,output,1,911 |
| Confirm urls in Django properly,instruction,0,912 |
| "```url('^$', include('sms.urls')),```",output,1,912 |
| Configure url in django properly,instruction,0,913 |
| "```url('^', include('sms.urls')),```",output,1,913 |
| get the tuple in list `a_list` that has the largest item in the second index,instruction,0,914 |
| "```max_item = max(a_list, key=operator.itemgetter(1))```",output,1,914 |
| find tuple in list of tuples `a_list` with the largest second element,instruction,0,915 |
| "```max(a_list, key=operator.itemgetter(1))```",output,1,915 |
| resample series `s` into 3 months bins and sum each bin,instruction,0,916 |
| "```s.resample('3M', how='sum')```",output,1,916 |
| "extract elements at indices (1, 2, 5) from a list `a`",instruction,0,917 |
| "```[a[i] for i in (1, 2, 5)]```",output,1,917 |
| filter lines from a text file 'textfile' which contain a word 'apple',instruction,0,918 |
| ```[line for line in open('textfile') if 'apple' in line]```,output,1,918 |
| convert a date string `s` to a datetime object,instruction,0,919 |
| "```datetime.datetime.strptime(s, '%Y-%m-%dT%H:%M:%SZ')```",output,1,919 |
| reading tab-delimited csv file `filename` with pandas on mac,instruction,0,920 |
| "```pandas.read_csv(filename, sep='\t', lineterminator='\r')```",output,1,920 |
| replace only first occurence of string `TEST` from a string `longlongTESTstringTEST`,instruction,0,921 |
| "```'longlongTESTstringTEST'.replace('TEST', '?', 1)```",output,1,921 |
| zip file `pdffile` using its basename as directory name,instruction,0,922 |
| "```archive.write(pdffile, os.path.basename(pdffile))```",output,1,922 |
| create a dictionary of pairs from a list of tuples `myListOfTuples`,instruction,0,923 |
| ```dict(x[1:] for x in reversed(myListOfTuples))```,output,1,923 |
| subtract elements of list `List1` from elements of list `List2`,instruction,0,924 |
| "```[(x1 - x2) for x1, x2 in zip(List1, List2)]```",output,1,924 |
| check if string `string` starts with a number,instruction,0,925 |
| ```string[0].isdigit()```,output,1,925 |
| "Check if string `strg` starts with any of the elements in list ('0', '1', '2', '3', '4', '5', '6', '7', '8', '9')",instruction,0,926 |
| "```strg.startswith(('0', '1', '2', '3', '4', '5', '6', '7', '8', '9'))```",output,1,926 |
| print script's directory,instruction,0,927 |
| ```print(os.path.dirname(os.path.realpath(__file__)))```,output,1,927 |
| "split string `text` by the occurrences of regex pattern '(?<=\\?|!|\\.)\\s{0,2}(?=[A-Z]|$)'",instruction,0,928 |
| "```re.split('(?<=\\?|!|\\.)\\s{0,2}(?=[A-Z]|$)', text)```",output,1,928 |
| Make a scatter plot using unpacked values of list `li`,instruction,0,929 |
| ```plt.scatter(*zip(*li))```,output,1,929 |
| rearrange tuple of tuples `t`,instruction,0,930 |
| ```tuple(zip(*t))```,output,1,930 |
| Get average for every three columns in `df` dataframe,instruction,0,931 |
| "```df.groupby(np.arange(len(df.columns)) |
| convert a list `L` of ascii values to a string,instruction,0,932 |
| "```"""""""""""".join(chr(i) for i in L)```",output,1,932 |
| count the number of pairs in dictionary `d` whose value equal to `chosen_value`,instruction,0,933 |
| ```sum(x == chosen_value for x in list(d.values()))```,output,1,933 |
| count the number of values in `d` dictionary that are predicate to function `some_condition`,instruction,0,934 |
| ```sum(1 for x in list(d.values()) if some_condition(x))```,output,1,934 |
| convert double 0.00582811585976 to float,instruction,0,935 |
| "```struct.unpack('f', struct.pack('f', 0.00582811585976))```",output,1,935 |
| convert datetime.date `dt` to utc timestamp,instruction,0,936 |
| "```timestamp = (dt - datetime(1970, 1, 1)).total_seconds()```",output,1,936 |
| sort column `m` in panda dataframe `df`,instruction,0,937 |
| ```df.sort('m')```,output,1,937 |
| Sort a data `a` in descending order based on the `modified` attribute of elements using lambda function,instruction,0,938 |
| "```a = sorted(a, key=lambda x: x.modified, reverse=True)```",output,1,938 |
| print the truth value of `a`,instruction,0,939 |
| ```print(bool(a))```,output,1,939 |
| rename `last` row index label in dataframe `df` to `a`,instruction,0,940 |
| ```df = df.rename(index={last: 'a'})```,output,1,940 |
| Fit Kmeans function to a one-dimensional array `x` by reshaping it to be a multidimensional array of single values,instruction,0,941 |
| "```km.fit(x.reshape(-1, 1))```",output,1,941 |
| Sort a list of strings 'words' such that items starting with 's' come first.,instruction,0,942 |
| "```sorted(words, key=lambda x: 'a' + x if x.startswith('s') else 'b' + x)```",output,1,942 |
| open the login site 'http://somesite.com/adminpanel/index.php' in the browser,instruction,0,943 |
| ```webbrowser.open('http://somesite.com/adminpanel/index.php')```,output,1,943 |
| "fetch all elements in a dictionary `parent_dict`, falling between two keys 2 and 4",instruction,0,944 |
| "```dict((k, v) for k, v in parent_dict.items() if 2 < k < 4)```",output,1,944 |
| fetch all elements in a dictionary 'parent_dict' where the key is between the range of 2 to 4,instruction,0,945 |
| "```dict((k, v) for k, v in parent_dict.items() if k > 2 and k < 4)```",output,1,945 |
| sort two lists `list1` and `list2` together using lambda function,instruction,0,946 |
| "```[list(x) for x in zip(*sorted(zip(list1, list2), key=lambda pair: pair[0]))]```",output,1,946 |
| get the number of values in list `j` that is greater than 5,instruction,0,947 |
| ```sum(((i > 5) for i in j))```,output,1,947 |
| get the number of values in list `j` that is greater than 5,instruction,0,948 |
| ```len([1 for i in j if (i > 5)])```,output,1,948 |
| get the number of values in list `j` that is greater than `i`,instruction,0,949 |
| "```j = np.array(j) |
| sum((j > i))```",output,1,949 |
| "zip list `a`, `b`, `c` into a list of tuples",instruction,0,950 |
| "```[(x + tuple(y)) for x, y in zip(zip(a, b), c)]```",output,1,950 |
| changing permission of file `path` to `stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH`,instruction,0,951 |
| "```os.chmod(path, stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH)```",output,1,951 |
| argparse associate zero or more arguments with flag 'file',instruction,0,952 |
| "```parser.add_argument('file', nargs='*')```",output,1,952 |
| get a list of booleans `z` that shows wether the corresponding items in list `x` and `y` are equal,instruction,0,953 |
| "```z = [(i == j) for i, j in zip(x, y)]```",output,1,953 |
| create a list which indicates whether each element in `x` and `y` is identical,instruction,0,954 |
| ```[(x[i] == y[i]) for i in range(len(x))]```,output,1,954 |
| ,instruction,0,955 |
| "```[int(s) for s in re.findall('\\b\\d+\\b', ""he33llo 42 I'm a 32 string 30"")]```",output,1,955 |
| create an empty data frame `df2` with index from another data frame `df1`,instruction,0,956 |
| ```df2 = pd.DataFrame(index=df1.index)```,output,1,956 |
| unpack first and second bytes of byte string `pS` into integer,instruction,0,957 |
| "```struct.unpack('h', pS[0:2])```",output,1,957 |
| print list `t` into a table-like shape,instruction,0,958 |
| "```print('\n'.join(' '.join(map(str, row)) for row in t))```",output,1,958 |
| ,instruction,0,959 |
| ```df.sort_values(by='Date')```,output,1,959 |
| check if a checkbox is checked in selenium python webdriver,instruction,0,960 |
| ```driver.find_element_by_name('<check_box_name>').is_selected()```,output,1,960 |
| determine if checkbox with id '<check_box_id>' is checked in selenium python webdriver,instruction,0,961 |
| ```driver.find_element_by_id('<check_box_id>').is_selected()```,output,1,961 |
| "replace `0` with `2` in the list `[0, 1, 0, 3]`",instruction,0,962 |
| "```[(a if a else 2) for a in [0, 1, 0, 3]]```",output,1,962 |
| Produce a string that is suitable as Unicode literal from string 'M\\N{AMPERSAND}M\\N{APOSTROPHE}s',instruction,0,963 |
| ```'M\\N{AMPERSAND}M\\N{APOSTROPHE}s'.encode().decode('unicode-escape')```,output,1,963 |
| Parse a unicode string `M\\N{AMPERSAND}M\\N{APOSTROPHE}s`,instruction,0,964 |
| ```'M\\N{AMPERSAND}M\\N{APOSTROPHE}s'.decode('unicode-escape')```,output,1,964 |
| convert Unicode codepoint to utf8 hex,instruction,0,965 |
| "```chr(int('fd9b', 16)).encode('utf-8')```",output,1,965 |
| use upper case letters to print hex value `value`,instruction,0,966 |
| ```print('0x%X' % value)```,output,1,966 |
| get a list `cleaned` that contains all non-empty elements in list `your_list`,instruction,0,967 |
| ```cleaned = [x for x in your_list if x]```,output,1,967 |
| create a slice object using string `string_slice`,instruction,0,968 |
| ```slice(*[(int(i.strip()) if i else None) for i in string_slice.split(':')])```,output,1,968 |
| Find all the tags `a` and `div` from Beautiful Soup object `soup`,instruction,0,969 |
| "```soup.find_all(['a', 'div'])```",output,1,969 |
| get the name of function `func` as a string,instruction,0,970 |
| ```print(func.__name__)```,output,1,970 |
| convert dictionary `adict` into string,instruction,0,971 |
| "```"""""""""""".join('{}{}'.format(key, val) for key, val in sorted(adict.items()))```",output,1,971 |
| convert dictionary `adict` into string,instruction,0,972 |
| "```"""""""""""".join('{}{}'.format(key, val) for key, val in list(adict.items()))```",output,1,972 |
| copy list `old_list` as `new_list`,instruction,0,973 |
| ```new_list = old_list[:]```,output,1,973 |
| copy list `old_list` as `new_list`,instruction,0,974 |
| ```new_list = list(old_list)```,output,1,974 |
| copy list `old_list` as `new_list`,instruction,0,975 |
| ```new_list = copy.copy(old_list)```,output,1,975 |
| deep copy list `old_list` as `new_list`,instruction,0,976 |
| ```new_list = copy.deepcopy(old_list)```,output,1,976 |
| make a copy of list `old_list`,instruction,0,977 |
| ```[i for i in old_list]```,output,1,977 |
| remove frame of legend in plot `plt`,instruction,0,978 |
| ```plt.legend(frameon=False)```,output,1,978 |
| Print a emoji from a string `\\ud83d\\ude4f` having surrogate pairs,instruction,0,979 |
| "```""""""\\ud83d\\ude4f"""""".encode('utf-16', 'surrogatepass').decode('utf-16')```",output,1,979 |
| calling a function named 'myfunction' in the module,instruction,0,980 |
| ```globals()['myfunction']()```,output,1,980 |
| "Check the status code of url ""http://www.stackoverflow.com""",instruction,0,981 |
| ```urllib.request.urlopen('http://www.stackoverflow.com').getcode()```,output,1,981 |
| "Check the status code of url ""www.python.org""",instruction,0,982 |
| "```conn = httplib.HTTPConnection('www.python.org') |
| conn.request('HEAD', '/') |
| r1 = conn.getresponse() |
| print(r1.status, r1.reason)```",output,1,982 |
| Check the status code of url `url`,instruction,0,983 |
| "```r = requests.head(url) |
| return (r.status_code == 200)```",output,1,983 |
| "Checking if website ""http://www.stackoverflow.com"" is up",instruction,0,984 |
| ```print(urllib.request.urlopen('http://www.stackoverflow.com').getcode())```,output,1,984 |
| "Selenium `driver` click a hyperlink with the pattern ""a[href^='javascript']""",instruction,0,985 |
| "```driver.find_element_by_css_selector(""a[href^='javascript']"").click()```",output,1,985 |
| "store data frame `df` to file `file_name` using pandas, python",instruction,0,986 |
| ```df.to_pickle(file_name)```,output,1,986 |
| calculate the mean of columns with same name in dataframe `df`,instruction,0,987 |
| "```df.groupby(by=df.columns, axis=1).mean()```",output,1,987 |
| sort list `bar` by each element's attribute `attrb1` and attribute `attrb2` in reverse order,instruction,0,988 |
| "```bar.sort(key=lambda x: (x.attrb1, x.attrb2), reverse=True)```",output,1,988 |
| get alpha value `alpha` of a png image `img`,instruction,0,989 |
| ```alpha = img.split()[-1]```,output,1,989 |
| ,instruction,0,990 |
| ```[len(x) for x in s.split()]```,output,1,990 |
| BeautifulSoup find tag 'div' with styling 'width=300px;' in HTML string `soup`,instruction,0,991 |
| "```soup.findAll('div', style='width=300px;')```",output,1,991 |
| Execute SQL statement `sql` with values of dictionary `myDict` as parameters,instruction,0,992 |
| "```cursor.execute(sql, list(myDict.values()))```",output,1,992 |
| Convert CSV file `Result.csv` to Pandas dataframe using separator ' ',instruction,0,993 |
| "```df.to_csv('Result.csv', index=False, sep=' ')```",output,1,993 |
| update the `globals()` dictionary with the contents of the `vars(args)` dictionary,instruction,0,994 |
| ```globals().update(vars(args))```,output,1,994 |
| find all substrings in `mystring` beginning and ending with square brackets,instruction,0,995 |
| "```re.findall('\\[(.*?)\\]', mystring)```",output,1,995 |
| "Format all floating variables `var1`, `var2`, `var3`, `var1` to print to two decimal places.",instruction,0,996 |
| "```print('%.2f kg = %.2f lb = %.2f gal = %.2f l' % (var1, var2, var3, var4))```",output,1,996 |
| Remove all items from a dictionary `d` where the values are less than `1`,instruction,0,997 |
| "```d = dict((k, v) for k, v in d.items() if v > 0)```",output,1,997 |
| Filter dictionary `d` to have items with value greater than 0,instruction,0,998 |
| "```d = {k: v for k, v in list(d.items()) if v > 0}```",output,1,998 |
| convert a string of date strings `date_stngs ` to datetime objects and put them in a dataframe,instruction,0,999 |
| ```pd.to_datetime(pd.Series(date_stngs))```,output,1,999 |
| "get value at index `[2, 0]` in dataframe `df`",instruction,0,1000 |
| "```df.iloc[2, 0]```",output,1,1000 |
| change the font size on plot `matplotlib` to 22,instruction,0,1001 |
| ```matplotlib.rcParams.update({'font.size': 22})```,output,1,1001 |
| converting dictionary `d` into a dataframe `pd` with keys as data for column 'Date' and the corresponding values as data for column 'DateValue',instruction,0,1002 |
| "```pd.DataFrame(list(d.items()), columns=['Date', 'DateValue'])```",output,1,1002 |
| create a dataframe containing the multiplication of element-wise in dataframe `df` and dataframe `df2` using index name and column labels of dataframe `df`,instruction,0,1003 |
| "```pd.DataFrame(df.values * df2.values, columns=df.columns, index=df.index)```",output,1,1003 |
| extract floating number from string 'Current Level: 13.4 db.',instruction,0,1004 |
| "```re.findall('\\d+\\.\\d+', 'Current Level: 13.4 db.')```",output,1,1004 |
| extract floating point numbers from a string 'Current Level: -13.2 db or 14.2 or 3',instruction,0,1005 |
| "```re.findall('[-+]?\\d*\\.\\d+|\\d+', 'Current Level: -13.2 db or 14.2 or 3')```",output,1,1005 |
| pair each element in list `it` 3 times into a tuple,instruction,0,1006 |
| "```zip(it, it, it)```",output,1,1006 |
| lowercase a python dataframe string in column 'x' if it has missing values in dataframe `df`,instruction,0,1007 |
| ```df['x'].str.lower()```,output,1,1007 |
| "append dict `{'f': var6, 'g': var7, 'h': var8}` to value of key `e` in dict `jsobj['a']['b']`",instruction,0,1008 |
| "```jsobj['a']['b']['e'].append({'f': var6, 'g': var7, 'h': var8})```",output,1,1008 |
| Concat a list of strings `lst` using string formatting,instruction,0,1009 |
| "```"""""""""""".join(lst)```",output,1,1009 |
| sum values greater than 0 in dictionary `d`,instruction,0,1010 |
| ```sum(v for v in list(d.values()) if v > 0)```,output,1,1010 |
| run flask application `app` in debug mode.,instruction,0,1011 |
| ```app.run(debug=True)```,output,1,1011 |
| "drop rows whose index value in list `[1, 3]` in dataframe `df`",instruction,0,1012 |
| "```df.drop(df.index[[1, 3]], inplace=True)```",output,1,1012 |
| replace nan values in a pandas data frame with the average of columns,instruction,0,1013 |
| "```df.apply(lambda x: x.fillna(x.mean()), axis=0)```",output,1,1013 |
| extract attribute `my_attr` from each object in list `my_list`,instruction,0,1014 |
| ```[o.my_attr for o in my_list]```,output,1,1014 |
| python get time stamp on file `file` in '%m/%d/%Y' format,instruction,0,1015 |
| "```time.strftime('%m/%d/%Y', time.gmtime(os.path.getmtime(file)))```",output,1,1015 |
| check if dictionary `subset` is a subset of dictionary `superset`,instruction,0,1016 |
| ```all(item in list(superset.items()) for item in list(subset.items()))```,output,1,1016 |
| Convert integer elements in list `wordids` to strings,instruction,0,1017 |
| ```[str(wi) for wi in wordids]```,output,1,1017 |
| Reset the indexes of a pandas data frame,instruction,0,1018 |
| ```df2 = df.reset_index()```,output,1,1018 |
| format datetime in `dt` as string in format `'%m/%d/%Y`,instruction,0,1019 |
| ```dt.strftime('%m/%d/%Y')```,output,1,1019 |
| format floating point number `TotalAmount` to be rounded off to two decimal places and have a comma thousands' seperator,instruction,0,1020 |
| "```print('Total cost is: ${:,.2f}'.format(TotalAmount))```",output,1,1020 |
| sum the values in each row of every two adjacent columns in dataframe `df`,instruction,0,1021 |
| "```df.groupby(np.arange(len(df.columns)) // 2 + 1, axis=1).sum().add_prefix('s')```",output,1,1021 |
| create list `randomList` with 10 random floating point numbers between 0.0 and 1.0,instruction,0,1022 |
| ```randomList = [random.random() for _ in range(10)]```,output,1,1022 |
| find href value that has string 'follow?page' inside it,instruction,0,1023 |
| "```print(soup.find('a', href=re.compile('.*follow\\?page.*')))```",output,1,1023 |
| immediately see output of print statement that doesn't end in a newline,instruction,0,1024 |
| ```sys.stdout.flush()```,output,1,1024 |
| get a random key `country` and value `capital` form a dictionary `d`,instruction,0,1025 |
| "```country, capital = random.choice(list(d.items()))```",output,1,1025 |
| split string `Word to Split` into a list of characters,instruction,0,1026 |
| ```list('Word to Split')```,output,1,1026 |
| Create a list containing words that contain vowel letter followed by the same vowel in file 'file.text',instruction,0,1027 |
| "```[w for w in open('file.txt') if not re.search('[aeiou]{2}', w)]```",output,1,1027 |
| Validate IP address using Regex,instruction,0,1028 |
| "```pat = re.compile('^\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}$')```",output,1,1028 |
| execute file 'filename.py',instruction,0,1029 |
| "```exec(compile(open('filename.py').read(), 'filename.py', 'exec'))```",output,1,1029 |
| SQLAlchemy count the number of rows with distinct values in column `name` of table `Tag`,instruction,0,1030 |
| ```session.query(Tag).distinct(Tag.name).group_by(Tag.name).count()```,output,1,1030 |
| remove null columns in a dataframe `df`,instruction,0,1031 |
| "```df = df.dropna(axis=1, how='all')```",output,1,1031 |
| check if all lists in list `L` have three elements of integer 1,instruction,0,1032 |
| ```all(x.count(1) == 3 for x in L)```,output,1,1032 |
| Get a list comparing two lists of tuples `l1` and `l2` if any first value in `l1` matches with first value in `l2`,instruction,0,1033 |
| ```[x[0] for x in l1 if any(x[0] == y[0] for y in l2)]```,output,1,1033 |
| clear the textbox `text` in tkinter,instruction,0,1034 |
| "```tex.delete('1.0', END)```",output,1,1034 |
| Convert long int `myNumber` into date and time represented in the the string format '%Y-%m-%d %H:%M:%S',instruction,0,1035 |
| ```datetime.datetime.fromtimestamp(myNumber).strftime('%Y-%m-%d %H:%M:%S')```,output,1,1035 |
| Spawn a process to run python script `myscript.py` in C++,instruction,0,1036 |
| ```system('python myscript.py')```,output,1,1036 |
| sort a list `your_list` of class objects by their values for the attribute `anniversary_score`,instruction,0,1037 |
| ```your_list.sort(key=operator.attrgetter('anniversary_score'))```,output,1,1037 |
| sort list `your_list` by the `anniversary_score` attribute of each object,instruction,0,1038 |
| ```your_list.sort(key=lambda x: x.anniversary_score)```,output,1,1038 |
| "convert a tensor with list of constants `[1, 2, 3]` into a numpy array in tensorflow",instruction,0,1039 |
| "```print(type(tf.Session().run(tf.constant([1, 2, 3]))))```",output,1,1039 |
| convert list `a` from being consecutive sequences of tuples into a single sequence of elements,instruction,0,1040 |
| ```list(itertools.chain(*a))```,output,1,1040 |
| Set value for key `a` in dict `count` to `0` if key `a` does not exist or if value is `none`,instruction,0,1041 |
| "```count.setdefault('a', 0)```",output,1,1041 |
| Do group by on `cluster` column in `df` and get its mean,instruction,0,1042 |
| ```df.groupby(['cluster']).mean()```,output,1,1042 |
| get number in list `myList` closest in value to number `myNumber`,instruction,0,1043 |
| "```min(myList, key=lambda x: abs(x - myNumber))```",output,1,1043 |
| check if any of the items in `search` appear in `string`,instruction,0,1044 |
| ```any(x in string for x in search)```,output,1,1044 |
| search for occurrences of regex pattern `pattern` in string `url`,instruction,0,1045 |
| ```print(pattern.search(url).group(1))```,output,1,1045 |
| factorize all string values in dataframe `s` into floats,instruction,0,1046 |
| ```(s.factorize()[0] + 1).astype('float')```,output,1,1046 |
| Get a list `C` by subtracting values in one list `B` from corresponding values in another list `A`,instruction,0,1047 |
| "```C = [(a - b) for a, b in zip(A, B)]```",output,1,1047 |
| "derive the week start for the given week number and year ‘2011, 4, 0’",instruction,0,1048 |
| "```datetime.datetime.strptime('2011, 4, 0', '%Y, %U, %w')```",output,1,1048 |
| "convert a list of strings `['1', '-1', '1']` to a list of numbers",instruction,0,1049 |
| "```map(int, ['1', '-1', '1'])```",output,1,1049 |
| "create datetime object from ""16sep2012""",instruction,0,1050 |
| "```datetime.datetime.strptime('16Sep2012', '%d%b%Y')```",output,1,1050 |
| update fields in Django model `Book` with arguments in dictionary `d` where primary key is equal to `pk`,instruction,0,1051 |
| ```Book.objects.filter(pk=pk).update(**d)```,output,1,1051 |
| update the fields in django model `Book` using dictionary `d`,instruction,0,1052 |
| ```Book.objects.create(**d)```,output,1,1052 |
| print a digit `your_number` with exactly 2 digits after decimal,instruction,0,1053 |
| ```print('{0:.2f}'.format(your_number))```,output,1,1053 |
| generate a 12-digit random number,instruction,0,1054 |
| "```random.randint(100000000000, 999999999999)```",output,1,1054 |
| generate a random 12-digit number,instruction,0,1055 |
| "```int(''.join(str(random.randint(0, 9)) for _ in range(12)))```",output,1,1055 |
| generate a random 12-digit number,instruction,0,1056 |
| "```"""""""""""".join(str(random.randint(0, 9)) for _ in range(12))```",output,1,1056 |
| generate a 12-digit random number,instruction,0,1057 |
| "```'%0.12d' % random.randint(0, 999999999999)```",output,1,1057 |
| remove specific elements in a numpy array `a`,instruction,0,1058 |
| "```numpy.delete(a, index)```",output,1,1058 |
| sort list `trial_list` based on values of dictionary `trail_dict`,instruction,0,1059 |
| "```sorted(trial_list, key=lambda x: trial_dict[x])```",output,1,1059 |
| read a single character from stdin,instruction,0,1060 |
| ```sys.stdin.read(1)```,output,1,1060 |
| get a list of characters in string `x` matching regex pattern `pattern`,instruction,0,1061 |
| "```print(re.findall(pattern, x))```",output,1,1061 |
| get the context of a search by keyword 'My keywords' in beautifulsoup `soup`,instruction,0,1062 |
| ```k = soup.find(text=re.compile('My keywords')).parent.text```,output,1,1062 |
| convert rows in pandas data frame `df` into list,instruction,0,1063 |
| "```df.apply(lambda x: x.tolist(), axis=1)```",output,1,1063 |
| convert a 1d `A` array to a 2d array `B`,instruction,0,1064 |
| "```B = np.reshape(A, (-1, 2))```",output,1,1064 |
| run app `app` on host '192.168.0.58' and port 9000 in Flask,instruction,0,1065 |
| "```app.run(host='192.168.0.58', port=9000, debug=False)```",output,1,1065 |
| encode unicode string '\xc5\xc4\xd6' to utf-8 code,instruction,0,1066 |
| ```print('\xc5\xc4\xd6'.encode('UTF8'))```,output,1,1066 |
| get the first element of each tuple from a list of tuples `G`,instruction,0,1067 |
| ```[x[0] for x in G]```,output,1,1067 |
| regular expression matching all but 'aa' and 'bb' for string `string`,instruction,0,1068 |
| "```re.findall('-(?!aa-|bb-)([^-]+)', string)```",output,1,1068 |
| regular expression matching all but 'aa' and 'bb',instruction,0,1069 |
| "```re.findall('-(?!aa|bb)([^-]+)', string)```",output,1,1069 |
| remove false entries from a dictionary `hand`,instruction,0,1070 |
| "```{k: v for k, v in list(hand.items()) if v}```",output,1,1070 |
| Get a dictionary from a dictionary `hand` where the values are present,instruction,0,1071 |
| "```dict((k, v) for k, v in hand.items() if v)```",output,1,1071 |
| sort list `L` based on the value of variable 'resultType' for each object in list `L`,instruction,0,1072 |
| "```sorted(L, key=operator.itemgetter('resultType'))```",output,1,1072 |
| sort a list of objects `s` by a member variable 'resultType',instruction,0,1073 |
| ```s.sort(key=operator.attrgetter('resultType'))```,output,1,1073 |
| sort a list of objects 'somelist' where the object has member number variable `resultType`,instruction,0,1074 |
| ```somelist.sort(key=lambda x: x.resultType)```,output,1,1074 |
| "join multiple dataframes `d1`, `d2`, and `d3` on column 'name'",instruction,0,1075 |
| "```df1.merge(df2, on='name').merge(df3, on='name')```",output,1,1075 |
| generate random Decimal,instruction,0,1076 |
| ```decimal.Decimal(random.randrange(10000)) / 100```,output,1,1076 |
| list all files of a directory `mypath`,instruction,0,1077 |
| "```onlyfiles = [f for f in listdir(mypath) if isfile(join(mypath, f))]```",output,1,1077 |
| list all files of a directory `mypath`,instruction,0,1078 |
| "```f = [] |
| for (dirpath, dirnames, filenames) in walk(mypath): |
| f.extend(filenames) |
| break```",output,1,1078 |
| "list all "".txt"" files of a directory ""/home/adam/""",instruction,0,1079 |
| ```print(glob.glob('/home/adam/*.txt'))```,output,1,1079 |
| "list all files of a directory ""somedirectory""",instruction,0,1080 |
| ```os.listdir('somedirectory')```,output,1,1080 |
| "execute sql query 'INSERT INTO table VALUES(%s,%s,%s,%s,%s,%s,%s,%s,%s)' with all parameters in list `tup`",instruction,0,1081 |
| "```cur.executemany('INSERT INTO table VALUES(%s,%s,%s,%s,%s,%s,%s,%s,%s)', tup)```",output,1,1081 |
| get keys with same value in dictionary `d`,instruction,0,1082 |
| ```print([key for key in d if d[key] == 1])```,output,1,1082 |
| get keys with same value in dictionary `d`,instruction,0,1083 |
| "```print([key for key, value in d.items() if value == 1])```",output,1,1083 |
| Get keys from a dictionary 'd' where the value is '1'.,instruction,0,1084 |
| "```print([key for key, value in list(d.items()) if value == 1])```",output,1,1084 |
| create list of 'size' empty strings,instruction,0,1085 |
| ```strs = ['' for x in range(size)]```,output,1,1085 |
| generate pdf file `output_filename` from markdown file `input_filename`,instruction,0,1086 |
| "```with open(input_filename, 'r') as f: |
| html_text = markdown(f.read(), output_format='html4') |
| pdfkit.from_string(html_text, output_filename)```",output,1,1086 |
| remove duplicate dict in list `l`,instruction,0,1087 |
| ```[dict(t) for t in set([tuple(d.items()) for d in l])]```,output,1,1087 |
| Set time zone `Europe/Istanbul` in Django,instruction,0,1088 |
| ```TIME_ZONE = 'Europe/Istanbul'```,output,1,1088 |
| "append `date` to list value of `key` in dictionary `dates_dict`, or create key `key` with value `date` in a list if it does not exist",instruction,0,1089 |
| "```dates_dict.setdefault(key, []).append(date)```",output,1,1089 |
| Group the values from django model `Article` with group by value `pub_date` and annotate by `title`,instruction,0,1090 |
| ```Article.objects.values('pub_date').annotate(article_count=Count('title'))```,output,1,1090 |
| clear Tkinter Canvas `canvas`,instruction,0,1091 |
| ```canvas.delete('all')```,output,1,1091 |
| "Initialize a pandas series object `s` with columns `['A', 'B', 'A1R', 'B2', 'AABB4']`",instruction,0,1092 |
| "```s = pd.Series(['A', 'B', 'A1R', 'B2', 'AABB4'])```",output,1,1092 |
| None,instruction,0,1093 |
| "```datetime.datetime.strptime('2007-03-04T21:08:12', '%Y-%m-%dT%H:%M:%S')```",output,1,1093 |
| sort list `a` using the first dimension of the element as the key to list `b`,instruction,0,1094 |
| ```a.sort(key=lambda x: b.index(x[0]))```,output,1,1094 |
| ,instruction,0,1095 |
| ```a.sort(key=lambda x_y: b.index(x_y[0]))```,output,1,1095 |
| Save plot `plt` as png file 'filename.png',instruction,0,1096 |
| ```plt.savefig('filename.png')```,output,1,1096 |
| Save matplotlib graph to image file `filename.png` at a resolution of `300 dpi`,instruction,0,1097 |
| "```plt.savefig('filename.png', dpi=300)```",output,1,1097 |
| get output from process `p1`,instruction,0,1098 |
| ```p1.communicate()[0]```,output,1,1098 |
| ,instruction,0,1099 |
| "```output = subprocess.Popen(['mycmd', 'myarg'], stdout=PIPE).communicate()[0]```",output,1,1099 |
| searche in HTML string for elements that have text 'Python',instruction,0,1100 |
| ```soup.body.findAll(text='Python')```,output,1,1100 |
| BeautifulSoup find string 'Python Jobs' in HTML body `body`,instruction,0,1101 |
| ```soup.body.findAll(text='Python Jobs')```,output,1,1101 |
| Sort items in dictionary `d` using the first part of the key after splitting the key,instruction,0,1102 |
| "```sorted(list(d.items()), key=lambda name_num: (name_num[0].rsplit(None, 1)[0], name_num[1]))```",output,1,1102 |
| "create a set that is the exclusive or of [1, 2, 3] and [3, 4, 5]",instruction,0,1103 |
| "```set([1, 2, 3]) ^ set([3, 4, 5])```",output,1,1103 |
| Get a list values of a dictionary item `pass_id` from post requests in django,instruction,0,1104 |
| ```request.POST.getlist('pass_id')```,output,1,1104 |
| Filter duplicate entries w.r.t. value in 'id' from a list of dictionaries 'L',instruction,0,1105 |
| "```list(dict((x['id'], x) for x in L).values())```",output,1,1105 |
| Get pandas GroupBy object with sum over the rows with same column names within dataframe `df`,instruction,0,1106 |
| "```df.groupby(df.columns, axis=1).sum()```",output,1,1106 |
| "convert the zip of range `(1, 5)` and range `(7, 11)` into a dictionary",instruction,0,1107 |
| "```dict(zip(list(range(1, 5)), list(range(7, 11))))```",output,1,1107 |
| Get all indexes of boolean numpy array where boolean value `mask` is True,instruction,0,1108 |
| ```numpy.where(mask)```,output,1,1108 |
| case insensitive comparison of strings `string1` and `string2`,instruction,0,1109 |
| "```if (string1.lower() == string2.lower()): |
| print('The strings are the same (case insensitive)') |
| else: |
| print('The strings are not the same (case insensitive)')```",output,1,1109 |
| case insensitive string comparison between `string1` and `string2`,instruction,0,1110 |
| "```if (string1.lower() == string2.lower()): |
| pass```",output,1,1110 |
| case insensitive string comparison between `string1` and `string2`,instruction,0,1111 |
| ```(string1.lower() == string2.lower())```,output,1,1111 |
| case insensitive string comparison between `first` and `second`,instruction,0,1112 |
| ```(first.lower() == second.lower())```,output,1,1112 |
| case insensitive comparison between strings `first` and `second`,instruction,0,1113 |
| ```(first.upper() == second.upper())```,output,1,1113 |
| "Taking the results of a bash command ""awk '{print $10, $11}' test.txt > test2.txt""",instruction,0,1114 |
| "```os.system(""awk '{print $10, $11}' test.txt > test2.txt"")```",output,1,1114 |
| remove multiple values from a list `my_list` at the same time with index starting at `2` and ending just before `6`.,instruction,0,1115 |
| ```del my_list[2:6]```,output,1,1115 |
| convert a string `s` to its base-10 representation,instruction,0,1116 |
| "```int(s.encode('hex'), 16)```",output,1,1116 |
| match regex pattern 'TAA(?:[ATGC]{3})+?TAA' on string `seq`,instruction,0,1117 |
| "```re.findall('TAA(?:[ATGC]{3})+?TAA', seq)```",output,1,1117 |
| sort a set `s` by numerical value,instruction,0,1118 |
| "```sorted(s, key=float)```",output,1,1118 |
| convert an int 65 to hex string,instruction,0,1119 |
| ```hex(65)```,output,1,1119 |
| append a pandas series `b` to the series `a` and get a continuous index,instruction,0,1120 |
| ```a.append(b).reset_index(drop=True)```,output,1,1120 |
| simple way to append a pandas series `a` and `b` with same index,instruction,0,1121 |
| "```pd.concat([a, b], ignore_index=True)```",output,1,1121 |
| Get a list of tuples with multiple iterators using list comprehension,instruction,0,1122 |
| "```[(i, j) for i in range(1, 3) for j in range(1, 5)]```",output,1,1122 |
| reverse sort items in dictionary `mydict` by value,instruction,0,1123 |
| "```sorted(iter(mydict.items()), key=itemgetter(1), reverse=True)```",output,1,1123 |
| select the last business day of the month for each month in 2014 in pandas,instruction,0,1124 |
| "```pd.date_range('1/1/2014', periods=12, freq='BM')```",output,1,1124 |
| disable the certificate check in https requests for url `https://kennethreitz.com`,instruction,0,1125 |
| "```requests.get('https://kennethreitz.com', verify=False)```",output,1,1125 |
| return dataframe `df` with last row dropped,instruction,0,1126 |
| ```df.ix[:-1]```,output,1,1126 |
| "check if ""blah"" is in string `somestring`",instruction,0,1127 |
| "```if ('blah' not in somestring): |
| pass```",output,1,1127 |
| check if string `needle` is in `haystack`,instruction,0,1128 |
| "```if (needle in haystack): |
| pass```",output,1,1128 |
| "check if string ""substring"" is in string",instruction,0,1129 |
| ```string.find('substring')```,output,1,1129 |
| "check if string `s` contains ""is""",instruction,0,1130 |
| "```if (s.find('is') == (-1)): |
| print(""No 'is' here!"") |
| else: |
| print(""Found 'is' in the string."")```",output,1,1130 |
| extract first and last row of a dataframe `df`,instruction,0,1131 |
| "```pd.concat([df.head(1), df.tail(1)])```",output,1,1131 |
| filter a Django model `MyModel` to have charfield length of max `255`,instruction,0,1132 |
| ```MyModel.objects.extra(where=['CHAR_LENGTH(text) > 254'])```,output,1,1132 |
| Filter queryset for all objects in Django model `MyModel` where texts length are greater than `254`,instruction,0,1133 |
| ```MyModel.objects.filter(text__regex='^.{254}.*')```,output,1,1133 |
| count the number of rows with missing values in a pandas dataframe `df`,instruction,0,1134 |
| "```sum(df.apply(lambda x: sum(x.isnull().values), axis=1) > 0)```",output,1,1134 |
| ,instruction,0,1135 |
| "```sorted(enumerate(a), key=lambda x: x[1])```",output,1,1135 |
| set the font 'Purisa' of size 12 for a canvas' text item `k`,instruction,0,1136 |
| "```canvas.create_text(x, y, font=('Purisa', 12), text=k)```",output,1,1136 |
| create a list containing all values associated with key 'baz' in dictionaries of list `foos` using list comprehension,instruction,0,1137 |
| ```[y['baz'] for x in foos for y in x['bar']]```,output,1,1137 |
| read pandas data frame csv `comma.csv` with extra commas in column specifying string delimiter `'`,instruction,0,1138 |
| "```df = pd.read_csv('comma.csv', quotechar=""'"")```",output,1,1138 |
| replace string 'in.' with ' in. ' in dataframe `df` column 'a',instruction,0,1139 |
| "```df['a'] = df['a'].str.replace('in.', ' in. ')```",output,1,1139 |
| Get all indexes of a list `a` where each value is greater than `2`,instruction,0,1140 |
| ```[i for i in range(len(a)) if a[i] > 2]```,output,1,1140 |
| check if a local variable `myVar` exists,instruction,0,1141 |
| ```('myVar' in locals())```,output,1,1141 |
| check if a global variable `myVar` exists,instruction,0,1142 |
| ```('myVar' in globals())```,output,1,1142 |
| check if object `obj` has attribute 'attr_name',instruction,0,1143 |
| "```hasattr(obj, 'attr_name')```",output,1,1143 |
| check if a local variable 'myVar' exists,instruction,0,1144 |
| "```if ('myVar' in locals()): |
| pass```",output,1,1144 |
| check if a global variable 'myVar' exists,instruction,0,1145 |
| "```if ('myVar' in globals()): |
| pass```",output,1,1145 |
| lambda function that adds two operands,instruction,0,1146 |
| "```lambda x, y: x + y```",output,1,1146 |
| count the number of items in a generator/iterator `it`,instruction,0,1147 |
| ```sum(1 for i in it)```,output,1,1147 |
| get tuples of the corresponding elements from lists `lst` and `lst2`,instruction,0,1148 |
| "```[(x, lst2[i]) for i, x in enumerate(lst)]```",output,1,1148 |
| create tuples containing elements that are at the same index of list `lst` and list `lst2`,instruction,0,1149 |
| "```[(i, j) for i, j in zip(lst, lst2)]```",output,1,1149 |
| get tuples from lists `lst` and `lst2` using list comprehension in python 2,instruction,0,1150 |
| "```[(lst[i], lst2[i]) for i in range(len(lst))]```",output,1,1150 |
| convert hex triplet string `rgbstr` to rgb tuple,instruction,0,1151 |
| "```struct.unpack('BBB', rgbstr.decode('hex'))```",output,1,1151 |
| "Check if 3 is not in a list [2, 3, 4]",instruction,0,1152 |
| "```(3 not in [2, 3, 4])```",output,1,1152 |
| "Check if tuple (2, 3) is not in a list [(2, 3), (5, 6), (9, 1)]",instruction,0,1153 |
| "```((2, 3) not in [(2, 3), (5, 6), (9, 1)])```",output,1,1153 |
| "Check if tuple (2, 3) is not in a list [(2, 7), (7, 3), ""hi""]",instruction,0,1154 |
| "```((2, 3) not in [(2, 7), (7, 3), 'hi'])```",output,1,1154 |
| "Check if 3 is not in the list [4,5,6]",instruction,0,1155 |
| "```(3 not in [4, 5, 6])```",output,1,1155 |
| create a list by appending components from list `a` and reversed list `b` interchangeably,instruction,0,1156 |
| "```[value for pair in zip(a, b[::-1]) for value in pair]```",output,1,1156 |
| delete the last column of numpy array `a` and assign resulting array to `b`,instruction,0,1157 |
| "```b = np.delete(a, -1, 1)```",output,1,1157 |
| commit all the changes after executing a query.,instruction,0,1158 |
| ```dbb.commit()```,output,1,1158 |
| join two dataframes based on values in selected columns,instruction,0,1159 |
| "```pd.merge(a, b, on=['A', 'B'], how='outer')```",output,1,1159 |
| set text color as `red` and background color as `#A3C1DA` in qpushbutton,instruction,0,1160 |
| ```setStyleSheet('QPushButton {background-color: #A3C1DA; color: red;}')```,output,1,1160 |
| find the mean of elements in list `l`,instruction,0,1161 |
| ```sum(l) / float(len(l))```,output,1,1161 |
| Find all the items from a dictionary `D` if the key contains the string `Light`,instruction,0,1162 |
| "```[(k, v) for k, v in D.items() if 'Light' in k]```",output,1,1162 |
| Get a md5 hash from string `thecakeisalie`,instruction,0,1163 |
| ```k = hashlib.md5('thecakeisalie').hexdigest()```,output,1,1163 |
| ,instruction,0,1164 |
| ```os.path.basename(os.path.normpath('/folderA/folderB/folderC/folderD/'))```,output,1,1164 |
| sort datetime objects `birthdays` by `month` and `day`,instruction,0,1165 |
| "```birthdays.sort(key=lambda d: (d.month, d.day))```",output,1,1165 |
| extract table data from table `rows` using beautifulsoup,instruction,0,1166 |
| ```[[td.findNext(text=True) for td in tr.findAll('td')] for tr in rows]```,output,1,1166 |
| strip the string `.txt` from anywhere in the string `Boat.txt.txt`,instruction,0,1167 |
| "```""""""Boat.txt.txt"""""".replace('.txt', '')```",output,1,1167 |
| get a list of the row names from index of a pandas data frame,instruction,0,1168 |
| ```list(df.index)```,output,1,1168 |
| get the row names from index in a pandas data frame,instruction,0,1169 |
| ```df.index```,output,1,1169 |
| create a list of all unique characters in string 'aaabcabccd',instruction,0,1170 |
| "```"""""""""""".join(list(OrderedDict.fromkeys('aaabcabccd').keys()))```",output,1,1170 |
| get list of all unique characters in a string 'aaabcabccd',instruction,0,1171 |
| ```list(set('aaabcabccd'))```,output,1,1171 |
| ,instruction,0,1172 |
| "```"""""""""""".join(set('aaabcabccd'))```",output,1,1172 |
| find rows with non zero values in a subset of columns where `df.dtypes` is not equal to `object` in pandas dataframe,instruction,0,1173 |
| "```df.loc[(df.loc[:, (df.dtypes != object)] != 0).any(1)]```",output,1,1173 |
| ,instruction,0,1174 |
| "```br.form.add_file(open(filename), 'text/plain', filename)```",output,1,1174 |
| "check if dictionary `d` contains all keys in list `['somekey', 'someotherkey', 'somekeyggg']`",instruction,0,1175 |
| "```all(word in d for word in ['somekey', 'someotherkey', 'somekeyggg'])```",output,1,1175 |
| "hide output of subprocess `['espeak', text]`",instruction,0,1176 |
| "```subprocess.check_output(['espeak', text], stderr=subprocess.STDOUT)```",output,1,1176 |
| replace nans by preceding values in pandas dataframe `df`,instruction,0,1177 |
| "```df.fillna(method='ffill', inplace=True)```",output,1,1177 |
| create 4 numbers in range between 1 and 3,instruction,0,1178 |
| "```print(np.linspace(1, 3, num=4, endpoint=False))```",output,1,1178 |
| Create numpy array of `5` numbers starting from `1` with interval of `3`,instruction,0,1179 |
| "```print(np.linspace(1, 3, num=5))```",output,1,1179 |
| create a symlink directory `D:\\testdirLink` for directory `D:\\testdir` with unicode support using ctypes library,instruction,0,1180 |
| "```kdll.CreateSymbolicLinkW('D:\\testdirLink', 'D:\\testdir', 1)```",output,1,1180 |
| get a list `slice` of array slices of the first two rows and columns from array `arr`,instruction,0,1181 |
| "```slice = [arr[i][0:2] for i in range(0, 2)]```",output,1,1181 |
| upload uploaded file from path '/upload' to Google cloud storage 'my_bucket' bucket,instruction,0,1182 |
| "```upload_url = blobstore.create_upload_url('/upload', gs_bucket_name='my_bucket')```",output,1,1182 |
| change directory to the directory of a python script,instruction,0,1183 |
| ```os.chdir(os.path.dirname(__file__))```,output,1,1183 |
| call a function with argument list `args`,instruction,0,1184 |
| ```func(*args)```,output,1,1184 |
| split column 'AB' in dataframe `df` into two columns by first whitespace ' ',instruction,0,1185 |
| "```df['AB'].str.split(' ', 1, expand=True)```",output,1,1185 |
| "pandas dataframe, how do i split a column 'AB' into two 'A' and 'B' on delimiter ' '",instruction,0,1186 |
| "```df['A'], df['B'] = df['AB'].str.split(' ', 1).str```",output,1,1186 |
| sort list `xs` based on the length of its elements,instruction,0,1187 |
| "```print(sorted(xs, key=len))```",output,1,1187 |
| sort list `xs` in ascending order of length of elements,instruction,0,1188 |
| "```xs.sort(lambda x, y: cmp(len(x), len(y)))```",output,1,1188 |
| sort list of strings `xs` by the length of string,instruction,0,1189 |
| ```xs.sort(key=lambda s: len(s))```,output,1,1189 |
| plot point marker '.' on series `ts`,instruction,0,1190 |
| ```ts.plot(marker='.')```,output,1,1190 |
| get all combination of n binary values,instruction,0,1191 |
| "```lst = list(itertools.product([0, 1], repeat=n))```",output,1,1191 |
| get all combination of n binary values,instruction,0,1192 |
| "```lst = map(list, itertools.product([0, 1], repeat=n))```",output,1,1192 |
| get all combination of 3 binary values,instruction,0,1193 |
| "```bin = [0, 1] |
| [(x, y, z) for x in bin for y in bin for z in bin]```",output,1,1193 |
| get all combination of 3 binary values,instruction,0,1194 |
| "```lst = list(itertools.product([0, 1], repeat=3))```",output,1,1194 |
| append string 'str' at the beginning of each value in column 'col' of dataframe `df`,instruction,0,1195 |
| ```df['col'] = 'str' + df['col'].astype(str)```,output,1,1195 |
| "get a dict of variable names `['some', 'list', 'of', 'vars']` as a string and their values",instruction,0,1196 |
| "```dict((name, eval(name)) for name in ['some', 'list', 'of', 'vars'])```",output,1,1196 |
| add a colorbar to plot `plt` using image `im` on axes `ax`,instruction,0,1197 |
| "```plt.colorbar(im, ax=ax)```",output,1,1197 |
| convert nested list 'Cards' into a flat list,instruction,0,1198 |
| ```[a for c in Cards for b in c for a in b]```,output,1,1198 |
| create a list containing keys of dictionary `d` and sort it alphabetically,instruction,0,1199 |
| "```sorted(d, key=d.get)```",output,1,1199 |
| print the number of occurences of not `none` in a list `lst` in Python 2,instruction,0,1200 |
| ```print(len([x for x in lst if x is not None]))```,output,1,1200 |
| lookup dictionary key `key1` in Django template `json`,instruction,0,1201 |
| ```{{json.key1}}```,output,1,1201 |
| remove duplicates from list `myset`,instruction,0,1202 |
| ```mynewlist = list(myset)```,output,1,1202 |
| "get unique values from the list `['a', 'b', 'c', 'd']`",instruction,0,1203 |
| "```set(['a', 'b', 'c', 'd'])```",output,1,1203 |
| "set size of `figure` to landscape A4 i.e. `11.69, 8.27` inches",instruction,0,1204 |
| "```figure(figsize=(11.69, 8.27))```",output,1,1204 |
| get every thing after last `/`,instruction,0,1205 |
| "```url.rsplit('/', 1)```",output,1,1205 |
| get everything after last slash in a url stored in variable 'url',instruction,0,1206 |
| "```url.rsplit('/', 1)[-1]```",output,1,1206 |
| open file '5_1.txt' in directory `direct`,instruction,0,1207 |
| "```x_file = open(os.path.join(direct, '5_1.txt'), 'r')```",output,1,1207 |
| create a list with the characters of a string `5+6`,instruction,0,1208 |
| ```list('5+6')```,output,1,1208 |
| concatenate a list of numpy arrays `input_list` together into a flattened list of values,instruction,0,1209 |
| ```np.concatenate(input_list).ravel().tolist()```,output,1,1209 |
| convert dictionary `dict` into a flat list,instruction,0,1210 |
| ```print([y for x in list(dict.items()) for y in x])```,output,1,1210 |
| Convert a dictionary `dict` into a list with key and values as list items.,instruction,0,1211 |
| ```[y for x in list(dict.items()) for y in x]```,output,1,1211 |
| get a random record from model 'MyModel' using django's orm,instruction,0,1212 |
| ```MyModel.objects.order_by('?').first()```,output,1,1212 |
| change current working directory to directory 'chapter3',instruction,0,1213 |
| ```os.chdir('chapter3')```,output,1,1213 |
| change current working directory,instruction,0,1214 |
| ```os.chdir('C:\\Users\\username\\Desktop\\headfirstpython\\chapter3')```,output,1,1214 |
| change current working directory,instruction,0,1215 |
| ```os.chdir('.\\chapter3')```,output,1,1215 |
| create a flat dictionary by summing values associated with similar keys in each dictionary of list `dictlist`,instruction,0,1216 |
| "```dict((key, sum(d[key] for d in dictList)) for key in dictList[0])```",output,1,1216 |
| sort pandas data frame `df` using values from columns `c1` and `c2` in ascending order,instruction,0,1217 |
| "```df.sort(['c1', 'c2'], ascending=[True, True])```",output,1,1217 |
| Converting string lists `s` to float list,instruction,0,1218 |
| ```floats = [float(x) for x in s.split()]```,output,1,1218 |
| Converting string lists `s` to float list,instruction,0,1219 |
| "```floats = map(float, s.split())```",output,1,1219 |
| "set labels `[1, 2, 3, 4, 5]` on axis X in plot `plt`",instruction,0,1220 |
| "```plt.xticks([1, 2, 3, 4, 5])```",output,1,1220 |
| read line by line from stdin,instruction,0,1221 |
| "```for line in fileinput.input(): |
| pass```",output,1,1221 |
| read line by line from stdin,instruction,0,1222 |
| "```for line in sys.stdin: |
| pass```",output,1,1222 |
| check if string `one` exists in the values of dictionary `d`,instruction,0,1223 |
| ```'one' in list(d.values())```,output,1,1223 |
| Check if value 'one' is among the values of dictionary `d`,instruction,0,1224 |
| ```'one' in iter(d.values())```,output,1,1224 |
| call parent class `Instructor` of child class constructor,instruction,0,1225 |
| "```super(Instructor, self).__init__(name, year)```",output,1,1225 |
| create a dictionary using two lists`x` and `y`,instruction,0,1226 |
| "```dict(zip(x, y))```",output,1,1226 |
| sort a list of dictionaries `a` by dictionary values in descending order,instruction,0,1227 |
| "```sorted(a, key=lambda i: list(i.values())[0], reverse=True)```",output,1,1227 |
| sorting a list of dictionary `a` by values in descending order,instruction,0,1228 |
| "```sorted(a, key=dict.values, reverse=True)```",output,1,1228 |
| "Use multiple groupby and agg operations `sum`, `count`, `std` for pandas data frame `df`",instruction,0,1229 |
| "```df.groupby(level=0).agg(['sum', 'count', 'std'])```",output,1,1229 |
| "for a dictionary `a`, set default value for key `somekey` as list and append value `bob` in that key",instruction,0,1230 |
| "```a.setdefault('somekey', []).append('bob')```",output,1,1230 |
| sum values in list of dictionaries `example_list` with key 'gold',instruction,0,1231 |
| ```sum(item['gold'] for item in example_list)```,output,1,1231 |
| get a sum of all values from key `gold` in a list of dictionary `example_list`,instruction,0,1232 |
| ```sum([item['gold'] for item in example_list])```,output,1,1232 |
| Get all the values in key `gold` summed from a list of dictionary `myLIst`,instruction,0,1233 |
| ```sum(item['gold'] for item in myLIst)```,output,1,1233 |
| writing string 'text to write\n' to file `f`,instruction,0,1234 |
| ```f.write('text to write\n')```,output,1,1234 |
| Write a string `My String` to a file `file` including new line character,instruction,0,1235 |
| ```file.write('My String\n')```,output,1,1235 |
| find consecutive segments from a column 'A' in a pandas data frame 'df',instruction,0,1236 |
| ```df.reset_index().groupby('A')['index'].apply(np.array)```,output,1,1236 |
| get a relative path of file 'my_file' into variable `fn`,instruction,0,1237 |
| "```fn = os.path.join(os.path.dirname(__file__), 'my_file')```",output,1,1237 |
| retrieve an element from a set `s` without removing it,instruction,0,1238 |
| ```e = next(iter(s))```,output,1,1238 |
| execute a command in the command prompt to list directory contents of the c drive `c:\\',instruction,0,1239 |
| ```os.system('dir c:\\')```,output,1,1239 |
| Make a auto scrolled window to the end of the list in gtk,instruction,0,1240 |
| "```self.treeview.connect('size-allocate', self.treeview_changed)```",output,1,1240 |
| "check if 3 is inside list `[1, 2, 3]`",instruction,0,1241 |
| "```3 in [1, 2, 3]```",output,1,1241 |
| Represent DateTime object '10/05/2012' with format '%d/%m/%Y' into format '%Y-%m-%d',instruction,0,1242 |
| "```datetime.datetime.strptime('10/05/2012', '%d/%m/%Y').strftime('%Y-%m-%d')```",output,1,1242 |
| convert a string literal `s` with values `\\` to raw string literal,instruction,0,1243 |
| "```s = s.replace('\\', '\\\\')```",output,1,1243 |
| get output of script `proc`,instruction,0,1244 |
| ```print(proc.communicate()[0])```,output,1,1244 |
| create a pandas data frame from list of nested dictionaries `my_list`,instruction,0,1245 |
| "```pd.concat([pd.DataFrame(l) for l in my_list], axis=1).T```",output,1,1245 |
| delete all columns in DataFrame `df` that do not hold a non-zero value in its records,instruction,0,1246 |
| "```df.loc[:, ((df != 0).any(axis=0))]```",output,1,1246 |
| sort a multidimensional array `a` by column with index 1,instruction,0,1247 |
| "```sorted(a, key=lambda x: x[1])```",output,1,1247 |
| "split string `s` to list conversion by ','",instruction,0,1248 |
| "```[x.strip() for x in s.split(',')]```",output,1,1248 |
| Get a list of items in the list `container` with attribute equal to `value`,instruction,0,1249 |
| ```items = [item for item in container if item.attribute == value]```,output,1,1249 |
| create a file 'filename' with each tuple in the list `mylist` written to a line,instruction,0,1250 |
| "```open('filename', 'w').write('\n'.join('%s %s' % x for x in mylist))```",output,1,1250 |
| Get multiple matched strings using regex pattern `(?:review: )?(http: |
| "```pattern = re.compile('(?:review: )?(http://url.com/(\\d+))\\s?', re.IGNORECASE)```",output,1,1251 |
| read a text file 'very_Important.txt' into a string variable `str`,instruction,0,1252 |
| "```str = open('very_Important.txt', 'r').read()```",output,1,1252 |
| Return values for column `C` after group by on column `A` and `B` in dataframe `df`,instruction,0,1253 |
| "```df.groupby(['A', 'B'])['C'].unique()```",output,1,1253 |
| read file `fname` line by line into a list `content`,instruction,0,1254 |
| "```with open(fname) as f: |
| content = f.readlines()```",output,1,1254 |
| read file 'filename' line by line into a list `lines`,instruction,0,1255 |
| "```with open('filename') as f: |
| lines = f.readlines()```",output,1,1255 |
| read file 'filename' line by line into a list `lines`,instruction,0,1256 |
| ```lines = [line.rstrip('\n') for line in open('filename')]```,output,1,1256 |
| "read file ""file.txt"" line by line into a list `array`",instruction,0,1257 |
| "```with open('file.txt', 'r') as ins: |
| array = [] |
| for line in ins: |
| array.append(line)```",output,1,1257 |
| convert the dataframe column 'col' from string types to datetime types,instruction,0,1258 |
| ```df['col'] = pd.to_datetime(df['col'])```,output,1,1258 |
| get a list of the keys in each dictionary in a dictionary of dictionaries `foo`,instruction,0,1259 |
| ```[k for d in list(foo.values()) for k in d]```,output,1,1259 |
| "get user input using message 'Enter name here: ' and insert it to the first placeholder in string 'Hello, {0}, how do you do?'",instruction,0,1260 |
| "```print('Hello, {0}, how do you do?'.format(input('Enter name here: ')))```",output,1,1260 |
| create pandas data frame `df` from txt file `filename.txt` with column `Region Name` and separator `;`,instruction,0,1261 |
| "```df = pd.read_csv('filename.txt', sep=';', names=['Region Name'])```",output,1,1261 |
| ,instruction,0,1262 |
| ```df['a'] = df['a'].apply(lambda x: x + 1)```,output,1,1262 |
| get the platform OS name,instruction,0,1263 |
| ```platform.system()```,output,1,1263 |
| sort list `a` in ascending order based on its elements' float values,instruction,0,1264 |
| "```a = sorted(a, key=lambda x: float(x))```",output,1,1264 |
| finding words in string `s` after keyword 'name',instruction,0,1265 |
| "```re.search('name (.*)', s)```",output,1,1265 |
| Find all records from collection `collection` without extracting mongo id `_id`,instruction,0,1266 |
| "```db.collection.find({}, {'_id': False})```",output,1,1266 |
| Get all the second values from a list of lists `A`,instruction,0,1267 |
| ```[row[1] for row in A]```,output,1,1267 |
| extract first column from a multi-dimensional array `a`,instruction,0,1268 |
| ```[row[0] for row in a]```,output,1,1268 |
| "sort list `['10', '3', '2']` in ascending order based on the integer value of its elements",instruction,0,1269 |
| "```sorted(['10', '3', '2'], key=int)```",output,1,1269 |
| check if file `filename` is descendant of directory '/the/dir/',instruction,0,1270 |
| "```os.path.commonprefix(['/the/dir/', os.path.realpath(filename)]) == '/the/dir/'```",output,1,1270 |
| check if any element of list `substring_list` are in string `string`,instruction,0,1271 |
| ```any(substring in string for substring in substring_list)```,output,1,1271 |
| construct pandas dataframe from a list of tuples,instruction,0,1272 |
| "```df = pandas.DataFrame(data, columns=['R_Number', 'C_Number', 'Avg', 'Std'])```",output,1,1272 |
| find and replace 2nd occurrence of word 'cat' by 'Bull' in a sentence 's',instruction,0,1273 |
| "```re.sub('^((?:(?!cat).)*cat(?:(?!cat).)*)cat', '\\1Bull', s)```",output,1,1273 |
| find and replace 2nd occurrence of word 'cat' by 'Bull' in a sentence 's',instruction,0,1274 |
| "```re.sub('^((.*?cat.*?){1})cat', '\\1Bull', s)```",output,1,1274 |
| sort list of strings in list `the_list` by integer suffix,instruction,0,1275 |
| "```sorted(the_list, key=lambda k: int(k.split('_')[1]))```",output,1,1275 |
| "sort list of strings `the_list` by integer suffix before ""_""",instruction,0,1276 |
| "```sorted(the_list, key=lambda x: int(x.split('_')[1]))```",output,1,1276 |
| make a list of lists in which each list `g` are the elements from list `test` which have the same characters up to the first `_` character,instruction,0,1277 |
| "```[list(g) for _, g in itertools.groupby(test, lambda x: x.split('_')[0])]```",output,1,1277 |
| ,instruction,0,1278 |
| "```[list(g) for _, g in itertools.groupby(test, lambda x: x.partition('_')[0])]```",output,1,1278 |
| Load the url `http://www.google.com` in selenium webdriver `driver`,instruction,0,1279 |
| ```driver.get('http: |
| "using python's datetime module, get the year that utc-11 is currently in",instruction,0,1280 |
| ```(datetime.datetime.utcnow() - datetime.timedelta(hours=11)).year```,output,1,1280 |
| "Get the difference between two lists `[1, 2, 2, 2, 3]` and `[1, 2]` that may have duplicate values",instruction,0,1281 |
| "```Counter([1, 2, 2, 2, 3]) - Counter([1, 2])```",output,1,1281 |
| remove tags from a string `mystring`,instruction,0,1282 |
| "```re.sub('<[^>]*>', '', mystring)```",output,1,1282 |
| encode string `data` as `hex`,instruction,0,1283 |
| ```data.encode('hex')```,output,1,1283 |
| filter `Users` by field `userprofile` with level greater than or equal to `0`,instruction,0,1284 |
| ```User.objects.filter(userprofile__level__gte=0)```,output,1,1284 |
| BeautifulSoup find a tag whose id ends with string 'para',instruction,0,1285 |
| ```soup.findAll(id=re.compile('para$'))```,output,1,1285 |
| select `div` tags whose `id`s begin with `value_xxx_c_1_f_8_a_`,instruction,0,1286 |
| "```soup.select('div[id^=""value_xxx_c_1_f_8_a_""]')```",output,1,1286 |
| delete an item `thing` in a list `some_list` if it exists,instruction,0,1287 |
| ```cleaned_list = [x for x in some_list if x is not thing]```,output,1,1287 |
| "print ""Please enter something: "" to console, and read user input to `var`",instruction,0,1288 |
| ```var = input('Please enter something: ')```,output,1,1288 |
| append 4 to list `foo`,instruction,0,1289 |
| ```foo.append(4)```,output,1,1289 |
| "append a list [8, 7] to list `foo`",instruction,0,1290 |
| "```foo.append([8, 7])```",output,1,1290 |
| insert 77 to index 2 of list `x`,instruction,0,1291 |
| "```x.insert(2, 77)```",output,1,1291 |
| remove white space padding around a saved image `test.png` in matplotlib,instruction,0,1292 |
| "```plt.savefig('test.png', bbox_inches='tight')```",output,1,1292 |
| concatenate lists `listone` and `listtwo`,instruction,0,1293 |
| ```(listone + listtwo)```,output,1,1293 |
| iterate items in lists `listone` and `listtwo`,instruction,0,1294 |
| "```for item in itertools.chain(listone, listtwo): |
| pass```",output,1,1294 |
| create dataframe `males` containing data of dataframe `df` where column `Gender` is equal to 'Male' and column `Year` is equal to 2014,instruction,0,1295 |
| ```males = df[(df[Gender] == 'Male') & (df[Year] == 2014)]```,output,1,1295 |
| print backslash,instruction,0,1296 |
| ```print('\\')```,output,1,1296 |
| replace '-' in pandas dataframe `df` with `np.nan`,instruction,0,1297 |
| "```df.replace('-', np.nan)```",output,1,1297 |
| delete column 'column_name' from dataframe `df`,instruction,0,1298 |
| "```df = df.drop('column_name', 1)```",output,1,1298 |
| "delete 1st, 2nd and 4th columns from dataframe `df`",instruction,0,1299 |
| "```df.drop(df.columns[[0, 1, 3]], axis=1)```",output,1,1299 |
| delete a column `column_name` without having to reassign from pandas data frame `df`,instruction,0,1300 |
| "```df.drop('column_name', axis=1, inplace=True)```",output,1,1300 |
| disable abbreviation in argparse,instruction,0,1301 |
| ```parser = argparse.ArgumentParser(allow_abbrev=False)```,output,1,1301 |
| extract dictionary values by key 'Feature3' from data frame `df`,instruction,0,1302 |
| ```feature3 = [d.get('Feature3') for d in df.dic]```,output,1,1302 |
| get data of column 'A' and column 'B' in dataframe `df` where column 'A' is equal to 'foo',instruction,0,1303 |
| "```df.loc[gb.groups['foo'], ('A', 'B')]```",output,1,1303 |
| "print '[1, 2, 3]'",instruction,0,1304 |
| "```print('[%s, %s, %s]' % (1, 2, 3))```",output,1,1304 |
| Display `1 2 3` as a list of string,instruction,0,1305 |
| "```print('[{0}, {1}, {2}]'.format(1, 2, 3))```",output,1,1305 |
| get values from a dictionary `my_dict` whose key contains the string `Date`,instruction,0,1306 |
| "```[v for k, v in list(my_dict.items()) if 'Date' in k]```",output,1,1306 |
| ,instruction,0,1307 |
| "```""""""{0.month}/{0.day}/{0.year}"""""".format(my_date)```",output,1,1307 |
| drop a single subcolumn 'a' in column 'col1' from a dataframe `df`,instruction,0,1308 |
| "```df.drop(('col1', 'a'), axis=1)```",output,1,1308 |
| "dropping all columns named 'a' from a multiindex 'df', across all level.",instruction,0,1309 |
| "```df.drop('a', level=1, axis=1)```",output,1,1309 |
| build dictionary with keys of dictionary `_container` as keys and values of returned value of function `_value` with correlating key as parameter,instruction,0,1310 |
| ```{_key: _value(_key) for _key in _container}```,output,1,1310 |
| click on the text button 'section-select-all' using selenium python,instruction,0,1311 |
| ```browser.find_element_by_class_name('section-select-all').click()```,output,1,1311 |
| "combine two dictionaries `d ` and `d1`, concatenate string values with identical `keys`",instruction,0,1312 |
| "```dict((k, d.get(k, '') + d1.get(k, '')) for k in keys)```",output,1,1312 |
| generate unique equal hash for equal dictionaries `a` and `b`,instruction,0,1313 |
| ```hash(pformat(a)) == hash(pformat(b))```,output,1,1313 |
| "convert nested list of lists `[['tom', 'cat'], ['jerry', 'mouse'], ['spark', 'dog']]` into a list of tuples",instruction,0,1314 |
| "```list(map(tuple, [['tom', 'cat'], ['jerry', 'mouse'], ['spark', 'dog']]))```",output,1,1314 |
| "sum the column `positions` along the other columns `stock`, `same1`, `same2` in a pandas data frame `df`",instruction,0,1315 |
| "```df.groupby(['stock', 'same1', 'same2'], as_index=False)['positions'].sum()```",output,1,1315 |
| ,instruction,0,1316 |
| "```df.groupby(['stock', 'same1', 'same2'])['positions'].sum().reset_index()```",output,1,1316 |
| change string `s` to upper case,instruction,0,1317 |
| ```s.upper()```,output,1,1317 |
| split a string `s` by ';' and convert to a dictionary,instruction,0,1318 |
| ```dict(item.split('=') for item in s.split(';'))```,output,1,1318 |
| "Add header `('Cookie', 'cookiename=cookie value')` to mechanize browser `br`",instruction,0,1319 |
| "```br.addheaders = [('Cookie', 'cookiename=cookie value')]```",output,1,1319 |
| set data in column 'value' of dataframe `df` equal to first element of each list,instruction,0,1320 |
| ```df['value'] = df['value'].str[0]```,output,1,1320 |
| get element at index 0 of each list in column 'value' of dataframe `df`,instruction,0,1321 |
| ```df['value'] = df['value'].str.get(0)```,output,1,1321 |
| remove square bracket '[]' from pandas dataframe `df` column 'value',instruction,0,1322 |
| ```df['value'] = df['value'].str.strip('[]')```,output,1,1322 |
| Get a string with string formatting from dictionary `d`,instruction,0,1323 |
| "```"""""", """""".join(['{}_{}'.format(k, v) for k, v in d.items()])```",output,1,1323 |
| "Sum of sums of each list, in a list of lists named 'lists'.",instruction,0,1324 |
| ```sum(sum(x) for x in lists)```,output,1,1324 |
| "Check whether a numpy array `a` contains a given row `[1, 2]`",instruction,0,1325 |
| "```any(np.equal(a, [1, 2]).all(1))```",output,1,1325 |
| check if all elements in list `mylist` are the same,instruction,0,1326 |
| ```len(set(mylist)) == 1```,output,1,1326 |
| split a string `s` at line breaks `\r\n`,instruction,0,1327 |
| "```[map(int, x.split('\t')) for x in s.rstrip().split('\r\n')]```",output,1,1327 |
| sort a dictionary `a` by values that are list type,instruction,0,1328 |
| "```t = sorted(list(a.items()), key=lambda x: x[1])```",output,1,1328 |
| Search for string 'blabla' in txt file 'example.txt',instruction,0,1329 |
| "```if ('blabla' in open('example.txt').read()): |
| pass```",output,1,1329 |
| Search for string 'blabla' in txt file 'example.txt',instruction,0,1330 |
| "```f = open('example.txt') |
| s = mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ) |
| if (s.find('blabla') != (-1)): |
| pass```",output,1,1330 |
| Search for string `blabla` in txt file 'example.txt',instruction,0,1331 |
| "```datafile = file('example.txt') |
| found = False |
| for line in datafile: |
| if (blabla in line): |
| return True |
| return False```",output,1,1331 |
| insert string `string1` after each character of `string2`,instruction,0,1332 |
| "```string2.replace('', string1)[len(string1):-len(string1)]```",output,1,1332 |
| getting every possible combination of two elements in a list,instruction,0,1333 |
| "```list(itertools.combinations([1, 2, 3, 4, 5, 6], 2))```",output,1,1333 |
| get a utf-8 string literal representation of byte string `x`,instruction,0,1334 |
| "```""""""x = {}"""""".format(x.decode('utf8')).encode('utf8')```",output,1,1334 |
| check if `x` is an integer,instruction,0,1335 |
| "```isinstance(x, int)```",output,1,1335 |
| check if `x` is an integer,instruction,0,1336 |
| ```(type(x) == int)```,output,1,1336 |
| play the wav file 'sound.wav',instruction,0,1337 |
| "```winsound.PlaySound('sound.wav', winsound.SND_FILENAME)```",output,1,1337 |
| create a list containing the `n` next values of generator `it`,instruction,0,1338 |
| ```[next(it) for _ in range(n)]```,output,1,1338 |
| get list of n next values of a generator `it`,instruction,0,1339 |
| "```list(itertools.islice(it, 0, n, 1))```",output,1,1339 |
| compare two lists in python `a` and `b` and return matches,instruction,0,1340 |
| ```set(a).intersection(b)```,output,1,1340 |
| ,instruction,0,1341 |
| "```[i for i, j in zip(a, b) if i == j]```",output,1,1341 |
| convert list `data` into a string of its elements,instruction,0,1342 |
| "```print(''.join(map(str, data)))```",output,1,1342 |
| match regex pattern '\\$[0-9]+[^\\$]*$' on string '$1 off delicious $5 ham.',instruction,0,1343 |
| "```re.match('\\$[0-9]+[^\\$]*$', '$1 off delicious $5 ham.')```",output,1,1343 |
| import a nested module `c.py` within `b` within `a` with importlib,instruction,0,1344 |
| "```importlib.import_module('.c', 'a.b')```",output,1,1344 |
| import a module 'a.b.c' with importlib.import_module in python 2,instruction,0,1345 |
| ```importlib.import_module('a.b.c')```,output,1,1345 |
| Convert array `a` to numpy array,instruction,0,1346 |
| ```a = np.array(a)```,output,1,1346 |
| Find all `div` tags whose classes has the value `comment-` in a beautiful soup object `soup`,instruction,0,1347 |
| "```soup.find_all('div', class_=re.compile('comment-'))```",output,1,1347 |
| a sequence of empty lists of length `n`,instruction,0,1348 |
| ```[[] for _ in range(n)]```,output,1,1348 |
| create dictionary from list of variables 'foo' and 'bar' already defined,instruction,0,1349 |
| "```dict((k, globals()[k]) for k in ('foo', 'bar'))```",output,1,1349 |
| get two random records from model 'MyModel' in Django,instruction,0,1350 |
| ```MyModel.objects.order_by('?')[:2]```,output,1,1350 |
| Print a dictionary `{'user': {'name': 'Markus'}}` with string formatting,instruction,0,1351 |
| "```""""""Hello {user[name]}"""""".format(**{'user': {'name': 'Markus'}})```",output,1,1351 |
| create a dictionary `list_dict` containing each tuple in list `tuple_list` as values and the tuple's first element as the corresponding key,instruction,0,1352 |
| ```list_dict = {t[0]: t for t in tuple_list}```,output,1,1352 |
| Generate a random integer between 0 and 9,instruction,0,1353 |
| "```randint(0, 9)```",output,1,1353 |
| Generate a random integer between `a` and `b`,instruction,0,1354 |
| "```random.randint(a, b)```",output,1,1354 |
| Generate random integers between 0 and 9,instruction,0,1355 |
| "```print((random.randint(0, 9)))```",output,1,1355 |
| reverse a string `a` by 2 characters at a time,instruction,0,1356 |
| "```"""""""""""".join(reversed([a[i:i + 2] for i in range(0, len(a), 2)]))```",output,1,1356 |
| transform time series `df` into a pivot table aggregated by column 'Close' using column `df.index.date` as index and values of column `df.index.time` as columns,instruction,0,1357 |
| "```pd.pivot_table(df, index=df.index.date, columns=df.index.time, values='Close')```",output,1,1357 |
| "check if the third element of all the lists in a list ""items"" is equal to zero.",instruction,0,1358 |
| ```any(item[2] == 0 for item in items)```,output,1,1358 |
| Find all the lists from a lists of list 'items' if third element in all sub-lists is '0',instruction,0,1359 |
| ```[x for x in items if x[2] == 0]```,output,1,1359 |
| sort dictionary of dictionaries `dic` according to the key 'Fisher',instruction,0,1360 |
| "```sorted(list(dic.items()), key=lambda x: x[1]['Fisher'], reverse=True)```",output,1,1360 |
| plot a data logarithmically in y axis,instruction,0,1361 |
| "```plt.yscale('log', nonposy='clip')```",output,1,1361 |
| ,instruction,0,1362 |
| "```map(int, re.findall('\\d+', s))```",output,1,1362 |
| list the contents of a directory '/home/username/www/',instruction,0,1363 |
| ```os.listdir('/home/username/www/')```,output,1,1363 |
| list all the contents of the directory 'path'.,instruction,0,1364 |
| ```os.listdir('path')```,output,1,1364 |
| merge a pandas data frame `distancesDF` and column `dates` in pandas data frame `datesDF` into single,instruction,0,1365 |
| "```pd.concat([distancesDF, datesDF.dates], axis=1)```",output,1,1365 |
| get value of first index of each element in list `a`,instruction,0,1366 |
| ```[x[0] for x in a]```,output,1,1366 |
| python how to get every first element in 2 dimensional list `a`,instruction,0,1367 |
| ```[i[0] for i in a]```,output,1,1367 |
| remove line breaks from string `textblock` using regex,instruction,0,1368 |
| "```re.sub('(?<=[a-z])\\r?\\n', ' ', textblock)```",output,1,1368 |
| Open gzip-compressed file encoded as utf-8 'file.gz' in text mode,instruction,0,1369 |
| "```gzip.open('file.gz', 'rt', encoding='utf-8')```",output,1,1369 |
| "test if either of strings `a` or `b` are members of the set of strings, `['b', 'a', 'foo', 'bar']`",instruction,0,1370 |
| "```set(['a', 'b']).issubset(['b', 'a', 'foo', 'bar'])```",output,1,1370 |
| "Check if all the values in a list `['a', 'b']` are present in another list `['b', 'a', 'foo', 'bar']`",instruction,0,1371 |
| "```all(x in ['b', 'a', 'foo', 'bar'] for x in ['a', 'b'])```",output,1,1371 |
| "Remove characters ""!@#$"" from a string `line`",instruction,0,1372 |
| "```line.translate(None, '!@#$')```",output,1,1372 |
| "Remove characters ""!@#$"" from a string `line`",instruction,0,1373 |
| "```line = re.sub('[!@#$]', '', line)```",output,1,1373 |
| "Remove string ""1"" from string `string`",instruction,0,1374 |
| "```string.replace('1', '')```",output,1,1374 |
| Remove character `char` from a string `a`,instruction,0,1375 |
| "```a = a.replace(char, '')```",output,1,1375 |
| Remove characters in `b` from a string `a`,instruction,0,1376 |
| "```a = a.replace(char, '')```",output,1,1376 |
| Remove characters in '!@#$' from a string `line`,instruction,0,1377 |
| "```line = line.translate(string.maketrans('', ''), '!@#$')```",output,1,1377 |
| binarize the values in columns of list `order` in a pandas data frame,instruction,0,1378 |
| "```pd.concat([df, pd.get_dummies(df, '', '').astype(int)], axis=1)[order]```",output,1,1378 |
| "store integer 3, 4, 1 and 2 in a list",instruction,0,1379 |
| "```[3, 4, 1, 2]```",output,1,1379 |
| define global variable `something` with value `bob`,instruction,0,1380 |
| ```globals()['something'] = 'bob'```,output,1,1380 |
| insert spaces before capital letters in string `text`,instruction,0,1381 |
| "```re.sub('([a-z](?=[A-Z])|[A-Z](?=[A-Z][a-z]))', '\\1 ', text)```",output,1,1381 |
| print unicode string `ex\xe1mple` in uppercase,instruction,0,1382 |
| ```print('ex\xe1mple'.upper())```,output,1,1382 |
| get last element of string splitted by '\\' from list of strings `list_dirs`,instruction,0,1383 |
| ```[l.split('\\')[-1] for l in list_dirs]```,output,1,1383 |
| combine two sequences into a dictionary,instruction,0,1384 |
| "```dict(zip(keys, values))```",output,1,1384 |
| customize the time format in python logging,instruction,0,1385 |
| ```formatter = logging.Formatter('%(asctime)s;%(levelname)s;%(message)s')```,output,1,1385 |
| Replace comma with dot in a string `original_string` using regex,instruction,0,1386 |
| "```new_string = re.sub('""(\\d+),(\\d+)""', '\\1.\\2', original_string)```",output,1,1386 |
| call a function `otherfunc` inside a bash script `test.sh` using subprocess,instruction,0,1387 |
| ```subprocess.call('test.sh otherfunc')```,output,1,1387 |
| ,instruction,0,1388 |
| "```subprocess.Popen(['bash', '-c', '. foo.sh; go'])```",output,1,1388 |
| remove multiple spaces in a string `foo`,instruction,0,1389 |
| "```"""""" """""".join(foo.split())```",output,1,1389 |
| convert decimal 8 to a list of its binary values,instruction,0,1390 |
| ```list('{0:0b}'.format(8))```,output,1,1390 |
| convert decimal integer 8 to a list of its binary values as elements,instruction,0,1391 |
| ```[int(x) for x in list('{0:0b}'.format(8))]```,output,1,1391 |
| convert decimal `8` to binary list,instruction,0,1392 |
| ```[int(x) for x in bin(8)[2:]]```,output,1,1392 |
| get key-value pairs in dictionary `my_dictionary` for all keys in list `my_list` in the order they appear in `my_list`,instruction,0,1393 |
| "```dict(zip(my_list, map(my_dictionary.get, my_list)))```",output,1,1393 |
| cartesian product of `x` and `y` array points into single array of 2d points,instruction,0,1394 |
| "```numpy.dstack(numpy.meshgrid(x, y)).reshape(-1, 2)```",output,1,1394 |
| selenium wait for driver `driver` 60 seconds before throwing a NoSuchElementExceptions exception,instruction,0,1395 |
| ```driver.implicitly_wait(60)```,output,1,1395 |
| selenium webdriver switch to frame 'frameName',instruction,0,1396 |
| ```driver.switch_to_frame('frameName')```,output,1,1396 |
| format current date to pattern '{%Y-%m-%d %H:%M:%S}',instruction,0,1397 |
| ```time.strftime('{%Y-%m-%d %H:%M:%S}')```,output,1,1397 |
| "sort list `['14:10:01', '03:12:08']`",instruction,0,1398 |
| "```sorted(['14:10:01', '03:12:08'])```",output,1,1398 |
| "find all occurrences of regex pattern '(?:\\w+(?:\\s+\\w+)*,\\s)+(?:\\w+(?:\\s\\w+)*)' in string `x`",instruction,0,1399 |
| "```re.findall('(?:\\w+(?:\\s+\\w+)*,\\s)+(?:\\w+(?:\\s\\w+)*)', x)```",output,1,1399 |
| remove duplicate rows from dataframe `df1` and calculate their frequency,instruction,0,1400 |
| "```df1.groupby(['key', 'year']).size().reset_index()```",output,1,1400 |
| sort dictionary `dictionary` in ascending order by its values,instruction,0,1401 |
| "```sorted(list(dictionary.items()), key=operator.itemgetter(1))```",output,1,1401 |
| Iterate over dictionary `d` in ascending order of values,instruction,0,1402 |
| "```sorted(iter(d.items()), key=lambda x: x[1])```",output,1,1402 |
| "iterate over a python dictionary, ordered by values",instruction,0,1403 |
| "```sorted(list(dictionary.items()), key=lambda x: x[1])```",output,1,1403 |
| split 1d array `a` into 2d array at the last element,instruction,0,1404 |
| "```np.split(a, [-1])```",output,1,1404 |
| convert dataframe `df` into a pivot table using column 'order' as index and values of column 'sample' as columns,instruction,0,1405 |
| "```df.pivot(index='order', columns='sample')```",output,1,1405 |
| select all rows from pandas DataFrame 'df' where the value in column 'A' is greater than 1 or less than -1 in column 'B'.,instruction,0,1406 |
| ```df[(df['A'] > 1) | (df['B'] < -1)]```,output,1,1406 |
| "Get the zip output as list from the lists `[1, 2, 3]`, `[4, 5, 6]`, `[7, 8, 9]`",instruction,0,1407 |
| "```[list(a) for a in zip([1, 2, 3], [4, 5, 6], [7, 8, 9])]```",output,1,1407 |
| select rows of dataframe `df` whose value for column `A` is `foo`,instruction,0,1408 |
| ```print(df.loc[df['A'] == 'foo'])```,output,1,1408 |
| select rows whose column value in column `column_name` does not equal `some_value` in pandas data frame,instruction,0,1409 |
| ```df.loc[df['column_name'] != some_value]```,output,1,1409 |
| select rows from a dataframe `df` whose value for column `column_name` is not in `some_values`,instruction,0,1410 |
| ```df.loc[~df['column_name'].isin(some_values)]```,output,1,1410 |
| select all rows whose values in a column `column_name` equals a scalar `some_value` in pandas data frame object `df`,instruction,0,1411 |
| ```df.loc[df['column_name'] == some_value]```,output,1,1411 |
| "Select rows whose value of the ""B"" column is ""one"" or ""three"" in the DataFrame `df`",instruction,0,1412 |
| "```print(df.loc[df['B'].isin(['one', 'three'])])```",output,1,1412 |
| repeat every character for 7 times in string 'map',instruction,0,1413 |
| "```"""""""""""".join(map(lambda x: x * 7, 'map'))```",output,1,1413 |
| delete an empty directory,instruction,0,1414 |
| ```os.rmdir()```,output,1,1414 |
| recursively delete all contents in directory `path`,instruction,0,1415 |
| "```shutil.rmtree(path, ignore_errors=False, onerror=None)```",output,1,1415 |
| recursively remove folder `name`,instruction,0,1416 |
| ```os.removedirs(name)```,output,1,1416 |
| "Add row `['8/19/2014', 'Jun', 'Fly', '98765']` to dataframe `df`",instruction,0,1417 |
| "```df.loc[len(df)] = ['8/19/2014', 'Jun', 'Fly', '98765']```",output,1,1417 |
| list all files in a current directory,instruction,0,1418 |
| ```glob.glob('*')```,output,1,1418 |
| List all the files that doesn't contain the name `hello`,instruction,0,1419 |
| ```glob.glob('[!hello]*.txt')```,output,1,1419 |
| List all the files that matches the pattern `hello*.txt`,instruction,0,1420 |
| ```glob.glob('hello*.txt')```,output,1,1420 |
| evaluate the expression '20<30',instruction,0,1421 |
| ```eval('20<30')```,output,1,1421 |
| Copy list `old_list` and name it `new_list`,instruction,0,1422 |
| ```new_list = [x[:] for x in old_list]```,output,1,1422 |
| convert scientific notation of variable `a` to decimal,instruction,0,1423 |
| "```""""""{:.50f}"""""".format(float(a[0] / a[1]))```",output,1,1423 |
| convert dataframe `df` to integer-type sparse object,instruction,0,1424 |
| ```df.to_sparse(0)```,output,1,1424 |
| display attribute `attr` for each object `obj` in list `my_list_of_objs`,instruction,0,1425 |
| ```print([obj.attr for obj in my_list_of_objs])```,output,1,1425 |
| count the number of True values associated with key 'success' in dictionary `d`,instruction,0,1426 |
| ```sum(1 if d['success'] else 0 for d in s)```,output,1,1426 |
| get the sum of values associated with the key ‘success’ for a list of dictionaries `s`,instruction,0,1427 |
| ```sum(d['success'] for d in s)```,output,1,1427 |
| get complete path of a module named `os`,instruction,0,1428 |
| ```imp.find_module('os')[1]```,output,1,1428 |
| get logical xor of `a` and `b`,instruction,0,1429 |
| ```(bool(a) != bool(b))```,output,1,1429 |
| get logical xor of `a` and `b`,instruction,0,1430 |
| ```((a and (not b)) or ((not a) and b))```,output,1,1430 |
| get logical xor of `a` and `b`,instruction,0,1431 |
| ```(bool(a) ^ bool(b))```,output,1,1431 |
| get logical xor of `a` and `b`,instruction,0,1432 |
| "```xor(bool(a), bool(b))```",output,1,1432 |
| get the logical xor of two variables `str1` and `str2`,instruction,0,1433 |
| ```return (bool(str1) ^ bool(str2))```,output,1,1433 |
| Sort list `my_list` in alphabetical order based on the values associated with key 'name' of each dictionary in the list,instruction,0,1434 |
| ```my_list.sort(key=operator.itemgetter('name'))```,output,1,1434 |
| "split a string `a , b; cdf` using both commas and semicolons as delimeters",instruction,0,1435 |
| "```re.split('\\s*,\\s*|\\s*;\\s*', 'a , b; cdf')```",output,1,1435 |
| "Split a string `string` by multiple separators `,` and `;`",instruction,0,1436 |
| "```[t.strip() for s in string.split(',') for t in s.split(';')]```",output,1,1436 |
| make a function `f` that calculates the sum of two integer variables `x` and `y`,instruction,0,1437 |
| "```f = lambda x, y: x + y```",output,1,1437 |
| Create list `instancelist` containing 29 objects of type MyClass,instruction,0,1438 |
| ```instancelist = [MyClass() for i in range(29)]```,output,1,1438 |
| "Make a dictionary from list `f` which is in the format of four sets of ""val, key, val""",instruction,0,1439 |
| "```{f[i + 1]: [f[i], f[i + 2]] for i in range(0, len(f), 3)}```",output,1,1439 |
| convert bytes string `s` to an unsigned integer,instruction,0,1440 |
| "```struct.unpack('>q', s)[0]```",output,1,1440 |
| concatenate a series `students` onto a dataframe `marks` with pandas,instruction,0,1441 |
| "```pd.concat([students, pd.DataFrame(marks)], axis=1)```",output,1,1441 |
| Sort list `alist` in ascending order based on each of its elements' attribute `foo`,instruction,0,1442 |
| ```alist.sort(key=lambda x: x.foo)```,output,1,1442 |
| BeautifulSoup select 'div' elements with an id attribute value ending with sub-string '_answer' in HTML parsed string `soup`,instruction,0,1443 |
| ```soup.select('div[id$=_answer]')```,output,1,1443 |
| "sympy solve matrix of linear equations `(([1, 1, 1, 1], [1, 1, 2, 3]))` with variables `(x, y, z)`",instruction,0,1444 |
| "```linsolve(Matrix(([1, 1, 1, 1], [1, 1, 2, 3])), (x, y, z))```",output,1,1444 |
| "best way to extract subset of key-value pairs with keys matching 'l', 'm', or 'n' from python dictionary object",instruction,0,1445 |
| "```{k: bigdict[k] for k in list(bigdict.keys()) & {'l', 'm', 'n'}}```",output,1,1445 |
| "extract subset of key-value pairs with keys as `('l', 'm', 'n')` from dictionary object `bigdict`",instruction,0,1446 |
| "```dict((k, bigdict[k]) for k in ('l', 'm', 'n'))```",output,1,1446 |
| "Get items from a dictionary `bigdict` where the keys are present in `('l', 'm', 'n')`",instruction,0,1447 |
| "```{k: bigdict.get(k, None) for k in ('l', 'm', 'n')}```",output,1,1447 |
| "Extract subset of key value pair for keys 'l', 'm', 'n' from `bigdict` in python 3",instruction,0,1448 |
| "```{k: bigdict[k] for k in ('l', 'm', 'n')}```",output,1,1448 |
| Selenium get the entire `driver` page text,instruction,0,1449 |
| ```driver.page_source```,output,1,1449 |
| extracting column `1` and `9` from array `data`,instruction,0,1450 |
| "```data[:, ([1, 9])]```",output,1,1450 |
| remove all square brackets from string 'abcd[e]yth[ac]ytwec',instruction,0,1451 |
| "```re.sub('\\[.*?\\]', '', 'abcd[e]yth[ac]ytwec')```",output,1,1451 |
| ,instruction,0,1452 |
| ```root.geometry('500x500')```,output,1,1452 |
| find all substrings in string `mystring` composed only of letters `a` and `b` where each `a` is directly preceded and succeeded by `b`,instruction,0,1453 |
| "```re.findall('\\b(?:b+a)+b+\\b', mystring)```",output,1,1453 |
| convert list `lst` of tuples of floats to list `str_list` of tuples of strings of floats in scientific notation with eight decimal point precision,instruction,0,1454 |
| ```str_list = [tuple('{0:.8e}'.format(flt) for flt in sublist) for sublist in lst]```,output,1,1454 |
| convert list of sublists `lst` of floats to a list of sublists `str_list` of strings of integers in scientific notation with 8 decimal points,instruction,0,1455 |
| ```str_list = [['{0:.8e}'.format(flt) for flt in sublist] for sublist in lst]```,output,1,1455 |
| Create a tuple `t` containing first element of each tuple in tuple `s`,instruction,0,1456 |
| ```t = tuple(x[0] for x in s)```,output,1,1456 |
| obtain the current day of the week in a 3 letter format from a datetime object,instruction,0,1457 |
| ```datetime.datetime.now().strftime('%a')```,output,1,1457 |
| get the ASCII value of a character 'a' as an int,instruction,0,1458 |
| ```ord('a')```,output,1,1458 |
| get the ASCII value of a character u'あ' as an int,instruction,0,1459 |
| ```ord('\u3042')```,output,1,1459 |
| get the ASCII value of a character as an int,instruction,0,1460 |
| ```ord()```,output,1,1460 |
| decode JSON string `u` to a dictionary,instruction,0,1461 |
| ```json.load(u)```,output,1,1461 |
| "Delete mulitple columns `columnheading1`, `columnheading2` in pandas data frame `yourdf`",instruction,0,1462 |
| "```yourdf.drop(['columnheading1', 'columnheading2'], axis=1, inplace=True)```",output,1,1462 |
| get a list of of elements resulting from splitting user input by commas and stripping white space from each resulting string `s`,instruction,0,1463 |
| "```[s.strip() for s in input().split(',')]```",output,1,1463 |
| create a list containing the digits values from binary string `x` as elements,instruction,0,1464 |
| ```[int(d) for d in str(bin(x))[2:]]```,output,1,1464 |
| get the max string length in list `i`,instruction,0,1465 |
| ```max(len(word) for word in i)```,output,1,1465 |
| get the maximum string length in nested list `i`,instruction,0,1466 |
| "```len(max(i, key=len))```",output,1,1466 |
| execute os command `my_cmd`,instruction,0,1467 |
| ```os.system(my_cmd)```,output,1,1467 |
| sort list `mylist` alphabetically,instruction,0,1468 |
| ```mylist.sort(key=lambda x: x.lower())```,output,1,1468 |
| sort list `mylist` in alphabetical order,instruction,0,1469 |
| ```mylist.sort(key=str.lower)```,output,1,1469 |
| sort a list of strings 'mylist'.,instruction,0,1470 |
| ```mylist.sort()```,output,1,1470 |
| sort a list of strings `list`,instruction,0,1471 |
| ```list.sort()```,output,1,1471 |
| Set multi index on columns 'Company' and 'date' of data frame `df` in pandas.,instruction,0,1472 |
| "```df.set_index(['Company', 'date'], inplace=True)```",output,1,1472 |
| get the attribute `x` from object `your_obj`,instruction,0,1473 |
| "```getattr(your_obj, x)```",output,1,1473 |
| remove first word in string `s`,instruction,0,1474 |
| "```s.split(' ', 1)[1]```",output,1,1474 |
| save xlsxwriter file in 'app/smth1/smth2/Expenses01.xlsx' path and assign to variable `workbook`,instruction,0,1475 |
| ```workbook = xlsxwriter.Workbook('app/smth1/smth2/Expenses01.xlsx')```,output,1,1475 |
| save xlsxwriter file to 'C:/Users/Steven/Documents/demo.xlsx' path,instruction,0,1476 |
| ```workbook = xlsxwriter.Workbook('C:/Users/Steven/Documents/demo.xlsx')```,output,1,1476 |
| change legend size to 'x-small' in upper-left location,instruction,0,1477 |
| "```pyplot.legend(loc=2, fontsize='x-small')```",output,1,1477 |
| change legend font size with matplotlib.pyplot to 6,instruction,0,1478 |
| "```plot.legend(loc=2, prop={'size': 6})```",output,1,1478 |
| split list `l` into `n` sized lists,instruction,0,1479 |
| "```[l[i:i + n] for i in range(0, len(l), n)]```",output,1,1479 |
| split a list `l` into evenly sized chunks `n`,instruction,0,1480 |
| "```[l[i:i + n] for i in range(0, len(l), n)]```",output,1,1480 |
| check if character '-' exists in a dataframe `df` cell 'a',instruction,0,1481 |
| ```df['a'].str.contains('-')```,output,1,1481 |
| "remove all non -word, -whitespace, or -apostrophe characters from string `doesn't this mean it -technically- works?`",instruction,0,1482 |
| "```re.sub(""[^\\w' ]"", '', ""doesn't this mean it -technically- works?"")```",output,1,1482 |
| find all digits between two characters `\xab` and `\xbb`in a string `text`,instruction,0,1483 |
| "```print(re.findall('\\d+', '\n'.join(re.findall('\xab([\\s\\S]*?)\xbb', text))))```",output,1,1483 |
| plot data of column 'index' versus column 'A' of dataframe `monthly_mean` after resetting its index,instruction,0,1484 |
| "```monthly_mean.reset_index().plot(x='index', y='A')```",output,1,1484 |
| "get the output of a subprocess command `echo ""foo""` in command line",instruction,0,1485 |
| "```subprocess.check_output('echo ""foo""', shell=True)```",output,1,1485 |
| Encode each value to 'UTF8' in the list `EmployeeList`,instruction,0,1486 |
| ```[x.encode('UTF8') for x in EmployeeList]```,output,1,1486 |
| combine two columns `foo` and `bar` in a pandas data frame,instruction,0,1487 |
| "```pandas.concat([df['foo'].dropna(), df['bar'].dropna()]).reindex_like(df)```",output,1,1487 |
| generate a list of consecutive integers from 0 to 8,instruction,0,1488 |
| ```list(range(9))```,output,1,1488 |
| convert list `myintegers` into a unicode string,instruction,0,1489 |
| "```"""""""""""".join(chr(i) for i in myintegers)```",output,1,1489 |
| inherit from class `Executive`,instruction,0,1490 |
| "```super(Executive, self).__init__(*args)```",output,1,1490 |
| Remove the string value `item` from a list of strings `my_sequence`,instruction,0,1491 |
| ```[item for item in my_sequence if item != 'item']```,output,1,1491 |
| randomly select an item from list `foo`,instruction,0,1492 |
| ```random.choice(foo)```,output,1,1492 |
| "check if all of the following items in list `['a', 'b']` are in a list `['a', 'b', 'c']`",instruction,0,1493 |
| "```set(['a', 'b']).issubset(['a', 'b', 'c'])```",output,1,1493 |
| "Check if all the items in a list `['a', 'b']` exists in another list `l`",instruction,0,1494 |
| "```set(['a', 'b']).issubset(set(l))```",output,1,1494 |
| set the stdin of the process 'grep f' to be b'one\ntwo\nthree\nfour\nfive\nsix\n',instruction,0,1495 |
| "```p = Popen(['grep', 'f'], stdout=PIPE, stdin=PIPE, stderr=STDOUT) |
| grep_stdout = p.communicate(input='one\ntwo\nthree\nfour\nfive\nsix\n')[0]```",output,1,1495 |
| set the stdin of the process 'grep f' to be 'one\ntwo\nthree\nfour\nfive\nsix\n',instruction,0,1496 |
| "```p = subprocess.Popen(['grep', 'f'], stdout=subprocess.PIPE, stdin=subprocess.PIPE) |
| p.stdin.write('one\ntwo\nthree\nfour\nfive\nsix\n') |
| p.communicate()[0] |
| p.stdin.close()```",output,1,1496 |
| to convert a list of tuples `list_of_tuples` into list of lists,instruction,0,1497 |
| ```[list(t) for t in zip(*list_of_tuples)]```,output,1,1497 |
| group a list `list_of_tuples` of tuples by values,instruction,0,1498 |
| ```zip(*list_of_tuples)```,output,1,1498 |
| merge pandas dataframe `x` with columns 'a' and 'b' and dataframe `y` with column 'y',instruction,0,1499 |
| "```pd.merge(y, x, on='k')[['a', 'b', 'y']]```",output,1,1499 |
| "Split string with comma (,) and remove whitespace from a string 'my_string'",instruction,0,1500 |
| "```[item.strip() for item in my_string.split(',')]```",output,1,1500 |
| Get all object attributes of object `obj`,instruction,0,1501 |
| ```print((obj.__dict__))```,output,1,1501 |
| Get all object attributes of an object,instruction,0,1502 |
| ```dir()```,output,1,1502 |
| Get all object attributes of an object,instruction,0,1503 |
| ```dir()```,output,1,1503 |
| pygobject center window `window`,instruction,0,1504 |
| ```window.set_position(Gtk.WindowPosition.CENTER)```,output,1,1504 |
| change the size of the sci notation to '30' above the y axis in matplotlib `plt`,instruction,0,1505 |
| "```plt.rc('font', **{'size': '30'})```",output,1,1505 |
| check if datafram `df` has any NaN vlaues,instruction,0,1506 |
| ```df.isnull().values.any()```,output,1,1506 |
| unpack the arguments out of list `params` to function `some_func`,instruction,0,1507 |
| ```some_func(*params)```,output,1,1507 |
| decode encodeuricomponent in GAE,instruction,0,1508 |
| ```urllib.parse.unquote(h.path.encode('utf-8')).decode('utf-8')```,output,1,1508 |
| get proportion of rows in dataframe `trace_df` whose values for column `ratio` are greater than 0,instruction,0,1509 |
| ```(trace_df['ratio'] > 0).mean()```,output,1,1509 |
| convert a set of tuples `queryresult` to a string `emaillist`,instruction,0,1510 |
| ```emaillist = '\n'.join(item[0] for item in queryresult)```,output,1,1510 |
| convert a set of tuples `queryresult` to a list of strings,instruction,0,1511 |
| ```[item[0] for item in queryresult]```,output,1,1511 |
| convert a list of tuples `queryresult` to a string from the first indexes.,instruction,0,1512 |
| ```emaillist = '\n'.join([item[0] for item in queryresult])```,output,1,1512 |
| get the widget which has currently the focus in tkinter instance `window2`,instruction,0,1513 |
| "```print(('focus object class:', window2.focus_get().__class__))```",output,1,1513 |
| Initialize a list `a` with `10000` items and each item's value `0`,instruction,0,1514 |
| ```a = [0] * 10000```,output,1,1514 |
| Keep only unique words in list of words `words` and join into string,instruction,0,1515 |
| "```print(' '.join(sorted(set(words), key=words.index)))```",output,1,1515 |
| generate 6 random numbers between 1 and 50,instruction,0,1516 |
| "```random.sample(range(1, 50), 6)```",output,1,1516 |
| generate six unique random numbers in the range of 1 to 49.,instruction,0,1517 |
| "```random.sample(range(1, 50), 6)```",output,1,1517 |
| lowercase keys and values in dictionary `{'My Key': 'My Value'}`,instruction,0,1518 |
| "```{k.lower(): v.lower() for k, v in list({'My Key': 'My Value'}.items())}```",output,1,1518 |
| lowercase all keys and values in dictionary `{'My Key': 'My Value'}`,instruction,0,1519 |
| "```dict((k.lower(), v) for k, v in {'My Key': 'My Value'}.items())```",output,1,1519 |
| "Convert each key,value pair in a dictionary `{'My Key': 'My Value'}` to lowercase",instruction,0,1520 |
| "```dict((k.lower(), v.lower()) for k, v in {'My Key': 'My Value'}.items())```",output,1,1520 |
| sorting the lists in list of lists `data`,instruction,0,1521 |
| ```[sorted(item) for item in data]```,output,1,1521 |
| SQLite get a list of column names from cursor object `cursor`,instruction,0,1522 |
| "```names = list(map(lambda x: x[0], cursor.description))```",output,1,1522 |
| get the absolute path of a running python script,instruction,0,1523 |
| ```os.path.abspath(__file__)```,output,1,1523 |
| sort 2d array `matrix` by row with index 1,instruction,0,1524 |
| "```sorted(matrix, key=itemgetter(1))```",output,1,1524 |
| Get all indexes of a letter `e` from a string `word`,instruction,0,1525 |
| "```[index for index, letter in enumerate(word) if letter == 'e']```",output,1,1525 |
| decode utf-8 code `x` into a raw unicode literal,instruction,0,1526 |
| ```print(str(x).decode('raw_unicode_escape'))```,output,1,1526 |
| split string 'abcdefg' into a list of characters,instruction,0,1527 |
| "```re.findall('\\w', 'abcdefg')```",output,1,1527 |
| check whether a file `fname` exists,instruction,0,1528 |
| ```os.path.isfile(fname)```,output,1,1528 |
| "check whether file ""/path/to/file"" exists",instruction,0,1529 |
| "```my_file = Path('/path/to/file') |
| if my_file.is_file(): |
| pass```",output,1,1529 |
| check whether file `file_path` exists,instruction,0,1530 |
| ```os.path.exists(file_path)```,output,1,1530 |
| "check whether a file ""/etc/password.txt"" exists",instruction,0,1531 |
| ```print(os.path.isfile('/etc/password.txt'))```,output,1,1531 |
| "check whether a file ""/etc"" exists",instruction,0,1532 |
| ```print(os.path.isfile('/etc'))```,output,1,1532 |
| "check whether a path ""/does/not/exist"" exists",instruction,0,1533 |
| ```print(os.path.exists('/does/not/exist'))```,output,1,1533 |
| "check whether a file ""/does/not/exist"" exists",instruction,0,1534 |
| ```print(os.path.isfile('/does/not/exist'))```,output,1,1534 |
| "check whether a path ""/etc"" exists",instruction,0,1535 |
| ```print(os.path.exists('/etc'))```,output,1,1535 |
| "check whether a path ""/etc/password.txt"" exists",instruction,0,1536 |
| ```print(os.path.exists('/etc/password.txt'))```,output,1,1536 |
| "split string ""a;bcd,ef g"" on delimiters ';' and ','",instruction,0,1537 |
| "```""""""a;bcd,ef g"""""".replace(';', ' ').replace(',', ' ').split()```",output,1,1537 |
| get a list each value `i` in the implicit tuple `range(3)`,instruction,0,1538 |
| ```list(i for i in range(3))```,output,1,1538 |
| add field names as headers in csv constructor `writer`,instruction,0,1539 |
| ```writer.writeheader()```,output,1,1539 |
| flatten a tuple `l`,instruction,0,1540 |
| "```[(a, b, c) for a, (b, c) in l]```",output,1,1540 |
| convert 3652458 to string represent a 32bit hex number,instruction,0,1541 |
| "```""""""0x{0:08X}"""""".format(3652458)```",output,1,1541 |
| convert a python dictionary `d` to a list of tuples,instruction,0,1542 |
| "```[(v, k) for k, v in list(d.items())]```",output,1,1542 |
| convert dictionary of pairs `d` to a list of tuples,instruction,0,1543 |
| "```[(v, k) for k, v in d.items()]```",output,1,1543 |
| convert python 2 dictionary `a` to a list of tuples where the value is the first tuple element and the key is the second tuple element,instruction,0,1544 |
| "```[(v, k) for k, v in a.items()]```",output,1,1544 |
| convert a python dictionary 'a' to a list of tuples,instruction,0,1545 |
| "```[(k, v) for k, v in a.items()]```",output,1,1545 |
| "convert a list of hex byte strings `['BB', 'A7', 'F6', '9E']` to a list of hex integers",instruction,0,1546 |
| "```[int(x, 16) for x in ['BB', 'A7', 'F6', '9E']]```",output,1,1546 |
| convert the elements of list `L` from hex byte strings to hex integers,instruction,0,1547 |
| "```[int(x, 16) for x in L]```",output,1,1547 |
| "assign values to two variables, `var1` and `var2` from user input response to `'Enter two numbers here: ` split on whitespace",instruction,0,1548 |
| "```var1, var2 = input('Enter two numbers here: ').split()```",output,1,1548 |
| Filter a json from a key-value pair as `{'fixed_key_1': 'foo2'}` in Django,instruction,0,1549 |
| ```Test.objects.filter(actions__contains=[{'fixed_key_1': 'foo2'}])```,output,1,1549 |
| create a list containing a four elements long tuples of permutations of binary values,instruction,0,1550 |
| "```itertools.product(list(range(2)), repeat=4)```",output,1,1550 |
| get yesterday's date as a string in `YYYY-MM-DD` format using timedelta,instruction,0,1551 |
| ```(datetime.now() - timedelta(1)).strftime('%Y-%m-%d')```,output,1,1551 |
| "Get the dot product of matrix `[1,0,0,1,0,0]` and matrix `[[0,1],[1,1],[1,0],[1,0],[1,1],[0,1]]`",instruction,0,1552 |
| "```np.dot([1, 0, 0, 1, 0, 0], [[0, 1], [1, 1], [1, 0], [1, 0], [1, 1], [0, 1]])```",output,1,1552 |
| convert date strings in pandas dataframe column`df['date']` to pandas timestamps using the format '%d%b%Y',instruction,0,1553 |
| "```df['date'] = pd.to_datetime(df['date'], format='%d%b%Y')```",output,1,1553 |
| Importing file `file` from folder '/path/to/application/app/folder',instruction,0,1554 |
| "```sys.path.insert(0, '/path/to/application/app/folder') |
| import file```",output,1,1554 |
| do a `left` merge of dataframes `x` and `y` on the column `state` and sort by `index`,instruction,0,1555 |
| "```x.reset_index().merge(y, how='left', on='state', sort=False).sort('index')```",output,1,1555 |
| Create a default empty json object if no json is available in request parameter `mydata`,instruction,0,1556 |
| "```json.loads(request.POST.get('mydata', '{}'))```",output,1,1556 |
| "get a list of tuples of every three consecutive items in list `[1, 2, 3, 4, 5, 6, 7, 8, 9]`",instruction,0,1557 |
| "```list(zip(*((iter([1, 2, 3, 4, 5, 6, 7, 8, 9]),) * 3)))```",output,1,1557 |
| "slice list `[1, 2, 3, 4, 5, 6, 7]` into lists of two elements each",instruction,0,1558 |
| "```list(grouper(2, [1, 2, 3, 4, 5, 6, 7]))```",output,1,1558 |
| ,instruction,0,1559 |
| "```[input[i:i + n] for i in range(0, len(input), n)]```",output,1,1559 |
| Sort list `keys` based on its elements' dot-seperated numbers,instruction,0,1560 |
| "```keys.sort(key=lambda x: map(int, x.split('.')))```",output,1,1560 |
| Sort a list of integers `keys` where each value is in string format,instruction,0,1561 |
| ```keys.sort(key=lambda x: [int(y) for y in x.split('.')])```,output,1,1561 |
| convert a 3d array `img` of dimensions 4x2x3 to a 2d array of dimensions 3x8,instruction,0,1562 |
| "```img.transpose(2, 0, 1).reshape(3, -1)```",output,1,1562 |
| replacing 'ABC' and 'AB' values in column 'BrandName' of dataframe `df` with 'A',instruction,0,1563 |
| "```df['BrandName'].replace(['ABC', 'AB'], 'A')```",output,1,1563 |
| "replace values `['ABC', 'AB']` in a column 'BrandName' of pandas dataframe `df` with another value 'A'",instruction,0,1564 |
| "```df['BrandName'] = df['BrandName'].replace(['ABC', 'AB'], 'A')```",output,1,1564 |
| Subtract the mean of each row in dataframe `df` from the corresponding row's elements,instruction,0,1565 |
| "```df.sub(df.mean(axis=1), axis=0)```",output,1,1565 |
| remove all non-alphabet chars from string `s`,instruction,0,1566 |
| "```"""""""""""".join([i for i in s if i.isalpha()])```",output,1,1566 |
| split a string `s` into integers,instruction,0,1567 |
| ```l = (int(x) for x in s.split())```,output,1,1567 |
| split a string `42 0` by white spaces.,instruction,0,1568 |
| "```""""""42 0"""""".split()```",output,1,1568 |
| ,instruction,0,1569 |
| "```map(int, '42 0'.split())```",output,1,1569 |
| get indexes of all true boolean values from a list `bool_list`,instruction,0,1570 |
| "```[i for i, elem in enumerate(bool_list, 1) if elem]```",output,1,1570 |
| group dataframe `data` entries by year value of the date in column 'date',instruction,0,1571 |
| ```data.groupby(data['date'].map(lambda x: x.year))```,output,1,1571 |
| Get the indices in array `b` of each element appearing in array `a`,instruction,0,1572 |
| "```np.in1d(b, a).nonzero()[0]```",output,1,1572 |
| display current time in readable format,instruction,0,1573 |
| "```time.strftime('%l:%M%p %z on %b %d, %Y')```",output,1,1573 |
| rotate x-axis text labels of plot `ax` 45 degrees,instruction,0,1574 |
| "```ax.set_xticklabels(ax.xaxis.get_majorticklabels(), rotation=45)```",output,1,1574 |
| "append array of strings `['x', 'x', 'x']` into one string",instruction,0,1575 |
| "```"""""""""""".join(['x', 'x', 'x'])```",output,1,1575 |
| retrieve all items in an numpy array 'x' except the item of the index 1,instruction,0,1576 |
| "```x[(np.arange(x.shape[0]) != 1), :, :]```",output,1,1576 |
| pull a value with key 'name' from a json object `item`,instruction,0,1577 |
| ```print(item['name'])```,output,1,1577 |
| read a file from redirected stdin and save to variable `result`,instruction,0,1578 |
| ```result = sys.stdin.read()```,output,1,1578 |
| Get all the texts without tags from beautiful soup object `soup`,instruction,0,1579 |
| "```"""""""""""".join(soup.findAll(text=True))```",output,1,1579 |
| extract all rows from dataframe `data` where the value of column 'Value' is True,instruction,0,1580 |
| ```data[data['Value'] == True]```,output,1,1580 |
| "removing duplicate characters from a string variable ""foo""",instruction,0,1581 |
| "```"""""""""""".join(set(foo))```",output,1,1581 |
| sort objects in model `Profile` based on Theirs `reputation` attribute,instruction,0,1582 |
| "```sorted(Profile.objects.all(), key=lambda p: p.reputation)```",output,1,1582 |
| flatten a dataframe df to a list,instruction,0,1583 |
| ```df.values.flatten()```,output,1,1583 |
| sort list `users` using values associated with key 'id' according to elements in list `order`,instruction,0,1584 |
| ```users.sort(key=lambda x: order.index(x['id']))```,output,1,1584 |
| sort a python list of dictionaries `users` by a given list `order` of ids 'id' with the desired order,instruction,0,1585 |
| ```users.sort(key=lambda x: order.index(x['id']))```,output,1,1585 |
| request URI '<MY_URI>' and pass authorization token 'TOK:<MY_TOKEN>' to the header,instruction,0,1586 |
| "```r = requests.get('<MY_URI>', headers={'Authorization': 'TOK:<MY_TOKEN>'})```",output,1,1586 |
| "un-escape a backslash-escaped string in `Hello,\\nworld!`",instruction,0,1587 |
| "```print('""Hello,\\nworld!""'.decode('string_escape'))```",output,1,1587 |
| match regex pattern 'a*?bc*?' on string 'aabcc' with DOTALL enabled,instruction,0,1588 |
| "```re.findall('a*?bc*?', 'aabcc', re.DOTALL)```",output,1,1588 |
| get second array column length of array `a`,instruction,0,1589 |
| ```a.shape[1]```,output,1,1589 |
| use operations like max/min within a row to a dataframe 'd' in pandas,instruction,0,1590 |
| "```d.apply(lambda row: min([row['A'], row['B']]) - row['C'], axis=1)```",output,1,1590 |
| "count number of occurrences of a substring 'ab' in a string ""abcdabcva""",instruction,0,1591 |
| "```""""""abcdabcva"""""".count('ab')```",output,1,1591 |
| get a list of values with key 'key' from a list of dictionaries `l`,instruction,0,1592 |
| ```[d['key'] for d in l if 'key' in d]```,output,1,1592 |
| get a list of values for key 'key' from a list of dictionaries `l`,instruction,0,1593 |
| ```[d['key'] for d in l]```,output,1,1593 |
| "get a list of values for key ""key"" from a list of dictionaries in `l`",instruction,0,1594 |
| ```[d['key'] for d in l]```,output,1,1594 |
| order a list of lists `l1` by the first value,instruction,0,1595 |
| ```l1.sort(key=lambda x: int(x[0]))```,output,1,1595 |
| "order a list of lists `[[1, 'mike'], [1, 'bob']]` by the first value of individual list",instruction,0,1596 |
| "```sorted([[1, 'mike'], [1, 'bob']])```",output,1,1596 |
| replace a string `Abc` in case sensitive way using maketrans,instruction,0,1597 |
| "```""""""Abc"""""".translate(maketrans('abcABC', 'defDEF'))```",output,1,1597 |
| "dictionary `d` to string, custom format",instruction,0,1598 |
| "```""""""<br/>"""""".join([('%s:: %s' % (key, value)) for key, value in list(d.items())])```",output,1,1598 |
| ,instruction,0,1599 |
| ```self.writer.writerow([str(s).encode('utf-8') for s in row])```,output,1,1599 |
| clear terminal screen on windows,instruction,0,1600 |
| ```os.system('cls')```,output,1,1600 |
| clear the terminal screen in Linux,instruction,0,1601 |
| ```os.system('clear')```,output,1,1601 |
| execute external commands/script `your_own_script` with csh instead of bash,instruction,0,1602 |
| ```os.system('tcsh your_own_script')```,output,1,1602 |
| execute command 'echo $0' in Z shell,instruction,0,1603 |
| "```os.system(""zsh -c 'echo $0'"")```",output,1,1603 |
| update a list `l1` dictionaries with a key `count` and value from list `l2`,instruction,0,1604 |
| "```[dict(d, count=n) for d, n in zip(l1, l2)]```",output,1,1604 |
| create a list with the sum of respective elements of the tuples of list `l`,instruction,0,1605 |
| ```[sum(x) for x in zip(*l)]```,output,1,1605 |
| sum each value in a list `l` of tuples,instruction,0,1606 |
| "```map(sum, zip(*l))```",output,1,1606 |
| count the number of non-nan elements in a numpy ndarray matrix `data`,instruction,0,1607 |
| ```np.count_nonzero(~np.isnan(data))```,output,1,1607 |
| Convert each list in list `main_list` into a tuple,instruction,0,1608 |
| "```map(list, zip(*main_list))```",output,1,1608 |
| "django get the value of key 'title' from POST request `request` if exists, else return empty string ''",instruction,0,1609 |
| "```request.POST.get('title', '')```",output,1,1609 |
| "check if string `test.mp3` ends with one of the strings from a tuple `('.mp3', '.avi')`",instruction,0,1610 |
| "```""""""test.mp3"""""".endswith(('.mp3', '.avi'))```",output,1,1610 |
| split a string 's' by space while ignoring spaces within square braces and quotes.,instruction,0,1611 |
| "```re.findall('\\[[^\\]]*\\]|""[^""]*""|\\S+', s)```",output,1,1611 |
| get biggest 3 values from each column of the pandas dataframe `data`,instruction,0,1612 |
| "```data.apply(lambda x: sorted(x, 3))```",output,1,1612 |
| permanently set the current directory to the 'C:/Users/Name/Desktop',instruction,0,1613 |
| ```os.chdir('C:/Users/Name/Desktop')```,output,1,1613 |
| get all characters between two `$` characters in string `string`,instruction,0,1614 |
| "```re.findall('\\$([^$]*)\\$', string)```",output,1,1614 |
| getting the string between 2 '$' characters in '$sin (x)$ is an function of x',instruction,0,1615 |
| "```re.findall('\\$(.*?)\\$', '$sin (x)$ is an function of x')```",output,1,1615 |
| Format a date object `str_data` into iso fomrat,instruction,0,1616 |
| "```datetime.datetime.strptime(str_date, '%m/%d/%Y').date().isoformat()```",output,1,1616 |
| get element at index 0 of first row and element at index 1 of second row in array `A`,instruction,0,1617 |
| "```A[[0, 1], [0, 1]]```",output,1,1617 |
| "subset numpy array `a` by column and row, returning the values from the first row, first column and the second row, second column and the third row, first column.",instruction,0,1618 |
| "```a[np.arange(3), (0, 1, 0)]```",output,1,1618 |
| Get a list of all keys from dictionary `dictA` where the number of occurrences of value `duck` in that key is more than `1`,instruction,0,1619 |
| "```[k for k, v in dictA.items() if v.count('duck') > 1]```",output,1,1619 |
| "Create sub matrix of a list of lists `[[2, 3, 4], [2, 3, 4], [2, 3, 4]]` (without numpy)",instruction,0,1620 |
| "```[[2, 3, 4], [2, 3, 4], [2, 3, 4]]```",output,1,1620 |
| "get an element at index `[1,1]`in a numpy array `arr`",instruction,0,1621 |
| "```print(arr[1, 1])```",output,1,1621 |
| Set colorbar range from `0` to `15` for pyplot object `quadmesh` in matplotlib,instruction,0,1622 |
| "```quadmesh.set_clim(vmin=0, vmax=15)```",output,1,1622 |
| read csv file 'my_file.csv' into numpy array,instruction,0,1623 |
| "```my_data = genfromtxt('my_file.csv', delimiter=',')```",output,1,1623 |
| read csv file 'myfile.csv' into array,instruction,0,1624 |
| "```df = pd.read_csv('myfile.csv', sep=',', header=None)```",output,1,1624 |
| read csv file 'myfile.csv' into array,instruction,0,1625 |
| "```np.genfromtxt('myfile.csv', delimiter=',')```",output,1,1625 |
| read csv file 'myfile.csv' into array,instruction,0,1626 |
| "```np.genfromtxt('myfile.csv', delimiter=',', dtype=None)```",output,1,1626 |
| read the first line of a string `my_string`,instruction,0,1627 |
| ```my_string.splitlines()[0]```,output,1,1627 |
| ,instruction,0,1628 |
| "```my_string.split('\n', 1)[0]```",output,1,1628 |
| generate a list from a pandas dataframe `df` with the column name and column values,instruction,0,1629 |
| ```df.values.tolist()```,output,1,1629 |
| Replace repeated instances of a character '*' with a single instance in a string 'text',instruction,0,1630 |
| "```re.sub('\\*\\*+', '*', text)```",output,1,1630 |
| "replace repeated instances of ""*"" with a single instance of ""*""",instruction,0,1631 |
| "```re.sub('\\*+', '*', text)```",output,1,1631 |
| multiply values of dictionary `dict` with their respective values in dictionary `dict2`,instruction,0,1632 |
| "```dict((k, v * dict2[k]) for k, v in list(dict1.items()) if k in dict2)```",output,1,1632 |
| Get a random string of length `length`,instruction,0,1633 |
| ```return ''.join(random.choice(string.lowercase) for i in range(length))```,output,1,1633 |
| Get total number of values in a nested dictionary `food_colors`,instruction,0,1634 |
| ```sum(len(x) for x in list(food_colors.values()))```,output,1,1634 |
| count all elements in a nested dictionary `food_colors`,instruction,0,1635 |
| ```sum(len(v) for v in food_colors.values())```,output,1,1635 |
| apply logical operator 'AND' to all elements in list `a_list`,instruction,0,1636 |
| ```all(a_list)```,output,1,1636 |
| removing vowel characters 'aeiouAEIOU' from string `text`,instruction,0,1637 |
| "```"""""""""""".join(c for c in text if c not in 'aeiouAEIOU')```",output,1,1637 |
| Divide elements in list `a` from elements at the same index in list `b`,instruction,0,1638 |
| "```[(x / y) for x, y in zip(a, b)]```",output,1,1638 |
| match regex 'abc(de)fg(123)' on string 'abcdefg123 and again abcdefg123',instruction,0,1639 |
| "```re.findall('abc(de)fg(123)', 'abcdefg123 and again abcdefg123')```",output,1,1639 |
| apply function `log2` to the grouped values by 'type' in dataframe `df`,instruction,0,1640 |
| ```df.groupby('type').apply(lambda x: np.mean(np.log2(x['v'])))```,output,1,1640 |
| get geys of dictionary `my_dict` that contain any values from list `lst`,instruction,0,1641 |
| "```[key for key, value in list(my_dict.items()) if set(value).intersection(lst)]```",output,1,1641 |
| get list of keys in dictionary `my_dict` whose values contain values from list `lst`,instruction,0,1642 |
| "```[key for item in lst for key, value in list(my_dict.items()) if item in value]```",output,1,1642 |
| Sum elements of tuple `b` to their respective elements of each tuple in list `a`,instruction,0,1643 |
| "```c = [[(i + j) for i, j in zip(e, b)] for e in a]```",output,1,1643 |
| get the common prefix from comparing two absolute paths '/usr/var' and '/usr/var2/log',instruction,0,1644 |
| "```os.path.commonprefix(['/usr/var', '/usr/var2/log'])```",output,1,1644 |
| get relative path of path '/usr/var' regarding path '/usr/var/log/',instruction,0,1645 |
| "```print(os.path.relpath('/usr/var/log/', '/usr/var'))```",output,1,1645 |
| filter dataframe `grouped` where the length of each group `x` is bigger than 1,instruction,0,1646 |
| ```grouped.filter(lambda x: len(x) > 1)```,output,1,1646 |
| sort dictionary of lists `myDict` by the third item in each list,instruction,0,1647 |
| "```sorted(list(myDict.items()), key=lambda e: e[1][2])```",output,1,1647 |
| "Format string `hello {name}, how are you {name}, welcome {name}` to be interspersed by `name` three times, specifying the value as `john` only once",instruction,0,1648 |
| "```""""""hello {name}, how are you {name}, welcome {name}"""""".format(name='john')```",output,1,1648 |
| "reorder indexed rows `['Z', 'C', 'A']` based on a list in pandas data frame `df`",instruction,0,1649 |
| "```df.reindex(['Z', 'C', 'A'])```",output,1,1649 |
| check if any values in a list `input_list` is a list,instruction,0,1650 |
| "```any(isinstance(el, list) for el in input_list)```",output,1,1650 |
| get the size of list `items`,instruction,0,1651 |
| ```len(items)```,output,1,1651 |
| "get the size of a list `[1,2,3]`",instruction,0,1652 |
| "```len([1, 2, 3])```",output,1,1652 |
| get the size of object `items`,instruction,0,1653 |
| ```items.__len__()```,output,1,1653 |
| function to get the size of object,instruction,0,1654 |
| ```len()```,output,1,1654 |
| get the size of list `s`,instruction,0,1655 |
| ```len(s)```,output,1,1655 |
| sort each row in a pandas dataframe `df` in descending order,instruction,0,1656 |
| "```df.sort(axis=1, ascending=False)```",output,1,1656 |
| ,instruction,0,1657 |
| "```df.sort(df.columns, axis=1, ascending=False)```",output,1,1657 |
| get count of rows in each series grouped by column 'col5' and column 'col2' of dataframe `df`,instruction,0,1658 |
| "```df.groupby(['col5', 'col2']).size().groupby(level=1).max()```",output,1,1658 |
| "check if string 'x' is in list `['x', 'd', 'a', 's', 'd', 's']`",instruction,0,1659 |
| "```'x' in ['x', 'd', 'a', 's', 'd', 's']```",output,1,1659 |
| "Delete an item with key ""key"" from `mydict`",instruction,0,1660 |
| "```mydict.pop('key', None)```",output,1,1660 |
| Delete an item with key `key` from `mydict`,instruction,0,1661 |
| ```del mydict[key]```,output,1,1661 |
| Delete an item with key `key` from `mydict`,instruction,0,1662 |
| "```try: |
| del mydict[key] |
| except KeyError: |
| pass |
| try: |
| del mydict[key] |
| except KeyError: |
| pass```",output,1,1662 |
| specify multiple positional arguments with argparse,instruction,0,1663 |
| "```parser.add_argument('input', nargs='+')```",output,1,1663 |
| Plot using the color code `#112233` in matplotlib pyplot,instruction,0,1664 |
| "```pyplot.plot(x, y, color='#112233')```",output,1,1664 |
| strip html from strings,instruction,0,1665 |
| "```re.sub('<[^<]+?>', '', text)```",output,1,1665 |
| align values in array `b` to the order of corresponding values in array `a`,instruction,0,1666 |
| "```a[np.in1d(a, b)]```",output,1,1666 |
| "split string ""jvm.args= -Dappdynamics.com=true, -Dsomeotherparam=false,"" on the first occurrence of delimiter '='",instruction,0,1667 |
| "```""""""jvm.args= -Dappdynamics.com=true, -Dsomeotherparam=false,"""""".split('=', 1)```",output,1,1667 |
| print numbers in list `list` with precision of 3 decimal places,instruction,0,1668 |
| "```print('[%s]' % ', '.join('%.3f' % val for val in list))```",output,1,1668 |
| format print output of list of floats `l` to print only up to 3 decimal points,instruction,0,1669 |
| "```print('[' + ', '.join('%5.3f' % v for v in l) + ']')```",output,1,1669 |
| print a list of floating numbers `l` using string formatting,instruction,0,1670 |
| ```print([('%5.3f' % val) for val in l])```,output,1,1670 |
| Change the current directory one level up,instruction,0,1671 |
| ```os.chdir('..')```,output,1,1671 |
| print a unicode string `text`,instruction,0,1672 |
| ```print(text.encode('windows-1252'))```,output,1,1672 |
| convert string representation `s2` of binary string rep of integer to floating point number,instruction,0,1673 |
| "```struct.unpack('d', struct.pack('Q', int(s2, 0)))[0]```",output,1,1673 |
| convert a binary '-0b1110' to a float number,instruction,0,1674 |
| "```float(int('-0b1110', 0))```",output,1,1674 |
| convert a binary `b8` to a float number,instruction,0,1675 |
| "```struct.unpack('d', b8)[0]```",output,1,1675 |
| plot a bar graph from the column 'color' in the DataFrame 'df',instruction,0,1676 |
| ```df.colour.value_counts().plot(kind='bar')```,output,1,1676 |
| plot categorical data in series `df` with kind `bar` using pandas and matplotlib,instruction,0,1677 |
| ```df.groupby('colour').size().plot(kind='bar')```,output,1,1677 |
| strip and split each line `line` on white spaces,instruction,0,1678 |
| ```line.strip().split(' ')```,output,1,1678 |
| apply functions `mean` and `std` to each column in dataframe `df`,instruction,0,1679 |
| "```df.groupby(lambda idx: 0).agg(['mean', 'std'])```",output,1,1679 |
| sort dictionary `tag_weight` in reverse order by values cast to integers,instruction,0,1680 |
| "```sorted(list(tag_weight.items()), key=lambda x: int(x[1]), reverse=True)```",output,1,1680 |
| find the largest integer less than `x`,instruction,0,1681 |
| ```int(math.ceil(x)) - 1```,output,1,1681 |
| check if the string `myString` is empty,instruction,0,1682 |
| "```if (not myString): |
| pass```",output,1,1682 |
| check if string `some_string` is empty,instruction,0,1683 |
| "```if (not some_string): |
| pass```",output,1,1683 |
| check if string `my_string` is empty,instruction,0,1684 |
| "```if (not my_string): |
| pass```",output,1,1684 |
| check if string `my_string` is empty,instruction,0,1685 |
| "```if some_string: |
| pass```",output,1,1685 |
| iterate over a dictionary `d` in sorted order,instruction,0,1686 |
| ```it = iter(sorted(d.items()))```,output,1,1686 |
| iterate over a dictionary `d` in sorted order,instruction,0,1687 |
| "```for (key, value) in sorted(d.items()): |
| pass```",output,1,1687 |
| iterate over a dictionary `dict` in sorted order,instruction,0,1688 |
| ```return sorted(dict.items())```,output,1,1688 |
| iterate over a dictionary `dict` in sorted order,instruction,0,1689 |
| ```return iter(sorted(dict.items()))```,output,1,1689 |
| iterate over a dictionary `foo` in sorted order,instruction,0,1690 |
| "```for (k, v) in sorted(foo.items()): |
| pass```",output,1,1690 |
| iterate over a dictionary `foo` sorted by the key,instruction,0,1691 |
| "```for k in sorted(foo.keys()): |
| pass```",output,1,1691 |
| assign the index of the last occurence of `x` in list `s` to the variable `last`,instruction,0,1692 |
| ```last = len(s) - s[::-1].index(x) - 1```,output,1,1692 |
| concatenating values in `list1` to a string,instruction,0,1693 |
| ```str1 = ''.join(list1)```,output,1,1693 |
| "concatenating values in list `L` to a string, separate by space",instruction,0,1694 |
| ```' '.join((str(x) for x in L))```,output,1,1694 |
| concatenating values in `list1` to a string,instruction,0,1695 |
| ```str1 = ''.join((str(e) for e in list1))```,output,1,1695 |
| concatenating values in list `L` to a string,instruction,0,1696 |
| "```makeitastring = ''.join(map(str, L))```",output,1,1696 |
| remove None value from list `L`,instruction,0,1697 |
| ```[x for x in L if x is not None]```,output,1,1697 |
| "select a random element from array `[1, 2, 3]`",instruction,0,1698 |
| "```random.choice([1, 2, 3])```",output,1,1698 |
| creating a 5x6 matrix filled with `None` and save it as `x`,instruction,0,1699 |
| ```x = [[None for _ in range(5)] for _ in range(6)]```,output,1,1699 |
| create a new 2D array with 2 random rows from array `A`,instruction,0,1700 |
| "```A[(np.random.choice(A.shape[0], 2, replace=False)), :]```",output,1,1700 |
| create a new 2 dimensional array containing two random rows from array `A`,instruction,0,1701 |
| "```A[(np.random.randint(A.shape[0], size=2)), :]```",output,1,1701 |
| combining rows in pandas by adding their values,instruction,0,1702 |
| ```df.groupby(df.index).sum()```,output,1,1702 |
| find all `owl:Class` tags by parsing xml with namespace,instruction,0,1703 |
| ```root.findall('{http://www.w3.org/2002/07/owl#}Class')```,output,1,1703 |
| generate a random string of length `x` containing lower cased ASCII letters,instruction,0,1704 |
| "```"""""""""""".join(random.choice(string.lowercase) for x in range(X))```",output,1,1704 |
| add a path `/path/to/2014_07_13_test` to system path,instruction,0,1705 |
| ```sys.path.append('/path/to/2014_07_13_test')```,output,1,1705 |
| round number `x` to nearest integer,instruction,0,1706 |
| ```int(round(x))```,output,1,1706 |
| round number `h` to nearest integer,instruction,0,1707 |
| ```h = int(round(h))```,output,1,1707 |
| round number 32.268907563 up to 3 decimal points,instruction,0,1708 |
| "```round(32.268907563, 3)```",output,1,1708 |
| round number `value` up to `significantDigit` decimal places,instruction,0,1709 |
| "```round(value, significantDigit)```",output,1,1709 |
| round number 1.0005 up to 3 decimal places,instruction,0,1710 |
| "```round(1.0005, 3)```",output,1,1710 |
| round number 2.0005 up to 3 decimal places,instruction,0,1711 |
| "```round(2.0005, 3)```",output,1,1711 |
| round number 3.0005 up to 3 decimal places,instruction,0,1712 |
| "```round(3.0005, 3)```",output,1,1712 |
| round number 4.0005 up to 3 decimal places,instruction,0,1713 |
| "```round(4.0005, 3)```",output,1,1713 |
| round number 8.005 up to 2 decimal places,instruction,0,1714 |
| "```round(8.005, 2)```",output,1,1714 |
| round number 7.005 up to 2 decimal places,instruction,0,1715 |
| "```round(7.005, 2)```",output,1,1715 |
| round number 6.005 up to 2 decimal places,instruction,0,1716 |
| "```round(6.005, 2)```",output,1,1716 |
| round number 1.005 up to 2 decimal places,instruction,0,1717 |
| "```round(1.005, 2)```",output,1,1717 |
| fill missing value in one column 'Cat1' with the value of another column 'Cat2',instruction,0,1718 |
| ```df['Cat1'].fillna(df['Cat2'])```,output,1,1718 |
| convert the argument `date` with string formatting in logging,instruction,0,1719 |
| "```logging.info('date=%s', date)```",output,1,1719 |
| Log message of level 'info' with value of `date` in the message,instruction,0,1720 |
| ```logging.info('date={}'.format(date))```,output,1,1720 |
| convert values in dictionary `d` into integers,instruction,0,1721 |
| "```{k: int(v) for k, v in d.items()}```",output,1,1721 |
| sum elements at the same index of each list in list `lists`,instruction,0,1722 |
| "```map(sum, zip(*lists))```",output,1,1722 |
| Convert a string `s` containing hex bytes to a hex string,instruction,0,1723 |
| ```s.decode('hex')```,output,1,1723 |
| convert a string `s` containing hex bytes to a hex string,instruction,0,1724 |
| ```binascii.a2b_hex(s)```,output,1,1724 |
| send data 'HTTP/1.0 200 OK\r\n\r\n' to socket `connection`,instruction,0,1725 |
| ```connection.send('HTTP/1.0 200 established\r\n\r\n')```,output,1,1725 |
| send data 'HTTP/1.0 200 OK\r\n\r\n' to socket `connection`,instruction,0,1726 |
| ```connection.send('HTTP/1.0 200 OK\r\n\r\n')```,output,1,1726 |
| set the value of cell `['x']['C']` equal to 10 in dataframe `df`,instruction,0,1727 |
| ```df['x']['C'] = 10```,output,1,1727 |
| normalize the dataframe `df` along the rows,instruction,0,1728 |
| ```np.sqrt(np.square(df).sum(axis=1))```,output,1,1728 |
| remove identical items from list `my_list` and sort it alphabetically,instruction,0,1729 |
| ```sorted(set(my_list))```,output,1,1729 |
| find the index of the element with the maximum value from a list 'a'.,instruction,0,1730 |
| "```max(enumerate(a), key=lambda x: x[1])[0]```",output,1,1730 |
| create a list where each element is a value of the key 'Name' for each dictionary `d` in the list `thisismylist`,instruction,0,1731 |
| ```[d['Name'] for d in thisismylist]```,output,1,1731 |
| create a list of tuples with the values of keys 'Name' and 'Age' from each dictionary `d` in the list `thisismylist`,instruction,0,1732 |
| "```[(d['Name'], d['Age']) for d in thisismylist]```",output,1,1732 |
| grab one random item from a database `model` in django/postgresql,instruction,0,1733 |
| ```model.objects.all().order_by('?')[0]```,output,1,1733 |
| "run python script 'script2.py' from another python script, passing in 1 as an argument",instruction,0,1734 |
| ```os.system('script2.py 1')```,output,1,1734 |
| python regex for hyphenated words in `text`,instruction,0,1735 |
| "```re.findall('\\w+(?:-\\w+)+', text)```",output,1,1735 |
| create variable key/value pairs with argparse,instruction,0,1736 |
| "```parser.add_argument('--conf', nargs=2, action='append')```",output,1,1736 |
| Get `3` unique items from a list,instruction,0,1737 |
| "```random.sample(list(range(1, 16)), 3)```",output,1,1737 |
| sort list `strings` in alphabetical order based on the letter after percent character `%` in each element,instruction,0,1738 |
| "```strings.sort(key=lambda str: re.sub('.*%(.).*', '\\1', str))```",output,1,1738 |
| sort a list of strings `strings` based on regex match,instruction,0,1739 |
| "```strings.sort(key=lambda str: re.sub('.*%', '', str))```",output,1,1739 |
| Create list `listy` containing 3 empty lists,instruction,0,1740 |
| ```listy = [[] for i in range(3)]```,output,1,1740 |
| sort numpy float array `A` column by column,instruction,0,1741 |
| "```A = np.array(sorted(A, key=tuple))```",output,1,1741 |
| Get a list from two strings `12345` and `ab` with values as each character concatenated,instruction,0,1742 |
| ```[(x + y) for x in '12345' for y in 'ab']```,output,1,1742 |
| "trim string "" Hello """,instruction,0,1743 |
| ```' Hello '.strip()```,output,1,1743 |
| trim string `myString `,instruction,0,1744 |
| ```myString.strip()```,output,1,1744 |
| "Trimming a string "" Hello """,instruction,0,1745 |
| ```' Hello '.strip()```,output,1,1745 |
| "Trimming a string "" Hello""",instruction,0,1746 |
| ```' Hello'.strip()```,output,1,1746 |
| "Trimming a string ""Bob has a cat""",instruction,0,1747 |
| ```'Bob has a cat'.strip()```,output,1,1747 |
| "Trimming a string "" Hello """,instruction,0,1748 |
| ```' Hello '.strip()```,output,1,1748 |
| Trimming a string `str`,instruction,0,1749 |
| ```str.strip()```,output,1,1749 |
| "Trimming ""\n"" from string `myString`",instruction,0,1750 |
| ```myString.strip('\n')```,output,1,1750 |
| "left trimming ""\n\r"" from string `myString`",instruction,0,1751 |
| ```myString.lstrip('\n\r')```,output,1,1751 |
| "right trimming ""\n\t"" from string `myString`",instruction,0,1752 |
| ```myString.rstrip('\n\t')```,output,1,1752 |
| "Trimming a string "" Hello\n"" by space",instruction,0,1753 |
| ```' Hello\n'.strip(' ')```,output,1,1753 |
| "sort a list of tuples 'unsorted' based on two elements, second and third",instruction,0,1754 |
| "```sorted(unsorted, key=lambda element: (element[1], element[2]))```",output,1,1754 |
| decode string `content` to UTF-8 code,instruction,0,1755 |
| ```print(content.decode('utf8'))```,output,1,1755 |
| find the index of the maximum value in the array `arr` where the boolean condition in array `cond` is true,instruction,0,1756 |
| "```np.ma.array(np.tile(arr, 2).reshape(2, 3), mask=~cond).argmax(axis=1)```",output,1,1756 |
| "convert a dataframe `df`'s column `ID` into datetime, after removing the first and last 3 letters",instruction,0,1757 |
| ```pd.to_datetime(df.ID.str[1:-3])```,output,1,1757 |
| read CSV file 'my.csv' into a dataframe `df` with datatype of float for column 'my_column' considering character 'n/a' as NaN value,instruction,0,1758 |
| "```df = pd.read_csv('my.csv', dtype={'my_column': np.float64}, na_values=['n/a'])```",output,1,1758 |
| convert nan values to ‘n/a’ while reading rows from a csv `read_csv` with pandas,instruction,0,1759 |
| "```df = pd.read_csv('my.csv', na_values=['n/a'])```",output,1,1759 |
| create a list containing all cartesian products of elements in list `a`,instruction,0,1760 |
| ```list(itertools.product(*a))```,output,1,1760 |
| remove uppercased characters in string `s`,instruction,0,1761 |
| "```re.sub('[^A-Z]', '', s)```",output,1,1761 |
| convert string '2011221' into a DateTime object using format '%Y%W%w',instruction,0,1762 |
| "```datetime.strptime('2011221', '%Y%W%w')```",output,1,1762 |
| read file 'myfile' using encoding 'iso-8859-1',instruction,0,1763 |
| "```codecs.open('myfile', 'r', 'iso-8859-1').read()```",output,1,1763 |
| create a list containing elements from list `list` that are predicate to function `f`,instruction,0,1764 |
| ```[f(x) for x in list]```,output,1,1764 |
| regex matching 5-digit substrings not enclosed with digits in `s`,instruction,0,1765 |
| "```re.findall('(?<!\\d)\\d{5}(?!\\d)', s)```",output,1,1765 |
| create a list containing elements of list `a` if the sum of the element is greater than 10,instruction,0,1766 |
| ```[item for item in a if sum(item) > 10]```,output,1,1766 |
| convert currency string `dollars` to decimal `cents_int`,instruction,0,1767 |
| ```cents_int = int(round(float(dollars.strip('$')) * 100))```,output,1,1767 |
| remove letters from string `example_line` if the letter exist in list `bad_chars`,instruction,0,1768 |
| "```"""""""""""".join(dropwhile(lambda x: x in bad_chars, example_line[::-1]))[::-1]```",output,1,1768 |
| Creating an empty list `l`,instruction,0,1769 |
| ```l = []```,output,1,1769 |
| Creating an empty list `l`,instruction,0,1770 |
| ```l = list()```,output,1,1770 |
| Creating an empty list,instruction,0,1771 |
| ```list()```,output,1,1771 |
| Creating an empty list,instruction,0,1772 |
| ```[]```,output,1,1772 |
| properly quit a program,instruction,0,1773 |
| ```sys.exit(0)```,output,1,1773 |
| add string `-` in `4th` position of a string `s`,instruction,0,1774 |
| ```s[:4] + '-' + s[4:]```,output,1,1774 |
| append 3 lists in one list,instruction,0,1775 |
| ```[[] for i in range(3)]```,output,1,1775 |
| Initialize a list of empty lists `a` of size 3,instruction,0,1776 |
| ```a = [[] for i in range(3)]```,output,1,1776 |
| request URL `url` using http header `{'referer': my_referer}`,instruction,0,1777 |
| "```requests.get(url, headers={'referer': my_referer})```",output,1,1777 |
| "set the y axis range to `0, 1000` in subplot using pylab",instruction,0,1778 |
| "```pylab.ylim([0, 1000])```",output,1,1778 |
| convert a column of list in series `s` to dummies,instruction,0,1779 |
| ```pd.get_dummies(s.apply(pd.Series).stack()).sum(level=0)```,output,1,1779 |
| ,instruction,0,1780 |
| "```max(abs(x - y) for x, y in zip(values[1:], values[:-1]))```",output,1,1780 |
| convert a hex string `x` to string,instruction,0,1781 |
| "```y = str(int(x, 16))```",output,1,1781 |
| check if string `a` is an integer,instruction,0,1782 |
| ```a.isdigit()```,output,1,1782 |
| function to check if a string is a number,instruction,0,1783 |
| ```isdigit()```,output,1,1783 |
| check if string `b` is a number,instruction,0,1784 |
| ```b.isdigit()```,output,1,1784 |
| pandas read comma-separated CSV file `s` and skip commented lines starting with '#',instruction,0,1785 |
| "```pd.read_csv(StringIO(s), sep=',', comment='#')```",output,1,1785 |
| "pandas: change all the values of a column 'Date' into ""int(str(x)[-4:])""",instruction,0,1786 |
| ```df['Date'] = df['Date'].apply(lambda x: int(str(x)[-4:]))```,output,1,1786 |
| sum a list of numbers `list_of_nums`,instruction,0,1787 |
| ```sum(list_of_nums)```,output,1,1787 |
| Get an item from a list of dictionary `lst` which has maximum value in the key `score` using lambda function,instruction,0,1788 |
| "```max(lst, key=lambda x: x['score'])```",output,1,1788 |
| BeautifulSoup find all tags with attribute 'name' equal to 'description',instruction,0,1789 |
| ```soup.findAll(attrs={'name': 'description'})```,output,1,1789 |
| "remove all spaces from a string converted from dictionary `{'a': 1, 'b': 'as df'}`",instruction,0,1790 |
| "```str({'a': 1, 'b': 'as df'}).replace(': ', ':').replace(', ', ',')```",output,1,1790 |
| convert dictionary `dict` into a string formatted object,instruction,0,1791 |
| "```'{' + ','.join('{0!r}:{1!r}'.format(*x) for x in list(dct.items())) + '}'```",output,1,1791 |
| concatenate items from list `parts` into a string starting from the second element,instruction,0,1792 |
| "```"""""""""""".join(parts[1:])```",output,1,1792 |
| "insert a character ',' into a string in front of '+' character in second part of the string",instruction,0,1793 |
| "```"""""",+"""""".join(c.rsplit('+', 1))```",output,1,1793 |
| delete all rows in a numpy array `a` where any value in a row is zero `0`,instruction,0,1794 |
| "```a[np.all(a != 0, axis=1)]```",output,1,1794 |
| extract only alphabetic characters from a string `your string`,instruction,0,1795 |
| "```"""""" """""".join(re.split('[^a-zA-Z]*', 'your string'))```",output,1,1795 |
| Extract only characters from a string as a list,instruction,0,1796 |
| "```re.split('[^a-zA-Z]*', 'your string')```",output,1,1796 |
| get the union set from list of lists `results_list`,instruction,0,1797 |
| ```results_union = set().union(*results_list)```,output,1,1797 |
| get the union of values in list of lists `result_list`,instruction,0,1798 |
| ```return list(set(itertools.chain(*result_list)))```,output,1,1798 |
| check if a numpy array `a1` contains any element of another array `a2`,instruction,0,1799 |
| "```np.any(np.in1d(a1, a2))```",output,1,1799 |
| removing control characters from a string `s`,instruction,0,1800 |
| ```return ''.join(ch for ch in s if unicodedata.category(ch)[0] != 'C')```,output,1,1800 |
| Compare if each value in list `a` is less than respective index value in list `b`,instruction,0,1801 |
| "```all(i < j for i, j in zip(a, b))```",output,1,1801 |
| python selenium click on button '.button.c_button.s_button',instruction,0,1802 |
| ```driver.find_element_by_css_selector('.button.c_button.s_button').click()```,output,1,1802 |
| ,instruction,0,1803 |
| ```driver.find_element_by_css_selector('.button .c_button .s_button').click()```,output,1,1803 |
| kill a process `make.exe` from python script on windows,instruction,0,1804 |
| ```os.system('taskkill /im make.exe')```,output,1,1804 |
| SQLAlchemy select records of columns of table `my_table` in addition to current date column,instruction,0,1805 |
| "```print(select([my_table, func.current_date()]).execute())```",output,1,1805 |
| remove duplicate characters from string 'ffffffbbbbbbbqqq',instruction,0,1806 |
| "```re.sub('([a-z])\\1+', '\\1', 'ffffffbbbbbbbqqq')```",output,1,1806 |
| remove periods inbetween capital letters that aren't immediately preceeded by word character(s) in a string `s` using regular expressions,instruction,0,1807 |
| "```re.sub('(?<!\\w)([A-Z])\\.', '\\1', s)```",output,1,1807 |
| Get a list of strings `split_text` with fixed chunk size `n` from a string `the_list`,instruction,0,1808 |
| "```split_list = [the_list[i:i + n] for i in range(0, len(the_list), n)]```",output,1,1808 |
| "match string 'this is my string' with regex '\\b(this|string)\\b' |
| then replace it with regex '<markup>\\1</markup>'",instruction,0,1809 |
| "```re.sub('\\b(this|string)\\b', '<markup>\\1</markup>', 'this is my string')```",output,1,1809 |
| output data of the first 7 columns of Pandas dataframe,instruction,0,1810 |
| "```pandas.set_option('display.max_columns', 7)```",output,1,1810 |
| Display maximum output data of columns in dataframe `pandas` that will fit into the screen,instruction,0,1811 |
| "```pandas.set_option('display.max_columns', None)```",output,1,1811 |
| set the value in column 'B' to NaN if the corresponding value in column 'A' is equal to 0 in pandas dataframe `df`,instruction,0,1812 |
| "```df.ix[df.A == 0, 'B'] = np.nan```",output,1,1812 |
| "Selecting Element ""//li/label/input"" followed by text ""polishpottery"" with Selenium WebDriver `driver`",instruction,0,1813 |
| "```driver.find_element_by_xpath(""//li/label/input[contains(..,'polishpottery')]"")```",output,1,1813 |
| "Sort a list of dictionaries `mylist` by keys ""weight"" and ""factor""",instruction,0,1814 |
| "```mylist.sort(key=operator.itemgetter('weight', 'factor'))```",output,1,1814 |
| ordering a list of dictionaries `mylist` by elements 'weight' and 'factor',instruction,0,1815 |
| "```mylist.sort(key=lambda d: (d['weight'], d['factor']))```",output,1,1815 |
| Convert a list of lists `lol` to a dictionary with key as second value of a list and value as list itself,instruction,0,1816 |
| ```{x[1]: x for x in lol}```,output,1,1816 |
| sort keys of dictionary 'd' based on their values,instruction,0,1817 |
| "```sorted(d, key=lambda k: d[k][1])```",output,1,1817 |
| round 123 to 100,instruction,0,1818 |
| "```int(round(123, -2))```",output,1,1818 |
| create file 'x' if file 'x' does not exist,instruction,0,1819 |
| "```fd = os.open('x', os.O_WRONLY | os.O_CREAT | os.O_EXCL)```",output,1,1819 |
| get a list of last trailing words from another list of strings`Original_List`,instruction,0,1820 |
| ```new_list = [x.split()[-1] for x in Original_List]```,output,1,1820 |
| Reverse a string 'hello world',instruction,0,1821 |
| ```'hello world'[::(-1)]```,output,1,1821 |
| Reverse list `s`,instruction,0,1822 |
| ```s[::(-1)]```,output,1,1822 |
| Reverse string 'foo',instruction,0,1823 |
| ```''.join(reversed('foo'))```,output,1,1823 |
| Reverse a string `string`,instruction,0,1824 |
| ```''.join(reversed(string))```,output,1,1824 |
| "Reverse a string ""foo""",instruction,0,1825 |
| ```'foo'[::(-1)]```,output,1,1825 |
| Reverse a string `a_string`,instruction,0,1826 |
| ```a_string[::(-1)]```,output,1,1826 |
| Reverse a string `a_string`,instruction,0,1827 |
| "```def reversed_string(a_string): |
| return a_string[::(-1)]```",output,1,1827 |
| Reverse a string `s`,instruction,0,1828 |
| ```''.join(reversed(s))```,output,1,1828 |
| generate a string of numbers separated by comma which is divisible by `4` with remainder `1` or `2`.,instruction,0,1829 |
| "```"""""","""""".join(str(i) for i in range(100) if i % 4 in (1, 2))```",output,1,1829 |
| "convert list `lst` of key, value pairs into a dictionary",instruction,0,1830 |
| "```dict([(e[0], int(e[1])) for e in lst])```",output,1,1830 |
| sorting a list of tuples `list_of_tuples` where each tuple is reversed,instruction,0,1831 |
| "```sorted(list_of_tuples, key=lambda tup: tup[::-1])```",output,1,1831 |
| sorting a list of tuples `list_of_tuples` by second key,instruction,0,1832 |
| "```sorted(list_of_tuples, key=lambda tup: tup[1])```",output,1,1832 |
| Concatenating two one-dimensional NumPy arrays 'a' and 'b'.,instruction,0,1833 |
| "```numpy.concatenate([a, b])```",output,1,1833 |
| writing items in list `thelist` to file `thefile`,instruction,0,1834 |
| "```for item in thelist: |
| thefile.write(('%s\n' % item))```",output,1,1834 |
| writing items in list `thelist` to file `thefile`,instruction,0,1835 |
| "```for item in thelist: |
| pass```",output,1,1835 |
| serialize `itemlist` to file `outfile`,instruction,0,1836 |
| "```pickle.dump(itemlist, outfile)```",output,1,1836 |
| writing items in list `itemlist` to file `outfile`,instruction,0,1837 |
| ```outfile.write('\n'.join(itemlist))```,output,1,1837 |
| Update a user's name as `Bob Marley` having id `123` in SQLAlchemy,instruction,0,1838 |
| ```session.query(User).filter_by(id=123).update({'name': 'Bob Marley'})```,output,1,1838 |
| send cookies `cookie` in a post request to url 'http://wikipedia.org' with the python requests library,instruction,0,1839 |
| "```r = requests.post('http://wikipedia.org', cookies=cookie)```",output,1,1839 |
| insert directory 'libs' at the 0th index of current directory,instruction,0,1840 |
| "```sys.path.insert(0, 'libs')```",output,1,1840 |
| get current date and time,instruction,0,1841 |
| ```datetime.datetime.now()```,output,1,1841 |
| get current time,instruction,0,1842 |
| ```datetime.datetime.now().time()```,output,1,1842 |
| get current time in pretty format,instruction,0,1843 |
| "```strftime('%Y-%m-%d %H:%M:%S', gmtime())```",output,1,1843 |
| get current time in string format,instruction,0,1844 |
| ```str(datetime.now())```,output,1,1844 |
| get current time,instruction,0,1845 |
| ```datetime.datetime.time(datetime.datetime.now())```,output,1,1845 |
| convert hex '\xff' to integer,instruction,0,1846 |
| ```ord('\xff')```,output,1,1846 |
| identify duplicated rows in columns 'PplNum' and 'RoomNum' with additional column in dataframe `df`,instruction,0,1847 |
| "```df.groupby(['PplNum', 'RoomNum']).cumcount() + 1```",output,1,1847 |
| get current utc time,instruction,0,1848 |
| ```datetime.utcnow()```,output,1,1848 |
| move last item of array `a` to the first position,instruction,0,1849 |
| ```a[-1:] + a[:-1]```,output,1,1849 |
| "Convert dataframe `df` to a pivot table using column 'year', 'month', and 'item' as indexes",instruction,0,1850 |
| "```df.set_index(['year', 'month', 'item']).unstack(level=-1)```",output,1,1850 |
| run a pivot with a multi-index `year` and `month` in a pandas data frame,instruction,0,1851 |
| "```df.pivot_table(values='value', index=['year', 'month'], columns='item')```",output,1,1851 |
| print a rational number `3/2`,instruction,0,1852 |
| ```print('\n\x1b[4m' + '3' + '\x1b[0m' + '\n2')```,output,1,1852 |
| ,instruction,0,1853 |
| ```li1.sort(key=lambda x: not x.startswith('b.'))```,output,1,1853 |
| iterate backwards from 10 to 0,instruction,0,1854 |
| "```range(10, 0, -1)```",output,1,1854 |
| get value of first child of xml node `name`,instruction,0,1855 |
| ```name[0].firstChild.nodeValue```,output,1,1855 |
| start a new thread for `myfunction` with parameters 'MyStringHere' and 1,instruction,0,1856 |
| "```thread.start_new_thread(myfunction, ('MyStringHere', 1))```",output,1,1856 |
| start a new thread for `myfunction` with parameters 'MyStringHere' and 1,instruction,0,1857 |
| "```thread.start_new_thread(myfunction, ('MyStringHere', 1))```",output,1,1857 |
| get index of the first biggest element in list `a`,instruction,0,1858 |
| ```a.index(max(a))```,output,1,1858 |
| replace periods `.` that are not followed by periods or spaces with a period and a space `. `,instruction,0,1859 |
| "```re.sub('\\.(?=[^ .])', '. ', para)```",output,1,1859 |
| convert a string `a` of letters embedded in squared brackets into embedded lists,instruction,0,1860 |
| "```[i.split() for i in re.findall('\\[([^\\[\\]]+)\\]', a)]```",output,1,1860 |
| extract dictionary `d` from list `a` where the value associated with the key 'name' of dictionary `d` is equal to 'pluto',instruction,0,1861 |
| ```[d for d in a if d['name'] == 'pluto']```,output,1,1861 |
| extract dictionary from list of dictionaries based on a key's value.,instruction,0,1862 |
| ```[d for d in a if d['name'] == 'pluto']```,output,1,1862 |
| Retrieve list of values from dictionary 'd',instruction,0,1863 |
| ```list(d.values())```,output,1,1863 |
| replace occurrences of two whitespaces or more with one whitespace ' ' in string `s`,instruction,0,1864 |
| "```re.sub(' +', ' ', s)```",output,1,1864 |
| Change the mode of file 'my_script.sh' to permission number 484,instruction,0,1865 |
| "```os.chmod('my_script.sh', 484)```",output,1,1865 |
| write pandas dataframe `df` to the file 'c:\\data\\t.csv' without row names,instruction,0,1866 |
| "```df.to_csv('c:\\data\\t.csv', index=False)```",output,1,1866 |
| remove all words which contains number from a string `words` using regex,instruction,0,1867 |
| "```re.sub('\\w*\\d\\w*', '', words).strip()```",output,1,1867 |
| control the keyboard and mouse with dogtail in linux,instruction,0,1868 |
| "```dogtail.rawinput.click(100, 100)```",output,1,1868 |
| parse date string '2009/05/13 19:19:30 -0400' using format '%Y/%m/%d %H:%M:%S %z',instruction,0,1869 |
| "```datetime.strptime('2009/05/13 19:19:30 -0400', '%Y/%m/%d %H:%M:%S %z')```",output,1,1869 |
| Get the position of a regex match for word `is` in a string `String`,instruction,0,1870 |
| "```re.search('\\bis\\b', String).start()```",output,1,1870 |
| Get the position of a regex match `is` in a string `String`,instruction,0,1871 |
| "```re.search('is', String).start()```",output,1,1871 |
| input an integer tuple from user,instruction,0,1872 |
| "```tuple(map(int, input().split(',')))```",output,1,1872 |
| input a tuple of integers from user,instruction,0,1873 |
| "```tuple(int(x.strip()) for x in input().split(','))```",output,1,1873 |
| replace unicode character '\u2022' in string 'str' with '*',instruction,0,1874 |
| "```str.decode('utf-8').replace('\u2022', '*').encode('utf-8')```",output,1,1874 |
| replace unicode characters ''\u2022' in string 'str' with '*',instruction,0,1875 |
| "```str.decode('utf-8').replace('\u2022', '*')```",output,1,1875 |
| convert ndarray with shape 3x3 to array,instruction,0,1876 |
| "```np.zeros((3, 3)).ravel()```",output,1,1876 |
| get os name,instruction,0,1877 |
| "```import platform |
| platform.system()```",output,1,1877 |
| get os version,instruction,0,1878 |
| "```import platform |
| platform.release()```",output,1,1878 |
| get the name of the OS,instruction,0,1879 |
| ```print(os.name)```,output,1,1879 |
| ,instruction,0,1880 |
| ```[x for x in my_list if not x.startswith('#')]```,output,1,1880 |
| "replace fields delimited by braces {} in string ""Day old bread, 50% sale {0}"" with string 'today'",instruction,0,1881 |
| "```""""""Day old bread, 50% sale {0}"""""".format('today')```",output,1,1881 |
| Get a minimum value from a list of tuples `list` with values of type `string` and `float` with nan,instruction,0,1882 |
| "```min(list, key=lambda x: float('inf') if math.isnan(x[1]) else x[1])```",output,1,1882 |
| Find average of a nested list `a`,instruction,0,1883 |
| ```a = [(sum(x) / len(x)) for x in zip(*a)]```,output,1,1883 |
| Log info message 'Log message' with attributes `{'app_name': 'myapp'}`,instruction,0,1884 |
| "```logging.info('Log message', extra={'app_name': 'myapp'})```",output,1,1884 |
| replace values of dataframe `df` with True if numeric,instruction,0,1885 |
| "```df.applymap(lambda x: isinstance(x, (int, float)))```",output,1,1885 |
| sort list `l` based on its elements' digits,instruction,0,1886 |
| "```sorted(l, key=lambda x: int(re.search('\\d+', x).group(0)))```",output,1,1886 |
| close the window in tkinter,instruction,0,1887 |
| ```self.root.destroy()```,output,1,1887 |
| "get mean of columns `2, 5, 6, 7, 8` for all rows in dataframe `df`",instruction,0,1888 |
| "```df.iloc[:, ([2, 5, 6, 7, 8])].mean(axis=1)```",output,1,1888 |
| filter dataframe `df` by sub-level index '0630' in pandas,instruction,0,1889 |
| ```df[df.index.map(lambda x: x[1].endswith('0630'))]```,output,1,1889 |
| flask-sqlalchemy delete row `page`,instruction,0,1890 |
| ```db.session.delete(page)```,output,1,1890 |
| Format a string `u'Andr\xc3\xa9'` that has unicode characters,instruction,0,1891 |
| "```"""""""""""".join(chr(ord(c)) for c in 'Andr\xc3\xa9')```",output,1,1891 |
| convert a unicode 'Andr\xc3\xa9' to a string,instruction,0,1892 |
| "```"""""""""""".join(chr(ord(c)) for c in 'Andr\xc3\xa9').decode('utf8')```",output,1,1892 |
| "list all files in directory "".""",instruction,0,1893 |
| "```for (dirname, dirnames, filenames) in os.walk('.'): |
| for subdirname in dirnames: |
| print(os.path.join(dirname, subdirname)) |
| for filename in filenames: |
| pass```",output,1,1893 |
| list all files in directory `path`,instruction,0,1894 |
| ```os.listdir(path)```,output,1,1894 |
| rename file `dir` to `dir` + '!',instruction,0,1895 |
| "```os.rename(dir, dir + '!')```",output,1,1895 |
| Insert a character `-` after every two elements in a string `s`,instruction,0,1896 |
| "```""""""-"""""".join(a + b for a, b in zip(s[::2], s[1::2]))```",output,1,1896 |
| printing numbers rounding up to third decimal place,instruction,0,1897 |
| ```print('%.3f' % 3.1415)```,output,1,1897 |
| add variable `var` to key 'f' of first element in JSON data `data`,instruction,0,1898 |
| ```data[0]['f'] = var```,output,1,1898 |
| get the path of module `a_module`,instruction,0,1899 |
| ```print(a_module.__file__)```,output,1,1899 |
| get the path of the current python module,instruction,0,1900 |
| ```print(os.getcwd())```,output,1,1900 |
| get the path of the python module `amodule`,instruction,0,1901 |
| ```path = os.path.abspath(amodule.__file__)```,output,1,1901 |
| fill list `myList` with 4 0's,instruction,0,1902 |
| ```self.myList.extend([0] * (4 - len(self.myList)))```,output,1,1902 |
| drop duplicate indexes in a pandas data frame `df`,instruction,0,1903 |
| ```df[~df.index.duplicated()]```,output,1,1903 |
| unpack elements of list `i` as arguments into function `foo`,instruction,0,1904 |
| ```foo(*i)```,output,1,1904 |
| generate list of numbers in specific format using string formatting precision.,instruction,0,1905 |
| ```[('%.2d' % i) for i in range(16)]```,output,1,1905 |
| sort dictionary `mydict` in descending order based on the sum of each value in it,instruction,0,1906 |
| "```sorted(iter(mydict.items()), key=lambda tup: sum(tup[1]), reverse=True)[:3]```",output,1,1906 |
| get top `3` items from a dictionary `mydict` with largest sum of values,instruction,0,1907 |
| "```heapq.nlargest(3, iter(mydict.items()), key=lambda tup: sum(tup[1]))```",output,1,1907 |
| "get index of character 'b' in list '['a', 'b']'",instruction,0,1908 |
| "```['a', 'b'].index('b')```",output,1,1908 |
| set font size of axis legend of plot `plt` to 'xx-small',instruction,0,1909 |
| "```plt.setp(legend.get_title(), fontsize='xx-small')```",output,1,1909 |
| ,instruction,0,1910 |
| ```int(' 23 ')```,output,1,1910 |
| extract the 2nd elements from a list of tuples,instruction,0,1911 |
| ```[x[1] for x in elements]```,output,1,1911 |
| get the opposite diagonal of a numpy array `array`,instruction,0,1912 |
| ```np.diag(np.rot90(array))```,output,1,1912 |
| flatten list of tuples `a`,instruction,0,1913 |
| ```list(chain.from_iterable(a))```,output,1,1913 |
| substitute two or more whitespace characters with character '|' in string `line`,instruction,0,1914 |
| "```re.sub('\\s{2,}', '|', line.strip())```",output,1,1914 |
| print float `a` with two decimal points,instruction,0,1915 |
| ```print(('%.2f' % a))```,output,1,1915 |
| print float `a` with two decimal points,instruction,0,1916 |
| ```print(('{0:.2f}'.format(a)))```,output,1,1916 |
| print float `a` with two decimal points,instruction,0,1917 |
| "```print(('{0:.2f}'.format(round(a, 2))))```",output,1,1917 |
| print float `a` with two decimal points,instruction,0,1918 |
| "```print(('%.2f' % round(a, 2)))```",output,1,1918 |
| limit float 13.9499999 to two decimal points,instruction,0,1919 |
| ```('%.2f' % 13.9499999)```,output,1,1919 |
| limit float 3.14159 to two decimal points,instruction,0,1920 |
| ```('%.2f' % 3.14159)```,output,1,1920 |
| limit float 13.949999999999999 to two decimal points,instruction,0,1921 |
| ```float('{0:.2f}'.format(13.95))```,output,1,1921 |
| limit float 13.949999999999999 to two decimal points,instruction,0,1922 |
| ```'{0:.2f}'.format(13.95)```,output,1,1922 |
| load a tsv file `c:/~/trainSetRel3.txt` into a pandas data frame,instruction,0,1923 |
| "```DataFrame.from_csv('c:/~/trainSetRel3.txt', sep='\t')```",output,1,1923 |
| set UTC offset by 9 hrs ahead for date '2013/09/11 00:17',instruction,0,1924 |
| ```dateutil.parser.parse('2013/09/11 00:17 +0900')```,output,1,1924 |
| "pass a list of parameters `((1, 2, 3),) to sql queue 'SELECT * FROM table WHERE column IN %s;'",instruction,0,1925 |
| "```cur.mogrify('SELECT * FROM table WHERE column IN %s;', ((1, 2, 3),))```",output,1,1925 |
| "sum all elements of two-dimensions list `[[1, 2, 3, 4], [2, 4, 5, 6]]]`",instruction,0,1926 |
| "```sum([sum(x) for x in [[1, 2, 3, 4], [2, 4, 5, 6]]])```",output,1,1926 |
| Retrieve an arbitrary value from dictionary `dict`,instruction,0,1927 |
| ```next(iter(dict.values()))```,output,1,1927 |
| access an arbitrary value from dictionary `dict`,instruction,0,1928 |
| ```next(iter(list(dict.values())))```,output,1,1928 |
| group dataframe `df` by columns 'Month' and 'Fruit',instruction,0,1929 |
| "```df.groupby(['Month', 'Fruit']).sum().unstack(level=0)```",output,1,1929 |
| sort list `mylist` of tuples by arbitrary key from list `order`,instruction,0,1930 |
| "```sorted(mylist, key=lambda x: order.index(x[1]))```",output,1,1930 |
| sort a list of dictionary `persons` according to the key `['passport']['birth_info']['date']`,instruction,0,1931 |
| "```sorted(persons, key=lambda x: x['passport']['birth_info']['date'])```",output,1,1931 |
| remove the fragment identifier `#something` from a url `http: |
| ```urlparse.urldefrag('http://www.address.com/something#something')```,output,1,1932 |
| download to a directory '/path/to/dir/filename.ext' from source 'http://example.com/file.ext',instruction,0,1933 |
| "```urllib.request.urlretrieve('http://example.com/file.ext', '/path/to/dir/filename.ext')```",output,1,1933 |
| remove all duplicates from a list of sets `L`,instruction,0,1934 |
| ```list(set(frozenset(item) for item in L))```,output,1,1934 |
| remove duplicates from a list of sets 'L',instruction,0,1935 |
| ```[set(item) for item in set(frozenset(item) for item in L)]```,output,1,1935 |
| terminate process `p`,instruction,0,1936 |
| ```p.terminate()```,output,1,1936 |
| delete all values in a list `mylist`,instruction,0,1937 |
| ```del mylist[:]```,output,1,1937 |
| throw an error window in python in windows,instruction,0,1938 |
| "```ctypes.windll.user32.MessageBoxW(0, 'Error', 'Error', 0)```",output,1,1938 |
| remove empty strings from list `str_list`,instruction,0,1939 |
| ```str_list = list([_f for _f in str_list if _f])```,output,1,1939 |
| remove newlines and whitespace from string `yourstring`,instruction,0,1940 |
| "```re.sub('[\\ \\n]{2,}', '', yourstring)```",output,1,1940 |
| remove the last dot and all text beyond it in string `s`,instruction,0,1941 |
| "```re.sub('\\.[^.]+$', '', s)```",output,1,1941 |
| remove elements from an array `A` that are in array `B`,instruction,0,1942 |
| "```A[np.all(np.any(A - B[:, (None)], axis=2), axis=0)]```",output,1,1942 |
| Write column 'sum' of DataFrame `a` to csv file 'test.csv',instruction,0,1943 |
| "```a.to_csv('test.csv', cols=['sum'])```",output,1,1943 |
| "call a Python script ""test2.py""",instruction,0,1944 |
| "```exec(compile(open('test2.py').read(), 'test2.py', 'exec'))```",output,1,1944 |
| "call a Python script ""test1.py""",instruction,0,1945 |
| "```subprocess.call('test1.py', shell=True)```",output,1,1945 |
| sort a zipped list `zipped` using lambda function,instruction,0,1946 |
| "```sorted(zipped, key=lambda x: x[1])```",output,1,1946 |
| ,instruction,0,1947 |
| ```zipped.sort(key=lambda t: t[1])```,output,1,1947 |
| sort a dictionary `y` by value then by key,instruction,0,1948 |
| "```sorted(list(y.items()), key=lambda x: (x[1], x[0]), reverse=True)```",output,1,1948 |
| using beautifulsoup to select div blocks within html `soup`,instruction,0,1949 |
| "```soup.find_all('div', class_='crBlock ')```",output,1,1949 |
| remove elements from list `centroids` the indexes of which are in array `index`,instruction,0,1950 |
| "```[element for i, element in enumerate(centroids) if i not in index]```",output,1,1950 |
| list duplicated elements in two lists `listA` and `listB`,instruction,0,1951 |
| ```list(set(listA) & set(listB))```,output,1,1951 |
| "download ""http://randomsite.com/file.gz"" from http and save as ""file.gz""",instruction,0,1952 |
| "```testfile = urllib.request.URLopener() |
| testfile.retrieve('http://randomsite.com/file.gz', 'file.gz')```",output,1,1952 |
| "download file from http url ""http://randomsite.com/file.gz"" and save as ""file.gz""",instruction,0,1953 |
| "```urllib.request.urlretrieve('http://randomsite.com/file.gz', 'file.gz')```",output,1,1953 |
| download file from http url `file_url`,instruction,0,1954 |
| ```file_name = wget.download(file_url)```,output,1,1954 |
| "set an array of unicode characters `[u'\xe9', u'\xe3', u'\xe2']` as labels in Matplotlib `ax`",instruction,0,1955 |
| "```ax.set_yticklabels(['\xe9', '\xe3', '\xe2'])```",output,1,1955 |
| get a list of all integer points in a `dim` dimensional hypercube with coordinates from `-x` to `y` for all dimensions,instruction,0,1956 |
| "```list(itertools.product(list(range(-x, y)), repeat=dim))```",output,1,1956 |
| convert unicode string `s` into string literals,instruction,0,1957 |
| ```print(s.encode('unicode_escape'))```,output,1,1957 |
| how to format a list of arguments `my_args` into a string,instruction,0,1958 |
| "```'Hello %s' % ', '.join(my_args)```",output,1,1958 |
| search and split string 'aaa bbb ccc ddd eee fff' by delimiter '(ddd)',instruction,0,1959 |
| "```re.split('(ddd)', 'aaa bbb ccc ddd eee fff', 1)```",output,1,1959 |
| regex search and split string 'aaa bbb ccc ddd eee fff' by delimiter '(d(d)d)',instruction,0,1960 |
| "```re.split('(d(d)d)', 'aaa bbb ccc ddd eee fff', 1)```",output,1,1960 |
| convert a list of dictionaries `d` to pandas data frame,instruction,0,1961 |
| ```pd.DataFrame(d)```,output,1,1961 |
| "split string ""This is a string"" into words that do not contain whitespaces",instruction,0,1962 |
| "```""""""This is a string"""""".split()```",output,1,1962 |
| "split string ""This is a string"" into words that does not contain whitespaces",instruction,0,1963 |
| "```""""""This is a string"""""".split()```",output,1,1963 |
| ,instruction,0,1964 |
| "```my_series.apply(your_function, args=(2, 3, 4), extra_kw=1)```",output,1,1964 |
| remove all duplicate items from a list `lseperatedOrblist`,instruction,0,1965 |
| ```woduplicates = list(set(lseperatedOrblist))```,output,1,1965 |
| sum of product of combinations in a list `l`,instruction,0,1966 |
| "```sum([(i * j) for i, j in list(itertools.combinations(l, 2))])```",output,1,1966 |
| regular expression for validating string 'user' containing a sequence of characters ending with '-' followed by any number of digits.,instruction,0,1967 |
| ```re.compile('{}-\\d*'.format(user))```,output,1,1967 |
| convert all of the items in a list `lst` to float,instruction,0,1968 |
| ```[float(i) for i in lst]```,output,1,1968 |
| "multiply all items in a list `[1, 2, 3, 4, 5, 6]` together",instruction,0,1969 |
| "```from functools import reduce |
| reduce(lambda x, y: x * y, [1, 2, 3, 4, 5, 6])```",output,1,1969 |
| write a tuple of tuples `A` to a csv file using python,instruction,0,1970 |
| ```writer.writerow(A)```,output,1,1970 |
| Write all tuple of tuples `A` at once into csv file,instruction,0,1971 |
| ```writer.writerows(A)```,output,1,1971 |
| "python, format string ""{} %s {}"" to have 'foo' and 'bar' in the first and second positions",instruction,0,1972 |
| "```""""""{} %s {}"""""".format('foo', 'bar')```",output,1,1972 |
| Truncate `\r\n` from each string in a list of string `example`,instruction,0,1973 |
| "```example = [x.replace('\r\n', '') for x in example]```",output,1,1973 |
| split elements of a list `l` by '\t',instruction,0,1974 |
| ```[i.partition('\t')[-1] for i in l if '\t' in i]```,output,1,1974 |
| search for regex pattern 'Test(.*)print' in string `testStr` including new line character '\n',instruction,0,1975 |
| "```re.search('Test(.*)print', testStr, re.DOTALL)```",output,1,1975 |
| find button that is in li class `next` and assign it to variable `next`,instruction,0,1976 |
| ```next = driver.find_element_by_css_selector('li.next>a')```,output,1,1976 |
| get the size of file 'C:\\Python27\\Lib\\genericpath.py',instruction,0,1977 |
| ```os.stat('C:\\Python27\\Lib\\genericpath.py').st_size```,output,1,1977 |
| return a string from a regex match with pattern '<img.*?>' in string 'line',instruction,0,1978 |
| "```imtag = re.match('<img.*?>', line).group(0)```",output,1,1978 |
| "Rename a folder `Joe Blow` to `Blow, Joe`",instruction,0,1979 |
| "```os.rename('Joe Blow', 'Blow, Joe')```",output,1,1979 |
| find overlapping matches from a string `hello` using regex,instruction,0,1980 |
| "```re.findall('(?=(\\w\\w))', 'hello')```",output,1,1980 |
| convert 173 to binary string,instruction,0,1981 |
| ```bin(173)```,output,1,1981 |
| convert binary string '01010101111' to integer,instruction,0,1982 |
| "```int('01010101111', 2)```",output,1,1982 |
| convert binary string '010101' to integer,instruction,0,1983 |
| "```int('010101', 2)```",output,1,1983 |
| convert binary string '0b0010101010' to integer,instruction,0,1984 |
| "```int('0b0010101010', 2)```",output,1,1984 |
| convert 21 to binary string,instruction,0,1985 |
| ```bin(21)```,output,1,1985 |
| convert binary string '11111111' to integer,instruction,0,1986 |
| "```int('11111111', 2)```",output,1,1986 |
| delete all digits in string `s` that are not directly attached to a word character,instruction,0,1987 |
| "```re.sub('$\\d+\\W+|\\b\\d+\\b|\\W+\\d+$', '', s)```",output,1,1987 |
| delete digits at the end of string `s`,instruction,0,1988 |
| "```re.sub('\\b\\d+\\b', '', s)```",output,1,1988 |
| Delete self-contained digits from string `s`,instruction,0,1989 |
| "```s = re.sub('^\\d+\\s|\\s\\d+\\s|\\s\\d+$', ' ', s)```",output,1,1989 |
| truncate string `s` up to character ':',instruction,0,1990 |
| "```s.split(':', 1)[1]```",output,1,1990 |
| "print a string `s` by splitting with comma `,`",instruction,0,1991 |
| "```print(s.split(','))```",output,1,1991 |
| "Create list by splitting string `mystring` using "","" as delimiter",instruction,0,1992 |
| "```mystring.split(',')```",output,1,1992 |
| remove parentheses only around single words in a string `s` using regex,instruction,0,1993 |
| "```re.sub('\\((\\w+)\\)', '\\1', s)```",output,1,1993 |
| webbrowser open url `url`,instruction,0,1994 |
| ```webbrowser.open_new(url)```,output,1,1994 |
| webbrowser open url 'http://example.com',instruction,0,1995 |
| ```webbrowser.open('http://example.com')```,output,1,1995 |
| change the background colour of the button `pushbutton` to red,instruction,0,1996 |
| ```self.pushButton.setStyleSheet('background-color: red')```,output,1,1996 |
| apply a list of functions named 'functions' over a list of values named 'values',instruction,0,1997 |
| "```[x(y) for x, y in zip(functions, values)]```",output,1,1997 |
| modify the width of a text control as `300` keeping default height in wxpython,instruction,0,1998 |
| "```wx.TextCtrl(self, -1, size=(300, -1))```",output,1,1998 |
| display a grayscale image from array of pixels `imageArray`,instruction,0,1999 |
| "```imshow(imageArray, cmap='Greys_r')```",output,1,1999 |
| replace all the nan values with 0 in a pandas dataframe `df`,instruction,0,2000 |
| ```df.fillna(0)```,output,1,2000 |
| export a table dataframe `df` in pyspark to csv 'mycsv.csv',instruction,0,2001 |
| ```df.toPandas().to_csv('mycsv.csv')```,output,1,2001 |
| Write DataFrame `df` to csv file 'mycsv.csv',instruction,0,2002 |
| ```df.write.csv('mycsv.csv')```,output,1,2002 |
| get the sum of each second value from a list of tuple `structure`,instruction,0,2003 |
| ```sum(x[1] for x in structure)```,output,1,2003 |
| sum the 3 largest integers in groupby by 'STNAME' and 'COUNTY_POP',instruction,0,2004 |
| ```df.groupby('STNAME')['COUNTY_POP'].agg(lambda x: x.nlargest(3).sum())```,output,1,2004 |
| Parse string '21/11/06 16:30' according to format '%d/%m/%y %H:%M',instruction,0,2005 |
| "```datetime.strptime('21/11/06 16:30', '%d/%m/%y %H:%M')```",output,1,2005 |
| get current script directory,instruction,0,2006 |
| ```os.path.dirname(os.path.abspath(__file__))```,output,1,2006 |
| double each character in string `text.read()`,instruction,0,2007 |
| "```re.sub('(.)', '\\1\\1', text.read(), 0, re.S)```",output,1,2007 |
| "concatenate strings in tuple `('a', 'b', 'c', 'd', 'g', 'x', 'r', 'e')` into a single string",instruction,0,2008 |
| "```"""""""""""".join(('a', 'b', 'c', 'd', 'g', 'x', 'r', 'e'))```",output,1,2008 |
| get full path of current directory,instruction,0,2009 |
| ```os.path.dirname(os.path.abspath(__file__))```,output,1,2009 |
| "variable number of digits `digits` in variable `value` in format string ""{0:.{1}%}""",instruction,0,2010 |
| "```""""""{0:.{1}%}"""""".format(value, digits)```",output,1,2010 |
| get current requested url,instruction,0,2011 |
| ```self.request.url```,output,1,2011 |
| get a random item from list `choices`,instruction,0,2012 |
| ```random_choice = random.choice(choices)```,output,1,2012 |
| sum the length of all strings in a list `strings`,instruction,0,2013 |
| ```length = sum(len(s) for s in strings)```,output,1,2013 |
| sort a list `s` by first and second attributes,instruction,0,2014 |
| "```s = sorted(s, key=lambda x: (x[1], x[2]))```",output,1,2014 |
| sort a list of lists `s` by second and third element in each list.,instruction,0,2015 |
| "```s.sort(key=operator.itemgetter(1, 2))```",output,1,2015 |
| Mysql commit current transaction,instruction,0,2016 |
| ```con.commit()```,output,1,2016 |
| filtering out strings that contain 'ab' from a list of strings `lst`,instruction,0,2017 |
| ```[k for k in lst if 'ab' in k]```,output,1,2017 |
| find the first letter of each element in string `input`,instruction,0,2018 |
| ```output = ''.join(item[0].upper() for item in input.split())```,output,1,2018 |
| get name of primary field `name` of django model `CustomPK`,instruction,0,2019 |
| ```CustomPK._meta.pk.name```,output,1,2019 |
| count the number of words in a string `s`,instruction,0,2020 |
| ```len(s.split())```,output,1,2020 |
| multiply array `a` and array `b`respective elements then sum each row of the new array,instruction,0,2021 |
| "```np.einsum('ji,i->j', a, b)```",output,1,2021 |
| check python version,instruction,0,2022 |
| ```sys.version```,output,1,2022 |
| check python version,instruction,0,2023 |
| ```sys.version_info```,output,1,2023 |
| format number 1000000000.0 using latex notation,instruction,0,2024 |
| ```print('\\num{{{0:.2g}}}'.format(1000000000.0))```,output,1,2024 |
| Initialize a list of empty lists `x` of size 3,instruction,0,2025 |
| ```x = [[] for i in range(3)]```,output,1,2025 |
| apply jinja2 filters `forceescape` and `linebreaks` on variable `my_variable`,instruction,0,2026 |
| ```{{my_variable | forceescape | linebreaks}}```,output,1,2026 |
| "zip a list of tuples `[(1, 4), (2, 5), (3, 6)]` into a list of tuples according to original tuple index",instruction,0,2027 |
| "```zip(*[(1, 4), (2, 5), (3, 6)])```",output,1,2027 |
| split a list of tuples `data` into sub-lists of the same tuple field using itertools,instruction,0,2028 |
| "```[list(group) for key, group in itertools.groupby(data, operator.itemgetter(1))]```",output,1,2028 |
| Convert a string into a list,instruction,0,2029 |
| ```list('hello')```,output,1,2029 |
| create new column `A_perc` in dataframe `df` with row values equal to the value in column `A` divided by the value in column `sum`,instruction,0,2030 |
| ```df['A_perc'] = df['A'] / df['sum']```,output,1,2030 |
| getting a list of all subdirectories in the directory `directory`,instruction,0,2031 |
| ```os.walk(directory)```,output,1,2031 |
| get a list of all subdirectories in the directory `directory`,instruction,0,2032 |
| ```[x[0] for x in os.walk(directory)]```,output,1,2032 |
| update all values associated with key `i` to string 'updated' if value `j` is not equal to 'None' in dictionary `d`,instruction,0,2033 |
| "```{i: 'updated' for i, j in list(d.items()) if j != 'None'}```",output,1,2033 |
| Filter a dictionary `d` to remove keys with value None and replace other values with 'updated',instruction,0,2034 |
| "```dict((k, 'updated') for k, v in d.items() if v is None)```",output,1,2034 |
| Filter a dictionary `d` to remove keys with value 'None' and replace other values with 'updated',instruction,0,2035 |
| "```dict((k, 'updated') for k, v in d.items() if v != 'None')```",output,1,2035 |
| count number of rows in a group `key_columns` in pandas groupby object `df`,instruction,0,2036 |
| ```df.groupby(key_columns).size()```,output,1,2036 |
| return list `result` of sum of elements of each list `b` in list of lists `a`,instruction,0,2037 |
| ```result = [sum(b) for b in a]```,output,1,2037 |
| What's the best way to search for a Python dictionary value in a list of dictionaries?,instruction,0,2038 |
| ```any(d['site'] == 'Superuser' for d in data)```,output,1,2038 |
| create a 2D array of `Node` objects with dimensions `cols` columns and `rows` rows,instruction,0,2039 |
| ```nodes = [[Node() for j in range(cols)] for i in range(rows)]```,output,1,2039 |
| replace extension '.txt' in basename '/home/user/somefile.txt' with extension '.jpg',instruction,0,2040 |
| ```print(os.path.splitext('/home/user/somefile.txt')[0] + '.jpg')```,output,1,2040 |
| Set the resolution of a monitor as `FULLSCREEN` in pygame,instruction,0,2041 |
| "```pygame.display.set_mode((0, 0), pygame.FULLSCREEN)```",output,1,2041 |
| format float `3.5e+20` to `$3.5 \\times 10^{20}$` and set as title of matplotlib plot `ax`,instruction,0,2042 |
| "```ax.set_title('$%s \\times 10^{%s}$' % ('3.5', '+20'))```",output,1,2042 |
| Get the age of directory (or file) `/tmp` in seconds.,instruction,0,2043 |
| ```print(os.path.getmtime('/tmp'))```,output,1,2043 |
| how to get month name of datetime `today`,instruction,0,2044 |
| ```today.strftime('%B')```,output,1,2044 |
| get month name from a datetime object `today`,instruction,0,2045 |
| ```today.strftime('%B')```,output,1,2045 |
| Convert nested list `x` into a flat list,instruction,0,2046 |
| ```[j for i in x for j in i]```,output,1,2046 |
| get each value from a list of lists `a` using itertools,instruction,0,2047 |
| ```print(list(itertools.chain.from_iterable(a)))```,output,1,2047 |
| "convert date string 'January 11, 2010' into day of week",instruction,0,2048 |
| "```datetime.datetime.strptime('January 11, 2010', '%B %d, %Y').strftime('%A')```",output,1,2048 |
| ,instruction,0,2049 |
| "```datetime.datetime.strptime('January 11, 2010', '%B %d, %Y').strftime('%a')```",output,1,2049 |
| "remove item ""b"" in list `a`",instruction,0,2050 |
| ```a.remove('b')```,output,1,2050 |
| remove item `c` in list `a`,instruction,0,2051 |
| ```a.remove(c)```,output,1,2051 |
| delete the element 6 from list `a`,instruction,0,2052 |
| ```a.remove(6)```,output,1,2052 |
| delete the element 6 from list `a`,instruction,0,2053 |
| ```a.remove(6)```,output,1,2053 |
| delete the element `c` from list `a`,instruction,0,2054 |
| "```if (c in a): |
| a.remove(c)```",output,1,2054 |
| delete the element `c` from list `a`,instruction,0,2055 |
| "```try: |
| a.remove(c) |
| except ValueError: |
| pass```",output,1,2055 |
| Get all matching patterns 'a.*?a' from a string 'a 1 a 2 a 3 a 4 a'.,instruction,0,2056 |
| "```re.findall('(?=(a.*?a))', 'a 1 a 2 a 3 a 4 a')```",output,1,2056 |
| outer product of each column of a 2d `X` array to form a 3d array `X`,instruction,0,2057 |
| "```np.einsum('ij,kj->jik', X, X)```",output,1,2057 |
| Getting the last element of list `some_list`,instruction,0,2058 |
| ```some_list[(-1)]```,output,1,2058 |
| Getting the second to last element of list `some_list`,instruction,0,2059 |
| ```some_list[(-2)]```,output,1,2059 |
| gets the `n` th-to-last element in list `some_list`,instruction,0,2060 |
| ```some_list[(- n)]```,output,1,2060 |
| get the last element in list `alist`,instruction,0,2061 |
| ```alist[(-1)]```,output,1,2061 |
| get the last element in list `astr`,instruction,0,2062 |
| ```astr[(-1)]```,output,1,2062 |
| make a list of integers from 0 to `5` where each second element is a duplicate of the previous element,instruction,0,2063 |
| "```print([u for v in [[i, i] for i in range(5)] for u in v])```",output,1,2063 |
| "create a list of integers with duplicate values `[0, 0, 1, 1, 2, 2, 3, 3, 4, 4]`",instruction,0,2064 |
| "```[0, 0, 1, 1, 2, 2, 3, 3, 4, 4]```",output,1,2064 |
| create a list of integers from 1 to 5 with each value duplicated,instruction,0,2065 |
| ```[(i // 2) for i in range(10)]```,output,1,2065 |
| remove first and last lines of string `s`,instruction,0,2066 |
| ```s[s.find('\n') + 1:s.rfind('\n')]```,output,1,2066 |
| create dict of squared int values in range of 100,instruction,0,2067 |
| ```{(x ** 2) for x in range(100)}```,output,1,2067 |
| "zip lists `[1, 2], [3, 4], [5, 6]` in a list",instruction,0,2068 |
| "```zip(*[[1, 2], [3, 4], [5, 6]])```",output,1,2068 |
| "zip lists in a list [[1, 2], [3, 4], [5, 6]]",instruction,0,2069 |
| "```zip(*[[1, 2], [3, 4], [5, 6]])```",output,1,2069 |
| request page 'https://www.mysite.com/' with credentials of username 'username' and password 'pwd',instruction,0,2070 |
| "```requests.get('https://www.mysite.com/', auth=('username', 'pwd'))```",output,1,2070 |
| get a new string from the 3rd character to the end of the string `x`,instruction,0,2071 |
| ```x[2:]```,output,1,2071 |
| get a new string including the first two characters of string `x`,instruction,0,2072 |
| ```x[:2]```,output,1,2072 |
| get a new string including all but the last character of string `x`,instruction,0,2073 |
| ```x[:(-2)]```,output,1,2073 |
| get a new string including the last two characters of string `x`,instruction,0,2074 |
| ```x[(-2):]```,output,1,2074 |
| get a new string with the 3rd to the second-to-last characters of string `x`,instruction,0,2075 |
| ```x[2:(-2)]```,output,1,2075 |
| reverse a string `some_string`,instruction,0,2076 |
| ```some_string[::(-1)]```,output,1,2076 |
| "select alternate characters of ""H-e-l-l-o- -W-o-r-l-d""",instruction,0,2077 |
| ```'H-e-l-l-o- -W-o-r-l-d'[::2]```,output,1,2077 |
| select a substring of `s` beginning at `beginning` of length `LENGTH`,instruction,0,2078 |
| ```s = s[beginning:(beginning + LENGTH)]```,output,1,2078 |
| terminate the program,instruction,0,2079 |
| ```sys.exit()```,output,1,2079 |
| terminate the program,instruction,0,2080 |
| ```quit()```,output,1,2080 |
| "Terminating a Python script with error message ""some error message""",instruction,0,2081 |
| ```sys.exit('some error message')```,output,1,2081 |
| "encode value of key `City` in dictionary `data` as `ascii`, ignoring non-ascii characters",instruction,0,2082 |
| "```data['City'].encode('ascii', 'ignore')```",output,1,2082 |
| get current CPU and RAM usage,instruction,0,2083 |
| "```psutil.cpu_percent() |
| psutil.virtual_memory()```",output,1,2083 |
| get current RAM usage of current program,instruction,0,2084 |
| "```pid = os.getpid() |
| py = psutil.Process(pid) |
| memoryUse = (py.memory_info()[0] / (2.0 ** 30))```",output,1,2084 |
| print cpu and memory usage,instruction,0,2085 |
| "```print((psutil.cpu_percent())) |
| print((psutil.virtual_memory()))```",output,1,2085 |
| read a ragged csv file `D:/Temp/tt.csv` using `names` parameter in pandas,instruction,0,2086 |
| "```pd.read_csv('D:/Temp/tt.csv', names=list('abcdef'))```",output,1,2086 |
| get first non-null value per each row from dataframe `df`,instruction,0,2087 |
| ```df.stack().groupby(level=0).first()```,output,1,2087 |
| print two numbers `10` and `20` using string formatting,instruction,0,2088 |
| "```""""""{0} {1}"""""".format(10, 20)```",output,1,2088 |
| "replace placeholders in string '{1} {ham} {0} {foo} {1}' with arguments `(10, 20, foo='bar', ham='spam')`",instruction,0,2089 |
| "```""""""{1} {ham} {0} {foo} {1}"""""".format(10, 20, foo='bar', ham='spam')```",output,1,2089 |
| create list `changed_list ` containing elements of list `original_list` whilst converting strings containing digits to integers,instruction,0,2090 |
| ```changed_list = [(int(f) if f.isdigit() else f) for f in original_list]```,output,1,2090 |
| get a dictionary with keys from one list `keys` and values from other list `data`,instruction,0,2091 |
| "```dict(zip(keys, zip(*data)))```",output,1,2091 |
| convert string `apple` from iso-8859-1/latin1 to utf-8,instruction,0,2092 |
| ```apple.decode('iso-8859-1').encode('utf8')```,output,1,2092 |
| Exclude column names when writing dataframe `df` to a csv file `filename.csv`,instruction,0,2093 |
| "```df.to_csv('filename.csv', header=False)```",output,1,2093 |
| "Escape character '}' in string '{0}:<15}}{1}:<15}}{2}:<8}}' while using function `format` with arguments `('1', '2', '3')`",instruction,0,2094 |
| "```print('{0}:<15}}{1}:<15}}{2}:<8}}'.format('1', '2', '3'))```",output,1,2094 |
| get dictionary with max value of key 'size' in list of dicts `ld`,instruction,0,2095 |
| "```max(ld, key=lambda d: d['size'])```",output,1,2095 |
| "format parameters 'b' and 'a' into plcaeholders in string ""{0}\\w{{2}}b{1}\\w{{2}}quarter""",instruction,0,2096 |
| "```""""""{0}\\w{{2}}b{1}\\w{{2}}quarter"""""".format('b', 'a')```",output,1,2096 |
| django create a foreign key column `user` and link it to table 'User',instruction,0,2097 |
| "```user = models.ForeignKey('User', unique=True)```",output,1,2097 |
| write a regex pattern to match even number of letter `A`,instruction,0,2098 |
| ```re.compile('^([^A]*)AA([^A]|AA)*$')```,output,1,2098 |
| join Numpy array `b` with Numpy array 'a' along axis 0,instruction,0,2099 |
| "```b = np.concatenate((a, a), axis=0)```",output,1,2099 |
| custom sort an alphanumeric list `l`,instruction,0,2100 |
| "```sorted(l, key=lambda x: x.replace('0', 'Z'))```",output,1,2100 |
| plot logarithmic axes with matplotlib,instruction,0,2101 |
| ```ax.set_yscale('log')```,output,1,2101 |
| "Access environment variable ""HOME""",instruction,0,2102 |
| ```os.environ['HOME']```,output,1,2102 |
| "get value of environment variable ""HOME""",instruction,0,2103 |
| ```os.environ['HOME']```,output,1,2103 |
| print all environment variables,instruction,0,2104 |
| ```print(os.environ)```,output,1,2104 |
| get all environment variables,instruction,0,2105 |
| ```os.environ```,output,1,2105 |
| get value of the environment variable 'KEY_THAT_MIGHT_EXIST',instruction,0,2106 |
| ```print(os.environ.get('KEY_THAT_MIGHT_EXIST'))```,output,1,2106 |
| get value of the environment variable 'KEY_THAT_MIGHT_EXIST' with default value `default_value`,instruction,0,2107 |
| "```print(os.getenv('KEY_THAT_MIGHT_EXIST', default_value))```",output,1,2107 |
| get value of the environment variable 'HOME' with default value '/home/username/',instruction,0,2108 |
| "```print(os.environ.get('HOME', '/home/username/'))```",output,1,2108 |
| create a dictionary containing each string in list `my_list` split by '=' as a key/value pairs,instruction,0,2109 |
| ```print(dict([s.split('=') for s in my_list]))```,output,1,2109 |
| find the index of element closest to number 11.5 in list `a`,instruction,0,2110 |
| "```min(enumerate(a), key=lambda x: abs(x[1] - 11.5))```",output,1,2110 |
| "find element `a` that contains string ""TEXT A"" in file `root`",instruction,0,2111 |
| "```e = root.xpath('.//a[contains(text(),""TEXT A"")]')```",output,1,2111 |
| Find the`a` tag in html `root` which starts with the text `TEXT A` and assign it to `e`,instruction,0,2112 |
| "```e = root.xpath('.//a[starts-with(text(),""TEXT A"")]')```",output,1,2112 |
| find the element that holds string 'TEXT A' in file `root`,instruction,0,2113 |
| "```e = root.xpath('.//a[text()=""TEXT A""]')```",output,1,2113 |
| create list `c` containing items from list `b` whose index is in list `index`,instruction,0,2114 |
| ```c = [b[i] for i in index]```,output,1,2114 |
| get the dot product of two one dimensional numpy arrays,instruction,0,2115 |
| "```np.dot(a[:, (None)], b[(None), :])```",output,1,2115 |
| multiplication of two 1-dimensional arrays in numpy,instruction,0,2116 |
| "```np.outer(a, b)```",output,1,2116 |
| execute a file './abc.py' with arguments `arg1` and `arg2` in python shell,instruction,0,2117 |
| "```subprocess.call(['./abc.py', arg1, arg2])```",output,1,2117 |
| Replace NaN values in column 'value' with the mean of data in column 'group' of dataframe `df`,instruction,0,2118 |
| ```df[['value']].fillna(df.groupby('group').transform('mean'))```,output,1,2118 |
| separate each character in string `s` by '-',instruction,0,2119 |
| "```re.sub('(.)(?=.)', '\\1-', s)```",output,1,2119 |
| concatenate '-' in between characters of string `str`,instruction,0,2120 |
| "```re.sub('(?<=.)(?=.)', '-', str)```",output,1,2120 |
| get the indexes of the x and y axes in Numpy array `np` where variable `a` is equal to variable `value`,instruction,0,2121 |
| "```i, j = np.where(a == value)```",output,1,2121 |
| print letter that appears most frequently in string `s`,instruction,0,2122 |
| ```print(collections.Counter(s).most_common(1)[0])```,output,1,2122 |
| find float number proceeding sub-string `par` in string `dir`,instruction,0,2123 |
| "```float(re.findall('(?:^|_)' + par + '(\\d+\\.\\d*)', dir)[0])```",output,1,2123 |
| Get all the matches from a string `abcd` if it begins with a character `a`,instruction,0,2124 |
| "```re.findall('[^a]', 'abcd')```",output,1,2124 |
| get a list of variables from module 'adfix.py' in current module.,instruction,0,2125 |
| ```print([item for item in dir(adfix) if not item.startswith('__')])```,output,1,2125 |
| get the first element of each tuple in a list `rows`,instruction,0,2126 |
| ```[x[0] for x in rows]```,output,1,2126 |
| get a list `res_list` of the first elements of each tuple in a list of tuples `rows`,instruction,0,2127 |
| ```res_list = [x[0] for x in rows]```,output,1,2127 |
| duplicate data in pandas dataframe `x` for 5 times,instruction,0,2128 |
| "```pd.concat([x] * 5, ignore_index=True)```",output,1,2128 |
| Get a repeated pandas data frame object `x` by `5` times,instruction,0,2129 |
| ```pd.concat([x] * 5)```,output,1,2129 |
| sort json `ips_data` by a key 'data_two',instruction,0,2130 |
| "```sorted_list_of_keyvalues = sorted(list(ips_data.items()), key=item[1]['data_two'])```",output,1,2130 |
| read json `elevations` to pandas dataframe `df`,instruction,0,2131 |
| ```pd.read_json(elevations)```,output,1,2131 |
| "generate a random number in 1 to 7 with a given distribution [0.1, 0.05, 0.05, 0.2, 0.4, 0.2]",instruction,0,2132 |
| "```numpy.random.choice(numpy.arange(1, 7), p=[0.1, 0.05, 0.05, 0.2, 0.4, 0.2])```",output,1,2132 |
| Return rows of data associated with the maximum value of column 'Value' in dataframe `df`,instruction,0,2133 |
| ```df.loc[df['Value'].idxmax()]```,output,1,2133 |
| find recurring patterns in a string '42344343434',instruction,0,2134 |
| "```re.findall('^(.+?)((.+)\\3+)$', '42344343434')[0][:-1]```",output,1,2134 |
| convert binary string '\x00\x00\x80?\x00\x00\x00@\x00\x00@@\x00\x00\x80@' to numpy array,instruction,0,2135 |
| "```np.fromstring('\x00\x00\x80?\x00\x00\x00@\x00\x00@@\x00\x00\x80@', dtype='<f4')```",output,1,2135 |
| convert binary string to numpy array,instruction,0,2136 |
| "```np.fromstring('\x00\x00\x80?\x00\x00\x00@\x00\x00@@\x00\x00\x80@', dtype='>f4')```",output,1,2136 |
| "insert variables `(var1, var2, var3)` into sql statement 'INSERT INTO table VALUES (?, ?, ?)'",instruction,0,2137 |
| "```cursor.execute('INSERT INTO table VALUES (?, ?, ?)', (var1, var2, var3))```",output,1,2137 |
| "Execute a sql statement using variables `var1`, `var2` and `var3`",instruction,0,2138 |
| "```cursor.execute('INSERT INTO table VALUES (%s, %s, %s)', (var1, var2, var3))```",output,1,2138 |
| ,instruction,0,2139 |
| "```cursor.execute('INSERT INTO table VALUES (%s, %s, %s)', (var1, var2, var3))```",output,1,2139 |
| "pandas split strings in column 'stats' by ',' into columns in dataframe `df`",instruction,0,2140 |
| "```df['stats'].str[1:-1].str.split(',', expand=True).astype(float)```",output,1,2140 |
| "split string in column 'stats' by ',' into separate columns in dataframe `df`",instruction,0,2141 |
| "```df['stats'].str[1:-1].str.split(',').apply(pd.Series).astype(float)```",output,1,2141 |
| Unpack column 'stats' in dataframe `df` into a series of columns,instruction,0,2142 |
| ```df['stats'].apply(pd.Series)```,output,1,2142 |
| wait for shell command `p` evoked by subprocess.Popen to complete,instruction,0,2143 |
| ```p.wait()```,output,1,2143 |
| encode string `s` to utf-8 code,instruction,0,2144 |
| ```s.encode('utf8')```,output,1,2144 |
| parse string '01-Jan-1995' into a datetime object using format '%d-%b-%Y',instruction,0,2145 |
| "```datetime.datetime.strptime('01-Jan-1995', '%d-%b-%Y')```",output,1,2145 |
| copy a file from `src` to `dst`,instruction,0,2146 |
| "```copyfile(src, dst)```",output,1,2146 |
| "copy file ""/dir/file.ext"" to ""/new/dir/newname.ext""",instruction,0,2147 |
| "```shutil.copy2('/dir/file.ext', '/new/dir/newname.ext')```",output,1,2147 |
| copy file '/dir/file.ext' to '/new/dir',instruction,0,2148 |
| "```shutil.copy2('/dir/file.ext', '/new/dir')```",output,1,2148 |
| print a list of integers `list_of_ints` using string formatting,instruction,0,2149 |
| "```print(', '.join(str(x) for x in list_of_ints))```",output,1,2149 |
| multiply column 'A' and column 'B' by column 'C' in datafram `df`,instruction,0,2150 |
| "```df[['A', 'B']].multiply(df['C'], axis='index')```",output,1,2150 |
| convert string 'a' to hex,instruction,0,2151 |
| ```hex(ord('a'))```,output,1,2151 |
| Get the sum of values to the power of their indices in a list `l`,instruction,0,2152 |
| "```sum(j ** i for i, j in enumerate(l, 1))```",output,1,2152 |
| remove extra white spaces & tabs from a string `s`,instruction,0,2153 |
| "```"""""" """""".join(s.split())```",output,1,2153 |
| replace comma in string `s` with empty string '',instruction,0,2154 |
| "```s = s.replace(',', '')```",output,1,2154 |
| "Resample dataframe `frame` to resolution of 1 hour `1H` for timeseries index, summing values in the column `radiation` averaging those in column `tamb`",instruction,0,2155 |
| "```frame.resample('1H').agg({'radiation': np.sum, 'tamb': np.mean})```",output,1,2155 |
| ,instruction,0,2156 |
| ```root.destroy()```,output,1,2156 |
| create a pandas dataframe `df` from elements of a dictionary `nvalues`,instruction,0,2157 |
| "```df = pd.DataFrame.from_dict({k: v for k, v in list(nvalues.items()) if k != 'y3'})```",output,1,2157 |
| Flask get value of request variable 'firstname',instruction,0,2158 |
| ```first_name = request.args.get('firstname')```,output,1,2158 |
| Flask get posted form data 'firstname',instruction,0,2159 |
| ```first_name = request.form.get('firstname')```,output,1,2159 |
| get a list of substrings consisting of the first 5 characters of every string in list `buckets`,instruction,0,2160 |
| ```[s[:5] for s in buckets]```,output,1,2160 |
| sort list `the_list` by the length of string followed by alphabetical order,instruction,0,2161 |
| "```the_list.sort(key=lambda item: (-len(item), item))```",output,1,2161 |
| Set index equal to field 'TRX_DATE' in dataframe `df`,instruction,0,2162 |
| ```df = df.set_index(['TRX_DATE'])```,output,1,2162 |
| List comprehension with an accumulator in range of 10,instruction,0,2163 |
| ```list(accumulate(list(range(10))))```,output,1,2163 |
| How to convert a date string '2013-1-25' in format '%Y-%m-%d' to different format '%m/%d/%y',instruction,0,2164 |
| "```datetime.datetime.strptime('2013-1-25', '%Y-%m-%d').strftime('%m/%d/%y')```",output,1,2164 |
| convert a date string '2013-1-25' in format '%Y-%m-%d' to different format '%-m/%d/%y',instruction,0,2165 |
| "```datetime.datetime.strptime('2013-1-25', '%Y-%m-%d').strftime('%-m/%d/%y')```",output,1,2165 |
| get a dataframe `df2` that contains all the columns of dataframe `df` that do not end in `prefix`,instruction,0,2166 |
| "```df2 = df.ix[:, (~df.columns.str.endswith('prefix'))]```",output,1,2166 |
| create list `new_list` containing the last 10 elements of list `my_list`,instruction,0,2167 |
| ```new_list = my_list[-10:]```,output,1,2167 |
| get the last 10 elements from a list `my_list`,instruction,0,2168 |
| ```my_list[-10:]```,output,1,2168 |
| convert matlab engine array `x` to a numpy ndarray,instruction,0,2169 |
| ```np.array(x._data).reshape(x.size[::-1]).T```,output,1,2169 |
| select the first row grouped per level 0 of dataframe `df`,instruction,0,2170 |
| "```df.groupby(level=0, as_index=False).nth(0)```",output,1,2170 |
| concatenate sequence of numpy arrays `LIST` into a one dimensional array along the first axis,instruction,0,2171 |
| "```numpy.concatenate(LIST, axis=0)```",output,1,2171 |
| "convert and escape string ""\\xc3\\x85あ"" to UTF-8 code",instruction,0,2172 |
| "```""""""\\xc3\\x85あ"""""".encode('utf-8').decode('unicode_escape')```",output,1,2172 |
| "encode string ""\\xc3\\x85あ"" to bytes",instruction,0,2173 |
| "```""""""\\xc3\\x85あ"""""".encode('utf-8')```",output,1,2173 |
| interleave the elements of two lists `a` and `b`,instruction,0,2174 |
| "```[j for i in zip(a, b) for j in i]```",output,1,2174 |
| merge two lists `a` and `b` into a single list,instruction,0,2175 |
| "```[j for i in zip(a, b) for j in i]```",output,1,2175 |
| delete all occureces of `8` in each string `s` in list `lst`,instruction,0,2176 |
| "```print([s.replace('8', '') for s in lst])```",output,1,2176 |
| "Split string `Hello` into a string of letters seperated by `,`",instruction,0,2177 |
| "```"""""","""""".join('Hello')```",output,1,2177 |
| "in Django, select 100 random records from the database `Content.objects`",instruction,0,2178 |
| ```Content.objects.all().order_by('?')[:100]```,output,1,2178 |
| create a NumPy array containing elements of array `A` as pointed to by index in array `B`,instruction,0,2179 |
| "```A[np.arange(A.shape[0])[:, (None)], B]```",output,1,2179 |
| pivot dataframe `df` so that values for `upc` become column headings and values for `saleid` become the index,instruction,0,2180 |
| "```df.pivot_table(index='saleid', columns='upc', aggfunc='size', fill_value=0)```",output,1,2180 |
| match zero-or-more instances of lower case alphabet characters in a string `f233op `,instruction,0,2181 |
| "```re.findall('([a-z]*)', 'f233op')```",output,1,2181 |
| match zero-or-more instances of lower case alphabet characters in a string `f233op `,instruction,0,2182 |
| "```re.findall('([a-z])*', 'f233op')```",output,1,2182 |
| split string 'happy_hats_for_cats' using string '_for_',instruction,0,2183 |
| "```re.split('_for_', 'happy_hats_for_cats')```",output,1,2183 |
| "Split string 'sad_pandas_and_happy_cats_for_people' based on string 'and', 'or' or 'for'",instruction,0,2184 |
| "```re.split('_(?:for|or|and)_', 'sad_pandas_and_happy_cats_for_people')```",output,1,2184 |
| Split a string `l` by multiple words `for` or `or` or `and`,instruction,0,2185 |
| "```[re.split('_(?:f?or|and)_', s) for s in l]```",output,1,2185 |
| zip keys with individual values in lists `k` and `v`,instruction,0,2186 |
| "```[dict(zip(k, x)) for x in v]```",output,1,2186 |
| Sort a list 'lst' in descending order.,instruction,0,2187 |
| "```sorted(lst, reverse=True)```",output,1,2187 |
| "sort array `order_array` based on column 'year', 'month' and 'day'",instruction,0,2188 |
| "```order_array.sort(order=['year', 'month', 'day'])```",output,1,2188 |
| "Sort a structured numpy array 'df' on multiple columns 'year', 'month' and 'day'.",instruction,0,2189 |
| "```df.sort(['year', 'month', 'day'])```",output,1,2189 |
| check if elements in list `my_list` are coherent in order,instruction,0,2190 |
| "```return my_list == list(range(my_list[0], my_list[-1] + 1))```",output,1,2190 |
| group rows of pandas dataframe `df` with same 'id',instruction,0,2191 |
| ```df.groupby('id').agg(lambda x: x.tolist())```,output,1,2191 |
| encode `u'X\xc3\xbcY\xc3\x9f'` as unicode and decode with utf-8,instruction,0,2192 |
| ```'X\xc3\xbcY\xc3\x9f'.encode('raw_unicode_escape').decode('utf-8')```,output,1,2192 |
| parse string `a` to float,instruction,0,2193 |
| ```float(a)```,output,1,2193 |
| Parse String `s` to Float or Int,instruction,0,2194 |
| "```try: |
| return int(s) |
| except ValueError: |
| return float(s)```",output,1,2194 |
| check if object `a` has property 'property',instruction,0,2195 |
| "```if hasattr(a, 'property'): |
| pass```",output,1,2195 |
| check if object `a` has property 'property',instruction,0,2196 |
| "```if hasattr(a, 'property'): |
| pass```",output,1,2196 |
| get the value of attribute 'property' of object `a` with default value 'default value',instruction,0,2197 |
| "```getattr(a, 'property', 'default value')```",output,1,2197 |
| delete every 8th column in a numpy array 'a'.,instruction,0,2198 |
| "```np.delete(a, list(range(0, a.shape[1], 8)), axis=1)```",output,1,2198 |
| convert `ms` milliseconds to a datetime object,instruction,0,2199 |
| ```datetime.datetime.fromtimestamp(ms / 1000.0)```,output,1,2199 |
| find the magnitude (length) squared of a vector `vf` field,instruction,0,2200 |
| "```np.einsum('...j,...j->...', vf, vf)```",output,1,2200 |
| request http url `url`,instruction,0,2201 |
| ```r = requests.get(url)```,output,1,2201 |
| request http url `url` with parameters `payload`,instruction,0,2202 |
| "```r = requests.get(url, params=payload)```",output,1,2202 |
| post request url `url` with parameters `payload`,instruction,0,2203 |
| "```r = requests.post(url, data=payload)```",output,1,2203 |
| make an HTTP post request with data `post_data`,instruction,0,2204 |
| "```post_response = requests.post(url='http://httpbin.org/post', json=post_data)```",output,1,2204 |
| django jinja slice list `mylist` by '3:8',instruction,0,2205 |
| ```{{(mylist | slice): '3:8'}}```,output,1,2205 |
| create dataframe `df` with content of hdf store file '/home/.../data.h5' with key of 'firstSet',instruction,0,2206 |
| "```df1 = pd.read_hdf('/home/.../data.h5', 'firstSet')```",output,1,2206 |
| get the largest index of the last occurrence of characters '([{' in string `test_string`,instruction,0,2207 |
| ```max(test_string.rfind(i) for i in '([{')```,output,1,2207 |
| print 'here is your checkmark: ' plus unicode character u'\u2713',instruction,0,2208 |
| ```print('here is your checkmark: ' + '\u2713')```,output,1,2208 |
| print unicode characters in a string `\u0420\u043e\u0441\u0441\u0438\u044f`,instruction,0,2209 |
| ```print('\u0420\u043e\u0441\u0441\u0438\u044f')```,output,1,2209 |
| pads string '5' on the left with 1 zero,instruction,0,2210 |
| ```print('{0}'.format('5'.zfill(2)))```,output,1,2210 |
| Remove duplicates elements from list `sequences` and sort it in ascending order,instruction,0,2211 |
| ```sorted(set(itertools.chain.from_iterable(sequences)))```,output,1,2211 |
| pandas dataframe `df` column 'a' to list,instruction,0,2212 |
| ```df['a'].values.tolist()```,output,1,2212 |
| Get a list of all values in column `a` in pandas data frame `df`,instruction,0,2213 |
| ```df['a'].tolist()```,output,1,2213 |
| escaping quotes in string,instruction,0,2214 |
| "```replace('""', '\\""')```",output,1,2214 |
| check if all string elements in list `words` are upper-cased,instruction,0,2215 |
| ```print(all(word[0].isupper() for word in words))```,output,1,2215 |
| remove items from dictionary `myDict` if the item's value `val` is equal to 42,instruction,0,2216 |
| "```myDict = {key: val for key, val in list(myDict.items()) if val != 42}```",output,1,2216 |
| Remove all items from a dictionary `myDict` whose values are `42`,instruction,0,2217 |
| "```{key: val for key, val in list(myDict.items()) if val != 42}```",output,1,2217 |
| Determine the byte length of a utf-8 encoded string `s`,instruction,0,2218 |
| ```return len(s.encode('utf-8'))```,output,1,2218 |
| kill a process with id `process.pid`,instruction,0,2219 |
| "```os.kill(process.pid, signal.SIGKILL)```",output,1,2219 |
| get data of columns with Null values in dataframe `df`,instruction,0,2220 |
| ```df[pd.isnull(df).any(axis=1)]```,output,1,2220 |
| "strip everything up to and including the character `&` from url `url`, strip the character `=` from the remaining string and concatenate `.html` to the end",instruction,0,2221 |
| "```url.split('&')[-1].replace('=', '') + '.html'```",output,1,2221 |
| Parse a file `sample.xml` using expat parsing in python 3,instruction,0,2222 |
| "```parser.ParseFile(open('sample.xml', 'rb'))```",output,1,2222 |
| Exit script,instruction,0,2223 |
| ```sys.exit()```,output,1,2223 |
| assign value in `group` dynamically to class property `attr`,instruction,0,2224 |
| "```setattr(self, attr, group)```",output,1,2224 |
| decode url-encoded string `some_string` to its character equivalents,instruction,0,2225 |
| ```urllib.parse.unquote(urllib.parse.unquote(some_string))```,output,1,2225 |
| "decode a double URL encoded string |
| 'FireShot3%2B%25282%2529.png' to |
| 'FireShot3+(2).png'",instruction,0,2226 |
| ```urllib.parse.unquote(urllib.parse.unquote('FireShot3%2B%25282%2529.png'))```,output,1,2226 |
| change flask security register url to `/create_account`,instruction,0,2227 |
| ```app.config['SECURITY_REGISTER_URL'] = '/create_account'```,output,1,2227 |
| open a file `/home/user/test/wsservice/data.pkl` in binary write mode,instruction,0,2228 |
| "```output = open('/home/user/test/wsservice/data.pkl', 'wb')```",output,1,2228 |
| remove the last element in list `a`,instruction,0,2229 |
| ```del a[(-1)]```,output,1,2229 |
| remove the element in list `a` with index 1,instruction,0,2230 |
| ```a.pop(1)```,output,1,2230 |
| remove the last element in list `a`,instruction,0,2231 |
| ```a.pop()```,output,1,2231 |
| remove the element in list `a` at index `index`,instruction,0,2232 |
| ```a.pop(index)```,output,1,2232 |
| remove the element in list `a` at index `index`,instruction,0,2233 |
| ```del a[index]```,output,1,2233 |
| print a celsius symbol on x axis of a plot `ax`,instruction,0,2234 |
| ```ax.set_xlabel('Temperature (\u2103)')```,output,1,2234 |
| Print a celsius symbol with matplotlib,instruction,0,2235 |
| ```ax.set_xlabel('Temperature ($^\\circ$C)')```,output,1,2235 |
| convert a list of lists `list_of_lists` into a list of strings keeping empty sub-lists as empty string '',instruction,0,2236 |
| ```[''.join(l) for l in list_of_lists]```,output,1,2236 |
| get a list of all the duplicate items in dataframe `df` using pandas,instruction,0,2237 |
| "```pd.concat(g for _, g in df.groupby('ID') if len(g) > 1)```",output,1,2237 |
| Delete third row in a numpy array `x`,instruction,0,2238 |
| "```x = numpy.delete(x, 2, axis=1)```",output,1,2238 |
| delete first row of array `x`,instruction,0,2239 |
| "```x = numpy.delete(x, 0, axis=0)```",output,1,2239 |
| merge rows from dataframe `df1` with rows from dataframe `df2` and calculate the mean for rows that have the same value of axis 1,instruction,0,2240 |
| "```pd.concat((df1, df2), axis=1).mean(axis=1)```",output,1,2240 |
| Get the average values from two numpy arrays `old_set` and `new_set`,instruction,0,2241 |
| "```np.mean(np.array([old_set, new_set]), axis=0)```",output,1,2241 |
| Matplotlib change marker size to 500,instruction,0,2242 |
| "```scatter(x, y, s=500, color='green', marker='h')```",output,1,2242 |
| Create new list `result` by splitting each item in list `words`,instruction,0,2243 |
| "```result = [item for word in words for item in word.split(',')]```",output,1,2243 |
| convert JSON string '2012-05-29T19:30:03.283Z' into a DateTime object using format '%Y-%m-%dT%H:%M:%S.%fZ',instruction,0,2244 |
| "```datetime.datetime.strptime('2012-05-29T19:30:03.283Z', '%Y-%m-%dT%H:%M:%S.%fZ')```",output,1,2244 |
| count `True` values associated with key 'one' in dictionary `tadas`,instruction,0,2245 |
| ```sum(item['one'] for item in list(tadas.values()))```,output,1,2245 |
| encode a pdf file `pdf_reference.pdf` with `base64` encoding,instruction,0,2246 |
| "```a = open('pdf_reference.pdf', 'rb').read().encode('base64')```",output,1,2246 |
| split string `a` using new-line character '\n' as separator,instruction,0,2247 |
| ```a.rstrip().split('\n')```,output,1,2247 |
| split a string `a` with new line character,instruction,0,2248 |
| ```a.split('\n')[:-1]```,output,1,2248 |
| return http status code 204 from a django view,instruction,0,2249 |
| ```return HttpResponse(status=204)```,output,1,2249 |
| check if 7 is in `a`,instruction,0,2250 |
| ```(7 in a)```,output,1,2250 |
| check if 'a' is in list `a`,instruction,0,2251 |
| ```('a' in a)```,output,1,2251 |
| sort list `results` by keys value 'year',instruction,0,2252 |
| "```sorted(results, key=itemgetter('year'))```",output,1,2252 |
| get current url in selenium webdriver `browser`,instruction,0,2253 |
| ```print(browser.current_url)```,output,1,2253 |
| "split string `str` with delimiter '; ' or delimiter ', '",instruction,0,2254 |
| "```re.split('; |, ', str)```",output,1,2254 |
| un-escaping characters in a string with python,instruction,0,2255 |
| "```""""""\\u003Cp\\u003E"""""".decode('unicode-escape')```",output,1,2255 |
| convert date string `s` in format pattern '%d/%m/%Y' into a timestamp,instruction,0,2256 |
| "```time.mktime(datetime.datetime.strptime(s, '%d/%m/%Y').timetuple())```",output,1,2256 |
| convert string '01/12/2011' to an integer timestamp,instruction,0,2257 |
| "```int(datetime.datetime.strptime('01/12/2011', '%d/%m/%Y').strftime('%s'))```",output,1,2257 |
| get http header of the key 'your-header-name' in flask,instruction,0,2258 |
| ```request.headers['your-header-name']```,output,1,2258 |
| select records of dataframe `df` where the sum of column 'X' for each value in column 'User' is 0,instruction,0,2259 |
| ```df.groupby('User')['X'].filter(lambda x: x.sum() == 0)```,output,1,2259 |
| Get data of dataframe `df` where the sum of column 'X' grouped by column 'User' is equal to 0,instruction,0,2260 |
| ```df.loc[df.groupby('User')['X'].transform(sum) == 0]```,output,1,2260 |
| Get data from dataframe `df` where column 'X' is equal to 0,instruction,0,2261 |
| ```df.groupby('User')['X'].transform(sum) == 0```,output,1,2261 |
| ,instruction,0,2262 |
| "```driver.find_elements_by_xpath(""//*[contains(text(), 'My Button')]"")```",output,1,2262 |
| convert pandas group by object to multi-indexed dataframe with indices 'Name' and 'Destination',instruction,0,2263 |
| "```df.set_index(['Name', 'Destination'])```",output,1,2263 |
| coalesce non-word-characters in string `a`,instruction,0,2264 |
| "```print(re.sub('(\\W)\\1+', '\\1', a))```",output,1,2264 |
| "open a file ""$file"" under Unix",instruction,0,2265 |
| "```os.system('start ""$file""')```",output,1,2265 |
| Convert a Unicode string `title` to a 'ascii' string,instruction,0,2266 |
| "```unicodedata.normalize('NFKD', title).encode('ascii', 'ignore')```",output,1,2266 |
| Convert a Unicode string `a` to a 'ascii' string,instruction,0,2267 |
| "```a.encode('ascii', 'ignore')```",output,1,2267 |
| create a list `files` containing all files in directory '.' that starts with numbers between 0 and 9 and ends with the extension '.jpg',instruction,0,2268 |
| "```files = [f for f in os.listdir('.') if re.match('[0-9]+.*\\.jpg', f)]```",output,1,2268 |
| "adding a 1-d array `[1, 2, 3, 4, 5, 6, 7, 8, 9]` to a 3-d array `np.zeros((6, 9, 20))`",instruction,0,2269 |
| "```np.zeros((6, 9, 20)) + np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])[(None), :, (None)]```",output,1,2269 |
| "add array of shape `(6, 9, 20)` to array `[1, 2, 3, 4, 5, 6, 7, 8, 9]`",instruction,0,2270 |
| "```np.zeros((6, 9, 20)) + np.array([1, 2, 3, 4, 5, 6, 7, 8, 9]).reshape((1, 9, 1))```",output,1,2270 |
| ,instruction,0,2271 |
| ```os.system('start excel.exe <path/to/file>')```,output,1,2271 |
| get the list with the highest sum value in list `x`,instruction,0,2272 |
| "```print(max(x, key=sum))```",output,1,2272 |
| sum the length of lists in list `x` that are more than 1 item in length,instruction,0,2273 |
| ```sum(len(y) for y in x if len(y) > 1)```,output,1,2273 |
| Enclose numbers in quotes in a string `This is number 1 and this is number 22`,instruction,0,2274 |
| "```re.sub('(\\d+)', '""\\1""', 'This is number 1 and this is number 22')```",output,1,2274 |
| multiply the columns of sparse matrix `m` by array `a` then multiply the rows of the resulting matrix by array `a`,instruction,0,2275 |
| "```numpy.dot(numpy.dot(a, m), a)```",output,1,2275 |
| Django check if an object with criteria `name` equal to 'name' and criteria `title` equal to 'title' exists in model `Entry`,instruction,0,2276 |
| "```Entry.objects.filter(name='name', title='title').exists()```",output,1,2276 |
| "sort a nested list by the inverse of element 2, then by element 1",instruction,0,2277 |
| "```sorted(l, key=lambda x: (-int(x[1]), x[0]))```",output,1,2277 |
| get domain/host name from request object in Django,instruction,0,2278 |
| ```request.META['HTTP_HOST']```,output,1,2278 |
| "get a string `randomkey123xyz987` between two substrings in a string `api('randomkey123xyz987', 'key', 'text')` using regex",instruction,0,2279 |
| "```re.findall(""api\\('(.*?)'"", ""api('randomkey123xyz987', 'key', 'text')"")```",output,1,2279 |
| invoke perl script './uireplace.pl' using perl interpeter '/usr/bin/perl' and send argument `var` to it,instruction,0,2280 |
| "```subprocess.call(['/usr/bin/perl', './uireplace.pl', var])```",output,1,2280 |
| print list of items `myList`,instruction,0,2281 |
| ```print('\n'.join(str(p) for p in myList))```,output,1,2281 |
| update the dictionary `mydic` with dynamic keys `i` and values with key 'name' from dictionary `o`,instruction,0,2282 |
| ```mydic.update({i: o['name']})```,output,1,2282 |
| split a `utf-8` encoded string `stru` into a list of characters,instruction,0,2283 |
| ```list(stru.decode('utf-8'))```,output,1,2283 |
| convert utf-8 with bom string `s` to utf-8 with no bom `u`,instruction,0,2284 |
| ```u = s.decode('utf-8-sig')```,output,1,2284 |
| Filter model 'Entry' where 'id' is not equal to 3 in Django,instruction,0,2285 |
| ```Entry.objects.filter(~Q(id=3))```,output,1,2285 |
| lookup an attribute in any scope by name 'range',instruction,0,2286 |
| "```getattr(__builtins__, 'range')```",output,1,2286 |
| restart a computer after `900` seconds using subprocess,instruction,0,2287 |
| "```subprocess.call(['shutdown', '/r', '/t', '900'])```",output,1,2287 |
| shutdown a computer using subprocess,instruction,0,2288 |
| "```subprocess.call(['shutdown', '/s'])```",output,1,2288 |
| abort a computer shutdown using subprocess,instruction,0,2289 |
| "```subprocess.call(['shutdown', '/a '])```",output,1,2289 |
| logoff computer having windows operating system using python,instruction,0,2290 |
| "```subprocess.call(['shutdown', '/l '])```",output,1,2290 |
| shutdown and restart a computer running windows from script,instruction,0,2291 |
| "```subprocess.call(['shutdown', '/r'])```",output,1,2291 |
| erase the contents of a file `filename`,instruction,0,2292 |
| "```open('filename', 'w').close()```",output,1,2292 |
| ,instruction,0,2293 |
| "```open('file.txt', 'w').close()```",output,1,2293 |
| convert dataframe `df` to list of dictionaries including the index values,instruction,0,2294 |
| ```df.to_dict('index')```,output,1,2294 |
| Create list of dictionaries from pandas dataframe `df`,instruction,0,2295 |
| ```df.to_dict('records')```,output,1,2295 |
| Group a pandas data frame by monthly frequenct `M` using groupby,instruction,0,2296 |
| ```df.groupby(pd.TimeGrouper(freq='M'))```,output,1,2296 |
| divide the members of a list `conversions` by the corresponding members of another list `trials`,instruction,0,2297 |
| "```[(c / t) for c, t in zip(conversions, trials)]```",output,1,2297 |
| sort dict `data` by value,instruction,0,2298 |
| "```sorted(data, key=data.get)```",output,1,2298 |
| Sort a dictionary `data` by its values,instruction,0,2299 |
| ```sorted(data.values())```,output,1,2299 |
| Get a list of pairs of key-value sorted by values in dictionary `data`,instruction,0,2300 |
| "```sorted(list(data.items()), key=lambda x: x[1])```",output,1,2300 |
| ,instruction,0,2301 |
| "```sorted(list(data.items()), key=lambda x: x[1])```",output,1,2301 |
| display current time,instruction,0,2302 |
| ```now = datetime.datetime.now().strftime('%H:%M:%S')```,output,1,2302 |
| find the index of the second occurrence of the substring `bar` in string `foo bar bar bar`,instruction,0,2303 |
| "```""""""foo bar bar bar"""""".replace('bar', 'XXX', 1).find('bar')```",output,1,2303 |
| check if key 'stackoverflow' and key 'google' are presented in dictionary `sites`,instruction,0,2304 |
| "```set(['stackoverflow', 'google']).issubset(sites)```",output,1,2304 |
| replace string ' and ' in string `stuff` with character '/',instruction,0,2305 |
| "```stuff.replace(' and ', '/')```",output,1,2305 |
| "Save array at index 0, index 1 and index 8 of array `np` to tmp file `tmp`",instruction,0,2306 |
| "```np.savez(tmp, *[getarray[0], getarray[1], getarray[8]])```",output,1,2306 |
| substract 1 hour and 10 minutes from current time,instruction,0,2307 |
| "```t = datetime.datetime.now() |
| (t - datetime.timedelta(hours=1, minutes=10))```",output,1,2307 |
| subtract 1 hour and 10 minutes from time object `t`,instruction,0,2308 |
| "```(t - datetime.timedelta(hours=1, minutes=10))```",output,1,2308 |
| add 1 hour and 2 minutes to time object `t`,instruction,0,2309 |
| "```dt = datetime.datetime.combine(datetime.date.today(), t)```",output,1,2309 |
| subtract 5 hours from the time object `dt`,instruction,0,2310 |
| ```dt -= datetime.timedelta(hours=5)```,output,1,2310 |
| encode string `data` using hex 'hex' encoding,instruction,0,2311 |
| ```print(data.encode('hex'))```,output,1,2311 |
| Return the decimal value for each hex character in data `data`,instruction,0,2312 |
| ```print(' '.join([str(ord(a)) for a in data]))```,output,1,2312 |
| Get all the items from a list of tuple 'l' where second item in tuple is '1'.,instruction,0,2313 |
| ```[x for x in l if x[1] == 1]```,output,1,2313 |
| Create array `a` containing integers from stdin,instruction,0,2314 |
| ```a.fromlist([int(val) for val in stdin.read().split()])```,output,1,2314 |
| place '\' infront of each non-letter char in string `line`,instruction,0,2315 |
| "```print(re.sub('[_%^$]', '\\\\\\g<0>', line))```",output,1,2315 |
| Get all `a` tags where the text starts with value `some text` using regex,instruction,0,2316 |
| "```doc.xpath(""//a[starts-with(text(),'some text')]"")```",output,1,2316 |
| convert a list of lists `a` into list of tuples of appropriate elements form nested lists,instruction,0,2317 |
| ```zip(*a)```,output,1,2317 |
| convert a list of strings `lst` to list of integers,instruction,0,2318 |
| "```[map(int, sublist) for sublist in lst]```",output,1,2318 |
| convert strings in list-of-lists `lst` to ints,instruction,0,2319 |
| ```[[int(x) for x in sublist] for sublist in lst]```,output,1,2319 |
| get index of elements in array `A` that occur in another array `B`,instruction,0,2320 |
| "```np.where(np.in1d(A, B))[0]```",output,1,2320 |
| create a list where each element is a dictionary with keys 'key1' and 'key2' and values corresponding to each value in the lists referenced by keys 'key1' and 'key2' in dictionary `d`,instruction,0,2321 |
| "```[{'key1': a, 'key2': b} for a, b in zip(d['key1'], d['key2'])]```",output,1,2321 |
| ,instruction,0,2322 |
| "```map(dict, zip(*[[(k, v) for v in value] for k, value in list(d.items())]))```",output,1,2322 |
| Get Last Day of the first month in 2002,instruction,0,2323 |
| "```calendar.monthrange(2002, 1)```",output,1,2323 |
| Get Last Day of the second month in 2002,instruction,0,2324 |
| "```calendar.monthrange(2008, 2)```",output,1,2324 |
| Get Last Day of the second month in 2100,instruction,0,2325 |
| "```calendar.monthrange(2100, 2)```",output,1,2325 |
| Get Last Day of the month `month` in year `year`,instruction,0,2326 |
| "```calendar.monthrange(year, month)[1]```",output,1,2326 |
| Get Last Day of the second month in year 2012,instruction,0,2327 |
| "```monthrange(2012, 2)```",output,1,2327 |
| Get Last Day of the first month in year 2000,instruction,0,2328 |
| "```(datetime.date(2000, 2, 1) - datetime.timedelta(days=1))```",output,1,2328 |
| "Calling an external command ""ls -l""",instruction,0,2329 |
| ```from subprocess import call```,output,1,2329 |
| "Calling an external command ""some_command with args""",instruction,0,2330 |
| ```os.system('some_command with args')```,output,1,2330 |
| "Calling an external command ""some_command < input_file | another_command > output_file""",instruction,0,2331 |
| ```os.system('some_command < input_file | another_command > output_file')```,output,1,2331 |
| "Calling an external command ""some_command with args""",instruction,0,2332 |
| ```stream = os.popen('some_command with args')```,output,1,2332 |
| "Calling an external command ""echo Hello World""",instruction,0,2333 |
| "```print(subprocess.Popen('echo Hello World', shell=True, stdout=subprocess.PIPE).stdout.read())```",output,1,2333 |
| "Calling an external command ""echo Hello World""",instruction,0,2334 |
| ```print(os.popen('echo Hello World').read())```,output,1,2334 |
| "Calling an external command ""echo Hello World""",instruction,0,2335 |
| "```return_code = subprocess.call('echo Hello World', shell=True)```",output,1,2335 |
| "Calling an external command ""ls""",instruction,0,2336 |
| "```p = subprocess.Popen('ls', shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) |
| for line in p.stdout.readlines(): |
| print(line, end=' ') |
| retval = p.wait()```",output,1,2336 |
| "Calling an external command ""ls -l""",instruction,0,2337 |
| "```call(['ls', '-l'])```",output,1,2337 |
| decode url `url` with utf8 and print it,instruction,0,2338 |
| ```print(urllib.parse.unquote(url).decode('utf8'))```,output,1,2338 |
| decode a urllib escaped url string `url` with `utf8`,instruction,0,2339 |
| ```url = urllib.parse.unquote(url).decode('utf8')```,output,1,2339 |
| delete letters from string '12454v',instruction,0,2340 |
| "```"""""""""""".join(filter(str.isdigit, '12454v'))```",output,1,2340 |
| Update row values for a column `Season` using vectorized string operation in pandas,instruction,0,2341 |
| ```df['Season'].str.split('-').str[0].astype(int)```,output,1,2341 |
| sort a list of tuples `my_list` by second parameter in the tuple,instruction,0,2342 |
| ```my_list.sort(key=lambda x: x[1])```,output,1,2342 |
| find indexes of all occurrences of a substring `tt` in a string `ttt`,instruction,0,2343 |
| "```[m.start() for m in re.finditer('(?=tt)', 'ttt')]```",output,1,2343 |
| find all occurrences of a substring in a string,instruction,0,2344 |
| "```[m.start() for m in re.finditer('test', 'test test test test')]```",output,1,2344 |
| split string `s` based on white spaces,instruction,0,2345 |
| "```re.findall('\\s+|\\S+', s)```",output,1,2345 |
| "set columns `['race_date', 'track_code', 'race_number']` as indexes in dataframe `rdata`",instruction,0,2346 |
| "```rdata.set_index(['race_date', 'track_code', 'race_number'])```",output,1,2346 |
| recursively go through all subdirectories and files in `rootdir`,instruction,0,2347 |
| "```for (root, subFolders, files) in os.walk(rootdir): |
| pass```",output,1,2347 |
| sort a list of dictionary values by 'date' in reverse order,instruction,0,2348 |
| "```list.sort(key=lambda item: item['date'], reverse=True)```",output,1,2348 |
| display first 5 characters of string 'aaabbbccc',instruction,0,2349 |
| "```""""""{:.5}"""""".format('aaabbbccc')```",output,1,2349 |
| unpack hexadecimal string `s` to a list of integer values,instruction,0,2350 |
| "```struct.unpack('11B', s)```",output,1,2350 |
| "finding the index of an item 'foo' given a list `['foo', 'bar', 'baz']` containing it",instruction,0,2351 |
| "```[i for i, j in enumerate(['foo', 'bar', 'baz']) if j == 'foo']```",output,1,2351 |
| "generate all permutations of list `[1, 2, 3]` and list `[4, 5, 6]`",instruction,0,2352 |
| "```print(list(itertools.product([1, 2, 3], [4, 5, 6])))```",output,1,2352 |
| "generate all permutations of a list `[1, 2, 3]`",instruction,0,2353 |
| "```itertools.permutations([1, 2, 3])```",output,1,2353 |
| substitute occurrences of unicode regex pattern u'\\p{P}+' with empty string '' in string `text`,instruction,0,2354 |
| "```return re.sub('\\p{P}+', '', text)```",output,1,2354 |
| manually throw/raise a `ValueError` exception with the message 'A very specific bad thing happened',instruction,0,2355 |
| ```raise ValueError('A very specific bad thing happened')```,output,1,2355 |
| "throw an exception ""I know Python!""",instruction,0,2356 |
| ```raise Exception('I know Python!')```,output,1,2356 |
| "Manually throw an exception ""I know python!""",instruction,0,2357 |
| ```raise Exception('I know python!')```,output,1,2357 |
| "throw a ValueError with message 'represents a hidden bug, do not catch this'",instruction,0,2358 |
| "```raise ValueError('represents a hidden bug, do not catch this')```",output,1,2358 |
| throw an Exception with message 'This is the exception you expect to handle',instruction,0,2359 |
| ```raise Exception('This is the exception you expect to handle')```,output,1,2359 |
| "throw a value error with message 'A very specific bad thing happened', 'foo', 'bar', 'baz'",instruction,0,2360 |
| ```raise ValueError('A very specific bad thing happened')```,output,1,2360 |
| throw a runtime error with message 'specific message',instruction,0,2361 |
| ```raise RuntimeError('specific message')```,output,1,2361 |
| "throw an assertion error with message ""Unexpected value of 'distance'!"", distance",instruction,0,2362 |
| "```raise AssertionError(""Unexpected value of 'distance'!"", distance)```",output,1,2362 |
| "if Selenium textarea element `foo` is not empty, clear the field",instruction,0,2363 |
| ```driver.find_element_by_id('foo').clear()```,output,1,2363 |
| clear text from textarea 'foo' with selenium,instruction,0,2364 |
| ```driver.find_element_by_id('foo').clear()```,output,1,2364 |
| convert a number 2130706433 to ip string,instruction,0,2365 |
| "```socket.inet_ntoa(struct.pack('!L', 2130706433))```",output,1,2365 |
| "Rearrange the columns 'a','b','x','y' of pandas DataFrame `df` in mentioned sequence 'x' ,'y','a' ,'b'",instruction,0,2366 |
| "```df = df[['x', 'y', 'a', 'b']]```",output,1,2366 |
| call base class's __init__ method from the child class `ChildClass`,instruction,0,2367 |
| "```super(ChildClass, self).__init__(*args, **kwargs)```",output,1,2367 |
| sum of all values in a python dict `d`,instruction,0,2368 |
| ```sum(d.values())```,output,1,2368 |
| ,instruction,0,2369 |
| ```sum(d.values())```,output,1,2369 |
| convert python dictionary `your_data` to json array,instruction,0,2370 |
| "```json.dumps(your_data, ensure_ascii=False)```",output,1,2370 |
| assign an array of floats in range from 0 to 100 to a variable `values`,instruction,0,2371 |
| "```values = np.array([i for i in range(100)], dtype=np.float64)```",output,1,2371 |
| sort a list of dictionaries `list_of_dct` by values in an order `order`,instruction,0,2372 |
| "```sorted(list_of_dct, key=lambda x: order.index(list(x.values())[0]))```",output,1,2372 |
| change the case of the first letter in string `s`,instruction,0,2373 |
| ```return s[0].upper() + s[1:]```,output,1,2373 |
| "join list of numbers `[1,2,3,4] ` to string of numbers.",instruction,0,2374 |
| "```"""""""""""".join([1, 2, 3, 4])```",output,1,2374 |
| delete every non `utf-8` characters from a string `line`,instruction,0,2375 |
| "```line = line.decode('utf-8', 'ignore').encode('utf-8')```",output,1,2375 |
| execute a command `command ` in the terminal from a python script,instruction,0,2376 |
| ```os.system(command)```,output,1,2376 |
| MySQL execute query 'SELECT * FROM foo WHERE bar = %s AND baz = %s' with parameters `param1` and `param2`,instruction,0,2377 |
| "```c.execute('SELECT * FROM foo WHERE bar = %s AND baz = %s', (param1, param2))```",output,1,2377 |
| Parse string `datestr` into a datetime object using format pattern '%Y-%m-%d',instruction,0,2378 |
| "```dateobj = datetime.datetime.strptime(datestr, '%Y-%m-%d').date()```",output,1,2378 |
|
|
