一、基本数据类型和运算

1.基本数据类型

Python中最基本的数据类型包括整型，浮点数，布尔值和字符串。类型是不需要声明的，比如：

[code]a = 1       # 整数
b = 1.2     # 浮点数
c = True    # 布尔类型
d = "False" # 字符串
e = None    # NoneType
#type函数可以查看一个变量的类型：
type(a)     # <type 'int'>
type(b)     # <type 'float'>
type(c)     # <type 'bool'>
type(d)     # <type 'str'>
type(e)     # <type 'NoneType'>

2.变量和引用

Python中基本变量的赋值一般建立的是个引用，比如下面的语句：

[code]a = 1
b = a
c = 1
id(a)   # 35556792L
id(b)   # 35556792L
id(c)   # 35556792L
b = 2   # b的引用到新的一个变量上
id(b)   # 35556768L

a赋值为1后，b=a执行时并不会将a的值复制一遍，然后赋给b，而是简单地为a所指的值，也就是1建立了一个引用，相当于a和b都是指向包含1这个值的这块内存的指针。所以c=1执行的也是个引用建立，这三个变量其实是三个引用，指向同一个值。Python内置了id函数，可以返回一个对象的地址，用id函数可以让我们知道每个变量指向的是不是同一个值。

3.运算符

[code]a = 2
b = 2.3
c = 3
a + b           # 2 + 2.3 = 4.3
c – a           # 3 - 2 = 1
a / b           # 整数除以浮点数，运算以浮点数为准，2 / 2.3 = 0.8695652173913044
a / c           # Python2中，整数除法，向下取整 2 / 3 = 0
a ** c          # a的c次方，结果为8
a += 1          # Python中没有i++的用法，自增用+=
c -= 3          # c变成0了
d = 'Hello'
d + ' world!'   # 相当于字符串拼接，结果为'Hello world!'
d += ' "world"!'# 相当于把字符串接在当前字符串尾，d变为'Hello "world"!'
e = r'\n\t\\'
print(e)        # '\\n\\t\\\\'

Python中的布尔值和逻辑的运算非常直接。

[code]a = True
b = False
a and b     # False
a or b      # True
not a       # False

==, !=和is在Python2中使用Python3中的一些特性都是用from future import来实现。

[code]from __future__ import division     # 使用Python3中的除法

 4.模块导入

import是利用Python中各种强大库的基础，比如要计算cos(π)的值，可以有下面4种方式：

[code]# 直接导入Python的内置基础数学库
import math
print(math.cos(math.pi))

# 从math中导入cos函数和pi变量
from math import cos, pi
print(cos(pi))

# 如果是个模块，在导入的时候可以起个别名，避免名字冲突或是方便懒得打字的人使用
import math as m
print(m.cos(m.pi))

# 从math中导入所有东西
from math import *
print(cos(pi))

一般来说最后一种方式不是很推荐，因为不知道import导入的名字里是否和现有对象名已经有冲突，很可能会不知不觉覆盖了现有的对象。

二、容器

1.列表

[code]a = [1, 2, 3, 4]
b = [1]
c = [1]
d = b
e = [1, "Hello world!", c, False]
print(id(b), id(c))                 # (194100040L, 194100552L)
print(id(b), id(d))                 # (194100040L, 194100040L)
print(b == c)                       # True
f = list("abcd")
print(f)                            # ['a', 'b', 'c', 'd']
g = [0]*3 + [1]*4 + [2]*2       # [0, 0, 0, 1, 1, 1, 1, 2, 2]

因为变量其实是个引用，所以对列表而言也没什么不同，所以列表对类型没什么限制。也正因为如此，和变量不同的是，即使用相同的语句赋值，列表的地址也是不同的，在这个例子中体现在id(b)和id(c)不相等，而内容相等。列表也可以用list()初始化，输入参数需要是一个可以遍历的结构，其中每一个元素会作为列表的一项。“*”操作符对于列表而言是复制，最后一个语句用这种办法生成了分段的列表。

列表的基本操作有访问，增加，删除，和拼接：

[code]a.pop()             # 把最后一个值4从列表中移除并作为pop的返回值
a.append(5)         # 末尾插入值，[1, 2, 3, 5]
a.index(2)          # 找到第一个2所在的位置，也就是1
a[2]                # 取下标，也就是位置在2的值，也就是第三个值3
a += [4, 3, 2]      # 拼接，[1, 2, 3, 5, 4, 3, 2]
a.insert(1, 0)      # 在下标为1处插入元素0，[1, 0, 2, 3, 5, 4, 3, 2]
a.remove(2)         # 移除第一个2，[1, 0, 3, 5, 4, 3, 2]
a.reverse()         # 倒序，a变为[2, 3, 4, 5, 3, 0, 1]
a[3] = 9            # 指定下标处赋值，[2, 3, 4, 9, 3, 0, 1]
b = a[2:5]          # 取下标2开始到5之前的子序列，[4, 9, 3]
c = a[2:-2]         # 下标也可以倒着数，方便算不过来的人，[4, 9, 3]
d = a[2:]           # 取下标2开始到结尾的子序列，[4, 9, 3, 0, 1]
e = a[:5]           # 取开始到下标5之前的子序列，[2, 3, 4, 9, 3]
f = a[:]            # 取从开头到最后的整个子序列，相当于值拷贝，[2, 3, 4, 9, 3, 0, 1]
a[2:-2] = [1, 2, 3] # 赋值也可以按照一段来，[2, 3, 1, 2, 3, 0, 1]
g = a[::-1]     # 也是倒序，通过slicing实现并赋值，效率略低于reverse()
a.sort()
print(a)            # 列表内排序，a变为[0, 1, 1, 2, 2, 3, 3]

