Datasets:

---

suriyagunasekar

/

stackoverflow-python-with-meta-data

like 12

[ "The simpliest solution is to use the Partial Index, which are supported for PostgreSQL, Partial Indexes and SQLite, Partial Indexes.\nThe code below should work for both:\nclass Association(Base):\n __tablename__ = \"association_table\"\n left_id = Column(ForeignKey(\"left_table.id\"), primary_key=True)\n right_id = Column(ForeignKey(\"right_table.id\"), primary_key=True)\n first_child = Column(Boolean, nullable=False)\n child = relationship(\"Child\", back_populates=\"parents\")\n parent = relationship(\"Parent\", back_populates=\"children\")\n\n __table_args__ = (\n Index(\n \"uci_first_child\",\n left_id,\n unique=True,\n postgres_where=first_child==True, # will be used for postgresql\n sqlite_where=first_child==True, # will be used for sqlite\n ),\n )\n\n" ]

[ 3 ]

[]

[]

[ "python", "sqlalchemy" ]

[ "Declare Data as empty list outside for-loop and use .append to insert a float value into it:\nData = []\nwith open(r\"myfile.asc\", \"r\") as file_in:\n for line in map(str.strip, file_in):\n if \"LoggingString :=\" in line:\n # ...\n Data.append(float(Output_list[count][8]))\n count += 1\n\nprint(Data)\n\n", "The problem occurs when trying to map an individual string '1.06' into a float object. It wil treat the string as an array and try to turn each individual element of the array into a float object, but the second element of this example is the dot character . which cannot be turned into a float object.\n>>> my_array = ['0','1.06','23.345']\n>>> list(map(float, my_array[1]))\nTraceback (most recent call last):\n File \"<stdin>\", line 1, in <module>\nValueError: could not convert string to float: '.'\n\nInstead it is more convenient to turn all elements of the array into float objects:\n>>> my_array = ['0', '1.06', '23.345']\n>>> list(map(float,my_array))\n[0.0, 1.06, 23.345]\n\nFor more information you can look at the map documentation.\n" ]

[ 1, 0 ]

[]

[]

[ "file", "numpy", "pandas", "python", "type_conversion" ]

[ "There is really not enough information given in this question to solve the problem outright. That said, if I understand correctly, you perhaps are looking to see where any two functions (line or curve) are intersecting.\nThere are a few approaches. The most simple I'd say would be to use robust curve intersection approach such as this implementation by sukhbinder: intersection, which is itself a python port of an existing Matlab File Exchange entry.\nFor example, given a sigmoid that looks somewhat like your figure above, and an overlapping sine wave, find the intersections:\nfrom intersect import intersection\nimport matplotlib.pyplot as plt\nimport numpy as np\n\nx1 = np.linspace(-1, 1, 100)\ny1 = 1 / (1 + np.exp(-x1 * 25))\n\nx2 = np.linspace(-1, 1, 100)\ny2 = np.sin(x2 * 2.25) + 0.5\n\nx, y = intersection(x1, y1, x2, y2)\n\nplt.plot(x1, y1, c=\"r\")\nplt.plot(x2, y2, c=\"g\")\nplt.plot(x, y, \"*k\")\nplt.show()\n\n\nEdit (#2 to solve for x at y=0)\nI do not have the reputation to comment on the original post, but will mention this sounds instead like a root finding problem.\nFor completeness, here's a rework of the same approach using the data supplied by OP. The intersecting line in this case is a line spanning the min/max of x1 where . Essentially, this is now a graphical look at finding the roots.\nfrom intersect import intersection\nimport matplotlib.pyplot as plt\nimport numpy as np\n\ndata = np.array(\n [\n [-2.0, -2.22537043],\n [-1.9, -2.22609532],\n [-1.8, -2.22075396],\n [-1.7, -2.22729678],\n [-1.6, -2.22353721],\n [-1.5, -2.22341588],\n [-1.4, -2.2180032],\n [-1.3, -2.22850037],\n [-1.2, -2.22553919],\n [-1.1, -2.22866368],\n [-1.0, -2.22400234],\n [-0.9, -2.22865694],\n [-0.8, -2.22058969],\n [-0.7, -2.22399086],\n [-0.6, -2.20372207],\n [-0.5, -2.22639477],\n [-0.4, -2.10633351],\n [-0.3, -2.03573848],\n [-0.2, -1.52582935],\n [-0.1, -0.344812049],\n [0.0, 1.61330696],\n [0.1, 2.21013059],\n [0.2, 2.22698993],\n [0.3, 2.22698993],\n [0.4, 2.22698993],\n [0.5, 2.22698993],\n [0.6, 2.22698993],\n [0.7, 2.21522144],\n [0.8, 2.22699297],\n [0.9, 2.22361681],\n [1.0, 2.22055266],\n [1.1, 2.22299154],\n [1.2, 2.21155482],\n [1.3, 2.22212628],\n [1.4, 2.22437687],\n [1.5, 2.22365865],\n [1.6, 2.21749658],\n [1.7, 2.22603657],\n [1.8, 2.22736],\n [1.9, 2.22471317],\n [2.0, 2.227242961]\n ]\n)\nx1, y1 = data[:, 0], data[:, 1]\n\nx2 = [np.min(x1), np.max(x1)]\ny2 = [0, 0]\n\nx, y = intersection(x1, y1, x2, y2)\n\nplt.plot(x1, y1, c=\"r\")\nplt.plot(x2, y2, c=\"g\")\nplt.plot(x, y, \"*k\")\nplt.show()\n\n\n", "I don't know if there is anything standard in matplotlib, but the below algorithm in a loop\n\nFind xi where y[xi] > 0. Call that location i.\nIf y[xi - 1] == 0, don't continue - its an x intercept add it to the array, else\nCompute the slope -> y2 - y1 / x2 -x1.\nPlugin an (x0, y0) pair to solve for the intercept.\nSolve for the x, instead of the y.\n\ncan compute those values.\nimport numpy as np\nvalues = np.loadtxt(r\"test.txt\", delimiter=\" \")\nx_intercepts = []\nfor i, v in enumerate(values):\n if i > 0:\n # if y > 0\n if v[1] > 0:\n previous_v = values[i - 1]\n # if the previous y == 0\n if previous_v[1] == 0:\n x_intercepts.append(previous_v[0])\n elif previous_v[1] < 0:\n # slope = y2 - y1 / x2 - x1\n # formula of linear equation -> y = mx + b\n # intercept -> b = y - m(x)\n slope = (v[1] - previous_v[1]) / (v[0] - previous_v[0])\n # if the slope is changing and not a constant\n if slope != 0:\n intercept = v[1] - (slope * v[0])\n # equation -> y = (slope * x) + intercept\n # equation -> y - intercept = (slope * x)\n # equation -> (y - intercept) / slope = x\n x_intercept = (0 - intercept) / slope\n x_intercepts.append(x_intercept)\n else:\n # if the if doesn't make it, we still need to check if the previous value was 0\n if values[i - 1][1] == 0:\n x_intercepts.append(values[i - 1][0])\nprint(x_intercepts)\n\nGive this a whirl and let me know how it works for you.\n\nExplanation\n\nThe for loop gives us the index (i) of the current value v.\nWe want to be able to use the current value as the pair (x2, y2) and the previous value as (x1, y1), so I check to make sure we aren't on the first iteration with if i > 0:\nIf y2 < 0 (the only else statement), check if y1 is == to 0 -> if so add it as an x intercept.\nIf y2 > 0, check if y1 is == to 0 -> if so add it as an x intercept.\nIf its not, check if it is less than 0.\nCompute the slope and check if the slope is not 0 -> we want to avoid a division by 0 error.\nCompute the y intercept.\nSolve for the x intercept and add it to the list of x intercepts.\n\n" ]

[ 5, 0 ]

[]

[]

[ "matplotlib", "python" ]

[ "write method takes exactly one argument\nso you should write like this:\nf.write(f\"{message_variable_from_previous_input}\\n\")\nor :\nf.write(str(message_variable_from_previous_input) + \"\\n\")\n" ]

[ 3 ]

[]

[]

[ "python", "txt" ]

[ "This session-scoped fixture should be defined in a conftest.py module, see conftest.py: sharing fixtures across multiple files in the docs.\n\nThe conftest.py file serves as a means of providing fixtures for an entire directory. Fixtures defined in a conftest.py can be used by any test in that package without needing to import them (pytest will automatically discover them).\n\nBy writing the fixture in something_fixture.py it was defined somewhere that went \"unnoticed\" because there was no reason for Python to import this module. The default test collection phase considers filenames matching these glob patterns:\n- test_*.py\n- *_test.py\n\nSince it's a session-scoped feature, define it instead in a conftest.py file, so it will be created at test collection time and available to all tests.\nYou can remove the import statement from tests.something_fixture import something. In fact the \"tests\" subdirectory generally doesn't need to be importable at all.\n" ]

[ 1 ]

[]

[]

[ "fixtures", "pytest", "python" ]

[ "To enable BigQuery API from console:\n\nGo to console.google.com\nFrom the menu, click on APIs & Services ->Enable APIs & Service\nClick on Enable APIs and Service\nSearch for BigQuery API and click on enable\n\nTo enable through gcloud sdk:\ngcloud services enable bigquery.googleapis.com\n\nYou may need to enable other BigQuery related APIs as well:\nbigquery.googleapis.com BigQuery API\nbigqueryconnection.googleapis.com BigQuery Connection API\nbigquerydatatransfer.googleapis.com BigQuery Data Transfer API\nbigquerymigration.googleapis.com BigQuery Migration API\nbigquerystorage.googleapis.com BigQuery Storage API\n\nTo enable a service through python REST refer this documentation\nTo interact/work with BigQuery using Python client library:\nInstall the Python Client library for BigQuery:\ninstall google-cloud-bigquery\n\nQuery stack overflow public dataset:\nfrom google.cloud import bigquery\n\nclient = bigquery.Client()\n\n# Perform a query.\nQUERY = (\"SELECT title FROM `bigquery-public-data.stackoverflow.posts_questions` LIMIT 10\")\nquery_job = client.query(QUERY) # API request\nrows = query_job.result() # Waits for query to finish\n\nfor row in rows:\n print(row.name)\n\nReference: BigQuery QuickStart using client libraries\n" ]

[ 0 ]

[]

[]

[ "google_api_client", "google_bigquery", "google_cloud_platform", "python" ]

[ "Add with AlternativePrinter(): in wait_and_print. The lines below if __name__ == \"__main__\": are not executed in the child process and hence AlternativePrinter() is never used.\n" ]

[ 1 ]

[]

[]

[ "io", "output", "python", "python_multiprocessing", "python_multithreading" ]

[ "You can change the return type of GetMonths() :\ndef GetMonths():\n Months = input(\"Enter the number of months you want to analyze\")\n return int(Months)\n\n\nOr You can cast the type to int in range() of AnalyzeBudget()\ndef AnalyzeBudget(months):\n for month in range(1,int(months)+1):\n print(\"\\nMonth\",month,\":\")\n print(\"=======\")\n MoBudget,MoSpent = GetMonthBudgetandSpent(month)\n\n", "As @quamrana said you need to\ndef GetMonths():\n Months = input(\"Enter the number of months you want to analyze\")\n return int(Months)\n\nThe error says TypeError: can only concatenate str (not \"int\") to str because when you ask for Months in\nMonths = input(\"Enter the number of months you want to analyze\")\n\nPython read the input as a string, then in months+1 you are adding a string with an int so you get the error.\nI recommend to factorize your code in an class where each function is a method, I can help you with this if you need to.\nEdit(This is not related to the original post).\nYou have an error in GetMonthBudgetandSpent, you can do the following.\ndef GetMonthBudgetandSpent(month):\n Mobudget = input(\"Enter the budget you have for the month\")\n MoSpent = input(\"Enter the amount you spent this month\")\n MoSpent = int(MoSpent)\n Mobudget = int(Mobudget)\n return Mobudget, MoSpent\n\nAs @Pranav Hosangadi said int function int docs takes in the first input of the thing you want to convert, so you can only pass one string.\nFor the if statement you asked for in the comments.\ndef AnalyzeBudget(months):\nfor month in range(1,months+1):\n print(\"\\nMonth\",month,\":\")\n print(\"=======\")\n MoBudget,MoSpent = GetMonthBudgetandSpent(month)\n if MoBudget >= MoSpent:\n print(\"Safe zone\")\n else :\n print(\"Danger zone\") \n\nHere if MoBudget >= MoSpent checks if the budget is more than spent in that month, if so then print \"safe zone\", else (MoSpent > Mobudget) then print \"Danger zone\"\n" ]

[ 0, 0 ]

[]

[]

[ "function", "loops", "python" ]

[ "You can use enumerate() + max() to get row with highest value. For example:\nimport csv\n\nwith open(\"CSV_load.csv\", \"r\") as csvfile:\n readCSV = csv.reader(csvfile, delimiter=\",\")\n line, row_with_highest_temp = max(\n enumerate(readCSV, 1), key=lambda row: int(row[1][2])\n )\n print(\"Highest Temp is\", row_with_highest_temp[2], \"on line\", line)\n\n" ]

[ 0 ]

[]

[]

[ "csv", "python" ]

[ "For a big applications it's better to work on virtual machine not on ready services\n" ]

[ 0 ]

[]

[]

[ "azure", "azure_devops", "flask", "python" ]

[ "You can update the example yourself.\nRemove the lines that tries to open the camera, and update this line which tries to capture image from the camera video with your image instead\nhttps://github.com/tensorflow/examples/blob/master/lite/examples/image_segmentation/raspberry_pi/segment.py#L76\n" ]

[ 0 ]

[]

[]

[ "google_colaboratory", "python", "tensorflow_lite" ]

[ "Turned off GPU acceleration in the Terminal of VS Code. That has seemed to resolve the matter; No longer cursor trails.\nSettings > Type 'Render' > Go to\nTerminal › Integrated: Gpu Acceleration.\nSetting controls whether the terminal will leverage the GPU to do its rendering.\nSwitch 'off' in dropdown menu\n" ]

[ 0 ]

[]

[]

[ "python", "python_3.x", "terminal", "visual_studio_code" ]

[ "I had the same question when evaluating a nullable=False column with mypy. One of my teammates found the answer in the SqlAlchemy docs:\nhttps://docs.sqlalchemy.org/en/14/orm/extensions/mypy.html#introspection-of-columns-based-on-typeengine\n\nThe types are by default always considered to be Optional, even for\nthe primary key and non-nullable column. The reason is because while\nthe database columns “id” and “name” can’t be NULL, the Python\nattributes id and name most certainly can be None without an explicit\nconstructor:\n\nThere are also mitigations they list in that article with declaring the columns to be mapped types explicitly.\n" ]

[ 1 ]

[]

[]

[ "mypy", "python", "sqlalchemy" ]

[ "cb_kwargs is a dictionary that will be passed the request’s callback.\nbody is the request's body.\nimport json\n\nyield scrapy.Request(url=self.url, body=json.dumps(params), callback=self.parse, headers=self.headers)\n\nEDIT:\nI misunderstood your question. This is what you want:\nimport urllib.parse\nurl_params = '?' + urllib.parse.urlencode(params)\n\nyield scrapy.Request(url=self.url+urlparams, callback=self.parse, headers=self.headers)\n\nWhere url is something like www.url.com/products/search.\n" ]

[ 1 ]

[]

[]

[ "python", "python_requests", "scrapy", "web_scraping" ]

[ "For other people: The problem might be your role id. Try grabbing the role id from the roles page in server settings instead of from a message. What the page looks like in the unlikely case you don't know\nRole ids are usually 18 digits long but newly created roles may be 19.\nThe error in this case was that he lacked intents in client = discord.Client()\nintents = discord.Intents().all()\nclient = commands.Bot(command_prefix=',', intents=intents)\n\nIntents must both be enabled in your code and in the developer portal.\n" ]

[ 0 ]

[]

[]

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

[ "You need to add a recursive element to your code. I would also suggest thinking in terms of 2D (and eventually 3D) matricies instead of 1D arrays and explore numpy's abilities in depth:\nimport numpy as np\n\ndef menger(matrix, size):\n quotient, remainder = divmod(size, 3)\n\n if remainder == 0:\n for x in np.arange(0, size, quotient):\n for y in np.arange(0, size, quotient):\n view = matrix[x:x + quotient, y:y + quotient]\n\n if (x // quotient) % 3 == 1 and (y // quotient) % 3 == 1:\n view *= 0\n\n menger(view, quotient)\n\nif __name__ == \"__main__\":\n import matplotlib.pyplot as plt\n\n SIZE = 27\n\n matrix = np.ones((SIZE, SIZE))\n\n menger(matrix, SIZE)\n\n plt.matshow(matrix)\n plt.colorbar()\n plt.show()\n\n\n" ]

[ 1 ]

[]

[]

[ "fractals", "python", "recursion" ]

[ "Try to pandas.Series.str.strip before the pandas.Series.map :\nq20[\"personality_type\"]= q20[\"personality_type\"].str.strip().map(mapping)\n\n# Output :\nprint(q20)\n\n personality_type\n0 8\n1 6\n2 7\n3 1\n4 17\n5 11\n\n", "The key NaN in your mapping dictionary and NaN value in your data frame do not match. I have modified the one in your dictionary.\ndf.apply(lambda x: x.fillna('NAN').map(mapping))\n\n personality_type\n0 8\n1 6\n2 7\n3 1\n4 17\n5 11\n\n" ]

[ 1, 1 ]

[]

[]

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

[ "You can use np.random.choice with a list of [0,1], or use np.random.radint with a range of 0,2\nIn [1]: import numpy as np \n\nIn [2]: np.random.choice([0,1]) \nOut[2]: 0\n\nIn [5]: np.random.choice([0,1]) \nOut[5]: 1\n\nIn [8]: np.random.randint(2) \nOut[8]: 0\n\nIn [9]: np.random.randint(2) \nOut[9]: 1\n\n\nYou can also use the random module for the equivalent of these functions\n", "You can use numpy.random.random_integers\nrandom_int= np.random.random_integers(0,1)\nprint (random_int)\n\n", "You can use np.random.randint(low, high=None, size=None). \n>>> np.random.randint(0,2,10)\narray([0, 1, 1, 0, 1, 1, 0, 0, 1, 0])\n>>> np.random.randint(2)\n0\n>>> np.random.randint(2)\n1\n\nFore more details, you can refer to https://docs.scipy.org/doc/numpy/reference/generated/numpy.random.randint.html\n", "You should consider using np.random.randint() This function takes a range as an input. \nFor example,\n>>> np.random.randint(2)\n\nThis will give you an output of either 0 or 1\n", "To add to the other answers, it is possible to simply do\np_True = 0.5 # 50% probability that you get 1\nyour_bool = p_True >= np.random.rand() # >= because rand returns a float between 0 and 1, excluding 1.\n\nYou can have a biased sample by changing p_true.\n", "Is there a reason to specifically use np.random.rand? This function outputs a float as noted in the question and previous answers, and you would need thresholding to obtain an int.\nscipy.stats.bernoulli(p) directly outputs a 1 with probability p and 0 with probability 1-p.\n", "You can use np.random.choice with a list of [0,1] and a size to get a random choice matrix like this:\nIn [1]: import numpy as np\n\nIn [2]: np.random.choice([0,1], size=(3,4))\nOut[2]: array([[1, 0, 0, 0],\n [0, 1, 1, 0],\n [1, 1, 1, 1]])\n\n" ]

[ 8, 1, 1, 1, 1, 0, 0 ]

[]

[]

[ "numpy", "python" ]

[ "I think you could create a df where you have the timestamp as your index.\nYou can then use pd.date_range to create a full datetime range for every hour from min to max.\nYou can then run the Index.difference to efficiently find any timestamps that are missing from your original dataframe --> this will be the index of a new df with missing values.\nThen just fill in missing columns with NaN\nimport pandas as pd\nimport numpy as np\n\n# name of your datetime column\ndatetime_col = 'datetime'\n \n# mock up some data\ndata = {\n datetime_col: [\n '2021-01-18 00:00:00', '2021-01-18 01:00:00',\n '2021-01-18 03:00:00', '2021-01-18 06:00:00'],\n 'extra_col1': ['b', 'c', 'd', 'e'],\n 'extra_col2': ['g', 'h', 'i', 'j'],\n}\n\ndf = pd.DataFrame(data)\n \n# Setting the Date values as index\ndf = df.set_index(datetime_col)\n \n# to_datetime() method converts string\n# format to a DateTime object\ndf.index = pd.to_datetime(df.index)\n \n# create df of missing dates from the sequence\n# starting from min dateitme, to max, with hourly intervals\nnew_df = pd.DataFrame(\n pd.date_range(\n start=df.index.min(), \n end=df.index.max(),\n freq='H'\n ).difference(df.index)\n)\n\n# you will need to add these columns to your df\nmissing_columns = [col for col in df.columns if col!=datetime_col]\n\n# add null data\nnew_df[missing_columns] = np.nan\n\n# fix column names\nnew_df.columns = [datetime_col] + missing_columns\n\nnew_df\n\n", "I am not sure I follow exactly what you need, i.e what is the frequency of the datetimes you are trying to complete, but assuming it is hourly, then you could try something along those lines:\n\nUse the pd.date_range(start_date, end_date, freq='H') function from pandas to create a pandas DataFrame with all the missing hourly times you need (one column and same name than the first column in your initial DataFrame).\nSee documentation here: https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.date_range.html\nUse the pd.merge(initial_df, complete_df, how='outer') function to perform an outer merge between the two dataframes. If I am not mistaken all columns of cases where you had no date in the initial DataFrame should be filled with NAs by default.\n\nReproducible example below using Matt's example:\nimport pandas as pd\nimport numpy as np\n \n# mock up some data\ndata = {\n 'date': [\n '2021-01-18 00:00:00', '2021-01-18 01:00:00',\n '2021-01-18 03:00:00', '2021-01-18 06:00:00'],\n 'extra_col1': ['b', 'c', 'd', 'e'],\n 'extra_col2': ['g', 'h', 'i', 'j'],\n}\n\ndf = pd.DataFrame(data)\n \n# Use to_datetime() method to convert string\n# format to a DateTime object\ndf['date'] = pd.to_datetime(df['date'])\n \n# Create df with missing dates from the sequence\n# starting from min dateitme, to max, with hourly intervals\nnew_df = pd.DataFrame(\n {'date': pd.date_range(\n start=df['date'].min(), \n end=df['date'].max(),\n freq='H'\n )}\n)\n\n# Use the merge function to perform an outer merge\n# and reorder the date column\nresult_df = pd.merge(df,new_df,how='outer')\nresult_df.sort_values(by='date',ascending=True, inplace=True)\n\n" ]

[ 2, 1 ]

[]

[]

[ "dataframe", "datetime", "pandas", "python", "python_3.x" ]

