Datasets:

---

suriyagunasekar

/

stackoverflow-python-with-meta-data

like 11

[ "make grouper for grouping\ngrouper = df['CD'].ne(df['CD'].shift(1)).cumsum()\n\ngrouper:\n0 1\n1 1\n2 1\n3 1\n4 2\n5 2\n6 3\n7 3\n8 4\n9 5\n10 5\n11 5\n12 5\n13 5\n14 5\nName: CD, dtype: int32\n\nthen use groupby with grouper\ndf.groupby(['ID', grouper, 'CD'])['DATE'].agg([min, max]).droplevel(1)\n\noutput:\n min max\nID CD \n1 A 1/1/2015 1/4/2015\n B 1/5/2015 1/6/2015\n A 1/7/2015 1/8/2015\n C 1/9/2016 1/9/2016\n2 A 1/2/2015 1/7/2015\n\n\nchange column name and use reset_index and so on..for your desired output\n(df.groupby(['ID', grouper, 'CD'])['DATE'].agg([min, max]).droplevel(1)\n .set_axis(['Start_Date', 'End_Date'], axis=1)\n .reset_index()\n .assign(CD=lambda x: x.pop('CD')))\n\nresult\n ID Start_Date End_Date CD\n0 1 1/1/2015 1/4/2015 A\n1 1 1/5/2015 1/6/2015 B\n2 1 1/7/2015 1/8/2015 A\n3 1 1/9/2016 1/9/2016 C\n4 2 1/2/2015 1/7/2015 A\n\n" ]

[ 1 ]

[]

[]

[ "pandas", "python", "python_3.x" ]

[ "That is because there is no table tag on the URL you are loading. Go to the URL and view the source then search on \"<table\" you will find that there are no results\n", "when you get the table, define the HTML tag of the table as a dictionary dict or a list list such as \"tablex\"\nafter that you may do the following\nfor x in tablex:\n #x represents each item from the table\n print(x)\n\n", "Save the data in a link\nlink='xyz_xyz.com'\ntables_on_page = pd.read_html(link)\ni=0\nwhile i<len(tables_on_page):\n print(tables_on_page[i])\n i=i+1\n\n" ]

[ 0, 0, 0 ]

[]

[]

[ "beautifulsoup", "python" ]

[ "You need a blank python file named __init__.py in the directory that has DB.py. It tells python that there is a python module in that directory.\n" ]

[ 0 ]

[]

[]

[ "python", "python_import" ]

[ "Python 2.6+ and Python 3:\nIf you want StopIteration to be raised if no matching element is found:\nnext(x for x in the_iterable if x > 3)\n\nIf you want default_value (e.g. None) to be returned instead:\nnext((x for x in the_iterable if x > 3), default_value)\n\nNote that you need an extra pair of parentheses around the generator expression in this case − they are needed whenever the generator expression isn't the only argument.\nI see most answers resolutely ignore the next built-in and so I assume that for some mysterious reason they're 100% focused on versions 2.5 and older -- without mentioning the Python-version issue (but then I don't see that mention in the answers that do mention the next built-in, which is why I thought it necessary to provide an answer myself -- at least the \"correct version\" issue gets on record this way;-).\nPython <= 2.5\nThe .next() method of iterators immediately raises StopIteration if the iterator immediately finishes -- i.e., for your use case, if no item in the iterable satisfies the condition. If you don't care (i.e., you know there must be at least one satisfactory item) then just use .next() (best on a genexp, line for the next built-in in Python 2.6 and better).\nIf you do care, wrapping things in a function as you had first indicated in your Q seems best, and while the function implementation you proposed is just fine, you could alternatively use itertools, a for...: break loop, or a genexp, or a try/except StopIteration as the function's body, as various answers suggested. There's not much added value in any of these alternatives so I'd go for the starkly-simple version you first proposed.\n", "Damn Exceptions!\nI love this answer. However, since next() raise a StopIteration exception when there are no items,\ni would use the following snippet to avoid an exception:\na = []\nitem = next((x for x in a), None)\n\n\nFor example, \na = []\nitem = next(x for x in a)\n\nWill raise a StopIteration exception;\nTraceback (most recent call last):\n File \"<stdin>\", line 1, in <module>\nStopIteration\n\n", "As a reusable, documented and tested function\ndef first(iterable, condition = lambda x: True):\n \"\"\"\n Returns the first item in the `iterable` that\n satisfies the `condition`.\n\n If the condition is not given, returns the first item of\n the iterable.\n\n Raises `StopIteration` if no item satysfing the condition is found.\n\n >>> first( (1,2,3), condition=lambda x: x % 2 == 0)\n 2\n >>> first(range(3, 100))\n 3\n >>> first( () )\n Traceback (most recent call last):\n ...\n StopIteration\n \"\"\"\n\n return next(x for x in iterable if condition(x))\n\nVersion with default argument\n@zorf suggested a version of this function where you can have a predefined return value if the iterable is empty or has no items matching the condition:\ndef first(iterable, default = None, condition = lambda x: True):\n \"\"\"\n Returns the first item in the `iterable` that\n satisfies the `condition`.\n\n If the condition is not given, returns the first item of\n the iterable.\n\n If the `default` argument is given and the iterable is empty,\n or if it has no items matching the condition, the `default` argument\n is returned if it matches the condition.\n\n The `default` argument being None is the same as it not being given.\n\n Raises `StopIteration` if no item satisfying the condition is found\n and default is not given or doesn't satisfy the condition.\n\n >>> first( (1,2,3), condition=lambda x: x % 2 == 0)\n 2\n >>> first(range(3, 100))\n 3\n >>> first( () )\n Traceback (most recent call last):\n ...\n StopIteration\n >>> first([], default=1)\n 1\n >>> first([], default=1, condition=lambda x: x % 2 == 0)\n Traceback (most recent call last):\n ...\n StopIteration\n >>> first([1,3,5], default=1, condition=lambda x: x % 2 == 0)\n Traceback (most recent call last):\n ...\n StopIteration\n \"\"\"\n\n try:\n return next(x for x in iterable if condition(x))\n except StopIteration:\n if default is not None and condition(default):\n return default\n else:\n raise\n\n", "The most efficient way in Python 3 are one of the following (using a similar example):\nWith \"comprehension\" style:\nnext(i for i in range(100000000) if i == 1000)\n\nWARNING: The expression works also with Python 2, but in the example is used range that returns an iterable object in Python 3 instead of a list like Python 2 (if you want to construct an iterable in Python 2 use xrange instead).\nNote that the expression avoid to construct a list in the comprehension expression next([i for ...]), that would cause to create a list with all the elements before filter the elements, and would cause to process the entire options, instead of stop the iteration once i == 1000.\nWith \"functional\" style:\nnext(filter(lambda i: i == 1000, range(100000000)))\n\nWARNING: This doesn't work in Python 2, even replacing range with xrange due that filter create a list instead of a iterator (inefficient), and the next function only works with iterators.\nDefault value\nAs mentioned in other responses, you must add a extra-parameter to the function next if you want to avoid an exception raised when the condition is not fulfilled.\n\"functional\" style:\nnext(filter(lambda i: i == 1000, range(100000000)), False)\n\n\"comprehension\" style:\nWith this style you need to surround the comprehension expression with () to avoid a SyntaxError: Generator expression must be parenthesized if not sole argument:\nnext((i for i in range(100000000) if i == 1000), False)\n\n", "Similar to using ifilter, you could use a generator expression:\n>>> (x for x in xrange(10) if x > 5).next()\n6\n\nIn either case, you probably want to catch StopIteration though, in case no elements satisfy your condition.\nTechnically speaking, I suppose you could do something like this:\n>>> foo = None\n>>> for foo in (x for x in xrange(10) if x > 5): break\n... \n>>> foo\n6\n\nIt would avoid having to make a try/except block. But that seems kind of obscure and abusive to the syntax.\n", "I would write this \nnext(x for x in xrange(10) if x > 3)\n\n", "For anyone using Python 3.8 or newer I recommend using \"Assignment Expressions\" as described in PEP 572 -- Assignment Expressions.\nif any((match := i) > 3 for i in range(10)):\n print(match)\n\n", "The itertools module contains a filter function for iterators. The first element of the filtered iterator can be obtained by calling next() on it:\nfrom itertools import ifilter\n\nprint ifilter((lambda i: i > 3), range(10)).next()\n\n", "For older versions of Python where the next built-in doesn't exist:\n(x for x in range(10) if x > 3).next()\n\n", "By using \n(index for index, value in enumerate(the_iterable) if condition(value))\n\none can check the condition of the value of the first item in the_iterable, and obtain its index without the need to evaluate all of the items in the_iterable.\nThe complete expression to use is\nfirst_index = next(index for index, value in enumerate(the_iterable) if condition(value))\n\nHere first_index assumes the value of the first value identified in the expression discussed above.\n", "This question already has great answers. I'm only adding my two cents because I landed here trying to find a solution to my own problem, which is very similar to the OP. \nIf you want to find the INDEX of the first item matching a criteria using generators, you can simply do:\nnext(index for index, value in enumerate(iterable) if condition)\n\n", "In Python 3:\na = (None, False, 0, 1)\nassert next(filter(None, a)) == 1\n\nIn Python 2.6:\na = (None, False, 0, 1)\nassert next(iter(filter(None, a))) == 1\n\nEDIT: I thought it was obvious, but apparently not: instead of None you can pass a function (or a lambda) with a check for the condition:\na = [2,3,4,5,6,7,8]\nassert next(filter(lambda x: x%2, a)) == 3\n\n", "You could also use the argwhere function in Numpy. For example:\ni) Find the first \"l\" in \"helloworld\":\nimport numpy as np\nl = list(\"helloworld\") # Create list\ni = np.argwhere(np.array(l)==\"l\") # i = array([[2],[3],[8]])\nindex_of_first = i.min()\n\nii) Find first random number > 0.1\nimport numpy as np\nr = np.random.rand(50) # Create random numbers\ni = np.argwhere(r>0.1)\nindex_of_first = i.min()\n\niii) Find the last random number > 0.1\nimport numpy as np\nr = np.random.rand(50) # Create random numbers\ni = np.argwhere(r>0.1)\nindex_of_last = i.max()\n\n", "here is a speedtest of three ways. Next() is not the fastest way.\nfrom timeit import default_timer as timer\n\n# Is set irreflexive?\n\ndef a():\n return frozenset((x3, x3) for x3 in set([x1[x2] for x2 in range(2) for x1 in value]) if (x3, x3) in value) == frozenset()\n\n\ndef b():\n return next((False for x1 in value if (x1[0], x1[0]) in value or (x1[1], x1[1]) in value), True)\n\n\ndef c():\n for x1 in value:\n if (x1[0], x1[0]) in value or (x1[1], x1[1]) in value:\n return False\n return True\n\n\ntimes = 1000000\nvalue = frozenset({(1, 3), (2, 1)})\n\n\nstart_time = timer()\nfor x in range(times):\n a()\nprint(\"a(): Calculation ended after \" + str(round((timer() - start_time) * 1000) / 1000.0) + \" sec\")\n\nstart_time = timer()\nfor x in range(times):\n b()\nprint(\"b(): Calculation ended after \" + str(round((timer() - start_time) * 1000) / 1000.0) + \" sec\")\n\nstart_time = timer()\nfor x in range(times):\n c()\nprint(\"c(): Calculation ended after \" + str(round((timer() - start_time) * 1000) / 1000.0) + \" sec\")\n\nResults to:\nCalculation ended after 1.365 sec\nCalculation ended after 0.685 sec\nCalculation ended after 0.493 sec\n\n", "I know it is too late but still, here is my answer:\ndef find_index(nums, fn):\n return next(i for i, x in enumerate(nums) if fn(x))\nprint(find_index([1, 2, 3, 4], lambda n: n % 2 == 1))\n\n", "If you don't want to use next() you can use unpacking:\n>>> a, *_ = filter(lambda e: e == 10, [7,8,9,10,11,12])\n>>> a\n10\n>>> _\n[]\n>>> a, *_ = filter(lambda e: e == 1000, [7,8,9,10,11,12])\nTraceback (most recent call last):\n File \"<stdin>\", line 1, in <module>\nValueError: not enough values to unpack (expected at least 1, got 0)\n\nNote that using filter() is equivalent to writing (item for item in iterable if condition) Python Docs.\nIf you need support for the edge case you can write like this:\n>>> a, *_ = [e for e in [7,8,9,10,11,12] if e == 1000] or [None]\n>>> a\nNone\n>>> _\n[]\n\n", "The following are 3 alternatives, with benchmarks.\nUsing next()\nThe one-liner:\nvalues = list(range(1, 10000000))\n\nvalue = next((x for x in values if x > 9999999), None)\n\nUsing a function\nThis is an alternative to using next() using a function, it's about 2%-5% faster:\nvalues = list(range(1, 10000000))\n\ndef first(items):\n for item in items:\n if item > 9999999: # Your condition\n return item\n return None # Default value\n\nvalue = first(values)\n\nUsing lambda\nThis is a function that can be used for replacing next() in all cases. Performance are about 300% slower:\nvalues = list(range(1, 10000000))\n\ndef first(items, condition, default = None):\n for item in items:\n if condition(item):\n return item\n return default\n\nvalue = first(values, lambda x: x > 9999999, None)\n\nBenchmarks\n\nFunction: 1x\nNext: 1.02x-1.05x\nLambda: > 3x\n\nMemory consumption is on par.\nThis is the benchmark.\n" ]

[ 767, 52, 43, 26, 13, 12, 12, 8, 7, 5, 4, 1, 1, 1, 0, 0, 0 ]

[ "Oneliner:\nthefirst = [i for i in range(10) if i > 3][0]\n\nIf youre not sure that any element will be valid according to the criteria, you should enclose this with try/except since that [0] can raise an IndexError.\n" ]

[ -3 ]

[ "iterator", "python" ]

[ "You could convert them to sets and get the intersection.\nlist(set(a) & set(b))\n\n", "When comparing values of one list to another you can use one of two options:\nFirst you could use a for loop like so:\nc = []\n\nfor element in a:\n if element in b:\n c.append(element)\nprint(c)\n\nThis is a rather chunky way of doing it, rather you could just use a comprehension like so:\nc = [element for element in a if element in b]\nprint(c)\n\nBoth of these answers give the output of:\n\n['wood', 'stone', 'diamond']\n\nHope this helps.\n" ]

[ 1, 0 ]

[]

[]

[ "compare", "list", "python" ]

[ "Have you tried using a proper Authorization header? Possibly the header is being filtered out by a web application firewall or proxy because it doesn't specify a scheme. For example:\n\ncurl --data '' -H \"Authorization: Basic dXNlcm5hbWU6cGFzc3dvcmQ=\" api.mysite.com/test\n\nThis sends a basic authorization header with the base64 encoded credentials username:password.\n", "On Google Cloud Functions (python 3.10 + Flask), I've been able to get the Authorization header as follows:\nrequest.environ.get('HTTP_AUTHORIZATION')\n\n" ]

[ 2, 0 ]

[]

[]

[ "authorization", "flask", "http", "python" ]

[ "In the latest Selenium version, executable_path has been deprecated, so you have to use Service:\nfrom selenium.webdriver.chrome.service import Service\n\ndriver = webdriver.Chrome(service=Service(<chromedriver.exe path>))\ndriver.get(<URL>)\n\n" ]

[ 0 ]

[]

[]

[ "attributeerror", "python", "selenium", "selenium_chromedriver" ]

[ "The usernames you're getting in a console is a list of tuples. Each tuple has only one item which you're accessing in dashboard.html like this:\n<OPTION value={{t[0]}}>{{t[1]}}</OPTION>\nThe second item {{t[1}} is None therefore you are getting no visible text in a select field. Try to go like this:\n<OPTION value={{t[0]}}>{{t[0]}}</OPTION>\n" ]

[ 1 ]

[]

[]

[ "flask", "python", "sqlite" ]

[ "You need a groupby, this works i think :\ndf.insert(2, 'Diff', (df.groupby('col1')['col2'].diff()))\n\n\nresult :\n col1 col2 Diff\n0 A 9.60 NaN\n1 A 10.40 0.80\n2 A 11.20 0.80\n3 B 3.30 NaN\n4 B 6.00 2.70\n5 B 4.00 -2.00\n6 C 1.94 NaN\n7 C 15.44 13.50\n8 C 6.17 -9.27\n9 D 8.16 NaN\n\n(you can replace the NaN by 0 if you wish)\n", "How about this:\ndifferences = []\n\nfor val in df.col1.unique():\n diffs = df.loc[df.col1 == val].col2.diff()\n differences.extend(diffs)\n\nThen you can add the differences list as a new column.\n", "You can use groupby() and diff()and assign the result to the new column Diff. Than you only need to fillna(0):\ndf['Diff'] = df.groupby('col1')['col2'].diff().fillna(0)\n\nThat should solve your problem:\n col1 col2 Diff\n0 A 9.60 0.00\n1 A 10.40 0.80\n2 A 11.20 0.80\n3 B 3.30 0.00\n4 B 6.00 2.70\n5 B 4.00 -2.00\n6 C 1.94 0.00\n7 C 15.44 13.50\n8 C 6.17 -9.27\n9 D 8.16 0.00\n\n" ]

[ 2, 1, 1 ]

[]

[]

[ "dataframe", "pandas", "python" ]

[ "Okay now, you should change this part\ndata = c.bbox(rect)\n\nif float(data[0]) <= 0 or float(data[1]) <= 0:\n print(data)\n c.scale(\"all\", ((x1+x2) / 2), ((y1+y2) / 2), 0.5, 0.5)\n\ninto this one:\ndata = c.bbox(rect)\nwhile float(data[0]) <= 0 or float(data[1]) <= 0:\n c.scale(\"all\", ((x1+x2) / 2), ((y1+y2) / 2), 0.5, 0.5)\n data = c.bbox(rect)\n\nNow until it doesn't touches walls, it rescales.\n" ]

[ 0 ]

[]

[]

[ "canvas", "python", "scale", "tkinter", "tkinter_canvas" ]

[ "Ok you have a custom datatype so you have to create the corresponding class:\nq = [ua.OSC(...), ua.OSC(...), ...]\ndata.set_value(ua.Variant(q, ua.VariantType.ExtensionObject)) \n\n" ]

[ 1 ]

[]

[]

[ "opc", "opc_ua", "python" ]

[ "As @Dan Mašek mentioned in his comment, the critical line is\nnet = cv2.dnn.readNetFromCaffe(\"E:/Face recognition/Models/deploy.prototxt.txt\"),(\"E:/Face recognition/Models/res10_300x300_ssd_iter_140000_fp16.caffemodel\")\n\nThe comma makes net a tuple containing the return value of the function calll cv2.dnn.readNetFromCaffe(\"E:/Face recognition/Models/deploy.prototxt.txt\") and the string \"E:/Face recognition/Models/res10_300x300_ssd_iter_140000_fp16.caffemodel\". This is equivalent to\n>>> a = 4, \"abc\"\n>>> a\n(4, 'abc')\n>>> type(a)\ntuple\n\nIn the last line you call net.setInput(blob) but a tuple has not attribute or method setInput, which is why you get the error.\nProbably, you wanted to write net = cv2.dnn.readNetFromCaffe(\"E:/Face recognition/Models/deploy.prototxt.txt\", \"E:/Face recognition/Models/res10_300x300_ssd_iter_140000_fp16.caffemodel\") or simply net = cv2.dnn.readNetFromCaffe(\"E:/Face recognition/Models/deploy.prototxt.txt\") (I do not know the method readNetFromCaffe, so I do not know what it requires as input).\n" ]

[ 0 ]

[]

[]

[ "python" ]

[ "You can use a regex with str.replace to detect the lowercase-UPPERCASE shifts and insert a _, then str.upper:\ndf.columns = (df.columns\n .str.replace('(?<=[a-z])(?=[A-Z])', '_', regex=True)\n .str.upper()\n )\n\nBefore:\n evaluationId createdAt scheduleEndDate sharedTo\n0 NaN NaN NaN NaN\n\nAfter:\n EVALUATION_ID CREATED_AT SCHEDULE_END_DATE SHARED_TO\n0 NaN NaN NaN NaN\n\n", "To change the labels of the columns in a Pandas DataFrame, you can use the DataFrame.rename() method. This method takes a dictionary as its argument, where the keys are the old column labels and the values are the new labels.\nFor example, to change the column labels in the DataFrame you provided, you can use the following code:\nimport pandas as pd\nimport pandas as pd \n# Create a sample DataFrame\ndf = pd.DataFrame(columns=['evaluationId,createdAt,scheduleEndDate,sharedTo, ...'])\n\n# Use the rename() method to change the column labels\ndf = df.rename(columns={'evaluationId,createdAt,scheduleEndDate,sharedTo, ...': 'EVALUATION_ID,CREATED_AT,SCHEDULE_END_DATE,SHARED_TO,...'})\n\nNote that the keys and values in the dictionary passed to the rename() method should be strings.\nIf you have many columns with the pattern \"aaaBb\" that you want to change to \"AAA_BB\", you can use the str.replace() method to do this in one go. This method takes two arguments: the substring you want to find, and the substring you want to replace it with.\nFor example, you could use the following code to replace all instances of \"aaaBb\" with \"AAA_BB\" in the column labels:\nimport pandas as pd\n\n# Create a sample DataFrame\ndf = pd.DataFrame(columns=['aaaBb1', 'aaaBb2', 'aaaBb3', ...])\n\n# Use the rename() method with the str.replace() method to change the column labels\ndf = df.rename(columns=lambda x: x.str.replace('aaaBb', 'AAA_BB'))\n\nThis code uses the lambda function to apply the str.replace() method to each column label in the DataFrame. This allows you to replace all instances of \"aaaBb\" with \"AAA_BB\" in the column labels in one go.\n" ]

[ 1, 0 ]

[]

[]

[ "dataframe", "pandas", "python" ]

