Datasets:

---

suriyagunasekar

/

stackoverflow-python-with-meta-data

like 12

[ "Next time, try to specify your issues and give a minimal reproducible example.\nThis is just an example how to use pd.melt and pd.groupby.\nI hope it helps with your question.\nimport pandas as pd\n\n### example dataframe\ndf = pd.DataFrame([['first', 1, 2, 3], ['second', 4, 5, 6], ['third', 7, 8, 9]], columns=['ID', 'A', 'B', 'C'])\n\n### directly sum up A, B and C\ndf['total'] = df.sum(axis=1, numeric_only=True)\nprint(df)\n\n### how to create a so called long dataframe with melt\ndf_long = pd.melt(df, id_vars='ID', value_vars=['A', 'B', 'C'], var_name='ABC')\nprint(df_long)\n\n### group long dataframe by column and sum up all values with this ID\ndf_group = df_long.groupby(by='ID').sum()\nprint(df_group)\n\n", "I'm not sure that I understand your question correctly. However, if you know exactly the column names (e.g., A, B, and C) that you want to concatenate you can do something like code below.\n''.join(merge_columns) is to concatenate column names.\nnew[merge_columns].apply(lambda x: ''.join(x), axis=1) is to concatenate their values.\nThen, you can count unique values of the new column using groupby().count().\nnew = mydata[[\"A\",\"B\",\"C\",\"D\"]]\nnew = new.rename(columns={'D': 'Total'})\nnew['Total'] = 1\n\n# added lines\nmerge_columns = ['A', 'B', 'C']\nmerged_col = ''.join(merge_columns)\nnew[merged_col] = new[merge_columns].apply(lambda x: ''.join(x), axis=1)\nnew.drop(merge_columns, axis=1, inplace=True)\nnew = new.groupby(merged_col).count().reset_index()\n\nnew.to_csv(p ,index=False)\n\nexample:\n# before\n\n> new\n\n A B C Total\n0 a b c 1\n1 x y z 1\n2 a b c 1\n\n# after execute added lines\n\n> new\n\n ABC Total\n0 abc 2\n1 xyz 1\n\n" ]

[ 0, 0 ]

[]

[]

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

[ " strings_col1 = [\"abcdefgh\", \"ijklmn\", \"opqr\", \"stuvwxyz123\"]\n sorted_list_col1 = list(sorted(strings_col1, key = len))\n print(sorted_list_col1)\n\noutput:\n\n['opqr', 'ijklmn', 'abcdefgh', 'stuvwxyz123']\n\n" ]

[ 0 ]

[]

[]

[ "excel", "openpyxl", "python" ]

[]

[]

[ "I think you want this.\nremove_item = \"eggs\"\nmyList = [\"Eggs\", \"eggS\", \"eGgS\", \"miLk\", \"milk\"]\nresult=[]\n\nmarker = set()\n\nfor l in myList:\n ll = l.lower()\n if ll != remove_item.lower():\n result.append(ll)\n\n\nprint(result)\n\n", "You would want the remove_items function to look like this:\ndef remove_items():\n global grocery_list\n item_to_remove = input(\"Which item do you want to remove? \").lower()\n newlist = grocery_list.copy()\n for item in grocery_list:\n if item.lower() == item_to_remove:\n newlist.remove(item)\n grocery_list = newlist\n\nHopefully that helps :)\nAlso, global grocery_list is there since we set grocery list to a new list later in the function, and python will error when doing this without it. The function should just need to be dropped in as a replacement of your current remove_items function.\n" ]

[ -1, -1 ]

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

[ "I found out that:\n#get all numerical and nonnull values\nshortDesc = shortDesc[shortDesc['report_id'].str.isdigit().notnull()]\n\nwas only checking if a value was not null and probably overwriting the str.isdigit() check, which caused the field \"report_id\" to not drop nonnumeric values. I changed this to two separate lines\nshortDesc = shortDesc[shortDesc['report_id'].notnull()]\nshortDesc = shortDesc[shortDesc['report_id'].str.isnumeric()]\n\nwhich allowed\nshortDesc.sort_values(by='when', inplace=True)\n\nto work as intended, I am still confused as to why .sort_values(by=\"when\") was affected by the column \"report_id\". So if anyone knows please enlighten me.\n" ]

[ 0 ]

[]

[]

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

[ "No need to capture the output of the Table. Return the Table instance and add it to your layout.\n" ]

[ 1 ]

[]

[]

[ "python", "rich" ]

[ "You need to reverse the nesting;\nallfiles = [join(root,f) for root,dirs,files in walk(root) for f in files]\n\nSee the list comprehension documentation:\n\nWhen a list comprehension is supplied, it consists of a single expression followed by at least one for clause and zero or more for or if clauses. In this case, the elements of the new list are those that would be produced by considering each of the for or if clauses a block, nesting from left to right, and evaluating the expression to produce a list element each time the innermost block is reached.\n\nIn other words, since you basically want the moral equivalent of:\nallfiles = []\nfor root, dirs, files in walk(root):\n for f in files:\n allfiles.append(f)\n\nyour list comprehension should follow the same ordering.\n", "it is:\nallfiles = [join(root, f) for _, dirs, files in walk(root) for f in files]\n\n", "\nA different option, remove .replace() if you want absolute path.*\n\nimport os\n\nworking_dir = os.getcwd()\nfile_list = [os.path.join(\ndirpath, file).replace(\n working_dir, \"\") for (\n dirpath, dirnames, filenames) in os.walk(\n working_dir) for file in filenames]\nprint(file_list)\n\nPython 3 Version.\n" ]

[ 29, 5, 0 ]

[]

[]

[ "list_comprehension", "python" ]

[ "This issue occurs probably due to some issue with the code which is returning elements in GlobalWindow while the PCollection has a different window set. For your requirement, I would suggest you to insert beam.WindowInto(beam.window.GlobalWindows()) between beam.WindowInto(NONGLOBALWINDOW) | beam.GroupByKey() and other Ptransform which causes problems.\n" ]

[ 0 ]

[]

[]

[ "apache_beam", "google_bigquery", "google_cloud_dataflow", "google_cloud_platform", "python" ]

[ "As was pointed out in the comments, the issue is caused by using the same name error for your custom exception class and for a boolean variable which you seem to have intended to use to track the current status. Once you run:\nclass error(BaseException):\n pass\n\nerror is now a class, which is not False so the while loop doesn't run any more.\nSince you have break and continue statements in your while loop, you don't actually need to track the status of whether or not an error occurred on the previous iteration. Also, don't you want to prompt the user for new input each time? Like this:\nwhile True:\n \n n = int(input(\"Enter: \"))\n\n class error(BaseException):\n pass\n try:\n def number(n):\n if n == 2:\n print(\"correct\")\n else:\n raise error\n number(n)\n break\n \n except error:\n print(\"Error\")\n continue\n\nExample input/output:\nEnter: 4\nError\nEnter: 3\nError\nEnter: 6\nError\nEnter: 9\nError\nEnter: 2\ncorrect\n\n" ]

[ 0 ]

[]

[]

[ "python", "while_loop" ]

[ "You'll most likely want to use the RbacAuthorizationV1Api. Afterward you can call create_namespaced_role and create_namespaced_role_binding to make what you need.\nA snippet might look like\nfrom kubernetes import client, config\n\nconfig.load_incluster_config()\npolicy_api = client.RbacAuthorizationV1Api()\nrole = client.V1Role(\n metadata=client.V1ObjectMeta(name=\"my-role\"),\n rules=[client.V1PolicyRule([\"\"], resources=[\"pods\"], verbs=[\"get\", \"list\"])],\n)\npolicy_api.create_namespaced_role(namespace=\"my-namespace\", body=role)\n\nrole_binding = client.V1RoleBinding(\n metadata=client.V1ObjectMeta(namespace=\"my-namespace\", name=\"my-role-binding\"),\n subjects=[\n client.V1Subject(\n name=\"user\", kind=\"User\", api_group=\"rbac.authorization.k8s.io\"\n )\n ],\n role_ref=client.V1RoleRef(\n api_group=\"rbac.authorization.k8s.io\", kind=\"Role\", name=\"user-role\"\n ),\n)\npolicy_api.create_namespaced_role_binding(namespace=\"my-namespace\", body=role_binding)\n\n\nSome more useful examples here.\n" ]

[ 0 ]

[]

[]

[ "client", "k8s_serviceaccount", "kubernetes", "programmatically", "python" ]

[ "If you use a web server to serve your application you could manage it with it, for example with nginx you could do:\nlocation = /some_path {\n return 301 /;\n}\n\nOr you can use a middleware:\nclass PrefixMiddleware(object):\n def __init__(self, app, prefix=\"\"):\n self.app = app\n self.prefix = prefix\n\n def __call__(self, environ, start_response):\n\n if environ[\"PATH_INFO\"].startswith(self.prefix):\n environ[\"PATH_INFO\"] = environ[\"PATH_INFO\"][len(self.prefix) :]\n environ[\"SCRIPT_NAME\"] = self.prefix\n return self.app(environ, start_response)\n else:\n #handle not found\n\nThen register your middleware by adding the prefix to \"ignore\"\napp = Flask(__name__)\napp.wsgi_app = PrefixMiddleware(biosfera_fe.wsgi_app, prefix=\"/some_path\")\n\n" ]

[ 0 ]

[]

[]

[ "api", "flask", "python" ]

[ "Python has a built in method called count that would work very well here \ntext = \"mango mango peach apple apple banana\"\nwords = text.split()\n\nfor word in words:\n if text.count(word) == 1:\n print(word)\n else:\n pass\n\n\n(xenial)vash@localhost:~/python/stack_overflow$ python3.7 mango.py \npeach\nbanana\n\n\nUsing list comprehension you can do this \n[print(word) for word in words if text.count(word) == 1]\n\n", "seq = \"mango mango peach\".split()\n[x for x in seq if x not in seq[seq.index(x)+1:]]\n\n", "First - split you string with empty space delimiter (split() method), than use Counter or calculate frequencies by your own code.\n", "You can use a Counter to find the number of occurrences of each word, then make a list of all words that appear only once.\nfrom collections import Counter\n\nphrase = \"mango peach mango\"\n\ncounts = Counter(phrase.split())\n\nprint([word for word, count in counts.items() if count == 1])\n# ['peach']\n\n", "sentence = \"mango mango peach\"\na)Convert the sentence into a list\nwords = sentence.split()\nprint(words)\nb)Convert the list into a set. Only unique words will be stored in the set\nunique_words = set(words)\nprint(unique_words)\n" ]

[ 4, 2, 0, 0, 0 ]

[]

[]

[ "python" ]

[ "The watchdog works via inotify mechanism and will only notify you that a file had been changed, created or deleted. There is no information in the filesystem about who did the change. The information you have is basically the same information that you would get by looking at a directory listing such as with ls -al.\nAssuming you are working on Linux, a file has an owner and a group. Typically, they are set according to the UID/GID of a process that creates the file, and remain unchanged even if a process with another UID/GID modifies the file (unless explicitly changed with chmod/chgrp).\nTo track filesystem changes in more detail, you probably need to use the audit subsystem, but that's a completely different story.\n" ]

[ 0 ]

[]

[]

[ "python", "python_3.x" ]

[ "Had the same problem, and downgrading TensorFlow from 2.11 fixed it. First remove the existing version:\npip uninstall tensorflow-cpu\n\nThen re-install, this time with 2.10.0:\npip install tensorflow-cpu==2.10.0\n\nAfter that, try importing it in Python. You should see something like the following (apologies for the messy output):\n>>> import tensorflow as tf\n2022-11-28 22:41:21.693757: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations: AVX2 AVX512F AVX512_VNNI FMA\nTo enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n2022-11-28 22:41:21.806150: I tensorflow/core/util/util.cc:169] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n2022-11-28 22:41:22.982148: I tensorflow/c/logging.cc:34] Successfully opened dynamic library libdirectml.d6f03b303ac3c4f2eeb8ca631688c9757b361310.so\n2022-11-28 22:41:22.982289: I tensorflow/c/logging.cc:34] Successfully opened dynamic library libdxcore.so\n2022-11-28 22:41:22.996385: I tensorflow/c/logging.cc:34] Successfully opened dynamic library libd3d12.so\n2022-11-28 22:41:27.615851: I tensorflow/c/logging.cc:34] DirectML device enumeration: found 1 compatible adapters.\n\nYou can test that it works by adding two tensors. Running a command like the following:\nprint(tf.add([1.0, 2.0], [3.0, 4.0]))\n\nAnd somewhere in the output, you should be able to verify that DirectML has found your GPU:\n2022-11-28 22:43:42.632447: I tensorflow/c/logging.cc:34] DirectML: creating device on adapter 0 (NVIDIA GeForce RTX 3080)\n\nHope this helps!\n" ]

[ 0 ]

[]

[]

[ "anaconda", "python", "tensorflow", "tensorflow2.0" ]

[ "If event has no \"\" surrounding, it has converted to dict already. However, you need to deal with json for Message.\nimport json\n\nmsg = event['Records'][0]['Sns']['Message']\ndeploymentGroupName = json.loads(msg)['deploymentGroupName']\ndeploymentGroupName\n\noutput:\n'Sandbox-ec2-deployment'\n\n" ]

[ 2 ]

[]

[]

[ "aws_lambda", "json", "lambda", "python" ]

[ "After much digging, I've found a solution (with some caveats) -\nyou'll need both homebrew and pyenv installed for this to work. The idea is to replace your old deprecated tkinter installation with an up-to-date one that actually works*\n\nNote that this will wipe out any packages you’ve installed with pip - back those up first!\n\nRun the following commands\n\nbrew uninstall tcl-tk uninstall the old tk if you have it\n\npyenv uninstall 3.10.5 ...or whatever your current global Python version is\n\nbrew install tcl-tk grab a fresh install of tk\n\npyenv install 3.10.5 grab a fresh install of Python 3.10.5 (or whichever)\n\npyenv global 3.10.5 set your global Python version (matching the version you just installed above)\n\n\nYou need to install tk via homebrew before installing Python with pyenv because pyenv will automatically try to use whatever tk package it can find when it installs Python.\nFinal Thoughts\n\nIf you don't already have homebrew installed, here are good instructions\n\nIf you don't have pyenv, just run brew install pyenv\n\nYou’ll probably need to select your preferred Python interpreter in VSCode again\n\n\n*This worked for me - YMMV\n", "I have the same issue on an M1 Pro. Works just fine on the intel Mac but not the M1. I have a further issue on the file dialog in which the file type does not appear in the M1 but works perfectly on the Intel Mac.\nI am not convinced that the hardware is the problem but more that it is the port of Tkinter to the platform.\n", "Install/activate and import all globally installed packages in a new virtual environment by running the command\npip install virtualenv\nvirtualenv venv --system-site-packages\nsource venv/bin/activate\n", "Had the same issue with Python 3.8 and Mac os Monterey; I've followed these steps to fix the issue:\n\nUpgraded Mac Os to the latest version\nUpgraded Python to 3.10/ 3.11\n\nMy issue was fixed.\n" ]

[ 3, 0, 0, 0 ]

[]

[]

[ "macos", "python", "tkinter" ]

[ "I tried the tutorial. I found the problem you mentioned. Actually, the settings.py file in your screenshot is the \".settings\" file you are missing.\nAnd you want to know how to deploy Django CMS on IIS Server. You can refer to this tutorial for the steps. Hope it is useful for you.\n" ]

[ 0 ]

[]

[]

[ "cgi", "django_cms", "iis", "python", "window" ]

[ "Breaks.objects.filter(date__range=[\"2011-01-01\", \"2011-01-31\"])\n\nOr if you are just trying to filter month wise:\nBreaks.objects.filter(date__year='2011', \n date__month='01')\n\nPlease reply to this message ,If it doesn't work.\n" ]

[ 0 ]

[]

[]

[ "django", "python" ]

[ "For Data Augmentation methods in FastAI 2 you have to use other methods names, for example:\naug_transforms\n", "I got the same question, fastai 1.0.61 could probably solve the problem.\n", "Enter this code at the very beginning and download it :\n!pip install \"torch==1.4\" \"torchvision==0.5.0\"\n\n" ]

[ 4, 0, 0 ]

[]

[]

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

[ "The best option would be to use a defaultdict.\nfrom collections import defaultdict\n\nout = defaultdict(list)\n\n#data is the list in question\n\nfor rec in data:\n for key,value in rec.items():\n out[key].append(value)\n\n\nA defaultdict returns a default value in case the key does not exist. dict.items is a method that returns and iterator of the key value pairs.\nYou can do it faster using pandas, but it would be overkill unless you have a huge dataset.\n" ]

[ 1 ]

[]

[]

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

[ "Python is a very dynamic language. Classes acts like molds, they can create instance according to a specific shape, but unlike other languages where shapes are fixed, in Python you can (nearly) always modify their shape.\nI never heard of \"data attribute\" in this context, so I'm not surprised that you did find nothing to explain this behavior.\nInstead, I recommend you the Python data model documentation. Under \"Class instances\" :\n\n[...] A class instance has a namespace implemented as a dictionary which is the first place in which attribute references are searched. When an attribute is not found there, and the instance’s class has an attribute by that name, the search continues with the class attributes.\n[...]\nSpecial attributes: __dict__ is the attribute dictionary; __class__ is the instance’s class.\n\nPython looks simple on the surface level, but what happens when you do a.my_value is rather complex. For the simple cases, my_value is an instance variable, which usually is defined during the class declaration, like so :\nclass Something:\n def __init__(self, parameter):\n self.my_value = parameter # storing the parameter in an instance variable (self)\n\na = Something(1)\nb = Something(2)\n\n# instance variables are not shared (by default)\nprint(a.my_value) # 1\nprint(b.my_value) # 2\na.my_value = 10\nb.my_value = 20\nprint(a.my_value) # 10\nprint(b.my_value) # 20\n\nBut it would have worked without the __init__:\nclass Something:\n pass # nothing special\n\na = Something()\na.my_value = 1 # we have to set it ourselves, because there is no more __init__\nb = Something()\nb.my_value = 2 # same\n\n# and we get the same results as before :\nprint(a.my_value) # 1\nprint(b.my_value) # 2\na.my_value = 10\nb.my_value = 20\nprint(a.my_value) # 10\nprint(b.my_value) # 20\n\nBecause each instance uses a dictionary to store its attributes (methods and fields), and you can edit this dictionary, then you can edit the fields of any object at any moment. This is both very handy sometimes, and very annoying other times.\nExample of the instance's __dict__ attribute :\nclass Something:\n pass # nothing special\n\na = Something()\nprint(a.__dict__) # {}\na.my_value = 1\nprint(a.__dict__) # {'my_value': 1}\na.my_value = 10\nprint(a.__dict__) # {'my_value': 10}\n\nBecause it did not existed before, it got added to the __dict__. Then it just got modified.\nAnd if we create another Something:\nb = Something()\nprint(a.__dict__) # {'my_value': 10}\nprint(b.__dict__) # {}\n\nThey were created with the same mold (the Something class) but one got modified afterwards.\nThe usual way to set attributes to instances is with the __init__ method :\nclass Something:\n def __init__(self, param):\n print(self.__dict__) # {}\n self.my_value = param\n print(self.__dict__) # {'my_value': 1}\n\na = Something(1)\nprint(a.__dict__) # {'my_value': 1}\n\nIt does exactly what we did before : add a new entry in the instance's __dict__. In that way, __init__ is not much more than a convention of where to put all your fields declarations, but you can do without.\nIt comes from the face that everything in Python is a dynamic object, that you can edit anytime. For example, that's the way modules work too :\nimport sys\nthis_module = sys.modules[__name__]\n\nprint(this_module.__dict__) # {... a bunch of things ...}\n\nMODULE_VAR = 4\n\nprint(this_module.__dict__) # {... a bunch of things ..., 'MODULE_VAR': 4}\n\nThis is a core feature of Python, its dynamic nature sometime makes things easy. For example, it enables duck typing, monkey patching, instrospection, ... But in a large codebases, without coding rules, you can quickly get a mess of undeclared instances everywhere. Nowadays, we try to write less clever, more reliable code, so adding new attributes to instances outside of the __init__ is indeed frowned upon.\n" ]

