In [4]:
tuple([4, 0, 2])
tup = tuple('string')
tup
In [6]:
nested_tup = (4, 5, 6), (7, 8) nested_tup nested_tup[0] nested_tup[1]
In [7]:
tup = tuple(['foo', [1, 2], True]) tup[2] = False
In [9]:
(4, None, 'foo') + (6, 0) + ('bar',)
In [11]:
tup = (4, 5, 6) a, b, c = tup b
In [12]:
tup = 4, 5, (6, 7) a, b, (c, d) = tup d
In [13]:
a, b = 1, 2 a b b, a = a, b a b
In [14]:
seq = [(1, 2, 3), (4, 5, 6), (7, 8, 9)]
for a, b, c in seq:
print(f'a={a}, b={b}, c={c}')
In [15]:
values = 1, 2, 3, 4, 5 a, b, *rest = values a b rest
In [17]:
a = (1, 2, 2, 2, 3, 4, 2) a.count(2)
In [18]:
a_list = [2, 3, 7, None]
tup = ("foo", "bar", "baz")
b_list = list(tup)
b_list
b_list[1] = "peekaboo"
b_list
In [19]:
gen = range(10) gen list(gen)
In [20]:
b_list.append("dwarf")
b_list
In [21]:
b_list.insert(1, "red") b_list
In [23]:
b_list.append("foo")
b_list
b_list.remove("foo")
b_list
In [26]:
[4, None, "foo"] + [7, 8, (2, 3)]
In [27]:
x = [4, None, "foo"] x.extend([7, 8, (2, 3)]) x
In [28]:
a = [7, 2, 5, 1, 3] a.sort() a
In [29]:
b = ["saw", "small", "He", "foxes", "six"] b.sort(key=len) b
In [30]:
seq = [7, 2, 3, 7, 5, 6, 0, 1] seq[1:5]
In [36]:
empty_dict = {}
d1 = {"a": "some value", "b": [1, 2, 3, 4]}
d1
In [37]:
d1[7] = "an integer" d1 d1["b"]
In [39]:
d1[5] = "some value"
d1
d1["dummy"] = "another value"
d1
del d1[5]
d1
ret = d1.pop("dummy")
ret
d1
In [40]:
list(d1.keys()) list(d1.values())
In [42]:
d1.update({"b": "foo", "c": 12})
d1
In [43]:
tuples = zip(range(5), reversed(range(5))) tuples mapping = dict(tuples) mapping
In [44]:
words = ["apple", "bat", "bar", "atom", "book"]
by_letter = {}
for word in words:
letter = word[0]
if letter not in by_letter:
by_letter[letter] = [word]
else:
by_letter[letter].append(word)
by_letter
In [45]:
by_letter = {}
for word in words:
letter = word[0]
by_letter.setdefault(letter, []).append(word)
by_letter
In [46]:
from collections import defaultdict
by_letter = defaultdict(list)
for word in words:
by_letter[word[0]].append(word)
In [47]:
hash("string")
hash((1, 2, (2, 3)))
hash((1, 2, [2, 3])) # fails because lists are mutable
In [48]:
d = {}
d[tuple([1, 2, 3])] = 5
d
In [49]:
set([2, 2, 2, 1, 3, 3])
{2, 2, 2, 1, 3, 3}
In [50]:
a = {1, 2, 3, 4, 5}
b = {3, 4, 5, 6, 7, 8}
In [53]:
c = a.copy() c |= b c d = a.copy() d &= b d
In [54]:
my_data = [1, 2, 3, 4]
my_set = {tuple(my_data)}
my_set
In [55]:
a_set = {1, 2, 3, 4, 5}
{1, 2, 3}.issubset(a_set)
a_set.issuperset({1, 2, 3})
In [57]:
sorted([7, 1, 2, 6, 0, 3, 2])
sorted("horse race")
In [58]:
seq1 = ["foo", "bar", "baz"] seq2 = ["one", "two", "three"] zipped = zip(seq1, seq2) list(zipped)
In [59]:
seq3 = [False, True] list(zip(seq1, seq2, seq3))
In [60]:
for index, (a, b) in enumerate(zip(seq1, seq2)):
print(f"{index}: {a}, {b}")
In [61]:
list(reversed(range(10)))
In [62]:
strings = ["a", "as", "bat", "car", "dove", "python"] [x.upper() for x in strings if len(x) > 2]
In [63]:
unique_lengths = {len(x) for x in strings}
unique_lengths
In [65]:
loc_mapping = {value: index for index, value in enumerate(strings)}
loc_mapping
In [66]:
all_data = [["John", "Emily", "Michael", "Mary", "Steven"],
["Maria", "Juan", "Javier", "Natalia", "Pilar"]]
In [67]:
names_of_interest = []
for names in all_data:
enough_as = [name for name in names if name.count("a") >= 2]
names_of_interest.extend(enough_as)
names_of_interest
In [68]:
result = [name for names in all_data for name in names
if name.count("a") >= 2]
result
In [69]:
some_tuples = [(1, 2, 3), (4, 5, 6), (7, 8, 9)] flattened = [x for tup in some_tuples for x in tup] flattened
In [70]:
flattened = []
for tup in some_tuples:
for x in tup:
flattened.append(x)
In [71]:
[[x for x in tup] for tup in some_tuples]
In [72]:
def my_function(x, y):
return x + y
In [73]:
my_function(1, 2) result = my_function(1, 2) result
In [74]:
def function_without_return(x):
print(x)
result = function_without_return("hello!")
print(result)
In [75]:
def my_function2(x, y, z=1.5):
if z > 1:
return z * (x + y)
else:
return z / (x + y)
In [76]:
my_function2(5, 6, z=0.7) my_function2(3.14, 7, 3.5) my_function2(10, 20)
In [77]:
a = []
def func():
for i in range(5):
a.append(i)
In [79]:
a = None
def bind_a_variable():
global a
a = []
bind_a_variable()
print(a)
In [80]:
states = [" Alabama ", "Georgia!", "Georgia", "georgia", "FlOrIda",
"south carolina##", "West virginia?"]
In [81]:
import re
def clean_strings(strings):
result = []
for value in strings:
value = value.strip()
value = re.sub("[!#?]", "", value)
value = value.title()
result.append(value)
return result
In [83]:
def remove_punctuation(value):
return re.sub("[!#?]", "", value)
clean_ops = [str.strip, remove_punctuation, str.title]
def clean_strings(strings, ops):
result = []
for value in strings:
for func in ops:
value = func(value)
result.append(value)
return result
In [84]:
clean_strings(states, clean_ops)
In [85]:
for x in map(remove_punctuation, states):
print(x)
In [86]:
def short_function(x):
return x * 2
equiv_anon = lambda x: x * 2
In [87]:
def apply_to_list(some_list, f):
return [f(x) for x in some_list]
ints = [4, 0, 1, 5, 6]
apply_to_list(ints, lambda x: x * 2)
In [88]:
strings = ["foo", "card", "bar", "aaaa", "abab"]
In [89]:
strings.sort(key=lambda x: len(set(x))) strings
In [90]:
some_dict = {"a": 1, "b": 2, "c": 3}
for key in some_dict:
print(key)
In [91]:
dict_iterator = iter(some_dict) dict_iterator
In [93]:
def squares(n=10):
print(f"Generating squares from 1 to {n ** 2}")
for i in range(1, n + 1):
yield i ** 2
In [95]:
for x in gen:
print(x, end=" ")
In [96]:
gen = (x ** 2 for x in range(100)) gen
In [97]:
sum(x ** 2 for x in range(100)) dict((i, i ** 2) for i in range(5))
In [98]:
import itertools
def first_letter(x):
return x[0]
names = ["Alan", "Adam", "Wes", "Will", "Albert", "Steven"]
for letter, names in itertools.groupby(names, first_letter):
print(letter, list(names)) # names is a generator
In [99]:
float("1.2345")
float("something")
In [100]:
def attempt_float(x):
try:
return float(x)
except:
return x
In [101]:
attempt_float("1.2345")
attempt_float("something")
In [103]:
def attempt_float(x):
try:
return float(x)
except ValueError:
return x
In [105]:
def attempt_float(x):
try:
return float(x)
except (TypeError, ValueError):
return x
In [106]:
path = "examples/segismundo.txt" f = open(path, encoding="utf-8")
In [107]:
lines = [x.rstrip() for x in open(path, encoding="utf-8")] lines
In [109]:
with open(path, encoding="utf-8") as f:
lines = [x.rstrip() for x in f]
In [110]:
f1 = open(path) f1.read(10) f2 = open(path, mode="rb") # Binary mode f2.read(10)
In [112]:
import sys sys.getdefaultencoding()
In [113]:
f1.seek(3) f1.read(1) f1.tell()
In [115]:
path
with open("tmp.txt", mode="w") as handle:
handle.writelines(x for x in open(path) if len(x) > 1)
with open("tmp.txt") as f:
lines = f.readlines()
lines
In [116]:
import os
os.remove("tmp.txt")
In [117]:
with open(path) as f:
chars = f.read(10)
chars
len(chars)
In [118]:
with open(path, mode="rb") as f:
data = f.read(10)
data
In [119]:
data.decode("utf-8")
data[:4].decode("utf-8")
In [120]:
sink_path = "sink.txt"
with open(path) as source:
with open(sink_path, "x", encoding="iso-8859-1") as sink:
sink.write(source.read())
with open(sink_path, encoding="iso-8859-1") as f:
print(f.read(10))
In [122]:
f = open(path, encoding='utf-8') f.read(5) f.seek(4) f.read(1) f.close()
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4