python学习

风舞红叶

已于 2024-05-06 22:41:33 修改

阅读量118

点赞数

分类专栏： python 文章标签： python

于 2023-02-21 23:45:00 首次发布

本文链接：https://blog.csdn.net/weixin_46488959/article/details/129140775

版权

python 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

文章目录

python脚本结构
内置函数
变量
关键字
赋值运算符
比较运算符
数据类型
- 数字类型
- 字符串类型
- 布尔类型、空类型
- 列表（队列）类型
- 元组类型
- 列表、元组操作
- 字典类型
- - 字典操作
- 集合（set）
不同数据间的转换
- 字符串与数字之间的转换
- 字符串与列表之间的转换
- 字符串与bytes的转换
- 元组、列表、集合间的转换
控制流程
- - 逻辑语句
  - 循环语句
函数
- 定义函数
- 递归函数
- 匿名函数lambda
对象
- 类定义
- 类的参数`self`
- 类的构造函数
- 对象声明周期
- 私有函数、私有变量
- - 定义私有
- 封装
- 装饰器
- - 装饰器用法
  - 类中的装饰器
继承
- `super`函数的作用
- 多态
- 类的高级函数
异常
- 异常类型
- 抛出异常 `raise`
- 自定义异常
- 断言`assert`
包与模块
- 包的导入
- 模块的导入
- 第三方包
- - 获取第三包
- 时间包
- 时间格式符
- time包
- os包
- sys包
文件操作
- 文件读写
- 序列化
常用函数和高价函数
- 加密模块
- - hashlib
  - base64
- 日志模块
- - logging模块
- 常用函数
- 高级函数
- random模块
- 迭代器
虚拟环境
多线程
- 进程`multiprocessing`
- 线程
- GIL全局锁
- 异步
- - async 与 await 关键字
  - gevent包
正则表达式`re`
抽奖系统
- 模块介绍
抽奖系统
- 模块介绍

python脚本结构

# coding:utf-8    

# 引用部分，使用前导入
import os

# 代码
print(os.getcwd())
print('hello world')

头部注释，文件第一行的注释
- # coding:utf-8 定义coding，脚本编码格式
- #!/usr/bin/env 定义 #! ，在指定路径下的python解释器
代码自上而下，逐行执行
注释：
- #注释 #aaaa
- 三引号注释 """aaaaa"""
- 单引号注释 '''aaa'''
脚本入口（并不一定要有）
- __name__=='__main__'

内置函数

print() 打印
- end='' 当前输出结尾不换行
result = input('请输入') 接收一个标准输入数据，返回一个string类型
type(已经被赋值的变量名或者变量)返回变量的类型
·id(变量)返回内存地址
in not in 相当于包含，不包含
max(数据) 当前数据中最大的成员，中文符号>字母>数字>英文符号
min(数据)当前数据中最小的成员，中文符号>字母>数字>英文符号
del 变量 把变量完全删除
range返回一个一定范围内可迭代的对象，元素为整型，它不是列表，无法打印信息，但可循环

变量

username='张三'
age = 20
_sleep_ = 'yes'
a,b,c = 1,2,3

数字、字母、下划线组成
必须 字母、下划线 开头
区分大小写
global函数体内修改全局变量的值

关键字

强关键字（完全不能用于定义变量名）

弱关键字（可以用于变量名，但是会影响关键字本身）

关键字	含义
True	布尔类型，真
False	布尔类型，假
None	None通常用于表示值的缺失
def、lambda、return	函数
pass	无意义，占位字符
yield	从循环或者函数依次返回数据
if…elif…else	逻辑中的判断
is	判断变量是否是某个类的实例
in	判断变量是否在序列中
try…except…finally	异常语句
raise	主动抛出异常
and、or、not	逻辑运算，与或非
del	删除
class	类
as	重命名
global	在函数体内修改全局变量
nonlocal
for、while、break、continue	循环语句
with	上下文管理
import、from	导入语句

赋值运算符

运算符	描述
=	等于
+=	加等
-=	减等
*=	乘等
/=	除等
%=	取模等
**=	幂等
//=	整除等

比较运算符

`==`	等于
`!=`，`<>`	不等于，python3弃用`<>`
`>`
`>=`
`<`
`<=`
`is`	判断两个对象存储单元是否相同
`is not`	两个对象单元内存地址是否不同

数据类型

数字类型

整型 int
python2中曾经有long整型，在python3中已经弃用

浮点型 float

'''整型'''
count_100_01 = int(100)
count_100_02 = 100

