Datasets:

---

suriyagunasekar

/

stackoverflow-python-with-meta-data

like 10

[ "I advice to not using on message for making commands\nwhat I do advice:\nimport discord\nfrom discord.ext import commands\n \[email protected](name=\"name here if you want a different one than the function name\", description=\"describe it here\", hidden=False) #set hidden to True to hide it in the help\nasync def mycommand(ctx, argument1, argument2):\n '''A longer description of the command\n\n\n Usage example:\n !mycommand hi 1\n '''\n await ctx.send(f\"Got {argument1} and {argument2}\")\n\nif you will use the two ways together then add after this line\nawait message.channel.send (\"hello, I'm bot 0.0.1 Alpha\")\nthis:\n else:\n await bot.process_commands(message)\n\nif you want to make help command u should first remove the default one\nby editing this line bot = commands.Bot(command_prefix='!',intents=intents) to :\nbot = commands.Bot(command_prefix='!',intents=intents,help_command=None)\n\noverall code should look like\nimport discord, asyncio\nimport char # class file\nfrom discord.ext import commands\n\nintents=discord.Intents.all()\nclient = discord.Client(intents=intents) \n\nbot = commands.Bot(command_prefix='!',intents=intents,help_command=None)\n\[email protected]\nasync def on_ready():\n await client.change_presence(status=discord.Status.online, activity=discord.Game(\"Game\"))\n\n\[email protected]\nasync def on_message(message):\n async def new_class(ctx,user:discord.user,context1,context2):\n global char_num\n globals()['char_{}'.format(char_num)]=char(name=context1,Sffter=context2,username=ctx.message.author.name)\n char_num+=1\n await ctx.message.channel.send (\"done\", context1,\"!\")\n\[email protected]()\nasync def make(ctx,name,data):\n #do whatever u want with the name and data premeter\n pass\[email protected]()\nasync def help(ctx):\n await ctx.send(\"hello, I'm bot 0.0.1 Alpha\")\[email protected]()\nasync def test(ctx):\n await ctx.send (\"{} | {}, Hello\".format(ctx.author, ctx.author.mention))\n\n\nclient.run('-')\n\nand yeah if u want to know what is ctx\nctx is context which is default premeter and have some methods like send,author and more\n" ]

[ 0 ]

[]

[]

[ "discord", "python" ]

[ "Client IP has nothing to do with channels\nself.scope[\"client\"][0] is undefined because when you receive data from the front end at the backend there is no data with the name client. so try to send it from the frontend. you can send a manual, static value at first to verify and then find techniques to read the IP address and then send it.\n" ]

[ 0 ]

[]

[]

[ "django", "django_channels", "nginx", "python" ]

[ "You should never expect numerical methods to perform identically on different devices; or even different runs of the same code on the same device. Due to the finite precision of the machine you can never calculate the \"real\" result, but only numerical approximations. During a long optimization task these differences can sum up.\nFurthermore, some optimazion methods use some kind of randomness on the inside to solve the problem of being stuck in local minima: they add a small, alomost vanishing noise to the previous calculated solution to allow the algorithm to converge faster in the global minimum and not being stuck in a local minimum or a saddle-point.\nCan you try to plot the landscape of the function you want to minimize? This can help you to analyze the problem: If both of the results (on each machine) are local minima, then this behaviour can be explained by my previous description.\nIf this is not the case, you should check the version of scipy you have installed on both machines. Maybe you are implicitly using float values on one device and double values on the other one, too?\nYou see: there are a lot of possible explanations for this (at the first look) strange numerical behaviour; you have to give us more details to solve this.\n", "I found that different versions of SciPy do or do not allow minimum and maximum bounds to be the same. For example, in SciPy version 1.5.4, a parameter with equal min and max bounds sends that term's Jacobian to nan, which brings the minimization to a premature stop.\n" ]

[ 0, 0 ]

[]

[]

[ "minimization", "optimization", "python", "scipy" ]

[ "Following code can be used for executing python script\n private void runPythonCode(String pythonScript) {\n ProcessBuilder pb = new ProcessBuilder(\"python\", pythonScript);\n\n Process process = pb.start();\n int errCode = process.waitFor();\n\n if (errCode == 1) {\n System.out.println(\"Error\");\n } else {\n String filePath = output(process.getInputStream());\n logger.info(\"Generated report file path ::\" + filePath);\n if (filePath != null) {\n File docxFile = new File(filePath.trim());\n // creates a new file only if it does not exists,\n // file.exists() returns false\n // if we explicitly do not create file even if the file\n // exists\n docxFile.createNewFile();\n String updatedFileName = docxFile.getParent() + File.separator \n + jobAccountJson.getProviderName() + \"_\" + docxFile.getName();\n File reanmedFileName = new File(updatedFileName);\n if(docxFile.renameTo(reanmedFileName)) {\n logger.info(\"Renamed file to \" + r\n\neanmedFileName.getPath());\n return reanmedFileName;\n } else {\n logger.error(\"Could not rename file to \" + updatedFileName);\n }\n return docxFile;\n }\n }\n}\nprivate static String output(InputStream inputStream) throws IOException {\n StringBuilder sb = new StringBuilder();\n BufferedReader br = null;\n try {\n br = new BufferedReader(new InputStreamReader(inputStream));\n String line = null;\n while ((line = br.readLine()) != null) {\n sb.append(line + System.getProperty(\"line.separator\"));\n }\n } finally {\n if(br != null) {\n br.close();\n }\n }\n return sb.toString();\n}\n\n", " ProcessBuilder pb = new ProcessBuilder(\"python\", \"NameOfScript.py\");\n Process p = pb.start();\n p.getInputStream().transferTo(System.out);\n\n" ]

[ 0, 0 ]

[]

[]

[ "java", "jython", "numpy", "python" ]

[ "In pandas.read_csv, the string which is passed inside as a parameter is the name of the file. If the file does not exist, then python just considers the value as a string which in your case is the same.\nTry checking out the location of the jupyter notebook that you are running the code in and the file you want to access. According to your code, they should be in the same location.\n" ]

[ 0 ]

[]

[]

[ "dataset", "pandas", "python", "read.csv", "string" ]

[ "To generate such a list, you can use numpy's random.multinomial function. This function allows you to generate a list of random numbers that sum to a specified total, where each number is chosen from a different bin with a specified size.\nFor example, to generate a list of 5 random numbers that sum to 10, where the first number can be any integer from 0 to 10, the second number can be any integer from 0 to 6, and so on, you can use the following code:\nimport numpy as np\n\nlimits = [10, 6, 3, 5, 1]\ntotal = 10\n\nrandom_list = np.random.multinomial(total, [1/x for x in limits])\n\n\nThis will generate a list of 5 random numbers that sum to 10 and are less than or equal to the corresponding element in the limits list.\nAlternatively, you could use numpy's random.randint function to generate random numbers that are less than or equal to the corresponding element in the limits list, and then use a loop to add up the numbers until the sum equals the specified total. This approach would look something like this:\nimport numpy as np\n\nlimits = [10, 6, 3, 5, 1]\ntotal = 10\n\nrandom_list = []\n\n# Generate a random number for each element in limits\nfor limit in limits:\n random_list.append(np.random.randint(limit))\n\n# Keep adding random numbers until the sum equals the total\nwhile sum(random_list) != total:\n random_list[np.random.randint(len(random_list))] += 1\n\n\nBoth of these approaches should work to generate a list of random numbers that sum to a specified total and are less than or equal to the corresponding element in the limits list.\nEDIT FOR @gerges\nTo generate a list of random numbers that sum to a specified total and are less than or equal to the corresponding element in the limits list, you can use a combination of the numpy functions random.multinomial and random.randint.\nHere is an example of how you could do this:\nimport numpy as np\n\nlimits = [10, 6, 3, 5, 1]\ntotal = 10\n\n# Generate a list of random numbers that sum to the total using the multinomial function\nrandom_list = np.random.multinomial(total, [1/x for x in limits])\n\n# Use the randint function to ensure that each number is less than or equal to the corresponding limit\nfor i, limit in enumerate(limits):\n random_list[i] = np.random.randint(random_list[i], limit+1)\n\n# Check that the sum of the numbers in the list equals the specified total and that each number is less than or equal to the corresponding limit\nassert sum(random_list) == total\nfor i, number in enumerate(random_list):\n assert number <= limits[I]\n\n\nThis approach generates a list of random numbers using the multinomial function, and then uses the randint function to ensure that each number is less than or equal to the corresponding limit. This guarantees that the resulting list of numbers will sum to the specified total and will be less than or equal to the corresponding element in the limits list.\n", "Found what I was looking for: The hypergeometric distribution which is similar to the binomial, but without replacement.\nThe distribution available in numpy:\nimport numpy as np\n\ngen = np.random.Generator(np.random.PCG64(seed))\nrandom_list = gen.multivariate_hypergeometric(limits, total)\n\n# array([4, 4, 1, 1, 0])\n\nAlso to make sure I didn't misunderstand the distribution did a sanity check with 10 million samples and check that the maximum is always within the limits\nres = gen.multivariate_hypergeometric(limits, total, size=10000000) \n\nres.max(axis=0)\n\n# array([10, 6, 3, 5, 1])\n\nwhich is same as limits.\n" ]

[ 1, 1 ]

[]

[]

[ "numpy", "pandas", "python", "scipy" ]

[ "The simple Answer\nWith this treelib, you can't.\nAs they say in their documentation (http://xiaming.me/treelib/pyapi.html#node-objects):\ntree.save2file(filename[, nid[, level[, idhidden[, filter[, key[, reverse]]]]]]])\n Save the tree into file for offline analysis.\n\nIt does not contain any JSON-Parser, so it can not read the files. \nWhat can you do?\nYou have no other option as building the tree each time for every run. \nImplement a JSON-Reader that parses the file and creates the tree for you.\nhttps://docs.python.org/2/library/json.html\n", "I have built a small parser for my case. Maybe it works in your case.\nThe note identifiers are named after the tag plus the depth of the node in the tree (tag+depth).\nimport json\nfrom types import prepare_class\nfrom treelib import Node, Tree, node\nimport os\n\nfile_path = os.path.abspath(os.path.dirname(__file__))\n\nwith open(file_path + '\\\\tree.json') as f:\n tree_json = json.load(f)\n\ntree = Tree()\n\ndef load_tree(json_tree, depth=0, parent=None):\n k, value = list(json_tree.items())[0]\n \n if parent is None:\n tree.create_node(tag=str(k), identifier=str(k)+str(depth))\n parent = tree.get_node(str(k)+str(depth))\n\n for counter,value in enumerate(json_tree[k]['children']): \n if isinstance(json_tree[k]['children'][counter], str):\n tree.create_node(tag=value, identifier=value+str(depth), parent=parent)\n else:\n tree.create_node(tag=list(value)[0], identifier=list(value)[0]+str(depth), parent=parent)\n load_tree(json_tree[k]['children'][counter], depth+1, tree.get_node(list(value)[0]+str(depth)) )\n\nload_tree(tree_json)\n\n", "I have created a function to convert json to a tree:\nfrom treelib import Node, Tree, node\n\ndef create_node(tree, s, counter_byref, verbose, parent_id=None):\n node_id = counter_byref[0]\n if verbose:\n print(f\"tree.create_node({s}, {node_id}, parent={parent_id})\")\n tree.create_node(s, node_id, parent=parent_id)\n counter_byref[0] += 1\n return node_id\n\ndef to_compact_string(o):\n if type(o) == dict:\n if len(o)>1:\n raise Exception()\n k,v =next(iter(o.items()))\n return f'{k}:{to_compact_string(v)}'\n elif type(o) == list:\n if len(o)>1:\n raise Exception()\n return f'[{to_compact_string(next(iter(o)))}]'\n else:\n return str(o)\n\ndef to_compact(tree, o, counter_byref, verbose, parent_id):\n try:\n s = to_compact_string(o)\n if verbose:\n print(f\"# to_compact({o}) ==> [{s}]\")\n create_node(tree, s, counter_byref, verbose, parent_id=parent_id)\n return True\n except:\n return False\n\ndef json_2_tree(o , parent_id=None, tree=None, counter_byref=[0], verbose=False, compact_single_dict=False, listsNodeSymbol='+'):\n if tree is None:\n tree = Tree()\n parent_id = create_node(tree, '+', counter_byref, verbose)\n if compact_single_dict and to_compact(tree, o, counter_byref, verbose, parent_id):\n # no need to do more, inserted as a single node\n pass\n elif type(o) == dict:\n for k,v in o.items():\n if compact_single_dict and to_compact(tree, {k:v}, counter_byref, verbose, parent_id):\n # no need to do more, inserted as a single node\n continue\n key_nd_id = create_node(tree, str(k), counter_byref, verbose, parent_id=parent_id)\n if verbose:\n print(f\"# json_2_tree({v})\")\n json_2_tree(v , parent_id=key_nd_id, tree=tree, counter_byref=counter_byref, verbose=verbose, listsNodeSymbol=listsNodeSymbol, compact_single_dict=compact_single_dict)\n elif type(o) == list:\n if listsNodeSymbol is not None:\n parent_id = create_node(tree, listsNodeSymbol, counter_byref, verbose, parent_id=parent_id)\n for i in o:\n if compact_single_dict and to_compact(tree, i, counter_byref, verbose, parent_id):\n # no need to do more, inserted as a single node\n continue\n if verbose:\n print(f\"# json_2_tree({i})\")\n json_2_tree(i , parent_id=parent_id, tree=tree, counter_byref=counter_byref, verbose=verbose,listsNodeSymbol=listsNodeSymbol, compact_single_dict=compact_single_dict)\n else: #node\n create_node(tree, str(o), counter_byref, verbose, parent_id=parent_id)\n return tree\n\nThen for example:\nimport json\nj = json.loads('{\"2\": 3, \"4\": [5, 6], \"7\": {\"8\": 9}}')\njson_2_tree(j ,verbose=False,listsNodeSymbol='+' ).show() \n\ngives:\n+\n├── 2\n│ └── 3\n├── 4\n│ └── +\n│ ├── 5\n│ └── 6\n└── 7\n └── 8\n └── 9\n\nWhile\njson_2_tree(j ,listsNodeSymbol=None, verbose=False ).show() \n\n+\n├── 2\n│ └── 3\n├── 4\n│ ├── 5\n│ └── 6\n└── 7\n └── 8\n └── 9\n\nAnd\njson_2_tree(j ,compact_single_dict=True,listsNodeSymbol=None).show() \n\n+\n├── 2:3\n├── 4\n│ ├── 5\n│ └── 6\n└── 7:8:9\n\nAs you see, there are different trees one can make depending on how explicit vs. compact he wants to be.\n" ]

[ 1, 1, 0 ]

[]

[]

[ "json", "python", "tree" ]

[ "The key named obj occurs in list of dictionaries. Before you define another key, you must also specify the index of the list element.\nimport ast\ndf['json2']=df['json2'].apply(ast.literal_eval) #if dictionary's type is string, convert to dictionary.\n\ndef get_followers(x):\n if x['obj'][0]['timestp']=='2022-12-03':\n return x['obj'][0]['followers']\n\ndf['date'] = df['json2'].apply(get_followers)\n\nAlso you can use this too. This does the same job as the function you are using:\ndf['date'] = df['json2'].apply(lambda x: x['obj'][0]['followers'] if x['obj'][0]['timestp']=='2022-12-03' else None)\n\nfor list of dicts:\ndef get_followers(x):\n for i in x['obj']:\n if i['timestp'] == '2022-12-03':\n return i['followers']\n break\n \ndf['date'] = df['json2'].apply(get_followers)\n\n" ]

[ 1 ]

[]

[]

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

[ "First of all, let's check if you were consistent with your question (function that returns the length of the longest run of repetition):\ne.g.:\na = [4,1,2,4,7,9,4]\nb = [5,3,5,6,9,4,4,4,4]\n(assuming, you are only checking single position, e.g. c = [1,2,3,1,2,3] could have one repetition of sequence 1,2,3 - i am assuming that is not your goal)\nSo:\nfor a, there is no repetitions of same value, therefore length equals 0\nfor b, you have one, quadruple repetition of 4, therefore length equals 4\nFirst, your max_amount_of_repetitions=0 and current_repetitions_run=0' So, what you need to do to detect repetition is simply check if value of n-1'th and n'th element is same. If so, you increment current_repetitions_run', else, you reset current_repetitions_run=0.\nLast step is check if your current run is longest of all:\nmax_amount_of_repetitions= max(max_amount_of_repetitions, current_repetitions_run)\nto surely get both n-1 and n within your list range, I'd simply start iteration from second element. That way, n-1 is first element.\nfor n in range(1,len(a)):\n if a[n-1] == a[n]:\n print(\"I am sure, you can figure out the rest\")\n\n", "you can use hash to calculate the frequency of the element and then get the max of frequencies.\nusing functional approach\nfrom collections import Counter\ndef longest_repitition(array):\n return max(Counter(array).values())\n\nother way, without using Counter\ndef longest_repitition(array):\n freq = {}\n for val in array:\n if val not in freq:\n freq[val] = 0\n freq[val] += 1\n values = freq.values()\n return max(values)\n\n" ]

[ 0, 0 ]

[]

[]

[ "list", "python" ]

[ "You can even use it as user input. No problem at all.\ntxid = {'vin': [{'txid' : 10}, {'txid' : 20}, {'txid' : 30}, {'txid' : 40}]}\n\nvin = txid['vin'][0]['txid']\nprint(vin)\n\nvout = 3\nvin = txid['vin'][vout]['txid']\nprint(vin)\n\nOutput:\n10\n40\n\n" ]

[ 0 ]

[]

[]

[ "arrays", "python" ]

[ "I'm going to give you one way to implement what you want specifically, but I believe you have an important design flaw in this, as I explain in a comment above. In the way you have this coded, your socketio.Server() object will broadcast to all your clients, so will not be able to get a callback. If you want to emit to one client (hopefully not the same one that sent the HTTP request), then you need to add a room=client_sid argument to the emit. Or, if you are contacting a Socket.IO server, then you need to use a Socket.IO client here, not a server.\nIn any case, to block your HTTP route until the callback function is invoked, you can use an Event object. Something like this:\nfrom threading import Event\nfrom flask import jsonify\n\[email protected]('/test/<param>')\ndef get(param):\n ev = threading.Event()\n result = None\n\n def ack(data):\n nonlocal result\n nonlocal ev\n\n result = {'data': data}\n ev.set() # unblock HTTP route\n\n sio.emit('event', param, room=some_client_sid, callback=ack)\n ev.wait() # blocks until ev.set() is called\n return jsonify(result)\n\n", "I had a similar problem using FastAPI + socketIO (async version) and I was stuck at the exact same point. No eventlet so could not try out the monkey patching option.\nAfter a lot of head bangings it turns out that, for some reason, adding asyncio.sleep(.1) just before ev.wait() made everything work smoothly. Without that, emitted event actually never reach the other side (socketio client, in my scenario)\n" ]

[ 2, 0 ]

[]

[]

[ "flask", "flask_socketio", "python", "socket.io" ]

[ "Your printReverse seems to do something else than what its name suggests. I would think that this function would just iterate the list nodes in reversed order and print the values, but it actually reverses the list, and doesn't print the result because of a bug.\nThe error in your code is that the final loop has a condition that is guaranteed to be false. current is always None when it reaches that loop, so nothing gets printed there. This is easily fixed by initialising current just before the loop with:\n current = self.head\n\nThat fixes your issue, but it is not nice to have a function that both reverses the list, and prints it. It is better practice to separate these two tasks. The method that reverses the list could be named reverse. Then add another method that allows iteration of the values in the list. This is done by defining __iter__. The caller can then easily print the list with that iterator.\nHere is how that looks:\n def reverse(self):\n current = self.head\n while current:\n current.previous, current.next = current.next, current.previous\n current = current.previous\n self.head, self.tail = self.tail, self.head\n\n def __iter__(self):\n node = self.head\n while node:\n yield node.data\n node = node.next\n\n def __repr__(self):\n return \"->\".join(map(repr, self))\n\nThe main program can then be:\nlst = DoubleLinkedList()\nlst.addAtStart(1)\nlst.addAtStart(2)\nlst.addAtStart(3)\nprint(lst)\nlst.reverse()\nprint(lst)\n\n" ]

[ 1 ]

[]

[]

[ "linked_list", "python" ]

[ "Strange but when I first ran this in the IPython interpreter I got a different exception:\n... :35, in Graph.isAdjacent(self, a, b)\n 34 def isAdjacent(self, a: GraphNode, b: GraphNode) -> bool:\n---> 35 if self.V[a]==b:\n 36 return True\n 37 return False\n\n<class 'str'>: (<class 'RecursionError'>, RecursionError('maximum recursion depth exceeded while getting the str of an object'))\n\nWhen I run it as a script or in the normal interpreter I do get the same one you had:\n... line 35, in isAdjacent\n if self.V[a]==b:\nKeyError: <exception str() failed>\n\nI'm not sure what this means so I ran the debugger and got this:\n File \"/Users/.../stackoverflow/bfs1.py\", line 1, in <module>\n class Graph:\n File \"/Users/.../stackoverflow/bfs1.py\", line 47, in BFS\n if self.isAdjacent(u,v):\n File \"/Users/.../stackoverflow/bfs1.py\", line 35, in isAdjacent\n if self.V[a]==b:\nKeyError: <unprintable KeyError object>\nUncaught exception. Entering post mortem debugging\nRunning 'cont' or 'step' will restart the program\n> /Users/.../stackoverflow/bfs1.py(35)isAdjacent()\n-> if self.V[a]==b:\n(Pdb) type(a)\n<class '__main__.Graph.GraphNode'>\n(Pdb) str(a)\n*** RecursionError: maximum recursion depth exceeded while calling a Python object\n\nSo it does seem like a maximum recursion error. (The error message you originally got is not very helpful). But the words <unprintable KeyError object> are a clue. It looks like it was not able to display the KeyError exception...\nThe culprit is this line in your class definition:\n def __repr__(self):\n return str(self)\n\nWhat were you trying to do here?\nThe __repr__ function is called when the class is asked to produce a string representation of itself. But yours calls the string function on the instance of the class so it will call itself! So I think you actually generated a second exception while the debugger was trying to display the first!!!.\nI replaced these lines with\n def __repr__(self):\n return f\"GraphNode({self.jar1}, {self.jar2}, {self.jar3}, {self.color}, {self.pi})\"\n\nand I don't get the exception now:\nSize of first jar: 1\nSize of second jar: 3\nSize of third jar: 6\nSize of target: 4\nTraceback (most recent call last):\n File \"/Users/.../stackoverflow/bfs1.py\", line 77, in <module>\n output = graph1.BFS()\n File \"/Users/.../stackoverflow/bfs1.py\", line 45, in BFS\n if self.isAdjacent(u,v):\n File \"/Users/.../stackoverflow/bfs1.py\", line 33, in isAdjacent\n if self.V[a]==b:\nKeyError: GraphNode(0, 0, 0, white, None)\n\nThis exception is easier to interpret. Now it's over to you to figure out why this GraphNode was not found in the keys of self.V!\n" ]

[ 1 ]

[]

[]

[ "breadth_first_search", "graph_traversal", "python" ]

[ "One approach you could take is to use regular expressions to search for patterns in the text that match the information you're looking for. For example, in the sentence \"The total volume of the sales in the year 2019 is 400 whereas in the year 2020 is 600.\", you could use the following regular expression to match the sales data for each year: \\d{4} is \\d+. This regular expression will match any four-digit number followed by \" is \" and then one or more digits.\nOnce you have matched the relevant data points, you can use a library like Python's re module to extract the information you need. For example, in Python you could do something like this:\nimport re\n\ntext = \"The total volume of the sales in the year 2019 is 400 whereas in the year 2020 is 600.\"\n\n# Use the regular expression to find all matches in the text\nmatches = re.findall(r\"\\d{4} is \\d+\", text)\n\n# Loop through the matches and extract the year and sales data\nfor match in matches:\n year, sales = match.split(\" is \")\n print(f\"Year: {year}, Sales: {sales}\")\n\nThis code would output the following:\nYear: 2019, Sales: 400\nYear: 2020, Sales: 600\n\nAnother option is to use a natural language processing (NLP) library like spaCy or NLTK to extract the information you need. These libraries can help you identify and extract specific entities, such as dates and numbers, from a piece of text.\nFor example, using spaCy you could do something like this:\nimport spacy\n\n# Load the English model\nnlp = spacy.load(\"en_core_web_sm\")\n\n# Parse the text\ntext = \"The total volume of the sales in the year 2019 is 400 whereas in the year 2020 is 600.\"\ndoc = nlp(text)\n\n# Loop through the entities in the document\nfor ent in doc.ents:\n # If the entity is a date and a number, print the year and the sales data\n if ent.label_ == \"DATE\" and ent.label_ == \"CARDINAL\":\n print(f\"Year: {ent.text}, Sales: {ent.text}\")\n\nThis code would output the same results as the previous example.\nOverall, there are many approaches you can take to extract multiple data points from a single paragraph. The approach you choose will depend on the specific requirements of your task and the data you are working with.\n" ]

[ 1 ]

[]

[]

[ "nlp", "python" ]