[ 1 ]

[]

[]

[ "attributes", "class", "python" ]

[]

[]

[ "Here is the error:\nhonda = brands1.get_group([brand, year]), please share more info, because it suits you.\n" ]

[ -1 ]

[ "pandas", "python" ]

[ "There is a mismatch between the path parameter in the path string and the function argument. Rename the function argument to question_id\[email protected](\n \"/{question_id}\",\n tags=[\"questions\"],\n status_code=status.HTTP_200_OK,\n response_model=Question,\n dependencies=[Depends(get_db)],\n)\ndef get_question(question_id: int = Path(..., gt=0)):\n return get_question_service(question_id)\n\nor the path parameter to id:\[email protected](\n \"/{id}\",\n tags=[\"questions\"],\n status_code=status.HTTP_200_OK,\n response_model=Question,\n dependencies=[Depends(get_db)],\n)\ndef get_question(id: int = Path(..., gt=0)):\n return get_question_service(id)\n\n\nBtw, ... in Path can be omitted.\nid: int = Path(gt=0) is equivalent to id: int = Path(gt=0)\n" ]

[ 0 ]

[]

[]

[ "fastapi", "fastapi_crudrouter", "python" ]

[ "It looks like your script wants to open some sort of graphical user interface.\nYou can try to install an X11 server on windows and configure this in WSL. That way you can open a graphical window in WSL. You should be able to find some tutorials online, but it can be a bit tedious. This could help you to get started, but there are multiple ways and tools.\nLater versions of WSL should support graphical interfaces out-of-the-box. I think you'll need Windows 11. (However, I have never tried it so far)\nThis might help.\n", "So I managed to fix the issue. I am not sure exactly why WSL was failing to launch the GUI application, I first thought it had something to do with X11, but I have the lastest version of WSL, which is supposed to have native GUI support. Next, I thought it had something to do with the python packages, because I had a working version of the code in a Virtual environment on my normal windows 11, I just didn't use it because it was unable to do multiprocessing. So to solve this, I copied the libs folder from the venv in my windows to the venv on my WSL. For some reason, it solved the problem. My initial reason for not doing this was because it didn't say I was missing any dependencies.\nThanks for those who tried to help though.\n" ]

[ 0, 0 ]

[]

[]

[ "pybullet", "python", "windows_subsystem_for_linux" ]

[ "The error is thrown because Python 3 opens your files with a default encoding that doesn't match the contents.\nIf all you are doing is copying file contents, you'd be better off using the shutil.copyfileobj() function together with opening the files in binary mode. That way you avoid encoding issues altogether (as long as all your source files are the same encoding of course, so you don't end up with a target file with mixed encodings):\nimport shutil\nimport os.path\n\nwith open('C:\\\\Dropbox\\\\Python\\\\master.txt','wb') as output:\n for path, f_name in files:\n with open(os.path.join(path, f_name), 'rb') as input:\n shutil.copyfileobj(input, output)\n output.write(b'\\n') # insert extra newline between files\n\nI've cleaned up the code a little to use context managers (so your files get closed automatically when done) and to use os.path to create the full path for your files.\nIf you do need to process your input line by line you'll need to tell Python what encoding to expect, so it can decode the file contents to python string objects:\nopen(path, mode, encoding='UTF8')\n\nNote that this requires you to know up front what encoding the files use.\nRead up on the Python Unicode HOWTO if you have further questions about python 3, files and encodings.\n", "I faced the similar issue while removing the file using os module remove function.\nThe required changes i performed is:\nfile = open(filename)\n\nto\nfile = open(filename, encoding=\"utf8\")\n\nAdd an encoding=“utf-8”\nUTF-8 is one of the most commonly used encodings, and Python often defaults to using it. UTF stands for “Unicode Transformation Format”, and the '8' means that 8-bit values are used in the encoding. ... UTF-8 uses the following rules: If the code point is < 128, it's represented by the corresponding byte value.\n" ]

[ 18, 4 ]

[ "Handling import and decode error with file handling\n\nOpen file with full absolute path\n\n(source - absolute path for directory of file folder, getting all files inside file_folder)\nimport os\nfile_list = os.listdir(source)\nfor file in file_list:\n absolute_file_path = os.path.join(source,file) \n file = open(absolute_file_path)\n\n\nEncoding the file as we open\n\nfile = open(absolute_file_path, mode, encoding, errors=ignore)\n" ]

[ -1 ]

[ "file_io", "python", "python_3.x", "python_unicode", "traceback" ]

[ "Looks like the title attribute is the only way to uniquely identify the link you wish to click, therefore in Selenium 4 syntax:\nselecdia = navegador.find_element(By.CSS_SELECTOR, \"a[title='30 de novembro']\")\n\nor:\nselecdia = navegador.find_element(By.XPATH, \"//a[@title='30 de novembro']\")\n\n" ]

[ 0 ]

[]

[]

[ "beautifulsoup", "pandas", "python", "selenium", "web_scraping" ]

[ "You can use onchange function and return lots_id field domain when the needs_auth field value change.\nExample:\[email protected](\"needs_auth\")\ndef _update_lots_id_domain(self):\n domain = [('product_id', '=?', self.product_id.id)]\n if self.needs_auth:\n domain.append(\n ('q_auth', '!=', False)\n )\n return {'domain': {'lots_id': domain}}\n\n", "How about using t-if / t-else:\n<xpath expr=\"//field[@name='lot_id']\" position=\"replace\">\n <field name=\"q_auth\" invisible=\"1\"/>\n <t t-if=\"needs_auth\"> \n <field name=\"lots_id\" groups=\"stock.group_production_lot\"\n domain=\"[('product_id','=?', product_id),('q_auth','!=',False)]\"\n context=\"{'product_id': product_id}\"/>\n </t>\n <t t-else=\"\">\n <field name=\"lots_id\" groups=\"stock.group_production_lot\"\n domain=\"[('product_id','=?', product_id)]\"\n context=\"{'product_id': product_id}\"/>\n </t>\n</xpath>\n\n" ]

[ 0, 0 ]

[]

[]

[ "odoo", "odoo_8", "python", "xml" ]

[ "You can use: errors ='ignore', Where both text and numbers are given.\nThere are other ways of preprocessing, you just need to know what you need it for.\n" ]

[ 0 ]

[]

[]

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

[ "It might be an array containing an empty string:\nis_empty = F.udf(lambda arr: arr == [''], T.BooleanType())\n\nOr it might be an array of null:\nis_empty = F.udf(lambda arr: arr == [None], T.BooleanType())\n\nTo check them all at once you can use:\nis_empty = F.udf(lambda arr: arr in [[], [''], [None]], T.BooleanType())\n\nBut actually you don't need a UDF for this, e.g. you can do:\ndf.filter(\"fruits = array() or fruits = array('') or fruits = array(null)\")\n\n", "You can do it by checking the length if the array.\nis_empty = F.udf(lambda arr: len(arr) == 0, T.BooleanType())\ndf.filter(is_empty(df.fruits).count()\n\n", "If you don't want to use UDF, you can use F.size to get the size of the array.\nTo filter empty array:\ndf.filter(F.size(df.fruits) == 0)\n\nTo filter non-empty array:\ndf.filter(F.size(df.fruits) != 0)\n\n" ]

[ 3, 2, 0 ]

[]

[]

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

[ "Since version 1.7.0, NumPy has a choice function that supports probability distributions.\nfrom numpy.random import choice\ndraw = choice(list_of_candidates, number_of_items_to_pick,\n p=probability_distribution)\n\nNote that probability_distribution is a sequence in the same order of list_of_candidates. You can also use the keyword replace=False to change the behavior so that drawn items are not replaced.\n", "Since Python 3.6 there is a method choices from the random module.\nIn [1]: import random\n\nIn [2]: random.choices(\n...: population=[['a','b'], ['b','a'], ['c','b']],\n...: weights=[0.2, 0.2, 0.6],\n...: k=10\n...: )\n\nOut[2]:\n[['c', 'b'],\n ['c', 'b'],\n ['b', 'a'],\n ['c', 'b'],\n ['c', 'b'],\n ['b', 'a'],\n ['c', 'b'],\n ['b', 'a'],\n ['c', 'b'],\n ['c', 'b']]\n\nNote that random.choices will sample with replacement, per the docs:\n\nReturn a k sized list of elements chosen from the population with replacement.\n\nNote for completeness of answer:\n\nWhen a sampling unit is drawn from a finite population and is returned\nto that population, after its characteristic(s) have been recorded,\nbefore the next unit is drawn, the sampling is said to be \"with\nreplacement\". It basically means each element may be chosen more than\nonce.\n\nIf you need to sample without replacement, then as @ronan-paixão's brilliant answer states, you can use numpy.choice, whose replace argument controls such behaviour.\n", "def weighted_choice(choices):\n total = sum(w for c, w in choices)\n r = random.uniform(0, total)\n upto = 0\n for c, w in choices:\n if upto + w >= r:\n return c\n upto += w\n assert False, \"Shouldn't get here\"\n\n", "\nArrange the weights into a\ncumulative distribution.\nUse random.random() to pick a random\nfloat 0.0 <= x < total. \nSearch the\ndistribution using bisect.bisect as\nshown in the example at http://docs.python.org/dev/library/bisect.html#other-examples.\n\nfrom random import random\nfrom bisect import bisect\n\ndef weighted_choice(choices):\n values, weights = zip(*choices)\n total = 0\n cum_weights = []\n for w in weights:\n total += w\n cum_weights.append(total)\n x = random() * total\n i = bisect(cum_weights, x)\n return values[i]\n\n>>> weighted_choice([(\"WHITE\",90), (\"RED\",8), (\"GREEN\",2)])\n'WHITE'\n\nIf you need to make more than one choice, split this into two functions, one to build the cumulative weights and another to bisect to a random point.\n", "If you don't mind using numpy, you can use numpy.random.choice.\nFor example:\nimport numpy\n\nitems = [[\"item1\", 0.2], [\"item2\", 0.3], [\"item3\", 0.45], [\"item4\", 0.05]\nelems = [i[0] for i in items]\nprobs = [i[1] for i in items]\n\ntrials = 1000\nresults = [0] * len(items)\nfor i in range(trials):\n res = numpy.random.choice(items, p=probs) #This is where the item is selected!\n results[items.index(res)] += 1\nresults = [r / float(trials) for r in results]\nprint \"item\\texpected\\tactual\"\nfor i in range(len(probs)):\n print \"%s\\t%0.4f\\t%0.4f\" % (items[i], probs[i], results[i])\n\nIf you know how many selections you need to make in advance, you can do it without a loop like this:\nnumpy.random.choice(items, trials, p=probs)\n\n", "As of Python v3.6, random.choices could be used to return a list of elements of specified size from the given population with optional weights.\n\nrandom.choices(population, weights=None, *, cum_weights=None, k=1)\n\n\npopulation : list containing unique observations. (If empty, raises IndexError)\nweights : More precisely relative weights required to make selections.\ncum_weights : cumulative weights required to make selections.\nk : size(len) of the list to be outputted. (Default len()=1)\n\n\nFew Caveats:\n1) It makes use of weighted sampling with replacement so the drawn items would be later replaced. The values in the weights sequence in itself do not matter, but their relative ratio does.\nUnlike np.random.choice which can only take on probabilities as weights and also which must ensure summation of individual probabilities upto 1 criteria, there are no such regulations here. As long as they belong to numeric types (int/float/fraction except Decimal type) , these would still perform.\n>>> import random\n# weights being integers\n>>> random.choices([\"white\", \"green\", \"red\"], [12, 12, 4], k=10)\n['green', 'red', 'green', 'white', 'white', 'white', 'green', 'white', 'red', 'white']\n# weights being floats\n>>> random.choices([\"white\", \"green\", \"red\"], [.12, .12, .04], k=10)\n['white', 'white', 'green', 'green', 'red', 'red', 'white', 'green', 'white', 'green']\n# weights being fractions\n>>> random.choices([\"white\", \"green\", \"red\"], [12/100, 12/100, 4/100], k=10)\n['green', 'green', 'white', 'red', 'green', 'red', 'white', 'green', 'green', 'green']\n\n2) If neither weights nor cum_weights are specified, selections are made with equal probability. If a weights sequence is supplied, it must be the same length as the population sequence. \nSpecifying both weights and cum_weights raises a TypeError.\n>>> random.choices([\"white\", \"green\", \"red\"], k=10)\n['white', 'white', 'green', 'red', 'red', 'red', 'white', 'white', 'white', 'green']\n\n3) cum_weights are typically a result of itertools.accumulate function which are really handy in such situations. \n\n From the documentation linked: \nInternally, the relative weights are converted to cumulative weights\n before making selections, so supplying the cumulative weights saves\n work.\n\nSo, either supplying weights=[12, 12, 4] or cum_weights=[12, 24, 28] for our contrived case produces the same outcome and the latter seems to be more faster / efficient.\n", "Crude, but may be sufficient:\nimport random\nweighted_choice = lambda s : random.choice(sum(([v]*wt for v,wt in s),[]))\n\nDoes it work?\n# define choices and relative weights\nchoices = [(\"WHITE\",90), (\"RED\",8), (\"GREEN\",2)]\n\n# initialize tally dict\ntally = dict.fromkeys(choices, 0)\n\n# tally up 1000 weighted choices\nfor i in xrange(1000):\n tally[weighted_choice(choices)] += 1\n\nprint tally.items()\n\nPrints:\n[('WHITE', 904), ('GREEN', 22), ('RED', 74)]\n\nAssumes that all weights are integers. They don't have to add up to 100, I just did that to make the test results easier to interpret. (If weights are floating point numbers, multiply them all by 10 repeatedly until all weights >= 1.)\nweights = [.6, .2, .001, .199]\nwhile any(w < 1.0 for w in weights):\n weights = [w*10 for w in weights]\nweights = map(int, weights)\n\n", "If you have a weighted dictionary instead of a list you can write this\nitems = { \"a\": 10, \"b\": 5, \"c\": 1 } \nrandom.choice([k for k in items for dummy in range(items[k])])\n\nNote that [k for k in items for dummy in range(items[k])] produces this list ['a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'c', 'b', 'b', 'b', 'b', 'b']\n", "Here's is the version that is being included in the standard library for Python 3.6:\nimport itertools as _itertools\nimport bisect as _bisect\n\nclass Random36(random.Random):\n \"Show the code included in the Python 3.6 version of the Random class\"\n\n def choices(self, population, weights=None, *, cum_weights=None, k=1):\n \"\"\"Return a k sized list of population elements chosen with replacement.\n\n If the relative weights or cumulative weights are not specified,\n the selections are made with equal probability.\n\n \"\"\"\n random = self.random\n if cum_weights is None:\n if weights is None:\n _int = int\n total = len(population)\n return [population[_int(random() * total)] for i in range(k)]\n cum_weights = list(_itertools.accumulate(weights))\n elif weights is not None:\n raise TypeError('Cannot specify both weights and cumulative weights')\n if len(cum_weights) != len(population):\n raise ValueError('The number of weights does not match the population')\n bisect = _bisect.bisect\n total = cum_weights[-1]\n return [population[bisect(cum_weights, random() * total)] for i in range(k)]\n\nSource: https://hg.python.org/cpython/file/tip/Lib/random.py#l340\n", "A very basic and easy approach for a weighted choice is the following:\nnp.random.choice(['A', 'B', 'C'], p=[0.3, 0.4, 0.3])\n\n", "import numpy as np\nw=np.array([ 0.4, 0.8, 1.6, 0.8, 0.4])\nnp.random.choice(w, p=w/sum(w))\n\n", "I'm probably too late to contribute anything useful, but here's a simple, short, and very efficient snippet:\ndef choose_index(probabilies):\n cmf = probabilies[0]\n choice = random.random()\n for k in xrange(len(probabilies)):\n if choice <= cmf:\n return k\n else:\n cmf += probabilies[k+1]\n\nNo need to sort your probabilities or create a vector with your cmf, and it terminates once it finds its choice. Memory: O(1), time: O(N), with average running time ~ N/2. \nIf you have weights, simply add one line:\ndef choose_index(weights):\n probabilities = weights / sum(weights)\n cmf = probabilies[0]\n choice = random.random()\n for k in xrange(len(probabilies)):\n if choice <= cmf:\n return k\n else:\n cmf += probabilies[k+1]\n\n", "If your list of weighted choices is relatively static, and you want frequent sampling, you can do one O(N) preprocessing step, and then do the selection in O(1), using the functions in this related answer.\n# run only when `choices` changes.\npreprocessed_data = prep(weight for _,weight in choices)\n\n# O(1) selection\nvalue = choices[sample(preprocessed_data)][0]\n\n", "If you happen to have Python 3, and are afraid of installing numpy or writing your own loops, you could do:\nimport itertools, bisect, random\n\ndef weighted_choice(choices):\n weights = list(zip(*choices))[1]\n return choices[bisect.bisect(list(itertools.accumulate(weights)),\n random.uniform(0, sum(weights)))][0]\n\nBecause you can build anything out of a bag of plumbing adaptors! Although... I must admit that Ned's answer, while slightly longer, is easier to understand.\n", "I looked the pointed other thread and came up with this variation in my coding style, this returns the index of choice for purpose of tallying, but it is simple to return the string ( commented return alternative):\nimport random\nimport bisect\n\ntry:\n range = xrange\nexcept:\n pass\n\ndef weighted_choice(choices):\n total, cumulative = 0, []\n for c,w in choices:\n total += w\n cumulative.append((total, c))\n r = random.uniform(0, total)\n # return index\n return bisect.bisect(cumulative, (r,))\n # return item string\n #return choices[bisect.bisect(cumulative, (r,))][0]\n\n# define choices and relative weights\nchoices = [(\"WHITE\",90), (\"RED\",8), (\"GREEN\",2)]\n\ntally = [0 for item in choices]\n\nn = 100000\n# tally up n weighted choices\nfor i in range(n):\n tally[weighted_choice(choices)] += 1\n\nprint([t/sum(tally)*100 for t in tally])\n\n", "A general solution:\nimport random\ndef weighted_choice(choices, weights):\n total = sum(weights)\n treshold = random.uniform(0, total)\n for k, weight in enumerate(weights):\n total -= weight\n if total < treshold:\n return choices[k]\n\n", "Here is another version of weighted_choice that uses numpy. Pass in the weights vector and it will return an array of 0's containing a 1 indicating which bin was chosen. The code defaults to just making a single draw but you can pass in the number of draws to be made and the counts per bin drawn will be returned.\nIf the weights vector does not sum to 1, it will be normalized so that it does. \nimport numpy as np\n\ndef weighted_choice(weights, n=1):\n if np.sum(weights)!=1:\n weights = weights/np.sum(weights)\n\n draws = np.random.random_sample(size=n)\n\n weights = np.cumsum(weights)\n weights = np.insert(weights,0,0.0)\n\n counts = np.histogram(draws, bins=weights)\n return(counts[0])\n\n", "It depends on how many times you want to sample the distribution. \nSuppose you want to sample the distribution K times. Then, the time complexity using np.random.choice() each time is O(K(n + log(n))) when n is the number of items in the distribution. \nIn my case, I needed to sample the same distribution multiple times of the order of 10^3 where n is of the order of 10^6. I used the below code, which precomputes the cumulative distribution and samples it in O(log(n)). Overall time complexity is O(n+K*log(n)).\nimport numpy as np\n\nn,k = 10**6,10**3\n\n# Create dummy distribution\na = np.array([i+1 for i in range(n)])\np = np.array([1.0/n]*n)\n\ncfd = p.cumsum()\nfor _ in range(k):\n x = np.random.uniform()\n idx = cfd.searchsorted(x, side='right')\n sampled_element = a[idx]\n\n", "There is lecture on this by Sebastien Thurn in the free Udacity course AI for Robotics. Basically he makes a circular array of the indexed weights using the mod operator %, sets a variable beta to 0, randomly chooses an index,\nfor loops through N where N is the number of indices and in the for loop firstly increments beta by the formula:\nbeta = beta + uniform sample from {0...2* Weight_max}\nand then nested in the for loop, a while loop per below:\nwhile w[index] < beta:\n beta = beta - w[index]\n index = index + 1\n\nselect p[index]\n\nThen on to the next index to resample based on the probabilities (or normalized probability in the case presented in the course).\nOn Udacity find Lesson 8, video number 21 of Artificial Intelligence for Robotics where he is lecturing on particle filters.\n", "Another way of doing this, assuming we have weights at the same index as the elements in the element array.\nimport numpy as np\nweights = [0.1, 0.3, 0.5] #weights for the item at index 0,1,2\n# sum of weights should be <=1, you can also divide each weight by sum of all weights to standardise it to <=1 constraint.\ntrials = 1 #number of trials\nnum_item = 1 #number of items that can be picked in each trial\nselected_item_arr = np.random.multinomial(num_item, weights, trials)\n# gives number of times an item was selected at a particular index\n# this assumes selection with replacement\n# one possible output\n# selected_item_arr\n# array([[0, 0, 1]])\n# say if trials = 5, the the possible output could be \n# selected_item_arr\n# array([[1, 0, 0],\n# [0, 0, 1],\n# [0, 0, 1],\n# [0, 1, 0],\n# [0, 0, 1]])\n\nNow let's assume, we have to sample out 3 items in 1 trial. You can assume that there are three balls R,G,B present in large quantity in ratio of their weights given by weight array, the following could be possible outcome:\nnum_item = 3\ntrials = 1\nselected_item_arr = np.random.multinomial(num_item, weights, trials)\n# selected_item_arr can give output like :\n# array([[1, 0, 2]])\n\nyou can also think number of items to be selected as number of binomial/ multinomial trials within a set. So, the above example can be still work as\nnum_binomial_trial = 5\nweights = [0.1,0.9] #say an unfair coin weights for H/T\nnum_experiment_set = 1\nselected_item_arr = np.random.multinomial(num_binomial_trial, weights, num_experiment_set)\n# possible output\n# selected_item_arr\n# array([[1, 4]])\n# i.e H came 1 time and T came 4 times in 5 binomial trials. And one set contains 5 binomial trails.\n\n", "One way is to randomize on the total of all the weights and then use the values as the limit points for each var. Here is a crude implementation as a generator.\ndef rand_weighted(weights):\n \"\"\"\n Generator which uses the weights to generate a\n weighted random values\n \"\"\"\n sum_weights = sum(weights.values())\n cum_weights = {}\n current_weight = 0\n for key, value in sorted(weights.iteritems()):\n current_weight += value\n cum_weights[key] = current_weight\n while True:\n sel = int(random.uniform(0, 1) * sum_weights)\n for key, value in sorted(cum_weights.iteritems()):\n if sel < value:\n break\n yield key\n\n", "Using numpy\ndef choice(items, weights):\n return items[np.argmin((np.cumsum(weights) / sum(weights)) < np.random.rand())]\n\n", "I needed to do something like this really fast really simple, from searching for ideas i finally built this template. The idea is receive the weighted values in a form of a json from the api, which here is simulated by the dict.\nThen translate it into a list in which each value repeats proportionally to it's weight, and just use random.choice to select a value from the list.\nI tried it running with 10, 100 and 1000 iterations. The distribution seems pretty solid.\ndef weighted_choice(weighted_dict):\n \"\"\"Input example: dict(apples=60, oranges=30, pineapples=10)\"\"\"\n weight_list = []\n for key in weighted_dict.keys():\n weight_list += [key] * weighted_dict[key]\n return random.choice(weight_list)\n\n", "I didn't love the syntax of any of those. I really wanted to just specify what the items were and what the weighting of each was. I realize I could have used random.choices but instead I quickly wrote the class below.\nimport random, string\nfrom numpy import cumsum\n\nclass randomChoiceWithProportions:\n '''\n Accepts a dictionary of choices as keys and weights as values. Example if you want a unfair dice:\n\n\n choiceWeightDic = {\"1\":0.16666666666666666, \"2\": 0.16666666666666666, \"3\": 0.16666666666666666\n , \"4\": 0.16666666666666666, \"5\": .06666666666666666, \"6\": 0.26666666666666666}\n dice = randomChoiceWithProportions(choiceWeightDic)\n\n samples = []\n for i in range(100000):\n samples.append(dice.sample())\n\n # Should be close to .26666\n samples.count(\"6\")/len(samples)\n\n # Should be close to .16666\n samples.count(\"1\")/len(samples)\n '''\n def __init__(self, choiceWeightDic):\n self.choiceWeightDic = choiceWeightDic\n weightSum = sum(self.choiceWeightDic.values())\n assert weightSum == 1, 'Weights sum to ' + str(weightSum) + ', not 1.'\n self.valWeightDict = self._compute_valWeights()\n\n def _compute_valWeights(self):\n valWeights = list(cumsum(list(self.choiceWeightDic.values())))\n valWeightDict = dict(zip(list(self.choiceWeightDic.keys()), valWeights))\n return valWeightDict\n\n def sample(self):\n num = random.uniform(0,1)\n for key, val in self.valWeightDict.items():\n if val >= num:\n return key\n\n", "Provide random.choice() with a pre-weighted list:\nSolution & Test:\nimport random\n\noptions = ['a', 'b', 'c', 'd']\nweights = [1, 2, 5, 2]\n\nweighted_options = [[opt]*wgt for opt, wgt in zip(options, weights)]\nweighted_options = [opt for sublist in weighted_options for opt in sublist]\nprint(weighted_options)\n\n# test\n\ncounts = {c: 0 for c in options}\nfor x in range(10000):\n counts[random.choice(weighted_options)] += 1\n\nfor opt, wgt in zip(options, weights):\n wgt_r = counts[opt] / 10000 * sum(weights)\n print(opt, counts[opt], wgt, wgt_r)\n\nOutput:\n['a', 'b', 'b', 'c', 'c', 'c', 'c', 'c', 'd', 'd']\na 1025 1 1.025\nb 1948 2 1.948\nc 5019 5 5.019\nd 2008 2 2.008\n\n", "In case you don't define in advance how many items you want to pick (so, you don't do something like k=10) and you just have probabilities, you can do the below. Note that your probabilities do not need to add up to 1, they can be independent of each other:\nsoup_items = ['pepper', 'onion', 'tomato', 'celery'] \nitems_probability = [0.2, 0.3, 0.9, 0.1]\n\nselected_items = [item for item,p in zip(soup_items,items_probability) if random.random()<p]\nprint(selected_items)\n>>>['pepper','tomato']\n\n", "let's say you have\nitems = [11, 23, 43, 91] \nprobability = [0.2, 0.3, 0.4, 0.1]\n\nand you have function which generates a random number between [0, 1) (we can use random.random() here).\nso now take the prefix sum of probability\nprefix_probability=[0.2,0.5,0.9,1]\n\nnow we can just take a random number between 0-1 and use binary search to find where that number belongs in prefix_probability. that index will be your answer\nCode will go something like this\nreturn items[bisect.bisect(prefix_probability,random.random())]\n\n" ]

