Python training in Chennai

What Is Django And Why Is It So Popular?

January 25, 2019 mouniyoga

Django is a network based Python, which means that it is used primarily on Python’s website. encouraging rapid development and protecting clothing and cleaning.

Why Is It So Popular?

Django is a Web Python format that encourages high-speed development and pure, genuine design. Structure of web applications is a device consisting of all forms of Web applications required. The goal here is to allow development, rather than implement the same frequency routine repeatedly, focus on the most up-to-date applications of your own projects in the project.

In fact, Django is full of other features. It deals with the many problems of development, allowing you to focus on your application without the permission to cripple the wheels. It’s free. In addition, Django’s system allows you to format your domain and code classes, and before you know, you already have a ORM. Let’s look at a recent vision that is well understood by your understanding.

It is time-tested:

In many cases, you will see that Django is one of the first ways to respond to the new crisis. Your important group is aware of other ways to do it. There are many things to say about Django’s stability. Although no one claims that all the wrong errors were correct, most of them have. Today, many Django journalists focus on issues on the limits and new features. Perhaps the program does not call a teenager, but generally making good decisions.

You have access to enough Django packages

Django community, such as the Python community has a lot of packs and bills that benefit from the global use. Write “Django” in PyPI and will see more than 4,000 packs ready for use, and this is on top of the battery “Django. The building will cover everything you want.

It’s been crowd-tested

Python and Django seem to be a little silent, with metal and noodles, which get a lot of reputation among users larger. Of course, this does not mean that some important names do not use Django. Django handles the most used websites such as Instagram and Pinterest, and even Facebook uses Django for their utility companies. Django came from printing, so it’s not surprising that such sites like Washington Post and Smithsonian Magazine use Django.

Django has wonderful documentation

Django came into the world with letters above the usual standard of open source projects, and just to improve time. First came out, the very best letters were one of the features that had to be split Django. Most other methods are used at that time only for the first list of modules and all methods and features.

This works well with immediate reference, but does not help when you have to find the foot for the first time. The Django Quality Paper is not specific, but still to be sure of one of the best examples of the open code world open. Possession of the documents is always anxious about the development of Django. You see, the documents are a great Django world-class citizen.

The Django community is hugely supportive

It has often been said that the community is one of the world’s best in the world to pray, even more realistic in the world of Django. Django is managed by Django Software Foundation or DSF. Any incident involving Django has a traditional rule. In fact, DSF has released statements on various, taking a place in the community of the kind of community they think.

There are many associations, such as the IRC list and debate and peace sometimes in the sun. Here, you will find them very well. Of course, there are sometimes cheaper apples, but quickly something held. Thank you for these policies, many favorite Django Girls are very good.

Django advocates best practices for SEO

Web and SEO development is not always legal. Scientific and technological works often seem contradictory. For Django, you should get this problem. If not, Django Python’s structure has been using the use of URLs for human readers, helping search engine and not only useful in the view of the actual user, but using keywords in the URL of the user to separate sites . The SEO team will be very grateful. Furthermore, it makes sense to ensure that URLs are not the right type of serial numbers written in a letter that means something somewhere.

Scalability

Of course, Django is a good thing to start and, surprisingly, great when it comes to too much size. Django, the core of his series, is a series of segments, which are connected to the use of the elderly. Now, these subjects have been deleted, this does not depend on one another, they can be deleted and replaced when they begin to require specific solutions.

Security

Django, apart from, prevents many errors than PHP. To start it, Django puts it in place or puts it on the website of your website which effectively produces web pages and uses the online textbooks online.

Finally, there are some things called how Django works for the market. Or better, the lack of business long-term. At least it is not a special way, we say, the cars sold. Until then, marketing efforts were made up of most PyCon negotiations, bloggers, and then only working on the structure, building abnormalities and allowing the results to be announced. Now, of course, there is DjangoCon and DSF and business advisors who are doing training sessions and many books and the rest, but all are still new. At the end of the day, the above points are some of the key points behind the growing Django movie seen from the beginning.

Python – Functions

January 25, 2019 mouniyoga

Functions is a structured and reusable organization that is used to perform only practical action. The Python Function will regularly make your application and a higher level of reuse.
As you have already learned, Python offers many local functions such as print (), etc., but you can also create your own work. These staff are called user-defined.

Defining a Function

You can describe jobs to pay for necessary work. Here are some simple rules to describe Python’s activities.

The types of activity begin with the main language followed by the name of the job and the cards ().
All borders or panels should be placed inside. You can also do the holes in these articles.
The first evidence of action can be voluntary training – documented work document or document.
The pulse code for each function starts with a clot (:) and goes backwards.
The return statement
This slideshow could not be started. Try refreshing the page or viewing it in another browser.
deletes the action, submitting it voluntarily to the applicant. Evidence of return without any argument is the same.

Syntax:

def functionname( parameters ):
   "function_docstring"
   function_suite
   return [expression]

If they do not appreciate, the boundaries have a temporary nature and it is necessary to report the same as described.

