Datasets:

reshinthadith

/

2048_has_code_filtered_base_code_review_python_based_on_property

like 0

[]

{ "AcceptedAnswerId": "265604", "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-07-30T14:35:05.840", "Id": "265551", "Score": "3", "Tags": [ "python", "numpy" ], "Title": "Dynamically indexing numpy array" }

[ { "body": "<ul>\n<li>Avoid <code>eval</code> at all costs</li>\n<li>Use the <code>slice</code> built-in for your <code>:</code> components, or the numeric index at the selected axis</li>\n<li>Do not abbreviate your variable names</li>\n<li>Type-hint your function signature</li>\n<li>Turn your example into something resembling a unit test with an <code>assert</code></li>\n<li>Modify the data in your example to add more non-zero entries making it clearer what's happening</li>\n<li>Prefer immutable tuples over mutable lists when passing initialization constants to Numpy</li>\n<li>Prefer the symbolic constants for Numpy types rather than strings</li>\n</ul>\n<h2>Suggested</h2>\n<pre><code>import numpy as np\n\n\ndef select_slice_axis(array: np.ndarray, index: int, axis: int) -&gt; np.ndarray:\n slices = tuple(\n index if a == axis else slice(None)\n for a in range(len(array.shape))\n )\n return array[slices]\n\n\narr = np.array(\n (\n ((0, 0, 0),\n (0, 0, 0),\n (0, 0, 9)),\n ((0, 1, 0),\n (2, 3, 4),\n (0, 5, 0)),\n ((0, 0, 0),\n (0, 0, 0),\n (8, 0, 0)),\n ),\n dtype=np.uint8,\n)\n\nactual = select_slice_axis(arr, 2, 1)\nexpected = np.array(\n (\n (0, 0, 9),\n (0, 5, 0),\n (8, 0, 0),\n ), dtype=np.uint8\n)\nassert np.all(expected == actual)\n</code></pre>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-09T07:51:31.133", "Id": "525143", "Score": "0", "body": "Thank you very much, this is really helpful! Just one more clarification: why `eval` is so bad? Thank you" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-09T12:51:27.720", "Id": "525156", "Score": "1", "body": "It greatly increases the surface area for bugs and security flaws." } ], "meta_data": { "CommentCount": "2", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-01T16:23:38.230", "Id": "265604", "ParentId": "265551", "Score": "1" } } ]

[]

{ "AcceptedAnswerId": "265773", "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-06T11:00:03.783", "Id": "265767", "Score": "0", "Tags": [ "python", "machine-learning" ], "Title": "Logistic Regression for non linearly separable data" }

