{"id":108340,"date":"2026-02-12T10:44:34","date_gmt":"2026-02-12T10:44:34","guid":{"rendered":"https:\/\/www.red-gate.com\/simple-talk\/?p=108340"},"modified":"2026-02-12T15:34:31","modified_gmt":"2026-02-12T15:34:31","slug":"python-is-good-but-not-perfect-here-are-10-reasons-to-avoid-it","status":"publish","type":"post","link":"https:\/\/www.red-gate.com\/simple-talk\/development\/python\/python-is-good-but-not-perfect-here-are-10-reasons-to-avoid-it\/","title":{"rendered":"Python is good, but not perfect – here are 10 reasons to avoid it"},"content":{"rendered":"\n

Four years ago I wrote a blog on this site explaining why Python is better than C#<\/a> and, arguably, most other programming languages.<\/ins> To redress the balance, here are 10 reasons why you might want to avoid getting caught up in Python\u2019s<\/a> oh-so-tempting coils – particularly when building large, long-lived systems.<\/p>\n\n\n\n

If this sounds like an attempt to have my cake and eat it, my defense is that I follow in my work what I preach here: I use Python for ad-hoc jobs, at which it is unsurpassed. For larger systems – such as our MV website – I use C#<\/a>, due to its strengths in maintainability, tooling as well as the practical consideration that my personal preference for Visual Basic<\/a> is not shared by the wider team.<\/p>\n\n\n\n

This article was peer reviewed by Rutuja Patil<\/a>.<\/em><\/p>\n\n\n\n

1. Argument Types<\/h2>\n\n\n\n

Consider this Python function:<\/p>\n\n\n\n

def formal_name(\n\tfirst_name: str,\n\tlast_name: str\n) -> str:\n\t\n\t\"\"\"\n\t\tCreates a formal name (eg \"Tom\", \"Cruise\" becomes \"Tom Cruise\")\n\t\"\"\"\n\treturn \"{0} {1}\".format(\n\t\tfirst_name.capitalize(),\n\t\tlast_name.capitalize()\n\t)\n\n# show this name\nprint(formal_name(\"Bob\",\"Smith\"))<\/pre><\/div>\n\n\n\n
These str<\/code> expressions are called type annotations<\/a>, introduced in Python 3.5. They are written using the following syntax:<\/p>\n\n\n\n
\"The<\/figure>\n\n\n\n
Type annotations are a useful feature because they enable development tools to provide more accurate auto-completion when accessing object attributes – for example, in the following code, the type annotation allows tooling to infer that last_name<\/code> holds a string:<\/p>\n\n\n\n
\"last_name<\/figure>\n\n\n\n
Sadly, however, this type information is not enforced at runtime and is only relied upon when incompatible operations are performed inside the function. You can make horrible calls like this (below), and they will initially run perfectly:<\/p>\n\n\n\n
# print a name consisting of a date and pi\nprint(formal_name(2025-12-31,3.14))\n<\/pre><\/div>\n\n\n\n
This code won\u2019t crash at the time the function is called as Python will quite happily create two arguments: one called first_name<\/code> (to hold a date), and another called last_name<\/code> (to hold a float value). It’ll only crash when the code attempts to capitalize ‘pi’!<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
This is a typical Python feature, placing the onus on the developer to follow conventions, and is a recipe for bugs when developer A passes inappropriate data types to a function written by developer B simply because they can. C# programmers – look on and despair.<\/p>\n\n\n\n
2. Module Inconsistency<\/h2>\n\n\n\n
Python modules are its superpower: whatever you want to do, there\u2019s a module for it. To test this theory, I asked ChatGPT<\/a> to help me find a module to manage my (imaginary) Lego collection, more in hope than expectation, and got this:<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Truly, there is a module for everything! However, because Python is open-source and its development relies on the goodwill of volunteers, these modules aren\u2019t always consistent – and that\u2019s an understatement!<\/p>\n\n\n\n
Here is one example to illustrate this. The following code uses the popular BeautifulSoup module<\/a> to print out the first hyperlink on Simple Talk:<\/p>\n\n\n\n
import requests\nfrom bs4 import BeautifulSoup as bs\n\n# go to Simple Talk website\nvisit = requests.get(\"https:\/\/www.red-gate.com\/simple-talk\/\")\n\n# check visit went OK\nif visit.status_code != 200:\n\tprint(visit.status_code)\n\tquit()\n\n# get the underlying HTML and parse it\nhtml = visit.text\nsoup = bs(html, \"html.parser\")\n\n# show first hyperlink\nfirst_link = soup.body.a\nprint(first_link.get(\"href\"))\n<\/pre><\/div>\n\n\n\n
However, there is no reliable auto-completion to help you with the penultimate line, as this information is only available at runtime. It\u2019s up to you to guess that you can refer to the body of the HTML page in this way:<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
BeautifulSoup is an excellent and powerful module \u2013 and the online documentation is, fortunately, very good \u2013 but, much like third-party Python libraries, it doesn\u2019t always follow what you might think of as standard Python conventions. This feels like a side effect of open-source development; perhaps there\u2019s something to be said for having Microsoft in overall control of a codebase after all!<\/p>\n\n\n\n
3. Data Type Inconsistency<\/h2>\n\n\n\n
C# may have a bewildering variety of data types, but at least they are universal: an int32<\/a> will always be an int32, no matter which namespace you\u2019re referencing. This is not the case with Python.<\/p>\n\n\n\n
Initially, Python\u2019s numeric types are refreshingly simple (and dare one say, Pythonic?):<\/p>\n\n\n\n
Data type<\/strong><\/td>What it contains<\/strong><\/td><\/tr>
str<\/strong><\/td>Any string of text<\/td><\/tr>
int<\/strong><\/td>Any whole number<\/td><\/tr>
float<\/strong><\/td>Any decimal number<\/td><\/tr>
bool<\/strong><\/td>Something which can be either true or false<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
However, many of the most important modules are written in C<\/a>, and therefore use C\u2019s data types. As a result, NumPy<\/a> defines its own set of numeric types (which Pandas<\/a> largely build):<\/p>\n\n\n\n
Type of data<\/strong><\/td>NumPy data type<\/strong><\/td>C equivalents<\/strong><\/td><\/tr>
Integer<\/em><\/td>np.int16<\/strong>, np.int32<\/strong> or np.int64<\/strong><\/td>int16<\/strong>, int32<\/strong>, int64<\/strong><\/td><\/tr>
Floating point<\/em><\/td>np.float32, np.float64<\/strong><\/strong><\/td>single<\/strong>, double<\/strong><\/td><\/tr>
Boolean<\/em><\/td>bool8<\/strong><\/td>bool<\/strong><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
This often means you have to learn one way of doing things in \u201cvanilla\u201d Python and another way in, for example, Pandas. Here\u2019s one of the most egregious examples (I\u2019m so proud of using this word in anger, as I\u2019ve finally learned what it means!). Suppose we want to show, in a Pandas data frame of films, the number of characters in each film\u2019s title (shown twice below):<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Here\u2019s some sample code to do this:<\/p>\n\n\n\n
# create a dictionary to hold some films\nfilms_dict = {\n\t\"Id\": [ 1,2,3,5,6 ],\n\t\"Title\": [ \"Jurassic Park\", \"Spider-Man\", \"King Kong\", \"Superman Returns\", \"Titanic\"],\n\t\"Run Time\": [ 126, 121, 187, 154, 194 ],\n\t\"Genre\": [ \"Adventure\", \"Action\",\"Adventure\", \"Action\",\"Romance\"]\n}\n\nimport pandas as pd\n\n# add a field giving length of each film name using a standard\n# Python list comprehension and the \"len\" function\nfilms_dict[\"Title length 1\"] = [len(title) for title in films_dict[\"Title\"]]\n\n# create a dataframe based on this dictionary\nfilm_dataframe = pd.DataFrame(films_dict)\n\n# add a column showing the film name length, converting the Title column\n# (which is held as an object) to a string and then taking the length of this\nfilm_dataframe[\"Title length 2\"] = film_dataframe[\"Title\"].str.len()\nprint(film_dataframe)<\/pre><\/div>\n\n\n\n
In vanilla Python you find the length of each string using the built-in len<\/code> function, but once you\u2019re in Pandas you have to convert the column to a string using the str<\/code> property and then<\/em> apply the len<\/code> method – neither of which are part of standard Python. Inconsistency like this makes Python harder to learn and more unpredictable.<\/p>\n\n\n\n
4. Python isn’t always as ‘pythonic’ as it thinks it is<\/h2>\n\n\n\n
While most things in Python are beautifully simple, not everything is. Here are four of my pet bugbears.<\/p>\n\n\n\n
If you want to check if something is contained in something else, you have to use this syntax:<\/p>\n\n\n\n
person_names = [\"BRIAN\",\"SALLY\",\"MAX\"]\n\n# test if someone in the list\nif person_name in person_names:\n<\/pre><\/div>\n\n\n\n
It would be so much more intuitive to use:<\/p>\n\n\n\n
# test if someone in the list\nif person_names.contains(person_name):\n<\/pre><\/div>\n\n\n\n
Bizarrely, there is a dunder<\/a> (double-underscore, but you knew that, I\u2019m sure) method called contains<\/code>,which does let you do this.<\/p>\n\n\n\n
My second bugbear is the lack of a .length<\/code> property for any sequence:<\/p>\n\n\n\n
# this works ...\nprint(len(\"Hippopotamus\"))\n\n# ... but this doesn't\nprint(\"Hippopotamus\".length)\n<\/pre><\/div>\n\n\n\n
There\u2019s a hidden len<\/code> property \u2013 why not expose a length property, to make this consistent with the
way the rest of string properties and methods work?<\/p>\n\n\n\n
A third bugbear \u2013 why when you write to a text file is there no writeline<\/code> method?<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
This means you have to remember to include a carriage return whenever you write something to a text file. <\/p>\n\n\n\n
And finally, the way you loop over dictionary items is just odd, and hard to remember:<\/p>\n\n\n\n
# create a dictionary to hold some films\nfilms_dict = {\n\t\"Jurassic Park\": (126, \"Adventure\", \"Bit scary\"),\n\t\"Titanic\": (194, \"Action\", \"Good, but too long\"),\n\t\"King Kong\": (187, \"Adventure\", \"Not seen\")\n}\n\n# show the film name and genre\nfor key, value in films_dict.items():\n\tprint(\"{0} <\/pre><\/div>\n\n\n\n
This would produce this output:<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
But why do you need to put .items<\/code> after the name of the dictionary, when Python knows it\u2019s a dictionary? And why is items<\/code> a method, instead of a property?<\/p>\n\n\n\n
5. Indentation – good or bad?<\/h2>\n\n\n\n
One of the most distinctive features of Python is its reliance on indentation<\/a> for meaning, but this can create code which is difficult to read (and easy to insert bugs within). This pseudo-code would create a series of parties for each of my circles of friends:<\/p>\n\n\n\n
# loop over all of my circles of friends (in reality\n# this would be a very short loop)\nFor each of my circles of friends:\n\n\t# for each circle, create a party for its members\n\tCreate a new party for this circle\n\tFor each friend in this circle:\n\n\t\t# for each friend in this circle, invite them\n\t\t# to this particular party IF I like them enough\n\t\tIf I really like them:\n\t\t\tAdd them to my Xmas card list\n\t\t\tInvite them to this party\n<\/pre><\/div>\n\n\n\n
This variation would invite every friend to every party, regardless of how much I liked them:<\/p>\n\n\n\n
# loop over all of my circles of friends (in reality\n# this would be a very short loop)\nFor each of my circles of friends:\n\n\t# for each circle, create a party for its members\n\tCreate a new party for this circle\n\tFor each friend in this circle:\n\n\t\t# for each friend in this circle, invite them\n\t\t# to this particular party IF I like them enough\n\t\tIf I really like them:\n\t\t\tAdd them to my Xmas card list\n\tInvite them to this party\n<\/pre><\/div>\n\n\n\n
You could of course make the same mistake in C#-style code, but it\u2019s a bit more obvious where loops and conditions begin and end:<\/p>\n\n\n\n
# loop over all of my circles of friends (in reality\n# this would be a very short loop)\nFor each of my circles of friends {\n\n\t# for each circle, create a party for its members\n\tCreate a new party for this circle\n\tFor each friend in this circle {\n\n\t\t# for each friend in this circle, invite them\n\t\t# to this particular party IF I like them enough\n\t\tIf I really like them {\n\t\t\tAdd them to my Xmas card list\n\t\t\tInvite them to this party\n\t\t}\n\t}\n}\n<\/pre><\/div>\n\n\n\n
Of course, it\u2019s clearest of all in Visual Basic, but that\u2019s another story \u2026\ud83d\ude42<\/p>\n\n\n\n
The problem really comes when I copy code from a website, and lose the indentation:<\/p>\n\n\n\n
# loop over all of my circles of friends (in reality\n# this would be a very short loop)\nFor each of my circles of friends:\n\n# for each circle, create a party for its members\nCreate a new party for this circle\nFor each friend in this circle:\n\n# for each friend in this circle, invite them\n# to this particular party IF I like them enough\nIf I really like them:\nAdd them to my Xmas card list\nInvite them to this party\n<\/pre><\/div>\n\n\n\n
The chances of introducing a bug in this code are high, whereas with almost any other language it would still be clear where loops and conditions begin and end. In Visual Studio, for example, you could press Ctrl + K followed by Ctrl + D to restore the correct indentation automatically, an option that simply doesn\u2019t work the same way for Python.<\/p>\n\n\n\n
6. Oh, Those Classes!<\/h2>\n\n\n\n
I\u2019ve left this until halfway down my list because I didn\u2019t want to lose too many readers at the start, but classes in Python are just pants. Fortunately, the majority of Python programmers never discover this because you can create ad-hoc programs in Python without ever creating classes!<\/p>\n\n\n\n
Suppose you want to create a simple (if pointless) class to allow someone to create a pet object like this in Python:<\/p>\n\n\n\n
# example use of class - creating Neo the Cat\nmy_pet = Pet(\"Neo\", \"Cat\")\n\n# create and show description of pet\nmy_pet.Document()\nprint(my_pet.output)\n<\/pre><\/div>\n\n\n\n
Or like this in C# (I\u2019m outputting the text to a web page):<\/p>\n\n\n\n
\/\/ example use of class - creating Neo the Cat\nvar my_pet = new Pet(\"Neo\", \"Cat\");\n\n\/\/ show what we've created\nmy_pet.Document();\nPetList = my_pet.Output;\n<\/pre><\/div>\n\n\n\n
Either of these code snippets should produce output like this for a cat called Neo:<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Here is the code you could create in C#:<\/p>\n\n\n\n
public class Pet\n {\n\t public string Output = \"\";\n\t \/\/ a class to hold instances of people's pets\n\n\t \/\/ private variables\n\t private string name = null;\n\t private int? legs = null;\n\n\t \/\/ used to determine number of legs given animal type\n\t private Dictionary<string, int> animalLegs = new Dictionary<string, int>\n\t { { \"dog\", 4 }, { \"cat\", 4 }, { \"bird\", 2 }, { \"fish\", 0 } };\n\n\t public Pet(string petName, string petAnimal)\n\t {\n\n\t\t \/\/ the constructor: when you create a pet, must give it a \n\t\t \/\/ name and say what sort of animal it is\n\t\t name = petName;\n\n\t\t \/\/ setting the animal type will set the number of legs\n\t\t Animal = petAnimal;\n\t }\n\n\t \/\/ read\/write property for the animal type\n\t private string animal = null;\n\t public string Animal\n\t {\n\t\t get\n\t\t {\n\t\t\t return animal;\n\t\t }\n\t\t set\n\t\t {\n\t\t\t animal = value;\n\t\t\t if (animalLegs.TryGetValue(value.ToLower(), out int legCount))\n\t\t\t {\n\t\t\t\t legs = legCount;\n\t\t\t }\n\t\t\t else\n\t\t\t {\n\t\t\t\t legs = null;\n\t\t\t }\n\t\t }\n\t }\n\n\t public void Document()\n\t {\n\n\t\t \/\/ a method to print out the pet's details\n\t\t Output += $\"Pet Name: {name}<br \/>\";\n\t\t Output += $\"Animal Type: {animal}<br \/>\";\n\t\t Output += $\"Number of Legs: {legs}\";\n\t }\n }\n<\/pre><\/div>\n\n\n\n
The Animal property is public, and it\u2019s ‘getter’ and ‘setter’ define the public interface, so when you consume the class you only see the publicly exposed properties and methods of each object:<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
This is as it should be. Compare this with the Python (rough) equivalent:<\/p>\n\n\n\n
class Pet:\n\t# a class to hold instances of people's pets\n\n\t# used to determine number of legs given animal type\n\t_leg_lookup = { \"dog\": 4, \"cat\": 4, \"bird\": 2, \"fish\": 0\t}\n\n\tdef __init__(self, name, animal):\n\n\t\t# the constructor: when you create a pet, must give it a \n\t\t# name and say what sort of animal it is\n\t\tself.Name = name\n\t\t\n\t\t# setting the animal type will set the number of legs too\n\t\tself.Animal = animal  \n\n\t\t# the final output\n\t\tself.output = \"\";\n\n\t# read\/write property for the animal type\n\t@property\n\tdef Animal(self):\n\t\treturn self._animal\n\n\t@Animal.setter\n\tdef Animal(self, value):\n\t\tself._animal = value\n\t\t\n\t\t# set legs based on lookup, defaulting to None if unknown\n\t\tself.Legs = self._leg_lookup.get(value.lower(), None)\n\n\tdef Document(self):\n\n\t\t# a method to print out the pet's details\n\t\tself.output += f\"Pet Name: {self.Name}\\n\";\n\t\tself.output += f\"Animal Type: {self.Animal}\\n\"\n\t\tself.output += f\"Number of Legs: {self.Legs}\"\n<\/pre><\/div>\n\n\n\n
When I come to consume the class, I see not only the properties I want to see, but also the ones I’d prefer to be private (so, not visible):<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
The syntax of a read-write property is itself the opposite of a thing of beauty:<\/p>\n\n\n\n
# read\/write property for the animal type\n\t@property\n\tdef Animal(self):\n\t\treturn self._animal\n\n\t@Animal.setter\n\tdef Animal(self, value):\n\t\tself._animal = value\n\t\t\n\t\t# set legs based on lookup, defaulting to None if unknown\n\t\tself.Legs = self._leg_lookup.get(value.lower(), None)\n<\/pre><\/div>\n\n\n\n
There\u2019s no obvious reason why this should be the syntax for the get<\/code> and set<\/code> parts of a property. The constructor (the bit of code which runs whenever an instance of a class is initialized) is nasty too:<\/p>\n\n\n\n
def __init__(self, name, animal):\n\n\t\t# the constructor: when you create a pet, must give it a \n\t\t# name and say what sort of animal it is\n\t\tself.Name = name\n\t\t\n\t\t# setting the animal type will set the number of legs too\n\t\tself.Animal = animal  \n\n\t\t# the final output\n\t\tself.output = \"\";<\/pre><\/div>\n\n\n\n
It\u2019s irritating having to keep passing a reference to the object being created (self<\/code>) to each method and property, and this implicit way of defining properties is anything but clear.<\/p>\n\n\n\n
I could go on, but I think I already have for long enough! It\u2019s as if whoever created Python abandoned usability when they got to classes.<\/p>\n\n\n\n
\n    
\n        
\n            
\n                
Enjoying this article? Subscribe to the Simple Talk newsletter<\/h3>\n                
\n                                            Get selected articles, event information, podcasts and other industry content delivered straight to your inbox.                                    <\/div>\n            <\/div>\n                                            Subscribe now<\/a>\n                    <\/div>\n    <\/div>\n<\/section>\n\n\n
7. Python is interpreted – not compiled<\/h2>\n\n\n\n
Python is interpreted, not compiled<\/a>. What this means is that, every time you run a Python program, the interpreter has to read through it line-by-line in sequential order, executing each line as it does so.<\/p>\n\n\n\n
There are two main downsides arising from Python\u2019s approach. The first is that Python runs more slowly than a compiled language like C#. I will freely admit I\u2019m not an authority on the subject, and can only dutifully report what others tell me: that Python uses more memory, has no support for true parallel execution of threads, and loads more slowly. For the programs I write, Python\u2019s speed has never been an issue, but that\u2019s because I rarely work with machine learning, AI<\/a>, or vast amounts of data.<\/p>\n\n\n\n
The second downside is that Python forces you to write programs in a certain order, and in particular you must declare functions before you can call them:<\/p>\n\n\n\n
def get_bmi(\n\tweight_in_kilos:float,\n\theight_in_metres: float\n) -> float:\n\n\t\"\"\"\n\tCalculates someone's BMI\n\t\"\"\"\n\treturn weight_in_kilos \/ (height_in_metres ** 2)\n\n# show my BMI\nprint(get_bmi(80,1.8))\n<\/pre><\/div>\n\n\n\n
Compare this with the more logical C# version, where you can call a function at the top of your program:<\/p>\n\n\n\n
Console.WriteLine(getBMI(80.0, 1.8).ToString(\"0.000\"));\n\n\nprivate double getBMI(\n\tdouble weightKilos,\n\tdouble heightMetres\n)\n{\n\t\/\/ calculate someonne's BMI\n\treturn weightKilos \/ (heightMetres * heightMetres);\n}\n<\/pre><\/div>\n\n\n\n
C# first compiles any program into an executable before running it, which means you can put the functions and function calls in any order you like.<\/p>\n\n\n\n
8. Dynamically-typed variables<\/h2>\n\n\n\n
I suspect that the average C# programmer would have put this at the start of their list, but I can only report on nuisances in the order in which I perceive them!<\/p>\n\n\n\n
Consider this block of code:<\/p>\n\n\n\n
# start with a simple integer counter\ncount = 0\t\t  \ncount += 1\t\t \n\n# much later in the code, someone\n# accidentally assigns it as a string\ncount = \"one\"\t  \n\n# then within a later loop, Python will crash\ncount += 1\n<\/pre><\/div>\n\n\n\n
This creates an int<\/code> variable called count<\/code>, but then replaces it with a str<\/code> variable with the same name (I\u2019m aware that this isn\u2019t exactly what happens, but it\u2019s a good model of it). The final line will then crash, since it\u2019s trying to add 1 to a string. You wouldn\u2019t and couldn\u2019t get this bug in C#:<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
The problem isn\u2019t that Python implicitly converts data types from one thing to another \u2013 it doesn\u2019t \u2013 but that Python doesn\u2019t prevent you rebinding a name to a value of a different type. I have to admit that I\u2019ve never found this to be a problem myself, but enough other people do that it would be remiss of me not to include it in this list.<\/p>\n\n\n\n
9. Releasing and packaging systems<\/h2>\n\n\n\n
The great benefit of a compiled language is that you can produce a single executable file. Here is the single file containing all of the C# code for our website (apart from the bits embedded in web pages):<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
This makes distributing a system comparatively simple \u2013 you just copy over the single executable file to the relevant network drive. OK, I\u2019m over-simplifying, particularly as you have to ensure that all the referenced packages are also included, but you the principle holds.<\/p>\n\n\n\n
With Python, things are more complicated as you have to package together all of the .py<\/code> files that you\u2019ve created along with any third-party modules they depend on. I\u2019ll admit that the only time I ever tried doing this (using PyInstaller<\/a>), I gave up.<\/p>\n\n\n\n
The situation is further complicated by the way Python uses virtual environments to manage different versions of modules. In the simple diagram below there are two virtual environments: the red one containing modules used by the timesheet system, and the blue one containing modules used by the expenses system.<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Unfortunately, new versions of modules (and of Python) are released quite often, so you can end up with several different virtual environments on your computer – each containing more-or-less duplicate files for your Python interpreter and the modules you’re importing. <\/p>\n\n\n\n
10. Python’s GUIs are hard to use<\/h2>\n\n\n\n
Python comes with a built-in GUI called TKinter<\/a>, which can be used to create tools like Wordle<\/a>, and a while ago I did exactly that. However, TKinter is also quite limited, so I then spent some considerable time trying to write a GUI using PyQt<\/a> – another popular Python module for creating a forms-based system – using the separate Qt Designer<\/a> to draw my forms on-screen:<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Reader, eventually I gave up<\/a>. The biggest problem was working with a built-in widget called QTableView<\/code> to control the display of rows of data, which I found pretty much unmanageable. I\u2019ve also worked with WPF and Windows Forms<\/a> and have to say that WinForms was by far the simplest of the GUI interfaces to work with – although I accept it\u2019s platform-dependent and not as powerful.<\/p>\n\n\n\n
So, what do<\/em> I use Python for – where does it shine?<\/h2>\n\n\n\n
Python remains my preferred language for solving one-off problems, whether that involves processing files, converting images, finding broken links on a website, automating the submission of prompts to AI tools or any other ad-hoc problem. I find the syntax easy to remember and a pleasure to use. I\u2019m a particular fan<\/a> of sequences and slicing in Python.<\/p>\n\n\n\n
However, if you asked me to build a larger system with a longer lifetime, perhaps involving a team of programmers, Python’s class model alone would push me towards a more conventional language such as C#. As they say in the UK (I have no idea whether this expression is universally known in English) – horses for courses!<\/em><\/p>\n\n\n\n
The latest from Simple Talk:<\/strong><\/h3>\n\n\n