# 浮点型
pi_01 = float(3.14)
pi_02 = 3.14

字符串类型

str 代表字符串类型，也是函数
字符串不可变
+ 字符串拼接
字符串和数字做乘法，字符串重复多少次

name_01 = 'a'
name_02 = "b"
name_03 = str('c')

# 获取字符串长度
lenfth = len(name_01)

格式化
- - 符号说明
    %s 字符串，通用类型
    %d 整型
    %f 浮点型
    %u 无符号整型
    %c 字符
    %o 无符号八进制数
    %x 无符号16进制数
    %e 科学计数法格式化浮点数
- f-strings方案
- format 格式化字符串函数
  - 使用位置，format会把参数按位置顺序来填充到字符串中，第一个参数时0，然后1
  - 使用关键字填充
  - 数字格式化
  - 输出花括号需要
字符串函数
- | 函数 | 功能 | |
  | --------------------------------------- | ------------------------------------------------------------ | ------------------------------------------------------------ |
  | capitalize() | 将字符串首字母大写，其他字母小写 | |
  | casefold()、lower() | 字符串中字母全部转小写 | |
  | upper() | 字符串全体大写 | |
  | swapcase() | 字母大写转小写，小写转大写 | |
  | zfill(width) | 为字符串定义长度(width)，长度不足，缺少的部分用0填补 | |
  | count(sub) | 返回当前字符串中某个成员的个数 | |
  | startswith(sub)、endswith(sub) | 是否以指定字符开头或结尾 | |
  | find(sub)、index(sub) | 返回查找元素的位置（字符串位置从0开始）；index找不到会报错；find找不到会返回 -1 | |
  | strip()、lstrip(sub)、rstrip(sub) | 去除字符串左右两边的指定元素，默认是空格 | |
  | replace(old,new,max) | 字符串新元素替换旧元素，指定替换数量，默认全部替换 | |
  | isspace() | 是否全是空格 | |
  | istitle() | 是否是标题类型（每个单词首字母大写） | |
  | isupper()、islower() | 字母是否全大写，是否全小写 | |
  | join | | |
  | split | | |

符号	说明
`%s`	字符串，通用类型
`%d`	整型
`%f`	浮点型
`%u`	无符号整型
`%c`	字符
`%o`	无符号八进制数
`%x`	无符号16进制数
`%e`	科学计数法格式化浮点数

字符串转义字符

符号	说明
`\n`	换行，strip对齐也有效
`\t`	横向制表符
`\v`	纵向制表符（会有一个男性符号）
`\a`	响铃
`\b`	退格符，将光标前移，覆盖
`\r`	回车
`\f`	翻页（会有一个女性符号）
`\'`	转义单引号
`\"`	转义双引号
`\\`	转义斜杠

转义无校符字符串前加r将当前字符串的转义字符无效化

布尔类型、空类型

bool
- int 0 -->False，非0—>True
- float 0.0 -->False，非0.0—>True
- 空字符串 -->False，非空字符串—>True
空类型不属于任何数据类型
- 固有值 None
- 空类型属于 False 范畴

列表（队列）类型

list 代表列表类型，也可以用于定义一个列表
列表中的元素存在于一个 [] 中
min max在列表中使用时，元素类型必须统一
列表是一个无限制长度的数据结构
有序，内容可以重复

元组类型

与列表一样，存储数据结构的队列
有序，元素可重复
无长度限制
min max在元组中使用时，元素类型必须统一
tuple代表元组，也可以定义
元组元素存在于 () 中，元素只有一个时最后要加,
元组比列表占用资源少
列表是可变的，元组是不可变的

列表、元组操作

len 计算长度
累加、乘法
in、not in
统计指定元素的数量count(item)
获取指定元素索引 index(item)
- 不存在会报错
列表的添加append(new_item)
- 只会追加到原有列表的末尾
列表添加insert(index,new_item)
- 添加到指定位置，位置不存在，加到结尾
列表删除元素remove(item)
- 删除成员不存在，会报错
- 有多个被删除元素时，只删除第一个
通过索引删除列表元素 pop(index)
- 函数返回删除的元素
- 索引不存在，报错
通过索引删除列表元素 del list[index]
- 直接删除，无返回值
- index不存在，报错
列表反转 reverse()
列表排序 sort(key=None,reverse=False)
- key 参数比较
- reverse =False升序，True降序
- 元素类型必须相同
列表清空 clear()
列表复制 copy()
- 属于浅拷贝
列表批量添加 extend(iterable)

字典类型

dict 代表字典，并且可以创建一个字典

