花了一晚上时间，终于把Python的基本用法归纳好了！

一、内置函数

1. complex([real[,imag]])

返回一个复数，实部 + 虚部*1j，或者把字符串或者数字转成复数形式。

参数可以是复数表达式，也可以是字符串。当参数是字符串的时候，数字与操作符之间不能有空格。即comple(1 + 2j)是错误的。

print(complex(1, 2)) print(complex(1 + 2j)) print(complex(1+2j)) # 输出 1+2j print(complex(1)) # 输出 1+0j

满足：实部 + 虚部*1j 的数被称为复数。

a = 1 + 3j # 求实部 print(a.real) # 求虚部 print(a.imag) # 求共轭 print(a.conjugate())

2. chr(i) 与 ord(i)

chr(i) 是将当前整数 i 转成对应的 ascii 字符，可以是十进制，也可以是十六进制，其中0 <= i <= 0x10ffff (1114111)。其对应的逆操作为 ord(i)，i 为 ascii 字符。

下面的函数演示如何求一个可迭代对象的 ascil字符 或者其对应的数值。注意函数 ordplus ，参数 x 中的每一个元素必须是单个字符，如果是列表，形式如下：[‘P’ , ‘y’, ‘t’ , ‘h’, ‘o’ , ‘n’]。

def chrplus(x): chr_string = for elem in x: chr_string += chr(elem) return chr_string def ordplus(x): ord_list = [] for elem in x: ord_list.append(ord(elem)) return ord_list x = Python高效编程 temp = ordplus(x) print(temp) # 输出：[112, 121, 116, 104, 111, 110, # 39640, 25928, 32534,31243] init = chrplus(temp) print(init) # 输出：Python高效编程

3.enumerate(iterable, start=0)

返回 enumerate 对象。迭代对象必须是序列，迭代器，或者其他支持迭代的对象。enmerate() 函数返回的是迭代器，同样是可迭代对象。每次迭代的元素，都包含元素在序列里的序号(strat 默认值为 0) 和元素对应值。因此，我们可以用 for 循环获取返回值。

等价于：

def enumerate(sequence, start=0): n = start for elem in sequence: yield n, elem n += 1 for i, elem in enumerate([P, y, t, h, o, n]): print(i, elem)

4. abs(x)

返回数的绝对值。参数可以是整数或者浮点数。如果参数是复数，返回复数的模。Python 中虚数用数值加上字符 j 的形式表示。要注意 j 前面的数值不能省略，比如 1j。

下面是我写的简易版的 abs 函数：

进群：960410445 即可获取数十套PDF！

from math import sqrt def naive_abs(x): # isinstance 判断参数x是否为整数或浮点数 if isinstance(x, int) or isinstance(x, float): if x < 0: x = - x # 判断参数x是否为复数 elif isinstance(x, complex): # x.real 复数的实部 # x.imag 复数的虚部 real = x.real imag = x.imag # 求复数的模 x = sqrt(real ** 2 + imag ** 2) else : return 请输入 int float complex return x print(abs(3+4j)) print(naive_abs(3+4j)) # 输出 5.0 print(abs(-6)) print(naive_abs(-6)) # 输出 6

二、算法与数据结构

1. 二分查找

要想使用二分搜索，首先要确保迭代序列是有序的。对于无序序列，我们首先要进行排序操作。

每次循环缩小一半搜索范围，时间复杂度为 O(logn)。每次循环，比较选取的中间数与需要查找的数字，如果待查数小于中间数，就减少右界至中间数的前一个数；如果待查数大于中间数，就增加左界到中间数后一个数；如果待查数等于中间数，返回中间数的下标，该下标即为待查数在序列中的位置。当左界大于右界时，循环结束，说明序列中并没有待查数。

def binary_search(item, find): # 有序可迭代对象 left, right = 0, len(item) - 1 mid = left + (right - left) // 2 while left <= right: if item[mid] == find: return mid elif item[mid] > find: right = mid - 1 else: left = mid + 1 mid = left + (right - left) // 2 return None seq = [1, 4, 7, 9, 13, 17, 18, 21, 34, 45, 65] binary_search(seq, 13) # 输出：4

