Python基础学习-两小时上手Python

前言

闲来没事学学Python。 总共花了两个小时， 硬是从无到有学会了Python的基本语法。 顺便写了冒泡、快排和二分查找。 注释很详细， 可以凭借注释很快的学会Python

代码展示

如下代码介绍了Python的部分基础语法，比如 代码块格式、 运算法则、 if else for等基本运算、 三目运算、注释、引用、数组 等基本语法。

代码做了下面几件事

• HelloWorld
• 定义一个数组
• 遍历这个数组
• 调用系统方法
• 了解Python的弱类型
• 取全局变量
• 基本格式化方式
• ······

见代码片段

# _*_ coding: utf8 _*_

# python的hello world
# Java 程序猿 通过这篇实例学习pyhon。

# def 关键字用于修饰一个方法。 需要用 : 结尾
"""
在python 中方法限制无须花括号{}. 通过严格的缩进来确定一段代码块的归属
使用三个引号或者三个分号来注释多行注释
使用 import 关键字来引入额余代码
"""
import random
import math

def helloWorld() :
    # 使用 print 直接打印出一个字符串， 末尾加 逗号 则不会自动换行
    print "helloWorld",
    print "helloWorld"

    # 定义一个数组
    arr = ["Today", "is", "a", "good", "day"]
    # for 循环遍历这个数组， 类似Java的迭代
    for i in arr:
        print i,
    # 打印一串 横线. 乘号用于对引号里面的字符串累加
    print "-" * 100
    # 直接调用一个方法， 方法可以有返回值。 跟其它语言一致
    print bubble(arr)
    # python 是一个弱类型语言， 类型变换相对方便
    # 但是对于数组的长度等， 是不可以变更的
    arr = range(8)
    for i in xrange(0,len(arr)):
        # phthon 库提供了多种工具， 可以直接使用
        # 此处的目的是为了获得一个 0~10000的随机数并向上取整
        arr[i] = math.ceil(random.random() * 10000)
    print arr

    find = 1
    arr[0] = find
    search_index = binary_search(quick(arr, 0, len(arr) - 1), find)
    print search_index
    # 这是python里面的三元运算
    str =  ((search_index != -1) and ("Find it at %d" % (search_index)) or ("Didn`t find"))
    print str

    print "*insert_sort*" * 10
    arr = range(10)
    for i in xrange(0,len(arr)):
        arr[i] = math.ceil(random.random() * 10000)
    print arr
    print insert_sort(arr)
    print "*binary_insert_sort*" * 8
    arr = range(10)
    for i in xrange(0,len(arr)):
        arr[i] = math.ceil(random.random() * 10000)
    print arr
    print binary_insert_sort(arr)


# 冒泡排序
def bubble(arr):

    size = len(arr)
    for x in xrange(0, size):
        for y in range(0, size):
            if arr[x] > arr[y]:
                tp = arr[x]
                arr[x] = arr[y]
                arr[y] = tp
    return arr

# 快速排序
def quick(arr, start, end):
    if start >= end:
        return
    # index 结点不能参与排序， 否则就死循环了
    index = quick_partition(arr, start, end)
    # 子序列前半部分快排
    quick(arr, start, index - 1)
    # 子序列后半部分快排
    quick(arr, index + 1, end)
    return arr

# 快排的拆分代码 写在快排的附近
'''
顺便介绍一下快排：
通过选择一个基准点， 然后依次从队列后面end、从队列前面start、从队列后面end - 1······ 
搜索比当前基准点小的值， 如果较小， 便交换两个值的位置，直到start >= end。 这个时候的将基准点放置在end位置。
通过递归的方式分别对基准点的前半部分数组和后半部分数组排序，从而实现整个数组的有序化
'''
i = 1
def quick_partition(arr, start, end):
    key = arr[start]
    # 使用该关键字来取全局变量
    global i
    j = 1
    while start < end:
        # 此处即从后半部分寻找第一个比基准值大的数值，让它排在基准点的左边。
        # 注意end是一个游标，end右边的值不一定有序，但是一定比基准值大。
        while arr[end] >= key and end > start:
            end = end - 1   
        arr[start] = arr[end]
        # 此处即从前半部分寻找第一个比基准值小的数值，让它排在基准点的右边。
        # 注意start是一个游标，start左边的值不一定有序，但是一定比基准值小。
        while arr[start] <= key and end > start:
            start = start + 1
        arr[end] = arr[start]
        # python的print语法跟C语言类似
        print "第 %d 次循环， 内循环第 %d 次， 此时 start=%d: end=%d, key=%d, 数组内容为：%s" % (i, j, start, end, key, arr)
        j = j + 1
    # 经过多次上述循环， 直到start>=end的时候， 就可以确定基准点处于当前序列的位置了。
    arr[end] = key
    i = i + 1

    return end

