Python数据类型

1.List和Tuple特点？

list创建语法：list = [1,2,3,4]
tuple创建语法：tuple = (1,2,3,4)

list是有序集合，内部元素可变化，tuple是有序的“不变”的元素集合，内部元素不可变化
list和tuple都使用索引访问内部元素  list[0],tuple[0],list[-1],tuple[-1]

list可以增（append(),insert(index,value)）、删(pop(),pop(index))、
改(list[index]=newValue)，tuple不可以，tuple所谓的“不变”是说，tuple的每个元素，指向永远
不变。即指向'a'，就不能改成指向'b'，指向一个list，就不能改成指向其他对象，但指向的这个list本
身是可变的！

使用tuple的好处：Tuple 比 list 操作速度快.如果您定义了一个值的常量集,并且唯一要用它做的是不
断地遍历它,请使用 tuple 代替 list.如果对不需要修改的数据进行 “写保护”,可以使代码更安全.使用 
tuple 而不是 list 如同拥有一个隐含的 assert 语句,说明这一数据是常量.如果必须要改变这些值,
则需要执行 tuple 到 list 的转换.

2.dict的特点？

dict的创建语法：dict = {'key':value,'key1':value1...}
改变key对应的value值：dict['ket'] = newValue
遍历dict是通过dict中的key得到value，dict是键值对元素的集合。

特点1：查找速度快，无论dictt有多少个元素，查找速度都一样,而list的查找速度随着元素增加而逐渐下降。
缺点是dic耗费内存，而list占用内存小。
特点2：dict元素无序；
特点3：dict的key不可以重复，不可变；

3.set的特点？

set是一系列不重复且无序的元素集合。
创建方式：set = set(list)  通过set方法传入list来完成set的创建。
set内部结构和ditc很像，判断一个元素是否在set中很快，set中的元素必须是不可变元素。
set可以被更新，增加（add(value)）、删除（remove(value)）

4.list / tuple切片？

切片，顾名思义，就是截取原来事物的一部分，对于list来说，指的就是截取list的一部分，当然截取list
的一部分可以一点一点取，但是python有更方便的方法。

list[start:end]  # 截取list指定位置开始到指定位置结束之间的部分，如：list[0:3]
list[:end]  # 截取从0开始到指定位置结束之间的部分，如list[:3]
list[:]  # 截取全部
list[start:end:step]  # 每几个元素取一个，也就是每隔step-1个元素取一个

倒序切片也是支持的，如  list[-3:-1]
字符串也可使用切片，如  'abcdefg'[1:3]

Python函数

1.函数定义？

在Python中，定义一个函数要使用 def 语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩
进块中编写函数体，函数的返回值用 return 语句返回。

def name(param...):
    return None

2.返回多值？

def name(param...):
    return value1,value2

实际上，函数返回多值，返回的是tuple类型的数据

3.定义函数可变参数？

可变参数的意义在于，在使用函数的时候不确定参数的个数，可以1个也可以多个，实现方法就是在定义函数
参数的时候，在参数前加 * 符号

def name(*args):

函数内部对于args的解析将会把args解析为一个tuple

程序结构

1.for循环遍历？

Python语言中的 for 循环的代码结构为：

for item in list:
    # code blow...

Python语言中的 for 循环抽象层次更高，item表示可以迭代处理的集合中的元素，而没有确定其数据类型，
对于不同的集合来说，for 循环的结构并不关心其内部元素的种类，处理结构都是相同的。

集合是指包含一组元素的数据结构，包括：
1. 有序集合：list，tuple，str和unicode；
2. 无序集合：set
3. 无序集合并且具有 key-value 对：dict

2.带索引的for循环？

for 循环中的item代表集合中的元素，而没有该元素在集合中的索引，想在循环的时候同时获得元素的索引，
可以使用enumerate函数：

for t in enumerate(list):
    index = t[0]
    item = t[1]

实现的原理就是，enumerate函数会将集合变成[(index,item)...]这样的结构，原先的item会变成带有
索引的tuple结构，因为集合这样处理之后，每个元素都是含有两个元素的tuple，那么上述循环结构也可以
写成：

for index,item in enumerate(list):
    # code blow...

函数式编程

1.高阶函数？

高阶函数指的是可以接收函数作为参数的函数，在Python语言中，函数名实际上也是变量，如下：

