python怎么实现
Ⅰ 想用python编写一个脚本,登录网页,在网页里做一系列操作,应该怎样实现
python编写一个脚本的具体操作：
1、首先，打开python并创建一个新的PY文件。
Ⅱ python怎么实现一个进程
想要充分利用多核CPU资源，Python中大部分情况下都需要使用多进程，Python中提供了multiprocessing这个包实现多进程。multiprocessing支持子进程、进程间的同步与通信，提供了Process、Queue、Pipe、Lock等组件。
开辟子进程
multiprocessing中提供了Process类来生成进程实例
Process([group [, target [, name [, args [, kwargs]]]]])1
group分组，实际上不使用
target表示调用对象，你可以传入方法的名字
args表示给调用对象以元组的形式提供参数，比如target是函数a，他有两个参数m，n，那么该参数为args=(m, n)即可
kwargs表示调用对象的字典
name是别名，相当于给这个进程取一个名字
- # -*- coding:utf-8 -*-from multiprocessing import Process, Poolimport osimport timedef run_proc(wTime):
- n = 0
- while n < 3: print "subProcess %s run," % os.getpid(), "{0}".format(time.ctime()) #获取当前进程号和正在运行是的时间
- time.sleep(wTime) #等待（休眠）
- n += 1if __name__ == "__main__":
- p = Process(target=run_proc, args=(2,)) #申请子进程
- p.start() #运行进程
- print "Parent process run. subProcess is ", p.pid print "Parent process end,{0}".format(time.ctime())12345678910111213141516171819
- # -*- coding:utf-8 -*-from multiprocessing import Process, Poolimport osimport timedef run_proc(wTime):
- n = 0
- while n < 3: print "subProcess %s run," % os.getpid(), "{0}".format(time.ctime())
- time.sleep(wTime)
- n += 1if __name__ == "__main__":
- p = Process(target=run_proc, args=(2,))
- p.daemon = True #加入daemon
- p.start() print "Parent process run. subProcess is ", p.pid print "Parent process end,{0}".format(time.ctime())
- # -*- coding:utf-8 -*-from multiprocessing import Process, Poolimport osimport timedef run_proc(wTime):
- n = 0
- while n < 3: print "subProcess %s run," % os.getpid(), "{0}".format(time.ctime())
- time.sleep(wTime)
- n += 1if __name__ == "__main__":
- p = Process(target=run_proc, args=(2,))
- p.daemon = True
- p.start()
- p.join() #加入join方法
- print "Parent process run. subProcess is ", p.pid print "Parent process end,{0}".format(time.ctime())21
- # -*- coding:utf-8 -*-from multiprocessing import Process, Poolimport osimport timeclass Myprocess(Process):
- def __init__(self, wTime):
- Process.__init__(self)
- self.wTime = wTime def run(self):
- n = 0
- while n < 3: print "subProcess %s run," % os.getpid(), "{0}".format(time.ctime())
- time.sleep(self.wTime)
- n += 1if __name__ == "__main__":
- p = Myprocess(2)
- p.daemon = True
- p.start() #自动调用run方法
- p.join() print "Parent process run. subProcess is ", p.pid print "Parent process end,{0}".format(time.ctime())2122232425262728
- # -*- coding:utf-8 -*-from multiprocessing import Process,Poolimport os,timedef run_proc(name): ##定义一个函数用于进程调用
- for i in range(5):
- time.sleep(0.2) #休眠0.2秒
- print 'Run child process %s (%s)' % (name, os.getpid())#执行一次该函数共需1秒的时间if __name__ =='__main__': #执行主进程
- print 'Run the main process (%s).' % (os.getpid())
- mainStart = time.time() #记录主进程开始的时间
- p = Pool(8) #开辟进程池
- for i in range(16): #开辟14个进程
- p.apply_async(run_proc,args=('Process'+str(i),))#每个进程都调用run_proc函数，
- #args表示给该函数传递的参数。
- print 'Waiting for all subprocesses done ...'
- p.close() #关闭进程池
- p.join() #等待开辟的所有进程执行完后，主进程才继续往下执行
- print 'All subprocesses done'
- mainEnd = time.time() #记录主进程结束时间
- print 'All process ran %0.2f seconds.' % (mainEnd-mainStart) #主进程执行时间21222324
先来个小例子：
运行结果：
Parent process run. subProcess is 30196
Parent process end,Mon Mar 27 11:20:21 2017
subProcess 30196 run, Mon Mar 27 11:20:21 2017
subProcess 30196 run, Mon Mar 27 11:20:23 2017
subProcess 30196 run, Mon Mar 27 11:20:25 2017
根据运行结果可知，父进程运行结束后子进程仍然还在运行，这可能造成僵尸（ zombie）进程。
通常情况下，当子进程终结时，它会通知父进程，清空自己所占据的内存，并在内核里留下自己的退出信息。父进程在得知子进程终结时，会从内核中取出子进程的退出信息。但是，如果父进程早于子进程终结，这可能造成子进程的退出信息滞留在内核中，子进程成为僵尸（zombie）进程。当大量僵尸进程积累时，内存空间会被挤占。
有什么办法可以避免僵尸进程呢？
这里介绍进程的一个属性 deamon，当其值为TRUE时，其父进程结束，该进程也直接终止运行（即使还没运行完）。
所以给上面的程序加上p.deamon = true，看看效果。
执行结果：
Parent process run. subProcess is 31856
Parent process end,Mon Mar 27 11:40:10 2017
这是问题又来了，子进程并没有执行完，这不是所期望的结果。有没办法将子进程执行完后才让父进程结束呢？
这里引入p.join()方法，它使子进程执行结束后，父进程才执行之后的代码
执行结果：
subProcess 32076 run, Mon Mar 27 11:46:07 2017
subProcess 32076 run, Mon Mar 27 11:46:09 2017
subProcess 32076 run, Mon Mar 27 11:46:11 2017
Parent process run. subProcess is 32076
Parent process end,Mon Mar 27 11:46:13 2017
这样所有的进程就能顺利的执行了。
将进程定义成类
通过继承Process类，来自定义进程类，实现run方法。实例p通过调用p.start()时自动调用run方法。
如下：
执行结果和上一个例子相同。
创建多个进程
很多时候系统都需要创建多个进程以提高CPU的利用率，当数量较少时，可以手动生成一个个Process实例。当进程数量很多时，或许可以利用循环，但是这需要程序员手动管理系统中并发进程的数量，有时会很麻烦。这时进程池Pool就可以发挥其功效了。可以通过传递参数限制并发进程的数量，默认值为CPU的核数。
直接上例子：
执行结果：
开头部分
Run the main process (30920).
Waiting for all subprocesses done …
Run child process Process0 (32396)
Run child process Process3 (25392)
Run child process Process1 (28732)
Run child process Process2 (32436)
末尾部分：
Run child process Process15 (25880)
All subprocesses done
All process last 2.49 seconds.
相关说明：
这里进程池对并发进程的限制数量为8个，而程序运行时会产生16个进程，进程池将自动管理系统内进程的并发数量，其余进程将会在队列中等待。限制并发数量是因为，系统中并发的进程不是越多越好，并发进程太多，可能使CPU大部分的时间用于进程调度，而不是执行有效的计算。
采用多进程并发技术时，就单个处理机而言，其对进程的执行是串行的。但具体某个时刻哪个进程获得CPU资源而执行是不可预知的（如执行结果的开头部分，各进程的执行顺序不定），这就体现了进程的异步性。
如果单个程序执行14次run_proc函数，那么它会需要至少16秒,通过进程的并发，这里只需要2.49秒，可见并发的优势。
Ⅲ 用Python如何实现呢
start_i = 5
result = 1
while(start_i<=500):
if start_i != 99:
result = result * start_i
start_i = start_i + 1
print(result)
Ⅳ python 怎么实现人工智能
一、Python是解释语言，程序写起来非常方便
写程序方便对做机器学习的人很重要。 因为经常需要对模型进行各种各样的修改，这在编译语言里很可能是牵一发而动全身的事情，Python里通常可以用很少的时间实现。举例来说，在C等编译语言里写一个矩阵乘法，需要自己分配操作数（矩阵）的内存、分配结果的内存、手动对BLAS接口调用gemm、最后如果没用smart pointer还得手动回收内存空间。Python几乎就是import numpy; numpy.dot两句话的事。
当然现在很多面向C/C++库已经支持托管的内存管理了，这也让开发过程容易了很多，但解释语言仍然有天生的优势——不需要编译时间。这对机器学习这种需要大量prototyping和迭代的研究方向是非常有益工作效率的。
二、Python的开发生态成熟，有很多有用的库可以用
Python灵活的语法还使得包括文本操作、list/dict comprehension等非常实用的功能非常容易高效实现（编写和运行效率都高），配合lambda等使用更是方便。这也是Python良性生态背后的一大原因。相比而言，Lua虽然也是解释语言，甚至有LuaJIT这种神器加持，但其本身很难做到Python这样，一是因为有Python这个前辈占领着市场份额，另一个也因为它本身种种反常识的设计（比如全局变量）。不过借着Lua-Python bridge和Torch的东风，Lua似乎也在寄生兴起。
三、Python效率超高
解释语言的发展已经大大超过许多人的想象。很多比如list comprehension的语法糖都是贴近内核实现的。除了JIT之外，还有Cython可以大幅增加运行效率。最后，得益于Python对C的接口，很多像gnumpy, theano这样高效、Python接口友好的库可以加速程序的运行，在强大团队的支撑下，这些库的效率可能比一个不熟练的程序员用C写一个月调优的效率还要高。
未来十年Python语言的发展前景形势一片大好，毫无疑问使用Python语言的企业将会越来越多，Python程序猿的人才缺口也将越来越大，认准时机，把握机遇，Python全栈开发工程师、Python开发工程师、自动化开发工程师、Linux运维工程师、Python爬虫开发工程师、前端开发工程师、大数据分析和数据挖掘等热门职位等你来选。
Ⅳ 用python如何实现啊
from random import randint
class Shengfen(object):
def __init__(self, sname):
self.sname = sname
def shengfen(self):
print(self.sname)
class Dijishi(Shengfen):
def __init__(self, sname, dname):
Shengfen.__init__(self, sname)
self.dname = dname
self.money = 10000 #现有钱数
self.number = 0 #商品数量
self.jycs = 0 #交易次数
def attach_g(self): #联系供应商
self.money -= 100
self.number += 1
if self.number >= 4:
self.xiaoshou() #库存积攒到4件时，开始销售该商品
print("现有钱数：" + str(self.money))
print("现有商品数量：" + str(self.number))
def xiaoshou(self): #销售该商品
if self.jycs < 4: #交易次数小于4次，继续交易
self.money += 110
self.number -= 1
self.jycs += 1
else: #交易次数大于4次，又百分之50的几率退货
if randint(1,2) == 1: #用randint函数创建1/2概率
self.money += 110
self.number -= 1
else:
self.tuihuo()
def tuihuo(self):
self.money -= 30 #退货一件，相当于亏了30元
print("退货一件")
class Gebishi(Shengfen):
def __init__(self, sname, gname):
Shengfen.__init__(self, sname)
self.gname = gname
if __name__ == "__main__":
count = 9 #交易次数
Qinshihuang = Dijishi('Guangdong', 'Guangzhou')
Liubang = Gebishi('Guangdong', 'Foshan')
Hanxin = Gebishi('Guangdong', 'Foshan')
for i in range(count):
Qinshihuang.attach_g()
大致按照要求来写了一下，可能有些地方还有问题，如果有的话，你留言一下，我再帮你改吧
Ⅵ python语言，如何实现如下小功能
用Python解决稍微有点繁琐，这里不贴代码了，我说一下大致思路：
1、Python安装第三方库：pyopenxl
2、读取b列1行的数据，赋值给x，
3、将x的数据中的字符变成单个字母的列表。
4、将x中列表的第一个字母赋值给y
5、将y写入e列1行
6、遍历所有行，用for循环重复2-5操作，可以将2-5定义一个函数。
个人建议：虽然Python能够实现这项工作，但是是不是用编程来解决有点太麻烦了。如果用excel解决会更快一些：
1、复制b列粘贴到e列
2、选中e列，在查找和替换中查找“aaa”替换成“a”；查找“bbb”替换成“b"以此类推
这样的话一个电子表几分钟就能解决问题了。
3、解决问题有很多种办法，采用最简单、效率、稳定可行的办法。不一定非要用编程解决。
Ⅶ python行转换成列怎么实现
可以使用Python字符串内置的替换方法把分隔符“，”替换成‘ ’ 换行符即可(Linux、MacOS下换行符为：" ")：
iPython下演示
Ⅷ python 怎么实现多线程的
线程也就是轻量级的进程，多线程允许一次执行多个线程，Python是多线程语言，它有一个多线程包，GIL也就是全局解释器锁，以确保一次执行单个线程，一个线程保存GIL并在将其传递给下一个线程之前执行一些操作，也就产生了并行执行的错觉。
Ⅸ 在python中，怎么实现输入
Python的输入输出分别是利用函数：
str = input("请输入：");
print ("你输入的内容是: ", str)；
input函数返回一个string类型的值，声明一个变量来接收输入的值，print是输出