Daniel Arbuckle s mastering Python build powerful Python applications 1st Edition by Daniel Arbuckle ISBN 1787283690 9781787283695 by Arbuckle, Daniel 9781787283695, 9781787284401, 1787283690, 1787284409 instant download after payment.

Daniel Arbuckle s mastering Python build powerful Python applications 1st Edition by Daniel Arbuckle - Ebook PDF Instant Download/Delivery: 1787283690, 9781787283695
Full download Daniel Arbuckle s mastering Python build powerful Python applications 1st Edition after payment

Product details:

ISBN 10: 1787283690 
ISBN 13: 9781787283695
Author: Daniel Arbuckle

Gain a thorough understanding of operating in a Python development environment, and some of the most important advanced topics with Daniel Arbuckle. This dynamic, concise book is full of real-world solutions for Python 3.6 problems, and advanced-level concepts such as reactive programming, microservices, ctypes and Cython.

Key Features:

- Covers the latest and advanced concepts of Python such as parallel processing with Python 3.6

- Explore the Python language from its basic installation and setup to concepts such as reactive programming and microservices

- Get introduced to the mechanism for rewriting code in a compiled language along with ctypes and Cython tools

Book Description:

Daniel Arbuckle's Mastering Python covers the basics of operating in a Python development environment, before moving on to more advanced topics. Daniel presents you with real-world solutions to Python 3.6 and advanced-level concepts, such as reactive programming, microservices, ctypes, and Cython tools.

You don't need to be familiar with the Python language to use this book, as Daniel starts with a Python primer. Throughout, Daniel highlights the major aspects of managing your Python development environment, shows you how to handle parallel computation, and helps you to master asynchronous I/O with Python 3.6 to improve performance. Finally, Daniel will teach you the secrets of metaprogramming and unit testing in Python, helping you acquire the perfect skillset to be a Python expert.

Daniel will get you up to speed on everything from basic programming practices to high-end tools and techniques, things that will help set you apart as a successful Python programmer.

Daniel Arbuckle s mastering Python build powerful Python applications 1st Table of contents:

1. Python Primer
2. Python basic syntax and block structure
3. Basic building blocks
4. Functions
5. Variables
6. Expressions
7. Classes
8. Flow control statements
9. Indentation
10. Python's built-in data structures and comprehensions
11. Dictionaries
12. List
13. Tuple
14. Set
15. Comprehension
16. First-class functions and classes
17. The defaultdict class
18. Attributes
19. The standard library
20. Different types of packages
21. What's new in modern Python
22. The changes in the syntactic
23. Changes in packages
24. Other changes in Python packages
25. Summary
26. Setting Up
27. Downloading and installing Python
28. Choosing a suitable version
29. Installing Python
30. Using the command line and the interactive shell
31. Opening a command-line window
32. Python interactive shell
33. Installing packages with pip
34. The pip tool for packages
35. Managing installed packages
36. Finding packages in the Python Package Index
37. Using keywords
38. Using Package Index
39. Searching the Package Index with pip
40. Legalities and licenses of the Python Package Index
41. Summary
42. Making a Package
43. Creating an empty package
44. Turning a regular folder into a package
45. Importing all package modules
46. Adding modules to the package
47. Module loading with namespace packages
48. The Package structure and interface
49. Accessing code from other modules
50. Importing a cyclic dependency
51. Resolving attribute errors raised due to cyclic dependencies
52. Adding static data files to the package
53. Summary
54. Basic Best Practices
55. PEP 8 and writing readable code
56. PEP 8 — guidelines for Python code
57. Code indentation
58. Formatting recommendations
59. Naming conventions
60. Using version control
61. Initializing Git
62. Committing the changes in Git
63. Undoing the changes
64. Branches
65. Merging codes
66. The mergetool command
67. The pull command
68. Using venv to create a stable and isolated work area
69. Creating a virtual environment
70. Activating a virtual environment
71. pip in virtual environments
72. Getting the most out of docstrings
73. PEP 257 and docutils
74. Sphinx
75. Turning docstrings into HTML
76. Using doctest to test documentation examples
77. Testing examples using doctest
78. What it means when a code example fails
79. Summary
80. Making a Command-Line Utility
81. Making a package executable via Python -m
82. Pipeline program
83. Handling command-line arguments with argparse
84. Creating an ArgumentParser object
85. Setting the name of argument
86. nargs
87. Python tools to interact with the user
88. Python's built-in functions - print and input
89. The getpass package
90. The pprint package
91. The cmd class
92. The Pipeline user interface
93. Executing other programs with subprocess
94. Subprocess and its variants
95. Using the Popen subprocess
96. The PIPE constant
97. The wait method
98. Finishing up our code example
99. Setting up a shell script or batch file to launch the program
100. Creating launches for our program
101. Summary
102. Parallel Processing
103. Using the concurrent.futures package
104. The concurrent.futures module
105. Calling ProcessPoolExecutor
106. Using the map method
107. Using the submit method
108. The done and result methods
109. The wait and as_completed functions
110. The add done callback function
111. The cancel method
112. Using the multiprocessing packages
113. Process class in the multiprocessing module
114. Queues
115. Pipes
116. Manager
117. The lock object
118. The event object
119. The condition object
120. The semaphore object
121. Summary
122. Coroutines and Asynchronous I/O
123. The difference between asynchronous processing and parallel processing
124. Multithreading is not good for servers
125. Cooperative coroutine scheduler versus coroutine
126. Python coroutines
127. The coroutine scheduler
128. Using the asyncio event loop and coroutine scheduler
129. Creating a coroutine
130. The asyncio scheduler - event_loop
131. ensure_future
132. The run_forever/run_until_complete methods
133. Closing event_loop
134. Awaiting data availability
135. asyncio's future objects
136. Asynchronous iterations
137. Synchronizing multiple tasks
138. Synchronization primitives
139. The wait coroutine
140. The wait_for coroutine
141. The gather coroutine
142. The asyncio Queue class
143. Queue types
144. Communicating across the network
145. Creating a simple client in asyncio
146. Creating a simple server in asyncio
147. Handling client disconnections
148. Summary
149. Metaprogramming
150. Using function decorators
151. Using the @ syntax in a function decorator
152. Global decorator - @staticmethod
153. Attributes
154. Enclosing the function in a wrapper
155. The @wraps decorator
156. The only function
157. Function annotations
158. Function annotation syntax
159. Accessing annotation data
160. The @no_type_check decorator
161. Annotations as input to function decorators
162. Keyword arguments
163. Inspecting the package signature function
164. Class decorators
165. Modifying class attributes
166. The factory function
167. The factory_constructed function
168. Class definitions
169. Metaclasses
170. What can we do with a metaclass?
171. The __prepare__method
172. The __new__ method
173. Context managers
174. Defining a context manager as a generator
175. Adding context manager behavior to a class
176. Synchronous-coroutine-based context managers
177. Creating an asynchronous-coroutine-based context manager
178. Descriptors
179. Using @property to create a descriptor
180. Writing descriptors as classes
181. Summary
182. Unit Testing
183. Understanding the principle of unit testing
184. What is a unit test?
185. Using the unittest package
186. Structuring a test file
187. assert methods
188. Comparing what happens to what should happen in unit tests
189. Using unittest.mock
190. What is a mock object?
191. Preconfiguring mock objects
192. assert methods of mock objects
193. The unittest.mock patch function
194. Using unittest's test discovery
195. Unittest's discovery tool
196. Command-line options in unit test discovery
197. Using nose for unified test discovery and reporting
198. Running our tests with nose
199. The cover-package option
200. Testing multiple worker processes
201. Summary
202. Reactive Programming
203. The concept of reactive programming
204. Building a simple reactive programming framework
205. Observers
206. Observables
207. Emitting events
208. Building the observable sequence
209. Illustrating a stream of animal events
210. Composing an observable sequence
211. Using the reactive extensions for Python (RxPY)
212. Translating our zoo demo into Rx
213. Observable factory methods
214. Explaining the observable sequence of events
215. Creating an asyncio scheduler
216. Combining and processing observable sequences
217. Miscellaneous observable factory methods
218. The Observable.create method
219. The Observable.select_many method
220. Empty, return_value, and from_iterable factory methods
221. The where factory method
222. Summary
223. Microservices
224. Microservices and the advantages of process isolation
225. Advantages of the microservice architecture
226. Applying the microservice architecture to web servers
227. Building high-level microservices with Flask
228. Installing Flask
229. Creating endpoints for a RESTful API in Flask
230. Building a microservice to maintain a database
231. Making Flask handle a request
232. Running and connecting to our microservice using Flask
233. Test running the microservice
234. Building high-level microservices with nameko
235. Installing nameko
236. Running and connecting a microservice using nameko
237. Things to know before using nameko
238. Interacting with our microservice
239. Interacting with a microservice manually using the nameko shell
240. Interacting with a microservice by creating another microservice
241. Summary
242. Extension Modules and Compiled Code
243. Advantages and disadvantages of compiled code
244. The downsides of compiled code
245. Accessing a dynamic library using ctypes
246. Locating and linking a dynamic library
247. Accessing functions defined in the library
248. Assigning attributes to a function
249. Using a pointer as a parameter of a function
250. Providing a function signature
251. Providing data structure layouts
252. Interfacing with C code using Cython
253. Working with Cython
254. Additional import methods in Cython
255. Writing extension modules in Cython
256. Methods to increase the execution speed of Python code
257. Using cpdef in a Cython class
258. Compiling an extension module in Python

People also search for Daniel Arbuckle s mastering Python build powerful Python applications 1st:

daniel arbuckle
    
quantlib python cookbook
    
5.10 data science with python
    
learn python 3 magic 8-ball
    
zybooks python 2.16
    
daniel x audiobook

Tags: Daniel Arbuckle, mastering, Python