[ 405, 357, 143, 82, 24, 20, 17, 15, 14, 10, 5, 4, 3, 3, 2, 2, 2, 2, 2, 1, 0, 0, 0, 0, 0, 0, 0 ]

[ "Step-1: Generate CDF F in which you're interesting\nStep-2: Generate u.r.v. u\nStep-3: Evaluate z=F^{-1}(u)\nThis modeling is described in course of probability theory or stochastic processes. This is applicable just because you have easy CDF.\n" ]

[ -1 ]

[ "optimization", "python" ]

[ "The version of pySerial that you're using is trying to call a function that's only available in Windows Vista, whereas you're running Windows XP.\nIt might be worth experimenting with using an older version of pySerial.\nThe code in question was added to pySerial on 3 May 2016, so a version just prior to that might be a good start.\n", "Older versions seem unavailable. But, this worked for me (assuming nanpy version 3.1.1):\n\nopen file \\lib\\site-packages\\serial\\serialwin32.py\ndelete methods _cancel_overlapped_io(), cancel_read(), cancel_write() in lines 436-455 nearly at the botton of the file\nchange method _close() als follows:\n\n(Python) \ndef _close(self):\n \"\"\"internal close port helper\"\"\"\n if self._port_handle is not None:\n # Restore original timeout values:\n win32.SetCommTimeouts(self._port_handle, self._orgTimeouts)\n # Close COM-Port:\n if self._overlapped_read is not None:\n win32.CloseHandle(self._overlapped_read.hEvent)\n self._overlapped_read = None\n if self._overlapped_write is not None:\n win32.CloseHandle(self._overlapped_write.hEvent)\n self._overlapped_write = None\n win32.CloseHandle(self._port_handle)\n self._port_handle = None\n\nAdditionally, create a non-default serial connection when starting the communication, otherwise you'll be bound to some linux device:\na = ArduinoApi(SerialManager(\"COM5:\"))\n\nfor i in range(10):\n a.pinMode(13, a.OUTPUT)\n a.digitalWrite(13, a.HIGH)\n # etc.\n\n", "And in serial\\win32.py comments\n#CancelIoEx = _stdcall_libraries['kernel32'].CancelIoEx\n#CancelIoEx.restype = BOOL\n#CancelIoEx.argtypes = [HANDLE, LPOVERLAPPED]\n\n", "There is no obvious reason why CancelIO was replaced with the cross-thread version CancelIOex, which allows code in one thread to cancel IO in another thread. Certainly cpython 2.x is single threaded.\nTo get pySerial to run on python 2.7 on Win2K, I just changed CancelIOex in serial back to CancelIO.\n" ]

[ 3, 3, 1, 0 ]

[]

[]

[ "pyserial", "python" ]

[ "The issue was due to incorrect usage of summary from torchinfo. It does a forward pass (if input size is provided), and the device is (by default) selected on basis of torch.cuda.is_available().\nIf device (as specified in the question) argument is given to summary, the training happens just fine.\n" ]

[ 0 ]

[]

[]

[ "deep_learning", "machine_learning", "python", "pytorch" ]

[ "I can't test it but it should be something like this if I understood it right now\nstore_ids = [637, 123, 865]\nfor store_id in store_ids: \n div_type = stores.select(\"Div\").where(f.col(\"ID\") == store_id ).collect()[0][0]\n final_list.join(stores, stores.ID == final_list.ID)\n .select(\"*\")\n .where((f.col(\"Div\") == div_type) &\\\n (f.col(\"store_id\") != store_id))\n\n", "store_div = store_df.select('Store','Div').distinct().collect()\n\nfc =0\nfor i in store_div: \n\n store_filter = store_df.filter((col('Store')==i[0]) & (col('Div')==i[1]))\n if fc == 0 :\n Updated_final_list = final_list.join(store_filter, [\"ID\",\"DiV\"], \"left_anti\")\n else:\n Updated_final_list = Updated_final_list.join(store_filter, [\"ID\",\"DiV\"], \"left_anti\")\n\n fc +=1\n\n" ]

[ 0, 0 ]

[]

[]

[ "azure_databricks", "pyspark", "python" ]

[ "So, you could be confused hardy when you use mutable objects as a default value of argument in your methods. There is the best explanation .\n" ]

[ 1 ]

[]

[]

[ "asynchronous", "object", "python" ]

[ "Since the error was raised when writing CSV with polars and polars has its own dependencies, when it's in exe form it needs to include --recursive-copy-metadata as per documentation pyinstaller --recursive-copy-metadata polars --onefile -w \"myfile.py\"\n" ]

[ 0 ]

[]

[]

[ "python" ]

[ "tqdm objects expose some information via the public property format_dict.\nfrom tqdm import tqdm\n\nwith tqdm(total=100) as t:\n ...\n t.update()\n print(t.format_interval(t.format_dict['elapsed']))\n\nOtherwise you could parse str(t).split()\n", "You can get elapsed and remaining time from format_dict and some calculations.\nt = tqdm(total=100)\n...\nelapsed = t.format_dict[\"elapsed\"]\nrate = t.format_dict[\"rate\"]\nremaining = (t.total - t.n) / rate if rate and t.total else 0 # Seconds*\n\n", "Here's the answer to the time remaining and time elapsed question:\nfrom tqdm import tqdm\nfrom time import sleep\n \nwith tqdm(total=100, bar_format=\"{l_bar}{bar} [ time left: {remaining}, time spent: {elapsed}]\") as pbar:\n for i in loop:\n pbar.update(1)\n sleep(0.01)\n\nIf needed to be worked with or printed elsewhere:\nelapsed = pbar.format_dict[\"elapsed\"]\nremains = pbar.format_dict[\"remaining\"]\n\n", "Edit: see the library maintainer's answer below. Turns out, it is possible to get this information in the public API.\n\ntqdm does not expose that information as part of its public API, and I don't recommend trying to hack your own into it. Then you would be depending on implementation details of tqdm that might change at any time.\nHowever, that shouldn't stop you from writing your own. It's easy enough to instrument a loop with a timer, and you can then abort the loop if it takes too long. Here's a quick, rough example that still uses tqdm to provide visual feedback:\nimport time\nfrom tqdm import tqdm\n\n\ndef long_running_function(n, timeout=5):\n start_time = time.time()\n\n for _ in tqdm(list(range(n))):\n time.sleep(1) # doing some expensive work...\n elapsed_time = time.time() - start_time\n if elapsed_time > timeout:\n raise TimeoutError(\"long_running_function took too long!\")\n\n\nlong_running_function(100, timeout=10)\n\nIf you run this, the function will stop its own execution after 10 seconds by raising an exception. You could catch this exception at the call site and respond to it in whatever way you deem appropriate.\n\nIf you want to be clever, you could even factor this out in a tqdm-like wrapper like this:\ndef timed_loop(iterator, timeout):\n start_time = time.time()\n iterator = iter(iterator)\n\n while True:\n elapsed_time = time.time() - start_time\n if elapsed_time > timeout:\n raise TimeoutError(\"long_running_function took too long!\")\n\n try:\n yield next(iterator)\n except StopIteration:\n pass\n\n\ndef long_running_function(n, timeout=5):\n for _ in timed_loop(tqdm(list(range(n))), timeout=timeout):\n time.sleep(0.1)\n\n\nlong_running_function(100, timeout=5)\n\n" ]

[ 17, 1, 0, -2 ]

[]

[]

[ "iterable", "printing", "progress_bar", "python", "tqdm" ]

[ "How about something like this [ktau]{4}\\b?\nhttps://regex101.com/r/BVwTcs/1\nThis will match at the end of a word for those character combinations.\nFor example, k, followed by u, followed by a, followed by t.\nThis can also match aaaa so take that into account.\nIt will match any 4 combinations of the characters at the end of the word.\n", "the below is my approach to it. Please try it:\nfrom itertools import permutations\n\nmystr = [[\"Rajakatu\",\"Lapinlahdenktau\",\"Nurmenkaut\",\"Linnakoskenkuat\"]]\n\n#to get the last four letters of whose permutations you need\nx = mystr[0][0]\nexclude= x[-4:]\n\n#get the permutations\nperms = [''.join(p) for p in permutations(exclude)]\nperms\n\n#remove the last for letters of the string if it lies in the perms\nfor i in range(4):\n curr = mystr[0][i]\n last4 = curr[-4:]\n \n if(last4 in perms):\n mystr[0][i]=curr[:-4]\n \nprint(mystr)\n\nOUTPUT: [['Raja', 'Lapinlahden', 'Nurmen', 'Linnakosken']]\n" ]

[ 1, 0 ]

[]

[]

[ "combinations", "filter", "python", "string" ]

[ "The reason is that you're printing the function objects, and not their results:\nfunction1 != function1()\nSo for your case you need:\ntable = {\n 'Checks' : ['Check #1', 'Check #2'],\n 'Summary' : ['Number of records on file', 'Number of records missing an ID'],\n 'Findings' : [function1(), function2()]\n}\ndf = pd.DataFrame(table)\ndf\n\nEdit: Oh damn and I also missed what the other user commented. You definitely need to return a value from your functions as well :)\n", "You need to change your functions so they return values, not output them, that is do\ndef function1():\n with open('data.csv') as file:\n record_number = len(list(file))\n return record_number\n\nand\ndef function2():\n df = pd.read_csv('data.csv', low_memory=False)\n return df[\"IDs\"].isna().sum()\n\nand call these functions like so\ntable = {\n 'Checks' : ['Check #1', 'Check #2'],\n 'Summary' : ['Number of records on file', 'Number of records missing an ID'],\n 'Findings' : [function1(), function2()]\n}\ndf = pd.DataFrame(table)\ndf\n\n", "For expected ouput add return with f-strings to both functions, in DataFrame call functions with parentheses:\ndef function1():\n with open('data.csv') as file:\n record_number = len(list(file))\n return f\"function #1 results (Number of records on file: {record_number})\")\n\n\ndef function2():\n df = pd.read_csv('data.csv', low_memory=False)\n missing_id = df[\"IDs\"].isna().sum()\n return f\"function #2 results (Number of records missing an ID: {missing_id})\")\n\n\ntable = {\n 'Checks' : ['Check #1', 'Check #2'],\n 'Summary' : ['Number of records on file', 'Number of records missing an ID'],\n 'Findings' : [function1(), function2()]\n}\ndf = pd.DataFrame(table)\n\nSolution with one function:\ndef function():\n with open('data.csv') as file:\n record_number = len(list(file))\n missing_id = df[\"IDs\"].isna().sum()\n \n return [f\"function #1 results (Number of records on file: {record_number})\"),\n f\"function #2 results (Number of records missing an ID: {missing_id})\")]\n\n\ntable = {\n 'Checks' : ['Check #1', 'Check #2'],\n 'Summary' : ['Number of records on file', 'Number of records missing an ID'],\n 'Findings' : function()\n}\ndf = pd.DataFrame(table)\n\n" ]

[ 2, 2, 0 ]

[]

[]

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

