# Python Learning

Contents

You can use the Jupyter notebook to code with Python programming language in cells in addition to adding some text using the markdown language.

And also in the jupyter notebook, you can import any Python package in the Python library and use it directly, for example, Numpy Matplotlib and Pandas libraries, you can use all of them by importing them, using the import statement.

A list is a mutable and ordered collection of items.

 1 2 3 4 5 6 7 8  #List creation new_list = [] new_list1 = list() print(new_list) print(new_list1) #Type of list type(new_list) 
 1 2 3 4 5 6  #List of numbers nums = [1, 2, 3, 4, 5] nums1 = list((10, 15, 20)) print(type(nums)) print(type(nums1)) 
 1 2 3  #List of strings str_list = ["blue", "red", "yellow"] print(str_list) 
 1 2 3  #Muliple types in a list mixed_list = ["Blue", True, 1, 3.5] print("The mixed list:", mixed_list) 
 1 2 3  #List in a list nums = [1, 2, [3, 3.1, 3.5], 4, 5] print(nums) 
 1 2 3 4 5 6 7  #Accessing list items with the index number print(nums[0]) print(nums[1]) print(nums[2]) #Knowing the number of items in list len(nums) 
 1 2 3 4 5 6  nums[0:3] # [1, 2, [3, 3.1, 3.5]] nums[:3] # [1, 2, [3, 3.1, 3.5]] nums[3:] # [4, 5] print(nums[-1]) print(nums[-2]) 
 1 2 3 4 5 6 7  colors = ["red", "black", "white"] "white" in colors # False "blue" not in colors # True colors.append("yellow") print(colors) # ['red', 'black', 'white', 'yellow'] 
  1 2 3 4 5 6 7 8 9 10 11  colors.insert(2, "green") colors # ['red', 'black', 'green', 'white', 'yellow'] colors.pop(3) # 'white' colors # ['red', 'black', 'green', 'yellow'] colors.extend(["indigo", "orange"]) colors # ['red', 'black', 'green', 'yellow', 'indigo', 'orange'] del colors[0] colors # ['black', 'green', 'yellow', 'indigo', 'orange'] 
 1 2 3 4 5 6 7 8  nums = tuple((1, 2, 3, 4, 5)) nums1 = (1, 2, 3, 4, 5, 6, 7, 8) print(type(nums)) # print(type(nums1)) # type(nums) # tuple len(nums1) # 8 
 1 2 3 4 5 6 7 8 9  nums1[0] # 1 nums1[0:3] # (1, 2, 3) nums[1] = 10 # --------------------------------------------------------------------------- # TypeError Traceback (most recent call last) # Input In [3], in () # ----> 1 nums[1] = 10 # # TypeError: 'tuple' object does not support item assignment 

You cannot change the value of the second item from the nums tuple. But if you want to change the variable that is called nums, you can change the whole variable. You can change the tuple completely, not a specific item.

  1 2 3 4 5 6 7 8 9 10 11  new_fruits = tuple(("Orange", "Cherry", "Lemon")) "Orange" in new_fruits # True "Cherry" not in new_fruits # False del new_fruits new_fruits # --------------------------------------------------------------------------- # NameError Traceback (most recent call last) # in # ----> 1 new_fruits # # NameError: name 'new_fruits' is not defined 

If you want to access the new_fruits after that, after deleting it, you will get an error after that because this tuple doesn’t exist anymore.

Dictionary is mutable key value pairs to store collections. Syntax: {key:value} or dict({key:value})

 1 2 3 4 5  new_D = {"Ronaldo": 36, "Jane": 34, "Smith": 27} new_D1 = dict({'Daniel': 33, 'Samuel': 24, 'Sunny': 30}) print(type(new_D)) # print(type(new_D1)) # 
 1 2 3 4 5 6 7 8  #Sequence of tuples children = dict({ ("Child1", "5"), ("Child2", "6"), ("Child3", "7"), }) type(children) # dict # It's possible to insert tuples, in a dictionary. 
 1 2 3 4 5 6 7 8 9  new_D["Jane"] # 34 new_D["Jane"] = "35" new_D # {'Ronaldo': 36, 'Jane': '35', 'Smith': 27} del new_D["Jane"] new_D # {'Ronaldo': 36, 'Smith': 27} "Lucas" in new_D # False # You should know that a dictionary items are changeable or mutable so you can change the value. of any key, you can change the value of any item from inside a dictionary. 

