Sequences

s = 'bicycle'
s[::3] # bye
s[::-2] # eccb

##

invoice = """
0.....6.................................40........52...55........
1909 Pimoroni PiBrella $17.50 3 $52.50
1489 6mm Tactile Switch x20 $4.95 2 $9.90
1510 Panavise Jr. - PV-201 $28.00 1 $28.00
1601 PiTFT Mini Kit 320x240 $34.95 1 $34.95
"""
DESCRIPTION = slice(6, 40)
line_items = invoice.split('\n')[2:]
for item in line_items:
  print(item[DESCRIPTION])

## Assigning to slices
l = list(range(10)) # 0 1 2 3 4 5 6 7 8 9
l[2:5] = [20, 30] # 0 1 20 30 5 6 7 8 9
del l[5:7] # 0 1 20 30 5 8 9
l[3::2] = [11, 22] # 0 1 20 11 5 22 9
# l[2:5] = 100 # not allowed if the target is sliced the right-hand side must be iterable even if it has just one item
l[2:5] = [100] # 0 1 100 22 9

from array import array
from random import random

# creates an array of double-precision floats from any iterable object, in this case, a generator
floats = array('d', (random() for i in range(10**7)))
floats2 = array('d')

# save the array to a binary file
fp = open('floats.bin', 'wb')
floats.tofile(fp)
fp.close()

# reads from the binary file
fp = open('floats.bin', 'rb')
floats2.fromfile(fp, 10**7)
fp.close()

from bitarray import bitarray

arr = bitarray()      

arr.append(False) # bitarray(0)
arr.append(True) # bitarray(1)

arr = bitarray(2**5) # creates an empty bit array of size 32
bitarray('11011011') # declares a bitarray using string

board = [['_'] * 3 for i in range(3)] # [['_', '_', '_'], ['_', '_', '_'], ['_', '_', '_']]
# equals to
board = []
for i in range(3):
  row = ['_'] * 3   # each iteration builds a new row and 
  board.append(row) # appends it to board.

##

# a wrong case
weird_board = [['_'] * 3] * 3 # this is made of three references to the same inner list.
weird_board[1][2] = 'O' # [['_', '_', 'O'], ['_', '_', 'O'], ['_', '_', 'O']]
# equals to
row = ['_'] * 3
board = []
for i in range(3):
  board.append(row) # the same row is appended 3 times to the board.

# Create a random byte array
rarray = bytearray('XYZ', 'utf-8')

# Get memory view
mview = memoryview(rarray)

# Print memory view's 0th Index
print(mview[0])

# Create a list of the memory view
print(list(mview[0:3]))

# Create a tuple of the memory view
print(tuple(mview[0:3]))

# Update a value of the memory view
mview[2] = 70

##

numbers = array.array('h', [-2, -1, 0, 1, 2])

# build memoryview from array of 5 short signed integers (typecode 'h')
memv = memoryview(numbers)

len(memv) # 5

# memv sees the same 5 items in the array
memv[0] # -2

# create memv_oct by casting the elements of memv to type code 'B' (unsigned char)
memv_oct = memv.cast('B')

# export elements of memv_oct as list for inspection
memv_oct.tolist() # [254, 255, 255, 255, 0, 0, 1, 0, 2, 0]

# assign value 4 to byte offset 5
memv_oct[5] = 4

# a 4 is in the most significant byte of a 2-byte unsigned integer is 1024.
numbers

class Vector:

  def __init__(self, x=0, y=0):
    self.x = x
    self.y = y

  def __repr__(self):
    return 'Vector(%r, %r)' % (self.x, self.y)

# immutable list example
# latitude and longitude of Los Angeles International Airport (LAX)
lax_coordinates = (33.9425, -118.408056)

# the most visible form of tuple unpacking
latitude, longitude = lax_coordinates

# unpacking with a star
t = divmod(20, 8)
a, b, rest = range(2) # 1, 2, []
a, b, rest = range(5) # 1, 2, [3, 4, 5]

import os
_, file_name = os.path.split('/home/luciano/.ssh/idrsa.pub') # filename = idrsa.pub

# data example
traveler_ids = [('USA', '4323412'), ('BRA', '2314233'), ('ESP', '3241235')]
for country, _ in traveler_ids: # USA BRA ESP
    print(country)

for passport in sorted(traveler_ids): # USA/4323412 BRA/2314233 ESP/3241235
    print('%s/%s' % passport)

metro_areas = [ ('Tokyo', 'JP', 36.933, (35.689722, 139.691667)),
                ('Delhi NCR', 'IN', 21.935, (28.613889, 77.208889)),
                ('Mexico City', 'MX', 20.142, (19.433333, -99.133333)),
                ('New York-Newark', 'US', 20.104, (40.808611, -74.020386)),
                ('Sao Paulo', 'BR', 19.649, (-23.547778, -46.635833)), 
              ]

fmt = '{:15} | {:9.4f} | {:9.4f}'
for name, cc, pop, (latitude, longitude) in metro_areas:
    if longitude <= 0:
        print(fmt.format(name, latitude, longitude))

my_list = [('b', 4), ('d', 1), ('e', 6), ('m', 2)]
my_list.sort(key=lambda s:s[1])

my_tup_lis = [(2, 4), (9, 16), (1, 12), (5, 4)]
mul_sort = sorted(my_tup_lis, key=lambda t: (t[1], t[0]))

from collections import namedtuple
from random import choice


Card = namedtuple('Card', ['rank', 'suit'])

class FrenchDeck:
 ranks = [ str(n) for n in range(2, 11) ] + list('JQKA')
 suits = 'spades diamonds clubs hearts'.split()

 def __init__(self):
  self._cards = [ Card(rank, suit) for suit in self.suits
           for rank in self.ranks ]

 def __len__(self):
  return len(self._cards)

 def __getitem__(self, position):
  return self._cards[position]

def spades_high(card):
 rank_value = FrenchDeck.ranks.index(card.rank)
 return rank_value * len(suit_values) + suit_values[card.suit]


if __name__ == "__main__":

 my_card = Card('7', 'diamonds') # Card(rank='7', suit='diamonds')
 deck = FrenchDeck()
 print(len(deck)) # 52
 print(deck[0]) # Card(rank='2', suit='spades')
 choice(deck) # i.e. Card(rank='3', suit='hearts')

 suit_values = dict(spades=3, hearts=2, diamonds=1, clubs=0)
 for card in sorted(deck, key=spades_high):
  print(card) # Card(rank='2', suit='clubs') Card(rank='2', suit='hearts') , ..., Card(rank='A', suit='spades')

 deck[12::13] # [start:stop:step]
 #[Card(rank='A', suit='spades'), Card(rank='A', suit='diamonds'), Card(rank='A', suit='clubs'), Card(rank='A', suit='hearts')]

 ## 

 City = namedtuple('City', 'name country population coordinates')
 tokyo = City('Tokyo', 'JP', 36.933, (35.689722, 139.691667))