python笔记

for循环语句练习99乘法表

for i in range (1,10): #控制列表输出1-9，y轴

    for j in range (1,i+1): #外部控制for循环执行一次，内部循环会根据外部的数字进行相加
        print('%d X %d = %d\t'%(j,i,i*j),end='') #int占位符 \t制表符 end有序排列不换行
    print() 

 

while 循环语句练习

a = 0
while a<10:
    print(a)
    a +=1  #循环执行到9结束

i = 1
while i < 5:
    print("我是will")
    i +=1
else:
    print("条件满足时跳出")    #循环执行4次，第五次跳出

n = int(input("请输入数字：")) #int类型输入数字
j = 1
while j <= n:  #外部while执行按照输入的数字比如5，外部控制就是5行
   i = 1
   while i <= j: #内部变量while循环变量i 根据外部while循环次数逐步增加内部的内容
       print("*",end='')
       i +=1 #内部while控制条件
   print()
   j +=1 #外部while控制满足条件。

使用pass、break、continue，控制执行语句的终止与继续，pass：执行，继续往下执行，break，停止，continue:停止条件语句，如果后面还有，则继续执行，例如下：
i = "william"
for i in i:
    if i =='l':
       continue
    print(i,end='')

列表推倒式练习：

#语法：[变量 for 变量 in 可迭代对象]
#未使用推倒式：
result2 = [] #空列表
for i in range(10):
    result2.append(i)
print(result2)

#使用列表推倒式
result3 = [i for i in range(11)] 
print(result3)

L = [[1,2,3],[4,5,6],[7,8,9]]  #1，2，3列表分别对应0 1 2
result=[i[0]for i in L]  #输出1 4 7
print(result)
result1=[L[i][i] for i in range(len(L))]
print(result1) #输出1 5 9

import copy包练习

# import copy
# a = [1,2,3,4,[6,7,8],9]
# b = a
# print('a的id:%s,b的id%s'%(id(a),id(b)))
# c = copy.copy(a)  #拷贝列表
# d = copy.deepcopy(a)
# a.append(10)
# a[4].append(11)
# print(b)
# print(c)  #增添后主列表已经限制，不变。子列表改变
# print(d)  #增添后不执行copy

函数：是一个被重复调用的入口和出口固定程序段

减少冗余代码

代码结构清晰

保证代码一致性

def fun(name,city='shanghai'):
    print('i am is %s,i am from %s'%(name,city))
fun('will') #调用函数执行
fun(name='wei',city='henan') #调用函数执行重新赋值

使用添加**kwargs，所有传递的参数都是键值对，

def say_hello(**kwargs):
    print(kwargs)
say_hello()
say_hello(a=1)
say_hello(a=1,b=2,c=3)

使用*args，返回元组，作用：传递元组，避免出错

def say_hello(*args):
    print(args)
say_hello()
say_hello(1)
say_hello(1,2,3)

使用*args和**kwargs结合，打印出元组和字典，格式：*args,**kwargs放最后

def hello(e,a,c=1,*args,**kwargs):
    y=args
    z=kwargs
    print(y,z)
hello(1,2,3,4,5,6,d=5)

(4, 5, 6) {'d': 5}

Process finished with exit code 0

匿名lambda函数，可以不用命名函数

好处：轻便即用即删除，匿名函数一般给filter，map这样的函数式编程服务

作为回调函数，传递给某些应用，比如消息处理，不用考虑命名冲突问题。

lambda参数，位置参数，不能包含循环，return，elif，可以有if

L = lambda x:x*x  #变量lambda，第一个x为传参数，
print(L(5))
print(L)

25
<function <lambda> at 0x000002789C0E0EA0>

Process finished with exit code 0

L = lambda  x:'x>10' if x>10 else 'x<10'   #结合if else实现判断
print(L(15))

map()是python的内置函数，接受一个函数和一个可迭代对象，并且通过函数一次作用在可迭代对象的每个元素上，得到新对象

map使用 : 对数据的处理可以使用map加lambda使用，非常方便

def func(x):
    return x*x
a=map(func,[1,2,3,4])  #使用map进行对列表相乘
print(list(a))  #配合list显示内容，不写会返回对象

b = map(lambda x:x**x,[1,2,3,4])  #结合map和lambda对数据进行运算
print(list(b))

#练习：两个列表相加
a=[1,2,3]
b=[4,5,6]
c=map(lambda x,y:x+y,a,b) #a，b复制给x和y
print(list(c))

[5, 7, 9]

Process finished with exit code 0

filter是过滤函数，返回判断成功过滤的数据

a=[1,2,3]
b=[4,5,6]
c=map(lambda x,y:x+y,a,b)
print(list(c))
d = filter(lambda x:x%3==0,b)   #b的值赋值给x：
print(list(d))

[5, 7, 9]
[6]

Process finished with exit code 0

 

函数作用域

L local 局部作用域，本地作用域

E enclosing 嵌套作用域，   G  global 全局作用域    b built-in 内建作用域     流程控制不会影响自己作用于域

