Basic Python

Reading time: 9 minutes

Python Basics

Useful information

list(xrange()) == range() --> Python3 में range, python2 का xrange है (यह एक सूची नहीं है बल्कि एक जनरेटर है)
Tuple और List के बीच का अंतर यह है कि tuple में एक मान की स्थिति उसे अर्थ देती है लेकिन सूचियाँ केवल क्रमबद्ध मान हैं। Tuples में संरचनाएँ होती हैं लेकिन सूचियों में एक क्रम होता है।

Main operations

एक संख्या बढ़ाने के लिए आप उपयोग करते हैं: 3**2 (नहीं 3^2)
यदि आप 2/3 करते हैं तो यह 1 लौटाता है क्योंकि आप दो ints (integers) को विभाजित कर रहे हैं। यदि आप दशमलव चाहते हैं तो आपको floats (2.0/3.0) को विभाजित करना चाहिए।
i >= j
i <= j
i == j
i != j
a और b
a या b
not a
float(a)
int(a)
str(d)
ord("A") = 65
chr(65) = 'A'
hex(100) = '0x64'
hex(100)[2:] = '64'
isinstance(1, int) = True
"a b".split(" ") = ['a', 'b']
" ".join(['a', 'b']) = "a b"
"abcdef".startswith("ab") = True
"abcdef".contains("abc") = True
"abc\n".strip() = "abc"
"apbc".replace("p","") = "abc"
dir(str) = उपलब्ध सभी विधियों की सूची
help(str) = str वर्ग की परिभाषा
"a".upper() = "A"
"A".lower() = "a"
"abc".capitalize() = "Abc"
sum([1,2,3]) = 6
sorted([1,43,5,3,21,4])

Join chars
3 * ’a’ = ‘aaa’
‘a’ + ‘b’ = ‘ab’
‘a’ + str(3) = ‘a3’
[1,2,3]+[4,5]=[1,2,3,4,5]

Parts of a list
‘abc’[0] = ‘a’
'abc’[-1] = ‘c’
'abc’[1:3] = ‘bc’ from [1] to [2]
"qwertyuiop"[:-1] = 'qwertyuio'

Comments
# One line comment
"""
Several lines comment
Another one
"""

Loops

if a:
#somethig
elif b:
#something
else:
#something

while(a):
#comething

for i in range(0,100):
#something from 0 to 99

for letter in "hola":
#something with a letter in "hola"

ट्यूपल्स