[ "Alex summarized well but, surprisingly, was too succinct.\nFirst, let me reiterate the main points in Alex’s post:\n\nThe default implementation is useless (it’s hard to think of one which wouldn’t be, but yeah)\n__repr__ goal is to be unambiguous\n__str__ goal is to be readable\nContainer’s __str__ uses contained objects’ __repr__\n\nDefault implementation is useless\nThis is mostly a surprise because Python’s defaults tend to be fairly useful. However, in this case, having a default for __repr__ which would act like:\nreturn \"%s(%r)\" % (self.__class__, self.__dict__)\n\nwould have been too dangerous (for example, too easy to get into infinite recursion if objects reference each other). So Python cops out. Note that there is one default which is true: if __repr__ is defined, and __str__ is not, the object will behave as though __str__=__repr__.\nThis means, in simple terms: almost every object you implement should have a functional __repr__ that’s usable for understanding the object. Implementing __str__ is optional: do that if you need a “pretty print” functionality (for example, used by a report generator).\nThe goal of __repr__ is to be unambiguous\nLet me come right out and say it — I do not believe in debuggers. I don’t really know how to use any debugger, and have never used one seriously. Furthermore, I believe that the big fault in debuggers is their basic nature — most failures I debug happened a long long time ago, in a galaxy far far away. This means that I do believe, with religious fervor, in logging. Logging is the lifeblood of any decent fire-and-forget server system. Python makes it easy to log: with maybe some project specific wrappers, all you need is a\nlog(INFO, \"I am in the weird function and a is\", a, \"and b is\", b, \"but I got a null C — using default\", default_c)\n\nBut you have to do the last step — make sure every object you implement has a useful repr, so code like that can just work. This is why the “eval” thing comes up: if you have enough information so eval(repr(c))==c, that means you know everything there is to know about c. If that’s easy enough, at least in a fuzzy way, do it. If not, make sure you have enough information about c anyway. I usually use an eval-like format: \"MyClass(this=%r,that=%r)\" % (self.this,self.that). It does not mean that you can actually construct MyClass, or that those are the right constructor arguments — but it is a useful form to express “this is everything you need to know about this instance”.\nNote: I used %r above, not %s. You always want to use repr() [or %r formatting character, equivalently] inside __repr__ implementation, or you’re defeating the goal of repr. You want to be able to differentiate MyClass(3) and MyClass(\"3\").\nThe goal of __str__ is to be readable\nSpecifically, it is not intended to be unambiguous — notice that str(3)==str(\"3\"). Likewise, if you implement an IP abstraction, having the str of it look like 192.168.1.1 is just fine. When implementing a date/time abstraction, the str can be \"2010/4/12 15:35:22\", etc. The goal is to represent it in a way that a user, not a programmer, would want to read it. Chop off useless digits, pretend to be some other class — as long is it supports readability, it is an improvement.\nContainer’s __str__ uses contained objects’ __repr__\nThis seems surprising, doesn’t it? It is a little, but how readable would it be if it used their __str__?\n[moshe is, 3, hello\nworld, this is a list, oh I don't know, containing just 4 elements]\n\nNot very. Specifically, the strings in a container would find it way too easy to disturb its string representation. In the face of ambiguity, remember, Python resists the temptation to guess. If you want the above behavior when you’re printing a list, just\nprint(\"[\" + \", \".join(l) + \"]\")\n\n(you can probably also figure out what to do about dictionaries.\nSummary\nImplement __repr__ for any class you implement. This should be second nature. Implement __str__ if you think it would be useful to have a string version which errs on the side of readability.\n", "My rule of thumb: __repr__ is for developers, __str__ is for customers.\n", "Unless you specifically act to ensure otherwise, most classes don't have helpful results for either:\n>>> class Sic(object): pass\n... \n>>> print(str(Sic()))\n<__main__.Sic object at 0x8b7d0>\n>>> print(repr(Sic()))\n<__main__.Sic object at 0x8b7d0>\n>>> \n\nAs you see -- no difference, and no info beyond the class and object's id. If you only override one of the two...:\n>>> class Sic(object): \n... def __repr__(self): return 'foo'\n... \n>>> print(str(Sic()))\nfoo\n>>> print(repr(Sic()))\nfoo\n>>> class Sic(object):\n... def __str__(self): return 'foo'\n... \n>>> print(str(Sic()))\nfoo\n>>> print(repr(Sic()))\n<__main__.Sic object at 0x2617f0>\n>>> \n\nas you see, if you override __repr__, that's ALSO used for __str__, but not vice versa.\nOther crucial tidbits to know: __str__ on a built-on container uses the __repr__, NOT the __str__, for the items it contains. And, despite the words on the subject found in typical docs, hardly anybody bothers making the __repr__ of objects be a string that eval may use to build an equal object (it's just too hard, AND not knowing how the relevant module was actually imported makes it actually flat out impossible).\nSo, my advice: focus on making __str__ reasonably human-readable, and __repr__ as unambiguous as you possibly can, even if that interferes with the fuzzy unattainable goal of making __repr__'s returned value acceptable as input to __eval__!\n", "__repr__: representation of python object usually eval will convert it back to that object\n__str__: is whatever you think is that object in text form\ne.g.\n>>> s=\"\"\"w'o\"w\"\"\"\n>>> repr(s)\n'\\'w\\\\\\'o\"w\\''\n>>> str(s)\n'w\\'o\"w'\n>>> eval(str(s))==s\nTraceback (most recent call last):\n File \"<stdin>\", line 1, in <module>\n File \"<string>\", line 1\n w'o\"w\n ^\nSyntaxError: EOL while scanning single-quoted string\n>>> eval(repr(s))==s\nTrue\n\n", "\nIn short, the goal of __repr__ is to be unambiguous and __str__ is to be\n readable.\n\nHere is a good example:\n>>> import datetime\n>>> today = datetime.datetime.now()\n>>> str(today)\n'2012-03-14 09:21:58.130922'\n>>> repr(today)\n'datetime.datetime(2012, 3, 14, 9, 21, 58, 130922)'\n\nRead this documentation for repr:\n\nrepr(object)\nReturn a string containing a printable representation of an object. This is the same value yielded by conversions (reverse\n quotes). It is sometimes useful to be able to access this operation as\n an ordinary function. For many types, this function makes an attempt\n to return a string that would yield an object with the same value when\n passed to eval(), otherwise the representation is a string enclosed in\n angle brackets that contains the name of the type of the object\n together with additional information often including the name and\n address of the object. A class can control what this function returns\n for its instances by defining a __repr__() method.\n\nHere is the documentation for str:\n\nstr(object='')\nReturn a string containing a nicely printable\n representation of an object. For strings, this returns the string\n itself. The difference with repr(object) is that str(object) does not\n always attempt to return a string that is acceptable to eval(); its\n goal is to return a printable string. If no argument is given, returns\n the empty string, ''.\n\n", "\nWhat is the difference between __str__ and __repr__ in Python?\n\n__str__ (read as \"dunder (double-underscore) string\") and __repr__ (read as \"dunder-repper\" (for \"representation\")) are both special methods that return strings based on the state of the object.\n__repr__ provides backup behavior if __str__ is missing.\nSo one should first write a __repr__ that allows you to reinstantiate an equivalent object from the string it returns e.g. using eval or by typing it in character-for-character in a Python shell.\nAt any time later, one can write a __str__ for a user-readable string representation of the instance, when one believes it to be necessary.\n__str__\nIf you print an object, or pass it to format, str.format, or str, then if a __str__ method is defined, that method will be called, otherwise, __repr__ will be used.\n__repr__\nThe __repr__ method is called by the builtin function repr and is what is echoed on your python shell when it evaluates an expression that returns an object.\nSince it provides a backup for __str__, if you can only write one, start with __repr__\nHere's the builtin help on repr:\nrepr(...)\n repr(object) -> string\n \n Return the canonical string representation of the object.\n For most object types, eval(repr(object)) == object.\n\nThat is, for most objects, if you type in what is printed by repr, you should be able to create an equivalent object. But this is not the default implementation.\nDefault Implementation of __repr__\nThe default object __repr__ is (C Python source) something like:\ndef __repr__(self):\n return '<{0}.{1} object at {2}>'.format(\n type(self).__module__, type(self).__qualname__, hex(id(self)))\n\nThat means by default you'll print the module the object is from, the class name, and the hexadecimal representation of its location in memory - for example:\n<__main__.Foo object at 0x7f80665abdd0>\n\nThis information isn't very useful, but there's no way to derive how one might accurately create a canonical representation of any given instance, and it's better than nothing, at least telling us how we might uniquely identify it in memory.\nHow can __repr__ be useful?\nLet's look at how useful it can be, using the Python shell and datetime objects. First we need to import the datetime module:\nimport datetime\n\nIf we call datetime.now in the shell, we'll see everything we need to recreate an equivalent datetime object. This is created by the datetime __repr__:\n>>> datetime.datetime.now()\ndatetime.datetime(2015, 1, 24, 20, 5, 36, 491180)\n\nIf we print a datetime object, we see a nice human readable (in fact, ISO) format. This is implemented by datetime's __str__:\n>>> print(datetime.datetime.now())\n2015-01-24 20:05:44.977951\n\nIt is a simple matter to recreate the object we lost because we didn't assign it to a variable by copying and pasting from the __repr__ output, and then printing it, and we get it in the same human readable output as the other object:\n>>> the_past = datetime.datetime(2015, 1, 24, 20, 5, 36, 491180)\n>>> print(the_past)\n2015-01-24 20:05:36.491180\n\n#How do I implement them?\nAs you're developing, you'll want to be able to reproduce objects in the same state, if possible. This, for example, is how the datetime object defines __repr__ (Python source). It is fairly complex, because of all of the attributes needed to reproduce such an object:\ndef __repr__(self):\n \"\"\"Convert to formal string, for repr().\"\"\"\n L = [self._year, self._month, self._day, # These are never zero\n self._hour, self._minute, self._second, self._microsecond]\n if L[-1] == 0:\n del L[-1]\n if L[-1] == 0:\n del L[-1]\n s = \"%s.%s(%s)\" % (self.__class__.__module__,\n self.__class__.__qualname__,\n \", \".join(map(str, L)))\n if self._tzinfo is not None:\n assert s[-1:] == \")\"\n s = s[:-1] + \", tzinfo=%r\" % self._tzinfo + \")\"\n if self._fold:\n assert s[-1:] == \")\"\n s = s[:-1] + \", fold=1)\"\n return s\n\nIf you want your object to have a more human readable representation, you can implement __str__ next. Here's how the datetime object (Python source) implements __str__, which it easily does because it already has a function to display it in ISO format:\ndef __str__(self):\n \"Convert to string, for str().\"\n return self.isoformat(sep=' ')\n\nSet __repr__ = __str__?\nThis is a critique of another answer here that suggests setting __repr__ = __str__.\nSetting __repr__ = __str__ is silly - __repr__ is a fallback for __str__ and a __repr__, written for developers usage in debugging, should be written before you write a __str__.\nYou need a __str__ only when you need a textual representation of the object.\nConclusion\nDefine __repr__ for objects you write so you and other developers have a reproducible example when using it as you develop. Define __str__ when you need a human readable string representation of it.\n", "On page 358 of the book Python scripting for computational science by Hans Petter Langtangen, it clearly states that \n\nThe __repr__ aims at a complete string representation of the object;\nThe __str__ is to return a nice string for printing.\n\nSo, I prefer to understand them as\n\nrepr = reproduce\nstr = string (representation)\n\nfrom the user's point of view\nalthough this is a misunderstanding I made when learning python.\nA small but good example is also given on the same page as follows:\nExample\nIn [38]: str('s')\nOut[38]: 's'\n\nIn [39]: repr('s')\nOut[39]: \"'s'\"\n\nIn [40]: eval(str('s'))\nTraceback (most recent call last):\n\n File \"<ipython-input-40-abd46c0c43e7>\", line 1, in <module>\n eval(str('s'))\n\n File \"<string>\", line 1, in <module>\n\nNameError: name 's' is not defined\n\n\nIn [41]: eval(repr('s'))\nOut[41]: 's'\n\n", "Apart from all the answers given, I would like to add few points :-\n1) __repr__() is invoked when you simply write object's name on interactive python console and press enter.\n2) __str__() is invoked when you use object with print statement.\n3) In case, if __str__ is missing, then print and any function using str() invokes __repr__() of object.\n4) __str__() of containers, when invoked will execute __repr__() method of its contained elements.\n5) str() called within __str__() could potentially recurse without a base case, and error on maximum recursion depth.\n6) __repr__() can call repr() which will attempt to avoid infinite recursion automatically, replacing an already represented object with ....\n", "(2020 entry)\nQ: What's the difference between __str__() and __repr__()?\nTL;DR:\n\nLONG\nThis question has been around a long time, and there are a variety of answers of which most are correct (not to mention from several Python community legends[!]). However when it comes down to the nitty-gritty, this question is analogous to asking the difference between the str() and repr() built-in functions. I'm going to describe the differences in my own words (which means I may be \"borrowing\" liberally from Core Python Programming so pls forgive me).\nBoth str() and repr() have the same basic job: their goal is to return a string representation of a Python object. What kind of string representation is what differentiates them.\n\nstr() & __str__() return a printable string representation of\nan object... something human-readable/for human consumption\nrepr() & __repr__() return a string representation of an object that is a valid Python expression, an object you can pass to eval() or type into the Python shell without getting an error.\n\nFor example, let's assign a string to x and an int to y, and simply showing human-readable string versions of each:\n>>> x, y = 'foo', 123\n>>> str(x), str(y)\n('foo', '123')\n\nCan we take what is inside the quotes in both cases and enter them verbatim into the Python interpreter? Let's give it a try:\n>>> 123\n123\n>>> foo\nTraceback (most recent call last):\n File \"<stdin>\", line 1, in <module>\nNameError: name 'foo' is not defined\n\nClearly you can for an int but not necessarily for a str. Similarly, while I can pass '123' to eval(), that doesn't work for 'foo':\n>>> eval('123')\n123\n>>> eval('foo')\nTraceback (most recent call last):\n File \"<stdin>\", line 1, in <module>\n File \"<string>\", line 1, in <module>\nNameError: name 'foo' is not defined\n\nSo this tells you the Python shell just eval()s what you give it. Got it? Now, let's repr() both expressions and see what we get. More specifically, take its output and dump those out in the interpreter (there's a point to this which we'll address afterwards):\n>>> repr(x), repr(y)\n(\"'foo'\", '123')\n>>> 123\n123\n>>> 'foo'\n'foo'\n\nWow, they both work? That's because 'foo', while a printable string representation of that string, it's not evaluatable, but \"'foo'\" is. 123 is a valid Python int called by either str() or repr(). What happens when we call eval() with these?\n>>> eval('123')\n123\n>>> eval(\"'foo'\")\n'foo'\n\nIt works because 123 and 'foo' are valid Python objects. Another key takeaway is that while sometimes both return the same thing (the same string representation), that's not always the case. (And yes, yes, I can go create a variable foo where the eval() works, but that's not the point.)\nMore factoids about both pairs\n\nSometimes, str() and repr() are called implicitly, meaning they're called on behalf of users: when users execute print (Py1/Py2) or call print() (Py3+), even if users don't call str() explicitly, such a call is made on their behalf before the object is displayed.\nIn the Python shell (interactive interpreter), if you enter a variable at the >>> prompt and press RETURN, the interpreter displays the results of repr() implicitly called on that object.\nTo connect str() and repr() to __str__() and __repr__(), realize that calls to the built-in functions, i.e., str(x) or repr(y) result in calling their object's corresponding special methods: x.__str__() or y.__repr()__\nBy implementing __str__() and __repr__() for your Python classes, you overload the built-in functions (str() and repr()), allowing instances of your classes to be passed in to str() and repr(). When such calls are made, they turn around and call the class' __str__() and __repr__() (per #3).\n\n", "To put it simply:\n__str__ is used in to show a string representation of your object to be read easily by others.\n__repr__ is used to show a string representation of the object.\nLet's say I want to create a Fraction class where the string representation of a fraction is '(1/2)' and the object (Fraction class) is to be represented as 'Fraction (1,2)'\nSo we can create a simple Fraction class:\nclass Fraction:\n def __init__(self, num, den):\n self.__num = num\n self.__den = den\n\n def __str__(self):\n return '(' + str(self.__num) + '/' + str(self.__den) + ')'\n\n def __repr__(self):\n return 'Fraction (' + str(self.__num) + ',' + str(self.__den) + ')'\n\n\n\nf = Fraction(1,2)\nprint('I want to represent the Fraction STRING as ' + str(f)) # (1/2)\nprint('I want to represent the Fraction OBJECT as ', repr(f)) # Fraction (1,2)\n\n", "From an (An Unofficial) Python Reference Wiki (archive copy) by effbot:\n__str__ \"computes the \"informal\" string representation of an object. This differs from __repr__ in that it does not have to be a valid Python expression: a more convenient or concise representation may be used instead.\"\n", "In all honesty, eval(repr(obj)) is never used. If you find yourself using it, you should stop, because eval is dangerous, and strings are a very inefficient way to serialize your objects (use pickle instead).\nTherefore, I would recommend setting __repr__ = __str__. The reason is that str(list) calls repr on the elements (I consider this to be one of the biggest design flaws of Python that was not addressed by Python 3). An actual repr will probably not be very helpful as the output of print([your, objects]).\nTo qualify this, in my experience, the most useful use case of the repr function is to put a string inside another string (using string formatting). This way, you don't have to worry about escaping quotes or anything. But note that there is no eval happening here.\n", "str - Creates a new string object from the given object.\nrepr - Returns the canonical string representation of the object.\nThe differences:\nstr():\n\nmakes object readable\ngenerates output for end-user\n\nrepr():\n\nneeds code that reproduces object\ngenerates output for developer\n\n", "From the book Fluent Python:\n\nA basic requirement for a Python object is to provide usable \n string representations of itself, one used for debugging and\n logging, another for presentation to end users. That is why the\n special methods __repr__ and __str__ exist in the data model.\n\n", "One aspect that is missing in other answers. It's true that in general the pattern is:\n\nGoal of __str__: human-readable\nGoal of __repr__: unambiguous, possibly machine-readable via eval\n\nUnfortunately, this differentiation is flawed, because the Python REPL and also IPython use __repr__ for printing objects in a REPL console (see related questions for Python and IPython). Thus, projects which are targeted for interactive console work (e.g., Numpy or Pandas) have started to ignore above rules and provide a human-readable __repr__ implementation instead.\n", "You can get some insight from this code:\nclass Foo():\n def __repr__(self):\n return(\"repr\")\n def __str__(self):\n return(\"str\")\n\nfoo = Foo()\nfoo #repr\nprint(foo) #str\n\n", "__str__ can be invoked on an object by calling str(obj) and should return a human readable string. \n__repr__ can be invoked on an object by calling repr(obj) and should return internal object (object fields/attributes)\nThis example may help:\nclass C1:pass\n\nclass C2: \n def __str__(self):\n return str(f\"{self.__class__.__name__} class str \")\n\nclass C3: \n def __repr__(self): \n return str(f\"{self.__class__.__name__} class repr\")\n\nclass C4: \n def __str__(self):\n return str(f\"{self.__class__.__name__} class str \")\n def __repr__(self): \n return str(f\"{self.__class__.__name__} class repr\")\n\n\nci1 = C1() \nci2 = C2() \nci3 = C3() \nci4 = C4()\n\nprint(ci1) #<__main__.C1 object at 0x0000024C44A80C18>\nprint(str(ci1)) #<__main__.C1 object at 0x0000024C44A80C18>\nprint(repr(ci1)) #<__main__.C1 object at 0x0000024C44A80C18>\nprint(ci2) #C2 class str\nprint(str(ci2)) #C2 class str\nprint(repr(ci2)) #<__main__.C2 object at 0x0000024C44AE12E8>\nprint(ci3) #C3 class repr\nprint(str(ci3)) #C3 class repr\nprint(repr(ci3)) #C3 class repr\nprint(ci4) #C4 class str \nprint(str(ci4)) #C4 class str \nprint(repr(ci4)) #C4 class repr\n\n", ">>> print(decimal.Decimal(23) / decimal.Decimal(\"1.05\"))\n21.90476190476190476190476190\n>>> decimal.Decimal(23) / decimal.Decimal(\"1.05\")\nDecimal('21.90476190476190476190476190')\n\nWhen print() is called on the result of decimal.Decimal(23) / decimal.Decimal(\"1.05\") the raw number is printed; this output is in string form which can be achieved with __str__(). If we simply enter the expression we get a decimal.Decimal output — this output is in representational form which can be achieved with __repr__(). All Python objects have two output forms. String form is designed to be human-readable. The representational form is designed to produce output that if fed to a Python interpreter would (when possible) reproduce the represented object.\n", "Excellent answers already cover the difference between __str__ and __repr__, which for me boils down to the former being readable even by an end user, and the latter being as useful as possible to developers. Given that, I find that the default implementation of __repr__ often fails to achieve this goal because it omits information useful to developers.\nFor this reason, if I have a simple enough __str__, I generally just try to get the best of both worlds with something like:\ndef __repr__(self):\n return '{0} ({1})'.format(object.__repr__(self), str(self))\n\n", "\nOne important thing to keep in mind is that container's __str__ uses contained objects' __repr__.\n\n>>> from datetime import datetime\n>>> from decimal import Decimal\n>>> print (Decimal('52'), datetime.now())\n(Decimal('52'), datetime.datetime(2015, 11, 16, 10, 51, 26, 185000))\n>>> str((Decimal('52'), datetime.now()))\n\"(Decimal('52'), datetime.datetime(2015, 11, 16, 10, 52, 22, 176000))\"\n\nPython favors unambiguity over readability, the __str__ call of a tuple calls the contained objects' __repr__, the \"formal\" representation of an object. Although the formal representation is harder to read than an informal one, it is unambiguous and more robust against bugs.\n", "In a nutshell:\nclass Demo:\n def __repr__(self):\n return 'repr'\n def __str__(self):\n return 'str'\n\ndemo = Demo()\nprint(demo) # use __str__, output 'str' to stdout\n\ns = str(demo) # __str__ is used, return 'str'\nr = repr(demo) # __repr__ is used, return 'repr'\n\nimport logging\nlogger = logging.getLogger(logging.INFO)\nlogger.info(demo) # use __str__, output 'str' to stdout\n\nfrom pprint import pprint, pformat\npprint(demo) # use __repr__, output 'repr' to stdout\nresult = pformat(demo) # use __repr__, result is string which value is 'str'\n\n", "Understand __str__ and __repr__ intuitively and permanently distinguish them at all.\n__str__ return the string disguised body of a given object for readable of eyes\n__repr__ return the real flesh body of a given object (return itself) for unambiguity to identify.\nSee it in an example\nIn [30]: str(datetime.datetime.now())\nOut[30]: '2017-12-07 15:41:14.002752'\nDisguised in string form\n\nAs to __repr__\nIn [32]: datetime.datetime.now()\nOut[32]: datetime.datetime(2017, 12, 7, 15, 43, 27, 297769)\nPresence in real body which allows to be manipulated directly.\n\nWe can do arithmetic operation on __repr__ results conveniently.\nIn [33]: datetime.datetime.now()\nOut[33]: datetime.datetime(2017, 12, 7, 15, 47, 9, 741521)\nIn [34]: datetime.datetime(2017, 12, 7, 15, 47, 9, 741521) - datetime.datetime(2\n ...: 017, 12, 7, 15, 43, 27, 297769)\nOut[34]: datetime.timedelta(0, 222, 443752)\n\nif apply the operation on __str__\nIn [35]: '2017-12-07 15:43:14.002752' - '2017-12-07 15:41:14.002752'\nTypeError: unsupported operand type(s) for -: 'str' and 'str'\n\nReturns nothing but error.\nAnother example.\nIn [36]: str('string_body')\nOut[36]: 'string_body' # in string form\n\nIn [37]: repr('real_body')\nOut[37]: \"'real_body'\" #its real body hide inside\n\nHope this help you build concrete grounds to explore more answers.\n", "\n__str__ must return string object whereas __repr__ can return any python expression.\nIf __str__ implementation is missing then __repr__ function is used as fallback. There is no fallback if __repr__ function implementation is missing.\nIf __repr__ function is returning String representation of the object, we can skip implementation of __str__ function.\n\nSource: https://www.journaldev.com/22460/python-str-repr-functions\n", "__repr__ is used everywhere, except by print and str methods (when a __str__is defined !)\n", "Every object inherits __repr__ from the base class that all objects created.\nclass Person:\n pass\n\np=Person()\n\nif you call repr(p) you will get this as default:\n <__main__.Person object at 0x7fb2604f03a0>\n\nBut if you call str(p) you will get the same output. it is because when __str__ does not exist, Python calls __repr__\nLet's implement our own __str__\nclass Person:\n def __init__(self,name,age):\n self.name=name\n self.age=age\n def __repr__(self):\n print(\"__repr__ called\")\n return f\"Person(name='{self.name}',age={self.age})\"\n\np=Person(\"ali\",20)\n\nprint(p) and str(p)will return\n __repr__ called\n Person(name='ali',age=20)\n\nlet's add __str__()\nclass Person:\n def __init__(self, name, age):\n self.name = name\n self.age = age\n \n def __repr__(self):\n print('__repr__ called')\n return f\"Person(name='{self.name}, age=self.age')\"\n \n def __str__(self):\n print('__str__ called')\n return self.name\n\np=Person(\"ali\",20)\n\nif we call print(p) and str(p), it will call __str__() so it will return\n__str__ called\nali\n\nrepr(p) will return\nrepr called\n\"Person(name='ali, age=self.age')\"\nLet's omit __repr__ and just implement __str__.\nclass Person:\ndef __init__(self, name, age):\n self.name = name\n self.age = age\n\ndef __str__(self):\n print('__str__ called')\n return self.name\n\np=Person('ali',20)\n\nprint(p) will look for the __str__ and will return:\n__str__ called\nali\n\nNOTE= if we had __repr__ and __str__ defined, f'name is {p}' would call __str__\n", "\nProgrammers with prior experience in languages with a toString method tend to implement __str__ and not __repr__.\nIf you only implement one of these special methods in Python, choose __repr__.\n\nFrom Fluent Python book, by Ramalho, Luciano.\n", "Basically __str__ or str() is used for creating output that is human-readable are must be for end-users.\nOn the other hand, repr() or __repr__ mainly returns canonical string representation of objects which serve the purpose of debugging and development helps the programmers.\n", "repr() used when we debug or log.It is used for developers to understand code.\none the other hand str() user for non developer like(QA) or user.\nclass Customer:\n def __init__(self,name):\n self.name = name\n def __repr__(self):\n return \"Customer('{}')\".format(self.name)\n def __str__(self):\n return f\"cunstomer name is {self.name}\"\n\ncus_1 = Customer(\"Thusi\")\nprint(repr(cus_1)) #print(cus_1.__repr__()) \nprint(str(cus_1)) #print(cus_1.__str__())\n\n", "As far as I see it:\n__str__ is used for converting an object as a string, which makes the object more human-readable (for costumers like me). However, __repr__ must be used for representing the class's object as a string, which seems more unambiguous. So __repr__ is most likely used by developers for development and debugging.\n" ]

