模块调用,datetime,time,logging,递归,双层装饰器, json,pickle迭代器和生成器

模块名.函数名
例：
import sys
import module

import module
#从某个模块导入某个功能
from module.xx.xx import xx
#从某个模块导入某个功能，并且给他个别名
from module.xx.xx import xx as rename  
#从某个模块导入所有
from module.xx.xx import *

需要编译环境：yum install python-devel gcc
下载源码包：wget http://xxxxxxxxxxx.tar
解压：tar -xvf xxx.tar
进入：cd xxx
编译：python setup.py build
安装：python setup.py install

#s4.py
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#  Author: Jason Wang

def login():
    print("login")

def logout():
    print(‘logout‘)

sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
#os.path.abspath(__file__)获取文件的绝对路径，os.path.dirname获取此文件的父目录，此例子为将Atm_shopping加入到系统path路径中去

>>> os.getcwd()
‘/Users/JasonWang/PycharmProjects/sd13‘

>>> os.chdir(‘/usr‘)
>>> os.getcwd()
‘/usr‘
>>> 

>>> os.curdir
‘.‘

>>> os.pardir
‘..‘

>>> os.makedirs(‘test/a1‘)
>>> os.listdir()
[‘__pycache__‘, ‘account.py‘, ‘commons.py‘, ‘index.py‘, ‘manager.py‘, ‘maopao.py‘, ‘test‘]

>>> os.removedirs(‘test/a1‘)
>>> os.listdir()
[‘__pycache__‘, ‘account.py‘, ‘commons.py‘, ‘index.py‘, ‘manager.py‘, ‘maopao.py‘]
>>> 

>>> os.mkdir(‘test‘)
>>> os.listdir()
[‘__pycache__‘, ‘account.py‘, ‘commons.py‘, ‘index.py‘, ‘manager.py‘, ‘maopao.py‘, ‘test‘]

>>> os.rmdir(‘test‘)
>>> os.listdir()
[‘__pycache__‘, ‘account.py‘, ‘commons.py‘, ‘index.py‘, ‘manager.py‘, ‘maopao.py‘]

>>> os.rename(‘test‘,‘test1‘)
>>> os.listdir()
[‘__pycache__‘, ‘account.py‘, ‘commons.py‘, ‘index.py‘, ‘manager.py‘, ‘maopao.py‘, ‘test1‘]

>>> os.stat(‘test1‘)
os.stat_result(st_mode=16877, st_ino=2841750, st_dev=16777220, st_nlink=2, st_uid=501, st_gid=20, st_size=68, st_atime=1465982539, st_mtime=1465982462, st_ctime=1465982462)
>>> 

>>> os.sep
‘/‘

>>> os.pathsep ‘:‘

>>> os.name
‘posix‘

>>> os.system(‘uptime‘)
 9:38  up 15 mins, 1 user, load averages: 2.24 2.55 2.02
0

>>> os.environ

os.path模块主要用于文件的属性获取，
os.path.abspath(path)  返回path规范化的
*os.path.split(path)  将path分割成目录和文件名二元组返回
*os.path.dirname(path)  返回path的目录。其实就是os.path.split(path)的第一个元素
*os.path.basename(path)  返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path)  如果path是绝对路径，返回True
os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回False
*os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path)  返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间

