python 学习笔记

发表于 分类于 Waline： 本文字数： 8.8k 阅读时长 ≈ 8 分钟

python 复制操作合集

通过跳转机连接 mysql

场景：本地->跳转机->mysql服务器
分两步：1.通过 sshtunnel 登陆跳转机；2.创建数据库连接。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import pymysql
from sshtunnel import SSHTunnelForwarder
 
with SSHTunnelForwarder(
        ('*.*.*.*', 11690),  # 指定ssh登录的跳转机的address，端口号
        ssh_username="***",  # 跳转机的用户
        ssh_pkey="/Users/.ssh/id_rsa", #私钥路径
        ssh_private_key_password="***", #密码（电脑开机密码）
        remote_bind_address=('*.*.*.*', 3306)) as server:  # mysql服务器的address，端口号
    conn = pymysql.connect(host='127.0.0.1',  # 此处必须是是127.0.0.1
                           port=server.local_bind_port,
                           user='**', #数据库用户名
                           passwd='**', #数据库密码
                           db='**' #数据库名称)
 
    cursor = conn.cursor()
    # 使用 execute()  方法执行 SQL 查询
    cursor.execute("SELECT VERSION()；")
 
    # 使用 fetchone() 方法获取单条数据.
    data = cursor.fetchone()
 
    print("Database version : %s " % data)
    # 关闭数据库连接
    cursor.close()

读取 Excel 文档

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
def read_excel(self, path):
    try:
        logger.info("begin read %s" % path)
        # 读取 Excel 预处理动作↓，使用 xlrd 包将 Excel 文件读入 book 中
        book = xlrd.open_workbook(path,encoding_override='utf-8')
        data = dict()
        sheets = book.sheets()
        for cur in sheets:
            sheet_name = cur.name
            nrows = cur.nrows
            ncols = cur.ncols
            logger.info("nrows=%d,ncols=%d" % (nrows, ncols))
            sheet_val = list()
            for idx in range(0, nrows):
                line = cur.row_values(idx)
                # sheet_val 为对应该页面每行数据的 list 数据
                sheet_val.append(line)
            # data 为整个 Excel 文件每一张 sheet 的 Map 数据
            data[sheet_name] = sheet_val
        logger.info("read end, sheet=%d" % len(data))
        return data
    except Exception as e:
        logger.info("read %s fail, err=%s" % (path, str(e)))
        return None

Excel 数据处理

Excel 转换成 SQL 语句

单独拉出一列，在首行传入该函数后，复制到每一行，可拉取对应列的数据，并转换为 sql 语句。

1
=CONCATENATE("INSERT INTO table_name (list_1,list_2,list_3) VALUES ('",A1,"','",B1,"','",C1,"');")

Python 批量处理 Excel

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
import pymysql
import xlrd

'''
连接数据库
args：db_name（数据库名称）
returns:db
'''


def mysql_link(db_name):
    try:
        db = pymysql.connect(host="xxx.xxx.xxx.xxx",
                             port=xxxx,
                             user="xxxxxx",
                             passwd="xxxxxx",
                             db=db_name,
                             charset='utf8')
    except:
        print("could not connect to mysql server")
    return db


'''
读取excel函数
args：excel_file（excel文件，目录在py文件同目录）
returns：book
'''


def open_excel(excel_file):
    try:
        book = xlrd.open_workbook(excel_file)  # 文件名，把文件与py文件放在同一目录下
    except:
        print("open excel file failed!")
    return book


'''
执行插入操作
args:db_name（数据库名称）
table_name(表名称）
excel_file（excel文件名，把文件与py文件放在同一目录下）
'''


def store_to(db_name: object, table_name: object, excel_file: object) -> object:
    db = mysql_link(db_name)  # 打开数据库连接
    cursor = db.cursor()  # 使用 cursor() 方法创建一个游标对象 cursor
    book = open_excel(excel_file)  # 打开excel文件
    sheets = book.sheet_names()  # 获取所有sheet表名
    for sheet in sheets:
        sh = book.sheet_by_name(sheet)  # 打开每一张表
        row_num = sh.nrows
        if row_num != 0:
            print(row_num - 1)
        data_list = []  # 定义列表用来存放数据
        num = 0  # 用来控制每次插入的数量
        for i in range(1, row_num):  # 第一行是标题名，对应表中的字段名所以应该从第二行开始，计算机以0开始计数，所以值是1
            row_data = sh.row_values(i)  # 按行获取excel的值
            value = (
                row_data[0], row_data[1], row_data[2], row_data[3], row_data[4], row_data[5], row_data[6], row_data[7],
                row_data[8])
            sql = "INSERT INTO " + str(table_name) + "(brand,sub_model_name,v8_10,`year`,trans_code,oe_code,std_name," \
                                                     "`level`,specification,creator,updator) VALUES(%s,%s,%s,%s,%s," \
                                                     "%s,%s,%s,%s,\"xing.liuxing1218\",\"xing.liuxing1218\") "
            data_list.append(value)  # 将数据暂存在列表
            num += 1
            if num >= 1000:  # 每一千条数据执行一次插入
                cursor.executemany(sql, data_list)  # 执行sql语句
                data_list.clear()  # 清空list
                print("worksheets: " + sheet + " has been inserted 1000 data!")
                num = 0  # 计数归零
        cursor.executemany(sql, data_list)  # 执行sql语句
        data_list.clear()  # 清空list
        print("worksheets: " + sheet + " has been inserted " + str(num) + " data!")
        if row_num != 0:
            print("Success: worksheets: " + sheet + " has been inserted " + str(row_num - 1) + " data!")
    db.commit()  # 提交
    cursor.close()  # 关闭连接
    db.close()
    return 0


if __name__ == '__main__':
    store_to('xxx', 'xxx', 'xxx.xls')

python 复制文件

1
shutil.copy(src, dst)

字符串处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 将变量转化成字符串类型
str(line)

# 将字符串全大写/全小写
name = name.upper()
name = name.lower()

# 类 C 语言中的字符串格式化语言，python 中用 % 处理变量转化
ftp_name = "%s_%s"%(cass_id, sec[1])

# strip()去掉字符串首位多余字符，为空时去掉多余空格
# split()将字符串通过参数中的字符，分割成若干字符串存在数组中
plist = pic_advantage.strip().split("，")

# re模块处理正则表达式，以下为将 code 转化为[^a-zA-Z0-9]字符的函数
pattern_code_trim = re.compile("[^a-zA-Z0-9]")
src_code_trim = pattern_code_trim.sub('', code)

# python中没有自增
i = i + 1

字典的遍历

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# keys() 该方法会返回字典的所有的key
# 该方法会返回一个序列，序列中保存有字典的所有的键
d = {'name':'孙悟空','age':18,'gender':'男'}
print(d.keys())
# 通过遍历keys()来获取所有的键
for k in d.keys() :
    print(k , d[k])

# values()
# 该方法会返回一个序列，序列中保存有字典的所有的值
d = {'name':'孙悟空','age':18,'gender':'男'}
for v in d.values():
    print(v)

# items()
# 该方法会返回字典中所有的项
# 它会返回一个序列，序列中包含有双值子序列
# 双值分别是，字典中的key和value
d = {'name':'孙悟空','age':18,'gender':'男'}
print(d.items())
for k,v in d.items():
    print(k, '=', v)

解析json

1
2
3
4
5
6
7
8
d = json.loads(req.text)
print(d['element'])
print(d['element_parent']['element_child'])

for item in d.items():
    print(item[1])
    if item[1]['element1'] == 'xx':
        print item[1]['element2']

常用去重方式

对列表去重

  • 用循环查找的方式
1
2
3
4
5
6
li = [1,2,3,3,4,2,3,4,5,6,1]
news_li = []
for i in li:
    if i not in news_li:
        news_li.append(i)
print (news_li)
  • 用集合的特性set()
1
2
li1 = [1,4,3,3,4,2,3,4,5,6,1]
new_li1 = list(set(li1))
  • 使用itertools模块的grouby方法
1
2
3
4
5
6
import itertools
li2 = [1,4,3,3,4,2,3,4,5,6,1]
li2.sort() # 排序
it = itertools.groupby(li2)
for k, g in it:
    print (k)
  • 运用while循环遍历的方式
1
2
3
4
5
6
7
def quchong(lb):
    for x in lb:
        while lb.count(x)>1:
            del lb[lb.index(x)]
    return lb
li3 = [1,4,3,3,4,2,3,4,5,6,1]
quchong(li3)
  • 使用keys()方式
1
2
3
li4 = [1,0,3,7,7,5]
formatli = list({}.fromkeys(li4).keys())
print (formatli)

对数据框去重

  • 用unique()对单属性列去重
1
2
3
4
5
6
7
import pandas as pd
data = {'id':['A','B','C','C','C','A','B','C','A'],'age':[18,20,14,10,50,14,65,14,98]}
data = pd.DataFrame(data)
data.id.unique()
#或者
import numpy as np
np.unique(data.id)
  • 用frame.drop_duplicates()对单属性列去重
1
data.drop_duplicates(['id'])
  • 用frame.drop_duplicates()对多属性列去重
1
data.drop_duplicates(['id','age'])
  • 用frame.duplicated()对多属性列去重
1
2
isduplicated = data.duplicated(['id','age'],keep='first')
data.loc[~isduplicated,:]

查找重复元素

1
2
3
4
5
6
7
8
9
10
from collections import Counter

a = [1, 2, 3, 4, 3, 2, "奔奔", "benben", "奔奔"]
b = dict(Counter(a))

# 只展示重复元素
print ([key for key,value in b.items() if value > 1])

# 展现重复元素和重复次数
print ({key:value for key,value in b.items()if value > 1})

方法一：

1
2
3
4
mylist = [1,2,2,2,2,3,3,3,4,4,4,4]
myset = set(mylist)
for item in myset:
    print("the %d has found %d" %(item,mylist.count(item)))
1
2
3
4
the 1 has found 1
the 2 has found 4
the 3 has found 3
the 4 has found 4

方法二：

1
2
3
from collections import Counter

Counter([1,2,2,2,2,3,3,3,4,4,4,4])
1
Counter({2: 4, 4: 4, 3: 3, 1: 1})

方法三：

1
2
3
4
5
6
List=[1,2,2,2,2,3,3,3,4,4,4,4]
a = {}
for i in List:
    if List.count(i) > 1:
        a[i] = List.count(i)
print (a)

格式化输出

动态指定长度的实现

1
2
3
4
5
# print %s固定长度格式输出：
print("%10s, %20s" % (A, B))

# 如果长度不定，以变量len代替：
print("%*s" % (len, A))

以指定宽度格式化输出（format）

1
2
3
4
5
mat = "{:20}\t{:28}\t{:32}"
print(mat.format("占4个长度","占8个长度", "占12长度"))
# 如果需要居中输出在宽度前面加一个^
mat = "{:^20}\t{:^28}\t{:^32}"
print(mat.format("占4个长度","占8个长度", "占12长度"))

Set 相关操作

python的set和其他语言类似, 是一个无序不重复元素集。基本功能包括关系测试和消除重复元素。集合对象还支持union(联合), intersection(交), difference(差)和sysmmetric difference(对称差集)等数学运算。

set 支持 x in set, len(set), 和 for x in set。作为一个无序的集合，set不记录元素位置或者插入点。因此，set不支持 indexing, slicing, 或其它类序列sequence-like的操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
s = set()

len(s) 
# set 的长度

x in s 
# 测试 x 是否是 s 的成员

x not in s 
# 测试 x 是否不是 s 的成员

s.issubset(t) s <= t 
# 测试是否 s 中的每一个元素都在 t 中

s.issuperset(t) s >= t 
# 测试是否 t 中的每一个元素都在 s 中

s.union(t) s | t 
# 返回一个新的 set 包含 s 和 t 中的每一个元素

s.intersection(t) s & t 
# 返回一个新的 set 包含 s 和 t 中的公共元素

s.difference(t) s - t 
# 返回一个新的 set 包含 s 中有但是 t 中没有的元素

s.symmetric_difference(t) s ^ t 
# 返回一个新的 set 包含 s 和 t 中不重复的元素

s.copy() 
# 返回 set “s”的一个浅复制

hash(s)
# 返回 s 的 hash 值

s.update(t)
s |= t
# 返回增加了 set “t”中元素后的 set “s”

s.intersection_update(t)
s &= t
# 返回只保留含有 set “t”中元素的 set “s”

s.difference_update(t)
s -= t
# 返回删除了 set “t”中含有的元素后的 set “s”

s.symmetric_difference_update(t)
s ^= t
# 返回含有 set “t”或者 set “s”中有而不是两者都有的元素的 set “s”

s.add(x)
# 向 set “s”中增加元素 x

s.remove(x)
# 从 set “s”中删除元素 x, 如果不存在则引发 KeyError

s.discard(x)
# 如果在 set “s”中存在元素 x, 则删除

s.pop()
# 删除并且返回 set “s”中的一个不确定的元素, 如果为空则引发 KeyError

s.clear()
# 删除 set “s”中的所有元素