[ 3334, 749, 498, 207, 201, 164, 49, 48, 37, 16, 15, 14, 12, 9, 9, 9, 8, 6, 6, 5, 5, 4, 4, 3, 3, 1, 1, 1, 0 ]

[]

[]

[ "magic_methods", "python", "repr" ]

[ "TL;DR: Not possible. See 'conclusion' at the end.\n\nThere is an usage scenario where you might need this. I'm not implying there are not better ways or achieving the same functionality.\nThis would be useful in order to 'dump' an arbitrary list of dictionaries in case of error, in debug modes and other similar situations.\nWhat would be needed, is the reverse of the eval() function:\nget_indentifier_name_missing_function()\n\nwhich would take an identifier name ('variable','dictionary',etc) as an argument, and return a\nstring containing the identifier’s name.\n\nConsider the following current state of affairs:\nrandom_function(argument_data)\n\nIf one is passing an identifier name ('function','variable','dictionary',etc) argument_data to a random_function() (another identifier name), one actually passes an identifier (e.g.: <argument_data object at 0xb1ce10>) to another identifier (e.g.: <function random_function at 0xafff78>):\n<function random_function at 0xafff78>(<argument_data object at 0xb1ce10>)\n\nFrom my understanding, only the memory address is passed to the function:\n<function at 0xafff78>(<object at 0xb1ce10>)\n\nTherefore, one would need to pass a string as an argument to random_function() in order for that function to have the argument's identifier name:\nrandom_function('argument_data')\n\nInside the random_function()\ndef random_function(first_argument):\n\n, one would use the already supplied string 'argument_data' to:\n\nserve as an 'identifier name' (to display, log, string split/concat, whatever)\n\nfeed the eval() function in order to get a reference to the actual identifier, and therefore, a reference to the real data:\nprint(\"Currently working on\", first_argument)\nsome_internal_var = eval(first_argument)\nprint(\"here comes the data: \" + str(some_internal_var))\n\n\n\nUnfortunately, this doesn't work in all cases. It only works if the random_function() can resolve the 'argument_data' string to an actual identifier. I.e. If argument_data identifier name is available in the random_function()'s namespace.\nThis isn't always the case:\n# main1.py\nimport some_module1\n\nargument_data = 'my data'\n\nsome_module1.random_function('argument_data')\n\n\n# some_module1.py\ndef random_function(first_argument):\n print(\"Currently working on\", first_argument)\n some_internal_var = eval(first_argument)\n print(\"here comes the data: \" + str(some_internal_var))\n######\n\nExpected results would be:\nCurrently working on: argument_data\nhere comes the data: my data\n\nBecause argument_data identifier name is not available in the random_function()'s namespace, this would yield instead:\nCurrently working on argument_data\nTraceback (most recent call last):\n File \"~/main1.py\", line 6, in <module>\n some_module1.random_function('argument_data')\n File \"~/some_module1.py\", line 4, in random_function\n some_internal_var = eval(first_argument)\n File \"<string>\", line 1, in <module>\nNameError: name 'argument_data' is not defined\n\n\nNow, consider the hypotetical usage of a get_indentifier_name_missing_function() which would behave as described above.\nHere's a dummy Python 3.0 code: .\n# main2.py\nimport some_module2\nsome_dictionary_1 = { 'definition_1':'text_1',\n 'definition_2':'text_2',\n 'etc':'etc.' }\nsome_other_dictionary_2 = { 'key_3':'value_3',\n 'key_4':'value_4', \n 'etc':'etc.' }\n#\n# more such stuff\n#\nsome_other_dictionary_n = { 'random_n':'random_n',\n 'etc':'etc.' }\n\nfor each_one_of_my_dictionaries in ( some_dictionary_1,\n some_other_dictionary_2,\n ...,\n some_other_dictionary_n ):\n some_module2.some_function(each_one_of_my_dictionaries)\n\n\n# some_module2.py\ndef some_function(a_dictionary_object):\n for _key, _value in a_dictionary_object.items():\n print( get_indentifier_name_missing_function(a_dictionary_object) +\n \" \" +\n str(_key) +\n \" = \" +\n str(_value) )\n######\n\nExpected results would be:\nsome_dictionary_1 definition_1 = text_1\nsome_dictionary_1 definition_2 = text_2\nsome_dictionary_1 etc = etc.\nsome_other_dictionary_2 key_3 = value_3\nsome_other_dictionary_2 key_4 = value_4\nsome_other_dictionary_2 etc = etc.\n......\n......\n......\nsome_other_dictionary_n random_n = random_n\nsome_other_dictionary_n etc = etc.\n\nUnfortunately, get_indentifier_name_missing_function() would not see the 'original' identifier names (some_dictionary_,some_other_dictionary_2,some_other_dictionary_n). It would only see the a_dictionary_object identifier name.\nTherefore the real result would rather be:\na_dictionary_object definition_1 = text_1\na_dictionary_object definition_2 = text_2\na_dictionary_object etc = etc.\na_dictionary_object key_3 = value_3\na_dictionary_object key_4 = value_4\na_dictionary_object etc = etc.\n......\n......\n......\na_dictionary_object random_n = random_n\na_dictionary_object etc = etc.\n\nSo, the reverse of the eval() function won't be that useful in this case.\n\nCurrently, one would need to do this:\n# main2.py same as above, except:\n\n for each_one_of_my_dictionaries_names in ( 'some_dictionary_1',\n 'some_other_dictionary_2',\n '...',\n 'some_other_dictionary_n' ):\n some_module2.some_function( { each_one_of_my_dictionaries_names :\n eval(each_one_of_my_dictionaries_names) } )\n \n \n # some_module2.py\n def some_function(a_dictionary_name_object_container):\n for _dictionary_name, _dictionary_object in a_dictionary_name_object_container.items():\n for _key, _value in _dictionary_object.items():\n print( str(_dictionary_name) +\n \" \" +\n str(_key) +\n \" = \" +\n str(_value) )\n ######\n\n\nIn conclusion:\n\nPython passes only memory addresses as arguments to functions.\nStrings representing the name of an identifier, can only be referenced back to the actual identifier by the eval() function if the name identifier is available in the current namespace.\nA hypothetical reverse of the eval() function, would not be useful in cases where the identifier name is not 'seen' directly by the calling code. E.g. inside any called function.\nCurrently one needs to pass to a function:\n\nthe string representing the identifier name\nthe actual identifier (memory address)\n\n\n\nThis can be achieved by passing both the 'string' and eval('string') to the called function at the same time. I think this is the most 'general' way of solving this egg-chicken problem across arbitrary functions, modules, namespaces, without using corner-case solutions. The only downside is the use of the eval() function which may easily lead to unsecured code. Care must be taken to not feed the eval() function with just about anything, especially unfiltered external-input data.\n", "Totally possible with the python-varname package (python3):\nfrom varname import nameof\n\ns = 'Hey!'\n\nprint (nameof(s))\n\nOutput:\ns\n\nInstall:\npip3 install varname\n\nOr get the package here:\nhttps://github.com/pwwang/python-varname\n", "I searched for this question because I wanted a Python program to print assignment statements for some of the variables in the program. For example, it might print \"foo = 3, bar = 21, baz = 432\". The print function would need the variable names in string form. I could have provided my code with the strings \"foo\",\"bar\", and \"baz\", but that felt like repeating myself. After reading the previous answers, I developed the solution below.\nThe globals() function behaves like a dict with variable names (in the form of strings) as keys. I wanted to retrieve from globals() the key corresponding to the value of each variable. The method globals().items() returns a list of tuples; in each tuple the first item is the variable name (as a string) and the second is the variable value. My variablename() function searches through that list to find the variable name(s) that corresponds to the value of the variable whose name I need in string form.\nThe function itertools.ifilter() does the search by testing each tuple in the globals().items() list with the function lambda x: var is globals()[x[0]]. In that function x is the tuple being tested; x[0] is the variable name (as a string) and x[1] is the value. The lambda function tests whether the value of the tested variable is the same as the value of the variable passed to variablename(). In fact, by using the is operator, the lambda function tests whether the name of the tested variable is bound to the exact same object as the variable passed to variablename(). If so, the tuple passes the test and is returned by ifilter().\nThe itertools.ifilter() function actually returns an iterator which doesn't return any results until it is called properly. To get it called properly, I put it inside a list comprehension [tpl[0] for tpl ... globals().items())]. The list comprehension saves only the variable name tpl[0], ignoring the variable value. The list that is created contains one or more names (as strings) that are bound to the value of the variable passed to variablename().\nIn the uses of variablename() shown below, the desired string is returned as an element in a list. In many cases, it will be the only item in the list. If another variable name is assigned the same value, however, the list will be longer.\n>>> def variablename(var):\n... import itertools\n... return [tpl[0] for tpl in \n... itertools.ifilter(lambda x: var is x[1], globals().items())]\n... \n>>> var = {}\n>>> variablename(var)\n['var']\n>>> something_else = 3\n>>> variablename(something_else)\n['something_else']\n>>> yet_another = 3\n>>> variablename(something_else)\n['yet_another', 'something_else']\n\n", "as long as it's a variable and not a second class, this here works for me:\ndef print_var_name(variable):\n for name in globals():\n if eval(name) == variable:\n print name\nfoo = 123\nprint_var_name(foo)\n>>>foo\n\nthis happens for class members:\nclass xyz:\n def __init__(self):\n pass\nmember = xyz()\nprint_var_name(member)\n>>>member\n\nans this for classes (as example):\nabc = xyz\nprint_var_name(abc)\n>>>abc\n>>>xyz\n\nSo for classes it gives you the name AND the properteries\n", "This is not possible.\nIn Python, there really isn't any such thing as a \"variable\". What Python really has are \"names\" which can have objects bound to them. It makes no difference to the object what names, if any, it might be bound to. It might be bound to dozens of different names, or none.\nConsider this example:\nfoo = 1\nbar = 1\nbaz = 1\n\nNow, suppose you have the integer object with value 1, and you want to work backwards and find its name. What would you print? Three different names have that object bound to them, and all are equally valid.\nIn Python, a name is a way to access an object, so there is no way to work with names directly. There might be some clever way to hack the Python bytecodes or something to get the value of the name, but that is at best a parlor trick.\nIf you know you want print foo to print \"foo\", you might as well just execute print \"foo\" in the first place.\nEDIT: I have changed the wording slightly to make this more clear. Also, here is an even better example:\nfoo = 1\nbar = foo\nbaz = foo\n\nIn practice, Python reuses the same object for integers with common values like 0 or 1, so the first example should bind the same object to all three names. But this example is crystal clear: the same object is bound to foo, bar, and baz.\n", "Technically the information is available to you, but as others have asked, how would you make use of it in a sensible way?\n>>> x = 52\n>>> globals()\n{'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', \n'x': 52, '__doc__': None, '__package__': None}\n\nThis shows that the variable name is present as a string in the globals() dictionary.\n>>> globals().keys()[2]\n'x'\n\nIn this case it happens to be the third key, but there's no reliable way to know where a given variable name will end up\n>>> for k in globals().keys():\n... if not k.startswith(\"_\"):\n... print k\n...\nx\n>>>\n\nYou could filter out system variables like this, but you're still going to get all of your own items. Just running that code above created another variable \"k\" that changed the position of \"x\" in the dict.\nBut maybe this is a useful start for you. If you tell us what you want this capability for, more helpful information could possibly be given.\n", "By using the the unpacking operator:\n>>> def tostr(**kwargs):\n return kwargs\n\n>>> var = {}\n>>> something_else = 3\n>>> tostr(var = var,something_else=something_else)\n{'var' = {},'something_else'=3}\n\n", "You somehow have to refer to the variable you want to print the name of. So it would look like:\nprint varname(something_else)\n\nThere is no such function, but if there were it would be kind of pointless. You have to type out something_else, so you can as well just type quotes to the left and right of it to print the name as a string:\nprint \"something_else\"\n\n", "What are you trying to achieve? There is absolutely no reason to ever do what you describe, and there is likely a much better solution to the problem you're trying to solve..\nThe most obvious alternative to what you request is a dictionary. For example:\n>>> my_data = {'var': 'something'}\n>>> my_data['something_else'] = 'something'\n>>> print my_data.keys()\n['var', 'something_else']\n>>> print my_data['var']\nsomething\n\nMostly as a.. challenge, I implemented your desired output. Do not use this code, please!\n#!/usr/bin/env python2.6\nclass NewLocals:\n \"\"\"Please don't ever use this code..\"\"\"\n def __init__(self, initial_locals):\n self.prev_locals = list(initial_locals.keys())\n\n def show_new(self, new_locals):\n output = \", \".join(list(set(new_locals) - set(self.prev_locals)))\n self.prev_locals = list(new_locals.keys())\n return output\n# Set up\neww = None\neww = NewLocals(locals())\n\n# \"Working\" requested code\n\nvar = {}\n\nprint eww.show_new(locals()) # Outputs: var\n\nsomething_else = 3\nprint eww.show_new(locals()) # Outputs: something_else\n\n# Further testing\n\nanother_variable = 4\nand_a_final_one = 5\n\nprint eww.show_new(locals()) # Outputs: another_variable, and_a_final_one\n\n", "Does Django not do this when generating field names?\nhttp://docs.djangoproject.com/en/dev//topics/db/models/#verbose-field-names\nSeems reasonable to me.\n", "I think this is a cool solution and I suppose the best you can get. But do you see any way to handle the ambigious results, your function may return?\nAs \"is\" operator behaves unexpectedly with integers shows, low integers and strings of the same value get cached by python so that your variablename-function might priovide ambigous results with a high probability. \nIn my case, I would like to create a decorator, that adds a new variable to a class by the varialbename i pass it:\ndef inject(klass, dependency):\nklass.__dict__[\"__\"+variablename(dependency)]=dependency\n\nBut if your method returns ambigous results, how can I know the name of the variable I added?\nvar any_var=\"myvarcontent\"\nvar myvar=\"myvarcontent\"\n@inject(myvar)\nclass myclasss():\n def myclass_method(self):\n print self.__myvar #I can not be sure, that this variable will be set...\n\nMaybe if I will also check the local list I could at least remove the \"dependency\"-Variable from the list, but this will not be a reliable result.\n", "Here is a succinct variation that lets you specify any directory.\nThe issue with using directories to find anything is that multiple variables can have the same value. So this code returns a list of possible variables.\ndef varname( var, dir=locals()):\n return [ key for key, val in dir.items() if id( val) == id( var)]\n\n", "I don't know it's right or not, but it worked for me\ndef varname(variable):\n for name in list(globals().keys()):\n expression = f'id({name})'\n if id(variable) == eval(expression):\n return name\n\n", "it is possible to a limited extent. the answer is similar to the solution by @tamtam .\nThe given example assumes the following assumptions -\n\nYou are searching for a variable by its value\nThe variable has a distinct value\nThe value is in the global namespace\n\nExample:\ntestVar = \"unique value\"\nvarNameAsString = [k for k,v in globals().items() if v == \"unique value\"]\n#\n# the variable \"varNameAsString\" will contain all the variable name that matches\n# the value \"unique value\"\n# for this example, it will be a list of a single entry \"testVar\"\n#\nprint(varNameAsString)\n\nOutput : ['testVar']\nYou can extend this example for any other variable/data type\n", "I'd like to point out a use case for this that is not an anti-pattern, and there is no better way to do it.\nThis seems to be a missing feature in python.\nThere are a number of functions, like patch.object, that take the name of a method or property to be patched or accessed.\nConsider this:\npatch.object(obj, \"method_name\", new_reg)\nThis can potentially start \"false succeeding\" when you change the name of a method. IE: you can ship a bug, you thought you were testing.... simply because of a bad method name refactor.\nNow consider: varname. This could be an efficient, built-in function. But for now it can work by iterating an object or the caller's frame:\nNow your call can be:\npatch.member(obj, obj.method_name, new_reg)\nAnd the patch function can call:\nvarname(var, obj=obj)\nThis would: assert that the var is bound to the obj and return the name of the member. Or if the obj is not specified, use the callers stack frame to derive it, etc.\nCould be made an efficient built in at some point, but here's a definition that works. I deliberately didn't support builtins, easy to add tho:\nFeel free to stick this in a package called varname.py, and use it in your patch.object calls:\npatch.object(obj, varname(obj, obj.method_name), new_reg)\nNote: this was written for python 3.\nimport inspect\n\ndef _varname_dict(var, dct):\n key_name = None\n for key, val in dct.items():\n if val is var:\n if key_name is not None:\n raise NotImplementedError(\"Duplicate names not supported %s, %s\" % (key_name, key))\n key_name = key\n return key_name\n\ndef _varname_obj(var, obj):\n key_name = None\n for key in dir(obj):\n val = getattr(obj, key)\n equal = val is var\n if equal:\n if key_name is not None:\n raise NotImplementedError(\"Duplicate names not supported %s, %s\" % (key_name, key))\n key_name = key\n return key_name\n\ndef varname(var, obj=None):\n if obj is None:\n if hasattr(var, \"__self__\"):\n return var.__name__\n caller_frame = inspect.currentframe().f_back\n try:\n ret = _varname_dict(var, caller_frame.f_locals)\n except NameError:\n ret = _varname_dict(var, caller_frame.f_globals)\n else:\n ret = _varname_obj(var, obj)\n if ret is None:\n raise NameError(\"Name not found. (Note: builtins not supported)\")\n return ret\n\n", "This will work for simnple data types (str, int, float, list etc.)\n\n>>> def my_print(var_str) : \n print var_str+':', globals()[var_str]\n>>> a = 5\n>>> b = ['hello', ',world!']\n>>> my_print('a')\na: 5\n>>> my_print('b')\nb: ['hello', ',world!']\n\n", "It's not very Pythonesque but I was curious and found this solution. You need to duplicate the globals dictionary since its size will change as soon as you define a new variable.\ndef var_to_name(var):\n # noinspection PyTypeChecker\n dict_vars = dict(globals().items())\n\n var_string = None\n\n for name in dict_vars.keys():\n if dict_vars[name] is var:\n var_string = name\n break\n\n return var_string\n\n\nif __name__ == \"__main__\":\n test = 3\n print(f\"test = {test}\")\n print(f\"variable name: {var_to_name(test)}\")\n\nwhich returns:\ntest = 3\nvariable name: test\n\n", "To get the variable name of var as a string:\nvar = 1000\nvar_name = [k for k,v in locals().items() if v == var][0] \nprint(var_name) # ---> outputs 'var'\n\n", "Thanks @restrepo, this was exactly what I needed to create a standard save_df_to_file() function. For this, I made some small changes to your tostr() function. Hope this will help someone else:\ndef variabletostr(**df):\n variablename = list(df.keys())[0]\n return variablename\n \n variabletostr(df=0)\n\n", "The original question is pretty old, but I found an almost solution with Python 3. (I say almost because I think you can get close to a solution but I do not believe there is a solution concrete enough to satisfy the exact request).\nFirst, you might want to consider the following:\n\nobjects are a core concept in Python, and they may be assigned a variable, but the variable itself is a bound name (think pointer or reference) not the object itself\nvar is just a variable name bound to an object and that object could have more than one reference (in your example it does not seem to)\nin this case, var appears to be in the global namespace so you can use the global builtin conveniently named global\ndifferent name references to the same object will all share the same id which can be checked by running the id builtin id like so: id(var)\n\nThis function grabs the global variables and filters out the ones matching the content of your variable.\ndef get_bound_names(target_variable):\n '''Returns a list of bound object names.'''\n return [k for k, v in globals().items() if v is target_variable]\n\nThe real challenge here is that you are not guaranteed to get back the variable name by itself. It will be a list, but that list will contain the variable name you are looking for. If your target variable (bound to an object) is really the only bound name, you could access it this way:\nbound_names = get_variable_names(target_variable)\nvar_string = bound_names[0]\n\n", "Possible for Python >= 3.8 (with f'{var=}' string )\nNot sure if this could be used in production code, but in Python 3.8(and up) you can use f' string debugging specifier. Add = at the end of an expression, and it will print both the expression and its value:\nmy_salary_variable = 5000\nprint(f'{my_salary_variable = }')\n\nOutput:\nmy_salary_variable = 5000\n\nTo uncover this magic here is another example:\nparam_list = f'{my_salary_variable=}'.split('=')\nprint(param_list)\n\nOutput:\n['my_salary_variable', '5000']\n\nExplanation: when you put '=' after your var in f'string, it returns a string with variable name, '=' and its value. Split it with .split('=') and get a List of 2 strings, [0] - your_variable_name, and [1] - actual object of variable.\nPick up [0] element of the list if you need variable name only.\nmy_salary_variable = 5000\nparam_list = f'{my_salary_variable=}'.split('=')\nprint(param_list[0])\nOutput:\nmy_salary_variable\n\nor, in one line\n\nmy_salary_variable = 5000\nprint(f'{my_salary_variable=}'.split('=')[0])\nOutput:\nmy_salary_variable\n\nWorks with functions too:\ndef my_super_calc_foo(number):\n return number**3\n\nprint(f'{my_super_calc_foo(5) = }')\nprint(f'{my_super_calc_foo(5)=}'.split('='))\n\nOutput:\nmy_super_calc_foo(5) = 125\n['my_super_calc_foo(5)', '125']\n\nProcess finished with exit code 0\n\n" ]

[ 62, 41, 14, 12, 7, 6, 3, 2, 2, 2, 2, 2, 2, 2, 1, 0, 0, 0, 0, 0, 0 ]

[ "This module works for converting variables names to a string:\nhttps://pypi.org/project/varname/\nUse it like this:\nfrom varname import nameof\n\nvariable=0\n\nname=nameof(variable)\n\nprint(name)\n\n//output: variable\n\nInstall it by:\npip install varname\n\n", "print \"var\"\nprint \"something_else\"\n\nOr did you mean something_else?\n" ]

[ -1, -3 ]

[ "python", "string", "variables" ]

[ "The policy you have shown appears to be a Bucket Policy that is assigned to a specific bucket. This policy is granting anyone in the world permission to use your S3 bucket, so it is not recommended from a security viewpoint. You should remove this bucket policy.\nYou have mentioned that the provided code is running on \"localhost\" -- I will presume this means you are running it on your own computer.\nIn order to make API calls to AWS from that code, you will need to provide AWS credentials. Typically, these credentials are stored in the ~/.aws/credentials file by running the AWS CLI aws configure command. You would need to provide an Access Key and Secret Key associated with an IAM User (via the Security Credentials tab in the IAM management console).\nYou would then need to assign permissions to the IAM User so that they can use the S3 bucket. Note that the permissions are given to the IAM User, not the bucket:\n{\n \"Version\": \"2012-10-17\",\n \"Statement\": [\n {\n \"Sid\": \"AllowPublicRead\",\n \"Effect\": \"Allow\",\n \"Action\": [\n \"s3:GetObject\",\n \"s3:GetObjectAcl\",\n \"s3:PutObject\",\n \"s3:PutObjectAcl\",\n \"s3:DeleteObject\"\n ],\n \"Resource\": \"arn:aws:s3:::my-bucket/*\"\n }\n ]\n}\n\nThe difference here is that there is no Principal because it is directly attached to the IAM User.\n" ]

[ 0 ]

[]

[]

[ "amazon_s3", "amazon_web_services", "boto3", "python" ]

[ "You might want something like:\nchosen_level = 'easy'\ngame_data = dict(zip(creature[chosen_level], attack[chosen_level]))\n\nimport random\ncre = random.choice(list(game_data))\natt = game_data[cre]\n\nprint(cre, att) \n\nOutput: rat scratches\n" ]

[ 2 ]

[]

[]

[ "dictionary", "keyerror", "python" ]

