标签：python
VII Python（1）基础知识
1989年诞生（同LinuxOS），google推崇，０６年后才开始在中国流行，０８年运维开始使用python
www.python.org（主流ＯＳ默认配的python为2.6或2.7，最好在Ubuntu12.10上使用python，对于开发很方便，否则会浪费很多时间在装某一软件包）
https://www.python.org/ftp/python/
Python（简单、容易上手、语法非常简明，任何功能都可实现；胶水语言，粘合剂，能与任何语言结合起来（如java、php、perl等）互相调用）
Python3.3（加入新功能，仅简单语法有变化整体９０%以上同2.7和2.6，3.3是2.7的过渡能识别2.7的语法及功能）
Win上（pythonXY、portable python可放在Ｕ盘到哪都能用）
模块，可以交互使用的一个代码段，或来自一个大规模的python程序，一旦导入一个模块就可引用它的任何的公共函数、类或属性（格式：>>>MODULE.FUNCTION，例如>>>sys.path）
注：并非所有模块都保存为*.py文件，如内置模块sys是用C写的源代码不是python所以不是.py文件，sys是置于python内部的
注：perl古老的语言，在文字处理方面（正则）非常强大，语法复杂，不适合团队开发；
注：php，轻量级的web开发，php能实现的python都能实现，php在Ｃ/S架构方面并不擅长，而pythonserver方面非常强悍，在web方面python一点不比php差；
注：软件工程师（编程，软件开发，游戏、搜索、嵌入式、网站、C/Ｓ软件），系统工程师（用python管理系统，脚本、运维自动化工具）；
注：shell和python，shell重在脚本方面，而python是语言，面向对象的语言，不止脚本方面
注：puppet（ruby）与python的外部框架类似
在python中一切皆对象，字符串是对象，列表是对象，函数是对象，模块是对象，一切都可以赋值给变量或作为参数传递给函数，所有函数都有一个内置的__doc__属性，它会返回在函数源代码中定义的doc string，sys模块是一个对象，它有一个叫作path的属性等
代码块指：函数、if语句、for循环、while循环等等，代码块通过缩进来定义，缩进是python这种语言的要求而并非是一种风格
测试模块：if__name==”__main__”:（注：if语句表达式不需用括号()括起来，以冒号结束，随后是缩进）
在python中向屏幕输出内容只用print即可，print语句可接受任何数据类型（字符串、整数、字典、列表等），甚至多种数据类型可混在一起输出到一行（各数据类型间用逗号分隔），显示在屏幕上时是用空格隔开的，逗号并不打印
Python中使用硬回车分割语句，冒号和缩进分割代码块；C++和JAVA使用分号分割语句，花括号来分割代码块
模块是对象，所有模块都有一个内置属性__name__，一个模块的__name__的值要看具体如何应用模块，如果import模块，那__name__的值通常为模块的文件名（无路径和文件扩展名），如果像标准程序一样直接运行模块那__name__的值是一个特别的默认值__main__，了解到这一点，你可在模块内部为你的模块设计一个测试套件（加入if语句），当运行模块时__name__的值是__main__测试套件执行，当导入模块时__name__的值就是特别的东西了，测试套件被忽略，这样使得将新的模块集成到一个大程序之前开发和调试容易多了
[root@localhost ~]# uname -a
Linux localhost.localdomain 2.6.32-358.el6.x86_64#1 SMP Tue Jan 29 11:47:41 EST 2013 x86_64 x86_64 x86_64 GNU/Linux
[root@localhost ~]# python -V
Python 2.6.6
[root@localhost ~]# which python
/usr/bin/python
[root@localhost ~]# vim test.py
----------script start---------------
#!/usr/bin/env python
def buildConnectionString(params):
"""Build a connection string from a dictionary ofparameters.
Returnsstring."""
return ";".join(["%s=%s" % (k, v) for k, v inparams.items()])
if __name__ == "__main__":
myParams = {"server":"mpilgrim", \
"database":"master", \
"uid":"sa",\
"pwd":"secret" \
}
printbuildConnectionString(myParams)
---------------script end--------------
[root@localhost ~]# python test.py（使用python SCRIPT_NAME，即可运行python脚本）
pwd=secret;database=master;uid=sa;server=mpilgrim
[root@localhost ~]# python（进入python编辑器模式）
Python 2.6.6(r266:84292, Oct 12 2012, 14:23:48)
[GCC 4.4.6 20120305 (Red Hat 4.4.6-4)]on linux2
Type "help","copyright", "credits" or "license" for moreinformation.
>>>
>>> print ‘hello world‘
hello world
一、
Python编程风格：
１、语法要求：
缩进统一（shell中的循环语句有关闭符号（fi、done），而python中无关闭符号，用缩进替代，敲两下回车即输入结束，程序从第二行开始之后的内容要统一格式，要么一个或两个或四个空格（ＴＡＢ键默认４个空格），否则语法错误（incident error））；
注：缩进在python中是语法要求而不是风格
变量（变量名由字母、数字、下划线组成，且第一个字符不能是数字（变量名的第一个字符必须是大写字母或小写字母或下划线（_）；变量名的其它部分可由大小写字母或下划线或数字组成）；变量名对大小写敏感，如myname和myName是不同的变量）
注：python与大多数语言一样，有局部变量和全局变量之分，但无明显的变量声明，变量通过首次赋值产生，当超出作用范围时自动消亡
注：当一条命令用续行符\分割成多行时，后续的行可以以任何方式缩进，在（）、[]、{}中的表达式可用也可不用换行符，若使用换行符可使代码读起来更容易，这只是风格而已
注：python不允许引用一个未被赋值的变量，否则会引发异常，赋值时可一次赋多值，也可连续值赋值，具体看以下举例
格式化字符串（用%s）、格式化整数（用%d）、格式化浮点数（用%f），字符串格式化不仅是格式化，还是连接，也是强制类型转换
字符串连接用“+”符号
举例：
有效变量名（i、_my_name、name_23、a1b2_c3）
无效变量名（2things、this is spaced out、my-name）
>>> name=‘jowin‘
>>> print name
jowin
>>> if name==‘jowin‘:（注意此句结尾是冒号）
... print ‘hello‘,name（此处敲两下回车即输入结束）
...
hello jowin
（一次赋多值，此例v是一个三元素的tuple，（x,y,z）是一个三变量的tuple，将一个tuple赋值给另一个tuple，会按照先后顺序对应的赋给每个变量）
>>>v=("a","b","e")
>>> v
(‘a‘, ‘b‘, ‘e‘)
>>> (x,y,z)=v
>>> x
‘a‘
>>> y
‘b‘
>>> z
‘e‘
（连续值赋值，内置的range函数返回连续的整数list，range的简化使用如range(7)接收一个上限值，返回一个初始值从0开始的list，依次递增但不包含上限值）
>>> range(7)
[0, 1, 2, 3, 4, 5, 6]
>>> range(1,8)
[1, 2, 3, 4, 5, 6, 7]
>>>(MONDAY,TUESDAY,WEDNESDAY,THURSDAY,FRIDAY,SATURDAY,SUNDAY)=range(1,8)
>>> MONDAY
1
>>> SATURDAY
6
（整个表达式的计算结果为一个字符串，第一个%s被变量k的值替换，第二个%s被变量v的值替换，其它字符原样输出，(k,v)是一个tuple
>>> k="uid"
>>> v="sa"
>>> "%s=%s" % (k,v)
‘uid=sa‘
字符串格式化与字符串连接比较
>>> uid="sa"
>>> pwd="secret"
>>> print pwd+"is not a good password for"+uid
secretis not a good password forsa
>>> print "%s is not a good password for %s" % (pwd,uid) （此处字符串连接与字符串格式化结果一样）
secret is not a good password for sa
注：(userCount,)是一个只包含一个元素的tuple，显示的说明这是一个tuple而不是其它，当定义一个list、dictionary、tuple可以总是在最后一个元素后面跟上逗号，但要定义仅包含一个元素的tuple时逗号是必须的否则python不知道(userCount,)是包含一个元素的tuple还是变量userCount的值
>>> userCount=6
>>> print "Usersconnected:%d" % (userCount,)
Users connected:6
>>> print "Usersconnected:"+userCount （将字符串与非字符串连接会产生异常）
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: cannot concatenate ‘str‘ and‘int‘ objects
格式化浮点数，%f十进制浮点数，不指定精度时默认打印6位小数
>>> print "today‘s stockprice:%f" % 50.4625
today‘s stock price:50.462500
>>> print "today‘s stockprice:%.2f" %50.4625
today‘s stock price:50.46
>>> print "today‘s stockprice:%+.2f" %50.4625
today‘s stock price:+50.46
２、单引号（强引用）、双引号（弱引用）、三引号（’’’或”””用于注释，可多行）
注：三引号用于注释（docstring），三引号的内容可包含多行字符串，在开始与结束间的所有东西都被视为单个字符串的一部分（包括硬回车和引号）；三引号（doc string）可用于提供上下文敏感文档信息，如键入一个函数名时，将显示提示信息，这会非常有用
注：在脚本中若注释一行在行首使用#，注释多行在开始和结尾处使用’’’或”””
３、在编辑模式下，可直接用于计算
>>> 3 * 2 / 2（可在编辑模式下直接做算述运算，在shell下是用bc）
3
>>> 88*2/2
88
>>> a=8
>>> b=6
>>> a>b
True
>>> a<b
False
>>> a!=b
True
４、赋值（用等号＝赋值，用双等号＝＝作判断）
>>> User_name=‘jowin‘
>>> print User_name
jowin
>>> Age=27
>>> print Age
27
>>> Next_year_age=Age+1
>>> print Next_year_age
28
>>> name=chai（此句是把chai当作变量，变量chai之前没有赋过值，所以报错未定义）
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name ‘chai‘ is not defined
>>> chai=‘hehe‘
>>> print chai
hehe
>>> print name
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name ‘name‘ is not defined
>>> name=chai
>>> print name
hehe
5、函数声明以关键字def开始，后接函数名，()内为参数，多个参数用逗号分隔（param1,param2）；
函数没有定义返回的数据类型，python不需要指定返回值的数据类型和返回值，每个python函数都有返回值，若函数执行过return语句则将返回指定的值，否则返回none（python的空值）；
Python中的参数不需指定数据类型，python会判断一个变量是什么类型，并在内部将其记录下来；
注：python既是动态类型定义语言（不用声明数据类型），又是强类型定义语言（一旦一个变量具有一个数据类型，实际上就一直是这个类型了）
二、
1、
导入模块（导入程序块或包，python自带的有内置模块，若想要用其它功能就要导入其它模块，使用方法>>>importMODULE_NAME）：
注：模块，可以交互使用的一个代码段，或来自一个大规模的python程序，一旦导入一个模块就可引用它的任何的公共函数、类或属性（格式：>>>MODULE.FUNCTION，例如>>>sys.path）
>>> import sys（导入sys模块使得它的所有函数和属性都有效）
>>> sys.path（模块导入的搜索路径，列出路径，列出的是当前包含的目录，sys.path是一个组成当前搜索路径的目录列表，在导入模块时会按照此路径逐个搜索匹配的*.py文件）
[‘‘, ‘/usr/lib64/python26.zip‘,‘/usr/lib64/python2.6‘, ‘/usr/lib64/python2.6/plat-linux2‘,‘/usr/lib64/python2.6/lib-tk‘, ‘/usr/lib64/python2.6/lib-old‘,‘/usr/lib64/python2.6/lib-dynload‘, ‘/usr/lib64/python2.6/site-packages‘,‘/usr/lib64/python2.6/site-packages/gtk-2.0‘,‘/usr/lib/python2.6/site-packages‘,‘/usr/lib/python2.6/site-packages/setuptools-0.6c11-py2.6.egg-info‘]
注：并非所有模块都保存为*.py文件，如内置模块sys是用C写的源代码不是python所以不是.py文件，sys是置于python内部的
>>> help(sys)
>>> sys.path.append(‘/root‘)（自定义加入其它路径）
>>> sys.path
[‘‘, ‘/usr/lib64/python26.zip‘,‘/usr/lib64/python2.6‘, ‘/usr/lib64/python2.6/plat-linux2‘,‘/usr/lib64/python2.6/lib-tk‘, ‘/usr/lib64/python2.6/lib-old‘,‘/usr/lib64/python2.6/lib-dynload‘, ‘/usr/lib64/python2.6/site-packages‘,‘/usr/lib64/python2.6/site-packages/gtk-2.0‘,‘/usr/lib/python2.6/site-packages‘,‘/usr/lib/python2.6/site-packages/setuptools-0.6c11-py2.6.egg-info‘, ‘/root‘]
使用TAB补全功能：
[root@localhost ~]# vim tab.py
-------------script start---------------
#!/usr/bin/env python
# python startup file
import sys
import readline
import rlcompleter
import atexit
import os
# tab completion
readline.parse_and_bind(‘tab: complete‘)
# history file
histfile = os.path.join(os.environ[‘HOME‘],‘.pythonhistory‘)
try:
readline.read_history_file(histfile)
except IOError:
pass
atexit.register(readline.write_history_file,histfile)
del os, histfile, readline, rlcompleter
--------------script end----------------
[root@localhost ~]# python
>>> import sys
>>> import tab（此处只用写名字，无需写后缀.py，注意此处是当前路径，若此脚本在其它位置，要使用绝对路径）
>>> sys.<TAB>
sys.__class__( sys.exitfunc(
sys.__delattr__( sys.flags
sys.__dict__ sys.float_info
sys.__displayhook__( sys.getc
……
>>> sys.version_info
(2, 6, 6, ‘final‘, 0)
>>> import os
>>> os.system(‘pwd‘)（调用shell命令）
/root
0
>>> from sys import path,version_info（直接使用path和version_info，而不是sys.path，sys.version_info这样使用）
>>> path
[‘‘, ‘/usr/lib64/python26.zip‘,‘/usr/lib64/python2.6‘, ‘/usr/lib64/python2.6/plat-linux2‘,‘/usr/lib64/python2.6/lib-tk‘, ‘/usr/lib64/python2.6/lib-old‘,‘/usr/lib64/python2.6/lib-dynload‘, ‘/usr/lib64/python2.6/site-packages‘,‘/usr/lib64/python2.6/site-packages/gtk-2.0‘, ‘/usr/lib/python2.6/site-packages‘,‘/usr/lib/python2.6/site-packages/setuptools-0.6c11-py2.6.egg-info‘]
>>> version_info
(2, 6, 6, ‘final‘, 0)
>>> from os import system
>>> system(‘df -h‘)
Filesystem Size Used Avail Use% Mounted on
/dev/mapper/VolGroup-lv_root
18G 2.4G 15G 15% /
tmpfs 116M 0 116M 0% /dev/shm
/dev/sda1 485M 33M 427M 8% /boot
/dev/sr0 3.5G 3.5G 0 100% /mnt/cdrom
0
>>> import sys,os（导入多个模块，用逗号分隔）
>>> from sys import version_infoas v（若某个模块的属性很长，可定义别名来使用）
>>> v
(2, 6, 6, ‘final‘, 0)
2、内置数据类型：dictionary字典、list列表、tuple元组
dictionary定义键和值之间一对一的关系，python中的dictionary象perl的hash哈希数组象java中的hashtable类的实例象vb中的scripting dictionary对象的实例，perl存储哈希值的变量是以%开头，在python中变量可任意取名并在python内部会记录下其数据类型
（1）定义dictionary用｛｝，此例有两个元素，将两元素赋值给变量d，元素间用逗号分隔，单个元素的key和value之间用冒号分隔且key和value本身用引号引起来，整个元素集合用大括号括起来
>>>d={"server":"mpilgrim","database":"master"}
>>> d
{‘database‘: ‘master‘, ‘server‘:‘mpilgrim‘}
（2）引用一个key所对应的value通过d["server"]，只能通过key引用value，不能通过value来获取key
>>> d["server"]
‘mpilgrim‘
>>> d["database"]
‘master‘
>>> d["mpilgrim"]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: ‘mpilgrim‘
（3）修改dictionary通过d["server"]="qikai"，若key存在则新value会覆盖之前的value，若key不存在则是新添加一个元素，一个dictionary中不能有相同的key，任何时候都可加入新的元素（key:value）这与修改存在的key:value是一样的
>>>d["server"]="qikai"
>>> d
{‘database‘: ‘master‘, ‘server‘: ‘qikai‘}
>>> d["server"]
‘qikai‘
>>>d["uid"]="sa"
>>> d
{‘database‘: ‘master‘, ‘uid‘: ‘sa‘,‘server‘: ‘qikai‘}
（4）dictionary中没有元素顺序的概念，只是序偶的简单排列，这是一个重要特性，dictionary中的key是大小写敏感的
>>>d["key"]="value"
>>> d["Key"]="othervalue"
>>> d
{‘Key‘: ‘other value‘, ‘database‘:‘master‘, ‘uid‘: ‘sa‘, ‘key‘: ‘value‘, ‘server‘: ‘qikai‘}
（5）dictionary中可混用数据类型，value可以是任意数据类型（字符串、整数、对象、甚至可以是其它的dictionary），在单个dictionary中dictionary的value不需要全都是同一数据类型，可根据需要混用；dictionary的key要严格些可以是字符串、整数和几种其它类型（如tuple等）
>>> d["retrycount"]=3
>>> d["42"]="douglas"
>>> d
{‘key‘: ‘value‘, ‘uid‘: ‘sa‘, ‘database‘:‘master‘, ‘42‘: ‘douglas‘, ‘server‘: ‘qikai‘,‘Key‘: ‘other value‘, ‘retrycount‘: 3}
（6）从dictionary中删除元素，del用于删除独立的元素，clear用于删除所有元素
>>> d
{‘key‘: ‘value‘, ‘uid‘: ‘sa‘, ‘database‘:‘master‘, ‘42‘: ‘douglas‘, ‘server‘: ‘qikai‘,‘Key‘: ‘other value‘, ‘retrycount‘: 3}
>>> del d["42"]
>>> d
{‘key‘: ‘value‘, ‘uid‘: ‘sa‘, ‘database‘:‘master‘, ‘server‘: ‘qikai‘, ‘Key‘: ‘other value‘, ‘retrycount‘: 3}
>>> d.clear()
>>> d
{}
list是python中使用最频繁的数据类型，python中的list象perl和java中的数组，perl中用来保存数组的变量总以@开始，在python中变量可任意取名并在内部会记录其数据类型，python中的list远比java中的数组强大，它可保存任意对象，并可在增加新元素时动态扩展
（1）定义list用[]，此例创建5个元素的list，元素间用逗号分隔并保持着初始的顺序，单个元素用双引号引起来，整个元素集合用中括号括起来；list的下标总是从0开始的数组，任何一个非空list的第一个元素是li[0]
>>>li=["a","b","mpilgrim","z","example"]
>>> li
[‘a‘, ‘b‘, ‘mpilgrim‘, ‘z‘, ‘example‘]
>>> li[0]
‘a‘
>>> li[1]
‘b‘
>>> li[4]
‘example‘
（2）负的list索引，负数索引从list的尾部开始来存取元素，任何一个非空的list最后一个元素总是li[-1]，可这样理解li[-n]=li[len(li0-n]，在此例中li[-3]=li[2]
>>> li[-1]
‘example‘
>>> li[-3]
‘mpilgrim‘
（3）list的分片slice，如li[1:3]指定2个索引得到list的子集叫一个slice，li[1:3]所返回的值是一个新的list，li[1:3]这个子集包含了list中按顺序从第一个slice索引li[1]直到但不包括第二个slice索引li[3]这之间的所有元素，再如li[0:3]从li[0]开始但不包括li[3]这之间的所有元素；slice简写，若左侧分片索引为0可将其省略，例如li[0:3]=li[:3]，若右侧分片索引是list的长度，可将其省略，例如li[3:5]=li[3:]；注意对称性li[:n]总返回前n个元素，li[n:]将返回剩下的元素，不管list有多长；若将左侧和右侧的两个分片全部省略，这将包括list的所有元素，但与原始的名为li的list不同，它是一个新的list，与原来的li有一样的元素，如li[:]是生成一个list完全拷贝的简写
>>> li[1:3]
[‘b‘, ‘mpilgrim‘]
>>> li[0:3]
[‘a‘, ‘b‘, ‘mpilgrim‘]
>>> li[:3]
[‘a‘, ‘b‘, ‘mpilgrim‘]
>>> li[3:5]
[‘z‘, ‘example‘]
>>> li[3:]
[‘z‘, ‘example‘]
>>> li[1:-1]
[‘b‘, ‘mpilgrim‘, ‘z‘]
>>> li[1:5]
[‘b‘, ‘mpilgrim‘, ‘z‘, ‘example‘]
>>> li[1:]
[‘b‘, ‘mpilgrim‘, ‘z‘, ‘example‘]
>>> li[:]
[‘a‘, ‘b‘, ‘mpilgrim‘, ‘z‘, ‘example‘]
（4）向list中增加元素，append、insert、extend后面紧跟的是（）小括号；append向list的末尾追加单个元素；insert将单个元素插入到list中，数值参数是插入点的索引，list中的元素可重复（不必唯一），如此例li[2]和li[6]；extend用来连接list，注意不要使用多个参数来调用extend，而要用一个list参数进行调用，在本例中这个list有两个元素
>>> li.append("new")
>>> li
[‘a‘, ‘b‘, ‘mpilgrim‘, ‘z‘, ‘example‘,‘new‘]
>>> li.insert(2,"new")
>>> li
[‘a‘, ‘b‘, ‘new‘, ‘mpilgrim‘, ‘z‘,‘example‘, ‘new‘]
>>> li[2]
‘new‘
>>> li[6]
‘new‘
>>>li.extend(["two","elements"])
>>> li
[‘a‘, ‘b‘, ‘new‘, ‘mpilgrim‘, ‘z‘,‘example‘, ‘new‘, ‘two‘, ‘elements‘]
extend与append的差别：
extend接受一个参数，这个参数总是一个list，并且添加这个list中的每个元素到原list中，如下例中len(li)共6个元素；
append接受一个参数，这个参数可以是任何数据类型，只是简单的追加到原list的尾部，如下例使用含有3个元素的list参数调用len(li)共4个元素
>>> li=["a","b","e"]
>>> li
[‘a‘, ‘b‘, ‘e‘]
>>>li.extend(["d","e","f"])
>>> li
[‘a‘, ‘b‘, ‘e‘, ‘d‘, ‘e‘, ‘f‘]
>>> len(li)
6
>>>li=["a","b","e"]
>>> li
[‘a‘, ‘b‘, ‘e‘]
>>>li.append(["d","e","f"])
>>> li
[‘a‘, ‘b‘, ‘e‘, [‘d‘, ‘e‘, ‘f‘]]
>>> len(li)
4
>>> li[-1]
[‘d‘, ‘e‘, ‘f‘]
（5）在list中搜索：index在list中查找一个值的首次出现并返回索引值，index后紧跟（）小括号若在list中没有找到值，python会引发一个异常，这一点与大部分语言截然不同，大部分语言会返回一个无效索引，好处在于在python程序中使用无效索引会引起崩溃；用in可测试一个值是否在list内，如"c" in li，若存在返回True，不存在返回False，注意python中的布尔值True和False第一个字母是大写的，如同python中的其它东西一样是大小写敏感
>>> li.index("b")
1
>>> li.index("e")
2
>>> li.index("example")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: list.index(x): x not in list
>>> "c" in li
False
>>> "e" in li
True
（6）从list中删除元素：remove从list中删除一个值的首次出现，删除时若没找到值会引发异常来响应index方法，remove后紧跟（）小括号；pop删除list的最后一个元素并将删除的值返回（注意做了两件事），li[-1]仅返回一个值但不改变list本身，li.remove("value")改变list但并不返回值
>>> li.remove("a")
>>> li
[‘b‘, ‘e‘, [‘d‘, ‘e‘, ‘f‘]]
>>> li.pop()
[‘d‘, ‘e‘, ‘f‘]
>>> li
[‘b‘, ‘e‘]
（7）使用list的运算符：可用+运算符连接起来，list=list+other list相当于list.extend(otherlist)，+运算符把一个新的list作为值返回（连接后的新的list），而extend只修改存在的list，对于大型list来说，extend的执行速度要快些；+=，如li+=["two"]等同于li.extend(["two"])，+=运算符可用于list、字符串和整数，并且它可以被重载于用户自定义的类中；*可作为一个重复器作用于list，li=[1,2]*3等同于li=[1,2]+[1,2]+[1,2]
>>>li=["a","b","mpilgrim"]
>>> li
[‘a‘, ‘b‘, ‘mpilgrim‘]
>>>li=li+["example","new"]
>>> li
[‘a‘, ‘b‘, ‘mpilgrim‘, ‘example‘, ‘new‘]
>>> li+=["two"]
>>> li
[‘a‘, ‘b‘, ‘mpilgrim‘, ‘example‘, ‘new‘,‘two‘]
>>> li=[1,2]*3
>>> li
[1, 2, 1, 2, 1, 2]
（8）映射list，python的强大特性之一是其对list的解析，它提供一种紧凑的方法，可通过对list中的每个元素应用一个函数，从而将一个list映射为另一个list
>>> li=[1,9,8,4]
>>> [elem*2 for elem in li] （从右向左看便于理解，python循环遍历li中的每个元素，对每个元素均执行elem*2这一函数操作，临时将其值赋给elem，再应用函数elem*2计算，最后将计算结果返回到要返回的list中，对list的解析并不改变原始的list）
[2, 18, 16, 8]
>>> li=[elem*2 for elem in li]
>>> li
[2, 18, 16, 8]
tuple是不可变list，一旦创建了tuple就不能以任何方式改变它
（1）定义tuple与定义list相同，不同之处list的整个元素用[]中括号而tuple的整个元素用（）小括号；tuple没有方法，不可以使用append、insert、remove、extend、pop这些方法，但可用index和in用来查找某元素是否存在
tuple的好处，tuple比list操作速度快，如果定义了一个值的常量级，并且唯一要用它做的是不断的遍历它，请使用tuple代替list；
tuple可对不需要修改的数据进行写保护，使得代码更安全，使用tuple如同拥有一个隐含的assert语句，说明这一数据是常量，如果必须要改变这些值，则用到一个特殊的函数执行tuple到list的转换；
tuple可在dictionary中被用作key，但list不行，dictionary的key可以是字符串、整数和其它几种类型，如tuple，dictionary的key的必须是不可变的，tuple本身是不可变的，但如果有一个list的tuple就认为可变若用于dictionary的key就是不安全的，只有字符串、整数和其它对dictionary安全的tuple才可以用作dictionarykey；
tuple可用在字符串格式化中
注：tuple和list可相互转换，内置的tuple函数接收一个list返回一个有相同元素的tuple，内置的list函数接收一个tuple返回一个list，可理解为tuple冻结一个list，list解冻一个tuple
>>>t=("a","b","mpilgrim","z","example")
>>> t
(‘a‘, ‘b‘, ‘mpilgrim‘, ‘z‘, ‘example‘)
>>> t[0]
‘a‘
>>> t[-1]
‘example‘
>>> t[1:3]
(‘b‘, ‘mpilgrim‘)
>>> t.append("new")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: ‘tuple‘ object has noattribute ‘append‘
>>> "z" in t
True
>>> t.index("example")
4
>>>t.extend(["new","old"])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: ‘tuple‘ object has noattribute ‘extend‘
>>> t.remove("example")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: ‘tuple‘ object has noattribute ‘remove‘
>>> t.insert(2,"new")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: ‘tuple‘ object has noattribute ‘insert‘
三、
raw_input、if…else…、for、while True:
注：raw_input() 默认输入是字符串，若要限定仅输入数字需调整int(raw_input())；print中’’’CONTENT’’’三引号中的%s,%d,%s是在注释的信息中引用变量，print后的单引号内的%s或%d也是引用外部的变量，print后不管是三引号还是单引号都要跟固定的格式，如print ‘the number is:%d’ % i或print ‘the number is :%d’ % (i)
注：python中引用一范围内的数值为range(1,100)，在shell中是seq 1 100或echo {1..100}
脚本使用（用raw_input实现用户交互）
>>> raw_input(‘please input yourname: ‘)
please input your name: jowin
‘jowin‘
>>> name=raw_input(‘please inputyour name: ‘) （给name变量赋值）
please input your name: jowin
>>> name
‘jowin‘
[root@localhost ~]# vim test1.py
-------------script start------------
#!/usr/bin/enc python
#
name=raw_input(‘Name:‘)
age=raw_input(‘Age:‘)
job=raw_input(‘Job:‘)
print ‘--------------‘
print name,age,job
--------------script end-------------
[root@localhost ~]# python test1.py
Name:jowin
Age:12
Job:yumwei
--------------
jowin 12 yumwei
[root@localhost ~]# vim test1.py
-------------script start----------
#!/usr/bin/enc python
#
name=raw_input(‘Name:‘)
age=raw_input(‘Age:‘)
job=raw_input(‘Job:‘)
print ‘--------------‘
print name,‘\n‘,age,‘\n‘,job
--------------script end------------
[root@localhost ~]# python test1.py
Name:jowin
Age:18
Job:IT
--------------
jowin
18
IT
[root@localhost ~]# vim test1.py
-------------script start-----------
#!/usr/bin/enc python
#
name=raw_input(‘Name:‘)
age=raw_input(‘Age:‘)
job=raw_input(‘Job:‘)
print ‘--------------‘
print‘\tNAME:‘,name,‘\n\tAGE:‘,age,‘\n\tJOB:‘,job
--------------script end-------------
[root@localhost ~]# python test1.py
Name:jowin
Age:22
Job:internet
--------------
NAME:jowin
AGE:22
JOB:internet
[root@localhost ~]# vim test1.py
------------script start-------------
#!/usr/bin/enc python
#
name=raw_input(‘Name:‘)
age=int(raw_input(‘Age:‘))
job=raw_input(‘Job:‘)
print ‘--------------‘
print type(age)
print ‘‘‘\tNAME:%s
\tAGE:%d
\tJOB:%s‘‘‘ %(name,age,job)
---------------script end-------------
注：raw_input() 默认输入是字符串，若要限定仅输入数字需调整int(raw_input())；此脚本中’’’CONTENT’’’三引号中的%s,%d,%s是在注释的信息中引用变量
[root@localhost ~]# python test1.py
Name:jowin
Age:23
Job:hehe
--------------
<type ‘int‘>
NAME:jowin
AGE:23
JOB:hehe
[root@localhost ~]# python test1.py（当Age:处输入不是数字时会报错）
Name:jowin
Age:hehe
Traceback (most recent call last):
File "test1.py", line 4, in <module>
age=int(raw_input(‘Age:‘))
ValueError: invalid literal for int() withbase 10: ‘hehe‘
脚本使用（流程控制if…else…）
[root@localhost ~]# vim test2.py
-------------script start--------------
#!/usr/bin/env python
#
name=raw_input(‘please input your name: ‘)
age=int(raw_input(‘please input your age:‘))
job=raw_input(‘please input your job: ‘)
print ‘--------------‘
print ‘‘‘NAME:%s
AGE:%d
JOB:%s‘‘‘ %(name,age,job)
if name==‘chai‘:
print "congratulations,you will can have the holiday."
elif age<30:
print "sorry,you will not have the holiday."
else:
print "you can do it as you had sent a gift to your booss."
----------------script end----------------
[root@localhost ~]# python test2.py
please input your name: jowin
please input your age: 22
please input your job: internet
--------------
NAME:jowin
AGE:22
JOB:internet
sorry,you will not have the holiday.
脚本使用（for语句）
>>> for i in range(1,5):
... print ‘the number is:%d‘ % i
...
the number is:1
the number is:2
the number is:3
the number is:4
>>> for i in range(1,3):
... print ‘the number is:%d‘ % (i)
...
the number is:1
the number is:2
>>> for i in range(1,5):
... if i==3:
... print "good luck,itis:",i
... print "the number is:%d" % i
...
the number is:1
the number is:2
good luck,it is: 3
the number is:3
the number is:4
[root@localhost ~]# vim test3.py
----------------------scriptstart--------------------
#!/usr/bin/env python
#
while True:
input=raw_input(‘please input your name: ‘)
if input==‘jowin‘:
password=raw_input(‘please input your password: ‘)
p=‘123‘
while password!=p:
password=raw_input(‘wrong password,input again: ‘)
else:
print "welcomelogin to my territory."
break
else:
print "sorry,user %s notfound " % input
------------------scriptend---------------------------
[root@localhost ~]# python test3.py
please input your name: jowin
please input your password: 123
welcome login to my territory.
[root@localhost ~]# python test3.py
please input your name: chai
sorry,user chai not found
please input your name: haha
sorry,user haha not found
本文出自 “Linux运维重难点学习笔记” 博客，请务必保留此出处http://jowin.blog.51cto.com/10090021/1771282
标签：python
原文地址：http://jowin.blog.51cto.com/10090021/1771282
