Create your own awesome maps

Even on the go

with our free apps for iPhone, iPad and Android

Get Started

Already have an account?
Log In

python3 in one pic by Mind Map: python3 in one pic
5.0 stars - 3 reviews range from 0 to 5

python3 in one pic

import this

""" The Zen of Python, by Tim Peters Beautiful is better than ugly. Explicit is better than implicit. Simple is better than complex. Complex is better than complicated. Flat is better than nested. Sparse is better than dense. Readability counts. Special cases aren't special enough to break the rules. Although practicality beats purity. Errors should never pass silently. Unless explicitly silenced. In the face of ambiguity, refuse the temptation to guess. There should be one-- and preferably only one --obvious way to do it. Although that way may not be obvious at first unless you're Dutch. Now is better than never. Although never is often better than *right* now. If the implementation is hard to explain, it's a bad idea. If the implementation is easy to explain, it may be a good idea. Namespaces are one honking great idea -- let's do more of those! """

Syntax Roles

Case-sensitive

a = 1 A = 2 print(a is not A) # True

Comments

# Comments will be ignored

Code blocks are defined by their indentation

Use 4 spaces per indentation level

Native Datatypes

Number

integer, a = 1 b = 0x10 # 16
print(type(a)) # <class 'int'>

float, c = 1.2 d = .5 # 0.5 g = .314e1 # 3.14
print(type(g)) # <class 'float'>

complex, e = 1+2j f = complex(1, 2)
print(type(e)) # <class 'complex'> print(f == e) # True

Operators, + - * / % **, ## Operators: + - * / ** // % print(1 + 1) # 2 print(2 - 2) # 0 print(3 * 3) # 9 print(5 / 4) # 1.25 print(2 ** 10) # 1024 print(5 // 4) # 1 print(5 % 4) # 1

Casting, # Integer/String -> Float, print(float.__doc__), """ float(x) -> floating point number Convert a string or number to a floating point number, if possible. """, print(float(3)) # 3.0 print(3 / 1) # 3.0 print(float("3.14")) # 3.14, # Float/String -> Integer, print(int.__doc__), """ int(x=0) -> integer int(x, base=10) -> integer ... """, print(int(3.14)) # 3 print(int("3", base = 10)) # 3 print(int("1010", base = 2)) # 10 print(int("0b1010", base = 0)) # 10

String

s1 = ‘:dog:\n’ s2 = "Dogge's home" s3 = """ Hello, Dogge! """
print(type(s1)) # <class 'str'> print("%s, %s, %s" % (s1, s2, s3))
# :dog: # , Dogge's home, # Hello, # Dogge!

Length, print(len(s1)) # 2

Slicing, s = 'study and practice' print('{0}:{1}'.format(s[:5], s[-8:])) # study:practice

Operator, +, print("abc" + "." + "xyz") # "abc.xyz"

Casting, print(str.__doc__), """ str(object='') -> str str(bytes_or_buffer[, encoding[, errors]]) -> str """, print(str(3.14)) # "3.14" print(str(3)) # "3" print(str([1,2,3])) # "[1,2,3]" print(str((1,2,3))) # "(1,2,3)" print(str({1,2,3})) # "{1,2,3}" print(str({'python': '*.py', 'javascript': '*.js'})) "{'python': '*.py', 'javascript': '*.js'}"

Byte

list of ascii character

# 0-255/x00-xff, byt = b'abc' print(type(byt)) # <class 'bytes'> print(byt[0] == 'a')# False print(byt[0] == 97) # True

Length, print(len(byt)) # 3

Boolean

True

False

print(type(True)) # <class 'bool'>

None

print(None is None) # True

print(type(None)) # <class 'NoneType'>

List

l = ['python', 3, 'in', 'one'] print(type(l)) # <class 'list'>

Length, print(len(l)) # 4

Slicing, print(l[0]) # 'python' print(l[-1]) # 'one' print(l[1:-1]) # [3, 'in']