t1 = (1,'2,'three')
t2 = (5,6)
t3 = t1 + t2 = (1, '2', 'three', 5, 6)
(4,) = सिंगलटन
d = () खाली ट्यूपल
d += (4,) --> ट्यूपल में जोड़ना
CANT! --> t1[1] == 'New value'
list(t2) = [5,6] --> ट्यूपल से सूची में

सूची (array)

d = [] खाली
a = [1,2,3]
b = [4,5]
a + b = [1,2,3,4,5]
b.append(6) = [4,5,6]
tuple(a) = (1,2,3) --> सूची से ट्यूपल में

शब्दकोश

d = {} खाली
monthNumbers={1:’Jan’, 2: ‘feb’,’feb’:2}—> monthNumbers ->{1:’Jan’, 2: ‘feb’,’feb’:2}
monthNumbers[1] = ‘Jan’
monthNumbers[‘feb’] = 2
list(monthNumbers) = [1,2,’feb’]
monthNumbers.values() = [‘Jan’,’feb’,2]
keys = [k for k in monthNumbers]
a={'9':9}
monthNumbers.update(a) = {'9':9, 1:’Jan’, 2: ‘feb’,’feb’:2}
mN = monthNumbers.copy() #स्वतंत्र प्रति
monthNumbers.get('key',0) #जांचें कि कुंजी मौजूद है, monthNumbers["key"] का मान लौटाएं या 0 यदि यह मौजूद नहीं है

सेट

सेट में कोई पुनरावृत्ति नहीं होती
myset = set(['a', 'b']) = {'a', 'b'}
myset.add('c') = {'a', 'b', 'c'}
myset.add('a') = {'a', 'b', 'c'} #कोई पुनरावृत्ति नहीं
myset.update([1,2,3]) = set(['a', 1, 2, 'b', 'c', 3])
myset.discard(10) #यदि मौजूद है, तो हटा दें, यदि नहीं, तो कुछ नहीं
myset.remove(10) #यदि मौजूद है तो हटा दें, यदि नहीं, तो अपवाद उठाएं
myset2 = set([1, 2, 3, 4])
myset.union(myset2) #myset या myset2 में मान
myset.intersection(myset2) #myset और myset2 में मान
myset.difference(myset2) #myset में मान लेकिन myset2 में नहीं
myset.symmetric_difference(myset2) #मान जो myset और myset2 में नहीं हैं (दोनों में नहीं)
myset.pop() #सेट का पहला तत्व प्राप्त करें और हटा दें
myset.intersection_update(myset2) #myset = दोनों myset और myset2 में तत्व
myset.difference_update(myset2) #myset = myset में तत्व लेकिन myset2 में नहीं
myset.symmetric_difference_update(myset2) #myset = दोनों में नहीं होने वाले तत्व

कक्षाएँ

__It__ में विधि वह होगी जिसका उपयोग क्रमबद्ध करने के लिए किया जाएगा यह तुलना करने के लिए कि क्या इस कक्षा का एक वस्तु दूसरे से बड़ा है

class Person(name):
def __init__(self,name):
self.name= name
self.lastName = name.split(‘ ‘)[-1]
self.birthday = None
def __It__(self, other):
if self.lastName == other.lastName:
return self.name < other.name
return self.lastName < other.lastName #Return True if the lastname is smaller

def setBirthday(self, month, day. year):
self.birthday = date tame.date(year,month,day)
def getAge(self):
return (date time.date.today() - self.birthday).days


class MITPerson(Person):
nextIdNum = 0	# Attribute of the Class
def __init__(self, name):
Person.__init__(self,name)
self.idNum = MITPerson.nextIdNum  —> Accedemos al atributo de la clase
MITPerson.nextIdNum += 1 #Attribute of the class +1

def __it__(self, other):
return self.idNum < other.idNum

map, zip, filter, lambda, sorted और one-liners

Map इस तरह है: [f(x) for x in iterable] --> map(tutple,[a,b]) = [(1,2,3),(4,5)]
m = map(lambda x: x % 3 == 0, [1, 2, 3, 4, 5, 6, 7, 8, 9]) --> [False, False, True, False, False, True, False, False, True]

zip तब रुकता है जब foo या bar में से छोटा रुकता है:

for f, b in zip(foo, bar):
print(f, b)

Lambda एक फ़ंक्शन को परिभाषित करने के लिए उपयोग किया जाता है
(lambda x,y: x+y)(5,3) = 8 --> lambda का उपयोग सरल function के रूप में करें
sorted(range(-5,6), key=lambda x: x** 2) = [0, -1, 1, -2, 2, -3, 3, -4, 4, -5, 5] --> एक सूची को क्रमबद्ध करने के लिए lambda का उपयोग करें
m = filter(lambda x: x % 3 == 0, [1, 2, 3, 4, 5, 6, 7, 8, 9]) = [3, 6, 9] --> फ़िल्टर करने के लिए lambda का उपयोग करें
reduce (lambda x,y: x*y, [1,2,3,4]) = 24

def make_adder(n):
return lambda x: x+n
plus3 = make_adder(3)
plus3(4) = 7 # 3 + 4 = 7

class Car:
crash = lambda self: print('Boom!')
my_car = Car(); my_car.crash() = 'Boom!'

mult1 = [x for x in [1, 2, 3, 4, 5, 6, 7, 8, 9] if x%3 == 0 ]

अपवाद

def divide(x,y):
try:
result = x/y
except ZeroDivisionError, e:
print “division by zero!” + str(e)
except TypeError:
divide(int(x),int(y))
else:
print “result i”, result
finally
print “executing finally clause in any case”

Assert()

यदि शर्त गलत है, तो स्ट्रिंग स्क्रीन पर प्रिंट की जाएगी।

def avg(grades, weights):
assert not len(grades) == 0, 'no grades data'
assert len(grades) == 'wrong number grades'

जनरेटर, yield

एक जनरेटर, कुछ लौटाने के बजाय, "yield" करता है। जब आप इसे एक्सेस करते हैं, यह उत्पन्न किया गया पहला मान "return" करेगा, फिर, आप इसे फिर से एक्सेस कर सकते हैं और यह अगला उत्पन्न किया गया मान लौटाएगा। इसलिए, सभी मान एक ही समय में उत्पन्न नहीं होते हैं और सभी मानों के साथ एक सूची के बजाय इसका उपयोग करके बहुत सारी मेमोरी बचाई जा सकती है।

def myGen(n):
yield n
yield n + 1

g = myGen(6) --> 6
next(g) --> 7
next(g) --> Error

नियमित अभिव्यक्तियाँ

import re
re.search("\w","hola").group() = "h"
re.findall("\w","hola") = ['h', 'o', 'l', 'a']
re.findall("\w+(la)","hola caracola") = ['la', 'la']

विशेष अर्थ:
. --> सब कुछ
\w --> [a-zA-Z0-9_]
\d --> संख्या
\s --> व्हाइटस्पेस वर्ण[ \n\r\t\f]
\S --> गैर-व्हाइटस्पेस वर्ण
^ --> से शुरू होता है
$ --> से समाप्त होता है
+ --> एक या अधिक
* --> 0 या अधिक
? --> 0 या 1 बार

विकल्प:
re.search(pat,str,re.IGNORECASE)
IGNORECASE
DOTALL --> डॉट को नई पंक्ति से मेल खाने की अनुमति दें
MULTILINE --> ^ और $ को विभिन्न पंक्तियों में मेल खाने की अनुमति दें

re.findall("<.*>", "<b>foo</b>and<i>so on</i>") = ['<b>foo</b>and<i>so on</i>']
re.findall("<.*?>", "<b>foo</b>and<i>so on</i>") = ['<b>', '</b>', '<i>', '</i>']

IterTools
product
from itertools import product --> 1 या अधिक सूचियों के बीच संयोजन उत्पन्न करता है, शायद मानों को दोहराते हुए, कार्तेशियन उत्पाद (वितरण गुण)
print list(product([1,2,3],[3,4])) = [(1, 3), (1, 4), (2, 3), (2, 4), (3, 3), (3, 4)]
print list(product([1,2,3],repeat = 2)) = [(1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3), (3, 1), (3, 2), (3, 3)]

permutations
from itertools import permutations --> हर स्थिति में सभी वर्णों के संयोजन उत्पन्न करता है
print list(permutations(['1','2','3'])) = [('1', '2', '3'), ('1', '3', '2'), ('2', '1', '3'),... हर संभावित संयोजन
print(list(permutations('123',2))) = [('1', '2'), ('1', '3'), ('2', '1'), ('2', '3'), ('3', '1'), ('3', '2')] लंबाई 2 के हर संभावित संयोजन

combinations
from itertools import combinations --> बिना वर्णों को दोहराए सभी संभावित संयोजन उत्पन्न करता है (यदि "ab" मौजूद है, तो "ba" उत्पन्न नहीं करता)
print(list(combinations('123',2))) --> [('1', '2'), ('1', '3'), ('2', '3')]

combinations_with_replacement
from itertools import combinations_with_replacement --> वर्ण से आगे सभी संभावित संयोजन उत्पन्न करता है (उदाहरण के लिए, तीसरा तीसरे से मिलाया जाता है लेकिन दूसरे या पहले के साथ नहीं)
print(list(combinations_with_replacement('1133',2))) = [('1', '1'), ('1', '1'), ('1', '3'), ('1', '3'), ('1', '1'), ('1', '3'), ('1', '3'), ('3', '3'), ('3', '3'), ('3', '3')]

डेकोरेटर

डेकोरेटर जो एक फ़ंक्शन को निष्पादित करने में लगने वाले समय को मापता है (from here):

from functools import wraps
import time
def timeme(func):
@wraps(func)
def wrapper(*args, **kwargs):
print("Let's call our decorated function")
start = time.time()
result = func(*args, **kwargs)
print('Execution time: {} seconds'.format(time.time() - start))
return result
return wrapper

@timeme
def decorated_func():
print("Decorated func!")

यदि आप इसे चलाते हैं, तो आप निम्नलिखित जैसा कुछ देखेंगे:

Let's call our decorated function
Decorated func!
Execution time: 4.792213439941406e-05 seconds