Datasets:

suriyagunasekar

/

stackoverflow-python-with-meta-data

like 9

[ "The easiest way to do hover text is to use fig.data (in your case, plot_impo_usos.data). to get the graph configuration data, so it is easy to customize it. So copy the hover template that is set up for the two listograms and edit it. Being able to customize it with the configuration information gives you more freedom of expression.\nimport plotly.express as px\n\nplot_impo_usos = px.histogram(df_grafico2[df_grafico2.Usos != \"Total\"],\n x = \"Usos\",\n y = \"Dolares\",\n color=\"Periodo\",\n barmode=\"group\",\n template=\"none\",\n hover_data =[\"Periodo\", \"Dolares\"],\n )\n\nplot_impo_usos.data[0].hovertemplate = 'Periodo: Octubre 2021*<br>Usos: %{x}<br>Dolares: $%{y}<extra></extra>'\nplot_impo_usos.data[1].hovertemplate = 'Periodo: Octubre 2022*<br>Usos: %{x}<br>Dolares: $%{y}<extra></extra>'\n\nplot_impo_usos.update_yaxes(tickformat = \",\",\n title_text='En millones de USD')\nplot_impo_usos.update_layout(separators=\",.\",\n font_family='georgia',\n title_text = \"Importación por usos económicos. Octubre de 2022 y octubre de 2021\",\n legend=dict(\n yanchor=\"top\",\n orientation = \"h\",\n y=1.07,\n xanchor=\"left\",\n x=0.3\n )\n )\n\nplot_impo_usos.show()\n\n\n", "You were very close, in hovertemplate you just need to use %{fullData.name} instead of %{color} :\nplot_impo_usos.update_traces(\n hovertemplate='Periodo: %{fullData.name}<br>Uso: %{x}<br>Dolares: %{y:$,.2f}<extra></extra>'\n)\n\nNb. When using hovertemplate, there is this \"secondary box\" that appears next to the hover box, which is (quite often) annoying :\n\nAnything contained in tag <extra> is displayed in the secondary box,\nfor example \"{fullData.name}\". To hide the secondary\nbox completely, use an empty tag <extra></extra>.\n\nNote also that fullData.name is the name of the (hovered) trace, which, when using px.histogram(), is set automatically according to the value of color.\n" ]

[ 1, 0 ]

[]

[]

[ "plotly", "plotly_express", "python" ]

[ "You can try with set_index with stack + unstack\nout = (df.set_index(['ID','Test','Year']).\n stack().unstack(level=1).\n add_suffix('_Score').reset_index())\nout\nOut[271]: \nTest ID Year level_2 Math_Score Writing_Score\n0 1 2008 Fall 15 22\n1 1 2008 Spring 16 22\n2 1 2008 Winter 19 24\n3 1 2009 Fall 12 10\n4 1 2009 Spring 13 14\n5 1 2009 Winter 27 20\n6 2 2008 Fall 12 13\n7 2 2008 Spring 13 11\n8 2 2008 Winter 25 29\n9 2 2009 Fall 16 23\n10 2 2009 Spring 14 20\n11 2 2009 Winter 21 26\n\n", "Here is another solution:\nimport pandas as pd\n\ndata = {'ID': [1, 1, 1, 1, 2, 2, 2, 2],\n 'Test': ['Math', 'Math', 'Writing', 'Writing', 'Math', 'Math', 'Writing', 'Writing'],\n 'Year': ['2008', '2009', '2008', '2009', '2008', '2009', '2008', '2009'],\n 'Fall': [15, 12, 22, 10, 12, 16, 13, 23],\n 'Spring': [16, 13, 22, 14, 13, 14, 11, 20],\n 'Winter': [19, 27, 24, 20, 25, 21, 29, 26]}\ndf_data = pd.DataFrame(data, columns=['ID', 'Test', 'Year', 'Fall', 'Spring', 'Winter'])\n\ndf = df_data.melt(id_vars=['ID', 'Year', 'Test'], var_name='Quarter', value_name='Score')\ndf = df.pivot(index=['ID', 'Year', 'Quarter'], columns=['Test'], values=['Score'])\ndf.columns = df.columns.droplevel(level=0)\ndf = df.add_suffix('_Score').reset_index(drop=False)\n\n", "This requires two pivoting operations using tidypandas:\nimport pandas as pd\nfrom tidypandas.tidy_accessor import tp\n\ndata = {'ID': [1, 1, 1, 1, 2, 2, 2, 2],\n 'Test': ['Math', 'Math', 'Writing', 'Writing', 'Math', 'Math', 'Writing', 'Writing'],\n 'Year': ['2008', '2009', '2008', '2009', '2008', '2009', '2008', '2009'],\n 'Fall': [15, 12, 22, 10, 12, 16, 13, 23],\n 'Spring': [16, 13, 22, 14, 13, 14, 11, 20],\n 'Winter': [19, 27, 24, 20, 25, 21, 29, 26]}\ndf_data = pd.DataFrame(data, columns=['ID', 'Test', 'Year', 'Fall', 'Spring', 'Winter'])\n\n>>> (df_data.tp.pivot_longer(cols = ['Fall', 'Spring', 'Winter'],\n... names_to='quarter'\n... )\n... .tp.pivot_wider(id_cols = ['ID', 'quarter', 'Year'],\n... names_from = 'Test',\n... values_from = 'value',\n... names_prefix = 'score_'\n... )\n... )\n Year quarter ID score_Math score_Writing\n0 2008 Fall 1 15 22\n1 2009 Fall 1 12 10\n2 2008 Spring 1 16 22\n3 2009 Spring 1 13 14\n4 2008 Winter 1 19 24\n5 2009 Winter 1 27 20\n6 2008 Fall 2 12 13\n7 2009 Fall 2 16 23\n8 2008 Spring 2 13 11\n9 2009 Spring 2 14 20\n10 2008 Winter 2 25 29\n11 2009 Winter 2 21 26\n\n" ]

[ 0, 0, 0 ]

[]

[]

[ "pandas", "python" ]

[ "The real error in your case is:\nImportError: cannot import name 'msvccompiler' from 'distutils'\n\nIt occured because setuptools has broken distutils in version 65.0.0 (and has already fixed it in version 65.0.2). According to your log, the error occured in your global setuptools installation (see the path in error message), so you need to update it with the following command:\npip install -U setuptools\n\nThose packages, however, may still not get installed or not work properly as the module causing this error doesn't support compiler versions needed for currently supported versions of Python.\n", "Same thing happened with me, it was basically pip's version problem.\nTry upgrading pip to latest version --22.3.1 and downgrade the python version from latest version --3.10.00 to 3.9.13...\npip --version check for pip's version\npip install notebook --upgrade -command to update pip to latest version\nThis worked for me\n" ]

[ 1, 0 ]

[]

[]

[ "dependencies", "pip", "python", "setup.py", "setuptools" ]

[ "You can retrieve them by checking whether contains the data-original-title attribute.\nSelenium:\ndriver.find_elements(by=By.XPATH, value=\"//*[contains(@data-original-title, '')]\")\n\nBeautifulsoup:\nsoup.find_all(\"span\", attrs={\"data-original-title\": True})\n\n\nOutput:\n[<span class=\"c-form-control-feedback c-form-control-feedback-error\" data-original-title=\"that username is already taken\" title=\"\"></span>]\n\n" ]

[ 1 ]

[]

[]

[ "python", "selenium" ]

[ "This solution avoids for loops and instead uses a temporary data frame to perform the task. The strings in the Unnamed: 4 column are split using the str.split() function provided by Pandas. The MAIN_METHOD information is transformed using a mapping. The df1 data frame is conditionally updated using numpy.where() before the temporay data frame is deleted.\nEDIT: The code has been modified to convert the temporary data frame column series to a numpy array using .values to avoid the error:\nValueError: Can only compare identically-labeled Series objects\n\nModified np.where() conditions:\ndf1['DRUG_ETCDTL'] = np.where(((df1['KEY']==tmp_df['KEY'].values) & \n (df1['MAIN_METHOD']==tmp_df['MAIN_METHOD'].values)),\n tmp_df['DRUG_ETCDTL'],\n df1['DRUG_ETCDTL'])\n\nAn alternative solution to avoiding the error would be to use .equals() instead of == when performing the comparison.\ndf1['DRUG_ETCDTL'] = np.where(((df1['KEY'].equals(tmp_df['KEY'])) & \n (df1['MAIN_METHOD'].equals(tmp_df['MAIN_METHOD']))),\n tmp_df['DRUG_ETCDTL'],\n df1['DRUG_ETCDTL'])\n\nComplete solution:\nimport pandas as pd\nimport numpy as np\n\ndf1 = pd.DataFrame({ \n 'KEY': [100944, 67488, 101476, 102549, 103227],\n 'MAIN_METHOD': [1, 20, 20, 1, 1],\n 'DRUG_ETCDTL': ['unknown', 'unknown', 'unknown', 'sleepingpill_plunitrazeparm', 'some drug']\n}, index=np.arange(11,16))\n\ndf2 = pd.DataFrame({\n '5. 방법/수단': [100944, 100984, 101476, 102549, 103227],\n 'Unnamed: 4': ['sleepingpill_unknown', 'others_green material', 'others_anorexia', 'sleepingpill_plunitrazeparm', 'sleepingpill_pentobarbytal']\n})\n\n# make a temporary copy of 'df2'\ntmp_df = df2[['5. 방법/수단', 'Unnamed: 4']].copy()\n# rename columns\ntmp_df.columns = ['KEY', 'METHOD_DRUG']\n# split the string to get 'METHOD' and 'DRUG_ETCDTL' information\ntmp_df[['METHOD', 'DRUG_ETCDTL']] = tmp_df['METHOD_DRUG'].str.split('_', expand=True)\n# use a mapping to create 'MAIN_METHOD' column\nmethod_map = { 'sleepingpill': 1, 'others': 20 }\ntmp_df['MAIN_METHOD'] = tmp_df['METHOD'].map(method_map)\n# drop unwanted columns (This step is optional)\ntmp_df.drop(['METHOD_DRUG', 'METHOD'], inplace=True, axis=1)\n# update 'df1'\ndf1['DRUG_ETCDTL'] = np.where(((df1['KEY']==tmp_df['KEY'].values) & \n (df1['MAIN_METHOD']==tmp_df['MAIN_METHOD'].values)),\n tmp_df['DRUG_ETCDTL'],\n df1['DRUG_ETCDTL'])\n# delete temporary copy of 'df2'\ndel tmp_df\n\n" ]

[ 0 ]

[]

[]

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

[ "Have you ever considered using \"GitHub-Actions\", or \"Google Firebase-Cloud Functions\" ? Those sound like good candidates for your demand.\n" ]

[ 0 ]

[]

[]

[ "heroku", "python", "pythonanywhere" ]

[ "Based on what i understand you want to add something at the end of the name file to prevent throwing an error.\nimport time\nFILE_NAME = f\"output-{time.time()}.png\"\nimg.save(FILE_NAME)\n\n", "Try this:\n\nPut all your code into a while true loop.\n\nDeclare a variable \"num\" and assign it to the integer 0. MAKE SURE THIS IS OUTSIDE THE WHILE TRUE LOOP!\n\nChange your code so that this part:\nsrc_path = r\"D:\\Python\\QRcode generator\\output.png\"\ndst_path = r\"D:\\Users\"\nlooks like this:\nsrc_path = r\"D:\\Python\\QRcode generator\\output\" + str(num) + \".png\"\ndst_path = r\"D:\\Users\"\n\n\nnum += 1\n(note) If you close the program it will reset\n" ]

[ 0, 0 ]

[]

[]

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

[ "The following code can be used to set a column for checkbox value in MySQL in Python:\nfrom mysql.connector import connect\n\ndb_connection = connect(\n host='localhost',\n user='username',\n password='password',\n database='my_database'\n)\n\n# Create a cursor object\ncursor = db_connection.cursor()\n\n# Create a table\ncursor.execute(\"CREATE TABLE my_table (id INT, checkbox_value BOOLEAN)\")\n\n# Insert data into the table\nsql = \"INSERT INTO my_table (id, checkbox_value) VALUES (%s, %s)\"\nvalues = (1, 0)\ncursor.execute(sql, values)\n\n# Commit the changes to the database\ndb_connection.commit()\n\n" ]

[ 0 ]

[]

[]

[ "mysql", "python" ]

[ "Serial Connection Issue\nThis error AttributeError: module 'serial' has no attribute 'Serial' suggests that the package serial or a local file name serial.py has a conflict with pyserial. Rename your file to something else besides serial.py and/or uninstall the serial package (not needed for TCLab). Your pyserial package is the latest version.\npip uninstall serial\n\nThe error occurs when there is a local file named serial.py and we import from the pyserial module. Additional common TCLab help issues are posted to the TCLab setup and troubleshooting page.\n\nSerial Port Permission\nIf the serial uninstall doesn't fix the problem of allowing a serial connection, one other thing to check is the USB port permission. On Linux, discover the USB port name with ls /dev/tty* Set the permission for that USB connection with the correct name.\nsudo chmod a+rw /dev/ttyACM0\n\nPython 3.10 Compatibility\nYou correctly found the issue with installing the latest version of TCLab for Python 3.10 compatibility. The module developer is still working on the next version of the TCLab package. Until that point, you can either edit the historian.py file (path is in the error message) with a text editor and change from collections import Iterable to from collections.abc import Iterable or install the new package from GitHub:\npip install --upgrade https://github.com/jckantor/TCLab/archive/master.zip\n\nThis will be resolved with the next release of TCLab on PyPI.org. The current version is 0.4.9 that does not include Python 3.10 compatibility because of the Iterable package change.\n" ]

[ 1 ]

[]

[]

[ "iterable", "python" ]

[ "Fix\nThat is because type(user_input) returns a type, not a string, don't confuse yourself with what you see printed and the real thing. When you print something you only see a representation of the thing. Only if it's a string you can copy and compare it directly\nprint(type(type(user_input))) # <class 'type'>\n\nSo you well understand, this is how it would work using type\nif str(type(user_input)) == \"<class 'int'>\":\n print('This is a integer.')\n\nif type(user_input) == int:\n print('This is a integer.')\n\nif type(user_input) is int:\n print('This is a integer.')\n\nImprove\nThe prefered way should be\nif isinstance(user_input, int):\n print('This is a integer.')\n\n", "Its because you're comparing it to the wrong thing. if you did \"type(user_input) == int\" your program should work as expected.\n", "You can use the isinstance method as mentioned above or just directly compare to the int like: \nuser_input = int(input('Enter input: '))\n\nif type(user_input) is int:\n print('This is a integer.')\n\n" ]

[ 0, 0, 0 ]

[]

[]

[ "conditional_statements", "if_statement", "input", "python", "types" ]

[]

[]

[ "To set an env variable in a jupyter notebook, just use a % magic commands, either %env or %set_env , e.g., %env VAR = VALUE or %env VAR VALUE .\n" ]

[ -1 ]

[ "jupyter_notebook", "python", "set" ]

[ "Data loading\nI have made a simple class that demonstrates a reasonable approach to doing so. Mind you, I am not that familiar with TensorFlow, mainly using PyTorch, so the code might not be optimized.\nYou are probably best at defining a custom generator if one can't be used for this. After reading the comments, I noticed that you don't want to compute all ahead of time all the values; this would do so because we are only keeping the underlying data in self.data and creating new tensors based on this.\nimport tensorflow as tf\nimport numpy as np\nv = np.array([[12055., 11430., 10966., 12055., 11430., 10966.], \n [11430., 10966., 10725., 11430., 10966., 10725.],\n [10966., 10725., 10672.,10966., 10725., 10672.]])\nq = tf.constant(v)\nclass MyData():\n\n def __init__(self, data, windows_size):\n self.data = data\n self.windows_size = windows_size\n self._dataset = tf.data.Dataset.from_generator(self._generator,\n output_types=tf.float32,\n output_shapes=(self.windows_size, self.data.shape[1]))\n\n def _generator(self):\n for i in range(self.data.shape[0] - self.windows_size + 1):\n yield self.data[i:i+self.windows_size]\n \n def __len__(self):\n return self.data.shape[0] - self.windows_size + 1\n\n def get_dataset(self):\n return self._dataset\n# Example usage:\ntest = MyData(q, 2)\nit = iter(test.get_dataset())\n\nfor data in it:\n print(data.shape)\n\nThis produces tensors that have a windows_size for the first dimension. The code was made to work with [N, DATA] -> [W, DATA], where N is for the time_series, and W is for the reduced window size; I added part of the example code from the previous link.\nModel design\nMultiple design decisions can be made for the model design.\nFirstly, you can treat it as an embedding problem (Embedding layer). Then you can reshape it to use with your 2D convolutions.\nThe second approach is to reshape the data into something resembling 2D images directly. Note that the second approach will be bad if the sequence length changes between different examples. You cannot batchify the training without modifying the network (adding extra layers to process images depending on the size is not relatively straightforward).\nLastly, there already exist tutorials that do such things with features of time series data, shown below:\ndef basic_conv2D(n_filters=10, fsize=5, window_size=5, n_features=2):\n new_model = keras.Sequential()\n new_model.add(tf.keras.layers.Conv2D(n_filters, (1,fsize), padding=”same”, activation=”relu”, input_shape=(window_size, n_features, 1)))\n new_model.add(tf.keras.layers.Flatten())\n new_model.add(tf.keras.layers.Dense(1000, activation=’relu’))\n new_model.add(tf.keras.layers.Dense(100))\n new_model.add(tf.keras.layers.Dense(1))\n new_model.compile(optimizer=”adam”, loss=”mean_squared_error”) \n return new_model\nm2 = basic_conv2D(n_filters=24, fsize=2, window_size=window_size, n_features=data_train_wide.shape[2])\nm2.summary()\n\n" ]

[ 0 ]

[]

[]

[ "conv_neural_network", "python" ]

[ "The warning message you are seeing, RuntimeWarning: coroutine 'Transaction.rollback' was never awaited, is indicating that you are using an async context manager (async with session.begin()) but you are not awaiting the rollback of the transaction if an exception is raised.\nIn your code, you are using an async context manager to manage a database transaction. This means that the transaction will be automatically committed when the context manager exits normally, but it will be rolled back if an exception is raised. However, because you are not awaiting the rollback of the transaction, the Transaction.rollback coroutine is never actually executed and the warning message is displayed.\nTo fix this issue, you can simply add an await statement to the Transaction.rollback coroutine. Here's an example of how you could do this:\nasync with session.begin() as txn:\n retailer: model.Retailer = (await session.scalars(select(model.Retailer).filter(model.Retailer.name==\"default\"))).first()\n await session.execute(insert(model.Contact).values(mock_contact(retailer.uuid)))\n raise RuntimeError()\n # await the rollback of the transaction\n await txn.rollback()\n\n" ]

[ 0 ]

[]

[]

[ "python", "sqlalchemy" ]

[ "create new list and append only string that is not empty\nuse eval() if they are string representation of list\ndf['Description'] = df['Description'].apply(lambda x: [item for item in eval(x) if item != ''])\n\n" ]

[ 0 ]

[]

[]

[ "dataframe", "list", "pandas", "python", "string" ]

[ "I don't think this is possible. The expression group.Mary[\"strength\"] essentially consists of 2 steps:\n\nretrieving the attribute named \"Mary\" from the object group, and;\ncalling the method __getitem__ on the retrieved attribute with argument \"strength\".\n\nHowever, note that in your example you require Step 1 (group.Mary) to return 25, which is an integer. Unfortunately, integers can't also be a mapping (objects that implement __getitem__).\n", "Added to class a method to create dynamically the properties but, for example, it can also be refactor as global function.\nEach attribute is private and its access is ruled by the descriptors. Notice the private attributes created dynamically required a bit more of care, see this for details and references.\nclass Person:\n @classmethod\n def property_factory(cls, name):\n # dynamical descriptors, -> private name mangling!\n p = property(fget=lambda self: getattr(self, f'_{cls.__name__}__{name}'), \n fset=lambda self, v: setattr(self, f'_{cls.__name__}__{name}', v))\n \n setattr(cls, name, p)\n\n def __init__(self, **p):\n # dynamically add properties\n for name in p.keys():\n self.property_factory(name)\n\n # initialization descriptors\n for name, d in p.items():\n setattr(self, name, d)\n\n\ndata = {\"Mary\": {\"age\":25, \"strength\": 80}, \"John\": {\"age\": 40, \"strength\": 70}}\n\np = Person(**data)\n\n# check property\nprint(type(p).Mary)\n#<property object at 0x7f5e5d469e00>\nprint(type(p.Mary))\n#<class 'dict'>\n\n# descriptors in action\np.Mary['age'] += 666\np.John['strength'] -= 666\nprint(p.John)\n#{'age': 40, 'strength': -596}\nprint(p.Mary)\n#{'age': 691, 'strength': 80}\n\n" ]

[ 0, 0 ]

[]

[]

[ "python" ]

[ "This is the problem which I faced during a production release.\nComplete details and the solution to this issue are discussed at -\nhttps://www.kaggle.com/code/adeepak7/load-old-sklearn-models-with-new-sklearn-package\n" ]

[ 0 ]

[]

[]

[ "model_management", "python", "python_3.x", "scikit_learn" ]

