The type Tuple is missing from the Variables section and also High level data structure?

Section: Introduction 2
Issue: Sentence is too long and would require multiple reads to understand.
Because of it's English like syntax, Python makes for an excellent prototyping language, any program implemented in Python has significantly less number of lines as compared to Java, but because it is a dynamically typed language, it is somewhat difficult to debug the programs written in Python or we need to be extra careful while writing them.

Fix

Because of its English like syntax, Python makes for an excellent prototyping language**.** Any program implemented in Python has significantly less number of lines as compared to Java. But because it is a dynamically typed language, it is somewhat difficult to debug the programs written in Python. Thus, we need to be extra careful while writing them.

Give your feedback here!

Introduction

because the changes are that someone already has written a package for that.

Replace changes with chances

In https://github.com/thewhitetulip/build-app-with-python-antitextbook/blob/master/manuscript/03-01-understanding-variables.md, it could be helpful to also show the difference between 1 and 1.0, e.g.

>>> type(1)
<type 'int'>
>>> type(1.)
<type 'float'>
>>> type(1.0)
<type 'float'>

More detailed examples for the operators

Feedback from r/learnpython. Need to modify the content to align with the larger goal of writing a guide for a newcomer to Python without presuming a linux background.

But who is this book for? Experienced coders learning Python? Absolute beginners with no coding experience in any language? Something in between? It's hard to tell -- you explain some basic concepts (string liberals, variables), but not others (the difference between the Python command line and the shell; how to get to each). Try to pick a target reader, and go through with that person in mind. An absolute beginner will need more hand-holding than you currently provide in some areas, or at least more indication that they should hold tight and not worry about not understanding everything yet -- sending beginners to the documentation is a sure way to lose them -- while experienced programmers will need a lot less.

In chapter 03-01 you did type comparison with the expression:

if type(a) == type(""): print("a is string")

You may want to say that everything in Python is an object, and explains why and how

isinstance('a string', str)

works as well.

https://github.com/thewhitetulip/build-app-with-python-antitextbook/blob/master/manuscript/03-01-understanding-variables.md#L45

See: https://docs.python.org/3.6/reference/expressions.html#is

x is y
# Can be rewritten as
id(x) == id(y)

If something goes wrong, our program complains, if everything goes wrong, we say nothing.
Maybe, wrong should be right?

https://github.com/vezycash/build-app-with-python-antitextbook/blob/master/01-intro-to-python.md#using-glob

current code

>>> import glob
>>> files = glob.glob('*.txt')
>>> files

