python进阶

一、第三方模块

1. virtualenv

• virtualenv就是用来为一个应用创建一套“隔离”的Python运行环境。

• 用pip安装的包都被安装到新建的环境下，系统Python环境不受任何影响

• 使用

  • 安装

      pip3 install virtualenv

  • 创建环境

      virtualenv --no-site-packages venv
      //no-site-packages指的是系统pip的不复制过去，建立一个纯净的python环境
      //例如Anocanda一个环境，Django单独安装一个环境
      //有些想用python2，有些用python3，都可以用虚拟环境解决

  • 使用环境

      source venv/bin/activate

2. Tkinter图形库

• Python提供了多个图形界面的库，如：

  • Tkinter： Python标准内置库，能在大多数Unix平台下使用

  • wxPython： 开源软件

  • Jython： 和java有关的一种

  • PyQT： 和QT有关的一种

二、文件操作

1. 读文件

1. open file
    open(path,flag[,encoding][,errors])
        path:路径
        flag:打开方式
#常用       r   只读，文件描述符放在文件开头
#常用       rb  只读，文件描述符放在文件开头，以二进制格式打开
            r+  读写，文件描述符放在文件开头
#常用       w   只写，若文件已存在会覆盖，不存在则创建
#常用       wb  打开一个文件只用于写入二进制
            w+  打开一个文件用于读写
            a   追加，若文件存在，文件描述符放在末尾
            a+
            encoding:编码方式
            errors:错误处理
2. operate file
3. close file

4. 注意
    打开文件后，要注意文件描述符的位置

• 打开文件

path=r"C:\Users\test.txt"   #文件并不存在
f=open(path,"r")
#f=open(path,"r",encoding="utf-8",error="ignole")   ignole指忽略错误

• 读文件

##1. 读全部
str1=f.read()   #常用

##2. 读10字节
str2=f.read(10)

##3. 读整行
str3=f.readline()   #常用
str4=f.readline(10)     #读取10字节，注意不是读取10行，若行字节小于10，读整行

##4. 读取所有行并返回列表
str5=f.readlines()
str6=f.readlines(20)    #若一行不足20字节，读一行，若小于20，读取最多不超过20字节的行数

##5. 修改描述符的位置
f.seek(0)

##########################################关闭文件

#1. try···finally
try:
    f1=open(path,'r')
    print(f1.read())
finally:
    if f1:
        f1.close()

#2. with···as··: 自动关闭

with open(path,'r') as f2:
    print(f2.read())

2. 写文件

path=r"C:\users\test.txt"

f=open(path,"w")

#1. 将信息写入缓冲区
f.write("Gao Lingyu")   #此时还没写入文件

#2. 刷新缓冲区
f.flush()   #直接把内部缓冲区的数据立刻写入文件
            #或者等缓冲区满自动刷新
            #关闭文件自动刷新

import time

time.sleep(0.01)

#3. 自动关闭

with open(path,"a") as f1:
    f1.write("Gao Lingyu")

3. 编码与解码

写爬虫时常用编解码：
    gzip 表示打包格式，要想用uft-8，就不能打包

#如果wb,rb二进制读写，要进行编解码

#编码
path=r"C:\test.txt"
with open(path,"wb",encoding="utf-8") as f1:
    str="gaolingyu"
    f1.write(str.encode("utf-8"))



#解码
with open(path,"rb") as fr:
    data=fr.read()
    print(type(data))
    newData=data.decode("utf-8")
    print(newData)

#编码和解码要一致才行，要想强行读，可以设置errors="ignore"

4. 对特殊数据结构的存储，pickle模块

    就是对特殊数据结构的存储
    可以直接在文件中存储这四种结构
    存储完后直接查看文件会出现乱码
    要用代码读

    数据持久性就是指把数据长期存储，比如存到本地文件

    写：dump
    读：load

import pickle   #数据持久性模块

#list存储
myList=[1,2,3,"gaolingyu"]
path=r"C:\text.txt"
f=open(path,"wb")
pickle.dump(myList,f)
f.close()

#读取
f=open(path,"rb")
tempList=pickle.load(f)
print(tempList)
f.close()

#其他结构类似，主要是dump,load

三、时间系统模块

1. calendar模块

#日历模块

import calendar

#返回指定月份的日历
print(calendar.month(2018,12))

#返回指定年份的日历
print(calendar.calendar(2018))

2. datetime模块