[ "You can find your answer here : Pydantic: Detect if a field value is missing or given as null\[email protected](\"/test\")\ndef test(entity: TestEntity):\n return entity.dict(exclude_unset=True)\n\n" ]

[ 0 ]

[]

[]

[ "fastapi", "pydantic", "python" ]

[ "As it happens, the Process call never actually does anything useful; target=multiprocessor(tasker,values) is running multiprocessor in the main process, then passing its return value (None, since it has no explicit return) as the target for the Process.\nSo yes, definitionally, this is completely pointless; you make the Pool in the parent process, run it to completion, then create a no-op Process, launch it, it does nothing, then when the useless Process exits, the main process continues. Unless there is some benefit to creating such a no-op process, the code would do the same thing if the guarded block were just:\nif __name__ == '__main__':\n values = foobar\n multiprocessor(tasker, values)\n\nIf the Process had been created correctly, with:\np = multiprocessing.Process(target=multiprocessor, args=(tasker, values))\n\nand the code was more complex, there might be some benefit to this, if the Process needed to be killable (you could kill it easily for whatever reason, e.g. because some deadline had passed), or it would allocate huge amounts of memory that must be completely returned to the OS (not merely released to the user-mode free pool for reuse), or you were trying to avoid any mutations of the main process's globals (if the Process's target mutated them, the changes would only be seen in that child process and any processes forked after the change, the parent would not see them changed).\nAs written, none of these conditions seem to apply (aside from maybe memory growth issues, especially due to the use of partial, which has issues when used as the mapper function with Pool's various map-like methods), but without knowing the contents of tasker (more specifically, what it returns, which Pool.map will collect and dispose of, consuming memory that isn't strictly needed only to free it in bulk at the end), I can't be sure.\n\nAn aside:\nI'll note your code as written makes no sense:\ndef multiprocessor (func, vals):\n chunks = np.array_split(vals, os.cpu_count())\n with multiprocessing.Pool() as pool:\n pool.map(partial(func,vals), chunksize=chunks)\n\ndoesn't provide an iterable to pool.map, and passed chunks (a list of numpy sub-arrays) as the chunksize, which should be an int.\nThe additional comments below assume it was actually implemented as:\ndef multiprocessor (func, vals):\n chunks = np.array_split(vals, os.cpu_count())\n with multiprocessing.Pool() as pool:\n pool.map(func, chunks, chunksize=1)\n\nor:\ndef multiprocessor (func, vals):\n chunk_size = -(-len(vals) // os.cpu_count()) # Trick to get ceiling division out of floor division operator\n with multiprocessing.Pool() as pool:\n pool.map(func, vals, chunksize=chunk_size)\n\nHaving said that, the possible memory issue from Pool.map storing all the results when they're clearly discarded can be ameliorated by using Pool.imap_unordered instead, and just forcing the resulting iterator to run to completion efficiently. For example, you could replace pool.map(func, chunks, chunksize=1) with consume(pool.imap_unordered(func, chunks)) and pool.map(func, vals, chunksize=chunk_size) with consume(pool.imap_unordered(func, vals, chunksize=chunk_size)) (where consume is the itertools recipe of the same name).\nIn both cases, rather than allocating a list for all the results, storing each result in it as the workers complete tasks (allocating more and more stuff you don't need), imap_unordered produces each result as it's returned, and consume immediately grabs each result and throws it away (memory must be allocated for each result, but it's immediately released, so the peak memory consumption for the process, and therefore the size the heap grows to, is kept minimal).\n" ]

[ 1 ]

[]

[]

[ "multiprocessing", "python" ]

[ "What you want can be computed with the builtin pow function as follows:\nans = pow(954, 893, mod = 1457)\n\nThis result can also be computed \"naively\" using ans = (954 ** 893) % 1457. However, this forces python to compute the value 954**893 (i.e. 954893), a 2660-digit number.\nFor these numbers, Python has no issues computing the solution, but the second approach becomes much worse for larger exponents. For example, the computation 954893000 mod 1457 takes approximately 0.1 ms the first way and 1 whole second the second way (on my device).\n" ]

[ 0 ]

[]

[]

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

[ "So, as far as I understand, the problem is that when \"temp_df\" is empty you want to add a blank row. You should be able to do that using the .append() method, appending an empty Series().\nif len(temp_df) == 0:\n temp_df=temp_df.append(pd.Series(), ignore_index=True)\n#Then concat...\n\n", "For your specific question, it works if you check if temp_df is empty or not in each step and make it a DataFrame of NaNs if it is empty.\nAnother note on the implementation is that, concatenating in each iteration will be a very expensive operation. It is much faster if you store the temp_dfs in each iteration in a list and concatenate once after the loop is over.\nlst = [] # <-- empty list to fill later\nfor row in range(3, sheet.max_row + 1): \n a0, b0, r = sheet.cell(row,1).value, sheet.cell(row,2).value, 0.001\n query = \"\"\"\n SELECT a,b,c,d,e FROM smthng\n WHERE q3c_radial_query(a,b,{:f},{:f},{:f}) LIMIT 1\n \"\"\".format(a0,b0,r)\n response = qc.query(sql=query,format='csv')\n temp_df = convert(response,'pandas')\n\n if temp_df.empty:\n temp_df = pd.DataFrame([np.nan])\n lst.append(temp_df)\n \ndf = pd.concat(lst) # <-- concat once\ndf.to_csv('output.csv', index=False)\n\n" ]

[ 1, 1 ]

[]

[]

[ "concatenation", "pandas", "python", "sql" ]

[ "are you sure that it should be only index 4?\ndict_list = [{'A': 0.102, 'B': 0.568, 'C': 0.33}, \n {'A': 0.026, 'B': 0.590, 'C': 0.382}, \n {'A': 0.005, 'B': 0.857, 'C': 0.137}, \n {'A': 0.0, 'B': 0.962, 'C': 0.036}, \n {'A': 0.0, 'B': 0.991, 'C': 0.008}] \n\nd = {'A': 0.005, 'B': 0.956, 'C': 0.038}\n\nmax_val = max(d.values())\nidxmax = [i for i,j in enumerate(dict_list) if max(j.values()) > max_val]\n\nprint(idxmax) # [3, 4]\n\n", "You can use enumerate for finding index of max value:\norg = [\n {'A': 0.102, 'B': 0.568, 'C': 0.33}, \n {'A': 0.026, 'B': 0.590, 'C': 0.382}, \n {'A': 0.005, 'B': 0.857, 'C': 0.137}, \n {'A': 0.0, 'B': 0.962, 'C': 0.036}, \n {'A': 0.0, 'B': 0.991, 'C': 0.008}\n] \n\ncom = {'A': 0.005, 'B': 0.956, 'C': 0.038}\n\ndef fnd_index(org, com):\n key_max, val_max = max(com.items(), key=lambda x: x[1])\n print('key_max:', key_max)\n print('val_max:', val_max)\n res = []\n for idx, dct in enumerate(org):\n if dct[key_max] > val_max:\n res.append(idx)\n return res\n\n\nres = fnd_index(org, com)\nprint('result:', res)\n\nOutput:\nkey_max: B\nval_max: 0.956\nresult: [3, 4]\n\n" ]

[ 1, 1 ]

[]

[]

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

[ "So if you have an array of shape (n, 3), np.sum((Ccenter - C)**2, axis=1)-R**2 so you could get the coefficients of x**2, y**2, z**2, x, y, z.\na,_,_,_ = np.linalg.lstsq(np.hstack([C**2, C]), np.ones(n), rcond=None)\nCcenter = -a[3:6] / (2*a[0])\n\nA test example\nimport numpy as np\nn = 4000; # a cloud of 4000 points\nx = np.random.randn(n, 3)\n# make them a standard sphere\nx = x / np.sqrt(np.sum(x**2, 1, keepdims=True));\n\n# Placement of the sphere\nr = 7\ncenter = [4,5,6]\nC = r * x + center\n\n# Discover the placement from the points\na,_,_,_ = np.linalg.lstsq(np.hstack([C**2, C]), np.ones(n), rcond=None)\nprint(-a[3:6] / (2*a[0]))\n\n" ]

[ 0 ]

[]

[]

[ "3d", "graph", "linear_algebra", "python", "voxel" ]

[ "Use these to save and read:\n#if you don't want to save the index column in the first place\ndf.to_csv('Frequency.csv', index=False) \n# drop the extra column if any while reading\npd.read_csv(\"Frequency.csv\",index_col=0)\n\nExample :\nimport pandas as pd\n\ndata = {\n \"calories\": [420, 380, 390],\n \"duration\": [50, 40, 45]\n}\ndf1 = pd.DataFrame(data)\n\ndf1.to_csv('calories.csv', index=False)\npd.read_csv(\"calories.csv\",index_col=0)\n\nI've used the combination of these 2 given below because my jupyter notebook adds index on it's own while reading even if I use index=False while saving. So I find the combo of these 2 as a full proof method.\ndf1.to_csv('calories.csv', index=False)\npd.read_csv(\"calories.csv\",index_col=0)\n\n", "It's writing the index into the csv, so then when you load it, it's an unnamed column. You can get around it by writing the csv like this.\ndf.to_csv('Frequency.csv', index=False)\n\n" ]

[ 1, 0 ]

[]

[]

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

[ "Your graphics card does not support CUDA 9.0.\nSince I've seen a lot of questions that refer to issues like this I'm writing a broad answer on how to check if your system is compatible with CUDA, specifically targeted at using PyTorch with CUDA support. Various circumstance-dependent options for resolving issues are described in the last section of this answer.\n\nThe system requirements to use PyTorch with CUDA are as follows:\n\nYour graphics card must support the required version of CUDA\nYour graphics card driver must support the required version of CUDA\nThe PyTorch binaries must be built with support for the compute capability of your graphics card\n\nNote: If you install pre-built binaries (using either pip or conda) then you do not need to install the CUDA toolkit or runtime on your system before installing PyTorch with CUDA support. This is because PyTorch, unless compiled from source, is always delivered with a copy of the CUDA library.\n\n1. How to check if your GPU/graphics card supports a particular CUDA version\nFirst, identify the model of your graphics card.\nBefore moving forward ensure that you've got an NVIDIA graphics card. AMD and Intel graphics cards do not support CUDA.\nNVIDIA doesn't do a great job of providing CUDA compatibility information in a single location. The best resource is probably this section on the CUDA Wikipedia page. To determine which versions of CUDA are supported\n\nLocate your graphics card model in the big table and take note of the compute capability version. For example, the GeForce 820M compute capability is 2.1.\nIn the bullet list preceding the table check to see if the required CUDA version is supported by the compute capability of your graphics card. For example, CUDA 9.2 is not supported for compute compatibility 2.1.\n\nIf your card doesn't support the required CUDA version then see the options in section 4 of this answer.\nNote: Compute capability refers to the computational features supported by your graphics card. Newer versions of the CUDA library rely on newer hardware features, which is why we need to determine the compute capability in order to determine the supported versions of CUDA.\n\n2. How to check if your GPU/graphics driver supports a particular CUDA version\nThe graphics driver is the software that allows your operating system to communicate with your graphics card. Since CUDA relies on low-level communication with the graphics card you need to have an up-to-date driver in order use the latest versions of CUDA.\nFirst, make sure you have an NVIDIA graphics driver installed on your system. You can acquire the newest driver for your system from NVIDIA's website.\nIf you've installed the latest driver version then your graphics driver probably supports every CUDA version compatible with your graphics card (see section 1). To verify, you can check Table 3 in the CUDA release notes. In rare cases I've heard of the latest recommended graphics drivers not supporting the latest CUDA releases. You should be able to get around this by installing the CUDA toolkit for the required CUDA version and selecting the option to install compatible drivers, though this usually isn't required.\nIf you can't, or don't want to upgrade the graphics driver then you can check to see if your current driver supports the specific CUDA version as follows:\nOn Windows\n\nDetermine your current graphics driver version (Source https://www.nvidia.com/en-gb/drivers/drivers-faq/)\n\n\nRight-click on your desktop and select NVIDIA Control Panel. From the\nNVIDIA Control Panel menu, select Help > System Information. The\ndriver version is listed at the top of the Details window. For more\nadvanced users, you can also get the driver version number from the\nWindows Device Manager. Right-click on your graphics device under\ndisplay adapters and then select Properties. Select the Driver tab and\nread the Driver version. The last 5 digits are the NVIDIA driver\nversion number.\n\n\nVisit the CUDA release notes and scroll down to Table 3. Use this table to verify your graphics driver is new enough to support the required version of CUDA.\n\nOn Linux/OS X\nRun the following command in a terminal window\nnvidia-smi\n\nThis should result in something like the following\nSat Apr 4 15:31:57 2020 \n+-----------------------------------------------------------------------------+\n| NVIDIA-SMI 435.21 Driver Version: 435.21 CUDA Version: 10.1 |\n|-------------------------------+----------------------+----------------------+\n| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |\n| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |\n|===============================+======================+======================|\n| 0 GeForce RTX 206... Off | 00000000:01:00.0 On | N/A |\n| 0% 35C P8 16W / 175W | 502MiB / 7974MiB | 1% Default |\n+-------------------------------+----------------------+----------------------+\n \n+-----------------------------------------------------------------------------+\n| Processes: GPU Memory |\n| GPU PID Type Process name Usage |\n|=============================================================================|\n| 0 1138 G /usr/lib/xorg/Xorg 300MiB |\n| 0 2550 G /usr/bin/compiz 189MiB |\n| 0 5735 G /usr/lib/firefox/firefox 5MiB |\n| 0 7073 G /usr/lib/firefox/firefox 5MiB |\n+-----------------------------------------------------------------------------+\n\nDriver Version: ###.## is your graphic driver version. In the example above the driver version is 435.21.\nCUDA Version: ##.# is the latest version of CUDA supported by your graphics driver. In the example above the graphics driver supports CUDA 10.1 as well as all compatible CUDA versions before 10.1.\nNote: The CUDA Version displayed in this table does not indicate that the CUDA toolkit or runtime are actually installed on your system. This just indicates the latest version of CUDA your graphics driver is compatible with.\nTo be extra sure that your driver supports the desired CUDA version you can visit Table 3 on the CUDA release notes page.\n\n3. How to check if a particular version of PyTorch is compatible with your GPU/graphics card compute capability\nEven if your graphics card supports the required version of CUDA then it's possible that the pre-compiled PyTorch binaries were not compiled with support for your compute capability. For example, in PyTorch 0.3.1 support for compute capability <= 5.0 was dropped.\nFirst, verify that your graphics card and driver both support the required CUDA version (see Sections 1 and 2 above), the information in this section assumes that this is the case.\nThe easiest way to check if PyTorch supports your compute capability is to install the desired version of PyTorch with CUDA support and run the following from a python interpreter\n>>> import torch\n>>> torch.zeros(1).cuda()\n\nIf you get an error message that reads\nFound GPU0 XXXXX which is of cuda capability #.#.\nPyTorch no longer supports this GPU because it is too old.\n\nthen that means PyTorch was not compiled with support for your compute capability. If this runs without issue then you should be good to go.\nUpdate If you're installing an old version of PyTorch on a system with a newer GPU then it's possible that the old PyTorch release wasn't compiled with support for your compute capability. Assuming your GPU supports the version of CUDA used by PyTorch, then you should be able to rebuild PyTorch from source with the desired CUDA version or upgrade to a more recent version of PyTorch that was compiled with support for the newer compute capabilities.\n\n4. Conclusion\nIf your graphics card and driver support the required version of CUDA (section 1 and 2) but the PyTorch binaries don't support your compute capability (section 3) then your options are\n\nCompile PyTorch from source with support for your compute capability (see here)\nInstall PyTorch without CUDA support (CPU-only)\nInstall an older version of the PyTorch binaries that support your compute capability (not recommended as PyTorch 0.3.1 is very outdated at this point). AFAIK compute capability older than 3.X has never been supported in the pre-built binaries\nUpgrade your graphics card\n\nIf your graphics card doesn't support the required version of CUDA (section 1) then your options are\n\nInstall PyTorch without CUDA support (CPU-only)\nInstall an older version of PyTorch that supports a CUDA version supported by your graphics card (still may require compiling from source if the binaries don't support your compute capability)\nUpgrade your graphics card\n\n", "To solve this issue, the following method answered for me:\n1- First you have to update Anaconda.\n2- In your notebook, select the following based on your system.\nhttps://pytorch.org/\n\n\nexample for Windows:(This may take some time. Be patient)\nconda install pytorch torchvision torchaudio cudatoolkit=10.2 -c pytorch\n\n3- Find and install the latest graphics card for your system through the following site:\nhttps://www.nvidia.com/Download/index.aspx\n\n\n4- Supported CUDA level of GPU and card. see this\n", "The same error can appear when the version of your Pytorch supports different CUDA. For example, my Pytorch version was with CUDA 8.0 support, but I had CUDA 9.0 installed. To fix that I had to upgrade my Pytorch to cu90 like this:\npip install torch_nightly -f https://download.pytorch.org/whl/nightly/cu90/torch_nightly.html\n\nReference: here\n", "I want to share also my experience, especially in the WSL2 environment. See my post here.\nDespite I had installed the correct and latest drivers following the guide provided by NVidia here, my WSL was not able to detect any GPU both in PyTorch and in the whole environment.\nMy GPU is Nvidia GeForce RTX 1650 Ti, which is not listed in the Wiki link above but is actually shown in the NVidia page.\nDowngrading to an older driver version found at this NVidia link, namely Driver Version: 472.39 helped me out. Now PyTorch can correctly detect the driver, as well as I can run containers that require GPU access since it is correctly found and used.\nHoping this will help someone in my situation.\n", "Just faced the same with my GPU (last available driver installed), none of above helped, searching for hours over Google also no luck. Here's what worked out for me:\n\nDelete all environments that were created in Anaconda. Uninstall Anaconda and delete all related folders in \"user\" folder\n\nInstall Anaconda\n\nAdd conda-forge to channels https://conda-forge.org/docs/user/introduction.html\n\nRun through installation Guide from NVIDIA https://docs.nvidia.com/cuda/cuda-installation-guide-microsoft-windows/index.html\n\nChoose proper configuration and run conda installation https://pytorch.org/get-started/locally/\nIF installation failed with well-known failed with initial frozen solve. Retrying with flexible solve. go with pip3 install instead of conda\n\nEnjoy your GPU in Jupyter Notebook:\nimport torch\ntorch.cuda.is_available()\nTrue\n\n\n", "ok here's my experience\nmy system is ubuntu 20.4, gpu - nvidi gtx 1060\nwhen i go and change run the 'Nvidia X Server Settings' application i found under the PRIME Profiles\nNvidia On-Demand or Inter(power saving mode) is selected\ngiving torch.cuda.is_available() to False\ni changed the GPU Mode to 'NVIDIA(Performance Mode) then i got True\nNVIDIA X Server Setting-GUI\n", "Step 1.) Check your cuda and GPU DRIVER version using\n nvidia-smi .\nThis will be helpful in downloading the correct version of pytorch with this hardware\nStep 2.) Check if you have installed gpu version of pytorch by using\nconda list pytorch\nIf you get \"cpu_\" version of pytorch then you need to uninstall pytorch and reinstall it by below command\n ```` conda uninstall pytorch \n conda install pytorch torchvision cudatoolkit=11.3 -c pytorch -c conda-forge ````\n\n", "I had a similar issue with a GPU with MIG mode. I had to disable the MIG mode:\n>> nvidia-smi -mig 0\n\nAs pointed out by ptrblck, it was enable by default but I didn't create any MIG devices.\nYou can try to create them (user guide).\n" ]

[ 125, 5, 2, 1, 1, 0, 0, 0 ]

[]

[]

[ "python", "pytorch" ]

[ "Maybe just use doit:\nIn [3]: v, w = symbols('v, w')\n\nIn [4]: diff(re(w), v)\nOut[4]: 0\n\nIn [5]: Derivative(re(w), v)\nOut[5]: \nd \n──(re(w))\ndv \n\nIn [6]: Derivative(re(w), v).doit()\nOut[6]: 0\n\n", "The doit is good since, otherwise, an unevaluated Derivative(x, y) will not evaluate to 0. But...if you want to do as requested, you can use a replace command to look for a derivative whose argument is re or im like this, using the args and func attributes of the expressions:\n>>> eq = Derivative(re(x),y)\n>>> eq.replace(\n... lambda x: isinstance(x, Derivative) and isinstance(x.args[0], (re,im)),\n... lambda x: x.args[0].func(x.func(x.args[0].args[0], *x.args[1:])))\nre(Derivative(x, y))\n\n" ]

[ 0, 0 ]

[]

[]

[ "python", "sympy" ]

[ "If the PYTHONSTARTUP environment variable exists and is the name of a valid Python file, then that file will be executed when any new Python shell starts up.\nSo whether you want to do this in a Docker container or on your local machine, it works the same way. Define PYTHONSTARTUP (in .bashrc, for instance) and then write a startup file.\n# .bashrc\nexport PYTHONSTARTUP=~/.python_startup\n\n \n# .python_startup\nfrom hashtable_nicolerg.hashtable import HashTable\n\n", "Thanks to Silvio Mayolo for the answer! Here is a Docker alternative to exporting an environment variable from ~/.bashrc:\n# Dockerfile\nFROM python:3\nRUN pip install --no-cache-dir hashtable-nicolerg\n\nWORKDIR /\nCOPY .python_startup .\nENV PYTHONSTARTUP=./.python_startup\n\nThen after building the image with docker build -t python-hashtable ., I get the desired behavior:\n$ docker run -it python-hashtable\nPython 3.11.0 (main, Nov 15 2022, 19:58:01) [GCC 10.2.1 20210110] on linux\nType \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n>>> hash_table = HashTable(capacity=100)\n\n" ]

[ 3, 1 ]

[]

[]

[ "docker", "python", "python_import" ]