sys.argv   命令行参数List，第一个元素是程序本身路径
sys.modules 返回系统导入的模块字段，key是模块名，value是模块
sys.exit(n)        退出程序，正常退出时exit(0)
sys.version        获取Python解释程序的版本信息
sys.maxint         最大的Int值
sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform       返回操作系统平台名称
sys.stdout.write(‘please:‘)
val = sys.stdin.readline()[:-1]
sys.modules.keys() 返回所有已经导入的模块名
sys.modules.values() 返回所有已经导入的模块
sys.exc_info()     获取当前正在处理的异常类,exc_type、exc_value、exc_traceback当前处理的异常详细信息
sys.exit(n)        退出程序，正常退出时exit(0)
sys.hexversion     获取Python解释程序的版本值，16进制格式如：0x020403F0
sys.version        获取Python解释程序的
sys.api_version    解释器的C的API版本
sys.version_info
‘final’表示最终,也有’candidate’表示候选，serial表示版本级别，是否有后继的发行
sys.displayhook(value)      如果value非空，这个函数会把他输出到sys.stdout，并且将他保存进__builtin__._.指在python的交互式解释器里，’_’ 代表上次你输入得到的结果，hook是钩子的意思，将上次的结果钩过来
sys.getdefaultencoding()    返回当前你所用的默认的字符编码格式
sys.getfilesystemencoding() 返回将Unicode文件名转换成系统文件名的编码的名字
sys.setdefaultencoding(name)用来设置当前默认的字符编码，如果name和任何一个可用的编码都不匹配，抛出 LookupError，这个函数只会被site模块的sitecustomize使用，一旦别site模块使用了，他会从sys模块移除
sys.builtin_module_names    Python解释器导入的模块列表
sys.executable              Python解释程序路径
sys.getwindowsversion()     获取Windows的版本
sys.copyright      记录python版权相关的东西
sys.byteorder      本地字节规则的指示器，big-endian平台的值是’big’,little-endian平台的值是’little’
sys.exc_clear()    用来清除当前线程所出现的当前的或最近的错误信息
sys.exec_prefix    返回平台独立的python文件安装的位置
sys.stderr         错误输出
sys.stdin          标准输入
sys.stdout         标准输出
sys.platform       返回操作系统平台名称
sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.maxunicode     最大的Unicode值
sys.maxint         最大的Int值
sys.version        获取Python解释程序的版本信息
sys.hexversion     获取Python解释程序的版本值，16进制格式如：0x020403F0

>>> import time
>>> time.time()
1466041557.853502

>>> time.ctime()#将时间戳转化为字符串格式Thu Jun 16 09:49:10 2016，默认是当前系统时间的时间戳
‘Thu Jun 16 09:49:10 2016‘
>>> time.ctime(time.time()-3600)#ctime可以接收一个时间戳作为参数，返回该时间戳的字符串形式 Wed Thu Jun 16 08:49:33 2016‘
‘Thu Jun 16 08:49:33 2016‘

>>> time.gmtime()#将时间戳转化为struct_time格式，默认是当前系统时间戳
time.struct_time(tm_year=2016, tm_mon=6, tm_mday=16, tm_hour=1, tm_min=52, tm_sec=57, tm_wday=3, tm_yday=168, tm_isdst=0)
>>> time.gmtime(time.time()-3600)
time.struct_time(tm_year=2016, tm_mon=6, tm_mday=16, tm_hour=0, tm_min=53, tm_sec=18, tm_wday=3, tm_yday=168, tm_isdst=0)

说明：
struct_time格式也是一种时间表现形式，其实有点类似列表或元祖的形式
共有九个元素，分别表示，同一个时间戳的struct_time会因为时区不同而不同顺序为
年 tm_year
月 tm_mon
日 tm_mday
小时 tm_hour
分钟 tm_min
秒 tm_sec
周 tm_wday，注意周是从0开始计数的，也就是周一是0
一年中的第几天 tm_yday
是否是夏令日 tm_isdst（也没啥卵用）

>>> time.localtime()# 同样是将时间戳转化为struct_time，只不过显示的是本地时间，gmtime显示的是标准时间（格里尼治时间）
time.struct_time(tm_year=2016, tm_mon=6, tm_mday=16, tm_hour=9, tm_min=55, tm_sec=24, tm_wday=3, tm_yday=168, tm_isdst=0)

>>> time.mktime(time.localtime())# 将struct_time时间格式转化为时间戳
1466042217.0

>>> time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())# 将struct_time时间格式转化为自定义的字符串格式
‘2016-06-16 09:58:43‘

说明：
"%Y-%m-%d %H:%M:%S"就是我们自定义的字符串个"%Y有点类似于占位符

>>> time.strptime("2016-06-16","%Y-%m-%d")# 与trftime相反，将字符串格式转化为struct_time格式
time.struct_time(tm_year=2016, tm_mon=6, tm_mday=16, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=168, tm_isdst=-1)

说明：
第一个参数是时间的字符串形式，第二个参数是第一个参数的格式，格式要与字符串对应
另外时分秒默认是0，可以省略，但是年月日不可以省

>>> time.asctime(time.localtime())# 将struct_time转化为字符串形式
‘Thu Jun 16 10:05:42 2016‘