# 二分查找
def binary_search(arr, search):
    # 二分查找基于一个有序队列。
    left = 0
    right = len(arr) - 1
    while left <= right:
        middle = (left + right) / 2
        print middle
        if arr[middle] > search:
            right = middle - 1
        elif arr[middle] < search:
            left = middle + 1
        else :
            return middle   

# 插入排序
def insert_sort(arr) :
    if len(arr) < 2:
        return arr
    ## 使得每次寻找的队列都是有序队列  
    for i in xrange(1, len(arr)):
        search = arr[i]
        pos = i
        j = i - 1
        while j >= 0:
            if arr[j + 1] < arr[j]:
                arr[j + 1] = arr[j]
                pos -= 1
            else:
                break
            # python 的 j-- 语法   
            arr[pos] = search
            j -= 1
        else:
            # python 的 for break else 语法
            print "Jump out!"   
    return arr      


# 二分插入排序
def binary_insert_sort(arr) :   
    if len(arr) < 2:
        return arr
    for i in xrange(1, len(arr)):
        search = arr[i]
        start = 0
        end = i - 1
        while start <= end:
            middle = (start + end) / 2
            if arr[middle] >= search:
                end = middle - 1
            else:
                start = middle + 1
        # python 从大到小的 for 循环暂时还没会。 通过这种方式实现类似功能        
        j = i - 1
        while j > end:
            arr[j + 1] = arr[j]
            j -= 1
        arr[end + 1] = search
    return arr  


if __name__ == '__main__':
    helloWorld()

---

输出结果不会恒定， 每次都不一样。 见输出：

helloWorld helloWorld
Today is a good day ----------------------------------------------------------------------------------------------------
['is', 'good', 'day', 'a', 'Today']
[7340.0, 8957.0, 9774.0, 1592.0, 7897.0, 9892.0, 8787.0, 2144.0]
第 1 次循环， 内循环第 1 次， 此时 start=0: end=0, key=1, 数组内容为：[1, 8957.0, 9774.0, 1592.0, 7897.0, 9892.0, 8787.0, 2144.0]
第 2 次循环， 内循环第 1 次， 此时 start=2: end=7, key=8957, 数组内容为：[1, 2144.0, 9774.0, 1592.0, 7897.0, 9892.0, 8787.0, 9774.0]
第 2 次循环， 内循环第 2 次， 此时 start=5: end=6, key=8957, 数组内容为：[1, 2144.0, 8787.0, 1592.0, 7897.0, 9892.0, 9892.0, 9774.0]
第 2 次循环， 内循环第 3 次， 此时 start=5: end=5, key=8957, 数组内容为：[1, 2144.0, 8787.0, 1592.0, 7897.0, 9892.0, 9892.0, 9774.0]
第 3 次循环， 内循环第 1 次， 此时 start=2: end=3, key=2144, 数组内容为：[1, 1592.0, 8787.0, 8787.0, 7897.0, 8957.0, 9892.0, 9774.0]
第 3 次循环， 内循环第 2 次， 此时 start=2: end=2, key=2144, 数组内容为：[1, 1592.0, 8787.0, 8787.0, 7897.0, 8957.0, 9892.0, 9774.0]
第 4 次循环， 内循环第 1 次， 此时 start=4: end=4, key=8787, 数组内容为：[1, 1592.0, 2144.0, 7897.0, 7897.0, 8957.0, 9892.0, 9774.0]
第 5 次循环， 内循环第 1 次， 此时 start=7: end=7, key=9892, 数组内容为：[1, 1592.0, 2144.0, 7897.0, 8787.0, 8957.0, 9774.0, 9774.0]
3
1
0
0
Find it at 0
*insert_sort**insert_sort**insert_sort**insert_sort**insert_sort**insert_sort**insert_sort**insert_sort**insert_sort**insert_sort*
[7347.0, 448.0, 5447.0, 3529.0, 8954.0, 4314.0, 6423.0, 2680.0, 3495.0, 8583.0]
Jump out!
[448.0, 2680.0, 3495.0, 3529.0, 4314.0, 5447.0, 6423.0, 7347.0, 8583.0, 8954.0]
*binary_insert_sort**binary_insert_sort**binary_insert_sort**binary_insert_sort**binary_insert_sort**binary_insert_sort**binary_insert_sort**binary_insert_sort*
[8702.0, 7143.0, 710.0, 2101.0, 549.0, 726.0, 1398.0, 6767.0, 7489.0, 5456.0]
[549.0, 710.0, 726.0, 1398.0, 2101.0, 5456.0, 6767.0, 7143.0, 7489.0, 8702.0]