[ "The problem is you are assigning same list to all keys.\na = {}\nb=[] # < --- You create one Array/list 'b'\nfor _, contents in tr.items():\n b.clear()\n for ind, val in enumerate(contents):\n if np.isnan(val):\n b.append(ind)\n continue\n else:\n pass\n print(_)\n print(b)\n a[_] = b # <-- assign same array to all keys.\n print(a)\n\nCheck my comment on the code above.\nb.clear()\n\nThis line just clears the same array, it does not create a new array.\nTo run the code as you intended, create a new array/list in side the loop.\na = {}\nfor _, contents in tr.items():\n b = [] # <--- new array/list is created\n for ind, val in enumerate(contents):\n if np.isnan(val):\n b.append(ind)\n continue\n else:\n pass\n print(_)\n print(b)\n a[_] = b # <--- Now you assign the new array 'b' to a[_]\n print(a)\n\n", "With the correct name convention, I would change your code\nafter:\nimport numpy as np\nimport pandas as pd\n\nimport sys\nif sys.version_info[0] < 3:\n from StringIO import StringIO\nelse:\n from io import StringIO\n\ns = StringIO(\"\"\"idx 7128 8719 14051 14636\nJDUTC_0 2451957.36 2452149.36 2457243.98 2452531.89\nJDUTC_1 2451957.37 2452149.36 2457243.99 2452531.90\nJDUTC_2 2451957.37 2452149.36 2457244.00 2452531.91\nJDUTC_3 NaN 2452149.36 NaN NaN\nJDUTC_4 NaN 2452149.36 NaN NaN\nJDUTC_5 NaN 2452149.36 NaN NaN\nJDUTC_6 1.23 2452149.37 NaN NaN\nJDUTC_7 NaN NaN NaN NaN\nJDUTC_8 NaN NaN NaN NaN\nJDUTC_9 NaN NaN NaN NaN\"\"\")\n\ntr = pd.read_csv(s, sep=\"\\t\", index_col=0)\n\n(people should give minimal working code - but often forget to give e.g. the code to build the data frame etc. and the imports)\nto:\n\n\na = {}\nb = []\nfor name, values in tr.items():\n b.clear() # this is problematic as you know\n for ind, val in enumerate(values):\n if np.isnan(val):\n b.append(ind)\n continue\n else:\n pass\n a[name] = b\n\ncontinue and pass are not necessary - they just say \"go on\" with the loop.\nIn Python, you are not forced to give the else branch:\nfor name, values in tr.items():\n b.clear() # This is still problematic at this state.\n for ind, val in enumerate(values):\n if np.isnan(val):\n b.append(ind)\n a[name] = b\n\nSuch collection of data using for-loops are better done with list-comprehensions:\na = {}\nfor name, values in tr.items():\n b = [ind for ind, val in enumerate(values) if np.isnan(val)]\n a[name] = b\n# now the result is already correct!\n\nAnd finally, you can even build list-comprehensions for dictionaries -\nmaking this entire code a one-liner - but a readable one - when one is familiar with list comprehensions:\na = {name: [i for i, x in enumerate(vals) if np.isnan(x)] for name, vals in tr.items()}\n\nYou can see the result:\na\n# which returns:\n{'7128': [3, 4, 5, 7, 8, 9],\n '8719': [7, 8, 9],\n '14051': [3, 4, 5, 6, 7, 8, 9],\n '14636': [3, 4, 5, 6, 7, 8, 9]}\n\nList-comprehensions are going into the direction of Functional Programming (FP).\nWhich exactly deals with the problem of not to apply mutation (like the b.append() or b.clear() methods - because - as you have seen: your case is a demonstration of how easily a bug is generated when using mutation. - and would contribute to the discussion - why FP - while it at the first sight looks brain-unfriendly - is\nactually the more brain-friendly way to program.\nList comprehensions are the Pythonic form of \"map\" - and if you use a \"if\" inside list comprehensions - this is the Pythonic equivalent to \"filter\" which FP people know like a second brain for breathing.\n" ]

[ 1, 1 ]

[]

[]

[ "dictionary", "for_loop", "python" ]

[ "The tool can have an attribute image, which denotes the path to a png image.\nimport matplotlib\nmatplotlib.rcParams[\"toolbar\"] = \"toolmanager\"\nimport matplotlib.pyplot as plt\nfrom matplotlib.backend_tools import ToolBase\n\nclass NewTool(ToolBase):\n image = r\"C:\\path\\to\\hiker.png\"\n\nfig = plt.figure()\nax = fig.add_subplot(111)\nax.plot([1, 2, 3], label=\"legend\")\nax.legend()\ntm = fig.canvas.manager.toolmanager\ntm.add_tool(\"newtool\", NewTool)\nfig.canvas.manager.toolbar.add_tool(tm.get_tool(\"newtool\"), \"toolgroup\")\nplt.show()\n\n\n", "\nI tried this solution, there is also a similar solution on matplotlib docs, but I >cannot reproduce it. I get the following error: tm.add_tool(\"newtool\", NewTool) >AttributeError: 'NoneType' object has no attribute 'add_tool' Seems weird that >plt.figure() does not contain canvas. Any ideas? –\nbad_locality\nJun 25, 2020 at 12:12\n\nI do not know if it's help, but I had the same issues at first and then i realized that I had not activated the interactive matplotlib option (%matplotlib with Python - spyder). Therefore no toolbar are associated since it only create a static figure.\n" ]

[ 7, 0 ]

[]

[]

[ "matplotlib", "python" ]

[ "To create a contour plot from your 1D arrays of x, y, and z coordinates, you can use NumPy's meshgrid function to create 2D grids from your 1D arrays, and then use the contour function from Matplotlib to create the contour plot.\nFirst, you need to create 2D grids from your 1D arrays of x and y coordinates using NumPy's meshgrid function. You can do this by calling np.meshgrid(x, y), where x and y are your 1D arrays of x and y coordinates, respectively. This will return two 2D grids, one for the x coordinates and one for the y coordinates.\nNext, you can use the contour function from Matplotlib to create the contour plot. You can do this by calling ax.contour(x, y, z), where ax is the axes object that you want to draw the contour plot on, x and y are the 2D grids of x and y coordinates that you created using meshgrid, and z is your 1D array of z coordinates. This will create a contour plot with x and y coordinates on the x- and y-axes, respectively, and z values as the contour levels.\nOne thing to keep in mind is that if you have any inf values in your z array, they will cause the contour function to throw an error. In this case, you will need to remove the inf values from your z array before creating the contour plot. You can do this by using NumPy's isinf function to find the indices of the inf values in your z array, and then use these indices to select only the non-inf values from your z array.\nHere is an example of how you can use these steps to create a contour plot from your 1D arrays of x, y, and z coordinates:\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# 1D arrays of x, y, and z coordinates\nx = ...\ny = ...\nz = ...\n\n# Create 2D grids of x and y coordinates\nX, Y = np.meshgrid(x, y)\n\n# Remove inf values from z array\nz_noninf = z[~np.isinf(z)]\n\n# Create figure and axes object\nfig, ax = plt.subplots()\n\n# Create contour plot\nax.contour(X, Y, z_noninf)\n\n# Add x and y labels\nax.set_xlabel('x')\nax.set_ylabel('y')\n\n# Show the plot\nplt.show()\n\nI hope this helps!\n" ]

[ 0 ]

[]

[]

[ "contour", "matplotlib", "python" ]

[ "os.makedirs has a switch to create a folder if it does not exist.\nuse it like this:\nos.makedirs(foldern_name, exist_ok=True)\n\nso just replace that try...except part of code which is this:\n\ntry:\n\n [os.makedirs(e) for e in ext_final]\n\nexcept:\n\n print(\"Folder already exists!\")\n\nwith this:\nfor e in ext_final:\n os.makedirs(e, exist_os=True)\n\n", "I tried my own approach ... It is kind of ugly but it gets the job done.\n\nimport os\nimport shutil\n\n\n\ndef sort_folder(fpath: str) -> None:\n\n dirs = []\n files = []\n filetypes = []\n\n for item in os.listdir(fpath):\n if os.path.isfile(f\"{fpath}\\{item}\"):\n files.append(item)\n else:\n dirs.append(item)\n\n for file in files:\n filetype = os.path.splitext(file)[1]\n filetypes.append(filetype)\n\n for filetype in set(filetypes):\n if not os.path.isdir(f\"{fpath}\\{filetype}\"):\n os.mkdir(f\"{fpath}\\{filetype}\")\n\n for (file, filetype) in zip(files, filetypes):\n shutil.move(f\"{fpath}\\{file}\", f\"{fpath}\\{filetype}\")\n\n\n\nif __name__ == '__main__':\n# running the script\n\n sort_folder(fpath)\n\n", "There are a few issues with your code that are preventing it from working as expected. Here are a few suggestions to help you fix the problems:\n\nYou are using the scandir function to iterate over the files and directories in the basepath directory, but you are not using the entries returned by this function. Instead, you are using the os.listdir function to get a list of all the files in the directory. This means that your code is not processing the entries returned by the scandir function, and it is not checking if the entries are files or directories.\n\nYou are creating a list of file extensions using the files list, but this list contains both files and directories, so the resulting list of extensions will not be accurate. Instead, you should use the entry.name property of the entries returned by the scandir function to get the names of the files and directories, and then you can split the names to get the file extensions.\n\nYou are using the try and except statements to catch any errors that might occur when creating the directories for the file extensions. However, the try and except statements are not being used correctly. The try statement should be used to run the code that might throw an error, and the except statement should be used to handle the error if it occurs. In your code, the try and except statements are not being used to handle any errors, so they are not doing anything.\nHere is a modified version of your code that fixes these problems and should work as expected:\nimport os\nimport shutil\nbasepath = r\"C:\\Users\\me\\Downloads\\test\"\nfor entry in scandir(basepath):\nif entry.is_file():\nfile_ext = entry.name.rsplit(\".\")[1]\nif not os.path.exists(file_ext):\nos.makedirs(file_ext)\nshutil.move(entry.path, file_ext)\n\n\nThis code uses the scandir function to iterate over the entries in the basepath directory, and it only processes the entries that are files (not directories). For each file, it gets the file extension from the file name, and it creates a directory with the same name as the file extension if it does not already exist. Then, it moves the file to the directory using the shutil.move function.\n" ]

[ 0, 0, 0 ]

[]

[]

[ "operating_system", "python", "shutil" ]

[ "You can use look-ahead to test one of the conditions, like the total length of the input. The other conditions can be expressed close to what you proposed, but with double digits (\\d\\d) and end-of-input anchors (^ and $)\n^(?=\\w{18}$)[A-Za-z]+\\d\\d[A-Za-z]+\\d\\d[A-Za-z]+$\n\n" ]

[ 0 ]

[]

[]

[ "digits", "letter", "python", "regex", "uppercase" ]

[ "t looks like you are trying to use the np.where function to find the index of a column in the X DataFrame by its name. However, the np.where function does not work like this - it returns the indices of elements in an array that match a specified condition.\nTo get the index of a column in a DataFrame by its name, you can use the DataFrame.columns.get_loc method instead. For example:\nanaemia_index = X.columns.get_loc(anaemia)\n\nThis will return the index of the anaemia column in the X DataFrame. You can then use this index to access the corresponding column in the x array.\nYou can also simplify your code by using the DataFrame.loc method to select the columns you want in the x array, rather than creating the x array manually and setting the values of its elements one by one. For example:\nx = X.loc[:, [\"high_blood_pressure\", \"serum_creatinine\", \"serum_sodium\", \"smoking\", anaemia]].values\n\nThis will create the x array by selecting the columns you want from the X DataFrame, and then converting the DataFrame to a NumPy array using the DataFrame.values attribute. You can then pass this array directly to the mode.predict method to get the predicted death outcome.\nHere is an example of how your predict_death function could be implemented using these changes:\ndef predict_death(anaemia, high_blood_pressure, serum_creatinine, serum_sodium, smoking):\n x = X.loc[:, [\"high_blood_pressure\", \"serum_creatinine\", \"serum_sodium\", \"smoking\", anaemia]].values\n return mode.predict([x])[0]\n\ndeath = predict_death(\"anaemia_yes\", 1, 1.9, 137, 1)\n\nNote that in this example, the anaemia argument to the predict_death function should be the name of the column in the X DataFrame that corresponds to the presence or absence of anaemia (e.g. \"anaemia_yes\" or \"anaemia_no\").\n" ]

[ 0 ]

[]

[]

[ "deep_learning", "for_loop", "function", "machine_learning", "python" ]

[ "As noted in the comments to the question, your second example is not directly comparable to your first example because your second example is missing the .all() at the end.\nSide note:\nsession.scalars(select(Subnet).order_by(Subnet.id)).all()\n\nis a convenient shorthand for\nsession.execute(select(Subnet).order_by(Subnet.id)).scalars().all()\n\nand is the recommended approach for SQLAlchemy 1.4+.\n" ]

[ 1 ]

[]

[]

[ "python", "sqlalchemy" ]

[ "It looks like you're trying to filter your DataFrame to get the first two rows for each unique value of the product_category column. One way to do this is to use the DataFrame.groupby method, which allows you to group your data by a particular column and then apply a function to each group.\nIn your case, you can group your data by the product_category column and then apply the DataFrame.head method to each group to get the first two rows of each group. Here is an example of how you could do this:\n# Group the data by the 'product_category' column\ngroups = dfDogNew.groupby(\"product_category\")\n\n# Apply the head method to each group to get the first two rows\nfinaldf = groups.head(2)\n\nThe finaldf DataFrame that is returned will contain the first two rows for each unique value of the product_category column in your original DataFrame. Note that this approach does not require a for loop, and is generally more efficient than looping over the rows of your DataFrame.\nIf you only want to include rows from your original DataFrame that have a product_category value that is present in the product_category array, you can filter your DataFrame using the DataFrame.isin method before grouping it. For example:\n# Filter the DataFrame to include only rows with a 'product_category'\n# value that is present in the 'product_category' array\ndfDogNew = dfDogNew[dfDogNew[\"product_category\"].isin(product_category)]\n\n# Group the data by the 'product_category' column\ngroups = dfDogNew.groupby(\"product_category\")\n\n# Apply the head method to each group to get the first two rows\nfinaldf = groups.head(2)\n\nThis will include only rows in the dfDogNew DataFrame that have a product_category value that is present in the product_category array, and then group and filter the data as described above.\nNote that when using the DataFrame.head method, if there are fewer than two rows in a group, the resulting DataFrame will only include the available rows. So, if a product_category value only has one row in your original DataFrame, the resulting finaldf DataFrame will only include that one row for that category. You do not need to worry about handling this case separately.\n" ]

[ 1 ]

[]

[]

[ "numpy_slicing", "pandas", "python" ]

[ "You have to add the lines read from the file to a list (see How to read a file line-by-line into a list?):\nlist_of_lines = []\nwith open('file.txt') as file:\n list_of_lines = [line.rstrip() for line in file]\n\nAfter that you can render the text lines from the list:\nfont = pygame.font.SysFont('impact', 30)\nmsg_list = []\nfor line in list_of_lines:\n msg = font.render(line, True, yellow)\n msg_list.append(msg)\n\n\nComplete example:\n\nimport pygame\nfrom pygame.locals import *\n\npygame.init()\nscreen=pygame.display.set_mode([800,600])\nclock = pygame.time.Clock()\n\nred = (255,0,0)\nyellow = (255, 191, 0)\n\nlist_of_lines = []\nwith open('file.txt') as file:\n list_of_lines = [line.rstrip() for line in file]\nfile.close()\n\nfont = pygame.font.SysFont('impact', 30)\nmsg_list = []\nfor line in list_of_lines:\n msg = font.render(line, True, yellow)\n msg_list.append(msg)\n\ncenterx, centery = screen.get_rect().centerx, screen.get_rect().centery\ndeltaY = centery + 50 # adjust so it goes below screen start\n\nrunning =True\nwhile running:\n clock.tick(100)\n for event in pygame.event.get():\n if event.type == QUIT:\n running = False\n\n screen.fill(0)\n \n deltaY -= 1\n for i, msg in enumerate(msg_list):\n pos = msg.get_rect(center=(centerx, centery + deltaY + 30 * i))\n screen.blit(msg, pos)\n \n pygame.display.update()\n\npygame.quit()\n\n" ]

[ 0 ]

[]

[]

[ "pygame", "python" ]

[ "You don't need the math module. Use just numpy functions:\nimport numpy as np\n\n\ndef normpdf(x, avg=0, std=1):\n exp = np.exp(-0.5 * ((x - avg) / std) ** 2)\n pdf = (1 / (std * np.sqrt(2 * np.pi)) * exp)\n return pdf\n\n\nx = np.linspace(1, 50)\n\nprint(normpdf(x))\n\nThe code above will result in:\n[2.41970725e-001 5.39909665e-002 4.43184841e-003 1.33830226e-004\n 1.48671951e-006 6.07588285e-009 9.13472041e-012 5.05227108e-015\n 1.02797736e-018 7.69459863e-023 2.11881925e-027 2.14638374e-032\n 7.99882776e-038 1.09660656e-043 5.53070955e-050 1.02616307e-056\n 7.00418213e-064 1.75874954e-071 1.62463604e-079 5.52094836e-088\n 6.90202942e-097 3.17428155e-106 5.37056037e-116 3.34271444e-126\n 7.65392974e-137 6.44725997e-148 1.99788926e-159 2.27757748e-171\n 9.55169454e-184 1.47364613e-196 8.36395161e-210 1.74636626e-223\n 1.34141967e-237 3.79052640e-252 3.94039628e-267 1.50690472e-282\n 2.12000655e-298 1.09722105e-314 0.00000000e+000 0.00000000e+000\n 0.00000000e+000 0.00000000e+000 0.00000000e+000 0.00000000e+000\n 0.00000000e+000 0.00000000e+000 0.00000000e+000 0.00000000e+000\n 0.00000000e+000 0.00000000e+000]\n\n", "Your implementation of the normal probability density function is almost correct. The issue you're encountering is that you're trying to evaluate the function for an array of values, but the math operations you're using only work with scalar values (single numbers).\nTo fix this, you can either evaluate the function for each value in the array separately, or you can use numpy functions that can operate on arrays. Here's an example of how you could do this using numpy:\nimport numpy as np\n\ndef normpdf(x, avg=0, std=1):\n # Compute the exponent\n exponent = np.exp(-0.5 * ((x - avg) / std) ** 2)\n\n # Compute the normalization constant\n const = 1 / (std * np.sqrt(2 * np.pi))\n\n # Compute the normal probability density function\n pdf = const * exponent\n\n return pdf\n\n# Set x values\nx = np.linspace(1, 50)\n\n# Compute the probability density function for the given values of x\npdf = normpdf(x, avg, std)\n\n# Print the result\nprint(pdf)\n\nNote that in this example I used numpy functions for the exponent and square root, which allows the function to operate on arrays of values instead of just scalars. I also used a numpy array for the x values, which means that the function will return an array of probabilities, one for each value of x.\n", "You are trying to calculate the normal probability density function of an array of values, but the math.exp() function expects a scalar value as input. To solve this issue, you can use the np.exp() function from the NumPy library, which can handle arrays as input and will apply the exponent calculation element-wise.\nimport numpy as np\n\ndef normpdf(x, avg=0, std=1):\n # normal distribution eq\n exponent = np.exp(-0.5 * ((x - avg) / std) ** 2)\n pdf = (1 / (std * np.sqrt(2 * np.pi)) * exponent)\n return pdf\n\n# set x values\nx = np.linspace(1, 50)\n\nnormpdf(x)\n\nI replaced the math.exp() and math.sqrt() functions with their NumPy equivalents, np.exp() and np.sqrt(). These functions can handle arrays as input and will return an array of results.\n" ]

[ 2, 1, 0 ]

[]

[]

[ "gaussian", "normal_distribution", "python" ]

[ "To take into account overtime versus regular rates of pay it seems like you will need to know how much time the employee worked in each category. With that in mind, here is a simplified example to illustrate some of the key concepts.\nExample:\ndef computepay(hours, rate):\n return hours * rate\n\nregular_rate = float(input(\"Hourly rate in dollars: \"))\nregular_hours = float(input(\"Regular hours worked: \"))\novertime_hours = float(input(\"Overtime hours worked: \"))\n\nregular_pay = computepay(regular_hours, regular_rate)\novertime_pay = computepay(overtime_hours, regular_rate * 1.5)\ntotal_pay = regular_pay + overtime_pay\n\nprint(f\"This pay period you earned: ${total_pay:.2f}\")\n\nOutput:\nHourly rate in dollars: 15.00\nRegular hours worked: 40\nOvertime hours worked: 10\nThis pay period you earned: $825.00\n\n", "My teacher told me to solve it in one function, computerpay . so try this .\ndef computepay(hours, rate):\nif hours > 40:\n reg = rate * hours\n otp = (hours - 40.0) * (rate * 0.5)\n pay = reg + otp\nelse:\n pay = hours * rate \nreturn pay\n\nThen The input Output Part\nsh = input(\"enter Hours:\")\nsr = input(\" Enter rate:\")\nfh = float(sh)\nfr = float(sr)\nxp = computepay(fh,fr)\nprint(\"Pay:\",xp)\n\n", "def computepay(hours, rate) :\n return hours * rate\ndef invalid_input() :\n print(\"Input Numeric Value\")\nwhile True :\n try :\n regular_rate = float(input(\"Hourly rate in dollars: \"))\n break\n except :\n invalid_input()\n continue\nwhile True :\n try :\n regular_hours = float(input(\"Regular Hours Worked: \"))\n break\n except :\n invalid_input()\n continue\nwhile True :\n try :\n overtime_hours = float(input(\"Overtime hours worked :\"))\n break\n except :\n invalid_input()\n continue\novertime_rate = regular_rate * 1.5\n\nregular_pay = computepay(regular_hours, regular_rate)\novertime_pay = computepay(overtime_hours, overtime_rate)\ntotal_pay = regular_pay + overtime_pay\n\nprint(\"PAY : \", total_pay)\n\n", "hour = float(input('Enter hours: '))\nrate = float(input('Enter rates: '))\ndef compute_pay(hours, rates):\nif hours <= 40:\n print(hours * rates)\nelif hours > 40:\n print(((hours * rate) - 40 * rate) * 1.5 + 40 * rate)\n\ncompute_pay(hour, rate )\n", "hour = float(input('Enter hours: '))\nrate = float(input('Enter rates: '))\ndef compute_pay(hours, rates):\nif hours <= 40:\n pay = hours * rates\n return pay\nelif hours > 40:\n pay = ((hours * rate) - 40 * rate) * 1.5 + 40 * rate\n return pay\n\npay = compute_pay(hour, rate)\nprint(pay)\n" ]

[ 0, 0, 0, 0, 0 ]

[]

[]

[ "function", "parameters", "python" ]

[ "SpesificWord = input() #get the specific word\nwith open('file.txt','r',encoding='utf-8') as file: #open the file\n for index, line in enumerate(file): #index is current no of file, line is current line\n print(len(line)) # prints the length of line - including space etc.\n print(f'Current Line: {index+1}) #prints current line\n if SpesificWord in line:\n print(f'Spesific word is in line {index+1})\n\n" ]

[ 0 ]

[]

[]

[ "filehandler", "python" ]

[ "The error IndexError: list index out of range is raised when you try to access an index in a list that doesn't exist. For example, if you try to access the 10th element of a list that only has 3 elements, you will get this error.\nIn your code, you are trying to access the elements in temp using the indices [0], [1], [2], and [3], but it looks like temp might not have enough elements for that.\nTo avoid this error, you should first check that temp has enough elements before trying to access them. You can do this using an if statement and the len() function, like this:\nif len(temp) >= 4:\n students_dict[temp[0]] = [temp[1], temp[2], temp[3]]\n\nAlternatively, you can use the get() method to safely access elements in temp, like this:\nstudents_dict[temp[0]] = [temp.get(1), temp.get(2), temp.get(3)]\n\nThis will set the elements in the list to None if they don't exist in temp, rather than raising an error.\nI hope this helps! Let me know if you have any other questions.\n" ]

[ 1 ]

[]

[]

[ "index_error", "python" ]

[ "The following code might give you some ideas. If it doesn't meet your needs then you need to clearly explain just what those needs are.\ndef contrast(nums):\n contrasted = []\n for num in nums:\n if num < 50:\n contrasted.append(num//2)\n elif num > 50:\n contrasted.append((num + 100)//2)\n else:\n contrasted.append(num)\n return contrasted\n\ndata = [0, 23, 50,58,100]\nprint(contrast(data))\n\nOutput: [0, 11, 50, 79, 100]\n" ]

[ 1 ]

[]

[]

[ "math", "python" ]

[ "table[\"amount\"] = 0 if table[\"period\"] < table[\"update\"] else None\n\n", "I did some more research and this code seems to solve my problem:\ndef check_update(row):\n if row[\"period\"] < row[\"update\"]:\n return 0\n else:\n return row[\"amount\"]\n\ntable[\"amount2\"] = table.apply(check_update, axis=1)\n\n" ]

[ 0, 0 ]

[]

[]

[ "pandas", "python" ]