var = len
str = "reeves"
var(str) # 结果为 6

函数的参数是变量，函数名也可以作为参数，这样，就相当于函数作为函数参数，如下：

def method(a,b,c):
    return c(a) + c(b)
method(-3,3,abs)

2.Python内置高阶函数？

map函数, 调用语法为：map(f,list) 处理过程是对于list中的每一个元素进行f函数处理，处理之后的list
作为返回值。f函数的参数为1个。

reduce函数，调用语法为：reduce(f,list) 处理过程是对list中的元素用前面元素的处理结果接着和后面元素
再进行相同处理，f函数必须有两个参数，reduce函数还可以接收第三个参数作为处理的初始参数。

filter函数，调用语法为：filter(f,list) 处理过程为对于list中的每个元素，f函数判断是否符合条件，最后
返回符合条件的元素集合list。

sort函数，sort函数本身可以进行顺序排序，如果需要按照其他排序规则进行排序，则可以自定义排序规则/函数，
sort函数的高阶函数使用方式为：sort(f,list)，比较函数的定义是，传入两个待比较的元素 x, y，
如果 x 应该排在 y 的前面，返回 -1，如果 x 应该排在 y 的后面，返回 1。如果 x 和 y 相等，返回 0。

3.返回函数？

Python中允许在函数内部建立内部函数，而且函数名本身就是变量，则可以将函数名当做返回值返回，也就是返回
函数。

def f_out():
    def f_in():
        return None
    return f_in

上述代码就返回了一个函数，内部函数可以使用外部函数的变量，并且可以返回，但是要注意的是，在返回内部函数
时函数处于未调用状态，当函数调用时，内部函数引用的外部函数局部变量的值是其“最终状态”时的值。

def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs

f1, f2, f3 = count() # 结果为：9,9,9，因为三个函数在调用时i的值为3

4.匿名函数？

Python支持匿名函数，匿名函数书写语法为：lambda param,...: code
param为匿名函数的参数，可以多个，code是表达式，不写return，该表达式的结果就是匿名函数的返回值。

面向对象

Python语言是有着面向对象的特性，Python的类定义如下：

class ClassName(parent):
    # code blow...

关键字class，parent是该类继承的父类，一般父类为object，类名一般首字母大写，定义类之后，获取类的实例的语法为：

instance = ClassName()

Python是一门动态语言，没有编译过程，直接解释执行，在程序执行的过程中可以对程序结构进行改变，同样，类的实例在获取之后，可以动态添加对象属性，即使类中并没有定义的属性可以在程序执行时动态添加。

在类当中直接定义的属性称作类属性，如：

class Student(object):
    sex = "female" # 类属性，属于类本身

类属性和实例的属性不同，实例属性每个实例保存一份，类属性只保存一份，访问类属性可以直接使用Student.sex即可，如果实例设置和类属性相同名字的实例属性，使用instance.property访问的是实例属性，如果实例没有和类属性重名的属性，那么instance.property访问的就是类属性。

如果类有固有属性，需要在类实例化的时候就指定其值，那么可以在类中把要初始化的参数写在__init__()方法中，使用方式为：

def __init__(self,param,...):
    property = param
    ....

其中self是在类的方法中才有的参数，而且是必须有，还必须是第一个参数，这里的self代表的是类的实例，类的实例在调用类中的方法时，不需要给出此参数，直接写其他参数即可，如下写法：

instance.method(param,...)

Python会将这种写法转换成：

Class.method(instance,param,...)

下面这种写法在Python程序中也是正确的，使用下面的方法时，就需要显式地提供类的实例作为方法的第一个参数。因此在类中的方法实际调用的时候，是需要把类的实例当做参数传进去的，只是使用instance.method()的方式方便而且容易理解而已。

类之间可以继承，如下：

class Student(object):
    def __init__(self,name,school):
        self.name = name
        self.school = school

class GoodStudent(Student):
    def __init__(self,name,school,order):
        super(GoodStudent,self).__init__(name,school)
        self.order = order

继承时，在类定义中的类名之后的括号中写继承的类名即可，在子类初始化时，也就是__init__()方法中，需要使用super()方法来获取父类，然后调用父类的初始化方法，这样子类才会拥有父类的相应属性。

Python还有一些知识没有介绍，比如多重继承、装饰器，之后添上。