const与引用

别名。一初始化，就必须指向某个对象，不能指向引用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

int ival = 1024;
int &refVal = ival;
refVal = 1;
cout << "ival = " << ival << ", refVal = " << refVal << endl;

const int ci = 1024;
const int &r1 = ci;
//    r1 = 42; 不能修改

const int r2 = ival;
//    r2 = 2048; 不能通过r2修改ival


int i = 1024;
int *p = &i;
int *&refVal2 = p; // refVal2是一个引用，它引用的对象是一个指针，指向int类型。
cout << *refVal2 << endl;

const与指针

指向常量的指针（pointer to const）

不能用于修改其所指对象的值，常量对象的指针，只能使用指向常量的指针。

1
2
3
4
5
6
7
8
9
10
11

const double pi = 3.14;
//double *ptr = π 需要指向一个double常量
const double *cptr = π
//*cptr = 42; 不能通过此指针修改值
double dval = 3.14;
cptr = &dval;
//*cptr = 3.15; 不能通过此指针修改值
cout << *cptr << endl;

...
3.14

const指针

常量指针必须初始化，且初始化完成后，其值不能再改变，也就是说只能一直指向某一个地址。可以通过此指针改变所指向对象的值。

1
2
3
4
5
6
7
8

 int errNumb = 0;
 int *const curErr = &errNumb; // 只能指向errNumb
 *curErr = 1; // 可修改所指向的对象
 const double pi = 3.14159;

 const double pi2 = 3.14159;
 const double *const pip = π
//pip = &pi2; //❌pip的值不能修改

从右往左法则

以const double *const pip = &pi为例，离pip最近的是const，说明pip本身的值不能改变，在往左，pip的类型是一个指针，说明pip是一个常量指针；在往左，说明pip是一个常量指针，它指向的对象是double类型；再往左，说明pip是一个常量指针，它指向的对象是一个double型常量的。

def的用途

用def定义的变量时无类型的变量，这里所说的无类型的变量，并不表示该变量就不属于某一个类型了，def修饰变量正是Groovy为动态语言的标记，大概def修饰变量就相当于Java中Object来修饰变量吧。如果通过使用def关键字使用可选类型，那么整数的类型将是可变的：它取决于这个类型实际包含的值。

1
2
3
4
5

assert a instanceof Integer
//assert a instanceof Long//错误
 
def b = 2147483648
assert b instanceof Long

关于函数的定义

如果所定义的函数没有参数，那么必须在调用的时候加上括号。

要有返回值的类型声明，如def、void、String等。

可以使用return返回值，若不写，则默认返回最后一行的值，没有则为null。

闭包是什么?

A closure in Groovy is an open, anonymous, block of code that can take arguments, return a value and be assigned to a variable. A closure may reference variables declared in its surrounding scope. In opposition to the formal definition of a closure, Closure in the Groovy language can also contain free variables which are defined outside of its surrounding scope.Apache Groovy Doc

语法与用法

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

{ println 'hi' }

{ name -> println name }

{ String x, int y ->                                
    println "hey ${x} the value is ${y}"
}

{ reader ->                                         
    def line = reader.readLine()
    line.trim()
}
// as an object
def listener = { e -> println "Clicked on $e.source" }      
assert listener instanceof Closure

Closure callback = { println 'Done!' } 

Closure<Boolean> isTextFile = {
    File it -> it.name.endsWith('.txt')                     
}
//闭包是有返回值的，默认最后一行语句就是该闭包的返回值，如果最后一行语句没有不输入任何类型，闭包将返回null。
// 调用闭包
def code = { 123 }
assert code() == 123
assert code.call() == 123

访问外部变量

1
2
3
4
5

def str='hello world'
def closure={
    println str
}
closure()

语法糖

• .闭包可作为一个参数传给另一个闭包，也可在闭包中返回一个闭包。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

def timesThree = {
    num -> num * 3
}
def runTwice = {
    num, func -> func(func(num))
}
println runTwice(10,timesThree)

def times = {
    x -> {
        y -> x * y
    }
}