因为列表是有顺序的，所以和顺序相关的操作是列表中最常见的，首先我们来打乱一个列表的顺序，然后再对这个列表排序：

[code]import random
a = range(10)                 # 生成一个列表，从0开始+1递增到9
print(a)                       # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
random.shuffle(a)             # shuffle函数可以对可遍历且可变结构打乱顺序
print(a)                       # [4, 3, 8, 9, 0, 6, 2, 7, 5, 1]
b = sorted(a)                 #临时排序，a的顺序没变
print(b)                       # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
c = sorted(a, reverse=True)
print(c)                       # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
a.sort()
print (a)   #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 永久排序

2.元祖

元组和列表有很多相似的地方，最大的区别在于不可变，还有如果初始化只包含一个元素的tuple和列表不一样，因为语法必须明确，所以必须在元素后加上逗号。另外直接用逗号分隔多个元素赋值默认是个tuple，这在函数多返回值的时候很好用：

[code]a = (1, 2)
b = tuple(['3', 4]) # 也可以从列表初始化
c = (5,)
print(c)            # (5,)
d = (6)
print(d)            # 6
e = 3, 4, 5
print(e)            # (3, 4, 5)

3.集合

集合是一种很有用的数学操作，比如列表去重，或是理清两组数据之间的关系，集合的操作符和位操作符有交集，注意不要弄混：

[code]A = set([1, 2, 3, 4])
B = {3, 4, 5, 6}
C = set([1, 1, 2, 2, 2, 3, 3, 3, 3])
print(C)        # 集合的去重效果，set([1, 2, 3])
print(A | B)    # 求并集，set([1, 2, 3, 4, 5, 6])
print(A & B)    # 求交集，set([3, 4])
print(A - B)    # 求差集，属于A但不属于B的，set([1, 2])
print(B - A)    # 求差集，属于B但不属于A的，set([5, 6])
print(A ^ B)    # 求对称差集，相当于(A-B)|(B-A)，set([1, 2, 5, 6])

4.字典

字典是一种非常常见的“键-值”(key-value)映射结构，键无重复，一个键不能对应多个值，不过多个键可以指向一个值。还是通过例子来了解，构建一个名字->年龄的字典，并执行一些常见操作：

[code]a = {'Tom': 8, 'Jerry': 7}
print(a['Tom'])             # 8
b = dict(Tom=8, Jerry=7)    # 一种字符串作为键更方便的初始化方式
print(b['Tom'])             # 8
if 'Jerry' in a:            # 判断'Jerry'是否在keys里面
print(a['Jerry'])        # 7
print(a.get('Spike'))       # None，通过get获得值，即使键不存在也不会报异常
a['Spike'] = 10
a['Tyke'] = 3
a.update({'Tuffy': 2, 'Mammy Two Shoes': 42})
print(a.values())   # dict_values([8, 2, 3, 7, 10, 42])
print(a.pop('Mammy Two Shoes'))     # 移除'Mammy Two Shoes'的键值对，并返回42
print(a.keys())     # dict_keys(['Tom', 'Tuffy', 'Tyke', 'Jerry', 'Spike'])

注意到初始化字典和集合很像，的确如此，集合就像是没有值只有键的字典。既然有了人名到年龄的映射，也许你立马想到是否可以给字典排序？在Python3.6之前，这个问题是错误的，字典是一种映射关系，没有顺序。当然了，如果要把(键, 值)的这种对进行排序，是没有问题的，前提是先把字典转化成可排序的结构，items()或者iteritems()可以做到这件事，接上段代码继续：

[code]b = a.items()
print(b)  # [('Tuffy', 2), ('Spike', 10), ('Tom', 8), ('Tyke', 3), ('Jerry', 7)]
from operator import itemgetter
c = sorted(a.items(), key=itemgetter(1))
print(c)  # [('Tuffy', 2), ('Tyke', 3), ('Jerry', 7), ('Tom', 8), ('Spike', 10)]
d = sorted(a.iteritems(), key=itemgetter(1))
print(d)  # [('Tuffy', 2), ('Tyke', 3), ('Jerry', 7), ('Tom', 8), ('Spike', 10)]
e = sorted(a)
print(e)  # 只对键排序，['Jerry', 'Spike', 'Tom', 'Tuffy', 'Tyke']

items()可以把字典中的键值对转化成一个列表，其中每个元素是一个tuple，tuple的第一个元素是键，第二个元素是值。变量c是按照值排序，所以需要一个操作符itemgetter，去位置为1的元素作为排序参考，如果直接对字典排序，则其实相当于只是对键排序。字典被当作一个普通的可遍历结构使用时，都相当于遍历字典的键。