[ "The reason your code is only returning one day name is because weekday will never match more than one string in the days tuple and therefore won't add any of the days of the week that follow it (nor wrap around to those before it). Even if it did somehow, it would still return them all as one long string because you're initializing result to an empty string, not an empty list.\nHere's a solution that uses the datetime module to create a list of all the weekday names starting with \"Monday\" in the current locale's language. This list is then used to create another list of names in the desired order which is returned. It does the ordering by finding the index of designated day in the original list and then splicing together two slices of it relative to that index to form the result. As an optimization it also caches the locale's day names so if it's ever called again with the same current locale (a likely scenario), it won't need to recreate this private list.\nimport datetime\nimport locale\n\ndef weekdays(weekday):\n current_locale = locale.getlocale()\n if current_locale not in weekdays._days_cache:\n # Add day names from a reference date, Monday 2001-Jan-1 to cache.\n weekdays._days_cache[current_locale] = [\n datetime.date(2001, 1, i).strftime('%A') for i in range(1, 8)]\n days = weekdays._days_cache[current_locale]\n index = days.index(weekday)\n return days[index:] + days[:index]\n\nweekdays._days_cache = {} # initialize cache\n\nprint(weekdays('Wednesday'))\n# ['Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday', 'Monday', 'Tuesday']\n\nBesides not needing to hard-code days names in the function, another advantage to using the datetime module is that code utilizing it will automatically work in other languages. This can be illustrated by changing the locale and then calling the function with a day name in the corresponding language.\nFor example, although France is not my default locale, I can set it to be the current one for testing purposes as shown below. Note: According to this Capitalization of day names article, the names of the days of the week are not capitalized in French like they are in my default English locale, but that is taken into account automatically, too, which means the weekday name passed to it must be in the language of the current locale and is also case-sensitive. Of course you could modify the function to ignore the lettercase of the input argument, if desired.\n# set or change locale\nlocale.setlocale(locale.LC_ALL, 'french_france')\n\nprint(weekdays('mercredi')) # use French equivalent of 'Wednesday'\n# ['mercredi', 'jeudi', 'vendredi', 'samedi', 'dimanche', 'lundi', 'mardi']\n\n", "A far quicker approach would be to keep in mind, that the weekdays cycle. As such, we just need to get the first day we want to include the list, and add the remaining 6 elements to the end. Or in other words, we get the weekday list starting from the starting day, append another full week, and return only the first 7 elements (for the full week).\ndays = ('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday')\ndef weekdays ( weekday ):\n index = days.index( weekday )\n return list( days[index:] + days )[:7]\n\n>>> weekdays( 'Wednesday' )\n['Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday', 'Monday', 'Tuesday']\n\n", "def weekdays(day):\n days = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']\n i=days.index(day) # get the index of the selected day\n d1=days[i:] #get the list from an including this index\n d1.extend(days[:i]) # append the list form the beginning to this index\n return d1\n\nAnd if you want to test that it works: \ndef test_weekdays():\n days = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']\n for day in days:\n print weekdays(day)\n\n", "Hmm, you are currently only searching for the given weekday and set as result :)\nYou can use the slice ability in python list to do this:\nresult = days[days.index(weekday):] + days[:days.index(weekdays)]\n\n", "Here's more what you want:\ndef weekdays(weekday):\n days = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']\n index = days.index(weekday)\n return (days + days)[index:index+7]\n\n", "You don't need to hardcode array of weekdays. It's already available in calendar module.\nimport calendar as cal\n\ndef weekdays(weekday):\n start = [d for d in cal.day_name].index(weekday)\n return [cal.day_name[(i+start) % 7] for i in range(7)]\n\n", "Your result variable is a string and not a list object. Also, it only gets updated one time which is when it is equal to the passed weekday argument.\nHere's an implementation:\nimport calendar\n\ndef weekdays(weekday):\n days = [day for day in calendar.day_name]\n for day in days:\n days.insert(0, days.pop()) # add last day as new first day of list \n if days[0] == weekday: # if new first day same as weekday then all done\n break \n return days\n\nExample output:\n>>> weekdays(\"Wednesday\")\n['Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday', 'Monday', 'Tuesday']\n>>> weekdays(\"Friday\")\n['Friday', 'Saturday', 'Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday']\n>>> weekdays(\"Tuesday\")\n['Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday', 'Monday']\n\n", "Every time you run the for loop, the day variable changes. So day is equal to your input only once. Using \"Sunday\" as input, it first checked if Monday = Sunday, then if Tuesday = Sunday, then if Wednesday = Sunday, until it finally found that Sunday = Sunday and returned Sunday.\n", "Another approach using the standard library:\ndays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday',\n 'Sunday']\ndef weekdays(weekday):\n n = days.index(weekday)\n return list(itertools.islice(itertools.cycle(days), n, n + 7))\n\nItertools is a bit much in this case. Since you know at most one extra cycle is needed, you could do that manually:\ndays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday',\n 'Sunday']\ndays += days\ndef weekdays(weekday):\n n = days.index(weekday)\n return days[n:n+7]\n\nBoth give the expected output:\n>>> weekdays(\"Wednesday\")\n['Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday', 'Monday', 'Tuesday']\n>>> weekdays(\"Sunday\")\n['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']\n>>> weekdays(\"Monday\")\n['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']\n\n", "The code below will gnereate a list based on X days you want a head , of you want to generate list of days going back change the [ minus to plus ]\nimport datetime\nnumdays = 7\nbase = datetime.date.today()\ndate_list = [base + datetime.timedelta(days=x) for x in range(numdays)]\ndate_list_with_dayname = [\"%s, %s\" % ((base + datetime.timedelta(days=x)).strftime(\"%A\"), base + datetime.timedelta(days=x)) for x in range(numdays)]\n\n", "You can use Python standard calendar module with very convenient list-like deque object. This way, we just have to rotate the list of the days to the one we want.\nimport calendar\nfrom collections import deque\n\ndef get_weekdays(first: str = 'Monday') -> deque[str]:\n weekdays = deque(calendar.day_name)\n weekdays.rotate(-weekdays.index(first))\n return weekdays\n\nget_weekdays('Wednesday')\n\nthat outputs:\ndeque(['Wednesday',\n 'Thursday',\n 'Friday',\n 'Saturday',\n 'Sunday',\n 'Monday',\n 'Tuesday'])\n\n", "okay, My simple approach would be :\nresult = days[days.index(weekday):] + days[:days.index(weekdays)]\n\nhope This will be helpfull\n" ]

[ 15, 10, 7, 4, 4, 4, 2, 1, 1, 0, 0, 0 ]

[]

[]

[ "calendar", "python", "weekday" ]

[ "So you just want to convert your data from csv to grayscale?\nfrom keras.preprocessing.image import ImageDataGenerator\ndata_generator = ImageDataGenerator()\ndata = data_generator.flow_from_dataframe(df, color_mode=\"grayscale\")\n\nThe df variable is your read csv. your data should return grayscale images using the code above.\n" ]

[ 0 ]

[]

[]

[ "csv", "mnist", "python" ]

[ "Can you try this:\ndfMatchDetails=pd.DataFrame()\nfor i in list(LMID5):\n url = 'https://api.football-data-api.com/match?key=&match_id=' + str(i)\n rm = requests.get(url)\n print(url)\n dfMatchDetails=pd.concat([dfMatchDetails,pd.json_normalize(rm.json()['data'])])\n\n" ]

[ 1 ]

[]

[]

[ "api", "loops", "pandas", "python", "python_requests" ]

[]

[]

[ "To add memoization to your matrix_explorer function, you can use a dictionary to store the results of previously computed paths. When the function is called, you can check if the result for the given n and m values has already been computed. If so, you can simply return the stored result from the dictionary instead of recomputing it. If not, you can compute the result and store it in the dictionary for future use.\ndictionary = {}\ndef matrix_explorer_cache(n ,m):\n if n == 1 or m == 1:\n return 1\n else:\n # Check if the result for the given n and m values has already been computed.\n if (n, m) not in dictionary:\n # Compute and store results\n dictionary[(n, m)] = matrix_explorer_cache(n-1, m) + matrix_explorer_cache(n, m-1)\n # At this point, dictionary[(n, m)] is guaranteed to exist\n return dictionary[(n, m)]\n\n" ]

[ -3 ]

[ "function", "matrix", "memoization", "python", "recursion" ]

[ "Can't say what the problem is without the error message but, match is not the only way to do this.\nHere's an example using a dictionary:\ncolorDict = {1:'red', 2:'green', 3:'blue', 4:'yellow'}\n\nimg = 3\ncolor = colorDict.get(img)\nif img in colorDict:\n matrixColored = colorDict[img]\n print(matrixColored)\nelse:\n print('something went wrong')\n\nIn your code example, this would transpose to :\ndef colorPrint():\n colorDict = {1:'red', 2:'green', 3:'blue', 4:'yellow'}\n for i in range(r):\n for j in range(c):\n if img[i][j] in colorDict:\n matrixColored[i][j] = colorDict[img[i][j]]\n else:\n print('something went wrong')\n\n" ]

[ 0 ]

[]

[]

[ "arrays", "for_loop", "indexing", "python", "range" ]

[ "It seems it has something to do with Windows 11, running a VM of Win10 Pro where it executes perfectly with the latest packages.\nPS: Windows Build Tools are now embedded in the latest Node, so no need to install them manually. Just Node, Git, Visual Studio Code and restart for PATH to update automatically.\n" ]

[ 0 ]

[]

[]

[ "node.js", "npm", "python" ]

[ "You could try the following with df your dataframe:\nstart = 500\nweights = (df[\"A\"].where(df[\"A_yes\"].eq(1), df[\"B\"]) * 0.5 + 0.5).cumprod()\ndf[\"Points\"] = start * weights\n\n\nUse .where to select between the value in A or B based on the A_yes and B_yes entries (my assumption here is that there's a 1 either in A_yes or B_yes, but not in both).\nCalculate the average between the selected value and 1.\nBuild the actual weights with .cumprod.\nMultiply the weights with the start value to get the Points.\n\nResult for df =\n A B A_yes B_yes\n0 2.43 1.55 1 0\n1 2.58 1.49 0 1\n2 1.61 2.32 1 0\n3 2.70 1.46 1 0\n\nis\n A B A_yes B_yes Points\n0 2.43 1.55 1 0 857.500000\n1 2.58 1.49 0 1 1067.587500\n2 1.61 2.32 1 0 1393.201688\n3 2.70 1.46 1 0 2577.423122\n\n" ]

[ 0 ]

[]

[]

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

[ "I'll post two solutions using two different libraries .\nI'm not sure if this will work , or is what you are looking for but it could lead you somewhere .\n #extract email addresses using pyPDF2\ndef extractEmails(pdfFile):\n pdfReader = PyPDF2.PdfFileReader(pdfFile)\n emails = []\n for pageNum in range(pdfReader.numPages):\n pageObj = pdfReader.getPage(pageNum)\n text = pageObj.extractText()\n emailRegex = re.compile(r'[\\w\\.-]+@[\\w\\.-]+')\n mo = emailRegex.findall(text)\n if mo != []:\n emails.extend(mo)\n return emails\n#extract email addresses using pdfminer\ndef extractEmails2(pdfFile):\n emails = []\n for pageNum in range(pdfReader.numPages):\n pageObj = pdfReader.getPage(pageNum)\n text = pageObj.extractText()\n emailRegex = re.compile(r'[\\w\\.-]+@[\\w\\.-]+')\n mo = emailRegex.findall(text)\n if mo != []:\n emails.extend(mo)\n return emails\n\n" ]

[ 0 ]

[]

[]

[ "python" ]

[ "To update a field in a SQLite database using Python, you can use the UPDATE statement in combination with the execute() method provided by the sqlite3 module.\nFor example, if you want to update the date field of the individual_fact_main_data table in your database, you can use the following Python code:\nimport sqlite3\n\n# Connect to the database\nconn = sqlite3.connect(robocza+\"database.ftb\")\nconn.text_factory = bytes\n\n# Create a cursor object\ncursor = conn.cursor()\n\n# Define the UPDATE query\nquery = \"UPDATE individual_fact_main_data SET date = ? WHERE guid = ?\"\n\n# Define the values to update\nvalues = (b'\\n\\x0b24 JUN 1974\"-\\x08\\x01\\x10\\x00\\x18\\x00 \\x18(\\x060\\xb6\\x0f8\\x00@\\x00H\\x00P\\x00X\\xbf\\x84=`\\x00h\\x00p\\x00x\\x00\\x80\\x01\\x00\\x88\\x01\\x01\\x90\\x01\\xa0\\xdc\\x90^', 'xxxxxx')\n\n# Execute the UPDATE query\ncursor.execute(query, values)\n\n# Save the changes to the database\nconn.commit()\n\n# Close the database connection\nconn.close()\n\nThis code will update the date field of the individual_fact_main_data table with the specified value, where the guid field has the value xxxxxx. The b'\\n\\x0b24 JUN 1974\"-\\x08\\x01\\x10\\x00\\x18\\x00 \\x18(\\x060\\xb6\\x0f8\\x00@\\x00H\\x00P\\x00X\\xbf\\x84=\\x00h\\x00p\\x00x\\x00\\x80\\x01\\x00\\x88\\x01\\x01\\x90\\x01\\xa0\\xdc\\x90^'` value is the binary representation of the date, which is the default representation for VARCHAR(255) fields in SQLite.\nFor more information about the UPDATE statement and other SQLite commands, you can refer to the SQLite documentation.\n" ]

[ 0 ]

[]

[]

[ "python", "sqlite" ]

[ "You can use groupby. By using groupby, you can group the products according to the customers and store them in the form of a list.\ndfx=df.groupby('Customer').agg({'ItemDescription':list})\n'''\n ItemDescription\nCustomer \n1064 [Produce, Snack]\n1080 [Drink, Snack]\n1128 [Meat, Snack]\n1229 [Drink, Snack]\n1230 [Drink, Snack, Meat, Snack]\n'''\n\nHere we will need to filter out customers who have not purchased a snack.\ndfx=dfx[pd.DataFrame(dfx.ItemDescription.tolist()).isin(['Snack']).any(1).values] # https://stackoverflow.com/a/53343080/15415267\n\nThen, convert the remaining rows into a list and get distributions with the Counter function.\nproducts=dfx.explode('ItemDescription')['ItemDescription'].to_list()\n#['Produce', 'Snack', 'Drink', 'Snack', 'Meat', 'Snack', 'Drink', 'Snack', 'Drink', 'Snack', 'Meat', 'Snack']\n\nfrom collections import Counter\noccurence_count = Counter(top)\noccurence_count.most_common(4) #get top 4 product \n#[('Snack', 6), ('Drink', 3), ('Meat', 2), ('Produce', 1)]\n\nIf you convert results to dataframe:\nfinal =pd.DataFrame(occurence_count.most_common(4),columns=['product','count'])\n'''\n product count\n0 Snack 6\n1 Drink 3\n2 Meat 2\n3 Produce 1\n\n'''\n\nor (shorter):\ndfx=df.groupby('Customer').agg({'ItemDescription':list})\n'''\n ItemDescription\nCustomer \n1064 [Produce, Snack]\n1080 [Drink, Snack]\n1128 [Meat, Snack]\n1229 [Drink, Snack]\n1230 [Drink, Snack, Meat, Snack]\n'''\n\ndfx=dfx[pd.DataFrame(dfx.ItemDescription.tolist()).isin(['Snack']).any(1).values] # https://stackoverflow.com/a/53343080/15415267\nproducts=dfx2.explode('ItemDescription')['ItemDescription'].value_counts()[0:4]\n'''\n ItemDescription\nSnack 6\nDrink 3\nMeat 2\nProduce 1\n\n'''\n\n\n", "To find the top 3 items that customers have bought along with \"Snack\", you can use the groupby() and value_counts() methods in pandas. Here is an example of how you can do this:\nimport pandas as pd\n\n# Create a sample DataFrame\ndf = pd.DataFrame({'Customer': [1064, 1064, 1080, 1080, 1230, 1230, 1128, 1128, 1229, 1229, 1230, 1230],\n 'ItemDescription': ['Produce', 'Snack', 'Drink', 'Snack', 'Drink', 'Snack', 'Meat', 'Snack', 'Drink', 'Snack', 'Meat', 'Snack'],\n 'Invoice': [55514, 55514, 56511, 56511, 55551, 55551, 55003, 55003, 55100, 55100, 55102, 55102],\n 'PurchaseDate': ['22-01', '22-01', '23-01', '23-01', '26-03', '26-03', '04-03', '04-03', '06-03', '06-03', '07-03', '07-03']})\n\n# Group the data by Customer\ndf_grouped = df.groupby('Customer')\n\n# Create a dictionary to store the counts of items bought along with \"Snack\" for each customer\nitem_counts = {}\n\n# Loop through each customer group\nfor customer, group in df_grouped:\n # Create a new DataFrame that only includes rows where the ItemDescription is \"Snack\"\n snacks = group[group['ItemDescription'] == 'Snack']\n\n # Loop through each row in the snacks DataFrame\n for index, row in snacks.iterrows():\n # Get the Invoice number for the current row\n invoice = row['Invoice']\n\n # Get the rows in the original DataFrame that have the same Invoice number as the current row\n invoice_rows = df[df['Invoice'] == invoice]\n\n # Loop through each row in the invoice_rows DataFrame\n for i, r in invoice_rows.iterrows():\n # If the ItemDescription is not \"Snack\", increment the count for that item in the item_counts dictionary\n if r['ItemDescription'] != 'Snack':\n item = r['ItemDescription']\n if item not in item_counts:\n item_counts[item] = 0\n item_counts[item] += 1\n\n# Sort the item_counts dictionary by value in descending order\nsorted_items = sorted(item_counts.items(), key=lambda x: x[1], reverse=True)\n\n# Print the top 3 items that customers have bought along with \"Snack\"\nfor i in range(3):\n print(i, sorted_items[i][0])\n\nIn the example above, the data in the DataFrame is first grouped by the values in the Customer column.\nThen, for each customer group, the rows where the ItemDescription is \"Snack\" are extracted and stored in a new DataFrame.\nFor each row in the snacks DataFrame, the rows in the original DataFrame that have the same Invoice number are extracted and stored in a new DataFrame.\nFinally, for each row in the invoice_rows DataFrame, the ItemDescription is checked. If the ItemDescription is not \"Snack\", the count for that item is incremented in the item_counts dictionary. After all the customer groups have been processed, the item_counts dictionary is sorted by value in descending order, and the top 3 items are printed.\n", "IIUC your requirement is to get the top items that were taken along with \"Snack\". So you first want to filter those Customers who didn't buy snack.\nUse groupby.filter for that. And then you want to compute the top items in terms of count. For that you use value_counts and then you take top 3 other than \"Snack\".\ns = (\n df.groupby(\"Customer\")\n .filter(lambda x: \"Snack\" not in x)[\"ItemDescription\"]\n .value_counts()\n)\ntop_3 = s.loc[s.index.difference([\"Snack\"])][:3]\n\nprint(top_3):\nDrink 3\nMeat 2\nProduce 1\n\n" ]

[ 0, 0, 0 ]

[]

[]

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

[ "I find an answer myself.\nFirst I wrap my function in a way that the y-value p is the first argument.\nAnd I used lmfit parameter class as arguments. Lmfit Parameters are basically dictionaries.\np_solvable = lambda p,T,parameter : function(p,T,parameter[\"p0\"],parameter[\"v\"],...)\n\nThen I solve the equation by scipy.optimize.root_scalar with the brentq method.\nThe brentq method needs Brackets where the signs are changing. I chose 1 as lower limit so np.log(1-p > 0) is defined and just the doubled maximum as upper limit.\np_max = np.max(p)\n\ndef p(T):\n P_Init = [root_scalar(p_solvable,args=(T,parameter), method=\"brentq\", bracket=[1,p_max*2]).root for T in T]\n return P_Init\n\nNow I have a function where I can input f(x) = y and fit it with lmfit or scipy curve_fit\n" ]

[ 0 ]

[]

[]

[ "curve_fitting", "lmfit", "pandas", "python", "scipy_optimize" ]

[ "Pipenv do natively implement freezing requirements.txt.\nIt is as simple as:\npipenv lock -r > requirements.txt\n\n", "Assuming you have your virtual environment activated, you have three simple approaches. I will list them from less verbose to more verbose.\npip\n$ pip freeze > requirements.txt\n\npip3\n$ pip3 freeze > requirements.txt\n\nIf a virtual environment is active, pip is most certainly equivalent to pip3.\npipenv run\n$ pipenv run pip freeze > requirements.txt\n$ pipenv run pip3 freeze > requirements.txt\n\npipenv run spawns a command installed into the virtual environment, so these commands are equivalent to the ones run without pipenv run. Once again, it is assumed that your virtual environment is active.\n", "As of v2022.8.13 of pipenv, the \"old\" lock -r functionality has been removed.\nGoing forward, this should be accomplished with:\npipenv requirements > requirements.txt\n\n", "By using run You can run given command from virtualenv, with any arguments forwarded\n$ pipenv run pip freeze > requirements.txt \n\n", "Recent pipenv versions (e.g. version 2022.6.7) are using the requirements subcommand and pipenv lock -r is deprecated.\nTo freeze default dependencies\npipenv requirements > requirements.txt\n\nto freeze development dependencies as well\npipenv requirements --dev > dev-requirements.txt\n\n", "It's as simple as changing django = \"*\" to django = \"your-preferred-version\". So if you wanted to freeze it to 2.1, the latest release at the time of this writing, you could do this:\n[packages]\ndjango=\"2.1\"\n\nThe pipfile Git repo has some good examples of different ways to specify version strings: https://github.com/pypa/pipfile#pipfile\nNote that when you generate a lockfile from your pipfile, that lockfile is actually the file that's supposed to \"freeze\" your dependency to a specific version. That way, you don't have to concern yourself with which version works with your code, since by distributing the lockfile everyone else must use the same dependency versions as you. The developers of pipenv intended for developers to use it like this\n", "first, you ensure that your virtual environment is active then you open the terminal and run the command\npip3 freeze > reqirements.txt (pip3)\npip3 freeze > reqirements.txt (pip3)\n", "This is the way that I was prompted by pipenv to generate a requirements.txt file from the project's Pipfile:\npipenv lock --requirements\n\n", "Use this as -r flag is deprecated\npipenv requirements > requirements.txt\n\n", "pipenv run python -m pip freeze > requirements.txt\n\n" ]