import sys
name = 'while' #全局变量
def outer():
    name='outer' #嵌套变量
    def inner():
        # global name  #修改全局变量
        # nonlocal name  #可修改嵌套变量名字
        name='inner'   #本地变量，就近原则打印name
        age = 10
        print(name)
        print(age)
    inner()
outer()

python多进程multiprocessing
# import multiprocessing
# import time
# def run_proc():
#     while True:
#         print('....22...')
#         time.sleep(2)
# if __name__ == '__main__':
#     # 开启子进程
#     sub_process = multiprocessing.Process(target=run_proc)
#     sub_process.start()
#     while True:
#         print('....1111....')
#         time.sleep(1)
#

# #打印pid进程号
# import multiprocessing,time
# import os
# def work():
#     curt_process = multiprocessing.current_process()
#     print("当前进程",curt_process)
#     print('当前进程编号',curt_process.pid,os.getpid())
#     print('父进程的编号',os.getppid())
#     time.sleep(2)
# if __name__ == '__main__':
#     cur_process = multiprocessing.current_process()
#     print("main",cur_process)
#     print("main的pid编号",cur_process.pid)
#     sub_process = multiprocessing.Process(target=work)
#     sub_process.start()
#     print('主进程结束')


#传参
# import multiprocessing,time,os
# def show_name(name,age):
#     print(name,age)
#     cur_process = multiprocessing.current_process()
#     print(cur_process.name)
# if __name__ == '__main__':
#     # 元组传参和字典传参
#     # sub_process = multiprocessing.Process(target=show_name,name='myprocess',args=('will',18))
#     sub_process = multiprocessing.Process(target=show_name,name='myprocess',kwargs={'name':'will','age':'18'})
#     sub_process.start()

# #使用join方法使子进程运行结束
# import multiprocessing,time,os
# def work():
#     for i in  range(10):
#         print('...工作中')
#         time.sleep(1)
# if __name__ == '__main__':
#     work_process = multiprocessing.Process(target=work)
#     #守护进程，守护其他进程结束而结束
#     work_process.daemon = True
#     work_process.start()
#     #join方法使子进程结束然后执行主进程，阻塞状态
#     #work_process.join()
#     time.sleep(2)
#     print("主进程结束")

# 进程间通信，queue对列，进程之间通信
import multiprocessing,time,os,queue
if __name__ == '__main__':
    queue_process = multiprocessing.Queue(3)
    queue_process.put(1)
    queue_process.put(2)
    queue_process.put('hi')
    if queue_process.qsize()== 0:
        print('队列为空')
    else:
        print('队列不为空')
    qsize = queue_process.qsize()
    print(qsize)
    vlus = queue_process.get()
    print(vlus)
    vlus = queue_process.qsize()
    print(vlus)

# import multiprocessing,time,os,queue
# def write_data(queue):
#     for i in range(10):
#         if queue.full():
#             print("队列已满")
#             break
#     #上面如果满了就break如果不满就put写入
#         queue.put(i)
#         time.sleep(0.2)
#         print('写入的数据为',i)
# def read_data(queue):
#     while True:
#         if queue.qsize() == 0:
#             print('队列为空')
#             break
#         value = queue.get()
#         print('得到的是',value)
#
# if __name__ == '__main__':
#     queue = multiprocessing.Queue(5)
#     write_process = multiprocessing.Process(target=write_data,args=(queue,))
#     read_process = multiprocessing.Process(target=read_data,args=(queue,))
#     write_process.start()
#     #使用join是让write运行完毕在执行read进程，否则将直接break
#     write_process.join()
#     read_process.start()

# #进程池同步阻塞异步不阻塞
# import multiprocessing,os,time
# def work():
#     print('打印中....',multiprocessing.current_process().pid)
#     time.sleep(0.5)
# if __name__ == '__main__':
#     pool = multiprocessing.Pool(3)
#     for i in range(5):
#         #同步阻塞，异步非阻塞，异步需要是用close和join阻塞让程序执行下来
#         pool.apply_async(work)
#         # pool.apply(work)
#     pool.close()
#     pool.join()
#

#进程池拷贝多任务
import os,shutil,multiprocessing,time
def copy_work(src_dir,dst_dir,file_name):
    pid = multiprocessing.current_process().pid
    print(pid)
    src_dir_path = src_dir+'/'+file_name
    dst_dir_path = dst_dir+'/'+file_name
    with open(src_dir_path,'rb') as src_file:
        with open(dst_dir_path,'wb') as dst_file:
            while True:
                src_file_data = src_file.read(1024)
                if src_file_data:
                    dst_file.write(src_file_data)
                else:
                    break
if __name__ == '__main__':
    src_dir = './copy/'
    dst_dir = './copy_in/'
    if os.path.exists(dst_dir):
        shutil.rmtree(dst_dir)
        os.mkdir(dst_dir)
    file_name_list = os.listdir(src_dir)
    pool = multiprocessing.Pool(3)
    for file_name in file_name_list:
        pool.apply_async(copy_work,(src_dir,dst_dir,file_name))
    pool.close()
    pool.join()