[记录贴]每天的问题和解决方法_正确学习方法

lightninng

今天继续处理之前的数据问题，数据量比较大，我需要用百度api去查经纬度，但是又不能一直让程序跑着，我的想法是，让它查的过程中一直记录查到第几条了，然后我打断程序时它能把这个数记在一个文件中，下次再次运行代码时它能够从文件中读取这个位置，然后从这里继续进行，这其中最大的问题是怎么样能够打断程序运行，但是又让它在运行结束之前能够完成一些上下文的保存工作
最近用的pyqt(python3.3+pyqt5.4)写了一个简单的界面演示如下：

1. #-*- coding:utf-8 -*-
   
2. """演示程序"""
   
3. import sys
   
4. from PyQt5 import QtWidgets
   
5. 
   
6. 
   
7. class GeoQuery(QtWidgets.QWidget):
   
8.     def __init__(self):
   
9.         super(GeoQuery, self).__init__()
   
10. 
    
11.         self.setWindowTitle("演示程序")
    
12. 
    
13.         self.flag = 1  # 用来控制while循环的结束
    
14.         grid = QtWidgets.QGridLayout()
    
15. 
    
16.         # 添加开始按钮并设定点击它出发start函数
    
17.         start_button = QtWidgets.QPushButton("开始")
    
18.         start_button.clicked.connect(self.start)
    
19.         grid.addWidget(start_button, 0, 3)
    
20. 
    
21.         # 添加停止按钮并设定点击它出发stop函数
    
22.         start_button = QtWidgets.QPushButton("停止")
    
23.         start_button.clicked.connect(self.stop)
    
24.         grid.addWidget(start_button, 1, 3)
    
25. 
    
26.         # 添加信息显示框用来显示一些必要的信息
    
27.         self.list_edit = QtWidgets.QListWidget()
    
28.         grid.addWidget(self.list_edit, 0, 0, 3, 3)
    
29. 
    
30.         self.setLayout(grid)
    
31. 
    
32.     def start(self):
    
33.         import time
    
34.         i = 0
    
35.         while self.flag == 1:
    
36.             i += 1
    
37.             time.sleep(1)
    
38.             # 把这个语句换为你的程序任务处理
    
39.             self.list_edit.addItem("正在处理第{}个文件".format(i))  
    
40.             QtWidgets.QApplication.processEvents()
    
41.         
    
42.          # 把这个语句换为你打断程序循环之后需要程序进行的任务（如保存上下文）
    
43.         self.list_edit.addItem("正在记录处理位置")
    
44.         self.list_edit.addItem("处理到了第{}个数据,并结束".format(i))
    
45. 
    
46.     def stop(self):
    
47.             self.flag = 0
    
48. 
    
49. app = QtWidgets.QApplication(sys.argv)
    
50. geo_query = GeoQuery()
    
51. geo_query.show()
    
52. sys.exit(app.exec_())

复制代码

这里比较关键的点是QtWidgets.QApplication.processEvents()这条语句，processEvents()会先将循环挂起处理队列中的其它请求，然后再返回循环继续进行，这里我绑定了开始按钮开始循环进行我们的主体工作，然后每次循环中都调用processEvent()函数，当检测到停止按钮按下时，先将循环暂停，去处理stop函数的调用（因为已经将停止按钮的点击操作和stop函数绑定），将self.flag设为0，然后返回循环，这样当该次循环结束再次判断循环条件就会失败，从而 跳出循环，然后在循环体后记录主体工作的进度即可，这里的i可以在GeoQuery类中先定义 ，在初始化时从文件中读取位置并赋值给i，然后退出时将i保存到文件中即可

截图：循环打断

lightninng

今天还是涉及数据库的问题，首先是遇到一个要复制一个表中的一列到另外一列

1. INSERT INTO direction (COL_1,  COL_2, COL_3) SELECT COL_4, COL_5, COL_6 FROM origin

复制代码

将origin表中的COL_4, COL_5, COL_6 三列数据分别复制到direction表中的COL_1,  COL_2, COL_3列中，
如果仅仅想插入一条数据可以

1. INSERT INTO direction (COL_1,  COL_2, COL_3) VALUES (VALUE_1, VALUE2, VALUE_3)

复制代码

如果在数据库中运行请在语句后面加上分号，如果是在python connecter中用cursor.execute()方法运行则不必