[ 99, 26, 24, 11, 9, 1, 0, 0, 0, 0 ]

[ "You can create a requirements.txt using this command : \npip3 freeze > requirements.txt\n\n" ]

[ -3 ]

[ "pipenv", "pipfile", "python" ]

[ "If you're using tensorflow >= 2.0, then import keras using\nfrom tensorflow import keras\n\nCommon convention is to import it as kr\n", "Can you please tell me if you're using multiple versions of python on the same device, if so please check if you've installed TensorFlow on the same version of python which you're using for jupyter notebook, to check that and install again:\n\nGo to the path where you've installed python(which you're using for\njupyter notebook) if you've installed anaconda then go to the path\nwhere anaconda is installed and follow the procedure.\n\nGo to the site-packages folder in the path of Anaconda or python.\n\nCheck if all the dependencies of TensorFlow and TensorFlow are\ninstalled there.\n\nIf you can't find it then add the current python version to\nenvironment variables, see:\nhttps://www.javatpoint.com/how-to-set-python-path#:~:text=SETTING%20PATH%20IN%20PYTHON%201%20Right%20click%20on,on%20Ok%20button%3A%209%20Click%20on%20Ok%20button%3A\nand\nhttps://www.geeksforgeeks.org/how-to-setup-anaconda-path-to-environment-variable/\n\nAfter you've added the current version of python to the environment path\nvariables then follow this link to install TensorFlow:\nhttps://www.geeksforgeeks.org/how-to-install-python-tensorflow-in-windows/#:~:text=%20%20%201%20Step%201%3A%20Click%20on,done%20with%20the%20use%20of%20following...%20More%20\nand\nhttps://machinelearningspace.com/installing-tensorflow-2-0-in-anaconda-environment/\n\n\nThen again follow step 2 and 3 and if it's still not appearing in the site-packages folder then follow this link:\nhttps://www.quora.com/How-can-I-work-with-Keras-on-a-Jupyter-notebook-using-Tensorflow-as-backend\nfor some details(not that helpful)\nAlso, Try installing Keras by this command:\npip3 install Keras\n\nIf you're using one version of python then please check if jupyter and TensorFlow are installed in the same Virtual Environment\nPlease tell me if it works or not.\n", "I am not sure how you have imported keras, but in past even I have faced a similar issue. What I had done is i did something like this\nimport keras\n\nwhich is wrong! We have to import it like this\nfrom tensorflow import keras\n\nwhich worked fine for me! Hope this Helps you!\n" ]

[ 1, 0, 0 ]

[]

[]

[ "anaconda", "jupyter_notebook", "keras", "python", "tensorflow" ]

[ "You can use this command to sort files to get the latest file from GCS bucket, you can change the condition based on the requirement.\ngsutil ls -l gs://[bucket-name]/ | sort -k 2 | tail -n 2\n\nTo specifically get the latest .avro file from the GCS Bucket, you can consider this code:\nfrom google.cloud import storage\nimport re\n\nstorage_client = storage.Client()\nbucket = storage_client.get_bucket('bucket-name')\n\nfiles = bucket.list_blobs() \nfileList = [file.name for file in files if '.avro' in file.name]\n \nlatestFile = fileList[0]\nlatestTimeStamp = bucket.get_blob(fileList[0]).updated\n \nfor i in range(len(fileList)):\n \n timeStamp = bucket.get_blob(fileList[i]).updated\n \n if timeStamp > latestTimeStamp:\n latestFile = fileList[i]\n latestTimeStamp = timeStamp\n \nprint(latestFile)\n\nTo know more about Object Metadata you can refer to this document.\n" ]

[ 0 ]

[]

[]

[ "avro", "google_bigquery", "google_cloud_platform", "google_cloud_storage", "python" ]

[ "A table cannot have two primary keys, but a single primary key may include two columns. This means you need to define the primary key constraint separately, not as an attribute of either column.\nhttps://docs.sqlalchemy.org/en/14/core/constraints.html#primary-key-constraint shows an example:\nmy_table = Table(\n \"mytable\",\n metadata_obj,\n Column(\"id\", Integer),\n Column(\"version_id\", Integer),\n Column(\"data\", String(50)),\n PrimaryKeyConstraint(\"id\", \"version_id\", name=\"mytable_pk\"),\n)\n\n\nEdit: I tested some more options and I looked at the SQLAlchemy code. It seems that although MySQL does support any column to be auto-increment as long as the column is the first column in any index (unique or non-unique), SQLAlchemy is more limited. I can't get it to add a column as auto-increment unless it's part of the primary key.\n" ]

[ 0 ]

[]

[]

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

[ "One place to start would be to review the offerings of www.voxforge.org; review the tutorial and forums sections to get an overview of the use of open source projects such as Julius and CMU Sphinx. It's a quite extensive subject and you will find that many people have trodden the path before you, so you can learn from their experience.\n", "You can run open.ai's whisper locally on your own hardware. You'll only need a network connection to download the neural models once. Once that's done none of the data you will be processing will leave your computer.\nTo have it running at reasonable speed you'll need a beefy GPU setup with cuda properly configured so that pytorch can use it. Running it on CPU will be orders of magnitude slower and likely to last for days (depending on your required throughput).\n" ]

[ 0, 0 ]

[]

[]

[ "deep_learning", "machine_learning", "python", "speech_recognition", "speech_to_text" ]

[ "Follow link to image here\nhttps://i.stack.imgur.com/69rHj.png\nSee line 32 and description on line33.\nThis had me going for 2 or 3 hours, too. Same error as yourself.\nFrom AWS CLI I derived my QS data set id. That was wrong in my case.\nUse the TEMPLATE data set id instead. Issue resolved, dashboard created.\n", "Keep the placeholder same as of template dataset but change Dataset ARN according to your target/replaceable dataset. I also had the same issue. But found the solution\n" ]

[ 0, 0 ]

[]

[]

[ "amazon_quicksight", "amazon_web_services", "boto3", "dashboard", "python" ]

[ "You can do this with a fairly straightforward double loop - i.e., two iterations checking for 0,1 then 1,0 pairs\nlst = [1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0]\n\nms = 0\n\nfor t in [0, 1], [1, 0]:\n i, c = 0, 0\n while i < len(lst)-1:\n if lst[i:i+2] == t:\n c += 1\n i += 1\n elif c > 0:\n ms = max(ms, c)\n c = 0\n i += 1\n\nprint(max(ms, c))\n\nOutput:\n4\n\n", "By using a regular expression you can work directly on string-data, no further casting to int, list, ... is needed. Here an example:\nimport re\n\nwith open(\"file.txt\", 'r+') as file:\n file_context = file.read()\n\n# remove extra whitespaces and commas\nfile_context = file_context.replace(', ', '')\n\n# search by pattern\nmatches_01 = re.findall(r'((?:01)+)', file_context)\nmatches_10 = re.findall(r'((?:10)+)', file_context)\n\n# get lengths\nmax_01 = len(max(matches_01, key=len)) // 2\nmax_10 = len(max(matches_10, key=len)) // 2\n\nmax_length = max(max_01, max_10)\n\n# result\nprint(f'Length longest sequence: {max_length}')\n\n" ]

[ 0, 0 ]

[]

[]

[ "python" ]

[ "import gym\nfrom gym.utils import play\nenv = play.play(gym.make('MountainCar-v0', render_mode='rgb_array').env, zoom=1, keys_to_action={\"2\":2, \"1\":0}, noop=1)\n\nthe noop sets the default action\n" ]

[ 0 ]

[]

[]

[ "openai_gym", "python" ]

[ "Here; I modified the player creation a little too.\nfrom dataclasses import dataclass\n@dataclass\nclass Player: \n firstname: str\n lastname: str\n coins: int\n slot: int\n def full_info(self) -> str:\n return f\"{self.firstname} {self.lastname} {self.coins} {self.slot}\"\n\n @classmethod\n def from_user_input(cls) -> 'Player':\n return cls(\n firstname=input(\"Please enter your first name:\"),\n lastname=input(\"Please enter your second name: \"),\n coins=100,\n slot= 0)\n\n# Creating players\nminplayer, maxplayer, n = 2, 5, -1\nwhile not(minplayer <= n <= maxplayer):\n n = int(input(f\"Please choose a number of players between {minplayer} and {maxplayer}: \"))\nplayersingame = []\nfor i in range(n):\n playersingame.append(Player.from_user_input())\n\n\nprint([player.full_info() for player in playersingame])\n\nboard = [[] for i in range(10)]\nprint(board)\n\nfor player in playersingame:\n board[player.slot].append(player)\n\nprint(board)\n\nExample:\nPlease choose a number of players between 2 and 5: 3\n\nPlease enter your first name:Tom\n\nPlease enter your second name: Bombadil\n\nPlease enter your first name:Frodo\n\nPlease enter your second name: Baggins\n\nPlease enter your first name:Saruman\n\nPlease enter your second name: ZeWhite\n['Tom Bombadil 100 0', 'Frodo Baggins 100 0', 'Saruman ZeWhite 100 0']\n[[], [], [], [], [], [], [], [], [], []]\n[[Player(firstname='Tom', lastname='Bombadil', coins=100, slot=0), Player(firstname='Frodo', lastname='Baggins', coins=100, slot=0), Player(firstname='Saruman', lastname='ZeWhite', coins=100, slot=0)], [], [], [], [], [], [], [], [], []]\n\nHere's code for one round (you can wrap it in a loop afterwards to implement the full game):\n# Playing a round\nimport random\n\nfor player in playersingame:\n input(f\"{player.firstname} {player.lastname}, please press enter to roll your die...\")\n die = random.randint(1,6)\n print(f\"You take {die} step{'s'*(die>1)} forward\")\n board[player.slot].remove(player)\n player.slot += die\n board[player.slot].append(player)\n \nprint(board)\n\nExample:\nTom Bombadil, please press enter to roll your die...\nYou take 3 steps forward\n\nFrodo Baggins, please press enter to roll your die...\nYou take 1 step forward\n\nSaruman ZeWhite, please press enter to roll your die...\nYou take 4 steps forward\n[[], [Player(firstname='Frodo', lastname='Baggins', coins=100, slot=1)], [], [Player(firstname='Tom', lastname='Bombadil', coins=100, slot=3)], [Player(firstname='Saruman', lastname='ZeWhite', coins=100, slot=4)], [], [], [], [], []]\n\n" ]

[ 0 ]

[]

[]

[ "python" ]

[ "You can use a regex to extractall the number before :, convert to integer and check if any is between 2 and 7:\nm = (df['Variant&Price'].str.extractall('(\\d+):')[0]\n .astype(int).between(2,7).groupby(level=0).any()\n )\n\nout = df[m]\n\nOutput:\n A Variant&Price Qty\n0 AAC 7:124|25: 443 1\n2 AAS 32:98|3:40 1\n3 AAG 2: |25: 1\n\n", "cond1 = (df['Variant&Price'].str.split('|').explode()\n .str.split(':').str[0]\n .astype('int')\n .between(2, 7).max(level=0))\n\ndf[cond1]\n\noutput:\n Am Variant&Price Qty\n0 AAC 7:124|25: 443 1\n2 AAS 32:98|3:40 1\n3 AAG 2: |25: 1\n\n" ]

[ 3, 1 ]

[]

[]

[ "pandas", "python" ]

[ "If you have vs-code, install \"Live-Server\" extension and open live-server.\nor\nopen terminal/command-prompt in the same folder. Assuming you have named your html file as \"index.html\", enter following command in terminal:\npython3 -m http.server 8000\nthen open http://0.0.0.0:8000 in your browser\n", "You are facing issue as mentioned below.\nAccess to fetch at 'pythonfile.py' from origin 'null' has been blocked by CORS policy: Cross origin requests are only supported for protocol schemes: http, data, isolated-app, chrome-extension, chrome, https, chrome-untrusted.\n\nthen you can try this instead of attaching a python file write it inline.\n<py-script>\n lst = [[\"a\", 45], [\"b\", 40], [\"c\", 18], [\"d\", 17]]\n\n name = input(\"Enter your name:\")\n\n print(\"Searching in list\")\n for item in lst:\n if item[0] == name:\n print(\"name:\", item[0], \"age:\", item[1])\n</py-script>\n\n", "When some thing does not work, please describe what is happening instead. In a web browser you can get more information from the developer tools Console, which can be opened by the menu or probably by pressing F12 or Ctrl+Shift+I (See here).\nAs GauravGiri already answered, the most probable reason is the difference between opening an HTML file locally and visiting it through a webserver:\nHTML Sites are not allowed to read the contents of other local files on your computer, while accessing them from the same webserver is allowed.\n" ]

[ 0, 0, 0 ]

[]

[]

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

[ "If I understand what you are trying to do, you can just augment the summation expression to include 2 variables... Something like:\nfor i in cols:\n prob += sum(x[i][j][k] for j in rows for k in vals) <= M[i][0]\n\n" ]

[ 0 ]

[]

[]

[ "for_loop", "optimization", "pulp", "python" ]

[ "I think you are trying to do the impossible. You can either have a 12km x 12km grid in a projected CRS that is approximately 12km x 12km and approximately square on the ground, or you have a regular Z by Z degrees grid in a lat-long projection that is approximately square and approximately 12km x 12 km on the ground.\nYou can't chop a spherical surface into exact 12km x 12km squares where the distance is measured along the surface.\n" ]

[ 0 ]

[]

[]

[ "geospatial", "python", "r" ]

[ "You're bumping into two issues. One is you're running your test file from within the directory it's written, and so Python doesn't know what .. represents. There are a couple of ways to fix this.\nOne is to take the solution that @lesiak proposed by changing the import to from solutions import helloWorldPackage but to execute your tests by running python tests/test_helloWorld.py. That will make sure that your project's top-level is in Python's search path and so it will see solutions.\nThe other solution is to open your project in VS Code one directory higher (whatever directory that contains solutions and tests). You will still need to change how you execute your code, though, so you are doing it from the top-level as I suggested above.\nEven better would be to either run your code using python -m tests.test_helloWorld, use the Python extension's Run command, or use the extension's Test Explorer. All of those options should help you with how to run your code (you will still need to either change the import or open the higher directory in VS Code).\n", "Do not use relative import.\nSimply change it to\nfrom solutions import helloWorldPackage as hw\n\nUpdate\nI initially tested this in PyCharm. PyCharm has a nice feature - it adds content root and source roots to PYTHONPATH (both options are configurable).\nYou can achieve the same effect in VS Code by adding a .env file:\nPYTHONPATH=.:${PYTHONPATH}\n\nNow, the project directory will be in the PYTHONPATH for every tool that is launched via VS Code. Now Ctrl+F5 works fine.\n", "\nSetup a main module and its source packages paths\n\nSolution found at:\n\nhttps://k0nze.dev/posts/python-relative-imports-vscode/#:~:text=create%20a%20settings.json%20within%20.vscode\nhttps://k0nze.dev/posts/python-relative-imports-vscode/#:~:text=Inside%20the-,launch.json,-you%20have%20to\n\nWhich also provide a neat in-depth video explanation\n\nThe solution to the attempted relative import with no known parent package issue, which is especially tricky in VScode (in opposite to Pycharm that provide GUI tools to flag folders as package), is to:\nAdd configuration files for the VScode debugger\n\nId Est add launch.json as a Module (this will always execute the file given in \"module\" key) and settings.json inside the MyProjectRoot/.vscode folder (manually add them if it's not there yet, or be guided by VScode GUI for Run & Debug)\n\nlaunch.json setup\n\nId Est add an \"env\" key to launch.json containing an object with \"PYTHONPATH\" as key, and \"${workspaceFolder}/mysourcepackage\" as value\nfinal launch.json configuration\n\nsettings.json setup\n\nId Est add a \"python.analysis.extraPaths\" key to settings.json containing a list of paths for the debugger to be aware of, which in our case is one [\"${workspaceFolder}/mysourcepackage\"] as value (note that we put the string in a list only for the case in which we want to include other paths too, it is not needed for our specific example but it's still a standard de facto as I know)\nfinal settings.json configuration\n\nThis should be everything needed to both work by calling the script with python from the terminal and from the VScode debugger.\n", "An Answer From 2022\nHere's a potential approach from 2022. The issue is identified correctly and if you're using an IDE like VS Code, it doesn't automatically extend the python path and discover modules.\nOne way you can do this using an .env file that will automatically extend the python path. I used this website k0nze.dev repeatedly to find an answer and actually discovered another solution.\nHere are the drawbacks of the solution provided in the k0nze.dev solution:\n\nIt only extends the python path via the launch.json file which doesn't effect running python outside of the debugger in this case\nYou can only use the ${workspaceFolder} and other variables within an \"env\" variable in the launch.json, which gets overwritten in precedence by the existence of a .env file.\nThe solution works only within VS Code since it has to be written within the launch.json (- overall portability)\n\nThe .env File\nIn your example tests falls under it's own directory and has it's own init.py. In an IDE like VS Code, it's not going to automatically discover this directory and module. You can see this by creating the below script anywhere in your project and running it:\n_path.py\nfrom sys import path as pythonpath\n\nprint(\"\\n ,\".join(pythonpath))\n\nYou shouldn't see your ${workspaceFolder}/tests/ or if you do, it's because your _path.py script is sitting in that directory and python automatically adds the script path to pythonpath. To solve this issue across your project, you need to extend the python path using .env file across all files in your project.\nTo do this, use dot notation to indicate your ${workspaceFolder} in lieu of being able to actually use ${workspaceFolder}. You have to do dot notation because .env files do not do variable assignment like ${workspaceFolder}. Your env file should look like:\nWindows\nPYTHONPATH = \".\\\\tests\\\\;.\\\\\" \n\nMac / Linux / etc\nPYTHONPATH = \"./tests/:./\"\n\nwhere:\n\n; and : are the path separators for environment variables for windows and Mac respectively\n./tests/ and .\\tests\\ extend python path to the files within the module tests for import in the init.py\n./ and .\\ extend the python path to modules tests and presumably solutions? I don't know if solutions is a module but I'm going to run with it.\n\nTest It Out\nNow re-run your _path.py script and you should see permanent additions to your path. This works for deeply nested modules as well if your company has a more stringent project structure.\nVS Code\nIf you are using VS Code, you cannot use environment variables provided by VS Code in the .env file. This includes ${workspaceFolder}, which is very handy to extend a file path to your currently open folder. I've beaten myself up trying to figure out why it's not adding these environment variables to the path for a very long time now and it seems\nThe solution is instead to use dot notation to prepend the path by using relative file path. This allows the user to append a file path relative to the project structure and not their own file structure.\nFor Other IDE's\nThe reason the above is written for VS Code is because it automatically reads in the .env file every time you run a python file. This functionality is very handy and unless your IDE does this, you will need the help of the dotenv package.\nYou can actually see the location that your version of VS Code is looking for by searching for the below setting in your preferences:\nVSCode settings env file\nAnyways, to install the package you need to import .env files with, run:\npip install python-dotenv\n\nIn your python script, you need to run and import the below to get it to load the .env file as your environment variables:\nfrom dotenv import load_dotenv()\n\n# load env variables \nload_dotenv()\n\n\"\"\"\nThe rest of your code here\n\"\"\"\n\nThat's It\nCongrats on making it to the bottom. This topic nearly drove me insane when I went to tackle it but I think it's helpful to be elaborate and to understand the issue and how to tackle it without doing hacky sys.path appends or absolute file paths. This also gives you a way to test what's on your path and an explanation of why each path is added in your project structure.\n", "I was just going through this with VS Code and Python (using Win10) and found a solution. Below is my project folder. Files in folder \"core\" import functions from folder \"event\", and files in folder \"unit tests\" import functions from folder \"core\".\nI could run and debug the top-level file file_gui_tk.py within VS Code but I couldn't run/debug any of the files in the sub-folders due to import errors. I believe the issue is that when I try to run/debug those files, the working directory is no longer the project directory and consequently the import path declarations no longer work.\nFolder Structure:\ntestexample\n core\n __init__.py\n core_os.py\n dir_parser.py\n events\n __inits__.py\n event.py\n unit tests\n list_files.py\n test_parser.py\n.env\nfile_gui_tk.py\n\nMy file import statements:\nin core/core_os.py:\n from events.event import post_event\n\nin core/dir_parser.py:\nfrom core.core_os import compare_file_bytes, check_dir\nfrom events.event import post_event\n\nTo run/debug any file within the project directory, I added a top level .env file with contents:\nPYTHONPATH=\"./\" \n\nAdded this statement to the launch.json file:\n\"env\": {\"PYTHONPATH\": \"/testexample\"},\n\nAnd added this to the settings.json file\n\"terminal.integrated.env.windows\": {\"PYTHONPATH\": \"./\",}\n\nNow I can run and debug any file and VS Code finds the import dependencies within the project.\nI haven't tried this with a project dir structure more than two levels deep.\n" ]

[ 4, 3, 1, 0, 0 ]

[]

[]

[ "import", "package", "python", "python_unittest", "visual_studio_code" ]

[ "First, it is always a good practice to use context manager when opening a file (using the with keyword). Second, read the file to a list and address the line number by index.\nimport os\n\n\nwith open(\"config.txt\", \"r\") as cf:\n file_lines = [line.replace(os.linesep, \"\") for line in cf.readlines()]\n\nNow each index in file_lines is relative to the line number in the file.\n", "This is how I did it:\nlines = [] \nwith open(\"txt.txt\", \"r\") as t:\n for i in t:\n lines.append(t)\nconfig1 = datainfile[0]\n\n" ]

[ 0, 0 ]

[]

[]

[ "file", "line", "python", "python_3.x", "variables" ]

