Home
Search results “Pep python style guide”
Python tricks: Writing user-friendly code with PEP-8 naming conventions
 
15:30
In this video, I describe the PEP-8 style guideline for Python, with a specific focus on the naming conventions for variables, functions, and classes, which can make your code much easier to use for others. The Jupyter notebook is available here: https://osf.io/xy8kh/
Views: 5112 Sebastiaan Mathôt
pep8.org — The Prettiest Way to View the PEP 8 Python Style Guide
 
07:36
Improve your Python skills, one bite at a time: https://dbader.org/python-tricks PEP 8 is the most popular code style guide for Python. It's widely known and used by the Python community. If you're looking for formatting advice on your Python code, look no further. It's a good time investment to spend a few hours reading through PEP 8 and learning how to apply its recommendation to your own projects. A common challenge with applying PEP 8 is that the original web page on python.org for it is kind of difficult to read—for example there's no code highlighting or a persistent table of contents you can use to navigate around. pep8.org is a project that aims to change this. It's a "nicely formatted" version of the original PEP 8 document with the goal to make this wonderful Python style guide more accessible and easier to share. pep8.org is an open-source project that was started by Kenneth Reitz, the creator of Requests and many other popular Python packages. I was happy to bump into Kenneth at PyCon 2017 (because he's one of my personal "Python heroes") and in the course of that I became a co-maintainer for pep8.org and brought it up to date and made some small fixes to the website over the last couple of days. In this video you'll see how pep8.org can help you write cleaner and more beautiful Python code that follows the PEP 8 community style guide. Here's how to find it: → https://pep8.org → https://github.com/kennethreitz/pep8.org * * * ► Subscribe to this channel: https://dbader.org/youtube/ ► Free Python Articles & Tutorials: https://dbader.org/newsletter
PEP8 Python Style Guide
 
10:30
Hi, it's Naz from subtlecoding.com. In this video, I've gone over some of the recommended methods of Python programming using the PEP8 (Pythong Enhancement Proposal) Style Guide. Topics covered in this video: 1. Naming convention for functions and variables. 2. Naming convention for classes. 3. Importing libraries in correct order 4. Using spaces and tabs before function definitions 5. Seperating keys in a particular order in long dictionaries 6. Uses of single space after every comma to make code readable. 7. Installing and Using flake8 to trace any styling error. How to install flake8? If you've not already installed pip (a python package manager) yet, click the following link: https://www.dropbox.com/s/u0zmopvjnyjrfrn/get-pip.py?dl=0 and download the file, and run the following command in a console: python3 get-pip.py Then run the following command python3 -m pip install flake8 Happy Coding. Useful Resources: 1. PEP8 Official Documentation: https://www.python.org/dev/peps/pep-0008/ 2. Installing pip: https://www.dropbox.com/s/u0zmopvjnyjrfrn/get-pip.py?dl=0 Visit Website: http://www.subtlecoding.com.
Views: 4943 Naz-Al Islam
Pylint Tutorial – How to Write Clean Python
 
17:49
https://dbader.org/python-tricks ► Get examples of clean and Pythonic code that passes any Pylint or PEP 8 run. In this Pylint tutorial video you'll see how to install and set up the Pylint code linter for Python step by step. We'll go over why you should use a code linter like Pylint, Flake8, Pyflakes, or other static analysis tools—and how they can help you write cleaner and more Pythonic code. Pylint is a well-known static analysis tool for Python 2 and 3. It has a number of useful features, like checking your code for compliance with the PEP 8 Python style guide. It makes sure that your code follows the code style guide and it can also automatically identify common bugs and errors in your Python code. To set up Pylint you'll first need to install it with the `pip install` command and then you can run it on any Python file with the "pylint" command. Pylint inspects your code and then gives you feedback on it. Besides running Pylint from the command-line you can also integrate it into your editor to get live feedback on your Python code. In this Pylint tutorial I'm going over the feedback produced by Pylint and I'm taking it to refactor and improve the quality of my code. You can get this setup up and running in a few minutes and it'll quickly help you write better and cleaner Python code. FREE COURSE – "5 Thoughts on Mastering Python" https://dbader.org/python-mastery SUBSCRIBE TO THIS CHANNEL: https://dbader.org/youtube * * * ► Python swag: MUGS, SHIRTS & more: https://nerdlettering.com FREE Python Tutorials & News: » Python Tutorials: https://dbader.org » Python News on Twitter: https://twitter.com/@dbader_org » Weekly Tips for Pythonistas: https://dbader.org/newsletter » Subscribe to this channel: https://dbader.org/youtube
Python Code Review: Refactoring a Web Scraper, PEP 8 Style Guide Compliance, requirements.txt
 
