python的基础学习 0

python的基础学习 0

编译和解释的区别是什么？

编译型：一次性将所有程序编译成二进制文件。 缺点：开发效率低，不能跨平台。 优点：运行速度快。 ：C，C++等等。

解释型：当程序执行时，一行一行的解释。 优点：开发效率高，可以跨平台。 缺点：运行速度慢。 :python, php,等等。

ASCLL表

字符串格式化输出

name = "wk"
print "i am %s " % name
  
#输出: i am wk
print str + "TEST" # 输出连接的字符串

查找：s.find

分割：s.split

大小写转换：s.upper s.lower

截取: s[3:-1]

追加：s+t

替换：s.replace(",", "#")

连接：",".join(s)//就是

翻转：s[::-1]

列表

append：添加 a.append('你好')

insert：在哪个后面添加什么 a.insert(0, '你好')

remove：删除a.remove('a')

 

---

 

【数据结构】

数组

1. 连续：顺序存储。

2. 定长：一旦定义后，长度不可变。

3. 根据下标可直接访问到这个下标的元素。

4. 不适合做插入删除等操作。

链表

1. 可以不连续。

2. 不定长

3. 无法根据下标去直接访问，必须从头一个一个往后面找

4. 适合做插入删除等操作。

队列

1. 先进先出

2. 只能从队列末尾插入数据

3. 只能从队列头部取出数据

栈

1. 先进后出

2. 只能从尾部插入数据

3. 只能从尾部取数据。

堆

1. 堆是一个二叉树

2. 叶子节点只存在最下面两层。

3. 从根节点到倒数第二层，是一个完全二叉树。

4. 一个节点不可能只有右孩子。

5. 一个节点的左孩子和右孩子都比这个节点大（或者小） 举个例子——大顶堆：

 

树

遍历

前序遍历（根左右）

还是以上图为例，前序遍历顺序是： [1, 2, 5, 6, 3, 7, 8, 9]

中序遍历（左根右）

还是以上图为例，中序遍历顺序是： [5, 2, 6, 1, 8, 7, 9, 3]

后续遍历（左右根）

还是以上图为例，后序遍历顺序是： [5, 6, 2, 8, 9, 7 ,3, 1]

插入排序

def insert_sort(origin_list):
    sorted_list = []
    for i in range(0, len(origin_list)):
        #print sorted_list
        if len(sorted_list) == 0:
            sorted_list.append(origin_list[i])
            continue
        for j in range(len(sorted_list) - 1, -1, -1):
            if sorted_list[j] <= origin_list[i]:
                sorted_list.insert(j + 1, origin_list[i])
                break
            if j == 0:
                sorted_list.insert(0, origin_list[i])
    origin_list[:] = sorted_list[:]
origin_list = [5, 3, 1, 7, 9, 8]
insert_sort(origin_list)
print origin_list

 

冒泡排序

def bubble_sort(origin_list):
    for i in range(len(origin_list), 0, -1):
        #print origin_list
        for j in range(0, i - 1):
            if origin_list[j] > origin_list[j + 1]:
                origin_list[j], origin_list[j + 1] = origin_list[j + 1], origin_list[j]
origin_list = [5, 3, 1, 7, 9, 8]
bubble_sort(origin_list)
print origin_list
​

 

快速排序

def quick_sort(origin_list, start, end):
    if start >= end:
        return
    left = start
    right = end
    flag_index = left
    while left < right:
        while right > left:
            if origin_list[right] < origin_list[flag_index]:
                origin_list[right], origin_list[flag_index] = origin_list[flag_index], origin_list[right]
                flag_index = right
                break
            right -= 1
        while left < right:
            if origin_list[left] > origin_list[flag_index]:
                origin_list[left], origin_list[flag_index] = origin_list[flag_index], origin_list[left]
                flag_index = left
                break
            left += 1
    quick_sort(origin_list, start, flag_index)
    quick_sort(origin_list, flag_index + 1, end)
origin_list = [5, 3, 1, 3, 7, 9, 8]
quick_sort(origin_list, 0, len(origin_list) - 1)
print origin_list

 

归并排序

 

def merge_sort(origin_list, start, end):
    if end <= start:
        return
    mid = (start + end) / 2
    merge_sort(origin_list, start, mid)
    merge_sort(origin_list, mid + 1, end)
    left_head = start
    right_head = mid + 1
    temp_list = []
    while left_head <= mid and right_head <= end:
        if origin_list[left_head] < origin_list[right_head]:
            temp_list.append(origin_list[left_head])
            left_head += 1
        if origin_list[left_head] >= origin_list[right_head]:
            temp_list.append(origin_list[right_head])
            right_head += 1
    if left_head <= mid:
        temp_list += origin_list[left_head:mid + 1]
    if right_head <= end:
        temp_list += origin_list[right_head:end + 1]
    for i in range(0, len(temp_list)):
        origin_list[i + start] = temp_list[i]
origin_list = [5, 3, 1, 3, 7, 9, 8]
merge_sort(origin_list, 0, len(origin_list) - 1)
print origin_list