[ "You're using a Core profile OpenGL Context (glfw.OPENGL_CORE_PROFILE). Therefore you have to create a Vertex Array Obejct:\nclass Window:\n # [...]\n\n def createshaders(self):\n # [...]\n\n v2f_1 = Vector2f(0.0, 0.0)\n # Request a buffer slot from GPU\n buffer = glGenBuffers(1)\n glBindBuffer(GL_ARRAY_BUFFER, buffer)\n strides = v2f_1.data.strides[0]\n glBufferData(GL_ARRAY_BUFFER, v2f_1.data, GL_DYNAMIC_DRAW)\n \n vao = glGenVertexArrays(1)\n glBindVertexArray(vao)\n \n loc = glGetAttribLocation(program, 'position')\n glEnableVertexAttribArray(loc)\n glVertexAttribPointer(loc, 2, GL_FLOAT, False, strides, None)\n\n\nAdditionally, you need to change either the background color or the fragment color, because you won't be able to see a black point on a black background. e.g. red:\ngl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); \n\n" ]

[ 1 ]

[]

[]

[ "opengl", "pyopengl", "python", "python_3.x" ]

[ "One way to make the process of generating a random binary matrix with no rows of only 0s more efficient is to use the np.random.choice function to randomly choose a non-zero entry from each row of the matrix and set its value to 1. This avoids the need to use a while loop and repeatedly check for rows of only 0s, which can be computationally expensive for large matrices.\nHere is an example of how you could use the np.random.choice function to generate a random binary matrix with no rows of only 0s:\nW = np.random.binomial(1, p, (n,n))\nfor row in W:\n nonzero_indices = np.where(row != 0)[0]\n if nonzero_indices.size == 0:\n random_index = np.random.randint(0, n)\n row[random_index] = 1\n else:\n random_index = np.random.choice(nonzero_indices)\n row[random_index] = 1\n\n", "When the matrix is large, regenerating the entire matrix just because few rows are full of zeros is not efficient. It should be statistically safe to only regenerate the target rows. Here is an example:\ndef random_matrix(p,n):\n W = np.random.binomial(1, p, (n,n))\n\n while True:\n null_rows = np.where(W.sum(axis=1) == 0)[0]\n # If there is no null row, then m>0 so we stop the replacement\n if null_rows.size == 0:\n break\n # Replace only the null rows\n W[null_rows] = np.random.binomial(1, p, (null_rows.shape[0],n))\n\n return W\n\n\nEven faster solutions\nThere is an even more efficient approach when p is close to 0 (when p is close to 1, then the above function is already fast). Indeed, a binomial random variable with 0-1 values is a Bernoulli random variable. The sum of Bernoulli random values with a probability p repeated many times is a binomial random value! Thus, you can generate the sum for all row using S = np.random.binomial(n, p, (n,n)), then apply the above method to remove null values and then build the final matrix by generating S[i] one values for the ith row and use np.shuffle so to randomize the order of the 0-1 values in each row. This method solve conflicts much more efficiently than all others. Indeed, it does not need to generate the full row to check if it is full of zeros. It is n times faster to solve conflicts!\nIf this is not enough, you can use the uint8 datatype to generate W. Indeed, the memory is slow so generating smaller matrices is generally faster, not to mention it takes less RAM.\nIf this is not enough, you can generate S item per item using Numba JIT compiler and a basic loop. This should be faster since there is no temporary array to create except the final one. For large matrices, this algorithm can even be parallelized (every row can be independently generated). This last solution should be close to be optimal.\n" ]

[ 0, 0 ]

[]

[]

[ "loops", "matrix", "numpy", "python", "random" ]

[ "A bit reversed, but this should work:\ndef foo():\n foo.counter += 1\n print \"Counter is %d\" % foo.counter\nfoo.counter = 0\n\nIf you want the counter initialization code at the top instead of the bottom, you can create a decorator:\ndef static_vars(**kwargs):\n def decorate(func):\n for k in kwargs:\n setattr(func, k, kwargs[k])\n return func\n return decorate\n\nThen use the code like this:\n@static_vars(counter=0)\ndef foo():\n foo.counter += 1\n print \"Counter is %d\" % foo.counter\n\nIt'll still require you to use the foo. prefix, unfortunately.\n(Credit: @ony)\n", "You can add attributes to a function, and use it as a static variable.\ndef myfunc():\n myfunc.counter += 1\n print myfunc.counter\n\n# attribute must be initialized\nmyfunc.counter = 0\n\nAlternatively, if you don't want to setup the variable outside the function, you can use hasattr() to avoid an AttributeError exception:\ndef myfunc():\n if not hasattr(myfunc, \"counter\"):\n myfunc.counter = 0 # it doesn't exist yet, so initialize it\n myfunc.counter += 1\n\nAnyway static variables are rather rare, and you should find a better place for this variable, most likely inside a class.\n", "One could also consider:\ndef foo():\n try:\n foo.counter += 1\n except AttributeError:\n foo.counter = 1\n\nReasoning:\n\nmuch pythonic (\"ask for forgiveness not permission\")\nuse exception (thrown only once) instead of if branch (think StopIteration exception)\n\n", "Many people have already suggested testing 'hasattr', but there's a simpler answer:\ndef func():\n func.counter = getattr(func, 'counter', 0) + 1\n\nNo try/except, no testing hasattr, just getattr with a default.\n", "Other answers have demonstrated the way you should do this. Here's a way you shouldn't:\n>>> def foo(counter=[0]):\n... counter[0] += 1\n... print(\"Counter is %i.\" % counter[0]);\n... \n>>> foo()\nCounter is 1.\n>>> foo()\nCounter is 2.\n>>> \n\nDefault values are initialized only when the function is first evaluated, not each time it is executed, so you can use a list or any other mutable object to store static values.\n", "Python doesn't have static variables but you can fake it by defining a callable class object and then using it as a function. Also see this answer.\nclass Foo(object):\n # Class variable, shared by all instances of this class\n counter = 0\n\n def __call__(self):\n Foo.counter += 1\n print Foo.counter\n\n# Create an object instance of class \"Foo,\" called \"foo\"\nfoo = Foo()\n\n# Make calls to the \"__call__\" method, via the object's name itself\nfoo() #prints 1\nfoo() #prints 2\nfoo() #prints 3\n\nNote that __call__ makes an instance of a class (object) callable by its own name. That's why calling foo() above calls the class' __call__ method. From the documentation:\n\nInstances of arbitrary classes can be made callable by defining a __call__() method in their class.\n\n", "Here is a fully encapsulated version that doesn't require an external initialization call:\ndef fn():\n fn.counter=vars(fn).setdefault('counter',-1)\n fn.counter+=1\n print (fn.counter)\n\nIn Python, functions are objects and we can simply add, or monkey patch, member variables to them via the special attribute __dict__. The built-in vars() returns the special attribute __dict__. \nEDIT: Note, unlike the alternative try:except AttributeError answer, with this approach the variable will always be ready for the code logic following initialization. I think the try:except AttributeError alternative to the following will be less DRY and/or have awkward flow: \ndef Fibonacci(n):\n if n<2: return n\n Fibonacci.memo=vars(Fibonacci).setdefault('memo',{}) # use static variable to hold a results cache\n return Fibonacci.memo.setdefault(n,Fibonacci(n-1)+Fibonacci(n-2)) # lookup result in cache, if not available then calculate and store it\n\nEDIT2: I only recommend the above approach when the function will be called from multiple locations. If instead the function is only called in one place, it's better to use nonlocal:\ndef TheOnlyPlaceStaticFunctionIsCalled():\n memo={}\n def Fibonacci(n):\n nonlocal memo # required in Python3. Python2 can see memo\n if n<2: return n\n return memo.setdefault(n,Fibonacci(n-1)+Fibonacci(n-2))\n ...\n print (Fibonacci(200))\n ...\n\n", "Use a generator function to generate an iterator.\ndef foo_gen():\n n = 0\n while True:\n n+=1\n yield n\n\nThen use it like\nfoo = foo_gen().next\nfor i in range(0,10):\n print foo()\n\nIf you want an upper limit:\ndef foo_gen(limit=100000):\n n = 0\n while n < limit:\n n+=1\n yield n\n\nIf the iterator terminates (like the example above), you can also loop over it directly, like\nfor i in foo_gen(20):\n print i\n\nOf course, in these simple cases it's better to use xrange :)\nHere is the documentation on the yield statement.\n", "Other solutions attach a counter attribute to the function, usually with convoluted logic to handle the initialization. This is inappropriate for new code.\nIn Python 3, the right way is to use a nonlocal statement:\ncounter = 0\ndef foo():\n nonlocal counter\n counter += 1\n print(f'counter is {counter}')\n\nSee PEP 3104 for the specification of the nonlocal statement.\nIf the counter is intended to be private to the module, it should be named _counter instead.\n", "Using an attribute of a function as static variable has some potential drawbacks:\n\nEvery time you want to access the variable, you have to write out the full name of the function.\nOutside code can access the variable easily and mess with the value.\n\nIdiomatic python for the second issue would probably be naming the variable with a leading underscore to signal that it is not meant to be accessed, while keeping it accessible after the fact.\nUsing closures\nAn alternative would be a pattern using lexical closures, which are supported with the nonlocal keyword in python 3.\ndef make_counter():\n i = 0\n def counter():\n nonlocal i\n i = i + 1\n return i\n return counter\ncounter = make_counter()\n\nSadly I know no way to encapsulate this solution into a decorator.\nUsing an internal state parameter\nAnother option might be an undocumented parameter serving as a mutable value container.\ndef counter(*, _i=[0]):\n _i[0] += 1\n return _i[0]\n\nThis works, because default arguments are evaluated when the function is defined, not when it is called.\nCleaner might be to have a container type instead of the list, e.g.\ndef counter(*, _i = Mutable(0)):\n _i.value += 1\n return _i.value\n\nbut I am not aware of a builtin type, that clearly communicates the purpose.\n", "A little bit more readable, but more verbose (Zen of Python: explicit is better than implicit):\n>>> def func(_static={'counter': 0}):\n... _static['counter'] += 1\n... print _static['counter']\n...\n>>> func()\n1\n>>> func()\n2\n>>>\n\nSee here for an explanation of how this works.\n", "\n_counter = 0\ndef foo():\n global _counter\n _counter += 1\n print 'counter is', _counter\n\nPython customarily uses underscores to indicate private variables. The only reason in C to declare the static variable inside the function is to hide it outside the function, which is not really idiomatic Python.\n", "def staticvariables(**variables):\n def decorate(function):\n for variable in variables:\n setattr(function, variable, variables[variable])\n return function\n return decorate\n\n@staticvariables(counter=0, bar=1)\ndef foo():\n print(foo.counter)\n print(foo.bar)\n\nMuch like vincent's code above, this would be used as a function decorator and static variables must be accessed with the function name as a prefix. The advantage of this code (although admittedly anyone might be smart enough to figure it out) is that you can have multiple static variables and initialise them in a more conventional manner.\n", "After trying several approaches I ended up using an improved version of @warvariuc's answer:\nimport types\n\ndef func(_static=types.SimpleNamespace(counter=0)):\n _static.counter += 1\n print(_static.counter)\n\n", "The idiomatic way is to use a class, which can have attributes. If you need instances to not be separate, use a singleton.\nThere are a number of ways you could fake or munge \"static\" variables into Python (one not mentioned so far is to have a mutable default argument), but this is not the Pythonic, idiomatic way to do it. Just use a class.\nOr possibly a generator, if your usage pattern fits.\n", "A static variable inside a Python method\nclass Count:\n def foo(self):\n try: \n self.foo.__func__.counter += 1\n except AttributeError: \n self.foo.__func__.counter = 1\n\n print self.foo.__func__.counter\n\nm = Count()\nm.foo() # 1\nm.foo() # 2\nm.foo() # 3\n\n", "Another (not recommended!) twist on the callable object like https://stackoverflow.com/a/279598/916373, if you don't mind using a funky call signature, would be to do\nclass foo(object):\n counter = 0;\n @staticmethod\n def __call__():\n foo.counter += 1\n print \"counter is %i\" % foo.counter\n\n\n>>> foo()()\ncounter is 1\n>>> foo()()\ncounter is 2\n\n", "Soulution n +=1 \ndef foo():\n foo.__dict__.setdefault('count', 0)\n foo.count += 1\n return foo.count\n\n", "A global declaration provides this functionality. In the example below (python 3.5 or greater to use the \"f\"), the counter variable is defined outside of the function. Defining it as global in the function signifies that the \"global\" version outside of the function should be made available to the function. So each time the function runs, it modifies the value outside the function, preserving it beyond the function.\ncounter = 0\n\ndef foo():\n global counter\n counter += 1\n print(\"counter is {}\".format(counter))\n\nfoo() #output: \"counter is 1\"\nfoo() #output: \"counter is 2\"\nfoo() #output: \"counter is 3\"\n\n", "Using a decorator and a closure\nThe following decorator can be used create static function variables. It replaces the declared function with the return from itself. This implies that the decorated function must return a function.\ndef static_inner_self(func):\n return func()\n\nThen use the decorator on a function that returns another function with a captured variable:\n@static_inner_self\ndef foo():\n counter = 0\n def foo():\n nonlocal counter\n counter += 1\n print(f\"counter is {counter}\")\n return foo\n\nnonlocal is required, otherwise Python thinks that the counter variable is a local variable instead of a captured variable. Python behaves like that because of the variable assignment counter += 1. Any assignment in a function makes Python think that the variable is local.\nIf you are not assigning to the variable in the inner function, then you can ignore the nonlocal statement, for example, in this function I use to indent lines of a string, in which Python can infer that the variable is nonlocal:\n@static_inner_self\ndef indent_lines():\n import re\n re_start_line = re.compile(r'^', flags=re.MULTILINE)\n def indent_lines(text, indent=2):\n return re_start_line.sub(\" \"*indent, text)\n return indent_lines\n\nP.S. There is a deleted answer that proposed the same. I don't know why the author deleted it.\nhttps://stackoverflow.com/a/23366737/195417\n", "Prompted by this question, may I present another alternative which might be a bit nicer to use and will look the same for both methods and functions:\n@static_var2('seed',0)\ndef funccounter(statics, add=1):\n statics.seed += add\n return statics.seed\n\nprint funccounter() #1\nprint funccounter(add=2) #3\nprint funccounter() #4\n\nclass ACircle(object):\n @static_var2('seed',0)\n def counter(statics, self, add=1):\n statics.seed += add\n return statics.seed\n\nc = ACircle()\nprint c.counter() #1\nprint c.counter(add=2) #3\nprint c.counter() #4\nd = ACircle()\nprint d.counter() #5\nprint d.counter(add=2) #7\nprint d.counter() #8    \n\nIf you like the usage, here's the implementation:\nclass StaticMan(object):\n def __init__(self):\n self.__dict__['_d'] = {}\n\n def __getattr__(self, name):\n return self.__dict__['_d'][name]\n def __getitem__(self, name):\n return self.__dict__['_d'][name]\n def __setattr__(self, name, val):\n self.__dict__['_d'][name] = val\n def __setitem__(self, name, val):\n self.__dict__['_d'][name] = val\n\ndef static_var2(name, val):\n def decorator(original):\n if not hasattr(original, ':staticman'): \n def wrapped(*args, **kwargs):\n return original(getattr(wrapped, ':staticman'), *args, **kwargs)\n setattr(wrapped, ':staticman', StaticMan())\n f = wrapped\n else:\n f = original #already wrapped\n\n getattr(f, ':staticman')[name] = val\n return f\n return decorator\n\n", "Instead of creating a function having a static local variable, you can always create what is called a \"function object\" and give it a standard (non-static) member variable.\nSince you gave an example written C++, I will first explain what a \"function object\" is in C++. A \"function object\" is simply any class with an overloaded operator(). Instances of the class will behave like functions. For example, you can write int x = square(5); even if square is an object (with overloaded operator()) and not technically not a \"function.\" You can give a function-object any of the features that you could give a class object.\n# C++ function object\nclass Foo_class {\n private:\n int counter; \n public:\n Foo_class() {\n counter = 0;\n }\n void operator() () { \n counter++;\n printf(\"counter is %d\\n\", counter);\n } \n };\n Foo_class foo;\n\nIn Python, we can also overload operator() except that the method is instead named __call__:\nHere is a class definition:\nclass Foo_class:\n def __init__(self): # __init__ is similair to a C++ class constructor\n self.counter = 0\n # self.counter is like a static member\n # variable of a function named \"foo\"\n def __call__(self): # overload operator()\n self.counter += 1\n print(\"counter is %d\" % self.counter);\nfoo = Foo_class() # call the constructor\n\nHere is an example of the class being used:\nfrom foo import foo\n\nfor i in range(0, 5):\n foo() # function call\n\nThe output printed to the console is:\ncounter is 1\ncounter is 2\ncounter is 3\ncounter is 4\ncounter is 5\n\nIf you want your function to take input arguments, you can add those to __call__ as well:\n# FILE: foo.py - - - - - - - - - - - - - - - - - - - - - - - - -\n\nclass Foo_class:\n def __init__(self):\n self.counter = 0\n def __call__(self, x, y, z): # overload operator()\n self.counter += 1\n print(\"counter is %d\" % self.counter);\n print(\"x, y, z, are %d, %d, %d\" % (x, y, z));\nfoo = Foo_class() # call the constructor\n\n# FILE: main.py - - - - - - - - - - - - - - - - - - - - - - - - - - - - \n\nfrom foo import foo\n\nfor i in range(0, 5):\n foo(7, 8, 9) # function call\n\n# Console Output - - - - - - - - - - - - - - - - - - - - - - - - - - \n\ncounter is 1\nx, y, z, are 7, 8, 9\ncounter is 2\nx, y, z, are 7, 8, 9\ncounter is 3\nx, y, z, are 7, 8, 9\ncounter is 4\nx, y, z, are 7, 8, 9\ncounter is 5\nx, y, z, are 7, 8, 9\n\n", "This answer builds on @claudiu 's answer.\nI found that my code was getting less clear when I always had \nto prepend the function name, whenever I intend to access a static variable.\nNamely, in my function code I would prefer to write:\nprint(statics.foo)\n\ninstead of\nprint(my_function_name.foo)\n\nSo, my solution is to :\n\nadd a statics attribute to the function\nin the function scope, add a local variable statics as an alias to my_function.statics\n\nfrom bunch import *\n\ndef static_vars(**kwargs):\n def decorate(func):\n statics = Bunch(**kwargs)\n setattr(func, \"statics\", statics)\n return func\n return decorate\n\n@static_vars(name = \"Martin\")\ndef my_function():\n statics = my_function.statics\n print(\"Hello, {0}\".format(statics.name))\n\n\nRemark\nMy method uses a class named Bunch, which is a dictionary that supports \nattribute-style access, a la JavaScript (see the original article about it, around 2000)\nIt can be installed via pip install bunch\nIt can also be hand-written like so:\nclass Bunch(dict):\n def __init__(self, **kw):\n dict.__init__(self,kw)\n self.__dict__ = self\n\n", "I personally prefer the following to decorators. To each their own.\ndef staticize(name, factory):\n \"\"\"Makes a pseudo-static variable in calling function.\n\n If name `name` exists in calling function, return it. \n Otherwise, saves return value of `factory()` in \n name `name` of calling function and return it.\n\n :param name: name to use to store static object \n in calling function\n :type name: String\n :param factory: used to initialize name `name` \n in calling function\n :type factory: function\n :rtype: `type(factory())`\n\n >>> def steveholt(z):\n ... a = staticize('a', list)\n ... a.append(z)\n >>> steveholt.a\n Traceback (most recent call last):\n ...\n AttributeError: 'function' object has no attribute 'a'\n >>> steveholt(1)\n >>> steveholt.a\n [1]\n >>> steveholt('a')\n >>> steveholt.a\n [1, 'a']\n >>> steveholt.a = []\n >>> steveholt.a\n []\n >>> steveholt('zzz')\n >>> steveholt.a\n ['zzz']\n\n \"\"\"\n from inspect import stack\n # get scope enclosing calling function\n calling_fn_scope = stack()[2][0]\n # get calling function\n calling_fn_name = stack()[1][3]\n calling_fn = calling_fn_scope.f_locals[calling_fn_name]\n if not hasattr(calling_fn, name):\n setattr(calling_fn, name, factory())\n return getattr(calling_fn, name)\n\n", "Building on Daniel's answer (additions):\nclass Foo(object): \n counter = 0 \n\ndef __call__(self, inc_value=0):\n Foo.counter += inc_value\n return Foo.counter\n\nfoo = Foo()\n\ndef use_foo(x,y):\n if(x==5):\n foo(2)\n elif(y==7):\n foo(3)\n if(foo() == 10):\n print(\"yello\")\n\n\nuse_foo(5,1)\nuse_foo(5,1)\nuse_foo(1,7)\nuse_foo(1,7)\nuse_foo(1,1)\n\nThe reason why I wanted to add this part is , static variables are used not only for incrementing by some value, but also check if the static var is equal to some value, as a real life example.\nThe static variable is still protected and used only within the scope of the function use_foo()\nIn this example, call to foo() functions exactly as(with respect to the corresponding c++ equivalent) :\nstat_c +=9; // in c++\nfoo(9) #python equiv\n\nif(stat_c==10){ //do something} // c++\n\nif(foo() == 10): # python equiv\n #add code here # python equiv \n\nOutput :\nyello\nyello\n\nif class Foo is defined restrictively as a singleton class, that would be ideal. This would make it more pythonic.\n", "I write a simple function to use static variables:\ndef Static():\n ### get the func object by which Static() is called.\n from inspect import currentframe, getframeinfo\n caller = currentframe().f_back\n func_name = getframeinfo(caller)[2]\n # print(func_name)\n caller = caller.f_back\n func = caller.f_locals.get(\n func_name, caller.f_globals.get(\n func_name\n )\n )\n \n class StaticVars:\n def has(self, varName):\n return hasattr(self, varName)\n def declare(self, varName, value):\n if not self.has(varName):\n setattr(self, varName, value)\n\n if hasattr(func, \"staticVars\"):\n return func.staticVars\n else:\n # add an attribute to func\n func.staticVars = StaticVars()\n return func.staticVars\n\nHow to use:\ndef myfunc(arg):\n if Static().has('test1'):\n Static().test += 1\n else:\n Static().test = 1\n print(Static().test)\n\n # declare() only takes effect in the first time for each static variable.\n Static().declare('test2', 1)\n print(Static().test2)\n Static().test2 += 1\n\n", "Miguel Angelo's self-redefinition solution is even possible without any decorator:\ndef fun(increment=1):\n global fun\n counter = 0\n def fun(increment=1):\n nonlocal counter\n counter += increment\n print(counter)\n fun(increment)\n\nfun() #=> 1\nfun() #=> 2\nfun(10) #=> 12\n\nThe second line has to be adapted to get a limited scope:\ndef outerfun():\n def innerfun(increment=1):\n nonlocal innerfun\n counter = 0\n def innerfun(increment=1):\n nonlocal counter\n counter += increment\n print(counter)\n innerfun(increment)\n\n innerfun() #=> 1\n innerfun() #=> 2\n innerfun(10) #=> 12\n\nouterfun()\n\nThe plus of the decorator is that you don't have to pay extra attention to the scope of your construction.\n" ]

