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

lightninng · 发表于 2015-4-3 15:42:28

本帖最后由 lightninng 于 2015-4-3 23:12 编辑

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

#-*- coding:utf-8 -*-
"""演示程序"""
import sys
from PyQt5 import QtWidgets


class GeoQuery(QtWidgets.QWidget):
    def __init__(self):
        super(GeoQuery, self).__init__()

        self.setWindowTitle("演示程序")

        self.flag = 1  # 用来控制while循环的结束
        grid = QtWidgets.QGridLayout()

        # 添加开始按钮并设定点击它出发start函数
        start_button = QtWidgets.QPushButton("开始")
        start_button.clicked.connect(self.start)
        grid.addWidget(start_button, 0, 3)

        # 添加停止按钮并设定点击它出发stop函数
        start_button = QtWidgets.QPushButton("停止")
        start_button.clicked.connect(self.stop)
        grid.addWidget(start_button, 1, 3)

        # 添加信息显示框用来显示一些必要的信息
        self.list_edit = QtWidgets.QListWidget()
        grid.addWidget(self.list_edit, 0, 0, 3, 3)

        self.setLayout(grid)

    def start(self):
        import time
        i = 0
        while self.flag == 1:
            i += 1
            time.sleep(1)
            # 把这个语句换为你的程序任务处理
            self.list_edit.addItem("正在处理第{}个文件".format(i))  
            QtWidgets.QApplication.processEvents()
        
         # 把这个语句换为你打断程序循环之后需要程序进行的任务（如保存上下文）
        self.list_edit.addItem("正在记录处理位置") 
        self.list_edit.addItem("处理到了第{}个数据,并结束".format(i))

    def stop(self):
            self.flag = 0

app = QtWidgets.QApplication(sys.argv)
geo_query = GeoQuery()
geo_query.show()
sys.exit(app.exec_())

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

截图：循环打断

lightninng · 发表于 2015-4-4 22:40:45

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

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列中，
如果仅仅想插入一条数据可以

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

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

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

lightninng · 发表于 2015-4-5 10:32:28

本帖最后由 lightninng 于 2015-4-5 22:13 编辑

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

先说我的问题，在通过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

一个例子：

import mysql.connector

cnx = mysql.connector.connect()

# 只有这个特定的游标可以将结果放入缓冲区
cursor = cnx.cursor(buffered=True)

# 所有通过cnx2连接创建的游标都没默认为buffered游标
cnx2 = mysql.connector.connect(buffered=True)

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

row = cursor.fetchone()
while row is not None:
  print(row)
  row = cursor.fetchone()

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

lightninng · 发表于 2015-4-7 00:12:15

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

lightninng · 发表于 2015-4-8 00:06:19

本帖最后由 lightninng 于 2015-4-8 23:47 编辑

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

