Learn Python Programming - Third Edition

Spis treści książki

• Preface
  • Who this book is for
  • What this book covers
  • To get the most out of this book
  • Get in touch
• A Gentle Introduction to Python
  • A proper introduction
  • Enter the Python
  • About Python
    • Portability
    • Coherence
    • Developer productivity
    • An extensive library
    • Software quality
    • Software integration
    • Satisfaction and enjoyment
  • What are the drawbacks?
  • Who is using Python today?
  • Setting up the environment
    • Python 2 versus Python 3
  • Installing Python
    • Setting up the Python interpreter
    • About virtual environments
    • Your first virtual environment
    • Installing third-party libraries
    • Your friend, the console
  • How to run a Python program
    • Running Python scripts
    • Running the Python interactive shell
    • Running Python as a service
    • Running Python as a GUI application
  • How is Python code organized?
    • How do we use modules and packages?
  • Pythons execution model
    • Names and namespaces
    • Scopes
    • Objects and classes
  • Guidelines for writing good code
  • Python culture
  • A note on IDEs
  • Summary
• Built-In Data Types
  • Everything is an object
  • Mutable or immutable? That is the question
  • Numbers
    • Integers
    • Booleans
    • Real numbers
    • Complex numbers
    • Fractions and decimals
  • Immutable sequences
    • Strings and bytes
      • Encoding and decoding strings
      • Indexing and slicing strings
      • String formatting
    • Tuples
  • Mutable sequences
    • Lists
    • Bytearrays
  • Set types
  • Mapping types: dictionaries
  • Data types
    • Dates and times
      • The standard library
      • Third-party libraries
    • The collections module
      • namedtuple
      • defaultdict
      • ChainMap
    • Enums
  • Final considerations
    • Small value caching
    • How to choose data structures
    • About indexing and slicing
    • About names
  • Summary
• Conditionals and Iteration
  • Conditional programming
    • A specialized else: elif
    • The ternary operator
  • Looping
    • The for loop
      • Iterating over a range
      • Iterating over a sequence
    • Iterators and iterables
    • Iterating over multiple sequences
    • The while loop
    • The break and continue statements
    • A special else clause
  • Assignment expressions
    • Statements and expressions
    • Using the walrus operator
    • A word of warning
  • Putting all this together
    • A prime generator
    • Applying discounts
  • A quick peek at the itertools module
    • Infinite iterators
    • Iterators terminating on the shortest input sequence
    • Combinatoric generators
  • Summary
• Functions, the Building Blocks of Code
  • Why use functions?
    • Reducing code duplication
    • Splitting a complex task
    • Hiding implementation details
    • Improving readability
    • Improving traceability
  • Scopes and name resolution
    • The global and nonlocal statements
  • Input parameters
    • Argument-passing
    • Assignment to parameter names
    • Changing a mutable object
    • Passing arguments
      • Positional arguments
      • Keyword arguments
      • Iterable unpacking
      • Dictionary unpacking
      • Combining argument types
    • Defining parameters
      • Optional parameters
      • Variable positional parameters
      • Variable keyword parameters
      • Positional-only parameters
      • Keyword-only parameters
      • Combining input parameters
      • More signature examples
      • Avoid the trap! Mutable defaults
  • Return values
    • Returning multiple values
  • A few useful tips
  • Recursive functions
  • Anonymous functions
  • Function attributes
  • Built-in functions
  • Documenting your code
  • Importing objects
    • Relative imports
  • One final example
  • Summary
• Comprehensions and Generators
  • The map, zip, and filter functions
    • map
    • zip
    • filter
  • Comprehensions
    • Nested comprehensions
    • Filtering a comprehension
    • Dictionary comprehensions
    • Set comprehensions
  • Generators
    • Generator functions
    • Going beyond next
    • The yield from expression
    • Generator expressions
  • Some performance considerations
  • Don't overdo comprehensions and generators
  • Name localization
  • Generation behavior in built-ins
  • One last example
  • Summary
• OOP, Decorators, and Iterators
  • Decorators
    • A decorator factory
  • Object-oriented programming (OOP)
    • The simplest Python class
    • Class and object namespaces
    • Attribute shadowing
    • The self argument
    • Initializing an instance
    • OOP is about code reuse
      • Inheritance and composition
    • Accessing a base class
    • Multiple inheritance
      • Method resolution order
    • Class and static methods
      • Static methods
      • Class methods
    • Private methods and name mangling
    • The property decorator
    • The cached_property decorator
    • Operator overloading
    • Polymorphism a brief overview
    • Data classes
  • Writing a custom iterator
  • Summary
