Python3.0入门知识思维导图

不了解Python3.0？没关系，看这里，有这一张思维导图就够啦！Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。Python的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。初级学习要点，入门必备。下图包括了Python的基础知识、函数相关、高级特性、函数式编程等四大内容。

Python3.7

• 基础知识
  • 数据类型和变量
    • （None）空值：类似于java中的Null
    • （inf）无限大：浮点数超过范围
  • 字符串和编码
    • ASCII编码
      • 1个字节
      • 特点：只支持英文字母和数字
    • Unicode编码
      • 2个字节
      • 特点：支持各种语言的文字，但即便是英文字母也得占2个字节
    • UTF-8（可变长编码）
      • 英文字母：1个字节
      • 汉字：3个字节
      • 生僻字符：4-6个字节
      • 特点：支持任何文字，可变长度编码，占用内存最小
    • API
      • ord()：获取单个字符的整数表示
      • chr()：编码转换成字符
      • len()：获取字符长度
      • encode():指定编码类型
    • 占位符
      • %% 百分号标记
      • %n 存储输出字符的数量放进参数列表的下一个变量中
      • %s 字符串
      • %d 有符号整数(十进制)
      • %u 无符号整数(十进制)
      • %o 无符号整数(八进制)
      • %x 无符号整数(十六进制)
      • %c 字符及其ASCII码
      • %e 浮点数字(科学计数法)
      • %E 浮点数字(科学计数法，用E代替e)
      • %f 浮点数字(用小数点符号)
      • %g 浮点数字(根据值的大小采用%e或%f)
      • %G 浮点数字(类似于%g)
      • %p 指针(用十六进制打印值的内存地址)
      • %X 无符号整数(十六进制大写字符)
    • format()
      • 'Hello, {0}, 成绩提升了 {1:.1f}%'.format('小明', 17.125)
  • list和tuple
    • list[]（列表，相当于数组）
      • pop(i):删除列表第i位,无参数就删除最后一位
      • insert(i,str):把元素插入到指定的位置
      • append():追加元素到末尾
    • tuple()(元组,不可变列表)
      • 区别和()的奇异,只有一个值的时加逗号(1,)
      • tuple不变的是指向，tuple里的list内容是可以改变
  • dict和set
    • dict(字典，相当于对象)
      • 判断属性是否存在
        • in：key in dict
        • get(key，df):第二个参数设置查询失败后返回的默认值
      • pop(key):删除一个属性
    • set([list])(有key值，无value,无序不重复)
      • add(key)
      • remove(key)
      • 两个set可以做数学意义上的交集、并集等操作
  • 循环
    • while型循环
    • for..in循环
• 函数相关
  • 空函数
    • def nop(): pass
  • 返回多个值（实际是返回tuple）
    • return nx, ny
  • 参数
    • 默认参数
      • def power(x, n=2):
      • 默认参数必须指向不变对象！(像list之类保存的是内存地址的容易出错)
        • def add_end(L=None): if L is None: L = [] L.append('END') return L
    • 可变参数
      • 在参数前面加*，相当于向函数内传递list/tuple
        • def calc(*numbers): sum = 0 for n in numbers: sum = sum + n * n return sum
      • 在list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去
        • >>> nums = [1, 2, 3] >>> calc(*nums) 14
    • 关键字参数
      • 在参数前面加**，相当于向函数内传递dict
        • def person(name, age, **kw): print('name:', name, 'age:', age, 'other:', kw)
      • 在list或tuple前面加一个*号，把dict的元素变成可变参数传进去
        • >>> extra = {'city': 'Beijing', 'job': 'Engineer'} >>> person('Jack', 24, **extra) name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
    • 命名关键字参数
      • 需要一个特殊分隔符*，*后面的参数被视为命名关键字参数
        • def person(name, age, *, city, job): print(name, age, city, job)
          • person('Jack', 24, city='Beijing', job='Engineer') Jack 24 Beijing Engineer
      • 参数中已经定义可变参数，后面跟着的命名关键字参数就不再需要*
        • def person(name, age, *args, city, job): print(name, age, args, city, job)
      • 命名关键字参数可以有缺省值
    • 参数组合
      • 参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数
