Python
Python
In Python, a scope defines the region of code where an object remains valid and accessible.
Every object in Python operates within its designated scope. Namespaces are used to uniquely
identify objects within a program, and each namespace is associated with a specific scope where
objects can be used without any prefix. The scope of a variable determines its accessibility and
lifespan.
Local scope: This refers to the objects that are defined within the current function and
are accessible only within that function.
Global scope: Objects in the global scope are available throughout the execution of the
code.
Module-level scope: This scope encompasses global objects that are associated with the
current module in the program. These objects are accessible within the module.
Outermost scope: This refers to all the built-in names that can be called from anywhere
in the program.
Interested in learning React JS? Click here to learn more about this React JS Certification!
Python supports various data types, including dictionaries. A dictionary in Python is a collection
of elements that are stored as key-value pairs. It is an unordered data structure, and the indexing
is done based on the keys assigned to each element. Let’s consider an example: we have a
dictionary named ‘dict’ with two keys, ‘Country’ and ‘Capital’, which have corresponding
values ‘India’ and ‘New Delhi’, respectively.
Syntax:
dict={‘Country’:’India’,’Capital’:’New Delhi’, }
A function is a segment of code that runs only when it is called. The “def” keyword is utilized to
define a specific function, as exemplified below:
def my_function():
print("Hi, Welcome to Intellipaat")
my_function() # call to the function
Output:
Hi, Welcome to Intellipaat
14. What is __init__ in Python?
In Python classes, the reserved method init serves a similar purpose as constructors in object-
oriented programming (OOP) terminology. When a new object is created, the init method is
automatically called, initializing the object and allocating memory for it. This method can also be
utilized to set initial values for variables.
Below is an example:
class Human:
def __init__(self, age):
self.age = age
def say(self):
print('Hello, my age is', self.age)
h = Human(22)
h.say()
Output:
Hello, my age is 22
Number
String
Tuple
List
Dictionary
set
A local variable is a variable that is defined within a specific function and is only accessible
within that function. It cannot be accessed by other functions within the program.
In contrast, a global variable is a variable that is declared outside of any function, allowing it to
be accessed by all functions in the program
Output: 20
If you attempt to access the local variable outside the func_multiply function, you will encounter
an error.
Become a Data Science engineer with expertise in Python. Enroll in Data Science with Python
training in Philippines
Python offers a valuable feature that allows for the conversion of data types as needed. This
process is referred to as type conversion in Python.
Implicit Type Conversion: This type of conversion is automatically performed by the Python
interpreter without requiring any user intervention.
Explicit Type Conversion: This type of conversion involves the user explicitly changing the
data type to the desired type.
dict(): This function is used to convert a tuple of key-value pairs into a dictionary.
complex(real, imag): This function is used to convert real numbers to complex numbers in the
form of complex(real, imag).
To install Python on Windows and set a path variable, follow the steps below:
Download Python:
After opening the Start menu, search “Environment Variables” or “Edit the system
environment variables.”
Click on the “Environment Variables” button.
Find the “Path” variable in “System Variables” and click “Edit.”
Select “New” and then provide the path to your Python installation directory. It is
typically found at “C:PythonXX” (XX represents the Python version number).
Click “OK” to save the changes.
Here’s the code to check the Python version using Command Prompt:
python –version
Yes, Python is a case sensitive language. In Python, it is important to note that “Function” and
“function” are distinct entities, similar to how SQL and Pascal handle them differently.
[::-1] ,take this example of slice notation and it helps in reversing the sequence, all with the help
of indexing.
[Start,stop,step count]
Output: 5,4,3,2,1
In Python, decorators serve as essential functions that enable the addition of functionality to an
already existing function without altering its structure. These decorators are denoted by the
@decorator_name syntax in Python and are invoked in a bottom-up manner. Below is an
example illustrating how decorators work correctly:
def decorator_lowercase(function): # defining a Python decorator
def wrapper():
result = function()
result_lowercase = result.lower()
return result_lowercase
return wrapper
@decorator_lowercase ## calling the decorator
def intro(): # Normal function
return 'Hello, I AM SAM'
print(intro())
Indentation is an essential aspect of Python syntax, ensuring proper code structure. It is a method
used by programming languages to determine the scope and extent of code blocks. In Python,
indentation serves this purpose. The mandatory requirement of indentation in Python not only
enforces consistent code formatting but also enhances code readability, which is likely the reason
behind its inclusion.
Learn the Pros and Cons of Python in our comprehensive blog on the Advantages and
Disadvantages of Python.
The following statements assist in altering the course of execution from the regular flow, which
categorizes them as loop control statements.
Python break: This statement aids in discontinuing the loop or the statement and
transferring control to the subsequent statement.
Python continue: This statement enforces the execution of the subsequent iteration when
a particular condition is met, instead of terminating it.
Python pass: This statement allows the syntactical writing of code while intending to
bypass its execution. It is also recognized as a null operation, as no action is taken when
the pass statement is executed.
26. How can you randomize the items of a list in place in Python?
This can be easily achieved by using the Shuffle() function from the random library as shown
below:
To include a multiline comment in Python, each line should begin with the # symbol. This
practice ensures that the code is clear and easily understood.
Python is a versatile programming language that excels not only as a general-purpose language
but also as a scripting tool.
Ready to ace your Desktop Support Engineer interview? Check out our blog for a
comprehensive list of Desktop Support Engineer Interview Questions and expert tips!
29. What are negative indexes and why are they used?
To retrieve an item from a sequential collection, we can simply utilize its index, which represents
the position of that specific item. Conventionally, the index commences at 0, implying that the
initial element has an index of 0, the second element has an index of 1, and so forth.
When employing reverse indexing, we access elements from the opposite end of the sequence. In
this case, the indexing initiates from the last element, denoted by the index number ‘-1’. The
second-to-last element is assigned an index of ‘-2’, and so forth. These negative indexes
employed in reverse indexing are specifically referred to as negative indexes.
Learn more about Python from this Python Training in New York to get ahead in your career!
In programming, literals are used to represent specific values assigned to variables or constants.
Python offers various types of literals, including string literals, numeric literals, and boolean
literals. Here are examples of each:
String Literals:
String literals are created by enclosing text within either single or double quotes. They can
represent any sequence of characters.
Example:
“Intellipaat”
‘45879’
Numeric Literals:
Integer: Integer literals represent whole numbers without any fractional part.
Example: I = 10
Example: i = 5.2
Example: 1.73j
Boolean Literals:
Boolean literals are utilized to denote boolean values, which can only be True or False.
Example: x = True
The map() function in Python has two parameters, function and iterable. The map() function is a
powerful tool that allows you to apply a specified function to every element within an iterable. It
takes two arguments: the function you want to apply and the iterable containing the elements you
want to process. This function is a versatile way to perform operations on multiple items
simultaneously, making your code more efficient and concise
For example:
def calculateSq(n):
return n*n
numbers = (2, 3, 4, 5)
result = map( calculateSq, numbers)
print(list(result))
Generators in Python are special functions that can be used to create iterable objects. Unlike
regular functions that return a value and then terminate, generators use the yield keyword to
suspend execution temporarily and yield a value one at a time. This makes generators memory
efficient as they don’t generate the entire sequence of values upfront but rather generate values
on-demand.
Generators are helpful when dealing with large datasets or when the complete sequence of values
is not needed at once. They allow us to iterate over a potentially infinite sequence without
consuming excessive memory.
Python iterators are objects that allow you to access elements of a collection one at a time. They
use the __iter__() and __next__() methods to retrieve the next element until there are no more.
Iterators are commonly used in for loops and can be created for custom objects. They promote
efficient memory usage and enable lazy evaluation of elements. In summary, iterators provide a
convenient way to iterate over data structures in a controlled and efficient manner.
No. Python is a dynamically typed language, i.e., the Python Interpreter automatically identifies
the data type of a variable based on the type of value assigned.
36. What are Dict and List comprehensions?
Python comprehensions are like decorators that help to build altered and filtered lists,
dictionaries, or sets from a given list, dictionary, or a set. Comprehension is a powerful feature in
Python that offers a convenient way to create lists, dictionaries, and sets with concise
expressions. It eliminates the need for explicit loops, which can help reduce code size and save
time during development.
For example:
Python comments are statements used by the programmer to increase the readability of the code.
With the help of the #, you can define a single comment. Another way of commenting is to use
the docstrings (strings enclosed within triple quotes).
For example:
#Comments in Python
print("Comments in Python ")
Yes, unlike Java, Python provides users with a range of support in terms of inheritance and its
usage. Multiple inheritance refers to a scenario where a class is instantiated from more than one
individual parent class. This provides a lot of functionality and advantages to users.
39. What is the difference between range & xrange?
Functions in Python, range() and xrange(), are used to iterate inside a for loop for a fixed number
of times. Functionality-wise, both these functions are the same. The difference comes when
talking about the Python version support for these functions and their return values.
The Pickle module accepts the Python object and converts it into a string representation and
stores it into a file by using the dump function. This process is called pickling. On the other
hand, the process of retrieving the original Python objects from the string representation is called
unpickling.
Want to know about the real-world uses of Python? Read our detailed blog on Python
Applications now.
Tkinter is a built-in Python module that is used to create GUI applications and it is Python’s
standard toolkit for GUI development. Tkinter comes pre-loaded with Python so there is no
separate installation needed. You can start using it by importing it in your script.
42. Is Python fully object oriented?
Python does follow an object-oriented programming paradigm and has all the basic OOPs
concepts such as inheritance, polymorphism, and more, with the exception of access specifiers.
Python doesn’t support strong encapsulation (adding a private keyword before data members).
Although, it has a convention that can be used for data hiding, i.e., prefixing a data member with
two underscores.
NumPy SciPy
NumPy stands for Numerical Python SciPy stands for Scientific Python
It is used for efficient and general numeric This module is a collection of tools in
computations on numerical data saved in arrays. Python used to perform operations such as
E.g., sorting, indexing, reshaping, and more integration, differentiation, and more
Full-fledged algebraic functions are
There are some linear algebraic functions available
available in SciPy for algebraic
in this module, but they are not full-fledged
computations
For opening a text file using the above modes, we will have to append ‘t’ with them as follows:
Similarly, a binary file can be opened by appending ‘b’ with them as follows:
To append the content in the files, we can use the append mode (a):
45. What do file-related modules in Python do? Can you name some file-related
modules in Python?
Python comes with some file-related modules that have functions to manipulate text files and
binary files in a file system. These modules can be used to create text or binary files, update
content by carrying out operations like copy, delete, and more.
Some file-related modules are os, os.path, and shutil.os. The os.path module has functions to
access the file system, while the shutil.os module can be used to copy or delete files.
Know about Python developer roles and responsibilities to begin a career as a Python
developer.
46. Explain the use of the 'with' statement and its syntax?
In Python, using the ‘with’ statement, we can open a file and close it as soon as the block of
code, where ‘with’ is used, exits. In this way, we can opt for not using the close() method.
To display the contents of a file in reverse, the following code can be used:
filename = "filename.txt"
with open(filename, "r") as file:
lines = file.readlines()
for line in reversed(lines):
print(line.rstrip())
1. xyz = 1,000,000
2. x y z = 1000 2000 3000
3. x,y,z = 1000, 2000, 3000
4. x_y_z = 1,000,000
Command:
f= open(“hello.txt”, “wt”)
len() is an inbuilt function used to calculate the length of sequences like list, python string, and
array.
my_list = [1, 2, 3, 4, 5]
length = len(my_list)
print(length)
Want to know about the real-world uses of Python? Read our detailed blog on Python Project
ideas now.
To remove duplicate elements from the list we use the set() function.
import os
os.remove("file_name.txt")
For example:
import random
def read_random(fname):
lines = open(fname).read().splitlines()
return random.choice(lines)
print(read_random('hello.txt'))
55. Write a Python program to count the total number of lines in a text file?
Refer the code below to count the total number of lines in a text file-
def file_count(fname):
with open(fname) as f:
for i, _ in enumerate(f):
pass
return i + 1
56. What would be the output if I run the following code block?
list1 = [2, 33, 222, 14, 25]
print(list1[-2])
1. 14
2. 33
3. 25
4. Error
Ans. output:14
In Python, negative indexing allows you to access elements from the end of the list. The index -1
represents the last element, -2 represents the second-to-last element, and so on.
In the given code, list1[-2] refers to the second-to-last element in the list list1, which is 14.
Therefore, the output of the code will be 14.
57. What is the purpose of “is”, “not” and “in” operators?
Operators are referred to as special functions that take one or more values (operands) and
produce a corresponding result.
is: returns the true value when both the operands are true (Example: “x” is ‘x’)
not: returns the inverse of the boolean value based upon the operands (example:”1”
returns “0” and vice-versa.
In: helps to check if the element is present in a given Sequence or not.
58. Whenever Python exits, why isn’t all the memory de-allocated?
Whenever Python exits, especially those Python modules which are having circular
references to other objects or the objects that are referenced from the global namespaces,
the memory is not always de-allocated or freed.
It is not possible to de-allocate those portions of memory that are reserved by the C
library.
On exit, because of having its own efficient clean up mechanism, Python will try to de-
allocate every object.
The ternary operator is the operator that is used to show conditional statements in Python. This
consists of the boolean true or false values with a statement that has to be checked.
Syntax:
x , y=10,20
count = x if x<y else y
Explanation:
If the condition x < y is true, then the value of x is assigned to count. This means that if the value
of x is less than the value of y, count will be equal to x.
If the condition x < y is false, then the value of y is assigned to count. This means that if the
value of x is not less than the value of y, count will be equal to y.
In python, adding elements in an array can be easily done with the help of extend(),append()
and insert() functions.
Consider the following example:
x=arr.array('d', [11.1 , 2.1 ,3.1] )
x.append(10.1)
print(x) #[11.1,2.1,3.1,10.1]
x.extend([8.3,1.3,5.3])
print(x) #[11.1,2.1,3.1,10.1,8.3,1.3,5.3]
x.insert(2,6.2)
print(x) # [11.1,2.1,6.2,3.1,10.1,8.3,1.3,5.3]
Elements can be removed from a python array by using pop() or remove() methods.
Output:
3.6
1.1 # element popped at 3 rd index
array('d', [ 2.4, 6.8, 7.7, 1.2])
Are you interested in learning Python from experts? Enroll in our online Python Course in
Bangalore today!
63. Can you write an efficient code to count the number of capital letters in a
file?
To make this code more efficient the whole code block can be converted into a one-line code
using the feature called generator expression. With this, the equivalent code line of the above
code block would be as follows:
To reverse a list in Python, you can use the slicing technique. Here’s a brief explanation of the
process:
Use the slicing syntax [::-1] to create a new list that includes all elements from the original list in
reverse order.
Assign the reversed list to a new variable or overwrite the original list with the reversed version.
original_list = [1, 2, 3, 4, 5]
reversed_list = original_list[::-1]
65. How will you remove the last object from a list in Python?
my_list = [1, 2, 3, 4, 5]
my_list.pop()
Here, −1 represents the last element of the list. Hence, the pop() function removes the last object
(obj) from the list.
Get certified in Python from the top Python Course in Singapore now!
This is achieved by importing the random module. It is the module that is used to generate
random numbers.
Syntax:
import random
random.random # returns the floating point random number between the range of
[0,1].
67. How will you convert a string to all lowercase?
To convert a string to all lowercase in Python, you can use the built-in lower() method. The
lower() method is available for strings and returns a new string with all characters converted to
lowercase.
For Example:
demo_string='ROSES'
print(demo_string.lower())
68. Why would you use NumPy arrays instead of lists in Python?
NumPy arrays provide users with three main advantages as shown below:
NumPy arrays consume a lot less memory, thereby making the code more efficient.
NumPy arrays execute faster and do not add heavy processing to the runtime.
NumPy has a highly readable syntax, making it easy and convenient for programmers.
Polymorphism is the ability of the code to take multiple forms. Let’s say, if the parent class has a
method named XYZ then the child class can also have a method with the same name XYZ
having its own variables and parameters.
Encapsulation in Python refers to the process of wrapping up the variables and different
functions into a single entity or capsule. The Python class is the best example of encapsulation in
python.
71. What advantages do NumPy arrays offer over (nested) Python lists?
Nested Lists:
Python lists are efficient, general-purpose containers that support efficient operations like
insertion, appending, deletion and concatenation.
The limitations of lists are that they don’t support “vectorized” operations like element
wise addition and multiplication, and the fact that they can contain objects of differing
types means that Python must store the data type information for every element, and must
execute type dispatching code when operating on each element.
Numpy:
NumPy is more efficient and more convenient as you get a lot of vector and matrix
operations for free, this helps avoid unnecessary work and complexity of the code.
NumPy is also efficiently implemented when compared to nested lists.
NumPy array is faster and contains a lot of built-in functions which will help in FFTs,
convolutions, fast searching, linear algebra,basic statistics, histograms,etc.
A lambda function is an anonymous function (a function that does not have a name) in Python.
To define anonymous functions, we use the ‘lambda’ keyword instead of the ‘def’ keyword,
hence the name ‘lambda function’. Lambda functions can have any number of arguments but
only one statement.
For example:
Output:30
Any more queries? Feel free to share all your doubts with us in our Python Community and
get them clarified today!
Self is an object or an instance of a class. This is explicitly included as the first parameter in
Python. On the other hand, in Java it is optional. It helps differentiate between the methods and
attributes of a class with local variables.
The self variable in the init method refers to the newly created object, while in other methods, it
refers to the object whose method was called.
Syntax:
Class A:
def func(self):
print("Hi")
Both append() and extend() methods are methods used to add elements at the end of a list.
The primary differentiation between the append() and extend() methods in Python is that
append() is used to add a single element to the end of a list. In contrast, open () is used to append
multiple aspects, such as another list or an iterable, to the end of a list.
For in-depth knowledge, check out our Python Tutorial and boost your Python skills!
Sign up for the Full Stack Developer Course to begin your career journey today.
Python lets users include a description (or quick notes) for their methods using documentation
strings or docstrings. Docstrings are different from regular comments in Python. Rather than
being completely ignored by the Python interpreter like in the case of comments, these are
defined within triple quotes.
Syntax:
"""
Using docstring as a comment.
This code add two numbers
"""
x=7
y=9
z=x+y
print(z)
Python has a multi-threading package but commonly not considered a good practice to use it as it
results in increased code execution time.
Python has a constructor called the Global Interpreter Lock (GIL). The GIL ensures that
only one of your ‘threads’ can execute at one time. The process makes sure that a thread
acquires the GIL, does work, then passes the GIL onto the next thread.
This occurs almost instantaneously, giving the illusion of parallel execution to the human
observer. However, the threads execute sequentially, taking turns utilizing the same CPU
core.
Slicing is a technique employed to extract a specific range of elements from sequential data
types, such as lists, strings, and tuples. Slicing is beneficial and easy to extract out elements. It
requires a : (colon) which separates the start index and end index of the field. All the data
sequence types, list or tuple, allows users to use slicing to get the needed elements. Although we
can get elements by specifying an index, we get only a single element. Whereas, using slicing,
we can get a group or appropriate range of needed elements.
Syntax:
List_name[start:stop]
Functional programming is a coding style where the main source of logic in a program comes
from functions.
Pure functions are functions that cause little or no changes outside the scope of the function.
These changes are referred to as side effects. To reduce side effects, pure functions are used,
which makes the code easy-to-follow, test, or debug.
Python does follow a functional programming style. Following are some examples of functional
programming in Python.
1. set([[1,2],[3,4],[4,5]])
2. set([1,2,2,3,4,5])
3. {1,2,3,4}
4. set((1,2,3,4))
Ans.
set([[1,2],[3,4],[4,5]])
Monkey patching is the term used to denote modifications that are done to a class or a module
during runtime. This can only be done as Python supports changes in the behavior of the
program while being executed.
# monkeyy.py
class X:
def func(self):
print("func() is being called")
The above module (monkeyy) is used to change the behavior of a function at the runtime as
shown below:
import monkeyy
def monkey_f(self):
print("monkey_f() is being called")
# Replacing the address of "func" with "monkey_f"
monkeyy.X.func = monkey_f
obj = monkeyy.X()
o /: is a division operator and returns the value of the quotient.
10/3
3.33
o // : is known as floor division operator and used to return the value of quotient
before the decimal point.
10//3
Pandas is an open source python library which supports data structures for data based operations
associated with data analyzing and data manipulation . Pandas, with its rich sets of features, fits
in every role of data operation, whether it be related to implementing different algorithms or for
solving complex business problems. Pandas helps to deal with a number of files in performing
certain operations on the data stored by files.
A dataframe refers to a two dimensional mutable data structure or data aligned in the tabular
form with labeled axes(rows and column).
Syntax:
data:It refers to various forms like ndarray, series, map, lists, dict, constants and can take
other DataFrame as Input.
index:This argument is optional as the index for row labels will be automatically taken
care of by pandas library.
columns:This argument is optional as the index for column labels will be automatically
taken care of by pandas library.
Dtype: refers to the data type of each column.
Different dataframes can be easily combined with the help of functions listed below:
<li
>Append():
pd.concat([data_frame1, data_frame2])
join(): This function is used to extract data from different dataframes which have one or
more columns in common.
data_frame1.join(data_frame2)
86. How do you identify missing values and deal with missing values in
Dataframe?
Identification:
isnull() and isna() functions are used to identify the missing values in your data loaded into
dataframe.
missing_count=data_frame1.isnull().sum()
df[‘col_name’].fillna(0)
Replace the missing values with the mean value of that column
df[‘col_name’] = df[‘col_name’].fillna((df[‘col_name’].mean()))
Regression is termed as a supervised machine learning algorithm technique which is used to find
the correlation between variables. It helps predict the value of the dependent variable(y) based
upon the independent variable (x). It is mainly used for prediction, time series modeling,
forecasting, and determining the causal-effect relationship between variables.
Scikit library is used in python to implement the regression and all machine learning algorithms.
Linear Regression: Used when the variables are continuous and numeric in nature.
Logistic Regression: Used when the variables are continuous and categorical in nature.
88. What is classification?
Classification refers to a predictive modeling process where a class label is predicted for a given
example of input data. It helps categorize the provided input into a label that other observations
with similar features have. For example, it can be used for classifying a mail whether it is spam
or not, or for checking whether users will churn or not based on their behavior.
Decision tree
Random forest classifier
Support vector machine
89. How do you split the data in train and test dataset in python?
This can be achieved by using the scikit machine learning library and importing train_test_split
function in python as shown below:
Support vector machine (SVM) is a supervised machine learning model that considers the
classification algorithms for two-group classification problems. Support vector machine is a
representation of the training data as points in space are separated into categories with the help of
a cleSupport Vector Machine (SVM) is a supervised machine learning model for classifying data
into two groups. It is particularly suitable for binary classification problems. SVM represents the
training data as points in space and aims to separate them into distinct categories. The separation
is achieved by identifying a clear gap between the data points, and the SVM model strives to
maximize the width of this gap.
Want to become a Machine Learning expert? Enroll in our Machine Learning Certification in
collaboration with IIT Madras
We can get the indices of N maximum values from a NumPy array using the below code:
import numpy as np
ar = np.array([1, 3, 2, 4, 5, 6])
print(ar.argsort()[-3:][::-1])
92. What is the easiest way to calculate percentiles when using Python?
The easiest and the most efficient way you can calculate percentiles in Python is to make use of
NumPy arrays and its functions.
import numpy as np
a = np.array([1,2,3,4,5,6,7])
p = np.percentile(a, 50) #Returns the 50th percentile which is also the
median
print(p)
A palindrome is a word, phrase, or sequence that reads the same backward as forward, e.g.,
madam, nurses run, etc.
def fun(string):
s1 = string
s = string[::-1]
if s1 == s:
return True
else:
return False
print(fun("madam"))
print(sum([2, 4, 5, 6, 7]))
def bubbleSort(x):
n = len(x)
# Traverse through all array elements
for i in range(n-1):
for j in range(0, n-i-1):
if x[j] > x[j+1]:
x[j], x[j+1] = x[j+1], x[j]
Output:
11,21,22,25,34,37,47
def Star_triangle(n):
for x in range(n):
print(' '*(n-x-1)+'*'*(2*x+1))
Star_triangle(9)
Output:
*
***
*****
*******
*********
***********
*************
***************
*****************
The Fibonacci series refers to a series where an element is the sum of two elements prior to it.
if n <= 0:
print("Please enter a positive integer")
elif n == 1:
print("Fibonacci sequence upto", n, ":")
print(n1)
else:
print("Fibonacci sequence:")
while count < n:
print(n1)
nth = n1 + n2
n1 = n2
n2 = nth
count += 1
num = 13
if num > 1:
for i in range(2, int(num/2)+1):
if (num % i) == 0:
print(num, "is not a prime number")
break
else:
print(num, "is a prime number")
else:
print(num, "is not a prime number")
Output:
13 is a prime number
my_list.sort()
print (my_list)
Output:
2,3,4,6,8
x= 'a'
Output: 65