[ 822, 270, 251, 70, 60, 33, 32, 17, 16, 11, 10, 9, 7, 6, 4, 4, 4, 4, 4, 4, 3, 3, 2, 1, 0, 0, 0 ]

[ "Sure this is an old question but I think I might provide some update.\nIt seems that the performance argument is obsolete. \nThe same test suite appears to give similar results for siInt_try and isInt_re2.\nOf course results vary, but this is one session on my computer with python 3.4.4 on kernel 4.3.01 with Xeon W3550.\nI have run it several times and the results seem to be similar.\nI moved the global regex into function static, but the performance difference is negligible. \nisInt_try: 0.3690\nisInt_str: 0.3981\nisInt_re: 0.5870\nisInt_re2: 0.3632\n\nWith performance issue out of the way, it seems that try/catch would produce the most future- and cornercase- proof code so maybe just wrap it in function\n" ]

[ -2 ]

[ "python", "static" ]

[ "You can't do this, at least in a general way, because while you can get the type annotations of the function's parameters, the objects that your function receives at runtime as arguments don't have type annotations attached to them.\nA function's types and their parameters can be inspected via its __annotations__ property:\n>>> def foo(x: list[int]) -> None:\n... print(sum(x))\n...\n>>> foo.__annotations__\n{'x': list[int], 'return': None}\n>>> foo.__annotations__['x'].__args__\n(<class 'int'>,)\n\nbut an actual list that is referenced by a variable that was annotated as list[int] has no such property that you can get the int type parameter from:\n>>> a: list[int] = []\n>>> dir(a)\n['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']\n>>> type(a)\n<class 'list'>\n\nA static typechecking tool (e.g. mypy) can see the annotation at the point where a is declared, and it can use that to validate that foo(a) is a valid function call, but runtime logic inside foo can't do that because the annotation isn't bound to the object at runtime.\nYou can of course hack around it with something like isinstance(a, list) and all(isinstance(i, int) for i in a) but it's hard to generalize this, and it doesn't actually provide a guarantee that a has the annotation you expect (an empty list at runtime is effectively a list[Any], even though in a static typechecking context the type of objects you can add to it is constrained by its type annotation).\nThe simple solution is to use mypy (or similar) statically rather than trying to enforce type annotations at runtime -- or make a best effort at runtime and accept that you'll miss a lot of cases that static type checking would have caught.\n" ]

[ 2 ]

[]

[]

[ "function", "python", "types", "typing" ]

[ "You need to override form_valid() instead of post().\nfrom django.http import HttpResponseRedirect\n\ndef form_valid(self, form):\n user = form.save() #save the user\n login(request, user)\n return HttpResponseRedirect(self.get_success_url())\n\n" ]

[ 0 ]

[]

[]

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

[ "When list[0] < 0 your code ignores the rest of the list, yet there could be more negative values there to count.\nSo in that case don't do:\n return count + 1\n\nbut:\n return 1 + countNegatives(list[1:])\n\n", "The step you were missing is to add the count to the returned value of the recursive call, so that the returned values of all recursive calls get summed up at the end. Here's one way you could do this:\ndef countNegatives(list):\n #if the list length is zero, we are done\n if len(list) == 0:\n return 0\n\n # Get the count of this iteration\n count = 1 if list[0] < 0 else 0\n # sum the count of this iteration with the count of all subsequent iterations\n return count + countNegatives(list[1:])\n\nSo, for your first example, the actual steps taken by your code would look like:\nreturn 0 + countNegatives([1, -1, 3, -5, 6])\nreturn 0 + countNegatives([-1, 3, -5, 6])\nreturn 1 + countNegatives([3, -5, 6])\nreturn 0 + countNegatives([-5, 6])\nreturn 1 + countNegatives([6])\nreturn 0 + countNegatives([])\nreturn 0\n\nExpanding all the values gives:\nreturn 0 + 0 + 1 + 0 + 1 + 0 + 0 \n\n", "Recursion is a functional heritage and so using it with functional style yields the best results. That means avoiding things like mutation, variable reassignments, and other side effects. We can implement using straightforward mathematical induction -\n\nIf the input list is empty, there is nothing to count. Return the empty result, 0\n(inductive) the input list has at least one element. If the first element is negative, return 1 plus the sum of the recursive sub-problem\n(inductive) the input list has at least one element and the first element is positive. Return 0 plus the sum of the recursive sub-problem\n\ndef countNegatives(t):\n if not t: return 0 # 1\n elif t[0] < 0: return 1 + countNegatives(t[1:]) # 2\n else: return 0 + countNegatives(t[1:]) # 3\n\nPython 3.10 offers an elegant pattern matching solution -\ndef countNegatives(t):\n match t:\n case []: #1\n return 0\n case [n, *next] if n < 0: #2\n return 1 + countNegatives(next)\n case [_, *next]: #3\n return 0 + countNegatives(next)\n\n", "All of the answers provided so far will fail with a stack overflow condition if given a large list, such as:\nprint(countNegatives([i-5000 for i in range(10000)]))\n\nThey all break a problem of size n into two subproblems of size 1 and size n-1, so the recursive stack growth is O(n). Python’s default stack size maxes out at around 1000 function calls, so this limits that approach to smaller lists.\nWhen possible, it's a good idea to try to split a recursive problem of size n into two subproblems that are half that size. Successive halving yields a stack growth that is O(log n), so it can handle vastly larger problems.\nFor your problem note that the number of negatives in a list of size n > 2 is the number in the first half of the list plus the number in the second half of the list. If the list has one element, return 1 if it's negative. If it's non-negative or the list is empty, return 0.\ndef countNegatives(lst):\n size = len(lst) # evaluate len() only once\n if size > 1:\n mid = size // 2 # find midpoint of lst\n return countNegatives(lst[:mid]) + countNegatives(lst[mid:])\n if size == 1 and lst[0] < 0:\n return 1\n return 0\n\nprint(countNegatives([0, 1, -1, 3, -5, 6])) # 2\nprint(countNegatives([-1, -3, 50, -4, -5, 1])) # 4\nprint(countNegatives([i - 5000 for i in range(10000)])) # 5000\n\nWith this approach you'll run out of memory to store the list long before you would get a stack overflow condition.\n" ]

[ 0, 0, 0, 0 ]

[ "The problem with your code is that you are not keeping track of the running count of negative numbers in the recursive calls. Specifically, you are returning count + 1 when the first item of the list is negative, and discarding the rest of the list, instead of using a recursive call to count the number of negative items in the rest of the list.\nTo fix the problem, you can add the result of the recursive call to count in both cases, when the first item is negative and when it is not. This way, the running count of negative items will be accumulated through the recursive calls, and returned as the final result when the base case is reached.\nHere's a corrected version of your code:\ndef countNegatives(lst):\n \"\"\"Takes in a list of numbers and\n returns the number of negative numbers\n that are inside the list.\"\"\"\n count = 0\n if len(lst) == 0:\n return 0\n else:\n if lst[0] < 0:\n count += 1\n count += countNegatives(lst[1:])\n return count\n\nprint(countNegatives([0, 1, -1, 3, -5, 6])) # Output: 2\nprint(countNegatives([-1, -3, 50, -4, -5, 1])) # Output: 4\n\nNote that I renamed the parameter list to lst, because list is the name of a built-in Python data type, and it is a good practice to avoid using built-in names as variable names.\n", "You want to accumulate count, so pass it to the recursive function. The first caller starts at zero, so you have a good default.\ndef countNegatives(list, count=0):\n \"\"\"Takes in a list of numbers and\n returns the number of negative numbers\n that are inside the list.\"\"\"\n if len(list):\n count += list[0] < 0\n return countNegatives(list[1:], count)\n else:\n return count\n\nresult = countNegatives([1,99, -3, 6, -66, -7, 12, -1, -1])\nprint(result)\nassert result == 5\n \n\n" ]

[ -1, -1 ]

[ "python", "recursion" ]

[ "\nfrom django.shortcuts import redirect\n\ndef login(request):\n # Verify the user's authentication data\n # and authenticate the user if the data is valid\n # ...\n\n # Redirect the user to the VueJS frontend\n return redirect('https://vuejs.app')\n\n\nIn this example, when the user is successfully authenticated in your Django application, the redirect function is called to redirect the user to the specified URL (in this case, https://vuejs.app). This will allow the user to access the VueJS frontend without having to log in again.\n" ]

[ 0 ]

[]

[]

[ "django", "python", "vite", "vue.js", "webpack" ]

[ "When you call cli_run as part of virtualenv, you don't need to include the first argument, in this case \"venv\".\nthis should work:\nfrom virtualenv import cli_run\ncli_run([\"--app-data APP_DATA\", \"--seeder {app-data,pip}\"]);\n\n", "According to virtualenv's documentation section \"Programmatic API\", this seems like the following should work:\nfrom virtualenv import cli_run\n\ncli_run(['path/to/venv', '--app-data', 'path/to/app_data', '--seeder', 'app-data'])\n\n" ]

[ 0, 0 ]

[]

[]

[ "python", "virtualenv" ]

[ "You can try something like :\nfor sv in driver.find_elements(By.XPATH,\"//*[local-name()='svg' and @class='rv-xy-plot__inner']//*[local-name()='g' and @class='rv-xy-plot__series rv-xy-plot__series--label typography-body-medium-xs text-primary']\"):\n txt= sv.find_emlement(By.XPATH, './/text').text\n print(txt)\n\n#OR\n for sv in driver.find_elements(By.XPATH,\"//*[local-name()='svg' and @class='rv-xy-plot__inner']//*[local-name()='g' and @class='rv-xy-plot__series rv-xy-plot__series--label typography-body-medium-xs text-primary']//text\"):\n txt= sv.text\n print(txt)\n \n \n\n", "sv = driver.find_elements(By.XPATH,\"//*[local-name()='svg' and @class='rv-xy-plot__inner']//*[local-name()='g' and @class='rv-xy-plot__series rv-xy-plot__series--label typography-body-medium-xs text-primary']//*[name()='text']\")\n\nThis gives me a list I can iterate through to get the values.\nThanks to the idea from @Fazlul, the modification I've made is //*[name()='text'] at the end.\n" ]

[ 1, 0 ]

[]

[]

[ "python", "selenium", "svg", "web_scraping" ]

[ "Solved.\nAfter some more investigation it was clear that I was facing 2 problems:\n\nNot declaring the env path in the system\nNot activating the virtual enviroment properly (hence the SSL error)\n\nSince I do not have the admin rights of the laptop (corporate one) I solved the path issue by defining the the project path in the .bat file, adding the path temporally each time the env is activated.\nThe one-liner I wrote in the initial .bat is not activating the enviroment. The correct way is to call the 'activate.bat' in the conda folder.\nHereby the solution in the .bat file:\n@echo off\nrem Define path to conda installation and env name.\nset CONDAPATH= #CondaPath\nset ENVNAME= #EnvName\n\nrem Activate the env\nif %ENVNAME%==base (set ENVPATH=%CONDAPATH%) else (set ENVPATH=%CONDAPATH%\\envs\\%ENVNAME%)\ncall %CONDAPATH%\\Scripts\\activate.bat %ENVPATH%\n\nset PYTHONPATH= #ProjectPath\n\nrem Run a python script in that environment\npython #ScriptPath_1\npython #ScriptPath_2\npython #ScriptPath_3\n\nrem Deactivate the environment\ncall conda deactivate\n\nHope this helps someone trying to automate python scripts using the windows task scheduler with .bat files\n" ]

[ 0 ]

[]

[]

[ "import", "path", "pycharm", "python" ]

[ "One of the algorithm commonly used for these type of questions (permutations and combinations) is using depth-first-search (DFS). Here's a link to a more similar but harder leetcode problem on palindrome partitioning that uses backtracking and DFS. My solution is based off of that leetcode post.\nAlgorithm\nIf my explanation is not enough go through the leetcode link provided above it may make sense.\nThe general idea is iteration through the list and get all the combinations from current element by resursively traversing through the remaining elements after the current elements.\nPseudocode\nfunction recursive (list)\n recurise condition\n yield child\n \n for element in remaining-elements:\n // Get the combinations from all elements start from 'element'\n partitions = recursive (...)\n\n // join the list of elements already explored with the provided combinations\n for every child from partitions:\n yield combination_before + child\n\n\nThe major concept through this is using Depth-First-Search, and maybe figuring out the recursive condition as that really took me a while when.\nYou can also optimize the code by storing the results of the deep recursive operations in a dictionary and access them when you revisit over in the next iterations. I'm also pretty sure there is some optimal dynamic programming solution for this somewhere out there. Goodluck, hope this helped\nEdit: My bad, I realised i had the actual solution before the edit, had no idea that may slighty conflict with individual community guidelines.\n" ]

[ 0 ]

[]

[]

[ "generator", "multidimensional_array", "python", "recursion" ]

[ "I had the same problem, and I found your question while trying to find a solution.\nTry adding host as string and port as integer types inside run_server like this:\napp.run_server(mode='external', host='your_host', port=your_port)\nMy host is 127.0.0.1, and the port is 8050.\nHope it helps\n" ]

[ 0 ]

[]

[]

[ "jupyter_notebook", "jupyterdash", "plotly_dash", "python" ]

[ "Here is one way to do it with Pandas assign and pipe:\ndf = (\n df.assign(total=df.groupby(\"Date\")[\"Pop\"].transform(\"sum\"))\n .pipe(\n lambda df_: df_.assign(\n pc=df_.groupby([\"City\"])\n .agg({\"Pop\": \"diff\", \"total\": \"shift\"})\n .pipe(lambda x: x[\"Pop\"] / x[\"total\"])\n )\n )\n .drop(columns=\"total\")\n)\n\nThen:\nprint(df)\n# Output\n Date City Pop pc\n0 2020-01-01 London 90 NaN\n1 2020-01-01 New York 70 NaN\n2 2020-01-01 Tokyo 60 NaN\n3 2021-01-01 London 85 -0.022727\n4 2021-01-01 New York 60 -0.045455\n5 2021-01-01 Tokyo 45 -0.068182\n6 2022-01-01 London 70 -0.078947\n7 2022-01-01 New York 40 -0.105263\n8 2022-01-01 Tokyo 32 -0.068421\n\n" ]

[ 1 ]

[]

[]

[ "pandas", "python" ]

[ "These variables that are available to the shell script are called environment variables and are separate from Python variables. To get environment variables in python, you need to use the os.environ dictionary. You can do it like this:\nimport os\n\n\npam_type = os.environ['PAM_TYPE']\nprint(pam_type)\n\npam_service = os.environ['PAM_SERVICE']\nprint(pam_service)\n\npam_ruser = os.environ['PAM_RUSER']\nprint(pam_ruser)\n\nNote that you need to remove the leading dollar sign ($)\n" ]

[ 2 ]

[]

[]

[ "linux", "python", "shell" ]

[ "I think it is:\nawait message.add_reaction(emoji)\n\n" ]

[ 0 ]

[]

[]

[ "discord", "discord.py", "python" ]

[ "In our systems, we handle this scenario with a dedicated publish branch.\nThe GitHub action workflow for publishing starts like this:\nname: Publish\n\non:\n push:\n branches: [publish]\n\nso it's only triggered by a push to publish and it deploys to the gh-pages branch in our case.\nAll the draft work and the review versions live in different branches, with the publish branch itself set to be protected so nothing can pushed to it without proper review.\nWe also have a review branch where we stage things for pre-publication review, and we merge into publish from review. A colleague has set that part up, but the review branch gets deployed into a staging subdomain similar to yours so we can review it before publication.\n" ]

[ 0 ]

[]

[]

[ "digital_ocean", "git", "python" ]

[ "You can use orient='records'.\nall_kpi.to_dict(orient='records')\n\nCheck out the pandas documentation for different orientation.\n" ]

[ 0 ]

[]

[]

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

[ "Many thanks to @hpaulj\nIt turns out to be a problem of datatype. The program is ok but the input datatype is int, which results in intermediate trancation errors.\nA lesson learned: be aware of the dtype of np.ndarray!\n" ]

[ 0 ]

[]

[]

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

[ "If you want a method to end in python you can just use return. In your ** ** case just type return under the if statement and it will ends. And in your ** case you just print goodbye or so and then use return.\n" ]

[ 0 ]

[]

[]

[ "python", "tkinter" ]

[ "Looks like you added LocaleMiddleware to the end of middlewares list. But order is matter here. From the docs:\n\nBecause middleware order matters, follow these guidelines:\nMake sure it’s one of the first middleware installed.\nIt should come after SessionMiddleware, because LocaleMiddleware makes use of session data. And it should come before CommonMiddleware\nbecause CommonMiddleware needs an activated language in order to\nresolve the requested URL.\nIf you use CacheMiddleware, put LocaleMiddleware after it.\n\nTry to change order according to this note.\n" ]

[ 0 ]

[]

[]

[ "django", "django_rest_framework", "internationalization", "python" ]

[ "The call to DF.RL requires a function of the differential equation, however, you used the solution to a differential equation - state (output of odeint call). From the package site https://pypi.org/project/differint/\ndef f(x):\n return x**0.5\n\nDF = df.RL(0.5, f)\nprint(DF)\n\nCan you try DF = df.RL(1, Lorenz, 0, len(t), len(t)) ?\n" ]

[ 0 ]

[]

[]

[ "derivative", "differential_equations", "python", "python_3.x" ]

[ "r.json is a method. So you need to call it with parentheses first:\nvar = r.json() #type(var) -- > dictionary\nvar = var['SOME VALUE']\n\n#or (shorter)\nvar = r.json()['SOME VALUE']\n\n" ]

[ 2 ]

[]

[]

[ "grequests", "python" ]

[ "When you run the python file in windows it uses Chrome installed in you Windows machine, but when you work in a bash terminal you do it on a Linux machine that runs as a virtual machine in you Windows.\nSo it is a separate machine and it cannot use Chrome from your Windows. It needs to have its own Chrome. Additionally this virtual machine does not have a GUI so you will need to run selenium in the headless mode.\n" ]

[ 0 ]

[]

[]

[ "automation", "bash", "python", "selenium", "selenium_chromedriver" ]

[ "It looks like the error is happening because you're trying to write an object of the Person class to the CSV file, but the csv.writerow method expects a string or a list of strings as input.\nTo fix the error, you can modify your code to convert the Person object to a string before writing it to the CSV file. One way to do this is to define a str method for the Person class, which will be called whenever you try to convert an instance of the class to a string.\nHere's an example of how you could define the str method for the Person class:\nclass Person:\ndef __init__(self, age):\n self.gender = random.randint(0,1)\n self.age = age\n\ndef __str__(self):\n return \"age: {}, gender: {}\".format(self.age, self.gender)\n\nWith this method defined, you can write the Person objects to the CSV file like this:\nfor person in peopleDictionary:\ndb.writerow([str(person)])\n\nThis will convert the Person objects to strings using the str method, and then write the strings to the CSV file.\n" ]

[ 0 ]

[]

[]

[ "csv", "python" ]

[ "Firstly, there is no reason to loop though all messages in a folder - that would be extremely slow in folders with thousands of messages, especially if the cached mode is off.\nUse Items.Restrict or Items.Find/FindNext - let the store provider do the heavy lifting for you. You will be able to specify a restriction on the Subject and/or ReceivedTime property\". See the examples at https://learn.microsoft.com/en-us/office/vba/api/outlook.items.restrict\n" ]

[ 0 ]

[]

[]

[ "email", "office_automation", "outlook", "python", "python_3.x" ]

[ "One issue with your code is that you are using the mean function on the desc array, which is not a valid input for the mean function because it is not a numerical array. The desc array is a 2D array of shape (N, 128), where N is the number of keypoints detected by the SIFT algorithm, and 128 is the length of the feature vector for each keypoint.\nTo compute the mean of the desc array, you can use the mean function along one of the axes, for example:\ndesc_mean = np.mean(desc, axis=0)\n\nThis will compute the mean of each column in the desc array, and return a 1D array of shape (128,) with the mean feature vector.\nAnother issue with your code is that you are trying to create a feat_mtx array of shape (224, 224) and fill it with the feature vectors from the desc array. This will not work because the desc array has a different shape than the feat_mtx array ((N, 128) vs (224, 224)), and it is not possible to directly fill the feat_mtx array with the feature vectors from the desc array.\nInstead, you can create a feat_mtx array of shape (N, 128) and fill it with the feature vectors from the desc array, like this:\nfeat_mtx = np.zeros((desc.shape[0], desc.shape[1]))\nfor int, j in enumerate(desc):\n feat_mtx[int] = j\n\nThis will create a feat_mtx array with the same shape as the desc array, and fill it with the feature vectors from the desc array.\nOnce you have fixed these issues with your code, you should be able to compute the mean of the feat_mtx array and append it to the desc_list array, like this:\n# compute the mean of the feat_mtx array\nfeat_mtx_mean = np.mean(feat_mtx, axis=0)\n\n# append the mean of the feat_mtx array to the desc_list array\ndesc_list.append(feat_mtx_mean)\n\nWith these changes, your code should be able to process all of the images in the dataset and compute the mean feature vectors for each category. You can then use these mean feature vectors as input for the PCA and deep learning model.\n" ]

