import module1[, module2[,... moduleN]

1 [‘‘, ‘/usr/lib/python3.4‘, ‘/usr/lib/python3.4/plat-x86_64-linux-gnu‘,
2 ‘/usr/lib/python3.4/lib-dynload‘, ‘/usr/local/lib/python3.4/dist-packages‘, ‘/usr/lib/python3/dist-packages‘]　　

from modname import name1[, name2[, ... nameN]]

from modname import *

 1#import test
 2#from test import add　　

import sys,os
BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(BASE_DIR)
import hello
hello.hello1()

if __name__==‘__main__‘:
    print(‘ok‘)

##-------------cal.py
def add(x,y):
 
    return x+y
##-------------main.py
import cal      #from module import cal
 
def main():
 
    cal.add(1,2)
     
##--------------bin.py
from module import main
 
main.main()

 1 import time
 2  
 3 # 1 time() :返回当前时间的时间戳
 4 time.time()  #1473525444.037215
 5  
 6 #----------------------------------------------------------
 7  
 8 # 2 localtime([secs])
 9 # 将一个时间戳转换为当前时区的struct_time。secs参数未提供，则以当前时间为准。
10 time.localtime() #time.struct_time(tm_year=2016, tm_mon=9, tm_mday=11, tm_hour=0,
11 # tm_min=38, tm_sec=39, tm_wday=6, tm_yday=255, tm_isdst=0)
12 time.localtime(1473525444.037215)
13  
14 #----------------------------------------------------------
15  
16 # 3 gmtime([secs]) 和localtime()方法类似，gmtime()方法是将一个时间戳转换为UTC时区（0时区）的struct_time。
17  
18 #----------------------------------------------------------
19  
20 # 4 mktime(t) : 将一个struct_time转化为时间戳。
21 print(time.mktime(time.localtime()))#1473525749.0
22  
23 #----------------------------------------------------------
24  
25 # 5 asctime([t]) : 把一个表示时间的元组或者struct_time表示为这种形式：‘Sun Jun 20 23:21:05 1993‘。
26 # 如果没有参数，将会将time.localtime()作为参数传入。
27 print(time.asctime())#Sun Sep 11 00:43:43 2016
28  
29 #----------------------------------------------------------
30  
31 # 6 ctime([secs]) : 把一个时间戳（按秒计算的浮点数）转化为time.asctime()的形式。如果参数未给或者为
32 # None的时候，将会默认time.time()为参数。它的作用相当于time.asctime(time.localtime(secs))。
33 print(time.ctime())  # Sun Sep 11 00:46:38 2016
34  
35 print(time.ctime(time.time()))  # Sun Sep 11 00:46:38 2016
36  
37 # 7 strftime(format[, t]) : 把一个代表时间的元组或者struct_time（如由time.localtime()和
38 # time.gmtime()返回）转化为格式化的时间字符串。如果t未指定，将传入time.localtime()。如果元组中任何一个
39 # 元素越界，ValueError的错误将会被抛出。
40 print(time.strftime("%Y-%m-%d %X", time.localtime()))#2016-09-11 00:49:56
41  
42 # 8 time.strptime(string[, format])
43 # 把一个格式化时间字符串转化为struct_time。实际上它和strftime()是逆操作。
44 print(time.strptime(‘2011-05-05 16:37:06‘, ‘%Y-%m-%d %X‘))
45  
46 #time.struct_time(tm_year=2011, tm_mon=5, tm_mday=5, tm_hour=16, tm_min=37, tm_sec=6,
47 #  tm_wday=3, tm_yday=125, tm_isdst=-1)
48  
49 #在这个函数中，format默认为："%a %b %d %H:%M:%S %Y"。
50  
51  
52 # 9 sleep(secs)
53 # 线程推迟指定的时间运行，单位为秒。
54  
55 # 10 clock()
56 # 这个需要注意，在不同的系统上含义不同。在UNIX系统上，它返回的是“进程时间”，它是用秒表示的浮点数（时间戳）。
57 # 而在WINDOWS中，第一次调用，返回的是进程运行的实际时间。而第二次之后的调用是自第一次调用以后到现在的运行
58 # 时间，即两次时间差。

help(time)
help(time.asctime)

 1 import random
 2  
 3 print(random.random())#(0,1)----float
 4  
 5 print(random.randint(1,3))  #[1,3]
 6  
 7 print(random.randrange(1,3)) #[1,3)
 8  
 9 print(random.choice([1,‘23‘,[4,5]]))#23
10  
11 print(random.sample([1,‘23‘,[4,5]],2))#[[4, 5], ‘23‘]
12  
13 print(random.uniform(1,3))#1.927109612082716
14  
15  
16 item=[1,3,5,7,9]
17 random.shuffle(item)
18 print(item)

sys.argv           命令行参数List，第一个元素是程序本身路径
sys.exit(n)        退出程序，正常退出时exit(0)
sys.version        获取Python解释程序的版本信息
sys.maxint         最大的Int值
sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform       返回操作系统平台名称

import sys,time
for i in range(10):
    sys.stdout.write(‘#‘)
    time.sleep(1)
    sys.stdout.flush()

import json
x="[null,true,false,1]"
print(eval(x))
print(json.loads(x))

 1 #----------------------------序列化
 2 import json
 3  
 4 dic={‘name‘:‘alvin‘,‘age‘:23,‘sex‘:‘male‘}
 5 print(type(dic))#<class ‘dict‘>
 6  
 7 j=json.dumps(dic)
 8 print(type(j))#<class ‘str‘>
 9  
10  
11 f=open(‘序列化对象‘,‘w‘)
12 f.write(j)  #-------------------等价于json.dump(dic,f)
13 f.close()
14 #-----------------------------反序列化<br>
15 import json
16 f=open(‘序列化对象‘)
17 data=json.loads(f.read())#  等价于data=json.load(f)

 1 ##----------------------------序列化
 2 import pickle
 3  
 4 dic={‘name‘:‘alvin‘,‘age‘:23,‘sex‘:‘male‘}
 5  
 6 print(type(dic))#<class ‘dict‘>
 7  
 8 j=pickle.dumps(dic)
 9 print(type(j))#<class ‘bytes‘>
10  
11  
12 f=open(‘序列化对象_pickle‘,‘wb‘)#注意是w是写入str,wb是写入bytes,j是‘bytes‘
13 f.write(j)  #-------------------等价于pickle.dump(dic,f)
14  
15 f.close()
16 #-------------------------反序列化
17 import pickle
18 f=open(‘序列化对象_pickle‘,‘rb‘)
19  
20 data=pickle.loads(f.read())#  等价于data=pickle.load(f)
21  
22  
23 print(data[‘age‘])    

 1 import shelve
 2  
 3 f = shelve.open(r‘shelve.txt‘)
 4  
 5 # f[‘stu1_info‘]={‘name‘:‘alex‘,‘age‘:‘18‘}
 6 # f[‘stu2_info‘]={‘name‘:‘alvin‘,‘age‘:‘20‘}
 7 # f[‘school_info‘]={‘website‘:‘oldboyedu.com‘,‘city‘:‘beijing‘}
 8 #
 9 #
10 # f.close()
11  
12 print(f.get(‘stu_info‘)[‘age‘])

 1 [DEFAULT]
 2 ServerAliveInterval = 45
 3 Compression = yes
 4 CompressionLevel = 9
 5 ForwardX11 = yes
 6   
 7 [bitbucket.org]
 8 User = hg
 9   
10 [topsecret.server.com]
11 Port = 50022
12 ForwardX11 = no

 1 import configparser
 2   
 3 config = configparser.ConfigParser()
 4 config["DEFAULT"] = {‘ServerAliveInterval‘: ‘45‘,
 5                       ‘Compression‘: ‘yes‘,
 6                      ‘CompressionLevel‘: ‘9‘}
 7   
 8 config[‘bitbucket.org‘] = {}
 9 config[‘bitbucket.org‘][‘User‘] = ‘hg‘
10 config[‘topsecret.server.com‘] = {}
11 topsecret = config[‘topsecret.server.com‘]
12 topsecret[‘Host Port‘] = ‘50022‘     # mutates the parser
13 topsecret[‘ForwardX11‘] = ‘no‘  # same here
14 config[‘DEFAULT‘][‘ForwardX11‘] = ‘yes‘<br>
15 with open(‘example.ini‘, ‘w‘) as configfile:
16    config.write(configfile)

 1 import hashlib
 2  
 3 m=hashlib.md5()# m=hashlib.sha256()
 4  
 5 m.update(‘hello‘.encode(‘utf8‘))
 6 print(m.hexdigest())  #5d41402abc4b2a76b9719d911017c592
 7  
 8 m.update(‘alvin‘.encode(‘utf8‘))
 9  
10 print(m.hexdigest())  #92a7e713c30abbb0319fa07da2a5c4af
11  
12 m2=hashlib.md5()
13 m2.update(‘helloalvin‘.encode(‘utf8‘))
14 print(m2.hexdigest()) #92a7e713c30abbb0319fa07da2a5c4af

1 import hashlib
2  
3 # ######## 256 ########
4  
5 hash = hashlib.sha256(‘898oaFs09f‘.encode(‘utf8‘))
6 hash.update(‘alvin‘.encode(‘utf8‘))
7 print (hash.hexdigest())#e79e68f070cdedcfe63eaf1a2e92c83b4cfb1b5c6bc452d214c1b7e77cdfd1c7

1 import hmac
2 h = hmac.new(‘alvin‘.encode(‘utf8‘))
3 h.update(‘hello‘.encode(‘utf8‘))
4 print (h.hexdigest())#320df9832eab4c038b6c1d7ed73a5940

1 #Popen它的构造函数如下：
2  
3 subprocess.Popen(args, bufsize=0, executable=None, stdin=None, stdout=None,stderr=None, preexec_fn=None, close_fds=False, shell=False,<br>                 cwd=None, env=None, universal_newlines=False, startupinfo=None, creationflags=0)

 1 import subprocess
 2  
 3 a=subprocess.Popen(‘ls‘)#  创建一个新的进程,与主进程不同步
 4  
 5 print(‘>>>>>>>‘,a)#a是Popen的一个实例对象
 6  
 7 ‘‘‘
 8 >>>>>>> <subprocess.Popen object at 0x10185f860>
 9 __init__.py
10 __pycache__
11 log.py
12 main.py
13  
14 ‘‘‘
15  
16 # subprocess.Popen(‘ls -l‘,shell=True)
17  
18 # subprocess.Popen([‘ls‘,‘-l‘])

1 import subprocess
2  
3 # subprocess.Popen(‘ls‘)
4 p=subprocess.Popen(‘ls‘,stdout=subprocess.PIPE)#结果跑哪去啦?
5  
6 print(p.stdout.read())#这这呢:b‘__pycache__\nhello.py\nok.py\nweb\n‘

 1 supprocess模块提供了一些函数，方便我们用于创建进程来实现一些简单的功能。
 2  
 3 subprocess.call(*popenargs, **kwargs)
 4 运行命令。该函数将一直等待到子进程运行结束，并返回进程的returncode。如果子进程不需要进行交 互,就可以使用该函数来创建。
 5  
 6 subprocess.check_call(*popenargs, **kwargs)
 7 与subprocess.call(*popenargs, **kwargs)功能一样，只是如果子进程返回的returncode不为0的话，将触发CalledProcessError异常。在异常对象中，包 括进程的returncode信息。
 8  
 9 check_output(*popenargs, **kwargs)
10 与call()方法类似，以byte string的方式返回子进程的输出，如果子进程的返回值不是0，它抛出CalledProcessError异常，这个异常中的returncode包含返回码，output属性包含已有的输出。
11  
12 getstatusoutput(cmd)/getoutput(cmd)
13 这两个函数仅仅在Unix下可用，它们在shell中执行指定的命令cmd，前者返回(status, output)，后者返回output。其中，这里的output包括子进程的stdout和stderr。

1 import logging  
2 logging.debug(‘debug message‘)  
3 logging.info(‘info message‘)  
4 logging.warning(‘warning message‘)  
5 logging.error(‘error message‘)  
6 logging.critical(‘critical message‘) 

 1 import logging  
 2 logging.basicConfig(level=logging.DEBUG,  
 3                     format=‘%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s‘,  
 4                     datefmt=‘%a, %d %b %Y %H:%M:%S‘,  
 5                     filename=‘/tmp/test.log‘,  
 6                     filemode=‘w‘)  
 7   
 8 logging.debug(‘debug message‘)  
 9 logging.info(‘info message‘)  
10 logging.warning(‘warning message‘)  
11 logging.error(‘error message‘)  
12 logging.critical(‘critical message‘)

 1 import logging
 2 
 3 logger = logging.getLogger()
 4 # 创建一个handler，用于写入日志文件
 5 fh = logging.FileHandler(‘test.log‘)
 6 
 7 # 再创建一个handler，用于输出到控制台
 8 ch = logging.StreamHandler()
 9 
10 formatter = logging.Formatter(‘%(asctime)s - %(name)s - %(levelname)s - %(message)s‘)
11 
12 fh.setFormatter(formatter)
13 ch.setFormatter(formatter)
14 
15 logger.addHandler(fh) #logger对象可以添加多个fh和ch对象
16 logger.addHandler(ch)
17 
18 logger.debug(‘logger debug message‘)
19 logger.info(‘logger info message‘)
20 logger.warning(‘logger warning message‘)
21 logger.error(‘logger error message‘)
22 logger.critical(‘logger critical message‘)

1 logger.debug(‘logger debug message‘)  
2 logger.info(‘logger info message‘)  
3 logger.warning(‘logger warning message‘)  
4 logger.error(‘logger error message‘)  
5 logger.critical(‘logger critical message‘)  

 1 ##################################################
 2 logger1 = logging.getLogger(‘mylogger‘)
 3 logger1.setLevel(logging.DEBUG)
 4 
 5 logger2 = logging.getLogger(‘mylogger‘)
 6 logger2.setLevel(logging.INFO)
 7 
 8 logger1.addHandler(fh)
 9 logger1.addHandler(ch)
10 
11 logger2.addHandler(fh)
12 logger2.addHandler(ch)
13 
14 logger1.debug(‘logger1 debug message‘)
15 logger1.info(‘logger1 info message‘)
16 logger1.warning(‘logger1 warning message‘)
17 logger1.error(‘logger1 error message‘)
18 logger1.critical(‘logger1 critical message‘)
19   
20 logger2.debug(‘logger2 debug message‘)
21 logger2.info(‘logger2 info message‘)
22 logger2.warning(‘logger2 warning message‘)
23 logger2.error(‘logger2 error message‘)
24 logger2.critical(‘logger2 critical message‘)

 1 import re
 2  
 3 ret=re.findall(‘a..in‘,‘helloalvin‘)
 4 print(ret)#[‘alvin‘]
 5  
 6  
 7 ret=re.findall(‘^a...n‘,‘alvinhelloawwwn‘)
 8 print(ret)#[‘alvin‘]
 9  
10  
11 ret=re.findall(‘a...n$‘,‘alvinhelloawwwn‘)
12 print(ret)#[‘awwwn‘]
13  
14  
15 ret=re.findall(‘a...n$‘,‘alvinhelloawwwn‘)
16 print(ret)#[‘awwwn‘]
17  
18  
19 ret=re.findall(‘abc*‘,‘abcccc‘)#贪婪匹配[0,+oo]  
20 print(ret)#[‘abcccc‘]
21  
22 ret=re.findall(‘abc+‘,‘abccc‘)#[1,+oo]
23 print(ret)#[‘abccc‘]
24  
25 ret=re.findall(‘abc?‘,‘abccc‘)#[0,1]
26 print(ret)#[‘abc‘]
27  
28  
29 ret=re.findall(‘abc{1,4}‘,‘abccc‘)
30 print(ret)#[‘abccc‘] 贪婪匹配

1 ret=re.findall(‘abc*?‘,‘abcccccc‘)
2 print(ret)#[‘ab‘]

 1 #--------------------------------------------字符集[]
 2 ret=re.findall(‘a[bc]d‘,‘acd‘)
 3 print(ret)#[‘acd‘]
 4  
 5 ret=re.findall(‘[a-z]‘,‘acd‘)
 6 print(ret)#[‘a‘, ‘c‘, ‘d‘]
 7  
 8 ret=re.findall(‘[.*+]‘,‘a.cd+‘)
 9 print(ret)#[‘.‘, ‘+‘]
10  
11 #在字符集里有功能的符号: - ^ \
12  
13 ret=re.findall(‘[1-9]‘,‘45dha3‘)
14 print(ret)#[‘4‘, ‘5‘, ‘3‘]
15  
16 ret=re.findall(‘[^ab]‘,‘45bdha3‘)
17 print(ret)#[‘4‘, ‘5‘, ‘d‘, ‘h‘, ‘3‘]
18  
19 ret=re.findall(‘[\d]‘,‘45bdha3‘)
20 print(ret)#[‘4‘, ‘5‘, ‘3‘]

1 ret=re.findall(‘I\b‘,‘I am LIST‘)
2 print(ret)#[]
3 ret=re.findall(r‘I\b‘,‘I am LIST‘)
4 print(ret)#[‘I‘]

 1 #-----------------------------eg1:
 2 import re
 3 ret=re.findall(‘c\l‘,‘abc\le‘)
 4 print(ret)#[]
 5 ret=re.findall(‘c\\l‘,‘abc\le‘)
 6 print(ret)#[]
 7 ret=re.findall(‘c\\\\l‘,‘abc\le‘)
 8 print(ret)#[‘c\\l‘]
 9 ret=re.findall(r‘c\\l‘,‘abc\le‘)
10 print(ret)#[‘c\\l‘]
11  
12 #-----------------------------eg2:
13 #之所以选择\b是因为\b在ASCII表中是有意义的
14 m = re.findall(‘\bblow‘, ‘blow‘)
15 print(m)
16 m = re.findall(r‘\bblow‘, ‘blow‘)
17 print(m)

1 m = re.findall(r‘(ad)+‘, ‘add‘)
2 print(m)
3  
4 ret=re.search(‘(?P<id>\d{2})/(?P<name>\w{3})‘,‘23/com‘)
5 print(ret.group())#23/com
6 print(ret.group(‘id‘))#23

1 ret=re.search(‘(ab)|\d‘,‘rabhdg8sd‘)
2 print(ret.group())#ab

 1 import re
 2 #1
 3 re.findall(‘a‘,‘alvin yuan‘)    #返回所有满足匹配条件的结果,放在列表里
 4 #2
 5 re.search(‘a‘,‘alvin yuan‘).group()  #函数会在字符串内查找模式匹配,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以
 6                                      # 通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。
 7  
 8 #3
 9 re.match(‘a‘,‘abc‘).group()     #同search,不过尽在字符串开始处进行匹配
10  
11 #4
12 ret=re.split(‘[ab]‘,‘abcd‘)     #先按‘a‘分割得到‘‘和‘bcd‘,在对‘‘和‘bcd‘分别按‘b‘分割
13 print(ret)#[‘‘, ‘‘, ‘cd‘]
14  
15 #5
16 ret=re.sub(‘\d‘,‘abc‘,‘alvin5yuan6‘,1)
17 print(ret)#alvinabcyuan6
18 ret=re.subn(‘\d‘,‘abc‘,‘alvin5yuan6‘)
19 print(ret)#(‘alvinabcyuanabc‘, 2)
20  
21 #6
22 obj=re.compile(‘\d{3}‘)
23 ret=obj.search(‘abc123eeee‘)
24 print(ret.group())#123

import re
ret=re.finditer(‘\d‘,‘ds3sy4784a‘)
print(ret)        #<callable_iterator object at 0x10195f940>
 
print(next(ret).group())
print(next(ret).group())

import re
 
ret=re.findall(‘www.(baidu|oldboy).com‘,‘www.oldboy.com‘)
print(ret)#[‘oldboy‘]     这是因为findall会优先把匹配结果组里内容返回,如果想要匹配结果,取消权限即可
 
ret=re.findall(‘www.(?:baidu|oldboy).com‘,‘www.oldboy.com‘)
print(ret)#[‘www.oldboy.com‘]