For example

The next task uses a string like a cordless print on the screen.

def printme( str ):
   "This prints a passed string into this function"
   print str
   return

Calling a Function:

The definition of the job gives name, defines the boundaries that need to be included in the waste disposal and the structure of the waste.

Become a Python Certified Expert in 25Hours

When the basic structure of the task is finished, you can kill it by calling another activity or directly on the Python chart. Next, for example, you should call the print action ()

#!/usr/bin/python
# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print str
   return;
# Now you can call printme function
printme("I'm first call to user defined function!")
printme("Again second call to the same function")

When the previous code is implemented, it produces the following results –

I'm first call to user defined function!
Again second call to the same function

Call by Reference vs Value

All the boundaries of the Python language are referred to as references. This means that if you change the boundaries of the technology, the change also returns to the call functions. For example –

#!/usr/bin/python
# Function definition is here
def changeme( mylist ):
   "This changes a passed list into this function"
   mylist.append([1,2,3,4]);
   print "Values inside the function: ", mylist
   return
# Now you can call changeme function
mylist = [10,20,30];
changeme( mylist );
print "Values outside the function: ", mylist

Here, we keep referring to previous items and adding value to the same thing. After this, this will produce the following results –

Values inside the function:  [10, 20, 30, [1, 2, 3, 4]]
Values outside the function:  [10, 20, 30, [1, 2, 3, 4]]

Function Arguments:

You can call technique using the following types of formal arguments:

Required Arguments
Keyword Arguments
Default Arguments
Variable Length Arguments

Required Arguments:

The necessary arguments are the arguments that have been submitted to the appropriate action in the correct position. Here, the number of calls to the call must correctly define the activities.
To call the publishing task (), you must properly log in, otherwise, give the error device the following –

#!/usr/bin/python
# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print str
   return;
# Now you can call printme function
printme()

When the previous code is implemented, it generates the following results –

Traceback (most recent call last):
   File "test.py", line 11, in <module>
      printme();
TypeError: printme() takes exactly 1 argument (0 given)

Keyword Arguments:

The term debate depends on call activities. When you use the key arguments in the action, the caller describes the arguments using the name of the control.
This will allow you to ignore the debate or post an order because the Python interpreter can use the displayed words to match the value of the boundary. You can also make important calls about print jobs () in the following ways:

#!/usr/bin/python
# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print str
   return;
# Now you can call printme function
printme( str = "My string")

When the previous code is implemented, it generates the following results –

My string

Default Arguments:

The common argument is a debate that is assumed to be a standard value if there is no value in the ‘debate’. The following examples give you an idea of how to debate the debate, it will generate the normal age if not exempt –

#!/usr/bin/python
# Function definition is here
def printinfo( name, age = 35 ):
   "This prints a passed info into this function"
   print "Name: ", name
   print "Age ", age
   return;
# Now you can call printinfo function
printinfo( age=50, name="miki" )
printinfo( name="miki" )

When the previous code is implemented, it generates the following results –

Name:  miki
Age  50
Name:  miki
Age  35

Variable Length Argument:

It may be necessary to solve the many arguments you have described as defined in the work. These discussions are called adventurous arguments that are not defined in the definition of action, which is different from those for which they are needed.

Get Python Online Certification Training

Articles for non-argumentative arguments for this –

def functionname([formal_args,] *var_args_tuple ):
   "function_docstring"
   function_suite
   return [expression]

The Anonymous Function:

These jobs are called unspecified names because they are not mentioned in the standard method of keyword. You can use lambda lamb to create confidential jobs.

Lamb Number can have any number of arguments, but only return the value of the sound. They can not take orders or comments.
Confidential work can not be a direct and printed call because the Lamb needs a talk.
Number number jobs have their own local advertisements and can not access other variables other than their strategic list and domain names.
Although it appears that the Lamb is a single-line function, it does not correspond to the C or C ++ guidelines, and their purpose is to pass the assignment process during the application for performance reasons.

Syntax:

The numbers in the lamb numbers contain only one sign, which is the following:

lambda [arg1 [,arg2,.....argn]]:expression

Below is an example of how the Lamb works –

#!/usr/bin/python
# Function definition is here
sum = lambda arg1, arg2: arg1 + arg2;
# Now you can call sum as a function
print "Value of total : ", sum( 10, 20 )
print "Value of total : ", sum( 20, 20 )

When the previous code is implemented, it generates the following results –

Value of total :  30
Value of total :  40

Return Statement:

The return statement [show] leaves the job, preferring a proposal for the call. Evidence of return without any argument is the same.

Learn Python From Experts at Besant Technologies

All previous models did not return any value. You can repeat the value of the performance in the following –

#!/usr/bin/python
# Function definition is here
def sum( arg1, arg2 ):
   # Add both the parameters and return them."
   total = arg1 + arg2
   print "Inside the function : ", total
   return total;
# Now you can call sum function
total = sum( 10, 20 );
print "Outside the function : ", total