通过 {} 将key、value存入字典

map_01 = dict()
map_02 = {'name':'zhang','age':20}

key 支持字符串，数字和元组，不支持列表；key 一定是唯一的
value支持所有类型
字典在 python3.7 之前是无序的，之后是有序的

字典操作

添加修改
- [] key不存在，会报错
添加字典 update(new_dict)
获取key对应value，不存在添加默认值 setdefault(key,value)
获取所有键 keys()
获取所有值 values()
根据key获取valueget(key,default=None)
- key不存在返回默认值
删除 clear() 清空当前字典所有数据
pop(key)删除指定key，并返回其value
- key不存在，报错
删除数据del
复制字典 copy()
判断字典中是否存在key in、not in
判断字典中是否存在key
删除字典中的末尾一对键值对 popitem()
- 返回被删除的键值对，用元组包裹0索引是key，1索引是value
- 字典为空，直接报错

集合（set）

无序的不重复元素序列
常用来对两个列表进行交并差的处理
支持所有类型
只是用来处理列表或者元组的一种临时类型，不适合存储与传输
没有获取元素的任何方法

集合创建

`add(item)`添加元素
`update(iterable)`添加一个新的集合
`remove(item)`删除元素，不存在会报错
`clear()`清空集合所有元素
`del 集合`
`a_set.difference(b_set)`求差集
`a_set.intersection(b_set...)`求交集
`a_set.union(b_set...)`求并集
`a_set.isdisjoint(b_set)`判断两个集合是否有相同元素

不同数据间的转换

字符串与数字之间的转换

字符串与列表之间的转换

split(seq=None,maxsplit=-1)seq 分割符，maxsplit分割次数，生成列表
'seq.join(iterable)'生成字符串，使用seq连接各个元素

字符串与bytes的转换

比特类型，字符串前 b标记
string.encode(encoding='utf-8',errors='strict')字符串转bytes
- encoding：编码格式，ascii，gbk，默认utf-8
- errors：出错时的处理方法，默认strict,直接抛出错误，也可以选择ignore忽略
- 返回一个比特（bytes）类型
bytes.decode(encoding='utf-8',errors='strict')bytes转字符串函数
- encoding：编码格式，ascii，gbk，默认utf-8
- errors：出错时的处理方法，默认strict,直接抛出错误，也可以选择ignore忽略
- 返回字符串
元组、列表、集合间的转换

控制流程

逻辑语句

if语法用法
else语句用法
elif语句用法

循环语句

for语句用法
while循环
```
while bool:
    ....
```
字典遍历

函数

定义函数

def name (a,b=1,*args.**kwargs):
    todo something...
    return ...

# 参数定义类型，参数名:类型=默认值   ， 在3.7之后可用，函数调用时会对参数类型进行验证
def person(name:str,age:int=33):
    print(name,age)

