def apply_twice(func, arg): return func(func(arg)) def add_five(x): return x + 5 print(apply_twice(add_five, 10)) #Pure function: def pure_function(x, y): temp = x + 2*y return temp / (2*x + y) #Impure function:some_list = [] def impure(arg): some_list.append(arg) def my_func(f, arg): return f(arg) my_func(lambda x: 2*x*x, 5) #named function def polynomial(x): return x**2 + 5*x + 4 print(polynomial(-4)) #lambda print((lambda x: x**2 + 5*x + 4) (-4)) def add_five(x): return x + 5 nums = [11, 22, 33, 44, 55] result = list(map(add_five, nums)) print(result) nums = [11, 22, 33, 44, 55] result = list(map(lambda x: x+5, nums)) print(result) nums = [11, 22, 33, 44, 55] res = list(filter(lambda x: x%2==0, nums)) print(res) xyz = [i for i input_list if isprime(i)] #List Comprehension - One line of for loops [print(i) for i in xyz] #Generators: (print(i) for i in xyz) def is_even(x): if x == 0: return True else: return is_odd(x-1) def is_odd(x): return not is_even(x) print(is_odd(17)) print(is_even(23)) def fib(x): if x == 0 or x == 1: return 1 else: return fib(x-1) + fib(x-2) print(fib(4)) first = {1, 2, 3, 4, 5, 6} second = {4, 5, 6, 7, 8, 9} print(first | second) print(first & second) print(first - second) print(second - first) print(first ^ second) The module itertools is a standard library that contains several functions that are useful in functional programming. One type of function it produces is infinite iterators. The function count counts up infinitely from a value. The function cycle infinitely iterates through an iterable (for instance a list or string). The function repeat repeats an object, either infinitely or a specific number of times. Example: from itertools import count for i in count(3): print(i) if i >=11: break There are many functions in itertools that operate on iterables, in a similar way to map and filter. Some examples: takewhile - takes items from an iterable while a predicate function remains true; chain - combines several iterables into one long one; accumulate - returns a running total of values in an iterable. from itertools import accumulate, takewhile nums = list(accumulate(range(8))) print(nums) print(list(takewhile(lambda x: x<= 6, nums))) There are also several combinatoric functions in itertool, such as product and permutation. These are used when you want to accomplish a task with all possible combinations of some items. Example: from itertools import product, permutations letters = ("A", "B") print(list(product(letters, range(2)))) print(list(permutations(letters))) What is the result of this code? nums = {1, 2, 3, 4, 5, 6} nums = {0, 1, 2, 3} & nums nums = filter(lambda x: x > 1, nums) print(len(list(nums))) What is the result of this code? def power(x, y): if y == 0: return 1 else: return x * power(x, y-1) print(power(2, 3)) Classes We have previously looked at two paradigms of programming - imperative (using statements, loops, and functions as subroutines), and functional (using pure functions, higher-order functions, and recursion). Another very popular paradigm is object-oriented programming (OOP). Objects are created using classes, which are actually the focal point of OOP. The class describes what the object will be, but is separate from the object itself. In other words, a class can be described as an object's blueprint, description, or definition. You can use the same class as a blueprint for creating multiple different objects. Classes are created using the keyword class and an indented block, which contains class methods (which are functions). Below is an example of a simple class and its objects. class Cat: def __init__(self, color, legs): self.color = color self.legs = legs felix = Cat("ginger", 4) rover = Cat("dog-colored", 4) stumpy = Cat("brown", 3) __init__ The __init__ method is the most important method in a class. This is called when an instance (object) of the class is created, using the class name as a function. All methods must have self as their first parameter, although it isn't explicitly passed, Python adds the self argument to the list for you; you do not need to include it when you call the methods. Within a method definition, self refers to the instance calling the method. Instances of a class have attributes, which are pieces of data associated with them. In this example, Cat instances have attributes color and legs. These can be accessed by putting a dot, and the attribute name after an instance. In an __init__ method, self.attribute can therefore be used to set the initial value of an instance's attributes. Example: class Cat: def __init__(self, color, legs): self.color = color self.legs = legs felix = Cat("ginger", 4) print(felix.color) In the example above, the __init__ method takes two arguments and assigns them to the object's attributes. The __init__ method is called the class constructor. Magic Methods More magic methods for common operators: __sub__ for - __mul__ for * __truediv__ for / __floordiv__ for // __mod__ for % __pow__ for ** __and__ for & __xor__ for ^ __or__ for | Magic Methods Python also provides magic methods for comparisons. __lt__ for < __le__ for <= __eq__ for == __ne__ for != __gt__ for > __ge__ for >= Magic Methods There are several magic methods for making classes act like containers. __len__ for len() __getitem__ for indexing __setitem__ for assigning to indexed values __delitem__ for deleting indexed values __iter__ for iteration over objects (e.g., in for loops) __contains__ for in There are many other magic methods that we won't cover here, such as __call__ for calling objects as functions, and __int__, __str__, and the like, for converting objects to built-in types. Example: Object Lifecycle The lifecycle of an object is made up of its creation, manipulation, and destruction. The first stage of the life-cycle of an object is the definition of the class to which it belongs. The next stage is the instantiation of an instance, when __init__ is called. Memory is allocated to store the instance. Just before this occurs, the __new__ method of the class is called. This is usually overridden only in special cases. After this has happened, the object is ready to be used. Data Hiding A key part of object-oriented programming is encapsulation, which involves packaging of related variables and functions into a single easy-to-use object - an instance of a class. A related concept is data hiding, which states that implementation details of a class should be hidden, and a clean standard interface be presented for those who want to use the class. In other programming languages, this is usually done with private methods and attributes, which block external access to certain methods and attributes in a class. The Python philosophy is slightly different. It is often stated as "we are all consenting adults here", meaning that you shouldn't put arbitrary restrictions on accessing parts of a class. Hence there are no ways of enforcing a method or attribute be strictly private. Data Hiding Weakly private methods and attributes have a single underscore at the beginning. This signals that they are private, and shouldn't be used by external code. However, it is mostly only a convention, and does not stop external code from accessing them. Its only actual effect is that from module_name import * won't import variables that start with a single underscore. Example: class Queue: def __init__(self, contents): self._hiddenlist = list(contents) def push(self, value): self._hiddenlist.insert(0, value) def pop(self): return self._hiddenlist.pop(-1) def __repr__(self): return "Queue({})".format(self._hiddenlist) queue = Queue([1, 2, 3]) print(queue) queue.push(0) print(queue) queue.pop() print(queue) print(queue._hiddenlist) Data Hiding Strongly private methods and attributes have a double underscore at the beginning of their names. This causes their names to be mangled, which means that they can't be accessed from outside the class. The purpose of this isn't to ensure that they are kept private, but to avoid bugs if there are subclasses that have methods or attributes with the same names. Name mangled methods can still be accessed externally, but by a different name. The method __privatemethod of class Spam could be accessed externally with _Spam__privatemethod. Example: class Spam: __egg = 7 def print_egg(self): print(self.__egg) s = Spam() s.print_egg() print(s._Spam__egg) print(s.__egg) 1/2 Class Methods Methods of objects we've looked at so far are called by an instance of a class, which is then passed to the self parameter of the method. Class methods are different - they are called by a class, which is passed to the cls parameter of the method. A common use of these are factory methods, which instantiate an instance of a class, using different parameters than those usually passed to the class constructor. Class methods are marked with a classmethod decorator. Example: class Rectangle: def __init__(self, width, height): self.width = width self.height = height def calculate_area(self): return self.width * self.height @classmethod def new_square(cls, side_length): return cls(side_length, side_length) square = Rectangle.new_square(5) print(square.calculate_area()) Static Methods Static methods are similar to class methods, except they don't receive any additional arguments; they are identical to normal functions that belong to a class. They are marked with the staticmethod decorator. Example: class Pizza: def __init__(self, toppings): self.toppings = toppings @staticmethod def validate_topping(topping): if topping == "pineapple": raise ValueError("No pineapples!") else: return True ingredients = ["cheese", "onions", "spam"] if all(Pizza.validate_topping(i) for i in ingredients): pizza = Pizza(ingredients) Properties provide a way of customizing access to instance attributes. They are created by putting the property decorator above a method, which means when the instance attribute with the same name as the method is accessed, the method will be called instead. One common use of a property is to make an attribute read-only. Example: class Pizza: def __init__(self, toppings): self.toppings = toppings @property def pineapple_allowed(self): return False pizza = Pizza(["cheese", "tomato"]) print(pizza.pineapple_allowed) pizza.pineapple_allowed = True Properties Properties can also be set by defining setter/getter functions. The setter function sets the corresponding property's value. The getter gets the value. To define a setter, you need to use a decorator of the same name as the property, followed by a dot and the setter keyword. The same applies to defining getter functions. Example: class Pizza: def __init__(self, toppings): self.toppings = toppings self._pineapple_allowed = False @property def pineapple_allowed(self): return self._pineapple_allowed @pineapple_allowed.setter def pineapple_allowed(self, value): if value: password = input("Enter the password: ") if password == "Sw0rdf1sh!": self._pineapple_allowed = value else: raise ValueError("Alert! Intruder!") pizza = Pizza(["cheese", "tomato"]) print(pizza.pineapple_allowed) pizza.pineapple_allowed = True print(pizza.pineapple_allowed) Define a decorator that would be used to add a setter to the property egg. @egg.setter A Simple Game Object-orientation is very useful when managing different objects and their relations. That is especially useful when you are developing games with different characters and features. Let's look at an example project that shows how classes are used in game development. The game to be developed is an old fashioned text-based adventure game. Below is the function handling input and simple parsing.def get_input(): command = input(": ").split() verb_word = command[0] if verb_word in verb_dict: verb = verb_dict[verb_word] else: print("Unknown verb {}". format(verb_word)) return if len(command) >= 2: noun_word = command[1] print (verb(noun_word)) else: print(verb("nothing")) def say(noun): return 'You said "{}"'.format(noun) verb_dict = { "say": say, } while True: get_input() A Simple Game The next step is to use classes to represent game objects.class GameObject: class_name = "" desc = "" objects = {} def __init__(self, name): self.name = name GameObject.objects[self.class_name] = self def get_desc(self): return self.class_name + "\n" + self.desc class Goblin(GameObject): class_name = "goblin" desc = "A foul creature" goblin = Goblin("Gobbly") def examine(noun): if noun in GameObject.objects: return GameObject.objects[noun].get_desc() else: return "There is no {} here.".format(noun) We created a Goblin class, which inherits from the GameObjects class. We also created a new function examine, which returns the objects description. Now we can add a new "examine" verb to our dictionary and try it out! verb_dict = { "say": say, "examine": examine, } A Simple Game This code adds more detail to the Goblin class and allows you to fight goblins.class Goblin(GameObject): def __init__(self, name): self.class_name = "goblin" self.health = 3 self._desc = " A foul creature" super().__init__(name) @property def desc(self): if self.health >=3: return self._desc elif self.health == 2: health_line = "It has a wound on its knee." elif self.health == 1: health_line = "Its left arm has been cut off!" elif self.health <= 0: health_line = "It is dead." return self._desc + "\n" + health_line @desc.setter def desc(self, value): self._desc = value def hit(noun): if noun in GameObject.objects: thing = GameObject.objects[noun] if type(thing) == Goblin: thing.health = thing.health - 1 if thing.health <= 0: msg = "You killed the goblin!" else: msg = "You hit the {}".format(thing.class_name) else: msg ="There is no {} here.".format(noun) return msg Result:>>> : hit goblin You hit the goblin : examine goblin goblin A foul creature It has a wound on its knee. : hit goblin You hit the goblin : hit goblin You killed the goblin! : examine goblin A goblin goblin A foul creature It is dead. : Regular Expressions Regular expressions are a powerful tool for various kinds of string manipulation. They are a domain specific language (DSL) that is present as a library in most modern programming languages, not just Python. They are useful for two main tasks: - verifying that strings match a pattern (for instance, that a string has the format of an email address), - performing substitutions in a string (such as changing all American spellings to British ones). Domain specific languages are highly specialized mini programming languages. Regular expressions are a popular example, and SQL (for database manipulation) is another. Private domain-specific languages are often used for specific industrial purposes. import re str = "My name is David. Hi David." pattern = r"David" newstr = re.sub(pattern, "Amy", str) print(newstr) import re pattern = r"([\w\.-]+)@([\w\.-]+)(\.[\w\.]+)" str = "Please contact info@sololearn.com for assistance" match = re.search(pattern, str) if match: print(match.group()) Content Models Metadata: Content that sets up the presentation or behavior of the rest of the content. These elements are found in the head of the document. Elements: , , ,

