book

Beyond the Basic Stuff with Python

Name: Beyond the Basic Stuff with Python
Author: Al Sweigart
ISBN: 9781593279660

by Al Sweigart

December 2020

Intermediate to advanced

384 pages

9h 54m

English

No Starch Press

Read now

Unlock full access

Acknowledgments
Introduction
Who Should Read This Book and WhyAbout This BookYour Programming Journey
Part 1: Getting Started
Chapter 1: Dealing with Errors and Asking for Help
How to Understand Python Error MessagesExamining TracebacksSearching for Error MessagesPreventing Errors with LintersHow to Ask for Programming HelpLimit Back and Forth by Providing Your Information UpfrontState Your Question in the Form of an Actual QuestionAsk Your Question on the Appropriate WebsiteSummarize Your Question in the HeadlineExplain What You Want the Code to DoInclude the Full Error MessageShare Your Complete CodeMake Your Code Readable with Proper FormattingTell Your Helper What You’ve Already TriedDescribe Your SetupExamples of Asking a QuestionSummary
Chapter 2: Environment Setup and the Command Line
The FilesystemPaths in PythonThe Home DirectoryThe Current Working DirectoryAbsolute vs. Relative PathsPrograms and ProcessesThe Command LineOpening a Terminal WindowRunning Programs from the Command LineUsing Command Line ArgumentsRunning Python Code from the Command Line with -cRunning Python Programs from the Command LineRunning the py.exe ProgramRunning Commands from a Python ProgramMinimizing Typing with Tab CompletionViewing the Command HistoryWorking with Common CommandsEnvironment Variables and PATHViewing Environment VariablesWorking with the PATH Environment VariableChanging the Command Line’s PATH Environment VariablePermanently Adding Folders to PATH on WindowsPermanently Adding Folders to PATH on macOS and LinuxRunning Python Programs Without the Command LineRunning Python Programs on WindowsRunning Python Programs on macOSRunning Python Programs on Ubuntu LinuxSummary
Part 2: Best Practices, Tools, and Techniques
Chapter 3: Code Formatting with Black
How to Lose Friends and Alienate Co-WorkersStyle Guides and PEP 8Horizontal SpacingUse Space Characters for IndentationSpacing Within a LineVertical SpacingA Vertical Spacing ExampleVertical Spacing Best PracticesBlack: The Uncompromising Code FormatterInstalling BlackRunning Black from the Command LineDisabling Black for Parts of Your CodeSummary
Chapter 4: Choosing Understandable Names
Casing StylesPEP 8’s Naming ConventionsAppropriate Name LengthToo Short NamesToo Long NamesMake Names SearchableAvoid Jokes, Puns, and Cultural ReferencesDon’t Overwrite Built-in NamesThe Worst Possible Variable Names EverSummary
Chapter 5: Finding Code Smells
Duplicate CodeMagic NumbersCommented-Out Code and Dead CodePrint DebuggingVariables with Numeric SuffixesClasses That Should Just Be Functions or ModulesList Comprehensions Within List ComprehensionsEmpty except Blocks and Poor Error MessagesCode Smell MythsMyth: Functions Should Have Only One return Statement at the EndMyth: Functions Should Have at Most One try StatementMyth: Flag Arguments Are BadMyth: Global Variables Are BadMyth: Comments Are UnnecessarySummary
Chapter 6: Writing Pythonic Code
The Zen of PythonLearning to Love Significant IndentationCommonly Misused SyntaxUse enumerate() Instead of range()Use the with Statement Instead of open() and close()Use is to Compare with None Instead of ==Formatting StringsUse Raw Strings If Your String Has Many BackslashesFormat Strings with F-StringsMaking Shallow Copies of ListsPythonic Ways to Use DictionariesUse get() and setdefault() with DictionariesUse collections.defaultdict for Default ValuesUse Dictionaries Instead of a switch StatementConditional Expressions: Python’s “Ugly” Ternary OperatorWorking with Variable ValuesChaining Assignment and Comparison OperatorsChecking Whether a Variable Is One of Many ValuesSummary