Alter, l.append('pic') # None # l == ['python', 3, 'in', 'one', 'pic'] l.insert(2, '.4.1') # None # l == ['python', 3, '.4.1', 'in', 'one', 'pic'] l.extend(['!', '!']) # l == ['python', 3, '.4.1', 'in', 'one', 'pic', '!', '!'] print(l.pop()) # '!' # l == ['python', 3, '.4.1', 'in', 'one', 'pic', '!'] print(l.pop(2)) # '.4.1' # l == ['python', 3, 'in', 'one', 'pic', '!'] l.remove("in") # l == ['python', 3, 'one', 'pic', '!'] del l[2] # l == ['python', 3, 'pic', '!']

Index, print(l.index('pic')) # 2

Tuple

Immutable list

tp = (1, 2, 3, [4, 5]) print(type(tp)) # <class 'tuple'> ## Length print(len(tp)) # 4 print(tp[2]) # 3 tp[3][1] = 6 print(tp) # (1, 2, 3, [4, 6]) ## Single element tp = (1, ) # Not tp = (1)

assign multiple values, v = (3, 2, 'a') (c, b, a) = v print(a, b, c) # a 2 3

Set

st = {'s', 'e', 'T'} print(type(st)) # <class 'set'> ## Length print(len(st)) # 3 ## Empty st = set() print(len(st)) # 0 st = {} print(type(st)) # <class 'dict'>

Alter, st = set(['s', 'e', 'T']) st.add('t') # st == {'s', 'e', 't', 'T'} st.add('t') # st == {'s', 'e', 't', 'T'} st.update(['!', '!']) # st == {'s', 'e', 't', 'T', '!'} st.discard('t') # st == {'T', '!', 's', 'e'} # No Error st.remove('T') # st == {'s', 'e', '!'} # KeyError st.pop() # 's' # st == {'e'} st.clear() # st == set()

Dict

dic = {} print(type(dic)) # <class 'dict'> dic = {'k1': 'v1', 'k2': 'v2'} ## Length print(len(dic)) # 2

print(dic['k2']) # 'v2' print(dic.get('k1')) # 'v1' print(dic.get('k3', 'v0')) # 'v0' dic['k2'] = 'v3' print(dic) # {'k1': 'v1', 'k2': 'v3'} print('k2' in dic) # True print('v1' in dic) # False

Standard Libraries

Pythonic

Module

Package

""" MyModule/ |--SubModuleOne/ |--__init__.py |--smo.py # smo.py def run(): print("Running MyModule.SubModuleOne.smo!") """ from MyModule.SubModule import smo smo.run() # Running MyModule.SubModuleOne.smo!

Search Path

1. current directory 2. echo $PYTHONPATH 3. sys.path

Import

import os print(os.name) # posix from sys import version_info as PY_VERSION print("VERSON: {}.{}".format(PY_VERSION.major, PY_VERSION.minor)) # VERSON: 3.5 from math import * print(pi) # 3.141592653589793

Class (OOP)

Override

class Animal: """This is an Animal""" def __init__(self, can_fly = False): self.can_fly = can_fly def fly(self): if self.can_fly: print("I CAN fly!") else: print("I can not fly!") class Bird: """This is a Bird""" def fly(self): print("I'm flying high!") bird = Bird() bird.fly() # I'm flying high!

Inheritance

class Animal: """This is an Animal""" def __init__(self, can_fly = False): self.can_fly = can_fly def fly(self): if self.can_fly: print("I CAN fly!") else: print("I can not fly!") class Dog(Animal): """This is a Dog""" def bark(self): print("Woof!") d = Dog() d.fly() # I can not fly! d.bark() # Woof!

Instance

class Animal: pass class Human: pass a = Animal() h = Human() print(isinstance(a, Animal)) # True print(isinstance(h, Animal)) # False

__init__ & self

