quote:

Username (userID1) 2021-07-14 14:49:22
wtf are you reading?
Username (userID2) 2021-07-14 14:49:22
nothing go away
Username (userID1) 2021-07-14 14:49:22
guys, erek is reading 50 shades of grey
lets all laugh and point at him
Username (userID2) 2021-07-14 14:49:22
50 Shades of Grey is a book not a series
I think
To google!
Username (userID1) 2021-07-14 14:49:22
wrong
there is like 3 books
Username (userID2) 2021-07-14 14:49:22
ew
there are three-...
How'd you know that...
Username (userID1) 2021-07-14 14:49:22
I um
uhh
gotta go!

quote:

defaultdict(<class 'list'>, {'Username (userID1)': ['wtf are you reading?', 'guys, erek is reading 50 shades of grey', 'lets all laugh and point at him', 'wrong', 'there is like 3 books', 'I um', 'uhh', 'gotta go!'], 'Username (userID2)': ['nothing go away', '50 Shades of Grey is a book not a series', 'I think', 'To google!', 'ew', 'there are three-...', "How'd you know that..."]})

QuarkJets posted:

Too simple for Python??? Yeah, probably. I like writing python so here's a crack at it anyway:

Jose Cuervo posted:

I am running into an issue. I have a Jupyter notebook which contains code that I want to run multiple times using different parameters. The table in the SQLite3 database from which the data will be pulled depends on a parameter passed in (there is one table with 4 hour data, one table with 6 hour data, and one table with 8 hour data). From reading stackoveflow posts (for example this one) it looks like the table name cannot be parameterized. The reasoning behind this is that they want to prevent SQL injection.

There are ways around this:

Python code:

select_str = f'SELECT SID, start_dt FROM tss_{tss_length_hrs}hr'
trlnt_SDTs = c.execute(f'{select_str} WHERE study_name == "trlnt"').fetchall()

where I create the select string first and then use it in the query.

I understand this is bad practice in general, but in this particular context where I am the user and will be supplying the tss_length_hrs string which will not be malicious, it should be ok, right?

QuarkJets posted:

SQL Injection is only possible if you accept unsanitized user input, there is nothing wrong with what you've written here. Put the f-string directly into the execute statement if you want, even. Just so long as you control the content of 'tss_length_hrs' and aren't just slamming in whatever a user provides. Dictionary dispatch would work well for that

Jose Cuervo posted:

Can you elaborate on what you mean by dictionary dispatch and also explain why it would work well in this context?

QuarkJets posted:

Sure, say that you want a user to be able to select which table is queried via a command line argument. Passing input directly to the query is dangerous because it would leave you vulnerable to SQL injection, but you can easily pass that value to a dictionary that maps to only valid names:

Python code:

user_input = sys.argv[1] # or use argparse
table_name = {'table1': 'table1',
              'table2': 'table2_with_nulls,
              'usernames': 'usernames'}[user_input]

This is dictionary dispatch; it's just mapping some input to a set of outputs. You could use the table_name variable here to build a SQL query without issue, because you know the valid table names already. If an invalid table name is provided then an exception is raised. If someone tries to attack you with an SQL injection input then it just dies at this dictionary lookup

Harik posted:

question: is handling command dispatch via getattr(self, 'command_' + command, self.unknown_command) remotely sane? It's a tossup between that and dict dispatch but
the latter has 3 times the boilerplate.

QuarkJets posted:

I try to avoid use of `getattr`, but there are rare circumstances where it makes sense. Can you provide a more complete example of what you're thinking about?

Harik posted:

Sure, it'd be something like

Python code:

class foo:
    def command_hello(self, data):
        # ... do something


    def unknown_command(self, data):
        # ...  return an error

    def process_command(self, command, data):
        func = getattr(self, 'command_' + command, self.unknown_command)
        func(data)

The dict version would be:

Python code:

class foo:
    command_lookup = {
        'hello': self.command_hello,
    }

    def command_hello(self, data):
        # ... do something


    def unknown_command(self, data):
        # ...  return an error

    def process_command(self, command, data):
        func = self.command_lookup.get(command, self.unknown_command))
        func(data)

I "coded" these both in the input textbox but that's the rough idea.

e: obviously there's a lot more going on with async callbacks and state and access checks, but none of that was really relevant to the core question.

e2: I guess the same could be achieved in __init__ by iterating over self and creating a dict of all the methods that startwith('command_')

QuarkJets posted:

Yeah iterating over the methods would be a cool way to implement this without resorting to getattr. Is this for a CLI? Have you looked at dispatch?

Harik posted:

I'd never spent any thought on default arguments before, and when they're bound, etc.

Python code:

def fart(a, butt=[]):
    butt.append(a)
    print(butt)
    
fart('a')
fart('b')

pre:

['a']
['a', 'b']

It took me a minute of headscratching before I realized exactly when the default argument was initialized, then I laughed because it's perfectly logical, reasonable, and unexpected.


question: is handling command dispatch via getattr(self, 'command_' + command, self.unknown_command) remotely sane? It's a tossup between that and dict dispatch but
the latter has 3 times the boilerplate.

duck monster posted:

That honestly feels like a bad design decision on pythons behalf. Almost worth reporting it as a bug. Principle of least surprise and all that.

duck monster posted:

That honestly feels like a bad design decision on pythons behalf. Almost worth reporting it as a bug. Principle of least surprise and all that.

StumblyWumbly posted:

I have a Python memory management and speed question: I have a Python program where I'm going to be reading in a stream of data and displaying the data received over the last X seconds. Data outside that window can be junked, I'd like to optimize for speed first, and size second. I know how I'd do this in C, but I'm not sure about Python memory management.
The data are going to be in a live updating graph, so accessing it contiguously would be good.

I have my own ideas about circular buffers or offset pre-allocated buffers, but I have the feeling Python has something off the shelf that will handle this well. Does anything like that exist?

Jabor posted:

Does python not have an arraydeque of any kind? It shouldn't be O(n) just to read items by index in the middle.

QuarkJets posted:

Assuming you're referring to Java's arraydeque, Python's equivalent is just called deque: https://docs.python.org/3/library/collections.html#collections.deque

quote:

Indexed access is O(1) at both ends but slows to O(n) in the middle.

StumblyWumbly posted:

I have a Python memory management and speed question: I have a Python program where I'm going to be reading in a stream of data and displaying the data received over the last X seconds. Data outside that window can be junked, I'd like to optimize for speed first, and size second. I know how I'd do this in C, but I'm not sure about Python memory management.
The data are going to be in a live updating graph, so accessing it contiguously would be good.

I have my own ideas about circular buffers or offset pre-allocated buffers, but I have the feeling Python has something off the shelf that will handle this well. Does anything like that exist?

Jabor posted:

This doesn't look like an arraydeque to me. It should have O(1) indexed access (as long as you're just peeking at elements and not adding/removing).

Jabor posted:

This doesn't look like an arraydeque to me. It should have O(1) indexed access (as long as you're just peeking at elements and not adding/removing).

quote:

Write a function `def product_except_self(nums):` that takes in a list of integers `nums` and returns a list of integers where each element is the product of all the numbers in `nums` except the one at that index.

Example:

Input: `[1, 2, 3, 4]`
Output: `[24, 12, 8, 6]`

Seventh Arrow posted:

Soylent Majority posted:

Thats the basic poo poo I need - now I have something far less dumb:

code:

num_vals = int(input())
numbers = []
normalized = []
for vals in range(num_vals):
    numbers.append(float(input()))
largest = float(max(numbers))
for x in numbers:
    normalized.append(float(x / largest))

for y in normalized:
    print(f'{y:.2f}')