甜橘子，专注成都网站制作网站设计与营销型网站建设与优化
QQ :532337155
电话：028-86922220
Python程序是由解释器来执行的。解释器启动后将出现一个命令提示，在此可以开始输入程序。在交互式shell中，可以输入任意合法的语句或语句序列，然后立即查看结果。例如：
创新互联专注于府谷网站建设服务及定制，我们拥有丰富的企业做网站经验。 热诚为您提供府谷营销型网站建设，府谷网站制作、府谷网页设计、府谷网站官网定制、微信平台小程序开发服务，打造府谷网络公司原创品牌,更为您提供府谷网站排名全网营销落地服务。
print("Hello World")以交互式方式使用Python时，特殊变量_用于保存最后一次运算结果。但要强调的是，此变量只有在交互式工作时才有定义。如果要创建可以重复运行的程序，可以将语句放到一个文件中：
#helloworld.py
print("Hello World")Python源文件是普通的文本文件，后缀通常是.py。#字符表示整行都是注释。
以下程序简要说明变量和表达式的用法：
principal = 1000 # 初始金额
rate = 0.05 # 利率
numyears = 5 # 年数
year = 1
while year <= numyears:
principal = principal * ( 1 + rate )
print(year, principal)
year += 1Python是一种动态类型的语言，在程序执行过程中，可将变更是名绑定到不同的值，而且这些值可以属于不同的类型。换行代表一条语句的结束。然而，也可以在同一行上使用分号来隔开多条语句，例如：
principal = 1000; rate = 0.05; numyears = 5;
While语句对随后的条件表达式进行测试。因为循环主体是由缩进表示的，Python不会指定所需缩进的量，只要在一个代码块中保持一致即可。
if与else语句可执行简单的测试，例如：
if a < b:
print("Yes")
else:
print("No")if和else子句的主体是用缩进表示的，else子句可选。要创造一条空子句，可以使用pass语句，例如：
if a < b:
pass # do nothing
else:
print("No")使用and、or和not关键字可以建立布尔类型的表达式：
if product == "game" and not (age < 4 or age > 8):
print("OK")Python没有专门的switch或case语句用于测试多个值，要处理多个分支，可以使用elif，例如：
if suffix == ".htm":
content = "text/html"
elif suffix == ".jpg":
content = "image/jpeg"
else:
raise RuntimeError("Unknown Content Type")要表示真值，可使用True和False。
以下程序可找开一个文件并逐行读取内容：
f = open("test.txt")
line = f.readline()
while line:
print(line, end='')
line = f.readline()
f.close()open()函数返回一个新的文件对象。readline()方法读取一行内容，包括结尾的换行符。如果程序在像这样的数据集上进行循环，那么通常就称为迭代。因为迭代是一种很常见的操作，所以Python为其提供了一条专用语句for，例如：
for line in open("test.txt"):
print(line, end='')要将输出送到一个文件中，可以指定一个文件，例如：
for line in open("test.txt"):
print(line, file=open("test2.txt", "w"))同样的技术也适用于标准的输出流和输入流。例如，想用交互方式读取用户输入，可以从文件sys.stdin中读取。如果要将数据输出到屏幕上，可以写入文件sys.stdout中，例如：
import sys
sys.stdout.write("Enter Your Name :")
sys.stdout.flush()
name = sys.stdin.readline()
要创建一个字符串字面量，将字符串放在单引号、双引号、三引号中即可，例如：
a = "Hello World"
b = 'Hello World'
c = """Hello World"""字符串前后使用的引号必须是对应匹配的。当字符串字面量的内容需要放在多个文件行上时，三此号字符就很有用，例如：
print('''
Hello World
Content
''')字符串存储在一个以0开始、使用整数索引的字符序列中，可以提取其中一个字符，例如：
a = "Hello World"
b = a[4]要提取子字符串，可以使用切片运算符s[i:j]，提取索引k的范围是i <= k < j，如果省略i，则假定使用字符串的起始位置，如果省略j，则假定使用字符串的结尾位置，例如：
c = a[:5]
d = a[6:]
e = a[3:8]可以使用"+"运算符连接两个字符串，例如：
g = a + "This is a test"
列表是任意对象的序列，把值放入方括号中就可以创建列表，例如：
names = ["Dave", "Mark", "Ann"]列表使用从0开始的整数索引，使用索引运算符可以访问并修改列表中的项，例如：
a = names[2]
names[0] = "Jeff"要将新项追加到列表末尾，可使用append()方法，要将一项插入到列表中，可使用insert()方法，例如：
names.append("Paula")
names.insert(2, "Thomas")使用切片运算符可以对子列表重新赋值，例如：
names[0:2] = ["Dave", "Mark", "Jeff"]使用"+"运算符可以连接列表，例如：
a = [1, 2, 3] + [4, 5]创建空列表有两种方式：
names = []
names = list()列表可以包含任意种类的Python对象，包括其他列表，嵌套列表中包含的项需要使用多次索引才能访问，例如：
a = [1, "Dave", 3.14, ["Mark", 7, 9]]
print(a[3][1])
要创建简单的数据结构，可以使用元组，在圆括号中放入一组值即可创建元组，例如：
stock = ("GOOG", 100, 490.10)
address = ("www.python.org", 80)
person = (first_name, last_name, phone)即使没有圆括号，Python通常也能识别出元组。可以定义0个和1个元素的元组，例如：
a = ()
b = (item, ) # 注意逗号
c = item, # 注意逗号和列表一样，也可以使用数字索引来提取元组中的值，更常见的做法是将元组解包为一组变量，例如：
name, shares, price = stock
host, port = address
first_name, last_name, phone = person尽管元组支持的大部分操作与旬表的相同，但创建元组后不能修改它的内容。程序元往往忽略了元组，而只用列表，但如果程序要创建大量的小列表，就会造成内存浪费。元组是不可变的，所以它们的表示更为紧凑，不会占据额外的内存空间。
集合用于包含一组无序的对象。要创建集合，可使用set()函数并如下所示提供一系列的项：
a = set([3, 5, 7, 9])
b = set("Hello")集合是无序的，也无法通过数字进行索引。此外，集合中的元素不能重复，如果检查前面代码b集合的值，结果会是(['H', 'e', 'l', 'o'])。集合支持一系列标准操作，包括并集、交集、差集和对称差集，例如：
c = a | b # a和b的并集
d = a & b # a和b的交集
c = t - s # 差集（项在a中，但不在s中）
d = t ^ s # 对称差集（项在a或b中，但不同时出现）使用add()和update()可以在集合中添加新项，例如：
a.add('x') # 添加一项
b.update([10, 20, 30]) # 添加多项
字典就是一个关联数组或散列表，其中包含通过关键字索引的对象。在大括号中放入值即可创建字典，例如：
stock = {
"name" : "GOOG",
"shares" : 100,
"price" : 490.10
}要访问字典成员，可使用关键字索引运算符，例如：
name = stock["name"]插入或修改对象，则例如：
stock["shares"] = 75
stock["date"] = "June 7, 2007"在定义一个可包含多个命名字段的对象时，字典是一种很有用的方式。然而，字典也可用作快速查找无序数据的一个容器。创建一个空字典的方式如下：
prices = {}
prices = dict()使用in运算符可以测试某个内容项是不是字典成员，例如：
if "SCOX" in prices:
p = prices["SCOX"]
else:
p = 0.0还可以把这样的步骤写成更简洁的形式，例如：
p = prices.get("SCOX", 0.0)要获得字典关键字的列表，直接转换即可，例如：
syms = list(prices) # 注意是关键字的列表，不是值使用del语句可以删除字典的元素：
del prices["MSFT"]
最常用的循环结构是用于迭代多个项的for语句。例如：
for n in [1, 2, 3, 4, 5]:
print(n)range(i, j[, 步进值])函数创建i到j-1的整数，如果起始值被省略，则认为是0，例如：
a = range(5)
b = range(1, 9)
c = range(8, 1, -1)for语句还可用于迭代多种对象，包括字符串、列表、字典和文件，例如：
a = "Hello World"
for c in a:
print(c)
b = ["Dave", "Mark", "Ann"]
for name in b:
print(name)
c= {
"GOOG": 490.10,
"IBM": 91.50,
"AAPL": 123.15
}
for key in c:
print(key, c[key])
使用def语句可以创建函数，例如：
def remainder(a, b):
q = a * b
return q要调用函数，只要使用函数名加上用圆括号括起来的参数即可，例如：
result = remainder(10, 20.5)要给函数参数提供默认值，可使用如下方式：
def connect(hostname, port, timeout=300)还可以使用关键字参数调用函数，但需要你知道函数定义中的参数名称，例如：
connect(port=80, hostname="www.test.com")在函数中创建变量或给变量赋值时，变量的作用域是局部的，要在函数内修改某个全局变量的值，可以使用global语句，例如：
count = 0
def foo():
global count
count += 1
如果使用yield语句，可以让函数生成一个结果序列，而不仅仅是一个值，例如：
def countdown(n):
print("Counting down!")
while n > 0:
yield n
n -= 1任何使用yield的函数都称为生成器，调用生成器函数将创建一个对象，该对象通过连续调用__next__()生成结果序列，例如：
c = countdown(5)
c.__next__() # Counting down! 5
c.__next__() # 4
c.__next__() # 3__next__()调用使生成器函数一直运行到下一条yield语句为止。此时__next__()将返回值传递给yield，而且函数将暂时中止。再次调用__next__()时，函数将继续执行yield之后的语句。通常不会像上面这样调用__next__()，而是会使用一个for循环，例如：
for i in countdown(5):
print(i)
通常函数运行时要使用一组输入参数，但是，也可以把函数编写为一个任务，从而能处理发送给它的一系列输入，这类函数称为协程，例如：
def print_matches(matchtext):
print("Looking for", matchtext)
while True:
line = (yield)
if matchtext in line:
print(line)
matcher = print_matches("python")
matcher.__next__()
matcher.send("Hello World")
matcher.send("python is cool")
matcher.close()使用send()为协程发送某个值之前，协程会暂时中止。这个过程将会继续，直到协程函数返回或者调用它的close()方法为止。
程序中使用的所有值都是对象。对象由内部数据和各种方法组成，这些方法会执行与这些数据相关的各种操作。dir()函数可列出对象上的可用方法，是进行交互式试验的有用工具，例如：
items = [10, 20]
print(dir(items))在面向对象的编程中，class语句用于定义新的对象类型。例如，下面的类定义了带有push()、pop()和length()操作的简单栈：
class Stack(object):
def __init__(self):
self.stack = []
def push(self, object):
self.stack.append(object)
def pop(self):
return self.stack.pop()
def length(self):
return len(self.stack)在类定义第一行中，圆括号是Python指定继承的方式，在这个例子里，Stack继承自object,object也是所有Python类型的根类型。类定义中使用def语句定义了方法，每个方未能中的第一个参数始终指向对象本身，根据约定，该参数名称为self。涉及对象属性都必须显示引用self。要使用类，可以使用如下方式：
s = Stack()
s.push("Dave")
x = s.pop()
del s也可以定义不同种类的方法，比如静态方法，例如：
class EventHanlder(object)
@staticmethod
def dispatcherThread():
while(1):
# 方法体
EventHanlder.dispatcherTread()
如果程序中出现错误，就会引发异常，可以使用try和except语句捕捉并处理异常，例如：
try:
f = open("test.text", "w")
except IOError as e:
print(e)处理完异常后，程序将继续执行紧跟在最后一个except代码块后面的语句。raise语句用于手工引发异常，引发异常时，可以使用任意一个内置异常，例如：
raise RuntimeError("No")
随着程序越来越大，为了便于维护，需要把它分为多个文件。为此python允许把定义放入一个文件中，然后在其他程序和脚本中将其作为模块导入。要创建模块，可将相关的语句和定义放入与模块同名的文件中（后缀必须是.py），例如：
# file: div.py
def divide(a, b):
q = a / b
r = q - q * b
return (q, r)要在其他程序中使用该模块，可以使用import语句，例如：
import div
a, b = div.divide(10, 20)import语句创建了一个新的命名空间，并在该命名空间中执行与.py文件相关的所有语句。要在导入后访问命名空间的内容，只要使用该模块的名称作为前缀。如果要使用不同的名称导入模块，可以加上as限定符，例如：
import div as foo
a, b = foo.divide(10, 20)要将具体的定义导入到当前的命名空间，可使用from语句，例如：
from div import divide
a, b = divide(10, 20)要把模块的所有内容加载到当前的命名空间中，还可以使用以下语句：
form div import *