[Quick Python] 4. The absolute basics

以下內容來自 "The Quick Python Book" : 

Preface : 
This chapter describes the absolute basics in Python: assignments and expressions, how to type a number or a string, how to indicate comments in code, and so forth. It starts out with a discussion of how Python blocks structures its code, which is different from any other major language. 

* Indenting and block structuring
* Differentiating comments
* Assigning variables
* Evaluating expressions
* Using common data types
* Getting user input
* Using correct Python style

Indentation and block structuring : 
Python differs from most other programming languages because it uses white-space and indentation to determine block structure (that is, to determine what constitutes the body of a loop, the else clause of a conditional, and so on). Most language use braces of some sort to do this. Below is C code that calculate the factorial of 9, leaving the result in the variable r : 

view plaincopy to clipboardprint?

1. /*This is C code*/  
2. int n, r;  
3. n = 9;  
4. r = 1;  
5. while(n > 0) {  
6.     r *= n;  
7.     n--;  
8. }  

The { and } delimit the body of the while loop, the code that is executed with each reputation of the loop. The code is usually indented more or less as shown. Below's the Python equivalent : 

view plaincopy to clipboardprint?

1. # This is Python code. (Yea!)  
2. n = 9  
3. r = 1  
4. while n > 0:  
5.     r = r * n  
6.     n = n - 1  

Python doesn't use braces to indicate code structure; instead, the indentation itself is used. The last two lines of the previous code are the body of the while loop because they come immediately after the while statement and are indented one level further that the while statement. If they weren't indented, they would't be part of the body of the while. Using indentation to structure code rather than braces may take some getting used to, but there are significant benefits : 

* It's impossible to have missing or extra braces. You'll never need to hunt through your code for the brace near the bottom that matches the one a few lines from the top.
* The visual structure of the code reflects its real structure. This makes it easy to grasp the skeleton of code just by looking at it.
* Python coding styles are mostly uniform. In other words, you're unlikely to go crazy from dealing with someone's idea of aesthetically pleasing code. Their code will look pretty much like yours.

Differentiating comments : 
For the most part, anything following a # symbol in a Python file is a comment and is disregarded by the language. The obvious exception is a # in a string, which is just a character of that string : 

view plaincopy to clipboardprint?

1. # Assign 5 to x  
2. x = 5  
3. x = 3  # Now x is 3  
4. x = "# This is not a comment"  

We'll put comments into Python code frequently. 

Variables and assignments : 
The most commonly used command in Python is assignment, which looks pretty close to what you might've used in other languages. Python code to create a variable called x and assign value 5 to that variable is : 

x = 5

In Python, neither a variable type declaration nor an end-of-line delimiter is necessary, unlike in many other computer languages. The line is ended by the end of the line. Variables are created automatically when they're first assigned. 
Python variables can be set to any object, unlike C or many other languages' variables, which can store only the type of value they're declared as. The following is perfectly legal Python code : 

>>> x = "Hello"
>>> print(x)
Hello
>>> x = 5
>>> print(x)
5

x starts out referring to the string object "Hello" and then refers to the integer object 5. Of course, this feature can be abused because arbitrarily assigning the same variable name to refer successively to different data types can make code confusing to understand. 

A new assignment overrides any previous assignments. The del statement delete the variable. Trying to print the variable's contents after deleting it gives an error the same as if the variable had never been created in the first place : 

>>> x = 5
>>> print(x)
5
>>> del x # 從當前 scope 刪除變數 x 的空間. 
>>> print(x)
Traceback (most recent call last):
File "", line 1, in
NameError: name 'x' is not defined

Here we have our first look at a traceback, which is printed when an error, called an exception, has been detected. The last line tells us what exception was detected, which in this case is a NameError exception on x. After its deletion, x is no longer a valid variable name. In this example, the trace returns only line 1, in because only the single line has been sent in the interactive mode. In general, the full dynamic call structure of the existing function calls at the time of the occurrence of the error is returned. 

Variable names are case sensitive and can include any alphanumeric character as well as underscores but most start with a letter or underscore. 

