Functional Programming For Dummies

 
 
Standards Information Network (Verlag)
  • 1. Auflage
  • |
  • erschienen am 28. Dezember 2018
  • |
  • 320 Seiten
 
E-Book | PDF mit Adobe-DRM | Systemvoraussetzungen
978-1-119-52749-7 (ISBN)
 
Your guide to the functional programming paradigm Functional programming mainly sees use in math computations, including those used in Artificial Intelligence and gaming. This programming paradigm makes algorithms used for math calculations easier to understand and provides a concise method of coding algorithms by people who aren't developers. Current books on the market have a significant learning curve because they're written for developers, by developers--until now. Functional Programming for Dummies explores the differences between the pure (as represented by the Haskell language) and impure (as represented by the Python language) approaches to functional programming for readers just like you. The pure approach is best suited to researchers who have no desire to create production code but do need to test algorithms fully and demonstrate their usefulness to peers. The impure approach is best suited to production environments because it's possible to mix coding paradigms in a single application to produce a result more quickly. Functional Programming For Dummies uses this two-pronged approach to give you an all-in-one approach to a coding methodology that can otherwise be hard to grasp. * Learn pure and impure when it comes to coding * Dive into the processes that most functional programmers use to derive, analyze and prove the worth of algorithms * Benefit from examples that are provided in both Python and Haskell * Glean the expertise of an expert author who has written some of the market-leading programming books to date If you're ready to massage data to understand how things work in new ways, you've come to the right place!
1. Auflage
  • Englisch
  • Newark
  • |
  • USA
John Wiley & Sons Inc
  • Für Beruf und Forschung
  • 8,31 MB
