发表于 | 阅读次数:
字数统计: 123 | 阅读时长 ≈ 1 
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
import numpy as np 


class NeuralNetwork(object):
    def __init__(self, x, y):
        self.input = x
        self.weight1 = np.random.rand(self.input.shape[1],4)
        self.weight2 = np.random.rand(4,1)
        self.y = y
        self.output = np.zeros(self.y.shape)

    def feedforward(self):
        self.layer1 = sigmoid(np.dot(self.input, self.weight1))
        self.layer2 = sigmoid(np.dot(self.layer1, self.weight2))

    def backprop(self):
        d_weight2 = np.dot(self.layer1.T, (2*(self.y - self.output)))
        d_weight1 = np.dot(self.input.T, 
                          (np.dot(2*(self.y - self.output)*sigmoid_derivative(self.output), self.weight2.T)*sigmoid_derivative(self.layer1)))
        self.weight1 += d_weight1
        self.weight2 += d_weight2

    def sigmoid_derivative(x):
        return x*(1-x)

    def sigmoid(z):
        return 1.0/(1.0+math.exp(-z))

发表于 | 分类于 | 阅读次数:
字数统计: 44 | 阅读时长 ≈ 1

1.去研究不懂的代码

2.精通代码调试

3.优化迭代速度

4.系统性的思考方式

5.重视能够节省时间的工具

发表于 | 阅读次数:
字数统计: 459 | 阅读时长 ≈ 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
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
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
    你需要实现一个转换器，将一个正整数在不同的进制(通用的/自定义的)之间转换。
    后面有一些预定义的进制及其字符集。
    
    示例：
    func("15", dec_chr, bin_chr)       -->  "1111"
    func("15", dec_chr, oct_chr)       -->  "17"
    func("1010", bin_chr, dec_chr)     -->  "10"
    func("1010", bin_chr, hex_chr)     -->  "a"
    func("0", dec_chr, alpha_chr)      --> "a"
    func("27", dec_chr, allow_chr)     --> "bb"
    func("hello", allow_chr, hex_chr)  --> "320048"
"""

import unittest


bin_chr      = '01'
oct_chr      = '01234567'
dec_chr      = '0123456789'
hex_chr      = '0123456789abcdef'
allow_chr    = 'abcdefghijklmnopqrstuvwxyz'
allup_chr    = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
alpha_chr    = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
alphanum_chr = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'


def func(input, source, target):
    """
    二进制 八进制 十进制 十六进制
    小写（26） 大写（26） 字母（52） 字母和数字（62）
    辗转相除
    """
    # your code
    #    oct()
    #    hex()
    #    bin()
    if len(target) != len(source):
        transfer = input2dec(input, source)
    #    print(transfer)
        get_re = dec2target(transfer, target)
        print(get_re)
    
    else:
        if target.startswith("A"):
            get_re = input.upper()
        if target.startswith("a"):
            get_re = input.lower()
    
    return get_re


def input2dec(input, source):
    get_power = len(source)
    get_sum = 0
    s = [i for i in input]
    s.reverse()
    for index, i in enumerate(s):
        num = source.find(i)
        get_value = num * (get_power**index)
        get_sum += get_value

    return get_sum


def dec2target(n, target):
    b=[]
    x = len(target)
    while True:
        s=n//x    #商
        y=n%x     #余数
        b=b+[y]
        if s==0:
            break
        n=s
    b.reverse()
    s = ''
    a = [i for i in target]
    for i in b:
#        print(a[i], end='')
        s += a[i]
    return s


class DefaultTestCase(unittest.TestCase):
    
    def test_func(self):
        self.assertEqual(func("15", dec_chr, bin_chr), "1111")
        self.assertEqual(func("15", dec_chr, oct_chr), "17")
        self.assertEqual(func("1010", bin_chr, dec_chr), "10")
        self.assertEqual(func("1010", bin_chr, hex_chr), "a")
        self.assertEqual(func("0", dec_chr, alpha_chr), "a")
        self.assertEqual(func("27", dec_chr, allow_chr), "bb")
        self.assertEqual(func("hello", allow_chr, hex_chr), "320048")
        self.assertEqual(func("SAME", allup_chr, allup_chr), "SAME")
        self.assertEqual(func("WORLD", allup_chr, alphanum_chr), 'Hgrz')


if __name__ == '__main__':
    unittest.main()

发表于 | 阅读次数:
字数统计: 402 | 阅读时长 ≈ 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
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
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
给定一个仅包含整数，且按照大小顺序排好序的列表，列表内不存在重复的整数。
实现一个函数，将列表格式化为由`,`(逗号)分隔的字符串；如果相邻的整数(至少3个)是
连续的(值相差1为连续)，则将这几个相邻的整数格式化为由`-`(减号)分隔、左右分别为
起始和终止位整数的字符串。

示例：
func([-6,-3,-2,-1,0,1,3,4,5,7,8,9,10,11,14,15,17,18,19,20])  -->  '-6,-3-1,3-5,7-11,14,15,17-20'
func([-3,-2,-1,2,10,15,16,18,19,20])  -->  '-3--1,2,10,15,16,18-20'

特殊情况示例：
func([])  -->  ''
"""