[ { "body": "<p>This is a very nice little project but there are some thing to upgrade here :)</p>\n<hr />\n<p><strong>Code beautification</strong></p>\n<ol>\n<li>Split everything to functions, there is no reason to put logic outside of a function, including the prediction part (this will remove the code duplication) and call everything from a <code>main</code> function. For example a loading function:</li>\n</ol>\n<pre class=\"lang-py prettyprint-override\"><code>def load_and_split_iris(data_cut: int=50, train_test_ratio: float=0,333)\n iris = load_iris()\n x_train = iris.data[data_cut:]\n y_train = iris.target[data_cut:]\n y_train = y_train - 1\n x_train, x_test, y_train, y_test = train_test_split(\n x_train, y_train, test_size=train_test_ratio, random_state=2021)\n return x_train, x_test, y_train, y_test\n</code></pre>\n<ol start=\"2\">\n<li>Magic numbers make your code look bad, turn them into a <code>CODE_CONSTANTS</code>.</li>\n<li>I really like type annotations, it will make your code more understandable for future usage and you will not confuse with the types. I added them in the code example in 1. Another example: <code>def fit(self, x: np.array, y: np.array, verbose: bool=False, seed: int=None):</code>. Type annotation can also declare return type, read into that.</li>\n<li>String formatting, this: <code>'model gets 100% train accuracy after {} epoch(s)'.format(i)</code> and turn into <code>f'model gets 100% train accuracy after {i} epoch(s)'</code>.</li>\n</ol>\n<p><strong>Bug</strong></p>\n<p>You reset the seed every loop (<code>LogisticRegression.fit</code>), in case you are passing <code>None</code> this is fine (since the OS will generate random for you) but if you pass a specific seed the numbers will be the same each time you shuffle. Take the seed setting outside of the loop.</p>\n<p><strong>Future work</strong></p>\n<p>If you are looking to continue the work I recommend to try and create a multiclass logistic regression.</p>\n", "comments": [], "meta_data": { "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-06T11:59:48.500", "Id": "265773", "ParentId": "265767", "Score": "2" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-09T21:08:26.723", "Id": "525195", "Score": "0", "body": "We are missing some information here. Can you include a screenshot of the program you're scripting, and explain why you're scripting it (instead of doing it once by hand?)" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-09T21:37:08.890", "Id": "525196", "Score": "0", "body": "Just added an edit with some screenshots so you can see it. The reason I am running this and want to optimize it is so that eventually I can randomly generate these maps to add to my D&D game." } ]

{ "AcceptedAnswerId": null, "CommentCount": "2", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-09T20:51:02.693", "Id": "265889", "Score": "2", "Tags": [ "python" ], "Title": "Maze generator for Dungeons and Dragons" }

[ { "body": "<blockquote>\n<p>My reason for creating this script is so that I can eventually randomize it to create a random generated map for my D&amp;D campaign that is somewhat original compared to just taking a map off the internet.</p>\n</blockquote>\n<p>Given that you want to eventually make a random map, your current approach won't work. You're just using hardcoded values, and there is no way to &quot;randomize&quot; it without fundamentally re-writing it.</p>\n<ul>\n<li>The first change I would recommend is separate the data out. This makes the program shorter, clearer, and easier to change to add something like randomness</li>\n</ul>\n<pre><code>#Create dungeon floor\npyautogui.moveTo(329,807)\npyautogui.mouseDown(329,807)\npyautogui.moveRel(100,-75)\npyautogui.mouseUp()\n\nlines = [\n ((-25, 0), (-50, 50)),\n ((-100,0), (250,-125))\n ((0,100), (50,25)),\n ((0,100), (100,-125)),\n ((0,0), (-25,-50)),\n ((-75,0), (175,-100)),\n ((0,0), (-25,-50)),\n ((25,0), (-225,-125)),\n]\n\nfor down, up in lines:\n pyautogui.moveRel(*down)\n pyautogui.mouseDown()\n pyautogui.moveRel(*up)\n pyautogui.mouseUp()\n</code></pre>\n<ul>\n<li>Work in absolute coordinates, not relative ones. It will make things easier for random dungeons.</li>\n<li>Add comments. Does a particular mouse movement draw a room? Does it draw a line bordering a room? I have literally no idea. In this case, move movement is so opaque it will be useful for you as well, not just other readers.</li>\n<li>As a warning, the whole idea of scripting a dungeon generation program may not be worth it. What happens if you want a map that's bigger than your screen resolution? If you just output your own image directly, it will be easier than scripting in some ways.</li>\n</ul>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-09T23:17:20.757", "Id": "525199", "Score": "0", "body": "Yes this is perfect and what I was looking for something along these lines (pun intended)! In a all seriousness though I do recognize the limitations of working with a limited amount of screen space right now and was heading in the direction you just explained. Adding the lines like that should really help. As for the limited map spacing, I was planning on just creating multiple that could possibly connected if I wrote in some kind of connection point to be in that would carry over into the next map. This is a great start for me though and I really do appreciate the time you took to answer" } ], "meta_data": { "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-09T23:07:19.260", "Id": "265891", "ParentId": "265889", "Score": "1" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-10T15:08:18.167", "Id": "525249", "Score": "2", "body": "Your `data.split(\"\\n\")[1].split(\" \")[9]` operation extracts the 10th space-separated word from the second line of `data`. We can't tell how robust that extraction process is without seeing what the sensor returns. Could you provide a sample of the actual data that gets returned from the sensor?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-11T14:20:24.947", "Id": "525313", "Score": "0", "body": "@AJNeufeld - thanks for info; this is data extracted for temperature = 23. First example is data = `70 01 55 05 7f a5 81 66 3d : crc=3d YES\n70 01 55 05 7f a5 81 66 3d t=23000\n` and this is tempData \n`t=23000`" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-12T01:19:27.617", "Id": "525373", "Score": "0", "body": "I’ve added the sample data to the question post. Please confirm it was formatted properly, by editing it if it was not." } ]

{ "AcceptedAnswerId": null, "CommentCount": "3", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-10T14:00:33.267", "Id": "265914", "Score": "5", "Tags": [ "python-3.x" ], "Title": "Temperature Sensor that loop and turns on cooling" }

[ { "body": "<p>I'm going to assume that your device has a <code>sysfs</code> interface identical to that described in <a href=\"https://albertherd.com/2019/01/20/using-c-to-monitor-temperatures-through-your-ds18b20-thermal-sensor-raspberry-pi-temperature-monitoring-part-3/\" rel=\"noreferrer\">this guide</a>, which based on your code is likely the case.</p>\n<blockquote>\n<p>How can I use &quot;Temperature&quot; as a global variable</p>\n</blockquote>\n<p>is the opposite direction to what you should do. Currently <em>all</em> of your code is global, but you should put some effort into making it re-entrant.</p>\n<p>Other than your global code, one thing that stands out is the non-guaranteed <code>close</code> call, which should be replaced by a <code>with</code> statement.</p>\n<p>You should not need to <code>read()</code> the entire file. Instead, read line-by-line until you find a match.</p>\n<pre><code> if temperature &gt; 24: #change this value to adjust the 'too hot' threshold\n tempLed.value = True\n else: \n tempLed.value = False\n</code></pre>\n<p>should be reduced to</p>\n<pre><code>temp_led.value = temperature &gt; threshold\n</code></pre>\n<p>where <code>threshold</code> is a parameter instead of being hard-coded, and the variable names are PEP8-compliant.</p>\n<pre><code>except KeyboardInterrupt:\n digitalio.cleanup() \n print (&quot;Program Exited Cleanly&quot;)\n</code></pre>\n<p>should instead be</p>\n<pre><code>except KeyboardInterrupt:\n pass\nfinally:\n digitalio.cleanup() \n print (&quot;Program Exited Cleanly&quot;)\n</code></pre>\n<p>In other words, you should clean up regardless of why and how the program exited.</p>\n<p>Don't hard-code the device ID - if you can assume that there's only one such sensor, use glob-matching instead.</p>\n<h2>Suggested (not tested)</h2>\n<pre class=\"lang-py prettyprint-override\"><code>class TempSensor:\n def __init__(self):\n sensor = digitalio.DigitalInOut(D14) # Temp sensor DS18B20 as configured in terminal\n sensor.switch_to_input(pull=digitalio.Pull.UP)\n sensor.pull = digitalio.Pull.UP\n\n parent, = Path('/sys/bus/w1/devices/').glob('28-*')\n self.path = parent / 'w1_slave'\n\n def read(self) -&gt; float:\n with self.path.open() as f:\n for line in f:\n parts = line.split('t=', 1)\n if len(parts) == 2:\n return float(parts[1].rstrip()) / 1000\n raise ValueError('Temperature not found')\n\n\ndef polling_loop(interval: float=1, threshold: float=24) -&gt; None:\n sensor = TempSensor()\n led = digitalio.DigitalInOut(D17) # PIN LED for too hot sensor. \n led.direction = digitalio.Direction.OUTPUT\n\n while True:\n temperature = sensor.read()\n print(temperature)\n led.value = temperature &gt; threshold\n time.sleep(interval)\n\n\ndef main() -&gt; None:\n try:\n polling_loop()\n except KeyboardInterrupt:\n pass\n finally:\n digitalio.cleanup() \n print(&quot;Program Exited Cleanly&quot;)\n\nif __name__ == '__main__':\n main()\n</code></pre>\n", "comments": [], "meta_data": { "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-10T16:14:58.777", "Id": "265919", "ParentId": "265914", "Score": "10" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-11T16:40:47.557", "Id": "525343", "Score": "0", "body": "Is there a reason you don't use [`type=argparse.FileType(\"r\")`](https://docs.python.org/3.9/library/argparse.html#argparse.FileType) to get automatic handling of '-' as a command line argument?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-11T20:03:42.133", "Id": "525356", "Score": "0", "body": "@RootTwo Because I didn't know that exists. This is exactly why I asked this question: I wanted someone to tell me I was working too hard. Although I don't quite see how to close the file without closing `stdin`/`stdout` if a `-` was passed..." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-11T20:13:51.897", "Id": "525357", "Score": "0", "body": "@RootTwo I'm not going to use that, though, see https://bugs.python.org/issue13824 . In particular, \"FileType is not what you want for anything but quick scripts that can afford to either leave a file open or to close stdin and/or stdout.\" I don't want to do either of those things. However, that thread does have some other solutions I might prefer" } ]

{ "AcceptedAnswerId": "265978", "CommentCount": "3", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-11T04:48:31.650", "Id": "265935", "Score": "0", "Tags": [ "python", "python-3.x" ], "Title": "argfile: read/write stdio or specified file depending on command line argument" }

[ { "body": "<p>The code can be simplified using the <code>contextlib.contextmanager</code> decorator:</p>\n<pre><code>from contextlib import contextmanager\n\n@contextmanager\ndef argfile(default: IO, filename: str, mode: str = 'r'):\n file_like = open(filename, mode) if filename != '-' else default\n yield file_like\n if filename != '-':\n file_like.close()\n</code></pre>\n<p>Use it the same way as your code.</p>\n<p>Is <code>default</code> ever anything other than <code>stdin</code> or <code>stdout</code>? If not, then maybe something like:</p>\n<pre><code>@contextmanager\ndef argfile(filename: str, mode: str = 'r'):\n\n if filename != '-' :\n file_like = open(filename, mode)\n\n else:\n file_like = sys.stdin if mode == 'r' else sys.stdout\n\n yield file_like\n\n if filename != '-':\n file_like.close()\n</code></pre>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-13T01:08:27.467", "Id": "525436", "Score": "0", "body": "I ended up using a modification of the second version which is `if filename == '-': yield sys.stdout if mode == 'w' else sys.stdin; else: with open(...) as f: yield f`, which is a bit shorter and nicer IMO" } ], "meta_data": { "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-12T05:34:16.303", "Id": "265978", "ParentId": "265935", "Score": "1" } } ]

[]

{ "AcceptedAnswerId": "266030", "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-11T20:23:57.220", "Id": "265968", "Score": "0", "Tags": [ "python", "pandas" ], "Title": "add column with count by constraint" }

[ { "body": "<p>Sorry, this is not a complete solution, just an idea.</p>\n<p>In Pandas you can split a data frame in subgroups based on one or multiple grouping variables using the <code>groupby</code> method. You can then apply an operation (in this case <code>nunique</code>) to each of the subgroups:</p>\n<pre class=\"lang-py prettyprint-override\"><code>df.groupby(['racecourse', 'going', 'distance', 'runners'])['id'].nunique()\n</code></pre>\n<p>This should give you the number of races with the same characteristics (racecourse, going, ...) but unique values for <code>id</code>.</p>\n<p>Most importantly, this should be much faster than looping over the rows, especially for larger data frames.</p>\n<hr />\n<p><strong>EDIT:</strong></p>\n<p>Here's a complete solution also including the combination with the original data frame (thanks to <em>ojdo</em> for suggesting <code>join</code>/<code>merge</code>)</p>\n<pre class=\"lang-py prettyprint-override\"><code>race_count = df.groupby(['racecourse', 'going', 'distance', 'runners'])['id'].nunique()\nrace_count.name = 'race_count'\ndf.merge(race_count, on=['racecourse', 'going', 'distance', 'runners'])\n</code></pre>\n<p>Conveniently, <code>merge</code> broadcasts the values in <code>race_count</code> to all rows of <code>df</code> based on the values in the columns specified by the <code>on</code> parameter.</p>\n<p>This outputs:</p>\n<pre><code> id racecourse going distance runners draw draw_bias race_count \n0 253375 178 Standard 7.0 13 2 0.50 1 \n1 253375 178 Standard 7.0 13 11 0.25 1 \n2 253375 178 Standard 7.0 13 12 1.00 1 \n3 253376 178 Standard 6.0 12 2 1.00 1 \n4 253376 178 Standard 6.0 12 8 0.50 1 \n5 4802789 192 Standard 7.0 16 11 0.50 2 \n6 4802789 192 Standard 7.0 16 16 0.10 2 \n7 4802790 192 Standard 7.0 16 1 0.25 2 \n8 4802790 192 Standard 7.0 16 3 0.50 2 \n9 4802790 192 Standard 7.0 16 8 1.00 2 \n</code></pre>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-13T12:49:19.880", "Id": "525449", "Score": "1", "body": "And to complete this thought, the remaining step \"combine\", simply set the index of this result to the desired column, and `join` it with the original. (The general pattern is called [split-apply-combine](https://pandas.pydata.org/pandas-docs/stable/user_guide/groupby.html?highlight=split%20apply%20combine#), and is often a good way to express operations.)" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-13T13:05:57.290", "Id": "525450", "Score": "0", "body": "Yes, good call. To be honest, I had problems coming up with a good implementation for combining the results (number of unique elements) with the original data frame `df`." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-14T14:11:18.747", "Id": "525495", "Score": "0", "body": "This is fantastic, exactly what I needed. Thank you very much and may the force continue to be with you " }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-21T03:41:52.880", "Id": "528825", "Score": "1", "body": "You can do this directly with [`groupby transform`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.core.groupby.DataFrameGroupBy.transform.html) instead of needing `merge` at all -> `df['race_count'] = df.groupby(['racecourse', 'going', 'distance', 'runners'])['id'].transform('nunique')`" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-22T14:44:56.287", "Id": "528946", "Score": "0", "body": "@Henry Ecker: Nice solution, very elegant and concise. I did not know about the `groupby transform` method. Cool!" } ], "meta_data": { "CommentCount": "5", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-13T11:34:48.490", "Id": "266030", "ParentId": "265968", "Score": "2" } } ]

[]

{ "AcceptedAnswerId": "266030", "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-11T20:23:57.220", "Id": "265968", "Score": "0", "Tags": [ "python", "pandas" ], "Title": "add column with count by constraint" }

[ { "body": "<p>Sorry, this is not a complete solution, just an idea.</p>\n<p>In Pandas you can split a data frame in subgroups based on one or multiple grouping variables using the <code>groupby</code> method. You can then apply an operation (in this case <code>nunique</code>) to each of the subgroups:</p>\n<pre class=\"lang-py prettyprint-override\"><code>df.groupby(['racecourse', 'going', 'distance', 'runners'])['id'].nunique()\n</code></pre>\n<p>This should give you the number of races with the same characteristics (racecourse, going, ...) but unique values for <code>id</code>.</p>\n<p>Most importantly, this should be much faster than looping over the rows, especially for larger data frames.</p>\n<hr />\n<p><strong>EDIT:</strong></p>\n<p>Here's a complete solution also including the combination with the original data frame (thanks to <em>ojdo</em> for suggesting <code>join</code>/<code>merge</code>)</p>\n<pre class=\"lang-py prettyprint-override\"><code>race_count = df.groupby(['racecourse', 'going', 'distance', 'runners'])['id'].nunique()\nrace_count.name = 'race_count'\ndf.merge(race_count, on=['racecourse', 'going', 'distance', 'runners'])\n</code></pre>\n<p>Conveniently, <code>merge</code> broadcasts the values in <code>race_count</code> to all rows of <code>df</code> based on the values in the columns specified by the <code>on</code> parameter.</p>\n<p>This outputs:</p>\n<pre><code> id racecourse going distance runners draw draw_bias race_count \n0 253375 178 Standard 7.0 13 2 0.50 1 \n1 253375 178 Standard 7.0 13 11 0.25 1 \n2 253375 178 Standard 7.0 13 12 1.00 1 \n3 253376 178 Standard 6.0 12 2 1.00 1 \n4 253376 178 Standard 6.0 12 8 0.50 1 \n5 4802789 192 Standard 7.0 16 11 0.50 2 \n6 4802789 192 Standard 7.0 16 16 0.10 2 \n7 4802790 192 Standard 7.0 16 1 0.25 2 \n8 4802790 192 Standard 7.0 16 3 0.50 2 \n9 4802790 192 Standard 7.0 16 8 1.00 2 \n</code></pre>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-13T12:49:19.880", "Id": "525449", "Score": "1", "body": "And to complete this thought, the remaining step \"combine\", simply set the index of this result to the desired column, and `join` it with the original. (The general pattern is called [split-apply-combine](https://pandas.pydata.org/pandas-docs/stable/user_guide/groupby.html?highlight=split%20apply%20combine#), and is often a good way to express operations.)" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-13T13:05:57.290", "Id": "525450", "Score": "0", "body": "Yes, good call. To be honest, I had problems coming up with a good implementation for combining the results (number of unique elements) with the original data frame `df`." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-14T14:11:18.747", "Id": "525495", "Score": "0", "body": "This is fantastic, exactly what I needed. Thank you very much and may the force continue to be with you " }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-21T03:41:52.880", "Id": "528825", "Score": "1", "body": "You can do this directly with [`groupby transform`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.core.groupby.DataFrameGroupBy.transform.html) instead of needing `merge` at all -> `df['race_count'] = df.groupby(['racecourse', 'going', 'distance', 'runners'])['id'].transform('nunique')`" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-22T14:44:56.287", "Id": "528946", "Score": "0", "body": "@Henry Ecker: Nice solution, very elegant and concise. I did not know about the `groupby transform` method. Cool!" } ], "meta_data": { "CommentCount": "5", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-13T11:34:48.490", "Id": "266030", "ParentId": "265968", "Score": "2" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-13T18:27:22.783", "Id": "525474", "Score": "2", "body": "This is too hypothetical to be on-topic, unfortunately." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-14T18:00:05.593", "Id": "525505", "Score": "0", "body": "If you're not using the result of a list comprehension, it's a huge clue that there's a far clearer way to write your program. In this case, you should be using an imperative-style `for` loop instead." } ]

{ "AcceptedAnswerId": "266041", "CommentCount": "2", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-13T16:58:51.493", "Id": "266039", "Score": "1", "Tags": [ "python" ], "Title": "Updating python dictionary in a loop" }

[ { "body": "<p>Your suspicions are correct, this is called using comprehension syntax for side-effects, and is normally bad practice.</p>\n<p>A better way to do this is with a <code>for</code> loop</p>\n<pre class=\"lang-py prettyprint-override\"><code>for item in x:\n # this also gets rid of your random number list\n item['key3'] = random.random()\n</code></pre>\n", "comments": [], "meta_data": { "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-13T17:21:21.390", "Id": "266041", "ParentId": "266039", "Score": "8" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-13T18:27:22.783", "Id": "525474", "Score": "2", "body": "This is too hypothetical to be on-topic, unfortunately." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-14T18:00:05.593", "Id": "525505", "Score": "0", "body": "If you're not using the result of a list comprehension, it's a huge clue that there's a far clearer way to write your program. In this case, you should be using an imperative-style `for` loop instead." } ]

{ "AcceptedAnswerId": "266041", "CommentCount": "2", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-13T16:58:51.493", "Id": "266039", "Score": "1", "Tags": [ "python" ], "Title": "Updating python dictionary in a loop" }

[ { "body": "<p>Your suspicions are correct, this is called using comprehension syntax for side-effects, and is normally bad practice.</p>\n<p>A better way to do this is with a <code>for</code> loop</p>\n<pre class=\"lang-py prettyprint-override\"><code>for item in x:\n # this also gets rid of your random number list\n item['key3'] = random.random()\n</code></pre>\n", "comments": [], "meta_data": { "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-13T17:21:21.390", "Id": "266041", "ParentId": "266039", "Score": "8" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-17T21:09:06.563", "Id": "525712", "Score": "2", "body": "Can you provide extra examples of expected input and output?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-18T13:01:00.000", "Id": "525752", "Score": "2", "body": "Your current wording is unclear. You ask how to find the number of adjacent elements, but then show an implementation. Is this implementation working?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-18T14:00:05.077", "Id": "525760", "Score": "0", "body": "So if I understand correctly, you are looking for the count of unique letters that are not equal to your target letter, after making a list of all neighbors of all instances of that target letter?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-18T17:09:06.970", "Id": "525781", "Score": "0", "body": "@Flater Yes, and also it should not be equal to '.'" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-18T17:29:37.540", "Id": "525788", "Score": "0", "body": "What is this code actually supposed to be doing? Is there a problem that this solves? I think that might help clear up what's going on" } ]

{ "AcceptedAnswerId": "266153", "CommentCount": "5", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-17T14:57:58.870", "Id": "266135", "Score": "-4", "Tags": [ "python" ], "Title": "How to find adjacent elements in multidimensional list in Python?" }

[ { "body": "<ul>\n<li>To be honest, I can't quite confirm what you actually want. Since you ask in <code>Code Review</code>, I assume you want someone to review your code and give some advice.</li>\n</ul>\n<h3>advice</h3>\n<ol>\n<li>Please always use meaningful name to variable and function name, don't use something like <code>a</code>, <code>b</code>, <code>x</code>, <code>y</code>, <code>f</code>. They are confusing to the people who read your code. When you read the code and following advice, you will find it. It is OK use <code>i</code>, <code>j</code> in some simple loop. So I replaced most of them, some of them may be not so proper.</li>\n<li>There is no need to record the adjacent elements in <code>ls</code>(result), just <code>+1</code> to the result of <code>f</code>(find_adjacent_elements).</li>\n<li>There is also no need to check the whole <code>l</code>(map), just check the <code>z</code>(base_char) up\\down\\left\\right 4 direction. It can speed up your code especially the size of map is huge.</li>\n<li>Please read <a href=\"https://www.python.org/dev/peps/pep-0008/\" rel=\"nofollow noreferrer\">PEP-8</a>, it can make your code more readable. Such as <code>a=e[0]</code> should be <code>a = e[0]</code>.</li>\n<li>I fix some other small issues, please check the difference between my code and your code.</li>\n</ol>\n<h3>fixed code:</h3>\n<pre><code>def find_adjacent_elements(base_pos):\n result = 0\n directions = [[1,0],[-1,0],[0,1],[0,-1]]\n for direction in directions:\n try:\n adjacent_element = map[base_pos[0] + direction[0]][base_pos[1] + direction[1]]\n if adjacent_element != base_char and adjacent_element != &quot;.&quot;:\n result += 1\n except IndexError:\n pass\n return result\n \nprint(&quot;please input the columns,rows and base character&quot;)\ncolumns,rows,base_char = input().split()\nmap = []\nbase_char_pos = []\ncolumns,rows = int(columns),int(rows)\nfor i in range(columns):\n map_line = list(input())\n for j in range(rows):\n if base_char == map_line[j]:\n base_char_pos.append([i,j])\n map.append(map_line)\nans = 0\nfor i in range(len(base_char_pos)):\n ans = max(ans,find_adjacent_elements(base_char_pos[i]))\nprint(ans)\n</code></pre>\n<h3>test:</h3>\n<pre><code>please input the columns,rows and base character\n4 4 R\n..A.\n.BRC\n.DRE\n..F.\n\n3\n\nplease input the columns,rows and base character\n2 2 R\nR.\n.R\n\n0\n\nplease input the columns,rows and base character\n3 2 W\nOO\nWW\nWW\n\n1\n\nplease input the columns,rows and base character\n3 4 R\nG.B.\n.RR.\nTTT.\n\n2\n</code></pre>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-18T09:17:24.567", "Id": "525737", "Score": "0", "body": "Thank you very much for your advice, I will keep those points in mind . I understood how you just checked the positions around the base character made it more efficient. Thanks for taking out your time and helping me!" } ], "meta_data": { "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-18T07:27:49.380", "Id": "266153", "ParentId": "266135", "Score": "2" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-20T12:12:09.123", "Id": "525947", "Score": "0", "body": "I get an error when running your code `NameError: name 'main' is not defined` before the expected messages `main() is already running - couldn't lock it` appear. I think your code is more suited to StackOverflow and not Code Review. Thanks." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-20T15:15:22.863", "Id": "525963", "Score": "0", "body": "@C.Harley that's because `main` is a stand-in for whatever my code is supposed to do, is irrelevant to the question, and is therefore not defined in the example. My real main function is very large" } ]

{ "AcceptedAnswerId": "266225", "CommentCount": "2", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-19T22:58:39.433", "Id": "266224", "Score": "2", "Tags": [ "python", "python-3.x" ], "Title": "Python Service with USR1 kill signal handler" }

[ { "body": "<p>Your basic code looks fine, but you may encounter one issue if you start doing more complex work.</p>\n<p>Signals are handled in a different context to the context your program is normally executing in - the OS can suspend your program at any time, while it's running or not, to run a signal handler which then may execute more code from your program (if it's a signal for your process).</p>\n<p>This problem gives rise to the concept of &quot;reentrant functions&quot; which can safely have one thread suspended half way through execution, and have another thread enter it and run - without say, stomping on shared global variables or static allocations. There are surprisingly few reentrant functions in the C standard library, and POSIX libraries - see <a href=\"https://man7.org/linux/man-pages/man7/signal-safety.7.html\" rel=\"nofollow noreferrer\">https://man7.org/linux/man-pages/man7/signal-safety.7.html</a> for more information and a list.</p>\n<p>Expect seriously weird bugs or crashes if you call non-reentrant functions from the signal handler context.</p>\n<p>A safer way of handling this is to have the signal handler set a flag in your program when it's called. A daemon thread in your program can poll this flag and run in your program's regular context, when desired.</p>\n<p>Very naïve pseudocode:</p>\n<pre><code>ShouldRun = False\n\nfunc HandleSigUsr1:\n ShouldRun = True\n \nfunc HandleSigUsr1Daemon:\n while (1):\n if ShouldRun == True:\n ShouldRUn = False\n run_main()\n\nsignal.Signal(SIGUSR1, handleSigUsr1)\n</code></pre>\n<p>A slightly more powerful implementation could sleep for a short time (0.001s? 0.01s?) between daemon loops to avoid constantly sucking up CPU time, or poll a file descriptor rather than a variable, to have the OS sleep the daemon until there's new content.</p>\n<p>As a final disclaimer, I'm not sure if Python's signal handling library already does something like this under the hood - it seems like the kind of detail a high level language and runtime like Python would try to hide.</p>\n", "comments": [], "meta_data": { "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-20T01:04:37.600", "Id": "266225", "ParentId": "266224", "Score": "3" } } ]

[]

{ "AcceptedAnswerId": "266257", "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-20T17:41:40.307", "Id": "266250", "Score": "1", "Tags": [ "python-3.x" ], "Title": "create script to convert array to string with array elements uniquely with randomness" }

[ { "body": "<h2>Performance</h2>\n<p>Since <a href=\"https://stackoverflow.com/q/38722105/9997212\">f-strings are faster than string concatenation</a>, you can replace</p>\n<pre class=\"lang-py prettyprint-override\"><code>score_string = score_string + ',' + str(score_array.pop(i))\n</code></pre>\n<p>with</p>\n<pre><code>score_string = score_string + f',{score_array.pop(i)}'\n</code></pre>\n<hr />\n<p>Since <a href=\"https://docs.python.org/3/library/stdtypes.html#mutable-sequence-types\" rel=\"nofollow noreferrer\"><code>pop</code></a> removes an element from a list given an index and returns it, you can simplify</p>\n<pre class=\"lang-py prettyprint-override\"><code>score_string = score_string + ',' + str(score_array[i])\ndel score_array[i]\n</code></pre>\n<p>to</p>\n<pre class=\"lang-py prettyprint-override\"><code>score_string = score_string + ',' + str(score_array.pop(i))\n</code></pre>\n<h2>Best practices</h2>\n<p>Since <a href=\"https://docs.python.org/3/library/functions.html#func-range\" rel=\"nofollow noreferrer\"><code>range</code></a> creates a iterable once in the iteration, you can replace</p>\n<pre class=\"lang-py prettyprint-override\"><code>loopidx = 0\nscore_index_len = len(score_array)\n\nwhile loopidx &lt; score_index_len:\n ...\n\n loopidx = loopidx + 1 \n</code></pre>\n<p>with</p>\n<pre class=\"lang-py prettyprint-override\"><code>for loopidx in range(len(score_array)):\n ...\n</code></pre>\n<hr />\n<p>Since <a href=\"https://docs.python.org/3/library/random.html#random.randint\" rel=\"nofollow noreferrer\"><code>randint</code></a> is an alias for <code>randrange(a, b+1)</code>, you can simplify</p>\n<pre class=\"lang-py prettyprint-override\"><code>i = randint(0, len(score_array)-1)\n</code></pre>\n<p>to</p>\n<pre class=\"lang-py prettyprint-override\"><code>i = randrange(len(score_array))\n</code></pre>\n<hr />\n<p>Just for readability, you could replace</p>\n<pre class=\"lang-py prettyprint-override\"><code>score_string = score_string + f',{score_array.pop(i)}'\n</code></pre>\n<p>with</p>\n<pre class=\"lang-py prettyprint-override\"><code>score_string += f',{score_array.pop(i)}'\n</code></pre>\n<hr />\n<p>To avoid using <code>[1:]</code> when returning, you could create a new list and use <a href=\"https://docs.python.org/3/library/stdtypes.html#str.join\" rel=\"nofollow noreferrer\"><code>str.join</code></a>:</p>\n<pre class=\"lang-py prettyprint-override\"><code>scores = []\nfor loopidx in range(len(score_array)):\n i = randrange(len(score_array))\n scores.append(f'{score_array.pop(i)}')\n \nreturn ','.join(scores)\n</code></pre>\n<h3>Refactored code:</h3>\n<pre class=\"lang-py prettyprint-override\"><code>def myscore():\n score_array = array.array('i',[0,1,2,3,4])\n \n scores = []\n for loopidx in range(len(score_array)):\n i = randrange(len(score_array))\n scores.append(f'{score_array.pop(i)}')\n\n return ','.join(scores)\n</code></pre>\n<h2>Alternative</h2>\n<p>A simpler alternative is just use <a href=\"https://docs.python.org/3/library/random.html#random.shuffle\" rel=\"nofollow noreferrer\"><code>shuffle</code></a>:</p>\n<pre class=\"lang-py prettyprint-override\"><code>def myscore():\n score_array = array.array('i',[0,1,2,3,4])\n shuffle(score_array)\n return ','.join(map(str, score_array))\n</code></pre>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-22T17:39:56.897", "Id": "526053", "Score": "0", "body": "I would argue that if you need the index out of each iteration you should use enumerate as its more idiomatic:" } ], "meta_data": { "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-21T03:30:13.717", "Id": "266257", "ParentId": "266250", "Score": "3" } } ]

[]

{ "AcceptedAnswerId": "266257", "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-20T17:41:40.307", "Id": "266250", "Score": "1", "Tags": [ "python-3.x" ], "Title": "create script to convert array to string with array elements uniquely with randomness" }

[ { "body": "<h2>Performance</h2>\n<p>Since <a href=\"https://stackoverflow.com/q/38722105/9997212\">f-strings are faster than string concatenation</a>, you can replace</p>\n<pre class=\"lang-py prettyprint-override\"><code>score_string = score_string + ',' + str(score_array.pop(i))\n</code></pre>\n<p>with</p>\n<pre><code>score_string = score_string + f',{score_array.pop(i)}'\n</code></pre>\n<hr />\n<p>Since <a href=\"https://docs.python.org/3/library/stdtypes.html#mutable-sequence-types\" rel=\"nofollow noreferrer\"><code>pop</code></a> removes an element from a list given an index and returns it, you can simplify</p>\n<pre class=\"lang-py prettyprint-override\"><code>score_string = score_string + ',' + str(score_array[i])\ndel score_array[i]\n</code></pre>\n<p>to</p>\n<pre class=\"lang-py prettyprint-override\"><code>score_string = score_string + ',' + str(score_array.pop(i))\n</code></pre>\n<h2>Best practices</h2>\n<p>Since <a href=\"https://docs.python.org/3/library/functions.html#func-range\" rel=\"nofollow noreferrer\"><code>range</code></a> creates a iterable once in the iteration, you can replace</p>\n<pre class=\"lang-py prettyprint-override\"><code>loopidx = 0\nscore_index_len = len(score_array)\n\nwhile loopidx &lt; score_index_len:\n ...\n\n loopidx = loopidx + 1 \n</code></pre>\n<p>with</p>\n<pre class=\"lang-py prettyprint-override\"><code>for loopidx in range(len(score_array)):\n ...\n</code></pre>\n<hr />\n<p>Since <a href=\"https://docs.python.org/3/library/random.html#random.randint\" rel=\"nofollow noreferrer\"><code>randint</code></a> is an alias for <code>randrange(a, b+1)</code>, you can simplify</p>\n<pre class=\"lang-py prettyprint-override\"><code>i = randint(0, len(score_array)-1)\n</code></pre>\n<p>to</p>\n<pre class=\"lang-py prettyprint-override\"><code>i = randrange(len(score_array))\n</code></pre>\n<hr />\n<p>Just for readability, you could replace</p>\n<pre class=\"lang-py prettyprint-override\"><code>score_string = score_string + f',{score_array.pop(i)}'\n</code></pre>\n<p>with</p>\n<pre class=\"lang-py prettyprint-override\"><code>score_string += f',{score_array.pop(i)}'\n</code></pre>\n<hr />\n<p>To avoid using <code>[1:]</code> when returning, you could create a new list and use <a href=\"https://docs.python.org/3/library/stdtypes.html#str.join\" rel=\"nofollow noreferrer\"><code>str.join</code></a>:</p>\n<pre class=\"lang-py prettyprint-override\"><code>scores = []\nfor loopidx in range(len(score_array)):\n i = randrange(len(score_array))\n scores.append(f'{score_array.pop(i)}')\n \nreturn ','.join(scores)\n</code></pre>\n<h3>Refactored code:</h3>\n<pre class=\"lang-py prettyprint-override\"><code>def myscore():\n score_array = array.array('i',[0,1,2,3,4])\n \n scores = []\n for loopidx in range(len(score_array)):\n i = randrange(len(score_array))\n scores.append(f'{score_array.pop(i)}')\n\n return ','.join(scores)\n</code></pre>\n<h2>Alternative</h2>\n<p>A simpler alternative is just use <a href=\"https://docs.python.org/3/library/random.html#random.shuffle\" rel=\"nofollow noreferrer\"><code>shuffle</code></a>:</p>\n<pre class=\"lang-py prettyprint-override\"><code>def myscore():\n score_array = array.array('i',[0,1,2,3,4])\n shuffle(score_array)\n return ','.join(map(str, score_array))\n</code></pre>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-22T17:39:56.897", "Id": "526053", "Score": "0", "body": "I would argue that if you need the index out of each iteration you should use enumerate as its more idiomatic:" } ], "meta_data": { "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-21T03:30:13.717", "Id": "266257", "ParentId": "266250", "Score": "3" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-24T21:22:27.627", "Id": "526206", "Score": "2", "body": "Please do not update the code in your question to incorporate feedback from answers, doing so goes against the Question + Answer style of Code Review. This is not a forum where you should keep the most updated version in your question. Please see *[what you may and may not do after receiving answers](http://meta.codereview.stackexchange.com/a/1765)*." } ]

{ "AcceptedAnswerId": "266330", "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-23T01:51:07.367", "Id": "266308", "Score": "0", "Tags": [ "python", "python-3.x", "json", "apache-kafka" ], "Title": "OOP Refactoring" }

[ { "body": "<h1><code>_col_type</code></h1>\n<p>You can use a generator expression here to return either the first match or <code>None</code>:</p>\n<pre class=\"lang-py prettyprint-override\"><code> # go from this\n def _col_type(self, column_name):\n for column in self.fields:\n if column[&quot;name&quot;] == column_name:\n return column\n return None\n\n # to this\n def _col_type(self, column_name):\n return next((\n col['name'] for col in self.fields if col['name'] == column_name\n ), None)\n</code></pre>\n<h1>Checking types</h1>\n<p>Use <code>isinstance</code> rather than <code>type(val) == cls</code>:</p>\n<pre class=\"lang-py prettyprint-override\"><code># instead of this\nif type(field[&quot;type&quot;]) == list:\n # do something\n# or this\nif type(val) is dict:\n # do something\n\n# do this instead\nif isinstance(field['type'], list):\n # do something\n\n# or\nif isinstance(field_type, (dict, avro.schema.ImmutableDict)):\n # do something\n</code></pre>\n<h1>When to use lambda vs function</h1>\n<p>In this statement:</p>\n<pre class=\"lang-py prettyprint-override\"><code>list(map(lambda x: self._field_type_converter(x), field_type))\n</code></pre>\n<p>You don't actually need the lambda:</p>\n<pre class=\"lang-py prettyprint-override\"><code>list(map(self._field_type_converter, field_type))\n</code></pre>\n", "comments": [], "meta_data": { "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-23T16:09:42.077", "Id": "266330", "ParentId": "266308", "Score": "1" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-25T07:24:09.687", "Id": "526216", "Score": "1", "body": "Hey welcome to Code Review! It looks like your linked Stack Overflow post contains the actual code you want reviewed and what you've posted here is just the alternative code if you were doing it by hand is that right? In that case you actually need to post the code you want reviewed here rather than linking to it. Also edit your post to say _why_ you want this at all, what problem does it solve? That will provide the necessary context to say whether your solution is suitable and how it might be improved." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-25T07:41:24.270", "Id": "526220", "Score": "0", "body": "(The *something* most *similar* to *bellow* should be to *bark*…?!;)" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-25T08:47:21.653", "Id": "526226", "Score": "0", "body": "@Greedo I'm not sure which one is better approach. I added an example to clarify idea." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-25T08:49:59.677", "Id": "526227", "Score": "0", "body": "@greybeard oh, well. Thanks for catching this. I added missing noun." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-25T12:01:54.750", "Id": "526241", "Score": "1", "body": "Code review is for code that you wrote and that you know is working. This question seems to indicate that someone else wrote the code and that you don't have it working the way you want to yet." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-25T14:59:01.423", "Id": "526259", "Score": "0", "body": "@pacmaninbw that's wrong assumption." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-25T15:04:24.250", "Id": "526260", "Score": "0", "body": "Also, why it was marked as off-topic. Could someone explain please?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-25T15:09:13.160", "Id": "526261", "Score": "0", "body": "Here is the [help page for on-topic questions](https://codereview.stackexchange.com/help/on-topic)." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-25T15:11:14.820", "Id": "526262", "Score": "0", "body": "5 people closed the question, however, the moderator changed the reason for closure and became the only person to close the question (makes 6 people that closed the question)." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-25T15:11:39.923", "Id": "526263", "Score": "0", "body": "Let us [continue this discussion in chat](https://chat.stackexchange.com/rooms/128933/discussion-between-su1tan-and-pacmaninbw)." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-25T20:45:19.180", "Id": "526283", "Score": "0", "body": "(It's rather that `bellow` isn't anything like the opposite of *above* - *below* is.)" } ]

{ "AcceptedAnswerId": "266375", "CommentCount": "11", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-25T06:35:50.140", "Id": "266370", "Score": "1", "Tags": [ "python", "reinventing-the-wheel" ], "Title": "Implementing conditional execution in Python" }

[ { "body": "<p><strong>Bitwise Operators</strong></p>\n<p>While your use of bitwise operators works fine as far as I can tell, I wouldn't expect them to be used like this in Python. So instead of</p>\n<pre><code>if ((a == &quot;boo&quot;) &amp; ((c == 2) | (b == 3))):\n</code></pre>\n<p>I'd prefer</p>\n<pre><code>if a == &quot;boo&quot; and (c == 2 or b == 3):\n</code></pre>\n<p>Also note that you don't need as many parantheses.</p>\n<hr />\n<p><strong><code>processed = True</code></strong></p>\n<pre><code>if boo(a, c):\n processed = True\n</code></pre>\n<p>can be replaced by</p>\n<pre><code>processed = boo(a, c)\n</code></pre>\n<p>as long as <code>boo</code> (or any other relevant function) returns a <code>bool</code>. If it returns something else you can convert it to a <code>bool</code> explicitly:</p>\n<pre><code>processed = bool(boo(a, c))\n</code></pre>\n<hr />\n<p><strong>EDIT:</strong></p>\n<ul>\n<li>You do not need <code>matched</code>, simply use an <code>if - elif - else</code>-construct</li>\n<li>You <em>can</em> replace <code>processed</code> by storing the matching function call in a variable. I'm not sure if you should though.</li>\n</ul>\n<pre><code>from functools import partial\n\n\ndef setup(a, b, c):\n function_call = lambda: False\n\n if a == &quot;boo&quot; and c == 1:\n function_call = partial(boo, a, c) # alt: lambda: boo(a, c)\n elif a == &quot;boo&quot; and (c == 2 or b == 3):\n function_call = partial(foo, a, b, c) # alt: lambda: foo(a, b, c)\n else:\n logger.warning(&quot;Couldn't match any rule&quot;)\n\n return bool(function_call())\n</code></pre>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-25T09:57:57.500", "Id": "526233", "Score": "0", "body": "thanks! But there is a problem: I don't want to be dependent on inner function implementation. Also, if I want to track matches together with function return? Adding more `matched = True` in each step? (sorry, for not being more specific at the beginning)" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-25T11:32:06.593", "Id": "526239", "Score": "0", "body": "I updated my original question with your proposal. But the code is not as DRY as it could be..." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-25T11:46:04.233", "Id": "526240", "Score": "1", "body": "In general, please refrain from editing suggestions from answers into your existing question. Prefer posting a new question with the updated code. I've included some pointers for decreasing repetition in your edited code." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-25T12:06:42.327", "Id": "526242", "Score": "0", "body": "Thanks for `partial` hint!" } ], "meta_data": { "CommentCount": "4", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-25T09:25:32.370", "Id": "266375", "ParentId": "266370", "Score": "2" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-26T07:38:44.730", "Id": "526293", "Score": "0", "body": "Do Python implementations typically eliminate tail-calls? If not, you're heading for a stack overflow by using recursion..." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-26T15:21:33.407", "Id": "526328", "Score": "4", "body": "@TobySpeight CPython, the reference implementation, doesn't perform any form of tail call elimination" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-26T16:23:54.723", "Id": "526333", "Score": "2", "body": "See https://tobiaskohn.ch/index.php/2018/08/28/optimising-python-3/ for more information @TobySpeight" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-26T22:47:22.883", "Id": "526347", "Score": "3", "body": "@Jasmijn: It's not just CPython. Guido van Rossum has said that *NO* Python implementation is allowed to eliminate tail calls. So, any implementation that eliminates tail calls is non-compliant, and thus *by definition* not a Python implementation. Therefore, it is impossible that there is a Python implementation that eliminates tail calls, because if it did, it wouldn't be a Python implementation. (Personally, I find that quite insane: not eliminating tail calls is essentially a memory leak, so why would you *force* implementors to leak memory?)" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-27T09:37:10.917", "Id": "526367", "Score": "0", "body": "@JörgWMittag Where do you store traceback information if TCO is allowed? In another stack? Isn't the point that tracebacks are more important than allowing you to use recursion to loop? If you need such levels of recursion you can normally quite easily convert away from an FP approach." } ]

{ "AcceptedAnswerId": "266410", "CommentCount": "5", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-26T06:40:30.310", "Id": "266408", "Score": "10", "Tags": [ "python", "recursion", "collatz-sequence" ], "Title": "My recursive attempt at Collatz Sequence in Python" }

[ { "body": "<p><strong>Formatting / Spacing</strong></p>\n<p>There should be spaces around operators, such as <code>n / 2</code> or <code>3 * n</code>. Some IDEs can handle this for you through an auto-formatting option (e.g. <kbd>Ctrl</kbd> + <kbd>Alt</kbd> + <kbd>L</kbd> for PyCharm on Windows).</p>\n<hr />\n<p><strong>Type hints</strong></p>\n<p>It's useful to provide type hints for arguments and function return values. This increases readability and allows for easier and better error checking. Refer to <a href=\"https://www.python.org/dev/peps/pep-0484/\" rel=\"nofollow noreferrer\">PEP484</a> for more information.</p>\n<pre><code>def collatz(n: int, counter: int) -&gt; int:\n # function body here\n</code></pre>\n<hr />\n<p><strong>Return values</strong></p>\n<p>Adding these type hints will help us identify the first improvement. As the Collatz sequence only contains integers, our <code>collatz</code> function should only take an integer as the <code>n</code> argument. <code>collatz(n / 2, counter + 1)</code> passes a float, so to keep it consistent we should probably convert it to an <code>int</code> before passing it: <code>collatz(int(n / 2), counter + 1)</code>. Even better, we can use the floor division operator <code>//</code>: <code>collatz(n // 2, counter + 1)</code></p>\n<p>Please note that you do not need to convert the function output to an <code>int</code>, as it will only ever return an <code>int</code> value.</p>\n<hr />\n<p><strong>Default arguments</strong></p>\n<p>There are multiple approaches to improving the handling of the <code>counter</code> argument, which rubs you the wrong way. This is good intuition on your part. With default arguments, Python offers one really concise option:</p>\n<pre><code>def collatz(n: int, counter: int = 0) -&gt; int:\n if n == 1:\n return counter\n elif n % 2 == 0:\n return collatz(n // 2, counter + 1)\n else:\n return collatz(3 * n + 1, counter + 1)\n</code></pre>\n<p>As you can see, the only addition we need to implement is <code>counter = 0</code>, which makes <code>0</code> the default argument for <code>counter</code>. This means that <code>counter</code> will be set to <code>0</code> if the argument is not provided by the caller.</p>\n<p>You can now simply call</p>\n<pre><code>print(collatz(15))\n</code></pre>\n<p>More on <a href=\"https://www.geeksforgeeks.org/default-arguments-in-python/\" rel=\"nofollow noreferrer\">default arguments in Python</a>.</p>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-26T07:58:43.470", "Id": "526295", "Score": "5", "body": "I would also recommend using `cache` from `itertools`, it will dramatically speed up the code." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-26T08:01:37.863", "Id": "526296", "Score": "0", "body": "@N3buchadnezzar I agree, good recommendation!" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-26T08:01:59.287", "Id": "526297", "Score": "2", "body": "The type hints are certainly useful, and I definitely miss it coming from C. Do Python programmers regularly use them? Or is it something that goes away when you're already comfortable using Python?\nThe `counter` variable initialization was my problem; I could not find where it should be put. And so my solution was just to pass it to the function. I know that's not how it should be because I admit my Python knowledge is still very limited. \nYou provided me with easy-to-understand explanations. Thank you :)" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-26T08:34:23.537", "Id": "526302", "Score": "1", "body": "Glad to help! I'd say type hints are useful at any level of Python proficiency, as they allow for easier debugging and maintainability. They do probably provide the biggest benefit to beginner and intermediate Pythonistas though =)" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-26T08:48:46.573", "Id": "526303", "Score": "0", "body": "Btw why do we care about keeping track of `counter`?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-26T10:12:03.417", "Id": "526306", "Score": "0", "body": "@N3buchadnezzar the goal of the code is to print the length of the collatz sequence. Could you elaborate as to why you asked? I have a beginner understanding of Python, and just programming in general (never touched a DSA topic before)." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-26T21:36:30.720", "Id": "526344", "Score": "0", "body": "@N3buchadnezzar: Because testing the Collatz conjecture isn't just about infinite loop or not; counting the iterations is interesting. https://en.wikipedia.org/wiki/Collatz_conjecture#Empirical_data / https://en.wikipedia.org/wiki/Collatz_conjecture#Visualizations. (Besides visualizations, results may provide some insight into algorithmic optimizations to short-circuit the basic steps; see various answers on [Why does C++ code for testing the Collatz conjecture run faster than hand-written assembly?](https://stackoverflow.com/q/40354978) that focus on the algorithm instead of asm)" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-26T21:52:41.800", "Id": "526345", "Score": "0", "body": "(Although I think you already know that based on your comments on your own answer; maybe I misunderstood what you were asking. Maybe you meant why we want a 2nd arg at all, when your answer shows a way to do it with non-tail calls where the eventual count just ends up in a return value. That's good too, but defeats tail-call optimization for languages / implementations that can do that.)" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-26T22:24:18.643", "Id": "526346", "Score": "0", "body": "Unless I'm mistaken Python doesn't actually have function overloading, usually it's faked with default arguments or some `*args` trickery. Maybe make that more clear?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-27T00:30:55.857", "Id": "526348", "Score": "0", "body": "@PeterCordes your second comment hit the nail right on the head about the meaning of my comment. I wrote it in the middle of an lecture, so I had to keep it brief. I elaborated as you said when I got home in my answer =)" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-27T09:28:33.803", "Id": "526365", "Score": "0", "body": "@ToddSewell Thanks for your comment, I cleared it up. That's what happens when you edit previously working code while writing the answer without re-running it." } ], "meta_data": { "CommentCount": "11", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-26T07:36:01.633", "Id": "266410", "ParentId": "266408", "Score": "9" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-28T12:06:44.313", "Id": "526448", "Score": "0", "body": "what do you mean by too inefficient? How long does it take and how much time do you have? How close to the hardware (read limit of your harddrive) are you?" } ]

{ "AcceptedAnswerId": null, "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-26T19:27:10.023", "Id": "266431", "Score": "6", "Tags": [ "python", "performance", "python-3.x", "io" ], "Title": "Reading 100,000 data files in Python" }

[ { "body": "<p>Avoid iterating over rows of a dataframe or array. Avoid copying data.</p>\n<p>Process one file at a time...read then write data for each file. There is no need to build a list of all the data.</p>\n<p>Perhaps use <code>np.loadtxt()</code> instead of <code>pd.read_csv()</code>. Use <code>skip</code> and <code>max_rows</code> to limit the amount of data read and parsed by <code>np.loadtxt()</code>. Use <code>unpack=True</code> and <code>ndmin=2</code> so it returns a row instead of a column. Then <code>np.savetxt()</code> will append a <code>'\\n'</code> after each row.</p>\n<p>Something like this (untested):</p>\n<pre><code>import numpy as np\nimport glob\nimport natsort\n\nwith open('x_position.txt', 'a') as outfile:\n\n filenames = natsort.natsorted(glob.glob(&quot;CoordTestCode/ParticleCoordU*&quot;))\n\n for f in filenames:\n data = np.loadtxt(f, skiprows=9, max_rows=20000, usecols=3, unpack=True, ndmin=2)\n\n np.savetxt(outfile, data, fmt=&quot;%7.3f&quot;)\n</code></pre>\n<p>Presuming the data is stored on hard drives, the average rotational latency for a 7200 rpm hard drive is 4.17ms. 100k files at 4.17ms each is about 417 seconds = almost 7 minutes just to seek to the first sector of all those files. Perhaps using <a href=\"https://docs.python.org/3.9/library/concurrent.futures.html#concurrent.futures.ThreadPoolExecutor\" rel=\"noreferrer\"><code>concurrent.futures.ThreadPoolExecutor</code></a> would let you overlap those accesses and cut down that 7 minutes.</p>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-27T15:25:31.670", "Id": "526380", "Score": "0", "body": "Thank you so much for the useful reply! However, I read in multiple forums that pandas is way faster than numpy.loadtxt due to the fact that the padas library is built in C. Any specific reason you recommend for switching back to np.loadtxt ?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-27T15:46:39.147", "Id": "526384", "Score": "0", "body": "How would ThreadPoolExecutor get around IO latency? I think it should only help with CPU-bound jobs." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-27T16:20:09.923", "Id": "526387", "Score": "0", "body": "@AlessandroPerego Mostly, I was trying to avoid the need tp copy the data from a DataFrame to an ndarray. Try it both ways and see which is faster." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-27T16:30:03.930", "Id": "526388", "Score": "1", "body": "@Seb The idea is that when one thread is waiting for IO, another thread can do some non-IO processing. For example, when one thread is waiting for the hard drive to return the next chunk of data, another thread can be parsing a chunk of data it read from a different file. Generally, use threads for IO-bound jobs and processes for CPU-bound jobs, but it depends on the actual workload. Try threads and processes and see which is faster. Another possibility is async using something like the `aiofile` library, but I haven't used it." } ], "meta_data": { "CommentCount": "4", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-27T01:35:28.813", "Id": "266437", "ParentId": "266431", "Score": "10" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-28T09:20:44.543", "Id": "526439", "Score": "1", "body": "In one place the input is called a two-dimensional array, and later it seems to be a file-like. Are the input and output stdin/stdout, or actually in-memory lists?" } ]

{ "AcceptedAnswerId": "266506", "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-27T19:44:55.643", "Id": "266456", "Score": "1", "Tags": [ "python", "performance", "python-3.x" ], "Title": "Encode event results as colors" }

[ { "body": "<p>For a faster algorithm, update a count of neighboring pairs at distance D as you go.</p>\n<pre class=\"lang-py prettyprint-override\"><code>from collections import defaultdict\n\ndef num_at_distance(d, pairs):\n # Keep track of whether each position is occupied or not.\n # Accepts a distance and a number of positions to update. Each position is a 2-tuple of:\n # - -1 for not-occupied or 1 for occupied\n # - A position which changed.\n # Returns [yellow, yellow, red...] as a generator\n\n # 'occupied' maps a position to whether it's occupied.\n # Everything is unoccupied to start (False).\n # For slightly faster performance you could switch to an array.\n occupied = defaultdict(bool)\n num_at_distance_d = 0\n for now_occupied, position in pairs:\n # A is the position D to the left of the update\n # i is the updated position\n # B is the position D to the right of the update\n a, i, b = position-d, position, position+d\n now_occupied = bool(now_occupied==1)\n\n if occupied[i] != now_occupied:\n occupied[i] = now_occupied\n if occupied[i]:\n # Use the fact that python's True and False are 1 and 0 for some math\n num_at_distance_d += occupied[a] + occupied[b]\n else:\n num_at_distance_d -= occupied[a] + occupied[b]\n if num_at_distance_d == 0:\n yield &quot;yellow&quot;\n else:\n yield &quot;red&quot;\n\nif __name__=='__main__':\n input = 4, [(1,2), (1,10), (1,6), (-1, 2), (-1, 6), (1, 9), (1,4)]\n output = list(num_at_distance(*input))\n print(output)\n</code></pre>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-29T23:15:52.590", "Id": "526549", "Score": "0", "body": "Works perfectly!" } ], "meta_data": { "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-29T20:58:09.923", "Id": "266506", "ParentId": "266456", "Score": "1" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-28T08:41:41.360", "Id": "526437", "Score": "1", "body": "The plural of \"die\" is \"dice\", and \"dices\" is not a word (yes, English is ridiculous)" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-28T11:23:08.083", "Id": "526445", "Score": "0", "body": "Thanks I didn't know!!" } ]

{ "AcceptedAnswerId": "266468", "CommentCount": "2", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-28T05:00:00.873", "Id": "266465", "Score": "3", "Tags": [ "python", "dice" ], "Title": "Tricky dice game in Python" }

[ { "body": "<h3>Variable names</h3>\n<p>Some names are not clear enough. What <code>p</code> means, a pair? You don't need a pair:</p>\n<p><code>for p in product(dice1,dice2):</code> =&gt; <code>for side1, side2 in product(dice1,dice2):</code></p>\n<p><code>a,b=count_wins(dices[i],dices[j])</code> =&gt; <code>wins1, wins2 = count_wins(dices[i],dices[j])</code></p>\n<p>What 'adj' means? &quot;Adjacent&quot;? Maybe it should be &quot;wins&quot; or something like this. Make the code readable.</p>\n<h3>Type hints</h3>\n<p>Use them.</p>\n<h3>Indents are important not only in the beginning</h3>\n<p>Put spaces at least right to commas and on the both sides of operators - or at least do it consistently. Sometimes you do, sometimes you don't. That irritating.</p>\n<h3>Use Python features more intensively</h3>\n<pre><code>assert len(dice1) == 6 == len(dice2) #chain compare\n....\nadj=[[] for _ in dices] #you don't need range(len()) if you don't need a number\n....\nfor i, wins in enumerate(adj): #&quot;enumerate&quot; generates index-value pairs\n if not wins: #&quot;len(...) == 0&quot; is just &quot;not ...&quot;\n ans = i\n</code></pre>\n<p>You can make <code>count_wins</code> function much shorter and readable, counting only wins, not losses. This will make you call it twice, but <span class=\"math-container\">\\$O(2n)==2O(n)==O(n)\\$</span>, and <span class=\"math-container\">\\$n\\$</span> is 6, so you lose nothing.</p>\n<pre><code>def count_wins(dice1, dice2):\n assert len(dice1) == 6 and len(dice2) == 6\n return sum(1 for side1, side2 in product(dice1,dice2) if side1&gt;side2)\n</code></pre>\n<p>Or you can do this twice inside <code>count_wins</code> - both ways.</p>\n<h3>Unnecessary and insufficient <code>assert</code>s</h3>\n<p>This code looks like there's only one entry point, at <code>compute_strategy</code>. So other functions probably shouldn't check for list sizes. On the other hand, you don't check many other things like type of input - is it a list of lists of integers? Can there be negative values? There's nothing wrong in extra checking, but if you are validating data - validate it, not just check one assertion several times.</p>\n<p>You can make it a class to make sure all inputs would go through an <code>__init__</code> method.</p>\n<h3>Remove debugging output before showing your code to others</h3>\n<p>I don't think <code>print</code>s belong here, though they could be very useful while debugging.</p>\n<h3>Optimization ideas</h3>\n<p>I don't think comparing 6-element lists needs an optimization, but you still can sort the sides and then bisect search the number of elements less than the other side. This will give you <span class=\"math-container\">\\$O(n*log(n))\\$</span> time instead of yours <span class=\"math-container\">\\$O(n^2)\\$</span> product. Once again - just FYI.</p>\n", "comments": [], "meta_data": { "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-28T06:31:48.060", "Id": "266468", "ParentId": "266465", "Score": "5" } } ]

[]

{ "AcceptedAnswerId": "266484", "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-28T14:34:06.797", "Id": "266479", "Score": "0", "Tags": [ "python", "python-3.x" ], "Title": "Config Variables Initialization | Python" }

[ { "body": "<p>With no usage shown, no implementation for <code>LookupDict</code> shown and nothing other than your network type values, this is overdesigned and offers nothing beyond</p>\n<pre><code>class NetworkType(Enum):\n GSM = 1\n UMTS = 2\n LTE = 3\n</code></pre>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-28T18:15:32.397", "Id": "526465", "Score": "0", "body": "I agree with you it is overdesigned if I won't use the purpose this was originally designed for by `requests`, but I just hate to write this, following your example: `NetworkType.GSM.value` every time I will use any of the config values" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-28T18:28:29.740", "Id": "526469", "Score": "0", "body": "Wouldn't it just be `NetworkType.GSM`? That seems pretty straightforward and readable. The value isn't important in enums, so if your use case is to actually use it, just omit the `(Enum)` from the class." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-28T19:00:10.270", "Id": "526472", "Score": "0", "body": "I actually need the value, thanks for the last tip, I didn't think about it that way" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-28T21:37:48.083", "Id": "526480", "Score": "0", "body": "PS: LookupDict definition is in the last link" } ], "meta_data": { "CommentCount": "4", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-28T16:36:02.963", "Id": "266484", "ParentId": "266479", "Score": "3" } } ]

[]

{ "AcceptedAnswerId": null, "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-30T09:32:48.960", "Id": "266521", "Score": "2", "Tags": [ "python", "beginner", "random", "natural-language-processing", "markov-chain" ], "Title": "Markov text generator program in Python" }

[ { "body": "<p>In the following, I assume that you use Python3 rather than Python2, though I can't say for sure that it makes a difference.</p>\n<p>First, when you parse your file, you could use a context manager:</p>\n<pre><code>file_name = input()\nwith open(file_name, &quot;r&quot;, encoding=&quot;utf-8&quot;) as file:\n # nltk.trigrams returns a list of 3-tuples\n trigrams = list(nltk.trigrams(file.read().split()))\n</code></pre>\n<p>That way, even if an exception is raised by the assignment to trigrams (in either of the 4 method calls), the file stream is properly closed.</p>\n<p>You could simplify your model generation using <code>defaultdict</code> from the <code>collections</code> package. Your way of doing it is actually wrong and I can't say for sure that this option is more pythonic but it might be interesting to know.</p>\n<pre><code>import collections\nmodel = collections.defaultdict(lambda : collections.defaultdict(int))\nfor trigram in trigrams:\n head = trigram[0] + &quot; &quot; + trigram[1]\n tail = trigram[2]\n model[head][tail] += 1\n</code></pre>\n<p>This does not change the behavior of your algorithm, it just feels a bit simpler to me.</p>\n<p>But you can do something more memory-efficient:</p>\n<pre><code>import collections\nmodel = collections.defaultdict(lambda : collections.defaultdict(int))\nfile_name = input()\nwith open(file_name, &quot;r&quot;, encoding=&quot;utf-8&quot;) as file:\n # nltk.trigrams returns a list of 3-tuples\n trigrams = nltk.trigrams(file.read().split())\n for trigram in trigrams:\n head = trigram[0] + &quot; &quot; + trigram[1]\n tail = trigram[2]\n model[head][tail] += 1\n</code></pre>\n<p>Since <code>nltk.trigrams</code> returns an iterator, and since you only use it once, you don't actually need to store it in a list (an operation that will take some time and memory to copy everything from the iterator into the list) before iterating over it. You could even completely remove the <code>trigrams</code> variable and directly do <code>for... in nltk.trigrams...</code>.</p>\n<p>Finally, in your <code>while</code> loop, your <code>most_probable_tail</code> is misnamed: it is not the most probable one, it is the one your algorithm randomly selected using a possibly non-uniform law. I would rather call it <code>candidate_tail</code>, or <code>selected_tail</code>, or, even better, simply <code>tail</code>.</p>\n", "comments": [], "meta_data": { "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-30T19:28:04.600", "Id": "266534", "ParentId": "266521", "Score": "1" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-31T11:07:59.620", "Id": "526611", "Score": "0", "body": "You *can* use the walrus operator here, but I don't think you should: `i = -1`, `while len(\" \".join(split_string[:(i := i + 1)])) <= index: pass`. It's neither simpler nor clearer, it just moves even more logic into the condition without saving a line." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-31T11:09:07.393", "Id": "526612", "Score": "0", "body": "Just to confirm, you're not looking into using enumerate (returns a counter as part of a `for` loop) or using slicing, such as `\"jean de la fontaine\"[8]` - correct?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-31T11:34:35.853", "Id": "526613", "Score": "0", "body": "thanks @riskypenguin, but as you pointed out, it only makes the code more complex, so it's not really what I'm looking for. I was just mentioning the walrus operator as a possible idea" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-31T11:44:42.330", "Id": "526614", "Score": "0", "body": "@C.Harley no, this is just an exemple but i'm trying to get the value of `i` in only one line, using the given condition, in order to get the number of the word in the string where the specified letter is (here, ̀\"jean de la fontaine\"[8]`). Sorry, I know it's not very clear but I don't see how I can explain the function more clearly than in its docstring" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-31T11:55:21.777", "Id": "526615", "Score": "1", "body": "`sum(1 for _ in itertools.takewhile(lambda i: PREDICATE, itertools.count()))`" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-31T17:49:22.427", "Id": "526642", "Score": "0", "body": "What about `return string[:index+1].count(\" \")` ?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-31T18:21:21.163", "Id": "526643", "Score": "0", "body": "thanks @SylvainD , but this is an example, and I'm looking for a global solution" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-31T19:53:24.117", "Id": "526652", "Score": "0", "body": "To be honest, I have the feeling that it works pretty well. I'd be interested in cases that are not handled properly." } ]

{ "AcceptedAnswerId": "266552", "CommentCount": "8", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-31T10:31:59.630", "Id": "266548", "Score": "2", "Tags": [ "python" ], "Title": "Counting how many times a condition is met in Python" }

[ { "body": "<p>You <em>could</em> replace your</p>\n<pre><code> i = 0\n while len(&quot; &quot;.join(split_string[:i])) &lt;= index:\n i += 1\n</code></pre>\n<p>with the oneliner using <a href=\"https://docs.python.org/3/library/itertools.html#itertools.count\" rel=\"noreferrer\"><code>itertools.count</code></a></p>\n<pre><code> i = next(i for i in count() if len(&quot; &quot;.join(split_string[:i])) &gt; index)\n</code></pre>\n<p>or more readably spread over two physical lines (still just one <a href=\"https://docs.python.org/3/reference/lexical_analysis.html#logical-lines\" rel=\"noreferrer\">logical line</a>:</p>\n<pre><code> i = next(i for i in count()\n if len(&quot; &quot;.join(split_string[:i])) &gt; index)\n</code></pre>\n<p>Both have advantages. The <code>while</code> solution has less clutter, the <code>next</code> solution makes it clearer that the whole point of the snippet is to compute <code>i</code>.</p>\n<p>If you already have a function for the condition, a good alternative would be <a href=\"https://docs.python.org/3/library/itertools.html#itertools.dropwhile\" rel=\"noreferrer\"><code>itertools.dropwhile</code></a>:</p>\n<pre><code> def condition(i):\n return len(&quot; &quot;.join(split_string[:i])) &lt;= index\n\n i = next(dropwhile(condition, count()))\n</code></pre>\n<p>As a oneliner, just to see how long/ugly it is in this case:</p>\n<pre><code> i = next(dropwhile(lambda i: len(&quot; &quot;.join(split_string[:i])) &lt;= index, count()))\n</code></pre>\n<p>So I'd likely really only use it if I had it as a function already.</p>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-31T13:00:39.833", "Id": "526619", "Score": "0", "body": "Thanks a lot! `itertools.count()` is what I needed right now, but I keep `dropwhile()` in mind, it is also very relevant.\nI'm always open to other ideas.\nBut the word \"could\" in your message suggests that this is not a good idea. It's true that it's not very clear. So you recommend not to use it, but to leave the \"while\" as it is?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-31T13:05:29.020", "Id": "526620", "Score": "0", "body": "I meant that as there's nothing wrong with the while loop. In this particular case, I'm undecided which I prefer, while or next. So you *could* switch, but you really don't have to." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-31T13:09:20.023", "Id": "526621", "Score": "0", "body": "Ok, I will keep this in mind, thank you !" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-31T13:12:14.153", "Id": "526622", "Score": "2", "body": "Put differently: Many Python beginners will write or see `while` loops and see experienced coders point out that they're horrible and that it should be done differently, and misunderstand that as \"while loops are *always* horrible\" rather than the meant \"this particular while loop is horrible\". Similar to the misconception \"to be pythonic, I must write this code as a oneliner\" :-)" } ], "meta_data": { "CommentCount": "4", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-08-31T12:30:25.130", "Id": "266552", "ParentId": "266548", "Score": "6" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-01T16:21:35.987", "Id": "526703", "Score": "0", "body": "The idea should be `copy_of_array[argmin_indices] = 0`." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-01T17:33:11.607", "Id": "526707", "Score": "0", "body": "Can you provide expected shape for each of your variables? e.g. `(1000, 2, 12)` or whatever." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-01T17:44:20.073", "Id": "526708", "Score": "1", "body": "@Reinderien Sure, `x0 = torch.tensor([[10, 20, 30], [2, 5, 1]])` and `x1 = torch.tensor([[2, 5, 10, -1], [1, 3, 2, 4], [5, 6, 2, 10]])`. I've added them to the original post for clarification as well." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-01T17:55:56.567", "Id": "526709", "Score": "0", "body": "@Andrew I believe that's similar to the way I went about solving it. It works, but I have to manually iterate over each row to mutate the min() value." } ]

{ "AcceptedAnswerId": "266602", "CommentCount": "4", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-01T15:47:59.910", "Id": "266597", "Score": "0", "Tags": [ "python", "pytorch" ], "Title": "Set min value of each row of a tensor to zero without using explicit loops" }

[ { "body": "<p>Not much of a code review, but this should work:</p>\n<pre><code>def zero_min(x):\n y = x.clone()\n y[torch.arange(x.shape[0]), torch.argmin(x, dim=1)] = 0\n return y\n</code></pre>\n<p>In each row, if the minimum is not unique, then only the occurrence with the smallest index will be zeroed out.</p>\n<p>To zero out all the occurrences, you could do something like the following:</p>\n<pre><code>def zero_em_all_min(x):\n y = x.clone()\n y[x == x.min(dim=1, keepdims=True).values] = 0\n return y\n</code></pre>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-01T18:24:07.987", "Id": "526716", "Score": "0", "body": "Thanks, didn't think to use `torch.arange` to iterate through the rows. I'll ask on regular SE in the future." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-01T18:26:02.620", "Id": "526717", "Score": "0", "body": "@Ryan I'm happy it could be answered, but perhaps that is indeed the better platform for a similar question!" } ], "meta_data": { "CommentCount": "2", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-01T18:16:27.703", "Id": "266602", "ParentId": "266597", "Score": "0" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-01T16:57:34.453", "Id": "526705", "Score": "1", "body": "It is not \\$O(n)\\$. List slicing itself is linear in the length of the slice." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-02T06:32:45.827", "Id": "527737", "Score": "0", "body": "Pardon me for that I didn't notice." } ]

{ "AcceptedAnswerId": null, "CommentCount": "2", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-01T15:48:26.747", "Id": "266598", "Score": "0", "Tags": [ "python", "time-limit-exceeded" ], "Title": "Leetcode (443) String Compression" }

[ { "body": "<p>It's not <span class=\"math-container\">\\$O(n)\\$</span> but <span class=\"math-container\">\\$O(n^2)\\$</span>, because:</p>\n<ul>\n<li><code>chars[i:]</code> takes <span class=\"math-container\">\\$O(n)\\$</span> time and space. You could instead move a second index <code>j</code> forwards until the last occurrence and then compute the length as <code>j - i + 1</code>.</li>\n<li><code>chars[i+1:i+count] = list_appending</code> takes <span class=\"math-container\">\\$O(n)\\$</span> time. Instead of replacing all <code>count</code> equal characters, better replace exactly as many as you need for the digits. Then the remaining characters don't get moved and it's <span class=\"math-container\">\\$O(1)\\$</span> (amortized).</li>\n</ul>\n<p>You shrink the list. I'd say you're not supposed to. If you were supposed to shrink the list, why would they want you to return the list length? I think you're supposed to write the compressed data into a prefix of the list and return where that compressed data ends. Like they requested in an <a href=\"https://leetcode.com/problems/remove-duplicates-from-sorted-array/\" rel=\"nofollow noreferrer\">earlier problem</a>.</p>\n<p>Converting <code>str(count)</code> to a list is unnecessary. And I'd find <code>digits</code> a more meaningful name than <code>list_appending</code>.</p>\n<p><a href=\"https://www.python.org/dev/peps/pep-0008/#pet-peeves\" rel=\"nofollow noreferrer\">PEP 8</a> suggests to write <code>chars[i+1:i+count]</code> as <code>chars[i+1 : i+count]</code> (and I agree).</p>\n<p>This is essentially a job for <a href=\"https://docs.python.org/3/library/itertools.html#itertools.groupby\" rel=\"nofollow noreferrer\"><code>itertools.groupby</code></a>, here's a solution using that:</p>\n<pre><code> def compress(self, chars: List[str]) -&gt; int:\n def compress():\n for c, g in groupby(chars):\n yield c\n k = countOf(g, c)\n if k &gt; 1:\n yield from str(k)\n for i, chars[i] in enumerate(compress()):\n pass\n return i + 1\n</code></pre>\n<p>Just for fun a bad but also fast regex solution:</p>\n<pre><code> def compress(self, chars: List[str]) -&gt; int:\n chars[:] = re.sub(\n r'(.)\\1+',\n lambda m: m[1] + str(len(m[0])),\n ''.join(chars))\n return len(chars)\n</code></pre>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-02T06:30:00.883", "Id": "527736", "Score": "0", "body": "I really appreciate your efforts. And thanks for the information I would follow rule about clean coding too.\nBut still that code ran so slow only about beating 20% users.\nCan I know why??" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-02T15:34:52.563", "Id": "527779", "Score": "0", "body": "It's not much slower than the faster ones, if at all. Look at the time distribution graph. And LeetCode's timing is unstable. How often did you submit it, and what were the individual results?" } ], "meta_data": { "CommentCount": "2", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-01T22:00:54.627", "Id": "266610", "ParentId": "266598", "Score": "1" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-04T04:14:48.490", "Id": "527824", "Score": "0", "body": "https://codereview.stackexchange.com/a/254846/25834 for reference" } ]

{ "AcceptedAnswerId": "267676", "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-03T21:20:10.730", "Id": "267666", "Score": "1", "Tags": [ "python", "performance", "beginner" ], "Title": "Expanding on a problem from Automate the Boring Stuff" }

[ { "body": "<ul>\n<li>Let's start with the basics. Always use if <code>__name__ == &quot;__main__&quot;: printArrow(rightArrow)</code> instead of directly calling your function (<code>printArrow(rightArrow)</code>) to avoid running it if importing the function in the future from another module.</li>\n<li>A function called <code>printArrow</code> should print an arrow, not ask a user for input, print an arrow, and control the flow of the program. Divide it into def print_arrow(list, direction), main(), etc.</li>\n<li>Instead of using <code>quit()</code> which controls the global execution flow, you can use a plain <code>return</code> when inside a function. Cleaner and follows SRP.</li>\n<li>Naming! In python we don't usually use camelCase for functions; use instead: print_arrow. Same for variables like <code>rowLength</code> -&gt; <code>row_length</code>.</li>\n<li>Pass your code through black or similar to have it nicely formatted (black.vercel.app/), otherwise the small human &quot;errors&quot; show up :)</li>\n<li>Constants in Python, by convention, use all upper case and don't need to be passed into functions (the only exception when globals are generally acceptable). So use <code>rightArrow</code> -&gt; <code>RIGHT_ARROW</code> and <code>def printArrow(list):</code> -&gt; <code>def printArrow():</code>.</li>\n<li>Use comments for the important stuff (the one which I can't trivially deduce from the code itself). What is this arbitrary amount of spaces? <code>' '</code>? Put it into a constant and comment why that many if it has a meaning. E.g., <code>SEPARATOR = ' '</code>.</li>\n<li>There is some code repetition, can't you put this into a function <code>def _print_arrow_auxiliary(x_start: int, x_end: int, x_step: int, y_start: int, y_end: int, y_step: int) -&gt; None:</code>?</li>\n</ul>\n<pre><code>for i in range(rowLength-1, -1, -1):\n for j in range(columnLength-1, -1, -1):\n print(list[j][i] + ' ', end='')\n print('\\n')\n</code></pre>\n<ul>\n<li>It is a matter of taste, but type-hinting your functions does give you many advantages (self-explanatory code, better IDE highlights and suggestions, etc.)...\n<code>def printArrow(list):</code> -&gt; <code>def printArrow(list: List[List[str]]) -&gt; None:</code>.</li>\n</ul>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-04T17:00:56.310", "Id": "527847", "Score": "0", "body": "Thanks for this response. There are a few things I need clairification on. I don't understand the following line: __name__ == \"__main__\": printArrow(rightArrow). Also, your second point about separating the function into print_arrow(list, direction), main(), etc. What is the purpose of 'main()' in this context?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-04T17:34:51.690", "Id": "527851", "Score": "0", "body": "First question is answered [here](https://stackoverflow.com/questions/419163/what-does-if-name-main-do), this is a basic in Python, so I suggest you spend some time and make sure you get it! As for separation functions, in general we try to follow [SRP](https://en.wikipedia.org/wiki/Single-responsibility_principle), each function should only do one thing. So print_arrow should do only that, print the arrow, not have the main program loop or ask the user for input. It is a convention to have a function called main() which has the program main loop." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-04T21:43:43.953", "Id": "527862", "Score": "0", "body": "Thanks! Last question, how did you determine that I had constants in my code? I'm not aware of the difference between a constant and a variable in Python. I know in JavaScript, the declaration is either var, const, or let, but as far as I know, every variable in Python is a variable." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-04T22:22:19.890", "Id": "527865", "Score": "2", "body": "Well, yes. In Python there are no constants. That is, there is no way to enforce a variable is actually constant and never changes. However, us, as ✨responsible programmers✨ do use some variables which we intend to use as constants. If we want to show that a variable is intended to be use as a constant, in Python we use all uppercase like SOME_CONSTANT. In your case, e.g., rightArrow is used but never modified, so let's make it explicit by using the naming convention for constants!" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-03T18:34:29.540", "Id": "532202", "Score": "0", "body": "If you have a moment and it's not too much trouble, would you be willing to take a look at the final product? The only problem I encountered was being unable to create a single function that prints the arrow in all four directions, so I created two functions, one for \"left right\" and one for \"up down\": https://github.com/ajoh504/Automate-The-Boring-Stuff-Exercises/blob/main/CH%204%20Lists/10_character_picture_grid2.py" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-04T08:06:17.277", "Id": "532233", "Score": "0", "body": "Maybe consider calling lower on user_input just once and storing it instead of repeating it. So: `user_input = input().lower()`. The rest seems fine!" } ], "meta_data": { "CommentCount": "6", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-04T09:30:40.540", "Id": "267676", "ParentId": "267666", "Score": "2" } } ]

[]

{ "AcceptedAnswerId": "267722", "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-06T02:52:13.250", "Id": "267715", "Score": "1", "Tags": [ "python", "beginner", "python-3.x", "mathematics" ], "Title": "Ask 2 terms from user and add them" }

[ { "body": "<p><strong>General</strong></p>\n<p>Attributes, variable names, function names and function arguments should be lowercase / <code>snake_case</code>.</p>\n<p>You should wrap your main procedure in a main function, as well as a <code>if __name__ == '__main__'</code> guard. <a href=\"https://stackoverflow.com/a/419185/9173379\">More info</a>.</p>\n<p>Documentation makes your code easier to read and understand. Use docstrings and comments to explain why and how your code is doing what it's doing.</p>\n<p>Type hints make your code easier to read and understand, use them. <a href=\"https://www.python.org/dev/peps/pep-0484/\" rel=\"nofollow noreferrer\">PEP 484</a> | <a href=\"https://docs.python.org/3/library/typing.html\" rel=\"nofollow noreferrer\">Python Docs</a></p>\n<hr />\n<p><strong><code>TermEva.__init__</code></strong></p>\n<pre><code>self.ex_variable = ex_variable\nif self.coefficient &lt; 0:\n self.ex_variable = &quot;-&quot; + self.variable\n</code></pre>\n<p>Depending on the value of <code>self.coefficient</code>, <code>self.ex_variable</code> will either be a number or a string. Sticking to the number representation seems more intuitive here:</p>\n<pre><code>self.ex_variable = ex_variable\nif self.coefficient &lt; 0:\n self.ex_variable = self.variable * -1\n</code></pre>\n<p>On closer inspection, your <code>main</code> functionality always passes strings to the constructor of <code>TermEva</code>. I don't think this is intended, as your implementation of <code>TermEva</code> implies the arguments are numbers. You should generally check user input for correctness and then convert it to the desired type.</p>\n<hr />\n<p><strong><code>TermEva.sim_term</code></strong></p>\n<p>f-strings are a great tool for string formatting:</p>\n<pre><code>def sim_term(self):\n return f&quot;{self.coefficient}{self.variable}&quot;\n</code></pre>\n<hr />\n<p><strong><code>TermEva.expanded_form</code></strong></p>\n<p>This pattern of list creation</p>\n<pre><code>expanded_form = []\nfor num in range(abs(self.Coefficient)):\n ExpandedForm.append(self.ExVariable)\n</code></pre>\n<p>can (and often should) be replaced by a more functional approach:</p>\n<ul>\n<li><code>return [self.ex_variable for _ in range(abs(self.coefficient))]</code></li>\n<li><code>return [self.ex_variable] * abs(self.coefficient)</code></li>\n</ul>\n<p>Note that it's convention to use <code>_</code> as a variable name for loop variables you don't actually use. This makes it immediately clear to the reader that the value of <code>num</code> is not needed.</p>\n", "comments": [], "meta_data": { "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-06T09:34:22.117", "Id": "267722", "ParentId": "267715", "Score": "2" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-06T20:22:03.440", "Id": "527946", "Score": "0", "body": "Welcome to Code Review! Please explain / summarize what the challenge task is, so that the question makes sense even if the link goes dead." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-07T10:41:13.537", "Id": "527979", "Score": "0", "body": "Hi, @200_success I have inserted a screenshot of the original problem." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-07T11:38:57.077", "Id": "527982", "Score": "0", "body": "I have solved this optimisation, thread can be closed. Thanks" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-07T17:25:36.270", "Id": "527999", "Score": "0", "body": "We don't delete questions on Code Review just because you have solved the challenge yourself. Rather, you should post an answer to your own question that explains your successful approach and your thought process, so that future readers can benefit from this post." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-08T17:08:39.683", "Id": "528076", "Score": "1", "body": "I have posted a comment under Anab's proposals with a brief summary of how I solved it in the end." } ]

{ "AcceptedAnswerId": "267741", "CommentCount": "5", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-06T19:28:03.667", "Id": "267740", "Score": "0", "Tags": [ "python", "python-3.x", "programming-challenge", "time-limit-exceeded", "binary-search" ], "Title": "Climbing the leaderboard (Hacker Rank) via binary search" }

[ { "body": "<p>I see three ways to improve your runtime. I have never done this problem so I can't guarantee that it will be enough to pass all the tests.</p>\n<h2>Sorted input</h2>\n<p>The leaderboard scores are sorted in decreasing order. Your duplicate-removal code converts a sorted list to a set to remove duplicates (O(n)), then converts it back to a list (O(n)), then sorts it (O(n*log(n)). You could use the fact that it is sorted: duplicates will always be side by side. You could do something like the following, for example:</p>\n<pre><code>prev = ranked[0]\nduplicateIndices = set()\nfor index, val in enumerate(ranked[1:], 1):\n if val == prev:\n duplicateIndices.add(index)\n prev = val\nranked2 = [x for i,x in enumerate(ranked) if i not in duplicateIndices]\n</code></pre>\n<p>This may not be the most efficient way to remove duplicate but it runs in O(n).</p>\n<h2>Sorted input 2</h2>\n<p><code>player</code> is sorted as well. That means that after each iteration, the player's rank is at most the previous one. This has two consequences:</p>\n<ol>\n<li>You don't need to add the player's score to <code>ranked2</code> (either two consecutive scores are equal, which is easy enough to detect without altering <code>ranked2</code>, or the second one is strictly better than the first and having inserted the first in <code>ranked2</code> will not change the insertion point of the second)</li>\n<li>The right boundary of your binary search is your previous insertion point.</li>\n</ol>\n<p>This will not change your asymptotical complexity but it should have an interesting effect on your runtime anyway.</p>\n<h2>Skipping the linear search</h2>\n<p>With a single line, your code goes from O(m*log(n)) to O(m*n). Since <code>ranked2</code> is a list, and Python does not know that it is sorted, <code>if i in ranked2</code> will iterate over the entire list searching for a match. This operation runs in O(n) and is repeated for each of the player's score. Besides, you have already handled the equality case in your binary search, so why bother?</p>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-07T11:38:08.547", "Id": "527981", "Score": "0", "body": "Thanks @Anab I removed the linear search per iteration and made use of the fact that my binary search returns the index if it finds the value in the list. Passed all cases" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-07T17:09:12.837", "Id": "527997", "Score": "0", "body": "Glad that it worked for you. Could you accept the answer if you're satisfied with it?" } ], "meta_data": { "CommentCount": "2", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-06T19:55:36.573", "Id": "267741", "ParentId": "267740", "Score": "2" } } ]

[]

{ "AcceptedAnswerId": "267764", "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-07T18:29:38.350", "Id": "267762", "Score": "1", "Tags": [ "python" ], "Title": "Cron email-deleter" }

[ { "body": "<p>The <code>listy</code> comprehension could be refactored into a generator:</p>\n<pre class=\"lang-py prettyprint-override\"><code>def search_emails(imap, senders):\n for sender in senders:\n typ, data = imap.search(None, f'FROM {sender}')\n msg_nums = data[0].decode().split()\n \n # check for content here\n if msg_nums:\n yield msg_nums\n\n\nwith imaplib.IMAP4_SSL(host='imap.gmail.com', port=993) as imap:\n imap.login(email, password)\n imap.select('INBOX', readonly=False)\n\n # also, visually breaking up the program with newlines\n # makes it more readable\n for email in search_emails(imap, senders):\n for j in email:\n imap.store(j, '+FLAGS', '\\\\Deleted')\n print('email_deleted')\n</code></pre>\n<p>This evaluates lazily, so you don't have to keep all of your emails in a list that you filter out later. It filters them as you iterate over the generator.</p>\n<h1><code>for j in email</code></h1>\n<p>This inner loop doesn't need to be there, per the docs on <a href=\"https://docs.python.org/3/library/imaplib.html#imaplib.IMAP4.store\" rel=\"nofollow noreferrer\"><code>IMAP4.store</code></a>, it takes a set of messages, not one at a time:</p>\n<pre class=\"lang-py prettyprint-override\"><code> ~snip~\n for emails in search_emails(imap, senders):\n imap.store(emails, '+FLAGS', '\\\\Deleted')\n print('emails_deleted')\n</code></pre>\n<p>The official docs also don't have the <code>decode</code> section when parsing the output from <code>IMAP4.search</code>:</p>\n<pre class=\"lang-py prettyprint-override\"><code>typ, data = M.search(None, 'ALL')\n\nfor num in data[0].split(): # &lt;------ Here\n M.store(num, '+FLAGS', '\\\\Deleted')\n</code></pre>\n<p>I haven't used this library, so I won't speculate on why your snippet is different, but just a note.</p>\n<h1>Variable Names</h1>\n<p>Things like <code>for i in iterable</code> and <code>for j in iterable</code> usually imply indices. I'd change the names here to more accurately represent what they are, it makes the code more readable</p>\n<h1>Function Params</h1>\n<p>Add spaces in between your function parameters:</p>\n<pre class=\"lang-py prettyprint-override\"><code># go from this\nimap.login(email,password)\n\n# to this\nimap.login(email, password)\n</code></pre>\n<h1>Passwords</h1>\n<p>You can use the <code>getpass</code> library for a masked password prompt:</p>\n<pre class=\"lang-py prettyprint-override\"><code>from getpass import getpass\n\npassword = getpass()\n</code></pre>\n<p>I'm not sure how you're currently implementing storing the password, since you haven't included it.</p>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-08T10:25:55.670", "Id": "528044", "Score": "0", "body": "incredible explanation" } ], "meta_data": { "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-07T19:36:20.990", "Id": "267764", "ParentId": "267762", "Score": "1" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-09T06:21:48.217", "Id": "528130", "Score": "0", "body": "(Please do *not* change in your code (after the first CR answer): when using round *and* square brackets for the notation of intervals, they are in standard orientation. I've seen mirrored ones when using (round) parentheses exclusively.)" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-09T06:23:33.887", "Id": "528131", "Score": "0", "body": "(*Dual pivot* is superior to *three way (<,=,>) partition*.)" } ]

{ "AcceptedAnswerId": null, "CommentCount": "2", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-08T09:07:41.443", "Id": "267782", "Score": "0", "Tags": [ "python", "python-3.x", "algorithm", "quick-sort" ], "Title": "Python Quicksort Implementation with duplicates" }

[ { "body": "<p>Performance problems with quicksort are due to one single partition getting almost all of the items, incurring repeated &quot;partition cost&quot;.<br />\nIn the extreme (undetected, if for sake of argument) case of <em>all equal keys</em>, the code presented (implementing <a href=\"https://en.m.wikipedia.org/wiki/Quicksort#Lomuto_partition_scheme\" rel=\"nofollow noreferrer\">Lomuto's partition scheme</a>) puts all items equal to pivot in the left partition, returning the index of the rightmost one, leading to quadratic time.<br />\nCareful implementations of Hoare partition move values equal to pivot to &quot;the other partition&quot;, resulting in a balanced split here.<br />\n(When implementing dual pivot, checking they differ seems prudent.)</p>\n<p>The minimally invasive change would seem to be to change the way values equal to pivot are handled - <em>either</em></p>\n<ul>\n<li>Keep a toggle indicating where to put the next one - <em>or</em></li>\n<li>Put the item in the partition currently smaller.\n<pre><code>if A[j] &lt; pivot or (\n A[j] == pivot and i-left &lt; j-i):\n</code></pre>\n</li>\n</ul>\n<hr />\n<ul>\n<li>Why restrict items to <code>int</code>?</li>\n<li>Most of the implementation looks minimalistic (down to function docstrings, only - without full-stops).<br />\nThe special handling of values not exceeding pivot before the main loop of <code>partition()</code> doesn't quite seem in line.</li>\n<li>While you can put pivot selection in <code>partition()</code> just as well as in <code>quicksort()</code>, you could put it in a function of its own to emphasize mutual independance.</li>\n</ul>\n", "comments": [], "meta_data": { "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-10T07:39:00.907", "Id": "268839", "ParentId": "267782", "Score": "2" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-09T06:21:48.217", "Id": "528130", "Score": "0", "body": "(Please do *not* change in your code (after the first CR answer): when using round *and* square brackets for the notation of intervals, they are in standard orientation. I've seen mirrored ones when using (round) parentheses exclusively.)" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-09T06:23:33.887", "Id": "528131", "Score": "0", "body": "(*Dual pivot* is superior to *three way (<,=,>) partition*.)" } ]

{ "AcceptedAnswerId": null, "CommentCount": "2", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-08T09:07:41.443", "Id": "267782", "Score": "0", "Tags": [ "python", "python-3.x", "algorithm", "quick-sort" ], "Title": "Python Quicksort Implementation with duplicates" }

[ { "body": "<p>Performance problems with quicksort are due to one single partition getting almost all of the items, incurring repeated &quot;partition cost&quot;.<br />\nIn the extreme (undetected, if for sake of argument) case of <em>all equal keys</em>, the code presented (implementing <a href=\"https://en.m.wikipedia.org/wiki/Quicksort#Lomuto_partition_scheme\" rel=\"nofollow noreferrer\">Lomuto's partition scheme</a>) puts all items equal to pivot in the left partition, returning the index of the rightmost one, leading to quadratic time.<br />\nCareful implementations of Hoare partition move values equal to pivot to &quot;the other partition&quot;, resulting in a balanced split here.<br />\n(When implementing dual pivot, checking they differ seems prudent.)</p>\n<p>The minimally invasive change would seem to be to change the way values equal to pivot are handled - <em>either</em></p>\n<ul>\n<li>Keep a toggle indicating where to put the next one - <em>or</em></li>\n<li>Put the item in the partition currently smaller.\n<pre><code>if A[j] &lt; pivot or (\n A[j] == pivot and i-left &lt; j-i):\n</code></pre>\n</li>\n</ul>\n<hr />\n<ul>\n<li>Why restrict items to <code>int</code>?</li>\n<li>Most of the implementation looks minimalistic (down to function docstrings, only - without full-stops).<br />\nThe special handling of values not exceeding pivot before the main loop of <code>partition()</code> doesn't quite seem in line.</li>\n<li>While you can put pivot selection in <code>partition()</code> just as well as in <code>quicksort()</code>, you could put it in a function of its own to emphasize mutual independance.</li>\n</ul>\n", "comments": [], "meta_data": { "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-10T07:39:00.907", "Id": "268839", "ParentId": "267782", "Score": "2" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-11T09:24:26.363", "Id": "528235", "Score": "0", "body": "i've updated the code,could you recheck it again" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-11T10:31:22.063", "Id": "528237", "Score": "1", "body": "This always returns that the last number is prime. E.g. n=125 or n=102 return 125 and 102 as prime respectively. No numbers that end in 2 or 5 are prime except 2 and 5 themselves." } ]

{ "AcceptedAnswerId": null, "CommentCount": "2", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-11T08:47:28.460", "Id": "267887", "Score": "0", "Tags": [ "python", "primes" ], "Title": "My prime sieve using Python" }

[ { "body": "<blockquote>\n<pre><code>print(&quot;Welcome to the Sieve of Eratosthenes, where you can generate prime numbers from 1 to n : &quot;)\n</code></pre>\n</blockquote>\n<p>This is not a <a href=\"https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes\" rel=\"nofollow noreferrer\">Sieve of Eratosthenes</a>. It is a prime sieve in the sense that it takes a list of numbers and removes (or sieves) out those that aren't prime. But it does not follow the algorithm of the Sieve of Eratosthenes.</p>\n<p>Here's what the Sieve of Eratosthenes looks like:</p>\n<pre><code>primes = [p for p in range(2, n + 1)]\n\nfor p in primes:\n if p &gt; n / p:\n break\n\n for i in range(p * p, n + 1, p):\n if i in primes:\n primes.remove(i)\n</code></pre>\n<p>This is not necessarily the optimal version (for example, it might be better to compare <code>p</code> to the square root of <code>n</code> rather than do the <code>n / p</code> each time; or it may be better to use a set rather than a list). Nor is it likely to be the most Pythonic. I don't do Python development, so you should not take anything I suggest as being Pythonic.</p>\n<p>Some things that this does that your version does not:</p>\n<ol>\n<li>It only works on numbers that are prime. The initial loop may look like it is iterating over the entire range. But it actually only iterates over the primes, because the non-primes have been removed before it reaches them (I tested and unlike PHP, Python iterates over the current version of the array, not a copy of the original). It starts with 2 and eliminates all the even numbers.</li>\n<li>It does no trial division. Instead, it uses the Eratosthenes method of taking multiples of the current prime.</li>\n</ol>\n<p>That piece about multiplying rather than dividing is what I would describe as the central principle of the Sieve of Eratosthenes algorithm. So when I say that your version is not a Sieve of Eratosthenes, I mean that it doesn't do that.</p>\n<p>Note: there is nothing wrong with implementing a different sieve. It's possible to write a better one (although I'm not convinced that this is better). The Sieve of Eratosthenes is notable for being relatively good as well as comprehensible with moderate effort. It's not the best performing sieve. I'm just saying that you shouldn't call your version a Sieve of Eratosthenes, as it isn't one.</p>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-12T06:56:47.653", "Id": "528268", "Score": "0", "body": "I like how your SoE code removes values from the list while you're iterating it. Setting a good example here :-)" } ], "meta_data": { "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-11T21:43:43.480", "Id": "267903", "ParentId": "267887", "Score": "2" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-12T17:32:28.477", "Id": "528290", "Score": "1", "body": "It might be a good idea to include a little more code so people can run an analysis in their IDE. They should be able to reproduce what you're seeing." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-13T19:32:53.843", "Id": "528381", "Score": "0", "body": "Thanks. I've added more code." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-13T22:55:29.280", "Id": "528397", "Score": "0", "body": "Thanks, that runs. So, each of your statements does something specific to get the graph to draw. I don't find it too verbose compared to the example page https://matplotlib.org/2.0.2/users/screenshots.html given that you're drawing two graphs (scatter and line) on one plot. Is there something specific you want to highlight?" } ]

{ "AcceptedAnswerId": "268005", "CommentCount": "3", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-12T12:41:42.690", "Id": "267917", "Score": "1", "Tags": [ "python", "matplotlib" ], "Title": "Plot a simple scatter plot graph with two additional solid lines" }

[ { "body": "<blockquote>\n<p>Is there any way for me to reduce the number of lines to achieve exactly the same outcome?</p>\n</blockquote>\n<p>should, in isolation, not be your overriding concern, and your code is about as minimally chunky as matplotlib will allow. Your current push - rather than to shed a line or two - should be to increase static testability, maintainability and structure. Said another way, this is not code golf, and not all short code is good code.</p>\n<p>To that end:</p>\n<ul>\n<li>Do not enforce a style in the global namespace - only call that from a routine in the application. What if someone else wants to import and reuse parts of your code?</li>\n<li>Add PEP484 type hints.</li>\n<li>Avoid calling <code>gca</code> and <code>gcf</code>. It's easy, and preferable, to have local references to your actual figure and axes upon creation, and to use methods bound to those specific objects instead of <code>plt</code>. Function calls via <code>plt</code> have more visual ambiguity, and need to infer the current figure and axes; being explicit is a better idea. On top of that, calls to <code>plt</code> are just wrappers to the bound instance methods anyway.</li>\n<li>Choose a consistent quote style. <code>black</code> prefers double quotes but I have a vendetta against <code>black</code> and personally prefer single quotes. It's up to you.</li>\n<li>Do not force a <code>show()</code> in the call to <code>plot_returns</code>, and return the generated <code>Figure</code> instead of <code>None</code>. This will improve reusability and testability.</li>\n<li>Do not use strings for internal date logic. Even if you had to use strings, prefer an unambiguous <code>YYYY-mm-dd</code> ISO format instead of yours.</li>\n<li><code>np.random.random</code> is <a href=\"https://numpy.org/doc/stable/reference/random/index.html\" rel=\"nofollow noreferrer\">deprecated</a>; use <code>default_rng()</code> instead.</li>\n</ul>\n<h2>Suggested</h2>\n<pre><code>from datetime import date\n\nimport pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport matplotlib.dates as mdates\nfrom matplotlib.figure import Figure\n\n\ndef plot_returns(\n dates: pd.DatetimeIndex,\n return_values: np.ndarray,\n ewma_values: np.ndarray,\n main_label: str,\n) -&gt; Figure:\n fig, ax = plt.subplots(figsize=(15, 10))\n\n ax.scatter(dates, return_values, linestyle='-', color='blue', s=3, label='Daily Returns')\n ax.plot(dates, ewma_values, linestyle='-', color='green', label='EWMA')\n\n fig.autofmt_xdate()\n \n ax.xaxis.set_major_formatter(mdates.DateFormatter('%Y-%m'))\n ax.xaxis.set_major_locator(mdates.DayLocator(interval=31))\n ax.set_xlabel('Day', fontsize=14)\n ax.set_ylabel('Return', fontsize=14)\n ax.set_title(main_label, fontsize=14)\n ax.legend(loc='upper right', facecolor='white', edgecolor='black', framealpha=1, ncol=1, fontsize=12)\n ax.set_xlim(left=min(dates))\n\n return fig\n\n\ndef main() -&gt; None:\n dates = pd.date_range(start=date(2018, 1, 1), end=date(2018, 10, 10))\n rand = np.random.default_rng()\n return_values = rand.random(len(dates))\n ewma_values = rand.uniform(low=0.5, high=0.6, size=len(dates))\n\n plt.style.use('ggplot')\n plot_returns(dates, return_values, ewma_values, 'Example')\n plt.show()\n\n\nif __name__ == '__main__':\n main()\n</code></pre>\n<p><a href=\"https://i.stack.imgur.com/0Hg8S.png\" rel=\"nofollow noreferrer\"><img src=\"https://i.stack.imgur.com/0Hg8S.png\" alt=\"screenshot of matplotlib\" /></a></p>\n", "comments": [], "meta_data": { "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-14T16:20:48.307", "Id": "268005", "ParentId": "267917", "Score": "1" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-13T05:38:24.923", "Id": "528328", "Score": "0", "body": "The question is vague and the code makes some assumptions that aren't in the question. For example, what is a \"word\" and a \"non-empty word\"? Just letters? What about numbers or punctuation? Also, the question doesn't say to recursively processes a directory and it's sub-directories, but that's what the code appears to do. Lastly, the question says to process all files in a directory, but the code only does \".txt\" files." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-13T06:02:39.873", "Id": "528329", "Score": "0", "body": "@RootTwo This question was asked in an interview, and interview questions are sadly, but deliberately vague. I've added an edit for your follow up questions." } ]

{ "AcceptedAnswerId": "267946", "CommentCount": "2", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-13T03:35:41.043", "Id": "267941", "Score": "4", "Tags": [ "python", "io", "iterator" ], "Title": "Iterate through non-empty words from text files" }

[ { "body": "<p>The code seems overly complicated and complex for a relatively simple task.</p>\n<pre><code>from pathlib import Path\n\ndef words(file_or_path):\n path = Path(file_or_path)\n \n if path.is_dir():\n paths = path.rglob('*.txt')\n else:\n paths = (path, )\n \n for filepath in paths:\n yield from filepath.read_text().split()\n</code></pre>\n<p>The function can take a a directory name or a file name. For both cases, create an iterable, <code>paths</code>, of the files to be processed. This way, both cases can be handled by the same code.</p>\n<p>For each filepath in <code>paths</code> use <code>Path.read_text()</code> to open the file, read it in, close the file, and return the text that was read. <code>str.split()</code> drops leading and trailing whitespace and then splits the string on whitespace. <code>yield from ...</code> yields each word in turn.</p>\n<p>If you don't want to read an entire file in at once, replace the <code>yield from ...</code> with something like:</p>\n<pre><code> with filepath.open() as f:\n for line in f:\n yield from line.split()\n</code></pre>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-13T09:58:03.227", "Id": "528336", "Score": "0", "body": "This is great, but I’d like to take it one step further by reading one word at a time instead of the whole line. However, I’m wondering if that can somehow backfire, since reading one character at a time until a white space is encountered isn’t exactly efficient. I wish there was a `readword` function." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-13T15:04:21.520", "Id": "528360", "Score": "0", "body": "The most commonly used python implementations will be based on C, its stdlib, and UNIX philosophy.\nThe IO there is build around lines and line-by-line processing. A `readword` function in python can be implemented very easily, but under the hood the implementation would read the line and discard everything except the word. You would not gain much" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-13T17:27:31.420", "Id": "528374", "Score": "0", "body": "It would be totally possible, although definitely harder and less clean, to read the file in fixed-sized chunks instead of by line. And you would gain the ability to not crash if you come across a file with very long lines, e.g. a 32-gigabyte file without the `\\n` character. Although I suppose such a file would likely [exceed `{LINE_MAX}`](https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/limits.h.html) (implementation-defined and only required to be >= 2048) and thus [wouldn't count as a \"text file\" according to the POSIX standard](https://unix.stackexchange.com/q/446237)..." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-13T19:40:30.650", "Id": "528383", "Score": "0", "body": "There's one issue with the `yield from` used here, it doesn't check for empty words, which is a requirement in the question. I changed it to `yield from filter(_is_not_blank, line.split())`." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-13T19:59:32.170", "Id": "528385", "Score": "1", "body": "@AbhijitSarkar, `.split()` should already filter out the blanks. Do you have an example input that causes it to return an empty word?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-13T21:11:49.237", "Id": "528395", "Score": "0", "body": "@RootTwo You're right, I tested with a file containing a line with `\\n` only, a line with spaces and `\\n`, and `split` handled those cases just fine." } ], "meta_data": { "CommentCount": "6", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-13T06:30:43.830", "Id": "267946", "ParentId": "267941", "Score": "6" } } ]

[]

{ "AcceptedAnswerId": null, "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-13T05:04:20.983", "Id": "267944", "Score": "4", "Tags": [ "python", "algorithm", "primes" ], "Title": "My prime number generation program in Python" }

[ { "body": "<p>I am not a professional Python developer, so I will address only the performance issue: judging from you <code>for</code> loops structure, it seems that the running time of your implementation is <span class=\"math-container\">\\$\\Theta(n^2)\\$</span>, where <span class=\"math-container\">\\$n\\$</span> is the prime limit. However, you can do the same in <span class=\"math-container\">\\$O(n \\log n)\\$</span>, or even, <span class=\"math-container\">\\$O(n \\log \\log n)\\$</span> time. (See below.)</p>\n<pre><code>import math\nimport time\n\n\ndef op_sieve(limit):\n lst = [y for y in range(limit + 1)]\n for i in range(0, len(lst)): # i = 1 and i is traversal\n for j in range(i, 0, -1): # divisor range\n if j != 1 and j &lt; lst[i] and lst[i] % j == 0:\n if j in lst:\n lst[i] = 0\n break\n\n for k in range(len(lst)):\n if 0 in lst:\n lst.remove(0)\n if 1 in lst:\n lst.remove(1)\n return lst\n\n\ndef sieve(limit):\n s = [True for i in range(limit + 1)]\n s[0] = s[1] = False\n\n for i in range(4, limit + 1, 2):\n s[i] = False\n\n for i in range(3, math.floor(math.sqrt(limit)) + 1, 2):\n if s[i]:\n for m in range(2 * i, limit + 1, i):\n s[m] = False\n\n primes = []\n prime_candidate = 0\n for i in s:\n if i:\n primes.append(prime_candidate)\n prime_candidate += 1\n\n return primes\n\n\ndef sieve2(limit):\n s = [True for i in range(limit + 1)]\n s[0] = s[1] = False\n\n for i in range(2, math.floor(math.sqrt(limit)) + 1):\n if s[i]:\n for j in range(i * i, limit + 1, i):\n s[j] = False\n\n primes = []\n prime_candidate = 0\n for i in s:\n if i:\n primes.append(prime_candidate)\n prime_candidate += 1\n\n return primes\n\n\ndef millis():\n return round(time.time() * 1000)\n\n\nlimit = 5000\n\nstart = millis()\noriginal_sieve = op_sieve(limit)\nend = millis()\n\nprint(end - start)\n\nstart = millis()\nmy_sieve = sieve(limit)\nend = millis()\n\nprint(end - start)\n\nstart = millis()\nmy_sieve2 = sieve2(limit)\nend = millis()\n\nprint(end - start)\n\n#print(original_sieve)\n#print(my_sieve)\n#print(my_sieve2)\nprint(&quot;Agreed: &quot;, original_sieve == my_sieve and my_sieve == my_sieve2)\n</code></pre>\n<p>The output might be as follows:</p>\n<pre><code>7199\n2\n2\nAgreed: True\n</code></pre>\n<p>Hope that helps.</p>\n", "comments": [], "meta_data": { "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-14T11:55:49.123", "Id": "267995", "ParentId": "267944", "Score": "2" } } ]

[]

{ "AcceptedAnswerId": null, "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-13T05:04:20.983", "Id": "267944", "Score": "4", "Tags": [ "python", "algorithm", "primes" ], "Title": "My prime number generation program in Python" }

[ { "body": "<p>I am not a professional Python developer, so I will address only the performance issue: judging from you <code>for</code> loops structure, it seems that the running time of your implementation is <span class=\"math-container\">\\$\\Theta(n^2)\\$</span>, where <span class=\"math-container\">\\$n\\$</span> is the prime limit. However, you can do the same in <span class=\"math-container\">\\$O(n \\log n)\\$</span>, or even, <span class=\"math-container\">\\$O(n \\log \\log n)\\$</span> time. (See below.)</p>\n<pre><code>import math\nimport time\n\n\ndef op_sieve(limit):\n lst = [y for y in range(limit + 1)]\n for i in range(0, len(lst)): # i = 1 and i is traversal\n for j in range(i, 0, -1): # divisor range\n if j != 1 and j &lt; lst[i] and lst[i] % j == 0:\n if j in lst:\n lst[i] = 0\n break\n\n for k in range(len(lst)):\n if 0 in lst:\n lst.remove(0)\n if 1 in lst:\n lst.remove(1)\n return lst\n\n\ndef sieve(limit):\n s = [True for i in range(limit + 1)]\n s[0] = s[1] = False\n\n for i in range(4, limit + 1, 2):\n s[i] = False\n\n for i in range(3, math.floor(math.sqrt(limit)) + 1, 2):\n if s[i]:\n for m in range(2 * i, limit + 1, i):\n s[m] = False\n\n primes = []\n prime_candidate = 0\n for i in s:\n if i:\n primes.append(prime_candidate)\n prime_candidate += 1\n\n return primes\n\n\ndef sieve2(limit):\n s = [True for i in range(limit + 1)]\n s[0] = s[1] = False\n\n for i in range(2, math.floor(math.sqrt(limit)) + 1):\n if s[i]:\n for j in range(i * i, limit + 1, i):\n s[j] = False\n\n primes = []\n prime_candidate = 0\n for i in s:\n if i:\n primes.append(prime_candidate)\n prime_candidate += 1\n\n return primes\n\n\ndef millis():\n return round(time.time() * 1000)\n\n\nlimit = 5000\n\nstart = millis()\noriginal_sieve = op_sieve(limit)\nend = millis()\n\nprint(end - start)\n\nstart = millis()\nmy_sieve = sieve(limit)\nend = millis()\n\nprint(end - start)\n\nstart = millis()\nmy_sieve2 = sieve2(limit)\nend = millis()\n\nprint(end - start)\n\n#print(original_sieve)\n#print(my_sieve)\n#print(my_sieve2)\nprint(&quot;Agreed: &quot;, original_sieve == my_sieve and my_sieve == my_sieve2)\n</code></pre>\n<p>The output might be as follows:</p>\n<pre><code>7199\n2\n2\nAgreed: True\n</code></pre>\n<p>Hope that helps.</p>\n", "comments": [], "meta_data": { "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-14T11:55:49.123", "Id": "267995", "ParentId": "267944", "Score": "2" } } ]

[]

{ "AcceptedAnswerId": null, "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-13T05:04:20.983", "Id": "267944", "Score": "4", "Tags": [ "python", "algorithm", "primes" ], "Title": "My prime number generation program in Python" }

[ { "body": "<p>I am not a professional Python developer, so I will address only the performance issue: judging from you <code>for</code> loops structure, it seems that the running time of your implementation is <span class=\"math-container\">\\$\\Theta(n^2)\\$</span>, where <span class=\"math-container\">\\$n\\$</span> is the prime limit. However, you can do the same in <span class=\"math-container\">\\$O(n \\log n)\\$</span>, or even, <span class=\"math-container\">\\$O(n \\log \\log n)\\$</span> time. (See below.)</p>\n<pre><code>import math\nimport time\n\n\ndef op_sieve(limit):\n lst = [y for y in range(limit + 1)]\n for i in range(0, len(lst)): # i = 1 and i is traversal\n for j in range(i, 0, -1): # divisor range\n if j != 1 and j &lt; lst[i] and lst[i] % j == 0:\n if j in lst:\n lst[i] = 0\n break\n\n for k in range(len(lst)):\n if 0 in lst:\n lst.remove(0)\n if 1 in lst:\n lst.remove(1)\n return lst\n\n\ndef sieve(limit):\n s = [True for i in range(limit + 1)]\n s[0] = s[1] = False\n\n for i in range(4, limit + 1, 2):\n s[i] = False\n\n for i in range(3, math.floor(math.sqrt(limit)) + 1, 2):\n if s[i]:\n for m in range(2 * i, limit + 1, i):\n s[m] = False\n\n primes = []\n prime_candidate = 0\n for i in s:\n if i:\n primes.append(prime_candidate)\n prime_candidate += 1\n\n return primes\n\n\ndef sieve2(limit):\n s = [True for i in range(limit + 1)]\n s[0] = s[1] = False\n\n for i in range(2, math.floor(math.sqrt(limit)) + 1):\n if s[i]:\n for j in range(i * i, limit + 1, i):\n s[j] = False\n\n primes = []\n prime_candidate = 0\n for i in s:\n if i:\n primes.append(prime_candidate)\n prime_candidate += 1\n\n return primes\n\n\ndef millis():\n return round(time.time() * 1000)\n\n\nlimit = 5000\n\nstart = millis()\noriginal_sieve = op_sieve(limit)\nend = millis()\n\nprint(end - start)\n\nstart = millis()\nmy_sieve = sieve(limit)\nend = millis()\n\nprint(end - start)\n\nstart = millis()\nmy_sieve2 = sieve2(limit)\nend = millis()\n\nprint(end - start)\n\n#print(original_sieve)\n#print(my_sieve)\n#print(my_sieve2)\nprint(&quot;Agreed: &quot;, original_sieve == my_sieve and my_sieve == my_sieve2)\n</code></pre>\n<p>The output might be as follows:</p>\n<pre><code>7199\n2\n2\nAgreed: True\n</code></pre>\n<p>Hope that helps.</p>\n", "comments": [], "meta_data": { "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-14T11:55:49.123", "Id": "267995", "ParentId": "267944", "Score": "2" } } ]

[]

{ "AcceptedAnswerId": null, "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-17T11:15:01.213", "Id": "268075", "Score": "2", "Tags": [ "python", "python-3.x", "multithreading" ], "Title": "Avoid global variable due to executor.map()" }

[ { "body": "<p>Your</p>\n<pre><code>try:\n value = socket.gethostbyname(s)\nexcept socket.gaierror:\n raise argparse.ArgumentTypeError(f&quot;Host '{s}' could not be resolved.&quot;)\nreturn value\n</code></pre>\n<p>should probably be</p>\n<pre class=\"lang-py prettyprint-override\"><code>try:\n return socket.gethostbyname(s)\nexcept socket.gaierror as e:\n raise argparse.ArgumentTypeError(f&quot;Host '{s}' could not be resolved.&quot;) from e\n</code></pre>\n<p>in other words, it's usually a good idea to maintain rather than break the exception cause chain.</p>\n<p>I would move your <code>except KeyboardInterrupt</code> up to a <code>try</code> in <code>main</code>, and rather than exiting, just <code>pass</code>. That way testers or external callers of <code>scan_tcp</code> can make their own decisions about how to handle keyboard interrupts.</p>\n<p>Why build up a list of <code>results</code> and defer printing until the end? Why not print results as you find them?</p>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-18T09:11:38.723", "Id": "528685", "Score": "0", "body": "thx for the advice. I build up a list and print at the end as otherwise The progress bar always gets interrupted so u have progressbar port x port y progressbar etc. and I didn't find that very pretty." } ], "meta_data": { "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-17T17:48:50.673", "Id": "268089", "ParentId": "268075", "Score": "2" } } ]

[]

{ "AcceptedAnswerId": null, "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-17T11:15:01.213", "Id": "268075", "Score": "2", "Tags": [ "python", "python-3.x", "multithreading" ], "Title": "Avoid global variable due to executor.map()" }

[ { "body": "<p>Your</p>\n<pre><code>try:\n value = socket.gethostbyname(s)\nexcept socket.gaierror:\n raise argparse.ArgumentTypeError(f&quot;Host '{s}' could not be resolved.&quot;)\nreturn value\n</code></pre>\n<p>should probably be</p>\n<pre class=\"lang-py prettyprint-override\"><code>try:\n return socket.gethostbyname(s)\nexcept socket.gaierror as e:\n raise argparse.ArgumentTypeError(f&quot;Host '{s}' could not be resolved.&quot;) from e\n</code></pre>\n<p>in other words, it's usually a good idea to maintain rather than break the exception cause chain.</p>\n<p>I would move your <code>except KeyboardInterrupt</code> up to a <code>try</code> in <code>main</code>, and rather than exiting, just <code>pass</code>. That way testers or external callers of <code>scan_tcp</code> can make their own decisions about how to handle keyboard interrupts.</p>\n<p>Why build up a list of <code>results</code> and defer printing until the end? Why not print results as you find them?</p>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-18T09:11:38.723", "Id": "528685", "Score": "0", "body": "thx for the advice. I build up a list and print at the end as otherwise The progress bar always gets interrupted so u have progressbar port x port y progressbar etc. and I didn't find that very pretty." } ], "meta_data": { "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-17T17:48:50.673", "Id": "268089", "ParentId": "268075", "Score": "2" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-24T16:38:51.517", "Id": "529167", "Score": "0", "body": "You will get much better answers faster if you provide a full runnable snippet with some reasonable test data." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-13T20:16:34.667", "Id": "530523", "Score": "0", "body": "Thanks for your feedback, I will certainly do that in the future! In the mean time I was able to find a solution which I am posting below." } ]

{ "AcceptedAnswerId": "268965", "CommentCount": "2", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-18T19:47:18.113", "Id": "268125", "Score": "2", "Tags": [ "python", "performance", "pandas" ], "Title": "Finding the difference in one column in a Pandas GroupBy" }

[ { "body": "<p>I was recently able to resolve this by removing one of my constraints. In the original post I noted that I need to include the start and end time to make up for low simulation time. The actual solution to low simulation time is quite simple; increase the simulation time. I also add a condition that revisit is only counted if it is longer than a couple of hours. With that, you get some pretty reasonable estimates.</p>\n<p>Calculating revisit is still a bit painful though. I include below the code that I used for this, but the difficult part came from <a href=\"https://stackoverflow.com/questions/20648346/computing-diffs-within-groups-of-a-dataframe\">this StackOverflow post.</a></p>\n<pre><code># Round lat and long and then use groupby to throw them all in similar buckets\nspecular_df['approx_LatSp'] = round(specular_df['LatSp'],1)\nspecular_df['approx_LonSp'] = round(specular_df['LonSp'],1)\n\n# Calculate time difference\nspecular_df.sort_values(by=['approx_LatSp', 'approx_LonSp', 'JulianDay'], inplace=True)\nspecular_df['revisit'] = specular_df['JulianDay'].diff()\n\n# Correct for borders\nspecular_df['revisit'].mask(specular_df.approx_LatSp != specular_df.approx_LatSp.shift(1), other=np.nan, inplace=True)\nspecular_df['revisit'].mask(specular_df.approx_LonSp != specular_df.approx_LonSp.shift(1), other=np.nan, inplace=True)\n\n# Get max revisit and store in new DF\nindeces = specular_df.groupby(['approx_LatSp', 'approx_LonSp'])['revisit'].transform(max) == specular_df['revisit']\n\nmax_rev_area_df = specular_df[indeces]\nmax_rev_area_df['revisit'].mask(max_rev_area_df['revisit'] &lt; 0.04, other=np.nan, inplace=True)\n</code></pre>\n", "comments": [], "meta_data": { "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-13T20:21:56.817", "Id": "268965", "ParentId": "268125", "Score": "1" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-20T03:51:42.370", "Id": "528771", "Score": "0", "body": "Use example 1, but please show all of your code." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-20T04:19:40.247", "Id": "528772", "Score": "0", "body": "@Reinderien This is all of the code. It's just an example I made up for my question." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-21T01:58:36.223", "Id": "528817", "Score": "0", "body": "There is a third option--use `calc_feedx(**params)`. It shortens code a lot, but violates PEP 20's \"Explicit is better than implicit.\". I think all three are reasonable options." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-21T03:55:28.893", "Id": "528826", "Score": "0", "body": "@ZacharyVance Your suggestion does not work because inputs to `calc_feedx(d, rho, temp)` are only `d`, `rho`, and `temp`. Using `**params` causes an error because the dictionary contains more parameters than what the function uses." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-21T04:00:38.480", "Id": "528827", "Score": "0", "body": "That's a good point I didn't notice. You could add a **kwargs to calc_feedx which is silently discarded, but that's pretty ugly." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-21T07:52:01.377", "Id": "528837", "Score": "0", "body": "I'm afraid this question does not match what this site is about. Code Review is about improving existing, working code. The example code that you have posted is not reviewable in this form because it leaves us guessing at your intentions. Unlike Stack Overflow, Code Review needs to look at concrete code in a real context. Please see [Why is hypothetical example code off-topic for CR?](//codereview.meta.stackexchange.com/q/1709)" } ]

{ "AcceptedAnswerId": "268194", "CommentCount": "6", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-20T00:37:53.510", "Id": "268168", "Score": "0", "Tags": [ "python", "configuration" ], "Title": "Utilize values in a parameters file for function inputs" }

[ { "body": "<p>What is missing is context. Example one is fine, but what if it contained 10 or 15 parameters? That means that you probably have some objects hiding in there.</p>\n<p>The problem with the second example is that you pass the whole params object in, but only need feedstock. calc_feedx(feedstock) would be much more appropriate, which makes it basically equivalent to the first example.</p>\n<p>Which brings me to this point - params object should not live everywhere. In fact it should stay as far away from your main logic as possible. What if you decide to host configuration on a server, are you going to rewrite the logic? Also, what if you change the names you use in the core of the app or in configuration? (These are just the examples off the top of my head). What I'm basically saying is that you should have configuration decoupled from the logic to avoid a potential mess.</p>\n<p>So don't think how you will make the code work with configuration, but how will you make configuration work with code if that makes sense. The way you can go about reading configuration is basically endless and the structure of the configuration could also be independent of your app.</p>\n<p>Edit:</p>\n<p>Here is the example:</p>\n<pre><code>def read_toml_config(path):\n def read(path):\n with open(self.file, 'r') as f:\n return toml.load(f)\n\n def map(raw_config):\n return { &quot;foo&quot;: raw_config[&quot;bar&quot;] }\n\n raw_config = read(path)\n return map(raw_config)\n\n# You decide how config object should look for your app\n# because the properties are determined by the read_toml_config\n# function and not by the path.toml file\nconfig = read_toml_config('path.toml')\n\n# calc_feedx does not know that the config exists\n# all it knows is that foo exists, which it needs\ncalc_feedx(config[&quot;foo&quot;])\n</code></pre>\n<p>You could generify read_toml_config to any other configuration -&gt; you read it in some way and then you map it to your application's needs. And you don't pass the whole configuration around, but just the objects the functions need. And at the same time, you might not read in the whole configuration from path.toml, but just the values you need -&gt; the code becomes the source of truth.</p>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-20T18:30:55.020", "Id": "528810", "Score": "0", "body": "I think I understand what you're saying. Can you provide a code example of how you would decouple the parameters file (configuration) from the logic?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-21T04:04:27.453", "Id": "528828", "Score": "0", "body": "Mapping the dictionary to another dictionary seems redundant to me. For my work, the parameter names defined in the TOML file are descriptive so there is no need to rename them elsewhere in the project. The parameter names in the code are typically consistent with their names in the parameters file." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-21T08:36:07.493", "Id": "528841", "Score": "0", "body": "You don't always need to map, but it is useful to have the config object defined by your code -> this is the responsibility of read_toml_config." } ], "meta_data": { "CommentCount": "3", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-20T17:01:20.077", "Id": "268194", "ParentId": "268168", "Score": "1" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-23T14:17:03.230", "Id": "529034", "Score": "2", "body": "What do `alphabet_position`, `count_smileys` and the Bingo stuff have to do with each other? It seems they're completely unrelated. Also: What are they supposed to do? Task description(s) is/are missing." } ]

{ "AcceptedAnswerId": "268295", "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-23T09:23:05.687", "Id": "268283", "Score": "2", "Tags": [ "python", "python-3.x" ], "Title": "Find alphabet position, count smileys, and play bingo with assertion testing" }

[ { "body": "<blockquote>\n<pre><code>random.seed(42)\n</code></pre>\n</blockquote>\n<p>We only want to do this in the <code>main</code> guard, not when loaded as a module. It's really part of the test function, not the module.</p>\n<blockquote>\n<pre><code>total = 0\n# Add 1 if it matches a face (Only works in Python 3.8 or greater)\n[total := total + 1 for s in smileys if bool(re.search(pattern, s))]\nreturn total\n</code></pre>\n</blockquote>\n<p>We can use <code>sum()</code> for counting:</p>\n<pre><code>return sum(1 for s in smileys if re.search(pattern, s))\n</code></pre>\n<p>We might want to make a separate function for <code>is_smiley()</code>, simply to make the tests more specific. Also consider compiling the regular expression just once, using <code>re.compile()</code>.</p>\n<p>On the subject of tests, seriously consider using the <code>doctest</code> module, to keep your tests close to the code they exercise. That would look like this for the <code>count_smileys()</code> function:</p>\n<pre><code>import re\n\nSMILEY_REGEX = re.compile(r'(:|;)(-|~)?(\\)|D)')\n\ndef count_smileys(smileys: list) -&gt; int:\n &quot;&quot;&quot;\n Return the number of strings in SMILEYS which contain at least one smiley face.\n\n &gt;&gt;&gt; count_smileys([])\n 0\n &gt;&gt;&gt; count_smileys([':D', ':~)', ';~D', ':)'])\n 4\n &gt;&gt;&gt; count_smileys([':)',':(',':D',':O',':;'])\n 2\n &gt;&gt;&gt; count_smileys([';]', ':[', ';*', ':$', ';-D'])\n 1\n &quot;&quot;&quot;\n return sum(1 for s in smileys if SMILEY_REGEX.search(s))\n\nif __name__ == &quot;__main__&quot;:\n import doctest\n doctest.testmod()\n</code></pre>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-23T15:32:05.470", "Id": "529039", "Score": "0", "body": "Just wondering: have you ever written/seen a program exceeding the compiled patterns cache?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-23T16:27:57.750", "Id": "529045", "Score": "0", "body": "Actually, I'd forgotten the cache. Are you saying it's better to just `re.compile()` every time the function is called? I'm not an expert with `re` internals." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-23T16:36:56.573", "Id": "529048", "Score": "0", "body": "No, I was thinking of just using `re.search`. But the explicit `compile` way [does indeed look much faster](https://tio.run/##bVGxbsIwEN39Fbcg@1BCC1naIMRCVFVql3ZplUYoBVMsEdtyzICE@PXUjkloS2@x/O69e88@fbBbJZM7bZpmY1QFVlRcWBCVVsaC4ZqXlpCa272GGVBKSd8irWCzlyur1K7uNLo0VpQ7oktruZFOZShLj1Nk8fGEc/aBxwVS8vr8@JS9L1@yh@zNc/hopSotdpydhehcS7PauuZP7iigpPZx0thN8oYHdzsbMzcqcCL4M2ry24jm6bTI41Mxz3FRUOxG@1eSzHFzAq5oP7CLFkGNNArNf7KxS/cKaMNeESYBKQjZKANLEBJMKb84SzBteR7mHs7C3ZfcV5/cuJjjW1897lfof6d22@BrFnbIuAvttxiddbNwIOZpUvRabYS0bMjoIFmDrIHCAJiFm85sCGN@j20c6@O0XhgBR3KRY9N8Aw), at least with such short test strings." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-24T14:34:56.047", "Id": "529137", "Score": "0", "body": "@TobySpeight thanks a lot for your answer. I'm struggling to understand though what the difference between re.compile vs re.search is." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-24T14:47:47.537", "Id": "529139", "Score": "2", "body": "`re.search()` takes a string, which needs to be turned into a regular expression automaton (i.e. compiled) each time the function is called. `re.compile()` does just the compilation, and allows us to reuse the internal form rather than constructing it anew each time we want to search. I think [the documentation](https://docs.python.org/3/library/re.html#re.compile) explains that better than I could!" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-24T14:55:21.100", "Id": "529141", "Score": "0", "body": "Thanks again! Brilliant answer!" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-25T12:55:38.427", "Id": "529245", "Score": "1", "body": "@TobySpeight No, `re.search` and others do **not** compile anew each time. At the end of exactly that section you yourself linked to it says *\"**The compiled versions of** [...] and the **module-level matching functions are cached**, so programs that use only a few regular expressions at a time needn’t worry about compiling regular expressions\"*." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-25T12:55:55.880", "Id": "529246", "Score": "0", "body": "Ah, so explicitly compiling only saves the cache lookup? Thanks for educating me." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-25T13:12:15.480", "Id": "529248", "Score": "0", "body": "As far as I can tell from that documentation and looking at the source code, yes. I'm also trying to verify it experimentally by inserting prints around the caching code, but somehow that makes the code hang/crash every time. I do see a few prints, but not of my test regex but of others." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-25T13:19:08.317", "Id": "529249", "Score": "0", "body": "Apparently somehow it just didn't like my prints. So I collected data in a list `re.foo` instead and printed that afterwards. Trying `re.search('foo', 'foobar')` five times led to [this lookup](https://github.com/python/cpython/blob/1f08d16c90b6619607fe0656328062ab986cce29/Lib/re.py#L294) failing once and succeeding the remaining four times." } ], "meta_data": { "CommentCount": "10", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-23T14:37:20.263", "Id": "268295", "ParentId": "268283", "Score": "4" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-23T11:55:01.000", "Id": "529023", "Score": "0", "body": "Do you want this to be `1-2 digits + 5*random uppercased letters + ...` or it can be any random string?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-23T11:57:42.137", "Id": "529024", "Score": "0", "body": "Yes, exactly. I model 31SPZVG2CZ2R8WFU this key as example. So digits+strs.. etc" } ]

{ "AcceptedAnswerId": "268292", "CommentCount": "2", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-23T11:51:19.193", "Id": "268290", "Score": "1", "Tags": [ "python", "random" ], "Title": "Generate random string to match a specific pattern" }

[ { "body": "<p>In your <code>random_char</code> function, you don't use <code>x</code> at all. Replace it with <code>_</code> (it's conventional in python to use <code>_</code> for throwaway variables). <code>y</code> could also be renamed to something more descriptive. The name of the function could also be renamed to <code>random_chars</code> since you're generating one or more of them.</p>\n<p>Also, use string formatting instead of all those extra variables:</p>\n<pre><code>def generate_key():\n return (f&quot;{random.randrange(1, 9)}{random_chars(5)}{random.randrange(1, 9)}{random_chars(2)}&quot; \n f&quot;{random.randrange(1, 9)}{random_chars(1)}{random.randrange(1, 9)}{random_chars(3)}&quot;)\n</code></pre>\n<p>Note that the f-strings are available for Python versions &gt;= 3.6</p>\n<p>As a side note, there's this nice <a href=\"https://github.com/asciimoo/exrex\" rel=\"nofollow noreferrer\">exrex</a> which can:</p>\n<blockquote>\n<p>Generate all - or random - matching strings to a given regular\nexpression and more. It's pure python, without external dependencies.</p>\n</blockquote>\n<p>Given some pattern (similar to what you want):</p>\n<pre><code>r&quot;(\\d[A-Z]{1,4}){4}&quot;\n</code></pre>\n<ul>\n<li><code>(...){4}</code> matches the previous token exactly 4 times.</li>\n<li><code>\\d</code> matches a digit (equivalent to <code>[0-9]</code>)</li>\n<li><code>[A-Z]{1,4}</code> matches the previous token between 1 and 4 times, as many times as possible, giving back as needed (greedy)</li>\n<li><code>A-Z</code> matches a single character in the range between A (index 65) and Z (index 90) (case sensitive)</li>\n</ul>\n<p><em>Note: I'm not a regex expert so there might be an easier / more correct version of this.</em></p>\n<p>I think you can use this regex which returns exactly the pattern you want: <code>\\d{1,2}[A-Z]{5}\\d[A-Z]{2}\\d[A-Z]{1}\\d[A-Z]{3}</code></p>\n<p>Your entire code could be rewritten as:</p>\n<pre><code>import exrex\n\nrandom_key = exrex.getone(r'(\\d[A-Z]{1,4}){4}')\nprint(random_key)\n</code></pre>\n<p>Which would generate:</p>\n<pre><code>'3C2BBV3NGKJ2XYJ'\n</code></pre>\n<p>For more information about regular expressions feel free to search on the internet to get familiar with them. For tests, I usually use <a href=\"https://regex101.com/\" rel=\"nofollow noreferrer\">regex101</a></p>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-23T12:57:05.110", "Id": "529028", "Score": "0", "body": "As an advice, before accepting an answer try to wait 1-2 days to see alternative solutions/improvements." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-23T13:26:29.963", "Id": "529031", "Score": "0", "body": "Is this right? The pattern you're using doesn't seem to follow the OP's, for instance having two leading digits." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-23T13:40:55.460", "Id": "529032", "Score": "1", "body": "@Reinderien It's just an example. I've specified in my answer that this regex might not be as the one in the question. And with a bit of effort from OP it can be easily modified/customized. More, that is an alternate solution for OP to have in mind ^^. //L.E: added a similar regex" } ], "meta_data": { "CommentCount": "3", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-23T12:36:51.060", "Id": "268292", "ParentId": "268290", "Score": "2" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-24T07:44:27.363", "Id": "529082", "Score": "0", "body": "You may be interested in the SO question [What is the cleanest way to do a sort plus uniq on a Python list?](//stackoverflow.com/q/2931672/4850040)" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-24T12:26:45.807", "Id": "529113", "Score": "1", "body": "Do you know that your ENTIRE script can be replaced with this ONE-liner: `sorted(set(l))`? This is extremely basic, `set` is a built-in data type that is ordered without duplicates with fast membership checking that is exactly what is designed to do this sort of thing, and then you just need to use `sorted` function to return a sorted (shallow) copy of the list. Type casting is by far the most efficient and readable way to do this." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-24T14:44:06.207", "Id": "529138", "Score": "0", "body": "@XeнεiΞэnвϵς I tried your `sorted(set(l))`. Didn't work. Got `NameError: name 'l' is not defined`." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-24T15:43:50.567", "Id": "529157", "Score": "0", "body": "@BolucPapuccuoglu `NameError: name 'z' is not defined`." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-24T15:46:44.180", "Id": "529161", "Score": "0", "body": "Oh boy I did not knew that @XeнεiΞэnвϵς LOL, but I just figured it out, anyways, I'm pretty sure the Question wanted me to do it by myself, but anyways thank you for your tip." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-24T15:48:48.410", "Id": "529163", "Score": "3", "body": "@BolucPapuccuoglu Yeah, but XeнεiΞэnвϵς said to replace ENTIRE script with that (shouting already theirs)." } ]

{ "AcceptedAnswerId": null, "CommentCount": "6", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-24T01:09:09.133", "Id": "268315", "Score": "6", "Tags": [ "python", "beginner", "python-3.x" ], "Title": "Remove repeated numbers from a list" }

[ { "body": "<p>It's a good start. Depending on what class this is for, the person (teacher?) who proposed this question to you might care about time complexity of your solution. Your solution is going to have a number of problems there, since:</p>\n<ul>\n<li><code>del z[y]</code> is linear-time (&quot;O(n)&quot;)</li>\n<li>That occurs within a loop over the list, within <em>another</em> loop over the list, making the solution worst-case cubic if I'm not mistaken.</li>\n</ul>\n<p>The trivial and common solution is to scrap the whole routine and replace it with calls to two built-ins:</p>\n<pre><code>from typing import Iterable, List\n\n\ndef remove_repeated_numbers(numbers: Iterable[int]) -&gt; List[int]:\n return sorted(set(numbers))\n</code></pre>\n<p>I will leave it as an exercise to you to read the <a href=\"https://wiki.python.org/moin/TimeComplexity\" rel=\"noreferrer\">documentation</a> and determine the complexity of this implementation.</p>\n<p>This will construct a set from the numbers, which guarantees uniqueness but not order; and then constructs a sorted list from that. Interpreted literally, the question doesn't call for the existence of a <code>main</code> but I don't know how picky the problem is.</p>\n<p>Other things to note:</p>\n<ul>\n<li>Don't use single-letter variables</li>\n<li>Add type hints for greater clarity</li>\n</ul>\n", "comments": [], "meta_data": { "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-24T03:04:23.770", "Id": "268317", "ParentId": "268315", "Score": "7" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-24T07:44:27.363", "Id": "529082", "Score": "0", "body": "You may be interested in the SO question [What is the cleanest way to do a sort plus uniq on a Python list?](//stackoverflow.com/q/2931672/4850040)" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-24T12:26:45.807", "Id": "529113", "Score": "1", "body": "Do you know that your ENTIRE script can be replaced with this ONE-liner: `sorted(set(l))`? This is extremely basic, `set` is a built-in data type that is ordered without duplicates with fast membership checking that is exactly what is designed to do this sort of thing, and then you just need to use `sorted` function to return a sorted (shallow) copy of the list. Type casting is by far the most efficient and readable way to do this." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-24T14:44:06.207", "Id": "529138", "Score": "0", "body": "@XeнεiΞэnвϵς I tried your `sorted(set(l))`. Didn't work. Got `NameError: name 'l' is not defined`." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-24T15:43:50.567", "Id": "529157", "Score": "0", "body": "@BolucPapuccuoglu `NameError: name 'z' is not defined`." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-24T15:46:44.180", "Id": "529161", "Score": "0", "body": "Oh boy I did not knew that @XeнεiΞэnвϵς LOL, but I just figured it out, anyways, I'm pretty sure the Question wanted me to do it by myself, but anyways thank you for your tip." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-24T15:48:48.410", "Id": "529163", "Score": "3", "body": "@BolucPapuccuoglu Yeah, but XeнεiΞэnвϵς said to replace ENTIRE script with that (shouting already theirs)." } ]

{ "AcceptedAnswerId": null, "CommentCount": "6", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-24T01:09:09.133", "Id": "268315", "Score": "6", "Tags": [ "python", "beginner", "python-3.x" ], "Title": "Remove repeated numbers from a list" }

[ { "body": "<p>It's a good start. Depending on what class this is for, the person (teacher?) who proposed this question to you might care about time complexity of your solution. Your solution is going to have a number of problems there, since:</p>\n<ul>\n<li><code>del z[y]</code> is linear-time (&quot;O(n)&quot;)</li>\n<li>That occurs within a loop over the list, within <em>another</em> loop over the list, making the solution worst-case cubic if I'm not mistaken.</li>\n</ul>\n<p>The trivial and common solution is to scrap the whole routine and replace it with calls to two built-ins:</p>\n<pre><code>from typing import Iterable, List\n\n\ndef remove_repeated_numbers(numbers: Iterable[int]) -&gt; List[int]:\n return sorted(set(numbers))\n</code></pre>\n<p>I will leave it as an exercise to you to read the <a href=\"https://wiki.python.org/moin/TimeComplexity\" rel=\"noreferrer\">documentation</a> and determine the complexity of this implementation.</p>\n<p>This will construct a set from the numbers, which guarantees uniqueness but not order; and then constructs a sorted list from that. Interpreted literally, the question doesn't call for the existence of a <code>main</code> but I don't know how picky the problem is.</p>\n<p>Other things to note:</p>\n<ul>\n<li>Don't use single-letter variables</li>\n<li>Add type hints for greater clarity</li>\n</ul>\n", "comments": [], "meta_data": { "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-24T03:04:23.770", "Id": "268317", "ParentId": "268315", "Score": "7" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-25T05:29:11.917", "Id": "529207", "Score": "0", "body": "I'm not sure why you removed the Python part of your program, since it makes your question off-topic. If the Python code works, you can put it back. If it doesn't work, the question wasn't ready for review. Please take a look at the [help/on-topic]." } ]

{ "AcceptedAnswerId": null, "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-25T00:22:30.063", "Id": "268364", "Score": "2", "Tags": [ "python", "beginner", "python-3.x", "functional-programming" ], "Title": "Garden simulator" }

[ { "body": "<h2>Pseudocode</h2>\n<p>First, your block-quoted pseudo-code is too much like code, and not enough pseudo. The purpose of pseudo-code is understanding. If it doesn't help you to understand, or if it doesn't help someone else (like a professor) to understand, then you're doing it wrong. In general, I'd suggest writing your pseudo-code in successive waves of refinement. Something like this:</p>\n<pre><code>while not done:\n get user choice()\n if choice is 'wait':\n get rainfall()\n if rainfall amount &lt; threshold:\n kill one plant()\n produce food from plants remaining()\n if choice is 'add plant':\n add new plant()\n if choice is 'display plants':\n display plants()\n if choice is 'quit':\n quit()\n \n print daily report()\n</code></pre>\n<p>That's probably enough to get yourself started writing code, and it might be enough to make a teacher happy. The details should be in the code itself, unless you are forced to change your logic.</p>\n<h2>Naming</h2>\n<p>You need to read and apply the <a href=\"https://www.pep8.org\" rel=\"nofollow noreferrer\">Python style guide.</a></p>\n<p>In particular: documentation for functions goes in the function's docstring. Constants should be ALL_CAPS.</p>\n<h2>Functions</h2>\n<p>You have some good functions. But I submit to you that each time you have a comment in your code, that's probably a good place for a function. Sometimes, you can combine several comments into a single function, but in general, if you're explaining what happens, you can explain better using a function and its accompanying docstring:</p>\n<pre><code> if rainfall &lt; high_threshold: \n plant_die = random.choice(plants) # pick random a plant for too little rain\n print(f&quot;Sadly, your {plant_die} plant has died&quot;) \n plants.remove(plant_die) # remove plant from list\n</code></pre>\n<p>Could be rewritten as:</p>\n<pre><code>if rainfall &lt; high_threshold:\n one_plant_dies(plants)\n</code></pre>\n<h2>Wrapping</h2>\n<p>Your text output functions are relying on the <code>print()</code> statement to emit each line. This means that wrapping of text is occurring at the line level.</p>\n<p>In many cases, you would do better to use the <a href=\"https://docs.python.org/3/library/textwrap.html\" rel=\"nofollow noreferrer\"><code>textwrap</code> </a> module to perform wrapping for you, and put entire paragraphs in <em>&quot;&quot;&quot;triple quotes.&quot;&quot;&quot;</em></p>\n<h2>Results</h2>\n<p>You have written all your functions as procedures -- subroutines that do not return a value. If you haven't encountered the <code>return</code> statement, I encourage you to read about it. You will find it very hard to use the SRP if you cannot return values.</p>\n<p>Much of your code looks like:</p>\n<pre class=\"lang-none prettyprint-override\"><code>print some information\nget some input\n</code></pre>\n<p>That sort of thing is a good candidate for encapsulation in a function that returns <em>well validated</em> result. Thus, your code might be something like:</p>\n<pre><code>def get_user_preference(params):\n while True:\n print some information\n get some input\n if input is valid:\n return result(input)\n</code></pre>\n<h2>main()</h2>\n<p>There's a standard way to handle calling the main entry point of your program or module:</p>\n<pre><code>if __name__ == '__main__':\n main()\n</code></pre>\n<p>The purpose and value of this is that it will call <code>main()</code> when you just run <code>python mycode.py</code> but it will <em>not</em> call anything if you <code>import mycode</code>. This is valuable if you are writing a program that is also a library, or if you are using a unit test driver that will import your code into its test engine.</p>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-25T02:20:46.223", "Id": "529203", "Score": "0", "body": "thank you so much. I was able to fix my code and create the 3 functions for wait option. I still don't understand how I can come up with psuedo code prior to programming, but I will be working on that." } ], "meta_data": { "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-25T01:46:30.813", "Id": "268365", "ParentId": "268364", "Score": "2" } } ]

[]

{ "AcceptedAnswerId": null, "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-27T15:07:35.237", "Id": "268439", "Score": "1", "Tags": [ "python-3.x" ], "Title": "Python code to check the null values in excel files" }

[ { "body": "<p>Use <code>print()</code> or <code>write()</code> for normal program output. The <code>logging</code> module is generally for recording information about how the program is running, e.g., for debugging, performance monitoring, etc.</p>\n<p>I'd recommend using <code>pathlib</code> in the standard library. <code>Path.rglob()</code> would be useful, it recursively searches directories for files with names that match a pattern, such as &quot;*.xlsx&quot;. Using it lets you eliminate the nested loops and a lot of the file/path handling code.</p>\n<p><code>pd.read_excel()</code> accepts a <code>pathlib.Path</code> for the first argument.</p>\n<p>The code collects the counts and path for each file, so the information can be sorted. This makes it easier to see which files have nulls, because they are grouped together.</p>\n<p>Use <code>f-strings</code> instead of string concatenation.</p>\n<p>I don't have excel files on this machine, so this code isn't tested:</p>\n<pre><code>import pandas as pd\nimport pathlib\n\nnull_counts = []\n\nstart_path = pathlib.Path(r&quot;C:\\Users\\Documents\\python\\Emp&quot;)\n\nfor file_path in start_path.rglob('*.xlsx'):\n\n df = pd.read_excel(file_path, engine='openpyxl')\n count_nan = df.isnull().sum().sum()\n\n null_counts.append((count_nan, file_path))\n\n\nnull_counts.sort(reverse=True)\n\nwith open('nanTest.log', 'wt') as output:\n for count, filepath in null_counts:\n print(f&quot;{count:5} {filepath}&quot;, file=output)\n</code></pre>\n", "comments": [], "meta_data": { "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-27T20:29:54.690", "Id": "268451", "ParentId": "268439", "Score": "1" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-28T08:33:52.073", "Id": "529433", "Score": "1", "body": "You might want to look through the answers to [Padding a hexadecimal string with zeros](/q/67611/75307), as it's a very similar problem." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-29T00:39:39.537", "Id": "529485", "Score": "1", "body": "@TobySpeight Sadly, I don't think that's going to buy OP a lot, since the pandas vectorized approach doesn't support the typical native approach." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-29T06:55:15.563", "Id": "529494", "Score": "0", "body": "@Reinderien, fair enough - I've never worked with pandas, so I'm speaking from a relatively ignorant position." } ]

{ "AcceptedAnswerId": null, "CommentCount": "3", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-28T07:01:16.050", "Id": "268462", "Score": "0", "Tags": [ "python", "python-3.x", "comparative-review" ], "Title": "Convert string to 10 character string with leading zeros if necessary" }

[ { "body": "<p>Are you sure you want the non-numeric case to result in <code>None</code>? Pandas more commonly uses <code>NaN</code>. Anyway.</p>\n<p>You're missing an important test case: what do you want to happen for values with a non-zero post-decimal half?</p>\n<p>Option 1 is broken because you're just substituting 0 for non-numeric cases.</p>\n<p>Option 2 is non-vectorized due to the <code>map</code>, and will not catch <code>123a</code>; so it's broken too. As a bonus, your <code>slice(0, 10)</code> is slicing from the wrong end of the string.</p>\n<p>Option 3 is non-vectorized due to the <code>apply</code>, and does manual parsing of the decimal which is slightly awkward; it's also not going to catch non-numerics so it's broken.</p>\n<p>So I mean... if I were to be picky, none of your code is functioning as intended so closure would be justified; but what the heck:</p>\n<p>One approach that does not break vectorization and meets all of the edge cases would be</p>\n<ul>\n<li>Call <code>to_numeric(errors='coerce')</code> as you do in #1</li>\n<li>For valid numerals only, maintaining the original index:\n<ul>\n<li>cast to <code>int</code> to drop the decimal</li>\n<li>cast to <code>str</code></li>\n<li><code>zfill</code> and <code>slice</code> (from the end, not the beginning)</li>\n</ul>\n</li>\n<li>Save back to the data frame on valid indices only</li>\n<li>Fill the invalid indices with <code>None</code> (<code>fillna</code> is not sufficient for this purpose)</li>\n</ul>\n<h2>Suggested</h2>\n<pre class=\"lang-py prettyprint-override\"><code>import pandas as pd\n\ndf = pd.DataFrame(\n [\n 123,\n float('nan'),\n '123a',\n 1111111111119,\n 0,\n 123.0,\n 123.4,\n ],\n columns=('DATA',)\n)\nas_floats = pd.to_numeric(df.DATA, errors='coerce')\nas_strings = (\n as_floats[pd.notna(as_floats)]\n .astype(int)\n .astype(str)\n .str.zfill(10)\n .str.slice(-10)\n)\ndf['out'] = as_strings\ndf.loc[pd.isna(as_floats), 'out'] = None\n</code></pre>\n", "comments": [], "meta_data": { "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-29T00:56:42.703", "Id": "268491", "ParentId": "268462", "Score": "2" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-28T08:55:03.320", "Id": "529435", "Score": "1", "body": "Welcome to Code Review! I changed the title so that it describes what the code does per [site goals](/questions/how-to-ask): \"*State what your code does in your title, not your main concerns about it.*\". Please check that I haven't misrepresented your code, and correct it if I have." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-28T18:29:38.683", "Id": "529470", "Score": "1", "body": "Are you not allowed to use user-defined functions? What kind of class is this?" } ]

{ "AcceptedAnswerId": null, "CommentCount": "2", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-28T08:42:02.990", "Id": "268466", "Score": "2", "Tags": [ "python", "homework", "connect-four" ], "Title": "Print a Connect 4 board" }

[ { "body": "<p>I will focus on creating a readable, maintainable and scalable implementation. Even without sacrificing readbaility (by avoiding things like multiple variable assignments per line), this implementation comes in at only 15 lines. This number could be reduced further by inlining some variables, etc. but I don't think that's worth doing here.</p>\n<p>Please note that this does not include proper validation of user input, which is generally a good idea.</p>\n<hr />\n<p><strong>Complete code</strong></p>\n<p>I added some blank lines for the sake of readability:</p>\n<pre><code>standard_game = input('Standard game? (y/n): ').lower() == &quot;y&quot;\n\nif standard_game:\n ROWS = 6\n COLUMNS = 7\nelse:\n ROWS = int(input('ROWS? (2 - 20): '))\n COLUMNS = int(input('COLUMNS? (2 - 20): '))\n \nwidth_y_axis_elements = len(str(ROWS - 1))\nwidth_x_axis_elements = len(str(COLUMNS - 1)) + 1\n\ndots = '·'.rjust(width_x_axis_elements) * COLUMNS\n\nfor i in range(ROWS - 1, -1, -1):\n label = str(i).rjust(width_y_axis_elements)\n print(f&quot;{label}{dots}&quot;)\n \nx_axis = ''.join(map(lambda s: s.rjust(width_x_axis_elements), map(str, range(COLUMNS))))\nprint(f&quot;{' ' * width_y_axis_elements}{x_axis}&quot;)\n</code></pre>\n<p>The key to simplifying this implementation is realizing that <code>ROWS</code> and <code>COLUMNS</code> being below or above 10 aren't actually special cases. You only need to consider the length of the highest number on each axis and then pad everything accordingly. For this we use <a href=\"https://www.w3schools.com/python/ref_string_rjust.asp\" rel=\"nofollow noreferrer\"><code>str.rjust</code></a>. Once you understand this conceptually, the implementation is rather straightforward. Don't hesitate to ask for clarifiction if necessary!</p>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-29T15:44:08.577", "Id": "529529", "Score": "0", "body": "Thanks for your input! My class hasn't introduced str.rjust or f threads yet, so I'm not sure if I'm allowed to use this, but I'll take that idea in mind." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-29T22:55:16.103", "Id": "529556", "Score": "0", "body": "You can easily replace f-strings with string concatenation, so `f\"{label}{dots}\"` becomes `label + dots`. You could also implement `str.rjust` on your own by checking the length of your input string, comparing it to the desired length and adding spaces to the front of the string until the desired length is reached." } ], "meta_data": { "CommentCount": "2", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-28T18:14:53.150", "Id": "268482", "ParentId": "268466", "Score": "2" } } ]

[]

{ "AcceptedAnswerId": null, "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-29T14:14:30.187", "Id": "268506", "Score": "1", "Tags": [ "python", "object-oriented" ], "Title": "optimization csv from url analyzer" }

[ { "body": "<p>This is doing too much. You're trying to support reading rows as both a list and a dict; both printing and not; and reading all lines or some lines.</p>\n<p>Change the class name to follow <a href=\"https://www.python.org/dev/peps/pep-0008/\" rel=\"nofollow noreferrer\">PEP 8</a>.</p>\n<p>Drop most of your configuration options.</p>\n<ul>\n<li>Don't print lines as you go. This was debugging code and can be removed in the final version.</li>\n<li>Either return <code>list</code> or <code>dict</code> items but not both--write two classes if you really need both options.</li>\n<li>Always read all lines. Let the user directly iterate over the class. As a feature, support streaming access--I assume the reason you're avoiding reading all lines is so you can print faster.</li>\n<li>Drop <code>get_key</code> and <code>get_keys</code> entirely, make them a static method, or move them out of the class.</li>\n</ul>\n<p>A piece of example code, the way I would want to use this as a user:</p>\n<pre><code>for row in read_CSV_URL('http://winterolympicsmedals.com/medals.csv'):\n​ print(row)\n</code></pre>\n", "comments": [], "meta_data": { "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-10T02:28:31.430", "Id": "268834", "ParentId": "268506", "Score": "3" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-30T23:08:20.753", "Id": "529620", "Score": "1", "body": "Your example has only two levels. Do you care about deeper hierarchy?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-01T10:05:14.500", "Id": "529659", "Score": "1", "body": "[os.walk](https://docs.python.org/3/library/os.html#os.walk) is what you are looking for. e.g. `[folder for folder, folders, files in os.walk(\".\") if not folders]`" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-01T14:02:45.823", "Id": "529670", "Score": "0", "body": "@vnp No, I don't." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-01T14:17:29.193", "Id": "529673", "Score": "0", "body": "@stefan Beautiful! Thanks!" } ]

{ "AcceptedAnswerId": null, "CommentCount": "4", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-30T16:23:50.120", "Id": "268541", "Score": "0", "Tags": [ "python", "file-system" ], "Title": "Efficient way to construct list of sub-subdirectories in python" }

[ { "body": "<p>The os module provides many functions to interact with operating system features, and one such method is <code>os.walk()</code>, which generates and fetch the files and folders in a directory tree. It can traverse the tree either top-down or bottom-up search, and by default, it sets as top-down search.</p>\n<p><strong>What you are looking for is to get the subdirectories with absolute path</strong> and using the <code>os.walk()</code> method you can retrieve the subdirectories in the absolute path.</p>\n<p>Below code gets both files and sub-directories but you can modify it to get only the subfolders according to your need.</p>\n<pre><code># import OS module\nimport os\n\n# List all the files and directories\npath = &quot;C:\\Projects\\Tryouts&quot;\nfor (root, directories, files) in os.walk(path, topdown=False):\n for name in files:\n print(os.path.join(root, name))\n for name in directories:\n print(os.path.join(root, name))\n</code></pre>\n<p>The other alternate way is to use the <code>glob</code> module. The glob module helps you retrieve the files/path matching a specified pattern as the glob supports the wildcard search. We can get both files and folders using the glob module.</p>\n<p>Source: <a href=\"https://itsmycode.com/python-list-files-in-a-directory/\" rel=\"nofollow noreferrer\">List Files and folders in a Directory</a></p>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-04T04:01:37.353", "Id": "529813", "Score": "1", "body": "You've been dropping links to your blog in your answers. Please take a look at [\"how not to be a spammer\"](//codereview.stackexchange.com/help/promotion) and consider making the affiliation more explicitly apparent in your answers." } ], "meta_data": { "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-03T23:44:47.507", "Id": "268632", "ParentId": "268541", "Score": "1" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-30T23:08:20.753", "Id": "529620", "Score": "1", "body": "Your example has only two levels. Do you care about deeper hierarchy?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-01T10:05:14.500", "Id": "529659", "Score": "1", "body": "[os.walk](https://docs.python.org/3/library/os.html#os.walk) is what you are looking for. e.g. `[folder for folder, folders, files in os.walk(\".\") if not folders]`" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-01T14:02:45.823", "Id": "529670", "Score": "0", "body": "@vnp No, I don't." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-01T14:17:29.193", "Id": "529673", "Score": "0", "body": "@stefan Beautiful! Thanks!" } ]

{ "AcceptedAnswerId": null, "CommentCount": "4", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-09-30T16:23:50.120", "Id": "268541", "Score": "0", "Tags": [ "python", "file-system" ], "Title": "Efficient way to construct list of sub-subdirectories in python" }

[ { "body": "<p>The os module provides many functions to interact with operating system features, and one such method is <code>os.walk()</code>, which generates and fetch the files and folders in a directory tree. It can traverse the tree either top-down or bottom-up search, and by default, it sets as top-down search.</p>\n<p><strong>What you are looking for is to get the subdirectories with absolute path</strong> and using the <code>os.walk()</code> method you can retrieve the subdirectories in the absolute path.</p>\n<p>Below code gets both files and sub-directories but you can modify it to get only the subfolders according to your need.</p>\n<pre><code># import OS module\nimport os\n\n# List all the files and directories\npath = &quot;C:\\Projects\\Tryouts&quot;\nfor (root, directories, files) in os.walk(path, topdown=False):\n for name in files:\n print(os.path.join(root, name))\n for name in directories:\n print(os.path.join(root, name))\n</code></pre>\n<p>The other alternate way is to use the <code>glob</code> module. The glob module helps you retrieve the files/path matching a specified pattern as the glob supports the wildcard search. We can get both files and folders using the glob module.</p>\n<p>Source: <a href=\"https://itsmycode.com/python-list-files-in-a-directory/\" rel=\"nofollow noreferrer\">List Files and folders in a Directory</a></p>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-04T04:01:37.353", "Id": "529813", "Score": "1", "body": "You've been dropping links to your blog in your answers. Please take a look at [\"how not to be a spammer\"](//codereview.stackexchange.com/help/promotion) and consider making the affiliation more explicitly apparent in your answers." } ], "meta_data": { "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-03T23:44:47.507", "Id": "268632", "ParentId": "268541", "Score": "1" } } ]

[]

{ "AcceptedAnswerId": "268600", "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-02T14:57:33.393", "Id": "268596", "Score": "2", "Tags": [ "python-3.x" ], "Title": "Counting Restaurant Orders" }

[ { "body": "<ul>\n<li>Add PEP484 typehints</li>\n<li>Don't count things yourself when <code>Counter</code> exists and is more suitable for the task</li>\n<li><code>rows</code> is ignored, so drop it from your arguments list</li>\n<li>Your assertions, main guard and function structure are pretty good; keep it up!</li>\n</ul>\n<h2>Suggested</h2>\n<pre class=\"lang-py prettyprint-override\"><code>from typing import Tuple, Iterable, Counter\n\n\ndef count_items(orders: Iterable[Tuple[str, str]]) -&gt; Counter[str]:\n return Counter(order for user, order in orders)\n\n\ndef test_count_matching():\n assert count_items([]) == Counter()\n assert count_items([(&quot;Bob&quot;, &quot;apple&quot;)]) == Counter({&quot;apple&quot;: 1})\n assert count_items([(&quot;Bob&quot;, &quot;apple&quot;), (&quot;John&quot;, &quot;apple&quot;)]) == Counter({&quot;apple&quot;: 2})\n assert count_items([(&quot;Bob&quot;, &quot;apple&quot;), (&quot;Bob&quot;, &quot;apple&quot;)]) == Counter({&quot;apple&quot;: 2})\n assert count_items([(&quot;Bob&quot;, &quot;apple&quot;), (&quot;John&quot;, &quot;pear&quot;)]) == Counter({&quot;apple&quot;: 1, &quot;pear&quot;: 1})\n\n\ndef tests():\n test_count_matching()\n\n\nif __name__ == &quot;__main__&quot;:\n tests()\n</code></pre>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-02T20:18:10.140", "Id": "529764", "Score": "0", "body": "The counter's keys need to be the last part of the tuple and not include the person's name. The reason is that the kitchen knows the order and needs to know how many times to cook that dish to complete the order for a group of people." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-02T20:30:42.073", "Id": "529766", "Score": "0", "body": "@AkashPatel _The counter's keys need to be the last part of the tuple and not include the person's name_ - right... which is what's happening here." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-02T20:42:16.480", "Id": "529767", "Score": "0", "body": "Sorry, I think misinterpreted the order variable as having both." } ], "meta_data": { "CommentCount": "3", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-02T17:21:09.907", "Id": "268600", "ParentId": "268596", "Score": "3" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-05T03:55:00.457", "Id": "529908", "Score": "3", "body": "I have concerns about the accuracy of that math (fixed year durations?), but that's a separable issue and I'll have to assume that you need an implementation faithful to this reference." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-05T08:31:21.180", "Id": "529925", "Score": "1", "body": "@Reinderien Correct - [this](https://pyeto.readthedocs.io/en/latest/hargreaves.html) existing implementation the author of the question seems to be aware of (some code copied verbatim!) *does* have proper conversion to Julian Days (the now-commented *.tm_yday*)..." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-05T09:06:43.050", "Id": "529932", "Score": "0", "body": "@Reinderien Yes, I had previously converted the day to Julian days, but after looking at my data source, I found that the day variable will be provided in Julian days." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-05T09:50:50.707", "Id": "529936", "Score": "0", "body": "Why does math in your image seem so complicated but in code so easy? xD" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-06T19:36:08.560", "Id": "530036", "Score": "1", "body": "Units are wrong for solar constant and extraterrestrial radiation. `a/b/c` is not the same as `a/(b/c)`." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-07T07:13:18.600", "Id": "530063", "Score": "0", "body": "Did you write the LaTeX documentation?" } ]

{ "AcceptedAnswerId": null, "CommentCount": "6", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-04T07:24:02.597", "Id": "268639", "Score": "8", "Tags": [ "python", "python-3.x", "object-oriented", "python-2.x", "classes" ], "Title": "Calculate evapotranspiration" }

[ { "body": "<p>I wonder if there is a need for a class here? It seems <code>class Hargreaves</code> has no responsibilities and is solely used to compute the evapotranspiration value based on the inputs provided in the constructor. Should a function be used instead?</p>\n<pre class=\"lang-py prettyprint-override\"><code>import math\nimport numpy as np\n\ndef hargreaves(tmin, tmax, tmean, day, lat):\n gsc = 0.082\n dr = 1 + 0.033 * math.cos((2*math.pi) * (day/365))\n d = 0.409 * math.sin((2*math.pi) * (day/365) - 1.39)\n ws = math.acos(-math.tan(lat) * math.tan(d))\n ra = 24 * 60 * (gsc/math.pi) * dr * ws * math.sin(lat) * math.sin(d) + (math.cos(lat) * math.cos(d) * math.sin(ws))\n et = (0.0023/2.45) * (tmean + 17.8) * ((tmax - tmin) ** 0.5 ) * ra\n return et\n</code></pre>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-05T06:11:39.610", "Id": "529914", "Score": "2", "body": "I'd agree if it were the only equation being so treated. In a complex system I'd however expect an interface \"Equation\" with a calculate method that takes another interface \"Parameters\" as input and returns an interface \"Output\" or something of the kind, then multiple implementations of that that can be plugged in as needed. But maybe I'm overthinking things." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-05T09:07:25.460", "Id": "529933", "Score": "0", "body": "Great solution, but I want to try to implementing a class for this particular equation." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-06T05:04:08.047", "Id": "529992", "Score": "2", "body": "@jwenting Given that functions are first class types in python I suspect you are overengineering. It sounds like you are trying to duplicate `<class 'function'>`" } ], "meta_data": { "CommentCount": "3", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-04T08:23:14.140", "Id": "268640", "ParentId": "268639", "Score": "35" } } ]

[]

{ "AcceptedAnswerId": "268719", "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-06T13:19:44.563", "Id": "268717", "Score": "2", "Tags": [ "python", "pandas" ], "Title": "Read CSV, with date filtering and resampling" }

[ { "body": "<p>It's normal to do the parameter checking first:</p>\n<pre><code>def file_loader(filep, freq: str = None, method: str = None,\n d_debut: str = None, d_fin: str = None):\n if d_debut is not None and d_fin is None:\n raise ValueError(&quot;Please provide an end timestamp!&quot;)\n if freq is not None and method is None:\n raise ValueError(&quot;Please provide a resampling method for the given frequency e.g. 'last' ,'mean'&quot;)\n</code></pre>\n<p>You might prefer to check that <code>d_fin</code> and <code>d_debut</code> are either both provided or both defaulted, rather than allowing <code>d_fin</code> without <code>d_debut</code> as at present:</p>\n<pre><code> if (d_debut is None) != (d_fin is None):\n raise ValueError(&quot;Please provide both start and end timestamps!&quot;)\n</code></pre>\n<p>Then after loading, the conditionals are simple:</p>\n<pre><code> if d_debut is not None:\n assert(d_fin is not None) # would have thrown earlier\n df = df.loc[df.index &gt;= d_debut and df.index &lt;= d_fin]\n \n if freq is not None:\n assert(method is not None) # would have thrown earlier\n df = getattr(df.resample(freq), method)()\n</code></pre>\n<p>The assertions are there to document something we know to be true. You could omit them safely, but they do aid understanding.</p>\n<hr />\n<p>It may make sense to provide a useful default <code>method</code> rather than None. Similarly, could the <code>df.index &gt;= d_debut and df.index &lt;= d_fin</code> test be adapted to be happy with one or the other cutoff missing? For example:</p>\n<pre><code> if d_debut is not None or d_fin is not None:\n df = df.loc[(d_debut is None or df.index &gt;= d_debut) and \n (d_fin is None or df.index &lt;= d_fin)]\n</code></pre>\n<p>Then we wouldn't need the parameter checks at all.</p>\n<hr />\n<p>Code style - please take more care with whitespace (consult PEP-8) for maximum readability. Lots of this code seems unnecessarily bunched-up.</p>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-06T14:29:45.290", "Id": "530019", "Score": "0", "body": "Thanks for your answer. I'd rather the function force the user to understand exactly what data he is getting, hence the strict checks. I don't understand why you have assert statements. As you've commented, errors would have been raised at the top. And my bad for the styling." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-06T14:40:38.153", "Id": "530022", "Score": "0", "body": "The asserts are there to document something we know to be true. You could omit them safely, but they do aid understanding." } ], "meta_data": { "CommentCount": "2", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-06T14:20:00.633", "Id": "268719", "ParentId": "268717", "Score": "1" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-06T19:14:35.657", "Id": "530034", "Score": "1", "body": "Please revisit your indentation - it's not going to work in its current state" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-06T21:44:05.510", "Id": "530040", "Score": "1", "body": "I'm new to codereview so I don't know if this should be answer or comment. But if you want better performance, you don't need to call .nlargest multiple times. Just call it with the largest value (9) and select the first i rows. And you don't need to create an intermediary dataframe and put them in lists. It would become less readable but generator expressions would probably be faster. Then again I really don't understand why you're concatenating dataframes and selecting the one you created in that loop? The values of create_df and weights are identical?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-07T02:31:50.930", "Id": "530052", "Score": "0", "body": "Yeah, I made errors in my original code. I have made amends which is above though I will try your largest value suggestion." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-07T02:52:08.033", "Id": "530054", "Score": "2", "body": "I rolled back the last edit. It is against this review policy to update the code after the answer has been posted., because it invalidates the answer." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-07T06:59:23.253", "Id": "530059", "Score": "0", "body": "@kubatucka, those are good observations about the code - please write an answer, and earn yourself some reputation points!" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-07T18:17:54.453", "Id": "530128", "Score": "1", "body": "@vpn; Ok, but it sounds like the original code was not _correct_. Vote to close? (Sorry @Kale!)" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-08T13:26:17.647", "Id": "530174", "Score": "0", "body": "Rather than add or alter the code after an answer, post a follow up question with the correct code. Link the follow up question to this question. Accept the answer to this question." } ]

{ "AcceptedAnswerId": null, "CommentCount": "7", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-06T17:52:45.777", "Id": "268726", "Score": "-2", "Tags": [ "python", "performance" ], "Title": "A custom trading strategy" }

[ { "body": "<p>The structure of your code is weird; are you sure it's doing what you want? If it is, <em>strongly</em> consider adding comments or better variable names or something to make it clearer what it's supposed to be doing. Without such explanation, it looks like you have code inside your loop that ought to go outside it.</p>\n<p>That said, I think this is the same behavior as what you've written:</p>\n<pre class=\"lang-py prettyprint-override\"><code>store_nlargest = [PCA1.nlargest(i, returns.columns)\n for i\n in range(5, 10)]\nlabels = [f&quot;Part_{u+1}&quot; for (u, _) in enumerate(store_nlargest)]\n\nstore_df = [] # persistent? reused? \n\ndef make_weights(i, nlargest):\n store_df.append(pd.DataFrame(nlargest)) # still contains data from prior call?\n df_concat = pd.concat(store_df, keys=labels) # needs better name.\n return df_concat[\n df_concat.index.get_level_values(0) == labels[i]\n ].droplevel(1)\n\nresults = [backtesting(make_weights(i, nlargest), prices, 3,\n initial_capital=10000000,\n strategy_name='Strategy',\n progress_bar=True)\n for (i, nlargest)\n in enumerate(store_nlargest)]\n</code></pre>\n<p>This isn't perfect, but I think it does a better job of making its weirdness explicit. You could make a case that the <code>results</code> list-comprehension should still be a <code>for</code> loop because it contains mutation of <code>store_df</code> as a side-effect; I don't really understand what supposed to be happening there so I won't take a side.</p>\n<p>A lot of folks in python like to use lists for everything, but they're not <em>perfect</em> for most things. They're mutable, and it's nice to have everything that <em>can</em> be immutable be immutable. They're also &quot;eager&quot;, whereas lazy generators aren't much more work to write (but do require careful use).</p>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-07T02:28:36.580", "Id": "530051", "Score": "0", "body": "You are right the code does not do what I wanted it to do - I made blunders. I have updated it, though the issue is speed is more speed than length. I have updated the code which does what I need it to do. It creates weights of the assets based on the nlargest n range and then runs the backtest. Is there a way to speed it up?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-11T02:42:41.553", "Id": "530317", "Score": "0", "body": "Is there an `nlargest` outside `make_weights(i, nlargest)`?" } ], "meta_data": { "CommentCount": "2", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-06T19:20:10.257", "Id": "268728", "ParentId": "268726", "Score": "2" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-06T19:14:35.657", "Id": "530034", "Score": "1", "body": "Please revisit your indentation - it's not going to work in its current state" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-06T21:44:05.510", "Id": "530040", "Score": "1", "body": "I'm new to codereview so I don't know if this should be answer or comment. But if you want better performance, you don't need to call .nlargest multiple times. Just call it with the largest value (9) and select the first i rows. And you don't need to create an intermediary dataframe and put them in lists. It would become less readable but generator expressions would probably be faster. Then again I really don't understand why you're concatenating dataframes and selecting the one you created in that loop? The values of create_df and weights are identical?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-07T02:31:50.930", "Id": "530052", "Score": "0", "body": "Yeah, I made errors in my original code. I have made amends which is above though I will try your largest value suggestion." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-07T02:52:08.033", "Id": "530054", "Score": "2", "body": "I rolled back the last edit. It is against this review policy to update the code after the answer has been posted., because it invalidates the answer." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-07T06:59:23.253", "Id": "530059", "Score": "0", "body": "@kubatucka, those are good observations about the code - please write an answer, and earn yourself some reputation points!" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-07T18:17:54.453", "Id": "530128", "Score": "1", "body": "@vpn; Ok, but it sounds like the original code was not _correct_. Vote to close? (Sorry @Kale!)" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-08T13:26:17.647", "Id": "530174", "Score": "0", "body": "Rather than add or alter the code after an answer, post a follow up question with the correct code. Link the follow up question to this question. Accept the answer to this question." } ]

{ "AcceptedAnswerId": null, "CommentCount": "7", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-06T17:52:45.777", "Id": "268726", "Score": "-2", "Tags": [ "python", "performance" ], "Title": "A custom trading strategy" }

[ { "body": "<p>The structure of your code is weird; are you sure it's doing what you want? If it is, <em>strongly</em> consider adding comments or better variable names or something to make it clearer what it's supposed to be doing. Without such explanation, it looks like you have code inside your loop that ought to go outside it.</p>\n<p>That said, I think this is the same behavior as what you've written:</p>\n<pre class=\"lang-py prettyprint-override\"><code>store_nlargest = [PCA1.nlargest(i, returns.columns)\n for i\n in range(5, 10)]\nlabels = [f&quot;Part_{u+1}&quot; for (u, _) in enumerate(store_nlargest)]\n\nstore_df = [] # persistent? reused? \n\ndef make_weights(i, nlargest):\n store_df.append(pd.DataFrame(nlargest)) # still contains data from prior call?\n df_concat = pd.concat(store_df, keys=labels) # needs better name.\n return df_concat[\n df_concat.index.get_level_values(0) == labels[i]\n ].droplevel(1)\n\nresults = [backtesting(make_weights(i, nlargest), prices, 3,\n initial_capital=10000000,\n strategy_name='Strategy',\n progress_bar=True)\n for (i, nlargest)\n in enumerate(store_nlargest)]\n</code></pre>\n<p>This isn't perfect, but I think it does a better job of making its weirdness explicit. You could make a case that the <code>results</code> list-comprehension should still be a <code>for</code> loop because it contains mutation of <code>store_df</code> as a side-effect; I don't really understand what supposed to be happening there so I won't take a side.</p>\n<p>A lot of folks in python like to use lists for everything, but they're not <em>perfect</em> for most things. They're mutable, and it's nice to have everything that <em>can</em> be immutable be immutable. They're also &quot;eager&quot;, whereas lazy generators aren't much more work to write (but do require careful use).</p>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-07T02:28:36.580", "Id": "530051", "Score": "0", "body": "You are right the code does not do what I wanted it to do - I made blunders. I have updated it, though the issue is speed is more speed than length. I have updated the code which does what I need it to do. It creates weights of the assets based on the nlargest n range and then runs the backtest. Is there a way to speed it up?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-11T02:42:41.553", "Id": "530317", "Score": "0", "body": "Is there an `nlargest` outside `make_weights(i, nlargest)`?" } ], "meta_data": { "CommentCount": "2", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-06T19:20:10.257", "Id": "268728", "ParentId": "268726", "Score": "2" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-08T09:04:40.093", "Id": "530150", "Score": "1", "body": "What do you mean by \"get the Firefox default profile\"? The full path to the folder it is in? Or something else? Can you [clarify](https://codereview.stackexchange.com/posts/268770/edit)? Please respond by [editing (changing) your question](https://codereview.stackexchange.com/posts/268770/edit), not here in comments (***without*** \"Edit:\", \"Update:\", or similar - the question should appear as if it was written right now)." } ]

{ "AcceptedAnswerId": "268771", "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-07T21:32:24.963", "Id": "268770", "Score": "5", "Tags": [ "python", "python-3.x" ], "Title": "Get the Firefox Default Profile" }

[ { "body": "<ul>\n<li>You don't need to import <code>glob</code>; <code>pathlib.Path</code> has a <a href=\"https://docs.python.org/3/library/pathlib.html#pathlib.Path.glob\" rel=\"noreferrer\"><code>Path.glob</code></a> method.</li>\n<li>You don't need to import <code>re</code>; you can merge the regex into the glob - <code>.*default-release.*</code> become <code>*default-release*</code>.</li>\n<li>You can use <code>next(...)</code> rather than <code>list(...)[0]</code>.</li>\n<li>By passing <code>None</code> as a second argument to <code>next</code> we can prevent the code from erroring if the user doesn't have a Firefox profile.</li>\n</ul>\n<pre class=\"lang-py prettyprint-override\"><code>import pathlib\n\nprofiles = pathlib.Path.home().glob(&quot;.mozilla/firefox/*default-release*/&quot;)\nfirefox_default_profile = next(profiles, None)\nprint(firefox_default_profile)\n</code></pre>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-07T22:13:56.760", "Id": "530133", "Score": "3", "body": "Note. This returns a `Path` object instead of a `str`. (And it will return `None` instead of raising an exception if the default profile cannot be found.)" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-07T22:22:05.227", "Id": "530134", "Score": "2", "body": "@AJNeufeld You are certainly correct. Depending on what Python version one is running may mean the code no-longer works as expected. Requiring a call to `str` before being passed to some functions." } ], "meta_data": { "CommentCount": "2", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-07T22:11:09.160", "Id": "268771", "ParentId": "268770", "Score": "8" } } ]

[]

{ "AcceptedAnswerId": "268918", "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-11T18:50:06.573", "Id": "268884", "Score": "2", "Tags": [ "python", "python-3.x", "generator" ], "Title": "Library to Help Loop with Generators" }

[ { "body": "<h1>Unnecessary variables</h1>\n<pre class=\"lang-py prettyprint-override\"><code>def pairs(generator):\n &quot;&quot;&quot;\n average time: O(n * n) where n is the number of yields from generator \n average space: O(1) \n &quot;&quot;&quot;\n first_generator = generator \n second_generator = generator \n for first in first_generator():\n second_generator = generator \n for second in second_generator():\n yield first, second \n</code></pre>\n<p>The value of <code>second_generator</code> does not change in the loop. Therefore, the assignment to <code>second_generator</code> in the loop may be omitted.</p>\n<pre class=\"lang-py prettyprint-override\"><code>def pairs(generator):\n &quot;&quot;&quot;\n average time: O(n * n) where n is the number of yields from generator \n average space: O(1) \n &quot;&quot;&quot;\n first_generator = generator \n second_generator = generator \n for first in first_generator():\n for second in second_generator():\n yield first, second \n</code></pre>\n<p>In fact, the value of <code>generator</code> never changes, so <code>first_generator</code> and <code>second_generator</code> always equal <code>generator</code>. Thus <code>first_generator</code> and <code>second_generator</code> are redundant variables and may be omitted entirely.</p>\n<pre class=\"lang-py prettyprint-override\"><code>def pairs(generator):\n &quot;&quot;&quot;\n average time: O(n * n) where n is the number of yields from generator \n average space: O(1) \n &quot;&quot;&quot;\n for first in generator():\n for second in generator():\n yield first, second \n</code></pre>\n<p>Identical improvements may be applied to the <code>triples</code> function.</p>\n<h1>Useless assignment</h1>\n<pre class=\"lang-py prettyprint-override\"><code> third = third_generator \n for third in third_generator():\n yield first, second, third \n</code></pre>\n<p>The assignment to <code>third</code> before the loop is immediately overwritten by the <code>for ... in ...</code> loop statement, which also assigns values to <code>third</code>.</p>\n", "comments": [], "meta_data": { "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-12T17:35:33.157", "Id": "268918", "ParentId": "268884", "Score": "0" } } ]

[]

{ "AcceptedAnswerId": "268918", "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-11T18:50:06.573", "Id": "268884", "Score": "2", "Tags": [ "python", "python-3.x", "generator" ], "Title": "Library to Help Loop with Generators" }

[ { "body": "<h1>Unnecessary variables</h1>\n<pre class=\"lang-py prettyprint-override\"><code>def pairs(generator):\n &quot;&quot;&quot;\n average time: O(n * n) where n is the number of yields from generator \n average space: O(1) \n &quot;&quot;&quot;\n first_generator = generator \n second_generator = generator \n for first in first_generator():\n second_generator = generator \n for second in second_generator():\n yield first, second \n</code></pre>\n<p>The value of <code>second_generator</code> does not change in the loop. Therefore, the assignment to <code>second_generator</code> in the loop may be omitted.</p>\n<pre class=\"lang-py prettyprint-override\"><code>def pairs(generator):\n &quot;&quot;&quot;\n average time: O(n * n) where n is the number of yields from generator \n average space: O(1) \n &quot;&quot;&quot;\n first_generator = generator \n second_generator = generator \n for first in first_generator():\n for second in second_generator():\n yield first, second \n</code></pre>\n<p>In fact, the value of <code>generator</code> never changes, so <code>first_generator</code> and <code>second_generator</code> always equal <code>generator</code>. Thus <code>first_generator</code> and <code>second_generator</code> are redundant variables and may be omitted entirely.</p>\n<pre class=\"lang-py prettyprint-override\"><code>def pairs(generator):\n &quot;&quot;&quot;\n average time: O(n * n) where n is the number of yields from generator \n average space: O(1) \n &quot;&quot;&quot;\n for first in generator():\n for second in generator():\n yield first, second \n</code></pre>\n<p>Identical improvements may be applied to the <code>triples</code> function.</p>\n<h1>Useless assignment</h1>\n<pre class=\"lang-py prettyprint-override\"><code> third = third_generator \n for third in third_generator():\n yield first, second, third \n</code></pre>\n<p>The assignment to <code>third</code> before the loop is immediately overwritten by the <code>for ... in ...</code> loop statement, which also assigns values to <code>third</code>.</p>\n", "comments": [], "meta_data": { "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-12T17:35:33.157", "Id": "268918", "ParentId": "268884", "Score": "0" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-13T01:22:33.863", "Id": "530455", "Score": "0", "body": "Is there a reason you're seemingly rewriting [basic NumPy functionality](https://numpy.org/devdocs/reference/generated/numpy.shape.html) here? Why not use NumPy to manage your arrays? How large/layers deep are you dealing with? Could you write a class abstraction that stores the length upon construction? I can say right off the bat that `(len_,) + tuple(...)` allocates 2 unnecessary objects that just go straight to the garbage collector after the concatenation but this seems like a micro-optimization given that depth would be unlikely to be huge, I'd imagine." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-13T16:08:26.233", "Id": "530501", "Score": "0", "body": "Given that if you know nothing about the sequence, you'll have to check every element recursively, you can't do better algorithmicly speaking. You could maybe optimize the implementation but not much." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-13T18:56:40.187", "Id": "530506", "Score": "0", "body": "@ggorlen End goal is to create the padded n-dim array as described, except need freedom to pad from left or right. I have the full function and `find_shape` is the bottleneck, especially when ran on GPU. Numpy can only create ragged, and not on GPU; Pytorch is used. If you have something in mind for this goal, I can open a question." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-15T01:38:15.817", "Id": "530613", "Score": "0", "body": "What do you mean with \"Solution shouldn't require list values, only basic attributes\"? You can't check a value's attributes without the value." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-15T17:28:10.370", "Id": "530666", "Score": "0", "body": "@don'ttalkjustcode `len(x)` doesn't require knowing `x[0]`" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-15T17:34:23.767", "Id": "530668", "Score": "0", "body": "Right, but it requires knowing `x`. And you don't know whether `x` is a list until you look at it. Same for `x[0]`. You need to look at it anyway, because it could be a list. Btw, is that \"Solution shouldn't require list values\" paragraph part of the \"Problem\" section, i.e., you're saying your solution *does* have that problem, i.e., it does \"require list values\"? Or is that paragraph an epilogue to the question, not intended to describe a problem with your solution?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-15T17:48:28.820", "Id": "530669", "Score": "0", "body": "Hmm... is it guaranteed that all *numbers* are at the same depth and that there are no lists at that depth? Or could there be cases like `[1, [2, 3]]` or `[4, [], 5]`? And can there be empty lists (your `fillvalue=1` somewhat suggests \"no\")?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-15T18:36:28.653", "Id": "530671", "Score": "0", "body": "@don'ttalkjustcode Updated. Yes, it's guaranteed, and no empties." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-15T19:09:33.483", "Id": "530674", "Score": "1", "body": "Ok, that allows much optimization. So it's guaranteed 5D and only third and fourth are unknown? That would also allow simpler code, and in that case it would help if your Test & bench code reflected that (that's excellent stuff, btw, I wish every question was that helpful :-), so that solutions making those assumptions would work there." } ]

{ "AcceptedAnswerId": "269021", "CommentCount": "9", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-12T23:35:09.490", "Id": "268932", "Score": "1", "Tags": [ "python", "array", "iteration", "nested" ], "Title": "Variable length nested list of lists pad shape" }

[ { "body": "<p>From your question:</p>\n<blockquote>\n<p>The data structure is a list of lists that's to form a 5D array, and only the final nest level contains non-lists, which are 1D arrays. First two nest levels have fixed list lengths (can directly form array), and the 1D arrays are of same length, so the only uncertainty is on 3rd and 4th dims.</p>\n</blockquote>\n<p>From your comment:</p>\n<blockquote>\n<p>and no empties</p>\n</blockquote>\n<p>We can make it much faster by taking advantage of that specification.</p>\n<p>Your solution walks over <em>everything</em>. Including the numbers, at the recursion leafs. Even always catching exceptions there, and <a href=\"https://docs.python.org/3/faq/design.html#how-fast-are-exceptions\" rel=\"nofollow noreferrer\">&quot;catching an exception is expensive&quot;</a></p>\n<p>Instead, for the fixed-size dimensions just take the first length, and for the others run over all their lists and take the maximum length.</p>\n<pre><code>from itertools import chain\n\ndef find_shape_new(seq):\n flat = chain.from_iterable\n return (\n len(seq),\n len(seq[0]),\n max(map(len, flat(seq))),\n max(map(len, flat(flat(seq)))),\n len(seq[0][0][0][0]),\n )\n</code></pre>\n<p>(Only partially tested, as your Test &amp; bench code doesn't adhere to your specification.)</p>\n<p>Could also be generalized, maybe like this:</p>\n<pre><code>def find_shape_new(seq, num_dims=None, fixed_dims=None):\n ...\n</code></pre>\n<p>Parameters:</p>\n<ul>\n<li><code>fixed_dims</code> would be a set naming the fixed dimensions. Like <code>{0, 1, 4}</code> or <code>{1, 2, 5}</code> for your specification above. For each fixed dimension, the function would use the <code>len(seq[0][0][0][0])</code> way, and for each non-fixed dimension, it would use the <code>max(map(len, flat(flat(seq))))</code> way.</li>\n<li><code>num_dims</code> would tell the dimensionality, e.g., for a 5D array it would be 5. If unknown, represented by <code>None</code>, you'd just keep going until you reach a number instead of a list. That would involve looking at a number, but only at one.</li>\n</ul>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-15T21:14:29.363", "Id": "530678", "Score": "0", "body": "So basically take short route for dims 0, 1, 4 and apply a faster `find_shape_old` on the rest? It's what I had in mind but hoped there's better, though it may very well be that better isn't needed - will test this" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-15T22:24:11.357", "Id": "530681", "Score": "0", "body": "@OverLordGoldDragon That, plus not looking at dim 5. It should be a lot better. Looking forward to your results. This is visiting almost only what needs to be visited, so I don't see how you'd hope for something better." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-18T19:06:11.347", "Id": "530857", "Score": "0", "body": "I omitted the simplifying parts to avoid \"divide and conquer\" solutions, instead focusing on the irreducible worst-case. Perhaps exhaustive iteration is the only way, which shifts optimization to parallelization. Your answer includes things I didn't think of, and I like that it can easily target the fixed dims, so I'll take it." } ], "meta_data": { "CommentCount": "3", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-15T20:12:53.270", "Id": "269021", "ParentId": "268932", "Score": "1" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-13T19:03:40.760", "Id": "530507", "Score": "1", "body": "What does the file structure look like?" } ]

{ "AcceptedAnswerId": null, "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-13T17:55:19.713", "Id": "268961", "Score": "0", "Tags": [ "python", "file-system", "pandas" ], "Title": "Combining iterrows of pandas with os.walk given I have a lot of directories" }

[ { "body": "<ul>\n<li><p>First off, you seem to have a typo: <code>os.path.join(path, dirname)</code> should almost certainly be <code>os.path.join(dirpath, dirname)</code>. The only way I could see this not causing problems is if all the directories you want to copy are immediate children of <code>path</code> - and in that case you don't want <a href=\"https://docs.python.org/3/library/os.html#os.walk\" rel=\"nofollow noreferrer\"><code>os.walk</code></a> at all, but should instead use <a href=\"https://docs.python.org/3/library/os.html#os.scandir\" rel=\"nofollow noreferrer\"><code>os.scandir</code></a>. But going forward I'll assume that <a href=\"https://docs.python.org/3/library/os.html#os.walk\" rel=\"nofollow noreferrer\"><code>os.walk</code></a> is in fact needed here</p>\n</li>\n<li><p>Since the target directory's name matches the <code>MSI Status</code> field, and those two loops are otherwise identical, it'd be easy to merge those two loops into a single one, ending with something like:</p>\n<pre class=\"lang-py prettyprint-override\"><code>destination = os.path.join(&quot;/SeaExp/mona/MSS_Status&quot;, row[&quot;MSI Status&quot;], dirname)\nshutil.copytree(joined_path, destination)\n</code></pre>\n</li>\n<li><p>If those are the only two statuses that are possible, you'd be able to get rid of the <code>if</code>s entirely. If not, you can still simplify it to something akin to <code>if row['MSI Status'] in {'MSI-H', 'MSS'}:</code></p>\n</li>\n<li><p>Back to <a href=\"https://docs.python.org/3/library/os.html#os.walk\" rel=\"nofollow noreferrer\"><code>os.walk</code></a> issues, once you've found a directory to copy, will you ever need to copy any subdirectory of that directory? For example, for a patient with ID <code>somebody</code>, would you want/need to copy <em>both</em> <code>./somebody/</code> and <code>./somebody/appointment_history/somebody_2020-12-13</code> independently? If not, you should modify the <code>dirnames</code> list while iterating to avoid descending into the directories you've already copied - which could perhaps look like this:</p>\n<pre class=\"lang-py prettyprint-override\"><code>for dirpath, dirnames, filenames in os.walk(path):\n remaining = []\n\n for dirname in dirnames:\n if row['Patient ID'] in dirname:\n source = os.path.join(path, dirname)\n destination = os.path.join('/SeaExp/mona/MSS_Status', row['MSI Status'], dirname)\n else:\n remaining.append(dirname)\n\n dirnames[:] = remaining # Note the use of [:] to update in-place\n</code></pre>\n</li>\n<li><p>Finally, pandas' <a href=\"https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.iterrows.html\" rel=\"nofollow noreferrer\"><code>iterrows</code></a> is almost certainly faster than <code>os.walk</code>, so if we're going to do one of those multiple times, it might be best to let that be the <a href=\"https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.iterrows.html\" rel=\"nofollow noreferrer\"><code>iterrows</code></a>. You might save time by turning your code inside-out like so:</p>\n<pre class=\"lang-py prettyprint-override\"><code>for dirpath, dirnames, filenames in os.walk(path):\n remaining = []\n\n for index, row in df.iterrows():\n for dirname in dirnames:\n if row['Patient ID'] in dirname:\n source = os.path.join(dirpath, dirname)\n destination = os.path.join(\n '/SeaExp/mona/MSS_Status',\n row['MSI Status'],\n dirname\n )\n shutil.copytree(source, destination)\n else:\n remaining.append(dirname)\n\n dirnames[:] = remaining\n\n\n</code></pre>\n</li>\n</ul>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-14T11:06:16.740", "Id": "530560", "Score": "1", "body": "If one were to combine our answers, your final bullet point would have the benefit of never walking down trees we've copied from ever. Gaining an even larger benefit than either of our answers would have standing alone. Nice answer." } ], "meta_data": { "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-13T20:30:31.630", "Id": "268966", "ParentId": "268961", "Score": "5" } } ]

[]

{ "AcceptedAnswerId": null, "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-14T16:38:00.860", "Id": "268990", "Score": "2", "Tags": [ "python", "web-scraping", "beautifulsoup" ], "Title": "Web scraping playlist from website and writing to CSV" }

[ { "body": "<p>I don't think the CSV format is benefiting you all that much here. You haven't written header names, and it seems you only have one column - and maybe only one row? Either you should have multiple columns with headers, or give up on CSV and just call it a text file.</p>\n<p>Otherwise:</p>\n<ul>\n<li>Prefer Requests over <code>urllib</code></li>\n<li>Check for errors during the HTTP request</li>\n<li>If possible, constrain the part of the DOM that BeautifulSoup parses, using a strainer</li>\n</ul>\n<p>The first part could look like:</p>\n<pre><code>def download_programme(session: Session, name: str) -&gt; str:\n with session.get(\n 'https://www.bbc.co.uk/programmes/' + name,\n headers={'Accept': 'text/html'},\n ) as response:\n response.raise_for_status()\n return response.text\n</code></pre>\n", "comments": [], "meta_data": { "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-14T19:49:06.057", "Id": "268997", "ParentId": "268990", "Score": "2" } } ]

[]

{ "AcceptedAnswerId": "269005", "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-14T19:00:27.540", "Id": "268992", "Score": "1", "Tags": [ "python", "python-3.x", "csv", "pandas" ], "Title": "How to speed up the search by patterns matching and modifying a DataFrame" }

[ { "body": "<p>The first thing I notice here that will tank performance the most is:</p>\n<pre><code>new_pd = pd.concat([new_pd, classify.worker(chunk)])\n</code></pre>\n<p>cs95 outlines this issue very well in <a href=\"https://stackoverflow.com/a/56746204/15497888\">their answer here</a>. The general advice is &quot;NEVER grow a DataFrame!&quot;. Essentially creating a new copy of the DataFrame in each iteration is quadratic in time complexity as the entire DataFrame is copied each iteration, <em>and</em> the DataFrame only gets larger which ends up costing more and more time.</p>\n<p>If we wanted to improve this approach we might consider something like:</p>\n<pre><code>df_list = []\nfor num, chunk in enumerate(df):\n df_list.append(classify.worker(chunk))\n\nnew_pd = pd.concat(df_list, ignore_index=True)\nnew_pd.to_csv('classified.csv', sep='\\t', index=False)\n</code></pre>\n<p>However, assuming we don't ever need the entire DataFrame in memory at once, and given that our <code>logs.csv</code> is so large that we need to <em>read it</em> in chunks, we should also consider <em>writing out</em> our DataFrame in chunks:</p>\n<pre><code>for num, chunk in enumerate(df):\n classify.worker(chunk).to_csv(\n 'classified.csv', sep='\\t', index=False,\n header=(num == 0), # only write the header for the first chunk,\n mode='w' if num == 0 else 'a' # append mode after the first iteration\n )\n</code></pre>\n<hr />\n<p>In terms of reading in the file, we appear to only using the <code>url</code> and <code>page_class</code> columns. Since we're not using the DateTime functionality of the <code>date</code> column we don't need to take the time to parse it.</p>\n<pre><code>df = pd.read_csv('logs.csv', delimiter='\\t', chunksize=1000000)\n</code></pre>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-15T07:00:45.647", "Id": "530620", "Score": "0", "body": "Thanks for your answer. Especially for \"header=(num == 0), mode='w' if num == 0 else 'a'\". This was very useful example for my practice." } ], "meta_data": { "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-15T04:35:09.097", "Id": "269005", "ParentId": "268992", "Score": "2" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-16T13:59:56.697", "Id": "530713", "Score": "0", "body": "Related: [Calculate Levenshtein distance between two strings in Python](https://codereview.stackexchange.com/questions/217065/)." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-17T12:12:12.450", "Id": "530764", "Score": "0", "body": "Please add a link to the programming challenge." } ]

{ "AcceptedAnswerId": null, "CommentCount": "2", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-16T10:00:30.540", "Id": "269031", "Score": "2", "Tags": [ "python", "beginner", "python-3.x", "programming-challenge" ], "Title": "Find the closest match to a string" }

[ { "body": "<h1>Code Review</h1>\n<p>Your code doesn't pass all of the test cases, so by some definitions, it is not ready for a code review. However, it is close enough to working and has several code-habits that should be corrected, that I'll give you a Code Review anyway.</p>\n<h2>Variable names</h2>\n<p>Both <code>count_list</code> and <code>word_list</code> are nice, descriptive variable names. <code>final</code> is ok, but not very descriptive (final what?). However, variable names like <code>s</code>, <code>n</code>, <code>N</code> are terrible, especially in global scope. The fact the <code>n</code> is a count, and <code>N</code> is a string is outright confusing.</p>\n<p><a href=\"https://pep8.org/\" rel=\"nofollow noreferrer\">PEP 8: The Style Guide for Python Code</a> recommends all variable names should be in <code>snake_case</code>. Uppercase letters are used only in <code>NAMED_CONSTANTS</code> and <code>ClassNames</code>.</p>\n<h2>Variable Types</h2>\n<p><code>count_list</code> and <code>word_list</code> are parallel data structures. <code>count_list[j]</code> is the count of matching letters in <code>word_list[j]</code>.</p>\n<p>The would be better expressed as a dictionary. Ie) <code>match_length = {}</code> and <code>match_length[word] = count</code>. As of Python 3.6 (December 2016), dictionaries are ordered by insertion order, so determining which word came before other words is still possible.</p>\n<h2>Throw-away variables</h2>\n<p>In the first loop, <code>for i in range(n):</code>, the variable <code>i</code> is never used. PEP-8 recommends using <code>_</code> for these kind of variables. Ie) <code>for _ in range(n):</code></p>\n<h2>Initialize before use</h2>\n<p>You have:</p>\n<pre class=\"lang-py prettyprint-override\"><code>count = 0\n\nfor i in range(n):\n ...\n \n for j in range(len(N)):\n if s[j] == N[j]:\n count += 1 \n ...\n count = 0\n</code></pre>\n<p>The variable <code>count</code> is set to zero in two different statements. The first initialization is before the outer loop, so it looks like it might be counting items found in the outer loop, but it is not; it is counting in the inner loop. This should be reorganized:</p>\n<pre class=\"lang-py prettyprint-override\"><code>\nfor i in range(n):\n ...\n count = 0\n \n for j in range(len(N)):\n if s[j] == N[j]:\n count += 1 \n ...\n</code></pre>\n<p>Now you only have one location where <code>count</code> is reset to zero. The code should be easier to understand.</p>\n<h2>Loop over values, not indices</h2>\n<p>The inner loop iterates over the indices of <code>N</code>, assigning successive values to <code>j</code>, but the contents of the loop only ever uses <code>j</code> as an index: <code>s[j]</code> and <code>N[j]</code>. Python is optimized for iterating over the values in containers.</p>\n<pre class=\"lang-py prettyprint-override\"><code>\n count = 0\n for s_letter, candidate_word_letter in zip(s, N):\n if s_letter == candidate_word_letter:\n count += 1\n</code></pre>\n<h2>Built in functions</h2>\n<pre class=\"lang-py prettyprint-override\"><code>max_c = count_list[0]\nfor i in range(len(count_list)):\n if count_list[i] &gt; max_c:\n max_c = count_list[i]\n</code></pre>\n<p>This is reinventing the wheel. It is such a common operation, Python has a built-in function for doing it.</p>\n<pre class=\"lang-py prettyprint-override\"><code>max_c = max(count_list)\n</code></pre>\n<h1>Incorrect Output</h1>\n<blockquote>\n<p>This code passed 3 test cases but failed the 4th</p>\n</blockquote>\n<p>Relook at your problem description. Print it out. Using a pen, cross off all the conditions that you test for. At the end, you should see something which you haven't tested. Adding a check for that will solve your problem.</p>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-17T12:14:14.133", "Id": "530765", "Score": "1", "body": "I'm going to leave the question open because this is a good answer." } ], "meta_data": { "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-16T18:40:36.877", "Id": "269043", "ParentId": "269031", "Score": "3" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-17T22:15:24.667", "Id": "530787", "Score": "3", "body": "Please make the question self contained. E.g include the information from the link =)" } ]

{ "AcceptedAnswerId": "269080", "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-17T20:11:20.537", "Id": "269078", "Score": "2", "Tags": [ "python", "programming-challenge" ], "Title": "CodeChef - Red Alert" }

[ { "body": "<p>I like your code =) What it does is clear, and your variable names and spacing is correct. There is not much of an algorithm to speak of here, so instead I will focus on structure.</p>\n<p>It is always a good idea to separate inputs from actions. This can be done using a if_main guard, and clear functions. Something like this passes the first test case</p>\n<pre><code>def is_red_alert(precipitation, drainage, waterlogging):\n\n water_level = 0\n\n for rain_today in precipitation:\n if rain_today &gt; 0:\n water_level += rain_today\n if rain_today == 0:\n if rain_today &lt; drainage:\n water_level = 0\n else:\n water_level -= drainage\n return water_level &gt; waterlogging\n\n\nif __name__ == &quot;__main__&quot;:\n test_cases = int(input())\n\n for _ in range(test_cases):\n _, drainage, waterlogging = [int(x) for x in input().split()]\n precipitation = [int(y) for y in input().split()]\n\n if is_red_alert(precipitation, drainage, waterlogging):\n print(&quot;YES&quot;)\n else:\n print(&quot;NO&quot;)\n</code></pre>\n<p>Otherwise the code is the same. I will change the name of a few of the variables throughout as naming is hard.. =) We can tidy up the logic a bit using <code>min</code> and <code>max</code>. Something like this</p>\n<pre><code>for day in precipitation:\n accumulation += max(0, day)\n if day == 0:\n accumulation -= min(drainage, accumulation)\n elif accumulation &gt; limit:\n return True\nreturn accumulation &gt; limit\n</code></pre>\n<p>Firstly we do not have to check if the precipitation of the current day is negative. We can just use <code>max(0, today)</code> [Yes, this <em>is</em> slower].\nInstead of setting the water level (or in my case the accumulation of water) we can just subtract the smallest number between <code>drainage</code> and <code>accumulation</code>. I will let you go through to check out what happens when <code>drainage &lt; accumulation</code>, and <code>drainage &gt; accumulation</code>. Similarly we only need to check if we are above the limit if the rain today is greater than zero. Otherwise there is no change.</p>\n<p>We can also add some descriptive typing hints to further explain what is going on in the code</p>\n<h2>Code</h2>\n<pre><code>from typing import Annotated\n\nPrecipitation = Annotated[\n list[int],\n &quot;The amount water released from clouds in the form of rain, snow, or hail over n days&quot;,\n]\nDrainage = Annotated[\n int,\n &quot;The amount of water removed on a dry day&quot;,\n]\nWaterMax = Annotated[\n int,\n &quot;The total amount of water before triggering an warning&quot;,\n]\n\n\ndef is_red_alert(\n precipitation: Precipitation, drainage: Drainage, limit: WaterMax\n) -&gt; bool:\n &quot;Returns True if the citys water level becomes larger than a given limit&quot;\n\n accumulation = 0\n\n for day in precipitation:\n accumulation += max(0, day)\n if day == 0:\n accumulation -= min(drainage, accumulation)\n elif accumulation &gt; limit:\n return True\n return accumulation &gt; limit\n\n\nif __name__ == &quot;__main__&quot;:\n test_cases = int(input())\n\n for _ in range(test_cases):\n _, drainage, water_limit = list(map(int, input().split()))\n precipitation = list(map(int, input().split()))\n\n if is_red_alert(precipitation, drainage, water_limit):\n print(&quot;YES&quot;)\n else:\n print(&quot;NO&quot;)\n</code></pre>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-18T02:43:59.440", "Id": "530795", "Score": "0", "body": "Thanks for such a comprehensive and thoughtful review." } ], "meta_data": { "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-17T23:51:52.057", "Id": "269080", "ParentId": "269078", "Score": "1" } } ]

[]

{ "AcceptedAnswerId": null, "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-18T02:27:32.520", "Id": "269081", "Score": "7", "Tags": [ "python" ], "Title": "Magic number game in Python" }

[ { "body": "<p>Welcome to Code Review! Congratulations on having a working game/project :)</p>\n<p>I have a few pointers to help you minimizing the code length, and probably make it easily extensible. Some of these might be considered personal quirks; so YMMV.</p>\n<h2>The deck</h2>\n<p>You're asking the user if their number; at a given state of the run; in any of the given decks. However, for a new player; you never really show the decks ever.</p>\n<p>Is the user supposed to remember <strong>the entire deck</strong>? Perhaps showing the deck before asking if the number is in the same would be better, unless you're using printed cards to act as the deck.</p>\n<h2>Functions</h2>\n<p>Use functions for doing something that you see being repeated. In your case, one of the examples is asking user for <code>Yes/No</code>. Let a function ask for user input, and return <code>True</code>/<code>False</code> for y/n values, and the while loop can live inside this little function.</p>\n<h2>User experience</h2>\n<p>Asking user to input <code>Yes</code>/<code>No</code> seems counter intuitive in the sense that you want them to input these exactly as shown. In general, a lot of cli programs accept <code>y</code>/<code>Y</code>/<code>Yes</code>/<code>yes</code> and variations thereof to be the same. You can have a validation with a small if-clause for acceptable values like so:</p>\n<pre><code>if choice not in {&quot;Yes&quot;, &quot;No&quot;}:\n print(&quot;Please enter Yes/No&quot;)\n</code></pre>\n<h2>if-main clause</h2>\n<p>Put the core logic of your run inside the famous <code>if __name__ == &quot;__main__&quot;</code> block. I will not go into details on the benefits, and just leave a link to <a href=\"https://stackoverflow.com/q/419163/1190388\">this excellent Stack Overflow discussion</a> about the same.</p>\n<h2>Mathematics</h2>\n<p>The game works using the concept of boolean algebra. Each set of numbers is actually only setting one of the bits in the binary representation. You can leverage this fact to generate the table dynamically (or to a custom upper limit) and let another function just set the bit value at correct position in the binary representation be set to <span class=\"math-container\">\\$ 1 \\$</span>.</p>\n", "comments": [], "meta_data": { "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-18T04:32:33.890", "Id": "269082", "ParentId": "269081", "Score": "5" } } ]

[]

{ "AcceptedAnswerId": null, "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-18T02:27:32.520", "Id": "269081", "Score": "7", "Tags": [ "python" ], "Title": "Magic number game in Python" }

[ { "body": "<p>Welcome to Code Review! Congratulations on having a working game/project :)</p>\n<p>I have a few pointers to help you minimizing the code length, and probably make it easily extensible. Some of these might be considered personal quirks; so YMMV.</p>\n<h2>The deck</h2>\n<p>You're asking the user if their number; at a given state of the run; in any of the given decks. However, for a new player; you never really show the decks ever.</p>\n<p>Is the user supposed to remember <strong>the entire deck</strong>? Perhaps showing the deck before asking if the number is in the same would be better, unless you're using printed cards to act as the deck.</p>\n<h2>Functions</h2>\n<p>Use functions for doing something that you see being repeated. In your case, one of the examples is asking user for <code>Yes/No</code>. Let a function ask for user input, and return <code>True</code>/<code>False</code> for y/n values, and the while loop can live inside this little function.</p>\n<h2>User experience</h2>\n<p>Asking user to input <code>Yes</code>/<code>No</code> seems counter intuitive in the sense that you want them to input these exactly as shown. In general, a lot of cli programs accept <code>y</code>/<code>Y</code>/<code>Yes</code>/<code>yes</code> and variations thereof to be the same. You can have a validation with a small if-clause for acceptable values like so:</p>\n<pre><code>if choice not in {&quot;Yes&quot;, &quot;No&quot;}:\n print(&quot;Please enter Yes/No&quot;)\n</code></pre>\n<h2>if-main clause</h2>\n<p>Put the core logic of your run inside the famous <code>if __name__ == &quot;__main__&quot;</code> block. I will not go into details on the benefits, and just leave a link to <a href=\"https://stackoverflow.com/q/419163/1190388\">this excellent Stack Overflow discussion</a> about the same.</p>\n<h2>Mathematics</h2>\n<p>The game works using the concept of boolean algebra. Each set of numbers is actually only setting one of the bits in the binary representation. You can leverage this fact to generate the table dynamically (or to a custom upper limit) and let another function just set the bit value at correct position in the binary representation be set to <span class=\"math-container\">\\$ 1 \\$</span>.</p>\n", "comments": [], "meta_data": { "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-18T04:32:33.890", "Id": "269082", "ParentId": "269081", "Score": "5" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-19T19:36:08.813", "Id": "530961", "Score": "4", "body": "Thank you for providing the link, however, links can break. Please include the text of the programming challenge in the question." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-19T19:42:24.457", "Id": "530963", "Score": "2", "body": "It's not clear from question, but I'm assuming the code is passing all tests?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-20T06:08:04.480", "Id": "531002", "Score": "0", "body": "Check out [Moore's algorithm](https://en.wikipedia.org/wiki/Boyer–Moore_majority_vote_algorithm)" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-28T09:57:42.980", "Id": "531637", "Score": "1", "body": "The current question title, which states your concerns about the code, is too general to be useful here. Please [edit] to the site standard, which is for the title to simply state **the task accomplished by the code**. Please see [How to get the best value out of Code Review: Asking Questions](//codereview.meta.stackexchange.com/q/2436) for guidance on writing good question titles." } ]

{ "AcceptedAnswerId": "269159", "CommentCount": "4", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-19T19:33:33.160", "Id": "269156", "Score": "-2", "Tags": [ "python", "programming-challenge" ], "Title": "leetcode 169 optimzations reducing complexity" }

[ { "body": "<h2>Your code, simplified:</h2>\n<p>Here's an alternative that uses fewer variables. It involves tuple comparisons in <code>max(num_cnt_max, num_cnt)</code>:</p>\n<pre><code>CNT, NUM = 0, 1\nclass Solution:\n def majorityElement(self, nums):\n unique_nums = set(nums)\n num_cnt_max = (0, 0)\n \n for num in unique_nums:\n num_cnt = (nums.count(num), num)\n num_cnt_max = max(num_cnt_max, num_cnt)\n return num_cnt_max[CNT]\n</code></pre>\n<hr />\n<h2>Use <code>Counter</code> instead of <code>set</code> and <code>list.count</code>:</h2>\n<p>Another suggestion is to use <a href=\"https://docs.python.org/3/library/collections.html?highlight=counter#collections.Counter\" rel=\"nofollow noreferrer\"><code>collections.Counter</code></a> instead of the combination of <code>set</code> and <code>list.count</code> your solution uses. In case you're not familiar with <code>Counter</code>, here's an example of its usage:</p>\n<pre><code>from collections import Counter\n\nnums = [1, 6, 3, 9, 3, 4, 3, 1]\nnums_counter = Counter(nums)\nprint(nums) # Counter({3: 3, 1: 2, 6: 1, 9: 1, 4: 1})\n</code></pre>\n<p>The relationship between <code>nums</code> and <code>nums_counter</code> is that <code>nums_counter[num] == nums.count(num)</code>. Creating a <code>Counter</code> (<code>Counter(nums)</code>) and then accessing it (<code>nums_counter[num]</code>) repeatedly is probably faster than repeatedly calling <code>nums.count(num)</code>.</p>\n<h2>Use information given in the problem statement:</h2>\n<p>Another suggestion is to use the information that the majority element appears more than <code>N / 2</code> times. In a list of <code>N</code> elements how many different elements can have a count of more than <code>N / 2</code>? Using that information would let you break out of the foo loop earlier and you'd know which element is the majority just by looking at its count, so you would not have to maintain the intermediate <code>num_cnt_max</code> variable.</p>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-19T22:13:14.443", "Id": "530983", "Score": "2", "body": "You should make note of the [`Counter.most_common([n])`](https://docs.python.org/3/library/collections.html?highlight=counter#collections.Counter.most_common) method, which reduces the code to one statement `return Counter(nums).most_common(1)[0]`. But what you really should do is provide a **review** of the OP's code, since alternate-solution-only answers are not valid answers on this site." } ], "meta_data": { "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-19T19:47:04.363", "Id": "269159", "ParentId": "269156", "Score": "0" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-21T13:05:10.987", "Id": "531134", "Score": "0", "body": "is the 2k or \\$ 2^k \\$?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-21T13:40:04.480", "Id": "531139", "Score": "0", "body": "It is 2^k or two to the power of k" } ]

{ "AcceptedAnswerId": null, "CommentCount": "2", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-21T12:30:24.380", "Id": "269223", "Score": "5", "Tags": [ "python", "programming-challenge", "sorting", "time-limit-exceeded" ], "Title": "Counting swaps in a sequence sorting algorithm" }

[ { "body": "<p>Disclaimer. This ia not a proper review, but an extended comment.</p>\n<p>Nice work with understanding the core of the problem. You just need to go one extra mile to come up with the closed form solution.</p>\n<p>If you rewrite the loop as</p>\n<pre><code>Choosy = 1\nsub = 0\nfor i in range(questions + 1):\n sub += triangular * Choosy\n triangular += zero + 1\n Choosy = Choosy * (questions - i) // (i + 1)\ntotal -= sub\n</code></pre>\n<p>it becomes obvious that the value it calculates is (<span class=\"math-container\">\\$q\\$</span> and <span class=\"math-container\">\\$z\\$</span> correspond to <code>zero</code> and <code>questions</code>)</p>\n<p><span class=\"math-container\">\\$\\displaystyle \\sum_{i=0}^q \\binom{q}{i}T_{z+i} = \\sum_{i=0}^q \\binom{q}{i}\\dfrac{(z+i)(z+i+1)}{2} = \\dfrac{1}{2}\\sum_{i=0}^q \\binom{q}{i}(i^2 + (2z+1)i + z(z+1)) =\\$</span></p>\n<p><span class=\"math-container\">\\$\\displaystyle \\dfrac{1}{2}\\sum_{i=0}^q \\binom{q}{i}i^2 + \\dfrac{2z+1}{2}\\sum_{i=0}^q \\binom{q}{i}i + \\dfrac{z(z+1)}{2}\\sum_{i=0}^q \\binom{q}{i}\\$</span></p>\n<p>Each term has a closed form. You don't need to loop at all.</p>\n<p>Ironically, this problem wouldn't teach you how to iterate. Rather it teaches to <em>not</em> iterate.</p>\n<p>A word of warning. You'd have to deal with quite large powers of 2. Do not compute them naively. Check out <a href=\"https://en.wikipedia.org/wiki/Exponentiation_by_squaring\" rel=\"noreferrer\">exponentiation by squaring</a>, and take the modulo after each multiplication.</p>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-22T12:17:22.737", "Id": "531189", "Score": "0", "body": "Hello is it appropriate to equate the summation symbol (the sidewards M) with a for i in range loop in python where the top value is the highest value for i and the bottom value is the starting value? Also thanks for your comment!" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-22T12:24:30.660", "Id": "531191", "Score": "0", "body": "also i dont understand this last bit 12∑=0()2+2+12∑=0()+(+1)2∑=0(), sorry i dont know how to write with proper maths notation like you did." } ], "meta_data": { "CommentCount": "2", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-21T18:30:21.090", "Id": "269234", "ParentId": "269223", "Score": "6" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-23T14:20:14.897", "Id": "531263", "Score": "0", "body": "Your code is not finding the greatest common factor. It's finding if the greatest factors of the two numbers are equal. The usual way to find the greatest common factor is the Euclidean algorithm." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-23T15:40:26.720", "Id": "531269", "Score": "0", "body": "The GCF of 15 and 27 should be 3. I've voted to close this question, since we only review code that is working correctly on this site." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-23T17:04:45.697", "Id": "531272", "Score": "0", "body": "@200_success no, we have to check if the greatest is same or not. for 15 it is 5 and for 27 it is 9 so not equal" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-23T17:05:04.947", "Id": "531273", "Score": "0", "body": "@Teepeemm how to use euclidean algorithm?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-23T17:11:09.640", "Id": "531276", "Score": "0", "body": "Sorry, I misinterpreted \"common greatest factor\" as \"greatest common factor\". I've edited the post to remove that confusion, and retracted my close vote." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-23T18:06:11.427", "Id": "531283", "Score": "0", "body": "@200_success it's okay and thank you :D" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-23T20:08:36.790", "Id": "531289", "Score": "0", "body": "The Euclidean algorithm is usually implemented along the lines of `gcf(a,b)=gcf(b,a%b)` and then recursing (or with a while loop). But that's not what your code is doing (if that's what it's supposed to be doing, then you've misinterpreted your requirement)." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-23T22:37:13.920", "Id": "531298", "Score": "1", "body": "(I'm somewhat ill at ease with the problem statement not explicitly excluding a natural number as its own factor.)" } ]

{ "AcceptedAnswerId": "269291", "CommentCount": "8", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-23T10:25:00.940", "Id": "269290", "Score": "0", "Tags": [ "python", "python-3.x", "mathematics" ], "Title": "Print greatest factor if it is same for both numbers" }

[ { "body": "<p>At any point, 1 is always common factor of any two numbers. Your code works perfectly. But if you want to write a shorter code, check the condition if both numbers are divisible by any number using for loop going from range 2 (1 is always factor) to min of both numbers. Take a new variable f which is <code>False</code> initially. If the condition is satisfied i.e. if both nos are divisible by a no, change f to <code>True</code>. Then, out of the loop, write an if condition, if f==True then print the number or else the condition was never satisfied and f is False and print &quot;no&quot;. Your code:</p>\n<pre><code>n1=int(input(&quot;Enter n1&quot;))\nn2=int(input(&quot;Enter n2&quot;))\nf=False\nfor i in range(2,min([n1,n2])):\n if n1%i==0 and n2%i==0:\n g=i\n f=True\nif f:\n print(g)\nelse:\n print(&quot;no&quot;)\n</code></pre>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-23T14:18:39.173", "Id": "531262", "Score": "2", "body": "This is a (slow) implementation of finding the greatest common factor, but that's not what OP's code dos." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-24T00:08:23.840", "Id": "531303", "Score": "0", "body": "(Ignoring not checking factors higher than any common ones: How about `for i in range(min([n1,n2])//2, 1, -1):` ?)" } ], "meta_data": { "CommentCount": "2", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-23T11:18:13.443", "Id": "269291", "ParentId": "269290", "Score": "0" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-25T17:37:45.560", "Id": "531426", "Score": "0", "body": "Travel \"right and down\" diagonally, or \"either right or down\"?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-25T17:41:25.787", "Id": "531427", "Score": "0", "body": "@Reinderien Right or down, no diagonal, good point" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-25T17:49:04.823", "Id": "531428", "Score": "0", "body": "I think you need to show much more of your code, not just this function - because some of the issues with this code, when fixed, will require a different calling convention." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-25T17:50:36.563", "Id": "531429", "Score": "0", "body": "@Reinderien Ok duly noted. I'll return with the rest of the code once I have it done, thanks for the input." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-25T20:18:18.453", "Id": "531435", "Score": "0", "body": "@SergioBost Don't you end up with all the cells (i,j) with i and/or j >= than x,y in your collection?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-25T20:22:24.350", "Id": "531436", "Score": "0", "body": "@kubatucka If you're referring to dx, dy, then yes, since I'm only moving forward (right or down) never backwards (left or up)" } ]

{ "AcceptedAnswerId": "269369", "CommentCount": "6", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-25T15:54:58.540", "Id": "269364", "Score": "1", "Tags": [ "python", "recursion", "depth-first-search" ], "Title": "Helper get_all_neighbors (in a grid) function - python" }

[ { "body": "<p>Welcome to CodeReview!</p>\n<p>Disclaimer: As noted in the comments, a review of this code is limited since I don't know the entire codebase / algorithmic approach. So this review is limited to this function's current implementation.</p>\n<hr />\n<p><strong>Naming</strong></p>\n<p><code>d</code> and <code>coll</code> are hard-to-understand names, <code>dungeon</code> and <code>collection</code> are already an improvement. <code>collection</code> however is almost meaningless, as it says nothing about the data stored in the variable. Since the function is called <code>get_neighbors</code>, the return value should probably be called <code>neighbors</code> (<code>coll.append(neighbor)</code> is another hint). If you find yourself needing comments to explain your variable names, you should change them. Reading this line <code># d == abbr. for dungeon is our board</code> is already a lot of unnecessary work compared to simply reading <code>dungeon</code> in the first place. Stick to meaningful and readable variable names, that do not require further explanation.</p>\n<hr />\n<p><strong>Type annotations</strong></p>\n<p>Including type annotations significantly increases the readability of your code. It also allows for better error-checking:</p>\n<pre><code>def get_neighbors(dungeon: list[list[int]], x: int, y: int, neighbors: list[tuple[int, int]])\\\n -&gt; list[tuple[int, int]]:\n</code></pre>\n<hr />\n<p><strong>Miscellaneous</strong></p>\n<hr />\n<p>You might have rows and columns the wrong way round. I would expect <code>dungeon</code> to be a list of rows, <code>y</code> to indicate the row and <code>x</code> to indicate the column. Your current implementation handles <code>dungeon</code> like a list of columns.</p>\n<hr />\n<p><code>if x + dx &gt; len(d[x]) - 1 or y + dy &gt; len(d) - 1: # Out of bounds check</code>:</p>\n<ul>\n<li>You don't need to access <code>len(d[x])</code> (<code>d[x]</code> should also be <code>d[y]</code> by the way), as <code>dungeon</code> is a rectangle, simply use <code>len(d[0])</code></li>\n<li>You already calculated and stored <code>row_length</code> &amp; <code>col_length</code>, use them</li>\n</ul>\n<hr />\n<pre><code>for dx in range(0, 2):\n for dy in range(0, 2):\n if dx == 0 and dy == 0 or dx == 1 and dy == 1:\n continue\n</code></pre>\n<p>should be way simpler:</p>\n<pre><code>for dx, dy in ((1, 0), (0, 1)):\n</code></pre>\n<p>While this might be fine for only two directions, a module- or class-level constant <code>DIRECTIONS = ((1, 0), (0, 1))</code> would be even better, especially once the number of directions increases.</p>\n<pre><code>for dx, dy in DIRECTIONS:\n</code></pre>\n<hr />\n<pre><code># I'm wondering why I even need this line, if I am only going to the right and to the bottom each time\n# Why do I need to guard against duplicates\nif neighbor not in coll:\n coll.append(neighbor)\n</code></pre>\n<p>In you current implementation you need to perform this check, because different paths can lead to the same cell. Consider the simplest example of the two paths (1. DOWN -&gt; 2. RIGHT) and (1. RIGHT-&gt; 2. DOWN).</p>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-25T18:42:51.620", "Id": "531434", "Score": "0", "body": "Very clear explanation, thanks. I'll make sure to be more thorough next time around." } ], "meta_data": { "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-25T17:54:18.770", "Id": "269369", "ParentId": "269364", "Score": "1" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-28T01:40:57.547", "Id": "531616", "Score": "1", "body": "Welcome to Code Review@SE. Time allowing, (re?)visit [How to get the best value out of Code Review](https://codereview.meta.stackexchange.com/q/2436). As per [How do I ask a Good Question?](https://codereview.stackexchange.com/help/how-to-ask), the title of a CR question (*and*, preferably, [the code itself](https://www.python.org/dev/peps/pep-0257/#what-is-a-docstring)) should state what the code is to accomplish." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-28T02:04:43.513", "Id": "531619", "Score": "2", "body": "It may help the non-mathheads if you added why&how 2-4 compute the distances. Please add how the result is going to be used - e.g, for comparisons, you don't need sqrt (`cdist(x, y, 'sqeuclidean')`). Do you need all values at once/as a matrix? Otherwise, a *generator* may help. What are typical dimensions of `x` and `y`?" } ]

{ "AcceptedAnswerId": "269504", "CommentCount": "2", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-27T18:14:16.877", "Id": "269436", "Score": "2", "Tags": [ "python", "performance", "comparative-review", "numpy" ], "Title": "How can I optimize this pairwise Euclidean distance search algorithm?" }

[ { "body": "<h3>Performance:</h3>\n<p>A way to use broadcasting but avoid allocating the 3d array is to separate the distance formula into $(x - y) ** 2 = x^2 + y^2 - 2xy$.</p>\n<pre><code>squared_matrix = np.sum(A ** 2,axis=1 )[:,np.newaxis] - 2 * (A@B.T) + np.sum(B ** 2,axis=1 )[np.newaxis,:]\ndistance_matrix = np.sqrt(squared_matrix)\n</code></pre>\n<p>Check:</p>\n<pre><code>np.allclose(distance_matrix,euclidean_distance(A,B))\n&gt;&gt;&gt; True\n</code></pre>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-29T12:46:06.953", "Id": "531716", "Score": "1", "body": "You can probably write this with np.einsum in a more succinct way but einsum makes my head hurt." } ], "meta_data": { "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-29T12:41:55.283", "Id": "269504", "ParentId": "269436", "Score": "1" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-27T04:14:07.690", "Id": "531640", "Score": "0", "body": "You don't need `elif topping not in available_toppings:`. It's fine with just `else:`" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-27T04:16:24.670", "Id": "531641", "Score": "0", "body": "`print(\"Ok, you ordered a {} \".format(size) + \"pizza with:\")` can be `print(f\"Ok, you ordered a {size} pizza with:\")`" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-27T04:20:02.833", "Id": "531642", "Score": "0", "body": "bro your code act weird when you do not provide topping it goes in endless loop it will keep on asking would you like another topping again and again as you give no to it as input" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-27T04:23:24.003", "Id": "531643", "Score": "0", "body": "and print the list of topping as user will chose from them" } ]

{ "AcceptedAnswerId": null, "CommentCount": "4", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-27T04:07:30.663", "Id": "269455", "Score": "1", "Tags": [ "python" ], "Title": "Cleaning up a basic Python script that takes and recites a pizza order" }

[ { "body": "<p>Firstly, you should add <code>else</code> instead of elif in -</p>\n<pre><code>elif topping not in available_toppings:\n print(&quot;Sorry, we do not have &quot; + topping + &quot;.&quot;)\n</code></pre>\n<p>You can use</p>\n<pre><code>else:\n print(&quot;Sorry, we do not have &quot; + topping + &quot;.&quot;)\n</code></pre>\n<p>And instead of</p>\n<pre><code>elif answer.lower() != &quot;n&quot; or answer.lower() != &quot;no&quot; or answer.lower() != &quot;y&quot; or answer.lower() != &quot;yes&quot;:\n print(&quot;Sorry, I didn't catch that.&quot;)\n continue\n</code></pre>\n<p>You should use</p>\n<pre><code>else:\n print(&quot;Sorry, I didn't catch that.&quot;)\n continue\n</code></pre>\n<p>And you should also check if the size of the pizza is correct, it can be invalid. You should also print the topping list, as it will help user pick.</p>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-27T04:52:06.643", "Id": "531644", "Score": "0", "body": "You can even add a few functions if you want." } ], "meta_data": { "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-27T04:16:48.990", "Id": "269456", "ParentId": "269455", "Score": "1" } } ]

[]

{ "AcceptedAnswerId": null, "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-31T09:04:16.237", "Id": "269572", "Score": "2", "Tags": [ "python", "factory-method" ], "Title": "Factory pattern using enum" }

[ { "body": "<h3>Using enums in Python</h3>\n<p>The posted code doesn't take advantage of most of the benefits provides by enums in Python.</p>\n<p>The typical use case of enums is to make decisions depending on a given enum member.\nFor example,\nin the context of the posted code,\nI can imagine a <code>create_foo</code> method which takes as parameter a value of <code>Color</code> type that is an enum,\nand callers would use <code>create_foo(Color.RED)</code> to create a foo object with one of the supported colors.</p>\n<p>Another common use case would be iterating over an enum type,\nfor example to display the available choices to users.</p>\n<p>In the posted code, only the iteration capability is used, and only internally.\nFor this simpler purpose, a simpler and better option would be using a dictionary:</p>\n<pre><code>SUPPORTED_COLORS = {\n &quot;red&quot;: Red,\n &quot;blue&quot;: Blue,\n}\n\ndef create_color(name):\n if name in SUPPORTED_COLORS:\n return SUPPORTED_COLORS[name]()\n\n return Blue()\n</code></pre>\n<hr />\n<p>Since the parameter of the factory method is a string,\nit doesn't help to find the accepted values.\nI have to read the implementation to know, which violates good encapsulation.</p>\n<p>You may argue that taking a string parameter makes it possible to accept unsupported values and fall back to a default. I think that without a specific use case to justify this need, it's likely to be more harmful than beneficial to bypass type safety this way.</p>\n<p>I find it unexpected to have a factory method as part of an enum type.\nI would not look for a factory method there.\nWhen I see an enum, I expect to use its members, or iterate over it.</p>\n<hr />\n<p>Based on the documentation of <a href=\"https://docs.python.org/3/library/enum.html\" rel=\"noreferrer\">enum support</a>,\n<em>enum members</em> should be named with <code>UPPER_CASE</code>, for example:</p>\n<pre><code>class Color(Enum):\n RED = auto\n BLUE = auto\n</code></pre>\n<p>Based on the examples on the page, it seems that singular noun is recommended as the name of the enum (<code>Color</code> rather than <code>Colors</code>).</p>\n<h3>Implementing the factory method pattern in Python</h3>\n<blockquote>\n<p>I wanted to have a factory-method, but without the if statements that are often seen in examples of this pattern.</p>\n</blockquote>\n<p>Why is that, really? What is the real problem you're trying to solve?\nWhen you try to do something that is different from what is &quot;often seen&quot;,\nI suggest to take a step back,\nand ask yourself if you really have a good reason to not follow a well established pattern.\nChances are that you are missing something, or you don't have a real need.</p>\n<p>Also keep in mind that &quot;often seen&quot; patterns are easier for everyone to understand, <em>because they are often seen</em>.\nWhen you take a different approach,\nthere is a high risk that readers will be surprised by it.\nSo it had better have a good justification to exist, and be rock solid.</p>\n<p>There is nothing fundamentally wrong with if statements in the factory method in general. On the other hand, I can imagine situations where a complex if-else chain could be replaced with something better, but I would have to be more specific about the problem to justify the need for improvement.</p>\n<p>I was surprised by the posted code, at multiple points.\nWhen I read the question title &quot;Factory pattern using enum&quot;, I expected to see:</p>\n<ul>\n<li>A factory method that takes an enum parameter</li>\n<li>The factory method decides what to return based on the enum parameter</li>\n</ul>\n<p>Reading on, when I saw &quot;but without the <code>if</code> statements&quot;, I expected a dictionary mapping enum members to some value or creator function, replacing if-else chain with dictionary lookup.</p>\n<hr />\n<p>I think <a href=\"https://realpython.com/factory-method-python/\" rel=\"noreferrer\">this tutorial on realpython.com</a> explains very nicely how to implement this pattern well in Python.</p>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-31T16:12:58.367", "Id": "531870", "Score": "0", "body": "\"I find it unexpected to have a factory method as part of an enum type.\" So do I , that is why I posted the code here. But the reasoning was simple: first I used a regular class, but that would require some extra methods to make it iterable - Enum is a quick way to solve this, and works well." } ], "meta_data": { "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-10-31T11:50:27.537", "Id": "269580", "ParentId": "269572", "Score": "6" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-02T22:16:29.827", "Id": "532104", "Score": "0", "body": "I think you forgot to increment the string index. As is this would fail with the following input of 2 strings : 'AB', 'BA' . But would work with strings[idx][idx]." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-03T04:23:08.810", "Id": "532116", "Score": "0", "body": "@kubatucka Thanks for the catch, somehow that didn't make it into the copy-paste!" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-03T09:35:57.637", "Id": "532140", "Score": "1", "body": "How returning empty string (or any other less-then-1000-long string) fails to meet the requirements?" } ]

{ "AcceptedAnswerId": "269712", "CommentCount": "3", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-02T21:55:52.977", "Id": "269667", "Score": "1", "Tags": [ "python", "python-3.x", "algorithm", "homework" ], "Title": "Generate a string that is not present in a list" }

[ { "body": "<p>Your algorithm is correct and will always provide a correct answer as the list length equals the string length. As @Toby already pointed out you shall not maintain two indices as you walk row and column on a diagonal.</p>\n<p>Additionally I want to give two more points.</p>\n<h1>Do not mix in the I/O operation with your processing function</h1>\n<p>That does bind your algorithm to the filename and does not allow generic usage and testing. Instead do a function that takes a list of strings and returns a single string. As your algorithm always provides a solution there is no need to return the truth value other than your appointment of course.</p>\n<pre><code>def find_excluded(strings: str) -&gt; Tuple[str, bool]:\n s = ...\n return (s, False)\n</code></pre>\n<p>which you use then like</p>\n<pre><code>strings = load_sequences()\nresult, should_be_false = find_excluded(strings)\n</code></pre>\n<p>Now we can easily do simple tests like</p>\n<pre><code>strings = [&quot;AA&quot;, &quot;AB&quot;]\nresult, _ = find_excluded(strings)\nassert len(result) == len(strings)\nassert result not in strings\n</code></pre>\n<p>You can also test edge cases etc.</p>\n<h1>Try to think in algorithms/filters applied to sequences of data</h1>\n<p>This is very often much more readable and self documenting if you chose good names for your temporaries/functions/expressions. As your algorithm walks the diagonal we name a temporary like that. For the character replacemaent a name like 'invert' sounds nice as the code is binary.</p>\n<pre><code>def find_excluded(strings: str) -&gt; Tuple[str, bool]:\n diagonal = [s[i] for i, s in enumerate(strings)]\n invert = {'A':'B', 'B':'A'}\n inverted = [invert[c] for c in diagonal]\n return (''.join(inverted), False)\n</code></pre>\n<p>That is pretty readdable, isn't it? Note: you may replace the list comprehensions by generator expressions. That allows working on big iterables efficiently.</p>\n<pre><code>def find_excluded(strings: str) -&gt; Tuple[str, bool]:\n diagonal = (s[i] for i, s in enumerate(strings))\n invert = {'A':'B', 'B':'A'}\n inverted = (invert[c] for c in diagonal)\n return (''.join(inverted), False)\n</code></pre>\n", "comments": [], "meta_data": { "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-03T19:15:22.140", "Id": "269712", "ParentId": "269667", "Score": "2" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-04T23:58:15.277", "Id": "532315", "Score": "0", "body": "Can you indicate where `Attr` comes from? I've been unable to find documentation on it." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-05T06:01:18.113", "Id": "532326", "Score": "0", "body": "It comes from boto3: https://boto3.amazonaws.com/v1/documentation/api/latest/reference/customizations/dynamodb.html#boto3.dynamodb.conditions.Attr" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-05T08:06:45.090", "Id": "532334", "Score": "1", "body": "Please [edit] your question so that the title describes the *purpose* of the code, rather than its *mechanism*. We really need to understand the motivational context to give good reviews. Thanks!" } ]

{ "AcceptedAnswerId": "269750", "CommentCount": "3", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-04T20:39:34.560", "Id": "269743", "Score": "3", "Tags": [ "python" ], "Title": "Scanning a DynamoDB table using a filter expression with multiple possible comparison operators" }

[ { "body": "<p>Yes, you should simplify this. Make a dictionary whose key is any of the potential values for <code>conditionAPIParam</code>, and value is a non-bound class function reference.</p>\n<pre class=\"lang-py prettyprint-override\"><code>PARAMS = {\n 'gt': Attr.gt,\n 'lt': Attr.lt,\n 'eq': Attr.begins_with,\n}\nquery_response = table.scan(\n FilterExpression=PARAMS[conditionAPIParam](\n Attr('Timestamp'), # self\n timestampAPIParam,\n ) &amp; Attr('Rule').contains(ruleAPIParam)\n)\n</code></pre>\n<p>With a non-bound reference, the first parameter must be <code>self</code>, which in all cases will be <code>Attr('Timestamp')</code>.</p>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-05T06:06:42.160", "Id": "532327", "Score": "0", "body": "Interesting solution. Does this solution work because Python allows us to use functions as values to keys in a dict?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-05T08:59:35.267", "Id": "532336", "Score": "0", "body": "@Reinderien What would be the differences/pros/cons of using this approach vs getattr/methodcaller ?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-05T13:02:57.267", "Id": "532356", "Score": "1", "body": "@PrithviBoinpally Python allows us to use functions as values basically anywhere (not just in a dict)" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-05T13:06:43.143", "Id": "532357", "Score": "2", "body": "@kubatucka This approach is simple and compatible with static analysis. A `getattr` approach defeats static analysis and will not benefit from e.g. IDE autocomplete." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-06T00:09:33.917", "Id": "532426", "Score": "1", "body": "@Reinderien That's probably true, but OP should also be aware that they could use `getattr(Attr('Timestamp'),conditionAPIParam)(timestampAPIParam)` and not need `PARAMS`." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-06T01:22:00.900", "Id": "532428", "Score": "2", "body": "@Teepeemm Not directly they can't. Note the difference between `eq` and `begins_with`." } ], "meta_data": { "CommentCount": "6", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-05T00:09:59.060", "Id": "269750", "ParentId": "269743", "Score": "5" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-06T13:10:31.030", "Id": "532462", "Score": "0", "body": "Welcome to Code Review@SE. A `return` statement looks lacking context without a `def`, and the title doesn't follow site conventions: Please (re)visit [How do I ask a Good Question?](https://codereview.stackexchange.com/help/how-to-ask)" } ]

{ "AcceptedAnswerId": "269812", "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-06T12:04:25.537", "Id": "269810", "Score": "1", "Tags": [ "python" ], "Title": "Checking whether box and gift colors satisfy the given criteria" }

[ { "body": "<p>Yes, this should be simplified. Prefer sets since you're doing membership checks, and write this as a boolean expression rather than a series of <code>if</code> checks with <code>return</code>s:</p>\n<pre><code>return (\n box.type != 'C'\n and (\n box.type == 'A'\n or box.color in {'red', 'white', 'black'}\n )\n and box.color != gift.color\n and gift.size != 'small'\n and gift.color in {'green', 'blue'}\n)\n</code></pre>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-06T13:48:22.203", "Id": "532466", "Score": "0", "body": "Thankyou so much!" } ], "meta_data": { "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-06T12:52:26.303", "Id": "269812", "ParentId": "269810", "Score": "1" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-08T22:24:03.117", "Id": "532672", "Score": "0", "body": "@200_success oh so thats what they meant by change the img to text data. Thanks for the edit." } ]

{ "AcceptedAnswerId": "269888", "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-08T09:12:25.020", "Id": "269868", "Score": "3", "Tags": [ "python", "python-3.x", "programming-challenge", "parsing" ], "Title": "Find the average score, given data in a table with labeled columns not in a fixed order" }

[ { "body": "<p>I liked the fact that you used the <code>sum()</code> builtin function, but I have no idea what <code>sOM</code> or <code>sOMCache</code> mean in <code>sOM = sum([int(x) for x in sOMCache])</code> — &quot;Sum of marks&quot;, maybe? But the capitalization is weird by <a href=\"https://www.python.org/dev/peps/pep-0008/\" rel=\"nofollow noreferrer\">Python standards</a>, and this isn't a cache — you wouldn't just eject data from this &quot;cache&quot;, would you?</p>\n<p>I think, as you probably suspected, that you missed the mark for this exercise. The main issues with your solution are:</p>\n<ul>\n<li>Misunderstanding the <code>Point</code>. What you're computing here is an average, not a dot product. The dot product in the tutorial was just to illustrate how you can access member fields within a <code>namedtuple</code> using <code>.x</code> or <code>.y</code>.</li>\n<li>Failure to take advantage of <code>namedtuple</code>. If you do things right, you should be able to write something like <code>row.MARKS</code> to get the value of the <code>MARKS</code> column for a particular <code>row</code>.</li>\n<li>Lack of expressiveness, such that it's not obvious what the code intends to do at a glance.</li>\n</ul>\n<h2>Suggested solution</h2>\n<pre><code>from collections import namedtuple\nfrom statistics import mean\nimport sys\n\ndef records(line_iter):\n &quot;&quot;&quot;\n Read records, one per line, space-separated, following a header.\n \n The header consists of two lines: the first line contains an integer\n specifying the number of records, and the second line specifies the\n column names. Records are yielded as namedtuples, where the fields\n have names specified by the second header row.\n &quot;&quot;&quot;\n n = int(next(line_iter))\n Record = namedtuple('Record', next(line_iter))\n for _ in range(n):\n yield Record(*next(line_iter).split())\n\nprint(mean(float(rec.MARKS) for rec in records(sys.stdin)))\n</code></pre>\n<p>Explanation:</p>\n<p>The final line of code drives all the work: read records from STDIN, and print the mean of the <code>MARKS</code> column. I've chosen to interpret the marks as <code>float</code>s for versatility, but if you're sure that the data are all integers then you could call <code>int(rec.MARKS)</code> instead.</p>\n<p>All of the work to read the input is handled by a generator function. The <a href=\"https://www.python.org/dev/peps/pep-0257/\" rel=\"nofollow noreferrer\">docstring</a> describes what it does. As you can see, it takes advantage of the <code>namedtuple</code> to let you refer to the column of interest later.</p>\n", "comments": [], "meta_data": { "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-08T21:01:59.617", "Id": "269888", "ParentId": "269868", "Score": "5" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-08T17:18:20.897", "Id": "532646", "Score": "0", "body": "Use Pandas? That will make this one line." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-08T17:27:55.467", "Id": "532647", "Score": "0", "body": "Can't use panadas unfortunately" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-08T17:28:53.927", "Id": "532648", "Score": "1", "body": "And why would that be? Is this for school?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-08T17:29:57.873", "Id": "532649", "Score": "2", "body": "Also: it's good that you've told us your columns, but can you show us the first few lines of a file?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-08T17:42:02.330", "Id": "532650", "Score": "0", "body": "Yes, and I added a screenshot of the first few lines of a file." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-08T18:01:52.770", "Id": "532652", "Score": "7", "body": "Screenshots are useless; please post a few lines of a file **as text**, including header line…." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-08T23:45:26.133", "Id": "532675", "Score": "1", "body": "Pandas may be a bit heavy for this but why not use the built-in Python [CSV module](https://docs.python.org/3/library/csv.html) ? It appears that you are parsing a simple CSV file so there is no need for a fancy line parsing routine. Plus, using a [DictReader](https://docs.python.org/3/library/csv.html#csv.DictReader) you could use column names. This would be so much more straightforward." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-09T15:52:06.247", "Id": "532708", "Score": "1", "body": "When you try to parse CSV by splitting, you are doing it wrong. Try the implementation on [this CSV](https://en.wikipedia.org/wiki/Comma-separated_values#Example)." } ]

{ "AcceptedAnswerId": null, "CommentCount": "8", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-08T16:59:48.020", "Id": "269885", "Score": "4", "Tags": [ "python", "homework" ], "Title": "Read bills from a bills.csv file" }

[ { "body": "<p>The least appealing, most tedious part of the current code is the conditional\nlogic to handle data conversion. Since you're dealing with a limited number of\ncolumns, you can use a data structure to eliminate the conditionals. (In my\nexperience, smarter or more convenient/suitable data structures are often the\nmost powerful devices to simplify algorithmic logic.) For example, to parse a\nsingle line, one could write something like this:</p>\n<pre><code>def parse_line(line):\n types = (str, str, int, int, int, float, str)\n raw_vals = [val.strip() for val in line.strip().split(',')]\n return [f(val) for val, f in zip(raw_vals, types)]\n</code></pre>\n<p>And if that line-parsing function existed, the overall bill-parsing\nfunction would be pretty trivial:</p>\n<pre><code>def read_bills(file_path):\n with open(file_path) as fh:\n return [parse_line(line) for line in fh]\n</code></pre>\n<p>Don't overlook the implicit suggestion here: separate the detailed logic (line\nparsing) from larger orchestration (opening a file and processing it line by\nline). The latter can usually be quite simple, hardly worth testing or worrying\nabout too much, while the former often requires more effort to ensure\ncorrectness. Reducing the footprint of the code requiring in-depth testing\nis usually a good move to make.</p>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-09T17:15:35.827", "Id": "532718", "Score": "0", "body": "I don't believe you need the `.strip()` in `line.strip().split(',')` as each value is stripped after the split." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-09T18:23:41.463", "Id": "532722", "Score": "0", "body": "@benh Only the no-argument form of `str.split()` includes the auto-magical behavior of also removing whitespace surrounding the delimiter. For example, do some experimenting with this: `'Foo Bar, Blah, 123'.split(',')`. Alas, further stripping is required. One could do it all in a single split by using `re.split()`, but I probably wouldn't take that route -- extra complexity with little benefit." } ], "meta_data": { "CommentCount": "2", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-08T18:42:35.893", "Id": "269887", "ParentId": "269885", "Score": "6" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-10T16:06:59.423", "Id": "532825", "Score": "3", "body": "Hey I'm afraid this is too hypothetical to be reviewed? You might need list comprehensions, maybe? Can't say without the complete code." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-10T17:39:19.817", "Id": "532831", "Score": "0", "body": "@kubatucka: This is my full code broken down to an MWE. What I basically want is: \"Get all elements from list `list_of_demo_classes` for which `val_a == i` and `val_b == j`, and then iterate over all possible entries for `val_a` and `val_b`\". My current approach is shown above, but it looks inefficient to me." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-10T19:20:22.247", "Id": "532837", "Score": "3", "body": "\"_Code Review requires concrete code from a project, with enough code and / or context for reviewers to understand how that code is used. Pseudocode, stub code, hypothetical code, obfuscated code, and generic best practices are outside the scope of this site._\" Minimal Working Examples are for **Stack Overflow**. At **Code Review**, we want actual code, so we can provide a real review. For instance `demo_class` is a horrible class name for several reasons, but creating a review for that is meaningless since it isn't a real class name." } ]

{ "AcceptedAnswerId": null, "CommentCount": "3", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-10T15:36:26.133", "Id": "269953", "Score": "-1", "Tags": [ "python" ], "Title": "Getting all elements in list with certain attribute value in python - Improved solution compared to loop" }

[ { "body": "<p>As best I can tell — based more on your code's behavior than your description of it — you have some objects and you want to print them all in an\norder based on their attribute values. If so, a <a href=\"https://docs.python.org/3/library/dataclasses.html\" rel=\"nofollow noreferrer\">dataclass</a> could help by\neliminating most of the boilerplate code and by supporting attribute-based\nsorting directly (via <code>order = True</code>). Here's a brief demonstration:</p>\n<pre><code>from dataclasses import dataclass\nfrom random import randint\n\n@dataclass(order = True)\nclass Element:\n a: int\n b: int\n c: int\n\nelements = [\n Element(randint(1, 3), randint(0, 2), randint(0, 2))\n for _ in range(10)\n]\n\nfor e in sorted(elements):\n print(e)\n</code></pre>\n<p>Output from one run:</p>\n<pre><code>Element(a=1, b=0, c=1)\nElement(a=1, b=2, c=2)\nElement(a=2, b=2, c=1)\nElement(a=2, b=2, c=1)\nElement(a=2, b=2, c=2)\nElement(a=3, b=0, c=0)\nElement(a=3, b=1, c=1)\nElement(a=3, b=1, c=2)\nElement(a=3, b=2, c=1)\nElement(a=3, b=2, c=1)\n</code></pre>\n", "comments": [], "meta_data": { "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-10T18:38:18.880", "Id": "269955", "ParentId": "269953", "Score": "1" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-12T03:11:13.710", "Id": "532941", "Score": "0", "body": "Is one of those \"x rows\" in the top row supposed to be something else? Otherwise, I think youve pretty much got it covered... : ) 3 out of 3 ain't bad; it's perfect! ...sry, I would've edited, but it's slightly over my head. Didn't want to mess it up." } ]

{ "AcceptedAnswerId": "270003", "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-10T19:05:06.057", "Id": "269957", "Score": "2", "Tags": [ "python", "pandas" ], "Title": "Compute the mean of every X rows of a pandas DataFrame" }

[ { "body": "<p>Your current code breaks two major pandas antipatterns, explained in depth by <a href=\"https://stackoverflow.com/users/4909087/cs95\">@cs95</a>:</p>\n<ul>\n<li><a href=\"https://stackoverflow.com/a/55557758/13138364\">Avoid iterating a DataFrame</a></li>\n<li><a href=\"https://stackoverflow.com/a/56746204/13138364\">Avoid growing a DataFrame</a></li>\n</ul>\n<p>The more idiomatic approaches are <a href=\"https://pandas.pydata.org/docs/reference/api/pandas.core.groupby.GroupBy.mean.html\" rel=\"nofollow noreferrer\"><code>groupby.mean</code></a> (fastest) and <a href=\"https://pandas.pydata.org/docs/reference/api/pandas.core.window.rolling.Rolling.mean.html\" rel=\"nofollow noreferrer\"><code>rolling.mean</code></a>:</p>\n<p><a href=\"https://i.stack.imgur.com/GZAE1.png\" rel=\"nofollow noreferrer\"><img src=\"https://i.stack.imgur.com/GZAE1.png\" width=\"320\"></a></p>\n<hr />\n<h3>1. <a href=\"https://pandas.pydata.org/docs/reference/api/pandas.core.groupby.GroupBy.mean.html\" rel=\"nofollow noreferrer\"><code>groupby.mean</code></a> (fastest)</h3>\n<p>(This is ~5.5x faster than <a href=\"https://pandas.pydata.org/docs/reference/api/pandas.core.window.rolling.Rolling.mean.html\" rel=\"nofollow noreferrer\"><code>rolling.mean</code></a> at 8M rows.)</p>\n<p>Generate pseudo-groups with <code>data.index // nb_row</code> and take the <a href=\"https://pandas.pydata.org/docs/reference/api/pandas.core.groupby.GroupBy.mean.html\" rel=\"nofollow noreferrer\"><code>groupby.mean</code></a>:</p>\n<pre><code>nb_row = 12\nnew_df = data.groupby(data.index // nb_row).mean()\n\n# f1 f2 f3 f4\n# 0 -0.171037 -0.288915 0.026885 -0.083732\n# 1 -0.018497 0.329961 0.107714 -0.430527\n# ... ... ... ... ...\n# 666665 -0.648026 0.232827 0.290072 0.535636\n# 666666 -0.373699 -0.260689 0.122012 -0.217035\n# \n# [666667 rows x 4 columns]\n</code></pre>\n<p>Note that if the real <code>data</code> has a custom index (instead of a default <code>RangeIndex</code>), then use <code>groupby(np.arange(len(df)) // nb_row)</code> instead.</p>\n<hr />\n<h3>2. <a href=\"https://pandas.pydata.org/docs/reference/api/pandas.core.window.rolling.Rolling.mean.html\" rel=\"nofollow noreferrer\"><code>rolling.mean</code></a></h3>\n<p><a href=\"https://codereview.stackexchange.com/a/269965/238890\">rak1507's answer</a> covers <a href=\"https://pandas.pydata.org/docs/reference/api/pandas.core.window.rolling.Rolling.mean.html\" rel=\"nofollow noreferrer\"><code>rolling.mean</code></a> but is missing a key detail.</p>\n<p><code>rolling(nb_row)</code> uses a window size of <code>nb_row</code> <strong>but slides 1 row at a time, not every <code>nb_row</code> rows.</strong></p>\n<ul>\n<li><p>That means slicing with <code>[nb_row-1:]</code> results in the wrong output shape (it's not reduced by a factor of <code>nb_row</code> as described in the OP):</p>\n<pre><code>new_df = data.rolling(nb_row).mean()[nb_row-1:]\nnew_df.shape\n\n# (7999989, 4)\n</code></pre>\n</li>\n<li><p>Instead we should slice with <code>[nb_row::nb_row]</code> to get every <code>nb_row</code>^th row:</p>\n<pre><code>new_df = data.rolling(nb_row).mean()[nb_row::nb_row]\nnew_df.shape\n\n# (666666, 4)\n</code></pre>\n</li>\n</ul>\n<hr />\n<h3>Timings (8M rows*)</h3>\n<pre><code>%timeit data.groupby(data.index // nb_row).mean()\n631 ms ± 56.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n</code></pre>\n<pre><code>%timeit data.rolling(nb_row).mean()[nb_row::nb_row]\n3.47 s ± 274 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n</code></pre>\n<p>^{<em>* <code>data = pd.DataFrame(np.random.random((8_000_000, 4)), columns=['f1', 'f2', 'f3', 'f4'])</code></em>}</p>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-12T09:04:26.347", "Id": "532959", "Score": "1", "body": "Oops yeah you're right I forgot to slice every nth element too. Nice answer - til about groupby" } ], "meta_data": { "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-12T00:43:23.983", "Id": "270003", "ParentId": "269957", "Score": "3" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-14T10:46:04.313", "Id": "533105", "Score": "7", "body": "\"I create a unique Mersenne prime number\". No you don't. ;) It's a creative idea, though." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-16T03:29:44.753", "Id": "533237", "Score": "0", "body": "I got the logic wrong too... probably should have tried a few more values before thinking it worked" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-16T08:15:41.730", "Id": "533250", "Score": "0", "body": "I think that if you indeed used prime numbers and not just `2**i - 1`, the code would work. It would become really slow, e.g. with a long string of unique unicode chars, but it should work as far as I can tell." } ]

{ "AcceptedAnswerId": "270024", "CommentCount": "3", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-12T17:11:10.397", "Id": "270022", "Score": "15", "Tags": [ "python", "python-3.x" ], "Title": "Check whether a lowercase string has any character repetition" }

[ { "body": "<p>You should use <a href=\"https://docs.python.org/3/tutorial/datastructures.html#sets\" rel=\"noreferrer\">sets</a> which are an unordered collection <em>without duplicates</em>. Sets are <a href=\"https://en.wikipedia.org/wiki/Set_(abstract_data_type)\" rel=\"noreferrer\">a fundamental data structure</a> found in many programming languages.</p>\n<p>You should also strive to be a bit more Pythonic. A more natural solution would be as follows:</p>\n<pre class=\"lang-py prettyprint-override\"><code>def is_unique(string: str) -&gt; bool:\n return len(string) == len(set(string))\n</code></pre>\n<p>I have also used <a href=\"https://docs.python.org/3/library/typing.html\" rel=\"noreferrer\">type hints</a> which can also be omitted. Here, they convey that the argument to the function should be a string and return value a boolean. You can learn about later if you want to get more serious with Python.</p>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-12T18:09:12.420", "Id": "532988", "Score": "0", "body": "A simple improvement to make this a valid answer would be at least to explain why you've changed `isUnique` to `is_unique`." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-12T18:30:15.527", "Id": "532990", "Score": "0", "body": "This is a cool solution. Thanks for sharing. Quick side question, how do I write more Pythonic code? Will reading other people's code help?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-12T18:35:10.883", "Id": "532991", "Score": "0", "body": "@AJNeufeld Thanks for the tip, I added some clarification. I hope someone else can chime in with a more deeper review." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-12T18:36:22.770", "Id": "532992", "Score": "0", "body": "@1d10t There are many ways in which you can get better. Reading other people's code, reading good books or other material, writing code & getting feedback... all of that should work more or less." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-12T18:45:15.040", "Id": "532993", "Score": "0", "body": "@Juho thank you for helping me out. I'm guessing this is probably the most atrocious code you've seen in your life. You think I got any chance as a programmer?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-12T18:46:49.937", "Id": "532994", "Score": "0", "body": "@1d10t Absolutely - no one's perfect when starting out. If you like it, just keep practicing and feel free to ask more questions here too :-) Good luck!" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-12T18:49:04.287", "Id": "532995", "Score": "2", "body": "@1d10t \"Pythonic\" doesn't have a standardized meaning. However code which follow's [PEP 8](https://www.python.org/dev/peps/pep-0008/) tends to be more Pythonic than other code. Additionally things like Ned Batchelder's \"Loop Like A Native\" advice also makes code more Pythonic, however the idioms are common in other languages now too." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-15T20:37:51.527", "Id": "533227", "Score": "0", "body": "This may be inefficient if `str` contains the full works of Shakespeare or something large. An optimization may be `len(string) < 26 && len(string) == len(set(string))` If then len is greater than the number of available characters then they can't be unique. Assumes: Standard ASCII 0->127" } ], "meta_data": { "CommentCount": "8", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-12T17:44:26.270", "Id": "270024", "ParentId": "270022", "Score": "15" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-14T10:46:04.313", "Id": "533105", "Score": "7", "body": "\"I create a unique Mersenne prime number\". No you don't. ;) It's a creative idea, though." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-16T03:29:44.753", "Id": "533237", "Score": "0", "body": "I got the logic wrong too... probably should have tried a few more values before thinking it worked" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-16T08:15:41.730", "Id": "533250", "Score": "0", "body": "I think that if you indeed used prime numbers and not just `2**i - 1`, the code would work. It would become really slow, e.g. with a long string of unique unicode chars, but it should work as far as I can tell." } ]

{ "AcceptedAnswerId": "270024", "CommentCount": "3", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-12T17:11:10.397", "Id": "270022", "Score": "15", "Tags": [ "python", "python-3.x" ], "Title": "Check whether a lowercase string has any character repetition" }

[ { "body": "<p>You should use <a href=\"https://docs.python.org/3/tutorial/datastructures.html#sets\" rel=\"noreferrer\">sets</a> which are an unordered collection <em>without duplicates</em>. Sets are <a href=\"https://en.wikipedia.org/wiki/Set_(abstract_data_type)\" rel=\"noreferrer\">a fundamental data structure</a> found in many programming languages.</p>\n<p>You should also strive to be a bit more Pythonic. A more natural solution would be as follows:</p>\n<pre class=\"lang-py prettyprint-override\"><code>def is_unique(string: str) -&gt; bool:\n return len(string) == len(set(string))\n</code></pre>\n<p>I have also used <a href=\"https://docs.python.org/3/library/typing.html\" rel=\"noreferrer\">type hints</a> which can also be omitted. Here, they convey that the argument to the function should be a string and return value a boolean. You can learn about later if you want to get more serious with Python.</p>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-12T18:09:12.420", "Id": "532988", "Score": "0", "body": "A simple improvement to make this a valid answer would be at least to explain why you've changed `isUnique` to `is_unique`." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-12T18:30:15.527", "Id": "532990", "Score": "0", "body": "This is a cool solution. Thanks for sharing. Quick side question, how do I write more Pythonic code? Will reading other people's code help?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-12T18:35:10.883", "Id": "532991", "Score": "0", "body": "@AJNeufeld Thanks for the tip, I added some clarification. I hope someone else can chime in with a more deeper review." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-12T18:36:22.770", "Id": "532992", "Score": "0", "body": "@1d10t There are many ways in which you can get better. Reading other people's code, reading good books or other material, writing code & getting feedback... all of that should work more or less." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-12T18:45:15.040", "Id": "532993", "Score": "0", "body": "@Juho thank you for helping me out. I'm guessing this is probably the most atrocious code you've seen in your life. You think I got any chance as a programmer?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-12T18:46:49.937", "Id": "532994", "Score": "0", "body": "@1d10t Absolutely - no one's perfect when starting out. If you like it, just keep practicing and feel free to ask more questions here too :-) Good luck!" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-12T18:49:04.287", "Id": "532995", "Score": "2", "body": "@1d10t \"Pythonic\" doesn't have a standardized meaning. However code which follow's [PEP 8](https://www.python.org/dev/peps/pep-0008/) tends to be more Pythonic than other code. Additionally things like Ned Batchelder's \"Loop Like A Native\" advice also makes code more Pythonic, however the idioms are common in other languages now too." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-15T20:37:51.527", "Id": "533227", "Score": "0", "body": "This may be inefficient if `str` contains the full works of Shakespeare or something large. An optimization may be `len(string) < 26 && len(string) == len(set(string))` If then len is greater than the number of available characters then they can't be unique. Assumes: Standard ASCII 0->127" } ], "meta_data": { "CommentCount": "8", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-12T17:44:26.270", "Id": "270024", "ParentId": "270022", "Score": "15" } } ]

[]

{ "AcceptedAnswerId": null, "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-16T10:52:57.187", "Id": "270111", "Score": "0", "Tags": [ "python", "lambda" ], "Title": "Is using except TypeError the right way to do this?" }

[ { "body": "<p>I would move the lambda into a full function. There are some schools of though that lambdas should never be assigned and persisted to variables (the alterative being they're directly passed as arguments.</p>\n<p>What your existing code shows is that you'd like the second argument (<code>y</code>) to be optional with a default value of 2 (or is it 20?). Therefore, you could do:</p>\n<pre class=\"lang-py prettyprint-override\"><code>def l(x, y=2):\n return x + y\n\nvalue = l(10) # 12\nvalue = l(10, 20) # 30\n</code></pre>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-16T18:00:34.873", "Id": "533281", "Score": "0", "body": "Please refrain from answering low-quality questions that are likely to get closed. Once you've answered, that [limits what can be done to improve the question](/help/someone-answers#help-post-body), making it more likely that your efforts are wasted. It's better to wait until the question is properly ready before you answer!" } ], "meta_data": { "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-16T16:21:36.717", "Id": "270124", "ParentId": "270111", "Score": "1" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-19T11:43:43.367", "Id": "533499", "Score": "2", "body": "One liner with a bit of maths to find x(x+1)/2 = n: lambda x: [print(\\*range(1+i*~-i//2, 1+i*-~i//2)) for i in range(int(((1+8*x)**.5-1)/2), 0, -1)]" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-19T13:27:37.203", "Id": "533509", "Score": "0", "body": "@rak1507 Thank you so much!!!" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-19T14:14:34.953", "Id": "533518", "Score": "0", "body": "@rak1507 could you please explain 1+i*~-i//2 this, its so tricky to understand this" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-19T14:38:39.513", "Id": "533522", "Score": "1", "body": "~-i is magic for (i-1) so it's 1 + i * (i-1) // 2 (sorry: code golfing habits die hard)" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-19T18:54:55.980", "Id": "533542", "Score": "0", "body": "@rak1507 ohhokay....got it..thank you so much for responding!" } ]

{ "AcceptedAnswerId": "270221", "CommentCount": "5", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-19T11:13:24.437", "Id": "270218", "Score": "1", "Tags": [ "python", "python-3.x" ], "Title": "Printing reverse number triangle" }

[ { "body": "<h3>Optimized != pythonic</h3>\n<p>Optimized means &quot;spending less resources&quot;. &quot;Pythonic&quot; means &quot;using idiomatic Python features&quot;. Sometimes they come together, sometimes don't. Pythonic code is clean and maintainable, while optimized can be very unclear and need many comments.</p>\n<p>Anyway, optimization should start with making the code readable, and pythonic code should be readable.</p>\n<h3>Make more use of Python features</h3>\n<p>List comprehensions, range arguments and unpacking can be very handy. This code</p>\n<pre><code> v = []\n for i in range(c):\n v.append(k+1)\n k += 1\n</code></pre>\n<p>is clearly just a</p>\n<pre><code> v = [k+1+i for i in range(c)]\n k += c\n</code></pre>\n<p>and, changing the range arguments,</p>\n<pre><code> v = list(range(k+1, k+c))\n k += c\n</code></pre>\n<p>And this code</p>\n<pre><code> for j in l[p-(i+1)]:\n print(j, end=' ')\n print()\n</code></pre>\n<p>can be written as</p>\n<pre><code> print(*l[p-(i+1)])\n</code></pre>\n<p>and</p>\n<pre><code>p = len(l)\nfor i in range(p):\n print(*l[p-(i+1)])\n</code></pre>\n<p>is walking the <code>l</code> list backwards, so it's</p>\n<pre><code>for line in reversed(l):\n print(*line)\n</code></pre>\n<p>This is pythonic.</p>\n<h3>Optimizations</h3>\n<p>Change the algorithm. Here you're gathering all the number in a list to output them. But the numbers are all in order, so you can easily avoid lists at all - just make loops with <code>print</code>s.</p>\n<p>First, read <a href=\"https://en.wikipedia.org/wiki/Triangular_number\" rel=\"nofollow noreferrer\">some theory</a>.</p>\n<p>Now you know that only numbers that equal <code>n*(n+1)/2</code> can be used to build such triangles. You can solve <code>n*(n+1)/2 = num</code> as a quadratic equation and round n down to get the number of lines without loops like <a href=\"https://codereview.stackexchange.com/users/251597/rak1507\">rak1507</a> did.</p>\n<p>Next, find formulas for starting and ending numbers in each line to put them into range arguments.</p>\n<p>And now you can code it in three lines.</p>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-19T13:27:19.363", "Id": "533508", "Score": "0", "body": "Thank you so much!! for this wonderful explaination" } ], "meta_data": { "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-19T12:38:30.200", "Id": "270221", "ParentId": "270218", "Score": "3" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-20T17:28:04.707", "Id": "533583", "Score": "0", "body": "It's likely that it doesn't even make sense to set such an instance variable in the constructor. But we can't really advise you properly based on the tiny code excerpt you've shown here." } ]

{ "AcceptedAnswerId": "270224", "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-19T12:41:45.070", "Id": "270222", "Score": "2", "Tags": [ "python", "object-oriented", "constructor" ], "Title": "Setting instance variable for salary bonus based on academic position" }

[ { "body": "<p>If you have to stick to using this specific structure, I'd do it like this:</p>\n<pre class=\"lang-py prettyprint-override\"><code>class Scholar:\n _ACADEMIC_POSITIONS_BONUS_MAP = {\n 'Professor': 70000,\n 'Associate Professor': 50000,\n 'Assistance Professor': 30000,\n }\n\n def __init__(self, name, salary, academic_position):\n self.name = name\n self.salary = salary\n self.academic_position = academic_position\n\n @property\n def bonus(self):\n for academic_position, bonus in self._ACADEMIC_POSITIONS_BONUS_MAP.items():\n if self.academic_position == academic_position:\n return bonus\n\n raise ValueError(\n f&quot;Invalid academic position. Allowed: &quot;\n f&quot;{', '.join(self._ACADEMIC_POSITIONS_BONUS_MAP)}&quot;\n )\n</code></pre>\n<p>And as other have mentioned, instead of iterating through the dict itself you can just do this:</p>\n<pre class=\"lang-py prettyprint-override\"><code>class Scholar:\n # ...\n\n @property\n def bonus(self):\n return self._ACADEMIC_POSITIONS_BONUS_MAP[self.academic_position]\n</code></pre>\n<p>We've created a map between each type of <code>academic_position</code> and its specific <code>bonus</code> and a <code>@property</code> where we return the bonus.</p>\n<p>And then you can use it like this:</p>\n<pre class=\"lang-py prettyprint-override\"><code>professor = Scholar(&quot;John Doe&quot;, 30000, &quot;Professor&quot;)\nassociate_professor = Scholar(&quot;Associate John Doe&quot;, 30000, &quot;Associate Professor&quot;)\nassistance_professor = Scholar(&quot;Assistance John Doe&quot;, 30000, &quot;Assistance Professor&quot;)\n\n\nprint(professor.bonus)\nprint(associate_professor.bonus)\nprint(assistance_professor.bonus)\n</code></pre>\n<p>Now, when you need to add another <code>academic_position</code>, you just have to modify <code>_ACADEMIC_POSITIONS_BONUS_MAP</code>.</p>\n<p>Next, in order to calculate the yearly salary, just create another method within your class:</p>\n<pre class=\"lang-py prettyprint-override\"><code>class Scholar:\n # ...\n\n def get_yearly_salary(self):\n # Note: multiply the salary with 12 if it's monthly-based\n return self.salary + self.bonus\n</code></pre>\n<p>Note: I'm not sure if <code>@property</code> is the best way of doing this. You could've just done something along the lines:</p>\n<pre class=\"lang-py prettyprint-override\"><code>class Scholar:\n _ACADEMIC_POSITIONS_BONUS_MAP = {\n 'Professor': 70000,\n 'Associate Professor': 50000,\n 'Assistance Professor': 30000,\n }\n\n def __init__(self, name, salary, academic_position):\n self.name = name\n self.salary = salary\n self.academic_position = academic_position\n\n self.bonus = self.get_bonus()\n\n def get_bonus(self):\n for academic_position, bonus in self._ACADEMIC_POSITIONS_BONUS_MAP.items():\n if self.academic_position == academic_position:\n return bonus\n\n raise ValueError(\n f&quot;Invalid academic position. Allowed: &quot;\n f&quot;{', '.join(self._ACADEMIC_POSITIONS_BONUS_MAP)}&quot;\n )\n</code></pre>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-19T13:53:30.337", "Id": "533514", "Score": "0", "body": "@ Grajdeano Alex thanks you so much for your answers. so basically @property is like an attribute which has immediate invoked call? we can access simply just like it is an instance variable?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-19T13:56:17.247", "Id": "533515", "Score": "0", "body": "and you're suggesting that I should write get_bonus() instead of the @property bonus in order to protect the variable from changing outside the class?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-19T14:10:17.973", "Id": "533517", "Score": "0", "body": "Basically yes. For a deeper read [have at this](https://www.programiz.com/python-programming/property)" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-19T14:15:53.573", "Id": "533519", "Score": "0", "body": "thanks for the knowledges" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-19T18:18:48.310", "Id": "533540", "Score": "2", "body": "Iterating over a `dict` to check a value for equality against each key seems to defeat the purpose of using a `dict`." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-19T19:00:19.603", "Id": "533543", "Score": "0", "body": "@GrajdeanuAlex I downvoted this answer because of the terrible use of the dict - it's not great to suggest answers to new people when you clearly haven't got a solid grasp of python yourself." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-20T10:16:19.220", "Id": "533576", "Score": "1", "body": "@FMc yep, that's correct. It was pretty late when I wrote this. Added extra-comments for that part now." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-20T10:18:33.570", "Id": "533577", "Score": "0", "body": "@rak1507 Fixed now. We're all learning here :) Next time if something is wrong, answer the question yourself and pinpoint what's wrong in other answers and why instead of just throwing out words. That't how OP and others can learn." } ], "meta_data": { "CommentCount": "8", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-19T13:25:46.207", "Id": "270224", "ParentId": "270222", "Score": "1" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-20T17:28:04.707", "Id": "533583", "Score": "0", "body": "It's likely that it doesn't even make sense to set such an instance variable in the constructor. But we can't really advise you properly based on the tiny code excerpt you've shown here." } ]

{ "AcceptedAnswerId": "270224", "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-19T12:41:45.070", "Id": "270222", "Score": "2", "Tags": [ "python", "object-oriented", "constructor" ], "Title": "Setting instance variable for salary bonus based on academic position" }

[ { "body": "<p>If you have to stick to using this specific structure, I'd do it like this:</p>\n<pre class=\"lang-py prettyprint-override\"><code>class Scholar:\n _ACADEMIC_POSITIONS_BONUS_MAP = {\n 'Professor': 70000,\n 'Associate Professor': 50000,\n 'Assistance Professor': 30000,\n }\n\n def __init__(self, name, salary, academic_position):\n self.name = name\n self.salary = salary\n self.academic_position = academic_position\n\n @property\n def bonus(self):\n for academic_position, bonus in self._ACADEMIC_POSITIONS_BONUS_MAP.items():\n if self.academic_position == academic_position:\n return bonus\n\n raise ValueError(\n f&quot;Invalid academic position. Allowed: &quot;\n f&quot;{', '.join(self._ACADEMIC_POSITIONS_BONUS_MAP)}&quot;\n )\n</code></pre>\n<p>And as other have mentioned, instead of iterating through the dict itself you can just do this:</p>\n<pre class=\"lang-py prettyprint-override\"><code>class Scholar:\n # ...\n\n @property\n def bonus(self):\n return self._ACADEMIC_POSITIONS_BONUS_MAP[self.academic_position]\n</code></pre>\n<p>We've created a map between each type of <code>academic_position</code> and its specific <code>bonus</code> and a <code>@property</code> where we return the bonus.</p>\n<p>And then you can use it like this:</p>\n<pre class=\"lang-py prettyprint-override\"><code>professor = Scholar(&quot;John Doe&quot;, 30000, &quot;Professor&quot;)\nassociate_professor = Scholar(&quot;Associate John Doe&quot;, 30000, &quot;Associate Professor&quot;)\nassistance_professor = Scholar(&quot;Assistance John Doe&quot;, 30000, &quot;Assistance Professor&quot;)\n\n\nprint(professor.bonus)\nprint(associate_professor.bonus)\nprint(assistance_professor.bonus)\n</code></pre>\n<p>Now, when you need to add another <code>academic_position</code>, you just have to modify <code>_ACADEMIC_POSITIONS_BONUS_MAP</code>.</p>\n<p>Next, in order to calculate the yearly salary, just create another method within your class:</p>\n<pre class=\"lang-py prettyprint-override\"><code>class Scholar:\n # ...\n\n def get_yearly_salary(self):\n # Note: multiply the salary with 12 if it's monthly-based\n return self.salary + self.bonus\n</code></pre>\n<p>Note: I'm not sure if <code>@property</code> is the best way of doing this. You could've just done something along the lines:</p>\n<pre class=\"lang-py prettyprint-override\"><code>class Scholar:\n _ACADEMIC_POSITIONS_BONUS_MAP = {\n 'Professor': 70000,\n 'Associate Professor': 50000,\n 'Assistance Professor': 30000,\n }\n\n def __init__(self, name, salary, academic_position):\n self.name = name\n self.salary = salary\n self.academic_position = academic_position\n\n self.bonus = self.get_bonus()\n\n def get_bonus(self):\n for academic_position, bonus in self._ACADEMIC_POSITIONS_BONUS_MAP.items():\n if self.academic_position == academic_position:\n return bonus\n\n raise ValueError(\n f&quot;Invalid academic position. Allowed: &quot;\n f&quot;{', '.join(self._ACADEMIC_POSITIONS_BONUS_MAP)}&quot;\n )\n</code></pre>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-19T13:53:30.337", "Id": "533514", "Score": "0", "body": "@ Grajdeano Alex thanks you so much for your answers. so basically @property is like an attribute which has immediate invoked call? we can access simply just like it is an instance variable?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-19T13:56:17.247", "Id": "533515", "Score": "0", "body": "and you're suggesting that I should write get_bonus() instead of the @property bonus in order to protect the variable from changing outside the class?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-19T14:10:17.973", "Id": "533517", "Score": "0", "body": "Basically yes. For a deeper read [have at this](https://www.programiz.com/python-programming/property)" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-19T14:15:53.573", "Id": "533519", "Score": "0", "body": "thanks for the knowledges" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-19T18:18:48.310", "Id": "533540", "Score": "2", "body": "Iterating over a `dict` to check a value for equality against each key seems to defeat the purpose of using a `dict`." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-19T19:00:19.603", "Id": "533543", "Score": "0", "body": "@GrajdeanuAlex I downvoted this answer because of the terrible use of the dict - it's not great to suggest answers to new people when you clearly haven't got a solid grasp of python yourself." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-20T10:16:19.220", "Id": "533576", "Score": "1", "body": "@FMc yep, that's correct. It was pretty late when I wrote this. Added extra-comments for that part now." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-20T10:18:33.570", "Id": "533577", "Score": "0", "body": "@rak1507 Fixed now. We're all learning here :) Next time if something is wrong, answer the question yourself and pinpoint what's wrong in other answers and why instead of just throwing out words. That't how OP and others can learn." } ], "meta_data": { "CommentCount": "8", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-19T13:25:46.207", "Id": "270224", "ParentId": "270222", "Score": "1" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-25T00:22:20.913", "Id": "533887", "Score": "0", "body": "Are you sure the code works at all?" } ]

{ "AcceptedAnswerId": "270377", "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-24T23:02:08.233", "Id": "270371", "Score": "1", "Tags": [ "python", "programming-challenge", "time-limit-exceeded", "binary-search" ], "Title": "HackerRank - Climbing the Leaderboard: I don't understand why my code is exceeding the time limit" }

[ { "body": "<p><strong>Removing duplicates efficiently</strong></p>\n<pre><code>ranked=[i for n, i in enumerate(ranked) if i not in ranked[:n]]\n</code></pre>\n<p>This line creates a copy of <code>ranked</code> at each iteration, which makes it inefficient.\nSince <code>ranked</code> is already sorted, create a new list and add elements one by one if different from the previous.</p>\n<p>Alternatively, you can use a dictionary that is ordered from Python 3.7.</p>\n<pre><code>ranked = list(dict.fromkeys(ranked))\n</code></pre>\n<p><strong>Rank assignment</strong></p>\n<p>The second part of the algorithm creates many copies of <code>ranked</code> in <code>ranked=ranked[1:]</code>, which might be the issue. As you said, using a while loop can speed things up. Refactored code:</p>\n<pre><code>def climbingLeaderboard(ranked, player):\n ranked = list(dict.fromkeys(ranked))\n player_rank = []\n ranking = len(ranked) + 1\n start = 0\n for pi, ps in enumerate(player[::-1]):\n j = start\n while j &lt; len(ranked):\n if ps &gt;= ranked[j]:\n player_rank.append(j + 1)\n break\n start += 1\n j += 1\n if j == len(ranked):\n player_rank.append(ranking)\n return player_rank[::-1]\n</code></pre>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-25T22:47:29.377", "Id": "533949", "Score": "0", "body": "Thanks it worked! I think ranked=ranked[1:] was the problem. I'm a bit new to code optimization, can you explain more about how that creates many copies of ranked?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-26T01:39:02.710", "Id": "533956", "Score": "0", "body": "@MysteriousShadow I am glad I could help. `ranked=ranked[1:]` creates many copies because it's in the for-loop." } ], "meta_data": { "CommentCount": "2", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-25T06:18:31.200", "Id": "270377", "ParentId": "270371", "Score": "2" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-26T11:23:41.837", "Id": "533994", "Score": "1", "body": "And clarify the task; is x excluded from the range and y included?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-27T02:45:23.210", "Id": "534053", "Score": "0", "body": "\"even places have same parity as odd places\" reduces to very simple rule: the mod 2 sum of **all** the digits equals 0. No need to break it into two pieces. Also, if you just look at some example ranges you'll notice a very simple pattern to the count, so you don't need to actually run through the values." } ]

{ "AcceptedAnswerId": "270428", "CommentCount": "2", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-26T10:25:13.987", "Id": "270414", "Score": "6", "Tags": [ "python", "performance", "integer", "interval" ], "Title": "Count the numbers in a range in which the sum of the odds digits have the same parity of the evens one" }

[ { "body": "<p>First some code simplifications and other adjustments. (1) Your sum\ncalculations don't need the conditional tests, because the ranges already\nensure compliance. (2) They also don't need to be wrapped in a <code>[]</code>. (3)\nEven better, if you switch from ranges to slices, you don't need to loop with\nin the sum calculations: just give a slice directly to <code>sum()</code>. In order to do\nthat, you can perform string-to-int conversion in one place, before summing.\n(4) Because <code>bool</code> is a subclass of <code>int</code>, your count-incrementing code does\nnot require conditional logic. (5) This function is difficult to describe and\nname compactly, but your current name is especially vague. Here's a possible\nrenaming. (6) Finally, and this is done purely to simplify the rest of the\ndiscussion, I have modified the function to do the counting over an inclusive\nrange.</p>\n<pre><code>def n_parity_balanced_integers(x, y):\n count = 0\n for number in range(x, y + 1):\n digits = tuple(map(int, str(number)))\n count += sum(digits[0::2]) % 2 == sum(digits[1::2]) % 2\n return count\n</code></pre>\n<p>Such edits improve the code, but they do not significantly affect the\nalgorithm's speed. It's still a brute-force solution. The key to making further\nprogress is to find a pattern that can be used to radically reduce the needed\ncomputation. One way to find these patterns is to experiment with the data. For\nexample:</p>\n<pre><code># A brief experiment.\nchecks = [\n (0, 9),\n (0, 99),\n (0, 999),\n (0, 9999),\n (10, 19),\n (20, 29),\n (10, 39),\n]\nfor lower, upper in checks:\n print(f'{lower}-{upper}:', n_parity_balanced_integers(lower, upper))\n\n# Output\n0-9: 5\n0-99: 50\n0-999: 500\n0-9999: 5000\n10-19: 5\n20-29: 5\n10-39: 15\n</code></pre>\n<p>In other words, over any inclusive range spanning an entire power-of-ten's\nworth of numbers (or any multiple of that, such as <code>10-39</code>), you can instantly\ncompute the answer without iterating over every discrete number in the range.\nSo the trick to this problem is to start with the full range, decompose it into\nsubcomponents that can be computed instantly, and then brute-force any\nstraggling bits. Give that a shot a see what you come up with.</p>\n", "comments": [], "meta_data": { "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-11-26T20:35:01.453", "Id": "270428", "ParentId": "270414", "Score": "5" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-01T05:27:41.037", "Id": "534370", "Score": "0", "body": "what if the given `current_time` was 9:49 AM in UTC+1 timezone? (8:49 AM UTC)" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-01T07:54:12.150", "Id": "534377", "Score": "0", "body": "@hjpotter92 I don't understand the question." } ]

{ "AcceptedAnswerId": null, "CommentCount": "2", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-01T00:40:14.073", "Id": "270558", "Score": "3", "Tags": [ "python", "python-3.x", "datetime" ], "Title": "Finding the next 9am/pm from now" }

[ { "body": "<p>Your function <code>_get_nineoclock_time</code> does two things, it replaces the <code>timezone</code> and it returns the next 9 O'clock time. The function will return different values depending on whether <code>current_time</code> has a timezone or not. That may be unexpected and seems a likely source of bugs. I'd set the timezone somewhere else.</p>\n<p>It is easy to calculate how many hours to add from midnight based on the current hour. Then use <code>timedelta</code> to add that many hours.</p>\n<pre><code>def get_next_nineoclock_time(current_time: datetime) -&gt; datetime:\n hours = 9 if current_time.hour &lt; 9 else 21 if current_time.hour &lt; 21 else 33\n \n midnight = current_time.replace(\n hour=0,\n minute=0,\n second=0,\n microsecond=0,\n )\n \n return midnight + timedelta(hours=hours)\n</code></pre>\n<p>Your could use this formula for <code>hours</code>, but I thinks it is less clear:</p>\n<pre><code>hours = 9 + 12*((current_time.hour + 3)//12)\n</code></pre>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-02T03:25:42.203", "Id": "534490", "Score": "0", "body": "Coincidentally, we realized that time zone issue today. I like this solution, thanks!" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-02T16:29:06.083", "Id": "534566", "Score": "0", "body": "@DanielKaplan this timezone issue was what I had pointed out earlier in the comment on question :)" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-02T17:16:01.307", "Id": "534577", "Score": "0", "body": "@hjpotter92 ah, sorry I didn't understand it" } ], "meta_data": { "CommentCount": "3", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-02T02:32:15.377", "Id": "270603", "ParentId": "270558", "Score": "3" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-01T05:11:46.277", "Id": "534369", "Score": "0", "body": "_Does_ it pass all the test cases?" } ]

{ "AcceptedAnswerId": "270562", "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-01T01:44:59.950", "Id": "270560", "Score": "0", "Tags": [ "python", "performance", "combinatorics" ], "Title": "Absolute Permutation | Hacker Rank: Any way to make this python code faster without changing it's whole logic?" }

[ { "body": "<p>Yeah, you are recreating <code>tmp</code> every iteration of your loop. This makes your solution O(n^2). You could easily make your solution O(n) by setting <code>tmp</code> before your loop and then updating it along with <code>newlist</code>. The reason your current solution is O(n^2) is that building the tmp set with all the items in newlist would take as long as new list. For example, if <code>newlist=[1,2,3,4,5,6,7,...1000]</code> then constructing the tmp set would take 1000 steps.</p>\n<pre><code>def absolutePermutation(number, k):\n newlist=[]\n tmp=set()\n for i in range(1,number+1):\n bigger=k+i\n smaller=i-k\n if (bigger&gt;number and smaller&lt;=0) or (bigger&gt;number and smaller in tmp) or (smaller&lt;=0 and bigger in tmp):\n return [-1]\n\n if smaller&lt;=0 or smaller in tmp:\n newn=bigger\n else:\n newn=smaller\n\n #print(newn)\n\n newlist.append(newn)\n tmp.add(newn)\n\n return newlist\n</code></pre>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-02T00:53:29.337", "Id": "534485", "Score": "0", "body": "Nice! Such a simple change actually passed all the tests. So I don't need the most efficient but hard to get to algorithm to solve this. Thanks for noticing the inefficiency!" } ], "meta_data": { "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-01T05:47:27.680", "Id": "270562", "ParentId": "270560", "Score": "1" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-01T07:57:38.307", "Id": "534378", "Score": "0", "body": "You probably want to reject \"Why?\" and \"Who?\" questions as well..." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-01T07:58:55.127", "Id": "534379", "Score": "0", "body": "Yes, need to take this into account" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-01T19:00:07.657", "Id": "534437", "Score": "4", "body": "@TobySpeight - \"Is the Who the greatest rock band of all time?\" And now we see the difficulty of natural language processing." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-01T20:06:46.647", "Id": "534450", "Score": "0", "body": "@ribs2spare - did you miss the `not` in that condition?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-01T20:09:56.470", "Id": "534451", "Score": "0", "body": "Sure did! Deleted it." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-01T22:21:01.033", "Id": "534469", "Score": "2", "body": "Forgive me if I am missing some quirk of python, but don't the `is_question` and `is_valid_question` functions completely ignore their inputs as currently implemented?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-01T23:36:03.473", "Id": "534477", "Score": "0", "body": "@LOTGP You are completely correct. Also, `('When' or 'How' or 'Where') not in q` will only test `'When' not in q`, since `('When' or 'How' or 'Where')` will evaluate to simply `'When'` ... the first truthy value. A proper way of writing what was intended would be `return all(term not in question for term in ('When', 'How', 'Where'))`" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-02T07:27:13.173", "Id": "534506", "Score": "0", "body": "Thanks for the clarification, debugged." } ]

{ "AcceptedAnswerId": "270573", "CommentCount": "8", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-01T07:40:35.363", "Id": "270566", "Score": "3", "Tags": [ "python", "python-3.x" ], "Title": "Magic ball 8 program" }

[ { "body": "<p>I'd like to address how you handle the yes/no question controlling the loop.</p>\n<p>The relevant sections of your code are:</p>\n<pre class=\"lang-py prettyprint-override\"><code>again = 'yes'\n\nwhile again == 'yes':\n # [...]\n again = input('Are there any other questions?\\n')\n # [...]\n</code></pre>\n<p>Almost all user input are interpreted as &quot;no&quot;. However, the user has no information that they are supposed to enter the exact string <code>yes</code> for a positive answer. It is common for command line programs to accept <code>y</code> or <code>n</code> as an input, but neither of these will be treated as a positive answer in your code. Same for <code>Yes</code>, <code>YES</code> (different capitalization), <code> yes</code>, <code>yes </code> (leading/trailing white space), <code>yeah</code>, <code>yep</code> (different words), while all of these answer are clearly positives.</p>\n<p>Similarly, inputs that are neither positive nor negative will be interpreted as negative, while the issue may be a typo or a misunderstanding of the answer expected. In this case, the input should be discarded, extra information given to the user on why, and the question asked again.</p>\n<p>This makes handling this input much more complex, but as asking yes/no questions is very common in CLI programs, if you write a function that handles this, you only need to write it once and you are then free to reuse it many more times in the future.</p>\n<p>My take on it is:</p>\n<pre class=\"lang-py prettyprint-override\"><code>def get_yes_no_input(prompt):\n POSITIVE_VALUES = ['yes',\n 'y',\n 'yeah',\n 'yep',\n 'true',\n '1']\n NEGATIVE_VALUES = ['no',\n 'n',\n 'nope',\n 'false',\n '0']\n while True:\n print(prompt)\n val = input('&gt; ').strip().lower()\n if val in POSITIVE_VALUES:\n return True\n if val in NEGATIVE_VALUES:\n return False\n print('Invalid answer. Please answer yes or no.')\n</code></pre>\n<p>Some comments on my code:</p>\n<ul>\n<li>since the function is meant to be reusable, it takes the question text as an argument (<code>prompt</code>)</li>\n<li>it returns a boolean value, as it can be handled differently according to the use case, and they are easier to work with than strings</li>\n<li>it uses constant lists for positive and negative answer, from which you can easily add or remove values</li>\n<li>the input is <code>strip</code>ped to handle potential leading/trailing white space</li>\n<li>the input is <code>lower</code>ed to handle capitalization issues</li>\n<li>if the input is neither positive or negative, it is rejected and information about the expected answer is given</li>\n</ul>\n<p>Use in your code would be something like this:</p>\n<pre class=\"lang-py prettyprint-override\"><code>again = True\n\nwhile again:\n # [...]\n again = get_yes_no_input('Are there any other questions?')\n # [...]\n<span class=\"math-container\">```</span>\n</code></pre>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-01T11:15:06.430", "Id": "534388", "Score": "0", "body": "Or more advanced way NLP can be used if you want more, happy coding ;)" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-01T13:36:49.353", "Id": "534411", "Score": "0", "body": "Thank you for the recomendations!" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-01T13:41:04.370", "Id": "534413", "Score": "0", "body": "Why did You capitalize lists of positive and negative values? I want the program to match the PEP-8, are list names allowed to be formatted like that?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-01T13:56:49.110", "Id": "534414", "Score": "0", "body": "@vlados155 All caps are used for constants. Although PEP8 recommends this for module-level constants, there is no recommendations for method- or class-level constants, so I did what I thought was best. You are free to disagree with me and use another naming convention in this case, just be consistent throughout your own code." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-01T14:04:15.900", "Id": "534415", "Score": "0", "body": "Thank You for the clarification." } ], "meta_data": { "CommentCount": "5", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-01T11:01:15.107", "Id": "270573", "ParentId": "270566", "Score": "5" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-01T19:22:15.813", "Id": "534443", "Score": "0", "body": "You've implemented an insertion sort (I think), which is inherently not really an optimal way to sort things. Do you want answers within the context of implementing insertion sorting in python or optimal sorting of a list in general? (i.e. `originallist.sort()`) :)" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-01T19:33:02.610", "Id": "534447", "Score": "0", "body": "Thank you for the feedback @JeffUk! It would be great if you could share insights on optimal sorting of list in general. list.sort(). And also any feedback to improve the thinking pattern to develop the algorithms based on the above code e.g. if I should be changing the mindset to approach a problem etc" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-01T19:36:25.147", "Id": "534448", "Score": "0", "body": "@JeffUK It's selection sort." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-01T19:46:59.923", "Id": "534449", "Score": "0", "body": "@KellyBundy I was just about to change my comment after doing some research. Should have taken Compsci instead of IT.." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-01T22:17:20.147", "Id": "534467", "Score": "1", "body": "I have added the [tag:reinventing-the-wheel] tag as otherwise the answer \"use the [Timsort](https://en.wikipedia.org/wiki/Timsort) built into Python from Python 2.3 by using `list.sort()` or `sorted`\" is 'the best' but possibly not too helpful answer." } ]

{ "AcceptedAnswerId": "270602", "CommentCount": "5", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-01T07:47:50.107", "Id": "270567", "Score": "0", "Tags": [ "python", "beginner", "python-3.x", "sorting", "reinventing-the-wheel" ], "Title": "Simple sort function" }

[ { "body": "<p>There's some odd features to this code, even for a coding practice exercise. Python of course has <a href=\"https://docs.python.org/3.7/library/functions.html#sorted\" rel=\"nofollow noreferrer\">a couple</a> of <a href=\"https://docs.python.org/3.7/library/stdtypes.html#list.sort\" rel=\"nofollow noreferrer\">list sorting</a> techniques which <strong>you should absolutely use</strong> in normal circumstances.</p>\n<p>So <em>accepting</em> that you are doing this for practice, I wonder what the point of the <code>duplicatelist</code> is? Or indeed <code>temp</code>? Are these development fossils of some earlier process that you have modified? Looping across this list just seems to find the minimum value in the remaining original list anyway, so</p>\n<pre><code>originallist=[5, 4, 8, 2, 3, 6, 0, 1, 7]\n\nsortedlist=[] ## Sorted list \n\nwhile len(originallist)&gt;0: # See if there are any elements left in original list\n\n lowervalue = originallist[0]\n for i in originallist: \n if lowervalue &gt; i:\n lowervalue = i\n print('New LowerValue: ', lowervalue)\n\n sortedlist.append(lowervalue)\n print('Growing Sorted List: ', sortedlist)\n originallist.remove(lowervalue)\n print('Reduced Original List: ', originallist, ' \\n')\n \n\nprint('Sorted List :' , sortedlist)\n</code></pre>\n<p>would apparently do the same.</p>\n<p>Of course there is also a <a href=\"https://docs.python.org/3.7/library/functions.html#min\" rel=\"nofollow noreferrer\">min</a> function that would find <code>lowervalue</code> quickly. This eliminates the inner loop (is this maybe why you didn't use it?):</p>\n<pre><code>originallist = [5, 4, 8, 2, 3, 6, 0, 1, 7]\n\nsortedlist=[] ## Sorted list \n\nwhile len(originallist)&gt;0: # See if there are any elements left in original list\n\n lowervalue = min(originallist)\n print('LowerValue: ', lowervalue)\n\n sortedlist.append(lowervalue)\n print('Growing Sorted List: ', sortedlist)\n originallist.remove(lowervalue)\n print('Reduced Original List: ', originallist, ' \\n')\n \n\nprint('Sorted List :' , sortedlist)\n</code></pre>\n<p>Using <code>remove</code> from a list can be slow - effectively rewriting the remainder of the list. For the purposes you have here, I don't think it makes an appreciable difference and has the slight advantage of being easy to understand.</p>\n<p>One construct you will often see in a reducing list is phrasing the <code>while</code> loop like this:</p>\n<pre><code>while originallist:\n</code></pre>\n<p>... any non-empty list evaluates as <code>True</code> in such a test, so this is the same test as you are making.</p>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-02T01:42:38.223", "Id": "534486", "Score": "0", "body": "@Syed You have to be careful with magic numbers as sentinel values. If I put `0.01` into your original list, it doesn't get sorted." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-02T09:15:58.907", "Id": "534510", "Score": "0", "body": "Thank you soo much Joffan!\n\nYour code makes a lot more sense. It is just that I was viewing the problem from very different perspective (given I have started with python recently with no back experience in algorithms and coding). The initial thought was to compare the originallist elements with itself and to visualize it better I went ahead with duplicating the list and comparing the elements." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-02T09:16:05.617", "Id": "534511", "Score": "0", "body": "The thought process behind the variable **temp** was there to store the smaller value when ever it compared 2 elements (the one from original list being compared to the one from duplicate). And then compare it with **lowervalue** to see if it is smaller among the list till that point in the iteration. But I can see your method is much simpler and efficient. I just could not see it that way while coding. \n\nI did not use the min function intentionally as I was trying to write code without python helping with the built in functions for practice." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-02T09:17:29.217", "Id": "534512", "Score": "0", "body": "Yes Teepeemm! I was struggling with what value to initialize for **lowervalue** but now i see we should do it with the first value of originallist as in the above code!" } ], "meta_data": { "CommentCount": "4", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-02T00:31:28.110", "Id": "270602", "ParentId": "270567", "Score": "3" } } ]

[]

{ "AcceptedAnswerId": null, "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-01T18:51:19.507", "Id": "270589", "Score": "0", "Tags": [ "python", "regex" ], "Title": "Python function for finding if all substrings exist in a string in sequence" }

[ { "body": "<p>The problem with your current approach is that it can give incorrect results\nor raise an exception if any of the substrings contain characters that\nhave special meaning in Python regular expressions.</p>\n<pre><code>are_substrings_in_text(['a', '.', 's'], 'abacus')) # Returns True\nare_substrings_in_text(['a', '+', 's'], 'abacus')) # Raises exception\n</code></pre>\n<p>The solution is to escape such characters so that they are handled as\nliteral substrings. This illustration also makes a few cosmetic adjustments\nto simplify things for readability:</p>\n<pre><code>from re import search, escape\n\ndef are_substrings_in_text(substrings, text):\n pattern = '.*'.join(escape(s) for s in substrings)\n return bool(search(pattern, text))\n</code></pre>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-01T23:21:27.913", "Id": "534475", "Score": "2", "body": "Any reason you're not using `'.*'.join(escape(s) for s in substrings)`?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-01T23:51:12.867", "Id": "534482", "Score": "1", "body": "@AJNeufeld I blame my aging mind." } ], "meta_data": { "CommentCount": "2", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-01T19:32:56.553", "Id": "270593", "ParentId": "270589", "Score": "4" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-03T09:21:49.910", "Id": "534619", "Score": "0", "body": "You shouldn't use comments to describe your function, but [docstrings](https://www.python.org/dev/peps/pep-0257/)." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-03T19:08:55.710", "Id": "534628", "Score": "0", "body": "I have rolled back Rev 5 → 3. Please see [_What to do when someone answers_](https://codereview.stackexchange.com/help/someone-answers)." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-03T22:18:36.907", "Id": "534635", "Score": "0", "body": "For `start_date = date(2021, 1, 8)`, the first date you produce is `'2021-01-08'`. Is that actually correct? That's the month's second Friday..." } ]

{ "AcceptedAnswerId": "270628", "CommentCount": "3", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-02T16:01:04.153", "Id": "270620", "Score": "3", "Tags": [ "python", "python-3.x", "datetime" ], "Title": "Produce a list of every 1st, 3rd, and 5th Friday of each month in a date range" }

[ { "body": "<p>It seems rather inefficient to generate every date, then filter out non-Fridays, then filter out ones that arent't the first, third, or fifth Friday. Calculate directly them instead.</p>\n<p>Find the first Friday in the range:</p>\n<pre><code>friday = start + timedelta((FRIDAY - start.weekday())%7)\n</code></pre>\n<p>Move forward a week if it's not the 1st, 3rd, or 5th Friday:</p>\n<pre><code>ONE_WEEK = timedelta(weeks=1)\n\nweek = (friday.day - 1)//7 + 1\nif week not in (1,3,5):\n friday += ONE_WEEK\n</code></pre>\n<p>While <code>friday</code> is still in the data range, yield the date. If it's the 1st or 3d Friday, add one week, otherwise add two weeks (day 22 is the start of the 4th week):</p>\n<pre><code>TWO_WEEKS = timedelta(weeks=2)\n\nwhile friday &lt; end:\n yield friday\n \n if friday.day &lt; 22:\n friday += TWO_WEEKS\n else:\n friday += ONE_WEEK\n</code></pre>\n<p>Putting it all together:</p>\n<pre><code># date.weekday() returns 0 for Monday, so 4 = Friday\nFRIDAY = 4\n\nONE_WEEK = timedelta(weeks=1)\nTWO_WEEKS = timedelta(weeks=2)\n\ndef gen_friday_135(start, end):\n friday = start + timedelta((FRIDAY - start.weekday())%7)\n \n week = (friday.day - 1)//7 + 1\n if week not in (1,3,5):\n friday += ONE_WEEK\n\n while friday &lt; end:\n yield friday\n \n if friday.day &lt; 22:\n friday += TWO_WEEKS\n else:\n friday += ONE_WEEK\n</code></pre>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-02T22:17:58.293", "Id": "534596", "Score": "0", "body": "Wow, almost all of my code is is unnecessary!" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-03T18:15:50.843", "Id": "534625", "Score": "0", "body": "What is the purpose of the minus 1 in the week variable? I tried the generator with and without that minus 1, and it produced the same list in both cases" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-03T23:39:50.363", "Id": "534640", "Score": "1", "body": "@StephenWilliams, `friday.day` returns integers in the range 1-31. The minus one converts it so the range starts at zero so the // operator gives the correct week number. Without it, the formula would calculate the 7th as being in the second week." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-04T02:56:20.860", "Id": "534647", "Score": "0", "body": "That makes sense to me. I'm still wondering why its removal didn't affect the list, though." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-04T04:24:42.123", "Id": "534648", "Score": "1", "body": "@StephenWilliams, without the -1 `gen_friday_135(start=date(2021, 5, 2),\n end=date(2021, 5, 30))` will yield the 5/14 and 5/28 (the 2nd and 4th Fridays) instead of 5/7 and 5/21 (the 1st and 3rd Fridays)." } ], "meta_data": { "CommentCount": "5", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-02T20:00:08.687", "Id": "270628", "ParentId": "270620", "Score": "9" } } ]

[]

{ "AcceptedAnswerId": "270626", "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-02T18:13:04.213", "Id": "270625", "Score": "2", "Tags": [ "python", "python-3.x", "file-system" ], "Title": "Read file from current path in Python" }

[ { "body": "<p>Which commandment did you violate? Using <code>os.path</code> and <code>pathlib</code> in the same breath! <code>pathlib</code> is an object-oriented replacement to <code>os.path</code>.</p>\n<pre><code> path = os.path.join(Path.cwd().resolve(), file)\n if os.path.isfile(path):\n with open(path) as f:\n</code></pre>\n<p>could be written as:</p>\n<pre><code> path = Path.cwd().joinpath(file)\n if path.is_file():\n with path.open() as f:\n</code></pre>\n<p>or since you're starting at the current directory, simply:</p>\n<pre><code> path = Path(file)\n if path.is_file():\n with path.open() as f:\n</code></pre>\n", "comments": [ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-02T19:00:03.640", "Id": "534587", "Score": "0", "body": "I am using `ruamel yaml` in my own project, so I might be missremembering the details. I thought one could simply do `content = yaml.load(path, Loader=SafeLoader)` directly on the path without having to explicitly open it?" }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-02T19:05:33.057", "Id": "534589", "Score": "0", "body": "@N3buchadnezzar That may be true; I haven't used `yaml` at all. My answer focused on the mashup between `os.path` and `pathlib`, stopping just before the `yaml.load(...)` line for that very reason." }, { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-02T19:06:06.347", "Id": "534590", "Score": "0", "body": "thank you, very helpful!" } ], "meta_data": { "CommentCount": "3", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-02T18:55:31.570", "Id": "270626", "ParentId": "270625", "Score": "3" } } ]

[ { "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-02T21:18:07.060", "Id": "534594", "Score": "0", "body": "Could you double check your indentation? If you highlight everything and click `{}`, that should get you started. Otherwise, your last few lines aren't rendering correctly." } ]

{ "AcceptedAnswerId": null, "CommentCount": "1", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-02T20:52:34.433", "Id": "270630", "Score": "1", "Tags": [ "python", "beginner", "rock-paper-scissors" ], "Title": "Simple Rock Paper Scissors game in Python" }

[ { "body": "<h1>Good things</h1>\n<p>You mostly follow PEP8 styling conventions, making your code quite readable. The only exception I see is an extra blank line at the beginning of the <code>score</code> and <code>play</code> methods.</p>\n<p>Also, it is good thinking to wrap your game state into a class for future integration into a more complex project. It is also a good use of a main guard at the end.</p>\n<p>However, there are things that need to be improved to reach your end goal.</p>\n<h1>Things to improve</h1>\n<h2>Game loop logic</h2>\n<p>Your game loop logic fails completely: execution loops forever inside the <code>play()</code> method, and thus the <code>game.score()</code> and <code>game.re_do()</code> are never called. The game never ends and the total score is never diplayed.</p>\n<p>You should remove one of the infinite loop, and handle it properly.</p>\n<p>I would have a <code>run(self)</code> instance method that goes something like this:</p>\n<pre class=\"lang-py prettyprint-override\"><code>class RockPaperScissors\n\n # some stuff\n\n def run(self):\n play_again = True\n while play_again:\n player_move = get_player_input()\n machine_move = get_machine_input()\n winner = get_winner(player_move, machine_move)\n show_message(winner, score)\n play_again = get_yes_no_input()\n\n\nif __name__ == &quot;__main__&quot;:\n game = RockPaperScissors()\n game.run()\n</code></pre>\n<p>It still has some issues I'll address later (for later integration in a PyGame project), but at it should behave as expected potential issues can be worked on one at a time, in each of the method called.</p>\n<h2>Separation of concern</h2>\n<p>Although you tried to separate logic (by implementing a game class) from display, you failed and mix both all over the code.</p>\n<p>For example, the <code>check()</code> method should return the winner instead of displaying a message. Further down the line, if you want to implement a GUI with PyGame, you can handle a function return, or query the state of member variables, but a <code>print</code> output will be no use.</p>\n<p>Same goes from getting input. Eventually, inputs will be supplied by a PyGame instance through widgets or something. You should put all console-related actions (<code>print</code> and <code>input</code>) in separate methods that you should be able to override, depending on how you want to use the game class.</p>\n", "comments": [], "meta_data": { "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-03T10:51:28.027", "Id": "270645", "ParentId": "270630", "Score": "2" } } ]

[]

{ "AcceptedAnswerId": "270640", "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-03T04:21:23.580", "Id": "270639", "Score": "3", "Tags": [ "python", "design-patterns" ], "Title": "Design a pattern using python" }

[ { "body": "<p>Welcome to Code Review.</p>\n<p>Your code is literally 4 lines. So there isn't much to review.</p>\n<ul>\n<li><p>Do not use the <code>is</code> operator to compare the integers. See <a href=\"https://stackoverflow.com/questions/132988/is-there-a-difference-between-and-is\">difference between <code>is</code> and <code>==</code></a></p>\n</li>\n<li><p>You can save the nested loop: you are already ensuring <code>col == row</code> so you can instead write:</p>\n</li>\n</ul>\n<pre class=\"lang-py prettyprint-override\"><code>for row in range(1,6):\n print(&quot;* &quot; * row)\n</code></pre>\n<ul>\n<li>If we want to get technical, the code you have written has a time complexity of <strong>O(n^3)</strong>, but the problem can be solved in <strong>O(n^2)</strong>. You can read more on this topic <a href=\"https://www.google.com/amp/s/www.mygreatlearning.com/blog/why-is-time-complexity-essential/%3famp\" rel=\"nofollow noreferrer\">here</a>.</li>\n</ul>\n", "comments": [], "meta_data": { "CommentCount": "0", "ContentLicense": "CC BY-SA 4.0", "CreationDate": "2021-12-03T05:01:41.520", "Id": "270640", "ParentId": "270639", "Score": "4" } } ]