Merge branch 'master' of github.com:bregman-arie/devops-exercises into devel

This commit is contained in:
abregman 2021-11-26 12:55:20 +02:00
commit abe451f0a6
2 changed files with 120 additions and 1 deletions

24
.github/workflows/ci_workflow.yml vendored Normal file
View File

@ -0,0 +1,24 @@
name: CI
on:
# Triggers the workflow on pull request events for the main and devel branch
pull_request:
branches: [ main, devel ]
# Allows running this workflow manually from the Actions tab
workflow_dispatch:
jobs:
# Contains a single job called "ci"
ci:
runs-on: ubuntu-latest
steps:
# Checks out repository under $GITHUB_WORKSPACE, so job can access it
- uses: actions/checkout@v2
- name: Install flake8
run: sudo apt install flake8
- name: Give executable permissions to the script
run: chmod a+x scripts/run_ci.sh
- name: Run the ci script in scripts folder
run: sh scripts/run_ci.sh
shell: bash

View File

@ -3031,8 +3031,38 @@ You can then assign a function to a variables like this `x = my_function` or you
<details>
<summary>Write a function to determine if a number is a Palindrome</summary><br><b>
- Code:
```
from typing import Union
def isNumberPalindrome(number: Union[int, str]) -> bool:
if isinstance(number, int):
number = str(number)
return number == number[::-1]
print(isNumberPalindrome("12321"))
```
- Using Python3.10 that accepts using bitwise operator '|'.
```
def isNumberPalindrome(number: int | str) -> bool:
if isinstance(number, int):
number = str(number)
return number == number[::-1]
print(isNumberPalindrome("12321"))
```
Note: Using slicing to reverse a list could be slower than other options like `reversed` that return an iterator.
- Result:
```
True
```
</b></details>
#### Python - OOP
@ -3239,6 +3269,28 @@ False
<details>
<summary>What is the __call__ method?</summary><br><b>
It is used to emulate callable objects. It allows a class instance to be called as a function.
- Example code:
```
class Foo:
def __init__(self: object) -> None:
pass
def __call__(self: object) -> None:
print("Called!")
f = Foo()
f()
```
- Result:
```
Called!
```
</b></details>
<details>
@ -3425,6 +3477,24 @@ some_list[:3]
<details>
<summary>How to insert an item to the beginning of a list? What about two items?</summary><br><b>
- One item:
```
numbers = [1, 2, 3, 4, 5]
numbers.insert(0, 0)
print(numbers)
```
- Multiple items or list:
```
numbers_1 = [2, 3, 4, 5]
numbers_2 = [0, 1]
numbers_1 = numbers_2 + numbers_1
print(numbers_1)
```
</b></details>
<details>
@ -3632,6 +3702,31 @@ list(zip(nums, letters))
<details>
<summary>What is List Comprehension? Is it better than a typical loop? Why? Can you demonstrate how to use it?</summary><br><b>
From [Docs](https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions): "List comprehensions provide a concise way to create lists. Common applications are to make new lists where each element is the result of some operations applied to each member of another sequence or iterable, or to create a subsequence of those elements that satisfy a certain condition.".
It's better because they're compact, faster and have better readability.
- For loop:
```
number_lists = [[1, 7, 3, 1], [13, 93, 23, 12], [123, 423, 456, 653, 124]]
odd_numbers = []
for number_list in number_lists:
for number in number_list:
if number % 2 == 0:
odd_numbers.append(number)
print(odd_numbers)
```
- List comprehesion:
```
number_lists = [[1, 7, 3, 1], [13, 93, 23, 12], [123, 423, 456, 653, 124]]
odd_numbers = [number for number_list in number_lists for number in number_list if number % 2 == 0]
print(odd_numbers)
```
</b></details>
<details>
@ -7339,7 +7434,7 @@ Not only this will tell you what is expected from you, it will also provide big
<details>
<summary>What does it mean when a database is ACID compliant?</summary><br>
ACID stands for Atomicity, Consistency, Isolation, Durability. In order to be ACID compliant, the database much meet each of the four criteria
ACID stands for Atomicity, Consistency, Isolation, Durability. In order to be ACID compliant, the database must meet each of the four criteria
**Atomicity** - When a change occurs to the database, it should either succeed or fail as a whole.