Show Menu
Cheatography
  1. Home >
  2. Programming >

strings, lists, tuples and dictionaries in python Cheat Sheet by

A cheatsheet for string, lists, tuples and dictionaries in python

STRINGS

Strings
string = "­wor­ds" or 'words'
conect
string­1+s­tring2
multiply
string*3
compare ('if' or 'if not')
string1 == string2 (or != or > or <)
check ('if or 'if not')
'subst­ring' in string
position
string[0] or string[-1] or string[x]
slicing
string­[st­art­:en­d:step]
 
string[:3] or string[1:]
 
string­[::-1] inverted

Slicing strings

slicing:
string­[st­art­:en­d:step]
from start to end
string­[2:5]
from start
string[:5]
to the end
string[2:]
jumping
string­[2:5:2]
negati­ve/­inv­erted
string­[::-1]

Modify strings

remove whites­paces before and after the string
string.st­rip()
or remove any 'chara­cters'
string.st­rip­('ch')
only before­(left) the string
string.ls­trip()
only after(­right) the string
string.rs­trip()
replace string
string.re­pla­ce(­"old value", "new value", counter)
counter is how many occurences from start, nothing is default and means every occurrence
use it to remove whites­paces inside the string
string.re­pla­ce(­" ", "­")
split strings create list from strings
string.sp­lit­(se­par­ato­r,m­axs­plit)
separator is optional, whitespace is default
string.sp­lit­(",")
maxsplit is optional, all occurr­ences is defaul­t(-1)
string.sp­lit­("-",1)
find string
string.fi­nd(­"­val­ue",­sta­rt,end)
find the first occurrence of a substring in a string
string.fi­nd(­"­sub­str­ing­")
start and end are optional
string.fi­nd(­"­sub­str­ing­"­,3,10)
returns the position of the substring
index and find are the same, except that when false find returns -1 and index returns error
string.in­dex­("su­bst­rin­g")
lowercase
string.lo­wer()
uppercase
string.up­per()
capitalize first char upper
string.ca­pit­alize()
title first char of each word upper
string.ti­tle()
join values of a list/d­ict­/tuple/ into string
' '.join­(list)
count the occurences of substring in a string
string.co­unt­('s­ubs­tring')

Format strings

str.format
'Hello, {} and {}'.fo­rma­t(s­tring, string2)
f-string (3.6+)
f'Hello, {string} and {string2}'
Integer numbers into strings*
f'Hello, {strin­g:_}'
'b' - binary
{string:b}
'c' - character (ASCII)
'Hello, {examp­le:­c}'.fo­rma­t(e­xample = 'String', ...)
'd' - decimal
'Hello, {0:d} and {1}.fo­rma­t(s­tri­ng,­str­ing2)
'o' - octal
{string:o}
'x' - hexade­cimal, lowercase
'Hello, {0.x} and {0:X}.f­or­mat­(st­ring)
'X' - hexade­cimal, uppercase
{string:X}
'n' - number, decimal in local language OS
{string:n}
Floati­ng-­point
f'{int­ege­r:f}' (6 standard)
round(a,2)
f'{int­ege­r:.2f}' (2 decimal digits)
'e' ou 'E' - scientific notation (6 standard)
{:e}.f­orm­at(999)
'E' - scientific notation (6 standard)
f'{999­:.3E}'
'g' precisão >=1, round digits p to signif­icant digit
{:g}.f­orm­at(­12.1­23­123­5843)
'n' - same as 'g', but local language OS
f'{12.1­23­123­584­3:n}'
'%' - multiply the number *100 and '%' after
f'{0.0­5:%}'
two digits before '.' and two after
'{:2.2­%}'.fo­rma­t(0.05)
Spacing
'<' left align / '^' center align / '>' right align
'{0:<1­6}'.fo­rma­t(s­tring) / f.'{st­rin­g:^16}' / {:>16}
number of digits
{:4)
whites­paces if the string has less than 16..
{strin­g:16}
choose char instead of whitespace
{*:16}

COLLEC­TIONS

List
collection which is ordered and change­able. Allows duplicate members.
Tuple
collection which is ordered and unchan­geable. Allows duplicate members.
Dictionary
collection which is ordered and change­able. No duplicate members.
Set
collection which is unordered, unchan­geable, and unindexed. No duplicate members.
 

LISTS

Lists
list = ["st­rin­g", "­str­ing­2", integer, Bool]
ordered, change­able, allow duplicates
list = [item1, item2, item3]
Lenght
len(list)
Access [start index includ­ed:end index not]
list[1] / list[-1], list[2:5], list[:5]
Check if Item exists
if "­ite­m" in list:
Change items
list[3] = "­new­_va­lue­"
range of items
list[2:5] = "­new­_va­lue­1", "­new­_va­lue­2"
insert­(in­dex­,value) without replacing any item
list.i­nse­rt(2, "­ite­m")
append() add item to the end
list.a­ppe­nd(­"­ite­m")
extend() add items from other list
list.e­xte­nd(­list2)
works with tuples also
list.e­xte­nd(­tuple)
remove() remove first matching value
list.r­emo­ve(­"­str­ing­")
pop() remove specified index, and returns it
list.p­op(1)
del() remove specified index
list.d­el(3)
clear() empties the list
list.c­lear()
sort() sort the list alphan­ume­rically
list.s­ort()
sort descending
list.s­ort­(re­ver­se=­True)
reverse() order
list.r­eve­rse()
copy() make a copy
list2 = list.c­opy()
or use list()
list3 = list(l­ist2)
Concat­enate Lists
list3 = list1 + list2
or use extend()
list.e­xte­nd(­list2)
count() returns the number of items*
list.c­ount() / list.c­oun­t('­value')
index() finds the item and return its index
list.i­nde­x('­value')
min() / max() / sum()
list.min() list.max() list.sum()
enumer­ate­(index, value)
for i, v in enumer­ate­(list): /n "{i} : {v}'
for loop
for x in list:
through index
for x in range(­len­(li­st)):
while loop
while x <= len(list): /n i+=1
list compre­ehe­nsion
[print[x] for x in list]

TUPLES

Tuples
tuple = ("va­lue­1", int, bool ,"va­lue­1")
are unordered, unchan­geable, allow duplicates
tuple = (item1,)
Lenght
len(tuple)
Access [start index includ­­ed:end index not]
tuple[1] / tuple[-1], tuple[­2:5], tuple[:5]
Check if Item exists
if "­­it­e­m­" in tuple:
Change items tuples are unchan­geable
list = list(t­uple)
convert tuple to list and back to tuple
tuple = tuple(­list)
Concat­enate add tuple to a tuple
tuple1 + tuple2 / tuple1 =+ tuple2
Lists inside a tuple are changeable
tuple = (["v­alu­e1",­"­val­ue2­"], item2, item3)
count() returns the number of items
tuple.c­ount() / tuple.c­ou­nt(­'va­lue')
index() finds the item and return its index
tuple.i­­n­de­­x('­­va­lue')
min() / max() / sum()
tuple.m­in() tuple.m­ax() tuple.s­um()
enumer­­at­e­(­index, value)
for i, v in enumer­­at­e­(­tuple): /n "{i} : {v}'
for loop
for x in tuple:
through index
for x in range(­­le­n­(­tup­le)):
while loop
while x <= len(tu­ple): /n i+=1
list compre­­eh­e­nsion
[print[x] for x in tuple]

DICTIO­NARIES

Dictio­naries
dict = {"ke­y":"v­alu­e", "­key­2":"v­alu­e2"}
ordered, change­­able, do not allow duplicates
dict={­"­key­1": bool,"k­ey2­"­:int, "­key­3": [list]}
dict cannot have same keys
Lenght
len(dict)
Access get the value of the "­key­"
value1 = dict["k­ey1­"]
dict.g­et(­"­key­"­,"return if not found")
value4 = dict.g­et(­"­key­4", "Not found")
List of Keys
x = dict.k­eys()
Check if key exists
if "­­ke­ys" in dict:
if values exists
if "­val­ue1­" in dict.v­alues()
Change values of a key
dict["k­ey"] = value
using update()
dict.u­pda­te(­{'k­ey'­:'v­alue'})
Add
dict["k­ey"] = value
also can use update()
dict.u­pda­te(­{'k­ey'­:'v­alue'})
Remove .pop or popite­m(r­emoves the last key inserted))
dict.p­op(­"­key­") / dict.p­opi­tem()
using del
del dict("k­ey")
del can delete the dictionary completely
del dict
clear empties the dictionary
dict.c­lear() or dict = {}
Copy
dict = dict2 / dict2 = dict.c­opy() / dict2 = dict(dict)
items()
dict.i­tems()
keys()
dict.k­eys()
values()
dict.v­alues()
for loop
for keys in dict:
keys
for keys in dict.k­eys():
values
for values in dict.v­alu­es():
keys and values
for keys, values in dict.i­tems()
               
 

Metadata

  • Languages:
  • Published: 7th November, 2022

Comments

No comments yet. Add yours below!

Add a Comment

Your Comment

Please enter your name.

    Please enter your email address

      Please enter your Comment.

          Related Cheat Sheets

          More Cheat Sheets by corisco

          file handling in python Cheat Sheet