Expressions : 
Python supports arithmetic and similar expressions; these will be familiar to most readers. The following code calculates the average of 3 and 5, leaving the result in the variable z : 

view plaincopy to clipboardprint?

1. x = 3  
2. y = 5  
3. z = (x + y) / 2  

Note that unlike the arithmetic rules of C in terms of type coercions, arithmetic operators involving only integers do not always return an integer. Even though all the values are integers, division (starting with Python 3) returns a floating-point number, so the fractional part isn’t truncated. If you want traditional integer division returning a truncated integer, you can use the // instead. Expressions don’t have to involve just numerical values; strings, Boolean values, and many other types of objects can be used in expressions in various ways. We’ll discuss these in more detail as they’re used. 

Strings : 
You’ve already seen that Python, like most other programming languages, indicates strings through the use of double quotes. This line leaves the string "Hello, World" in the variable x : 

x = "Hello, World"

Backslashes can be used to escape characters, to give them special meanings. \n means the newline character, \t means the tab character, \\ means a single normal backslash character, and \" is a plain double-quote character. It doesn’t end the string : 

view plaincopy to clipboardprint?

1. x = "\tThis string starts with a \"tab\"."  
2. x = "This string contains a single backslash(\\)."  

You can use single quotes instead of double quotes. The only difference is that you don’t need to backslash " characters in single-quoted strings or ' characters in double-quoted strings : 

view plaincopy to clipboardprint?

1. x = "Don't need a backslash"  
2. x = 'Can\'t get by without a backslash'  
3. x = "Backslash your \" character!"  
4. x = 'You can leave the " alone'   

You can’t split a normal string across lines; this code won’t work : 

view plaincopy to clipboardprint?

1. # This Python code will cause an ERROR -- you can't split the string  
2. across two lines.  
3. x = "This is a misguided attempt to  
4. put a newline into a string without using backslash-n"  

But Python offers triple-quoted strings, which let you do this and permit single and 
double quotes to be included without backslashes : 

view plaincopy to clipboardprint?

1. x = """Starting and ending a string with triple " characters  
2. permits embedded newlines, and the use of " and ' without  
3. backslashes"""  