When the previous code is implemented, it generates the following results –

Inside the function :  30
Outside the function :  30

The scope of Variable:

All program variables may not be all programs in the program. This depends on where you declared the variable.
The scope of the change determines part of the program that you can get specific identification. There are two basic components in Python –

Global Variable
Local Variable

Global Vs Local Variable:

The changes described in FGM have the local area definition described in the international dimension.
This means that local variables are available only for the announced activities, while the global change is available in all parts of the program. When the action is called, the alterations in the sound are placed in size. Here is a simple example –

#!/usr/bin/python
total = 0; # This is global variable.
# Function definition is here
def sum( arg1, arg2 ):
   # Add both the parameters and return them."
   total = arg1 + arg2; # Here total is local variable.
   print "Inside the function local total : ", total
   return total;
# Now you can call sum function
sum( 10, 20 );
print "Outside the function global total : ", total

When the above code is executed, it produces the following result −

Inside the function local total :  30
Outside the function global total :  0

Python – Date & Time

January 9, 2019 mouniyoga

Python – Date & Time

The Python program can Handle on date and time in many ways. Changes in data structures are a normal process for the computer.Python’s time and calendar modules help track dates and times.

What is Tick?

Scores points for points in second. For a few minutes, in particular, the time period was shown in seconds from 12:00 to 1 January 1970 (time).
There is a popular module available from Python which provides collaborative work to change the representation schedule. Time time. () returns at the time of the ticketing system until 00:00, January 1, 1970 (time).

Become a Python Certified Expert in 25Hours

Example:

#!/usr/bin/python
import time;  # This is required to include time module.
ticks = time.time()
print "Number of ticks since 12:00am, January 1, 1970:", ticks

This will result in such a result –

Number of ticks since 12:00am, January 1, 1970: 7186862.73399

It is easy to create an accounting history with ticks. However, before it can be explained in this way. The future can not be unified in the same way – the shortest stage in the 2038 UNIX and Windows stages.

What is TimeTuple?

More time Python times to deal with time tuple of 9 numbers, as shown in the following –

Index	Field	Values
0	4-digit year	2008
1	Month	1 to 12
2	Day	1 to 31
3	Hour	0 to 23
4	Minute	0 to 59
5	Second	0 to 61 (60 or 61 are leap-seconds)
6	Day of Week	0 to 6 (0 is Monday)
7	Day of year	1 to 366 (Julian day)
8	Daylight savings	-1, 0, 1, -1 means library determines DST

above the same structure structure. This property has the following characteristics –

Index	Attributes	Values
0	tm_year	2008
1	tm_mon	1 to 12
2	tm_mday	1 to 31
3	tm_hour	0 to 23
4	tm_min	0 to 59
5	tm_sec	0 to 61 (60 or 61 are leap-seconds)
6	tm_wday	0 to 6 (0 is Monday)
7	tm_yday	1 to 366 (Julian day)
8	tm_isdst	-1, 0, 1

Getting Current Time?

To translate again the second measurement value for the length of time points, beyond the cost of the working circle (for example, local time), and return to the tuple of time and the nine correct points.

#!/usr/bin/python
import time;
localtime = time.localtime(time.time())
print "Local current time :", localtime

This will lead to lower down link, which can be set in a better way –

Local current time : time.struct_time(tm_year=2013, tm_mon=7, 
tm_mday=17, tm_hour=21, tm_min=26, tm_sec=3, tm_wday=2, tm_yday=198, tm_isdst=0)

Getting Formatted Time

You can format any time according to your needs, but a simple way to get the time to read is ascending () –

#!/usr/bin/python
import time;
localtime = time.asctime( time.localtime(time.time()) )
print "Local current time :", localtime

This will yield low productivity –

Local current time : Tue Jan 13 10:17:09 2009

Get a Calendar of months

The Timesheet provides a variety of ways to play the annual and monthly calendar. Here is the monthly posting of the monthly newsletter (January 2008) –

#!/usr/bin/python
import calendar
cal = calendar.month(2008, 1)
print "Here is the calendar:"
print cal

This will yield low productivity –

Here is the calendar:
   January 2008
Mo Tu We Th Fr Sa Su
    1  2  3  4  5  6
 7  8  9 10 11 12 13
14 15 16 17 18 19 20
21 22 23 24 25 26 27
28 29 30 31

The Time Module

There is a popular module available at Python which provides working to work and convert the museums. Below is a list of all available methods –

Learn Python From Experts at Besant Technologies