37:36
https://dbader.org/python-mastery ► How to become an effective & productive Python developer Python Code Review: Unplugged – Episode 2: Code Review for Milton This is a Python code review I did for Milton's Python project on GitHub. Milton is definitely on the right track with his Python journey. I liked how he used functions to split up his web scraper program into functions that each handle a different phase, like *fetch the html*, *parse it*, and *generate the output file*. The main thing that this code base could benefit from would be consistent formatting. Making the formatting as regular and consistent as possible really helps with keeping the "mental overhead" low when you're working on the code or handing it off to someone else. Besides formatting, the video also covers things like writing a great GitHub README, how to name functions and modules, and the use of constants to simplify your Python code. Again, I left the video completely unedited. That’s why I’m calling this series Code Review: Unplugged. It’s definitely not a polished tutorial or course. But based on the feedback I got so far that seems to be part of the appeal :D The article I mention in the video: "How to write a great GitHub README" » https://dbader.org/blog/write-a-great-readme-for-your-github-project Here's some more background info about this video: https://dbader.org/blog/python-code-review-unplugged-episode-2 FREE COURSE – "5 Thoughts on Mastering Python" https://dbader.org/python-mastery SUBSCRIBE TO THIS CHANNEL: https://dbader.org/youtube * * * ► Python Developer MUGS, T-SHIRTS & MORE: https://nerdlettering.com FREE Python Tutorials & News: » Python Tutorials: https://dbader.org » Python News on Twitter: https://twitter.com/@dbader_org » Weekly Tips for Pythonistas: https://dbader.org/newsletter » Subscribe to this channel: https://dbader.org/youtube
Mastering Python Tutorial: PEP 8 and Writing Readable Code | packtpub.com
 
06:31
Part of 'Mastering Python' video series. For the full Course visit: https://www.packtpub.com/big-data-and-business-intelligence/mastering-python-video?utm_source=youtube&utm_medium=video-description&utm_campaign=yt-masteringpython Make your code more readable for yourself and others using Python's communal coding standard. • Spaces versus tabs • Understanding the code layout • Using naming conventions to perfection _______________________________________________________ For the latest in Big Data and Business Intelligence video tutorials, please visit: http://www.packtpub.com/books/video?utm_source=youtube&utm_medium=video-description&utm_campaign=yt-masteringpython Find us on Facebook -- http://www.facebook.com/Packtvideo Follow us on Twitter - http://www.twitter.com/packtvideo
Views: 3603 Packt Video
Transforming Code into Beautiful, Idiomatic Python
 
48:51
Raymond Hettinger Learn to take better advantage of Python's best features and improve existing code through a series of code transformations, "When you see this, do that instead."
Views: 457967 Next Day Video
Tip 7 - PEP8 - Python Style Guide
 
04:03
Learn Programming With Python In 100 Steps Section: 9 Python Tips For Beginners 76. Tip 7 - PEP8 - Python Style Guide For Notes And Tests Visit https://programmingisalife.blogspot.com
Sublime Text Settings for Writing PEP 8 Python
 
03:29
► Optimize your Python + Sublime Text Setup: https://SublimeTextPython.com How to configure Sublime Text to help you write PEP 8 compliant Python code. In this video we'll take a quick look at the "rulers" feature in combination with word wrapping. ► Weekly Tips for Python Developers: https://dbader.org/newsletter
How to write more readable code in Python - What is PEP 8 style guide for Python code
 
02:41
Hi everyone. In this video we're going to talk about guides how to write more readable and maintainable Python code. And we'll talk about that what PEP 8 is and where to get documentations for writing better code in Python.
Views: 215 nevsky.programming
Programming with Python - 8 - PEP Guidelines | While Loops
 
24:16
PEP Guidelines While Loops
Views: 72 #RandomStuff
1.5 Python coding style PEP8
 
