3 Python 快速入门

Python 快速入门

程序输出: print 函数及打印 “hello world”

hello.py 文件

#!/usr/bin/python3
import sys

if sys.version[0] == '2':
    print 'Hello World!'
elif sys.version[0] == '3':
    print('Hello World!')

不管哪种 Unix 平台，Python 脚本都可以像下面这样，在命令行上通过解释器执行。

$ python hello.py

输出结果为:

Hello World!

对 #!/usr/bin/python3 代码的解释

如果你使用的是类 Unix 平台，你可以在你的脚本的第一行使用 shell 魔术字符串（“sh-bang”）。

注意: 包括任何的脚本语言。

Unix 平台还可以在不明确指定 Python 解释器的情况下，自动执行 Python 解释器。

#!/usr/bin/python
是告诉操作系统执行这个脚本的时候，调用 /usr/bin 下的 python 解释器。

#!/usr/bin/python3
表示该脚本调用 /usr/bin 下的 python3 解释器。

#!/usr/bin/env python
这种用法是为了防止操作系统用户没有将 python 装在默认的 /usr/bin 路径里。当系统看到这一行的时候，首先会到 env 设置里查找 python 的安装路径，再调用对应路径下的解释器程序完成操作。(推荐这种写法)

程序输入: input() 函数

输入用户名

#!/usr/bin/python3
import sys

if sys.version[0] == '2':
    user = raw_input('Enter login name: ')
elif sys.version[0] == '3':
    user = input('Enter login name: ')

print('Your login is', user)

输入一个数值字符串，并将字符串转换为整型

#!/usr/bin/python3
import sys

if sys.version[0] == '2':
    num = raw_input('Now enter a number: ')
elif sys.version[0] == '3':
    num = input('Now enter a number: ')

print('Doubling your number: %d' % (int(num) * 2))

注释

行注释。Python 使用 # 符号标示注释，从 # 开始，直到一行结束的内容都是注释。

def foo():
	# This is a doc string.
	return True

文档字符串注释。你可以在模块、类或者函数的起始添加一个字符串，起到在线文档的功能，这是 Java 程序员非常熟悉的一个特性。

def foo():
	""" This is a doc string. """
	return True

与普通注释不同，文档字符串可以在运行时访问，也可以用来自动生成文档。

变量和赋值

下列代码

counter = 0
miles = 1000.0
name = 'Bob'
counter = counter + 1
kilometers = 1.609 * miles

print('%f miles is the same as %f km' % (miles, kilometers))

输出结果为:

1000.000000 miles is the same as 1609.000000 km

Python 中变量名规则

Python 中变量名规则与其他大多数高级语言一样，都是受 C 语言影响（或者说这门语言本身就是 C 语言写成的）。
变量名仅仅是一些字母开头的标识符——所谓字母开头——意指大写或小写字母，另外还包括下划线（_）。其他的字符可以是数字、字母或下划线。
Python 变量名是大小写敏感的，也就是说变量 “case” 与 “CaSe” 是两个不同的变量。

Python 动态类型

Python 是动态类型语言，也就是说不需要预先声明变量的类型。

变量的类型和值在赋值那一刻被初始化。变量赋值通过等号来执行。

数字类型

Python 支持五种基本数字类型，其中有三种是整型类型。

• 长整型 (int)
• 浮点值 (float)
• 复数 (complex)

数字的基本运算

下列代码

