x**2 # x squared

- Float : <class 'float'>
```python
float('-inf')
float('inf')	

int('123') # Convert string to number

nums.pop(0) # pop specified element

tuple = ()
tuple = ('123', 123)
tuple([123, 456])

- Boolean: <class 'bool'> True, False, true
- Set: Automatically removes duplicate elements
```python

set("test")
set1 = set(['23', '454'])
set2 = set(['34'])
print('234' in set1)
print(set1 - set2) # Difference
print(set1 | set2) # Union
print(set1 ^ set2) # Symmetric Difference

dict2 = { 'a': 1231 }
dict1 = dict({1: 'Geeks'}) # Other way dict(aaa=123) dict(('asdf', 123))
dict1[1]
del dict1[1]
dict1.keys()
1 in dict1 # Check if key exists

# Array to Dictionary

list_1 = [('a', 1), ('b',2)]
result = dict(list_1)
print(result)

defaultdict(list) # Declare a hashmap, similar to userId -> list
defaultdict(set) # Declare a hashmap, similar to userId -> set

a, b = 1, 2

z = []
if z:
	print(True)

### Basic Methods of Data Types

Number
```python
323 // 3 # Integer division (truncates towards zero)

dict.items() # Returns an array (elements are tuples)

dict.get('a', 0) # The second parameter can be used to assign a default value

name = "Alice"
age = 30

# Using f-string
print(f"My name is {name} and I am {age} years old.")

# Using format
print("Hello, {}. You are {} years old.".format("Alice", 25))
# Output: Hello, Alice. You are 25 years old.

print("Hello, {1}. You are {0} years old.".format(25, "Alice"))
# Output: Hello, Alice. You are 25 years old.

print("Hello, {name}. You are {age} years old.".format(name="Alice", age=25))
# Output: Hello, Alice. You are 25 years old.

list = [1,2]
list[-1] # Access the last element

Array slicing
``` python
list[:k] # Returns the first k elements 
list[k+1:] # Returns elements from k+1 (inclusive) onwards

list_1 = [('A', 1), ('b',2), ('b',3), ('d', 6)]  
keys = [item[0] for item in list_1[:3]]  
print(keys)

Initialize the array:
``` python

list = [0] * length # Initialize the array

Merge array
``` python
list = [4, 5]
list.extend([2,2,3]) # Will modify the original array
  
list2 = list + [6,8]  # Merges and returns a new array

### Two-dimensional array
```python
# Define a list of lists called 'dict'
dict = [
    [123, 1],
    [4, 5455]
]

# Iterate over the range from 0 to 2 (exclusive)
for i in range(2):
    # Create a new list using list comprehension
# For each 'row' in 'dict', select the element at index 'i'
    selected_elements = [row[i] for row in dict]

    # Print the resulting list
    print(selected_elements)

# Sort the array  
list_1 = [('A', 1), ('b',2)]  
print(sorted(list_1, key=lambda x:x[1], reverse=True))  
list_2 = [4,2,6]
print(sorted(list_2, reverse=True)) 

# To sort a dictionary (which is like an object), you need to first convert it into an array (with elements being tuples) using the
# dict.items() method, and then sort it
dict_1 = { 'a': 5, 'b': 4, 'd': 3 }
print(sorted(dict_1.items(), key=lambda x:x[1]))

# reverse
sorted(list)[::-1]

 range(4) => [0,1,2,3,4] 
 range(0, 10, 3) # increments by 3  
 range(3, -1, -1) # represents step size in reverse order

filter(fn, [])
map(fn, []) map(fn, [], [])
reduce(fn, []) reduce(fn, [], 0)







### Keywords
in 
not in 
del
not
or: Equivalent to ||
and: equivalent to &&
pass statement does nothing, it's just used for placeholders
None
False
True
true
is
as: alias

```python
result = 3 * 4  # Multiplication: result is 12