08:32
Python coding style • PEP 8 has emerged as the style guide that most projects adhere to; it promotes a very readable and eye-pleasing coding style. • Every Python developer should read it at some point. • PEP stands for Python Enhancement Proposals. https://www.python.org/dev/peps/pep-0008 PEP 8 • Most languages can be written in different styles; some are more readable than others. Making it easy for others to read your code is always a good idea. Adopt nice simple coding style to help others. • Python has simple style and the most important points are discussed in this session. https://docs.python.org/3.7/tutorial/controlflow.html#intermezzo-coding-style Code Lay-out • Indentation • Wrap lines • Blank Lines • Comments • Docstrings • Tabs or Spaces? • Tabs or Spaces? • Line Break • Source File Encoding • Imports • Module Level Dunder Names Indentation • Use 4-space indentation, and no tabs. Tab in some editors (ex. Notepad++) have 4 space tab. • 4 spaces are a good compromise between small indentation (allows greater nesting depth) and large indentation (easier to read). Wrap lines (Max line length) • Wrap lines so that they don’t exceed 79 characters. • This helps users with small displays and makes it possible to have several code files side-by-side on larger displays. • Python is free language. You can break line any where. Blank lines for readability • Use blank lines to separate functions and classes, and larger blocks of code inside functions. Comments • Add comments for clear understanding to benefit fellow programmers to quickly catchup. Python has two ways to annotate Python code. • Single-line comments begin with the hash character ("#") and are terminated by the end of line. • Multi line comments are achieved by inserting a multi-line string with """ as the delimiter on each end. Use docstrings • Docstrings (documentation strings): strings that are located alone without assignment as the first indented line within a module, class, method or function, automatically set their contents as an attribute named __doc__. docstrings Spaces • Use spaces around operators and after commas, but not directly inside bracketing constructs: a = f(1, 2) + g(3, 4). Naming classes and functions Name your classes and functions consistently; • Classes naming convention: camelCase • functions and methods: lower_case_with_underscores • camelCase is named after the camel humps, is the practice of writing phrases with middle of the phrase begins with a capital letter. Common examples include "iPhone" and "eBay". Encode in UTF-8 Don’t use fancy encodings if your code is meant to be used in collaborated/ international environments. Python’s default, UTF-8, or even plain ASCII work best in any case. Don’t use non-ASCII • Don’t use non-ASCII characters in identifiers when people speaking different languages are required to read or maintain the code. Naming Conventions – descriptive Prescriptive: Naming Conventions – Names to Avoid – ASCII Compatibility – Package and Module Names – Class Names – Type Variable Names – Exception Names – Global Variable Names – Function and Variable Names – Function and Method Arguments – Method Names and Instance Variables – Constants – Designing for Inheritance – And more… Function Annotations Annotations are stored in the __annotations__ attribute of the function as a dictionary and have no effect on any other part of the function. Function annotations are defined in PEP 3107. https://www.python.org/dev/peps/pep-3107/ Module Level Dunder Names • Module level "dunders" (i.e. names with two leading and two trailing underscores) such as __all__, __author__, __version__, etc. should be placed after the module docstring but before any import statements except from __future__ imports. • Python mandates that future-imports must appear in the module before any other code except docstrings:
Views: 14 CBTUniversity
Learn Python Programming Tutorial 35 | Python Naming Conventions
 
04:32
This python tutorial will overview naming conventions used within Python. Python naming conventions are helpful to reduce the effort needed to read and understand source code and also to help avoid "naming collisions". For more tutorials check out http://www.mybringback.com . Visit Our Friends @ Stone River E-Learning for Additional Tutorials - http://bit.ly/1fjsXTn Coupon 20% Off HTML & CSS for Beginners - http://bit.ly/1MmuYfw
Views: 4098 mybringback
Python Data Structures and Style Guide
 
11:46
Lists: http://www.codeskulptor.org/#user13_cKN7PG95uaDL1qi.py Tuples: http://www.codeskulptor.org/#user13_RLy1fXYGKIrqxml.py Functions: http://www.codeskulptor.org/#user13_A5Un7HhkUKFBQra.py PEP: www.python.org/dev/peps/ Slides: http://slid.es/decached/python
Views: 3418 Akash Kothawale
Python: 4.0 - Good Coding Practices
 
12:18
Content and video by Naveena Benjamin - This video is created by someone like you, want to help improve it further? in English or any other language in world. Gain access by joining Stanford Crowd Course Initiative! https://goo.gl/BOUA02
Views: 2541 Stanford Scholar
PEP 20 Presentation - Zen of Python
 
05:10
Jessica Lynch, Max Harris, Noah Dillion
Views: 1706 Maximilian Harris
Python 3.5 Tutorial - 5.  variable naming conventions and more string functionality
 
10:48
► SPONSORS ◄ DevMountain Coding Bootcamp https://goo.gl/P4vgKS .Tech domains https://goo.gl/6EnZmg Use Coupon Code - HISPERT18 - at checkout Get a domain: $4.99 for 1 year | $24.99 for 5 years My Latest Courses: https://www.udemy.com/user/christopher-hawkes-3/
Views: 10551 Chris Hawkes
Naming Python Variables
 
