Datasets:

---

suriyagunasekar

/

stackoverflow-python-with-meta-data

like 12

[ "It's possible to place an anchor using href to where you want to navigate. You can use html.A to add an invisible anchor.\nNote that there's no '#' in html.A id.\nEx:\nhtml.A(id=\"PageSection1\"),\n\nThen just place navigate button where you need it. Clicking the button will take you to the anchor position.\nhtml.A(html.Button('Go to page section1', id='page1-btn', n_clicks=0),href='#PageSection1'),\n\n" ]

[ 0 ]

[]

[]

[ "plotly_dash", "python" ]

[ "In Python version 3.11 I got also the error.\nPython version 3.11 https://i.stack.imgur.com/EI0Co.png\nPython version 3.10 works fine.\n" ]

[ 0 ]

[]

[]

[ "python", "python_3.x" ]

[ "It is not entirely clear what the final signal is you want to do a Fourier Transform on, but I made the following assumptions:\n\nyour time domain signal x(t)=sin(21)+sin(22). From what your wrote it wasn't entirely clear\nyou want to have the FFT of above x(t)\nyour total time T=1s (you wrote T=1, units are important)\nyour sampling frequency fs=64 sample/s (you wrote fs=64, units are important)\n\nWith these givens, you can do something like the following:\nimport numpy as np\nimport math\nimport matplotlib.pyplot as plt\n\n# Entering your input variables\nfs = 64\nT = 1\nf1 = 3\nf2 = 5\n\n# Creating the time and frequency axis\ntime = np.arange(0, T, 1/fs)\nfreq = np.arange(0, fs/2, 1/T)\n\n# Creating the time domain x signal\nx1 = np.sin(2*math.pi*f1*time)\nx2 = np.sin(2*math.pi*f2*time)\nx = x1 + x2\n\n# Making the FFT, while normalizing to make sure the amplitude is correct\nX = np.fft.fft(x)/len(time)*2\n\n# Plotting the time domain + frequency domain signals on a subplot. For the\n# frequency domain plot, we only take the first half of the frequency axis\n# (going up to fs/2) because we're dealing with a real signal.\nfig, axs = plt.subplots(2,1)\naxs[0].plot(time, x)\naxs[0].set_xlabel('Time [s]')\naxs[0].set_ylabel('Amplitude')\naxs[1].plot(freq, abs(np.split(X,2)[0]), \"x\")\naxs[1].set_xlabel('Frequency [Hz]')\naxs[1].set_ylabel('Amplitude')\nplt.show()\n\nOut of this, you get the following plot:\n\nAs you can see, you clearly see peaks with amplitude 1 on 3 and 5 Hz! :)\nNow, it's possible I didn't perfectly understand what your x(t) signal needed to be, but you can easily change the definitions of x1, x2 and x and get the output you want.\nHope this helps!\n" ]

[ 0 ]

[]

[]

[ "fft", "python", "signal_processing" ]

[ "Berkeley DB and Berkeley DB XML are two different products. My python bindings (legacy \"bsddb3\" and current \"berkeleydb\") only interface with Berkeley DB.\nI am not aware of any Python bindings for Berkeley DB XML.\nI am a freelance with commercial contracts, if that option would be useful to you.\n" ]

[ 1 ]

[]

[]

[ "api", "berkeley_db", "berkeley_db_xml", "python", "python_3.x" ]

[ "Python-Magic has a hard-coded fallback for Alpine Linux so you might be in for a hard time with file-magic, which just uses ctypes.util.find_library('magic') and apparently can't find your library.\nThe exact behavior of ctypes.util.find_library is pretty complicated but if you trace through the code and see which methods it attempts to use on your platform you will probably find a way to get it to find the library (probably one of gcc, /sbin/ldconfig, or objdump).\nAnother solution is to patch ctypes.py to properly handle systems like Alpine:\nwget https://patch-diff.githubusercontent.com/raw/python/cpython/pull/10461.patch -O - | patch /usr/local/lib/python3.7/ctypes/util.py\n\nNow you just need to set LD_LIBRARY_PATH and Python can find the library:\n/ # LD_LIBRARY_PATH=\"/usr/lib/\" python -c \"import ctypes.util; print(ctypes.util.find_library('magic'))\"\nlibmagic.so.1\n\n", "The other solution didn't work for me Docker Python 2.7 Alpine\nSolution - rename the file :)\n# fix no libmagic found error\nRUN cp /usr/lib/libmagic.so.1 /usr/lib/libmagic.so \n\n" ]

[ 4, 0 ]

[]

[]

[ "alpine_linux", "libmagic", "python" ]

[ "It's because Scrapy sets the Accept header to 'text/html,application/xhtml+xml,application/xml ...'. You can see that from this.\nI experimented and found that server sends a JSON response if the request has no Accept header.\n" ]

[ 1 ]

[]

[]

[ "api", "python", "python_requests", "scrapy", "web_scraping" ]

[ "The expected output is unclear, but assuming you want a list/Series of those values.\nLet's start with a dummy example:\nnp.random.seed(0)\ndf = pd.DataFrame(np.random.randint(0, 100, size=(20, 10)))\n\nAnd get the quantile(0.75) per column:\ndf.quantile(0.75)\n\n0 75.50\n1 67.50\n2 72.75\n3 78.25\n4 68.25\n5 77.00\n6 67.50\n7 77.75\n8 57.50\n9 74.50\nName: 0.75, dtype: float64\n\nWe can then use:\ndf.where(df.gt(df.quantile(0.75))).stack().droplevel(0).sort_index()\n\n0 77.0\n0 94.0\n0 78.0\n0 81.0\n0 80.0\n1 88.0\n1 69.0\n1 95.0\n1 84.0\n1 79.0\n2 82.0\n2 75.0\n2 80.0\n2 88.0\n2 82.0\n...\n\nOr as list:\ndf.where(df.gt(df.quantile(0.75))).stack().groupby(level=1).agg(list)\n\n0 [81.0, 78.0, 94.0, 80.0, 77.0]\n1 [88.0, 79.0, 84.0, 69.0, 95.0]\n2 [88.0, 82.0, 75.0, 82.0, 80.0]\n3 [99.0, 82.0, 99.0, 93.0, 86.0]\n4 [72.0, 88.0, 91.0, 99.0, 77.0]\n5 [95.0, 98.0, 86.0, 94.0, 83.0]\n6 [83.0, 79.0, 69.0, 81.0, 98.0]\n7 [87.0, 80.0, 99.0, 94.0, 98.0]\n8 [69.0, 76.0, 85.0, 62.0, 70.0]\n9 [87.0, 88.0, 79.0, 96.0, 85.0]\ndtype: object\n\n" ]

[ 0 ]

[]

[]

[ "dataframe", "loops", "pandas", "percentile", "python" ]

[ "All you have to do is:\nimport requests\nimport json \nimport pandas as pd\n\nurl = 'https://api.nasdaq.com/api/company/AAPL/insider-trades?limit=25&offset=0&type=ALL&sortColumn=lastDate&sortOrder=DESC'\n\nheaders = {\n 'accept': 'application/json, text/plain, */*',\n 'accept-encoding': 'gzip, deflate, br',\n 'accept-language': 'en-US,en;q=0.9',\n 'origin': 'https://www.nasdaq.com',\n 'referer': 'https://www.nasdaq.com',\n 'sec-fetch-mode': 'cors',\n'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/104.0.5112.79 Safari/537.36'\n}\n\nr = requests.get(url, headers=headers)\n\ndf = pd.json_normalize(r.json()['data']['transactionTable']['table']['rows'])[['lastDate', 'transactionType', 'sharesTraded']]\ndf.to_json(\"AAPL22_institutional_table_MRKTVAL.json\", indent=4)\n\n" ]

[ 1 ]

[]

[]

[ "api", "json", "python" ]

[ "You should be able to rotate your xlabels, which makes your plot more readable. Try:\nax = sns.lineplot(x=\"ds\", y=\"y\", data=df_new, hue=\"Type\", marker=\"o\")\nax.tick_params(axis='x', labelrotation=45)\n\nAnd then plotting your data.\n" ]

[ 0 ]

[]

[]

[ "forecast", "pandas", "plot", "python" ]

[ "you have nan as string , you can do :\ndf.eq(\"nan\").sum()\n\noutput :\ncol_1 0\ncol_2 2\ncol_3 1\ndtype: int64\n\n", "It took me a while to see that you changed your initial code for the dataset. However, if you would like to extract all of the rows where you have the 'nan' string, I would use a mask.\nmask = np.column_stack([df[col].str.contains(\"nan\", na = False) for col in df])\ndf_new = df.loc[mask.any(axis = 1)]\n\nThis creates a new data frame that you can experiment with.\n" ]

[ 2, 0 ]

[]

[]

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

[ "If the engine was created and ran on different versions, this may happen. TensorRT engines are not compatible across different TensorRT versions. Go to this reference for more info.\n", "For future readers, if you get this error building and running on the same machine or even the same container, your tensorrt python package might have a different version than your system package try the following commands to check\nIn python:\nimport tensorrt as trt\ntrt.__version__\n\nIn terminal:\ndpkg -l | grep TensorRT\n\n" ]

[ 2, 0 ]

[]

[]

[ "nvidia_docker", "python", "tensorflow", "tensorrt" ]

[ "You can loop through the dict.items() function to loop through the key and the value.\njob_role_overtime_att_rate = {\n 'Healthcare Representative Overtime Rate': 0.05405405405405406,\n 'Human Resources Overtime Rate': 0.38461538461538464,\n 'Laboratory Technician Total': 0.5,\n 'Manager Total': 0.14814814814814814,\n 'Manufacturing Director Total': 0.10256410256410256,\n 'Research Director Total': 0.043478260869565216,\n 'Research Scientist Total': 0.3402061855670103,\n 'Sales Executive Total': 0.32978723404255317,\n 'Sales Representative Total': 0.6666666666666666\n}\n\nfor name, value in job_role_overtime_att_rate.items():\n a = round(value*100, 2)\n job_role_overtime_att_rate[name] = a\n\nprint(job_role_overtime_att_rate)\n\n", "I'm not sure what your point is, but you loop over values and in the inner loop again over values.\nSo for each value you loop over all values, thus it's expected that you will get n^2 prints for dictionary with n values.\nIf I guess right this code does what you need:\nfor key, value in job_role_overtime_att_rate.items():\n job_role_overtime_att_rate[key]= value*100\n\n" ]

[ 2, 0 ]

[]

[]

[ "dictionary", "nested_for_loop", "python" ]

[ "Your document is a dynamic XFA form. These dynamic forms are defined entirely in XML and the PDF file serves as a container. The PDF file has a single page with the message you extracted, this is for the PDF processors that do not support dynamic XFA forms.\nOpen the file with Adobe Reader and you will see a full PDF file with 3 pages. Open the file with SumatraPDF and you will see an empty PDF file just with the warning you got.\nMaybe PyPDF2 can work with XFA forms. If not, you will need a low level PDF tool to extract the XML streams.\n" ]

[ 0 ]

[]

[]

[ "adobe", "pdf", "pypdf2", "python" ]

[ "You were pretty close actually:\n[print(f'There are {len({tuple(walk) for (walk, distance) in dic[i] if distance == 0})} different unique walks with length {i}') for i in range(1,11)]\n\nBut it's a long and ugly oneliner, in a regular for it looks way better.\n", "Technically yes, but I'd not recommend doing that. You can actually use a list comprehension for that but it would really defy their purpose.\nYou can use functions in comprehensions, but usually their return values is accumulated in the structure. Since the print function doesn't return a value (None), such a comprehension would accumulate a series of Nones, which is not very pythonic.\n>>> res = [print(i) for i in range(1, 11)]\n1\n2\n...\n>>> res\n[None, None, ...]\n\nMuch better is to collect all the lines you want to print and concatenate them together (for example using str.join or unpacking them into print):\n>>> print('\\n'.join(str(i) for i in range(1, 11)))\n1\n2\n...\n\nor\n>>> res = [i for i in range(1, 11)]\n>>> res\n[1, 2, ...]\n>>> print(*res, sep='\\n')\n1\n2\n...\n\n" ]

[ 2, 1 ]

[]

[]

[ "list_comprehension", "printing", "python", "set_comprehension" ]

[ "I managed to get your example to work using the following code. The data was not passed in the correct format to the function, so the SOAP message was incomplete.\nCheck the zeep documentation for details about passing SOAP datastructures.\ndeviceio_type_factory = deviceIO_service.zeep_client.type_factory(\"http://www.onvif.org/ver10/deviceIO/wsdl\")\nserial_data = deviceio_type_factory.SerialData(Binary=zoomin)\n\nack = deviceIO_service.ws_client.SendReceiveSerialCommand(Token= ports[0].token, SerialData=serial_data, TimeOut='PT0M6S', DataLength='100', Delimiter='')\n\nvisca_ack_comp = ack['Binary'].hex()\nprint(visca_ack_comp )\n\nHere is what I get from the camera: 9041ff9051ff (ACK + COMP).\nNote, you could use the WDSL file from ONVIF instead of creating your own, as that one is correct.\nclass MyDeviceIO(OnVif):\n wsdl_file = \"https://www.onvif.org/ver10/deviceio.wsdl\"\n namespace = \"http://www.onvif.org/ver10/deviceIO/wsdl\"\n sub_xaddr = \"DeviceIO\"\n port = \"DeviceIOBinding\"\n\n" ]

[ 2 ]

[]

[]

[ "ip_camera", "onvif", "python", "python_onvif", "zeep" ]

[ "threshold is datetime and you compare it to timedelta object (difference). Did you mean:\nfrom datetime import timedelta\n...\nthreshold = datetime.timedelta(minutes=15)\n\n", "Given this dataframe:\n actual_ts id\n0 05:00:00 SPAM\n1 5:15:00 SPAM\n2 5:33:00 SPAM <-- Should highlight\n3 5:45:00 SPAM\n4 6:02:00 SPAM <-- Should highlight\n5 11:15:00 FOO\n6 11:32:00 FOO <-- Should highlight\n7 11:45:00 FOO\n8 12:08:00 FOO <-- Should highlight\n\nThis is a step-by-step way of getting to where you want, definitely not the most optimal but it's clear enough to teach you how to avoid looping over dataframes, which is a major no-no. Try running and printing the dataframe every step so you know what's happening.\n# Convert column to timedelta.\ndf[\"actual_ts\"] = pd.to_timedelta(df[\"actual_ts\"])\n\n# Sort as a best practice if not computationally expensive.\ndf = df.sort_values(by=[\"id\", \"actual_ts\"])\n\n# Shift the actual_ts by one row per group.\ndf[\"lagged_ts\"] = df.groupby([\"id\"])[\"actual_ts\"].shift(1)\n\n# Fill nulls with same time if you want to avoid NaNs and NaTs.\ndf[\"lagged_ts\"] = df[\"lagged_ts\"].fillna(df[\"actual_ts\"])\n\n# Calculate difference in seconds.\ndf[\"diff_seconds\"] = (df[\"actual_ts\"] - df[\"lagged_ts\"]).dt.seconds\n\n# Mark as True all events greater than 15 minutes.\ndf[\"highlight\"] = df[\"diff_seconds\"] > 900\n\n# Keep all columns you need.\nnew_df = df[[\"actual_ts\", \"id\", \"diff_seconds\", \"highlight\"]]\n\nYou get this:\n actual_ts id diff_seconds highlight\n5 0 days 11:15:00 FOO 0 False\n6 0 days 11:32:00 FOO 1020 True\n7 0 days 11:45:00 FOO 780 False\n8 0 days 12:08:00 FOO 1380 True\n0 0 days 05:00:00 SPAM 0 False\n1 0 days 05:15:00 SPAM 900 False\n2 0 days 05:33:00 SPAM 1080 True\n3 0 days 05:45:00 SPAM 720 False\n4 0 days 06:02:00 SPAM 1020 True\n\nCleaning up the 0 days is up to you. You can also change diff_seconds to minutes but that's easy enough.\n" ]