因为上上段代码中用到了iteritems()，所以这里顺带提一下迭代器（iterator），迭代器相当于一个函数，每次调用都返回下一个元素，从遍历的角度来看就和列表没有区别了。iteritems()就是一个迭代器，所以效果一样，区别是迭代器占用更少内存，因为不需要一上来就生成整个列表。一般来说，如果只需要遍历一次，用迭代器是更好的选择，若是要多次频繁从一个可遍历结构中取值，且内存够，则直接生成整个列表会更好。当然，用迭代器生成一个完整列表并不麻烦，所以有个趋势是把迭代器作为默认的可遍历方式，比如前面我们使用过用来生成等差数列列表的range()，在Python2中对应的迭代器形式是xrange()。在Python3中，range()就不再产生一个列表了，而是作为迭代器，xrange()直接没了。

三、分支和循环

1.for循环

[code]a = ['This', 'is', 'a', 'list', '!']
b = ['This', 'is', 'a', 'tuple', '!']
c = {'This': 'is', 'an': 'unordered', 'dict': '!'}

# 依次输出：'This', 'is', 'a', 'list', '!'
for x in a:
print(x)

# 依次输出：'This', 'is', 'a', 'tuple', '!'
for x in b:
print(x)

# 键的遍历。不依次输出：'This', 'dict', 'an'
for key in c:
print(key)

# 依次输出0到9
for i in range(10):
print(i)
names = ["Rick", "Daryl", "Glenn"]

# 依次输出下标和名字
for i, name in enumerate(names):
print(i, name)
words = ["This", "is", "not", "recommended"]

# not pythonic :(
for i in xrange(len(words)):
print(words[i])

2.if和分支结构

[code]pets =['dog', 'cat', 'droid', 'fly']

for pet in pets:
if pet == 'dog':        # 狗粮
food = 'steak'      # 牛排
elif pet == 'cat':      # 猫粮
food = 'milk'       # 牛奶
elif pet == 'droid':    # 机器人
food = 'oil'        # 机油
elif pet == 'fly':      # 苍蝇
food = 'sh*t'       #
else:
pass
print(food)

3..while循环

[code]i = 0
while i < 100:  # 笑100遍
print("ha")

while True:     # 一直笑
print("ha")

四、函数

1.语法

Python 定义函数使用 def 关键字，一般格式如下：

[code]def 函数名（参数列表）:
函数体

[code]# 计算面积函数
def area(width, height):
return width * height

def print_welcome(name):
print("Welcome", name)

print_welcome("Runoob")
w = 4
h = 5
print("width =", w, " height =", h, " area =", area(w, h))

2.参数传递

在 python 中，类型属于对象，变量是没有类型的：

[code]a=[1,2,3]

a="Runoob"

可更改(mutable)与不可更改(immutable)对象

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

• 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
• 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：

• 不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
• 可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

[code]#python 传不可变对象实例
def ChangeInt( a ):
a = 10

b = 2
ChangeInt(b)
print( b ) # 结果是 2
#传可变对象实例
def changeme( mylist ):
"修改传入的列表"
mylist.append([1,2,3,4])
print ("函数内取值: ", mylist)
return

# 调用changeme函数
mylist = [10,20,30]
changeme( mylist )
print ("函数外取值: ", mylist)
'''
函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
函数外取值:  [10, 20, 30, [1, 2, 3, 4]]
'''

3.匿名函数

python 使用 lambda 来创建匿名函数。

所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

• lambda 只是一个表达式，函数体比 def 简单很多。
• lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
• lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
• 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

lambda 函数的语法只包含一个语句，如下：

[code]lambda [arg1 [,arg2,.....argn]]:expression

[code]# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2

# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))
'''
相加后的值为 :  30
相加后的值为 :  40
'''

4.变量作用域

Python 中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的。

变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。Python的作用域一共有4种，分别是：

• L （Local） 局部作用域
• E （Enclosing） 闭包函数外的函数中
• G （Global） 全局作用域
• B （Built-in） 内建作用域

以 L –> E –> G –>B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内建中找。

[code]x = int(2.9)  # 内建作用域

g_count = 0  # 全局作用域
def outer():
o_count = 1  # 闭包函数外的函数中
def inner():
i_count = 2  # 局部作用域

Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这些语句内定义的变量，外部也可以访问。

[code]if True:
msg = 'I am from Runoob'

print msg
#'I am from Runoob'

5.全局变量和局部变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。

[code]total = 0 # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
#返回2个参数的和."
total = arg1 + arg2 # total在这里是局部变量.
print ("函数内是局部变量 : ", total)
return total

#调用sum函数
sum( 10, 20 )
print ("函数外是全局变量 : ", total)
'''
函数内是局部变量 :  30
函数外是全局变量 :  0
'''

6.global 和 nonlocal关键字

当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了。

[code]num = 1
def fun1():
global num  # 需要使用 global 关键字声明
print(num)
num = 123
print(num)
fun1()
print(num)
'''
函数内是局部变量 :  30
函数外是全局变量 :  0
'''
#如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字。
def outer():
num = 10
def inner():
nonlocal num   # nonlocal关键字声明
num = 100
print(num)
inner()
print(num)
outer()
'''
100
100
'''

五、面向对象

Python从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容易的。本章节我们将详细介绍Python的面向对象编程。