Set is unordered and immutable collection, no duplicates in sets. Syntax: {1,2,3} or set([1,2,3])

 1 2 3 4 5 6  set_nums = set((2, 4, 6, 8, 10)) set_nums1 = {1, 2, 3, 4, 5, 6} print(set_nums) # {2, 4, 6, 8, 10} print(set_nums1) # {1, 2, 3, 4, 5, 6} print(type(set_nums)) # print(type(set_nums1)) # 
  1 2 3 4 5 6 7 8 9 10 11  set('Python') # {'P', 'h', 'n', 'o', 't', 'y'} x = set({1: "name", 2: "age"}) type(x) # set del x x # --------------------------------------------------------------------------- # NameError Traceback (most recent call last) # Input In [33], in () # ----> 1 x # # NameError: name 'x' is not defined 

You can use the For loop to execute a part of code once for each element in sequence or collection of elements, or you can use it to iterate over sequences or over collection of values. For example, you can use the follow up to iterate over lists, to iterate over tuples and so on.

  1 2 3 4 5 6 7 8 9 10 11  for chars in "Arknights": print(chars) # A # r # k # n # i # g # h # t # s 
 1 2 3 4 5 6 7  for i in range(5): print("Arknights") # Arknights # Arknights # Arknights # Arknights # Arknights 
 1 2 3 4 5 6 7  for i in range(5, 15): print(i + i) # 10 # 12 # 14 # 16 # 18 
 1 2 3 4 5  for i in [1,2,3]: print(i) # 1 # 2 # 3 
• Functions: block of related statements to perform actions.
• Function types: Built-in and User-Defined Functions
• Call it to work and you can call it many time.
 1 2 3 4 5 6 7  abs(11) # 11 abs(-15.33) # 15.33 bool(1) # True bool(0) # False complex(3, 4) # (3+4j) x = dict(name = "Ahmed", age = 28) x # {'name': 'Ahmed', 'age': 28} 
  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45  dir(x) # ['__class__', # '__class_getitem__', # '__contains__', # '__delattr__', # '__delitem__', # '__dir__', # '__doc__', # '__eq__', # '__format__', # '__ge__', # '__getattribute__', # '__getitem__', # '__gt__', # '__hash__', # '__init__', # '__init_subclass__', # '__ior__', # '__iter__', # '__le__', # '__len__', # '__new__', # '__or__', # '__reduce__', # '__reduce_ex__', # '__repr__', # '__reversed__', # '__ror__', # '__setattr__', # '__setitem__', # '__sizeof__', # '__str__', # '__subclasshook__', # 'clear', # 'copy', # 'fromkeys', # 'get', # 'items', # 'keys', # 'pop', # 'popitem', # 'setdefault', # 'update', # 'values'] # We used the dir function to get all the attributes and methods related to the variable that stores our dictionary type or our dictionary data structure. 
  1 2 3 4 5 6 7 8 9 10 11  x = input("Entered name: ") # Entered name: ... print("Hi, Functions!") # Hi, Functions! sum([1, 2, 3]) # 6 x = [1, 2, 3] y = [4, 5, 6] z = zip(x, y) print(list(z)) # [(1, 4), (2, 5), (3, 6)] # Z, the variable that contains the zip operation, this will design a list based on tuples. You will see all the tuples inside that list, as in the output, as you can see, exactly one from the first list and four from the second list. The first item on the first item, the second item and the second item. 

There are different uses for the Lambda Function.

 1 2 3 4 5 6  multiply = lambda x: x * 20 print(multiply(2)) # 40 remaind = lambda n: n % 2 print(remaind(11)) # 1 print(remaind(20)) # 0 
 1 2 3 4 5  def testing(n): return lambda i: i * n r1 = testing(120) print(r1(5)) # 600 print(r2(10)) # 2000 
 1 2 3 4 5 6 7 8 9  # return a generic function, then use lambda expression. def handle(f, x): return f(x) def is_even(x): return x % 2 == 0 kq1 = handle(lambda x: x ** 2, 9) print("kq1= ", kq1) # 81 kq2 = handle(lambda x: is_even(x), 7) print("kq2= ", kq2) # False 
  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17  # using function and lambda in switch-case dict. from math import * def indirect(i,f=0,x=0): switcher = { 0: lambda:'zero', 1: lambda: exp(x), 2: lambda: f(x) } func = switcher.get(i,lambda: "Invalid") return func() print(indirect(0)) # zero print(indirect(2,lambda x: x ** 2,9)) # 81 print(indirect(1)) # 1 print(indirect(1,0,1)) # 2.718281828459045 print("A= ", indirect(2,lambda x: log1p(x),9)) #Return the natural logarithm of 1+x (base e) # 2.302585092994046 print(indirect(3,lambda x: exp(x),9)) # Invalid