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再传输到浏览器