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')