On Friday, December 30, 2022 at 02:20:10 PM MST, T. Zack Crawford via PLUG-discuss <plug-discuss@lists.phxlinux.org> wrote:
I don't really know what your question is or what you are trying to do,
but I'll mention my immediate thoughts on what you wrote.
Python is a very strong language and you can do A LOT with it. It is
very popular in data science and for web applications via flask. It
excels in writing abstracted code efficiently. It can be less terse than
other languages but it is usually easy to follow. It is less good than
other language for writing applications that are very demanding for
performance or need to be especially snappy.
The built-in data structures in python are very strong. The dictionary
is incredibly useful. The list() is technically a linked list but is
very stack-like. I don't know how they work exactly but there are built
in optimizations so you don't have to think too much on if you are using
a particular type of array. Obviously numpy is the most relevant module
for arithmetic operations. There are VERY rare cases you might have a
performance boost by using modules with more "correct" stack data
structures. Pandas is a good package for SQL-like tables. And if you are
familiar with writing SQL queries, consider using pandasql. It sounds
like you plan on working with binary trees, I'm not sure what the best
module is for your use case. There is a binarytree module. Hashlib is
pretty much the only other module with data strutures I have used
frequently. You aren't implementing something that will have enough data
to warrant utilizing a spark (distributed computing) database.
I have quite a few informative jupyter notebooks that might be useful.
But they are on my desktop at home. You should directly email me in a
couple days and maybe I can share some code/notes on data structures or
data-science or web development topics.
Zack
z@tzcrawford.comOn 22/12/30 01:37PM, trent shipley via PLUG-discuss wrote:
> Python UTF8 Treeview Project Feedback Request
>
> I want to move beyond classroom assignments and Exercism.org toy exercises
> and start work on my own project. A major motivation is to have something
> to show if I make it to an interview for a software curation and writing
> job.
>
> This kind of view of a file tree is everywhere in Python documentation. It
> would seem there is a utility, but I haven't been able to find it.
>
> /home/user/Projects/flask-tutorial
> ├── flaskr/
> │ ├── __init__.py
> │ ├── db.py
> │ ├── schema.sql
> │ ├── auth.py
> │ ├── blog.py
> │ ├── templates/
> │ │ ├── base.html
> │ │ ├── auth/
> │ │ │ ├── login.html
> │ │ │ └── register.html
> │ │ └── blog/
> │ │ ├── create.html
> │ │ ├── index.html
> │ │ └── update.html
> │ └── static/
> │ └── style.css
> ├── tests/
> │ ├── conftest.py
> │ ├── data.sql
> │ ├── test_factory.py
> │ ├── test_db.py
> │ ├── test_auth.py
> │ └── test_blog.py
> ├── venv/
> ├── setup.py
> └── MANIFEST.in
>
> (
https://flask.palletsprojects.com/en/2.2.x/tutorial/layout/ retrieved
> 2022-12-16)
>
> What I have discovered is that writing your own program to make this kind
> of ASCII representation of a file tree is a classic classroom assignment.
> You write a simple general tree, you do recursion, you have to get the
> output just right. It's not a bad little class assignment for a data
> structures and algorithms second semester.
>
> So I'm thinking I can put the ASCII tree classroom assignment on steroids
> and gold plate it.
>
> It would be nice to do a general implementation in C++, Rust, or Java, but
> I'm spending a lot of time in Python at work. Since Python is pretty
> friendly, I can probably produce a Python version with less effort than in
> other languages. It might turn out to be a useful utility run from the
> Python command or as a library, and it would then serve as a prototype for
> an attempt in a more rigorous and generally applicable language.
>
> *LAYERS*
>
> The project will have Python CLI and library interfaces. For example, it
> might take a parameters such as start=top-left or start=top-center
>
> Working from the output layer down, we have the layer which formats and
> emits the file system as a pretty-printed UTF8 file. By way of gold
> plating, the program could have front ends which pretty-print in HTML,
> LibreOffice Writer, and PDF. Although it looks like ASCII representations
> of file trees can be generated on the fly with a lexically ordered
> depth-first traversal of the tree, there could be a tree structure and a
> tree builder. Then a tree formatter gets the populated tree collection or
> data structure. It walks the intermediate tree using a canned algorithm
> provided as a parameter, the links/edges in the tree represent the tree's
> structure, and the tree's nodes have default string representations which
> will be printed as the nodes of the ASCII graphic.
>
>
> *THE MISSING PYTHON LIBRARY*
>
>
> The back of the library should be a utility which provides a general tree
> data structure as a container or collection and functions providing
> depth-first and breadth-first algorithms to traverse the tree. I thought
> there would certainly be a mature, robust, definitive library wrapping
> optimized, long-used C implementations of the top 25 data structures and
> their associated algorithms integrated into the Python ecosystem. What I
> managed to find was one recent library, implemented in Python with few
> tests and little documentation (alltrees 1.2.4
>
https://pypi.org/search/?q=alltrees&o= accessed 2022-12-16). I didn't
> find anything with specialized implementations of things like singly linked
> lists or stacks which can be emulated by under-using Python's built-in
> dictionaries, lists, sets, and tuples.
>
> If there really isn't much in PyPI providing pure implementations of
> classic data structures, then one could fill that space first by creating a
> library of (inefficient) pure Python implementations of the desired data
> structure containers, and then complementing the Python implementation with
> a library providing wrappers around well-proven open-source implementations
> of data structures written in C, and tooling the integration well enough
> that using the resulting Python packages members provide idiomatic Python
> syntax. The data structure collections, while more specialized than
> dictionaries, lists, sets, and tuples, would probably be reasonably useful
> for hard-core Pythonistas. It's actually a much better project than the
> walk-and-pretty-print-a-tree project I started out with. Unfortunately,
> The only C I even had was learned kind of in passing when I took one
> semester of C++ in 1999, and except for sometimes reading a code snippet, I
> haven't used it since.
>
>
> I'm soliciting thoughts, feedback, and comments.
> ---------------------------------------------------
> PLUG-discuss mailing list:
PLUG-discuss@lists.phxlinux.org> To subscribe, unsubscribe, or to change your mail settings:
>
https://lists.phxlinux.org/mailman/listinfo/plug-discuss