【python库包简易使用 - capa、Haversine、itertools、sql】

索寒

2023-12-01

capa库

import pandas as pd
import cpca

name_list = ['张三', '李四', '赵五', '王六']
address_list = ['徐汇区虹漕路xxx号xx号楼x楼',
                "泉州市洛江区万安塘西工业区",
                "朝阳区北苑华贸城",
                ""]
df = pd.DataFrame({"姓名": name_list,
                   "地址": address_list})

split_df = cpca.transform(df['地址'].values.tolist())

df['省'] = split_df["省"].values.tolist()
print(df)

Haversine库

# Successfully installed haversine-2.5.1
# https://pypi.org/project/haversine/
from haversine import inverse_haversine, Direction
from math import pi

paris = (48.8567, 2.3508)
# Finding 0.5km west of Paris
inverse_haversine(paris, 0.5, Direction.WEST)
# (48.856699798042406, 2.3439656826864126)
inverse_haversine(paris, 0.5, Direction.EAST)
# (48.856699798042406, 2.357634317313587)
inverse_haversine(paris, 0.5, Direction.NORTH)
# (48.86119660181863, 2.3508)
inverse_haversine(paris, 0.5, Direction.SOUTH)
# (48.85220339818137, 2.3508)
# Finding 0.5km southwest of Paris
inverse_haversine(paris, 0.5, pi * 1.25)
# (48.853520321391, 2.3459677148041402)


from haversine import haversine, Unit

lyon = (45.7597, 4.8422) # (lat, lon)
paris = (48.8567, 2.3508)

haversine(lyon, paris)
# 392.2172595594006  km
haversine(lyon, paris, unit=Unit.MILES)
haversine(lyon, paris, unit='mi')
# 243.71250609539814

from haversine import haversine, Unit
camera = (503142.8879060493, 279585.4789697734)
record = (522389.8704484559, 334150.4538552045)
haversine(camera, record)

计算经纬度坐标之间的距离(km)

在WGS84坐标系下，计算两点之间的距离：

import math

def LLs2Dist(lat1, lon1, lat2, lon2):
    R = 6371
    dLat = (lat2 - lat1) * math.pi / 180.0
    dLon = (lon2 - lon1) * math.pi / 180.0

    a = math.sin(dLat / 2) * math.sin(dLat / 2) + math.cos(lat1 * math.pi / 180.0) * math.cos(lat2 * math.pi / 180.0) * math.sin(dLon / 2) * math.sin(dLon / 2)
    c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))
    dist = R * c
    return dist


x1 = 37.779388
y1 = -122.423246
x2 = 32.719464
y2 = -117.220406

dist = LLs2Dist(y1, x1, y2, x2)
print(dist)

itertools

循环器是对象的容器，包含有多个对象。通过调用循环器的next()方法，循环器将依次返回一个对象。直到所有的对象遍历穷尽，循环器将举出StopIteration错误。
for i in iterator结构中，循环器每次返回的对象将赋予给i，直到循环结束。使用iter()内置函数，可以将列表、字典等容器变为循环器。比如：

for i in iter([2, 4, 5, 6]):
	print(i)

标准库itertools包提供了更加灵活的生成循环器的工具。

from itertools import *

无穷循环器

# 从5开始的整数循环器，每次增加2
count(5, 2)  # 5, 7, 9, 11, 13, 15...
# 重复序列的元素
cycle('abc') # a, b, c, a, b, c, a...
# 重复1.2，构成无穷循环器
repeat(1.2) # 1.2, 1.2, 1.2...
# repeat函数也可以有一个次数限制
repeat(10, 5) # 10, 10, 10, 10, 10

函数式编程

函数式编程是将函数本身作为处理对象的编程范式。在python中，函数也是对象，可轻松的进行一些函数式的处理，如map()、filter()、reduce()函数。itertools包含类似的工具，接收函数作为参数，并将结果返回为一个循环器。

from itertools import *
rlt = imap(pow, [1, 2, 3], [1, 2, 3])
for num in rlt:
    print(num)

imap函数与map()函数功能类似，只不过返回的不是序列，而是一个循环器，包含元素1，4，27。