[ "Your code has a few quirks that you may want to tweak:\n\nThere is a break statement inside the try, but no for loop.\nBoth if and else print the same text. You can't know which one printed the output.\n\nJust by changing the captured exception type from NameError to SyntaxError should be enough:\nvar = input(\"Enter a list of Number to Find its Minimum, Maximum, Average and Total:\")\ntry:\n a = eval(var)\n b = min(a)\n c = max(a)\n d = sum(a)/len(a)\n e = sum(a)\n print('min -', b, 'max -', c, 'avg -', d, 'total -', e)\nexcept SyntaxError:\n print(\"Please enter a valid input\")\n\nNonetheless, if you want to print different messages for [1,2,3ab,4] and [@,+,_] you should know that str.isalpha() only returns True if all characters are letters, which is not true just by adding commas or brackets. I would suggest using regular expressions (regex):\nimport re\n\nvar = input(\"Enter a list of Number to Find its Minimum, Maximum, Average and Total:\")\ntry:\n a = eval(var)\n b = min(a)\n c = max(a)\n d = sum(a)/len(a)\n e = sum(a)\n print('min -', b, 'max -', c, 'avg -', d, 'total -', e)\nexcept SyntaxError:\n if re.match(r'[a-zA-Z]', var):\n print(\"Text contains letters. Please enter a valid input\")\n elif re.match(r'[\\@\\+\\_]', var):\n print(\"Text contains special characters. Please enter a valid input\")\n else:\n print(\"Please enter a valid input\")\n\nYou can play with regex on regexr.com.\nIf you would rather not use the re library, you can do it iterating over the string:\nvar = input(\"Enter a list of Number to Find its Minimum, Maximum, Average and Total:\")\ntry:\n a = eval(var)\n b = min(a)\n c = max(a)\n d = sum(a)/len(a)\n e = sum(a)\n print('min -', b, 'max -', c, 'avg -', d, 'total -', e)\nexcept SyntaxError:\n for l in var:\n if l.isnumeric() or l in [',', '[', ']']:\n continue\n if l.isalpha():\n print(\"Text contains letters. Please enter a valid input\")\n elif l in ['@', '+', '_']:\n print(\"Text contains special characters. Please enter a valid input\")\n else:\n print(\"Please enter a valid input\")\n break\n\n" ]

[ 0 ]

[]

[]

[ "python", "syntax_error" ]

[ "Part 1: Anchor times\nA simple way is to find the times of interest (lowest point) in each frame, then plot each series with x=t - t_peak instead of x=t. Two ways come to mind to find the desired anchor points:\n\nSimply using the global minimum (in your plots, that would work fine), or\nUsing the most prominent local minimum, either from first principles, or using scipy's find_peaks().\n\nBut first of all, let us attempt to build a reproducible example:\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport pandas as pd\n\ndef make_sample(t_peak, tmax_approx=17.5, n=100):\n # uneven times\n t = np.random.uniform(0, 2*tmax_approx/n, n).cumsum()\n y = -1 / (0.1 + 2 * np.abs(t - t_peak))\n trend = 4 * np.random.uniform(-1, 1) / n\n level = np.random.uniform(10, 12)\n y += np.random.normal(trend, 1/n, n).cumsum() + level\n return pd.DataFrame({'t': t, 'y': y})\n\npoi = [2, 2.48, 2.6, 2.1]\n\nnp.random.seed(0)\nframes = [make_sample(t_peak) for t_peak in poi]\n\nplt.rcParams['figure.figsize'] = (6,2)\nfig, ax = plt.subplots()\nfor df in frames:\n ax.plot(*df.values.T)\n\n\nIn this case, we made the problem maximally inconvenient by giving each time series its own, independent, unevenly distributed time sampling.\nNow, retrieving the \"maximum drop\" by global minimum:\npeaks = [df.loc[df['y'].idxmin(), 't'] for df in frames]\n>>> peaks\n[2.0209774600118764, 2.4932468358014157, 2.5835972003585472, 2.12438578790615]\n\nfig, ax = plt.subplots()\nfor t_peak, df in zip(peaks, frames):\n ax.plot(df['t'] - t_peak, df['y'])\n\n\nBut imagine a case where the global minimum is not suitable. For example, add a large sine wave to each series:\nframes = [df.assign(y=df['y'] + 5 * np.sin(df['t'])) for df in frames]\n\n# just plotting the first series\ndf = frames[0]\nplt.plot(*df.values.T)\n\n\nClearly, there are several local minima, and the one we want (\"sharpest drop\") is not the global one.\nA simple way to find the desired sharpest drop time is by looking at the difference from each point to its two neighbors:\ndef arg_steepest_min(v):\n # simply find the minimum that is most separated from the surrounding points\n diff = np.diff(v)\n i = np.argmin(diff[:-1] - diff[1:]) + 1\n return i\n\npeaks = [df['t'].iloc[arg_steepest_min(df['y'])] for df in frames]\n>>> peaks\n[2.0209774600118764, 2.4932468358014157, 2.5835972003585472, 2.12438578790615]\n\n# just plotting the first curve and the peak found\ndf = frames[0]\nplt.plot(*df.values.T)\nplt.plot(*df.iloc[arg_steepest_min(df['y'])].T, 'x')\n\n\nThere are more complex cases where you want to bring the full power of find_peaks(). Here is an example that uses the most prominent minimum, using a certain number of samples for neighborhood:\nfrom scipy.signal import find_peaks, peak_prominences\n\ndef arg_most_prominent_min(v, prominence=1, wlen=10):\n peaks, details = find_peaks(-v, prominence=prominence, wlen=wlen)\n i = peaks[np.argmax(details['prominences'])]\n return i\n\npeaks = [df['t'].iloc[arg_most_prominent_min(df['y'])] for df in frames]\n>>> peaks\n[2.0209774600118764, 2.4932468358014157, 2.5835972003585472, 2.12438578790615]\n\nIn this case, the peaks found by both methods are the same. Aligning the curves gives:\nfig, ax = plt.subplots()\nfor t_peak, df in zip(peaks, frames):\n ax.plot(df['t'] - t_peak, df['y'])\n\n\nPart 2: aligning the time series for numeric operations\nHaving found the anchor times and plotted the time series by shifting the x-axis accordingly, suppose now that we want to align all the time series, for example to somehow compare them to one another (e.g.: differences, correlation, etc.). In this example we made up, the time samples are not equidistant and all series have their own sampling.\nWe can use resample() to achieve our goal. Let us convert the frames into actual time series, transforming the column t (supposed in seconds) into a DateTimeIndex, after shifting the time using the previously found t_peak and using an arbitrary \"0\" date:\nframes = [\n pd.Series(\n df['y'].values,\n index=pd.Timestamp(0) + (df['t'] - t_peak) * pd.Timedelta(1, 's')\n ) for t_peak, df in zip(peaks, frames)]\n>>> frames[0]\nt\n1969-12-31 23:59:58.171107267 11.244308\n1969-12-31 23:59:58.421423545 12.387291\n1969-12-31 23:59:58.632390727 13.268186\n1969-12-31 23:59:58.823099841 13.942224\n1969-12-31 23:59:58.971379021 14.359900\n ... \n1970-01-01 00:00:14.022717327 10.422229\n1970-01-01 00:00:14.227996854 9.504693\n1970-01-01 00:00:14.235034496 9.489011\n1970-01-01 00:00:14.525163506 8.388377\n1970-01-01 00:00:14.526806922 8.383366\nLength: 100, dtype: float64\n\nAt this point, the sampling is still uneven, so we use resample to get a fixed frequency. One strategy is to oversample and interpolate:\nframes = [df.resample('100ms').mean().interpolate() for df in frames]\n\nfor df in frames:\n df.plot()\n\n\nAt this point, we can compare the Series. Here are the pairwise differences and correlations:\nfig, axes = plt.subplots(nrows=len(frames), ncols=len(frames), figsize=(10, 5))\nfor axrow, a in zip(axes, frames):\n for ax, b in zip(axrow, frames):\n (b-a).plot(ax=ax)\n ax.set_title(fr'$\\rho = {b.corr(a):.3f}$')\n ax.get_xaxis().set_visible(False)\n ax.get_yaxis().set_visible(False)\nplt.tight_layout()\n\n\n" ]

[ 2 ]

[]

[]

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

[ "According to the documentation:\n\nA binomial discrete random variable.\nAs an instance of the rv_discrete class, binom object inherits from it\na collection of generic methods (see below for the full list), and\ncompletes them with details specific for this particular distribution.\n\nSome of these methods are pmf(k, n, p, loc=0), median(n, p, loc=0), and std(n, p, loc=0).\n\nAlternatively, the distribution object can be called (as a function) to fix the shape and location. This returns a “frozen” RV object holding the given parameters fixed.\n\nSo that\nfrom scipy.stats import binom\n\nn,p = 5, 0.4\nrv = binom(n, p)\nrv.rvs(size=1000)\n\nbinom.rvs(n, p, size=1000)\n\ndo the same thing, because you froze the parameters at n,p when you called the constructor function binom.\n" ]

[ 0 ]

[]

[]

[ "probability_distribution", "python", "scipy", "scipy.stats", "statistics" ]

[ "This is a bug in the library itself. Everything below is done in pytube 11.01.\nIn the captions.py file on line 76 replace:\nfor i, child in enumerate(list(root)):\n\nto:\nfor i, child in enumerate(list(root.findall('body/p'))):\n\nThen on line 83, replace:\nduration = float(child.attrib[\"dur\"])\n\nto:\nduration = float(child.attrib[\"d\"])\n\nThen on line 86, replace:\nstart = float(child.attrib[\"start\"])\n\nto:\nstart = float(child.attrib[\"t\"])\n\nIf only the number of lines and time will be displayed but no subtitle text, replace line 77:\ntext = child.text or \"\"\n\nto:\ntext = ''.join(child.itertext()).strip()\nif not text:\n continue\n\nIt worked for me, python 3.9, pytube 11.01. Good luck!\n", "I did some work on the source code of the file captions.py.\nJust replace the entire code of this file with this code:\nimport math\nimport os\nimport time\nimport xml.etree.ElementTree as ElementTree\nfrom html import unescape\nfrom typing import Dict, Optional\n\nfrom pytube import request\nfrom pytube.helpers import safe_filename, target_directory\n\n\nclass Caption:\n\n def __init__(self, caption_track: Dict):\n\n self.url = caption_track.get(\"baseUrl\")\n\n name_dict = caption_track['name']\n if 'simpleText' in name_dict:\n self.name = name_dict['simpleText']\n else:\n for el in name_dict['runs']:\n if 'text' in el:\n self.name = el['text']\n\n self.code = caption_track[\"vssId\"]\n\n self.code = self.code.strip('.')\n\n @property\n def xml_captions(self) -> str:\n\n return request.get(self.url)\n\n def generate_srt_captions(self) -> str:\n\n return self.xml_caption_to_srt(self.xml_captions)\n\n @staticmethod\n def float_to_srt_time_format(d: float) -> str:\n\n fraction, whole = math.modf(d/1000)\n time_fmt = time.strftime(\"%H:%M:%S,\", time.gmtime(whole))\n ms = f\"{fraction:.3f}\".replace(\"0.\", \"\")\n return time_fmt + ms\n\n def xml_caption_to_srt(self, xml_captions: str) -> str:\n\n segments = []\n root = ElementTree.fromstring(xml_captions)\n count_line = 0\n for i, child in enumerate(list(root.findall('body/p'))):\n \n text = ''.join(child.itertext()).strip()\n if not text:\n continue\n count_line += 1\n caption = unescape(text.replace(\"\\n\", \" \").replace(\" \", \" \"),)\n try:\n duration = float(child.attrib[\"d\"])\n except KeyError:\n duration = 0.0\n start = float(child.attrib[\"t\"])\n end = start + duration\n try:\n end2 = float(root.findall('body/p')[i+2].attrib['t'])\n except:\n end2 = float(root.findall('body/p')[i].attrib['t']) + duration\n sequence_number = i + 1 # convert from 0-indexed to 1.\n line = \"{seq}\\n{start} --> {end}\\n{text}\\n\".format(\n seq=count_line,\n start=self.float_to_srt_time_format(start),\n end=self.float_to_srt_time_format(end2),\n text=caption,\n )\n segments.append(line)\n\n return \"\\n\".join(segments).strip()\n\n def download(\n self,\n title: str,\n srt: bool = True,\n output_path: Optional[str] = None,\n filename_prefix: Optional[str] = None,\n ) -> str:\n\n if title.endswith(\".srt\") or title.endswith(\".xml\"):\n filename = \".\".join(title.split(\".\")[:-1])\n else:\n filename = title\n\n if filename_prefix:\n filename = f\"{safe_filename(filename_prefix)}{filename}\"\n\n filename = safe_filename(filename)\n\n filename += f\" ({self.code})\"\n\n if srt:\n filename += \".srt\"\n else:\n filename += \".xml\"\n\n file_path = os.path.join(target_directory(output_path), filename)\n\n with open(file_path, \"w\", encoding=\"utf-8\") as file_handle:\n if srt:\n file_handle.write(self.generate_srt_captions())\n else:\n file_handle.write(self.xml_captions)\n\n return file_path\n\n def __repr__(self):\n return '<Caption lang=\"{s.name}\" code=\"{s.code}\">'.format(s=self)\n\n", "# Apparently YouTube changed their captions format.\n\n# Here's my version of the function for the function in captions.py\n\nI found this good\n \n\n def xml_caption_to_srt(self, xml_captions: str) -> str:\n \"\"\"Convert xml caption tracks to \"SubRip Subtitle (srt)\".\n \n :param str xml_captions:\n XML formatted caption tracks.\n \"\"\"\n segments = []\n root = ElementTree.fromstring(xml_captions)\n i=0\n for child in list(root.iter(\"body\"))[0]:\n if child.tag == 'p':\n caption = ''\n if len(list(child))==0:\n # instead of 'continue'\n caption = child.text\n for s in list(child):\n if s.tag == 's':\n caption += ' ' + s.text\n caption = unescape(caption.replace(\"\\n\", \" \").replace(\" \", \" \"),)\n try:\n duration = float(child.attrib[\"d\"])/1000.0\n except KeyError:\n duration = 0.0\n start = float(child.attrib[\"t\"])/1000.0\n end = start + duration\n sequence_number = i + 1 # convert from 0-indexed to 1.\n line = \"{seq}\\n{start} --> {end}\\n{text}\\n\".format(\n seq=sequence_number,\n start=self.float_to_srt_time_format(start),\n end=self.float_to_srt_time_format(end),\n text=caption,\n )\n segments.append(line)\n i += 1\n return \"\\n\".join(segments).strip()\n \n \n\n" ]

[ 4, 3, 0 ]

[]

[]

[ "python", "pytube", "xml" ]

[ "I assume you use the discord libary, so this could be a solution to your problem\nimport discord #dependencies\n\nclient = discord.Client() #create a client object\n\[email protected] #bind the function\nasync def on_message(message):\n if message.author.id == 398238482382: #check for id\n await message.channel.send(\"Hey\") #send 'hey' to channel where the message was written\n\nclient.run(yout_token) #starts the bot\n\n" ]

[ 0 ]

[]

[]

[ "bots", "discord", "python" ]

[ "One solution might be creating few tasks which wait for data (job_url, job_id) from asyncio.Queue and perform the get_all_files, downloading, ... tasks independent of each other.\nA pseudocode:\nimport asyncio\nimport aiohttp\n\nqueue = asyncio.Queue()\n\n\nasync def get_all_files_task():\n async with aiohttp.ClientSession() as session:\n while True:\n job_url, job_id = await queue.get()\n\n # get all files using aiohttp:\n # async with session.get(...)\n\n # perform keep file, download file...\n\n await asyncio.sleep(0.5)\n\n # task is done, wait for another\n queue.task_done()\n print(\"Task done.\")\n\n\nasync def main():\n\n tasks = [asyncio.create_task(get_all_files_task()) for _ in range(10)]\n\n async with aiohttp.ClientSession() as session:\n\n # here you will put into a queue job_url, job_id from get_all_jobs\n # async for job in get_all_jobs(job_url=JOBS_ENDPOINT, session=session):\n for i in range(20):\n queue.put_nowait((100, 200))\n\n # wait for queue to be empty\n await queue.join()\n\n # cancel the get_all_files_tasks\n for t in tasks:\n t.cancel()\n try:\n await t\n except asyncio.CancelledError:\n pass\n\n\nasyncio.run(main())\n\n" ]

[ 0 ]

[]

[]

[ "aiohttp", "python", "python_asyncio" ]

[ "\nCoCalc is expensive.\n\nFortunately, we also provide a complete free easy to install open source version of CoCalc, which you can run on any computer that supports Docker. For example, here's how to run it on Google cloud.\n(I have put too many years of my life into making realtiime collaboration work for Jupyter via CoCalc... In any case, the open source code has been battle tested in production for a while now and is working well finally. I hope it can solve your problem...)\n", "You can upload your notebook to Deepnote. It provides a hosted environment, where you and your colleague can connect at the same time and work on the same notebook in real-time (the same way you'd do in Google Docs). \nColab is also good, but writing at the same time will result in conflicts. \n", "Notebook itself doesn't support to collaborate simultaneously, but you can use GitHub to manage your python script and upload it into Colab separately. This way Github can help manage the file history and solve the conflicts.\n", "JupyterLab 3.1.0a7 introduced real time collaboration.\nThere is a screencast showing it in action.\nKey thing to note is the new top-level menu item called Share, to the right of Settings & Help.\n\nYou can click on launch binder here or here to try it now.\n\n\"Once you see the JupyterLab interface, there's a new top-level menu item called \"Share\"; click that, grab and share that URL, and you're done!\"-SOURCE: Step #5 here\n\nThere's a gist here that seems to be updated regularly with how to activate the feature.\nThere's a detailed walk-through here if you want to add the ability into your own repositories that can launch via MyBinder.org. Although if that repo falls behind the gist, you'll probably want to consult the gist for the current best practices once you have the idea from the detailed walk-through.\n\n\nClosely related question with an answer by @krassowski, is here. You may want to look there for some additional details.\n", "While you can use github for this it can get messy, many people clear output cells when committing to git to avoid conflict issues. Which would defeat the object of your review work.\nYou should try Curvenote (which we're building for that reason) it doesn't offer compute as its a collaborative writing tool, works on top of Jupyter via a chrome extenson and gives you real time versioning, commenting and diffs.\n", "\nGoogle Colab has been Deprecated and CoCalc is expensive\n\nNoteable.io is 100% free for all users including storage, compute, RAM. For your purposes, it will be ideal as you will get Google Drive like collaboration (commenting, @mentioning, Annotating data points), versioning, sharing, interactive visualizations, choice of using Python and SQL in the same notebook and a ton of other features.\nHere are good example notebooks on Noteable:\n\nClimate Change: An analysis of Dew Point for the city of Toronto\nHealthcare Sector Employee Attrition Exploratory Data Analysis\nExploratory Data Analysis Using SQL and Python - Online Retailer Orders\n\n" ]

[ 9, 5, 2, 2, 1, 0 ]

[]

[]

[ "collaboration", "jupyter_notebook", "python" ]

[ "Turns out it was a VSCode thing. Opening a new terminal outside of VSCode didn't give the errors. It's due to the Python extension that was installed trying to activate an environment:\n\"python.terminal.activateEnvironment\": true\n\n" ]

[ 1 ]

[]

[]

[ "homebrew", "pyenv", "python", "shell", "zsh" ]

[ "This should be what you are looking for:\ntry:\n num_1 = int(input(\"Enter the first number: \"))\n num_2 = int(input(\"Enter the second number: \"))\nexcept ValueError:\n print(\"invalid\")\n exit()\nTotal = num_1 + num_2\nprint(\"The total is: \", Total)\n\nif num_1 > num_2:\n print(\"num_1 is greater then num_2\")\nelif num_2 > num_1:\n print(\"num_2 is greater then num_1\")\nelse:\n print(\"Equal\")\n\n", "In your first two lines you’re calling int() on a string in the situation you’re describing. This won’t work, and your code will stop running here. What you want is probably something call a try-catch statement.\n" ]

[ 1, 0 ]

[]

[]

[ "if_statement", "python" ]