[ "To adjust a subset of a column in a pandas dataframe, you can use the loc method. The loc method allows you to access a subset of the dataframe by specifying the values in the rows and columns that you want. In your case, you want to adjust the values in the ht column where the age column is equal to one. You can do this with the following code:\ndf.loc[df['age'] == 'one', 'ht'] = df[df['age'] == 'one']['ht'] * 10**6\n\nThe first argument to the loc method is a condition that specifies the rows that you want to select. In this case, the condition is df['age'] == 'one', which selects all rows where the value in the age column is one. The second argument specifies the column or columns that you want to adjust. In this case, we want to adjust the ht column, so the second argument is 'ht'. Finally, the right-hand side of the assignment operator sets the new values for the selected rows and columns. In this case, the right-hand side is df[df['age'] == 'one']['ht'] * 10**6, which multiplies the values in the ht column for rows where the age column is one by 10^6.\nAfter running this code, the values in the ht column where the age column is one will be adjusted as desired. Here's an example of how you could use this code in your case:\nimport pandas as pd\n\ndf = pd.DataFrame({\n 'famid': [1, 1, 1, 2, 2, 2, 3, 3, 3],\n 'birth': [1, 2, 3, 1, 2, 3, 1, 2, 3],\n 'ht_one': [2.8, 2.9, 2.2, 2, 1.8, 1.9, 2.2, 2.3, 2.1],\n 'ht_two': [3.4, 3.8, 2.9, 3.2, 2.8, 2.4, 3.3, 3.4, 2.9]\n})\ndf = pd.wide_to_long(df, stubnames='ht', i=['famid', 'birth'], j='age',\n sep='_', suffix=r'\\w+')\ndf.reset_index(inplace = True)\n\n# Adjust the values in the ht column where the age column is 'one'\ndf.loc[df['age'] == 'one', 'ht'] = df[df['age'] == 'one']['ht'] * 10**6\n\n# Print the updated dataframe\nprint(df)\n\nAfter running this code, the dataframe will have the adjusted values in the ht column where the age column is one.\n", "Let's try this:\ndf.loc[df['age'] == 'one', 'ht'] *= 10**6\n\nOutput:\n famid birth age ht\n0 1 1 one 2800000.0\n1 1 1 two 3.4\n2 1 2 one 2900000.0\n3 1 2 two 3.8\n4 1 3 one 2200000.0\n5 1 3 two 2.9\n6 2 1 one 2000000.0\n7 2 1 two 3.2\n8 2 2 one 1800000.0\n9 2 2 two 2.8\n10 2 3 one 1900000.0\n11 2 3 two 2.4\n12 3 1 one 2200000.0\n13 3 1 two 3.3\n14 3 2 one 2300000.0\n15 3 2 two 3.4\n16 3 3 one 2100000.0\n17 3 3 two 2.9\n\n", "To perform calculations on a subset of a column in a pandas dataframe, you can use the .loc method to select the subset of the dataframe and then apply the calculation to that subset. For example, to multiply the ht values for rows where age is equal to one by 10^6, you could use the following code:\ndf.loc[df['age']=='one', 'ht'] = df.loc[df['age']=='one', 'ht'] * 10**6\n\nThis code selects the subset of rows where age is one using df.loc[df['age']=='one'], and then applies the multiplication operation to the ht column in that subset using df.loc[df['age']=='one', 'ht'] * 10**6.\nYou can also use the .loc method to perform calculations on multiple columns in the subset. For example, if you wanted to multiply the ht values by 10^6 and then add 1000 to the birth values for rows where age is one, you could use the following code:\ndf.loc[df['age']=='one', ['ht', 'birth']] = df.loc[df['age']=='one', ['ht', 'birth']]\n\n", "To adjust values in a subset of a DataFrame, you can use the loc method and select the rows you want to adjust using a boolean mask. The syntax for modifying values using loc is as follows:\ndf.loc[mask, column] = new_value\n\nwhere mask is a boolean array that specifies which rows to adjust, column is the name of the column to adjust, and new_value is the value to assign to the selected rows.\nIn your case, you want to adjust the ht column for rows where the age column is equal to \"one\", so your mask would be df['age'] == 'one'. To modify the values in the ht column, you would use the following code:\ndf.loc[df['age'] == 'one', 'ht'] = df[df['age'] == 'one']['ht'] * 10**6\n\nThis code will select the rows where age is equal to \"one\", and then set the values in the ht column to their current value times 10^6.\nAlternatively, you can use the isin method to create your boolean mask, which can make the code more readable. The isin method returns a boolean array where each element is True if the corresponding value in the column is in the given list of values, and False otherwise. So, to create a mask for rows where the age column is equal to \"one\", you can use the following code:\nmask = df['age'].isin(['one'])\n\nThen you can use this mask with the loc method to modify the values in the ht column:\ndf.loc[mask, 'ht'] = df[mask]['ht'] * 10**6\n\nI hope this helps! Let me know if you have any other questions.\n", "Here is a way:\ndf.assign(ht = df['ht'].mask(df['age'].isin(['one']),df['ht'].mul(10**6)))\n\nby using isin(), more values from the age column can be added.\nOutput:\n famid birth age ht\n0 1 1 one 2800000.0\n1 1 1 two 3.4\n2 1 2 one 2900000.0\n3 1 2 two 3.8\n4 1 3 one 2200000.0\n5 1 3 two 2.9\n6 2 1 one 2000000.0\n7 2 1 two 3.2\n8 2 2 one 1800000.0\n9 2 2 two 2.8\n10 2 3 one 1900000.0\n11 2 3 two 2.4\n12 3 1 one 2200000.0\n13 3 1 two 3.3\n14 3 2 one 2300000.0\n15 3 2 two 3.4\n16 3 3 one 2100000.0\n17 3 3 two 2.9\n\n" ]

[ 2, 2, 1, 1, 1 ]

[]

[]

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

[ "The problem is not that \"your program ignore the lines\", it's that you test the parity of original_collatz which doesn't change.\n\nYou need to check the parity of collatz\nYou need to use integer division (//) when dividing by two or collatz will become a float.\nYou don't really need to use new_collatz as an intermediate, you could just overwrite collatz directly.\n\nHere is a fixed sample:\n# collatz program\nimport time\n\ncollatz = 7\noriginal_collatz = collatz\nnew_collatz = collatz\n\nwhile True:\n if collatz % 2 == 1:\n new_collatz = (collatz * 3) + 1\n\n else:\n new_collatz = collatz // 2\n\n collatz = new_collatz\n\n print(collatz)\n\n if collatz == 1:\n print('woo hoo')\n original_collatz += 1\n collatz = original_collatz\n\n time.sleep(1)\n\n", "Working example:\nimport time\n\ncollatz_init = 7\ncollatz = collatz_init\n\nwhile True:\n if collatz % 2 == 1:\n collatz = (collatz * 3) + 1\n else:\n collatz //= 2\n\n print(collatz)\n\n if collatz == 1:\n print('woo hoo')\n collatz_init += 1\n collatz = collatz_init\n\n time.sleep(1)\n\n" ]

[ 1, 1 ]

[]

[]

[ "collatz", "integer", "modulo", "python" ]

[ "The executescript() will run the whole sql file but will raise exception when an error occurs.\nSince you want to continue the DB schema creation regardless of errors, you could switch from using executescript() to looping over the sql statements list by calling the execute() on each of them.\nThis example will demonstrate that the processing continues when an error occurs. We will try to create a table that already exists to simulate sqlite error.\ncreate.sql:\nCREATE TABLE Stade (\n nomeStade TEXT PRIMARY KEY,\n local TEXT NOT NULL,\n idGame INTEGER REFERENCES Game\n);\n\nCREATE TABLE Stade (\n nomeStade TEXT PRIMARY KEY,\n local TEXT NOT NULL,\n idGame INTEGER REFERENCES Game\n);\n\nCREATE TABLE Stade2 (\n nomeStade TEXT PRIMARY KEY,\n local TEXT NOT NULL,\n idGame INTEGER REFERENCES Game\n);\n\nCREATE TABLE Stade2 (\n nomeStade TEXT PRIMARY KEY,\n local TEXT NOT NULL,\n idGame INTEGER REFERENCES Game\n);\n\nCREATE TABLE Stade3 (\n nomeStade TEXT PRIMARY KEY,\n local TEXT NOT NULL,\n idGame INTEGER REFERENCES Game\n);\n\npython:\nimport traceback\nimport sqlite3\ndb_mem = sqlite3.connect(\":memory:\")\ncur = db_mem.cursor()\nall_errors = []\ntry:\n with open('create.sql', 'r') as fp:\n text = fp.read().split(';')\n for sql in text:\n try:\n cur.execute(sql)\n except:\n # print(\"exception at sql: {}, details: {}\".format(sql, traceback.format_exc()))\n all_errors.append(traceback.format_exc())\nexcept:\n print(\"exception, details: {}\".format(traceback.format_exc()))\n \nelse:\n db_disk = sqlite3.connect('db.sqlite')\n db_mem.backup(db_disk)\n\nfor i, error in enumerate(all_errors):\n print(\"Error #{}: {}\".format(i, error)\n\nrunning it, we can see 2 error messages, and inspecting the db.sqlite we can see the 3rd table as well, i.e. the processing reached the last sql.\n" ]

[ 1 ]

[]

[]

[ "python", "sqlite" ]

[ "install pygeos i.e conda install pygeos\nit worked for me\n", "I found same issue when running example code from a couple of years ago. The pysal API has changed.\nImport libpysal first then import the esda libraries eg\nimport libpysal\nfrom esda.moran import Moran\nfrom esda.smaup import Smaup\n\nsee\nhttps://pysal.org/esda/generated/esda.Moran.html\n" ]

[ 0, 0 ]

[]

[]

[ "geospatial", "gis", "import", "jupyter_notebook", "python" ]

[ "It looks like you are creating a new instance of the webdriver.Chrome class when you initialize the About class in this line:\ngo = About(webdriver.Chrome())\n\nThis is causing a new Chrome browser to be opened when you create the About object. Instead, you should create the webdriver.Chrome object outside of the About class and pass it to the About class when you create the object. Here is an example of how you can do that:\nimport selenium\nimport time\nfrom selenium import webdriver\nfrom selenium.webdriver.common.by import By\nfrom selenium.webdriver.support.ui import WebDriverWait\n\nclass About(object):\n def __init__(self, driver):\n self.driver = driver\n\n def pause(self):\n time.sleep(1)\n\n def run(self):\n self.driver.get('https://google.com')\n self.pause()\n\n def tearDown(self):\n self.driver.quit()\n\n# Create the webdriver.Chrome object outside of the About class\ndriver = webdriver.Chrome()\ngo = About(driver)\n\nif __name__ == '__main__':\n go.run()\n go.tearDown()\n\nThis way, only one instance of the webdriver.Chrome class will be created and only one browser will be opened. When you create the About object, you pass the webdriver.Chrome object to it so that it can be used in the methods of the About class.\n" ]

[ 0 ]

[]

[]

[ "google_chrome", "python", "selenium", "selenium_webdriver", "webdriver" ]

[ "You can take advantage of NumPy's vectorized operations to eliminate all loops which should be much faster.\n# Remove grey background\nis_grey = ((150 <= image) & (image <= 180)).all(axis=2, keepdims=True)\nimage = np.where(is_grey, 0, image)\n\n# Remove green dashes\nis_green_dash = (image[..., 0] == 0) & (image[..., 1] == 169) & (image[..., 2] == 0)\nis_green_dash = is_green_dash[..., np.newaxis] # append a new dim at the end\nimage = np.where(is_green_dash, 0, image)\n\nBoth invocations of np.where rely on NumPy's broadcasting.\n", "One way to improve the performance of your code would be to use the cv2.inRange() function to find pixels with the desired colors, and then use the cv2.bitwise_and() function to remove those pixels from the image. This can be done more efficiently than looping through each pixel individually, which can be slow and computationally intensive. Here is an example of how this could be implemented:\nimport cv2\nimport numpy as np\n\n# Read the image\noriginal_image = cv2.imread('image.jpg')\n\n# Define the colors to be removed as ranges of BGR values\ngrey_min = np.array([150, 150, 150], np.uint8)\ngrey_max = np.array([180, 180, 180], np.uint8)\ngreen_min = np.array([0, 0, 0], np.uint8)\ngreen_max = np.array([0, 169, 0], np.uint8)\n\n# Use inRange() to find pixels with the desired colors\ngrey_mask = cv2.inRange(original_image, grey_min, grey_max)\ngreen_mask = cv2.inRange(original_image, green_min, green_max)\n\n# Use bitwise_and() to remove the pixels with\n\n", "You can apply numpy filtering to image. In your scenario it would be:\nmask_gray = (\n (150 <= image[:, :, 0]) & (image[:, :, 0] <= 180) & \n (150 <= image[:, :, 1]) & (image[:, :, 1] <= 180) & \n (150 <= image[:, :, 2]) & (image[:, :, 2] <= 180)\n)\n\nimage[mask_gray] = 0\n\nmask_green = (\n (image[:, :, 0] == 0) &\n (image[:, :, 1] == 169) &\n (image[:, :, 2] == 0)\n)\n\nimage[mask_green] = 0\n\nmask_gray and mask_green here are boolean masks\n", "If you insist on writing your own loops...\nYou could just use numba. It's a JIT compiler for Python code.\nfrom numba import njit\n\n@njit\ndef your_function(input):\n ...\n return output\n\ninput = cv.imread(...) # yes this will shadow the builtin of the same name\noutput = your_function(input)\n\nThe first time you call your_function, it'll take a second to compile. All further calls are blazingly fast.\n" ]

[ 3, 1, 0, 0 ]

[]

[]

[ "cv2", "image_processing", "numpy", "python" ]

[ "Simply check if the current line equal the new line character.\nwith open('filename.txt', 'r') as f:\n for line in f:\n if line == '\\n':\n print('Empty line')\n else:\n print('line contain string')\n\n", "If you're stripping the linebreak off each line, you can just check afterward to see if the result is empty. Given the following file text.txt:\nABCD\nEFG\nHIJK\nLMNOP\n\nQRSTUV\nWXYZ\n\nhere's an example of reading it into a list of lists of strings:\n>>> arr = [[]]\n>>> with open(\"text.txt\") as f:\n... for line in f:\n... line = line.strip()\n... if line:\n... arr[-1].append(line)\n... else:\n... arr.append([])\n...\n>>> arr\n[['ABCD', 'EFG', 'HIJK', 'LMNOP'], ['QRSTUV', 'WXYZ']]\n\n" ]

[ 0, 0 ]

[]

[]

[ "file", "python", "txt" ]

[ "Once you made the dates month-year, they were object type--character strings, not dates—as in date-type. When you sorted, you sorted by calendar month.\nFirst, use strptime to make it a date, sort it, then use strftime.\nimport pandas as pd\nimport plotly.graph_objects as go\nfrom datetime import datetime as dt\n\ndef multicat_chart(infile=None, sheet_name=None, chart_type = None, chart_title = None):\n \n #chart type must be given\n df = pd.read_excel(infile, sheet_name)\n df = df.fillna(method='ffill') # fill in companies\n\n df['month'] = [dt.strptime(x, '%b-%Y') for x in df['month']] # date for ordering\n df.sort_values(by = ['month', 'company'], inplace = True) # appearance order\n df['month2'] = [dt.strftime(x, '%b-%Y') for x in df['month']] # visual appearance\n fig = go.Figure() # plot it\n fig.add_trace( go.Bar(x = [df.iloc[:, 0], df.iloc[:, 4]], \n y = df.iloc[:, 2], name=\"# people got interviewed\" ))\n fig.add_trace( go.Bar(x = [df.iloc[:, 0], df.iloc[:, 4]], \n y = df.iloc[:, 3], name=\"# people employed\" ))\n fig.update_layout(width = 1000, height = 1000)\n return fig\n\n\n\nYou had a lot of extra work going on in your function; I cut a lot of that out because you didn't need it.\nIf you have any questions, let me know!\n" ]

[ 0 ]

[]

[]

[ "linux", "plotly", "python" ]

[ "It looks like you're trying to scrape Twitter using Beautiful Soup, but the code you've provided won't work for several reasons.\nFirst, the Twitter website uses JavaScript to dynamically generate its content, which means that the raw HTML you get from a requests.get() call won't include the tweets you're looking for. Instead, you'll need to use a tool that can execute the JavaScript on the page and return the fully-rendered HTML.\nSecond, even if you were able to get the fully-rendered HTML, the code you've provided won't work because the data-testid attribute you're using to find the tweets doesn't exist on the page. You'll need to use a different approach to locate the tweets in the HTML.\nTo scrape Twitter using Beautiful Soup, you'll need to use a different approach. One option is to use the Twitter API to retrieve the tweets you're interested in, and then use Beautiful Soup to parse the returned data. Here's an example of how you could do that:\nimport tweepy\nfrom bs4 import BeautifulSoup as bs\n\n# Authenticate with the Twitter API\nauth = tweepy.OAuthHandler(consumer_key, consumer_secret)\nauth.set_access_token(access_token, access_token_secret)\napi = tweepy.API(auth)\n\n# Get the tweets from the user with the username \"AlMosahf\"\ntweets = api.user_timeline(screen_name=\"AlMosahf\")\n\n# Parse the tweets using Beautiful Soup\nfor tweet in tweets:\n soup = bs(tweet.text, 'html.parser')\n # Do something with the parsed tweet\n\n", "The error you are seeing is because you are trying to access the second element of the twi list, but the list is empty. This means that the find_all() method did not find any elements that match the search criteria you specified.\nThere are several reasons why this might happen, in general. One possible reason is that the page structure has changed, so the elements you are trying to find are no longer present on the page. Another possible reason (the reason in this scenario) is that the page uses JavaScript to dynamically generate its content, so the content you see in the browser may not be present in the initial HTML source that is downloaded by the requests library.\nTo fix this error, you can try the following steps:\n\nUse the developer tools in your web browser to inspect the page and verify that the elements you are trying to find are actually present on the page.\nIf the elements are present, try using a different method to extract the content. For example, you could use a different parsing library, or you could try using a web scraping framework like Scrapy or Selenium.\nIf the elements are not present, you may need to use a different approach to extract the content. For example, you could try using the Twitter API to access the tweets directly, rather than trying to scrape them from the page.\n\nYou can use the tweepy library to access the Twitter API and extract the tweets from a specific account. This can be a more reliable and efficient way to access the tweets, compared to scraping the page using BeautifulSoup.\nHere is an example of how you could use tweepy to extract the tweets from a specific account:\nimport tweepy\n\n# Set up your API keys and access tokens\nconsumer_key = 'your-consumer-key'\nconsumer_secret = 'your-consumer-secret'\naccess_token = 'your-access-token'\naccess_token_secret = 'your-access-token-secret'\n\n# Authenticate with the Twitter API\nauth = tweepy.OAuthHandler(consumer_key, consumer_secret)\nauth.set_access_token(access_token, access_token_secret)\napi = tweepy.API(auth)\n\n# Extract the tweets from the specified account\naccount = 'AlMosahf'\ntweets = api.user_timeline(screen_name=account)\n\n# Print the tweets\nfor tweet in tweets:\n print(tweet.text)\n\nThis code uses the tweepy library to authenticate with the Twitter API and extract the tweets from the specified account. The tweets are then printed to the console.\nYou can modify this code to suit your needs. For example, you could use the limit parameter to specify the number of tweets you want to extract, or you could use the since_id and max_id parameters to specify a date range for the tweets. For more information, you can refer to the tweepy documentation.\n" ]

[ 2, 0 ]

[]

[]

[ "beautifulsoup", "python" ]

[ "It looks like you're using a for loop to iterate over the list and calling pop on the list at the same time. This is generally not a good idea because the for loop uses an iterator to go through the items in the list, and modifying the list while you're iterating over it can cause the iterator to become confused and not behave as expected.\nOne way to fix this is to create a new list that contains only the items that you want to keep, and then replace the original list with the new one. Here's an example:\n# Create an empty list to store the items that we want to keep\nfiltered_auctions = []\n\n# Iterate over the items in the list\nfor auction in accepted_auctions:\n # Check if the item meets the criteria for being kept\n if some_condition(auction):\n # If it does, append it to the filtered list\n filtered_auctions.append(auction)\n\n# Replace the original list with the filtered list\naccepted_auctions = filtered_auctions\n\nAnother way to fix this is to use a while loop instead of a for loop. Here's an example:\n# Keep looping until the list is empty\nwhile accepted_auctions:\n # Pop the first item from the list\n auction = accepted_auctions.pop(0)\n\n # Check if the item meets the criteria for being kept\n if some_condition(auction):\n # If it does, append it to the filtered list\n filtered_auctions.append(auction)\n\n# Replace the original list with the filtered list\naccepted_auctions = filtered_auctions\n\nI hope this helps! Let me know if you have any other questions.\n", "Modifying a list as you iterate over it will invalidate the iterator (because the indices of all the items are changing as you remove items), which in turn causes it to skip items. Don't do that.\nThe easiest way to create a filtered list is via a list comprehension that creates a new list, e.g.:\naccepted_auctions = [a for a in accepted_auctions if something(a)]\n\nHere's a simple example using a list comprehension to filter a list of ints to only the odd numbers:\n>>> nums = list(range(10))\n>>> nums\n[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n>>> nums = [n for n in nums if n % 2]\n>>> nums\n[1, 3, 5, 7, 9]\n\n" ]

[ 3, 2 ]

[]

[]

[ "python", "python_3.x" ]

[ "To visualize it:\nimport seaborn as sns\nsns.countplot(x='ColumnName',data=df)\n\ntoo see counts normally:\ndf['ColumnName'].value_counts()\n\n" ]

[ 1 ]

[]

[]

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

[ "The issue here is with your map function. Try the following syntax:\n{ posts.map((post) => (\n <div className=\"music_container\" onClick={playPause} id=\"music_container\">\n <img id=\"music_image\" src={'http://127.0.0.1:8000'+post.image} />\n <button>\n <FontAwesomeIcon icon={icon} id=\"playBtn\" />\n </button>\n <audio src='' id=\"audio\" onTimeUpdate={e=>UpdateProgress(e)}/>\n <p className=\"caption\">{post.title}</p>\n <p>{post.title}</p>\n </div>\n)) }\n\n" ]

[ 0 ]

[]

[]

[ "django_rest_framework", "python", "reactjs" ]

[ "Here is one possible solution using the np.bincount function:\nimport numpy as np\n\n# create initial array with numbers between 10 and 1, in descending order\ninitial_array = np.array([10, 10, 7, 4, 2])\n\n# create output array that counts the number of occurrences between 1 and 10\noutput_array = np.bincount(initial_array, minlength=11)\n\n# print output array\nprint(output_array)\n\nThis produces the following output:\n[0 1 0 1 0 0 1 0 0 2]\n\nNote that the minlength parameter of the np.bincount function determines the size of the output array, which should be equal to the maximum value in the initial array plus one (11 in this case, since the maximum value is 10). If you don't specify this parameter, the output array will only have as many elements as the maximum value in the initial array.\nFor example, if you remove the minlength parameter from the code above, the output will be:\n[0 1 0 1 0 0 1 0 0 2]\n\n" ]

[ 2 ]

[]

[]

[ "arrays", "python" ]

[ "Mark Ransom pointed out the issue in a comment. The fix is to append mean to rata in the loop:\nrata = []\nfor z in dfs:\n for x in tanggal:\n mean = z.loc[z['tanggal'] == x, 'harga'].mean()\n rata.append(mean)\n\nAt this point, rata will be a list such that len(rata) == len(tanggal)*len(dfs) and the mean of harga across tanggal in the first, second, etc data frame is in rata[0 : len(tanggal)], rata[len(tanggal) : 2*len(tanggal)], etc respectively.\nA side comment, if your data is only a single list (like rata), consider using pandas.Series instead.\n" ]

[ 0 ]

[]

[]

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

[ "Check the RBAC roles your user is assigned to for the storage account. The default ones don’t always enable you to view data and sounds like it’s causing your problems.\n" ]

[ 0 ]

[]

[]

[ "azure", "azure_python_sdk", "python" ]

[ "You're basically looking for the Dijkstra algorithm. Dijkstra's algorithm adapts Breadth First Search to let you find the shortest path to your target. In order to retrieve the shortest path from the origin to a node, all that needs to be stored is the parent for each node discovered\nLet's say this is your tree node:\nclass TreeNode:\n def __init__(self, value, children=None, parent=None):\n self.value = value\n self.parent = parent\n self.children = [] if children is None else children\n\nThis function returns the path from the tree root node to the target node:\nfrom queue import Queue\n\ndef path_root2target(root_node, target_value):\n def build_path(target_node):\n path = [target_node]\n while path[-1].parent is not None:\n path.append(path[-1].parent)\n return path[::-1]\n q = Queue()\n q.put(root_node)\n while not q.empty():\n node = q.get()\n if node.value == target_value:\n return build_path(node)\n for child in node.children:\n child.parent = node\n q.put(child)\n raise ValueError('Target node not found')\n\nExample:\n>>> D = TreeNode('D')\n>>> A = TreeNode('A', [D])\n>>> B = TreeNode('B')\n>>> C = TreeNode('C')\n>>> R = TreeNode('R', [A, B, C])\n>>> path_root2target(R, 'E')\nValueError: Target node not found\n>>> [node.value for node in path_root2target(R, 'D')]\n['R', 'A', 'D']\n\nIf you want to return the node values (instead of the nodes themselves, then just modify the build_path function accordingly.\n", "As crazy as this sounds, I also asked ChatGPT to help me with this problem and, after I requested that it tweak its output in a few ways, here's what it came up with (comments included!), with just a couple small edits by me to replicate the tree from my diagram. (I verified it works.)\n# Import the necessary modules\nimport queue\n\n# Define a TreeNode class to represent each node in the tree\nclass TreeNode:\n def __init__(self, value, children=[]):\n self.value = value\n self.children = children\n\n\n# Define a function to perform the search\ndef iterative_deepening_bfs(tree, target):\n # Set the initial depth to 0\n depth = 0\n\n # Create an infinite loop\n while True:\n # Create a queue to store the nodes at the current depth\n q = queue.Queue()\n\n # Add the root node to the queue\n q.put(tree)\n\n # Create a set to track which nodes have been visited\n visited = set()\n\n # Create a dictionary to store the paths to each visited node\n paths = {tree: [tree]}\n\n # Create a variable to track whether the target has been found\n found = False\n\n # Create a loop to process the nodes at the current depth\n while not q.empty():\n # Get the next node from the queue\n node = q.get()\n\n # If the node has not been visited yet, process it\n if node not in visited:\n # Check if the node is the target\n if node == target:\n # Set the found variable to a tuple containing the depth and path to the target, and break out of the loop\n found = (depth, paths[node])\n break\n\n # Add the node to the visited set\n visited.add(node)\n\n # Add the node's children to the queue\n for child in node.children:\n q.put(child)\n paths[child] = paths[node] + [child]\n\n # If the target was found, return the depth and path to the target\n if found:\n return found\n\n # Increment the depth and continue the loop\n depth += 1\n\n\nroot = TreeNode(\"Root\")\nnodeA = TreeNode(\"A\")\nnodeB = TreeNode(\"B\")\nnodeC = TreeNode(\"C\")\nnodeD = TreeNode(\"D\")\nnodeE = TreeNode(\"E\")\nnodeF = TreeNode(\"F\")\nnodeG = TreeNode(\"G\")\nnodeH = TreeNode(\"H\")\nnodeI = TreeNode(\"I\")\nnodeJ = TreeNode(\"J\")\nnodeK = TreeNode(\"K\")\nnodeL = TreeNode(\"L\")\ntarget = TreeNode(\"Target\")\n\nroot.children = [nodeA, nodeB, nodeC]\nnodeA.children = [nodeD]\nnodeB.children = [nodeE, nodeF]\nnodeC.children = [nodeG]\nnodeE.children = [nodeH]\nnodeF.children = [nodeI]\nnodeG.children = [nodeJ]\nnodeH.children = [target]\nnodeI.children = [nodeK]\nnodeJ.children = [nodeL]\n\n# Assign the root node to the tree variable\ntree = root\n\n\n\n# Call the iterative_deepening_bfs function to search for the target node\nresult = iterative_deepening_bfs(tree, target)\n\n# Print the depth and path to the target node\nprint(f\"The target was found at depth {result[0]} with path [{', '.join([str(node.value) for node in result[1]])}]\")\n\n" ]