另外 ，在内存足够时，尽量将数据一次性取出处理好，再一次性存入数据库，不然数据库的读取带来的时间上的损失是你无法接受的~

lightninng

这其实是昨天的问题,今早倒腾了半天 没解决，下午找到了解决办法

先说我的问题，在通过MySQL connecter 执行多次大量数据库操作后报错InternalError ：Unread result found，百度结果并不理想，只有一个中文的说到要用fetchXX方法（目测他也是随便写一下，fetch还多写了个c半天没搜到~~），看到英文的IT相关技术问答网站，有人详细的说了这个问题，但是这个伙计说了问题，解决方法我没看懂，于是照他给的连接查到了MySQL官方网站对这个问题的说法，特翻译如下，红字部分即为原因

http://dev.mysql.com/doc/connector-python/en/connector-python-api-mysqlcursorbuffered.html

10.6.1 类 cursor.MySQLCursorBuffered

执行查询后,MySQLCursorBuffered游标标从服务器获取整个结果集和并将他们放在缓冲区中。

执行查询使用buffered游标时 ,取行方法如fetchone()返回的是缓冲区中的行。nonbuffered游标,将不从服务器获取数据,直到你调用了某个取数据行的方法（这里应该是指fetch开头的一些方法，如fetchone(),fetchall()等）。在使用nonbuffered游标时,你必须确保取出结果集中的所有行，才能再用同一连接执行其他语句在,否则会提高InternalError(Unread result found)异常发生的概率。

Buffered游标适用于你需要进行多个小结果集的查询,且多个结果集之间的数据需要一起使用。

如果你需要创建buffered游标,调用连接的cursor()方法时需要使用buffered参数（查了一些文档这个参数是一个没默认参数，默认值为False）。另外,你也可以通过设定连接参数，来将所有通过该连接创建的游标默认置为buffered=true

一个例子：

1. import mysql.connector
   
2. 
   
3. cnx = mysql.connector.connect()
   
4. 
   
5. # 只有这个特定的游标可以将结果放入缓冲区
   
6. cursor = cnx.cursor(buffered=True)
   
7. 
   
8. # 所有通过cnx2连接创建的游标都没默认为buffered游标
   
9. cnx2 = mysql.connector.connect(buffered=True)

复制代码

原因找到了，那么解决办法也就很简单了，虽然花了点时间，但是和之前看这些东西比，算是少的首先，自己的结果集没取完，那么直接用fetchall()取完就ok，但是似乎不甚理想，fetchall()半天也没取完剩下的数据，可能是自己的程序有问题，也可能是本来就那么慢，总之我没耐心就ctrl+ c了（这个方法就是在要进行下一个MySQL语句前加入语句cursor.fetchall()）
然后，在取完数据集的操作中，通过游标cursor的迭代来进行处理的方法，也会有一定的概率触发InternalError ：Unread result found，这里的迭代方法比较基本，前面 的贴子中也有就不写了，于是又换一种方法

1. row = cursor.fetchone()
   
2. while row is not None:
   
3.   print(row)
   
4.   row = cursor.fetchone()

复制代码

这是官方文档我翻到介绍fetchone()方法时里面提到的方法，想通过这种方法避免internalerror，结果我还是太天真了，以为成功了，结果第二次运行的时候同样 的报错~最终问题是这样解决的，将游标置为buffered，然后分多次从数据库中读取数据并处理，确实如MySQL官网上所说，将游标置为buffered之后再未出现过InternalError ：Unread result found这个错误，但是多次取数据之后程序会卡在原地不动，我是2600多w数据，每次取100w，取到第5次之后程序就卡住 了，至今原因未知~~

lightninng

今天一天几乎 什么都没干，晚上写了一会dbscan,遇到各种问题，明天继续~~

lightninng

花了一天时间把自己的dbscan算法跑通，参数选好了，不是很复杂的东西，但是数据量真的太大了，之前是300w条，只拿出来了1w条跑，果然google的map-reduce是一个伟大的发明！！！真要是有时间想研究一下

1. ESP = 5  # esp的默认值
   
2.     def dbscan(esp=0, minpts=4):
   
3.     import pickle
   
4.     import os
   
5.     import math
   
6.     import matplotlib.pyplot as plt
   
7. 
   
