python内建函数测试对象身份_python 学习笔记day03-python基础、python对象、数字、函数...

python基础

语句和语法

注释及续行

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

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

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

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

缩进及代码组

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

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

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

同行多个语句

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

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

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

>>> a = 3;print a

3

>>> x = 3;def foo(): print x

File "", 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 "", 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 "", line 1, in

TypeError: ‘int‘ object is not callable

>>> del len

>>> 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)

>>> a = ‘hello‘

>>> type(a)

>>> a = []

>>> type(a)

- 值：对象表示的数据项

python对象属性

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

用.标记法来访问属性

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

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

python对象类型

标准类型

数字

- 整型

- 长整形

- 布尔型

- 浮点型

- 复数型

字符串

列表

元组

字典

其他内建类型

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

- 类型

- Null对象(None)

- 文件

- 集合/固定集合

- 函数/方法

- 模块

- 类

内部类型

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

- 代码

- 帧

- 跟踪记录

- 切片

- 省略

- xrange

标准类型运算符

对象值的比较

运算符功能

expr1  < expr2expr1小于expr2

expr1 > expr2expr1 大于expr2

expr1 <= expr2expr1 小于等于expr2

expr1 >= expr2expr1 大于等于expr2

expr1 == expr2expr1 等于expr2

expr1 != expr2expr1 不等于expr2

expr1 <> expr2expr1 不等于expr2

对象身份比较

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

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

>>> aList = [‘hello‘,‘bob‘]

>>> bList = aList

>>> id(aList)

3071001644L

>>> id(bList)

3071001644L

>>> bList[1] = ‘tom‘

>>> aList

[‘hello‘, ‘tom‘]

布尔逻辑运算符

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

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

运算符功能

not exprexpr的逻辑非(否)

expr1 and expr2expr1 和expr2 的逻辑与

expr1 or expr2expr1 和expr2的逻辑或

数字

数字简介

创建数值对象并赋值

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

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

>>> 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

位运算符

位运算符只适用于整数

位运算符功能

～num单目运算，对数的每一位取反

num1 << num2num1 左移 num2位

num1 >> num2num1 右移num2位

num1 & num2num1 与num2按位与

num1 ^ num2num1 异或 num2(相同为0，不同为1)

num1 | num2num1 与num2 按位或

内建函数

标准类型函数

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.

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 [email protected] "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()

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