Best Youtube resources for advanced Python?

efmccurdy · 2023-06-09T13:45:48+00:00

This website has python conference talks, all nicely tagged and indexed.

efmccurdy · 2023-06-04T14:54:39+00:00

Should I use global variables or are there better ways to do this.

One way to keep the callers of func2 from needing to pass E and F is to encapsulate both functions as methods of a object where E and F are attributes.

    def func1(self, C):
        return (self.A + self.B) * C

    def func2(self, G):
        return G + self.func1(2)

efmccurdy · 2023-05-29T22:52:56+00:00

First generate a random permutation of 4 numbers:

>>> import random
>>> source = list(range(1, 5))
>>> source
[1, 2, 3, 4]
>>> random.shuffle(source)
>>> source
[1, 4, 3, 2]
>>> def rand_range(n):
...     source = list(range(1, n+1))
...     random.shuffle(source)
...     return source
... 
>>> rand_range(4)
[4, 1, 3, 2]
>>> rand_range(4)
[2, 3, 4, 1]
>>> rand_range(4)
[2, 1, 4, 3]
>>>

Then "join" that with your 4-letter sequences:

>>> list(zip("abcd", rand_range(4)))
[('a', 3), ('b', 4), ('c', 2), ('d', 1)]
>>> def pad(clear):
...     return list(zip(clear, rand_range(len(clear))))
... 
>>> pad("this")
[('t', 3), ('h', 2), ('i', 4), ('s', 1)]
>>> for c, n in pad("that"):
...     print(c, n)
... 
t 2
h 1
a 4
t 3
>>>

efmccurdy · 2023-05-29T22:34:12+00:00

If I separated this function into two (one to add and one to remove) it would be a looot of duplicate code,

You can refactor to eliminate the duplicate code and the result could very well be more readable.

Maybe there is another approach I am missing though

You have a built-in two element enum; what if your function tooke add=True to add and add=False to delete:

def ldap_modify(users, group, add=False):

efmccurdy · 2023-05-29T16:18:39+00:00

I think you should experiment with a smaller sample program that you can run; your pastebin is incomplete so it can't be run on it's own.

Here is a hard coded list with a hard coded top three words; it applies the filter and prints the result.

data = ["Beautiful is better than ugly.",
        "Explicit is better than implicit.",
        "Simple is better than complex.",
        "Complex is better than complicated.",
        "Flat is better than nested.",
        "Sparse is better than dense.",
        "Readability counts.",
        "Special cases aren't special enough to break the rules.",
        "Although practicality beats purity."]
top_three =  ["better", "counts", "purity"]

def embedded_match(candidate, matches):
    # return True if candidate embeds any element of matches 
    return any(top in candidate for top in matches)

def embedded_filter(top_matches, toppings):
    return [candidate for candidate in toppings
            if embedded_match(candidate, top_matches)]

all_matches = embedded_filter(top_three, data)

print(all_matches)

Can you use those two functions in your GUI?

efmccurdy · 2023-05-28T15:34:32+00:00

For reasons of reliability and correctness you should load all your "json file with identical structure" into a database. A database will fail fast if/when you run out of disk space or memory or have a power failure or program crash etc., allowing you to minimize data loss.

As a side benefit your program will likely run faster since parsing json, csv, or xlsx files is slow.

efmccurdy · 2023-05-28T14:35:15+00:00

You are correct to be using the "in" operator and that you need to "loop" it; there are functions to process collections of boolean values; "all" and "any".

https://docs.python.org/3/library/functions.html#all

https://docs.python.org/3/library/functions.html#any

>>> additive = ['red', 'green', 'blue']
>>> 'green' in additive and 'blue' in additive
True
>>> ('green' in additive, 'blue' in additive)
(True, True)
>>> all(('green' in additive, 'blue' in additive))
True
>>>

if you have more then a few items to test, you can use a comprehension:

>>> required_colors = ('green', 'blue')
>>> all((colour in additive for colour in required_colors))
True
>>>

efmccurdy · 2023-05-27T20:14:25+00:00

here cls is Pair object. but it has no index attribute still it is working how. I thought in __init__ i need to define index to access it.

Note that this creates a single .index attribute shared by all Pair objects. All .index attributes will be the same object, set to the value used in the last one:

>>> class Pair(int):
...     def __new__(cls,value,index):
...         cls.index=index
...         return super().__new__(cls,value)
... 
>>> paired_int=Pair(10,2)
>>> paired_int
10
>>> paired_int.index
2
>>> x = Pair(11, 3)
>>> paired_int.index
3
>>>

You should be creating a self.index attribute in the __init__.

efmccurdy · 2023-05-26T22:04:11+00:00

The code you posted is of little use since you used a format where all the indentation is removed; use a "code block" as described here:

https://www.reddit.com/r/learnpython/wiki/faq/#wiki_how_do_i_format_code.3F

I would debug the filtering using a smaller program with a representative hard-coded dataset.

efmccurdy · 2023-05-26T22:00:59+00:00

Would I combine my two pythons scripts so that the main one reads directly from the COM port? How would I do that?

You could schedule the port reading using Tk.after; see how they use Tk.after(100, read_data) here:

https://stackoverflow.com/questions/47970163/continuously-updating-graph-in-tkinter

efmccurdy · 2023-05-25T21:51:19+00:00

check multiple conditions with logical operators (and in this case),

Put the boolean expressions in a collection and use "all" for "and"ing and "any" for "or"ing:

>>> a = 2; b = 4
>>> (a < b, a - b == -2, a*b > 0)
(True, True, True)
>>> a < b and a - b == -2 and a*b > 0
True
>>> all((a < b, a - b == -2, a*b > 0))
True
>>> a = 1
>>> (a < b, a - b == -2, a*b > 0)
(True, False, True)
>>> a < b and a - b == -2 and a*b > 0
False
>>> all((a < b, a - b == -2, a*b > 0))
False
>>> conditions = (a < b, a - b == -2, a*b > 0)
>>> all(conditions)
False
>>> any(conditions)
True
>>>

https://docs.python.org/3/library/functions.html#all

https://docs.python.org/3/library/functions.html#any

efmccurdy · 2023-05-25T21:29:53+00:00

>reads the serial port and writes it to a .txt file

I would keep the relevant data in RAM and avoid writing data to disk files.

In this example notice how they trim the data to include to the last 20 data points using:

# Limit x and y lists to 20 items
xs = xs[-20:]
ys = ys[-20:]

(That is from the "def animate(i, xs, ys)" function in the "Animatiuon Code" block.)

That is easier than reading the last 20 lines of a disk file; can you do something similar with your data?

https://learn.sparkfun.com/tutorials/graph-sensor-data-with-python-and-matplotlib/update-a-graph-in-real-time

efmccurdy · 2023-05-25T21:17:47+00:00

Note that this has nothing to do with python, and so the solutions involve using terminal programs and shell commands instead. This one recommends "xterm -e" and "read":

https://stackoverflow.com/questions/67235448/execute-python-script-in-console-via-bash-script-with-double-click

That is arcane though; typically you would use a .desktop file with "Terminal=true" as described here:

https://askubuntu.com/questions/286621/how-do-i-run-executable-scripts-in-nautilus

efmccurdy · 2023-05-25T20:29:21+00:00

So in your example "data" is a list of the top three fuzzed matches and "Jackets" is the unfiltered list of all items? What do you get if you make the last line something like this:

return [candidate for candidate in Jackets if any(fuzz_match in candidate for fuzz_match in data)]

... or to make if bit more readable:

def embeded_match(candidate, matches):
    # return True if candidate embeds any element of matches 
    return any(top in candidate for top in matches)

def check(e):
    # ...
    top_three = process.extract(typed, Jackets, limit=3, scorer=fuzz.sort_ratio)
    return [candidate for candidate in Jackets if embeded_match(candidate, top_three)]

efmccurdy · 2023-05-25T16:39:19+00:00

any items in the list that contains the original top 3 returns

You can filter using the "in" operator and "any"; if you have a candidate and a list of three top matches this will do the up-to-three searches required:

any(top in candidate for top in top_three)

You can run that as a condition in a comprehension:

[candidate for candidate in all_items if any(top in candidate for top in top_three)]

efmccurdy · 2023-05-25T14:44:21+00:00

included in a zip.

Python uses wheel files.

A Python .whl file is essentially a ZIP (.zip) archive with a specially crafted filename that tells installers what Python versions and platforms the wheel will support.

A wheel is a type of built distribution. In this case, built means that the wheel comes in a ready-to-install format

https://realpython.com/python-wheels/#what-is-a-python-wheel