result = 2 ** 3  # Exponentiation: result is 8


"ADF" * 123 # ADF repeated 123 times

class Reverse:
    """Iterator for looping over a sequence backwards."""
    def __init__(self, data):
        self.data = data
self.index = len(data)
        
    def __iter__(self):
        return self
    
    def __next__(self):
if self.index == 0:
            raise StopIteration
        self.index = self.index - 1
        return self.data[self.index]

# Example usage
rev = Reverse('spam')

# Using iter() explicitly is not necessary, as the __iter__ method is defined in the class
# iter(rev)

for char in rev:
    print(char)

set1 = set(['Geeks', 'For'])
for i in set1:
	print(i, end=" ")
print("Geeks" in set1)


for i, v in enumerate(['tic','ggg']):
print(i, v)

questions = ['name', 'quest']
answers = ['asdfa', 'ggg']
for q, a in zip(questions, answers):
	print('what is your {0} ? It is {1}'.format(q, a))

# Complex example
a = [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
print(a)


for element in [1, 2, 3]:
    print(element)
for element in (1, 2, 3):
print(element)
for key in {'one':1, 'two':2}:
    print(key)
for char in "123":
print(char)

val if not self.min else min(val, self.min[-1])

if not self.min # Check if array is empty
if self.min # Check if array is not empty

### Functions

Functions are defined using the def keyword, and they can be assigned values

```python

def fib(n): 
	a = 0
	while a < n:
print(a)

def ask_ok(prompt, retries=4, complaint='Yes or no, please!'):
	print(prompt)

def f(a, L = None):
	pass


def f(a, L):

Keyword parameters (function annotations)

```python
def greet(name, *, greeting="Hello", punctuation="!"):
    """
Greets a person with a customizable message.

    Parameters:
    - name: The name of the person.
    - greeting: The greeting message (default is "Hello").
- punctuation: The punctuation to add to the message (default is "!").
    """
    print(f"{greeting}, {name}{punctuation}")

# Calling the function with both positional and keyword arguments
greet("Alice", greeting="Hi")  # Output: "Hi, Alice!"

# This would raise a TypeError because 'greeting' is specified as a keyword-only argument
# greet("Bob", "Hi")

# Print function annotations
print(greet.__doc__)

def topK(nums: List[int]) -> List[int]:

sorted(dict().items(), key = lambda x: x[1])

res = 0
def test:
	print(res)
test() # This will cause an error


res = [0]
def test:
	print(res[0]) # This is ok
test()

#python or declare as nonlocal

res = 0
def test:
	nonlocal res
print(res)

# ** Dictionary Destructuring
def parrot(voltage, state='a stiff', action='voom'):
    print(action, voltage, state)
    
dict = { "voltage": 12, "state": 'g', "action": 'Zo' }

parrot(**dict)


# * Deconstruction
a, *rest = [1, 2, 3, 4, 5]  # Unpacks the first element into 'a', and the rest into 'rest'

first, *rest, last = [1, 2, 3, 4, 5]
# 'first' is 1, 'rest' is [2, 3, 4], 'last' is 5


def my_function(*args):
    # 'args' is a tuple containing all positional arguments passed to the function
    print(args)

my_function(1, 2, 3)  # Output: (1, 2, 3)

values = [1, 2, 3]
my_function(*values)  # Equivalent to my_function(1, 2, 3)

# Array destructuring
a, b = [1, 5]

class MyClass: 
	""" test """
	i = 123123 # Class shared variable
	def __init__(self):
self.i = 323; # instance variable
def f(self):
	return 'hello'
		
		
a = MyClass.f('asdf')

b = MyClass.i

print(b)

b = MyClass()

print(b.i)

print(MyClass.__doc__)

class MyClass2(MyClass):
    j = 123

# Multiple inheritance
class MyClass2(MyClass, MyClassBase):
j = 123

class Mapping:
    def __init__(self, iterable):
        self.items_list = []
        self.__update(iterable)
def update(self, iterable):
        for item in iterable:
            self.items_list.append(item)
    __update = update  # Copy one update method
class MappingSubclass(Mapping):
    def update(self, keys, values): # Subclasses can override the update method without affecting the init method
        for item in zip(keys, values):
            self.items_list.append(item)

class CustomExceptionHandler:
    def __enter__(self):
        # The operations to be performed when entering the with statement block
        pass

def __exit__(self, exc_type, exc_value, traceback):
        if exc_type is not None:
            # When exiting the with statement block, if an exception occurs, the actions to be performed
            print(f"Caught exception: {exc_type.__name__}, Error message: {exc_value}")
# Here you can add custom exception handling logic

            # Return True to indicate the exception has been handled and will not be thrown again; return False to indicate the exception will continue to propagate
            return True
        # If no exception occurs, return None

# Example Usage
try:
    with CustomExceptionHandler():
    # Place code that may raise exceptions here
result = 1 / 0  # Division by zero will raise a ZeroDivisionError exception
except Exception as e:
    # Here you can handle exceptions not processed by CustomExceptionHandler
    print(f"Exception not handled by CustomExceptionHandler: {type(e).__name__}, Error message: {str(e)}")

raise StopException

import module_name as alias_name # Import module

### Running the Python interpreter

```python
python -c command [arg]

quit()

math.isnan()
math.prod() # multiplication

from collections import OrderedDict

#### Related to Liss

Package name: collections

```python
# Import the 'deque' class from the 'collections' module

Package: bisect

```python
import bisect
scores = [(100, 'PER1'), (200, 'TCS'), (400, 'dsf')]
bisect.insort(scores, (300, 'sdf'))
print(scores)

from decimal import *

#### Weak references

```python
import weakref, gc
class A:
    def __init__(self, value):

#### IO operations

open() Open a file

#### Log

```python
import logging
logging.debug('Debugging')

logging.info('Infomatiiii')

logging.warning('Warning')

logging.error('error')
logging.critical('critical')

dq = deque([root]) # Deque

node = dq.popleft()

import heapq # Python does not have a max heap. So generally, all values are made negative to simulate a max heap

minheap = [2,2,3]
# Or

---

Python is a relatively popular language, for personal interest refer to the official documentation: <https://docs.python.org/2/tutorial/index.html>
I translated it while reading (it will be continuously updated), those interested can take a look.

Python has advanced data structures and can efficiently support object-oriented programming. Its elegant syntax, dynamic typing, and interpreted nature allow it to quickly develop applications on most platforms. Its third-party packages, tools, and libraries can all be found here: <https://www.python.org/。>

Python is easy to extend through C/C++ functions or data types. For writing extensions, see: [Extending Python](https://docs.python.org/2/extending/index.html#extending-index), [Python C/C++ API](https://docs.python.org/2/c-api/index.html#c-api-index)

For more documentation, see [Python Standard Library](https://docs.python.org/2/library/index.html#library-index), [Python API](https://docs.python.org/2/reference/index.html#reference-index)

Through this introductory tutorial, you will learn some common features of Python and methods or modules of the standard library.

### Preface

For those who work in front of the computer every day, you might need to do some automated tasks, such as batch replacement, search and replace, or you might want to write some interface programs, games, etc.

While for professional software developers, developing through C/C++/Java libraries
、Testing, compiling, etc., are too cumbersome.

At this point, Python is the best choice.

You can write some shell scripts or bat scripts to move files or modify data, but they are not very suitable for writing interface programs or games. C/C++/Java are too cumbersome. Python is more suitable for quickly completing the work you want on various platforms (Windows, Mac, Unix).

Python is a true programming language, it has advanced data structures, such as flexible arrays and dictionaries that can be manipulated.

Python is modular, and its standard library contains some modules that you can use, which provide functions such as file I/O, sockets, etc.

Python can write more concise programs than C/C++/Java, for three reasons:
1 It has advanced data structures
2 It uses indentation to distinguish blocks of code rather than parentheses
3 No need for variable or parameter declarations

Python is extensible. You can embed the Python interpreter into a C program.

### Using the Python Interpreter

Run the python interpreter

Method 1:
The Python interpreter is generally installed in the /usr/local/bin/python directory under Linux. Switch to this directory and enter the following command to run the Python interpreter

Generally, on Windows, it is installed in the C:\Python27 directory. Press the Win+R shortcut, then type cmd to open the DOS interface. Enter the following command to set the environment variable:

python -c command [arg] ..

quit()

python -m module [arg] ...

Enter interactive command mode:

Multi-line mode is... Single line is>>>

Interpreter and environment

Set code encoding

Generally, it doesn't need to be set. The default is utf-8

Introduction to Python

The beginning marks comments, >>> and ... mark Python statements

Treat Python as a calculator

#### Number

Here 2 is int and 5.0 is float. The type of the result of / is determined by the two numbers involved in the calculation. If one of the numbers is float, the result will be of float type.
// The operator is floor division, with the decimal part set to 0.

% is the remainder
** is exponentiation

Declare variable n=12
If you use an undeclared variable, it will cause an error

Polynomial calculations will automatically perform data type conversion: when calculating with int and float together, int will be automatically converted to float

In interactive mode, the last printed variable is assigned to _

_is read-only and cannot be assigned.

#### String

Strings are enclosed in single or double quotes, and \ is used for escaping
If you don't want to escape: add an r before the string

Multi-line string: Three """ or '''

\identifier remove line break, no \ output is like this:

String concatenation: + String repetition:*

Automatic concatenation:

Get a single character from a string

Negative indicators read from the end: -0 is equal to 0 The last character is -1

Select range:

Array bounds violation error:

>>> word[42]  # the word only has 6 characters
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>

But accessing a non-existent range does not cause an error:

Strings cannot be modified:

Supports Unicode strings: Add 'u' before the string

0x0020 indicates a space
Supports raw mode: Add "ur" before the string
Python's default encoding is ASCII. If a Unicode string is printed or written to a file, or converted using the str() method, it will default to ASCII. If the string is not in the range of 0-127, an error will occur

Convert to specific encoding: The method parameter is lowercase

### Array

Define an array

Access elements within an array

Retrieve segments within an array, for example in the third example above, it will return a new array copy, the original array will not be changed
Array merging:

The content of a string cannot be changed, while an array can be changed:

Adding elements to an array:

can be assigned to a sliced array:

Get the length of the array:

Elements of an array can also be an array:

Finally starting to program!

How to implement a Fibonacci:

As mentioned before, the indentation indicates the start of a code block.
The print method can control formatting, such as adding spaces:

Add a comma at the end of the print statement to avoid the printed result from being on a new line:

Control flow

if statement

if…elif..else(不是必须的)…

for

Python's for can iterate over arrays and strings (this is slightly different from the for statement in C)

Modifying an array inside a loop: First, copy the original array by slicing it (this concept was mentioned before)

The range function can create an array based on an algorithm

Iterate over the array indices:

Exit loop

The break statement will exit the inner for loop; continue will skip the execution of the following statements (same as in C language).

pass statement

The pass statement does nothing, it's just used as a placeholder

Define a function and call a function

Note that the function body and code should be indented
Functions can be assigned (fib will be added to the symbol table):

Even if the function does not have a return, it will return a None

return without anything following it also returns None

Define a function with parameters

Parameters with default values: The default value of retries is 4

Default values can be variables: i is a variable

i = 5

def f(arg=i):
    print arg

If the default argument is a mutable object, it will be assigned multiple times:

def f(a, L=[]):
    L.append(a)
    return L

If you don't want L to be changed, you can do this:

If only one parameter is accepted, but two parameters are passed, an error will occur:

*arg accepts an 不确定 number of parameters:

Auto-parse parameters:

Docstring:

A lambda expression is an anonymous function, lambda a, b: a+b. a and b are two parameters, and the result returns the sum of a and b:

lambda can also be passed as a parameter:

>>> pairs.sort(key=lambda pair: pair[1])
>>> pairs
[(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]

>>> stack = [3, 4, 5]
>>> stack.append(6)

#### Using as a Queue

#### Some common methods

filter(function, sequence): Returns all values for which function returns true

map(function, sequence): Returns the processed values

Pass two arrays: take one number from each array and return the sum

reduce(function, sequence) : Adds the sum of the first two parameters of the array to the third parameter, and so on. If the array is empty, it returns an exception

reduce can specify the index of the first number to start:

...    def add(x,y): return x+y
...    return reduce(add, seq, 0)
...
>>> sum(range(1, 11))
55
>>> sum([])
0

>>> squares = []
>>> for x in range(10):
...    squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

squares = [x**2 for x in range(10)]

squares = map(lambda x: x**2, range(10))

>>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

>>> freshfruit = ['  banana', '  loganberry ', 'passion fruit  ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']
>>> [x, x**2 for x in range(6)]
  File "<stdin>", line 1, in <module>
    [x, x**2 for x in range(6)]
^
SyntaxError: invalid syntax
>>> # flatten a list using a list comprehension with two 'for' loops
>>> vec = [[1,2,3], [4,5,6], [7,8,9]]
>>> [num for elem in vec for num in elem]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> from math import pi
>>> [str(round(pi, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']

>>> matrix = [
...    [1, 2, 3, 4],
...    [5, 6, 7, 8],
...    [9, 10, 11, 12],
... ]

>>> [[row[i] for row in matrix] for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.25, 1234.5]
>>> del a[:]
>>> a
[]

>>> del a

>>> t = 12345, 54321, 'hello!'  # Input without parentheses
>>> t[0]
12345
>>> t
(12345, 54321, 'hello!')  # Output with parentheses
>>> # Tuples may be nested:
... u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
>>> # Cannot be modified
... t[0] = 88888
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> # The internal elements can be mutable types such as arrays, etc.
... v = ([1, 2, 3], [3, 2, 1])
>>> v
([1, 2, 3], [3, 2, 1])

0
>>> len(singleton)
1
>>> singleton
('hello',)

>>> t = (12345, 54321, 'hello!')
>>> x, y, z = t

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> fruit = set(basket)              # Create a set
>>> fruit
set(['orange', 'pear', 'apple', 'banana'])
>>> 'orange' in fruit                # Test if 'orange' is in the set fruit
True
>>> 'crabgrass' in fruit
False

>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  # unique letters in a
set(['a', 'r', 'b', 'c', 'd'])
>>> a - b                              # letters in a but not in b
set(['r', 'd', 'b'])
>>> a | b                              # letters in either a or b
set(['a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'])
>>> a & b                              # letters in both a and b
set(['a', 'c'])
>>> a ^ b                              # letters in a or b but not both
set(['r', 'd', 'b', 'm', 'z', 'l'])

>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
set(['r', 'd'])

>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'sape': 4139, 'guido': 4127, 'jack': 4098}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'guido': 4127, 'irv': 4127, 'jack': 4098}
>>> tel.keys()
['guido', 'irv', 'jack']
>>> 'guido' in tel
True

>>> {'sape': 4139, 'guido': 4127, 'jack': 4098}
{'sape': 4139, 'jack': 4098, 'guido': 4127}

>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}

>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'jack': 4098, 'guido': 4127}

>>> for i, v in enumerate(['tic', 'tac', 'toe']):
...    print i, v
...
0 tick
1 tack
2 toe

>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
...    print 'What is your {0}?  It is {1}.'.format(q, a)
...
What is your name?  It is lancelot.
What is your quest?  It is the holy grail.
What is your favorite color?  It is blue

>>> for i in reversed(range(1, 10, 2)):
...    print(i)
...
9
7
5
3
1

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
...    print f
...
apple
banana
orange
pear

>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}

Change an array when traversing:

#### More conditional statements

Comparison operators:
in and not in determine whether something is in a sequence; is and is not are used to compare whether two objects are the same object;
Comparisons can be chained: a < b == c checks if a is less than b, and b is equal to c
Boolean operators: and and or have lower precedence than comparison operators; not has the highest precedence and or has the lowest

With boolean operators, if one condition is met, the calculation will not continue to the next one

Comparison results can be assigned:

### Module

After exiting the interpreter, all declared functions or variables no longer exist. So we need to create a Python script that can run sustainably. Each script file is called a module.
For example, we create a file: fibo.py

Import this module in the interpreter:

>>> fibo.fib(1000)

A function is assigned to a variable

### Execute module script

To run a module like this

It's the same as importing a module and setting __name__ to __main__: equivalent to putting the following code at the bottom of the module

Importing it alone will not run this script:

### Module Search Path

1 Built-in modules
2 Search all directories in sys.path

Initialization content of sys.path:
Current directory
PYTHONPATH (directory path, with the same syntax as the environment variable PATH)
Python installation path

sys.path will be modified, the current directory takes precedence over the standard library path.

### Compiled Python Files

If spam.pyc (the compiled Python file) and spam.py coexist, the compiled file will be used first. If the compilation time saved in spam.pyc does not match the modification time of spam.py, the compiled file will be ignored (i.e., the spam.py file will be used). The spam.pyc file is platform-independent, meaning it can be shared across different platforms.

### Standard Modules

Python has its own standard library. To access lower-level functionality, some modules are built into the parser. Additionally, some built-in modules depend on the environment; for example, the winreg module is only provided in the Windows environment. A notable module is sys, which is built into every Python interpreter. sys.ps1 and sys.ps2 represent Python's prompt.

The value of sys.path is the interpreter's module search path. We can add to the path:

#### dir() function

The dir() function returns an array of strings, which is used to indicate what names a module defines

Returns the currently defined module\function\variable names without parameters

dir() does not return built-in functions and variables. To print built-ins, you need to pass __builtin__

#### Package

Packages are a way to organize Python modules, for example, A.B indicates that there is a sub-module B under package A.
A package structure is similar to the following:

formats/                  Subpackage for file format conversions
              __init__.py
              wavread.py
              wavwrite.py
aiffread.py
              aiffwrite.py
              auread.py
              auwrite.py
...
      effects/                  Subpackage for sound effects
              __init__.py
              echo.py
surround.py
              reverse.py
              ...
      filters/                  Subpackage for filters
__init__.py
              equalizer.py
              vocoder.py
              karaoke.py
...

import sound.effects.echo

sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)

from sound.effects import echo

echo.echofilter(input, output, delay=0.7, atten=4)

from sound.effects.echo import echofilter

echofilter(input, output, delay=0.7, atten=4)

import item.subitem.subsubitem

__all__ = ["echo", "surround", "reverse"]

from sound.effects import *

import sound.effects.echo
import sound.effects.surround
from sound.effects import *

from . import echo
from .. import formats
from ..filters import equalizer

>>> s = 'Hello, world.'
>>> str(s)
'Hello, world.'
>>> repr(s)
"'Hello, world.'"
>>> str(1.0/7.0)
'0.142857142857'
>>> repr(1.0/7.0)
'0.14285714285714285'
>>> x = 10 * 3.25
>>> y = 200 * 200
>>> s = 'The value of x is ' + repr(x) + ', and y is ' + repr(y) + '...'
>>> print s
The value of x is 32.5, and y is 40000...
>>> # The repr() of a string adds string quotes and backslashes:
... hello = 'hello, world\n'
>>> hellos = repr(hello)
>>> print hellos
'hello, world\n'
>>> # The argument to repr() may be any Python object:
... repr((x, y, ('spam', 'eggs')))
"(32.5, 40000, ('spam', 'eggs'))"

...    print repr(x*x*x).rjust(4)
...
1  1    1
2  4    8
3  9  27
4  16  64
5  25  125
6  36  216
7  49  343
8  64  512
9  81  729
10 100 1000

>>> for x in range(1,11):
...    print '{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x)
...
1  1    1
2  4    8
3  9  27
4  16  64
5  25  125
6  36  216
7  49  343
8  64  512
9  81  729
10 100 1000

>>> '12'.zfill(5)
'00012'
>>> '-3.14'.zfill(7)
'-003.14'
>>> '3.14159265359'.zfill(5)
'3.14159265359'

>>> print 'We are the {} who say "{}!"'.format('knights', 'Ni')
We are the knights who say "Ni!"

>>> print '{0} and {1}'.format('spam', 'eggs')
Spam and eggs
>>> print '{1} and {0}'.format('spam', 'eggs')
Eggs and spam

>>> print 'This {food} is {adjective}.'.format(
...      food='spam', adjective='absolutely horrible')
This spam is absolutely horrible.

>>> print 'The story of {0}, {1}, and {other}.'.format('Bill', 'Manfred')
...                                                    other='Georg')
The story of Bill, Manfred, and Georg.

>>> import math
>>> print 'The value of PI is approximately {}.'.format(math.pi)
The value of PI is approximately 3.14159265359.
>>> print 'The value of PI is approximately {!r}.'.format(math.pi)
The value of PI is approximately 3.141592653589793.

>>> import math
>>> print 'The value of PI is approximately {0:.3f}.'.format(math.pi)
The value of PI is approximately 3.142.

>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}
>>> for name, phone in table.items():
...    print '{0:10} ==> {1:10d}'.format(name, phone)
...
Jack      ==>      4098
Dcab      ==>      7678
Sjoerd    ==>      4127

>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> print ('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; ')
...        'Dcab: {0[Dcab]:d}'.format(table))
Jack: 4098; Sjoerd: 4127; Dcab: 8637678

>>> import math
>>> print 'The value of PI is approximately %5.3f.' % math.pi
The value of PI is approximately 3.142.

>>> f = open('workfile', 'w')
>>> print f
<open file 'workfile', mode 'w' at 80a0960

>>> f.read()
'This is the entire file.\n'
>>> f.read()
''

>>> f.readline()
'This is the first line of the file.\n'
>>> f.readline()
'Second line of the file\n'
>>> f.readline()
''

>> for line in f:
        print line,

This is the first line of the file.
Second line of the file

>>> f.write('This is a test\n')

>>> value = ('the answer', 42)
>>> s = str(value)
>>> f.write(s)

>>> f = open('workfile', 'r+')
>>> f.write('0123456789abcdef')
>>> f.seek(5)      # To the 6th byte
>>> f.read(1)
'5'
>>> f.seek(-3, 2)  # Position of the 3rd byte from the end (2 indicates from the end)
>>> f.read(1)
'd'

>>> f.close()
>>> f.read()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: I/O operation on closed file

>>> with open('workfile', 'r') as f:
...    read_data = f.read()
>>> f.closed
True

>>> import json
>>> json.dumps([1, 'simple', 'list'])
'[1, "simple", "list"]'

json.dump(x, f)

Reading from a file:

>>> while True print 'Hello world'
  File "<stdin>", line 1
    while True print 'Hello world'
                  ^
SyntaxError: invalid syntax

>>> 10 * (1/0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: integer division or modulo by zero
>>> 4 + spam*3
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: cannot concatenate 'str' and 'int' objects

>>> while True:

Only ValueError is caught here; if more exceptions are caught:

The code after try...except...else..else will always execute