The print() function displays a representation of a Python object in the output window.

print()

The input() function is used to prompt a user to enter in a value when it is run. When the function is evaluated, the prompt will be shown. Any further functions which reference the input() input will use the number provided by the user in the prompt. 

input() Function

The range(start, stop, step) function returns a sequence of numbers starting from 'start' and ending at 'stop' - 1, incremented by 'step' When calling the function, arguments for 'start' and 'step' may be omitted. They will default to 0 and 1, respectively.

range()

- The built-in function abs() gives back the absolute value of a number provided as its 
   argument
- Argument of abs() function can be an integer, a floating point number or a complex 
  number.
- abs() function will return the magnitude of a complex number.

abs() function

The bin() function converts an integer to binary string. The binary string always has a prefix 0b. 
```python
x = bin(100)
print(x) #it prints 0b1100100
```


bin()

The bool() function returned ```True``` or ```False``` depending on the object.
It always returns ```True``` for all objects, with the following exception: empty object like empty list/dictionary, 0, False, None.
```python
print(bool(False)) #False
print(bool(0)) #False
print(bool(None)) #False
print(bool([])) #False
print(bool("abc")) #True
print(bool(4)) #True
print(bool([1,2,3])) #True
```

bool()

len() function returns the length or number of items in an object.
The object must be a sequence e.g string, list, tuples or a collection e.g dictionary, set.  
```python
print(len("apple")) #returns 5
print(len(["a", "b", "c"])) #returns 3
print(len({"age": 20, "score": 100})) #returns 2
print(len(1)) #throws an error: TypeError: object of type 'int' has no len()
```

len()

The round() function rounds off a number to N decimal points. 
Syntax:
```python
round(number, digits)
```
```number``` is the number to be rounded. ```digit```  is the number of decimals. If the ```digits``` parameter is empty, the default value is 0 and the number is rounded to the nearest integer.
```python
x = round(2.8399, 2) #2.84
y = round(2.8391, 3) #2.839
z = round(2.8399) #3
print(x)
print(y)
print(z)
```

round()

This built in function has 3 number parameters: x being the base, y being the exponent, and z (optional) used for modulus. 

pow(x, y) computes x^y
pow(x, y, z) computes x^y % z

pow(x, y, z)

This built-in method takes in an integer and returns a character (as a string) whose Unicode code point is the given integer.

If the integer i is out of range, chr(i) will raise a ValueError.


chr(i)

The built in function can have 3 parameters:

* start - (optional, default = none) the starting integer where the object slicing starts
* stop - the integer until the slicing continues to (slicing stops at the index before the 'stop' integer)
* step - (optional, default = none) the integer representing the increment between each index for slicing

slice()

hex() function convert the integer passed as its argument to a lowercase hexadecimal string with a prefix '0x'

hex()

This function will convert an integer to an octal string with the prefix '0o'

oct()

The `int` function. cantake a floating point number or a string, and turn it into an int. For floating point numbers, it discards the decimal portion of the number, a process called "truncation towards zero" on the number line.

Example:
```
print(3.14, int(3.14))
print(3.9999, int(3.9999))       # This doesn't round to the closest int!
print(3.0, int(3.0))
print(-3.999, int(-3.999))        # Note that the result is closer to zero

print("2345", int("2345"))        # parse a string to produce an int
print(17, int(17))                # int even works on integers
print(int("23bottles"))
```
```
3.14 3
3.9999 3
3.0 3
-3.999 -3
2345 2345
17 17
```
The last line throws a ValueError as the int() function does not take String literals.

int()

The type converter `str` turns its argument into a string.
```
print(str(17))
print(str(123.45))
print(type(str(123.45)))
```
```
17
123.45
<class 'str'>
```

str()

The type converter `float` can turn an integer, a float, or a syntactically legal string into a float.

Example:
```
print(float("123.45"))
print(type(float("123.45")))
```
```
123.45
<class 'float'>
```

float()

This function is used to convert a character to an integer.
```
s = ' 4'
c = ord(s)
print(c)
```
```
52
```

ord()

The built-in open() function can open a file in a given directory and return a corresponding file object to it.

Parameters for open are as follows: 
- file: object representing file path
- mode (optional): mode when opening file, including reading ('r'), writing ('w'), exclusive creation ('x'), appending ('a'), text ('t'), binary ('b'), and read/write ('+') modes
- errors (optional): string specifying how to handle encoding/decoding errors
- newline​ (optional): how newlines mode works (available values: None, ' ', '\n', 'r', and '\r\n'
- closed (optional): must be True (default); if given otherwise, an exception will be raised
- opener (optional): a custom opener; must return an open file descriptor

Some methods for file reading and editing, including open().write and open().read.

open()

In Python, the `id()` function returns the exact address of a referenced object in memory. This unique integer identity can be used to verify if two variables point to the identical memory location or to demonstrate when an operation, such as variable reassignment, causes new memory to be allocated instead of updating the object in-place.

Python id() Function

Python comes with a host of built-in functions. Here are some examples:
- print()
- input()
- id()
- range()
- abs()
- bin()
- bool()
- len()
- round()
- pow(x,y,z)
- chr(i)
- slice()
- ord()
- hex()
- oct()
- int()
- float()
- str()
- open()



University of Michigan - Ann Arbor

Rutgers University

San Jose State University

California Polytechnic State University, San Luis Obispo

University of Illinois at Urbana-Champaign

Claude

Function can be thought of as devices that take in material, perform a specified operation on the taken-in material, then output a resulting object. 

Inputs are referred to as arguments 
End result is referred to as output or return value. 

Functions in Python

Python Documentation

Dive into Deep Learning

New functions can be created with the keyword def, as such:

```python
def sub(x, y):
   return x - y

def add(x, y):
   return x + y

def square(x):
    return x ** 2
```
 


Defining Functions in Python 

Functions are displayed and written in the following format:

- For one argument: functionname(argument)
- For two arguments: functionname(argument1, argument2)
- For three arguments: functionname(argument1, argument2, argument3)
- *And so forth 

Format of Functions in Python

The terms input and argument are often used interchangeably to refer to function arguments. However, the term "input" can also refer to the input() function. 

"Argument" will universally refer to information that is passed into a function as such: function(argument) 

Inputs vs Arguments in Python

Built-In Functions in Python

In Python, function parameters refer to the variables that are listed within a function definition. For example, in the function rotate(x, y), the parameters are x and y.

Function Parameters in Python

Which of the following are true about functions in Python? (choose all that apply)

Lambdas are shorthand function definitions. A lambda function is a small anonymous function. A lambda function can take any number of arguments, but can only have one expression. The syntax is, lambda arguments : expression. For instance,

```python
func = lambda x, y : x + y
```

defines a Python function that takes two arguments (which must support the + operator) and returns their sum/concatenation.

Lambdas in Python

Example of the square function:
- ```square(4)``` --> 16

Example of the subtraction function:
- ```sub(6, 4)``` --> 2

Example of the square function in a multidimensional problem:
- ```sub(square(3), square(4))``` --> -7 

Example of the print function:
- ```print(3)``` --> *Integer 3 will actually display on output screen. 

Examples of Python Arithmetic Functions 

A Python generator is a special type of function that returns a lazy iterator. Instead of computing and storing all values in memory at once, a generator produces one value at a time using the `yield` keyword, pausing its execution state between calls. This memory-efficient approach makes generators highly effective for processing large datasets, such as in deep learning data loaders where they iteratively yield a single data batch without loading the entire dataset into memory.

Learn Before

Related

Learn After