8.     if not os.path.exists(r"F:\data_storage\distance.txt"):  # distance.txt存放距离矩阵，字典形式{点名: {点名： 两点之间的距离}}
   
9.         print("距离矩阵不存在，重新建立距离矩阵")
   
10. 
    
11.         def o_dis(a, b):
    
12.             # 计算欧式距离
    
13.             return math.sqrt((a[0]-b[0])**2 + (a[1]-b[1])**2)
    
14.         with open(r"org_dict.txt", "rb") as fp:  # org_dict .txt存放数据点坐标，字典形式{点名: (横坐标，纵坐标)}
    
15.             org_dict = pickle.load(fp)
    
16.         n = len(org_dict)
    
17.         print(n)
    
18.         distance = {}
    
19.         with open("F:\data_storage\distance.txt", "wb") as fp_w:
    
20.             i = 0
    
21.             for each_key in org_dict.keys():
    
22.                 temp_dict = {}
    
23.                 for each_item in org_dict.items():
    
24.                     temp_dict[each_item[0]] = o_dis(org_dict[each_key], each_item[1])
    
25.                 distance[each_key] = temp_dict
    
26.                 i += 1
    
27.                 if i % 1000 == 0:
    
28.                     print("距离矩阵已更新{}行".format(i))
    
29.             pickle.dump(distance, fp_w)
    
30. 
    
31.     # 如输入参数esp未给定则重新计算esp
    
32.     if esp == 0:
    
33.         print("开始计算esp")
    
34.         esp_set = []
    
35.         with open("distance.txt", "rb") as fp:
    
36.             distance = pickle.load(fp)
    
37.         i = 0
    
38.         n = len(distance)
    
39.         for each_key in distance.keys():
    
40.             i += 1
    
41.             esp_set.append(sorted(list(distance[each_key].values()))[minpts])
    
42.             print("已经计算完{}个esp值".format(i))
    
43.         # 绘制dsp-k4图
    
44.         esp_set.sort(reverse=True)
    
45.         x = range(n)
    
46.         y = esp_set
    
47.         esp = esp_set[int(len(esp_set)*esp_rate)]
    
48.         plt.plot(x, y, "o")
    
49.         plt.xlabel("x")
    
50.         plt.ylabel("esp-k4")
    
51.         plt.show()
    
52. 
    
53. 
    
54.     print("esp已设定为{}".format(esp))
    
55.     print("minpts已设定为{}".format(minpts))
    
56.     with open("F:\data_storage\distance.txt", "rb") as fp:
    
57.         distance = pickle.load(fp)
    
58.     print("org_dict读取完毕")
    
59.     with open(r"F:\data_storage\org_dict.txt", "rb") as fp:
    
60.         org_dict = pickle.load(fp)
    
61.     print("distance读取完毕")
    
62.     """
    
63.     标记所有对象为 unvisited
    
64.     while True:
    
65.         随机选择一个 unvisited 对象 p
    
66.         标记 p 为 visited
    
67.         if p 的ε -邻域至少有MinPts个对象
    
68.             创建一个新簇C，并把 p 添加到C
    
69.             令 N 为 p 的ε -邻域中的对象集合
    
70.             for  N 中每个点p'
    
71.                 if p' 是 unvisited
    
72.                     标记 p' 为 visited
    
73.                 if p' 的 ε -邻域至少有 MinPts 个点，把这些点添加到 N
    
74.                 if p'还不是任何簇的成员，把p'添加到 C
    
75.             输出C；
    
76.         else 标记 p 为噪声；
    
77.         if 没有标记为 unvisited 的对象:
    
78.             break
    
79.     """
    
80.     # 标记所有对象为 unvisited
    
81.     unvisited = set()
    
82.     for each_key in org_dict.keys():
    
83.         unvisited.add(each_key)
    
84.     print("所有对象已标记未遍历")
    
85.     result = {}
    
86.     i = 0
    
87.     k = 0
    
88.     while unvisited:
    
89.         p_key = unvisited.pop()
    
90.         p_set = set([key for key, value in distance[p_key].items() if value <= esp])
    
91.         if len(p_set) >= minpts+1:
    
92.             print("初始p_set为{}".format(p_set))
    
93.             i += 1
    
94.             j = 0
    
95.             result[p_key] = i
    
