python-基础巩固

字符串和编码

• python中字符串替换replace()
  • Str.replace(old,new[,max])
  • Old 将被替换的字符串
  • New 新字符串
  • max 替换不超过max次
• python中大小写敏感，True，False才是布尔值正确写法，python中没有null，有类型None
•  但是在python3中能识别true，false
  
• Ord()获取字符(包括中文)的整数表示
• Chr()把编码转换成对应的字符
• “string”.encode(‘’ascii)将字符串(纯英文)转换为bytes格式
  • b’string’
  • ‘中文’.encode(‘utf-8’)将含有中文的字符转换为字节流，注意含有中文不能使用ascii进行编码
• ‘bytes’.decode(‘ascii’)进行解码
  • ‘bytes’.decode(‘utf-8’,errors=‘ignore’),参数errors=ignore忽略bytes中的一小部分无效的字节
  • len()计算包含多少字符/字节（参数是字符串/bytes）
• String.find(str1)查找字符串，找到返回下标，否则返回-1
  • string.find(str1,1)从下标为1处开始查找
• 字典
  • D.has_key() true/false，在python3中已经被废除
  • key in d.keys()判断键值是否存在
  • d.get(‘key’),如果key不存在返回none，也可以自己设定不存在返回的值d.get(‘key’,-1)
  • d.pop(‘key’) 删除元素
• 函数
  • abs（）返回绝对值
  • max（）返回最大值
  • int（）转换为int类型
  • float（）转换为float类型
  • str（）转换为str类型
  • bool（）转化为布尔类型
  • Map（f,[]）,f是函数[]是一个元组
  • reduce（）
  • filter（）接受一个函数和一个序列，把传入的函数依次作用于每个元素然后根据返回的值绝对是否丢弃该元素
  • sorted（list[]）对列表排序
    • sorted([],key=abs)
  • isinstance(x,str)判断x是不是字符串
  • 可以返回函数
  • 函数可以同时返回多个值，相当于一个元组tuple
  • 匿名函数 使用关键字lambda表示匿名函数
• 切片
• list或tuple操作
  • 取出前3个数 range(3) L[:3]
  • 取出后10个数L[-10:]
  • 前10个数每两个取一个L[:10:2]
  • 所有数，每5个取一个L[::5]
• 列表
  • list.append()
  • list(range(1,11))

安装第三方模块

• pip install <name>

面向对象编程

• 构造函数def __init__(self):
  • 注意每个成员函数必须加self参数
• 可以自由给实例绑定属性
  • 创建实例的时候认为必须绑定的属性强制填写进去，所以在定义类的时候__init__构造函数中，将必须的属性绑定进去
• 数据封装
  • 在python中的数据封装，就是通过在类中创建成员函数访问属性
• 访问限制，限制外部访问
  • __<name>使用双下划线，表示私有属性，方法
  • _单下划线表示受保护的属性/方法
  • __name__一般是系统属性方法

class classname：

• 继承
  • class classname（baseclass[,baseclass2[,baseclass3]]）：
• 多态
• 判断某个变量是某个类型
  • isinstance(a,类型)
  • type（）获取对象变量
• dir（对象）获取一个对象的所有属性和方法
• getattr(obj，’y’[,404]) 获取属性值不存在抛出异常，第三个参数如果设置了则抛出第三个参数
• setattr(obj，’x’，’value’) 设置一个属性
• hasattr(obj,’x’)obj是否含有x属性，返回布尔值

使用__slots__

• 当创建了一个class实例，我们可以给实例灵活的绑定任何属性和方法
  • s=student（），s.name=‘mich’ …
  • S.set_age=methodtype(set_age,s),给实例绑定一个方法，需要引入types模块
  • 但是，给一个实例绑定方法，对另一个实例是不起作用的
• 给class绑定方法 Student.set_score=set_score
  • 这样每个实例都可以使用该方法
• 在定义类的时候
  • class student：

__slots__=(‘name’,age)#用tuple定义允许绑定的属性名称

• • 这样在类外只能绑定name和age属性，其他的会报错
  • __solts__只对当前类实例起作用，对继承的子类是不起作用的

使用__str__()  __repr__()定制类

• 在类中定义__str__()具体作用参考廖雪峰教程
• __getitem__()
• __setitem__()
• __getattr__() 当调用了不存在属性时，会触发本函数
• __call__() 定义了本函数可以直接对实例进行调用