println times(3)(4)

• 闭包的一些快捷写法.
  • 当闭包作为闭包或方法的最后一个参数，可以将闭包从参数圆括号中提取出来接在最后。
  • 如果闭包中不包含闭包，则闭包或方法参数所在的圆括号也可以省略。
  • 对于有多个闭包参数的，只要是在参数声明最后的，均可以按上述方式省略。

闭包的Delegation代理

• this 指闭包所在的最近的类 .class
• owner 指定义闭包的宿主，不仅仅是类，还可能是一个闭包
• delegate 代理，默认使用的是owner
• delegate strategy 代理的代理策略

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

def p = new Person(name:'Jessica', age:42)
def t = new Thing(name:'Printer')
def cl = p.fetchAge
cl.delegate = p //设置代理
assert cl() == 42
cl.delegate = t
assert cl() == 42 //owner优先，fetchAge是一个闭包，它的owner是Person

cl.resolveStrategy = Closure.DELEGATE_ONLY //修改策略
cl.delegate = p
assert cl() == 42
cl.delegate = t
try {
    cl()
    assert false //呵呵，delegate上面没有该属性，报错
} catch (MissingPropertyException ex) {
    // "age" is not defined on the delegate //没有定义
}

至此基本的东西差不多解决了。

其实关于堆栈的问题在脑海中盘旋了挺久的了。从C语言开始，到数据结构，再到现在的Java，它一直在！现在就让我们从头开始吧。

明确概念

首先应该明确堆和栈是不同的东西，其次数据结构中的堆和栈与编程语言中的堆和栈不是同一个概念。

从数据结构说起

栈：即Stack，是一个LIFO队列。对它的操作有pop()，push()，peek()等。

堆：即Heap，是一棵完全二叉树（heap的某一种），它的特点是父节点的值大于（小于）两个子节点的值（分别称为大顶堆和小顶堆）。

具体内容可以参考后续关于数据结构的系列博客。

再到C语言

1
2
3
4
5
6
7
8
9
10
11
12

int a = 0; //全局初始化区 
char *p1; //全局未初始化区 
main() 
{ 
    int b; //栈 
    char s[] = "abc"; //栈 
    char *p2; //栈 
    char *p3 = "123456"; //123456\0在常量区，p3在栈上。 
    static int c =0； //全局（静态）初始化区 
    p1 = (char *)malloc(10); //堆 
    p2 = (char *)malloc(20);  //堆 
}

一个比较直观的感受就是使用malloc（）函数分配出来的空间在堆上，其它经过系统初始化的在栈上。堆上的不能自己回收，栈上的会随着函数结束后自动回收。

Java中的堆和栈

堆区：存放所有new出来的对象本身

栈区：存放基本类型的变量数据和对象的引用

静态域：存放静态成员（由static定义）

常量池：存放字符串常量和基本类型常量（public static final）

很久没用过Python了，熟悉一下用法准备ms。

输入和输出

1
2
3
4

>>> var=input('input:')
input:sjdf asdkjf 123 adsf ;dfa--..
>>> print(var)
sjdf asdkjf 123 adsf ;dfa--..

暂时理解input()读入一行数据，且可以加入提示信息。
读入一个整数：

1
2

s = input('birth: ')
birth = int(s)

基本注意事项