Sr.No.	Function with Description
1	time.altzoneThe offset of the local DST timezone, in seconds west of UTC, if one is defined. This is negative if the local DST timezone is east of UTC (as in Western Europe, including the UK). Only use this if daylight is nonzero.
2	time.asctime([tupletime])Accepts a time-tuple and returns a readable 24-character string such as ‘Tue Dec 11 18:07:14 2008’.
3	time.clock( )Returns the current CPU time as a floating-point number of seconds. To measure computational costs of different approaches, the value of time.clock is more useful than that of time.time().
4	time.ctime([secs])Like asctime(localtime(secs)) and without arguments is like asctime( )
5	time.gmtime([secs])Accepts an instant expressed in seconds since the epoch and returns a time-tuple t with the UTC time. Note : t.tm_isdst is always 0
6	time.localtime([secs])Accepts an instant expressed in seconds since the epoch and returns a time-tuple t with the local time (t.tm_isdst is 0 or 1, depending on whether DST applies to instant secs by local rules).
7	time.mktime(tupletime)Accepts an instant expressed as a time-tuple in local time and returns a floating-point value with the instant expressed in seconds since the epoch.
8	time.sleep(secs)Suspends the calling thread for secs seconds.
9	time.strftime(fmt[,tupletime])Accepts an instant expressed as a time-tuple in local time and returns a string representing the instant as specified by string fmt.

The Calendar Module

The Distribution Unit will provide activities related to the calendar, including calendar work to publish monthly or annual scripts.

Get Python Online Certification Training

At the usual time, the time is Monday, the first day of the week with the box. To change this, call the Job Calendar .setfirstweekday ().
Here is a list of available jobs and the AC module –

Sr.No.	Function with Description
1	calendar.calendar(year,w=2,l=1,c=6) Returns a multiline string with a calendar for year year formatted into three columns separated by c spaces. w is the width in characters of each date; each line has length 21w+18+2c. l is the number of lines for each week.
2	calendar.firstweekday( ) Returns the current setting for the weekday that starts each week. By default, when calendar is first imported, this is 0, meaning Monday.
3	calendar.isleap(year) Returns True if year is a leap year; otherwise, False.
4	calendar.leapdays(y1,y2) Returns the total number of leap days in the years within range(y1,y2).
5	calendar.month(year,month,w=2,l=1) Returns a multiline string with a calendar for month month of year year, one line per week plus two header lines. w is the width in characters of each date; each line has length 7*w+6. l is the number of lines for each week.
6	calendar.monthcalendar(year,month) Returns a list of lists of ints. Each sublist denotes a week. Days outside month month of year year are set to 0; days within the month are set to their day-of-month, 1 and up.
7	calendar.monthrange(year,month) Returns two integers. The first one is the code of the weekday for the first day of the month month in year year; the second one is the number of days in the month. Weekday codes are 0 (Monday) to 6 (Sunday); month numbers are 1 to 12.
8	calendar.prcal(year,w=2,l=1,c=6) Like print calendar.calendar(year,w,l,c).
9	calendar.prmonth(year,month,w=2,l=1) Like print calendar.month(year,month,w,l).

Other Modules and Functions:

If you like, then here is a list of other parts that led to the date and time of Python –

Date and time module
Pytz’s format
Date of the date

What Is Django And Why Is It So Popular?

December 25, 2018 mouniyoga

What Is Django And Why Is It So Popular?

Django is a network based Python, which means that it is used primarily on Python’s website. encouraging rapid development and protecting clothing and cleaning.

Why Is It So Popular?

Enroll Now: Python Training in Chennai

It is time-tested:

You have access to enough Django packages

It’s been crowd-tested

Django has wonderful documentation

The Django community is hugely supportive

Enroll Now: Python Training in Bangalore

Django advocates best practices for SEO

Scalability

Security

Python break, continue and pass Statements

December 25, 2018 mouniyoga

Python break, continue and pass Statements

Python offers a break and continues to control such cases and has good control over your circle.This training will address the breaking of sentence, continue to make Python.

Introduction:

Using circles and circuits in Python will allow you to work on tasks and benefits.
But sometimes external factors can affect the way the program works. When this happens, you may want to make a program that you have finished the drawer, jumping from the front door before continuing to ignore the external issues. You can do these steps and breakthroughs, breaking and forwarding.

What is the use of Break and continue in Python?

Python, Break and continue of the declaration can change the usual cycle.
Loops to repeat the border number until the test scan is false, but we always want to end the current or even the whole circle without judging the test scores.
Holidays and sentences are still in use in this case.

The Break Statement:

Python’s breach of the sentence has ended in the velocity of the current and subsequently restarting judgment, with the exception of traditional breed found in C.
The maximum use is determined when some conditions are outdoors, which need to be removed immediately. The text can be used to break the cycle time.
For example:

#!/usr/bin/python

for letter in 'Python':     # First Example

   if letter == 'h':

      break

   print 'Current Letter :', letter

var = 10                    # Second Example

while var > 0:             

   print 'Current variable value :', var

   var = var -1

   if var == 5:

         break

print "Good bye!"

This will produce the following results:

Current Letter : P

Current Letter : y

Current Letter : t

Current variable value : 10

Current variable value : 9

Current variable value : 8

Current variable value : 7

Current variable value : 6

Good bye!

The continue statement:

Python’s text repeats the control of the start-up period. It repeatedly denies all the statements contained in the repeated tactile tactics and control of the control of the cycle.
The text occurred to be used during the cycle.
For example:

#!/usr/bin/python

for letter in 'Python':     # First Example

   if letter == 'h':

      continue

   print 'Current Letter :', letter

var = 10                    # Second Example

while var > 0:             

   var = var -1

   if var == 5:

      continue

   print 'Current variable value :', var

print "Good bye!"

This will produce the following results:

Current Letter : P

Current Letter : y

Current Letter : t

Current Letter : o

Current Letter : n

Current variable value : 10

Current variable value : 9

Current variable value : 8

Current variable value : 7

Current variable value : 6

Current variable value : 4

Current variable value : 3

Current variable value : 2

Current variable value : 1

Good bye!

The Else Statement used with Loops:

• If other proofs are used in the circle, the other statement will be applied to the list of the lists.
• If there are other leaflets used during the cycle, this statement will be enforced when the other terms are false.
For example:
The following examples illustrate the combination of other indicators to obtain the basic numbers 10 to 20.

#!/usr/bin/python

for num in range(10,20):  #to iterate between 10 to 20

   for i in range(2,num): #to iterate on the factors of the number

      if num%i == 0:      #to determine the first factor

         j=num/i #to calculate the second factor

         print '%d equals %d * %d' % (num,i,j)

         break #to move to the next number, the #first FOR

   else:        # else part of the loop

      print num, 'is a prime number'

This will produce the following results:

10 equals 2 * 5

11 is a prime number

12 equals 2 * 6

13 is a prime number

14 equals 2 * 7

15 equals 3 * 5

16 equals 2 * 8

17 is a prime number

18 equals 2 * 9

19 is a prime number

So you can do any other appearance of loop while ringing.

The Pass Statement:

Written statement is passed on to Python as used when the evidence is required in the same way, but you do not want to order all orders or sounds.
Guidelines for use are invalid; nothing happened if done. It also benefits from areas where the code is likely to be, although not written (for example, lists, for example):
For example:

 #!/usr/bin/python

for letter in 'Python':

   if letter == 'h':

      pass

      print 'This is pass block'

   print 'Current Letter :', letter

print "Good bye!"

This will produce the following results:

 Current Letter : P

Current Letter : y

Current Letter : t

This is pass block

Current Letter : h

Current Letter : o

Current Letter : n

Good bye!

The law did not carry any evidence or letter in the case of ‘h’. The last statement is useful if you make a block of code, but there is no need.
After that you can delete the instructions in the block, but leave the normal block, so that it does not interfere with other parts of the number.

Python Modules

November 27, 2018November 27, 2018 mouniyoga

Python Modules

In this article, you will learn how to create and download a custom Python module. In addition, there are various techniques for the import and use of the inner module and the Python technology.

What are the modules in Python?
How to import modules in Python?
- Python import statement
- Import with renaming
- Python from…import statement
- Import all names
Python Module Search Path
Reloading a module
The dir() built-in function

What are the modules in python?

The module refers to the files that contain Python’s description and description.

For example, in the Python code, for example, for example, it is called modules and name module and will be an example.

We use the software system to suppress large files in smaller and manageable areas. In addition, the code gives the code reuse.

We can determine our most commonly used module and import, rather than the definition of its various programs.

We want to make a module. Write the following as an example.

# Python Module example

def add(a, b):

“””This program adds two

numbers and return the result”””

result = a + b

return result

How to import modules in Python?

We can refer to the process of defining another way or interpersonal interaction with Python.

We use the keyword import tool to do this. To download the pre-defined system of people listed in the Python origin background.

>>> import example

This does not include the names of jobs described in the laboratory directly on the current table. Just enter the name of the module in the module.

By using the module name you can get the time (.) Functionality. For example:

>>> example.add(4,5.5)

9.5

Python import statement:

We can download the module from the import report and find the employer’s description using the site as described above. Below is an example.

# import statement example

# to import standard module math

import math

print(“The value of pi is”, math.pi)

Once the program is implemented, production will be:

The value of pi is 3.141592653589793

Import with renaming:

I can output the module when changing the name in the following way.

# import module by renaming it

import math as m

print(“The value of pi is”, m.pi)

Python from…import statement:

We can extract the names of specific formats without deleting the full module. Below is an example.

# import only pi from math module

from math import pi

print(“The value of pi is”, pi)

We have just downloaded the module.

For example, if we use the company. We can produce several of these features.

>>> from math import pi, e

>>> pi

3.141592653589793

>>> e

2.718281828459045

Import all names:

We can generate all the names (definitions) of the module using the following format.

# import all names from the standard module math

from math import *

print(“The value of pi is”, pi)

Python Module Search Path:

When you download the module, Python searches in several places. English first searches for complex and subsequent (if found) list of advisers identified in your check. Find out in this series.

Current record.
PYTHONPATH (variable with a book list).
The connected installation system.

>>> import sys

>>> sys.path

