PythonNotesForProfessionals.pdf

(6073 KB) Pobierz
Notes for Professionals
Python
Python
Notes for Professionals
®
of professional hints and tricks
700+ pages
GoalKicker.com
Free Programming Books
Disclaimer
This is an unocial free book created for educational purposes and is
not aliated with ocial Python
®
group(s) or company(s).
All trademarks and registered trademarks are
the property of their respective owners
Contents
About
................................................................................................................................................................................... 1
Chapter 1: Getting started with Python Language
...................................................................................... 2
Section 1.1: Getting Started
........................................................................................................................................... 2
Section 1.2: Creating variables and assigning values
................................................................................................ 6
Section 1.3: Block Indentation
..................................................................................................................................... 10
Section 1.4: Datatypes
................................................................................................................................................. 11
Section 1.5: Collection Types
...................................................................................................................................... 15
Section 1.6: IDLE - Python GUI
.................................................................................................................................... 19
Section 1.7: User Input
................................................................................................................................................. 21
Section 1.8: Built in Modules and Functions
.............................................................................................................. 21
Section 1.9: Creating a module
................................................................................................................................... 25
Section 1.10: Installation of Python 2.7.x and 3.x
....................................................................................................... 26
Section 1.11: String function - str() and repr()
........................................................................................................... 28
Section 1.12: Installing external modules using pip
................................................................................................... 29
Section 1.13: Help Utility
............................................................................................................................................... 31
Chapter 2: Python Data Types
............................................................................................................................ 33
Section 2.1: String Data Type
..................................................................................................................................... 33
Section 2.2: Set Data Types
....................................................................................................................................... 33
Section 2.3: Numbers data type
................................................................................................................................ 33
Section 2.4: List Data Type
......................................................................................................................................... 34
Section 2.5: Dictionary Data Type
............................................................................................................................. 34
Section 2.6: Tuple Data Type
..................................................................................................................................... 34
Chapter 3: Indentation
............................................................................................................................................. 35
Section 3.1: Simple example
....................................................................................................................................... 35
Section 3.2: How Indentation is Parsed
..................................................................................................................... 35
Section 3.3: Indentation Errors
................................................................................................................................... 36
Chapter 4: Comments and Documentation
.................................................................................................. 37
Section 4.1: Single line, inline and multiline comments
............................................................................................ 37
Section 4.2: Programmatically accessing docstrings
.............................................................................................. 37
Section 4.3: Write documentation using docstrings
................................................................................................ 38
Chapter 5: Date and Time
...................................................................................................................................... 41
Section 5.1: Parsing a string into a timezone aware datetime object
.................................................................... 41
Section 5.2: Constructing timezone-aware datetimes
............................................................................................ 41
Section 5.3: Computing time dierences
.................................................................................................................. 43
Section 5.4: Basic datetime objects usage
............................................................................................................... 43
Section 5.5: Switching between time zones
.............................................................................................................. 44
Section 5.6: Simple date arithmetic
........................................................................................................................... 44
Section 5.7: Converting timestamp to datetime
...................................................................................................... 45
Section 5.8: Subtracting months from a date accurately
....................................................................................... 45
Section 5.9: Parsing an arbitrary ISO 8601 timestamp with minimal libraries
...................................................... 45
Section 5.10: Get an ISO 8601 timestamp
.................................................................................................................. 46
Section 5.11: Parsing a string with a short time zone name into a timezone aware datetime object
................ 46
Section 5.12: Fuzzy datetime parsing (extracting datetime out of a text)
............................................................ 47
Section 5.13: Iterate over dates
.................................................................................................................................. 48
Chapter 6: Date Formatting
.................................................................................................................................. 49
Section 6.1: Time between two date-times
............................................................................................................... 49
Section 6.2: Outputting datetime object to string
.................................................................................................... 49
Section 6.3: Parsing string to datetime object
......................................................................................................... 49
Chapter 7: Enum
.......................................................................................................................................................... 50
Section 7.1: Creating an enum (Python 2.4 through 3.3)
......................................................................................... 50
Section 7.2: Iteration
................................................................................................................................................... 50
Chapter 8: Set
............................................................................................................................................................... 51
Section 8.1: Operations on sets
.................................................................................................................................. 51
Section 8.2: Get the unique elements of a list
.......................................................................................................... 52
Section 8.3: Set of Sets
................................................................................................................................................ 52
Section 8.4: Set Operations using Methods and Builtins
......................................................................................... 52
Section 8.5: Sets versus multisets
.............................................................................................................................. 54
Chapter 9: Simple Mathematical Operators
................................................................................................. 56
Section 9.1: Division
..................................................................................................................................................... 56
Section 9.2: Addition
.................................................................................................................................................... 57
Section 9.3: Exponentiation
........................................................................................................................................ 58
Section 9.4: Trigonometric Functions
........................................................................................................................ 59
Section 9.5: Inplace Operations
................................................................................................................................. 60
Section 9.6: Subtraction
.............................................................................................................................................. 60
Section 9.7: Multiplication
........................................................................................................................................... 60
Section 9.8: Logarithms
.............................................................................................................................................. 61
Section 9.9: Modulus
................................................................................................................................................... 61
Chapter 10: Bitwise Operators
............................................................................................................................. 63
Section 10.1: Bitwise NOT
............................................................................................................................................ 63
Section 10.2: Bitwise XOR (Exclusive OR)
.................................................................................................................. 64
Section 10.3: Bitwise AND
............................................................................................................................................ 65
Section 10.4: Bitwise OR
.............................................................................................................................................. 65
Section 10.5: Bitwise Left Shift
.................................................................................................................................... 65
Section 10.6: Bitwise Right Shift
.................................................................................................................................. 66
Section 10.7: Inplace Operations
................................................................................................................................ 66
Chapter 11: Boolean Operators
............................................................................................................................ 67
Section 11.1: `and` and `or` are not guaranteed to return a boolean
...................................................................... 67
Section 11.2: A simple example
................................................................................................................................... 67
Section 11.3: Short-circuit evaluation
......................................................................................................................... 67
Section 11.4: and
........................................................................................................................................................... 68
Section 11.5: or
.............................................................................................................................................................. 68
Section 11.6: not
............................................................................................................................................................ 69
Chapter 12: Operator Precedence
...................................................................................................................... 70
Section 12.1: Simple Operator Precedence Examples in python
............................................................................. 70
Chapter 13: Variable Scope and Binding
......................................................................................................... 71
Section 13.1: Nonlocal Variables
................................................................................................................................. 71
Section 13.2: Global Variables
.................................................................................................................................... 71
Section 13.3: Local Variables
...................................................................................................................................... 72
Section 13.4: The del command
................................................................................................................................. 73
Section 13.5: Functions skip class scope when looking up names
......................................................................... 74
Section 13.6: Local vs Global Scope
........................................................................................................................... 75
Section 13.7: Binding Occurrence
............................................................................................................................... 77
Chapter 14: Conditionals
......................................................................................................................................... 78
Section 14.1: Conditional Expression (or "The Ternary Operator")
......................................................................... 78
Section 14.2: if, elif, and else
....................................................................................................................................... 78
Section 14.3: Truth Values
........................................................................................................................................... 78
Section 14.4: Boolean Logic Expressions
................................................................................................................... 79
Section 14.5: Using the cmp function to get the comparison result of two objects
............................................. 81
Section 14.6: Else statement
....................................................................................................................................... 81
Section 14.7: Testing if an object is None and assigning it
...................................................................................... 82
Section 14.8: If statement
............................................................................................................................................ 82
Chapter 15: Comparisons
........................................................................................................................................ 83
Section 15.1: Chain Comparisons
................................................................................................................................ 83
Section 15.2: Comparison by `is` vs `==`
...................................................................................................................... 84
Section 15.3: Greater than or less than
...................................................................................................................... 85
Section 15.4: Not equal to
........................................................................................................................................... 85
Section 15.5: Equal To
................................................................................................................................................. 86
Section 15.6: Comparing Objects
............................................................................................................................... 86
Chapter 16: Loops
....................................................................................................................................................... 88
Section 16.1: Break and Continue in Loops
................................................................................................................ 88
Section 16.2: For loops
................................................................................................................................................ 90
Section 16.3: Iterating over lists
.................................................................................................................................. 90
Section 16.4: Loops with an "else" clause
.................................................................................................................. 91
Section 16.5: The Pass Statement
.............................................................................................................................. 93
Section 16.6: Iterating over dictionaries
.................................................................................................................... 94
Section 16.7: The "half loop" do-while
........................................................................................................................ 95
Section 16.8: Looping and Unpacking
....................................................................................................................... 95
Section 16.9: Iterating dierent portion of a list with dierent step size
............................................................... 96
Section 16.10: While Loop
............................................................................................................................................ 97
Chapter 17: Arrays
...................................................................................................................................................... 99
Section 17.1: Access individual elements through indexes
....................................................................................... 99
Section 17.2: Basic Introduction to Arrays
................................................................................................................. 99
Section 17.3: Append any value to the array using append() method
................................................................ 100
Section 17.4: Insert value in an array using insert() method
................................................................................ 100
Section 17.5: Extend python array using extend() method
................................................................................... 100
Section 17.6: Add items from list into array using fromlist() method
.................................................................. 101
Section 17.7: Remove any array element using remove() method
..................................................................... 101
Section 17.8: Remove last array element using pop() method
............................................................................ 101
Section 17.9: Fetch any element through its index using index() method
........................................................... 101
Section 17.10: Reverse a python array using reverse() method
........................................................................... 101
Section 17.11: Get array buer information through buer_info() method
........................................................ 102
Section 17.12: Check for number of occurrences of an element using count() method
.................................... 102
Section 17.13: Convert array to string using tostring() method
............................................................................ 102
Section 17.14: Convert array to a python list with same elements using tolist() method
.................................. 102
Section 17.15: Append a string to char array using fromstring() method
........................................................... 102
Chapter 18: Multidimensional arrays
.............................................................................................................. 103
Section 18.1: Lists in lists
............................................................................................................................................ 103
Section 18.2: Lists in lists in lists in..
.......................................................................................................................... 103
Chapter 19: Dictionary
............................................................................................................................................ 105
Section 19.1: Introduction to Dictionary
................................................................................................................... 105
Section 19.2: Avoiding KeyError Exceptions
........................................................................................................... 106
Section 19.3: Iterating Over a Dictionary
................................................................................................................. 106
Section 19.4: Dictionary with default values
........................................................................................................... 107
Section 19.5: Merging dictionaries
........................................................................................................................... 108
Section 19.6: Accessing keys and values
................................................................................................................ 108
Section 19.7: Accessing values of a dictionary
....................................................................................................... 109
Section 19.8: Creating a dictionary
.......................................................................................................................... 109
Section 19.9: Creating an ordered dictionary
......................................................................................................... 110
Section 19.10: Unpacking dictionaries using the ** operator
................................................................................. 110
Section 19.11: The trailing comma
............................................................................................................................ 111
Section 19.12: The dict() constructor
........................................................................................................................ 111
Section 19.13: Dictionaries Example
......................................................................................................................... 111
Section 19.14: All combinations of dictionary values
.............................................................................................. 112
Chapter 20: List
......................................................................................................................................................... 113
Section 20.1: List methods and supported operators
............................................................................................ 113
Section 20.2: Accessing list values
.......................................................................................................................... 118
Section 20.3: Checking if list is empty
..................................................................................................................... 119
Section 20.4: Iterating over a list
............................................................................................................................. 119
Section 20.5: Checking whether an item is in a list
................................................................................................ 120
Section 20.6: Any and All
.......................................................................................................................................... 120
Section 20.7: Reversing list elements
...................................................................................................................... 121
Section 20.8: Concatenate and Merge lists
............................................................................................................ 121
Section 20.9: Length of a list
.................................................................................................................................... 122
Section 20.10: Remove duplicate values in list
....................................................................................................... 122
Section 20.11: Comparison of lists
............................................................................................................................ 123
Section 20.12: Accessing values in nested list
........................................................................................................ 123
Section 20.13: Initializing a List to a Fixed Number of Elements
........................................................................... 124
Chapter 21: List comprehensions
...................................................................................................................... 126
Section 21.1: List Comprehensions
........................................................................................................................... 126
Section 21.2: Conditional List Comprehensions
...................................................................................................... 128
Section 21.3: Avoid repetitive and expensive operations using conditional clause
............................................ 130
Section 21.4: Dictionary Comprehensions
............................................................................................................... 131
Section 21.5: List Comprehensions with Nested Loops
.......................................................................................... 132
Section 21.6: Generator Expressions
........................................................................................................................ 134
Section 21.7: Set Comprehensions
........................................................................................................................... 136
Section 21.8: Refactoring filter and map to list comprehensions
......................................................................... 136
Section 21.9: Comprehensions involving tuples
...................................................................................................... 137
Section 21.10: Counting Occurrences Using Comprehension
............................................................................... 138
Section 21.11: Changing Types in a List
.................................................................................................................... 138
Section 21.12: Nested List Comprehensions
............................................................................................................ 138
Section 21.13: Iterate two or more list simultaneously within list comprehension
.............................................. 139
Chapter 22: List slicing (selecting parts of lists)
....................................................................................... 140
Section 22.1: Using the third "step" argument
........................................................................................................ 140
Section 22.2: Selecting a sublist from a list
............................................................................................................ 140
Section 22.3: Reversing a list with slicing
................................................................................................................ 140
Section 22.4: Shifting a list using slicing
.................................................................................................................. 140
Chapter 23: groupby()
............................................................................................................................................ 142
Section 23.1: Example 4
............................................................................................................................................. 142
Section 23.2: Example 2
............................................................................................................................................ 142
Section 23.3: Example 3
............................................................................................................................................ 143
Chapter 24: Linked lists
......................................................................................................................................... 145
Section 24.1: Single linked list example
................................................................................................................... 145
Chapter 25: Linked List Node
............................................................................................................................. 149
Section 25.1: Write a simple Linked List Node in python
....................................................................................... 149
Chapter 26: Filter
...................................................................................................................................................... 150

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin