Datasets:

---

suriyagunasekar

/

stackoverflow-python-with-meta-data

like 12

[ "Assuming Gaussian statistics, the uncertainties stem from Gaussian parent distributions. In such a case, it is standard to weight the measurements (nominal values) by the inverse variance. This application to the general weighted average gives,\n$$ \\frac{\\sum_i w_i x_i}{\\sum_i w_i} = \\frac{\\sum_i x_i/\\sigma_i^2}{\\sum_i 1/\\sigma_i^2} $$.\n\nOne need only perform good 'ol error propagation on this to get an uncertainty of the weighted average as,\n$$ \\sqrt{\\sum_i \\frac{1}{1/\\sum_i \\sigma_i^2}} $$\n\nI don't have an n-length formula to do this syntactically speaking on hand, but here's how one could get the weighted average and its uncertainty in a simple case:\n a = un.ufloat(5, 2)\n b = un.ufloat(8, 4)\n wavg = un.ufloat((a.n/a.s**2 + b.n/b.s**2)/(1/a.s**2 + 1/b.s**2), \n np.sqrt(2/(1/a.s**2 + 1/b.s**2)))\n print(wavg)\n >>> 5.6+/-2.5298221281347035\n\nAs one would expect, the result tends more-so towards the value with the smaller uncertainty. This is good since a smaller uncertainty in a measurement implies that its associated nominal value is closer to the true value in the parent distribution than those with larger uncertainties.\n", "Unless I'm missing something, you could calculate the sum divided by the length of the array:\nfrom uncertainties import unumpy, ufloat\nimport numpy as np\narr = np.array([ufloat(2, 1), ufloat(3, 2), ufloat(4,3)])\nprint(sum(arr)/len(arr))\n# 3.0+/-1.2\n\nYou can also define it like this:\narr1 = unumpy.uarray([2, 3, 4], [1, 2, 3])\nprint(sum(arr1)/len(arr1))\n# 3.0+/-1.2\n\nuncertainties takes care of the rest.\n", "I used Captain Morgan's answer to serve up some sweet Python code for a project and discovered that it needed a little extra ingredient:\n import uncertainties as un\n from un.unumpy import unp\n epsilon = unp.nominal_values(values).mean()/(1e12)\n wavg = ufloat(sum([v.n/(v.s**2+epsilon) for v in values])/sum([1/(v.s**2+epsilon) for v in values]), \n np.sqrt(len(values)/sum([1/(v.s**2+epsilon) for v in values])))\n if wavg.s <= np.sqrt(epsilon):\n wavg = ufloat(wavg.n, 0.0)\n\nWithout that little something (epsilon) we'd get div/0 errors from observations recorded with zero uncertainty.\n", "If you already have a .csv file which stores variables in 'mean+/-sted' format, you could try the code below; it works for me.\nfrom uncertainties import ufloat_fromstr\ndf=pd.read_csv('Z:\\compare\\SL2P_PAR.csv')\nfor i in range(len(df.uncertainty)):\ndf['mean'] = ufloat_fromstr(df['uncertainty'][I]).n\ndf['sted'] = ufloat_fromstr(df['uncertainty'][I]).s\n\n" ]

[ 3, 1, 0, 0 ]

[]

[]

[ "arrays", "python", "uncertainty" ]

[ "With your one example, this works:\ns = '''82290574 BB BBBBB 3.0 195.00 3.75 0.00 0.00 0.00 85.00 113.75 21.61 135.36 220811 11.08.2022 00.000\n82290600 BB BBBBB 2.5 375.00 3.13 0.00 0.00 0.00 225.00 153.13 29.09 182.22 220811 11.08.2022 00.000\n82290633 BB BBBBB 36.0 270.00 45.00 0.00 0.00 0.00 122.04 192.96 36.66 229.62 220812 12.08.2022 04.110\n123 12345678'''\n\nprint(re.findall(r'\\b(?:\\d{3} )?\\d{8}\\b', s))\n\n['82290574', '82290600', '82290633', '123 12345678']\n\nIt works even without the word breaks in this case.\n" ]

[ 1 ]

[]

[]

[ "python", "regex" ]

[ "You can execute any raw SQL query which you need (of course you have to get appropriate rights in the session). To change a variable run something like this:\n# change variable name and values to what you need\nconnection.execute(\"SET SESSION query_cache_type = OFF\")\n\n", "As mentioned previously, you could use the following code the set a variable using the raw Connection object.\nconnection.execute(\"SET SESSION query_cache_type = OFF\")\n\nIf you have a Session object, you can retrieve the underlying Connection object using the Session.connection() function.\nSo your code could look as follows.\nsession.connection().execute(\"SET SESSION query_cache_type = OFF\")\n\n" ]

[ 5, 0 ]

[]

[]

[ "mysql", "python", "sqlalchemy" ]

[ "TL;DR: you should not use such a loop in any performance critical code but ''.join instead. The inefficient execution appears to be related to a regression during the bytecode generation in CPython 3.11 (and missing optimizations during the evaluation of binary add operation on Unicode strings).\n\nGeneral guidelines\nThis is an antipattern. You should not write such a code if you want this to be fast. This is described in PEP-8:\n\nCode should be written in a way that does not disadvantage other implementations of Python (PyPy, Jython, IronPython, Cython, Psyco, and such). \nFor example, do not rely on CPython’s efficient implementation of in-place string concatenation for statements in the form a += b or a = a + b. This optimization is fragile even in CPython (it only works for some types) and isn’t present at all in implementations that don’t use refcounting. In performance sensitive parts of the library, the ''.join() form should be used instead. This will ensure that concatenation occurs in linear time across various implementations.\n\nIndeed, other implementations like PyPy does not perform an efficient in-place string concatenation for example. A new bigger string is created for every iteration (since strings are immutable, the previous one may be referenced and PyPy does not use a reference counting but a garbage collector). This results in a quadratic runtime as opposed to a linear runtime in CPython (at least in past implementation).\n\nDeep Analysis\nI can reproduce the problem on Windows 10 between the embedded (64-bit x86-64) version of CPython 3.10.8 and the one of 3.11.0:\nTimings:\n - CPython 3.10.8: 146.4 ms\n - CPython 3.11.0: 15186.8 ms\n\nIt turns out the code has not particularly changed between CPython 3.10 and 3.11 when it comes to Unicode string appending. See for example PyUnicode_Append: 3.10 and 3.11.\nA low-level profiling analysis shows that nearly all the time is spent in one unnamed function call of another unnamed function called by PyUnicode_Concat (which is also left unmodified between CPython 3.10.8 and 3.11.0). This slow unnamed function contains a pretty small set of assembly instructions and nearly all the time is spent in one unique x86-64 assembly instruction: rep movsb byte ptr [rdi], byte ptr [rsi]. This instruction is basically meant to copy a buffer pointed by the rsi register to a buffer pointed by the rdi register (the processor copy rcx bytes for the source buffer to the destination buffer and decrement the rcx register for each byte until it reach 0). This information shows that the unnamed function is actually memcpy of the standard MSVC C runtime (ie. CRT) which appears to be called by _copy_characters itself called by _PyUnicode_FastCopyCharacters of PyUnicode_Concat (all the functions are still belonging to the same file). However, these CPython functions are still left unmodified between CPython 3.10.8 and 3.11.0. The non-negligible time spent in malloc/free (about 0.3 seconds) seems to indicate that a lot of new string objects are created -- certainly at least 1 per iteration -- matching with the call to PyUnicode_New in the code of PyUnicode_Concat. All of this indicates that a new bigger string is created and copied as specified above.\nThe thing is calling PyUnicode_Concat is certainly the root of the performance issue here and I think CPython 3.10.8 is faster because it certainly calls PyUnicode_Append instead. Both calls are directly performed by the main big interpreter evaluation loop and this loop is driven by the generated bytecode.\nIt turns out that the generated bytecode is different between the two version and it is the root of the performance issue. Indeed, CPython 3.10 generates an INPLACE_ADD bytecode instruction while CPython 3.11 generates a BINARY_OP bytecode instruction. Here is the bytecode for the loops in the two versions:\nCPython 3.10 loop:\n\n >> 28 FOR_ITER 6 (to 42)\n 30 STORE_NAME 4 (_)\n 6 32 LOAD_NAME 1 (a)\n 34 LOAD_CONST 2 ('a')\n 36 INPLACE_ADD <----------\n 38 STORE_NAME 1 (a)\n 40 JUMP_ABSOLUTE 14 (to 28)\n\nCPython 3.11 loop:\n\n >> 66 FOR_ITER 7 (to 82)\n 68 STORE_NAME 4 (_)\n 6 70 LOAD_NAME 1 (a)\n 72 LOAD_CONST 2 ('a')\n 74 BINARY_OP 13 (+=) <----------\n 78 STORE_NAME 1 (a)\n 80 JUMP_BACKWARD 8 (to 66)\n\nThis changes appears to come from this issue. The code of the main interpreter loop (see ceval.c) is different between the two CPython version. Here are the code executed by the two versions:\n // In CPython 3.10.8\n case TARGET(INPLACE_ADD): {\n PyObject *right = POP();\n PyObject *left = TOP();\n PyObject *sum;\n if (PyUnicode_CheckExact(left) && PyUnicode_CheckExact(right)) {\n sum = unicode_concatenate(tstate, left, right, f, next_instr); // <-----\n /* unicode_concatenate consumed the ref to left */\n }\n else {\n sum = PyNumber_InPlaceAdd(left, right);\n Py_DECREF(left);\n }\n Py_DECREF(right);\n SET_TOP(sum);\n if (sum == NULL)\n goto error;\n DISPATCH();\n }\n\n//----------------------------------------------------------------------------\n\n // In CPython 3.11.0\n TARGET(BINARY_OP_ADD_UNICODE) {\n assert(cframe.use_tracing == 0);\n PyObject *left = SECOND();\n PyObject *right = TOP();\n DEOPT_IF(!PyUnicode_CheckExact(left), BINARY_OP);\n DEOPT_IF(Py_TYPE(right) != Py_TYPE(left), BINARY_OP);\n STAT_INC(BINARY_OP, hit);\n PyObject *res = PyUnicode_Concat(left, right); // <-----\n STACK_SHRINK(1);\n SET_TOP(res);\n _Py_DECREF_SPECIALIZED(left, _PyUnicode_ExactDealloc);\n _Py_DECREF_SPECIALIZED(right, _PyUnicode_ExactDealloc);\n if (TOP() == NULL) {\n goto error;\n }\n JUMPBY(INLINE_CACHE_ENTRIES_BINARY_OP);\n DISPATCH();\n }\n\nNote that unicode_concatenate calls PyUnicode_Append (and do some reference counting checks before). In the end, CPython 3.10.8 calls PyUnicode_Append which is fast (in-place) and CPython 3.11.0 calls PyUnicode_Concat which is slow (out-of-place). It clearly looks like a regression to me.\nPeople in the comments reported having no performance issue on Linux. However, experimental tests shows a BINARY_OP instruction is also generated on Linux, and I cannot find so far any Linux-specific optimization regarding string concatenation. Thus, the difference between the platforms is pretty surprising.\n\nUpdate: towards a fix\nI have opened an issue about this available here. One should not that putting the code in a function is significantly faster due to the variable being local (as pointed out by @Dennis in the comments).\n\nRelated posts:\n\nHow slow is Python's string concatenation vs. str.join?\nPython string 'join' is faster (?) than '+', but what's wrong here?\nPython string concatenation in for-loop in-place?\n\n" ]

[ 16 ]

[]

[]

[ "optimization", "performance", "python", "python_3.10", "python_3.11" ]

[ "We need to make sure that all the configurations has been done which building python webapp.\nbelow are few key points where we need to look into:\n\nFor FlaskApp App service looks for App.py which has below content:\n\n\n If application.py\ngunicorn --bind=0.0.0.0 --timeout 600 application:app\n If app.py\ngunicorn --bind=0.0.0.0 --timeout 600 app:app\n\n\n\nCheck for customized build automations in MS Docs\n\nAlso below are few predefined configs which needs to be set, check them one by one based on your requirement:\n az group create -n <some_name> --location westus\n az appservice plan create --name <some_name> -g <some_name> --sku s1 --location westus --is-linux\n az webapp create -g <some_name> -n <some_globaly_unique_name> --plan <some_name> --runtime \"PYTHON|3.7\"\n az webapp config appsettings set -g <some_name> -n <some_globaly_unique_name> --settings WEBSITE_RUN_FROM_PACKAGE=\"1\"\n az webapp config appsettings set -g <some_name> -n <some_globaly_unique_name> --settings SCM_DO_BUILD_DURING_DEPLOYMENT=true\n az webapp restart -n <some_globaly_unique_name> -g <some_name>\n\n git clone https://github.com/Azure-Samples/python-docs-hello-world\n cd .\\python-docs-hello-world\\\n Compress-Archive -Path * -DestinationPath package.zip\n az webapp deployment source config-zip -n <some_globaly_unique_name> -g <some_name> --src .\\package.zip\n\nNote: Check for your current versions and replace them accordingly.\n", "For some reason, I had to manually create app-service from Azure Portal UI, as az webapp up -n <your-appservice> command didn't work. It deployed app successfully after creating it.\n", "Try running az account set -s <Subscription ID> first.\nEven if you already logged in with the Azure CLI, that still may not pick a subscription for billing. You have to set that first. This is what solved the problem for me. The selected answer did it through the web portal, which does pick a subscription for you.\n" ]

[ 1, 0, 0 ]

[]

[]

[ "azure", "azure_web_app_service", "python" ]

[ "We can get the performance up, without tracer(), by removing the intentional slowdowns (speed(5)) and drawing less precisely:\nfrom turtle import Screen, Turtle\n\nMESSAGE_FONT = ('Helvetica', 28, 'bold')\n\ndef write_inside_heart():\n turtle.penup()\n turtle.goto(0, 15)\n turtle.pencolor('white')\n turtle.write(\"Willst du meine Freundin sein?\", align='center', font=MESSAGE_FONT)\n\ndef draw_complete_heart():\n turtle.fillcolor('red')\n turtle.left(140)\n\n turtle.begin_fill()\n\n turtle.forward(297.5)\n draw_left_curve_of_heart()\n\n turtle.left(170)\n\n draw_right_curve_of_heart()\n turtle.forward(297.5)\n\n turtle.end_fill()\n\ndef draw_left_curve_of_heart():\n for _ in range(90):\n turtle.right(2.5)\n turtle.forward(6)\n\ndef draw_right_curve_of_heart():\n for _ in range(90):\n turtle.forward(6)\n turtle.right(2.5)\n\nscreen = Screen()\n\nturtle = Turtle()\nturtle.speed('fastest')\n\nturtle.penup()\nturtle.sety(-200)\nturtle.pendown()\n\ndraw_complete_heart()\nwrite_inside_heart()\n\nturtle.hideturtle()\nscreen.exitonclick()\n\nWe can do better speed-wise, and possibly recapture some precision, by using turtle's circle() method with an extent argument instead of drawing the arcs ourselves:\ndef draw_complete_heart():\n turtle.fillcolor('red')\n turtle.left(140)\n\n turtle.begin_fill()\n\n turtle.forward(288.8)\n turtle.circle(-135, extent=225)\n\n turtle.left(170)\n\n turtle.circle(-135, extent=225)\n turtle.forward(288.8)\n\n turtle.end_fill()\n\n" ]

[ 0 ]

[]

[]

[ "python", "python_turtle", "turtle_graphics" ]

[ "Have you tried decoding your string, and then combining your UTF-8 strings together? In Python 2.4+ (at least), this can be achieved with\nresult = [x.decode('utf8') for x in proc.stdout.readlines()]\n\nThe important point is that your lines x are sequences of bytes that must be interpreted as representing characters. The decode() method performs this interpretation (here, the bytes are assumed to be in the UTF-8 encoding): x.decode('utf8') is of type unicode, which you can think of as \"string of characters\" (which is different from \"string of numbers between 0 and 255 [bytes]\").\n", "I run into the same issue when using LogPipe. \nI solved this by specifying additional arguments encoding='utf-8', errors='ignore' to fdopen().\n# https://codereview.stackexchange.com/questions/6567/redirecting-subprocesses-output-stdout-and-stderr-to-the-logging-module\nclass LogPipe(threading.Thread):\n def __init__(self):\n \"\"\"Setup the object with a logger and a loglevel\n and start the thread\n \"\"\"\n threading.Thread.__init__(self)\n self.daemon = False\n # self.level = level\n self.fdRead, self.fdWrite = os.pipe()\n self.pipeReader = os.fdopen(self.fdRead, encoding='utf-8', errors='ignore') # set utf-8 encoding and just ignore illegal character\n self.start()\n\n def fileno(self):\n \"\"\"Return the write file descriptor of the pipe\n \"\"\"\n return self.fdWrite\n\n def run(self):\n \"\"\"Run the thread, logging everything.\n \"\"\"\n for line in iter(self.pipeReader.readline, ''):\n # vlogger.log(self.level, line.strip('\\n'))\n vlogger.debug(line.strip('\\n'))\n\n self.pipeReader.close()\n\n def close(self):\n \"\"\"Close the write end of the pipe.\n \"\"\"\n os.close(self.fdWrite)\n\n", "Short answer\nSet enviornment variable PYTHONIOENCODING, and set the encoding in Popen:\n#tst1.py\nimport subprocess\nimport sys, os\n\n#print(sys.stdout.encoding) #output: utf-8 this default for interactive console\nos.environ['PYTHONIOENCODING'] = 'utf-8'\np = subprocess.Popen(['python', 'tst2.py'], encoding='utf-8', stdout=subprocess.PIPE, stderr=subprocess.PIPE)\n#print(p.stdout) #output: <_io.TextIOWrapper name=3 encoding='utf-8'>\n#print(p.stdout.encoding, ' ', p.stderr.encoding) #ouput: utf-8 utf-8\nouts, errors = p.communicate()\nprint(outs, errors)\n\nwhere tst1.py, runs another python script tst2.py, like:\n#tst2.py\nimport sys\n\nprint(sys.stdout.encoding) #output: utf-8\nprint('\\u2e85') #a chinese char\n\nLong Answer\nUsing PIPE, indicates that a pipe to the standard stream should be opened. A pipe, is a unidirectional data channel that can be used for interprocess communication. Pipes deal with binary, and are agnostic to the encoding. Applications on each side of the pipe should have consensus on the text encoding , if it is text (read more).\nSo firstly, stdout of tst2.py should have utf-8 encoding, otherwise it raises error:\nUnicodeEncodeError: 'charmap' codec can't encode character '\\u2e85' in position 0: character maps to <undefined>\n\nThe streams sys.stdout and sys.stderr are regular text files like those returned by the open() function. On Windows, non-character devices such as pipes and disk files use the system locale encoding (i.e. an ANSI codepage like CP1252). Under all platforms, you can override the character encoding by setting the PYTHONIOENCODING environment variable before running the interpreter.\nSecondly, tst1.py should know how to read from pipe, thus the encoding='utf-8' in Popen.\nMore Details\nWith python 3.6+, following PEP 528, the default encoding of the interactive console in Windows is utf-8 (it can be changed by setting both PYTHONIOENCODING and PYTHONLEGACYWINDOWSSTDIO). But this does not apply to pipes and redirecting.\n" ]

[ 6, 1, 0 ]

[]

[]

[ "python" ]

[ "Why don't you just auto-scale the figsize argument?\nfrom math import ceil\n\nN=100\n\nfig, axs = plt.subplots( ncols=4, nrows=ceil(N/4), layout='constrained',\n figsize=(3.5 * 4, 3.5 * ceil(N/4)) )\n\nfor (i, var), ax in zip(enumerate(df.iloc[:,:N]), axs.flat):\n ax.set_title(var)\n ax.axis('equal')\n ax.plot(dfquantiles0.loc[:][var], dfquantiles0.loc[:][var])\n ax.plot(dfquantiles0.loc[:][var], dfquantiles1.loc[:][var])\n\nI slightly changed your plotting routine to be a bit more straight forward.\nYou might swap ceil(N/4) by -(-N//4) if you don't like importing from math.\n\n" ]

[ 1 ]

[]

[]

[ "autoresize", "matplotlib", "python" ]

[ "As others have stated, it's because of floating-point rounding errors.\nA standard workaround is to represent monetary amounts as integer numbers of the smallest unit (usually the cent) instead of as a float number of dollars/euros/pounds/whatever.\nHere's an alternative implementation of your function that uses integer arithmetic internally, and only uses float for the input and final output (dict keys).\nIt also specifies the denominations in a list “constant” instead of in the code. This lets you easily adapt it to other coinage systems, like the US dollar's [100, 25, 10, 5, 1]. (We technically have a half-dollar in circulation, but it's rarely used.)\n# Assuming you're using Euro coins here.\nDENOMINATIONS = [200, 100, 50, 20, 10, 5, 2, 1]\n\ndef change(money):\n res = {}\n cents = round(money * 100)\n for coin in DENOMINATIONS:\n parcel, cents = divmod(cents, coin)\n res[coin / 100] = parcel\n return res\n\nSample function call:\n>>> change(7.71)\n{2.0: 3, 1.0: 1, 0.5: 1, 0.2: 1, 0.1: 0, 0.05: 0, 0.02: 0, 0.01: 1}\n\n", "The problem is in float rounding. E. g. 0.71 - 0.5 = 0.20999999999999996.\nUse round function.\ndef change(money):\n res = {}\n coin = 2.0\n while coin>=0.01:\n parcel = money // coin\n res[coin] = int(parcel)\n print(parcel, money, coin, parcel*coin)\n money = round(money - parcel * coin, 2)\n if coin not in (0.5, 0.05):\n coin = coin/2\n else:\n if coin == 0.5:\n coin = 0.2\n else:\n coin = 0.02\n return res\n\nprint(change(7.71))\n\nResult\n{2.0: 3, 1.0: 1, 0.5: 1, 0.2: 1, 0.1: 0, 0.05: 0, 0.02: 0, 0.01: 1}\n\n" ]

[ 3, 0 ]

[]

[]

[ "dictionary", "floating_point", "function", "math", "python" ]

[ "It's possible that you're running two version of Python on your machine. Ex. a 2.7 and a 3.10. If you're on Windows, you can run the command py -0p to list all your python versions and their paths.\nIf you're looking to install pyperclip for a 3+ version of Python, you might want to use pip3 to install it.\n" ]

[ 0 ]

[]

[]

[ "python", "python_3.x" ]

[ "1. What do figure coordinates mean?\nFigure coordinates go 0 to 1, where (0,0) is the lower left corner and (1,1) is the upper right corner. A coordinate of y=1.05 is hence slightly outside the figure.\n\n2. what is the effect on figure size when specifying y to suptitle?\nSpecifying y to suptitle has no effect whatsoever on the figure size.\n3a. How do I manually adjust figure size and spacing to add a figure title per panel and a suptitle for the entire figure?\nFirst, one would not add an additional linebreak. I.e. if you want to have 2 lines, don't use 3 linebreaks (\\n). Then one can adjust the subplot parameters as desired to leave space for the titles. E.g. fig.subplots_adjust(top=0.8) and use a y <= 1 for the title to be inside the figure.\nimport matplotlib.pyplot as plt\nimport numpy as np\n\ndata = np.random.random(size=100)\nfig, axes = plt.subplots(2, 2, figsize=(10, 5))\nfig.subplots_adjust(top=0.8)\n\naxes[0,0].plot(data)\naxes[0,0].set_title(\"\\n\".join([\"this is a really long title\"]*2))\naxes[0,1].plot(data)\naxes[1,1].plot(data)\n\nfig.suptitle(\"\\n\".join([\"a big long suptitle that runs into the title\"]*2), y=0.98)\n\nplt.show()\n\n\n3b. ... while maintaining the size of each ax in the figure?\nMaintaining the size of the axes and still have enough space for the titles is only possible by changing the overall figure size.\nThis could look as follows, where we define a function make_space_above which takes the array of axes as input, as well as the newly desired top margin in units of inches. So for example, you come to the conclusion that you need 1 inch of margin on top to host your titles:\nimport matplotlib.pyplot as plt\nimport numpy as np\n\ndata = np.random.random(size=100)\nfig, axes = plt.subplots(2, 2, figsize=(10, 5), squeeze = False)\n\naxes[0,0].plot(data)\naxes[0,0].set_title(\"\\n\".join([\"this is a really long title\"]*2))\naxes[0,1].plot(data)\naxes[1,1].plot(data)\n\nfig.suptitle(\"\\n\".join([\"a big long suptitle that runs into the title\"]*2), y=0.98)\n\n\ndef make_space_above(axes, topmargin=1):\n \"\"\" increase figure size to make topmargin (in inches) space for \n titles, without changing the axes sizes\"\"\"\n fig = axes.flatten()[0].figure\n s = fig.subplotpars\n w, h = fig.get_size_inches()\n\n figh = h - (1-s.top)*h + topmargin\n fig.subplots_adjust(bottom=s.bottom*h/figh, top=1-topmargin/figh)\n fig.set_figheight(figh)\n\n\nmake_space_above(axes, topmargin=1) \n\nplt.show()\n\n\n(left: without calling make_space_above; right: with call to make_space_above(axes, topmargin=1))\n", "Short Answer\nFor those coming from Google for adjusting the title position on a scatter matrix, you can simply set the y parameter to a value slightly lower than 1:\nplt.suptitle('My Title', y=0.92)\n", "... or use constrained_layout:\nimport matplotlib.pyplot as plt\nimport numpy as np\n\ndata = np.random.random(size=100)\nf, a = plt.subplots(2, 2, figsize=(10, 5), constrained_layout=True)\n\na[0,0].plot(data)\na[0,0].set_title(\"this is a really long title\\n\"*2)\na[0,1].plot(data)\na[1,1].plot(data)\n\nplt.suptitle(\"a big long suptitle that runs into the title\\n\"*2);\n\n\n", "A bit of a hacky solution, but if your plots only have 1 column, perhaps consider just add the main title to the title of the first plot, like so:\nax[0].set_title(\"Main Title\\\n\n" ]

[ 93, 53, 12, 0 ]

[]

[]

[ "matplotlib", "python" ]

[ "This can be formulated as a Minimum Cost Maximum Flow Problem.\nStart with a sink. It connects to the tasks along channels of cost 0 and flow 1. Each task connects to the agents along channels of costs from your matrix and flow 1. Each agent connects to the sink with a channel of flow 1 and cost 0. Agents are also connected to a pool with channels of flow M-N and high cost. And the pool is connected to the sink with a channel of flow M-N and similarly high cost.\nThe maximum flow with minimum cost will have a flow of M from the source to the tasks. It will then have a flow of M from the source to the agents. A flow of N will take the cheap and narrow pipes to the sink directly from the agents. And the remaining M-N will take the expensive route to the pool, and from the pool to the sink. Because the flow from agents to pool and back again is expensive, there will be only a minimum of flow to the pool, and no flow from the pool back to the agents.\nTherefore the maximum flow will be an answer to your problem with each agent getting the flow from at least one task.\n", "Here is a simple optimization model:\n# sets\ni : tasks\nj : agents\n\n# model\nmin sum((i,j), c[i,j]*x[i,j])\nsum(j, x[i,j]) = 1 ∀i \"assign each task to an agent\"\nsum(i, x[i,j]) >= 1 ∀j \"each agent needs to do at least one task\"\nx[i,j] ∈ {0,1}\n\nThese models tend to solve very easily.\nHere is a small test script:\nimport cvxpy as cp\nimport numpy as np\n\nNTASK = 1000\nNAGENT = 200\n\n# random data\nnp.random.seed(123)\nc = np.random.uniform(1,100,(NTASK,NAGENT))\n\n# model\nx = cp.Variable((NTASK,NAGENT),boolean=True)\nprob = cp.Problem(cp.Minimize(cp.sum(cp.multiply(c,x))),\n [cp.sum(x,axis=1) == 1, \n cp.sum(x,axis=0) >= 1])\n\n# solve and print results\nres = prob.solve(verbose=True)\nprint(prob.status)\nprint(prob.value)\n# print(x.value) \n\nIf you prefer, this model can be solved as an LP by relaxing the x variable to x[i,j] ∈ [0,1].\n" ]

[ 3, 2 ]

[]

[]

[ "algorithm", "computer_science", "optimization", "python" ]

[ "I was able to implement this by creating a TouchHandler widget:\nclass TouchHandler(Widget):\n \"\"\" Non-display widget to handle touch order \"\"\"\n instance = None\n\n def __init__(self):\n super().__init__()\n TouchHandler.instance = self\n self.active = None\n\nThen overriding Window's on_motion method prior to calling MyApp().run():\nif __name__ == '__main__':\n # Ignore new touches before first touch has resolved\n TouchHandler()\n def on_motion(self, etype, me):\n if 'pos' in me.profile:\n if etype == 'begin':\n if not TouchHandler.instance.active:\n TouchHandler.instance.active = me\n\n Window.bind(on_motion=on_motion)\n\n Window.size = (500,500)\n MyApp().run()\n\nFor this to work, you need to manage your touch events very carefully and reset TouchHandler.instance.active to None when you're done with the touch in the on_touch_up method for any widget that will use the touch:\ndef on_touch_up(self, touch):\n if touch != TouchHandler.instance.active:\n return True # Signals Kivy to kill the event\n piece = touch.ud['piece']\n if piece:\n # ...\n self.update_geometry()\n TouchHandler.instance.active = None\n\n", "This is an answer, but I'm kind of afraid of it, I'm pretty sure it's bad programming practice but:\nI created a global variable with touch_counter = 0, then in on_touch_down I referenced the global variable and then += 1 it, and in on_touch_up I -= 1 it. In on_touch_move I check if the touch_counter == 1 and then performed what I wanted it to do with only one touch.\nThis works with multitouch_sim, I realize this might mess up with actually multitouch devices, but so far so good.\n" ]

[ 0, 0 ]

[]

[]

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

[ "As mentioned above this question has many answers. Taking just 1 date as an example:\nts = pd.to_datetime('01oct2012') produces the timestamp:\nTimestamp('2012-10-01 00:00:00')\nTo convert to the desired format:\nts.strftime('%d-%m-%Y') \n\nyields:\n'01-10-2012'\n" ]

[ 0 ]

[]

[]

[ "pandas", "python" ]

[ "You can start debugging from the visual studio code as shown here and deployment sample with score.py.\n%%writefile source_directory/x/y/score.py\nimport joblib\nimport json\nimport numpy as np\nimport os\n\nfrom inference_schema.schema_decorators import input_schema, output_schema\nfrom inference_schema.parameter_types.numpy_parameter_type import NumpyParameterType\n\ndef init():\n global model\n # AZUREML_MODEL_DIR is an environment variable created during deployment. Join this path with the filename of the model file.\n # It holds the path to the directory that contains the deployed model (./azureml-models/$MODEL_NAME/$VERSION)\n # If there are multiple models, this value is the path to the directory containing all deployed models (./azureml-models)\n model_path = os.path.join(os.getenv('AZUREML_MODEL_DIR'), 'sklearn_regression_model.pkl')\n # Deserialize the model file back into a sklearn model.\n model = joblib.load(model_path)\n\n global name\n # Note here, the entire source directory from inference config gets added into image.\n # Below is an example of how you can use any extra files in image.\n with open('./source_directory/extradata.json') as json_file:\n data = json.load(json_file)\n name = data[\"people\"][0][\"name\"]\n\ninput_sample = np.array([[10.0, 9.0, 8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0]])\noutput_sample = np.array([3726.995])\n\n@input_schema('data', NumpyParameterType(input_sample))\n@output_schema(NumpyParameterType(output_sample))\ndef run(data):\n try:\n result = model.predict(data)\n # You can return any JSON-serializable object.\n return \"Hello \" + name + \" here is your result = \" + str(result)\n except Exception as e:\n error = str(e)\n return error\n\n" ]

[ 0 ]

[]

[]

[ "azure_machine_learning_service", "azure_machine_learning_studio", "azure_machine_learning_workbench", "python", "scoring" ]

[ "universal_newlines=True enables text mode. Combined with stdout=PIPE, it forces decoding of the child process' output using locale.getpreferredencoding(False) that is not utf-8 on Windows. That is why you see UnicodeDecodeError.\nTo read the subprocess' output using utf-8 encoding, drop universal_newlines=True:\n#!/usr/bin/env python3\nfrom subprocess import Popen, PIPE\n\nwith Popen(r'C:\\path\\to\\program.exe \"arg 1\" \"arg 2\"',\n stdout=PIPE, stderr=PIPE) as p:\n output, errors = p.communicate()\nlines = output.decode('utf-8').splitlines()\n\n\nstr.encode(\"utf-8\") is equivalent to \"utf-8\".encode(). There is no point to pass it to .communicate() unless you set stdin=PIPE and the child process expects b'utf-8' bytestring as an input.\nstr.encode(encoding=\"utf-8\", errors=\"ignore) has the form klass.method(**kwargs). .encode() method expects self (a string object) that is why you see TypeError.\n>>> str.encode(\"abc\", encoding=\"utf-8\", errors=\"ignore\") #XXX don't do it\nb'abc'\n>>> \"abc\".encode(encoding=\"utf-8\", errors=\"ignore\")\nb'abc'\n\nDo not use klass.method(obj) instead of obj.method() without a good reason.\n", "You are not supposed to call .encode() on the class itself. What you probably want to do is something like\np1.communicate(\"FOOBAR\".encode(\"utf-8\"))\n\nThe error message you're getting means that the encode() function has nothing to encode, since you called it on the class, rather than on an instance (that would then be passed as the self parameter to encode()).\n", "If using Popen to run another Python script, then see my answer.\nThe short answer is set the enviornment variable PYTHONIOENCODING, and set encoding='utf-8' in Popen.\n" ]

[ 22, 2, 0 ]

[]

[]

[ "encoding", "popen", "python", "python_3.x", "subprocess" ]

[ "Solution: the first dimension of each tensorflow dataset element is supposed to be the batch_size. To do this all you have to do is slightly modify the df_to_dataset method:\n# A utility method to create a tf.data dataset from a Pandas Dataframe\ndef df_to_dataset(df, batch_size=32):\n y = df.pop('is_promoted')\n ds = tf.data.Dataset.from_tensor_slices((dict(df), y))\n ds = ds.batch(batch_size)\n return ds\n\nAlso a '?' cannot be in the name of any of your columns since this is incompatible with tf datasets. You can change the name of this column with the pd.rename() method.\n" ]

[ 0 ]

[]

[]

[ "pandas", "python", "scikit_learn", "tensorflow" ]

[ "The error in the reasoning comes from this part:\n\nAs a sanity check, I've ensured that v_i and v_j are indeed eigenvectors of op, which means they are correct, and which means they should be orthogonal.\n\nIf v_i and v_j are associated to the same eigenvalue lambda, then (v_i+v_j)/sqrt(2) is an eigenvector associated to lambda and which isn't orthogonal to v_i or v_j.\nIn order to ensure that the eigenvectors are orthogonal, simply perform:\neigvecs = np.linalg.qr(eigvecs)[0]\n\neigvecs will now contain orthonormal eigenvectors of op.\n" ]

[ 2 ]

[]

[]

[ "linear_algebra", "numpy", "python" ]

[ "You are passing a function that returns Optional[int] but a function is required that returns SupportsLessThan. Optional[int] does not support \"less than\", because None cannot be compared to any int.\nWhat does support \"less than\" is just int. So you could change the return type of your function to int and make it return some integer in the special case that r is not a Colour, instead of None.\nWhich integer it should return in this case depends on what you are trying to achieve. Possibly you could return -1 in case you want any non-Colour values to be sorted before any Colour values, since that would be smaller than any value of r.index (at least that's what I expect from something called \"index\").\n" ]

[ 2 ]

[]

[]

[ "python", "python_3.x", "sorting", "typing" ]

[ "from collections import Counter\nCounter(df['Wafer'])\n\nTo plot the dict result, the follwing link is helpful https://stackoverflow.com/a/52572237/16353662.\n" ]

[ 0 ]

[]

[]

[ "dataframe", "google_colaboratory", "python" ]

[ "you could use either None or np.nan to create an array of just missing values in Python like so:\nnp.full(shape=5, fill_value=None)\nnp.full(shape=5, fill_value=np.nan)\n\nback to your example, this works just fine:\nimport numpy as np\nimport pandas as pd\n\nunknowns = np.full(shape=5, fill_value=None)\ncategories = np.random.choice(['web', 'software', 'hardware', 'biotech'], size = 15, replace = True)\ncategories = np.concatenate([categories, unknowns])\nexample = pd.DataFrame(data = {'categories': categories})\nexample['transformed'] = [ x if pd.isna(x) == False else 'unknown' for x in example['categories']]\n\nprint(example['transformed'].value_counts())\n\nLastly, this line is inefficient.\nexample['transformed'] = [ x if pd.isna(x) == False else 'unknown' for x in example['categories']]\nYou do want to avoid loops & list comprehensions when using pandas\non large data, this is going to run much faster:\nexample['transformed'] = example.categories.apply(lambda s: s if s else 'unknown')\n", "There is a typing problem here.\nIf you're working in numpy, vectors are typed after being initialized. Assigning a np.nan value to a vector initialized with strings will try to coalesce back into a string:\nimport numpy as np\n\nv1 = np.array(['a', 'b', 'c'])\nv1[0] = np.nan\n# v1 = array(['n', 'b', 'c'], dtype='<U1')\n\nv2 = np.array(['ab', 'cd', 'ef'])\nv2[0] = np.nan\n# v2 = array(['na', 'cd', 'ef'], dtype='<U2')\n\nv3 = np.array(['abc', 'def', 'ghi'])\nv3[0] = np.nan\n# v3 = array(['nan', 'def', 'ghi'], dtype='<U3')\n\nHowever, if you're working with pandas in the second half of the question, there's a separate way for handling missing data:\nimport pandas as pd\n\ndf = pd.DataFrame({\"x\": [pd.NA, \"Hello\", \"World\"]})\n\n", "A simple way to create an empty Series in pandas:\ns = pd.Series(index=range(15))\n\nOutput:\n0 NaN\n1 NaN\n2 NaN\n3 NaN\n4 NaN\n5 NaN\n6 NaN\n7 NaN\n8 NaN\n9 NaN\n10 NaN\n11 NaN\n12 NaN\n13 NaN\n14 NaN\ndtype: float64\n\nOr, with a string dtype:\ns = pd.Series(index=range(15), dtype='string')\n\nOutput:\n0 <NA>\n1 <NA>\n2 <NA>\n3 <NA>\n4 <NA>\n5 <NA>\n6 <NA>\n7 <NA>\n8 <NA>\n9 <NA>\n10 <NA>\n11 <NA>\n12 <NA>\n13 <NA>\n14 <NA>\ndtype: string\n\n" ]

[ 2, 0, 0 ]

[]

[]

[ "numpy", "python" ]