[ 1, 0 ]

[]

[]

[ "breadth_first_search", "graph_theory", "python", "tree" ]

[ "This issue is solved by updating pycocotools to version 2.0.5\n" ]

[ 0 ]

[]

[]

[ "pycocotools", "python", "rle" ]

[ "I think you want to check if products = Product.objects.filter(title__icontains=searched) is returning results instead of checking if \"searched\" is in the GET arguments.\nTo check if the database returned results you can you exists()\nhttps://docs.djangoproject.com/en/4.1/ref/models/querysets/#django.db.models.query.QuerySet.exists\n", "Your if is returning true because the term 'searched' is in fact in the request.GET dictionary. That doesn't mean that there is a product in your database with the value request.GET['searched'], which might be \"hello\" when you type in \"hello\". request.GET is a dictionary with a key of 'searched' and a value of \"hello\". You can also use get(), which will either get the value of request['searched'] or return None, so you do not have to check it with an if at all.\nNow to check if the database has the value of the search term, you can check the queryset:\ndef search(request):\n \n # Return the value or None\n searched = request.GET.get('searched')\n\n products = Product.objects.filter(title__icontains=searched)\n\n # Check if there are any products with the search term:\n if products:\n return render(request, 'epharmacyweb/search.html', {'searched': searched, 'products': products})\n else:\n return render(request, 'epharmacyweb/search_error.html')\n\n" ]

[ 0, 0 ]

[]

[]

[ "django", "python" ]

[ "From what I understood, the behaviour is if you have only the side input parameter, you can pass it with a keyword argument or positional argument, but if you have multiple parameters, you have to use positional arguments :\n\nOnly side input argument :\n\ndef test_side_input(self):\n import apache_beam as beam\n import time\n \n\n class UseSideInput(beam.DoFn):\n def process(self, element, some_side_input, *args, **kwargs):\n yield f\"{element}~{some_side_input}\"\n\n with beam.Pipeline() as p:\n pcollect_bar = p | \"create bar\" >> beam.Create([\"bar\"])\n\n (\n p\n | \"create foo\" >> beam.Create([\"foo\"])\n | \"add timestamp\" >> beam.Map(\n lambda element: beam.window.TimestampedValue(element, int(time.time())))\n | \"use side input one arg positional\" >> beam.ParDo(UseSideInput(), beam.pvalue.AsSingleton(pcollect_bar))\n # | \"use side input one arg param\" >> beam.ParDo(UseSideInput(),\n # some_side_input=beam.pvalue.AsSingleton(pcollect_bar))\n | \"print\" >> beam.Map(print)\n )\n\n\nMultiple arguments :\n\ndef test_side_input(self):\n import apache_beam as beam\n import time\n\n class UseSideInput(beam.DoFn):\n def process(self, element, some_side_input, other, timestamp=beam.DoFn.TimestampParam, *args, **kwargs):\n yield f\"{element}~{some_side_input}~{timestamp.to_rfc3339()}\"\n\n with beam.Pipeline() as p:\n pcollect_bar = p | \"create bar\" >> beam.Create([\"bar\"])\n\n (\n p\n | \"create foo\" >> beam.Create([\"foo\"])\n | \"add timestamp\" >> beam.Map(\n lambda element: beam.window.TimestampedValue(element, int(time.time())))\n | \"use side input\" >> beam.ParDo(UseSideInput(),\n beam.pvalue.AsSingleton(pcollect_bar),\n 0)\n | \"print\" >> beam.Map(print)\n )\n\nIn the second example, I have 2 arguments : some_side_input and other\nAccording to the documentation : 4.5.3. Accessing additional parameters in your DoFn, the timestamp allows to access to the timestamp of element and needs to have a default value with beam.DoFn.TimestampParam :\nimport apache_beam as beam\n\nclass ProcessRecord(beam.DoFn):\n\n def process(self, element, timestamp=beam.DoFn.TimestampParam):\n # access timestamp of element.\n pass\n\nThis timestamp argument is not considered like other usual arguments.\nYou also have an alternative for side inputs and use methods as functions in Map or FlatMap (built in Beam DoFn) and in this case the keyword arguments works everytime :\ndef test_other(self):\n import apache_beam as beam\n import time\n\n def to_element(element, some_side_input, other):\n return f\"{element}~{some_side_input}~{other}\"\n\n with beam.Pipeline() as p:\n pcollect_bar = p | \"create bar\" >> beam.Create([\"bar\"])\n\n (\n p\n | \"create foo\" >> beam.Create([\"foo\"])\n | \"add timestamp\" >> beam.Map(\n lambda element: beam.window.TimestampedValue(element, int(time.time())))\n | \"use side input\" >> beam.Map(to_element,\n some_side_input=beam.pvalue.AsSingleton(pcollect_bar),\n other=0)\n | \"print\" >> beam.Map(print)\n )\n\n" ]

[ 1 ]

[]

[]

[ "apache_beam", "parameter_passing", "python" ]

[ "You could try something like that:\nobj = \" *\\n * *\\n * *\\n * *\\n*** ***\\n * *\\n * *\\n *****\"\n\nlines = obj.split('\\n')\nspace = len(max(lines, key=len)) + 3\n\nfor line in lines:\n print(line + \" \"* (space - len(line)) + line)\n\n", "Use a multiline string for your image, iterate through the lines and print each one doubled:\n# using dots to indicate spaces clearly\ns = '''\\\n....*.....\n...*.*....\n..*...*...\n.*.....*..\n***...***.\n..*...*...\n..*...*...\n..*****...\n'''.replace('.',' ')\n\n# double each line\nfor line in s.splitlines():\n print(line * 2)\n\nOutput:\n * * \n * * * * \n * * * * \n * * * * \n*** *** *** *** \n * * * * \n * * * * \n ***** ***** \n\n", "This works:\narrow = \" *\\n * *\\n * *\\n * *\\n*** ***\\n * *\\n * *\\n *****\"\n \narrow_lines = arrow.split(\"\\n\")\ndouble_arrow_lines = [line +\" \"*(15-len(line)) +line for line in arrow_lines]\ndouble_arrow = \"\\n\".join(double_arrow_lines)\n \nprint(double_arrow)\n\n" ]

[ 2, 1, 0 ]

[ "To print the object side by side, you can use the join() method. The join() method takes a list of strings and concatenates them together, using the string on which the method is called as a separator.\nFor example, you can use the following code to print the object side by side:\nobj = \" *\\n * \\n * \\n * \\n ***\\n * *\\n * *\\n *****\"\n\nprint(\"\\n\".join([obj, obj]))\n\nThis will print the object twice, with a newline between each instance.\nAlternatively, you could use string multiplication to repeat the string, and then use the print() function to print the result on a single line, like this:\nobj = \" *\\n * \\n * \\n * \\n ***\\n * *\\n * *\\n *****\"\n\nprint(obj * 2, sep=\"\")\n\nIn this case, we use the sep parameter of the print() function to specify that no separator should be used between the items being printed. This will print the objects side by side on a single line.\n" ]

[ -4 ]

[ "python" ]

[ "It sounds like the variable desc is not defined in the other function. You can fix this by making desc a global variable that can be accessed by both functions. You can do this by adding the global keyword before the variable name in both functions, like this:\ndef weather():\n global desc\n # [code for the API is working fine]\n with open('weather.json') as f:\n data = json.load(f)\n desc = data[\"weather\"][0][\"description\"]\n temp = data[\"main\"][\"temp\"]\n print(desc, temp)\n time.sleep(120) # this would print something like \"extra sunny 293\" (temp in °K) every 2 mins \n\ndef other():\n global desc\n while True:\n print(desc)\n\n\nAlternatively, you can pass the value of desc as an argument to the other function when you create the thread2 object, like this:\nthread2 = Thread(target=other, args=(desc,))\n\nThen, you can access the desc argument in the other function using the index of the args tuple, like this:\ndef other(desc):\n while True:\n print(desc)\n time.sleep(10) # this should no longer cause the \"NameError: name 'desc' is not defined\" error\n\n\n" ]

[ 0 ]

[]

[]

[ "multithreading", "python", "python_multithreading" ]

[ "Change STATIC_URL to \"STATIC_ROOT = os.path.join(BASE_DIR,'static')\". Could use decouple to hide those variables too.\n" ]

[ 0 ]

[]

[]

[ "amazon_s3", "amazon_web_services", "django", "python" ]

[ "from fastapi import Request, HTTPException\nfrom fastapi.security import HTTPBearer, HTTPAuthorizationCredentials\n\n\n\n\nclass JWTBearer(HTTPBearer):\n def __init__(self, auto_error: bool = True):\n super(JWTBearer, self).__init__(auto_error=auto_error)\n\n async def __call__(self, request: Request):\n credentials: HTTPAuthorizationCredentials = await super(JWTBearer, self).__call__(request)\n if credentials:\n if not credentials.scheme == \"Bearer\":\n raise HTTPException(status_code=403, detail=\"Invalid authentication scheme.\")\n #if not self.verify_jwt(credentials.credentials):\n # raise HTTPException(status_code=403, detail=\"Invalid token or expired token.\")\n return credentials.credentials\n else:\n raise HTTPException(status_code=403, detail=\"Invalid authorization code.\")```\n\nnow change your schema to \n\noauth2_schema = JWTBearer().\n\nThis will give a new type of authorization that only accept jwt token instead of the normal password and username.\n\nProcess flow on swagger docs:\n\n1) go to any of the endpoints that give you token\n\n2) copy the token and click on the padlock icon, \n\n3) paste the token then you are login.\n\n" ]

[ 0 ]

[]

[]

[ "authentication", "fastapi", "oauth_2.0", "python" ]

[ "You're not seeing the grades because you're not telling python to run computegrade. If you do\ntry:\n score = float(score)\n computegrade()\n\nIt'll be done with.\nSome observations about the computegrade method. I advise you to make it accept score as an argument\ndef computegrade(score):\n # grade calculations...\n\nAlthough it works without this - as long as there is a score variable in the same scope, Python takes it - it feels counterintuitive to call a function that requires as score, not passing a score to it.\nAlso, currently your program accepts grades bigger than 1.0 and smaller than 0.0, which is something you may want to raise an AssertionError in the future. I don't know if that is in the scope of your learning program, but having an\ndef computegrade():\n if score > 1.0 or score < 0.0:\n raise AssertionError('Scores must be within the 1.0 and 0.0 range!')\n\nIs a good practice.\n", "def compute_grade(marks):\n try:\n if float(marks)>1.0 or float(marks)<0.0:\n print(\"Invalid enteries\")\n else:\n if float(marks) >= 0.9:\n print(\"Grade A\")\n elif float(marks) >= 0.8:\n print(\"Grade B\")\n elif float(marks) >= 0.7:\n print(\"Grade C\")\n elif float(marks) >= 0.6:\n print(\"Grade D\")\n elif float(marks) < 0.6:\n print(\"Grade F\")\n except:\n print(\"Please enter numeric value\")\ncompute_grade(input(\"Please enter your marks\\n\"))\n\n", "sco = float(input('Enter your score: '))\ndef compute_grade(score):\nif score > 1.0:\n s = 'Out of Range!'\n return s\nelif score >= 0.9:\n s = \"A\"\n return s\nelif score >= 0.8:\n s = 'B'\n return s\nelif score >= 0.7:\n s = 'C'\n return s\nelif score >= 0.6:\n s = 'D'\n return s\nelif score >= 0.5:\n s = 'E'\n return s\nelse:\n s = 'Bad score'\n return s\n\nsc = compute_grade(sco)\nprint(sc)\n" ]

[ 0, 0, 0 ]

[ "You aren’t calling the function; you have told Python what the function is, but not called it. \nWhat you need to do is \nscore = float(score) \ngrade = computegrade()\nprint(‘Score :’, score,’ Grade :’, grade)\n\nIt is better practice to define your function so that it takes a parameter ;\ndef computegrade( score):\n\nInstead of your current ‘def’ line, and then when you call the function:\ngrade = computegrade( score) \n\nIt is far better practice to write functions with parameters rather than rely on external variables. \n", "You forgot to call the function.\nThe following is only a definition of the wanted function.\ndef computegrade():\n if score >=0.9:\n print('Grade A')\n elif score >=0.8 and score<0.9:\n print('Grade B')\n elif score >=0.7 and score<0.8:\n print('Grade C')\n elif score >=0.6 and score<0.7:\n print('Grade D')\n else:\n print('Grade F')\n\nYou need to call the function for it to be \"activated\".\nYou do so by writing:\ncomputegrade()\n\nSo i would guess that the resulting code should look like this:\nscore = input('Enter the score: ')\ntry:\n computegrade()\nexcept:\n print('Enter numbers only')\n\n(no need to convert to float, the command input() does it for you...)\n" ]

[ -1, -1 ]

[ "python" ]

[ "Here's how I would attack this... In pseudocode....\n\nmake a set of teams that you can use to index a couple of new variables.\n\nMake subsets of your players grouped by team, or use pandas data frame filters to limit summations of players to the team of interest.\n\nMake 2 new variables, that are binary \"indicator\" variables, one call it use5from[team] and one called use[team] to indicate that the team has been used at all.\n\nMake appropriate constraints to link those to the selection variables. Something like:\n\n\n\nfor team in teams:\n 5 * use5from[team] <= pulp.lpSum(x[i] for i in team[i])\n\n\nAnd for the other, a constraint to indicate any use...\n\n\nfor team in teams:\n use[team] <= pulp.lpSum(x[i] for i in team[I]) \n\n\nAnd then make constraints that those two variables sum to over 1 and 3 respectively.\n\n" ]

[ 1 ]

[]

[]

[ "constraints", "pulp", "python" ]

[ "As hpaulj hinted at in a comment, var1.argmax(dim=1) will result in a zero tensor because you have var1.size(1) == 1.\n", "The error seems to occur when using argmax() on the tensor. The argmax() function returns the index of the maximum value of a tensor along a given dimension. In your code, you are using argmax() with the dim argument set to 1, which will return the indices of the maximum value along the second dimension of the tensor.\nHowever, since your tensor has only one element in the second dimension, the argmax() function will always return 0 as the index of the maximum value, which means that all the values in your tensor will be set to 0 when you convert it to a NumPy array.\nTo avoid this issue, you can try using the numpy() function instead of the argmax() function to convert your tensor to a NumPy array. This will simply convert the tensor to a NumPy array without changing the values.\nHere is how you can do it:\nnump_var1 = var1.squeeze(0).cpu().numpy()\n\nYou can also remove the squeeze() function, as it is not necessary in this case. The squeeze() function is used to remove dimensions of size 1 from a tensor, but since your tensor has only one element in the first and second dimensions, the squeeze() function will not have any effect.\nHere is the updated code:\nvar1 = tensor([[[[0., 1., 1., ..., 1., 0., 0.],\n [0., 0., 1., ..., 0., 0., 0.],\n [0., 0., 0., ..., 0., 0., 1.],\n ...,\n [0., 0., 0., ..., 1., 1., 1.],\n [0., 0., 0., ..., 1., 1., 1.],\n [0., 0., 0., ..., 1., 1., 1.]]]])\n\nprint(var1.size())\nprint(type(var1))\nprint(var1.dtype)\n\n# Use the numpy() function to convert the tensor to a NumPy array\nnump_var1 = var1.cpu().numpy()\n\nprint(nump_var1)\nprint(nump_var1.shape)\nprint(type(nump_var1))\nprint(nump_var1.dtype)\n\nThis should fix the issue and give you the expected output. Let me know if this helps.\n" ]

[ 0, 0 ]

[]

[]

[ "machine_learning", "numpy", "python", "pytorch", "tensor" ]

[ "To python cgi script on apache2 server on Ubuntu(Tested on Ubuntu 20.04) from scratch, Follow these steps(Expects python is installed and works perfectly).\n\nInstall apache2 sever.\nsudo apt install apache2\n\n\nEnable CGI module.\nsudo a2enmod cgi\n\n\n\n\nHere we set /var/www/cgi-bin/ as cgi-bin directory. If you want a different directory, change files appropriately.\n\n\nOpen Apache server configuration file [/etc/apache2/apache2.conf] by,\nsudo gedit /etc/apache2/apache2.conf\n\nAnd following lines to the end of the file.\n######### Adding capaility to run CGI-scripts #################\nServerName localhost\nScriptAlias /cgi-bin/ /var/www/cgi-bin/\nOptions +ExecCGI\nAddHandler cgi-script .cgi .pl .py\n\n\nOpen file /etc/apache2/conf-available/serve-cgi-bin.conf by,\nsudo gedit /etc/apache2/conf-available/serve-cgi-bin.conf\n\nChange lines :\nScriptAlias /cgi-bin/ /usr/lib/cgi-bin/\n<Directory \"/usr/lib/cgi-bin\">\n AllowOverride None\n Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch\n Require all granted\n</Directory> \n\nTo :\nScriptAlias /cgi-bin/ /var/www/cgi-bin/\n<Directory \"/var/www/cgi-bin/\">\n AllowOverride None\n Options +ExecCGI\n</Directory>\n\n\nNow restart apache2 server by,\nsudo service apache2 restart\n\n\nNow create python script say, first.py inside directory\n/var/www/cgi-bin/ by,\nsudo gedit /var/www/cgi-bin/first.py\n\nand add following sample code :\n#!/usr/bin/env python\nimport cgitb\n\ncgitb.enable()\n\nprint(\"Content-Type: text/html;charset=utf-8\")\nprint (\"Content-type:text/html\\r\\n\")\nprint(\"<H1> Hello, From python server :) </H1>\")\n\nAnd give executable permission to first.py by,\nsudo chmod +x /var/www/cgi-bin/first.py\n\n\n\nNow curl will work.\n:~$ curl http://localhost/cgi-bin/first.py\n<H1> Hello, From python server :) </H1>\n\nOr open browser and browse http://localhost/cgi-bin/first.py. This should work and will display webpage showing \"Hello, From python server :)\".\nHope it helps... Happy coding :)\n", "These lines need to be in your apache2 site configuration file\n(for example /etc/apache2/sites-available/default-ssl.conf\nif your website uses HTTPS):\n<Directory /var/www/yoursite/yourdir/>\n Options +ExecCGI\n PassEnv LANG\n AddHandler cgi-script .py\n</Directory>\n\nAdd them for the directory you want and restart apache2. You might also need to add\nAddHandler python-program .py\n\nto your httpd.conf if not present already.\nA more detailed discussion concerning python scripts and apache2 is found here: Executing a Python script in Apache2.\n", "Probably the problem you're running in Python 3 and your code is written in Python 2\nChange the title to python2:\n#!/usr/bin/python\nprint \"Content-type: text/html\\n\"\nprint \"Hello, world!\"\n\n", "For just proof of concept, use this python script ; No input nor output needed.\n#!/usr/bin/env python3\nimport cgitb\ncgitb.enable()\noutputfile = open(\"javascriptPython.out\", \"a\")\noutputfile.write(\"Hello from Python\\n\\n\")\n\n" ]

[ 7, 4, 0, 0 ]

[]

[]

[ "apache2", "cgi", "python", "server_side_scripting", "ubuntu" ]

[ "go for settings and make it as default settings,consider the below image for the referance,count the row and select ok\n", "New version of pycharm let you unselect the Chinese interface and back to English interface.\n" ]

[ 2, 0 ]

[]

[]

[ "internationalization", "locale", "pycharm", "python", "user_interface" ]

[ "For the follow up on the original question, if I understand you correctly, you want all URIs with a specific prefix, which you'd get with this query:\nSELECT DISTINCT ?o\n{ \n ?s ?p ?o\n FILTER CONTAINS(str(?o), \"http://dbpedia.org/resource/\")\n}\n\nFor your data set you'd get these URIs:\ndbpedia:Ford\ndbpedia:LeMans\ndbpedia:Peugeot\ndbpedia:Delorean_Motor_Company\ndbpedia:Pontiac\ndbpedia:Ferrari\n\nAnd if you want to use those URIs further on, you can do it like this:\nSELECT * \n{\n {\n SELECT DISTINCT ?o\n { \n ?s ?p ?o\n FILTER CONTAINS(str(?o), \"http://dbpedia.org/resource/\")\n }\n }\n\n #rest of the query where ?o can be used\n}\n\n\n\nEDIT:\n\n\nIf I run this\nSELECT ?car ?brand ?motor ?dateManufactured\n{\n ?car ex:Deportivo ?brand;\n schema:Motor ?motor;\n schema:dateManufactured ?dateManufactured.\n FILTER (?dateManufactured > \"2000-12-31\"^^xsd:date)\n}\n\nI get these triples\ncar brand motor dateManufactured\nex:Mustang dbpedia:Ford ex:Gasolina \"2020-05-29\"\nex:California dbpedia:Ferrari ex:Gasolina \"2010-05-29\"\nex:Enzo dbpedia:Ferrari ex:Gasolina \"2002-05-29\"\n\nCan you edit your answer again, so I can see exactly what result you want to get? If you want to merge brands with car/motor/dateManufactured, you don't have to get all brands first, but simply use the ex:Deportivo that connect them -> ?car ex:Deportivo ?brand.\n" ]

[ 0 ]

[]

[]

[ "python", "rdf", "schema", "sparql" ]

[ "You can make colors an array with a forth component like this:\n# combine the color components\ncolors = np.zeros(sphere.shape + (4, ))\ncolors[..., 0] = rc\ncolors[..., 1] = gc\ncolors[..., 2] = bc\ncolors[..., 3] = 0.2 # opacity (alpha)\n\nBTW, I (half unconsciously) used the matplotlib example that you linked to. The challenge with your code is that it's not complete, so I cannot run it myself (hint ;)).\n" ]

[ 1 ]

[]

[]

[ "matplotlib", "numpy", "python" ]

[ "It looks like you are trying to use a bitmap image with the Tkinter library in Python, but the image you are trying to use has not been defined. To fix this error, you need to make sure that the bitmap image has been defined before you try to use it. This can be done by using the BitmapImage class in Tkinter to create a new instance of the image. For example:\nfrom tkinter import BitmapImage\n\nimage = BitmapImage(\"class.ico\")\n\nOnce you have defined the image, you can use it in your Tkinter application. For example, you can set it as the icon for a window using the iconbitmap method:\nroot = tk.Tk()\nroot.iconbitmap(image)\n\nI hope this helps! Let me know if you have any other questions.\n" ]

[ 0 ]

[]

[]

[ "keras", "machine_learning", "python", "tensorflow", "tkinter" ]

[ "It is possible to create a loop that iterates through each row in an HTML table and delete a row if the first cell in the row matches a certain value. This can be done using a combination of the HTML DOM (Document Object Model) and JavaScript.\nFirst, you will need to use the getElementsByTagName method to retrieve all of the tr elements (table rows) in the table. Then, you can use a for loop to iterate over each of these rows.\nInside the loop, you can use the getElementsByTagName method again to retrieve all of the th elements (table headers) in the current row. If the first th element has a data-stat attribute with a value of \"player\", then you can use the deleteRow method to delete the current row from the table.\nHere is an example of how this might look in code:\n// Get all of the table rows in the table\nvar rows = document.getElementsByTagName(\"tr\");\n\n// Loop through each row\nfor (var i = 0; i < rows.length; i++) {\n // Get all of the table headers in the current row\n var headers = rows[i].getElementsByTagName(\"th\");\n \n // If the first header has a data-stat attribute with a value of \"player\"\n if (headers[0].getAttribute(\"data-stat\") == \"player\") {\n // Delete the current row\n rows[i].deleteRow();\n }\n}\n\nKeep in mind that this is just an example and may need to be modified to fit the specific structure of your HTML table.\n" ]

[ 0 ]

[]

[]

[ "python" ]

[ "I can reproduce the error message with\nIn [5]: x=np.array([1])\n\nIn [6]: x+=np.ones((1,5),int)\n---------------------------------------------------------------------------\nValueError Traceback (most recent call last)\nInput In [6], in <cell line: 1>()\n----> 1 x+=np.ones((1,5),int)\n\nValueError: non-broadcastable output operand with shape (1,) doesn't match the broadcast shape (1,5)\n\n", "In linearRegression_update_weights, weights.shape == (1,) but weights_delta.shape == (1, 15) so the in-place subtraction fails. The shape of weights_delta is wrong because y_pred.shape == (15,) but y.shape == (15, 1) so (y_pred - y).shape == (15, 15) because of broadcasting. This results in the wrong shape of weights_delta after multiplied by X.T. The fix is to ensure y is a 1-D array to match the shape of y_pred, preventing broadcasting:\ny = data['Weight'].values.reshape(-1)\n\n" ]

[ 0, 0 ]

[]

[]

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