[ "For anybody that ends up here via Google (like I did), here is a hack I've devised that works in both Windows and Ubuntu. In my case, I actually still need the terminal, but just want the dialog to be on top when displayed.\n# Make a top-level instance and hide since it is ugly and big.\nroot = Tkinter.Tk()\nroot.withdraw()\n\n# Make it almost invisible - no decorations, 0 size, top left corner.\nroot.overrideredirect(True)\nroot.geometry('0x0+0+0')\n\n# Show window again and lift it to top so it can get focus,\n# otherwise dialogs will end up behind the terminal.\nroot.deiconify()\nroot.lift()\nroot.focus_force()\n\nfilenames = tkFileDialog.askopenfilenames(parent=root) # Or some other dialog\n\n# Get rid of the top-level instance once to make it actually invisible.\nroot.destroy()\n\n", "Use AppleEvents to give focus to Python. Eg:\nimport os\n\n os.system('''/usr/bin/osascript -e 'tell app \"Finder\" to set frontmost of process \"Python\" to true' ''')\n\n", "I had this issue with the window behind Spyder:\nroot = tk.Tk()\nroot.overrideredirect(True)\nroot.geometry('0x0+0+0')\nroot.focus_force()\nFT = [(\"%s files\" % ftype, \"*.%s\" % ftype), ('All Files', '*.*')]\nttl = 'Select File'\nFile = filedialog.askopenfilename(parent=root, title=ttl, filetypes=FT)\nroot.withdraw()\n\n", "filenames = tkFileDialog.askopenfilenames(parent=root,initialdir=starting_dir)\nWell parent=root is enough for making tkFileDialog on top. It simply means that your root is not on top, try making root on top and automatically tkFileDialog will take top of the parent.\n", "Try the focus_set method. For more, see the Dialog Windows page in PythonWare's An Introduction to Tkinter.\n", "None of the other answers above worked for me 100% of the time.\nIn the end, what worked for me was adding 2 attibutes: -alpha and -topmost\nThis will force the window to be always on top, which was what I wanted.\nimport tkinter as tk\n\nroot = tk.Tk()\n# Hide the window\nroot.attributes('-alpha', 0.0)\n# Always have it on top\nroot.attributes('-topmost', True)\nfile_name = tk.filedialog.askopenfilename( parent=root, \n title='Open file',\n initialdir=starting_dir,\n filetypes=[(\"text files\", \"*.txt\")])\n# Destroy the window when the file dialog is finished\nroot.destroy()\n\n" ]

[ 15, 6, 4, 1, 0, 0 ]

[]

[]

[ "python", "tkinter" ]

[ "I think adding quotes around the dictionaries is the right approach. You can use regex to do so and use a different quote character than \" (I used § in my example):\nfrom io import StringIO\nimport re\nimport json\n\nwith open(\"store.txt\", \"r\") as f:\n csv_content = re.sub(r\"(\\{.*})\", r\"§\\1§\", f.read())\n\ndf = pd.read_csv(StringIO(csv_content), skipinitialspace=True, quotechar=\"§\", engine=\"python\")\n\ndf_out = pd.concat([\n df[[\"id\", \"name\", \"storeid\"]],\n pd.DataFrame(df[\"report\"].apply(lambda x: json.loads(x)).values.tolist())\n], axis=1)\n\nprint(df_out)\n\n\nNote: the very last value in your csv isn't valid json: \"code\":001. It should either be \"code\":\"001\" or \"code\":1\nOutput:\n id name storeid Source ... itemtrack info itemsboughtid stolenitem\n0 11 JohnSmith 3221-123-555 online ... 110 {'haircolor': 'black', 'age': 53} [] [{'item': 'candy', 'code': 1}, {'item': 'candy...\n1 35 BillyDan 3221-123-555 letter ... 110 {'haircolor': 'black', 'age': 21} [1, 42, 465, 5] [{'item': 'shoe', 'code': 2}]\n2 64 NickWalker 3221-123-555 letter ... 110 {'haircolor': 'red', 'age': 22} [1, 2] [{'item': 'sweater', 'code': 11}, {'item': 'ma...\n\n" ]

[ 0 ]

[]

[]

[ "pandas", "python", "text_files" ]

[ "There is something going wrong with your function SearchStudent. You may want to pass an extra parameter OR to use a class member variable to compare to the string 'byId'.\nIn the case the if condition passes (i.e.: self == 'byId' is true), then your class reference self is a string. So it is normal it does not have the members you request.\nclass Student(): \n\n def __init__(self, data):\n self.data = \"studentMockData_AS2.txt\"\n self.students = []\n with open (data, 'r') as datafile:\n self.content = datafile.read()\n for line in datafile:\n self.datum = line.split()\n self.students.append(self.datum)\n\n # notice the new parameter here\n def SearchStudent(self, rtype):\n if rtype == ('byId'):\n searchId = input('Enter student id: ')\n \n for self.datum in self.students:\n if self.datum[0] == searchId:\n print(self.datum)\n # the rest of the code\n\n" ]

[ 0 ]

[]

[]

[ "class", "python" ]

[ "In case you don't want to use any 3rd libraries, you can add one more parameter to your expensive function: ttl_hash=None. This new parameter is so-called \"time sensitive hash\", its the only purpose is to affect lru_cache.\nFor example:\nfrom functools import lru_cache\nimport time\n\n\n@lru_cache()\ndef my_expensive_function(a, b, ttl_hash=None):\n del ttl_hash # to emphasize we don't use it and to shut pylint up\n return a + b # horrible CPU load...\n\n\ndef get_ttl_hash(seconds=3600):\n \"\"\"Return the same value withing `seconds` time period\"\"\"\n return round(time.time() / seconds)\n\n\n# somewhere in your code...\nres = my_expensive_function(2, 2, ttl_hash=get_ttl_hash())\n# cache will be updated once in an hour\n\n\n", "The OP is using python 2.7 but if you're using python 3, ExpiringDict mentioned in the accepted answer is currently, well, expired. The last commit to the github repo was June 17, 2017 and there is an open issue that it doesn't work with Python 3.5\nAs of September 1, 2020, there is a more recently maintained project cachetools.\npip install cachetools\nfrom cachetools import TTLCache\n\ncache = TTLCache(maxsize=10, ttl=360)\ncache['apple'] = 'top dog'\n...\n>>> cache['apple']\n'top dog'\n... after 360 seconds...\n>>> cache['apple']\nKeyError exception raised\n\nttl is the time to live in seconds.\n", "Regarding an expiring in-memory cache, for general purpose use, a common design pattern to typically do this is not via a dictionary, but via a function or method decorator. A cache dictionary is managed behind the scenes. As such, this answer somewhat complements the answer by User which uses a dictionary rather than a decorator.\nThe ttl_cache decorator in cachetools works a lot like functools.lru_cache, but with a time to live.\nimport cachetools.func\n\[email protected]_cache(maxsize=128, ttl=10 * 60)\ndef example_function(key):\n return get_expensively_computed_value(key)\n\n\nclass ExampleClass:\n EXP = 2\n\n @classmethod\n @cachetools.func.ttl_cache()\n def example_classmethod(cls, i):\n return i * cls.EXP\n\n @staticmethod\n @cachetools.func.ttl_cache()\n def example_staticmethod(i):\n return i * 3\n\n", "You can use the expiringdict module:\n\nThe core of the library is ExpiringDict class which is an ordered dictionary with auto-expiring values for caching purposes.\n\nIn the description they do not talk about multithreading, so in order not to mess up, use a Lock.\n", "I absolutely love the idea from @iutinvg, I just wanted to take it a little further; decouple it from having to know to pass the ttl into every function and just make it a decorator so you don't have to think about it. If you have django, py3, and don't feel like pip installing any dependencies, try this out.\nimport time\nfrom django.utils.functional import lazy\nfrom functools import lru_cache, partial, update_wrapper\n\n\ndef lru_cache_time(seconds, maxsize=None):\n \"\"\"\n Adds time aware caching to lru_cache\n \"\"\"\n def wrapper(func):\n # Lazy function that makes sure the lru_cache() invalidate after X secs\n ttl_hash = lazy(lambda: round(time.time() / seconds), int)()\n \n @lru_cache(maxsize)\n def time_aware(__ttl, *args, **kwargs):\n \"\"\"\n Main wrapper, note that the first argument ttl is not passed down. \n This is because no function should bother to know this that \n this is here.\n \"\"\"\n def wrapping(*args, **kwargs):\n return func(*args, **kwargs)\n return wrapping(*args, **kwargs)\n return update_wrapper(partial(time_aware, ttl_hash), func)\n return wrapper\n\nProving it works (with examples):\n@lru_cache_time(seconds=10)\ndef meaning_of_life():\n \"\"\"\n This message should show up if you call help().\n \"\"\"\n print('this better only show up once!')\n return 42\n\n\n@lru_cache_time(seconds=10)\ndef multiply(a, b):\n \"\"\"\n This message should show up if you call help().\n \"\"\"\n print('this better only show up once!')\n return a * b\n \n# This is a test, prints a `.` for every second, there should be 10s \n# between each \"this better only show up once!\" *2 because of the two functions.\nfor _ in range(20):\n meaning_of_life()\n multiply(50, 99991)\n print('.')\n time.sleep(1)\n\n", "I know this is a little old, but for those who are interested in no third-party dependencies, this is a minor wrapper around the builtin functools.lru_cache (I noticed Javier's similar answer after writing this, but figured I post it anyway since this doesn't require Django):\nimport functools\nimport time\n\n\ndef time_cache(max_age, maxsize=128, typed=False):\n \"\"\"Least-recently-used cache decorator with time-based cache invalidation.\n\n Args:\n max_age: Time to live for cached results (in seconds).\n maxsize: Maximum cache size (see `functools.lru_cache`).\n typed: Cache on distinct input types (see `functools.lru_cache`).\n \"\"\"\n def _decorator(fn):\n @functools.lru_cache(maxsize=maxsize, typed=typed)\n def _new(*args, __time_salt, **kwargs):\n return fn(*args, **kwargs)\n\n @functools.wraps(fn)\n def _wrapped(*args, **kwargs):\n return _new(*args, **kwargs, __time_salt=int(time.time() / max_age))\n\n return _wrapped\n\n return _decorator\n\nAnd its usage:\n@time_cache(10)\ndef expensive(a: int):\n \"\"\"An expensive function.\"\"\"\n time.sleep(1 + a)\n\n\nprint(\"Starting...\")\nexpensive(1)\nprint(\"Again...\")\nexpensive(1)\nprint(\"Done\")\n\nNB this uses time.time and comes with all its caveats. You may want to use time.monotonic instead if available/appropriate.\n", "If you want to avoid third-party packages, you can add in a custom timed_lru_cache decorator, which builds upon the lru_cache decorator.\nThe below defaults to a 20-second lifetime and a max size of 128. Note that the entire cache expires after 20 seconds, not individual items.\nfrom datetime import datetime, timedelta\nfrom functools import lru_cache, wraps\n\n\ndef timed_lru_cache(seconds: int = 20, maxsize: int = 128):\n def wrapper_cache(func):\n func = lru_cache(maxsize=maxsize)(func)\n func.lifetime = timedelta(seconds=seconds)\n func.expiration = datetime.utcnow() + func.lifetime\n\n @wraps(func)\n def wrapped_func(*args, **kwargs):\n if datetime.utcnow() >= func.expiration:\n func.cache_clear()\n func.expiration = datetime.utcnow() + func.lifetime\n\n return func(*args, **kwargs)\n\n return wrapped_func\n\n return wrapper_cache\n\nThen, just add @timed_lru_cache() above your function and you'll be good to go:\n@timed_lru_cache()\ndef my_function():\n # code goes here...\n\n", "Yet Another Solution\nHow it works?\n\nThe user function is cached using @functools.lru_cache with support for maxsize and typed parameters.\nThe Result object records the function's return value and \"death\" time using time.monotonic() + ttl.\nThe wrapper function checks the \"death\" time of the return value against time.monotonic() and if the current time exceeds the \"death\" time, then recalculates the return value with a new \"death\" time.\n\nShow me the code:\nfrom functools import lru_cache, wraps\nfrom time import monotonic\n\n\ndef lru_cache_with_ttl(maxsize=128, typed=False, ttl=60):\n \"\"\"Least-recently used cache with time-to-live (ttl) limit.\"\"\"\n\n class Result:\n __slots__ = ('value', 'death')\n\n def __init__(self, value, death):\n self.value = value\n self.death = death\n\n def decorator(func):\n @lru_cache(maxsize=maxsize, typed=typed)\n def cached_func(*args, **kwargs):\n value = func(*args, **kwargs)\n death = monotonic() + ttl\n return Result(value, death)\n\n @wraps(func)\n def wrapper(*args, **kwargs):\n result = cached_func(*args, **kwargs)\n if result.death < monotonic():\n result.value = func(*args, **kwargs)\n result.death = monotonic() + ttl\n return result.value\n\n wrapper.cache_clear = cached_func.cache_clear\n return wrapper\n\n return decorator\n\nHow to use it?\n# Recalculate cached results after 5 seconds.\n@lru_cache_with_ttl(ttl=5)\ndef expensive_function(a, b):\n return a + b\n\nBenefits\n\nShort, easy to review, and no PyPI install necessary. Relies only on the Python standard library, 3.7+.\nNo annoying ttl=10 parameter needed at all callsites.\nDoes not evict all items at the same time.\nKey/value pairs actually live for the given TTL value.\nStores only one key/value pair per unique (*args, **kwargs) even when items expire.\nWorks as a decorator (kudos to the Javier Buzzi answer and Lewis Belcher answer).\nIs thread safe.\nBenefits from the C-optimizations of CPython from python.org and is compatible with PyPy.\n\nThe accepted answer fails #2, #3, #4, #5, and #6.\nDrawbacks\nDoes not proactively evict expired items. Expired items are evicted only when the cache reaches maximum size. If the cache will not reach the maximum size (say maxsize is None), then no evictions will ever occur.\nHowever, only one key/value pair is stored in the cache per unique (*args, **kwargs) given to the cached function. So if there are only 10 different parameter combinations, then the cache will only ever have 10 entries at max.\nNote that the \"time sensitive hash\" and \"time salt\" solutions are much worse because multiple key/value cache items with identical keys (but different time hashes/salts) are left in the cache.\n", "Something like that ?\nfrom time import time, sleep\nimport itertools\nfrom threading import Thread, RLock\nimport signal\n\n\nclass CacheEntry():\n def __init__(self, string, ttl=20):\n self.string = string\n self.expires_at = time() + ttl\n self._expired = False\n\n def expired(self):\n if self._expired is False:\n return (self.expires_at < time())\n else:\n return self._expired\n\nclass CacheList():\n def __init__(self):\n self.entries = []\n self.lock = RLock()\n\n def add_entry(self, string, ttl=20):\n with self.lock:\n self.entries.append(CacheEntry(string, ttl))\n\n def read_entries(self):\n with self.lock:\n self.entries = list(itertools.dropwhile(lambda x:x.expired(), self.entries))\n return self.entries\n\ndef read_entries(name, slp, cachelist):\n while True:\n print \"{}: {}\".format(name, \",\".join(map(lambda x:x.string, cachelist.read_entries())))\n sleep(slp)\n\ndef add_entries(name, ttl, cachelist):\n s = 'A'\n while True:\n cachelist.add_entry(s, ttl)\n print(\"Added ({}): {}\".format(name, s))\n sleep(1)\n s += 'A'\n\n\n\nif __name__ == \"__main__\":\n signal.signal(signal.SIGINT, signal.SIG_DFL)\n\n cl = CacheList()\n print_threads = []\n print_threads.append(Thread(None, read_entries, args=('t1', 1, cl)))\n # print_threads.append(Thread(None, read_entries, args=('t2', 2, cl)))\n # print_threads.append(Thread(None, read_entries, args=('t3', 3, cl)))\n\n adder_thread = Thread(None, add_entries, args=('a1', 2, cl))\n adder_thread.start()\n\n for t in print_threads:\n t.start()\n\n for t in print_threads:\n t.join()\n\n adder_thread.join()\n\n", "I really liked @iutinvg solution due to its simplicity. However, I don't want to put an extra argument into every function, that I need to cache.\nSo inspired by Lewis and Javiers answer, I thought a decorator would be best. However, I did not want to use 3rd party libraries (as Javier) and I thought I could improve upon Lewis solution. So this is what I came up with.\nimport time\nfrom functools import lru_cache\n\n\ndef ttl_lru_cache(seconds_to_live: int, maxsize: int = 128):\n \"\"\"\n Time aware lru caching\n \"\"\"\n def wrapper(func):\n\n @lru_cache(maxsize)\n def inner(__ttl, *args, **kwargs):\n # Note that __ttl is not passed down to func,\n # as it's only used to trigger cache miss after some time\n return func(*args, **kwargs)\n return lambda *args, **kwargs: inner(time.time() // seconds_to_live, *args, **kwargs)\n return wrapper\n\nMy solution use a lambda to get fewer lines of code and integer floor division (//) so no casting to int is required.\nUsage\n@ttl_lru_cache(seconds_to_live=10)\ndef expensive(a: int):\n \"\"\"An expensive function.\"\"\"\n time.sleep(1 + a)\n\n\nprint(\"Starting...\")\nexpensive(1)\nprint(\"Again...\")\nexpensive(1)\nprint(\"Done\")\n\nNote: With these decorators, you should never set maxsize=None, because the cache would then grow to infinity over time.\n" ]

[ 163, 130, 44, 32, 19, 19, 8, 7, 5, 2 ]

[ "You can also go for dictttl, which has MutableMapping, OrderedDict and defaultDict(list)\nInitialize an ordinary dict with each key having a ttl of 30 seconds\ndata = {'a': 1, 'b': 2}\ndict_ttl = DictTTL(30, data)\n\nOrderedDict\ndata = {'a': 1, 'b': 2}\ndict_ttl = OrderedDictTTL(30, data)\n\ndefaultDict(list)\ndict_ttl = DefaultDictTTL(30)\ndata = {'a': [10, 20], 'b': [1, 2]}\n[dict_ttl.append_values(k, v) for k, v in data.items()]\n\n", "Somebody took some work to put it into a python package, see https://github.com/vpaliy/lru-expiring-cache.\nWell, I've been mislead by the other answers (which don't really address the question), so this might not be the best tool. Still,\nfrom lru import LruCache\n\ncache = LruCache(maxsize=10, concurrent=True)\n\ndef producer(key: str, value = True, TTL = 20):\n cache.add(key = key, value = value, expires = TTL)\n\ndef consumer():\n remaining_items = cache.items()\n # Alternatively, iterate over available items until you find one not in the cache\n return remaining_items\n\n\nproducer(\"1\", TTL = 1)\nproducer(\"5\", TTL = 3)\nprint(consumer()) ## 1, 5\n\ntime.sleep(2)\nprint(consumer()) ## 5\n\ntime.sleep(2)\nprint(consumer()) ## nothing\n\nTo my surprise, it keeps a ('Concurrent', 'True') entry when running in concurrent mode.\n" ]

[ -1, -1 ]

[ "caching", "python" ]

[ "Add this to your Jupyter Notebook or Python script file\nimport logging\nlogging.getLogger().setLevel(logging.CRITICAL)\n\n", "When you are using the OpenAI python package and do requests to GPT-3 for example you will get messages like OP shows (showing the duration of the request for example).\nIn theory you need to get the base logger and raise its level.\nHowever, it seems like inside the openAI package a specific logger is specified. Therefore you need to load this one and set its level.\nThe Info-messages will be gone then:\nopenai.util.logging.getLogger().setLevel(logging.WARNING)\n\n" ]

[ 0, 0 ]

[]

[]

[ "openai", "python" ]