07:58
Discusses the conventions for naming Python Variables
Views: 6487 John Philip Jones
Pep8Machine
 
12:28
Using Warford's Pep-8 simulator to run machine-object code. The simulator is available at http:--code.google.com-p-pep8-1-
Views: 3170 Peter Macpherson
Raymond Hettinger, "Being a Core Developer in Python", PyBay2016
 
01:02:59
PyBay 2016 Keynote What I've learned from being a maintainer and core developer for the past 15 years. Thoughts on channeling Guido, stability, hyper-generalization, Sturgeon's law and egativity, evaluating submissions, inability to predict the future, user centric design, treating mature code differently, believing in or doubting your predecessors, lever arguments and completers, problems of too many choices, implementation details, how much to document, needs of the standard library versus the needs of users, code that is dead on arrival and how PyPI changed everything, orthogonality, importance of skill and expertise, consistency and foolish consistency, optimization and premature optimization, security tautologies, argument ordering, operator abuse, avoiding race to implementation (we can all write working code), the naming of parts, economy of force and complexity balance, feature creep, developing for others, over reliance on Guido, great minds don't think alike, preference for compactness, and aversion to deprecations. What it means to be completely reliant on long term unpaid volunteers. Bio: Raymond has been a prolific contributor to the CPython project for over a decade, having implemented and maintained many of Python's great features. He has been instrumental in modules like bisect, collections, decimal, functools, itertools, math, random, with types like namedtuple, sets, dictionaries, and in many other places around the codebase. He has contributed to the modification of nearly 90,000 lines of code in the CPython repository, and has made over 160 changes in the PEP repository. Raymond has also served as a director of the Python Software Foundation, and has mentored many people over the years on their contributions to the python-dev community. He's also well known for his contributions to the Python Cookbook, and shares many pieces of Python wisdom on Twitter. He received the Distinguished Service Award at PyCon 2014 for his exceptional contributions to the python community. ​ https://speakerdeck.com/pybay2016/raymond-hettinger-keynote-core-developer-world ​
Views: 25613 SF Python
7 Simple Tricks to Write Better Python Code
 
25:39
Visit http://python.cogsci.nl/ for more tutorials! Seven solutions to common small problems that Python programmers often solve in a suboptimal way. This video is understandable for beginners, but also contains useful advice for experienced programmers. - 0:50 Using enumerate() - 3:22 Using zip() - 6:35 Tuple unpacking - 9:40 Default dict values - 12:42 For ... else - 16:13 File reading with 'with' - 19:40 Exception handling
Views: 218156 Sebastiaan Mathôt
Optional Arguments in Python With *args and **kwargs
 
10:44
https://dbader.org/python-tricks ► Discover Python's advanced features & how to use them to write cleaner and more maintainable code An overview on Python's *args and **kwargs feature for writing functions with a variable number of arguments and/or making some parameters that a function accepts optional. In this tutorial I also demonstrate real world applications and use cases for optional parameters. For example, a design pattern you can use to extend the behavior of a parent class without having to replicate the full signature of its constructor in the child class. In summary, this is how optional function and method parameters work in Python: *args and **kwargs let you write functions with a variable number of arguments in Python. *args collects extra positional arguments as a tuple. **kwargs collects the extra keyword arguments as a dictionary. The actual syntax is * and **. Calling them args and kwargs is just a convention (one you should stick to). To learn how to use the full potential of Python check out "Python Tricks: The Book" at the link below. FREE COURSE – "5 Thoughts on Mastering Python" https://dbader.org/python-mastery PYTHON TRICKS: THE BOOK https://dbader.org/pytricks-book SUBSCRIBE TO THIS CHANNEL: https://dbader.org/youtube * * * ► Python Developer MUGS, T-SHIRTS & MORE: https://nerdlettering.com FREE Python Tutorials & News: » Python Tutorials: https://dbader.org » Python News on Twitter: https://twitter.com/@dbader_org » Weekly Tips for Pythonistas: https://dbader.org/newsletter » Subscribe to this channel: https://dbader.org/youtube
GNS3 Talks: Python for Network Engineers with GNS3 (Part 7) - How to write better code and styles
 