# 注释某行中其后的内容。
缩进代替C系列语言中的大括号。
大小写敏感。
字符串可用''或""包裹, \可用于转义。\n\t等
r’’表示’’内部的字符串默认不转义
'''表示多行输入

1
2
3
4
5
6
7
8
9
10
11

>>> print(r'\\\t\\')
\\\t\\
>>> print('''hi
... hi
... hi
... hello,py
... ''')
hi
hi
hi
hello,py

空值是一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。
用全部大写的变量名表示常量。
三种除法，//地板除，/整除，得到浮点数，%取余。
在计算机内存中，统一使用Unicode编码，当需要保存到硬盘或者需要传输的时候，就转换为UTF-8编码。
ord()函数获取字符的整数表示，chr()函数把编码转换为对应的字符。
格式化：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

>>> 'Hi, %s, you have $%d.' % ('Michael', 1000000)
'Hi, Michael, you have $1000000.'
```  
## 有意思的数据类型
#### list
```python
>>> fruits = ['apple', 'banana', 'orange']
>>> fruits
['apple', 'banana', 'orange']
>>> len(fruits)
3
>>> fruits[1]
'banana'
>>> fruits[6]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

• 倒数

  1 2 3 4 5 6 7 8

  >>> fruits[-1] 'orange' >>> fruits[-2] 'banana' >>> fruits[-6] Traceback (most recent call last): File "<stdin>", line 1, in <module> IndexError: list index out of range

  append()
  insert(1, ‘hi’)
  pop()
  list中的元素类型可以不同

tuple

不可更改的list，声明用()
当你定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来。
t = (1)定义的是自然数1，要定义成tuple需要加‘,’，规则。
t = (‘a’, ‘b’, [‘A’, ‘B’])其中的list是可变的。

dict

1
2
3
4
5
6

>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael']
95
>>> d['Adam'] = 67
>>> d['Adam']
67

• 判断是否存在dict中的两个方法
  一是通过in判断key是否存在；
  二是通过dict提供的get()方法，如果key不存在，可以返回None，或者自己指定的value。

  1 2 3 4 5

  >>> 'Thomas' in d False >>> d.get('Thomas') >>> d.get('Thomas', -1) -1

  删除用pop(‘Bob’)。

set

1
2
3

s = set([1, 2, 3])
s.add(4)
s.remove(4)

可以对集合进行&和|操作。

判断&循环

if

1
2
3
4
5
6
7
8
9
10
11
12
13
14

age = 3
if age >= 18:
    print('adult')
elif age >= 6:
    print('teenager')
else:
    print('kid')

s = input('birth: ')
birth = int(s)
if birth < 2000:
    print('00前')
else:
    print('00后')

for…in

可打印list、tuple中的数据。

1
2
3
4
5
6
7
8

names = ['Michael', 'Bob', 'Tracy']
for name in names:
    print(name)

sum = 0
for x in range(101):
    sum = sum + x
print(sum)

while

1
2
3
4
5
6

sum = 0
n = 99
while n > 0:
    sum = sum + n
    n = n - 2
print(sum)

break&continue

同C系列语言

函数

内置函数

• abs()
• int()
• max()
• hex()
• isinstance()
  函数名其实就是指向一个函数对象的引用，完全可以把函数名赋给一个变量，相当于给这个函数起了一个“别名”：

  1 2 3

  >>> a = abs # 变量a指向abs函数 >>> a(-1) # 所以也可以通过a调用abs函数 1

自定义函数

1
2
3
4
5

def my_abs(x):
    if x >= 0:
        return x
    else:
        return -x

• pass
  什么都不做,作为占位符
• 返回多个值
  在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值，所以，Python的函数返回多值其实就是返回一个tuple

函数参数

• 默认参数

  1 2 3 4 5 6

  def power(x, n=2): s = 1 while n > 0: n = n - 1 s = s * x return s

• 可变参数

  1 2 3 4 5 6 7 8

  def calc(*numbers): sum = 0 for n in numbers: sum = sum + n * n return sum >>> nums = [1, 2, 3] >>> calc(*nums) 14

  *nums表示把nums这个list的所有元素作为可变参数传进去。

• 关键字参数

  1 2 3 4 5 6 7 8 9 10 11 12 13 14

  def person(name, age, **kw): print('name:', name, 'age:', age, 'other:', kw) >>> person('Michael', 30) name: Michael age: 30 other: {} >>> person('Bob', 35, city='Beijing') name: Bob age: 35 other: {'city': 'Beijing'} >>> person('Adam', 45, gender='M', job='Engineer') name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'} >>> extra = {'city': 'Beijing', 'job': 'Engineer'} >>> person('Jack', 24, city=extra['city'], job=extra['job']) name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'} >>> extra = {'city': 'Beijing', 'job': 'Engineer'} >>> person('Jack', 24, **extra) name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

  **extra表示把extra这个dict的所有key-value用关键字参数传入到函数的**kw参数，kw将获得一个dict，注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra

• 命名关键字参数

  • 命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数。
  • 如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了。
  • 命名关键字参数必须传入参数名，这和位置参数不同。如果没有传入参数名，调用将报错

    1 2 3 4 5 6 7 8 9 10

    def person(name, age, *, city, job): print(name, age, city, job) >>> person('Jack', 24, city='Beijing', job='Engineer') Jack 24 Beijing Engineer def person(name, age, *args, city, job): print(name, age, args, city, job) def person(name, age, *, city='Beijing', job): print(name, age, city, job) >>> person('Jack', 24, job='Engineer') Jack 24 Beijing Engineer

    限定了kw中的关键字只能为city,job

• 参数组合
  参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

• 支持递归

高级特性

切片

1
2
3
4
5
6
7
8

L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']
L[0:3]
L[:3]
L[-2:]
L[-2:-1]
L[:10:2]
L[::5]
L[:]

迭代

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

>>> d = {'a': 1, 'b': 2, 'c': 3}
>>> for key in d:
...     print(key)
...
a
b
c
>>> for k, v in d.items():
...     print(k,v)
...
a 1
b 2
c 3
>>> for value in d.values():
...     print(value)
...
1
2
3
>>> for i, value in enumerate(['A', 'B', 'C']):
...     print(i, value)
...
0 A
1 B
2 C

列表生成式

1
2
3
4
5
6
7
8
9
10
11
12
13

>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>> [m + n for m in 'ABC' for n in 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']
>>> import os # 导入os模块，模块的概念后面讲到
>>> [d for d in os.listdir('.')] # os.listdir可以列出文件和目录
['.emacs.d', '.ssh', '.Trash', 'Adlm', 'Applications', 'Desktop', 'Documents', 'Downloads', 'Library', 'Movies', 'Music', 'Pictures', 'Public', 'VirtualBox VMs', 'Workspace', 'XCode']
>>> d = {'x': 'A', 'y': 'B', 'z': 'C' }
>>> [k + '=' + v for k, v in d.items()]
['y=B', 'x=A', 'z=C']
>>> L = ['Hello', 'World', 'IBM', 'Apple']
>>> [s.lower() for s in L]
['hello', 'world', 'ibm', 'apple']

生成器

1
2
3
4
5
6
7

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return 'done'

函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。

小结

生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。

把list、dict、str等Iterable变成Iterator可以使用iter()函数：

凡是可作用于for循环的对象都是Iterable类型；

凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；

集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。

Python的for循环本质上就是通过不断调用next()函数实现的，例如：

1
2
3
4
5
6
7
8
9
10
11
12

for x in [1, 2, 3, 4, 5]:
    pass
# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break

函数式编程

高阶函数

• 传入函数

  1 2	def add(x, y, f): return f(x) + f(y)

map/reduce

• map

  1 2 3 4 5 6

  >>> def f(x): ... return x * x ... >>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9]) >>> list(r) [1, 4, 9, 16, 25, 36, 49, 64, 81]

• reduce
  reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
• 两者综合

  1 2 3 4 5 6 7 8

  from functools import reduce DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9} def str2int(s): def fn(x, y): return x * 10 + y def char2num(s): return DIGITS[s] return reduce(fn, map(char2num, s))

• filter

  1 2 3 4 5 6 7 8

  def is_odd(n): return n % 2 == 1 list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15])) # 结果: [1, 5, 9, 15] def not_empty(s): return s and s.strip() list(filter(not_empty, ['A', '', 'B', None, 'C', ' '])) # 结果: ['A', 'B', 'C']

• sorted

  1 2 3 4 5 6

  >>> sorted([36, 5, -12, 9, -21], key=abs) [5, 9, -12, -21, 36] >>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower) ['about', 'bob', 'Credit', 'Zoo'] >>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True) ['Zoo', 'Credit', 'bob', 'about']