ex13 uses the expression "throw an error" but this won't make sense to people who haven't seen exceptions before.

First chapter switches from "Python" to "IPython", then circles back to explain the difference about 30 seconds later - should move explanation up.

ex4 introduces comments "Something that Filip didn't mention in his videos" but code samples have included comments before this point.

"Python is getting funkier by the minute, but fear not" and similar phrases should probably be excised - one good rule of writing is that if something isn't still witty the fifth time you say it aloud, it should be cut.

Chapter 2 says "The ; sign is used to place commands on the same line" in passing in one exercise - I recommend pulling this up, and making it clear that it doesn't work for control flow.

The editor's tab completion and bracket completion features are really nice, but aren't explicitly introduced and demonstrated early in the lesson.

Hi, not sure if I should address the issue here, but maybe you can redirect :)

in https://www.learnpython.org/en/Classes_and_Objects
in Accessing Object Variables
in 3-rd exercise

class MyClass:
    variable = "blah"

    def function(self):
        print("This is a message inside the class.")

myobjectx = MyClass()
myobjecty = MyClass()

myobjecty.variable = "yackity"

# Then pring out both values
print(myobjectx.variable)
print(myobjecty.variable)

explanation does'nt mention, that new instance variable is created (and overrides static variable for that instance)
And doesn't mention possibility of MyClass.variable = "asdf"

imo, instead should be introduced

    __init__(self):
         self.variable = "blah"

If the lesson explains the continuation prompt '...', I missed it.

Chapter 2 says:

Watch out! list() and [:] might not copy properly if you put complex things in your lists.

Without an explanation of what "complex things" are, or why this might not work, or a forward reference to such explanations, all we've done is scare learners without informing them.

There are sooo many feedback message from students in non-US countries saying that height and weight are the wrong way round. the issue is that they see heights in inches of 70 or so, and assume that they are weights in kg.

The text explains the units to them several times, but so solve the problem completely, we need to write the variable names as height_in and weight_lb throughout the whole chapter.

I've found that Python's inclusive:exclusive convention for slices confuses every newcomer, particularly those with backgrounds in MATLAB and other languages that are inclusive at both ends. There are several made-up explanations for why Python works this way: including any explanation at this point will help novices remember the rule.

Later, the notes say that "The start index will be included, while the end index is not" - should change to say "the value at the start index..." and likewise for the end (since another common confusion is between indices and the values they select).

This is a placeholder for the Content Quality Team, please feel free to ignore!

In the second exercise of chapter 3 (https://campus.datacamp.com/courses/intro-to-python-for-data-science/chapter-3-functions-and-packages?ex=2), the success message turns out like this:
https://www.dropbox.com/s/ivqtnrdu2t43afr/Screenshot%202017-01-05%2016.02.24.png?dl=0

Exercise link: https://campus.datacamp.com/courses/intro-to-python-for-data-science/chapter-4-numpy?ex=15
Issue: the error states to insert 2 but the submit answer accepts only the correct 1. Error with indices 1/2 in line "corr = np.corrcoef(np_baseball[:,0], np_baseball[:,2])"

The most effective way to explain the difference between copying and aliasing is with diagrams. If they haven't been introduced earlier, the section "Inner workings of lists" is a good place: without pictures of what slicing does (creates a new list whose elements alias values from the source list), most learners won't understand why a[:] creates a copy, or why list(some_existing_list) does.

In Extend a list, there's a typo in the hints, which state:

• "Follow the code sample in the assignment. x is areas here, and ["e", "f"] is ["poolhouse", 24]."

The instructions and solution code have ["poolhouse", 24.5]"

Recommendation

Correct the hints

Screenshot

Cf [email protected], #63179
Cc @bakera81

Sports examples (e.g. baseball) may lack cross-cultural appeal, and while sports is big business, it is typically regarded as less "serious" than some other fields. Things like health care data, on the other hand, are cross-culturally comprehensible and universally regarded as "serious".

Chapter 2 introduces a variable areas_1, but earlier, we had el1 and el2 without the underscore - pick one style and stick to it. (Separating words with underscores is slightly more readable for non-native speaks of a language than runningWordsTogether, but consistency trumps both.)

"You just won the lottery, awesome!" is another example of text that doesn't re-read well.

When the user omitting the begin index on slicing lesson there's no validation for upstairs, the exercise asks for:
Create upstairs again, as the last 4 elements of areas. This time, simplify the slicing by omitting the end index.

ex5 of Chapter 2 uses the term "iterable", but neither the concept nor the term have been introduced.

Chapter 2 has learners run help(complex) - the output is pretty dense even for someone familiar with Python. Can we introduce help with something (much) simpler?

It's common in some technical documentation to write f() to mean "the function f". However:

1. It's then confusing for readers whether f() means "the function" or "a zero-arg call to the function".
2. This confusion becomes a lot worse when doing higher-order functions.
3. It's inconsistent: we don't write a[] to mean "the array a".

Strongly recommend changing house style so that f is "the function as a thing" and f() is "the function called without arguments".

Background
"Hi, for some reason in Python class after I listened to the next session I’m able to run code but the submit answer seems to fail. Restart allows to run code again but I can’t submit the answer."

Replicate

I can confirm when inputting the accurate code to exercise:
https://campus.datacamp.com/courses/intro-to-python-for-data-science/chapter-2-python-lists?ex=2

The system accepts the code, lets me know I've passed but when I check the outline of the course it resets back to looking as if I never submitted an answer for that exercise:

UID: 2692990

It looks like there is an extra ======== in the explanation text

https://campus.datacamp.com/courses/intro-to-python-for-data-science/chapter-3-functions-and-packages?ex=6

I found exercise 6 of chapter 4 (on constructing arrays) confusing - I'll try to come up with an alternative.

Title line says it all - text in this portion of the video is too small on a standard screen.

Chapter 3 says that "most list methods will change the list they're called on". Better to change "most" to "some" (a quick count shows 50/50).

A couple of diagrams to explain the difference between concatenating and extending lists will save a lot of confusion.

Students are asked to find how often 14.5 appears in the vector areas, but it doesn't appear at all, which is weird. Should this be 9.5 (which does appear instead)?

@filipsch Am I missing something about this exercise? Or should I just go ahead and change it to 9.5 throughout?

First example of lists is [a, b, c], but those are abstractions: better to introduce with something concrete to reduce cognitive load in novices.

Later, the example is [el1, el2, el3], which is probably even harder to understand: el is presumably an abbreviation for element, but given how verbose we are with naming things elsewhere, it's unlikely that novices will clue to that - they will probably also be wondering whether they missed the definition of el1 somewhere.

Presenter moves around a lot in videos (noticeably more than in other courses) - occasionally distracting.

By default, Python 3 displays strings using single quotes. We should therefore use single-quoted strings everywhere in our code (except when demonstrating that double quotes also work) to reduce cognitive load.

If we believe most numerical users will rely on Anaconda, we should probably show people conda for installation rather than pip (or possibly show both, though I worry that will lead to confusion).