python 学习笔记

python学习必看！python学习笔记思维导图，涵盖python的转义、变量和计算三大基本语法，list和tuple两类列表，if、for和while三种条件判断形式，函数的定义、调用详细介绍，以及切片、迭代、列表生成式等高级特性等内容，还有多种字符编码详细介绍

Python

基本语法

转义

\n换行、\t制表符

r''不转义

'''...'''多行



变量

变量本身类型不固定的语言称之为动态语言

布尔值

用and、or和not运算

字符串

以Unicode编码

ord()获取字符的整数表示，chr()把编码转换为对应的字符

对bytes类型的数据用带b前缀的单引号或双引号

x = b'ABC'

str.encode()方法可以编码为指定的bytes

>>> 'ABC'.encode('ascii') b'ABC' >>> '中文'.encode('utf-8') b'\xe4\xb8\xad\xe6\x96\x87'

str.decode()把bytes变为str

在bytes中，无法显示为ASCII字符的字节，用\x##显示

如果bytes中只有一小部分无效的字节，可以传入errors='ignore'忽略错误的字节：

b'\xe4\xb8\xad\xff'.decode('utf-8', errors='ignore')

格式化



格式化整数和浮点数还可以指定是否补0和整数与小数的位数(补0时,需用0起头)

print('%2d-%02d' % (3, 1)) print('%.2f' % 3.1415926)

%%来转义一个%

format()

>>> 'Hello, {0}, 成绩提升了 {1:.1f}%'.format('小明', 17.125) 'Hello, 小明, 成绩提升了 17.1%'

不可变变量

字符串、数字、tuple

计算

除法

'/'除法计算结果是浮点数

'//'称为地板除，两个整数的除法仍然是整数

列表

list

classmates = ['Michael', 'Bob', 'Tracy']

可变有序列表LIST=[]

len(list)方法查询长度

可以通过正/负索引查询元素

正索引: >>> classmates[0] 'Michael' 负索引: >>> classmates[-2] 'Bob'

添加、删除元素的方法

LIST.append('STR')---添加末尾

LIST.insert(INDEX, 'STR')---插入指定位置

LIST.pop()---删除末尾

LIST.pop(INDEX)---删除指定位置

LIST[INDEX] = 'STR'---替换指定位置

list的元素也可以是另一个list,从而构成二维乃至更高维数组

tuple

classmates = ('Michael', 'Bob', 'Tracy')

不可变有序列表TUPLE=()

定义一个只有1个元素的tuple，必须在元素后加上逗号---t = (1,)

没有添加、删除、替换元素的方法。但是如果是list元素，可以修改list中的元素

range()函数

可以生成一个整数序列

dict

d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}

dict内部存放的顺序和key放入的顺序是没有关系的

判断key是否存在

KEY in DICT

DICT.get(KEY)---如果key不存在，可以返回None，或者自己指定的value

>>> d.get('Thomas') >>> d.get('Thomas', -1) -1

删除---DICT.pop(KEY)

key必须是不可变对象

set

set([1, 2, 3]) 或者{1, 2, 3}

要创建一个set，需要提供一个list作为输入集合

无序的key集合，不能储存value，没有重复的key

两个set可以做数学意义上的交集、并集（$、|）

条件判断

if

if <条件判断1>: <执行1> elif <条件判断2>: <执行2> elif <条件判断3>: <执行3> else: <执行4>

for x in ...

while

函数

定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:

空函数：用pass语句占位

返回多个值

def move(x, y, step, angle=0): nx = x + step * math.cos(angle) ny = y - step * math.sin(angle) return nx, ny x, y = move(100, 100, 60, math.pi / 6)

实际上，Python函数返回的仍然是单一值，不过这个单一值是一个tuple，多个变量可以同时接收一个tuple，按位置赋给对应的值

参数

默认参数

在声明函数时,将常用的参数提前设置好固定的值,平时调用函数时,如果该默认参数不需改动,则不需填写相应的参数

必选参数在前，默认参数在后

默认参数必须指向不变对象,可以用None这个不变对象来实现

def add_end(L=None): if L is None: L = [] L.append('END') return L

可变参数

参数前面加了一个*号,在函数内部，参数numbers接收到的是一个tuple.调用该函数时，可以传入任意个参数，包括0个参数(许你在list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去)

>>> nums = [1, 2, 3] >>> calc(*nums)

关键字参数

允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。这些关键字参数在函数内部自动组装为一个dict

可以只传入必选参数

参数前面加了**

>>> extra = {'city': 'Beijing', 'job': 'Engineer'} >>> person('Jack', 24, **extra)

命名关键字参数

限制关键字参数的名字

需要一个特殊分隔符*，;*后面的参数被视为命名关键字参数

def person(name, age, *, city, job):

如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了

def person(name, age, *args, city, job):

命名关键字参数必须传入参数名

以有缺省值，从而简化调用

参数组合

必选参数、默认参数、可变参数、命名关键字参数和关键字参数

高级特性

切片:取一个list或tuple的部分元素

LIST[n1:n2:step]；n1指索引，n2指数量,setp绝对值大小决定了切取数据时的步长，而正负号决定了切取方向

倒数切片LIST[-n1:-n2]；-n1指数量，-n2指倒数索引

只写[:]就可以原样复制一个list

tuple也可以用切片操作，只是操作的结果仍是tuple

字符串也可以切片,返回结果仍是字符串

迭代

dict迭代

for key in d: for value in d.values() for k, v in d.items()

是通过collections模块的Iterable类型判断一个对象是可迭代对象