2. 快速排序

首先要打乱序列顺序 ，以防算法陷入最坏时间复杂度。快速排序使用“分而治之”的方法。对于一串序列，首先从中选取一个数，凡是小于这个数的值就被放在左边一摞，凡是大于这个数的值就被放在右边一摞。然后，继续对左右两摞进行快速排序。直到进行快速排序的序列长度小于 2 （即序列中只有一个值或者空值）。

# quicksort import random def quicksort(seq): if len(seq) < 2: return seq else: base = seq[0] left = [elem for elem in seq[1:] if elem < base] right = [elem for elem in seq[1:] if elem > base] return quicksort(left) + [base] + quicksort(right) seq = [9, 8, 7, 6, 5, 4, 3] random.shuffle(seq) # seq：[6, 4, 9, 3, 8, 5, 7] print(quicksort(seq)) # 输出：[3, 4, 5, 6, 7, 8, 9]

3. 冒泡排序

冒泡排序（顺序形式），从左向右，两两比较，如果左边元素大于右边，就交换两个元素的位置。其中，每一轮排序，序列中最大的元素浮动到最右面。也就是说，每一轮排序，至少确保有一个元素在正确的位置。这样接下来的循环，就不需要考虑已经排好序的元素了，每次内层循环次数都会减一。其中，如果有一轮循环之后，次序并没有交换，这时我们就可以停止循环，得到我们想要的有序序列了。

def bouble_sort(sequence): seq = sequence[:] length = len(seq) - 1 i = j = 0 flag = 1 while i < length: j = 0 while j < length - i: if seq[j] > seq[j + 1]: seq[j], seq[j + 1] = seq[j + 1], seq[j] flag = 0 j += 1 if flag: break i += 1 return seq

4. 选择排序

选择排序，每次选择当前序列的最小值，将其与当前序列的第一个元素交换位置，每迭代一次，当前序列长度减一。迭代结束，即可得到有序序列。

def find_minimal_index(seq): min_elem = seq[0] count = 0 min_elem_index = count for elem in seq[1:]: count += 1 if elem < min_elem: elem, min_elem = min_elem, elem min_elem_index = count return min_elem_index def select_sort(sequence): # 选择排序 seq = sequence[:] length = len(seq) for i in range(length): index = find_minimal_index(seq[i:]) seq[index + i], seq[i] = seq[i], seq[index + i] return seq

5. 去重序列重复元素

首先新建一个集合 set，对于序列中的元素，如果已经在集合中了，我们就不返回这个值。如果不在集合中，就向集合添加这个元素，并返回这个值。key 是函数名，通过修改 key，我们可以改变重复元素的判断依据。比如对于下面这个序列：a = [{a: 6, b: 4}, {a: 6, b: 3}, {a: 6, b: 4},{a: 8, b: 12}]list(dedupe(a, lambda x: x[a]))这里我们把 dedupe 设置为，基于关键字 ‘a’ 对应值去除重复元素，也就是说集合中添加的元素为关键字 ‘a’ 对应值。输出为：[{a: 6, b: 4}, {a: 8, b: 12}]list(dedupe(a, lambda x: (x[a],x[b])))这里，集合添加的是关键字’a’和’b’对应值的元组。

输出为： [{a: 6, b: 4}, {a: 6, b: 3}, {a: 8, b: 12}]

# Python高效编程 def dedupe(sequence, key): # 依序去除重复元素 seen = set() items = sequence[:] for item in items: if key: seq = key(item) if seq not in seen: seen.add(seq) yield item

6. Vector

