# python笔记
  1. python是动态语言，变量本身的类型不固定 如: 
    a=1;  
a="abc";
    这是正确的

  2. python中有两种除法 / // / 得到的总是浮点数 ,// 叫做地除法 它总是只取整数部分 如： 

    10/3
    3.3333 10//3 3

  3. 字符和编码转换 ord() chr()

  4. 由于Python的字符串类型是str，在内存中以Unicode表示，一个字符对应若干个字节。如果要在网络上传输，或者保存到磁盘上，就需要把str变为以字节为单位的bytes。 

    x=b'xyx'
  5. 以Unicode表示的str通过encode()方法可以编码为指定的bytes 
    'abc'.encode('utf-8')
  6. 如果我们从网络或磁盘上读取了字节流，那么读到的数据就是bytes。要把bytes变为str，就需要用decode()方法 
     b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf8')
  7. 字符串str长度函数len(),此函数同样适用于字节
  8. 由于Python源代码也是一个文本文件，所以，当你的源代码中包含中文的时候，在保存源代码时，就需要务必指定保存为UTF-8编码。当Python解释器读取源代码时，为了让它按UTF-8编码读取，我们通常在文件开头写上这两行： 
    #!/usr/bin/env python3
# -*- coding: utf-8 -*-
9.list api 
    list=['1','2','3']
    len(list)
    list[-1] //返回最后一个元素
    list[-2] //返回倒数第二个 依次类推
    list.append('4')  //追加元素
    list.insert(1,'5')
    list.pop() //删除最后一个
    list.pop(1) //删除索引为1的元素
10. tuple 数组 tuple一旦初始化就不能修改 如果tuple中只有一个元素要跟一个逗号如 
    t=(1,)
  1. 条件判断 
    if age>18:
    print("18")
elif age>10:
    print('10')
else :
    print('baby')
  2. 循环 
    for cell in cells
    print(cell)

while n>10
    sum = sum+n
    print(sum)
  3. dict 同java中的map 
    dict={'name':'123'}
print(dict['name'])
//判断dict中是否含有某个key
'age' in dict
//dict的get方法
print(dict.get('name')) //输出 123 
print(dict.get('age')) //None
print(dict.get('age',-1)) // -1
dict.pop('name')
dict['age']=10 //新增元素
    和list比较，dict有以下几个特点： 查找和插入的速度极快，不会随着key的增加而变慢； 需要占用大量的内存，内存浪费多。 而list相反： 查找和插入的时间随着元素的增加而增加； 占用空间小，浪费内存很少。

  4. set 

    s = set('apage')
print(s)
s1 = set([1,2,3])
s1.add(5)
s1.remove(5)
  5. 内置函数 数据类型检查可以用内置函数isinstance() 
    isinstance(123,(int,float)) //第二个参数可以是一个数组
  6. 函数可以返回多个值 
    def move(x,y){
    //处理
    return x,y
}

x,y  = move(1,2);
print(x);
print(y);


r = move(1,2);
print(r);//r=(xx,xx);返回值是tuple
  7. 函数参数 1) 定义函数时可以使用默认值，例如 
    def power(x,n=2):
    s = 1;
    while n >= 1 :
        s = x * s;
        n = n-1;
    return s
    带默认值要放到参数后面； 参数默认值问题，默认参数必须指向不变对象！ 可以使用None来避免：如 
        def add_end(L=None):
         if L is None:
             L = []
             L.append('END')
        return L
    2) 可变参数 
        def calc(*numbers):
        sum = 0
        for n in numbers:
             sum = sum + n * n
        return sum
将list或tuple作为可变参数传入

    num = [1,2,3]
    calc(*num)
    3) 关键字参数 
        def person(**kw)
        print(kw)
    4) 命名关键字参数 
        def person(a,b,*,city,job)
命名关键字需要用*号分开，*后面的参数被视为命名关键字参数
命名关键字参数可以使用默认值：

    def person(a,b,*,city='beijing',job)
    5) 小结： 默认参数一定要用不可变对象，如果是可变对象，程序运行时会有逻辑错误！ 
    要注意定义可变参数和关键字参数的语法：
*args是可变参数，args接收的是一个tuple；
**kw是关键字参数，kw接收的是一个dict。
命名的关键字参数是为了限制调用者可以传入的参数名，同时可以提供默认值。定义命名的关键字参数在没有可变参数的情况下不要忘了写分隔符*，否则定义的将是位置参数
  8. 尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。

  9. 分片操作 即截取操作，list,tuple,字符串都可以使用分片操作，例如： 

    list=[1,2,3,4,5];
list[1:3]  //截取第二个到第三个  ，索引从0开始
list[:3]  //截取前三个
list[-2:]  //截取倒数两个
list[:]   //复制
tuple=(1,2,3,4,5)
tuple[2:3]
tuple[2:3:-1]  //截取出‘子串’，然后倒序输出  如果最后一位如果为正则，则正序输出；为负，则倒序输出
  10. 迭代 1) 迭代dict 
        dict = {'a':1,'b':2,'c':3}
    //默认迭代key
    for key in dict
        print(key)
    //迭代value
    for value in dict.values()
        print(value)
    //同时迭代
    for key,value in dict.items()
        print(key,':'value)
    2） 判断元素是否可以迭代：导入collections模块的Iterable类型 
        from collections import Iterable
     isinstance('abc',Iterable) 

    //enumerate将list转换为索引-元素对 
for i,value in enumerate(['a','b','c']):
    print(i,value)
  11. 列表生成式 生成一个list列表，如 
    dict={'a':1,'b':2,'c':3]
list =[x+"="+str(y) for x,y in dict.items()]
  12. 列表生成器 列表生成器和生成式的区别在于：生成器为“（）” 而生成式是“[]” 可以使用next()函数获取generator的下一个值，当获取不到值后，会产生StopIteration异常，如： 
    generator = (x+"="+str(y) for x,y in dict.items())
next(generator)
//使用for循环
for x in generator
    print(x)
//使用函数产生一个生成器 
def  fib_generator(max):
    n,a,b = 0,0,1
    while n<max:
        yield(b)
        a,b = b, a+b
        n=n+1
    return 'done'

for x in fib_generator(5):
    print(x)
    但是用for循环调用generator时，发现拿不到generator的return语句的返回值。如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中： 
     g = fib(6)
 while True:
    try:
         x = next(g)
        print('g:', x)
    except StopIteration as e:
             print('Generator return value:', e.value)
     break
  13. 凡是可作用于for循环的对象都是Iterable类型； 凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列； 集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。
Python的for循环本质上就是通过不断调用next()函数实现的
  1. 函数式编程 1） 高阶函数：参数中含有其他函数的函数称为高阶函
    2） map/reduce
    map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。
    reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，其效果就是： 
    reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

    本文根据廖雪峰老师博客记录