• 高级特性
  • 切片
    • L[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3
    • 第一个索引是0，还可以省略L[:3]
    • 支持负数（倒数）
    • [:]什么参数都不写可以复制list
    • 可以对list,tuple,字符串使用
  • 迭代
    • for ... in
    • list（val,index）
      • for i, value in enumerate(['A', 'B', 'C'])
    • 迭代dict
      • key
        • >>> d = {'a': 1, 'b': 2, 'c': 3} >>> for key in d: ... print(key)
      • value
        • for value in d.values()
      • (key,value)
        • for k, v in d.items()
    • 判断是否可以迭代
      • >>> from collections import Iterable >>> isinstance('abc', Iterable) # str是否可迭代 True >>> isinstance([1,2,3], Iterable) # list是否可迭代 True >>> isinstance(123, Iterable) # 整数是否可迭代 False
  • 列表生成式
    • [参数运算 for循环 判断条件]
      • [x * x for x in range(1, 11) if x % 2 == 0]
    • 多层循环
      • [m + n for m in 'ABC' for n in 'XYZ']
    • 缺点：数据大了消耗内存
  • 生成器(generator)
    • 书写格式同列表生成式，区别是[]变（）
    • generator保存的是算法，每次调用next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误
    • 用for循环迭代，无需手动调用next()，也不会抛出StopIteration的错误
    • generator函数/yield
      • def fib(max): n, a, b = 0, 0, 1 while n < max: yield b a, b = b, a + b n = n + 1 return 'done'
  • 列表生成式和生成器(generator)的区别
    • 列表生成式需要先range一个范围，数值很大就会浪费很多内存。generator则是一个一个遍历，省内存
  • 迭代器
    • Iterable（可迭代对象）
      • 凡是可作用于for循环的对象都是Iterable类型
        • 一类是集合数据类型，如list、tuple、dict、set、str等
        • 一类是generator，包括生成器和带yield的generator function
      • 集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象
      • 使用isinstance()判断一个对象是否是Iterable对象
        • >>> from collections import Iterable >>> isinstance([], Iterable) True >>> isinstance({}, Iterable) True >>> isinstance('abc', Iterable) True >>> isinstance((x for x in range(10)), Iterable) True >>> isinstance(100, Iterable) False
    • Iterator(迭代器)
      • 不但可以作用于for循环，可以被next()函数调用并不断返回下一个值的对象称为迭代器
      • isinstance()判断一个对象是否是Iterator对象
        • >>> from collections import Iterator >>> isinstance((x for x in range(10)), Iterator) True >>> isinstance([], Iterator) False >>> isinstance({}, Iterator) False >>> isinstance('abc', Iterator) False
    • Python的for循环本质上就是通过不断调用next()函数实现的
    • 可迭代对象和迭代器的区别：可迭代对象有长度，迭代器是一个惰性计算的序列，只能通过next()获取下一个数据，长度是不确定的。
• 函数式编程
  • 高阶函数
    • 变量可以指向函数
    • 函数名也是变量
      • 把内置函数名赋值，内存地址变了就无法调用该函数
    • 函数可以当参数
    • API
      • map(fn,Iterable):遍历每个元素做运算
      • reduce(fn(x,y),Iterable):把上一次运算的结果和下一个元素运算
      • filter(fn,Iterable):传入的函数依次作用于每个元素，根据返回值是True还是False决定保留还是丢弃该元素
        • filter()函数返回的是一个Iterator,list(filter(fn,Iterable))返回列表
      • sorted(list,key=fn, reverse=True)排序
  • 返回函数
    • return fn
    • 闭包
      • 返回闭包时牢记一点：返回函数不要引用任何循环变量，或者后续会发生变化的变量。
  • 匿名函数
    • 关键字lambda表示匿名函数，冒号前面的x表示函数参数
      • list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
    • 匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果
  • 装饰器
    • 在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）
    • def log(func): def wrapper(*args, **kw): print('call %s():' % func.__name__) return func(*args, **kw) return wrapper
      • @log def now(): print('2015-3-25')
        • @log相当于now = log(now)
    • decorator本身需要传入参数
      • def log(text): def decorator(func): def wrapper(*args, **kw): print('%s %s():' % (text, func.__name__)) return func(*args, **kw) return wrapper return decorator
        • @log('execute') def now(): print('2015-3-25')
          • @log相当于now = log('execute')(now)
    • now.__name__的返回值从func变成了wrapper
      • 不需要编写wrapper.__name__ = func.__name__
        • 使用@functools.wraps(func)
          • import functools def log(func): @functools.wraps(func) def wrapper(*args, **kw): print('call %s():' % func.__name__) return func(*args, **kw) return wrapper
  • 偏函数
    • 作用：包装函数固定几个参数生成新的函数，方便调用
    • functools.partial生成偏函数
      • >>> import functools >>> int2 = functools.partial(int, base=2) >>> int2('1000000')