[ "Thats a good effort.\nHere are some comments to help and also on how to skip one row.\n\nShould generally only ever need to save the workbook once at the end of all your edits, unless you are making multiple copies. So the wb.save after the insert command is not necessary.\nThere shouldn't be need to use 'mr + 1' here. Just the value 'mr' is fine, it matches the rows count.\nNot necessary to assign an intermediate variable for just copying a value from one cell to another. Assign the new cell value to the existing cell value in one line as shown. However it's fine if you want to use the variable 'v' as an intermediate.\nwb.close should be wb.close() however wont do anything on this workbook anyway Only affects read-only and write-only modes which is a method when opening the workbook. So not need to include that line.\n\n\n\nTo skip rows you can set the stepping in the range. Stepping is the last number in the range params. So\nrange(2, mr, 2)\n\nMeans 'i' starts at 2, increases to max value [ws.max_row] in increments of 2.\nIn this case since the max value is 7, i will be 2, 4 and 6\n\n...\nwb = xl.load_workbook(datafile)\nws = wb['Sheet1']\n\n# insert a new column #5\nws.insert_cols(idx=5, amount=1)\n# wb.save(datafile) # <--- not necessary just save at the end\n\nmr = ws.max_row\n\n# move cells\n# Move and delete the rows by making the changes from the bottom up\nfor i in reversed(range(2,mr,2)):\n ws.cell(row=i, column=5).value = ws.cell(row=i + 1, column=4).value\n ws.delete_rows(idx=i + 1, amount=1)\n\nwb.save(datafile)\n# wb.close # <-- Not needed, should have brackets anyway\n\n\n#---- Additional Information ----#\nThe issue with the deletion is; when you delete a row the rows below shift up immediately. Therefore if you delete row 2 then row 3 becomes row 2 which means starting from the top and deleting down in a pattern like this usually wont work.\nTo delete the unncessary rows its easier to run the loop in reverse so deletion of a row doesn't affect the rows you have yet to change.\n" ]

[ 0 ]

[]

[]

[ "excel", "move", "openpyxl", "python" ]

[ "You are working with more than 1 if-statement this means that the programm is gonna check both of them individually also, check the first one if is correct is going to print 'correct' then is gonna check the next if-statement and if this one is false is gonna print \"Incorrect\", try doing this\nif quote == choices[0] and inp == \"kingdom hearts\":\n print(\"correct\")\nelif quote == choices[1] and inp == \"alan wake\":\n print(\"correct\")\nelse:\n print(\"incorrect\")\n\nHere you check all the option and when one of them is correct it stop comparing and print the msg.\n" ]

[ 1 ]

[]

[]

[ "if_statement", "list", "python", "random", "string" ]

[ "I don't know why it worked before, but after reading the seaborn documentation ( documentation ) the parameter height doesn't exist when you use pointplot.\n" ]

[ 0 ]

[]

[]

[ "matplotlib", "python", "seaborn" ]

[ "Thanks all for response after days of struggle at last I've figured out the mistake im making.\nI dont know if I'm right or wrong correct me if I'm wrong but this worked for me:\n object_name_in_gcs_bucket = bucket.blob(\"path-to-upload\"+file.name)\n\nChanging the , to + between the filepath and filename made my issue solve.\nSorry for the small issue.\nHappy that I could solve it.\n", "You have some variables in your code and I guess you know what they represent. Try this out else make sure you add every relevant information to the question and the code snippet.\ndef main():\n file = st.file_uploader(\"Upload file\")\n if file is not None:\n file_details = {\"FileName\":file.name,\"FileType\":file.type}\n st.write(file_details)\n \n file_path = os.path.join(\"tempDir/\", file.name)\n with open(file_path,\"wb\") as f: \n f.write(file.getbuffer()) \n st.success(\"Saved File\")\n\n print(file_path)\n\n\n def upload():\n file_name = file_path\n read_file(file_name)\n st.write(file_name)\n\n st.session_state[\"upload_state\"] = \"Saved successfully!\"\n object_name_in_gcs_bucket = bucket.blob(\"gcp-bucket-destination-path\"+ file.name)\n object_name_in_gcs_bucket.upload_from_filename(file_path)\n \n st.write(\"Youre uploading to bucket\", bucketName)\n st.button(\"Upload file to GoogleCloud\", on_click=upload)\n\n\nif __name__ == \"__main__\":\n main() \n\n", "This one works for me.\nSolution 1\nimport streamlit as st\nfrom google.oauth2 import service_account\nfrom google.cloud import storage\nimport os\n\nSTREAMLIT_SCRIPT_FILE_PATH = os.path.dirname(os.path.abspath(__file__))\n\ncredentials = service_account.Credentials.from_service_account_info(\n st.secrets[\"gcp_service_account\"]\n)\nclient = storage.Client(credentials=credentials)\n\ndef main():\n bucketName = 'survey-appl-dev-public'\n file = st.file_uploader(\"Upload file\")\n if file is not None:\n file_details = {\"FileName\":file.name,\"FileType\":file.type}\n st.write(file_details)\n\n with open(os.path.join(\"tempDir\", file.name), \"wb\") as f:\n f.write(file.getbuffer())\n\n st.success(\"Saved File\")\n\n bucket = client.bucket(bucketName)\n object_name_in_gcs_bucket = bucket.blob(file.name)\n\n # src_relative = f'./tempDir/{file.name}' # also works\n src_absolute = f'{STREAMLIT_SCRIPT_FILE_PATH}/tempDir/{file.name}'\n object_name_in_gcs_bucket.upload_from_filename(src_absolute)\n\nif __name__ == '__main__':\n main()\n\nSolution 2\nInstead of saving the file to disk, use the file bytes directly using upload_from_string().\nReferences:\nGoogle Cloud upload_from_string\nStreamlit file uploader\ncredentials = service_account.Credentials.from_service_account_info(\n st.secrets[\"gcp_service_account\"]\n)\nclient = storage.Client(credentials=credentials)\n\ndef gcs_upload_data():\n bucket_name = 'your_gcs_bucket_name'\n\n file = st.file_uploader(\"Upload file\")\n if file is not None:\n fname = file.name\n ftype = file.type\n\n file_details = {\"FileName\":fname,\"FileType\":ftype}\n st.write(file_details)\n\n # Define gcs bucket.\n bucket = client.bucket(bucket_name)\n bblob = bucket.blob(fname)\n\n # Upload the bytes directly instead of a disk file.\n bblob.upload_from_string(file.getvalue(), ftype)\n\nif __name__ == '__main__':\n gcs_upload_data()\n\n" ]

[ 1, 0, 0 ]

[]

[]

[ "api", "google_cloud_storage", "python", "python_3.x", "streamlit" ]

[ "The basic auth seems fine, it is base64 encoded already. 403 means you are authorized in the application but this specific action is forbidden. In airflow there are different roles admin/dag manager/operator and not all roles are allowed to do DAG operations. Can you specify the user role and operations you try to do? Have in mind that base64 auth string can be easily decoded to plain text and people can see your username and password.\nIn the picture you have shared the verb you are using is POST, opening the link in tbe browser is probably a GET operation which is different in terms of permissions required.\n" ]

[ 2 ]

[]

[]

[ "airflow", "postman", "python" ]

[ "I have reproduced in my environment and the below code worked for me and I followed code of @SwethaKandikonda 's SO-thread\ninit.py:\nimport logging\nfrom azure.storage.blob import BlockBlobService\nimport azure.functions as func\n\n\ndef main(myblob: func.InputStream):\n logging.info(f\"Python blob trigger function processed blob \\n\"\n f\"Name: {myblob.name}\\n\"\n f\"Blob Size: {myblob.length} bytes\")\n \n file=\"\" \n fileContent=\"\" \n blob_service = BlockBlobService(account_name=\"rithwikstor\",account_key=\"EJ7xCyq2+AStqiar7Q==\")\n containername=\"samples-workitems\"\n generator = blob_service.list_blobs(container_name=containername) \n for blob in generator:\n file=blob_service.get_blob_to_text(containername,blob.name)\n logging.info(blob.name)\n logging.info(file.content)\n fileContent+=blob.name+'\\n'+file.content+'\\n\\n'\n\nfunction.json:\n{\n \"scriptFile\": \"__init__.py\",\n \"bindings\": [\n {\n \"name\": \"myblob\",\n \"type\": \"blobTrigger\",\n \"direction\": \"in\",\n \"path\": \"samples-workitems/{name}\",\n \"connection\": \"rithwikstor_STORAGE\"\n }\n ]\n}\n\nlocal.settings.json:\n{\n \"IsEncrypted\": false,\n \"Values\": {\n \"AzureWebJobsStorage\": \"Connection String Of storage account\",\n \"FUNCTIONS_WORKER_RUNTIME\": \"python\",\n \"rithwikstor_STORAGE\": \"Connection String Of storage account\"\n }\n}\n\nHost.json:\n{\n \"version\": \"2.0\",\n \"logging\": {\n \"applicationInsights\": {\n \"samplingSettings\": {\n \"isEnabled\": true,\n \"excludedTypes\": \"Request\"\n }\n }\n },\n \"extensionBundle\": {\n \"id\": \"Microsoft.Azure.Functions.ExtensionBundle\",\n \"version\": \"[3.*, 4.0.0)\"\n },\n \"concurrency\": {\n \"dynamicConcurrencyEnabled\": true,\n \"snapshotPersistenceEnabled\": true\n }\n}\n\nThen i added blobs as below:\n\nOutput:\n\n\nPlease try to file the above process and code, you will get correct output as I have got.\n" ]

[ 0 ]

[]

[]

[ "azure", "azure_blob_storage", "azure_functions", "python" ]

[ "Use a boolean mask for in place modification (boolean indexing):\ncols = ['B', 'C']\nm = (df[cols].gt(7)|df[cols].lt(5)).reindex(columns=df.columns, fill_value=False)\n\ndf[m] = np.nan\n\nIf you need a copy:\ncols = ['B', 'C']\nout = df.mask((df[cols].gt(7)|df[cols].lt(5))\n .reindex(columns=df.columns, fill_value=False))\n\nOutput:\n A B C D\n0 2 NaN 5.0 7\n1 2 NaN NaN 7\n2 5 NaN 6.0 7\n\nIntermediates:\n(df[cols].gt(7)|df[cols].lt(5))\n\n B C\n0 True False\n1 True True\n2 True False\n\n(df[cols].gt(7)|df[cols].lt(5)).reindex(columns=df.columns, fill_value=False)\n\n A B C D\n0 False True False False\n1 False True True False\n2 False True False False\n\n", "You can assign back to filtered columns with DataFrame.mask:\ncols = ['B', 'C']\n\ndf[cols] = df[cols].mask(df[cols].gt(7) | df[cols].lt(5))\nprint (df)\n A B C D\n0 2 NaN 5.0 7\n1 2 NaN NaN 7\n2 5 NaN 6.0 7\n\nOr with numpy.where:\ncols = ['B', 'C']\n\ndf[cols] = np.where(df[cols].gt(7) | df[cols].lt(5), np.nan, df[cols])\nprint (df)\n A B C D\n0 2 NaN 5.0 7\n1 2 NaN NaN 7\n2 5 NaN 6.0 7\n\n" ]

[ 3, 0 ]

[]

[]

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

[ "You have a variable scoping issue. In getTotal, totalPints is being updated with its value local to the function, not the global one like you are expecting. Returning the new value from the function and assigning it seems to have the intended effect. Below is the updated snippet:\n def getTotal(pints, totalPints):\n index = 0\n while index < 7:\n totalPints = totalPints + int(pints[index])\n index = index + 1\n print(totalPints)\n return totalPints\n\n totalPints = getTotal(pints, totalPints)\n\n" ]

[ 1 ]

[]

[]

[ "function", "python" ]

[ "If I add <stu:StudentBreakdown xmlns:stu= \"stu\" xmlns:st=\"st\"> to your XML root element, I get with:\nimport pandas as pd\nimport xml.etree.ElementTree as ET\n\ntree = ET.parse('ns.xml')\nroot= tree.getroot()\n\ncolumns= [\"TAG\", \"VALUE\"]\ndata = []\nfor stud in root.iter():\n if \"\\n\" not in stud.text:\n stud.text = stud.text\n else:\n stud.text = None\n row = (stud.tag , stud.text)\n data.append(row)\n \ndf = pd.DataFrame(data, columns=columns)\nprint(df)\n\nOutput:\n TAG VALUE\n0 {stu}StudentBreakdown None\n1 {stu}Studentdata None\n2 {stu}StudentScreening None\n3 {st}name Sam Davies\n4 {st}age 15\n5 {st}hair Black\n6 {st}eyes Blue\n7 {st}grade 10\n8 {st}teacher Draco Malfoy\n9 {st}dorm Innovation Hall\n10 {st}name Master Splinter\n11 {stu}StudentScreening None\n12 {st}name Cassie Stone\n13 {st}age 14\n14 {st}hair Science\n15 {st}grade 9\n16 {st}teacher Luna Lovegood\n17 {st}name Kelly Clarkson\n18 {stu}StudentScreening None\n19 {st}name Derek Brandon\n20 {st}age 17\n21 {st}eyes green\n22 {st}teacher Ron Weasley\n23 {st}dorm Hogtie Manor\n24 {st}name Miley Cyrus\n\nMaybe there is a better way to manage the nested XML namespace definition.\n" ]

[ 1 ]

[]

[]

[ "elementtree", "python", "xml" ]

[ "You should re-read and update your list after you put input and added line. You should avoid using my_list = open(\"Characters.txt\") as you may forget to close it. Or sometimes it gives an error and stay unclosed which you cannot perform anything over it.\nfrom tkinter import *\nfrom tkinter import messagebox\n\nroot = Tk()\nroot.title(\"test tool\") #App Title\nroot.geometry(\"1600x800\") #App Dimensions\n\nDropDownvar = StringVar(value=\"Select an option\")\nDropDownvar.set(\"Select an option\")\n\n\nDropDownMenu = OptionMenu(root, DropDownvar,\" \")\nDropDownMenu.pack()\n\ninputBox = Entry(root)\ninputBox.pack()\n\ndef fillOptionMenu():\n with open(\"characters.txt\",\"r\") as f:\n my_list = f.readlines()\n\n DropDownMenu[\"menu\"].delete(0,\"end\")\n # DropDownMenu.set_menu(my_list)\n for i in my_list:\n DropDownMenu[\"menu\"].add_command(label=i, command=lambda value=i: DropDownvar.set(i))\n\ndef ButtonFun():\n InputBoxEntry = inputBox.get()\n with open(\"Characters.txt\", \"a\") as text_file:\n text_file.write(InputBoxEntry + \"\\n\")\n root.update()\n\n fillOptionMenu()\n\n\ninputBoxButton = Button(root, text=\"Input\", command=ButtonFun)\ninputBoxButton.pack()\n\nfillOptionMenu()\n\nroot.mainloop()\n\n", "You need to add the input item to the dropdown manually inside ButtonFun().\nAlso using .readlines() will not strip out the trailing newline '\\n' from each line in the file, better use .read().splitlines() instead:\n...\nwith open(\"Characters.txt\") as f:\n my_list = f.read().splitlines()\nDropDownMenu = OptionMenu(root, DropDownvar, *my_list)\nDropDownMenu.pack()\n...\ndef ButtonFun():\n InputBoxEntry = inputBox.get()\n with open(\"Characters.txt\", \"a\") as text_file:\n text_file.write(InputBoxEntry + \"\\n\")\n # add the input item to dropdown\n DropDownMenu[\"menu\"].add_command(label=InputBoxEntry, command=lambda: DropDownvar.set(InputBoxEntry))\n...\n\n" ]

[ 0, 0 ]

[]

[]

[ "python", "tkinter" ]

[ "The mean issue can be resolved by computing a mask:\nmask_norm = tf.reduce_sum(tf.clip_by_value(true_mat, 0., 1.),axis=0)\ntrue_mean = tf.math.divide(tf.reduce_sum(true_mat, axis=1), mask_norm)\n#true_mean : [1.5, 6. , 8. ]\n\nYou can find the count using tf.reduce_sum(tf.where(true_mean < false_mean, 1, 0))\n", "You could also try something like this:\nimport tensorflow as tf\n\n\nA = tf.constant([[1.0, 2.0, 3.0],\n [4.0, 5.0, 6.0],\n [7.0, 8.0, 9.0]])\n\nB = tf.constant([[True, True, False],\n [False, False, True],\n [True, False, True]])\n\nt_rows = tf.where(B)\nf_rows = tf.where(~B)\n_true = tf.gather_nd(A, t_rows)\n_false = tf.gather_nd(A, f_rows)\n\ncount = tf.reduce_sum(tf.cast(tf.math.greater(tf.math.segment_mean(_false, f_rows[:, 0]), tf.math.segment_mean(_true, t_rows[:, 0])), dtype=tf.int32))\ntf.print(count)\n\n1\n\nWorks also with rows that are all True or False:\nB = tf.constant([[True, True, True],\n [False, False, True],\n [True, False, True]])\n# 0\n\nB = tf.constant([[False, False, False],\n [False, False, False],\n [True, False, True]])\n# 2\n\n", "I would say your start is good\ntrue_mat = np.where(B, A, 0)\nfalse_mat = np.where(B, 0, A)\n\nBut we want to divide by the number of Trues or Falses, respectively, so...\ntrue_sum = np.sum(B, axis = 1) #sum of Trues per row\nfalse_sum = N-true_sum # if you don't have N given, do N=A.shape[0]\n\ntrue_mean = np.sum(true_mat, axis = 1)/true_sum #add up rows of true_mat and divide by true_sum\nfalse_mean = np.sum(false_mat, axis = 1)/false_sum\n\nFor your example this gives\n[1.5 6. 8. ]\n[3. 4.5 8. ]\n\nSo now we just have to compare where the second is larger than the first:\ncount = np.sum(np.where(false_mean > true_mean, 1, 0))\n\n" ]

[ 1, 1, 1 ]

[]

[]

[ "arrays", "numpy", "python", "pytorch", "tensorflow" ]

[ "dict/zip the two series:\nimport pandas as pd\n\ndata = pd.DataFrame({\n 'Column_Name': ['FirstName', 'LastName', 'Department', 'EmployeeID'],\n 'Datatype': ['string', 'string', 'integer', 'string'],\n})\n\nmapping = dict(zip(data['Column_Name'], data['Datatype']))\n\nprint(mapping)\n\nprints out\n{'FirstName': 'string', 'LastName': 'string', 'Department': 'integer', 'EmployeeID': 'string'}\n\n", "use to record which is much more handy.\nprint(dict(df.to_records(index=False)))\n\nShould Gives #\n{'FirstName': 'string', 'LastName': 'string', 'Department': 'integer', 'EmployeeID': 'string'}\n\nEdit :\nIf you want keys alone then\nd = dict(df.to_records(index=False))\n\nprint(list(d.keys()))\n\nshould Gives #\n['FirstName', 'LastName', 'Department', 'EmployeeID']\n\n", "You can do an easy dict comprehension with your data:\nInput data:\ndata = pd.DataFrame({'Column_Name' : ['FirstName', 'LastName', 'Department'], 'Datatype' : ['Jane', 'Doe', 666]})\nDict comprehension:\n{n[0]:n[1] for n in data.to_numpy()}\nThis will give you:\n{'FirstName': 'Jane', 'LastName': 'Doe', 'Department': '666'}\nThere are for sure other ways, e.g. using the pandas to_dict function, but I am not very familiar with this.\nEdit:\nBut keep in mind, a dictionary needs unique values.\nYour categories (first, lastname) looks like general categories. This here will only work for a single person, otherwise you have multiple keys.\n" ]

[ 2, 1, 0 ]

[]

[]

[ "dataframe", "dtype", "json", "list", "python" ]