[ 0, 0 ]

[]

[]

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

[ "We can use groupby agg to create the summary rows then append to the DataFrame:\ndf = df.append(df.groupby('Team', as_index=False).agg({\n 'Position': ' + '.join, # Concat Strings together\n 'Points': 'sum' # Total Points\n}), ignore_index=True)\n\ndf:\n Team Position Points\n0 Atlanta Defense 5\n1 Atlanta Kicker 10\n2 Cleveland Defense 15\n3 Cleveland Kicker 20\n4 Atlanta Defense + Kicker 15\n5 Cleveland Defense + Kicker 35\n\nWe can also whitelist certain positions by filtering df before groupby to aggregate only the desired positions:\nwhitelisted_positions = ['Kicker', 'Defense']\ndf = df.append(\n df[df['Position'].isin(whitelisted_positions)]\n .groupby('Team', as_index=False).agg({\n 'Position': ' + '.join, # Concat Strings together\n 'Points': 'sum' # Total Points\n }), ignore_index=True\n)\n\n", "pandas.DataFrame.append is deprecated since version 1.4.0. Henry Ecker's neat solution just needs a slight tweak to use concat instead.\nwhitelisted_positions = ['Kicker', 'Defense']\ndf = pd.concat([df,\n df[df['Position'].isin(whitelisted_positions)]\n .groupby('Team', as_index=False).agg({\n 'Position': ' + '.join, # Concat Strings together\n 'Points': 'sum' # Total Points\n })],\n ignore_index=True)\n\n" ]

[ 1, 0 ]

[]

[]

[ "aggregate", "append", "dataframe", "pandas", "python" ]

[ "When you use pytest-django you can use import the fixture admin_client and then do requests like this:\ndef test_get_project_list(admin_client):\n resp = admin_client.get(\"/projects/\")\n assert resp.status_code == 200\n resp_json = resp.json()\n assert resp_json == {\"some\": \"thing\"}\n\n" ]

[ 0 ]

[]

[]

[ "django_rest_framework", "django_testing", "django_tests", "http_mock", "python" ]

[ "The following is a general purpose single producer/multiple consumer implementation. The producer (class StreamVideos) creates a shared memory array whose size is the number of bytes in the video frame. One or more consumers (you specify the number of consumers to StreamVideos) can then call StreamVideos.get_next_frame() to retrieve the next frame. This method converts the shared array back into a numpy array for subsequent processing. The producer will only read the next frame into the shared array after all consumers have called get_next_frame:\n#!/usr/bin/env python3\n\nimport multiprocessing\nimport numpy as np\nimport ctypes\nimport cv2\n\nclass StreamVideos:\n def __init__(self, path, n_consumers):\n \"\"\"\n path is the path to the video:\n n_consumers is the number of tasks to which we will be sreaming this.\n \"\"\"\n self._path = path\n\n self._event = multiprocessing.Event()\n\n self._barrier = multiprocessing.Barrier(n_consumers + 1, self._reset_event)\n\n # Discover how large a framesize is by getting the first frame\n cap = cv2.VideoCapture(self._path)\n ret, frame = cap.read()\n if ret:\n self._shape = frame.shape\n frame_size = self._shape[0] * self._shape[1] * self._shape[2]\n self._arr = multiprocessing.RawArray(ctypes.c_ubyte, frame_size)\n else:\n self._arr = None\n cap.release()\n\n def _reset_event(self):\n self._event.clear()\n\n def start_streaming(self):\n cap = cv2.VideoCapture(self._path)\n\n while True:\n self._barrier.wait()\n ret, frame = cap.read()\n if not ret:\n # No more readable frames:\n break\n\n # Store frame into shared array:\n temp = np.frombuffer(self._arr, dtype=frame.dtype)\n temp[:] = frame.flatten(order='C')\n\n self._event.set()\n\n cap.release()\n self._arr = None\n self._event.set()\n\n def get_next_frame(self):\n # Tell producer that this consumer is through with the previous frame:\n self._barrier.wait()\n # Wait for next frame to be read by the producer:\n self._event.wait()\n if self._arr is None:\n return None\n\n # Return shared array as a numpy array:\n return np.ctypeslib.as_array(self._arr).reshape(self._shape)\n\ndef consumer(producer, id):\n frame_name = f'Frame - {id}'\n while True:\n frame = producer.get_next_frame()\n if frame is None:\n break\n cv2.imshow(frame_name, frame)\n cv2.waitKey(1)\n\n cv2.destroyAllWindows()\n\n\ndef main():\n producer = StreamVideos('videoplayback.mp4', 2)\n\n consumer1 = multiprocessing.Process(target=consumer, args=(producer, 1))\n consumer1.start()\n consumer2 = multiprocessing.Process(target=consumer, args=(producer, 2))\n consumer2.start()\n\n \"\"\"\n # Run as a child process:\n producer_process = multiprocessing.Process(target=producer.start_streaming)\n producer_process.start()\n producer_process.join()\n \"\"\"\n # Run in main process:\n producer.start_streaming()\n\n consumer1.join()\n consumer2.join()\n\nif __name__ == '__main__':\n main()\n\n" ]

[ 0 ]

[]

[]

[ "multiprocessing", "opencv", "python", "queue" ]

[ "Pass the arguments as kwargs from a dictionary, from which you filter out the None values:\nkwargs = dict(p1='FOO', p2=None)\n\nalpha(**{k: v for k, v in kwargs.items() if v is not None})\n\n", "\nBut assume that alpha is used in other places where it is actually supposed to handle None as it does.\n\nTo respond to this concern, I have been known to have a None-like value which isn't actually None for this exact purpose.\n_novalue = object()\n\ndef alpha(p1=_novalue, p2=_novalue):\n if p1 is _novalue:\n p1 = \"foo\"\n if p2 is _novalue:\n p2 = \"bar\"\n print('{0},{1}'.format(p1, p2))\n\nNow the arguments are still optional, so you can neglect to pass either of them. And the function handles None correctly. If you ever want to explicitly not pass an argument, you can pass _novalue.\n>>> alpha(p1=\"FOO\", p2=None)\nFOO,None\n>>> alpha(p1=\"FOO\")\nFOO,bar\n>>> alpha(p1=\"FOO\", p2=_novalue)\nFOO,bar\n\nand since _novalue is a special made-up value created for this express purpose, anyone who passes _novalue is certainly intending the \"default argument\" behavior, as opposed to someone who passes None who might intend that the value be interpreted as literal None.\n", "\nalthough ** is definitely a language feature, it's surely not created for solving this particular problem. Your suggestion works, so does mine. Which one works better depends on the rest of the OP's code. However, there is still no way to write f(x or dont_pass_it_at_all)\n - blue_note\n\nThanks to your great answers, I thought I'd try to do just that:\n# gen.py\ndef callWithNonNoneArgs(f, *args, **kwargs):\n kwargsNotNone = {k: v for k, v in kwargs.items() if v is not None}\n return f(*args, **kwargsNotNone)\n\n \n# python interpreter\n>>> import gen\n>>> def alpha(p1=\"foo\", p2=\"bar\"):\n... print('{0},{1}'.format(p1,p2))\n...\n>>> gen.callWithNonNoneArgs(alpha, p1=\"FOO\", p2=None)\nFOO,bar\n>>> def beta(ree, p1=\"foo\", p2=\"bar\"):\n... print('{0},{1},{2}'.format(ree,p1,p2))\n...\n>>> beta('hello', p2=\"world\")\nhello,foo,world\n>>> beta('hello', p2=None)\nhello,foo,None\n>>> gen.callWithNonNoneArgs(beta, 'hello', p2=None)\nhello,foo,bar\n\nThis is probably not perfect, but it seems to work: It's a function that you can call with another function and it's arguments, and it applies deceze's answer to filter out the arguments that are None.\n", "You could inspect the default values via alpha.__defaults__ and then use them instead of None. That way you circumvent the hard-coding of default values:\n>>> args = [None]\n>>> alpha('FOO', *[x if x is not None else y for x, y in zip(args, alpha.__defaults__[1:])])\n\n", "I had the same problem when calling some Swagger generated client code, which I couldn't modify, where None could end up in the query string if I didn't clean up the arguments before calling the generated methods. I ended up creating a simple helper function:\ndef defined_kwargs(**kwargs):\n return {k: v for k, v in kwargs.items() if v is not None}\n\n>>> alpha(**defined_kwargs(p1=\"FOO\", p2=None))\nFOO,bar\n\nIt keeps things quite readable for more complex invocations:\ndef beta(a, b, p1=\"foo\", p2=\"bar\"):\n print('{0},{1},{2},{3}'.format(a, b, p1, p2,))\n\np1_value = \"foo\"\np2_value = None\n\n>>> beta(\"hello\",\n \"world\",\n **defined_kwargs(\n p1=p1_value, \n p2=p2_value))\n\nhello,world,FOO,bar\n\n", "I'm surprised nobody brought this up\ndef f(p1=\"foo\", p2=None):\n p2 = \"bar\" if p2 is None else p2\n print(p1+p2)\n\nYou assign None to p2 as standart (or don't, but this way you have the true standart at one point in your code) and use an inline if. Imo the most pythonic answer. Another thing that comes to mind is using a wrapper, but that would be way less readable.\nEDIT:\nWhat I'd probably do is use a dummy as standart value and check for that. So something like this:\nclass dummy():\n pass\n\ndef alpha(p1=\"foo\", p2=dummy()):\n if isinstance(p2, dummy):\n p2 = \"bar\"\n print(\"{0},{1}\".format(p1, p2))\n\nalpha()\nalpha(\"a\",\"b\")\nalpha(p2=None)\n\nproduces:\nfoo,bar\na,b\nfoo,None\n\n", "Unfortunately, there's no way to do what you want. Even widely adopted python libraries/frameworks use your first approach. It's an extra line of code, but it is quite readable. \nDo not use the alpha(\"FOO\", myp2 or \"bar\") approach, because, as you mention yourself, it creates a terrible kind of coupling, since it requires the caller to know details about the function.\nRegarding work-arounds: you could make a decorator for you function (using the inspect module), which checks the arguments passed to it. If one of them is None, it replaces the value with its own default value.\n", "Not a direct answer, but I think this is worth considering:\nSee if you can break your function into several functions, neither of which has any default arguments. Factor any shared functionality out to a function you designate as internal.\ndef alpha():\n _omega('foo', 'bar')\n\ndef beta(p1):\n _omega(p1, 'bar')\n\ndef _omega(p1, p2):\n print('{0},{1}'.format(p1, p2))\n\nThis works well when the extra arguments trigger \"extra\" functionality, as it may allow you to give the functions more descriptive names.\nFunctions with boolean arguments with True and/or False defaults frequently benefit from this type of approach.\n", "\nAnother possibility is to simply do alpha(\"FOO\", myp2 or \"bar\"), but that requires us to know the default value. Usually, I'd probably go with this approach, but I might later change the default values for alpha and this call would then need to be updated manually in order to still call it with the (new) default value.\n\nJust create a constant:\nP2_DEFAULT = \"bar\"\n\ndef alpha(p1=\"foo\", p2=P2_DEFAULT):\n print('{0},{1}'.format(p1, p2))\n\n\nand call the function:\nalpha(\"FOO\", myp2 or P2_DEFAULT)\n\nIf default values for alpha will be changed, we have to change only one constant.\nBe careful with logical or for some cases, see https://stackoverflow.com/a/4978745/3605259\nOne more (better) use case\nFor example, we have some config (dictionary). But some values are not present:\nconfig = {'name': 'Johnny', 'age': '33'}\nwork_type = config.get('work_type', P2_DEFAULT)\n\nalpha(\"FOO\", work_type)\n\nSo we use method get(key, default_value) of dict, which will return default_value if our config (dict) does not contain such key.\n", "As I cannot comment on answers yet, I'd like to add that the first solution (unpacking the kwargs) would fit nicely in a decorator as follows:\ndef remove_none_from_kwargs(func):\n @wraps(func)\n def wrapper(self, *args, **kwargs):\n func(self,*args, **{k: v for k, v in kwargs.items() if v is not None})\n return wrapper\n\n" ]

[ 66, 14, 12, 5, 3, 2, 1, 1, 1, 0 ]

[]

[]

[ "python", "python_3.x" ]

[ "Welcome to Stackoverflow!!\nYour problem is related to the fact that you are working with exponential numbers, but you're using a linear colormap. For x=90 you have z=1.2e+39, reaaaally large.\nYou were very close with your second attempt! I just changed 1 line in there, instead of\nnorm = mpl.colors.Normalize(vmin=0, vmax=1)\nI used\nnorm = mpl.colors.LogNorm()\nAnd the result I got was the following:\n\nNow, you can tweak this as much as you like in order to get the colors you want :) Just don't forget that your colormap should be normalized in a logarithmic fashion, so that it counters the exponential behaviour of your function in this case.\nHope this helps!\n" ]

[ 1 ]

[]

[]

[ "colormap", "matplotlib", "python" ]

[ "Iterating over dict using .items()will yield you a pair of (key, value)\nMaking a list of a single value...gives list with a single value, max of it returns that single item.\nYour whole function body could be:\nclass Solution:\n def top_notes(self, di: dict)->dict:\n di[\"top_note\"] = max(di[\"notes\"])\n di.pop(\"notes\", None)\n return di\n\nFew more words/hints:\n\nThis \"Solution\" class suggests it's some kinda coding task, for that it's fine otherwise just drop it\nThink of better name than \"di\" which means nothing literally\nFunctions should in general have a verb in a name as \"do stuff\",\nthe \"stuff\" is your object/class/variable name etc.\nUse type hints, they save a lot of time when debugging if IDE is set right\n\n", "There are multiple issues:\n\nif key in di == 'notes' - it can't work as di is a dictionary and not a string. Moreover, pay attention that the result of the expression di == 'notes' is of a boolean type.\nYou shouldn't mutate (add/remove items) while iterating over a dictionary (or any other iterable).\nlt = list(values) - values is already a list, your code checks the maximum of a list of lists which not what you want probably\nyou don't have to iterate over the key/values of the dict as you can access/add keys/values directly.\n\nI would suggest you to implement top_notes() as following:\n def top_notes(self, di):\n if 'notes' in di.keys():\n di['top_note'] = max(di[\"notes\"])\n di.pop(\"notes\")\n return di\n\n", "When you say\nif key in di == 'notes':\n\nwhat happens is that Python first evaluates key in di which will be True since we are looping over the keys in the di.\nIt then compares True == 'notes' which will always be False and it will never enter the if clause.\nTo fix this, just drop the in di part:\nif key == 'notes':\n\n", "there are some problems in your code, firstly you have to take an empty list for calculating the maximum among all, then one by one add the values of notes in list, and then store the maximum of all values in the key of dictionary.\nyou can refer this code:\nclass Solution(object):\n\n def top_notes(self, di):\n lt=[]\n for key, values in di.items():\n if key == 'notes':\n lt += list(values)\n maximum = max(lt)\n di['top_notes'] = di['notes']\n del di['notes']\n di['top_notes'] = maximum\n return di\n\nif __name__ == '__main__' :\n p = Solution()\n dt = {\"name\":\"John\", \"notes\": [3,5,4]}\n print(p.top_notes(dt))\n\n", "You can use dict.pop() to change the key:\nclass Solution(object):\n def top_notes(self, di):\n di['top_notes'] = di.pop('notes')\n di['top_notes'] = max(di['top_notes'])\n return di\n\nOr:\nclass Solution(object):\n def top_notes(self, di):\n di['top_notes'] = max(di.get('notes'))\n del di['notes']\n return di\n\n" ]

