Julia 1.0 Programming Complete Reference Guide电子书

About Packt

Why subscribe?

Packt.com

Contributors

About the authors

Packt is searching for authors like you

Preface

Who this book is for

What this book covers

To get the most out of this book

Download the example code files

Download the color images

Conventions used

Get in touch

Reviews

Installing the Julia Platform

Installing Julia

Windows OS

OS X

Linux OS

Building from source

JuliaPro

Working with Julia's REPL

Startup options and Julia scripts

Packages

Adding a new package

Installing and working with IJulia

Installing Juno

Installing julia-vscode

Installing Sublime-IJulia

Other editors and IDEs

How Julia works

Summary

Variables, Types, and Operations

Variables, naming conventions, and comments

Types

Integers

Floating point numbers

Elementary mathematical functions and operations

Rational and complex numbers

Characters

Strings

Formatting numbers and strings

Regular expressions

Ranges and arrays

Other ways to create arrays

Some common functions for arrays

Dates and times

Scope and constants

Summary

Functions

Defining functions

Optional and keyword arguments

Anonymous functions

First-class functions and closures

functions

Broadcasting

Map, filter, and list comprehensions

Generic functions and multiple dispatch

Summary

Control Flow

Conditional evaluation

Repeated evaluation

for loops

while loops

The break statement

The continue statement

Exception handling

Scope revisited

Tasks

Summary

Collection Types

Matrices

Tuples

Dictionaries

Keys and values – looping

Sets

An example project – word frequency

Summary

More on Types, Methods, and Modules

Type annotations

Type conversions and promotions

The type hierarchy – subtypes and supertypes

Concrete and abstract types

User-defined and composite types

When are two values or objects equal or identical?

A multiple-dispatch example

Types and collections – inner constructors

Type unions

Parametric types and methods

Standard modules and paths

Summary

Metaprogramming in Julia

Expressions and symbols

Evaluation and interpolation

Defining macros

Built-in macros

Testing

Debugging

Benchmarking

Starting a task

Reflection capabilities

Summary

I/O, Networking, and Parallel Computing

Basic input and output

Working with files

Reading and writing CSV files

Using DataFrames

Other file formats

Working with TCP sockets and servers

Interacting with databases

Parallel operations and computing

Creating processes

Using low-level communications

Parallel loops and maps

Summary

Running External Programs

Running shell commands

Interpolation

Pipelining

Calling C and Fortran

Calling Python

Performance tips

Tools to use

Summary

The Standard Library and Packages

Digging deeper into the standard library

Julia's package manager

Installing and updating packages

Graphics in Julia

Using Plots on data

Summary

Creating Our First Julia App

Technical requirements

Defining variables

Constants

Why are constants important?

Comments

Strings

Triple-quoted strings

Concatenating strings

Interpolating strings

Manipulating strings

Unicode and UTF-8

Regular expressions

Raw string literals

Numbers

Integers

Overflow behavior

Floating-point numbers

Rational numbers

Numerical operators

Vectorized dot operators

There's more to it

Tuples

Named tuples

Ranges

Arrays

Iteration

Mutating arrays

Comprehensions

Generators

Exploratory data analysis with Julia

The Iris flower dataset

Using the RDatasets package

Using simple statistics to better understand our data

Visualizing the Iris flowers data

Loading and saving our data

Saving and loading using tabular file formats

Working with Feather files

Saving and loading with MongoDB

Summary

Setting Up the Wiki Game

Technical requirements

Data harvesting through web scraping

How the web works – a crash course

Making HTTP requests

Learning about HTTP methods

Understanding HTTPS

Understanding HTML documents

HTML selectors

Learning about the HTML attributes

Learning about CSS and JavaScript selectors

Understanding the structure of a link

Accessing the internet from Julia

Making requests with the HTTP package

Handling HTTP responses

HTTP status codes

Learning about HTTP headers

The HTTP message body

Understanding HTTP responses

The status code

The headers

The message body

Learning about pairs

Dictionaries

Constructing dictionaries

Ordered dictionaries

Working with dictionaries

Using the HTTP response

Manipulating the response body

Building a DOM representation of the page

Parsing HTML with Gumbo

Coding defensively

The pipe operator

Handling errors like a pro

The try...catch statements

The finally clause

Throwing exceptions on errors

Rethrowing exceptions

Learning about functions

The return keyword

Returning multiple values

Optional arguments

Keyword arguments

Documenting functions

Writing a basic web crawler – take one

Setting up our project

Writing a Julia program

Conditional evaluation of if, elseif, and else statements

The ternary operator

Short-circuit evaluation

Beware of operator precedence

Carrying on with the crawler's implementation

Summary

Building the Wiki Game Web Crawler

Technical requirements

Six Degrees of Wikipedia, the gameplay

Some additional requirements

Organizing our code

Using modules to tame our code

Defining modules

Productive REPL sessions with Julia

Setting up our modules

Referencing modules

Setting up the LOAD_PATH

Loading modules with using

Loading modules with import

Loading modules with include

Nesting modules

Setting up our game's architecture

Checking our code

Building our Wikipedia crawler - take two

Using blocks

Implementing the gameplay

Finishing touches

One more thing

Learning about Julia's type system

Defining our own types

Constructing types

Mutable composite types

Type hierarchy and inheritance

Type unions

Using article types

Inner constructors

Methods

Working with relational databases

Adding MySQL support

Connecting to the database

Setting up our Article module

Adding the persistence and retrieval methods

Putting it all together

Summary

Adding a Web UI for the Wiki Game

Technical requirements

The game plan

Learning about Julia's web stack

Beginning with a simple example – Hello World

Developing the game's web UI

Defining our routes

Preparing the landing page

Starting a new game

Extracting the difficulty settings from the page URL

Starting a new game session

Rendering the first Wikipedia article from the chain

Setting up in-article navigation

Displaying information about the game session

Displaying a Wikipedia article page

Navigating back up the article chain

Showing the solution

Handling any other requests

Wrapping it up

Summary

Implementing Recommender Systems with Julia

Technical requirements

Understanding recommender systems

Classifying recommender systems

Learning about non-personalized, stereotyped, and personalized recommendations

Understanding personalized recommendations

Explicit and implicit ratings

Understanding content-based recommender systems

Beginning with association-based recommendations

Learning about collaborative filtering

Understanding user-item CF

Item-item CF

Summary

Machine Learning for Recommender Systems

Technical requirements

Comparing the memory-based versus model-based recommenders

Learning about the model-based approach

Understanding our data

A first look at the data

Loading the data

Handling missing data

Data analysis and preparation

Training our data models

Scaling down our dataset

Training versus testing data

Machine learning-based recommendations

Making recommendations with Recommendation

Setting up the training data

Building and training the recommender

Matrix Factorization

Making recommendations

Testing the recommendations

Learning about hybrid recommender systems

Summary

Other Books You May Enjoy

Leave a review - let other readers know what you think