[”,

‘C:\\Python33\\Lib\\idlelib’,

‘C:\\Windows\\system32\\python33.zip’,

‘C:\\Python33\\DLLs’,

‘C:\\Python33\\lib’,

‘C:\\Python33’,

‘C:\\Python33\\lib\\site-packages’]

Reloading a module:

Translation interpreter for Python interpreter only. This makes it useful. Below is a guide to show how this is.

Tell us we have the following code in the module called my_module.

# This module shows the effect of

# multiple imports and reload

print(“This code got executed”)

Now we see the impact of the importance.

>>> import my_module

This code got executed

>>> import my_module

The dir() built-in function:

We can use the dir () function to find the name of the course in the module.

For example, we will have another function () in the example of the module we started.

>>> dir(example)

[‘__builtins__’,

‘__cached__’,

‘__doc__’,

‘__file__’,

‘__initializing__’,

‘__loader__’,

‘__name__’,

‘__package__’,

‘add’]

Here, we can see a list of names that are separated (accompanied by coordination). All other names are based on the features that come under the characteristics of the standard Python module (we do not know ourselves).

For example, __name__ the attribute contains the name of the module.

>>> import example

>>> example.__name__

‘example’

All the names defined in the name, which can now be omitted from the use of dir () for no reason.

>>> a = 1

>>> b = “hello”

>>> import math

>>> dir()

[‘__builtins__’, ‘__doc__’, ‘__name__’, ‘a’, ‘b’, ‘math’, ‘pyscripter’]

Python Global Keyword

November 26, 2018 mouniyoga

In this article, you will learn a lot about important international roles, the world, and the use of an important global keyword.

Python global Keyword
- Rules of global Keyword
- Use of global Keyword (With Example)
Global Variables Across Python Modules
Global in Nested Functions in Python

Before reading this article, be sure to have some of the Global Python foundations inside and outside.

Python global Keyword:

In Python, the important international word allows the change of variables outside of the scope of today. It is used to make global variables and variables to create a change in the environmental situation.

Rules of global Keyword:

Basic rules for the keyword in Python are:

If we make changes to work, which is at a level.
If a variable is left out of the operation, which is an international standard. You should not use the important international word.
We use words that are keywords for reading and writing across the globe through international staff.
Use the important international agenda items to deal with

Use of global Keyword (With Example):

Let’s take an example.

Example 1: Accessing global Variable From Inside a Function

c = 1 # global variable

def add():

print(c)

add()

When we implement the old program, productivity will be:

However, we can have several behaviors that we have to make a big difference in the world.

Example 2: Modifying Global Variable From Inside the Function

c = 1 # global variable

def add():

c = c + 2 # increment c by 2

print(c)

add()

When we implement the old program, the result shows the error:

UnboundLocalError: local variable ‘c’ referenced before assignment

This is because we can only access global variables, but can not change internal processing.

The world’s most important solution to keywords.

Example 3: Changing Global Variable From Inside a Function using global

c = 0 # global variable

def add():

global c

c = c + 2 # increment by 2

print(“Inside add():”, c)

add()

print(“In main:”, c)

When we implement the old program, productivity will be:

Inside add(): 2

In main: 2

The first program we made was how the world’s key elements in the add () function work.

Then, the lowest value is c 1, c = c + 2. Then, we call an action (). Finally, we consider global change c.

As we have seen, the trends have also affected international outcomes over the work, c = 2.

Global Variables Across Python Modules:

In Python, we create one module to configure global variable config.py and share information through the Python module in the same program.

Here’s how we can share global variables through Python methods.

Example 4: Share a global Variable Across Python Modules

Make config.py files, to store global variables

a = 0

b = “empty”

Create an update.py file, change a global variable

import config

config.a = 10

config.b = “alphabet”

Make the main.py file, to test the price change

import config

import update

print(config.a)

print(config.b)

When we download the main.py file, the product will be

alphabet

Above, we run three files: config.py, update.py main.py.

The Config.py section stores a general trend and b. Update.py in the file, which provides the config.py method and retains a and b value. Also, the main.py file will release parts and update.py config.py. Finally, the value of international print media is analyzed, and whether it is changed or not changed.

Global in Nested Functions in Python:

Here is how you can use global variables that work in the ongoing activities.

Example 5: Using a Global Variable in Nested Function

def foo():

x = 2

def bar():

global x

x = 25

print(“Before calling bar: “, x)

print(“Calling bar now”)

bar()

print(“After calling bar: “, x)

foo()

print(“x in main : “, x)

When we implement the old program, productivity will be:

Before calling bar: 20

Calling bar now

After calling bar: 20

x in main: 25

In the first program, we call the global variable (function) (). The movement off (), x has an important international influence.

Before and after the call block (), the variable x takes a value, the variables in the x = 20. External f (), variable x will receive the value defined by a (), x = 25. This is the reason we used the variables of the keywords x in the production of the international workplace () (the area boundaries).

If we make changes to all the bar () function, this change seems to be fast, that is, foo ().

Python Global, Local and Nonlocal variables

November 24, 2018 mouniyoga