1.面向对象技术简介

• 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
• 方法：类中定义的函数。
• 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
• 数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
• 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
• 局部变量：定义在方法中的变量，只作用于当前实例的类。
• 实例变量：在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
• 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
• 实例化：创建一个类的实例，类的具体对象。
• 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

2.类定义

[code]class ClassName:
<statement-1>
.
.
.
<statement-N>

3.类对象 

类对象支持两种操作：属性引用和实例化。

属性引用使用和 Python 中所有的属性引用一样的标准语法：obj.name。

类对象创建后，类命名空间中所有的命名都是有效属性名。

[code]class MyClass:
"""一个简单的类实例"""
i = 12345
def f(self):
return 'hello world'

# 实例化类
x = MyClass()

# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i)
print("MyClass 类的方法 f 输出为：", x.f())
'''
MyClass 类的属性 i 为： 12345
MyClass 类的方法 f 输出为： hello world
'''

类有一个名为 __init__() 的特殊方法（构造方法），该方法在类实例化时会自动调用。类定义了 __init__() 方法，类的实例化操作会自动调用 __init__() 方法。当然， __init__() 方法可以有参数，参数通过 __init__() 传递到类的实例化操作上。

[code]class Complex:
def __init__(self, realpart, imagpart):
self.r = realpart
self.i = imagpart
x = Complex(3.0, -4.5)
print(x.r, x.i)   # 输出结果：3.0 -4.5

self代表类的实例，而非类

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。

[code]class Test:
def prt(self):
print(self)
print(self.__class__)

t = Test()
t.prt()
'''
<__main__.Test instance at 0x100771878>
__main__.Test
'''

4.类成员

类的成员可以分为三大类：字段、方法和属性。

注：所有成员中，只有普通字段的内容保存对象中，即：根据此类创建了多少对象，在内存中就有多少个普通字段。而其他的成员，则都是保存在类中，即：无论对象的多少，在内存中只创建一份。

字段

字段包括：普通字段和静态字段，他们在定义和使用中有所区别，而最本质的区别是内存中保存的位置不同，

• 普通字段属于对象
• 静态字段属于类
• 静态字段在内存中只保存一份
• 普通字段在每个对象中都要保存一份

[code]#【普通字段需要通过对象来访问】【静态字段通过类访问】，在使用上可以看出普通字段和静态字段的归属是不同的。
class Province:

# 静态字段
country ＝ '中国'

def __init__(self, name):

# 普通字段
self.name = name

# 直接访问普通字段
obj = Province('河北省')
print obj.name

# 直接访问静态字段
Province.country

方法

在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。

[code]#类定义
class people:
#定义基本属性
name = ''
age = 0
#定义私有属性,私有属性在类外部无法直接进行访问
__weight = 0
#定义构造方法
def __init__(self,n,a,w):
self.name = n
self.age = a
self.__weight = w
def speak(self):
print("%s 说: 我 %d 岁。" %(self.name,self.age))

# 实例化类
p = people('runoob',10,30)
p.speak()  #runoob 说: 我 10 岁。

方法包括：普通方法、静态方法和类方法，三种方法在内存中都归属于类，区别在于调用方式不同。

• 普通方法：由对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self；
• 类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls；
• 静态方法：由类调用；无默认参数；

[code]class Foo:

def __init__(self, name):
self.name = name
def ord_func(self):
""" 定义普通方法，至少有一个self参数 """

# print self.name
print '普通方法'

@classmethod
def class_func(cls):
""" 定义类方法，至少有一个cls参数 """

print '类方法'

@staticmethod
def static_func():
""" 定义静态方法 ，无默认参数"""

print '静态方法'

# 调用普通方法
f = Foo()
f.ord_func()

# 调用类方法
Foo.class_func()

# 调用静态方法
Foo.static_func()

相同点：对于所有的方法而言，均属于类（非对象）中，所以，在内存中也只保存一份。

不同点：方法调用者不同、调用方法时自动传入的参数不同。

属性

Python中的属性其实是普通方法的变种。

由属性的定义和调用要注意一下几点：

• 定义时，在普通方法的基础上添加 @property 装饰器；
• 定义时，属性仅有一个self参数
• 调用时，无需括号
             方法：foo_obj.func()
             属性：foo_obj.prop

注意：属性存在意义是：访问属性时可以制造出和访问字段完全相同的假象

        属性由方法变种而来，如果Python中没有属性，方法完全可以代替其功能。

[code]class Foo:

def func(self):
pass

# 定义属性
@property
def prop(self):
pass
# ############### 调用 ###############
foo_obj = Foo()

foo_obj.func()
foo_obj.prop   #调用属性

属性的定义有两种方式：

• 装饰器 即：在方法上应用装饰器
• 静态字段 即：在类中定义值为property对象的静态字段 

(1)装饰器方式：在类的普通方法上应用@property装饰器

我们知道Python中的类有经典类和新式类，新式类的属性比经典类的属性丰富。（ 如果类继object，那么该类是新式类 ）
经典类，具有一种@property装饰器。

[code]# ############### 定义 ###############
class Goods:

@property
def price(self):
return "wupeiqi"
# ############### 调用 ###############
obj = Goods()
result = obj.price  # 自动执行 @property 修饰的 price 方法，并获取方法的返回值

