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)