Datasets:

suriyagunasekar

/

stackoverflow-python-with-meta-data

like 7

[ "My code was very similar to what is in the question:\nclass Command(BaseCommand):\n help = \"Check order\"\n\n def add_arguments(self, parser):\n parser.add_argument(\"--order-no\", nargs=\"?\", type=str)\n\n def handle(self, *args, **options):\n order = Orders.objects.get(order_no=options[\"order_no\"])\n print(order)\n\nI figured out by accident that the connection is randomly closed every now and then and it causes InterfaceError. In my case probably some other section of the code uses models on global level or maybe django.setup() is loading module that creates a connection to database, or perhaps connection is kept in memory and re-used between consecutive django calls. (No idea so far, need to dig more).\nBut solution to it was pretty simple, add transaction context manager.\nIt will look like this:\nfrom django.db import transaction \n\n\nclass Command(BaseCommand):\n help = \"Check order\"\n\n def add_arguments(self, parser):\n parser.add_argument(\"--order-no\", nargs=\"?\", type=str)\n\n def handle(self, *args, **options):\n with transaction.atomic():\n order = Orders.objects.get(order_no=options[\"order_no\"])\n print(order)\n\n", "MySQL is lazily connected to Django. If connection.connection is None means you have not connected to MySQL before.\nIf the connection is closed and you try to access the cursor, you will get an InterfaceError. You can close the database connection so that when you use ORM methods Django will reconnect to open a new connection\nI have created a helper reconnect() which we are using in production.\ndef reconnect():\n from django.db import connections\n from logging import getLogger\n \n for alias in list(connections):\n conn = connections[alias]\n if conn.connection and not conn.is_usable():\n conn.close()\n del connections[alias]\n closed.append(alias)\n getLogger(__name__).warn('Closing unusable connections: %s', closed)\n\nI am further attaching a few helpful examples on maintaining database connections healthy\nhttps://www.programcreek.com/python/example/100987/django.db.connection.is_usable\n" ]

[ 1, 0 ]

[]

[]

[ "django", "mysql", "python" ]

[ "total_acc_avg is a pandas Series object that contains the average of the mort_acc column, grouped by the total_acc column. In this case, the 6th index of the total_acc_avg Series contains the average value of the mort_acc column for the group with total_acc value of 6.\n" ]

[ 1 ]

[]

[]

[ "list", "mean", "pandas", "python" ]

[ "You've configured the weight on the columns, but you haven't given any weight to any rows. Because of that, and because the frames by default are only 1 pixel tall, the columns will be virtually invisible.\nTo fix this you can give non-zero weight to one or more rows. For example, self.rowconfigure(0, weight=1)\nYou also haven't configured the contents in each column to fill the space allocated. You should add sticky=\"nsew\" to get each of the inner frames to expand to fill. For example, cfg.grid(row=0, column=0, sticky=\"nsew\")\n\n" ]

[ 2 ]

[]

[]

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

[ "You need to install urllib.\nThis is required by matplotlib\n", "Install Python 3.10 and update pip and then try to install Matplotlib and also install urllib using pip install urllib\n" ]

[ 0, 0 ]

[ "Look Install urllib from : https://pypi.python.org/pypi/urllib2_file/0.2.1\nOr if you was instaled pip you can use sudo pip install urllib\n" ]

[ -1 ]

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

[ "You can use pandas.DataFrame.merge with pandas.Series.fillna :\ndf_order = pd.read_excel(\"SuperStoreUS.xlsx\", sheet_name=\"Orders\")\ndf_return = pd.read_excel(\"SuperStoreUS.xlsx\", sheet_name=\"Returns\")\n\nUse either :\n# --- To create a new dataframe\nout = df_order.merge(df_return, on=\"Order ID\", how=\"left\")\nout[\"Status\"] = out[\"Status\"].fillna(\"Not Returned\")\n\nOr:\n# --- To update df_order\ndf_order = df_order.merge(df_return, on=\"Order ID\", how=\"left\")\ndf_order[\"Status\"] = df_order[\"Status\"].fillna(\"Not Returned\")\n\n", "Another way is to create a new column in df_order, with values conditioned on the row's Order ID:\ndf_orders['Status'] = df_orders['Order ID'].map(lambda x: 'Returned' if x in df_returns['Order ID'].tolist() else 'Not returned')\n\n" ]

[ 1, 1 ]

[]

[]

[ "matching", "multiple_columns", "pandas", "python" ]

[ "Here is a script where you can read all files in a directory and write the name of the file and the content into a another file like you did.\nimport os\n\nValuesTextFile = open(\"values.txt\",\"a\")\nPath = './files/'\nfor Filename in os.listdir(Path):\n print (Filename)\n ValuesTextFile.writelines(Filename)\n File = open(Path + Filename, \"r\")\n Content = File.readlines()\n ValuesTextFile.writelines(Content[33:36])\n File.close()\nValuesTextFile.close()\n\n" ]

[ 0 ]

[]

[]

[ "new_operator", "python" ]

[ "a = 'some_description'\ndf.assign(some_description=df[a].str.split(r'\\. ')).explode(a)\n\nresult:\n num_legs num_wings some_description\nfalcon 2 2 falcons have wings\nfalcon 2 2 falcons fly\ndog 4 0 dog have 4 legs\ndog 4 0 they are the best\nspider 8 0 spiders create webs\nspider 8 0 spiders have 8 legs\nfish 0 0 fish swims\nfish 0 0 fish lives in water\n\n" ]

[ 0 ]

[]

[]

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

[ "Use data.values() as target in for loop to iterate over the JSON objects. Doing a loop over data iterates over the keys which is a string value (e.g. \"A1J780\").\ndata = {\n 'A1J780': {'ter': '0.20%', 'wkn': 'A1J780', 'isin': 'IE00B88DZ566'},\n 'A1J7W9': {'ter': '0.20%', 'isin': 'IE00B8KMSQ34'}\n}\nvalue_list = []\nfor i in data.values():\n value_list.append(i['isin'])\nprint(value_list)\n\nOutput:\n['IE00B88DZ566', 'IE00B8KMSQ34']\n\nIf the isin key is not present in any of the dictionary objects then you would need to use i.get('isin') and check if the value is not None otherwise i['isin'] would raise an exception.\n", "The error message TypeError: string indices must be integers, not 'str' indicates that you are trying to access a dictionary value using a string as the key, but the type of the key should be an integer instead.\nIn your code, the i variable in the for loop is a string, because it represents the keys in the data dictionary. However, you are trying to access the 'isin' value in the dictionary using the i['isin'] syntax, which is not valid for a string key.\nTo fix this issue, you can use the i variable as the key to access the dictionary value, like this:\nwith open('output.json') as f:\n data = json.load(f)\n\nvalue_list = list()\nfor i in data:\n value_list.append(data[i]['isin'])\nprint(value_list)\n\nIn this updated code, the data[i] syntax is used to access the dictionary value associated with the key i, and then the ['isin'] syntax is used to access the 'isin' value in the nested dictionary.\nThis code should produce the expected output of a list of ISINs from the output.json file.\n" ]

[ 0, 0 ]

[]

[]

[ "dictionary", "json", "python" ]

[ "Use option --timeout <sec> to set socket time out.\nAlso, as @Iain Shelvington mentioned, timeout = <sec> in pip configuration will also work.\nTIP: Every time you want to know something (maybe an option) about a command (tool), before googling, check the manual page of the command by using man <command> or use <command> --help or check that command's docs online will be very useful too (Maybe better than Google).\n", "To set the timeout time to 30sec for example. The easiest way is executing: pip config global.timeout 30 or going to the pip configuration file pip.ini located in the directory ~\\AppData\\Roaming\\pip in the case of Windows operating system. If the file does not exist there, create it and write:\n[global]\ntimeout = 30.\n" ]

[ 10, 0 ]

[]

[]

[ "pip", "python", "request_timed_out" ]

[ "Quick example :\n################################################################################\n# the code for the \"framework\"\nevent1_listeners = []\nevent2_listeners = []\n\ndef listen_event1(func):\n event1_listeners.append(func)\n return func\n\ndef listen_event2(func):\n event2_listeners.append(func)\n return func\n\ndef process_event(event):\n if event[\"type\"] == 1:\n for func in event1_listeners:\n func(event)\n elif event[\"type\"] == 2:\n for func in event2_listeners:\n func(event)\n else:\n raise NotImplementedError(f\"{event['type']=!r}\")\n\n################################################################################\n# your code\n@listen_event1\ndef handle_event1_v1(event):\n print(f\"handle_event1_v1 : {event!r}\")\n\n@listen_event1\ndef handle_event1_v2(event):\n print(f\"handle_event1_v2 : {event!r}\")\n\n@listen_event2\ndef handle_event2(event):\n print(f\"handle_event2 : {event!r}\")\n\n################################################################################\n# the events processed by the framework\nprocess_event({\"type\": 1, \"msg\": \"hello\"})\nprocess_event({\"type\": 2, \"msg\": \"world\"})\n\nhandle_event1_v1 : {'type': 1, 'msg': 'hello'}\nhandle_event1_v2 : {'type': 1, 'msg': 'hello'}\nhandle_event2 : {'type': 2, 'msg': 'world'}\n\nEssentially, the decorators will store the function someplace, and when an event is received, the framework iterates over the functions registered for it.\nRemoving a listener dynamically is basically just removing the func reference from the list.\nThe decorator in this case is simply \"sugar\" to not having to do event1_listeners.append(func) yourself.\n", "Here's a simple class-based solution I quickly coded:\nclass Event:\n def __init__(self):\n # Initialise a list of listeners\n self.__listeners = []\n \n # Define a getter for the 'on' property which returns the decorator.\n @property\n def on(self):\n # A declorator to run addListener on the input function.\n def wrapper(func):\n self.addListener(func)\n return func\n return wrapper\n \n # Add and remove functions from the list of listeners.\n def addListener(self,func):\n if func in self.__listeners: return\n self.__listeners.append(func)\n \n def removeListener(self,func):\n if func not in self.__listeners: return\n self.__listeners.remove(func)\n \n # Trigger events.\n def trigger(self,args = []):\n # Run all the functions that are saved.\n for func in self.__listeners: func(*args)\n\nIt allows you to create an Event that functions can 'subscribe' to:\nevn = Event()\n\n# Some code...\n\nevn.trigger(['arg x','arg y'])\n\nThe functions can both subscribe to the event with decorators:\n@evn.on\ndef some_function(x,y): pass\n\nOr with the addListener method:\ndef some_function(x,y): pass\nevn.addListener(some_function)\n\nYou can also remove listeners:\nevn.removeListener(some_function)\n\nTo create something similar to what you asked for you can do something like this:\n# some.py\n\nfrom event import Event\n\nclass SomeClass:\n def __init__(self):\n # Private event variable\n self.__event = Event()\n # Public event variable (decorator)\n self.event = self.__event.on\n\nsome = SomeClass()\n\nAnd then use it like so:\n# main.py\n\nfrom some import some\n\n@some.event\nasync def on_ready(some_info):\n print(some_info)\n\n@some.event\nasync def on_error(err):\n print(err)\n\n" ]

[ 1, 0 ]

[]

[]

[ "decorator", "discord", "python" ]

[ "It looks like your code is vulnerable to SQL injection attacks in the addrec function. In particular, the following line of code concatenates user input directly into the SQL query string, which can allow an attacker to inject arbitrary SQL commands:\ncur.executescript(\"INSERT INTO tasks (title,body) VALUES (\" +\n html.unescape(sqlescape(title)) + \",\" + html.unescape(sqlescape(body.decode())) +\n \");\")\n\nFor example, if an attacker were to provide the following input for the title field:\n'; DROP TABLE tasks; --\n\nThe resulting SQL query would be:\nINSERT INTO tasks (title,body) VALUES (''; DROP TABLE tasks; --','[base64-encoded body value]');\n\nThis query would first insert a new record with a title value of '; DROP TABLE tasks; --', and then execute a DROP statement to delete the entire tasks table.\nTo protect against SQL injection attacks, you should use parameterized queries instead of concatenating user input into the query string. In Python, you can use the ? placeholder in your SQL query and pass the user input as a separate argument to the execute or executemany method. For example, the addrec function could be rewritten as follows:\n @app.route('/addrec', methods=['POST', 'GET'])\ndef addrec():\n if request.method == 'POST':\n con = sqlite3.connect(db)\n msg = \"\"\n try:\n # Get the user input\n title = request.form['title']\n body = request.form['body']\n key = request.form['password']\n body = encode_body(body, key)\n\n # Use a parameterized query to insert the user input into the database\n cur = con.cursor()\n cur.execute(\"INSERT INTO tasks (title,body) VALUES (?, ?)\", (title, body.decode()))\n\n # Commit the changes to the database\n con.commit()\n msg = \"Record successfully added\"\n except:\n con.rollback()\n msg = \"error in insert operation\"\n\n finally:\n return render_template(\"result.html\", msg=msg)\n con.close()\n\n" ]

[ 1 ]

[]

[]

[ "python", "sql", "sql_injection" ]

[ "A decorator method should return a method:\ndef wrapThis(func):\n def wrapper_func(msg):\n msg = str(msg).upper()\n return func(msg)\n return wrapper_func\n\n@wrapThis\ndef msgReturnAsList(msg):\n msg = list(msg)\n return msg\n\nb = \"Convert to upper and output it as a list of letters.\"\nprint(msgReturnAsList(b))\n\nHow to Create and Use Decorators in Python With Examples\n" ]

[ 1 ]

[]

[]

[ "python", "python_decorators" ]

[ "You use Polars Dataframe instead of Pandas dataframe and indexing is a little different here and what is why you have this error. In order to plot it, one way to do it is to convert the dataframe from Polars to Pandas on the fly by using to_pandas():\nfig = px.line(df.to_pandas(),x='time', y=['A', 'B'])\n\nOutput\n\nYou can also use this way:\nfig = px.line(x=df['time'], y=[df[\"A\"],df[\"B\"]])\n\n", "In your code, you can use the line() function to plot the A and B columns from your DataFrame, which contain the time-series data for the two series. You can then set the x and y parameters of the line() function to specify which column should be used for the X-axis and which columns should be used for the Y-axis.\nHere's an example of how you can use the line() function to plot the A and B columns from your DataFrame with time on the X-axis:\n# Import the necessary modules\nfrom numpy import linspace\nimport plotly.express as px\n\n# Create a DataFrame with time-series data for two series\ntimes = linspace(1, 6, 10)\ndf = pl.DataFrame({\n 'time': times,\n 'A': times**2,\n 'B': times**3,\n})\n\n# Use the line() function to plot the A and B columns from the DataFrame\nfig = px.line(df, x='time', y=['A', 'B'])\n\n# Show the plot\nfig.show()\n\nThis will create a line chart with the A and B columns from your DataFrame as the data series, and the time column as the X-axis. The resulting plot should show the two series with time on the X-axis.\n" ]

[ 1, 0 ]

[]

[]

[ "plotly", "python" ]

[ "There is an object for that unfortunately its a java object, and not translated to pyspark.\nYou can still access it with Spark constucts:\n>>> df._jdf.queryExecution().executedPlan().apply(0).output().apply(0).toString()\nu'department#1621'\n>>> df._jdf.queryExecution().executedPlan().apply(0).output().apply(1).toString()\nu'max_age#1632L'\n\nYou could loop through both the above apply to get the information you are looking for with something like:\nplan = df._jdf.queryExecution().executedPlan()\nsteps = [ plan.apply(i).toString() for i in range(1,100) if not isinstance(plan.apply(i), type(None)) ]\n\nBit of a hack but apparently size doesn't work.\n", "Yes, it is possible to obtain a list of source columns that are being referenced by a PySpark DataFrame. To do this, you can use the DataFrame's df.columns attribute, which returns a list of the column names in the DataFrame. In your example, this would be df.columns which would return ['department', 'max_age'].\nAlternatively, you can also use the df.dtypes attribute, which returns a list of tuples containing the column names and their data types. For example, df.dtypes would return [('department', 'string'), ('max_age', 'bigint')].\n" ]

[ 4, 0 ]

[ "You can try the below codes, this will give you a column list and its data type in the data frame.\nfor field in df.schema.fields:\n print(field.name +\" , \"+str(field.dataType))\n\n" ]

[ -1 ]

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

[ "Here is one way to do this using the shutil module in Python:\nimport shutil\n\n# Replace the source and destination paths with the appropriate paths on your system\nsrc_dir = \"C:\\\\source\\\\folder\"\ndst_dir = \"C:\\\\destination\\\\folder\"\n\n# Use the shutil.copytree function to copy everything from the source directory to the destination directory\nshutil.copytree(src_dir, dst_dir)\n\nThis will copy all files and subdirectories from src_dir to dst_dir. Note that dst_dir must not already exist, otherwise the copytree function will raise an error.\nYou can also use the copy function from the shutil module to copy individual files. For example:\nimport shutil\n\n# Replace the source and destination paths with the appropriate paths on your system\nsrc_file = \"C:\\\\source\\\\folder\\\\file.txt\"\ndst_file = \"C:\\\\destination\\\\folder\\\\file.txt\"\n\n# Use the shutil.copy function to copy the file\nshutil.copy(src_file, dst_file)\n\nThis will copy the file at src_file to the destination at dst_file. If dst_file already exists, it will be overwritten.\nYou can use these functions in a loop to iterate over all files in a directory and copy them to the destination directory. Here is an example:\nimport os\nimport shutil\n\n# Replace the source and destination paths with the appropriate paths on your system\nsrc_dir = \"C:\\\\source\\\\folder\"\ndst_dir = \"C:\\\\destination\\\\folder\"\n\n# Create the destination directory if it does not already exist\nif not os.path.exists(dst_dir):\n os.makedirs(dst_dir)\n\n# Iterate over all files in the source directory\nfor filename in os.listdir(src_dir):\n # Construct the full paths for the source and destination files\n src_file = os.path.join(src_dir, filename)\n dst_file = os.path.join(dst_dir, filename)\n \n # Use the shutil.copy function to copy the file\n shutil.copy(src_file, dst_file)\n\n", "import shutil\nimport os\n\n# Path to the directory\nsource = 'C:/path/to/source/folder'\n\n# Path to the destination directory\ndestination = 'C:/path/to/destination/folder'\n\n# Copy contents from source to destination\nshutil.copytree(source, destination)\n\n# List all the files in source directory\nsource_files = os.listdir(source)\n\n# Iterate over all the files in source directory\nfor file_name in source_files:\n # Create full path of file in source directory\n full_file_name = os.path.join(source, file_name)\n # If file is a directory, create corresponding directory in destination\n # directory\n if os.path.isdir(full_file_name):\n shutil.copytree(full_file_name, os.path.join(destination, file_name))\n else:\n # Copy the file from source to destination\n shutil.copy2(full_file_name, destination)\n\n" ]

[ 0, 0 ]

[]

[]

[ "coding_style", "copy", "paste", "python", "windows" ]