新式类，具有三种@property装饰器。

[code]# ############### 定义 ###############
class Goods(object):

@property
def price(self):
print '@property'

@price.setter
def price(self, value):
print '@price.setter'

@price.deleter
def price(self):
print '@price.deleter'

# ############### 调用 ###############
obj = Goods()
obj.price          # 自动执行 @property 修饰的 price 方法，并获取方法的返回值
obj.price = 123    # 自动执行 @price.setter 修饰的 price 方法，并将  123 赋值给方法的参数
del obj.price      # 自动执行 @price.deleter 修饰的 price 方法

注：经典类中的属性只有一种访问方式，其对应被 @property 修饰的方法
      新式类中的属性有三种访问方式，并分别对应了三个被@property、@方法名.setter、@方法名.deleter修饰的方法

由于新式类中具有三种访问方式，我们可以根据他们几个属性的访问特点，分别将三个方法定义为对同一个属性：获取、修改、删除。

(2)静态字段方式，创建值为property对象的静态字段。

property的构造方法中有个四个参数

• 第一个参数是方法名，调用 

  对象.属性

   时自动触发执行方法
• 第二个参数是方法名，调用 

  对象.属性 ＝ XXX

   时自动触发执行方法
• 第三个参数是方法名，调用 

  del 对象.属性

   时自动触发执行方法
• 第四个参数是字符串，调用 

  对象.属性.__doc__

   ，此参数是该属性的描述信息

[code]class Goods(object):

def __init__(self):
# 原价
self.original_price = 100
# 折扣
self.discount = 0.8

def get_price(self):
# 实际价格 = 原价 * 折扣
new_price = self.original_price * self.discount
return new_price

def set_price(self, value):
self.original_price = value

def del_price(self, value):
del self.original_price

PRICE = property(get_price, set_price, del_price, '价格属性描述...')

obj = Goods()
obj.PRICE         # 获取商品价格
obj.PRICE = 200   # 修改商品原价
del obj.PRICE     # 删除商品原价

5.继承

Python 同样支持类的继承，如果一种语言不支持继承，类就没有什么意义。

[code]class DerivedClassName(BaseClassName1):
<statement-1>
.
.
.
<statement-N>

需要注意圆括号中基类的顺序，若是基类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 即方法在子类中未找到时，从左到右查找基类中是否包含方法。BaseClassName（示例中的基类名）必须与派生类定义在一个作用域内。

[code]#类定义
class people:
#定义基本属性
name = ''
age = 0
#定义私有属性,私有属性在类外部无法直接进行访问
__weight = 0
#定义构造方法
def __init__(self,n,a,w):
self.name = n
self.age = a
self.__weight = w
def speak(self):
print("%s 说: 我 %d 岁。" %(self.name,self.age))

#单继承示例
class student(people):
grade = ''
def __init__(self,n,a,w,g):
#调用父类的构函
people.__init__(self,n,a,w)
self.grade = g
#覆写父类的方法
def speak(self):
print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))

s = student('ken',10,60,3)
s.speak()   #ken 说: 我 10 岁了，我在读 3 年级

6.多继承

 Python同样有限的支持多继承形式。

[code]class DerivedClassName(Base1, Base2, Base3):
<statement-1>
.
.
.
<statement-N>

需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 即方法在子类中未找到时，从左到右查找父类中是否包含方法。

[code]#!/usr/bin/python3

#类定义
class people:
#定义基本属性
name = ''
age = 0
#定义私有属性,私有属性在类外部无法直接进行访问
__weight = 0
#定义构造方法
def __init__(self,n,a,w):
self.name = n
self.age = a
self.__weight = w
def speak(self):
print("%s 说: 我 %d 岁。" %(self.name,self.age))

#单继承示例
class student(people):
grade = ''
def __init__(self,n,a,w,g):
#调用父类的构函
people.__init__(self,n,a,w)
self.grade = g
#覆写父类的方法
def speak(self):
print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))

#另一个类，多重继承之前的准备
class speaker():
topic = ''
name = ''
def __init__(self,n,t):
self.name = n
self.topic = t
def speak(self):
print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))

#多重继承
class sample(speaker,student):
a =''
def __init__(self,n,a,w,g,t):
student.__init__(self,n,a,w,g)
speaker.__init__(self,n,t)

test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同，默认调用的是在括号中排前地父类的方
#我叫 Tim，我是一个演说家，我演讲的主题是 Python

 7.方法重写

如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法。

[code]class Parent:        # 定义父类
def myMethod(self):
print ('调用父类方法')

class Child(Parent): # 定义子类
def myMethod(self):
print ('调用子类方法')

c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法
'''
调用子类方法
调用父类方法
'''

8.类属性与方法 

类的私有属性

       __private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

类的方法

      在类地内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self，且为第一个参数，self 代表的是类的实例。self 的名字并不是规定死的，也可以使用 this，但是最好还是按照约定是用 self。

类的私有方法

    __private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类地外部调用。self.__private_methods。

[code]class JustCounter:
__secretCount = 0  # 私有变量
publicCount = 0    # 公开变量

def count(self):
self.__secretCount += 1
self.publicCount += 1
print (self.__secretCount)