[ "Go to the Atom's menu bar -> Packages -> Script -> Configure Script\n(Or, you can use the shortcut Shift+Ctrl+Alt+O)\nThen type python3 to the Command space.\nHopefully, it will work.\n", "i am using \"script\" package (3.18.1 by rgbkrk) to run code inside atom and this is how i fixed it\n\nopen package settings -> view code \nopen lib -> grammars -> python.coffee\nchange from python to python3 in those two places 'Selection Based' and 'File Based'\n\n", "Install atom-runner in your Atom going into your settings of Atom and then inside Package and search for atom-runner and install it.\n\nNow click on settings tab for atom-runner as shown above on picture.\nThen click on View Code as shown in below picture.\n \nThen go to lib folder and open atom-runner.coffee and replace the following section of code:\ndefaultScopeMap:\ncoffee: 'coffee'\njs: 'node'\nruby: 'ruby'\npython: 'python3'\ngo: 'go run'\nshell: 'bash'\npowershell: 'powershell -noninteractive -noprofile -c -'\n\nMake sure that for python keyword value is python3, by default it is python. Refer to the pic below:\n \nOther way is to find the location of python3 using command\nwhich python3\n\nfor me output is :\n/usr/local/bin/python3\n\nand add as a shebang in your every python file. For example:-\n#!/usr/local/bin/python3\nimport sys\nprint(\"Version \",sys.version)\n\nOnly catch is that you have to write this in each file.\n", "If you are using Mac OS X, use the directory on the terminal to open the file. \nSelect the file python3, right click and select \"get info\". Select the directory from \"Where:\" and past it in Atom. \nAs Terry told you:\n\nThen type python3 to the Command space.\n\n", "You can use the Atom package atom-python-run to launch python code from Atom, the python version can be configured in the package settings. By default atom-python-run uses the syntax python {file}. If the python command on your system is not yet pointing to python3, just replace the setting and write python3 {file}.\n", "You are probably using atom-python-run package to run Python directly from Atom. If Python2 is the default version of Python in your system, then Atom will try to run your Python code with Python2 interpreter. All you have to do is to change some settings in atom-python-run package to tell it that we want to use Python3. The process is simple. Go to settings>>Packages, click the settings button on atom-python-run package and in the fields of F5 and F6 command, exchange python with python3. That's it. Now you can run your Python3 script by pressing F5 or F6 button.\n\n", "If you are using Atom on Mac OS and have script 3.18.1 and atom-python-run 0.9.7 packages installed, the following steps will help you out.\nScript-> Configure Script\n\nThen type in Python3 in the command field in the options dialog.\n\nThis should solve your problem.\n", "For mac user:\nif you want to use Python3 by default, you can open Atom Settings, Atom→Preferences→Open Config Folder, and open.atom/packages/script/lib/grammars/python.coffee, Changing python to python3 under 'Selection Based' and 'File Based', saving it.\n", "Im using Linux/Ubuntu so in other Linux distro and Mac this method will work.\nFirst you need go to package settings and find Script and click its Settings.\n\nin next step click on view code.\n\nWith this, you will get access to all the main source files of the package. follow the path below to reach the python.js file.\n> lib > grammars > python.js\n\n\nNow you need to change the highlighted parts to the following value, you just need to change the python to python3 :\nexport const Python = {\n \"Selection Based\": {\n command: \"python3\",\n args(context) {\n setEncoding()\n const code = context.getCode()\n const tmpFile = GrammarUtils.createTempFileWithCode(code)\n return [\"-u\", tmpFile]\n },\n },\n\n \"File Based\": {\n command: \"python3\",\n args({ filepath }) {\n setEncoding()\n return [\"-u\", filepath]\n },\n },\n}\n\nSave the file and close it and return to your program and run your program using Run Script or Ctrl + shift + b .\nYou will get the following result\n\nEverything will work fine.\n", "Just add your command in the Configure Run Options and save it. Then use 'Run with Profile' to use the command to execute your script. This worked for me.\n\n", "I have Atom v1.57.0 application installed in Ubuntu 20.04 and the atom package called script is installed to execute python3 scripts.\nTo allow Atom configuration to run python3 script persistently, I installed the python-is-python3 package by running the terminal command sudo apt install python-is-python3. These links 1 and 2 explain what it is. So simply pressing Ctrl+Shift+B or Run Script will run the python3 scripts persistently by default and without error messages.\nIf you do not want python to be replace python3 at the system-wide level, you can uninstalled python-is-python3, i.e. run terminal command sudo apt remove python-is-python3. Then in Atom, pressed Ctrl+Shift+P, typed script and selected Script: Run Options. For Command, you can key in the path /usr/bin/python3.8 or /usr/bin/python3 to define using python3.8 or python3 to execute your python script. Thereafter, you have to click on Save as profile, give it a profile name and then selected that profile name to execute your python script. See this video that was created by Corey-Schafer from 18.21mins. It shows you what to do. So finally, instead of using Ctrl+Shift+B or Run Script to execute your script, you now have to use Alt+Ctrl+Shift+B or Run With Profile to execute the script. More tedious but this approach allows finer control. For folks who want to use Atom to run different version-types of Python scripts.\n" ]

[ 33, 12, 6, 4, 3, 2, 1, 1, 1, 0, 0 ]

[]

[]

[ "atom_editor", "path", "python", "python_3.x" ]

[ "To convert a hexadecimal string to a list of hexadecimal values, each one byte long, you can use the binascii.unhexlify() method from the binascii module. This method takes a hexadecimal string as its input, and returns a bytes object containing the corresponding binary data.\nYou can then use the bytearray() constructor to convert the bytes object to a bytearray, which is similar to a list, but allows you to manipulate the individual bytes.\nHere is an example of how you could use these methods to convert the hexadecimal string you provided:\nimport binascii\n\n# Define the hexadecimal string\nhex_string = '7609a2fed47be9131ea1b803afc517b8'\n\n# Use the unhexlify() method to convert the hexadecimal string to a bytes object\nbytes_obj = binascii.unhexlify(hex_string)\n\n# Use the bytearray() constructor to convert the bytes object to a bytearray\nhex_list = bytearray(bytes_obj)\n\n# Display the resulting bytearray\nprint(hex_list)\n\nThis code should produce the following output:\nbytearray(b'v\\t\\xa2\\xfe\\xd4{\\xe9\\x13\\x1e\\xa1\\xb8\\x03\\xaf\\xc5\\x17\\xb8')\n\nAs you can see, the hexadecimal string has been converted to a bytearray, where each element is one byte long.\nTo convert this bytearray to a list of decimal values, you can use the list() function to convert the bytearray to a regular list, and then use the map() function with the int() function to convert each element from hexadecimal to decimal.\nHere is an example of how you could do this:\n# Convert the bytearray to a regular list\nhex_list = list(hex_list)\n\n# Use the map() function with the int() function to convert each element from hexadecimal to decimal\ndecimal_list = list(map(int, hex_list))\n\n# Display the resulting list\nprint(decimal_list)\n\nThis code should produce the following output:\n[118, 9, 162, 254, 212, 123, 233, 19, 30, 161, 184, 3, 175, 197, 23, 184]\n\n", "Try this:\n# Hexadecimal to Decimal\nhex_string = '7609a2fed47be9131ea1b803afc517b8'\ndec_array = [int(hex_string[i:i+2], 16) for i in range(0, len(hex_string), 2)]\nprint(dec_array)\n# Output: [118, 9, 162, 254, 212, 123, 233, 19, 30, 161, 184, 3, 175, 197, 23, 184]\n\n" ]

[ 0, 0 ]

[]

[]

[ "arrays", "hex", "python" ]

[ "First of all, I recommend you to read the documentation\nhttps://docs.pytest.org/en/6.2.x/parametrize.html\nMy spider sense says \"KEY1K\" is a project requirement. Therefore, you can either keep or remove it from parametrization and setup on test function begin\[email protected](\"test_input,expected\", [(\"3+5\", 8), (\"2+4\", 6), (\"6*9\", 42)])\n\n\[email protected]('signature_algorithm, cipher, expected_value', [\n pytest.param(rsa_pss_rsae_sha256, AES128-GCM-SHA256, 'expected_result_1'),\n pytest.param(rsa_pss_rsae_sha384, AES128-GCM-SHA256, 'expected_result_2')\n]):\ndef test(signature_algorithm, cipher) :\n do_stuff(\"KEY1K\")\n # Do test stuff\n undo_stuff(\"KEY1K\")\n\n\n", "To call a function only once before the test starts you can use @pytest.fixture().\nFor this example we can call this a \"setup\" function but it can have any name you define. Add your functaion1(data) function call to the setup function.\nI commented out the functaion1(data) function call in my example since it is not clear where \"data\" is coming from.\nimport pytest\n\nclass Testonething:\n\n @pytest.fixture()\n def setup(self):\n print(\"setting up\")\n # functaion1(data)\n\n def test_one_thing(self, setup):\n print(\"This is branch1\")\n assert True\n\n" ]

[ 0, 0 ]

[]

[]

[ "pytest", "python" ]

[ "I think it's better to use the symmetric difference operation of sets to do that Here is the link to the doc.\n>>> dict1 = {1:'donkey', 2:'chicken', 3:'dog'}\n>>> dict2 = {1:'donkey', 2:'chimpansee', 4:'chicken'}\n>>> set1 = set(dict1.items())\n>>> set2 = set(dict2.items())\n>>> set1 ^ set2\n{(2, 'chimpansee'), (4, 'chicken'), (2, 'chicken'), (3, 'dog')}\n\nIt is symmetric because:\n>>> set2 ^ set1\n{(2, 'chimpansee'), (4, 'chicken'), (2, 'chicken'), (3, 'dog')}\n\nThis is not the case when using the difference operator.\n>>> set1 - set2\n{(2, 'chicken'), (3, 'dog')}\n>>> set2 - set1\n{(2, 'chimpansee'), (4, 'chicken')}\n\nHowever it may not be a good idea to convert the resulting set to a dictionary because you may lose information:\n>>> dict(set1 ^ set2)\n{2: 'chicken', 3: 'dog', 4: 'chicken'}\n\n", "Try the following snippet, using a dictionary comprehension:\nvalue = { k : second_dict[k] for k in set(second_dict) - set(first_dict) }\n\nIn the above code we find the difference of the keys and then rebuild a dict taking the corresponding values.\n", "Another solution would be dictdiffer (https://github.com/inveniosoftware/dictdiffer).\nimport dictdiffer \n\na_dict = { \n 'a': 'foo',\n 'b': 'bar',\n 'd': 'barfoo'\n} \n\nb_dict = { \n 'a': 'foo', \n 'b': 'BAR',\n 'c': 'foobar'\n} \n\nfor diff in list(dictdiffer.diff(a_dict, b_dict)): \n print diff\n\nA diff is a tuple with the type of change, the changed value, and the path to the entry.\n('change', 'b', ('bar', 'BAR'))\n('add', '', [('c', 'foobar')])\n('remove', '', [('d', 'barfoo')])\n\n", "You were right to look at using a set, we just need to dig in a little deeper to get your method to work.\nFirst, the example code:\ntest_1 = {\"foo\": \"bar\", \"FOO\": \"BAR\"}\ntest_2 = {\"foo\": \"bar\", \"f00\": \"b@r\"}\n\nWe can see right now that both dictionaries contain a similar key/value pair:\n{\"foo\": \"bar\", ...}\n\nEach dictionary also contains a completely different key value pair. But how do we detect the difference? Dictionaries don't support that. Instead, you'll want to use a set.\nHere is how to turn each dictionary into a set we can use:\nset_1 = set(test_1.items())\nset_2 = set(test_2.items())\n\nThis returns a set containing a series of tuples. Each tuple represents one key/value pair from your dictionary.\nNow, to find the difference between set_1 and set_2:\nprint set_1 - set_2\n>>> {('FOO', 'BAR')}\n\nWant a dictionary back? Easy, just:\ndict(set_1 - set_2)\n>>> {'FOO': 'BAR'}\n\n", "You can use DeepDiff:\npip install deepdiff\n\nAmong other things, it lets you recursively calculate the difference of dictionaries, iterables, strings and other objects:\n>>> from deepdiff import DeepDiff\n\n>>> d1 = {1:1, 2:2, 3:3, \"foo\":4}\n>>> d2 = {1:1, 2:4, 3:3, \"bar\":5, 6:6}\n>>> DeepDiff(d1, d2)\n{'dictionary_item_added': [root['bar'], root[6]],\n 'dictionary_item_removed': [root['foo']],\n 'values_changed': {'root[2]': {'new_value': 4, 'old_value': 2}}}\n\nIt lets you see what changed (even types), what was added and what was removed. It also lets you do many other things like ignoring duplicates and ignoring paths (defined by regex).\n", "A solution is to use the unittest module:\nfrom unittest import TestCase\nTestCase().assertDictEqual(expected_dict, actual_dict)\n\nObtained from How can you test that two dictionaries are equal with pytest in python\n", "This function gives you all the diffs (and what stayed the same) based on the dictionary keys only. It also highlights some nice Dict comprehension, Set operations and python 3.6 type annotations :)\nfrom typing import Dict, Any, Tuple\ndef get_dict_diffs(a: Dict[str, Any], b: Dict[str, Any]) -> Tuple[Dict[str, Any], Dict[str, Any], Dict[str, Any], Dict[str, Any]]:\n\n added_to_b_dict: Dict[str, Any] = {k: b[k] for k in set(b) - set(a)}\n removed_from_a_dict: Dict[str, Any] = {k: a[k] for k in set(a) - set(b)}\n common_dict_a: Dict[str, Any] = {k: a[k] for k in set(a) & set(b)}\n common_dict_b: Dict[str, Any] = {k: b[k] for k in set(a) & set(b)}\n return added_to_b_dict, removed_from_a_dict, common_dict_a, common_dict_b\n\nIf you want to compare the dictionary values:\nvalues_in_b_not_a_dict = {k : b[k] for k, _ in set(b.items()) - set(a.items())}\n\n", "A function using the symmetric difference set operator, as mentioned in other answers, which preserves the origins of the values:\ndef diff_dicts(a, b, missing=KeyError):\n \"\"\"\n Find keys and values which differ from `a` to `b` as a dict.\n\n If a value differs from `a` to `b` then the value in the returned dict will\n be: `(a_value, b_value)`. If either is missing then the token from \n `missing` will be used instead.\n\n :param a: The from dict\n :param b: The to dict\n :param missing: A token used to indicate the dict did not include this key\n :return: A dict of keys to tuples with the matching value from a and b\n \"\"\"\n return {\n key: (a.get(key, missing), b.get(key, missing))\n for key in dict(\n set(a.items()) ^ set(b.items())\n ).keys()\n }\n\nExample\nprint(diff_dicts({'a': 1, 'b': 1}, {'b': 2, 'c': 2}))\n\n# {'c': (<class 'KeyError'>, 2), 'a': (1, <class 'KeyError'>), 'b': (1, 2)}\n\nHow this works\nWe use the symmetric difference set operator on the tuples generated from taking items. This generates a set of distinct (key, value) tuples from the two dicts.\nWe then make a new dict from that to collapse the keys together and iterate over these. These are the only keys that have changed from one dict to the next.\nWe then compose a new dict using these keys with a tuple of the values from each dict substituting in our missing token when the key isn't present.\n", "Not sure this is what the OP asked for, but this is what I was looking for when I came across this question - specifically, how to show key by key the difference between two dicts:\nPitfall: when one dict has a missing key, and the second has it with a None value, the function would assume they are similar\nThis is not optimized at all - suitable for small dicts\ndef diff_dicts(a, b, drop_similar=True):\n res = a.copy()\n\n for k in res:\n if k not in b:\n res[k] = (res[k], None)\n\n for k in b:\n if k in res:\n res[k] = (res[k], b[k])\n else:\n res[k] = (None, b[k])\n\n if drop_similar:\n res = {k:v for k,v in res.items() if v[0] != v[1]}\n\n return res\n\n\nprint(diff_dicts({'a': 1}, {}))\nprint(diff_dicts({'a': 1}, {'a': 2}))\nprint(diff_dicts({'a': 2}, {'a': 2}))\nprint(diff_dicts({'a': 2}, {'b': 2}))\nprint(diff_dicts({'a': 2}, {'a': 2, 'b': 1}))\n\nOutput:\n{'a': (1, None)}\n{'a': (1, 2)}\n{}\n{'a': (2, None), 'b': (None, 2)}\n{'b': (None, 1)}\n\n", "This is my own version, from combining https://stackoverflow.com/a/67263119/919692 with https://stackoverflow.com/a/48544451/919692, and now I see it is quite similar to https://stackoverflow.com/a/47433207/919692:\ndef dict_diff(dict_a, dict_b, show_value_diff=True):\n result = {}\n result['added'] = {k: dict_b[k] for k in set(dict_b) - set(dict_a)}\n result['removed'] = {k: dict_a[k] for k in set(dict_a) - set(dict_b)}\n if show_value_diff:\n common_keys = set(dict_a) & set(dict_b)\n result['value_diffs'] = {\n k:(dict_a[k], dict_b[k])\n for k in common_keys\n if dict_a[k] != dict_b[k]\n }\n return result\n\n", "I would recommend using something already written by good developers. Like pytest. It has a deal with any data type, not only dicts. And, BTW, pytest is very good at testing.\nfrom _pytest.assertion.util import _compare_eq_any\n\nprint('\\n'.join(_compare_eq_any({'a': 'b'}, {'aa': 'vv'}, verbose=3)))\n\nOutput is:\nLeft contains 1 more item:\n{'a': 'b'}\nRight contains 1 more item:\n{'aa': 'vv'}\nFull diff:\n- {'aa': 'vv'}\n? - ^^\n+ {'a': 'b'}\n? ^\n\nIf you don't like using private functions (started with _), just have a look at the source code and copy/paste the function to your code.\nP.S.: Tested with pytest==6.2.4\n", "What about this? Not as pretty but explicit.\norig_dict = {'a' : 1, 'b' : 2}\nnew_dict = {'a' : 2, 'v' : 'hello', 'b' : 2}\n\nupdates = {}\nfor k2, v2 in new_dict.items():\n if k2 in orig_dict: \n if v2 != orig_dict[k2]:\n updates.update({k2 : v2})\n else:\n updates.update({k2 : v2})\n\n#test it\n#value of 'a' was changed\n#'v' is a completely new entry\nassert all(k in updates for k in ['a', 'v'])\n\n", "def flatten_it(d):\n if isinstance(d, list) or isinstance(d, tuple):\n return tuple([flatten_it(item) for item in d])\n elif isinstance(d, dict):\n return tuple([(flatten_it(k), flatten_it(v)) for k, v in sorted(d.items())])\n else:\n return d\n\ndict1 = {'a': 1, 'b': 2, 'c': 3}\ndict2 = {'a': 1, 'b': 1}\n\nprint set(flatten_it(dict1)) - set(flatten_it(dict2)) # set([('b', 2), ('c', 3)])\n# or \nprint set(flatten_it(dict2)) - set(flatten_it(dict1)) # set([('b', 1)])\n\n", "Old question, but thought I'd share my solution anyway. Pretty simple.\ndicta_set = set(dicta.items()) # creates a set of tuples (k/v pairs)\ndictb_set = set(dictb.items())\nsetdiff = dictb_set.difference(dicta_set) # any set method you want for comparisons\nfor k, v in setdiff: # unpack the tuples for processing\n print(f\"k/v differences = {k}: {v}\")\n\nThis code creates two sets of tuples representing the k/v pairs. It then uses a set method of your choosing to compare the tuples. Lastly, it unpacks the tuples (k/v pairs) for processing.\n", "This will return a new dict (only changed data).\ndef get_difference(obj_1: dict, obj_2: dict) -> dict:\nresult = {}\n\nfor key in obj_1.keys():\n value = obj_1[key]\n\n if isinstance(value, dict):\n difference = get_difference(value, obj_2.get(key, {}))\n\n if difference:\n result[key] = difference\n\n elif value != obj_2.get(key):\n result[key] = obj_2.get(key, None)\n\nreturn result\n\n", "Here is a variation that lets you update dict1 values if you know the values in dict2 are right.\nConsider:\ndict1.update((k, dict2.get(k)) for k, v in dict1.items())\n\n", "For one side comparison you can use dict comprehension:\ndict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}\ndict2 = {'a': OMG, 'b': 2, 'c': 3, 'd': 4}\n\ndata = {a:dict1[a] for a in dict1 if dict1[a] != dict2[a]}\n\noutput: {'a': 1}\n", "sharedmLst = set(a_dic.items()).intersection(b_dic.items())\ndiff_from_b = set(a_dic.items()) - sharedmLst\ndiff_from_a = set(b_dic.items()) - sharedmLst\n\nprint(\"Among the items in a_dic, the item different from b_dic\",diff_from_b)\nprint(\"Among the items in b_dic, the item different from a_dic\",diff_from_a)\n\n\nResult :\nAmong the items in a_dic, the item different from b_dic {('b', 2)}\nAmong the items in b_dic, the item different from a_dic {('b', 20)}\n\n" ]

[ 184, 108, 67, 12, 12, 10, 8, 8, 7, 6, 6, 5, 5, 3, 1, 0, 0, 0 ]

[]

[]

[ "dictionary", "python" ]

[ "As far as I know it only works with python 3.6 and 3.7 (lucidsonicdreams), although I didn't have success on 3.6. I had to create a virtual environment through conda and run code through Jupyter notebook. conda install tensorflow==1.15 (will not work with higher versions), python==3.7, pip install lucidsonicdreams in your new python 3.7 environment. Make sure module versions line up with your Nvidia CUDA drivers or lucidsonicdreams won't work.\n" ]

[ 0 ]

[]

[]

[ "anaconda", "librosa", "libsndfile", "python", "pythonpath" ]

[ "If I understood correctly, you just want a way to match the returned values from all your tasks to the instances of Foo whose url_to_download attributes you passed as arguments to said tasks.\nSince all you are doing in that last loop is blocking until all tasks are completed, you may as well simply run the coroutines concurrently via asyncio.gather. The order of the individual return values in the list it returns corresponds to the order of the coroutines passed to it as arguments:\nfrom asyncio import gather, run\nfrom dataclasses import dataclass\n\n\n@dataclass\nclass Foo:\n url_to_download: str\n ...\n\n\nasync def download_file(url: str):\n return url\n\n\nasync def main() -> None:\n objs: list[Foo] = [Foo(\"foo\"), Foo(\"bar\"), Foo(\"baz\")]\n returned_values = await gather(\n *(download_file(obj.url_to_download) for obj in objs)\n )\n print(returned_values) # ['foo', 'bar', 'baz']\n\n\nif __name__ == '__main__':\n run(main())\n\nThat means you can simply match the objs and returned_values via index or zip them or whatever you need to do.\n\nAs for your comment that saving the returned the returned value in an attribute of the object itself is \"poor design\", I see absolutely no justification for that assessment. That would also be a perfectly valid way and arguably even cleaner. You might even define a download method on Foo for that purpose. But that is another discussion.\n" ]

[ 0 ]

[]

[]

[ "python", "python_asyncio" ]

[ "For a single value, you can do: df[(df[:] != 20).all(axis = 1)]\nFor multiple values you can use numpy arrays to do elementwise boolean logic:\nar1 = np.array((df[:] != 20).all(axis = 1))\nar2 = np.array((df[:] != 30).all(axis = 1))\ndf[ar1 & ar2]\n\n", "To select rows in a Pandas DataFrame that do not contain a specific value, you can use the ~ operator to negate the DataFrame.isin() method. This method returns a Boolean mask indicating whether each element in the DataFrame is equal to one of the values you provide.\nFor example, to select rows in the DataFrame that do not contain the value 20, you can use the following code:\nimport pandas as pd\n\n# Load the DataFrame from a CSV file\ndata = pd.read_csv('data.csv')\n\n# Select the columns you want to include\nassignments = data.loc[:, ~data.columns.isin(['A', 'B', 'C'])]\n\n# Select rows that do not contain the value 20\nselected = data.loc[~data.isin([20]).any(axis=1)]\n\nThis code first selects the columns in the DataFrame that are not named 'A', 'B', or 'C'. It then uses the isin() method to create a Boolean mask indicating which rows contain the value 20. Finally, it uses the ~ operator to negate the mask, selecting only the rows that do not contain the value 20.\nTo include multiple values in the isin() method, you can pass them as a list or array to the values parameter. For example, to select rows that do not contain the values 20, 10, or 0, you can use the following code:\nimport pandas as pd\n\n# Load the DataFrame from a CSV file\ndata = pd.read_csv('data.csv')\n\n# Select the columns you want to include\nassignments = data.loc[:, ~data.columns.isin(['A', 'B', 'C'])]\n\n# Select rows that do not contain the values 20, 10, or 0\nselected = data.loc[~data.isin([20, 10, 0]).any(axis=1)]\n\n" ]

