python学习笔记

【python学习笔记】
data：2017-12-28

#!/usr/bin/env python# 
Filename : helloworld.py
print 'Hello World'

解释器
//
命令行输入python启动解释器
可以直接 print‘hello world’

运行一个python文件
1、python file.py
2、chomd a+x file.py
改成可执行的文件 ./file.py
3、添加到环境变量中
像命令一样直接运行
file.py
echo $PATH: 加$表示引用PATH的值

三引号可以指示一个多行的语句

\ 单独一个可以表示连接两行的内容
print i 与
print /
i
等价
python把习惯上把每一个物理行当作一个逻辑行，所以在编写代码时也最好这样，不要随便换行。

缩进是语法的一部分，不要随意空格
同一层次的语句必须有相同的缩进。每一组这样的语句称为一个块。

/

【输入】
guess = int(raw_input(‘Enter an integer : ‘))
int把输入转换成整形
raw_input（）函数为接收输入，里面‘’可选

s = raw_input(‘Enter something : ‘)
if s == ‘quit’: #字符串

【if语句】
if elif else

每一个条件后面需加冒号
else和C一样不能加条件
注意缩进，在if语句中 缩进代替了大括号

【while语句】
while True：
注意冒号
缩进代表大括号
while后可跟else，不过一般不需要

【for】

for i in range(1, 5):     #注意此处冒号
    print i
else: 
    print 'The for loop is over'

range（x,y,z）
x–>y但不包括y
z是步进

【break】
如果从for或while循环中 终止 ，任何对应的循环else块将不执行。

【continue】
continue语句被用来告诉Python跳过当前循环块中的剩余语句，然后 继续 进行下一轮循环。

while True: 
    s = raw_input('Enter something : ') 
    if s == 'quit': 
        break 
    if len(s) < 3: 
        continue 
    print 'Input is of sufficient length' 
    # Do other kinds of processing here...

—————————-【–函–数–】————————————-
def printMax(a, b):
if a > b:
print a, ‘is maximum’
else:
print b, ‘is maximum’

【global】

def func(): 
    global x 
    print 'x is',x
    x=2 
    print 'Changed local x to',x
x=50
func()
print 'Value of x is',x

如果你想要为一个定义在函数外的变量赋值，
那么你就得告诉Python这个变量名不是局部的，
而是 全局的。

【默认参数值】
def say(message, times = 1):
print message * times

say(‘Hello’)
say(‘World’, 5)

def func(a, b=5)是有效的，
但是def func(a=5, b)是无效的。
因为按位赋值的原则

【关键参数】
是按名字赋值的，与默认参数不一样
def func(a, b=5, c=10):
print ‘a is’, a, ‘and b is’, b, ‘and c is’, c

func(3, 7)
func(25, c=24)
func(c=50, a=100)

【return】
除非你提供你自己的return语句，每个函数都在结尾暗含有return

【DocStrings】文档字符串
在函数的第一个逻辑行的字符串是这个函数的 文档字符串
{规则}
文档字符串的惯例是一个多行字符串，它的首行以大写字母开始，句号结尾。
第二行是空行，从第三行开始是详细的描述。
强烈建议 你在你的函数中使用文档字符串时遵循这个惯例。
你可以使用doc（注意双下划线）调用printMax函数的文档字符串属性（属于函数的名称）。
请记住Python把 每一样东西 都作为对象，包括这个函数。

#!/usr/bin/env python
# Filename: func_doc.py
def printMax(x,y): 
    '''Prints the maximum of two numbers. 

    The two values must be integers.''' 
    x=int(x) # convert to integers, if possible 
    y=int(y) 

    if x>y: 
        print x,'is maximum' 
    else: 
        print y,'is maximum'

printMax(3,5)
print printMax.__doc__

强烈建议 你对你所写的任何正式函数编写文档字符串。

————————-【–模块–】—————————————-
模块基本上就是一个包含了所有你定义的函数和变量的文件。
为了在其他程序中重用模块，模块的文件名必须以.py为扩展名。
【import】
我们利用import语句 输入 sys模块

【.pyc】
字节编译的文件
是一种中间状态的文件，速度会快

【form..improt..】
如果你想要直接输入argv变量到你的程序中（避免在每次使用它时打sys.），
那么你可以使用from sys import argv语句。
如果你想要输入所有sys模块使用的名字，
那么你可以使用from sysimport *语句