[ "You'll need to merge your dataframes, adding a hue column. Here is an example starting from some test data. Note that when using multiple distributions, in order to make the plot more readable, seaborn automatically changes the marginal plots from histograms to kdeplots.\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nimport pandas as pd\nimport numpy as np\n\nnp.random.seed(20221129)\ndfb = pd.DataFrame({'col4': np.random.randn(1000).cumsum(),\n 'col6': np.random.randn(1000).cumsum()})\ndfr = pd.DataFrame({'col4': np.random.randn(100).cumsum(),\n 'col6': np.random.randn(100).cumsum()})\ndf_merged = pd.DataFrame({'col4': pd.concat([dfb['col4'], dfr['col4']]),\n 'col6': pd.concat([dfb['col6'], dfr['col6']]),\n 'origin': ['dfb'] * len(dfb) + ['dfr'] * len(dfr)}).reset_index()\n\nsns.jointplot(x='col4', y='col6', hue='origin', data=df_merged, palette=[\"blue\", \"red\"])\n\n\n" ]

[ 1 ]

[]

[]

[ "matplotlib", "pandas", "python", "seaborn" ]

[ "You can do this by using the function with_column in combination with the lit function. The with_column function needs a Column expression and for a literal value this can be made with the lit function. see documentation here: https://docs.snowflake.com/en/developer-guide/snowpark/reference/python/api/snowflake.snowpark.functions.lit.html\nfrom snowflake.snowpark.functions import lit \nsnowpark_df = snowpark_df.with_column('NEW_COL', lit('your_string'))\n\n" ]

[ 0 ]

[]

[]

[ "dataframe", "python", "snowpark" ]

[ "You want to build a graph.\nYou can combine pandas and networkx for this:\nimport pandas as pd\nimport networkx as nx\n\nG = nx.from_pandas_edgelist(pd.read_excel('CHILD--PARENT.xlsx'),\n source='Parent', target='Child',\n create_using=nx.DiGraph)\n\nThen fetch the descendants using nx.descendants:\nnx.descendants(G, '064AQ')\n\nOutput:\n{'070AQ', '471AQ', '040AQ'}\n\nRelevant part of the graph:\n\nA bit larger context of the graph:\n\n" ]

[ 1 ]

[]

[]

[ "algorithm", "data_structures", "dataframe", "excel_formula", "python" ]

[ "The FileUpload widget from Ipywidgets is a widget that allows users to upload files from their local file system to the JupyterLab web application. It works by sending an HTTP request to the JupyterLab server, which then reads the file and sends it back to the widget.\nIn order to make the FileUpload widget work with JupyterLab inside a Docker container, you need to make sure that the container has access to the host's file system. This can be done by using Docker Bind Mounts.\nTo do this, you need to add the following line to your Dockerfile:\nVOLUME [\"/host/path/to/files:/container/path/to/files\"]\n\nThis will mount the host's file system to the container's file system, allowing the FileUpload widget to access the files on the host.\nOnce this is done, you should be able to use the FileUpload widget as expected.\n" ]

[ 1 ]

[]

[]

[ "docker", "ipywidgets", "jupyter_lab", "python" ]

[ "Firstly, you don't really \"find random row and column indices\". What you are doing is generating an array of size k with random elements of cat[:,0,0], not with their indices.\nGenerating a random arry of indices would be done as follow:\nidx_r=random.choices(np.arange(cat[:,0,0].shape[0]), k=int((cat.shape[0]*0.25)))\nidx_c=random.choices(np.arange(cat[0,:,0].shape[0]), k=int((cat.shape[0]*0.25)))\n\nSecondly, you should not need torch.add here, cat[i, j, :] = cat[i, j, :] + cost should have the same effect and might allow you to not import pytorch.\nI will leave the rest of the answer here in case it is useful for anyone, but it doesn't seem of any use for the original question in this state.\nHere, I used the answer to How to set numpy matrix elements to a value with given indexes to do a simple matrix addition.\nidx_r=random.choices(np.arange(cat[:,0,0].shape[0]), k=int((cat.shape[0]*0.25)))\nidx_c=random.choices(np.arange(cat[0,:,0].shape[0]), k=int((cat.shape[0]*0.25)))\nzeros = np.zeros(cat.shape)\nzeros[idx_r[:], idx_c[:], :] = cost\ncat = np.add(cat, zeros)\n\nAfter verification, it seems this method is way slower than the original you proposed. So much slower in fact that I would assume it is an error rather than a coherent result:\nfrom timeit import timeit\nsetup: str = '''\nimport numpy as np\nimport random\ncat = np.random(500, 500, 500)\nidx_r = random.choices(np.arange(cat[:,0,0].shape[0]), k=int((cat.shape[0]*0.25)))\nidx_c = random.choices(np.arange(cat[0,:,0].shape[0]), k=int((cat.shape[0]*0.25)))\ncost = 42\n'''\noriginal: str = '''\nfor i in idx_r:\n for j in idx_c:\n cat[i, j, :] = cat[i, j, :] + cost\n'''\nmine: str = '''\nzeros = np.zeros(cat.shape)\nzeros[idx_r[:], idx_c[:], :] = cost\ncat = np.add(cat, zeros)\n'''\ntimeit(original, setup=setup, number=100) # 4.27609...\ntimeit(mine, setup=setup, number=100) # 30.05506...\n\n" ]

[ 0 ]

[]

[]

[ "arrays", "python", "pytorch" ]

[ "I corrected your code:\nYou had several errors in your code, like using the bitwise and, not correctly calling the function and some conditionals that I did not understnd what they did.\nWhat I undeartand you want to do is have a list of allowed password, and grant access if the input password matches one of those.\ndef PasswordChecker(password):\n allowed_passwords = [\"secret\", \"choccie\"]\n error_message = \"Wrong password input\"\n\n if password in allowed_passwords:\n print(\"Welcome!\")\n return True\n else:\n print(error_message)\n return False\n \n\ninput_password = input(\"Write the password: \")\naccess_granted = PasswordChecker(input_password)\n\nHardcoding the allowed passwords like this is a bad practice, since anybody with access to the source code will then have access to those passwords, so use this only as a way of learning python and not as a real password checker.\n", "Try bracketing your condition in a pair. Other than that, you can share more details on the error you are facing.\n if (len(InputPassword) != len(password) or InputPassword[0] != password[0]) or (InputPassword[-1] != password[-1] or InputPassword.isupper() == True):\n\n" ]

[ 0, 0 ]

[]

[]

[ "password_checker", "passwords", "python" ]

[ "So, after a few hours of research I was able to find my own solution. The method used to read multiple files, was taken from this answer. By breaking the [object FileList] into separate files and appending them to the FormData. The models are based on this answer\nOn the backend, overriding the create method of the serializer and loop through resquest.POST.data excluding unwanted keys to access the just the files. And saving them into the Images model (should be named PostImage).\nNote that I do no access the validated_data for the files, instead they are retrieved directly from the request.\nI used bootstrap5 in the frontend.\nEDIT: Tested only two types of request GET(list) and POST(create) (as you see in vue component)\nmodels.py:\nclass Post(models.Model):\n title = models.CharField(max_length=128)\n body = models.CharField(max_length=400)\n \ndef get_image_filename(instance, filename):\n title = instance.post.title\n slug = slugify(title)\n return \"post_images/%s-%s\" % (slug, filename) \n\n\nclass Images(models.Model):\n post = models.ForeignKey(Post, default=None, on_delete=models.CASCADE)\n image = models.ImageField(upload_to=get_image_filename,\n verbose_name='Image')\n\nserializers.py:\nfrom core.models import Images, Post\nfrom rest_framework import serializers\n\nclass PostSerializer(serializers.ModelSerializer):\n images = serializers.SerializerMethodField()\n\n class Meta:\n model = Post\n fields = '__all__'\n\n def create(self, validated_data):\n new_post = Post.objects.create(**validated_data)\n data = self.context['request'].data\n for key, image in data.items():\n if key != 'title' and key != 'body':\n image = Images.objects.create(post=new_post, image=image)\n\n return new_post\n \n def get_images(self, obj):\n images = []\n qs = Images.objects.filter(post=obj)\n for item in qs:\n images.append(item.image.name)\n return images\n\nviews.py:\nfrom rest_framework import viewsets\n \nfrom core.models import Post\nfrom core.serializers import PostSerializer\n\n\nclass PostViewSet(viewsets.ModelViewSet):\n queryset = Post.objects.all()\n serializer_class = PostSerializer\n\nTestComponent.vue:\n<template>\n <div class=\"container\" style=\"display: flex; justify-content: center; align-items: center;\">\n <form @submit.prevent=\"submit\" >\n <div class=\"mb-3\">\n <label for=\"exampleInputTitle\" class=\"form-label\">Title</label>\n <input type=\"text\" class=\"form-control\" id=\"exampleInputTitle\" v-model=\"title\"> \n </div>\n\n <div class=\"mb-3\">\n <label for=\"exampleInputBody\" class=\"form-label\">Body</label>\n <input type=\"text\" class=\"form-control\" id=\"exampleInputBody\" v-model=\"body\"> \n </div>\n\n <div class=\"mb-3\">\n <label for=\"formFileMultiple\" class=\"form-label\">Multiple files input example</label>\n <input class=\"form-control\" type=\"file\" id=\"formFileMultiple\" ref=\"file\" multiple>\n </div>\n\n <div>\n <button type=\"submit\" class=\"btn btn-primary\">Submit</button>\n </div>\n </form>\n </div>\n</template>\n\n<script>\n\nimport axios from 'axios'\n\nexport default {\n data () {\n this.title = '',\n this.body = ''\n },\n methods: {\n submit() {\n const formData = new FormData();\n for( var i = 0; i < this.$refs.file.files.length; i++ ){\n let file = this.$refs.file.files[i];\n formData.append('files[' + i + ']', file);\n }\n formData.append(\"title\", this.title);\n formData.append(\"body\", this.body);\n\n axios.post('http://localhost:8000/posts/', formData, {\n headers: {\n 'Content-Type': 'multipart/form-data'\n }\n })\n .then((response) => {\n console.log(response.data);\n })\n .catch((error) => {\n console.log(error.response);\n });\n }\n },\n mounted() {\n axios.get('http://localhost:8000/posts/')\n .then((response) => {\n console.log(response.data);\n })\n .catch((error) => {\n console.log(error.response);\n });\n }\n}\n</script>\n\n", "Hope this helps someone.\nFinally after three days battling with this I found the solution to my issue. In the models I have this function that generates a string I can use as the upload_to string for the PostImage:\ndef post_directory_path(instance, filename):\n return 'user_{0}/posts/post_{1}/{2}'.format(instance.user.id, instance.post.id, filename)\n\nThere is no user instance on the PostImage only on the Post and Django does not not throw an exception or show any errors for this mistake, which is why I did not look for the problem there.\n" ]

[ 0, 0 ]

[]

[]

[ "axios", "django", "django_rest_framework", "python", "vue.js" ]

[ "There are two cases when using in or not in operators, the value (right) can be a list or a boolean (The boolean case is an abuse and handled for backward compatibility)\nYou can use self.env.ref to get the list of users that belongs to a group using the group's external identifier\nExample:\ndefault=lambda self: self.env.ref('point_of_sale.group_pos_manager').users\n\nEdit:\nYou can use a function to compute the domain\nExample\ndef _get_domain(self):\n return [('id', 'in', self.env.ref('point_of_sale.group_pos_manager').users.ids)]\n\nmanagers = fields.Many2many('res.users', string=\"Managers in group\", domain=_get_domain)\n\n" ]

[ 1 ]

[]

[]

[ "odoo", "odoo_15", "python" ]

[ "I would use a list comprehension.\n[{'Customer': d['Customer'], \n 'Store': d['Store'], \n 'Basket': d['Basket'], \n **d2} \n for d in transactions \n for d2 in d['items']]\n# [{'Customer': 'Leia', 'Store': 'Hammersmith', 'Basket': 'basket1', \n# 'Product': 'Cheddar', 'Quantity': 2, 'GrossSpend': 2.5}, \n# {'Customer': 'Leia', 'Store': 'Hammersmith', 'Basket': 'basket1', \n# 'Product': 'Grapes', 'Quantity': 1, 'GrossSpend': 3.0},\n# {'Customer': 'Luke', 'Store': 'Ealing', 'Basket': 'basket2', \n# 'Product': 'Custard Creams', 'Quantity': 1, 'GrossSpend': 3.0}]\n\nIf the 'items' key is not present or empty, use dict.get with a default value of [].\n[{'Customer': d['Customer'], \n 'Store': d['Store'], \n 'Basket': d['Basket'], \n **d2} \n for d in transactions \n for d2 in d.get('items', [])]\n\nOr more flexibly yet, generate a dictionary containing all of the keys in both the top level dictionary and the nested dictionary, then remove the extraneous 'items' key with a dictionary comprehension.\n[{k: v \n for k, v in d3.items() \n if k != 'items'} \n for d in transactions \n for d2 in d.get('items', []) \n for d3 in ({**d, **d2},)]\n\n", "Your code looks good to me, I've modified a bit, if you think we can optimize the lines. Handled the case if items is not there in input.\nflattened_transactions = []\nfor transaction in transactions:\n items = transaction.pop(\"items\", [])\n for item in items:\n for key, value in item.items():\n transaction[key] = value\n flattened_transactions.append(transaction)\n else:\n flattened_transactions.append(transaction)\npprint(flattened_transactions)\n\n" ]

[ 2, 1 ]

[ "If you just want to flatten the list it can be done with this simple code:\nouput = []\n\nfor transaction in transactions:\n output = [*output, *transaction]\n\n\nThe * operator in python returns the values of an iterator as in iterator with in braces/brackets. It is equivalent to the ...(spread) operator in javascript. More details in the documentaion.\n" ]

[ -2 ]

[ "python" ]

[ "More efficient than apply, use a loop and update the dictionaries in place:\nfor d1, d2 in zip(df['attributes'], df['prod.attributes']):\n d1['prod'] = d2\n\nIf you want to remove the original column use pop:\nfor d1, d2 in zip(df['attributes'], df.pop('prod.attributes')):\n d1['prod'] = d2\n\nUpdated dataframe:\n id attributes\n0 1 {'dd': True, 'budget': '35k', 'prod': {'img': 'img1.url', 'name': 'millennials'}}\n1 2 {'dd': True, 'budget': '25k', 'prod': {'img': 'img2.url', 'name': 'single'}}\n2 3 {'dd': True, 'budget': '40k', 'prod': {'img': 'img3.url', 'name': 'married'}}\n\ntimings\ndf = pd.concat([df]*10000, ignore_index=True)\n\n%%timeit\nfor d1, d2 in zip(df['attributes'], df['prod.attributes']):\n d1['prod'] = d2\n3.49 ms ± 137 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n\n%%timeit\ndf['attributes'] = [{**a, **{'prod' : b}} \n for a, b in zip(df['attributes'], df['prod.attributes'])]\n11.3 ms ± 384 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n\n%%timeit\ndf.apply(lambda r: {**r['attributes'], **{'prod': r['prod.attributes']}}, axis=1)\n173 ms ± 7.03 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n\n", "Use ** for merge both dictionaries in list comprehension, DataFrame.pop is used for remove column after using:\ndf['attributes'] = [{**a, **{'prod' : b}} \n for a, b in zip(df['attributes'], df.pop('prod.attributes'))]\nprint (df)\n id attributes\n0 1 {'dd': True, 'budget': '35k', 'prod': {'img': ...\n1 2 {'dd': True, 'budget': '25k', 'prod': {'img': ...\n2 3 {'dd': True, 'budget': '40k', 'prod': {'img': ...\n\n" ]

[ 2, 1 ]

[]

[]

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

[ "You have to provide a passphrase, when loading an encrypted key using the RSAKey.from_private_key_file.\nThough note that you do not have to load the key at all, when using the Pageant. That's the point of using an authentication agent. But only the SSHClient class supports the Pageant. The Transport class does not, on its own.\nYou can follow the code in How to use Pageant with Paramiko on Windows?\nThough as the allow_agent is True by default, there is actually nothing special about the code.\nOnce connected and authenticated, use the SSHClient.open_sftp method to get your instance of the SFTPClient. \nssh = paramiko.SSHClient()\nssh.connect(host, username='user', allow_agent=True)\nsftp = ssh.open_sftp()\n\nYou will also need to verify the host key:\nParamiko \"Unknown Server\"\n", "This worked for me\n\nprivatekeyfile = 'path to key'\nmykey = paramiko.RSAKey.from_private_key_file(privatekeyfile)\nssh_client = paramiko.SSHClient()\nssh_client.load_system_host_keys()\nssh_client.connect(hostname='host', username='user', allow_agent=True, pkey=mykey)\n\nftp_client = ssh_client.open_sftp()\n\nprint(ftp_client.listdir('/'))\n\n" ]

[ 9, 0 ]

[]

[]

[ "pageant", "paramiko", "private_key", "python", "ssh" ]

[ "You did not make it entirely clear what result exactly you are after (or what your problem with the morpholocial op's was, exactly), but i had a shot at it.\n\nConnecting all the \"lines\" into a single object with a morpholical operation. I used a circular kernel here, which i think gives decent results. No rotation necessary at this point.\n\nInterpolating a line for each object, using coutours. This selects only the largest contours, apply further tresholding as you see fit.\n\n\nGives this:\n\nimport cv2\n\n# get image\nimg = cv2.imread(\"<YourPathHere>\", cv2.IMREAD_GRAYSCALE)\n\n# threshold to binary\nret, imgbin = cv2.threshold(img,5,255,cv2.THRESH_BINARY)\n\n# morph \ndilateKernelSize = 80; erodeKernelSize = 65;\nimgbin = cv2.dilate(imgbin, cv2.getStructuringElement(cv2.MORPH_ELLIPSE, [dilateKernelSize,dilateKernelSize]))\nimgbin = cv2.erode(imgbin, cv2.getStructuringElement(cv2.MORPH_ELLIPSE, [erodeKernelSize,erodeKernelSize]))\n\n# extract contours\ncontours, _ = cv2.findContours(imgbin,cv2.RETR_LIST,cv2.CHAIN_APPROX_SIMPLE)\nprint(\"Found \",len(contours),\"contours\")\n\n# fit lines for large contours\nlines = []; threshArea = 11000;\nfor cnt in contours:\n if(cv2.contourArea(cnt)>threshArea):\n lines += [cv2.fitLine(cnt, cv2.DIST_L2,0,0.01,0.01)] # [vx,vy,x,y]\n\n\n# show results\nimgresult = cv2.cvtColor(imgbin,cv2.COLOR_GRAY2RGB)\ncv2.drawContours(imgresult, contours, -1, (255,125,0), 3)\n\nVX_ = 0; VY_ = 1; X_ = 2; Y_ = 3;\nrows,cols = imgbin.shape[:2]\np1 = [0,0]; p2 = [cols-1,0];\nfor l in lines:\n p1[1] = int((( 0-l[X_])*l[VY_]/l[VX_]) + l[Y_])\n p2[1] = int(((cols-l[X_])*l[VY_]/l[VX_]) + l[Y_])\n cv2.line(imgresult,p1,p2,(0,255,255),2)\n\n# save image \nprint(cv2.imwrite(\"<YourPathHere>\", imgresult))\n\n# HighGUI\ncv2.namedWindow(\"img\", cv2.WINDOW_NORMAL)\ncv2.imshow(\"img\", img)\ncv2.namedWindow(\"imgresult\", cv2.WINDOW_NORMAL)\ncv2.imshow(\"imgresult\", imgresult)\ncv2.waitKey(0)\ncv2.destroyAllWindows()\n\n\n" ]

[ 0 ]

[]

[]

[ "image_processing", "opencv", "python" ]