05:30
Udemy: Get the course for $10 here: https://goo.gl/QYC988 GNS3 Academy: Get the course for $10 here: https://goo.gl/vnZJhg More free Python videos here: https://www.youtube.com/playlist?list=PLhfrWIlLOoKPn7T9FtvbOWX8GxgsFFNwn Learn Python programming with GNS3. In this series of videos I will show you how you can quickly and easily program Cisco networks using Python. In this video we discuss how to write better code with the Python Style guide: https://www.python.org/dev/peps/pep-0008/ Transcription: This is one of multiple videos teaching you network programmability using Python and GNS3. This is a very useful document to breed PEP 8 - Style Guide for Python Code. A lot of people get hung up about how the way code is written and you'll often find debates and people flaming one another when code isn't written as neatly or as well as some people think it should be. Now again using the idea of get started and learn, you can always improve the readability of your code and improve as you go along. But this is a document worth reading to try and write better code. So one of the key insights taught here is that code is: read much more often than it is written so the idea of these guidelines is to improve the readability of code and make it consistent. So they say here style guide is about consistency, consistency with a style guide is important but consistency within a project is more important. Consistency within one module or function is the most important. If you don't know what a module is or a function, don't worry we'll talk about them later. But notice there are always exceptions. Know when to be inconsistent. Sometimes Style Guide recommendations are just not applicable. When in doubt, use your best judgment. Have a look at other examples and decide what looks best. Don't hesitate to ask. They give you some good reasons to ignore a particular guideline. So as an example ignore a guideline if your code is less readable. You may have to ignore the style guide to be consistent with old code. But you have some recommendations. Indentation is very important in Python so use 4 spaces per indentation level. They give you some recommendations for continuation lines. So as an example, this is good, but this is not good. There’s a section about tabs or spaces. Spaces are preferred, tabs should only be used to remain consistent with code that is already indented with tabs. Python 3 disallows the mixing of tabs and spaces for indentation. Python 2 code indented with a mixture of tabs and spaces should be converted to spaces exclusively. You can use the -t option with Python 2 to issue warnings about code that illegally mixes tabs and spaces. You can use the -tt option to make those warnings errors. These options are highly recommended. The maximum line length is 79 characters that is a recommendation based on historical reasons. So for flowing a long blocks of text with fewer structural restrictions, the line length should be limited to 72 characters that will allow you to open windows side-by-side so you can have multiple code windows open side-by-side. There are a lot of other recommendations in this document and as you code and are unsure about how to space or how to indent or how to write your code, refer back to this document. I've linked at it below this video. Here's one about string quotes. In Python single quoted strings and double quoted strings are the same. This PEP does not make a recommendation for this. Pick one rule and stick to it. When a string contains single or double quote characters, however use the other one to avoid backslashes in the string to improve readability. Here's some pet peeves about white space. So avoid white space if not needed. So this is good, this is not good, this is good, this is not good, this is good, this is not good and so forth and so on. To improve your code, have a look at to the style guide. When in doubt, refer to this. Lots of recommendations are provided here. I hope you enjoyed it this video. If you did, please like it and please subscribe to my YouTube channel. I wish you all the very best!
Views: 11714 David Bombal
Python 3.6 Tutorial #15(Docstrings, Annotations and the basics of PEP8)
 
11:29
In this videos we cover some minor things like comments, multi-line comments, Docstrings, annotations and cover what PEP8 is. Python | https://docs.python.org/3/tutorial/controlflow.html#documentation-strings My Website | https://www.itconnected.tech
Views: 1093 IT Connected
Learn Python Episode #15: User-Defined Functions
 
07:04
Get The Learn to Code Course Bundle! https://josephdelgadillo.com/product/learn-to-code-course-bundle/ Enroll in The Complete Python Course on Udemy! https://goo.gl/XW4Q1i Let's get into user-defined functions. Now, every programming language has functions, however they are going to look different depending on the language. If you have any experience with PHP or JavaScript, functions in Python are going to look similar. So, we are now past the need to use terminal, and from here on out we are going to use our IDE. In addition to functions, we are going to cover a few of the PEP guidelines. PEP is basically a style guide for the Python language, and the first thing we need to do is drop down two lines from the top of the script. To begin defining a function in Python, all you need to do is type the word "def". When naming functions we must be mindful of the PEP guidelines. With Python you will be using snake case, words separated with underscores, when naming your function. def my_function(): Within the parenthesis we can pass parameters into our function, then we end the line with a colon. So, now we have a function but it doesn't perform any actions, yet. def my_function(): print("This is my function!") print("A second string.") my_function() Now our function will print out two strings. Notice that our IDE automatically indents 4 spaces. When you indent in Python you are creating block of code. When we skip a line and remove the indentation, we are telling Python that our function is completed. Lastly, we will call our function. In the next video we will talk about arguments and how use them inside your function. Web - https://josephdelgadillo.com/ Subscribe - https://goo.gl/tkaGgy Follow for Updates - https://goo.gl/DPZvua
Views: 2107 Joseph Delgadillo
Python 3.5 Tutorial - Explaining The DocString
 