[ 1, 0 ]

[]

[]

[ "csv", "pandas", "python" ]

[ "Do you want to remove 1 value on each border?\na = np.array([[ 0, 1, 2, 3, 4],\n [ 5, 6, 7, 8, 9],\n [10, 11, 12, 13, 14],\n [15, 16, 17, 18, 19]])\n\nout = a[1:a.shape[0]-1, 1:a.shape[1]-1]\n\nGeneralization for N:\nN = 1\na[N:a.shape[0]-N, N:a.shape[1]-N]\n\nOutput:\narray([[ 6, 7, 8],\n [11, 12, 13]])\n\n", "Your specific example:\narr = np.array([[0, 1, 2, 3, 4],\n [5, 6, 7, 8, 9],\n [10, 11, 12, 13, 14],\n [15, 16, 17, 18, 19]])\narr[1:3, 1:4]\n\nStrip function in general:\ndef strip_func(arr, r1, r2, c1, c2):\n return(arr[r1:r2+1, c1:c2+1])\n\nr1 and r2 is the beginning and end of the range of rows that you want to subset. c1 and c2 is the same but for the columns.\n", "A solution that works only for the specified use case wwould be:\ndef fun_strip(array):\n return np.array([array[1][1:4],array[2][1:4]])\n\nYou need to specvify better what the use case rappresent if you want a better,more general implementation\n" ]

[ 1, 0, 0 ]

[]

[]

[ "numpy", "python", "strip" ]

[ "Updated Answer\nThe logic that @mozway gave was an elegant one liner which i liked a lot but for some reason does not work always. Also it does not give the non nan values in the extra columns.\nI managed to get it working in a slightly long but relatively simple to understand logic. Here goes:\n#read the excel file\ndf = pd.read_excel('df.xlsx')\n\n#subset the df into original and extra df's\nextra = df.filter(regex=(\"Unnamed:.*\"))\noriginal = df.drop(extra, axis = 1)\n\n#ori contains a list of count of NaN values in original columns as asked \nori = original.isnull().sum(axis=1).tolist() #or to_dict() if you want a dict\next = len(extra.columns) - extra.isnull().sum(axis=1)\n#ext1 contains a list of count of non NaN values in the extra columns as asked\next1 = ext.tolist() # or to_dict() if you want a dict\n\nOriginal comment/answer\n@mozway As mentioned in the comments I am adding your code I tried to apply the logic to only a subset of dataframe:\nextra = df.filter(regex=(\"Unnamed:.*\"))\ny = extra.isna().cummin(axis=1).sum(axis=1).clip(upper=2).tolist()\n\nAccording to the dataframe the output should be [1, 2, 0, 1] (as there are 1 nan values in row 1, 2 in row 2 0 in row 3 and 1 in row 4) but the above code is giving output [0, 2, 0, 1]\n", "You can use isna and cummin to identify the leading NAs, then sum to count them and clip to limit the shift to the original number of columns:\ndf.isna().cummin(axis=1).sum(axis=1).clip(upper=2)\n\nOutput:\n0 1\n1 0\n2 2\n3 2\ndtype: int64\n\nIntermediates:\ndf.isna()\n\n Heading 1 Heading 2 Unnamed: 1 Unnamed: 2\n0 True False False True\n1 False False True True\n2 True True False False\n3 True True True False\n\ndf.isna().cummin(axis=1)\n\n Heading 1 Heading 2 Unnamed: 1 Unnamed: 2\n0 True False False False\n1 False False False False\n2 True True False False\n3 True True True False\n\ndf.isna().cummin(axis=1).sum(axis=1)\n\n0 1\n1 0\n2 2\n3 3\ndtype: int64\n\n" ]

[ 1, 0 ]

[]

[]

[ "data_cleaning", "data_preprocessing", "dataframe", "pandas", "python" ]

[ "a['Names'].str.contains('Mel') will return an indicator vector of boolean values of size len(BabyDataSet)\nTherefore, you can use\nmel_count=a['Names'].str.contains('Mel').sum()\nif mel_count>0:\n print (\"There are {m} Mels\".format(m=mel_count))\n\nOr any(), if you don't care how many records match your query\nif a['Names'].str.contains('Mel').any():\n print (\"Mel is there\")\n\n", "You should use any()\nIn [98]: a['Names'].str.contains('Mel').any()\nOut[98]: True\n\nIn [99]: if a['Names'].str.contains('Mel').any():\n ....: print(\"Mel is there\")\n ....:\nMel is there\n\na['Names'].str.contains('Mel') gives you a series of bool values\nIn [100]: a['Names'].str.contains('Mel')\nOut[100]:\n0 False\n1 False\n2 False\n3 False\n4 True\nName: Names, dtype: bool\n\n", "OP meant to find out whether the string 'Mel' exists in a particular column, not contained in any string in the column. Therefore the use of contains is not needed, and is not efficient.\nA simple equals-to is enough:\ndf = pd.DataFrame({\"names\": [\"Melvin\", \"Mel\", \"Me\", \"Mel\", \"A.Mel\"]})\n\nmel_count = (df['names'] == 'Mel').sum() \nprint(\"There are {num} instances of 'Mel'. \".format(num=mel_count)) \n \nmel_exists = (df['names'] == 'Mel').any() \nprint(\"'Mel' exists in the dataframe.\".format(num=mel_exists)) \n\nmel_exists2 = 'Mel' in df['names'].values \nprint(\"'Mel' is in the dataframe: \" + str(mel_exists2)) \n\nPrints:\nThere are 2 instances of 'Mel'. \n'Mel' exists in the dataframe.\n'Mel' is in the dataframe: True\n\n", "I bumped into the same problem, I used:\nif \"Mel\" in a[\"Names\"].values:\n print(\"Yep\")\n\nBut this solution may be slower since internally pandas create a list from a Series.\n", "If there is any chance that you will need to search for empty strings, \n a['Names'].str.contains('') \n\nwill NOT work, as it will always return True.\nInstead, use\n if '' in a[\"Names\"].values\n\nto accurately reflect whether or not a string is in a Series, including the edge case of searching for an empty string. \n", "For case-insensitive search.\na['Names'].str.lower().str.contains('mel').any()\n\n", "Pandas seem to be recommending df.to_numpy since the other methods still raise a FutureWarning: https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.to_numpy.html#pandas.DataFrame.to_numpy\nSo, an alternative that would work int this case is:\nb=a['Names']\nc = b.to_numpy().tolist()\nif 'Mel' in c:\n print(\"Mel is in the dataframe column Names\")\n\n", "import re\ns = 'string'\n\ndf['Name'] = df['Name'].str.findall(s, flags = re.IGNORECASE)\n\n#or\ndf['Name'] = df[df['Name'].isin(['string1', 'string2'])]\n\n", "import pandas as pd\n\n(data_frame.col_name=='str_name_to_check').sum()\n\n", "If you want to save the results then you can use this:\na['result'] = a['Names'].apply(lambda x : ','.join([item for item in str(x).split() if item.lower() in ['mel', 'etc']]))\n\n", "To check if a particular string exists in a column of a Pandas DataFrame, you can use the DataFrame.str.contains() method. This method returns a Boolean mask indicating which elements in the column contain the string you provide.\nHowever, the str.contains() method cannot be used directly in an if statement, because it returns a series of Boolean values instead of a single value. To use the str.contains() method in an if statement, you need to use one of the methods that return a single value, such as any(), all(), or bool().\nFor example, to check if the string 'Mel' exists in the 'Names' column of the DataFrame you provided, you can use the following code:\nimport pandas as pd\n\n# Define the data\nBabyDataSet = [('Bob', 968), ('Jessica', 155), ('Mary', 77), ('John', 578), ('Mel', 973)]\n\n# Create a DataFrame from the data\na = pd.DataFrame(data=BabyDataSet, columns=['Names', 'Births'])\n\n# Use the str.contains() method with the any() method to check if the 'Names' column contains 'Mel'\nif a['Names'].str.contains('Mel').any():\n print(\"Mel is there\")\n\nThis code uses the any() method to check if any of the elements in the 'Names' column contain the string 'Mel'. If at least one element contains this string, the if statement will be executed and the message \"Mel is there\" will be printed.\n" ]

[ 165, 36, 20, 8, 3, 3, 2, 2, 1, 0, 0 ]

[ "You should check the value of your line of code like adding checking length of it.\nif(len(a['Names'].str.contains('Mel'))>0):\n print(\"Name Present\")\n\n" ]

[ -1 ]

[ "pandas", "python" ]

[ "Merge all df's into one df. Then group by id and calculate the median of each group.\ndf = pd.concat([df_1,df_2,df_3])\ndf = df.groupby('#id').agg({'values':'median'})\n'''\n#id values\n1 2.0\n2 5.0\n3 5.5\n4 5.0\n5 7.0\n\n'''\n\nWrite to excel:\ndf.reset_index().to_excel('give_an_excel_name.xlsx',index=None)\n#or\ndf.to_excel('give_an_excel_name.xlsx')\n\n" ]

[ 0 ]

[]

[]

[ "numpy", "pandas", "python" ]

[ "Follow the instructions provided here. I think its related to the problem you are having on pygame and PyCharm on windows. \nHow do I download Pygame for Python 3.5.1?\n", "its bcus pycharme has not recognised you're env or working on wrong env\n\nhttps://www.jetbrains.com/help/pycharm/creating-virtual-environment.html\ncheck this\n" ]

[ 0, 0 ]

[]

[]

[ "failed_installation", "pycharm", "pygame", "python", "python_3.x" ]

[ "This bug has been fixed in PyCharm 2022.1, the Unresolved attribute reference warning is now correctly shown by the IDE's linter.\n\n" ]

[ 1 ]

[]

[]

[ "enums", "pycharm", "python" ]

[ "I would use:\n(df_.pivot(index='time', columns='group', values='value')\n # reindex only of you want to add missing times for all groups\n .reindex(range(df_['time'].min(), df_['time'].max()+1))\n .ffill().unstack().reset_index(name='value')\n)\n\nOutput:\n group time value\n0 A 1 100.0\n1 A 2 105.0\n2 A 3 105.0\n3 A 4 111.0\n4 B 1 200.0\n5 B 2 200.0\n6 B 3 234.0\n7 B 4 222.0\n\n", "Instead of a template dataframe you could create a new index and then reindex with ffill:\nnew_idx = pd.MultiIndex.from_product([list('AB'), range(1,5)], names=['group', 'time'])\ndf_.set_index(['group', 'time']).reindex(new_idx, method='ffill').reset_index()\n\nThe result keeps the datatype of the value column:\n group time value\n0 A 1 100\n1 A 2 105\n2 A 3 105\n3 A 4 111\n4 B 1 200\n5 B 2 200\n6 B 3 234\n7 B 4 222\n\n" ]

[ 2, 1 ]

[]

[]

[ "pandas", "python" ]

[ "After a long time looking for a anwser, I didn't find quickly. So to help someone else this is what helps me.\nThe link about this issues is: https://youtrack.jetbrains.com/issue/PY-50116\nSolution:\n\nIn menus bar go to Run/Debug Configurations\n\n\n\nAdd a New Configuration\n\n\n\nClick on Python\n\n\n\nRename the Configuration\n\n\n\nSelect the script\n\n\n\nUncheck the \"Run with Python Console\" option\n\n\n\nDONE =D\n\n" ]

[ 1 ]

[]

[]

[ "multiprocessing", "pycharm", "python", "python_3.x" ]

[ "According to airflow XCOM documentation(https://airflow.apache.org/docs/apache-airflow/stable/concepts/xcoms.html), you might wish to use templated result:\nPythonSensor(\n task_id=\"poll_job_status\",\n poke_interval=POKE_INTERVAL,\n timeout={{ task_instance.xcom_pull(task_ids='t1', key='timeout') }}, # value pushed into xcom in t1\n mode=MODE,\n soft_fail=True,\n python_callable=t2 \n )\n\n" ]

[ 0 ]

[]

[]

[ "airflow", "python" ]

[ "If the JSON files are very large then loading them (as Python dictionaries) will be I/O bound. Therefore, multithreading would be appropriate for parallelisation.\nRather than having discrete variables for each dictionary, why not have a single dictionary keyed on the significant numeric part of the filename(s).\nFor example:\nfrom concurrent.futures import ThreadPoolExecutor as TPE\nfrom json import load as LOAD\nfrom sys import stderr as STDERR\n\nNFILES = 8\nJDATA = {}\n\ndef get_json(n):\n try:\n with open(f'part_00{n}.json') as j:\n return n, LOAD(j)\n except Exception as e:\n print(e, file=STDERR)\n return n, None\n\ndef main():\n with TPE() as tpe:\n JDATA = dict(tpe.map(get_json, range(NFILES)))\n\nif __name__ == '__main__':\n main()\n\nAfter running this, the dictionary representation of the JSON file part_005.json (for example) would be accessible as JDATA[5]\nNote that if an exception arises during accessing or processing of any of the files, the relevant dictionary value will be None\n" ]

[ 1 ]

[]

[]

[ "for_loop", "json", "list", "python" ]

[ "You should do nothing. Unless you create an accessor property these attributes are already inaccessible from Python. Python cannot automatically see C/C++ struct members.\n" ]

[ 1 ]

[]

[]

[ "c++", "python", "python_c_api" ]

[ "You have two issues here, and they are all in this line:\nextensions = [\"dat\", \"ssp\", \"dta\", \"20dta\", \"u20dta\", \"f1dta\", \"f2dta\", \"v9\", \"xlsx\"]\n\nFirst issue\nThe first issue is in the order of the elements of this list. \"dat\" and \"dta\" are substrings of other elements in this string and they are at the front of this list. Let's take an example: h47f1dat.zip needs to become h47. But in these lines:\nreplacements = dict.fromkeys((f\"{ext}[.]zip$\" for ext in extensions), \"\")\ndf[\"file_id\"] = df[\"full_url\"].str.split(\"/\").str[-1].replace(replacements, regex=True)\n\nYou keep the order, meaning that you'll first be filtering with the \"dat\" string, which becomes h47f1. This can be easily fixed by reordering your list.\nSecond issue\nYou missed an entry in your extensions list: if you want h47f1dat.zip to become h47 you need to have \"f1dat\" in your list but you only have \"f1dta\".\nConclusion\nYou were almost there! There was simply a small issue with the order of the elements and one extension was missing (or you have a typo in your URLs).\nThe following extensions list:\nextensions = [\"ssp\", \"20dta\", \"u20dta\", \"f1dat\", \"f1dta\", \"f2dta\", \"v9\", \"dat\", \"dta\", \"xlsx\"]\n\nTogether with the rest of your code gives you the result you want:\n0 h225 \n1 h51b \n2 h47 \n3 h225 \n4 h220i \n5 h220h \n6 h220e \n7 h224 \n8 h36brr \n9 h36u \n10 h197i \n11 h197i\n\n", "Good catch about the issue of the order of the elements and the missing extension! Thank you.\nQuestion 1: Do you mean the list extensions is not sorted alphabetically? Can I not use the Python sort() method to sort the list? I have over one thousand rows in the actual dataframe, and I prefer to sort the list programmatically. I hope I do not misunderstand your comments.\nQuestion 2: I don't understand why I am getting h36u instead of the desired value h36 in the output even after reordering the list as you suggested. Any thoughts?\nI have tried another approach (code below) using Jupyter Lab, which provides the output in which the first two values are different from the desired output (also shown below), but the other values seem to be what I desire including h36.\ndf[\"file_id\"] = df[\"full_url\"].str.split(\"/\").str[-1].str.replace(r'(\\dat.zip \\\n|f1dat.zip|dta.zip|f1dta.zip|f2dta.zip|20dta.zip|u20dta.zip|xlsx.zip|v9.zip|ssp.zip)' \\\n,'', regex=True)\nprint(df[\"file_id\"])\n\nOutput (annotated)\n0 h225dat.zip (not desired; h225 desired)\n1 h51bdat.zipn (not desired; h51b desired)\n2 h47\n3 h225\n4 h220i\n5 h220h\n6 h220e\n7 h224\n8 h36brr\n9 h36\n10 h197i\n11 h197i\n\n\nQuestion 3: Any comments on the above alternative code snippets?\n" ]

[ 0, 0 ]

[]

[]

[ "python", "regex" ]

[ "you can use regex to do the same but I prefer to just use python.\nstring classes in python can be split to list of words. (join can join a list to string). while using word in list_of_words will help you understand if word is in the list.\nkeywords=['special','dreams']\nfound = True\nfor word in keywords:\n if not word in search_string1.split():\n found = False\n\n", "Could be not the best idea, but we could check if one set is a part of another set:\nkeywords = ['special', 'dreams']\n\nstrs = [\n \"This is something that manifests especially in dreams\",\n \"This is something that manifests in special cases in dreams\"\n]\n\n_keywords = set(keywords)\nfor s in strs:\n s_set = set(s.split())\n if _keywords.issubset(s_set):\n print(f\"Matched: {s}\")\n\n", "Axe319's comment works and is closest to my original question of how to solve the problem using regex. To quote the solution again:\nall(re.search(fr'\\b{x}\\b', search_text) for x in keywords)\nThanks to everyone!\n" ]

[ 1, 1, 1 ]

[]

[]

[ "python", "string" ]

[ "As what the name locals means, it stores only local variables. So locals() inside the function just contains local variables defined inside the function.\nIt is not recommended to use locals() like this. Just use a normal dictionary instead:\n...\n# Example: Change Frame Color to Blue\ndef change_background(frame_id):\n widgets[frame_id].config(bg=\"blue\")\n\n# Root Window\nroot = Tk()\nroot.geometry(\"800x600\")\n\n# Widget Creation\n# use a normal dictionary instead of locals()\nwidgets = {}\nfor item in new_dict[\"items\"]:\n if item[\"type\"] == \"frame\":\n frame_id = item[\"id\"]\n widgets[item[\"id\"]] = Frame(root, width=200, height=200, bg=\"green\")\n widgets[item[\"id\"]].pack(side=BOTTOM, fill=BOTH)\n elif item[\"type\"] == \"button\":\n widgets[item[\"id\"]] = Button(root, text=item[\"text\"], command=lambda: change_background(frame_id))\n widgets[item[\"id\"]].place(x=50, y=50, anchor=CENTER)\n...\n\n" ]

[ 1 ]

[]

[]

[ "dictionary", "python", "tkinter", "variables" ]

[ "You can use merge with kwargs left_on and right_on:\npd.merge(left, right, how=\"left\", left_on=\"A\", right_on=\"C\")\n\nOutput:\n A B C D\n0 A0 B0 A0 D0\n1 A1 B1 A1 D2\n2 A2 B2 A2 D3\n\nEdit: you can drop the C column with .drop(\"C\", axis=1)\n" ]

[ 1 ]

[]

[]

[ "pandas", "python" ]

[ "Hard to say about time complexity, but the first is actually faster at runtime, presumably because it doesn't involve\n\na name lookup (all)\na function call (all)\na generator expression\na list construction (['a','b','c']) (though this may be negligible for an imported module)\nSee comments.\n\nSee for yourself:\n# All found\n~ $ python3 -m timeit -s \"line = 'fooabc'\" \"'a' in line and 'b' in line and 'c' in line\"\n20000000 loops, best of 5: 55 nsec per loop\n~ $ python3 -m timeit -s \"line = 'fooabc'\" \"all( sub_str in line for sub_str in ['a','b','c'])\"\n5000000 loops, best of 5: 397 nsec per loop\n# None found\n~ $ python3 -m timeit -s \"line = 'fooddd'\" \"'a' in line and 'b' in line and 'c' in line\"\n50000000 loops, best of 5: 25.2 nsec per loop\n~ $ python3 -m timeit -s \"line = 'fooddd'\" \"all( sub_str in line for sub_str in ['a','b','c'])\"\n5000000 loops, best of 5: 325 nsec per loop\n\n", "Both are O(mn) where m is the number of values to search and n is the length of the string.\nThere is no simple way to do asymptotically better. If you wanted to test for or instead of and, you could write a regex like a|b|c and it would take O(n) time to scan a string of length n, so long as you use a regular expression library which guarantees linear time searches (which is possible by using finite automata, but the standard library's re module doesn't give this guarantee).\nBut you want to test whether all of the patterns match, which is harder to do with a regex. If the patterns cannot overlap, then a regular expression can still work; you will need to iterate through the matches and keep track of which patterns have been found so far (e.g. using a set). Again, this will take O(n) time if you use a regex library that guarantees linear time searches.\nIf the patterns can overlap, then it's still not theoretically impossible to do with a regex (because an intersection of regular languages is regular), but it's impractical. An alternative approach would be something like the Aho–Corasick algorithm which can find all matches of a set of strings in O(n) time, including overlapping matches. This algorithm is not available in the standard library but there appear to be several third-party packages which implement it.\nAll of that said, if m is small then I expect it is hard to get any significant improvement in actual running time compared to the simple O(mn) approach, even if other algorithms theoretically have a lower complexity.\n", "\nI want to know if there is any time-complexity difference between the two approaches.\n\nTL;DR: no.\nThe all() approach has overhead inherent in calling a function, and producing a generator for the argument to all() also has a cost. But I expect these costs each to scale as O(1) with any problem dimension you choose, and you perform each one exactly once, so they have no impact on asymptotic complexity.\nI expect execution of an all() to contribute a linear scale factor with respect to the number or elements available from the iterable presented to it. In the first program, however, changing the number of elements to test would require modifying the program, so this number is not an adjustable parameter. Therefore, scaling with respect to it is irrelevant for the purposes of the comparison we're considering.\nSupposing that the \"Do something\" is the same in both cases, there remains only the evaluations of expressions of the form x in line. The two alternatives evaluate the same number of such expressions, with the same operands, so these scale the same in the two alternatives.\n" ]

