Practices of the Python Pro

seeders: 38
leechers: 6
updated:
Download torrent
Added by tutsnode in Other > Tutorials
Download Fast Safe Anonymous
movies, software, shows...
  • Downloads: 381
  • Language: English

Files

Practices of the Python Pro [TutsNode.com] - Practices of the Python Pro
  • 13 - Chapter 3. Abstraction and encapsulation.mp4 (65.6 MB)
  • 46 - Chapter 9. Keeping things lightweight.mp4 (64.2 MB)
  • 50 - Chapter 10. Achieving loose coupling.mp4 (58.7 MB)
  • 20 - Chapter 4. Make it work, make it right, make it fast.mp4 (58.4 MB)
  • 54 - Chapter 11. Onward and upward.mp4 (56.2 MB)
  • 51 - Chapter 10. Recognizing coupling.mp4 (56.1 MB)
  • 42 - Chapter 8. The inheritance of programming present.mp4 (55.4 MB)
  • 11 - Chapter 2. The hierarchy of separation in Python.mp4 (55.3 MB)
  • 52 - Chapter 10. Addressing coupling.mp4 (54.8 MB)
  • 23 - Chapter 5. Functional testing approaches.mp4 (54.1 MB)
  • 35 - Chapter 6. The presentation layer.mp4 (53.7 MB)
  • 14 - Chapter 3. Encapsulation.mp4 (52.5 MB)
  • 6 - Chapter 1. Design is democratic.mp4 (52.3 MB)
  • 39 - Chapter 7. Solutions for rigidity.mp4 (52.0 MB)
  • 16 - Chapter 3. Typing, inheritance, and polymorphism.mp4 (51.7 MB)
  • 32 - Chapter 6. The persistence layer.mp4 (50.5 MB)
  • 2 - Chapter 1. The bigger picture.mp4 (49.7 MB)
  • 18 - Chapter 4. Time complexity.mp4 (49.6 MB)
  • 25 - Chapter 5. Statements of fact.mp4 (49.1 MB)
  • 4 - Chapter 1. Design enables better software.mp4 (48.7 MB)
  • 21 - Chapter 4. Tools.mp4 (48.0 MB)
  • 26 - Chapter 5. Writing your first integration test with unittest.mp4 (46.7 MB)
  • 34 - Chapter 6. The business logic layer.mp4 (46.1 MB)
  • 56 - Chapter 11. Distributed systems.mp4 (45.0 MB)
  • 30 - Chapter 6. Separation of concerns in practice.mp4 (44.4 MB)
  • 49 - Chapter 9. Extracting classes and forwarding calls.mp4 (43.8 MB)
  • 19 - Chapter 4. Performance and data types.mp4 (43.7 MB)
  • 28 - Chapter 5. Beyond functional testing.mp4 (40.4 MB)
  • 43 - Chapter 8. Inheritance in Python.mp4 (40.2 MB)
  • 12 - Chapter 2. Classes.mp4 (38.5 MB)
  • 33 - Chapter 6. The persistence layer.mp4 (38.0 MB)
  • 57 - Chapter 11. Where you’ve been.mp4 (37.5 MB)
  • 8 - Chapter 2. Modules.mp4 (37.4 MB)
  • 38 - Chapter 7. Modifying existing behaviors.mp4 (36.9 MB)
  • 15 - Chapter 3. Programming styles are an abstraction too.mp4 (36.5 MB)
  • 37 - Chapter 7. Extensibility and flexibility.mp4 (36.4 MB)
  • 47 - Chapter 9. Breaking down complexity.mp4 (36.3 MB)
  • 9 - Chapter 2. Separation of concerns.mp4 (36.0 MB)
  • 41 - Chapter 8. The rules (and exceptions) of inheritance.mp4 (35.9 MB)
  • 22 - Chapter 5. Testing your software.mp4 (35.6 MB)
  • 45 - Chapter 8. Inheritance and composition in Bark.mp4 (33.9 MB)
  • 3 - Chapter 1. Design is a process.mp4 (32.9 MB)
  • 24 - Chapter 5. Integration testing.mp4 (32.1 MB)
  • 40 - Chapter 7. An exercise in extension.mp4 (31.2 MB)
  • 31 - Chapter 6. An initial code structure, by concern.mp4 (30.5 MB)
  • 55 - Chapter 11. Design patterns.mp4 (30.3 MB)
  • 17 - Chapter 4. Designing for high performance.mp4 (26.3 MB)
  • 5 - Chapter 1. When to invest in design.mp4 (25.4 MB)
  • 44 - Chapter 8. Abstract base classes.mp4 (24.6 MB)
  • 10 - Chapter 2. The many masks of importing.mp4 (24.1 MB)
  • 27 - Chapter 5. Testing with pytest.mp4 (23.4 MB)
  • 48 - Chapter 9. Decomposing classes.mp4 (22.9 MB)
  • 36 - Chapter 6. The presentation layer.mp4 (17.8 MB)
  • 29 - Part 3. Nailing down large systems.mp4 (6.0 MB)
  • 7 - Part 2. Foundations of design.mp4 (5.0 MB)
  • 1 - Part 1. Why it all matters.mp4 (3.7 MB)
  • 53 - Part 4. What’s next.mp4 (3.5 MB)
  • TutsNode.com.txt (0.1 KB)
  • [TGx]Downloaded from torrentgalaxy.to .txt (0.6 KB)
    • .pad
    • 0 (421.4 KB)
    • 1 (306.9 KB)
    • 2 (306.1 KB)
    • 3 (121.9 KB)
    • 4 (316.8 KB)
    • 5 (412.9 KB)
    • 6 (149.8 KB)
    • 7 (242.5 KB)
    • 8 (191.0 KB)
    • 9 (409.2 KB)
    • 10 (293.7 KB)
    • 11 (510.5 KB)
    • 12 (235.5 KB)
    • 13 (47.6 KB)
    • 14 (299.3 KB)
    • 15 (462.9 KB)
    • 16 (259.0 KB)
    • 17 (369.1 KB)
    • 18 (429.6 KB)
    • 19 (292.5 KB)
    • 20 (477.4 KB)
    • 21 (342.9 KB)
    • 22 (411.8 KB)
    • 23 (503.6 KB)
    • 24 (113.1 KB)
    • 25 (211.3 KB)
    • 26 (324.9 KB)
    • 27 (67.0 KB)
    • 28 (269.0 KB)
    • 29 (483.7 KB)
    • 30 (24.2 KB)
    • 31 (8.2 KB)
    • 32 (67.2 KB)
    • 33 (125.8 KB)
    • 34 (15.8 KB)
    • 35 (120.0 KB)
    • 36 (246.2 KB)
    • 37 (506.2 KB)
    • 38 (152.0 KB)
    • 39 (389.4 KB)
    • 40 (57.8 KB)
    • 41 (74.2 KB)
    • 42 (452.8 KB)
    • 43 (301.3 KB)
    • 44 (510.9 KB)
    • 45 (229.5 KB)
    • 46 (243.8 KB)
    • 47 (134.2 KB)
    • 48 (359.3 KB)
    • 49 (422.8 KB)
    • 50 (74.5 KB)
    • 51 (90.7 KB)
    • 52 (153.9 KB)
    • 53 (15.2 KB)
    • 54 (480.0 KB)
    • 55 (259.7 KB)