[ 1 ]

[]

[]

[ "python", "typeerror" ]

[ "Separate the values and plug them into the formula.\na,b,c = median.array\ncalc = [(-.5447 + .1712 * a + -.5447 + .9601 * b + -.5447 + .8474 * c)]\n\n\nAdd parenthesis around the terms to ensure order of operations.\n\nOr\nq = median.array * (.1712,.9601,.8474)\n# q = median.to_numpy() * (.1712,.9601,.8474)\nq = q + (-.5447,-.5447,-.5447)\nr = q.sum()\n\n\nPandas Series\n" ]

[ 0 ]

[]

[]

[ "array_formulas", "for_loop", "function", "python" ]

[ "One way to optimize the memory usage in this code is to avoid using a list to store the numbers of the lightbulbs that are turned on. Instead, you can use a Python set to store the numbers of the lightbulbs, which is more memory-efficient.\nHere is an updated version of the code that uses a set to store the numbers of the lightbulbs:\nfrom collections import Counter\n\ndef getWhiteLightLength(n, m, lights):\n lt_nv = set()\n ctd = 0\n for clr, inic, fim in lights:\n for num in range(inic, fim+1):\n lt_nv.add(num)\n c = Counter(lt_nv)\n for ch, vl in c.items():\n if vl == m:\n ctd += 1\n return ctd\n\nIn this code, the lt_nv set is used to store the numbers of the lightbulbs that are turned on. The add() method is used to add each number to the set, and the Counter() function is used to count the number of times each lightbulb number appears in the set.\nThis updated code should be more memory-efficient and should be able to pass the tests on HackerRank without a memory usage error.\n" ]

[ 0 ]

[]

[]

[ "loops", "memory", "memory_management", "python" ]

[ "Thanks to @Rolf of Saxony headsup I figured it out!\nIt took the following 3 steps:\n1st Step:\nTop Title Text Display from:\nclass MyTitleBarPnl(wx.Panel):\n def CreateCtrls(self):\n self.titleBar.SetSize((w, 54))\n\n def OnResize(self, event):\n self.titleBar.SetSize((w, 54))\n\n\n2nd Step:\nVertical Spacing Below Title Text Without Text Display:\nclass MyFrame(wx.Frame):\n def CreateCtrls(self):\n self.titleBarPnl = MyTitleBarPnl(self, -1, (w, 54))\n\n def OnResize(self, event):\n self.titleBarPnl.SetSize((w, 24))\n\n\n3rd Step:\nVertical Spacing Below Title Text WithText Display:\nclass MyFrame(wx.Frame):\n def CreateCtrls(self):\n self.titleBarPnl = MyTitleBarPnl(self, -1, (w, 54))\n\n def OnResize(self, event):\n self.titleBarPnl.SetSize((w, 54))\n\n\nEDIT:\n4th Step:\nStatus Bar Display:\nclass MyFrame(wx.Frame):\n def CreateCtrls(self):\n self.titleBarPnl = MyTitleBarPnl(self, -1, (w, 54))\n\n def OnResize(self, event):\n self.titleBarPnl.SetSize((w, 54))\n self.mainPnl.SetSize((w, h - 55)) # 25\n\n\n" ]

[ 1 ]

[]

[]

[ "height", "python", "python_3.x", "wxpython", "wxwidgets" ]

[ "Try changing your Book model to inherit from ClusterableModel (which itself inherits from models.Model)\nfrom modelcluster.models import ClusterableModel\n\nclass Book(ClusterableModel):\n\n" ]

[ 0 ]

[]

[]

[ "django", "django_models", "python", "wagtail", "wagtail_admin" ]

[ "I think since you want to replace rather than extend some functionality, monkey patching is the correct approach.\n" ]

[ 0 ]

[]

[]

[ "python", "wagtail" ]

[ "First, 0 is not a multiple of 5. The first multiple of 5 is 5 (5*1). The problem with your code is that you only stop when num_multiples is negative (less than 0). Instead, you want to stop when it is zero. Like this:\ndef print_first_multiples(n, num_multiples): \n if num_multiples == 0:\n return\n else:\n print_first_multiples(n, num_multiples - 1)\n print(n * num_multiples, end=' ')\n\n\nprint_first_multiples(5, 10)\n\nIf you do want to start at 0 and go up to 45, then you can subtract one from num_multiples. Like this:\ndef print_first_multiples(n, num_multiples): \n if num_multiples == 0:\n return\n else:\n print_first_multiples(n, num_multiples - 1)\n print(n * (num_multiples-1), end=' ')\n\n\nprint_first_multiples(5, 10)\n\n", "Try if num_multiples <= 0: instead\n", "It prints until it doesn't enter if num_multiples < 0. So e.x. with the initial value num_multiples = 3 you print for num_multiples=3, num_multiples=2, num_multiples=1, and num_multiples=0 so 4 times. Replace if num_multiples < 0 with if num_multiples == 0 and you'd get what you expect\n" ]

[ 1, 0, 0 ]

[]

[]

[ "function", "python", "recursion" ]

[ "Selenium can't upload files using the Windows select file option, so you'll have to do something else - you might be able to use the send_keys function, i.e.:\nelem = driver.find_element(By.XPATH, \"//input[@type='file']\")\nelem.send_keys('C:\\\\Path\\\\To\\\\File')\n\nNote that this may not work, depending on the type of input, and you may be able to instead simulate a drag-and-drop operation if the website supports this.\nSee How to upload file ( picture ) with selenium, python for more info\n", "For windows path you need double backslashes. Try this:\nwait.until(EC.presence_of_element_located((By.XPATH,\"//input[@type='file']\"))send_keys(\"C:\\\\Users\\\\my_user\\\\Downloads\\\\doch.jpeg\")\n\n" ]

[ 0, 0 ]

[]

[]

[ "python", "selenium" ]

[ "It's just the terminal following tab(4 spaces in your case) convention. So add spaces before and after \\t.\n", "All results has \\t\nRun your code with python yourcode.py | cat -T\nThis is the results. ^I is the tab.\n$ python yourcode.py | cat -T\nindex=0^Ival=14\nindex=1^Ival=46\nindex=2^Ival=87\nindex=3^Ival=83\nindex=4^Ival=28\nindex=5^Ival=77\nindex=6^Ival=34\nindex=7^Ival=66\nindex=8^Ival=64\nindex=9^Ival=80\nindex=10^Ival=28\nindex=11^Ival=21\nindex=12^Ival=64\nindex=13^Ival=79\nindex=14^Ival=92\nindex=15^Ival=67\nindex=16^Ival=69\nindex=17^Ival=50\n\nMan page of cat says\n\n -T, --show-tabs\n display TAB characters as ^I\n\n\nYou may change the length of TAB. Check this article\n", "The behavior you're seeing is because the \\t escape sequence inserts a tab character, which is typically used for indenting text. By default, most text editors and terminals use a tab stop of 8 characters, which means that a tab character will move the cursor to the next multiple of 8 characters.\nIn your code, the first nine values in the list don't have any big spaces because they are not aligned with a multiple of 8 characters. This is because the {index=} and {val=} expressions in the format string each add 3 characters to the output, and the = character adds an additional 1 character, for a total of 7 characters. This means that the first nine values are not aligned with a multiple of 8 characters, and the tab character does not insert any extra spaces.\nIf you want to insert a fixed number of spaces in your output, rather than using a tab character, you can use the {:<N} format specifier, where N is the total number of characters you want the output to occupy. For example, you could use the following code to insert 10 spaces between the index and val values in your output:\nimport random\n\nlst = [random.randint(1,100) for i in range(51)]\nfor index, val in enumerate(last):\n print(f'{index:<10}{val=}')\n\nIn this code, the {index:<10} format specifier tells the format function to left-align the index value within a field of 10 characters. This ensures that there are always 10 spaces between the index and val values, regardless of their actual values.\nOverall, the \\t escape sequence is useful for indenting text, but it may not always produce the results you expect if the text is not aligned\n" ]

[ 0, 0, 0 ]

[]

[]

[ "python" ]

[ "If you are using python 3.x, Please try this commands\n\nsudo pip3 install --upgrade pip\nsudo pip3 install virtualenv\n\n", "Run this command and try again\ncurl https://bootstrap.pypa.io/get-pip.py | python\n\nThe detailed description can be found in the link shared by Anupam in the comments.\n", "Please try below commands\npip install --upgrade virtualenv\n\n", "We tried the above but they didn't work in our case because we had two versions of python3 on the systems. One via a normal install a few months back and one via brew (on a Mac). When we discovered that, we downloaded and installed the latest version from python.org and as a result the pip was updated too. Once the pip was installed the sudo pip3 install virturaenv command worked fine. \n", "Try Below commands:\n\npip install --upgrade pip\n\n\npip install <'package-name'>\n\nexample: pip install locust_plugins\nTo check the list of packages installed, use below command:\n\npip list\n\nI tried the same and it worked for me\n", "It is sometimes because of connectivity issue. Re-running the same command when connectivity is okay solves it.\npip install virtualenv\n\nInitial Output:\nWARNING: Retrying (Retry(total=4, connect=None, read=None, redirect=None, status=None)) after connection broken by 'NewConnectionError('<pip._vendor.urllib3.connection.HTTPSConnection object at 0x0000023A91A94190>: Failed to establish a new connection: [Errno 11001] getaddrinfo failed')': /simple/virtualenv/\nWARNING: Retrying (Retry(total=3, connect=None, read=None, redirect=None, status=None)) after connection broken by 'NewConnectionError('<pip._vendor.urllib3.connection.HTTPSConnection object at 0x0000023A922B3390>: Failed to establish a new connection: [Errno 11001] getaddrinfo failed')': /simple/virtualenv/\nWARNING: Retrying (Retry(total=2, connect=None, read=None, redirect=None, status=None)) after connection broken by 'NewConnectionError('<pip._vendor.urllib3.connection.HTTPSConnection object at 0x0000023A922B0850>: Failed to establish a new connection: [Errno 11001] getaddrinfo failed')': /simple/virtualenv/\nWARNING: Retrying (Retry(total=1, connect=None, read=None, redirect=None, status=None)) after connection broken by 'NewConnectionError('<pip._vendor.urllib3.connection.HTTPSConnection object at 0x0000023A922C5990>: Failed to establish a new connection: [Errno 11001] getaddrinfo failed')': /simple/virtualenv/\nWARNING: Retrying (Retry(total=0, connect=None, read=None, redirect=None, status=None)) after connection broken by 'NewConnectionError('<pip._vendor.urllib3.connection.HTTPSConnection object at 0x0000023A922C64D0>: Failed to establish a new connection: [Errno 11001] getaddrinfo failed')': /simple/virtualenv/\nERROR: Could not find a version that satisfies the requirement virtualenv (from versions: none)\nERROR: No matching distribution found for virtualenv\nWARNING: There was an error checking the latest version of pip.\n\nOutput after re-run when connectivity is okay:\nCollecting virtualenv\n Using cached virtualenv-20.17.0-py3-none-any.whl (8.8 MB)\nWARNING: Retrying (Retry(total=4, connect=None, read=None, redirect=None, status=None)) after connection broken by 'ReadTimeoutError(\"HTTPSConnectionPool(host='pypi.org', port=443): Read timed out. (read timeout=15)\")': /simple/distlib/\nCollecting distlib<1,>=0.3.6\n Using cached distlib-0.3.6-py2.py3-none-any.whl (468 kB)\nCollecting filelock<4,>=3.4.1\n Using cached filelock-3.8.0-py3-none-any.whl (10 kB)\nCollecting platformdirs<3,>=2.4\n Using cached platformdirs-2.5.4-py3-none-any.whl (14 kB)\nInstalling collected packages: distlib, platformdirs, filelock, virtualenv\nSuccessfully installed distlib-0.3.6 filelock-3.8.0 platformdirs-2.5.4 virtualenv-20.17.0\n\n[notice] A new release of pip available: 22.3 -> 22.3.1\n[notice] To update, run: python.exe -m pip install --upgrade pip\n\n" ]

[ 15, 14, 13, 1, 0, 0 ]

[ "pip install --upgrade virtualenv\nThis solution works for me in Centos8\n", "If you are using Windows, you have to run cmd as admin.\n" ]

[ -1, -5 ]

[ "pip", "python", "virtualenv" ]

[ "The logic is unclear, but assuming you want the expanding average count of values, use:\ndf['mean'] = pd.Series(pd.factorize(df['Name'])[0], index=df.index)\n .expanding()\n .apply(lambda s: s.value_counts().mean())\n )\n\nOutput:\n Date Name mean\n0 2022-11-1 Tom 1.00\n1 2022-11-2 Mike 1.00\n2 2022-11-3 Paul 1.00\n3 2022-11-4 Pauline 1.00\n4 2022-11-5 Pauline 1.25\n5 2022-11-6 Mike 1.50\n6 2022-11-7 Tom 1.75\n7 2022-11-8 Louise 1.60\n8 2022-11-9 Tom 1.80\n9 2022-11-10 Mike 2.00\n10 2022-11-11 Paul 2.20\n11 2022-11-12 Pauline 2.40\n12 2022-11-13 Pauline 2.60\n13 2022-11-14 Mike 2.80\n14 2022-11-15 Tom 3.00\n15 2022-11-16 Louise 3.20\n\n" ]

[ 2 ]

[]

[]

[ "pandas", "python" ]

[ "I could run successfully following the steps:\n\nDownloaded sparkling water distribution zip: http://h2o-release.s3.amazonaws.com/sparkling-water/spark-3.1/3.36.1.1-1-3.1/index.html\nDependent JARs path: s3://bucket_name/sparkling-water-assembly-scoring_2.12-3.36.1.1-1-3.1-all.jar\n--additional-python-modules, h2o-pysparkling-3.1==3.36.1.1-1-3.1\n\n" ]

[ 0 ]

[]

[]

[ "apache_spark", "h2o", "python", "sparkling_water" ]

[ "Yes, you need to have the assignment within the exec statement:\n>>> def foo():\n... return 5\n...\n>>> exec(\"a = foo()\")\n>>> a\n5\n\nThis probably isn't relevant for your case since its being used in controlled testing, but be careful with using exec with user defined input. \n", "A few years later, but the following snippet helped me:\nthe_code = '''\na = 1\nb = 2\nreturn_me = a + b\n'''\n\nloc = {}\nexec(the_code, globals(), loc)\nreturn_workaround = loc['return_me']\nprint(return_workaround) # 3\n\nexec() doesn't return anything itself, but you can pass a dict which has all the local variables stored in it after execution. By accessing it you have a something like a return.\nI hope it helps someone.\n", "While this is the ugliest beast ever seen by mankind, this is how you can do it by using a global variable inside your exec call:\ndef my_exec(code):\n exec('global i; i = %s' % code)\n global i\n return i\n\nThis is misusing global variables to get your data across the border.\n>>> my_exec('1 + 2')\n3\n\nNeedless to say that you should never allow any user inputs for the input of this function in there, as it poses an extreme security risk.\n", "Something like this can work:\ndef outer():\n def inner(i):\n return i + 10\n\n\nfor f in outer.func_code.co_consts:\n if getattr(f, 'co_name', None) == 'inner':\n\n inner = type(outer)(f, globals())\n\n # can also use `types` module for readability:\n # inner = types.FunctionType(f, globals())\n\n print inner(42) # 52\n\nThe idea is to extract the code object from the inner function and create a new function based on it.\nAdditional work is required when an inner function can contain free variables. You'll have to extract them as well and pass to the function constructor in the last argument (closure).\n", "Here's a way to return a value from exec'd code:\ndef exec_and_return(expression):\n exec(f\"\"\"locals()['temp'] = {expression}\"\"\")\n return locals()['temp']\n\nI'd advise you to give an example of the problem you're trying to solve. Because I would only ever use this as a last resort.\n", "use eval() instead of exec(), it returns result\n", "This doesn't get the return value per say, but you can provide an empty dictionary when calling exec to retrieve any variables defined in the code.\n# Python 3\nex_locals = {}\nexec(\"a = 'Hello world!'\", None, ex_locals)\nprint(ex_locals['a'])\n# Output: Hello world!\n\nFrom the Python 3 documentation on exec:\n\nThe default locals act as described for function locals() below: modifications to the default locals dictionary should not be attempted. Pass an explicit locals dictionary if you need to see effects of the code on locals after function exec() returns.\n\nFor more information, see How does exec work with locals?\n", "Here's a solution with a simple code:\n# -*- coding: utf-8 -*-\nimport math\n\nx = [0]\nexec(\"x[0] = 3*2\")\nprint(x[0]) # 6\n\n", "Since Python 3.7, dictionary are ordered. So you no longer need to agree on a name, you can just say \"last item that got created\":\n>>> d = {}\n>>> exec(\"def addone(i): return i + 1\", d, d)\n>>> list(d)\n['__builtins__', 'addone']\n>>> thefunction = d[list(d)[-1]]\n>>> thefunction\n<function addone at 0x7fd03123fe50>\n\n" ]

[ 37, 29, 10, 4, 3, 3, 2, 0, 0 ]

[ "if we need a function that is in a file in another directory, eg\nwe need the function1 in file my_py_file.py \nlocated in /home/.../another_directory\n\nwe can use the following code:\n\n\ndef cl_import_function(a_func,py_file,in_Dir): \n... import sys\n... sys.path.insert(0, in_Dir)\n... ax='from %s import %s'%(py_file,a_func)\n... loc={}\n... exec(ax, globals(), loc)\n... getFx = loc[afunc]\n... return getFx\n\ntest = cl_import_function('function1',r'my_py_file',r'/home/.../another_directory/')\ntest()\n\n(a simple way for newbies...)\n", "program = 'a = 5\\nb=10\\nprint(\"Sum =\", a+b)'\nprogram = exec(program)\nprint(program)\n" ]

[ -1, -1 ]

[ "exec", "function", "python", "return" ]

[ "\nhave written the code in python but will be deploying it to a\nmicrocotroller so I want to create it in C.\n\nThere exist MicroPython\n\nMicroPython is a lean and efficient implementation of the Python 3\nprogramming language that includes a small subset of the Python\nstandard library and is optimised to run on microcontrollers and in\nconstrained environments.\n\nand there exist numpy subset for above in form of micropython-numpy, if you manage to make it run at your microcotroller then conversion to C becomes no longer required.\n", "This is some code for the linearly spaced array:\n#include <stdlib.h>\n#include <stdio.h>\n#include <math.h>\n\n// ...\n\nint sampleRate = 1000;\nint center_freq = 20;\nint cutoff_freq = 10;\n\nfloat signal_1[1000];\nfloat signal_2[1000];\n\nfloat value = 0.0f;\nfloat inc = (2.0f * M_PI * (float)center_freq) / (float)sampleRate;\n\nfor(int i = 0; i < sampleRate; ++i)\n{\n signal_1[i] = (float)cos(value);\n value += inc;\n}\n\nfor(int i = 0; i < sampleRate; ++i)\n{\n signal_2[i] = (float)rand() / (float)RAND_MAX;\n}\n\n" ]

[ 0, 0 ]

[]

[]

[ "arduino", "c", "python" ]

[ "Here is one way to do it with product from Python standard library's itertool module:\nfrom itertools import product\n\nimport pandas as pd\n\n\naxis = [\"X\", \"Y\", \"Z\"]\n\ndf = (\n pd.concat(\n [\n df,\n pd.DataFrame(\n product(df[\"X\"].unique(), repeat=df[\"X\"].nunique()),\n columns=axis,\n ),\n ]\n )\n .drop_duplicates(subset=axis, keep=\"first\")\n .sort_values(axis, ignore_index=True)\n)\n\nThen:\nprint(df)\n# Output\n X Y Z t\n0 1 1 1 0.994531\n1 1 1 2 NaN\n2 1 1 3 NaN\n3 1 2 1 NaN\n4 1 2 2 NaN\n5 1 2 3 NaN\n6 1 3 1 NaN\n7 1 3 2 0.937584\n8 1 3 3 NaN\n9 2 1 1 NaN\n10 2 1 2 0.168245\n11 2 1 3 NaN\n12 2 2 1 NaN\n13 2 2 2 0.362854\n14 2 2 3 NaN\n15 2 3 1 NaN\n16 2 3 2 NaN\n17 2 3 3 NaN\n18 3 1 1 NaN\n19 3 1 2 NaN\n20 3 1 3 NaN\n21 3 2 1 0.634389\n22 3 2 2 NaN\n23 3 2 3 NaN\n24 3 3 1 0.953114\n25 3 3 2 NaN\n26 3 3 3 NaN\n\n" ]

[ 1 ]

[]

[]

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