[ "\nI tried to reproduce the issue and it worked for me.\n\naciconfig = AciWebservice.deploy_configuration(\ncpu_cores=1,\nmemory_gb=1,\ntags={\"data\":\"nlp classifier\"},\ndescription='nlp cLASSIFICATION MODEL'\n)\ninference_config = InferenceConfig(entry_script=\"scoringscript.py\", environment=myenv)\nservice = Model.deploy(workspace=ws,\nname='nlpse',\nmodels=[model],\ninference_config=inference_config,\ndeployment_config=aciconfig,\noverwrite = True)\nservice.wait_for_deployment(show_output=True)\nurl = service.scoring_uri\nprint(url)\n\n\nFrom the above code block,service.wait_for_deployment(show_output=True) is being called initially when the code block starts executing. It is taking the pipeline to wait for the long duration and hence it is detaching the connection after the TTL.\n\nservice.wait_for_deployment(show_output=True) -> After getting the config and service details, then we need to execute the service wait method. It will solve the connection error.\n\n\n" ]

[ 0 ]

[]

[]

[ "azure_machine_learning_studio", "azure_machine_learning_workbench", "python" ]

[ "Some string splitting can do this for you.\nimport shutil\nimport os\n\n\nfiles = [\n \"cfrad.20220322_170444.122_COW1_v2_s02_el3.40_SUR.nc\",\n \"cfrad.20220322_170456.550_COW1_v2_s03_el4.22_SUR.nc\",\n \"cfrad.20220322_170508.975_COW1_v2_s04_el5.09_SUR.nc\",\n \"cfrad.20220322_170521.397_COW1_v2_s05_el5.99_SUR.nc\",\n \"cfrad.20220322_170533.811_COW1_v2_s06_el0.45_SUR.nc\",\n \"cfrad.20220322_170546.228_COW1_v2_s07_el1.20_SUR.nc\",\n \"cfrad.20220322_170558.648_COW1_v2_s08_el1.90_SUR.nc\",\n \"cfrad.20220322_170611.072_COW1_v2_s09_el2.61_SUR.nc\",\n \"cfrad.20220322_170623.503_COW1_v2_s10_el3.40_SUR.nc\",\n \"cfrad.20220322_170635.923_COW1_v2_s11_el4.21_SUR.nc\",\n \"cfrad.20220322_170648.341_COW1_v2_s12_el5.09_SUR.nc\",\n \"cfrad.20220322_170700.765_COW1_v2_s13_el5.99_SUR.nc\",\n \"cfrad.20220322_170713.179_COW1_v2_s14_el0.45_SUR.nc\",\n \"cfrad.20220322_170725.604_COW1_v2_s15_el1.20_SUR.nc\",\n \"cfrad.20220322_170738.030_COW1_v2_s16_el1.90_SUR.nc\",\n \"cfrad.20220322_170750.461_COW1_v2_s17_el2.61_SUR.nc\",\n \"cfrad.20220322_170802.877_COW1_v2_s18_el3.40_SUR.nc\",\n \"cfrad.20220322_170815.301_COW1_v2_s19_el4.22_SUR.nc\",\n \"cfrad.20220322_170827.715_COW1_v2_s20_el8.01_SUR.nc\",\n \"cfrad.20220322_170840.144_COW1_v2_s21_el11.02_SUR.nc\",\n]\n\n\nfor f in files:\n with open(f, \"w\") as of:\n of.write(\"\\n\")\n\n# force the if statement below to be True on first run\nel = 99999999\nbasepath = \".\"\n\n\nfor f in files:\n new_el = int(f.split(\".\")[2].split(\"_\")[-1].replace(\"el\", \"\"))\n if new_el < el:\n # store new dir name\n curr_dir = f.split(\".\")[1]\n print(curr_dir)\n # create directory\n os.makedirs(curr_dir, exist_ok=True)\n # store new el\n el = new_el\n # move file\n shutil.move(f\"{basepath}{os.sep}{f}\", f\"{basepath}{os.sep}{curr_dir}{os.sep}{f}\")\n\n\n" ]

[ 1 ]

[]

[]

[ "python" ]

[ "I found why this problem occurred.\nI wrote the custom layer by\nimport tensorflow.python.keras \n\nwhile using other keras layers and creating the model by\nimport tensorflow.keras\n\nI think these two libraries may not be compatible, so my custom layer was splitted into several operation layers. Thus, weights cannot be obtained and updated.\nI changed all imports to tensorflow.keras, now everything goes well.\n" ]

[ 0 ]

[]

[]

[ "deep_learning", "keras", "keras_layer", "python", "tensorflow" ]

[ "Here's a solution based on the Python port of Niklaus Wirth's n-queen solver from https://en.wikipedia.org/wiki/Eight_queens_puzzle\ndef queens(n, k, i=0, a=[], b=[], c=[]):\n if k == 0:\n yield a + [None] * (n - len(a))\n return\n for j in range(n):\n if j not in a and i+j not in b and i-j not in c:\n yield from queens(n, k-1, i+1, a+[j], b+[i+j], c+[i-j])\n if k < n - i:\n yield from queens(n, k, i+1, a+[None], b, c)\n\nfor i, solution in enumerate(queens(10, 9)):\n print(i, solution)\n\nIt finds all 56832 ways to place 9 queens on a 10x10 board in less than a second (1.5 sec if they are printed out to the console).\nThe program works like Wirth's: a contains the positions of the queens on the rows processed so far, and b and c contain the diagonal numbers of the queens placed so far. The only difference is that there's an extra k parameter, which says how many queens to place, and some extra code to consider solutions with no queen on a row. Other than this simple optimization of how the board is represented, it's just a depth-first search.\nThe format of the output is the solution number (0-based), and then a list of position of the queen on each row, or None if there's no queen on that row.\n", "I had some fun coming up with a brute force solution with this question:\nfrom typing import Dict, List, Callable, Optional\n\n\ndef create_k_by_k_board(k: int) -> Dict[int, bool]:\n # True means the spot is available, False means it has a queen and None means it is checked by a Queen\n if k <= 0:\n raise ValueError(\"k must be higher than 0\")\n return {i: True for i in range(1, k**2+1)}\n\n\ndef check_position(conditions: List[Callable], position: int) -> bool:\n # Checks if any function returns True\n for func in conditions:\n if func(position):\n return True\n return False\n\n\ndef get_all_checked_positions(queen_location: int, board_size: int) -> List[int]:\n from math import sqrt\n row_len = int(sqrt(board_size))\n conditions = [\n # Horizontal check\n lambda x: ((x - 1) // row_len) == ((queen_location - 1) // row_len),\n # Vertical check\n lambda x: (x % row_len) == (queen_location % row_len),\n # Right diagonal check\n lambda x: (x % (row_len + 1)) == (queen_location % (row_len + 1)),\n # Left diagonal check\n lambda x: (x % (row_len - 1)) == (queen_location % (row_len - 1)),\n ]\n return [\n position for position in range(1, board_size + 1)\n if position != queen_location\n and check_position(conditions, position)\n ]\n\n\ndef place_queen_on_board(board: Dict[int, Optional[bool]], position: int) -> Dict[int, Optional[bool]]:\n # We don't want to edit the board in place because we may need to go back to it\n new_board = board.copy()\n if new_board[position] is True:\n # Place a new queen\n new_board[position] = False\n for checked_position in get_all_checked_positions(position, len(board)):\n # Set the location as checked (no risk of erasing queens)\n new_board[checked_position] = None\n return new_board\n else:\n raise ValueError(f\"Tried to add queen to position {position} in board {board}\")\n\n\ndef get_all_queen_configurations(numb_queens: int, row_length: int) -> List[Dict[int, Optional[bool]]]:\n board = create_k_by_k_board(row_length)\n\n def recursive_queen_search(curr_round: int, curr_board: Dict[int, Optional[bool]]) -> List[Dict[int, Optional[bool]]]:\n successful_boards = []\n available_spots = [position for position, is_free in curr_board.items() if is_free is True]\n for spot in available_spots:\n new_board = place_queen_on_board(curr_board, spot)\n if curr_round < numb_queens:\n successful_boards.extend(\n recursive_queen_search(curr_round+1, new_board)\n )\n else:\n successful_boards.append(new_board)\n return successful_boards\n\n success_boards_with_duplicates = recursive_queen_search(1, board)\n success_boards = []\n for success_board in success_boards_with_duplicates:\n if success_board not in success_boards:\n success_boards.append(success_board)\n return success_boards\n\n\ndef visualize_board(board: Dict[int, Optional[bool]]) -> None:\n from math import sqrt\n row_len = int(sqrt(len(board)))\n parse_dict = {\n False: \"Q\",\n }\n for row in range(len(board), 0, -row_len):\n print(\n \"[\" + \"][\".join([parse_dict.get(board[x], \" \") for x in range(row - row_len + 1, row + 1)]) + \"]\"\n )\n\nAs I mentioned this is a brute force solution, you can further improve it by doing 2 things.\n\nUsing this method on only one eighth of the board.\n\nFor example if we use the algorithm for 3 queens on a 4*4 board:\n>>> a = get_all_queen_configurations(3,4)\n>>> visualize_board(a[0])\n[ ][ ][Q][ ]\n[ ][ ][ ][ ]\n[ ][ ][ ][Q]\n[Q][ ][ ][ ]\n>>> visualize_board(a[1])\n[ ][Q][ ][ ]\n[ ][ ][ ][Q]\n[ ][ ][ ][ ]\n[Q][ ][ ][ ]\n>>> visualize_board(a[2])\n[ ][ ][ ][Q]\n[Q][ ][ ][ ]\n[ ][ ][ ][ ]\n[ ][Q][ ][ ]\n>>> visualize_board(a[3])\n[ ][ ][ ][Q]\n[ ][ ][ ][ ]\n[Q][ ][ ][ ]\n[ ][ ][Q][ ]\n\nYou can see that all the solutions are the same solution mirrored through one of the axes of symmetry.\nUsing this simplification would make the code at least 8 times faster, probably more.\n\nUse a smarter algorithm. But this probably involves searching online and going through academic papers, which you've opted not to do.\n\nThe limitations of the brute force algo are quite serious:\n\n5 queens in 6*6 board: ~0.2 sec\n6 queens in 7*7 board: ~4 sec\n7 queens in 8*8 board: ~128 sec\n8 queens in 9*9 board: ~Legend has it it's still running to this day...\n\nSo whatever, here's my code, let me know if you have any questions.\n" ]

[ 2, 0 ]

[]

[]

[ "algorithm", "n_queens", "python" ]

[ "You have to create a __init__.py file in the MyProject/helpers directory. Maybe you already have created it. If not, create an empty file.\nThen in the MyProject/helpers/helper.py, access the module helpers.class_container like this.\nfrom helpers.class_container import MyClass\ndef func():\n # some code using MyClass\n\nYou can also use a relative import like this.\nfrom .class_container import MyClass\n\nIf you want to run the MyProject/helpers/helper.py independently, add test code in helper.py like this.\nfrom helpers.class_container import MyClass\ndef func():\n # some code using MyClass\n\nif __name__ == '__main__':\n func()\n\nAnd run like this in the MyProject directory.(I assume a Linux environment.)\n$ python3 -m helpers.helper\n\nThe point is to differentiate Python modules from Python scripts and treat them differently.\n" ]

[ 0 ]

[]

[]

[ "import", "module", "path", "python", "scope" ]

[ "What you are trying to do is use a dotenv variable directly using os.environ.\nIn order to use variables from .env, you need the dotenv library.\nInstall dotenv library:\npip install dotenv\n\nThen import dotenv like this.\nfrom dotenv import load_dotenv\nload_dotenv() # this will load variables from .env.\n\n", "If you have tried the answers mentioned by @Shadab and you're still getting None while printing the values from env.\n\nMaybe you didn't created the .env file in the correct file directory.\n\nWe meed to create the .env file within project scope, not inside any folders.\n" ]

[ 2, 0 ]

[]

[]

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

[ "Under the hood, the step will install the package at the runtime when executing the component. This requires a package to be hosted in a location that can be accessed by the runtime environment later.\nGiven that, you need to upload the package to a location that can be accessed later, e.g. git repository as Jose mentioned.\n", "\nFor this I need to understand where does KFP look for packages when installing those on top of base_image.\n\nWhat you specified in packages_to_install is passed to pip install command, so it looks for packages from PyPI.\nYou can also install a package from a source control as pip supports it. See examples: https://packaging.python.org/en/latest/tutorials/installing-packages/#installing-from-vcs\n", "I found the answer to this\nWith KFP SDK 1.8.12, Kubeflow allows you to specify custom pip_index_url\nSee Kubeflow feature request\nWith this feature, I can install my custom python module like this\n@component(\n # this component builds an xgboost classifier with xgboost\n pip_index_urls=[CUSTOM_ARTEFACT_REPO, \"https://pypi.python.org/simple\"],\n packages_to_install=[\"my-custom-python-module\",\"google-cloud-bigquery\", \"xgboost\", \"pandas\", \"sklearn\", \"joblib\", \"pyarrow\"],\n base_image=\"python:3.9\",\n output_component_file=\"output_component/create_xgb_model_xgboost.yaml\"\n)\ndef build_xgb_xgboost(project_id: str,\n data_set_id: str,\n training_view: str,\n metrics: Output[Metrics],\n model: Output[Model]\n):\n\n" ]

[ 1, 1, 0 ]

[]

[]

[ "google_cloud_vertex_ai", "kubeflow", "kubeflow_pipelines", "python" ]

[ "pip install paho-mqtt\n\nhttps://pypi.org/project/paho-mqtt/\nI solved my error by using this command\n" ]

[ 0 ]

[]

[]

[ "import", "libraries", "mqtt", "pip", "python" ]

[ "No, display cannot prevent newlines, in part because there are no newlines to prevent. Each displayed object gets its own div to sit in, and these are arranged vertically. You might be able to adjust this by futzing with CSS, but I wouldn't recommend that.\nThe only way you could really get two objects to display side-by-side is to build your own object which encapsulates multiple displayed objects, and display that instead.\nFor instance, your simple string case:\nclass ListOfStrings(object):\n def __init__(self, *strings):\n self.strings = strings\n\n def _repr_html_(self):\n return ''.join( [\n \"<span class='listofstr'>%s</span>\" % s\n for s in self.strings\n ])\n\ndisplay(ListOfStrings(\"hi\", \"hello\", \"hello there\"))\n\nexample notebook\n", "I had exactly reverse problem (\\n not working) and I solved it from py side. You can use for example this\na = 'first line', 'second line' # This converts to tuple\ndisplay(\" \".join(a)) \n\nWith this result\n'first line second line'\n\n" ]

[ 9, 0 ]

[]

[]

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

[ "The default = uuid.uuid4 is a Django ORM default, it's not something the database will do for you like the auto incrementing for ID. So if you add an entry via the phpmyadmin, it will not set the uuid field.\n", "You will be needing to make migration like this in order to populate the fields for existing entries. Visit this to learn how to do that. With creation of new objects the field is auto populated using the python way. Thanks\nMigrations that add unique fields\nYou can visit this question which may help you with your answer:\nAutomatically fill pre-existing database entries with a UUID in Django\n", "Basically, you can't add an entry in the php admin panel and expect that django adds the UUID, because it is sets by Django and not by the database. You can try to implement a function in the model.py file and serialize it as source of a Charfield, however in this case you need django rest framework\n" ]

[ 1, 0, 0 ]

[ "change default = uuid.uuid4 to default = uuid.uuid4()\n" ]

[ -2 ]

[ "django", "python" ]

[ "You are just complicated everything. Create a cell class and keep information of x,y and iftouched in it. This way you can add new capabilities into cells easily.\nCreate a board and make an array inside it. Create cell instances and place into that array.\nYou should do inside this board whatever you do. Define rules, move capabilities etc.\nGUI simply should be an illusion of this imaginary board. When things get complicated you just update your user interface according to your board!\nimport tkinter as tk\nimport random\n\nGRID_SIZE = 8\n\n#this is cell which going to keep information\nclass cell:\n def __init__(self,x,y,IsTouched=False):\n self.x= x\n self.y = y\n self.touched = IsTouched\n\nclass board:\n def __init__(self):\n self.initializeBoard()\n self.knight = [0,0]\n self.placeKnightRandomly()\n \n def moveKnight(self,x,y):\n #if knight can move in the board, return True so that\n #we can show in the GUI.\n if(self.board[x][y].touched):\n return False\n else:\n self.knight = [x,y]\n print(f\"Knight new position:{x},{y}\")\n return True\n \n def initializeBoard(self):\n #This function creates board from zero.\n #if you want to reset board, simple run this function.\n self.board = []\n for row in range(GRID_SIZE):\n line = []\n for column in range(GRID_SIZE):\n line.append(cell(row,column))\n self.board.append(line)\n\n def placeKnightRandomly(self):\n #place knight randomly\n x = random.randint(0,7)\n y = random.randint(0,7)\n self.knight = [x,y]\n self.board[x][y].touched = True\n print(\"knight:\",x,y)\n\n\nclass GUI:\n def __init__(self):\n self.mw = tk.Tk()\n self.mw.geometry(\"800x800\")\n\n self.board = board()\n\n self.buttonFrame = tk.Frame(self.mw)\n self.buttonFrame.place(relx=0,rely=0,relheight=1,relwidth=1)\n\n self.updateButtons()\n self.mw.mainloop()\n\n def updateButtons(self):\n for child in self.buttonFrame.winfo_children():\n child.destroy()\n self.buttonsList = []\n for lines in self.board.board:\n \n buttons = []\n\n for column in lines:\n x = column.x\n y = column.y\n btn = tk.Button(self.buttonFrame,text=f\"{x},{y}\",width=12,height=5)\n if(self.board.board[x][y].touched):\n btn.configure(bg=\"red\")\n\n #lets connect a buttons to functions. Send x and y as parameters.\n btn.configure(command=lambda x = x,y=y:self.touchInto(x,y) )\n btn.grid(row=x,column=y)\n\n buttons.append(btn)\n\n self.buttonsList.append(buttons)\n \n def touchInto(self,x,y):\n #when you clicked button, this function going to run\n if(self.board.moveKnight(x,y)):\n self.board.board[x][y].touched = True\n self.buttonsList[x][y].configure(bg=\"red\")\n else:\n print(\"cannot move!\")\n\n\n\nif __name__ == \"__main__\":\n GUI()\n\n\n" ]

[ 0 ]

[]

[]

[ "python", "tkinter", "tkinter_button" ]

[ "Firstly, your exception handling syntax is wrong. You want the following.\ntry:\n height_input = input(f\"Please enter your height in meters : \")\n height = float(height_input)\nexcept ValueError:\n print(\"Invalid Input. Please Try Again\")\n continue\n\nSecondly, continue is just going to the next loop iteration. You can't tell it where in the loop to begin. What you need are three separate loops to read each piece of information.\nThirdly, at the end of each try block you'll want to break or your loops will continue infinitely.\n", "You can split the code to multiply while codes, also you need to check for height being different to 0 like below:\nwhile True:\n try:\n height_input = input(\"Please enter your height in meters : \")\n height = float(height_input)\n if height != 0:\n break\n\n except Exception:\n print(\"Invalid Input. Please Try Again\")\n\nwhile True:\n try:\n weight_input = input(\"Please enter your weight in kilograms\")\n weight = float(weight_input)\n\n break\n except Exception:\n print(\"Invalid Input. Please Try Again\")\n\nbmi = weight/(height*height)\nprint(f\"Your bmi is: {round(bmi,2)}\")\n\n\n", "I'd extract the input logic into a function in accordance with the DRY principle. That would also make the code more readable:\ndef input_value(msg, type):\n while True:\n try:\n return type(input(msg))\n except ValueError:\n print(\"Invalid Input. Please Try Again\")\n\nweight = input_value(\"Please enter your weight in kilograms: \", float)\nheight = input_value(\"Please enter your height in meters: \", float)\n\n" ]

