PythonNotesForProfessionals.pdf
(
6212 KB
)
Pobierz
Notes for Professionals
Python
Python
Notes for Professionals
®
of professional hints and tricks
800+ pages
GoalKicker.com
Free Programming Books
Disclaimer
This is an unocial free book created for educational purposes and is
not aliated with ocial 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
...................................................................................................................................... 42
Section 5.1: Parsing a string into a timezone aware datetime object
.................................................................... 42
Section 5.2: Constructing timezone-aware datetimes
............................................................................................ 42
Section 5.3: Computing time dierences
.................................................................................................................. 44
Section 5.4: Basic datetime objects usage
............................................................................................................... 44
Section 5.5: Switching between time zones
.............................................................................................................. 45
Section 5.6: Simple date arithmetic
........................................................................................................................... 45
Section 5.7: Converting timestamp to datetime
...................................................................................................... 46
Section 5.8: Subtracting months from a date accurately
....................................................................................... 46
Section 5.9: Parsing an arbitrary ISO 8601 timestamp with minimal libraries
...................................................... 46
Section 5.10: Get an ISO 8601 timestamp
.................................................................................................................. 47
Section 5.11: Parsing a string with a short time zone name into a timezone aware datetime object
................ 47
Section 5.12: Fuzzy datetime parsing (extracting datetime out of a text)
............................................................ 48
Section 5.13: Iterate over dates
.................................................................................................................................. 49
Chapter 6: Date Formatting
.................................................................................................................................. 50
Section 6.1: Time between two date-times
............................................................................................................... 50
Section 6.2: Outputting datetime object to string
.................................................................................................... 50
Section 6.3: Parsing string to datetime object
......................................................................................................... 50
Chapter 7: Enum
.......................................................................................................................................................... 51
Section 7.1: Creating an enum (Python 2.4 through 3.3)
......................................................................................... 51
Section 7.2: Iteration
................................................................................................................................................... 51
Chapter 8: Set
............................................................................................................................................................... 52
Section 8.1: Operations on sets
.................................................................................................................................. 52
Section 8.2: Get the unique elements of a list
.......................................................................................................... 53
Section 8.3: Set of Sets
................................................................................................................................................ 53
Section 8.4: Set Operations using Methods and Builtins
......................................................................................... 53
Section 8.5: Sets versus multisets
.............................................................................................................................. 55
Chapter 9: Simple Mathematical Operators
................................................................................................. 57
Section 9.1: Division
..................................................................................................................................................... 57
Section 9.2: Addition
.................................................................................................................................................... 58
Section 9.3: Exponentiation
........................................................................................................................................ 59
Section 9.4: Trigonometric Functions
........................................................................................................................ 60
Section 9.5: Inplace Operations
................................................................................................................................. 61
Section 9.6: Subtraction
.............................................................................................................................................. 61
Section 9.7: Multiplication
........................................................................................................................................... 61
Section 9.8: Logarithms
.............................................................................................................................................. 62
Section 9.9: Modulus
................................................................................................................................................... 62
Chapter 10: Bitwise Operators
............................................................................................................................. 65
Section 10.1: Bitwise NOT
............................................................................................................................................ 65
Section 10.2: Bitwise XOR (Exclusive OR)
.................................................................................................................. 66
Section 10.3: Bitwise AND
............................................................................................................................................ 67
Section 10.4: Bitwise OR
.............................................................................................................................................. 67
Section 10.5: Bitwise Left Shift
.................................................................................................................................... 67
Section 10.6: Bitwise Right Shift
.................................................................................................................................. 68
Section 10.7: Inplace Operations
................................................................................................................................ 68
Chapter 11: Boolean Operators
............................................................................................................................ 69
Section 11.1: `and` and `or` are not guaranteed to return a boolean
...................................................................... 69
Section 11.2: A simple example
................................................................................................................................... 69
Section 11.3: Short-circuit evaluation
......................................................................................................................... 69
Section 11.4: and
........................................................................................................................................................... 70
Section 11.5: or
.............................................................................................................................................................. 70
Section 11.6: not
............................................................................................................................................................ 71
Chapter 12: Operator Precedence
...................................................................................................................... 72
Section 12.1: Simple Operator Precedence Examples in python
............................................................................. 72
Chapter 13: Variable Scope and Binding
......................................................................................................... 73
Section 13.1: Nonlocal Variables
................................................................................................................................. 73
Section 13.2: Global Variables
.................................................................................................................................... 73
Section 13.3: Local Variables
...................................................................................................................................... 74
Section 13.4: The del command
................................................................................................................................. 75
Section 13.5: Functions skip class scope when looking up names
......................................................................... 76
Section 13.6: Local vs Global Scope
........................................................................................................................... 77
Section 13.7: Binding Occurrence
............................................................................................................................... 79
Chapter 14: Conditionals
......................................................................................................................................... 80
Section 14.1: Conditional Expression (or "The Ternary Operator")
......................................................................... 80
Section 14.2: if, elif, and else
....................................................................................................................................... 80
Section 14.3: Truth Values
........................................................................................................................................... 80
Section 14.4: Boolean Logic Expressions
................................................................................................................... 81
Section 14.5: Using the cmp function to get the comparison result of two objects
............................................. 83
Section 14.6: Else statement
....................................................................................................................................... 83
Section 14.7: Testing if an object is None and assigning it
...................................................................................... 84
Section 14.8: If statement
............................................................................................................................................ 84
Chapter 15: Comparisons
........................................................................................................................................ 86
Section 15.1: Chain Comparisons
................................................................................................................................ 86
Section 15.2: Comparison by `is` vs `==`
...................................................................................................................... 87
Section 15.3: Greater than or less than
...................................................................................................................... 88
Section 15.4: Not equal to
........................................................................................................................................... 88
Section 15.5: Equal To
................................................................................................................................................. 89
Section 15.6: Comparing Objects
............................................................................................................................... 89
Chapter 16: Loops
....................................................................................................................................................... 91
Section 16.1: Break and Continue in Loops
................................................................................................................ 91
Section 16.2: For loops
................................................................................................................................................ 93
Section 16.3: Iterating over lists
.................................................................................................................................. 93
Section 16.4: Loops with an "else" clause
.................................................................................................................. 94
Section 16.5: The Pass Statement
.............................................................................................................................. 96
Section 16.6: Iterating over dictionaries
.................................................................................................................... 97
Section 16.7: The "half loop" do-while
........................................................................................................................ 98
Section 16.8: Looping and Unpacking
....................................................................................................................... 98
Section 16.9: Iterating dierent portion of a list with dierent step size
............................................................... 99
Section 16.10: While Loop
.......................................................................................................................................... 100
Chapter 17: Arrays
.................................................................................................................................................... 102
Section 17.1: Access individual elements through indexes
..................................................................................... 102
Section 17.2: Basic Introduction to Arrays
.............................................................................................................. 102
Section 17.3: Append any value to the array using append() method
................................................................ 103
Section 17.4: Insert value in an array using insert() method
................................................................................ 103
Section 17.5: Extend python array using extend() method
................................................................................... 103
Section 17.6: Add items from list into array using fromlist() method
.................................................................. 104
Section 17.7: Remove any array element using remove() method
..................................................................... 104
Section 17.8: Remove last array element using pop() method
............................................................................ 104
Section 17.9: Fetch any element through its index using index() method
........................................................... 104
Section 17.10: Reverse a python array using reverse() method
........................................................................... 104
Section 17.11: Get array buer information through buer_info() method
........................................................ 105
Section 17.12: Check for number of occurrences of an element using count() method
.................................... 105
Section 17.13: Convert array to string using tostring() method
............................................................................ 105
Section 17.14: Convert array to a python list with same elements using tolist() method
.................................. 105
Section 17.15: Append a string to char array using fromstring() method
........................................................... 105
Chapter 18: Multidimensional arrays
.............................................................................................................. 106
Section 18.1: Lists in lists
............................................................................................................................................ 106
Section 18.2: Lists in lists in lists in..
.......................................................................................................................... 106
Chapter 19: Dictionary
............................................................................................................................................ 108
Section 19.1: Introduction to Dictionary
................................................................................................................... 108
Section 19.2: Avoiding KeyError Exceptions
........................................................................................................... 109
Section 19.3: Iterating Over a Dictionary
................................................................................................................. 109
Section 19.4: Dictionary with default values
........................................................................................................... 110
Section 19.5: Merging dictionaries
........................................................................................................................... 111
Section 19.6: Accessing keys and values
................................................................................................................ 111
Section 19.7: Accessing values of a dictionary
....................................................................................................... 112
Section 19.8: Creating a dictionary
.......................................................................................................................... 112
Section 19.9: Creating an ordered dictionary
......................................................................................................... 113
Section 19.10: Unpacking dictionaries using the ** operator
................................................................................. 113
Section 19.11: The trailing comma
............................................................................................................................ 114
Section 19.12: The dict() constructor
........................................................................................................................ 114
Section 19.13: Dictionaries Example
......................................................................................................................... 114
Section 19.14: All combinations of dictionary values
.............................................................................................. 115
Chapter 20: List
......................................................................................................................................................... 117
Section 20.1: List methods and supported operators
............................................................................................ 117
Section 20.2: Accessing list values
.......................................................................................................................... 122
Section 20.3: Checking if list is empty
..................................................................................................................... 123
Section 20.4: Iterating over a list
............................................................................................................................. 123
Section 20.5: Checking whether an item is in a list
................................................................................................ 124
Section 20.6: Any and All
.......................................................................................................................................... 124
Section 20.7: Reversing list elements
...................................................................................................................... 125
Section 20.8: Concatenate and Merge lists
............................................................................................................ 125
Section 20.9: Length of a list
.................................................................................................................................... 126
Section 20.10: Remove duplicate values in list
....................................................................................................... 126
Section 20.11: Comparison of lists
............................................................................................................................ 127
Section 20.12: Accessing values in nested list
........................................................................................................ 127
Section 20.13: Initializing a List to a Fixed Number of Elements
........................................................................... 128
Chapter 21: List comprehensions
...................................................................................................................... 130
Section 21.1: List Comprehensions
........................................................................................................................... 130
Section 21.2: Conditional List Comprehensions
...................................................................................................... 132
Section 21.3: Avoid repetitive and expensive operations using conditional clause
............................................ 134
Section 21.4: Dictionary Comprehensions
............................................................................................................... 135
Section 21.5: List Comprehensions with Nested Loops
.......................................................................................... 136
Section 21.6: Generator Expressions
........................................................................................................................ 138
Section 21.7: Set Comprehensions
........................................................................................................................... 140
Section 21.8: Refactoring filter and map to list comprehensions
......................................................................... 140
Section 21.9: Comprehensions involving tuples
...................................................................................................... 141
Section 21.10: Counting Occurrences Using Comprehension
............................................................................... 142
Section 21.11: Changing Types in a List
.................................................................................................................... 142
Section 21.12: Nested List Comprehensions
............................................................................................................ 142
Section 21.13: Iterate two or more list simultaneously within list comprehension
.............................................. 143
Chapter 22: List slicing (selecting parts of lists)
....................................................................................... 144
Section 22.1: Using the third "step" argument
........................................................................................................ 144
Section 22.2: Selecting a sublist from a list
............................................................................................................ 144
Section 22.3: Reversing a list with slicing
................................................................................................................ 144
Section 22.4: Shifting a list using slicing
.................................................................................................................. 144
Chapter 23: groupby()
............................................................................................................................................ 146
Section 23.1: Example 4
............................................................................................................................................. 146
Section 23.2: Example 2
............................................................................................................................................ 146
Section 23.3: Example 3
............................................................................................................................................ 147
Chapter 24: Linked lists
......................................................................................................................................... 149
Section 24.1: Single linked list example
................................................................................................................... 149
Chapter 25: Linked List Node
............................................................................................................................. 154
Section 25.1: Write a simple Linked List Node in python
....................................................................................... 154
Chapter 26: Filter
...................................................................................................................................................... 155
Plik z chomika:
kat305
Inne pliki z tego folderu:
Learning Python_ powerful object-oriented programming.pdf
(15068 KB)
Python Object Oriented Programming Exercises Become a Pro Developer_ Python OOPS Concepts with 73 Exercises With Solution.pdf
(12982 KB)
PythonNotesForProfessionals.pdf
(6212 KB)
Al-Sweigart-Automate-The-Boring-Stuff-With-Python.pdf
(12505 KB)
Step_by_Step_Guide_to_Python_en.pdf
(11046 KB)
Inne foldery tego chomika:
AWS
C
C#
C++
Data Science
Zgłoś jeśli
naruszono regulamin