[ "Can you please try by replacing from this:\n # Bets\n while play_again == 'Y':\n while end_game == False:\n while funds > 0:\n while bet == 0:\n bet = int(input('Enter bet amount: '))\n\n if bet > funds:\n print('Insufficient funds')\n bet = 0\n\nWith\n # Bets\n while play_again == 'Y':\n while end_game == False:\n if play_again != 'Y':\n break\n while funds > 0:\n if play_again != 'Y' or end_game:\n break\n while bet == 0:\n bet = int(input('Enter bet amount: '))\n\n if bet > funds:\n print('Insufficient funds')\n bet = 0\n\n\nI believe we don't even need to add end_game as it is unnecessary in current scope.\nThese are nested while loop and parent while loop will not break until child breaks. so we need to add extra condition in child while loop which break it on the basis of parent check.\nyou can read this post 5 Ways To Break Out of Nested Loops in Python\n", "So the issue (to Usman's point) really comes from the nesting levels. Basically for the below logic, it will only check if play_again is still True once end_game is False, which it will only check once funds is no longer > 0.\nwhile play_again == 'Y':\n while end_game == False:\n while funds > 0:\n while bet == 0:\n ...\n play_again = input(\"Play again?\")\n\nYour code would actually work fine if you had the proper indentation (end of loop being within the \"play_again\" or \"end_game\" levels), but unless there's a really good reason, it's typically better to combine conditionals rather than nesting them in multiple while loops that are easy to lose track of. Consider instead:\nwhile (play_again == \"Y\") and (funds > 0):\n if bet == 0:\n bet = int(input('Enter bet amount: '))\n if bet < self.funds:\n print(\"Insufficient funds\")\n ...\n\nOther Notes\nBased on the coding style it seems like you're at the start of your wonderful journey into Python, and I wanted to pay forward the help I got starting out by giving some (hopefully) useful tips in case this wasn't part of a structured course. I wound up slapping together an MVP for how this might look below (can build further), please read through the notes though additionally:\n\nBreak apart large functions! It'll make your life a lot easier, this looks to be maybe an initial project and you get a better knack for where to break things up as you move along, but a single function being ~300 lines is just going to make you miserable. General rule of thumb to have maybe 40-50 lines max unless there's a really good reason.\nUtilize classes more (especially if you're trying to be OOP!), a \"BlackjackGame\" class could help keep methods and attributes organized vs having to set them only once per iteration, and helps keep track of variables across games (i.e. total value).\nType hinting to make your life easier. Depending on where you are in your learning path this might be a bit later on, but it makes things infinitely easier for working with Intellisense hints (see below using Pylance in VSCode). You could also just create a Deck class itself.\n\n\nSample\nimport itertools\nimport random\nimport os\nfrom typing import List, Literal\n\ndef clear():\n os.system(\"clear\")\n\nclass BlackjackRound:\n def __init__(self, deck):\n self.player_hand: Hand = Hand()\n self.dealer_hand: Hand = Hand()\n self.deck: List[Card] = deck\n \n ## Draw top cards\n for hand in [self.player_hand, self.dealer_hand]:\n for _ in range(2):\n self.deck = hand.draw(self.deck)\n \n self._print_stats()\n while self.player_hand.value < 21:\n choice = input(\"Enter H to Hit or S to Stand : \")\n if len(choice) != 1 or (choice.upper() != 'H' and choice.upper() != 'S'):\n clear()\n print(\"Wrong choice!! Try Again\")\n continue\n if choice.upper() == 'H':\n self.deck = self.player_hand.draw(self.deck)\n if choice.upper() == 'S':\n break\n self._print_stats()\n ## Resolve Dealer Hand\n self._print_stats(mask_dealer=False)\n while self.dealer_hand.value < 17:\n print(\"Dealer draws...\")\n self.deck = self.dealer_hand.draw(self.deck)\n self._print_stats(mask_dealer=False)\n ##For dramatic tension\n if self.dealer_hand.value < 17:\n input(\"Enter to continue...\")\n\n def _print_stats(self, mask_dealer=True):\n print(\"You're hand\")\n self.player_hand.print_cards()\n print(f\"PLAYER SCORE = {self.player_hand.value}\")\n\n print(\"Dealer showing...\")\n if mask_dealer:\n self.dealer_hand.print_cards(hidden=True, n_cards=1)\n print(f\"DEALER SCORE = {self.dealer_hand.cards[0].card_value}\")\n else:\n self.dealer_hand.print_cards()\n print(f\"DEALER SCORE = {self.dealer_hand.value}\")\n\n\n# The Card class definition\nclass Card:\n def __init__(self, suit, value, card_value, suit_format): \n # Suit of the Card like Spades and Clubs\n self.suit = suit\n # Representing Value of the Card like A for Ace, K for King\n self.value = value\n # Score Value for the Card like 10 for King\n self.card_value = card_value\n self.suit_format = suit_format\n #How should Card be printed?\n def __repr__(self):\n return str(self.__dict__)\n\nclass Hand:\n def __init__(self):\n self.cards: List[Card] = []\n self.value = 0\n \n def draw(self, deck: List[Card]):\n player_card = random.choice(deck)\n self.cards.append(player_card)\n deck.remove(player_card)\n self.value += player_card.card_value\n self.revalue_ace()\n return deck\n \n def revalue_ace(self):\n ##Sum greater than 21, \n if (self.value > 21) and (\"A\" in [card.value for card in self.cards]):\n swap_card = list(filter(lambda x: x.value == \"A\", self.cards))[0]\n self.cards[self.cards.index(swap_card)].card_value = 1\n self.value-=10\n else:\n pass\n \n def print_cards(self, hidden: bool=False, n_cards=None):\n s = \"\"\n cards = self.cards if n_cards is None else self.cards[0:n_cards]\n for card in cards:\n s = s + \"\\t ________________\"\n if hidden:\n s += \"\\t ________________\"\n print(s)\n \n \n s = \"\"\n for card in cards:\n s = s + \"\\t| |\"\n if hidden:\n s += \"\\t| |\" \n print(s)\n \n s = \"\"\n for card in cards:\n if card.value == '10':\n s = s + \"\\t| {} |\".format(card.value)\n else:\n s = s + \"\\t| {} |\".format(card.value) \n if hidden:\n s += \"\\t| |\" \n print(s)\n \n s = \"\"\n for card in cards:\n s = s + \"\\t| |\"\n if hidden:\n s += \"\\t| * * |\"\n print(s) \n \n s = \"\"\n for card in cards:\n s = s + \"\\t| |\"\n if hidden:\n s += \"\\t| * * |\"\n print(s) \n \n s = \"\"\n for card in cards:\n s = s + \"\\t| |\"\n if hidden:\n s += \"\\t| * * |\"\n print(s) \n \n s = \"\"\n for card in cards:\n s = s + \"\\t| |\"\n if hidden:\n s += \"\\t| * * |\"\n print(s) \n \n s = \"\"\n for card in cards:\n s = s + \"\\t| {} |\".format(card.suit_format)\n if hidden:\n s += \"\\t| * |\"\n print(s) \n \n s = \"\"\n for card in cards:\n s = s + \"\\t| |\"\n if hidden:\n s += \"\\t| * |\"\n print(s) \n \n s = \"\"\n for card in cards:\n s = s + \"\\t| |\"\n if hidden:\n s += \"\\t| * |\"\n print(s)\n \n s = \"\"\n for card in cards:\n s = s + \"\\t| |\"\n if hidden:\n s += \"\\t| |\"\n print(s)\n \n s = \"\"\n for card in cards:\n s = s + \"\\t| |\"\n if hidden:\n s += \"\\t| |\"\n print(s) \n \n s = \"\"\n for card in cards:\n if card.value == '10':\n s = s + \"\\t| {} |\".format(card.value)\n else:\n s = s + \"\\t| {} |\".format(card.value)\n if hidden:\n s += \"\\t| * |\" \n print(s) \n \n s = \"\"\n for card in cards:\n s = s + \"\\t|________________|\"\n if hidden:\n s += \"\\t|________________|\"\n print(s) \n \n print()\n \n\n\nclass BlackjackGame:\n def __init__(self):\n ##play_again can only be Y/N\n self.play_again: Literal[\"Y\", \"N\"] = \"Y\"\n self.player_name: str = input(\"Player name?: \")\n self.funds = 100\n self.wins = 0\n self.losses = 0\n self.ties = 0\n self.blackjacks = 0\n self.busts = 0\n \n def _print_stats(self):\n print(f\"Current funds: {self.funds}\")\n def play_game(self):\n self._print_stats\n self.shuffle_deck()\n bet = 0\n while (self.play_again == \"Y\") and (self.funds > 0):\n if bet == 0:\n bet = int(input('Enter bet amount: '))\n if bet < self.funds:\n print(\"Insufficient funds\")\n continue #Restart at the top of the key\n round = BlackjackRound(self.deck)\n if round.player_hand.value == 21:\n print(\"Blackjack!\")\n self.blackjacks+=1\n self.funds+=bet\n elif round.player_hand.value > 21:\n print(\"BUST\")\n self.busts+=1\n self.funds-=bet\n elif round.dealer_hand.value > 21:\n print(\"DEALER BUST!\")\n self.wins +=1\n self.funds+=bet\n elif round.player_hand.value > round.dealer_hand.value:\n print(\"Win!\")\n self.wins+=1\n self.funds+=bet\n elif round.player_hand.value < round.dealer_hand.value:\n print(\"Lose!\")\n self.losses+=1\n self.funds-=bet\n else:\n print(\"Tie!\")\n self.ties+=1\n ## Error handling for exit\n bet=0\n ##Update deck from round\n self.deck = round.deck\n while True:\n self.play_again = input('Play again(Y/N)?: ')\n if self.play_again == \"N\":\n print(\"So long!\")\n quit()\n elif self.funds == 0:\n print(\"Too bad, you're broke!\")\n quit()\n elif self.play_again == \"Y\":\n print(\"Around we go!\")\n print(\"Try again plz\")\n \n def shuffle_deck(self,\n suits = {\"Spades\":\"\\u2664\", \"Hearts\":\"\\u2661\", \"Clubs\": \"\\u2667\", \"Diamonds\": \"\\u2662\"},\n cards = {\"A\": 11, \"2\":2, \"3\":3, \"4\":4, \"5\":5, \"6\":6, \"7\":7, \"8\":8, \"9\":9, \"10\":10, \"J\":10, \"Q\":10, \"K\":10}\n ):\n \"\"\"\n Create a deck of 52 cards\n \"\"\"\n self.deck = [Card(combo[0], combo[1], cards[combo[1]], suits[combo[0]]) for combo in itertools.product(suits.keys(), cards.keys())]\n\n\n \nif __name__ == '__main__':\n bg = BlackjackGame()\n bg.play_game()\n\n" ]

[ 0, 0 ]

[]

[]

[ "blackjack", "oop", "python" ]

[ "You get the mentioned problem as you are trying to add an object into the fish array which is a nested array (aquarium is also an array).\nYou need $ operator after aquarium. Aims to update the first matched aquarium array.\n\nMongoDB query\n\ndb.collection.update({\n \"_id\": ObjectId(\"5a934e000102030405000000\"),\n \"aquarium.name\": \"Aqua A\"\n},\n{\n \"$push\": {\n \"aquarium.$.fish\": {\n name: \"Tortoise\",\n color: \"Green\"\n }\n }\n})\n\nDemo @ Mongo Playground\nusers_db.find_one_and_update\n (\n {\n \"_id\": ObjectId(str(id)),\n \"aquarium.name\": aquarium_name\n }, \n {\n \"$push\": {\"aquarium.$.fish\": obj}\n }\n )\n\n" ]

[ 1 ]

[]

[]

[ "mongodb", "pymongo", "python", "rest" ]

[ "Like yourself, running Windows 10 64-bit, using a sufficiently up to date copy of Python 3.9 (I'm using 3.9.13), if I do the following:\nvirtualenv test_env\ntestenv\\Scripts\\activate\npip install pandas\npip install darts\n\nThis installs a large number of dependencies for darts and takes several minutes to complete, without errors or warnings.\nThe installed version of pandas after this is 1.5.2 and the installed version of darts is 0.22.0. (it's unclear why yours would be 0.16.0)\nI can then run the following using Python:\nfrom darts import TimeSeries, concatenate\n\nAnd I get no error message. The error you're reporting cannot be reproduced using current and up to date versions of the packages you mentioned.\nWhy exactly do you have a reliance upon darts version 0.16.0 specifically?\n" ]

[ 0 ]

[]

[]

[ "libraries", "python" ]

[ "This solution uses the groupby method to find rows which share job and eligible values. Subgroups which share the same year are then identified. A random index is selected to choose the ID to assign for the paired_ID.\nimport numpy as np\nimport pandas as pd\n\ndf = pd.DataFrame(columns=['ID', 'job', 'eligible', \"date\"])\ndf['ID'] = ['1', '2', '3', '4', '5', '6', '7', '8']\ndf['job'] = ['waitress', 'doctor', 'benevolent', 'nurse', 'hairstylist', 'banker', 'waitress', 'waitress']\ndf['eligible'] = ['No', 'Yes', 'No', 'Yes', 'No', 'No', 'No', 'No']\ndf['date'] = ['1.1.2016', '31.12.2015', '1.1.2016', '31.12.2015', '1.1.2016', '31.12.2015', '1.1.2015', '1.1.2015']\n\ndf[\"date\"] = pd.to_datetime(df[\"date\"])\n\n# Add column\ndf['paired_ID'] = None\n\nfor _, matches in df.groupby(['job', 'eligible']):\n if (len(matches) > 1):\n year_groups = matches.groupby(by=matches['date'].dt.year)\n if (len(year_groups) > 1):\n years = tuple(year_groups.groups.keys())\n for y in years:\n pair_y = np.random.choice(tuple([x for x in years if x != y]))\n for index in year_groups.groups[y]:\n paired_index = np.random.choice(year_groups.groups[pair_y])\n paired_ID = int(df['ID'].iloc[paired_index])\n df['paired_ID'].iloc[index] = paired_ID\n\n" ]

[ 0 ]

[]

[]

[ "pandas", "python" ]

[ "Function winsorize may work, to some extent, if you can specify the percentages to cut on each side of the vector.\nOr, you can use the user-defined function as follows with iif:\ndef clip(x,minValue,maxValue): iif(x>maxValue,maxValue,iif(x<minValue,minValue,x))\nin = [1, 2, 3, 4, 5, 6, 7, 8 ] \nclip(in,2,6)\n\nOutput:\noffset 0 1 2 3 4 5 6 7\n0 2 2 3 4 5 6 6 6\n\n" ]

[ 0 ]

[]

[]

[ "dolphindb", "numpy", "python" ]

[ "I think it doesn't like that you use both type as index and value. A workaround would be to use a dummy column:\ntable_1 = pd.pivot_table(df1.assign(val=1), \n values='val', index=['brand','type'],\n columns=['Year','Month'], aggfunc={'val':len},\n fill_value=0, margins=True)\n\nprint(table_1)\n\nOutput:\nYear 2022 All\nMonth 8 9 10 \nbrand type \nA C 1 5 2 8\n D 1 0 0 1\nB C 0 3 0 3\n D 0 0 1 1\nAll 2 8 3 13\n\nNB. Use fill_value=0 to avoid having an object dtype.\n" ]

[ 1 ]

[]

[]

[ "margins", "pandas", "pivot_table", "python" ]

[ "I think you must save the form's content actually:\nform.save()\n\n" ]

[ 0 ]

[]

[]

[ "django", "django_views", "pandas", "python" ]

[ "Based on the information you have provided, you should try setting the column names with df.columns = ['column name 1', 'column name 2'] and so on before you export. If that answer does not help, could you provide some of the data and commands you are putting in along with the output you are getting? That could be helpful in resolving this.\n" ]

[ 0 ]

[]

[]

[ "pandas", "python" ]

[ "The solution is given in the link you pasted.\nSometimes on Windows, the installation works, but importing Parselmouth fails with an error message saying . This error is cause by some missing system files, but can luckily be solved quite easily by installing the “Microsoft Visual C++ Redistributable for Visual Studio 2017”.\nFor a 64-bit Python installation: https://aka.ms/vs/16/release/VC_redist.x64.exe\nFor a 32-bit Python installation: https://aka.ms/vs/16/release/VC_redist.x86.exe\n" ]

[ 0 ]

[]

[]

[ "python", "visual_studio_code" ]

[ "\"Artist\" is a term from matplotlib:\nhttps://matplotlib.org/stable/tutorials/intermediate/artists.html\nPresumably the error message means that there are no items in the legend whose font size can be changed.\nMaybe pass the fontsize argument to the same plt.legend call in which you create the legend, or call plt.legend(fontsize=...) after you have created the legend.\n" ]

[ 1 ]

[]

[]

[ "legend", "matplotlib", "python" ]

[ "The first error that I got was this:\nPatsyError: numbers besides '0' and '1' are only allowed with **\nTemp ~ MEI+ CO2+ CH4+ N2O+ CFC-11+ CFC-12+ TSI+ Aerosols\n ^^\n\nAccording to this link: http://patsy.readthedocs.io/en/latest/builtins-reference.html#patsy.builtins.Q\nyou can use Q(\"var\") in the formula to get rid of the error. I was getting the same error but it was solved.\nlinMod = smf.ols('Temp ~ MEI+ CO2+ CH4+ N2O+ Q(\"CFC-11\")+ Q(\"CFC-12\")+ TSI+ Aerosols',data = trainingSet).fit()\n\nthis is the solved line of code. I had tried\nlinMod = smf.ols('Temp ~ MEI+ CO2+ CH4+ N2O+ Q(\"CFC-11 + CFC-12\")+ TSI+ Aerosols',data = trainingSet).fit()\n\nbut this did not work. It seems that when using formula, the numbers and variables happen to have certain meaning that does not let the use of certain names. in my case error was:\nPatsyError: Error evaluating factor: NameError: no data named 'CFC-11+ CFC-12' found\nTemp ~ MEI+ CO2+ CH4+ N2O+ Q(\"CFC-11+ CFC-12\")+ TSI+ Aerosols\n ^^^^^^^^^^^^^^^^^^^\n\n", "patsy is handling the formula parsing and is parsing the string and interpreting it as formula with the given syntax. So some elements in the string are not allowed because they are part of the formula syntax. To keep them as names, patsy also has a code for taking the names as literal text Q which should work in this case\nhttp://patsy.readthedocs.io/en/latest/builtins-reference.html#patsy.builtins.Q\nOtherwise, if you already have the full design matrix with all the dummy variables, then there is no reason to go through the formula interface. Using the direct interface with pandas DataFrames or numpy arrays:\nsm.OLS(y, x) \nwill ignore any names of DataFrame columns except for using it as strings in the summary table. \nVariable/column names are also used as one way of defining restrictions for t_test but those go also through patsy and I am not sure it works with special characters in the names.\n", "Error: Temp ~ MEI+ CO2+ CH4+ N2O+ Q(\"CFC-11+ CFC-12\")+ TSI+ Aerosols\nAnswer: Temp ~ MEI+ CO2+ CH4+ N2O+ CFC_11+ CFC_12+ TSI+ Aerosols.\nYou need to remove the symbols like minus or hyphen ('-'), small brackets from the column names. In this way you can solve the problem.\n df = pd.read_csv(filepath)\n col = []\n for i in df.columns:\n i = i.replace('-','_')\n i = i.replace('(','_')\n i = i.replace(')','_')\n col.append(i)\n df.columns = columns\n\n" ]

[ 8, 2, 0 ]

[]

[]

[ "linear_regression", "python", "statsmodels" ]

