python高级（二）完结

Day01

一、变量的作用域

变量 ---存储数据的
作用域 ---有效作用的范围
创建 
类型：L E G B

作用域由什么决定？

由变量所在的位置决定的

作用域的产生：

只能在 模块 类 函数中产生

局部变量---定义在函数内部的变量
全局变量---定义在函数外的变量
嵌套作用域
内置作用域

在if else for while中验证 是否有作用域？---没有！

-------作用域的类型-------

搜索变量名优先级 L E G B法则
局部 >嵌套 >全局 >内置 
L E G B

二、global nonlocal

global 在函数内部修改全局变量的
nonlocal 在嵌套函数中
内部函数修改外部函数的临时变量

三、python 中的内存管理机制

name='张三'
当我们创建变量的时候 python 的内存管理机制 
会给这个变量的值创建一个内存, 那么,这个变量就是引用这个内存地址
用id() 查看内存地址

四、深拷贝和浅拷贝（不太懂） 拷贝-- 复制 – copy
需要用到一个模块 copy 模块

1、导模块 

2、浅拷贝 copy.copy()
对不可变数据类型进行浅拷贝 内存地址是一样的
对可变数据类型进行浅拷贝 内存地址是不一样的
浅拷贝只会拷贝引用 不会拷贝内容 

3、深拷贝 copy.deepcopy()
深拷贝会复制一个和原变量内容一模一样的变量
并且对任意一个修改都不会影响另一个

五、== 和 is

== 只比较内容 不比较内存地址 ---- 浅拷贝
is 比较内容 和内存地址 是否都相同 --- 深拷贝

Day02

迭代器

1、什么是迭代器
迭代即-----遍历

2、能被便利的数据类型有？
str list dict set tuple
for i in 序列：
print(i)

—列表的遍历—

#—字典的遍历—

3、可迭代对象

能被for 遍历的对象 就是可迭代对象 Iterable

4、如何判断一个对象是否是可迭代对象

1、能被for 遍历
2、用isinstance(o,t)
o object 要判断的对象
t type 要判断的类型 iterable/iterator
如果返回 True 代表是可迭代对象
如果返回 false 代表不可迭对象

5、能不能自己创建一个可迭代对象？ —Yes

1、通过类
2、类里边必须有 __iter__ 方法 
也就是说 具备了__iter__ 方法就是可迭代对象

6、迭代器？ —Iterator

能够帮助我们记录遍历当前元素的‘人’

7、可迭代对象不是迭代器

8、判断一个对象是否是迭代器
isinstance(o,t)

9、如何把可迭代对象变成迭代器？

1、对已知数据类型转换
2、对自定义的对象进行转换
在类里加一个 __next__
一个具备了 __iter__方法 和 __next__方式的对象 就是 迭代器

10、迭代器的输出方式

1、使用next()

2、for遍历

3、list()/tuple()

11、for循环的本质

1、先通过iter()获取可迭代对象的迭代器
2、通过next()获取值 并且把值赋给i
3、当遇到stopIteration 异常就结束循环
for i in range(1,10):
print(i)

Day03

生成器 —generator

一边循环一遍计算的机制
生成器是特殊的迭代器

一、查看迭代器的方式能不能用来查看生成器？

1、next()
2、for遍历
3、list()/tuple()

二、如何创建生成器？

1、将列表推导式的[]换成()

2、将函数中的return 换成 yield
如果一个函数中有 yield 那么这个函数就是生成器

三、yield的作用（重点）

1、将函数返回
2、保持函数的运行状态，将函数挂起

四、斐波那契数列

五、唤醒生成器的三种方式（重点）

1、next()

2、__next__

3、send() 给生成器传值

Day04

高阶函数
把一系列的运算过程转换成嵌套函数的调用
就是 一个函数把另一个函数作为参数把它传入

 ---------map---------------
1、map(func,Iterable)
用法：
将可迭代对象里的每一个元素 依次执行一遍函数 
并且将结果返回到一个迭代器里

---------reduce---------------
2、reduce() 需要导包
用法
将可迭代对象里面相邻的两个参数传到函数里执行 将结果与第三个数再放到函数里执行，依次类推 结果是一个值