[ "You have to add shell=True to execute a shell command. check_output is trying to find an executable called: date | grep -o -w '\"+tz+\"'' | wc -w and he cannot find it. (no idea why you removed the essential information from the error message).\nSee the difference between:\n>>> subprocess.check_output('date | grep 1')\nTraceback (most recent call last):\n File \"<stdin>\", line 1, in <module>\n File \"/usr/lib/python3.4/subprocess.py\", line 603, in check_output\n with Popen(*popenargs, stdout=PIPE, **kwargs) as process:\n File \"/usr/lib/python3.4/subprocess.py\", line 848, in __init__\n restore_signals, start_new_session)\n File \"/usr/lib/python3.4/subprocess.py\", line 1446, in _execute_child\n raise child_exception_type(errno_num, err_msg)\nFileNotFoundError: [Errno 2] No such file or directory: 'date | grep 1'\n\nAnd: \n>>> subprocess.check_output('date | grep 1', shell=True)\nb'gio 19 giu 2014, 14.15.35, CEST\\n'\n\nRead the documentation about the Frequently Used Arguments for more information about the shell argument and how it changes the interpretation of the other arguments.\n\nNote that you should try to avoid using shell=True since spawning a shell can be a security hazard (even if you do not execute untrusted input attacks like Shellshock can still be performed!). \nThe documentation for the subprocess module has a little section about replacing the shell pipeline.\nYou can do so by spawning the two processes in python and use subprocess.PIPE:\ndate_proc = subprocess.Popen(['date'], stdout=subprocess.PIPE)\ngrep_proc = subprocess.check_output(['grep', '1'], stdin=date_proc.stdout, stdout=subprocess.PIPE)\ndate_proc.stdout.close()\noutput = grep_proc.communicate()[0]\n\nYou can write some simple wrapper function to easily define pipelines:\nimport subprocess\nfrom shlex import split\nfrom collections import namedtuple\nfrom functools import reduce\n\nproc_output = namedtuple('proc_output', 'stdout stderr')\n\n\ndef pipeline(starter_command, *commands):\n if not commands:\n try:\n starter_command, *commands = starter_command.split('|')\n except AttributeError:\n pass\n starter_command = _parse(starter_command)\n starter = subprocess.Popen(starter_command, stdout=subprocess.PIPE)\n last_proc = reduce(_create_pipe, map(_parse, commands), starter)\n return proc_output(*last_proc.communicate())\n\ndef _create_pipe(previous, command):\n proc = subprocess.Popen(command, stdin=previous.stdout, stdout=subprocess.PIPE)\n previous.stdout.close()\n return proc\n\ndef _parse(cmd):\n try:\n return split(cmd)\n except Exception:\n return cmd\n\nWith this in place you can write pipeline('date | grep 1') or pipeline('date', 'grep 1') or pipeline(['date'], ['grep', '1'])\n", "The most common cause of FileNotFound with subprocess, in my experience, is the use of spaces in your command. If you have just a single command (not a pipeline, and no redirection, wildcards, etc), use a list instead.\n# Wrong, even with a valid command string\nsubprocess.run(['grep -o -w \"+tz+\"'])\n\n# Fixed; notice also \nsubprocess.run([\"grep\", \"-o\", \"-w\", '\"+tz+\"'])\n\nThis change results in no more FileNotFound errors, and is a nice solution if you got here searching for that exception with a simpler command.\nIf you need a pipeline or other shell features, the simple fix is to add shell=True:\nsubprocess.run(\n '''date | grep -o -w '\"+tz+\"'' | wc -w''',\n shell=True)\n\nHowever, if you are using python 3.5 or greater, try using this approach:\nimport subprocess\n\na = subprocess.run([\"date\"], stdout=subprocess.PIPE)\nprint(a.stdout.decode('utf-8'))\n\nb = subprocess.run([\"grep\", \"-o\", \"-w\", '\"+tz+\"'],\n input=a.stdout, stdout=subprocess.PIPE)\nprint(b.stdout.decode('utf-8'))\n\nc = subprocess.run([\"wc\", \"-w\"],\n input=b.stdout, stdout=subprocess.PIPE)\nprint(c.stdout.decode('utf-8'))\n\nYou should see how one command's output becomes another's input just like using a shell pipe, but you can easily debug each step of the process in python. Using subprocess.run is recommended for python > 3.5, but not available in prior versions.\n", "The FileNotFoundError happens because - in the absence of shell=True - Python tries to find an executable whose file name is the entire string you are passing in. You need to add shell=True to get the shell to parse and execute the string, or figure out how to rearticulate this command line to avoid requiring a shell.\nAs an aside, the shell programming here is decidedly weird. On any normal system, date will absolutely never output \"+tz+\" and so the rest of the processing is moot.\nFurther, using wc -w to count the number of output words from grep is unusual. The much more common use case (if you can't simply use grep -c to count the number of matching lines) would be to use wc -l to count lines of output from grep.\nAnyway, if you can, you want to avoid shell=True; if the intent here is to test the date command, you should probably replace the rest of the shell script with native Python code.\nPros:\n\nThe person trying to understand the program only needs to understand Python, not shell script.\nThe script will have fewer external dependencies (here, date) rather than require a Unix-like platform.\n\nCons:\n\nReimplementing standard Unix tools in Python is tiresome and sometimes rather verbose.\n\nWith that out of the way, if the intent is simply to count how wany times \"+tz+\" occurs in the output from date, try\np = subprocess.run(['date'],\n capture_output=True, text=True,\n check=True)\nresult = len(p.stdout.split('\"+tz+\"'))-1\n\nThe keyword argument text=True requires Python 3.7; for compatibility back to earlier Python versions, try the (misnomer) legacy synonym universal_newlines=True. For really old Python versions, maybe fall back to subprocess.check_output().\nIf you really need the semantics of the -w option of grep, you need to check if the characters adjacent to the match are not alphabetic, and exclude those which are. I'm leaving that as an exercise, and in fact would assume that the original shell script implementation here was not actually correct. (Maybe try re.split(r'(?<=^|\\W)\"\\+tz\\+\"(?=\\W|$)', p.stdout).)\nIn more trivial cases (single command, no pipes, wildcards, redirection, shell builtins, etc) you can use Python's shlex.split() to parse a command into a correctly quoted list of arguments. For example,\n>>> import shlex\n>>> shlex.split(r'''one \"two three\" four\\ five 'six seven' eight\"'\"nine'\"'ten''')\n['one', 'two three', 'four five', 'six seven', 'eight\\'nine\"ten']\n\nNotice how the regular string split() is completely unsuitable here; it simply splits on every whitespace character, and doesn't support any sort of quoting or escaping. (But notice also how it boneheadedly just returns a list of tokens from the original input:\n>>> shlex.split('''date | grep -o -w '\"+tz+\"' | wc -w''')\n['date', '|', 'grep', '-o', '-w', '\"+tz+\"', '|', 'wc', '-w']\n\n(Even more parenthetically, this isn't exactly the original input, which had a superfluous extra single quote after '\"+tz+\"').\nThis is in fact passing | and grep etc as arguments to date, not implementing a shell pipeline! You still have to understand what you are doing.)\n", "The question already has an answer above but just in case the solutions are not working for you; Please check the path itself and if all the environment variables are set for the process to locate the path.\n", "what worked for me on python 3.8.10 (inspired by @mightypile solution here: https://stackoverflow.com/a/49986004/12361522), was removed splits of parametres and i had to enable shell, too:\nthis:\nc = subprocess.run([\"wc -w\"], input=b.stdout, stdout=subprocess.PIPE, shell=True)\n\ninstead of:\nc = subprocess.run([\"wc\", \"-w\"], input=b.stdout, stdout=subprocess.PIPE)\n\n\n\nif anyone wanted to try my solution (at least for v3.8.10), here is mine:\ni have directory with multiple files of at least 2 file-types (.jpg and others). i needed to count specific file type (.jpg) and not all files in the directory, via 1 pipe:\nls *.jpg | wc -l\n\nso eventually i got it working like here:\nimport subprocess\nproc1 = subprocess.run([\"ls *.jpg\"], stdout=subprocess.PIPE, shell=True)\nproc2 = subprocess.run(['wc -l'], input=proc1.stdout, stdout=subprocess.PIPE, shell=True)\nprint(proc2.stdout.decode())\n\nit would not work with splits:\n[\"ls\", \"*.jpg\"] that would make ls to ignore contraint *.jpg\n['wc', '-l'] that would return correct count, but will all 3 outputs and not just one i was after\nall that would not work without enabled shell shell=True\n", "I had this error too and what worked for me was setting the line endings of the .sh file - that I was calling with subprocess - to Unix (LF) instead of Windows CRLF.\n" ]

[ 139, 20, 6, 0, 0, 0 ]

[]

[]

[ "pipe", "python", "shell", "subprocess" ]

[ "As far as i know sklearn doesn't return p values, is better using the statsmodels library.\nBut if you need to use sklearn anyway, you can find various solutions here:\nFind p-value (significance) in scikit-learn LinearRegression\n" ]

[ 1 ]

[]

[]

[ "data_science", "machine_learning", "python", "regression", "statistics" ]

[ "Use df.groupby('No_1')['C_N'].apply(list).to_dict().\nThis gives you {1: [1, 2, 7], 2: [13, 6]}.\n" ]

[ 1 ]

[]

[]

[ "python" ]

[ "First, your pattern can be shortened considerably by implementing an optional non-capturing group so that v or version could be matched without the need of an alternation.\nNext, the first \\b requires a word boundary but the version information starts after _ in the second expected match, and _ is a word char.\nYou can use\n(?<![^\\W_])v(?:ersion)?\\s?[\\d.]*\\b\n\nSee the regex demo.\nDetails:\n\n(?<![^\\W_]) - immediately on the left, there can be no letter or digit\nv - a v char\n(?:ersion)? - an optional ersion string\n\\s? - an optional whitespace\n[\\d.]* - zero or more digits or dots\n\\b - a word boundary.\n\n" ]

[ 1 ]

[]

[]

[ "python", "regex" ]

[ "You can access the dictionary at the heart of a dataclass like so\na = MyDataClass(\"a\", 1)\na.__dict__\n\nthis outputs:\n{'i': 'a', 's': 1}\n\nKnowing this, if you have an iterable arr of type MyDataClass, you can access the __dict__ attribute and construct a dataframe\narr = [MyDataClass(\"a\", 1), MyDataClass(\"b\", 2)]\ndf = pd.DataFrame([x.__dict__ for x in arr])\n\ndf outputs:\n i s\n0 a 1\n1 b 2\n\nThe limitation with this approach that if the slots option is used, then this will not work.\nAlternatively, it is possible to convert the data from a dataclass to a tuple or dictionary using dataclasses.astuple and dataclasses.asdict respectively.\nThe data frame can be also constructed using either of the following:\n# using astuple\ndf = pd.DataFrame(\n [dataclasses.astuple(x) for x in arr], \n columns=[f.name for f in dataclasses.fields(MyDataClass)]\n)\n\n# using asdict\ndf = pd.DataFrame([dataclasses.asdict(x) for x in arr])\n\n" ]

[ 1 ]

[]

[]

[ "pandas", "python", "python_attrs" ]

[ "You'll need to introduce a while loop to keep it going. Try this:\ncredit_limit = 2000\ncredit_balance = 0\n\nwhile True:\n\n print('Welcome to the Credit Card Company')\n Purchase = int(input(\"How much was your purchase? \"))\n Total = credit_balance + Purchase\n\n print(\"Your account value right now: \", Total)\n\n if Total >= credit_limit:\n print(\"You have reached your credit limit!\", Total)\n\nNote that this will keep it going indefinitely. You'll need to add logic for the user to input a command to exit. You can use something like:\n print('Welcome to the Credit Card Company')\n Purchase = int(input(\"How much was your purchase? Or type Exit to exit.\"))\n\nThen:\nif Purchase == 'Exit':\n exit()\n\nEdit:\nHere's a version that retains the balance each time. The key difference is that a variable can equal its previous value plus a change. I rewrote a few things for clarity.\ncredit_limit = 2000\ncurrent_balance = 0\n\nwhile True:\n\n print('Welcome to the Credit Card Company')\n Purchase = int(input(\"How much was your purchase? \"))\n current_balance = current_balance + Purchase\n\n print(\"Your account value right now: \", current_balance)\n\n if current_balance == credit_limit:\n print(\"You have reached your credit limit!\", current_balance)\n\n\n", "If you don't want your code to exit you can use the while loop.\ncredit_balance = 0\ncredit_limit = 2000\n\nwhile True:\n purchase = int(input(\"How much was your purchase? \"))\n Total = credit_balance + purchase\n print(\"Your account value right now: \", Total)\n if Total == credit_limit:\n print(\"You have reached your credit limit!\", Total)\n\nPlease notice I also changed the variable Purchase to purchase.\nThis is because in Python the convention is lower case letters for variables.\nYou can read more about conventions here:\nPython Conventions\nAlso if you want to read more about loops, you can have a look here:\nPython Loops\nGood luck and welcome to python :)\n", "You can get user input infinitely if you use a while loop:\ncredit_balance = 0\ncredit_limit = 2000\n\nwhile True:\n purchase = int(input(\"How much was your purchase? \"))\n credit_balance += purchase # add purchase to credit_balance\n \n print(\"Your account value right now: \", credit_balance)\n \n if credit_balance >= credit_limit:\n print(\"You have reached/exceeded your credit limit!\", Total)\n\nA good exercise would be to add some logic to ensure purchases don't exceed the credit limit.\n" ]

[ 1, 1, 0 ]

[]

[]

[ "python" ]

[ "If B is semidefinite, it means it has at least one eigenvector associated with an eigenvalue 0, you still could have solutions if the nullspace of B is also a null space of A, i.e. if B @ x = 0, A @ x = 0, but in that case the generalized eigenvalue associated with x is undetermined.\n" ]

[ 0 ]

[]

[]

[ "eigenvalue", "eigenvector", "linear_algebra", "python", "scipy" ]

[ "The slowness is due to compilation indeed. But there is now the manylinux tag. Which allows the installation of pre-compiled distributions. See for example the PyPI page of numpy to see if a manylinux package is provided for your Python version.\nUpdate (2021-06)\nSince this answer received some attention lately, there are now many manylinux tags for precompiled packages (no pun intended).\n", "For me, I was running into this issue with pip 22.0.4, Ubuntu 20.04.4 LTS.\nI was installing tensorflow-gpu, which already takes too much time, but the pip was unusually very slow.\nThe above solutions didn't make any sense to me, so I did the following:\n\nDo not run pip commands with sudo.\napt-update && apt-upgrade\nReboot the server/computer\n\nI know it doesn't seem to be a permanent solution, but it fixed the issue for me.\n", "In case anyone was having the network issue and landed on this page like me:\nI noticed slowness on my machine because pip install would get stuck in network calls while trying to create socket connections (sock.connect()). As discussed here, this can happen when the host supports IPv6 but your network doesnt. As instructed here, I checked if this was true by disabling IPv6 on my Ubuntu machine as follows :\nsysctl net.ipv6.conf.all.disable_ipv6=1\n\nI was no longer hanging in network calls after this change.\nHowever, I am not sure if this is a sustainable solution since we are all slowly moving to IPv6.\n" ]

[ 24, 1, 0 ]

[ "Command\nInstead of (too slow to complete)\npython -m pip install numpy\n\nThis worked (fast as supposed to be)\npip install numpy\n\nCheck\npython\n\nimport numpy as np \n\n(it shouldn't give any errors)\n" ]

[ -34 ]

[ "pip", "python" ]

[ "You can do this in many ways. Your subprocess.call() option would work - but it depends on the details of implementation. Perhaps the easiest is to use multiprocessing to run the program in a subprocess while the parent simply restarts it as necessary.\nimport multiprocessing as mp\nimport time\n\ndef do_the_things(arg1, arg2):\n print(\"doing the things\")\n time.sleep(2) # for test\n raise RuntimeError(\"Virgin Media dun me wrong\")\n\ndef launch_and_monitor():\n while True:\n print(\"start the things\")\n proc = mp.Process(target=do_the_things, args=(0, 1))\n proc.start()\n proc.wait()\n print(\"things went awry\")\n time.sleep(2) # a moment before restart hoping badness resolves\n\nif __name__ == \"__main__\":\n launch_and_monitor()\n\nNote: The child process uses the same terminal as the parent. Running separate terminals is quite a bit more difficult. It would depend, for instance, on how you've setup to have a terminal attach to the pi.\nIf you want to catch and process errors in the parent process, you could write some extra code to catch the error, pickle it, and have a queue to pass it back to the parent. Multiprocessing pools already do that, so you could just have a pool with 1 process and and a single iterable to consume.\nwith multiprocessing.Pool(1) as pool:\n while True:\n try:\n result = pool.map(do_the_things, [(0,1)])\n except Exception as e:\n print(\"caught\", e)\n\n", "Ok, I got it!\nFor anyone else interested in trying to do what my original question was:\nTo close down a script on the occurrence of an error and then open either a new script, or a copy of the original one (for the purpose of having the same functionality as the first) in a new terminal window, this is the answer using my original code samples as an example (first.py and second.py where both scripts run the exact same code - other than defining them as different names and this name allocation defined within for which alternate file to open in its place)\nfirst.py\nimport time\nimport subprocess\n\nthisfile = \"first\"\n#thisfile = \"second\"\n\nif thisfile == \"second\":\n restartcommand = 'python3 /home/mypi/myprograms/first.py'\nelse:\n restartcommand = 'python3 /home/mypi/myprograms/second.py'\n\ntime.sleep(3)\nwhile thisfile == \"second\":\n print(\"this is the second file\")\n time.sleep(1)\n subprocess.run('lxterminal -e ' + restartcommand, shell=True)\n print(\"I'm leaving second now\")\n break\nwhile thisfile == \"first\":\n print(\"this is the first file\")\n time.sleep(1)\n subprocess.run('lxterminal -e ' + restartcommand, shell=True)\n print(\"I'm leaving first now\")\n break\ntime.sleep(1)\nquit()\n\nsecond.py\nimport time\nimport subprocess\n\n#thisfile = \"first\"\nthisfile = \"second\"\n\nif thisfile == \"second\":\n restartcommand = 'python3 /home/mypi/myprograms/first.py'\nelse:\n restartcommand = 'python3 /home/mypi/myprograms/second.py'\n\ntime.sleep(3)\nwhile thisfile == \"second\":\n print(\"this is the second file\")\n time.sleep(1)\n subprocess.run('lxterminal -e ' + restartcommand, shell=True)\n print(\"I'm leaving second now\")\n break\nwhile thisfile == \"first\":\n print(\"this is the first file\")\n time.sleep(1)\n subprocess.run('lxterminal -e ' + restartcommand, shell=True)\n print(\"I'm leaving first now\")\n break\ntime.sleep(1)\nquit()\n\nThe result of running either one of these will be that the program runs, then opens the other file and starts running that before closing down itself and this operation will continue back and forth, back and forth until you close down the running file before it gets a chance to open the other file.\nTry it! it's fun!\n" ]

[ 1, 0 ]

[]

[]

[ "python", "restart" ]

[ "Using sort_values:\ndf = df.sort_values('Month')\n\nor directly plotting from pandas:\nimport matplotlib.ticker as mticker\n\nfig, ax = plt.subplots(1,1)\ndf.sort_values('Month').plot(\n x='Month', y='Count', \n marker='o', legend=False, ax=ax\n)\nax.grid(color='gray', linestyle='-', linewidth=0.1)\nax.xaxis.set_major_locator(mticker.MultipleLocator())\n\nOutput:\n\n" ]

[ 0 ]

[]

[]

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

[ "You can set the date as index and update like:\ndf1 = df.set_index('date')\ndf1.loc[new_date, dic.keys()] = dic.values()\ndf = df1.sort_index().reset_index().ffill()\n\nIt will insert new date if it doesn't exist. If it exists it will update the record at that index.\n" ]

[ 1 ]

[]

[]

[ "pandas", "python" ]

[ "Following this snippet you can do this:\nfrom flask.json import JSONEncoder\nfrom datetime import date\n\n\nclass CustomJSONEncoder(JSONEncoder):\n def default(self, obj):\n try:\n if isinstance(obj, date):\n return obj.isoformat()\n iterable = iter(obj)\n except TypeError:\n pass\n else:\n return list(iterable)\n return JSONEncoder.default(self, obj)\n\napp = Flask(__name__)\napp.json_encoder = CustomJSONEncoder\n\nRoute:\nimport datetime as dt\n\[email protected]('/', methods=['GET'])\ndef index():\n now = dt.datetime.now()\n return jsonify({'now': now})\n\n", "datetime.date is not a JSON type, so it's not serializable by default. Instead, Flask adds a hook to dump the date to a string in RFC 1123 format, which is consistent with dates in other parts of HTTP requests and responses.\nUse a custom JSON encoder if you want to change the format. Subclass JSONEncoder and set Flask.json_encoder to it.\nfrom flask import Flask\nfrom flask.json import JSONEncoder\n\nclass MyJSONEncoder(JSONEncoder):\n def default(self, o):\n if isinstance(o, date):\n return o.isoformat()\n\n return super().default(o)\n\nclass MyFlask(Flask):\n json_encoder = MyJSONEncoder\n\napp = MyFlask(__name__)\n\nIt is a good idea to use ISO 8601 to transmit and store the value. It can be parsed unambiguously by JavaScript Date.parse (and other parsers). Choose the output format when you output, not when you store.\n\nA string representing an RFC 2822 or ISO 8601 date (other formats may be used, but results may be unexpected).\n\nWhen you load the data, there's no way to know the value was meant to be a date instead of a string (since date is not a JSON type), so you don't get a datetime.date back, you get a string. (And if you did get a date, how would it know to return date instead of datetime?)\n", "You can change your app's .json_encoder attribute, implementing a variant of JSONEncoder that formats dates as you see fit.\n", "Flask 2.2 shows a deprecation warning\n'JSONEncoder' is deprecated and will be removed in Flask 2.3. Use 'Flask.json' to provide an alternate JSON implementation instead.\nAn update is needed to remove it and/or have it work in Flask 2.3+. Another example from the Flask repository here\nfrom flask import Flask\nfrom flask.json.provider import DefaultJSONProvider\n\nclass UpdatedJSONProvider(DefaultJSONProvider):\n def default(self, o):\n if isinstance(o, date) or isinstance(o, datetime):\n return o.isoformat()\n return super().default(o)\n\napp = Flask(__name__)\napp.json = UpdatedJSONProvider(app)\n\n" ]

[ 59, 23, 1, 0 ]

[]

[]

[ "date", "datetime", "flask", "json", "python" ]

[ "In a session, I'd just store the object primary key:\nrequest.session['card'] = card.id\n\nand when loading the card from the session, obtain the card again with:\ntry:\n card = Card.objects.get(id=request.session['card'])\nexcept (KeyError, Card.DoesNotExist):\n card = None\n\nwhich will set card to None if there isn't a card entry in the session or the specific card doesn't exist.\nBy default, session data is serialised to JSON. You could also provide your own serializer, which knows how to store the card.id value or some other representation and, on deserialization, produce your Card instance again.\n", "Unfortunately the suggested answer does not work if the object is not a database object but some other kind of object - say, datetime or an object class Foo(object): pass that isn't a database model object.\nSure, if the object happen to have some id field you can store the id field in the database and look up the value from there but in general it may not have such a simple value and the only way is to convert the data to string in such a way that you can read that string and reconstruct the object based on the information in the string.\nIn the case of a datetime object this is made more complicated by the fact that while a naive datetime object can print out format %Z by simply not printing anything, the strptime object cannot read format %Z if there is nothing, it will choke unless there is a valid timezone specification there - so if you have a datetime object that may or may not contain a tzinfo field you really have to do strptime twice once with %Z and then if it chokes without the %Z. This is silly. It is made even sillier by the fact that datetime objects have a fromtimestamp function but no totimestamp function that uniformly produces a timestamp that fromtimestamp will read. If there is a format code that produces timestamp number I haven't found one and again, strftime/strptime suffer from the fact that they are not symmetric as described above.\n", "There are two simple ways to do this.\n\nIf each object belongs to a single session at the same time, store session id as a model field, and update models.\nIf an object can belong to multiple sessions at the same time, store object.id as a session variable.\n\n", "@Martijn is or might be the correct way to save the object in session variables. \nBut the issue was solved by moving back to Django 1.5. So this issue is specifically for django 1.6.2. \nHope this helps. \n", "--> DON'T EVER FEEL LIKE DOING SOMETHING LIKE THIS! <--\nDjango using session and ctypes: Plz read Martijn Pieters explanation comment below.\nclass MyObject:\n def stuff(self):\n return \"stuff...\"\n\nmy_obj = MyObject()\nrequest.session['id_my_obj'] = id(my_obj)\n\n...\n\nid_my_obj = request.session.get('id_my_obj')\n\nimport ctypes\nobj = ctypes.cast(id_my_obj, ctypes.py_object).value\n\nprint(obj.stuff()) \n# returns \"stuff...\"\n\n", "Objects cannot be stored in session from Django 1.6 or above.\nIf you don't want to change the behavior of the cookie value(of a object), you can add a dictionary there. This can be used for non database objects like class object etc.\nfrom django.core.serializers.json import DjangoJSONEncoder\nimport json \ncard_dict = card.__dict__\ncard_dict .pop('_state', None) #Pop which are not json serialize\ncard_dict = json.dumps(card_dict , cls=DjangoJSONEncoder)\nrequest.session['card'] = card_dict \n\nHope it will help you!\n", "In my case, as the object is not serializable (selenium webdriver), I had to use global variables, which is working great.\n" ]

[ 23, 4, 3, 0, 0, 0, 0 ]

[]

[]

[ "django", "python" ]

[ "I figured this out although it may not be elegant:\ndf2 = pd.DataFrame()\nfor item in df['item'].unique():\n df_ = df[df['item'] == item]\n df_ = pd.concat([df_,df_.apply(lambda dt: pd.date_range(dt['start_date'], dt['end_date'], freq=\"MS\"), axis = 'columns').explode(ignore_index=True)], axis=1)\n df_.drop(['start_date', 'end_date'], axis=1, inplace = True)\n # df_.iloc[:, -1:].rename({'0':'dates'},inplace=True)\n df_.ffill(inplace=True)\n df_.bfill(inplace=True)\n df2 = df2.append(df_)\n\ndf2.rename(columns={0:'dates'},inplace=True)\n\n" ]

