What are some Python concepts I must know?

Python has some neat features you don’t need every day but are still occasionally useful.

1. Nested functions (closures):

Example:

def a(b):
   def c(d):
       return b+d
   return c

A will return a function that adds B to it’s argument. Very useful to pass to functions like map() or filter().

2. Decorators

Example:

def decorator(f):
    def b(*args):
        print ("calling "+f.__name__)
        return f()
    return b
 
@decorator
def func(a, b):
    return a*b

The decorator means that the func=decorator(func). In this case, decorator is a closure that prints “calling func” before every call to func. You could, for example, have a profiling decorator that measures the time between the start and end of your function. There are also built in decorators like the attribute function to make something like a C# get {}.

3. Iterator comprehension:

(i**2 for i in range(2, 24, 2) if str(i)[0]!='1')

Very usefull features. You can replace complicated loops and lists with neat, compact statements, and it’s also much faster than loops or list comprehension because the values are not stored but rather calculated when you need them. If you break out of a loop using a iterator, the rest of the iterator will not be stored or calculated.

4. __name__

class MyProgram(object):
    def __init__(self):
        pass #you should only set variables,
             #not anything error prone here
    def run(self):
        pass #main program logic
    def cleanup(self):
        pass #your cleanup code here
 
if __name__=="__main__":
    try:
        prog=MyProgram()
        prog.run()
    finally:
        prog.cleanup()

The __name__==”__main__” makes the code not execute when the file is imported from another script. In this way, if you want to use some of the class code from another project, just import it. You won’t have to worry about side effects.

Putting logic in a class has many benefits even for small projects. Keeping local data strictly separate from global data means you have less variable names to worry about. You can easily make functions without having to worry about how data will be passed back and forth.

5. Lambda

filter(lambda x: str(x)[0] in ('1','3'), range(0,99))

define a quick, inline function. Similar to the => in C#.

6. Looping over files

file=open("checksums")
checksums={i.split("\t")[0]: i.split("\t")[1] for i in file}
f.close()

I just read a csv file into my dictionary in 3 lines, and it isn’t even unreadable. This is why I love python.

7. Tuples

g=(1,2,2312,"blo")

A tuple is basically a immutable, yet much better version of a list. It’s much faster, saves a lot of memory, you can’t change it by accident, and it’s hash-able so it can be used as a dictionary key.

8. Useful builtin modules:

import itertools #stuff like Cartesian product and permutation
 
import functools #lots of decorators, for example a decorator that stores the last output in a cage and uses it again if possible
 
import sys, os #do system level stuff
 
import subprocess, multithreading, multiprocessing #various multithreading strategies
 
import curses #mess with the terminal
 
import tkinter #make fancy GUIs
 
import pickle #serialize objects
 
import urllib, ftplib, httplib, poplib #communicate with the internet
 
import md5, zlib, gzip, csv, xml, json #common file formats

9. Useful third party modules:

import twisted #asyncronious network programming
 
import pygame #graphics programming
 
import crypto #user friendly cryptography
 
import httplib2 #more standards-compliant http
 
import numpy #advanced math and statistics
 
import django #python HTTP server framewor

Update Time Zone In Linux Using Commad Prompt

dpkg-reconfigure tzdata

Erp

https://github.com/nabinhait/erpbook

Git Tutorials

1.Initialize git repository

git init-It will create a new empty directory /.git/.The directory is hidden by default

2.Current status of git

git status-all file changes in the repository

3.Add newly created file to repository

git add filename-added file in staging area.not a part of repository yet.To store the file in repository we need to commit changes

4.Store file repository

git commit -m "commit commands"

5.Add Multiple of same type
use wildcard
git add ".txt"-where .txt is file extension

6.Log of commit
git log

7.Remote Repository
Create an account in git to use git remotely,create a project

To use git in remote repository
use
git remote add origin https://github.com/try-git/try_git.git
name of our remote is origin .default local branch is master

7.save all data to remote using push commands
 git push -u origin master
-u will save parameter,so next time only use git push

8.get changes in repository by pull command
git pull origin master

9.Find difference between two commit using diff command

git diff HEAD-Where head refers to last commit

Staged file are files that are ready to commit

10.remove a staged file using git reset
git reset staged file name

11.Files can be changes to how they were in last commit using git checkout command

git checkout -- filename

-- refers that no arguments after --

14.create a branch

mostly all bug anf features are commited to branch and merge to master

git branch branch name

15.show branch name

git branch

16.To switch between branch use git checkout branch name
git checkout branch name

17.To remove files from git use rm

git rm

Learn Python From A Single Image

Python In Single Image-Link

Learn Javascript From A Single Image

Javascript in one image-link

Round a number to nearest 100 using python

Use round function

Example

>>> round(12351.221212,-2)
12400.0
>>>round(12349.221212,-2)
12300.0