Chapter 7: Programming Jargon
DefinitionsPython the Language and Python the InterpreterGarbage CollectionLiteralsKeywordsObjects, Values, Instances, and IdentitiesItemsMutable and ImmutableIndexes, Keys, and HashesContainers, Sequences, Mapping, and Set TypesDunder Methods and Magic MethodsModules and PackagesCallables and First-Class ObjectsCommonly Confused TermsStatements vs. ExpressionsBlock vs. Clause vs. BodyVariable vs. AttributeFunction vs. MethodIterable vs. IteratorSyntax vs. Runtime vs. Semantic ErrorsParameters vs. ArgumentsType Coercion vs. Type CastingProperties vs. AttributesBytecode vs. Machine CodeScript vs. Program, Scripting Language vs. Programming LanguageLibrary vs. Framework vs. SDK vs. Engine vs. APISummaryFurther Reading
Chapter 8: Common Python Gotchas
Don’t Add or Delete Items from a List While Looping Over ItDon’t Copy Mutable Values Without copy.copy() and copy.deepcopy()Don’t Use Mutable Values for Default ArgumentsDon’t Build Strings with String ConcatenationDon’t Expect sort() to Sort AlphabeticallyDon’t Assume Floating-Point Numbers Are Perfectly AccurateDon’t Chain Inequality != OperatorsDon’t Forget the Comma in Single-Item TuplesSummary
Chapter 9: Esoteric Python Oddities
Why 256 Is 256 but 257 Is Not 257String InterningPython’s Fake Increment and Decrement OperatorsAll of NothingBoolean Values Are Integer ValuesChaining Multiple Kinds of OperatorsPython’s Antigravity FeatureSummary
Chapter 10: Writing Effective Functions
Function NamesFunction Size Trade-OffsFunction Parameters and ArgumentsDefault ArgumentsUsing * and ** to Pass Arguments to FunctionsUsing * to Create Variadic FunctionsUsing ** to Create Variadic FunctionsUsing * and ** to Create Wrapper FunctionsFunctional ProgrammingSide EffectsHigher-Order FunctionsLambda FunctionsMapping and Filtering with List ComprehensionsReturn Values Should Always Have the Same Data TypeRaising Exceptions vs. Returning Error CodesSummary
Chapter 11: Comments, Docstrings, and Type Hints
CommentsComment StyleInline CommentsExplanatory CommentsSummary Comments“Lessons Learned” CommentsLegal CommentsProfessional CommentsCodetags and TODO CommentsMagic Comments and Source File EncodingDocstringsType HintsUsing Static AnalyzersSetting Type Hints for Multiple TypesSetting Type Hints for Lists, Dictionaries, and MoreBackporting Type Hints with CommentsSummary
Chapter 12: Organizing Your Code Projects with Git
Git Commits and ReposUsing Cookiecutter to Create New Python ProjectsInstalling GitConfiguring Your Git Username and EmailInstalling GUI Git ToolsThe Git WorkflowHow Git Keeps Track of File StatusWhy Stage Files?Creating a Git Repo on Your ComputerAdding Files for Git to TrackIgnoring Files in the RepoCommitting ChangesDeleting Files from the RepoRenaming and Moving Files in the RepoViewing the Commit LogRecovering Old ChangesUndoing Uncommitted Local ChangesUnstaging a Staged FileRolling Back the Most Recent CommitsRolling Back to a Specific Commit for a Single FileRewriting the Commit HistoryGitHub and the git push CommandPushing an Existing Repository to GitHubCloning a Repo from an Existing GitHub RepoSummary
Chapter 13: Measuring Performance and Big O Algorithm Analysis
The timeit ModuleThe cProfile ProfilerBig O Algorithm AnalysisBig O OrdersA Bookshelf Metaphor for Big O OrdersBig O Measures the Worst-Case ScenarioDetermining the Big O Order of Your CodeWhy Lower Orders and Coefficients Don’t MatterBig O Analysis ExamplesThe Big O Order of Common Function CallsAnalyzing Big O at a GlanceBig O Doesn’t Matter When n Is Small, and n Is Usually SmallSummary
Chapter 14: Practice Projects
The Tower of HanoiThe Output The Source CodeWriting the CodeFour-in-a-RowThe OutputThe Source Code Writing the CodeSummary
Part 3: Object-Oriented Python
Chapter 15: Object-Oriented Programming and Classes
Real-World Analogy: Filling Out a FormCreating Objects from ClassesCreating a Simple Class: WizCoinMethods, __init__(), and selfAttributesPrivate Attributes and Private MethodsThe type() Function and __qualname__ AttributeNon-OOP vs. OOP Examples: Tic-Tac-ToeDesigning Classes for the Real World Is HardSummary
Chapter 16: Object-Oriented Programming and Inheritance
How Inheritance WorksOverriding MethodsThe super() FunctionFavor Composition Over InheritanceInheritance’s DownsideThe isinstance() and issubclass() FunctionsClass MethodsClass AttributesStatic MethodsWhen to Use Class and Static Object-Oriented FeaturesObject-Oriented BuzzwordsEncapsulationPolymorphismWhen Not to Use InheritanceMultiple InheritanceMethod Resolution OrderSummary
Chapter 17: Pythonic OOP: Properties and Dunder Methods
PropertiesTurning an Attribute into a PropertyUsing Setters to Validate DataRead-Only PropertiesWhen to Use PropertiesPython’s Dunder MethodsString Representation Dunder MethodsNumeric Dunder MethodsReflected Numeric Dunder MethodsIn-Place Augmented Assignment Dunder MethodsComparison Dunder MethodsSummary
Index

Content preview from Beyond the Basic Stuff with Python

10 Writing Effective Functions

Functions are like mini programs within our programs that allow us to break code into smaller units. This spares us from having to write duplicate code, which can introduce bugs. But writing effective functions requires making many decisions about naming, size, parameters, and complexity.

This chapter explores the different ways we can write functions and the benefits and drawbacks of different trade-offs. We’ll delve into how to trade off between small and large functions, how the number of parameters affects the function’s complexity, and how to write functions with variable numbers of arguments using the ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781098128203

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Beyond the Basic Stuff with Python

by Al Sweigart

10 Writing Effective Functions

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.