[ 1, 1, 0, 0, 0 ]

[]

[]

[ "dictionary", "list", "python" ]

[ "Just keep track which individuals were already selected by putting their indices into a set (already_selected). Then select only when cum_prob[i]>=r and i not in already_selected.\nparent_number = population_size\nchosen = []\nalready_selected = set()\nfor n in range(parent_number):\n r=random.random()\n for (i, individual) in enumerate(population_list):\n if cum_prob[i]>=r and i not in already_selected:\n chosen.append(list(individual))\n already_selected.add(i)\n break\n\n" ]

[ 0 ]

[]

[]

[ "genetic_algorithm", "python", "roulette_wheel_selection" ]

[ "Take a look at this code, i hope this will be helpful.\nimport cadquery as cq\n\nplane1 = cq.Workplane()\n\nblock = plane1.rect(10,12).extrude(10)\n\nedges = block.edges(\"|Z\")\n\nfilleted_block = edges.all()[0].fillet(0.5)\n\nshow(filleted_block)\n\n", "For the posterity. To select multiple edges eg. for chamfering you can use newObject() on Workplane. The argument is a list of edges (they have to be cq.occ_impl.shapes.Edge instances, NOT cq.Workplane instances).\nimport cadquery as cq\n\nmodel = cq.Workplane().box(10, 10, 5)\nedges = model.edges()\n\n# edges.all() returns worplanes, we have to get underlying geometry\nselected = list(map(lambda x: x.objects[0], edges.all()))\n\nmodel_with_chamfer = model.newObject(selected).chamfer(1)\n\nTo get edge length you can do something like this:\nedge = model.edges().all()[0] # This select one 'random' edge\nlength = edge.objects[0].Length()\n\nedge.Length() doesn't work since edge is Workplane instance, not geometry instance.\nTo get edges of certain length you can just create dict with edge geometry and length and filter it using builtin python's filter(). Here is a snippet of my implementation for chamfering short edges on topmost face:\ntop_edges = model.edges(\">Z and #Z\")\n\ndef get_length(edge):\n try:\n return edge.vals()[0].Length()\n except Exception:\n return 0.0\n\n# Inside edges are shorter - filter only those\nedge_len_list = list(map(\n lambda x: (x.objects[0], get_length(x)),\n top_edges.all()))\navg = mean([a for _, a in edge_len_list])\nselected = filter(lambda x: x[1] < avg, edge_len_list)\nselected = [e for e, _ in selected]\n\nvertical_edges = model.edges(\"|Z\").all()\nselected.extend(vertical_edges)\n\nmodel = model.newObject(selected)\nmodel = model.chamfer(chamfer_size)\n\n" ]

[ 1, 0 ]

[]

[]

[ "cad", "cadquery", "python" ]

[ "I wouldn't say it's a pythonic way to be honest. Python has initializers, not \"constructors\", the constructor would be the magic method __new__ if you really needed that (which is rare).\nFor customizable initializers the decorator @classmethod (multiple factory methods) is the way to go.\nAlso __str__ and __repr__ are not the same (neither is their purpose).\nAlso most often you actually should define a new class for each type of custom exception (and inherit from the Exception class).\nclass MyCustomException(Exception):\n def __init__(self, name:str, message:str)->None:\n super().__init__(message) \n self.name = name\n\n" ]

[ 3 ]

[]

[]

[ "error_handling", "python" ]

[ "See again the flask documentation for request.files\n\nEach value in files is a Werkzeug FileStorage object\n\nIt is not just the filename but much more than that. The error message is telling you something: That secure_filename() expects a string, but you are passing it something that isn't a string.\nHave a look again at the flask documentation for file uploads: https://flask.palletsprojects.com/en/2.2.x/patterns/fileuploads/\n" ]

[ 0 ]

[]

[]

[ "file", "flask", "python" ]

[ "join each time with one column and then union all the results together:\nout1 = df1.merge(df2, left_on=['Column B'], right_on=['Column X1'])\nout2 = df1.merge(df2, left_on=['Column B'], right_on=['Column X2'])\nout = pd.concat([out1, out2], ignore_index=True)\n\nout['Column X1'].loc[out['Column B'] == out['Column X1']] = out['Column X2']\nout = out.drop('Column X2', axis = 1).rename({'Column X1':'New_Column'}, axis = 1)\nprint(out)\n\noutput:\n Column A Column B New_Column Column Y\n0 id1 name1 name4 company1\n1 id3 name3 name8 company3\n2 id2 name2 name6 company2\n\n" ]

[ 0 ]

[]

[]

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

[ "Maybe you should remove .show() so that your column is captured in lv_seconds_back variable.\n", "Your first line has two issues. The first one: col(\"max(time_horizon)\") cannot work because the col function expects a column name. Either do expr(\"max(time_horizon)\") or max(col(\"time_horizon\")). Then, the show function displays part of the dataframe but does not return anything. Therefore it does not make sense to assign the result of show to a variable.\nIf you remove show and with the col call, the result is a dataframe with one row of one element. The first function can get you the Row object from which you can access its only element like this:\nlv_seconds_back = mv_time_horizon.select(F.expr(\"max(time_horizon)\") * 60).first()[0]\n\nThen, if you want to substract that value from a timestamp, do it before you convert it to a string:\nmv_now = spark.sql(f\"select from_unixtime(unix_timestamp() - {lv_seconds_back}) as mv_now\")\n\n" ]

[ 0, 0 ]

[]

[]

[ "apache_spark", "dataframe", "pyspark", "python", "sql" ]

[ "You're definitely on the right track, you want to use np.reshape() here by doing\nM = M.reshape(n,n)\n\nor\nM = np.reshape(M, (n,n))\n\nNote the extra parentheses in the second case, they are important for it to work right because you are passing the tuple (n,n) as an argument.\n" ]

[ 0 ]

[]

[]

[ "arrays", "numpy", "python", "reshape", "vector" ]

[ "It is a matter of indentation. self.draw_objects() must be called in the application loop not after the application loop:\nclass Game:\n # [...]\n\n def run_game_loop(self):\n\n gameRunning = True\n while gameRunning:\n for event in pygame.event.get():\n if event.type == pygame.QUIT:\n gameRunning = False\n if gameRunning == False:\n pygame.quit()\n\n # INDENTATION\n #-->|\n \n self.draw_objects()\n self.clock.tick(60)\n\n", "Your loop never actually does anything but clear the event queue looking for pygame.QUIT.\nYou need to indent the calls to self.draw_objects() and self.clock.tick(60) so they are inside the loop.\n" ]

[ 1, 0 ]

[]

[]

[ "pygame", "python" ]

[ "Yes there is a way. Here is an example below\ndf = pd.DataFrame(\n np.array([['A','A','B','C','C'],[1,2,1,1,2]]).T\n , columns= ['type','value']\n )\ngroups = df.groupby('type')\ngroups_without_single_row_df = [g for g in groups if len(g[1]) > 1]\n\ngroupby return a list of tuples.\nHere, 'type' (A, b or C) is the first element of the tuple and the subdataframe the second element.\nYou can check length of each subdataframe with len() as in [g for g in groups if len(g[1]) > 1] where we check the lengh of the second element of the tuple.\nIf the the len() is greater than 1, it is include in the ouput list.\nHope it helps\n" ]

[ 0 ]

[]

[]

[ "dataframe", "group_by", "python" ]

[ "You get duplicated lines in output2 because you ask it to do so. Your condition is: If item exists in both columns, write the line to output1, else write it to output2. Then you proceed to do this for each item in list. Since there are two items in list, and (e.g. in line 1) the first item doesn't exist in both columns, it writes the line once to output2, then the second item doesn't exist in both columns either, so it writes the line again to output2.\nLet's restate your condition:\n\n[Check if] the cell pairs in columns 1 and 4 simultaneously contain the pattern \"BBB\" or \"CCC\". If true, send the whole line to output1. If false, send the whole line to output2.\n\nSo for each row, you want to check if any (any) of the items in list(for item in lst) occur in both those columns(item in cols[0] and item in cols[3]).\nlst = [\"BBB\", \"CCC\"]\nfor line in input_file:\n cols = line.split(\"\\t\")\n if any(item in cols[0] and item in cols[3] for item in lst):\n output1.write(line)\n else:\n output2.write(line)\n\nNote that I renamed list to lst and input to input_file in my code to avoid shadowing the builtins\n", "The issue is with the else part of the if statement. As every time the if condition doesn't return True you are writing the line to the output2.txt file, which is not the logic you want.\nYou will need to change the logic of the code to make it only write to output2.txt, if both 'BBB' and 'CCC' are not found.\n" ]

[ 2, 0 ]

[]

[]

[ "python" ]

[ "You don't have access to the command-line value when the @deco decorator is applied, no. But you can delay applying that decorator until you do have access.\nDo so by creating your own decorator. A decorator is simply a function that applied when Python parses the @decorator and def functionname lines, right after Python created the function object; the return value of the decorator takes the place of the decorated function. What you need to make sure, then, is that your decorator returns a different function that can apply the deco decorator when the command is being executed.\nHere is such a decorator:\nfrom functools import wraps\n\ndef apply_deco_from_name(f):\n @wraps(f)\n def wrapper(self, *args, **options):\n # this code is called instead of the decorated method\n # and *now* we have access to the options mapping.\n name = options[\"name\"] # or use options.pop(\"name\") to remove it\n decorated = deco(name)(f) # the same thing as @deco(name) for the function\n return decorated(self, *args, **options)\n \n return wrapper\n\nThen use that decorator on your command handler:\nclass Command(BaseCommand):\n def add_arguments(self, parser):\n parser.add_argument(\n \"--name\",\n type=str,\n required=True,\n )\n\n @apply_deco_from_name\n def handle(self, *_args, **options):\n name = options[\"name\"]\n\nWhat happens here? When Python handles the @apply_deco_from_name and def handle(...) lines, it sees this as a complete function statement inside the class. It'll create a handle function object, then passes that to the decorator, so it calls apply_deco_from_name(handle). The decorator defined above return wrapper instead.\nAnd when Django then executes the command handler, it will do so by calling that replacement with wrapper(command, [other arguments], name=\"command-line-value-for-name\", [other options]). At that point the code creates a new decorated version of the handler with decorated = deco(\"command-line-value-for-name\")(f) just like Python would have done had you used @deco(\"command-line-value-for-name\") in your command class. deco(\"command-line-value-for-name\") returns a decorator function, and deco(\"command-line-value-for-name\")(f) returns a wrapper, and you can call that wrapper at the end.\n", "You can make a \"meta-decorator\", something like:\nfrom functool import wraps\n\ndef metadeco(function):\n @wraps(function)\n def func(*args, **kwargs):\n name = kwargs['name']\n return deco(name)(function)(*args, **kwargs)\n return func\n\nand then work with that meta-decorator:\nclass Command(BaseCommand):\n def add_arguments(self, parser):\n parser.add_argument(\n \"--name\",\n type=str,\n required=True,\n )\n \n @metadeco\n def handle(self, *_args, **options):\n name = options['name']\n # …\n", "Your decorator doesn't really need to be a decorator. Since you are using classes, you can make use of the mixin pattern:\nclass YourMixin:\n def handle(self, name):\n # Code that was previously in deco\n\n\nclass Command(YourMixin, BaseCommand):\n def add_arguments(self, parser):\n parser.add_argument(\n \"--name\",\n type=str,\n required=True,\n )\n\n def handle(self, *_args, **options):\n # Code before calling YourMixin.handle\n name = options[\"name\"]\n super().handle(name)\n # Code after calling YourMixin.handle\n\n" ]

[ 3, 2, 2 ]

[]

[]

[ "argparse", "django", "python" ]

[ "It is very simple to implement by using tokenization via XML and XQuery.\nNotable points:\n\n1st CROSS APPLY is tokenazing Query column as XML.\n2nd CROSS APPLY is filtering out tokens that don't have \"@\" symbol.\n\nSQL #1\n-- DDL and sample data population, start\nDECLARE @tbl TABLE (ID INT IDENTITY PRIMARY KEY, Query VARCHAR(2048));\nINSERT INTO @tbl (Query) VALUES\n('SELECT * FROM table WHERE id = @organisationId'),\n('SELECT * FROM topic WHERE creation_time <=@startDate AND creation_time >= @endDate AND id = @enterOrgHere'),\n('SELECT name + ''@'' + domain FROM user');\n-- DDL and sample data population, end\n\nDECLARE @separator CHAR(1) = SPACE(1);\n\nSELECT t.ID\n , Parameters = IIF(t2.Par LIKE '@[a-z]%', t2.Par, NULL)\nFROM @tbl AS t\nCROSS APPLY (SELECT TRY_CAST('<root><r><![CDATA[' + \n REPLACE(Query, @separator, ']]></r><r><![CDATA[') + \n ']]></r></root>' AS XML)) AS t1(c)\nCROSS APPLY (SELECT TRIM('><=' FROM c.query('data(/root/r[contains(text()[1],\"@\")])').value('text()[1]','VARCHAR(1024)'))) AS t2(Par)\n\nSQL #2\nA cleansing step was added to handle other than a regular space whitespaces first.\nSELECT t.*\n , Parameters = IIF(t2.Par LIKE '@[a-z]%', t2.Par, NULL)\nFROM @tbl AS t\nCROSS APPLY (SELECT TRY_CAST('<r><![CDATA[' + Query + ']]></r>' AS XML).value('(/r/text())[1] cast as xs:token?','VARCHAR(MAX)')) AS t0(pure)\nCROSS APPLY (SELECT TRY_CAST('<root><r><![CDATA[' + \n REPLACE(Pure, @separator, ']]></r><r><![CDATA[') + \n ']]></r></root>' AS XML)) AS t1(c)\nCROSS APPLY (SELECT TRIM('><=' FROM c.query('data(/root/r[contains(text()[1],\"@\")])')\n .value('text()[1]','VARCHAR(1024)'))) AS t2(Par);\n\nOutput\n\n\n\n\nID\nParameters\n\n\n\n\n1\n@organisationId\n\n\n2\n@startDate @endDate @enterOrgHere\n\n\n3\nNULL\n\n\n\n", "The official way to interrogate the parameters is with sp_describe_undeclared_parameters, eg\nexec sp_describe_undeclared_parameters @tsql = N'SELECT * FROM topic WHERE creation_time <=@startDate AND creation_time >= @endDate AND id = @enterOrgHere' \n\n", "Using SQL Server for parsing is a very bad idea because of low performance and lack of tools. I highly recommend using .net assembly or external language (since your project is in python anyway) with regexp or any other conversion method.\nHowever, as a last resort, you can use something like this extremely slow and generally horrible code (this code working just on sql server 2017+, btw. On earlier versions code will be much more terrible):\nDECLARE @sql TABLE\n(\n id INT PRIMARY KEY IDENTITY\n, sql_query NVARCHAR(MAX)\n);\n\nINSERT INTO @sql (sql_query)\nVALUES (N'SELECT * FROM table WHERE id = @organisationId')\n , (N'SELECT * FROM topic WHERE creation_time <=@startDate AND creation_time >= @endDate AND id = @enterOrgHere')\n , (N' SELECT name + ''@'' + domain FROM user')\n ;\n\n\nWITH prepared AS\n(\n SELECT id\n , IIF(sql_query LIKE '%@%'\n , SUBSTRING(sql_query, CHARINDEX('@', sql_query) + 1, LEN(sql_query))\n , CHAR(32)\n ) prep_string\n FROM @sql\n),\nparsed AS\n(\nSELECT id\n , IIF(CHARINDEX(CHAR(32), value) = 0\n , SUBSTRING(value, 1, LEN(VALUE))\n , SUBSTRING(value, 1, CHARINDEX(CHAR(32), value) -1)\n ) parsed_value\n FROM prepared p\n CROSS APPLY STRING_SPLIT(p.prep_string, '@')\n)\nSELECT id, '@' + STRING_AGG(IIF(parsed_value LIKE '[a-zA-Z]%', parsed_value, NULL) , ', @')\n FROM parsed\nGROUP BY id\n\n", "You can use string split, and then remove the undesired caracters, here's a query :\nDROP TABLE IF EXISTS #TEMP\n\nSELECT 1 AS ID ,'SELECT * FROM table WHERE id = @organisationId' AS Query\nINTO #TEMP\nUNION ALL SELECT 2, 'SELECT * FROM topic WHERE creation_time <=@startDate AND creation_time >= @endDate AND id = @enterOrgHere'\nUNION ALL SELECT 3, 'SELECT name + ''@'' + domain FROM user'\n\n;WITH cte as\n(\n SELECT ID,\n Query,\n STRING_AGG(REPLACE(REPLACE(REPLACE(value,'<',''),'>',''),'=',''),', ') AS Parameters\n FROM #TEMP\n CROSS APPLY string_split(Query,' ')\n WHERE value LIKE '%@[a-z]%'\n GROUP BY ID,\n Query\n)\nSELECT #TEMP.*,cte.Parameters\nFROM #TEMP\nLEFT JOIN cte on #TEMP.ID = cte.ID\n\n" ]