04:48
► SPONSORS ◄ DevMountain Coding Bootcamp https://goo.gl/P4vgKS .Tech domains https://goo.gl/6EnZmg Use Coupon Code - HISPERT18 - at checkout Get a domain: $4.99 for 1 year | $24.99 for 5 years My Latest Courses: https://www.udemy.com/user/christopher-hawkes-3/
Views: 11051 Chris Hawkes
[Python] Formatando código de acordo com a PEP 8
 
12:29
Esse vídeo explica alguns conceitos básicos do guia de estilos do Python, também conhecido como PEP8.
Views: 214 DrPexe
IPP M3, Python pep 8
 
21:33
Materia Modulo 3, parte 4 PEP-8, estándares
Views: 67 Sebastián Terán
What's the meaning of underscores (_ & __) in Python variable names?
 
06:01
https://dbader.org/python-tricks ► Make those underscores count and write clean and beautiful Python, by example Leading underscores in Python variable names (for example _foo and __foo) protect developers from naming conflicts. In this video you'll learn how to work with these Pythonic coding conventions and why they exist. A single underscore in front of a variable name (prefix) is a hint that a variable is meant for internal use only. A double underscore prefix causes the Python interpreter to rewrite the variable name in order to avoid naming conflicts in subclasses. Double underscores are also called "dunders" in Python. Watch the video tutorial to see the details of how double underscore name mangling works and how it affects your own Python classes. FREE COURSE – "5 Thoughts on Mastering Python" https://dbader.org/python-mastery SUBSCRIBE TO THIS CHANNEL: https://dbader.org/youtube * * * ► Python MUGS, T-SHIRTS & MORE: https://nerdlettering.com FREE Python Tutorials & News: » Python Tutorials: https://dbader.org » Python News on Twitter: https://twitter.com/@dbader_org » Weekly Tips for Pythonistas: https://dbader.org/newsletter » Subscribe to this channel: https://dbader.org/youtube
[PY101] 4.1 - Phong Cách Viết Mã (Code Style Guide) trong Python
 
17:41
Nội dung của video nói về phong cách trình bày source code trong Python theo chuẩn PEP8; cách cài đặt và cấu hình pep8 trong VSCode. Link tham khảo: https://www.python.org/dev/peps/pep-0008/ Học lập trình trực tuyến tại http://vnegg.com
Views: 358 VNEGG
Controversial PEPs You (Probably) Never Heard Of
 
05:25
Some PEPs never made it; others were quite controversial. Watch this talk to lean about these Python PEPs. EVENT: PyCon AU 2018 PERMISSIONS: Original video was published with the Creative Commons Attribution license (reuse allowed). CREDITS: Original video source: https://www.youtube.com/watch?v=rNkbmu4e3MA&t=1620s
Views: 3538 Coding Tech
CSC205 Pep/8 Trace Tag Walk Through
 
05:25
This video provides a demonstration of how the trace tags work in Pep/8, allowing you to have a visual representation of variables without having to look into the memory dump.
Views: 32 Scott Davis
FreeCAD Programming 101
 
25:01
Links shown in the video: The code repo (which also has most of these links): https://github.com/skaiser/D3D-Printer-Workbench. But, since that's under active development for an actual feature, see also https://github.com/skaiser/FreeCAD_Workbench_Starter FreeCAD scripting basics (super helpful): https://www.freecadweb.org/wiki/index.php?title=FreeCAD_Scripting_Basics FreeCAD python scripting tutorial: https://www.freecadweb.org/wiki/Python_scripting_tutorial PySide (i.e., QtGui in FreeCAD): https://www.freecadweb.org/wiki/PySide Some FreeCAD APIs: https://www.freecadweb.org/wiki/Category:API FreeCAD API class reference: https://www.freecadweb.org/api/annotated.html FreeCAD Mod Dev Guide PDF: https://github.com/qingfengxia/FreeCAD_Mod_Dev_Guide/tree/master/pdf FreeCAD source code: https://github.com/FreeCAD/FreeCAD FreeCAD Add-ons examples: https://github.com/FreeCAD/FreeCAD-addons Coin3D: https://bitbucket.org/Coin3D/coin/wiki/Home Python 2 documentation: https://docs.python.org/2/ Python PEP 8 Style Guide: https://www.python.org/dev/peps/pep-0008/
Views: 3978 Stephen Kaiser
Guido van Rossum - Type Hints for Python 3.5
 