# datetime可以理解为对time的封装，接口更易用


import datetime

d1=datetime.datetime.now()
print(d1)

d2=datetime.datetime(2000,12,2)
print(d2,type(d2))

#将时间转为字符串
d3=d1.strftime("%y-%m-%d %X")
print(d3)

#算时间差距
d4=d1-d2
print(d4,type(d4))
print(d4.days)  #只有这个类才有days属性

3. time模块

UTC(世界协调时间)
DST(夏令时)

时间的表示形式：
1. 时间戳：以整形或浮点型表示，以秒为单位，从1970.1.1号开始的计数值
2. 元组：一种Python的数据结构，这个元组有9个整型内容
        year,month,day
        hours,minute,second
        weekday,yearday,flag(0,1,-1)
3. 格式化字符串
    %Y 年份 %m 月份 %d天数 %H 小时

import time

#时间戳
t=time.time()
print(t)

#UTC时间元组
t=time.gmtime()
print(t)

#本地时间元组
t=time.localtime()
print(t)
print(type(t))
#将本地时间转换成时间戳
m=time.mktime(t)
print(m)

q=time.strftime("%Y.%m.%d %H:%M:%S")
print(q)

q=time.strftime("%Y.%m.%d %H:%M:%S",t)
print(q)

#time.clock() can be used to count time
y1=time.clock()
print(y1)
time.sleep(1)
y2=time.clock()
print(y2)
print(int(y2-y1))

4.

四、OS模块

#OS:包含了普遍的操作系统的功能

import os

#获得系统名字
#nt windows
#posix  Linux/Unix/Mac OS X
print(os.name)

#获得操作系统详细信息，仅linux下可用
try:
    os.uname()
except:
    pass

#获取系统环境变量
#print(os.environ)
print(os.environ.get("APPDATA"))

print(os.curdir)    #当前目录

print(os.getcwd())  #当前工作目录，即Python脚本所在目录

print(os.listdir(r"E:\code20G"))    #获得该目录下所有文件，返回一个列表

os.mkdir("Python创建的目录")    #在当前目录下创建文件夹，也可以用绝对路径
os.rmdir("Python创建的目录")

print(os.stat("filename"))  #获得文件属性

os.rename("srcfile","newName")  #改名

os.remove("filename")   #删除文件

os.system("notepad")  #直接执行命令
os.system("mspaint")    #画板

#shutdown -s -t 500 500秒后关机
#shutdown -a    取消关机
os.system("taskkill /f /im notepad.exe")    #关闭指定程序

os.path.abspath("./")   #查看当前路径的绝对路径

p1="/root"
p2="mydir"
os.path.join(p1,p2) #拼接路径，得到 /root/mydir

p1="/root/mydir/aaa.txt"
os.path.split(p1)   #得到一个列表，两个元素，['/root/mydir','aaa.txt']
os.path.splitext(p1)   #得到一个列表，两个元素，['/root/mydir/aaa','.txt']
                        #只获取扩展名，没有扩展名的话为空

os.path.isdir(p1)
os.path.isfile(p1)  #判断文件是否存在
os.path.exists(p1)  #目录是否存在
os.path.getsize(p1) #获得文件大小

五、类

0. 类的定义

class 类名(父类列表):
    属性    属性也可以定义在__init__(self)中
    私有属性 在名字前加两个下划线__
    行为

class Person(object):
    __name=""   #私有属性
    age=0       #公有属性

    def run(self):
        pass

    def setName(self,name):
        self.name=name

    def getName(self):
        return self.name

p=Person()
p.setName("lingyu")
name=p.getName()
print(name)

1. 单继承

class Person(object):
    name="lingyu"
    age=0

    # def __init__(self):
    #     print("构造函数")

    def __init__(self,name,age):
        self.name=name
        self.age=age
        print("带参数的构造函数",self.name,self.age)

    def run(self):
        pass

    def setName(self,name):
        self.name=name

    def getName(self):
        return self.name

class Student(Person):
    def __init__(self,name,age):
        super(Student,self).__init__(name,age)
        self.id=1000

# s=Student()

s2=Student("hhh",10)
print(s2.getName())

2. 多继承

'''
    若父类中有方法名相同，默认调用继承时排前面的父类的方法名

'''

class Father(object):
    
    def __init__(self,money):
        self.money=money


class Mather(object):
    def __init__(self,butiful):
        self.butiful=butiful