# ---------sorted---------------
3、sorted()
|1| =1
|-1|=1
sorted(iterable,key=abs,reverse=True) 排序
用法：
如果可迭代对象里有负数 并且绝对值 那么排序的时候根据负数的绝对值进行排序

回忆：列表排序
使用 sort 排序
默认是正序
倒序 列表名.sort(reverse=True)

 ---------filter---------------
4、filter(func,Iterable)
用法/语法
将可迭代对象里的每一个元素依次放函数中去判断 是否满足条件 将满足条件（True） 的元素放到一个迭代器中返回 

---------返回函数---------------

返回函数
一个函数把另一个函数作为 返回值 返回 

闭包：

在嵌套函数中内部函数引用外部函数的临时变量，并且外部函数把内部函数作为返回值返回

匿名函数 形参 表达式
lambda 参数列表：表达式

装饰器
装饰器
定义：在不修改原函数代码的前提下 给函数增加新功能

需要导time模块
time.sleep(1) 暂停一秒
写一个函数func 先输出 hello 暂停一秒 输出 world 
time.time() 用来获取当前的时间

---------双层装饰器执行流程---------------

双层装饰器执行流程
1、开始的时候执行外部函数 顺序 从下往上
2、执行嵌套函数 顺序 从上往下
3、执行原函数
4、结束的时候 顺序 从下往上

---------偏函数----------

1、partial 需要导包
2、用 partial 创建一个 偏函数
函数名= partial(原函数，参数固定值)
参数必须是最后一个形参
只需要调用新函数即可

-------递归---------
优点 逻辑清晰 定义简单
缺点 过深的调用 会导致栈溢出

-------求阶乘-----------
3！ =1*2*3
5！ =1*2*3*4*5
n! =1*2*3*.......(n-1)*n

------数据结构------

网络四层协议
应用层 网络层 传输层 数据链路层

应用层 表示层 会话层 传输层 网络层
定义 是计算机 存储 组织 数据的方式

分类：

逻辑结构 面向问题的元素之间的关系
分类：线性、图形、树形 、集合
物理结构 面向计算机的 ----存储

定义：数据的螺距结构在计算机中的存储形式
分类:顺序存储结构
链式存储结构
目的都是将数据及逻辑关系 存储到计算机的内存中

--------------算法--------------

定义：
解决特定问题求解步骤的描述

算法的基本特性：
输入
输出
可行性
有穷性
确定性

算法的复杂度

时间复杂度：
计算算法运行起来所需的时间

空间复杂度：
计算算法所需的内存空间

评价一个算法的好坏重要依据 时间复杂度

时间复杂度 ： 大 O 表示法
list 中的时间复杂度
append() O(1)
pop() O(1)
pop(i) O(n)
reverse O(n)
sort O(nlogn)

字典的时间复杂度
delete O(1)

--------------线性表--------------

定义：
具备零个或多个 数据元素的有限序列

特征：
第一个元素没有前驱元素（车头）
最后一个元素没有后继元素（车尾）
其他的元素 只有一个前驱和一个后继（车厢）

操作：
插入 删除 查找

分类:

1、顺序表 ---存储结构连续
定义：
在计算机的内存中 以 一组地址连续的存储单元 依次 存储数据元素的 线性表
优缺点：
优点：支持随机访问
缺点：插入和删除需要移动大量的元素，造成存储空间的碎片
在python中的应用 ----元组/列表
时间复杂度：
访问 O(1)
插入删除 O(n)

2、链表 ---逻辑连续 存储结构不连续
定义：
(1)常见的数据结构 是一种线性表
(2)存储结构不在连续
分类：
（1）单向链表
（2）单项循环链表
（3）双向链表
一个元素域,两个链接域 
优缺点：
优点：插入删除比较方便
缺点：不支持随机访问
时间复杂度：

--------------栈--------------

定义：
只允许在表尾进行插入删除的线性表

特征：
后进先出

栈的操作： 
Stack() 创建一个新的空栈 alist=[]
push(item) 添加一个新的元素item到栈顶 append()
pop() 弹出栈顶元素 pop（-1）
peek() 返回栈顶元素 alist[-1]
is_empty() 判断栈是否为空 len(alist)==0
size() 返回栈的元素个数 len(alist)

--------------队列--------------

