python语法奇奇怪怪小合集

发表于 | 分类于 | 次阅读
字数统计: 3k 字 | 阅读时长 ≈ 12 分钟
说是奇奇怪怪，只是自己没学通，记录一下python tip

pandas

默认读取excel时

第一行为默认索引行，不作为数据存在。.read_csv("test.cvs",header=None)#取消将第一行作列属性

第一列默认为数据

1
2
3
4
5
6
7
8
9
10
11
data_table = pd.read_excel('data.xlsx')
# 读取一列
x_list = data_table['X坐标']
# 读取多列
x_y_z_list = data_table[['X坐标', 'Y坐标', 'Z坐标']]

# DataFrame类型修改指定单元格的值
#整数索引
df.iloc[i][j] = x
#对于混合位置和索引，使用.ix。但是你需要确保你的索引不是整数，否则会引起混淆。
df.ix[0, 'COL_NAME'] = x # 在pandas的1.0.0版本开始，移除了Series.ix and DataFrame.ix 方法。

生成excel时-有小坑

1
2
3
4
5
6
dataframe = pd.DataFrame(data)
#这样默认生成时，excel文件会自带行列索引，
#等读取时，第一行为列索引不计入数据，但是第一列会计入数据导致数据错位。
dataframe.to_excel('data.xlsx') 
#所以最好是去除掉行索引
dataframe.to_excel('data.xlsx', index=False)

pandas条件组合筛选和按范围筛选

DataFrame多条件筛选

DataFrame的数据查询 / 提取

python 把几个DataFrame合并成一个DataFrame——merge,append,join,conca

pandas 用excelwriter生成表格，运行正常但是没有生成文件？

目的是为了多条数据从指定行写入数据（python字典）

原始代码

1
2
3
4
5
writer = pd.ExcelWriter(filepath)
df1 = pd.DataFrame(random_wolk_parameters, index=[0])
df1.to_excel(excel_writer=writer, startrow=0)
df2 = pd.DataFrame(pso_parameters, index=[0])
df2.to_excel(excel_writer=writer, startrow=3)

修改后成功代码

1
2
3
4
5
with pd.ExcelWriter(filepath) as writer:
    df1 = pd.DataFrame(random_wolk_parameters, index=[0])
    df1.to_excel(excel_writer=writer, startrow=0, index=False)
    df2 = pd.DataFrame(pso_parameters, index=[0])
    df2.to_excel(excel_writer=writer, startrow=2, index=False)

成功得有点莫名。。(看with的用法-ctrl+鼠标点击直达,大概能理解了.)

At least one sheet must be visible

maybe是写入的数据有问题

TypeError: sequence item 0: expected str instance, numpy.int64 found

“ “.jion(str), jion分割的必须是字符串!!,如果传入的列表内都是str则没问题,但我们传的列表内是含有int的!所以会报类型错误参考

seaborn

【数据分析】seaborn的 heatmap热力图的cmap参数选项

cmap图集

项目requirements.txt

当前虚拟环境

1
pip freeze > requirements.txt

当前项目

1
2
3
4
# 安装
pip install pipreqs
# 在当前目录生成
pipreqs . --encoding=utf8 --force

注意 --encoding=utf8 为使用utf8编码，不然可能会报UnicodeDecodeError: ‘gbk’ codec can’t decode byte 0xae in position 406: illegal multibyte sequence 的错误。

--force 强制执行，当 生成目录下的requirements.txt存在时覆盖。

安装

1
pip install -r requirements.txt

_、--和__xx__的区别

来源：python— 、--和__xx__的区别

  1. _ 在类的方法或属性前面添加，意味着该方法或属性不该被调用，不属于API。类似于C++中类的私有方法

  2. --真正作用是用来避免子类覆盖其内容，防止子类重写，若子类重写后，只能在该子类的内部中使用。这个方法不能被重写，它只允许在该类的内部中使用。

  3. __xx__经常是操作符或本地函数调用的magic methods。

    在特殊的情况下，它只是python调用的hook。例如，init()函数是当对象被创建初始化时调用的;new()是用来创建实例。

字典与匿名函数的巧妙组合