96.             print("第{0}类聚类开始，已经检测出{1}个噪点".format(i, k))
    
97.             while p_set:
    
98.                 p1_key = p_set.pop()
    
99.                 if p1_key in unvisited:
    
100.                     unvisited.remove(p1_key)
     
101.                     p1_value = i
     
102.                     result[p1_key] = p1_value
     
103.                     j += 1
     
104.                     print("聚类{0}已经有{1}个元素".format(i, j))
     
105.                 p1_set = set([key for key, value in distance[p1_key].items() if value <= esp])
     
106.                 if len(p1_set) >= minpts+1:
     
107.                     for each in p1_set:
     
108.                         if each in unvisited:
     
109.                             p1_set.add(each)
     
110. 
     
111.             print("聚类{}已创建完毕".format(i))
     
112.         else:
     
113.             result[p_key] = 0
     
114.             k += 1
     
115.             if k % 100 == 0:
     
116.                 print("已经检测出{}个噪点".format(k))
     
117. 
     
118.     output = {}
     
119.     for pos, cluster in [(tuple(org_dict[key]), result[key]) for key in result.keys()]:
     
120.         if cluster not in output:
     
121.             output[cluster] = [pos]
     
122.         else:
     
123.             output[cluster].append(pos)
     
124.     color = {0: (0, 0, 0, 1),
     
125.              1: (250/255, 240/255, 230/255, 1),
     
126.              2: (1, 0, 0, 1),
     
127.              3: (1, 1, 0, 1),
     
128.              4: (156/255, 102/255, 31/255, 1),
     
129.              5: (1, 125/255, 64/255, 1),
     
130.              6: (1, 0, 1, 1),
     
131.              7: (100/255, 0, 0, 1),
     
132.              8: (0, 1, 0, 1),
     
133.              9: (0, 0, 1, 1),
     
134.              10: (192/255, 192/255, 192/255, 1),
     
135.              }
     
136.     for cluster in output:
     
137.         if cluster < 10:
     
138.             for each in output[cluster]:
     
139.                 plt.plot(each[0], each[1], 'o', color=color[cluster])
     
140.         else:
     
141.             print("聚类{}未绘制".format(cluster))
     
142.     print("聚类完成，得到聚类{0}个，检测出{1}个噪点".format(i, k))
     
143.     plt.show()

复制代码

lightninng

今天基本完成了昨天dbscan算法的测试，感觉写的还是略冗余，而且读取源数据和dbscan核心算法部分未分开，这样并不好，自己写的pyqt程序界面与功能代码也未分开，有待加强，剩下的时间先更新一节pyqt的贴子去，下午研究了主成分分析的算法，意外的不难，明天自己实现 ，跑起来试一下~

lightninng

python自带的扩展模块已经非常强大了，比如 说这个itertools模块，把觉得有意思的发上来，具体请看http://www.cnblogs.com/cython/articles/2169009.html
chain(iter1, iter2, ..., iterN)：
给出一组迭代器(iter1, iter2, ..., iterN)，此函数创建一个新迭代器来将所有的迭代器链接起来，返回的迭代器从iter1开始生成项，知道iter1被用完，然后从iter2生成项，这一过程会持续到iterN中所有的项都被用完。

1. >>> from itertools import chain
   
2. >>> test = chain('AB', 'CDE', 'F')
   
3. >>> test
   
4. <itertools.chain object at 0x00000000033ADB38>
   
5. >>> list(test)
   
6. ['A', 'B', 'C', 'D', 'E', 'F']
   
7. >>>

复制代码

combinations(iterable, r):
创建一个迭代器，返回iterable中所有长度为r的子序列，返回的子序列中的项按输入iterable中的顺序排序:
PS:今天就是用到这个才搜到这个模块的，其实就是返回iterable中选择r个元素的所有不同组合的序列

1. >>> from itertools import combinations
   
2. >>> test = combinations([1,2,3,4,5], 3)
   
3. >>> test
   
4. <itertools.combinations object at 0x00000000033E0138>
   
5. >>> list(test)
   
6. [(1, 2, 3), (1, 2, 4), (1, 2, 5), (1, 3, 4), (1, 3, 5), (1, 4, 5), (2, 3, 4), (2, 3, 5), (2, 4, 5), (3, 4, 5)]
   
7. >>>

复制代码