Description


Description

A wealth of information on general software architecture and truths that are applicable to any language.
David T. Kerns, Rincon Research Corporation

Professional developers know the many benefits of writing application code that’s clean, well-organized, and easy to maintain. By learning and following established patterns and best practices, you can take your code and your career to a new level.

With Practices of the Python Pro, you’ll learn to design professional-level, clean, easily maintainable software at scale using the incredibly popular programming language, Python. You’ll find easy-to-grok examples that use pseudocode and Python to introduce software development best practices, along with dozens of instantly useful techniques that will help you code like a pro.
about the technology

Professional-quality code does more than just run without bugs. It’s clean, readable, and easy to maintain. To step up from a capable Python coder to a professional developer, you need to learn industry standards for coding style, application design, and development process. That’s where this book is indispensable.
about the book

Practices of the Python Pro teaches you to design and write professional-quality software that’s understandable, maintainable, and extensible. Dane Hillard is a Python pro who has helped many dozens of developers make this step, and he knows what it takes. With helpful examples and exercises, he teaches you when, why, and how to modularize your code, how to improve quality by reducing complexity, and much more. Embrace these core principles, and your code will become easier for you and others to read, maintain, and reuse.

Released January 2020



Download torrent
2.2 GB
seeders:38
leechers:6
Practices of the Python Pro

Trackers

tracker name
udp://inferno.demonoid.pw:3391/announce
udp://tracker.openbittorrent.com:80/announce
udp://tracker.opentrackr.org:1337/announce
udp://torrent.gresille.org:80/announce
udp://glotorrents.pw:6969/announce
udp://tracker.leechers-paradise.org:6969/announce
udp://tracker.pirateparty.gr:6969/announce
udp://tracker.coppersurfer.tk:6969/announce
udp://ipv4.tracker.harry.lu:80/announce
udp://9.rarbg.to:2710/announce
udp://shadowshq.yi.org:6969/announce
udp://tracker.zer0day.to:1337/announce
µTorrent compatible trackers list

Download torrent
2.2 GB
seeders:38
leechers:6
Practices of the Python Pro

Torrent hash: D7399E1879C615568E714F87C77441C16C377889