定义：
允许在一端进行插入，另一端进行删除的先进先出的线性表

队列的操作：
Queue() 创建一个空的队列 alist = []
enqueue(item) 往队列中添加一个item元素 alist.append()
dequeue() 从队列头部删除一个元素 alist.pop(0)
is_empty() 判断一个队列是否为空 len(alist)==0
size() 返回队列的大小 len(alist)

--------------树（了解）--------------

节点的度 一个节点含有子树的个数 称为该节点的度
树的度 最大节点的度 就是树的度
叶节点/终端节点 度为0的节点 
父节点 若一个节点含有子节点，则这个子节点的父节点
子节点 一个节点含有的子树的兄弟节点

节点的层次 从根开始定义
树的高度 最大的节点的层次
堂兄弟节点
节点的祖先
子孙
森林

树的种类：
有序树
无序树
二叉树 ***
完全二叉树
平衡二叉树
排序二叉树
霍夫曼树
B树

树的存储：
顺序存储
链序存储 ---二叉树存储的方式

树的应用：（重点） *****
1、路由协议
2、mysql 数据库索引
3、文件系统的目录结构
4、AI算法
5、xml html

二叉树
分类：
完全二叉树
满二叉树 除了叶节点 其他的节点都有左右子树

遍历
深度优先遍历

先序
根节点 ---左子树 ---右子树
A-B-D-H-I-E-J-C-F-G
中序
左子树 ---根节点 ---右子树
H-D-I-B-J-E-A-C-G
后序
左子树 ---右子树 ---根节点
H-I-D-J-E-B-F-G-A

广度优先遍历 ---层次遍历
从上往下 从左往右依次输出
A-B-C-D-E-F-G-H-I-J

排序：

------冒泡排序----


------选择排序----

查找：
------二分法查找----


-----二分法查找（递归）----

--------------网络编程--------------

TCP/IP四层网络模型:
TCP/IP协议族可以分为四层：应用层、传输层、网络层、数据链路层。

应用层协议:
与网络相关的程序通过网络与其他程序通信使用的数据格式规范。

HTTP（80端口），主要用于普通浏览。
HTTPS（443端口），HTTP协议的安全版本。
FTP（20和21端口），用于文件传输。
POP3（110端口），收邮件用。
SMTP（25端口），用来发送电子邮件。
SSH（22端口），用于加密安全登陆用。
DHCP（67端口，动态主机配置协议），动态配置IP地址。
DNS，用于完成地址查找，邮件转发等工作（运行在TCP和UDP协议上）。
SNMP，用于网络信息的收集和网络管理。
ARP，用于动态解析以太网硬件的地址。

传输层协议:
解决诸如端到端可靠性（数据是否已经到达目的地）和保证数据按照正确的顺序到达这样的问题。TCP、UDP都是传输层协议。

网络层协议:
解决在一个单一网络上传输数据包的问题。IP协议是网络层协议。

数据链路层协议:
它是数据包从一个设备的网络层传输到另外一个设备的网络层遵循的规范。比如以太网协议、Wi-Fi协议。

四层协议
ip
1、DNS
DNS 服务器用于将用户的域名请求转换为IP地址
2、查看电脑IP地址（windows）
windows ipconfig
linux ifconfig
3、ping 用来查看电脑是否有网
ping www.baidu.com

分类：
A政府机构 
B 大型公司
C 平常人
D广播
E 备用IP

端口号 0----65535
知名端口号 0---1023
动态端口号 1024--65535
80 http的端口号
mysql的端口号 3306

主机地址 127.0.0.1
localhost

查看电脑的端口
netstat -ano
查看虚拟机的端口
netstat -an

总结;IP地址用来确定是哪台电脑 而端口号是用来确定是电脑中哪个应用

socket套接字
作用：用来实现不同电脑之间进程的通信

创建socket 套接字
1、先导包 import socket
2、socket(address family,type)
address family,type 分为:
AF_INET(实现网络之间进程的通信)
AF_UNIX(一台电脑进程之间的通信)
type 分为：
udp SOCK_DGRAM
tcp SOCK_STREAM
3、关闭套接字 close

udp和tcp区别：

udp 套接字 不需要建立连接 时效性较高 多对一 一对一 一对多 多对多
tcp 套接字 需要建立连接 更加安全 一对一