# + 加法
print(100 + 3)
# - 减法
print(100 - 3)
# * 乘法
print(100 * 2)
# / 除法
print(100 / 3)
# // 整除
print(100 // 3)
# % 余数
print(100 % 3)
# ** 乘方
print(10 ** 2)

输出结果为:

103
97
200
33.333333333333336
33
1
100

数字的比较

Python 当然也有标准比较操作符，比较运算根据表达式的值的真假返回布尔值。

< <= > >= == != <>

下列代码

print(2 < 4)
print(2 == 4)
print(2 > 4)
print(6.2 <= 6)
print(6.2 <= 6.2)
print(6.2 <= 6.20001)

输出结果为:

True
False
False
False
True
True

Python 目前支持两种 “不等于“ 比较操作符，!= 和 <>，分别是 C 风格和 ABC/Pascal 风格。目前后者慢慢地被淘汰了，所以我们推荐使用前者。

布尔类型

布尔类型的常量值为: False 和 True

布尔的逻辑操

Python 也提供了逻辑操作符。

and or not

使用逻辑操作符可以将任意表达式连接在一起，并得到一个布尔值。
下列代码

print(True and False)
print(False or True)
print(not False)

输出结果为:

False
True
True

字符串类型

Python 中字符串被定义为引号之间的字符集合。
Python 支持使用成对的单引号或双引号，三引号（三个连续的单引号或者双引号）可以用来包含特殊字符。

字符串连接

加号（+）用于字符串连接运算

# Python is cool!
print('Python' + ' ' + 'is cool!')

字符串重复

星号（*）则用于字符串重复

# PythonPythonPython
print('Python' * 3)

字符串长度

使用 len() 函数可以获取序列对象的元素个数。

通过 len() 函数，获取字符串的字符数。

pystr = 'Python'
print(len(pystr)) # 6

字符串索引

使用索引操作符（[]）得到字符。

字符串有其特有的索引规则：第一个字符的索引是 0,最后一个字符的索引是 -1。

pystr = 'Python'
print(pystr[0])
print(pystr[3])
print(pystr[-1])

‘Python’ 字符串长度为 6 (等同于 len(pystr))， 从索引 0 到 索引 5 (等同于 len(pystr) - 1)。

字符串切片

切片操作符（[start:end:step]）可以得到子字符串。

子字符串从索引从 start 到 end-1，步长 step 默认为 1

代码

pystr = 'Python'
print(pystr[2:5])   # 子字符串索引从 2 到 4
print(pystr[:2])    # 子字符串索引从 0 到 1
print(pystr[3:])    # 子字符串索引从 3 到字符串末尾
print(pystr[3:-1])  # 子字符串索引从 3 到 4
print(pystr[-4:-1]) # 子字符串索引从 2 到 4
print(pystr[::-1])  # 子字符串逆向输出

等同于下面代码

def print_str(s, start=None, end=None, step=1):
    if step > 0:
        if start == None:
            start = 0
        elif start < 0:
            start = len(s) + start
        elif start > 0:
            start = start
        else:
            raise ValueError('start is bad.')

        if end == None:
            end = len(s)
        elif end < 0:
            end = len(s) + end
        elif end > 0:
            end = end
        else:
            raise ValueError('end is bad.')
    elif step < 0:
        if start == None:
            start = -1
        elif start < 0:
            start = start
        elif start > 0:
            start = len(s) - start
        else:
            raise ValueError('start is bad.')

        if end == None:
            end = -len(s) - 1
        elif end < 0:
            end = end
        elif end > 0:
            end = len(s) - end
        else:
            raise ValueError('end is bad.')
    elif step == 0:
        raise ValueError('step cannot be zero.')

    print('start=%d, end=%d, step=%d' % (start, end, step))
    for i in range(start, end, step):
        print(pystr[i], sep='', end='')
    print()

print_str(pystr, start=2, end=5)   # 子字符串索引从 2 到 4
print_str(pystr, end=2)    # 子字符串索引从 0 到 1
print_str(pystr, start=3)    # 子字符串索引从 3 到字符串末尾
print_str(pystr, start=3, end=-1)  # 子字符串索引从 3 到 4
print_str(pystr, start=-4, end=-1) # 子字符串索引从 2 到 4
print_str(pystr, step=-1)  # 子字符串逆向输出
print_str(pystr, step=0)  # 抛出异常

列表

可以将列表当成普通的 “数组”，它能保存任意数量任意类型的 Python 对象。和数组一样，通过从 0 开始的数字索引访问元素，但是列表可以存储不同类型的对象。

列表元素用中括号（[]）包裹，元素的个数及元素的值可以改变。通过切片运算（[]和[:]）可以得到子集，这一点与字符串的使用方法一样。

pylist = [1, 2, 3, 4]

# 打印列表
print(pylist)

# 列表索引
print(pylist[0])
print(pylist[-1])

# 列表切片
print(pylist[2:])
print(pylist[:3])

# 列表长度
print(len(pylist))

# 列表元素赋值
pylist[0] = 10

元组

元组与列表相似。

元组元素用小括号（()）包裹，不可以更改（尽管他们的内容可以）。元组可以看成是只读的列表。通过切片运算（[]和[:]）可以得到子集，这一点与字符串的使用方法一样。

pytuple = ('robots', 77, 93, 'try')

# 打印元组
print(pytuple)

# 元组索引
print(pytuple[0])
print(pytuple[-1])

# 元组切片
print(pytuple[2:])
print(pytuple[:3])

# 元组长度
print(len(pytuple))

# 元组不能修改
pytuple[0] = 10 # 抛出异常，元组不能赋值

字典

字典是 Python 中的映射数据类型，工作原理类似 Perl 中的关联数组或哈希表，由键-值（key-value）对构成。

几乎所有类型的 Python 对象都可以用作键，不过一般还是以数字或者字符串最为常用。

值可以是任意类型的 Python 对象。

字典元素用大括号（{}）包裹，每个元素是一个键值对。

pydict = {'ip': '10.0.0.1'}

# 添加键值对
pydict['port'] = 80

# 打印字典
print(pydict)

# 字典元素
print(pydict['port'])

集合

Python 中的集合类型，表示元素是唯一的。

用法类似于列表，但不支持索引和切片操作

pyset = {1, 2, 2, 3, 4, 5, 6}

# 打印集合
print(pyset)

# 集合元素数量
print(len(pyset))

代码块及缩进对齐

代码块通过缩进对齐表达代码逻辑，而不是使用大括号。因为没有了额外的字符，程序的可读性更高。而且缩进完全能够清楚地表达一个语句属于哪个代码块。当然，代码块也可以只有一个语句组成。

对一个 Python 初学者来说，仅使用缩进可能令他诧异。人们通常竭力避免改变，因此对那些使用大括号很多年的人来说，初次使用纯缩进来表示逻辑也许会多少感到有些不够坚定（不用大括号？到底成不成啊？）。然而回想一下，Python有两大特性，一是简洁，二是可读性好。如果你实在讨厌使用缩进作为代码分界，我们希望你从现在开始，半年后再来看一下这种方式。也许你会发现生活中没有大括号并不会像你想像的那么糟糕。

if 语句

标准 if 条件语句的语法如下:

if expression1:
	...
elif expression2:
	...
elif expressio3:
	...
else:
	...

while 语句

标准 while 条件循环语句的语法类似if，语法如下:

while expression:
	...

for 循环 和 range() 函数

Python 中的 for 接受可迭代对象（例如序列或迭代器）作为其参数，每次迭代其中一个元素。

标准 for 循环语句的语法如下:

for item in range(...):
	...

文件 和 函数 open()、file()

如何打开文件

handle = open(file_name, access_mode = 'r')

file_name 变量包含我们希望打开的文件的字符串名字，
access_mode 中 'r’表示读取，‘w’ 表示写入，‘a’ 表示添加。其他可能用到的标识还有 '+'表示读写，‘b’ 表示二进制访问。如果未提供 access_mode, 默认值为 ‘r’。
如果 open() 成功，一个文件对象句柄会被返回。所有后续的文件操作都必须通过此文件句柄进行。
当一个文件对象返回之后，我们就可以访问它的一些方法，比如 readlines() 和 close()。文件对象的方法属性也必须通过句点属性标识法访问。

下面有一些代码，提示用户输入文件名，然后打开一个文件，并显示它的内容到屏幕上。

filename = input('Enter file name: ')
fread = open(filename, 'r')
for each_line in fread:
	print(each_line)
fread.close()

错误和异常

编译时会检查语法错误，不过 Python 也允许在程序运行时检测错误。当检测到一个错误，Python 解释器就引发一个异常，并显示异常的详细信息。程序员可以根据这些信息迅速定位问题并进行调试，并找出处理错误的办法。

要给你的代码添加错误检测及异常处理，只要将它们 “封装” 在 try-except 语句当中 try 之后的代码组，就是你打算管理的代码 except 之后的代码组，则是你处理错误的代码。

try:
	filename = input('Enter file name: ')
	fread = open(filename, 'r')
	for each_line in fread:
		print(each_line)
	fread.close()
except IOError as e:
	print('file open error:', e)

程序员也可以通过使用 raise 语句故意引发一个异常。

函数

类似于其他语言，Python中的函数使用小括号（()）调用。函数在调用之前必须先定义。如果函数中没有return语句，就会自动返回None对象。

Python是通过引用调用的。这意味着函数内对参数的改变会影响到原始对象。不过事实上只有可变对象会受此影响，对不可变对象来说，它的行为类似按值调用。

# 定义函数
def addMe2Me(x):
	''' apply + operation to argument '''
	return (x + x)

# 调用函数
addMe2Me(4.25)
addMe2Me(10)
addMe2Me('Python')
addMe2Me([-1, 'abc'])

类

是面向对象编程的核心，它扮演相关数据及逻辑容器的角色。它们提供了创建“真实”对象（也就是实例）的蓝图。因为Python并不强求你以面向对象的方式编程（与Java不同），此刻你也可以不学习类。不过我们还是在这儿放了些例子，以方便感兴趣的读者浏览。

# 定义类
class FooClass(object):
	""" my very first class: FooClass """
	version = 0.1 # 类属性
	
	def __init__(self, name='John Doe'):
		""" 构造函数 """
		self.name = name # 实例属性
		print('Created a class instance for', name)
	
	def showname(self):
		""" 显示实例属性和类名 """
		print('Your name is', self.name)
		print('My name is', self.__class__.__name__)
		
	def showver(self):
		""" 显示类(静态)属性 """
		print(self.version) # 参考 FooClass.version

	def addMe2Me(self, x): # 不使用 'self'
		""" apply + operation to argument """
		return x + x
	
# 使用类
foo1 = FooClass()
foo1.showname()
foo1.showver()
print(foo1.addMe2Me(5))
print(foo1.addMe2Me('xyz'))

foo2 = FooClass('Jane Smith')
foo2 = showname()

模块

模块是一种组织形式，它将彼此有关系的 Python 代码组织到一个个独立文件当中。模块可以包含可执行代码、函数和类，或者这些东西的组合。

当你创建了一个 Python 源文件，模块的名字就是不带 .py 后缀的文件名。一个模块创建之后，你可以从另一个模块中使用 import 语句导入这个模块来使用。

# 导入模块
import sys

# 访问模块的函数、变量等
sys.stdout.write('Hello World!\n')
print(sys.platform)
print(sys.verion)