[ 2, 2, 0, 0 ]

[]

[]

[ "c#", "excel", "python", "sql", "sql_server" ]

[ "If I understand your question correctly you want a numpy array that consists of 30 values that are equally spaced between 0 and 20, containing 0 and 20, but also to contain the value of 2.0 exactly? That is not possible, since the steps will not be equally spaced anymore.\nYou either have to adjust the boundaries, or the number of steps, for instance 31 steps will get you a nice spacing of exactly 2/3:\n>>> a = np.linspace(0,20,31)\n>>> a\narray([ 0. , 0.66666667, 1.33333333, 2. , 2.66666667,\n 3.33333333, 4. , 4.66666667, 5.33333333, 6. ,\n 6.66666667, 7.33333333, 8. , 8.66666667, 9.33333333,\n 10. , 10.66666667, 11.33333333, 12. , 12.66666667,\n 13.33333333, 14. , 14.66666667, 15.33333333, 16. ,\n 16.66666667, 17.33333333, 18. , 18.66666667, 19.33333333,\n 20. ])\n\n" ]

[ 1 ]

[]

[]

[ "numpy", "python" ]

[ "@Ehrendil - do you want to calculate running total ..\nselect date,loan,\nsum(loan) over(order by date row between unbounded preceding and current row) as running_total from table\n\n" ]

[ 0 ]

[]

[]

[ "dataframe", "pyspark", "python", "sql" ]

[ "Alright so, in order for you to inherit from the main class, you have to make your __init__() method's signature the same + whatever you might need for the top level class.\nExample:\nclass Parent:\n def __init__(self, attr1):\n self.attr1 = attr1\n\nclass Child(Parent):\n def __init__(self, attr1, attr2):\n super().__init__(attr1) # You can manipulate attr1 here\n self.attr2 = attr2\n # You can also manipulate attr1 here using\n # self.attr1 = whatever value.\n\n", "You shouldn't use inheritance for this. Inheritance is an \"is a\" relationship. If you inherit from MainWindow than your other window is a MainWindow with extra features. You don't want two MainWindow instances.\nInstead, you need to pass the instance of MainWindow to login.\nclass MainWindow():\n def __init__(self,master):\n ...\n self.login_btn = tk.Button(self.master, text=\"Login \", command=self.login)\n ...\n\n def login(self):\n login_window = login(main_window=self)\n # ^^^^^^^^^^^^^^^^\n\nclass login():\n def __init__(self, main_window):\n self.main_window = main_window\n ...\n\n def login2(self):\n ...\n self.main_window.lbl_msg.configure(text=\"welcome \" + self.user)\n # ^^^^^^^^^^^^\n ...\n\n" ]

[ 0, 0 ]

[]

[]

[ "inheritance", "python", "subclass", "tkinter", "toplevel" ]

[ "An approach realizing this is using the self:: axis and the not() operator in a predicate:\nFor example, with an XML like this\n<root>\n <tr>\n <td>1</td>\n <td>2</td>\n <td>3</td>\n <td>4</td>\n <td>5</td>\n </tr> \n <dr>\n <td>1</td>\n <td>4</td>\n </dr> \n</root>\n\nyou can use this XPath-1.0 expression:\n//tr/td[not(self::*=//dr/td)]\n\nwhich can be shortened to\n//tr/td[not(.=//dr/td)]\n\nThe resulting nodeset is as desired\n<td>2</td>\n<td>3</td>\n<td>5</td>\n\nThe XPath expression selects all elements of the first part and checks in the predicate if every element itself (self::* or .) is in the second part. If it is, it will be excluded (not(...)).\nYou can also apply this approach to attribute nodes. In this case you have to use the ., because self::* is more specific and only selects elements. So you could replace self::* by ., but not the other way round. (The most general axis would be self::node().)\n", "You can use logic and and not operators here.\nFor your specific example you can use the following XPath\n\"//tr/td[not(text()=`1`)][not(text()=`4`)]\"\n\n", "In XPath 2.0+ there is an operator for this: except. If E and F are general expressions returning sets of nodes, then E except F returns all nodes selected by E that are not selected by F.\nThere's no convenient way of doing the same thing in XPath 1.0, but the rather cumbersome (and potentially expensive) expression E[count(.|F) != count(F)] is equivalent (though you need to take care about the context for evaluation of F).\nIn many practical cases you can achieve the desired effect with a filter predicate, for example //td[not(ancestor::tr)].\n" ]

[ 1, 0, 0 ]

[]

[]

[ "html", "python", "web_scraping", "xpath", "xpath_1.0" ]

[ "You can define a def __float__(self): function in your class, and it will be called when you use float(obj). You can also add __int__, __str__ and __complex__ in the same way.\n" ]

[ 2 ]

[]

[]

[ "casting", "python", "type_conversion" ]

[ "You need to iterate over the axes. Otherwise it will just use the last subplot.\nfor i, ax, title in zip(sub_list, axes.flat, mytitles):\n ax.hist(i, bins = 20)\n ax.set_title(title)\nplt.show()\n\n" ]

[ 1 ]

[]

[]

[ "histogram", "list", "python" ]

[ "Change the last part to:\nfor target,color in zip(targets,colors):\n indicesToKeep=breast_dataset['label']==target\n plt.scatter(principal_breast_Df[breast_dataset['label']==target]['Principal component 1'], principal_breast_Df[breast_dataset['label']==target]['Principal component 2'],c=color,s=50)\n plt.legend(targets,prop={'size':15});\n\n" ]

[ 0 ]

[]

[]

[ "colors", "graph", "python", "spyder" ]

[ "The problem is that you are not adding the / when you pass the output path to imwrite. This way, it reads the filename as for example Scans164617.png.\nI guess what you are looking for is:\ncv2.imwrite(str(scan_dir / \"image_name.png\"), data)\n\n" ]

[ 0 ]

[]

[]

[ "pathlib", "python" ]

[ "It's not possible to get the last modification of each spreadsheet sheet because this modification is fetched through Google Drive.\nIt's possible to obtain the last modification of the entire worksheet using the lastUpdateTime:\nimport gspread\nsa = gspread.service_account('authentication')\nsa.open(\"worksheet name\").lastUpdateTime\n\n" ]

[ 0 ]

[]

[]

[ "google_sheets", "google_sheets_api", "gspread", "python" ]

[ "The better solution here is to not cache the packages in the first place (you're not going to need them anyway; the image build process won't benefit from them unless you're doing something terrible).\nThe simplest solution is to just pass --no-cache-dir to your pip invocations, and it won't cache the packages to disk in the first place. Alternatively, you can drop a pip.conf containing:\n[global]\nno-cache-dir = True\n\nto /etc/pip.conf in the container to disable it globally (without needing to pass the switch each time). Note that if your image ships with a version of pip prior to 19.0.1 the pip.conf solution is buggy; if that's the case, you can use --no-cache-dir command line switch manually to update pip to a post-19.0.1 version, then modify /etc/pip.conf to add the extra line if needed.\nBonus: You may want to expand the pip.conf to:\n[install]\ncompile = no\n\n[global]\nno-cache-dir = True\n\nwhere the compile = no tells pip not to compile the Python source files to bytecode on install; the benefit of pre-compiled bytecode is (slightly) faster startup, but by bloating your image, it will take longer to download/run it, so the cost to the Docker layer outweighs any savings for Python launch itself.\nLastly, add:\nENV PYTHONDONTWRITEBYTECODE=1\n\nto your Dockerfile (can be combined with other ENV settings to avoid extra layers) near the top of the file. Where the pip.conf prevents compiling/writing bytecode on install, the environment variable prevents writing them at runtime (which would be a pointless exercise; when the container exits, the bytecode would be lost anyway).\n" ]

[ 1 ]

[]

[]

[ "docker", "linux", "pip", "python" ]

[ "\ndifference between using AES-GCM 256-bit encryption, or using SSL/TLS\n\nThese cannot be directly compared.\n\nAES-GCM is encryption with integrity protection - nothing more. It needs an encryption key which somehow needs to be exchanged between the sender and recipient - how this is done is out of scope of AES-CGM.\nSSL/TLS is a protocol specifically to protect a communication between two parties.It provides encryption and integrity protection (for example using AES-CGM), but much more: Key exchange to compute a common key which is then used in the encryption, replay protection, authentication of the server to protect against man in the middle attacks.\n\nThus, better use SSL/TLS since it provides not only encryption but much more of what is needed for secure communication.\n" ]

[ 2 ]

[]

[]

[ "aes", "encryption", "python", "security", "ssl" ]

[ "You can use numpy.where:\nm = df['strand'].eq('-')\n\ndf['coordinates'] = (np.where(m, 'complement(', '')\n +df['start'].astype(str)+'..'+df['end'].astype(str)\n +np.where(m, ')', '')\n )\n\nOr boolean indexing:\nm = df['strand'].eq('-')\n\ndf['coordinates'] = df['start'].astype(str)+'..'+df['end'].astype(str)\n\ndf.loc[m, 'coordinates'] = 'complement('+df.loc[m, 'coordinates']+')'\n\nOutput:\n genome start end strand coordinates\n0 GUT_GENOME270877.fasta 98 396 + 98..396\n1 GUT_GENOME270877.fasta 384 574 - complement(384..574)\n2 GUT_GENOME270877.fasta 593 984 + 593..984\n3 GUT_GENOME270877.fasta 991 999 - complement(991..999)\n\n" ]

[ 1 ]

[]

[]

[ "conditional_statements", "if_statement", "pandas", "python" ]

[ "Go to /Applications/Python3.x and run 'Install Certificates.command'\n", "(for OSX users)\nIn another words...\n\nGo to your applications folder and look for Python folder. Mine says \"Python 3.11\"\nOpen that directory, there is a file called \"Install Certificates.command\".\nOpen that file and it will run the command.\n\n", "# Solved in \n# add\nimport ssl\nssl._create_default_https_context = ssl._create_stdlib_context\n\n" ]

[ 0, 0, 0 ]

[]

[]

[ "python", "pytube", "ssl", "youtube" ]

[ "Make sure black is installed in current used environment.\nOpen a integrated Terminal and activate the venv, run pip show black to see if it's installed in current environment. If not,\n1.Comment these two settings;\n\n\"python.formatting.provider\": \"black\",\n\"python.formatting.blackPath\":\"path-to-/bin/black\",\n\n2.Turn to python file, right click choose Format Document With... --> Python, there would be a prompt popping up to mention you install formatter, choose install black. After installation, the following setting will occur automatically in the Settings.json:\n\"python.formatting.provider\": \"black\"\n\nThen you can Format Document.\n\n", "I found out that you must set the default formatter which is language specific.\nFor python this is ms-python.python extension by Microsoft, which allows a specific formatter to be enabled, e.g autopep8, black, yapf, etc. Note I was getting notification telling me that Extension 'prettier - Code formatter' cannot format file.py\n\"[python]\": {\n \"editor.defaultFormatter\": \"ms-python.python\",\n}\n\nThen include your actual formatter:\n\"python.formatting.provider\": \"black\",\n\"python.formatting.blackPath\": \"/path/\"\n\n", "If you're developing in docker you can add\nRUN ln -s $(poetry env info -p)/bin/black /usr/local/bin/black\n\nand in your settings.json use the link\n...\n\"python.formatting.provider\": \"black\",\n\"python.formatting.blackPath\": \"/usr/local/bin/black\",\n\nwhich will use your black settings in your pyproject.toml (i.e) something like\n[tool.black]\nline-length = 80\ntarget-version = ['py39']\n\n" ]

[ 2, 1, 0 ]

[]

[]

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

[ "Always use expressionAttributeValues/Names so that you do not have to check if the word is reserved or not. That is not a static list of reserved words and can be changed at anytime. There is no API to check for reserved key words.\n" ]

[ 1 ]

[]

[]

[ "amazon_dynamodb", "boto3", "python" ]

[ "The format is to tell pandas how to parse the datetime string, not how to output the result. From the docs:\nThe strftime to parse time, e.g. \"%d/%m/%Y\"\n\nhttps://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.to_datetime.html\nYou can use something like this to format the datetime:\nimport pandas as pd\n\ndf = pd.DataFrame(['2012-01-01 12:00:01', '2012-01-01 12:00:02'])\n\npd.to_datetime(df[0]).dt.strftime('%d-%m-%Y')\n\n0 01-01-2012\n1 01-01-2012\nName: 0, dtype: object\n\n\n" ]

[ 2 ]

[]

[]

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

[ "I had the same error because I used RectLabel and I exported the CSV file directly from there.\nThe CSV must have this line first:\nfilename,width,height,class,xmin,ymin,xmax,ymax\nExample annotations.csv:\nfilename,width,height,class,xmin,ymin,xmax,ymax\n8.jpg,1280,720,label1,427,82,848,578\n9.jpg,1280,720,label1,426,87,845,585\n28.jpg,1280,720,label1,435,100,847,563\n14.jpg,352,640,label2,103,215,276,398\n15.jpg,352,640,label2,106,215,279,399\n29.jpg,352,640,label2,61,197,270,405\n17.jpg,1280,720,label1,471,178,875,671\n\nI made that file running this script:\nhttps://gist.github.com/iKhushPatel/ed1f837656b155d9b94d45b42e00f5e4\nAnd following this tutorial:\nhttps://towardsdatascience.com/custom-object-detection-using-tensorflow-from-scratch-e61da2e10087\n" ]

[ 0 ]