[ "You can do this via inline CSS and st.markdown, although it's admittedly hacky.\ndef _set_block_container_style(\n max_width: int = 1200,\n max_width_100_percent: bool = False,\n padding_top: int = 1,\n padding_right: int = 1,\n padding_left: int = 1,\n padding_bottom: int = 1,\n):\n\nif max_width_100_percent:\n max_width_str = f\"max-width: 100%;\"\nelse:\n max_width_str = f\"max-width: {max_width}px;\"\n \nstyl = f\"\"\"\n <style>\n .reportview-container .main .block-container{{\n {max_width_str}\n padding-top: {padding_top}rem;\n padding-right: {padding_right}rem;\n padding-left: {padding_left}rem;\n padding-bottom: {padding_bottom}rem;\n }}\n }}\n </style>\n\n", "You have to pay close attention to the classes to get the right class and also making sure you wrap the css in a valid format in order to get it working.\nThis is a work around which I think should solve your problem. But I am not really sure if there are change in class names in deferent versions of streamlit.\nst.markdown(\"\"\"\n <style>\n ul[class=\"css-wjbhl0 e1fqkh3o9\"]{\n position: relative;\n padding-top: 2rem;\n display: flex;\n justify-content: center;\n flex-direction: column;\n align-items: center;\n }\n \n .css-17lntkn {\n font-weight: bold;\n font-size: 20px;\n color: yellow;\n }\n \n .css-pkbazv {\n font-weight: bold;\n font-size: 20px;\n }\n </style>\"\"\", unsafe_allow_html=True)\n\n" ]

[ 0, 0 ]

[]

[]

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

[ "To get the desired visualization in plotly, you will need to specify the x and y values manually. Instead of passing in the labels as a list, you should specify the x and y values as a list of tuples, like so:\nx = [(-10, 9), (-9, 8), ... (9, -10)]\ny = [(-10, 9), (-9, 8), ... (9, -10)]\n\nThis should produce the desired visualization.\n", "As I mentioned in my comment, the internal representation of px.imshow() is a heatmap. I coded your objective with a heatmap in a graph object. I didn't change this for any clear reason, I just took a different approach because I couldn't achieve it with px.imshow().\nimport plotly.graph_objects as go\n\nimg = np.arange(20**2).reshape((20, 20))\n\nfig = go.Figure(data=go.Heatmap(z=img.tolist()[::-1]))\n\nfig.update_yaxes(tickvals=np.arange(0, 20, 1), ticktext=[str(x) for x in np.arange(-10, 10, 1)])\nfig.update_xaxes(tickvals=np.arange(0, 20, 1), ticktext=[str(x) for x in np.arange(-10, 10, 1)])\nfig.update_layout(autosize=False, height=500, width=500)\nfig.show()\n\n\n", "It looks like the issue is that the y values in the px.imshow() function are being interpreted as the actual y-values for the data points in your matrix, rather than labels for the y-axis. Therefore, when you provide y=list(reversed(range(-10, 10))), the y-values of your data points are being reversed, resulting in the vertical reversal of the image.\nOne way to fix this is to use the yaxis_title argument in the px.imshow() function to specify the title for the y-axis, and then use the tickvals and ticktext arguments to specify the values and labels for the y-axis ticks, respectively.\nFor example:\nimport numpy as np\nimport plotly.express as px\n\nimg = np.arange(20**2).reshape((20, 20))\n\ny_values = list(range(-10, 10))\n\nfig = px.imshow(img,\n x=list(range(-10, 10)),\n yaxis_title=\"y-axis\",\n tickvals=y_values,\n ticktext=reversed(y_values),\n )\nfig.show()\n\nThis should produce an image where the y-axis labels are in the correct order, without reversing the image.\n" ]

[ 2, 2, 0 ]

[ "import plotly.graph_objects as go\nimport plotly.express as px\n\nimg = np.arange(20**2).reshape((20, 20))\nfig = px.imshow(img,\n x=list(range(-10, 10)),\n y=list(range(10, 30, 1)),\n)\n\nfig.show()\n\nOutput:\n\n" ]

[ -1 ]

[ "plotly", "plotly_python", "python" ]

[ "I'd initialize a dict that maps letters to grades and then apply it to a new column.\nvals = { \"A\" : 4, \"B\" : 3, \"C\" : 2, \"D\" : 1, \"F\" : 0 }\ndf['Grade number'] = df['Grade'].apply(lambda x: vals.get(x))\n\n" ]

[ 0 ]

[]

[]

[ "assign", "python" ]

[ "It looks to me that the reason your piece is dropping faster when you press a button is because if the user doesn't press a button the timer is set to 600ms. If they do press a button then the timer is set to 100ms.\nAs for how to fix this, you'll need to decouple the downward piece movement and user-input movement. I'd suggest making another event that only handles downward movement.\nDROPEVENT = pygame.USEREVENT + 1\n\nelif event.Type == DROPEVENT:\n pygame.time.set_timer(DROPEVENT, 600)\n # Your piece drop logic.\n\nThis snippet is not complete nor tested at all, but I hope it get the idea across. You don't seem to have posted the logic that handles dropping the piece, but you would need to move this into the new event.\n", "Waiting a long time (100 ms is already long) before reacting to user input feels bad, so you don’t want to wait a full piece-movement time before checking for input again just because there is none at the moment you check. Instead, poll for input at a steady pace of (say) 30 Hz; for simplicity, the usual approach is to just run the whole game at that frequency even if nothing needs to change on the screen for some (or even most) frames. (This technique also naturally allows smooth animations of or between piece movements.)\nThe usual implementation of “nothing” on a frame is to adjust the piece’s position every frame but integer-divide that position by some constant before using it for anything other than keeping track of its progress toward the next movement (like drawing it or checking for collisions). You might use pixels as the “invisible unit” when movement must be by whole tiles; games where sprites can be drawn at any pixel divide each into some convenient number of subpixels in the same fashion.\n" ]

[ 0, 0 ]

[]

[]

[ "pygame", "python" ]

[ "Most of the answers here have dealt with how to mange EOFError exceptions, which is really handy if you're unsure about whether the pickled object is empty or not.\nHowever, if you're surprised that the pickle file is empty, it could be because you opened the filename through 'wb' or some other mode that could have over-written the file.\nfor example:\nfilename = 'cd.pkl'\nwith open(filename, 'wb') as f:\n classification_dict = pickle.load(f)\n\nThis will over-write the pickled file. You might have done this by mistake before using:\n...\nopen(filename, 'rb') as f:\n\nAnd then got the EOFError because the previous block of code over-wrote the cd.pkl file. \nWhen working in Jupyter, or in the console (Spyder) I usually write a wrapper over the reading/writing code, and call the wrapper subsequently. This avoids common read-write mistakes, and saves a bit of time if you're going to be reading the same file multiple times through your travails \n", "I would check that the file is not empty first:\nimport os\n\nscores = {} # scores is an empty dict already\n\nif os.path.getsize(target) > 0: \n with open(target, \"rb\") as f:\n unpickler = pickle.Unpickler(f)\n # if file is not empty scores will be equal\n # to the value unpickled\n scores = unpickler.load()\n\nAlso open(target, 'a').close() is doing nothing in your code and you don't need to use ;.\n", "It is very likely that the pickled file is empty.\nIt is surprisingly easy to overwrite a pickle file if you're copying and pasting code.\nFor example the following writes a pickle file:\npickle.dump(df,open('df.p','wb'))\n\nAnd if you copied this code to reopen it, but forgot to change 'wb' to 'rb' then you would overwrite the file:\ndf=pickle.load(open('df.p','wb'))\n\nThe correct syntax is\ndf=pickle.load(open('df.p','rb'))\n\n", "As you see, that's actually a natural error ..\nA typical construct for reading from an Unpickler object would be like this ..\ntry:\n data = unpickler.load()\nexcept EOFError:\n data = list() # or whatever you want\n\nEOFError is simply raised, because it was reading an empty file, it just meant End of File ..\n", "You can catch that exception and return whatever you want from there. \nopen(target, 'a').close()\nscores = {};\ntry:\n with open(target, \"rb\") as file:\n unpickler = pickle.Unpickler(file);\n scores = unpickler.load();\n if not isinstance(scores, dict):\n scores = {};\nexcept EOFError:\n return {}\n\n", "if path.exists(Score_file):\n try : \n with open(Score_file , \"rb\") as prev_Scr:\n\n return Unpickler(prev_Scr).load()\n\n except EOFError : \n\n return dict() \n\n", "I have encountered this error many times and it always occurs because after writing into the file, I didn't close it. If we don't close the file the content stays in the buffer and the file stays empty.\nTo save the content into the file, either file should be closed or file_object should go out of scope.\nThat's why at the time of loading it's giving the ran out of input error because the file is empty. So you have two options :\n\nfile_object.close()\nfile_object.flush(): if you don't wanna close your file in between the program, you can use the flush() function as it will forcefully move the content from the buffer to the file.\n\n", "Had the same issue. It turns out when I was writing to my pickle file I had not used the file.close(). Inserted that line in and the error was no more.\n", "Note that the mode of opening files is 'a' or some other have alphabet 'a' will also make error because of the overwritting.\npointer = open('makeaafile.txt', 'ab+')\ntes = pickle.load(pointer, encoding='utf-8')\n\n", "temp_model = os.path.join(models_dir, train_type + '_' + part + '_' + str(pc))\n# print(type(temp_model)) # <class 'str'>\nfilehandler = open(temp_model, \"rb\")\n# print(type(filehandler)) # <class '_io.BufferedReader'>\ntry:\n pdm_temp = pickle.load(filehandler)\nexcept UnicodeDecodeError:\n pdm_temp = pickle.load(filehandler, fix_imports=True, encoding=\"latin1\")\n\n", "This error comes when your pickle file is empty (0 Bytes). You need to check the size of your pickle file first. This was the scenario in my case. Hope this helps!\n" ]

[ 297, 176, 27, 11, 3, 2, 1, 1, 0, 0, 0 ]

[ "from os.path import getsize as size\nfrom pickle import *\nif size(target)>0:\n with open(target,'rb') as f:\n scores={i:j for i,j in enumerate(load(f))}\nelse: scores={}\n\n#line 1.\nwe importing Function 'getsize' from Library 'OS' sublibrary 'path' and we rename it with command 'as' for shorter style of writing. Important is hier that we loading only one single Func that we need and not whole Library!\nline 2.\nSame Idea, but when we dont know wich modul we will use in code at the begining, we can import all library using a command '*'.\nline 3.\nConditional Statement... if size of your file >0 ( means obj is not an empty). 'target' is variable that schould be a bit earlier predefined.\njust an Example : target=(r'd:\\dir1\\dir.2..\\YourDataFile.bin')\nLine 4.\n'With open(target) as file:' an open construction for any file, u dont need then to use file.close(). it helps to avoid some typical Errors such as \"Run out of input\" or Permissions rights.\n'rb' mod means 'rea binary' that u can only read(load) the data from your binary file but u cant modify/rewrite it.\nLine5.\nList comprehension method in applying to a Dictionary..\nline 6. Case your datafile is empty, it will not raise an any Error msg, but return just an empty dictionary.\n" ]

[ -1 ]

[ "file", "pickle", "python" ]

[ "You can do it like this:\nresult = statement.all()\nresponse = []\n\nfor r in result:\n\n response.append({\n \"id\": r[1],\n \"username\": r[2]\n })\n\nThis code will iterate over the query result, and create a dictionary object with only the id and username fields, and append it to the response list. You can then return the response list as the JSON response.\n" ]

[ 0 ]

[]

[]

[ "fastapi", "python", "python_3.x", "sqlalchemy" ]

[ "It looks like you are appending the values to the list within the try block, which means that if an exception occurs, the list will not be updated. Instead, you should append the values to the list outside of the try block, and use a default value within the except block. For example, instead of this:\ntry:\n med_name = []\n for i in driver.find_elements(By.XPATH,\"//div[@id='brand_dose']//div[@class='product-name']\"):\n med_name.append(i.text)\nexcept:\n med_name.append(None)\n\nYou can do this:\nmed_name = []\ntry:\n for i in driver.find_elements(By.XPATH,\"//div[@id='brand_dose']//div[@class='product-name']\"):\n med_name.append(i.text)\nexcept:\n med_name.append(None)\n\nThis way, the med_name list will always be updated, whether or not an exception occurs.\nTo achieve the expected output, you can simply use the extend method to add the elements of the lists to the data list, instead of creating a dictionary and appending that to the data list. For example, instead of this:\ndata.append({\n 'Medicine_name':med_name,\n 'Manufacture_name':manuf_name,\n 'Product_Counry':country,\n 'Prescription_Required':pres_req,\n 'Product_Details':str_price})\n\nYou can do this:\ndata.extend(zip(med_name, manuf_name, country, pres_req, str_price))\n\nThis will create a list of tuples, where each tuple contains the values of the corresponding elements from the med_name, manuf_name, country, pres_req, and str_price lists. This will give you the desired output, where each medicine's details are on a separate row.\n" ]

[ 0 ]

[]

[]

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

[ "It looks like you are using the comparison operators >= and <= to try and specify the time range you want to include in your time period dataframe. However, these comparison operators will not work as expected on string values like the ones you have in your time column. Instead of using these operators, you can use the str.slice() method to extract the hour portion of the time strings and then use the comparison operators on those numeric values to specify your time range.\nHere is an example of how you could do this:\n# First, extract the hour portion of the time strings\ndf['hour'] = df['time'].str.slice(0, 2)\n\n# Next, create a boolean mask using the comparison operators on the 'hour' column\ntime_period = (df['hour'] >= '01') & (df['hour'] <= '05')\n\n# Finally, use this boolean mask to create your time period dataframe\ntime_period_df = df.loc[time_period]\n\nThis should give you a dataframe that includes only the rows with time values between and including 1:00:00 and 5:00:00.\nNote that this solution assumes that the time strings in your time column are in the format 'HH:MM:SS'. If the time strings are in a different format, you will need to adjust the str.slice() call accordingly.\n" ]

[ 0 ]

[]

[]

[ "group_by", "pandas", "python", "python_datetime", "time_series" ]

[ "You should use math to understand the components that are part of the answer. you need to calculate sum of all numbers until h, denote s, and the sum of all squares 1^2+2^2+3+2+... denotes sum_power\nit comes down to: h*m*n + s*n + s*m + sum_power\nthis is a working solution:\nimport time\n\ndef pyramid_blocks(n, m, h):\n return sum((n+i)*(m+i) for i in range(h))\n\n\ndef efficient_pyramid_blocks(n, m, h):\n s = (h-1)*h/2\n sum_power = (h-1)*h*(2*(h-1)+1)/6\n return int(h*n*m + s*(n+m) + sum_power)\n\n\nif __name__ == '__main__':\n h = 100000\n m = 32\n n = 47\n start = time.time()\n print(pyramid_blocks(n, m, h))\n print(time.time()-start)\n start = time.time()\n print(efficient_pyramid_blocks(n, m, h))\n print(time.time() - start)\n\nand the output is:\n333723479800000\n0.016993045806884766\n333723479800000\n1.2159347534179688e-05\n\n", "A bit of math can help:\nhere we use a symbolic calculator to get the equation for the blocks in the pyramid using a sigma sum of (n+count)*(m+count) from count = 0 to count = h-1\nThen we just paste the equation into code (the double slash // is just to use integer division instead of float division):\ndef count_blocks(n,m,h):\n return (2*(h**3)+3*(h**2)*m+3*(h**2)*n+6*h*m*n-3*(h**2)-3*h*m-3*h*n+h)//6\n\nEdit: This also outputs the correct result of 10497605327499753 for n,m,h = (2123377, 2026271, 2437)\n" ]

[ 0, 0 ]

[]

[]

[ "list", "python" ]

[ "You can use the nested query in Elasticsearch to filter on multiple subfields of the same ObjectField. Here is an example of how you can do this in django-elasticsearch-dsl:\nx = ItemDocument.search().query(\n \"nested\",\n path=\"details\",\n query=Q(\"match\", details__category_id=3) & Q(\"range\", details__value={'lt':1.5})\n).execute()\n\nThe nested query allows you to filter on multiple subfields of the details object, and only return documents that have a detail object with both category_id==3 and value < 1.5.\nYou can also use the inner_hits option with the nested query to get the details of the matching detail objects:\nx = ItemDocument.search().query(\n \"nested\",\n path=\"details\",\n query=Q(\"match\", details__category_id=3) & Q(\"range\", details__value={'lt':1.5}),\n inner_hits={}\n).execute()\n\nThis will add a nested field to each search result, which contains the details of the matching detail objects. You can access this field in your code like this:\nresults = x.to_dict()\nfor result in results['hits']['hits']:\n nested_results = result['inner_hits']['details']['hits']['hits']\n # do something with nested_results\n\n" ]

[ 1 ]

[]

[]

[ "django", "elasticsearch", "elasticsearch_dsl_py", "python" ]

[ "Here is an example of how you could write a Python program to retrieve all the products from the API server and print the total number of products currently stored in the server:\nimport requests\n\n# Define the base URL of the API\nBASE_URL = \"http://host1.open.uom.lk:8080\"\n\n# Use the requests library to make a GET request to the API's /api/products/ endpoint\nresponse = requests.get(f\"{BASE_URL}/api/products/\")\n\n# Check the status code of the response to make sure the request was successful\nif response.status_code == 200:\n # If the request was successful, parse the JSON response\n products = response.json()\n \n # Retrieve the list of products from the \"data\" key in the JSON response\n products_list = products[\"data\"]\n \n # Print the total number of products stored in the server\n print(f\"Total number of products in the server: {len(products_list)}\")\nelse:\n # If the request was not successful, print an error message\n print(f\"An error occurred: {response.text}\")\n\nThis code should print the total number of products stored in the server.\n" ]

[ 0 ]

[]

[]

[ "api", "python" ]

[ "It would be useful to know what library (sklearn, pytorch, tensorflow, etc.) you used to train the model, but for this example I'm going to assume you used the pickle library to pickle and the sklearn library to train the model.\nAt some point you used something like pickle.dump(model, open(filename, 'wb')) to save your model.\nYou can also use pickle to load the model through pickle.load(open(filename, 'rb')) and then call the model through model.predict(new_X) where new_X represents the dataframe you want to make the predictions on.\n" ]

[ 0 ]

[]

[]

[ "jupyter_notebook", "machine_learning", "python", "sentiment_analysis" ]

[ "If I am correct I think it is rect.left or rect.top that gives it. Another method is to create another rectangle and check if the rectangle is in that.\n", "#To move a rect object in Pygame, you can use the move_ip() method. This method takes two arguments, the x and y coordinates to move the rect by. For example, if you want to move the rect one pixel to the right and one pixel down, you can use the following code:\n\nrectball.move_ip(1, 1)\n\n#You can also use the x and y attributes of the rect to move it by a certain amount. For example, if you want to move the rect one pixel to the right, you can use the following code:\n\nrectball.x += 1\n\n#Note that this will only move the rect object and not the image that it represents. To move the image on the screen, you will also need to update the position of the ball surface using the blit() method.\n\n#Here is an updated version of your code that moves the rect and the image on the screen:\n\nimport sys\nimport pygame\n\npygame.init()\n\nsize = width, height = 1920, 1080\nblack = 0, 0, 0\n\nscreen = pygame.display.set_mode(size)\n\nball = pygame.image.load(\"ball.png\")\nrectball = ball.get_rect()\n\nwhile True:\n for event in pygame.event.get():\n if event.type == pygame.QUIT:\n sys.exit()\n\n # Move the rect one pixel to the right and one pixel down\n rectball.move_ip(1, 1)\n\n # Update the position of the ball on the screen\n screen.blit(ball, rectball)\n\n pygame.display.flip()\n\n" ]

[ 0, 0 ]

[]

[]

[ "python" ]