一般说来，应该避免使用from..import而使用import语句，
因为这样可以使你的程序更加易读，也可以避免名称的冲突。

【name】

if __name__ == '__main__': 
    print 'This program is being run by itself'
else: 
    print 'I am being imported from another module'

注意是两个下划线

【dir()】
内建的dir函数来列出模块定义的标识符。标识符有函数、类和变量。
当你为dir()提供一个模块名的时候，它返回模块定义的名称列表。
如果不提供参数，它返回当前模块中定义的名称列表。

—————————-【–数据结构–】———————————–
在Python中有三种内建的数据结构——列表、元组和字典

【列表】
shoplist = [‘apple’, ‘mango’, ‘carrot’, ‘banana’]
注意列表是中括号！！！！

len(shoplist)
shoplist.append(‘rice’)末尾添加
shoplist.sort()排序
del shoplist[0] 删除

典型用法：
print ‘these items are:’,
for item in shoplist:
print item,
注意，我们在print语句的结尾使用了一个 逗号 来消除每个print语句自动打印的换行符

【元组】

zoo=('wolf','elephant','penguin')
print 'Number of animals in the zoo is',len(zoo)
new_zoo=('monkey','dolphin',zoo)
print 'Number of animals in the new zoo is',len(new_zoo)
print 'All animals in new zoo are',new_zoo
print 'Animals brought from old zoo are',new_zoo[2]
print 'Last animal brought from old zoo is',new_zoo[2][2]

注意是元括号
元组输出
age = 22
name = ‘Swaroop’
print ‘%s is %d years old’ % (name, age)
print ‘Why is %s playing with that python?’ % name
这样使用print，避免了一直以来我们使用的逗号
在第二个print语句中，我们使用了一个定制，
后面跟着%符号后的单个项目——没有圆括号。这只在字符串中只有一个定制的时候有效。

【字典】
字典类似于你通过联系人名字查找地址和联系人详细情况的地址簿，即，我们把键（名字）和值（详细情况）联系在一起。
注意，键必须是唯一的，就像如果有两个人恰巧同名的话，你无法找到正确的信息。

d = {key1 : value1, key2 : value2 }
#!/usr/bin/env python
# Filename: using_dict.py
# 'ab' is short for 'a'ddress'b'ook
ab={ 'Swaroop' : 'swaroopch@byteofpython.info', 'Larry' : 'larry@wall.org', 'Matsumoto' : 'matz@ruby-lang.org', 'Spammer' : 'spammer@hotmail.com' }
print "Swaroop's address is %s" %ab['Swaroop']
# Adding a key/value pair
ab['Guido']='guido@python.org'
# Deleting a key/value pair
del ab['Spammer']
print '\nThere are %d contacts in the address-book\n' %len(ab)
for name,address in ab.items(): 
    print 'Contact %s at %s' %(name,address)
if 'Guido' in ab: # OR ab.has_key('Guido') 
    print "\nGuido's address is %s" %ab['Guido']

【序列】
列表、元组和字符串都是序列
序列的两个主要特点是索引操作符和切片操作符。
索引操作符让我们可以从序列中抓取一个特定项目。
切片操作符让我们能够获取序列的一个切片，即一部分序列。
pyshoplist = [‘apple’, ‘mango’, ‘carrot’, ‘banana’]
print ‘Item 2 is’, shoplist[2]
print ‘Item 2 to end is’, shoplist[2:]
print ‘Item 1 to 3 is’, shoplist[1:3] #注意，这里并不包括3，只1,2

name = ‘swaroop’
print ‘characters 1 to 3 is’, name[1:3]
print ‘characters 1 to -1 is’, name[1:-1]

【参考】
记住列表的赋值语句不创建拷贝。你得使用切片操作符来建立序列的拷贝
shoplist = [‘apple’, ‘mango’, ‘carrot’, ‘banana’]
mylist = shoplist # mylist is just another name pointingto the same object!
mylist = shoplist[:] # make a copy by doing a full slice
这二者是不同的，一个是同一个，另一个是复制，在删除操作或其他操作时，结果是不一样的

【str】

name='Swaroop' # This is a string object

if name.startswith('Swa'): 
    print 'Yes, the string starts with "Swa"'

if 'a' in name: 
    print 'Yes, it contains the string "a"'

if name.find('war')!=-1: 
    print 'Yes, it contains the string "war"'

delimiter='_*_'
mylist=['Brazil','Russia','India','China']
print delimiter.join(mylist)