[ "@Louis and @jedesha if you check my name, you see it's kw while I specified on my label that it's a capital letter K and not a small letter k or Kw. what you need to do is ensure your filename is correctly written without any underscore in the filename as 1_245 to 1245\n`<object>\n <name>Kw</name> (wrong name)\n <pose>Unspecified</pose>\n <truncated>0</truncated>\n <difficult>0</difficult>\n <bndbox>\n <xmin>733</xmin>\n <ymin>175</ymin>\n <xmax>1210</xmax>\n <ymax>960</ymax>\n </bndbox>\n </object>\n </annotation>\n\n Right Name\n\n<object>\n<name>K</name> (Right name)\n<pose>Unspecified</pose>\n<truncated>0</truncated>\n<difficult>0</difficult>\n<bndbox>\n<xmin>733</xmin>\n<ymin>175</ymin>\n<xmax>1210</xmax>\n<ymax>960</ymax>\n</bndbox>\n</object>\n</annotation>`\n \n\n" ]

[ -1 ]

[ "pandas_groupby", "python", "python_3.x", "tensorflow" ]

[ "You could try using the --user option installs the package in the user's home directory.\nEg.\npip install octosuite --user\n\n" ]

[ 0 ]

[]

[]

[ "nix", "pip", "python", "replit" ]

[ "It cannot be saved directly. it is generator object. You can use my reference below to save it into file.\nfile_content = git_client.get_item_content(repo_id,path=file_path,download=True,include_content=True)\nwith open('output.txt', 'wb') as f:\n for x in file_content:\n f.write(x)\n\n" ]

[ 0 ]

[]

[]

[ "azure_devops", "azure_devops_rest_api", "azure_repos", "python" ]

[ "I found your question while I was looking for the exact same answer and having come to the same conclusions about the documentation needing to be a little more helpful.\nI'm using an Azure Service Principal (Registered App) not username/password, that's the primary difference.\nI store creds securely in Windows Credentials Manager using keyring.\nSo, in case you didn't figure it out yet, and for anyone else who finds your question, here's code that worked for me;\nscriptName ='send_csv_to_spo.py'\nimport keyring #to access Windows Credentials Manager, where user/passwords are stored securely\nfrom office365.sharepoint.client_context import ClientContext\nfrom office365.runtime.auth.client_credential import ClientCredential\nimport os #interact with OS for file actions\n#Get creds from Windows Credentials Manager\nappID = 'AppName' #Azure Registered App\nclientId = '********-****-****-****-*************'\nsecret=keyring.get_password(appID,clientId)\nsharepoint_url = f'https://*******.sharepoint.com'\nsiteName = f'/sites/*******'\ntarget_url = f\"folder/sub-folder\"\nsite_url = sharepoint_url + siteName\n#ensure file to send is in the same folder as this script\n#call function from other script, passing the fileName\n#eg:\n#import send_csv_to_spo as sendFile #imports this file as module\n#fileStr = 'test.csv' #test file in same folder\n#sendFile.sendFileToSPO(fileStr) #calls function in module\n\ndef sendFileToSPO(fileName):\n #Authenticate using stored Azure App credentials\n from office365.sharepoint.client_context import ClientContext\n ctx = ClientContext(site_url).with_credentials(ClientCredential(clientId, secret))\n #Collect file for uploading\n with open(fileName, 'rb') as content_file:\n file_content = content_file.read()\n #Upload file to target url\n target_folder = ctx.web.get_folder_by_server_relative_url(target_url)\n name = os.path.basename(fileName)\n target_file = target_folder.upload_file(name, file_content).execute_query()\n print(\"File has been uploaded as follows: {0}\".format(target_file.serverRelativeUrl))\n #File has been uploaded to url: /sites/******/******/******/testPush.csv\n\n" ]

[ 0 ]

[]

[]

[ "python", "sharepoint" ]

[ "You need to add\nstate=\"*\"\n\ninto\[email protected]_query_handler(text=[\"random1-10\", \"random1-100\"])\n\n" ]

[ 0 ]

[]

[]

[ "aiogram", "python", "telegram_api", "telegram_bot" ]

[ "You need some state to allow you to remember when a player says \"no more cards\". A boolean flag per player would be one way to do it:\nplayer1_keep_dealing = True\nplayer2_keep_dealing = True\nwhile player1_keep_dealing and player2_keep_dealing:\n if player1_keep_dealing:\n player1_yrn = input(\"Player 1, Do you want more numbers? (Y/N): \").upper()\n if player1_yrn == \"Y\":\n player1 = player1 + random.randint(1,19)\n print(f\"Player 1's number is {player1}\")\n else:\n print(f\"Player 1's number is {player1}\")\n player1_keep_dealing = False\n\n if player2_keep_dealing:\n player2_yrn = input(\"Player 2, Do you want more numbers? (Y/N) : \").upper()\n if player2_yrn == \"Y\":\n player2 = player2 + random.randint(1,19)\n print(f\"Player 2's number is {player2}\")\n else:\n print(f\"Player 2's number is {player2}\")\n player2_keep_dealing = False\n\nNotice that you now have a natural loop termination condition.\nDesign Note\nIf you have a bunch of repeated variables with numbers in the names, and may want to add more, it may be time to look at classes. For example, player state and functionality can reasonably be encapsulated in a Player class:\nclass Player:\n def __init__(self, n):\n self.n = n\n keep_dealing = True\n self.value = random.randint(1, 19)\n\n def ask(self):\n yrn = input(f\"Player {self.n}, Do you want more numbers? (Y/N): \").upper()\n if yrn == \"Y\":\n self.value += random.randint(1, 19)\n else:\n self.keep_dealing = False\n print(f\"Player {self.n}'s number is {self.value}\")\n\nIn your loop, you can\n", "Make a set storing which players are still actively playing (being dealt to). You can also store their scores / numbers in a dictionary for convenience and avoiding duplication.\nplaying = {1, 2}\nnumbers = {1: random.randint(1,19), 2: random.randint(1, 19)}\nprint(*numbers.values())\nwhile playing:\n for player in list(playing): # we make a copy of the active players to iterate over\n more = input(f\"Player {player}, Do you want more numbers? (Y/N): \").upper()\n if more == \"Y\":\n numbers[player] += random.randint(1,19)\n else:\n playing.remove(player) # stop dealing to this player\n print(f\"Player {player}'s number is {numbers[player]}\")\n\n", "An easy way would be to keep track of which player is still playing with booleans, and execute the request code only if the player is still playing.\nAlso, you could use a list to store players scores, and a list to store which player is still playing, which would lead to something like this :\nplayers = []\nyrn = input(\"R u going to play black jack? (Y/N): \").upper()\nif yrn == \"Y\":\n player_number = int(input(\"how many players ?\"))\n for player in range(player_number):\n players.append((random.randint(1,19), True))\n\nwhile True:\n for i,player in enumerate(players):\n if not player[1]:\n continue\n player_yrn = input(f\"Player {i}, Do you want more numbers? (Y/N): \").upper()\n if player_yrn == \"Y\":\n player[0] = player[0] + random.randint(1,19)\n else:\n player[1] = False\n print(f\"Player {i}'s number is {player1}\")\n\nSuch code would be much more modular :)\n" ]

[ 0, 0, 0 ]

[]

[]

[ "input", "python" ]

[ "Someone is signing up with a username that already exists. The username field in the auth_user table has a uniqueness constraint that prevents you from inserting a row that has a username that already exists in the table.\n", "thanks @Eshter the solution was as mention above :create an \"application password\" for this specific program, which you would find out if you went to the link they gave you in the error message and have to use this created password inside the code exactly the way i used to use a regular password\n" ]

[ 2, 0 ]

[]

[]

[ "django", "email", "oauth_2.0", "python" ]

[ "Python is using foo to determine the metaclass to use for Bar. No explicit metaclass is given, so the \"most derived metaclass\" must be determined. The metaclass of a base class is its type; usually, that's type itself. But in this case, the type of the only base \"class\", foo, is Foo, so that becomes the most derived metaclass. And so,\nclass Bar(foo):\n pass\n\nis being treated as\nclass Bar(metaclass=Foo):\n pass\n\nwhich means that Bar is created by calling Foo:\nBar = Foo('Bar', (foo,), {})\n\nNote that Bar is now an instance of Foo, not a type. Yes, a class statement does not necessarily create a class.\n" ]

[ 6 ]

[]

[]

[ "inheritance", "metaclass", "python", "python_3.x" ]

[ "It would be like this:\ndef NewCalculations(data):\n# some calculations\n return u, v, speed, dir\n\nThe matlab syntax is\nfunction outvars = functionname(inputvars)\n\n" ]

[ 1 ]

[]

[]

[ "function", "matlab", "python" ]

[ "A simple example using psycopg2 as the Python driver to a Postgres\ndatabase:\ncat file.csv \ndatabase,tablename\ndb1,tbl1\ndb2,tbl2 \ndb2,tbl3\ndb1,tbl4\n\nimport psycopg2\nfrom psycopg2 import sql\nimport csv\n\nwith open('file.csv') as csv_file:\n r = csv.DictReader(csv_file)\n for row in r:\n print(row['database'], row['tablename'])\n con = psycopg2.connect(dbname=row['database'], host=\"localhost\", user=\"postgres\")\n cur = con.cursor()\n cur.execute(sql.SQL(\"delete * from {}\").format(sql.Identifier(row[\"tablename\"])))\n\n\nIf this was a large file you would probably want to look at sorting by database to reduce the connections and/or use a connection pooler.\nUPDATE\nTo read connection information from file:\ncat pg.json \n\n{\"DBMSType\": \"POSTGRESQL\", \"serverName\": \"server_name\", \"databaseName\": \"mars\", \"port\": \"5601\", \"userID\": \"test\", \"password\": \"test_pswd\"}\n\nwith open('pg.json', 'r') as pg_file:\n db_dict = json.loads(pg_file.read())\n\ndb_dict\n{'DBMSType': 'POSTGRESQL',\n 'serverName': 'server_name',\n 'databaseName': 'mars',\n 'port': '5601',\n 'userID': 'test',\n 'password': 'test_pswd'}\n\nwith open('file.csv') as csv_file:\n r = csv.DictReader(csv_file)\n for row in r:\n print(row['database'], row['tablename'])\n if row['database'] == db_dict['databaseName']:\n con = psycopg2.connect(dbname=db_dict['databaseName'], host=db_dict['serverName'], user=db_dict['userID'], port=db_dict['port'], password=db_dict['password'])\n cur = con.cursor()\n cur.execute(sql.SQL(\"delete * from {}\").format(sql.Identifier(row[\"tablename\"]\n\n\n" ]

[ 0 ]

[]

[]

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

[ "Since your output is of the same shape as your input, and you want to classify each point, maybe you should try a unet, similar to this one:\n Something like the following (added normalization, and some noise and dropout to prevent overfitting):\nskip_connections = []\nkernel_size = 7\npool_size = 10\ndeepth = 3\ndef units(i: int): return 32*2**i\nnorm_layer = layers.Normalization()\nnorm_layer.adapt(x_train_slices)\ninputs = layers.Input(shape=(input_dim, 2))\nx = norm_layer(inputs)\nx = layers.GaussianNoise(stddev=0.01)(x)\nfor i in range(deepth):\n x = layers.Conv1D(units(i), kernel_size, activation='relu', padding='same')(x)\n x = layers.BatchNormalization()(x)\n x = layers.SpatialDropout1D(.3)(x)\n x = layers.Conv1D(units(i), kernel_size, activation='relu', padding='same')(x)\n x = layers.BatchNormalization()(x)\n skip_connections.append(x)\n #x = layers.Conv1D(units(i), kernel_size, strides=pool_size, activation='relu', padding='same')(x)\n x = layers.MaxPool1D(pool_size)(x)\n x = layers.BatchNormalization()(x)\nx = layers.SpatialDropout1D(.3)(x)\nx = layers.Conv1D(units(deepth+1), kernel_size, activation='relu', padding='same')(x)\nx = layers.BatchNormalization()(x)\nx = layers.Conv1D(units(deepth+1), kernel_size, activation='relu', padding='same')(x)\nx = layers.BatchNormalization()(x)\nfor i in range(deepth-1, -1, -1):\n x = layers.Conv1DTranspose(units(i), kernel_size, strides=pool_size, activation='relu', padding='same')(x)\n skip_x = skip_connections.pop()\n x = layers.Concatenate(axis=-1)([x, skip_x])\n x = layers.BatchNormalization()(x)\n x = layers.Conv1D(units(i), kernel_size, activation='relu', padding='same')(x)\n x = layers.BatchNormalization()(x)\n x = layers.Conv1D(units(i), kernel_size, activation='relu', padding='same')(x)\n x = layers.BatchNormalization()(x)\n\n\nx = layers.Conv1D(2, kernel_size, activation='sigmoid', padding='same')(x)\nmodel = tf.keras.Model(inputs=inputs, outputs=x)\n\nWhich gives some results:\nEpoch 150/1000\n5/5 [==============================] - 2s 330ms/step - loss: 1.5309e-05 - \nprecision: 0.0903 - val_loss: 1.5629e-05 - val_precision: 1.0000\nEpoch 151/1000\n5/5 [==============================] - 2s 329ms/step - loss: 1.6166e-05 - \nprecision: 0.0681 - val_loss: 1.4105e-05 - val_precision: 0.0938\nEpoch 152/1000\n5/5 [==============================] - 2s 329ms/step - loss: 1.3713e-05 - \nprecision: 0.1277 - val_loss: 1.5543e-05 - val_precision: 1.0000\nEpoch 153/1000\n5/5 [==============================] - 2s 330ms/step - loss: 1.3353e-05 - \nprecision: 0.2615 - val_loss: 1.4101e-05 - val_precision: 0.4091\nEpoch 154/1000\n5/5 [==============================] - 2s 331ms/step - loss: 1.4418e-05 - \nprecision: 0.1412 - val_loss: 1.4621e-05 - val_precision: 0.8333\n\n" ]

[ 0 ]

[]

[]

[ "autoencoder", "conv_neural_network", "machine_learning", "python", "tensorflow" ]

[ " so inside a procedder there was if stament to check if run right then will return 1 if not 0 so we assing that to int value and then use it when calling procedure\nif order_count ==1:\nprint ('succesesfull' )\nelif: order_count ==0:\nprint('faild')\nelse:\npass ```\n\n" ]

[ 0 ]

[]

[]

[ "cx_oracle", "oracle", "python", "sql" ]

[ "Every time you will similar pattern text like in above case you get 230 volts...Like in another example you will get 320 volts? ...So which will be formatted as x volts?\nIf so\nimport pandas as pd\nc1_str = ' '.join(df[\"Text\"])\n\nc1_str = c1_str.replace('linebreaks', 'linebreaks|')\nc1_str = c1_str.replace('Volt', 'Volt|')\nmask =c1_str.split('|')\nprint(mask)\n\nGives #\n['230 Volt', ' This is a sentence with multiple linebreaks', '. More text with spaces']\n\nExplination:\nConvert df column to string & manuplate string according to pattern you want by creating split patterns. Converting string to list based on split pattern |\n" ]

[ 0 ]

[]

[]

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

[ "This seems to be working:\nimport pandas as pd\nfrom yahooquery import Ticker\nsymbols = ['AAPL','GOOG','MSFT'] \nfaang = Ticker(symbols)\nfaang.asset_profile\ndf = pd.DataFrame(faang.asset_profile).T\ndf.to_csv('output.csv', mode='a', index=True, header=True)\n\n" ]

[ 0 ]

[]

[]

[ "dataframe", "dictionary", "pandas", "python", "yfinance" ]

