What questions are we most urgently missing?

• How can I know the correct indentation for the code?

• How can I diagnose and understand IndentationError (and TabError)?

  • (And so on for SyntaxError, and for other common types like TypeError, ValueError, AttributeError in particular)

• (How) can I choose variable names at runtime ("create variable variables")?

• Where does the code start running?

  • How does if __name__ == '__main__': work?

• How do if statements work with non-booleans (values other than True and False)?

  • How do tricks like x and y or z work?

  • Why isn't x < y < z the same as either (x < y) < z or x < (y < z)?

• How do Python's negative indexes (for sequences) work?

• How do Python's slices (for sequences) work?

• How do * and ** work

  • in function parameters?

  • in function-call arguments?

  • in "unpacking" syntax?

  • in "packing" syntax (e.g. merging dicts)?

  • How does / work in function parameters?

• (Something about the conventions Python documentation uses when describing function signatures etc.)

• What's the difference between / and //?

  • How does // work with negative numbers in particular?

• How can I call a method on a literal integer?

• Where does Python look for variable definitions?

  • How do I use (inspect / assign / modify) global variables?

  • ... "non-local" variables from a closure (in a nested function)?

  • What is "shadowing"?

  • Why don't built-in names work properly (after shadowing them), and how do I get them back?

  • Why did I get UnboundLocalError from my local variable?

  • Why did I get UnboundLocalError from my (intended) global variable?

• How do eval and exec work, and why should I avoid them?

• How can I analyze and understand recursive code?

• Why did my recursive code...

  • ... return None instead of the value from a recursive call?

  • ... end up with confused state after returning from the recursive call?

  • raise a RecursionError?

• What is yield (how do generators work)?

  • What is yield from?

  • How does .sending to a generator work?

• What is self? (How do methods work?)

  • (Probably needs several questions, can be elaborated later)

