Python基础与高级

类型
    Numbers(数字)：int|logn|float|complex
    布尔：true、false
    String(字符串)
    List(列表)
    Tuple(元组) 元组的元素不能修改
    Dictionary(字典)
    Set()集合，可以快速的完成对list中的元素去重复的功能
数据类型转换
    int()|long()|float()|str()|repr()对象转表达式字符串|eval()计算在字符串中的有效Python表达式,并返回一个对象
    tuple()|list()|chr()|unichr|ord|hex|oct
关键字
    and     as      assert     break     class      continue    def     del
    elif    else    except     exec      finally    for         from    global
    if      in      import     is        lambda     not         or      pass
    print   raise   return     try       while      with        yield
格式符号
    %c字符|%s字符串|%i%d%u%o%x...
输入
    raw_input()输入字符串|input()接受表达式输入
运算符
    算术运算符 + - * / //取整除 %取余 **幂
    赋值运算符 a,b=1,2
    复合赋值运算符 c *=a 相当于c = c*a
    比较(关系)运算符 == != <> > < >= <=
    逻辑运算符 and or not
判断
    if/elif/else while
循环
    for break用来结束整个循环 continue用来结束本次循环，紧接着执行下一次的循环
    break/continue只能用在循环中，除此以外不能单独使用
    break/continue在嵌套循环中，只对最近的一层循环起作用
字符串
    下标[0] 切片[起始:结束:步长]
    find() index() count() replace() split() capitalize第一个字符大写 title每个单词首字母大写
    startswith endswith lower upper ljust rjust center
    strip|lstrip|rstrip删除空白字符 rfind rindex partition按字符串切割 splitlines按行切割
    isalpha isdigit isalnum isspace join
列表
    len append列表添加元素 extend将另一个集合中的元素逐一添加到列表中 insert
    in(not in) count del根据下标进行删除 pop删除最后一个元素 remove根据元素的值进行删除
    sort reverse enumerate遍历索引和值
    +合并 *复制
元组
    下标[0] count index
字典
    get(key,default) del clear len keys values items has_key
内置函数
    cmp()比较两个值 len() max() min() del()
函数
    函数中修改全局变量，那么就需要使用global进行声明
    def printinfo(name,age=35) 带有默认值的参数一定要位于参数列表的最后面
    def fun(a,b,*args,**kwargs) 不定长参数，加了星号（*）的变量args会存放所有未命名的变量参数，args为元组；而加**的变量kwargs会存放命名参数，即形如key=value的参数， kwargs为字典
    Python中函数参数是引用传递（注意不是值传递）。对于不可变类型(字符串)，因变量不能修改，所以运算不会影响到变量自身；而对于可变类型(list)来说，函数体中的运算有可能会更改传入的参数变量
    匿名函数 lambda
文件操作
    open close write read readlines readline tell seek
    os.rename("oldname", "newname") os.remove("filename") os.mkdir("filename") os.getcwd()
    os.chdir("../")改变默认目录 os.listdir("./")获取目录列表 os.rmdir("dir")删除文件夹
    r w+ a+ ...
面向对象
    __init__()初始化函数，用来完成一些默认的设定
    __init__()方法，在创建一个对象时默认被调用，不需要手动调用
    __init__(self)中，默认有1个参数名字为self，如果在创建对象时传递了2个实参，那么__init__(self)中出了self作为第一个形参外还需要2个形参，例如__init__(self,x,y)
    __init__(self)中的self参数，不需要开发者传递，python解释器会自动把当前的对象引用传递进去
    __str__() 一个类的实例变成str
    __new__()
    __all__变量，那么也就意味着这个变量中的元素，不会被from xxx import *时导入__init__.py 控制着包的导入行为
    __del__() 删除一个对象时，python解释器也会默认调用一个方法，这个方法为__del__()方法
    __表示私有属性和私有方法
    封装
    多继承
    多态：定义时的类型和运行时的类型不一样，此时就成为多态
    @classmethod 类方法，用classmethod来进行修饰
    @staticmethod 静态方法不需要多定义参
    简单工厂模式、工厂方法模式、单例模式
    异常 try catch finally else
    动态语言：可以在运行的过程中，修改代码
    静态语言：编译时已经确定好代码，运行过程中不能修改