[ "OSError: [WinError 193] %1 is not a valid Win32 application\n\nMaybe your computer's OS is not window_32, But your python version is 32-bit. So check your OS, I guess your OS is window_64, And install right python version.\nHere is python installer for window_64.\npython installer for win_64\n", "I ran into the same OS error using, win_64 Bit and I have both python 32-bit and 64-bit installed. The problem is definitely the nltk module.\non the nltk documentation, the [nltk webpage] (https://www.nltk.org/install.html) suggests to install Windows 32-bit versions of python. Try python 32.\nI would have just done a comment but I have no reputation.\n", "Also as described in this link make sure you are using a 64 bit console e.g.\nC:\\Windows\\SysWOW64\\cmd.exe\n\nwhile using pip to install your dependencies. This ensures the 64 bit version of the dependencies is installed. Also make sure you are using Python 64 bits and if loading any external .dll or .so compiled in C it was compiled using 64 bits.\n" ]

[ 0, 0, 0 ]

[]

[]

[ "corpus", "nltk", "python", "python_3.x" ]

[ "Use list comprehension: it is more Pythonic and concise:\ncamelcase = input(\"camelCase: \")\nsnakecase = ''.join(c if c.lower() == c else '_' + c.lower() for c in camelcase)\nprint(snakecase)\n\n", "With += you are adding the _ to the end of the snakecase variable. This you do for every uppercase character and then add the character itself. The output should be something like myteststring_t_s for myTestString.\nInstead, build the new string one char by the other.\ncamel_case = 'myTestString'\nsnake_case = \"\"\n\nfor c in camel_case:\n if c.isupper():\n snake_case += f'_{c.lower()}'\n else:\n snake_case += c\n\nprint(snake_case)\n\n" ]

[ 2, 1 ]

[ "Your function would work if snakecase was empty, but it is not.\nYou should initialize it to snakecase = str()\n" ]

[ -1 ]

[ "python", "snakecase" ]

[ "It would be possible to create a machine learning model to predict the prices given a dataset of previous prices. Take a look at this post for instance. You would have to modify it slightly such that it predicts the prices in the gaps given previous and upcoming prices.\nBut for the example you gave assuming the dates are of this year 2022, these are a Saturday and Sunday, the stock market is closed on the weekends, hence there is not price of the item. Also notice that there are other days in the year where there is not trading occurring, think about holidays, then there also is not price of course.\n" ]

[ 1 ]

[]

[]

[ "keras", "python", "tensorflow", "tf.keras" ]

[ "You can do this by using zip and list comprehension\nres_arr = [np.arange(start, stop + 1) for start, stop in zip(arr_1, arr_2)]\n\n" ]

[ 2 ]

[]

[]

[ "arrays", "multidimensional_array", "numpy", "python" ]

[ "This regular expression will replace all U+nnnn sequences with the corresponding Unicode character:\nimport re\n\ns = u'''\\\nU+0021\nU+0022\nU+0023\n.......\nU+0024\n'''\n\ns = re.sub(ur'U\\+([0-9A-F]{4})',lambda m: unichr(int(m.group(1),16)),s)\n\nprint(s)\n\nOutput:\n!\n\"\n#\n.......\n$\n\nExplanation:\n\nunichr gives the character of a codepoint, e.g. unichr(0x21) == u'!'.\nint('0021',16) converts a hexadecimal string to an integer.\nlambda(m): expression is an anonymous function that receives the regex match.\nIt defines a function equivalent to def func(m): return expression but inline.\nre.sub matches a pattern and sends each match to a function that returns the replacement. In this case, the pattern is U+hhhh where h is a hexadecimal digit, and the replacement function converts the hexadecimal digit string into a Unicode character.\n\n", "In case anyone using Python 3 and above wonders, how to do this effectively, I'll leave this post here for reference, since I didn't realize the author was asking about Python 2.7...\nJust use the built-in python function chr():\nchar = chr(0x2474)\nprint(char)\n\nOutput:\n⑴\n\nRemember that the four digits in Unicode codenames U+WXYZ stand for a hexadecimal number WXYZ, which in python should be written as 0xWXYZ.\n", "The code written below will take every Unicode string and will convert into the string.\nfor I in list:\n print(I.encode('ascii', 'ignore'))\n\n" ]

[ 2, 1, 0 ]

[ "a = 'U+aaa'\na.encode('ascii','ignore')\n'aaa'\n\nThis will convert for unicode to Ascii which i think is what you want.\n" ]

[ -2 ]

[ "python", "python_2.7", "unicode" ]

[ "I had this issue recently on PyCharm 2020.3.3 Community Edition.\nWhat I've found is in the top right corner of the editor there is a Reader Mode button.\nIf you click it you turn the Reader Mode off and then you can see your errors.\n\nYou can re-enable it by clicking the book icon\n\n", "I found. i've enabled by chance the \"power safe mode\" that avoid error checking. it can be re-enabled by clicking on the little man on bottom right corner.\n", "In my case, I had some ticks disabled in the Python Inspections menu in Settings > Editor > Inspections > Python. I have ticked everything and applied, and now it is working.\n\nI don't really understand why this happened as the problem arose from one day to another. I had even re-installed the whole PyCharm, trying older versions, and deleted the .pycharm configuration folder from home.\n", "I had the same issue with PyCharm Community Edition, v.2016.3.2. To fix, \ngo to Preferences... from the PyCharm menu, and open Editor/Colors & Fonts/General\nNow go to Errors and Warnings/Error under your current schema.\nI also had to set my Project Interpreter under Preferences/Project:<name>/Project Interpreter.\nSee screenshot.\n\n", "None of the previous answers worked for me when I ran into this issue, but I was able to fix it by doing a hard reset on my PyCharm settings:\nFrom the main menu, select File | Manage IDE Settings | Restore Default Settings.\nYou will lose all your custom settings this way of course, but this was the only thing that worked for me.\n", "I have tried many things, but only Invalidate Caches did the trick, after that I could hover the green arrow (top right side) and change Highlight to All Problems\n", "I just faced a similar issue.\nI ran my web with IIS so I didn't have an interpreter on my Pycharm project, when I added my virtual environment interpreter everything returned to work.\nI hope this will help someone in the future\n", "I needed to \"Add content root\" under \"Project Structure\" in Preferences. I had no content root.\n", "Nothing of this worked for me.\nMy problem was a single warning: \"unreachable code\" which blocked all errors from being highlighted.\nI removed this line of code (+ the warning) and all errors showed up again.\n" ]

[ 57, 6, 3, 2, 2, 0, 0, 0, 0 ]

[]

[]

[ "pycharm", "python" ]

[ "Answering my own question after I got inspired by a friend. This is easily formulated in a linear constraint. The coefficient of benefits_male minus earnings_male needs to equal 0:\nconstraints_matrix=pd.DataFrame([0,1,0,-1]).transpose()\nconstraints_values=pd.Series([0])\nmod.add_constraints(constraints_matrix,constraints_values)\nprint(mod.fit(cov_type=\"unadjusted\"))\n\n" ]

[ 0 ]

[]

[]

[ "linearmodels", "python", "seemingly_unrelated_regression" ]

[ "Aren't you over-complicating things a bit here?\nIf it's the pattern you are looking for here:\ndef print_pattern(bangs: int, stars: int)->None:\n output = f\"{'!'*bangs}{'*'*stars}\"\n print(output)\n\nCare to provide some more explanations about what do you expect actually?\nIs the total number of chars fixed?\nIs it the sum of i and j, something else?\ni, j = 0, 6\ntotal = i+1\nwhile i+j == total:\n if i>5:\n break\n print_pattern(bangs=i, stars=j)\n i+=1\n j-=1\n\n", "Use only 1 print, and include 'end' with a space:\nprint( ...., end = \" \")\ni = 0\nj = 6\ns1 = \"\"\ns2 = \"\"\nwhile True:\n i += 1\n j -= 1\n if i >= 5:\n break\n s1 = f\"{'!'*(j-1)}\"\n s2 = f\"{s2:*^{i*2}}\"\n print(s1 + s2, end=\" \")\n\nOutput:\n!!!!** !!!**** !!****** !******** \n\nI also modified your break clause.\n", "It looks like you want a space after each sequence of asterisks but probably not at the end of the output. Therefore:\nM = 4\nN = 2\n\nfor m in range(M, 0, -1):\n print(f\"{'!' * m}{'*' * N} \", end='')\n N += 2\n\nprint('\\b')\n\nOutput:\n!!!!** !!!**** !!****** !********\n\n" ]

[ 0, 0, 0 ]

[ "I found wrong thing.\ns1 = f\"{s1:!<{j}}\" in this part, value(j) is max value.\nSo, s1 already full.\nAt the end of the loop, s1 must be initialized.\nI should add s1 = \"\"\n" ]

[ -1 ]

[ "alignment", "f_string", "python", "while_loop", "width" ]

[ "If the initial line has changed, set initial to current.\nIn the function checkvar()\ndef checkvar():\n initial = getvar()\n print(\"Initial var: {}\".format(initial))\n while True:\n current = getvar()\n if initial == current:\n pass \n else:\n initial = current #initial line set to current line\n print(\"var has changed!\")\n pass\n\n", "You are never re-assigning initial, so when you check if initial == current, it's only checking against the very first version of the file. Instead, re-assign as follows\ndef getvar():\n with open('readme.txt') as f:\n first_line = f.readline().strip('\\n')\n result = first_line\n return result\n\ndef checkvar():\n last = getvar()\n while True:\n current = getvar()\n if last != current:\n print(\"var has changed!\")\n last = current\n\ncheckvar()\n\n" ]

[ 2, 2 ]

[]

[]

[ "if_statement", "python", "while_loop" ]

[ "I would reshape, then updated every other row with the horizontally flipped version of that row.\nimport numpy as np\n\na = np.array([4, 3, 2, 1, 5, 6, 7, 8, 12, 11, 10, 9])\nnumcols = 4\n\na = a.reshape(-1,numcols)\na[::2] = np.flip(a, axis=1)[::2]\n\nprint(a)\n\nOutput\n[[ 1 2 3 4]\n [ 5 6 7 8]\n [ 9 10 11 12]]\n\n", "Based on @Chris' answer (full credit to him), here seems to be a working version for both 1D and n-dimensional input:\nimport numpy as np\n\ndef unzigzag(z, numcols):\n new_shape = (z.shape[0] // numcols, numcols) + z.shape[1:]\n a = z.copy().reshape(new_shape)\n a[::2] = np.flip(a, axis=1)[::2]\n return a\n\nunzigzag(np.array([4, 3, 2, 1, 5, 6, 7, 8, 12, 11, 10, 9]), numcols=4)\n\n# [[ 1 2 3 4]\n# [ 5 6 7 8]\n# [ 9 10 11 12]]\n# shape: (3, 4)\n\nunzigzag(np.array([[4,4], [3, 3], [2, 2], [1, 1], [5, 5], [6, 6], [7, 7], [8, 8], [12, 12], [11, 11], [10, 10], [9, 9]]), numcols=4)\n\n# [[[ 1 1]\n# [ 2 2]\n# [ 3 3]\n# [ 4 4]]\n\n# [[ 5 5]\n# [ 6 6]\n# [ 7 7]\n# [ 8 8]]\n\n# [[ 9 9]\n# [10 10]\n# [11 11]\n# [12 12]]]\n# shape: (3, 4, 2)\n\n" ]

[ 4, 1 ]

[]

[]

[ "matrix", "numpy", "numpy_ndarray", "performance", "python" ]

[ "By using zip built-in function you get tuples:\nleft_side, right_side = zip(*list1, *list2, *list3)\n\nAnd if you really need lists:\nleft_side, right_side = map(list, zip(*list1, *list2, *list3))\n\n", "The below seems to work.\nlist1 = [[1, 2], [56, 32], [34, 244]]\nlist2 = [[43, 21], [30, 1], [19, 3]]\nlist3 = [[1, 3], [8, 21], [9, 57]]\n\nleft = []\nright = []\nlst = [list1, list2, list3]\nfor l in lst:\n for ll in l:\n left.append(ll[0])\n right.append(ll[1])\nprint(f'Left: {left}')\nprint(f'Right: {right}')\n\n", "If you do not have any issues with importing some standard libraries, you might achieve the goal as follows:\nimport itertools\nfrom operator import itemgetter\n\nright_side = list(map(itemgetter(1), itertools.chain(list1, list2, list3)))\nleft_side = list(map(itemgetter(0), itertools.chain(list1, list2, list3)))\n\nOutput of the due prints shall be:\n[2, 32, 244, 21, 1, 3, 3, 21, 57]\n[1, 56, 34, 43, 30, 19, 1, 8, 9]\n\n", "You can use numpy\nimport numpy as np\nAll = list1+list2+list3\nAll = np.array(All)\nprint(All[:,1].tolist())\n\nGives right elemnst #\n[2, 32, 244, 21, 1, 3, 3, 21, 57]\n\nTo get left #\nprint(All[:,0].tolist())\n\nGives #\n[1, 56, 34, 43, 30, 19, 1, 8, 9]\n>>> \n\n" ]

[ 2, 2, 2, 1 ]

[]

[]

[ "list", "python" ]

[ "You unconditionally write the header again each time you call submit. Either:\n\nRemove that header write, and have, somewhere outside submit (early in your program, run exactly once), the code that initializes (opens in \"w\" mode so the file is cleared) the file with just the header, so each submit doesn't add an extra copy, or\n\nLeave the header write it, but make it conditional on the file being empty (so you only write it when the file is already empty, and otherwise assume the file already has the header), e.g.\n with open(\"Data_amount.csv\", \"a\", newline=\"\") as csvfile:\n writer = csv.writer(csvfile)\n #Header \n if not os.fstat(csvfile.fileno()).st_size:\n writer.writerow([\"Amount\", \"Time\"]) # Write header only if input is empty\n\n\n\n" ]

[ 0 ]

[]

[]

[ "csv", "python" ]

[ "Flask\nscreenx = ((int(width[0][0]) - 0)) \nreturn render_template('/barchart.html', data=screenx)\n\nHTML\nscreenx1={{data}}\n\nUse data instead of screen?\n" ]

[ 0 ]

[]

[]

[ "canvas", "flask", "html", "python" ]

[ "Both calc_minimums and calc_maximums are copying string data directly from the provided filtered_data argument without performing any type conversions. It's string data because the filter_data function is not performing any type conversions itself, and since you're not reading from the file with the csv.QUOTE_NONNUMERIC flag operating on the reader, no type conversion is performed (all the fields in each row are str).\nIt's possible you think you've performed the conversions because you called float on the fields in calc_averages, but that only read from the fields, parsed them, and returned a new float, leaving the original list unchanged (the values are still str).\nIf you want this to work, do one of:\n\nChange calc_minimums and calc_maximums to perform the same type conversions that calc_averages is doing (kind of important, because right now your mins and maxes are based on str comparisons, not float comparisons, and string lexicographic sorting is almost certainly wrong much of the time, unless all your values have the exact same number of digits)\nApply a conversion step to convert the necessary fields to float ahead of time, before the data is used (saves repeated conversion work)\n(If the CSV format supports it) Add the csv.QUOTE_NONNUMERIC to your csv.reader creation (assumes all non-numeric fields are in fact quoted, which is unlikely, unless the file was created using the same flag, or comes from an unusual CSV generator)\n\nAssuming #3 isn't an option, the easiest solution (as well as fastest, and least error-prone) is #2; your existing functions don't have to change (the float conversions could even be removed from calc_averages). Just make a new function, e.g.:\n# Defaulted arguments match the type and indices your code uses\ndef convert_data(data, totype=float, convert_indices=(7, 8, 9, 11)):\n '''Modifies data in-place, converting specified indices in each row to totype'''\n for row in data:\n for idx in convert_indices:\n row[idx] = totype(row[idx])\n\nThen just add:\nconvert_data(filtered_data)\n\nimmediately after the line filtered_data = filter_data(user_input, data).\nIf you prefer not operating in-place, you can make a new list with something like this:\n# Defaulted arguments match the type and indices your code uses\ndef convert_data(data, totype=float, convert_indices=frozenset({7, 8, 9, 11})):\n '''Returns new copy of data with specified indices in each row converted to totype'''\n convert_indices = frozenset(convert_indices) # Optimize to reduce cost of\n # checking if index should be converted\n return [[totype(x) if i in convert_indices else x for i, x in enumerate(row)]\n for row in data]\n\nand make the inserted line:\nfiltered_data = convert_data(filtered_data)\n\n" ]

