Pascal Bugnion [Pascal Bugnion] - Scala for Data Science
Here you can read online Pascal Bugnion [Pascal Bugnion] - Scala for Data Science full text of the book (entire story) in english for free. Download pdf and epub, get meaning, cover and reviews about this ebook. year: 2016, publisher: Packt Publishing, genre: Computer. Description of the work, (preface) as well as reviews are available. Best literature library LitArk.com created for fans of good reading and offers a wide selection of genres:
Romance novel
Science fiction
Adventure
Detective
Science
History
Home and family
Prose
Art
Politics
Computer
Non-fiction
Religion
Business
Children
Humor
Choose a favorite category and find really read worthwhile books. Enjoy immersion in the world of imagination, feel the emotions of the characters or learn something new for yourself, make an fascinating discovery.
![Pascal Bugnion [Pascal Bugnion] Scala for Data Science](https://litark.com/uploads/posts/book/119601/pascal-bugnion-pascal-bugnion-scala-for-data.jpg)
- Book:Scala for Data Science
- Author:
- Publisher:Packt Publishing
- Genre:
- Year:2016
- Rating:3 / 5
- Favourites:Add to favourites
- Your mark:
Scala for Data Science: summary, description and annotation
We offer to read an annotation, description, summary or preface (depends on what the author of the book "Scala for Data Science" wrote himself). If you haven't found the necessary information about the book — write in the comments, we will try to find it.
Leverage the power of Scala with different tools to build scalable, robust data science applications
About This Book
- A complete guide for scalable data science solutions, from data ingestion to data visualization
- Deploy horizontally scalable data processing pipelines and take advantage of web frameworks to build engaging visualizations
- Build functional, type-safe routines to interact with relational and NoSQL databases with the help of tutorials and examples provided
Who This Book Is For
If you are a Scala developer or data scientist, or if you want to enter the field of data science, then this book will give you all the tools you need to implement data science solutions.
What You Will Learn
- Transform and filter tabular data to extract features for machine learning
- Implement your own algorithms or take advantage of MLLibs extensive suite of models to build distributed machine learning pipelines
- Read, transform, and write data to both SQL and NoSQL databases in a functional manner
- Write robust routines to query web APIs
- Read data from web APIs such as the GitHub or Twitter API
- Use Scala to interact with MongoDB, which offers high performance and helps to store large data sets with uncertain query requirements
- Create Scala web applications that couple with JavaScript libraries such as D3 to create compelling interactive visualizations
- Deploy scalable parallel applications using Apache Spark, loading data from HDFS or Hive
In Detail
Scala is a multi-paradigm programming language (it supports both object-oriented and functional programming) and scripting language used to build applications for the JVM. Languages such as R, Python, Java, and so on are mostly used for data science. It is particularly good at analyzing large sets of data without any significant impact on performance and thus Scala is being adopted by many developers and data scientists. Data scientists might be aware that building applications that are truly scalable is hard. Scala, with its powerful functional libraries for interacting with databases and building scalable frameworks will give you the tools to construct robust data pipelines.
This book will introduce you to the libraries for ingesting, storing, manipulating, processing, and visualizing data in Scala.
Packed with real-world examples and interesting data sets, this book will teach you to ingest data from flat files and web APIs and store it in a SQL or NoSQL database. It will show you how to design scalable architectures to process and modelling your data, starting from simple concurrency constructs such as parallel collections and futures, through to actor systems and Apache Spark. As well as Scalas emphasis on functional structures and immutability, you will learn how to use the right parallel construct for the job at hand, minimizing development time without compromising scalability. Finally, you will learn how to build beautiful interactive visualizations using web frameworks.
This book gives tutorials on some of the most common Scala libraries for data science, allowing you to quickly get up to speed with building data science and data engineering solutions.
Style and approach
A tutorial with complete examples, this book will give you the tools to start building useful data engineering and data science solutions straightaway
Downloading the example code for this book. You can download the example code files for all Packt books you have purchased from your account at http://www.PacktPub.com. If you purchased this book elsewhere, you can visit http://www.PacktPub.com/support and register to have the code file.
Pascal Bugnion [Pascal Bugnion]: author's other books
Who wrote Scala for Data Science? Find out the surname, the name of the author of the book and a list of all author's works by series.
Scala for Data Science — read online for free the complete book (whole text) full work
Below is the text of the book, divided by pages. System saving the place of the last page read, allows you to conveniently read the book "Scala for Data Science" online for free, without having to search again every time where you left off. Put a bookmark, and you can go to the page where you finished reading at any time.
Font size:
Interval:
Bookmark:
Pattern matching is a powerful tool for control flow in Scala. It is often underused and under-estimated by people coming to Scala from imperative languages.
Let's start with a few examples of pattern matching before diving into the theory. We start by defining a tuple:
We can use pattern matching to extract the elements of this tuple and bind them to variables:
We just extracted the two elements of the names tuple, binding them to the variables firstName and lastName. Notice how the left-hand side defines a pattern that the right-hand side must match: we are declaring that the variable names must be a two-element tuple. To make the pattern more specific, we could also have specified the expected types of the elements in the tuple:
What happens if the pattern on the left-hand side does not match the right-hand side?
This results in a compile error. Other types of pattern matching failures result in runtime errors.
Pattern matching is very expressive. To achieve the same behavior without pattern matching, you would have to do the following explicitly:
- Verify that the variable
namesis a two-element tuple - Extract the first element and bind it to
firstName - Extract the second element and bind it to
lastName
If we expect certain elements in the tuple to have specific values, we can verify this as part of the pattern match. For instance, we can verify that the first element of the names tuple matches "Pascal":
Besides tuples, we can also match on Scala collections:
Notice the similarity between this pattern matching and array construction:
Syntactically, Scala expresses pattern matching as the reverse process to instance construction. We can think of pattern matching as the deconstruction of an object, binding the object's constituent parts to variables.
When matching against collections, one is sometimes only interested in matching the first element, or the first few elements, and discarding the rest of the collection, whatever its length. The operator _* will match against any number of elements:
By default, the part of the pattern matched by the _* operator is not bound to a variable. We can capture it as follows:
Besides tuples and collections, we can also match against case classes. Let's start by defining a case representing a name:
We can match against instances of Name in much the same way we matched against tuples:
All these patterns can also be used in match statements:
Pattern matching is useful in for comprehensions for extracting items from a collection that match a specific pattern. Let's build a collection of Name instances:
We can use pattern matching to extract the internals of the class in a for-comprehension:
So far, nothing terribly ground-breaking. But what if we wanted to extract the surname of everyone whose first name is "Martin"?
Writing Name("Martin", last) <- names extracts the elements of names that match the pattern. You might , Web APIs demonstrate the usefulness and versatility of this language pattern, for instance, for extracting specific fields from JSON objects.
If you define a case class, as we saw with Name, you get pattern matching against the constructor for free . You should be using case classes to represent your data as much as possible, thus reducing the need to implement your own pattern matching. It is nevertheless useful to understand how pattern matching works.
When you create a case class, Scala automatically builds a companion object:
The method used (internally) for pattern matching is unapply. This method takes, as argument, an object and returns Option[T], where T is a tuple of the values of the case class.
The unapply method is an extractor . It plays the opposite role of the constructor: it takes an object and extracts the list of parameters needed to construct that object. When you write val Name(firstName, lastName), or when you use Name as a case in a match statement, Scala calls Name.unapply on what you are matching against. A value of Some[(String, String)] implies a pattern match, while a value of None implies that the pattern fails.
Font size:
Interval:
Bookmark:
Similar books «Scala for Data Science»
Look at similar books to Scala for Data Science. We have selected literature similar in name and meaning in the hope of providing readers with more options to find new, interesting, not yet read works.
Discussion, reviews of the book Scala for Data Science and just readers' own opinions. Leave your comments, write what you think about the work, its meaning or the main characters. Specify what exactly you liked and what you didn't like, and why you think so.