Now x is the entire sentence between the """ delimiters. (You can also use triple single quotes—'''—instead of triple double quotes to do the same thing.) 

Numbers : 
Because you’re probably familiar with standard numeric operations from other languages, here doesn’t contain a separate chapter describing Python’s numeric 
abilities. This section describes the unique features of Python numbers, and the Python documentation lists the available functions. 

Python offers four kinds of numbers: integers, floats, complex numbers, and Booleans. An integer constant is written as an integer—0, –11, +33, 123456—and has unlimited range, restricted only by the resources of your machine. A float can be written with a decimal point or using scientific notation: 3.14, –2E-8, 2.718281828. The precision of these values is governed by the underlying machine but is typically equal to double (64-bit) types in C. Complex numbers are probably of limited interest and are discussed separately later in the section. Booleans are either True or False and behave identically to 1 and 0 except for their string representations. 

Arithmetic is much like it is in C. Operations involving two integers produce an integer, except for division (/), where a float results. If the // division symbol is used, the result is an integer, with truncation. Operations involving a float always produce a float. Here are a few examples : 

>>> 5 + 2 - 3 * 2
1
>>> 5 / 2 # floating point result with normal division
2.5
>>> 5 / 2.0 # also a floating point result
2.5
>>> 5 // 2 # integer result with truncation when divided using '//'
2
>>> 30000000000 # This would be too large to be an int in many languages
30000000000
>>> 30000000000 * 3
90000000000
>>> 30000000000 * 3.0
90000000000.0
>>> 2.0e-8 # Scientific notation gives back a float
2e-08
>>> 3000000 * 3000000
9000000000000
>>> int(200.2) # (1)
200
>>> int(2e2) # (1)
200
>>> float(200) # (1)
200.0

These are explicit conversions between types (1). int() will truncate float values. Numbers in Python have two advantages over C or Java. First, integers can be arbitrarily large; and second, the division of two integers results in a float. 

- Built-in numeric functions 
Python provides the following number-related functions as part of its core : 

abs(), divmod(), cmp(), coerce, float(), hex(), int(), long(), max(), min(), oct(), pow(), round()

- Advanced numeric functions 
More advanced numeric functions such as the trig and hyperbolic trig functions, as well as a few useful constants, aren’t built-ins in Python but are provided in a standard module called math. Modules will be explained in detail later; for now, it’s sufficient to know that the math functions in this section must be made available by starting your Python program or interactive session with the statement : 

from math import *

- Numeric computation 
The core Python installation isn’t well suited to intensive numeric computation because of speed constraints. But the powerful Python extension NumPy provides highly efficient implementations of many advanced numeric operations. The emphasis is on array operations, including multidimensional matrices and more advanced functions such as the Fast Fourier Transform. 

- Complex numbers 
Complex numbers are created automatically whenever an expression of the form nj is encountered, with n having the same form as a Python integer or float. j is, of course, standard engineering notation for the imaginary number equal to the square root of –1. Note that Python expresses the resulting complex number in parentheses, as a way of indicating that what is printed to the screen represents the value of a single object : 

>>> 3 + 2j - (4+4j)
(-1-2j)
>>> (1+2j) * (3+4j)
(-5+10j)
>>> 1j * 1j
(-1+0j)

Calculating j * j gives the expected answer of –1, but the result remains a Python complex number object. Complex numbers are never converted automatically to equivalent real or integer objects. But you can easily access their real and imaginary parts with real and imag : 

>>> z = (3+5j)
>>> z.real
3.0
>>> z.imag
5.0

(Note that real and imaginary parts of a complex number are always returned as floatingpoint numbers.) 

- Advanced complex-number functions 
The functions in the math module don’t apply to complex numbers; the rationale is that most users want the square root of –1 to generate an error, not an answer! Instead, similar functions, which can operate on complex numbers, are provided in the cmath module : 

acos, acosh, asin, asinh, atan, atanh, cos, cosh, e, exp, log, log10, pi, sin, sinh, sqrt, tan, tanh.

In order to make clear in the code that these are special-purpose complex-number functions and to avoid name conflicts with the more normal equivalents, it’s best to import the cmath module by saying : 

import cmath

and then to explicitly refer to the cmath package when using the function : 

>>> import cmath
>>> cmath.sqrt(-1)
1j

 

The None value : 
In addition to standard types such as strings and numbers, Python has a special basic data type that defines a single special data object called None. As the name suggests, None is used to represent an empty value. It appears in various guises throughout Python. For example, a procedure in Python is just a function that doesn’t explicitly return a value, which means that, by default, it returns None. 

None is often useful in day-to-day Python programming as a placeholder, to indicate a point in a data structure where meaningful data will eventually be found, even though that data hasn’t yet been calculated. You can easily test for the presence of None, because there is only one instance of None in the entire Python system (all references to None point to the same object), and None is equivalent only to itself. 

Getting input from the user : 
You can also use the input() function to get input from the user. Use the prompt string you want displayed to the user as input’s parameter : 
 

This is a fairly simple way to get user input. The one catch is that the input comes in as a string, so if you want to use it as a number, you have to use the int() or float()function to convert it. 

Built-in operators : 
Python provides various built-in operators, from the standard (such as +, *, and so on) to the more esoteric, such as operators for performing bit shifting, bitwise logical functions, and so forth. Most of these operators are no more unique to Python than to any other language, and hence I won’t explain them in the main text. You can find a complete list of the Python built-in operators in the documentation. 

Basic Python style : 
Python has relatively few limitations on coding style with the obvious exception of the requirement to use indentation to organize code into blocks. Even in that case, the amount of indentation and type of indentation (tabs versus spaces) isn’t mandated. However, there are preferred stylistic conventions for Python, which are contained inPython Enhancement Proposal (PEP) 8, which is summarized in the appendix. A selection of Pythonic conventions is provided in table 4.1, but to fully absorb Pythonic style you’ll need to periodically reread PEP 8 : 
 

Supplement : 
* [Python 學習筆記] 函式、類別與模組 : 模組 (import、import as、from import)