• How do I store separate per-instance data when using classes? (Why are my objects "sharing" a value?)

  • How are attributes looked up/assigned/modified on objects?

  • How do method calls work? (What's a "bound method object", etc.?)

• How does is work?

  • Why are some simple values always the same object and others not?

  • How does the id builtin work? (and related gotchas)

• What are "dunder methods", and how do I use them to make my class easier to use?

  • When would I ever need __new__?

  • How do __op__, __rop__, __iop__ combinations work to implement binary operators?

  • Why is there a __repr__ separate from __str__?

  • How do I make my instances show up neatly when printed?

  • How does __del__ work, and why isn't it called when I expect? (How does it relate to the del keyword?)

  • What are "context managers" and how can I implement one (__enter__ and __exit__)?

• How can I cache or "memoize" results of a function (e.g. for "dynamic programming")?

• How can I open a file?

  • ... and read its contents, e.g. into a list of string lines?

  • ... and overwrite it, append to it, etc.?

  • What are "text mode" and "binary mode"? (Why does it matter, etc.)

  • What's a "data format"? Can I create my own?

  • How can I easily work with XYZ popular data format? (What can I use to read and parse the file, and where do I go from there? Probably many questions of this form, for JSON, TOML, CSV, images, etc.)

• How do I share global variables between modules?

• How do commas (and their precedence) work in Python syntax?

  • (This would probably be split into more concrete questions about gotcha syntax, e.g. failing to make a singleton tuple, the 'a' in 'b', 'a' example from the FAQ, etc.)

• Is there a "ternary operator" (conditional expression) in Python?

• Conceptually, how can I get numbers, lists, etc. (non-strings) input from the user?

  • How can I parse the string representation of e.g. a list and get an actual list?

• How can I repeatedly ask for input until the response is valid?

• How can I make the same/similar code run repeatedly?

  • Specifically, how can I process a list (or other sequence) to get a list of results?

    • (Probably several different questions on this general theme.)

• Techniques for avoiding redundant code

• How can I do many comparisons at once?

  • E.g.: value is one of multiple candidates; all values meet a condition; any value meets a condition; overlap between two groups of values; ...

  • Why is "a == b or c" always evaluating as true?

• How does assignment work in Python?

  • How does modifying an existing value differ from assigning a new one?

  • What uses of = assign, and what uses modify?

  • Doesn't assignment copy values? How do I get independent (mutable) values?

• Why is my default parameter value "remembering" changes between calls?

• How do I use functions to organize the code?

  • How do I provide information to a function / how does it get information?

  • How do I get a result back from a function and use it?

    • ... multiple results?

  • Why do I need to use return? Can't I just print the things I want?

  • What happens when I call a function (how does the program flow work)?

  • If calling a function is not like a "go to", how can I represent "places" in my code?

  • How do values get passed to functions in Python?

  • What happens if I don't return anything?

  • Can I "overload" functions like in other languages? How?

• How can I make nested data (e.g. a list of lists) with independent values?

• How can I copy nested data that's independent of the original?

• How can I access and work with nested data structures?

  • How can I flatten a nested structure by one level?

  • ... All the way (recursively)?

• When would I prefer each built-in "container" data structure (list, tuple, set, dict, ...)?

• How can I properly remove items from a list while iterating (looping) over it?

• How can I store a function and look it up / call it later?

  • ... and "bind" arguments for the later call?

    • When I did this in a loop, why didn't they get separate bound arguments?

  • Why did { 'x': func(value) } not work for this?

• Why does "chaining" methods that modify a list, fail with an AttributeError?

  • What is "command-query separation"?

• How can I iterate through sequences in parallel, and "pair up" the elements?

• How can I get overlapping pairs (or a "sliding window" of longer slices) of a list (or tuple)?

• How can I get *non-*overlapping pieces (split it into chunks of equal size)?

• How can I split a str...

  • at newline characters (into "lines")?

  • on whitespace (into "words")?

  • at other specific delimiter characters?

  • where it matches a pattern?

  • into a specific number of pieces?

  • (N.B. the "into equal-size chunks" case is the same as for lists)

• Are dicts ordered? (How can I sort or re-order them?)

• How can I get a Cartesian ("cross") product of elements from multiple input sequences?

• What are combinations, permutations, combinations_with_replacement and product from itertools, and how do I choose between them? (How do I "get combinations" of values, for varying informal definitions of "combination"?)

• How do combinations etc. work when there are duplicate elements in the input?

• How can I compute the number of combinations, permutations etc. without generating them?

• (Possibly some more "advanced" combinatorics questions, but those are definitely lower priority.)

• How can I remove duplicates from a list?

  • ... and preserve order?

• How do I properly iterate over a dict?

• How can I find out what methods or (other) attributes an object has

• How can I find out an object's name? (Deliberately ambiguous; a question like this needs to address confusion)

  • Within the code of my module, how can I find the module's name?

• Within the code of my module, how can I get the module object itself? (Lower priority, but prompted by the above)

• How can I reverse a list (or tuple), or process it in reverse?

• Why does a_tuple[i] += ['item'] raise an exception when the addition works? (I really can't improve on the FAQ title...)

• How can I sort a list...

  • ... according to an attribute, etc. of the elements?

  • ... according to a function calculated on the elements?

  • ... according to keys provided in another list?

  • ... according to where its elements appear in another list?

  • ... if I don't know how to "key" the elements, but know how to compare two elements?

• How can I sort one list, and rearrange another in a corresponding way? (N.B. This is actually the same as "sort according to keys provided in another list"; we can sort the "other" list naturally, and rearrange the first one correspondingly.)

• How can I check the type of an object at runtime?

  • What is "the type of an object" in Python's type system?

• How can I find all the instances of a class?

• What are metaclasses and how are they used?

  • How can Python represent types as objects?

  • How can type be its own type?

• What is super and how is it used?

• What are decorators and how are they used?

  • What are @staticmethod and @classmethod and how are they used (and how do they differ from each other)?

• What is "name mangling" in Python and how does it work?

• What are .pyc files and the __pycache__ folder? (Is Python "compiled"?)

• (Why) Can I put import statements not at the top of the file? (Should I?)

• How does from ... import ... syntax work? (Why does it let me "import" both modules and non-modules?)

• What happens in Python when a module is imported?

  • Is the source code necessary to make imports work?

  • Can I import from things that are not Python code? How?

• How do I write an absolute import statement?

• How do I write a relative import statement?

  • Why doesn't import .example work?

• How does Python look for modules, and how do I influence that

  • ... when doing an absolute import?

  • ... when doing a relative import?

    • Why can't Python always find the parent module (or "package") in the parent directory?

    • What's necessary in order to set up working relative imports?

  • Can I import a module "dynamically" (i.e. using a path to the code file decided at runtime)? How?

    • (Probably something about how __import__ works)

  • Why did my import find the wrong file (raise an exception based on the wrong file's contents)?

    • Why did I get an import error from my code unexpectedly importing itself?

    • Why does my REPL break, etc. when I name my code the wrong way?

    • How can I fix "shadowing" problems (e.g. access the standard library despite my own code's module names)?

  • What does and doesn't work in terms of circular imports in Python?

  • Why does top-level module code only run once when I import the module multiple times? (How) can I "reload" the module?

  • (It might make sense to factor out a more general question about the sys.modules cache, and have some other things refer to that. We can worry about that later.)

• How can I choose between relative and absolute imports?

• What do __init__.py files accomplish?

• (Probably a lot of questions about virtual environments and packaging; I've done some of these already and the rest may be less important)

• Something about scoping and the unscoped keyword.

• Something about nil-safe references. I can stick a & on the end of everything that could be nil in function calls like something&.function(), where calling function() on nil emits an error, but I probably shouldn't just be sprinkling &s through my code just in case, right? But what should I be doing?

• This might sound dumb, but in view code, it took me a while to notice (and thus get) the difference between <% ruby code %> and <%= ruby code %>.

• Our project uses the MVC pattern but there are also helpers (in app/helpers, alongside app/view etc). How are those tied in to the rest of the code? I usually run into this by starting from a view, trying to track behavior back to the controller, and coming up empty in the controller.

• Something about database migrations versus maintenance tasks -- if I need to move some data, when should I prefer which?

Unicode related questions. I guess "What is Unicode?" is too broad, we could split it in more specific ones:

• What is an Unicode code point?
• How Unicode defines a character?
• What are encodings?
• What are the normalization forms?
• What's a collation?

Floating point arithmetic:

• Why 0.1 + 0.2 == 0.3 is false?
• What is IEEE 754?
• Why NaN is not equal to itself?

Others:

• Paradigms. There's already What's the difference between Inheritance and Polymorphism?, but it could expand to:
  • What's functional Programming?
  • What's Object Oriented Programming?
  • And so on (maybe those are too broad and could be split in more specific questions)
• Type systems: difference between static and dynamic typing, strong and weak typing