#/usr/bin/env  python

# -*- coding:utf-8 -*-

str_input = 'jack'

number = int(str_input)

print(number)

执行结果：

Traceback (most recent call last):

  File "C:/Users/zhang/PycharmProjects/S12-python3/day8/test/test.py", line 5, in <module>

    number = int(str_input)

ValueError: invalid literal for int() with base 10: 'jack'

try:

    str_input = 'jack'

    number = int(str_input)

    print(number)

except Exception as e:

    print("\033[32;1m出现错误如下\033[0m")

    print(e)

执行结果：

出现错误如下

invalid literal for int() with base 10: 'jack'

try:

    #正常逻辑代码

    user_input = input("\033[32;1m请输入数字：\033[0m")

    number = int(user_input)

except Exception as e:  #这个e是对象Exception类创建的！Exception这里面封装了你上面逻辑块出现问题的所有错误

    #逻辑代码出现错误,这里的代码块就是如果上面的代码出现问题之后执行这个代码块的内容

    print(e) #如果这个e你不想要，可以自己定义

    #这里也可以记录日志，把错误的详细记录，错误详细在e里了！

执行结果1，输入整数：

请输入数字：123

123

执行结果2，输入非法的字符串：

请输入数字：1as

invalid literal for int() with base 10: '1as'

socket.getaddrinfo(host, port, family=0, type=0, proto=0, flags=0) #获取要连接的对端主机地址

sk.bind(address) #s.bind(address) 将套接字绑定到地址。address地址的格式取决于地址族。在AF_INET下，以元组（host,port）的形式表示地址。

sk.listen(backlog) #开始监听传入连接。backlog指定在拒绝连接之前，可以挂起的最大连接数量，backlog等于5，表示内核已经接到了连接请求，但服务器还没有调用accept进行处理的连接个数最大为5，这个值不能无限大，因为要在内核中维护连接队列

sk.setblocking(bool) #是否阻塞（默认True），如果设置False，那么accept和recv时一旦无数据，则报错。

sk.accept() #接受连接并返回（conn,address）,其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址，接收TCP 客户的连接（阻塞式）等待连接的到来

sk.connect(address) #连接到address处的套接字。一般，address的格式为元组（hostname,port）,如果连接出错，返回socket.error错误。

sk.connect_ex(address) #同上，只不过会有返回值，连接成功时返回 0 ，连接失败时候返回编码，例如：10061

sk.close() #关闭套接字

sk.recv(bufsize[,flag]) #接受套接字的数据。数据以字符串形式返回，bufsize指定最多可以接收的数量。flag提供有关消息的其他信息，通常可以忽略。

sk.recvfrom(bufsize[.flag]) #与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。

sk.send(string[,flag]) #将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。即：可能未将指定内容全部发送。

sk.sendall(string[,flag]) #将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常，内部通过递归调用send，将所有内容发送出去。

sk.sendto(string[,flag],address) #将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。该函数主要用于UDP协议。

sk.settimeout(timeout) #设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如 client 连接最多等待5s ）

sk.getpeername() #返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。

sk.getsockname() #返回套接字自己的地址。通常是一个元组(ipaddr,port)

sk.fileno() #套接字的文件描述符

socket.sendfile(file, offset=0, count=None) #发送文件 ，但目前多数情况下并无什么卵用

socket server 和　select & epoll 还是不太一样他的本质是：客户端第一次链接的时候，只要一进来，我服务端有个while循环为你创建一个

线程和进程，客户端就和服务端直接创建通信，以后传送数据什么的就不会通过server端了，直接他俩通过线程或者进程通信就可以了！

如果在多进程的时候，client1和client2他们同时传输10G的文件都是互相不影响！

如果在多线程的时候，python中的多线程，在同一时间只有一个线程在工作，他底层会自动进行上下文切换，client1传一点，client2传一点。

知识回顾：

python中的多线程，有一个GIL在同一时间只有一个线程在工作，他底层会自动进行上下文切换.

这样会导致python的多线程效率会很低，也就是人们经常说的python多线程问题

import  socketserver

class MyTCPHandler(socketserver.BaseRequestHandler):

    def handle(self):

        print("New Conn:",self.client_address)

        while True:

            data = self.request.recv(1024)

            if not  data:

                break

            print("Client Says:",data.decode())

            self.request.send(data)

            self.request.send(bytes("本次数发送完毕","utf8"))

if __name__ == "__main__":

    Host,Port = "localhost",9003

    server = socketserver.ThreadingTCPServer((Host,Port),MyTCPHandler)

    server.serve_forever()

import  socket

ip_port = ("127.0.0.1",9003)

sk = socket.socket()

sk.connect(ip_port)

while True:

    aaa = input(">>:")

    sk.send(bytes(aaa,"utf8"))

    server_reply = sk.recv(4096)

    print(server_reply.decode())

    data = sk.recv(1024)

    print(data.decode())

A thread is an execution context, which is all the information a CPU needs to execute a stream of instructions.

Suppose you're reading a book, and you want to take a break right now, but you want to be able to come back and resume reading from the exact point where you stopped. One way to achieve that is by jotting down the page number, line number, and word number. So your execution context for reading a book is these 3 numbers.

If you have a roommate, and she's using the same technique, she can take the book while you're not using it, and resume reading from where she stopped. Then you can take it back, and resume it from where you were.

Threads work in the same way. A CPU is giving you the illusion that it's doing multiple computations at the same time. It does that by spending a bit of time on each computation. It can do that because it has an execution context for each computation. Just like you can share a book with your friend, many tasks can share a CPU.

On a more technical level, an execution context (therefore a thread) consists of the values of the CPU's registers.