>>> from collections import Iterable >>> isinstance('abc', Iterable)

内置的enumerate函数可以把一个list变成索引-元素对,实现下标循环

for i, value in enumerate(['A', 'B', 'C']):

列表生成式

[x * x for x in range(1, 11)]；把要生成的元素x * x放到前面，后面跟for循环

for循环后面还可以加上if判断； [x * x for x in range(1, 11) if x % 2 == 0]

还可以使用两层循环，可以生成全排列；[m + n for m in 'ABC' for n in 'XYZ']

生成器---一边循环一边计算的列表

g = (x * x for x in range(10))；与列表的区别仅在于最外层的[]和()

可以通过next()函数获得generator的下一个返回值，但是不常使用。而是通过for循环迭代

如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator

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的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行

迭代器

直接作用于for循环的对象统称为可迭代对象：Iterable

可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator

生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator;把list、dict、str等Iterable变成Iterator可以使用iter()函数

Iterator对象表示的是一个数据流，可以把这个数据流看做是一个有序序列，但却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据，所以Iterator的计算是惰性的

for循环本质上就是通过不断调用next()函数

函数式编程

高阶函数---接收另一个函数作为参数

map()函数---接收两个参数，一个是函数，一个是Iterable，并把结果作为新的Iterator返回

>>> def f(x): ... return x * x ... >>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9]) >>> list(r) [1, 4, 9, 16, 25, 36, 49, 64, 81]

reduce()把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算

>>> from functools import reduce >>> def add(x, y): ... return x + y ... >>> reduce(add, [1, 3, 5, 7, 9])

filter()

也接收一个函数和一个序列,把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素

函数返回的是一个Iterator

sorted()

sorted()函数也是一个高阶函数，它还可以接收一个key函数来实现自定义的排序

>>> sorted([36, 5, -12, 9, -21], key=abs) [5, 9, -12, -21, 36]

要进行反向排序，不必改动key函数，可以传入第三个参数reverse=True

返回函数

返回函数不要引用任何循环变量，或者后续会发生变化的变量

def count(): def f(j): def g(): return j*j return g fs = [] for i in range(1, 4): fs.append(f(i)) # f(i)立刻被执行，因此i的当前值被传入f() return fs

闭包

装饰器

函数对象有一个__name__属性，可以拿到函数的名字

>>> f.__name__ 'now'

增强now()函数的功能，但又不希望修改函数的定义，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）

本质上，decorator就是一个返回函数的高阶函数

借助Python的@语法，把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')

经过decorator装饰之后的函数，它们的__name__会改变

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)

把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单

创建偏函数时，实际上可以接收函数对象、*args和**kw这3个参数

模块

引入了按目录来组织模块的方法，称为包（Package）

每一个包目录下面都会有一个__init__.py的文件，这个文件是必须存在的

__init__.py可以是空文件，也可以有Python代码，因为__init__.py本身就是一个模块，而它的模块名就是包名

作用域通过_前缀来实现变量的私有化

面向对象

类和实例

class后面紧接着是类名，即Student，类名通常是大写开头的单词，紧接着是(object)，表示该类是从哪个类继承下来的，

class Student(object): pass

构造函数__init__

第一个参数永远是self

访问限制

把属性的名称前加上两个下划线__

不能直接访问因为Python解释器对外把__name变量改成了_类名__name

变量名类似__xxx__的，也就是以双下划线开头，并且以双下划线结尾的，是特殊变量，特殊变量是可以直接访问的，不是private变量

以一个下划线开头的实例变量名，这样的实例变量外部是可以访问的,但是不推荐

获取对象信息

dir()获得一个对象的所有属性和方法,返回一个包含字符串的list

配合getattr()、setattr()以及hasattr()，我们可以直接操作一个对象的状态

面向对象高级编程

__slots__

限制实例的属性

class Student(object): __slots__ = ('name', 'age')

__slots__定义的属性仅对当前类实例起作用，对继承的子类是不起作用的

@property

把一个方法变成属性调用

class Student(object): @property def score(self): return self._score @score.setter def score(self, value): if not isinstance(value, int): raise ValueError('score must be an integer!') if value < 0 or value > 100: raise ValueError('score must between 0 ~ 100!') self._score = value

定制类

__str__()

定制print()返回的字符串

__repr__()

定制调试器返回的字符串

__iter__()

个类想被用于for ... in循环，就必须实现一个__iter__()方法，该方法返回一个迭代对象，for循环就会不断调用该迭代对象的__next__()方法拿到循环的下一个值，直到遇到StopIteration错误时退出循环

__getitem__()\__setitem__()

像list那样按照下标取出元素

通过传入的参数类型不同，自己定义的类表现得和Python自带的list、tuple、dict

__getattr__()

方法

数据类型检查

isinstance(x, (int, float))

字符编码

8个比特（bit）作为一个字节（byte）,所以，一个字节能表示的最大的整数就是255,两个字节可以表示的最大整数是65535

ASCII

1个字节表示1个字符

127个字符

GB2312

中文

Unicode

4个字节

浪费储存空间

UTF-8

可变长编码,1-6字节

ASCII是其中一部分,解决兼容问题

应用

在计算机内存中，统一使用Unicode编码，当需要保存到硬盘或者需要传输的时候，就转换为UTF-8编码。

用记事本编辑的时候，从文件读取的UTF-8字符被转换为Unicode字符到内存里，编辑完成后，保存的时候再把Unicode转换为UTF-8保存到文件：

浏览网页的时候，服务器会把动态生成的Unicode内容转换为UTF-8再传输到浏览器