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]