46:14
Guido van Rossum - Type Hints for Python 3.5 [EuroPython 2015] [22 July 2015] [Bilbao, Euskadi, Spain] PEP 484, "Type Hints", was accepted in time for inclusion in Python 3.5 beta 1. This introduces an optional standard for specifying types in function signatures. This concept was previously discussed as "optional static typing" and I similar to the way TypeScript adds optional type declarations to JavaScript. In this talk I will discuss the motivation for this work and show the key elements of the DSL for describing types (which, by the way is backward compatible with Python 3.2, 3.3 and 3.4). Note: *Python will remain a dynamically typed language, and I have no desire to ever make type hints mandatory, even by convention!*
Views: 3983 EuroPython Conference
Part 7  PEP8 Loop
 
09:08
Views: 1135 Vipin Verma
My Python Code Looks Ugly and Confusing – Help!
 
05:49
LEARN MORE: https://dbader.org/blog/python-code-linting Automated code analysis tools can help you become a better Python developer quickly. In this video I'll explain what a code linter (like Pyflakes, Flake8, or Pycodestyle / Pep8) can do for you. Next I'll show you a few simple steps you can use immediately to run a code linter on your own Python programs. I'll also show you how to integrate linter feedback with your code editor (I'm using Sublime Text 3 in the video). This gives you immediate feedback on your Python code as you type it. I've seen great results from this technique. I believe it's one of the quickest ways to improve your Python skills. Give it a try and let me know how it went :) * In-depth guide for setting up Sublime Text (with integrated code linting and auto-completion for Python): https://SublimeTextPython.com * Flake8: https://pypi.python.org/pypi/flake8 * Pyflakes: https://pypi.python.org/pypi/pyflakes * Pycodestyle (former pep8): https://pypi.python.org/pypi/pycodestyle * Pylint: https://pypi.python.org/pypi/pylint * * * Shameless plug: If you want to get a Sublime Text setup just like the one in the video then check out my Sublime Text Setup Guide for Python Developers: https://SublimeTextPython.com 😊 ► Weekly Tips for Python Developers: https://dbader.org/newsletter
Evolution of autopep8 (Gource Visualization)
 