>>> datetime.date.today()# 返回当前日期的字符串形式2016-02-17
datetime.date(2016, 6, 16)
>>> print(datetime.date.today())
2016-06-16

>>> print( datetime.datetime.now())#返回的时间的字符串形式
2016-06-16 10:10:37.612443
>>> print( datetime.datetime.now().timestamp())# 转化为struct_time格式
1466043058.141845

>>> datetime.date.fromtimestamp(time.time()- 3600 *24)
datetime.date(2016, 6, 15)
>>> print(datetime.date.fromtimestamp(time.time()- 3600 *24))
2016-06-15

>>> print(datetime.datetime.now() - datetime.timedelta(days = 2))
2016-06-14 10:27:09.652336

递归函数
def d():
    return "123"
def c():
    r = d()
    return r
def b():
    r = c()
    return r
def a():
    r = b()
    print(r)
a()
#123
def func(n):
    n += 1
    if n >=4:
        return ‘end‘
    return func(n)
r = func(1)
print(r)
#end

#阶乘递归
def func(num):
    if num == 1:
        return 1
    return num*func(num-1)
a = func(7)
print(a)
#5040

1 def binary_search(data_list,find_num):
 2     mid_pos = int(len(data_list) /2 ) # 获取中间的索引
 3     mid_val = data_list[mid_pos] # 获取中间的索引对相应元素，也就是值
 4     print(data_list)
 5     if len(data_list) >1: # 递归结束条件，也就是规模绩效
 6         if mid_val > find_num: # 中间的值比要找的值大，说明在中间值左边
 7             print("[%s] should be in left of [%s]" %(find_num,mid_val))
 8             binary_search(data_list[:mid_pos],find_num) # 递归自己，继续查找自己的左边（也就是递归要求里的缩小调用规模）
 9         elif mid_val < find_num: # 中间的值比要找的值大，说明在中间值左边
10             print("[%s] should be in right of [%s]" %(find_num,mid_val))
11             binary_search(data_list[mid_pos + 1:],find_num)
12         else: # 如果既不大于也不小于说明正好等于
13             print("Find ", find_num)
14  
15     else:
16         # 当列表的大小等于1的时候，不在调用自己，结束递归
17         if mid_val == find_num: # 判断最用一个元素是否等于要查找的数
18             print("Find ", find_num)
19         else:
20             print("cannot find [%s] in data_list" %find_num)
21  
22 if __name__ == ‘__main__‘:
23     primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103,104]
24     binary_search(primes,5)
25     binary_search(primes,66)

1 [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 104]
 2 [5] should be in left of [47]
 3 [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43]
 4 [5] should be in left of [19]
 5 [2, 3, 5, 7, 11, 13, 17]
 6 [5] should be in left of [7]
 7 [2, 3, 5]
 8 [5] should be in right of [3]
 9 [5]
10 Find  5
11 [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 104]
12 [66] should be in right of [47]
13 [53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 104]
14 [66] should be in left of [79]
15 [53, 59, 61, 67, 71, 73]
16 [66] should be in left of [67]
17 [53, 59, 61]
18 [66] should be in right of [59]
19 [61]
20 cannot find [66] in data_list
复制代码

>>> import logging
>>> logging.warning("user [Jason] attempted wrong password more than 5 times")
WARNING:root:user [Jason] attempted wrong password more than 5 times

import logging
logging.basicConfig(filename=‘test.log‘,level=logging.INFO)
logging.debug(‘This message should come to log files‘)
logging.info(‘come in this‘)
logging.warning(‘hey it came out‘)

import logging
logging.basicConfig(format=‘%(asctime)s %(message)s‘, datefmt=‘%m/%d/%Y %I:%M:%S %p‘)
logging.warning(‘is when this event was logged.‘)
 
#输出
12/12/2010 11:46:36 AM is when this event was logged.

logging.basicConfig(level=logging.DEBUG,
                    format=‘%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s‘,
                    datefmt=‘%a, %d %b %Y %H:%M:%S‘,
                    filename=‘test.log‘,
                    filemode=‘w‘)
 
logging.debug(‘debug message‘)
logging.info(‘info message‘)
logging.warning(‘warning message‘)
logging.error(‘error message‘)
logging.critical(‘critical message‘)

import logging
 
