值此考试周之际，实在无心复习，苦于离散，微积分久之困惑，无从下手，接续寒假未竟之课程，作此blog。

考试终于考完了，现在开始看书，记下琐碎的知识！

Chapter1

1.2

1.1.1主要讲了环境的配置，这里就不写出来了

1.1.2主要讲了什么是表达式，如何调用表达式，变量名称，Pure-Function

表达式由操作符和操作数组成，简单的表达式就是计算表达式，最常见的函数调用表达式，函数作为操作符，参数作为操作数，我们还可以使用嵌套表达式，即一个表达式作为另一个操作符的操作数，嵌套表达式需要先计算内部的表达式，再计算外部的表达式。

名称用于指代计算的对象，如果一个变量有了一个名称，那么我们就说这个变量已经被赋值了，python里允许我们对一个名称赋值为一个函数，也允许一个表达式实现多次赋值的功能

1
2
3
4
f = max
f(1,2,3)#答案是3
x,y = 1,2#对x,y同时赋值
x,y = y,x#交换x,y的值

Pure-Function,纯函数，只接受输入值并返回输出值，Non-Pure-Function,除了输入值输出值外还会产生其他影响，比如print函数

1.3定义新的函数

格式如下

1
2
def <name>(<formal parameters>):
    return <return expression>

嵌套定义的函数是可以直接调用原函数的变量的

1.6 high-order function

对函数进行操作的函数就是高阶函数

一个函数A的参数是函数B,这样就可以在A的内部对B操作，当B发生变化时，我们内在的逻辑是不变的，这样就能让函数A实现更普适的功能，比如求和函数，我们对求和函数传入一个函数来表示求和的每一项的表达式，那么我们就能得到不同的求和公式。

下面这个求黄金分割率的函数

1
2
3
4
5
6
7
8
9
10
11
12
def Caculate(update,close,guess=1):
    while not close(guess):
        guess = update(guess)
    return guess
def goden_update(x):
    x=1/x+x
    return x
def goden_close(x):
    return approx_eq(x*x,x+1)#黄金分割率是x^2-x-1=0的根
def approx_eq(x,y,tolerance=1e-3):
    return abs(x-y)<tolerance
phi = Caculate(goden_updata,goden_close)

嵌套定义计算平方根

1
2
3
4
5
6
7
8
9
10
11
12
def average(x,y):
    return (x+y)/2
def improve(close,upadte,guess=1):
    while not close(guess):
        guess = updat(guess)
    return guess
def sqrt(a):
    def sqrt_close(x):
        return aprox_eq(x*x,a)
    def sqrt_update(x):
        return average(x,a/x)
    return improve(sqrt_close,sqrt_update)

Lambda表达式

1
2
Lambda		x		:		f(g(x))
#代表的是以x为参数的一个返回f(g(x))的匿名函数

Chapter2

2.1数的数据类型

整数（int）

浮点数（float）

复数（complex）

浮点数的储存有一定的精度差异，像下面这两个例子

1
2
3
4
>>>7/3*3
7.0
>>>1/3*7*3
6.999999999999999

浮点数的比较

1
2
>>> 1/3 == 0.333333333333333312345
True

由于这种情况的存在，我们比较两个数一般采用近似比较，即判断两个数的差值是否足够小

列表（list）

对列表中的元素赋值的方法：

  1. 多元素直接赋值
  2. 下标索引赋值
  3. getitem()方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
>>>pair = [10,20]
#1
>>>x,y = pair
>>>x
10
>>>y
20
#2
>>>x = pair[0]
>>>y = pair[1]
#3
>>>from operator import getitem
>>>getitem(pair,0)
10
>>>getitem(pair,1)
20

列表里的加法：将两个相加的列表拼接起来

列表里的乘法：将一个列表重复k次（乘k）

列表的迭代

1
2
for <name> in <expression>:
	<suite>

首先计算\是否是一个可迭代的值，然后对每一个元素在当前的栈帧中将\绑定这个值，执行for语句内的循环体

如果expression的元素也是列表，那么我们可以进行列表赋值

1
2
3
4
5
6
#expression = [[1,1],[2,3],[3,4]]
for x,y in expression:
    same_count = 0
    if x == y:
        same_count += 1
    return same_count

列表推导式

1
[<map expression> for <name> in <sequence expression> if <fliter expression>]

in关键字

判断一个元素是否在列表中，返回真假值

切片(slicing)

1
2
3
4
5
>>>digits = [1,8,2,8]
>>>digits[0:2]
[1,8]
>>>digits[1:]
[8,2,8]

看不懂的单词

全英文实在难顶，只能慢慢一句一句地适应，在这里记下阅读文档过程中不认识的单词

muster:号召，召集

irratate:刺激，激怒

vanquish:征服

pester:纠缠

airborne:空中

succumb:屈服

wrath:愤怒

paradigm：范例

graphical user interface:GUI

fleet:舰队

expend:花费（这么简单的都认不得了……）

wasp:黄蜂

encapsulate:封装

swarm:一群

constarint:约束

frail:脆弱

onslaught:猛攻

vault:保险库

laser:激光

语法知识

带默认值参量的函数定义方法：

1
def __init__(self, name, exit=None):

Ants

记录遇到的第一个问题：

thrower ant的nearest_bee方法实现中，定义上下界来让不同的子类具有自定义的攻击范围，自定义的方法有两种，一种是子类定义init函数，init函数是“magic method”,在我们不定义的时候编译器默认实现，我们定义之后可以根据需要，自定义输入的参数，根据参数来创建对象。另一种方式是直接在子类的类属性里添加即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def nearest_bee(self):
    P = self.place
    distance = 0
    while P.is_hive is False:
        if P.bees == []:
            P = P.entrance
            distance += 1
        else:
            if distance >= self.lower_bound and distance <= self.upper_bound:
                return random_bee(P.bees)
            else:
                P = P.entrance
                distance += 1
    return None

第二个问题：子类重写父类方法的过程出现死递归

在fireant的子类里重写父类的reduce_health方法，我们应在其中显示地调用超类的reduce_health,而不是直接在子类里调用该方法，如果直接调用，子类优先调用重写后的reduce_health方法，这样就会陷入死递归

1
2
3
4
5
class FireAnt(Ant):
    def reduce_health(self, amount):
        super().reduce_health(amount)  # 正确调用父类的 reduce_health 方法
        if self.health <= 0:
            self.place.remove_insect(self)

第三行也可以写作

1
Ant.reduce_health(self,amount)

要注意的是，对以列表表示的bee而言，每一次fireant的攻击我们都应该对一个备份进行，否则可能因为有bee被打败，导致遍历出错，同时每一轮在fireant死后的攻击前也要重新copy，否则在对原来列表中进行遍历，可能会对None操作，导致段错误

一个有意思的点：如何实现ContainerAnt

一个方格内只能放一只蚂蚁，那么如何实现ContainerAnt使得两个蚂蚁在一个方格上呢，为Container写两个属性，CanContain和ant_contained，前者判断能否储存蚂蚁，后者对多的蚂蚁进行储存。

许可协议

本文采用 署名-非商业性使用-相同方式共享 4.0 国际 许可协议，转载请注明出处。