[ "\nI've only seen turtle used to draw lines, not shapes, much less\nmovable game pieces. I think pygame would definitely be better for\nthis – OneCricketeer\n\nBelow is an example slide game simplified from an earlier answer I wrote about creating numbered tiles using turtle:\nfrom turtle import Screen, Turtle\nfrom functools import partial\nfrom random import random\n\nSIZE = 4\nTILE_SIZE = 100\nOFFSETS = [(-1, 0), (0, -1), (1, 0), (0, 1)]\n\nCURSOR_SIZE = 20\n\ndef slide(tile, row, col, x, y):\n tile.onclick(None) # disable handler inside handler\n\n for dy, dx in OFFSETS:\n try:\n if row + dy >= 0 <= col + dx and matrix[row + dy][col + dx] is None:\n matrix[row][col] = None\n row, col = row + dy, col + dx\n matrix[row][col] = tile\n x, y = tile.position()\n tile.setposition(x + dx * TILE_SIZE, y - dy * TILE_SIZE)\n break\n except IndexError:\n pass\n\n tile.onclick(partial(slide, tile, row, col))\n\nscreen = Screen()\n\nmatrix = [[None for _ in range(SIZE)] for _ in range(SIZE)]\n\noffset = TILE_SIZE * 1.5\n\nfor row in range(SIZE):\n for col in range(SIZE):\n if row == SIZE - 1 == col:\n break\n\n tile = Turtle('square', visible=False)\n tile.shapesize(TILE_SIZE / CURSOR_SIZE)\n tile.fillcolor(random(), random(), random())\n tile.penup()\n tile.goto(col * TILE_SIZE - offset, offset - row * TILE_SIZE)\n tile.onclick(partial(slide, tile, row, col))\n tile.showturtle()\n\n matrix[row][col] = tile\n\nscreen.mainloop()\n\nClick on a tile next to the blank space to have it move into that space:\n\n" ]

[ 0 ]

[]

[]

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

[ "To encrypt the ASCII code of each symbol in the message using a Caesar cipher, you will need to modify the code as follows:\nReplace the LETTERS string with a string containing all the ASCII characters that you want to encrypt. For example, you could use the string string.printable from the string module, which includes all the ASCII characters that are considered printable, including digits, letters, and punctuation marks.\nIn the for loop that iterates over each symbol in the message, use the ord() function to convert the symbol to its ASCII code, and the chr() function to convert the encrypted or decrypted ASCII code back to a character.\nHere is an example of how you could modify the code to encrypt the ASCII code of each symbol in the message using a Caesar cipher:\nimport string\nimport pyperclip\n\n# the string to be encrypted/decrypted\nmessage = 'This is my secret message.'\n# the encryption/decryption key\nkey = 13\n\n# tells the program to encrypt or decrypt\nmode = 'encrypt' # set to 'encrypt' or 'decrypt'\n# every possible ASCII character that can be encrypted\nLETTERS = string.printable\n\n# stores the encrypted/decrypted form of the message\ntranslated = ''\n\n# run the encryption/decryption code on each symbol in the message string\nfor symbol in message:\n # get the ASCII code of the symbol\n ascii_code = ord(symbol)\n if ascii_code in range(len(LETTERS)):\n # get the encrypted (or decrypted) ASCII code for this symbol\n if mode == 'encrypt':\n ascii_code = ascii_code + key\n elif mode == 'decrypt':\n ascii_code = ascii_code - key\n\n # handle the wrap-around if the ASCII code is out of range\n if ascii_code >= len(LETTERS):\n ascii_code = ascii_code - len(LETTERS)\n elif ascii_code < 0:\n ascii_code = ascii_code + len(LETTERS)\n\n # add the encrypted/decrypted character to the translated string\n translated = translated + chr(ascii_code)\n\n else:\n # just add the character without encrypting/decrypting\n translated = translated + symbol\n\n# print the encrypted/decrypted string to the screen\nprint(translated)\n\n# copy the encrypted/decrypted string to the clipboard\npyperclip.copy(translated)\n\nThis code should encrypt the ASCII code of each symbol in the message using a Caesar cipher and print the encrypted message to the screen. The encrypted message will also be copied to the clipboard.\n" ]

[ 1 ]

[]

[]

[ "python" ]

[ "instead of a for loop. Using the NumPy minimum and sum functions, you can compute the desired matrix output as follows:\noutput = np.sum(np.minimum(A[:, None], A), axis=2)\n\n" ]

[ 0 ]

[]

[]

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

[ "Does this do what you want? It's not clear what the conversion requirements are, but this matches your target strings:\nimport re\n\nline = \"thiêu (30:33). chương 36-37 ghi lại tất cả những 2:6 việc này đã thật sự xảyra như thế nào (37:36-38).\"\nwant1 = 'thiêu (30:33). chương 36-37 ghi lại tất cả những 2:6 việc này đã thật sự xảyra như thế nào (37:36-38\\index[KT]{?@?!037|036 @37:36-38}).'\nwant2 = 'thiêu (30:33\\index[KT]{?@?!030|033 @30:33}). chương 36-37 ghi lại tất cả những 2:6\\index[KT]{?@?!02|06 @2:6} việc này đã thật sự xảyra như thế nào (37:36-38\\index[KT]{?@?!037|036 @37:36-38}).'\n\nline1 = re.sub(r'(\\d+):(\\d+)-(\\d+)', r'\\1:\\2-\\3\\\\index[KT]{?@?!0\\1|0\\2 @\\1:\\2-\\3}', line)\nprint(line1)\nassert line1 == want1\nline2 = re.sub(r'(\\d+):((\\d+)(?:-\\d+)?)', r'\\1:\\2\\\\index[KT]{?@?!0\\1|0\\3 @\\1:\\2}', line)\nprint(line2)\nassert line2 == want2\n\nOutput:\nthiêu (30:33). chương 36-37 ghi lại tất cả những 2:6 việc này đã thật sự xảyra như thế nào (37:36-38\\index[KT]{?@?!037|036 @37:36-38}).\nthiêu (30:33\\index[KT]{?@?!030|033 @30:33}). chương 36-37 ghi lại tất cả những 2:6\\index[KT]{?@?!02|06 @2:6} việc này đã thật sự xảyra như thế nào (37:36-38\\index[KT]{?@?!037|036 @37:36-38}).\n\n" ]

[ 0 ]

[]

[]

[ "python", "regex" ]

[]

[]

[ "It looks like the problem is that the image array is being saved in a text file as an array of strings rather than an array of integers. When you read the text file and convert it back into an array, the values are being interpreted as strings, resulting in the wrong colors when the image is displayed.\nOne solution to this problem is to save the array in the text file as an array of integers rather than an array of strings. You can do this by using the numpy.savetxt() function, which saves an array to a text file in a specified format. Here is an example of how you could modify your code to save the array as integers in the text file:\nimport cv2\nimport sys\nimport numpy\nfrom PIL import Image\n\nnumpy.set_printoptions(threshold=sys.maxsize)\n\ndef img_to_txt_array(img):\n image = cv2.imread(img)\n # Save the array as integers in the text file\n numpy.savetxt('img_array.txt', image, fmt='%d')\n\ndef show_imagem(array):\n # Create a NumPy array from the text file\n arry = numpy.loadtxt('img_array.txt', dtype=int)\n \n # Create a PIL image from the NumPy array\n image = Image.fromarray(arry.astype('uint8'), 'RGB')\n \n # Save the image\n #image.save('image.jpg')\n \n # Show the image\n image.show(image)\n\narray = [] #paste here the txt\n\nimg_to_txt_array('mickey.png')\nshow_imagem(array)\n\nIn this code, the img_to_txt_array() function saves the image array as integers in the text file using the numpy.savetxt() function. The show_imagem() function reads the array from the text file using the numpy.loadtxt() function, and then creates and displays the image from the array. This should fix the problem of the wrong colors in the image.\n" ]

[ -1 ]

[ "numpy", "python", "python_3.x", "python_imaging_library" ]

[ "If you can make \"everyone\" to install using my ffmpeg-downloader then all of you can install FFmpeg by:\npip install ffmpeg-downloader\nffdl install\n\nThen in Python your package could use\nimport ffmpeg_downloader as ffdl\n\nsp.run([ffdl.ffmpeg_path, '-i', 'input.mp4', 'output.mkv'])\n\nAlternately, you can use static-ffmpeg to (dynamically) install FFmpeg to Lib/site-package. (See the linked GitHub page for howto.)\n" ]

[ 0 ]

[]

[]

[ "ffmpeg", "python", "shutil", "subprocess" ]

[ "As mentioned in the message you've received after trying plt.legend(), the function is looking for labels. So, let's supply them inside plt.plot by setting the label parameter.\nWe can use enumerate to get index values for the dfs in your list dframes as well, to be used inside the f-strings.\ndframes = [df1, df2, df3]\nfor i, frame in enumerate(dframes):\n frame[\"C\"] = frame[\"A\"] + frame[\"B\"]\n plt.plot(frame[\"C\"], label=f'df{i+1}') # setting the label: `df1`, `df2`, `df3`\n \nplt.legend() # or `plt.legend(bbox_to_anchor=[1,1])` to move it outside of the plot\nplt.show()\n\nResult\n\n\nUpdate. Example using a dict and using the keys for the labels:\ndframes = {'ll_800': df1, 'll_600wo_200': df2, 'wo_800': df3}\nfor k, v in dframes.items():\n v[\"C\"] = v[\"A\"] + v[\"B\"]\n plt.plot(v[\"C\"], label=k)\nplt.legend(bbox_to_anchor=[1,1])\nplt.show()\n\nResult\n\n" ]

[ 1 ]

[]

[]

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

[ "That Select element is hidden and can't be used by Selenium as we use normal Select elements to select drop-down menu items.\nHere we need to open the drop-down as we open any other elements by clicking them, select the desired options and click the Search button.\nSo, these lines are opening that drop down and selecting 2 options in the drop-down menu:\nwait.until(EC.element_to_be_clickable((By.XPATH, \"//div[@class='form-group'][contains(.,'Category')]//div[@class='dropdown-display-label']\"))).click()\nwait.until(EC.element_to_be_clickable((By.XPATH, \"//div[@class='form-group'][contains(.,'Category')]//li[@data-value='23']\"))).click()\nwait.until(EC.element_to_be_clickable((By.XPATH, \"//div[@class='form-group'][contains(.,'Category')]//li[@data-value='1']\"))).click()\n\nThe result so far is:\n\nAnd by finally clicking the Search button the result is:\n\nThe entire code is:\nfrom selenium import webdriver\nfrom selenium.webdriver.chrome.service import Service\nfrom selenium.webdriver.chrome.options import Options\nfrom selenium.webdriver.support.ui import WebDriverWait\nfrom selenium.webdriver.common.by import By\nfrom selenium.webdriver.support import expected_conditions as EC\noptions = Options()\noptions.add_argument(\"start-maximized\")\n\nwebdriver_service = Service('C:\\webdrivers\\chromedriver.exe')\ndriver = webdriver.Chrome(service=webdriver_service, options=options)\nwait = WebDriverWait(driver, 20)\n\nurl = \"https://channelcrawler.com/\"\n\ndriver.get(url)\n\nwait.until(EC.element_to_be_clickable((By.XPATH, \"//div[@class='form-group'][contains(.,'Category')]//div[@class='dropdown-display-label']\"))).click()\nwait.until(EC.element_to_be_clickable((By.XPATH, \"//div[@class='form-group'][contains(.,'Category')]//li[@data-value='23']\"))).click()\nwait.until(EC.element_to_be_clickable((By.XPATH, \"//div[@class='form-group'][contains(.,'Category')]//li[@data-value='1']\"))).click()\nwait.until(EC.element_to_be_clickable((By.CSS_SELECTOR, \"button[type='submit']\"))).click()\n\n" ]

[ 2 ]

[]

[]

[ "drop_down_menu", "python", "select", "selenium", "xpath" ]

[ "Since you didn't provide all your code, I can't test this, so I'm guessing a good start would be changing this:\nself.turtle = turtle.RawTurtle(turtle.TurtleScreen(self.canvas))\n\nto something like:\nscreen = turtle.TurtleScreen(self.canvas)\nscreen.tracer(False)\nself.turtle = turtle.RawTurtle(screen)\n\n" ]

[ 0 ]

[]

[]

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

[ "if str(message.chat.id) not in chat_mapping\nin this lane, your statement will check if message.chat.id is equal one of the keys of dictionary, not values.\nMeans your message.chat.id can't be 123 or 321.\nUSER_ID = some id\nchat_mapping = [some ids] \n@app.on_message()\ndef my_handler(client, message):\n if str(message.chat.id) not in chat_mapping:\n return\n elif str(message.chat.id) == USER_ID:\n storeMsg(message)\n else:\n print(message.text)\n\napp.run()\n\n" ]

[ 0 ]

[]

[]

[ "pyrogram", "python" ]

[ "No need for an if.. else statement here. You can use numpy.where instead.\n\nnumpy.where(condition, [x, y, ]/)\n\nReplace this :\nif df[df['HIST_60_100'] > df['HIST_60_100'].shift(+1)]: # check if the valus is > previous row value\n df['COLOR-60-100'] = \"GREEN\"\nelse:\n df['COLOR-60-100'] = \"RED\"\n\nBy this :\ndf['COLOR-60-100'] = np.where(df['HIST_60_100'].gt(df['HIST_60_100'].shift(1), \"GREEN\", \"RED\")\n\n" ]

[ 0 ]

[]

[]

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

[ "You could use pandas to import the csv files, combine the two, and then overwrite the original mainfile.csv.\nI have created some dummy data to demonstrate. Here are the test files that I used:\nmainfile.csv\nFruit,Animals,Numbers\nApple,Cat,5\nBanana,Dog,8\nCherry,Goat,2\nDurian,Horse,4\n\nfilewith1row.csv\nFruta,Animales,Números\n\n\nThis is the code that I used to combine the two CSVs.\nCode:\nimport pandas as pd\n\nmainfile = pd.read_csv('mainfile.csv', header=None)\none_liner = pd.read_csv('filewith1row.csv', header=None)\n\nmainfile.loc[0.5]=one_liner.loc[0]\nmainfile = mainfile.sort_index() \nmainfile.to_csv('mainfile.csv', index=False, header=False)\n\nOutput:\nmainfile.csv\nFruit,Animals,Numbers\nFruta,Animales,Números\nApple,Cat,5\nBanana,Dog,8\nCherry,Goat,2\nDurian,Horse,4\n\n", "Combine the two files into a new one.\ncat hdr.csv \nfirst_col,second_col,third_col\n\ncat data.csv \n1,2,3\n4,5,6\n7,8,9\n\n\nwith open('new_file.csv', 'w') as new_file:\n with open('hdr.csv') as hdr_file:\n new_file.write(hdr_file.read())\n with open('data.csv') as data_file:\n new_file.write(data_file.read())\n\ncat new_file.csv \nfirst_col,second_col,third_col\n1,2,3\n4,5,6\n7,8,9\n\n\n\n" ]

[ 1, 0 ]

[]

[]

[ "append", "csv", "python", "row" ]

[ "# Consider the input as an int\nindata = input('Enter Ur Number: ')\n\nfor x in indata: print(DictN.get(x,'!'))\n\n", "a dict works like this:\n# the alphabetical letters are the keys, and the numbers are the values which belong to the keys\na = {'a': 1, 'b': 2}\n\n# if you want to have value from a it would be \nprint(a.get('a'))\n# or\nprint(a['a'])\n\n# which is in your example:\nDictN= {\n '1':'one',\n '2':'two',\n '3':'three'\n}\nInpN = input('Enter Ur Number: ')\nprint(DictN[InpN])\n\nin your example you could do something like this\nDictN= {\n '1':'one',\n '2':'two',\n '3':'three'\n}\nInpN = input('Enter Ur Number: ')\nfor i in InpN:\n print(InpN[i], '!')\n\nby the way you would not use these variable names in Python. This source is good for best practices:\nhttps://peps.python.org/pep-0008/\nhttps://python-reference.readthedocs.io/en/latest/docs/dict/get.html\n", "The solution to your problem can be programmed pretty much exactly how it's written in english, like this:\nDictN = {\n '1':'one',\n '2':'two',\n '3':'three'\n}\nInpN = input('Enter Ur Number: ')\n\nfor i in InpN:\n if i in DictN:\n print(DictN[i])\n else:\n print(\"!\")\n\ngerrel93 explained how to retrieve data from a dictionary, and for many methods regarding iterables (objects such as strings and lists), dictionaries are treated as a list of their keys. The in keyword is one example of this.\n", "Since the other answers already show you how to use a dictionary, thought I'd demonstrate an alternative way of solving your problem. Would have written this as a comment, but I don't have enough reputation :)\nThe hope is that this helps you learn about iterators and some neat builtins\ninp = input(\"Enter Ur Number: \")\n\nwords = [\"one\", \"two\", \"three\"]\ndict_n = dict(zip(range(1, len(words) + 1), words))\nprint(\" \".join([dict_n.get(int(n), \"!\") for n in inp]))\n\nBreaking it down\n>>> range(1, len(words)) # iterator\nrange(1, 3)\n\n>>> dict(zip([1,2,3], [4,5,6])) # eg: zip elements of two iterators\n{1: 4, 2: 5, 3: 6}\n\n>>> dict(zip(range(1, len(words)), words))\n{1: 'one', 2: 'two'}\n\n>>> [n for n in range(3)] # list comprehension\n[0, 1, 2]\n\n>>> \" \".join([\"1\", \"2\", \"3\"])\n'1 2 3'\n\nHope the above block helps break it down :)\n", "The problem with your code is that you loop over the dictionary, and then check whether a certain value is in the input. You should do this in the reverse way: Loop over the input and then check whether aech digit is in the dictionary:\nDictN= {\n '1':'one',\n '2':'two',\n '3':'three'\n}\nInpN = input('Enter Ur Number: ')\n\nfor digit in InpN:\n if digit in DictN:\n print(DictN[digit], end=\" \")\n else:\n print(\"!\", end=\" \")\nprint(\"\")\n\nThe output is the following:\nEnter Ur Number: 12345\none two three ! ! \n\nSo, first we define the dictionary DicN and receive the input in InpN exactly as you did. Then we loop over the string we received as input. We do this because we want to print a single character for each digit. In the loop, we check for each digit whether it is in the dictionary. If it is, then we retreive the correct word from the dictionary. If it isn't, then we print !.\nDo also note that I used end=\" \" in the prints. This is because otherwise every word or ! would be printed on a new line. The end argument of the print function determines what value is added after the printed string. By default this is \"\\n\", a newline. That's why I changed it to a space. But this does also mean that we have to place print() after the code, because otherwise the following print call would print its text on the same line.\n", "Alternative using map:\nDictN={'1':'one','2':'two','3':'three'}\nprint(*map(lambda i:DictN.get(i,'!'),input('Enter Ur Number: ')),sep=' ')\n\n# Enter Ur Number: 12345\n# one two three ! !\n\n" ]

[ 2, 0, 0, 0, 0, 0 ]

[]

[]

[ "python", "python_3.x" ]

[ "The error you received caused by a space before the class name value.\nSpaces between class names are used to separate between multiple class names.\nSo, to use this specific class name you could try this (without the space):\ndriver.find_element(By.CLASS_NAME, \"css-47sehv\").click()\n\nBut css-47sehv seems to be a dynamically generated class name so I'd advice to use more fixed attribute for locating that element.\nTry this locator instead:\ndriver.find_element(By.XPATH, \"//button[contains(.,'AGREE')]\").click()\n\nTo give you better answer we need to see that web page and all your Selenium code\n", "Try to use By.CSS_SELECTOR. Find element and copy its selector\n" ]

[ 1, 0 ]

[]

[]

[ "css_selectors", "python", "selenium_chromedriver", "selenium_webdriver", "xpath" ]

