python 学习笔记day03-python基础、python对象、数字、函数

标签：python 基础/对象/函数/

python基础

    语句和语法

        注释及续行

            首要说明的是：尽管python可读性最好的语言之一，这并不意味者程序员在代码中就可以不写注释

            和很多UNIX脚本类似，python注释语句从#字符开始

            注释可以在一行的任何地方开始，解释器会忽略掉该行#之后的所有内容

            一行过长的语句可以使用反斜杠\分解成几行

        缩进及代码组

            缩进相同的一组语句构成一个代码块，称之为代码组

            首行以关键字开始，以冒号：结束，该行之后的一行或多行代码构成代码组

            如果代码组只有一行，可以将其直接写在冒号后面，但是这样的写法可读性差，不推荐

        同行多个语句

            分号；允许你将多个语句写在同一行上

            但是这些语句不能在这行开始一个新的代码块

            因为可读性差，所以不推荐使用

                >>> a = 3;print a
                3
                >>> x = 3;def foo(): print x
                  File "<stdin>", line 1
                    x = 3;def foo(): print x
                            ^
                SyntaxError: invalid syntax

    变量赋值

        赋值运算符

            python语言中，等号=是主要的赋值运算符

            赋值并不是直接将一个值赋给一个变量

            在python中，对象是通过引用传递的。在赋值时，不管这个对象十新创建的，还是一个已经存在的，都是将该对象的引用(并不是值)赋值给变量

            python也支持链式多重赋值

                >>> x=y=1
                >>> x
                1
                >>> y
                1
        增量赋值

            从python 2.0开始，等号可以和一个算数运算符结合在一起，将计算结果重新赋值给左边的变量，这被称为增量赋值

                >>> x=1
                >>> x=x+1
                >>> x
                2
                >>> x += 1
                >>> x
                3
                >>> x++
                  File "<stdin>", line 1
                    x++
                      ^
                SyntaxError: invalid syntax
                >>> ++x
                3
        多元赋值

            另一种将多个变量同时赋值的方法称为多元赋值，采用这种方式赋值时，等号两边的对象都是元组

                >>> x,y,z=1,2,‘a string‘
                >>> print ‘x=%d,y=%d‘ %(x,y)
                x=1,y=2
                >>> x,y = y,x
                >>> print ‘x=%d,y=%d‘ %(x,y)
                x=2,y=1
    标识符

        合法的标识符

            python 标识符字符串规则和其他大部分用C编写的高级语言相似

            第一个字符必须十字母或下划线（_）

            剩下的字符可以使字母和数字或下划线

            大小写敏感

        关键字

            和其它的高级语言一样，python也拥有一些被称作关键字的保留字符

            任何语言的关键字应该保持相对的稳定，但是因为python是一门不断成长和进化的语言，其关键字偶尔会更新

            关键字列表和iskyward()函数都放入了keyword模块以便查阅

                >>> import keyword
                >>> keyword.iskeyword("if")  #判断if是不是关键字
                True
                >>> keyword.kwlist
                [‘and‘, ‘as‘, ‘assert‘, ‘break‘, ‘class‘, ‘continue‘, ‘def‘, ‘del‘, ‘elif‘, ‘else‘, ‘except‘, ‘exec‘, ‘finally‘, ‘for‘, ‘from‘, ‘global‘, ‘if‘, ‘import‘, ‘in‘, ‘is‘, ‘lambda‘, ‘not‘, ‘or‘, ‘pass‘, ‘print‘, ‘raise‘, ‘return‘, ‘try‘, ‘while‘, ‘with‘, ‘yield‘]
