this doesn't really makes sense: lists are part of the basic features of python, so it is natural that there is a specific syntax to manipulate them, and it's also quite an intuitive one.
with your reasoning one could say that C doesn't have a basic syntax, since you don't have a new library to manipulate pointers, but they extended the syntax (and surely not in a way that is intuitive).
Why does a language have to have alot of syntax around something just because it's part of the core? (And I don't say that C is well-structured when it comes to syntax; I don't particularily like the language at all)
Well, ok, this is maybe only my preference, but I like it if a language's core is as small as possible and handles as little as possible. This is why I really like the Scala language (I've metioned it a few times before; it has become my prime example of how a language should be built up), because it only has a few concepts that it builds on, and does so in an uniform way: The Object, Inheritance, the Function, and pattern matching (almost everything else is expressed in libraries).
Every object can inherit from every other, every function is an object and every object is a function... (Yes, you can inherit from functions)
Compare that to Python, where there are lists and maps and hybrids between them, such as slices, etc, that everything builds on. Many of these types are atomic in Python (even if they can be split up, they can still only be handled as an unit, you can't implement your own fully working List class, which makes the core have to handle the List implementation etc).
Then we can cover syntax uniformness. What is the []-Operator? When does it apply to what, and what does it do? What is the value of what it contains (for example "2:3")? Can you make your own classes with this operator?
And method signatures, and static typing... I won't even go there.
And Python is still good compared to other scripting languages. For example, in vb script:
CODE
for i as integer = 0 to 5
end for
What is the value of "0 to 5"? What is the result of the operation "i as integer"? What is the "end"-syntax element? A function? It just doesn't make any sense.
Oh well, enough ranting on this subject; I might introduce my opinions in another thread instead of this one
EDIT: Example on a scalable language with very basic syntax (Scala):
(Warning: very deep programming language analyzation ahead
)
CODE
object MyApp {
def main(args: Array[String]) = args.foreach(println)
}
"
object MyApp" defines a new singleton object. The "object" keyword is a keyword here because of performance; it could be a scala function aswell if we really wanted it to (that takes an "identifier" and a "List of statements" as its paramters)
"
{ ... }" is a paramter list of statements for the object keyword. They contain the object definition.
"
def main" declares a new method/function. "def" could also be a scala function if we really wanted it to, but we don't.
"
(args: Array[String])" is of type "single-element paramter list". The "def"-keyword awaits an identifier and one or more parameter lists as its arguments. Here, this paramter list contains one element of type "array of strings" with the identifier "args".
"
= args.foreach(println)" assigns a list of statements to the method. This list of statements is only one element and therefore doesn't need the "{}". The Array class has a method with the name "foreach" that takes "a function accepting one [String] argument that returns Unit" (String is ttype-paramterized in this case) as its argument and applies every member of the array on that function (Unit is similar to "void"). "println" is a method accepting one string parameter and returning Unit, a member of the "scala.Predef" singleton object. IT prints its parameter to the standard output stream.
This I call a well-structured language