class Child(Father,Mather):
    
    def __init__(self,my_name,money,butiful):
        Father.__init__(self,money)
        Mather.__init__(self,butiful)
        self.name=my_name

c=Child("吕口",1000,100)
print(c.money)
print(c.name)

3. 对象属性与类属性

对象属性：
    通过对象名调用

    对象可在实例后，自己临时添加属性

    临时添加方法：from type import MethodType
                MethodType(要添加的函数名，实例对象名)

类属性：
    通过类名调用，和C++类中的static类似，但有区别

class Person(object):
    str="这是一个人"    #可通过Person.str访问
    def __init__(self):
        self.name="这是对象属性"    #不能通过Person.str访问
        
#对象属性的优先级大于类属性
p=Person()
print(p.str)
print(Person.str)
p.str="改变了类属性"
p.age=18
print(p.age)    #可临时给对象添加属性，类中没添加

print(Person.str)
print(p.str)

4. 构造函数

__init__(self)  
在类的对象创建时自动调用
可以不写，但会自动生成一个
构造函数不能有多个，要实现多态可以传多个参数
属性也可以定义在__init__(self)中

class Person(object):
    name=""
    age=0

    # def __init__(self):
    #     print("构造函数")

    def __init__(self,name,age):
        self.name=name
        self.age=age
        print("带参数的构造函数",self.name,self.age)

    def run(self):
        pass

    def setName(self,name):
        self.name=name

    def getName(self):
        return self.name

p=Person("lingyu",18)

5. 析构函数

__del__(self)   释放对象时调用 

class Person(object):
    name=""
    age=0

    # def __init__(self):
    #     print("构造函数")

    def __init__(self,name,age):
        self.name=name
        self.age=age
        print("带参数的构造函数",self.name,self.age)

    def run(self):
        pass

    def setName(self,name):
        self.name=name

    def getName(self):
        return self.name

    def __del__(self):
        print("析构函数执行了")

p=Person("lingyu",18)

del p
while 1:
    pass

6. 重写__str__()

class Person(object):
    name=""
    age=0

    # def __init__(self):
    #     print("构造函数")

    def __init__(self,name,age):
        self.name=name
        self.age=age
        print("带参数的构造函数",self.name,self.age)

    def run(self):
        pass

    def setName(self,name):
        self.name=name

    def getName(self):
        return self.name

    def __str__(self):
        return "这是一个人的类"

p=Person("lingyu",18)

print(p)

7. 运算符重载

• 就是重写特殊函数

  • 例如：__str__(self)等

六、模块

1.包

• 为什么用包：

  • 若不同的人写的模块名字相同，引用会发生冲突

• 怎么用：

  • 相当于建立一个文件夹，该文件夹下必须有__init__.py文件，有这个文件才能被认为是一个包

2. 系统模块

• sys主要用argv属性，获得命令行参数

• 相当于main(argv,args[])中的args

import sys

for i in sys.argv:
    print(i)

3. 自定义模块

• 一个.py文件就是一个模块

• __name__=="__main__"的作用

  def hello():
      pass
  if __name__=="__main__":
      print("只有当这个py文件直接运行时这一段代码\
      才会运行，否则不运行")
  else:
      print("这个py文件被引入其他文件时会执行这句")

  #常用格式：

  def main(): pass

  if name=="main": main()

七、高级函数

1. 过滤器

filter(fn,lsd)
fn: func name
lsd: 序列
function: 过滤序列
        把传入的函数依次作用于序列中的每一个元素，
        返回True就保留，False不保留

def is_oushu(num):
    if num%2==0:
        return True
    return False
list1=[1,2,3,4,5,6,7,8,9]
print(list1)

res=filter(is_oushu,list1)
print(list(res))

2. 队列

    先进先出
    使用collections模块

import collections

#创建一个空队列
queue = collections.deque()
print(queue)

#进队
queue.append("a")
queue.append("b")
queue.append("c")
print(queue)
res1=queue.pop()
res2=queue.popleft()    #这个才是先进先出
print(res1)
print(res2)
print(queue)

3. 栈

后进先出
用列表来模拟找
append()入栈
pop()出栈

stack=[]

stack.append("a")
stack.append("b")
stack.append("c")
print(stack)

res=stack.pop()
print(res)
print(stack)

4. 排序

ll=[4,2,-7,1,5]
ll2=sorted(ll)  #默认升序排序