[ 1 ]

[]

[]

[ "data_wrangling", "pandas", "python" ]

[ "I was in the same boat. The best solution that worked great for me was to use global variables.\nIn this case, before creating the web driver object, just call \"global driver\" on each view that you need that same object.\nSo, I would do this way:\nglobal driver\ndriver = webdriver.Chrome(executable_path=driverpath, desired_capabilities=caps)\n\nOn any other view in your views.py file, just call the \"global driver\" again and use the same object instance already instantiated before.\n" ]

[ 0 ]

[]

[]

[ "django", "python", "selenium", "session", "store" ]

[ "Is your python path looking in the right place? Check where python is looking for the module. Within the notebook try:\nimport os\nos.sys.path\n\nIs the cv2 module located in any of those directories? If not your path is looking in the wrong place. If it is overlooking the install location, append it to your python path. You can follow the instructions here.\n", "I didn't have the openCV installation in my Python3 kernel, so I installed it by activating the specific environment and running this in the command prompt:\npip install opencv-python\n\nHow to find and activate my environment?\nTo list all of Your conda environments, run this command:\nconda info --envs\n\nYou will get something like this:\nipykernel_py2 D:\\Anaconda\\envs\\ipykernel_py2\nroot D:\\Anaconda\n\nAfter that, activate the environment that is complaining for the missing cv2 and run the pip install opencv-python command.\nHow to activate an environment?\nJust run the command:\nactivate env_name\n\nwhere env_name is the wanted environment (for example, You could type activate ipykernel_py2 if You wanted to access the first of the two environments listed above).\nNote: If You are on Linux, You need to type source activate env_name.\n", "Go to your notebook, in menu section\nkernel -> Change kernel -> Python<desired version>\nNow in the notebook run following command to install opencv2 in the selected environment kernel\npython2:\n!pip install opencv-python\npython3:\n!pip3 install opencv-python\n", "Binmosa's explanation is great and to the point. As an alternative (easier, but I'm pretty sure it's just a band-aid fix), if you write:\n import sys\n !{sys.executable} -m pip install opencv-python\n\ndirectly into your notebook, you'll be able to actually install the module in the notebook itself.\nThe longer explanation is interesting and informative, though. Link: https://jakevdp.github.io/blog/2017/12/05/installing-python-packages-from-jupyter/\n", "To make this clear for those who are having the same issue:\nBy default: Anaconda (jupyter notebook) has its own version of Python & packages once it has been installed on your PC.\nIf you have Python x.x installed on your PC, and you installed OpenCV or -whatever packages- using the package manager of this python version, it does NOT mean your jupyter notebook will get access to these python packages you installed earlier. They are not living in the same folder.\nTo illustrate this, open your windows CMD and write :\npython\n\nthen write:\nimport os\nos.path\n\nyou will get the path of your python. in my case (C:\\Python35)\nNow open the Anaconda Prompt and write the same commands again:\nyou will get the anaconda's python path. In my case (C:\\Users\\MY_NAME\\Anaconda3).\nAs you can see, there are two different paths of python, so make sure that your first step in diagnosing such error (No module named x) is to ask yourself whether you installed the package in the right place or not!\nN.B: within Anaconda itself you can create environments, each environment may have different packages installed in it, so you also have to make sure you're in the right environment and it is the active one.\n", "It is because of opencv library.\nTry running this command in anaconda prompt:\nconda install -c conda-forge opencv\n\n", "You can simply open Jupyter Notebook and in any of the cell, just write:\npip install opencv-python\n\nIt will automatically install the file\nNote : Keep turn ON your Internet connection\nThen in next cell :\nimport cv2\n\nIt will work.\n", "I added \\envs\\myenv\\Library\\bin also in the path variable and it got solved.\n", "You will need to install ipykernel for the jupyter notebook. Follow the following steps:\npython -m virtualenv env\nsource env/bin/acitivate\npip install opencv-contrib-python\npip install ipykernel --upgrade\npython -m ipykernel install --user\njupyter notebook\n\n", "I had this issue in my Jupyter Notebook after I had \"installed\" the opencv package, using Anaconda Navigator, on my base (root) environment. \nHowever, after \"installing\" the package and its dependencies, Anaconda Navigator showed a reminder popup to update to the next Anaconda Navigator version. I ignored this at first, but couldn't use the opencv package in my Jupyter Notebook.\nAfter I did update Anaconda Navigator to the newer version, the opencv package install worked fine.\n", "pip install opencv-python\n\nThis solved the error for me in MacOS.\n", "I had similar problem. None of the above solution worked for me. I did below in my notebook and that solved the issue\n!pip install opencv-python\n!pip install opencv-python-headless\n\n", "I hope you have already activated the environment you know OpenCV is installed in but is not running/import error in jupyter notebook.\nIf not then run the below command and activate your environment before running the jupyter notebook.\nconda activate /Users/prajendr/anaconda3/envs/cvpy39\n\nThen, check all the anaconda environments on your machine using the below command on the jupyter notebook.\n!conda info --envs\n\nThe output would be similar -\n\nTry to install OpenCV in the environment again.\n\nYou know that you have OpenCV installed in this anaconda environment - cvpy39 and the path is \"/Users/prajendr/anaconda3/envs/cvpy39/lib/python3.9/site-packages\"\nThen type the below commands to see if the OpenCV path was imported in the notebook or not?\nimport os\nos.sys.path\n\n\nyou see the OpenCV path is not in this list so you need to manually import it.\nThen in a cell type the below set of code. Make sure to change the python path of the environment to yours.\nimport sys\npath_to_module = \"/User/prajendr/anaconda3/envs/cvpy39/lib/python3.9/site-packages/\"\nsys.path.append(path_to_module)\nimport cv2\n\nYou will now be able to import OpenCV to your jupyter notebook.\n", "You can simply try this in your jupyter notebook cell `%pip install opencv-python`\n\nno matter which python version you're using. you may need to restart kernel to use updated package\n" ]

[ 17, 13, 7, 6, 5, 3, 3, 1, 1, 0, 0, 0, 0, 0 ]

[ "One of possibility is that you could have written import cv2 and its utilisation in separate cells of jupyter notebook.If this is the case then first run the cell having import cv2 part and then run the cell utilising the cv2 library.\n" ]

[ -1 ]

[ "jupyter_notebook", "opencv", "python" ]

[ "You've created the structure , but you haven't done the implementation in GVL.\nYou have to add in GVL:\nVAR_GLOBAL\n\n sample_structure : sample_structure;\n\nEND_VAR\n\n" ]

[ 0 ]

[]

[]

[ "linux", "plc", "python", "structure" ]

[ "You can use groupby.apply to compute a set difference with the range from the min to max value. Then explode:\n(df1.astype({'Invoice': int})\n .groupby('Store')['Invoice']\n .apply(lambda s: set(range(s.min(), s.max())).difference(s))\n .explode().reset_index()\n)\n\nNB. if you want to ensure having sorted values, use lambda s: sorted(set(range(s.min(), s.max())).difference(s)).\nOutput:\n Store Invoice\n0 A 3\n1 A 4\n2 A 7\n3 B 21\n4 B 22\n5 B 25\n6 B 26\n7 B 27\n8 B 28\n9 B 29\n10 C 201\n11 D 205\n\n", "Here's an approach:\nimport pandas as pd\nimport numpy as np\n\ndf1 = pd.DataFrame()\ndf1['Store'] = ['A','A','A','A','A','B','B','B','B','C','C','C']\ndf1['Invoice'] = ['1','2','5','6','8','20','23','24','30','200','202','203']\ndf1['Invoice'] = df1['Invoice'].astype(int)\n\ndf2 = df1.groupby('Store')['Invoice'].agg(['min','max'])\ndf2['MissInvoice'] = [[]]*len(df2)\nfor store,row in df2.iterrows():\n df2.at[store,'MissInvoice'] = np.setdiff1d(np.arange(row['min'],row['max']+1), \n df1.loc[df1['Store'] == store, 'Invoice'])\ndf2 = df2.explode('MissInvoice').drop(columns = ['min','max']).reset_index()\n\nThe resulting dataframe df2:\n Store MissInvoice\n0 A 3\n1 A 4\n2 A 7\n3 B 21\n4 B 22\n5 B 25\n6 B 26\n7 B 27\n8 B 28\n9 B 29\n10 C 201\n\nNote: Store D is absent from the dataframe in my code because it is omitted from the lines in the question defining df1.\n" ]

[ 4, 1 ]

[]

[]

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

[ "This is a low effort response but you have a low effort question https://help.relativity.com/RelativityOne/Content/Relativity/Regular_expressions/Searching_with_regular_expressions.htm\nThe answer is regular expressions.\n" ]

[ 0 ]

[]

[]

[ "python" ]

[ "The infinite input can be done using the while loop. You can save that input to the other data structure such a list, but you can also put below it the code.\nwhile True:\n x = input('Enter something')\n determineGrade(x)\n determinePass(x)\n\n", "Try this out.\nwhile True:\n try:\n variable = int(input(\"Enter your input\"))\n # your code\n\n except (EOFError,ValueError):\n break\n\nEOFError- You will get this error if you are taking input from a file.\nValueError- In case wrong input is provided.\n", "To ask for data an unlimited number of times, you want a while loop.\nscores=[] \nwhile True:\n score=input(\"Students score >>\")\n #asks for an input\n if score in (\"\",\"q\",\"quit\",\"e\",\"end\",\"exit\"):\n #if the input was any of these strings, stop asking for input.\n break\n elif score.isdigit():\n #if the input was a number, add it to the list.\n scores.append(int(score))\n else:\n #the user typed in nonsense, probably a typo, ask them to try again \n print(\"invalid score, please try again or press enter to end list\")\n#you now have an array scores to process as you see fit.\n\n", "Have a look into and get the idea of https://docs.python.org/3/library/itertools.html, so just for the letters itertools.cycle('ABCDF') might fit. Or for the scores:\nimport random\n\ndef next_input():\n return random.randint(1, 100)\n\nif __name__ == '__main__':\n while True:\n studentScore = next_input()\n print(f\"score: {studentScore:3}\")\n\nFurther read (for probability distributions) could be https://numpy.org/doc/stable/reference/random/index.html.\n", "Sorry if I am a little late, but I will provide another example in case this is an assignment that may have others confused. I tried to approach it differently than using while True: as someone already explained this. I will be using a sentinel value(s) or the value(s) that cause a loop to terminate. See below:\n\"\"\"\nI kept your function the same besides removing the invalid conditional branch and adding a \nprint statement\n\"\"\"\ndef determineGrade (studentScore):\n print(\"Student earned the following grade: \", end = \" \")\n \n if studentScore <= 40:\n print ('F')\n elif studentScore <= 50:\n print ('D')\n elif studentScore <= 60:\n print ('C')\n elif studentScore <= 70:\n print ('B')\n elif studentScore <= 100:\n print ('A')\n\n\"\"\"\nI kept this function very similar as well except I used a list initialized in main so you have a \nhistory of all student scores input and how many passed or failed. I also put the fail and passing\nvariables here for readability and to avoid scope problems.\n\"\"\"\ndef determinePass (score_list):\n fail = 0\n passing = 0\n \n for i in range(len(score_list)):\n if score_list[i] <= 40:\n fail += 1\n else:\n passing += 1\n \n print(\"Students passing: {}\".format(passing))\n print(\"Students failing: {}\".format(fail))\n\n\"\"\"\nI finished this function by using basic list functions that calculate the average. In the future,\nuse the keyword pass or a stub in your definition if not finished so you can still test it :)\n\"\"\"\ndef classAverage (score_list):\n avg = sum(score_list) / len(score_list)\n \n print(\"Class Average: {}\".format(avg))\n\n\"\"\" MAIN \"\"\"\nif __name__ == \"__main__\":\n # Makes sentinel value known to the user (any negative number).\n print(\"Welcome. Input a negative integer at any time to exit.\")\n # Wrapped input in float() so input only accepts whole and decimal point numbers. \n studentScore = float(input(\"Grade for a student: \"))\n # Declares an empty list. Remember that they are mutable meaning they can change even in functions.\n score_list = []\n \n # Anything below 0 is considered a sentinel value or what terminates the loop. \n while studentScore >= 0:\n # If input score is between 0-100:\n if studentScore <= 100:\n # Input score is added to our list for use in the functions.\n score_list.append(studentScore)\n \n determineGrade(studentScore)\n determinePass(score_list)\n classAverage(score_list)\n # If a number beyond 100 is input as a score.\n else:\n print(\"Invalid. Score must be between 0-100\")\n \n # Used to avoid infinite loop and allow as many valid inputs as desired.\n print(\"Welcome. Input a negative integer at any time to exit.\")\n studentScore = float(input(\"Grade for a student: \"))\n\nSome important notes I would like to add. One, a reference to what techniques were introduced in this example with a little more detail: (https://redirect.cs.umbc.edu/courses/201/fall16/labs/lab05/lab05_preLab.shtml).\nSecond, I tried to follow my formatting based on the functional requirements provided in your code and explanation, but since I did not have the guidelines, you may need to reformat some things.\nThird, I tried to use techniques that you or someone is likely learning in the near future or already learned up to this assignment. As you gain experience, you may wish to alter this program to where entering anything but an integer or float will throw an exception and/or not terminate the program. You may also wish to reduce the runtime complexity by shifting or modifying some things. You could even track the name or id of students using a different structure such as a dictionary. Basically, what I provided is just a working example around what I deemed students may already know at this point to get you started :)\nIf you have any questions, need additional resources, or want some examples of any other techniques, let me know and happy coding!\n" ]

[ 2, 1, 1, 1, 0 ]

[]

[]

[ "function", "input", "python" ]

[ "This is one way:\ndf['uuid'] = [uuid.uuid4() for _ in range(len(df.index))]\n\n", "I can't speak to computational efficiency here, but I prefer the syntax here, as it's consistent with the other apply-lambda modifications I usually use to generate new columns:\ndf['uuid'] = df.apply(lambda _: uuid.uuid4(), axis=1)\n\nYou can also pick a random column to remove the axis requirement (why axis=0 is the default, I'll never understand):\ndf['uuid'] = df['col'].apply(lambda _: uuid.uuid4())\n\nThe downside to these is technically you're passing in a variable (_) that you don't actually use. It would be mildly nice to have the capability to do something like lambda: uuid.uuid4(), but apply doesn't support lambas with no args, which is reasonable given its use case would be rather limited.\n", "from uuid import uuid4\ndf['uuid'] = df.index.to_series().map(lambda x: uuid4())\n\n", "To create a new column, you must have enough values to fill the column. If we know the number of rows (by calculating the len of the dataframe), we can create a set of values that can then be applied to a column.\nimport uuid\nimport pandas as pd\nimport numpy as np\n\ndf = pd.DataFrame(np.random.randn(4,3), columns=list('abc'),\n index=['apple', 'banana', 'cherry', 'date'])\n\n\n# you can create a simple list of values using a list comprehension \n# based on the len (or number of rows) of the dataframe\ndf['uuid'] = [uuid.uuid4() for x in range(len(df))]\nprint(df)\n\napple -0.775699 -1.104219 1.144653 f98a9c76-99b7-4ba7-9c0a-9121cdf8ad7f\nbanana -1.540495 -0.945760 0.649370 179819a0-3d0f-43f8-8645-da9229ef3fc3\ncherry -0.340872 2.445467 -1.071793 b48a9830-3a10-4ce0-bca0-0cc136f09732\ndate -1.286273 0.244233 0.626831 e7b7c65c-0adc-4ba6-88ab-2160e9858fc4\n\n", "A revised version of S. A. Calder's answer using Pandas v1.5.2:\nfrom uuid import uuid4\ndf['uuid'] = df.index.map(lambda _: uuid4())\n\nThere is no need to convert the index to a Series. replacing lambda x: with lambda _: indicates to the programmer that the series elements provided by the map method are unused in calculating the UUIDs.\n" ]

[ 38, 20, 4, 2, 0 ]

[]

[]

[ "dataframe", "pandas", "python", "python_3.x", "uuid" ]

[ "Check the startup.sh file permissions on the Windows machine and make sure that it's executable.\n" ]

[ 0 ]

[]

[]

[ "docker", "fastapi", "python", "windows" ]

[ "It turns out that you can just use a serializer!\nfrom django_enum_choices.serializers import EnumChoiceModelSerializerMixin\nfrom rest_framework import serializer\n\n\nclass DeviceSerializer(EnumChoiceModelSerializerMixin, serializers.ModelSerializer):\n class Meta:\n model = Device\n fields = (\n \"service\",\n )\n\nResults:\nquery = Device.objects.values(\"service\").all()\nresults = DeviceSerializer(query, many=True)\nprint(results)\n\n# [OrderedDict([('service', 'MOBILE')]), OrderedDict([('service', 'LAPTOP')])]\n\n" ]

[ 0 ]

[]

[]

[ "django", "enums", "python" ]

[ "i hope i understood you correctly, if i did this code will do the trick:\nnumber_of_tables = 35\nnumber_of_people = 3\n\ntables_list = [int(number_of_tables / number_of_people) for _ in range(number_of_people)]\n\nremainder = number_of_tables % number_of_people\n\nfor index in range(remainder):\n tables_list[index] += 1\n\nprint(tables_list)\n\n" ]

[ 2 ]

[]

[]

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

[ "As said by @jasonharper on the opening post comment, the solution was to insert buffer.seek(0) at the end of the function before returning it.\n(...)\n wave_write.close()\n buffer.seek(0)\n return buffer\n\n" ]

[ 0 ]

[]

[]

[ "pyaudio", "python", "torchaudio", "wave" ]

[ "You should try to open terminal in VS Code, and run pip freeze (and pip3 freeze). Check if you find pandas in the results, it won't. That must be because you'd have multiple installations of Python on your system. You may do any one of the below -\n\nGet rid of all but one Python installation.\nInstall pandas on the VS Code installed python instance.\nConfigure the same installation of python that is referenced by your command prompt. (choose the correct python interpreter from VS Code Command Palette)\n\n" ]

[ 2 ]

[ "To read an Excel file with Python, you need to install the pandas library. To install pandas, open the command line or terminal and type:\npip install pandas\nOnce pandas is installed, you can read an Excel file like this:\nimport pandas as pd\ndf = pd.read_excel('file_name.xlsx')\nprint(df)\nYou should also make sure that the file path is correct and that you have the correct permissions to access the file.\nIf you are still having issues, try using the absolute file path instead of a relative file path.\n" ]

[ -1 ]

[ "pip", "python", "visual_studio_code" ]