[ 1 ]

[]

[]

[ "csv", "python", "string" ]

[ "Alternate way is read that text file to a list & append based on index as follows.\nwith open('sample.txt') as file:\n lines = [line.rstrip() for line in file]\n\nline1 = lines[1]\nnew_line1 = line1 + str(12)\nlines[1] = new_line1\n\nwith open('sample.txt', mode='wt', encoding='utf-8') as f:\n f.write('\\n'.join(lines))\n\nUpdated sample.txt\nNo, Color, Height, age\n1, blue,70,12\n2, white,65,\n3, brown,49,\n4, purple,71,\n5, grey,60,\n\nExplination:\nOnce you read the text file to list.\n0th element will ebcome ---> index(1st line)\n1st element will become ----> 2nd line \n---\n--\n\n--\n\nAccess based on index & append your strings uinsg + operator\n", "In this example, I used a 2D array and it worked for me. Try it out and send a chat to me if it doesn't work or if you need a more in-depth explanation.\nwith open(\"sample.txt\", 'r') as file:\n data = file.readlines()\n\n for index, item in enumerate(data):\n data[index] = item.strip(\"\\n\")\n\n for index, item in enumerate(data):\n data[index] = item.split(\", \")\n\ndata[1][3] = \"12\"\n\nndata = []\n\nfor index, _ in enumerate(data):\n data1 = \", \".join(data[index])\n ndata.append(data1)\n\nmdata = \"\\n\".join(ndata)\n\nwith open(\"sample.txt\", 'w') as file:\n file.write(mdata)\n\n" ]

[ 0, 0 ]

[]

[]

[ "file_writing", "overwrite", "python", "text" ]

[ "From your code trials shown here looks like you didn't add the new line correctly.\nTo upload multiple files you can construct a string adding all the absolute paths of the uploaded files separated by \\n , as following:\nall_path_images = \"\"\nfor i in range(len(new_images)):\n all_path_images + = r\"C:\\\\Users\\\\33651\\Documents\\Documents\\\\facebook-automate\\\\facebook-automate\\\\\" + new_images[i] + ' \\n '\n#remove the last new line character from the string\nall_path_images = all_path_images.strip()\nadd_images.send_keys(path)\n\n" ]

[ 1 ]

[]

[]

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

[ "line1.cord[0] returns x1,y1 not x1,x2\nimport matplotlib.pyplot as plt\nfrom shapely.geometry import LineString\n\nline1 = LineString([(1,3),(4,3)])\nline2 = LineString([(1,2),(4,2)])\n\nfig, ax = plt.subplots()\nax.plot(*line1.xy)\nax.plot(*line2.xy)\n\nxs1, ys1 = line1.coords[0]\nxe1, ye1 = line1.coords[1]\n\nm1 = (ye1-ys1)/(xe1-xs1)\n\nxs2, ys2 = line2.coords[0]\nxe2, ye2 = line2.coords[1]\n\nm2 = (ye2-ys2)/(xe2-xs2)\n\nprint(m1,m2)\n\n" ]

[ 2 ]

[]

[]

[ "line", "math", "python", "shapely" ]

[ "First you should use the argument of the function in the body of older_people instead of the global variable plist. people should be used instead of plist.\nThen, your return statement is inside the for loop, this means that it will leave the function at the first time the if condition is true, hence printing only one person.\ndef older_people(people: list, year: int):\n result = []\n for person in people:\n if person[1] < year:\n result.append(person[0])\n return result\n\n\n\n\np1 = (\"Adam\", 1977)\np2 = (\"Ellen\", 1985)\np3 = (\"Mary\", 1953)\np4 = (\"Ernest\", 1997)\nplist = [p1, p2, p3, p4]\n\nolder = older_people(plist, 1979)\nprint(older)\n\n", "Alternately you could reference both elements of the tuple with labels instead of by index, also list comprehension...\ndef older_people(people: list, year: int):\n return [person for person, birth_year in people if birth_year <= year]\n\n" ]

[ 2, 0 ]

[]

[]

[ "python", "tuples" ]

[ "\nThe steps in the main question above is the nb_conda_kernels way. With nb_conda_kernels installed in the base environment, any notebook running from the base environment will automatically show the kernel from any other environment which has ipykernel installed. We only need one jupyter notebook, ideally installed in the base env.\n\nNot ideal way: The \"quick and dirty method\" is to install jupyter notebook in each env. \"If you install jupyter in any environment and run jupyter notebook from that environment the notebook will use the kernel from the active environment. The kernel will show with the default name Python 3 but we can verify this works by doing the following.\"\n\n\nimport os\nprint (os.environ['CONDA_DEFAULT_ENV'])\n\nThe \"usual or easy way\" is \"to individually register each environment you want to show in your kernels list.\" There is no need to install nb_conda_kernels.\n\nAfter creating the new env, python3.11 for example\n`\nconda activate python3.11 # make it active\n\nconda install ipykernel # needed for each env\n\nconda install ipywidgets # for additional jupyter functionalities\n\npython -m ipykernel install --user --name python3.11 --display-name \"Python 3.11 env\" # will install kernelspec python3.11\n\n`\nThat's it, when running jupyter notebook, one will see \"Python 3.11 env\" as one of the env to select from.\nNOTE:\nThe problem with this easy way is that running commands using ! like:\n!python --version\n\n!pip3 list\n\n!conda list\n\nwill always refer to the env where jupyter notebook was started from, irregardless of whatever kernel version is currently selected (in use) by jupyter notebook.\nSo if we do this :\n!pip3 install --upgrade numpy\n\nnumpy will be installed or upgraded in the env where jupyter notebook was started from. This is a problem if we are programatically trying to upgrade a package within jupyter notebook itself based on a condition, for example.\nIf instead, we used the nb_conda_kernels way, the above command will always install/upgrade in the env of the active kernel, irregardless of the env where jupyter notebook was started from.\nSo that's something to take note of, if one is installing packages in environments other than base.\nPersonally, I use both nb_conda_kernels way (nb_conda_kernels) and the usual/easy way. Just follow all the steps of the usual way, then the last step, before running jupyter notebook, is :\n# make sure you are in base env\nconda install nb_conda_kernels\n\nSo my kernel list in Jupyter notebook would look like :\nPython 3 (ipykernel)\nPython3.11 env\nPython [conda env:python3.11]\netc.\nI can select whichever kernel I want and it will work, while remembering the behavior I mentioned above.\nIf I want !pip3 install --upgrade to work on the packages in the base, while using a kernel whose version is different from the base (Python 3.8 for example), I would start notebook from the base env, and select kernel \"Python3.11 env\".\nAnd if I want !pip3 install --upgrade to work on the packages in the env of a certain env, I can start notebook from any env, and select the kernel \"Python [conda env:python3.11]\".\n" ]

[ 0 ]

[]

[]

[ "conda", "jupyter_notebook", "python" ]

[ "Tuples are immutable.So you have to replace it .Here _ is meant to avoid conflict with fieldnames ._replace\nfrom urllib.parse import parse_qs, urlencode, urlsplit\nurl = 'http://example.com/?page=1&text=test#section'\nparam, newvalue = 'page', '2'\nparsed = urlsplit(url)\nquery_dict = parse_qs(parsed.query)\nquery_dict[param][0] = newvalue\nquery_new = urlencode(query_dict, doseq=True)\nparsed=parsed._replace(query=query_new)\nurl_new = (parsed.geturl())\n\n", "Just using urllib for python 3 (quite long but flexible):\nfrom urllib.parse import urlparse, ParseResult, parse_qs, urlencode\n\nu = urlparse('http://example.com/?page=1&text=test#section')\nparams = parse_qs(u.query)\nparams['page'] = 22 # change query param here\nres = ParseResult(scheme=u.scheme, netloc=u.hostname, path=u.path, params=u.params, query=urlencode(params), fragment=u.fragment)\nprint (res.geturl())\n\n", "As namedtuple are immutable, we have to work around.\nA solution is to use a very basic and fast replace.\nfrom urllib.parse import urlparse, parse_qs, urlencode\n\nurl = 'http://example.com/?page=1&text=test#section'\n\nparsed_url = urlparse(url)\nparams = parse_qs(parsed_url.query)\nparams['page'] = 22 # changing query parameters\n\nnew_url = url.replace(parsed_url.query, urlencode(params))\n\n" ]

[ 9, 6, 0 ]

[]

[]

[ "python", "url", "urllib" ]

[ "# you can try some thing like \ndate=datetime.datetime(2023, 3, 1, 0, 0,)\ntimestamp = pd.Timestamp(date, tz='Europe/Paris') #Convert timezone of timestamp.\nprint(timestamp)\n\nafter looking into p1 and p2 and trying to find the difference i found out this :\nprint(p1,p2)\nprint(d1,d2)\nprint(p2.astimezone(utc))\nprint(d2.astimezone(utc))\nprint(d1.astimezone(utc))\nprint(p1.astimezone(utc))\nprint(p2.astimezone(utc) - p1.astimezone(utc))\nprint(p2 - p1)\nprint(d2-d1)\nprint(d2.astimezone(utc) - d1.astimezone(utc))\n\n2023-03-01 00:00:00+01:00 2023-09-01 00:00:00+02:00\n2023-03-01 00:00:00+01:00 2023-09-01 00:00:00+02:00\n2023-08-31 22:00:00+00:00\n2023-08-31 22:00:00+00:00\n2023-02-28 23:00:00+00:00\n2023-02-28 23:00:00+00:00\n183 days 23:00:00\n183 days 23:00:00\n184 days, 0:00:00\n183 days, 23:00:00\n\n# if you can see the difference between both p1 and p2 also d1 d2 its slightly #different :\n#184 days, 0:00:00\n#183 days, 23:00:00 \n\ndate=datetime.datetime(2023, 3, 1, 0, 0,)\ndate2=datetime.datetime(2023, 9, 1, 0, 0,)\ntimestamp = pd.Timestamp(date, tz='Europe/Paris') #Convert timezone of timestamp.\ntimestamp2 = pd.Timestamp(date2, tz='Europe/Paris')\nso p2-p1 == timestamp2-timestamp\n\n\n" ]

[ 0 ]

[]

[]

[ "datetime", "pandas", "python", "python_datetime", "timezone" ]

[ "Use this. I hope that I can help you with it.\nclient = MyClient(intents=intents)\nt = app_commands.CommandTree(client)\n\[email protected](name=\"clear\", description=\"Clear n messages specific user\", guild=discord.Object(id=867851000286806016))\nasync def self(ctx, interaction: discord.Interaction, amount: int, member: discord.Member):\n channel = interaction.channel\n\n def check_author(m):\n return m.author.id == member.id\n await ctx.channel.purge(limit=amount, check=check_author)\n await ctx.send(f\"Successfully deleted {amount} messages from {member.name}\") \n\n" ]

[ 0 ]

[]

[]

[ "discord.py", "python" ]

[ "\nI guess you are using Selenium 4. If so find_element_by_* are no more supported there. You need to use the modern syntax of driver.find_element(By. as folllowing.\nYou need to introduce WebDriverWait expected_conditions to wait for element to become clickable.\n\nThe following code works\nfrom selenium import webdriver\nfrom selenium.webdriver.chrome.service import Service\nfrom selenium.webdriver.chrome.options import Options\nfrom selenium.webdriver.support.ui import WebDriverWait\nfrom selenium.webdriver.common.by import By\nfrom selenium.webdriver.support import expected_conditions as EC\n\noptions = Options()\noptions.add_argument(\"start-maximized\")\n\nwebdriver_service = Service('C:\\webdrivers\\chromedriver.exe')\ndriver = webdriver.Chrome(options=options, service=webdriver_service)\nwait = WebDriverWait(driver, 10)\n\nurl = \"https://splendour.themerex.net/contact/\"\ndriver.get(url)\n\nwait.until(EC.element_to_be_clickable((By.CSS_SELECTOR, \"input[type='submit']\"))).click()\n\n" ]

[ 0 ]

[]

[]

[ "python", "selenium", "selenium4", "webdriverwait" ]

[ "From the Pension class object's perspective it doesn't actually matter how is the growth provided. Also in this case maybe it's worth to make the result a property, then there's no need to call it as a function (just access like any other property, but the values will be calculated \"dynamically\").\nYou can customize the __str__ method to return any str representation of your object.\nclass Pension:\n def __init__(self, name,age,savings,growth):\n self.name = name\n self.age = age\n self.savings = savings\n self.growth = growth\n self._result = result\n\n @property\n def result(self):\n amount=self.savings\n rate=1+(self.growth/100)\n years=65-self.age\n return (amount * (1 - pow(rate, years))) / (1 - rate)\n\n\n def __str__(self):\n return f\"Pension:\\n{self.amount=}\\n{self.age=}\\n{self.savings}\\n{self.growth=}\\n{self.result}\"\n\nAnd then just:\nfor p in pensions:\n print(p)\n\n" ]

[ 0 ]

[]

[]

[ "class", "methods", "printing", "python" ]

[ "This isn't a full solution, more like some thoughts that may lead to one. Also, someone please double-check my math.\nVariables and test data\nFirst, let's begin by defining some test data. While doing so, I transpose the a1a2a3a4 matrix because it will prove more conventient. Plus, I'm renaming it to a14 because I cannot be bothered writing the whole thing all the time, sorry.\nimport numpy as np\nfrom numpy import linalg, random\nfrom scipy import optimize\n\na14 = random.uniform(-1., 1., (500, 4)) * (0.25, 0.75, 1., 2.)\nat = random.uniform(-1., 1., 500)\nxpoints = np.cumsum(random.random(500))\ninitial_guess = np.full(4, 0.25)\n\nTarget\nOkay, here is my first slight point of confusion: OP described the target as the \"area difference\" between two graphs. X coordinates are given by xpoints. Y coordinates of the target are given as at and we search coeffs so that a14 @ coeffs gives Y coordinates close to the target.\nNow, when we talk \"area under the graph\", my first instinct is piecewise linear. Similar to the trapezoidal rule this gives us the formula sum{(y[i+1]+y[i]) * (x[i+1]-x[i])} / 2.\nWe can reformulate that a bit to get something of the form (y[0]*(x[1]-x[0]) + y[1]*(x[2]-x[0]) + y[2]*(x[3]-x[1]) + ... + y[n-1]*(x[n-1]-x[n-2])) / 2. We want to precompute the x differences and scaling factor.\nweights = 0.5 * np.concatenate(\n ((xpoints[1] - xpoints[0],),\n xpoints[2:] - xpoints[:-2],\n (xpoints[-1] - xpoints[-2],)))\n\nThese factors are different from the ones OP used. I guess they are integrating a piecewise constant function instead of piecewise linear? Anyway, switching between these two should be simple enough so I leave this here as an alternative.\nLoss function\nAdapting OP's loss function to my interpretation gives\ndef loss(coeffs):\n absdiff = abs(at - (a14 * coeffs).sum(axis=1))\n return (absdiff * weights).sum()\n\nAs I've noted in comments, this can be simplified by using matrix vector multiplications.\ndef loss(coeffs):\n return abs(a14 @ coeffs - at) @ weights\n\nThis is the same as abs((a14 * weights[:, np.newaxis]) @ coeffs - (at * weights)).sum() which in turn makes it obvious that we are talking about minimizing the L1 norm.\na14w = a14 * weights[:, np.newaxis]\natw = at * weights\ndef loss(coeffs):\n return linalg.norm(a14w @ coeffs - atw, 1)\n\nThis isn't a huge improvement as far as computing the loss function goes. However, it goes a long way towards pressing our problem into a regular pattern.\nApproximate solution\nAs noted in comments, the abs() function in the L1 norm is poison for optimization because it is non-differentiable. If we switch to an L2 norm, we basically have a least squares fit with additional constraints. Of course this is somewhat unsound as we start solving a different, if closely related, problem. I suspect the solution would be \"good enough\"; or it could be the starting solution that is then polished to conform with the actual target.\nIn any case, we can use scipy.optimize.lsq_linear as a quick and easy solver. However, that one does not support linearity constraints. We can mimic that with a regularization parameter.\ndef loss_lsqr(coeffs):\n return 0.5 * linalg.norm(a14w @ coeffs - atw)**2\n\ngrad1 = a14w.T @ a14w\ngrad2 = a14w.T @ at\ndef jac_lsqr(coeffs):\n return grad1 @ coeffs - grad2\n\nregularization = loss_lsqr(initial_guess) # TODO: Pick better value\na14w_regular = np.append(a14w, np.full((1, 4), regularization), axis=0)\natw_regular = np.append(atw, regularization)\napprox = optimize.lsq_linear(a14w_regular, atw_regular, bounds=(0., 1.))\n\n# polish further, maybe?\nbounds = ((0., 1.),) * 4\nconstraint = optimize.LinearConstraint(np.ones(4), 1., 1.)\nsecond_guess = approx.x\nsecond_guess /= linalg.norm(second_guess) # enforce constraint\nexact = optimize.minimize(\n loss_lsqr, second_guess, jac=jac_lsqr,\n bounds=bounds, constraints=constraint)\n\n" ]