[ "you can use CBVs to easily save data on form valid\n\nviews.py\n\nfrom django.views import generic\n\nclass ContactCreateView(generic.CreateView,):\n model = Contact\n fields = \"__all__\" \n success_url = reverse_lazy(url_name)\n\nthen in in your templates\n\ntemplates/contact_form.html\n\n\n<form action=\"{% url 'contact' %}\" id=\"contactform\" method=\"post\">\n {% csrf_token %}\n {% for formfield in form %}\n <div class=\"col-md-6 col-lg-6\">\n <div class=\"form_block\">\n {{ formfield}}\n {% for error in formfield.errors %}\n <p class=\"text-danger\">{{ error }}</p>\n {% endfor %}\n </div>\n </div>\n#add submit button here\n\n\n\nurls.py\njust remember to add as_view() when calling your view in url\n\n path(\"\", views.ContactCreateView.as_view(), name=\"contact\"),\n\nor using FBV you could try:\ndef contact_us(request):\n contact_form = ContactForm(request.POST or None)\n if contact_form.is_valid():\n contact_form.save()\n \n \n context = {\n 'form': contact_form\n }\n\n return render(request, 'contact_us/contact_us.html', context)\n\n\n\n", "Remove these lines from your forms.py:\n def __init__(self, *args, **kwargs):\n super(ContactForm, self).__init__()\n for visible in self.visible_fields():\n visible.field.widget.attrs['class'] = 'form_field require'\n\nFix your view based on documentation:\ndef contact_us(request):\n if request.method == 'POST':\n contact_form = ContactForm(request.POST)\n if contact_form.is_valid():\n ContactUs.objects.create(**contact_form.cleaned_data)\n messages.success(request, 'My success message')\n # you want to send to your home\n return redirect('/contact')\n\n else:\n contact_form = ContactForm()\n context = {\n 'form': contact_form\n }\n\n return render(request, 'contact_us.html', context)\n\nI took the liberty to clean up your view by using **kwargs since you have many fields. Used Django messages to display successful message on obj creation. Here is how to display it.\n" ]

[ 0, 0 ]

[]

[]

[ "django", "python" ]

[ "This is not an answer to the question yet.\nIt is a suggestion on how to monitor state changes for the files, since that\nseems to be the main issue.\nAdded code to create the initial files.\nAdded a function to be called before and after desired state changes.\n# Initialize the files\nprint('*' * 20, 'passwords.txt', '*' * 20)\nwith open('passwords.txt','w') as f:\n header = '*' * 20 + 'passwords.txt' + '*' * 20\n f.write(header)\nwith open('usernames.txt','w') as f:\n header = '*' * 20 + 'usernames.txt' + '*' * 20\n f.write(header)\n\n\ndef report_files():\n \"\"\"This function is used to look at the files before and after change\"\"\"\n with open('passwords.txt') as f:\n print(f.readlines())\n with open('usernames.txt') as f:\n print(f.readlines())\n\n\ndef login():\n createusername = ''\n createuserpass = ''\n\n with open('password.txt') as f:\n passfile = [(passfile.strip()) for passfile in f.readlines()]\n\n with open('username.txt') as g:\n userpass = [(userpass.strip()) for userpass in g.readlines()]\n\n def createnewusername():\n createusername = input(\"Enter a new username: \")\n return createusername\n\n def createuserpassword():\n createuserpass = input(\"Enter a new password: \")\n return createuserpass\n\n haveusername = input(\n \"Do you have a login? Enter yes for yes, Enter no for no: \")\n if haveusername == \"yes\":\n username = input(\"Enter your username: \")\n password = input(\"Enter your password: \")\n report_files() # monitor state\n if username in userpass:\n if password in passfile:\n print(\n \"Login in succesful. \"\"Logged into the account: \" + username)\n else:\n print(\"incorrect password - restarting\")\n login()\n else:\n print(\"incorrect username - restarting\")\n login()\n elif haveusername == \"no\":\n wantlogin = input(\n \"Do you want to create a login? Enter yes for yes, Enter no for no: \")\n if wantlogin == \"yes\":\n report_files()\n print(userpass)\n if createusername in userpass:\n print(\"This username already exists - restarting\")\n login()\n else:\n createuserpassword()\n if createuserpass in passfile:\n print(\"This password already exists - restarting\")\n login()\n else:\n # Start of part that doesnt work\n with open(\"password.txt\", \"a\") as passcreation:\n passcreation.write(createuserpass)\n passcreation.write('\\n')\n with open(\"username.txt\", \"a\") as namecreation:\n namecreation.write(createusername)\n namecreation.write('\\n')\n # End of part that doesnt work\n print(\"Restarting - Please enter your new login\")\n login()\n report_files()\n createnewusername()\n elif wantlogin == \"no\":\n print(\"Okay - restarting\")\n login()\n else:\n print(\"Login not created - restarting\")\n login()\n else:\n print(\"Invalid input - restarting\")\n\n\ntest = 1\nif test == 1:\n login()\n\n" ]

[ 0 ]

[]

[]

[ "passwords", "python", "text_files" ]

[ "I went about it a different way . turns out the pre element can be predictable in length.\nimport pandas as pd\nimport requests\nfrom bs4 import BeautifulSoup as bs\n \nr = requests.get('LINK')\nsoup = bs(r.content, 'lxml')\npre = soup.select_one('pre').text\nresults = []\n \nfor line in pre.split('\\n')[1:-1]:\n if '--' not in line:\n row = [line[i:i+20].strip() for i in range(0, len(line), 22)]\n results.append(row)\n \n df = pd.DataFrame(results)\n print(df)\n\n" ]

[ 0 ]

[]

[]

[ "mysql", "pandas", "parsing", "python", "selenium" ]

[ "I had the same problem on Linux. Solved it by invalidating caches as suggested here:\nhttps://stackoverflow.com/a/45099651/3990607\nIn pycharm click on File menu, then choose Invalidate caches..., tick all 4 boxes and then restart PyCharm. Solved the problem for me.\n", "Dealt with the same issue despite using python and pycharm without issue for months. Recently kept giving me the error despite changing the PATH variable of my system and even manually pathing within pycharm. After hours of reinstalling pycharm, python and even jumping around versions with no success it turned out it was because my python directory had a space in it that it just randomly decided to break.\nFor anyone who has tried what seems like everything to no avail ensure that NO part of the path to your python directory contains spaces\n", "Had the same issue just today. I was able to resolve it by uninstalling python 3.10.1 and then reinstalling it under directory \"C:/Program Files\" instead of the default directory where it goes.\nThere are many other fixes also suggested by people all over the internet such as:\n\nInstalling an older version of Pycharm i.e. 2021.2\nAllowing the pycharmProjects folder in windows defender\n\nBut the change of installation directory is what worked for me.\n", "Python 3.10 version installed through windows store didn't have any spaces in default directory names (as my username doesn't have a space within itself).\nI id invalidated caches through the file menu. However, patapouf_ai had suggested doing it for Linux.\nThe problem was resolved for me after installing and then reinstalling it through windows' remove and store, and it seems it's been caused by changing windows' user account control level to \"never notify.\" The other possibility is that somehow python 3.10 has stopped functioning without a good reason and lost recognition by windows (not updated or modified by any means).\n", "using IDLE\nimport sys\nprint(sys.executable)\n#output is a path to where the interpreter is, copy path\nPyCharm / file / settings / Project / Python Interpreter / show all / paste path\n", "I had the same issue. I got around it by installing an older version of PyCharm.\n", "Check if your python executable is named python.exe!\nI had the same problem and I solved it by going into C:\\Users<user>\\AppData\\Local\\Programs\\Python\\Python310. My python executable was named python3.exe, but Pycharm needs python.exe for some unknown reason. So I\n\ncopied python3.exe,\npasted it in the same directory and\nrenamed it to python.exe, and all started working magically. Maybe just renaming will also work.\n\n", "I had this same error on windows, none of the answers in this thread worked.\nBut i found a solution so i will share it.\nGo to %appdata%/Jetbrains/ and search for jdk.table, backup the file and delete it (this will delete all your interpreters configs) close all your pycharm instances, and start them again. After that just add your interpreter like you normally would.\nThis is what worked for me.\n" ]

[ 7, 4, 0, 0, 0, 0, 0, 0 ]

[ "on Pycharm, click on up right corner search button --> wrire swştch python interpreter --> add new interpreter --> add local interpreter --> hit OK\n" ]

[ -1 ]

[ "pycharm", "python" ]

[ "cat car.csv \n12,life,car,good,exellent\n10,gift,truck,great,great\n11,time,car,great,perfect\n\nimport csv\n\nwith open('car.csv') as car_file:\n r = csv.reader(car_file)\n with open('out.csv', 'w') as out_file:\n w = csv.writer(out_file)\n for row in r:\n w.writerow([row[2]])\n\ncat out.csv \ncar\ntruck\ncar\n\n\n\n\n" ]

[ 0 ]

[]

[]

[ "csv", "python" ]

[ "You should use pandas.Series.tolist (that returns a list) instead of pandas.Series.items (that returns an iterable).\nReplace this :\nif(spec_symbol == (a for a in df['Symbol'].items())):\n\nBy this :\nif(spec_symbol == (a for a in df['Symbol'].tolist())):\n\nOr simply :\nif spec_symbol in df['Symbol'].tolist():\n\n" ]

[ 0 ]

[]

[]

[ "pandas", "python", "streamlit" ]

[ "Is it important that you read your Excel file line-by-line? Or is it also okay for you to read the entirety of your Excel file into a Dataframe and just iterate through that?\n", "since you're new to programming, a good counsel I can give is to read and search the documentation when doubts first appear.\nMany tools even have tutorials to help you start coding and search to help you find basic code.\nCheck this link, I think it will help a lot!\nhttps://pandas.pydata.org/docs/getting_started/intro_tutorials/02_read_write.html?highlight=read%20excel\n" ]

[ 0, 0 ]

[]

[]

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

[ "One way are regular expressions:\nimport re\n\nrace = \"The rabbit will run with the turtle in the race.\"\n\nm = re.match(r'([^r]*r)(.*)(r[^r]*)$', race)\n\nresult1 = m.group(1) + m.group(2).replace('r', 'R') + m.group(3)\n\nprint(result1)\n\n" ]

[ 0 ]

[]

[]

[ "python" ]

[ "Assuming that your \"hidden signs\" always contain two characters, simply create new columns containing these prefixes:\ndf['Prefix'] = df['Product'].str[:2]\n\nYou may then group by prefix:\ndf.groupby('Prefix').sum()\n\n", "Here is a proposition using pandas.Series.str.extract :\nout = (\n df\n .assign(Signs= df[\"Product\"].str.extract(\"(P\\d)\", expand=False))\n .groupby(\"Signs\", as_index=False)[\"Price\"].sum()\n .sort_values(by=\"Price\", ascending=False, ignore_index=True)\n )\n\n# Output :\nprint(out)\n\n Signs Price\n0 P2 5210\n1 P3 3550\n2 P1 2600\n\n" ]

[ 0, 0 ]

[]

[]

[ "group_by", "pandas", "python" ]

[ "You're trying to make a list within your list-comprehension; you can just use the existing list:\nreturn \"\".join([char for char in x if char not in \"aeiouAEIOU\"])\n\nNote that we could even omit the list comprehension and just use a generator expression (by omitting the square brackets), but join() works internally by converting the sequence to a list anyway, so in this case using a list-comprehension is actually quicker.\n", "def disemvowel(string_):\n vowels = 'a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'\n for a in vowels:\n string_ = string_.replace(a, '')\n return string_\n\n", "I did in one liner but I don't know it's the correct way, although it is working and have passed all the tests. Any guidance is appreciated. Thanks.\ndef disemvowel(string_):\n return string_.replace('a','').replace('e','').replace('i','').replace('o','').replace('u','').replace('A','').replace('E','').replace('I','').replace('O','').replace('U','')\n\n" ]

[ 4, 0, 0 ]

[]

[]

[ "list", "list_comprehension", "python", "python_3.x", "string" ]

[ "Your solution looks pretty complicated. Why not do something like:\ndata = \"\"\"2-4,6-8\n2-3,4-5\n5-7,7-9\n2-8,3-7\n6-6,4-6\n2-6,4-8\n\"\"\"\n\ndef included(line):\n (a1, b1), (a2, b2) = (map(int, pair.split(\"-\")) for pair in line.strip().split(\",\"))\n return (a1 <= a2 and b2 <= b1) or (a2 <= a1 and b1 <= b2)\n\nprint(sum(included(line) for line in data.splitlines()))\n\nI did some timing with my AoC-input for day 4 (1,000 lines):\nfrom timeit import timeit\n\n# Extract the interval boundaries for the pairs\nboundaries = [\n [tuple(map(int, pair.split(\"-\"))) for pair in line.strip().split(\",\")]\n for line in data.splitlines()\n]\n\n# Version 1 with simple comparison of boundaries\ndef test1(boundaries):\n def included(pairs):\n (a1, b1), (a2, b2) = pairs\n return (a1 <= a2 and b2 <= b1) or (a2 <= a1 and b1 <= b2)\n \n return sum(included(pairs) for pairs in boundaries)\n\n# Version 2 with range-subset test\ndef test2(boundaries):\n def included(pairs):\n (a1, b1), (a2, b2) = pairs\n numbers1, numbers2 = set(range(a1, b1 + 1)), set(range(a2, b2 + 1))\n return numbers1 <= numbers2 or numbers2 <= numbers1\n \n return sum(included(pairs) for pairs in boundaries)\n\n# Test for identical result\nprint(test1(boundaries) == test2(boundaries))\n\n# Timing\nfor i in 1, 2:\n t = timeit(f\"test{i}(boundaries)\", globals=globals(), number=1_000)\n print(f\"Duration version {i}: {t:.1f} seconds\")\n\nResult here, on a mediocre machine (repl.it):\nDuration version 1: 0.4 seconds\nDuration version 2: 5.4 seconds\n\n", "You're prob. making it overcomplicated in the current approach. If you split the pairs to two sets - eg. a, and b then you could easily do a set ops. to check if there is overlapping. That should be faster than yours.\nSomething like this one-line:\n # some input reading, and split to a, b sets.\n # count = 0\n\n if set(range(a, b + 1)) & set(range(x, y + 1)):\n count += 1 # that's part1 answer.\n\n\n# part 2\nfor line in open('04.in'):\n a, b, x, y = map(int, line.replace(\",\", \"-\").split(\"-\"))\n if set(range(a, b + 1)) & set(range(x, y + 1)):\n ans += 1\n\nThere are questions about the memory efficiency about this approach earlier, I've run some profiling and this is the result to share - it's confirmed there should be NO problem given this puzzle's input size.\nFilename: day04.py\n\nLine # Mem usage Increment Occurrences Line Contents\n=============================================================\n 27 43.758 MiB 43.758 MiB 1 @profile\n 28 def part2(file):\n 29 43.762 MiB 0.004 MiB 1 ans = 0\n 30\n 31 43.770 MiB 0.000 MiB 1001 for line in open(file):\n 32 43.770 MiB 0.004 MiB 1000 a, b, x, y = map(int, line.replace(\",\", \"-\").split(\"-\"))\n 33 43.770 MiB 0.000 MiB 1000 if set(range(a, b + 1)) & set(range(x, y + 1)):\n 34 43.770 MiB 0.004 MiB 847 ans += 1\n 35\n 36 43.770 MiB 0.000 MiB 1 return ans\n\n" ]

[ 1, 0 ]

[]

[]

[ "python", "python_3.x" ]

[ "przycisk_0a is your callback function bind to the button0 button, so you must define your function, but you have defined the button0 button which is nonsense. \nIt must be like this:\ndef przycisk_0a():\n\n", "This changes the value of a and then changes the value of b the next time you press the button.\nfrom tkinter import *\n\nkalkulator = Tk()\n\na=0\nb=0\n\ndef button_0a():\n b=0\n return 0\n\ndef button_0a():\n a=0\n button0.configure(command = button_0b)\n return 0\n\nbutton0= Button(kalkulator, text=\"0\", command=button_0a)\n\nbutton0.grid(row=1, column=0)\n\nkalkulator.mainloop()\n\n" ]

[ 0, 0 ]

[]

[]

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

[ "You might need to try the technique of walking through your program and speaking it out loud.\nFor example, this is how I read your listing and how I can detect an issue.\n\nI create a new GoldenDog\nThe GoldenDog calls the super.__init\nThe super init calculates the cost based on the discount of zero\nI then run the rest of the GoldenDog.__init\nI set the discount to 0.10\n\nThe problem is you are setting the discount after the cost has been calculated.\nTo solve this, you ought to calculate the cost when a caller asks for the cost. That way, it will be able to use the current value of the discount (rather than only being able to use the discount that applied when created).\nAlternatively, you need to pass the discount to the super.__init call.\nclass Golden(Dog):\n def __init__(self, food, amount, cost, damage, discount=0):\n super().__init__(food, amount, cost, discount=-damage)\n self.damage = damage\n\nYour next task will be to fix the discount logic as it currently increases the price, rather than reducing it.\n" ]

[ 0 ]

[]

[]

[ "attributes", "class", "object", "oop", "python" ]

[ "Your seyrogus function needs to return a list rather than returning a single value. The reason you're only getting 4 as the result is that every time you call it, it iterates over numbers from the beginning and then returns the first converted value rather than iterating over the entire list.\nBoth getData and seyrogus can be implemented very simply as list comprehensions. You then need to iterate over both numbers and seyrogus(numbers) in parallel in displayData; an easy way of doing that is the zip function.\ndef getData():\n with open(\"numbers.csv\") as file:\n return [int(line.strip()) for line in file]\n\ndef seyrogus(numbers):\n return [n * 3 + 1 if n % 2 else n // 2 for n in numbers]\n\ndef displayData(numbers):\n print(\"Original Numbers \\t Converted Numbers\")\n for original, converted in zip(numbers, seyrogus(numbers)):\n print(f\"{original} \\t \\t \\t {converted}\")\n\ndef main():\n displayData(getData())\n\nmain()\n\nprints:\nOriginal Numbers Converted Numbers\n1 4\n2 1\n3 10\n4 2\n5 16\n6 3\n7 22\n8 4\n9 28\n10 5\n11 34\n\netc.\n" ]

[ 4 ]

[]

[]

[ "python" ]