[ "EDIT:\nThese two approaches are very general and can work for small-medium scale instances. For a more efficient approach, check the answer of chthonicdaemon (using customized preprocessing and scipy's optimize.nnls).\nUsing scipy\nCode\nimport numpy as np\nfrom scipy.optimize import minimize\n\na = np.array([1.2, 2.3, 4.2])\nb = np.array([1, 5, 6])\nc = np.array([5.4, 6.2, 1.9])\n\nm = np.vstack([a,b,c])\ny = np.array([5.3, 0.9, 5.6])\n\ndef loss(x):\n return np.sum(np.square((np.dot(x, m) - y)))\n\ncons = ({'type': 'eq',\n 'fun' : lambda x: np.sum(x) - 1.0})\n\nx0 = np.zeros(m.shape[0])\nres = minimize(loss, x0, method='SLSQP', constraints=cons,\n bounds=[(0, np.inf) for i in range(m.shape[0])], options={'disp': True})\n\nprint(res.x)\nprint(np.dot(res.x, m.T))\nprint(np.sum(np.square(np.dot(res.x, m) - y)))\n\nOutput\nOptimization terminated successfully. (Exit mode 0)\n Current function value: 18.817792344\n Iterations: 5\n Function evaluations: 26\n Gradient evaluations: 5\n[ 0.7760881 0. 0.2239119]\n[ 1.87173571 2.11955951 4.61630834]\n18.817792344\n\nEvaluation\n\nIt's obvious that the model-capabilitites / model-complexity is not enough to obtain a good performance (high loss!)\n\nUsing general-purpose QP/SOCP-optimization modelled by cvxpy\nAdvantages:\n\ncvxpy prooves, that the problem is convex\nconvergence for convex optimization problems is guaranteed (might be also true for the above)\nin general: better accuracy\nin general: more robust in regards to numerical instabilities (solver is only able to solve SOCPs; not non-convex models like the SLSQP-approach above!)\n\nCode\nimport numpy as np\nfrom cvxpy import *\n\na = np.array([1.2, 2.3, 4.2])\nb = np.array([1, 5, 6])\nc = np.array([5.4, 6.2, 1.9])\n\nm = np.vstack([a,b,c])\ny = np.array([5.3, 0.9, 5.6])\n\nX = Variable(m.shape[0])\nconstraints = [X >= 0, sum_entries(X) == 1.0]\n\nproduct = m.T * diag(X)\ndiff = sum_entries(product, axis=1) - y\nproblem = Problem(Minimize(norm(diff)), constraints)\nproblem.solve(verbose=True)\n\nprint(problem.value)\nprint(X.value)\n\nOutput\nECOS 2.0.4 - (C) embotech GmbH, Zurich Switzerland, 2012-15. Web: www.embotech.com/ECOS\n\nIt pcost dcost gap pres dres k/t mu step sigma IR | BT\n 0 +0.000e+00 -0.000e+00 +2e+01 5e-01 1e-01 1e+00 4e+00 --- --- 1 1 - | - - \n 1 +2.451e+00 +2.539e+00 +4e+00 1e-01 2e-02 2e-01 8e-01 0.8419 4e-02 2 2 2 | 0 0\n 2 +4.301e+00 +4.306e+00 +2e-01 5e-03 7e-04 1e-02 4e-02 0.9619 1e-02 2 2 2 | 0 0\n 3 +4.333e+00 +4.334e+00 +2e-02 4e-04 6e-05 1e-03 4e-03 0.9326 2e-02 2 1 2 | 0 0\n 4 +4.338e+00 +4.338e+00 +5e-04 1e-05 2e-06 4e-05 1e-04 0.9698 1e-04 2 1 1 | 0 0\n 5 +4.338e+00 +4.338e+00 +3e-05 8e-07 1e-07 3e-06 7e-06 0.9402 7e-03 2 1 1 | 0 0\n 6 +4.338e+00 +4.338e+00 +7e-07 2e-08 2e-09 6e-08 2e-07 0.9796 1e-03 2 1 1 | 0 0\n 7 +4.338e+00 +4.338e+00 +1e-07 3e-09 4e-10 1e-08 3e-08 0.8458 2e-02 2 1 1 | 0 0\n 8 +4.338e+00 +4.338e+00 +7e-09 2e-10 2e-11 9e-10 2e-09 0.9839 5e-02 1 1 1 | 0 0\n\nOPTIMAL (within feastol=1.7e-10, reltol=1.5e-09, abstol=6.5e-09).\nRuntime: 0.000555 seconds.\n\n4.337947939 # needs to be squared to be compared to scipy's output!\n # as we are using l2-norm (outer sqrt) instead of sum-of-squares\n # which is nicely converted to SOCP-form and easier to\n # tackle by SOCP-based solvers like ECOS\n # -> does not change the solution-vector x, only the obj-value\n[[ 7.76094262e-01]\n [ 7.39698388e-10]\n [ 2.23905737e-01]]\n\n", "You can get a good solution to this with a little bit of math and scipy.optimize.nnls:\nFirst we do the math:\nIf \ny = b1*a + b2*b + b3*c and b1 + b2 + b3 = 1, then b3 = 1 - b1 - b2. \nIf we substitute and simplify we end up with \ny - c = b1(a - c) + b2(b - c)\nNow, we don't have any equality constraints and nnls can solve directly:\nimport scipy.optimize\nA = np.vstack([a - c, b - c]).T\n(b1, b2), norm = scipy.optimize.nnls(A, y - c)\nb3 = 1 - b1 - b2\n\nThis recovers the same solution as obtained in the other answer using cvxpy.\nb1 = 0.77608809648662802\nb2 = 0.0\nb3 = 0.22391190351337198\nnorm = 4.337947941595865\n\nThis approach can be generalised to an arbitrary number of dimensions as follows. Assume that we have a matrix B constructed with a, b, c from the original question arranged in the columns. Any additional dimensions will get added to this.\nNow, we can do\nA = B[:, :-1] - B[:, -1:]\nbb, norm = scipy.optimize.nnls(A, y - B[:, -1])\nbi = np.append(bb, 1 - sum(bb))\n\n", "One comment regarding sascha's scipy implementation: be aware that with scipy minimize, the trial-and-error nature of SLSQP may get you a solution that is slightly off unless you make some other specifications, namely the maximum iterations (maxiter) and maximum tolerance (ftol), as detailed in the scipy docs here.\nThe default values are: maxiter=100 and ftol=1e-06.\nHere is an example to illustrate using matrix notation: first get rid of the constraints and bounds. Also assume for simplicity that the intercept=0. In that case, the coefficients for any multiple regression, as covered here on page 4, will be (precisely):\ndef betas(y, x):\n # y and x are ndarrays--response & design matrixes\n return np.dot(np.linalg.inv(np.dot(x.T, x)), np.dot(x.T, y))\n\nNow, given that the goal of least squares regression is to minimize the sum of squared residuals, take sascha's loss function (re-written slightly):\ndef resids(b, y, x):\n resid = y - np.dot(x, b)\n return np.dot(resid.T, resid)\n\nGiven your actual Y and X vectors, you can plug in the resulting \"true\" betas from the first equation above into the second to get a much better \"benchmark.\" Compare this benchmark to the .fun attribute of res (what scipy minimize spits out). Even tiny changes can cause meaningful changes to the resulting coefficients.\nSo to make a long story short, it will sacrifice speed but improve accuracy to use something like\noptions={'maxiter' : 1000, 'ftol' : 1e-07}\n\nwithin sascha's code.\n", "Your problem is a linear least squares, you could solve it directly with a quadratic programming solver using the solve_ls function in qpsolvers. Here is a snippet adapted from this post on linear regression in Python:\nfrom qpsolvers import solve_ls\n\n# Objective (|| R x - s ||^2): || [a b c] x - y ||^2\nR = m.T\ns = y\n\n# Linear constraint (A * x == b): sum(x) = 1\nA = np.ones((1, 3))\nb = np.array([1.0])\n\n# Box constraint (lb <= x): x >= 0\nlb = np.zeros(3)\n\nx = solve_ls(R, s, A=A, b=b, lb=lb, solver=\"quadprog\")\n\nOn my machine this code finds the solution x = array([0.7760881, 0.0, 0.2239119]). I've uploaded the full code to constrained_linear_regression.py, feel free to try it out.\n", "thanks @sascha for the great answer! the cvxpy example there is pretty out of date, so thought I would provide a slightly different version based on their current API and with some light editing, for clarity:\nimport numpy as np\nimport cvxpy as cp\n\nx1 = np.arange(1000)\nx2 = np.random.normal(size=(1000,))\nx = np.vstack([x1, x2]).T\n\ny = np.random.random_sample(size=(1000,))\n\nprint(\"x shape\", x.shape)\nprint(\"y shape\", y.shape)\n\nweights = cp.Variable(x.shape[1])\n\nobjective = cp.sum_squares(x @ weights - y)\nminimize = cp.Minimize(objective)\n\nconstraints = [weights >= 0, cp.sum(weights) == 1.0]\nproblem = cp.Problem(minimize, constraints)\n\nproblem.solve(verbose=True)\n\nprint(problem.value)\nprint(weights.value)\n\nI'll add that cvxpy is actively managed and the team there seems very responsive.\n" ]

[ 9, 6, 1, 0, 0 ]

[]

[]

[ "linear_regression", "python", "quadratic_programming", "scipy" ]

[ "Try:\nlst = [\n [4, 6, 8, 9, 3],\n [5, 1, 2, 5, 6],\n [1, 9, 4, 5, 7],\n [3, 8, 8, 2, 5],\n [1, 4, 2, 2, 7],\n]\n\nfor row in lst:\n row[:] = range(1, len(row) + 1)\n\nprint(lst)\n\nPrints:\n[\n [1, 2, 3, 4, 5],\n [1, 2, 3, 4, 5],\n [1, 2, 3, 4, 5],\n [1, 2, 3, 4, 5],\n [1, 2, 3, 4, 5],\n]\n\n", "As you tagged your question with numpy, I assume that your source array\nis a Numpy array.\nSo, for the test purpose, you can create it as:\narr = np.array([[4,6,8,9,3],[5,1,2,5,6],[1,9,4,5,7],[3,8,8,2,5],[1,4,2,2,7]])\n\nThen, to fill each row with consecutive numbers, you can run:\narr[:] = np.arange(1, arr.shape[1] + 1)\n\nDue to Numpy broadcasting there is no need to use any loop\nto operate on consecutive rows.\nThe result is:\narray([[1, 2, 3, 4, 5],\n [1, 2, 3, 4, 5],\n [1, 2, 3, 4, 5],\n [1, 2, 3, 4, 5],\n [1, 2, 3, 4, 5]])\n\n" ]

[ 0, 0 ]

[]

[]

[ "arrays", "matrix", "numpy", "python", "row" ]

[ "You can define a custom function for that and apply it on new/existing column,\nlike so:\npd = pd.DataFrame(\n {\"col1\": [1,2,2,3,4],\n \"prices\": [\"1€\", \"2.2€\", \"5€\",\"66€\", \"999€\"]\n }\n)\n\n# Use own function to create custom column\ndef remove_currency_sign(price: str, sign:str = \"€\")->int:\n return int(price.replace(sign,\"\"))\n\npd[\"new_col\"] = pd[\"prices\"].apply(remove_currency_sign)\nprint(pd)\n\n", "When you have data in pandas DataFrame you can do:\n#... your code\n\ndf = pd.DataFrame(all_data)\n\ndf[\"price\"] = df[\"price\"].str.replace(r\"[€,]\", \"\", regex=True)\ndf[\"price\"] = pd.to_numeric(df[\"price\"], errors=\"coerce\")\n\ndf[\"year\"] = pd.to_numeric(df[\"year\"], errors=\"coerce\")\n\nprint(df)\n\nPrints:\n make model year price dealer_name address url feature_speed feature_engine feature_transmission feature_door-icon1 feature_petrol5 feature_hatchback feature_owner feature_paint\n0 BMW 5 Series 2012 14250.0 JOS Jack O Sullivan Cars Co. Wexford https://jammer.ie/vehicle/150168-bmw-5-series-2012 103000 miles 2.0 litres Automatic 0 doors Diesel Saloon NaN NaN\n1 Citroen C3 2003 1999.0 Somerville Motors Co. Meath https://jammer.ie/vehicle/167272-citroen-c3-2003 74000 miles 1.4 litres Automatic 5 doors Petrol Hatchback 8 previous owners Grey\n2 Volkswagen Touareg 2017 29958.0 Holden Motor Company Co. Dublin https://jammer.ie/vehicle/167271-volkswagen-touareg-2017 145000 miles 3.0 litres Automatic 5 doors Diesel SUV 3 previous owners Black\n3 Audi A6 2010 7950.0 Roskeen Cars & Commercials Co. Cork https://jammer.ie/vehicle/167270-audi-a6-2010 174921 miles 2.0 litres Manual 5 doors Diesel Estate 1 previous owners Grey\n4 Volkswagen Passat 2012 6999.0 Somerville Motors Co. Meath https://jammer.ie/vehicle/167269-volkswagen-passat-2012 150000 miles 1.6 litres Manual 4 doors Diesel Saloon 7 previous owners Silver\n5 Vauxhall Insignia 2016 12499.0 ARTHUR AUTO SALES Co. Limerick https://jammer.ie/vehicle/167268-vauxhall-insignia-2016 127000 miles 2.0 litres Manual 5 doors Diesel Hatchback 1 previous owners Black\n6 Audi A6 2022 NaN Audi Approved Plus Kilkenny Co. Kilkenny https://jammer.ie/vehicle/167267-audi-a6-2022 932 miles 2.0 litres Automatic NaN Diesel Saloon NaN Grey\n7 Volkswagen Polo 2018 14999.0 O Neills Car Sales Co. Meath https://jammer.ie/vehicle/167266-volkswagen-polo-2018 73868 miles 1.0 litres Manual 5 doors Petrol Hatchback 1 previous owners White\n8 Audi A1 2022 NaN Audi Approved Plus Kilkenny Co. Kilkenny https://jammer.ie/vehicle/167265-audi-a1-2022 932 miles 1.0 litres Manual NaN Petrol Hatchback NaN Grey\n9 Volkswagen Golf 2014 24999.0 O Neills Car Sales Co. Meath https://jammer.ie/vehicle/167263-volkswagen-golf-2014 82523 miles 2.0 litres Manual 3 doors Petrol Hatchback 1 previous owners Black\n10 Peugeot 5008 2014 13950.0 PRESTIGE AUTOS Co. Dublin https://jammer.ie/vehicle/167260-peugeot-5008-2014 47000 miles 1.6 litres Automatic 5 doors Petrol MPV 1 previous owners White\n11 Audi A4 2014 14950.0 PRESTIGE AUTOS Co. Dublin https://jammer.ie/vehicle/167259-audi-a4-2014 120000 miles 2.0 litres Manual 4 doors Diesel Saloon 2 previous owners White\n12 Volkswagen up! 2013 NaN PRESTIGE AUTOS Co. Dublin https://jammer.ie/vehicle/167257-volkswagen-up-2013 90101 miles 1.0 litres Manual 4 doors Petrol Hatchback 3 previous owners White\n13 Ford Fiesta 2010 5950.0 Car Options Co. Dublin https://jammer.ie/vehicle/111682-ford-fiesta-2010 113144 miles 1.4 litres Manual 5 doors Diesel Hatchback 4 previous owners Silver\n14 Vauxhall Insignia 2015 8950.0 PRESTIGE AUTOS Co. Dublin https://jammer.ie/vehicle/167256-vauxhall-insignia-2015 111849 miles 2.0 litres Manual 0 doors Diesel Hatchback 1 previous owners Black\n15 Nissan X-Trail 2016 18950.0 PRESTIGE AUTOS Co. Dublin https://jammer.ie/vehicle/167255-nissan-x-trail-2016 83887 miles 1.6 litres Manual 4 doors Diesel MPV 2 previous owners White\n16 Hyundai i10 2016 8950.0 PRESTIGE AUTOS Co. Dublin https://jammer.ie/vehicle/167254-hyundai-i10-2016 59031 miles 1.0 litres Manual 4 doors Petrol Hatchback 4 previous owners Silver\n17 Peugeot 3008 2017 23950.0 PRESTIGE AUTOS Co. Dublin https://jammer.ie/vehicle/167253-peugeot-3008-2017 74566 miles 1.6 litres Manual 5 doors Diesel Hatchback 1 previous owners Black\n18 Kia Sportage 2019 NaN Kirwan's Co. Wexford https://jammer.ie/vehicle/167252-kia-sportage-2019 56008 miles 1.6 litres Manual 5 doors Diesel MPV 2 previous owners Grey\n19 Toyota Corolla 2007 2950.0 LPD Commercials Co. Dublin https://jammer.ie/vehicle/167251-toyota-corolla-2007 115000 miles 1.4 litres Manual 5 doors Petrol Hatchback 3 previous owners Blue\n20 Peugeot Partner 2012 5950.0 LPD Commercials Co. Dublin https://jammer.ie/vehicle/167250-peugeot-partner-2012 118000 miles 1.6 litres Manual 5 doors Diesel MPV 3 previous owners Blue\n21 Audi A6 2006 2950.0 LPD Commercials Co. Dublin https://jammer.ie/vehicle/167249-audi-a6-2006 130000 miles 2.0 litres Manual 6 doors Diesel Saloon 3 previous owners Black\n22 Opel Insignia 2011 4950.0 Blue Diamond Cars Co. Cork https://jammer.ie/vehicle/167248-opel-insignia-2011 153000 miles 2.0 litres Manual 4 doors Diesel Saloon 6 previous owners Black\n23 Hyundai Bayon 2023 26545.0 Doran Motors Co. Monaghan https://jammer.ie/vehicle/167247-hyundai-bayon-2023 NaN 1.2 litres Manual 5 doors Petrol SUV NaN Red\n24 Volkswagen Jetta 2014 9950.0 Ballincollig Motor Company / Trident Co. Cork https://jammer.ie/vehicle/167246-volkswagen-jetta-2014 112000 miles 1.2 litres Manual 4 doors Petrol Saloon 2 previous owners Black\n25 Lexus CT 2011 9950.0 Weirs Motors Co. Dublin https://jammer.ie/vehicle/167245-lexus-ct-2011 139210 miles 1.8 litres Automatic 5 doors NaN Hatchback 4 previous owners White\n26 BMW 5 Series 2018 31995.0 Auto Vision Motor Company Co. Dublin https://jammer.ie/vehicle/159883-bmw-5-series-2018 78646 miles 2.0 litres Automatic 4 doors Hybrid Saloon 1 previous owners Grey\n27 Kia N/A 2012 6950.0 Ballincollig Motor Company / Trident Co. Cork https://jammer.ie/vehicle/167244-kia-2012 115000 miles 1.6 litres Manual 3 doors Diesel Hatchback 1 previous owners Grey\n28 Volkswagen Scirocco 2015 18950.0 Weirs Motors Co. Dublin https://jammer.ie/vehicle/167242-volkswagen-scirocco-2015 34928 miles 2.0 litres Manual 3 doors Diesel Coupe NaN Black\n29 Volkswagen Fox 2010 4800.0 Pat & Jason Ryan Co. Waterford https://jammer.ie/vehicle/167241-volkswagen-fox-2010 150095 miles 1.2 litres Manual 3 doors Petrol Hatchback 3 previous owners Grey\n30 Peugeot 3008 2019 30950.0 Gowan Motors Co. Dublin https://jammer.ie/vehicle/167240-peugeot-3008-2019 20989 miles 1.5 litres Automatic 5 doors Diesel SUV 1 previous owners Grey\n31 Volkswagen Beetle 2017 20950.0 Grange Road Motors Co. Dublin https://jammer.ie/vehicle/167239-volkswagen-beetle-2017 39023 miles 1.2 litres Automatic 3 doors Petrol Hatchback 1 previous owners Red\n32 Mercedes-Benz E-Class 2012 13950.0 Car Options Co. Dublin https://jammer.ie/vehicle/167238-mercedes-benz-e-class-2012 119487 miles 2.1 litres Automatic 4 doors Diesel Saloon 2 previous owners Silver\n33 Kia Optima 2016 16500.0 BG Motors Ltd Co. Kerry https://jammer.ie/vehicle/167237-kia-optima-2016 86994 miles 1.7 litres Manual 5 doors Diesel Estate 2 previous owners Black\n34 Volkswagen Beetle 2007 4950.0 Moloney Motors Co. Dublin https://jammer.ie/vehicle/167236-volkswagen-beetle-2007 103150 miles 1.4 litres Manual 2 doors Petrol Convertible 6 previous owners Blue\n35 BMW 5 Series 2019 NaN Cieran McConnon Car Sales Co. Monaghan https://jammer.ie/vehicle/167235-bmw-5-series-2019 34500 miles 2.0 litres Automatic 4 doors Diesel Saloon 1 previous owners Blue\n36 Opel Corsa 2011 6999.0 Michael Tynan Cars Co. Dublin https://jammer.ie/vehicle/167234-opel-corsa-2011 59032 miles 1.2 litres Manual 5 doors Petrol Hatchback 3 previous owners Black\n37 Ford Focus 2018 21999.0 Michael Tynan Cars Co. Dublin https://jammer.ie/vehicle/167233-ford-focus-2018 31691 miles 1.5 litres Manual 4 doors Diesel Hatchback 2 previous owners Blue\n38 Volkswagen Polo 2021 22222.0 Michael Tynan Cars Co. Dublin https://jammer.ie/vehicle/167232-volkswagen-polo-2021 10573 miles 1.0 litres Manual 5 doors Petrol Hatchback 1 previous owners Red\n\n" ]

[ 1, 1 ]

[]

[]

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

[ "You can use groupby's size:\nIn [11]: df.groupby([\"Group\", \"Size\"]).size()\nOut[11]:\nGroup Size\nModerate Medium 1\n Small 1\nShort Small 2\nTall Large 1\ndtype: int64\n\nIn [12]: df.groupby([\"Group\", \"Size\"]).size().reset_index(name=\"Time\")\nOut[12]:\n Group Size Time\n0 Moderate Medium 1\n1 Moderate Small 1\n2 Short Small 2\n3 Tall Large 1\n\n", "Update after pandas 1.1 value_counts now accept multiple columns\ndf.value_counts([\"Group\", \"Size\"])\n\n\nYou can also try pd.crosstab()\nGroup Size\n\nShort Small\nShort Small\nModerate Medium\nModerate Small\nTall Large\n\npd.crosstab(df.Group,df.Size)\n\n\nSize Large Medium Small\nGroup \nModerate 0 1 1\nShort 0 0 2\nTall 1 0 0\n\n\nEDIT: In order to get your out put\npd.crosstab(df.Group,df.Size).replace(0,np.nan).\\\n stack().reset_index().rename(columns={0:'Time'})\nOut[591]: \n Group Size Time\n0 Moderate Medium 1.0\n1 Moderate Small 1.0\n2 Short Small 2.0\n3 Tall Large 1.0\n\n", "Other posibbility is using .pivot_table() and aggfunc='size'\ndf_solution = df.pivot_table(index=['Group','Size'], aggfunc='size')\n\n", "You can use function pd.crosstab() from Pandas. It works the same way as value_counts() but for more than one column.\n" ]

[ 191, 86, 5, 0 ]

[]

[]

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

[ "So I found a working solution.\nWhat I did was to combine Javascript with python Playwright code.\nI start the setInterval with a timer of 200ms to scroll down on the page with page.evaluate() and then I follow it up with a python loop that checks every second whether the total height of the page (scroll included) has changed. If it changes it continues to scroll and if it hasn't changed than the scroll is over.\nThis is what it looks like:\npage.evaluate(\n \"\"\"\n var intervalID = setInterval(function () {\n var scrollingElement = (document.scrollingElement || document.body);\n scrollingElement.scrollTop = scrollingElement.scrollHeight;\n }, 200);\n\n \"\"\"\n)\nprev_height = None\nwhile True:\n curr_height = page.evaluate('(window.innerHeight + window.scrollY)')\n if not prev_height:\n prev_height = curr_height\n time.sleep(1)\n elif prev_height == curr_height:\n page.evaluate('clearInterval(intervalID)')\n break\n else:\n prev_height = curr_height\n time.sleep(1)\n\nEDIT\nSee the below answer using the new mouse.wheel(x, y) feature for an up to date way to scroll using playwright. Combine my answer with his to lessen the need to use JS.\n", "The new Playwright version has a scroll function. it's called mouse.wheel(x, y). In the below code, we'll be attempting to scroll through youtube.com which has an \"infinite scroll\":\nfrom playwright.sync_api import Playwright, sync_playwright\nimport time\n\n\ndef run(playwright: Playwright) -> None:\n browser = playwright.chromium.launch(headless=False)\n context = browser.new_context()\n\n # Open new page\n page = context.new_page()\n\n page.goto('https://www.youtube.com/')\n\n # page.mouse.wheel(horizontally, vertically(positive is \n # scrolling down, negative is scrolling up)\n for i in range(5): #make the range as long as needed\n page.mouse.wheel(0, 15000)\n time.sleep(2)\n i += 1\n \n time.sleep(15)\n # ---------------------\n context.close()\n browser.close()\n\n\nwith sync_playwright() as playwright:\n run(playwright)\n\n", "The other solutions were a tad bit verbose and \"overkill\" for me and this is what worked for me.\nHere's a two liner that took me a few migraines to come around to :)\nNote: you are going to have to put in your own selector. This is just an example...\n while page.locator(\"span\",has_text=\"End of results\").is_visible() is False:\n page.mouse.wheel(0,100)\n #page.keyboard.down(PageDown) also works\n\nLiterally just keep scrolling until some sort of unique selector is present. In this case a span tag with the string \"End of results\" (for the context of my use case) popped up when you scroll to the bottom.\nI trust you can translate this logic for you own usage..\n", "the playwright has the page.keyboard.down('End') command, it will scroll to the end of the page.\n" ]

[ 12, 5, 1, 0 ]

[ "This topic old, but new to me. I have been using the playwright wheel scroll but for me it takes control/focus on the mouse.\nSo if I happen to be typing (which i usually am) and it scrolls, my beautiful words go into the void to never be seen again.\nI am going to go ahead and try out the js solution posted above and see if that gets me around the mouse/focus issue.\n" ]

[ -2 ]

[ "javascript", "playwright", "python", "python_3.x" ]

[ "try to change \"mandelbrot\" function to\ndef mandelbrot(x, y):\n c0 = complex(x, y)\n c = 0\n for i in range(1, 1000):\n if abs(c) > 2:\n return (0, 0, 0)\n c = c * c + c0\n return (0, 255, 255)\n\nFinal return statement is a background color\n" ]

[ 1 ]

[]

[]

[ "mandelbrot", "python" ]