----------udp通信流程---------

1、创建udp套接字
2、地址 ---ip地址
3、内容 ---input(请输入内容)
4、发送 ---sendto（）
5、接受 ---recv_data,ip_port=recvfrom(1024)
#1024接收的最大字节数
6、关闭 ---close（）

--------------Tcp--------------

需要建立连接
tcp通讯流程
三次握手 四次挥手

建立连接之前

三次握手
第一次 客户端向服务器发送请求
第二次 服务器向客户端发送确定请求 并等待连接
第三次 客户端向服务器发送确定 开始建立连接

断开连接之前

四次挥手
第一次挥手 客户端向服务端发送断开请求
第二次挥手 服务器向客户端发送确定断开请求
第三次挥手 服务器断开
第四次挥手 客户端确定断开 断开连接

--------------tcp客户端--------------

1、创建套接字
2、地址
3、建立连接
4、写内容 编码
5、发送 send()
6、接收 recv_data=recv（1024） 解码 decode（）
7、输出接收到的数据
8、关闭

--------------tcp服务端--------------

1、创建套接字
2、绑定ip地址、端口号
3、把套接字变为被动 listen()
4、等待连接 client.socket,ip_port=accept()
5、接收数据 client.socket.recv(1024).decode('gbk')
6、发送数据 client.send()
7、关闭 客户端
关闭 服务端

udp和tcp区别

1、tcp需要建立连接 安全系数高 所需要的资源多 只支持 一对一
2、udp不需要建立连接 时效性好 所需要的资源少 支持 一对一 一对多 多对一 多对多 

--------------浏览器向服务器请求数据的过程--------------

1、输入网址
2、DNS服务器 找到ip地址
3、web服务器
4、获取本地资源
5、传回web服务器 --

--------------正则表达式--------------

用到的方法
match('正则表达式','字符串') 从头开始匹配

1、匹配单字符 一个字符

. 匹配任意字符 除了\n
[] 匹配[]中列举的字符
\d 匹配数字 0-9 digit
\D 匹配非数字
\w 匹配单词 0-9 a-z A-Z word
\W 匹配非单词和数字
\s 匹配空格 tab和空格键 space
\S 匹配非空格

2、匹配多字符

+ 匹配前一个字符出现1次或无限次 至少出现1次
* 匹配前一个字符出现0次或无限次 可有可无
？ 匹配前一个字符出现0次或1次
{m} 前一个字符 m次
{m,} 匹配前一个字符至少出现m次
{m，n}匹配前一个字符至少出现m次，最多出现n次

匹配开头 ^
匹配结尾 $ 
匹配左右任意一个 | 
匹配分组 ()
\num 引用分组匹配到的字符串 
（？p<name>） 起别名
（？p=name）

格式：
import re
res=re.match(' ')
print(res.group())

search()
从起始位置开始匹配 直到遇到匹配成功才会结束


finadll()
从起始位置开始匹配 直到把所有匹配成功的字符串找出来才会结束
会把结果放到一个列表中

--------------线程和进程--------------
线程

1、多任务
定义：同一时间执行多个任务
方式：
并行 多个任务同时执行
并发 多个内容交替执行
2、用代码实现先跳舞后唱歌

--------------多个线程同时执行 一个任务--------------

3、在python中如何创建线程

1、导包 threading import threading
2、需要有函数 至少两个或多个
3、变量名=thraeding.thread(target=函数名，args/kwargs)
4、变量名.start() 开启线程

4、主线程

子线程 程序员自己创建的线程
主线程不会等待子线程结束在结束
解决办法：
用join() 实现主线程等待子线程结束后在结束

5、多线程执行起来是无序的

6、线程之间共享全局变量

--------------守护线程--------------
守护主线程：

当一个线程为守护线程时,主线程结束 守护线程是否运行完成 立即结束
主线程不会等待子线程