starmap(pow, [(1, 1), (2, 2), (3, 3)])  # pow将依次作用于列表中的每个tuple

ifilter(lambda x: x > 5, [2, 3, 5, 6, 7])
# 将lambda函数依次作用于每个元素，返回满足条件的元素
# 6， 7
ifilterfalse(lambda x: x > 5, [2, 3, 5, 6, 7])
# 2, 3, 5

takewhile(lambda x: x < 5, [1, 3, 6, 7, 1])
# 当满足条件时，收集元素到循环器。一旦遇到不满足条件的，则停止。
# 1， 3
dropwhile(lambda x: x < 5, [1, 3, 6, 7, 1])
# 当不满足条件时，跳过元素。一旦满足条件，则开始收集之后的元素到循环器
# 6， 7， 1

组合工具

可以通过组合原有循环器，来获得新的循环器

chain([1, 2, 3], [4, 5, 7]) # 连接两个循环器成为一个
product('abc', [1, 2]) # 多个循环器集合的笛卡尔积，相当于嵌套循环

for m, n in product('abc', [1, 2]):
    print(m, n)

permutations('abc', 2) 
# 从'abcd'中挑选两个元素，比如ab, ba, bc, ...将所有结果排序，返回为新的循环器
combinations('abc', 2)
# 从'abcd'中挑选两个元素，比如ab, bc, ...将所有结果排序，返回为新的循环器。此时不分顺序，即ab和ba，只返回一个ab
combinations_with_replacement('abc', 2)
# 与上面的类似，但允许两次选出的元素，重复，即多了aa, bb, cc

groupby()

将key函数作用于原循环器的各个元素。根据key函数结果，将拥有相同函数结果的元素分到一个新的循环器。每个新的循环器以函数返回结果为标签。

def height_class(h):
    if h > 180:
        return "tall"
    elif h < 160:
        return "short"
    else:
        return "middle"
    
friends = [191, 158, 159, 165, 170, 177, 181, 182, 190]

friends = sorted(friends, key=height_class)
for m, n in groupby(friends, key=height_class):
    print(m)
    print(list(n))

分组之前需要使用sorted()对原有循环器的元素，根据key函数进行排序，让同组元素先在位置上靠拢。

其他工具

compress('ABCD', [1, 1, 1, 0])
# 根据[1, 1, 1, 0]的真假，选择第一个参数'ABCD'中的元素
# A, B, C
islice()
# 类似于slice()函数，只是返回的是一个循环器
izip()
# 类似于zip()函数，只是返回的是一个循环器

sql

from sqlalchemy import create_engine
from sqlalchemy.types import Text
import pymysql

conn = create_engine("mysql+pymysql://xxxx:xxxxxx@xxx.xx.xxx.xx:xxxx/xxxxxxxx?charset=utf8")
# "mysql+mysqldb://{}:{}@{}/{}".format('username', 'password', 'host:port', 'database')
# "数据库类型dialect+数据库驱动选择driver://..."

df = input_table.copy()
dtypedict = {"person_id": Text()}  # 自定义列的类型
df.to_sql(name="tb_person", con=conn, if_exists='replace', index=False, dtype=dtypedict)
# if_exists参数意味着如果表已经存在，该如何表现。if_exists='fail'(default），表示引发ValueError；if_exists='replace'，表示插入新值之前删除表；if_exists='append'，表示将新值插入现有表。
# index参数，是否将df的索引写为列，使用index_label作为表中的列名。
# dtype参数，指定列的数据类型；如果使用字典，键为列名，值为sqlalchemy类型或sqlite3传统模式的字符串；如果使用标量，将应用于所有列。

sqlalchemy 常用数据类型

数据类型	Python数据类型	说明
Integer	int	整型
String	str	字符串
Float	float	浮点型
DECIMAL	decimal.Decimal	定点型
Boolean	bool	布尔型
Date	datetime.date	日期
DateTime	datetime.datetime	日期和时间
Time	datetime.time	时间
Enum	str	枚举类型
Text	str	文本类型
LongText	str	长文本类型