ll3=sorted(ll,key=abs)  #按绝对值大小排序
                        #还可以根据key实现自定义排序规则
print(ll)
print(ll2)
print(ll3)

自己写排序函数
def up_to_len(str):
    return len(str)
ll=["asd","as","qwded","adwwe"]
ll4=sorted(ll,key=up_to_len)
print(ll4)

5. map,reduce

• map就是对列表的每一个元素应用某个函数

• reduce是计算

分布式计算
    map把数据分给不同的主机
    reduce把各主机的结果整合起来

map(fn,lsd)
fn: 函数
lsd: 序列
功能：将传入的函数依次作用于序列中的每一个元素，
    并把结果作为新的Iterator返回

reduce(fn,lsd)
fn: 函数
lsd: 列表
功能：一个函数作用在序列上，这个函数必须接受两个参数，
    reduce把结果继续和序列的下一个元素累计运算
例子：reduce(f,[a,b,c])
    等价于：f(f(f(a),b),c)

    map例子
'''
def char2int(ch):
    '''
        将character装换成int
    '''
    chs={"0":0,"1":1,"2":2}
    return chs[ch]

list1=["1","2","0"]

result=map(char2int,list1)
print(result)
print(list(result))

'''
    将other换成string
'''
list2=[0,1,2,True,4,5,6,7.5,8,9999]
res2=map(str,list2)
print(list(res2))

'''
    reduce例子
    map不用额外库，reduce需要