输出：Brazil_*_Russia_*_India_*_China

—————–【脚本】———————–
【一个备份脚本的编写】
os.system函数 运行 命令，
利用这个函数就好像在 系统 中运行命令一样。
即在shell中运行命令——如果命令成功运行，它返回0，否则它返回错误号。

time.strftime(‘%Y%m%d’)
if os.system(zip_command) == 0:
‘ ’.join

tar_command=”tar -zcvf ‘%s’ %s” % (target,’ ‘.join(source)) #%s 上面的单引号不加也行
//
if not os.path.exists(today):
os.mkdir*(today)

target = today + os.sep + now + ‘.zip’
注意os.sep变量的用法——这会根据你的操作系统给出目录分隔符，
即在Linux、Unix下它是’/’，在Windows下它是’\’，而在Mac OS下它是’:’。
使用os.sep而非直接使用字符，会使我们的程序具有移植性，可以在上述这些系统下工作。
///
target = today + os.sep + now + ‘_’ + \
comment.replace(’ ‘, ‘_’) + ‘.zip’

【软件开发过程】
软件是长出来的，而不是建造的
1.什么（分析）
2.如何（设计）
3.编写（实施）
4.测试（测试与调试）
5.使用（实施或开发）
6.维护（优化）

—————————【类】———————————————————

self
init
del

【继承】
继承 机制。继承完全可以理解成类之间的 类型和子类型 关系。
一个子类型在任何需要父类型的场合可以被替换成父类型，
即对象可以被视作是父类的实例，这种现象被称为多态现象。

——————————【异常】—————————–
【try..except】
我们可以使用try..except语句来处理异常。我们把通常的语句放在try-块中，而把我们的错误处理语句放在except-块中。

我们把所有可能引发错误的语句放在try块中，然后在except从句/块中处理所有的错误和异常。
except从句可以专门处理单一的错误或异常，或者一组包括在圆括号内的错误/异常。
如果没有给出错误或异常的名称，它会处理 所有的 错误和异常。
对于每个try从句，至少都有一个相关联的except从句。
如果某个错误或异常没有被处理，默认的Python处理器就会被调用。它会终止程序的运行，并且打印一个消息，我们已经看到了这样的处理。
你还可以让try..catch块关联上一个else从句。当没有异常发生的时候，else从句将被执行。

【引发异常】

#!/usr/bin/python
class ShortInputException(Exception):
def __init__(self,length,atleast):
Exception.__init__(self)
self.length = length
self.atleast = atleast
try:
s = raw_input('please input>')
if len(s) < 3:
raise ShortInputException(len(s),3)
except EOFError:
print '/n you input EOF'
except ShortInputException,x:
print 'ShortInputException:%d,%d' % (x.length,x.atleast)
else:
print 'NO ERROR'

1.定义一个异常类，自定义的异常类必须是Exception或者Error的子类！

2.try中使用raise语句来引发一个异常

3.执行try，可能会产生EOFRrror异常，我们自定义的异常

4.如果是EOFError，打印

5.如果是自定义的异常，打印

6，只有在try中没有异常才执行else语句。

【try..finally】
在读一个文件的时候，希望在无论异常发生与否的情况下都关闭文件
在程序运行的时候，按Ctrl-c中断/取消程序。
我们可以观察到KeyboardInterrupt异常被触发，程序退出。但是在程序退出之前，finally从句仍然被执行，把文件关闭上
——————————-【标准库】———————————
【sys模块】
sys模块包含系统对应的功能。

【os模块】
这个模块包含普遍的操作系统功能

———————–【特殊的方法】————————————

【lambda形式】
lambda语句被用来创建新的函数对象，并且在运行时返回它们。

【exec和eval语句】
exec语句用来执行储存在字符串或文件中的Python语句。
例如，我们可以在运行时生成一个包含Python代码的字符串，然后使用exec语句执行这些语句。下面是一个简单的例子。

exec ‘print “Hello World”’
Hello World
eval语句用来计算存储在字符串中的有效Python表达式。下面是一个简单的例子。
eval(‘2*3’)
6

【assert语句】
assert语句用来声明某个条件是真的。
例如，如果你非常确信某个你使用的列表中至少有一个元素，
而你想要检验这一点，并且在它非真的时候引发一个错误，
那么assert语句是应用在这种情形下的理想语句。
当assert语句失败的时候，会引发一个AssertionError。

【repr函数】
repr函数用来取得对象的规范字符串表示