[ "#qqe signal\n df[\"RSI_Period\"]=ta.rsi (df['close'],14)\n SF = 5\n QQE = 4.238\n ThreshHold = input(10, title=\"Thresh-hold\")\n\n src = df['close']\n Wilders_Period = df[\"RSI2\"] * 2 - 1\n\n Rsi = rsi(src, RSI_Period)\n RsiMa = ta.ema(Rsi, SF)\n AtrRsi = abs(RsiMa[1] - RsiMa)\n MaAtrRsi = ta.ema(AtrRsi, Wilders_Period)\n dar = ema(MaAtrRsi, Wilders_Period) * QQE\n\n longband = 0.0\n shortband = 0.0\n trend = 0\n\n DeltaFastAtrRsi = dar\n RSIndex = RsiMa\n newshortband = RSIndex + DeltaFastAtrRsi\n newlongband = RSIndex - DeltaFastAtrRsi\n if longband == RSIndex[-1] > longband[-1] and RSIndex > longband[-1] ? max(longband[-1], newlongband) : newlongband\n shortband == RSIndex[-1] < shortband[-1] and RSIndex < shortband[-1] ? min(shortband[-1], newshortband) : newshortband\n cross_1 = cross(longband[1], RSIndex)\n trend == cross(RSIndex, shortband[1]) ? 1 : cross_1 ? -1 : nz(trend[1], 1)\n FastAtrRsiTL = trend == 1 ? longband : shortband\n\n # Find all the QQE Crosses\n\n QQExlong = 0\n QQExlong == nz(QQExlong[-1])\n QQExshort = 0\n QQExshort == nz(QQExshort[-1])\n QQExlong == FastAtrRsiTL < RSIndex ? QQExlong + 1 : 0\n QQExshort == FastAtrRsiTL > RSIndex ? QQExshort + 1 : 0\n\n #Conditions\n\n qqeLong = QQExlong == 1 ? FastAtrRsiTL[-1] - 50 : na\n qqeShort = QQExshort == 1 ? FastAtrRsiTL[-1] - 50 : na\n \n\n? I couldn't find what to use instead.\n", "// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/\n// © blackcat1402\n//@version=4\n\nstudy(\"[blackcat] L3 Banker Fund Flow Trend Oscillator\", overlay=false)\n\n//functions\nxrf(values, length) =>\n r_val = float(na)\n if length >= 1\n for i = 0 to length by 1\n if na(r_val) or not na(values[i])\n r_val := values[i]\n r_val\n r_val\n\nxsa(src,len,wei) =>\n sumf = 0.0\n ma = 0.0\n out = 0.0\n sumf := nz(sumf[1]) - nz(src[len]) + src\n ma := na(src[len]) ? na : sumf/len\n out := na(out[1]) ? ma : (src*wei+out[1]*(len-wei))/len\n out\n \n//set up a simple model of banker fund flow trend \nfundtrend = ((3*xsa((close- lowest(low,27))/(highest(high,27)-lowest(low,27))*100,5,1)-2*xsa(xsa((close-lowest(low,27))/(highest(high,27)-lowest(low,27))*100,5,1),3,1)-50)*1.032+50)\n//define typical price for banker fund\ntyp = (2*close+high+low+open)/5\n//lowest low with mid term fib # 34\nlol = lowest(low,34)\n//highest high with mid term fib # 34\nhoh = highest(high,34)\n//define banker fund flow bull bear line\nbullbearline = ema((typ-lol)/(hoh-lol)*100,13)\n//define banker entry signal\nbankerentry = crossover(fundtrend,bullbearline) and bullbearline<25\n\n//banker fund entry with yellow candle\nplotcandle(0,50,0,50,color=bankerentry ? color.new(color.yellow,0):na)\n\n//banker increase position with green candle\nplotcandle(fundtrend,bullbearline,fundtrend,bullbearline,color=fundtrend>bullbearline ? color.new(color.green,0):na)\n\n//banker decrease position with white candle\nplotcandle(fundtrend,bullbearline,fundtrend,bullbearline,color=fundtrend<(xrf(fundtrend*0.95,1)) ? color.new(color.white,0):na)\n\n//banker fund exit/quit with red candle\nplotcandle(fundtrend,bullbearline,fundtrend,bullbearline,color=fundtrend<bullbearline ? color.new(color.red,0):na)\n\n//banker fund Weak rebound with blue candle\nplotcandle(fundtrend,bullbearline,fundtrend,bullbearline,color=fundtrend<bullbearline and fundtrend>(xrf(fundtrend*0.95,1)) ? color.new(color.blue,0):na)\n\n//overbought and oversold threshold lines\nh1 = hline(80,color=color.red, linestyle=hline.style_dotted)\nh2 = hline(20, color=color.yellow, linestyle=hline.style_dotted)\nh3 = hline(10,color=color.lime, linestyle=hline.style_dotted)\nh4 = hline(90, color=color.fuchsia, linestyle=hline.style_dotted)\nfill(h2,h3,color=color.yellow,transp=70)\nfill(h1,h4,color=color.fuchsia,transp=70)\n\nalertcondition(bankerentry, title='Alert on Yellow Candle', message='Yellow Candle!')\nalertcondition(fundtrend>bullbearline, title='Alert on Green Candle', message='Green Candle!')\nalertcondition(fundtrend<(xrf(fundtrend*0.95,1)), title='Alert on White Candle', message='White Candle!')\nalertcondition(fundtrend<bullbearline, title='Alert on Red Candle', message='Red Candle!')\nalertcondition(fundtrend<bullbearline and fundtrend>(xrf(fundtrend*0.95,1)), title='Alert on Blue Candle', message='Blue Candle!')\n\nCan you help me convert this to python?\n" ]

[ 0, 0 ]

[]

[]

[ "pine_script", "python", "tradingview_api" ]

[ "Start the loop\nwhile True:\n x=int(input(\"please type in any number: \"))\n y=input(\"please type operation: +,-,*,/: \")\n z=int(input(\"please type in your 2nd number: \"))\n if(y==\"+\"):\n print(\"your answer is: \", x+z)\n print(\"thanks for using this calculator!\")\n print(\"goodbye\")\n elif(y==\"-\"):\n print(\"your answer is: \", x-z)\n print(\"thanks for using this calculator!\")\n print(\"goodbye\")\n elif(y==\"*\"):\n print(\"your answer is: \", x*z)\n print(\"thanks for using this calculator!\")\n print(\"goodbye\")\n elif(y==\"/\"):\n print(\"your answer is: \", x/z)\n print(\"thanks for using this calculator!\")\n print(\"goodbye\")\n\n" ]

[ 0 ]

[]

[]

[ "python" ]

[ "I solved this storing in 2 database tables and comparing them after.\n" ]

[ 0 ]

[]

[]

[ "arrays", "mysql", "python", "sorting" ]

[ "For Tkinter you can just pass gen.quit to the command of a button widget, like so:\nclose = Button(gen, text = 'Close', command = gen.quit).pack()\n\n", "You can use sys.exit() to close the program.\nclose(gen, text=\"Close\", command = lambda: sys.exit()).pack()\n\n" ]

[ 0, 0 ]

[]

[]

[ "button", "python", "tkinter" ]

[ "Here's how you can parse some parts of it.\nimport pickle\nimport zlib\n\nfile = '4402905758116487.dat'\ncache_file = open(file, 'rb') # This can be improved to not keep the file opened.\n\n# Converting pickle items from python2 to python3 you need to use the \"bytes\" encoding or \"latin1\". \nlegacyBattleResultVersion, brAllDataRaw = pickle.load(cache_file, encoding='bytes', errors='ignore')\n\narenaUniqueID, brAccount, brVehicleRaw, brOtherDataRaw = brAllDataRaw\n\n# The data stored inside the pickled file will be a compressed pickle again. \nvehicle_data = pickle.loads(zlib.decompress(brVehicleRaw), encoding='latin1')\naccount_data = pickle.loads(zlib.decompress(brAccount), encoding='latin1')\nbrCommon, brPlayersInfo, brPlayersVehicle, brPlayersResult = pickle.loads(zlib.decompress(brOtherDataRaw), encoding='latin1')\n\n\n# Lastly you can print all of these and see a lot of data inside. \n\nThe response contains a mixture of more binary files as well as some data captured from the replays.\nThis is not a complete solution but it's a decent start to parsing these files.\n", "After loading the pickle files like gabzo mentioned, you will see that it is simply a list of values and without knowing what the value is referring to, its hard to make sense of it. The identifiers for the values can be extracted from your game installation:\nimport zipfile\n\nWOT_PKG_PATH = \"Your/Game/Path/res/packages/scripts.pkg\"\nBATTLE_RESULTS_PATH = \"scripts/common/battle_results/\"\n\narchive = zipfile.ZipFile(WOT_PKG_PATH, 'r')\n\nfor file in archive.namelist():\n if file.startswith(BATTLE_RESULTS_PATH):\n archive.extract(file)\n\nYou can then decompile the python files(uncompyle6) and then go through the code to see the identifiers for the values.\nOne thing to note is that the list of values for the main pickle objects (like brAccount from gabzo's code) always has a checksum as the first value. You can use this to check whether you have the right order and the correct identifiers for the values. The way these checksums are generated can be seen in the decompiled python files.\nI have been tackling this problem for some time and I have a solution that is works here (albeit in Rust): https://github.com/dacite/wot-battle-results-parser.\nRun ./wot_datfile_parser_cli --help after downloading the binary for options. Note that you can just run the binary without any options to get a folder of .json files for the .dat files currently in the cache folder\n", "First you can look at the replay file itself in a text editor. But it won't show the code at the beginning of the file that has to be cleaned out. Then there is a ton of info that you have to read in and figure out but it is the stats for each player in the game. THEN it comes to the part that has to do with the actual replay. You don't need that stuff.\nYou can grab the player IDs and tank IDs from WoT developer area API if you want.\n" ]

[ 0, 0, 0 ]

[]

[]

[ "python" ]

[ "Another way is to use numpy to stack the two dataframes and then use pd.DataFrame constructor:\npd.DataFrame(np.vstack([df1.values,df2.values]), columns = df1.columns)\n\nOutput:\n A B\n0 a b\n1 a b\n2 b a\n3 b a\n\n", "Here is a proposition to do an SQL UNION ALL with pandas by using pandas.concat :\nlist_dfs = [df1, df2]\n\nout = (\n pd.concat([pd.DataFrame(sub_df.to_numpy()) for sub_df in list_dfs], \n ignore_index=True)\n .set_axis(df1.columns, axis=1)\n )\n\n# Output :\nprint(out)\n\n A B\n0 a b\n1 a b\n2 b a\n3 b a\n\n" ]

[ 1, 0 ]

[]

[]

[ "pandas", "python" ]

[ "First, learn what \"real-time\" means. Wikipedia: https://en.wikipedia.org/wiki/Real-time_computing\nUnderstand the terms \"hard\" and \"soft\" real-time. Understand which aspects of your environment are soft and which require hard real-time.\nUnderstand the response times that your environment requires. Understand the time scales.\nThis does not involve fuzzy terms like \"quick\" or \"significant\" or \"accurate\". It involves actual quantifiable time spans that depend on your task and its environment, acceptable error rates, ...\nYou did not share any details about your environment. I find it unlikely that you even need 30 fps for any application involving a road intersection.\nYou only need enough frame rate so you don't miss objects of interest, and you have fine enough data to track multiple objects with identity without mistaking them for each other.\nExample: assume a car moving at 200 km/h. If your camera takes a frame every 1/30 second, the car moves 1.85 meters between frames.\n\nHow's your motion blur? What's the camera's exposure time? I'd recommend something on the order of a millisecond or better, giving motion blur of 0.05m\nHow's your tracking? Can it deal with objects \"jumping\" that far between frames? Does it generate object identity information that is usable for matching (association)?\n\n", "Real-time refers to the fact that a system is able to process and respond to data as it is received, without any significant delay. In the context of your object detection and tracking script, real-time would mean that the system is able to process and respond to new frames of the video as they are received, without a significant delay. This would allow the system to accurately count the objects in the video in near-real-time as the video is being played.\nIn the case of traffic lights management or lifting a bridge for a passing boat, real-time would mean that the system is able to quickly and accurately process data from sensors and other sources, and use that information to make decisions and take actions in a timely manner. This is important in these scenarios because any significant delay in processing and responding to data could have serious consequences, such as traffic accidents or collisions.\nOverall, real-time systems are designed to process and respond to data quickly and accurately, in order to support time-sensitive applications and scenarios.\n" ]

[ 1, 0 ]

[]

[]

[ "computer_vision", "object_detection", "object_tracking", "python", "real_time" ]

[ "http://docs.python.org/howto/unicode.html#the-unicode-type\nstr = unicode(str, errors='replace')\n\nor\nstr = unicode(str, errors='ignore')\n\nNote: This will strip out (ignore) the characters in question returning the string without them.\nFor me this is ideal case since I'm using it as protection against non-ASCII input which is not allowed by my application.\nAlternatively: Use the open method from the codecs module to read in the file:\nimport codecs\nwith codecs.open(file_name, 'r', encoding='utf-8',\n errors='ignore') as fdata:\n\n", "Changing the engine from C to Python did the trick for me.\nEngine is C:\npd.read_csv(gdp_path, sep='\\t', engine='c')\n\n\n'utf-8' codec can't decode byte 0x92 in position 18: invalid start byte\n\nEngine is Python:\npd.read_csv(gdp_path, sep='\\t', engine='python')\n\nNo errors for me.\n", "This type of issue crops up for me now that I've moved to Python 3. I had no idea Python 2 was simply steam rolling any issues with file encoding. \nI found this nice explanation of the differences and how to find a solution after none of the above worked for me. \nhttp://python-notes.curiousefficiency.org/en/latest/python3/text_file_processing.html\nIn short, to make Python 3 behave as similarly as possible to Python 2 use:\nwith open(filename, encoding=\"latin-1\") as datafile:\n # work on datafile here\n\nHowever, read the article, there is no one size fits all solution. \n", "the first,Using get_encoding_type to get the files type of encode:\nimport os \nfrom chardet import detect\n\n# get file encoding type\ndef get_encoding_type(file):\n with open(file, 'rb') as f:\n rawdata = f.read()\n return detect(rawdata)['encoding']\n\nthe second, opening the files with the type:\nopen(current_file, 'r', encoding = get_encoding_type, errors='ignore')\n\n", ">>> '\\x9c'.decode('cp1252')\nu'\\u0153'\n>>> print '\\x9c'.decode('cp1252')\nœ\n\n", "I had same problem with UnicodeDecodeError and i solved it with this line.\nDon't know if is the best way but it worked for me.\nstr = str.decode('unicode_escape').encode('utf-8')\n\n", "This solution works nice when using Latin American accents, such as 'ñ'.\nI have solved this problem just by adding\ndf = pd.read_csv(fileName,encoding='latin1')\n\n", "Just in case of someone has the same problem. I'am using vim with YouCompleteMe, failed to start ycmd with this error message, what I did is: export LC_CTYPE=\"en_US.UTF-8\", the problem is gone.\n", "What can you do if you need to make a change to a file, but don’t know the file’s encoding? If you know the encoding is ASCII-compatible and only want to examine or modify the ASCII parts, you can open the file with the surrogateescape error handler:\nwith open(fname, 'r', encoding=\"ascii\", errors=\"surrogateescape\") as f:\n data = f.read()\n\n", "If as you say you simply want to permit pure 7-bit ASCII, just discard any bytes which are not. There is no straightforward way to guess what the remote end intended them to represent anyway, without an explicitly specified encoding.\nwhile bytes := socket.read_line_bytes():\n try:\n string = bytes.decode('us-ascii')\n except UnicodeDecodeError as exc:\n logger.warning('[%s] - rejected non-ASCII input %s' % (client, bytes.decode('us-ascii', errors='backslashreplace'))\n socket.write(b'421 communication error - non-ASCII content rejected\\r\\n')\n continue\n ...\n\n", "I had the same error.\nFor me, Python complained about the byte \"0x87\". I looked it up on https://bytetool.web.app/en/ascii/code/0x87/ where it told me that this byte belong to the codec Windows-1252.\nI then only added this line to the beginning of my Python file:\n#-*- encoding: Windows-1252 -*-\"\n\nAnd all errors were gone. Before I had added this line, I had tried Pandas to import the file like this:\nDf = pd.read_csv(data, sep=\",\", engine='python', header=0, encoding='Windows-1252')\n\nbut this returned me an error. So I changed it back to this:\nDf = pd.read_csv(data, sep=\",\", engine='python', header=0)\n\n" ]

[ 420, 132, 76, 38, 37, 30, 18, 3, 2, 1, 0 ]

[ "\ndjango-storage is implicitly supported read byte file in text mode till django-storage == 1.8\nRemoved support in https://github.com/jschneier/django-storages/pull/657\nNeed to specify the binary mode for reading byte files.\n\n" ]

[ -1 ]

[ "linux", "python", "python_unicode" ]

[ "Try calculating the results after you input the data, not before that\n", "How I would do it\ndef get_input():\n print (\"How many U.S dollars can you afford to spend on your trip?: \")\n dollars = float(input())\n\n print(\"How many pounds of chocoloate will you be buying?:\")\n pounds = float(input())\n\n print(\"What is the tempature in degrees Celsius on the European news?:\")\n tempC = float(input())\n return [dollars, pounds, tempC]\n\ndef dollars_to_euros(dollars):\n return 0.95 * dollars\n\ndef pounds_to_kilograms(pounds):\n return pounds / 2.2\n\ndef tempC_to_tempF(tempC):\n return tempC * 9 / 5 + 32\n\nglobe = \"\\U0001F30D\"\n\n[dollars, pounds, tempC] = get_input()\n\n#move formula calculation after receiving the input\neuros = dollars_to_euros(dollars)\nkilograms = pounds_to_kilograms(pounds)\ntempF = tempC_to_tempF(tempC)\n\n\nprint (\"ITINERARY NOTES\")\nprint (\"------------------------------------------------------\")\n\nprint (globe + \" you have {:.2f} euros to spend.\" .format(euros))\nprint (globe + \" Plan to buy {:.2f} of chocolate for family and friends\".format(kilograms))\nprint (globe + \" The tempature in Europe is {} degrees F, So dress appropriately.\".format(tempF))\n\nMinimal changes to your existing snippet to make it work:\ndollars = 0\npounds = 0\ntempF = 0\ntempC = 0\nglobe = \"\\U0001F30D\"\n\n\nprint (\"How many U.S dollars can you afford to spend on your trip?: \")\ndollars = float(input())\n\nprint(\"How many pounds of chocoloate will you be buying?:\")\npounds = float(input())\n\nprint(\"What is the tempature in degrees Celsius on the European news?:\")\ntempC = float(input())\n\n#move formula calculation after receiving the input\neuros = dollars*.95\nkilograms = pounds/2.2\ntempF = tempC* 9/5+32 \n\n\nprint (\"ITINERARY NOTES\")\nprint (\"------------------------------------------------------\")\n\nprint (globe + \" you have {:.2f} euros to spend.\" .format(euros))\nprint (globe + \" Plan to buy {:.2f} of chocolate for family and friends\".format(kilograms))\nprint (globe + \" The tempature in Europe is {} degrees F, So dress appropriately.\".format(tempF))\n\n" ]

[ 1, 0 ]

[]

[]

[ "python", "python_3.x" ]