拷贝
    浅拷贝，a,b同时指向一个id,当其中一个修改时，另外一个也会被修改
    深拷贝，c单独开辟一个id,用来存储和a一样的内容
生成器
    一边循环一边计算的机制，称为生成器：generator,生成器函数基于yield指令，可以暂停一个函数并返回中间结果
    eg:通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。
    要创建一个generator，有很多种方法。第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：
迭代器
    迭代是访问集合元素的一种方式。迭代器是一个可以记住遍历的位置的对象。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
闭包
    在函数内部再定义一个函数，并且这个函数用到了外边函数的变量，那么将这个函数以及用到的一些变量称之为闭包
装饰器
    计数器装饰器
    

#!/usr/bin/env python
# -*- coding:utf-8 -*-
'''
 @author:yuanhua
 @datetime:2018/8/28 下午2:58
'''

# 闭包
def line_conf(a, b):
    def line(x):
        return a*x + b
    return line
# 生成器
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
def main():
    # 查询关键字
    import keyword
    print keyword.kwlist
    # 整形、字符串、列表、字典 相关操作
    digit,str_a,list_b,dict_c = 100,'abc',[1,2,3],{'name','yann'}
    print type(digit)
    print "digit:%d;\nstr:%s"%(digit,str_a)
    print str_a[::-1],str_a[1:],str_a[1:-1]
    print 'Hello I am Yann'.partition('am')
    print ''.join(map(lambda x: str(x), list_b)) #sort(key = lambda x:x['name'])
    # 读取文件
    with open('/Users/yuanhua/PycharmProjects/Test0528/zip.py', 'r') as f:
       print f.readlines()
    try:
        f = open('123.txt','r')
    except (IOError,NameError) as errorMsg:
    # except Exception as errorMsg:
        print errorMsg
    # else:
    #     print 'no error'
    finally:
        f.close()
    # 列表推导
    for i,element in enumerate(list_b):print i,element # 获取索引

    # 迭代器
    # 可迭代对象：最简单的解释：可以使用for... in ...语句进行循环的对象，就是可迭代对象（Iterable），可以使用isinstance()方法进行判断。
    from collections import Iterable
    print isinstance(list_b,Iterable)
    # 迭代器：指的是可以使用next()方法来回调的对象，可以对可迭代对象使用iter()方法，将其转换为迭代器
    print type(iter(list_b)),next(iter(dict_c)) # next方法返回下一个项目 iter返回迭代器本身

    # 生成器 L是列表，I是生成器
    L = [x*2 for x in range(5)]
    I = (x*2 for x in range(5))
    print L,type(L)
    print I,type(I),next(I),next(I),next(I),next(I),next(I)
    # for j in I:print j # 创建了一个generator后，基本上永远不会调用next()，而是通过for循环来迭代它，并且不需要关心StopIteration的错误
    from collections import Iterable
    print isinstance('abc', Iterable)
    f = fib(4)
    # for ff in f:print ff # 斐波拉契数列（Fibonacci），除第一个和第二个数外，任意一个数都可由前两个数相加得到

    print id(digit) # id来查看在内存中的地址
    # 闭包
    line1 = line_conf(1, 1) #y = x + 1
    line2 = line_conf(4, 5) #y = 4x + 5
    print(line1(5))
    print(line2(5))
    import sys
    print sys.path

    # 深拷贝和浅拷贝
    import copy
    copy_a = [1,2,3,[4,5],6]
    copy_b = copy_a #浅拷贝，a,b同时指向一个id,当其中一个修改时，另外一个也会被修改。
    copy_c = copy.deepcopy(copy_a) #深拷贝，c单独开辟一个id,用来存储和a一样的内容。
    copy_a.append(7)
    copy_a[3].append(55)
    print copy_b,copy_c

    # lambda匿名函数、map\reduce高阶函数
    print map(lambda x:x*x,list_b)

if __name__ == '__main__':
    main()