counter = JustCounter()
counter.count()
counter.count()
print (counter.publicCount)
print (counter.__secretCount)  # 报错，实例不能访问私有变量
'''
1
2
2
Traceback (most recent call last):
File "test.py", line 16, in <module>
print (counter.__secretCount)  # 报错，实例不能访问私有变量
AttributeError: 'JustCounter' object has no attribute '__secretCount'
'''

class Site:
def __init__(self, name, url):
self.name = name       # public
self.__url = url   # private

def who(self):
print('name  : ', self.name)
print('url : ', self.__url)

def __foo(self):          # 私有方法
print('这是私有方法')

def foo(self):            # 公共方法
print('这是公共方法')
self.__foo()

x = Site('菜鸟教程', 'www.runoob.com')
x.who()        # 正常输出
x.foo()        # 正常输出
x.__foo()      # 报错

9.类的专有方法：

• __init__ : 构造函数，在生成对象时调用
• __del__ : 析构函数，释放对象时使用
• __repr__ : 打印，转换
• __setitem__ : 按照索引赋值
• __getitem__: 按照索引获取值
• __len__: 获得长度
• __cmp__: 比较运算
• __call__: 函数调用
• __add__: 加运算
• __sub__: 减运算
• __mul__: 乘运算
• __truediv__: 除运算
• __mod__: 求余运算
• __pow__: 乘方

举例：__call__对象后面加括号，触发执行

[code]class Foo:

def __init__(self):
pass

def __call__(self, *args, **kwargs):

print '__call__'

obj = Foo() # 执行 __init__
obj()       # 执行 __call__

10.运算符重载

Python同样支持运算符重载，我们可以对类的专有方法进行重载。

[code]class Vector:
def __init__(self, a, b):
self.a = a
self.b = b

def __str__(self):
return 'Vector (%d, %d)' % (self.a, self.b)

def __add__(self,other):
return Vector(self.a + other.a, self.b + other.b)

v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)  #Vector(7,8)

11.反射

python中的反射功能是由以下四个内置函数提供：hasattr、getattr、setattr、delattr，改四个函数分别用于对对象内部执行：检查是否含有某成员、获取成员、设置成员、删除成员。

[code]class Foo(object):

def __init__(self):
self.name = 'wupeiqi'

def func(self):
return 'func'

obj = Foo()

# #### 检查是否含有成员 ####
hasattr(obj, 'name')
hasattr(obj, 'func')

# #### 获取成员 ####
getattr(obj, 'name')
getattr(obj, 'func')

# #### 设置成员 ####
setattr(obj, 'age', 18)
setattr(obj, 'show', lambda num: num + 1)

# #### 删除成员 ####
delattr(obj, 'name')
delattr(obj, 'func')

六、迭代器与生成器

1.迭代器

迭代是Python最强大的功能之一，是访问集合元素的一种方式。

迭代器是一个可以记住遍历的位置的对象。

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

迭代器有两个基本的方法：iter() 和 next()。

字符串，列表或元组对象都可用于创建迭代器。

[code]list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
print (next(it))   # 输出迭代器的下一个元素 1
print (next(it))   #2

#迭代器对象可以使用常规for语句进行遍历
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
for x in it:
print (x, end=" ") #1 2 3 4

#使用 next() 函数
import sys         # 引入 sys 模块

list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象

while True:
try:
print (next(it))
except StopIteration:
sys.exit()
'''
1
2
3
4
'''

2.创建一个迭代器

把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__() 。

如果你已经了解的面向对象编程，就知道类都有一个构造函数，Python 的构造函数为 __init__(), 它会在对象初始化的时候执行。

__iter__() 方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 __next__() 方法并通过 StopIteration 异常标识迭代的完成。

__next__() 方法（Python 2 里是 next()）会返回下一个迭代器对象。

创建一个返回数字的迭代器，初始值为 1，逐步递增 1。

[code]class MyNumbers:
def __iter__(self):
self.a = 1
return self

def __next__(self):
x = self.a
self.a += 1
return x

myclass = MyNumbers()
myiter = iter(myclass)

print(next(myiter)) #1
print(next(myiter)) #2
print(next(myiter)) #3
print(next(myiter)) #4
print(next(myiter)) #5

3.StopIteration

StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，在 __next__() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。

[code]class MyNumbers:
def __iter__(self):
self.a = 1
return self

def __next__(self):
if self.a <= 20:
x = self.a
self.a += 1
return x
else:
raise StopIteration

myclass = MyNumbers()
myiter = iter(myclass)

for x in myiter:
print(x)

4.生成器

在 Python 中，使用了 yield 的函数被称为生成器（generator）。

跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。

在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。

调用一个生成器函数，返回的是一个迭代器对象。

[code]#使用 yield 实现斐波那契数列
import sys

def fibonacci(n): # 生成器函数 - 斐波那契
a, b, counter = 0, 1, 0
while True:
if (counter > n):
return
yield a
a, b = b, a + b
counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成

while True:
try:
print (next(f), end=" ")
except StopIteration:
sys.exit()
#0 1 1 2 3 5 8 13 21 34 55

七、装饰器

1.闭包函数