这一节，我们来实现一个简单的 Vector 类。Vector 类有两个属性，为 x，y 坐标，即对应向量的横纵坐标。首先，实现重载 + 号的方法def __add__，及实现两个向量的加法。具体做法是：将加号两边的 Vector 对象的 x, y值相加，得到新的 x, y值并且返回一个新的向量对象。__sub__方法实现了 Vector 对象的减法，和加法差不多。让向量对象的对应属性相减，并返回新的向量对象。__ads__方法，使得可以对实例进行 ads操作(即取横纵坐标的模)。__mul__方法，使得实例可以通过乘法进行伸缩的操作。__repr__与__str__方法使得打印对象更加美观。

import math # Python高效编程 class Vector(object): def __init__(self, x, y): self.x = x self.y = y def __add__(self, other): x = self.x + other.x y = self.y + other.y return Vector(x, y) def __sub__(self, other): x = self.x - other.x y = self.y - other.y return Vector(x, y) def __abs__(self): return math.sqrt(self.x ** 2 + self.y ** 2) def __bool__(self): return bool(self.x or self.y) def __mul__(self, times): return Vector(self.x * times, self.y * times) def __repr__(self): return Vector({}, {}).format(self.x, self.y) __str__ = __repr__ def main(): v1 = Vector(3, 5) v2 = Vector(4, 5) v3 = v1 + v2 v4 = v3 * 2 v5 = v2 - v1 print(v3) print(v4) print(abs(v3)) print(v5) if __name__ == __main__: main() # 输出： # Vector(7, 10) # Vector(14, 20) # 12.206555615733702 # Vector(1, 0)

7. 具名元组

具名元组（namedtuple） 是 python 标准库 collections 中的工厂函数。它接受两个参数，第一个参数表示类的名称，第二个参数是类的字段名。后者可以是可迭代对象，也可以是空格隔开的字符串。然后，我们通过一串参数的形式将参数传递到构造函数中。这样，我们既可以通过字段名访问元素，也可以用索引访问元素。

from collections import namedtuple ToDo = namedtuple(ToDo, date content priority) t = ToDo(12, null, 1) print(t.date) print(t[1]) # 输出: # 12 # null

下面是具名元组的演示程序：我们创建了一个 ToDoList 类，并且支持 + 、索引、切片与显示等操作。并且通过格式化输出，美化打印结果。

from collections import namedtuple ToDo = namedtuple(ToDo, date content priority) class ToDoList: def __init__(self): self.item = [] def add(self, date, content, priority): self.item.append(ToDo(date, content, priority)) def _modify(self, item): self.item = item @property def _getitem(self): return self.item def __getitem__(self, pos): return self.item[pos] def __add__(self, other): item = self._getitem + other._getitem t = ToDoList() t._modify(item) return t def __repr__(self): items = self._getitem text = {:<5}{:^10}{:^10}.format(date, content, priority) fmt = {:<5}{:^10}{:^10} for item in items: text += \n text += fmt.format(item.date, item.content, item.priority) return text __str__ = __repr__ def main(): t1 = ToDoList() t1.add(12, play, 0) t1.add(8, seek, 6) t2 = ToDoList() t2.add(4, sleep, 2) t3 = t1 + t2 print(t3) if __name__ == __main__: main() # 输出 # date content priority #12 play 0 #8 seek 6 # 4 sleep 2

三、递归

1. 阶乘

迭代停止条件：n < 2

# 阶乘 # n > 0 def factor(n): return 1 if n < 2 else n * factor(n-1)

2. 序列和

迭代停止条件：序列为空

# 和 def naive_sum(seq): if not seq: return 0 else: return seq[0] + naive_sum(seq[1:])

3. 求序列长度

迭代停止条件：序列为空

# 计数 def naive_count(seq): if not seq: return 0 else: return 1 + naive_count(seq[1:])

4. 求序列最大值

迭代停止条件：序列为空

# 最大值 count = 1 def naive_max(seq): global count global max_num if count: max_num = seq[0] count = 0 if not seq: count = 1 return max_num else: if seq[0] > max_num: seq[0], max_num = max_num, seq[0] return naive_max(seq[1:])

以上便是本次的全部内容，大家可以亲自编程练练手。