[ "def my_func():\n \"\"\"Docstring goes here.\"\"\"\n print my_func.__doc__\n\nThis will work as long as you don't change the object bound to the name my_func. \nnew_func_name = my_func\nmy_func = None\n\nnew_func_name()\n# doesn't print anything because my_func is None and None has no docstring\n\nSituations in which you'd do this are rather rare, but they do happen.\nHowever, if you write a decorator like this:\ndef passmein(func):\n def wrapper(*args, **kwargs):\n return func(func, *args, **kwargs)\n return wrapper\n\nNow you can do this:\n@passmein\ndef my_func(me):\n print me.__doc__\n\nAnd this will ensure that your function gets a reference to itself (similar to self) as its first argument, so it can always get the docstring of the right function. If used on a method, the usual self becomes the second argument.\n", "This should work (in my tests it does, also included output). You could probably use __doc__ instead of getdoc, but I like it, so thats just what i used. Also, this doesn't require you to know the names of the class/method/function.\nExamples both for a class, a method and a function. Tell me if it's not what you were looking for :)\nfrom inspect import *\n\nclass MySelfExplaningClass:\n \"\"\"This is my class document string\"\"\"\n\n def __init__(self):\n print getdoc(self)\n\n def my_selfexplaining_method(self):\n \"\"\"This is my method document string\"\"\"\n print getdoc(getattr(self, getframeinfo(currentframe()).function))\n\n\nexplain = MySelfExplaningClass()\n\n# Output: This is my class document string\n\nexplain.my_selfexplaining_method()\n\n# Output: This is my method document string\n\ndef my_selfexplaining_function():\n \"\"\"This is my function document string\"\"\"\n print getdoc(globals()[getframeinfo(currentframe()).function])\n\nmy_selfexplaining_function()\n\n# Output: This is my function document string\n\n", "This works:\ndef my_function():\n \"\"\"Docstring for my function\"\"\"\n #print the Docstring here.\n print my_function.__doc__\n\nmy_function()\n\nin Python 2.7.1\nThis also works:\nclass MyClass(object):\n def my_function(self):\n \"\"\"Docstring for my function\"\"\"\n #print the Docstring here, either way works.\n print MyClass.my_function.__doc__\n print self.my_function.__doc__\n\n\nfoo = MyClass()\n\nfoo.my_function()\n\nThis however, will not work on its own:\nclass MyClass(object):\n def my_function(self):\n \"\"\"Docstring for my function\"\"\"\n #print the Docstring here.\n print my_function.__doc__\n\n\nfoo = MyClass()\n\nfoo.my_function()\n\nNameError: global name 'my_function' is not defined\n", "There's quite a simple method for doing this that nobody has mentioned yet:\nimport inspect\n\ndef func():\n \"\"\"Doc string\"\"\"\n print inspect.getdoc(func)\n\nAnd this does what you want.\nThere's nothing fancy going on here. All that's happening is that by doing func.__doc__ in a function defers attribute resolution long enough to have looking up __doc__ on it work as you'd expect.\nI use this with docopt for console script entry points.\n", "You've posed your question like a class method rather than a function. Namespaces are important here. For a function, print my_function.__doc__ is fine, as my_function is in the global namespace.\nFor a class method, then print self.my_method.__doc__ would be the way to go.\nIf you don't want to specify the name of the method, but rather pass a variable to it, you can use the built-in functions hasattr(object,attribute) and getattr(obj,attr), which do as they say, allowing you to pass variables in with strings being the name of a method. e.g.\nclass MyClass:\n def fn(self):\n \"\"\"A docstring\"\"\"\n print self.fn.__doc__ \n\ndef print_docstrings(object):\n for method in dir( object ):\n if method[:2] == '__': # A protected function\n continue\n meth = getattr( object, method )\n if hasattr( meth , '__doc__' ):\n print getattr( meth , '__doc__' )\n\nx = MyClass()\nprint_docstrings( x )\n\n", "As noted many times, using the function name is a dynamic lookup in the globals() directory. It only works in the module of the definition and only for a global function. If you want to find out the doc string of a member function, you would need to also lookup the path from the class name - which is quite cumbersome as these names can get quite long:\ndef foo():\n \"\"\" this is foo \"\"\"\n doc = foo.__doc__\nclass Foo:\n def bar(self):\n \"\"\" this is bar \"\"\"\n doc = Foo.bar.__doc__\n\nis equivalent to\ndef foo():\n \"\"\" this is foo \"\"\"\n doc = globals()[\"foo\"].__doc__\nclass Foo:\n def bar(self):\n \"\"\" this is bar \"\"\"\n doc = globals()[\"Foo\"].bar.__doc__\n\nIf you want to look up the doc string of the caller, that won't work anyway as your print-helper might live in a completely different module with a completely different globals() dictionary. The only correct choice is to look into the stack frame - but Python does not give you the function object being executed, it only has a reference to the \"f_code\" code object. But keep going, as there is also a reference to the \"f_globals\" of that function. So you can write a function to get the caller's doc like this, and as a variation from it, you get your own doc string.\nimport inspect\n\ndef get_caller_doc():\n frame = inspect.currentframe().f_back.f_back\n for objref in frame.f_globals.values():\n if inspect.isfunction(objref):\n if objref.func_code == frame.f_code:\n return objref.__doc__\n elif inspect.isclass(objref):\n for name, member in inspect.getmembers(objref):\n if inspect.ismethod(member):\n if member.im_func.func_code == frame.f_code:\n return member.__doc__\n\nand let's go to test it:\ndef print_doc():\n print get_caller_doc()\n\ndef foo():\n \"\"\" this is foo \"\"\"\n print_doc()\n\nclass Foo:\n def bar(self):\n \"\"\" this is bar \"\"\"\n print_doc()\n\ndef nothing():\n print_doc()\n\nclass Nothing:\n def nothing(self):\n print_doc()\n\nfoo()\nFoo().bar()\n\nnothing()\nNothing().nothing()\n\n# and my doc\n\ndef get_my_doc():\n return get_caller_doc()\n\ndef print_my_doc():\n \"\"\" showing my doc \"\"\"\n print get_my_doc()\n\nprint_my_doc()\n\nresults in this output\n this is foo \n this is bar \nNone\nNone\n showing my doc \n\nActually, most people want their own doc string only to hand it down as an argument, but the called helper function can look it up all on its own. I'm using this in my unittest code where this is sometimes handy to fill some logs or to use the doc string as test data. That's the reason why the presented get_caller_doc() only looks for global test functions and member functions of a test class, but I guess that is enough for most people who want to find out about the doc string. \nclass FooTest(TestCase):\n def get_caller_doc(self):\n # as seen above\n def test_extra_stuff(self):\n \"\"\" testing extra stuff \"\"\"\n self.createProject(\"A\")\n def createProject(self, name):\n description = self.get_caller_doc()\n self.server.createProject(name, description)\n\nTo define a proper get_frame_doc(frame) with sys._getframe(1) is left to the reader().\n", "Try: \nclass MyClass():\n # ...\n def my_function(self):\n \"\"\"Docstring for my function\"\"\"\n print MyClass.my_function.__doc__\n # ...\n\n(*) There was a colon (:) missing after my_function()\n", "If you're using Test class to make sure that doc string will appear in each test, then the efficient approach would be this.\n\n\n def setup_method(self, method):\n print(getattr(self, method.__name__).__doc__)\n \n \n\n\r\n\nThis will print doc string of each method before it gets executed or you can past the same script on teardown_method to print it in the end of each test case.\n" ]

[ 89, 10, 6, 6, 2, 2, 1, 0 ]

[ "inserting \nprint __doc__\njust after the class declaration,, before the def __init__, will print the doc string to the console every time you initiate an object with the class\n" ]

[ -1 ]

[ "docstring", "function", "printing", "python" ]

[ "For the record: this was the Advent of Code 2022 Day 3 Part 2 challenge. I kept my data in a file called input.txt and just read line by line, but this solution can be applied to a string too.\nI turned converted every line into a set and used the & intersection operator. From there, I converted it to a list and removed the new line character. s[0] is therefore the only repeated character. Like this:\nwith open('input.txt') as f:\n lines = f.readlines()\n for i in range(0, len(lines), 3):\n s = list(set(lines[i]) & set(lines[i + 1]) & set(lines[i + 2]))\n s.remove('\\n')\n print(s[0])\n\nHere's an example using your data string. In this case, I'd split by the new line character and no longer need to remove it from the list. I'd also extract the element from the set without converting to a list:\ndata = \"\"\"vJrwpWtwJgWrhcsFMMfFFhFp\njqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL\nPmmdzqPrVvPwwTWBwg\nwMqvLMZHhHMvwLHjbvcjnnSBnvTQFn\nttgJtRGJQctTZtZT\nCrZsJsPPZsGzwwsLwLmpwMDw\"\"\"\n\n\nlines = data.split('\\n')\nfor i in range(0, len(lines), 3):\n (ch,) = set(lines[i]) & set(lines[i + 1]) & set(lines[i + 2])\n print(ch)\n\n", "If I understand your question correctly:\nJust solved it this morning coincidently. ;-)\n# ordering = ascii_lowercase + ascii_uppercase\n\n# with open('day03.in') as fin:\n# data = fin.read().strip()\n \n# b = 0\nlines = data.split('\\n') # assuming some date- read-in already\n\n# go through 3 chunks:\nfor i in range(0, len(lines), 3):\n chunk = lines[i: i+3]\n print(chunk)\n \n #for i, c in enumerate(ordering):\n # if all(c in ll for ll in chunk):\n #b += ordering.index(c) + 1 # answer.\n\n" ]

[ 1, 1 ]

[]

[]

[ "python", "python_3.x" ]

[ "There are many ways to do this shorter. For example, you can use the Counter class (in Python 2.7 or later):\nimport collections\ns = \"helloworld\"\nprint(collections.Counter(s).most_common(1)[0])\n\nIf you don't have that, you can do the tally manually (2.5 or later has defaultdict):\nd = collections.defaultdict(int)\nfor c in s:\n d[c] += 1\nprint(sorted(d.items(), key=lambda x: x[1], reverse=True)[0])\n\nHaving said that, there's nothing too terribly wrong with your implementation.\n", "If you are using Python 2.7, you can quickly do this by using collections module.\ncollections is a hight performance data structures module. Read more at\nhttp://docs.python.org/library/collections.html#counter-objects\n>>> from collections import Counter\n>>> x = Counter(\"balloon\")\n>>> x\nCounter({'o': 2, 'a': 1, 'b': 1, 'l': 2, 'n': 1})\n>>> x['o']\n2\n\n", "Here is way to find the most common character using a dictionary\nmessage = \"hello world\"\nd = {}\nletters = set(message)\nfor l in letters:\n d[message.count(l)] = l\n\nprint d[d.keys()[-1]], d.keys()[-1]\n\n", "Here's a way using FOR LOOP AND COUNT()\nw = input()\nr = 1\nfor i in w:\n p = w.count(i)\n if p > r:\n r = p\n s = i\nprint(s)\n\n", "The way I did uses no built-in functions from Python itself, only for-loops and if-statements.\ndef most_common_letter():\n string = str(input())\n letters = set(string)\n if \" \" in letters: # If you want to count spaces too, ignore this if-statement\n letters.remove(\" \")\n max_count = 0\n freq_letter = []\n for letter in letters:\n count = 0\n for char in string:\n if char == letter:\n count += 1\n if count == max_count:\n max_count = count\n freq_letter.append(letter)\n if count > max_count:\n max_count = count\n freq_letter.clear()\n freq_letter.append(letter)\n return freq_letter, max_count\n\nThis ensures you get every letter/character that gets used the most, and not just one. It also returns how often it occurs. Hope this helps :)\n", "If you want to have all the characters with the maximum number of counts, then you can do a variation on one of the two ideas proposed so far:\nimport heapq # Helps finding the n largest counts\nimport collections\n\ndef find_max_counts(sequence):\n \"\"\"\n Returns an iterator that produces the (element, count)s with the\n highest number of occurrences in the given sequence.\n\n In addition, the elements are sorted.\n \"\"\"\n\n if len(sequence) == 0:\n raise StopIteration\n\n counter = collections.defaultdict(int)\n for elmt in sequence:\n counter[elmt] += 1\n\n counts_heap = [\n (-count, elmt) # The largest elmt counts are the smallest elmts\n for (elmt, count) in counter.iteritems()]\n\n heapq.heapify(counts_heap)\n\n highest_count = counts_heap[0][0]\n\n while True:\n\n try:\n (opp_count, elmt) = heapq.heappop(counts_heap)\n except IndexError:\n raise StopIteration\n\n if opp_count != highest_count:\n raise StopIteration\n\n yield (elmt, -opp_count)\n\nfor (letter, count) in find_max_counts('balloon'):\n print (letter, count)\n\nfor (word, count) in find_max_counts(['he', 'lkj', 'he', 'll', 'll']):\n print (word, count)\n\nThis yields, for instance:\nlebigot@weinberg /tmp % python count.py\n('l', 2)\n('o', 2)\n('he', 2)\n('ll', 2)\n\nThis works with any sequence: words, but also ['hello', 'hello', 'bonjour'], for instance.\nThe heapq structure is very efficient at finding the smallest elements of a sequence without sorting it completely. On the other hand, since there are not so many letter in the alphabet, you can probably also run through the sorted list of counts until the maximum count is not found anymore, without this incurring any serious speed loss.\n", "def most_frequent(text):\n frequencies = [(c, text.count(c)) for c in set(text)]\n return max(frequencies, key=lambda x: x[1])[0]\n\ns = 'ABBCCCDDDD'\nprint(most_frequent(s))\n\nfrequencies is a list of tuples that count the characters as (character, count). We apply max to the tuples using count's and return that tuple's character. In the event of a tie, this solution will pick only one.\n", "Question :\nMost frequent character in a string\nThe maximum occurring character in an input string\nMethod 1 :\na = \"GiniGinaProtijayi\"\n\nd ={}\nchh = ''\nmax = 0 \nfor ch in a : d[ch] = d.get(ch,0) +1 \nfor val in sorted(d.items(),reverse=True , key = lambda ch : ch[1]):\n chh = ch\n max = d.get(ch)\n \n \nprint(chh) \nprint(max) \n\nMethod 2 :\na = \"GiniGinaProtijayi\"\n\nmax = 0 \nchh = ''\ncount = [0] * 256 \nfor ch in a : count[ord(ch)] += 1\nfor ch in a :\n if(count[ord(ch)] > max):\n max = count[ord(ch)] \n chh = ch\n \nprint(chh) \n\nMethod 3 :\n import collections\n \n line ='North Calcutta Shyambazaar Soudipta Tabu Roopa Roopi Gina Gini Protijayi Sovabazaar Paikpara Baghbazaar Roopa'\n \nbb = collections.Counter(line).most_common(1)[0][0]\nprint(bb)\n\nMethod 4 :\nline =' North Calcutta Shyambazaar Soudipta Tabu Roopa Roopi Gina Gini Protijayi Sovabazaar Paikpara Baghbazaar Roopa'\n\n\ndef mostcommonletter(sentence):\n letters = list(sentence)\n return (max(set(letters),key = letters.count))\n\n\nprint(mostcommonletter(line)) \n\n \n\n", "I noticed that most of the answers only come back with one item even if there is an equal amount of characters most commonly used. For example \"iii 444 yyy 999\". There are an equal amount of spaces, i's, 4's, y's, and 9's. The solution should come back with everything, not just the letter i:\nsentence = \"iii 444 yyy 999\"\n\n# Returns the first items value in the list of tuples (i.e) the largest number\n# from Counter().most_common()\nlargest_count: int = Counter(sentence).most_common()[0][1]\n\n# If the tuples value is equal to the largest value, append it to the list\nmost_common_list: list = [(x, y)\n for x, y in Counter(sentence).items() if y == largest_count]\n\nprint(most_common_count)\n\n# RETURNS\n[('i', 3), (' ', 3), ('4', 3), ('y', 3), ('9', 3)]\n\n", "Here are a few things I'd do:\n\nUse collections.defaultdict instead of the dict you initialise manually.\nUse inbuilt sorting and max functions like max instead of working it out yourself - it's easier.\n\nHere's my final result:\nfrom collections import defaultdict\n\ndef find_max_letter_count(word):\n matches = defaultdict(int) # makes the default value 0\n\n for char in word:\n matches[char] += 1\n\n return max(matches.iteritems(), key=lambda x: x[1])\n\nfind_max_letter_count('helloworld') == ('l', 3)\n\n", "If you could not use collections for any reason, I would suggest the following implementation:\ns = input()\nd = {}\n\n# We iterate through a string and if we find the element, that\n# is already in the dict, than we are just incrementing its counter.\nfor ch in s:\n if ch in d:\n d[ch] += 1\n else:\n d[ch] = 1\n\n# If there is a case, that we are given empty string, then we just\n# print a message, which says about it.\nprint(max(d, key=d.get, default='Empty string was given.'))\n\n", "sentence = \"This is a great question made me wanna watch matrix again!\"\n\nchar_frequency = {}\n\nfor char in sentence:\n if char == \" \": #to skip spaces\n continue\n elif char in char_frequency:\n char_frequency[char] += 1 \n else:\n char_frequency[char] = 1\n\n\nchar_frequency_sorted = sorted(\n char_frequency.items(), key=lambda ky: ky[1], reverse=True\n)\nprint(char_frequency_sorted[0]) #output -->('a', 9)\n\n", "# return the letter with the max frequency.\n\ndef maxletter(word:str) -> tuple:\n ''' return the letter with the max occurance '''\n v = 1\n dic = {}\n for letter in word:\n if letter in dic:\n dic[letter] += 1\n else:\n dic[letter] = v\n\n for k in dic:\n if dic[k] == max(dic.values()):\n return k, dic[k]\n\nl, n = maxletter(\"Hello World\")\nprint(l, n)\n\noutput: l 3\n", "you may also try something below.\nfrom pprint import pprint \n sentence = \"this is a common interview question\" \n \n char_frequency = {} \n for char in sentence: \n if char in char_frequency: \n char_frequency[char] += 1 \n else: \n char_frequency[char] = 1 \n pprint(char_frequency, width = 1) \n out = sorted(char_frequency.items(), \n key = lambda kv : kv[1], reverse = True) \n print(out) \n print(out[0]) \n\n", "statistics.mode(data)\nReturn the single most common data point from discrete or nominal data. The mode (when it exists) is the most typical value and serves as a measure of central location.\nIf there are multiple modes with the same frequency, returns the first one encountered in the data. If the smallest or largest of those is desired instead, use min(multimode(data)) or max(multimode(data)). If the input data is empty, StatisticsError is raised.\nimport statistics as stat\n\ntest = 'This is a test of the fantastic mode super special function ssssssssssssss'\ntest2 = ['block', 'cheese', 'block']\nval = stat.mode(test)\nval2 = stat.mode(test2)\nprint(val, val2)\n\nmode assumes discrete data and returns a single value. This is the standard treatment of the mode as commonly taught in schools:\n\n\n\n\n\n\nmode([1, 1, 2, 3, 3, 3, 3, 4])\n3\nThe mode is unique in that it is the only statistic in this package that also applies to nominal (non-numeric) data:\n\n\n\n\n\n\nmode([\"red\", \"blue\", \"blue\", \"red\", \"green\", \"red\", \"red\"])\n'red'\n" ]

[ 36, 5, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0 ]

[ "#file:filename\n#quant:no of frequent words you want\n\ndef frequent_letters(file,quant):\n file = open(file)\n file = file.read()\n cnt = Counter\n op = cnt(file).most_common(quant)\n return op \n\n", "# This code is to print all characters in a string which have highest frequency\n \ndef find(str):\n \n y = sorted([[a.count(i),i] for i in set(str)])\n # here,the count of unique character and the character are taken as a list \n # inside y(which is a list). And they are sorted according to the \n # count of each character in the list y. (ascending)\n # Eg : for \"pradeep\", y = [[1,'r'],[1,'a'],[1,'d'],[2,'p'],[2,'e']]\n\n most_freq= y[len(y)-1][0] \n # the count of the most freq character is assigned to the variable 'r'\n # ie, most_freq= 2\n\n x= []\n\n for j in range(len(y)):\n \n if y[j][0] == most_freq:\n x.append(y[j])\n # if the 1st element in the list of list == most frequent \n # character's count, then all the characters which have the \n # highest frequency will be appended to list x.\n # eg :\"pradeep\"\n # x = [['p',2],['e',2]] O/P as expected\n return x\n\nfind(\"pradeep\")\n\n" ]

[ -1, -1 ]

[ "algorithm", "optimization", "python", "time_complexity" ]

[ "The images are diagonal because you calculate the y-coordinate depending on the ino_number, so that the y-coordinate increases with increasing ino_number. The y-coordinate must be the same for all objects. Only the coordinated x must increase with the number ino_number:\ndef create_army(screen, inos):\n # [...]\n\n for row_number in range(number_ino_y - 1):\n for ino_number in range(number_ino_x):\n ino = Ino(screen)\n ino.x = ino_width + (ino_width * ino_number)\n ino.y = ino_height\n ino.rect.x = ino.x\n ino.rect.y = ino.y\n inos.add(ino)\n\n" ]

[ 0 ]

[]

[]

[ "pygame", "python" ]

