Python-其他笔记

作者: davidic | 来源:发表于2019-02-13 17:16 被阅读0次

json操作

1.1 json转字符串

result = json.loads(s)

1.2 遍历json的key

将json当做dict，用dict的方法遍历

for k,v in result.items():
    print result[k]

1.3 读json文件

import json

f = open("/home/david/keywordjson")

result = json.load(f,encoding='utf-8')
for k,v in result.items():
    print result[k]

1.4 报错

Python json.loads shows ValueError: Extra data

https://stackoverflow.com/questions/21058935/python-json-loads-shows-valueerror-extra-data

1.5 判断是否包含key

jsonObject 是个json
if (key in jsonObject) :
    print '有'
else:
    print '没有'

文件操作

2.1 读CSV文件

csv文件的格式如

id,click,hour,C1,C2,C3,C4,C5
123,1,14091123,a,b,c,d,e

读取的方式为：

from csv import DictReader

# t是每行的index，row是每行的具体数据，dict型
for t, row in enumerate(DictReader(open(path))):
        ID = row['id']

2.2 按行读普通文件

    for line in open('../result/ctrout-featurelist-1-10.dat'):
        #要去掉换行符
        arr = line.strip('\n').split(',')
        if len(arr) > 0:
            try:
                prectr.append(float(arr[0]))
                onlinectr.append(float(arr[1]))
                isclick.append(1 if arr[2]=='true' else 0)
            except ValueError:
                continue

上述方法不够严谨，为防止读取时出错，应该用

 with codecs.open(fname, "r") as f:
        for line in f.readlines():
        # 按行读是带换行符的，要用strip去掉
            data = line.strip('\n').split()

读文件转成二维数组

def read(file):
    '''read raw date from a file '''
    Instances = []
    fp = open(file, 'r')
    for line in fp:
        line = line.strip('\n')  # discard '\n'
        if line != '':
            Instances.append(line.split(','))
    fp.close()
    return (Instances)

写文件

filename = 'write_data.txt'
with open(filename,'w') as f: # 如果filename不存在会自动创建， 'w'表示写数据，写之前会清空文件中的原有数据！
    f.write("I am Meringue.\n")
    f.write("I am now studying in NJTECH.\n")
    

# or
f = open('test.txt', 'w') # 若是'wb'就表示写二进制文件
f.write('Hello, world!')
f.close()

判断文件是否存在

import os
os.path.exists(test_file.txt)
#True

os.path.exists(no_exist_file.txt)
#False

内置函数

3.1 hash

返回对象的hash值，返回的哈希值是使用一个整数表示，通常使用在字典里，以便实现快速查询键值。参数object输入是数字类型时，是根据数值来计算的，比如1和1.0计算出来是一样的哈希值，因此说这个函数是不区分不同的数值类型。

日期操作



import datetime

dstr = '20170228'

d2 =  datetime.datetime.strptime(dstr,'%Y%m%d') + datetime.timedelta(days=1)
d2str = d2.strftime('%Y%m%d')
# 结果是20170301

# 获取当前日期并格式化
import time
time.strftime('%Y%m%d',time.localtime(time.time()))
time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time()))
# 如果要获取datetime类型的当前时间
datetime.datetime.now()

# 日期加减
#datetime.timedelta(days, seconds, microseconds)
d1 = datetime.date.today()
# 加一天：
d2 = d1 + datetime.timedelta(1)
# 減一天：
d2 = d1 + datetime.timedelta(-1)

# 当天日期的格式化
datetime.date.today().strftime('%Y%m%d')