[ 6, 1, 1 ]

[]

[]

[ "python" ]

[ "We can use df.applymap(), with dict comprehension to convert each list to a dict, like this:\ndf[col_list] = df[col_list].applymap(lambda lst: {k: v for k, v in lst})\n\n", "import pandas as pd\n\ndf = pd.DataFrame.from_records([{'01AB': [(\"ABC\", 5),(\"XYZ\", 4),(\"LMN\", 1)], '02AB_QTY': [(\"Other\", 20),(\"not_Other\", 150)]}])\n\nout_dict = dict()\nfor col in df.columns:\n out_dict[col] = dict(df[col][0])\n\nOutput:\n{'01AB': {'ABC': 5, 'XYZ': 4, 'LMN': 1},\n '02AB_QTY': {'Other': 20, 'not_Other': 150}}\n\n", "You can use a dictionary comprehension:\nout = {k: dict(x) for k,v in df.iloc[0].to_dict().items()}\n\nOutput:\n{'01AB': {'ABC': 5, 'XYZ': 4, 'LMN': 1},\n '02AB_QTY': {'ABC': 5, 'XYZ': 4, 'LMN': 1}}\n\n", "thanks for all the leads, I was able to resolve the issue like below -\nimport pandas as pd\n\ndf = pd.DataFrame.from_records([{'01AB': [(\"ABC\", 5),(\"XYZ\", 4),(\"LMN\", 1)], '02AB_QTY': [(\"Other\", 20),(\"not_Other\", 150)]}])\n\ncol_list = [\"01AB\", \"02AB_QTY\",]\n\nprint(df)\n\nfor col in col_list:\n df[col] = df[col].apply(lambda x: {} if x is None else dict(x))\n\nprint(df)\n\nOutPut -\n01AB 02AB_QTY\n{'ABC': 5, 'XYZ': 4, 'LMN': 1} {'Other': 20, 'not_Other': 150}\n\n" ]

[ 1, 1, 1, 0 ]

[]

[]

[ "amazon_dynamodb", "lambda", "pandas", "python" ]

[ "Actually I found the issue. When downgrading tensorflow I used the --user option, so 2.6 version was installed in a user-specific location of machine A, not accessible from machine B.\n" ]

[ 0 ]

[]

[]

[ "pip", "python", "python_install" ]

[ "what does (random.randint(0,9)) in (x) means?\nYou try iterate over int/number. You need to create an iterable object to loop over it like list, tuple, range etc.\n", "If you want to iterate until x==y you should use a while loop. for loops iterate over a sequence.\nYou could do something like\nimport random\nx = (random.randint(0,9))\nprint (x)\ny = (random.randint(0,9))\nprint (y)\nwhile y != x:\n y = (random.randint(0,9))\n\nIn general do not put assignations inside conditions (we are not in C!)\n" ]

[ 0, 0 ]

[]

[]

[ "loops", "numbers", "python", "random", "typeerror" ]

[ "Your current directory is automatically added to sys.path by locust, according to the documentation https://docs.locust.io/en/stable/writing-a-locustfile.html#how-to-structure-your-test-code\nTry going to the parent directory and run\nlocust -f amapitest/my_locustfiles/instr_performance.py\n", "Ive solved my problem by moving \"my_locustfiles\" folder into root directory of project and running test from this directory.\nI still dont understand why locust cant find imported methods when locust file was located in \"amapitest\"\nbut...anyway, thanks everyone\n", "\nprint(sys.path) to see the path that helps Python to find modules.\n\nIf the path is found. e.g. Let's say \"/Users/user/SomeFolder/amapitest/\", try @Cyberwiz's comment, adding __init__.py file in every folder to turn folders to modules. Execute locust at amapitest folder\n\n\nIf you want to execute locust at sub-folder and module not found still happened, try Step 3.\n\nWithin instr_performance.py, append parent path like this\nsys.path.append(\n os.path.join(\n os.path.dirname(__file__), '..'\n )\n)\n\nYou will see '/Users/user/SomeFolder/amapitest/my_locustfiles/..' when print(sys.path), I think this workaround may helps\n\n" ]

[ 0, 0, 0 ]

[]

[]

[ "locust", "performance_testing", "pytest", "python", "web_api_testing" ]

[ "Yet another step ahead from dano's and Connor's answers is to wrap the whole thing as a context manager:\nimport contextlib\nimport joblib\nfrom tqdm import tqdm\n\[email protected]\ndef tqdm_joblib(tqdm_object):\n \"\"\"Context manager to patch joblib to report into tqdm progress bar given as argument\"\"\"\n class TqdmBatchCompletionCallback(joblib.parallel.BatchCompletionCallBack):\n def __call__(self, *args, **kwargs):\n tqdm_object.update(n=self.batch_size)\n return super().__call__(*args, **kwargs)\n\n old_batch_callback = joblib.parallel.BatchCompletionCallBack\n joblib.parallel.BatchCompletionCallBack = TqdmBatchCompletionCallback\n try:\n yield tqdm_object\n finally:\n joblib.parallel.BatchCompletionCallBack = old_batch_callback\n tqdm_object.close()\n\nThen you can use it like this and don't leave monkey patched code once you're done:\nfrom math import sqrt\nfrom joblib import Parallel, delayed\n\nwith tqdm_joblib(tqdm(desc=\"My calculation\", total=10)) as progress_bar:\n Parallel(n_jobs=16)(delayed(sqrt)(i**2) for i in range(10))\n\nwhich is awesome I think and it looks similar to tqdm pandas integration.\n", "Why can't you simply use tqdm? The following worked for me\nfrom joblib import Parallel, delayed\nfrom datetime import datetime\nfrom tqdm import tqdm\n\ndef myfun(x):\n return x**2\n\nresults = Parallel(n_jobs=8)(delayed(myfun)(i) for i in tqdm(range(1000))\n100%|██████████| 1000/1000 [00:00<00:00, 10563.37it/s]\n\n", "The documentation you linked to states that Parallel has an optional progress meter. It's implemented by using the callback keyword argument provided by multiprocessing.Pool.apply_async:\n# This is inside a dispatch function\nself._lock.acquire()\njob = self._pool.apply_async(SafeFunction(func), args,\n kwargs, callback=CallBack(self.n_dispatched, self))\nself._jobs.append(job)\nself.n_dispatched += 1\n\n...\nclass CallBack(object):\n \"\"\" Callback used by parallel: it is used for progress reporting, and\n to add data to be processed\n \"\"\"\n def __init__(self, index, parallel):\n self.parallel = parallel\n self.index = index\n\n def __call__(self, out):\n self.parallel.print_progress(self.index)\n if self.parallel._original_iterable:\n self.parallel.dispatch_next()\n\nAnd here's print_progress:\ndef print_progress(self, index):\n elapsed_time = time.time() - self._start_time\n\n # This is heuristic code to print only 'verbose' times a messages\n # The challenge is that we may not know the queue length\n if self._original_iterable:\n if _verbosity_filter(index, self.verbose):\n return\n self._print('Done %3i jobs | elapsed: %s',\n (index + 1,\n short_format_time(elapsed_time),\n ))\n else:\n # We are finished dispatching\n queue_length = self.n_dispatched\n # We always display the first loop\n if not index == 0:\n # Display depending on the number of remaining items\n # A message as soon as we finish dispatching, cursor is 0\n cursor = (queue_length - index + 1\n - self._pre_dispatch_amount)\n frequency = (queue_length // self.verbose) + 1\n is_last_item = (index + 1 == queue_length)\n if (is_last_item or cursor % frequency):\n return\n remaining_time = (elapsed_time / (index + 1) *\n (self.n_dispatched - index - 1.))\n self._print('Done %3i out of %3i | elapsed: %s remaining: %s',\n (index + 1,\n queue_length,\n short_format_time(elapsed_time),\n short_format_time(remaining_time),\n ))\n\nThe way they implement this is kind of weird, to be honest - it seems to assume that tasks will always be completed in the order that they're started. The index variable that goes to print_progress is just the self.n_dispatched variable at the time the job was actually started. So the first job launched will always finish with an index of 0, even if say, the third job finished first. It also means they don't actually keep track of the number of completed jobs. So there's no instance variable for you to monitor.\nI think your best best is to make your own CallBack class, and monkey patch Parallel:\nfrom math import sqrt\nfrom collections import defaultdict\nfrom joblib import Parallel, delayed\n\nclass CallBack(object):\n completed = defaultdict(int)\n\n def __init__(self, index, parallel):\n self.index = index\n self.parallel = parallel\n\n def __call__(self, index):\n CallBack.completed[self.parallel] += 1\n print(\"done with {}\".format(CallBack.completed[self.parallel]))\n if self.parallel._original_iterable:\n self.parallel.dispatch_next()\n\nimport joblib.parallel\njoblib.parallel.CallBack = CallBack\n\nif __name__ == \"__main__\":\n print(Parallel(n_jobs=2)(delayed(sqrt)(i**2) for i in range(10)))\n\nOutput:\ndone with 1\ndone with 2\ndone with 3\ndone with 4\ndone with 5\ndone with 6\ndone with 7\ndone with 8\ndone with 9\ndone with 10\n[0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]\n\nThat way, your callback gets called whenever a job completes, rather than the default one.\n", "Expanding on dano's answer for the newest version of the joblib library. There were a couple of changes to the internal implementation.\nfrom joblib import Parallel, delayed\nfrom collections import defaultdict\n\n# patch joblib progress callback\nclass BatchCompletionCallBack(object):\n completed = defaultdict(int)\n\n def __init__(self, time, index, parallel):\n self.index = index\n self.parallel = parallel\n\n def __call__(self, index):\n BatchCompletionCallBack.completed[self.parallel] += 1\n print(\"done with {}\".format(BatchCompletionCallBack.completed[self.parallel]))\n if self.parallel._original_iterator is not None:\n self.parallel.dispatch_next()\n\nimport joblib.parallel\njoblib.parallel.BatchCompletionCallBack = BatchCompletionCallBack\n\n", "TLDR solution:\nWorks with joblib 0.14.0 and tqdm 4.46.0 using python 3.5. Credits to frenzykryger for contextlib suggestions, dano and Connor for monkey patching idea.\nimport contextlib\nimport joblib\nfrom tqdm import tqdm\nfrom joblib import Parallel, delayed\n\[email protected]\ndef tqdm_joblib(tqdm_object):\n \"\"\"Context manager to patch joblib to report into tqdm progress bar given as argument\"\"\"\n\n def tqdm_print_progress(self):\n if self.n_completed_tasks > tqdm_object.n:\n n_completed = self.n_completed_tasks - tqdm_object.n\n tqdm_object.update(n=n_completed)\n\n original_print_progress = joblib.parallel.Parallel.print_progress\n joblib.parallel.Parallel.print_progress = tqdm_print_progress\n\n try:\n yield tqdm_object\n finally:\n joblib.parallel.Parallel.print_progress = original_print_progress\n tqdm_object.close()\n\nYou can use this the same way as described by frenzykryger\nimport time\ndef some_method(wait_time):\n time.sleep(wait_time)\n\nwith tqdm_joblib(tqdm(desc=\"My method\", total=10)) as progress_bar:\n Parallel(n_jobs=2)(delayed(some_method)(0.2) for i in range(10))\n\nLonger explanation:\nThe solution by Jon is simple to implement, but it only measures the dispatched task. If the task takes a long time, the bar will be stuck at 100% while waiting for the last dispatched task to finish execution.\nThe context manager approach by frenzykryger, improved from dano and Connor, is better, but the BatchCompletionCallBack can also be called with ImmediateResult before the task completes (See Intermediate results from joblib). This is going to get us a count that is over 100%.\nInstead of monkey patching the BatchCompletionCallBack, we can just patch the print_progress function in Parallel. The BatchCompletionCallBack already calls this print_progress anyway. If the verbose is set (i.e. Parallel(n_jobs=2, verbose=100)), the print_progress will be printing out completed tasks, though not as nice as tqdm. Looking at the code, the print_progress is a class method, so it already has self.n_completed_tasks that logs the number we want. All we have to do is just to compare this with the current state of joblib's progress and update only if there is a difference.\nThis was tested in joblib 0.14.0 and tqdm 4.46.0 using python 3.5.\n", "Text progress bar\nOne more variant for those, who want text progress bar without additional modules like tqdm. Actual for joblib=0.11, python 3.5.2 on linux at 16.04.2018 and shows progress upon subtask completion.\nRedefine native class:\nclass BatchCompletionCallBack(object):\n # Added code - start\n global total_n_jobs\n # Added code - end\n def __init__(self, dispatch_timestamp, batch_size, parallel):\n self.dispatch_timestamp = dispatch_timestamp\n self.batch_size = batch_size\n self.parallel = parallel\n\n def __call__(self, out):\n self.parallel.n_completed_tasks += self.batch_size\n this_batch_duration = time.time() - self.dispatch_timestamp\n\n self.parallel._backend.batch_completed(self.batch_size,\n this_batch_duration)\n self.parallel.print_progress()\n # Added code - start\n progress = self.parallel.n_completed_tasks / total_n_jobs\n print(\n \"\\rProgress: [{0:50s}] {1:.1f}%\".format('#' * int(progress * 50), progress*100)\n , end=\"\", flush=True)\n if self.parallel.n_completed_tasks == total_n_jobs:\n print('\\n')\n # Added code - end\n if self.parallel._original_iterator is not None:\n self.parallel.dispatch_next()\n\nimport joblib.parallel\nimport time\njoblib.parallel.BatchCompletionCallBack = BatchCompletionCallBack\n\nDefine global constant before usage with total number of jobs:\ntotal_n_jobs = 10\n\nThis will result in something like this:\nProgress: [######################################## ] 80.0%\n\n", "Here's another answer to your question with the following syntax:\naprun = ParallelExecutor(n_jobs=5)\n\na1 = aprun(total=25)(delayed(func)(i ** 2 + j) for i in range(5) for j in range(5))\na2 = aprun(total=16)(delayed(func)(i ** 2 + j) for i in range(4) for j in range(4))\na2 = aprun(bar='txt')(delayed(func)(i ** 2 + j) for i in range(4) for j in range(4))\na2 = aprun(bar=None)(delayed(func)(i ** 2 + j) for i in range(4) for j in range(4))\n\nhttps://stackoverflow.com/a/40415477/232371\n", "In Jupyter tqdm starts a new line in the output each time it outputs.\nSo for Jupyter Notebook it will be:\nFor use in Jupyter notebook.\nNo sleeps:\nfrom joblib import Parallel, delayed\nfrom datetime import datetime\nfrom tqdm import notebook\n\ndef myfun(x):\n return x**2\n\nresults = Parallel(n_jobs=8)(delayed(myfun)(i) for i in notebook.tqdm(range(1000))) \n\n100% 1000/1000 [00:06<00:00, 143.70it/s]\nWith time.sleep:\nfrom joblib import Parallel, delayed\nfrom datetime import datetime\nfrom tqdm import notebook\nfrom random import randint\nimport time\n\ndef myfun(x):\n time.sleep(randint(1, 5))\n return x**2\n\nresults = Parallel(n_jobs=7)(delayed(myfun)(i) for i in notebook.tqdm(range(100)))\n\nWhat I'm currently using instead of joblib.Parallel:\nimport concurrent.futures\nfrom tqdm import notebook\nfrom random import randint\nimport time\n\niterable = [i for i in range(50)]\n\ndef myfun(x):\n time.sleep(randint(1, 5))\n return x**2\n\ndef run(func, iterable, max_workers=8):\n with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:\n results = list(notebook.tqdm(executor.map(func, iterable), total=len(iterable)))\n return results\n\nrun(myfun, iterable)\n\n", "Setting verbose=13 was enough for me: https://joblib.readthedocs.io/en/latest/generated/joblib.Parallel.html\nI get a line on stderr that says something like:\n[Parallel(n_jobs=16)]: Done 134 tasks | elapsed: 7.7min\n\n" ]

[ 77, 25, 22, 11, 7, 4, 1, 0, 0 ]

[]

[]

[ "joblib", "multiprocessing", "multithreading", "parallel_processing", "python" ]

[ "You can do something similar using nested classes:\nfrom pydantic import BaseModel\n\nclass UserStats(BaseModel):\n age: int\n height: float\n\nclass User(BaseModel):\n id: int\n name = 'Jane Doe'\n stats: UserStats\n\nThen when you construct any User instance you can pass the stats field as a dictionary and it would be converted automatically:\nuser = User(id=1234, stats={\"age\": 30, \"height\": 180.0})\n\nThe only difference is that the stats field of User is a class (instance of UserStats) so if you want to access fields of it you need to do so using attribute access not using dictionary access:\nprint(user.age) # ok!\nprint(user[\"age\"]) # not ok...\n\nIf you need ste stats attribute to be a dictionary then you could use TypedDict from the typing_extensions (python3.7) or typing (python3.8+) module:\nfrom typing import TypedDict\nfrom pydantic import BaseModel\n\nclass UserStats(TypedDict):\n age: int\n height: float\n\nclass User(BaseModel):\n id: int\n name = 'Jane Doe'\n stats: UserStats\n\nuser = User(id=1234, stats={\"age\": 30, \"height\": 180.0})\nprint(user.stats[\"age\"]) # will work!\n\nEDIT:\nAs mentioned in the comments of this answer the question author did not want to globally define the UserStats class to avoid pollution.\nThis can be solved by defining the class directly inside the User class:\nclass User(BaseModel):\n id: int\n name = \"Jane Doe\"\n class Stats(TypedDict):\n age: int\n height: float\n stats: Stats\n\nThis allows for multiple classes like User to each define their stats without duplicated Stats classes in the global namespace.\nA more coincise but less friendly to type checkers and language servers would be to use the functional API of TypedDict:\n class User(BaseModel):\n id: int\n name = \"Jane Doe\"\n stats: TypedDict(\"Stats\", age=int, height=float)\n\n", "Just for the sake of completeness, you can also make use of the functional API provided by TypedDict to write your model like this:\nfrom typing import TypedDict\nfrom pydantic import BaseModel\n\n\nclass User(BaseModel):\n id: int\n name = 'Jane Doe'\n stats: TypedDict(\"Stats\", {\"age\": int, \"height\": float})\n\nI can't think of a way to make this more concise. I was not sure at first regarding how this plays with type checkers, but at least PyCharm with the Pydantic plugin seems to have no trouble correctly inferring the types and spitting out warnings, if you try to provide a wrongly typed value in the stats dictionary.\n" ]

[ 3, 2 ]

[]

[]

[ "pydantic", "python" ]

[ "An option is to convert the criacao date string value to a python datetime data type, review the month for this date, and then assign that month to a specific quarter.\n\nMonth 1-3, assigned to Quarter 1\nMonth 4-6, assigned to Quarter 2\nMonth 7-9, assigned to Quarter 3\nMonth 10-12, assigned to Quarter 4\n\nPandas lets you use a function to apply the logic on each value of a column and output to a new column using apply and lambda\n# import datetime\nfrom datetime import datetime\n\ndef assign_quarter(criacao):\n # convert format from string to datetime \n criacao_formatted = datetime.strptime(criacao, \"%Y-%m-%d %H:%M:%S\")\n # return quarter of year\n return (criacao_formatted.month-1)//3\n\n# make a new column for the criacao quarter\ndf_fresh['criacao_quarter'] = df_fresh.apply(lambda x: assign_quarter(x['criacao']))\n\nMore about apply here: https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.apply.html\nThen there are a couple options for how to extract the criacao values and create the fd_pri_tri variable,\nlike this\nfd_pri_tri = (df_fresh.query('criacao_quarter == 1')['criacao'])\nor this\nfd_pri_tri = (df_fresh.loc[df_fresh['criacao_quarter'] == 1, 'criacao'])\n" ]

[ 0 ]

[]

[]

[ "pandas", "python" ]

[ "Solved!\nshoutout to @dan-mašek for helping me to solve this problem. here is the code: https://pastebin.com/DXrxmf17\n# COLOR SEGMENTATION\nlab_convert = convert_lab(frame)\nL, a, b = cv2.split(lab_convert)\nL_mean, a_mean, b_mean = cv2.mean(lab_convert)[:-1]\n\nrgb_convert = convert_rgb(frame)\nR, G, B = cv2.split(rgb_convert)\nR_mean = cv2.mean(R)[0]\n\nycbcr_convert = convert_ycbcr(frame)\nY, Cb, Cr = cv2.split(ycbcr_convert)\n\nlab_rule_1 = L >= L_mean\nlab_rule_2 = a >= a_mean\nlab_rule_3 = b >= b_mean\nlab_rule_4 = b >= a_mean\nlab_satisfied = lab_rule_1 & lab_rule_2 & lab_rule_3 & lab_rule_4\n\nrgb_rule_1 = (R > G) & (G > B) # No chaining in numpy\nrgb_rule_2 = R >= R_mean\nrgb_satisfied = rgb_rule_1 & rgb_rule_2\n\nycbcr_rule_1 = (R >= G) & (G > B)\nycbcr_rule_2 = (R > 190) & (G > 100) & (B < 140)\nycbcr_rule_3 = Y >= Cb\nycbcr_rule_4 = Cr >= Cb\nycbcr_satisfied = (ycbcr_rule_1 & ycbcr_rule_2) | (ycbcr_rule_3 & ycbcr_rule_4)\n\n\nlab_convert = np.uint8(lab_satisfied) * 255\nrgb_convert = np.uint8(rgb_satisfied) * 255\nycbcr_convert = np.uint8(ycbcr_satisfied) * 255\n\ncombined = lab_convert | rgb_convert | ycbcr_convert\nframe_copy = np.repeat(combined[:, :, np.newaxis], 3, axis=2)\n\n" ]