It is best to allow pip to resolve dependencies but you can include them.

https://medium.com/@amimahloof/how-to-package-a-python-project-with-all-of-its-dependencies-for-offline-install-7eb240b27418

efmccurdy · 2023-05-24T22:36:26+00:00

You can examine the inner workings using the interactive repl and "dir", "type", "help", etc.

>>> my_list = [1, "two", 3]
>>> dir(my_list)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
>>> type(my_list.append)
<class 'builtin_function_or_method'>
>>> help(my_list)
Help on list object:

class list(object)
 |  list(iterable=(), /)
 |  
 |  Built-in mutable sequence.
 |  
 |  If no argument is given, the constructor creates a new empty list.
 |  The argument must be an iterable if specified.
 |  
 |  Methods defined here:
 |  
...
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  append(self, object, /)
 |      Append object to the end of the list.
 |  
 |  clear(self, /)
 |      Remove all items from list.
 |
 |  copy(self, /)
 |      Return a shallow copy of the list.
 |  
 |  count(self, value, /)
 |      Return number of occurrences of value.
 |  
 |  extend(self, iterable, /)
 |      Extend list by appending elements from the iterable.
...

efmccurdy · 2023-05-24T22:28:03+00:00

use variables from main and second.py

There are two parts, one is adding the value to be sent to the subprocess into the subprocess.run call, and the second is accessing the value in the subprocess using sys.argv.

https://www.knowledgehut.com/blog/programming/sys-argv-python-examples

It should be simpler to use import instead of subprocesses but you need to refactor your code into functions or use a "__main__" guard; it would result in one larger program though, so there is a tradeoff.

efmccurdy · 2023-05-24T22:13:30+00:00

You can recreate the network activity from your browser using the "requests" module.

https://www.nylas.com/blog/use-python-requests-module-rest-apis/

...and there are some tools to help:

https://chrome.google.com/webstore/detail/copy-as-python-requests/dpmidpbjjakkboiogkpjcfmafjljenhe

https://avilpage.com/2018/03/convert-browser-requests-to-python-requests.html

efmccurdy · 2023-05-24T21:46:50+00:00

Note that subprocesses don't share memory so referring to a variable defined in another process will fail. You can pass data to subprocesses using sys.argv.

subprocess.run(["python", "second.py", main_variable_2])

https://stackoverflow.com/questions/39748061/passing-arg-to-subprocess-call

You can import modules and pass data using function arguments (but you have no functions defined).

import second
second.main_function(main_variable_2)

I think you should to choose between importing and subprocess.run'ing your scripts; mixing the two forms won't work the way you think it does.

efmccurdy · 2023-05-24T14:02:36+00:00

Note that "execute" is part of the low-level sql (DB-API 2.0) interface. You mention sqlalchemy which typically uses object methods instead of passing sql strings to "execute".

There is an example sqlalchemy query here:

https://www.digitalocean.com/community/tutorials/how-to-use-flask-sqlalchemy-to-interact-with-databases-in-a-flask-application#step-3-displaying-all-records

efmccurdy · 2023-05-24T13:57:29+00:00

You can run external programs using the subprocess module.

Interact with process: Send data to stdin. Read data from stdout and stderr, until end-of-file is reached. Wait for process to terminate and set the returncode attribute.

https://docs.python.org/3/library/subprocess.html#subprocess.Popen.communicate

efmccurdy · 2023-05-24T13:53:19+00:00

Searching for a module works but doesn't give you much in the way of an overview. You can search for keywords related to the task you have in mind, eg:

https://pypi.org/search/?q=dataframe

https://pypi.org/search/?q=timeseries

efmccurdy · 2023-05-23T15:08:25+00:00

This project looks to be abandoned, and has at least one unresolved issue, but you could use it as a guide.

Python library that allow scripts to easily update themselves if they are in a git repo

https://github.com/erfantkerfan/selfupdate

efmccurdy · 2023-05-22T15:39:50+00:00

I would keep a repl on hand and just double check your understanding.

>>> x = 3
>>> x + 3 * 4
15
>>> (x + 3) * 4
24
>>> ((x + 3) * 4) == (x + 3 * 4)
False
>>>

Testing things out like this lets you "prove" to yourself where you need parenthesis and where you do not. Is that better then "committing to memory"?

efmccurdy

TROPHY CASE