One example of this is when a classmate of mine was taking an artificial intelligence class at Berkeley (Cog Sci 131) and was at a loss because she was taking 61as which was taught in strictly scheme, and the artificial intelligence class was taught in strictly python.
Both classes are wonderful and I can proudly say that it has made me a better computer scientist. http://cs61a.org/
Nowadays, though, I feel like my time spent getting used to functional programming in school has given me a secret weapon. It's something much more subtle than the ability to bandy about obscure words that probably start with M. I really do think I'm just fundamentally better at dealing with abstraction, both using it and creating it, than my peers who haven't had such an experience. And that's not small beans considering that, to an approximation, working with abstractions is what I do all day every day.
I can say without a doubt that having functional programming knowledge first would have been a phenomenal advantage.
I do think that another major advantage for Python is the fact that you can do cooler things with it, faster. CS has a serious funnel problem and the quicker we can get students to do cool things with CS (GUI stuff, web stuff), the better CS education will be.
The issue is these skills don't solve serious or interesting problems. GUI and web programming have become easier than ever and requires less programmers on staff to perform. My company can't find enough qualified engineers with a good depth of knowledge in CS.
I've found functional concepts have been incredibly important in shipping maintainable code on the JVM using both Java 8 and Scala.
Unless one plans on developing mostly in python during his or her career, I think its beneficial to be forced to learn multiple languages.
It's not what you learned that's the problem, it's what you didn't. You almost certainly missed out on things that you could very well never see again, or even know the existence of (at least for a very long time) unless you were motivated enough to go discovering stuff by yourself.
Did you ever learn about macros in Python? I doubt it, because they don't exist. Did you get introduced to metaprogramming -- the idea that you can write programs that generate more powerful programs? I doubt it, because it's hard to do that in Python. But The old 61A, which used Scheme, did just that. They added an OOP system --- yes, that's classes, inheritance, methods, constructors, etc. --- to a language that never had one, and they even taught you the basics of how it was done. 
This is something you can't even dream of doing in most (all?) languages that aren't dialects of LISP. You won't even realize it's a possibility, unless someone teaches it to you or unless you're lucky enough to stumble across it and realize its importance.
i.e., you won't know what you're missing out on.
Whereas with Python, there's not much you're missing out on: there are a ton of languages like it that you're bound to see them later in industry, if not Python itself, and learn what you would have learned anyway.
In any class of reasonable difficulty/usefulness, there will be students who do great, ones that do okay, and ones that struggle. What we should aim to do as the very first intro course is to help as many of those people from all of those groups to do as well as possible in their future classes/careers.
For the great students, I actually believe we did them a disservice. CS61A in scheme was truly beautiful. It was amazing, given how simple the language was, how much you could achieve. All pieces of the puzzle fit together perfectly. Trying to do the course in python, on the other hand, we had to compromise a little bit. We didn't want to just teach the exact same content in a different language. We wanted to teach the "Pythononic" way of doing things. To give a few examples:
- The first 1/3 of CS61A in scheme had no mutation. That is almost impossible in Python to do, and is not the way the language is used in industry. I personally believe functional programming and immutability is The-Way to program, so I see this as a huge loss.
- We teach recursive lists (linked lists) in order to teach recursion, but I feel like having both the default Python mutable lists (which are array lists) and linked lists is confusing to students, since we do not teach their performance tradeoffs (that is in 61B).
- Mutual recursion was almost useless to teach. Where it was most commonly used in Scheme, you achieve the similar thing using list comprehensions in Python (the language feature essentially took away your need to construct the list in a recursive fashion).
- The very interesting bits of the old class about metacircular evaluators, we simply could not do in Python.
- Python also has tons of quirks (magic methods, for instance) and lost some of the elegance we saw in scheme.
But for the okay and struggling students - 70-80 percentile and below, the students who understand most of the material, but perhaps fail to grasp some of the more complex concepts - I think Python was the correct way to go for a few reasons:
- It is a much more commonly used language. It sets you up to go for internships, research, hackathons, whatever you please, straight from what you learned in class.
- The language is way more similar to Java, which allows students to translate what they learned easier to the next course in the series, CS61B.
- 80% of the material hasn't changed but you've gained the above benefits. Remember, we are talking about students who probably would have struggled to grasp those last 20% anyway (maybe they are completely new to programming and they already have their hands full with the 80% to begin with).
I think therein lies the difference in opinion. If you took CS61A in scheme and understood it very well, then you don't understand the change. If you understood the intricacies of what was taught in CS61A, you will find it very easy to generalize those concepts to new languages - and new concepts. In fact, you will find that much of what you learn in the rest of your undergrad career will be "CS61A review". However, for students who may not have had the CS maturity or time to grasp all the concepts, they find that the Python course is much more useful.
One thing I've seen is that when you're first learning a langauge and pick up bad habits, they can be really hard to break. I've heard lots of students talk about the problem this causes when interviewing, especially early on. Additionally, for languages like Python, where there is loads of (often excellent) support online it can be confusing/frustrating to have a class teach one method and find answers which are mostly unrelated.
That said, I agree with what was said. Scheme is pretty amazing :)
What is stopping you from implementing those ideas in Python during a first-semester course in CS is that you will not serve your students, as amatsukawa described.
Pretty unambiguous to me. GP had a very thoughtful reply to be clear.
If the desire was to teach idiomatic python, that's totally legitimate. But the decision to whether or not teach FP concepts is in no way constrained by the choice of language.