dropwhile(predicate, iterable):
创建一个迭代器，只要函数predicate(item)为True，就丢弃iterable中的项，如果predicate返回False，就会生成iterable中的项和所有后续项。

1. >>> from itertools import dropwhile
   
2. >>> test = dropwhile(str.isalpha, ['a','A','2','e','2'])
   
3. >>> test
   
4. <itertools.dropwhile object at 0x00000000033F1A88>
   
5. >>> list(test)
   
6. ['2', 'e', '2']
   
7. >>>

复制代码

-*--*--*--*--*--*--*--*--*--*--*---*--*--*--*--*--*--*--*--*--*--*---*--*--*--*--*--*--*--*--*--*--*---*--*--*--*--*--*--看到一个同学问到关于类的问题一下想起当时在下面这个python学习教程上看到的关于类中的__slot__变量
http://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000
使用__slots__

想要限制class的属性怎么办？比如，只允许对Student实例添加name和age属性。

为了达到限制的目的，Python允许在定义class的时候，定义一个特殊的__slots__变量，来限制该class能添加的属性：

1. >>> class Student(object):
   
2. ...     __slots__ = ('name', 'age') # 用tuple定义允许绑定的属性名称

复制代码

然后试试

1. >>> s = Student() # 创建新的实例
   
2. >>> s.name = 'Michael' # 绑定属性'name'
   
3. >>> s.age = 25 # 绑定属性'age'
   
4. >>> s.score = 99 # 绑定属性'score'
   
5. Traceback (most recent call last):
   
6.   File "<stdin>", line 1, in <module>
   
7. AttributeError: 'Student' object has no attribute 'score'

复制代码

由于'score'没有被放到__slots__中，所以不能绑定score属性，试图绑定score将得到AttributeError的错误。

使用__slots__要注意，__slots__定义的属性仅对当前类起作用，对继承的子类是不起作用的：

1. <font color="rgb(51, 51, 51)">>>> class GraduateStudent(Student):
   
2. ...     pass
   
3. ...
   
4. >>> g = GraduateStudent()
   
5. >>> g.score = 9999</font>

复制代码

除非在子类中也定义__slots__，这样，子类允许定义的属性就是自身的__slots__加上父类的__slots__。

lightninng

最近写的程序老是出问题，想让它自己完成一些事情 ，然后自己可以离开机器，于是要写很多print语句，其实调试还有很多办法 ，暂时就没学了，
http://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/
这个里面关于调试的条目写的非常的详细，有时间我一定会试一下
自己在print语句里面总是想加上时间，python 的time模块是相当 强大的，之前碰到过的加上这次用的，介绍简单的几个一、time模块
1、clock()，这个函数常常用于记录程序运行的时间，比如你要和别人写的函数比效率时，函数功能如下
  clock() -> floating point number
  该函数有两个功能，
  在第一次调用的时候，返回的是程序运行的实际时间；
  以第二次之后的调用，返回的是自第一次调用后,到这次调用的时间间隔

1. def power_1(x, y):
   
2.     return (x ** y)
   
3. def power_2(x, y):
   
4.     result = 1
   
5.     for i in range(y):
   
6.         result *= x
   
7.     return result
   
8. 
   
9. import time
   
10. start = time.clock()
    
11. power_1(144764326432, 100)
    
12. time_1 = time.clock()
    
13. power_2(144764326432, 100)
    
14. time_2 = time.clock()
    
15. print("power_1运行了{}秒".format(time_1 - start))
    
16. print("power_2运行了{}秒".format(time_2 - time_1))
    

复制代码

运行结果如下

1. >>>
   
2. power_1运行了8.659919199746488e-06秒
   
3. power_2运行了4.5224022487565005e-05秒
   
4. >>>

复制代码