a必传参数，函数定义时没有默认值
b默认参数，定义函数时设置的有默认值，调用时可传可不传
*args可变元组参数、**kwargs可变字典参数
传入元组及列表类型的数据，变量名前加 *解包
传入字典内心那个数据，变量名前加 **解包
关键字参数，关键字和形参匹配，实参的顺序任意

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VXxJ7VMt-1676956747120)(https://gitee.com/wind_dancing_red_leaves/images/raw/master/202302181541147.png)]

递归函数

内存溢出问题

匿名函数lambda

对象

类定义

class 类名首字母大写，多个单词每个单词首字母大写

class Name(object):
    #属性
    atter = something
    #方法
    def funcName(self):
        do

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8ACg9GfP-1676956747122)(https://gitee.com/wind_dancing_red_leaves/images/raw/master/202302181546084.png)]

类的参数`self`

self 是类函数中的必传参数，且必须放在第一个参数的位置
self 是一个对象，它代表实例化的变量自身
self 可以直接通过.来定义一个类变量 self.name='lili'
self 中的变量与含有self参数的函数可以在类中的任何一个函数内随意调用
非函数中定义的变量在定义的时候不用self

类的构造函数

类中的一种默认函数，用来将类实例化的同时，将参数传入类中

class Test(object):
    def __init__(self,a,b):
    self.a=a
    self.b=b
  
t =Test(1,2)

对象声明周期

以 __(下横线)开头和结尾的函数都是类的默认函数
__init__实例化，对象声明的开始，内存中分配空间
__del__删除对象，内存中释放空间

私有函数、私有变量

无法被实例化后的对象调用的类中的函数和变量
类内部可以调用私有函数与变量
只希望类内部业务使用，不希望被使用者调用

定义私有

在函数或者变量前添加__2个下横线，后面无需添加

封装

将不对外的私有属性或者方法通过可对外使用的函数来使用

装饰器

一种函数
可以接收函数作为参数
可以返回函数

接收一个函数，内部对其处理，然后返回一个新函数，动态增强函数功能

def out(func_args):							#外围函数
    def inter(*args,**kwargs):				#内嵌函数
        return func_args(*args,**kwargs)	
    return inter							#外围函数返回内嵌函数

装饰器用法

将被调用的函数直接作为参数传入装饰器
将装饰器与被调用函数绑定在一起（@装饰器函数，放在被调用函数的上一行，被调用函数正常定义，只需要直接调用被执行函数）

类中的装饰器

classmethod类函数可以不经过实例化而直接被调用
- @classmethod修饰的函数，第一个参数是 cls代表当前类
staticmethod类函数不经实例化而被直接调用，函数不许传递 self、cls参数，而且无法在该函数内部调用其他类函数或者类变量
property将类函数的执行免去括弧，只是用无参数的类函数（self、cls除外）

继承

定义子类时，将父类传入子类参数内
子类实例化可以调用自己与父类的函数与变量

父类无法调用子类的函数与变量

class Parent(object):
    def talk(self):
        print('talk')
        
        
class Child(Parent):
    def swimming(self):
        print('child can swiming')
        
        
c = Child()
c.talk()
# talk
c.swimming()
# child can swiming

p = Parent()
p.talk()
# talk
p.swimming()
# AttributeError: 'Parent' object has no attribute 'swimming'

多重继承的方法class Child(Parent1,Parent2...)

`super`函数的作用

在子类函数中使用父类方法

多态

子类中重写父类的方法

类的高级函数

`__str__`	打印对象时，打印该函数的return信息
`__getattr__`	当调用的属性或者方法不存在时，返回该方法定义的信息
`__setattr__`	给属性赋值时，会先进入该方法
`__call__`	将类变成一个函数
`__mro__`	返回类的继承链
`__dict__`	内置字典

异常

try:
    <代码块1>
except <异常的类型>:
    <代码块2>
finally:
    <代码块3>

异常类型

Exception	通用异常类型（基类）
ZeroDivisionError	不能除0
AttributeError	对象没有这个属性
IOError	IO失败
IndexError	没有当前的索引
KeyError	没有这个键值key
NameError	没有这个变量，未初始化对象
SyntaxError	Python语法错误
SystemError	解释器系统错误
ValueError	传入参数错误

抛出异常 `raise`

raise 异常类型(message)

自定义异常

继承基类Exception

在构造函数中定义错误信息

class NewError(Exception):
    def __init__(self,message):
        self.message=message

断言`assert`

用于判断一个表达式，在表达式条件为false的时候触发异常

assert expression
# expression：表达式，一般是判断相等，或者判断是某种数据类型的bool判断语句

包与模块

原则上是一个文件夹，里面放着一个个py文件或者子包
在包中可以被调用的一个个py文件，叫做模块
__init__.py是每一个python包里面必须存在的文件

包的导入

import package将包导入当前的py文件中
只会拿到对应包__init__.py中的功能，或者当前模块下的功能

模块的导入

通过从某个包中找到对应的模块
from package import module

第三方包

获取第三包

第三方包管理工具，pip的使用率最高，easy_install
3.4以上版本安装时自带这两种包管理工具
老版本通过https://pip.pypa.io/en/stable/installing/
pip install [--trusted-host url] 包名[==版本号]
- --trusted-host url从指定位置下载包
- 阿里云：mirrors.aliyun.com/pypi/simple/`
- 清华：pypi.tuna.tsinghua.edu.cn/simple`
pip uninstall 包名删除指定包
github 搜索 python 第三方包

时间包

# 导入包
import datetime
#获取当前时间
datetime.datetime.now()
#获取时间间隔对象
datetime.timedelta(days=1)



# 导入模块
from datetime import datetime
from datetime import timedelta
#获取当前时间
now = datetime.now()
#获取时间间隔对象
timedelta(days=1)
# 时间转字符串
date_str = now.strftime('%Y-%m-%d')
# 字符串转时间
datetime.strptime('符合格式的字符串','%Y-%m-%d')
# 获取时间戳,now datetime时间对象
now_timestamp = datetime.timestamp(now)
# 时间戳 转时间对象
datetime.fromtimestamp(now_timestamp)

时间格式符

符号	含义
%y	两位数的年份表示（00-99）
%Y	两位数的年份表示（00-99）
%m	两位数的年份表示（00-99）
%d	月内中的一天（0-31）
%H	月内中的一天（0-31）
%I	12 小时制小时数（01-12）
%M	分钟数（00=59）
%S	秒（00-59）
%a	本地简化星期名称
%A	本地完整星期名称
%b	本地简化的月份名称
%B	本地简化的月份名称
%c	本地相应的日期表示和时间表示
%j	年内的一天（001-366）
%p	本地 A.M.或 P.M.的等价符
%U	一年中的星期数（00-53）星期天为星期的开始
%w	星期（0-6），星期天为星期的开始
%W	一年中的星期数（00-53）星期一为星期的开始
%x	本地相应的日期表示
%X	本地相应的时间表示
%Z	当前时区的名称
%%	%号本身

time包

import time

# 生成时间戳，返回秒级别的浮点类型
time.time()
# 获取本地时间,timestamp时间戳（可不传）
time.localtime(timestamp)

# 暂停函数,second希望程序被暂停的秒数
time.sleep(second)

# 格式化,format 格式化规范；t time.localtime对应的时间类型
time.strftime(format,t)

# 解析字符串，time_str 符合时间格式的字符串；format 格式
time.strptime(time_str,format)

os包

import os

函数名	参数	介绍	举例	返回值
getcwd	无	返回当前的路径	os.getcwd()	字符串
listdir	path	返回指定路径下的所有文件或者文件夹	os.listdir(‘c://’)	返回一个列表
makedirs	Path	创建多级文件夹	os.makedirs(‘d://im/py’)	无
removedirs	path	删除多级文件夹	os.removedirs(‘d://im/py’)	无
rename	oldname,newname	文件改名	os.rename(‘d://old’,‘d://new’)	无
rmdir	path	只能删除空文件夹	os.rmdir(‘d://im’)	无
exists	path	是否存在	os.path.exists(‘d://’)	bool
isdir	path	是否是文件夹	os.path.isdir(‘d://’)	bool
isabs	path	是否是绝对路径	os.path.isabs(‘test’)	bool
isfile	path	是否是文件	os.path.isfile(‘d://a.py’)	bool
join	path,path	路径字符串合并	os.path.join(‘d://’,‘test’)	字符串
split	path	分割路径，以最后一层为基准	os.path.split(‘d://a.py’)	列表

sys包

函数名	参数	介绍	举例	返回值
modules（属性）	无	py启动时加载的模块	sys.modules()	列表
path（属性）	无	返回当前py的环境路径	sys.path	列表
exit	arg	退出程序	sys.exit(0)	无
getdefaultencoding	无	获取系统编码	sys.getdefaultencoding()	字符串
platform（属性）	无	获取当前系统平台	sys.platform	字符串
version（属性）	无	获取python版本	sys.version	字符串
argv（属性）	无	程序外部获取参数	sys.argv	列表

文件操作

文件读写

获取文件对象 open(path,model)

path；文件路径
model: 操作模式

返回文件对象

模式	说明
w	创建文件
w+	创建或者追加内容
wb	二进制形式创建文件
wb+	二进制形式创建或者追加内容
a	追加内容
a+	读写模式的追加
ab+	二进制形式读写追加
r	读取文件
rb	二进制形式读取文件

方法	参数	说明	举例
write	message	写入信息	f.write(‘hello’)
writelines	message_list	批量写入	f.writelines([‘hello’,‘world’])
close	无	关闭并保存文件	f.close()
read	无	返回整个文件字符串	f.read()
readlines	无	返回数据列表，每一行数据是一个元素	f.readlines()
readline	无	返回文件中的一行	f.readline()
model	无	文件模式	f.mode
name	无	返回文件名称	f.name
closed	无	文件是否关闭	f.closed

# 文件读写，脱离代码块之后，文件自动关闭
with open(path,model) as f:
    data = f.read()
print(data)

序列化

可以序列化的数据类型
- number
- str
- list
- tuple
- dict
json模块
- 对象序列化 json.dumps([1,2])返回字符串
- 反序列化 json.loads('[1,2]')返回原始数据类型
pickle模块
- 对象序列化 pickle.dumps([1,2])返回比特
- 反序列化 pickle.loads('[1,2]')返回原始数据类型

Yaml文件的读取

pip install pyyaml安装第三方包

import yaml导入包

f = open(yaml_file,'r')
# 返回字典类型
data = yaml.load(f.read())
f.close()

常用函数和高价函数

加密模块

hashlib

加密需要先实例化 MD5 对象，再将字符串转成bytes类型进行加密

import hashlib

# md5
m = hashlib.md5() # 实例化md5对象
m.update('imooc'.encode())
print(m.hexdigest())

# sha1
s1 = hashlib.sha1()
s1.update("imooc".encode("utf-8"))
print(s1.hexdigest())

# sha256
s256 = hashlib.sha256()
s256.update("imooc".encode("utf-8"))
print(s256.hexdigest())

#sha224
s224 = hashlib.sha224()
s224.update("imooc".encode("utf-8"))
print(s224.hexdigest())

# sha384
s384= hashlib.sha384()
s384.update("imooc".encode("utf-8"))
print(s384.hexdigest())

# sha512
s512 =hashlib.sha512()
s512.update("imooc".encode("utf-8"))
print(s512.hexdigest())

base64

用64个字符来表示任意二进制数据的方法，可用来将非ASCII字符的数据转换成ASCII字符，是一种可逆的编码方式

import base64

#‘imooc'.encode()将字符串变成二进制
res = base64.b64encode('imooc'.encode()) # base64编码
# res.decode()把bytes转成字符串
jie_mi_res = base64.b64decode(res.decode())# base64解码
print(jie_mi_res.decode())

函数	参数	说明	返回值	eg
encodestring	Byte	加密	Byte	base64.encodestring(b’hello’)
decodestring	Byte	解密	Byte	base64.decodestring(b’hello’)
encodebytes	Byte	加密	Byte	base64.encodebytes(b’hello’)
decodebytes	Byte	解密	Byte	base64.decodebytes(b’hello’)

日志模块

日志等级
- debug
- info
- warnning
- error
- critical

logging模块

import logging
logging.baseConfig()

参数作用 eg
level 输出等级 level=logging.DEBUG
format 输出格式
filename 存储位置 filename=‘d://back.log’
filemode 输入模式 filemode=“w”
format格式

格式符含义
%(levelname)s 日志级别名称
%(pathname)s 执行程序的路径
%(filename)s 执行程序名
%(lineno)d 日志的当前行号
%(asctime)s 打印日志的时间
%(message)s 日志信息
format='%(asctime)s %(filename)s [line:%(lineno)d] %(levelname)s %(message)s'
logging.info('消息')

参数	作用	eg
level	输出等级	level=logging.DEBUG
format	输出格式
filename	存储位置	filename=‘d://back.log’
filemode	输入模式	filemode=“w”

格式符	含义
%(levelname)s	日志级别名称
%(pathname)s	执行程序的路径
%(filename)s	执行程序名
%(lineno)d	日志的当前行号
%(asctime)s	打印日志的时间
%(message)s	日志信息

常用函数

函数名	参数	说明	返回值	举例
abs	Number	返回绝对值	正整数	abs(-10)
all	List	判断列表中的每个元素是否全是true	bool	all([‘’,‘123’])
help	object	打印对象的用法	无	help(list)
enumerate	iterable	迭代时记录索引	无	for index,item in enumerate(list)
input	Str	接收命令行输入	str	input(‘请输入信息：’)
isinstance	object,type	判断对象是否是某种类型	bool	isinstance(‘a’,str)
type	object	判断对象的类型	str	type(10)
vars	instance	返回实例化的字典信息	dict
dir	object	返回对象中所有可用方法和属性	list	dir(‘asd’)
hasattr	object,key	判断对象中是否有某个属性	bool	hasatter(list,‘append’)
setatter	obj,key,value	为实例化对象添加属性与值	无	setatter(instance,key,value)
getatter	obj,key	通过对象获取属性	任何类型	getatter(obj,key)
any	iterable	判断内容是否有true值	bool	any([1,0,’ '])
sum		求和		sum([1,2,3])
max		最大		max([1,2,3])
min		最小		min([1,2,3])
reverse		用于反向列表中的元素，直接修改原列表
hash		获取哈希值		hash(obj)
zip
pow		返回x的y次方的值		pow(2,3)#2的三次方

高级函数

filter(func,list)对list每个元素进行条件过滤,返回符合要求的新列表
```
res = filter(lambda x:x>1,[0,1,2])
print(list(res))#2
```

map(func,list)对每个元素做map处理

res = map(lambda x:x+1,[1,2,3])
print(list(res))#[2,3,4]

reduce(func,list)对元素进行累积

from functools import reduce
res = reduce(lambda x,y:x+y,[1,2,3])
print(res)#6

random模块

random.random()随机返回0~1之间的随机数
random.uniform(a,b)产生一个a，b区间的随机浮点数
random.randint(a,b)产生一个a，b区间的随机整数
random.choice(['a','b']) random.choice('ab')返回对象中一个随机元素
random.sample(['a','b',5],2) random.choice('abc',2)随机返回对象中指定数量的元素
random.randrange(0,100,1)获取区间内的一个随机数

迭代器

arr = [1,2,3]
#1、iter()生成迭代器
iter_obj = iter(arr)

#2、for循环生成迭代器 ---yield
def test():
    for i in range(10):
        yield i
        
next(test())
#3、for循环一行生成迭代器
res2 = (i for i in [1,2,3])
next(res2)



#获取迭代中数据，每次获取一个，获取完之后在进行获取会报错
next(iter_obj)

# for循环获取
for item in res2:
    print(item)

虚拟环境

在一台电脑上，不同项目运行在不同的python版本中
虚拟环境工具
- Virtualenv（依赖系统中安装了哪些版本）
  - 命令行下运行
  - pip install virtualenv
  - 选择目录
  - virtualenv -p python3.10 penv -p 指定版本，penv 给虚拟环境起名称（虚拟环境就是创建一个文件夹）
  - linux 启动虚拟环境 ./penv(虚拟环境名称)/bin/activate
  - windows 进入cd /penv(虚拟环境名称)/bin目录activate回车启动
  - 退出虚拟环境输入deactivate
- pyenv（不依赖安装的版本）

多线程

进程`multiprocessing`

进程创建

函数	说明	参数	返回值
Process	创建一个进程	target,args	进程对象
start	执行进程	无	无
join	阻塞进程	无	无
kill	杀死进程	无	无
is_alive	进程是否存活	无	bool

通过进程模块执行函数无法获取返回值
多个进程同时修改文件可能会出现错误
进程数量太多可能会造成资源不足

进程池的创建

函数	说明	参数	返回值
Pool	创建进程池	processcount	进程池对象
apply_async	任务加入进程池（异步）	func,args	无
join	等待进程池任务结束	无	无
close	关闭进程池	无	无

进程锁

from multiprocessing import Manager

manage = Manager()
lock = manage.Lock()

#加锁
lock.acquire()
#释放锁
lock.release()

进程通信

通过队列通信

函数	说明	参数	返回值
Queue	队列的创建	mac_cout	队列对象
put	信息放入队列	message	无
get	获取队列信息	无	str

线程

线程创建`threading`

import threading
# 创建线程
t = threading.Thread(target,args)

函数	说明	参数	返回值
Thread	创建一个线程	target,args	线程对象
start	启动线程	无	无
join	阻塞直到线程执行结束	无	无
getName	获取线程名字
setName	设置线程名字
is_alive	线程是否存活	无	bool
setDaemon	守护线程	bool

通过线程程模块执行函数无法获取返回值
多个线程同时修改文件可能会出现错误

线程池`from concurrent.futures import ThreadPoolExecutor`

函数	说明	参数	返回值
ThreadPoolExecuter	创建一个线程池	max_workes	线程池对象
submit	向线程池提交任务	target,args	Future对象
done	Future是否完成了任务
result	获取Future执行的结果

线程锁

import threading

lock = threading.Lock()

#加锁
lock.acquire()
#释放锁
lock.release()

GIL全局锁

单一cpu工作（线程只能在进程所在的cpu上执行）
线程安全
自带的解释器有全局锁；pypy解释器，不含有全局锁
多进程+多线程

异步

轻量级的线程（协程）
可以获取异步函数的返回值
主进程需要异步才行
更适合文件读写使用

async 与 await 关键字

    
import asyncio

# async 定义异步
# await 执行异步，要在异步环境中使用
async def test():
    return 'a'

async def handle():
    result = awit test()


# asyncio 调用 async函数
# gather(asyncfunc...)   批量执行异步函数，返回List
# run([task])       执行异步函数，返回执行结果
print(asyncio.run(test()))

async def main():
    res = await asyncio.gather(test(), handle())
    return res

print(asyncio.run(main()))

gevent包

pip install gevent
windows需要依赖（Microsoft Visual C++）

有的linux需要依赖（pip install wheel）

import gevent
import random

def gevent_a():
    for i in range(10):
        print(i,'a gevent',os.getpid())
        gevent.sleep(random.random()*2)
     return 'gevent_a'


def gevent_b():
    for i in range(10):
        print(i,'b gevent',os.getpid())
        gevent.sleep(random.random()*2)
     return 'gevent_b'

if __name__ == '__main__':
    #spawn 创建协程对象  
    g_a = gevent.spawn(gevent_a)
    g_b = gevent.spawn(gevent_b)
    
    gevent_list = [g_a,g_b]
    # 批量处理协程对象
    res = gevent.joinall(gevent_list)
    print(res)

| 函数 | 说明 | 参数 | 返回值 |
| ---------- | -------------------- | ---- | ------------ |
| get(value) | 获取异步程序结果 | | 函数的返回值 |
| join | 阻塞等待异步程序结束 | | |
| kill | 杀掉当前协程 | | |
| dead | 判断协程是否消亡 | | bool |

正则表达式`re`

正则表达式模式

模式	描述
`^`、`\A`	匹配字符串开头
`$`、`\Z`	匹配字符串的末尾
`.`	匹配任意字符，除了换行符(\n)
`[...]`	表示匹配一组字符中的任意一个，[amk]匹配’a’,‘m’,‘k’
`[^...]`	不在[]中的字符：`[^abc]`匹配除了a,b,c之外的字符
`re*`	匹配0次或者多次表达式
`re+`	至少匹配1次
`re?`	匹配0次或者1次。非贪婪方式
`re{n}`	匹配n次
`re{n,}`	至少匹配n次
`re{n,m}`	匹配n到m次
`a	b`
`\w`	匹配字母数字及下划线
`\W`	匹配非字母数字及下划线
`\s`	匹配任意空白字符，等价于[\t\n\r\f]
`\S`	匹配任意非空字符
`\d`	匹配[0-9]任意数字
`\D`	匹配任意非数字
`[0-9]`	匹配任意数字0-9中任意一个
`[a-z]`	匹配任意小写字母
`[A-Z]`	匹配任意大写字母
`[a-zA-Z0-9]`	匹配任何字母及数字
`[^0-9]`	匹配任何非数字
`\`	将特殊字符无效化
`()`	在匹配规则中只要指定的数据

0次或者多次属于贪婪模式

通过?组合变成非贪婪模式

`re`函数	说明
`findall(pattern, string [, flags])`	查找字符串中所有（非重复）出现的正则表达式模块，并返回一个匹配列表
`search(pattern, string, flags=0)`	使用可选标记搜索字符串中第一次出现的正则表达式模块，如果匹配成功，则返回匹配对象；如果失败，返回None
`group(num)`	返回整个匹配对象，或者编号为num的特定子组
`groups()`	返回一个包含所有匹配子组的元组（失败返回空元组）
`split(pattern, string, max=0)`	根据正则表达式的模式分隔符，split函数将字符串分割为列表，返回成功匹配的列表，分割最多操作max次，默认返回所有成功的位置
`match(pattern, string, flags=0)`	尝试使用带有可选的标记的正则表达式的模式来匹配字符串。成功返回匹配对象，失败返回None
`compile(pattern, flags=0)`	定义一个匹配规则的对象

re的额外匹配要求(方法中的第三个参数)

属性	描述
`re.I`、`re.IGNORECASE`	不区分大小写的匹配
`re.L`、`re.LOCALE`	根据所使用的的本地语言环境通过\w、\W、\b、\B、\s、\S实现匹配
`re.M`、`re.MULTILINE`	^和$分别匹配目标字符串中的行的起始和结尾，而不是严格匹配整个字符串本身的起始和结尾
`re.S`、`re.DOTALL`	`.`通常匹配除了\n之外的所有单个字符，该标记表示`.`可以匹配全部字符
`re.X`、`re.VERBOSE`	通过反斜线转义，否则所有空格加上#（以及在改行中所有后续文字）都被忽略，除非在一个字符类中或者允许注释并且提高可读性

抽奖系统

模块介绍

re的额外匹配要求(方法中的第三个参数)

属性	描述
`re.I`、`re.IGNORECASE`	不区分大小写的匹配
`re.L`、`re.LOCALE`	根据所使用的的本地语言环境通过\w、\W、\b、\B、\s、\S实现匹配
`re.M`、`re.MULTILINE`	^和$分别匹配目标字符串中的行的起始和结尾，而不是严格匹配整个字符串本身的起始和结尾
`re.S`、`re.DOTALL`	`.`通常匹配除了\n之外的所有单个字符，该标记表示`.`可以匹配全部字符
`re.X`、`re.VERBOSE`	通过反斜线转义，否则所有空格加上#（以及在改行中所有后续文字）都被忽略，除非在一个字符类中或者允许注释并且提高可读性