class Animal: """This is an Animal""" def __init__(self, can_fly = False): print("Calling __init__() when instantiation!") self.can_fly = can_fly def fly(self): if self.can_fly: print("I CAN fly!") else: print("I can not fly!") a = Animal() # Calling __init__() when instantiation! a.fly() # I can not fly! b = Animal(can_fly = True) # Calling __init__() when instantiation! b.fly() # I CAN fly!

Class

class Animal: """This is an Animal""" def fly(_): print("I can fly!") a = Animal() a.fly() # I can fly! print(a.__doc__) # This is an Animal

Function

Arguments

Decorator, def log(f): def wrapper(): print("Hey log~") f() print("Bye log~") return wrapper @log def fa(): print("This is fa!") # Equal to... def fb(): print("This is fb!") fb = log(fb) fa() print("*"*10) fb(), # Hey log~ # This is fa! # Bye log~ # ********** # Hey log~ # This is fb! # Bye log~

Lambda, pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')] pairs.sort(key=lambda pair: pair[1]) print(pairs) "[(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]" pairs.sort(key=lambda pair: pair[0]) print(pairs) "[(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]"

arbitrary arguments, def f(*args, **kargs): print("args ", args) print("kargs ", kargs) print("FP: {} & Scripts: {}".format(kargs.get("fp"), "/".join(args))) f("Python", "Javascript", ms = "C++", fp = "Haskell") # args ('Python', ‘Javascript’) # kargs {'ms': 'C++', 'fp': 'Haskell'} # FP: Haskell and Scripts: Python/Javascript, def f(*args, con = " & "): print(isinstance(args, tuple)) print("Hello", con.join(args)) f("Python", "C", "C++", con = "/") # True # "Hello Python/C/C++"

keyword arguments, def f(v, l = "Python"): """return '$v, $l'""" return "{}, {}!".format(v, l) print(f("Hello")) # "Hello, Python!" print(f("Bye", "C/C++")) # "Bye, C/C++!"

default arguments, def f(name = "World"): """return 'Hello, $name'""" return "Hello, {}!".format(name) print(f()) # 'Hello, World!' print(f("Python")) # 'Hello, Python!'

Definition

def f(): """return 'Hello, World!'""" return "Hello, World!" print(f()) # "Hello, World!" print(f.__doc__) # "return 'Hello, World!'"

Flow Control

Comprehensions

Dict, ls = {s: len(s) for s in ["Python", "Javascript", "Golang"]} print(ls) # {'Python': 6, 'Javascript': 10, 'Golang': 6} sl = {v: k for k, v in ls.items()} print(sl) # {10: 'Javascript', 6: 'Golang'}

Set, s = {2 * x for x in range(10) if x ** 2 > 3} print(s) # {4, 6, 8, 10, 12, 14, 16, 18} pairs = set([(x, y) for x in range(2) for y in range(2)]) print(pairs) # {(0, 1), (1, 0), (0, 0), (1, 1)}

List, pairs = [(x, y) for x in range(2) for y in range(2)] print(pairs) # [(0, 0), (0, 1), (1, 0), (1, 1)], s = [2 * x for x in range(10) if x ** 2 > 3] print(s) #[4, 6, 8, 10, 12, 14, 16, 18]

Loop

Iterators & Generators, def reverse(data): for index in range(len(data)-1, -1, -1): yield data[index] nohtyp = reverse("Python") print(nohtyp) # <generator object reverse at 0x1029539e8> for i in nohtyp: print(i) # n # o # h # t # y # P, python = iter("Python") print(python) # <str_iterator object at 0x10293f8d0> for i in python: print(i) # P # y # t # h # o # n

break / continue, for n in range(2, 10): if n % 2 == 0: print("Found an even number ", n) continue if n > 5: print("GT 5!") break

While, prod = 1 i = 1 while i < 10: prod = prod * i i += 1 print(prod)

For, for i in "Hello": print(i)

If

import sys if sys.version_info.major < 3: print("Version 2.X") elif sys.version_info.major > 3: print("Future") else: print("Version 3.X")