978-1-119-52749-7 (9781119527497)
weitere Ausgaben werden ermittelt
John Paul Mueller has written more than 100 books and 600+ articles on everything from networking and home security to database management and heads-down programming. His technical editing talents have helped more than 70 authors refine and polish their manuscripts. John's books address every level of skill from beginning to advanced.
  • Intro
  • Title Page
  • Copyright Page
  • Table of Contents
  • Introduction
  • About This Book
  • Foolish Assumptions
  • Icons Used in This Book
  • Beyond the Book
  • Where to Go from Here
  • Part 1 Getting Started with Functional Programming
  • Chapter 1 Introducing Functional Programming
  • Defining Functional Programming
  • Understanding its goals
  • Using the pure approach
  • Using the impure approach
  • Considering Other Programming Paradigms
  • Imperative
  • Procedural
  • Object-oriented
  • Declarative
  • Using Functional Programming to Perform Tasks
  • Discovering Languages That Support Functional Programming
  • Considering the pure languages
  • Considering the impure languages
  • Finding Functional Programming Online
  • Chapter 2 Getting and Using Python
  • Working with Python in This Book
  • Creating better code
  • Debugging functionality
  • Defining why notebooks are useful
  • Obtaining Your Copy of Anaconda
  • Obtaining Analytics Anaconda
  • Installing Anaconda on Linux
  • Installing Anaconda on MacOS
  • Installing Anaconda on Windows
  • Understanding the Anaconda package
  • Downloading the Datasets and Example Code
  • Using Jupyter Notebook
  • Defining the code repository
  • Getting and using datasets
  • Creating a Python Application
  • Understanding cells
  • Adding documentation cells
  • Other cell content
  • Running the Python Application
  • Understanding the Use of Indentation
  • Adding Comments
  • Understanding comments
  • Using comments to leave yourself reminders
  • Using comments to keep code from executing
  • Closing Jupyter Notebook
  • Getting Help with the Python Language
  • Chapter 3 Getting and Using Haskell
  • Working with Haskell in This Book
  • Obtaining and Installing Haskell
  • Installing Haskell on a Linux system
  • Installing Haskell on a Mac system
  • Installing Haskell on a Windows system
  • Testing the Haskell Installation
  • Compiling a Haskell Application
  • Using Haskell Libraries
  • Getting Help with the Haskell Language
  • Part 2 Starting Functional Programming Tasks
  • Chapter 4 Defining the Functional Difference
  • Comparing Declarations to Procedures
  • Understanding How Data Works
  • Working with immutable data
  • Considering the role of state
  • Eliminating side effects
  • Seeing a Function in Haskell
  • Using non-curried functions
  • Using curried functions
  • Seeing a Function in Python
  • Creating and using a Python function
  • Passing by reference versus by value
  • Chapter 5 Understanding the Role of Lambda Calculus
  • Considering the Origins of Lambda Calculus
  • Understanding the Rules
  • Working with variables
  • Using application
  • Using abstraction
  • Performing Reduction Operations
  • Considering a-conversion
  • Considering ß-reduction
  • Considering ?-conversion
  • Creating Lambda Functions in Haskell
  • Creating Lambda Functions in Python
  • Chapter 6 Working with Lists and Strings
  • Defining List Uses
  • Creating Lists
  • Using Haskell to create Lists
  • Using Python to create lists
  • Evaluating Lists
  • Using Haskell to evaluate Lists
  • Using Python to evaluate lists
  • Performing Common List Manipulations
  • Understanding the list manipulation functions
  • Using Haskell to manipulate lists
  • Using Python to manipulate lists
  • Understanding the Dictionary and Set Alternatives
  • Using dictionaries
  • Using sets
  • Considering the Use of Strings
  • Understanding the uses for strings
  • Performing string-related tasks in Haskell
  • Performing string-related tasks in Python
  • Part 3 Making Functional Programming Practical
  • Chapter 7 Performing Pattern Matching
  • Looking for Patterns in Data
  • Understanding Regular Expressions
  • Defining special characters using escapes
  • Defining wildcard characters
  • Working with anchors
  • Delineating subexpressions using grouping constructs
  • Using Pattern Matching in Analysis
  • Working with Pattern Matching in Haskell
  • Performing simple Posix matches
  • Matching a telephone number with Haskell
  • Working with Pattern Matching in Python
  • Performing simple Python matches
  • Doing more than matching
  • Matching a telephone number with Python
  • Chapter 8 Using Recursive Functions
  • Performing Tasks More than Once
  • Defining the need for repetition
  • Using recursion instead of looping
  • Understanding Recursion
  • Considering basic recursion
  • Performing tasks using lists
  • Upgrading to set and dictionary
  • Considering the use of collections
  • Using Recursion on Lists
  • Working with Haskell
  • Working with Python
  • Passing Functions Instead of Variables
  • Understanding when you need a function
  • Passing functions in Haskell
  • Passing functions in Python
  • Defining Common Recursion Errors
  • Forgetting an ending
  • Passing data incorrectly
  • Defining a correct base instruction
  • Chapter 9 Advancing with Higher-Order Functions
  • Considering Types of Data Manipulation
  • Performing Slicing and Dicing
  • Keeping datasets controlled
  • Focusing on specific data
  • Slicing and dicing with Haskell
  • Slicing and dicing with Python
  • Mapping Your Data
  • Understanding the purpose of mapping
  • Performing mapping tasks with Haskell
  • Performing mapping tasks with Python
  • Filtering Data
  • Understanding the purpose of filtering
  • Using Haskell to filter data
  • Using Python to filter data
  • Organizing Data
  • Considering the types of organization
  • Sorting data with Haskell
  • Sorting data with Python
  • Chapter 10 Dealing with Types
  • Developing Basic Types
  • Understanding the functional perception of type
  • Considering the type signature
  • Creating types
  • Composing Types
  • Understanding monoids
  • Considering the use of Nothing, Maybe, and Just
  • Understanding semigroups
  • Parameterizing Types
  • Dealing with Missing Data
  • Handling nulls
  • Performing data replacement
  • Considering statistical measures
  • Creating and Using Type Classes
  • Part 4 Interacting in Various Ways
  • Chapter 11 Performing Basic I/O
  • Understanding the Essentials of I/O
  • Understanding I/O side effects
  • Using monads for I/O
  • Interacting with the user
  • Working with devices
  • Manipulating I/O Data
  • Using the Jupyter Notebook Magic Functions
  • Receiving and Sending I/O with Haskell
  • Using monad sequencing
  • Employing monad functions
  • Chapter 12 Handling the Command Line
  • Getting Input from the Command Line
  • Automating the command line
  • Considering the use of prompts
  • Using the command line effectively
  • Accessing the Command Line in Haskell
  • Using the Haskell environment directly
  • Making sense of the variety of packages
  • Obtaining CmdArgs
  • Getting a simple command line in Haskell
  • Accessing the Command Line in Python
  • Using the Python environment directly
  • Interacting with Argparse
  • Chapter 13 Dealing with Files
  • Understanding How Local Files are Stored
  • Ensuring Access to Files
  • Interacting with Files
  • Creating new files
  • Opening existing files
  • Manipulating File Content
  • Considering CRUD
  • Reading data
  • Updating data
  • Completing File-related Tasks
  • Chapter 14 Working with Binary Data
  • Comparing Binary to Textual Data
  • Using Binary Data in Data Analysis
  • Understanding the Binary Data Format
  • Working with Binary Data
  • Interacting with Binary Data in Haskell
  • Writing binary data using Haskell
  • Reading binary data using Haskell
  • Interacting with Binary Data in Python
  • Writing binary data using Python
  • Reading binary data using Python
  • Chapter 15 Dealing with Common Datasets
  • Understanding the Need for Standard Datasets
  • Finding the Right Dataset
  • Locating general dataset information
  • Using library-specific datasets
  • Loading a Dataset
  • Working with toy datasets
  • Creating custom data
  • Fetching common datasets
  • Manipulating Dataset Entries
  • Determining the dataset content
  • Creating a DataFrame
  • Accessing specific records
  • Part 5 Performing Simple Error Trapping
  • Chapter 16 Handling Errors in Haskell
  • Defining a Bug in Haskell
  • Considering recursion
  • Understanding laziness
  • Using unsafe functions
  • Considering implementation-specific issues
  • Understanding the Haskell-Related Errors
  • Fixing Haskell Errors Quickly
  • Relying on standard debugging
  • Understanding errors versus exceptions
  • Chapter 17 Handling Errors in Python
  • Defining a Bug in Python
  • Considering the sources of errors
  • Considering version differences
  • Understanding the Python-Related Errors
  • Dealing with late binding closures
  • Using a variable
  • Working with third-party libraries
  • Fixing Python Errors Quickly
  • Understanding the built-in exceptions
  • Obtaining a list of exception arguments
  • Considering functional style exception handling
  • Part 6 The Part of Tens
  • Chapter 18 Ten Must-Have Haskell Libraries
  • binary
  • Hascore
  • vect
  • vector
  • aeson
  • attoparsec
  • bytestring
  • stringsearch
  • text
  • moo
  • Chapter 19 Ten (Plus) Must-Have Python Packages
  • Gensim
  • PyAudio
  • PyQtGraph
  • TkInter
  • PrettyTable
  • SQLAlchemy
  • Toolz
  • Cloudera Oryx
  • funcy
  • SciPy
  • XGBoost
  • Chapter 20 Ten Occupation Areas that Use Functional Programming
  • Starting with Traditional Development
  • Going with New Development
  • Creating Your Own Development
  • Finding a Forward-Thinking Business
  • Doing Something Really Interesting
  • Developing Deep Learning Applications
  • Writing Low-Level Code
  • Helping Others in the Health Care Arena
  • Working as a Data Scientist
  • Researching the Next Big Thing
  • Index
  • EULA