2、sleep(t)，等待t秒钟的时间，往往用在你需要频繁的请求数据时，比如我调用百度的geocoding，在循环体中会加上time.sleep(1)这样的语句，防止ip被封
3、strftime()，这个函数相当的强大，可以按你要求的格式 返回一个表示当前时间(默认)的字符串
将指定的struct_time(默认为当前时间)，根据指定的格式化字符串输出
  python中时间日期格式化符号：
  %y 两位数的年份表示（00-99）
  %Y 四位数的年份表示（000-9999）
  %m 月份（01-12）
  %d 月内中的一天（0-31）
  %H 24小时制小时数（0-23）
  %I 12小时制小时数（01-12）
  %M 分钟数（00=59）
  %S 秒（00-59）
  
  %a 本地简化星期名称
  %A 本地完整星期名称
  %b 本地简化的月份名称
  %B 本地完整的月份名称
  %c 本地相应的日期表示和时间表示
  %j 年内的一天（001-366）
  %p 本地A.M.或P.M.的等价符
  %U 一年中的星期数（00-53）星期天为星期的开始
  %w 星期（0-6），星期天为星期的开始
  %W 一年中的星期数（00-53）星期一为星期的开始
  %x 本地相应的日期表示
  %X 本地相应的时间表示
  %Z 当前时区的名称
  %% %号本身 例如：

1. >>> from time import strftime
   
2. >>> strftime("%a %b %d %H:%M:%S %Y")
   
3. 'Fri Apr 10 23:20:18 2015'

复制代码

二、os模块
1、os.getcwd()
函数得到当前工作目录，即当前Python脚本工作的目录路径。比如，你想直接用import XX来导入当前目录的某些模块，或者你想直接用文件名调用和代码相同文件夹的文件，可以这么做

1.     import os
   
2.     import sys
   
3.     sys.path.append(os.getcwd())  # 运行时将当前目录暂时放入系统变量的path中

复制代码

2、os.listdir()
函数得到指定目录的文件列表，用一个列表存放起来，比如，获取当前目录的文件列表

1. >>> import os
   
2. >>> os.listdir()
   
3. ['DLLs', 'Doc', 'include', 'Lib', 'libs', 'LICENSE.txt', 'NEWS.txt', 'python.exe', 'pythonw.exe', 'pywin32-wininst.log', 'qt.conf', 'README.txt', 'Removepywin32.exe', 'Scripts', 'share', 'tcl', 'Tools']
   
4. >>>

复制代码

3、os.chdir()函数可以更改当前文件目录，比较简单，不举例了就
4、os.system()
这个函数可以用于执行shell命令，在windows中相当于在cmd中输入命令，例如：

1. >>> os.system('dir')
   
2. 0
   
3. >>> os.system('cmd') #启动cmd

复制代码

5、os.popen()这个函数和system差不多，但是它可以返回你输入的shell命令的结果，例如：

1. >>> import os
   
2. >>> list(os.popen("dir"))  # 这里将返回的结果转化为列表
   
3. [' 驱动器 C 中的卷没有标签。\n', ' 卷的序列号是 D02F-B239\n', '\n', ' C:\\Python33 的目录\n', '\n', '2015/03/26  22:08    <DIR>          .\n', '2015/03/26  22:08    <DIR>          ..\n', '2015/03/25  22:30    <DIR>          DLLs\n', '2015/03/25  22:30    <DIR>          Doc\n', '2015/04/09  23:46    <DIR>          include\n', '2015/03/25  22:30    <DIR>          Lib\n', '2015/03/25  22:30    <DIR>          libs\n', '2013/05/16  00:16            33,326 LICENSE.txt\n', '2013/05/15  22:51           214,554 NEWS.txt\n', '2013/05/16  00:07            40,448 python.exe\n', '2013/05/16  00:07            40,960 pythonw.exe\n', '2015/03/25  22:31           123,862 pywin32-wininst.log\n', '2015/03/25  22:31               103 qt.conf\n', '2013/05/15  22:51             6,701 README.txt\n', '2015/03/25  22:30           222,208 Removepywin32.exe\n', '2015/03/26  22:42    <DIR>          Scripts\n', '2015/03/26  22:08    <DIR>          share\n', '2015/03/25  22:30    <DIR>          tcl\n', '2015/03/25  22:30    <DIR>          Tools\n', '               8 个文件        682,162 字节\n', '              11 个目录 50,187,689,984 可用字节\n']

复制代码

看到2中的例子有些同学可能想得到目录中所有非目录的文件名， 可以这么做

1. >>> os.popen("dir /A-D /B").readlines()
   
2. ['LICENSE.txt\n', 'NEWS.txt\n', 'python.exe\n', 'pythonw.exe\n', 'pywin32-wininst.log\n', 'qt.conf\n', 'README.txt\n', 'Removepywin32.exe\n']

复制代码

