top

  Info

  • Utilizzare la checkbox di selezione a fianco di ciascun documento per attivare le funzionalità di stampa, invio email, download nei formati disponibili del (i) record.

  Info

  • Utilizzare questo link per rimuovere la selezione effettuata.

Biblioteca

MARC Lista (tabellare)
Azure Kubernetes services with microservices : understanding its patterns and architecture / / Kasam Ahmed Shaikh, Shailesh S. Agaskar
Azure Kubernetes services with microservices : understanding its patterns and architecture / / Kasam Ahmed Shaikh, Shailesh S. Agaskar
Autore Shaikh Kasam
Pubbl/distr/stampa New York, New York : , : Apress L. P., , [2022]
Descrizione fisica 1 online resource (257 pages)
Disciplina 004.654
Soggetto topico Service-oriented architecture (Computer science)
ISBN 1-4842-7809-7
Formato Materiale a stampa
Livello bibliografico Monografia
Lingua di pubblicazione eng
Nota di contenuto Chapter 1: Introduction to Microservices & AKS -- Chapter 2: Microservices Architecting & Design Considerations -- Chapter 3: Microservices Design Patterns -- Chapter 4: Containers & Azure Kubernetes Services -- Chapter 5: Things you should know -- Securing and Monitoring application running on AKS -- Chapter 6: CI/CD for AKS.
Record Nr. UNINA-9910523001603321
Shaikh Kasam  
New York, New York : , : Apress L. P., , [2022]
Materiale a stampa
Lo trovi qui: Univ. Federico II
Opac: Controlla la disponibilità qui
Beginning deep learning with TensorFlow : work with Keras, MNIST data sets, and advanced neural networks / / Liangqu Long, Xiangming Zeng
Beginning deep learning with TensorFlow : work with Keras, MNIST data sets, and advanced neural networks / / Liangqu Long, Xiangming Zeng
Autore Long Liangqu
Pubbl/distr/stampa New York, New York : , : Apress L. P., , [2022]
Descrizione fisica 1 online resource (727 pages)
Disciplina 006.31
Soggetto topico Machine learning
ISBN 1-5231-5104-8
1-4842-7915-8
Formato Materiale a stampa
Livello bibliografico Monografia
Lingua di pubblicazione eng
Nota di contenuto Intro -- Table of Contents -- About the Authors -- About the Technical Reviewer -- Acknowledgments -- Chapter 1: Introduction to Artificial Intelligence -- 1.1 Artificial Intelligence in Action -- 1.1.1 Artificial Intelligence Explained -- 1.1.2 Machine Learning -- 1.1.3 Neural Networks and Deep Learning -- 1.2 The History of Neural Networks -- 1.2.1 Shallow Neural Networks -- 1.2.2 Deep Learning -- 1.3 Deep Learning Characteristics -- 1.3.1 Data Volume -- 1.3.2 Computing Power -- 1.3.3 Network Scale -- 1.3.4 General Intelligence -- 1.4 Deep Learning Applications -- 1.4.1 Computer Vision -- 1.4.2 Natural Language Processing -- 1.4.3 Reinforcement Learning -- 1.5 Deep Learning Framework -- 1.5.1 Major Frameworks -- 1.5.2 TensorFlow 2 and 1.x -- 1.5.3 Demo -- 1.6 Development Environment Installation -- 1.6.1 Anaconda Installation -- 1.6.2 CUDA Installation -- 1.6.3 TensorFlow Installation -- 1.6.4 Common Editor Installation -- 1.7 Summary -- 1.8 Reference -- Chapter 2: Regression -- 2.1 Neuron Model -- 2.2 Optimization Method -- 2.3 Linear Model in Action -- 2.4 Summary -- 2.5 References -- Chapter 3: Classification -- 3.1 Handwritten Digital Picture Dataset -- 3.2 Build a Model -- 3.3 Error Calculation -- 3.4 Do We Really Solve the Problem? -- 3.5 Nonlinear Model -- 3.6 Model Complexity -- 3.7 Optimization Method -- 3.8 Hands-On Handwritten Digital Image Recognition -- 3.8.1 Build the Network -- 3.8.2 Model Training -- 3.9 Summary -- 3.10 Reference -- Chapter 4: Basic TensorFlow -- 4.1 Data Types -- 4.1.1 Numeric -- 4.1.2 String -- 4.1.3 Boolean -- 4.2 Numerical Precision -- 4.3 Tensors to Be Optimized -- 4.4 Create Tensors -- 4.4.1 Create Tensors from Arrays and Lists -- 4.4.2 Create All-0 or All-1 Tensors -- 4.4.3 Create a Customized Numeric Tensor -- 4.4.4 Create a Tensor from a Known Distribution -- 4.4.5 Create a Sequence.
4.5 Typical Applications of Tensors -- 4.5.1 Scalar -- 4.5.2 Vector -- 4.5.3 Matrix -- 4.5.4 Three-Dimensional Tensor -- 4.5.5 Four-Dimensional Tensor -- 4.6 Indexing and Slicing -- 4.6.1 Indexing -- 4.6.2 Slicing -- 4.6.3 Slicing Summary -- 4.7 Dimensional Transformation -- 4.7.1 Reshape -- 4.7.2 Add and Delete Dimensions -- 4.7.3 Swap Dimensions -- 4.7.4 Copy Data -- 4.8 Broadcasting -- 4.9 Mathematical Operations -- 4.9.1 Addition, Subtraction, Multiplication and Division -- 4.9.2 Power Operations -- 4.9.3 Exponential and Logarithmic Operations -- 4.9.4 Matrix Multiplication -- 4.10 Hands-On Forward Propagation -- Chapter 5: Advanced TensorFlow -- 5.1 Merge and Split -- 5.1.1 Merge -- 5.1.2 Split -- 5.2 Common Statistics -- 5.2.1 Norm -- 5.2.2 Max, Min, Mean, and Sum -- 5.3 Tensor Comparison -- 5.4 Fill and Copy -- 5.4.1 Fill -- 5.4.2 Copy -- 5.5 Data Limiting -- 5.6 Advanced Operations -- 5.6.1 tf.gather -- 5.6.2 tf.gather_nd -- 5.6.3 tf.boolean_mask -- 5.6.4 tf.where -- 5.6.5 tf.scatter_nd -- 5.6.6 tf.meshgrid -- 5.7 Load Classic Datasets -- 5.7.1 Shuffling -- 5.7.2 Batch Training -- 5.7.3 Preprocessing -- 5.7.4 Epoch Training -- 5.8 Hands-On MNIST Dataset -- Chapter 6: Neural Networks -- 6.1 Perceptron -- 6.2 Fully Connected Layer -- 6.2.1 Tensor Mode Implementation -- 6.2.2 Layer Implementation -- 6.3 Neural Network -- 6.3.1 Tensor Mode Implementation -- 6.3.2 Layer Mode Implementation -- 6.3.3 Optimization -- 6.4 Activation function -- 6.4.1 Sigmoid -- 6.4.2 ReLU -- 6.4.3 LeakyReLU -- 6.4.4 Tanh -- 6.5 Design of Output Layer -- 6.5.1 Common Real Number Space -- 6.5.2 [0, 1] Interval -- 6.5.3 [0,1] Interval with Sum 1 -- 6.5.4 (-1, 1) Interval -- 6.6 Error Calculation -- 6.6.1 Mean Square Error Function -- 6.6.2 Cross-Entropy Error Function -- 6.7 Types of Neural Networks -- 6.7.1 Convolutional Neural Network -- 6.7.2 Recurrent Neural Network.
6.7.3 Attention Mechanism Network -- 6.7.4 Graph Convolutional Neural Network -- 6.8 Hands-On of Automobile Fuel Consumption Prediction -- 6.8.1 Dataset -- 6.8.2 Create a Network -- 6.8.3 Training and Testing -- 6.9 References -- Chapter 7: Backward Propagation Algorithm -- 7.1 Derivatives and Gradients -- 7.2 Common Properties of Derivatives -- 7.2.1 Common Derivatives -- 7.2.2 Common Property of Derivatives -- 7.2.3 Hands-On Derivative Finding -- 7.3 Derivative of Activation Function -- 7.3.1 Derivative of Sigmoid Function -- 7.3.2 Derivative of ReLU Function -- 7.3.3 Derivative of LeakyReLU Function -- 7.3.4 Derivative of Tanh Function -- 7.4 Gradient of Loss Function -- 7.4.1 Gradient of Mean Square Error Function -- 7.4.2 Gradient of Cross-Entropy Function -- 7.5 Gradient of Fully Connected Layer -- 7.5.1 Gradient of a Single Neuron -- 7.5.2 Gradient of Fully Connected Layer -- 7.6 Chain Rule -- 7.7 Back Propagation Algorithm -- 7.8 Hands-On Optimization of Himmelblau -- 7.9 Hands-On Back Propagation Algorithm -- 7.9.1 Dataset -- 7.9.2 Network Layer -- 7.9.3 Network model -- 7.9.4 Network Training -- 7.9.5 Network Performance -- 7.10 References -- Chapter 8: Keras Advanced API -- 8.1 Common Functional Modules -- 8.1.1 Common Network Layer Classes -- 8.1.2 Network Container -- 8.2 Model Configuration, Training, and Testing -- 8.2.1 Model Configuration -- 8.2.2 Model Training -- 8.2.3 Model Testing -- 8.3 Model Saving and Loading -- 8.3.1 Tensor Method -- 8.3.2 Network Method -- 8.3.3 SavedModel method -- 8.4 Custom Network -- 8.4.1 Custom Network Layer -- 8.4.2 Customized Network -- 8.5 Model Zoo -- 8.5.1 Load Model -- 8.6 Metrics -- 8.6.1 Create a Metrics Container -- 8.6.2 Write Data -- 8.6.3 Read Statistical Data -- 8.6.4 Clear the Container -- 8.6.5 Hands-On Accuracy Metric -- 8.7 Visualization -- 8.7.1 Model Side -- 8.7.2 Browser Side.
8.8 Summary -- Chapter 9: Overfitting -- 9.1 Model Capacity -- 9.2 Overfitting and Underfitting -- 9.2.1 Underfitting -- 9.2.2 Overfitting -- 9.3 Dataset Division -- 9.3.1 Validation Set and Hyperparameters -- 9.3.2 Early Stopping -- 9.4 Model Design -- 9.5 Regularization -- 9.5.1 L0 Regularization -- 9.5.2 L1 Regularization -- 9.5.3 L2 Regularization -- 9.5.4 Regularization Effect -- 9.6 Dropout -- 9.7 Data Augmentation -- 9.7.1 Rotation -- 9.7.2 Flip -- 9.7.3 Cropping -- 9.7.4 Generate Data -- 9.7.5 Other Methods -- 9.8 Hands-On Overfitting -- 9.8.1 Build the Dataset -- 9.8.2 Influence of the Number of Network Layers -- 9.8.3 Impact of Dropout -- 9.8.4 Impact of Regularization -- 9.9 References -- Chapter 10: Convolutional Neural Networks -- 10.1 Problems with Fully Connected N -- 10.1.1 Local Correlation -- 10.1.2 Weight Sharing -- 10.1.3 Convolution Operation -- 10.2 Convolutional Neural Network -- 10.2.1 Single-Channel Input and Single Convolution Kernel -- 10.2.2 Multi-channel Input and Single Convolution Kernel -- 10.2.3 Multi-channel Input and Multi-convolution Kernel -- 10.2.4 Stride Size -- 10.2.5 Padding -- 10.3 Convolutional Layer Implementation -- 10.3.1 Custom Weights -- 10.3.2 Convolutional Layer Classes -- 10.4 Hands-On LeNet-5 -- 10.5 Representation Learning -- 10.6 Gradient Propagation -- 10.7 Pooling Layer -- 10.8 BatchNorm Layer -- 10.8.1 Forward Propagation -- 10.8.2 Backward Propagation -- 10.8.3 Implementation of BatchNormalization layer -- 10.9 Classical Convolutional Network -- 10.9.1 AlexNet -- 10.9.2 VGG Series -- 10.9.3 GoogLeNet -- 10.10 Hands-On CIFAR10 and VGG13 -- 10.11 Convolutional Layer Variants -- 10.11.1 Dilated/Atrous Convolution -- 10.11.2 Transposed Convolution -- o + 2p − k = n * s -- o + 2p − k ≠n * s -- Matrix Transposition -- Transposed Convolution Implementation -- 10.11.3 Separate Convolution.
10.12 Deep Residual Network -- 10.12.1 ResNet Principle -- 10.12.2 ResBlock Implementation -- 10.13 DenseNet -- 10.14 Hands-On CIFAR10 and ResNet18 -- 10.15 References -- Chapter 11: Recurrent Neural Network -- 11.1 Sequence Representation Method -- 11.1.1 Embedding Layer -- 11.1.2 Pre-trained Word Vectors -- 11.2 Recurrent Neural Network -- 11.2.1 Is a Fully Connected Layer Feasible? -- 11.2.2 Shared Weight -- 11.2.3 Global Semantics -- 11.2.4 Recurrent Neural Network -- 11.3 Gradient Propagation -- 11.4 How to Use RNN Layers -- 11.4.1 SimpleRNNCell -- 11.4.2 Multilayer SimpleRNNCell Network -- 11.4.3 SimpleRNN Layer -- 11.5 Hands-On RNN Sentiment Classification -- 11.5.1 Dataset -- 11.5.2 Network Model -- 11.5.3 Training and Testing -- 11.6 Gradient Vanishing and Gradient Exploding -- 11.6.1 Gradient Clipping -- 11.6.2 Gradient Vanishing -- 11.7 RNN Short-Term Memory -- 11.8 LSTM Principle -- 11.8.1 Forget Gate -- 11.8.2 Input Gate -- 11.8.3 Update Memory -- 11.8.4 Output Gate -- 11.8.5 Summary -- 11.9 How to Use the LSTM Layer -- 11.9.1 LSTMCell -- 11.9.2 LSTM layer -- 11.10 GRU Introduction -- 11.10.1 Reset Door -- 11.10.2 Update Gate -- 11.10.3 How to Use GRU -- 11.11 Hands-On LSTM/GRU Sentiment Classification -- 11.11.1 LSTM Model -- 11.11.2 GRU model -- 11.12 Pre-trained Word Vectors -- 11.13 Pre-trained Word Vectors -- 11.14 References -- Chapter 12: Autoencoder -- 12.1 Principle of Autoencoder -- 12.2 Hands-On Fashion MNIST Image Reconstruction -- 12.2.1 Fashion MNIST Dataset -- 12.2.2 Encoder -- 12.2.3 Decoder -- 12.2.4 Autoencoder -- 12.2.5 Network Training -- 12.2.6 Image Reconstruction -- 12.3 Autoencoder Variants -- 12.3.1 Dropout Autoencoder -- 12.3.2 Adversarial Autoencoder -- 12.4 Variational Autoencoder -- 12.4.1 Principle of VAE -- 12.4.2 Reparameterization Trick -- 12.5 Hands-On VAE Image Reconstruction -- 12.5.1 VAE model.
12.5.2 Reparameterization Trick.
Record Nr. UNINA-9910522921003321
Long Liangqu  
New York, New York : , : Apress L. P., , [2022]
Materiale a stampa
Lo trovi qui: Univ. Federico II
Opac: Controlla la disponibilità qui
Beginning Hibernate 6 : Java Persistence from Beginner to Pro
Beginning Hibernate 6 : Java Persistence from Beginner to Pro
Autore Ottinger Joseph B
Edizione [5th ed.]
Pubbl/distr/stampa Berkeley, CA : , : Apress L. P., , 2021
Descrizione fisica 1 online resource (495 pages)
Disciplina 005.71262
Altri autori (Persone) LinwoodJeff
MinterDave
Soggetto genere / forma Electronic books.
ISBN 1-4842-7337-0
Formato Materiale a stampa
Livello bibliografico Monografia
Lingua di pubblicazione eng
Nota di contenuto Intro -- Table of Contents -- About the Authors -- About the Technical Reviewer -- Acknowledgments -- Introduction -- Chapter 1: An Introduction to Hibernate 6 -- Plain Old Java Objects (POJOs) -- Building a Project -- Hibernate As a Persistence Solution -- Summary -- Chapter 2: Integrating and Configuring Hibernate -- The Steps Needed to Integrate and Configure Hibernate -- Understanding Where Hibernate Fits into Your Java Application -- Deploying Hibernate -- Installing Maven -- Connection Pooling -- Using JNDI -- Summary -- Chapter 3: Building a Simple Application -- A Simple Application -- Relationships and Cardinality -- A First Attempt -- Writing Data -- Rounding Out the Data Model -- Reading Data -- Updating Data -- Persistence Contexts -- Removing Data -- A Note on Transactions -- The Full Test for Rankings -- Writing Our Sample Application -- Add a Ranking -- Update a Ranking -- Remove a Ranking -- Find Average Ranking for a Subject's Skill -- Find All Rankings for a Subject -- Find the Highest-Ranked Subject for a Skill -- Putting It All Together -- Summary -- Chapter 4: The Persistence LifeCycle -- Introducing the Lifecycle -- Entities, Classes, and Names -- Identifiers -- Entities and Associations -- Saving Entities -- Object Equality and Identity -- Loading Entities -- Merging Entities -- Refreshing Entities -- Updating Entities -- Deleting Entities -- Cascading Operations -- Lazy Loading, Proxies, and Collection Wrappers -- Querying Objects -- Summary -- Chapter 5: An Overview of Mapping -- Why Mapping Cannot Easily Be Automated -- Primary Keys -- Lazy Loading -- Associations -- The One-to-One Association -- The One-to-Many and Many-to-One Associations -- The Many-to-Many Association -- Applying Mappings to Associations -- Other Supported Features -- Specification of (Database) Column Types and Sizes.
The Mapping of Inheritance Relationships to the Database -- Primary Key -- The Use of SQL Formula-Based Properties -- Mandatory and Unique Constraints -- Summary -- Chapter 6: Mapping with Annotations -- Creating Hibernate Mappings with Annotations -- The Drawbacks of Annotations -- The Benefits of Annotations -- Choosing Which Mapping Mechanism to Use -- JPA 2 Persistence Annotations -- Entity Beans with @Entity -- Primary Keys with @Id and @GeneratedValue -- Generating Primary Key Values with @SequenceGenerator -- Generating Primary Key Values with @TableGenerator -- Compound Primary Keys with @Id, @IdClass, or @EmbeddedId -- Database Table Mapping with @Table and  @SecondaryTable -- Persisting Basic Types with @Basic -- Omitting Persistence with @Transient -- Mapping Properties and Fields with @Column -- Modeling Entity Relationships -- Mapping an Embedded (Component) One-to-One Association -- Mapping a Conventional One-to-One Association -- Mapping a Many-to-One or One-to-Many Association -- Mapping a Many-to-Many Association -- Cascading Operations -- Collection Ordering -- Inheritance -- Single Table -- Joined Table -- Table per Class -- Choosing Between Inheritance Types When Modeling Inheritance -- Other JPA 2 Persistence Annotations -- Temporal Data -- Element Collections -- Large Objects -- Mapped Superclasses -- Ordering Collections with @OrderColumn -- Named Queries (HQL or JPQL) -- Named Native Queries (SQL) -- Configuring the Annotated Classes -- Hibernate-Specific Persistence Annotations -- @Immutable -- Natural IDs -- Summary -- Chapter 7: JPA Integration and Lifecycle Events -- The Java Persistence API -- The Project Object Model -- Introducing Lombok -- The JPASessionUtil Class -- Testing JPASessionUtil -- Lifecycle Events -- External Entity Listeners -- Data Validation -- Summary -- Chapter 8: Using the Session -- Sessions.
Transactions and Locking -- Transactions -- The ACID Tests -- Locking -- Deadlocks -- Caching -- Threads -- Summary -- Chapter 9: Searches and Queries -- Hibernate Query Language (HQL) -- Syntax Basics -- UPDATE -- DELETE -- INSERT -- SELECT -- Named Queries -- Logging and Commenting the Underlying SQL -- Logging the SQL -- Commenting the Generated SQL -- The from Clause and Aliases -- The select Clause and Projection -- Using Restrictions with HQL -- Using Named Parameters -- Paging Through the Result Set -- Obtaining a Unique Result -- Sorting Results with the order by Clause -- Associations and Joins -- Aggregate Methods -- Bulk Updates and Deletes with HQL -- Using Native SQL -- Summary -- Chapter 10: Filtering the Results of Searches -- When to Use Filters -- Getting Started -- Defining and Attaching Filters -- Filters with Annotations -- Filters with XML Mapping Documents -- Using Filters in Your Application -- A Basic Filtering Example -- Summary -- Chapter 11: Integration into the Web -- Setting the Stage -- The Plan -- The Application -- The Project Model -- The Data Model -- Building Our First Servlet Test -- Our First (Wrong) Servlet: Adding a User -- The AddUserServlet, Corrected -- Where DTOs Shine -- Rounding Out the Application -- Creating a Post -- A Better "Get Posts" Servlet -- Rounding Out the "Application" -- Summary -- Chapter 12: Integrating Hibernate -- Spring -- Spring Data with Spring Boot -- ActiveJ -- Quarkus -- Summary -- Chapter 13: Hibernate Envers -- What Does a "Version" Mean? -- Creating a Simple Project -- Looking for Revisions with Specific Data -- An Example Reverting Data -- Summary -- Index.
Record Nr. UNINA-9910506385103321
Ottinger Joseph B  
Berkeley, CA : , : Apress L. P., , 2021
Materiale a stampa
Lo trovi qui: Univ. Federico II
Opac: Controlla la disponibilità qui
Beginning IntelliJ IDEA : Integrated Development Environment for Java Programming
Beginning IntelliJ IDEA : Integrated Development Environment for Java Programming
Autore Hagos Ted
Pubbl/distr/stampa Berkeley, CA : , : Apress L. P., , 2021
Descrizione fisica 1 online resource (283 pages)
Soggetto genere / forma Electronic books.
ISBN 9781484274460
9781484274453
Formato Materiale a stampa
Livello bibliografico Monografia
Lingua di pubblicazione eng
Record Nr. UNINA-9910510545303321
Hagos Ted  
Berkeley, CA : , : Apress L. P., , 2021
Materiale a stampa
Lo trovi qui: Univ. Federico II
Opac: Controlla la disponibilità qui
Beginning iPhone development with SwiftUI : exploring the iOS SDK / / Wally Wang
Beginning iPhone development with SwiftUI : exploring the iOS SDK / / Wally Wang
Autore Wang Wally
Edizione [Sixth edition.]
Pubbl/distr/stampa Berkeley, California : , : Apress L. P., , [2022]
Descrizione fisica 1 online resource (468 pages)
Disciplina 004.165
Soggetto topico Operating systems (Computers)
Apple computer
ISBN 1-4842-7818-6
Formato Materiale a stampa
Livello bibliografico Monografia
Lingua di pubblicazione eng
Nota di contenuto Chapter 1: Understanding iOS Programming -- Chapter 2: Designing User Interfaces with SwiftUI -- Chapter 3: Placing Views on the User Interface -- Chapter 4: Working with Text -- Chapter 5: Working with Images -- Chapter 6: Responding to the User with Buttons and Segmented Controls -- Chapter 7: Retrieving Text from Text Fields and Text Editors -- Chapter 8: Limiting Choices with Pickers -- Chapter 9: Limiting Choices with Toggles, Steppers, and Sliders -- Chapter 10: Providing Options with Links and Menus -- Chapter 11: Touch Gestures -- Chapter 12: Using Alerts, Action Sheets, and Contextual Menus -- Chapter 13: Displaying Lists -- Chapter 14: Using Forms and Group Boxes -- Chapter 15: Using Disclosure Groups, Scroll Views, and Outline Groups -- Chapter 16: Using the Navigation View -- Chapter 17: Using the Tab View -- Chapter 18: Using Grids -- Chapter 19: Using Animation -- Chapter 20: Using GeometryReader -- Appendix: An Introduction to Swift.
Record Nr. UNINA-9910522991203321
Wang Wally  
Berkeley, California : , : Apress L. P., , [2022]
Materiale a stampa
Lo trovi qui: Univ. Federico II
Opac: Controlla la disponibilità qui
Beginning Java 17 Fundamentals : Object-Oriented Programming in Java 17
Beginning Java 17 Fundamentals : Object-Oriented Programming in Java 17
Autore Sharan Kishori
Edizione [3rd ed.]
Pubbl/distr/stampa Berkeley, CA : , : Apress L. P., , 2021
Descrizione fisica 1 online resource (1023 pages)
Altri autori (Persone) DavisAdam L
Soggetto genere / forma Electronic books.
ISBN 9781484273074
9781484273067
Formato Materiale a stampa
Livello bibliografico Monografia
Lingua di pubblicazione eng
Nota di contenuto Intro -- Table of Contents -- About the Authors -- About the Technical Reviewer -- Acknowledgments -- Introduction -- Chapter 1: Programming Concepts -- What Is Programming? -- Components of a Programming Language -- Programming Paradigms -- Imperative Paradigm -- Procedural Paradigm -- Declarative Paradigm -- Functional Paradigm -- Logic Paradigm -- Object-Oriented Paradigm -- What Is Java? -- The Object-Oriented Paradigm and Java -- Abstraction -- Abstraction for Hiding Complexities -- Data Abstraction -- Encapsulation and Information Hiding -- Inheritance -- Polymorphism -- Overloading Polymorphism -- Coercion Polymorphism -- Inclusion Polymorphism -- Parametric Polymorphism -- Summary -- Chapter 2: Setting Up the Environment -- System Requirements -- Installing JDK 17 -- The JDK Directory Structure -- Verifying the JDK Installation -- Starting the JShell Tool -- Installing NetBeans 12 -- Configuring NetBeans -- Summary -- Chapter 3: Writing Java Programs -- The Goal Statement -- Using the JShell Tool -- What Is a Java Program? -- Writing the Source Code -- Writing Comments -- Declaring a Module -- Declaring Types -- Package Declaration -- Import Declarations -- Class Declaration -- Types Have Two Names -- Compiling the Source Code -- Packaging the Compiled Code -- Running a Java Program -- Playing with Module Options -- Listing Observable Modules -- Limiting the Observable Modules -- Describing a Module -- Printing Module Resolution Details -- Dry-Running Your Program -- Enhancing a Module Descriptor -- Running Java Programs in Legacy Mode -- Duplicate Modules on a Module Path -- Syntax for Command-Line Options -- Writing Java Programs Using the NetBeans IDE -- Creating a Java Project -- Creating Modular JARs in NetBeans -- NetBeans Project Directory Structure -- Adding Classes to a Module -- Customizing NetBeans Project Properties.
Opening an Existing NetBeans Project -- Behind the Scenes -- Summary -- Chapter 4: Data Types -- What Is a Data Type -- What Is an Identifier? -- Keywords -- Data Types in Java -- Local Variable Type Inference -- Primitive Data Types in Java -- Integral Data Types -- The int Data Type -- The long Data Type -- The byte Data Type -- The short Data Type -- The char Data Type -- Character Literals in Single Quotes -- Character Escape Sequence -- Unicode Character Escape Sequence -- Octal Character Escape Sequence -- The boolean Data Type -- Floating-Point Data Types -- The float Data Type -- The double Data Type -- Underscores in Numeric Literals -- Java Compiler and Unicode Escape Sequence -- A Short Break -- Binary Representation of Integers -- Diminished Radix Complement -- Radix Complement -- Binary Representation of Floating-Point Numbers -- 32-Bit Single-Precision Floating-Point Format -- Sign -- Exponent -- Significand -- Special Floating-Point Numbers -- Signed Zeros -- Signed Infinities -- NaN -- Denormals -- Rounding Modes -- Rounding Toward Zero -- Rounding Toward Positive Infinity -- Rounding Toward Negative Infinity -- Rounding Toward Nearest -- IEEE Floating-Point Exceptions -- Division by Zero Exception -- Invalid Operation Exception -- Overflow Exception -- Underflow Exception -- Inexact Exception -- Java and IEEE Floating-Point Standards -- Little-Endian and Big-Endian -- Summary -- Chapter 5: Operators -- What Is an Operator? -- Assignment Operator -- Declaration, Initialization, and Assignment -- Arithmetic Operators -- Addition Operator (+) -- Subtraction Operator (-) -- Multiplication Operator (*) -- Division Operator (/) -- Modulus Operator (%) -- Rule #1 -- Rule #2 -- Rule #1 -- Rule #2 -- Rule #3 -- Rule #4 -- Rule #5 -- Unary Plus Operator (+) -- Unary Minus Operator (-) -- Compound Arithmetic Assignment Operators.
Increment (++) and Decrement (--) Operators -- String Concatenation Operator (+) -- Relational Operators -- Equality Operator (==) -- Rule #1 -- Rule #2 -- Rule #3 -- Inequality Operator (!=) -- Greater Than Operator (> -- ) -- Greater Than or Equal to Operator (> -- =) -- Less Than Operator (< -- ) -- Less Than or Equal to Operator (< -- =) -- Boolean Logical Operators -- Logical NOT Operator (!) -- Logical Short-Circuit AND Operator (& -- & -- ) -- Logical AND Operator (& -- ) -- Logical Short-Circuit OR Operator (||) -- Logical OR Operator (|) -- Logical XOR Operator (^) -- Compound Boolean Logical Assignment Operators -- Ternary Operator (?:) -- Bitwise Operators -- Operator Precedence -- Summary -- Chapter 6: Statements -- What Is a Statement? -- Types of Statements -- Declaration Statement -- Expression Statement -- Control Flow Statement -- A Block Statement -- The if-else Statement -- The switch Statement -- The switch Expression -- The for Statement -- Initialization -- Condition Expression -- Expression List -- The for-each Statement -- The while Statement -- The do-while Statement -- The break Statement -- The continue Statement -- An Empty Statement -- Summary -- Chapter 7: Classes -- What Is a Class? -- Declaring a Class -- Declaring Fields in a Class -- Creating Instances of a Class -- The null Reference Type -- Using Dot Notation to Access Fields of a Class -- Default Initialization of Fields -- Access Level Modifiers for a Class -- Import Declarations -- Single-Type Import Declaration -- Import-on-Demand Declaration -- Import Declarations and Type Search Order -- Automatic Import Declarations -- Static Import Declarations -- Static Import Rule #1 -- Static Import Rule #2 -- Static Import Rule #3 -- Declaring a Record -- Summary -- Chapter 8: Methods -- What Is a Method? -- Declaring Methods of a Class.
Local Variables -- Rule #1 -- Rule #2 -- Rule #3 -- Rule #4 -- Instance Methods and Class Methods -- Invoking a Method -- The Special main() Method -- What Is this? -- Access Levels for Class Members -- Access Level: A Case Study -- What Is a Var-Args Method? -- Overloading a Var-Args Method -- Var-Args Methods and the main() Method -- Parameter-Passing Mechanisms -- Pass by Value -- Pass by Constant Value -- Pass by Reference -- Pass by Reference Value -- Pass by Constant Reference Value -- Pass by Result -- Pass by Value Result -- Pass by Name -- Pass by Need -- Parameter-Passing Mechanisms in Java -- Summary -- Chapter 9: Constructors -- What Is a Constructor? -- Declaring a Constructor -- Overloading a Constructor -- Writing Code for a Constructor -- Calling a Constructor from Another Constructor -- Using a return Statement Inside a Constructor -- Access Level Modifier for a Constructor -- Default Constructor -- A static Constructor -- Instance Initialization Block -- Static Initialization Block -- The final Keyword -- final Local Variables -- final Parameters -- final Instance Variables -- final Class Variables -- final Reference Variables -- Compile-Time vs. Runtime final Variables -- Generic Classes -- Summary -- Chapter 10: Modules -- What Is a Module? -- Declaring Modules -- Declaring Module Dependence -- An Example of Module Dependence -- Troubleshooting -- Empty Package Error -- Module Not Found Error -- Package Does Not Exist Error -- Module Resolution Exception -- Implicit Dependence -- Optional Dependence -- Opening Modules and Packages -- Open Modules -- Opening Packages -- Splitting Packages Across Modules -- Restrictions in Module Declarations -- Types of Modules -- Normal Modules -- Open Modules -- Automatic Modules -- Unnamed Modules -- Aggregator Modules -- Knowing About Modules at Runtime -- Migration Path to Modules.
Java Class Dependency Analyzer -- Disassembling Module Definitions -- Summary -- Chapter 11: Object and Objects Classes -- The Object Class -- Rule #1 -- Rule #2 -- What Is the Class of an Object? -- Computing the Hash Code of an Object -- Comparing Objects for Equality -- String Representation of an Object -- Cloning Objects -- Finalizing an Object -- Immutable Objects -- The Objects Class -- Bounds Checks -- Comparing Objects -- Computing Hash Code -- Checking for Null -- Validating Arguments -- Obtaining String Representation of Objects -- Using the Objects Class -- Summary -- Chapter 12: Wrapper Classes -- Wrapper Classes -- Numeric Wrapper Classes -- The Character Wrapper Class -- The Boolean Wrapper Class -- Unsigned Numeric Operations -- Autoboxing and Unboxing -- Beware of Null Values -- Overloaded Methods and Autoboxing/Unboxing -- Comparison Operators and Autoboxing/Unboxing -- Collections and Autoboxing/Unboxing -- Summary -- Chapter 13: Exception Handling -- What Is an Exception? -- An Exception Is an Object -- Using a try-catch Block -- Transfer of Control -- Exception Class Hierarchy -- Arranging Multiple catch Blocks -- A Multi-catch Block -- Checked and Unchecked Exceptions -- Checked Exception: Catch or Declare -- Checked Exceptions and Initializers -- Throwing an Exception -- Creating an Exception Class -- The finally Block -- Rethrowing an Exception -- Analysis of Rethrown Exceptions -- Throwing Too Many Exceptions -- Accessing the Stack of a Thread -- The try-with-resources Block -- Summary -- Chapter 14: Assertions -- What Is an Assertion? -- Testing Assertions -- Enabling/Disabling Assertions -- Using Assertions -- Checking for Assertion Status -- Summary -- Chapter 15: Strings -- What Is a String? -- String Literals -- Escape Sequence Characters in String Literals -- Unicode Escapes in String Literals -- What Is a CharSequence?.
Creating String Objects.
Record Nr. UNINA-9910510557103321
Sharan Kishori  
Berkeley, CA : , : Apress L. P., , 2021
Materiale a stampa
Lo trovi qui: Univ. Federico II
Opac: Controlla la disponibilità qui
Beginning JOOQ : Learn to Write Efficient and Effective Java-Based SQL Database Operations
Beginning JOOQ : Learn to Write Efficient and Effective Java-Based SQL Database Operations
Autore Koleoso Tayo
Pubbl/distr/stampa Berkeley, CA : , : Apress L. P., , 2021
Descrizione fisica 1 online resource (221 pages)
Soggetto genere / forma Electronic books.
ISBN 1-4842-7431-8
Formato Materiale a stampa
Livello bibliografico Monografia
Lingua di pubblicazione eng
Nota di contenuto Intro -- Table of Contents -- About the Author -- About the Technical Reviewer -- Chapter 1: Welcome to jOOQ -- Database Operations in Java: The Good Parts -- Database Operations in Java: The…Not So Good Parts -- You Have Got to Be jOOQing -- jOOQ Feature Tour -- Database Aware -- Code Generation -- Type Safety -- Domain-Specific Language -- Tooling Support -- JVM Languages -- Chapter 2: Getting Started with jOOQ -- Eden Auto Mart -- Setting Up jOOQ -- Install Dependencies for Commercial-Licensed jOOQ -- CRUD with jOOQ -- Your SQL Dialect and You -- Tools of CRUD in jOOQ -- Select Statements -- The SELECT DSL -- With the WHERE DSL -- Conditions -- Subqueries -- Conditional Logic in Queries -- With the… WITH Clause -- With the GROUP BY DSL -- With the HAVING DSL -- With the ORDER BY DSL -- ORDER BY CASE -- ORDER BY NULL -- Paginate Query Results -- Insert Statements -- With Multiple Rows -- With Sequences -- With Select -- Update Statements -- Delete Statements -- Tuple Syntax -- Alternative Data Access Modes -- Streaming Access -- Lazy Access -- Transactions -- With Locking -- Configuration -- Connection Management -- Schema, Catalog, and Multi-tenant Deployment -- Query Management -- Query Lifecycle Integration -- Chapter 3: Working with jOOQ -- Generating Code -- Tools of jOOQ Code Generation -- Configure jOOQ for Code Generation -- Generate Code with Maven -- Generate Code from the Command Line -- Generate Code Programmatically -- Results of Code Generation -- Tables -- Global Artifacts -- Add Custom Code to Generated Code -- Working with Generated Code -- CRUD with Generated Code -- Enhancements from UpdatableRecord -- Formatting -- Optimistic Locking -- Advanced Database Operations -- Joins -- Non-SQL Grouping -- Batch Operations -- Explicit Batching -- Batch Import -- Advanced Query Syntax -- Merge and Upsert -- Window Functions.
Chapter 4: Integrating with jOOQ -- Java Persistence API with jOOQ -- Generate JPA Entities -- Generate from JPA Entities -- Generate SQL Queries -- Spring Boot and jOOQ -- Configure jOOQ in Spring Boot -- With Custom SQL -- jOOQ Spring Boot Starter -- Quarkus and jOOQ -- Chapter 5: Packaging and Testing jOOQ -- Package Code with jOOQ -- When You Don't Need Code Generation -- When You Don't Have an Active Database Connection -- When Your Schema Needs to Incrementally Evolve -- Recipe for a Self-Sufficient Database Project -- Testing with jOOQ -- Tools of the (SQL) Testing Trade -- Unit Testing with jOOQ -- Using Mockito -- With SQL Parsing -- Integration Testing with Docker and TestContainers -- With Spring Boot -- Index.
Record Nr. UNINA-9910508462003321
Koleoso Tayo  
Berkeley, CA : , : Apress L. P., , 2021
Materiale a stampa
Lo trovi qui: Univ. Federico II
Opac: Controlla la disponibilità qui
Beginning Mathematica and Wolfram for Data Science : Applications in Data Analysis, Machine Learning, and Neural Networks
Beginning Mathematica and Wolfram for Data Science : Applications in Data Analysis, Machine Learning, and Neural Networks
Autore Villalobos Alva Jalil
Edizione [2nd ed.]
Pubbl/distr/stampa Berkeley, CA : , : Apress L. P., , 2024
Descrizione fisica 1 online resource (476 pages)
Disciplina 001.42
ISBN 9798868803482
9798868803475
Formato Materiale a stampa
Livello bibliografico Monografia
Lingua di pubblicazione eng
Nota di contenuto Intro -- Table of Contents -- About the Author -- About the Technical Reviewer -- Acknowledgments -- Introduction -- Chapter 1: Introduction to Mathematica -- Why Mathematica? -- The Wolfram Language -- Structure of Mathematica -- Design of Mathematica -- Mathematica Environment -- Notebook Interface -- Text Processing -- Palettes -- Notebook Style and Features -- Expression in Mathematica -- Assigning Values -- Built-in Functions -- Dates and Time -- Strings -- Basic Plotting -- Logical Operators and Infix Notation -- Algebraic Expressions -- Solving Algebraic Equations -- Using Wolfram Alpha Inside Mathematica -- Delayed and Immediate Expressions -- Improving Code -- Code Performance -- Handling Errors -- Debugging Techniques -- How Mathematica Works -- How Computations are Made (Form of Input) -- Searching for Assistance -- Notebook Security -- Summary -- Chapter 2: Data Manipulation -- Lists -- Types of Numbers -- Working with Digits -- A Few Mathematical Functions -- Numeric Function -- Lists of Objects -- List Representation -- Generating Lists -- Arrays of Data -- Nested Lists -- Vectors -- Matrixes -- Matrix Operations -- Restructuring a Matrix -- Manipulating Lists -- Retrieving Data -- Assigning or Removing Values -- Structuring List -- Criteria Selection -- Summary -- Chapter 3: Working with Data and Datasets -- Operations with Lists -- Arithmetic Operations to a List -- Addition and Subtraction -- Division and Multiplication -- Exponentiation -- Joining a List -- Applying Functions to a List -- Defining Own Functions -- Pure Functions -- Indexed Tables -- Tables with the Wolfram Language -- Associations -- Dataset Format -- Constructing Datasets -- Accessing Data in a Dataset -- Adding Values -- Dropping Values -- Filtering Values -- Applying Functions -- Functions by Column or Row -- Joining and Merging Datasets.
Customizing a Dataset -- Generalization of Hash Tables -- Summary -- Chapter 4: Import and Export -- Importing Files -- CSV and TSV Files -- XLSX Files -- JSON Files -- Web Data -- Semantic Import -- Quantities -- Datasets with Quantities -- Costume Import (Dealing with Large Datasets) -- Export -- Other Formats -- XLS and XLSX Formats -- JSON Formats -- Content File Objects -- Searching Files with Wolfram Language -- Connecting to External Services -- External Connections -- External Resources -- Database and File Operations (SQL) -- Summary -- Chapter 5: Data Visualization -- Basic Visualization -- 2D Plots -- Plotting Data -- Plotting Defined Functions -- Customizing Plots -- Adding Text to Charts -- Frame and Grids -- Filled Plots -- Filling Patterns and Gradient -- Combining Plots -- Multiple Plots -- Multiaxis Plots -- Coloring Plot Grids -- Colors Palette -- 3D Plots -- Customizing 3D Plots -- Hue Color Function and List3D -- Contour Plots -- 3D Plots and 2D Projections -- Plot Themes -- Summary -- Chapter 6: Statistical Data Analysis -- Random Numbers -- Random Sampling -- Systematic Sampling -- Commons Statistical Measures -- Measures of Central Tendency -- Measures of Dispersion -- Statistical Charts -- Bar Charts -- Histograms -- Pie Charts and Sector Charts -- Box Plots -- Distribution Chart -- Charts Palette -- Ordinary Least Squares Method -- Pearson Coefficient -- Linear Fit -- Model Properties -- Summary -- Chapter 7: Data Exploration -- Wolfram Data Repository -- Wolfram Data Repository Website -- Selecting a Category -- Extracting Data from the Wolfram Data Repository -- Accessing Data Inside Mathematica -- Data Observation and Querying -- Descriptive Statistics -- Table and Grid Formats -- Dataset Visualization -- Data Outside Dataset Format -- 2D and 3D Plots -- Summary -- Chapter 8: Machine Learning with the Wolfram Language.
Gradient Descent Algorithm -- Getting the Data -- Algorithm Implementation -- Multiple Alphas -- Linear Regression -- Predict Function -- Boston Dataset -- Model Creation -- Model Measurements -- Model Assessment -- Retraining Model Hyperparameters -- Logistic Regression -- Titanic Dataset -- Data Exploration -- Classify Function -- Testing the Model -- Data Clustering -- Clusters Identification -- Choosing a Distance Function -- Identifying Classes -- K-Means Clustering -- Dimensionality Reduction -- Applying K-Means -- Changing the Distance Function -- Different k's -- Cluster Classify -- Summary -- Chapter 9: Neural Networks with the Wolfram Language -- Layers -- Input Data -- Linear Layer -- Weights and Biases -- Initializing a Layer -- Retrieving Data -- Mean Squared Layer -- Activation Functions -- Softmax Layer -- Function Layer -- Encoder and Decoders -- Encoder -- Pooling Layer -- Decoders -- Applying Encoder and Decoders -- NetChains and Graphs -- Containers -- Multiple Chains -- NetGraphs -- Combining Containers -- Network Properties -- Exporting and Importing a Model -- Summary -- Chapter 10: Neural Networks Framework -- Training a Neural Network -- Data Input -- Training Phase -- Model Implementation -- Batch Size and Rounds -- Training Method (NetTrain) -- Measuring Performance -- Model Assessment -- Exporting a Neural Network -- Wolfram Neural Net Repository -- Selecting a Neural Net Model -- Accessing Inside Mathematica -- Retrieving Relevant Information -- LeNet Neural Network -- LeNet Model -- MINST Dataset -- LeNet Architecture -- MXNet Framework -- Preparing LeNet -- LeNet Training -- LeNet Model Assesment -- Testing LeNet -- GPT and LLM Basics -- A Brief Overview -- LLM in the Wolfram Language -- Chat Notebooks -- Wolfram Prompt Repository -- LLM Functionalities -- GTP-1 and GPT-2 Models -- Final Remarks -- Index.
Record Nr. UNINA-9910872191103321
Villalobos Alva Jalil  
Berkeley, CA : , : Apress L. P., , 2024
Materiale a stampa
Lo trovi qui: Univ. Federico II
Opac: Controlla la disponibilità qui
Beginning Python : From Novice to Professional
Beginning Python : From Novice to Professional
Autore Hetland Magnus Lie
Edizione [4th ed.]
Pubbl/distr/stampa Berkeley, CA : , : Apress L. P., , 2024
Descrizione fisica 1 online resource (620 pages)
Disciplina 005.13/3
Altri autori (Persone) NelliFabio
ISBN 9798868801969
9798868801952
Formato Materiale a stampa
Livello bibliografico Monografia
Lingua di pubblicazione eng
Nota di contenuto Intro -- About the Authors -- About the Technical Reviewers -- Preface -- Introduction -- Chapter 1: Instant Hacking: The Basics -- The Interactive Interpreter -- Algo . . . What? -- Numbers and Expressions -- Hexadecimals Octals and Binary -- Variables -- Statements -- Getting Input from the User -- Functions -- Modules -- cmath and Complex Numbers -- Saving and Executing Your Programs -- Running Your Python Scripts from a Command Prompt -- Making Your Scripts Behave Like Normal Programs -- What About Double-Clicking? -- Comments -- Strings -- Single-Quoted Strings and Escaping Quotes -- Concatenating Strings -- String Representations, str and repr -- Long Strings, Raw Strings, and bytes -- Long Strings -- Raw Strings -- Unicode, bytes, and bytearray -- Summary -- New Functions in This Chapter -- What Now? -- Chapter 2: Lists and Tuples -- Sequence Overview -- Common Sequence Operations -- Indexing -- Slicing -- A Nifty Shortcut -- Longer Steps -- Adding Sequences -- Multiplication -- None, Empty Lists, and Initialization -- Membership -- Length, Minimum, and Maximum -- Lists: Python's Workhorse -- The list Function -- Basic List Operations -- Changing Lists: Item Assignments -- Deleting Elements -- Assigning to Slices -- List Methods -- append -- clear -- copy -- count -- extend -- index -- insert -- pop -- remove -- reverse -- sort -- Advanced Sorting -- Tuples: Immutable Sequences -- Summary -- New Functions in This Chapter -- What Now? -- Chapter 3: Working with Strings -- Basic String Operations -- String Formatting: The Short Version -- String Formatting: The Long Version -- Replacement Field Names -- Basic Conversions -- Width, Precision, and Thousands Separators -- Signs, Alignment, and Zero-Padding -- String Methods -- center -- find -- join -- lower -- replace -- split -- strip -- translate -- Is My String… -- Summary.
New Functions in This Chapter -- What Now? -- Chapter 4: Dictionaries: When Indices Won't Do -- Dictionary Uses -- Creating and Using Dictionaries -- The dict Function -- Basic Dictionary Operations -- String Formatting with Dictionaries -- Dictionary Methods -- clear -- copy -- fromkeys -- get -- items -- keys -- pop -- popitem -- setdefault -- update -- values -- Summary -- New Functions in This Chapter -- What Now? -- Chapter 5: Conditionals, Loops, and Some Other Statements -- More About print and import -- Printing Multiple Arguments -- Importing Something as Something Else -- Assignment Magic -- Sequence Unpacking -- Chained Assignments -- Augmented Assignments -- Blocks: The Joy of Indentation -- Multiline Editing -- Conditions and Conditional Statements -- So That's What Those Boolean Values Are For -- Conditional Execution and the if Statement -- else Clauses -- elif Clauses -- Nesting Blocks -- More Complex Conditions -- Comparison Operators -- The Equality Operator -- is: The Identity Operator -- in: The Membership Operator -- String and Sequence Comparisons -- Boolean Operators -- Assertions -- Loops -- while Loops -- for Loops -- Iterating Over Dictionaries -- Some Iteration Utilities -- Parallel Iteration -- Numbered Iteration -- Reversed and Sorted Iteration -- Breaking Out of Loops -- break -- continue -- The while True/break Idiom -- else Clauses in Loops -- Comprehensions-Slightly Loopy -- And Three for the Road -- Nothing Happened! -- Deleting with del -- Executing and Evaluating Strings with exec and eval -- exec -- eval -- Summary -- New Functions in This Chapter -- What Now? -- Chapter 6: Abstraction -- Laziness Is a Virtue -- Abstraction and Structure -- Creating Your Own Functions -- Documenting Functions -- Functions That Aren't Really Functions -- The Magic of Parameters -- Where Do the Values Come From?.
Can I Change a Parameter? -- Why Would I Want to Modify My Parameters? -- What If My Parameter Is Immutable? -- Keyword Parameters and Defaults -- Collecting Parameters -- Reversing the Process -- Parameter Practice -- Scoping -- Recursion -- Two Classics: Factorial and Power -- Another Classic: Binary Search -- Summary -- New Functions in This Chapter -- What Now? -- Chapter 7: More Abstraction -- The Magic of Objects -- Polymorphism -- Polymorphism and Methods -- Polymorphism Comes in Many Forms -- Encapsulation -- Inheritance -- Classes -- What Is a Class, Exactly? -- Making Your Own Classes -- Attributes, Functions, and Methods -- Privacy Revisited -- The Class Namespace -- Specifying a Superclass -- Investigating Inheritance -- Multiple Superclasses -- Interfaces and Introspection -- Some Thoughts on Object-Oriented Design -- Summary -- New Functions in This Chapter -- What Now? -- Chapter 8: Exceptions -- What Is an Exception? -- Making Things Go Wrong . . . Your Way -- The raise Statement -- Custom Exception Classes -- Catching Exceptions -- Look, Ma, No Arguments! -- More Than One except Clause -- Catching Two Exceptions with One Block -- Catching the Object -- A Real Catchall -- When All Is Well -- And Finally . . . -- Exceptions and Functions -- The Zen of Exceptions -- Not All That Exceptional -- A Quick Summary -- New Functions in This Chapter -- What Now? -- Chapter 9: Magic Methods, Properties, and Iterators -- Constructors -- Overriding Methods in General, and the Constructor in Particular -- Calling the Unbound Superclass Constructor -- Using the super Function -- Item Access -- The Basic Sequence and Mapping Protocol -- Subclassing list, dict, and str -- More Magic -- Properties -- The property Function -- Static Methods and Class Methods -- __getattr__, __setattr__, and Friends -- Iterators -- The Iterator Protocol.
Making Sequences from Iterators -- Generators -- Making a Generator -- A Recursive Generator -- Generators in General -- Generator Methods -- Simulating Generators -- The Eight Queens -- Generators and Backtracking -- The Problem -- State Representation -- Finding Conflicts -- The Base Case -- The Recursive Case -- Wrapping It Up -- Summary -- New Functions in This Chapter -- What Now? -- Chapter 10: Batteries Included -- Modules -- Modules Are Programs -- Modules Are Used to Define Things -- Defining a Function in a Module -- Adding Test Code in a Module -- Making Your Modules Available -- Putting Your Module in the Right Place -- Telling the Interpreter Where to Look -- Packages -- Exploring Modules -- What's in a Module? -- Using dir -- The __all__ Variable -- Working with IDE Development Tools -- Getting Help with help -- Documentation -- Use the Source -- The Standard Library: A Few Favorites -- sys -- os -- fileinput -- Sets, Heaps, and Deques -- Sets -- Heaps -- Deques (and Other Collections) -- time -- random -- shelve and json -- A Potential Trap -- A Simple Database Example -- re -- What Is a Regular Expression? -- The Wildcard -- Escaping Special Characters -- Character Sets -- Alternatives and Subpatterns -- Optional and Repeated Subpatterns -- The Beginning and End of a String -- Contents of the re Module -- Match Objects and Groups -- Group Numbers and Functions in Substitutions -- Finding the Sender of an Email -- A Sample Template System -- Other Interesting Standard Modules -- Summary -- New Functions in This Chapter -- What Now? -- Chapter 11: Files and Stuff -- Opening Files -- File Modes -- The Basic File Methods -- Reading and Writing -- Piping Output -- Reading and Writing Lines -- Closing Files -- Using the Basic File Methods -- Iterating Over File Contents -- One Character (or Byte) at a Time -- One Line at a Time.
Reading Everything -- Lazy Line Iteration with fileinput -- File Iterators -- CSV Files -- XML Files -- HTML Files -- JSON Files -- Apache Parquet -- Summary -- New Functions in This Chapter -- What Now? -- Chapter 12: Graphical User Interfaces -- Building a Sample GUI Application -- Initial Exploration -- Layout -- Event Handling -- The Final Program -- Using Something Else -- Summary -- What Now? -- Chapter 13: Database Support -- The Python Database API -- Global Variables -- Exceptions -- Connections and Cursors -- Types -- SQLite and PySQLite -- Getting Started -- A Sample Database Application -- Creating and Populating Tables -- Searching and Dealing with Results -- SQL Alchemy -- A Database in a Container with Docker -- Setting Up a PostgreSQL Database with Docker -- Using a PostgreSQL Database with Python -- Using Mongo, a No-SQL Database with Docker and Python -- Summary -- New Functions in This Chapter -- What Now? -- Chapter 14: Network Programming -- A Couple of Networking Modules -- The socket Module -- The urllib3 Module -- Other Modules -- socketserver and http.server -- Multiple Connections -- Enhance an HTTP server with socketserver Forking and Threading -- Asynchronous I/O with asyncio -- Twisted -- Downloading and Installing Twisted -- Writing a Twisted Server -- Summary -- What Now? -- Chapter 15: Python and the Web -- Screen Scraping -- Tidy and XHTML Parsing -- What's Tidy? -- Getting Tidy -- But Why XHTML? -- Using HTMLParser -- Beautiful Soup -- Dynamic Web Pages with CGI -- Step 1: Preparing the Web Server -- Step 2: Adding the Pound Bang Line -- Step 3: Setting the File Permissions -- CGI Security Risks -- A Simple CGI Script -- Debugging with cgitb -- Using the cgi Module -- A Simple Form -- Using a Web Framework -- Other Web Application Frameworks -- Web Services: Scraping Done Right -- RSS and Friends.
Remote Procedure Calls with XML-RPC.
Record Nr. UNINA-9910872180803321
Hetland Magnus Lie  
Berkeley, CA : , : Apress L. P., , 2024
Materiale a stampa
Lo trovi qui: Univ. Federico II
Opac: Controlla la disponibilità qui
Beginning React and Firebase : Create Four Beginner-Friendly Projects Using React and Firebase
Beginning React and Firebase : Create Four Beginner-Friendly Projects Using React and Firebase
Autore Biswas Nabendu
Pubbl/distr/stampa Berkeley, CA : , : Apress L. P., , 2021
Descrizione fisica 1 online resource (189 pages)
Soggetto genere / forma Electronic books.
ISBN 9781484278123
9781484278116
Formato Materiale a stampa
Livello bibliografico Monografia
Lingua di pubblicazione eng
Record Nr. UNINA-9910510563403321
Biswas Nabendu  
Berkeley, CA : , : Apress L. P., , 2021
Materiale a stampa
Lo trovi qui: Univ. Federico II
Opac: Controlla la disponibilità qui