Cheatography

# Python Basics Cheat Sheet by leenmajz

Basics of Python Semester 1 in Informatics

### Transf­orming Number Bases

 Transform a number string of base a to a decimanl integer int(st­ring, a) Transform an integer n to binary, octide­cimal or hexide­cimal bin(n), oct(n), hex(n)

### Generating Series of numbers

 [0,a) range(a) [1,a) range(1,a) [a,b) skipping c range(­a,b,c)

### Strings

 Input returns a string input(­'pr­ompt') Tab character \t New line character \n Quotation mark character \" Backslash character \\ String index [a,b) with c steps string­[a:b:c] Length including tabs, newlin­es,.. len(st­ring) Converts a char into an order ord("ch­ar") Converts an order into a char chr(nu­mber)

### String Methods

 Case Modifi­cation str.up­­per(), str.lo­­wer(), str.ca­­pi­t­a­li­­ze(), str.ti­­tle() String Searching and Counting Count occurr­ences str.co­unt­("s") If not found, returns -1 str.fi­nd(­"­s") If not found, returns ValueError str.in­dex­("s") finds last occurence str.rf­ind­("s") Stripping Whitespace str.st­­rip(), str.ls­­tr­ip(), str.rs­­trip() Replac­­ement and Modifi­­cation Expand tabs str.ex­pan­dtabs() Replace a with b str.re­pla­ce(a,b) Splitting and joining str.sp­­lit(), " ".jo­­in­(­list) Alignment and formatting str.ce­­nt­e­r(20, "­­-"), str.lj­­us­t(20, "­­-"), str.rj­­us­t(20, "­­-"), str.zf­­il­l(20) Prefix and suffix removal str.re­­mo­v­e­pr­­efi­­x(­"­p­"), str.re­­mo­v­e­su­­ffi­­x(­"­s­") Testing strings: (returns true or false) str.is­­al­p­ha(), str.is­­ti­tle() Includes non-ASCII digits str.is­­nu­m­e­ric() Only ASCII digits str.is­­di­git() Contains num or alpha or both str.is­­al­num()

### Basic Progra­mming Constructs

 Condit­ional Execution if, elif, else Iterative Execution while, while not Flags active = True while active: Count-­con­trolled loop for More stamenents Leaves the loop break returns to the beginning continue null operation pass

### F Strings

 f"{e­xpr­ession} this is a string­" Break the statement into multiple lines \ Braces can be included using double braces {{ }}
Expres­sions should not use comments using #, nor you can use backsl­ashes to escape in the expression

### List

 Adding or changing elements list.a­­pp­e­n­d(x), list.e­­xt­e­n­d(­­list2), list.i­­ns­e­rt(i, x), list[i]=x Removing elements Removes the first occurence of x list.r­­em­o­ve(x) Removes and returns [i] element list.p­­op(i) Removes all elements from the list list.c­lear() Deletes [i] element del list[i] Searching and counting Returns the index of first x occurence between [a,b) indices and returns "­Val­ueE­rro­r" if x is not found list.i­nde­x(x­,a,b) Counts the occurences of "­x" list.c­oun­t("x­") Sorting Modifies original list and retursn none, key = lambda, len, functi­on_name list.s­ort­(ke­y=None, revers­e=F­alse) Returns a new sorted list sorted­(list, key=None, revers­e=F­alse) List membership "x in list", "x not in list" Iterating through a list for x in list: for i,x in enumer­ate­(list): [expre­ssion for x in list if condition] [expre­ssion if condition else expres­sion2 for x in list] [expre­ssion for x in [expre­ssion2 for y in list]] for x,y in zip(li­st2­,li­st2): Transp­osing the matrix t_matrix = zip(*m­­atrix) Other operaters list.r­eve­rse(), len(list), list.c­opy(), min(list), max(list), y = []+x, y= x[:], y=list(x)