import unittest
from itertools import groupby


def func(lst):
    # your code
    sum = sub_arr(lst)
    return ','.join(sum)


def sub_arr(lst):
    fun = lambda x: x[1] - x[0]
    sum = []
    for k, g in groupby(enumerate(lst), fun):
        s = [v for i, v in g]
#        print(s)
        if len(s) <= 1:
            sum.append(str(s[0]))
        elif len(s) == 2:
            sum.append(str(s[0]))
            sum.append(str(s[1]))
        else:
            target = [str(s[0]), str(s[-1])]
            n = '-'.join(target)
            sum.append(n)

    return sum


class DefaultTestCase(unittest.TestCase):

    def test_func(self):
        self.assertEqual(func([-6,-3,-2,-1,0,1,3,4,5,7,8,9,10,11,14,15,17,18,19,20]), '-6,-3-1,3-5,7-11,14,15,17-20')
        self.assertEqual(func([-3,-2,-1,2,10,15,16,18,19,20]), '-3--1,2,10,15,16,18-20')
        self.assertEqual(func([]), '')
        self.assertEqual(func([-6,-4,-2,0,2,4,6]), '-6,-4,-2,0,2,4,6')
        self.assertEqual(func([-6,-5,-3,-2,0,1,3,4,6]), '-6,-5,-3,-2,0,1,3,4,6')

if __name__ == '__main__':
    unittest.main()

发表于 | 阅读次数:
字数统计: 1.3k | 阅读时长 ≈ 4

Python的一个重要设计目标是让程序简单、清晰和优雅，坚持一套整齐划一的设计风格。Python程序具有易写、易读、易维护的特点，受到广大程序员欢迎。这些特质也是导致Python的使用越来越广泛的原因。21世纪以来，Python已发展为世界上最受欢迎的编程语言之一，其使用非常广泛。国际上一些公司做过（或一直在做）各种编程语言使用情况的调查，统计结果中Python都位于前四五名之内。它还被TIOBE编程语言排行榜（最有影响力的语言排行榜之一）评为2010年的年度语言。

Python被广泛认为是一种容易入门的语言。实际上，Python语言机制的跨度比较大，从完成最简单计算的表达式开始，一直延伸到许多当前最先进的编程概念，如面向对象的程序设计、数据抽象、迭代器、异步编程等。这些情况有利于学习者在一个语言里逐步深入地学习许多编程概念和技术。Python用正文缩进形式表现程序的结构，具有较好的可读性。

Python是一种比较高级的编程语言。除了最基本的编程机制外，它还提供了使用方便的数据功能，可以很方便地组织和管理大批数据。Python的所有编程机制和结构都围绕着对象的概念，程序里定义和操作的各种实体都是对象，不仅所有数据都是对象，函数和类等也是对象。它也能很好支持面向对象编程的理念和相关技术。

由于其基本设计的一些特点，Python代码和部件比较容易重用，已开发的程序容易修改和扩充，有利于软件的升级改造，可以减轻软件开发者的工作负担，提高程序开发的效率。此外，Python语言的设计也为开发大规模软件系统提供了很好支持。这些是许多IT公司乐于选择和使用Python作为其主要开发语言的重要原因。

在用Python开发程序时，可以采用交互式的执行方式，随时把代码发送给系统，立刻看到执行效果。这种方式使人更容易在编程中做各种试验，可以提高工作效率。一个Python程序文件（称为模块）的内容就是一系列简单或复杂的命令的序列。人们也把这样的语言称为脚本语言（script language），其程序就像一个工作脚本。

实际上，Python并不是简单的脚本语言，而是一个能支持大规模软件开发的通用编程语言，其实现具有较高的执行效率。PSF的Python系统带有一个很大的标准库，提供了很多在实际开发中非常有用的功能。此外，全世界的开发者已经为Python开发了面向各种应用领域的大量专用程序包，例如面向图形用户界面的设计和编程，面向网络应用、数值计算、数据统计和处理、图形图像处理、可视化等。针对所有重要应用领域，都可以找到相关的程序包，大大方便了人们用Python开发领域应用软件和综合性软件的工作。

Python语言和标准库的设计特别考虑了可扩充性，提供了丰富的接口和工具，使有经验的程序员比较容易使用其他语言，例如C、C++、CPython（一种专门用于扩充Python的C语言工具）等编写Python模块，然后能像Python标准库包一样方便地使用。这种情况也使一些大公司把Python用作高级的粘接语言（glue language），用一些较低级的语言实现一批性能要求较高的完成具体工作任务的模块，而后用Python实现整个系统的高层控制和调度。这样做，既能获得很好的开发效率，也有利于修改和扩充。

Python基金会提供最新版本的Python语言系统和基本开发环境，任何人都可以免费获取。该系统可以在各种主流计算机和软件平台上运行，包含了丰富的标准程序库和完整文档。此外，也存在另外一些商业的或非商业的Python系统可供选择。经过多年使用，全世界的Python开发者和使用者已经形成了一个活跃的专业社群，活跃在世界各地（包括中国），探讨、交流学习和使用Python的经验。互联网有很多与Python有关的信息，有许多Python讨论组。这些都促进了Python语言的学习和传播。