python 进阶课程
====================数据结构、链表操作========================
数据结构
逻辑结构
存储结构
线性表的链式存储
单链表类构建
1 #创建节点类 2 class Node: 3 '''将自定义的类视为节点的生成类，实例对象中包含数据部分和指向下一个节点的 next'''' 4 5 def __init__(self, val, next=None): 6 self.val = val # 有数据 7 self.next = next # 循环下一个节点的关系
1 class LinkList: 2 def __init__(self): #初始化链表，标记一个链表的开端，以便于获取后续的节点 3 self.head = Node(None) 4 5 def init_list(self,list_): #通过 list_ 为链表添加一组节点 6 p = self.head 7 for item in list_: 8 p.next = Node(item) 9 p = p.next
1 #遍历链表 2 def show(self): 3 p = self.head.next #第一个有效节点 4 while p is not None: 5 print(p.val) 6 p = p.next #p 向后移动
1 # 判断链表为空 2 def is_empty(self): 3 if self.head.next is None: 4 return True 5 else: 6 return False 7 8 # 清空链表 9 def clear(self): 10 self.head.next = None 11 12 # 尾部插入 13 def append(self, val): 14 p = self.head 15 while p.next is not None: 16 p = p.next 17 p.next = Node(val) 18 19 # 头部插入 20 def head_insert(self, val): 21 node = Node(val) 22 node.next = self.head.next 23 self.head.next = node 24 25 # 指定插入位置 26 def insert(self, index, val): 27 p = self.head 28 for i in range(index): 29 if p.next is None: 30 break 31 p = p.next 32 node = Node(val) 33 node.next = p.next 34 p.next = node
删除节点
1 def delete(self, x): 2 p = self.head 3 while p.next and p.next.val != x: # and 左右判断不能颠倒 4 p = p.next 5 6 if p.next is None: 7 raise ValueError("x not in linklist") 8 else: 9 p.next = p.next.next
获取节点
1 # 传入节点位置，获取节点的值 2 def get_index(self, index): 3 p = self.head.next 4 for i in range(index): 5 if p.next is None: 6 raise IndexError(index out of range") 7 p = p.next 8 return p.val
====================栈、队列========================
栈
栈模型
1 class SStack: 2 3 def __init__(slef): 4 5 self._elems = [] #空列表就是栈的存储空间，列表的最后一个元素作为栈顶 6 7 def is_empty(self): #判断栈是否为空 8 9 return self._elems == [] 10 11 def push(self,val): #入栈 12 13 self._elems.append(val) 14 15 def pop(self): #出栈 16 17 return self._elems.pop() 18 19 def top(self): #显示栈顶元素 20 21 return self._elems[-1]
栈的链式栈
1 #自定义异常 2 class StackError(Exception): 3 pass 4 5 class Node: 6 def __init__(self, val, next=None): 7 self.val = val 8 self.next = next 9 10 #链式栈操作 11 class LStack: 12 def __init__(self): 13 #标记栈的栈顶位置 14 self._top = None 15 16 def is_empty(self): 17 return self._top is None 18 19 def push(self,val): 20 #node = Node(val) 21 #node.next = self._top 22 #self._top = node 23 self._top = Node(val,self._top) 24 25 def pop(self): 26 if self._top is None: 27 raise StackError("Stack is empty") 28 value = self._top.val 29 self._top = self._top.next 30 return value 31 32 def top(self): 33 if self._top is None: 34 raise StackError("Stack is empty") 35 return self.top.val 36
队列
队列的操作：入队、出队、
1 #自定义队列异常 2 3 class QueueError(Exception): 4 pass 5 6 #队列操作 7 8 class Squeue: 9 10 def __init__(self): 11 self._elems = [] 12 13 #判断队列是否为空 14 def is_empty(self): 15 return self._elems == [] 16 17 #入队 18 def enqueue(self,val): 19 self._elems.append(val) 20 21 #出队 22 def dequeue(self): 23 if not self._elems: 24 raise QueueError("Queue is empty") 25 return self._elems.pop(0)
链式队列
1 # 队列操作 2 3 class LQueue: 4 def __init__(self): 5 # 定义队头和队尾的属性变量 6 self.front = self.rear = Node(Node) #无用节点 7 8 def is_empty(self): 9 return self.front == self.rear 10 11 # 入队 rear动 12 def enqueue(self,val): 13 self.rear.next = Node(val) 14 self.rear = self.rear.next 15 16 # 出队 front 动 17 def dequeue(self): 18 if self.front == self.rear: 19 raise QueueError("Queue is empty") 20 # 认为 front 指向的节点已经出队 21 self.front = self.front.next 22 return self.front.val
====================二叉树、算法基础========================
树形结构
二叉树
二叉树实践
1 class Node:
2 def __init__(self,val,left=None,right=None): 3 self.val = val 4 self.left = left 5 self.right = right 6 7 #遍历二叉树 8 class Bitree: 9 def __init__(self,root = None): 10 self.root = root 11 12 #先序遍历 13 def preOrder(self,node): 14 if node is None: #终止条件 15 return 16 print(node.val) 17 self.preOrder(node.left) 18 self.preOrder(node.right) 19 20 #中序遍历 21 def inOrder(self,node): 22 if node is None: #终止条件 23 return 24 self.inOrder(node.left) 25 print(node.val,end = "") 26 self.inOrder(node.right)
层次遍历
算法基础
排序
# 选择排序
=====================================linux_IO=================================================
二分查找
Linux命令
linux 目录结构：
.开头的都是隐藏文件
ctrl+alt+t 打开新终端
ctrl+shift+n 打开当前新终端
ctrl+l 清屏
IO与字节串
文件操作
打开文件：
读取文件：
read([size]) #读取文件，默认读取全部。文件过大的话，建议设置 size 参数
readline([size]) #读取一行
readlines([sizeint]) #读取文件中的每一行作为列表中的一项
# f 为可迭代对象，每次迭代一行内容
写入文件：
write()
writelines() #也需要人为添加换行
open() :第三个参数
示例：文件复制操作
===============================TCP、UDP 编程=============================================
with 操作、文件缓冲区
缓冲刷新条件：
1、缓冲区满了
2、行缓冲换行时会自动刷新
3、程序运行结束或者文件close 关闭
4、调用 flush() 函数
文件偏移量
空洞文件、文件函数
空洞文件：在文件结尾，向后偏移，会存出多余的空间，以便使用(例如文件下载，会提前预留出所需的空间)
文件操作函数：
import os
os.path.getsize() #获取文件大小
os.listdir('.') #获取当前目录中的文件
os.path.exists() #判断一个文件是否存在
os.path.isfile() #查看一个文件是否为普通文件
os.remove() #删除一个文件
网络编程基础
计算机网络功能主要包括实现资源共享，实现数据信息的快速传递。
OSI 七层模型
高内聚：应用模块单一化
低耦合：降低模块的依赖度
TCP/IP 模型
数据传输
网络基础概念
端口建议个人使用 10000 以上
tcp、udp 服务
socket 套接字
tcp 服务端
服务端流程
->socket-> bind-> listen-> accept-> send/recv-> close
(->电话 -> 电话号 -> 话费 -> 开机 -> 沟通 -> 销毁)
1、创建套接字
from socket import *
sockfd=socket.socket(socket_family=AF_INET, socket_type=SOCK_STREAM, proto=0)
功能：创建套接字
参数：socket_family ：网络地址类型 AF_INET 表示 ipv4
socket_type： 套接字类型 SOCK_STREAM (流式)、SOCK_DGRAM(数据报)
proto 通常为 0 ：选择子协议（tcp/udp用不到子协议，所以为零）
返回值：套接字对象
2、绑定地址
本地地址：‘localhost’ , '127.0.0.1'
网络地址：'172.40.91.188' (ifconfig的地址)
自动获取地址：'0.0.0.0'
3、设置监听
4、等待处理客户端连接请求
5、消息收发
6、关闭套接字
connfd.close()
==========================套接字属性、广播=========================
tcp 客户端
sockfd = socket() #创建套接字
#连接：
server_addr = ('127.0.0.1',8888)
sockfd.connect(server_addr)
data = inupt("Msg>>")
sockfd.send(data.encode()) #转化为字节串再发送
sockfd.close() #关闭套接字
请求连接
收发缓冲区、tcp粘包
缓冲区：
粘包：
udp客户端与服务端
服务端：
1、创建数据报套接字
2、绑定地址
3、消息收发
4、关闭套接字
客户端：
from socket import *
sockfd = socket(AF_INET,SOCK_DGRAM)
while True:
data = input("Msg>>")
sockfd.sendto(data.encode(),ADDR)
msg,addr = sockdf.recvfrom(1024)
print(“from”,data.decode())
总结：
socket套接字属性
udp应用
tcp应用
一、请求行：具体的情趣你类别和请求内容
请求类别：每个请求类别表示要做不同的事情
二、请求头：对请求的进一步解释和描述
Accept-Encoding: gzip
空行
请求头
http响应
...
struct模块
多任务编程
进程的基本概念
进程特征、fork
五态：多了新建和终止
fork代码详解
进程相关函数、孤儿和僵尸进程
os.getppid( ) 获取父级pid值
--------------------------孤儿进程、僵尸进程--------------------------------------------------------
僵尸进程详解
为 避免阻塞，可以使用二级子进程处理僵尸
==============================concurrent=================================================
群聊聊天室01
群聊聊天室02
multiprocessing创建多进程
等同于
进程对象属性
进程池
---------------------------------------------------------------进程间通信、threading线程、线程间通信---------------------------
进程间通信Pipe
进程间通信Queue
进程间通信--共享内存
进程间通信--信号量
线程编程
！ 进程包含线程，线程共享进程资源
Threading模块
启动线程
回收线程
线程参数传递、对象属性
自定义线程类
线程间通信方法、Event
1、线程间使用全局变量进行通信
2、
Lock、死锁
from threading import Thread,Lock
总结
--------------------------------------------------------------------------------------------------------------------
并发网络通信
多线程并发
IO
非阻塞IO
IO多路复用
准备就绪：操作系统已经感知到了发生，交给应用程序处理；不可逆行为
select方法：
位运算
与：一假则假
或：一真则真
异或：相同为零不同为一
poll方法
epoll
协成
HTTP2.0
正则表达式
^ 匹配以某个字符开头 \A
$ 匹配以某个字符结尾 \Z
* 前面一个字符出现0或多次
+ 前面一个字符出现1或多次
？前面字符0或1次
{} 匹配字符出现指定次数
\d 匹配任意数字字符，相当于 [0-9]
\D 匹配任意非数字字符，相当于[^0-9]
\w 匹配普通字符 （数字字母下划线）
\W 匹配非普通字符
\s 匹配空字符 （\r \n \t \v \f）
\S 匹配非空字符
\b 单词边界 数字字母下划线与其他字符交界位置
\B 非单词边界
贪婪模式
非贪婪模式
？ 变成非贪婪模式
1 .com 邮箱
分组
re.search()
RE 模块
flags
=============================================mysql=======================
mysql
sql 语句
1. show databases; #查看数据库
数据表
数字类型：
单精度和双精度区别是小数点后的位数不同
字符串类型：
表的操作
主键：唯一确定（区分）一个记录的字段，主键不能为空，不能重复
desc class; #查看class表结构
show create table class; #查看class表的建表语句
增加数据
日期时间函数
时间操作、高级查询语句
排序、分页、联合查询
数据库备份与修复
pymysql 的使用
二进制文件存储
git配置
git config --list 查看git 所有配置信息
git 的基本命令
git 工作区
分支管理
远程仓库操作
-u 第一次push的时候使用，本地与远程建立起关联。
-a 查看所有分支： git push -a
软件项目开发流程
========================mysql_core===================================
聚合函数：
连接数据库插入数据：
索引：
索引优缺点：
索引分类：
========================django01====================================
========================django02====================================
========================ajax========================================
========================web_project===================================
浙公网安备 33010602011771号