#create logger
logger = logging.getLogger(‘TEST-LOG‘)
logger.setLevel(logging.DEBUG)
 
 
# create console handler and set level to debug
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
 
# create file handler and set level to warning
fh = logging.FileHandler("access.log")
fh.setLevel(logging.WARNING)
# create formatter
formatter = logging.Formatter(‘%(asctime)s - %(name)s - %(levelname)s - %(message)s‘)
 
# add formatter to ch and fh
ch.setFormatter(formatter)
fh.setFormatter(formatter)
 
# add ch and fh to logger
logger.addHandler(ch)
logger.addHandler(fh)
 
# ‘application‘ code
logger.debug(‘debug message‘)
logger.info(‘info message‘)
logger.warn(‘warn message‘)
logger.error(‘error message‘)
logger.critical(‘critical message‘)

# 创建一个logger
logger = logging.getLogger()
#创建一个带用户名的logger
logger1 = logging.getLogger(‘Jasonlog‘)
#设置一个日志级别
logger.setLevel(logging.INFO)
logger1.setLevel(logging.INFO)
#创建一个handler，用于写入日志文件
fh = logging.FileHandler(‘test.log‘)
# 再创建一个handler，用于输出到控制台
ch = logging.StreamHandler()
# 定义handler的输出格式formatter
formatter = logging.Formatter(‘%(asctime)s - %(name)s - %(levelname)s - %(message)s‘)
fh.setFormatter(formatter)
ch.setFormatter(formatter)
# 给logger添加handler
#logger.addFilter(filter)
logger.addHandler(fh)
logger.addHandler(ch)
# 给logger1添加handler
#logger1.addFilter(filter)
logger1.addHandler(fh)
logger1.addHandler(ch)
#给logger添加日志
logger.info(‘logger info message‘)
logger1.info(‘logger1 info message‘)

# import json
# dic = {‘k1‘:‘v1‘}
# print(dic,type(dic))
# #将python的基本类型转换为字符串
# result = json.dumps(dic)
# print(result,type(result))
{‘k1‘: ‘v1‘} <class ‘dict‘>
{"k1": "v1"} <class ‘str‘>
s1 = ‘{"k1":123}‘

import json
dic = json.loads(s1) #存入内存中
print(dic,type(dic))
{‘k1‘: 123} <class ‘dict‘>
import requests
import json
response = requests.get(‘http://wthrcdn.etouch.cn/weather_mini?city=北京‘)
response.encoding = ‘utf-8‘
print(response)

dic = json.loads(response.text)#**使用双引号
print(dic)
print(type(dic))

import json
li = [11,22,33]
json.dump(li,open(‘db‘,‘w‘))#序列化
li = json.load(open(‘db‘,‘r‘))##将字符产反序列化，读文件
print(type(li),li)

class Foo():
    def f1(self):
        print(‘test‘)
import json
a = Foo
r = json.loads(a)
print(r)

import pickle
li = [11,22,33]
r = pickle.dumps(li)
print(r)
#b‘\x80\x03]q\x00(K\x0bK\x16K!e.‘
result = pickle.loads(r)
print(result)
#[11, 22, 33]
import pickle
li = [11,22,33]
pickle.dump(li, open(‘db‘,‘wb‘))
result = pickle.load(open(‘db‘,‘rb‘))
print(result)
#[11, 22, 33]

User_INFO = {}

def check_login(func):
    def inner(*args,**kwargs):
        if User_INFO.get(‘is_login‘,None):
            ret = func(*args, **kwargs)
            return ret
        else:
            print(‘请登录‘)

    return inner

def check_admin(func):
    def inner(*args,**kwargs):
        if User_INFO.get(‘user_type‘,None) == 2:
            ret = func(*args,**kwargs)
            return ret
        else:
            print("无权限查看")
    return inner
@check_login
@check_admin
def index():
    print("login success")
@check_login
def login():
    User_INFO[‘is_login‘] = ‘True‘
    print("普通用户登录")

def search():
    print("")
def main():
    while True:
        inp = input("1.登录2.查看3.后台登录")
        if inp == ‘1‘:
            User_INFO[‘is_login‘] = True
            login()
        elif inp == ‘2‘:
            search()
        elif inp == ‘3‘:
            User_INFO[‘user_type‘] = 2
            index()

main()