本文主要向大家介绍了Python语言精要，通过具体的实例让大家了解，希望对大家学习Python语言有所帮助。

###Python解释器 Python是一种解释型语言。Python解释器是通过“一次执行一条语句”的方式运行程序的。 我所有实例将会使用Ipython（一种加强的交互式Pyhton解释器）。默认的Ipthon提示符采用的是一种编号风格（如In [3]:），而不是标准的“>>>”提示符。

Python 2.7.10 (default, May 23 2015, 09:40:32) [MSC v.1500 32 bit (Intel)]

Type "copyright", "credits" or "license" for more information.

IPython 2.4.1 -- An enhanced Interactive Python.

?         -> Introduction and overview of IPython's features.

%quickref -> Quick reference.

help      -> Python's own help system.

object?   -> Details about 'object', use 'object??' for extra details.

In [1]: print "hello word!"

hello word!

In [2]:

###基础知识 ####缩进，而不是大括号

Python是通过空白字符（制表符或空格）来组织代码的。

使用空白符的主要好处：

(1.)统一美观，增强代码可读性；没有无实际意义的空白符。

(2.)简单易读；不管是阅读自己以前的还是别人的代码时不容易出现“认知失调”。

In [2]: for i in xrange(5):

   ...:     print i

   ...:01234

In [3]:

Python可以以分号结束，比如在一行上分隔多条语句：

a = 3; b = 9; c = 7

在一行上放置多条语句的做法在Python中一般是不推荐的，因为这往往会使代码的可读性变差。

####注释

单行注释：任何前缀为井号（#）的文本都会被Python解释器忽略。

#这是一条注释

多行注释：Python允许定义长字符串，用匿名的字符串来代替多行注释的效果。

'''

xxx

这一段文字将作为静态常量的长字符串

xxx

'''

####函数调用和对象方法调用

#函数的调用需要用到圆括号以及0个或多个参数，此外还可以将返回值赋值给一个变量 result = f1(x, y, z)

f2()

#Python对象可以访问该对象的内部数据

obj.some_method(x, y)

#函数既可以接受位置参数，也可以接受默认参数

result = f(a, b, c=5, d='foo')

####变量和传引用

在Python中对变量赋值时，你其实是在创建等号右侧对象的一个引用。

在某些语言中，该赋值过程将导致[1, 2, 3]被复制。而在Python中，arr和lst现在都指向同一个对象，即原始列表[1, 2, 3]（如图1）

![arr和lst现在都指向同一个对象][id] [id]: https://static.oschina.net/uploads/img/201511/20195124_jqCJ.png图1：指向同一对象的两个引用

In [4]: arr = [1, 2, 3]

In [5]: lst = arr

In [6]: arr, lst

Out[6]: ([1, 2, 3], [1, 2, 3])

In [7]: arr.append(5)

In [8]: arr, lst

Out[8]: ([1, 2, 3, 5], [1, 2, 3, 5])

当你将对象以参数的形式传人函数时，其实只是穿入了一个引用而已，不会发生任何复制。因此，Python被称为是按引用传递的，而某些语言可以进行传值和传引用。也就是说，Python函数可以修改其参数的内容。

In [9]: def append_element(some_list, element):

   ...:     some_list.append(element)

   ...:

In [10]: append_element(arr, 7)

In [11]: arr, lst

Out[11]: ([1, 2, 3, 5, 7], [1, 2, 3, 5, 7])

Python中的对象之间赋值时是按引用传递的，如果需要拷贝对象，需要使用标准库中的copy模块。 1) copy.copy 浅拷贝 只拷贝父对象，不会拷贝对象的内部的子对象。 2) copy.deepcopy 深拷贝 拷贝对象及其子对象。

import copy

a = [1, 2, 3, 4, ['a', 'b']] #原始对象

b = a #赋值，传对象的引用

c = copy.copy(a) #对象拷贝，浅拷贝

d = copy.deepcopy(a) #对象拷贝，深拷贝

a.append(5) #修改对象a

a[4].append('c') #修改对象a中的['a', 'b']数组对象

print 'a = ', aprint 'b = ', bprint 'c = ', cprint 'd = ', d

a = [1, 2, 3, 4, ['a', 'b', 'c'], 5] b = [1, 2, 3, 4, ['a', 'b', 'c'], 5] c = [1, 2, 3, 4, ['a', 'b', 'c']] d = [1, 2, 3, 4, ['a', 'b']]