[ "The compiled-in module names are in sys.builtin_module_names. For all importable modules, see pkgutil.iter_modules.\nRun these in a clean virtualenv to get (almost) only the modules that come with Python itself.\n\nNote that a “popularity poll” will necessarily include modules that use old, discouraged naming conventions because they were written before today's guidelines were put in place, and can't change because need to be backwards compatible. It might be useful for something, but not for answering best-practice questions such as “How should I name my functions?”. For that, see the PEP8, the Python style guide, especially the “Naming Conventions” section.\n", "How about this? Though, this gets a list of built-in functions and variables rather than modules...\ndir(__builtins__)\n\nhelp('modules') will give you a list of all modules, according to How can I get a list of locally installed Python modules?. Not a list of strings, though.\n", "Now there is a 3rd party package for this. It scrapes the TOC of the Standard Library page in the official Python docs and builds a list.\nYou can install it using pip\npip install stdlib_list\n\nand got get a list of libraries\nIn [12]: from stdlib_list import stdlib_list\n\nIn [13]: libraries = stdlib_list(\"3.5\")\n\nIn [14]: libraries[4:12]\nOut[14]: ['abc', 'aifc', 'argparse', 'array', 'ast', 'asynchat', 'asyncio', 'asyncore']\n\nYou can find source code here.\n", ">>>dir (__builtins__)\nor\n>>>help (__builtins__)\n", "From the CPython`s docs:\n\nAll known built-in modules are listed in sys.builtin_module_names\n\nNames of modules in sys.builtin_module_names is actual only for used a Python interpreter:\n\nA tuple of strings giving the names of all modules that are compiled into this Python interpreter\n\nEach built-in module use the special loader while importing: BuiltinImporter\nIn [65]: import itertools, sys, gc\n\nIn [66]: itertools.__loader__, sys.__loader__, gc.__loader__\nOut[66]: \n(_frozen_importlib.BuiltinImporter,\n _frozen_importlib.BuiltinImporter,\n _frozen_importlib.BuiltinImporter)\n\nIn the Python 3 the number of built-in modules has slightly increased \n$ python2.7 -c \"import sys; print('Count built-in modules: %d' %len(sys.builtin_module_names)); print(sys.builtin_module_names)\"\nCount built-in modules: 51\n('__builtin__', '__main__', '_ast', '_bisect', '_codecs', '_collections', '_functools', '_heapq', '_io', '_locale', '_md5', '_random', '_sha', '_sha256', '_sha512', '_socket', '_sre', '_struct', '_symtable', '_warnings', '_weakref', 'array', 'binascii', 'cPickle', 'cStringIO', 'cmath', 'datetime', 'errno', 'exceptions', 'fcntl', 'gc', 'grp', 'imp', 'itertools', 'marshal', 'math', 'operator', 'posix', 'pwd', 'select', 'signal', 'spwd', 'strop', 'sys', 'syslog', 'thread', 'time', 'unicodedata', 'xxsubtype', 'zipimport', 'zlib')\n$ python3.4 -c \"import sys; print('Count built-in modules: %d' %len(sys.builtin_module_names)); print(sys.builtin_module_names)\"\nCount built-in modules: 54\n('_ast', '_bisect', '_codecs', '_collections', '_datetime', '_elementtree', '_functools', '_heapq', '_imp', '_io', '_locale', '_md5', '_operator', '_pickle', '_posixsubprocess', '_random', '_sha1', '_sha256', '_sha512', '_socket', '_sre', '_stat', '_string', '_struct', '_symtable', '_thread', '_tracemalloc', '_warnings', '_weakref', 'array', 'atexit', 'binascii', 'builtins', 'errno', 'faulthandler', 'fcntl', 'gc', 'grp', 'itertools', 'marshal', 'math', 'posix', 'pwd', 'pyexpat', 'select', 'signal', 'spwd', 'sys', 'syslog', 'time', 'unicodedata', 'xxsubtype', 'zipimport', 'zlib')\n\nAs the CPython is implemented (primary) on the C programming language, so it is not easy to find it, as example location the Python`s module sys (based on this answer):\n$ locate sysmodule | grep python\n/usr/include/python2.7/sysmodule.h\n/usr/include/python3.4m/sysmodule.h\n/usr/local/include/python3.5m/sysmodule.h\n\n\nMore information about getting an information about all available modules is the CPython, look in my answer here.\n", "It can be done using the given block of code below and it is the most effective way as per me.\nimport sys\na = sys.builtin_module_names\nprint(a)\n\nThe last line to be included if you want to print them.\nHere, a is a tuple and so it can access all the functionalities of a tuple.\nYou can have a look at sys.builtin_module_names for further help\nhttps://docs.python.org/3/library/sys.html\n", "I was working on a similar problem when I learned that 'builtin' means something like \"there is no source file associated with this object\".\nHere's a solution based on checking the /lib and /Dlls folders manually.\nThe use of \"unique\" may be redundant; it's there because I'm not sure if DLLs is strictly for packages which come with python/it was useful for a different problem I was trying to solve (finding out the requirements for a source package).\nfrom typing import Generator, Iterable\nimport os, re, sys\n\ndef unique(iterable:Iterable, yielded:list=None) -> Generator:\n \"\"\"\n Iterate over unique elements of an iterable\n examples:\n >>> [*unique('abbcccdddd')]\n ['a', 'b', 'c', 'd']\n >>> [*unique('abcd')]\n ['a', 'b', 'c', 'd']\n \"\"\"\n yielded = yielded if not isinstance(yielded, type(None)) else []\n for i in iterable:\n if not i in yielded:\n yield i\n yielded.append(i)\n\ndef native_modules() -> Generator:\n \"\"\"\n Every module found:\n under your installation's /lib and /DLLs directories; excuding any under /lib/site-packages/*\n in sys.builtin_module_names\n \"\"\"\n omitables = 'site-packages __pycache__ .pyo .ico .dll .pdb'.split()\n \n path = lambda folder: os.path.join(sys.exec_prefix, folder)\n tidy = lambda pth: os.path.split(os.path.splitext(pth)[0])[-1] # separate the name from the path and extension, if present\n discriminant = lambda pth: not any(re.match(i, pth) for i in map(re.escape, omitables))\n \n lib = map(tidy, filter(discriminant, os.listdir(path('lib'))))\n dlls = map(tidy, filter(discriminant, os.listdir(path('DLLs'))))\n\n yielded = []\n yield from yielded\n yield from unique(sys.builtin_module_names, yielded)\n yield from unique(lib, yielded)\n yield from unique(dlls, yielded)\n\n", "All the commands like dir(builtins) or help(builtins) or sys.builtin_module_names, are either missing several core inbuilt package names or giving thousands of lines of verbose output.\n>>> help('modules')\nThe best command to show all the installed modules is help('modules'). It gives you name of all the installed modules in python without missing anything.\nIncase you need names of inbuilt modules only, create a temporary fresh venev and give the command there. It might be bit slow but is the only way by far in my experience to list every single package.\n", "In Linux, you can get a dump of all the built-in modules that came with the fresh install with the following commands\nsudo apt-get install python3-virtualenv\n\ntmpDir=`mktemp -d`\n\npython3 -m virtualenv $tmpDir\nsource /tmp/virtualenv/bin/activate\npython\n\nhelp('modules')\n\nExample Execution\nHere's an example execution of the above commands in Debian 11 with python 3.9\nuser@disp643:~$ sudo apt-get install python3-virtualenv\nReading package lists... Done\nBuilding dependency tree... Done\nReading state information... Done\npython3-virtualenv is already the newest version (20.4.0+ds-2+deb11u1).\nThe following packages were automatically installed and are no longer required:\n ethtool libbotan-2-17 libtspi1 linux-image-5.10.0-10-amd64\n linux-image-5.10.0-13-amd64 linux-image-5.10.0-14-amd64\n linux-image-5.10.0-15-amd64 linux-image-5.10.0-16-amd64\n linux-image-5.10.0-17-amd64 net-tools sse3-support\nUse 'sudo apt autoremove' to remove them.\n0 upgraded, 0 newly installed, 0 to remove and 4 not upgraded.\nuser@disp643:~$ \n\nuser@disp643:~$ tmpDir=`mktemp -d`\nuser@disp643:~$ \n\nuser@disp643:~$ python3 -m virtualenv $tmpDir\ncreated virtual environment CPython3.9.2.final.0-64 in 120ms\n creator CPython3Posix(dest=/tmp/tmp.qQsKZHGZqk, clear=False, no_vcs_ignore=False, global=False)\n seeder FromAppData(download=False, pip=bundle, setuptools=bundle, wheel=bundle, via=copy, app_data_dir=/home/user/.local/share/virtualenv)\n added seed packages: pip==20.3.4, pkg_resources==0.0.0, setuptools==44.1.1, wheel==0.34.2\n activators BashActivator,CShellActivator,FishActivator,PowerShellActivator,PythonActivator,XonshActivator\nuser@disp643:~$ source /tmp/virtualenv/bin/activate\n(virtualenv) user@disp643:~$ python\nPython 3.9.2 (default, Feb 28 2021, 17:03:44) \n[GCC 10.2.1 20210110] on linux\nType \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n>>> help('modules')\n\nPlease wait a moment while I gather a list of all available modules...\n\n__future__ _tracemalloc graphlib retrying\n_abc _uuid grp rlcompleter\n_aix_support _virtualenv gzip runpy\n_ast _warnings hashlib sched\n_asyncio _weakref heapq secrets\n_bisect _weakrefset hmac select\n_blake2 _xxsubinterpreters html selectors\n_bootlocale _xxtestfuzz html5lib setuptools\n_bootsubprocess _zoneinfo http shelve\n_bz2 abc idna shlex\n_codecs aifc imaplib shutil\n_codecs_cn antigravity imghdr signal\n_codecs_hk appdirs imp site\n_codecs_iso2022 argparse importlib sitecustomize\n_codecs_jp array inspect smtpd\n_codecs_kr ast io smtplib\n_codecs_tw asynchat ipaddr sndhdr\n_collections asyncio ipaddress socket\n_collections_abc asyncore itertools socketserver\n_compat_pickle atexit json spwd\n_compression audioop keyword sqlite3\n_contextvars base64 lib2to3 sre_compile\n_crypt bdb linecache sre_constants\n_csv binascii locale sre_parse\n_ctypes binhex logging ssl\n_ctypes_test bisect lzma stat\n_curses builtins mailbox statistics\n_curses_panel bz2 mailcap string\n_datetime cProfile marshal stringprep\n_dbm calendar math struct\n_decimal certifi mimetypes subprocess\n_elementtree cgi mmap sunau\n_functools cgitb modulefinder symbol\n_hashlib chunk msgpack symtable\n_heapq cmath multiprocessing sys\n_imp cmd netrc sysconfig\n_io code nis syslog\n_json codecs nntplib tabnanny\n_locale codeop ntpath tarfile\n_lsprof collections nturl2path telnetlib\n_lzma colorama numbers tempfile\n_markupbase colorsys opcode termios\n_md5 compileall operator test\n_multibytecodec concurrent optparse textwrap\n_multiprocessing configparser os this\n_opcode contextlib ossaudiodev threading\n_operator contextlib2 packaging time\n_osx_support contextvars parser timeit\n_peg_parser copy pathlib tkinter\n_pickle copyreg pdb token\n_posixshmem crypt pep517 tokenize\n_posixsubprocess csv pickle toml\n_py_abc ctypes pickletools trace\n_pydecimal curses pip traceback\n_pyio dataclasses pipes tracemalloc\n_queue datetime pkg_resources tty\n_random dbm pkgutil turtle\n_sha1 decimal platform types\n_sha256 difflib plistlib typing\n_sha3 dis poplib unicodedata\n_sha512 distlib posix unittest\n_signal distutils posixpath urllib\n_sitebuiltins doctest pprint urllib3\n_socket easy_install profile uu\n_sqlite3 email progress uuid\n_sre encodings pstats venv\n_ssl enum pty warnings\n_stat errno pwd wave\n_statistics faulthandler py_compile weakref\n_string fcntl pyclbr webbrowser\n_strptime filecmp pydoc wheel\n_struct fileinput pydoc_data wsgiref\n_symtable fnmatch pyexpat xdrlib\n_sysconfigdata__linux_x86_64-linux-gnu formatter pyparsing xml\n_sysconfigdata__x86_64-linux-gnu fractions queue xmlrpc\n_testbuffer ftplib quopri xxlimited\n_testcapi functools random xxsubtype\n_testimportmultiple gc re zipapp\n_testinternalcapi genericpath readline zipfile\n_testmultiphase getopt reprlib zipimport\n_thread getpass requests zlib\n_threading_local gettext resolvelib zoneinfo\n_tkinter glob resource \n\nEnter any module name to get more help. Or, type \"modules spam\" to search\nfor modules whose name or summary contain the string \"spam\".\n\n>>> \n\n" ]

[ 56, 24, 15, 7, 5, 2, 1, 1, 0 ]

[]

[]

[ "python" ]

[ "You can check on the id and value like this:\nfor store in student_data:\n id = store.h5.attrs['id']\n value = store.h5.text\n print(id, value)\n\nThen you can use if statements to check the id's. For example,\nfor store in student_data:\n id = store.h5.attrs['id']\n value = store.h5.text\n if id == \"name\":\n print(value)\n\nDoes this answer your question?\n" ]

[ 1 ]

[]

[]

[ "element", "html", "parsing", "python", "web_scraping" ]

[ "def DescribeProgram():\n \n print(\"\"\"\\\nThis program uses a for loop to monitor your budget.\nThe program will prompt you to enter your budget, and amount spent\nfor a certain month and calculate if your were under or over budget.\nYou will have the option of choosing how many months you would like to\nmonitor.\\n\"\"\")\n\n\ndef GetMonths():\n Months = int(input(\"Enter the number of months you want to analyze\")) \n return Months\n\ndef GetMonthBudgetandSpent(month):\n Mobudget = input(\"Enter the budget you have for the month\")\n MoSpent = input(\"Enter the amount you spent this month\")\n return Mobudget, MoSpent\n\ndef AnalyzeBudget(months):\n for month in range(1,months+1):\n print(f\"\\nMonth {month}:\")\n print(\"=======\")\n MoBudget,MoSpent = GetMonthBudgetandSpent(month)\n\ndef main():\n DescribeProgram()\n months = GetMonths()\n AnalyzeBudget(months)\n\nmain()\n\nOnly if MoBudget and MoSpent is at this level of indentation will the code work as of what I felt the code is for which is:\n- Display what this program does\n- Get no. of months to analyse budget\n- For each month, take user input of budget and amount spend\n\nYou've not written any code to analyse the budget?\n" ]

[ 0 ]

[]

[]

[ "for_loop", "function", "loops", "python", "while_loop" ]

[ "This is really about applying an incrementing multiplier to Y, so it is more suitably implemented by iterating over a range of multipliers.\nTo produce 4 items, for example:\ni = -0.5\ntot = 0.025\nlst = [i + tot * m for m in range(4)]\n\n" ]

[ 0 ]

[]

[]

[ "append", "list", "python" ]

[ "The threading module has a wait method that will block until notify or notify_all is called. This should accomplish what you're looking for in your first question. For question 2 you can either define a function that handles the exit case, or just recreate a thread to start form the beginning.\n", "Simply it can work like this, maybe helps.\nfrom threading import Thread, Event\n\ncount = 0\ncounter = Event()\n\ndef pre():\n\n global count\n counter.wait()\n count -= 1\n print(count)\n\ndef main():\n\n global count\n print(count)\n while True:\n command = input(\"Enter 1 to increase, Enter 2 to decrease :\")\n if command == \"1\":\n t1 = Thread(target=pre, args=())\n t1.start()\n counter.set()\n else :\n count += 1\n print(count)\n\n\nmain()\n\n" ]

[ 0, 0 ]

[]

[]

[ "multithreading", "python" ]

[ "You can use:\na = pd.to_numeric(df['col'].str.split('±').str[0], errors='coerce').to_numpy()\n\nOr (more efficient):\na = pd.to_numeric(df['col'].str.extract('(.*)\\s*±', expand=False), errors='coerce').to_numpy()\n\nExample output:\narray([10. , 20. , 33.3])\n\nUsed input:\ndf = pd.DataFrame({'col': ['10 ± 1', '20 ± 2', '33.3 ± 3']})\n\n" ]

[ 1 ]

[]

[]

[ "pandas", "python" ]

[ "For better location of packages and files and better management, you should use virtual environments.\n\nFirst create a folder (Django) and open it in vscode.\n\nThen use the following command in the terminal to create a new virtual environment (.venv)\npython -m venv .venv\n\n\n\nAfter the command is executed, select the virtual environment interpreter in the select interpreter panel\n\n\nCreate a new terminal activation environment\n\n\nInstall django using the command in the new terminal\npython -m pip install django\n\n\n\nCreate a Django project\ndjango-admin startproject web_project .\n\n\n\nCreate an empty development database\npython manage.py migrate\n\n\n\nTo verify the Django project, make sure your virtual environment is activated, then start Django's development server using the command\npython manage.py runserver\n\n\n\n\n" ]

[ 0 ]

[]

[]

[ "django", "python", "visual_studio_code" ]

[ "It looks like you created draw_blocks incorrectly for what you are trying to do.\nIf you want it to only draw blocks when x is divisible by 2 or 5, you need to draw the block at the position of x times square_size. I've modified your draw_blocks function below, which fixes the issue:\ndef draw_blocks():\n for x in range(0, 21):\n if x % 5 == 0 or x % 2 == 0:\n draw_square(square_size*x, 0)\n\n" ]

[ 0 ]

[]

[]

[ "for_loop", "python" ]

[ "If you use sets, you cannot define a 1-to-1 relationship, as those are unordered.\nIf you have lists, you could use:\nlist1 = [1,2,3,4,5,6,7,8,9,10]\nlist2 = [10,20,30,40,50,60,70,80,90,100]\n\nratios = [b/a for a,b in zip(list1, list2)]\n\nOutput: [10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0]\nOr using a set comprehension:\nS = {round(b/a, 3) for a,b in zip(list1, list2)}\n# {10.0}\n\n# check there is only one possibility\nif len(S) != 1:\n print('there is not a unique ratio')\n\n" ]

[ 0 ]

[]

[]

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

[ "import pandas as pd\nresults = [[('three', 'beer'), ('zero', 'wine')], [('one', 'beer'), ('two', 'wine')]]\nPlayer1Qty = []\nPlayer1type = []\nPlayer2Qty = []\nPlayer2type = []\nfor tmp in results:\n Player1Qty.append(tmp[0][0])\n Player1type.append(tmp[0][1])\n Player2Qty.append(tmp[1][0])\n Player2type.append(tmp[1][1])\npd.DataFrame({'Player1Qty': Player1Qty, 'Player1type': Player1type, 'Player2Qty': Player2Qty, 'Player2type': Player2type})\n\n", "try this:\nimport numpy as np\nimport pandas as pd\n\n\ndata = [\n [('one', 'apple'), ('three', 'orange') ],\n [('two', 'pear'), ('four', 'banana') ]\n]\ndf = pd.DataFrame(data)\nout = pd.DataFrame([*df.apply(np.hstack, axis=1)])\ncols = [f'Player{i//2 + 1}{\"Qty\" if i % 2 else \"type\"}' for i in out.columns]\nout.columns = cols\nprint(out)\n>>>\n\n Player1type Player1Qty Player2type Player2Qty\n0 one apple three orange\n1 two pear four banana\n\n" ]

[ 0, 0 ]

[]

[]

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

[ "If you're trying to output to a specific channel, you need something like this:\nasync def on_ready():\n channel = client.get_channel(channel ID here)\n await channel.send(x.link)\n\nAs for the x.link part, that comes with feedparser, which you can get with import feedparser. You would then get the feed with the following:\nx = feedparser.parse('rss link here')\n\nThis is what I've been using so far, I hope it's of some help.\n" ]

[ 0 ]

[]

[]

[ "discord", "python", "rss" ]

[ "how about using a library instead of calling system's curl? \n", "You could try using the original string in subprocess.Popen with the additional keyword argument to Popen of shell=True:\nsubprocess.Popen(\"curl --data-binary \\@\"+input_file_path+\" -o \"+ file_name +\" localhost:30\",\n stdout=subprocess.PIPE,\n shell=True)\n\n", "How about using requests library\nPython POST binary data\nOr yet another\nCheck out this link for binary (image file) case\nHow to download image using requests\n" ]

[ 3, 2, 0 ]

[]

[]

[ "curl", "popen", "python" ]

[ "The first step you want to do can be done by df.loc[\"A\", \"High\"] > df.loc[\"C\", \"Low\"]. To apply this to all rows you could do something like below:\nfor i in range(2, len(df)):\n print(df[\"High\"][i-2] > df[\"Low\"][i])\n\nI'm sure there are better ways to do it, but this would work.\n", "you can use shift operation on column to shift the rows up/down\n`df['High'] > df['Low'].shift(-2)`\n\nTo elaborate what's going on, run below commands\ndf = pd.DataFrame(np.random.randn(5,4), list('ABCDE'), ['Open', 'High', 'Low', 'Close'])\ndf['Low_shiftup'] = df['Low'].shift(-2)\ndf.head()\ndf['High'] > df['Low_shiftup']\n\n", "As I explained in the question I have now found multiple solutions for this problem. One being itertuples.\nHere is how to use itertuples to solve the problem.\nFirst, create the dataframe\nimport pandas as pd\nimport numpy as np\nnp.random.seed(2022)\n\n# make example data\nclose = np.sin(range(610)) + 10\nhigh = close + np.random.rand(*close.shape)\nopen = high - np.random.rand(*close.shape)\nlow = high - 3\nclose[2] += 100\ndates = pd.date_range(end='2022-06-30', periods=len(close))\n\n# insert into pd.dataframe\ndf = pd.DataFrame(index=dates, data=np.array([open, high, low, close]).T, columns=['Open', 'High', 'Low', 'Close'])\nprint(df)\n\nNow we use itertuples to iterate over the rows of the dataframe\nfor row in df.itertuples():\n o = row.Open\n for r in df.itertuples():\n c = r.Close\n if o < c:\n print('O is less than C')\n else:\n print('O is greater than C')\n\nThis will find all instances of when the open price is less than the close price\nThis can be expanded on to check other conditions within the same loop just by adding more variables and more if statements, and also using enumerate to check positioning\nFor example:\nfor idx, row in enumerate(df.itertuples()):\n o = row.Open\n h = row.High\n for i, r in enumerate(df.itertuples()):\n c = r.Close\n l = r.Low\n if (i > idx) & ((h - 2) > l):\n if o < c:\n print('O is less than C')\n else:\n print('O is greater than C')\n else:\n continue\n\nThe above code uses enumerate to add a counter to each loop. The additional if statement will only check if 'o < c' in rows which the loop counter for 'c' is greater than the loop counter for 'o'.\nAs you can see any value in the dataframe can be compared to another using the correct if statements.\n" ]

[ 1, 0, 0 ]

[]

[]

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

[ "i = 0\nres = []\nwhile i < df.shape[1]:\n res.append(df.iloc[:, i: (i + 3)])\n i = i + 3\nprint(res[0])\nprint(res[1])\nprint(res[2])\n\n" ]

[ 0 ]

[]

[]

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

[ "Assuming the number of values is even, you can use:\nout = pd.DataFrame(df.iloc[:,0].to_numpy().reshape(-1,2), columns=['X', 'Y'])\n\nOutput:\n X Y\n0 792.0 610.0\n1 786.0 602.0\n\n" ]

[ 0 ]

[]

[]

[ "csv", "multiple_columns", "pandas", "python", "split" ]

[ "This error message indicates the presence of null values:\nNo Shapely geometry can be created from null value\n\nYou must have a None or NaN in your geometry column. This is different from (and possibly in addition to) any issues you may have with self-intersections.\nYou can search for nulls, e.g. with the following, to diagnose what’s going on:\npz32[pz32.isnull()]\n\nOr just drop the row:\npz32 = pz32[pz32.notnull()]\n\nShapely can’t just create a geometry from nothing, so it’s asking you to decide what to do with the null value. While geopandas can handle null values, you’re forcing the whole GeometryArray to be converted to a single shapely object by taking the unary_union.\n" ]

[ 0 ]

[]

[]

[ "geometry", "geopandas", "gis", "python", "shapely" ]

[ "Move your range check to be outside your actual looping, eg:\ndef shampoo_instructions(num_cycles):\n if num_cycles < 1:\n print 'Too few.'\n elif num_cyles > 4:\n print 'Too many.'\n else:\n for num_cycles in range(1,num_cycles+1):\n print num_cycles, 'lather and rinse.'\n print 'Done'\n\n", "found some help from reddit.\ndef shampoo_instructions(num_cycles):\n if num_cycles <= 0:\n print(\"Too few.\")\n elif num_cycles >= 5:\n print(\"Too many.\")\n else:\n for num_cycles in range (1, num_cycles + 1):\n print(num_cycles,\":\", \"Lather and rinse.\")\n print(\"Done.\")\n\n", "''' Your solution goes here '''\ndef print_shampoo_instructions(num_cycles):\n if num_cycles < 1:\n print('Too few.')\n elif num_cycles > 4:\n print('Too many.')\n else:\n i = 1\n while i <= num_cycles:\n print(f'{i} : Lather and rinse.')\n i += 1\n print('Done.')\n\nuser_cycles = int(input())\nprint_shampoo_instructions(user_cycles)\n\n" ]