[ "there are many possible ways one of them is to create as a dataset as your error message indicated a mismatched datatype for model.fit()\nSample: Transform input word by vocab and match their string bytes, or tokenize them.\nimport tensorflow as tf\nimport tensorflow_text as tft\n\nimport json\n\ninput_word = tf.constant(' \\'Cause it\\'s easy as an ice cream sundae Slipping outta your hand into the dirt Easy as an ice cream sundae Every dancer gets a little hurt Easy as an ice cream sundae Slipping outta your hand into the dirt Easy as an ice cream sundae Every dancer gets a little hurt Easy as an ice cream sundae Oh, easy as an ice cream sundae ')\nvocab = [ \"a\", \"b\", \"c\", \"d\", \"e\", \"f\", \"g\", \"h\", \"i\", \"j\", \"k\", \"l\", \"m\", \"n\", \"o\", \"p\", \"q\", \"r\", \"s\", \"t\", \"u\", \"v\", \"w\", \"x\", \"y\", \"z\", \"_\", \n\"A\", \"B\", \"C\", \"D\", \"E\", \"F\", \"G\", \"H\", \"I\", \"J\", \"K\", \"L\", \"M\", \"N\", \"O\", \"P\", \"Q\", \"R\", \"S\", \"T\", \"U\", \"V\", \"W\", \"X\", \"Y\", \"Z\"]\nlayer = tf.keras.layers.StringLookup(vocabulary=vocab)\nsequences_mapping_string = layer(tf.strings.bytes_split(input_word))\n\n\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n: Method 1 create label from map it with vocaburary\n\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\nprint( 'input_word: ' + str(input_word) )\nprint( \" \" )\nprint( tf.strings.bytes_split(input_word) )\nprint( sequences_mapping_string )\n\n\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n: Method 2 create label from it tokenizer\n\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\ntext = \"Cause its easy as an ice cream sundae Slipping outta your hand\"\ntokenizer = tf.keras.preprocessing.text.Tokenizer(num_words=10000, oov_token='oov', filters='!\"#$%&()*+,-./:;<=>?@[\\\\]^_`{|}~\\t\\n', lower=True,)\ntokenizer.fit_on_texts([text])\n\ni_count = tf.strings.split([text])[0].shape[0] + 1\naDict = json.loads(tokenizer.to_json())\ntext_input = tf.constant([''], shape=())\n\n\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n: Class / Functions\n\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\ndef auto_paddings( data, max_sequences=15 ):\n data = tf.constant( data, shape=(data.shape[0], 1) )\n paddings = tf.constant([[1, 15 - data.shape[0] - 1], [0, 0]])\n padd_data = tf.pad( data, paddings, \"CONSTANT\" )\n padd_data = tf.constant( padd_data, shape=(15, 1) ).numpy()\n return padd_data\n\n\ninput_word = tf.zeros([1, 15, 1], dtype=tf.int64)\ninput_label = tf.ones([1, 1, 1], dtype=tf.int64)\n\nfor i in range(i_count):\n word = json.loads(aDict['config']['index_word'])[str(i + 1)]\n i_word = layer(tf.strings.bytes_split(word))\n padd_data = tf.constant(auto_paddings( i_word, 15 ), shape=(1, 15, 1))\n \n index = json.loads(aDict['config']['word_index'])[word]\n\n if i > 0:\n input_word = tf.experimental.numpy.vstack([input_word, padd_data])\n input_label = tf.experimental.numpy.vstack([input_label, tf.constant(index, shape=(1, 1, 1))])\n\n\ndataset = tf.data.Dataset.from_tensors(( input_word, input_label ))\nfor d in dataset:\n print(d)\n\nprint( \" ==================================================== \" )\n\nOutput: Input word as a string\ninput_word: tf.Tensor(b\" 'Cause it's easy as an ice cream sundae Slipping outta your hand into the dirt Easy as an ice cream sundae Every dancer gets a little hurt Easy as an ice cream sundae Slipping outta your hand into the dirt Easy as an ice cream sundae Every dancer gets a little hurt Easy as an ice cream sundae Oh, easy as an ice cream sundae \", shape=(), dtype=string)\n\nOutput: String to bytes as a splitters.\ntf.Tensor(\n[b' ' b\"'\" b'C' b'a' b'u' b's' b'e' b' ' b'i' b't' b\"'\" b's' b' ' b'e'\n b'a' b's' b'y' b' ' b'a' b's' b' ' b'a' b'n' b' ' b'i' b'c' b'e' b' '\n ...\n b'n' b'd' b'a' b'e' b' '], shape=(327,), dtype=string)\n\nOutput: Sequence mapping a string to phones.\ntf.Tensor(\n[ 0 0 30 1 21 19 5 0 9 20 0 19 0 5 1 19 25 0 1 19 0 1 14 0\n 9 3 5 0 3 18 5 1 13 0 19 21 14 4 1 5 0 46 12 9 16 16 9 14\n ...\n 5 0 3 18 5 1 13 0 19 21 14 4 1 5 0], shape=(327,), dtype=int64)\n\nOutput: A string input, required of list conversion or array-like none repeats.\nCause its easy as an ice cream sundae Slipping outta your hand\n\nOutput: A dataset creates from input_word and name label.\n(<tf.Tensor: shape=(13, 15, 1), dtype=int64, numpy=\n array([[[ 0],\n [ 0],\n ...\n [ 0]]], dtype=int64)>, <tf.Tensor: shape=(13, 1, 1), dtype=int64, numpy=\n array([[[ 1]],\n [[[ 2]]\n ...\n [[13]]], dtype=int64)>)\n ====================================================\n\nApplication: Word input compares process from slide X windows channel.\ndataset = tf.data.Dataset.from_tensors( tf.strings.bytes_split(input_word) )\nwindow_size = 6\ndataset = dataset.map(lambda x: tft.sliding_window(x, width=window_size, axis=0)).flat_map(tf.data.Dataset.from_tensor_slices)\n\nApplication: Wireless breaks.\nmapping_vocab = [ \"_\", \"I\", \"l\", \"o\", \"v\", \"e\", \"c\", \"a\", \"t\", \"s\" ]\nstring_matching = [ 27, 9, 12, 15, 22, 5, 3, 1, 20, 19 ]\nstring_matching_reverse = [ 1/27, 1/9, 1/12, 1/15, 1/22, 1/5, 1/3, 1/1, 1/20, 1/19 ]\n\nprint( tf.math.multiply( tf.constant(string_matching, dtype=tf.float32), tf.constant(string_matching_reverse, dtype=tf.float32 ), name=None ) )\n\nOutput: encode and decodes, each number represents bytes you may replace with trained parameters.\nencode: tf.Tensor([[27 27 27 9 12 15 22 5 3 1 20 19]], shape=(1, 12), dtype=int64)\ndecode: tf.Tensor([[b'_' b'_' b'_' b'I' b'l' b'o' b'v' b'e' b'c' b'a' b't' b's']], shape=(1, 12), dtype=string)\ntf.Tensor([1. 1. 1. 1. 1. 1. 1. 1. 1. 1.], shape=(10,), dtype=float32)\n\n" ]

[ 0 ]

[]

[]

[ "artificial_intelligence", "deep_learning", "neural_network", "python", "tensorflow" ]

[ "What you want is called extrapolation (as opposed to interpolation which is predicting a value that is inside the trained domain / range). There is never a good solution for extrapolation and using higher powers can give you a better fit for a specific problem, but if you change the fitted curve slightly (either change its x and y-intercept, one of the powers, etc) the extrapolation will be pretty bad again.\nThis is also why neural networks use a large data set (to maximize their input range and rely on interpolation) and why over-training / over fitting (which is what you're trying to do) is a bad idea; it never works well in the general case.\n" ]

[ 0 ]

[]

[]

[ "python", "pytorch" ]

[ "As @Michael Butcher answered there was a variable with the same name as my function, train, renaming the function fixed the issue.\n" ]

[ 1 ]

[]

[]

[ "function", "list", "python" ]

[ "Ok, here's a working answer. Note that if A and B have the same lengths, part of the code is unnecessary (but I'll leave it anyway to make it more portable):\nimport numpy as np\n\ndef makeAparalleltoB(pointSA, pointEA, pointSB, pointEB):\n# pointSA... are np.arrays of the 3 coordinates\n\n # Calculating the coordinates of the vectors\n vecA = pointEA - pointSA\n vecB = pointEB - pointSB\n\n # Calculating the lengths of the vectors\n # Unnecessary if we know that A and B have the same lengths\n vecANorm = np.linalg.norm(vecA)\n vecBNorm = np.linalg.norm(vecB)\n\n # Calculating the coordinates of a vector collinear to B, of the same length as A\n newvecA = vecB * vecANorm/vecBNorm\n\n # Returning new coordinates for the endpoint of A\n return pointSA + newvecA\n\nExample:\na = np.array([1,1,1])\nb = np.array([2,3,4])\nc = np.array([0,0,0])\nd = np.array([1,1,1])\n\nprint(makeAparalleltoB(a, b, c, d))\n\n# [3.1602469 3.1602469 3.1602469]\n\nIf we know that A and B have the same length, then it's even simpler: we simply make it so SB, EB, EA, SA is a parallelogram:\nnewpointEA = pointSA + pointEB - pointSB\n\n" ]

[ 1 ]

[]

[]

[ "math", "numpy", "python" ]

[ "I would strongly recommend you use skimage.io to load your images, not opencv. It opens the images in RGB format by default, removing your shuffling overhead, but if you want to convert BGR to RGB you can use this:\nimport numpy as np\n\nimg = np.arange(27).reshape(3,3,3)\nb = img[:,:,0]\ng = img[:,:,1]\nr = img[:,:,2]\n\nrgb = np.dstack([r,g,b])\n\nprint(img)\nprint(\"#\"*20)\nprint(rgb)\n\n" ]

[ 1 ]

[]

[]

[ "image", "python", "pytorch", "pytorch_dataloader" ]

[ "This should work if you convert to strings, pad with zeros and provide a format to to_datetime:\ndf['time'] = pd.to_datetime(df['Occurred Time'].astype(int)\n .astype(str).str.zfill(4),\n format='%H%M')\n\nOutput:\n Occurred Time time\n0 1200 1900-01-01 12:00:00\n1 0 1900-01-01 00:00:00\n2 1536 1900-01-01 15:36:00\n\nAdd .dt.time if you want only the time:\ndf['time'] = pd.to_datetime(df['Occurred Time'].astype(int)\n .astype(str).str.zfill(4),\n format='%H%M').dt.time\n\nOutput:\n Occurred Time time\n0 1200 12:00:00\n1 0 00:00:00\n2 1536 15:36:00\n\n" ]

[ 2 ]

[]

[]

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

[ "First, pip install tqdm if you haven't already. Second, specify the path to your Lib/site-packages. You can do this by either:\n\nAdding an argument to pathex in your .spec file\n(.venv for a virtual environment at some folder .venv in your local directory, or the absolute path to your global Python install Lib/site-packages if you're not using a virtual environment):\n\npathex=['.venv/Lib/site-packages']\n\n\nSpecifying the path to Lib/site-packages from the command-line:\n\npyinstaller --paths '.venv/Lib/site-packages' my_program.py\n\nFrom the pyinstaller docs\n\npathex: a list of paths to search for imports (like using PYTHONPATH), including paths given by the --paths option.\n\nSome Python scripts import modules in ways that PyInstaller cannot detect: for example, by using the __import__() function with variable data, using importlib.import_module(), or manipulating the sys.path value at run time.\n" ]

[ 1 ]

[ "Hi is this the accepted answer still valid? I have the exact same problem but the solution doesn't work for me.\n" ]

[ -2 ]

[ "huggingface_transformers", "pyqt", "pyside", "python" ]

[ "It sounds like you are trying to use the Flask flash function to show a message to the user in real time, but the message is only being displayed after the page is refreshed.\nThe reason this is happening is that the Flask flash function stores messages in the user's session, and those messages are only displayed to the user when the page is rendered. This means that if you call the flash function and then immediately return a response, the user will not see the flashed message until they refresh the page or navigate to a different page in your app.\nTo show the flashed message in real time, you will need to trigger a new page render after calling the flash function. One way to do this is to use the Flask redirect function to redirect the user to the same page (or a different page) after calling the flash function. This will cause the page to be rendered again, and the flashed message will be displayed to the user.\nHere is an example of how you could use the redirect function to show a flashed message in real time:\n@dashapp.callback(\n[\n ServersideOutput(\n \"data-store\", \"data\", backend=cache_backend, arg_check=False\n ),\n\n\n ServersideOutput(\n \"availability-data-store\",\n \"data\",\n backend=cache_backend,\n arg_check=False,\n ),\n ],\n Input(\"refresh-placeholder\", \"n_clicks\"),\n prevent_initial_call=True,\n)\n\ndef _fetch_data(_n):\n temp_output = get_data(get_session_vinsight_token())\n if not temp_output:\n flash(\n \"No data loaded. Please reconnect to vinsight from your account page if the error continues.\",\n \"error\",\n )\n # Use the redirect function to redirect the user to the same page\n return redirect(request.url)\n # Alternatively, you can redirect the user to a different page\n # return redirect(\"/some-other-page\")\n\n (df, availability_df) = temp_output\n return [df, availability_df]\n\nIn this code, the _fetch_data function calls the flash function to store a message in the user's session if there is an error. Then, it uses the redirect function to redirect the user to the same page (using request.url). This will cause the page to be rendered again, and the flashed message will be displayed to the user in real time.\n" ]

[ 0 ]

[]

[]

[ "flask", "notifications", "plotly_dash", "python", "toastr" ]

[ "Your Julia code doing a number of things that aren't idiomatic and are worsening your performance. This won't be a full overview, but it should give you a good idea to start.\nThe first thing is passing params as a Vector is a bad idea. This means it will have to be heap allocated, and the compiler doesn't know how long it is. Instead, use a Tuple which will allow for a lot more optimization. Secondly, don't make gaussian act on a Vector of xs. Instead, write the scalar version and broadcast it. Specifically, with these changes, you will have\nfunction gaussian(x::Number, params::NTuple{3, Float64})\n amp, mu, sigma = params\n \n # The next 2 lines should probably be done outside this function, but I'll leave them here for now.\n amplitude = amp/(abs(sigma)*sqrt(2*pi))\n arg = ((x-mu)/sigma)\n return amplitude*exp(-0.5*(arg^2))\nend\n\n", "One straightforward way to speed this up is to use ForwardDiff not Zygote, since you are taking a gradient of a vector of length 3, many times. Here this gets me from 16 to 3.5 seconds, with the last factor of 2 involving Chunk(3) to improve type-stability. Perhaps this can be improved further.\nfunction myjacobian(x::Vector, params)\n # return rand(eltype(x), length(x), length(params)) # with no gradient, takes 0.5s\n output = zeros(eltype(x), length(x), length(params))\n config = ForwardDiff.GradientConfig(nothing, params, ForwardDiff.Chunk(3))\n for (i, xi) in enumerate(x)\n # grad = gradient(p->gaussian(xi, p), params)[1] # original, takes 16s\n # grad = ForwardDiff.gradient(p-> gaussian(xi, p)) # ForwardDiff, takes 7s\n grad = ForwardDiff.gradient(p-> gaussian(xi, p), params, config) # takes 3.5s\n copyto!(view(output,i,:), grad) # this allows params::Tuple, OK for Zygote, no help\n end\n return output\nend\n# This needs gaussian.(x, Ref(params)) elsewhere to use on many x, same params\nfunction gaussian(x::Real, params)\n # amp, mu, sigma = params # with params::Vector this is slower, 19 sec\n amp = params[1]\n mu = params[2]\n sigma = params[3] # like this, 16 sec\n T = typeof(x) # avoids having (2*pi)::Float64 promote everything\n amplitude = amp/(abs(sigma)*sqrt(2*T(pi)))\n arg = (x-mu)/sigma\n return amplitude * exp(-(arg^2)/2)\nend\n\nHowever, this is still computing many small gradient arrays in a loop. It could easily compute one big gradient array instead.\nWhile in general Julia is happy to compile loops to something fast, loops that make individual arrays tend to be a bad idea. And this is especially true for Zygote, which is fastest on matlab-ish whole-array code.\nHere's how this looks, it gets me under 1s for the whole program:\nfunction gaussian(x::Real, amp::Real, mu::Real, sigma::Real)\n T = typeof(x)\n amplitude = amp/(abs(sigma)*sqrt(2*T(pi)))\n arg = (x-mu)/sigma\n return amplitude * exp(-(arg^2)/2)\nend\nfunction myjacobian2(x::Vector, params) # with this, 0.9s\n amp = fill(params[1], length(x))\n mu = fill(params[2], length(x))\n sigma = fill(params[3], length(x)) # use same sigma & different x value at each row:\n grads = gradient((amp, mu, sigma) -> sum(gaussian.(x, amp, mu, sigma)), amp, mu, sigma)\n hcat(grads...)\nend\n# Check that it agrees:\nmyjacobian2(x, params) ≈ myjacobian(x, params)\n\nWhile this has little effect on the speed, I think you probably also want op(jac::Matrix) = Hermitian(jac'*jac) \\ jac' rather than inv.\n" ]

[ 4, 2 ]

[]

[]

[ "jax", "julia", "optimization", "python" ]

[ "I am learning how to write stored procedures in Mariadb. I have done a test procedure which insert data in a Mariadb database. This test works from Mariadb terminal. Trying to follow an example from internet I wrote following simple code:\n import mariadb\n connection = mariadb.connect(host='localhost',\n database='Terrain',\n password=\"xxxxxxx\",\n port = 3306,\n user='admin'\n )\n \n cursor = connection.cursor(prepared=True)\n args = 10,20,45\n cursor.callproc(AddPolygon, args)\n\nWhen typing cursor. a list with alternatives pops up but \"callproc\" is not in this list.\nWhen i try to execute to code I recieve the message: object has no attribute 'callproc'\n" ]

[ 0 ]

[]

[]

[ "mariadb", "python", "stored_procedures" ]

[ "See the following lines:\nuser_lemmas = [token.lemma_ for token in sentence if token_isolation(token)]\nuser_token = [token for token in sentence if token_isolation(token)]\n\nthe user_lemmas is a list of strings (picked up from lemma_ string attribute), the user_token is a list of spacy tokens, i.e., spacy objects. The sentence is the spacy document object.\nWhen you test: if i in sentence the \"in\" operator is supported only for the spacy token objects, not strings.\nThus you cannot do \"Word\" in sentence as this is not supported. You need to test spacy token in sentence which is fullfilled with user_token as it is spacy token and not a string.\n\nMinimal example to produce the error:\nimport spacy\nnlp = spacy.load(\"en_core_web_sm\")\ndoc = nlp(\"Apple is looking at buying U.K. startup for $1 billion\")\n\ncontained = \"Apple\" in doc\n\n>>> TypeError: Argument 'other' has incorrect type (expected spacy.tokens.token.Token, got str)\n\n\nExample of code that compares tokens by the lemmas:\nimport spacy\n\ndef compare_token(first_token, second_token, compare_by_lemma):\n \"\"\"Compares two spacy tokens, first compares POS tag, then lemma/form match.\n Switch between lemma/form by bool `compare_by_lemma`.\n \"\"\"\n if not first_token.pos_ == second_token.pos_:\n return False\n\n if compare_by_lemma:\n if first_token.lemma_ == second_token.lemma_:\n return True\n else:\n if first_token.text == second_token.text:\n return True\n return False\n\n\nnlp = spacy.load(\"en_core_web_sm\")\ndoc = nlp(\"Apple is looking at buying U.K. startup for $1 billion, while bought other company yesterday.\")\nbuying_token = doc[4]\n\n\nfor token in doc:\n is_match = compare_token(buying_token, token, compare_by_lemma=True) # <<< notice compare_by_lemma=True, try False\n if is_match:\n print(f\"{token.text}\\t{is_match}\")\n>>> buying True\n>>> bought True\n\n" ]

[ 0 ]

[]

[]

[ "nlp", "python" ]

[ "It's a bit messy, and not very efficient but here's a solution:\nIn [3]: df[df[\"is_critical\"]].apply(lambda critical_row: df[\"time\"][(df[\"time\"] > critical_row[\"time\"]) & (df[\"value\"] >= critical_row[\"value\"])].min(), axis=1)\nOut[3]:\n1 0:10\n4 0:08\n8 0:10\ndtype: object\n\nWorks by first filtering out any non-critical rows, then applying a boolean expression to each row of that result: \"values in the dataframe where the value is greater than or equal to the current value, and the time is greater than the current time\" where \"current\" refers to each row in the filtered data.\nYou can clean up a little:\ndef time_of_return_to_critical(df, critical_row):\n mask = (df.time > critical_row.time) & (df.value >= critical_row.value)\n return df[\"time\"][mask].min()\n\n\ndf[df.is_critical].apply(lambda row: time_of_return_to_critical(df, row), axis=1)\n\nNote that the .min() is a brittle solution. You should convert the \"time\" column to a proper datetime or timestamp data type because right now it's only \"working\" as a string comparator.\n" ]

[ 0 ]

[]

[]

[ "pandas", "python" ]

[ "To clear the text in the Entry widget, you can use the delete method and specify the indices of the characters that you want to delete. For example, to delete all the text in the Entry widget, you can use the following code:\ndef clear_name_box():\n input_entry.delete(0, 'end')\n\nThis code will delete all the text from the beginning (index 0) to the end ('end') of the text in the Entry widget.\nTo clear the text in the Label widget, you can use the config method to change the text attribute of the Label to an empty string. For example:\ndef clear_name_box():\n input_entry.delete(0, 'end')\n name_label.config(text=\"\")\n\nThis code will clear the text in both the Entry and Label widgets when the clear_name_box function is called.\n" ]

