Python基础

一、python入门
1.安装python：官网下载，傻瓜式安装，配置环境变量
2.数据类型：
整数，任意大小的整数包括负整数，十六进制用0x前缀和0-9，a-f表示。加减乘除取余 同java一样
浮点数，可以用科学计数法表示。
字符串，""或’‘括起来的文本。可以用\对"和’进行转义或在字符串前面加r，如果字符串内转义字符较多用’’’ ‘’‘括起来。\n表示换行，\表示\字符本身
布尔值，True、False;可以用and、or、not来运算。and和or是短路计算，python把0、空字符串’‘和None看成False,其他数值和非空字符串都看成True
空值，None，类似java中的null。
3.print语句：
print ‘a’, ‘b’, ‘c’ #输出是 abc
python添加对Unicode的支持，比如 print u’中文’
4.变量
变量必须是大小写英文数字和下划线的组合，且不能用数字开头，python是动态语言变量类型可以不固定。
5.list
python内置的一种数据类型是列表：list, 用[]把各种类型元素括起来就是一个list对象。
例如L=[‘a’,121,‘b’] 试试打印 print L[0] print L[1] print L[-1]
添加 L.append(‘c’) L.insert(0,‘c’)意思是将’c’添加到索引为0的位置上
删除 L.pop()删除最后一个元素，L.pop(2)删除索引为2的元素
替换 L[2]=‘d’ 或L[-1]=‘d’
tuple是另一种有序的列表，翻译为’元组’，和list类似，但它一旦创建完毕就不能修改了。例如t=(‘aa’,‘bb’) 可以获取元素，但不能增删修改元素。但是单元素时要多加个逗号避免歧义 t=(1,)
t=(‘aa’,‘bb’,[‘a’,‘b’])中的’a’,‘b’可以改成’x’,‘y’。 tuple不变的含义是指向不变。
6.if语句 for循环 while循环
python代码的缩进规则：具有相同缩进的代码被视为代码块，严格按照python的习惯写法，4个空格，不要使用TAB键，不要混写TAB和空格，否则很容易引起语法错误。:代表代码块开始，退出缩进要多敲一行回车。
if 1>0:
print ‘abc’
print ‘123’

elif 2<5:
print ‘2233’
else：
print ‘end’
#for循环
L=[‘a’,‘b’,‘c’]
for name in L:
print name
#while循环
while 2<3:
print ‘死循环’
if 1<2:
break #break用来跳出循环，continue跳出当前循环，继续下一次循环

7.Dict和Set类型
d={ ‘a’:1, ‘b’:2,‘c’:3 } {}表示这是一个dict,类似java中的map，len()可以计算任意集合的大小。特点是查找速度快占用内存大，而list的查找速度随元素的增加下降占用内存小。key-alue序对没有顺序，key不可变且不能重复。
取值,if ‘a’ in d: print d[‘a’] 或 print d.get(‘a’)
修改，即赋值
遍历，for key in d: print key

set持有一系列元素，和list很像，但set的元素不重复且无序,并且这些元素不可变，可以用在判断用户输入的元素是否有效。
创建，s=set([‘a’,‘b’,‘c’,‘c’]) 通过调用set()并传入一个list创建，有重复元素会自动去重
访问， 访问set中的某个元素实际上就是判断一个元素是否在set中， ‘a’ in s
遍历， 可以使用for循环进行遍历
更新，先s.add(‘d’) 在s.remove(‘c’) 添加时不需要判断，删除时要先判断该元素是否在set里面，如果不在删除时会报错。
8.函数
编写函数，def my_abs(x): 通过def来定义一个函数
abs函数，可以通过help(abs)查看abs函数的帮助信息
com(x,y)比较函数；int(‘123’)，str(123)转换函数
递归函数，计算n! 使用递归函数时注意防止栈溢出。
def fact(n):
if n==1:
return 1
return n * fact(n - 1)
返回多值，实际上返回的是单一值tuple,只不过省略了括号
import math
def move(x, y, step, angle):
nx = x + step * math.cos(angle)
ny = y - step * math.sin(angle)
return nx, ny
>>>x,y=move(100,100,60,math.pi/6)
>>>print x,y
定义默认参数，作用是简化调用，默认参数只能定义在必须参数的后面
定义可变参数，作用是简化调用，让一个函数可以接受任意个参数。