>>>
        内建

            除了关键字之外，python还有可以在任何一级代码使用的“内建”的名字集合，这些名字可以由解释器设置或使用

            虽然built-in不是关键字，但是应该把它当作“系统保留字”

            保留的常量如：True、False、None

                >>> len = 10
                >>> len(‘abcdf‘)
                Traceback (most recent call last):
                  File "<stdin>", line 1, in <module>
                TypeError: ‘int‘ object is not callable

                >>> del len
                >>> len
                <built-in function len>
                >>> len(‘abcdf‘)
                5
    基本风格

        模块结构及布局

            编写程序时，应该建立一个统一且容易阅读的结构，并将它应用到每一个文件中去

                #!/usr/bin/env python  #起始行
                "this is a test module"  #模块文档字符串
                import sys               #导入模块
                import os
                debug = True             #全局变量声明
                class FooClass(object):  #类定义
                ‘Foo class’
                pass
                def test():              #函数定义
                    "test function"
                    foo = FooClass()
                if __name__ == ‘__main__‘: #程序主体
                test()

        主程序中的测试代码

            优秀的程序员和软件工程师，总是会为其应用程序提供一组测试代码或者简单教程

            测试代码仅当该文件被直接执行时运行，即被其他模块导入时不执行

            利用__name__ 变量这个有力条件，将测试代码放在一个函数中，如果该模块是被当成脚本运行，就调用这个函数

练习：创建文件

1、编写一个程序，要求用户输入文件名

2、如果文件已经存在，要求用户重新输入

3、提示用户输入数据，每行数据先写到列表中

4、将列表数据写入到用户输入的文件中

#!/usr/bin/env python

import os

contents = []
while True:
    fname = raw_input("Plz input a file name: ")
    if not os.path.exists(fname):
        break
    print "%s already exists.Try again." % fname

while True:
    data = raw_input("(Enger to quit)> ")
    if  not data:
        break
    contents.append(data + ‘\n‘)


fobj = open(fname,‘w‘)
fobj.writelines(contents)
fobj.close()
升级版：（改成函数模式）

#!/usr/bin/env python

import os
def get_fname():
    while True:
        fname = raw_input("Plz input a file name: ")
        if not os.path.exists(fname):
            break
        print "%s already exists.Try again." % fname
    return fname

def get_contents():
    contents = []
    while True:
        data = raw_input("(Enger to quit)> ")
        if  not data:
            break
        contents.append(data + ‘\n‘)
    return contents

def wfile():
    fobj = open(fname,‘w‘)
    fobj.writelines(contents)
    fobj.close()

if __name__ == ‘__main__‘:
    filename = get_fname()
    lines = get_contents()
    wfile(filename,lines)

python 对象

    python对象基础

        python对象特性

            所有的python对象都拥有三个特性：

                - 身份：每一个对象都有一个唯一的身份标识自己，任何对象的身份可以使用内建函数id()来得到

                    >>> a = 3
                    >>> b = 3
                    >>> id(a)
                    146065560
                    >>> id(b)
                    146065560

                - 类型：决定了该对象可以保存什么类型的值，可以进行什么样的操作，以及遵循什么样的规则。用内建函数type()查看对象的类型

                    >>> a = 1
                    >>> type(a)
                    <type ‘int‘>
                    >>> a = ‘hello‘
                    >>> type(a)
                    <type ‘str‘>
                    >>> a = []
                    >>> type(a)
                    <type ‘list‘>

                - 值：对象表示的数据项

        python对象属性

            某些python对象有属性、值或相关联的可执行代码

            用.标记法来访问属性

            最常用的属性是函数和方法，不过有一些python类型也有数据属性

            含有数据属性的对象包括（但不限于）：类、类实例、模块、复数和文件

    python对象类型

        标准类型

            数字

                - 整型

                - 长整形

                - 布尔型

                - 浮点型

                - 复数型

            字符串

            列表

            元组

            字典

        其他内建类型

            在python开发时，还可能用到的数据类型有：

                - 类型

                - Null对象(None)

                - 文件

                - 集合/固定集合

                - 函数/方法

                - 模块

                - 类

        内部类型

            以下类型通常用不到，只是为了知识的完整性，简要的列出：

                - 代码

                - 帧

                - 跟踪记录

                - 切片

                - 省略

                - xrange

    标准类型运算符

            对象值的比较

            对象身份比较

                对象可以通过引用被赋值到另一个变量

                因为每个变量都指向同一个(共享的)数据对象，只要任何一个引用发生改变，该对象的其他引用也会随之改变

                    >>> aList = [‘hello‘,‘bob‘]
                    >>> bList = aList
                    >>> id(aList)
                    3071001644L
                    >>> id(bList)
                    3071001644L
                    >>> bList[1] = ‘tom‘
                    >>> aList
                    [‘hello‘, ‘tom‘]

            布尔逻辑运算符

                not运算符拥有最高优先级，只比所有比较运算符低一级

                and 和 or 运算符则相应的在低一级