[ 1, 0, 0 ]

[]

[]

[ "python" ]

[ "If it's WAV format, torchaudio.load should be able to decode it from file-like object. Your code snippet looks good to me.\nThe following tutorial demonstrates it with different file-like objects.\nhttps://pytorch.org/audio/0.13.0/tutorials/audio_io_tutorial.html#loading-from-file-like-object\nStill, there are many reasons it does not work. For example, is your file-like object's cursor pointing the correct position (the beginning of the audio data)? Does the read method conformant to the io.RawIOBase.read protocol?\nIt's hard to tell without seeing the error stacktrace.\n" ]

[ 0 ]

[]

[]

[ "python", "torch", "torchaudio" ]

[ "Try this:\nnew_df[['e', 'e_s', 'rh']] = data.apply(lambda x: new_vars(x['Temp'], x['Dewpt_Temp']), axis=1)\n\nAnd in the function declaration:\ndef new_vars(temp, dewpt)\n\nAnd delete these two lines:\n temp = dataframe.Temp\n dewpt = dataframe.Dewpt_Temp\n\n", "Can you try this:\nnew_df = pd.DataFrame()\nnew_df[['e', 'e_s', 'rh']] = df.apply(lambda x: new_vars(x),axis=1)\n\nFull code:\ndata = pd.read_csv('file path/weather_data.csv')\n\ndef new_vars(dataframe):\n temp = dataframe.Temp\n dewpt = dataframe.Dewpt_Temp\n \n e = 6.11*(10**((7.5*dewpt)/(273.3 + dewpt)))\n e_s = 6.11*(10**((7.5*temp)/(273.3 + temp)))\n rh = (e/e_s) * 100\n \n return (e, e_s, rh)\n\nnew_df = pd.DataFrame()\nnew_df[['e', 'e_s', 'rh']] = df.apply(lambda x: new_vars(x),axis=1)\n\n", "You seem to be unclear on what lambda means. It defines a function in terms of the dummy variable given immediately after it. If that is then followed by an expression in terms of that variable after a colon, then you have a function that varies as that variable varies. But if you have a different variable, then the function will always return the expression evaluated for that variable. For instance, lambda x: x*2 defines a function that takes any value and doubles it. But lambda x: y*2 will always return whatever y*2 is, regardless of what x is. If you want to apply new_vars, you can just pass it to apply:\nnew_df = data.apply(new_vars, axis=1)\n\n" ]

[ 0, 0, 0 ]

[]

[]

[ "apply", "function", "pandas", "python" ]

[ "Assuming a pandas dataframe, you can use boolean operations and groupby.any:\nquestion 1\n# define boolean masks\nm1 = df['new_company_status'].eq('Yes')\nm2 = df['calling'].eq('Yes')\n\n# count the number of companies\n# with at least one occurrence of m1 and m2\n(m1&m2).groupby(df['company_name']).any().sum()\n\nOutput: 1\nquestion 2\n# counting the companies with at least one calling AND one po as Yes\ndf[['calling', 'po']].eq('Yes').groupby(df['company_name']).any().all(axis=1).sum()\n\nOutput: 3\n" ]

[ 0 ]

[]

[]

[ "count", "datetime", "function", "python" ]

[ "You can get the current year and month from datetime.date.today() (See Datetime current year and month in Python)\nimport datetime\n\ntoday = datetime.date.today()\n\n# Current year: today.year\n# Current month today.month\n\nIterate over each element of purchases. The \"date\" key in each element tells you the date for that purchase. It's annoying that the value at this key is a string representation of a tuple, but we can parse it using ast.literal_eval.\nThe first element of this tuple is the year for the purchase. The second element is the month. So we need to check if these values match the values for today, and add to the corresponding totals:\nimport ast\n\ntotal_month = 0\ntotal_year = 0\n\nfor purchase in purchases:\n p_date = ast.literal_eval(purchase[\"date\"])\n if p_date[0] == today.year:\n total_year += purchase[\"price\"]\n if p_date[1] == today.month:\n total_month += purchase[\"price\"]\n\nAnd after we've looked through all purchases, we can check our criteria:\nif total_year >= 15_000:\n print(\"20% discount\")\n if total_month >= 3000:\n print(\"Extra 15% discount\")\n\n" ]

[ 1 ]

[]

[]

[ "date", "list", "python", "python_3.x" ]

[ "there are many variances including samples and models to improve the accuracy of binary class-entropy as a single objective. To improves the accuracy first you need to use the correct measurement, the accuracy matric works correctly when you label with 0 to 1 as float since it is binary cross entropy it may reflect minus number result because that is from the square different of the label values.\nIt is not fluctuating loss and accuracy but you need to use the correct approaches, binary cross-entropy as single is a very fast drive but the return of turn points is deterministic.\n\nSample: You can apply the mean of all output or simply critical points.\n\nplt.figure(figsize=(5,2))\nplt.title(\"Actors recognitions\")\nfor i in range(len(list_file)):\n img = tf.keras.preprocessing.image.array_to_img(\n list_file[i],\n data_format=None,\n scale=True\n )\n img_array = tf.keras.preprocessing.image.img_to_array(img)\n img_array = tf.expand_dims(img_array, 0)\n predictions = model.predict(img_array)\n score = tf.nn.softmax(predictions[0])\n \n plt.subplot(5, 2, i + 1)\n plt.xticks([])\n plt.yticks([])\n plt.grid(False)\n plt.imshow(list_file_actual[i])\n \n if predictions[0] > 0.51 :\n plt.xlabel(str(list_label_actual[1]) + \" score: \" + str(predictions[0]))\n else :\n plt.xlabel(str(list_label_actual[0]) + \" score: \" + str(predictions[0]))\n\n\nSample: You may try to use vectors to improves of the results.\n\nimport os\nfrom os.path import exists\n\nimport tensorflow as tf\nimport tensorflow_io as tfio\n\nimport matplotlib.pyplot as plt\n\n\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n[PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]\nNone\n\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\nphysical_devices = tf.config.experimental.list_physical_devices('GPU')\nassert len(physical_devices) > 0, \"Not enough GPU hardware devices available\"\nconfig = tf.config.experimental.set_memory_growth(physical_devices[0], True)\nprint(physical_devices)\nprint(config)\n\n\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\nVariables\n\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\nPATH = os.path.join('F:\\\\datasets\\\\downloads\\\\Actors\\\\train\\\\Pikaploy', '*.tif')\nPATH_2 = os.path.join('F:\\\\datasets\\\\downloads\\\\Actors\\\\train\\\\Candidt Kibt', '*.tif')\nfiles = tf.data.Dataset.list_files(PATH)\nfiles_2 = tf.data.Dataset.list_files(PATH_2)\n\nlist_file = []\nlist_file_actual = []\nlist_label = []\nlist_label_actual = [ 'Pikaploy', 'Candidt Kibt' ]\nfor file in files.take(5):\n image = tf.io.read_file( file )\n image = tfio.experimental.image.decode_tiff(image, index=0)\n list_file_actual.append(image)\n image = tf.image.resize(image, [32,32], method='nearest')\n list_file.append(image)\n # list_label.append([0, 0])\n list_label.append([0.0])\n \nfor file in files_2.take(5):\n image = tf.io.read_file( file )\n image = tfio.experimental.image.decode_tiff(image, index=0)\n list_file_actual.append(image)\n image = tf.image.resize(image, [32,32], method='nearest')\n list_file.append(image)\n # list_label.append([1, 1])\n list_label.append([1.0])\n\ncheckpoint_path = \"F:\\\\models\\\\checkpoint\\\\\" + os.path.basename(__file__).split('.')[0] + \"\\\\TF_DataSets_01.h5\"\ncheckpoint_dir = os.path.dirname(checkpoint_path)\nloggings = \"F:\\\\models\\\\checkpoint\\\\\" + os.path.basename(__file__).split('.')[0] + \"\\\\loggings.log\"\n\nif not exists(checkpoint_dir) : \n os.mkdir(checkpoint_dir)\n print(\"Create directory: \" + checkpoint_dir)\n \nlog_dir = checkpoint_dir\n\n\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\nDataSet\n\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n# dataset = tf.data.Dataset.from_tensor_slices((tf.constant(tf.cast(list_file, dtype=tf.int64), shape=(10, 1, 32, 32, 4), dtype=tf.int64),tf.constant(list_label, shape=(10, 1, 2), dtype=tf.int64)))\ndataset = tf.data.Dataset.from_tensor_slices((tf.constant(tf.cast(list_file, dtype=tf.int64), shape=(10, 1, 32, 32, 4), dtype=tf.int64),tf.constant(list_label, shape=(10, 1, 1), dtype=tf.float32)))\n\n\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n: Model Initialize\n\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\nmodel = tf.keras.models.Sequential([\n tf.keras.layers.InputLayer(input_shape=( 32, 32, 4 )),\n tf.keras.layers.Normalization(mean=3., variance=2.),\n tf.keras.layers.Normalization(mean=4., variance=6.),\n tf.keras.layers.Conv2D(32, (3, 3), activation='relu'),\n tf.keras.layers.MaxPooling2D((2, 2)),\n tf.keras.layers.Dense(128, activation='relu'),\n tf.keras.layers.Reshape((128, 225)),\n tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(96, return_sequences=True, return_state=False)),\n tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(96)),\n tf.keras.layers.Flatten(),\n tf.keras.layers.Dense(192, activation='relu'),\n tf.keras.layers.Dense(1, activation='sigmoid'),\n])\n\n\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n: Optimizer\n\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n# optimizer = tf.keras.optimizers.SGD(\n # learning_rate=0.001,\n # momentum=0.0,\n # nesterov=False,\n # name='SGD',# )\n\noptimizer = tf.keras.optimizers.Nadam(\n learning_rate=0.00001, beta_1=0.9, beta_2=0.999, epsilon=1e-07,\n name='Nadam'\n)\n\n\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n: Loss Fn\n\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\" \nlossfn = tf.keras.losses.BinaryCrossentropy(\n from_logits=False,\n label_smoothing=0.0,\n axis=-1,\n reduction=tf.keras.losses.Reduction.AUTO,\n name='binary_crossentropy'\n)\n\n\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n: Model Summary\n\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\nmodel.compile(optimizer=optimizer, loss=lossfn, metrics=['accuracy'])\n\n\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n: Callback\n\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\nclass custom_callback(tf.keras.callbacks.Callback):\n def on_epoch_end(self, epoch, logs={}):\n # if( logs['loss'] <= 0.2 ):\n # self.model.stop_training = True\n if( logs['accuracy'] >= 0.95 ):\n self.model.stop_training = True\n \ncustom_callback = custom_callback()\n\n\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n: FileWriter\n\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\nif exists(checkpoint_path) :\n model.load_weights(checkpoint_path)\n print(\"model load: \" + checkpoint_path)\n input(\"Press Any Key!\")\n\n\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n: Training\n\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\nhistory = model.fit( dataset, validation_data=dataset, batch_size=10, epochs=10000, callbacks=[custom_callback] )\nmodel.save_weights(checkpoint_path)\n\nplt.figure(figsize=(5,2))\nplt.title(\"Actors recognitions\")\nfor i in range(len(list_file)):\n img = tf.keras.preprocessing.image.array_to_img(\n list_file[i],\n data_format=None,\n scale=True\n )\n img_array = tf.keras.preprocessing.image.img_to_array(img)\n img_array = tf.expand_dims(img_array, 0)\n predictions = model.predict(img_array)\n score = tf.nn.softmax(predictions[0])\n \n plt.subplot(5, 2, i + 1)\n plt.xticks([])\n plt.yticks([])\n plt.grid(False)\n plt.imshow(list_file_actual[i])\n \n if predictions[0] > 0.51 :\n plt.xlabel(str(list_label_actual[1]) + \" score: \" + str(predictions[0]))\n else :\n plt.xlabel(str(list_label_actual[0]) + \" score: \" + str(predictions[0]))\n\nplt.show()\n\nplt.plot(history.history['accuracy'], label='accuracy')\nplt.plot(history.history['val_accuracy'], label = 'val_accuracy')\nplt.xlabel('Epoch')\nplt.ylabel('Accuracy')\nplt.ylim([0.5, 1])\nplt.legend(loc='lower right')\n\nplt.show()\n\n\nOutput results:\n\n\n\nAccuracy versus epoaches:\n\n\n" ]

[ 0 ]

[]

[]

[ "classification", "deep_learning", "machine_learning", "python", "tensorflow" ]

[ "First, use np.where to optimize your current code, which is the same and faster than the function wrapped with np.vectorize:\n>>> np.where(a, '8', '.')\narray([['.', '8', '.', '.'],\n ['8', '8', '8', '8'],\n ['.', '.', '.', '.'],\n ['.', '.', '.', '.']], dtype='<U1')\n\nTo concatenate the characters in each line, I prefer to use ndarray.view, which will create a view at a very low cost. It treats all characters in each line as a string with a length of 4:\n>>> np.where(a, '8', '.').view('<U4')\narray([['.8..'],\n ['8888'],\n ['....'],\n ['....']], dtype='<U4')\n\nThen use ndarray.ravel() or ndarray.flat to unpack the flat results into the print function, with the newline character as the separator:\n>>> print(*np.where(a, '8', '.').view('<U4').flat, sep='\\n')\n.8..\n8888\n....\n....\n\nOr use str.join to get the complete string:\n>>> print('\\n'.join(np.where(a, '8', '.').view('<U4').flat))\n.8..\n8888\n....\n....\n\n" ]

[ 3 ]

[]

[]

[ "arrays", "numpy", "pretty_print", "python" ]

[ "Assuming df and groupings your two input DataFrames:\nout = df.join(df.groupby(df.columns.map(groupings.set_index('names')['groupings']),\n axis=1).sum()\n )\n\nOutput:\n date James Jamie John Allysia Jean girl guy\n0 2022-01-01 NaN 6 5 4.0 3 13.0 5.0\n1 2022-01-02 7.0 6 7 NaN 5 11.0 14.0\n\n" ]

[ 0 ]

[]

[]

[ "python" ]

[ "You could do:\ndf['class'] = [i//2 for i in range(len(df))]\nBut this is a pretty limited answer; you might want to apply a certain value on your other columns to get the group ID, or you may have a specific label in mind to apply for the class column, in which case you could follow up with a map function on the series to turn those numbers into something else.\n", "You can use this to achieve what you want:\ndf[\"class\"] = [f\"c{(i // 2) + 1}\" for i in range(df.shape[0])]\n\n\n", "Another possible solution:\ndf['class'] = ['c' + str(1+x) for x in np.repeat(range(int(len(df)/2)), 2)]\n\nOutput:\n TimeStamp Value class\n0 t1 akak c1\n1 t2 bb c1\n2 t3 vvv c2\n3 t4 ff c2\n4 t5 ff c3\n5 t6 44 c3\n6 t7 99 c4\n7 t8 kfkkf c4\n8 t9 ff c5\n9 t10 oo c5\n\n", "You can vectorize the operation with numpy:\nimport numpy as np\n\ndf['class'] = np.core.defchararray.add('c', (np.arange(len(df))//2+1).astype(str))\n\nOr, with a Series:\ndf['class'] = pd.Series(np.arange(len(df))//2+1, index=df.index, dtype='string').radd('c')\n\nOutput:\n TimeStamp Value class\n0 t1 akak c1\n1 t2 bb c1\n2 t3 vvv c2\n3 t4 ff c2\n4 t5 ff c3\n5 t6 44 c3\n6 t7 99 c4\n7 t8 kfkkf c4\n8 t9 ff c5\n9 t10 oo c5\n\n", "try this:\ndf.assign(Class=(df.index//2+1).map('c{}'.format))\n>>>\n\nTimeStamp Value Class\n0 t1 akak c1\n1 t2 bb c1\n2 t3 vvv c2\n3 t5 ff c2\n4 t6 44 c3\n5 t7 99 c3\n6 t8 kfkkf c4\n7 t9 ff c4\n8 t10 oo c5\n\n" ]

[ 0, 0, 0, 0, 0 ]

[]

[]

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

[ "This could possibly mean there is no TFTModel in that version. Have you checked documentation and other versions?\n", "I think I figured it out.\nAs seen in the documentation it says it's in darts.models.forcasting, so try:\nfrom darts.models.forcasting import TFTModel\n\n" ]

[ 0, 0 ]

[]

[]

[ "libraries", "python" ]

[ "You can use math.isnan (or numpy.isnan) to check the NA status. Combine it with a generator and next with a default value to handle cases without valid value:\nfrom math import isnan\n\ndef last_valid(lst):\n return next((x for x in reversed(lst) if x and not isnan(x)), None) # or 'null'\n\nlast_valid([])\n# None\n\nlast_valid([0.0,np. NaN,2,0,0.0,\"\"])\n# 2\n\nlast_valid([1,np. NaN,np. NaN,0,0.0,np. NaN])\n# 1\n\nlast_valid([0.0,np. NaN,np. NaN,0,0.0,np. NaN])\n# None\n\naccepting 0 as valid:\nGiven your update of the rule (0 was initially described as non-valid), you can convert to string in the first test to consider 0 valid:\nfrom math import isnan\ndef last_valid(lst):\n return next((x for x in reversed(lst) if str(x) and not isnan(x)), '\"null\"')\n\nlast_valid([]))\n# '\"null\"'\n\nlast_valid([0.0,np. NaN,2,0,0.0,\"\"])\n# 0.0\n\nlast_valid([1,np. NaN,np. NaN,0,0.0,np. NaN])\n# 0.0\n\nlast_valid([0.0,np. NaN,np. NaN,0,0.0,np. NaN])\n# 0.0\n\nlast_valid([np. NaN,np. NaN,np. NaN])\n# '\"null\"'\n\n", "import numpy as np\nimport pandas as pd\n\nlistF=[0.0,np. NaN,2,0,0.0,\"\"]\n\noutput = 'empty list'\nfor tmp in listF[::-1]:\n if not tmp or pd.isna(tmp):\n continue\n else:\n output = tmp\n break\noutput\n\n", "This is the oneliner you almost got.\nYou have to keep in mind that nan is not false when in a bolean expression!\nBut always returns false if compared to itself :)\nprint([i for i in list if i and not i!=i][-1])\n\n" ]

[ 3, 1, 0 ]

[]

[]

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

[ "As mentionned by @ALoolz in a comment, pandas (and python in general) is using a rounding to minimize bias when summing different elements, called Rounding half to even.\nAs Wikipedi says:\n\nRounding half to even\nA tie-breaking rule without positive/negative\nbias and without bias toward/away from zero is round half to even. By\nthis convention, if the fractional part of x is 0.5, then y is the\neven integer nearest to x. Thus, for example, +23.5 becomes +24, as\ndoes +24.5; however, −23.5 becomes −24, as does −24.5. This function\nminimizes the expected error when summing over rounded figures, even\nwhen the inputs are mostly positive or mostly negative, provided they\nare neither mostly even nor mostly odd.\nThis variant of the round-to-nearest method is also called convergent\nrounding, statistician's rounding, Dutch rounding, Gaussian rounding,\nodd–even rounding,[6] or bankers' rounding.\nThis is the default rounding mode used in IEEE 754 operations for\nresults in binary floating-point formats, and the more sophisticated\nmode[clarification needed] used when rounding to significant figures.\nBy eliminating bias, repeated addition or subtraction of independent\nnumbers, as in a one-dimensional random walk, will give a rounded\nresult with an error that tends to grow in proportion to the square\nroot of the number of operations rather than linearly.\nHowever, this rule distorts the distribution by increasing the\nprobability of evens relative to odds. Typically this is less\nimportant[citation needed] than the biases that are eliminated by this\nmethod.\n\nIn your case, if you want to use the rounding used \"in school\" called Rounding half up, you could apply a function that adds 0.5 and then truncate: lambda x: int(x + 0.5)\nSo, you should do when rounding your DataFrame:\ndf_rounding_half_up = df.applymap(lambda x: int(x + 0.5))\n\n... while Python-default round up to even would be something like:\ndf_rounding_half_to_even = df.applymap(lambda x: int(round(x, 0)))\n\n" ]

[ 0 ]