[ 0 ]

[]

[]

[ "python" ]

[ "You can work with:\nclass CreatePageForm(forms.Form):\n page_name = forms.CharField()\n page_contents = forms.CharField(widget=forms.Textarea())\n\n def __init__(self, *args, disabled=False, **kwargs):\n super().__init__(*args, **kwargs)\n self.fields['page_contents'].disabled = disabled\nand call it with:\nCreatePageForm(disabled=True)\n\n", "PrintOrderDetails(orderNum: 31, productName: \"Red Mug\", sellerName: \"Gift Shop\");\nPrintOrderDetails(productName: \"Red Mug\", sellerName: \"Gift Shop\", orderNum: 31);\n" ]

[ 0, 0 ]

[]

[]

[ "django", "forms", "python" ]

[ "Yes, by default the debug drawing will just print out the result (its made in this way so that you can use it without installing anything else and even run it from the terminal).\nHowever, it also comes with a module for the two libraries pygame and pyglet that are documented here:\nhttp://www.pymunk.org/en/latest/pymunk.pygame_util.html\nand here\nhttp://www.pymunk.org/en/latest/pymunk.pyglet_util.html\nBoth work in more or less the same way, just use their implementation of the SpaceDebugDrawOptions class instead of the default one.\n" ]

[ 0 ]

[]

[]

[ "pymunk", "python" ]

[ "Like this:\nkeys = ['a', 'b', 'c']\nvalues = [1, 2, 3]\ndictionary = dict(zip(keys, values))\nprint(dictionary) # {'a': 1, 'b': 2, 'c': 3}\n\nVoila :-) The pairwise dict constructor and zip function are awesomely useful.\n", "\nImagine that you have:\nkeys = ('name', 'age', 'food')\nvalues = ('Monty', 42, 'spam')\n\nWhat is the simplest way to produce the following dictionary ?\ndict = {'name' : 'Monty', 'age' : 42, 'food' : 'spam'}\n\n\nMost performant, dict constructor with zip\nnew_dict = dict(zip(keys, values))\n\nIn Python 3, zip now returns a lazy iterator, and this is now the most performant approach.\ndict(zip(keys, values)) does require the one-time global lookup each for dict and zip, but it doesn't form any unnecessary intermediate data-structures or have to deal with local lookups in function application.\nRunner-up, dict comprehension:\nA close runner-up to using the dict constructor is to use the native syntax of a dict comprehension (not a list comprehension, as others have mistakenly put it):\nnew_dict = {k: v for k, v in zip(keys, values)}\n\nChoose this when you need to map or filter based on the keys or value.\nIn Python 2, zip returns a list, to avoid creating an unnecessary list, use izip instead (aliased to zip can reduce code changes when you move to Python 3).\nfrom itertools import izip as zip\n\nSo that is still (2.7):\nnew_dict = {k: v for k, v in zip(keys, values)}\n\nPython 2, ideal for <= 2.6\nizip from itertools becomes zip in Python 3. izip is better than zip for Python 2 (because it avoids the unnecessary list creation), and ideal for 2.6 or below:\nfrom itertools import izip\nnew_dict = dict(izip(keys, values))\n\nResult for all cases:\nIn all cases:\n>>> new_dict\n{'age': 42, 'name': 'Monty', 'food': 'spam'}\n\nExplanation:\nIf we look at the help on dict we see that it takes a variety of forms of arguments:\n\n>>> help(dict)\n\nclass dict(object)\n | dict() -> new empty dictionary\n | dict(mapping) -> new dictionary initialized from a mapping object's\n | (key, value) pairs\n | dict(iterable) -> new dictionary initialized as if via:\n | d = {}\n | for k, v in iterable:\n | d[k] = v\n | dict(**kwargs) -> new dictionary initialized with the name=value pairs\n | in the keyword argument list. For example: dict(one=1, two=2)\n\n\nThe optimal approach is to use an iterable while avoiding creating unnecessary data structures. In Python 2, zip creates an unnecessary list:\n>>> zip(keys, values)\n[('name', 'Monty'), ('age', 42), ('food', 'spam')]\n\nIn Python 3, the equivalent would be:\n>>> list(zip(keys, values))\n[('name', 'Monty'), ('age', 42), ('food', 'spam')]\n\nand Python 3's zip merely creates an iterable object:\n>>> zip(keys, values)\n<zip object at 0x7f0e2ad029c8>\n\nSince we want to avoid creating unnecessary data structures, we usually want to avoid Python 2's zip (since it creates an unnecessary list).\nLess performant alternatives:\nThis is a generator expression being passed to the dict constructor:\ngenerator_expression = ((k, v) for k, v in zip(keys, values))\ndict(generator_expression)\n\nor equivalently:\ndict((k, v) for k, v in zip(keys, values))\n\nAnd this is a list comprehension being passed to the dict constructor:\ndict([(k, v) for k, v in zip(keys, values)])\n\nIn the first two cases, an extra layer of non-operative (thus unnecessary) computation is placed over the zip iterable, and in the case of the list comprehension, an extra list is unnecessarily created. I would expect all of them to be less performant, and certainly not more-so.\nPerformance review:\nIn 64 bit Python 3.8.2 provided by Nix, on Ubuntu 16.04, ordered from fastest to slowest:\n>>> min(timeit.repeat(lambda: dict(zip(keys, values))))\n0.6695233230129816\n>>> min(timeit.repeat(lambda: {k: v for k, v in zip(keys, values)}))\n0.6941362579818815\n>>> min(timeit.repeat(lambda: {keys[i]: values[i] for i in range(len(keys))}))\n0.8782548159942962\n>>> \n>>> min(timeit.repeat(lambda: dict([(k, v) for k, v in zip(keys, values)])))\n1.077607496001292\n>>> min(timeit.repeat(lambda: dict((k, v) for k, v in zip(keys, values))))\n1.1840861019445583\n\ndict(zip(keys, values)) wins even with small sets of keys and values, but for larger sets, the differences in performance will become greater.\nA commenter said:\n\nmin seems like a bad way to compare performance. Surely mean and/or max would be much more useful indicators for real usage.\n\nWe use min because these algorithms are deterministic. We want to know the performance of the algorithms under the best conditions possible. \nIf the operating system hangs for any reason, it has nothing to do with what we're trying to compare, so we need to exclude those kinds of results from our analysis.\nIf we used mean, those kinds of events would skew our results greatly, and if we used max we will only get the most extreme result - the one most likely affected by such an event.\nA commenter also says:\n\nIn python 3.6.8, using mean values, the dict comprehension is indeed still faster, by about 30% for these small lists. For larger lists (10k random numbers), the dict call is about 10% faster. \n\nI presume we mean dict(zip(... with 10k random numbers. That does sound like a fairly unusual use case. It does makes sense that the most direct calls would dominate in large datasets, and I wouldn't be surprised if OS hangs are dominating given how long it would take to run that test, further skewing your numbers. And if you use mean or max I would consider your results meaningless.\nLet's use a more realistic size on our top examples:\nimport numpy\nimport timeit\nl1 = list(numpy.random.random(100))\nl2 = list(numpy.random.random(100))\n\nAnd we see here that dict(zip(... does indeed run faster for larger datasets by about 20%.\n>>> min(timeit.repeat(lambda: {k: v for k, v in zip(l1, l2)}))\n9.698965263989521\n>>> min(timeit.repeat(lambda: dict(zip(l1, l2))))\n7.9965161079890095\n\n", "Try this:\n>>> import itertools\n>>> keys = ('name', 'age', 'food')\n>>> values = ('Monty', 42, 'spam')\n>>> adict = dict(itertools.izip(keys,values))\n>>> adict\n{'food': 'spam', 'age': 42, 'name': 'Monty'}\n\nIn Python 2, it's also more economical in memory consumption compared to zip.\n", "keys = ('name', 'age', 'food')\nvalues = ('Monty', 42, 'spam')\nout = dict(zip(keys, values))\n\nOutput:\n{'food': 'spam', 'age': 42, 'name': 'Monty'}\n\n", "You can also use dictionary comprehensions in Python ≥ 2.7:\n>>> keys = ('name', 'age', 'food')\n>>> values = ('Monty', 42, 'spam')\n>>> {k: v for k, v in zip(keys, values)}\n{'food': 'spam', 'age': 42, 'name': 'Monty'}\n\n", "A more natural way is to use dictionary comprehension \nkeys = ('name', 'age', 'food')\nvalues = ('Monty', 42, 'spam') \ndict = {keys[i]: values[i] for i in range(len(keys))}\n\n", "If you need to transform keys or values before creating a dictionary then a generator expression could be used. Example:\n>>> adict = dict((str(k), v) for k, v in zip(['a', 1, 'b'], [2, 'c', 3])) \n\nTake a look Code Like a Pythonista: Idiomatic Python.\n", "with Python 3.x, goes for dict comprehensions\nkeys = ('name', 'age', 'food')\nvalues = ('Monty', 42, 'spam')\n\ndic = {k:v for k,v in zip(keys, values)}\n\nprint(dic)\n\nMore on dict comprehensions here, an example is there:\n>>> print {i : chr(65+i) for i in range(4)}\n {0 : 'A', 1 : 'B', 2 : 'C', 3 : 'D'}\n\n", "For those who need simple code and aren’t familiar with zip:\nList1 = ['This', 'is', 'a', 'list']\nList2 = ['Put', 'this', 'into', 'dictionary']\n\nThis can be done by one line of code:\nd = {List1[n]: List2[n] for n in range(len(List1))}\n\n", "you can use this below code:\ndict(zip(['name', 'age', 'food'], ['Monty', 42, 'spam']))\n\nBut make sure that length of the lists will be same.if length is not same.then zip function turncate the longer one.\n", "\n2018-04-18\n\nThe best solution is still:\nIn [92]: keys = ('name', 'age', 'food')\n...: values = ('Monty', 42, 'spam')\n...: \n\nIn [93]: dt = dict(zip(keys, values))\nIn [94]: dt\nOut[94]: {'age': 42, 'food': 'spam', 'name': 'Monty'}\n\nTranpose it:\n lst = [('name', 'Monty'), ('age', 42), ('food', 'spam')]\n keys, values = zip(*lst)\n In [101]: keys\n Out[101]: ('name', 'age', 'food')\n In [102]: values\n Out[102]: ('Monty', 42, 'spam')\n\n", "Here is also an example of adding a list value in you dictionary\nlist1 = [\"Name\", \"Surname\", \"Age\"]\nlist2 = [[\"Cyd\", \"JEDD\", \"JESS\"], [\"DEY\", \"AUDIJE\", \"PONGARON\"], [21, 32, 47]]\ndic = dict(zip(list1, list2))\nprint(dic)\n\nalways make sure the your \"Key\"(list1) is always in the first parameter.\n{'Name': ['Cyd', 'JEDD', 'JESS'], 'Surname': ['DEY', 'AUDIJE', 'PONGARON'], 'Age': [21, 32, 47]}\n\n", "I had this doubt while I was trying to solve a graph-related problem. The issue I had was I needed to define an empty adjacency list and wanted to initialize all the nodes with an empty list, that's when I thought how about I check if it is fast enough, I mean if it will be worth doing a zip operation rather than simple assignment key-value pair. After all most of the times, the time factor is an important ice breaker. So I performed timeit operation for both approaches.\nimport timeit\ndef dictionary_creation(n_nodes):\n dummy_dict = dict()\n for node in range(n_nodes):\n dummy_dict[node] = []\n return dummy_dict\n\n\ndef dictionary_creation_1(n_nodes):\n keys = list(range(n_nodes))\n values = [[] for i in range(n_nodes)]\n graph = dict(zip(keys, values))\n return graph\n\n\ndef wrapper(func, *args, **kwargs):\n def wrapped():\n return func(*args, **kwargs)\n return wrapped\n\niteration = wrapper(dictionary_creation, n_nodes)\nshorthand = wrapper(dictionary_creation_1, n_nodes)\n\nfor trail in range(1, 8):\n print(f'Itertion: {timeit.timeit(iteration, number=trails)}\\nShorthand: {timeit.timeit(shorthand, number=trails)}')\n\nFor n_nodes = 10,000,000\nI get,\nIteration: 2.825081646999024\nShorthand: 3.535717916001886\nIteration: 5.051560923002398\nShorthand: 6.255070794999483\nIteration: 6.52859034499852\nShorthand: 8.221581164998497\nIteration: 8.683652416999394\nShorthand: 12.599181543999293\nIteration: 11.587241565001023\nShorthand: 15.27298851100204\nIteration: 14.816342867001367\nShorthand: 17.162912737003353\nIteration: 16.645022411001264\nShorthand: 19.976680120998935\nYou can clearly see after a certain point, iteration approach at n_th step overtakes the time taken by shorthand approach at n-1_th step.\n", "It can be done by the following way.\nkeys = ['name', 'age', 'food']\nvalues = ['Monty', 42, 'spam'] \n\ndict = {}\n\nfor i in range(len(keys)):\n dict[keys[i]] = values[i]\n \nprint(dict)\n\n{'name': 'Monty', 'age': 42, 'food': 'spam'}\n\n", "All answers sum up:\nl = [1, 5, 8, 9]\nll = [3, 7, 10, 11]\n\nzip:\ndict(zip(l,ll)) # {1: 3, 5: 7, 8: 10, 9: 11}\n\n#if you want to play with key or value @recommended\n\n{k:v*10 for k, v in zip(l, ll)} #{1: 30, 5: 70, 8: 100, 9: 110}\n\ncounter:\nd = {}\nc=0\nfor k in l:\n d[k] = ll[c] #setting up keys from the second list values\n c += 1\nprint(d)\n{1: 3, 5: 7, 8: 10, 9: 11}\n\n\nenumerate:\nd = {}\nfor i,k in enumerate(l):\n d[k] = ll[i]\nprint(d)\n{1: 3, 5: 7, 8: 10, 9: 11}\n\n", "Solution as dictionary comprehension with enumerate:\ndict = {item : values[index] for index, item in enumerate(keys)}\n\nSolution as for loop with enumerate:\ndict = {}\nfor index, item in enumerate(keys):\n dict[item] = values[index]\n\n", "If you are working with more than 1 set of values and wish to have a list of dicts you can use this:\ndef as_dict_list(data: list, columns: list):\n return [dict((zip(columns, row))) for row in data]\n\nReal-life example would be a list of tuples from a db query paired to a tuple of columns from the same query. Other answers only provided for 1 to 1.\n", "keys = ['name', 'age', 'food']\nvalues = ['Monty', 42, 'spam']\ndic = {}\nc = 0\nfor i in keys:\n dic[i] = values[c]\n c += 1\n\nprint(dic)\n{'name': 'Monty', 'age': 42, 'food': 'spam'}\n\n", " import pprint\n def makeDictUsingAlternateLists1(**rest):\n print(\"*rest.keys() : \",*rest.keys())\n print(\"rest.keys() : \",rest.keys())\n print(\"*rest.values() : \",*rest.values())\n print(\"**rest.keys() : \",rest.keys())\n print(\"**rest.values() : \",rest.values())\n [print(a) for a in zip(*rest.values())]\n \n [ print(dict(zip(rest.keys(),a))) for a in zip(*rest.values())]\n print(\"...\")\n \n \n finalRes= [ dict( zip( rest.keys(),a)) for a in zip(*rest.values())] \n return finalRes\n \n l = makeDictUsingAlternateLists1(p=p,q=q,r=r,s=s)\n pprint.pprint(l) \n\"\"\"\n*rest.keys() : p q r s\nrest.keys() : dict_keys(['p', 'q', 'r', 's'])\n*rest.values() : ['A', 'B', 'C'] [5, 2, 7] ['M', 'F', 'M'] ['Sovabazaar', 'Shyambazaar', 'Bagbazaar', 'Hatkhola']\n**rest.keys() : dict_keys(['p', 'q', 'r', 's'])\n**rest.values() : dict_values([['A', 'B', 'C'], [5, 2, 7], ['M', 'F', 'M'], ['Sovabazaar', 'Shyambazaar', 'Bagbazaar', 'Hatkhola']])\n('A', 5, 'M', 'Sovabazaar')\n('B', 2, 'F', 'Shyambazaar')\n('C', 7, 'M', 'Bagbazaar')\n{'p': 'A', 'q': 5, 'r': 'M', 's': 'Sovabazaar'}\n{'p': 'B', 'q': 2, 'r': 'F', 's': 'Shyambazaar'}\n{'p': 'C', 'q': 7, 'r': 'M', 's': 'Bagbazaar'}\n...\n[{'p': 'A', 'q': 5, 'r': 'M', 's': 'Sovabazaar'},\n {'p': 'B', 'q': 2, 'r': 'F', 's': 'Shyambazaar'},\n {'p': 'C', 'q': 7, 'r': 'M', 's': 'Bagbazaar'}]\n\"\"\"\n\n" ]

[ 2791, 220, 134, 40, 31, 19, 15, 11, 10, 3, 3, 2, 2, 1, 1, 0, 0, 0, 0 ]

[ "method without zip function\nl1 = [1,2,3,4,5]\nl2 = ['a','b','c','d','e']\nd1 = {}\nfor l1_ in l1:\n for l2_ in l2:\n d1[l1_] = l2_\n l2.remove(l2_)\n break \n\nprint (d1)\n\n\n{1: 'd', 2: 'b', 3: 'e', 4: 'a', 5: 'c'}\n\n", "Although there are multiple ways of doing this but i think most fundamental way of approaching it; creating a loop and dictionary and store values into that dictionary. In the recursive approach the idea is still same it but instead of using a loop, the function called itself until it reaches to the end. Of course there are other approaches like using dict(zip(key, value)) and etc. These aren't the most effective solutions.\ny = [1,2,3,4]\nx = [\"a\",\"b\",\"c\",\"d\"]\n\n# This below is a brute force method\nobj = {}\nfor i in range(len(y)):\n obj[y[i]] = x[i]\nprint(obj)\n\n# Recursive approach \nobj = {}\ndef map_two_lists(a,b,j=0):\n if j < len(a):\n obj[b[j]] = a[j]\n j +=1\n map_two_lists(a, b, j)\n return obj\n \n\n\nres = map_two_lists(x,y)\nprint(res)\n\n\nBoth the results should print\n{1: 'a', 2: 'b', 3: 'c', 4: 'd'} \n\n" ]

[ -1, -1 ]

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

[ "I rewrote you code into a function that can be called using each filename you have, possibly collected into a list using os.listdir().\nfrom Bio import SeqIO\n\ndef parse_file(filename):\n new_name = f\"rc_{filename}\"\n with open(new_name, \"w\") as new:\n for rec in SeqIO.parse(filename, \"fasta\"):\n print(rec_id:=rec.id)\n print(rev_comp:=str(rec.seq.reverse_complement()))\n new.write(f\">rc_{rec_id}\\n{rev_comp}\\n\")\n\nI used f-strings to create both the new filename and the strings written to that file. I also used the \"walrus operator\" to assign the values of rec.id and rec.seq.reverse_complement() to temp variables so we don't have to run those operations again when we write the data. This will save compute cycles and time over the long run. However, use of := means the code will only run under Python 3.8 and later.\n" ]

[ 0 ]

[]

[]

[ "biopython", "python" ]

[ "I can't tell exactly what you want because of how you worded it, but I'm pretty sure this is what you want\ndef set_date():\n my_label.config(text=cal.get_date())\n today = cal.get_date()\n return today\n\nIf you then import this function in another file and call it like this\nselected_date = set_date()\n\nThis isn't quite what you want though as it will modify the label each time you want to get the date, so you will want to add this function to get the selected date that you want.\ndef get_date():\n today = cal.get_date()\n return today\n\n" ]

