一、程序输出，print语句及“Hello World！”
在有些语言中，比如C通过函数输出数据到屏幕，printf()。而在Python和大多数解释执行的脚本语言中，使用语句进行输出。很多的shell脚本语言使用echo 命令来输出程序结果。
在交互式解释器中显示变量的值——通常会在代码中使用print语句输出，不过在交互式解释器中，可以用print语句显示变量的字符串表示，或者仅用变量名来查看该变量的原始值。
>>> myString = 'Hello World!'
>>> print myString
Hello World!
>>> myString
'Hello World!'
>>>
需注意，在仅使用变量名时，输出的字符串是用单引号括起来的。这是为了让非字符串对象也能以字符串的方式显示在屏幕上——即它显示的是该对象的字符串表示，而不仅仅是字符串本身。引号表示你刚刚输入的变量值是一个字符串。print语句调用str()函数显示对象。而交互式解释器则调用repr()函数显示对象。
下划线“_” 在解释器中有特别的含义，表示最后一个表达式的值。
>>> _
'Hello World!'
Python的print语句，与字符串格式操作符（%）结合使用，可实现字符串替换功能。
>>> print "%s is number %d!" % ("python",1)
python is number 1!
print语句也支持将输出重定向到文件。从Python2.0新增。用符号“>>”重定向。
将输出重定向到标准错误输出。
>>> print >> sys.stderr, 'Fatal error: invalid input!'
Fatal error: invalid input!
将输出重定向到日志文件：
>>> logfile = open('/tmp/mylog.txt','a')
>>> print >> logfile, 'Fatal error: invalid input!'
>>> logfile.close()
[root@localhost ~]# cat /tmp/mylog.txt
Fatal error: invalid input!
二、程序输入和raw_input()内建函数
使用raw_input()内建函数读取标准输入，并将读取到的数据赋值给指定的变量。可以用int()内建函数将用户输入字符串转换为整形。
>>> user = raw_input('Enter login name: ')
Enter login name: root
>>> print 'Your login is:', user
Your login is: root
>>> num = raw_input('Now enter a number: ')
Now enter a number: 1024
>>> print 'Doubling your number : %d' % (int(num) * 2)
Doubling your number : 2048
从交互式解释器中获得帮助
使用内建函数help()。比如help(raw_input)
Help on built-in function raw_input in module __builtin__:
raw_input(...)
raw_input([prompt]) -> string
Read a string from standard input. The trailing newline is stripped.
If the user hits EOF (Unix: Ctl-D, Windows: Ctl-Z+Return), raise EOFError.
On Unix, GNU readline is used if enabled. The prompt string, if given,
is printed without a trailing newline before reading.
raw_input(...)
raw_input([prompt]) -> string
Read a string from standard input. The trailing newline is stripped.
If the user hits EOF (Unix: Ctl-D, Windows: Ctl-Z+Return), raise EOFError.
On Unix, GNU readline is used if enabled. The prompt string, if given,
is printed without a trailing newline before reading.
从标准输入读取一个字符串并自动删除串尾的换行字符。如果用户键入了EOF字符（Ctrl+D或Ctrl+Z+回车），则引发EOFError，在Unix平台，，只要可用，就使用GUN readline库。如果提供提示字符串参数，则显示该字符串并自动删去字符串末尾的换行字符。
三、注释
Python使用 # 符号标示注释，从 # 开始，知道一行结束的内容都是注释。
>>> # one comment
... print 'Hello World!' # another comment
Hello World!
>>> def foo():
... "This is a doc string."
... return True 四、操作符
与一般语言一样，操作符以你熟悉的方式工作。但Python有两种除法，一种单斜杠用于传统除法，双斜杠用作浮点除法（对结果进行四舍五入）。
>>> print 5.0 / 3
1.66666666667
>>> print 5.0 // 3
1.0
>>> print -2 * 4 + 3 ** 2
1
Python支持两种“不等于”比较操作符，！= 和 <> ，推荐使用前者。
>>> 3 < 4 < 5
True
五、变量和赋值
Python的变量名是大小写敏感的。
Python是动态类型语言，不需要预先声明变量的类型。变量的类型和值在赋值的那一刻就被初始化。变量赋值通过等号来执行。
>>> 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
n *= 10
Python不支持C语言中的自增1和自减1操作符，Python会将--n 解释为 -（-n）从而得到1.
六、数字
Python支持五种基本数字类型，其中有三种是整型类型。
有符号整型
长整型
布尔值
浮点值
复数
Python的长整型所能表达的范围远远超过C语言的，事实上，它仅受限于用户计算机的虚拟内存总数。从Python2.3开始，再也不会报整型溢出错误，结果会被自动转为长整型。
其实还有第六种数字类型，decimal，用于十进制浮点型。不过它并非内建类型，你必须先导入decimal模块才能使用。但是在Python2.4中增加了这种类型。
七、字符串
Python中字符串被定义为引号之间的字符集合。Python支持使用成对的单引号或双引号。三引号可以用来包含特殊字符。使用索引操作符( [] )和切片操作符( [ : ] )可以得到子字符串。字符串有特有的索引规则：第一个字符的索引是 0 ，最后一个字符的索引是 -1 。
加号 （ + ）用于字符串连接运算，星号（ * ）用于字符串重复。
>>> pystr = 'Python'
>>> iscool = 'is cool!'
>>> pystr[0]
'P'
>>> pystr[2:5]
'tho'
>>> iscool[:2]
'is'
>>> iscool[3:]
'cool!'
>>> iscool[-1]
'!'
>>> pystr + iscool
'Pythonis cool!'
>>> pystr + ' ' + iscool
'Python is cool!'
>>> pystr * 2
'PythonPython'
>>> '-' * 20
'--------------------'
>>> pystr = '''Python
... is cool!'''
>>> pystr
'Python \n\tis cool!'
>>> print pystr
Python
is cool!
八、列表和元组
可以将列表和元组当成普通的“数组”，它能保存任意数量任意类型的Python对象。从0开始索引访问，但是列表和元组可以存储不同类型的对象。
列表和元组有几处重要区别。列表元素用中括号‘[]’包裹，元素的个数及元素的值可以改变。元组元素用小括号“()”包裹，不可以更改。元组可以看成是只读的列表。
>>> l1 = [1,2,3,4]
>>> l1
[1, 2, 3, 4]
>>> l1[0]
1
>>> l1[:3]
[1, 2, 3]
>>> l1[2:]
[3, 4]
>>> l1[3] = 5
>>> l1
[1, 2, 3, 5]
元组也可以进行切片运算，得到的结果还是元组，不能被修改。
>>> t1 = ('robots',22,33,'try')
>>> t1
('robots', 22, 33, 'try')
>>> t1[:3]
('robots', 22, 33)
>>> t1[1] = 5
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
九、字典
由键-值对构成，几乎所有的Python对象都可以用作键，但一般还是以数字或字符串为主，值可以是任意类型的Python对象。字典用大括号 {} 包裹。
十、代码块及缩进
代码块通过缩进对齐表达式代码逻辑。十一、if语句
if expression：
if_suite
if expression:
if_suite
elif:
elif_suite
else:
else_suite
十二、while循环
while expression：
while_suite
十三、for 循环和range()内建函数
Python的for循环类似于shell脚本里的foreach迭代，for 接受可迭代对象作为其参数，每次迭代其中一个元素。
>>> print 'I like to use the internet for: '
I like to use the internet for:
>>> for item in ['e-mail', 'net-surfing', 'homework', 'chat']:
... print item
e-mail
net-surfing
homework
chat
>>> for item in ['e-mail', 'net-surfing', 'homework', 'chat']:
... print item,
e-mail net-surfing homework chatprint 语句会默认网每一行添加一个换行符，只要在print语句最后添加一个逗号（,），就可以改变这种行为。
>>> print 'I like use the internet for : '
... for item in ['e-mail', 'net-surfing', 'homework', 'chat']:
... print item,
... print
I like use the internet for :
e-mail net-surfing homework chat
可以通过一个没有任何参数的print语句，输出一个换行符。否则提示信息会立即出现在我们输出之后。
range()函数和len()函数一起用于字符串索引。
>>> foo = 'abc'
>>> for i in range(len(foo)):
... print foo[i], '(%d)' % i
a (0)
b (1)
c (2)
不过这些循环有个约束，就是要么循环索引，要么循环元素。这导致了enumerte()函数的诞生。
>>> for i, ch in enumerate(foo):
... print ch, '(%d)' % i
a (0)
b (1)
c (2)十四、列表解析
>>> squared = [ x ** 2 for x in range(5)]
>>> for i in squared:
... print i
0
1
4
9
16
>>> sqdEvens = [x ** 2 for x in range(16) if not x % 2]
>>> for i in sqdEvens:
... print i
0
4
16
36
64
100
144
196
十五、文件和内建函数open()，file()
handle = open(file_name, access_mod = 'r')
file_name 表示文件名，access_mod中的 ‘r’ 表示读取， ‘w’表示写入，‘a’表示添加。其他可能用到的标示有
“+” 表示读写， ‘b'表示二进制访问。默认为’r‘。如果 open()成功，则会返回一个文件对象句柄。所有后续的文件操作都必须通过此文件句柄进行。文件对象的方法属性也必须通过句点属性标识法访问。
filename = raw_input('Enter file name: ')
fobj = open(filename, 'r')
for eachLine in fobj:
print eachLine,
fobj.close()
以上这段代码，我们一次读入文件的所有行，然后关闭文件，再迭代每一行输出。这样写的好处是可以快速完整的访问文件，但是文件太大会占用太多内存。
另外，我们在print 语句中使用了 ， 来抑制自动生成的换行符号。因为文本中的每一行自带了换行字符，如果不这样，就会产生多余的空行
[root@localhost mypython]# python open_file.py
Enter file name: /etc/passwd
root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin
adm:x:3:4:adm:/var/adm:/sbin/nologin
file()内建函数的功能等同于open()，不过file() 这个名字可以更确切的表明它是一个工厂函数（生成文件对象）。类似于int()生成整型对象，dict()生成字典对象。
十六、错误和异常
Python允许程序运行时检测错误。当检测到一个错误，Python解释器就引发一个异常，并显示异常的详细信息。
要给自己的代码添加错误检测以及异常处理，只要将它们封装在 try-except语句当中。try之后的代码组，就是你打算管理的代码。except之后的代码组，则是处理错误的代码。
try:
filename = raw_input('Enter file name: ')
fobj = open(filename, 'r')
for eachLine in fobj:
print eachLine
fobj.close()
except IOError, e:
print 'file open error: ', e
十七、函数
类似其他语言，Python中的函数使用小括号调用。函数在调用之前必须先定义。如果函数中没有return语句，则会自动返回None对象。
Python是通过引用调用函数的。这意味着函数内对参数的改变会影响到原始对象。不过事实上只有可变对象才会受此影响，不不可变对象来说，它的行为类似按值调用。
17.1 如何定义函数
def function_name([arguments]):
"optional documentation string"
function_suite
exp:
def add(x):
'apply + operaion to argument'
return (x + x)
17.2 如何调用函数
>>> def add(x):
... return (x + x)
>>> add(4.25)
8.5
>>> add(10)
20
>>> add('Python')
'PythonPython'
>>> add([1,'abc'])
[1, 'abc', 1, 'abc']
为函数名加上函数操作符—— 小括号。括号之间是所有可选的参数。即使一个参数也没有，小括号也不能省略。
17.3 默认参数
函数的参数可以有一个默认值，如果提供默认值，在函数的定义中，参数以赋值的形式提供。事实上这仅仅是提供默认参数的语法，它表示函数调用时如果没有提供这个参数，它就取这个值为默认值
>>> def foo(debug=True):
... if debug:
... print 'in debug mode'
... print 'done'
>>> foo()
in debug mode
done
>>> foo(False)
done
这个例子中，debug参数有一个默认的值True。
十八、类
类是面向对象编程的核心，它扮演相关数据及逻辑容器的角色。它们提供了创建”真实“对象（实例）的蓝图。
如何定义类
class ClassName(base_class[es]):
"optional documentation string"
static_member_declarations
method_declarations
使用class关键字定义类。可以提供一个可选的父类或者说是基类；如果没有合适的基类，就使用object作为基类。class行之后是可选的文档字符串、静态成员定义和方法定义。
>>> class FooClass(object):
... """my very first class : FooClass"""
... version = 0.1 # class (data) attribute
... def __init__(self, nm='John Doe'):
... """constructor"""
... self.name = nm # class instance (data) attribute
... print 'Created a class instance for', nm
... def showname(self):
... """display instance attribute and class name"""
... print 'Your name is ', self.name
... print 'My name is ', self.__class__.__name__
... def showver(self):
... print self.version
... def add(self, x):
... return x + x在上面这个类中，我们定义一个静态变量version，它将被所有实例及4个方法共享。这些方法仅仅输出对应的信息。__init__()方法有个特殊的名字，所有名字开始和结束都有两个下划线的方法都是特殊方法。、
当一个类实例被创建时，__init__() 方法会自动执行，在类实例创建完毕后执行，类似构造器。__init__()可以被当成构造器，不过不像其他语言中的构造器，它并不创建实例——它仅仅是你的对象创建后执行的第一个方法。它的目的是执行一些该对象必要的初始化工作。
通过创建自己的__init__()方法，可以覆盖默认的该方法（默认什么也不做），从而能够修饰刚刚创建的对象。__init__()需要一个默认的参数，例子中每个方法都有的一个参数——self。它是类实例自身的引用。
如何创建类实例
>>> fool = FooClass()
Created a class instance for John Doe这里显示的就是自动调用__init__()方法的结果。
创建一个类实例就像调用一个函数，它们确实拥有一样的语法，它们都是可调用对象。类实例使用同样的函数操作符调用一个函数或方法。
>>> fool.showname()
Your name is John Doe
My name is FooClass
>>> fool.showver()
0.1
>>> print fool.add(5)
10
>>> print fool.add('world')
worldworld
我们在创建类实例时并未传递名字参数，因此使用默认参数。加入我们传递一个参数。
>>> fool2 = FooClass('Beny')
Created a class instance for Beny
>>> fool2.showname()
Your name is Beny
My name is FooClass
十九、模块
模块是一种组织形式，它将彼此有关系的Python代码组织到一个个独立文件当中。模块可以包含执行代码、函数和类，或者它们的组合。
当你创建了一个Python源文件，模块的名字就是不带.py 后缀的文件名。一个模块创建后，你可以从另一个模块中使用import语句来导入这个模块来使用。
19.1 如何导入模块
import module_name
19.2 如何访问一个模块函数或模块变量
module.function()
module.variable
>>> import sys
>>> sys.stdout.write('Hello world!\n')
Hello world!
>>> sys.platform
'linux2'
>>> sys.version
'2.7.11 (default, Apr 18 2016, 21:23:06) \n[GCC 4.8.3 20140911 (Red Hat 4.8.3-9)]'
关于PEP：
一个PEP就是一个Python增强提案（Python Enhancement Proposal），这也是在新版Python中增加新特性的方式。
二十、实用的函数
函数 描述
dir([obj]) 显示对象的属性，如果没有提供参数，则显示全局变量的名字。
help([obj]) 以一种整齐美观的形式，显示对象的文档字符串，若未提供参数，则进入交互式帮助。
int(obj) 将一个对象转换为整型。
len(obj) 返回对象的长度。
open(fn,mode) 以mode方式打开一个文件名为fn的文件。
range([[start,]stop[,step]) 返回一个整型列表，起始值start，结束值stop-1，start默认0，step默认1
raw_input(str) 等待用户输入一个字符串，可以提供可选参数str用作提示信息。
str(obj) 将一个对象转换为字符串。
type(obj) 返回对象类型。
扫一扫
102
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
