Python递归、反射、2分查找、冒泡排序

一、冒泡排序:比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。针对所有的元素重复以上的步骤，除了最后一个。持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
冒泡排序的时间复杂度为O（n^2）；属于稳定排序算法
冒泡排序原理：有一个无序数组（A，下标为i,元素个数为n），要对无需数组进行排序。第一轮比较：第一步开始进行相邻两个元素的对比，若第1个位于第2位，交换他们的位置；第二步，用刚才比较大的那个数字和第3位数比较，谁大谁就在第3位。。。以此类推，直至最大的数放在最后一位。第二轮比较：重复第一轮的方法，直至第n-1轮（即len(A[i])-1）轮比较，此时我们便得到了一个有序的数组。
代码示例：
冒泡排序：
data = [1, 3, 5, 10, 4, 7]
times = 0
"冒泡排序"
for i in range(len(data)):
for j in range(len(data) - i - 1):
if data[j] > data[j + 1]:
tmp = data[j + 1]
data[j + 1] = data[j]
data[j] = tmp
times += 1
print("冒泡排序")
print(data)
print("times:%d" % times)
插入排序：
def insertion_sort(sort_list):
iter_len = len(sort_list)
if iter_len < 2:
return sort_list
for i in range(1,iter_len):
key = sort_list[i]
j = i - 1
while j >=0 and sort_list[j] > key:
sort_list[j+1] = sort_list[j]
j -= 1
sort_list[j+1] = key
print(sort_list)
insertion_sort([23,321,3213,123,312,21312,])
选择排序：
def selection_sort(sort_list):
iter_len = len(sort_list)
if iter_len < 2:
return sort_list
for i in range(iter_len-1):
smallest = sort_list[i]
localtion = i
for j in range(i,iter_len):
if sort_list[j] < smallest:
smallest = sort_list[j]
localtion = j
if i != localtion:
sort_list[i],sort_list[localtion] = sort_list[localtion],sort_list[i]
print(sort_list)

selection_sort([2312,3123,132,312,13,31,31,])

二. 2分查找:二分查找要求对象必须有序
连续将满足条件的值等分，直到找到正确答案，这就是二分法。
这个算法的本身就是递归的定义，也可以用递归来实现
def search_data(data,data_find):
# 中间值的索引号的定义：数组长度/2
mid = int(len(data)/2)
#print(mid)
# 判断从1开始的数字数组内查找
if data[mid] >= 1:
# 如果我们要找的值（data_find）比中间值（data[mid]）小
if data[mid] > data_find:
print("你要找的数字比中间值[%s]小..." % data[mid])
# 在中间值（data[mid]）的左侧继续查找，在此函数中继续循环
search_data(data[:mid],data_find) # 如果我们要找的值（data_find）比中间值（data[mid]
elif data[mid] < data_find:
print("你要找的数字比中间值[%s]大..." % data[mid])
# 在中间值（data[mid]）的右侧继续查找，在此函数中继续循环
search_data(data[mid:],data_find)
else:
# 如果我们要找的值（data_find）既不比中间值（data[mid]）大，也不比中间值（data[mid]）小，则就是
print("这就是你要找的[%s]！" % data[mid])
else:
print("不好意思，没有找到你要的值...")
if __name__ == '__main__':
# 创建一个1到6000万的连续数字数组
data = list(range(60000000))
# 调用函数找到95938的值
search_data(data,95938)

三.Python 递归:完整的递归：有函数调用本身的行为，且有正确的返回条件
求阶乘:
#非递归版本
def factorial(x):
result = 1
for i in range(1, x+1):
result *= i
print(result)

def factorial(x):
result = x
for i in range(1, x):
result *= i
print(result)
#递归版本
def factorial(x):
if x == 1:
return 1
return x * factorial(x - 1)
四.Python反射:Python里面反射指的是可以通过字符串在对象里面（比如一个模块）去操作（查找，删除，判断）一个成员（比如这个模块里面的函数)
动态导入模块：
imp = input(“请输入你想导入的模块名:”)
CC = __import__(imp) 這种方式就是通过输入字符串导入你所想导入的模块
CC.f1() # 执行模块中的f1方法
反射相关的函数
getattr(object, name[, default])
cat com.py
#!/usr/bin/env python3
Url = "www.baidu.com"
def f1():
return "F1"
def f2():
return "F2"
cat test.py
#!/usr/bin/env python3
import com
target_func = getattr(commons, "f1")
#通过设置默认值可以避免获取不到方法时报错
#target_func = getattr(commons, "f1f1f1", None)
print(target_func)
#通过getattr获取模块中的全局变量
getattr(commons, "Url", None)