[ "I would use the key argument to the sorted function\nsorted(folks, key=lambda x: folks[x][-1])[::-1]\n\n\nsorted pulls the keys out of the dictionary\nkey=lambda x: folks[x][-1] determines how to sort those keys\n[::-1] reverses the list.\n\nI get:\n['Leia',\n 'Sunita',\n 'Luitgard',\n 'Gorou',\n 'Issur',\n # ... \n 'Estera',\n 'Arsenio',\n 'Samantha',\n 'Adrastos',\n 'Keiko']\n\n", "Here is one way to do it:\n# Get the values of the last item in each sublist\nlast_values = [folks[name][-1] for name in folks]\n\n# Sort the values in descending order\nsorted_values = sorted(last_values, reverse=True)\n\n# Create a list of names, sorted by the last value in their sublist\nsorted_names = [name for value in sorted_values\n for name in folks\n if folks[name][-1] == value]\n\n# Print the resulting list\nprint(sorted_names)\n\nThis code uses two nested list comprehensions to create the sorted list of names. The first list comprehension gets the values of the last item in each sublist, and the second list comprehension uses those values to create the sorted list of names.\n" ]

[ 1, 0 ]

[]

[]

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

[ "It seems you're looking to see if a number occurs in a range. This can be accomplished very directly in Python. Just remember that the end of the range is exclusive: 0 to 5 is covered by range(0, 6).\n>>> n = 16\n>>> n in range(0, 17)\nTrue\n>>> n in range(0, 6)\nFalse\n>>> n not in range(0, 6)\nTrue\n>>>\n\n", "you are using a test of 0 - 5 but to python this means zero minus five which is negative five, just as you would do in a calculator. Instead you mean if userAge >= 0 and userAge <= 5 and so on for the remaining tests.\n" ]

[ 1, 0 ]

[]

[]

[ "python" ]

[ "The problem is that when the case variable is equal to 0, the return valor statement is being executed within the switch() function, but this function is being called recursively so the value of valor is not being returned to the caller.\nTo fix this, you can add another return statement at the end of the switch() function that returns the value of valor when case is 0. This will ensure that the value of valor is returned to the caller, even when the switch() function is being called recursively.\ndef switch(valor):\n case = int(input('Escolha uma opcao... (0 para encerrar) : '))\n if case == 1:\n valor = funcoes_moeda.aumentar(valor)\n print('Valor aumentado: {}'.format(valor))\n switch(valor)\n\n elif case == 2:\n pass\n elif case == 3:\n pass\n elif case == 4:\n pass\n else:\n return valor\n\n # Return the value of valor when case is 0\n return valor\n\n", "When returning a value the recursion is braking and the value returns to the previous call of the function. If you want to return the value to the first call, you can return the value every time you call switch:\nimport funcoes_moeda\n\ndef switch(valor):\n case = int(input('Escolha uma opcao... (0 para encerrar) : '))\n if case == 1:\n valor = funcoes_moeda.aumentar(valor)\n print('Valor aumentado: {}'.format(valor))\n return switch(valor)\n\n elif case == 2:\n pass\n elif case == 3:\n pass\n elif case == 4:\n pass\n else:\n return valor\n\nvalor = float(input('Insira o valor: '))\nprint(\"Escolha a funcao a ser aplicada no valor inserido: \\n\" \\\n \"1 - Aumentar Valor \\n\" \\\n \"2 - Diminuir Valor \\n\" \\\n \"3 - Dobrar Valor \\n\" \\\n \"4 - Dividir Valor \\n\" \\\n \"0 - Encerrar o Prorama\"\n )\n\nvalor = switch(valor)\n\nprint('Funcao foi aplicada. O valor final ficou: {}'.format(valor))\n\n", "Two issues:\n\nThe return at the end of the function 'switch' should be at the end of the function and not part of the 'else' case. Because if you select '1' you will change the value of 'valor', but after changing the value you exit the function withou returning a value.\nThe returned value of the recursive call to 'switch' in the code section of 'if case == 1:' is not saved and therefore lost.\n\nIf you only correct the first point above you will get changed values only from the top call to 'switch', but all changes from the recursive calls will get lost.\nThe solution proposed by thebjorn solves both above listed issues. But treating the issues one by one, might be easier to understand.\n" ]

[ 1, 0, 0 ]

[]

[]

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

[ "toppers = ['holographic', 'flakies', 'glitter', 'microshimmer']\n\nrandomTop = random.randint(1,4)\nprint('The topper you should use is ' + toppers[randomTop] + '.')\n\ntoppers is a list with four items. Python lists are indexed starting at zero, so the valid indexes are 0-3.\nBut you're picking a random number from 1 to 4. If you happen to pick 4, that is out of range. Use random.randint(0,3).\nOr even better, use random.choice(toppers), so you don't have to worry about the index value at all.\n" ]

[ 1 ]

[]

[]

[ "index_error", "python" ]

[ "See comments in line.\nimport sys # will be used to exit the game.\n\nnumbersEntered = [] # Accumulate the numbers provided by the user\n\n\n# Since I see you are familiar with functions, use a function to end\n\ndef quit_game():\n print('Quit Game')\n sys.exit()\n\n\ndef menu():\n print(\"[A] Smallest\")\n print(\"[B] Largest\")\n print(\"[C] Quit Game\")\n\n# Get the starting number of number to process.\nlengthNumbers = int(input(\"Please enter the length of your list/array:\"))\nprint(\"Please enter your numbers individually:\")\n\nwhile True:\n for x in range(lengthNumbers):\n data = int(input())\n numbersEntered.append(data)\n if data == -1000:\n quit_game()\n # Once all numbers are entered provide the user a choice:\n # display the smallest or largest of the numbers or exit.\n menu()\n Options = str(input(f\"Please select either option A,B,or C:\")).upper()\n if Options == 'A':\n print(\"The smallest number is:\", min(numbersEntered))\n elif Options == 'B':\n print(\"The largest number is:\", max(numbersEntered))\n # check for 'C' input from user to break out of the while loop\n elif Options == 'C':\n quit_game()\n # Allow the user to process another set.\n lengthNumbers = int(input(\"Please enter the length of your list/array:\"))\n print(\"Please enter your numbers individually:\")\n# print('Quit Game') Moved to the function\n\n" ]

[ 0 ]

[]

[]

[ "arrays", "nested_loops", "python", "while_loop" ]

[ "Here is one way to accept the string and assign it to the receivedstring variable in your Flask server:\nfrom flask import Flask, request, abort\n\napp = Flask(__name__)\n\[email protected]('/webhook', methods=['GET'])\ndef webhook():\n if request.method == 'GET':\n receivedstring = request.args.get('Date_Event')\n # You can now process the received string as needed.\n # For example, you can print it to the console:\n print(receivedstring)\n # You can also access the other query parameters in the same way:\n device_id = request.args.get('DeviceID')\n variable = request.args.get('Variable')\n print(device_id, variable)\n # Return a response to the client if needed\n return \"OK\"\n\nif __name__ == '__main__':\n app.run()\n\nIn this code, the request.args.get() method is used to retrieve the query parameters from the request URL. This method takes the name of the query parameter (e.g. \"Date_Event\") as its argument and returns the corresponding value (e.g. \"2013-12-31T15:21:32Z\").\nIf you want to retrieve all query parameters at once, you can use the request.args property, which is a dictionary-like object containing all the query parameters and their values. For example:\[email protected]('/webhook', methods=['GET'])\ndef webhook():\n if request.method == 'GET':\n # Get all query parameters as a dictionary\n query_params = request.args\n # You can now process the query parameters as needed\n # For example, you can print them to the console:\n print(query_params)\n # Return a response to the client if needed\n return \"OK\"\n\nI hope this helps! Let me know if you have any other questions.\n" ]

[ 1 ]

[]

[]

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

[ "To create a list of tokens that appear in at least 1% of the reviews, you can use a dictionary to count the number of times each token appears in the training set, and then filter the dictionary to only include tokens that appear in at least 1% of the reviews.\nHere's an example of how you could do this:\n# First, create an empty dictionary to count the number of times each token appears\ntoken_counts = {}\n\n# Loop through each review in the training set\nfor review in x:\n # Loop through each token in the review\n for token in review:\n # If the token is not already in the dictionary, add it with a count of 1\n if token not in token_counts:\n token_counts[token] = 1\n # If the token is already in the dictionary, increment its count by 1\n else:\n token_counts[token] += 1\n\n# Next, create a list of tokens that appear in at least 1% of the reviews\ncommon_tokens = []\n\n# Calculate the number of reviews in the training set\nnum_reviews = len(x)\n\n# Loop through each token and its count in the dictionary\nfor token, count in token_counts.items():\n # If the token appears in at least 1% of the reviews, add it to the list of common tokens\n if count / num_reviews >= 0.01:\n common_tokens.append(token)\n\n# Finally, you can use the list of common tokens to generate a vector for each review, where each position in the vector indicates how many times the corresponding token appears in the review\nfor review in x:\n # Create an empty vector with the same length as the list of common tokens\n vector = [0] * len(common_tokens)\n # Loop through each token in the review\n for token in review:\n # If the token is in the list of common tokens, increment the corresponding position in the vector\n if token in common_tokens:\n vector[common_tokens.index(token)] += 1\n # At this point, the vector for the review will be a list of numeric variables, where each position indicates how many times the corresponding common token appears in the review\n print(vector)\n\n" ]

[ 0 ]

[]

[]

[ "python" ]

[ "You have to pass complete(absolute) path along with file name to manager.append(files) at line#12. The directory you got at Ln#6 is used to retrieve the list of files, however you have not used this while appending the files at Ln#12\n", "@venkat is correct in his answer. manager.append(files) does not contain the full path, and therefore cannot merge the files.\nFor your example, try\nfor files in listdir(filedirinput):\n if files.endswith(pdf):\n manager.append(filedirinput + str(\"\\\\\") + files)\n\noutputname = input(\"Please enter your desired filename: \")\nmerger.write(filedirinput + str(\"\\\\\") + new_filename)\nmerger.close()\n\n" ]

[ 0, 0 ]

[]

[]

[ "python" ]

[ "To check if the input is valid, you can use an if statement inside the try block to check if the input matches the expected colors. If the input is not valid, you can raise a ValueError to indicate that there was an issue with the input. Here is an example of how you can do this:\nwhile True:\n try:\n color1 = str(input(\"What should the color of the broken window be, Purple or Sky Blue? > \")).lower().strip()\n color2 = str(input(\"What should the color of the broken window, white Yellow or Pink? > \")).lower().strip()\n if color1 not in [\"purple\", \"sky blue\"]:\n raise ValueError(\"Invalid input for color1: {}\".format(color1))\n if color2 not in [\"white\", \"yellow\", \"pink\"]:\n raise ValueError(\"Invalid input for color2: {}\".format(color2))\n user_info = {\"color2\": color1, \"color2\": color2,}\n except ValueError as error:\n print(\"Error: {}\".format(error))\n continue\n else:\n break\n\nThis code will check if the input for color1 is either \"purple\" or \"sky blue\", and if the input for color2 is either \"white\", \"yellow\", or \"pink\". If the input is not valid, a ValueError is raised with a message indicating which color had an invalid input. The except block will catch this error and print the error message, then continue the loop to prompt for input again. If the input is valid, the loop will break and the program will continue. I hope this helps. Feel free to ask if you have any other questions.\n", "That works:\nwhile True:\n try:\n color1 = str(input(\"What should the color of the broken window be, Purple or Sky Blue? > \")).lower().strip()\n color2 = str(input(\"What should the color of the broken window, white Yellow or Pink? > \")).lower().strip()\n user_info = {\"color2\": color1, \"color2\": color2,}\n valid_input1 = ['purple', 'sky blue']\n valid_input2 = ['white', 'yellow', 'pink']\n if color1 not in valid_input1 or color2 not in valid_input2:\n raise ValueError\n except ValueError:\n print(\"Choose a valid input please...\")\n continue\n else:\n break\n\nYou could also do something like this:\n\ncolor1 = str(input(\"What should the color of the broken window be, Purple or Sky Blue? > \")).lower().strip()\ncolor2 = str(input(\"What should the color of the broken window, white Yellow or Pink? > \")).lower().strip()\nuser_info = {\"color2\": color1, \"color2\": color2,}\n\nvalid_input1 = ['purple', 'sky blue']\nvalid_input2 = ['white', 'yellow', 'pink']\n\nwhile color1 not in valid_input1 or color2 not in valid_input2:\n print(\"Choose a valid input please...\")\n color1 = str(input(\"What should the color of the broken window be, Purple or Sky Blue? > \")).lower().strip()\n color2 = str(input(\"What should the color of the broken window, white Yellow or Pink? > \")).lower().strip()\n\n", "You aren't raising ValueError, you can change your code to check for invalid input using an if statement for each input:\nwhile True:\n color1 = str(input(\"What should the color of the broken window be, Purple or Sky Blue? > \")).lower().strip()\n color2 = str(input(\"What should the color of the broken window, white Yellow or Pink? > \")).lower().strip()\n user_info = {\"color2\": color1, \"color2\": color2,}\n if color1 not in [\"purple\", \"sky blue\"] or color2 not in [\"yellow\", \"pink\"]:\n print(\"Choose a valid input please...\")\n continue\n break\n\nAlso if you are using Python 3, then input returns a string, so passing it to str isn't needed.\n" ]

[ 0, 0, 0 ]

[]

[]

[ "python" ]

[ "I think I may have found the answer, not sure if it's correct because the only way to compare is by visual approximation, but here is what I came up with. If anyone could try it out and determine is the calculation is off, that would be amazing!\nFirst, we have to create a helper function to convert log odds to probabilities\ndef lo_to_prob(x):\n odds = np.exp(x)\n return odds / (1 + odds)\n\nSet up our shap\nexplainer = shap.TreeExplainer(model)\nshap_values = explainer.shap_values(X_train)\n\nThis is the conversion formula I found\n# this is the row that we want to find the shap outcomes for\nobservation = 0\n\n# this is the column that we want to find the percent change for\ncolumn_num = 2\n\n# this formula gives us the outcome probability number\nshap_outcome_val = lo_to_prob(\n explainer.expected_value + shap_values[observation, :].sum()\n)\n\n# this give us the shap outcome value, without the single column\nshap_outcome_minus_one_column = lo_to_prob(\n explainer.expected_value + shap_values[observation, :].sum() - shap_values[observation, :][column_num]\n)\n\n# simply subtract the 2 probabilities to get the pct increase that the one column provides\npct_change = shap_outcome_val - shap_outcome_minus_one_column\npct_change\n\nCheck the graph to see if the length of the bar of the column we're interested in, is about the length that we get from the calculation\nshap.force_plot(\n explainer.expected_value,\n shap_values[observation, :],\n X_train.iloc[observation, :],\n link='logit'\n)\n\nAgain, not sure if this is 100% correct, as the only way to verify is visually. It looks close tho. Try it out and let me know\n" ]

[ 0 ]

[]

[]

[ "machine_learning", "math", "probability", "python", "shap" ]

[]

[]

[ "I think the issue is that your websocket server is not handling the client's messages properly. When the client sends a message, the server receives it and parses it as JSON. If the type property of the message is \"monitor\", the server starts running the run_command function. However, your run_command function does not handle the case where the client disconnects from the websocket. As a result, when the client disconnects, the server continues to run the run_command function indefinitely, without being able to send any more messages over the websocket.\nTo fix this, you can add a try block around the for loop in the run_command function, and use the websocket.closed property to check if the client has disconnected. If the client has disconnected, you can break out of the loop and return from the run_command function.\nHere's an example of how you could modify the run_command function to do this:\nasync def run_command(websocket: WebSocket):\n print(\"running command\")\n command = \"cat /dev/ttyUSB0\"\n args = shlex.split(command)\n\n with Popen(args, stdout=PIPE, stderr=STDOUT) as process:\n try:\n for output in process.stdout:\n # If the client has disconnected, break out of the loop\n if websocket.closed:\n break\n await websocket.send_text(output.decode())\n except:\n # Catch any exceptions that occur while sending messages\n pass\n\n" ]

[ -1 ]

[ "fastapi", "popen", "python", "stdout", "websocket" ]

[ "The answer is literally in the comment at the first line of the code you pasted.\nThis method translates bounding boxes in normalized coordinates (xmin, ymin, xmax, y max) to not normalized coordinates (xmin, ymin, width, height).\nCoordinates are usually expressed in pixels, which is the not normalized form. Normalized coordinates are ones that are divided by the image dimensions, i.e. numbers between 0 and 1.\nThe point (xmin, ymin) is the top-left corner of the bounding box and (xmax, ymax) the bottom-right one. (width, height) is simply the dimensio of the bounding box.\n" ]

[ 0 ]

[]

[]

[ "python", "yolov4" ]

[ "The error message says that you are trying to concatenate tensors of different sizes along the 0th dimension, which is not allowed. This is likely happening because you are not specifying the pad_to_max_length argument when calling tokenizer.encode_plus(), which means that the length of the encoded tensors will not be the same for all input texts.\nTo fix this error, you can either specify pad_to_max_length = True when calling tokenizer.encode_plus(), which will ensure that all tensors are padded to the same length, or you can use the torch.nn.utils.rnn.pad_sequence() function to pad the tensors before concatenating them.\nHere is an example of how you could use pad_sequence() to fix the error:\nfrom torch.nn.utils.rnn import pad_sequence\n\n# Encode the input texts and create the input tensors\ninput_ids = []\nattention_mask = []\n\nfor i in text:\n encoded_data = tokenizer.encode_plus(\n i,\n add_special_tokens=True,\n truncation=True,\n max_length=64,\n padding=True,\n return_attention_mask= True,\n return_tensors='pt')\n input_ids.append(encoded_data['input_ids'])\n attention_mask.append(encoded_data['attention_mask'])\n\n# Pad the input tensors to the same length\ninput_ids = pad_sequence(input_ids, batch_first=True)\nattention_mask = pad_sequence(attention_mask, batch_first=True)\n\n# Create the label tensor\nlabels = torch.tensor(labels)\n\n# Create the dataset and dataloaders\ndataset = TensorDataset(input_ids, attention_mask, labels)\ntrain_size = int(0.8 * len(dataset))\nval_size = len(dataset) - train_size\ntrain_dataset, val_dataset = random_split(dataset, [train_size, val_size])\n\ntrain_dl = DataLoader(train_dataset, sampler=RandomSampler(train_dataset),\n batch_size=2)\nval_dl = DataLoader(val_dataset, sampler=SequentialSampler(val_dataset),\n batch_size=2)\n\n# Create and train the model\nmodel = BertForSequenceClassification.from_pretrained(\n 'bert-base-uncased',\n num_labels=2,\n output_attentions=False,\n output_hidden_states=False)\n\n" ]

[ 1 ]

[]

[]

[ "bert_language_model", "machine_learning", "python", "sentiment_analysis", "torch" ]

[ "To update the value in the table when the variable charactername changes, you can use the following code:\n# Update the value of charactername in the table\nplayerdata['Saves'][0]['name'] = charactername\n\nThis code accesses the Saves key in the playerdata dictionary, then accesses the first element in the Saves list (which is a dictionary), and finally updates the name key with the current value of the charactername variable.\nNote that you will also need to update the value in the JSON file by writing the updated playerdata dictionary to the file, using the json.dump() method.\nHere is an example of how you can do that:\nimport json\n\n# Update the value of charactername in the table\nplayerdata['Saves'][0]['name'] = charactername\n\n# Open the JSON file for writing\nwith open('playerdata.json', 'w') as f:\n # Dump the updated playerdata dictionary to the file\n json.dump(playerdata, f)\n\n" ]

[ 0 ]

[]

[]

[ "python" ]

[ "sample:\ndata = {\n \"date\": [\"2022-12-02\"],\n \"time\": [\"23:55:00\"]\n}\ndf = pd.DataFrame(data)\n\ncode:\ndf[\"datetime\"] = (\n pd.to_datetime(df[\"date\"].str.cat(df[\"time\"], sep=\" \"))\n .dt.tz_localize(\"UTC\")\n .dt.tz_convert(\"US/Mountain\")\n .dt.tz_localize(None)\n)\ndf[\"date\"], df[\"time\"] = zip(*[(x.date(), x.time()) for x in df.pop(\"datetime\")])\nprint(df)\n\noutput:\n date time\n0 2022-12-02 16:55:00\n\n" ]

[ 0 ]

[]

[]

[ "datetime", "pandas", "python", "time_series", "types" ]

[ "To sort the list of tokens in f_sp['tokenized_company_name'] by the corresponding value in tf_sp['output_column'], you can use the zip function to combine the two columns and then sort the resulting list of tuples by the value of the second element in each tuple (which is the corresponding value from tf_sp['output_column']). You can then extract only the first element of each tuple (which is the token) to obtain the sorted list of tokens.\nHere is an example of how you can achieve this using a lambda function with the apply method of f_sp:\nf_sp['tokenized_company_name'] = f_sp.apply(lambda x: [t[0] for t in sorted(zip(x['tokenized_company_name'], tf_sp.loc[x.name, 'output_column']), key=lambda t: t[1], reverse=True)], axis=1)\n\nThis will sort the list of tokens in f_sp['tokenized_company_name'] by the corresponding value in tf_sp['output_column'] and store the sorted list back in f_sp['tokenized_company_name'].\nNote that this solution assumes that the length of f_sp['tokenized_company_name'] and tf_sp['output_column'] is the same for each row in f_sp. Otherwise, you may need to handle the case where the length of the two columns is different.\n", "To order a list of lists of strings by another list of lists of floats in Pandas, you can use the \"sort_values\" method. Here is an example:\nimport pandas as pd\n\n# create dataframe with string lists as data\ndf = pd.DataFrame({'strings': [['apple', 'banana', 'cherry'],\n ['dog', 'cat', 'bird'],\n ['red', 'green', 'blue']]})\n\n# create dataframe with float lists as data\ndf_floats = pd.DataFrame({'floats': [[1.0, 2.0, 3.0],\n [4.0, 5.0, 6.0],\n [7.0, 8.0, 9.0]]})\n\n# sort the string dataframe by the float dataframe\ndf.sort_values(by=df_floats['floats'])\n\nThis will return a new dataframe with the strings in each list sorted according to the corresponding list of floats.\n" ]

[ 0, 0 ]

[]

[]

[ "nlp", "pandas", "python", "string", "token" ]

[ "The reason why the code in your example doesn't have a transaction is because it's just fetching data from the database. There are no changes happening to the database (no udpates, no inserted data, no deleting of data, etc..) Quoted from asyncpg docs:\n\nWhen not in an explicit transaction block, any changes to the database will be applied immediately. This is also known as auto-commit.\n\nFrom the quote above, when you use asyncpg to execute a query to change data in the database, it will be automatically committed unless you use a transaction. When you wrap your code in a transaction, you have to call commit to have those changes saved. Additionally, transactions allow you to execute queries and if any of those queries fail, you can rollback all of the executed queries that were wrapped in that transaction. Here is an example of a transaction that shows you the mechanics.\ntr = connection.transaction()\nawait tr.start()\ntry:\n ...\nexcept:\n await tr.rollback()\n raise\nelse:\n await tr.commit()\n\n" ]

[ 1 ]

[]

[]

[ "asyncpg", "python" ]

[ "First, import the numpy library:\n\nimport numpy as np\n\nThen, create the matrix:\n\nmatrix = np.array([[1,2,3], [4,5,6], [7,8,9]])\n\nFinally, use the index to replace the value:\n\nmatrix[1,2] = 10\nThe new matrix will be:\n\n[[ 1 2 3]\n [ 4 5 10]\n [ 7 8 9]]\n\n" ]

[ 0 ]

[]

[]

[ "python" ]

[ "When in doubt, take a look at the official docs! You're missing an old library.\nWhile you may be able to bring it in, the maintainers have actually deprecated it and suggest another https://github.com/adafruit/Adafruit_Python_GPIO\n\nThis library has been deprecated in favor of our python3 Blinka library. We have replaced all of the libraries that use this repo with CircuitPython libraries that are Python3 compatible, and support a wide variety of single board/linux computers!\n\nDo take a look at the updated docs from Adafruit: https://learn.adafruit.com/monochrome-oled-breakouts/python-usage-2\nThey have a direct example showing the use of these libraries\nimport board\nimport digitalio\nfrom PIL import Image, ImageDraw, ImageFont\nimport adafruit_ssd1306\n...\n\n", "This is a couple years late, but figured why not post my solution.\nI’ve put together an updated setup.py script that’s adapted to Adafruit’s newer CircuitPython libraries. To note, I’ve tested this on a 4GB RPI4B running Raspbian GNU/Linux 11 armv7.\nBefore attempting to execute this script, make sure to follow the\n'Python Setup' instructions listed here.\n" ]

[ 0, 0 ]

[]

[]

[ "adafruit", "python", "raspberry_pi4" ]

[ "I found this exact error too.\nIn your .txt files you've created for the annotations, there will be an integer number followed by four floats (ie, 13 0.3434 0.251 0.4364 0.34353) - something like that.\nThis error essentially articulates that your number of classes (ie, the number of different objects you're trying to train into the model) is too low for the ID number of the classes you're using. In my example above, the ID is 13 (the 14th class since 0 is included). If I set nc=1, then I can only have on class (0). I would need to set nc=14 and ensure that 0-12 existed.\nTo fix this, simply change the classes so that the IDs sit inside your chose number of classes. For nc=1, you'll only need class/ID = 0.\nAs a note (and I fell foul of this), delete train.cache before you re-run the training. That caused me a bit of a nuisance since it still was certain I had classes of >0, when I didn't.\n", "The error is caused by the fact that you have one or many labels with the number 15 as a class. You have to change the class to an allowed class value (which in your case appears to be only 0), you can do it manually or with a script. I changed the values of the classes manually in my dataset, for finding the files that contained the non-allowed classes, I ran a python script, which I have adapted for your situation:\npath = 'C:/foo/bar' #path of labels\nlabels = os.listdir('path')\nfor x in labels:\n with open('path'+x) as f:\n lines = f.read().splitlines()\n for y in lines:\n if y[:1]!='0':\n print(x)\n\nThis snippet will print all of the files that contain a class different from 0.\nFor anyone that finds this and has more than one class, you must substitute the value of 0 with the value or values(you could iterate through a list of possible values) of the class or classes that are higher than the number of classes you stated before.\n", "I also faced this problem and tried few solutions and solved as below:\nActually the dataset is consist of 11 class. And when i check .xml files which is include label of image, i saw label:11. So :\n\nset nc:12,\nadd '' value to the label array. ['','apple','banana', etc.]\n\nDont forget to remove label chache !rm -f data/train/labels.npy\n" ]