def power(x, n=2):
s = 1
while n > 0:
n = n - 1
s = s * x
return s

power(5)
#定义可变参数
def fn(*args):
print args

9.切片
list切片，L[0:3]取list的索引为0到索引为3的元素，包含0不包含3；list[:3]省略了0，list[:]从头到尾，L[::2]每个2个元素 取出来一个。
倒序切片，倒数第一个元素的索引是-1，包含起始索引，不包含结束索引，例如L[-2:] ,L[:-2] ,L[-3,-1] ,L[-4?2]
字符串切片，例如’abcd’[:3]，‘123’[-3:]
10.迭代
迭代，即遍历，python中的迭代通过for…in 完成，可以对集合进行迭代操作。迭代取的是元素的本身而不是元素的索引
索引迭代，对有序集合想要按索引 取值可以通过enumerate()，这个函数把list变成了tuple。
for index, name in enumerate(L):
print index, ‘-’, name
迭代dict,d.values() d.itervalues那这两个方法有何不同之处呢？

1. values() 方法实际上把一个 dict 转换成了包含 value 的list。

2. 但是 itervalues() 方法不会转换，它会在迭代过程中依次从 dict 中取出 value，所以 itervalues() 方法比 values() 方法节省了生成 list 所需的内存。

3. 打印 itervalues() 发现它返回一个 对象，这说明在Python中，for 循环可作用的迭代对象远不止 list，tuple，str，unicode，dict等，任何可迭代对象都可以作用于for循环，而内部如何迭代我们通常并不用关心。

如果一个对象说自己可迭代，那我们就直接用 for 循环去迭代它，可见，迭代是一种抽象的数据操作，它不对迭代对象内部的数据有任何要求。
迭代dict的key-value使用d.items(),和 values() 有一个 itervalues() 类似， items() 也有一个对应的 iteritems()，iteritems() 不把dict转换成list，而是在迭代过程中不断给出 tuple，所以， iteritems() 不占用额外的内存。

11.列表生成式
生成列表，range(1,11),[x*x for x in range(1,11)], 还可以加判断[x * x for x in range(1, 11) if x % 2 == 0]只有true时，才把当前的元素添加到列表中。
复杂表达式，
tds = [’%s%s’ % (name, score) for name, score in d.iteritems()]
print ‘

’
print ‘’
print ‘\n’.join(tds)
print ‘

Name	Score

’
多层表达式， [m + n for m in ‘ABC’ for n in ‘123’]翻译成循环代码如下
L = []
for m in ‘ABC’:
for n in ‘123’:
L.append(m + n)

12.函数式编程
简介，函数式，一种编程范式。
特点，把计算视为函数而非指令；
纯函数式编程：不需要变量，没有副作用，测试简单
支持高阶函数，代码简洁

			python支持的函数式编程特点，不是纯的函数式编程允许有变量
																支持高阶函数，函数也可以作为变量传入
																支持闭包，有了闭包就能返回函数
																有限度地支持匿名函数
高阶函数，能接收函数作为参数的函数。变量可以指向一个函数，函数名其实就是指向函数的变量。
map函数，python里内置的函数，接收一个函数和一个list，把这个函数依次作用在list的每个元素上，返回一个新的list。
reduce函数，接收一个函数和一个list，传入的函数必须传两个值，然后这个函数对list的每个元素反复作用，返回最终结果值。
		reduce(f, [1, 3, 5, 7, 9])，      def  f(x, y):  return x + y
		先计算头两个元素：f(1, 3)，结果为4；
		再把结果和第3个元素计算：f(4, 5)，结果为9；
		再把结果和第4个元素计算：f(9, 7)，结果为16；
		再把结果和第5个元素计算：f(16, 9)，结果为25；
		由于没有更多的元素了，计算结束，返回结果25。
