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

University of Illinois at Urbana-Champaign

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()



Built-In Functions in Python

Python Documentation

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()

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.

Learn Before

Related