'''
from functools import reduce

def count_sum(a,b):
    '''
        计算a+b
    '''
    return a+b

list3=[1,2,3,4]
res=reduce(count_sum,list3)
print(res)

6. 偏函数

print("----------------自己定义的偏函数---------------")
#自己定义偏函数

print(int("1000"))  #默认基数为10

print(int("1000",base=2))   #设置基数为2

#自己定义的偏函数
def int2(str,base=2):
    return int(str,base)
print(int2("1000"))

print("----------------调用模块---------------")

import functools

#作用：把一个参数固定住，形成一个新的函数
#把int函数的base参数固定为2
int3=functools.partial(int,base=2)

print(int3("1000"))

7. 装饰器

概念：是一个闭包，把一个函数当做参数，返回一个替代版的函数
        就是一个返回函数的函数
用途：不能更改原来的函数，又想增加一些功能

• 最简单的装饰器

print("-------------最简单装饰器----------")

def ppp():
    print("Hello")

def outer1(func):
    def inner():
        print("***")
        func()
    return inner

f = outer1(ppp)
f()

• 改进的装饰器

print("-------------改进装饰器----------")

def outer(func):
    def inner(age):
        if(age<0):
            print("年龄有误，更改为0")
            age=0
        func(age)
    return inner

@outer
def say(age):
    print("I am %d years old"%(age))

#上面加 @outer 代替了下面这句
#say=outer(say)

say(-1)

• 通用的装饰器

print("----------------通用装饰器---------------")

def outer2(func):
    def inner(*args,**kwargs):
        #添加修改的功能
        print("装饰器修饰了")
        return func(*args,**kwargs)
    return inner

@outer2
def say2(name,age):
    print("I am %s, %d years old"%(name,age))

say2("吕口",18)

8. 广度遍历

队列模拟广度优先遍历

import os
import collections
def getAllDirQueue(path):
    queue=collections.deque()
    queue.append(path)
    while len(queue)!=0:
        dirPath=queue.popleft()
        file_list=os.listdir(dirPath)
        for file_name in file_list:
            absPath=os.path.join(dirPath,file_name)
            if os.path.isdir(absPath):
                print("目录：",file_name)
                queue.append(absPath)
            else:
                print("文件：",file_name)

path  =r"E:\Task\3_上_专业英语"
getAllDirQueue(path)

9. 深度遍历

用栈遍历模拟递归遍历（深度遍历）
import os

def getAllDirDeep(path,sp):
    stack=[]
    stack.append(path)
    sp +="   "
    #当栈为空时结束循环
    while len(stack)!=0:
        dirPath=stack.pop()
        file_list=os.listdir(dirPath)
        for file_name in file_list:
            absPath=os.path.join(dirPath,file_name)
            if os.path.isdir(absPath):
                print(sp,"目录：",file_name)
                stack.append(absPath)
            else:
                print(sp,"文件：",file_name)

path=r"E:\Task\3_上_专业英语"
sp=""
getAllDirDeep(path,sp)

10. 递归遍历目录

import os

def getAllDir(path,sp):
    #获得当前目录下所有文件
    file_list=os.listdir(path)
    sp +="   "
    #判断每一个文件是否是目录，是的话递归遍历，不是的话
    for file_name in file_list:
        abs_path=os.path.join(path,file_name)
        if os.path.isdir(abs_path):
            print(sp,"目录：",file_name)
        #递归
            getAllDir(abs_path,sp)
        else:
            print(sp,"文件：",file_name)

sp=""
getAllDir(r"E:\Task\3_上_专业英语",sp)

八、多任务

1. 用途

• 计算密集型 or IO密集型

  • 计算密集型就是用CPU比较多，此时进程数等于CPU核数效率最高，例如对视频高清解码

  • IO密集型就是多IO，此时进程越多越好，但也不能无限多，例如Web应用

多任务实现原理

设计Master-Worker模式，Master负责分配任务，Worker负责执行任务，
通常是一个Master，多个Worker

多进程

主进程是Master，其他进程是Worker
1. 优点
    稳定性高，一个进程崩溃了，不会影响主进程和其他进程
2. 缺点
    创建进程的开销大，Linux下的fork还好，Windows下开销巨大
    操作系统能同时运行的进程数也是有限的

多线程

主线程是Master，others is Worker
1. 优点
    在windows下，多线程效率比多进程高
2. 缺点
    任何一个线程挂掉都可能造成整个进程崩溃

2. 进程

入门

• multiprocessing是一个跨平台的多进程库

from multiprocessing import Process
import time

def process2():
    while True:
        print("进程2-------")
        time.sleep(1)


def main():
    print("主进程启动")

    p=Process(target=process2)
    p.start()

    while True:
        print("主进程------")
        time.sleep(1)
if __name__=="__main__":
    main()

父子进程的先后顺序

• 一般子进程启动后，不受父进程的结束影响,可用.join()，让父进程等子进程运行完后再运行

from multiprocessing import Process
import time

def process2():
    while True:
        print("进程2----开始---")
        time.sleep(1)
        print("进程2----结束---")



def main():
    print("主进程启动")

    p=Process(target=process2)
    p.start()
    #父进程等子进程结束后再继续向下运行
    p.join()    #此时代码不往下执行
    while True:
        print("主进程------")
        time.sleep(1)
if __name__=="__main__":
    main()

进程间通信：通过队列实现

• 有点类似管道

import time
from multiprocessing import Process,Queue
import os

def write(q):
    print("启动了进程%s" % (os.getpid()))
    for chr in ["A","B","C","D"]:
        q.put(chr)
        time.sleep(1)
    print("子进程%s结束"%(os.getpid()))


def read(q):
    print("启动了读进程%s" % (os.getpid()))
    while True:
        value=q.get(True)
        print("value=",value)
    print("结束了读进程%s" % (os.getpid()))
    
    

if __name__ == "__main__":
    q=Queue()
    pw=Process(target=write,args=(q,))
    pr=Process(target=read,args=(q,))

    pw.start()
    pr.start()

    pw.join()
    #pr is a infinite loop and can only be forced to end 
    pr.terminate()

    print("The parent process ends")

进程池

• 用于处理大量子进程

from multiprocessing import Process
from multiprocessing import Pool
import os
import time


def run(name):
    print("子进程%d启动---%s" % (name,os.getpid()))



if __name__ == "__main__":
    print("父进程启动")    
    #create multiple process
    #use process pool
    #the pool's default size is the number of core
    pool=Pool()
    for i in range(10):
        #create process and manage by pool
        pool.apply_async(run,args=(i,))

    #call close() before call join(), after close(),can't create new process
    pool.close()
    pool.join()
    print("父进程结束")   

全局变量在多个进程中互不影响

from multiprocessing import Process
import time
num=100


def run():
    global num
    num += 1
    print("子进程",num)

def main():
    p=Process(target=run)
    p2=Process(target=run)

    p.start()
    p2.start()
    p.join()
    p2.join()
    print("父进程",num)


if __name__ == "__main__":
    main()

自己封装进程

from multiprocessing import Process
import time

class lvkouProcess(Process):

    def __init__(self,name):
        Process.__init__(self)
        self.name=name

    def run(self):
        print("子进程%s启动" % (self.name))
        print("子进程%s结束" % (self.name))


if __name__ == "__main__":
    print("主进程启动")
    p=lvkouProcess("LingYu")
    p.start()   #Automatically call run()
    p.join()
    print("主进程结束")

3. 线程

入门

• 线程用的是进程的空间

import threading
import time

a=10

def run():
    print("子线程%s启动" % (threading.current_thread().name))
    print(a)
    time.sleep(2)
    print("子线程%s结束" % (threading.current_thread().name))

if __name__ == "__main__":
    print("主线程%s启动" % (threading.current_thread().name))
    t=threading.Thread(target=run,name="son")
    t.start()
    print("主线程%s结束" % (threading.current_thread().name))

多线程共享变量

• 多进程，会对使用内存进行拷贝，各进程互不影响

• 多线程，各线程共享相同变量，若多个线程同时改一个变量，容易把内存搞乱

import threading
import time
import os

num=0

def run(n):
    global num
    for i in range(10000000):
        num  += n
        num  -= n

if __name__ == "__main__":
    t=threading.Thread(target=run,args=(9,))
    t2=threading.Thread(target=run,args=(6,))

    print(num)
    t.start()
    t2.start()
    t.join()
    t2.join()
    print(num)

加锁

import threading
import time
import os

num=0
#锁对象
lock=threading.Lock()

def run(n):
    global num
    for i in range(10000000):
        lock.acquire()
        try:
            num =num + n
            num =num - n
        finally:#一定要释放锁
            lock.release()
        #下三行与上面功能一样，with能自动释放
        with lock:
            num += n
            num -= n

if __name__ == "__main__":
    t=threading.Thread(target=run,args=(9,))
    t2=threading.Thread(target=run,args=(6,))

    print(num)
    t.start()
    t2.start()
    t.join()
    t2.join()
    print(num)

定时线程

import threading

def run():
    print("the child thread")

#延时5s
t=threading.Timer(5,run)

t.start()

t.join()
print("The parent ends")

条件变量调度

• 若不加cond,线程执行是没有顺序的,加了后从0到9依次执行

• 这只是两个进程，多个进程用到再学吧

import threading,time

cond=threading.Condition()

def run1():
    with cond:
        for i in range(0,10,2):
            print(threading.current_thread().name,i)
            time.sleep(0.2)
            cond.wait() #等待
            cond.notify()   #通知不用等待了


def run2():
    with cond:
        for i in range(1,10,2):
            print(threading.current_thread().name,i)
            time.sleep(0.2)
            cond.notify()
            cond.wait()

if __name__ == "__main__":
    t1=threading.Thread(target=run1)
    t2=threading.Thread(target=run2)
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    print("主线程结束")

生产者消费者

import threading,queue,time,random

#生产者
def product(id,q):
    while True:
        num=random.randint(0,10000)
        q.put(num)
        print("%d product a %d" % (id,num))
        time.sleep(3)
    q.task_done()

#消费者
def customer(id,q):
    while True:
        item=q.get()
        # print(type(item))
        if item is None:
            break
        print("%d customed %d" % (id,item))
        time.sleep(2)
    q.task_done()


if __name__ == "__main__":
    #消息队列
    q=queue.Queue()

    #启动生产者
    for i in range(4):
        threading.Thread(target=product,args=(i,q)).start()
    #启动消费者
    for i in range(3):
        threading.Thread(target=customer,args=(i,q)).start()

4. 协成

入门

• Python协程是通过generator实现的,这就是一个简单的协程

• 子程序/函数：层级调用，A调用B,B调用C,通过栈实现，调用的顺序明确

• 协程：看上去也是子程序，但在执行过程中，在子程序内部中可中断，然后转而执行别的子程序

• 协程实现功能像线程，但是一个线程执行，而不是多个线程调度执行，

• 协程效率极高，不存在同时写变量的冲突

def run2():
    data=""
    r=yield data
    #第一次send,r=None
    print(1,r,data)
    r=yield data
    #第二次send,r="hello"
    print(2,r,data)
    r=yield data
    #第三次send,r="lingyu"
    print(3,r,data)


def run():
    print(1)
    yield 10
    print(2)
    yield 20
    print(3)
    yield 30


if __name__ == "__main__":
    m=run()
    print(type(m))
    print(next(m))
    print(next(m))
    print(next(m))
    #数据传输，run2()实现
    m=run2()
    print(m.send(None)) #启动
    print(m.send("hello"))
    print(m.send("lingyu"))

协程实现消费者生产者

def product(m):
    m.send(None)
    for i in range(5):
        print("product %d" % (i))
        recive=m.send(i)
        print("recive %s from cunstom" % (recive))
    m.close()

def customer():
    data=""
    while True:
        n= yield data
        if n==None:
            return
        print("custome %d" % (n))
        data="200"

if __name__ == "__main__":
    m=customer()
    product(m)

九、正则表达式

1. re模块

re.match(pattern,string,flags=0)
patter: 匹配的正则表达式
string: 要匹配的字符串，
flags: 标志位，用于控制正则表达式的匹配方式，例如可以忽略大小写
        值如下：re.I    忽略大小写
               re.M     多行匹配,正则表达式中的^操作符能够将给定字符串的每行当做匹配开始
               re.S     .能匹配所有字符，默认匹配除换行符以外的所有字符
               re.U     根据Unicode字符集解析字符 影响\b等
function: 只从头匹配

import re
#www.baidu.com
str1="www.baidu.com"
str2="Www.baidu.com"
str3="baidu.com.www"
print(re.match("www",str1))
print(re.match("www",str2))
print(re.match("www",str3))

'''
re.search(pattern,string,flags=0)