[ 1 ]

[ "a = 5\n\ndef set_a(val):\n global a\n a = val\n \nprint(a)\nset_a(0)\nprint(a)\n\nWhat you are doing is a very bad practice (you can use the global keyword before your variable to update it, but never do this). Instead either store it in a mutable data object for example a dictionary or as a pickle file(depending on your application).\nprogram_variables = {'a':5}\n\ndef set_a(val):\n program_variables['a'] = val\n \nprint(program_variables['a'])\nset_a(0)\nprint(program_variables['a'])\n\nif you need pickles, you can search for tutorials on using it as well\n" ]

[ -2 ]

[ "python", "tkcalendar", "tkinter" ]

[ "any():\nif any(t < 0 for t in x):\n # do something\n\nAlso, if you're going to use \"True in ...\", make it a generator expression so it doesn't take O(n) memory:\nif True in (t < 0 for t in x):\n\n", "Use any().\nif any(t < 0 for t in x):\n # do something\n\n", "Python has a built in any() function for exactly this purpose.\n" ]

[ 246, 37, 11 ]

[ "a=x.copy()\na.sort()\nif a[0]<0:\n # do something\n\n" ]

[ -1 ]

[ "list", "python" ]

[ "You have a typo in set_do_follow(percentage not precentage)\n" ]

[ 0 ]

[]

[]

[ "function", "instagram", "instapy", "module", "python" ]

[ "Note that QImage::scaled() has an optional parameter transformMode that defaults to Qt::FastTransformation. If you pass Qt::SmoothTransformation the results should be better, because bilinear filtering is used.\n" ]

[ 0 ]

[]

[]

[ "pyqt5", "python", "qimage", "qt", "video_processing" ]

[ "I think you missed .read() for cluster.\n" ]

[ 0 ]

[]

[]

[ "python", "python_re" ]

[ "To access data from both the Word and Token objects in a single loop, you can simply loop through the Sentence objects in the document, and then within each sentence loop through the Word objects. For each Word object, you can access its associated Token object through the .token attribute. Here is an example of how you might do this:\nfor sentence in it_doc.sentences:\n for word in sentence.words:\n # Get the Word object's data\n word_text = word.text\n word_upos = word.upos\n word_xpos = word.xpos\n word_feats = word.feats\n\n # Get the Token object's data\n token = word.token\n token_start = token.start_char\n token_end = token.end_char\n token_text = token.text\n \n # Use the data as needed\n print(f\"Word: {word_text}\\nUPOS: {word_upos}\\nXPOS: {word_xpos}\\nFeats: {word_feats}\\nToken: {token_text}\\nToken start: {token_start}\\nToken end: {token_end}\")\n\nAlternatively, you can access the Token object directly from the Sentence object, using the sentence.tokens property, which is a list of Token objects. Here is an example of how you might do this:\nfor sentence in it_doc.sentences:\n # Get the Sentence object's tokens\n tokens = sentence.tokens\n \n for token in tokens:\n token_start = token.start_char\n token_end = token.end_char\n token_text = token.text\n\n # Use the data as needed\n print(f\"Token: {token_text}\\nToken start: {token_start}\\nToken end: {token_end}\")\n\nEither of these approaches should allow you to access data from both the Word and Token objects in a single loop.\n", "I just discovered the zip function which returns an iterator of tuples in Python 3.\nTherefore to iterate in parallel through the Words and Tokens of a sentence you can code:\nfor sentence in it_doc.sentences:\n for t, w in zip(sentence.tokens, sentence.words):\n print(f\"Text->{w.text}\\tLemma->{w.lemma}\\tStart->{t.start_char}\\tStop->{t.end_char}\")\n\n" ]

[ 0, 0 ]

[]

[]

[ "nlp", "python", "stanford_nlp" ]

[ "You can use itertools.zip_longest to handle different length of two lists.\nfrom itertools import zip_longest\ndef add2NumberArrays(a,b):\n # Explanation: \n # list(zip_longest(a, b, fillvalue=0))\n # [(4, 2), (4, 1), (7, 2), (0, 2)]\n return [i+j for i,j in zip_longest(a, b, fillvalue=0)]\n \n\na = [4,4,7]\nb = [2,1,2,2]\n\nprint(add2NumberArrays(a,b))\n# [6, 5, 9, 2]\n\nYour code need to change like below:\ndef add2NumberArrays(a,b):\n res = []\n for i in range(0,len(a)):\n res.append(a[i]+b[i])\n return res\n\n # As a list comprehension\n # return [a[i]+b[i] for i in range(0,len(a))]\n\n\na = [4,4,7]\nb = [2,1,2]\n\nprint(add2NumberArrays(a,b))\n# [6, 5, 9]\n\n" ]

[ 0 ]

[]

[]

[ "python" ]

[]

[]

[ "I'll be very clear, I'm answering this question to test GPT. That's not my answer, I don't know the anwser. But I asked GPT.\nIf this offends anyone, feel free to delete my message.\n\nTo disable the automatic raising of exceptions for non-OK HTTP status codes, you can create your own HTTPErrorProcessor class that extends the urllib.request.HTTPDefaultErrorHandler class and overrides the http_error_default() method, like this:\nfrom urllib.request import HTTPErrorProcessor, HTTPDefaultErrorHandler\nclass MyHTTPErrorProcessor(HTTPErrorProcessor, HTTPDefaultErrorHandler):\n def http_error_default(self, req, fp, code, msg, headers):\n # do nothing and return the response object\n return fp\n\nThen, when you create an OpenerDirector object and add the handler for HTTP errors, you can use your custom MyHTTPErrorProcessor class instead of the default HTTPDefaultErrorHandler class, like this:\nfrom urllib.request import build_opener, HTTPHandler, OpenerDirector\n\n# create an OpenerDirector object\nopener = build_opener(HTTPHandler)\n\n# add the custom HTTPErrorProcessor to the opener\nopener.add_handler(MyHTTPErrorProcessor())\n\nNow, when you make a request using this opener, Python will not automatically raise an exception for non-OK HTTP status codes. You can check the HTTP status code of the response and handle it as needed, like this:\n# make a request using the opener\nresponse = opener.open(\"https://www.example.com\")\n\n# check the HTTP status code of the response\nif response.code != 200:\n print(\"Received non-OK HTTP status code:\", response.code)\nelse:\n # process the response\n ...\n\nPlease note that this solution only applies to the urllib.request module in Python 2. In Python 3, the urllib.request module has been split into several smaller modules, and the urllib.request.urlopen() function has been moved to the urllib.request.urlopen() function in the urllib.request module. The solution for disabling the automatic raising of exceptions for non-OK HTTP status codes in Python 3 is similar, but the syntax and the classes used are slightly different.\n" ]

[ -2 ]

[ "python", "urllib" ]

[ "If you want to simulate a key press and hold using the keyboard library in Python, you can use the keyboard.press_and_release method instead of the keyboard.send method. This method simulates a press and release of a key, so if you want to simulate holding down a key, you can use a loop to repeatedly call this method.\nHere's an example of how you can use the keyboard.press_and_release method to simulate holding down the \"W\" key:\nimport keyboard\n\n# simulate holding down the \"W\" key\nwhile True:\n keyboard.press_and_release('w')\n\nThis code will simulate pressing and releasing the \"W\" key repeatedly, which should have the same effect as holding down the key. You can modify this code to suit your specific use case.\n" ]

[ 0 ]

[]

[]

[ "keyboard", "python" ]

[ "You can access it like this:\ndata[\"props\"][\"XYZ\"][\"ABC\"][0][\"current\"]\n\nWhy? Key current is inside a list of dictionaries. ABC is of type list, and we access the elements using their location in the list (0 in your example).\n", "As the other answers have already explained, you need to add [0] between ['ABC'] and ['current'] because the value that corresponds to the \"ABC\" key is a list containing a dictionary with the \"current\" key, so you can access it with\ndata[\"props\"][\"XYZ\"][\"ABC\"][0][\"current\"]\n\n\nAlso, if you have a very complex and nested data structure and you want to quickly you can use this set of functions\ngetNestedVal(data, 'current')\n\nprints sold, and\ngetNestedVal(data, 'current', 'just_expr', 'data')\n\nprints data[\"props\"][\"XYZ\"][\"ABC\"][0][\"current\"] so that you can copy it from the terminal and use in your code. (It's not the best idea to use it other than for just figuring out data structure since it can use up quite a bit of time and memory.)\n", "You can access current like below:\ndata[\"props\"][\"XYZ\"][\"ABC\"][0][\"current\"]\n\nyou can get a list of dictionaries by accessing \"ABC\" key's value.\nSo whenever you get curly {} bracket it shows that it is a dictionary and you can access value of particular keys using\ndict[key] or dict.get(key,default_value)\nand whenever you get square [] bracket it shows that it is list and you can access its element by index list[0],list[1].\nSo, accessing list element and dictionary's key's value is two different things. I hope you understood my point.\n" ]

[ 1, 1, 0 ]

[]

[]

[ "beautifulsoup", "json", "python", "python_3.x", "python_requests" ]

[ "As the warning message suggests, you are missing the back_populates= attributes in your relationships:\nclass User(db.Model):\n# …\n books = db.relationship('Book', secondary=user_book, back_populates=\"users\")\n# …\n \nclass Book(db.Model):\n# …\n users = db.relationship('User', secondary=user_book, back_populates=\"books\")\n# …\n\n", "I kind of figure this out.\nAs the code in official tutorial.\nfrom sqlalchemy import Column, ForeignKey, Integer, String, Table\nfrom sqlalchemy.orm import declarative_base, relationship\n\nBase = declarative_base()\n\n\nclass User(Base):\n __tablename__ = \"user\"\n id = Column(Integer, primary_key=True)\n name = Column(String(64))\n kw = relationship(\"Keyword\", secondary=lambda: user_keyword_table)\n\n def __init__(self, name):\n self.name = name\n\n\nclass Keyword(Base):\n __tablename__ = \"keyword\"\n id = Column(Integer, primary_key=True)\n keyword = Column(\"keyword\", String(64))\n\n def __init__(self, keyword):\n self.keyword = keyword\n\n\nuser_keyword_table = Table(\n \"user_keyword\",\n Base.metadata,\n Column(\"user_id\", Integer, ForeignKey(\"user.id\"), primary_key=True),\n Column(\"keyword_id\", Integer, ForeignKey(\"keyword.id\"), primary_key=True),\n)\n\nDoesn't it make you wander why the relationship only exists in User class rather than both class ?\nThe thing is, it automatically creates the reverse relationship in Keyword class (a \"backref='users' liked parameter is required I supposed ?)\n" ]

[ 6, 1 ]

[]

[]

[ "postgresql", "python", "sqlalchemy" ]

[ "The hex() function expects an integer, that's the reason why it complains about the str object.\nYou can use help(hex) to obtain the documentation : \"Return the hexadecimal representation of an integer.\"\nIn the loop you can convert each letter to an integer thanks to the ord() function that \"returns the Unicode code point for a one-character string\".\np = tuple(hex(ord(x)) for x in MS) # ('0x48', '0x65', '0x6c', '0x6c', '0x6f')\n\n" ]

[ 0 ]

[]

[]

[ "hex", "python" ]

[]

[]

[ "Try to add str() to flame as well\nf.write(str(flow_temp)+\",\"+str(return_temp)+str(flame)+\"\\n\")\n\nor you could alternativaly write row using csv lib in python\nimport csv\n\n# create a csv.writer object\nwriter = csv.writer(f)\n\n# write the data to the CSV file\nwriter.writerow([flow_temp, return_temp, flame])\n\n" ]

[ -1 ]

[ "concatenation", "csv", "python" ]

[ "A simple list comprehension\nlst = [i**2 for i in range(3)]\n\nis interpreted as:\nlst = []\nfor i in range(3):\n lst.append(i**2)\n\nNow back to your example: So your code is currently like this:\nmy_lis = []\n\ndef l(m):\n result = []\n for x in range(m):\n result.append(my_lis.append(x))\n return result\n\n\nprint(l(10)) # [None, None, None, None, None, None, None, None, None, None]\nprint(my_lis) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n\nSo basically you're filling the my_lis when you call my_lis.append(), but .append() is an in-place method, It just adds item to the list but its return value is None and you're filling result with Nones. Indeed result is the what list comprehension hands you after-all.\n\nAs per request in comment:\nYou basically don't need extra my_lis list. The list comprehension inside the lambda gives you the final result, so:\nl = lambda m: [x for x in range(m)]\nprint(l(10))\n\nNow [x for x in range(m)] is pointless and slower here, You can directly call list on range(m):\nl = lambda m: list(range(m))\nprint(l(10))\n\n" ]

[ 2 ]

[]

[]

[ "lambda", "python" ]

[ "You can use the update_state() method and pass in the new cookies that were set in the server response. \nFor example:\nbrowser=RoboBrowser()\nbrowser.session.headers['X-Requested-With']='XMLHttpRequest'\nbrowser.open('https://example.com/test/Users/set-role?id='+role_id+'&__RequestVerificationToken='+token,method='POST')\n\n# Update cookies with new values from the server response\nbrowser.cookies = browser.response.cookies\n\nprint browser.response.content\n\nAlternatively, you can use the open() method again with the same URL to automatically update the cookies with the new values from the server response.\nbrowser=RoboBrowser()\nbrowser.session.headers['X-Requested-With']='XMLHttpRequest'\nbrowser.open('https://example.com/test/Users/set-role?id='+role_id+'&__RequestVerificationToken='+token,method='POST')\n\n# Open the same URL again to update cookies with new values\nbrowser.open('https://example.com/test/Users/set-role?id='+role_id+'&__RequestVerificationToken='+token,method='POST')\n\nprint browser.response.content\n\nYou can also use the cookies property of the RoboBrowser instance to manually access and update the cookies.\nbrowser=RoboBrowser()\nbrowser.session.headers['X-Requested-With']='XMLHttpRequest'\nbrowser.open('https://example.com/test/Users/set-role?id='+role_id+'&__RequestVerificationToken='+token,method='POST')\n\n# Update cookies with new values from the server response\nbrowser.cookies = browser.response.cookies\n\nprint browser.response.content\n\n" ]

[ 0 ]

[]

[]

[ "http", "python", "python_2.7", "python_requests", "urllib2" ]

[ "First, on windows, long (or long int) is a (signed) 32-bit (integer) type. So when asking for \"how to use atomics with long\" while at the same time allocating for 64-bit types in your code:\nresult_count = np.zeros(1, dtype=np.int64)\n\nbegs the question are you really asking about how to use atomics with long, or are you really asking about how to use atomics on a 64-bit integer type? I'll assume you want 64-bit atomics. In CUDA, atomicAdd for 64-bit integer types is only supported for unsigned types. So we will choose to use unsigned long long here, as it is unambiguously 64-bits unsigned on either windows or linux (for all currently supported CUDA activity using 64-bit OS's).\nSecond, to address your attempt in comments, you cannot do atomics on a local variable. When you use this variable:\n__global__ void test_cuda_LongIntArray(long InitianCount,\n ^^^^^^^^^^^^\n\nin a thread, that is effectively thread-local. Atomics work on global (or shared) variables. A global variable will generally be passed to a kernel using a pointer, perhaps like so:\n__global__ void test_cuda_LongIntArray(long *InitianCount,\n\nIf we aim for that (albeit using the result_count example), we can create something like this:\n$ cat t36.py\nimport pycuda.driver as cuda\nimport pycuda.autoinit\nfrom pycuda.compiler import SourceModule\nimport numpy as np\n\nInitianCount = 0\n\nrecord_result = np.zeros((10000000, 4)).astype(np.float32)\nrecord_result_gpu = cuda.mem_alloc(record_result.nbytes)\n\n# result_count = np.int64(0)\nresult_count = np.zeros(1, dtype=np.uint64)\nresult_count_gpu = cuda.mem_alloc(result_count.nbytes)\ncuda.memcpy_htod(result_count_gpu, result_count)\n\nprint('result_count.nbytes is ' + str(result_count.nbytes))\n\nmod = SourceModule(\"\"\"\n #include <cstdlib>\n\n __global__ void test_cuda_LongIntArray(long long InitianCount, unsigned long long *result_count, float *record_result)\n// __global__ void test_cuda_LongIntArray(long InitianCount, long *result_count, float *record_result)\n {\n unsigned long long result_index;\n result_index = atomicAdd(result_count,1);\n// result_index = atomicAdd(&InitianCount,1);\n }\n \"\"\")\n\nfunc = mod.get_function(\"test_cuda_LongIntArray\")\nfunc( np.int64(InitianCount), result_count_gpu, record_result_gpu, block=(4,16,16))\n\ncuda.memcpy_dtoh(record_result, record_result_gpu)\n\nprint('record_result is with dimension ' + str(len(record_result)) + ' x ' + str(len(record_result[0])))\nprint(record_result)\n\nrecord_result_gpu.free()\n$ python t36.py\nresult_count.nbytes is 8\nrecord_result is with dimension 10000000 x 4\n[[ 0. 0. 0. 0.]\n [ 0. 0. 0. 0.]\n [ 0. 0. 0. 0.]\n ...,\n [ 0. 0. 0. 0.]\n [ 0. 0. 0. 0.]\n [ 0. 0. 0. 0.]]\n$\n\n" ]

[ 1 ]

[]

[]

[ "cuda", "python" ]

[ "To disable teacher forcing in the model, you need to modify the code that generates the input and target sequences. Currently, the input sequence is constructed by taking a contiguous block of seq_length tokens from the ids tensor, starting at position i and ending at position i + seq_length. The target sequence is constructed by taking a contiguous block of seq_length tokens from the ids tensor, starting at position i + 1 and ending at position (i + 1) + seq_length.\nTo disable teacher forcing, you need to construct the input and target sequences differently. Instead of using a fixed length sequence of tokens, you should use a single token as the input and the corresponding target token. This means that you will need to loop through the ids tensor one token at a time, instead of using a fixed length block of tokens. Here is how you could modify the code to do this:\n#Train the model\nfor epoch in range(num_epochs):\n # Set initial hidden and cell states\n states = (torch.zeros(num_layers, batch_size, hidden_size).to(device),\n torch.zeros(num_layers, batch_size, hidden_size).to(device))\n \n # Loop through the tokens in the input sequence one at a time\n for i in range(0, ids.size(1)):\n # Get the current input and target tokens\n input = ids[:, i].to(device)\n target = ids[:, i+1].to(device)\n \n # Forward pass\n states = detach(states)\n outputs, states = model(input, states)\n loss = criterion(outputs, target)\n \n # Backward and optimize\n optimizer.zero_grad()\n loss.backward()\n clip_grad_norm_(model.parameters(), 0.5)\n optimizer.step()\n\n if i % 100 == 0:\n\n`\n" ]

[ 0 ]

[]

[]

[ "python", "recurrent_neural_network" ]

[ "It seems that the sources are using different terminology and definitions for \"stackful\" and \"stackless\" coroutines.\nIn the first source, \"stackful\" means that the coroutine has its own stack, which is separate from the calling function's stack. This allows the coroutine to have its own local variables and execution state, and to return to the calling function at a later time.\nIn the second source, \"stackless\" means that the coroutine does not have its own stack, and instead shares the stack with the calling function. This means that the coroutine cannot return to the calling function at a later time, and must instead be resumed from the same point in the calling function's stack.\nSo, both sources are correct, but they are talking about different aspects of coroutines. Python coroutines are stackful in the sense that they have their own stack, but they may also be considered stackless in the sense that they share the stack with the calling function.\n" ]

[ 0 ]

[]

[]

[ "coroutine", "python", "python_asyncio" ]