[ 2 ]

[]

[]

[ "optimization", "performance", "python", "scipy", "scipy_optimize" ]

[ "This sounds like a good use case for scipy cdist, also discussed here.\nimport pandas as pd\nfrom scipy.spatial.distance import cdist\n\n\ndata1 = {'Lat': pd.Series([50.6373473,50.63740441,50.63744285,50.63737839,50.6376054,50.6375896,50.6374239,50.6374404]),\n 'Lon': pd.Series([3.075029928,3.075068636,3.074951754,3.074913884,3.0750528,3.0751209,3.0750246,3.0749554]),\n 'Zone': pd.Series(['A','A','A','A','B','B','B','B'])}\n\ndata2 = {'Lat': pd.Series([50.6375524099,50.6375714407]),\n 'Lon': pd.Series([3.07507914474,3.07508201591])}\n\n\ndef closest_point(point, points):\n \"\"\" Find closest point from a list of points. \"\"\"\n return points[cdist([point], points).argmin()]\n\ndef match_value(df, col1, x, col2):\n \"\"\" Match value x from col1 row to value in col2. \"\"\"\n return df[df[col1] == x][col2].values[0]\n\n\ndf1 = pd.DataFrame(data1)\ndf2 = pd.DataFrame(data2)\n\ndf1['point'] = [(x, y) for x,y in zip(df1['Lat'], df1['Lon'])]\ndf2['point'] = [(x, y) for x,y in zip(df2['Lat'], df2['Lon'])]\n\ndf2['closest'] = [closest_point(x, list(df1['point'])) for x in df2['point']]\ndf2['zone'] = [match_value(df1, 'point', x, 'Zone') for x in df2['closest']]\n\nprint(df2)\n# Lat Lon point closest zone\n# 0 50.637552 3.075079 (50.6375524099, 3.07507914474) (50.6375896, 3.0751209) B\n# 1 50.637571 3.075082 (50.6375714407, 3.07508201591) (50.6375896, 3.0751209) B\n\n", "note that the current title of the post Find closest point in Pandas DataFrames but OP's attempt shows that they are looking for the zone within which a point is found.\nIt is possible to leverage the geopandas library to do this operation elegantly & efficiently.\nConvert the DataFrame into a GeoDataFrame.\nThen aggregate the points in df1 to create a polygon. The aggregation operation is called dissolve.\nFinally, use a spatial join sjoin with the predicate such that points in df2 are covered by the polygon representing a Zone in zones and output the Lat, Lon&Zone` columns.\n# set up\nimport pandas as pd\nimport geopandas as gpd\n\ndf1 = pd.DataFrame({\n 'Id': [1, 1, 1, 1, 2, 2, 2, 2],\n 'Order': [1, 2, 3, 4, 1, 2, 3, 4],\n 'Lat': [50.6373473, 50.63740441, 50.63744285, 50.63737839, 50.6376054, 50.6375896, 50.6374239, 50.6374404], \n 'Lon': [3.075029928, 3.075068636, 3.074951754, 3.074913884, 3.0750528, 3.0751209, 3.0750246, 3.0749554],\n 'Zone': ['A', 'A', 'A', 'A', 'B', 'B', 'B', 'B']\n})\n\ndf2 = pd.DataFrame({\n 'Lat': [50.6375524099, 50.6375714407],\n 'Lon': [3.07507914474, 3.07508201591] \n})\n\n# convert to GeoDataFrame\ndf1 = gpd.GeoDataFrame(df1, geometry=gpd.points_from_xy(df1.Lon, df1.Lat))\ndf2 = gpd.GeoDataFrame(df2, geometry=gpd.points_from_xy(df2.Lon, df2.Lat))\n\n# aggregate & merge\nzones = df1.dissolve(by='Zone').convex_hull.rename('geometry').reset_index()\nmerged = df2.sjoin(zones, how='left', predicate='covered_by')\n\n# output\noutput_columns = ['Lat', 'Lon', 'Zone']\nmerged[output_columns]\n\nthis outputs:\n Lat Lon Zone\n0 50.637552 3.075079 B\n1 50.637571 3.075082 B\n\n" ]

[ 14, 0 ]

[]

[]

[ "pandas", "postgresql", "python" ]

[ "df.to_csv(\"output.csv\", index=False)\n\nOR\ndf.to_excel(\"output.xlsx\")\n\n", "You can write the dataframe to excel using the pandas ExcelWriter, such as this:\nimport pandas as pd\nwith pd.ExcelWriter('path_to_file.xlsx') as writer:\n dataframe.to_excel(writer)\n\n", "If you want to create multiple sheets in the same file\nwith pd.ExcelWriter('csv_s/results.xlsx') as writer:\n same_res.to_excel(writer, sheet_name='same')\n diff_res.to_excel(writer, sheet_name='sheet2')\n\n" ]

[ 21, 3, 0 ]

[]

[]

[ "pandas", "python" ]

[ "I solved this issue by using the older keras h5 format:\nh5-format\nSimply load and save the model with the .h5 extension:\nmodel.save('model_name.h5')\nloaded_model = keras.model.load_model('model_name.h5')\n\n", "For me this happened when I trained a network on computer1 and tried to predict using it on computer2. Might be related to differing tensorflow of h5py versions\n", "You have saved your model using .save_model method of the tensorflow.keras.models. This by default saves it in SavedModel format of tensorflow.\nWhen you load back the model using tensorflow.keras.models.load_model method, you can use the predict method of the model.\nmodel = tf.keras.models.load_model(<saved_model_folder>)\npredictions = model.predict(input_tensor)\n\nBut if you try to load the same model, which was saved using the tf.keras.models.save_model, using tf.saved_model.load you have to do it in this way:\nmodel = tf.saved_model.load(<saved_model_folder>)\npredictions = model(input_tensor) # Notice predict is not used.\n\nThe is written in the Note section of https://www.tensorflow.org/api_docs/python/tf/keras/Model#call.\nIf you want inference(predict) function, you can do it as follows:\nmodel_loaded = tf.keras.models.load_model(<saved_model_folder>)\nDEFAULT_FUNCTION_KEY = 'serving_default'\npredict_func = model_loaded.signatures[DEFAULT_FUNCTION_KEY]\n\nfor batch in predict_dataset.take(1):\n print(predict_func(batch))\n\nI think you are using keras API to save and saved_model API to load the model and hence the issue.\n" ]

[ 4, 1, 0 ]

[]

[]

[ "python" ]

[ "You need an else. Boiling down your error:\nx = 1 if True\n\n File \"<stdin>\", line 1\n x = 1 if True\n ^\nSyntaxError: invalid syntax\n\n\n# No error here\nx = 1 if True else 2\n\nSince you are using a dictionary, maybe use dict.get:\ntable['sp1 name'] = table['sp1'].apply(lambda x: sp1_new_dict.get(x))\n\nWhich returns None if the key isn't present\n" ]

[ 2 ]

[]

[]

[ "dictionary", "lambda", "pandas", "python" ]

[ "If you do not want to keep first_name and last_name in User then you can\n\ncustomize __init__.\nuse validator for setting full_name.\n\nBoth methods do what you want:\nfrom typing import Optional\nfrom pydantic import BaseModel, validator\n\n\nclass UserDB(BaseModel):\n first_name: Optional[str] = None\n last_name: Optional[str] = None\n\n\nclass User_1(BaseModel):\n location: str # for a change\n full_name: Optional[str] = None\n\n def __init__(self, user_db: UserDB, **data):\n super().__init__(full_name=f\"{user_db.first_name} {user_db.last_name}\", **data)\n\n\nuser_db = UserDB(first_name=\"John\", last_name=\"Stark\")\nuser = User_1(user_db, location=\"Mars\")\nprint(user)\n\n\nclass User_2(BaseModel):\n first_name: Optional[str] = None\n last_name: Optional[str] = None\n full_name: Optional[str] = None\n\n @validator('full_name', always=True)\n def ab(cls, v, values) -> str:\n return f\"{values['first_name']} {values['last_name']}\"\n\n\nuser = User_2(**user_db.dict())\nprint(user)\n\noutput\nlocation='Mars' full_name='John Stark'\nfirst_name='John' last_name='Stark' full_name='John Stark'\n\nUPDATE:\nFor working with response_model you can customize __init__ in such way:\nclass User_1(BaseModel):\n location: str # for a change\n full_name: Optional[str] = None\n\n # def __init__(self, user_db: UserDB, **data):\n def __init__(self, first_name, last_name, **data):\n super().__init__(full_name=f\"{first_name} {last_name}\", **data)\n\n\nuser_db = UserDB(first_name=\"John\", last_name=\"Stark\")\nuser = User_1(**user_db.dict(), location=\"Mars\")\nprint(user)\n\n", "I created a pip package that seems to do exactly what you need. Here is the link: https://pypi.org/project/pydantic-computed/\nYour example would then look like this:\nfrom pydantic import BaseModel\nfrom pydantic_computed import Computed, computed\n\nclass UserDB(BaseModel):\n first_name: Optional[str] = None\n last_name: Optional[str] = None\n\nclass User(UserDB):\n full_name: Computed[str]\n\n @computed('full_name')\n def compute_full_name(first_name: str, last_name: str):\n return first_name + ' ' + last_name\n\n\n# parsing also works as normal:\nuser_db = UserDB(first_name='John', last_name='Doe')\nuser = User.parse_obj(user_db)\nprint(user.full_name) # Outputs \"John Doe\"\n\n\nThis will also work for response_model (e.g. in FastAPI) since the computed value is actually set on the full_name property.\n" ]

[ 16, 0 ]

[]

[]

[ "fastapi", "pydantic", "python" ]

[ "You need to use the datetime accessor dt like this:\nlistOfDates = df2['TradeDate'].drop_duplicates().reset_index(drop=True).dt.strftime(\"%Y%m%d\")\n\nDocumented here\n" ]

[ 1 ]

[]

[]

[ "pandas", "python", "series" ]

[ "You can use to to_dict method like so:\nimport pandas as pd\n\nrows = [\n {'a': 1, 'b': 2},\n {'a': 3, 'b': 4},\n]\n\ndf = pd.DataFrame(rows)\n\n# define new column as the json format of another\n# also convert to str as that is what you have in your output\ndf['c'] = df[['a', 'b']].astype(str).to_dict(orient='records')\n\nto_dict has a really nice interface for transforming to JSON format or to other object types. In this instance you are looking for orient='records' which is a list of dictionaries.\nIn your case, you will use:\ndf['new_column'] = df[\n ['Analysis', 'Dexterity', 'Skills']\n].astype(str).to_dict(orient='records')\n\n" ]

[ 4 ]

[]

[]

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

[ "You have to actually call the functions. Further, you don't want to return until you actually call all three. You also don't need any additional variables; Question1 is already a variable that refers to the function originally bound to it.\ndef questionfunction():\n questionlist = [Question1, Question2, Question3]\n random.shuffle(questionlist)\n questionlist[0]()\n questionlist[1]()\n questionlist[2]()\n\nYou could, alternatively, just return the shuffled list and let the caller call the functions.\ndef questionfunction():\n questionlist = [Question1, Question2, Question3]\n random.shuffle(questionlist)\n return questionlist\n\nfor q in questionfunction():\n q()\n\n" ]

[ 0 ]

[]

[]

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

[ "You can use unpacking when iterate over elements of the list.\n>>> [[a[:-4], b] for (a, b) in lst]\n[['ABC', 'X'], ['DCS', 'X'], ['SCS', 'X'], ['SFA', 'X']]\n\n" ]

[ 1 ]

[]

[]

[ "list", "python" ]

[ "Configuration directives and command line options are managed by the same parser: https://uwsgi-docs.readthedocs.org/en/latest/Configuration.html\nIn the case of the ini format you only need to remove the double dashes before the option.\n", "uwisgi.ini \nstats = :1717 --stats-http\n\nDocumentation: http://uwsgi-docs.readthedocs.org/en/latest/StatsServer.html\n", "This worked for me:\nstats = 0.0.0.0:6000\nstats-http = true\n\n" ]

[ 4, 4, 0 ]

[]

[]

[ "ini", "python", "uwsgi" ]

[ "When extracting values from the dictionary you need to validate their existence. You may even want to check the data type(s).\nThere is no need for global variables in this case.\nThe main method might as well be static as it does not depend upon any other attributes of the Solution class.\nSomething like this will suffice and be more robust:\nclass Solution:\n @staticmethod\n def total_profit(di):\n cp = di.get('cost_price')\n sp = di.get('sell_price')\n iv = di.get('inventory')\n if cp and sp and iv:\n return (sp - cp) * iv\n # implicit return of None if any keys unavailable\n\n\ndt = {\"cost_price\": 2.77,\n \"sell_price\": 7.95,\n \"inventory\": 8500}\n\nprint(Solution.total_profit(dt))\n\nOutput:\n44030.0\n\n", "In your first \"elif\" block indeed the inventory variable is unbound (it hasn't been defined before). The line earlier you just checked if k is equal to string \"inventory\", but as explained below it never is in your case.\nTLDR;\nAin't somebody learning for a interview huh? :D\nBy default if you loop over a dictionary you are looping over its keys.\nEnumerate yields idx of an iterable and its value. So you are mixing stuff here.\nThis (compare with your case please):\n x = {\"a\":5, \"b\":77}\n for k,v in enumerate(x):\n print(k,v)\n\nWill print for you:\n 0, \"a\"\n 1, \"b\"\n\nRather not what you are aiming at. So iterate using .items(), which will give you pairs of key, value on each loop iteration.\n" ]

[ 0, 0 ]

[]

[]

[ "dictionary", "global_variables", "python" ]