python中没有switch/case以及三目运算符

优雅实现switch/case

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
# 情况1: 范围判断
conditions = lambda x: {
    x < -1: 0, -1 <= x <= 1: 0.5, x > 1: 1
}
# 返回第一个满足条件的值 0.5
num = conditions(0.25)[True]
print(num)
# 返回最后一个不满足条件的值 1
num = conditions(0.25)[False]
print(num)

# 情况2: 映射对应程序段
def select_train():
    t = 0

def select_test():
    t = 1

def select_eval():
    t = 2
    
def select_result(goal):
    condition_list = {
        'train': select_train,
        'test': select_test,
        'eval': select_eval,
    }
    # 搜寻不到输出后面字符串
    print(condition_list.get(goal, '必须是 train / test / eval 这三种类型'))

select_result('train')

with语句

需要事先做一些设置，事后做一些清理．（类似于try/excption/finally）

1
2
with open(r'c:\test.txt', 'r') as f:
	data = f.read()

with后面接的对象返回的结果赋值给f。此例当中open函数返回的文件对象赋值给了f；with会自已获取上下文件的异常信息。

模块调用

python只用另一模块中的类， 为什么不包含在类中的代码也会被执行？

因为引用了其他模块的函数，但是该模块里面有不是包含在函数中的代码，你在引用该模块中dao的函数时候会先执行被引用模块的代码。

深拷贝与浅拷贝-巨坑

大佬写的很清楚：Python List的赋值方法

Python中关于对象复制有三种类型的使用方式，赋值、浅拷贝与深拷贝。

赋值：对象的赋值就是简单的对象引用，他们指向同一片内存，b是a的别名，是引用（同一个内存地址）。

浅拷贝.copy()： 浅拷贝会创建新对象，其内容是原对象的引用。二者包含的元素的地址是相同的。是它仅仅只拷贝了一层，在a中有一个嵌套的list，如果我们修改了它，情况就不一样了。

深拷贝.deepcopy()：深拷贝拷贝了对象的所有元素，包括多层嵌套的元素。因而，它的时间和空间开销要高。因为深拷贝出来的对象根本就是一个全新的对象，不再与原来的对象有任何关联。

二维列表定义与赋值

1
2
3
4
#错误写法
 consume_list = [[0] * list_col] * list_row
 consume_list[i][j] = dis * value
 #发现bug ---- 尝试给其中一个元素赋值,整个列表的第j列都被赋值,导致结果不正确

二维列表定义与赋值-error

参考：python二维列表list赋值时整列重复赋值问题

原因：本质上是“浅拷贝”的锅，二者包含的元素的地址是相同的。上面的定义手法是将第一行的元素的地址给了下面行，所以改变的时候，会出现整列一起改变的情况。

1
2
# 正确写法 --- 每一行创建不同的元素
consume_list = [[0] * list_col for i in range(list_row)]

二维列表定义与赋值-right

二维数组定义与初始化

1
2
3
4
5
6
# 方法一：
current_food = np.ones((row, col)) * init_value
# 方法二：
#先生成一个list 再转换成数组 ；0 是 数组初始化的值  ；数组较大 时候 效率较慢
consume_list = [[0] * list_col for i in range(list_row)]
a = np.array(consume_list)

代码精炼

绘制三维图

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
import matplotlib.pyplot as plt
#设置画布
fig = plt.figure()
ax = fig.add_subplot(projection='3d')
# 三维散点图
#对应点的颜色和尺寸（可设置不同）
color_map = []
size_map = []
ax.scatter3D(x_data, y_data, z_data, c=color_map, s=size_map, cmap='Blues')
ax.set_xlabel('X', fontsize=16)
ax.set_ylabel('Y', fontsize=16)
ax.set_zlabel('Z', fontsize=16)
plt.show()

# 三维曲面图
# 0-43.65等距分成1165份
x_data = np.linspace(0, 43.65, 1165)
y_data = np.linspace(0, 58.2, 876)
#用于三维曲面的分格线座标（必须要有）
x, y=np.meshgrid(x_data, y_data)
#z坐标数据（二维数组）
z = np.array(data)
ax.contour3D(x, y, z, 150, cmap='rainbow')
# ax.plot_trisurf(x, y, z, 50, cmap='rainbow')
plt.show()

