2021-07-23随机学习Python

 

 

"""
name="张倩"
age=23
weight=65
string="姓名：{name}\n年龄：{age}\n体重：{weight}kg"
print(string.format(name=name,weight=weight,age=age))
points=19
total=22
# print('所占百分比:{:.2%}'.format(points/total))
print('所占百分比:{:}'.format(points/total))
age=20
gender='男'
print(f'年龄：{age}\n性别:{gender}')
num=int(input("请输入要转换的数据：\n"))
change=input("请选择转换进制：二：2、八：8、十：10、十六：16\n")
if change=='2':
    print(f'进制转换后的数据为：{bin(num)}')
elif change=='8':
    print("进制转换后的数据为：%s"%(oct(num)))
elif change=='10':
    print("进制转换后的数据为：%s"%(int(num)))
elif change=='16':
    print("进制转换后的数据为：{}}".format(hex(num)))

"""
'''
import time
incomplete_sign=50
print('='*23+'开始下载'+'='*25)
for i in range(incomplete_sign+1):
    completed="*"*i  #表示已经完成
    incomplete="."*(incomplete_sign-i) #表示未完成
    percentage=(i/incomplete_sign)*100
    print("\r{:.0f}%[{}{}]".format(percentage,completed,incomplete),end="")
    time.sleep(0.5)
print("\n"+'='*23+'下载完成'+'='*25)
'''
# word='t'
# str='python'
# print(str.find('t'))
# res=str.find(word,1,7)
# print(res)
'''
#gpu执行cpu   发出自己的指令  干自己的其他的事情 判断是否活这
time.sleep()
print(p.is_alive())#操作系统已经响应了关闭进程的需求  再去检测的时候，
p.terminate()#异步非阻塞  结束一个进程
p.start()#异步非阻塞
'''
"""
import os
import  time
from multiprocessing import Process

class MyProcess1(Process):
    def run(self):
        while True:
            print('is alive')
            time.sleep(0.5)
        print(os.getpid(),os.getppid())


class MyProcess2(Process):
    def __init__(self,x,y):
        self.x=x
        self.y=y
        super().__init__()#传参不要忘记super的init
    def run(self):
        '''子进程要做的事情写在run方法中'''
        print(self.x,self.y,os.getppid())
        for i in range(5):
            print('in son2')
            time.sleep(1)
        print(os.getpid(),os.getppid())


if __name__ == '__main__':
    mp=MyProcess1()
    mp.daemon=True
    mp.start()
    mp2=MyProcess2(1,2)
    mp2.start()
    print('main:',os.getpid())
    time.sleep(1)
    print(mp.is_alive())
    mp.terminate()#结束当前线程
'''
Process类
开启进程的方式
   面向函数
      def 函数名：要在子进程中执行的代码
      p=Process(target==函数名，args=(参数1，））
      p.start()开启进程
    面向对象
    class l类名（Process）：
       def __init__(self,参数1，参数2):  如果子进程不需要参数可以不写
          self.a=参数1
          self.b=参数2
          super().___init()
        def run(self):
                 要在子进程中执行的代码 
                 
    Process 提供的操作进程的方法
    p.start() 开启进程   异步非阻塞
    p.terminate 结束进程    异步非阻塞 
    p.join()    同步阻塞
    p.isalive()获取当前进程的状态
    daemon=True  设置为守护进程，守护进程永远在主进程的代码结束之后自动结束
'''
#锁   tcp  soceet   sever
"""
# 并发能够做的事：
#   1.实现能够响应多个client端的sever
#   2.抢票系统
"""
"""

import  time
import  json
from multiprocessing import Process,Lock

def search_ticket(user):
    with open('ticket_count') as f :
        dic=json.load(f)
        # print(dic('count'))
        print('%s查询结果：%s张余票'%(user,dic['count']))

def buy_ticket(user,lock):
    #with lock:
        #lock.acquire();#给这段代码加锁
        time.sleep(0.02)
        with open('ticket_count') as f:
            # time.sleep(0.02)
            dic=json.load(f)
        if dic['count']>0:
            print("%s买到票了"%(user))
            dic['count'] -=1
        else:
            print("%s没买到票"%(user))
        time.sleep(0.02)
        with open('ticket_count','w') as f:
            # time.sleep(0.02)
            json.dump(dic,f)
        #lock.release()#给这段代码解锁
#search_ticket()

def task(user,lock):
    search_ticket(user)
    with lock:
       buy_ticket(user,lock)

if __name__ == '__main__':
    lock=Lock()
    for i in range(10):
        # p=Process(target=search_ticket,args=('user%s'%i,))
        # p = Process(target=buy_ticket, args=('user%s' % i,lock))
        p = Process(target=task, args=('user%s' % i, lock))
        p.start()
#1如果在一个并发的场景下，涉及到某部分内容 是需要修改一些所有进程共享数据资源  需要枷锁来维护数据安全
#在数据安全的基础上，才考虑吧效率问题
#同步存在的意义  数据安全
#主进程实例化lock=Lock()
# 把这把锁传递给子进程
# 在子进程中 对需要加锁的代码 进行 with lock:
#       with lock 相当于lock.acquire()和lock.release()
# 在进程中需要加锁的场景
#    操作共享的数据资源（文件数据库）  对资源进行修改操作

# 加锁之后 数据的安全性保证 降低了程序的执行效率

 

 

 

 

#进程之间的数据隔离
from multiprocessing import  Process
n=100
def func():
    global  n
    n=-1

if __name__ == '__main__':
    p_l=[]
    for i in range(10):
        p=Process(target=func)
        p.start()
        p_l.append(p)
    for p in p_l:p.join()
    print(n)

#通信  进程之间的通信  ipc  inter process communication
#Queue
from  multiprocessing import  Queue,Process

def func(exp,q):
    ret=eval(exp)
    print(ret)
    q.put(ret)
    q.put(ret*4)
    q.put({ret,2,3})

if __name__ == '__main__':
    q=Queue()
    Process(target=func,args=('1+2+3',q)).start()
    print(q.get())
#Queue基于文件家族 socket  pickle  lock底层实现