zd0307

支持

lightninng

zd0307 发表于 2015-4-11 02:35
支持

谢谢支持，欢迎交流~

lightninng

今天算是休息了一天，只更新了一下pyqt5的贴子，不过学到个东西，之前一直困扰我的，在文件路径符，如果表示一个目录，最后一个是\会导致，python报错

1. >>> file_name = "test"
   
2. SyntaxError: EOL while scanning string literal
   

复制代码

file_path 指定的是test这个目录这时候可以这么做

1. >>> file_name = "test/"

复制代码

我们来看看效果，它到底能不能用做路径

1. >>> import os
   
2. >>> os.chdir(file_name)  # 我的当前路径是在桌面上，然后我新建了一个test文件夹
   
3. >>> print(os.getcwd())
   
4. C:\Users\Administrator\Desktop\test
   
5. >>>

复制代码

-*--*--*--*--*--*--*--*--*--*--*---*--*--*--*--*--*--*--*--*--*--*---*--*--*--*--*--*--*--*--*--*--*---*--*--*--*--*--*--另外 一个就是上次提到的想用pyqt5做一个可以打断 保存断点的程序，里面用到了QListWidget这个部件，它用于以条目的形式显示 数据，在程序开始运行之后，会不停的往里面添加条目，到后面会非常卡，于是加了这么一段

1. if self.list_edit.count() > 10:
   
2.                 self.list_edit.clear()

复制代码

self.list_edit是我在__init__方法中定义的一个QlistWidget的实例，在下面的函数中的这段代码是说在list_edit 中的条目达到超过10，就清空

d5zhao

加油，学习中

lightninng

d5zhao 发表于 2015-4-12 03:53
加油，学习中

这么晚还在学习啊~~加油

lightninng

今天终于把所有的数据都准备妥当了，在处理数据的过程 中，需要对不同的变量做不同的处理，于是想到了C语言的swith语句 ，但是发现python里好像没有switch，那么python里是怎么做的呢，一个方法就是用字典代替，比如

1. # -*- coding: utf-8 -*-
   
2. def fun_1(x):
   
3.     print("fun_1的输入为:", x)
   
4. def fun_2(y):
   
5.     print("fun_2的输入为:", y)
   
6. fun_dict = {1: fun_1, 2: fun_2}
   
7. fun_dict[1]("王司徒")
   
8. fun_dict[2]("丞相")

复制代码

这段程序的输入为

1. >>>
   
2. fun_1的输入为: 王司徒
   
3. fun_2的输入为: 丞相
   
4. >>>

复制代码

这里可以看到通过对fun_dict的索引得到了两个函数名，通过函数名找到相应的函数并调用，这里fun_dict[1]("王司徒")和fun_1("王司徒")是一样的，后面同理，这就是python中需要用到switch语句时可以用的一个方法~
当然用一连串的if...elif也是可以的

d5zhao

lightninng 发表于 2015-4-12 10:21
这么晚还在学习啊~~加油

我是时差党。嘿嘿

conn

:funk:

conn

:sweat:

lightninng

d5zhao 发表于 2015-4-13 09:04
我是时差党。嘿嘿

哈哈，我之前也是时差党，被室友强行搬过来了，加油~~

lightninng

conn 发表于 2015-4-13 09:34

你肿么了亲~

lightninng

之前一直说的主成分分析的（Principal Component Analysis，PCA）内容，今天终于把数据搞定了，跑通了这个，其实都是从机器学习实战上抄过来的，不过自己写一下代码，又用自己的数据跑通了，感觉还是有必要记录一下

1. import numpy
   
2. cov_mat = numpy.cov(data_array, rowvar=0)
   
3. eig_vals, eig_vects = numpy.linalg.eig(numpy.mat(cov_mat))
   

复制代码

其实核心语句就这三行，导入numpy模块，创建协方差矩阵，求协方差矩阵的特征值和特征向量前面需要做的工作有，将数据矩阵(data_array)置中，即所有数据的每个变量之和应为0,这是前提
所以前面 应该有这样的代码

1. mean_values = numpy.mean(data_array, axis=0)
   
2. data_array = data_array - mean_values

复制代码

第一行求出每个变量的平均值存在mean_values,第二行将源数据data_array重新赋值，新的矩阵的每个值都减去了所在列所代表变量的平均值