[ 2, 1, 1 ]

[]

[]

[ "python" ]

[ "flask app return format json. If you return req.content, it will break function. You must parse response request to json before return it.\nfrom flask import jsonify \nreturn jsonify(req.json())\n\nIt's better with safe load response when the request fail\nreq = requests.get()\nif req.status_code !=200:\n return {}\nelse:\n return jsonify(req.json())\n\n" ]

[ 0 ]

[]

[]

[ "flask", "python", "python_requests" ]

[ "Use a list comprehension:\n[item for item in x if item not in y]\n\nIf you want to use the - infix syntax, you can just do:\nclass MyList(list):\n def __init__(self, *args):\n super(MyList, self).__init__(args)\n\n def __sub__(self, other):\n return self.__class__(*[item for item in self if item not in other])\n\nyou can then use it like: \nx = MyList(1, 2, 3, 4)\ny = MyList(2, 5, 2)\nz = x - y \n\nBut if you don't absolutely need list properties (for example, ordering), just use sets as the other answers recommend.\n", "Use set difference\n>>> z = list(set(x) - set(y))\n>>> z\n[0, 8, 2, 4, 6]\n\nOr you might just have x and y be sets so you don't have to do any conversions.\n", "if duplicate and ordering items are problem :\n[i for i in a if not i in b or b.remove(i)]\na = [1,2,3,3,3,3,4]\nb = [1,3]\nresult: [2, 3, 3, 3, 4]\n\n", "That is a \"set subtraction\" operation. Use the set data structure for that.\nIn Python 2.7:\nx = {1,2,3,4,5,6,7,8,9,0}\ny = {1,3,5,7,9}\nprint x - y\n\nOutput:\n>>> print x - y\nset([0, 8, 2, 4, 6])\n\n", "For many use cases, the answer you want is:\nys = set(y)\n[item for item in x if item not in ys]\n\nThis is a hybrid between aaronasterling's answer and quantumSoup's answer.\naaronasterling's version does len(y) item comparisons for each element in x, so it takes quadratic time. quantumSoup's version uses sets, so it does a single constant-time set lookup for each element in x—but, because it converts both x and y into sets, it loses the order of your elements.\nBy converting only y into a set, and iterating x in order, you get the best of both worlds—linear time, and order preservation.*\n\nHowever, this still has a problem from quantumSoup's version: It requires your elements to be hashable. That's pretty much built into the nature of sets.** If you're trying to, e.g., subtract a list of dicts from another list of dicts, but the list to subtract is large, what do you do?\nIf you can decorate your values in some way that they're hashable, that solves the problem. For example, with a flat dictionary whose values are themselves hashable:\nys = {tuple(item.items()) for item in y}\n[item for item in x if tuple(item.items()) not in ys]\n\nIf your types are a bit more complicated (e.g., often you're dealing with JSON-compatible values, which are hashable, or lists or dicts whose values are recursively the same type), you can still use this solution. But some types just can't be converted into anything hashable.\n\nIf your items aren't, and can't be made, hashable, but they are comparable, you can at least get log-linear time (O(N*log M), which is a lot better than the O(N*M) time of the list solution, but not as good as the O(N+M) time of the set solution) by sorting and using bisect:\nys = sorted(y)\ndef bisect_contains(seq, item):\n index = bisect.bisect(seq, item)\n return index < len(seq) and seq[index] == item\n[item for item in x if bisect_contains(ys, item)]\n\n\nIf your items are neither hashable nor comparable, then you're stuck with the quadratic solution.\n\n* Note that you could also do this by using a pair of OrderedSet objects, for which you can find recipes and third-party modules. But I think this is simpler.\n** The reason set lookups are constant time is that all it has to do is hash the value and see if there's an entry for that hash. If it can't hash the value, this won't work.\n", "If the lists allow duplicate elements, you can use Counter from collections:\nfrom collections import Counter\nresult = list((Counter(x)-Counter(y)).elements())\n\nIf you need to preserve the order of elements from x:\nresult = [ v for c in [Counter(y)] for v in x if not c[v] or c.subtract([v]) ]\n\n", "Looking up values in sets are faster than looking them up in lists:\n[item for item in x if item not in set(y)]\n\nI believe this will scale slightly better than:\n[item for item in x if item not in y]\n\nBoth preserve the order of the lists.\n", "The other solutions have one of a few problems:\n\nThey don't preserve order, or\nThey don't remove a precise count of elements, e.g. for x = [1, 2, 2, 2] and y = [2, 2] they convert y to a set, and either remove all matching elements (leaving [1] only) or remove one of each unique element (leaving [1, 2, 2]), when the proper behavior would be to remove 2 twice, leaving [1, 2], or\nThey do O(m * n) work, where an optimal solution can do O(m + n) work\n\nAlain was on the right track with Counter to solve #2 and #3, but that solution will lose ordering. The solution that preserves order (removing the first n copies of each value for n repetitions in the list of values to remove) is:\nfrom collections import Counter\n\nx = [1,2,3,4,3,2,1] \ny = [1,2,2] \nremaining = Counter(y)\n\nout = []\nfor val in x:\n if remaining[val]:\n remaining[val] -= 1\n else:\n out.append(val)\n# out is now [3, 4, 3, 1], having removed the first 1 and both 2s.\n\nTry it online!\nTo make it remove the last copies of each element, just change the for loop to for val in reversed(x): and add out.reverse() immediately after exiting the for loop.\nConstructing the Counter is O(n) in terms of y's length, iterating x is O(n) in terms of x's length, and Counter membership testing and mutation are O(1), while list.append is amortized O(1) (a given append can be O(n), but for many appends, the overall big-O averages O(1) since fewer and fewer of them require a reallocation), so the overall work done is O(m + n).\nYou can also test for to determine if there were any elements in y that were not removed from x by testing:\nremaining = +remaining # Removes all keys with zero counts from Counter\nif remaining:\n # remaining contained elements with non-zero counts\n\n", "I think the easiest way to achieve this is by using set().\n>>> x = [1,2,3,4,5,6,7,8,9,0] \n>>> y = [1,3,5,7,9] \n>>> list(set(x)- set(y))\n[0, 2, 4, 6, 8]\n\n", "You could also try this if the values are unique anyway:\nlist(set(x) - set(y))\n\n", "Try this.\ndef subtract_lists(a, b):\n \"\"\" Subtracts two lists. Throws ValueError if b contains items not in a \"\"\"\n # Terminate if b is empty, otherwise remove b[0] from a and recurse\n return a if len(b) == 0 else [a[:i] + subtract_lists(a[i+1:], b[1:]) \n for i in [a.index(b[0])]][0]\n\n>>> x = [1,2,3,4,5,6,7,8,9,0]\n>>> y = [1,3,5,7,9]\n>>> subtract_lists(x,y)\n[2, 4, 6, 8, 0]\n>>> x = [1,2,3,4,5,6,7,8,9,0,9]\n>>> subtract_lists(x,y)\n[2, 4, 6, 8, 0, 9] #9 is only deleted once\n>>>\n\n", "We can use set methods as well to find the difference between two list\nx = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]\ny = [1, 3, 5, 7, 9]\nlist(set(x).difference(y))\n[0, 2, 4, 6, 8]\n\n", "The answer provided by @aaronasterling looks good, however, it is not compatible with the default interface of list: x = MyList(1, 2, 3, 4) vs x = MyList([1, 2, 3, 4]). Thus, the below code can be used as a more python-list friendly:\nclass MyList(list):\n def __init__(self, *args):\n super(MyList, self).__init__(*args)\n\n def __sub__(self, other):\n return self.__class__([item for item in self if item not in other])\n\nExample: \nx = MyList([1, 2, 3, 4])\ny = MyList([2, 5, 2])\nz = x - y\n\n", "This example subtracts two lists:\n# List of pairs of points\nlist = []\nlist.append([(602, 336), (624, 365)])\nlist.append([(635, 336), (654, 365)])\nlist.append([(642, 342), (648, 358)])\nlist.append([(644, 344), (646, 356)])\nlist.append([(653, 337), (671, 365)])\nlist.append([(728, 13), (739, 32)])\nlist.append([(756, 59), (767, 79)])\n\nitens_to_remove = []\nitens_to_remove.append([(642, 342), (648, 358)])\nitens_to_remove.append([(644, 344), (646, 356)])\n\nprint(\"Initial List Size: \", len(list))\n\nfor a in itens_to_remove:\n for b in list:\n if a == b :\n list.remove(b)\n\nprint(\"Final List Size: \", len(list))\n\n", "from collections import Counter\n\ny = Counter(y)\nx = Counter(x)\n\nprint(list(x-y))\n\n", "list1 = ['a', 'c', 'a', 'b', 'k'] \nlist2 = ['a', 'a', 'a', 'a', 'b', 'c', 'c', 'd', 'e', 'f'] \nfor e in list1: \n try: \n list2.remove(e) \n except ValueError: \n print(f'{e} not in list') \nlist2 \n# ['a', 'a', 'c', 'd', 'e', 'f']\n\nThis will change list2. if you want to protect list2 just copy it and use the copy of list2 in this code.\n", "def listsubtraction(parent,child):\n answer=[]\n for element in parent:\n if element not in child:\n answer.append(element)\n return answer\n\nI think this should work. I am a beginner so pardon me for any mistakes\n" ]

[ 456, 362, 45, 42, 25, 14, 10, 10, 9, 6, 2, 2, 1, 0, 0, 0, 0 ]

[]

[]

[ "list", "python" ]

[ "You don't need the if else block, you can simply do as it is documented here.\n page = request.GET.get('page')\n paginator = Paginator(get_records_by_date, 5)\n users = paginator.get_page(page)\n return users\n\nThe django method already deals with input verification in the page GET, so you don't need to worry with the input you get.\n" ]

[ 0 ]

[]

[]

[ "django", "python" ]

[ "Actually this was a simple problem to solve using numpy library. I had to convert all using numpy.array() funtion. Numpy takes care of all the different types and converts them into numpy array.\nm = numpy.array(row[3])\n\n" ]

[ 0 ]

[]

[]

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

[ "You can extend dictionary by values from another columns, only necessary different keys in both columns for correct working like mentioned mozway in comments:\nsort_order_dict = {\"FAILED\":0, \"YET_TO_START\":1, \"RUNNING\":2, \"COMPLETED\":3,\n \"LATE\":4, \"---\":5, \"NOT_MET\":6, \"MET\":7}\ndf = df.sort_values(by=['Status','SLA'], key=lambda x: x.map(sort_order_dict))\nprint (df)\n JOB-NAME Status SLA\n5 job_5 FAILED LATE\n3 job_2 YET_TO_START LATE\n0 job_1 YET_TO_START ---\n6 job_7 YET_TO_START ---\n4 job_6 RUNNING LATE\n2 job_4 RUNNING MET\n7 job_8 COMPLETED NOT_MET\n1 job_3 COMPLETED MET\n\nOr use ordered Categorical:\ndf['Status'] = pd.Categorical(df['Status'], ordered=True, \n categories=['FAILED', 'YET_TO_START', 'RUNNING', 'COMPLETED'])\n \ndf['SLA'] = pd.Categorical(df['SLA'], ordered=True, \n categories= ['LATE', '---', 'NOT_MET', 'MET'])\ndf = df.sort_values(by=['Status','SLA'])\nprint (df)\n JOB-NAME Status SLA\n5 job_5 FAILED LATE\n3 job_2 YET_TO_START LATE\n0 job_1 YET_TO_START ---\n6 job_7 YET_TO_START ---\n4 job_6 RUNNING LATE\n2 job_4 RUNNING MET\n7 job_8 COMPLETED NOT_MET\n1 job_3 COMPLETED MET\n\n", "Use numpy.lexsort, you can use any number of parameters easily:\nimport numpy as np\n\nsort_order_dict = {\"FAILED\":0, \"YET_TO_START\":1, \"RUNNING\":2, \"COMPLETED\":3}\nsort_order_dict2 = {'LATE': 0, '---': 1, 'NOT_MET': 2, 'MET': 3}\n\norder = np.lexsort([df['SLA'].map(sort_order_dict2),\n df['Status'].map(sort_order_dict),\n ])\n\nout = df.iloc[order]\n\nOutput:\n JOB-NAME Status SLA\n5 job_5 FAILED LATE\n3 job_2 YET_TO_START LATE\n0 job_1 YET_TO_START ---\n6 job_7 YET_TO_START ---\n4 job_6 RUNNING LATE\n2 job_4 RUNNING MET\n7 job_8 COMPLETED NOT_MET\n1 job_3 COMPLETED MET\n\n" ]

[ 1, 1 ]

[]

[]

[ "pandas", "python" ]

[ "Borrowing a solution from here, the following works (added to .bashrc or .bash_aliases):\nexport PYENV_VIRTUALENV_DISABLE_PROMPT=1\nexport BASE_PROMPT=$PS1\nfunction updatePrompt {\n if [[ \"$(pyenv virtualenvs)\" == *\"* $(pyenv version-name) \"* ]]; then\n export PS1='($(pyenv version-name)) '$BASE_PROMPT\n else\n export PS1=$BASE_PROMPT\n fi\n}\nexport PROMPT_COMMAND='updatePrompt'\n\n" ]

[ 1 ]

[]

[]

[ "pyenv", "pyenv_virtualenv", "python", "virtualenv" ]

[ "See Override a method at instance level for many possible solutions. None of them will really work with super though, since you're simply not defining the replacement function in a class. You can define it slightly differently though for it to work:\nclass Foo:\n def bar(self):\n print('bar')\n\nf = Foo()\n\ndef _bar(self):\n type(self).bar(self) # or Foo.bar(self)\n print('baz')\n\nfrom typing import MethodType\n\nf.bar = MethodType(_bar, f)\nf.bar() # outputs bar baz\n\nSince you're replacing the method at the instance level, you don't really need to access the method of the super class, you just want to access the method of the class, which still exists in its original form.\n" ]

[ 2 ]

[]

[]

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

[ "You are using numpy.empty which is an\n\nArray of uninitialized (arbitrary) data of the given shape, dtype, and order. Object arrays will be initialized to None.\n\nSee documentation.\nUse either numpy.zeros or numpy.ones to start with a proper initialized array.\n", "The problem lies in the fact that an empty array is initialized with np.empty. I am not an expert on computers and how they work, but what I do know is that when an empty array is initialized, a block of memory is allocated where the values of the new array are to be saved. This block of memory can contain values previously initialized. Basically there is still some 1's and zeros in the memory that you are now printing.\nWhen you change values in the np.pad, for the first time, the old memory gets overwritten.\nWhat I think you are trying to do is np.zeros().\ncomparison:\n\n>>> import numpy\n>>> a = numpy.empty([2,2])\n>>> a\narray([[8.88913424e-317, 0.00000000e+000],\n [4.01601648e-212, 1.10215522e-317]])\n>>> b = numpy.zeros([2,2])\n>>> b\narray([[0., 0.],\n [0., 0.]])\n>>> \n\n\n" ]

[ 1, 1 ]

[]

[]

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

[ "Add a landing = \"\" after def landings(tricks): to get rid of the error.\nBut the if checks in your function are wrong. You check if tricks, which is a list, is equal to backflip, etc. which are all strings. So thats why none of the ifs are true and landing got no value assigned.\nThat question was also about permutation in python. Maybe it helps.\n" ]

[ 0 ]

[]

[]

[ "error_handling", "function", "permutation", "python" ]

[ "Your code works just fine. If it doesn't do the job. It might have the version and platform related thing.\nMy environment is following:\n\nMacbook M1 chip, Ventura\nPython 3.9.14\nPandas 1.5.2\n\nCode is following:\nimport pandas as pd\n\n# Build DataFrame\nnames = [\"weight_KG\", \"UpperBoundary\", \"LowerBoundary\"]\nweight_KG = [23.2, 55.2, 44.2, 47.8, 38.7, 0]\nUpperBoundary = [30, 40, 50, 50, 30, 20]\nLowerBoundary = [20, 30, 40, 40, 20, 10]\n\ndict = {\n \"weight_KG\": weight_KG,\n \"UpperBoundary\": UpperBoundary,\n \"LowerBoundary\": LowerBoundary,\n}\ndf1 = pd.DataFrame(dict)\n\ndf2 = df1[\n (df1[\"weight_KG\"] <= df1[\"UpperBoundary\"])\n & (df1[\"weight_KG\"] >= df1[\"LowerBoundary\"])\n]\nprint(df2)\nprint(pd.__version__)\n\nOutput is following:\n weight_KG UpperBoundary LowerBoundary\n0 23.2 30 20\n2 44.2 50 40\n3 47.8 50 40\n1.5.2\n\n" ]

[ 1 ]

[]

[]

[ "filtering", "python" ]

[ "Just concat the input along axis=0\nimport numpy as np\nimport tensorflow as tf\nfrom keras import layers as tfl\n\nclass Encoder(tfl.Layer):\n def __init__(self,):\n super().__init__()\n self.embed_layer = tfl.Embedding(4500, 64, mask_zero=True)\n self.attn_layer = tfl.MultiHeadAttention(num_heads=2,\n key_dim=16,\n attention_axes=2)\n\n def call(self, x):\n x = self.embed_layer(x) # Output: (4, 5, 20, 32)\n x = tf.concat(x, axis=0)\n x, attention_scores = self.attn_layer(query=x, key=x, value=x , return_attention_scores=True) # Output: (4, 5, 20, 32)\n return x , attention_scores\n\n\neg_input = tf.constant(np.random.randint(0, 150, (4, 5, 20)))\nenc = Encoder()\nscores , attentions = enc(eg_input)\n\nscores.shape , attentions.shape\n#(TensorShape([4, 5, 20, 64]), TensorShape([4, 5, 2, 20, 20]))\n\n" ]

[ 1 ]

[]

[]

[ "attention_model", "python", "python_3.x", "self_attention", "tensorflow" ]

[ "disclaimer: I am the author of borb, the library used in this answer\nYou can simply add the Image to a Document (use absolute positioning), and then add a Paragraph of text (containing the raffle number) at the position you want to have it.\nfrom borb.pdf import Document\nfrom borb.pdf import Page\nfrom borb.pdf import Image\nfrom borb.pdf import Paragraph\nfrom borb.pdf import PDF\nfrom borb.pdf.canvas.geometry.rectangle import Rectangle\n\nfrom decimal import Decimal\n\n# create empty document\ndoc: Document = Document()\n\n# add empty page\npge: Page = Page()\ndoc.add_page(pge)\n\n# define a Rectangle on which we want to draw content\n# fmt: off\nr: Rectangle = Rectangle(\n Decimal(59), # x: 0 + page_margin\n Decimal(848 - 84 - 100), # y: page_height - page_margin - height_of_textbox\n Decimal(595 - 59 * 2), # width: page_width - 2 * page_margin\n Decimal(100), # height\n)\n# fmt: on\n\n# add Image\nImage(\"path_to_image.png\", \n width=Decimal(100), \n height=Decimal(100)).paint(pge, r)\n\n# add Paragraph\nParagraph(\"00001\").paint(pge, r)\n\n# store\nwith open(\"output.pdf\", \"wb\") as fh:\n PDF.dumps(fh, doc)\n\nborb is an open source, pure Python PDF library that creates, modifies and reads PDF documents. You can download it using:\npip install borb\n\nAlternatively, you can build from source by forking/downloading the GitHub repository.\n" ]

[ 0 ]

[]

[]

[ "image", "pdf", "python" ]