(in windows python 3.6, calling files without a print statement does not display anything
Fix

import glob
files = glob.glob('*.txt')
print(files)

A mention could be deserved by list comprensions and generators (on which an entire chapter, maybe, should be done).

Specifically, you may want to explain the difference between

[requests.get('http://website.com/page/{}'.format(x) for x in range(0,10)]

and

(requests.get('http://website.com/page/{}'.format(x) for x in range(0,10))

which is a very powerful example on how generators may help during software development.

In 03-01-understanding-variables.md, under String, it says that escapes like \n\t are affected by the use of " or '. This is incorrect as there is no difference to Python with respect to which quote character you use. The only difference is which character you can use within the string without escaping.

If you do want to disable escape sequences, it requires prefixing the string with r and it doesn't matter which quote character is used. That is, r'this string\n\t' or r"this string\n\t" both do not use the escape sequences and apply the strings literally.

import sys
for i, item in enumerate(sys.argv):
    print("{} {}".format(i, item))

https://www.reddit.com/r/learnpython/comments/608fm3/thank_you_rlearnpython_just_finished_the_final/df4tjl3/

You don't show the % (modulus) operator at the top in the beginning but you show it in the interpreter in the division section.

But you don't say what it is and the result you typed is wrong:
>>> 27%7
1

but 27%7 = 6

http://notebooks.azure.com is a free, hosted Jupyter notebook service by microsoft.com

Check out the intro to python sample on the front page.

It would be great if this guide is added so that anyone can view & run it.

Cheers,

s (disclaimer - associated w the project)

There are a large number of languages out there and new ____ coming out (new) week, so this question is important, why learn Python over X.

Try

There are a large number of languages out there and new ones coming out every week. So the question why learn Python over X is important.

glob in Python 3 supports a wide variety of syntax including **/*.txt. Being an anti-textbook, glob is more suitable for 01-intro-to-python.md, in my opinion.

>>> import glob
>>> glob.glob('*.txt')
['file1.txt',
 'file2.txt',
 'file3.txt',
 'file4.txt',
 'file5.txt']

https://github.com/thewhitetulip/build-app-with-python-antitextbook/blob/master/01-intro-to-python.md#example-list-all-txt-files

import os
files = os.listdir()
for file in files:
    if file.endswith(".txt"):
        print(file)

Function os.listdir() expects an argument (a folder name)

files = os.listdir("folder")

folder = the folder which contains the text files.

OR
files=os.listdir(".")
//In this case, the files have to be in the same directly as file.py

Section: Writing Style

Original

Code that is supposed to run on the Interpreter starts with >>> like >>> not True. In this case, >>> not True is the statement and False is the output.

>>> not True
  False

Reordered

Code that is supposed to run on the Interpreter starts with >>>
Example:

>>> not True
  False

In this case, >>> not True is the statement and False is the output.

There is an error in the tutorial, triple quoted strings are told as multiple line comments without mentioning docstrings.

Elaborate more on comments and their importance

Hi,

Suraj I would like to know how you usually start your books.

Do you first write stuff into an manuscript folder on Github and then import it to Gitbooks or do you first start with an GitBook template?

see PEP3101 .format was introduce in python 2.6 and should be the preferred way to do string interpolation

Section: Introduction 2

Because of it's English like syntax,

Fix: Change it's to its

Need to update README and chapterone

URL: https://github.com/vezycash/build-app-with-python-antitextbook/blob/master/02-more-about-language.md#hybrid-approach

In an era where computers also are capable to write Python scripts, we need to be better than them!

Fix
In an era where computers also are capable of writing Python scripts, we need to be better than them!

I think implementing basic algorithms with python is a great way to learn. For examples Stack, Singly Linked Lists, Circular Linked Lists, Doubly Linked Lists, Arrays, Binary Trees, Binary Search, Recursion and String Processing.

... python creates a new variable and does not.

From line 151 of manuscript/03-01-understanding-variables.md.

All examples are in procedural style. Please, add a chapter about OOP. Thank you!

We need to teach the user to search and navigate the documentation, hence it would be helpful if we add a link to the topics that we have in the book to the docs

No example exists for the with clause
is statement missing

I applaud you for trying to do this - but I have noted one or more issues :

• Variables page - the id function does not return the address - it returns the object identifier. It is not intended to be nor should it be implied that it is the address.
• Variables Page - a nit pick here but strictly speaking the variable doesn't have a type. The value has a type and the name simply points to an object which has a value. In Python it is dynamic typing, so you can assign an integer object to a name, and two lines later assign a string object to the same name. Talking about objects (rather than 'memory') is important because only some objects in Python are mutable, and some aren't : adding something to a list will change the list - adding a value to a number will create a brand new object for the new value; that distinction is critical.
• Your 'more about the language' page mentions 'Batch mode' - no-one I know calls it that. Please use the right terminology.
• Constructs page : Most beginners wont understand what 'constructs' mean, and if they do, they aren't beginners; I would suggest a page titled making decisions, and another page entitled loops.
• Constructs page: you mention that indentation is counted as 4 spaces - stricly this is wrong - you can use any level of indentation you want so long as your blocks are consistent. I know indents of 4 spaces are recommeded by you can use 1 space, 3, 8 or anything.
• Constructs page: You give this example :

    for i in range(len(l)):
        print(l[i]) 

This is so horrible that it is strongly discouraged. If you need to have the index of an item of the list - do this :

for index, item in enumerate(my_list):
     print(index, ':', item )

• Constructs page : I appreciate you attempting to show your indentation - but I am not sure using [] to illustrate where the intendentations are works - is there a different way to do this ?
• Constructs page : No mention of else after a loop so that you can execute code only if the list doesn't execute a break.
• Your list, sets, dicts page contains no details of how to iterate around these (i.e. a for loop), and no mention of using enumerate while iterating to get the index and the element.
• Your file handling section is poor to be honest - you do a readline() before each loop; not only is this superfluous, but with a very large file you could well end up filling memory. You appear not to realise that an an open file is an iterator (it has been since Python2.3) or earlier, which means you can use a for loop to iterate around the file contents
• No mention of 'with' to open file safely (i.e. ensure it is always closed). This is much prefered than using open/close and hoping nothing goes wrong.
• Your file handling page mentions list comprehensions - should this be in the list,set,dict page - or a page on it's own ? Also - no mention of dict or set comprehensions.
• Exception handling - no mention of using 'else' to execute code if no exception is triggered - different from 'finally'
• Functions - No mention of mutating arguments (if a function is passed a mutable value as an argument, and the function changes that value, then the calling function will see that change).
• Functions - no mention of not using 'mutable objects' as default arguments - it doesn't do what most beginners think it should.
• Todo list manager : Instead of using a '|' to separate title and content and text files - why not show your students the better way to do things - each task should be a dictionary - that enables you to extend the dictionary later - maybe with due dates etc. and then use the pickle library to save and load your list of tasts. It is far better to do that than to try to use text for complex data.
• CSV to sql - why not use the CSV reader module - you should be showing your students the power of the standard library rather than writing their own.

Please - try to fix these issues - as I say - I applaud you for trying - but if you want to teach - teach best practice.