python是一种面向对象的编程语言，在python中一切皆对象，这样就使得变量所拥有的属性，函数也同样拥有。这样我们就可以理解在函数内创建一个函数的行为是完全合法的。这种函数被叫做内嵌函数，这种函数只可以在外部函数的作用域内被正常调用，在外部函数的作用域之外调用会报错。 而如果内部函数里引用了外部函数里定义的对象（甚至是外层之外，但不是全局变量），那么此时内部函数就被称为闭包函数。闭包函数所引用的外部定义的变量被叫做自由变量。闭包从语法上看非常简单，但是却有强大的作用。闭包可以将其自己的代码和作用域以及外部函数的作用结合在一起。

[code]def count():
a = 1
b = 1
def sum():
c = 1
return a + c  # a - 自由变量
return sum

总结：闭包函数主要是满足两点：函数内部定义的函数；引用了外部变量但非全局变量。

2.python装饰器

   python装饰器本质上就是一个函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外的功能，装饰器的返回值也是一个函数对象（函数的指针）。装饰器函数的外部函数传入我要装饰的函数名字，返回经过修饰后函数的名字；内层函数（闭包）负责修饰被修饰函数。

• 实质： 是一个函数
• 参数：是你要装饰的函数名（并非函数调用）
• 返回：是装饰完的函数名（也非函数调用）
• 作用：为已经存在的对象添加额外的功能
• 特点：不需要对对象做任何的代码上的变动

     装饰器最大的作用就是对于我们已经写好的程序，我们可以抽离出一些雷同的代码组建多个特定功能的装饰器，这样我们就可以针对不同的需求去使用特定的装饰器，这时因为源码去除了大量泛化的内容而使得源码具有更加清晰的逻辑。

3.函数装饰器

[code]import time

def decorator(func):
def wrapper(*args, **kwargs):
start_time = time.time()
func()
end_time = time.time()
print(end_time - start_time)

return wrapper

@decorator
def func():
time.sleep(0.8)

func() # 函数调用
# 输出：0.800644397735595

4.类方法的函数装饰器

[code]import time

def decorator(func):
def wrapper(me_instance):
start_time = time.time()
func(me_instance)
end_time = time.time()
print(end_time - start_time)
return wrapper

class Method(object):

@decorator
def func(self):
time.sleep(0.8)

p1 = Method()
p1.func() # 函数调用

5.类装饰器

[code]class Decorator(object):
def __init__(self, f):
self.f = f
def __call__(self):
print("decorator start")
self.f()
print("decorator end")

@Decorator
def func():
print("func")

func()

要使用类装饰器必须实现类中的__call__()方法，就相当于将实例变成了一个方法。

八、标准库 

1.OS模块　

提供对操作系统进行调用的接口。

[code]os.getcwd()# 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")  # 改变当前脚本工作目录；相当于shell下cd
os.curdir  # 返回当前目录: ('.')
os.pardir  # 获取当前目录的父目录字符串名：('..')
os.makedirs('dirname1/dirname2')    # 可生成多层递归目录
os.removedirs('dirname1')    # 若目录为空，则删除，并递归到上一级目录，
#如若也为空，则删除，依此类推
os.mkdir('dirname')    # 生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname')    # 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname')    # 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()  # 删除一个文件
os.rename("oldname","newname")  # 重命名文件/目录
os.stat('path/filename')  # 获取文件/目录信息
os.sep    # 输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
os.linesep    # 输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
os.pathsep    # 输出用于分割文件路径的字符串
os.name    # 输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")  # 运行shell命令，直接显示
os.environ  # 获取系统环境变量
os.path.abspath(path)  # 返回path规范化的绝对路径
os.path.split(path)  # 将path分割成目录和文件名二元组返回
os.path.dirname(path)  # 返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.basename(path) #  返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。
#即os.path.split(path)的第二个元素
os.path.exists(path)  # 如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path)  # 如果path是绝对路径，返回True
os.path.isfile(path) #  如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path)  # 如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[, path2[, ...]])  # 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path) # 返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path) #  返回path所指向的文件或者目录的最后修改时间

2.sys模块

[code]sys.argv           #命令行参数List，第一个元素是程序本身路径
sys.exit(n)        #退出程序，正常退出时exit(0)
sys.version        #获取Python解释程序的版本信息
sys.maxint         #最大的Int值
sys.path           #返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform       #返回操作系统平台名称
sys.stdout.write('please:')
val = sys.stdin.readline()[:-1]

九、标准输入输出

1.打印到屏幕

产生输出的最简单方法是使用print语句，可以通过用逗号分隔零个或多个表达式。这个函数传递表达式转换为一个字符串。

[code]print ("Python is really a great language,", "isn't it?")
#Python is really a great language, isn't it?

2.读取键盘输入

Python2中有两个内置的函数可从标准输入读取数据，它默认来自键盘。这些函数分别是：input() 和 raw_input()。 
但在Python3中，raw_input()函数已被弃用。此外， input() 函数是从键盘作为字符串读取数据，不论是否使用引号(”或“”)。 

