python脚本_python脚本编写 - CSDN
精华内容
参与话题
  • python常用运维脚本实例

    千次阅读 2018-07-17 16:58:46
    file是一个类,使用file('file_name', 'r+')这种方式打开文件,返回一个file对象,以写模式打开文件不存在则会被创建。但是更推荐使用内置函数open()来打开一个文件 .   首先open是内置函数,使用方式是open('...

    file是一个类,使用file('file_name', 'r+')这种方式打开文件,返回一个file对象,以写模式打开文件不存在则会被创建。但是更推荐使用内置函数open()来打开一个文件 .

     

    首先open是内置函数,使用方式是open('file_name', mode, buffering),返回值也是一个file对象,同样,以写模式打开文件如果不存在也会被创建一个新的。

     

    f=open('/tmp/hello','w')

     

    #open(路径+文件名,读写模式)

     

    #读写模式:r只读,r+读写,w新建(会覆盖原有文件),a追加,b二进制文件.常用模式

     

    如:'rb','wb','r+b'等等

     

    读写模式的类型有:

     

    rU 或 Ua 以读方式打开, 同时提供通用换行符支持 (PEP 278)

    w     以写方式打开,

    a     以追加模式打开 (从 EOF 开始, 必要时创建新文件)

    r+     以读写模式打开

    w+     以读写模式打开 (参见 w )

    a+     以读写模式打开 (参见 a )

    rb     以二进制读模式打开

    wb     以二进制写模式打开 (参见 w )

    ab     以二进制追加模式打开 (参见 a )

    rb+    以二进制读写模式打开 (参见 r+ )

    wb+    以二进制读写模式打开 (参见 w+ )

    ab+    以二进制读写模式打开 (参见 a+ )

     

    注意:

     

    1、使用'W',文件若存在,首先要清空,然后(重新)创建,

     

    2、使用'a'模式 ,把所有要写入文件的数据都追加到文件的末尾,即使你使用了seek()指向文件的其他地方,如果文件不存在,将自动被创建。

     

    f.read([size]) size未指定则返回整个文件,如果文件大小>2倍内存则有问题.f.read()读到文件尾时返回""(空字串)

     

    file.readline() 返回一行

     

    file.readline([size]) 返回包含size行的列表,size 未指定则返回全部行

     

    for line in f: 

    print line #通过迭代器访问

     

    f.write("hello\n") #如果要写入字符串以外的数据,先将他转换为字符串.

     

    f.tell() 返回一个整数,表示当前文件指针的位置(就是到文件头的比特数).

     

    f.seek(偏移量,[起始位置])

     

    用来移动文件指针

     

    偏移量:单位:比特,可正可负

     

    起始位置:0-文件头,默认值;1-当前位置;2-文件尾

     

    f.close() 关闭文件

     

    要进行读文件操作,只需要把模式换成'r'就可以,也可以把模式为空不写参数,也是读的意思,因为程序默认是为'r'的。

    >>>f = open('a.txt', 'r')

    >>>f.read(5)

    'hello'

    read( )是读文件的方法,括号内填入要读取的字符数,这里填写的字符数是5,如果填写的是1那么输出的就应该是‘h’。

    打开文件文件读取还有一些常用到的技巧方法,像下边这两种:

    1、read( ):表示读取全部内容

     

    2、readline( ):表示逐行读取

     

     

    一、用python写一个列举当前目录以及所有子目录下的文件,并打印出绝对路径

     

     

    #!/usr/bin/env python

    import os

    for root,dirs,files in os.walk('/tmp'):

        for name in files:

            print (os.path.join(root,name))

     

     

    os.walk()

    原型为:os.walk(top, topdown=True, οnerrοr=None, followlinks=False)

     

    我们一般只使用第一个参数。(topdown指明遍历的顺序)

     

    该方法对于每个目录返回一个三元组,(dirpath, dirnames, filenames)。

    第一个是路径,第二个是路径下面的目录,第三个是路径下面的非目录(对于windows来说也就是文件)

     

    os.listdir(path) 

     

    其参数含义如下。path 要获得内容目录的路径

     

     

    二、写程序打印三角形

     

    #!/usr/bin/env python

    input = int(raw_input('input number:'))

    for i in range(input):

        for j in range(i):

            print '*',

        print '\n'

     

     

    三、猜数器,程序随机生成一个个位数字,然后等待用户输入,输入数字和生成数字相同则视为成功。成功则打印三角形。失败则重新输入(提示:随机数函数:random)

     

    #!/usr/bin/env python

    import random

    while True:

        input = int(raw_input('input number:'))

        random_num = random.randint(1, 10)

        print input,random_num

        if input == random_num:

            for i in range(input):

                for j in range(i):

                    print '*',

                print '\n'

        else:

            print 'please input number again'

     

    四、请按照这样的日期格式(xxxx-xx-xx)每日生成一个文件,例如今天生成的文件为2013-09-23.log, 并且把磁盘的使用情况写到到这个文件中。

     

    #!/usr/bin/env python

    #!coding=utf-8

    import time

    import os

    new_time = time.strftime('%Y-%m-%d')

     

    disk_status = os.popen('df -h').readlines()

     

    str1 = ''.join(disk_status)

     

    f = file(new_time+'.log','w')

     

    f.write('%s' % str1)

    f.flush()

    f.close()

     

    五、统计出每个IP的访问量有多少?(从日志文件中查找)

    #!/usr/bin/env python

    #!coding=utf-8

    list = []

    f = file('/tmp/1.log')

    str1 = f.readlines() 

    f.close() 

    for i in str1:

        ip =  i.split()[0]

     

        list.append(ip) 

     

    list_num = set(list)

     

    for j in list_num: 

        num = list.count(j) 

        print '%s : %s' %(j,num)

     

     

     

     

     

    1. 写个程序,接受用户输入数字,并进行校验,非数字给出错误提示,然后重新等待用户输入。

    2. 根据用户输入数字,输出从0到该数字之间所有的素数。(只能被1和自身整除的数为素数)

     

    #!/usr/bin/env python

    #coding=utf-8

    import tab

    import sys

    while True:

        try:

            n = int(raw_input('请输入数字:').strip())

            for i in range(2, n + 1):

                for x in range(2, i):

                    if i % x == 0:

                        break

                else:

                    print i

        except ValueError:

            print('你输入的不是数字,请重新输入:')

        except KeyboardInterrupt:

            sys.exit('\n')

     

     

     

    python练习 抓取web页面

     

    from urllib import urlretrieve

    def firstNonBlank(lines): 

        for eachLine in lines: 

            if not eachLine.strip(): 

                continue 

        else: 

            return eachLine 

    def firstLast(webpage): 

        f=open(webpage) 

        lines=f.readlines() 

        f.close 

        print firstNonBlank(lines), #调用函数

        lines.reverse() 

        print firstNonBlank(lines), 

    def download(url= 'http://search.51job.com/jobsearch/advance_search.php',process=firstLast): 

        try: 

            retval = urlretrieve(url) [0] 

        except IOError: 

            retval = None 

        if retval: 

            process(retval) 

    if __name__ == '__main__': 

        download()

     

     

     

    Python中的sys.argv[]用法练习

     

    #!/usr/bin/python

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

    import sys

    def readFile(filename):

        f = file(filename)

        while True:

            fileContext = f.readline()

            if len(fileContext) ==0:

                break;

            print fileContext

        f.close()

    if len(sys.argv) < 2:

        print "No function be setted."

        sys.exit()

     

    if sys.argv[1].startswith("-"):

     

        option = sys.argv[1][1:]

     

        if option == 'version':

            print "Version1.2"

        elif option == 'help':

            print "enter an filename to see the context of it!"

        else:

            print "Unknown function!"

            sys.exit()

    else:

        for filename in sys.argv[1:]:

            readFile(filename)

     

     

    python迭代查找目录下文件

     

    #两种方法

    #!/usr/bin/env python

    import os

     

    dir='/root/sh'

    '''

    def fr(dir):

      filelist=os.listdir(dir)

      for i in filelist:

        fullfile=os.path.join(dir,i)

        if not os.path.isdir(fullfile):

          if i == "1.txt":

            #print fullfile

        os.remove(fullfile)

        else:

          fr(fullfile)

     

    '''

    '''

    def fw()dir:

      for root,dirs,files in os.walk(dir):

        for f in files:

          if f == "1.txt":

            #os.remove(os.path.join(root,f))

            print os.path.join(root,f)

    '''

     

    一、ps 可以查看进程的内存占用大小,写一个脚本计算一下所有进程所占用内存大小的和。

    (提示,使用ps aux 列出所有进程,过滤出RSS那列,然后求和)

     

    #!/usr/bin/env python

    #!coding=utf-8

    import os

    list = []

    sum = 0   

    str1 = os.popen('ps aux','r').readlines()

    for i in str1:

        str2 = i.split()

        new_rss = str2[5]

        list.append(new_rss)

    for i in  list[1:-1]: 

        num = int(i)

        sum = sum + num 

    print '%s:%s' %(list[0],sum)

     

     

     

     

     

    写一个脚本,判断本机的80端口是否开启着,如果开启着什么都不做,如果发现端口不存在,那么重启一下httpd服务,并发邮件通知你自己。脚本写好后,可以每一分钟执行一次,也可以写一个死循环的脚本,30s检测一次。

     

    #!/usr/bin/env python

    #!coding=utf-8

    import os

    import time

    import sys

    import smtplib

    from email.mime.text import MIMEText

    from email.MIMEMultipart import MIMEMultipart

     

    def sendsimplemail (warning):

        msg = MIMEText(warning)

        msg['Subject'] = 'python first mail'

        msg['From'] = 'root@localhost'

        try:

            smtp = smtplib.SMTP()

            smtp.connect(r'smtp.126.com')

            smtp.login('要发送的邮箱名', '密码')

            smtp.sendmail('要发送的邮箱名', ['要发送的邮箱名'], msg.as_string())

            smtp.close()

        except Exception, e:

            print e

     

    while True:

        http_status = os.popen('netstat -tulnp | grep httpd','r').readlines()

        try:

            if http_status == []:

                os.system('service httpd start')

                new_http_status = os.popen('netstat -tulnp | grep httpd','r').readlines()

                str1 = ''.join(new_http_status)

                is_80 = str1.split()[3].split(':')[-1]

                if is_80 != '80':

                    print 'httpd 启动失败'

                else:

                    print 'httpd 启动成功'

                    sendsimplemail(warning = "This is a warning!!!")#调用函数

            else:

                print 'httpd正常'

            time.sleep(5)

        except KeyboardInterrupt:

            sys.exit('\n') 

     

     

     

    #!/usr/bin/python

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

    #输入这一条就可以在Python脚本里面使用汉语注释!此脚本可以直接复制使用;

     

    while True:            #进入死循环

            input = raw_input('Please input your username:')    

    #交互式输入用户信息,输入input信息;

            if input == "wenlong":        

    #如果input等于wenlong则进入此循环(如果用户输入wenlong)

                    password = raw_input('Please input your pass:')    

    #交互式信息输入,输入password信息;

                    p = '123'                  

    #设置变量P赋值为123

                    while password != p:         

    #如果输入的password 不等于p(123), 则进此入循环

                            password = raw_input('Please input your pass again:') 

    #交互式信息输入,输入password信息;

                    if password == p:        

    #如果password等于p(123),则进入此循环

                            print 'welcome to select system!'              #输出提示信息;

                            while True:           

    #进入循环;

                                    match = 0     

    #设置变量match等于0;

                                    input = raw_input("Please input the name whom you want to search :")   

    #交互式信息输入,输入input信息;

                                    while not input.strip():   

    #判断input值是否为空,如果input输出为空,则进入循环;

                                            input = raw_input("Please input the name whom you want to search :")        

    #交互式信息输入,输入input信息;

                                    name_file = file('search_name.txt')     

    #设置变量name_file,file('search_name.txt')是调用名为search_name.txt的文档

                                    while True:               

    #进入循环;

                                            line = name_file.readline()           #以行的形式,读取search_name.txt文档信息;

                                            if len(line) == 0:      #当len(name_file.readline() )为0时,表示读完了文件,len(name_file.readline() )为每一行的字符长度,空行的内容为\n也是有两个字符。len为0时进入循环;

                                                     break       #执行到这里跳出循环;

                                            if input in line:    #如果输入的input信息可以匹配到文件的某一行,进入循环;

                                                    print 'Match item: %s'  %line     #输出匹配到的行信息;

                                                    match = 1    #给变量match赋值为1

                                    if match == 0 :              #如果match等于0,则进入   ;

                                            print 'No match item found!'         #输出提示信息;

            else: print "Sorry ,user  %s not found " %input      #如果输入的用户不是wenlong,则输出信息没有这个用户;

     

     

     

    #!/usr/bin/python

    while True:

            input = raw_input('Please input your username:')

            if input == "wenlong":

                    password = raw_input('Please input your pass:')

                    p = '123'

                    while password != p:

                            password = raw_input('Please input your pass again:')

                    if password == p:

                            print 'welcome to select system!'

                            while True:

                                    match = 0

                                    input = raw_input("Please input the name whom you want to search :")

                                    while not input.strip():

                                            print 'No match item found!'

                                            input = raw_input("Please input the name whom you want to search :")

                                    name_file = file('search_name.txt')

                                    while True:

                                            line = name_file.readline()

                                            if len(line) == 0:

                                                     break

                                            if input in line:

                                                    print 'Match item: '  , line

                                                    match = 1

                                    if match == 0 :

                                            print 'No match item found!'

            else: print "Sorry ,user  %s not found " %input

     

    Python监控CPU情况

     

    1、实现原理:通过SNMP协议获取系统信息,再进行相应的计算和格式化,最后输出结果

    2、特别注意:被监控的机器上需要支持snmp。yum install -y net-snmp*安装

    """

     

    #!/usr/bin/python

    import os

    def getAllitems(host, oid):

            sn1 = os.popen('snmpwalk -v 2c -c public ' + host + ' ' + oid + '|grep Raw|grep Cpu|grep -v Kernel').read().split('\n')[:-1]

            return sn1

                                                                    

    def getDate(host):

            items = getAllitems(host, '.1.3.6.1.4.1.2021.11')

                                                                    

            date = []

            rate = []

            cpu_total = 0

            #us = us+ni, sy = sy + irq + sirq

            for item in items:

                    float_item = float(item.split(' ')[3])

                    cpu_total += float_item

                    if item == items[0]:

                            date.append(float(item.split(' ')[3]) + float(items[1].split(' ')[3]))

                    elif item == item[2]:

                            date.append(float(item.split(' ')[3] + items[5].split(' ')[3] + items[6].split(' ')[3]))

                    else:

                            date.append(float_item)

                                                                    

            #calculate cpu usage percentage

            for item in date:

                    rate.append((item/cpu_total)*100)

                                                                    

            mean = ['%us','%ni','%sy','%id','%wa','%cpu_irq','%cpu_sIRQ']

                                                                    

            #calculate cpu usage percentage

            result = map(None,rate,mean)

            return result

                                                                    

    if __name__ == '__main__':

            hosts = ['192.168.10.1','192.168.10.2']

            for host in hosts:

                    print '==========' + host + '=========='

                    result = getDate(host)

                    print 'Cpu(s)',

                    #print result

                    for i in range(5):

                            print ' %.2f%s' % (result[i][0],result[i][1]),

                    print

                    print

     

    Python监控系统负载

    1、实现原理:通过SNMP协议获取系统信息,再进行相应的计算和格式化,最后输出结果

    2、特别注意:被监控的机器上需要支持snmp。yum install -y net-snmp*安装

    """

     

    #!/usr/bin/python

    import os

    def getAllitems(host, oid):

            sn1 = os.popen('snmpwalk -v 2c -c public ' + host + ' ' + oid).read().split('\n')

            return sn1

                                                                         

    def getload(host,loid):

            load_oids = '1.3.6.1.4.1.2021.10.1.3.' + str(loid)

            return getAllitems(host,load_oids)[0].split(':')[3]

                                                                         

    if __name__ == '__main__':

            hosts = ['192.168.10.1','192.168.10.2']

            #check_system_load

            print '==============System Load=============='

            for host in hosts:

                    load1 = getload(host, 1)

                    load10 = getload(host, 2)

                    load15 = getload(host, 3)

                    print '%s load(1min): %s ,load(10min): %s ,load(15min): %s' % (host,load1,load10,load15)

     

    Python监控网卡流量

    1、实现原理:通过SNMP协议获取系统信息,再进行相应的计算和格式化,最后输出结果

    2、特别注意:被监控的机器上需要支持snmp。yum install -y net-snmp*安装

    """

    #!/usr/bin/python

    import re

    import os

    #get SNMP-MIB2 of the devices

    def getAllitems(host,oid):

            sn1 = os.popen('snmpwalk -v 2c -c public ' + host + ' ' + oid).read().split('\n')[:-1]

            return sn1

                                                                                          

    #get network device

    def getDevices(host):

            device_mib = getAllitems(host,'RFC1213-MIB::ifDescr')

            device_list = []

            for item in device_mib:

                    if re.search('eth',item):

                            device_list.append(item.split(':')[3].strip())

            return device_list

                                                                                          

    #get network date

    def getDate(host,oid):

            date_mib = getAllitems(host,oid)[1:]

            date = []

            for item in date_mib:

                    byte = float(item.split(':')[3].strip())

                    date.append(str(round(byte/1024,2)) + ' KB')

            return date

                                                                                          

    if __name__ == '__main__':

            hosts = ['192.168.10.1','192.168.10.2']

            for host in hosts:

                    device_list = getDevices(host)

                                                                                          

                    inside = getDate(host,'IF-MIB::ifInOctets')

                    outside = getDate(host,'IF-MIB::ifOutOctets')

                                                                                          

                    print '==========' + host + '=========='

                    for i in range(len(inside)):

                            print '%s : RX: %-15s   TX: %s ' % (device_list[i], inside[i], outside[i])

                    print

     

     

    Python监控磁盘

     

    1、实现原理:通过SNMP协议获取系统信息,再进行相应的计算和格式化,最后输出结果

    2、特别注意:被监控的机器上需要支持snmp。yum install -y net-snmp*安装

    """

    #!/usr/bin/python

    import re

    import os

    def getAllitems(host,oid):

            sn1 = os.popen('snmpwalk -v 2c -c public ' + host + ' ' + oid).read().split('\n')[:-1]

            return sn1

                                                                 

    def getDate(source,newitem):

            for item in source[5:]:

                    newitem.append(item.split(':')[3].strip())

            return newitem

                                                                 

    def getRealDate(item1,item2,listname):

            for i in range(len(item1)):

                    listname.append(int(item1[i])*int(item2[i])/1024)

            return listname

                                                                 

    def caculateDiskUsedRate(host):

            hrStorageDescr = getAllitems(host, 'HOST-RESOURCES-MIB::hrStorageDescr')

            hrStorageUsed = getAllitems(host, 'HOST-RESOURCES-MIB::hrStorageUsed')

            hrStorageSize = getAllitems(host, 'HOST-RESOURCES-MIB::hrStorageSize')

            hrStorageAllocationUnits = getAllitems(host, 'HOST-RESOURCES-MIB::hrStorageAllocationUnits')

                                                                 

            disk_list = []

            hrsused = []

            hrsize = []

            hrsaunits = []

                                                                 

            #get disk_list

            for item in hrStorageDescr:

                    if re.search('/',item):

                            disk_list.append(item.split(':')[3])

            #print disk_list      

                                                                 

            getDate(hrStorageUsed,hrsused)

            getDate(hrStorageSize,hrsize)

            #print getDate(hrStorageAllocationUnits,hrsaunits)

                                                                 

            #get hrstorageAllocationUnits

            for item in hrStorageAllocationUnits[5:]:

                    hrsaunits.append(item.split(':')[3].strip().split(' ')[0])

            #caculate the result

            #disk_used = hrStorageUsed * hrStorageAllocationUnits /1024 (KB)

            disk_used = []

            total_size = []

            disk_used = getRealDate(hrsused,hrsaunits,disk_used)

            total_size = getRealDate(hrsize,hrsaunits,total_size)

                                                                 

            diskused_rate = []

            for i in range(len(disk_used)):

                    diskused_rate.append(str(round((float(disk_used[i])/float(total_size[i])*100), 2)) + '%')

                                                                 

            return diskused_rate,disk_list

                                                                 

    if __name__ == '__main__':

            hosts = ['192.168.10.1','192.168.10.2']

            for host in hosts:

                    result = caculateDiskUsedRate(host)

                    diskused_rate = result[0]

                    partition = result[1]

                    print "==========",host,'=========='

                    for i in range(len(diskused_rate)):

                            print '%-20s used: %s' % (partition[i],diskused_rate[i])

                    print

     

     

    Python监控内存(swap)的使用率

     

     

    1、实现原理:通过SNMP协议获取系统信息,再进行相应的计算和格式化,最后输出结果

    2、特别注意:被监控的机器上需要支持snmp。yum install -y net-snmp*安装

    '''

    #!/usr/bin/python

    import os

    def getAllitems(host, oid):

            sn1 = os.popen('snmpwalk -v 2c -c public ' + host + ' ' + oid).read().split('\n')[:-1]

            return sn1

                                                                                

    def getSwapTotal(host):

            swap_total = getAllitems(host, 'UCD-SNMP-MIB::memTotalSwap.0')[0].split(' ')[3]

            return swap_total

                                                                                

    def getSwapUsed(host):

            swap_avail = getAllitems(host, 'UCD-SNMP-MIB::memAvailSwap.0')[0].split(' ')[3]

            swap_total = getSwapTotal(host)

            swap_used = str(round(((float(swap_total)-float(swap_avail))/float(swap_total))*100 ,2)) + '%'

            return swap_used

                                                                                

    def getMemTotal(host):

            mem_total = getAllitems(host, 'UCD-SNMP-MIB::memTotalReal.0')[0].split(' ')[3]

            return mem_total

                                                                                

    def getMemUsed(host):

            mem_total = getMemTotal(host)

            mem_avail = getAllitems(host, 'UCD-SNMP-MIB::memAvailReal.0')[0].split(' ')[3]

            mem_used = str(round(((float(mem_total)-float(mem_avail))/float(mem_total))*100 ,2)) + '%'

            return mem_used

                                                                                

    if __name__ == '__main__':

            hosts = ['192.168.10.1','192.168.10.2']

            print "Monitoring Memory Usage"

            for host in hosts:

                    mem_used = getMemUsed(host)

                    swap_used = getSwapUsed(host)

                    print '==========' + host + '=========='

                    print 'Mem_Used = %-15s   Swap_Used = %-15s' % (mem_used, swap_used)

                    print

     

    Python运维脚本 生成随机密码

     

    #!/usr/bin/env python

    # -*- coding=utf-8 -*-

    #Using GPL v2.7

    #Author: leexide@126.com

     

    import random, string        #导入random和string模块

     

    def GenPassword(length):

        #随机出数字的个数

        numOfNum = random.randint(1,length-1)

        numOfLetter = length - numOfNum

        #选中numOfNum个数字

        slcNum = [random.choice(string.digits) for i in range(numOfNum)]

        #选中numOfLetter个字母

        slcLetter = [random.choice(string.ascii_letters) for i in range(numOfLetter)]

        #打乱组合

        slcChar = slcNum + slcLetter

        random.shuffle(slcChar)

        #生成随机密码

        getPwd = ''.join([i for i in slcChar])

        return getPwd

     

    if __name__ == '__main__':

        print GenPassword(6)

     

     

    利用random生成6位数字加字母随机验证码

     

    import random

    li = []

    for i in range(6):

        r = random.randrange(0, 5)

        if r == 2 or r == 4:

            num = random.randrange(0, 9)

            li.append(str(num))

        else:

            temp = random.randrange(65, 91)

            c = chr(temp)

            li.append(c)

    result = "".join(li)  # 使用join时元素必须是字符串

    print(result)

    输出

    335HQS

    VS6RN5

    ...

     

    random.random()用于生成一个指定范围内的随机符点数,两个参数其中一个是上限,一个是下限。如果a > b,则生成随机数

     

    n: a <= n <= b。如果 a <b, 则 b <= n <= a。

     

    print random.uniform(10, 20)  

    print random.uniform(20, 10)  

    #---- 

    #18.7356606526  

    #12.5798298022  

     

    random.randint 用于生成一个指定范围内的整数。其中参数a是下限,参数b是上限,Python生成随机数

    print random.randint(12, 20) #生成的随机数n: 12 <= n <= 20 

    print random.randint(20, 20) #结果永远是20 

    #print random.randint(20, 10) #该语句是错误的。 

    下限必须小于上限。

     

    random.randrange 从指定范围内,按指定基数递增的集合中 

     

    random.randrange的函数原型为:random.randrange([start], stop[, step]),从指定范围内,按指定基数递增的集合中 获取一个随机数。

    如:

    random.randrange(10, 100, 2),结果相当于从[10, 12, 14, 16, ... 96, 98]序列中获取一个随机数。

    random.randrange(10, 100, 2)在结果上与 random.choice(range(10, 100, 2) 等效

     

    随机整数:

    >>> import random

    >>> random.randint(0,99)

    21

     

    随机选取0到100间的偶数:

    >>> import random

    >>> random.randrange(0, 101, 2)

    42

     

    随机浮点数:

    >>> import random

    >>> random.random() 

    0.85415370477785668

    >>> random.uniform(1, 10)

    5.4221167969800881

     

    随机字符:

     

    random.choice从序列中获取一个随机元素

    其函数原型为:random.choice(sequence)。参数sequence表示一个有序类型

     

    这里要说明 一下:sequence在python不是一种特定的类型,而是泛指一系列的类型。

     

    list, tuple, 字符串都属于sequence。

     

    print random.choice("学习Python")   

    print random.choice(["JGood", "is", "a", "handsome", "boy"])  

    print random.choice(("Tuple", "List", "Dict"))  

     

    >>> import random

    >>> random.choice('abcdefg&#%^*f')

    'd'

     

    多个字符中选取特定数量的字符:

     

    random.sample的函数原型为:random.sample(sequence, k),从指定序列中随机获取指定长度的片断

     

    sample函数不会修改原有序列。

     

    >>> import random

    random.sample('abcdefghij',3) 

    ['a', 'd', 'b']

     

    多个字符中选取特定数量的字符组成新字符串:

    >>> import random

    >>> import string

    >>> string.join(random.sample(['a','b','c','d','e','f','g','h','i','j'], 3)).r

    eplace(" ","")

    'fih'

     

    随机选取字符串:

    >>> import random

    >>> random.choice ( ['apple', 'pear', 'peach', 'orange', 'lemon'] )

    'lemon'

     

    洗牌:

    random.shuffle的函数原型为:random.shuffle(x[, random]),用于将一个列表中的元素打乱 .

    >>> import random

    >>> items = [1, 2, 3, 4, 5, 6]

    >>> random.shuffle(items)

    >>> items

    [3, 2, 5, 6, 4, 1]

     

     

    1、random.random

     

     random.random()用于生成一个0到1的随机符点数: 0 <= n < 1.0

     

    2、random.uniform

      random.uniform(a, b),用于生成一个指定范围内的随机符点数

    两个参数其中一个是上限,一个是下限。

     

      如果a < b,则生成的随机数n: b>= n >= a。

     

      如果 a >b,则生成的随机数n: a>= n >= b。

     

      print random.uniform(10, 20)

      print random.uniform(20, 10)

      # 14.73

      # 18.579 

     

    3、random.randint

      random.randint(a, b),用于生成一个指定范围内的整数。其中参数a是下限,参数b是上限,生成的随机数n: a <= n <= b

     

      print random.randint(1, 10)

     

    4、random.randrange

      random.randrange([start], stop[, step]),从指定范围内,按指定基数递增的集合中 获取一个随机数。

     

      如:random.randrange(10, 100, 2),结果相当于从[10, 12, 14, 16, ... 96, 98]序列中获取一个随机数。

     

    5、random.choice

      random.choice从序列中获取一个随机元素。其函数原型为:random.choice(sequence)。参数sequence表示一个有序类型。

     

      这里要说明 一下:sequence在python不是一种特定的类型,而是泛指一系列的类型。list, tuple, 字符串都属于sequence。

     

      print random.choice("Python")

      print random.choice(["JGood", "is", "a", "handsome", "boy"])

      print random.choice(("Tuple", "List", "Dict")) 

     

    6、random.shuffle

      random.shuffle(x[, random]),用于将一个列表中的元素打乱

     

      如:

     

        p = ["Python", "is", "powerful", "simple", "and so on..."]

        random.shuffle(p)

        print p

        # ['powerful', 'simple', 'is', 'Python', 'and so on...'] 

     

    7、random.sample

      random.sample(sequence, k),从指定序列中随机获取指定长度的片断。sample函数不会修改原有序列。

     

      例如:

     

      list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10,11,12]

      slice = random.sample(list, 6)  # 从list中随机获取6个元素,作为一个片断返回

      print slice

      print list  # 原有序列并没有改变

     

     

    1.生成随机整数:

    random.randint(a,b)


    random.randint(a,b) #返回一个随机整数,范围是a <=x <= b
    >>> random.randint(888,999)
    897
    >>> random.randint(888,999)
    989
    >>> random.randint(888,999)
    995


    random.randrange(start, stop[, step]) #返回指定范围的整数
    >>> random.randrange(2,20,2)
    6
    >>> random.randrange(2,20,2)
    4
    >>> random.randrange(2,20,2)
    14
    2.浮点数


    random.random() #返回一个浮点数,范围是0.0 到1.0
    >>> random.random()
    0.22197993728352594
    >>> random.random()
    0.8683996624230081
    >>> random.random()
    0.29398514954873434


    random.uniform(a,b)#返回一个指定范围的浮点数
    >>> random.uniform(1, 10)
    3.0691737651343636
    >>> random.uniform(1, 10)
    9.142357395475619
    >>> random.uniform(1, 10)
    6.927435868405478


    3.随机序列


    random.choice()#从非空序列中返回一个随机元素
    >>> name
    ['du', 'diao', 'han', 'jiang', 'xue']
    >>> random.choice(name)
    'xue'
    >>> random.choice(name)
    'xue'
    >>> random.choice(name)
    'du'
    >>> random.choice(name)
    'du'
    >>> random.choice(name)
    'du'
    >>> random.choice(name)
    'jiang'


    #随机返回指定长度的子序列
    >>> random.sample(name,2)
    ['xue', 'du']
    >>> random.sample(name,2)
    ['diao', 'jiang']
    >>> random.sample(name,2)
    ['xue', 'du']


    生成指定长度的随机密码:


    [root@zhu ~]# python jiang.py
    GrDUytJE
    [root@zhu ~]# python jiang.py
    8XaCoUTz
    [root@zhu ~]# cat jiang.py

    import random,string

    chars=string.ascii_letters+string.digits

    print ''.join([random.choice(chars) for i in range(8)])

     

     

     

    #!/usr/bin/env python

    import random

    import string

    import sys

     

    similar_char = '0OoiI1LpP'

    upper = ''.join(set(string.uppercase) - set(similar_char))

    lower = ''.join(set(string.lowercase) - set(similar_char))

     

    symbols = '!#$%&\*+,-./:;=?@^_`~'

     

    numbers = '123456789'

     

    group = (upper, lower, symbols, numbers)

     

    def getpass(lenth=8):

        pw = [random.choice(i) for i in group]

        con = ''.join(group)

     

        for i in range(lenth-len(pw)):

     

            pw.append(random.choice(con))

     

            random.shuffle(pw)

        return ''.join(pw)

     

    genpass = getpass(int(sys.argv[1]))

    print genpass

     

     

     

    #!/usr/bin/env python

    import random

    import string

    def GenPassword(length):

     

        chars=string.ascii_letters+string.digits

     

        return ''.join([random.choice(chars) for i in range(length)])

     

    if __name__=="__main__":

        for i in range(10):

            print GenPassword(15) 

     

     

     

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

    '''

    简短地生成随机密码,包括大小写字母、数字,可以指定密码长度

    '''

    #生成随机密码

    from random import choice

    import string

    #python3中为string.ascii_letters,而python2下则可以使用string.letters和string.ascii_letters

     

    def GenPassword(length=8,chars=string.ascii_letters+string.digits):

     

        return ''.join([choice(chars) for i in range(length)])

    if __name__=="__main__":

        #生成10个随机密码    

        for i in range(10):

            #密码的长度为8

            print(GenPassword(8))

     

     

     

    #!/usr/bin/env python

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

    #导入random和string模块

    import random, string

    def GenPassword(length):

     

        #随机出数字的个数

        numOfNum = random.randint(1,length-1)

        numOfLetter = length - numOfNum

     

        #选中numOfNum个数字

        slcNum = [random.choice(string.digits) for i in range(numOfNum)]

     

        #选中numOfLetter个字母

        slcLetter = [random.choice(string.ascii_letters) for i in range(numOfLetter)]

     

        #打乱这个组合

        slcChar = slcNum + slcLetter

        random.shuffle(slcChar)

        #生成密码

        genPwd = ''.join([i for i in slcChar])

        return genPwd

    if __name__ == '__main__':

        print GenPassword(6)

     

     

     

     

     

     

     

     

     

    round取相邻整数

     

    print(round(1.4))

    print(round(1.8))

    输出:

    1

    2

     

    查看各个进程读写的磁盘IO

    #!/usr/bin/env python

    # -*- coding=utf-8 -*-

     

     

    import sys

    import os

    import time

    import signal

    import re

     

    class DiskIO:

       def __init__(self, pname=None, pid=None, reads=0, writes=0):

           self.pname = pname

           self.pid = pid

           self.reads = 0

           self.writes = 0

     

    def main():

       argc = len(sys.argv)

       if argc != 1:

           print "usage: please run this script like [./diskio.py]"

           sys.exit(0)

       if os.getuid() != 0:

           print "Error: This script must be run as root"

           sys.exit(0)

       signal.signal(signal.SIGINT, signal_handler)

       os.system('echo 1 > /proc/sys/vm/block_dump')

       print "TASK              PID       READ      WRITE"

       while True:

           os.system('dmesg -c > /tmp/diskio.log')

           l = []

           f = open('/tmp/diskio.log', 'r')

           line = f.readline()

           while line:

               m = re.match(\

                   '^(\S+)(\d+)(\d+): (READ|WRITE) block (\d+) on (\S+)', line)

               if m != None:

                   if not l:

                       l.append(DiskIO(m.group(1), m.group(2)))

                       line = f.readline()

                       continue

                   found = False

                   for item in l:

                       if item.pid == m.group(2):

                           found = True

                           if m.group(3) == "READ":

                               item.reads = item.reads + 1

                           elif m.group(3) == "WRITE":

                               item.writes = item.writes + 1

                   if not found:

                       l.append(DiskIO(m.group(1), m.group(2)))

               line = f.readline()

           time.sleep(1)

           for item in l:

               print "%-10s %10s %10d %10d" % \

                   (item.pname, item.pid, item.reads, item.writes)

    def signal_handler(signal, frame):

       os.system('echo 0 > /proc/sys/vm/block_dump')

       sys.exit(0)

    if __name__=="__main__":

       main()

     

     

    Python自动化运维之简易ssh自动登录

     

     

    #!/usr/bin/env python

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

     

    import pexpect

    import sys

     

    ssh = pexpect.spawn('ssh root@192.168.20.103 ')

    fout = file('sshlog.txt', 'w')

    ssh.logfile = fout

     

     

    ssh.expect("root@192.168.20.103's password:")

     

    ssh.sendline("yzg1314520")

     

    ssh.expect('#')

    ssh.sendline('ls /home')

    ssh.expect('#')

     

     

     

    Python运维-获取当前操作系统的各种信息

     

     

    #通过Python的psutil模块,获取当前系统的各种信息(比如内存,cpu,磁盘,登录用户等),并将信息进行备份

    # coding=utf-8

     

    # 获取系统基本信息

    import sys

    import psutil

    import time

    import os 

     

    #获取当前时间

    time_str =  time.strftime( "%Y-%m-%d", time.localtime( ) )

    file_name = "./" + time_str + ".log"

     

    if os.path.exists ( file_name ) == False :

       os.mknod( file_name )

       handle = open ( file_name , "w" )

    else :

       handle = open ( file_name , "a" )

     

     

    #获取命令行参数的个数

    if len( sys.argv ) == 1 :

       print_type = 1

    else :

       print_type = 2

     

    def isset ( list_arr , name ) :

        if name in list_arr :

           return True

        else :

           return False

     

    print_str = "";

     

    #获取系统内存使用情况

    if ( print_type == 1 ) or isset( sys.argv,"mem" )  :

     memory_convent = 1024 * 1024

     mem = psutil.virtual_memory()

     print_str +=  " 内存状态如下:\n" 

     print_str = print_str + "   系统的内存容量为: "+str( mem.total/( memory_convent ) ) + " MB\n" 

     print_str = print_str + "   系统的内存以使用容量为: "+str( mem.used/( memory_convent ) ) + " MB\n" 

     print_str = print_str + "   系统可用的内存容量为: "+str( mem.total/( memory_convent ) - mem.used/( 1024*1024 )) + "MB\n"

     print_str = print_str + "   内存的buffer容量为: "+str( mem.buffers/( memory_convent ) ) + " MB\n" 

     print_str = print_str + "   内存的cache容量为:" +str( mem.cached/( memory_convent ) ) + " MB\n"

     

     

    #获取cpu的相关信息

    if ( print_type == 1 ) or isset( sys.argv,"cpu" ) :

     print_str += " CPU状态如下:\n"

     cpu_status = psutil.cpu_times()

     print_str = print_str + "   user = " + str( cpu_status.user ) + "\n" 

     print_str = print_str + "   nice = " + str( cpu_status.nice ) + "\n"

     print_str = print_str + "   system = " + str( cpu_status.system ) + "\n"

     print_str = print_str + "   idle = " + str ( cpu_status.idle ) + "\n"

     print_str = print_str + "   iowait = " + str ( cpu_status.iowait ) + "\n"

     print_str = print_str + "   irq = " + str( cpu_status.irq ) + "\n"

     print_str = print_str + "   softirq = " + str ( cpu_status.softirq ) + "\n" 

     print_str = print_str + "   steal = " + str ( cpu_status.steal ) + "\n"

     print_str = print_str + "   guest = " + str ( cpu_status.guest ) + "\n"

     

     

    #查看硬盘基本信息

    if ( print_type == 1 ) or isset ( sys.argv,"disk" ) :

     print_str +=  " 硬盘信息如下:\n" 

     disk_status = psutil.disk_partitions()

     for item in disk_status :

         print_str = print_str + "   "+ str( item ) + "\n"

     

    #查看当前登录的用户信息

    if ( print_type == 1 ) or isset ( sys.argv,"user" ) :

     print_str +=  " 登录用户信息如下:\n " 

     user_status = psutil.users()

     for item in  user_status :

         print_str = print_str + "   "+ str( item ) + "\n"

     

    print_str += "---------------------------------------------------------------\n"

    print ( print_str )

    handle.write( print_str )

    handle.close()

     

     

     

    Python自动化运维学习笔记

     

    psutil  跨平台的PS查看工具

    执行pip install psutil 即可,或者编译安装都行。

     

    # 输出内存使用情况(以字节为单位)

     

    import psutil

     

    mem = psutil.virtual_memory()

    print mem.total,mem.used,mem

    print psutil.swap_memory()  # 输出获取SWAP分区信息

     

    # 输出CPU使用情况

     

    cpu = psutil.cpu_stats()

    printcpu.interrupts,cpu.ctx_switches

      

    psutil.cpu_times(percpu=True)      # 输出每个核心的详细CPU信息

    psutil.cpu_times().user              # 获取CPU的单项数据 [用户态CPU的数据]

    psutil.cpu_count()                   # 获取CPU逻辑核心数,默认logical=True

    psutil.cpu_count(logical=False) # 获取CPU物理核心数

     

    # 输出磁盘信息

     

    psutil.disk_partitions()         # 列出全部的分区信息

    psutil.disk_usage('/')               # 显示出指定的挂载点情况【字节为单位】

    psutil.disk_io_counters()       # 磁盘总的IO个数

    psutil.disk_io_counters(perdisk=True)  # 获取单个分区IO个数

     

     

    # 输出网卡信息

    psutil.net_io_counter() 获取网络总的IO,默认参数pernic=False

    psutil.net_io_counter(pernic=Ture)获取网络各个网卡的IO

     

    # 获取进程信息

    psutil.pids()     # 列出所有进程的pid号

    p = psutil.Process(2047)

    p.name()   列出进程名称

    p.exe()    列出进程bin路径

    p.cwd()    列出进程工作目录的绝对路径

    p.status()进程当前状态[sleep等状态]

    p.create_time()   进程创建的时间 [时间戳格式]

    p.uids()

    p.gids()

    p.cputimes()  【进程的CPU时间,包括用户态、内核态】

    p.cpu_affinity()  # 显示CPU亲缘关系

    p.memory_percent()   进程内存利用率

    p.meminfo()   进程的RSS、VMS信息

    p.io_counters()   进程IO信息,包括读写IO数及字节数

    p.connections()   返回打开进程socket的namedutples列表

    p.num_threads()   进程打开的线程数

     

    #下面的例子中,Popen类的作用是获取用户启动的应用程序进程信息,以便跟踪程序进程的执行情况

     

    import psutil

    from subprocess import PIPE

    p =psutil.Popen(["/usr/bin/python" ,"-c","print 'helloworld'"],stdout=PIPE)

    p.name()

    p.username()

    p.communicate()

    p.cpu_times()

     

    # 其它

    psutil.users()    # 显示当前登录的用户,和Linux的who命令差不多

      

    # 获取开机时间

    psutil.boot_time() 结果是个UNIX时间戳,下面我们来转换它为标准时间格式,如下:

    datetime.datetime.fromtimestamp(psutil.boot_time())  # 得出的结果不是str格式,继续进行转换 datetime.datetime.fromtimestamp(psutil.boot_time()).strftime('%Y-%m-%d%H:%M:%S')

     

    转载

    展开全文
  • python脚本编写

    万次阅读 多人点赞 2019-03-29 22:37:20
    Python 是一种“脚本语言”。脚本,对应的英文是:script。一般人看到script这个英文单词,或许想到的更多的是:电影的剧本,就是一段段的脚本,所组成的。电影剧本的脚本,决定了电影中的人和物,都做哪些事情,...

     

    什么是脚本

    Python 是一种“脚本语言”。脚本,对应的英文是:script。一般人看到script这个英文单词,或许想到的更多的是:电影的剧本,就是一段段的脚本,所组成的。电影剧本的脚本,决定了电影中的人和物,都做哪些事情,怎么做。而计算机中的脚本,决定了:计算机中的操作系统和各种软件工具,要做哪些事情,以及具体怎么做。

    脚本 vs 程序

    你可能想要了解脚本与一般程序的区别是什么。

    脚本与一般程序的主要区别在于是否编译。相对于程序而言,脚本更加随性。写完了脚本,直接就可以在某种具有解释功能的环境中运行。(我们将会在本课学习如何写和运行 Python 脚本。)

    而非脚本语言(编译语言),比如 C、Java 语言。我们需要通过编译(Compile)和链接(link)等步骤,生成可执行文件。然后通过可执行文件在计算机上运行。

    脚本编写

    欢迎学习这节关于脚本编写的课程!你将学习:

    • Python 安装和环境设置
    • 运行和修改 Python 脚本
    • 与用户输入交互
    • 处理异常
    • 读写文件
    • 导入本地、标准和第三方模块
    • 在解释器中进行实验

    安装 Python 3

    我们将使用最新版 Python - Python 3。虽然 Python 2 在很多场合依然会用到,但是已经不再接受更新。为了与后续 Python 改进保持兼容,建议使用 Python 3。

    为了完成这一步骤,你需要使用命令行。我们将详细介绍所有细节部分,因此如果你从未使用过命令行,也没关系!如果你想深入了解命令行,请参阅我们的 Shell 讲习班,详细了解 Unix Shell。

    你的计算机上已经有 Python 吗?

    Mac OS X 和 Linux 通常已经自带了一个版本号比较老的 Python 2,请不要对该 Python 做出任何修改或者删除,因为操作系统的部分组件依赖它,修改或者删除它可能会影响到操作系统的某些功能。但是单独安装 Python 3,也不会对系统有任何影响。

    Windows 通常没有自带 Python,但是你可以在安装之前,先检查下系统是否安装了 Python。首先检查是否已经安装了 Python 3。

    打开终端或命令行。在 Windows 上,进入命令提示符窗口的方式是转到运行…(同时按下带有windows图标的win键+字母r),然后输入 cmd 并按下 Enter 键。

    在新的终端或命令提示符窗口中,输入 python --version 或者 python3 --version

    $ python --version
    

    然后按下 Enter 键。

    注意:这里的$符号在这里只是一个提示,表示命令行的开始,它会自动显示在屏幕上。这不是命令的一部分。

    系统可能会显示已安装的 Python 版本是 Python 2.7.9。在这种情况下,表明你已经安装了 Python 2,你需要按照下面几个部分中的步骤操作,更新到 Python 3。

    如果版本号以 3 开头,则表明你已经安装了 Python 3!请勿再次安装 Python!

    此外,你可能会看到错误消息。暂时不用管该错误,直接尝试下面几个部分中的步骤。

    方法 1:安装 Anaconda

    对于数据分析学员,强烈建议采用这种 Python 安装方式。

    如果你对数据科学方面的 Python 感兴趣,强烈建议安装 Anaconda,即使你已经在计算机上安装了 Python。如果你尚未设置计算机,请参阅我们的 Anaconda 和 Jupyter notebook 简短课程设置计算机。你将学习如何为这门课程设置环境,需要安装 Python 3.6、Jupyter Notebook、NumPy、pandas、Matplotlib 和 Seaborn。

    Anaconda 包含大量专门针对数据科学的库和软件分发版本,某些库和软件比较难安装。同时,你可以很轻松地在计算机上设置不同的环境,以便在不同版本的 Python 和软件包之间快速切换!例如,如果你正在处理的某个项目需要 Python 3.6 以及不同的依赖项,那么 Anaconda 的环境管理功能可以提供帮助。上面给出链接的 Anaconda 和 Jupyter notebook 免费课程讲授了如何处理这类情形。

    如果你的英语不是很熟练,你也可以在中文网站上搜索安装Anaconda的教程,比如这个知乎帖子

    方法 2:安装 Python

    对使用 Python 进行数据分析不感兴趣的学员建议采用此方法。

    如果你对学习面向数据科学的 Python 不感兴趣,并且你的计算机尚未安装 Python 3,那么现在该安装 Python 3 了!请转到 Python 下载页面并找到适用于你的操作系统、以 3 开头的最新版本(例如 Python 3.5.2)。

    对于 Windows 和 Mac,我们发现最简单的方法是直接从 Python 下载网站下载安装程序并运行。如果你使用的是 Linux,Python 下载页面提供了进行下载和编译的源代码。此外,你可以使用 APT 等安装工具安装 Python 3。

    如果你使用的是 Windows 设备,确保在安装过程中选中 Add Python 3.5 to PATH 或 Add Python to environment variables 选项,这样可以确保从命令行提示符窗口中访问 Python。

    如果你使用的是 Windows 设备,并且已经安装了 Python,但是未选中上述选项,则需要将 Python 添加到 PATH。这样的话,当你输入 python 时,可以告诉命令行运行 Python 3。如果你未选中上述选项,或者转到下一阶段时似乎不可行,请按照 Python 文档中的这些说明将 Python 添加到 PATH。

    完成安装程序中的所有步骤操作或编译了源代码后,则安装完毕,你可以在自己的计算机上使用 Python 3 了!

    运行 Python 脚本

    运行 Python 脚本!!

    1. 下载在本页面底部给出链接的文件 first_script.py(你可能需要右击它,并存储为文件),然后将该文件移到计算机上的相应目录下。如果你还没有为这门课程创建一个目录的话,可以乘机创建一个目录。
    2. 打开终端并使用 cd 命令转到包含所下载文件的目录。
    3. 现在你已经位于该文件所在的目录,可以运行该文件了,方法是输入 python first_script.py,然后按下 Enter 键。

    提示:文件下载后,_ 会变成- ,你可能需要改成python first-script.py

    如果你看到终端输出了以下消息,则表明你成功地运行了脚本:

    Congratulations on running this script!!
    

    辅助材料

     first_script.py

    编程环境设置

    配置 Python 编程环境

    你已经看到我的设置,现在花时间在你自己的计算机上熟悉下界面。 下面是一些我们推荐的文本编辑器,你可以尝试一个看看。

    对于 Mac:

    对于 Windows:

    对于 Linux:

    设置好屏幕,打开文本编辑器、终端/命令行,并在网络浏览器中打开优达学城课堂,以便与你的 Python 脚本交互。调整显示器选项,找到你觉得最舒适的显示效果,并看看能否找到 tab-to-four-spaces 选项 - 该选项对于 Python 缩进来说非常有用。

    修改 Python 脚本

    自己编写脚本

    在文本编辑器中打开全新的空文件,命名该文件并将其保存到放置 Python 课程文件的文件夹中。将以下代码放入该文件里。

    how_many_snakes = 1
    snake_string = """
    Welcome to Python3!
    
                 ____
                / . .\\
                \  ---<
                 \  /
       __________/ /
    -=:___________/
    
    <3, Juno
    """
    
    
    print(snake_string * how_many_snakes)

    在脚本中接受原始输入

    我们可以使用内置函数 input 获取用户的原始输入,该函数接受一个可选字符串参数,用于指定在要求用户输入时向用户显示的消息。

    name = input("Enter your name: ")
    print("Hello there, {}!".format(name.title()))
    

    这段代码提示用户输入姓名,然后在问候语中使用该输入。input 函数获取用户输入的任何内容并将其存储为字符串。如果你想将输入解析为字符串之外的其他类型,例如整数(如以下示例所示),需要用新的类型封装结果并从字符串转换为该类型。

    num = int(input("Enter an integer"))
    print("hello" * num)
    

    我们还可以使用内置函数 eval 将用户输入解析为 Python 表达式。该函数会将字符串评估为一行 Python 代码。

    result = eval(input("Enter an expression: "))
    print(result)
    

    如果用户输入 2 * 3,输出为 6

    练习:在脚本中接受原始输入

    练习:生成消息

    假设你是一名老师,需要向每位学生发一条消息,提醒他们未交的作业和分数是多少。你知道每名学生的姓名,没交的作业份数和分数,这些数据保存在了电子表格中,你只需将这些输入插入你想到的以下消息中即可:

    Hi [insert student name],

    This is a reminder that you have [insert number of missing assignments] assignments left to submit before you can graduate. Your current grade is [insert current grade] and can increase to [insert potential grade] if you submit all assignments before the due date.

    你可以将此消息复制粘贴后发送给每位学生,并且每次手动插入相应的值。但是你要写一个程序来帮助你完成这一流程。

    写一个完成以下操作的脚本:

    1. 请求用户输入三次。一次是名字列表,一次是未交作业数量列表,一次是分数列表。使用该输入创建 namesassignments 和 grades 列表。
    2. 使用循环为每个学生输出一条信息并包含正确的值。潜在分数是 2 乘以未交作业数加上当前分数。

    下面是在终端内成功运行该脚本的示例。

    错误和异常

    • 当 Python 无法解析代码时,就会发生语法错误,因为我们没有遵守正确的 Python 语法。当你出现拼写错误或第一次开始学习 Python 时,可能会遇到这些错误。

    • 当在程序执行期间出现意外情况时,就会发生异常,即使代码在语法上正确无误。Python 有不同类型的内置异常,你可以在错误消息中查看系统抛出了什么异常。

    Try 语句

    我们可以使用 try 语句处理异常。你可以使用 4 个子句(除了视频中显示的子句之外还有一个子句)。

    • try:这是 try 语句中的唯一必需子句。该块中的代码是 Python 在 try 语句中首先运行的代码。
    • except:如果 Python 在运行 try 块时遇到异常,它将跳到处理该异常的 except 块。
    • else:如果 Python 在运行 try 块时没有遇到异常,它将在运行 try 块后运行该块中的代码。
    • finally:在 Python 离开此 try 语句之前,在任何情形下它都将运行此 finally 块中的代码,即使要结束程序,例如:如果 Python 在运行 except 或 else 块中的代码时遇到错误,在停止程序之前,依然会执行此finally 块。

    为何在 Python 中需要 finally 子句?

    指定异常

    我们实际上可以指定要在 except 块中处理哪个错误,如下所示:

    try:
        # some code
    except ValueError:
        # some code
    

    现在它会捕获 ValueError 异常,但是不会捕获其他异常。如果我们希望该处理程序处理多种异常,我们可以在 except 后面添加异常元组。

    try:
        # some code
    except (ValueError, KeyboardInterrupt):
        # some code
    

    或者,如果我们希望根据异常执行不同的代码块,可以添加多个 except 块。

    try:
        # some code
    except ValueError:
        # some code
    except KeyboardInterrupt:
        # some code

    练习解决方案:处理除以零的情形

    def create_groups(items, num_groups):
        try:
            size = len(items) // num_groups
        except ZeroDivisionError:
            print("WARNING: Returning empty list. Please use a nonzero number.")
            return []
        else:
            groups = []
            for i in range(0, len(items), size):
                groups.append(items[i:i + size])
            return groups
        finally:
            print("{} groups returned.".format(num_groups))
    
    print("Creating 6 groups...")
    for group in create_groups(range(32), 6):
        print(list(group))
    
    print("\nCreating 0 groups...")
    for group in create_groups(range(32), 0):
        print(list(group))

    修改上面的脚本以处理除以零错误。正确修改的话,应该会输出:

    Creating 6 groups...
    6 groups returned.
    [0, 1, 2, 3, 4]
    [5, 6, 7, 8, 9]
    [10, 11, 12, 13, 14]
    [15, 16, 17, 18, 19]
    [20, 21, 22, 23, 24]
    [25, 26, 27, 28, 29]
    [30, 31]
    
    Creating 0 groups...
    WARNING: Returning empty list. Please use a nonzero number.
    0 groups returned.

    访问错误消息

    在处理异常时,依然可以如下所示地访问其错误消息:

    try:
        # some code
    except ZeroDivisionError as e:
       # some code
       print("ZeroDivisionError occurred: {}".format(e))
    

    应该会输出如下所示的结果:

    ZeroDivisionError occurred: division by zero
    

    因此依然可以访问错误消息,即使已经处理异常以防止程序崩溃!

    如果没有要处理的具体错误,依然可以如下所示地访问消息:

    try:
        # some code
    except Exception as e:
       # some code
       print("Exception occurred: {}".format(e))
    

    Exception 是所有内置异常的基础类。你可以在此处详细了解 Python 的异常。

    读写文件

    以下是如何在 Python 中读写文件的方式。

    读取文件

    f = open('my_path/my_file.txt', 'r')
    file_data = f.read()
    f.close()
    
    1. 首先使用内置函数 open 打开文件。需要文件路径字符串。open 函数会返回文件对象,它是一个 Python 对象,Python 通过该对象与文件本身交互。在此示例中,我们将此对象赋值给变量 f
    2. 你可以在 open 函数中指定可选参数。参数之一是打开文件时采用的模式。在此示例中,我们使用 r,即只读模式。这实际上是模式参数的默认值。
    3. 使用 read 访问文件对象的内容。该 read 方法会接受文件中包含的文本并放入字符串中。在此示例中,我们将该方法返回的字符串赋值给变量 file_data
    4. 当我们处理完文件后,使用 close 方法释放该文件占用的系统资源。

    写入文件

    f = open('my_path/my_file.txt', 'w')
    f.write("Hello there!")
    f.close()
    1. 以写入 ('w') 模式打开文件。如果文件不存在,Python 将为你创建一个文件。如果以写入模式打开现有文件,该文件中之前包含的所有内容将被删除。如果你打算向现有文件添加内容,但是不删除其中的内容,可以使用附加 ('a') 模式,而不是写入模式。
    2. 使用 write 方法向文件中添加文本。
    3. 操作完毕后,关闭文件。

    With

    Python 提供了一个特殊的语法,该语法会在你使用完文件后自动关闭该文件。

    with open('my_path/my_file.txt', 'r') as f:
        file_data = f.read()
    

    该 with 关键字使你能够打开文件,对文件执行操作,并在缩进代码(在此示例中是读取文件)执行之后自动关闭文件。现在,我们不需要调用 f.close() 了!你只能在此缩进块中访问文件对象 f。

    导入本地脚本

    我们实际上可以导入其他脚本中的 Python,如果你处理的是大型项目,需要将代码整理成多个文件并重复利用这些文件中的代码,则导入脚本很有用。如果你要导入的 Python 脚本与当前脚本位于同一个目录下,只需输入 import,然后是文件名,无需扩展名 .py。

    import useful_functions
    

    Import 语句写在 Python 脚本的顶部,每个导入语句各占一行。该 import 语句会创建一个模块对象,叫做 useful_functions。模块是包含定义和语句的 Python 文件。要访问导入模块中的对象,需要使用点记法。

    import useful_functions
    useful_functions.add_five([1, 2, 3, 4])
    

    我们可以为导入模块添加别名,以使用不同的名称引用它。

    import useful_functions as uf
    uf.add_five([1, 2, 3, 4])
    

    使用 if main 块

    为了避免运行从其他脚本中作为模块导入的脚本中的可执行语句,将这些行包含在 if __name__ == "__main__" 块中。或者,将它们包含在函数 main() 中并在 if main 块中调用该函数。

    每当我们运行此类脚本时,Python 实际上会为所有模块设置一个特殊的内置变量 __name__。当我们运行脚本时,Python 会将此模块识别为主程序,并将此模块的 __name__ 变量设为字符串 "__main__"。对于该脚本中导入的任何模块,这个内置 __name__ 变量会设为该模块的名称。因此,条件 if __name__ == "__main__"会检查该模块是否为主程序。 

    尝试一下!

    下面是我在上述视频中使用的代码。请在同一目录下创建这些脚本,并在终端里运行这些脚本!实验 if main 块并访问导入模块中的对象!

    # demo.py
    
    import useful_functions as uf
    
    scores = [88, 92, 79, 93, 85]
    
    mean = uf.mean(scores)
    curved = uf.add_five(scores)
    
    mean_c = uf.mean(curved)
    
    print("Scores:", scores)
    print("Original Mean:", mean, " New Mean:", mean_c)
    
    print(__name__)
    print(uf.__name__)
    
    # useful_functions.py
    
    def mean(num_list):
        return sum(num_list) / len(num_list)
    
    def add_five(num_list):
        return [n + 5 for n in num_list]
    
    def main():
        print("Testing mean function")
        n_list = [34, 44, 23, 46, 12, 24]
        correct_mean = 30.5
        assert(mean(n_list) == correct_mean)
    
        print("Testing add_five function")
        correct_list = [39, 49, 28, 51, 17, 29]
        assert(add_five(n_list) == correct_list)
    
        print("All tests passed!")
    
    if __name__ == '__main__':
        main()

    标准库

    你可以在 Python 一周模块博客中发现新的模块。

    我们的推荐模块

    Python 标准库包含大量模块!为了帮助你熟悉那些实用的模块,我们在下面筛选了一些我们推荐的 Python 标准库模块并解释为何我们喜欢使用它们! 

    • csv:对于读取 csv 文件来说非常便利 
    • collections:常见数据类型的实用扩展,包括 OrderedDictdefaultdict 和 namedtuple
    • random:生成假随机数字,随机打乱序列并选择随机项 
    • string:关于字符串的更多函数。此模块还包括实用的字母集合,例如 string.digits(包含所有字符都是有效数字的字符串)。 
    • re:通过正则表达式在字符串中进行模式匹配 
    • math:一些标准数学函数 
    • os:与操作系统交互 
    • os.pathos 的子模块,用于操纵路径名称 
    • sys:直接使用 Python 解释器 
    • json:适用于读写 json 文件(面向网络开发)

    希望你能用上这些模块!

    导入模块技巧

    还有一些在不同情形下很有用的其他形式的 import 语句。

    1. 要从模块中导入单个函数或类:
      from module_name import object_name
      
    2. 要从模块中导入多个单个对象:
      from module_name import first_object, second_object
      
    3. 要重命名模块:
      import module_name as new_name
      
    4. 要从模块中导入对象并重命名:
      from module_name import object_name as new_name
      
    5. 要从模块中单个地导入所有对象(请勿这么做):
      from module_name import *
      
    6. 如果你真的想使用模块中的所有对象,请使用标准导入 module_name 语句并使用点记法访问每个对象。
      import module_name

    模块、软件包和名称

    为了更好地管理代码,Standard 标准库中的模块被拆分成了子模块并包含在软件包中。软件包是一个包含子模块的模块。子模块使用普通的点记法指定。

    子模块的指定方式是软件包名称、点,然后是子模块名称。你可以如下所示地导入子模块。

    import package_name.submodule_name

    第三方库

    独立开发者编写了成千上万的第三方库!你可以使用 pip 安装这些库。pip 是在 Python 3 中包含的软件包管理器,它是标准 Python 软件包管理器,但并不是唯一的管理器。另一个热门的管理器是 Anaconda,该管理器专门针对数据科学。

    要使用 pip 安装软件包,在命令行中输入“pip install”,然后是软件包名称,如下所示:pip install package_name。该命令会下载并安装该软件包,以便导入你的程序中。安装完毕后,你可以使用从标准库中导入模块时用到的相同语法导入第三方软件包。

    使用 requirements.txt 文件

    大型 Python 程序可能依赖于十几个第三方软件包。为了更轻松地分享这些程序,程序员经常会在叫做 requirements.txt 的文件中列出项目的依赖项。下面是一个 requirements.txt 文件示例。

    beautifulsoup4==4.5.1
    bs4==0.0.1
    pytz==2016.7
    requests==2.11.1
    

    该文件的每行包含软件包名称和版本号。版本号是可选项,但是通常都会包含。不同版本的库之间可能变化不大,可能截然不同,因此有必要使用程序作者在写程序时用到的库版本。

    你可以使用 pip 一次性安装项目的所有依赖项,方法是在命令行中输入 pip install -r requirements.txt

    实用的第三方软件包

    能够安装并导入第三方库很有用,但是要成为优秀的程序员,还需要知道有哪些库可以使用。大家通常通过在线推荐或同事介绍了解实用的新库。如果你是一名 Python 编程新手,可能没有很多同事,因此为了帮助你了解入门信息,下面是优达学城工程师很喜欢使用的软件包列表。(可能部分网站在国内网络中无法打开)

    • IPython - 更好的交互式 Python 解释器 
    • requests - 提供易于使用的方法来发出网络请求。适用于访问网络 API。 
    • Flask - 一个小型框架,用于构建网络应用和 API。
    • Django - 一个功能更丰富的网络应用构建框架。Django 尤其适合设计复杂、内容丰富的网络应用。 
    • Beautiful Soup - 用于解析 HTML 并从中提取信息。适合网页数据抽取。 
    • pytest - 扩展了 Python 的内置断言,并且是最具单元性的模块。 
    • PyYAML - 用于读写 YAML 文件。 
    • NumPy - 用于使用 Python 进行科学计算的最基本软件包。它包含一个强大的 N 维数组对象和实用的线性代数功能等。 
    • pandas - 包含高性能、数据结构和数据分析工具的库。尤其是,pandas 提供 dataframe! 
    • matplotlib - 二维绘制库,会生成达到发布标准的高品质图片,并且采用各种硬拷贝格式和交互式环境。 
    • ggplot - 另一种二维绘制库,基于 R's ggplot2 库。
    • Pillow - Python 图片库可以向你的 Python 解释器添加图片处理功能。 
    • pyglet - 专门面向游戏开发的跨平台应用框架。 
    • Pygame - 用于编写游戏的一系列 Python 模块。 
    • pytz - Python 的世界时区定义。

    在解释器中进行实验

    通过在终端里输入 python 启动 python 交互式解释器。你可以接着输入内容,直接与 Python 交互。这是每次实验和尝试一段 Python 代码的很棒工具。只需输入 Python 代码,输出将出现在下一行。

    >>> type(5.23)
    <class 'float'>
    

    在解释器中,提示符窗口中最后一行的值将自动输出。如果有多行代码需要输出值,依然需要使用 print。

    如果你开始定义函数,你将在提示符窗口中看到变化,表示这是可以继续的行。在定义函数时,你需要自己添加缩进。

    >>> def cylinder_volume(height, radius):
    ...         pi = 3.14159
    ...         return height * pi * radius ** 2
    

    解释器的不足之处是修改代码比较麻烦。如果你在输入该函数时出现了拼写错误,或者忘记缩进函数的主体部分,无法使用鼠标将光标点到要点击的位置。需要使用箭头键在代码行中来回移动。有必要了解一些实用的快捷方式,例如移到一行的开头或结尾。

    注意,我可以引用我在解释器中之前定义的任何对象!

    >>> cylinder_volume(10, 3)
    282.7431
    

    一个实用技巧是在交互式提示符窗口中使用上下箭头键循环浏览最近的命令。这样可以重新运行或修改已经尝试的代码。

    要退出 Python 交互式解释器,使用命令 exit() 或在 mac/linux 上按下 ctrl+D,在 windows 上按下 ctrl+Z,然后按下 Enter 键。

    IPython

    实际上有一个代替默认 python 交互式解释器的强大解释器 IPython,它具有很多其他功能。

    • Tab 键补充完整
    • ?:关于对象的详细信息
    • !:执行系统 shell 命令
    • 语法突出显示

    你可以在此处查看更多其他功能!

    获取所需的信息

    要想成为熟练的程序员,需要掌握大量知识。需要了解库、记住语法以及其他细节。此外,让这一切更具挑战的是,技术在不断革新,因为新的技巧和工具会不断出现。

    对于编程新手来说,学习所有这些细节并及时获悉新的发展动态似乎是一项不可能完成的任务。的确是这样!具有多年经验的编程专业人士实际上并不是在脑中记下百科全书一样的知识,而是掌握了快速查找信息的技巧。

    如何搜索

    下面是高效网络搜索的一些技巧:

    • 在查询时,尝试使用 Python 或要使用的库的名称作为第一个字词。这样会告诉搜索引擎优先显示与你要使用的工具明确相关的结果。
    • 创建良好的搜索查询需要多次尝试。如果第一次尝试时没有找到有用的结果,再试一遍。 
    • 尝试使用在一开始搜索时发现的网页上发现的关键字,使搜索引擎在后续搜索中转到更好的资源。
    • 复制粘贴错误消息作为搜索字词。这样会出现错误解释性信息和潜在原因。错误消息可能包括你所写的特定行号引用。只在搜索中包含这些信息之前的错误消息部分。
    • 如果找不到问题答案,自己提出问题!StackOverflow 等社区有一些行为规则,如果你要加入该社区,必须了解这些规则,但是别因为这些规则而不愿意使用这些资源。

    在线资源的优先级

    虽然有很多关于编程的在线资源,但是并非所有资源都是同等水平的。下面的资源列表按照大致的可靠性顺序排序。

    1. Python 教程 - 这部分官方文档给出了 Python 的语法和标准库。它会举例讲解,并且采用的语言比主要文档的要浅显易懂。确保阅读该文档的 Python 3 版本!
    2. Python 语言和库参考资料 - 语言参考资料和库参考资料比教程更具技术性,但肯定是可靠的信息来源。当你越来越熟悉 Python 时,应该更频繁地使用这些资源。
    3. 第三方库文档 - 第三方库会在自己的网站上发布文档,通常发布于 https://readthedocs.org/ 。你可以根据文档质量判断第三方库的质量。如果开发者没有时间编写好的文档,很可能也没时间完善库。
    4. 非常专业的网站和博客 - 前面的资源都是主要资源,他们是编写相应代码的同一作者编写的文档。主要资源是最可靠的资源。次要资源也是非常宝贵的资源。次要资源比较麻烦的是需要判断资源的可信度。Doug Hellmann 等作者和 Eli Bendersky 等开发者的网站很棒。不出名作者的博客可能很棒,也可能很糟糕。
    5. StackOverflow - 这个问答网站有很多用户访问,因此很有可能有人之前提过相关的问题,并且有人回答了!但是,答案是大家自愿提供的,质量参差不齐。在将解决方案应用到你的程序中之前,始终先理解解决方案。如果答案只有一行,没有解释,则值得怀疑。你可以在此网站上查找关于你的问题的更多信息,或发现替代性搜索字词。
    6. Bug 跟踪器 - 有时候,你可能会遇到非常罕见的问题或者非常新的问题,没有人在 StackOverflow 上提过。例如,你可能会在 GitHub 上的 bug 报告中找到关于你的错误的信息。这些 bug 报告很有用,但是你可能需要自己开展一些工程方面的研究,才能解决问题。
    7. 随机网络论坛 - 有时候,搜索结果可能会生成一些自 2004 年左右就不再活跃的论坛。如果这些资源是唯一解决你的问题的资源,那么你应该重新思考下寻找解决方案的方式。
    展开全文
  • python脚本基础总结

    千次阅读 2018-07-08 08:42:30
    注释 ①单行注释:#单行注释 ②多行注释: ''' 三个单引号,多行注释符 ''' ③中文注释:#coding=utf-8 或者 #coding=gbk2.输入输出 ① 输入: 3.0后的python输出为print函数,print()...

    本文转载自博客园,原文地址:点击打开链接


    1. 注释


        ①单行注释:#单行注释

        ②多行注释: '''

                             三个单引号,多行注释符

                          '''

        ③中文注释:#coding=utf-8 或者 #coding=gbk

    2.输入输出

         ① 输入:  3.0后的python输出为print函数,print(); 如  print('python');  #输出python

                    多个字段时可中间逗号隔开, 如  print('hello','python','user');  #输出 hello python user   默认中间有一个空格。

         ②输出:input函数,如:name=input();  

    3.数据类型
       ①整数:Python可以处理任意大小的整数,当然包括负整数,在程序中的表示方法和数学上的写法一模一样,例如:1,100,-8080,0,等等。
       ②浮点数:浮点数也就是小数,之所以称为浮点数,是因为按照科学记数法表示时,一个浮点数的小数点位置是可变的,比如,1.23x109和12.3x108是完全相等的。
       ③字符串:字符串是以单引号'或双引号"括起来的任意文本,比如'abc',"xyz"等等。
               转义字符\可以转义很多字符,比如\n表示换行,\t表示制表符,字符\本身也要转义,所以\\表示的字符就是\。

           >>> print('I\'m learning\nPython.')
              I'm learning
             Python.

               如果字符串里面有很多字符都需要转义,就需要加很多\,为了简化,Python还允许用r''表示''内部的字符串默认不转义。如:

            >>> print(r'\\\t\\')
               \\\t\\

               如果字符串内部有很多换行,用\n写在一行里不好阅读,为了简化,Python允许用'''...'''的格式表示多行内容,可以自己试试:

           >>> print('''line1
                ... line2
                ... line3''')
              line1
              line2
              line3

         ④布尔值 :布尔值和布尔代数的表示完全一致,一个布尔值只有True、False两种值,要么是True,要么是False,在Python中,可以直接用True、False表示布尔值(请注意大小写)。

           and运算是与运算,只有所有都为True,and运算结果才是True

               or运算是或运算,只要其中有一个为True,or运算结果就是True
               not运算是非运算,它是一个单目运算符,把True变成False,False变成True

         ⑤空值:空值是Python里一个特殊的值,用None表示。None不能理解为0,因为0是有意义的,而None是一个特殊的空值

    4.变量和常量

     ① 变量在程序中就是用一个变量名表示了,变量名必须是大小写英文、数字和_的组合,且不能用数字开头等号。 如:a = 1 ;  t_007 = 'T007';  Answer = True

     ②  =  是赋值语句,可以把任意数据类型赋值给变量,同一个变量可以反复赋值,而且可以是不同类型的变量。如:a = 123 # a是整数

        ③常量:在Python中,通常用全部大写的变量名表示常量:PI = 3.14159265359

    5.编码

        ①对于单个字符的编码,Python提供了ord()函数获取字符的整数表示,chr()函数把编码转换为对应的字符:

       >>> ord('A')
         65
       >>> ord('中')
         20013
       >>> chr(66)
         'B'
       >>> chr(25991)
         '文'

       ②Python对bytes类型的数据用带b前缀的单引号或双引号表示:

         x = b'ABC'

         要注意区分'ABC'和b'ABC',前者是str,后者虽然内容显示得和前者一样,但bytes的每个字符都只占用一个字节。

         以Unicode表示的str通过encode()方法可以编码为指定的bytes,例如:

       >>> 'ABC'.encode('ascii')
       b'ABC'
       >>> '中文'.encode('utf-8')
       b'\xe4\xb8\xad\xe6\x96\x87'

       ③ 在bytes中,无法显示为ASCII字符的字节,用\x##显示。反过来,如果我们从网络或磁盘上读取了字节流,那么读到的数据就是bytes。要把bytes变为str,就需要用decode()方法:

      >>> b'ABC'.decode('ascii')
       'ABC'
    要计算str包含多少个字符,可以用len()函数;len()函数计算的是str的字符数,如果换成bytes,len()函数就计算字节数:

    >>> len('ABC')
    3

        ④由于Python源代码也是一个文本文件,所以,当你的源代码中包含中文的时候,在保存源代码时,就需要务必指定保存为UTF-8编码。当Python解释器读取源代码时,为了让它按UTF-8编码读取,我们通常在文件开头写上这两行:

         #!/usr/bin/env python3
         # -*- coding: utf-8 -*-

            第一行注释是为了告诉Linux/OS X系统,这是一个Python可执行程序,Windows系统会忽略这个注释;

            第二行注释是为了告诉Python解释器,按照UTF-8编码读取源代码,否则,你在源代码中写的中文输出可能会有乱码。

            申明了UTF-8编码并不意味着你的.py文件就是UTF-8编码的,必须并且要确保文本编辑器正在使用UTF-8 without BOM编码

    >>> len(b'ABC')
    3

    可见,1个中文字符经过UTF-8编码后通常会占用3个字节,而1个英文字符只占用1个字节。

    6 格式化

        %运算符就是用来格式化字符串的。在字符串内部,%s表示用字符串替换,%d表示用整数替换,有几个%?占位符,后面就跟几个变量或者值,顺序要对应好。如果只有一个%?,括号可以省略。

        >>> 'Hi, %s, you have $%d.' % ('Michael', 1000000)
        'Hi, Michael, you have $1000000.'

            常见的占位符有:
    %d     整数
    %f     浮点数
    %s     字符串
    %x     十六进制整数

          其中,格式化整数和浮点数还可以指定是否补0和整数与小数的位数:

        >>> '%2d-%02d' % (3, 1)
        ' 3-01'
        >>> '%.2f' % 3.1415926
        '3.14'

          如果你不太确定应该用什么,%s永远起作用,它会把任何数据类型转换为字符串:

       >>> 'Age: %s. Gender: %s' % (25, True)
       'Age: 25. Gender: True'

          有些时候,字符串里面的%是一个普通字符怎么办?这个时候就需要转义,用%%来表示一个%:

        >>> 'growth rate: %d %%' % 7
        'growth rate: 7 %'

    7. list和tuple
        list和tuple是Python内置的有序集合,一个可变,一个不可变。
    一、list

    >>> classmates = ['Michael', 'Bob', 'Tracy']

    list是一种有序的集合,可以随时添加和删除其中的元素。用索引来访问list中每一个位置的元素,记得索引是从0开始的

          倒叙取值:  用-1做索引,直接获取最后一个元素  如:>>> classmates[-1]   >>> classmates[-2]

           要把某个元素替换成别的元素,可以直接赋值给对应的索引位置:>>> classmates[1] = 'Sarah'
           list里面的元素的数据类型也可以不同:>>> L = ['Apple', 123, True]
           list元素也可以是另一个list:>>> s = ['python', 'java', ['asp', 'php'], 'scheme']  取值:print(s[2][0])  #'asp'
           如果一个list中一个元素也没有,就是一个空的list,它的长度为0
      常用方法:
        len()函数: 可以获得list元素的个数;最后一个元素的索引是len(classmates) - 1
           append(): 往list中追加元素到末尾。 >>> classmates.append('Adam')

    insert():元素插入到指定的位置,比如索引号为1的位置:>>> classmates.insert(1, 'Jack')

    pop():删除list末尾的元素;要删除指定位置的元素,用pop(i)方法,其中i是索引位置:>>> classmates.pop(1)

    二、tuple

    >>> classmates = ('Michael', 'Bob', 'Tracy')

       tuple一旦初始化就不能修改
      它也没有append(),insert()这样的方法。其他获取元素的方法和list是一样的,你可以正常地使用classmates[0],classmates[-1],但不能赋值成另外的元素
      因为tuple不可变,所以代码更安全。如果可能,能用tuple代替list就尽量用tuple。

     只有1个元素的tuple定义时必须加一个逗号,

    >>> t = (1,)
    >>> t
    (1,)

     最后来看一个“可变的”tuple:这个tuple定义的时候有3个元素,分别是'a','b'和一个list。

    >>> t = ('a', 'b', ['A', 'B'])
    >>> t[2][0] = 'X'
    >>> t[2][1] = 'Y'
    >>> t
    ('a', 'b', ['X', 'Y'])

    8.判读语句

    if语句执行有个特点,它是从上往下判断,如果在某个判断上是True,把该判断对应的语句执行后,就忽略掉剩下的elif和else,所以,请测试并解释为什么下面的程序打印的是teenager:

    age = 20
    if age >= 6:
        print('teenager')
    elif age >= 18:
        print('adult')
    else:
        print('kid')

    if判断条件还可以简写,比如写:

    if x:
        print('True')

    只要x是非零数值、非空字符串、非空list等,就判断为True,否则为False。

    s = input('birth: ')
    birth = int(s)
    if birth < 2000:
        print('00前')
    else:
        print('00后')

    9.循环

    Python的循环有两种,一种是for...in循环,依次把list或tuple中的每个元素迭代出来,看例子:

    names = ['Michael', 'Bob', 'Tracy']
    for name in names:
        print(name)

    如果要计算1-100的整数之和,从1写到100有点困难,幸好Python提供一个range()函数,可以生成一个整数序列,再通过list()函数可以转换为list。比如range(5)生成的序列是从0开始小于5的整数:

    >>> list(range(5))
    [0, 1, 2, 3, 4])

    第二种循环是while循环,只要条件满足,就不断循环,条件不满足时退出循环。比如我们要计算100以内所有奇数之和,可以用while循环实现:

    sum = 0
    n = 99
    while n > 0:
        sum = sum + n
        n = n - 2
    print(sum)

    在循环内部变量n不断自减,直到变为-1时,不再满足while条件,循环退出。

    break:

    在循环中,break语句可以提前退出循环

    n = 1
    while n <= 100:
        if n > 10: # 当n = 11时,条件满足,执行break语句
            break # break语句会结束当前循环
        print(n)
        n = n + 1
    print('END')

    continue

    在循环过程中,也可以通过continue语句,跳过当前的这次循环,直接开始下一次循环。

    n = 0
    while n < 10:
        n = n + 1
        if n % 2 == 0: # 如果n是偶数,执行continue语句
            continue # continue语句会直接继续下一轮循环,后续的print()语句不会执行
        print(n)

    10.dict和set

    一.数据字典:dict

    ①使用键-值(key-value)存储,具有极快的查找速度。由于一个key只能对应一个value,所以,多次对一个key放入value,后面的值会把前面的值冲掉。例如:

    >>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
    >>> d['Michael']
    95

       ②添加:把数据放入dict的方法,除了初始化时指定外,还可以通过key放入:

          >>> d['Adam'] = 67

           要避免key不存在的错误,有两种办法,一是通过in判断key是否存在:

            >>> 'Thomas' in d
           False

          二是通过dict提供的get方法,如果key不存在,可以返回None,或者自己指定的value:

           >>> d.get('Thomas')

          >>> d.get('Thomas', -1)
            -1

              注意:返回None的时候Python的交互式命令行不显示结果。

       ③删除: 要删除一个key,用pop(key)方法,对应的value也会从dict中删除:

           >>> d.pop('Bob')
             75
          >>> d
        {'Michael': 95, 'Tracy': 85}

     请务必注意,dict内部存放的顺序和key放入的顺序是没有关系的。


    二.set
    set和dict类似,也是一组key的集合,但不存储value。由于key不能重复,所以,在set中,没有重复的key。

    >>> s = set([1, 2, 3])
    >>> s
    {1, 2, 3}
    add(key)方法可以添加元素到set中

    >>> s.add(4)
    >>> s
    {1, 2, 3, 4}

      remove(key)方法可以删除元素:

    >>> s.remove(4)

      set可以看成数学意义上的无序和无重复元素的集合,因此,两个set可以做数学意义上的交集、并集等操作:

    >>> s1 = set([1, 2, 3])
    >>> s2 = set([2, 3, 4])
    >>> s1 & s2
    {2, 3}
    >>> s1 | s2
    {1, 2, 3, 4}

    11.函数

        要调用一个函数,需要知道函数的名称和参数,比如求绝对值的函数abs,只有一个参数。可以直接从Python的官方网站查看文档:

         http://docs.python.org/3/library/functions.html#abs

        也可以在交互式命令行通过help(abs)查看abs函数的帮助信息。

        调用abs函数:

      >>> abs(-20)
      20
     调用Python的函数,需要根据函数定义,传入正确的参数。如果函数调用出错,一定要学会看错误信息

       数据类型转换

       Python内置的常用函数还包括数据类型转换函数,比如int()函数可以把其他数据类型转换为整数:

    >>> int('123')
    123
    >>> int(12.34)
    12
    >>> float('12.34')
    12.34
    >>> str(1.23)
    '1.23'
    >>> str(100)
    '100'
    >>> bool(1)
    True
    >>> bool('')
    False

    一.定义函数

    在Python中,定义一个函数要使用def语句,依次写出函数名、括号、括号中的参数和冒号:,然后,在缩进块中编写函数体,函数的返回值用return语句返回。

       定义函数时,需要确定函数名和参数个数;

       如果有必要,可以先对参数的数据类型做检查;

       函数体内部可以用return随时返回函数结果;

       函数执行完毕也没有return语句时,自动return None。

       函数可以同时返回多个值,但其实就是一个tuple。


    如:请定义一个函数quadratic(a, b, c),接收3个参数,返回一元二次方程:ax2 + bx + c = 0的两个解。  

       空函数

       如果想定义一个什么事也不做的空函数,可以用pass语句:

    def nop():
        pass

    二.参数设置

       ①默认参数

         

         power(5)调用时,第二个参数默认为2;power(5,3),第二个参数传递,n=3.

        注意:

        一是必选参数在前,默认参数在后,否则Python的解释器会报错(思考一下为什么默认参数不能放在必选参数前面);

       二是如何设置默认参数。当函数有多个参数时,把变化大的参数放前面,变化小的参数放后面。变化小的参数就可以作为默认参数。

        Python函数在定义的时候,默认参数L的值就被计算出来了,即[],因为默认参数L也是一个变量,它指向对象[],每次调用该函数,如果改变了L的内容,则下次调用时,默认参     数的内容就变了,不再是函数定义时的[]了。

        所以,定义默认参数要牢记一点:默认参数必须指向不变对象!

    def add_end(L=None):
        if L is None:
            L = []
        L.append('END')
        return L

     ②可变参数

     可变参数就是传入的参数个数是可变的.
      把函数的参数改为可变参数:仅仅在参数前面加了一个*号。
         

       如果已经有一个list或者tuple,要调用一个可变参数,在list或tuple前面加一个*号,把list或tuple的元素变成可变参数传进去。

         

        *nums表示把nums这个list的所有元素作为可变参数传进去。

      ③关键字参数

        可变参数允许你传入0个或任意个参数,这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数,这些关键字参数在函数内部自动组装为一个dict。

          

          
     比如,在person函数里,我们保证能接收到name和age这两个参数,但是,如果调用者愿意提供更多的参数,我们也能收到。
    展开全文
  • python的基本语法和脚本格式

    万次阅读 多人点赞 2018-06-01 15:26:37
    我们在上一篇文章中已经学会了如何简单的运行python命令和脚本,但是,距离真正的写脚本还有一段距离。 python的使用和运行 为了防止我们写出来的脚本运行时报各种语法格式错误,我们需要在本章先学习下python的...

    我们在上一篇文章中已经学会了如何简单的运行python命令和脚本,但是,距离真正的写脚本还有一段距离。
    python的使用和运行

    为了防止我们写出来的脚本运行时报各种语法格式错误,我们需要在本章先学习下python的基本语法和脚本格式。

    脚本声明

    由于Python源代码也是一个文本文件,所以,当你的源代码中包含中文的时候,在保存源代码时,就需要务必指定保存为UTF-8编码。当Python解释器读取源代码时,为了让它按UTF-8编码读取,我们通常在文件开头写上这两行:

    # !/usr/bin/env python
    # -*- coding:utf-8 -*-  
    或者
    #coding:utf-8

    第一行注释是为了告诉Linux/OS X系统,这是一个Python可执行程序,根据usr/bin/env路径去找python的运行程序来运行,Windows系统会忽略这个注释;

    第二行注释是为了告诉Python解释器,按照UTF-8编码读取源代码,否则,你在源代码中写的中文输出可能会有乱码。

    如果你使用Notepad++进行编辑,除了要加上# -- coding: utf-8 --外,中文字符串必须是Unicode字符串。

    模块(类库)的引入

    引入语句一般放在声明语句后面。

    Python在语义中存在着包、模块、类(当然还有函数)这几个概念。

    在编写Python代码时,我们需要管理代码的文件目录结构。

    这时候会遇到这样一种情况:
    1.由于Python一个文件算一个模块,一个带init.py的目录算一个包。
    2.而为了控制代码文件不要过大,我们需要的是一个类(几个类或加些许函数)分配一个文件。

    Python拥有一个强大的标准库。
    Python语言的核心只包含数字、字符串、列表、字典、文件等常见类型和函数,而由Python标准库提供了系统管理、网络通信、文本处理、数据库接口、图形系统、XML处理等额外的功能。Python标准库命名接口清晰、文档良好,很容易学习和使用。
    如引用,需import,如引入算数模块,系统模块
    引入mysql数据库驱动

    import math,os,sys
    import MySQLdb

    Python社区提供了大量的第三方模块,使用方式与标准库类似。它们的功能无所不包,覆盖科学计算、Web开发、数据库接口、图形系统多个领域,并且大多成熟而稳定。第三方模块可以使用Python或者C语言编写。SWIG,SIP常用于将C语言编写的程序库转化为Python模块。Boost C++ Libraries包含了一组库,Boost.Python,使得以 Python 或 C++ 编写的程序能互相调用。借助于拥有基于标准库的大量工具、能够使用低级语言如C和可以作为其他库接口的C++,Python已成为一种强大的应用于其他语言与工具之间的胶水语言。

    引用自己写的模块则需要注意路径问题,现在有相对引用和绝对引用的说法,更多详情可查看。
    Python相对导入与绝对导入

    一般来说自己需要引用所有的py文件放到调用它们的py文件同一目录下使用import即可。

    例如我们有main.py文件和hapdbtools.py文件,放在同一目录如下:

    hapdbtools.py文件声明了一个类DBtool内容如下:

    #coding:utf-8
    __author__ = 'zzq'
    import MySQLdb
    import sys
    class DBtool():
        def __init__(self):
    
            '''
            获取数据库连接 __enter__函数配合with 使用 自动调用 enter 和 exit
            :return:
            '''
            try:
                self.__db = MySQLdb.connect(host='192.168.1.80', port=3306, db='test', user='zzq',
                                            passwd='123456', charset='utf8')
                self.__cursor = self.__db.cursor()
    
            except MySQLdb.Error, e:
                self.error_code = e.args[0]
                error_msg = 'MySQL error! ', e.args[0], e.args[1]
                print error_msg
    
        def __enter__(self):
            '''
            获取数据库连接 __enter__函数配合with 使用 自动调用 enter 和 exit
            :return:
            '''
            self.__db = MySQLdb.connect(host='192.168.1.80', port=3306, db='test', user='zzq',
                                            passwd='123456', charset='utf8')
            self.__cursor = self.__db.cursor()
            return self
    
        def __exit__(self, type, value, traceback):
            self.__db.close()
    
    
    
        def query_data_by_barcode(self,barcode):
            SQL_select_data="select data from mytable where barcode=%s" 
            self.__cursor.execute(SQL_select_data,barcode)
            result=self.__cursor.fetchall()
            #result=self.__cursor.fetchone()
            if result:
                return result
            else:
                return "none"

    则main文件中引用时使用语句:

    from hapdbtools import DBtool

    调用方法时使用语句:

    dbtools = DBtool()
    result = dbtools.query_data_by_barcode(barcode)
    print(result)

    查看哪些脚本调用了hapdbtools脚本使用命令

    grep hapdbtools *

    注释

    # 注释以 # 字符起始,直至实际的行尾;代码中注释不会被Python解释;文本字符串中的#仅表示#
    # this is the first comment
    SPAM = 1                              # and this is the second comment
     STRING = "# This is not a comment"    # and this is the third comment        
    '''
    前后三个单引号可进行多行注释
    通常是对函数、对象的说明
    注释代码仍以 # 为主
    '''

    赋值

    # " = " 用于变量赋值;变量直接赋值,无须定义变量类型; 无须定义变量的数据类型
    a = 20
    #变量在使用前必须赋值,否则会出错
    x = y = z = 1          # 可将同一个值赋给多个变量

    在Python中,变量名没有类型,但对象有;变量名只是对对象的引用(内部实现为指针)

    变量命名规则及惯例
    语法: (下划线或字母)+(任意数目的字母、数字或下划线)

    变量名必须以下划线或字母开头,而后面接任意数目的字母、数字或下划线。

    区分大小写: SPAM和spam不同
    禁止使用保留字

    命名惯例:

    以单一下划线开头的变量名(_X)不会被 from module import *语句导入
    前后有下划线的变量名(_X_)是系统定义的变量名,对解释器有特殊意义
    以双下划线开头,但结尾没有双下划线的变量名(__X)是类的本地(“压缩”)变量
    通过交互模式运行时,只有单个下划线的变量名(_)会保存最后表达式的结果

    简单的输入、输出

    # 简单的输入输出
    raw_input("Please input: ")            # Python2.x  raw_input() 
    input("Please input: ")                 # Python3.x input()
    print "hello world"                    # Python2.x  可以不用加()
    print("hello world")                   # Python3.x  必须要加(),不然会报错! Python3.x print() 会是空行,而Python2.x  print() 则会显示(),须注意!
    print("This is "Note"")              # 该条报错!需对"转义

    关于特殊字符及Unicode

    # 关于特殊字符及Unicode
    print("This is \"Note\"")                #  \  转义
    print("This is\nNote")                   #  \n 换行
    print ("Hello"+u"\u0020"+"World")        #  u'xxxx':Python2.x unicode对象 = 直接在字符串前加u关键字
    print("Hello\u0020World")                #  Python2.x 直接输出 Hello\u0020World ,Python3.x 会输出 Hello World

    字符串双引号等特殊字符需转义,转义的方法是在 前面加上\;
    \n 表示换行
    从Python 3.0开始所有的字符串都支持Unicode(参考 http://www.unicode.org
    Unicode 的先进之处在于为每一种现代或古代使用的文字系统中出现的每一个字符都提供了统一的序列号。之前,文字系统中的字符只能有 256 种可能的顺序。通过代码页分界映射。文本绑定到映射文字系统的代码页。这在软件国际化的时候尤其麻烦(通常写作 i18n —— ’i’ + 18 个字符 + ’n’ )。Unicode 解决了为所有的文字系统设置一个独立代码页的难题。

    语法规则

    a,b = 0,1                  # 变量也可这么赋值,但不建议
    while b < 30:
        print(b)
        a,b = b,a+b        # 相当于 a=b 和 b = a+b

    需要注意的是:缩进

    Python开发者有意让违反了缩进规则的程序不能通过编译,以此来强制程序员养成良好的编程习惯。并且Python语言利用缩进表示语句块的开始和退出(Off-side规则),而非使用花括号或者某种关键字。增加缩进表示语句块的开始,而减少缩进则表示语句块的退出。缩进成为了语法的一部分。同样的如 if 语句如下:

    根据PEP的规定,必须使用4个空格来表示每级缩进(不清楚4个空格的规定如何,在实际编写中可以自定义空格数,但是要满足每级缩进间空格数相 等)。使用Tab字符和其它数目的空格虽然都可以编译通过,但不符合编码规范。支持Tab字符和其它数目的空格仅仅是为兼容很旧的的Python程序和某些有问题的编辑程序。

    不缩进会报错的例子

    a = 2
    if a>1:
    print("a>1")     # if 无执行语句会报错,若需实现if条件下print,参考如下

    缩进不对导致if语句无效的例子

    a = 0 
    if a>1:
         print("a>1")
    print("a!=1")    # 该语句始终会执行,因为缩进并不在if条件下

    缩进不对导致if语句无效不会报错,非常容易坑人,改为以下层次if条件生效:

    a = 0 
    if a>1:
         print("a>1")
         print("a!=1")    # 该语句仅if成立条件下执行

    更多格式问题参考:
    遇到的问题–python—代码格式层级错误导致if判断无效
    遇到的问题–python—IndentationError:expected an indented block
    遇到的问题–python—IndentationError: unexpected indent

    控制语句

    if语句,当条件成立时运行语句块。经常与else, elif(相当于else if) 配合使用。
    for语句,遍历列表、字符串、字典、集合等迭代器,依次处理迭代器中的每个元素。
    while语句,当条件为真时,循环运行语句块。
    try语句。与except,finally配合使用处理在程序运行中出现的异常情况。
    class语句。用于定义类型。
    def语句。用于定义函数和类型的方法。
    pass语句。表示此行为空,不运行任何操作。
    assert语句。用于程序调适阶段时测试运行条件是否满足。
    with语句。Python2.6以后定义的语法,在一个场景中运行语句块。比如,运行语句块前加密,然后在语句块运行退出后解密。
    yield语句。在迭代器函数内使用,用于返回一个元素。自从Python 2.5版本以后。这个语句变成一个运算符。
    raise语句。制造一个错误。
    import语句。导入一个模块或包。
    from import语句。从包导入模块或从模块导入某个对象。
    import as语句。将导入的对象赋值给一个变量。
    in语句。判断一个对象是否在一个字符串/列表/元组里。

    数据结构

    Python采用动态类型系统。在编译的时候,Python不会检查对象是否拥有被调用的方法或者属性,而是直至运行时,才做出检查。所以操作对象时可能会抛出异常。不过,虽然Python采用动态类型系统,它同时也是强类型的。Python禁止没有明确定义的操作, 比如数字加字符串。
    与其它面向对象语言一样,Python允许程序员定义类型。构造一个对象只需要像函数一样调用类型即可。类型本身也是特殊类型type的对象(type类型本身也是type对象),这种特殊的设计允许对类型进行反射编程。
    Python内置丰富的数据类型。与Java、C++相比,这些数据类型有效地减少代码的长度。下面这个列表简要地描述了Python内置数据类型(适用于Python 3.x):
    除了各种数据类型,Python语言还用类型来表示函数、模块、类型本身、对象的方法、编译后的Python代码、运行时信息等等。因此,Python具备很强的动态性。

    类型 描述 例子 备注
    str 一个由字符组成的不可更改的类型 “joe” 在python3里,字符串由Unicode字符组成
    bytes 一个由字节组成的不可更改的类型 b = b”joe”
    list 可以包含多种类型的可改变的类型 [4.0,”joe”,True]
    tuple 可以包含多种类型的不可改变的类型 {4.0,”joe”,True}
    set,frozenset 与数学集合的概念类型,无序,每个元素唯一 {4.0,”joe”,True},frozenset()
    dict 一个可改变的由键值对组成的类型 {4.0,”joe”,True}
    int 精度不限的整数 66
    float 浮点数,精度与系统相关 3.1415927
    complex 复数 3+2.7j
    bool 逻辑值,真假 True,False

    表达式

    +, -, *, /, //, **, ~, %分别表示加法或者取正、减法或者取负、乘法、除法、整除、乘方、取补、取模。
    >>, <<表示右移和左移。
    &, |, ^表示二进制的AND, OR, XOR运算。
    >, <, ==, !=, <=, >=用于比较两个表达式的值,分别表示大于、小于、等于、不等于、小于等于、大于等于。
    
    在这些运算符里面,~, |, ^, &, <<, >>必须应用于整数。
    使用and, or, not表示逻辑运算
    区分列表(list)和元组(tuple)两种类型;支持列表切割(list slices)
    一些Python特有的方法,如 range()  lambda 等

    函数

    Python的函数支持递归、默认参数值、可变参数,但不支持函数重载。为了增强代码的可读性,可以在函数后书写“文档字符串”(Documentation Strings,或者简称docstrings),用于解释函数的作用、参数的类型与意义、返回值类型与取值范围等。可以使用内置函数help()打印出函数的使用帮助。比如: help(randint)

    # 函数示例
    def my_fun1():
        print("hi")
    my_fun1()                  # 调用函数
    def my_fun2(a):            # 函数可带参数, 参数可为多个
        if(a>2):
            print(">2")
    my_fun2(3)

    对象

     # 对象示例
     class User(object):                # Python2.x 需在()内加object;Python3.x 不用加object
         def __init__(self,name):       # 类似于构造函数
            self.name=name
         def print_name(self):
             print(self.name)
    
      u = User("John")                   # u为一 User对象
      print(u.name)                      # 输出对象属性
      User.print_name(u)                 # 调用print_name()函数
    展开全文
  • 今天再看python的项目时,发现GitHub中给出的python脚本的执行格式是python -m pip install somepackage。于是开始了python模式启动之旅。 其中很多相关借鉴了该博客,同时感谢博主:...
  • python——刷票脚本

    万次阅读 多人点赞 2017-06-03 09:45:33
    前言现在部分比赛为了推广赞助商或者比赛本身,需要参赛队伍进行网上拉票,甚至票数还会占一定比例的成绩。因此,刷票也就应运而生了。此次我们团队参加一个比赛,就需要网上投票决出前几名,作为一位技术人员,当然...
  • 【Python】python脚本实例

    千次阅读 2019-07-28 21:50:32
    python脚本的实例 本文通过一个简单的python脚本实例,来介绍python语法。 参数:ip地址,端口号port 需求: 首先进行ping,如果ping不成功就就进行traceroute 如果ping得通就行telnet traceroute的结果要输出最后...
  • 浏览器执行Python脚本

    万次阅读 2020-03-15 10:14:40
    https://blog.csdn.net/yzy_1996/article/details/80223053
  • Python 脚本编写

    万次阅读 多人点赞 2018-07-14 19:50:05
    运行和修改 Python 脚本 与用户输入交互 处理异常 读写文件 导入本地、标准和第三方模块 在解释器中进行实验 安装 Python 检查计算机是否安装了 Python ? 在终端窗口输入如下指令,并按回车 python --...
  • Python 脚本的三种执行方式

    万次阅读 2018-10-19 16:12:34
    1.交互模式下执行 Python,这种模式下,无需创建脚本文件,直接在 Python解释器的交互模式下编写对应的 Python 语句即可。 1)打开交互模式的方式: Windows下: 在开始菜单找到“命令提示符”,打开,就进入到...
  • 利用Python脚本自动刷网课

    万次阅读 多人点赞 2018-06-16 23:24:28
    到期末时间有点紧,但是还有一堆无聊的网课,用...只能网上找资料自己写一个脚本了。 用到的库:time、pyautogui 参考:https://blog.csdn.net/AstroBoyTHU/article/details/78068070 # /usr/bin/env pytho...
  • 在手机里编写python脚本控制手机

    万次阅读 多人点赞 2019-09-26 14:03:32
    今天我有一个大胆的想法,想在手机里面编写python脚本自动化控制手机。既然有了这么大胆而想法,而且我还能实现,那么就有了我现在这篇文章。 如何在手机里面编程 首先先介绍一款能直接在手机里面运行代码的软件...
  • Python脚本的调试和分析

    千次阅读 2019-04-12 10:30:59
    本文摘自千锋教育编著的**《Python快乐编程》** 关注“千问千知”公众号,免费领取Python视频资料。 后台回复:XX视频即可。 调试和分析在Python开发中发挥重要作用 。调试器可帮助程序员分析完整的代码。调试器...
  • Linux下执行Python脚本

    万次阅读 多人点赞 2017-12-15 11:24:14
    1.Linux Python环境 Linux系统一般集成Python,如果没有安装,可以手动安装,联网状态下可直接安装。Fedora下使用yum install,Ubuntu下使用apt-get install,前提都是root权限。安装完毕,可将Python加入环境变量...
  • shell脚本中调用python脚本的函数并获取python脚本函数的return值 例子1: 废话少说,直接上代码: python脚本:merge_report.py # coding=utf-8 import sys def main(param): return param def find_...
  • java调用python脚本

    千次阅读 2018-09-28 18:35:42
    调用python脚本有以下几种情况,不带参数调用python脚本,动态传参数调用python脚本,调用python脚本中的某个方法,以下将讲解如何实现上述需求。  代码在windows系统上运行,需要提前安装p...
  • Java调用Python脚本

    万次阅读 2018-11-22 16:15:06
    最近突发奇想地想要在Java里调用Python脚本,在网上查过之后还真的可以。 常见的java调用python脚本方式 通过Jython.jar提供的类库实现 通过Runtime.getRuntime()开启进程来执行脚本文件 这两种方法我都尝试过,...
  • [272]如何把Python脚本导出为exe程序

    万次阅读 多人点赞 2018-07-08 14:07:34
    pyinstaller将Python脚本打包成可执行程序,使在没有Python环境的机器上运行 最新版是pyinstaller 3.1.1。支持python2.7和python3.3+。 可运行在Windows,Mac和Linux操作系统下。 但它不是跨编译的,也就是说在...
  • 在iOS设备中跑Python脚本

    万次阅读 2018-11-13 00:03:23
    在iOS设备中运行python脚本?那不就意味着可以在手机上跑爬虫,可以使用各种牛逼哄哄的python库了吗。 这个标题对我很有吸引力,曾经就有见到过在iOS平台上的python编译器(很多iOS上python的IDE,如Python3IDE),...
  • shell中: python test.py $para1 $para2 python中: def main($canshu1, $canshu2)  ..... main(sys.argv[1], sys.argv[2])
1 2 3 4 5 ... 20
收藏数 388,021
精华内容 155,208
关键字:

python脚本