[ 1 ]

[]

[]

[ "image_processing", "image_segmentation", "numpy", "opencv", "python" ]

[ "Here is what I think.\nIf you can somehow get the highest & lowest valued coordinates in the pixels that are forming the lines, you can use those pixels to form a rectangle that consist of the straight edges.\n\nUsing the pixels to (roughly) form a rectangle can be the solution!\n\nTo find the pixels in a line, you can take a look in here, here and here.\n", "you may use cv.approxPolyDP to extract dominant points from edges and stick to the edges that have 2 dominant points.\nps: you apply approxPolyDP on edges after collecting them by cv.findcontours\n" ]

[ 0, 0 ]

[]

[]

[ "computer_vision", "edge_detection", "image_processing", "opencv", "python" ]

[ "You can add a common column for both datasets and then we can use pandas merge on that common column\nHere is the sample code\nmwe1['common']=mwe2['common']=1\ndf = pd.merge(mwe1,mwe2,on='common').drop('common',1)\ndf.sort_values(by='salesforce_name',inplace=True)\n\nOutput:\n company_name revenue salesforce_name CEO\n0 Deloitte 100 Deloite John\n2 PriceWaterhouseCoopers 200 Deloite John\n4 KPMG 300 Deloite John\n6 Ernst & Young 250 Deloite John\n8 intentionall typo company XYZ 400 Deloite John\n1 Deloitte 100 PriceWaterhouseCooper Jane\n3 PriceWaterhouseCoopers 200 PriceWaterhouseCooper Jane\n5 KPMG 300 PriceWaterhouseCooper Jane\n7 Ernst & Young 250 PriceWaterhouseCooper Jane\n9 intentionall typo company XYZ 400 PriceWaterhouseCooper Jane\n\n" ]

[ 0 ]

[]

[]

[ "fuzzy_comparison", "pandas", "python", "string" ]

[ "I'm not sure I fully understand what format you're trying to do, but hope ths helps point you in the right direction.\nIf you want to print only the values where val > 0.05:\n\nMake your joint_pmf_ID a numpy array.\nIndex by boolean condition and set the desired values to 0.\nIn your looping function, don't print zeros.\n\njoint_pmf_ID = np.array(joint_pmf_ID)\njoint_pmf_id[joint_pmf_id<=0.05] = 0\n# Below is just a fancy print function; print how you will\nfor i, row in enumerate(joint_pmf_ID):\n print('| ')\n for j, val in enumerate(row):\n print(val if val else ' ')\n print(' | ')\n\n" ]

[ 1 ]

[]

[]

[ "numpy", "python", "statistics" ]

[ "if you're willing to consider alternatives to timeit, i recently found the stopwatch timer utility which might be useful in your case. it's really simple and intuitive, too:\nimport stopwatch\n\nclass TimedClass():\n\n def __init__(self):\n t = stopwatch.Timer()\n # do stuff here\n t.stop()\n print t.elapsed\n\n", "Why do you want the timing inside the class being timed itself? If you take the timing out of the class, you can just pass a reference. I.e.\nimport timeit\n\nclass TimedClass():\n def __init__(self):\n self.x = 13\n self.y = 15\n\n def square(self, _x, _y):\n print _x**_y\n\nmyTimedClass = TimedClass()\ntimeit.Timer(myTImedClass.square).timeit()\n\n(of course the class itself is redundant, I assume you have a complexer use-case where a simple method is not sufficient).\nIn general, just pass a callable that has all setup contained/configured. If you want to pass strings to be timed they should contain all necessary setup inside them, i.e.\ntimeit.Timer(\"[str(x) for x in range(100)]\").timeit()\n\nIf you really, really need the timing inside the class, wrap the call in a local method, i.e.\ndef __init__(self, ..):\n def timewrapper():\n return self.multiply(self.x, self.y)\n\n timeit.Timer(timewrapper)\n\n", "To address your initial error, you can use timeit within a class with parameters like this:\n t = timeit.Timer(lambda: self.square(self.x, self.y)).timeit()\n\n", "(posting as an answer because the code markup does not work in a comment)\nI would add a try/finally closure for additional safety:\nclass TimedClass():\n def __init__(self):\n t = stopwatch.Timer()\n try:\n # do stuff here, you can even use return \"foo\" here and throw exceptions\n finally:\n t.stop()\n print t.elapsed\n\n", "Just pass self through the new globals parameter of timeit.Timer() (added in version 3.5):\nimport timeit\n\nclass TimedClass():\n def __init__(self):\n self.x = 13\n self.y = 15\n my_globals = globals()\n my_globals.update({'self':self})\n t = timeit.Timer(stmt=\"self.square(self.x, self.y)\", globals=my_globals)\n try:\n t.timeit()\n except:\n t.print_exc()\n\n def square(self, _x, _y):\n print (_x**_y)\n\nmyTimedClass = TimedClass()\n\n" ]

[ 10, 9, 7, 0, 0 ]

[]

[]

[ "python", "self", "timeit" ]

[ "There are two misconcepts. First is how you are building you 'diff_set' variable to check in the template, it should be a list with the name of the fruit (Otherwise you need to do logic at template level, which is one thing you should always avoid.):\n['ananas',...]\n\nSecond is trying to color lines inside a text area with HTML tags. It is possible to do it based on this answer (personally I never even tried such thing).\nBesides that, there are some redundant processes in your code. But, in order to make it work the way it is, just filter your diff_set, and change your template:\ntemplate.html:\n{% block content %}\n <div class=\"container center\">\n {% for key, value in content %}\n <span {% if key in diff_set %} style=\"color: red;\" {% endif %}>{{ key }}: {{value}}</span><br>\n {% endfor %}\n\n <p>------------------------------------------------------</p>\n\n {% for key, value in content_excel %}\n <span {% if key in diff_set %} style=\"color: red;\"{% endif %}>{{ key }}: {{value}}</span><br>\n {% endfor %}\n </div>\n{% endblock %}\n\nviews.py:\nfrom .test_file import TestFile\n\ndef compare_data(request):\n test_file = TestFile()\n\n content_excel = \"\"\n content = \"\"\n content = test_file.data_compare()\n content_excel = test_file.data_compare2()\n diff_set =test_file.compare_dic()\n\n # filter diff_set\n unique_keys = []\n for v in diff_set:\n if v[0] not in unique_keys:\n unique_keys.append(v[0])\n\n context = {\"content\": content, \"content_excel\": content_excel, \"diff_set\": unique_keys}\n\n return render(request, \"compare.html\", context)\n\n" ]

[ 1 ]

[]

[]

[ "django", "python" ]

[ "Your loot dict has in real reference to objects and if you assign to player character any object from loot_dict you assign reference to the same object what is in your loot_dict. (Just like a pointer in cpp).\nYou need to create new instance of object every time the player gets new item.\nTo achive it You can do something like this:\nloot_dict={'Rings':[RingOfRegeneration]}\n\nNow u can call it:\nitem_class = random.choice(list(loot_dict.keys())) \nnew_item_instance = random.choice(loot_dict[item_class])() #Calling class __init__ method\n\nnew_item_instace is now fresh base statistics.\n" ]

[ 1 ]

[]

[]

[ "class", "python", "reset" ]

[ "If you want to change the background of the items in your File menu, you have to config that Menu instead of the root Menu1\nfilemenu.config(background='red')\n\nIf you want to color each menu item individually, you can set background for each add_command\nfilemenu.add_command(label=\"New\", background='red')\nfilemenu.add_command(label=\"Open\", background='orange')\nfilemenu.add_command(label=\"Save\", background='yellow')\nfilemenu.add_command(label=\"Save as...\", background='green')\nfilemenu.add_command(label=\"Close\", background='blue')\n\n" ]

[ 0 ]

[]

[]

[ "python", "tkinter" ]

[ "is this what you're looking for?\nresult = df.groupby([\"col1\", \"col2\"])[\"col3\"].count().unstack(fill_value=0).stack()\n\n\nresult :\ncol1 col2\nA 1 2\n 2 1\n 3 0\nB 1 0\n 2 0\n 3 1\nC 1 2\n 2 0\n 3 0\n\n\n" ]

[ 2 ]

[]

[]

[ "cartesian_product", "count", "pandas", "python" ]

[ "If I understand your question correctly, you would like to have the user pass the info required by OAuth2PasswordRequestForm and also include some extra required information.\nThe easiest way to do this would probably be to create your own scheme that is a subclass of OAuth2PasswordRequestForm.\n\n import fastapi\n from fastapi import Depends\n from fastapi.security import OAuth2PasswordRequestForm\n \n app = fastapi.FastAPI()\n\n class ExtendedOAuth2PasswordRequestForm(OAuth2PasswordRequestForm):\n extra_data_field: str\n\n @app.post(\"/your_endpoint\")\n def login_for_access_token(form_data: ExtendedOAuth2PasswordRequestForm = Depends()):\n #do stuff with all of the normal OAuth2PasswordRequestForm and your extra data field...\n\n", "You can add extend parameter to body request as follow:\n\nAnd add the parameter to form data in frontend part:\n\n" ]

[ 0, 0 ]

[]

[]

[ "fastapi", "python" ]

[ "I'd suggest using enumerate to iterate over the items with their indices (as you're already doing), and then using all to iterate over all the items after a given item, and sum to sum all of the all results:\n>>> def count_dominators(items):\n... return sum(all(n > m for m in items[i+1:]) for i, n in enumerate(items))\n...\n>>> count_dominators([42, 7, 12, 9, 2, 5])\n4\n\nAnother approach would be to compare to the max of the remaining items, although then you need to special-case the end of the list (all returns True for an empty list, but max will raise an exception):\n>>> def count_dominators(items):\n... return sum(n > max(items[i+1:]) for i, n in enumerate(items[:-1])) + 1\n...\n>>> count_dominators([42, 7, 12, 9, 2, 5])\n4\n\n" ]

[ 1 ]

[]

[]

[ "python" ]

[ "Here is some code illustrating what I think is a cleaner way to solve the problem.\nimport hashlib\nimport hmac\nimport io\nimport os\nimport pickle\n\nsample_obj = {'hello': [os.urandom(50)]}\n\ndata = pickle.dumps(sample_obj)\n\n# write it out\n\nmy_hmac = hmac.new(b'my_hmac_key', digestmod=hashlib.blake2b)\nmy_hmac.update(data)\nmac_result = my_hmac.digest()\npickle_out = io.BytesIO()\npickle_out.write(mac_result + data)\n\n# read it in\n\npickle_in = io.BytesIO(pickle_out.getbuffer().tobytes())\nmy_hmac = hmac.new(b'my_hmac_key', digestmod=hashlib.blake2b)\nmac_from_stream = pickle_in.read(my_hmac.digest_size)\ndata_from_stream = pickle_in.read()\nmy_hmac.update(data_from_stream)\ncomputed_mac = my_hmac.digest()\n\n# see if they match\n\nprint(hmac.compare_digest(computed_mac, mac_from_stream))\n\nWe avoid hexdigest() all together and thus eliminate unnecessary encoding and decoding. We create the mac instance and keep it around so that we can get the hmac.digest_size property. The use of io.BytesIO is just for illustrating the I/O part of your code.\n" ]

[ 1 ]

[]

[]

[ "hmac", "pickle", "python" ]

[ "One approach is to use list comprehension (optional) and regular expressions, where a pattern can be set to keep only alphabetical characters. (e.g.: [a-zA-Z]+ meaning one or more alpha characters.)\nThe str.join() function is used to combine the regex search output into a single string, which is added as an element to the output list.\nFor example:\nimport re\n\nout = [' '.join(re.findall('[a-zA-Z]+', i)) for i in array]\n\nOutput:\n['Apple Mug Seaweed Wallet Toilet Bear Toy Key Alcohol Paper',\n 'cup egg pillow leash banana raindrop phone animal shirt basket',\n 'Dog America Notebook Moisturizer ADHD Balloon Contacts Blanket Home Pencil']\n\n", "Without using the RE library you can also continue the code you used earlier and just add a try/except block to look for numbers, hope this is also helpful.\nout = []\nfor i in array:\n row = []\n for j in i.split():\n j = j.strip(',.')\n try:\n int(j)\n except:\n row.append(j)\n row = f\"{' '.join(row)}\"\n out.append(row)\nprint(out)\n\n" ]

[ 2, 0 ]

[]

[]

[ "list", "python" ]

[ "Just to be sure, do you have Firefox installed? Does this thread help for you?\n" ]

[ 0 ]

[]

[]

[ "python", "selenium", "selenium_webdriver", "web_scraping" ]

[ "Coverage 4.0 includes a command-line option --concurrency=multiprocessing to deal with this. You must use coverage combine afterward. For instance, if your tests are in regression_tests.py, then you would simply do this at the command line:\ncoverage run --concurrency=multiprocessing regression_tests.py\ncoverage combine\n\n", "I've had spent some time trying to make sure coverage works with multiprocessing.Pool, but it never worked.\nI have finally made a fix that makes it work - would be happy if someone directed me if I am doing something wrong.\nhttps://gist.github.com/andreycizov/ee59806a3ac6955c127e511c5e84d2b6\n", "One of the possible causes of missing coverage data from forked processes, even with concurrency=multiprocessing, is the way of multiprocessing.Pool shutdown. For example, with statement leads to terminate() call (see __exit__ here). As a consequence, pool workers have no time to save coverage data. I had to use close(), timed join() (in a thread), terminate sequence instead of with to get coverage results saved.\n" ]

[ 28, 1, 0 ]

[]

[]

[ "code_coverage", "coverage.py", "coveralls", "multiprocessing", "python" ]

[ "I've had a similar problem. locally I had to execute the following\nansible-galaxy collection install kubernetes.core\n\nOn the target server make sure that you have python3 installed as python2 won't be enough. Once that is installed, I also had to define the below in my vars:\nansible_python_interpreter: /bin/python3\n\n" ]

[ 0 ]

[]

[]

[ "ansible", "kubernetes", "python" ]

[ "For a full description on why Submodule objects retrieved from Trees are not fully functional, see https://github.com/gitpython-developers/GitPython/issues/1092\nSo the short answer: It is a bug/missing feature in GitPython that is still unsolved.\n" ]

[ 0 ]

[]

[]

[ "git", "gitpython", "python" ]

[ "I think you have to rework your code in main()\ndef main():\n\n for _ in range(3):\n user_choice = get_user_input()\n computer_choice = random_choice()\n game(user_choice, computer_choice)\n\n print(\"Game has ended!\")\n\nTry something like this\n", "Your program works great! just one small placement error, the random_choice needs to change with every iteration of the loop so I moved the random_choice assignment variable in and that solved the problem. This is also if you want the player to only be able to make one choice.\ndef main():\n user_choice = get_user_input()\n for _ in range(3):\n computer_choice = random_choice()\n game('Rock', computer_choice)\n print(\"Game has ended!\")\n\nmain()\n\nif you want the player to pick every round then it would look like this;\ndef main():\n for _ in range(3):\n user_choice = get_user_input()\n computer_choice = random_choice()\n game('Rock', computer_choice)\n print(\"Game has ended!\")\n \n\nmain()\n\n" ]

[ 2, 1 ]

[]

[]

[ "python", "python_3.x" ]

[ "if produtos = list_products('all') is the output df in the question.\nprodutos = list_products('all')\ndf = pd.json_normalize(produtos.explode('retorno.produtos')['retorno.produtos'])\n\n'''\n| | produto.id | produto.codigo | produto.descricao | produto.tipo | produto.situacao | produto.unidade | produto.preco | produto.precoCusto | produto.descricaoCurta | produto.descricaoComplementar | produto.dataInclusao | produto.dataAlteracao | produto.imageThumbnail | produto.urlVideo | produto.nomeFornecedor | produto.codigoFabricante | produto.marca | produto.class_fiscal | produto.cest | produto.origem | produto.idGrupoProduto | produto.linkExterno | produto.observacoes | produto.grupoProduto | produto.garantia | produto.descricaoFornecedor | produto.idFabricante | produto.categoria.id | produto.categoria.descricao | produto.pesoLiq | produto.pesoBruto | produto.estoqueMinimo | produto.estoqueMaximo | produto.gtin | produto.gtinEmbalagem | produto.larguraProduto | produto.alturaProduto | produto.profundidadeProduto | produto.unidadeMedida | produto.itensPorCaixa | produto.volumes | produto.localizacao | produto.crossdocking | produto.condicao | produto.freteGratis | produto.producao | produto.dataValidade | produto.spedTipoItem | produto.clonarDadosPai | produto.codigoPai |\n|---:|-------------:|:-----------------|:------------------------------------|:---------------|:-------------------|:------------------|----------------:|---------------------:|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:--------------------------------|:-----------------------|:------------------------|:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:-------------------|:-------------------------|:---------------------------|:----------------|:-----------------------|:---------------|-----------------:|-------------------------:|:----------------------|:----------------------|-----------------------:|-------------------:|------------------------------:|:-----------------------|-----------------------:|:------------------------------|------------------:|--------------------:|------------------------:|------------------------:|:---------------|:------------------------|-------------------------:|------------------------:|------------------------------:|:------------------------|------------------------:|------------------:|:----------------------|-----------------------:|:-------------------|:----------------------|:-------------------|:-----------------------|:-----------------------|:-------------------------|--------------------:|\n| 0 | 15874512815 | 005.02.G | CALÇA NATUREZA OFF WHITE TAMANHO G | P | Ativo | UN | 172.9 | nan | <p style=\"box-sizing: border-box; padding: 0px; border: 0px; outline: none; margin-block: 0px 1em; color: #333333; font-family: Lato, sans-serif; font-size: 18px; background-color: #fefffe;\"><span style=\"box-sizing: border-box; padding: 0px; margin: 0px; border: 0px; outline: none; font-size: 12px;\"><span style=\"box-sizing: border-box; padding: 0px; margin: 0px; border: 0px; outline: none; font-family: Tahoma, Geneva, sans-serif;\">Aquela calça super comfy e estilosa para te acompanhar nesse inverno!<\\/span><\\/span><\\/p> | | 2022-05-26 | 2022-11-08 | http:\\/\\/orgbling.s3.amazonaws.com\\/358dd3a99dc65df69a3f3852c88a9c7f\\/t\\/ff947f17eb154298f3fb991594ab17b2?AWSAccessKeyId=AKIATCLMSGFX4J7TU445&Expires=1669817234&Signature=PPHn8S%2FTDDIGI0nKS3dYXXwfLR4%3D | | | | | 6006.32.20 | | 0 | 0 | | | nan | nan | nan | | 5108713 | Calças | 0.3 | 0.31 | 0 | 0 | | | 1 | 1 | 1 | Centímetros | 0 | 0 | | 0 | Não Especificado | N | P | 0000-00-00 | | S | 5.02 |\n| | | | | | | | | | <p style=\"box-sizing: border-box; padding: 0px; border: 0px; outline: none; margin-block: 0px; color: #333333; font-family: Lato, sans-serif; font-size: 18px; background-color: #fefffe;\"><span style=\"box-sizing: border-box; padding: 0px; margin: 0px; border: 0px; outline: none; font-size: 12px;\"><span style=\"box-sizing: border-box; padding: 0px; margin: 0px; border: 0px; outline: none; font-family: Tahoma, Geneva, sans-serif;\">Com moletom felpado e uma modelagem que abraça o corpo, ela é a nossa queridinha por aqui! &lt;3<\\/span><\\/span><\\/p> | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |\n| 1 | 15874512814 | 005.02.M | CALÇA NATUREZA OFF WHITE TAMANHO M | P | Ativo | UN | 172.9 | nan | <p style=\"box-sizing: border-box; padding: 0px; border: 0px; outline: none; margin-block: 0px 1em; color: #333333; font-family: Lato, sans-serif; font-size: 18px; background-color: #fefffe;\"><span style=\"box-sizing: border-box; padding: 0px; margin: 0px; border: 0px; outline: none; font-size: 12px;\"><span style=\"box-sizing: border-box; padding: 0px; margin: 0px; border: 0px; outline: none; font-family: Tahoma, Geneva, sans-serif;\">Aquela calça super comfy e estilosa para te acompanhar nesse inverno!<\\/span><\\/span><\\/p> | | 2022-05-26 | 2022-11-08 | http:\\/\\/orgbling.s3.amazonaws.com\\/358dd3a99dc65df69a3f3852c88a9c7f\\/t\\/ff947f17eb154298f3fb991594ab17b2?AWSAccessKeyId=AKIATCLMSGFX4J7TU445&Expires=1669817234&Signature=PPHn8S%2FTDDIGI0nKS3dYXXwfLR4%3D | | | | | 6006.32.20 | | 0 | 0 | | | nan | nan | nan | | 5108713 | Calças | 0.3 | 0.31 | 0 | 0 | | | 1 | 1 | 1 | Centímetros | 0 | 0 | | 0 | Não Especificado | N | P | 0000-00-00 | | S | 5.02 |\n| | | | | | | | | | <p style=\"box-sizing: border-box; padding: 0px; border: 0px; outline: none; margin-block: 0px; color: #333333; font-family: Lato, sans-serif; font-size: 18px; background-color: #fefffe;\"><span style=\"box-sizing: border-box; padding: 0px; margin: 0px; border: 0px; outline: none; font-size: 12px;\"><span style=\"box-sizing: border-box; padding: 0px; margin: 0px; border: 0px; outline: none; font-family: Tahoma, Geneva, sans-serif;\">Com moletom felpado e uma modelagem que abraça o corpo, ela é a nossa queridinha por aqui! &lt;3<\\/span><\\/span><\\/p> | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |\n'''\n\nFull code:\nimport requests\nimport pandas as pd\nfrom pandas import json_normalize\nimport json\n\nBLING_SECRET_KEY = my_apikey\n\ndef list_products(page=1):\n url = f'https://bling.com.br/Api/v2/produtos/page={page}/json/'\n payload = {'apikey': BLING_SECRET_KEY,}\n all_products = {'retorno': {'produtos': []}}\n\n if page == 'all':\n page = 1\n \n while True:\n url = f'https://bling.com.br/Api/v2/produtos/page={page}/json/'\n produtos = requests.get(url, params=payload)\n try:\n pagina = produtos.json()['retorno']['produtos']\n page += 1\n for item in pagina:\n all_products['retorno']['produtos'].append(item)\n except KeyError:\n\n break\n\n df = json_normalize(all_products, \n meta=['produtos'])\n return df \n \n\nprodutos = list_products('all')\ndf = pd.json_normalize(produtos.explode('retorno.produtos')['retorno.produtos'])\n\n\n" ]

