如果想要好的观感，建议进入我的博客
Python的学习
环境的搭建
请参考以下文章
Python：环境变量配置方法 详细教程_python环境变量的配置-优快云博客
编译器的下载
https://www.jetbrains.com.cn/en-us/pycharm/
HelloWorld案例的实现
print("HelloWorld")
基础语法
输入与输出
print() 输出括号的内容之后默认回车，变量与变量之间用逗号隔开
input(提示信息) 显示提示信息（可有可无），接收键盘的输入，获得的内容默认转换为字符串
注释
# 为单行注释
""" """ 为多行注释
变量
概述：
能够储存计算结果的或能表示值的抽象概念，变量没有数据类型，可以存储任意数据
type()
概述：判断数据类型
常见的转换语句
| 语句（函数） | 说明 |
|---|---|
| int(x) | 将x转换为一个整数 |
| float(x) | 将x转换为一个浮点数 |
| str(x) | 将对象x转换为字符串 |
字符串的拼接与格式化
拼接：
使用“+”号连接字符串变量或者字符串字面量，但是无法与非字符串类型进行拼接
格式化：
- “%占位符”%变量
- f“{变量} {变量}”
if语句
格式：
if型：
if 要判断的条件：
条件成立时，要做的事
#注意，用缩进表示归属于的代码块
if else型：
if 要判断的条件：
条件成立时，要做的事
else：
条件不成立及要做的事
if elif else型：
if 要判断的条件：
条件成立时，要做的事
elif 要判断的条件：
条件成立及要做的事
else：
条件不成立要做的事
随机数的产生
import random
num = random.randint(a,b)
while循环
while 条件：
条件满足时，做的事情
嵌套循环
注意用缩进表示层次关系就行
for循环
格式：
for 临时变量 in 待处理数据集（序列）：
循环执行代码
注意：他会将序列的元素一个一个放入临时变量里在代码区处理，直到所有的元素都处理才停止
循环中断与停止
- continue：中断循环，直接进入下一次
- break：结束循环
range语句
功能：
获得一个数字序列
语法格式：
range(num) #从0开始到num结束（不含有num本身），步长默认为1
range(num1,num2) #从num1到num2结束（不含有num2本身），步长默认为1
range(num1,num2,step) #从num1到num2结束（不含有num2本身），步长为step
range用途很多，多数用在for循环场景
函数
概述：
组织好的，可重复使用的，用来实现特定功能的代码段
定义：
def 函数名（传入参数）：
函数体
return 返回值
lambda匿名函数
概述：无名称的函数，只可临时使用一次
定义：
lambda 传入参数：函数体（一行代码）
注意：只能写一行代码，无法写多行代码
多个返回值
def test_return():
return 1,2
x,y = test_return()
print(x) #结果1
print(y) #结果2
按照返回的顺序，写对应顺序的多个变量接受即可
变量之间用逗号隔开
支持不同类型的数据return
多个传参方式
-
位置传参：根据参数位置来传递参数
-
关键字传参：通过”键=值“形式传递参数，没有顺序要求
-
缺省参数：缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值
-
不定长参数：也叫可变参数，用于不确定调用的时候会传递多少个参数（不传参也可以）
-
位置传递
def user_info(*arge): print(arge) #('TOM') user_info('TOM') #('TOM','18') user_info('TOM',18) 注意： 传进的所有参数都会被args变量收集，他会根据传进参数的位置合并为一个元组（tuple），args是元组类型，这就是元组类型，这就是元组类型，这就是位置传递 -
关键字传递
def user_info(**kargs): print(kwargs) #{'name';'TOM','age';18,'id':110} user_info(name='TOM',age=18,id=110) 注意： 参数是”键=值“形式的形式的情况下，所有的”键=值“都会被kwargs接受，同时会根据”键=值“组成字典
-
注意：
- 位置参数必须出现在其他参数前面，包括函数定义和调用
函数作为参数传递
def test_func(compute):
result = compute(1,2)
print(result)
def compute(x,y):
return x+y
test_func(compute) #结果：3
这是一种计算逻辑的传递，而非数据的传递，就像上述代码那样，不仅仅是相加，相减，相除，等任何逻辑都可以自行定义并作为函数传入
None
概述：
None是类型‘NoneType’的字面量，用于表示：空的，无意义的
函数不是用return就会默认返回None
说明文档
"""
param x: 参数x的说明
param y: 参数y的说明
return: 返回值的说明
"""
类型注解
变量注解
- 语法一：变量：类型
- 语法二：在注释中，#type：类型
函数注解：
def 函数方法名(形参：类型，……，形参：类型) -> 返回值类型：
pass
注意，返回值类型注解的符号使用：->
Union注解（联合类型注解）：
- 导包：from typing import Union
- 使用：Union[类型，……，类型]
局部变量与全局变量
局部变量：
定义在函数内部，外部无法使用
全局变量：
定义在函数外面，函数内外都可以使用，定义在函数内部的变量可以通过global关键字声明为全局变量
对象
在程序中是可以做到和生活中那样，设计表格，生产表格，填写表格的组织形式的
1.在程序中设计表格，我们称为：设计类（class）
2.在程序中打印生产表格，我们称之为：创建对象
3.在程序中填写表格，我们称之为：对象属性赋值
类
1.类是由哪两部分组成呢？
-
类的属性，称之为：成员变量
-
类的行为，称之为：成员方法
注意：函数是写在类外的，定义在类内部，我们都称之为方法
2.类和成员方法的定义语法
class 类名称:
成员变量
def 成员方法(self,参数列表):
成员方法体
对象 = 类名称()
3.self的作用
- 表示类对象本身的意思
- 只有通过self，成员方法才能访问类的成员变量
- self出现在形参列表中，但是不占用参数位置，无需理会
类与对象
1.现实世界的事物由什么组成？
- 属性
- 行为
类也可以包含属性和行为，所以使用类描述现实世界事物非常合适的
2.类和对象的关系是什么？
- 类是程序中的“设计图纸”
- 对象是基于图纸生产的具体实体
3.什么是面向对象编程？
面向对象编程就是，使用对象进行编程。
即，设计类，基于类创建对象，并使用对象来完成具体的工作
构造方法
Python类可以使用：_ init _ ()方法，称之为构造方法。
可以实现：
- 在创建对象（构造类）的时候，会自动执行。
- 在创建类对象（构造类）的时候，将传入的参数自动传递给_ init _方法使用
class student:
name = None
age = None 这些可以不写
tel = Nome
def _init_(self,name.age.tel):
self.name = name
self.age = age
self.tel = tel
print("student类创建了一个对象")
魔术方法
| 方法 | 功能 |
|---|---|
| _ init _ | 构造方法，可用于创建类对象的时候设置初始化行为 |
| _ str _ | 用于实现类对象转字符的行为 |
| _ lt _ | 用于两个类对象进行小于或大于比较 |
| _ le _ | 用于两个类进行小于等于或大于等于比较 |
| _ eq _ | 用于两个类进行相等比较 |
封装
1.封装的概念是指？
将现实世界事物在类中描述为属性和方法，即为封装。
2.什么是私有成员？为什么需要私有成员？
现实事物有部分属性和行为是不公开对使用者开放的。同样在类的描述属性和方法的时候也需要到达这个要求，就需要定义私有成员了
3.如何定义私有成员？
成员变量和成员方法的命名均以 __ 作为开头即可
4.私有成员的访问限制？
- 类对象无法访问私有成员
- 类中的其他成员可以访问私有成员
继承
什么是继承？
继承就是一个类，继承另外一个类的成员变量和成员方法
语法：
class 类(父类1,父类2,父类3,...,父类n):
类内容体
子类构建的类对象，可以
- 有自己的成员变量，和成员方法
- 使用父类的成员变量和成员方法
2.单继承和多继承
单继承：一个类继承另一个类
多继承：一个类继承多个类，按照顺序从左向右依次继承
多继承中，如果父类有同名方法或属性，先继承的优先级高于后继承
3.pass关键之的作用是什么
pass是占位语句，用来保证函数（方法 ）或类定义的完整，表示无内容，空的意思
复写
1.复写表示：
对父类的成员属性或者成员方法进行重新定义
2.复写的语法：
在子类中重新实现同名成员方法或成员属性即可
3.在子类中，如何调用父类成员
方法一：
-
调用父类成员
使用成员变量：父类名.成员变量
使用成员方法：父类名.成员方法(self)
方法2：
-
使用super()调用父类成员变量
使用成员变量：super().成员变量
使用成员方法：super().成员方法()
注意：只能可以在子类内部调用父类的同名成员，子类的实体类对象调用默认是调用子类复写的
多态
1.什么是多态？
多态指的是，同一个行为的不同对象获得不同的状态。
如，定一个函数（方法），通过类型注释声明需要父类对象，实际传入子类对象进行工作，从而获得不同的工作状态
2.什么是抽象类（接口的）
包含抽象方法的类，称之为抽象类。抽象方法是指：没有具体实现的方法（pass）称之为抽象方法
3.抽象类的作用
多用于做顶层设计（设计标准），一边子类做具体实现。
也是对子类的一种软性约束，要求子类必须复写（实现）父类的一些方法，并配合多态使用，获得不同的工作状态。
闭包
1.什么是闭包？
定义双重函数，内层嵌套可以访问外层函数的变量，将内存函数作为外层函数的返回，此内层函数就是闭包函数
2.闭包的好处和缺点？
- 优点：不定义全局变量，也可以让函数持续访问和修改一个外部变量
- 优点：闭包函数引用的外部变量，是外层函数的内部变量。作用域封闭难以被误操作修改
- 缺点：额外的内存占用
3.nonlocal关键字的作用
在闭包函数（内部函数中）想要修改外部变量的变量值，需要用nonlocal声明这个外部变量
装饰器
1.什么是装饰器？
装饰器就是使用一个闭包函数，在闭包函数内调用目标函数。可以达到不改动目标函数的同时。增加额外的功能。
2.装饰器的写法
def outer(func):
def inner();
print("我要睡觉了")
func()
print("我要起床了")
return inner
@outer
def sleep():
import random
import time
print("睡眠中……")
time.sleep(random.randint(1,5))
sleep()
设计模式
1.什么是设计模式
设计模式就是一种编程套路。使用特定的套路得到特定的效果
2.什么是单例设计模式
单例模式就是对一个类，只获取其唯一的类实例对象，维持复用它。
- 节省空间
- 节省创建对象的开销
3.什么是工厂模式
将对象的创建由使用原生类本身创造，转换到由特定的工厂方法来创造
4.好处
- 大批量创建对象的时候有统一的入口方法，易于代码维护
- 当发生修改，仅修改工厂类的创建方法即可
- 符合现实世界模式，即由工厂来制作产品（对象）
线程
1.什么是进程
程序在操作系统内运行，即成为一个运行进程
2.什么是线程
进程内部可以有多个线程，程序的运行本质上就是由进程内部的线程在实际工作的
3.什么是并行执行
- 多个线程同时在运行，即不同的程序同时运行，称之为：多任务并行执行
- 一个进程内多个线程同时在运行，称之为：多线程并行执行
threading模块
import threading
thread_obj = threading.Thread([group [,targer [, name [, args [,kwargs]]]])
- group:暂时无用，未来功能的预留参数
- target:执行目标任务名
- args:以元组的方式给执行任务传参
- kwargs:以字典方式给执行任务传参
- neme:线程名，一般不用设置
#启动线程，让线程开始工作
thread_obj.start()
#创建线程对象
thread_obj = threading.Thread(target=func)
数据库
1.数据库是什么？有什么作用呢？
数据库就是指数据存储的库，作用就是组织数据并存储数据。
2.数据库如何组织数据呢？
按照：库->表->数据 三个层级进行组织
3.数据库软件是什么？我们学习哪种数据库软件呢？
数据库软件就是提供库->表->数据,这种数据组织形式的工具软件，也是称之为数据库管理系统
常见的数据库软件由：Oracle，MySQL，SQL Server，PostgreSQL，SQLite
4.数据库和SQL的关系是？
数据库（软件）提供数据组织储存的能力
SQL语句则是操作数据，数据库的工具语言
数据容器
概述：
一种可以存储多个元素的python数据类型
常见的有list（列表），tuple（元组），str（字符串），set（集合），dict（字典）
list
基本格式：
#字面量
[元素1，元素2，元素3，...]
#定义变量
变量名称 = [元素1，元素2，元素3，...]
#定义空列表
变量名称 = []
变量名称 = list[]
索引：
每个元素都有编号，被称为下标索引
- 从前到后的方向，编号从0开始递增
- 从后向前的方向，编号从-1开始递减
列表的方法
| 使用方式 | 说明 |
|---|---|
| 列表.append（元素） | 向列表中追加一个元素 |
| 列表.extend（容器） | 将数据容器的内容依次取出，追加到列表尾部 |
| 列表.insert（下标，元素） | 在指定下标处，插入指定的元素 |
| del 列表[下标] | 删除列表指定下标元素 |
| 列表.pop(下标) | 删除列表指定下标元素 |
| 列表.remove(元素) | 从前向后，删除此元素第一个匹配项 |
| 列表.clear() | 清空列表 |
| 列表.count(元素) | 统计此元素在列表中出现的次数 |
| 列表.index(元素) | 查找指定元素在列表的下标（找不到会报错ValueError） |
| len(列表) | 统计容器内有多少元素 |
特点
- 可以容纳不容类型的元素（混装）
- 数据是有序的（有下标序号）
- 允许数据重复
tuple
基本格式：
#定义元组字面量
(元素，元素，....)
#定义元组变量
变量名称 = (元素，元素，....)
#定义空元组
变量名称 = ()
变量名称 = tuple()
元组的方法
| 方法 | 说明 |
|---|---|
| index() | 查找指定元素在元组的下标（找不到会报错ValueError） |
| count() | 统计此元素在元组中出现的次数 |
| len(元组) | 统计容器内有多少元素 |
元组的特点
多数特性与列表一致，不同点在于元组具有不可以修改的特性
str
索引：
- 从前到后的方向，编号从0开始递增
- 从后向前的方向，编号从-1开始递减
#通过下标获取特定位置字符
name = "helloworld"
print(name[0]) #结果为h
print(name[-1])#结果为d
字符串的替换
语法：字符串.replace(字符串1，字符串2)
功能：将字符串内的全部内容：字符串1，替换为字符串2，返回一个新的字符串
字符串的分割
语法：字符串.split(分隔符字符串)
功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并返回一个列表对象
规整操作
语法：字符串.strip() #去除前后的空格
语法：字符串.strip(字符串1) #去除前后指定字符串1中字符
特点
- 只存储字符串
- 不可修改
序列
概述：
内容有序，可以使用下标索引的一类数据容器，列表，元组，字符串，均可以视为序列
切片：
语法：序列[起始：结束：步长]
- 起始可以省略，省略从头开始
- 结束可以省略，省略到尾结束
- 步长可以省略，省略步长为1（可以为负数，表示倒叙执行）
set
基本格式
#定义集合字面量
{元素，元素，……}
#定义集合变量
变量名称 = {元素，元素，……}
#定义空集合
变量名称 = set()
常用功能
| 操作 | 说明 |
|---|---|
| 集合.add(元素) | 集合内添加一个元素 |
| 集合.remove(元素) | 移除集合内指定元素 |
| 集合.pop() | 从集合中随机取出一个元素 |
| 集合.clear() | 将集合清空 |
| 集合1.difference(集合2) | 得到一个新集合，内含2个集合的差集，原有的2个集合内容不变 |
| 集合1,difference_updata(集合2) | 在集合1中，删除集合2中存在的元素，集合1被修改，集合2不变 |
| 集合1.union(集合2) | 得到1个新集合，内含2个集合的全部元素，原有的2个集合内容不变 |
| len(集合) | 得到一个整数，记录集合的元素数量 |
特点
- 可以容纳不同的数据类型（混装）
- 数据是无序存储的
- 没有重复数据
- 可以增加删除元素
- 支持for循环
dict
基本格式：
#字典存储的是键值对
#定义字典字面量
{key:value,key:value,……}
#定义字典变量
my_dict = {key:value,key:value,……}
#定义空字典
my_dict = {}
my_dict = dict()
注意
- 键值对的Key和Value可以是任意类型（key不可以为字典）
- 字典内的Key不能重复，重复添加等于覆盖原有数据
- 字典没有下标索引，但可以通过key索检value
常用功能
| 操作 | 说明 |
|---|---|
| 字典[key] | 获取指定key对应的value值 |
| 字典[key]=value | 添加或更新键值对 |
| 字典.pop(key) | 取出key对应的value并在字典内删除此key的键值对 |
| 字典.clear() | 清空字典 |
| 字典.keys() | 获取字典的全部key，可用于for循环遍历字典 |
| len(字典) | 计算字典内的元素数量 |
容器的通用功能
| 功能 | 说明 |
|---|---|
| 通用for循环 | 遍历容器（字典是遍历Key） |
| max() | 容器内最大的元素 |
| min() | 容器内最小的元素 |
| len() | 容器元素的个数 |
| list() | 转换为列表 |
| tuple() | 转换为元组 |
| str() | 转换为字符串 |
| set() | 转换为集合 |
| sorted(序列，[reverse=True]) | 排序，reverse=True表示降序得到一个排好序的列表 |
列表的sort方法
使用方法：
列表.sort(key=选择排序依据的函数，reverse=True|False)
- 参数key，要求传入一个函数，表示将列表的每一个元素都传入函数中，返回排列的依据
- 参数reverse，是否反转排序结果，True表示降序，False表示升序
文件
open()打开函数
open(name,mode,encoding)
name:文件名或文件路径
mode:访问模式
encoding：编码格式（推荐使用UTF-8）
示例代码：
f=open('python.txt','r',encoding='UTF-8')
#encoding的顺序不是第三位，所以不能用位置参数，用关键字参数直接指定
访问模式
| 模式 | 描述 |
|---|---|
| r | 以只读方式打开文件。文件的指针将会再文件的开头。这是默认模式 |
| w | 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，原有内容会被删除，如果该文件不存在，创建新文件。 |
| a | 打开一个文件用于追加。如果该文件已存在，新的内容将会被写入到已有的内容。如果该文件不存在，创建新文件进行写入。 |
操作总汇
| 操作 | 描述 |
|---|---|
| 文件对象 = open(file,mode,encoding) | 打开文件获取文件对象 |
| 文件对象.read(num) | 读取指定长度字节，不指定num读取文件全部 |
| 文件对象.readline() | 读取一行 |
| 文件对象.readlines() | 读取全部行，得到列表 |
| for line in 文件对象 | for循环文件行，一次循环得到一行数据 |
| 文件对象.close() | 关闭文件对象 |
| with open() as f | 通过with open语法打开文件，可以自动关闭 |
| 文件对象.wirte() | 写入内容 |
| 文件对象.flush() | 刷新内容到硬盘里 |
捕获异常
语法：
try:
可能发生异常的语句
except 异常 as 别名:
出现异常的手段
else:
未出现异常时应做的事情
finally:
不管出没出异常都会做的事情
导入模块
概述：
就是一个Python文件，里面有类，函数，变量，我们可以拿来用（导入模块去使用）
语法
[from 模块名] import [模块|类|变量|函数|*] [as 别名]
注意：
- from可以省略，直接import即可
- as别名可以省略
- 通过“.”来确定层级关系
_main_变量的功能是？
if _main_=="_main_"表示，只有当前程序是直接执行的才会进入if内部，如果是被导入的，则if无法进入
注意：
不同模块，同名的功能，如果都被导入，那么后导入的会覆盖先导入的
_all_变量可以控制import*的时候那些功能可以被导入
什么是Python的包？
包就是一个文件夹，里面可以存放许多Python的模块（代码文件），通过包，在逻辑上将一批模块归为一类，方便使用。
_init_.py文件的作用？
创建包会默认自动创建的文件，通过这个文件来表示一个文件夹是Python的包，而非普通的文件夹。
_all_变量的作用？
同模块中学习到的是一个作用，控制import*能够导入的内容
第三方包
概述：
非Python官方制作的包，具有丰富的功能，可以提升我们题高开发效率，如：
- 科学计算中常用的：numpy包
- 数据分析中常用的：pandas包
- 大数据计算中常用的：pyspark，apache-flink包
- 图形可视化常用的：matplotlib，pyecharts
- 人工智能常用的：tensorflow
- 等
安装第三方包-pip
利用Python内置的pip程序
- 打开我们许久未见的：命令提示符程序，在里输入：
- pip install 包名称
- pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名称
数据可视化
什么是json
- Json是一种轻量级的数据交互格式。可以按照json指定的格式去组织和封装数据
- json本质上是一个带有特定格式的字符串
主要功能：json就是一种在各个编程语言中流通的数据格式（各种编程语言的中转站），负责不同编程语言中的数据传递和交互，类似于：
- 国际通用语言—英语
- 全中国通用语言—普通话
Python语言使用JSON有很大优势，因为：JSON无非就是一个单独的字典或者一个内部元素都是字典的列表
所以JSON可以直接和Python的字典或列表无缝转换。
操作
| 操作 | 描述 |
|---|---|
| json.dumps(data) | 将python数据转换为json数据，如果有中文数据可以使用：ensure_ascii=False参数来确保中文正常转换 |
| json.loads(data) | 将json数据转换为Python列表或者字典 |
PyEcharts模块
开发可视化图使用的技术栈是：
Echarts框架的Python版本：PyEcharts包
如果查看官方示例：
打开官方画廊：https://gallery.pyecharts.org/#/README
基础折线图
# 导包Line功能构建折线图对象
from pycharts.charts import Line
# 得到折线图对象
line = line()
# 添加x轴数据
line.add_xaxis(['中国','美国','英国'])
# 添加y轴数据
line.add_yaxis("GDP",[30,20.10])
# 生成图表
line,render()
全局配置选项
- 配置图标的标题
- 配置图列
- 配置鼠标移动效果
- 配置工具栏
- 等整体配置项
基础地图
# 导包map实现对象创造
from pycharts.charts import Map
# 准备地图对象
map = Map()
# 准备数据
data = [
("北京",99),
("上海",199),
("湖南",299),
("台湾",399),
("广东",499)
]
# 添加数据
map.add("测试地图",data,"china")
#绘图
map.render()
基础柱状图
# 导包Bar
from pyecharts.charts import Bar
from pyecharts.options import LabelOpts
# 构造柱状图对象
bar = Bar（）
# 添加x轴数据
bar.add_xaxis(["中国","英国","美国"])
# 添加y轴数据
bar.add_yaxis("GDP",[30,20.10],label_opts=LabelOpts(position="right"))
# 反转x和y轴
bar.reversal_axis()
# 绘图
bar.render("基础柱状图.html")
基础时间柱状图
# 导包Bar
from pyecharts.charts import Bar，Timeline
from pyecharts.options import LabelOpts
# 构造时间线对象
timeline = Timeline()
# 在时间线内添加柱状图对象
timeline.add(bar1,"点1")
timeline.add(bar2,"点2")
timeline.add(bar3,"点3")
# 设置自动播放
timeline.add_schema(
play_interval=1000, #自动播放的时间间隔，单位毫秒
is_timeline_show=True, #是否在自动播放的时间，显示时间线
is_auto_play=True, #是否自动播放
is_loop_play=True #是否循环自动播放
)
# 绘图
timeline.render("基础时间柱状图.html")
设置主题
from pyecharts.globals import ThemeType
timeline = Timeline(
{"theme":themeType.LIGHT}
)
正则表达式
概述:
就是使用字符串来定义规则，并通过规则去验证字符串是否匹配
正则的三个基础方法：
Python正则表达式，使用re模块，并基于re模块中的三个基础方法来做正则匹配。分别是：match,search,findall三个基础方法
-
re.match(匹配规则，被匹配字符串)
从被匹配字符串开头进行匹配，匹配成功返回匹配对象（包含匹配的信息），匹配不成功返回空 s = 'python itheima python itheima python itheima' result = re.match('python',s) print(result) #<re.Match object; span=(0,6),match='python' print(resuit.span()) #(0,6) print(resuit.group()) #python s = '1python itheima python python itheima' result = re.match('python',s) print(result) #None -
search（匹配规则，被匹配字符串）
搜索整个字符串，找出匹配的。从前向后，找到第一个后，就停止，不会继续向后 s = '1phthon666itheima666python666' result = re.search('python',s) print(result) #<re.Match object;span=(1,7),match='python'> print(result.span()) #(1,7) print(result.group()) #python 整个字符串都找不到，返回None s = 'itheima666' result = re.search('python',s) print(result) #Nome -
findall(匹配规则，被匹配字符串)
匹配整个字符串，找出全部匹配项 s = '1python666itheima666python666' result = re.findall('python',s) print(result) #{'python','python'} 找不到返回空list:[] s = '1python666itheima666python666' result = re.findall('itcast',s) print(resuit) #[]
元字符匹配
单字符匹配：
| 字符 | 功能 |
|---|---|
| . | 匹配任意一个字符（除了\n），\ .匹配点本身 |
| [] | 匹配[]中列举的字符 |
| \d | 匹配数字，即0-9 |
| \D | 匹配非数字 |
| \s | 匹配空白，及空格，tab键 |
| \S | 匹配非空白 |
| \w | 匹配单词字符，即a-z，A-Z，0-9，_ |
| \W | 匹配非单词字符 |
示例：
字符串 s = "itheima1@@python2!!666##itcast3"
找出全部数字：re.findall(r'\d',s)
找出特殊字符：re.findall(r'\W',s)
找出全部英文字母：re.findall(r'[a-zA-Z]',s)
[]内可以写：[a-zA-Z0-9]这三种范围组合或指定单个字符如[aceDFG135]
注意：字符串的r标记表示，字符串内转移字符无效，作为普通字符使用
数量匹配：
| 字符 | 功能 |
|---|---|
| * | 匹配前一个规则的字符现0至无数次 |
| + | 匹配前一个规则的字符出现1至无数次 |
| ？ | 匹配前一个规则的字符出现0次或1次 |
| {m} | 匹配前一个规则的字符出现m次 |
| {m,} | 匹配前一个规则的字符出现最少m次、 |
| {m,n} | 匹配前一个规则的字符出现m到n次 |
边界匹配：
| 字符 | 功能 |
|---|---|
| ^ | 匹配字符串开头 |
| $ | 匹配字符串结尾 |
| \b | 匹配一个单词的边界 |
| \B | 匹配非单词边界 |
分组匹配：
| 字符 | 功能 |
|---|---|
| | | 比配左右任意一个表达式 |
| () | 将括号中字符作为一个分组 |
网络编程
服务端开发
#socktr创建对象
import socket
socket_server = socker.socket()
#绑定socket_server到指定IP和地址
socker_server.bind(host.port)
#服务器开始监听端口
socker_server.listen(backlog)
#backlog为int整数，表示允许的连接数量，超过的会等待，可以不填满，不填会自动设置一个合理值
#接听客服端连接，获取连接对象
conn.address = socker_server.accept()
print(f"接受到客户端连接，连接来自：{address}")
#accept方法是阻塞方法，如果没有连接，会卡再当前这一行不向下执行代码
#accpet返回的是一个二元元组，可以使用上述形式，用两个变量接受二元元组的2个元素
#客户端连接后，通过recv方法，接收客户端发送的消息
while True:
data = conn.recv(1024).decode("UTF-8")
#recv方法的返回值是字节数组（Bytes），可以通过decode使用UTF-8解码为字符串
#recv方法的传参是buffsize，缓冲区大小，一般设置为1024即可
if data == 'exit':
break
print("接收到发送来的数据："，data)
# 可以通过while True无限循环来持续和客户端进行数据交互
#可以通过判定客户端发来的特殊标记，如exit，来退出无限循环
#通过conn（客户端当次连接对象），调用send方法可以回复消息
while True:
data = conn.recv(1024).decode("UTF-8")
if data == 'exit':
break
print("接收到发送来的数据："，data)
conn.send(你好呀哈哈哈"，encode("UTF-8"))
#conn（客户端当次连接对象)和socket_server对象调用close方法，关闭连接
下载网络调试助手作为客户端
https://github.com/nicedayzhu/netAssist/releases
客服端开发
#创建socket对象
import socket
socket_client = socket.socket()
#连接到服务端
socket_client.connect(("localhost",8888))
#发送消息
while True: #可以通过无限循环来确保持续的发送消息给服务端
send_msg = input("请输入要发送的消息")
if send_msg = 'exit':
# 通过特殊标记来确保可以退出无限循环
break
socket_client.send(send_msg.encode("UTF-8")
# 消息需要编码为字节数组（UTF-8编码)
#接收返回消息
while True:
send_msg =input("请输入要发送的消息").encode（"UTF-8")
socket_client.send(send_msg)
recv_data = socket_client.recv(1024) # 1024是缓冲区大小，一般1024即可
#recv方法是阻塞式的，即不接收到返回，就卡在这里等待
print("服务端回复消息为：",recv_data.decode("UTF-8"）)
#接受的消息需要通过UTF-8解码为字符串
#关闭链接
socket_client.close() # 最后通过close关闭链接
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