数字

    数字简介

        创建数值对象并赋值

            数字提供了标量贮存和直接访问

            创建数值对象和给变量赋值一样简单

                >>> anint = 1
                >>> aLong = -9999999999999999999999L
                >>> aFloat = 3.141325677839900349
                >>> aComplex = 1.23 + 4.56J

        更新数字对象

            数字是不可变类型，也就是说变更数字的值会生成新的对象

            在python中，变量更像一个指针指向装变量值的盒子

            对不可变类型来说，你无法改变盒子的内容，但你可以将指针指向一个新盒子

                >>> i  =3
                >>> id(i)
                146065560
                >>> i = 4
                >>> id(i)
                146065548

        删除数字对象

            按照python的法则，无法真正删除一个数值对象，仅仅是不再使用它而已

            删除一个数值对象的引用，使用del语句

            删除对象的引用之后，就不能再使用这个引用（变量名），除非给它赋一个新值

            绝大多数情况下并不需要明确del一个对象

    整形

        布尔型

            该类型的取值只有两个，即True和False

            True的数值为1，False的数值为0

            在判断语句中，空列表、空元组、空字符串、空字典数值为0的数字以及None皆为Fasle，其他皆为True

                >>> True + 2
                3
                >>> if "hello": print ‘Yes‘
                ...
                Yes
                >>> if not []: print ‘yes‘
                ...
                yes

        标准整数类型

            标准整数类型是最通用的数字类型

            python标准整数类型等价于C的（有符号）长整型

            整数一般以十进制表示

            如果八进制整数以数字“0”开始，十六进制整数以“0x” 或“0X”开始，二进制整数以“0b”或“0B”开始

                >>> 0x10
                    16
                    >>> 010
                    8
                    >>> 0b10
                    2

        长整型

            C或其他编译型语言的长整数类型的取值范围是32位或64位

            python的长整数类型能表达的数值仅仅与机器支持的（虚拟）内存大小有关

            在一个整数值后面加个L（大写或小写都可以），表示这个整数十长整型

            这个整数可以是十进制，八进制，或十六进制

    运算符

       标准类型运算符

            在做数值运算时，必须努力保证操作数是合适的数据类型

            相同类型数值运算，得到的结果也是该类型的数值

            不同类型数值运算，需要（显示或隐式地）做数据类型转换

                    >>> print 5/3
                    1
                    >>> print 5.0 /3
                    1.66666666667

        混合模式运算符

        算术运算符

            python支持单目运算符正号（+）和负号（-）

            双目运算符，+、-、*、/、%，还有**,分别表示加法，减法，乘法，除法，取余和幂运算

            从python2.2起，还增加了一种新的整除运算符//,即地板除

                >>> print 3.0/2
                1.5
                >>> print 3.0 // 2
                1.0
                >>> print round(3.0/2)
                2.0

        位运算符

          位运算符只适用于整数

    内建函数

        标准类型函数

            cmp(num1,num2)

                - num1 大于num2结果为正值

                - num1 小于num2 结果为负值

                - num1 等于num2 结果为0

            str(num)：将num转换成字符串表示格式

            type(obj)：判断obj类型

        数字类型函数

            函数int()，long()，float()和complex()来将其它数值类型转换为相应的数值类型

               int(‘11‘) 默认十进制

                int(‘11‘,base=2) 二进制

                int(‘11‘,base=16)十六进制

            abs()：返回给定参数的绝对值;abs(10),abs(-10)

            divmod()：内建函数把除法和取余运算结合起来，返回一个包含商和余数的元组

                >>> divmod(5,3)
                (1, 2)

            pow()：进行指数运算

                    >>> pow(3,2)
                    9
                    >>> pow(2,3)
                    8

            round():用于对浮点数进行四舍五入运算

                    >>> print 5 / 3.0
                    1.66666666667
                    >>> print round(5 / 3.0)
                    2.0
                    >>> print round(5 / 3.0,2)  #保留两位小数点。
                    1.67

        仅用于整数的函数

            hex()：转换为字符串形式的十六进制数  eg：ex(100)

            oct()：转换为字符串形式的八进制数  eg：oct(100)

            bin()：转换为字符串形式的二进制数  eg： bin(100)  

            ord()：接受一个字符，返回其对应的ASCII值  eg：ord(‘a‘)

            chr()：接受一个单字节ASCII码整数值，返回一个字符串 eg：chr(65)    