02:04
Gource visualization of autopep8 (https://github.com/hhatto/autopep8). A tool that automatically formats Python code to conform to the PEP 8 style guide.
Views: 99 Landon Wilkins
Pep8 Assembly - Reading in decimal numbers and adding with the accumilator
 
03:14
How to read in decimal numbers, and add them together in pep-8 simulated assembly code. Like and subscribe for more pep-8 tutorials!
Views: 719 GigaNetwork
Python GUI Frameworks (Guide)
 
04:50
https://dbader.org/python-tricks ► Learn how to write "developer style" Python, step-by-step What's the landscape for Python GUI frameworks and how can you use them to write graphical user interfaces using Python 2 or 3? In this video I'm covering a number of popular frameworks you can use to build Python GUIs: - TkInter (built into the Python standard library) - PyQt (Qt bindings for Python, available on PyPI) - Kivy (desktop + mobile GUI framework, available on PyPI) - BeeWare Project / PyBee (native desktop + mobile GUI framework, available on PyPI) - PyGame (Python game development framework) What's your favorite way of building GUI applications with Python? Leave a comment below and share your thoughts with us :) Tweet your Python and software dev career questions at me (@dbader_org) or leave a comment on this video and I'll try to cover your question in one of the next videos. FREE COURSE – "5 Thoughts on Mastering Python" https://dbader.org/python-mastery SUBSCRIBE TO THIS CHANNEL: https://dbader.org/youtube * * * ► Python Developer MUGS, T-SHIRTS & MORE: https://nerdlettering.com ► PythonistaCafe – A peer-to-peer learning community for Python developers: https://www.pythonistacafe.com FREE Python Coding Tutorials & News: » Python Tutorials: https://dbader.org » Python News on Twitter: https://twitter.com/@dbader_org » Weekly Tips for Pythonistas: https://dbader.org/newsletter » Subscribe to this channel: https://dbader.org/youtube
How to Pep 8.avi
 
01:08
pep8
Views: 242 MailaPT
03 Pep/8 Demo
 
02:52
Views: 401 Mark Holthouse
Pep8  Introduction to  Adding  Subtracting
 
05:32
This video is will show you how to add and subtract using Pep8. I used adda and suba commands to perform the operations.
Views: 2546 martin93003
Python Tutorial For Beginners - Part - 09 - Variables in Python
 
11:25
Python Tutorial For Beginners - Part - 09 - Variables in Python www.justlearnpython.com Just Learn Python Python Tutorial for Beginners Part-09 -Variables variable --------- constant , 10, 20,30 40 - which doesn’t change variable is an identifier whose value may change a = 10 a = 20 a = 30 Variables in Python -------------------- is a reference to a computer memory, where the value is stored. Unlike in other languages, in Python variable is just a label or reference. Variable in Python, doesn’t hold any value. age = 17 print(age) 'age' is a variable , which points a memory location where 17 is stored. Its value may change, during the course of time. age = 21 print(age) Some points to know about variables in Python. #1. can have different values during course of program. #2. Each value that a variable is pointing has an associated datatype. Like number, list, tuple, string, set etc. #3. Python is completely object oriented, and everything in python is an object That means variables, datatypes are also objects. #4. Dynamically typed and strongly typed programming language. Unlike in C , C++ or Java, there is no need to declare the data type for variable. #5. dynamically determines the type of data assigned to the variable. Let’s look at some examples Try assigning different values to same variable “price” price = 10 price = 10.50 price = "Alex" print(price) Naming rules for variables. --------------------------- 1.Variables names must start with a letter or an underscore a, x, _a, _x are valid variable names 2. From second letter onward may contain letters, numbers or underscores a, x, _a, _x , __a, __x , name, _name, __name, password, userName, user_name, password9 are all valid variable names. 3. Names are case sensitive name , Name, nAme, naMe, namE are all different variables. upper_case, UPPER_CASE, Upper_Case are different variables. Invalid variable names. 8user_name # variable name starting with number username# #variable name ending with special character '#' username) # variable name ending with special character ')' $username # variable name starting with special character '$' %username # variable name starting with special character '%' Are there any naming conventions ? ---------------------------------- Yes, apart form naming rules, some best practices are fallowed. Below are some naming conventions to start with. Naming conventions. 1.Python is known for readability. the variable names to be self descriptive. 2. You can use descriptive nouns, verbs with UnderScore, or camelCase style. Exmples: UnderScore style. user_name, pass_word, database_name or db_name, camelCase style. userName, passWord, dataBase, dbName etc.. more popular is the underscore style. 3. Avoid using the lowercase letter 'l', uppercase 'O', and uppercase 'I'. As 'l' and 'I' looks like digit 1 and 'O' looks like digit zero. 4. Avoid using double underscore variable such as __name__ these type variables are internally used by Python. Coding guidelines are detailed in PEP 8 — Style Guide for Python Code There are tools or modules that format your code to conform with pep 8, like autopep8 PEP stands for Python Enhancement Proposal. Here you can find list of PEPs , reading documentation is a vital part of python learning. You can start with PEP 8, 20, 257, 3099. What is flexible variable assignment ? Flexible Variable assignment. Python allows to assign multiple variable assignment in a single line. Examples: Assigning same value to variables a = b = c = 20 # a,b,c are variables assigned value 20 This is called chain loader assignment, where all variables refer to the same object. Try this on Python shell a = b = c = 20 Assigning different values to variables x,y = 45, 67 x,y = 45, 67 This is called parallel assignment. Assigning different values to variables t1 = 10,11,12 a, b, c = t1 # a,b,c are variables a is 10, b is 11, c is 12 This is called tuple unpacking assignment. More tuples in later section. a, b, c = t1 Assigning different datatypes to variables name, age ,salary = “Jennifer”, 26, 99000 #name, age, salary are variables. name, age ,salary = "Jennifer", 26, 99000 A variable can hold more than one value a = 10, 20, 50 #comma separated values are Tuples in python a (10, 20, 50) This is called tuple packing assignment. Just Learn Python All about Python programming, In this channel you will find videos related various Python programming topics, Like tutorials, Exercises, code snippets, Projects, tips and tricks of Python, Python best practices , Python tutorials, Real life examples, coding practices, interview questions.
Views: 51 Just Learn Python
PEP8 Standard
 
12:04
There's no right way to write Python code, but there is a way to make it easy to read. Follow these simple rules to help you out.
Views: 18 David Maruszewski

Novosemide 20 mg prednisone
Generico do viagra faz mal lavar
Palmeiras 0 x 1 internacional socialista
Erythromycin allergy and macrobid 100mg
Apo furosemide tab 80mg