[ "There seems to be an issue in pandas.round function which does not round 0.5 to 1. In that case you could use built-in round with applymap\nimport pandas as pd\nimport numpy as np\n\ndef getRound(x):\n return(round(x))\n\ndf = pd.DataFrame(np.random.random([3, 3]),\ncolumns=['A', 'B', 'C'], index=['first', 'second', 'third'])\n\ndf will look like this\n A B C\nfirst 0.474011 0.082135 0.476545\nsecond 0.313154 0.265458 0.523410\nthird 0.057491 0.141635 0.037582\n\nChange one value to be 0.5\ndf['A'][1]=0.5\n\nApply lambda function\ndf.applymap(getRound)\n\nOutput:\n A B C\nfirst 0.0 0.0 0.0\nsecond 1.0 0.0 1.0\nthird 0.0 0.0 0.0\n\n" ]

[ -2 ]

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

[ "This can be done with the use of numpy which allows for vectorization of arrays and array-like operations. I'm sure this can be reduced in size, but we can create an array in x and y before making a grid out of these points. We then apply the entire grid to the function A=sin(i**2+j). We then get (I assume ii' is the same as the transpose of ii?)\nimport numpy as np # Import library\nimport matplotlib.pyplot as plt # To visualize\nN = 2000 # NxN \nx = np.linspace(0,1,N)*np.pi #Define two arrays of length N\ny = np.linspace(0,1,N)*np.pi\n\nX, Y = np.meshgrid(x,y) #Create a NxN grid with arrays\n\nA = np.sin(X**2+Y) # Apply grid to function\n\nplt.imshow(A.T, origin='lower', aspect='auto') #Show that it has worked\nplt.show()\n\nwhich gives (updated to match your result in the range [0,pi])\n\n", "Many things you can do in MATLAB have exact translations in numpy. Here's a handy cheat-sheet\nN = 2000 # remains unchanged\nii = np.arange(1, N+1) # In the cheat-sheet section Linear Algebra Equivalents \n\nNow, there's a slight difference. In MATLAB, everything is treated as a matrix, so a 1-dimensional array is just a 1xN matrix, so transposing it is done just like any other matrix. In numpy, 1-dimensional arrays can't be transposed, so let's add a dummy dimension to ii:\nii = ii[None, :]\n\nNow, ii is a 1xN matrix, so we can get A as:\nA = np.sin(ii**2 + ii.T);\n\nNumpy takes care of broadcasting the shapes (1, N) and (N, 1) and gives you a result that is (N, N)\n Note that a' in MATLAB is the conjugate transpose, which would be a.conj().T in numpy, but since these are all real numbers it makes no difference\n" ]

[ 3, 3 ]

[]

[]

[ "numpy", "python", "vectorization" ]

[ "Example\ndata = {'col': {1: 'A', 2: 'B', 3: 'C', 4:'A'}}\ndf = pd.DataFrame(data)\n\ndf:\n col\n1 A\n2 B\n3 C\n4 A\n\nOrdinal Encoding\ndf['col'] = pd.factorize(df['col'])[0]\n\nresult(df)\n col\n1 0\n2 1\n3 2\n4 0\n\n" ]

[ 0 ]

[]

[]

[ "dataframe", "linear_regression", "machine_learning", "pandas", "python" ]

[ "There are two approaches you can take here.\n\nKeep version in pyproject.toml and get it from the package metadata in the source code. So, in your foo/__init__.py or wherever:\n\nfrom importlib.metadata import version\n__version__ = version(__package__)\n\nimportlib.metadata.version is available since Python 3.8. For earlier Python versions, you can do similar with the importlib_metadata backport.\n\nKeep the version in the source code and instruct the build system to get it from there. For a setuptools build backend, it looks like this in pyproject.toml:\n\n[project]\ndynamic = [\"version\"]\n\n[tool.setuptools.dynamic]\nversion = {attr = \"foo.__version__\"}\n\nMy recommendation is actually () ... neither! Don't keep a __version__ attribute in the source code at all. It's an outdated habit which we can do without these days. Version is already a required field in the package metadata, it's redundant to keep the same string as an attribute in the package/module namespace.\n" ]

[ 2 ]

[]

[]

[ "pyproject.toml", "python" ]

[ "Here are a few ways I do it:\ncolumns = df.columns.tolist()\ncolumns.insert(0, columns.pop(columns.index(\"Gross foreign liabilities\")))\ndf = df.reindex(columns=columns)\n\nOR\ncol = [\"Gross foreign liabilities\"]\ndf = df[col + [x for x in df.columns if x not in col]]\n\n", "You can use pop and insert:\nname = 'Gross foreign liabilities'\ndf.insert(0, name, df.pop(name))\n\nas a function:\ndef move_first(df, name):\n df.insert(0, name, df.pop(name))\n\nmove_first(df, 'Gross foreign liabilities')\n\nOutput:\n Gross foreign liabilities BoP transfers Current balance \\\n1998 60.597848 12.346282 -6.7953 \n1999 61.033082 19.064381 -2.9895 \n2000 64.014381 18.248880 -3.9694 \n2001 67.077982 24.860020 1.1716 \n2002 70.161086 32.382422 5.7433 \n\n Domestic demand Effective exchange rate RoR (foreign liabilities) \\\n1998 106.861039 88.134000 0.0433 \n1999 104.703025 95.642500 0.0437 \n2000 104.592542 99.927725 0.0542 \n2001 103.835322 101.927450 0.0539 \n2002 102.817094 107.855650 0.0474 \n\n Gross foreign assets Gross domestic income Inflation rate Credit \n1998 19.720897 104.903794 52.6613 0.202699 \n1999 22.662007 103.153619 19.3349 0.215428 \n2000 25.182707 103.067778 16.0798 0.282949 \n2001 30.394227 102.858865 15.0760 0.395481 \n2002 37.264773 102.285182 17.2360 0.357826 \n\n", "Example\ndata = {'col1': {0: 0, 1: 2}, 'col2': {0: 1, 1: 3}, 'col3': {0: 2, 1: 4}}\ndf = pd.DataFrame(data)\n\ndf\n col1 col2 col3\n0 0 1 2\n1 2 3 4\n\nCode\ndf.insert(0, 'col3', df.pop('col3'))\n\noutput(df):\n col3 col1 col2\n0 2 0 1\n1 4 2 3\n\nmake example more simple plz\n" ]

[ 1, 0, 0 ]

[]

[]

[ "columnsorting", "pandas", "python" ]

[ "Databricks File System (DBFS) is a distributed file system mounted into an Azure Databricks workspace and available on Azure Databricks clusters. If you are using local file API you have to reference the Databricks filesystem. Azure Databricks configures each cluster node with a FUSE mount /dbfs that allows processes running on cluster nodes to read and write to the underlying distributed storage layer with local file APIs (see also the documentation).\nSo in the path /dbfs: has to be included:\nroot = \"/dbfs/mnt/rawdata/parent/\"\n\nThat is different then working with the Databricks Filesystem Utility (DBUtils). The file system utilities access Databricks File System, making it easier to use Azure Databricks as a file system:\ndbutils.fs.ls(\"/mnt/rawdata/parent/\")\n\nFor larger Data Lakes I can recommend a Scala example in the Knowledge Base.\nAdvantage is that it runs the listing for all child leaves distributed, so will work also for bigger directories.\n", "I got this to work.\nfrom azure.storage.blob import BlockBlobService \n\nblob_service = BlockBlobService(account_name='your_account_name', account_key='your_account_key')\n\nblobs = []\nmarker = None\nwhile True:\n batch = blob_service.list_blobs('rawdata', marker=marker)\n blobs.extend(batch)\n if not batch.next_marker:\n break\n marker = batch.next_marker\nfor blob in blobs:\n print(blob.name)\n\nThe only prerequisite is that you need to import azure.storage. So, in the Clusters window, click 'Install-New' -> PyPI > package = 'azure.storage'. Finally, click 'Install'.\n", "This worked for me - finding all the parquet's in starting from a DBFS path:\n#------\n# find parquet files in subdirectories recursively\ndef find_parquets(dbfs_ls_list):\n parquet_list = []\n if isinstance(dbfs_ls_list, str):\n # allows for user to start recursion with just a path\n dbfs_ls_list = dbutils.fs.ls(root_dir)\n parquet_list += find_parquets(dbfs_ls_list)\n else:\n for file_data in dbfs_ls_list:\n if file_data.size == 0 and file_data.name[-1] == '/':\n # found subdir\n new_dbdf_ls_list = dbutils.fs.ls(file_data.path)\n parquet_list += find_parquets(new_dbdf_ls_list)\n elif '.parquet' in file_data.name:\n parquet_list.append(file_data.path)\n return parquet_list\n\n#------\nroot_dir = 'dbfs:/FileStore/my/parent/folder/'\nfile_list = find_parquets(root_dir)\n\n" ]

[ 16, 2, 0 ]

[]

[]

[ "azure_data_lake", "azure_databricks", "databricks", "python", "scala" ]

[ "It looks like setuptools>=58 breaks support for use_2to3:\nsetuptools changelog for v58\nSo you should update setuptools to setuptools<58 or avoid using packages with use_2to3 in the setup parameters.\nI was having the same problem, pip==19.3.1\n", "I install setuptools==58It worked for me. pip install setuptools==58. The error coming from setuptools==69 that previously run on my device. and Finally saved me setuptools version 58 for this error.\n", "\"pip install setuptools==58\" worked for me. The setuptools version was 59 when I upgraded ubuntu to 22.04 and its python 3.10. I started a clean virtual environment for an existings django project. It had just two packages:\n`pip list\nPackage Version\n\npip 22.0.2\nsetuptools 59.6.0`\nThen I downgrade the setuptools to 58 as pip install setuptools==58.0.0. After that the pip install -r requirements.txt has not such error above.\n", "Upgrading MongoEngine to >= 0.20 would also fix the problem as Python2 support (hence use_2to3) was dropped in 0.20\n", "This worked for me.\npip install --upgrade pip setuptools==57.5.0 \n\n", "I'm working on Windows 11 and these solutions didn't work. I installed pybluez2 instead. Your python version >= 3.9 on Windows.\npip install pybluez2\n\n" ]

[ 152, 47, 2, 1, 1, 0 ]

[]

[]

[ "pip", "python", "python_3.x", "setuptools" ]

[ "The method str.ljust sounds like what you are interested in. This will pad out the input string with spaces to the length specified.\n>>> 'test'.ljust(10)\n'test '\n\nAnd if you wanted it to justify to the right side then you could also use the related function str.rjust.\n" ]

[ 0 ]

[]

[]

[ "python", "string", "string_formatting" ]

[ "You can use a merge, after reworking a bit Overall_Season_Avg :\ndf.merge(Overall_Season_Avg\n .set_index(['Team_Season_Code', 'Team'])\n [['OS', 'TS']].add_prefix('O'),\n left_on=['Opponent_Season_Code', 'Opponent'],\n right_index=True, how='left'\n )\n\nOutput:\n Season Date Team Team_Season_Code TS L Opponent Opponent_Season_Code OS OOS OTS\n0 2019 20181109 Abilene_Chr 1_2019 94 Home Arkansas_St 15_2019 73 65.242424 70.909091\n1 2019 20181115 Abilene_Chr 1_2019 67 Away Denver 82_2019 61 72.156250 74.031250\n2 2019 20181122 Abilene_Chr 1_2019 72 N Elon 70_2019 56 71.818182 73.636364\n3 2019 20181123 Abilene_Chr 1_2019 73 Away Pacific 224_2019 71 76.466667 78.333333\n4 2019 20181124 Abilene_Chr 1_2019 60 N UC_Riverside 306_2019 48 78.060606 79.545455\n\nmerging only on Opponent_Season_Code/Team_Season_Code:\ndf.merge(Overall_Season_Avg\n .set_index('Team_Season_Code')\n [['OS', 'TS']].add_prefix('O'),\n left_on=['Opponent_Season_Code'],\n right_index=True, how='left'\n )\n\nOutput:\n Season Date Team Team_Season_Code TS L Opponent Opponent_Season_Code OS OOS OTS\n0 2019 20181109 Abilene_Chr 1_2019 94 Home Arkansas_St 15_2019 73 65.242424 70.909091\n1 2019 20181115 Abilene_Chr 1_2019 67 Away Denver 82_2019 61 72.156250 74.031250\n2 2019 20181122 Abilene_Chr 1_2019 72 N Elon 70_2019 56 71.818182 73.636364\n3 2019 20181123 Abilene_Chr 1_2019 73 Away Pacific 224_2019 71 76.466667 78.333333\n4 2019 20181124 Abilene_Chr 1_2019 60 N UC_Riverside 306_2019 48 78.060606 79.545455\n\n", "df.merge(Overall_Season_Avg, on=['Team_Season_Code', 'Team'], how='left')\n\nand rename column's names\n\nor use transform instead agg when make Overall_Season_Avg.\nbut i don remain transform code becuz you don provide reproducible example\nmake simple and reproducible example plz\nhttps://stackoverflow.com/help/minimal-reproducible-example\n" ]

[ 2, 0 ]

[]

[]

[ "dataframe", "group_by", "numpy", "pandas", "python" ]

[ "I have trained a similar model based on a movie review dataset(positive or negative)\nmodel.predict(X_test_padded).all() > 0.5\n\nThe out of above will always be True so the if loop will execute all the time.\nInstead use\nmodel.predict(X_test_padded) > 0.5\n\nFor more details please refer to this gist. Thank You.\n" ]

[ 0 ]

[]

[]

[ "python", "tensorflow" ]

[ "TLDR: You can't\nIt is not possible to consistently get the path of a Jupyter notebook. See ipython issue #10123 for more information. I'll quote Carreau:\n\nHere are some reasons why the kernel (in this case IPython):\n\nmay not be running from single file\neven if one file, the file may not be a notebook.\neven if notebook, the notebook may not be on a filesystem.\neven if on a file system, it may not be on the same machine.\neven if on the same machine the path to the file may not make sens in the IPython context.\neven if it make sens the Jupyter Protocol has not been designed to do so. And we have no plan to change this abstraction in short or long term.\n\n\nYour hack works in most cases and is not too bad depending on the situation.\n", "if you can open it \nyou can use this function \n1-open your Jupyter notebook \n2- write this function\n3-it will print out the path\npwd\n\nif not\nnavigate to your python installation folder \nopen folder scripts and there you will find it.\nhope this may help others \n", "Update:\nI found this answer which solves the problem. The following command returns the folder path for both *.py and *.ipynb files.\nimport os\nos.path.abspath(\"\")\n\n\nI have a bit of a work around to solve this issue but I find that it is often helpful to have for non-notebook projects as well. In the same folder as your notebook create a file called \"base_fns.py\". Inside this file place the following code:\nimport os\n\ndef get_local_folder():\n return os.path.dirname(os.path.realpath(__file__))\n\nThen, you can get the path to the folder containing base_fns using:\nfrom base_fns import get_local_folder()\nrt_fldr = get_local_folder()\nprint(rt_fldr)\n\nA few notes:\n\nThis gives you the absolute path to the folder containing \"base_fns.py\", not your notebook. If your notebook and base_fns are in the same folder, then the absolute path to the folder for your notebook and base_fns will be the same.\nIf you place base_fns in a different folder, you will need to know the relative path to navigate from the base_fns folder to your notebook folder.\nIf you are working on a larger project with a folder structure, you can place base_fns.py in a known folder and then navigate around to find any other folders/files that you may require.\n\n", "use this in cell \n%%javascript\nIPython.notebook.kernel.execute('nb_name = \"' + IPython.notebook.notebook_name + '\"')\nprint(nb_name)\n\n", "What I am doing is not really beautifull but quite efficient. On VScode, I right click \"Copy Path\" on a sub folder in my working folder, in which I have my multiples Jupyter Notebook. I remove the end of the string and I obtain the aboslute path to the folder\nI after use in one of my jupyter notebook the command:\nos.chdir(r\"path_to_your_folder\") and this is it.\nNB: Since I work collaborately on repo cointaining Jupyter notebooks, this is the only ugly but efficient solution that I found.\n" ]

[ 35, 4, 3, 1, 0 ]

[ "I know this is an old post, but it seems the path to the notebook can be found using\nos.path.abspath(\"mynotebook.ipynb\")\nIt's hardcoding the name of the notebook, but that should be relatively easy to keep in sync.\n", "You can just use \"pwd\" which stands for print working directory.\nenter image description here\n", "You can right clic in the Jupyter notebook shortcut icon (in my case under Anaconda3 folder) and go to properties.\nThere you will find the full path to Jupyter: D:\\anaconda3\\python.exe d:\\anaconda3\\cwp.py d:\\anaconda3 d:\\anaconda3\\python.exe d:\\anaconda3\\Scripts\\jupyter-notebook-script.py \"%USERPROFILE%/\"\nProperties of Jupyter shortcut:\n\n" ]

[ -1, -4, -4 ]

[ "jupyter", "jupyter_notebook", "python" ]

[ "Are you sure you even tried?\nCheck the following out. Is this what you want?\ns='123 we wr 21'\ns.replace(' ' ,'@')\ns #123@we@wr@21\n\n" ]

[ 0 ]

[]

[]

[ "python" ]

[ "you need to install\n\n\"python-docx\"\n\nby\npip install python-docx \n\n", "Try pip freeze and check whether the module name is listed or not.\n", "\nUninstall docx if installed\npip uninstall docx\n\n\nInstall python-docx\npip install python-docx\n\n\nImport docx\nimport docx\n\n\nImport Document from docx\nfrom docx import Document\n\n\n\n" ]

[ 8, 0, 0 ]

[]

[]

[ "python", "python_docx" ]

[ "If you are using python 3x don't do pip install docx instead go for\npip install python-docx \n\nIt is compatible with python 3.x\nOfficial Documentation available here: https://pypi.org/project/python-docx/\n", "When want to use import docx, be sure to install python-docx, not docx.You can install the module by running pip install python-docx.\nThe installation name docx is for a different module\nHowever, \nwhen you are going to import the python-docx module, \nyou’ll need to run\nimport docx, not import python-docx.\nif still you want to use docx module then:\nFirst of all, you will need to make sure that the docx module is installed.\nIf not then simply run pip install docx. \nIf it shows '*requirement already satisfied*'\nthen the solution is :\n\nGo to the library to find docx.py file,\nyou'll need to go to directory where you installed python then \\Lib\\site-packages\\ and find docx.py file\nOpen docx.py file in text editor and find this code\nfrom exceptions import PendingDeprecationWarning\n\nReplace the above code with\n\ntry:\n from exceptions import PendingDeprecationWarning\nexcept ImportError:\n pass\n\n\nSave the file\nNow you can run import docx module in Python 3.x without any problem\n\n", "\nUninstall docx module with pip uninstall docx\nDownload python_docx-0.8.6-py2.py3-none-any.whl file from http://www.lfd.uci.edu/~gohlke/pythonlibs/\nRun pip install python_docx-0.8.6-py2.py3-none-any.whl to reinstall docx.\n\nThis solved the above import error smoothly for me.\n", "If you're using python 3.x, Make sure you have both python-docx & docx installed.\nInstalling python-docx :\npip install python-docx\n\nInstalling docx :\npip install docx\n\n", "You may be install docx, not python-docx \nYou can see this for install python-docx\nhttp://python-docx.readthedocs.io/en/latest/user/install.html#install\n", "\nIn Python 3 exceptions module was removed and all standard exceptions were moved to builtin module. Thus meaning that there is no more need to do explicit import of any standard exceptions.\n\ncopied from\n", "The problem, as was noted previously in comments, is the docx module was not compatible with Python 3. It was fixed in this pull-request on github: https://github.com/mikemaccana/python-docx/pull/67\nSince the exception is now built-in, the solution is to not import it.\ndocx.py\n@@ -27,7 +27,12 @@\n except ImportError:\n TAGS = {}\n\n-from exceptions import PendingDeprecationWarning\n+# Handle PendingDeprecationWarning causing an ImportError if using Python 3\n+try:\n+ from exceptions import PendingDeprecationWarning\n+except ImportError:\n+ pass\n+\n from warnings import warn\n\n import logging\n\n", "pip install python-docx\nthis worked for me, try installing with admin mode\n", "I had the same problem, but pip install python-docx worked for me, I'm using python 3.7.1\n", "You need to make it work with python3. \n sudo pip3 install python-docx\n\nThis installation worked for me in Python3 without any further additions. \n python3\n >> import docx\n\nPS: Note that the 'pip install python-docx' or apt-get python3-docx are not useful. \n", "I had the same problem, after installing docx module, got a bunch of errors regarding docx, .oxml and lxml...seems that for my case the package was installed in this folder:\nC:\\Program Files\\Python3.7\\Lib\\site-packages\nand I moved it one step back, to:\nC:\\Program Files\\Python3.7\\Lib\nand this solved the issue.\n", "Had faced similar issue and found a work around have posted answer aswell under similar question find its link :https://stackoverflow.com/a/74609166/17385292\n" ]

[ 277, 27, 19, 15, 10, 8, 3, 3, 1, 1, 0, 0 ]

[]

[]

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

[ "For spacy v2 models, the under-constrained requirement >=2.1.4 means >=2.1.4,<2.2.0 in effect, and as a result this model will only work with spacy v2.1.x.\nThere is no way to convert a v2 model to v3. You can either use the model with v2.1.x or retrain the model from scratch with your training data.\n", "pip3 install spacy==2.1.4\n\nThis can download required\n" ]

