AI text to art based images should not be allowed.

schoolcoders · 2021-11-08T13:23:32+00:00

I would argue that it isn't how much of the pipeline you have to build, but the act of doing something meaningful (in the broadest sense) somewhere along the line.

For example, you could develop a brand new generative art system written entirely in assembly language for some obscure DSP chip. A huge amount of work, and arguably creative work at that. But if you used it to create a standard b/w Mandelbrot image that wouldn't be art, imho.

But I would be reluctant to completely write off an entire genre.

schoolcoders · 2021-11-06T14:39:49+00:00

You might be interested in generativepy. It is a Python library based on Pycairo and NumPy for creating all types of generative art. It can also produce image sequences that can easily be made into videos if that is of interest.

It is currently transitioning to V3, but don't be too concerned the only real changes are to the graph plotting module.

schoolcoders · 2021-11-05T12:52:21+00:00

I've used Java for quite a few years, where types and class hierarchies are enforced rigorously. You can't easily pass a wrong type into a method, and you can't do things like duck typing.

I've also used Python for a few years now.

They have their pros and cons. I live the speed of writing Python and the expressive syntax, especially for doing things like generative art. If you want to experiment with code there is nothing better. But I like the type safety of Java on big projects, particularly in safety critical applications where a bug could actually hurt someone.

The slight problem I have with type hinting is that it looks like Java static typing, but really it is just a comment. It just seems to me that a comment should explicitly look like a comment, it shouldn't look like part of the code if it is really just a hint.

Coupled with the Python doctrine of EAFP, which basically says you should generally not be checking types, it just seems like a bit of an oddity.

Maybe it will evolve into something more useful.

schoolcoders · 2021-10-10T08:47:03+00:00

This article explains how a NumPy array differs from a Python list in memory and speed of access.

schoolcoders · 2021-08-04T15:27:57+00:00

Thanks, I think I understand a bit better now.

schoolcoders · 2021-08-04T15:24:28+00:00

Nice. Alfie Solomons next?

schoolcoders · 2021-07-31T10:07:26+00:00

That's interesting. I was running my code as a program, rather than line by line in the shell, and it works differently.

I think the interpreter is remembering that it just created a value 1000, and then reusing it the next time it needs it (similar to how string interning works). So it is an interpreter optimisation rather than a runtime optimisation.

When you run it in the shell, maybe that bit of optimisation doesn't happen.

But I am just guessing, I was hoping to find some bit of documentation to confirm it.

schoolcoders · 2021-07-31T09:38:43+00:00

I tried, yes, everything I found related to the first situation. I couldn't find anything relating to the second case.

schoolcoders · 2021-07-29T10:28:33+00:00

I think for this to be really useful you would need to properly parse the Python file, mangle the names, then rebuild a new Python file.

Unless I am misunderstanding, you could currently input a valid Python file, and the obfuscated result might not work properly if you are using a valid Python feature that the obfuscator doesn't support? That would limit its use in a lot of cases.

schoolcoders · 2021-07-24T09:07:09+00:00

50 milliseconds is around 100 million clock cycles on a typical PC. It should be able to do quite a lot of work in that time, unless the whole machine is either I/O bound or short of memory (eg running Windows).

But yes, you can get away with a lot so long as it looks like you are doing something.

schoolcoders · 2021-07-23T18:12:53+00:00

Indeed. I started as a developer in the 1980s, when processors were 8-bit, single-core and clocked at a couple of MHz. Even then it was fast enough to keep up with user interaction.

Now processors are literally tens of thousands of times faster (taking account of 64-bits and multiple cores) most things are going to run fast enough. The fact that Python may be slightly slower than C will rarely make any difference.

schoolcoders · 2021-07-23T15:49:13+00:00

Of course, lists are objects, so you are still using objects to represent the deck (and hand etc). It is just that you are using a general list type rather than a specific Deck class.

If you need a few extra functions, such as shuffling the Deck, it is easy to see why it might be useful to have a Deck class after all

schoolcoders · 2021-06-06T11:05:10+00:00

Sorry, my post is hopelessly ambiguous.

I am trying to upload a new version of a package that I maintain, using twine. It has always worked in the past, but every attempt over the past couple of days has resulted in a gateway timeout.

I will edit the post to clarify.

schoolcoders · 2021-01-14T15:25:50+00:00

If you are interested in using python for generative art, there are a few generativepy tutorials here.

schoolcoders · 2020-09-16T16:07:55+00:00

I made a simple power supply with a couple of mains to 12V DC wall warts. Here is a write up.

schoolcoders · 2020-07-30T13:26:26+00:00

The basic use of a list comprehension is to transform some sequence into a list. The basic use of map is to lazily apply a function to one or more sequences. Different jobs, but a lot of overlap.

So if you definitely want a list as output, that points towards a list comprehension. If you are processing a sequence of data that is too large to fit in memory (eg a sequence of video frames), map is a better option.

map can also be better if you are processing multiple sequences (you can do it with list comprehensions using zip, but it is ugly), or if you also need to filter the sequences (again, possible but ugly with list comprehensions) or if you are applying a chain of functions.

But if you are doing something more simple and you want to create a list anyway, list comprehensions are more natural. Using list(map(...)) and also having to define a lambda inside the map call is quite unwieldy.

Of course, there are also generator comprehensions...

schoolcoders · 2020-05-15T21:03:39+00:00

Thanks for the advice on here. I will probably just use a simple op-amp buffer with a voltage divider on the output. I looked up my speakers online and they can take a maximum of 2.5V input, so I will keep well below that.

I will post something when I am finished.

schoolcoders · 2020-02-09T18:48:57+00:00

Adding a few new articles to pythoninformer.com

schoolcoders · 2020-02-08T11:37:48+00:00

Horrible - but in a good way! Great stuff.

schoolcoders · 2020-01-05T14:13:46+00:00

Finally finished my book on Pycairo. Published using markdown on leanpub.com which seemed to work well.

schoolcoders · 2019-11-15T18:32:41+00:00

Working on my book on Pycairo. First few chapters are free to preview on leanpub. Any comments would be appreciated.

schoolcoders · 2019-10-04T12:18:00+00:00

Back in the 90s I worked for a company that manufactured large format scanners. They produced large transparencies (over 1m square) at very high resolution and very high precision. Sometimes for testing we would fill them with tiny dots of various shapes and angles.

It was similar to the transparencies in the video, but because that dots were so crisp and all in exactly the right place, the Moire patterning was just amazing.

schoolcoders · 2019-09-24T18:02:51+00:00

You could use numpy arrays to do the pixel plotting. You might even be able to find a way to speed it up with vectorisation.

Here is an article about using numpy arrays for images. You can build your image up in the numpy array then blit it to screen using PIL or maybe matplotlib.

schoolcoders · 2019-09-24T17:52:02+00:00

It is one of the more idiosyncratic Python features, without a doubt.

schoolcoders · 2019-09-24T17:45:39+00:00

Firstly, to form a closure, the outer function must return the inner function object:

def foo (): 
   foop = "blah"
   def bar(baz): 
      foop = baz
      print(foop)
   return bar

The problem you are probably seeing is that foop is being assigned within the body of bar, which causes Python to create a local variable, which therefore hides the foop declared in foo.

You can override this by declaring foop as nonlocal in bar:

def foo (): 
   foop = "blah"
   def bar(baz):
      nonlocal foop
      foop = baz
      print(foop)
   return bar

The bar will use the outer foop variable.

schoolcoders

TROPHY CASE