这篇博客全面总结了Python中的常用函数，包括系统函数、列表、集合、字典、字符串等数据结构的操作，以及函数、变量作用域、匿名函数、装饰器等概念。此外，还涵盖了文件操作、时间模块、正则表达式等相关知识。
系统函数
- print 输出
- input 输入
- type 查看数据类型
- del 删除
- int 整型
- str 字符串
- float 浮点型
- ord 查看字符对应的整数
- chr 查看整字对应字符
- pow 求幂
- divmod 求商和余数
- abs求绝对值
- range 产生特殊序列的对象
- enmerate 枚举对象
- counter 统计元素及次数
- round 四舍五入
- max 求最大值
- min 求最小值
- sum 求一个序列所有元素的和
- format 占位函数
- len 可以统计字符串的长度
列表函数
-
append 在列表末尾添加一个元素
-
insert 在指定下标添加个一新的元素，不覆盖原数据，原数据向后延申
-
index 查找列表中元素第一次出现的下标
-
extand 将序列中的元素添加到列表
-
remove 删除列表中的指定元素
-
del 根据下标删除列表中的元素
-
reverse 将列表逆序
-
sort 将列表升序排列
-
pop 弹出并删除列表中的元素,默认最后一个,可以指定下标
-
count 统计元素出现的个数
-
enumerate 列举
-
enumerate 遍历列表，同时给出下标和值
-
range 生成一个列表
集合的函数
- add 添加一个元素
- remove 删除元素 不存在会报错
- discard 删除元素, 不存在不会报错
- pop 随机弹出一个元素,并删除
- union 并集
- intersection 交集
- difference 差集
- isdisjoint 判断是否有交集
- issubset 判断是否是子集
- insuperset 判断是否是父集
- clear 清空元素
- abs 绝对值
字典的函数
- get 通过键,获取值,不存在返回None,可以指定默认值
- update 添加键值对,存在的就覆盖,不存在就添加
- setdefault 键存在就返回对应值，不存在先添加，再返回。值默认值None，可以指定
- popitems 随机弹出并返回一个键值对，一般是末尾的元素，字典为空会报错
- pop 删除指定的键，并返回值，一般是末尾的元素，没有会报错。
- items 返回字典的所有键值对组成（每个键值对是一个元素）列表，可以遍历，转换
字符串的函数
- splitlines 按照换行进行切割
- split 按照指定内容进行切割
- join 拼接字符串
- find 查找字符串的某个内容出现的次数
- rfind 从右边开始查找出现的次数
- count 统计字符串出现的次数
- startwith 判断字符串是否以指定内容开头
- endwith 判断是否以指定内容结尾
- upper 全部转为大写
- lower 全部转为小写
- swapcase 大小写互换
- capitalize 首字母大写
- title 每个单词首字母大写
- replace 替换指定内容
- isupper 判断是否全是小写
- isdecimal 判断是否全是数字
- istitle 判断是否每个单词首字母都大写
- isalpha 判断是否群是字母
- isalnum 判断是否全是数字或字母
- isidentifier 判断是否是合理的标识符
- ljust 左对齐，右侧填充指定内容，默认填充空格
- rjust 右对齐，左侧填充指定内容，默认填充空格
- center 居中对齐，两边填充指定内容，默认填充空格
- strip 同时去除两边的指定内容的字符串
- lstrip 去除左边的指定内容的字符
- rstrip 去除左边的指定内容的字符
函数
- return 返回
- args **kwargs 接收多余参数args 返回的是元祖，接收有属性的参数**kwargs 返回的是字典
变量的作用域
- global 修改全局变量，声明函数
- nonlocal 内部函数修改外部函数变量，声明函数
匿名函数
- lambda 匿名函数，用于简单函数的使用
装饰器
- @装饰器函数
函数判断
isfunction 判断对象是否是函数 from inspect import isfunction
callable 判断函数是否可以调用
生成器
- yield 返回yield后面的值，然后停止在这里
- next 从生成器里提取元素
迭代器
- Iterable 判断一个对象是否是可迭代对象 from collections import Iterable #isinstance(lt, Iterable)
- Iterator 判断一个对象是否是迭代器 from collections import Iterato #isinstance(lt, Iterator)
- iter 可以将迭代对象转为迭代器
高阶函数
- map 用func依次作用于iter1的每一个元素，返回一个迭代器
- filter 使用function依次作用于iterable中的每个元素中，返回值为真的元素保留下来
- reduce 使用function函数做用于sequence序列中的元素，得到的结果与下一个元素再次使用function处理， 最终得到一个结果，然后返回 from functools import reduce
- sorted 排序函数，支持升序降序，还支持任意类型的排序，返回的排序后的新列表，原列表保持不变
数学模块 math
- math.pi 打印Π
- math.e 打印一个常量
- math.ceil 向上取整
- math.floor 向下取整
- math.sqrt 求x平方根
- math.radians 把角度下转换为弧度 360 = 2Π
- math.degrees(math.pi) 把x从弧度转换成角度 一个Π是180度
随机模块 random
- random.randint 生成指定范围内的随机整数
- random.uniform 生成指定范围内的随机小数
- random.random 生成0-1的随机小数
- random.choice 从容器对象中随机挑取一个元素
- random.sample 从容器对象中随机挑取指定个数的元素，返回一个列表
- random.choices 从容器对象中挑选一个元素，返回一个列表,相当于sample提取个数为1的情况
- random.shuffle 打乱列表的元素的顺序
系统模块
- sys.argv 保存所有的命令行参数
- sys.platform 系统平台
os模块
- os.system(‘cls’) 清空屏幕
- os.system(‘calc’) 出计算器
- os.name 查看系统类型
os模块目录操作
- os.getcwd() 查看当前工作目录
- os.mkdir(‘test’) 创建目录,默认当前目录,可以指定目录,不能创建中间目录 os.mkdir(‘test/c/练习’)
- os.makedirs(‘a/b/c’) 可以创建中间目录
- os.rmdir(‘test’) 删除目录,只能删除空目录
- os.rename() 修改名称,可以修改文件名,也可以修改目录名,(old,new)
- os.listdir() 查看目录信息
- os.stat() 查看文件信息
- os.stat(‘os模块.py’).st_size 获取指定属性 字节
- os.remove 删除文件
os模块中path的操作
- path.join(‘abc/def/’,‘hello.py’) 目录拼接：目录分隔符会自动处理
- ath.dirname(‘abc/def/hello.py’) 目录提取,提取文件的上层目录
- ath.basename(os.getcwd()) 取文件名
- dir_name, file_name = path.split(‘abc/def/hello.py’ 切割文件名与路径
- file_name, ext = path.splitext(‘hello.py’) 切割文件名与后缀
- path.exists(‘aa’) 判断文件是否存在
- path.isfile() 判断是否是普通文件
- path.isbd() 判断是否是绝对路径
- path.isdir() 判断是否是目录
- path.getsize() 获取大小，仅限文件
文件读写的函数
- open 打开文件
- read 读取文件
- write 写入文件
- close 关闭文件
- readable 判断文件是否可读
- writeable 判断文件是否可写
字节流
- encode 编码
- decode 解码
环境变量
- set 设置环境变量 名称=值 获取 set 名称
- os.environ[ ] 获取指定环境变量，不存在会报错
- os.environ.get() 存在则返回对应的值，不存在则返回默认值
- os.getenv() 是os.environ.get()它的简写形式
shutil库
- shutil.copy() 拷贝文件
- shutil.copy() 拷贝目录
- shutil.rmtree 删除目录
- shutil.move 移动文件或目录
time时间模块
- time.sleep() 设置睡眠的秒数
- time.time() 获取当前时间戳
- time.locktime() 将时间戳转换为时间对象,时间带时区
- time.gmtime() 将时间转为时间对象，不带时区
- time.timezone() 0时区与当地时区的时间差（秒数）
- time.mktime(()) 将时间信息转换为时间戳
- time.strtime(’%Y-%m-%d %H:%M:%S %w %w’,local_time) 时间格式化显示，%Y：年(4位) %y：年(2位) %m：月 %d：日 %D：月/日/年 %H：时 %M：分 %S：秒 %w：星期几(1~7) %W：本周是今年的第几周
calendar日历模块
calendar.calendar() 返回某一年的日历 w:显示星期的字符数 l:内容的行高 c:两个月的水平间隔
calendar.month() 返回某个月的日历，指定年和月
calendar.issleap() 判断是否是闰年 import calendar
calendar.leapdays() 获取两个闰年之间的数量，[起始年份，结束年份）
datetime日期时间模块
date() 指定年月日 from datetime import date
date.today() 表示今天的日期
d = date.fromtimestamp() 根据时间戳创建日期
d.year, d.month, d).day 单独提取年月日信息
d.timetuple 将date转换为time.struct_time time.struct_time(tm_year=2019, tm_mon=3, tm_mday=21, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=80, tm_isdst=-1)
d.isoweekday() 获取星期几，格式：1-7
d.weekday() 获取星期:0-6
d.isoformat() 标准格式
d.issocalendar() 日历显示:(年,月,日,星期)
d.strftime(’%Y//%m//%d‘) 格式化显示
t = time(11,22,33) 创建时间对象 from datetime import time
t.hour,t.minute,t.second 单独获取时分秒
t.strftime(’%H-%M-%S’) 格式化显示
dt = datetime(2019,3,21,22,28,20) 时间日期datetime from datetime import datetime
dt.timestamp(） 转换为时间戳 dt.strftime(’%Y/%m/%d %H:%M:%S’) 格式化显示
datetime.utcnow() 当前时间,不带时区
datetime.fromtimestamp(time.time()) 根据时间戳进行转换
d = dt.date() 提取日期 dt.time() 提取时间
时间间隔timedelta
from datetime import datetime,timedelta
d1 = datetime(2019,3,11,14,19,56)
d2 = datetime(2019,3,1,15,30,25)
delta = d2 - d1
print(delta, type(delta))
# 查看相差的天数
print(delta.days)
# 查看相差的除天以外的秒数
print(delta.seconds)
# 查看的相差的总共的秒数
print(delta.total_seconds())
# 创建时间相差对象
delta2 = timedelta(days=0,seconds=10)
# 运算后得到一个新的对象
d3 = d1 + delta2
虚拟环境
# 为什么要使用虚拟环境？
# 在一个环境中不同软件依赖同一包的不同版本，为了进行环境隔离就出现了虚拟环境。
# 安装工具：virtualenv
# pip install virtualenv
# 创建虚拟环境：
# virtualenv 虚拟环境目录
# 启动虚拟环境：
# 虚拟环境目录\Scripts\activate.bat
# 退出虚拟环境：
# 虚拟环境目录\Scripts\deactivate.bat
# 快速复制一个虚拟环境：
# 冷藏要复制的环境：pip freeze > requirements.txt
# 创建新的虚拟环境：virtualenv 虚拟环境名
# 激活虚拟环境：虚拟环境目录\Scripts\activate.bat
# 安装依赖：pip install -r requirements.txt
# 虚拟环境管理：virtualenvwrapper-win
# 安装：pip install virtualenvwrapper-win
# 说明：通过系统环境变量WORKON_HOME设置虚拟环境存放目录，默认保存在C:\Users\用户名\Envs
# 查看：lsvirtualenv
# 创建：mkvirtualenv
# 删除：rmvirtualenv
# 启动：workon 虚拟环境
# 退出：deactivate.bat
面向对象
self 哪个对象调用就代表谁
str__ 没有重写此方法，默认打印对象的类名加地址 重写此方法，打印对象会打印该方法的返回值
init 构造方法：创建对象后系统会自动调用该方法完成初始化设置
init 析构方法 ：当对象释放时，系统会自动调用 用于资源释放操作，如：断开数据链接，关闭文件等
常用内置函数 获取属性时
# 说明：内置函数在特定时机被系统自动调用，不需要进行手动调用
# 设置、获取、删除属性时会自动触发的函数
class Person:
def __init__(self,name):
self.name = name
# 访问不存在的属性自动触发
def __getattr__(self, item):
#ietm：获取不存在的属性名
print(item)
if item == 'age':
return 10
elif item == 'weight':
return 60
return '你猜'
# 设置属性时自动触发
def __setattr__(self, key, value):
#key：表示属性名，value表示属性值
# print(key,value)
#手动保存
self.__dict__[key] = value
# 删除对象属性时自动触发
def __delattr__(self, item):
print(item,'属性即将销毁')
del self.__dict__[item]
xiaohuang = Person('小黄')
# print(xiaohuang.age)
# print(xiaohuang.weight)
# print(xiaohuang.height)
# 设置属性
xiaohuang.age = 18
print(xiaohuang.age)
print(xiaohuang.name)
# 存放所有的对象属性
print(xiaohuang.__dict__)
del xiaohuang.name
print(xiaohuang.name)
常用内置函数 当作字典时
# 把对象当作字典时，会自动触发相关函数
class Person:
#将对象当作字典，添加或设置属性时
def __setitem__(self, key, value):
# print(key,value)
self.__dict__[key] = value
# 将对象当作字典操作，获取属性时
def __getitem__(self, item):
# print(item)
return self.__dict__.get(item)
#将对象当作字典操作，删除属性时
def __delitem__(self, key):
print(key,'即将销毁')
del self.__dict__[key]
xixi = Person()
xixi['name'] = '西西'
print(xixi['name'])
del xixi['name']
print(xixi['name'])
常用内置函数 当作函数调用
class Person:
#对象当作函数调用，会自动触发
def __call__(self, *args, **kwargs):
# print('__call__')
return sum(args)
xixi = Person()
print(xixi(1,2,3))
def text():
pass
# 判断一个对象是否可以调用
print(callable(xixi))
print(callable(text()))
# 判断一个对象是否拥有__call__属性
print(hasattr(xixi,'__call__'))
print(hasattr(text(),'__call__'))
# 判断是否是函数
from inspect import isfunction
print(isfunction(text))
print(isfunction(xixi))
面向对象的特点
封装：即是对数据的封装，又是对数据方法的封装
继承：强调的是父子类的关系
多态：不同对象调用相同的方法，有不同的响应
继承属性重写
super().eat() 父类属性重写
多继承
继承链的查找顺序 __mro__属性记录了继承链的查找顺序，一旦找到立刻停止查找并返回，使用广度遍历的方式查找
for i in Son.__mro__:
print(i,)
访问权限
权限
公有的：在类内可以使用，在类的外部以及子类中可以直接使用
私有的：在类内可以使用，在类的外部以及子类中不可使用
两个__开头就是私有属性
类属性
class Person(object):
#类属性
CN = '中国'
#限制对象可以使用的属性,可以提高访问的效率
__slots__ = ('name','age')
def __init__(self,name,age):
self.name = name
self.age = age
def __str__(self):
return '我叫{},年龄{}'.format(self.name,self.age,)
#类属性通过类名访问
print(Person.CN)
p = Person('大猫',21)
# p.weight = 56
print(p)
# 获取对象的类型
print(p.__class__)
# 特殊的类属性
# 类的名字
print(Person.__name__)
#父类组成的元祖
print(Person.__bases__)
# 类相关的信息
print(Person.__dict__)
#继承链的查找顺序
print(Person.__mro__)
# 类的成员属性`
print(Person.__slots__)
类方法和静态方法
# 说明
#类方法通过类名调用
# 定义时需要使用装饰器classmethod
class Air:
# 成员方法
def fly(self):
print('我喜欢飞')
# 类方法
@classmethod
def test(cls):
#cls 表示当前对象
print(cls)
@classmethod
def shoot(cls):
jianjiu = cls()
jianjiu.zhidan = 2000
return jianjiu
jianshi = Air()
jianshi.fly()
jianshi.test()
#创建对象 或`创建简单对象
#通过类名来调用
A = Air.shoot()
A.fly()
# 静态方法
# 说明:定义需要使用装饰器staticmethod
# 也是通过类名来调用
class Person(object):
#定义静态方法
@staticmethod
def text():
print("正在测试")
#创建对象
@staticmethod
def ple():
p = Person()
p.name = '达摩'
return p
#通过类名来调用
Person.text()
p = Person.ple()
print(p.name)
#总结
# 静态方法能够解决的问题类方法都可以解决
# 若类方法没有使用类名,都可以使用静态方法完成
repr
repr 对象的字符串表示方法
eval 其本身类型的表示打印方法
# 对象调用repr方法时会自动触发，通常返回的是字符串的表示形式
def __repr__(self):
return 'Person("{}",{})'.format(self.name,self.age)
运算符重载
# 算术运算符重载
class Number(object):
def __init__(self,num):
self.num = num
def __str__(self):
return str(self.num)
#对象出现'+'的左边时自动触发
def __add__(self, other):
print('__add__')
return other + self.num
# 对象出现'+'的右边时自动触发
def __radd__(self, other):
print('__radd__')
return self.num + other
# += 运算时会自动触发，若没有重写，会调用__add__方法
def __iadd__(self, other):
print('__iadd_')
self.num += other
return self
# 对象出现'-'的左边时自动触发
def __sub__(self, other):
print('__sub_')
return self.num - other
# 对象出现'-'的右边时自动触发
def __rsub__(self, other):
print('__rsub_')
return other - self.num#可互换结果不一样
# -= 运算时会自动触发，若没有重写，会调用__sub__方法
def __isub__(self, other):
print('__isub_')
self.num -= other
return self
# 对象出现'*'的左边时自动触发
def __mul__(self, other):
print('__mul__')
return self.num * other
# 对象出现'*'的左边时自动触发
def __rmul__(self, other):
print('__rmul__')
return self.num * other
# *= 运算时会自动触发，若没有重写，会调用__mul__方法
def __imul__(self, other):
print('__imul_')
self.num *= other
return self
# 对象出现'/'的左边时自动触发
def __truediv__(self, other):
print('__truediv__')
return self.num / other
# 对象出现'/'的右边时自动触发
def __rtruediv__(self, other):
print('__rtruediv__')
return self.num / other
# /= 运算时会自动触发，若没有重写，会调用__truediv__方法
def __itruediv__(self, other):
print('__itruediv__')
self.num /= other
return self
# 对象出现'%'的左边时自动触发
def __mod__(self, other):
print('__mod__')
return self.num % other
# 对象出现'%'的右边时自动触发
def __rmod__(self, other):
print('__rmod__')
return self.num % other
# %= 运算时会自动触发，若没有重写，会调用__mod__方法
def __imod__(self, other):
print('__imod__')
self.num %= other
return self
# 对象出现'//'的左边时自动触发
def __floordiv__(self, other):
print('__floordiv__')
return self.num // other
# 对象出现'//'的右边时自动触发
def __rfloordiv__(self, other):
print('__rfloordiv__')
return other // self.num
# //= 运算时会自动触发，若没有重写，会调用__floordiv_方法
def __ifloordiv__(self, other):
print('__ifloordiv__')
self.num //= other
return self
n = Number(14)
# ret = n + 10
# ret = 10 + n
# n += 30
# ret = n - 10
# ret = 20 - n
# n -= 1
# ret = 30 * n
# n *= 2
# ret = 28 / n
# n /= 2
# ret = n % 3
# ret = n // 10
# ret = 100 // n
n //= 10
print(n, type(n))
# print(ret)
关系运算符重载
class Number(object):
def __init__(self,num):
self.num = num
#大于 self > other 或other < self
def __gt__(self, other):
print('这里是大于')
return self.num > other
# 大于等于 self >= other
def __ge__(self, other):
print('这里是大于等于')
return self.num > other
# 小于 <
def __lt__(self, other):
print('这里是小于')
return self.num > other
# 小于等于 <=
def __le__(self, other):
print('这里是小于等于')
return self.num > other
# 等于 ==
def __eq__(self, other):
print('这里是等于等于')
return self.num > other
# 不等于 != 若重写则执行此方法，若没有重写则会尝试__eq__方法
def __ne__(self, other):
print('这里是不等于')
return self.num != other
n = Number(7)
print(n > 5)
print(n >= 7)
print(n < 3)
print(n <= 7)
print(n == 7)
print(n != 7)
属性函数
# 说明：将成员方法当做属性一样访问
# 作用：保护特定的属性，或者对指定的属性进行特定的处理
class User(object):
def __init__(self, name,password):
self.name = name
# 可以保护特殊属性
self.__password = password
# @property #可以访问password方法，当作属性来访问
# def password(self):
# print('in func password')
# return '不给你看'
#
# @password.setter # 装饰方法 默认生成新方法，传一个新参数，password
# def password(self,password):
# print('设置新密码',password)
# #可以进行特殊的处理
# self.__password = 'xxx' + password +'111'
u = User('damao','000000')
# print(u.password)
u.password = '000000'
print(u.__dict__)
抽象基类
# 抽象基类是为了统一接口而存在的
# 抽象基类不能进行实例化
# 继承自抽象基类的子类必须实现抽象基类的方法
from abc import ABC,abstractmethod
# 抽象基类：不能实例化（创建对象）
class Animal(ABC):
#定义抽象方法：规定接口
@abstractmethod
def eat(self):
print('运动')
class Cat(Animal):
#继承自抽象类的子类，必须实现基类的抽象方法，否则不能实例化创建对象）
def eat(self):
print('mao喜欢走猫步')
class Dog(Animal):
def eat(self):
print('狗喜欢吃屎')
# a = Animal()
# a.run()
c = Cat()
c.eat()
#不继承抽象类的方法，所以不能创建对象
# d = Dog()
单列模式
# 设计模式:针对特定场景的特定解决对象
# 单列模式:无论创建多少次对象,得到的始终都是同一个
# 内置函数:__new__
class Person(object):
# 创建对象时,自动调用 cls相当于object *args,**kwargs相当于Person传的参数
def __new__(cls, *args, **kwargs):
print('这里是__new__函数')
return object.__new__(cls)
#创建对象后,初始化对象,自动调用
def __init__(self):
print('这里是__init__')
#__new__创建对象时使用,但是不能这么使用.
# p =Person.__new__(Person)
# print(type(p))
p = Person()
# p1 = Person()
# p2 = Person()
# print(id(p1))
# print(id(p2))
class Person(object):
def __new__(cls, *args, **kwargs):
#判断cls类 是否有'pp'属性,如果有直接返回之前创建的对象
if not hasattr(cls, 'pp'):
print('程序已经运行到这里')
cls.pp = object.__new__(cls)
return cls.pp
p1 = Person()
p2 = Person()
print(id(p1),id(p2))
内存管理 引用计数
# 当创建一个对象赋值给一个变量时，引用计数记为1；当多一个变量指向该对象，计数值加1；当少一个变量指向对象时，计数值减1，减到0时调用对象的__del__方法释放相关资源
# 引用计数的考察是针对可变变量来说的，不可变变量的引用计数对应我们来说没有意义
from sys import getrefcount
a = 10
b = 10
print(id(a))
print(id(b))
c = '我好烦'
d = '我好烦'
print(id(c))
print(id(d))
# getrefcount 用来查看变量出现的次数,使用该方法会是引用计数加1
print(getrefcount(a))
print(getrefcount(c))
lt = [1,2,3]
lt2 = lt
print(getrefcount(lt))
del lt2
print(getrefcount(lt))
class Person:
def __del__(self):
print('删除对象')
p = Person()
print(getrefcount(p))
del p
print('GG')
函数传参
def text(n):
n += 1
num = 100
# 参数传递的是值
# text(num)#传递的num和上面的num没有一毛钱关系
# text(num)相当于text(100)
print(num)
def aaa(lt2):
lt2[0] += 100
lt = [1,2,3]
# 参数传递的是引用
aaa(lt)
print(lt)
深浅拷贝
import copy
lt = [1,2,[3,4]]
# 浅拷贝：只拷贝对象本身，里面的元素只增加引用,不能改变,但是变量可改
lt1 = copy.copy(lt)
lt1[2] = 100#只是引用,不能改变原列表
print(lt)
print(lt is lt1)#返回Falses说明不是原列表,只是引用
# 深拷贝：拷贝对象本身，里面的元素也进行拷贝,可以改变
lt2 = copy.deepcopy(lt)
lt2[2] = 300
print(lt2)
class Person(object):
#浅拷贝自动调用
def __copy__(self):
print('执行copy方法')
return '111'
#深拷贝自动调用
def __deepcopy__(self, memodict={}):
print('执行deepcopy方法')
return '555'
p = Person()
#浅拷贝
p1 = copy.copy(p)
print(p1)
p2 = copy.deepcopy(p)
print(p2)
print(p is p2)
对象序列化-json
# 将对象转换为str
# json
import json
d = {'name':'damao','age':20}
# 转为json字符串
s = json.dumps(d)
print(s,type(s))
# 转为字典对象
d2 = json.loads(s)
print(d2,type(d2))
# 保存到文件
# s = json.dumps(d)
# fp = open('dict.josn','w')
# fp.write(s)
#简单方法
fp = open('dict.josn','w')
json.dump(d, fp)
#读取对象
fp = open('dict.josn','r')
d3 = json.load(fp)
print(d3,type(d3))
对象序列化-pickle
# 将对象转换为bytes字节流
import pickle
class Person(object):
def __init__(self,name,age):
self.name = name
self.age = age
def __str__(self):
return 'name:{},age:{}'.format(self.name,self.age)
damao = Person('大毛',20)
# 序列化:将对象转换成bytes
s = pickle.dumps(damao)
print(s,type(s))
# 反序列化:从bytes中加载对象
dm = pickle.loads(s)
print(dm, type(dm))
# 序列化到文件
fp = open('data.txt','wb')
pickle.dump(damao,fp)
# 从文件序列化中得到对象
fp = open('data.txt','rb')
dam = pickle.load(fp)
print(dam, type(dam))
异常处理
# 概念
# 错误：程序运行之前的语法问题，如：关键字、缩进不齐，符号不成对。
# 异常：程序运行过程中出现的问题，如：除数为0.，小标越界，访问不存在的变量或对象属性
# 说明：异常处理可以理解为一种特殊的流程控制语句，可以提高代码的健壮性
# 基本语法
try:
print('正常运行')
a = 10 / 0
except Exception as i:
#此处捕获异常，然后做出处理
print('出现异常', i)
print('over')
#完整结构
try:
# print(a)
print('hahah')
except Exception as e:
#出现异常的时候执行
print('出现异常',e)
else:
#没有异常
print('正常结束')
finally:
#无论有无异常都执行
print('无论是否出现异常，我都是您的爹')
抛出异常
try:
print('正常执行')
raise Exception('抛出的异常')
print('正常结束')
except Exception as e:
print('出现异常：',e)
print('OVER')
异常嵌套
print('游戏开始')
try:
print('敌军还有五秒到达战场')
raise Exception('有一个小兵，昨晚吃冰淇淋，身体不舒服')
print('敌军已到达战场，请开始你的表演')
except Exception as e:
print('有一个小兵拉肚子了')
try:
print('替补上场')
raise Exception('替补也拉肚子了')
print('游戏继续')
except Exception as e:
print('替补出现问题')
print('替替补已就位')
print('游戏可以继续了')
print('热情满满开始打游戏')
自定义异常
class MyException(Exception):
def __init__(self,msg):
self.msg = msg
def __str__(self):
return self.msg
def deal(self):
print('自定义异常处理中')
print('自定义异常处理完成。')
try:
print('正常执行')
raise MyException('参数有误')
print('执行结束')
except MyException as e:
#子类的异常的捕获应该放在前面，否则可能无法被捕获
print('自定义异常：',e)
print('其他处理异常')
print('over')
with语句
# 当进行文件操作时，无论过程中有无异常，最后一定需要关闭文件。
# 凡是有上下文的场景，都可以使用with语句，来保证关闭上下文
'''
fp = open('xxx,txt')
# 文件操作
fp.close()
'''
# with open('xxx.txt') as fp:
# #文件操作
# pass
# #with语句结束，无论中间是否有异常，一定能关闭文件，并且不要执行fp.close()
class Person:
def __init__(self):
print('aa')
#进入上下文自动调用
def __enter__(self):
print('__enter__')
# 退出上下文时自动调用
def __exit__(self, exc_type, exc_val, exc_tb):
print('__exit__')
print('异常类型:', exc_type)
print('异常内容:', exc_val)
print('异常追溯:', exc_tb)
with Person() as p:
print('代码执行中')
raise Exception('出错了')
print('代码执行结束')
正则表达式
# 说明：正则的解析不是我们来写的，python中的re模块专门用来处理正则
import re
# 从头进行匹配，找到返回正则结果对象，没有找到返回None
m = re.match('abc','abcaabcooo')
print(m)
# 功能同上，可以在任意位置匹配
a = re.search('a','llokoamjjnhh')
print(a)
#提取匹配的内容 位置
print(m.group(),m.span())
# 匹配所有的内容 ，以列表形式返回匹配内容，没有返回空列表
f = re.findall('qwer','tyuuoqwdsdqwwerllqwer')
print(f)
# 先生成正则表达式对象
d = re.compile('djw')
# 从头开始匹配
m = d.match('djwqowleodkdjwss')
print(m)
print(m.group(),m.span())
# 从任意位置开始匹配
s = d.search('fekkkefdjweffkekekekk')
print(s.group(),s.span())
# 匹配所有
f = d.findall('jfojfowdjwfwjfjfdjw')
print(f)
# 正则替换
s = 'if1you2do3not4leave5meI6will7by8you9side2until4the6life8end'
o = re.compile(r'\d')
#按照正则进行替换,可以指定次数
# s2 = o.sub('',s, 3)
# 干预替换
def tihuan(o):
# print(o.group())
return '*'
# s2 = o.sub(tihuan,s)
def double(o):
# return o.group() * 2
#函数作为替换的结果
return str(int(o.group()) * 2)
s2 = o.sub(double,s)
print(s2)
# 可以传递一个函数,人为的干预替换过程
s3 = re.sub(r'\d',lambda m:str(int(m.group())*2),'how1are2you3')
print(s3)
正则语法
import re
# 单个字符
# 普通字符：就是一对一的完整匹配
'''
[]：匹配指定范围内的任意一个字符
[abc]：匹配任意一个字符
[0-9]：任意的数字
[a-zA-Z]：任意的字母
[^0-9]：任意的非数字
\d：数字字符，等价于[0-9]
\D：非数字字符，等价于0-9
\w：字(数字、字母、下划线、汉字)
\W：非字
\s：空白字符(\n、\r、\t、空格)
\S：非空白字符
\b：词边界(开头、结尾、空格、标点)
\B：非词边界
. ：匹配除\n以外的任意字符
'''
# [] 匹配指定范围内的任意一个字符
# o = re.compile('[*]')#匹配任意一个字符
# o = re.compile('[0-9]')#任意的数字
# o = re.compile('[a-zA-Z]+')#任意的字母
# o = re.compile('[^0-9]+')#任意的非数字
#\d :数字字符，等价于[0-9]
# o = re.compile(r'\d+')
#\D:非数字字符 等价于[^0-9]
# o = re.compile(r'\D+')
#\w:字（数字、字母、下划线、汉字）
# o = re.compile(r'\w+')
# \W:非字
# o = re.compile(r'\W+')
#\s:空白字符（\n、\r、\t、空格）
# o = re.compile(r'\s+')
# \S:非空白字符
# o = re.compile(r'\S')
#\b:词边界（开头，结尾，空格，标点）
# o = re.compile(r'\b ')
#\B:非词边界
# o = re.compile(r'\B')
# s = o.search('kklsabDSFcjdsv 1230oo_59*/ll')
# if s:
# print(s.group(), s.span())
#次数限定
#{m}:m次
# o = re.compile(r'ab{5}c')
#{m-n}:m-n次
# o = re.compile(r'ab{3,5}c')
#{m,}:至少m次
# o = re.compile(r'ab{3,}c')
#{,m}:至多m次
#o = re.compile(r'ab{,3}c')
# ?:至多一次
# o = re.compile(r'ab?c')
# +:至少一次
# o = re.compile(r'ab+c')
# *:任意次
# o = re.compile(r'ab*c')
# s = o.findall('abbbbbbbbbbbc')
# print(s)
# 边界判断
# ^:以指定的内容开头
# o =re.compile(r'^hello')
# $:以指定字符结尾
# o = re.compile(r'world$')
# s =o.search('helloworld')
# if s:
# print(s.group(),s.span())
# |的使用
# :表示或，拥有最低的优先级
# c = re.compile(r'hello|world')
# s = c.search('helloworld')
# if s:
# print(s.group(),s.span())
# 分组匹配
# o = re.compile(r'(\d+)([a-z]+)(\d+)')
#
# s = o.search('gas1235asdkj1235adugd')
# if s:
# print(s.group(), s.span())
# #分组默认为0
# print(s.group(0), s.span(0))
# #指定组号，返回对应组的匹配结果，一个（）表示一个组
# print(s.group(1), s.span(1))
# print(s.group(2), s.span(2))
# print(s.group(3), s.span(3))
# 固定匹配
# o = re.compile(r'<a>\w+</a>')
# o = re.compile(r'<div><a>\w+</a></div>')
# 无名分组: \1表示第一组,即第二个()的匹配的结果
# o = re.compile(r'<([a-z]+)><([a-z]+)>\w+</\2></\1>')
# 命名分组: 给每个组取名字,后面通过名字指定
# o = re.compile(r'<(?P<erniu>[a-z]+)><(?P<dankiu>[a-z]+)>\w+</(?P=dankiu)></(?P=erniu)>')
# s = o.search('<div><a>百度一下</a></div>')
# if s:
# print(s.group(), s.span())
# #所有匹配到的信息，是一个元祖，适用于分组
# print(s.groups())
# #所有匹配到的信息，是一个字典，用于命名分组
# print(s.groupdict())
# 贪婪匹配
# 贪婪：最大限度的匹配。正则的匹配默认是贪婪的。
# 非贪婪：只要满足条件，能少匹配就少匹配。
# ? 可以取消.*的任意多次的贪婪匹配
# o = re.compile(r'a.*?')
# ? 可以取消.+的至少一次的贪婪匹配
# o = re.compile(r'a.+?b')
# s = o.search('ahsdsadbkjasdbskj')
# if s:
# print(s.group())
# 匹配模式
# re.I:忽略大小写
# s = re.search(r'hello',"Hello world",re.I)
# re.M :多行匹配,默认单行
# s = re.search(r'^hello', 'ahd\nhkah\nhello world', re.M)
# re.S：单行模式，可以让.匹配包括\n在内的任意字符
string = '''<div>
helloworld
</div>'''
s = re.search(r'<div>.*?</div>', string, re.S)
if s:
print(s.group())
扫一扫
1190
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