创建守护线程的方式：
1、t=Thread(target=func,daemon=True)
2、t.setDaemon(True）

--------------互斥锁--------------

线程之间是共享全局变量的
为了防止多个线程同时修改全局变量 就要用到互斥锁

互斥锁的创建：

1、用threading中的Lock()
cock=threading.lock()
2、上锁 lock.acquire()
3、解锁 lock.release()

练习：用互斥锁实现两个线程对全局变量 加1000000次

死锁：

等待释放锁的过程 

避免死锁的方法：
1、设置超长等待时间
2、银行家算法

--------------进程--------------
1、进程的概念：

一个程序运行起来 所占用的资源
是操作系统资源分配的基本单位

2、一个程序至少有一个进程、一个进程至少有一个线程
线程依附在进程中 没有进程就没有线程

3、进程的三种方法：

就绪态
执行态
等待态

4、线程和进程的对比

一个程序至少有一个进程、一个进程至少有一个线程
线程所需要的资源比较小 进程需要的资源比较少
进程拥有自己的内存单元 线程共享线程的内存单元
线程不能单独执行

5、创建进程

1、导包 import multiprocessing
2、创建任务 函数
3、multiprocessing.Process(target=函数名)
4、开启进程 start()
5、join()

6、进程之间是否共享全局变量？

NO

7、打印进程号

os.getpid()

--------------进程间的通信--------------

进程间的通信 ----- 消息队列 
Process()
Queue() -----队列 
接收消息 put()

判断队列是否为空 队列名.empty()
读取 get(True)

进程池 Pool()
p=pool(3)
apply_async(函数名 args/kwargs)
作用 快速批量的创建进程

--------------协程--------------
实现协程的方式：

1、yield

2、greenlet

3、gevent

--------------Linux 虚拟机--------------

调整终端字体的大小
变大 ctrl+shift + =
变小 ctrl+ -

ls 查看目录下的所有文件
ls -l 查看文件的详细信息
ls -a 显示所有文件 包括隐藏文件
ls -lh 查看所有文件的详细信息

cd 切换目录
cd +文件夹名 切换到文件夹
cd . 当前路径 
cd ..返回上级目录
cd - 上次所在目录
cd ~ 返回主目录 

mkdir 创建文件夹/目录
touch 创建文件/txt
cat 查看文件内容
写内容---vim编辑器

三种模式：

1、命令模式
2、编写模式
3、退出模式

1、进入文件内 vi + 文件名 
2、将命令模式----编写模式 i
3、退出编写模式 按esc
4、wq 保存并退出

pwd 查看当前位置

绝对路径
有盘符 文件所在的位置
绝对路径 从根目录为起点到你所在的目录
相对路径 从一个目录为七点奥你所在目录

cp 复制文件
-i 交互式复制
-v 显示拷贝进度
-r 递归复制

rmdir 删除目录/文件夹
rm 删除文件

mv 重命名 移动
mv 文件名 新地方
mv 旧名 新名

--help 查看帮助信息
man +命令 查看命令的帮助信息
推出 按q

tab 提示命令

history 查看历史命令
重定向 >
history 50 > 文件名
more 分屏显示
more + 文件名
空格换页
q 退出

clear 清屏 ctrl + l

| 一个命令的输出 作为另一个命令的读

建立连接 ln

软连接 源文件删除 则失效 ln -s 文件名 新文件
硬连接 之恶能连接普通文件 ln 文件名 新文件名

压缩文件

1、打包文件 tar -cvf 打包后的文件名.tar 要打包的文件
解包文件 tar -xvf 打包后的文件名
2、开始压缩

压缩方式

gzip(需要先打包) 2006A
压缩zip -r 打包后的文件名
解压 gzip -d 压缩后的文件名
bzip2 2007A
压缩 tar -jcvf ee.tar.gz2 2007A
解压 tar -jxvf ee.tar.gz2

zip 2008A
压缩 zip 压缩后的文件名 要压缩的文件
解压 unzip 压缩后的文件名

which 查看命令的位置

修改文件的权限
chmod 
属主 user u
属组 group g
其他 other o

对文件的操作

写 write w
读 read r
执行 excute x

1、数字法

chmod 
chmod 
chmod 

2、字母法

chmod u+x 文件名
chmod g-r 文件名

原文章在有道云中
链接：http://note.youdao.com/noteshare?id=e6449b2b2fd655b758cd841e66299e54&sub=2E21666B3C4B4D4EA1B05BC5BDF5E12A，
欢迎转载！！！！！！！！！！！！！！！！！！！！！！！