[ 3, 0 ]

[]

[]

[ "python", "spacy" ]

[ "You can pass the limit argument to readline for a file object which would have similar behavior of stopping on a max character or a newline. Example text file:\n01234567890123456789\n01234567890123456789\n\nwith open(\"test.txt\", \"r\") as f:\n while data := f.readline(8):\n print(\"line:\", data)\n\nOutputs:\nline: 01234567\nline: 89012345\nline: 6789\n\nline: 01234567\nline: 89012345\nline: 6789\n\n\n" ]

[ 1 ]

[]

[]

[ "c", "python" ]

[ "You can concat using the keys and names parameters, then reset_index:\n(pd.concat([df1, df2], keys=[1, 2], names=['class', None])\n .reset_index('class')\n)\n\nOutput:\n class id Name\n0 1 A01 ABC\n1 1 A02 PQR\n0 2 B05 XYZ\n1 2 B06 TUV\n\nOr without reset_index to get a MultiIndex:\npd.concat([df1, df2], keys=[1, 2], names=['class', None])\n\n id Name\nclass \n1 0 A01 ABC\n 1 A02 PQR\n2 0 B05 XYZ\n 1 B06 TUV\n\nhiding the \"duplicated\" class:\n(pd.concat([df1, df2], keys=[1, 2], names=['class', None])\n .reset_index('class')\n .assign(**{'class': lambda d: d['class'].mask(d['class'].duplicated(), '')})\n)\n\nOutput:\n class id Name\n0 1 A01 ABC\n1 A02 PQR\n0 2 B05 XYZ\n1 B06 TUV\n\n" ]

[ 1 ]

[]

[]

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

[ "Official documentation doesn't include value as a valid parameter\nhttps://discordpy.readthedocs.io/en/stable/api.html#embed\nclass discord.Embed(*, colour=None, color=None, title=None, type='rich', url=None, description=None, timestamp=None)\nYou are probably reading outdated documentation somewhere.\n" ]

[ 2 ]

[]

[]

[ "discord.py", "python" ]

[ "It is not recommended (or should not) call tkinter mainloop() inside __init__() as mainloop() is a blocking function. Therefore super().__init__() will not return until the root window is closed. Since the button is created after super().__init__(), so the root window is blank.\nRemove self.root.mainloop() inside A.__init__() and call tkinter mainloop() after you created instance of B():\nfrom tkinter import *\n\nclass A:\n def __init__(self):\n self.root = Tk()\n # don't call mainloop() here\n\nclass B(A):\n def __init__(self):\n super().__init__()\n self.my_button = Button(self.root,text=\"test\")\n self.my_button.pack()\n\nd = B()\nd.root.mainloop() # call mainloop() here\n\n" ]

[ 1 ]

[]

[]

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

[ "I'd say your biggest issue here is that recur1 isn't always guaranteed to return a generator. For example, suppose your stack calls into the else branch three times before calling into the if branch. In this case, the top three frames would be returning a generator received from the lower frame, but the lowest from would be returned from this:\nyield parents, parentChild\n\nSo, then, there is a really simple way you can fix this code to ensure that yield from works. Simply transform your return from a tuple to a generator-compatible type by enclosing it in a list:\nyield [(parents, parentChild)]\n\nThen, when you call yield from recur1(df=df, parents=parents, parentChild=parentChild, step=step+1) you'll always be working with something for which yeild from makes sense.\n" ]

[ 0 ]

[]

[]

[ "pandas", "python", "recursion" ]

[ "I was confusing the object with the list, changing the list to another name then add it to the function make it work\nnew_x = x + sprite.directions[new_direction][0]\n new_y = y + sprite.directions[new_direction][1]\n\n" ]

[ 0 ]

[]

[]

[ "function", "list", "python", "python_3.x" ]

[ "I would do something like this:\n# Using Spark 3.3.0\n\n# Dataset as per the question\ndata = [\n [1, '1234', 5678]\n, [2, 'Null', 1254]\n, [3, 'Null', 4567]\n, [4, 'Null', 4567] \n]\n\ncols = ['rowNum', 'Vehicle', 'Production']\n\n# Creating Dataframe\ndf = spark.createDataFrame(data, cols)\n\n\n# list comprehension to represent the distinct Production values on 'Null' Vehicles\nlist = [p.Production for p in df.select('Production').distinct().where(\"Vehicle == 'Null'\").collect()]\n\nlist\n\nThe output I am having is the following:\n\n" ]

[ 1 ]

[]

[]

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

[ "You can try using matplotlib. You can read image to numpy array by using mpimg.imread (documentation) from matplotlib, then you can use subplots (documentation) and for creating two columns for figures and finally imshow (documetation) to display images.\nimport matplotlib.pyplot as plt\nimport matplotlib.image as mpimg\nfrom matplotlib import rcParams\n\n%matplotlib inline\n\n# figure size in inches optional\nrcParams['figure.figsize'] = 11 ,8\n\n# read images\nimg_A = mpimg.imread('\\path\\to\\img_A.png')\nimg_B = mpimg.imread('\\path\\to\\img_B.png')\n\n# display images\nfig, ax = plt.subplots(1,2)\nax[0].imshow(img_A)\nax[1].imshow(img_B)\n\n", "matplotlib is a very good tool for plotting but I found it very heavy and slow for scenarios where I simply need a fast and easy way to display bigger number of images.\nTo solve this I'm using IPyPlot package:\nimport ipyplot\n\nipyplot.plot_images(images_list, max_images=20, img_width=150)\n\nYou would get a plot similar to this:\n\n", "Kind of late but i found out about this over here\nYou can do it via Hbox.\nHbox is a special container where you can add widgets. It aims at providing an efficient way to lay out, align and distribute space among items in a given space. Although its a bit cumbersome to define so many elements just to display 2 images you can add a lot more functionality like sliders, dropdown menus as well as buttons making your Jupiter notebook more interactive.\nimport IPython.display as display\nimport ipywidgets as widgets\n\nimg1=open('path_to_image','rb').read()\nwi1 = widgets.Image(value=img1, format='jpg', width=300, height=400)\nimg2=open('path_to_image','rb').read()\nwi2 = widgets.Image(value=img2, format='jpg', width=300, height=400)\na=[wi1,wi2]\nwid=widgets.HBox(a)\ndisplay.display(wid)\n\n", "This easy solution worked great for me:\nfrom IPython.display import Video, Image, HTML, display\n\nimage_path1 = \"/myfolder/my_img1.jpg\"\nimage_path2 = \"/myfolder/my_img2.jpg\"\n\n\nHTML(f\"\"\"\n <div class=\"row\">\n <img src={image_path1} style=\"width:30%\"> </img>\n <img src={image_path1} style=\"width:53.2%\"> </img>\n </div>\n \"\"\")\n\nI put in different widths for if you have a portrait and a landscape picture, but that is up to you depending on the images and the aspect ratios.\n", "For some guys who may want to place an image and a text snippet side by side(adapted from this answer):\nimport base64\nfrom IPython.display import HTML, display\nb64_img = base64.b64encode(open('./path', 'rb').read()).decode('ascii')\ntxt = \"sjfa;\\nakd;f\\nsdfa\"\ndisplay(HTML(f\"\"\"\n <div class=\"row\">\n <img style=\"float:left;margin-right:30px;\" src=\"data:image/jpeg;base64,{b64_img}\" width=\"400\" height=\"300\" />\n <div style=\"font-size:10px;white-space:pre;\">{txt}</div>\n </div>\n \"\"\"))\n\n", "It should be like this:\nfrom IPython.display import Image, HTML, display\n\nimg_A = '\\path\\to\\img_A.png'\nimg_B = '\\path\\to\\img_B.png'\n\ndisplay(HTML(\"<table><tr><td><img src={0}></td><td><img src={1}></td></tr></table>\".format(image_A,img_B)))\n\nYou mistook the variable name as variable itself.\n" ]

[ 21, 13, 3, 1, 0, 0 ]

[]

[]

[ "image", "ipython", "jupyter_notebook", "python" ]

[]

[]

[ "Very little context information on this post, so I'll help out with fixes that change as little as possible.\nFirst of all, to fix your code you need a place to save the changes that you've made. A variable that only exists in a function is deleted at the end of that function.\nNow usually you'd give more information regarding your use case, and I'd give you the best choice and why. It could be to store data in a JSON file, or a Database, or an in memory object that would serve the purpose best.\nHere there's no info so we'll just make a variable. Keep in mind that this variable will be reset every time you restart the shell. So if your API is not \"always on\" then this may no work.\nfrom fastapi import APIRouter, Request, Response\nfrom fastapi.templating import Jinja2Templates\n\nVARIABLE = None\nAPI_URL = \"my_domain.com/api\"\n\ntemplates = Jinja2Templates(directory=\"templates\")\nrouter = APIRouter()\n\[email protected](\"/my-first-view\")\nasync def function1(request: Request) -> Response:\n \"\"\"Display the home page.\"\"\"\n my_variable = value\n return templates.TemplateResponse(\n \"home.jinja\",\n context={\n \"complete_url\": f\"{API_URL}/my-second-view?my_variable={VARIABLE}\"\n },\n )\n\[email protected](\"/my-second-view\")\nasync def function2(request: Request, my_variable: str) -> Response:\n \"\"\"Display the variable processing page.\"\"\"\n\n VARIABLE = my_variable\n \n return templates.TemplateResponse(\n \"page.jinja\"\n )\n\nAs far as the template goes, you haven't shared url_for, but I suppose it just creates the path. I'd just make home.jinja as follows.\n<a href=\"{{ complete_url }}\" title=\"connect\">Connect</a>\n\nAlso I've replaced the url_for call with a simple f-string.\nDepending on what you pass in your VARIABLE you may need to encode it.\nFor an example of that, please look at the following thread: How to urlencode a querystring in Python?\n" ]

[ -1 ]

[ "fastapi", "python" ]

[ "This loop will run forever until you set the flag:\n def run(self):\n while not self.stopped():\n sleep(1)\n print('Test')\n\nYou don't actually need an event. A simple Boolean will do.\nFOLLOWUP\nHere's an example based on your code that shows how this works:\nimport threading\nfrom time import sleep\n\nclass StoppableThread(threading.Thread):\n def __init__(self, caller=None):\n super(StoppableThread, self).__init__()\n self._stop_event = False\n self.caller = caller\n\n def stop(self):\n self._stop_event = True\n\n def stopped(self):\n return self._stop_event\n\n def run(self) -> None:\n while not self.stopped():\n sleep(1)\n print('Test')\n print(\"exited\")\n\nthread = StoppableThread(caller=None)\nthread.start()\nsleep(5)\nthread.stop()\nsleep(1)\nprint(\"program ending\")\n\n" ]

[ 1 ]

[]

[]

[ "multithreading", "python", "python_3.x", "tkinter" ]

[ "Assuming that you want to distribute the data across the available GPUs (If you have batch size of 16, and 2 GPUs, you might be looking providing the 8 samples to each of the GPUs), and not really spread out the parts of models across difference GPU's. This can be done as follows:\nIf you want to use all the available GPUs:\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n\nmodel = CreateModel()\n\nmodel= nn.DataParallel(model)\nmodel.to(device)\n\nIf you want to use specific GPUs:\n(For example, using 2 out of 4 GPUs)\ndevice = torch.device(\"cuda:1,3\" if torch.cuda.is_available() else \"cpu\") ## specify the GPU id's, GPU id's start from 0.\n\nmodel = CreateModel()\n\nmodel= nn.DataParallel(model,device_ids = [1, 3])\nmodel.to(device)\n\nTo use the specific GPU's by setting OS environment variable:\nBefore executing the program, set CUDA_VISIBLE_DEVICES variable as follows:\nexport CUDA_VISIBLE_DEVICES=1,3 (Assuming you want to select 2nd and 4th GPU)\nThen, within program, you can just use DataParallel() as though you want to use all the GPUs. (similar to 1st case). Here the GPUs available for the program is restricted by the OS environment variable.\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n\nmodel = CreateModel()\n\nmodel= nn.DataParallel(model)\nmodel.to(device)\n\nIn all of these cases, the data has to be mapped to the device.\nIf X and y are the data:\nX.to(device)\ny.to(device)\n\n\n", "Using multi-GPUs is as simply as wrapping a model in DataParallel and increasing the batch size. Check these two tutorials for a quick start: \n\nMulti-GPU Examples\nData Parallelism\n\n", "Another option would be to use some helper libraries for PyTorch:\nPyTorch Ignite library Distributed GPU training\nIn there there is a concept of context manager for distributed configuration on:\n\nnccl - torch native distributed configuration on multiple GPUs\nxla-tpu - TPUs distributed configuration\n\nPyTorch Lightning Multi-GPU training\nThis is of possible the best option IMHO to train on CPU/GPU/TPU without changing your original PyTorch code.\nWorth cheking Catalyst for similar distributed GPU options.\n", "When I ran naiveinception_googlenet, the above methods didn't work for me. The following method solved my problem.\nimport os\nos.environ[\"CUDA_DEVICE_ORDER\"] = \"PCI_BUS_ID\"\nos.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0,3\" # specify which GPU(s) to be used\n\n", "If you want to run your code only on specific GPUs (e.g. only on GPU id 2 and 3), then you can specify that using the CUDA_VISIBLE_DEVICES=2,3 variable when triggering the python code from terminal.\nCUDA_VISIBLE_DEVICES=2,3 python lstm_demo_example.py --epochs=30 --lr=0.001\n\nand inside the code, leave it as:\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else 'cpu')\nmodel = LSTMModel()\nmodel = nn.DataParallel(model)\nmodel = model.to(device)\n\nSource : https://glassboxmedicine.com/2020/03/04/multi-gpu-training-in-pytorch-data-and-model-parallelism/\n", "In 2022, PyTorch says:\n\nIt is recommended to use DistributedDataParallel, instead of this class, to do multi-GPU training, even if there is only a single node. See: Use nn.parallel.DistributedDataParallel instead of multiprocessing or nn.DataParallel and Distributed Data Parallel.\n\nin https://pytorch.org/docs/stable/generated/torch.nn.DataParallel.html#torch.nn.DataParallel\nThus, seems that we should use DistributedDataParallel, not DataParallel.\n" ]

[ 58, 22, 5, 1, 1, 1 ]

[]

[]

[ "python", "pytorch" ]

[ "Ohh, I finally solved the problem. Need to set hash seed on my laptop using this method: https://gerrychain.readthedocs.io/en/latest/topics/reproducibility.html#set-pythonhashseed-0\nThis solution is mentioned in optuna for reproducing pruning behaviour: https://optuna.readthedocs.io/en/stable/reference/generated/optuna.pruners.HyperbandPruner.html\n" ]

[ 0 ]

[]

[]

[ "lightgbm", "optuna", "python", "replicate" ]

[ "What about using (?<=[\\d.])(?=[^\\d.\\n])|(?<=[^\\d.])(?=[\\d.]) to detect alternating numbers/non-numbers?\ntext = '''Abu Dhabi1.90Morrisville Samp Army1.90\nDeccan Gladiators1.40The Chennai Braves2.87\nBangla Tigers1.90Delhi Bulls1.90\nNew Zealand1.68India2.15\nAustralia1.09Draw14.00West Indies13.00\nSri Lanka1.51Afghanistan2.50\nTas Tigers1.28South Australia3.50'''\n\nprint(re.sub('(?<=[\\d.])(?=[^\\d.\\n])|(?<=[^\\d.])(?=[\\d.])', ', ', text))\n\nOutput:\nAbu Dhabi, 1.90, Morrisville Samp Army, 1.90\nDeccan Gladiators, 1.40, The Chennai Braves, 2.87\nBangla Tigers, 1.90, Delhi Bulls, 1.90\nNew Zealand, 1.68, India, 2.15\nAustralia, 1.09, Draw, 14.00, West Indies, 13.00\nSri Lanka, 1.51, Afghanistan, 2.50\nTas Tigers, 1.28, South Australia, 3.50\n\nregex demo\n", "You can use an alternation pattern to match either consecutive alphabets and spaces followed by a digit, or consecutive digits and dots followed by an alphabet, and substitute the match with itself followed by a comma and a space:\nimport re\n\ns = '''Abu Dhabi1.90Morrisville Samp Army1.90\nDeccan Gladiators1.40The Chennai Braves2.87\nBangla Tigers1.90Delhi Bulls1.90\nNew Zealand1.68India2.15\nAustralia1.09Draw14.00West Indies13.00\nSri Lanka1.51Afghanistan2.50\nTas Tigers1.28South Australia3.50'''\n\nprint(re.sub(r'([A-Za-z ]+(?=\\d)|[\\d.]+(?=[A-Za-z]))', r'\\1, ', s))\n\nThis outputs:\nAbu Dhabi, 1.90, Morrisville Samp Army, 1.90\nDeccan Gladiators, 1.40, The Chennai Braves, 2.87\nBangla Tigers, 1.90, Delhi Bulls, 1.90\nNew Zealand, 1.68, India, 2.15\nAustralia, 1.09, Draw, 14.00, West Indies, 13.00\nSri Lanka, 1.51, Afghanistan, 2.50\nTas Tigers, 1.28, South Australia, 3.50\n\nDemo: https://replit.com/@blhsing/NewInternationalGravity\n" ]

[ 0, 0 ]

[]

[]

[ "data_cleaning", "python", "strsplit", "web_scraping" ]

[ "No, it's not right. Your iText function doesn't have any inputs, so it shouldn't have any parameters. Next, in your test function, you need to CALL iText and check what it returns:\ndef iText():\n url = requests.get(\"http://nlp.cs.aueb.gr/software_and_datasets/lingspam_public.tar.gz\")\n text = url[-1].strip() \n label = url[-1].strip() \n data_frame = pd.DataFrame(text, label)\n return text, data_frame\n\ndef test_coba():\n text, data_frame = iText()\n assert text, data_frame\n\nHowever, if you're fetching a tarball, what do you think url[-1].strip() is going to do?\n" ]

[ 0 ]

[]

[]

[ "pytest", "python" ]

[ "how about\nfor f, c in zip (optimized_lr.feature_names_in_,tuned.coef_[0]):\n print(f, c)\n\n" ]

[ 0 ]

[]

[]

[ "logistic_regression", "pycaret", "python", "regression" ]

[]

[]

[ "If your code is in the same directory as this file, you can simply do photo = PhotoImage(file = \"./TestButton.png\")\n" ]

[ -2 ]

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

[ "refrence should have CusOrder instance and super should call before the creation as CusOrder object should be created first.\n def save(self,*args,**kwrgs):\n instance = super(CusOrder,self).save(*args,**kwrgs)\n p_instance = ProductOut.objects.create(\n stock_out = self.qty,\n sell_price = self.sell_price,\n product = self.product.first()\n )\n p_instance.refrence.add(instance)\n p_instance.save()\n \n\nBest way is to use Django Signals, In above case specifically use post_save. Django Signals- master pre_save and post_save \n" ]

[ 0 ]

[]

[]

[ "django", "django_models", "django_modeltranslation", "python" ]

[ "This should work:\nFROM python:3.7-slim-buster\n\n# setup dependencies\nRUN apt-get update\nRUN apt-get install xz-utils\nRUN apt-get -y install curl\n\n# Download latest nodejs binary\nRUN curl https://nodejs.org/dist/v14.15.4/node-v14.15.4-linux-x64.tar.xz -O\n\n# Extract & install\nRUN tar -xf node-v14.15.4-linux-x64.tar.xz\nRUN ln -s /node-v14.15.4-linux-x64/bin/node /usr/local/bin/node\nRUN ln -s /node-v14.15.4-linux-x64/bin/npm /usr/local/bin/npm\nRUN ln -s /node-v14.15.4-linux-x64/bin/npx /usr/local/bin/npx\n\n\nTo run node start it with docker run -it <containerName> /bin/bash\nThen node, npm and npx are available\n", "npm globally packages need to add links if you want to use it as command.\nFROM python:3.7-slim-buster\nENV NODE_VERSION 14.15.4\n\n#if build in `china`, debian mirrors, npm registry change to china source\nARG AREA=london\n\nRUN set -ex \\\n && if [ 'china' = \"$AREA\" ] ; then \\\n sed -i \"s@http://deb.debian.org@https://mirrors.aliyun.com@g\" /etc/apt/sources.list; \\\n fi \\\n && apt-get update \\\n && apt-get install -y git xz-utils curl \\\n\n # install node\n && curl \"https://nodejs.org/dist/v$NODE_VERSION/node-v$NODE_VERSION-linux-x64.tar.xz\" -O \\\n && tar -xf \"node-v$NODE_VERSION-linux-x64.tar.xz\" \\\n && ln -s \"/node-v$NODE_VERSION-linux-x64/bin/node\" /usr/local/bin/node \\\n && ln -s \"/node-v$NODE_VERSION-linux-x64/bin/npm\" /usr/local/bin/npm \\\n && ln -s \"/node-v$NODE_VERSION-linux-x64/bin/npx\" /usr/local/bin/npx \\\n\n # npm install bump, openapi-generator\n && if [ 'china' = \"$AREA\" ] ; then \\\n npm config set registry https://registry.npm.taobao.org/; \\\n fi \\\n && npm install -g [email protected] \\\n && ln -s \"/node-v$NODE_VERSION-linux-x64/bin/bump\" /usr/local/bin/bump \\ \n\n # clear\n && npm cache clean --force \\\n && rm -rf /var/lib/apt/lists/* \\\n && rm -f \"/node-v$NODE_VERSION-linux-x64.tar.xz\" \\\n && apt-get clean \\\n && apt-get autoremove\n\n", "Just use the official installation for Debian from here :\nRUN curl -fsSL https://deb.nodesource.com/setup_19.x | bash - &&\\\n apt-get install -y nodejs\n\n" ]