[ "TL;DR:\nThat can be a oneliner:\nmax_price = df[df[\"h_price\"] == \"mansion\"]][\"h_price\"].max()\n\nExplanation\nA little bit of explaining here:\ndf[df[\"h_price\"] == \"mansion\"]]\n\nThat pieces selects all the rows who's column \"h_price\" value is the maximum.\ndf[df[\"h_price\"] == \"mansion\"]][\"h_price\"]\n\nThen, we access the column \"h_price\" of all the rows.\nFinally\ndf[df[\"h_price\"] == \"mansion\"]][\"h_price\"].max()\n\nWill return the maximum value for that column (amongs all rows).\n" ]

[ 0 ]

[]

[]

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

[ "You need to convert raw byte string to Python dict first, assuming that you are using Python version 3.6+ and your response object is either string or bytes:\nimport json\n\ndata = json.loads(response) # loads() decodes it to dict\ntemp = response['_items'] \n\n" ]

[ 4 ]

[]

[]

[ "json", "python" ]

[ "Edit: figured how to do it by myself\nAdd another annotation like this, although it gives the text at the upper left corner of the graph,works for me. Just add this code instead of the previous annotation code in the question,the rest of the code remains the same.These dimensions work for the particular alignment mentioned.\nfig.add_annotation(\n showarrow=False,\n text=\"23 paths over 450 updates\",\n font=dict(size=15),\n xref='paper',\n x=0.014,\n yref='paper',\n y=1.077\n )\n\n" ]

[ 1 ]

[]

[]

[ "plotly", "python" ]

[ "The code does not make much sense in Stata.\nWhat doesn't make sense is that the over-arching command\nif inlist(nid, 4580, 4250, 165101, 4679, 236205, 419098, 438439, 11240, 317089, 430032, 3716, 164729) \n\ncan in Stata only apply to the first observation (case, record, row) in the dataset.\nIn other words. it means in practice\nif inlist(nid[1], 4580, 4250, 165101, 4679, 236205, 419098, 438439, 11240, 317089, 430032, 3716, 164729) \n\nas a condition attaching to the rest of the code.\nThe rest of the code says: if such and such a variable exists, overwrite its value with 0 in every observation; otherwise create it with 0 in every observation.\nWhat is perhaps more likely is the original programmer was confusing the if command (used here) and the if qualifier.\nI'd put a prior probability near 1 on this code and whatever it comes with as being not worth translation until it is checked.\n" ]

[ 1 ]

[]

[]

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

[ "So consider logically what you have to do, then write that algorithmically.\nLogically, you have a list of words, a list of broken letters, and you need to return the count of words that have none of those broken letters in them.\n\"None of those broken letters in them\" is the important bit -- if even one broken letter is in the word, it's no good.\ndef count_words(broken_letters, word_list) -> int:\n words = word_list.split() # split on spaces\n broken_letters = set(broken_letters) # we'll be doing membership checks\n # on this kind of a lot, so changing\n # it to a set is more performant\n count = 0\n for word in words:\n for letter in word:\n if letter in broken_letters:\n # this word doesn't work, so break out of the\n # \"for letter in word\" loop\n break\n else:\n # a for..else block is only entered if execution\n # falls off the bottom naturally, so in this case\n # the word works!\n count += 1\n\n return count\n\nThis can, of course, be written much more concisely and (one might argue) idiomatically, but it is less obvious to a novice how this code works. As exercise to the reader: see if you can understand how this code works and how you might modify it if the exercise was, instead, giving you all the letters that work rather than the letters that are broken.\ndef count_words(broken_letters, word_list) -> int:\n words = word_list.split()\n broken_letters = set(broken_letters)\n return sum((1 for word in words if all(lett not in broken_letters for lett in word)))\n\n" ]

[ 0 ]

[]

[]

[ "python" ]

[ "You can use the widget attribute of the event object. It is a reference to the widget that got the event.\ndef handleEvent2(self,event):\n a = event.widget.get()\n print(a)\n\n", "You can use the event.widget attribute to get a reference to the widget that triggered the event.\n", "Since you are using tkinker,\nevent.widget will contain what you want.\nSorry for short reply, navigating from mobile.\n" ]

[ 2, 1, 0 ]

[]

[]

[ "python", "tkinter" ]

[ "i is indexing the row in d=m[i][j]*v[j], but your loop is over the number of columns. You could eliminate errors like that and make the code cleaner by looping directly over the rows. Instead of for i in range (c): you'd have for row in m: and d=row[j]*v[j]. You should also take advantage of the sum function to do the dot products. Combining these you end up replacing\nfor i in range (c):\n re=0\n for j in range(len(v)):\n d=m[i][j]*v[j]\n re+=d\n print('[',re,']')\n\nwith\nfor row in m:\n re=sum(row[j] * v[j] for j in range(v)]\n print('[',re,']')\n\nIf you really need an incrementing index then enumerate is the function that can provide it, for example:\nfor i, row in enumerate(m):\n re=sum(row[j] * v[j] for j in range(v)]\n print(f'{i}. [{re}]')\n\n" ]

[ 0 ]

[]

[]

[ "linear_algebra", "python" ]

[ "You can try to put ? after the prefix which will cause the expression not to match as much of the text as possible\n(?:DB2.Database)(?:\\s|\\S)*?\n\nThen the following\n(?:DB2.Database)(((?:\\s|\\S)*?(?:\\s+(JOIN|FROM)\\s+)(\\w+\\.\\w+))+)\n\nwould almost work but re module doesn't support repeated captures\nAs a workaround, running the original regex (?:\\s+(FROM|JOIN)\\s+)(\\w+\\.\\w+) with the first matched group should give you the desired result.\n", "Simple implemention of the solution proposed by @radof\nimport re\nimport pandas\n\ntext =\"\"\"let\n Source = DB2.Database(\"\"69.69.69.69\"\", \"\"bcudb\"\", [HierarchicalNavigation=true, Implementation=\"\"Microsoft\"\", Query=\"\"SELECT i.ASSIGNMENT_GROUP, i.BUSINESS_SERVICE, i.CATEGORY, i.CAUSED_BY, i.CLOSE_CODE, i.CLOSED_ON, i.COMPANY, i.CONTACT_TYPE, i.DESCRIPTION, i.NUMBER, i.PARENT_INCIDENT, i.PRIORITY, i.RESOLVED_ON, i.SHORT_DESCRIPTION, i.CREATED_ON, i.CAUSE_CODE, i.CLOSED, i.CREATED, i.RESOLVED, i.RESOLUTION_MET, p.problem_id FROM EDWP_D2PM.SN_INC_RPTG_SCRUBBED i LEFT OUTER JOIN EDWP_D2PM.SN_INCIDENTS_CUST_RPTG p on p.number = i.number WHERE i.PRIORITY INLEFT OUTER JOIN EDWP_D2PM.SN_INCIDENTS_CUST_RPTG ('1 - Critical', '2 - High') AND TO_CHAR(i.created_on,'YYYY-MM') > (select to_char((CURRENT DATE - 12 MONTHS),'YYYY-MM') from SYSIBM.SYSDUMMY1) AND (i.CATEGORY <> 'Alert' OR (i.CATEGORY IS NULL)) AND i.PARENT_INCIDENT IS NULL AND i.EXCLUSIONS <> 'R' AND i.CLOSE_CODE <> 'Duplicate - No Action Taken' with ur\"\"]), RIGHT JOIN EDWP.TEMP blaha blah\n #\"\"Changed Type\"\" = Table.TransformColumnTypes(Source,{{\"\"RESOLVED_ON\"\", type datetime\n #filler \n filler\n filler\n filler\n }})\nin\n #\"\"Changed Type\"\"\"\n\nDB2_pattern = re.compile(r'(DB2.Database)(?:\\s|\\S)*', re.IGNORECASE)\nSchema_Table = re.compile(r'(?:\\s+JOIN\\s+)(\\w+\\.\\w+)|(?:\\s+FROM\\s+)(\\w+\\.\\w+)', re.IGNORECASE)\n\nDB2_matches = DB2_pattern.finditer(text)\nfor constring in DB2_matches:\n db2=constring.group()\n #print(db2)\n matches = Schema_Table.finditer(db2)\n for i in matches:\n tables=i.group()\n print(tables)\n\n" ]

[ 0, 0 ]

[]

[]

[ "python", "regex", "regex_group" ]

[ "The error message you attached is pretty clear:\n\nin line 23, either paymentsTable[i][k] or paymentsTable[k+1][j]\nhas an index out of range.\n\npaymentsTable has exactly leng elements, so their valid indices go from 0 to leng-1.\nEvery element paymentsTable[i] is also a list with exactly leng elements, so their valid indices also go from 0 to leng-1.\nNow, i ranges inside range(leng), but j is ranging over (range(1, leng + 1)), which means the first value will be 1 and the last will be leng.\nHence, in the last iteration of for j in range(1,leng+1), j is leng and the last valid index of paymentsTable[i] was leng-1, so you get the \"IndexError: list index out of range\"\nMoreover, k+1 also gets the value leng in the last iteration of that line, it is also out of range, considering that the last valid index of paymentsTable is also leng.\n", "I haven't tried this yet but I think the problem is with the row assignment. paymentsRow and idTableRow must be created outside the for a loop. Your implementation means it loops through and appends, but after appending, it makes the list empty again. So basically in your code, paymentsRow and idTableRow have only one element in them.\n[UPDATE]\nI integrated Rodrigo's solution with mine and no errors appeared.\ntotal_task=float(input(\"Enter the assigned total task length(in half-hour(s)):\"))\ntotal_len=total_task*2\nleng=int(total_len)\npayments=[]\nhours=[]\nfor i in range(leng):\n print(\"Enter the payment value( in TL) for task portion ID \",(i+1),\" having length \",((i+1)*0.5),\" hour(s):\")\n portionLen=int(input())\n payments.append(portionLen)\n hours.append(portionLen)\npaymentsTable=[]\npaymentsRow=[]\nfor i in range(leng):\n for j in range(leng):\n paymentsRow.append(0)\n paymentsTable.append(paymentsRow)\nfor i in range(leng):\n paymentsTable[i][i]=payments[i]\nfor i in range(leng):\n for j in range(1,leng):\n maxPayment=0\n for k in range(j):\n pay=paymentsTable[i][k]+paymentsTable[k+1][j]\n if(pay>maxPayment):\n maxPayment=pay\n paymentsTable[i][j]=maxPayment\nidTable=[]\nidTableRow=[]\n\nfor i in range(leng):\n for j in range(leng):\n idTableRow.append(0)\n idTable.append(idTableRow)\nfor i in range(leng):\n idTable[i][i]=i+1\nfor i in range(leng):\n for j in range(1,leng):\n maxPayment=0\n for k in range(j):\n pay = paymentsTable[i][k] + paymentsTable[k + 1][j]\n if (pay > maxPayment):\n maxPayment = pay\n paymentsTable[i][j] = maxPayment\nfor i in range(leng):\n for j in range(1,leng):\n maxPayment=0\n for k in range(j):\n pay = paymentsTable[i][k] + paymentsTable[k + 1][j]\n if (pay > maxPayment):\n maxPayment = pay\n idTable[i][j]=k+1\n\n" ]

[ 2, 0 ]

[]

[]

[ "arrays", "multidimensional_array", "python" ]

[ "Using awk:\n$ awk '{print $1,($2+0>1000?1000:$2)}' file\n\nOutput:\nName Value\nABV 1000\nCCD 1000\nCAD 500\nDDD 1000\n\n", "A few issues with OP's current code:\n\nneed to skip processing of the first line\n-gt is invalid in awk ... use > instead\n-F, says to use the comma as the input field delimiter but the sample input file does not contain commas; for now I'm going to assume the sample input file is correct (ie, there are no commas)\n\nUpdating OP's current code to address these issues:\nawk 'NR==1 {print $0; next} {if ($2 > 1000) {$2=1000} {print $0}}' book1.csv\n\nOr an equivalent:\nawk 'NR>1 && ($2>1000) {$2=1000} 1' book1.csv\n\nBoth of these generate:\nName Value\nABV 1000\nCCD 1000\nCAD 500\nDDD 1000\n\n" ]

[ 2, 1 ]

[]

[]

[ "awk", "bash", "python", "shell" ]

[ "Instead of the dirname function for grouping you have to create your own function which can look like\nimport os.path\n\ndef grouper(path):\n d, f = os.path.split(path)\n f = f.split('-')[0]\n return d, f\n\nIt returns a tuple with the directory and the relevant part of the filename.\nIt can be used in the same way as you did already in your code:\nfrom itertools import groupby\nsorted_by_file = [list(g) for _,g in groupby(paths, grouper)]\n\n" ]

[ 2 ]

[]

[]

[ "python" ]

[ "i['displayName'] = \"Name Surname\"\n\njsonFile.write(json.dumps(i))\n\n" ]

[ 0 ]

[]

[]

[ "json", "python" ]

[ "I would like to correct you in your usage of the term Variable . Airflow attributes a special meaning to this object. What you want is for the file info to be accessible as parameters in a task.\nUse XCom\nAssume you have the DAG with the python task called -- list_files_from_gcs.\nThis task is a python task which exactly runs the collect_path function that you have written. Since this function returns a list, airflow automatically stuffs this into XCom. So now you can access this information anywhere in your DAG in subsequent tasks.\n\nNow your subsequent task can again be a python task in the same DAG which case you can access XCom very very easily:\n@task\ndef next_task(xyz, abc, **context):\n ti = context['ti']\n files_list = ti.xcom_pull(task_ids='list_files_from_gcs')\n ...\n ...\n\n\nIf you are now looking to call an entirely different DAG now, then you can use TriggerDagRunOperator as well and pass this list as dag_run config like this:\nTriggerDagRunOperator(\n conf={\n \"gcs_files_list\": \"{{task_instance.xcom_pull(task_ids='list_files_from_gcs'}}\"\n },\n ....\n ....\n)\n\nThen your triggered DAG can just parse the DAG run config to move ahead.\n\n\n" ]

[ 1 ]

[]

[]

[ "airflow", "apache_beam", "google_cloud_composer", "google_cloud_dataflow", "python" ]

[ "I solved it adding one more conditional\nfor replace, lower in zip(l_replace, list_category_lower): \n globals()['%s' % replace] = folium.FeatureGroup(lower)\n variable = globals()['%s' % replace]\n #temp = variable.layer_name\n for feature in data_geo.data['features']:\n\n category = feature['properties']['Category']\n\n if category == None:\n category = 'No Value'\n category = category.lower()\n\n if feature['properties']['Country'] == 'Canada': \n for i in list_category_lower:\n if i == variable.layer_name:\n if category == i: \n folium.Marker(location=list(reversed(feature['geometry']['coordinates'])),\n icon=folium.Icon(color=\"green\",icon='info-sign'), \n popup=\"<b>Timberline Lodge</b>\",\n tooltip = feature['properties']['Category'],\n #Categoria=feature['properties']['entidad']\n ).add_to(variable)\n (globals()['%s' % replace]).add_to(m) \n\nfolium.LayerControl().add_to(m) \nm.save('demo.html')\n\nm\n\n" ]

[ 1 ]

[]

[]

[ "folium", "layer", "loops", "maps", "python" ]

[ "The Python developers had the same idea, they just put the option after the command:\npython setup.py install --force\n\nThe distutils documentation doesn't mention the --force option specifically, but you can find it by using the --help option:\npython setup.py --help install\n\n", "Go to the setup.py directory and I simply use:\npip install .\n\nIt works for me.\n", "In my case, I have to remove the build and dist folders\nrm -rf build\nrm -rf dist\npython3 setup.py install\n\n" ]

[ 53, 4, 0 ]

[]

[]

[ "distutils", "installation", "overwrite", "python" ]

[ "import numpy as np # Import NumPy\nimport matplotlib.pyplot as plt # Import the matplotlib.pyplot module\n\nvector = np.array([[-3,7,12,4,0o2,7,-3],\n [7,7,12,4,0o2,4,12],\n [12,-3,4,10,12,4,-3],\n [10,12,4,0o3,7,10,12]])\n\nrows, columns = vector.shape\nplt.title(\"Scatter plot\") # Set the title of the graph\nplt.xlabel(\"Column #\") # Set the x-axis label\nplt.ylabel(\"Occurences of values for each column\") # Set the y-axis label\nplt.xlim([1,columns]) # Set the limits of the x-axis\nplt.ylim([-5,15]) # Set the limits of the y-axis\n\nfor i in range(1, columns+1):\n y = vector[:,i-1]\n x = [i] * rows\n plt.plot(x, y, \"r.\")\n\nplt.show()\n\n" ]

[ 1 ]

[]

[]

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

[ "Slicing a ctypes pointer will generate a Python list of the contents. Since a pointer has no knowledge of how many items it points to, you'll need to know the size, usually through another parameter:\n>>> import ctypes as ct\n>>> f = (ct.c_float * 4)(1,2,3,4)\n>>> f\n<__main__.c_float_Array_4 object at 0x00000216D6B7A840>\n>>> f[:4]\n[1.0, 2.0, 3.0, 4.0]\n\nHere's a fleshed-out example based on your code:\ntest.c\n#include <stdlib.h>\n\n#ifdef _WIN32\n# define API __declspec(dllexport)\n#else\n# define API\n#endif\n\nstruct Floats {\n float *fptr;\n size_t size;\n};\n\nAPI struct Floats *alloc_floats(float *fptr, size_t size) {\n struct Floats *pFloats = malloc(sizeof(struct Floats));\n pFloats->fptr = fptr;\n pFloats->size = size;\n return pFloats;\n}\n\nAPI void free_floats(struct Floats *pFloats) {\n free(pFloats);\n}\n\ntest.py\nimport ctypes as ct\n\nclass Floats(ct.Structure):\n _fields_= (('fptr', ct.POINTER(ct.c_float)), # Pointer, not array.\n ('size', ct.c_int)) # Used to know the size of the array pointed to.\n # Display routine when printing this class.\n # Note the slicing of the pointer to generate a Python list.\n def __repr__(self):\n return f'Floats({self.fptr[:self.size]})'\n\ndll = ct.CDLL('./test')\ndll.alloc_floats.argtypes = ct.POINTER(ct.c_float), ct.c_size_t\ndll.alloc_floats.restype = ct.POINTER(Floats)\ndll.free_floats.argtypes = ct.POINTER(Floats),\ndll.free_floats.restype = None\n\ndata = (ct.c_float * 4)(1.0, 2.0, 3.0, 4.0)\np = dll.alloc_floats(data, len(data))\nprint(p.contents)\ndll.free_floats(p)\n\nOutput:\nFloats([1.0, 2.0, 3.0, 4.0])\n\n" ]

[ 0 ]

[]

[]

[ "arrays", "c", "ctypes", "pointers", "python" ]

[ "Try to find this element using driver.find_element(By.CSS_SELECTOR \"CSS_SELECTOR\")and simply copy selector of element in page inspection section\n" ]

[ 0 ]

[]

[]

[ "python", "selenium" ]

[ "Using the awesome Pillow library:\n>>> from PIL import Image \n>>> img = Image.open('test.png')\n>>> img.show() \n\nThis will open the image in your default image viewer.\n", "In a new window using Pillow/PIL\nInstall Pillow (or PIL), e.g.:\n$ pip install pillow\n\nNow you can\nfrom PIL import Image\nwith Image.open('path/to/file.jpg') as img:\n img.show()\n\nUsing native apps\nOther common alternatives include running xdg-open or starting the browser with the image path:\nimport webbrowser\nwebbrowser.open('path/to/file.jpg')\n\nInline a Linux console\nIf you really want to show the image inline in the console and not as a new window, you may do that but only in a Linux console using fbi see ask Ubuntu or else use ASCII-art like CACA.\n", "Since you are probably running Windows (from looking at your tags), this would be the easiest way to open and show an image file from the console without installing extra stuff like PIL.\nimport os\nos.system('start pic.png')\n\n", "In Xterm-compatible terminals, you can show the image directly in the terminal. See my answer to \"PPM image to ASCII art in Python\"\n\n", "Or simply execute the image through the shell, as in \nimport subprocess\nsubprocess.call([ fname ], shell=True)\n\nand whatever program is installed to handle images will be launched.\n", "Why not just display it in the user's web browser?\n", "If you would like to show it in a new window, you could use Tkinter + PIL library, like so:\nimport tkinter as tk\nfrom PIL import ImageTk, Image\n\ndef show_imge(path):\n image_window = tk.Tk()\n img = ImageTk.PhotoImage(Image.open(path))\n panel = tk.Label(image_window, image=img)\n panel.pack(side=\"bottom\", fill=\"both\", expand=\"yes\")\n image_window.mainloop()\n\nThis is a modified example that can be found all over the web.\n", "You cannot display images in a console window.\nYou need a graphical toolkit such as Tkinter, PyGTK, PyQt, PyKDE, wxPython, PyObjC, or PyFLTK.\nThere are plenty of tutorials on how to create simple windows and loading images in python.\n", "You can also using the Python module Ipython, which in addition to displaying an image in the Spyder console can embed images in Jupyter notebook. In Spyder, the image will be displayed in full size, not scaled to fit the console. \nfrom IPython.display import Image, display\ndisplay(Image(filename=\"mypic.png\"))\n\n", "I made a simple tool that will display an image given a filename or image object or url.\nIt's crude, but it'll do in a hurry.\nInstallation:\n $ pip install simple-imshow\n\nUsage:\nfrom simshow import simshow\nsimshow('some_local_file.jpg') # display from local file\nsimshow('http://mathandy.com/escher_sphere.png') # display from url\n\n", "If you want to open the image in your native image viewer, try os.startfile:\nimport os\n\nos.startfile('file')\n\nOr you could set the image as the background using a GUI library and then show it when you want to. But this way uses a lot more code and might impact the time your script takes to run. But it does allow you to customize the ui. Here's an example using wxpython:\nimport wx\n \n########################################################################\nclass MainPanel(wx.Panel):\n \"\"\"\"\"\"\n \n #----------------------------------------------------------------------\n def __init__(self, parent):\n \"\"\"Constructor\"\"\"\n wx.Panel.__init__(self, parent=parent)\n self.SetBackgroundStyle(wx.BG_STYLE_PAINT) # Was wx.BG_STYLE_CUSTOM)\n self.frame = parent\n \n sizer = wx.BoxSizer(wx.VERTICAL)\n hSizer = wx.BoxSizer(wx.HORIZONTAL)\n \n for num in range(4):\n label = \"Button %s\" % num\n btn = wx.Button(self, label=label)\n sizer.Add(btn, 0, wx.ALL, 5)\n hSizer.Add((1,1), 1, wx.EXPAND)\n hSizer.Add(sizer, 0, wx.TOP, 100)\n hSizer.Add((1,1), 0, wx.ALL, 75)\n self.SetSizer(hSizer)\n self.Bind(wx.EVT_ERASE_BACKGROUND, self.OnEraseBackground)\n \n #----------------------------------------------------------------------\n def OnEraseBackground(self, evt):\n \"\"\"\n Add a picture to the background\n \"\"\"\n # yanked from ColourDB.py\n dc = evt.GetDC()\n \n if not dc:\n dc = wx.ClientDC(self)\n rect = self.GetUpdateRegion().GetBox()\n dc.SetClippingRect(rect)\n dc.Clear()\n bmp = wx.Bitmap(\"file\")\n dc.DrawBitmap(bmp, 0, 0)\n \n \n########################################################################\nclass MainFrame(wx.Frame):\n \"\"\"\"\"\"\n \n #----------------------------------------------------------------------\n def __init__(self):\n \"\"\"Constructor\"\"\"\n wx.Frame.__init__(self, None, size=(600,450))\n panel = MainPanel(self) \n self.Center()\n \n########################################################################\nclass Main(wx.App):\n \"\"\"\"\"\"\n \n #----------------------------------------------------------------------\n def __init__(self, redirect=False, filename=None):\n \"\"\"Constructor\"\"\"\n wx.App.__init__(self, redirect, filename)\n dlg = MainFrame()\n dlg.Show()\n \n#----------------------------------------------------------------------\nif __name__ == \"__main__\":\n app = Main()\n app.MainLoop()\n\n(source code from how to put a image as a background in wxpython)\nYou can even show the image in your terminal using timg:\nimport timg\n\nobj = timg.Renderer() \nobj.load_image_from_file(\"file\")\nobj.render(timg.SixelMethod)\n\n(PyPI: https://pypi.org/project/timg)\n", "2022:\nimport os\n\nos.open(\"filename.png\")\n\nIt will open the filename.png in a window using default image viewer.\n", "You can use the following code:\nimport matplotlib.pyplot as plt\nimport matplotlib.image as mpimg\n%matplotlib inline\nimg = mpimg.imread('FILEPATH/FILENAME.jpg')\nimgplot = plt.imshow(img)\nplt.axis('off')\nplt.show()\n\n", "Displaying images in console using Python\nFor this you will need a library called ascii_magic\nInstallation : pip install ascii_magic\nSample Code :\nimport ascii_magic\n\nimg = ascii_magic.from_image_file(\"Image.png\")\nresult = ascii_magic.to_terminal(img)\n\n\nReference : Ascii_Magic\n", "The easiest way to display an image from a console script is to open it in a web browser using webbrowser standard library module.\n\nNo additional packages need to be installed\n\nWorks across different operating systems\n\nOn macOS, webbrowser directly opens Preview app if you pass it an image file\n\n\nHere is an example, tested on macOS.\n import webbrowser\n\n # Generate PNG file\n path = Path(\"/tmp/test-image.png\")\n with open(path, \"wb\") as out:\n out.write(png_data)\n\n # Test the image on a local screen\n # using a web browser.\n # Path URL format may vary across different operating systems,\n # consult Python manual for details.\n webbrowser.open(f\"file://{path.as_posix()}\")\n\n" ]

