舉報 
會員
Julia 1.0 Programming Complete Reference Guide
JuliaoffersthehighproductivityandeaseofuseofPythonandRwiththelightning-fastspeedofC++.There’sneverbeenabettertimetolearnthislanguage,thankstoitslarge-scaleadoptionacrossawiderangeofdomains,includingfintech,biotechandartificialintelligence(AI).YouwillbeginbylearninghowtosetuparunningJuliaplatform,beforeexploringitsvariousbuilt-intypes.ThisLearningPathwalksyouthroughtwoimportantcollectiontypes:arraysandmatrices.You’llbetakenthroughhowtypeconversionsandpromotionswork,andinfurtherchaptersyou'llstudyhowJuliainteractswithoperatingsystemsandotherlanguages.You’llalsolearnabouttheuseofmacros,whatmakesJuliasuitablefornumericalandscientificcomputing,andhowtorunexternalprograms.Onceyouhavegraspedthebasics,thisLearningPathgoesontohowtoanalyzetheIrisdatasetusingDataFrames.Whilebuildingawebscraperandawebapp,you’llexploretheuseoffunctions,methods,andmultipledispatches.Inthefinalchapters,you'lldelveintomachinelearning,whereyou'llbuildabookrecommendersystem.BytheendofthisLearningPath,you’llbewellversedwithJuliaandhavetheskillsyouneedtoleverageitshighspeedandefficiencyforyourapplications.ThisLearningPathincludescontentfromthefollowingPacktproducts:Julia1.0Programming-SecondEditionbyIvoBalbaert.JuliaProgrammingProjectsbyAdrianSalceanu.
最新章節
- Leave a review - let other readers know what you think
- Other Books You May Enjoy
- Summary
- Learning about hybrid recommender systems
- Testing the recommendations
- Making recommendations
品牌：中圖公司
上架時間：2021-06-24 12:18:21
出版社：Packt Publishing
本書數字版權由中圖公司提供，并由其授權上海閱文信息技術有限公司制作發行
- Leave a review - let other readers know what you think 更新時間：2021-06-24 14:22:37
- Other Books You May Enjoy
- Summary
- Learning about hybrid recommender systems
- Testing the recommendations
- Making recommendations
- Matrix Factorization
- Building and training the recommender
- Setting up the training data
- Making recommendations with Recommendation
- Machine learning-based recommendations
- Training versus testing data
- Scaling down our dataset
- Training our data models
- Data analysis and preparation
- Handling missing data
- Loading the data
- A first look at the data
- Understanding our data
- Learning about the model-based approach
- Comparing the memory-based versus model-based recommenders
- Technical requirements
- Machine Learning for Recommender Systems
- Summary
- Item-item CF
- Understanding user-item CF
- Learning about collaborative filtering
- Beginning with association-based recommendations
- Understanding content-based recommender systems
- Explicit and implicit ratings
- Understanding personalized recommendations
- Learning about non-personalized stereotyped and personalized recommendations
- Classifying recommender systems
- Understanding recommender systems
- Technical requirements
- Implementing Recommender Systems with Julia
- Summary
- Wrapping it up
- Handling any other requests
- Showing the solution
- Navigating back up the article chain
- Displaying a Wikipedia article page
- Displaying information about the game session
- Setting up in-article navigation
- Rendering the first Wikipedia article from the chain
- Starting a new game session
- Extracting the difficulty settings from the page URL
- Starting a new game
- Preparing the landing page
- Defining our routes
- Developing the game's web UI
- Beginning with a simple example – Hello World
- Learning about Julia's web stack
- The game plan
- Technical requirements
- Adding a Web UI for the Wiki Game
- Summary
- Putting it all together
- Adding the persistence and retrieval methods
- Setting up our Article module
- Connecting to the database
- Adding MySQL support
- Working with relational databases
- Methods
- Inner constructors
- Using article types
- Type unions
- Type hierarchy and inheritance
- Mutable composite types
- Constructing types
- Defining our own types
- Learning about Julia's type system
- One more thing
- Finishing touches
- Implementing the gameplay
- Using blocks
- Building our Wikipedia crawler - take two
- Checking our code
- Setting up our game's architecture
- Nesting modules
- Loading modules with include
- Loading modules with import
- Loading modules with using
- Setting up the LOAD_PATH
- Referencing modules
- Setting up our modules
- Productive REPL sessions with Julia
- Defining modules
- Using modules to tame our code
- Organizing our code
- Some additional requirements
- Six Degrees of Wikipedia the gameplay
- Technical requirements
- Building the Wiki Game Web Crawler
- Summary
- Carrying on with the crawler's implementation
- Beware of operator precedence
- Short-circuit evaluation
- The ternary operator
- Conditional evaluation of if elseif and else statements
- Writing a Julia program
- Setting up our project
- Writing a basic web crawler – take one
- Documenting functions
- Keyword arguments
- Optional arguments
- Returning multiple values
- The return keyword
- Learning about functions
- Rethrowing exceptions
- Throwing exceptions on errors
- The finally clause
- The try...catch statements
- Handling errors like a pro
- The pipe operator
- Coding defensively
- Parsing HTML with Gumbo
- Building a DOM representation of the page
- Manipulating the response body
- Using the HTTP response
- Working with dictionaries
- Ordered dictionaries
- Constructing dictionaries
- Dictionaries
- Learning about pairs
- The message body
- The headers
- The status code
- Understanding HTTP responses
- The HTTP message body
- Learning about HTTP headers
- HTTP status codes
- Handling HTTP responses
- Making requests with the HTTP package
- Accessing the internet from Julia
- Understanding the structure of a link
- Learning about CSS and JavaScript selectors
- Learning about the HTML attributes
- HTML selectors
- Understanding HTML documents
- Understanding HTTPS
- Learning about HTTP methods
- Making HTTP requests
- How the web works – a crash course
- Data harvesting through web scraping
- Technical requirements
- Setting Up the Wiki Game
- Summary
- Saving and loading with MongoDB
- Working with Feather files
- Saving and loading using tabular file formats
- Loading and saving our data
- Visualizing the Iris flowers data
- Using simple statistics to better understand our data
- Using the RDatasets package
- The Iris flower dataset
- Exploratory data analysis with Julia
- Generators
- Comprehensions
- Mutating arrays
- Iteration
- Arrays
- Ranges
- Named tuples
- Tuples
- There's more to it
- Vectorized dot operators
- Numerical operators
- Rational numbers
- Floating-point numbers
- Overflow behavior
- Integers
- Numbers
- Raw string literals
- Regular expressions
- Unicode and UTF-8
- Manipulating strings
- Interpolating strings
- Concatenating strings
- Triple-quoted strings
- Strings
- Comments
- Why are constants important?
- Constants
- Defining variables
- Technical requirements
- Creating Our First Julia App
- Summary
- Using Plots on data
- Graphics in Julia
- Installing and updating packages
- Julia's package manager
- Digging deeper into the standard library
- The Standard Library and Packages
- Summary
- Tools to use
- Performance tips
- Calling Python
- Calling C and Fortran
- Pipelining
- Interpolation
- Running shell commands
- Running External Programs
- Summary
- Parallel loops and maps
- Using low-level communications
- Creating processes
- Parallel operations and computing
- Interacting with databases
- Working with TCP sockets and servers
- Other file formats
- Using DataFrames
- Reading and writing CSV files
- Working with files
- Basic input and output
- I/O Networking and Parallel Computing
- Summary
- Reflection capabilities
- Starting a task
- Benchmarking
- Debugging
- Testing
- Built-in macros
- Defining macros
- Evaluation and interpolation
- Expressions and symbols
- Metaprogramming in Julia
- Summary
- Standard modules and paths
- Parametric types and methods
- Type unions
- Types and collections – inner constructors
- A multiple-dispatch example
- When are two values or objects equal or identical?
- User-defined and composite types
- Concrete and abstract types
- The type hierarchy – subtypes and supertypes
- Type conversions and promotions
- Type annotations
- More on Types Methods and Modules
- Summary
- An example project – word frequency
- Sets
- Keys and values – looping
- Dictionaries
- Tuples
- Matrices
- Collection Types
- Summary
- Tasks
- Scope revisited
- Exception handling
- The continue statement
- The break statement
- while loops
- for loops
- Repeated evaluation
- Conditional evaluation
- Control Flow
- Summary
- Generic functions and multiple dispatch
- Map filter and list comprehensions
- Broadcasting
- functions
- First-class functions and closures
- Anonymous functions
- Optional and keyword arguments
- Defining functions
- Functions
- Summary
- Scope and constants
- Dates and times
- Some common functions for arrays
- Other ways to create arrays
- Ranges and arrays
- Regular expressions
- Formatting numbers and strings
- Strings
- Characters
- Rational and complex numbers
- Elementary mathematical functions and operations
- Floating point numbers
- Integers
- Types
- Variables naming conventions and comments
- Variables Types and Operations
- Summary
- How Julia works
- Other editors and IDEs
- Installing Sublime-IJulia
- Installing julia-vscode
- Installing Juno
- Installing and working with IJulia
- Adding a new package
- Packages
- Startup options and Julia scripts
- Working with Julia's REPL
- JuliaPro
- Building from source
- Linux OS
- OS X
- Windows OS
- Installing Julia
- Installing the Julia Platform
- Reviews
- Get in touch
- Conventions used
- Download the color images
- Download the example code files
- To get the most out of this book
- What this book covers
- Who this book is for
- Preface
- Packt is searching for authors like you
- About the authors
- Contributors
- Packt.com
- Why subscribe?
- About Packt
- Julia 1.0 Programming Complete Reference Guide
- Copyright and Credits
- Title Page
- coverpage
- coverpage
- Title Page
- Copyright and Credits
- 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 更新時間：2021-06-24 14:22:37