模块psutil的使用

pip install psutil

import tab

import psutil

psutil.<tab><tab>

psutil.users()

psutil.used_phymem()

psutil.used_phymem() / 1024 / 1024

import os

os.system(‘free -m‘)

psutil.boot_time()

import time

psutil.disk_partitions()

psutil.disk_partitions()[0]

a = psutil.disk_partitions()[0]

type(a)

a.mountpoint

# pip install ecdsa

# pip install pycrypto

一个修改密码的脚本

#!/bin/bash

if [ -z "$3"]; then
    echo "Usage: $0 ipfile oldpass newpss"
    exit 1
fi

ipfile=$1
oldpass=$2
newpass=$3

if [ ! -f $ipfile ]; then
    ehco "$ipfile does not exists"
    exit 2
fi
for ip in $(cat $ipfile)
do
    expect << EOF
        spawn ssh root@ip "echo $newpass | passwd --stdin root"
        expect "(yes/no)?"{
           send "yes\r"
           expect "password:"
               send "$oldpass\r"
       } "password:" {send "$oldpass\r"}
        expect eof
EOF
done

python程序实现（改密码/执行远程命令）

#!/usr/bin/env python

import sys
import paramiko

def remote_comm(host,pwd,comm):
    ssh = paramiko.SSHClient()
    ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    ssh.connect(host,username=‘root‘,password=pwd)
    stdin,stdout,stderr = ssh.exec_command(comm)
    print stdout.read()
    print stdout.read()

if __name__ ==‘__main__‘:
    if len(sys.argv) != 4:
        print "Usage: %s ipfile oldpass newpass" %sys.argv[0]
    else:
        ipfile =  sys.argv[1]
        oldpass = sys.argv[2]
        newpass = sys.argv[3]
        ch_pwd = "echo %s | passwd --stdin root" % newpass
        fobj = open(ipfile)
        for line in fobj:
            ip = line.strip()   #去除字符串两端空白
            remote_comm(ip,oldpass,ch_pwd)

多线程版python（改密码/执行远程命令）

#!/usr/bin/env python

import sys
import paramiko
import threading
def remote_comm(host,pwd,comm):
    ssh = paramiko.SSHClient()
    ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    ssh.connect(host,username=‘root‘,password=pwd)
    stdin,stdout,stderr = ssh.exec_command(comm)
    print stdout.read(),
    print stderr.read(),

if __name__ ==‘__main__‘:
    if len(sys.argv) != 4:
        print "Usage: %s ipfile oldpass newpass" %sys.argv[0]
    else:
        ipfile =  sys.argv[1]
        oldpass = sys.argv[2]
        newpass = sys.argv[3]
        ch_pwd = "echo %s | passwd --stdin root" % newpass
        fobj = open(ipfile)
        for line in fobj:
            ip = line.strip()   #去除字符串两端空白
            t = threading.Thread(target=remote_comm,args=(ip,oldpass,ch_pwd
                                                          ))
            t.start()

本文出自 “linux服务器” 博客，请务必保留此出处http://sailq21.blog.51cto.com/6111337/1858651

python 学习笔记day03-python基础、python对象、数字、函数

标签：python 基础/对象/函数/

原文地址：http://sailq21.blog.51cto.com/6111337/1858651