[Python]简介

1. 运行Python

Python程序是由解释器来执行的。解释器启动后将出现一个命令提示，在此可以开始输入程序。在交互式shell中，可以输入任意合法的语句或语句序列，然后立即查看结果。例如：

创新互联专注于府谷网站建设服务及定制，我们拥有丰富的企业做网站经验。 热诚为您提供府谷营销型网站建设，府谷网站制作、府谷网页设计、府谷网站官网定制、微信平台小程序开发服务，打造府谷网络公司原创品牌,更为您提供府谷网站排名全网营销落地服务。

print("Hello World")

以交互式方式使用Python时，特殊变量_用于保存最后一次运算结果。但要强调的是，此变量只有在交互式工作时才有定义。如果要创建可以重复运行的程序，可以将语句放到一个文件中：

#helloworld.py
print("Hello World")

Python源文件是普通的文本文件，后缀通常是.py。#字符表示整行都是注释。
 

2. 变量和算数表达式

以下程序简要说明变量和表达式的用法：

principal = 1000 # 初始金额
rate = 0.05 # 利率
numyears = 5 # 年数
year = 1
while year <= numyears:
    principal = principal * ( 1 + rate )
    print(year, principal)
    year += 1

Python是一种动态类型的语言，在程序执行过程中，可将变更是名绑定到不同的值，而且这些值可以属于不同的类型。换行代表一条语句的结束。然而，也可以在同一行上使用分号来隔开多条语句，例如：

principal = 1000; rate = 0.05; numyears = 5;
While语句对随后的条件表达式进行测试。因为循环主体是由缩进表示的，Python不会指定所需缩进的量，只要在一个代码块中保持一致即可。
 

3. 条件语句

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。
 

4. 文件输入和输出

以下程序可找开一个文件并逐行读取内容：

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()

5. 字符串

要创建一个字符串字面量，将字符串放在单引号、双引号、三引号中即可，例如：

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"

6. 列表

列表是任意对象的序列，把值放入方括号中就可以创建列表，例如：

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])

7. 元组

要创建简单的数据结构，可以使用元组，在圆括号中放入一组值即可创建元组，例如：

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

尽管元组支持的大部分操作与旬表的相同，但创建元组后不能修改它的内容。程序元往往忽略了元组，而只用列表，但如果程序要创建大量的小列表，就会造成内存浪费。元组是不可变的，所以它们的表示更为紧凑，不会占据额外的内存空间。
 

8. 集合

集合用于包含一组无序的对象。要创建集合，可使用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]) # 添加多项

9. 字典

字典就是一个关联数组或散列表，其中包含通过关键字索引的对象。在大括号中放入值即可创建字典，例如：

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"]

10. 迭代与循环

最常用的循环结构是用于迭代多个项的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])

11. 函数

使用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

12. 生成器

如果使用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)

13. 协程

通常函数运行时要使用一组输入参数，但是，也可以把函数编写为一个任务，从而能处理发送给它的一系列输入，这类函数称为协程，例如：

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()方法为止。
 

14. 对象与类

程序中使用的所有值都是对象。对象由内部数据和各种方法组成，这些方法会执行与这些数据相关的各种操作。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()

15. 异常

如果程序中出现错误，就会引发异常，可以使用try和except语句捕捉并处理异常，例如：

try:
    f = open("test.text", "w")
except IOError as e:
    print(e)

处理完异常后，程序将继续执行紧跟在最后一个except代码块后面的语句。raise语句用于手工引发异常，引发异常时，可以使用任意一个内置异常，例如：

raise RuntimeError("No")

16. 模块

随着程序越来越大，为了便于维护，需要把它分为多个文件。为此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 *