枚举类

• 引入模块from enum import Enum
• 定义枚举类型时需要继承Enum类
• 元类
• type（）
  • 使用type(‘Hello’，（object），dict（hello=fn）)函数创建类
  • 参数class名称 继承的父类集合 class方法名称和函数绑定
• metaclass

types模块

• 可以用来判断是否为一个对象或变量等
  • type(fn)==types.FunctionType 判断fn是否为一个函数
  • type(abs)==types.BuiltinFunctionType 判断abs是否为系统函数
  • type(lambda x: x)==types.LambdaType 是否为匿名方法
  • type((x for x in range(10)))==types.GeneratorType

错误处理

• try…except…finally
  • 所有错误都是从BaseException类中派生的
  • raise ValueError()

文件读写

• f=open(‘filename’,’r’)打开一个文件
  • 文件不存在返回一个IOError错误
  • 读取二进制文件时打开方式’rb’
  • 读取非utf-8文件时，需要指定第三个参数，encoding=‘gbk’
• f.read()将文件内容全部读取
• f.close()关闭文件
• 使用try…finally…将代码包裹，保证文件流能正确关闭
• 或者使用with open（’filename’,’r’）as f:
  • print(f.read())
  • 自动调用close（）函数
• f.read(size)读取指定大小
• F.readline()每次读一行
• F.readlines()一次读取所有并按行返回list
• f.write(string)
• String.strip()去除末尾换行空格

StringIO

• from io import StringIO使用前引入
• 在内存中读写
• f=StringIO()
  • 可以在创建的时候就写入f=StringIO(‘Hello’)
• f.write(‘hello’)向内存中写数据
• F.getvalue()获取写入后的str
• f.readline()

BytesIO

• from io import BytesIO
• 如果内存中操作的是二进制必须使用BytesIO
• f=BytesIO()
• F.write(‘中文’.encode(‘utf-8’))
• print(f.getvalue());

文件和目录操作

• import os引入模块
• os.name;获取操作系统类型
• os.uname().操作系统详细信息
• os.environ 环境变量
  • Os.environ.get(‘PATH’)获取某个环境变量的值
• 操作文件和目录的函数一部分放在os模块中，一部分放在os.path模块中
• os.path.abspath(‘.’)查看当前目录的绝对路径
• Os.path.join(‘path’,’newdir’)将新目录的完整路径表示出来
• os.mkdir(‘path/newdir’)创建新目录
• os.rmdir(‘dir’) 删除一个目录
• 注意在把两个路径合并时，使用os.path.join()函数这样可以正确处理不同操作系统的路径分隔符 
  • os.path.split(‘’)拆分为两部分，第二部分是最后级别的目录或文件名
  • os.path.splittext(‘’)将文件路径和扩展名拆分开
  • 这些合并和拆分路径并不要求目录和文件要真实存在，只对字符串进行操作
• os.rename(‘test.txt’,’test.py’)对文件重命名
• Os.remove(‘’)删掉文件
• shutil模块中提供了copyfile（）复制文件的函数
• os.path.isdir()判断是不是目录，返回布尔值
• Os.path.isfile()判断是否为一个存在的文件，返回布尔值
• Os.path.exists(path)判断path是否存在
• Os.path.isabs(path)判断path是否为绝对路径
• os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素
• Os.path.basename(path) 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
• Os.path.normpath()规范化路径
• Os.listdir()返回的是一个列表，指定目录下的条目名称

序列化（pickling）

• 从内存中变成可存储或传输的过程称之为序列化
• 把序列化对象重新读到内存里称之为反序列化
• import pickle引入模块
• pickle.dumps(d),把任意对象序列化一个bytes，然后写入文件
• pickle.dump(d,f)直接把对象序列化后写入一个文件。f为打开的文件流
• pickle.loads(d)反序列化出对象，需要先读一个bytes的d
• pickle.load(f),f为打开的文件流

Json

• Json.dumps(d)将python对象转化为json对象
• json.loads(json_str)将json对象转化为python对象
• 将类实例转化为json对象时，需要指定参数
  • json.dumps(d,default=lambda obj:obj.__dict__)
  • Json.dumps(d,default=funname),funname是将类属性转换为dict格式的函数
• __dict__属性是类存储属性的一个字典
• 多进程多线程

• 实现多任务
  • 多进程模式
  • 多线程模式
  • 多进程+多线程模式

