python 学习笔记day03-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

标准类型运算符

对象值的比较

运算符	功能
expr1 < expr2	expr1小于expr2
expr1 > expr2	expr1 大于expr2
expr1 <= expr2	expr1 小于等于expr2
expr1 >= expr2	expr1 大于等于expr2
expr1 == expr2	expr1 等于expr2
expr1 != expr2	expr1 不等于expr2
expr1 <> expr2	expr1 不等于expr2

对象身份比较
对象可以通过引用被赋值到另一个变量
因为每个变量都指向同一个(共享的)数据对象，只要任何一个引用发生改变，该对象的其他引用也会随之改变

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

布尔逻辑运算符

not运算符拥有最高优先级，只比所有比较运算符低一级
and 和 or 运算符则相应的在低一级

运算符	功能
not expr	expr的逻辑非（否）
expr1 and expr2	expr1 和expr2 的逻辑与
expr1 or expr2	expr1 和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 << num2	num1 左移 num2位
num1 >> num2	num1 右移num2位
num1 & num2	num1 与num2按位与
num1 ^ num2	num1 异或 num2(相同为0，不同为1)
num1 | num2	num1 与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.<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程序实现[b]（改密码/执行远程命令）[/b]
#!/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()