# 等高线图
#填充颜色
plt.contourf(x, y, z, 10, alpha=0.6, cmap='rainbow')
plt.contourf(x, y, z, 10, alpha=0.6)
#绘制等高线
C = plt.contour(x, y, z, 3, colors='black')
#显示各等高线的数据标签
plt.clabel(C, inline=True, fontsize=15, colors='y')
plt.show()

按照优先级快排算法(升序)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def partition(arr, low, high, rule):
    i = low
    pivot = rule[high]
    for j in range(low, high):
        if rule[j] <= pivot:
            # ≤最后一个元素的所有元素依次放在左边索引0~i的位置
            arr[i], arr[j] = arr[j], arr[i]
            rule[i], rule[j] = rule[j], rule[i]
            i = i + 1
    # 然后将最后一个元素放在索引i的位置
    arr[i], arr[high] = arr[high], arr[i]
    rule[i], rule[high] = rule[high], rule[i]
    return i

def quickSort(arr, low, high, rule):
    if low < high:
        pi = partition(arr, low, high, rule)
        quickSort(arr, low, pi - 1, rule)
        quickSort(arr, pi + 1, high, rule)

双栈A*算法

参考：

图算法 - 只需“五步” ，获取两节点间的所有路径（非递归方式）

求两点间所有路径的遍历算法

无向连通图中两点间所有路径的算法