线程时cpu调度的基本单位，进程时资源分配和调度的基本单位

多进程

• import os引入模块
• Os.fork()创建一个子进程
  • 返回值，如果当前是子进程返回0，如果是父进程返回子进程id
  • Os.getpid() 返回当前进程id
  • Os.getppid()返回后父进程id

• from multiprocessing import Process 引入模块
  • 在windos上不支持fork（）
  • 使用Process（）创建子进程
    • p=Process(target=funname,args=()) args中是funname的参数,必须加一个’，’号，否则会报错
  • Os.getpid()获取进程id
  • p.start() 使用start（）函数启动子进程
  • p.join()等待子进程结束后继续往下执行
• If __name__ ==‘__main__’： 当当前模块正在被执行时

-from multiprocessing import Pool引入模块 进程池方式启动大量子进程

• p=Pool(4)创建进程池对象，设置允许同时运行的进程数，默认是cpu核数
• p.apply_async(funname,args=()),启动子进程
• pool对象调用join()方法会等待所有子进程执行完毕
  • 调用join（）之前必须先调用close(),
  • 调用close()后就不能添加新的process，就可以等待所有子进程结束

子进程

• Nslookup 查询域名对应的ip
• import subprocess 引入模块，该模块可以方便地启动一个外部进程
  • Subprocess.call([‘nslookuo’,’www.python.org’])调用外部命令

进程间通信

• multiprocessing模块提供了Queue Pipes等多种方式来交换数据
• from multiprocessing import Process, Queue
• Queue.put(value)队尾插入一个项目
• queue.get(true)队头删除一个项目并返回
• p=Process()创建进程
• p.start()启动进程
• p.join()等待进程结束
• p.terminate()强行终止一个进程

多线程

• import threading引入模块
  • 启动一个线程就是把一个函数传入并创建Thread实例然后调用start（）开始执行
  • t=threading.thread(target=funname,name=‘threadname’)
  • t.start()开始执行
  • T.join() 等待执行结束
• threading.current_thread() 返回当前线程的实例
• threading.current_thread().name 返回当前线程的名字
  • 主线程名字叫mainThread
• 线程的资源是共享的，
  • lock=threading,Lock()创建一个锁
  • lock.acquire()获取锁
  • lock.release()释放锁
  • 防止死线程，使用try…finally来确保锁一定会被释放
• import threading
  • local_school=threading.local()创建全局Threadlocal对象
  • local_school.student=name 为threadlocal对象绑定属性，每个属性相当于线程的局部变量可以任意读写，且互不干扰

单线程的异步编程模型称为协程。

分布式进程？？？

• 在Thread和Process中，应当优选Process，因为Process更稳定，而且，Process可以分布到多台机器上，而Thread最多只能分布到同一台机器的多个CPU上。

正则表达式

• \转义字符
• \d数字 \w字母 \s空格
• []表示范围，[0-9a-zA-Z\_]匹配一个数字，字母或者下划线
• * + ？
• A|B 匹配A或B
• ^开头 $表示结束
• import re引入re模块
  • 使用r前缀，只是在表达式中对字符\不用再次转义（即用\\表示\）,其他特殊字符（-，*等等）还是需要转义
• Re.match(pattern,string)，匹配成功返回match对象（python3中返回匹配的字符串，早起版本返回的是地址？），失败返回none
• re.split(pattern,string)使用正则表达式切割字符串
• 分组
  • 表达式中含有括号，就是要提取的分组
  • group（n）表示匹配第n个括号中的子串，括号从1开始，m.group（0）表示原始字符串
  • m.groups()返回元组不包含原始字符串

贪婪匹配

• 贪婪匹配就是尽可能多的匹配
  • re.match(r'^(\d+)(0*)$', ‘102300').groups()
  • ('102300', '')
• 非贪婪匹配就是尽可能少的匹配
  • re.match(r'^(\d+?)(0*)$', ‘102300').groups()
  • ('1023', '00')

编译

• 使用正则表达式时，内部会干两件事
  • 编译正则表达式，如果正则表达式的字符串本身不合法，会报错
  • 用编译后的正则表达式去匹配字符串
• 如果一个正则表达式重复使用上千次，每次都编译会影响效率
• Re.telephone=re.compile(pattern) 使用compile()预编译正则表达式，生成一个预编译对象
  • re.telephone.match(string) 用这个对象点用match方法就不会再次编译正则表达式，提高效率