[ 12, 2, 1 ]

[]

[]

[ "docker", "dockerfile", "node.js", "python" ]

[ "Typo in web.service.ts. Forgot a slash after /reviews/. Second a typo on this.reviewIDw.\nSo in your error you see the value of reviewID is undefined. This can bring this CORS error, too. Then the route was not found.\nGreetings Florian\n" ]

[ 0 ]

[]

[]

[ "angular", "python", "typescript" ]

[ "m5.util.addToPath('../../') is missing. This is used to add the common scripts to the path to your directory from where you are instantiating the simulation.\n" ]

[ 0 ]

[]

[]

[ "c++", "gcc", "gem5", "python", "riscv" ]

[ "Actually, you can import a module with an invalid name. But you'll need to use imp for that, e.g. assuming file is named models.admin.py, you could do\nimport imp\nwith open('models.admin.py', 'rb') as fp:\n models_admin = imp.load_module(\n 'models_admin', fp, 'models.admin.py',\n ('.py', 'rb', imp.PY_SOURCE)\n )\n\nBut read the docs on imp.find_module and imp.load_module before you start using it.\n", "If you really want to, you can import a module with an unusual filename (e.g., a filename containing a '.' before the '.py') using the imp module:\n>>> import imp\n>>> a_b = imp.load_source('a.b', 'a.b.py')\n>>> a_b.x\n\"I was defined in a.b.py!\"\n\nHowever, that's generally a bad idea. It's more likely that you're trying to use packages, in which case you should create a directory named \"a\", containing a file named \"b.py\"; and then \"import a.b\" will load a/b.py.\n", "The file is called models/admin.py. (Source)\nThat is, it should be called admin.py in a directory called models.\nThen you can import using from models.admin import *, assuming that it is in your Python path.\n", "Like below\nAssume dir structure is like this:\nC:.\n│ script.py\n│ \n└───Parent\n └───Child\n ├───1.1\n │ main.py\n │ \n └───1.2\n\n**assume you want to import main.py in script.py **\nyour main.py looks like below\ndef my_function():\n print(\"Hello from a function\")\n\nyour script.py looks like below\nfrom os import path\nimport importlib\nfrom os.path import dirname\nimport sys\nimport importlib.util\n\n\ndef getPath():\n # your logic to get to the path\n return path.join(dirname(__file__),'Parent','Child','1.1','main.py')\n\nfile_path = getPath() \nmodule_name = 'main'\n\nspec = importlib.util.spec_from_file_location(module_name, file_path)\nmodule = importlib.util.module_from_spec(spec)\nspec.loader.exec_module(module)\n\n#call functions like this\nmodule.my_function()\n\nCheck out this gist\n", "No, you can't import a python file as a module if its name contains a period (or a question mark, or exclamation mark, etc). A python module's name (not including the .py) must be a valid python name (ie can be used as a variable name).\n", "In my case, I am using grafanalib, and the filename has to be xx.dashboard.py based on the doc. However, I do want to import this file to simplify the uploading step.\nI got warning when I use import imp:\n\nthe imp module is deprecated in favour of importlib and slated for removal in Python 3.12; see the module's documentation for alternative uses\n\nHere is the simple demo using importlib and pathlib:\nfoo.bar.py and main.py are in the same foler.\n# foo.bar.py\n\nnum = 42\n\n# main.py\n\nimport importlib.machinery\nimport pathlib\n\nmodule = importlib.machinery.SourceFileLoader(\n \"foo_bar\",\n pathlib.Path(__file__).parent.joinpath(\"foo.bar.py\").resolve().as_posix(),\n).load_module()\nprint(module.num) # 42\n\n" ]

[ 40, 15, 4, 4, 3, 0 ]

[ "You are not referencing files in the import statement, you are referencing modules and packages.\nPlease read the docs, they are very clear on that matter.\nAnyway, since you are using django, the usual approach won't work. If you want to keep models in separate files, rather than in models.py, you have to take extra steps, outlined, for example, here.\nEdit:\nWell, I don't really know what the questioneer means when he mentions admin and whether or not it is related to the admin interface of django. My points still stand.\n" ]

[ -1 ]

[ "import", "module", "package", "python", "python_import" ]

[ "You need to specify the appropriate Default Renderer (or Renderers, if you want to visualize it in the Notebook and also when exporting to PDF using the File-->Download as-->PDF via Latex (.pdf) option you mentioned).\nI have been struggling with this myself for some hours too, but the setup that ended up working for me is the following:\nimport plotly.io as pio\npio.renderers.default = \"notebook+pdf\" # Renderer for Notebook and HTML exports + Renderer for PDF exports\n# init_notebook_mode(connected=True) # Do not include this line because it may not work\n\nNote that you can concatenate as many Renderers as you want using the + symbol, and Plotly will magically know when to use each of them.\n", "I think because plotly graphs are svg objects and generated by javascript, I dont have export to PDF working in my jupyter notebook, so I was unable to check and confirm my answer.\nPlotly offline does not have show as image, you can use plotly online to do this, its free to generate graphs, \nYou need to create an online account, also you need to paste the username and API key from plotly website (API key can be found in settings).\n\nNote: please check in plotly if the plots are shared in public or private, I am not responsible for your plots becoming public.\n\nAnyway this will give you an image output of the graph, and you can export it to PDF\nCode:\nimport plotly\nimport plotly.graph_objs as go\n\nplotly.plotly.sign_in('<<username goes here>>', '<<api key goes here>>')\ntrace = go.Bar(x=[2, 4, 6], y= [10, 12, 15])\ndata = [trace]\nlayout = go.Layout(title='A Simple Plot', width=800, height=640)\nfig = go.Figure(data=data, layout=layout)\n\nplotly.plotly.image.save_as(fig, filename='a-simple-plot.png')\n\nfrom IPython.display import Image\nImage('a-simple-plot.png')\n\n", "A bit easier solution is to use image_bytes = fig.to_image(format='png') and than display using Image(image_bytes), but firstly you should install orca, and pip3 install psutil requests \nexample: \nfig = go.Figure()\n\"\"\" here goes some code to draw \"\"\"\n\nimage_bytes = fig.to_image(format='png', , width=1200, height=700, scale=1) # you can use other formats as well (like 'svg','jpeg','pdf')\n\n#instead of using fig.show()\nfrom IPython.display import Image\nImage(img_bytes)\n\nYou can read more here\nThan you can convert it with File -> Download as -> PDF or using terminal jupyter nbconvert --to pdf <notebook_name>.ipynb\n", "I don't have a solution for the exact original problem above. However, if you wish to consider the .html format, here is a nice solution that worked for me. After all, my goal was just to share the notebook with people who didn't have jupyter installed.\nThe conversion to .html is performed with plotlyhtmlexporter.\nHere is a piece of code you can copy-paste:\n pip install plotlyhtmlexporter\n jupyter nbconvert --to plotlyhtml mynotebook.ipynb\n\nYou might then want to try and save (print) the .html from your browser as a .pdf, but I think it would be equivalent to just printing the original notebook to .pdf. As I say, in my case, having a jupyter-independent .html file was enough.\n", "Just use this and download the notebook as PDF via HTML. Also you need to pip install kaleido first.\n import plotly.io as pio\n pio.kaleido.scope.default_format = \"png\"\n\n" ]

[ 6, 2, 1, 1, 0 ]

[]

[]

[ "jupyter_notebook", "pdf", "plotly", "python" ]

[ "I could not find supporting documentation, but I believe image_dataset_from_directory is taking the end portion of the dataset as the validation split. shuffle is now set to True by default, so the dataset is shuffled before training, to avoid using only some classes for the validation split.\nThe split done by image_dataset_from_directory only relates to the training process. If you need a (highly recommended) test split, you should split your data beforehand into training and testing. Then, image_dataset_from_directory will split your training data into training and validation.\nI usually take a smaller percent (10%) for the in-training validation, and split the original dataset 80% training, 20% testing.\nWith these values, the final splits (from the initial dataset size) are:\n\n80% training:\n\n72% training (used to adjust the weights in the network)\n8% in-training validation (used only to check the metrics of the model after each epoch)\n\n\n20% testing (never seen by the training process at all)\n\nThere is additional information how to split data in your directories in this question: Keras split train test set when using ImageDataGenerator\n", "For splitting into train and validation maybe you can do smth like that.\nThe main point is to keep the same seed.\ntrain_ds = tf.keras.preprocessing.image_dataset_from_directory(\n directory,\n label_mode='categorical',\n validation_split=0.2,\n subset=\"training\",\n seed=1337,\n color_mode=\"grayscale\",\n image_size=image_size,\n batch_size=batch_size,\n)\nval_ds = tf.keras.preprocessing.image_dataset_from_directory(\n directory,\n validation_split=0.2,\n subset=\"validation\",\n label_mode='categorical',\n seed=1337,\n color_mode=\"grayscale\",\n image_size=image_size,\n batch_size=batch_size,\n)\n\nis taken from:\nhttps://keras.io/examples/vision/image_classification_from_scratch/\n", "You almost got the answer. The key is to use .take() and .skip() to further split the validation set into 2 datasets -- one for validation and the other for test. If I use your example, then you need to execute the following lines of codes. Let's assume that you need 70% for training set, 10% for validation set, and 20% for test set. For the sake of completeness, I am also including the step to generate the training set. Let's also assign a few basic variables that must be same when first splitting the entire data set into training and validation sets.\nseed_train_validation = 1 # Must be same for train_ds and val_ds\nshuffle_value = True\nvalidation_split = 0.3\n\ntrain_ds = tf.keras.utils.image_dataset_from_directory(\ndirectory ='etlcdb/ETL9G_IMG/',\nimage_size = (128, 127),\nvalidation_split = validation_split,\nsubset = \"training\",\nseed = seed_train_validation,\ncolor_mode = 'grayscale',\nshuffle = shuffle_value)\n\nval_ds = tf.keras.utils.image_dataset_from_directory(\ndirectory ='etlcdb/ETL9G_IMG/',\nimage_size = (128, 127),\nvalidation_split = validation_split,\nsubset = \"validation\",\nseed = seed_train_validation,\ncolor_mode = 'grayscale',\nshuffle = shuffle_value)\n\n\nNext, determine how many batches of data are available in the validation set using tf.data.experimental.cardinality, and then move the two-third of them (2/3 of 30% = 20%) to a test set as follows. Note that the default value of batch_size is 32 (re: documentation).\nval_batches = tf.data.experimental.cardinality(val_ds)\ntest_ds = val_ds.take((2*val_batches) // 3)\nval_ds = val_ds.skip((2*val_batches) // 3)\n\nAll the three datasets (train_ds, val_ds, and test_ds) yield batches of images together with labels inferred from the directory structure. So, you are good to go from here.\n" ]

[ 3, 1, 1 ]

[]

[]

[ "keras", "python", "tensorflow" ]

[ "In python3, you can just ignore the brackets.\nIn other words, class Car is equivalent to class Car() and the former one is more pythonic. However, In python2, you have to use class Car(object) to suit python2's requirement.\n" ]

[ 1 ]

[]

[]

[ "python", "python_3.x" ]

[ "You can Create a User like this. Django uses hashing technique to store users' passwords with some salt. If You are creating a user you have to call set_password method to store the password.\nfrom django.contrib.auth.models import User\n\nuser = User()\nuser.username = request.POST.get('username')\nuser.set_password(request.POST.get('password'))\nuser.save()\n\n", "First of all, there is no better tutorial than the original one, it will help you understand many concepts that are not quite well explained in most. No better place to start and to continue growing by further exploring the documentation.\nI must say, there are many flaws in your code and project design. Lets start with the database schema you shared. I can see that you don't have a custom user model, instead you have four user models, three of them to represent groups.\nIn your views, use the 'snake_case' name convention, it is a good practice. Also, to handle input data and validation Django Forms are the way to do it. Lastly, it is not necessary to have three different templates to render based on the group.\nTo the code...It is all inside an app called 'core'\nedit: updated views.py with login required decorator\nFirst, Create the Custom User Model:\nmodels.py\nfrom django.db import models\nfrom django.contrib.auth.models import AbstractBaseUser, BaseUserManager, PermissionsMixin\n\n# Create your models here.\nGENDER_CHOICES = [\n ('F', 'Female'),\n ('M', 'Male'),\n]\nBLOOD_GROUP_CHOICES = [\n ('A', 'A'),\n ('B', 'B'),\n ('O', 'O'),\n ('AB', 'AB'),\n]\n\nclass UserManager(BaseUserManager):\n def create_user(self, email, password=None, **kwargs):\n if not email:\n raise ValueError('Users must have an email address')\n\n user = self.model(email=self.normalize_email(email), **kwargs)\n user.set_password(password)\n user.save(using=self._db)\n return user \n\n def create_superuser(self, email, password=None):\n user = self.create_user(email, password=password)\n user.is_staff = True\n user.is_superuser = True\n user.save(using=self._db)\n return user\n\nclass User(AbstractBaseUser, PermissionsMixin): \n email = models.CharField(max_length=128, unique=True)\n name = models.CharField(max_length=128)\n gender = models.CharField(max_length=10, choices=GENDER_CHOICES)\n phone_number = models.CharField(max_length=128, blank=True)\n address = models.CharField(max_length=128)\n birth_date = models.DateField()\n blood_group = models.CharField(max_length=2, choices=BLOOD_GROUP_CHOICES)\n is_active = models.BooleanField(default=True)\n is_staff = models.BooleanField(default=True)\n\n objects = UserManager()\n \n USERNAME_FIELD = 'email'\n\nremember to add the model in settings.py:\nAUTH_USER_MODEL = 'core.User'\n\nforms.py\nfrom django import forms\nfrom django.core.exceptions import ValidationError\nfrom datetime import datetime\nfrom django.contrib.auth import get_user_model\n\nGENDER_CHOICES = [\n ('F', 'Female'),\n ('M', 'Male'),\n]\nBLOOD_GROUP_CHOICES = [\n ('A', 'A'),\n ('B', 'B'),\n ('O', 'O'),\n ('AB', 'AB'),\n]\n\nclass UserRegisterForm(forms.ModelForm): \n password = forms.CharField(label='Password', widget=forms.PasswordInput)\n password_confirmation = forms.CharField(label='Password confirmation', widget=forms.PasswordInput)\n\n class Meta:\n model = get_user_model()\n fields = ('email', 'name', 'gender', 'phone_number', 'address', 'birth_date', 'blood_group')\n\n def clean_password_confirmation(self):\n # Check that the two password entries match\n password1 = self.cleaned_data.get(\"password\")\n password2 = self.cleaned_data.get(\"password_confirmation\")\n if password1 and password2 and password1 != password2:\n raise ValidationError(\"Passwords don't match\")\n return password2\n \n def save(self, commit=True):\n # Save the provided password in hashed format\n user = super().save(commit=False)\n user.set_password(self.cleaned_data[\"password\"])\n user.last_login = datetime.now()\n if commit:\n user.save()\n return user\n\nclass UserSignInForm(forms.Form):\n email = forms.EmailField(required=True)\n password = forms.CharField(widget=forms.PasswordInput())\n\n def save(self, commit=True):\n # Save the provided password in hashed format\n user = super().save(commit=False)\n user.last_login = datetime.now()\n if commit:\n user.save()\n return user\n\nCreate the views using forms and setup the URLs:\nviews.py\nfrom django.shortcuts import render, redirect\nfrom django.contrib import messages\nfrom django.contrib.auth import authenticate, login, logout\nfrom django.contrib.auth.decorators import login_required\n\nfrom core.forms import UserRegisterForm, UserSignInForm\n\n# Create your views here.\ndef register(request):\n if request.method == 'POST':\n form = UserRegisterForm(request.POST)\n if form.is_valid():\n form.save()\n messages.success(request, 'Successful registration')\n return redirect('/user/index/')\n else:\n messages.error(request, 'Please fill the fields correctly')\n else:\n form = UserRegisterForm()\n\n context = {\n 'form': form\n }\n\n return render(request, 'register.html', context)\n\ndef user_login(request):\n if request.method == 'POST':\n form = UserSignInForm(request.POST)\n if form.is_valid():\n email = form.cleaned_data['email']\n password = form.cleaned_data['password']\n user = authenticate(request, email=email, password=password)\n if user is not None:\n login(request, user)\n qs = user.groups.values_list('name',flat = True)\n groups = l_as_list = list(qs)\n messages.success(request, 'Successfull login')\n return render(request, 'index.html', {'groups': groups})\n else:\n messages.error(request, 'User not found')\n else:\n form = UserSignInForm()\n\n context = {\n 'form': form\n }\n return render(request, 'login.html', context)\n\ndef user_logout(request):\n logout(request)\n return redirect('/user/login/')\n\n@login_required(login_url='/user/login/')\ndef index(request):\n return render(request, 'index.html', {})\n\nurls.py\nfrom django.urls import path\nfrom core import views\n\napp_name = 'core'\n\nurlpatterns = [\n path('index/', views.index, name='index'),\n path('register/', views.register, name='user-register'),\n path('login/', views.user_login, name='user-login'),\n path('logout/', views.user_logout, name='user-logout'),\n]\n\nCreate templates using forms and messages:\nlogin.html\n{% extends 'base.html' %}\n\n{% block content %}\n {% if messages %}\n <ul class=\"messages\">\n {% for message in messages %}\n <li{% if message.tags %} class=\"{{ message.tags }}\"{% endif %}>{{ message }}</li>\n {% endfor %}\n </ul>\n {% endif %}\n\n <form method=\"POST\" action=\"{% url 'core:user-login' %}\">\n {% csrf_token %}\n <table>\n {{ form }}\n </table>\n <input type=\"submit\" value=\"Submit\">\n </form>\n{% endblock %}\n\nregister.html\n{% extends 'base.html' %}\n\n{% block content %}\n {% if messages %}\n <ul class=\"messages\">\n {% for message in messages %}\n <li{% if message.tags %} class=\"{{ message.tags }}\"{% endif %}>{{ message }}</li>\n {% endfor %}\n </ul>\n {% endif %}\n\n <form method=\"post\" action=\"{% url 'core:user-register' %}\">\n {% csrf_token %}\n <table>\n {{ form }}\n </table>\n <button type=\"submit\">Register</button>\n </form>\n{% endblock %}\n\nindex.html\n{% extends 'base.html' %}\n\n{% block content %}\n {% if messages %}\n <ul class=\"messages\">\n {% for message in messages %}\n <li{% if message.tags %} class=\"{{ message.tags }}\"{% endif %}>{{ message }}</li>\n {% endfor %}\n </ul>\n {% endif %}\n\n {% if 'doctor' in groups %}\n <p>I am a doctor</p>\n {% elif 'patient' in groups %}\n <p>I am a patient</p>\n {% elif 'receptionist' in groups %}\n <p>I am a recepcionist</p>\n {% endif %}\n <a href=\"{% url 'core:user-logout' %}\">Logout</a>\n{% endblock %}\n\n" ]

[ 0, 0 ]

[]

[]

[ "authentication", "django", "python", "sqlite" ]

[ "Use GroupBy.cumcount with ascending=False for counter in descending order and pivoting by 4 columns, then use rename - add keys to dictionary for rename if 3 or 4 duplicated decisions:\ndf = (df.assign(g = df.groupby(['id','date']).cumcount(ascending=False))\n .pivot(['id','date'], 'g', 'decision')\n .reindex(columns=range(4))\n .fillna(0)\n .rename(columns={0:'CR',1:'Principal',2:'final',3:'post final'})\n .rename_axis(columns=None)\n .reset_index())\nprint (df)\n id date CR Principal final post final\n0 1 2022-11-10 checked improve 0.0 0.0\n1 2 2021-09-12 checked 0 0.0 0.0\n2 3 2020-08-22 checked 0 0.0 0.0\n3 4 2019-11-10 revise complete 0.0 0.0\n\n" ]

[ 0 ]

[]

[]

[ "dataframe", "datatables", "pandas", "pivot", "python" ]