filter函数，接收一个函数和一个list，这个函数会对list中的每个元素进行判断，返回True或False，过滤掉不符合条件的元素。比如删除None或者空字符串。
		def is_not_empty(s):
		return s and len(s.strip()) > 0
		filter(is_not_empty, ['test', None, '', 'str', '  ', 'END'])

自定义排序函数，可以调用sorted()函数对list进行排序，也可以对字符串进行排序，默认按照ASCII大小来比较，也可以接收一个比较函数来实现自定义排序，比较函数的定义是传入两个待比较的元素 x, y，如果 x 应该排在 y 的前面，返回 -1，如果 x 应该排在 y 的后面，返回 1。如果 x 和 y 相等，返回 0。

def reversed_cmp(x, y):
    if x > y:
        return -1
    if x < y:
        return 1
    return 0
    >>> sorted([36, 5, 12, 9, 21], reversed_cmp)
[36, 21, 12, 9, 5]

	**python中返回函数**，python不仅可以返回list,dict,str,int等数据类型，也可以返回函数。

例如，定义一个函数 f()，我们让它返回一个函数 g，可以这样写：

def f():
    print 'call f()...'
    # 定义函数g:
    def g():
        print 'call g()...'
    # 返回函数g:
    return g
仔细观察上面的函数定义，我们在函数 f 内部又定义了一个函数 g。由于函数 g 也是一个对象，函数名 g 就是指向函数 g 的变量，所以，最外层函数 f 可以返回变量 g，也就是函数 g 本身。

调用函数 f，我们会得到 f 返回的一个函数：

>>> x = f()   # 调用f()
call f()...
>>> x   # 变量x是f()返回的函数：
<function g at 0x1037bf320>
>>> x()   # x指向函数，因此可以调用
call g()...   # 调用x()就是执行g()函数定义的代码
请注意区分返回函数和返回值：

def myabs():
    return abs   # 返回函数
def myabs2(x):
    return abs(x)   # 返回函数调用的结果，返回值是一个数值
返回函数可以把一些计算延迟执行。例如，如果定义一个普通的求和函数：

def calc_sum(lst):
    return sum(lst)
调用calc_sum()函数时，将立刻计算并得到结果：

>>> calc_sum([1, 2, 3, 4])
10
但是，如果返回一个函数，就可以“延迟计算”：

def calc_sum(lst):
    def lazy_sum():
        return sum(lst)
    return lazy_sum
# 调用calc_sum()并没有计算出结果，而是返回函数:

>>> f = calc_sum([1, 2, 3, 4])
>>> f
<function lazy_sum at 0x1037bfaa0>
# 对返回的函数进行调用时，才计算出结果:

>>> f()
10
由于可以返回函数，我们在后续代码里就可以决定到底要不要调用该函数。

	闭包，	

在函数内部定义的函数和外部定义的函数是一样的，只是他们无法被外部访问：

def g():
    print 'g()...'

def f():
    print 'f()...'
    return g
将 g 的定义移入函数 f 内部，防止其他代码调用 g：

def f():
    print 'f()...'
    def g():
        print 'g()...'
    return g
但是，考察上一小节定义的 calc_sum 函数：

def calc_sum(lst):
    def lazy_sum():
        return sum(lst)
    return lazy_sum
注意: 发现没法把 lazy_sum 移到 calc_sum 的外部，因为它引用了 calc_sum 的参数 lst。

像这种内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure）。

闭包的特点是返回的函数还引用了外层函数的局部变量，所以，要正确使用闭包，就要确保引用的局部变量在函数返回后不能变。举例如下：

# 希望一次返回3个函数，分别计算1x1,2x2,3x3:
def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs

f1, f2, f3 = count()
你可能认为调用f1()，f2()和f3()结果应该是1，4，9，但实际结果全部都是 9（请自己动手验证）。

原因就是当count()函数返回了3个函数时，这3个函数所引用的变量 i 的值已经变成了3。由于f1、f2、f3并没有被调用，所以，此时他们并未计算 i*i，当 f1 被调用时：

>>> f1()
9     # 因为f1现在才计算i*i，但现在i的值已经变为3
因此，返回函数不要引用任何循环变量，或者后续会发生变化的变量。

	匿名函数，
	decorator装饰器， 定义了一个函数想在运行时动态增加功能又不想改动函数本身的代码
	无参/有参装饰器，
	完善装饰器，
	偏函数，

13.模块
模块和包的概念，包就是文件夹，模块就是xx.py文件，包也可以有多级，包下面必须有_init_.py文件而且是每层都要有。
导入模块，import math ，如果是只导入模块的几个函数 from math import pow, sin, log as logger 可通过起别名避免名称冲突。
动态导入模块，

try:
    from cStringIO import StringIO
except ImportError:
    from StringIO import StringIO

	测试新特性，在旧的版本测试新版本的特性可以导入_future_模块的某些功能实现，比如form _future_  import  division	
	安装第三方模块，内置了许多模块，还可以安装第三方模块，python提供了模块管理工具（easy_install、pip推荐使用，已内置到Python2.7.9，安装python时选择pip，打开命令窗口，输入pip install web.py     python    import web）

14.面向对象编程基础
面向对象编程，是一种程序设计范式，把程序看做不同对象的相互调用，对现实世界建立对象模型
类用于定义抽象类型 class Person(object): ，实例根据类的定义被创建出来,xiaoming=new Person(),xiaoming.name=‘xiao ming’ ,由于python是动态语言，可以直接对属性赋值，实例的属性可以像普通变量一样进行操作。初始化实例属性_init_()方法,init()方法的第一个参数必须是self。
类的属性，实例属性每个实例各自拥有，相互独立，而类的属性有且只有一份。由于类的属性是直接绑定在类上，所以，访问类的属性不需要创建实例。所有实例都可以访问到它所属的类的属性。当实例的属性和类的属性重名时，实例属性的优先级高，将屏蔽掉对类属性的访问。
实例方法，第一个参数永远是self，指向调用该方法的实例本身，其他参数和普通参数一样
实例方法其实也是属性，实际上是一个函数对象，加上括号才是方法调用。
类方法，和属性类似，方法也分实例方法和类方法，在class中定义的全部是实例方法，实例方法第一个参数self是实例本身，类方法需要加@classmethod，因为是在类上调用，而非实例上调用，因此类方法无法获得任何实例变量，只能获得类的引用。

class Person(object):
    address='earth' #类的属性
    count = 0
    def __init__(self, name, gender, birth):
        self.__name = name
        self.gender = gender
        self.birth = birth
        
    def get_name():
    	return self.__name

    @classmethod
    def how_many(cls):
        return cls.count
xiaoming = Person('Xiao Ming', 'Male', '1991-1-1')#调用时必须提供除self以外的参数。
print Person.address
print xiaoming.address
Person.address='China'#类的属性也可以动态添加和修改，修改后，实例访问的类的属性也会改变
print xiaoming.address
xiaoming.address='123'
del  xiaoming.address#删除实例的属性

#可以对实例动态添加方法,并不常用
xiaoming.get_namexx=types.MethodType(get_name,xiaoming,Person)
print xiaoming.get_namexx()

	访问限制，python对属性的权限的控制是通过属性名来实现的，如果一个属性由双下划线开头，该属性无法被外部访问；如果是以“_xxx_”的形式定义，可以被外部访问，这种定义在python的类中被称为特殊属性，有很多预定义的特殊属性可以使用，普通属性通常不要这样定义；以单下划线开头的属性“_xxx”虽然也可以被外部访问，但是按照习惯他们不应该被外部访问。

15.类的继承
继承，