Python Global, Local and Nonlocal variables

In this article, you will learn variable Python as variable nonlocal variable and where used.

Global Variables in Python
Local Variables in Python
Global and Local Variables Together
Nonlocal Variables in Python

Global Variable in Python:

Python, a declaration of change outside of the work or scope of international variable variables known worldwide. This means international variables are available inside or outside of the activity.

Let’s see examples of how an international change has been created in Python.

Example 1: Create a Global Variable

x = “global”

def foo():

print(“x inside :”, x)

foo()

print(“x outside:”, x)

When we codify the code, an output will be:

x inside : global

x outside: global

In the preceding lines, we create a variable x which defines foo () that will print x variable. Finally, we call an f () value x will be published.

What if you want to change the value of x inside?

x = “global”

def foo():

x = x * 2

print(x)

foo()

When we codify the code, an output will be:

UnboundLocalError: local variable ‘x’ referenced before assignment

The output shows errors because it is about Python x as a variable and x is not defined in the foo ().

Use this task by using the global keyword, to find out more and visit the keyword in Python.

Local Variables in Python:

A description of the physical function or the size of the local changes is known locally.

Example 2: Accessing local variable outside the scope

def foo():

y = “local”

foo()

print(y)

When we codify the code, an output will be:

NameError: name ‘y’ is not defined

The output shows the error because we are trying to locate internal changes and international and local changes just like the foo () or local boundary.

Let’s see examples of how Python created local changes.

Example 3: Create a Local Variable

Usually, we can declare functional variables to create a local change.

def foo():

y = “local”

print(y)

foo()

When we vote in the code, it will be:

local

Let’s look at previous problems, x is an international animal and we want to change x ().

Global and Local Variables Together:

Next, it will show you how to use international variables and internal code changes are the same.

Example 4: Using Global and Local variables in the same code

x = “global”

def foo():

global x

y = “local”

x = x * 2

print(x)

print(y)

foo()

When we codify the code, an output will be:

global global

local

In the preceding code, we declare x and y as an international variable such as the local variable (). Next, we use multilanguage staff * alter global variable x and print x and y both.

After you call the foo (), the value x is the world because x * 2 is used to print twice in the world. After that, we publish the local value-added change.

Example 5: Global variable and Local variable with the same name

x = 5

def foo():

x = 10

print(“local x:”, x)

foo()

print(“global x:”, x)

When we codify the code, an output will be:

local x: 10

global x: 5

In the previous article, the same name has been used both in terms of internal changes and international trends. I get different results when the same changes are printed because the variables are specified on both sides, that is, inside () and outside the scope of the world (foo).

When printing non-inside (), which comes out of x: x 10, it is called the size of the local stock.

Also, when we print the () variable (x), the global x-ray of x: 5, known as the ‘global’ scale.

Nonlocal Variables in Python

Non-residential changes used in intermediate activities are not defined in the environment. This means that variables can be maintained locally or internationally.

Let’s see examples of how an international change has been created in Python.

We use keywords to make non-volatile variables.

Example 6: Create a nonlocal variable

def outer():

x = “local”

def inner():

nonlocal x

x = “nonlocal”

print(“inner:”, x)

inner()

print(“outer:”, x)

outer()

When we codify the code, an output will be:

inner: nonlocal

outer: nonlocal

The first item is the internal action (). We use keywords to make non-volatile variables. An intelligent idea () is defined as the number of other functions outside ()

Note: If you change the value of the inputs, the changes appear in the internal variables.

Python Anonymous / Lambda Function

November 23, 2018 mouniyoga

Python Anonymous / Lambda Function

In this article, you will learn about confidential activities, also known as lambda. You will learn what it is, the word and how it is used (examples).

What are lambda functions in Python?
How to use lambda Functions in Python?
- Syntax of Lambda Function in python
- Example of Lambda Function in python
- Use of Lambda Function in python

What is the lambda function in Python?

Python, anonymous secret is a non-named name.

With the usual work described in the DEF word, Python’s activities are defined using the keyword number.

Therefore, secret services are also called lambda.

How to use lambda Functions in Python?

The Lamb works in Python has the following word.

Syntax of Lambda Function in python:

lambda arguments: expression

The number plate numbers may have only one reason, but only one word. This guide is evaluated and returned to the Lamb using it whenever needed.

Example of Lambda Function in python:

Below is a sample for the lambda price.

# Program to show the use of lambda functions

double = lambda x: x * 2

# Output: 10

print(double(5))

In the first program, the x + x: 2 is a function. Here is a list of X and X * 2 are the words to be assessed earlier and later.

This job does not have a name. This technique returns the product identification number two times. Now we can call the normal work. statement in

double = lambda x: x * 2

is nearly the same as

def double(x):

return x * 2

Use of Lambda Function in python:

We use the number when we need a short time without the name.

In Python, we generally use as a discussion of high-action (techniques for other arguments). A function is used for constructions, such as filter (), map () and so on.

Examples of use filter ():