[ 0 ]

[]

[]

[ "api", "json", "pandas", "powerbi", "python" ]

[ "The issue was with Pipfile, the logs indicated some dependency issues and conflicts. I do not remember why but at some point the allow_prereleases flag was set to true in the file. When I set it to false and recreated the Pipfile.lock, the error gone away.\n" ]

[ 0 ]

[]

[]

[ "docker_compose", "mib", "pysnmp", "python", "snmp" ]

[ "Delta Lake itself does not itself enable sorting because this would require any engine writing to sort the data. To balance simplicity, speed of ingestion, and speed of query, this is why Delta Lake itself does not require or enable sorting per se. i.e., your statement is correct.\n\nMy understanding is that it partitions the data and doesn't care about the sort order. data is spread across multiple partitions.\n\nNote that Delta Lake includes data skipping and OPTIMIZE ZORDER. This allows you to skip files/data using the column statistics and by clustering the data. While sorting can be helpful for a single column, Z-order provides better multi-column data cluster. More info is available in Delta 2.0 - The Foundation of your Data Lakehouse is Open.\nSaying this, how Delta Lake stores the data is often a product of what the writer itself is doing. If you were to specify a sort during the write phase, e.g.:\ndf_sorted = df.repartition(\"date\").sortWithinPartitions(\"date\", \"id\")\ndf_sorted.write.format(\"delta\").partitionBy(\"date\").save('deltalocation')\n\nThen the data should be sorted and when read it will be sorted as well.\n" ]

[ 0 ]

[]

[]

[ "azure_data_lake", "azure_databricks", "delta_lake", "pyspark", "python" ]

[ "The Text widget doesn't support textvariable because a Text widget can contain more than just text. To get the content out of the Text widget you need to call the get method on the widget.\nTo get all of the contents of the widget you first need to keep a reference to the widget. Then it's just a matter of calling get with an index for the range of text you want. Typically the two indexes will be the strings \"1.0\" for the first character, and \"end-1c\" for the last character before the newline added by the text widget itself.\ndef _set_project_description_frame(self):\n ...\n self.text_widget = tk.Text(project_description_frame, height=5)\n self.text_widget.pack(side=tk.LEFT, expand=True, fill=tk.X)\n ...\n\nWith that, anywhere else in your code that needs to fetch the data can do this:\nself.text_widget.get(\"1.0\", \"end-1c\")\n\n" ]

[ 1 ]

[]

[]

[ "python", "tkinter", "user_interface" ]

[ "use following code:\ndf.sort_index(axis=1)\n\n", "You can do:\ndf = df[sorted(df.columns.tolist())].copy()\n\n", "df = df[['col1', 'col2', 'col3', 'col4']]\n\n" ]

[ 1, 0, 0 ]

[]

[]

[ "data_science", "pandas", "python", "python_3.x" ]

[ "The ufunc.add.at() is much more generic then your addat(). It iterates over the array elements and calls some unit operation function for each element. Let the unit operation function be add_vectors(). It adds two input vectors, where a vector means array elements in C-contiguous order and aligned. It utilizes SIMD operations if possible.\nBecause the ufunc.add.at() accesses elements randomly(not sequentially), the add_vectors() should be called multiple times for each pair of input elements. But your addat() does not have this penalty because Numba generates a machine code that accesses Numpy array elements directly.\nYou can see the overhead in the Numpy source at this and this for example.\nFor your second question on the performance of other Numpy functions, I recommend to experiment by yourself, because both Numpy and Numba do so complex operations behind the scene.(My naive opinion is that a well written Numba implementation for a ufunc operation will perform better than the Numpy implementation, because Numba also utilizes SIMD operations if possible.)\n" ]

[ 1 ]

[]

[]

[ "numba", "numpy", "python" ]

[ "You can use the type() function to check the type of an object in Python. In this case, x['data'] returns a dictionary, so you can use the items() method to get the items in the dictionary and then iterate over them to check their values. Here's an example of how you can do this:\n# Get the items in the 'data' dictionary\ndata_items = x['data'].items()\n\n# Iterate over the items in the dictionary\nfor key, value in data_items:\n # Check the type of the value\n if type(value) == bool:\n print(key)\n\n\nIn this code, key will be the name of the data (e.g. data1, data2, etc.), and value will be the dictionary containing the type, default value, and flag. You can then check the values in this dictionary using the get() method, as you did in your code.\n", "Given a file called yaml.yaml containing your supplied yaml data:\nuser: john\ndescription: Blablabla\nversion: 1\ndata: \n data1: {type : bool, default: 0, flag: True}\n data2: {type : bool, default: 0, flag: True}\n data3: {type : float, default: 0, flag: false}\n\nYou can parse the file with PyYAML in a standard way, which is covered in other answers such as this one. For example:\nimport yaml\n\nwith open(\"yaml.yaml\", \"r\") as stream:\n try:\n my_dict = yaml.safe_load(stream)\n print(my_dict)\n except yaml.YAMLError as exc:\n print(exc)\n\nYields a print out of your YAML as a dict:\n$ python.exe yaml_so.py \n{'user': 'john', 'description': 'Blablabla', 'version': 1, 'data': {'data1': {'type': 'bool', 'default': 0, 'flag': True}, 'data2': {'type': 'bool', 'default': 0, 'flag': True}, 'data3': {'type': 'float', 'default': 0, 'flag': False}}}\n\nCreating a list of all data items where flag == True can be accomplished by using dict.items() to iterate a view of the dictionary, for example:\nfor key, sub_dict in my_dict[\"data\"].items():\n if \"flag\" in sub_dict:\n for sub_key, value in sub_dict.items():\n if sub_key == \"flag\" and value:\n print(f\"sub_dict_entry: {key} -> key: {sub_key} -> value: {value}\")\n\nYields:\nsub_dict_entry: data1 -> key: flag -> value: True\nsub_dict_entry: data2 -> key: flag -> value: True\n\n" ]

[ 0, 0 ]

[]

[]

[ "python", "python_3.x", "yaml" ]

[ "Your submit() method is creating Image widgets and adding them to a newly created layout2, You are returning that new layout2 from that method, but that does not add it to your GUI. Try replacing:\nlayout2.add_widget(self.img)\n\nwith:\nself.root.add_widget(self.img)\n\n" ]

[ 0 ]

[]

[]

[ "image", "kivy", "kivymd", "python" ]

[ "def recursive(total, n):\n if n == 0:\n return total\n else:\n return recursive(total + n * n, n - 1)\n\nA couple of thought\n\nThis can be refactored to using only a single argument, but by supplying both the total and the current iteration count, it is easier to see how to transform the iterative approach to a recursive one.\nWhile this function can be made recursive, it should not be, as there is no advantage over the iterative approach.\n\n" ]

[ 0 ]

[]

[]

[ "loops", "python", "recursion" ]

[ "Just add 1. The range function, when used as range(start, stop), does not include stop, and it stops when the next number is greater than or equal to stop.\nif __name__ == '__main__':\n n = int(input())\n for i in range(1,n + 1):\n print(i, end=\" \")\n\n" ]

[ 2 ]

[]

[]

[ "python" ]

[ "\nExtract the row using whichever method you prefer and save it as a list\nUse any of these methods to flatten your list\n\nrow = list(df.loc[0])\ntarget = [val for val in sublist for sublist in row]\n\n" ]

[ 1 ]

[]

[]

[ "arrays", "pandas", "python" ]

[ "In fact, dataFrame.select(colName) is supposed to return a column(a dataframe of with only one column) but not the column value of the line. I see in your comment you want to do recursive lookup in a spark dataframe. The thing is, firstly, spark AFAIK, doesn't support recursive operation. If you have a deep recursive operation to do, you'd better collect the dataframe you have and do it on your driver without spark. Instead, you can use what library you want but you lose the advantage of treating the data in the distributive way.\nSecondly, spark isn't designed to do operations with iteration on each record. Try to achieve with join of dataframes, but it return to my first point, if your later operation of join depends on your join result, in a recursive way, just forget spark.\n" ]

[ 0 ]

[]

[]

[ "apache_spark", "apache_spark_sql", "pyspark", "python" ]

[ "There is no pop method for NumPy arrays, but you could just use basic slicing (which would be efficient since it returns a view, not a copy):\nIn [104]: y = np.arange(5); y\nOut[105]: array([0, 1, 2, 3, 4])\n\nIn [106]: last, y = y[-1], y[:-1]\n\nIn [107]: last, y\nOut[107]: (4, array([0, 1, 2, 3]))\n\nIf there were a pop method it would return the last value in y and modify y.\nAbove, \nlast, y = y[-1], y[:-1]\n\nassigns the last value to the variable last and modifies y.\n", "Here is one example using numpy.delete():\nimport numpy as np\narr = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])\nprint(arr)\n# array([[ 1, 2, 3, 4],\n# [ 5, 6, 7, 8],\n# [ 9, 10, 11, 12]])\narr = np.delete(arr, 1, 0)\nprint(arr)\n# array([[ 1, 2, 3, 4],\n# [ 9, 10, 11, 12]])\n\n", "Pop doesn't exist for NumPy arrays, but you can use NumPy indexing in combination with array restructuring, for example hstack/vstack or numpy.delete(), to emulate popping.\nHere are some example functions I can think of (which apparently don't work when the index is -1, but you can fix this with a simple conditional):\ndef poprow(my_array,pr):\n \"\"\" row popping in numpy arrays\n Input: my_array - NumPy array, pr: row index to pop out\n Output: [new_array,popped_row] \"\"\"\n i = pr\n pop = my_array[i]\n new_array = np.vstack((my_array[:i],my_array[i+1:]))\n return [new_array,pop]\n\ndef popcol(my_array,pc):\n \"\"\" column popping in numpy arrays\n Input: my_array: NumPy array, pc: column index to pop out\n Output: [new_array,popped_col] \"\"\"\n i = pc\n pop = my_array[:,i]\n new_array = np.hstack((my_array[:,:i],my_array[:,i+1:]))\n return [new_array,pop]\n\nThis returns the array without the popped row/column, as well as the popped row/column separately: \n>>> A = np.array([[1,2,3],[4,5,6]])\n>>> [A,poparow] = poprow(A,0)\n>>> poparow\narray([1, 2, 3])\n\n>>> A = np.array([[1,2,3],[4,5,6]])\n>>> [A,popacol] = popcol(A,2)\n>>> popacol\narray([3, 6])\n\n", "There isn't any pop() method for numpy arrays unlike List, Here're some alternatives you can try out-\n\nUsing Basic Slicing\n\n>>> x = np.array([1,2,3,4,5])\n>>> x = x[:-1]; x\n>>> [1,2,3,4]\n\n\nOr, By Using delete() \n\nSyntax - np.delete(arr, obj, axis=None)\narr: Input array \nobj: Row or column number to delete \naxis: Axis to delete \n>>> x = np.array([1,2,3,4,5])\n>>> x = x = np.delete(x, len(x)-1, 0)\n>>> [1,2,3,4]\n\n", "The important thing is that it takes one from the original array and deletes it.\nIf you don't m\nind the superficial implementation of a single method to complete the process, the following code will do what you want.\nimport numpy as np\n\na = np.arange(0, 3)\ni = 0\nselected, others = a[i], np.delete(a, i)\n\nprint(selected)\nprint(others)\n\n# result:\n# 0\n# [1 2]\n\n", "The most 'elegant' solution for retrieving and removing a random item in Numpy is this:\nimport numpy as np\nimport random\n\narr = np.array([1, 3, 5, 2, 8, 7])\nelement = random.choice(arr)\nelementIndex = np.where(arr == element)[0][0]\narr = np.delete(arr, elementIndex)\n\nFor curious coders:\nThe np.where() method returns two lists. The first returns the row indexes of the matching elements and the second the column indexes. This is useful when searching for elements in a 2d array. In our case, the first element of the first returned list is interesting.\n", "unutbu had a simple answer for this, but pop() can also take an index as a parameter. This is how you replicate it with numpy:\npop_index = 4\npop = y[pop_index]\ny = np.concatenate([y[:pop_index],y[pop_index+1:]])\n\n", "To add, If you want to implement pop for a row or column from a numpy 2D array you could do like:\ncol = arr[:, -1] # gets the last column\nnp.delete(arr, -1, 1) # deletes the last column\n\nand for row:\nrow = arr[-1, :] # gets the last row\nnp.delete(arr, -1, 0) # deletes the last row\n\n", "OK, since I didn't see a good answer that RETURNS the 1st element and REMOVES it from the original array, I wrote a simple (if kludgy) function utilizing global for a 1d array (modification required for multidims):\ntmp_array_for_popfunc = 1d_array\n\ndef array_pop():\n global tmp_array_for_popfunc\n \n r = tmp_array_for_popfunc[0]\n tmp_array_for_popfunc = np.delete(tmp_array_for_popfunc, 0)\n return r\n\ncheck it by using-\nprint(len(tmp_array_for_popfunc)) # confirm initial size of tmp_array_for_popfunc\nprint(array_pop()) #prints return value at tmp_array_for_popfunc[0]\nprint(len(tmp_array_for_popfunc)) # now size is 1 smaller\n\n", "I made a function as follow, doing almost the same. This function has 2 arguments: np_array and index, and return the value of the given index of the array.\ndef np_pop(np_array, index=-1):\n '''\n Pop the \"index\" from np_array and return the value. \n Default value for index is the last element.\n '''\n # add this to make sure 'numpy' is imported \n import numpy as np\n # read the value of the given array at the given index\n value = np_array[index]\n # remove value from array\n np.delete(np_array, index, 0)\n # return the value\n return value\n\nRemember you can add a condition to make sure the given index is exist in the array and return -1 if anything goes wrong.\nNow you can use it like this:\nimport numpy as np\ni = 2 # let's assume we want to pop index number 2\ny = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9]) # assume 'y' is our numpy array \npoped_val = np_pop(y, i) # value of the piped index\n\n" ]

[ 30, 20, 6, 6, 2, 1, 1, 0, 0, 0 ]

[]

[]

[ "arrays", "list", "numpy", "python", "stack" ]

[ "example\ndf.groupby(df['c1'].str[-1]).sum()\n\noutput:\n c2\nc1 \nx 3\ny 7\n\nuse following code:\ndf.groupby('C' + df['c1'].str[-1]).sum().reset_index()\n\nresult:\n c1 c2\n0 Cx 3\n1 Cy 7\n\n", "You may do:\nout = df.groupby(df.c1.str[-1]).sum().reset_index()\nout['c1'] = 'C' + out['c1']\n\nprint(out):\n c1 c2\n0 Cx 3\n1 Cy 7\n\n", "Groupby is very flexible so let's group by the last character of the \"c1\" column and then sum the \"c2\" values:\n>>> (df.groupby(df.c1.str[-1])[\"c2\"]\n .sum().reset_index()\n .assign(c1=lambda fr: fr.c1.radd(\"C\")))\n\n c1 c2\n0 Cx 3\n1 Cy 7\n\nWithout the assign at the end, resultant \"c1\" values are the groupers, i.e., \"x\" and \"y\". I add (from right, hence radd) the character \"C\" to them.\n", "Here is a proposition using pandas.Series.replace with GroupBy.sum :\nout = (\n df\n .assign(c1= df[\"c1\"].str.replace(\"[A-Z]\", \"C\", regex=True))\n .groupby(\"c1\", as_index=False).sum(numeric_only=True)\n )\n\nOutput :\n​\nprint(out)\n​\n c1 c2\n0 Cx 3\n1 Cy 7\n\n" ]

[ 2, 1, 1, 1 ]

[]

[]

[ "pandas", "python" ]

[ "I had the same problem. I needed to install package python3-venv.\n", "In order to fix this, I had to run from my terminal:\npip install virtualenv\n\nAfter installing the virtualenv package everything works as expected.\n", "If you have python3-env already installed, the commands provided in most of the answers will not work as you need the python3-venv package specifically for Python 3.10\nThe exact package as pointed by @fabel in comments is python3.10-venv .\nsudo apt install python3.10-venv\n\nRun this command and it should be good to go.\n", "I attempted the previous answers and eventually found that I had to delete the venv folder and allow PyCharm to recreate it.\n", "In my case, I didn't have pip installed on my computer.\n", "just open your terminal and install pip package:\nIn ubuntu:\nsudo apt install pip\nFor windows:\nhttps://phoenixnap.com/kb/install-pip-windows\nThen try to create the virtual environment again\n", "A possible reason could be not having the package virtualevn installed in your computer. I had the problem after reinstalling OS.\nThe following is valid for ubuntu OS with Python3 installed.\nCheck if the pip is installed after installing Python.\nUse the command sudo apt install python3-pip.\nOnce pip installed, install the package using pip3 install virtualenv.\nThen go back to Pycharm IDE settings to set up the venv.\n", "In my case i wasn't the owner of the project file. I was needed to run the CHOWN command to resolve this.\n\nsudo chown $USER /Users/Sites/***<Project_Folder>***\n\nand i was done.\n", "In my case, there was something wrong with the latest PyCharm Community Edition of 2022.2.3 version (build ID: 222.4345.23). I tried everything mentioned here with no vain. After spending several hours, just downgraded to version 2021.3.2 version of PyCharm community edition, and it just worked. Hope this helps.\n", "I ran \"pip install virtualenv\" in the terminal,\nbut after trying again it didn't work.\nI downloaded python 3.10 from python.org\nthen because i had problems updating my python version from 3.9 to 3.10 on my computer, i decided to try to make a virtual environment in PyCharm, in my main project (my only one) I clicked \"Add Interpreter...\" then selected \"Virtualenv environment\" then set the location to \"/home/myname/Documents/PyCharm/venvPy3.10\" and then i set base interpreter to the one i downloaded by clicking on the three dots on the right of it then going to my downloads folder. I also selected both \"Inherit global site-packages\" and \"Make available to all project\" then clicked \"OK\".\nThen it gives me warning.\n", "There is a bug in Windows venv, which is known to be exposed if you install a VisualStudio 2022 runtime. If PyCharm uses venv and not another virtual environment (not sure as I don't use PyCharm) s See if my issue/workaround in this Q&A aligns with yours.\nEdit: I realize that you are using virtualenv instead. However, virtualenv uses venv.EnvBuilder so the issue could still be related.\n", "if you don't have pip before install pip\nsudo apt install python3-pip\n\npress Ctrl + Alt + S\n\nthen click settings button and select show all\n\npress Alt + Insert keys then\n\nSelect Virtualenv Environment and check Inherit global site-packages\n", "I had the same problem, but solved it by adding an interpreter manually.\n\n", "If someone is still not able to fix this then, create it manually.\n\ngo in the dir that you want the venv in, then python3.10 -m venv <name of venv>\nsource <name of venv>/bin/activate\ngo in Python\nInterpeter settings and then select the location of the manually\ncreated venv in the 'existing environment'\n\n", "I had same problem tried many things\nBut I realized that Window Defender is blocking PyCharm to create virtual environment\nJust go in Defender Settings and allow PyChram\n", "I had same issue with following version.\npycharm - PyCharm 2022.1.3 (Community Edition)\npython - python 3.9\nOnce I changed interpreter version to python 3.10. It started working.\n", "I ran into the same problem, but was able to resolve it in my environment.\nGo to Help -> Edit Custom VM Options and add the following\n-Dfile.encoding=UTF-8\n\nHere is my environment:\nWindows 11\nPyCharm Community 2022.2.3 (installed from JetBrains ToolBox)\nPython 3.11 (installed from microsoft store)\n\n", "I had the same error and I don't know how the solution that I'll explain solved\nI was naming the project as \"Joining Data with pandas\", \"joining_data_with_pandas\"\nbut when I changed the name to \"joiningDataPandas\", it works with no error.\nI think it may be a bug from the ide or something, because if I tried to create a new project with the old name that has spaces or \"_\" the error will be back, but with writing the project name with the camelCase, there is no error.\n", "\nOpen and clear the log: %AppData%\\Local\\JetBrains\\PyCharmCE2022.1\\log\\idea.log\n(in PyCharm click Help > Show Log in Explorer).\n\nTry to create VirtualEnv via PyCharm, you will see\nthe \"Failed to create Venv...\" message \n\nOpen the log and look for errors In my case it was unable to import some modules because the threading module was not found (ie: ModuleNotFoundError: No module named 'threading'). My python3.10 was broken, maybe I have some problems with my PATH variable.\n\nI was missing the modules threading, logging, and weakref, so I just copied them to %AppData%\\Local\\Programs\\Python\\Python310\\Lib\\ (from site-packages folder, in my case)\n\nEnjoy creating as many VENV's as you needed. If you still have an error in PyCharm then repeat steps 2, 3, and 4 until you fix all errors about missing modules or other.\n\n\n", "I fixed this problem by first deleting my current venv folder. Then I went back to PyCharm to Configure Local Environment>Add Local Interpreter> and made sure the location is in an empty directory. I did this by just adding /venv at the end of my path.\n" ]