Dateiformat: PDF
Kopierschutz: Adobe-DRM (Digital Rights Management)

Systemvoraussetzungen:

Computer (Windows; MacOS X; Linux): Installieren Sie bereits vor dem Download die kostenlose Software Adobe Digital Editions (siehe E-Book Hilfe).

Tablet/Smartphone (Android; iOS): Installieren Sie bereits vor dem Download die kostenlose App Adobe Digital Editions (siehe E-Book Hilfe).

E-Book-Reader: Bookeen, Kobo, Pocketbook, Sony, Tolino u.v.a.m. (nicht Kindle)

Das Dateiformat PDF zeigt auf jeder Hardware eine Buchseite stets identisch an. Daher ist eine PDF auch für ein komplexes Layout geeignet, wie es bei Lehr- und Fachbüchern verwendet wird (Bilder, Tabellen, Spalten, Fußnoten). Bei kleinen Displays von E-Readern oder Smartphones sind PDF leider eher nervig, weil zu viel Scrollen notwendig ist. Mit Adobe-DRM wird hier ein "harter" Kopierschutz verwendet. Wenn die notwendigen Voraussetzungen nicht vorliegen, können Sie das E-Book leider nicht öffnen. Daher müssen Sie bereits vor dem Download Ihre Lese-Hardware vorbereiten.

Bitte beachten Sie bei der Verwendung der Lese-Software Adobe Digital Editions: wir empfehlen Ihnen unbedingt nach Installation der Lese-Software diese mit Ihrer persönlichen Adobe-ID zu autorisieren!

Weitere Informationen finden Sie in unserer E-Book Hilfe.


Download (sofort verfügbar)

20,99 €
inkl. 7% MwSt.
Download / Einzel-Lizenz
PDF mit Adobe-DRM
siehe Systemvoraussetzungen
E-Book bestellen