### Sets

 Set creation set = {1,2,3}, set() Adding­­/r­e­m­oving elements set.ad­­d(a), set.up­­da­t­e­(s­­et2), set.cl­­ear() Raises a KeyError if a is not found set.re­­mo­ve(a) Does not give key error set.di­­sc­a­rd(a) Removes and returns a, returns KeyError if a not found set.pop(a) Set operations Set1USet2 set1.u­nio­n(set2) set1|set2 Set1 and Set2 set1.i­nte­rse­cti­on(­set2) set1 & set2 All in Set1 but not in Set2 set1.d­iff­ere­nce­(set2) set1 - set2 In Set1 and Set2 but not in both set1.s­ymm­ert­ric­_di­ffe­ren­ce(­set2) set1 ^ set2 Set comparison True if set1 is subset of set2 set1.i­ssu­bse­t(set2) True if set1 is superset of set2 set1.i­ssu­per­set­(set2) True if set1 has no elements in common with set2 set1.i­sdi­sjo­int­(set2) Set membership x in set, x not in set Looping through sets for x in set {statement for x in set} Set updates removes elements from set1 that are also in set2 set1.d­iff­ere­nce­_up­dat­e(set2) keeps only the inters­ection set1.i­nte­rse­cti­on_­upd­ate­(set2) keeps only the symmetric difference set1.s­ymm­etr­ic_­dif­fer­enc­e_u­pda­te(­set2) More operations set.co­py(), len(set), min(set), max(set)

### Tuples

 Tuple Creation tuple = (1,2,3), single­_tuple = (1,), tuple() Accessing elements tuple[i] [a,b) tuple[a:b] Tuple unpacking unpacks elements into separate variables a,b,c a,b,c = tuple Checking membership x in tuple, x not in tuple Miscel­laneous len(tu­ple), tuple(­sor­ted­(my­_tu­ple)) Named tuples from collec­tions import namedtuple Person = namedt­upl­e('­Per­son', ['name', 'age'] alice = Person­('A­lic­e',30) alice.n­ame, alice.age Tuple methods tuple.c­ou­nt(a), tuple.i­nd­ex(a) Concat­enation tuple1 + tuple2 Looping in a tuple for x in tuple: for i, x in enumer­­at­e­(­tu­­ple): new_tuple = tuple(­exp­ression for x in tuple) for x in zip(li­st1­,li­st2):
Tuples are immutable. Once created, their elements cannot be changed or added.

### Dictionary

 Dictionary Creation dic = {"ke­­y": "­­va­l­u­e"}, dict(), dict(z­ip(­lis­t1,­list2)) Accessing Values Returns "­Key­Err­or" if key is not found dic[key] Returns a defaul­t_value if key is not found dic.ge­t(key, defaul­t_v­alue) Returns value, if key not present, adds the key with defaul­t_value and returns defaul­t_value dic.se­tde­fau­lt(key, defaul­t_v­alue) Updating Values dic[ke­y]=­new­_value Methods returns a view of all keys dic.keys() returns a view of all values dic.va­­lues() returms a view of all key-value pairs dic.it­ems() Adding­/re­moving elements dic[ne­w_k­ey]­=ne­w_value removes and return the value deleted, KeyError if key not found dic.po­p(key) removes and returns last key-value pair as a tuple, KeyError if dic is empty dic.po­pitem() deletes the key-value pair del dic[key] Dictionary size len(dic) More methods Checking membership key in dic, key not in dic Clearing dictionary dic.cl­ear() Copying dic.copy() Adds new keys and updates existing keys dic.up­dat­e(dic2) Looping for key in dic for value in dic.va­lues() for key,value in dic.it­ems(): {key,value for key,value in dic.items}

### Importing Modules

 Standard import import module­­_name module­­_n­a­m­e.f­­un­­ct­i­o­n_­­name() Alias import import module­­_name as a a.func() Dynamic import a = _ _ import _ _ ("mo­dul­e_n­ame­") a.func() Importing and renaming within a module from module­_name import functi­on_name as func func()

### Functions

 Defining a function def functi­on_­nam­e(p­ara­meter1, parame­ter2): statement return result Calling a function print(­­fu­n­c­ti­­on_­­na­m­e­(a,b)) Packing arguments def functi­on_­nam­e(*­arg): functi­on_­nam­e(a­,b,c,d) Unpacking arguments def func(a­,b,­c,d): func(*­tuple) Packing a dictionary def func(**­kw­args): func(key1 = value1, key2 = value2) Global and local variable x = "­global variab­le" def func(): _____g­lobal x # Change x outside the func to be the x inside the func _____x ="local variab­le" Function docume­ntation AKA Docstring def func(): _____" " "This is a docstr­ing­" " " Help help(func)

### Lambda Functions

 Basic square = lambda x: x^2 square(2) Default argument lambda x, y = a: x*y