[ "I think the proble comes from the following lines\nbesthp_nn = tuner_nn.get_best_hyperparameters()\\[0\\]\n\nand\nbesthp_gru = tuner_gru.get_best_hyperparameters()\\[0\\]\n\nYou might want to try something like\nbesthp_nn = tuner_nn.get_best_hyperparameters(1)[0]\nbesthp_gru = tuner_gru.get_best_hyperparameters(1)[0]\n\n\n", "Python raises the TypeError: 'float' object is not subscriptable if you use indexing or slicing with the square bracket notation on a float variable that is not indexable.\n" ]

[ 0, 0 ]

[]

[]

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

[ "Use DataFrame.xs for select second levels with avoid remove first level with drop_level=False, then use rename for same MultiIndex, subtract and add to original with concat, last use DataFrame.sort_index:\ndfa = df.xs('a', axis=1, level=1, drop_level=False).rename(columns={'a':'c'})\ndfb = df.xs('b', axis=1, level=1, drop_level=False).rename(columns={'b':'c'})\n\ndf = pd.concat([df, dfa.sub(dfb)], axis=1).sort_index(axis=1)\nprint (df)\n x y z \n a b c a b c a b c\n0 100 200 -100 400 500 -100 111 222 -111\n1 77 28 49 110 211 -101 27 81 -54\n2 11 22 -11 33 11 22 22 33 -11\n3 213 124 89 136 147 -11 54 56 -2\n\nWith loop select columns by tuples, subtract Series and last use DataFrame.sort_index:\nfor c in df.columns.levels[0]:\n df[(c, 'c')] = df[(c, 'a')].sub(df[(c, 'b')])\n\ndf = df.sort_index(axis=1)\nprint (df)\n x y z \n a b c a b c a b c\n0 100 200 -100 400 500 -100 111 222 -111\n1 77 28 49 110 211 -101 27 81 -54\n2 11 22 -11 33 11 22 22 33 -11\n3 213 124 89 136 147 -11 54 56 -2\n\n", "a = df.xs('a', level=1, axis=1)\nb = df.xs('b', level=1, axis=1)\ndf1 = pd.concat([a.sub(b)], keys=['c'], axis=1).swaplevel(0, 1, axis=1)\n\ndf1\n x y z\n c c c\n0 -100 -100 -111\n1 49 -101 -54\n2 -11 22 -11\n3 89 -11 -2\n\nthen at first concat df and df1 , next sort\npd.concat([df, df1], axis=1).sort_index(axis=1)\n\n\nother way\nuse stack and unstack\ndf.stack(level=0).assign(c=lambda x: x['b'] - x['a']).stack().unstack([1, 2])\n\nresult:\n x y z\n a b c a b c a b c\n0 100 200 100 400 500 100 111 222 111\n1 77 28 -49 110 211 101 27 81 54\n2 11 22 11 33 11 -22 22 33 11\n3 213 124 -89 136 147 11 54 56 2\n\n", "Dump down into numpy, build a new dataframe, and concatenate to the original dataframe:\nresult = df.loc(axis=1)[:,'a'].to_numpy() - df.loc(axis=1)[:, 'b'].to_numpy()\nheader = pd.MultiIndex.from_product([['x','y','z'], ['c']])\nresult = pd.DataFrame(result, columns=header)\npd.concat([df, result], axis=1).sort_index(axis=1)\n\n x y z\n a b c a b c a b c\n0 100 200 -100 400 500 -100 111 222 -111\n1 77 28 49 110 211 -101 27 81 -54\n2 11 22 -11 33 11 22 22 33 -11\n3 213 124 89 136 147 -11 54 56 -2\n\nAnother option, using pipe, without dumping into numpy:\nresult = df.swaplevel(axis=1).pipe(lambda df: df['a'] - df['b'])\nresult.columns = pd.MultiIndex.from_product([result.columns, ['c']])\npd.concat([df, result], axis=1).sort_index(axis=1)\n\n x y z\n a b c a b c a b c\n0 100 200 -100 400 500 -100 111 222 -111\n1 77 28 49 110 211 -101 27 81 -54\n2 11 22 -11 33 11 22 22 33 -11\n3 213 124 89 136 147 -11 54 56 -2\n\n" ]

[ 2, 2, 1 ]

[]

[]

[ "dataframe", "multi_index", "pandas", "pivot_table", "python" ]

[ "As pointed out by @python_user, you can iterate through every element in your list using a list comprehension and using replace():\nnew_list = [i.replace('_', '+') for i in my_list]\nReturns your expected output\n['A0+123', 'BD+SEI', 'SW+TH']\n\n" ]

[ 0 ]

[]

[]

[ "list", "python" ]

[ "I've recently encountered the exact same problem while trying to put my routes into a submodule.\nI can't explain why this happens, but from what I can tell, it has something to do with the Flask-SQLAlchemy version - I've initially tried running version 3.0.2.\nWhat solved the problem for me was a downgrade to version 2.5.1\n" ]

[ 0 ]

[]

[]

[ "flask", "flask_sqlalchemy", "python", "sqlalchemy" ]

[ "You need to call the OpenFileMapping() at the client. But currently the Python mmap module calls the CreateFileMapping() to open an existing file mapping object.(You can see that at this.)\nSo you can't do what you want in pure Python. I recommend using other IPC mechanisms provided by multiprocessing module.(The multiprocessing.shared_memory.SharedMemory will not help because it calls the mmap API in the backend.)\nAs a side note, I recommend you to make an issue report on here.\n" ]

[ 1 ]

[]

[]

[ "local_security_policy", "memory_mapped_files", "python", "windows", "windows_server_2019" ]

[ "Never mind, I somehow got it to work. I think the problem had to do with the environmental variables. What I did was change my code from the one above to this:\napp.config['MAIL_DEFAULT_SENDER'] = os.environ.get('MAIL_DEFAULT_SENDER')\napp.config[\"MAIL_PASSWORD\"] = os.environ.get(\"MAIL_PASSWORD\")\napp.config[\"MAIL_PORT\"] = 587\napp.config[\"MAIL_SERVER\"] = \"smtp.gmail.com\"\napp.config[\"MAIL_USE_TLS\"] = True\napp.config[\"MAIL_USERNAME\"] = os.environ.get(\"MAIL_USERNAME\")\nmail = Mail(app)\n\n" ]

[ 0 ]

[]

[]

[ "cs50", "flask", "flask_mail", "html", "python" ]

[ "I do not understand how you write code. You are using too many duplicates. I will not going to explain to you. In line 51 and 54 , I changed command to None. You can replace it.\nHere is code:\nfrom tkinter import *\n\nstart = Tk()\nstart.geometry(\"800x500\")\nstart.configure(bg=\"lightblue\")\nstart.title(\"Bibliotekapp\")\n \ndef menu():\n start.geometry(\"500x500\")\n start.title(\"Bibliotekapp\")\n start.configure(bg=\"red\")\n\ndef Register():\n start.geometry(\"800x800\")\n start.configure(bg=\"yellow\")\n start.title(\"Bibliotekapp Login\")\n \ndef Submit():\n elev = open(\"bruker.txt\", \"r\")\n sjekk = elev.read()\n\n if brukeridinc.get() in sjekk:\n informasjon.set(\"User already exists\")\n\n else:\n elev.close()\n elev = open(\"bruker.txt\", \"a\")\n elev.write(brukeridinc.get() + \"\")\n elev.write(fornavn.get() + \"\")\n elev.write(etternavn.get() + \"\\n\")\n elev.close()\n informasjon.set(\"You are started\")\n\n\n####### GUI ############\nlabel_brukerid = Label(start, text=\"Brukerid:\", bg=\"white\", font=(\"Arial\", 25))\nlabel_brukerid.grid(row=1, column=0, padx=5, pady=5, sticky=E)\n\nlabel_fornavn = Label(start, text=\"Fornavn:\", bg=\"white\", font=(\"Arial\", 25))\nlabel_fornavn.grid(row=2, column=0, padx=5, pady=5, sticky=E)\n\nlabel_etternavn = Label(start, text=\"Etternavn:\", bg=\"white\", font=(\"Arial\", 25))\nlabel_etternavn.grid(row=3, column=0, padx=5, pady=5, sticky=E)\n\nbrukeridinc= StringVar()\nentry_brukerid= Entry(start, width=10, textvariable=brukeridinc, font=(\"Arial\", 25))\nentry_brukerid.grid(row=1, column=1, padx=5, pady=5, sticky=W) \n\nfornavn= StringVar()\nentry_fornavn= Entry(start, width=10, textvariable=fornavn, font=(\"Arial\", 25))\nentry_fornavn.grid(row=2, column=1, padx=5, pady=5, sticky=W) \n\netternavn= StringVar()\nentry_etternavn= Entry(start, width=10, textvariable=etternavn, font=(\"Arial\", 25))\nentry_etternavn.grid(row=3, column=1, padx=5, pady=5, sticky=W) \n\nbutton_start = Button(start, text=\"start\", bg=\"white\", font=(\"Arial\", 25), command=Submit)\nbutton_start.grid(row=5, column=5, padx=5, pady=5, sticky=E)\n\nbutton_login = Button(start, text=\"Login\", bg=\"white\", font=(\"Arial\", 25), command=menu)\nbutton_login.grid(row=6, column=5, padx=5, pady=5, sticky=E)\n\nbutton_lån = Button(start, text=\"Lån\", bg=\"white\", font=(\"Arial\", 25), command=Register)\nbutton_lån.grid(row=7, column=5, padx=5, pady=5, sticky=E)\n \ninformasjon= StringVar()\nentry_informasjon= Entry(start, width=24, textvariable=informasjon, state=\"readonly\", font=(\"Arial\", 25))\nentry_informasjon.grid(row=5, column=1, padx=5, pady=5, sticky=W)\n \nstart.mainloop()\n\nResult:\n\nResult Red:\n\nResult for yellow:\n\n" ]

[ 0 ]

[]

[]

[ "event_handling", "function", "python", "tkinter", "user_interface" ]

[ "You can use:\nUSE_DJANGO_JQUERY = True instead of JQUERY_URL = True in your \nsettings.py\n\nPlease reply to this message if the issue still persist.\n" ]

[ 0 ]

[]

[]

[ "django", "django_forms", "django_smart_selects", "dropdown", "python" ]

[ "Try using SMTP. It is a standard Python packages. And the syntax is pretty easy.\nTutorial link - https://www.youtube.com/watch?v=JRCJ6RtE3xU\n" ]

[ 0 ]

[]

[]

[ "gmail", "hotmail", "html_email", "mimemultipart", "python" ]

[ "If you use your own view to change password, django gives you ability to update the session after changing password so that the user isn't logged off.\nFor that you can use update_session_auth_hash function.\nDjango's user_change_password update the session after password change. But for you own custom views, you can use update_session_auth_hash like this:\nfrom django.contrib.auth import update_session_auth_hash\n\ndef password_change(request):\n if request.method == 'POST':\n form = PasswordChangeForm(user=request.user, data=request.POST)\n if form.is_valid():\n form.save()\n update_session_auth_hash(request, form.user)\n else:\n ...\n\nDjango docs about session invalidation on password change\nInstead of going through all this, you can use django-allauth instead. It is an awesome app and has all sort of authentication functionality to it.\n", "For some reason the accepted answer didn't work for me. So I did the obvious... I logged in the user again as usual. Example of a ChangePasswordForm overriding the save() method.\nclass ChangePasswordForm(models.Form):\n old_password = forms.CharField(widget=forms.PasswordInput())\n password1 = forms.CharField(widget=forms.PasswordInput())\n password2 = forms.CharField(widget=forms.PasswordInput())\n\n def __init__(self, *args, **kwargs):\n self.request = kwargs.pop(\"request\")\n super().__init__(*args, **kwargs)\n\n def clean(self):\n data = self.cleaned_data\n # authenticate user here (using old_password)\n # check if password1 == password2\n return data\n\n def save(self, commit=True):\n user = super().save(commit=False)\n if commit:\n user.save()\n login(self.request, user) # HERE IS THE WHOLE THING \n\n return user\n\n" ]

[ 5, 0 ]

[]

[]

[ "django", "python" ]

[ "Below is an option for igraph within R.\n\nI think you may have to annotate the community info manually (see grp below) and then use it when plotting, e.g.,\ng <- graph_from_data_frame(df, directed = FALSE)\ngrp <- lapply(\n groups(cluster_edge_betweenness(g)),\n function(x) {\n c(\n x,\n names(which(colSums(distances(g, x) == 1) > 1))\n )\n }\n)\nplot(g, mark.groups = grp)\n\nor using max_cliques with minimal size 3 (thank @clp's comment)\ng <- graph_from_data_frame(df, directed = FALSE)\ngrp <- max_cliques(g, min = 3)\nplot(g, mark.groups = grp)\n\n\nData\ndf <- data.frame(\n from = c(\"A\", \"A\", \"A\", \"B\", \"B\", \"C\", \"C\", \"E\", \"E\", \"F\", \"G\", \"G\", \"G\", \"H\", \"H\", \"I\"),\n to = c(\"B\", \"C\", \"D\", \"C\", \"D\", \"D\", \"E\", \"F\", \"G\", \"G\", \"H\", \"I\", \"J\", \"I\", \"J\", \"J\")\n)\n\n" ]

[ 3 ]

[]

[]

[ "igraph", "networkx", "python", "r", "visualization" ]

[ "No regex. single line use just to split on your target word.\nstring = 'Server:xxx-zzzzzzzzz.eeeeeeeeeee.frPIPELININGSIZE'\n\nlast = string.split(\"fr\",1)[1]\n\nfirst =string[:string.index(\":\")]\nprint(f'{first} : {last}')\n\nGives #\nServer:PIPELININGSIZE\n\n", "Not sure if this helps, because your question was quite vaguely formulated. :)\nimport re\n\nstring = 'Server:xxx-zzzzzzzzz.eeeeeeeeeee.frPIPELININGSIZE'\n\nstring_1 = re.search('[a-z.-]+([A-Z]+)', string).group(1)\n\nprint(f'string: Server:{string_1}')\n\nOutput:\nstring: Server:PIPELININGSIZE\n\n", "The wording of the question suggests that you wish to find the hostname in the string, but the expected output suggests that you want to remove it. The following regular expression will create a tuple and allow you to do either.\nimport re\n\nstr = \"Server:xxx-zzzzzzzzz.eeeeeeeeeee.frPIPELININGSIZE\"\n\np = re.compile('^([A-Za-z]+[:])(.*?)([A-Z]+)$')\nm = re.search(p, str)\nresult = m.groups()\n# ('Server:', 'xxx-zzzzzzzzz.eeeeeeeeeee.fr', 'PIPELININGSIZE')\n\nRemove the hostname:\nprint(f'{result[0]} {result[2]}')\n# Output: 'Server: PIPELININGSIZE'\n\nExtract the hostname:\nprint(result[1])\n# Output: 'xxx-zzzzzzzzz.eeeeeeeeeee.fr'\n\n" ]

[ 0, 0, 0 ]

[]

[]

[ "python", "replace", "string", "url" ]

[ "This is probably what you want:\nfiltered_result = []\nfor i in a:\n lst_id = i[\"id\"]\n lst_to_compare = i[\"test\"]\n filtered_inner_list = [item for item in lst_to_compare if item[\"id__\"] == lst_id]\n filtered_result.append({\"id\": lst_id, \"test\": filtered_inner_list})\n\nprint(filtered_result)\n\n", "Here's how I would solve this problem, hope it helps. The problem with your solution was that you were trying to eliminate the item of a list which you were looping over, so the whole iteration was faulty.\nind_list = list()\nfor key in my_list:\n id_num = key['id']\n for item in key['test']:\n if item['id__'] != id_num:\n ind_list.append(key['test'].index(item))\n for i in ind_list:\n key['test'].pop(i)\n ind_list.clear()\nprint(my_list)\n\n" ]

[ 0, 0 ]

[]

[]

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

[ "If you want a method-chained solution, you could use something like this:\nimport pandas as pd\n\n\nroce_by_year = (\n pd.merge(nopat, capital_employed)\n .rename(columns={\"\": \"date\"})\n .assign(\n date=lambda xdf: pd.to_datetime(\n xdf[\"date\"], errors=\"coerce\"\n ).dt.year\n )\n .assign(\n roce=lambda xdf: xdf.apply(\n lambda row: compute roce(\n row[\"nopat\"], row[\"capital_employed\"]\n ), axis=1\n )\n )\n .sort_values(\"date\", ascending=True)\n)[[\"date\", \"roce\"]]\n\n\n", "df1['date'] = pd.to_datetime(df1['date'])\ndf1\n###\n date nopat\n0 2021-12-31 3580000000\n1 2020-12-31 625000000\n2 2019-12-31 -1367000000\n3 2018-12-31 2028000000\n\ndf2['date'] = pd.to_datetime(df2['date'])\ndf2\n###\n date capital_employed\n0 2021-12-31 59240000000\n1 2020-12-31 60624000000\n2 2019-12-31 52035000000\n3 2018-12-31 54412000000\n\ndf3 = pd.merge(df1, df2, how='outer', left_on='date', right_on='date')\\\n .pipe(lambda x: x.assign(roe = x['nopat']/x['capital_employed']))\\\n .sort_values(by='date', ascending=True)\\\n .pipe(lambda x: x[['date', 'roe']])\\\n .pipe(lambda x: x.assign(date = x['date'].dt.strftime('%Y'))).reset_index(drop=True)\ndf3\n###\n date roe\n0 2018 0.037271\n1 2019 -0.026271\n2 2020 0.010309\n3 2021 0.060432\n\n", "Apply creates only the new column. You can try to create a new column on the existing dataframe like\nnopat.rename(columns={\"\": \"date\"}, inplace=True)\nnopat.sort_values(by='date', inplace=True)\n\nnopat.set_index('date', inplace=True)\ncapital_employed.rename(columns={\"\": \"date\"}, inplace=True)\ncapital_employed.set_index('date', inplace=True)\ncapital_employed.sort_values(by='date', inplace=True)\ndf = nopat.join(capital_employed, on='date')\ndf['roce'] = df.apply(lambda row: compute_roce(row['nopat'], \n row['capital_employed']), axis=1)\n\n" ]

[ 1, 1, 0 ]

[]

[]

[ "pandas", "python" ]

[ "This is the problem:\nclass ListAlt():\n def __init__(self):\n self.queue = [Node] # <--\n\nYou are setting queue to a list containing the Node class. Why not just an empty list?\nAlso, dequeue returns a Node instance. So to get 10, you need to write this instead:\nprint(lista.dequeue().value)\n\n\nHere is how I would change that code:\nclass Node:\n def __init__(self, node_id: int, value: int) -> None:\n self.id = node_id\n self.value = value\n\nclass ListAlt:\n def __init__(self) -> None:\n self.queue: list[Node] = []\n\n def append(self, node: Node) -> None:\n self.queue.append(node)\n\n def dequeue(self) -> Node:\n id_max = 0\n i = 0\n for nodo in self.queue:\n if nodo.value > self.queue[id_max].value:\n id_max = i\n i += 1\n result = self.queue[id_max]\n return result\n\nif __name__ == \"__main__\":\n n1 = Node(1, 10)\n n2 = Node(2, 3)\n n3 = Node(3, 6)\n \n lista = ListAlt()\n lista.append(n1)\n lista.append(n2)\n lista.append(n3)\n \n print(lista.dequeue().value)\n\n", "You are initializing your queue with the type Node. So, it is trying to get the value attribute of the type, which does not exist. Change your code with:\nclass ListAlt():\n def __init__(self):\n self.queue = []\n\n ...\n\n" ]

[ 3, 2 ]

[]

[]

[ "attributeerror", "python" ]