[code]x=input("请输入x=")
y=input("请输入y=")
z=x+y
print("x+y="+z)
'''
请输入x=111
请输入y=222
x+y=111222
'''
#input的返回值永远是字符串，当我们需要返回int型时需要使用int(input())的形式。
x=int(input("请输入x="))
y=int(input("请输入y="))
z=x+y
print("x+y=",z)
'''
请输入x=111
请输入y=222
x+y= 333
'''

3.格式化输出

一般来说，我们希望更多的控制输出格式，而不是简单的以空格分割。这里有两种方式： 
第一种是由你自己控制。使用字符串切片、连接操作以及 string 包含的一些有用的操作。 

第二种是使用str.format()方法。用法：它通过

{}

和

:

来代替传统

%

方式

• 使用位置参数

要点：从以下例子可以看出位置参数不受顺序约束，且可以为{},只要format里有相对应的参数值即可,参数索引从0开，传入位置参数列表可用*列表的形式。

[code]li = ['hoho',18]
'my name is {} ,age {}'.format('hoho',18)#'my name is hoho ,age 18'
'my name is {1} ,age {0}'.format(10,'hoho')#'my name is hoho ,age 10'
'my name is {1} ,age {0} {1}'.format(10,'hoho')#'my name is hoho ,age 10 hoho'
'my name is {} ,age {}'.format(*li)#'my name is hoho ,age 18'

• 使用关键字参数

要点：关键字参数值要对得上，可用字典当关键字参数传入值，字典前加**即可。

[code] hash = {'name':'hoho','age':18}
'my name is {name},age is {age}'.format(name='hoho',age=19)#'my name is hoho,age is 19'
'my name is {name},age is {age}'.format(**hash)#'my name is hoho,age is 18'

•  填充与格式化

格式：

{0:[填充字符][对齐方式 <^>][宽度]}.format()

[code]'{0:*>10}'.format(20)  ##右对齐 '********20'
'{0:*<10}'.format(20)  ##左对齐 '20********'
'{0:*^10}'.format(20)  ##居中对齐  '****20****'

• 精度与进制

[code]'{0:.2f}'.format(1/3) #'0.33'
'{0:b}'.format(10)    #二进制 '1010'
'{0:o}'.format(10)     #八进制 '12'
'{0:x}'.format(10)     #16进制 'a'
'{:,}'.format(12369132698)  #千分位格式化 '12,369,132,698'

• 使用索引

[code]'name is {0[0]} age is {0[1]}'.format(li) #'name is hoho age is 18

十、 文件IO

Python提供了基本的功能和必要的默认操作文件的方法。使用一个 file 对象来做大部分的文件操作。

1.open 函数

在读取或写入一个文件之前，你必须使用 Python 内置open()函数来打开它。 该函数创建一个文件对象，这将被用来调用与它相关的其他支持方式。 

[code]file object = open(file_name [, access_mode][, buffering])

 下面是参数的详细信息： 
file_name: 文件名(file_name )参数是包含您要访问的文件名的字符串值。 
access_mode: access_mode指定该文件已被打开，即读，写，追加等方式。可能值的完整列表，在表中如下。这是可选的参数，默认文件访问模式是读(r)。 

buffering: 如果该缓冲值被设置为0，则表示不使用缓冲。如果该缓冲值是1，则在访问一个文件进行时行缓冲。如果指定缓冲值大于1的整数，缓冲使用所指示的缓冲器大小进行。如果是负数，缓冲区大小是系统默认的(默认行为)。

2.file 对象属性 

file.closed：如果文件被关闭返回true，否则为false 
file.mode ：返回文件打开访问模式 
file.name ：返回文件名

[code]# Open a file
fo = open("foo.txt", "wb")
print ("Name of the file: ", fo.name)
print ("Closed or not : ", fo.closed)
print ("Opening mode : ", fo.mode)
fo.close()
print ("Closed or not : ", fo.closed)
'''
Name of the file:  foo.txt
Closed or not :  False
Opening mode :  wb
Closed or not :  True
'''

3.file对象的方法

• f.read()  为了读取一个文件的内容，调用 f.read(size), 这将读取一定数目的数据, 然后作为字符串或字节对象返回。
• f.readline() 会从文件中读取单独的一行。换行符为 ‘\n’。f.readline() 如果返回一个空字符串, 说明已经已经读取到最后一行。
• f.readlines()  将返回该文件中包含的所有行。 
• f.write()   f.write(string) 将 string 写入到文件中, 然后返回写入的字符数。
• f.tell()  返回文件对象当前所处的位置, 它是从文件开头开始算起的字节数。
• f.seek()  如果要改变文件当前的位置, 可以使用 f.seek(offset, from_what) 函数。

[code]''''
foo.txt
Hello World！
Hello Python！
'''
# 打开一个文件
f = open("foo.txt", "r",encoding= 'UTF-8')
str = f.read()
print(str)
'''
Hello World！
Hello Python！
'''
str = f.readline()
print(str) #Hello World！

str = f.readlines()
print(str) #['Hello World！\n', 'Hello Python！']

#另一种方式是迭代一个文件对象然后读取每行
for line in f:
print(line, end='')
'''
Hello World！
Hello Python！
'''
num = f.write( "Python 是一个非常好的语言。\n是的，的确非常好!!\n" )
print(num)#29
'''
Python 是一个非常好的语言。
是的，的确非常好!!
'''

# 关闭打开的文件
f.close()