function: 扫描整个字符串，返回第一个成功的匹配
'''
print("---------------------------------")
print(re.search("www",str1))
print(re.search("www",str2))
print(re.search("www",str3))


'''
re.findall(pattern,string,flags=0)

function: 扫描整个字符串，返回所有成功匹配的列表
'''

str4="www.baidu.www.com"
print(re.findall("www",str4))

十、数据库

1. mysql

• 连接中出现的问题：

  • 一开始这个文件的名字不叫“连接测试.py”，而是"pymysql.py",和包名重名了就会出问题

import pymysql


#连接数据库
'''
参数1：mysql服务所在主机的IP
参数2: 用户名
参数3：密码
参数4：要连接的数据库名
'''
db=pymysql.connect("localhost","root", "123456","news")

title='贵州大学喜报：我馆“书心旅图”项目获“2018年全民阅读优秀案例奖项”'
publicTime='2018-12-03'
publicContent='2018年11月23日'
visitCount='13'
id=1
#创建一个cursor对象
cursor=db.cursor()
sql="select version()"

insert="insert into newsapp_newsitem \
        values('"+str(id)+"','"+title+"','"+publicTime+"','"+publicContent+"','"+visitCount+"');"
cursor.execute(insert)
db.commit()
#执行sql语句
data=cursor.execute(sql)
print(data)

#断开
cursor.close()
db.close()

十一、网络编程

1. TCP

clent

import socket

client=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

client.connect(("192.168.1.107",8081))

count=0

while True:
    count += 1
    data = input("请输入给服务器发送的数据：")
    client.send(data.encode("utf-8"))
    info = client.recv(1024)
    print("服务器说：",info.decode("utf-8"))

server

import socket

server=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

#绑定IP端口
server.bind(('192.168.1.107',8081))

#监听
server.listen(5)
print("服务器启动成功")

#等待连接
client_socket,client_address=server.accept()
print(client_socket,"连接成功",client_address)

while True:
    data=client_socket.recv(1024)
    if len(data)>0:
        print("收到：",client_address,"的数据：",data.decode("utf-8"))
        client_socket.send("已收到，你好".encode("utf-8"))

多个client

• 之前的只能接受一个client连接,这个可以接受多个client的连接

import socket
import threading

server=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

server.bind(("192.168.1.107",8081))

server.listen()

print("server start sucessfully!")


def deal(sk,address):
    while True:
        data=sk.recv(1024).decode("utf-8")
        print("收到",address,"的消息：",data)
        sk.send("已收到".encode("utf-8"))

while True:
    client_socket,client_address=server.accept()
    t=threading.Thread(target=deal,args=(client_socket,client_address))
    t.start()

2. UDP

client

import socket

client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

while True:
    data=input("请输入：")
    client.sendto(data.encode("utf-8"),("192.168.1.107",8081))
    data=client.recv(1024).decode("utf-8")
    print(data)

server

import socket

server=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

server.bind(("192.168.1.107",8081))

print("服务器启动成功")

while True:
    data,address=server.recvfrom(1024)
    print("收到消息：",data.decode("utf-8"))
    server.sendto("已收到".encode("utf-8"),address)