[ 1, 0, 0 ]

[]

[]

[ "python", "yolov5" ]

[ "Because, get_queryset() always return a queryset of objects or a list of objects.\nYou cannot return an object or a field from the get_queryset method.\nthe last_price value will be printed, but it is a field value and therefore the get_queryset method will not return it.\nWhen you add [0], it takes the first object from the filtered queryset. Till that point, it is a queryset of objects.\n", "A bit hacky and I am sure there must be a better way to do this.\nI wanted to get return of either a single row(last_date_time) based or the last_price value.\nI wrapped the query:\n# removed the .last_price\nlast_price = StockPriceModel.objects.all().filter(\n ticker=self.request.data['ticker']).order_by('-last_date_time')[0]\nlast_price = [last_price] # made it into a list, i.e. iterable\nreturn last_price\n\nAnd now I can get the last row.\nPosting here incase someone spends the same number of hours trying to figure this out. If you have the correct way of doing this, please post.\n" ]

[ 0, 0 ]

[]

[]

[ "django", "python" ]

[ "In this case I would make a serializer for the user and then use that in the FriendshipRequestSerializer.\nclass UserSerializer(serializers.ModelSerializer):\n \n class Meta:\n model = User\n fields = ('id', 'first_name', 'last_name',)\n\n\nclass FriendshipRequestSerialiser(serializers.ModelSerializer):\n to_user = UserSerializer(many=False)\n from_user = UserSerializer(many=False)\n\n class Meta:\n model = FriendshipRequest\n fields = ('id', 'to_user', 'from_user', 'message', ...\n extra_kwargs = ...\n\n" ]

[ 0 ]

[]

[]

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

[ "http://127.0.0.1:8000/reportes looks like a typo (extra \"e\").\nAnyway you can add one more route to your function as follows:\[email protected](\"/reports\", methods=[\"GET\", \"POST\"])\[email protected](\"/reports/<int:ds>\", methods=[\"GET\", \"POST\"])\ndef reports(ds=1): # <-- provide here the default value you want ds to be\n View=ds\nif View == 1:\n return render_template(\n \"template.html\")\nif View == 0:\n return render_template(\n \"templateNew.html\")\n\nAnother option is to pass the default value in the route definition:\[email protected](\"/reports\", methods=[\"GET\", \"POST\"], defaults={'ds': 1})\[email protected](\"/reports/<int:ds>\", methods=[\"GET\", \"POST\"])\ndef reports(ds): to be\n View=ds\nif View == 1:\n return render_template(\n \"template.html\")\nif View == 0:\n return render_template(\n \"templateNew.html\")\n\n" ]

[ 0 ]

[]

[]

[ "flask", "python" ]

[]

[]

[ "I don't think your looop works like you expect it to\nYou never exit the while loop to start the main loop.\ninstead you might wanna try something like this:\ndef update_cube():\n cube.rotate_y(0.01)\n cube.rotate_x(0.01)\n canvas.delete(\"all\")\n cube.draw()\n root.update()\n root.after(10, update_cube())\n\nroot.after(0, update_cube())\nroot.mainloop()\n\nAnd I think there is someting wrong with your poligons in your draw method.\nThe attribute is supposed to hold tupples but you have multiple lists of values.\nCheck your self.polygons and make sure the values you put in the create_polygon method are correct. Depending on your IDE, if you tell self.canvas to be a Canvas, you might get some information about the argument error. At least in PyCharm this works.\ndef draw(self):\n for polygon in self.polygons:\n self.canvas: Canvas\n self.canvas.create_polygon(polygon, fill=self.colors[self.polygons.index(polygon)], outline='black')\n\n" ]

[ -1 ]

[ "python", "tkinter" ]

[ "# See comments in line.\nfi = open(\"test.txt\", 'w')\nfor n in range(10):\n fi.write(str(n))\nfi.close()\n\nmy_file = open(\"test.txt\")\nfor line in my_file:\n print(\"Here it says: \" + line)\n# The file indicates there are no more lines by setting the EOF\n# End of file marker\nlines = my_file.readlines() # reads the same end of file marker.\nprint(lines[1])\n\n" ]

[ 0 ]

[]

[]

[ "jupyter_notebook", "python" ]

[ "This should work if you want to modify the original matrix; if not, Chris' answer is simpler.\nfor x in a:\n for i in range(len(x)):\n x[i] = int(x[i] * 1.2)\n\n", "You may wish to generate a new \"matrix\" with your adjusted values, in which case list comprehensions can be useful:\nb = [[int(y * 1.2) for y in x] for x in a]\n\nPrinting the matrix we can find the widest number, then use str.rjust to ensure columns are lined up.\n>>> w = len(str(max(max(x) for x in a)))\n>>> str(400).rjust(w)\n' 400'\n>>> for x in a:\n... print(*(str(y).rjust(w) for y in x), sep=' ', end='\\n')\n... \n 200 300 5000 400\n 554 500 1000 652\n 800 500 650 800\n 950 120 470 500\n 500 600 2000 100\n>>>\n\n" ]

[ 0, 0 ]

[]

[]

[ "python" ]

[ "Tuple unpacking works.\n(element,) = myset\n\n(By the way, python-dev has explored but rejected the addition of myset.get() to return an arbitrary element from a set. Discussion here, Guido van Rossum answers 1 and 2.)\nMy personal favorite for getting an arbitrary element is (when you have an unknown number, but also works if you have just one):\nelement = next(iter(myset)) ¹\n\n1: in Python 2.5 and before, you have to use iter(myset).next()\n", "Between making a tuple and making an iterator, it's almost a wash, but iteration wins by a nose...:\n$ python2.6 -mtimeit -s'x=set([1])' 'a=tuple(x)[0]'\n1000000 loops, best of 3: 0.465 usec per loop\n$ python2.6 -mtimeit -s'x=set([1])' 'a=tuple(x)[0]'\n1000000 loops, best of 3: 0.465 usec per loop\n$ python2.6 -mtimeit -s'x=set([1])' 'a=next(iter(x))'\n1000000 loops, best of 3: 0.456 usec per loop\n$ python2.6 -mtimeit -s'x=set([1])' 'a=next(iter(x))'\n1000000 loops, best of 3: 0.456 usec per loop\n\nNot sure why all the answers are using the older syntax iter(x).next() rather than the new one next(iter(x)), which seems preferable to me (and also works in Python 3.1).\nHowever, unpacking wins hands-down over both:\n$ python2.6 -mtimeit -s'x=set([1])' 'a,=x'\n10000000 loops, best of 3: 0.174 usec per loop\n$ python2.6 -mtimeit -s'x=set([1])' 'a,=x'\n10000000 loops, best of 3: 0.174 usec per loop\n\nThis of course is for single-item sets (where the latter form, as others mentioned, has the advantage of failing fast if the set you \"knew\" had just one item actually had several). For sets with arbitrary N > 1 items, the tuple slows down, the iter doesn't:\n$ python2.6 -mtimeit -s'x=set(range(99))' 'a=next(iter(x))'\n1000000 loops, best of 3: 0.417 usec per loop\n$ python2.6 -mtimeit -s'x=set(range(99))' 'a=tuple(x)[0]'\n100000 loops, best of 3: 3.12 usec per loop\n\nSo, unpacking for the singleton case, and next(iter(x)) for the general case, seem best.\n", "I reckon kaizer.se's answer is great. But if your set might contain more than one element, and you want a not-so-arbitrary element, you might want to use min or max. E.g.:\nelement = min(myset)\n\nor:\nelement = max(myset)\n\n(Don't use sorted, because that has unnecessary overhead for this usage.)\n", "I suggest:\nelement = myset.pop()\n\n", "you can use element = tuple(myset)[0] which is a bit more efficient, or, you can do something like \nelement = iter(myset).next()\n\nI guess constructing an iterator is more efficient than constructing a tuple/list.\n", "There is also Extended Iterable Unpacking which will work on a singleton set or a mulit-element set\nelement, *_ = myset\nThough some bristle at the use of a throwaway variable.\n", "One way is to use reduce with lambda x: x.\nfrom functools import reduce\n\n> reduce(lambda x: x, {3})\n3\n\n> reduce(lambda x: x, {1, 2, 3})\nTypeError: <lambda>() takes 1 positional argument but 2 were given\n\n> reduce(lambda x: x, {})\nTypeError: reduce() of empty sequence with no initial value\n\nBenefits:\n\nFails for multiple and zero values\nDoesn't change the original set\nDoesn't require data transformations (e.g., to list or iterable)\nDoesn't need a new variable and can be passed as an argument\nArguably less awkward and PEP-compliant\n\n", "You can use the more-itertools package. All functions below will return one item from the set, with different behaviors if the set does not contain exactly one item:\n\nmore_itertools.one raises an exception if iterable is empty or has more than one item:\nelement = more_itertools.one(myset)\n\nThis works like (element,) = myset, but might not be as fast:\n$ python3.11 -m timeit -s 'myset = {42}' '(element,) = myset'\n5000000 loops, best of 5: 57.9 nsec per loop\n$ python3.11 -m timeit -s 'from more_itertools import one\nmyset = {42}' 'element = one(myset)'\n500000 loops, best of 5: 611 nsec per loop\n\n\nmore_itertools.only returns a default if iterable is empty or raises an exception if iterable has more than one item:\nelement = more_itertools.only(myset)\n\n\nmore_itertools.first raises an exception if iterable is empty, or a default when one is provided:\nelement = more_itertools.first(myset)\n\nThis works as element = next(iter(myset)), but is arguably more idiomatic.\n\nmore_itertools.first_true returns the first \"truthy\" value in the iterable or a default if iterable is empty:\nelement = more_itertools.first_true(myset)\n\n\n\nYou can also use the first package:\nfrom first import first\n\nelement = first(myset)\n\nThis works like more_itertools.first_true, mentioned above.\n" ]

[ 129, 31, 25, 15, 2, 2, 0, 0 ]

[]

[]

[ "python", "set" ]

[ "There is a quite clear description and examples on the official documentaiton.\nLet's take an example from it:\npd.to_datetime([1, 2, 3], unit='D',\n origin=pd.Timestamp('1960-01-01'))\n\nOutput:\nDatetimeIndex(['1960-01-02', '1960-01-03', '1960-01-04'], dtype='datetime64[ns]', freq=None)\n\nWhat has happened here? Basically we are taking origin as the base date, and this list in the beginning as a… multiplier? By unit='D' we set it to days, no problem, let's see how it behaves on a different list:\npd.to_datetime([0, 30, 64], unit='D',\n origin=pd.Timestamp('1960-01-01'))\n\nOutput:\nDatetimeIndex(['1960-01-01', '1960-01-31', '1960-03-05'], dtype='datetime64[ns]', freq=None)\n\nNow look. 0 means there is no change.\n30 means we are adding 30 days to our starting date.\nFinally 64 means we are adding 64 days to our base date.\nLet's do it in Excel:\n\n\n\n\nvar\nvalue\n\n\n\n\nBase=\n01-01-60\n\n\n+64\n05-03-60\n\n\n\n\n\nSo, feels legit, does not it?\nLet's try it on some different unit, e.g. s which stands for seconds:\npd.to_datetime([0, 30, 64], unit='s',\n origin=pd.Timestamp('1960-01-01'))\n\nOutput:\nDatetimeIndex(['1960-01-01 00:00:00', '1960-01-01 00:00:30',\n '1960-01-01 00:01:04'],\n dtype='datetime64[ns]', freq=None)\n\nThat was expected. Basically same thing, we are rather taking the base value, or add 30 seconds or get 00:01:04 by adding 64 seconds\nTo sum it up\nYou are misusing this unit= key, it's meant to add up to the base datetime by providing a list of values of how much you want to add up. Your date should be featured in origin= key as origin='2022-01-01'.\nIf you don't want this functionality and you want to cast this value to a day, than look at the other answer. Basically:\npd.to_datetime('2022-01-01', format='%Y-%m-%d').day\n\nOutput:\n1\n\nOne is the first day of Jan 2022.\nUpdate\nFrom the comments I remember you wanted to cast you datetime with seconds to date. You can do it with .ceil('1D').\n" ]

[ 1 ]

[]

[]

[ "datetime", "pandas", "parsing", "python", "timestamp" ]

[ "In the first code I use the integrator developed in scipy.integrate.solve_ivp from scipy.\nCode 1.\n##########################################\n# AUTHOR : CARLOS DUARDO DA SILVA LIMA #\n# DATE : 03/12/2022 #\n# LANGUAGE: python #\n# IDE : GOOGLE COLAB #\n# CODE 1 : #\n##########################################\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom scipy.integrate import odeint, solve_ivp\n\n# Ordinary Differential Equations\na = 0.05\nb = 1.20\n\ndef B(t):\n return 1.2*np.exp(-0.5*(t-30))\n\ndef f(t,r):\n x,y=r\n if t>=0 and t<=30:\n ode1 = -x+a*y+x**2*y\n ode2 = b-a*y-x**2*y\n s = np.array([ode1,ode2])\n return s\n elif t>30:\n b_ = B(t)\n ode1 = -x+a*y+x**2*y\n ode2 = b_-a*y-x**2*y\n s = np.array([ode1,ode2])\n return s\n\n# Time t0<=t<=tf\nti = 0.0\ntf = 100.0\nt = np.array([ti,tf])\n\n# Initial conditions\nx0 = 1.0\ny0 = 1.0\nr0 = np.array([x0,y0])\n\n# Solving the set of ordinary differential equations (Initial Value Problem)\n#sol = solve_ivp(f, t_span = t, y0 = r0,method='Radau', rtol=1E-09, atol=1e-09)\n#sol = solve_ivp(f, t_span = t, y0 = r0,method='DOP853', rtol=1E-09, atol=1e-09)\n#sol = solve_ivp(f, t_span = t, y0 = r0,method='RK23', rtol=1E-09, atol=1e-09)\nsol = solve_ivp(f, t_span = t, y0 = r0,method='RK45', rtol=1E-09, atol=1e-09)\n\nt_= sol.t\nx = sol.y[0, :]\ny = sol.y[1, :]\n\n# graphic\nplt.figure(figsize = (8,8))\nplt.style.use('dark_background')\nplt.title('scipy.integrate.solve_ivp - RK45')\nplt.plot(t_,x,'y.',t_,y,'g.')\nplt.xlabel('t')\nplt.ylabel('x, y')\nplt.legend(['x', 'y'], shadow=True)\nplt.grid(lw = 0.95,color = 'white',linestyle = '--')\nplt.show()\n\nFigure 1: Output graph using scipy.integrate.solve_ivp\nIn the second code I try to solve the problem following his reasoning, creating the fourth order Runge-Kutta method in the initial value problem. Heads up! The initial conditions for x0 and y0 were informed and I use them in both codes (code 1 and code 2), x0 = 1.0 and y0 = 1.0.\n##########################################\n# AUTHOR : CARLOS DUARDO DA SILVA LIMA #\n# DATE : 03/12/2022 #\n# LANGUAGE: python #\n# IDE : GOOGLE COLAB #\n# CODE 2 : #\n##########################################\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom scipy.integrate import odeint, solve_ivp\n\n# Ordinary Differential Equations\na = 0.05\nb = 1.20\n\ndef B(t):\n return 1.2*np.exp(-0.5*(t-30))\n\ndef f(t,x,y):\n if t>=0 and t<=30:\n ode1 = -x+a*y+x**2*y\n ode2 = b-a*y-x**2*y\n s = np.array([ode1,ode2])\n return s\n elif t>30:\n b_ = B(t)\n ode1 = -x+a*y+x**2*y\n ode2 = b_-a*y-x**2*y\n s = np.array([ode1,ode2])\n return s\n\n# Initial conditions\nti = 0.0\nx0 = 1.0\ny0 = 1.0\nN = 1000000\nh = 1E-4 # Step\n\nt = np.zeros(N)\nx = np.zeros(N)\ny = np.zeros(N)\nt[0] = ti\nx[0] = x0\ny[0] = y0\n\nfor i in range(0,N-1,1):\n k11 = h*f(t[i],x[i],y[i])[0]\n k12 = h*f(t[i],x[i],y[i])[1]\n\n k21 = h*f(t[i]+(h/2),x[i]+(k11/2),y[i]+(k12/2))[0]\n k22 = h*f(t[i]+(h/2),x[i]+(k11/2),y[i]+(k12/2))[1]\n\n k31 = h*f(t[i]+(h/2),x[i]+(k21/2),y[i]+(k22/2))[0]\n k32 = h*f(t[i]+(h/2),x[i]+(k21/2),y[i]+(k22/2))[1]\n\n k41 = h*f(t[i]+h,x[i]+k31,y[i]+k32)[0]\n k42 = h*f(t[i]+h,x[i]+k31,y[i]+k32)[1]\n\n x[i+1] = x[i] + ((k11+2*(k21+k31)+k41)/6)\n y[i+1] = y[i] + ((k12+2*(k22+k32)+k42)/6)\n t[i+1] = t[i] + h \n\n# graphic\nt_ = t\nplt.figure(figsize = (8,8))\nplt.style.use('dark_background')\nplt.title('4-Order Runge-Kutta')\nplt.plot(t_,x,'r.',t_,y,'b.')\nplt.xlabel('t')\nplt.ylabel('x, y')\nplt.legend(['x', 'y'], shadow=True)\nplt.grid(lw = 0.95,color = 'white',linestyle = '--')\nplt.show()\n\nFigure 2: Output graph 4-Order Runge-Kutta\nIn case you don't want to be limited only between 0<=t<=30, we can use a simple logic, like.\ndef f(t,r):\n x,y=r\n if t>=30:\n b_ = B(t)\n ode1 = -x+a*y+x**2*y\n ode2 = b_-a*y-x**2*y\n s = np.array([ode1,ode2])\n return s\n else:\n ode1 = -x+a*y+x**2*y\n ode2 = b-a*y-x**2*y\n s = np.array([ode1,ode2])\n return s\n\nYou can apply them to both of the above codes by replacing the function f, bounded between 0<=t<=30 and t>30. One last note! I replaced variables A and F with x and y. Up until :).\n" ]

[ 0 ]

[]

[]

[ "math", "ode", "python" ]

[ "As official Flask's documentation says, never run your application in production in dev mode (what app.run() actually is).\nPlease refer to this section if you are going to deploy in self-hosted machine: https://flask.palletsprojects.com/en/2.2.x/deploying/\nAnd if you are going to deploy to Heroku, you need to prepare for correct Procfile, like this:\nweb: gunicorn run:app\n\n" ]

[ 0 ]

[]

[]

[ "flask", "gunicorn", "heroku", "python" ]

[ "I managed to find a way to not plot the triangles at the bottom by using the following code:\nxtri = x_after[triangles] - np.roll(x_after[triangles], 1, axis=1)\nytri = y_after[triangles] - np.roll(y_after[triangles], 1, axis=1)\nmaxi = np.max(np.sqrt(xtri**2 + ytri**2), axis=1)\nmax_radius = 4.5\ntriang.set_mask(maxi > max_radius)\n\n\n", "\nMost of my code is devoted to build the x, y arrays and the list of triangles in terms of the numbering of the nodes, but I suppose that you already have (or at least you can get) a list of triangles from the mesher program that you have used... if you have the triangles it's as simple as plt.tricontourf(x, y, triangles, z).\nAnd here it is the code complete of the boring stuff.\nimport matplotlib.pyplot as plt\nimport numpy as np\n\nth0 = th2 = np.linspace(-0.5, 0.5, 21)\nth1 = np.linspace(-0.475, 0.475, 20)\nr = np.array((30, 31, 32))\n\nx = np.concatenate(( np.sin(th0)*r[0], \n np.sin(th1)*r[1],\n np.sin(th2)*r[2]))\ny = np.concatenate(( np.cos(th0)*r[0], \n np.cos(th1)*r[1],\n np.cos(th2)*r[2]))\n\nz = np.sin(x)-np.cos(y)\n\nnodes0 = np.arange( 0, 21, dtype=int)\nnodes1 = np.arange(21, 41, dtype=int)\nnodes2 = np.arange(41, 62, dtype=int)\n\ntriangles = np.vstack((\n np.vstack((nodes0[:-1],nodes0[1:],nodes1)).T,\n np.vstack((nodes0[1:-1],nodes1[1:],nodes1[:-1])).T,\n np.vstack((nodes2[:-1],nodes1,nodes2[1:])).T,\n np.vstack((nodes1[:-1],nodes1[1:],nodes2[1:-1])).T,\n (0, 21, 41),\n (20, 61, 40)\n ))\n\nfig, ax = plt.subplots()\nax.set_aspect(1)\ntp = ax.triplot(x, y, triangles, color='k', lw=0.5, zorder=4)\ntc = ax.tricontourf(x, y, triangles, np.sin(x)-np.cos(y))\nplt.colorbar(tc, location='bottom')\nplt.show()\n\n" ]

[ 0, 0 ]

[]

[]

[ "interpolation", "matplotlib", "python", "triangulation" ]

[ "First, you need to find where it was installed.\npip3 show jupyter | grep Location\n\nExample:\n$ pip3 show pip | grep Location\n\nLocation: /usr/lib/python3/dist-packages\n\nThen you need to ensure that the path you get is in your PATH.\nExample:\n$ export PATH=/usr/lib/python3/dist-packages:$PATH\n\n", "Try adding Python's bin/ folder path to $PATH variable.\nYou should be able to find it here - /Users/<your-username>/Library/Python/3.x/bin\nStep 1 : Open .bash_profile in text editor\nopen ~/.bash_profile\n\nStep 2 : Add the following line at the end of the file\nexport PATH=\"/Users/<your-username>/Library/Python/3.x/bin:$PATH\"\n\nStep 3 : Save the edits made to .bash_profile and restart the terminal\n" ]

[ 6, 0 ]

[]

[]

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

[ "There is no real difference between using a plain typing.Dict and dict, no.\nHowever, typing.Dict is a Generic type * that lets you specify the type of the keys and values too, making it more flexible:\ndef change_bandwidths(new_bandwidths: typing.Dict[str, str],\n user_id: int,\n user_name: str) -> bool:\n\nAs such, it could well be that at some point in your project lifetime you want to define the dictionary argument a little more precisely, at which point expanding typing.Dict to typing.Dict[key_type, value_type] is a 'smaller' change than replacing dict.\nYou can make this even more generic by using Mapping or MutableMapping types here; since your function doesn't need to alter the mapping, I'd stick with Mapping. A dict is one mapping, but you could create other objects that also satisfy the mapping interface, and your function might well still work with those:\ndef change_bandwidths(new_bandwidths: typing.Mapping[str, str],\n user_id: int,\n user_name: str) -> bool:\n\nNow you are clearly telling other users of this function that your code won't actually alter the new_bandwidths mapping passed in.\nYour actual implementation is merely expecting an object that is printable. That may be a test implementation, but as it stands your code would continue to work if you used new_bandwidths: typing.Any, because any object in Python is printable.\n\n*: Note: If you are using Python 3.7 or newer, you can use dict as a generic type if you start your module with from __future__ import annotations, and as of Python 3.9, dict (as well as other standard containers) supports being used as generic type even without that directive.\n", "typing.Dict is a generic version of dict:\n\nclass typing.Dict(dict, MutableMapping[KT, VT])\nA generic version of dict. The usage of this type is as follows:\ndef get_position_in_index(word_list: Dict[str, int], word: str) -> int:\n return word_list[word]\n\n\nHere you can specify the type of key and values in the dict: Dict[str, int]\n", "as said in python org:\n\nclass typing.Dict(dict, MutableMapping[KT, VT])\n\n\nA generic version of dict. Useful for annotating return types. To\nannotate arguments it is preferred to use an abstract collection type\nsuch as Mapping.\n\nThis type can be used as follows:\ndef count_words(text: str) -> Dict[str, int]:\n ...\n\nBut dict is less general and you will be able to alter the mapping passed in.\nIn fact, in python.Dict you specify more details.\nAnother tip:\n\nDeprecated since version 3.9: builtins.dict now supports []. See PEP 585\nand Generic Alias Type.\n\n", "If you're coming from google for\nTypeError: Too few parameters for typing.Dict; actual 1, expected 2, you need to provide a type for both the key and value.\nSo, Dict[str, str] instead of Dict[str]\n" ]

[ 285, 39, 11, 0 ]

[]

[]

[ "dictionary", "python", "python_typing", "type_hinting" ]

[ "Thank you, odog, your error helped me track mine down. This simple example now works for me:\nfrom machine import Pin, I2C\nfrom ssd1306 import SSD1306_I2C\n\ni2c=I2C(0,sda=Pin(0), scl=Pin(1), freq=400000)\n\ndevices = i2c.scan()\ntry:\n oled = SSD1306_I2C(128, 64, i2c,addr=devices[0])\n oled.text(\"hello world\", 0, 0)\n oled.show()\nexcept Exception as err:\n print(f\"Unable to initialize oled: {err}\")\n\nSince yours stopped responding to the address you found, I'm not sure if it will help you.\n" ]

[ 0 ]

[]

[]

[ "python", "raspberry_pi_pico", "thonny" ]