####动态引用，强类型

跟许多编译型语言（如Java和C++）相反，Python中的对象没有与之关联的类型信息。

In [12]: a = 2

In [13]: type(a)Out[13]: int

In [14]: b = 'foo'

In [15]: type(b)Out[15]: str

变量其实就是对象在特定命名空间中的名称而已。对象的类型信息保存在它自己的内部的。有人可能轻率的认为Python不是一种“类型化语言”。其实不是这样的。看看下面这个例子：

In [16]: '2' + 2---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-16-4c6dd5170204> in <module>()----> 1 '2' + 2

TypeError: cannot concatenate 'str' and 'int' objects

在一些语言中，字符串'2'可能会被隐式地转换为整数，于是就会得到4.而在另一些语言中，整数2可能会被转换为字符串，于是就会得到“22”。而在这一点上，Python可以被认为是一种强类型语言，也就是说所有对象都有一个特定的类型（或类），隐式转换只在很明显的情况下才会发生，比如下面这样：

In [17]: a = 6.5

In [18]: b = 2

In [19]: print 'a is %s, b is %s' % (type(a), type(b))

a is <type 'float'>, b is <type 'int'>

In [20]: a / b

Out[20]: 3.25

####属性和方法

Python中的对象通常都既有属性又有方法。它们都能通过obj.attribute_name这样的语法进行访问：

In [21]: str = 'hello word'`

In [22]: str.(按<Tab>键)str.capitalize str.format     str.isupper    str.rindex     str.stripstr.center     str.index      str.join       str.rjust      str.swapcasestr.count      str.isalnum    str.ljust      str.rpartition str.titlestr.decode     str.isalpha    str.lower      str.rsplit     str.translatestr.encode     str.isdigit    str.lstrip     str.rstrip     str.upperstr.endswith   str.islower    str.partition  str.split      str.zfillstr.expandtabs str.isspace    str.replace    str.splitlinesstr.find       str.istitle    str.rfind      str.startswith

In [22]: str.split('o')

Out[22]: ['hell', ' w', 'rd']

####引入（import）

如果你想要在其他程序中重用很多函数,就可以使用模块（module）。在Python中，模块就是一个含有函数和变量定义以及引入的其他.py文件。

#1.直接导入（自定义）模块：import _moduleNameimport sys, timeimport self_module

#2.引入模块中的变量和函数：from _moduleName import ..from urllib import urlopen

#3.引入不同的变量名（定义别名）。import some_module as smfrom some_module import 

####可变和不可变的对象

大部分Python对象是可变的，比如列表，字典以及大部分用户自定义类型（类）。也就是说它们所包含的对象或值是可以被修改的。

In [23]: a_lst = ['arr', 1, [2, 3]]

In [24]: a_lst[2] = (5, 6)

In [25]: a_lst

Out[25]: ['arr', 1, (5, 6)]

而其它的（如字符串和元组等）则是不可变的；不可变指的是“不能修改原内存块的数据”。也就是说，技术修改成功了，也只是创建了一个新对象并将其引用赋值给原变量而已。

**注意：**仅仅因为“可以修改某个对象”并不代表“就该那么做”。这种行为在编程中也叫做副作用。例如，在编写一个函数时，任何副作用都应该通过该函数的文档或注释明确地告知用户。即使可以使用可变对象，我也建议尽量尽量避免副作用且注重不变性。

####数值类型

用于表示数字的主要Python类型是int和float。能被保存为int的整数的大小由平台（32b or 64b）决定，但Python会自动将非常大的整数转换为long，它可以存储任意大小的整数。

#Python会自动将非常大的整数转换为longIn [26]: ival = 65536

In [27]: ival ** 6

Out[27]: 79228162514264337593543950336L

#浮点数会被表示为float类型。它们也可以用科学计数法表示In [28]: fval = 9.3657

In [29]: fvale = 6.321e-5

#复数的虚部会是用j表示的In [30]: cval = 1 + 3j

In [31]: cval * (1 - 3j)

Out[31]: (10+0j)

以上就介绍了Python的相关知识，希望对Python有兴趣的朋友有所帮助。了解更多内容，请关注职坐标编程语言Python频道！