, <style>, <title> Embedded: Content that imports other resources into the document. Elements: <audio>, <video>, <canvas>, <iframe>, <img>, <math>, <object>, <svg> Interactive: Content specifically intended for user interaction. Elements: <a>, <audio>, <video>, <button>, <details>, <embed>, <iframe>, <img>, <input>, <label>, <object>, <select>, <textarea> Heading: Defines a section header. Elements: <h1>, <h2>, <h3>, <h4>, <h5>, <h6>, <hgroup> Phrasing: This model has a number of inline level elements in common with HTML4. Elements: <img>, <span>, <strong>, <label>, <br />, <small>, <sub>, and more. Making Elements Draggable The drag and drop feature lets you "grab" an object and drag it to a different location. To make an element draggable, just set the draggable attribute to true: <img draggable="true" /> Any HTML element can be draggable. The API for HTML5 drag and drop is event-based. Example:<!DOCTYPE HTML> <html> <head> <script> function allowDrop(ev) { ev.preventDefault(); } function drag(ev) { ev.dataTransfer.setData("text", ev.target.id); } function drop(ev) { ev.preventDefault(); var data = ev.dataTransfer.getData("text"); ev.target.appendChild(document.getElementById(data)); } defines a rectangle: Try It Yourself The following code will draw a green-filled rectangle. defines a line segment: Try It Yourself (x1, y1) define the start coordinates(x2, y2) define the end coordinates. defines shapes built from multiple line definitions: Try It Yourself Points are the polyline's coordinates. The code below will draw a black check sign: The

Python Snippets