# 字符串转日期
import datetime
detester = ‘2017-01-01'
date = datetime.datetime.strptime(detester,’%Y-%m-%d')
                                  
# 日期转字符串
import datetime
# python3的
date = datetime.now()
detester = date.strftime(‘%Y-%m-%d')        
                         
# 比较两个时间之差
nowtime=datetime.datetime.today()
(nowtime-gpstime_datetime).seconds

字符串

字符串拼接

runToday=date.today().strftime('%y-%m-%d')
b=time.strptime(runToday,'%y-%m-%d')
btime = datetime(*b[:3])
",".join(["/shortdata/persona/xid_present_info/" + (btime - timedelta(x)).strftime('%y-%m-%d') for x in range(2,13)])

'/shortdata/persona/xid_present_info/17-05-08,/shortdata/persona/xid_present_info/17-05-07,/shortdata/persona/xid_present_info/17-05-06,/shortdata/persona/xid_present_info/17-05-05,/shortdata/persona/xid_present_info/17-05-04,/shortdata/persona/xid_present_info/17-05-03,/shortdata/persona/xid_present_info/17-05-02,/shortdata/persona/xid_present_info/17-05-01,/shortdata/persona/xid_present_info/17-04-30,/shortdata/persona/xid_present_info/17-04-29,/shortdata/persona/xid_present_info/17-04-28'

字符串定位

str_1='wo shi yi zhi da da niu  '
char_1='i'
nPos=str_1.index(char_1)
print(nPos)
运行结果：7

========是使用find==========

str_1='wo shi yi zhi da da niu  '
char_1='i'
nPos=str_1.find(char_1)
print(nPos)
结果：5


========如何查找所有‘i’在字符串中位置呢？===========

#开挂模式
str_1='wo shi yi zhi da da niu  '
char_1=str(input('Please input the Char you want:'))
count=0
str_list=list(str_1)
for each_char in str_list:
    count+=1
    if each_char==char_1:
        print(each_char,count-1)
      

运行结果：

Please input the Char you want:i
i 0
i 1
i 2
i 3

数字

除法后转float

# 加个点即可
scale = state.shape[1] / 720.

循环

documents = ["Human machine interface for lab abc computer applications",
             "A survey of user opinion of computer system response time",
             "The EPS user interface management system",
             "System and human system engineering testing of EPS"]
stoplist = set('for a of the and to in'.split())

texts = [[word for word in document.lower().split() if word not in stoplist]
        for document in documents]

hdfs操作

https://snakebite.readthedocs.io/en/latest/client.html

代码规范

定义类

class model_evaluation(object):

    def __init__(self, prectrArr, onlinectrArr, isclickArr):
        self.prectrArr = prectrArr
        self.onlinectrArr = onlinectrArr
        self.isclickArr = isclickArr

main函数

def main(argv=None):
    if argv == None:
        argv = sys.argv
     
if __name__ == "__main__":
    main()

nohup执行

nohup python -u download_bing_api.py >> result.log &

可以输出print的内容

max

初级技巧

tmp = max(1,2,4)
print(tmp)

#可迭代对象
a = [1, 2, 3, 4, 5, 6]
tmp = max(a)
print(tmp)

中级技巧：key属性的使用

当key参数不为空时，就以key的函数对象为判断的标准。
如果我们想找出一组数中绝对值最大的数，就可以配合lamda先进行处理，再找出最大值

a = [-9, -8, 1, 3, -4, 6]
tmp = max(a, key=lambda x: abs(x))
print(tmp)

高级技巧：找出字典中值最大的那组数据

如果有一组商品，其名称和价格都存在一个字典中，可以用下面的方法快速找到价格最贵的那组商品：

prices = {
    'A':123,
    'B':450.1,
    'C':12,
    'E':444,
}
# 在对字典进行数据操作的时候，默认只会处理key，而不是value
# 先使用zip把字典的keys和values翻转过来，再用max取出值最大的那组数据
max_prices = max(zip(prices.values(), prices.keys()))
print(max_prices) # (450.1, 'B')

画图

画圆

import numpy as np   
import matplotlib.pyplot as plt  
from matplotlib.patches import Polygon  
import matplotlib.patches as mpatches  

for i in range(0,r,600):
    plt.plot(np.cos(t)*i, np.sin(t)*i)
plt.show()

去掉坐标轴

ax=plt.subplot(111)
ax.set_xticks([])  
ax.set_yticks([])

直方图

教你利用Python玩转histogram直方图的五种方法

进程

subprocess

运行python的时候，我们都是在创建并运行一个进程。像Linux进程那样，一个进程可以fork一个子进程，并让这个子进程exec另外一个程序。在Python中，我们通过标准库中的subprocess包来fork一个子进程，并运行一个外部的程序。

如

cat = subprocess.Popen(["hadoop", "fs", "-du", abspath], stdout=subprocess.PIPE)

Popen对象创建后，主程序不会自动等待子进程完成。我们必须调用对象的wait()方法，父进程才会等待 (也就是阻塞block)，举例：

>>> import subprocess
>>> child = subprocess.Popen(['ping','-c','4','blog.linuxeye.com'])
>>> print 'parent process'

从运行结果中看到，父进程在开启子进程之后并没有等待child的完成，而是直接运行print。对比等待的情况:

>>> import subprocess
>>> child = subprocess.Popen('ping -c4 blog.linuxeye.com',shell=True)
>>> child.wait()
>>> print 'parent process'

从运行结果中看到，父进程在开启子进程之后并等待child的完成后，再运行print。
此外，你还可以在父进程中对子进程进行其它操作，比如我们上面例子中的child对象:

child.poll() # 检查子进程状态
child.kill() # 终止子进程
child.send_signal() # 向子进程发送信号
child.terminate() # 终止子进程

子进程的PID存储在child.pid，子进程的标准输入、标准输出和标准错误如下属性分别表示:

child.stdin
child.stdout
child.stderr

例如lbspoi.py

def generate_poi_content(self):
        city_list = []
        cmd_out = subprocess.Popen(
            " hadoop fs -ls /shortdata/mobile_poi_raw/day_id=%s|awk -F'city=' 'NF==2{print $2}'" % (self.today),
            stdout=subprocess.PIPE, shell=True)
        for line in cmd_out.stdout:
            line = line.strip()
            if len(line) > 0:
                city_list.append(line)

        for city_code in city_list:
            sql = "pig -p MOBILE_POI_RAW=/shortdata/mobile_poi_raw/day_id=%s/city=%s " \
                  "-p CITY_CODE=%s -p MOBILE_POI_INFO=/shortdata/persona/mobile_poi/%s/%s " \
                  "/opt/pig_home/mobile_poi/GeneratePoiContent.pig" % (
                      self.today, city_code, city_code, self.today, city_code)
            taskCmd(sql)
            sql = "alter table mobile_poi " \
                  "add partition (day_id='%s',city_code='%s') " \
                  "location '/shortdata/persona/mobile_poi/%s/%s';" % (self.today, city_code, self.today, city_code)
            cmd = 'hive -e "use persona; %s"' % (sql)
            taskCmd(cmd)

Python模块安装方法

一、方法1：单文件模块
直接把文件拷贝到 $python_dir/Lib

二、方法2：多文件模块，带setup.py

下载模块包，进行解压，进入模块文件夹，执行：
python setup.py install

三、方法3：easy_install 方式

先下载ez_setup.py,运行python ez_setup 进行easy_install工具的安装，之后就可以使用easy_install进行安装package了。
easy_install packageName
easy_install package.egg

四、方法4：pip 方式

先进行pip工具的安裝：easy_install pip（pip 可以通过easy_install 安裝，而且也会装到 Scripts 文件夹下。）

安裝：pip install PackageName

更新：pip install -U PackageName

移除：pip uninstall PackageName

搜索：pip search PackageName

帮助：pip help

输出日志

logger = logging.getLogger("eventToKafka")
logger.setLevel(logging.DEBUG)
# 建立一个filehandler来把日志记录在文件里，级别为debug以上
fh = logging.FileHandler("/home/hdbatch/fh.log")
fh.setLevel(logging.DEBUG)
# 建立一个streamhandler来把日志打在CMD窗口上，级别为error以上
ch = logging.StreamHandler()
ch.setLevel(logginng.ERROR)
# 设置日志格式
formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
ch.setFormatter(formatter)
fh.setFormatter(formatter)
#将相应的handler添加在logger对象中
logger.addHandler(ch)
logger.addHandler(fh)
# 开始打日志
logger.debug("debug message")
logger.info("info message")
logger.warn("warn message")
logger.error("error message")
logger.critical("critical message")

输出到excel

import xlwt
from datetime import datetime
 
style0 = xlwt.easyxf('font: name Times New Roman, color-index red, bold on',num_format_str='#,##0.00')
style1 = xlwt.easyxf(num_format_str='D-MMM-YY')
 
wb = xlwt.Workbook(encoding='utf-8')
ws = wb.add_sheet('A Test Sheet')
ln = 1

for line in open('/home/david/taxo.txt'):
    arr = line.strip('\n').split('|')
    if len(arr) > 0:
        try:
            print arr[0]
            ws.write(ln,0,arr[0])
            print arr[1]
            ws.write(ln,1,arr[1])
            print arr[2]
            ws.write(ln,2,arr[2])
            ln += 1
        except ValueError:
            print ValueError.message
            continue
 
wb.save('/home/david/example.xls')

用nohup执行python程序时，print无法输出

nohup python test.py > nohup.out 2>&1 &

发现nohup.out中显示不出来python程序中print的东西。

这是因为python的输出有缓冲，导致nohup.out并不能够马上看到输出。

python 有个-u参数，使得python不启用缓冲。

nohup python -u test.py > nohup.out 2>&1 &

latin1转utf8

很多语料库下载后都是latin1编码，是乱码

判断变量是否为None

三种主要的写法有：

第一种：if X is None;

第二种：if not X；

当X为None,  False, 空字符串"", 0, 空列表[], 空字典{}, 空元组()这些时，not X为真，即无法分辨出他们之间的不同。

第三种：if not X is None;

在Python中，None、空列表[]、空字典{}、空元组()、0等一系列代表空和无的对象会被转换成False。除此之外的其它对象都会被转化成True。

在命令if not 1中，1便会转换为bool类型的True。not是逻辑运算符非，not 1则恒为False。因此if语句if not 1之下的语句，永远不会执行。

对比：foo is None 和 foo == None

示例：

>>> class Foo(object):
       def __eq__(self, other):
           return True

>>> f = Foo()
>>> f == None
True
>>> f is None
False

输入参数判断

import argparse


parser = argparse.ArgumentParser()
parser.add_argument("-v", "--verbosity", help="increase output verbosity")
args = parser.parse_args()
if args.verbosity:
        print "verbosity turned on"

一种是通过一个-来指定的短参数，如-h；
一种是通过--来指定的长参数，如--help

这两种方式可以同存，也可以只存在一个。通过解析后，其值保存在args.verbosity变量中
用法如下：

yarving@yarving-VirtualBox /tmp $ python prog.py -v 1
verbosity turned on

yarving@yarving-VirtualBox /tmp $ python prog.py --verbosity 1
verbosity turned on

yarving@yarving-VirtualBox /tmp $ python prog.py -h           
usage: prog.py [-h] [-v VERBOSITY]

optional arguments:
  -h, --help            show this help message and exit
  -v VERBOSITY, --verbosity VERBOSITY
                        increase output verbosity

yarving@yarving-VirtualBox /tmp $ python prog.py -v 
usage: prog.py [-h] [-v VERBOSITY]
prog.py: error: argument -v/--verbosity: expected one argument

或者这样使用

parser = argparse.ArgumentParser()
    parser.add_argument('--phone', default='Android', choices=['Android', 'IOS'], type=str, help='mobile phone OS')
    parser.add_argument('--sensitivity', default=2.045, type=float, help='constant for press time')
    parser.add_argument('--serverURL', default='http://localhost:8100', type=str, help='ServerURL for wda Client')
    parser.add_argument('--resource', default='resource', type=str, help='resource dir')
    parser.add_argument('--debug', default=None, type=str, help='debug mode, specify a directory for storing log files.')
    args = parser.parse_args()
    # print(args)

    AI = WechatAutoJump(args.phone, args.sensitivity, args.serverURL, args.debug, args.resource)

type定义了输入的数据类型，如果不符合会报错

后面也可以给args增加新的参数

args.vocab_size=50

搜索指定目录下的文件

import glob
# 搜索目录下的所有png文件，返回的是所有路径的列表
glob.glob(os.path.join(self.resource_dir, 'circle/*.png'))

复制文件

import shutil
shutil.copyfile('state.png', os.path.join(self.debug, 'state_{:03d}.png'.format(self.step)))

codecs

普通的open打开会有编码问题，用codecs.open打开后，再写入数据就不会有问题

https://www.cnblogs.com/buptldf/p/4805879.html

这种方法可以指定一个编码打开文件，使用这个方法打开的文件读取返回的将是unicode。写入时，如果参数是unicode，则使用open()时指定的编码进行编码后写入；如果是str，则先根据源代码文件声明的字符编码，解码成unicode后再进行前述操作。相对内置的open()来说，这个方法比较不容易在编码上出现问题。

with codecs.open(input_file, "r", encoding=self.encoding) as f:
            data = f.read()

这里的read就是读取整个文本，换行符为\r\n

with

with codecs.open(input_file, "r", encoding=self.encoding) as f:
            data = f.read()

使用with后不管with中的代码出现什么错误，都会进行对当前对象进行清理工作。

例如file的file.close()方法，无论with中出现任何错误，都会执行file.close（）方法

with语句类似

try :

except:

finally:

的功能：但是with语句更简洁。而且更安全。代码量更少。

collections

collections模块自Python 2.4版本开始被引入，包含了dict、set、list、tuple以外的一些特殊的容器类型，分别是：

OrderedDict类：排序字典，是字典的子类。引入自2.7。
namedtuple()函数：命名元组，是一个工厂函数。引入自2.6。
Counter类：为hashable对象计数，是字典的子类。引入自2.7。
deque：双向队列。引入自2.4。
defaultdict：使用工厂函数创建字典，使不用考虑缺失的字典键。引入自2.5。

Counter

Counter类的目的是用来跟踪值出现的次数。它是一个无序的容器类型，以字典的键值对形式存储，其中元素作为key，其计数作为value。计数值可以是任意的Interger（包括0和负数）。Counter类和其他语言的bags或multisets很相似。

c = collections.Counter('sdfsadfag')

Counter({'a': 2, 's': 2, 'd': 2, 'f': 2, 'g': 1})

counter对象的常用操作

sum(c.values())  # 所有计数的总数
c.clear()  # 重置Counter对象，注意不是删除
list(c)  # 将c中的键转为列表
set(c)  # 将c中的键转为set
dict(c)  # 将c中的键值对转为字典
c.items()  # 转为(elem, cnt)格式的列表
Counter(dict(list_of_pairs))  # 从(elem, cnt)格式的列表转换为Counter类对象
c.most_common()[:-n:-1]  # 取出计数最少的n-1个元素
c += Counter()  # 移除0和负值

sorted

默认是升序

>>> L=[('b',2),('a',1),('c',3),('d',4)]
>>> sorted(L, cmp=lambda x,y:cmp(x[1],y[1]))   # 利用cmp函数
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> sorted(L, key=lambda x:x[1])               # 利用key
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
# 变成降序
sorted(L, key=lambda x:-x[1])

zip

>>> a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 打包为元组的列表
[(1, 4), (2, 5), (3, 6)]
>>> zip(a,c)              # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> zip(*zipped)          # 与 zip 相反，可理解为解压，返回二维矩阵式
[(1, 2, 3), (4, 5, 6)]

持久化

http://blog.csdn.net/bh20077/article/details/6070278

如果希望透明地存储 Python 对象，而不丢失其身份和类型等信息，则需要某种形式的对象序列化：它是一个将任意复杂的对象转成对象的文本或二进制表示的过程。同样，必须能够将对象经过序列化后的形式恢复到原有的对象。在 Python 中，这种序列化过程称为 pickle，可以将对象 pickle 成字符串、磁盘上的文件或者任何类似于文件的对象，也可以将这些字符串、文件或任何类似于文件的对象 unpickle 成原来的对象。

# 写入
# 这里的chars是字符的列表
with open(vocab_file, 'wb') as f:
            cPickle.dump(chars, f)

# 读取
with open(vocab_file, 'rb') as f:
            self.chars = cPickle.load(f)

map

map() 会根据提供的函数对指定序列做映射。

第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

>>>def square(x) :            # 计算平方数
...     return x ** 2
... 
>>> map(square, [1,2,3,4,5])   # 计算列表各个元素的平方
[1, 4, 9, 16, 25]
>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数
[1, 4, 9, 16, 25]
 
# 提供了两个列表，对相同位置的列表数据进行相加
>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
[3, 7, 11, 15, 19]

记录shell执行的结果

如果用os.system执行shell命令，不会保存执行的结果，要保存结果，可以用

        city_list = []
        cmd_out = subprocess.Popen(
            " hadoop fs -ls /shortdata/mobile_poi_raw/day_id=%s|awk -F'city=' 'NF==2{print $2}'" % (self.today),
            stdout=subprocess.PIPE, shell=True)
        for line in cmd_out.stdout:
            line = line.strip()
            if len(line) > 0:
                city_list.append(line)

其中，

shell=True如果 args 是字符串，它将作为命令行字符串通过shell 执行．如果是一个序列，

它的第一个条目将作为命令行字符串，后面的条目作为附加的shell参数。

stdout=subprocess.PIPE如果stdout=PIPE,这个属性是个文件对象，提供子进程的输出，否则它是None

这样cmd_out就可以保存shell的结果

统计程序的执行时间（python3）

x1 = [9, 2, 5, 0, 0, 7, 5, 0, 0, 0, 9, 2, 5, 0, 0]
x2 = [9, 2, 2, 9, 0, 9, 2, 5, 0, 0, 9, 2, 5, 0, 0]
### VECTORIZED DOT PRODUCT OF VECTORS ###
tic = time.process_time()
dot = np.dot(x1,x2)
toc = time.process_time()
print ("dot = " + str(dot) + "\n ----- Computation time = " + str(1000*(toc - tic)) + "ms")

pass

如果初始化的时候不需要什么，可以写pass当占位符。

class NaiveBayes(object):

    def __init__(self):
        pass

基于数组A对数组B排序

import numpy as np
a = np.array([0,1,3,2,6,4,5])
b = np.array([0,1,2,3,4,5,6])
# 数据格式为[(0, 0), (1, 1), (2, 3), (3, 2), (4, 5), (5, 6), (6, 4)]
zipped=sorted(zip(a, b), key=lambda x:x[0])
# 拆分
aa,bb = zip(*zipped)

Python爬虫模拟登录

还没有试成功

def setup():
    browser = webdriver.Safari()
    return browser

def login(username, password, browser=None):
    browser.get("http://www.car900.com/login/")

    pwd_btn = browser.find_element_by_id("userPwd")
    act_btn = browser.find_element_by_id("userName")
    submit_btn = browser.find_element_by_id("login")  

    act_btn.send_keys(username)
    pwd_btn.send_keys(password)
    submit_btn.send_keys(Keys.ENTER)

    return browser

def set_sessions(browser):
    request = requests.Session()
    headers = {
        "User-Agent":
            "Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 "
            "(KHTML, like Gecko) Chrome/44.0.2403.157 Safari/537.36"
    }
    request.headers.update(headers)
    cookies = browser.get_cookies()
    
    for cookie in cookies:
        request.cookies.set(cookie['name'], cookie['value'])

    return request
    
#request = requests.Session()
#headers = {
#    "User-Agent":
#        "Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 "
#        "(KHTML, like Gecko) Chrome/44.0.2403.157 Safari/537.36"
#}
#request.headers.update(headers)
#request.cookies.set("http://www.car900.com/", "sessionId=7957926f-8aa7-40a9-be91-d264500c4659")
#browser = login(u"创辉测试","123456", setup())
#rq = set_sessions(browser)

https://www.jianshu.com/p/cc70e35b47fc

'chromedriver' executable needs to be in PATH

https://blog.csdn.net/tymatlab/article/details/78649727

使用brew安装`chromedriver`

1.brew安装chromedriver

$ brew install chromedriver

2.安装完成后，再次运行：

from selenium import webdriver
driver = webdriver.Chrome()

python带cookie爬

先从chrome获取cookie

cookies={}
cookies['sessionId']='7957926f-8aa7-40a9-be91-d264500c4659'
response = requests.get("http://www.car900.com/http/TwoChargeVehicle/QueryMortgagePoint.json?city=%E6%B7%AE%E5%8D%97%E5%B8%82&_=1527554506552", cookies=cookies)
print(response.text)

随机挑选N个列表中的数

import random as rd

rand_num_list = [1,2,3,4,5]
rand_num = rd.choice(rand_num_list)

col_names = ['all_avg_speed_nighttime_sd_3days', 'all_distance_in_10km_around_now_unit_address_avg_3days', 'all_distance_in_5km_around_address_avg_3days']

rd.sample(col_names,rand_num)

PyHive

pandas读取hive并转成dataframe

from pyhive import hive
import pandas as pd

def getData():
    conn = hive.Connection(host="1.0.1.38", auth="CUSTOM", username='hive', password="pvXxHTsdqrt8", port=10000, database='tapro_atg')
    df = pd.read_sql("select * from sales_data_leisure_view", conn)
    records = df.head(n=100000)
    print(records.to_json(orient='records'))

getData();

作者：Helen_Cat
链接：https://www.jianshu.com/p/cb2b864b4aca
來源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。

https://blog.csdn.net/qq_41664845/article/details/80775319

插入数据

cursor.execute("""LOAD DATA LOCAL INPATH '%s' INTO TABLE %s""" % ('aaa.csv', 'carthage_dev.tmp_local_to_hive'))

sql = ''' LOAD DATA LOCAL INPATH '/home/infra_pub/david.xu/aaa.csv' OVERWRITE INTO TABLE carthage_dev.tmp_local_to_hive '''
cursor.execute(sql, async=True)

数据问题

setup没有权限

python setup.py install

error: [Errno 13] Permission denied: '/Users/david/anaconda3/lib/python3.6/site-packages/easy-install.pth'

sudo chown ysbecca easy-install.pth 
chmod +x easy-install.pth

python多线程、多进程详细

https://blog.csdn.net/u011734144/article/details/55519272

批量执行shell命令

import os

cmdtxt = '''hadoop fs -text /user/dmp/yyfq_car_gps/saigerealtime/180910/10/part-r-00000.gz | grep '"gpsTime\":\"2018-09-08 %s' > 2018-09-08-%srecov;gzip 2018-09-08-%srecov;hadoop fs -put 2018-09-08-%srecov.gz /user/dmp/yyfq_car_gps/saigerealtime/180908/%s'''

for i in range(3, 24, 1):
    hour_str = str(i)
    if i < 10:
        hour_str = '0' + str(i)
    cmd_new = cmdtxt % (hour_str, hour_str, hour_str, hour_str, hour_str)
    print cmd_new
    os.system(cmd_new)

python2 get、post请求

def saige_last_gpstime(is_wx, gps_no):
    post_json = {
        'callLetter': gps_no,
        'flag': 'false',
        'sign': '335BB919C5476417E424FF6F0BC5AD6F'
    }

    unittype = "YX"
    requrl = "http://218.17.3.228:8008/mljrserver/vehicle/queryYXGpsInfo"
    if is_wx:
        unittype = "WX"
        requrl = "http://218.17.3.228:8008/mljrserver/vehicle/queryWXGpsInfo"
    headers = {'Content-Type': 'application/json'}

    req = urllib2.Request(url=requrl, headers=headers, data=json.dumps(post_json))
    res_data = urllib2.urlopen(req)
    res = json.loads(res_data.read())

    if res['datas']:
        gpstime_str = res['datas']['list'][0]['gpsTime']
        if random.random() < 0.001:
            print('random print' + gps_no + ',' + gpstime_str)

        gpstime_date = get_time(gpstime_str)
        if (datetime.datetime.now() - gpstime_date).seconds > 10800 and (gpstime_date.date() - yester_date).days == 1:
            print(unittype + ',' + gps_no + ',' + gpstime_str)

随机数

import random
# 0-1之间
if random.random() < 0.001:
    print('random print' + gps_no + ',' + gpstime_str)