ESP = 5  # esp的默认值
    def dbscan(esp=0, minpts=4):
    import pickle
    import os
    import math
    import matplotlib.pyplot as plt

    if not os.path.exists(r"F:\data_storage\distance.txt"):  # distance.txt存放距离矩阵，字典形式{点名: {点名： 两点之间的距离}}
        print("距离矩阵不存在，重新建立距离矩阵")

        def o_dis(a, b):
            # 计算欧式距离
            return math.sqrt((a[0]-b[0])**2 + (a[1]-b[1])**2)
        with open(r"org_dict.txt", "rb") as fp:  # org_dict .txt存放数据点坐标，字典形式{点名: (横坐标，纵坐标)}
            org_dict = pickle.load(fp)
        n = len(org_dict)
        print(n)
        distance = {}
        with open("F:\data_storage\distance.txt", "wb") as fp_w:
            i = 0
            for each_key in org_dict.keys():
                temp_dict = {}
                for each_item in org_dict.items():
                    temp_dict[each_item[0]] = o_dis(org_dict[each_key], each_item[1])
                distance[each_key] = temp_dict
                i += 1
                if i % 1000 == 0:
                    print("距离矩阵已更新{}行".format(i))
            pickle.dump(distance, fp_w)

    # 如输入参数esp未给定则重新计算esp
    if esp == 0:
        print("开始计算esp")
        esp_set = []
        with open("distance.txt", "rb") as fp:
            distance = pickle.load(fp)
        i = 0
        n = len(distance)
        for each_key in distance.keys():
            i += 1
            esp_set.append(sorted(list(distance[each_key].values()))[minpts])
            print("已经计算完{}个esp值".format(i))
        # 绘制dsp-k4图
        esp_set.sort(reverse=True)
        x = range(n)
        y = esp_set
        esp = esp_set[int(len(esp_set)*esp_rate)]
        plt.plot(x, y, "o")
        plt.xlabel("x")
        plt.ylabel("esp-k4")
        plt.show()


    print("esp已设定为{}".format(esp))
    print("minpts已设定为{}".format(minpts))
    with open("F:\data_storage\distance.txt", "rb") as fp:
        distance = pickle.load(fp)
    print("org_dict读取完毕")
    with open(r"F:\data_storage\org_dict.txt", "rb") as fp:
        org_dict = pickle.load(fp)
    print("distance读取完毕")
    """
    标记所有对象为 unvisited
    while True:
        随机选择一个 unvisited 对象 p
        标记 p 为 visited
        if p 的ε -邻域至少有MinPts个对象
            创建一个新簇C，并把 p 添加到C
            令 N 为 p 的ε -邻域中的对象集合
            for  N 中每个点p'
                if p' 是 unvisited
                    标记 p' 为 visited
                if p' 的 ε -邻域至少有 MinPts 个点，把这些点添加到 N
                if p'还不是任何簇的成员，把p'添加到 C
            输出C；
        else 标记 p 为噪声；
        if 没有标记为 unvisited 的对象:
            break
    """
    # 标记所有对象为 unvisited
    unvisited = set()
    for each_key in org_dict.keys():
        unvisited.add(each_key)
    print("所有对象已标记未遍历")
    result = {}
    i = 0
    k = 0
    while unvisited:
        p_key = unvisited.pop()
        p_set = set([key for key, value in distance[p_key].items() if value <= esp])
        if len(p_set) >= minpts+1:
            print("初始p_set为{}".format(p_set))
            i += 1
            j = 0
            result[p_key] = i
            print("第{0}类聚类开始，已经检测出{1}个噪点".format(i, k))
            while p_set:
                p1_key = p_set.pop()
                if p1_key in unvisited:
                    unvisited.remove(p1_key)
                    p1_value = i
                    result[p1_key] = p1_value
                    j += 1
                    print("聚类{0}已经有{1}个元素".format(i, j))
                p1_set = set([key for key, value in distance[p1_key].items() if value <= esp])
                if len(p1_set) >= minpts+1:
                    for each in p1_set:
                        if each in unvisited:
                            p1_set.add(each)

            print("聚类{}已创建完毕".format(i))
        else:
            result[p_key] = 0
            k += 1
            if k % 100 == 0:
                print("已经检测出{}个噪点".format(k))

    output = {}
    for pos, cluster in [(tuple(org_dict[key]), result[key]) for key in result.keys()]:
        if cluster not in output:
            output[cluster] = [pos]
        else:
            output[cluster].append(pos)
    color = {0: (0, 0, 0, 1),
             1: (250/255, 240/255, 230/255, 1),
             2: (1, 0, 0, 1),
             3: (1, 1, 0, 1),
             4: (156/255, 102/255, 31/255, 1),
             5: (1, 125/255, 64/255, 1),
             6: (1, 0, 1, 1),
             7: (100/255, 0, 0, 1),
             8: (0, 1, 0, 1),
             9: (0, 0, 1, 1),
             10: (192/255, 192/255, 192/255, 1),
             }
    for cluster in output:
        if cluster < 10:
            for each in output[cluster]:
                plt.plot(each[0], each[1], 'o', color=color[cluster])
        else:
            print("聚类{}未绘制".format(cluster))
    print("聚类完成，得到聚类{0}个，检测出{1}个噪点".format(i, k))
    plt.show()

lightninng · 发表于 2015-4-8 23:50:47

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

lightninng · 发表于 2015-4-9 21:42:02

本帖最后由 lightninng 于 2015-4-9 23:20 编辑

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

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

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

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

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

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

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

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

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

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

然后试试

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

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

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

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

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

lightninng · 发表于 2015-4-10 23:14:13

本帖最后由 lightninng 于 2015-5-5 20:46 编辑

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

def power_1(x, y):
    return (x ** y)
def power_2(x, y):
    result = 1
    for i in range(y):
        result *= x
    return result

import time
start = time.clock()
power_1(144764326432, 100)
time_1 = time.clock()
power_2(144764326432, 100)
time_2 = time.clock()
print("power_1运行了{}秒".format(time_1 - start))
print("power_2运行了{}秒".format(time_2 - time_1))

运行结果如下

>>> 
power_1运行了8.659919199746488e-06秒
power_2运行了4.5224022487565005e-05秒
>>>

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 当前时区的名称
  %% %号本身例如：

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

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

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

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

>>> import os
>>> os.listdir()
['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']
>>>

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

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

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

>>> import os
>>> list(os.popen("dir"))  # 这里将返回的结果转化为列表
[' 驱动器 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中的例子有些同学可能想得到目录中所有非目录的文件名，可以这么做

>>> os.popen("dir /A-D /B").readlines()
['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 · 发表于 2015-4-11 02:35:05

支持

lightninng · 发表于 2015-4-11 11:09:32

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

谢谢支持，欢迎交流~

lightninng · 发表于 2015-4-11 19:50:48

本帖最后由 lightninng 于 2015-4-12 10:42 编辑

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

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

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

>>> file_name = "test/"

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

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

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

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

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

d5zhao · 发表于 2015-4-12 03:53:44

加油，学习中

lightninng · 发表于 2015-4-12 10:21:44

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

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

lightninng · 发表于 2015-4-12 22:53:12

本帖最后由 lightninng 于 2015-4-12 23:14 编辑

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

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

这段程序的输入为

>>> 
fun_1的输入为: 王司徒
fun_2的输入为: 丞相
>>>

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

d5zhao · 发表于 2015-4-13 09:04:12

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

我是时差党。嘿嘿

conn · 发表于 2015-4-13 09:29:48

:funk:

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

:sweat:

lightninng · 发表于 2015-4-13 23:01:04

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

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

lightninng · 发表于 2015-4-13 23:04:56

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

你肿么了亲~

lightninng · 发表于 2015-4-13 23:14:37

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

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

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

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

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

账号		自动登录	找回密码
密码			立即注册

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