From 4b34232081c146d00f2cb3aeb118b66ed7de08a3 Mon Sep 17 00:00:00 2001 From: thomasabishop Date: Wed, 15 Feb 2023 07:36:48 +0000 Subject: [PATCH] Autosave: 2023-02-15 07:36:48 --- .../NodeJS/REST_APIs/4_DELETE.md | 0 .../Python/Syntax/Lists_in_Python.md | 142 ++++++++++++++++++ .../Python/Syntax/Sets_in_Python.md | 47 ++++++ .../Python/Syntax/Tuples_in_Python.md | 77 ++++++---- _meta/Resources.md | 4 + 5 files changed, 241 insertions(+), 29 deletions(-) delete mode 100644 Programming_Languages/NodeJS/REST_APIs/4_DELETE.md diff --git a/Programming_Languages/NodeJS/REST_APIs/4_DELETE.md b/Programming_Languages/NodeJS/REST_APIs/4_DELETE.md deleted file mode 100644 index e69de29..0000000 diff --git a/Programming_Languages/Python/Syntax/Lists_in_Python.md b/Programming_Languages/Python/Syntax/Lists_in_Python.md index a5d9895..2bfe69b 100644 --- a/Programming_Languages/Python/Syntax/Lists_in_Python.md +++ b/Programming_Languages/Python/Syntax/Lists_in_Python.md @@ -15,3 +15,145 @@ Lists have the following properties: - They **allow duplicate** members - They are **indexed** - You can increase/decrease their length by adding/removing new members + +> Lists are denoted with `[...]` + +## Basic usage + +```python +# Defining a list +list1 = ['John', 'Paul', 'George', 'Ringo'] +list2 = [4] + +# Empty list +list3 = [] # empty list +list3 = list() # Also empty list + +# Nested list +list5 = [[2, 3], [6, 8]] +``` + +## Slicing + +```python +list1 = ['John', 'Paul', 'George', 'Ringo'] + +print(list1[1]) +print(list1[-1]) +print(list1[1:3]) +print(list1[:3]) +print(list1[1:]) + +""" +Ringo +['Paul', 'George'] +['John', 'Paul', 'George'] +['Paul', 'George', 'Ringo'] +""" +``` + +## Adding additional values to existing list + +```python +list1 = ['John', 'Paul', 'George', 'Ringo'] + +# Add single element to the end of a list +list1.append('Pete') +# ['John', 'Paul', 'George', 'Ringo', 'Pete'] + +# Add multiple elements to end of a list +list1.extend(['Albert', 'Bob']) +list1 += ['Ginger', 'Sporty'] +# ['John', 'Paul', 'George', 'Ringo', 'Pete', 'Albert', 'Bob', 'Ginger', 'Sporty'] + +## Insert at specific index +list1.insert(2, 7) +['John', 'Paul', 7, 'George', 'Ringo', 'Pete', 'Albert', 'Bob', 'Ginger', 'Sporty'] + +a_list = ['Adele', 'Madonna', 'Cher'] +print(a_list) +a_list.insert(1, 'Paloma') +print(a_list) +# ['Adele', 'Paloma', 'Madonna', 'Cher'] + +``` + +## Removing elements + +We distinguish `del` from `remove` when removing elements from lists: + +- `del` requires an index value +- `remove` requires a value reference (i.e. the mame of the element rather than its index) + +`del` is simple deletion whereas `remove` searches the list. Therefore `del` is more efficient. + +```python +# Remove and return element removed +list6 = ['Once', 'Upon', 'a', 'Time'] +print(list6.pop(2)) +# a + +# Remove and return last element +list6 = ['Once', 'Upon', 'a', 'Time'] +print(list6.pop()) +list6.pop() +print(list6) +# Time + +list6.remove('Upon') +print(list6) +# ['Once', 'a'] + +my_list = ['A', 'B', 'C', 'D', 'E'] +print(my_list) +# ['A', 'B', 'C', 'D', 'E'] +del my_list[2] +print(my_list) +# ['A', 'B', 'D', 'E'] + + +print(my_list) +# ['A', 'B', 'C', 'D', 'E'] +del my_list[1:3] +print(my_list) +# ['A', 'D', 'E'] + +``` + +## Retrieve elements by index + +```python +list7 = [2, 3, 6, 8] +print(list7.index(8)) +# 3 + +list6 = ['Once', 'Upon', 'a', 'Time'] +print(list6.index('a')) +# 2 +``` + +## Nesting lists + +```python +l1 = [1, 43.5, 'Phoebe', True] +l2 = ['apple', 'orange', 31] +root_list = ['John', l1, l2, 'Denise'] +print(root_list) +# ['John', [1, 43.5, 'Phoebe', True], ['apple', 'orange', 31], 'Denise'] +``` + +## List comprehension + +> List comprehension is an older feature of Python. Now the same functionality can be achieved with greater concision using functional methods like `map` and `filter`. But you may see it used in older code. + +```python +values = [1, 2, 4, 6, 8, 9] + +new_values = [i + 1 for i in values] +print('new_values', new_values) +# new_values [2, 3, 5, 7, 9, 10] +new_list = [item + 1 for item in values if item % 2 == 0] + +print('new_list:', new_list) +# new_list: [3, 5, 7, 9] +``` diff --git a/Programming_Languages/Python/Syntax/Sets_in_Python.md b/Programming_Languages/Python/Syntax/Sets_in_Python.md index 40b8ffa..585eef8 100644 --- a/Programming_Languages/Python/Syntax/Sets_in_Python.md +++ b/Programming_Languages/Python/Syntax/Sets_in_Python.md @@ -10,3 +10,50 @@ tags: [python, data-structures] - You can increase/decrease their length by adding/removing new members - They **do not allow duplicate members** - **Can only hold immutable objects** + +> Sets are denoted with `{...}` + +## Basic usage + +```python +basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'} +print(basket) # show that duplicates have been removed +print(len(basket)) +# {'apple', 'pear', 'banana', 'orange'} +# 4 +``` + +## Looping through sets + +```python +for item in basket: + print(item) + +""" +apple +pear +banana +orange +""" +``` + +## Check for membership + +```python +basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'} +print('apple' in basket) +# True +``` + +## Remove items from set + +> `remove` will raise an error if the specified item does not exist, `discard` will not + +```python +basket.remove('apple') +basket.discard('apricot') +print(basket) +# {'pear', 'banana', 'orange'} +``` + +## Add items to a set diff --git a/Programming_Languages/Python/Syntax/Tuples_in_Python.md b/Programming_Languages/Python/Syntax/Tuples_in_Python.md index f4dbb56..2381723 100644 --- a/Programming_Languages/Python/Syntax/Tuples_in_Python.md +++ b/Programming_Languages/Python/Syntax/Tuples_in_Python.md @@ -16,43 +16,48 @@ Tuples have the following properties: - **Allow duplicate** members - They are **indexed** +As with all containers in Python they permit any data type. + +> Tuples are denoted with `(...)` + +## Basic usage + ```python tup1 = (1, 3, 5, 7) -print('tup1[0]:\t', tup1[0]) -print('tup1[1]:\t', tup1[1]) -print('tup1[2]:\t', tup1[2]) -print('tup1[3]:\t', tup1[3]) +print(tup1[0]) +print(tup1[1]) +print(tup1[2]) +print(tup1[3]) """ -tup1[0]: 1 -tup1[1]: 3 -tup1[2]: 5 -tup1[3]: 7 +1 +3 +5 +7 """ +``` -# Slicing +## Slicing -print('tup1[1:3]:\t', tup1[1:3]) -print('tup1[:3]:\t', tup1[:3]) -print('tup1[1:]:\t', tup1[1:]) -print('tup1[::-1]:\t', tup1[::-1]) +```python +tup1 = (1, 3, 5, 7) + +print(tup1[1:3]) +print(tup1[:3]) +print(tup1[1:]) +print(tup1[::-1]) """ -tup1[1:3]: (3, 5) -tup1[:3]: (1, 3, 5) -tup1[1:]: (3, 5, 7) -tup1[::-1]: (7, 5, 3, 1) +(3, 5) +(1, 3, 5) +(3, 5, 7) +(7, 5, 3, 1) """ +``` +## Looping -print('len(tup1):\t', len(tup1)) -# len(tup1): 4 - -tup2 = (1, 'John', True, -23.45) -print(tup2) -# (1, 'John', True, -23.45) - - +```python tup3 = ('apple', 'pear', 'orange', 'plum', 'apple') for x in tup3: print(x) @@ -64,20 +69,32 @@ orange plum apple """ +``` +## Useful methods and predicates + +```python +tup3 = ('apple', 'pear', 'orange', 'plum', 'apple') + +# Count instances of a member print(tup3.count('apple')) -print(tup3.index('pear')) - # 2 + +# Get index of a member +print(tup3.index('pear')) # 1 - +# Check for membership if 'orange' in tup3: print('orange is in the Tuple') # orange is in the Tuple +``` + +## Nest tuples + +```python -tuple1 = (1, 3, 5, 7) tuple2 = ('John', 'Denise', 'Phoebe', 'Adam') tuple3 = (42, tuple1, tuple2, 5.5) print(tuple3) @@ -85,3 +102,5 @@ print(tuple3) # (42, (1, 3, 5, 7), ('John', 'Denise', 'Phoebe', 'Adam'), 5.5) ``` + +// TODO: How to flatten a tuple? diff --git a/_meta/Resources.md b/_meta/Resources.md index 329cda3..d555e9d 100644 --- a/_meta/Resources.md +++ b/_meta/Resources.md @@ -96,6 +96,10 @@ A. Sweighart. 2020. **Beyond the Basic Stuff with Python** A. Sweighart. 2015. **Automate the Boring Stuff with Python** +J. Hunt. 2019. **A Beginner's Guide to Python Programming** + +J. Hunt. 2019. **An Advanced Guide to Python Programming** + [Tiny Python Projects (O'Reilly)](https://learning.oreilly.com/library/view/tiny-python-projects/9781617297519/) [Learning Arduino with Python](https://realpython.com/arduino-python/)