[ 77, 12, 10, 8, 7, 6, 6, 5, 3, 2, 1, 1, 0, 0, 0 ]

[]

[]

[ "image", "python" ]

[ "The following command helped me solve this problem:\npip install --upgrade PyQt6\n\n" ]

[ 0 ]

[]

[]

[ "import", "pyqt", "pyqt6", "python" ]

[ "Well, your solution is not bad. There are a few things I would suggest to improve.\nIterate over sub-dictionaries directly\nYou don't seem to use the keys (object_id) at all, so you might as well iterate via dict.values.\nNo need for the issue variable\nYou can just return your flag once an \"issue\" is found and otherwise return the opposite at the end of the loop.\nReduce indentation\nUse continue in the loop, if the vehicle_type is not present to reduce indentation.\nDecide what assumptions are sensible\nIf you know that each vehicle sub-dictionary will have the lead key and the one below that will have the version key (which you imply by using dict.get multiple times without checking for None first), just use regular dictionary subscript notation ([]).\nNo need for the class dictionary\nIf you are checking a specific vehicle type when calling your function anyway, there is no need for that dictionary (as far as I can tell). You just need a local variable to hold the last known version number for that type.\nSemantics\nThis may be a matter of personal preference, but I would design the function to return True, if everything is \"fine\" and False if there is a mismatch somewhere.\nSpecify type arguments\nIf you already take the time to use type annotations, you should take the time to specify your generics properly. Granted, in this case it may become unwieldy, if your dictionary nesting gets much deeper, but in that case you can still at least use dict[str, Any].\nUse constants for repeating keys\nTo reduce the room for error, I like to define constants for strings that have fixed meaning in my code and are used repeatedly. That schema seems to be more or less fixed, so you can define the keys once and then use the constants throughout the code. This has the added benefit that it will be very easy to fix, if the schema does change for some reason and one of the keys is renamed (e.g. from version to ver or something like that).\nObviously, in this super simple situation this is overkill, but if you refer to the same keys in more places throughout your code, I highly suggest adopting this practice.\nSuggested implementation\nKEY_LEAD = \"lead\"\nKEY_VERSION = \"version\"\n\ndef versions_consistent(\n vehicle_type: str,\n data: dict[str, dict[str, dict[str, dict[str, str]]]]\n) -> bool:\n version_found: str | None = None\n for vehicles in data.values():\n vehicle = vehicles.get(vehicle_type)\n if vehicle is None:\n continue\n if version_found is None:\n version_found = vehicle[KEY_LEAD][KEY_VERSION]\n elif version_found != vehicle[KEY_LEAD][KEY_VERSION]:\n return False\n return True\n\nBonus\nYou might consider performing an additional check at the end, to see if version_found is still None. That might indicate that an invalid vehicle_type was passed (e.g. due to a typo). In that case you could raise an exception.\nAs an alternative, if you know the vehicle types in advance, you can avoid this by defining them again as constants ahead of time and then checking at the beginning of the function, if a valid type was passed.\nFinally, you could consider not just returning a bool, but actually saving the mismatches/inconsistencies in some data structure and returning that to indicate which IDs had which versions for a specified vehicle type.\nSo it could also look something like this:\nALLOWED_VEHICLES = {\"car\", \"bike\", \"jet_ski\"}\n\ndef get_version_id_mapping(\n vehicle_type: str,\n data: dict[str, dict[str, dict[str, dict[str, str]]]]\n) -> dict[str, set[str]]:\n if vehicle_type not in ALLOWED_VEHICLES:\n raise ValueError(f\"{vehicle_type} is not a valid vehicle type\")\n version_id_map: dict[str, set[str]] = {}\n for obj_id, vehicles in data.items():\n vehicle = vehicles.get(vehicle_type)\n if vehicle is None:\n continue\n ids = version_id_map.setdefault(vehicle[\"lead\"][\"version\"], set())\n ids.add(obj_id)\n return version_id_map\n\nCalling get_version_id_mapping(\"bike\", d) (d being your example data) gives the following:\n\n{'2.2': {'tigj09j32f0j2'}, '2.3': {'fj983j2r9jfjf'}}\n\nCalling it for jet_ski gives this:\n\n{'3.3': {'fj983j2r9jfjf', 'tigj09j32f0j2'}}\n\nSo by checking the length of the output dictionary, you would see, if there is an inconsistency (length > 1) or not.\nBonus 2\nCome to think of it, if you want to do this check for every type of vehicle for the entire dataset anyway, this can all be done in one go:\ndef vehicle_type_versions(\n data: dict[str, dict[str, dict[str, dict[str, str]]]]\n) -> dict[str, dict[str, set[str]]]:\n output: dict[str, dict[str, set[str]]] = {}\n for obj_id, vehicles in data.items():\n for vehicle_type, vehicle_data in vehicles.items():\n sub_dict = output.setdefault(vehicle_type, {})\n ids = sub_dict.setdefault(vehicle_data[\"lead\"][\"version\"], set())\n ids.add(obj_id)\n return output\n\nCalling this on your example data yield the following output:\n\n{'bike': {'2.2': {'tigj09j32f0j2'}, '2.3': {'fj983j2r9jfjf'}},\n 'car': {'1.1': {'fj983j2r9jfjf', 'tigj09j32f0j2'}},\n 'jet_ski': {'3.3': {'fj983j2r9jfjf', 'tigj09j32f0j2'}}}\n\n", "def is_version_issue(vehicle_type: str, object_json: dict):\n current_object = object_json[object_id]\n for object_id in current_object:\n if vehicle_type in object_json[object_id]:\n current_vehicle_version = current_object[vehicle_type][\"lead\"][\"version\"]\n # vehicles is a class dictionary that contains the vehicles I am looking for\n if self.vehicles[vehicle_type]:\n if self.vehicles[vehicle_type] != current_vehicle_version:\n return True\n return False\n\nNo I think this is the most logical way I think you have some redundancy but this makes sense to me. Aslo some other problems with you not being clear about how you are using the dict.\nI would also not use the temp current_ variables but they are good if you are using a debugger.\n" ]

[ 2, 1 ]

[]

[]

[ "dictionary", "python" ]

[ "Try with !expr\n ```{r}\n #| label: fig-example\n #| fig-cap: !expr params$txt\n plot(1:10, 1:10)\n ```\n\n-output\n\n\nIf we need to add some text, either paste or use glue\n#| fig-cap: !expr glue::glue(\"This should be {params$txt}\")\n\n" ]

[ 3 ]

[]

[]

[ "python", "quarto", "r" ]

[ "After updating the code on the EC2 instance, you need to build a new web docker image from that new code. If you are just restarting things then docker-compose is going to continue to pick up the last docker image you built.\nYou need to run the following sequence of commands (on the EC2 instance):\ndocker-compose build web\ndocker-compose up -d\n\n\nYou are seeing the static files change immediately, without rebuilding the docker image, because you are mapping to those files via docker volume.\n", "I found the issue... it was because I had template caching.\nIf I remove the cache and do what @MarkB suggested, all is updating.\nI don't understand why this happens since I tried flushing all redis cache after changes but I guess it solves my issues.\n" ]

[ 0, 0 ]

[]

[]

[ "amazon_web_services", "django", "nginx", "python", "redis" ]

[ "Full answer is here\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport matplotlib.colors as colors\nfrom matplotlib import cm\n\ndelta = 0.01\nx = np.arange(0, 4.001, delta)\ny = np.arange(0.0, 4.001, delta)\nX, Y = np.meshgrid(x, y)\nZ = X**2 + Y**2\n\nfig = plt.figure(figsize=(6,3))\nax = fig.add_subplot(121)\nm1 = plt.contourf(Z, cmap=cm.seismic, levels=np.arange(0,33,1), norm=colors.TwoSlopeNorm(vmin=0, vmax=32, vcenter=1), extend='max')\nplt.colorbar(m1)\n\nax = fig.add_subplot(122)\nm1 = plt.pcolormesh(Z, cmap=cm.seismic, norm=colors.TwoSlopeNorm(vmin=0, vmax=32, vcenter=1))\ncb = plt.colorbar(m1, extend='max', spacing='proportional')\ncb.ax.set_yscale('linear')\n\nplt.tight_layout()\nplt.show()\n\n\n" ]

[ 0 ]

[]

[]

[ "matplotlib", "python" ]

[ "I am also just starting my deep-in NL and interested in learning.\nFirst:\nWould recommend first to get in details with 2 good examples that are well implemented and explained:\n\nFlappy Bird 2. Google Dinosaur.\nBoth have game code + NEAT implementation tied together.\nGoogle search will give plenty of examples.\n\nSecond: as per your question.\nPer my mind no any NL would be able to solve it in such example.\nJust because there are no 'good and enough' input data. It will always be just 50/50 per poor probability theory.\nIn order to make NEAT work, need to have some input data and some type of output data, and that output data should be a consequence of a 'choise' based on input data, hope it not get too complicated, but in one word should be some kind of dependency of input data and actions that should be taken to achieve valuable output data.\nMore exactly:\nin your case, as input data you have a choosed random number - that ok. But you have no any data, parameters based on which that random number is actually choosed.\nThis data needed in order to let NEAT create genomes that will make tries, calculations, fits...in order to find best parameters for its model, to get a good guess.\nThat why NL model can not be constructed.\nHope all makes sense and happy to discuss if interested.\n" ]

[ 0 ]

[]

[]

[ "neat", "python" ]

[ "ida_dbg.send_dbg_command() is exactly what I needed.\n" ]

[ 0 ]

[]

[]

[ "console", "ida", "python", "scripting", "windbg" ]

[ "My problem is almost solve there is one issue. I can't get the next, previous and last option in pagination but soon I'll figure it out.\nthis is my views.py file coding\ndef car(request):\n all_products = None \n all_category = category.get_all_category()\n categoryid = request.GET.get('category')\n if categoryid:\n all_products = Product.get_all_products_by_id(categoryid)\n else:\n all_products = Product.get_all_products()\n #pagination\n paginator = Paginator(all_products,3)\n page_number=request.GET.get('page')\n finaldata=paginator.get_page(page_number)\n\n totalpage=finaldata.paginator.num_pages\n\n \n data = {'all_products':finaldata,\n 'lastpage':totalpage,\n 'totalPageList':[n+1 for n in range(totalpage)]}\n\n data['products'] = finaldata #all products\n\n \n data['category'] = all_category #all category\n all_products = Product.get_all_products()\n data['product'] = all_products\n \n return render(request, 'car.html', data)\n\nThis is my html coding\nmy html file screenshot\nI'm sharing html screenshot due to this error\nYour post appears to contain code that is not properly formatted as code. Please indent all code by 4 spaces using the code toolbar button or the CTRL+K keyboard shortcut. For more editing help, click the [?] toolbar icon.\nIt looks like your post is mostly code; please add some more details.\nI'm not familiar with stack overflow so I don't know what to do so I shared screenshot\nwhen I find any solution for first previous and last option then soon I'll share that here\n", "Based on pagination documentation, it would be something similar to this:\n(Always explore the framework documentation, it is the best source to learn)\nviews.py\nfrom django.core.paginator import Paginator\nfrom django.shortcuts import render\n\ndef car(request, category_id=None):\n products = Products.objects.all() \n\n if category_id:\n products = Product.objects.filter(category__id=category_id)\n\n paginator = Paginator(products, 3)\n\n page_number = request.GET.get('page')\n page_obj = paginator.get_page(page_number)\n\n context = {\n 'page_obj': page_obj\n }\n\n return render(request, 'car.html', context)\n\ntempate.html (where you access previous and next pages, and total number of pages)\n{% for car in page_obj %}\n {{ car.category }}<br>\n ...\n{% endfor %}\n\n<div class=\"pagination\">\n <span class=\"step-links\">\n {% if page_obj.has_previous %}\n <a href=\"?page=1\">&laquo; first</a>\n <a href=\"?page={{ page_obj.previous_page_number }}\">previous</a>\n {% endif %}\n\n <span class=\"current\">\n Page {{ page_obj.number }} of {{ page_obj.paginator.num_pages }}.\n </span>\n\n {% if page_obj.has_next %}\n <a href=\"?page={{ page_obj.next_page_number }}\">next</a>\n <a href=\"?page={{ page_obj.paginator.num_pages }}\">last &raquo;</a>\n {% endif %}\n </span>\n</div>\n\nurls.py (you want to pass category_id, if you don't it will be none)\npath('cars/category/<int:category_id>/', views.car, name='car'),\n\n" ]

[ 0, 0 ]

[]

[]

[ "django", "pagination", "python" ]

[ "You may need string formatting.\ndepartment_names = [\"n1\", \"n2\", \"n3\", \"n4\"]\ndepartment_numbers = [1, 2, 3, 4]\nproduct_variables = [\"p1\", \"p2\", \"p3\", \"p4\"]\n\nfor department_name, department_number, product_variable in zip(department_names, department_numbers, product_variables):\n print(f\"'+' {department_name}, ({department_number}, {product_variable})\")\n\nOutput:\n'+' n1, (1, p1)\n'+' n2, (2, p2)\n'+' n3, (3, p3)\n'+' n4, (4, p4)\n\n", "l1= [\n {'id': '2', 'name': 'Sou', 'Medicine': 'Paracetamol'},\n {'id': '2', 'name': 'Sou', 'Medicine': 'Supradyn'},\n {'id': '3', 'name': 'Roopa', 'Medicine': 'Revital'},\n {'id': '3','name': 'Roopa', 'Medicine': 'Pain killer'},\n {'id': '4','name': 'Tabu', 'Medicine': 'Vitamin C'}\n \n]\n\ndef mergeListOfDictionaries1(l1):\n dn = {}\n for d in l1:\n if d['id'] in dn:\n if isinstance(dn[d['id']]['Medicine'],list):\n dn[d['id']]['Medicine'].append(d['Medicine'])\n else:\n dn[d['id']]['Medicine'] = [dn[d['id']]['Medicine'],d['Medicine'] ]\n \n else:\n dn[d['id']] = d\n \n return list(dn.values()) \n \naa= mergeListOfDictionaries1(l1)\nprint(aa)\n\n\"\"\"\n[{'id': '2', 'name': 'Sou', 'Medicine': ['Paracetamol', 'Supradyn']}, \n{'id': '3', 'name': 'Roopa', 'Medicine': ['Revital', 'Pain killer']}, \n{'id': '4', 'name': 'Tabu', 'Medicine': 'Vitamin C'}]\n\n\"\"\"\n\n import itertools, pandas as pd\n \n l1 = [\"n1\", \"n2\", \"n3\", \"n4\"]\n l2 = [1, 2, 3, 4]\n l3 = [\"p1\", \"p2\", \"p3\", \"p4\"]\n \n \n nest = [l1,l2,l3] \n cc = pd.DataFrame(\n (x for x in itertools.zip_longest(*nest))\n )\n print(cc)\n\"\"\"\nOutput : \n 0 1 2\n0 A 1 P\n1 B 2 Q\n2 C 3 R\n\"\"\"\n\n\n\n for l1,l2,l3 in zip(l1,l2,l3):\n print(l1 , '+',l2 , '+', l3)\n\"\"\"\nPrint all and put a plus sign in between so that the output becomes\nA + 1 + P\nB + 2 + Q\nC + 3 + R\nD + 4 + S\n\"\"\"\n\nNow If we want to zip and Print Alternate words from different lists.\nOutput :\n[('A', 1, 'P'), ('B', 2, 'Q'), ('C', 3, 'R'), ('D', 4, 'S')]\nThen,\n l1 = [\"A\", \"B\", \"C\", \"D\"]\n l2 = [1, 2, 3, 4]\n l3 = [\"P\", \"Q\", \"R\", \"S\"]\n \n \n def zipAlternate(list1,*rest,fillvalue=None):\n rest = [iter(r) for r in rest]\n for x in list1:\n res = yield x, *[next(r,fillvalue) for r in rest]\n return res \n zz = zipAlternate(l1,l2,l3)\n zzl = list(zz)\n print(zzl) \n\"\"\"\nOutput :\n[('A', 1, 'P'), ('B', 2, 'Q'), ('C', 3, 'R'), ('D', 4, 'S')]\n \n\nNow if few Strings are given.\nl1 = 'ABCDE',\nl2 = '12',\nl3 = 'PQXYZ'\nand we want the output as 'A1PB2QC'.\nl1 = 'ABCDE'\nl2 = '12'\nl3 = 'PQXYZ'\ndef zipAlternateString(*allString):\n rest = [iter(r) for r in allString]\n str= ''\n while True:\n for r in rest:\n try : \n str += next(r)\n except StopIteration:\n return str \n return str \n \naa = zipAlternateString(l1,l2,l3)\nprint(aa) \n\"\"\"\n Output :\n A1PB2QC\n\"\"\"\n\n\n\nd1 = {'A': 'a', 'B': 'b'}\nd2 = {'A': 'c', 'B': 'd'}\nd3 = {'A': 'e', 'B': 'f'}\n\naa = {\n \n k : [d1.get(k),d2.get(k),d3.get(k)] for k in d1.keys() | d2.keys() | d3.keys() \n \n }\n\nprint(aa)\n\n\"\"\"\n{'A': ['a', 'c', 'e'], 'B': ['b', 'd', 'f']}\n\n\"\"\"\n\n\nl12= ['A','1','B','2']\n\ni = iter(l12)\nl122 = dict(zip(i,i))\nprint(l122)\n\"\"\"\n{'A': '1', 'B': '2'}\n\"\"\"\n\ns = \"banana 4 apple 2 orange 4\"\n\nl1 = s.split()\nprint(l1)\n\"\"\"\n['banana', '4', 'apple', '2', 'orange', '4']\n\"\"\"\n\ni= iter(l1)\ndict1 = dict(zip(i,i))\nprint(dict1) #{'banana': '4', 'apple': '2', 'orange': '4'}\n\n" ]

[ 0, 0 ]

[]

[]

[ "python", "string", "zip" ]

[ "You need to count all the lists that contain at least once the number one. To do that you can't use any other module.\ndef count_none_zero_items(matrix):\n count = 0\n for row in matrix:\n if 1 in row:\n count += 1\n return count\n\n\nx = [[0, 0, 0, 0], [1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 0]]\ncount_none_zero_items(x)\n\nAlso notice that i changed the function name to lower case as this is the convention in python. Read more about it here:\nPython3 Conventions\nAlso it's worth mentioning that in python we call the variable list instead of array.\n", "Those look like tuples, not arrays. I tried this myself and if I change the tuples into nested arrays (adding outer brackets and commas between the single arrays), this function works:\ndef xArrayCount(MX):\n x = 0\n count = 0\n\n for i in matrix:\n if MX[count][count] == 0:\n count += 1\n else:\n x += 1\n count += 1\n\n return x\n\n" ]

[ 8, 0 ]

[]

[]

[ "arrays", "python" ]

[ "Since you're ingesting JSON, you can do the key replacement right in the parse phase for a faster and simpler experience using the object_pairs_hook argument to json.loads.\nimport json\n\nkey_mapping = {\n \"name\": \"noot\",\n \"age\": \"doot\",\n \"relation\": \"root\",\n}\n\n\ndef lambda_handler(events, _):\n replaced_events = json.loads(\n events[\"body\"],\n object_pairs_hook=lambda pairs: dict(\n (key_mapping.get(k, k), v) for k, v in pairs\n ),\n )\n return {\n \"statusCode\": 200,\n \"body\": json.dumps(replaced_events),\n }\n\n\nbody = {\n \"name\": \"michael\",\n \"age\": 35,\n \"family\": {\"name\": \"john\", \"relation\": \"father\"},\n}\nprint(\n lambda_handler(\n {\n \"body\": json.dumps(body),\n },\n None,\n )\n)\n\nprints out\n{'statusCode': 200, 'body': '{\"noot\": \"michael\", \"doot\": 35, \"family\": {\"noot\": \"john\", \"root\": \"father\"}}'}\n\n" ]

[ 1 ]

[]

[]

[ "amazon_web_services", "aws_lambda", "python", "python_3.x", "recursion" ]