Last: threads are different from processes. A thread is a context of execution, while a process is a bunch of resources associated with a computation. A process can have one or many threads.

Clarification: the resources associated with a process include memory pages (all the threads in a process have the same view of the memory), file descriptors (e.g., open sockets), and security credentials (e.g., the ID of the user who started the process).

An executing instance of a program is called a process.

Each process provides the resources needed to execute a program. A process has a virtual address space, executable code, open handles to system objects, a security context, a unique process identifier, environment variables, a priority class, minimum and maximum working set sizes, and at least one thread of execution. Each process is started with a single thread, often called the primary thread, but can create additional threads from any of its threads.

Threads share the address space of the process that created it; processes have their own address space.

Threads have direct access to the data segment of its process; processes have their own copy of the data segment of the parent process.

Threads can directly communicate with other threads of its process; processes must use interprocess communication to communicate with sibling processes.

New threads are easily created; new processes require duplication of the parent process.

Threads can exercise considerable control over threads of the same process; processes can only exercise control over child processes.

Changes to the main thread (cancellation, priority change, etc.) may affect the behavior of the other threads of the process; changes to the parent process does not affect child processes.

import threading

import time

def sayhi(num): #定义每个线程要运行的函数

    print("running on number:%s" %num)

    time.sleep(3)

if __name__ == '__main__':

    t1 = threading.Thread(target=sayhi,args=(1,)) #生成一个线程实例

    t2 = threading.Thread(target=sayhi,args=(2,)) #生成另一个线程实例

    t1.start() #启动线程

    t2.start() #启动另一个线程

    print(t1.getName()) #获取线程名

    print(t2.getName())

import threading

import time

class MyThread(threading.Thread):

    def __init__(self,num):

        threading.Thread.__init__(self)

        self.num = num

    def run(self):#定义每个线程要运行的函数

        print("running on number:%s" %self.num)

        time.sleep(3)

if __name__ == '__main__':

    t1 = MyThread(1)

    t2 = MyThread(2)

    t1.start()

    t2.start()

import time

import threading

def addNum():

    global num #在每个线程中都获取这个全局变量

    print('--get num:',num )

    time.sleep(1)

    num  -=1 #对此公共变量进行-1操作

num = 100  #设定一个共享变量

thread_list = []

for i in range(100):

    t = threading.Thread(target=addNum)

    t.start()

    thread_list.append(t)

for t in thread_list: #等待所有线程执行完毕

    t.join()

print('final num:', num )

import time

import threading

def addNum():

    global num #在每个线程中都获取这个全局变量

    print('--get num:',num )

    time.sleep(1)

    lock.acquire() #修改数据前加锁

    num  -=1 #对此公共变量进行-1操作

    lock.release() #修改后释放

num = 100  #设定一个共享变量

thread_list = []

lock = threading.Lock() #生成全局锁

for i in range(100):

    t = threading.Thread(target=addNum)

    t.start()

    thread_list.append(t)

for t in thread_list: #等待所有线程执行完毕

    t.join()

print('final num:', num )

import threading,time

def run1():

    print("grab the first part data")

    lock.acquire()

    global num

    num +=1

    lock.release()

    return num

def run2():

    print("grab the second part data")

    lock.acquire()

    global  num2

    num2+=1

    lock.release()

    return num2

def run3():

    lock.acquire()

    res = run1()

    print('--------between run1 and run2-----')

    res2 = run2()

    lock.release()

    print(res,res2)

if __name__ == '__main__':

    num,num2 = 0,0

    lock = threading.RLock()

    for i in range(10):

        t = threading.Thread(target=run3)

        t.start()

while threading.active_count() != 1:

    print(threading.active_count())

else:

    print('----all threads done---')

    print(num,num2)

import threading,time

def run(n):

    semaphore.acquire()

    time.sleep(1)

    print("run the thread: %s\n" %n)

    semaphore.release()

if __name__ == '__main__':

    num= 0

    semaphore  = threading.BoundedSemaphore(2) #最多允许5个线程同时运行

    for i in range(20):

        t = threading.Thread(target=run,args=(i,))

        t.start()

while threading.active_count() != 1:

    pass #print threading.active_count()

else:

    print('----all threads done---')

    print(num)

收先要明确，线程和进程都是系统帮咱们开辟的，不管是thread还是process他内部都是调用的系统的API

而对于协程来说它和系统毫无关系！

他就和程序员有关系，对于线程和进程来说，是不是有CPU来决定调度的！

对于协程来说，程序员就是上帝，你想让谁执行到哪里他就执行到哪里

#!/usr/bin/env python

# -*- coding:utf-8 -*-

from greenlet import greenlet

def test1():

    print 12

    gr2.switch()#切换到协程2执行

    print 34 #2切回来之后，在这里和yield类似

    gr2.switch() 

def test2():

    print 56

    gr1.switch()#上面执行了一句，在切换到协程1里去了

    print 78

gr1 = greenlet(test1) #创建了一个协程

gr2 = greenlet(test2)

gr1.switch() #执行test1 

'''

比I/O操作，如果10个I/O，我程序从上往下执行，如果同时发出去了10个I/O操作，那么返回的结果如果同时回来了2个

，是不是就节省了很多时间？

如果一个线程里面I/O操作特别多，使用协程是不是就非常适用了！

如果一个线程访问URL通过协程来做，协程告诉它你去请求吧，然后继续执行，但是如果不用协程就得等待第一个请求完毕之后返回之后才

继续下一个请求。

协程：把一个线程分成了多个协程操作，每个协程做操作

多线程：是把每一个操作，分为多个线程做操作，但是python中，在同一时刻只能有一个线程操作，并且有上下文切换。但是如果上下文切换非常频繁的话

是非常耗时的，但对于协程切换就非常轻便了~