[ 22, 19, 10, 7, 6, 4, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[]

[]

[ "pycharm", "python", "virtualenv" ]

[ "IIUC, try this using the str accessor with extract method and your regex:\ndf['email'] = df['info'].str.extract('([\\w.+-]+@[\\w-]+\\.[\\w.-]+)')\ndf['Email Found'] = df['email'].notna()\n\noutput:\n info \\\n0 Maxwell <[email protected]>... \n1 Julianna <[email protected]>... \n2 Janelle <[email protected]... \n\n email Email Found \n0 [email protected] True \n1 [email protected] True \n2 [email protected] True \n\n" ]

[ 0 ]

[]

[]

[ "dataframe", "pandas", "python", "text_extraction" ]

[ "Inspect the askForTime value you get from this line:\ndef main():\n askForTime = input(\"What time is it? \").strip().split()\n\nWhen you do, you will discover that it is returning the input as a list. (That's because you used .split() - the return is a list.) Your convert() function \"works\" because it expects a list. However, check50 tests by calling with a string, like this:\npset_1/meal/SO_74635140/ $ python\n>>> from meal import convert\n>>> print(convert(\"7:30\"))\n\nWhen you run as shown above, you will get this error message:\nTraceback (most recent call last):\n File \"<stdin>\", line 1, in <module>\n File \"/workspaces/68927141/pset_1/meal/SO_74635140/meal.py\", line 19, in convert\n hours, minutes = clock[0].split(\":\")\nValueError: not enough values to unpack (expected 2, got 1)\n\nAlso, you have \"breakfast time\" misspelled as \"breacfast time\". That will cause another check50 error once you fix the 1st problem.\n" ]

[ 0 ]

[]

[]

[ "cs50", "decimal", "python", "type_conversion" ]

[ "When using format, the {} are a place holder for an expression. Do the arithmetic in the format argument, not in the place holder.\nstr = \"a = {}\"\na = 10\nstra = str.format(a-1)\nprint(stra)\n>> a = 9\n\n" ]

[ 1 ]

[]

[]

[ "f_string", "python" ]

[ "As mentioned in the comments, the pattern you mention does not match the one you use in your code, nor does it correspond to the example strings you want replaced. So you may or may not want to adjust the following pattern depending on what you actually need.\nimport re\nfrom pathlib import Path\n\n\nPATTERN = re.compile(r'<a\\s+class=“req-link”\\s+href=“https://.*?</a>')\n\n\ndef replace_a_tags(input_file: str, output_file: str) -> None:\n contents = Path(input_file).read_text()\n with Path(output_file).open(\"w\") as f:\n f.write(re.sub(PATTERN, \"TBD\", contents))\n\n\nif __name__ == \"__main__\":\n replace_a_tags(\"input.txt\", \"output.txt\")\n\nThe .*? is important to match lazily (as opposed to greedily) so that it matches any character (.) between zero and unlimited times, as few times as possible until it hits the closing anchor tag.\nThe pattern matches both your example strings.\nThe Path.read_text method obviously reads the entire file into memory, so that may be a problem, if it happens to be gigantic, but I doubt it. The benefit is that the global regex replacement is much more efficient than iterating over each line in the file individually.\n" ]

[ 0 ]

[]

[]

[ "python", "regex" ]

[ "input returns a str\nsen = input('lotfan sen khod ra vared konid :')\n\nYou can convert it to an int for your comparisons\nsen = int(input('lotfan sen khod ra vared konid :'))\n\n" ]

[ 0 ]

[]

[]

[ "python" ]

[ "The sys package is part of python's standard library, which means it comes with python and does not need installed separately.\n" ]

[ 0 ]

[]

[]

[ "conda", "python", "sys" ]

[ "IIUC you want to row- and columnwise divide each element of coor by word_occurrences. This can be done by simple elementwise division and broadcasting:\nimport numpy as np\n\ncooc = np.array([[0, 1, 1, 0], [1, 0, 2, 1], [1, 2, 0, 1], [0, 1, 1, 0]])\nword_occurrences = [1, 2, 3, 4]\n\ncooc / word_occurrences / np.array(word_occurrences)[:, np.newaxis]\n\nResult:\narray([[0. , 0.5 , 0.33333333, 0. ],\n [0.5 , 0. , 0.33333333, 0.125 ],\n [0.33333333, 0.33333333, 0. , 0.08333333],\n [0. , 0.125 , 0.08333333, 0. ]])\n\nIs this what you are looking for?\n" ]

[ 0 ]

[]

[]

[ "apply", "numpy", "python" ]

[ "Look at this attribute:\ncur.description\n\nAfter you have executed your query, it will be set to None if no rows were returned, or will contain data otherwise - for example:\n(Column(name='id', type_code=20, display_size=None, internal_size=8, precision=None, scale=None, null_ok=None),)\n\nCatching exceptions is not ideal because there may be a case where you're overriding a genuine exception.\n", "Check whether cursor.pgresult_ptr is None or not.\ncursor.execute(sql)\nif cursor.pgresult_ptr is not None:\n cursor.fetchall()\n\n", "The accepted answer using cur.description does not solve the problem any more. cur.statusmessage can be a solution. This returns SELECT 0 or INSERT 0 1. A simple string operation can then help determine the last query.\n", "The problem is that what turns out to be None is the result of cur.fetchone()\nSo the way to stop the loop is :\ncursor.execute(\"SELECT * from rep_usd\")\noutput = cursor.fetchone()\nwhile output is not None:\n print(output)\n output = DBCursor.fetchone()\n\ncursor.description will never be None!\n", "The current best solution I found is to use cursor.rowcount after an execute(). This will be > 0 if the execute() command returns a value otherwise it will be 0.\n" ]

[ 31, 4, 2, 0, 0 ]

[]

[]

[ "psycopg2", "python" ]

[ "Did you mean something like this:\ndef example():\n pass\n\na = []\na.append(example)\n\n# What is a[0]'s name?\nprint(a[0].__name__)\n\nAs en element of the list a, we don't know the function's name. But by calling the __name__ attribute, I get the associated string.\n" ]

[ 0 ]

[]

[]

[ "python", "python_3.x" ]

[ "Of course, you can parallelize all available cores of your CPU. I use the convenient and simple parallelbar library. The idea is simple. Create a function that returns a list of indexes. Run this function on a thread pool and pass a list of inputs to the pool.\nimport pandas as pd\nimport numpy as np\nfrom parallelbar import progress_map #pip install parallelbar\n#create dataframe with 3000 000 rows\ndf = pd.DataFrame({\"X\":np.random.randint(0, 1000, size=3000_000),\n \"Y\":np.random.randint(0, 1000, size=3000_000)})\n# synchronous cicle\nind_list = []\nfor input in range(1,5000):\n inds = df[(input >= df[\"X\"]) & (input <= df[\"Y\"])].index\n ind_list.append(inds)\n\nOutpu: Wall time: 25 s\n\n#create simple function\ndef foo(inp):\n return df[(inp >= df[\"X\"]) & (inp <= df[\"Y\"])].index\n\n#run in the thread pool with map method\n%%time\nresult = progress_map(foo, range(1,5000), executor='threads')\n\nOutput: Wall time is 17 s.\n\nIt's a little faster.\nalso, you can pass to numpy array. Operations directly on these arrays are always faster than pandas.\nnp_val = df.values\n\n#synchronous cycle with numpy\n%%time\nind_list = []\nfor i in range(1,5000):\n inds = np.where((i >= np_val[:,0]) & (i <= np_val[:,1]))[0]\n ind_list.append(inds)\n\nOutput: Wall time is 15 s\n\n\ndef foo(inp):\n return np.where((inp >= np_val[:,0]) & (inp <= np_val[:,1]))[0]\n\n%%time\nresult = progress_map(foo, range(1,5000), executor='threads')\n\nOutpu: Wall time is 8.5 s\n\nTotal speedup: 25/8.5 ~ 3\n" ]

[ 0 ]

[]

[]

[ "dataframe", "pandas", "python" ]

[ "Methods are class attributes, so some_func needs to be attached to type(self), not self itself.\nclass Foo:\n\n def __init__(self):\n self.reference = \"ti-hihi\"\n self.foo2 = Foo2()\n for (method_name, pass_this) in [(\"bar\", \"passed-for-bar\"), (\"bar2\", \"passed-for-bar2\")]:\n my_doc = f\"\"\"my_custom_docstring: {pass_this}\"\"\"\n\n def some_func(self):\n self.foo2.do_this(pass_this=pass_this)\n some_func.__doc__ = my_doc\n setattr(type(self), method_name, some_func)\n\nAs such, the __init_ method is not really the proper place to do this, as you'll be repeatedly attaching the (effectively same) methods to the class every time you instantiate the class. A class decorator would be more appropriate:\ndef add_methods(cls):\n for (method_name, pass_this) in [(\"bar\", \"passed-for-bar\"), (\"bar2\", \"passed-for-bar2\")]:\n my_doc = ...\n def some_func(self):\n self.foo2.do_this(pass_this=pass_this)\n some_func.__doc__ = my_doc\n setattr(cls, method_name, some_func)\n return cls\n\n\n@add_methods\nclass Foo:\n def __init__(self):\n self.reference = \"ti-hihi\"\n self.foo2 = Foo2()\n\nadd_methods doesn't really require any special information about Foo. Indeed, add_methods can be applied to any class that\n\nDefines a foo2 attribute for its instances, and\nfoo2 has a type that provides an appropriate do_this method.\n\nEven that assumption can be made more explicit by defining a suitable base class.\ndef FooBase:\n def __init__(self):\n self.foo2 = Foo2()\n\n@add_methods\ndef Foo(FooBase):\n pass\n\nNow you can simply state that add_methods is designed to work with subclass of FooBase.\n", "Thanks to @AndrewAllaire for this tip, using functools.partial solved it for me\nsome_func = partial(self.foo2.do_this, pass_this=pass_this)\n\n" ]

[ 0, 0 ]

[]

[]

[ "class", "lambda", "python", "setattr" ]

[ "If you're talking about Python module DLLs, then simply modifying sys.path should be fine. However, if you're talking about DLLs linked against those DLLs; i.e. a libfoo.dll which a foo.pyd depends on, then you need to modify your PATH environment variable. I wrote about doing this for PyGTK a while ago, but in your case I think it should be as simple as:\nimport os\nos.environ['PATH'] = 'my-app-dir' + os.pathsep + os.environ['PATH']\n\nThat will insert my-app-dir at the head of your Windows path, which I believe also controls the load-order for DLLs.\nKeep in mind that you will need to do this before loading the DLL in question, i.e., before importing anything interesting.\nsqlite3 may be a bit of a special case, though, since it is distributed with Python; it's obviously kind of tricky to test this quickly, so I haven't checked sqlite3.dll specifically.\n", "The answer with modifying os.environ['PATH'] is right but it didn't work for me because I use python 3.9.\nStill I was getting an error:\n\nImportError: DLL load failed while importing module X: The specified\nmodule could not be found.\n\nTurned out since version python 3.8 they added a mechanism to do this more securely.\nRead documentation on os.add_dll_directory https://docs.python.org/3/library/os.html#os.add_dll_directory\nSpecifically see python 3.8 what's new:\n\nDLL dependencies for extension modules and DLLs loaded with ctypes on Windows are now resolved more securely. Only the system paths, the directory containing the DLL or PYD file, and directories added with add_dll_directory() are searched for load-time dependencies. Specifically, PATH and the current working directory are no longer used, and modifications to these will no longer have any effect on normal DLL resolution. If your application relies on these mechanisms, you should check for add_dll_directory() and if it exists, use it to add your DLLs directory while loading your library.\n\nSo now this is the new way to make it work in python 3.8 and later:\nimport os\nos.add_dll_directory('my-app-dir')\n\nAgain, the old way is still correct and you will have to use it in python 3.7 and older:\nimport os\nos.environ['PATH'] = 'my-app-dir' + os.pathsep + os.environ['PATH']\n\nAfter that my module with a dll dependency has been successfully loaded.\n", "Ok it turns out python always loads the dll in the same directory as the pyd file, regardless of what the python and os paths are set to.\nSo I needed to copy the _sqlite3.pyd from python/v2.5/DLLS to my apps directory where the new sqlite3.dll is, making it load my new dll, rather than the one that comes with python (since the pyd files seem to follow the PYTHONPATH, even though the actual dlls themselves don't).\n", "If your version of sqlite is in sys.path before the systems version it will use that. So you can either put it in the current directory or change the PYTHONPATH environment variable to do that.\n", "I had the same issue as administrative rights to the default python library is blocked in a corporate environment and its extremely troublesome to perform installations.\nWhat works for me:\n\nDuplicate the sqlite3 library in a new location\nPut in the latest sqlite3.dll (version you want from sqlite3 web) and the old _sqlite3.pyd into the new location or the new sqlite3 library. The old _sqlite3.pyd can be found in the default python library lib/DLLs folder.\nGo to the new sqlite3 library and amend the dbapi2.py as follows:\nChange \"from _sqlite3 import *\" to \"from sqlite3._sqlite3 import *\"\nMake sure python loads this new sqlite3 library first. Add the path to this library if you must.\n\n", "I encountered the same problem for my .pyd that depends on cuda/cudnn/tensorrt.\nI came with a little function I call before importing my module.\ndef add_cuda_to_path():\n if os.name != \"nt\":\n return\n path = os.getenv(\"PATH\")\n if not path:\n return\n path_split = path.split(\";\")\n for folder in path_split:\n if \"cuda\" in folder.lower() or \"tensorrt\" in folder.lower():\n os.add_dll_directory(folder)\n\nIt is the easiest workaround I found, so I don't need to hardcode any path.\nI guess little improvement would to actually check for .dll file, but this snippet serves well my needs.\nThen you can simply:\nadd_cuda_to_path()\nimport my_module_that_depends_on_cuda\n\nHave a nice day.\n" ]

[ 32, 15, 7, 0, 0, 0 ]

[]

[]

[ "module", "python" ]

[ "your need to have model like this:\nclass Choices(models.Model):\n animal = models.CharField(max_length=20)\n\nclass Owner(models.Model):\n animal = models.ManyToManyField(Choices)\n\n", "Presumably your best solution is to think about how you are going to store the data at a database level. This will dictate your approach and therefore your solution.\nYou want a single column that stores multiple values so your best approach would be to use django-multiselectfield\nfrom multiselectfield import MultiSelectField\n\nMY_CHOICES = ((1, 'Item title 2.1'),\n (2, 'Item title 2.2'),\n (3, 'Item title 2.3'),\n (4, 'Item title 2.4'),\n (5, 'Item title 2.5'))\n\nclass MyModel(models.Model):\n my_field = MultiSelectField(choices=MY_CHOICES,\n max_choices=3,\n max_length=3)\n\n" ]

[ 0, 0 ]

[]

[]

[ "django", "python" ]

[ "There are two parts to your question.\n1. Renaming the Node\nRegarding renaming the node by using Unique Name as the alias for Parent name, the above answer on aliasDict is good but we can modify the DataFrame directly instead, leaving your code unchanged.\nI have modified your DataFrame because it does not seem to run properly, and your code example does not clearly show that Unique Name is an alias for Parent in some cases.\ndata = pd.DataFrame(\n columns=[\"Unique Name\", \"Parent\", \"Child\"],\n data=[\n [\"US_SQ\", \"A\", \"A1\"],\n [\"US_SQ\", \"A\", \"A2\"],\n [\"UC_LC\", \"A2\", \"A21\"],\n [\"UI_QQ\", \"B\", \"B1\"]\n ]\n)\n\n# Rename Parent and Child columns using aliasDict\naliasDict = dict(data[[\"Parent\", \"Unique Name\"]].values)\ndata[\"Parent\"] = data[\"Parent\"].replace(aliasDict)\ndata[\"Child\"] = data[\"Child\"].replace(aliasDict)\n\n# Your original code - unchanged\nnodes = {}\nfor parent, child in zip(data[\"Parent\"],data[\"Child\"]):\n add_nodes(nodes, parent, child)\n\n2. Exporting to DataFrame\nIn the second part, anyTree does not provide integration with pandas DataFrame. An alternative bigtree Python package does this out-of-the-box for you.\nThe whole code example can be implemented as such,\nimport pandas as pd\nfrom bigtree import dataframe_to_tree_by_relation, print_tree, tree_to_dataframe\n\ndata = pd.DataFrame(\n columns=[\"Unique Name\", \"Parent\", \"Child\"],\n data=[\n [\"root\", \"root\", \"A\"], # added this line\n [\"root\", \"root\", \"B\"], # added this line\n [\"US_SQ\", \"A\", \"A1\"],\n [\"US_SQ\", \"A\", \"A2\"],\n [\"UC_LC\", \"A2\", \"A21\"],\n [\"UI_QQ\", \"B\", \"B1\"]\n ]\n)\n\n# Rename Parent and Child columns using aliasDict (same as above)\naliasDict = dict(data[[\"Parent\", \"Unique Name\"]].values)\ndata[\"Parent\"] = data[\"Parent\"].replace(aliasDict)\ndata[\"Child\"] = data[\"Child\"].replace(aliasDict)\n\n# Create a tree from dataframe, print the tree\nroot = dataframe_to_tree_by_relation(data, parent_col=\"Parent\", child_col=\"Child\")\nprint_tree(root)\n# root\n# ├── US_SQ\n# │ ├── A1\n# │ └── UC_LC\n# │ └── A21\n# └── UI_QQ\n# └── B1\n\n# Export tree to dataframe\ntree_to_dataframe(root, parent_col=\"Parent\", name_col=\"Child\")\n# path Child Parent\n# 0 /root root None\n# 1 /root/US_SQ US_SQ root\n# 2 /root/US_SQ/A1 A1 US_SQ\n# 3 /root/US_SQ/UC_LC UC_LC US_SQ\n# 4 /root/US_SQ/UC_LC/A21 A21 UC_LC\n# 5 /root/UI_QQ UI_QQ root\n# 6 /root/UI_QQ/B1 B1 UI_QQ\n\nSource: I'm the creator of bigtree ;)\n" ]

[ 2 ]

[]

[]

[ "anytree", "python", "tree", "treeview" ]

[ "It turns out that object-hash prefixes the variable for hashing with its type. In the case of strings I needed to add string:{string_length}: to the hash stream.\nhash = hashlib.sha1()\n\nhash.update(f'string:{len(json_data)}:'.encode('utf-8')) # The line in question\n\nhash.update(json_data)\nres = hash.hexdigest()\nprint(res)\n\nHaving done that, the hashes produced by hashlib and crypto are the same as those of object-hash.\nNote: This is not documented and I had to look through the source code to find exactly how to prefix strings in particular. Other types have different prefixes.\n" ]

[ 0 ]

[]

[]

[ "hashlib", "javascript", "node.js", "object_hash", "python" ]

[ "This is not how for loops work in Python.\nfor col in combi:\n if combi[col].dtype==\"object\":\n # ...\n\ncol isn't an index into the collection you're iterating over (combi), it is the dereferenced element itself. Change all instances of combi[col] inside your for loop to col to correct. Example:\nfor col in combi:\n if col.dtype==\"object\":\n\nYou didn't post all of your code so it's unclear if this will resolved the problem you're seeing, but it is certainly a step in the right direction.\n" ]

[ 0 ]

[]

[]

[ "jupyter_notebook", "kaggle", "python", "scikit_learn", "seaborn" ]

[ "So from your data you could do:\nimport random\nfrom collections import Counter\n\n\ndata = [random.randint(0,6) for _ in range(10)]\ntotal_data = [data]\n\nfrequency = Counter(data)\nnumber_elements = len(data)\n\ntotal_data.append(list((frequency[item] / number_elements)*100 if item != 0 else '' for item in total_data[0]))\n\ndf = pd.DataFrame(total_data)\n\nprint(df)\n\ndf.to_excel(r'H:\\Grade10\\Cs\\Mir Hussain 12.00.00 3.xlsx', index=False)\n\nItem frequency count in Python\n", "import pandas as pd\nimport random\n\ndata = [random.randint(0,6) for _ in range(10)]\n\ndf = pd.DataFrame(data)\n\ndf = df.value_counts(normalize=True) # this line makes the percentages\n\ndf.to_excel(r'H:\\Grade10\\Cs\\Mir Hussain 12.00.00 3.xlsx', index=False)\n\n" ]

[ 0, 0 ]

[]

[]

[ "python" ]

[ "I think what you are looking for is the Decimal module:\n>>> from decimal import *\n>>> getcontext().prec = 6\n>>> Decimal(1) / Decimal(7)\nDecimal('0.142857')\n>>> getcontext().prec = 28\n>>> Decimal(1) / Decimal(7)\nDecimal('0.1428571428571428571428571429')\n\nIt gives complete control on the precision of your operations as long as you use Decimal objects.\n" ]

[ 1 ]

[ "Use this\nprint(\"{0:.4f}\".format(250459325658972.0 +0.4047617913405519))\n\n" ]

[ -2 ]

[ "floating_point", "python" ]

[ "Had exactly the same issue and solved it by installing the latest of win32com.\npip install pywin32==301\n\n", "I had the same issue:\nfrom win32com.shell import shellcon, shell\n ImportError: DLL load failed: The specified module could not be found.***\n\nI fixed mine by clearing my environment variable called PYTHONPATH. I was messing with it and tried to add paths to it for another application (which turned out to not use PYTHONPATH).\nI guess that was confusing Anaconda when starting up because it was importing incorrect libraries or something. I couldn't use Spyder, Anaconda Navigator, Jupyter Notebooks or anything other than Anaconda Prompt. Glad the issue wasn't too big!\n", "It finally solved!\ni uninstalled the 32-bit Anaconda\nMeanwhile, i noticed that in the C:\\Users\\aaron.wu\\AppData\\Local\\Programs\nThere is folder named python which is not supposed to be there and it includeds pip folder.\nI manually delete \"python\" folder and reinstalled 64-bit and it worked out!\n", "It looks like the issue is related to a conflict in newer versions of the pywin32 package.\nTry downgrading the package (I had 301 installed):\npip install --user --upgrade pywin32==228\n\nSource: https://github.com/conda/conda/issues/11503#issuecomment-1159613779\n" ]

[ 5, 4, 1, 0 ]

[]

[]

[ "anaconda", "python" ]