The Python filter () function performs the list of functions.

The activities are called various elements of the list and the list of new features on the back to evaluate Real activities.

The following examples use a filter () to limit even numbers even on the list.

# Program to filter out only the even items from a list

my_list = [1, 5, 4, 6, 8, 11, 3, 12]

new_list = list(filter(lambda x: (x%2 == 0) , my_list))

# Output: [4, 6, 8, 12]

print(new_list)

Examples of the use of map ()

The Python traffic map (Python) performs the functions of the list.

The activities are called various items from the list and the list of new items that have been restored to the workpiece.

The following examples use the map function () that contains all the items in the list.

# Program to double each item in a list using map()

my_list = [1, 5, 4, 6, 8, 11, 3, 12]

new_list = list(map(lambda x: x * 2 , my_list))

# Output: [2, 10, 8, 12, 16, 22, 6, 24]

print(new_list)

Python Recursion

November 22, 2018November 22, 2018 mouniyoga

Python Recursion

In this article, you will learn how to create a recruiter; the action itself is declaring itself.

What is recursion in Python?
Python Recursive Function
Advantages of Recursion
Disadvantages of Recursion

What is Recursion in Python?

Recovery is the way to define my own.

For example, the physical world should be compared to two parallel lenses. Every item between them will be reviewed.

Python Recursive Function:

We know Python, a job can call other activities. This is also possible to call your call. This type of structure is called recruitment staff.

The following is an example of a repeat review sample to get the whole number.

Condition of one of the products for all signs from 1 to number. For example, this article 6 (shown in 6) runs from 1 * 2 * 3 * 4 * 5 * 6 = 720.

Example of Recursive Function:

calc_factorial(4) # 1st call with 4

4 * calc_factorial(3) # 2nd call with 3

4 * 3 * calc_factorial(2) # 3rd call with 2

4 * 3 * 2 * calc_factorial(1) # 4th call with 1

4 * 3 * 2 * 1 # return from 4th call as number=1

4 * 3 * 2 # return from 3rd call

4 * 6 # return from 2nd call

24 # return from 1st call

In the previous example, calc_factorial () is a repetitive act because they are called together.

If we serve this task with a good amount, it will call it back by reducing the number.

Any call from the spelling analysis number 1 to the number is the same. This return call is described in the following steps.

Recovery is completed when the number is low. This is called the state language.

Any repetitive work must have the basic requirements for the termination of repairs or other functions called “unusual.

Merits of Recursion:

The repetitive tasks perform the cleaner and its appearance.
Hard work that can be divided into simple and simple problems using repatriation.
The standard setup is easy to use multiple repetitions.

Demerits of Recursion:

Sometimes the probability behind recovery is difficult to maintain.
Repeat calls are expensive (invalid), as they contain a lot of memory and time.
Recurring tasks are very difficult to prevent.

Defining a Function

Syntax:

For example

Calling a Function:

Call by Reference vs Value

Function Arguments:

Required Arguments:

Keyword Arguments:

Default Arguments:

Variable Length Argument:

The Anonymous Function:

Syntax:

Return Statement:

The scope of Variable:

Global Vs Local Variable:

Python – Date & Time

What is Tick?

What is TimeTuple?

Getting Current Time?

Getting Formatted Time

Get a Calendar of months

The Time Module

The Calendar Module

Other Modules and Functions:

What Is Django And Why Is It So Popular?

Why Is It So Popular?

It is time-tested:

You have access to enough Django packages

It’s been crowd-tested

Django has wonderful documentation

The Django community is hugely supportive

Django advocates best practices for SEO

Scalability

Security

Python break, continue and pass Statements

Introduction:

What is the use of Break and continue in Python?

The Break Statement:

The continue statement:

The Else Statement used with Loops:

The Pass Statement:

Python Modules

Table of Contents

How to import modules in Python?

Python import statement:

Import with renaming:

Python from…import statement:

Import all names:

Python Module Search Path:

Reloading a module:

The dir() built-in function:

Table of Contents

Python global Keyword:

Rules of global Keyword:

Use of global Keyword (With Example):

Example 1: Accessing global Variable From Inside a Function

Example 2: Modifying Global Variable From Inside the Function

Example 3: Changing Global Variable From Inside a Function using global

Global Variables Across Python Modules:

Example 4: Share a global Variable Across Python Modules

a = 0

b = “empty”

Global in Nested Functions in Python:

Example 5: Using a Global Variable in Nested Function

Python Global, Local and Nonlocal variables

Table of Contents

Global Variable in Python:

Example 1: Create a Global Variable

Local Variables in Python:

Example 2: Accessing local variable outside the scope

Example 3: Create a Local Variable

Global and Local Variables Together:

Example 4: Using Global and Local variables in the same code

Example 5: Global variable and Local variable with the same name

Nonlocal Variables in Python

Example 6: Create a nonlocal variable

Python Anonymous / Lambda Function

Table of Contents

What is the lambda function in Python?

How to use lambda Functions in Python?