• Exceptions and Context Managers
  • Exceptions
    • Raising exceptions
    • Defining your own exceptions
    • Tracebacks
    • Handling exceptions
    • Not only for errors
  • Context managers
    • Class-based context managers
    • Generator-based context managers
  • Summary
• Files and Data Persistence
  • Working with files and directories
    • Opening files
      • Using a context manager to open a file
    • Reading and writing to a file
      • Reading and writing in binary mode
      • Protecting against overwriting an existing file
    • Checking for file and directory existence
    • Manipulating files and directories
      • Manipulating pathnames
    • Temporary files and directories
    • Directory content
    • File and directory compression
  • Data interchange formats
    • Working with JSON
      • Custom encoding/decoding with JSON
  • I/O, streams, and requests
    • Using an in-memory stream
    • Making HTTP requests
  • Persisting data on disk
    • Serializing data with pickle
    • Saving data with shelve
    • Saving data to a database
  • Summary
• Cryptography and Tokens
  • The need for cryptography
    • Useful guidelines
  • Hashlib
  • HMAC
  • Secrets
    • Random numbers
    • Token generation
    • Digest comparison
  • JSON Web Tokens
    • Registered claims
      • Time-related claims
      • Authentication-related claims
    • Using asymmetric (public key) algorithms
  • Useful references
  • Summary
• Testing
  • Testing your application
    • The anatomy of a test
    • Testing guidelines
    • Unit testing
      • Writing a unit test
      • Mock objects and patching
      • Assertions
    • Testing a CSV generator
      • Boundaries and granularity
      • Testing the export function
      • Final considerations
  • Test-driven development
  • Summary
• Debugging and Profiling
  • Debugging techniques
    • Debugging with print
    • Debugging with a custom function
    • Using the Python debugger
    • Inspecting logs
    • Other techniques
      • Reading tracebacks
      • Assertions
    • Where to find information
  • Troubleshooting guidelines
    • Where to inspect
    • Using tests to debug
    • Monitoring
  • Profiling Python
    • When to profile
    • Measuring execution time
  • Summary
• GUIs and Scripting
  • First approach: scripting
    • The imports
    • Parsing arguments
    • The business logic
  • Second approach: a GUI application
    • The imports
    • The layout logic
    • The business logic
      • Fetching the web page
      • Saving the images
      • Alerting the user
    • How can we improve the application?
  • Where do we go from here?
    • The turtle module
    • wxPython, Kivy, and PyQt
    • The principle of least astonishment
    • Threading considerations
  • Summary
• Data Science in Brief
  • IPython and Jupyter Notebook
    • Using Anaconda
    • Starting a Notebook
  • Dealing with data
    • Setting up the Notebook
    • Preparing the data
    • Cleaning the data
    • Creating the DataFrame
      • Unpacking the campaign name
      • Unpacking the user data
      • Cleaning everything up
    • Saving the DataFrame to a file
    • Visualizing the results
  • Where do we go from here?
  • Summary
• Introduction to API Development
  • What is the Web?
    • How does the Web work?
    • Response status codes
  • Type hinting: An overview
    • Why type hinting?
    • Type hinting in a nutshell
  • APIs: An introduction
    • What is an API?
    • What is the purpose of an API?
    • API protocols
    • API data-exchange formats
  • The railway API
    • Modeling the database
    • Main setup and configuration
      • Adding settings
    • Station endpoints
      • Reading data
      • Creating data
      • Updating data
      • Deleting data
    • User authentication
    • Documenting the API
  • Consuming an API
    • Calling the API from Django
  • Where do we go from here?
  • Summary
• Packaging Python Applications
  • The Python Package Index
  • The train schedule project
  • Packaging with setuptools
    • Required files
      • pyproject.toml
      • License
      • README
      • Changelog
      • setup.cfg
      • setup.py
      • MANIFEST.in
    • Package metadata
      • Accessing metadata in your code
    • Defining the package contents
      • Accessing package data files
    • Specifying dependencies
    • Entry points
  • Building and publishing packages
    • Building
    • Publishing
  • Advice for starting new projects
  • Alternative tools
  • Further reading
  • Summary
• Other Books You May Enjoy
• Index

pokaż cały spis treści

ukryj recenzje