可实现图中任意两点所有路径以及（优先级排序后的最少节点-距离终点最近/最短路径-距离起点and终点最近）的路径

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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
# 找寻起点与终点的最少节点的路径
def way_finding(start, end):
    # 计算完直接读取，避免重复计算
    # 节点之间消耗度（舒适度、饱食度）
    # consume_list = pd.read_excel('consume_list.xlsx')
    consume_list = pd.read_excel('consume_list_1.xlsx')
    dis_list = pd.read_excel('dis_list.xlsx')
    # print(dis_list.iloc[0, 0])
    # print(dis_list.iloc[0, 1])
    # print(dis_list.iloc[5, 0])
    # print(dis_list.iloc[0, 5])
    # print(dis_list.iloc[5, 5])
    print('消耗表的大小：', consume_list.shape)
    print('距离表的大小：', dis_list.shape)

    file = open('./node_map.txt', 'r')
    node_map = eval(file.read())
    file.close()
    file = open('./2.txt', 'w')
    # print(node_map)
    # 约束
    # 死亡条件
    dead_condition = -5
    # 终点条件
    destination_condition = -3

    # 存放当前已选择节点 的主栈
    main_stack = [start]
    # 存放接下来可连接的点 的辅栈
    side_stack = [node_map[start]]
    # 舒适度栈,饱食度栈
    food_stack = [10.0]
    temp_stack = [10.0]

    count = 0
    min_dis = float('inf')

    # 当主栈不为空
    while len(main_stack) > 0:
        # print('主栈', main_stack)
        # print('辅栈', side_stack)

        # 弹出当前可以连接的 辅栈栈顶节点 尝试加入主栈
        side_top = side_stack.pop()

        # 主栈栈顶
        current_main_top = main_stack[-1]
        current_food = food_stack[-1]
        current_temp = temp_stack[-1]
        id_current_main_top = int(current_main_top)
        print('id_current_main_top:%d,当前饱食度:%f,当前舒适度%f' % (id_current_main_top, current_food, current_temp), main_stack)
        str_1 = 'id_current_main_top:%d,当前饱食度:%f,当前舒适度%f' % (id_current_main_top, current_food, current_temp) + str(
            main_stack) + '\n'
        file.write(str_1)
        # 找下一个主栈栈顶
        # 当栈顶节点不为空
        if len(side_top) > 0:
            # 辅栈栈顶
            main_top = side_top[0]
            id_main_top = int(main_top)

            type_main = type_date.iloc[id_main_top]
            supply_main = energy_data.iloc[id_main_top]
            consume_main = consume_list.iloc[id_current_main_top][id_main_top]
            print('从%d点到%d点要消耗%f的能量(无论是食物还是温度),该顶点提供%d能量'
                  % (id_current_main_top, id_main_top, consume_main, supply_main))
            file.write('从%d点到%d点要消耗%f的能量(无论是食物还是温度),该顶点提供%d能量\n'
                       % (id_current_main_top, id_main_top, consume_main, supply_main))
            # 人物存活约束
            if current_food - consume_main >= dead_condition and current_temp - consume_main >= dead_condition:
                # 辅栈栈顶节点加入主栈栈顶
                main_stack.append(main_top)
                # 消耗能量
                current_food -= consume_main
                current_temp -= consume_main
                # 补充食物或温度
                if type_main:
                    current_food += supply_main
                else:
                    current_temp += supply_main

                food_stack.append(current_food)
                temp_stack.append(current_temp)
                # 辅栈加入 栈顶节点接下来可连接的点
                side_stack.append(side_top[1:])
                # 去除掉辅栈中(主栈已经存在的节点),避免回路
                if len(node_map[main_top]) > 0:
                    side_top = []
                    for v in node_map[main_top]:
                        if v not in main_stack:
                            side_top.append(v)
                    side_stack.append(side_top)

            # 不满足人物存活条件
            else:
                # 辅栈中去掉当前辅栈栈顶节点
                side_stack.append(side_top[1:])
                # print('辅栈', side_stack)

        # 如果走不通,去除主栈的栈顶顶点
        else:
            main_stack.pop()
            food_stack.pop()
            temp_stack.pop()

        # 栈顶为终点并且满足终点约束and不走回头路约束（路径不包含回路或环）便输出这条路径
        if len(main_stack) > 0 and main_stack[-1] == end \
                and food_stack[-1] >= destination_condition and temp_stack[-1] >= destination_condition:
            # if len(main_stack) > 0 and main_stack[-1] == end:
            count += 1
            dis_sum = 0
            for i in range(len(main_stack) - 1):
                # 距离
                current_node = int(main_stack[i])
                next_node = int(main_stack[i + 1])
                dis_sum += dis_list.iloc[current_node, next_node]
                # print('%d %d: ' % (current_node, next_node), dis_list.iloc[current_node, next_node])
            if min_dis > dis_sum:
                min_dis = dis_sum
                index_min_dis = count
                save_str = "********  当前最小距离为：%f, 出现在第 %d 条, 节点数是%d, 到达终点时饱食度: %f,舒适度: %f,路径是 " \
                           % (min_dis, index_min_dis, len(main_stack), current_food, current_temp) + str(
                    main_stack)
                print(save_str)
                file.write(save_str)
            print("=====FOUND=====", count)
            save_result = "该人物从起点到终点（经过的食物点和篝火点的次数最少,用序号表示）的路线为：: " + str(main_stack) + \
                          ' \n途经 %d 个节点,到达终点时饱食度: %f,舒适度: %f' % (len(main_stack), current_food, current_temp) \
                          + ' 此时距离为：%f 米' % dis_sum
            print(save_result)
            result_file = open('./moni2-2_result_file.txt', 'w')
            result_file.write(save_result)
            result_file.close()
            file.close()
            break
            pop_stack(main_stack, side_stack)


def pop_stack(main_stack, side_stack):
    main_stack.pop()
    if len(side_stack) > 0:
        side_stack.pop()
       
way_finding('0', '587')

遗传算法

参考：

geatpy教程

geatpy库笔记

python运筹优化（三）：遗传算法和Geatpy使用实践

1
2


参考文章

python— 、--和__xx__的区别

Python3 之 with语句（高效、便捷）

Python中如何优雅地使用switch语句

Python switch/case语句实现方法

为什么python的函数没被调用就被执行了？

Python List的赋值方法

---------------- 本文结束 ----------------

本文标题:python语法奇奇怪怪小合集

文章作者:Pabebe

发布时间:2020年07月15日 - 17:41:54

最后更新:2020年09月23日 - 10:35:01

原始链接:https://pabebezz.github.io/article/e58acc82/

许可协议: 署名-非商业性使用-禁止演绎 4.0 国际 转载请保留原文链接及作者。

0%