python语法一览
# mymodule.py
from package_name import module
from module import global_variable
from module import class
# it is discouraged, it will import all into current module namespace
from module import *
import module
# use as to rename in current scope
# support follow three ways of from express
from module import class as newclassname
from package import module as newmodulename
from module import global_variable as newvar
# not support
from module import method
# global variable, variable scope is current module
# they can be accessed by mymodule.global_var1, mymodule.global_var2
global_var1 =1
global_var2 = None
# start with '_' can be stop to be imported by from module import *, but can be import by : from mymodule import _global_var3
_global_var3 = 0
# global method
def global_method():
# when need use global variable, you should use 'global' keyword
global global_var1
print('i am global static method')
# control flow
if (something) and (something1) or (something11) or ( not something111()):
do_something()
elif something2 = 2 or something2 != 3:
do_something2()
else:
do_someelse()
# support while, but not support do...while
while(something):
do()
else: # this is optional
do_else()
for var in collection:
do1
# suporrt break, continue
# with
with Myclass:
dosomething()
with Myclass() as my:
my.dosomething()
# define a class
# class suport multi-Hirent
class Myclass(Thread,Request):
# private static property, python interpreter will rename this as _Myclass__private_static_property, don't access this property by this way, this will be different name in different python version
__private_static_property = None
# public static property, this can be accessed by Myclass.public_static_property1
# public_static_property1 = None
# constructor, can define parameter freedom , python doesn't support overload constructor, but can simulate by __new__ with different parameter
def __init__(self, *args, **kwargs):
# call super class's constructor
Thread.__init__(args, kwargs)
# call super class's constructor
Request.__init__(args, kwargs)
# add instance property
self.instance_propert1 = None
self.instance_propert2 = None
# 1. execute before __init__
# 2. must return a instance of current class
# 3. instance will transfer to __init__ as self parameter
def __new__(cls, *args, **kwargs):
# class private static variable
cls.__private_static_propert2 = None
# class public static variable, this way is the same as public_static_property1
cls.public_static_property2 = None
# must return a instance of current class
return Myclass(args,kwargs)
# enter method
def __enter__(self):
print(' iam enter')
# destroy method, will auto call by python intepreter
# no args
def __destroy__(self):
print('destory object')
# exit method
def __exit__(self):
print('i am exit')
#public instance method
def get_property():
return self.instance_property2
# private instance method
def __count():
self.instance_property1 += 1
# override super class's method
def run():
print('i am override method')
# overload method
def run(arg):
print('i am overload method')
# 1. when excute module, this variable '__name__' will be current module name
# 2. the main module(python program startup module) will be special, it will be '__main__',
if __name__ == '__main__':
test()