[ "Well it took me 3 days and A LOT of searching, trial and error but ive been able to get the desired result. It may not be the most efficient but it's a start.\nIve created a new function to create the subplots setup() I call that initially when the program opens. Then in the clear() function I am able to forget the canvas widget, reset the variables and call the setup() function again. Now when I click graph() function it creates a new graph.\nimport tkinter as tk\nfrom tkinter import *\nimport matplotlib.pyplot as plt\nfrom matplotlib.backends.backend_tkagg import FigureCanvasTkAgg\nimport matplotlib.animation as animation\nimport serial\nimport datetime\n\nroot = tk.Tk()\nroot.state('zoomed')\nwidth, height = root.winfo_screenwidth(), root.winfo_screenheight()\nroot.geometry('%dx%d+0+0' % (width, height))\nroot.configure(background='white')\nroot.title(\"CMJ\")\n\ntimes = []\ndata = []\n\n\ndef setup():\n global fig, ax\n fig, ax = plt.subplots()\n ax.set_ylim(0, 40)\n plt.xticks(rotation=45, ha='right')\n\ndef animate(i):\n ser = serial.Serial('/dev/cu.usbserial-1420', 115200, timeout=1)\n for i in range(20):\n raw = ser.readline()\n dec = raw.decode()\n strline = dec.split(\" \")\n lines = float(strline[0])\n now = datetime.datetime.now()\n now1 = now.strftime('%M:%S.%f')\n now = now1[:-5]\n data.append(lines)\n times.append(now)\n ser.close()\n line, = ax.plot(times, data, label=\"Force\", color=\"blue\")\n line.set_ydata(data)\n x = max(data)\n most.configure(text=x)\n print(times, data)\n return line,\n graph()\n\ndef graph():\n global canvas\n graphframe.pack(pady=20)\n canvas = FigureCanvasTkAgg(fig, master=graphframe)\n canvas.get_tk_widget().pack()\n ani = animation.FuncAnimation(fig, animate, frames=19, repeat=FALSE, interval=20, cache_frame_data=TRUE)\n canvas.draw()\n\ndef clear():\n global times, data\n times = []\n data = []\n canvas.get_tk_widget().forget()\n setup()\n\n\nbuttonframe = Frame(root)\nbuttonframe.pack()\ngraphframe = Frame(root)\ngraphframe.pack()\nbutton = tk.Button(buttonframe, text='graph', command=graph, width=15)\nbutton.pack()\nbutton2 = tk.Button(buttonframe, text='clear', command=clear, width=15)\nbutton2.pack()\nmost = tk.Label(buttonframe, text=\"0\")\nmost.pack()\n\nsetup()\n\nroot.mainloop()\n\nIf you notice any thing I am overlooking, anything that is unnecessary or overkill please let me know.\nThank you for your time, hope this helps if you arr encountering something similar.\n" ]

[ 0 ]

[]

[]

[ "arduino", "matplotlib", "python", "tkinter" ]

[ "You can use either\nprint(\"\\\\'/\") \n\nor \nprint(r\"\\'/\")\n\nThe escape character in Python is \\ and the option of r before the string represent the string as literals without the need of escape chars. \n", "Is this what you're looking for?\nprint(\"\\\\\\'/\")\n", ">>> print(r\"\\'/\")\n\\'/\n\n" ]

[ 2, 2, 2 ]

[ "The Best way to do this is to Add a Front Slash() and then inverted commas.\nprint('a'')\na='That's a Sample Case'\nprint(a)\n" ]

[ -1 ]

[ "python" ]

[ "use\nnp.asarray(img_00)\n\nyour image needs 3 channels: (width, height,colorchannels)\n", "A small example that displays a similar error\nIn [72]: alist = [np.ones((3,3,3)), np.zeros((3,3))]\n\nIn [73]: np.array(alist)\nC:\\Users\\paul\\AppData\\Local\\Temp\\ipykernel_7196\\2629805649.py:1: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n np.array(alist)\n---------------------------------------------------------------------------\nValueError Traceback (most recent call last)\nInput In [73], in <cell line: 1>()\n----> 1 np.array(alist)\n\nValueError: could not broadcast input array from shape (3,3,3) into shape (3,3)\n\n" ]

[ 1, 0 ]

[]

[]

[ "numpy", "python", "tensorflow" ]

[ "Instead of sample your file I would recommend you working with the entire file using cloud competing.\nYou can create a free account in AWS or AZURE using those links\nhttps://aws.amazon.com/pt/free \nhttps://azure.microsoft.com/pt-br/free/\nI would suggest you use AZURE because you will receive 200 dollars and will have more flexibility to use as you want.\nAfter create you account you can create a powerful virtual machine with enough memory to read your entire file.\nYou can check the link bellow to see how to use Azure azure-machine-learning to create your VM:\nhttps://github.com/maxreis86/FIEP-Machine-Learning-e-Computacao-em-Nuvem#azure-machine-learning\n" ]

[ 0 ]

[]

[]

[ "deserialization", "machine_learning", "pickle", "python" ]

[ "The difference between the two answers you cite is because of how the script is used.\nIn the negative answer, the python script was listed directly as the PAM module. This will not work. PAM modules need to be shared objects, e.g. binary compiled code. The are directly linked into the running process that is uses PAM as needed. A Python script isn't compiled code.\nIn the positive answer, the PAM module used is pam_exec. pam_exec is a shared object:\n/usr/lib64/security/pam_exec.so: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, BuildID[sha1]=d0c1dbb05c0689e3645193b45d3125d3b27b32ce, stripped\n\npam_exec then runs a program, which CAN be a Python script. Because it runs a program rather than dynamically linking to an shared object, it doesn't have the same limitation. This is the whole point of pam_exec really.\nSo yes, you can use Python, but you must pam_exec the script. Do be aware of this note from pam_exec, it's important:\n\nCommands called by pam_exec need to be aware of that the user can have control over the environment.\n\n", "You can use the pam-python library, which provides bindings and helper functions for working with PAM in Python.\nOnce your PAM module is written and compiled, you can configure it to be used by the PAM system by modifying the appropriate PAM configuration file. For example, if you want to use your PAM module for password authentication, you would add it to the\n/etc/pam.d/common-password file.\n" ]

[ 1, 0 ]

[]

[]

[ "linux", "python" ]

[ "You can style the text inside each bar through insidetextfont:\nfig1.update_traces(insidetextfont=dict(color='white', size=16,family='Times New Roman'))\n\n\n" ]

[ 0 ]

[]

[]

[ "plotly", "python" ]

[ "All the find_element_by_* and find_elements_by_* methods are deprecated in current Selenium versions. You need to use driver.find_element(By.CLASS_NAME, \" \"), driver.find_element(By.XPATH, \" \") etc. methods.\n" ]

[ 0 ]

[]

[]

[ "attributeerror", "automation", "bots", "python", "selenium" ]

[ "In the first line of your while:\nrain.append(rainfall)\n\nat this point since you didn't reassign it rainfall is still the value that you set it to earlier:\nrainfall = 0\n\nand your while runs for the numbers\n1, 2, 3, 4, 5, 6, 7\n\nsince those are the integers < 8\n", "This is the correct version for your aim.\nrain = []\ncounter = 1\n\nwhile counter <= 7:\n rainfall = float(input(\"Enter the rainfall of day {0}: \".format(counter)))\n rain.append(rainfall)\n counter += 1\nprint(rain)\n\nYou were passing default parameter you created for rainfall.\nNo need to set default rainfall.\n" ]

[ 1, 1 ]

[]

[]

[ "list", "python" ]

[ "As @DeepSpace said, list.pop will\n\nRemove the item at the given position in the list, and return it. If no index is specified, a.pop() removes and returns the last item in the list.\n\nSo basically, the solution to your problem would be to replace last_odd = numbers[num] with last_odd = num.\n", "list.pop() receive index as argument and remove the value. So, last_odd should be assigned to num instead of numbers[num]\nYour function doesn't have return value yet. It should return numbers list.\ndef remove_last_odd(numbers):\n for num in range(len(numbers)):\n if numbers[num] % 2 == 1:\n last_odd = num\n numbers.pop(last_odd)\n return numbers\n\nnumbers = [1, 7, 2, 34, 8, 7, 2, 5, 14, 22, 93, 48, 76, 15, 6]\nprint(remove_last_odd(numbers))\n\n# [1, 7, 2, 34, 8, 7, 2, 5, 14, 22, 93, 48, 76, 6]\n\nOr iterating numbers value and using remove() method instead of pop():\ndef remove_last_odd(numbers):\n for num in numbers:\n if num % 2: last_odd = num\n numbers.remove(last_odd)\n return numbers\n\nnumbers = [1, 7, 2, 34, 8, 7, 2, 5, 14, 22, 93, 48, 76, 15, 6]\nprint(remove_last_odd(numbers))\n\n# [1, 7, 2, 34, 8, 7, 2, 5, 14, 22, 93, 48, 76, 6]\n\n", "No need to reverse the list but you can search it in reverse.\ndef remove_last_odd(numbers):\n for i in range(len(numbers)-1, -1, -1):\n if numbers[i] & 1:\n numbers.pop(i)\n break\n\nnumbers = [1, 7, 2, 34, 8, 7, 2, 5, 14, 22, 93, 48, 76, 15, 6]\n\nremove_last_odd(numbers)\n\nprint(numbers)\n\nOutput:\n[1, 7, 2, 34, 8, 7, 2, 5, 14, 22, 93, 48, 76, 6]\n\nOption:\nIf you insist on a 'forward' search then:\ndef remove_last_odd(numbers):\n ri = -1\n for i, v in enumerate(numbers):\n if v & 1:\n ri = i\n if ri >= 0:\n numbers.pop(ri)\n\n", "To get the index of the last odd element you can use the reversed() iterator which will not reverse the original list object.\nA quick way to get the index is:\n >>> numbers = [1, 7, 2, 34, 8, 7, 2, 5, 14, 22, 93, 48, 76, 15, 6]\n >>> -next(filter(lambda v: v[1]%2==1, enumerate(reversed(numbers))))[0] \n -1\n\nEven for very large lists with a lot of even numbers at the end the result will be delivered quite quick (compared with the proposed code):\n >>> from timeit import timeit\n >>> def find_last_odd(numbers):\n for num in range(len(numbers)):\n if numbers[num] % 2 == 1:\n last_odd = num\n return last_odd\n >>> numbers2=numbers+([2]*10000) # create a list with 10000 even numbers at the end!\n >>> timeit(lambda: find_last_odd(numbers2),number=100)\n 0.5675344999999936\n >>> timeit.timeit(lambda: -next(filter(lambda v: v[1]%2==1, enumerate(reversed(numbers2)))).__getitem__(0),number=100)\n 0.10892959999998197\n \n\n", "Remove the item at the given position in the list, and return it. If no index is specified, a.pop() removes and returns the last item in the list.\nSo basically, the solution to your problem would be to replace last_odd = numbers[num] with last_odd = num.\n" ]

[ 0, 0, 0, 0, 0 ]

[]

[]

[ "iteration", "python" ]

[ "The problem you face is that you try to assign the return of imshow (which is an matplotlib.image.AxesImage to an existing axes object. \nThe correct way of plotting image data to the different axes in axarr would be\nf, axarr = plt.subplots(2,2)\naxarr[0,0].imshow(image_datas[0])\naxarr[0,1].imshow(image_datas[1])\naxarr[1,0].imshow(image_datas[2])\naxarr[1,1].imshow(image_datas[3])\n\nThe concept is the same for all subplots, and in most cases the axes instance provide the same methods than the pyplot (plt) interface. \nE.g. if ax is one of your subplot axes, for plotting a normal line plot you'd use ax.plot(..) instead of plt.plot(). This can actually be found exactly in the source from the page you link to. \n", "One thing that I found quite helpful to use to print all images :\n_, axs = plt.subplots(n_row, n_col, figsize=(12, 12))\naxs = axs.flatten()\nfor img, ax in zip(imgs, axs):\n ax.imshow(img)\nplt.show()\n\n", "You are plotting all your images on one axis. What you want ist to get a handle for each axis individually and plot your images there. Like so:\nfig = plt.figure()\nax1 = fig.add_subplot(2,2,1)\nax1.imshow(...)\nax2 = fig.add_subplot(2,2,2)\nax2.imshow(...)\nax3 = fig.add_subplot(2,2,3)\nax3.imshow(...)\nax4 = fig.add_subplot(2,2,4)\nax4.imshow(...)\n\nFor more info have a look here: http://matplotlib.org/examples/pylab_examples/subplots_demo.html\nFor complex layouts, you should consider using gridspec: http://matplotlib.org/users/gridspec.html\n", "If the images are in an array and you want to iterate through each element and print it, you can write the code as follows:\nplt.figure(figsize=(10,10)) # specifying the overall grid size\n\nfor i in range(25):\n plt.subplot(5,5,i+1) # the number of images in the grid is 5*5 (25)\n plt.imshow(the_array[i])\n\nplt.show()\n\nAlso note that I used subplot and not subplots. They're both different\n", "Below is a complete function show_image_list() that displays images side-by-side in a grid. You can invoke the function with different arguments.\n\nPass in a list of images, where each image is a Numpy array. It will create a grid with 2 columns by default. It will also infer if each image is color or grayscale.\n\nlist_images = [img, gradx, grady, mag_binary, dir_binary]\n\nshow_image_list(list_images, figsize=(10, 10))\n\n\n\nPass in a list of images, a list of titles for each image, and other arguments.\n\nshow_image_list(list_images=[img, gradx, grady, mag_binary, dir_binary], \n list_titles=['original', 'gradx', 'grady', 'mag_binary', 'dir_binary'],\n num_cols=3,\n figsize=(20, 10),\n grid=False,\n title_fontsize=20)\n\n\nHere's the code:\nimport matplotlib.pyplot as plt\nimport numpy as np\n\ndef img_is_color(img):\n\n if len(img.shape) == 3:\n # Check the color channels to see if they're all the same.\n c1, c2, c3 = img[:, : , 0], img[:, :, 1], img[:, :, 2]\n if (c1 == c2).all() and (c2 == c3).all():\n return True\n\n return False\n\ndef show_image_list(list_images, list_titles=None, list_cmaps=None, grid=True, num_cols=2, figsize=(20, 10), title_fontsize=30):\n '''\n Shows a grid of images, where each image is a Numpy array. The images can be either\n RGB or grayscale.\n\n Parameters:\n ----------\n images: list\n List of the images to be displayed.\n list_titles: list or None\n Optional list of titles to be shown for each image.\n list_cmaps: list or None\n Optional list of cmap values for each image. If None, then cmap will be\n automatically inferred.\n grid: boolean\n If True, show a grid over each image\n num_cols: int\n Number of columns to show.\n figsize: tuple of width, height\n Value to be passed to pyplot.figure()\n title_fontsize: int\n Value to be passed to set_title().\n '''\n\n assert isinstance(list_images, list)\n assert len(list_images) > 0\n assert isinstance(list_images[0], np.ndarray)\n\n if list_titles is not None:\n assert isinstance(list_titles, list)\n assert len(list_images) == len(list_titles), '%d imgs != %d titles' % (len(list_images), len(list_titles))\n\n if list_cmaps is not None:\n assert isinstance(list_cmaps, list)\n assert len(list_images) == len(list_cmaps), '%d imgs != %d cmaps' % (len(list_images), len(list_cmaps))\n\n num_images = len(list_images)\n num_cols = min(num_images, num_cols)\n num_rows = int(num_images / num_cols) + (1 if num_images % num_cols != 0 else 0)\n\n # Create a grid of subplots.\n fig, axes = plt.subplots(num_rows, num_cols, figsize=figsize)\n \n # Create list of axes for easy iteration.\n if isinstance(axes, np.ndarray):\n list_axes = list(axes.flat)\n else:\n list_axes = [axes]\n\n for i in range(num_images):\n\n img = list_images[i]\n title = list_titles[i] if list_titles is not None else 'Image %d' % (i)\n cmap = list_cmaps[i] if list_cmaps is not None else (None if img_is_color(img) else 'gray')\n \n list_axes[i].imshow(img, cmap=cmap)\n list_axes[i].set_title(title, fontsize=title_fontsize) \n list_axes[i].grid(grid)\n\n for i in range(num_images, len(list_axes)):\n list_axes[i].set_visible(False)\n\n fig.tight_layout()\n _ = plt.show()\n\n\n", "As per matplotlib's suggestion for image grids:\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.axes_grid1 import ImageGrid\n\nfig = plt.figure(figsize=(4., 4.))\ngrid = ImageGrid(fig, 111, # similar to subplot(111)\n nrows_ncols=(2, 2), # creates 2x2 grid of axes\n axes_pad=0.1, # pad between axes in inch.\n )\n\nfor ax, im in zip(grid, image_data):\n # Iterating over the grid returns the Axes.\n ax.imshow(im)\n\nplt.show()\n\n", "I end up at this url about once a week. For those who want a little function that just plots a grid of images without hassle, here we go:\nimport matplotlib.pyplot as plt\nimport numpy as np\n\ndef plot_image_grid(images, ncols=None, cmap='gray'):\n '''Plot a grid of images'''\n if not ncols:\n factors = [i for i in range(1, len(images)+1) if len(images) % i == 0]\n ncols = factors[len(factors) // 2] if len(factors) else len(images) // 4 + 1\n nrows = int(len(images) / ncols) + int(len(images) % ncols)\n imgs = [images[i] if len(images) > i else None for i in range(nrows * ncols)]\n f, axes = plt.subplots(nrows, ncols, figsize=(3*ncols, 2*nrows))\n axes = axes.flatten()[:len(imgs)]\n for img, ax in zip(imgs, axes.flatten()): \n if np.any(img):\n if len(img.shape) > 2 and img.shape[2] == 1:\n img = img.squeeze()\n ax.imshow(img, cmap=cmap)\n\n# make 16 images with 60 height, 80 width, 3 color channels\nimages = np.random.rand(16, 60, 80, 3)\n\n# plot them\nplot_image_grid(images)\n\n", "Sample code to visualize one random image from the dataset\ndef get_random_image(num):\n path=os.path.join(\"/content/gdrive/MyDrive/dataset/\",images[num])\n image=cv2.imread(path)\n return image\n\nCall the function\nimages=os.listdir(\"/content/gdrive/MyDrive/dataset\")\nrandom_num=random.randint(0, len(images))\nimg=get_random_image(random_num)\nplt.figure(figsize=(8,8))\nplt.imshow(cv2.cvtColor(img,cv2.COLOR_BGR2RGB))\n\nDisplay cluster of random images from the given dataset\n#Making a figure containing 16 images \nlst=random.sample(range(0,len(images)), 16)\nplt.figure(figsize=(12,12))\nfor index,value in enumerate(lst):\n img=get_random_image(value)\n img_resized=cv2.resize(img,(400,400))\n #print(path)\n plt.subplot(4,4,index+1)\n plt.imshow(img_resized)\n plt.axis('off')\n\nplt.tight_layout()\nplt.subplots_adjust(wspace=0, hspace=0)\n#plt.savefig(f\"Images/{lst[0]}.png\")\nplt.show() \n\n\n" ]

[ 148, 56, 32, 26, 13, 8, 4, 0 ]

[ "Plotting images present in a dataset\nHere rand gives a random index value which is used to select a random image present in the dataset and labels has the integer representation for every image type and labels_dict is a dictionary holding key val information\nfig,ax = plt.subplots(5,5,figsize = (15,15))\nax = ax.ravel()\nfor i in range(25):\n rand = np.random.randint(0,len(image_dataset))\n image = image_dataset[rand]\n ax[i].imshow(image,cmap = 'gray')\n ax[i].set_title(labels_dict[labels[rand]])\n \nplt.show()\n\n" ]

[ -2 ]

[ "matplotlib", "python" ]

[ "It seems like you want to use the numba.njit decorator to speed up your code by making it run in parallel. To use numba.njit with parallel execution, you will need to specify the parallel=True keyword argument when you decorate your function. Additionally, you will need to use the prange function instead of the built-in range function in order to specify which loops should be executed in parallel.\nfrom numba import njit, prange\n\n@njit(nopython=True, parallel=True)\ndef _calculate_acceleration(n, npts, G, mass, pos, rsoft):\n \"\"\"\n Calculate the acceleration. This function is out of the class.\n \"\"\"\n # TODO:\n posx = pos[:,0]\n posy = pos[:,1]\n posz = pos[:,2]\n acc = np.zeros((n, 3))\n sqrt = np.sqrt\n\n for i in prange(npts):\n for j in prange(npts):\n if (j>i): \n x = (posx[i]-posx[j])\n y = (posy[i]-posy[j])\n z = (posz[i]-posz[j])\n rsq = x**2 + y**2 + z**2\n req = sqrt(x**2 + y**2)\n\n f = -G*mass[i,0]*mass[j,0]/rsq\n \n theta = np.arctan2(y, x)\n phi = np.arctan2(z, req)\n fx = f*np.cos(theta)*np.cos(phi)\n fy = f*np.sin(theta)*np.cos(phi)\n fz = f*np.sin(phi)\n\n acc[i,0] += fx/mass[i]\n acc[i,1] += fy/mass[i]\n acc[i,2] += fz/mass[i]\n acc[j,0] -= fx/mass[j]\n acc[j,1] -= fy/mass[j]\n acc[j,2] -= fz/mass[j]\n return acc\n\n" ]

[ 0 ]

[]

[]

[ "jit", "jupyter_notebook", "numba", "python" ]

[ "You can write something like this:\nnumber_of_players = int(input(\"Number of players:\"))\nwhile not (2 <= number_of_players <= 5):\n print(\"please chose a number between 2 and 5\")\n number_of_players = int(input(\"Number of players: \"))\n\nGood luck :)\n" ]

[ 0 ]

[]

[]

[ "list", "python" ]

[ "I wonder whether or not you have resolved this. But the problem is that your Kaggle notebook is not connected to the internet. You can try opening the setting on the right of your screen, and make sure your internet is toggled on. This may require you to verify your phone number. Good luck\n" ]

[ 0 ]

[]

[]

[ "data_science", "python" ]

[ "\nIt seems the failure of assign comes from a conflict with the varname rule; to solve it, simply place |assign BEFORE |variable in your expression rule.\n\nA now obsolete workaround, that I'll leave anyway:\n# I added a negative lookahead for '=' so it will not conflict with the assign rule\nvarname = /[a-z]+/!'=' ;\n \nassign = /[a-z]+/ '=' expression ';' expression ;\n\nExample:\nparser.parse(\"x=1;+(x,1)\")\n# ['x', '=', '1', ';', AST({'left': '+', 'right': ['(', 'x', ',', '1', ')']})]\n\n\nAbout 'application' : replacing ' ' with / / at the start of the rule, and placing |application at the start of the expression rule solves the problem:\n\nparser.parse(\"1 2 (x=1;3) *(4,5)\")\nOut[207]: \n(' ',\n '1',\n (' ',\n '2',\n (' ',\n ['(', ['x', '=', '1', ';', '3'], ')'],\n ['*', ['(', '4', ',', '5', ')']])))\n\n" ]

[ 0 ]

[]

[]

[ "grammar", "parsing", "python", "tatsu" ]