Python is a versatile language that you can use on the backend, frontend, or full stack of a web application. The main topics in Python are:
* Web development
* Data science
* Machine learning
* Cyber security
* Game development.
Functions. Functions are building blocks in Python
Functions are one of the most important concepts in programming, and they are essential in Python. Functions are a way to group together related code so that it can be reused. They can take arguments and return values, which makes them very powerful.
Functions are usually defined in a module, which is a file that contains Python code. A module can contain multiple functions, and a function can be called from any other Python code, including from within another function. This makes it easy to create small programs that do one thing well, or large programs that do many things.
When you call a function, Python will execute the code inside the function and then return any values that the function produces. If a function doesn’t return anything explicitly, it will return None .
Positional and keyword arguments
When calling a Python function, there are two ways to pass arguments: positional and keyword. Positional means that the order of the arguments is important, and they will be mapped to the parameters in order from left to right. For example, if we have a function defined like this:
Articles of Interest:
def print_message(msg): print(msg) And we call it like this:
print_message(“Hello world!”) The “Hello world!” string will be assigned to the msg parameter inside the print_message() function, and then printed out. So our output would be: Hello world!
Keyword means that we specify which parameter each argument should be assigned to by name. For example, if we have a different print_message() function defined like this: def print_message(msg 1, msg 2): # different parameter names! print(msg 1 + msg 2) # different operation now let’s say we want to swap around which message is printed first. We could do that by using keyword arguments when we call the function like this:
print_message(msg 2=”Hello “, msg 1=”world!”)# note how they’re reversed compared to how they appear in the definition the output would now be: world! Hello
We can also mix positional and keyword args when calling functions, like this:
print_message(“Hello”, msg 2=”world!”)In this case, “Hello” is assigned to the msg 1 parameter (because it’s in position 1), and “world!” is assigned to msg 2 (because it’s specified by name). The output would still be: world! Hello.
“Python is a great language for beginners because it is easy to read and understand. It is also a powerful language that can be used for many different
10 Examples to Master *args and **kwargs in Python
Python supports two special argument types that are incredibly useful-and can save you a lot of time! These are *args and **kwargs, and we’re going to take a look at what they are, how they work, and some examples of their usage.
So what exactly are *args and **kwargs? *args is short for “argument tuple”, while **kwargs is short for “keyword arguments”. Both of these allow you to pass an arbitrary number of arguments to a function (or method). The main difference between the two is that *args allows you to pass the arguments as a tuple, while **kwargs allows you to pass them as keywords.
Let’s take a look at some examples to see how this works in practice. We’ll start with a simple example using *args:
def my_func(* args): print (type( args)) #prints
my_func(‘a’,’b’,’c’)
As you can see, we defined a function called my_func that takes an arbitrary number of arguments. We then printed out the type of args (which is a tuple), as well as the contents of args. When we call my_func with three arguments (‘a’, ‘b’, and ‘c’), it prints out:
(‘a’, ‘b’, c’)
Notice how the three arguments we passed in become elements of a tuple when they’re passed to our function! This is because *args accepts any number of positional arguments and packs them into one tuple. So if we call my_func with no arguments, or one argument, or tenarguments-it will always return one tuple containing all of those arguments (or an empty tuples if there were noarguments).
11 Must-Know Operations to Master Python Lists
Python lists are one of the data structures that you will come across frequently when working with data in Python. In this article, we’ll go over 11 must-know operations for Python lists so that you can master them.
1. Creating Lists
There are a couple different ways to create lists in Python. The first is by using the list keyword followed by a set of square brackets containing items separated by commas:
>>> my_list = [1, 2, 3]
You can also create lists using the built-in list() function:
>>> my_list = list([1, 2, 3]).