VII Python(2)基础知识

  1. 云栖社区>
  2. 博客>
  3. 正文

VII Python(2)基础知识

技术小阿哥 2017-11-27 14:54:00 浏览1399
展开阅读全文

每种语言都各具特色,在各自领域都有其适用范围,python只是其中一种,在应用方面表现较好,是一种面向对象、解释型计算机程序设计语言,有丰富强大的类库,常被昵称为胶水语言,能轻松的把其它语言的各种模块联结在一起;openstackpython开发,有很多组件,python不仅是脚本语言它更适合开发大型程序,它是完整意义的编程语言或控制语言,调用其它语言的类库使其联结起来(胶水语言);

python非常流行,google在其网络搜索上用python实现,IntelHPCitrix等公司用python编写程序作硬件测试,NASA内部用的很多程序都用python编写;

编程语言,用户问题(问题空间)-->计算机(解空间,解决问题),编程语言将计算机所提供的解决问题的能力抽象,让其接近用户所理解的方面,抽象程度越高,则越接近人的理解,则这种语言越高级;

机器代码-->微码编程(芯片级别)-->高级语言(人类易理解)

解释器(可理解为同声传译),编译器(将写好的整段代码转换为机器所理解的二进制格式);

bytecode字节码,执行时编译,类似phpopcodejava的字节码,若在类接口统一情况下可互换执行;

python在性能方面比CC++要差些,python有丰富的类库和便捷的开发工具,使得开发过程更快、效益要高,现代计算机性能更强对于微弱的性能损失可忽略,python可在任意平台运行,只要该平台有PVMpythonvirtual machine),像JAVA似的一次编译到处运行;

 

source code.py--编译器compiler(PVM)-->bytecode.pyc--解释器interpreter(PVM)-->processor处理器

 

python被当作三种工具:

OS级别的自动化,脚本语言(shell编程,LinuxOS级别的自动化,在这一层面最好用shell,而python要用特定的调用接口才能实现,若只是用python作系统自动化方面的事情,会大材小用、自找麻烦);

文本处理(python在文本处理方面是shell无法比拟的,如网页抓取分析、正则表达式的高级处理等通过python强大的类库完成);

借助框架完成各方面的开发(如借助Django完成web开发)

 

python的实现:

CPython(原始、标准的实现方式,C语言开发的python);

Jython(用于与JAVA语言集成的实现,JAVA语言实现的python);

IronPython(用于与.NET框架集成的实现,.NET语言实现的python

 

python性能优化工具:

Psycopython语言的一个扩展模块,可以即时对程序代码进行专业的算法优化,可在一定程度上提高程序的执行速度,尤其是在程序中有大量循环操作时,目前开发工作已停止,由PyPy接替);

PyPy(是用python实现的pthon解释器,python语言的动态编译器,是Psyco的后继项目,可运行在Linux32bit64bitMacOSXWIN32bit平台中);

Shed Skinpython编译器,能够将python代码转换成优化的C++代码)

 

编写、执行python代码(初学使用vim即可),win下有IDLE及众多的免费及商业化的工具可提供便利(如补全等):

交互式解释器,#python,在命令行下直接启动python,显示信息取决于程序版本及OS等,交互式模式下的程序执行完后不能难以再次运行;

python程序文件,将编写的程序保存为.py文件,方便多次运行

 

程序文件结构,可将函数单独放在一文件中,python的类包含了一系列预编写好的语句的程序文件,称作模块,能直接运行的模块文件通常称作脚本,即程序的顶层文件,python的模块类似shell中的functionshell中的function不能单独运行,要通过脚本(程序的顶层文件)中语句作为入口调用才能执行)

python的程序文件,源文件通常以.py为扩展名,第一行为魔数shebang,执行脚本时通知要启动的解释器,紧接着导入模块或变量赋值,如:

#vim firstpycode.py

#!/usr/bin/python

import platform

print platform.uname()

#chmod +x firstpycode.py

#./firstpycode.py

注:魔数shebang,在系统中任何程序要能运行通常要表现为进程,进程想启动要向内核注册,由kernel给它生成进程描述结构task_struct,进程才能运行,内核必须要理解这是个可执行程序,按可执行程序内部的各种结构以了解其执行程序入口,内核将执行程序入口放在CPU上内核退出程序执行,kernel通过读取第一行内容的代码就知道以下的这些代码不能直接在CPU上运行而要调用python程序把之后的代码当作参数来执行,如同JVM运行指令时看到的是JAVA进程而不是具体的命令

 

python程序文件可分解成模块、语句、表达式、对象:

程序由模块构成;模块包含语句;语句包含表达式;表达式建立并处理对象

注:表达式是“某事”,而语句是“做某事”即指令,如1+2是“某事”,而print1+2是“做某事”;语句的特性,它们改变了事物,如赋值语句改变了变量,print语句改变了屏幕输出;在shell中变量是命名的内存空间,而在python中一切皆对象,对象在内存空间通过引用方式实现

 

pythonIDE

IDLE,标准python环境提供;EclipsePyDevPython WinKomodoWingwarePycharm

 

python程序设计,面向过程、面向对象:

面向过程,以指令为中心,以指令处理数据,如何组织代码解决问题;

面向对象,以数据为中心,所有的处理代码都围绕数据展开,要设计数据结构组织数据,并提供对此类数据所允许处理操作,适用大型复杂程序;先设计类由类进行实例化后,对象间互相操作完成程序执行过程

 

若要安装更高版本的python,注意系统自带的低版本的不能卸载,系统运行要用到

readline-devel(用于交互模式的程序控制,如删除字符);sqlite-devel(实现历史命令保存);ipython(使得使用python更便捷,如自动补全、错误输出提示、格式化输出等等)

注:ipython 是一个 python 的交互式 shell,比默认的python shell 好用得多,支持变量自动补全,自动缩近,支持 bash shell 命令,内置了许多很有用的功能和函数。在ubuntu 下只要 sudo apt-getinstall ipython 就装好了,通过 ipython 启动。 IPython  Python 的原生交互式 shell 的增强版,可以完成许多不同寻常的任务,比如帮助实现并行化计算;我主要使用它提供的交互性帮助,比如代码着色、改进了的命令行回调、制表符完成、宏功能以及改进了的交互式帮助。3.x 将会是 IPython 最后一个统一庞大的发布版本,下一个发布周期(4.0)会把日益增长的项目分离成 Python 特定语言组件和语言无关组件。语言无关项目(notebook,qtconsole,etc.) 将会归于新项目 Jupyter,而 Python 特定语言项目 (interactive Python shell,Python kernel, IPython.parallel) 将会继续留在 IPython,而且会被分离成几个更小的包。notebook 的图标已经换成了 Jupyter 的图标。

 

[root@localhost ~]# yum -y install zlib-devel bzip2-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel

[root@localhost ~]# tar xf Python-2.7.6.tgz

[root@localhost ~]# cd Python-2.7.6

[root@localhost Python-2.7.6]# ./configure --help | less

--enable-profiling(代码剖析enable C-level code profiling

--enable-unicode[=ucs[24]] Enable Unicode strings (default isucs2)

--with(out)-threads[=DIRECTORY]disable/enable thread supportpython的两种线程库

--with(out)-thread[=DIRECTORY]deprecated; use --with(out)-threads

[root@localhost Python-2.7.6]# ./configure --prefix=/usr/local/python2.7/

[root@localhost Python-2.7.6]# make && make install

[root@localhost Python-2.7.6]# ln -sv /usr/local/python2.7/bin/python2

python2           python2.7         python2.7-config  python2-config   

[root@localhost Python-2.7.6]# ln -sv /usr/local/python2.7/bin/python2.7 /usr/bin/python2.7

`/usr/bin/python2.7' ->`/usr/local/python2.7/bin/python2.7'

[root@localhost Python-2.7.6]# python2.7

Python 2.7.6 (default, Jun  5 2016, 21:35:23)

[GCC 4.4.7 20120313 (Red Hat 4.4.7-4)] onlinux2

Type "help","copyright", "credits" or "license" for moreinformation.

>>> 

>>> exit()

[root@localhost Python-2.7.6]# cd

 

[root@localhost ~]# tar xf ipython-3.0.0.tar.gz

[root@localhost ~]# cd ipython-3.0.0

[root@localhost ipython-3.0.0]# python2.7 setup.py install

[root@localhost ipython-3.0.0]# ln -sv /usr/local/python2.7/bin/ipython /usr/bin/

`/usr/bin/ipython' ->`/usr/local/python2.7/bin/ipython'

[root@localhost ipython-3.0.0]# ipython

Python 2.7.6 (default, Jun  5 2016, 21:35:23)

Type "copyright","credits" or "license" for more information.

 

IPython 3.0.0 -- An enhanced InteractivePython.

?        -> Introduction and overview of IPython's features.

%quickref -> Quick reference.

help     -> Python's own help system.

object?  -> Details about 'object', use 'object??' for extra details.

 

In [1]:

In [1]: exit()

[root@localhost ipython-3.0.0]# ls

build       docs      IPython   README.rst setupbase.py   setupegg.py  setup.py

COPYING.rst examples  PKG-INFO  scripts    setupbase.pyc  setupext

 

In [2]: import platform

In [3]: print platform.uname()

In [4]: dir(platform)   (获取platform内置的属性和方法(函数))

Out[4]:

['DEV_NULL',

 '__builtins__',

 '__copyright__',

 '__doc__',

 '__file__',

 '__name__',

 '__package__',

 '__version__',

 '_abspath',

 '_architecture_split',

 '_bcd2str',

 '_default_architecture',

 '_dist_try_harder',

 '_follow_symlinks',

……

In [5]: print platform.uname(得到内存地址,uname不是属性而是方法,方法需要调用,要用到小括号,而查看类中的属性时不需要调用)

<function uname at 0x1f82848>

In [6]: print platform.uname()

('Linux', 'localhost.localdomain','2.6.32-431.el6.x86_64', '#1 SMP Sun Nov 10 22:19:54 EST 2013', 'x86_64','x86_64')

In [7]: platform.<TAB>  (得到所有属性和方法)

platform.DEV_NULL               platform.platform               platform.re

platform.architecture           platform.popen                  platform.release

platform.dist                   platform.processor              platform.string

platform.java_ver               platform.python_branch          platform.sys

platform.libc_ver               platform.python_build           platform.system

platform.linux_distribution     platform.python_compiler        platform.system_alias

platform.mac_ver               platform.python_implementation platform.uname

platform.machine                platform.python_revision        platform.version

platform.node                   platform.python_version         platform.win32_ver

platform.os                    platform.python_version_tuple

 

数据结构,通过某种方式(如对元素进行编号)组织在一起的数据元素的集合,这些数据元素可以是数据或字符,甚至可以是其它的数据结构;

python的最基本的数据结构是序列sequence;序列中的每个元素被分配一个序号即元素的位置,亦称索引;

python包含6种内建的数据序列(listtuplestringunicode字符串、buffer对象、xrange对象)

程序=数据结构+算法

 

python的关键要素:

基本数据类型、对象引用(变量)、组合数据类型、逻辑操作符、控制流语句、算术操作符、输入/输出、函数的创建与调用

 

基本数据类型(数值、字符、布尔,任何程序语言都必须能够表示基本数据项):

intInteger类型(整型,不可变类型);

float,浮点类型(浮点数、复数、十进制数字);

字符串(是序列,不可变类型,可用name[1]搜索并查询,python中的所有字符串都要用引号,单双引号不区别,数值不需要引号);

bool,布尔型,TrueFalse不能加引号

 

对象引用:

python将所有数据存为内存对象,python中变量事实上是指向内存对象的引用;

动态类型(在任何时候只要需要,某个对象引用都可重新引用一个不同的对象,可以是不同的数据类型);

内建函数(type(),用于返回给定数据项的数据类型);

=用于将变量名与内存中的某对象绑定,如果对象事先存在就直接进行绑定,否则会在内存中创建=后引用的对象;

python中变量和数据是分开存放的,变量名是个指针指向了数据的内存空间,与JAVA类似,各内存对象在不被引用时会自动的由GC回收;

变量命名规则(只能包含字母、数字、下划线_,且不能以数字开头,区分字母大小写,禁止使用保留字,系统中的关键字即为保留字,如ifforwhile等等);

命名惯例(以单一下划线开始的变量名不会被from MODULE import *导入,如_x;前后有双下划线的变量名是系统定义的变量名,对python解释器有重要意义,如__x__print a+b解释器会将运算转为内置的方法调用print a__add__(b);仅以双下划线开头的变量名是类的本地变量,如__x;交互式模式下,变量名为“_”用于保存最后表达式的结果);

In [7]: 1+1

Out[7]: 2

In [8]: print _

2

 

变量名没有类型,对象才有,变量名都是以标签形式指向对象,是变量名引用的对象;变量分可变类型和不可变类型,整型、字符串是不可变类型

交互式模式下,表达式可直接执行,如;

In [9]:name='tom'

In [10]:type(name)

Out[10]:str

In [11]:name=3.14

In [12]:type(name)

Out[12]:float

 

组合数据类型:

序列类型(listtuplestringlist是可变类型,可原处修改(在内存的存储位置处直接修改),tuplestring是不可变类型);

集合类型(集合set);

映射类型(dict字典,是可变类型)

In [13]:l1=['this','is','a','sheep']

In [14]:l1[0][1]

Out[14]:'h'

In [15]:id(l1)   (该变量所指向的内存地址)

Out[15]:38673656

In [16]:l1[3]

Out[16]:'sheep'

In [17]:id(l1)

Out[17]:38673656

In [18]:print l1

['this','is', 'a', 'sheep']

In [19]: l1[3]='tom'  (支持原处修改)

In [20]: print l1

['this', 'is', 'a', 'tom']

In [21]: name='jerry'

In [22]: name[0:4:2]  (切片,会创建新的对象,原始内容并不发生改变)

Out[22]: 'jr'

列表是可变序列,元组是不可变序列,listtuplestring是有大小的,长度可用len()得出元素个数;

python中组合数据类型也是对象,可以嵌套,如['hello','world',[1,2,3]]

实质上listtuple并不真正存储数据,而是存放对象引用;

python对象(同一类或同一种数据结构)可具有共同可被调用的特定方法(函数)

 

逻辑操作符(逻辑运算是任何程序设计语言的基本功能):

身份操作符is(判定左边对象引用是否相同于右边对象引用,也可与None比对);

比较操作符<,>,<=,>=,!=,==

成员操作符in,not in

逻辑运算符and,or,not

In [23]: name='jerry'

In [24]: test='jerry'

In [25]: name is test

Out[25]: True

In [26]: test='tom'

In [27]: name is test

Out[27]: False

 

控制流语句:if,while,for...in..,try...except

 

算术操作符:

使用增强赋值操作符,性能要好,+=,-=,%=pythonint类型不可变,增强型赋值的实际过程是创建了一个新的对象来存储结果再将变量名进行绑定,所以性能要好;

 

输入/输出:

现实中,具有实际功能的程序必须能够从键盘或文件读取输入,产生输出并写至终端或文件中;

input()raw_input()printpython2.*中是print语句,python3.*中是print()函数)

python解释器提供了3种标准文件对象,分别为标准输入stdin、标准输出stdout、标准错误stderr,在sys模块中分别以sys.stdinsys.stdoutsys.stderr形式提供;

print语句实现打印(一个对程序员友好的标准输出流接口);

从技术角度讲,print是把一个或多个对象转换为其文本表达形式,然后发送给标准输出或另一个类似文件的流,在python中打印和文件和流的概念联系紧密,文件写入方法是把字符串写入到任意文件,print默认把对象打印到stdout流,并添加了一些自动的格式化;实质上print语句是python人性化特性的具体实现,它提供了sys.stdout.write()的简单接口,再加上一些默认的格式化设置,print接受一个逗号分隔的对象列表,并为行尾自动添加一个换行符,如果不需要,则在最后元素后添加逗号

print'string %format1 %format2...'  %(variable1,variable2,...)  (显示的效果由%format1决定,与变量无关)

常用的格式化符号:

s(字符串或任意对象,格式化代码使用str()生成字符串)

d,i(十进制整数或长整数)

u(无符号整数或长整数)

o(八进制整数或长整数)

x(十六进制整数或长整数)

X(十六进制整数)

f(浮点数,如[-]m.dddddd

e(浮点数,如[-]m.dddddde+-xx

E(浮点数,如[-]m.ddddddE+-xx

g,G(指数小于-4或更高精度时使用%e%E,否则使用%f

r(同repr()生成的字符串)

c(单个字符)

%(字面量,显示其本身)

 

%后可使用的修饰符,如果有,则只能按如下顺序:

%[(name)][flags][width][.precision]tpecode

其中(name)dict类型有关,位于括号中的一个属于后面的字典的key名,用于选出一个具体项,dict中的key可以是字符也可以是数字,但在格式化输出引用时要用字符串;

其中flags中有,-表示左对齐,默认是右对齐;+表示包含数字符号,正数带此符号;0表示一个0填充;

width指定最小宽度的数字;

.precision用于按照精度侵害字段的宽度,一个数字,指定要打印字符串的最大字符个数,浮点数中小数点之后的位数或整数的最小位数

举例:

In [28]:d={'x':23,'y':3.14159,'z':47}  

In [29]:print '%(x)-10d %(y)0.3g' % d

23         3.14

 

函数的创建与引用:

函数是实现模块化编程的基本组件;

python使用def定义函数,def语句创建一个函数对象,并同时创建一个指向函数的对象引用;

函数可以参数化,通过传递不同的参数来调用;

每个python函数都有一个返回值,默认为None,也可使用return VALUE明确定义返回值;

函数也是对象,可存储在组合数据类型中,也可作为参数传递给其它函数;

callable()可用于测试函数是否可调用;

In [30]: def testFunc(arg1):

  ....:     print arg1

  ....:    

In [31]: callable(testFunc)  (测试某对象是否可调用)

Out[31]: True

注:惯例:函数名中第一个单词的第一个字母小写,后面的所有单词的首字母均大写;定义类,类名中的每个单词的首字母均大写

 

 

数据类型转换(显式、隐式):

str()repr()format(),完成非字符型数据转为字符;

int()转为整数、float()转为浮点数;

tuple(s)将字符串转为元组、set(s)将字串转为集合、dict(d)创建字典d必须是(key,value)的元组序列、frozenset(s)将字串转为不可变集合、chr(x)将整数转为单个字符、ord(c)将字符转为整数值、hex(x)将整数转为十六进制字串、bin(x)将整数转为二进制字串、oct(x)将整数转为八进制字串;

In [32]: num=7.9

In [33]: type(num)

Out[33]: float

In [34]: test=str(num)    (显式转换)

In [35]: type(test)

Out[35]: str

In [36]: type(num)

Out[36]: float

In [37]: dir(__builtins__)   (同__builtin__python启动时导入的内建模块,如dir(),id(),type(),str(),help(),len(),callable()

Out[37]:

['ArithmeticError',

 'AssertionError',

 'AttributeError',

……

In [38]: print dir(__builtins__)     (这些内建模块都可用help()获取其详细信息)

['ArithmeticError', 'AssertionError', 'AttributeError','BaseException', 'BufferError', 'BytesWarning', 'DeprecationWarning','EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False','FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError','ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'KeyError','KeyboardInterrupt', 'LookupError', 'MemoryError', 'NameError', 'None','NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError','PendingDeprecationWarning', 'ReferenceError', 'RuntimeError', 'RuntimeWarning','StandardError', 'StopIteration', 'SyntaxError', 'SyntaxWarning','SystemError', 'SystemExit', 'TabError', 'True', 'TypeError','UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError','UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning','ValueError', 'Warning', 'ZeroDivisionError', '__IPYTHON__','__IPYTHON__active', '__debug__', '__doc__', '__import__', '__name__','__package__', 'abs', 'all', 'any', 'apply', 'basestring', 'bin', 'bool','buffer', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'cmp','coerce', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict','dir', 'divmod', 'dreload', 'enumerate', 'eval', 'execfile', 'file', 'filter','float', 'format', 'frozenset', 'get_ipython', 'getattr', 'globals', 'hasattr','hash', 'help', 'hex', 'id', 'input', 'int', 'intern', 'isinstance','issubclass', 'iter', 'len', 'license', 'list', 'locals', 'long', 'map', 'max','memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print','property', 'range', 'raw_input', 'reduce', 'reload', 'repr', 'reversed','round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum','super', 'tuple', 'type', 'unichr', 'unicode', 'vars', 'xrange', 'zip']

In [39]: help(str)

……

In [40]: name='tom'

In [41]: name.<TAB>  namestr类,一个类所接受的操作方法,决定了类实例化后所支持的操作或运算)

name.capitalize  name.find        name.isspace     name.partition   name.rstrip      name.translate

name.center      name.format      name.istitle     name.replace     name.split       name.upper

name.count       name.index       name.isupper     name.rfind       name.splitlines  name.zfill

name.decode      name.isalnum     name.join        name.rindex      name.startswith 

name.encode      name.isalpha     name.ljust       name.rjust       name.strip      

name.endswith    name.isdigit     name.lower       name.rpartition  name.swapcase   

name.expandtabs  name.islower     name.lstrip      name.rsplit      name.title      

In [41]: name.upper()  upperstr类的方法,将方法施加在name所引用的字符串上)

Out[41]: 'TOM'

In [42]: dir()

Out[42]:

['In',

 'Out',

 '_',

 '_10',

 '_12',

……

In [43]: print dir()

['In', 'Out', '_', '_10', '_12', '_14','_15', '_16', '_17', '_22', '_25', '_27', '_31', '_33', '_35', '_36', '_37','_4', '_41', '_42', '_7', '__', '___', '__builtin__', '__builtins__','__doc__', '__name__', '__package__', '_dh', '_i', '_i1', '_i10', '_i11','_i12', '_i13', '_i14', '_i15', '_i16', '_i17', '_i18', '_i19', '_i2', '_i20','_i21', '_i22', '_i23', '_i24', '_i25', '_i26', '_i27', '_i28', '_i29', '_i3','_i30', '_i31', '_i32', '_i33', '_i34', '_i35', '_i36', '_i37', '_i38', '_i39','_i4', '_i40', '_i41', '_i42', '_i43', '_i5', '_i6', '_i7', '_i8', '_i9','_ih', '_ii', '_iii', '_oh', '_sh', 'd', 'exit', 'get_ipython', 'l1', 'name','num', 'platform', 'quit', 'test', 'testFunc']

In [44]: testFunc('hello world')  (相当于testFunc.__call__('hello world'),调用函数,小括号()表示对可调用对象的调用,所有可调用对象内部有一个方法叫call,非函数的类型是没有的)

hello world

In [45]: name='tony'

In [46]: name()  (不可调用对象,报错如下)

---------------------------------------------------------------------------

TypeError                                 Traceback(most recent call last)

<ipython-input-46-23d722c1bae6> in<module>()

----> 1 name()

TypeError: 'str' objectis not callable

注:任何一个对象的内置方法决定了它所能参与的运算,()就是一种调用运算符,python标准库中有200多个内置模块,这些模块拥有大量函数,python模块实际上就是包含python代码的.py文件,其拥有自定义的函数与类及变量等;import MODULE用于导入模块,不加文件扩展名.py,导入模块后可访问其内部包含的任意函数、类及变量

In [47]: import random

In [48]:x=random.choice(['a','b','c','d','e','f','g'])

In [49]: print x

e

In [50]: print x

e

注:import类似shell中的source,使用模块时MODULE.FUNC,用from MODULE import FUNC,这样可直接用函数名,若直接用函数名可能与其它模块中的函数冲突(新的会覆盖旧的)

 

 

python编程风格,语句和语法:

#(注释,可以在一行的任意地方开始,既不要缺少注释,也要避免过渡注释);

\(续行,转义符);

__doc__(文档,python允许通过__doc__动态获得文档字串,如print str.__doc__);

''' '''""" """(多行注释,闭合操作符,续行(单一语句跨多行));

代码组(缩进统一使用4个空格,缩进相同的一组语句构成一个代码块,首行以关键字开始,如ifwhile等,以冒号结束;python使用缩进来分隔代码组,同一代码组的代码行必须严格左对齐,否则语法错误;同一行放置的多个语句可以分号作为分隔符,但不建议这么做;.pycbytecode文件在程序执行完后会自动删除,若是模块被导入则不会删除);

模块(每一个python脚本文件都可被当成是一个模块;模块里的代码可以是一段直接执行的脚本,也可以是一些类似库的函数从而可由别的模块导入);

标识符(是计算机编程语言中允许作为名字的有效字符串集合,由字母、数字、下划线组成且第一个字符不能是数字,区分大小写,不能使用保留字(或称关键字,它们是语言的标识符,不能用于其它用途),标识符要做到见名知义);

注:python内建的标识符集合,尽量避免使用这些特别的名字,如:from,True,False,None,is,and,not,in,for,if,elif,else,while,def,return,lambda,class,try,except,finally,raise,break,continue,nonlocal,global,with,as,yield,assert,import,pass

参考googlepython风格指南

 

python文件结构:

[root@localhost ~]# vim example.py

#!/usr/bin/env python  #(起始行,此种方式更灵活,同一OS可多个python版本共存,通过PYTHONENV设置当前版本)

#

"this is a test module"  #(模块文档,docstring,若跨行要用三引号)

import sys    #(模块导入)

import os

debug='True'   #(全局变量定义,相对于当前程序而言是全局)

class FooClass(object):  #(类定义,自定义的类,是用特定结构组织了数据,如内置的str类、int类等,类中有对数据操作的方法)

       "Foo Class"

       pass

def test():   #(函数定义)

       "test function"

       foo=FooClass()

       if debug:

                print 'run test()'

if __name__=='__main__':    #(主程序)

       test()

[root@localhost ~]# chmod +x example.py

 

python文件主程序:

无论当前模块是被导入还是作为脚本直接执行,都会执行主程序这部分代码;所有的模块都有能力执行代码;

最高级别的python语句(没有缩进,顶格写的),在模块被导入时就会执行,无论是否真的需要执行;妥当的做法,除那些真正需要执行的代码以外,所有的功能代码都通过函数建立,因此,仅在主程序中编写大量的顶级的可执行代码,用于被导入的模块只应该存在较少的顶级执行代码);

__name__指示模块如何被加载,如果模块是被导入__name__的值是模块名字,如果模块是直接执行__name__的值是__main__

每个模块都有一个名为__name__的内建变量,此变量会根据调用此模块的方式发生变化,如果此文件被作为模块导入__name__的值为模块名称,如果文件被直接执行则__name__的值为__main__

 

python对象类型及运算:

python程序中保存的所有数据都是围绕对象这个概念展开的,程序中存储的所有数据都是对象;

每个对象都有一个身份(id(),在内在中的具体位置)、一个类型(type())、一个值,如school='magedu'会以magedu创建一个字符串对象,其身份是指向它在内存中所处位置的指针(内存地址),而school就是引用这个具体位置的名称;

对象的类型也称对象的类别,用于描述对象的内部表示及它支持的方法和操作,对象的类型决定了它所支持的方法和操作,某一对象一旦创建出来,它所支持或适用的方法就确定了;

创建特定类型的对象时,有时也将该对象称为该类型的实例;

实例被创建后,其身份和类型就不可改变,若对象的值可修改的称为可变对象,若对象的值不可修改则称为不可变对象;

如果某个对象包含其它对象的引用,则称其为容器;

大多数对象都拥有大量特有的数据属性(与对象相关的值)和方法(被调用时将在对象上执行某些操作的函数),使用点.运算符可访问属性和方法,访问属性时点号后跟属性名即可,访问方法点号后跟方法还要跟小括号表示调用;

=数据(变量)+方法(函数),一般讲,方法是公共的,而数据是私有的,class自定义类型时使用,type查看内置类,instance实例化;

对象的身份与类型,python内置函数id()可返回一个对象的身份,即该对象在内存中的位置;

两个对象比较:

is运算符,身份比较,用于比较两个对象的身份,id()用于确定是否为同一个对象;

type,类型比较,用于返回一个对象的类型,用于确定是否同属于一个类型;

==值比较,等值比较;

对象类型本身也是一个对象,称为对象的类,该对象的定义是唯一的,且对于某类型的所有实例都是相同的,所有类型对象都有一个指定的名称,可用于执行类型检查,如listdict

In [1]: a=1

In [2]: b=2

In [3]: a is b

Out[3]: False

In [4]: a==b

Out[4]: False

In [5]: type(a) is type(b)

Out[5]: True

 

python核心数据类型:

数字(int,long,float,complex,bool);

字符(str,unicode);

列表(list);

元组(tuple);

字典(dict);

文件(file);

其它类型(set集合,frozenset,类类型,None

 

其它文件类工具(pipesfifossockets

 

In [2]: str1='hello world'

In [3]: l1=list(str1)

In [4]: print l1

['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o','r', 'l', 'd']

In [5]: t1=tuple(str1)

In [6]: print t1

('h', 'e', 'l', 'l', 'o', ' ', 'w', 'o','r', 'l', 'd')

In [7]: s1=set(str1)

In [8]: print s1

set([' ', 'e', 'd', 'h', 'l', 'o', 'r','w'])

In [9]: l1=[('a',1),('b',2),('c',3)]

In [10]: d1=dict(l1)   (使用dict创建字典,l1必须是列表它里面包含的是分别由两元素组成的元组,每单个元组是这个列表的元素)

In [11]: print d1

{'a': 1, 'c': 3, 'b': 2}

In [12]: f1=frozenset(str1)

In [13]: print f1

frozenset([' ', 'e', 'd', 'h', 'l', 'o','r', 'w'])

In [14]: chr(5)

Out[14]: '\x05'

In [15]: c1=chr(5)

In [16]: print c1

In [17]: type(c1)

Out[17]: str

In [18]: str1='45'

In [19]: num1=ord(str1)

---------------------------------------------------------------------------

TypeError                                 Traceback(most recent call last)

<ipython-input-19-1414c93a330e> in<module>()

----> 1 num1=ord(str1)

TypeError: ord() expected a character, butstring of length 2 found

In [20]: ord(c1)

Out[20]: 5

In [21]: hex(88)

Out[21]: '0x58'

In [22]: bin(88)

Out[22]: '0b1011000'

In [23]: oct(88)

Out[23]: '0130'

 

数字类型操作:

python5种数字类型(bool布尔型、int整型、长整型、浮点型、complex复数),所有数字类型均为不可变类型,python的数字字面量(boolTrue1False0;整数;浮点数;复数);

算术运算(+,-,*,/,//截断除法,**乘方,%,-x一元减法,+x一元加法);

比较运算(<<左移(使数字变大),>>右移,&按位与,|按位或,^按位异或,~x按位求反);

In [24]: import math  (用来实现高级数学运算)

In [25]: math.

math.acos       math.atanh      math.e          math.factorial  math.hypot     math.log10      math.sin

math.acosh      math.ceil       math.erf        math.floor      math.isinf      math.log1p      math.sinh

math.asin       math.copysign   math.erfc       math.fmod       math.isnan      math.modf       math.sqrt

math.asinh      math.cos        math.exp        math.frexp      math.ldexp      math.pi         math.tan

math.atan       math.cosh       math.expm1      math.fsum       math.lgamma     math.pow        math.tanh

math.atan2      math.degrees    math.fabs       math.gamma      math.log        math.radians    math.trunc

 

序列sequence类型:

序列表示索引为非负整数的有序对象集合,包括:字符串、列表、元组;

字符串是字符的,列表和元组是任意python对象的序列;

字符和元组是不可变序列,列表是可变序列(支持插入、删除、替换等原处修改),所有序列都支持迭代;

字符串字面量,把文本放入单引号、双引号、三引号之中,若要使用unicode编码,需在字符串之前加u进行标识,如u'magedu'

In [1]: str1=u'hello world'  (在字符串引号前加u表示支持unicode编码,python3.X已支持此项不需加u

In [2]: type(str1)

Out[2]: unicode

docstring文档字符串,模块、类、函数的第一条语句是一段字符的话,该段字符串就成为文档字符串,可用__doc__属性引用;

In [3]: def printName():

  ...:     "test function"

  ...:     print 'hello magedu'

  ...:    

In [4]: printName.__doc__

Out[4]: 'test function'

适用所有序列的操作和方法:

s[i](索引运算符)

s[i:j](切片运算符,切片后的结果会生成新的对象,支持负索引,正负索引之和为字串长度len(s)

s[i:j:stride](扩展切片运算符,stride为步长)

min(s),max(s)(只适用于能对序列中的元素排序的序列,若是字符是按ASCII码表中的次序)

sum(s)(只适用于数字序列)

all(s)(检查s中所有项是否为True

any(s)(检查s中任意项是否为True

序列类型支持的操作符:

s+r(连接);

s*N,N*s(制作sN个副本);

v1,v2,v3,...,vn=s(变量解包unpack);

s[i](索引);

s[i:j](切片);

s[i:j:stride](扩展切片);

x in s,x not in s(从属关系判断);

for x in s:(迭代);

all(s)(如果s中的所有项都为True则返回True);

any(s)(如果s中的任意项为True则返回True);

len(s)(长度);

min(s),max(s)

sum(s[,initial])(具有可选初始值的项的和);

适用于可变序列的操作:

s[i]=VALUE(项目赋值)

s[i:j]=TUPLE(切片赋值)

s[i:j:stride]=TUPLE(扩展切片赋值)

del s[i](项目删除)

del s[i:j](切片删除)

del s[i:j:stride](扩展切片删除)

适用于字符串str的操作和方法:

python2提供2种字符串对象类型(字节字符串,字节序列,8bit数据;unicode字符串,unicode字符序列,16bit数据;python可用32bit整数保存unicode字符,但此为可选特性);

help(str.METHOD)

dir(str)

In [47]: print dir(str)

['__add__', '__class__', '__contains__','__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__','__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__','__init__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__','__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__','__setattr__', '__sizeof__', '__str__', '__subclasshook__','_formatter_field_name_split', '_formatter_parser','capitalize', 'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs','find', 'format', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower','isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip','partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit','rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title','translate', 'upper', 'zfill']

s.capitalize()(首字母变大写)

s.index(sub[,start[,end]])(找到指定子字符串sub首次出现的位置,否则报错)

s.join(t)(使用s作为分隔符连接序列t中的字符串,如'_'join(str1)

s.lower()(转小写)

s.upper()(转大写)

s.replace(old,new[,maxreplace])(替换一个子字符串)

s.split([sep[,maxsplit]])(使用sep作为分隔符对一个字符串进行划分,maxsplit是划分的最大次数)

s.strip([chrs])(删除chrs开头和结尾的空白或字符)

可用于列表list的操作和方法:

列表(容器类型,任意对象的有序集合,通过索引访问其中的元素,可变对象,异构(任意数据类型),支持原处修改,修改指定的索引元素,修改指定的分片,删除语句,内置方法);

list(s)(可将任意可迭代类型转换为列表,如果s已经是一个列表,则该函数构造的新列表是s的一个浅复制);

In [46]: print dir(list)

['__add__', '__class__', '__contains__','__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__','__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__','__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__','__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__','__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__','__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop','remove', 'reverse', 'sort']

s.append(x)(将一个新元素x追加到列表s末尾);

s.extend(x)(将一个新列表追加到列表s末尾);

s.count(x)(计算列表sx出现的次数);

s.index(x,[start[,stop]])(当s[i]==x.start时返回最小的i,可选参数stop用于指定搜索的起始和结束索引);

s.insert(i,x)(在索引i处插入x);

s.pop([i])(删除索引i对应的元素并弹出该元素,若省略i则删除并弹出最后一个元素);

s.remove(x)(搜索x并从列表s中移除它);

s.reverse()(在原处反向排序列表s中的所有元素,reversesort操作后不返回结果,查看要用print语句);

s.sort([key[,reverse]])(在原处对列表s中的所有元素进行排序,key是一个键函数,reverse是一个标志表示以倒序对列表进行排序,keyreverse应该始终以关键字函数的形式指定);

l1+l2(合并两个列表,返回一个新列表,不会修改原列表);

l1*N(把l1重复N次,返回新列表);

in,not in(成员关系判断用,用法item in container);

列表解析:[elem*2for elem in l1]

列表复制的两种方式:方式一l2=l1[:];方式二l2=copy.deepcopy(l1)

s[i]=x(索引实现赋值);

s[i:j]=r(切片赋值);

s[i:j:stride]=r(扩展切片赋值);

del s[i](删除一个元素);

del s[i:j](删除一个切片);

del s[i:j:stride](删除一个扩展切片);

元组tuple的操作(同列表):

元组(容器类型,任意对象的有序集合,通过索引访问其中的元素,不可变对象,长度固定,异构,嵌套);

In [45]: print dir(tuple)

['__add__', '__class__', '__contains__','__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__','__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__','__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__','__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__','__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']

t1+t4(合并两元组);

t1*N(重复);

t1=('x',[1,2,3])(元组本身是不可变对象,但元组中的某元素是可变的那最终也是可变的);

t1[1].pop()

字典dict支持的操作和方法:

字典在其它编程语言中又称作关联数组或散列表,通过key实现元素存取,无序集合,可变类型容器,长度可变,异构,嵌套;

In [48]: print dir(dict)

['__class__', '__cmp__', '__contains__','__delattr__', '__delitem__', '__doc__', '__eq__', '__format__', '__ge__','__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__','__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__','__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__','__str__', '__subclasshook__', 'clear', 'copy','fromkeys', 'get', 'has_key', 'items', 'iteritems', 'iterkeys', 'itervalues','keys', 'pop', 'popitem', 'setdefault', 'update', 'values', 'viewitems','viewkeys', 'viewvalues']

字典复制d2=d1.copy()

d1.get('x')等同于d1['x'](当key所对应的value存在时这两种方式得到的结果一样,当key所对应的value不存在,使用get返回空,而用下标引用的方式会抛出异常);

d1.items()(返回key,value的元组列表,把keyvalue拆为元组,所有元组构成列表);

d2={}.fromkeys(l1,0)(可将列表l1的元素生成字典d2 keyd2value全为0);

t1,t2=d1.items()(变量解包,两边要有相同的数量);

d1.keys()(返回key的列表);

d1.values()(返回value的列表);

d1.pop('x)(删除并弹出key所对应的value);

d1.popitem()(随机删除并弹出key所对应的value);

d1.update(d2)(类似列表的extend方法,将一个字典添加至当前字典,若有key重复新值会覆盖当前值);

i1=d1.iteritems()(返回迭代器对象,可用i1.next()遍历对象的每个元素,全部返回即结束不会再次从头返回,若用i1.next不加小括号返回的是对象的身份,加小括号是调用其方法);

i2=d1.iterkeys()i2.next());

i3=d1.itervalues()i3.next());

d1.viewitems()(显示字典的定义方式);

d2=dict(name='jerry',age=18,gender='M')(可用此种方式创建字典);

d3=dict(zip('xyz','123'))(可用此种方式创建字典,zip分别将两组序列中的元素一一对应生成元组组成的列表)

d2.viewkeys()

d2.viewvalues()

d2.viewitems()

注:help(dict)

class dict(object)

 | dict() -> new empty dictionary

 | dict(mapping) -> new dictionary initialized from a mapping object's

 |     (key, value) pairs

 | dict(iterable) -> new dictionary initialized as if via:

 |      d= {}

 |     for k, v in iterable:

 |         d[k] = v

 | dict(**kwargs) -> new dictionary initialized with the name=valuepairs

 |     in the keyword argument list.  Forexample:  dict(one=1, two=2)

注:help(zip)

zip(...)

   zip(seq1 [, seq2 [...]]) -> [(seq1[0], seq2[0] ...), (...)]

集合set的操作和方法:

set集合(无序排列的可hash的值,支持集合关系测试,支持成员关系测试,迭代,不支持index、元素获取、切片,没有特定语法格式,只能通过工厂函数创建;集合的类型:set()可变,frozenset()不可变);

In [8]: print dir(set)

['__and__', '__class__', '__cmp__','__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__','__getattribute__', '__gt__', '__hash__', '__iand__', '__init__', '__ior__','__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__','__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__','__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__','__sub__', '__subclasshook__', '__xor__', 'add','clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection','intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove','symmetric_difference', 'symmetric_difference_update', 'union', 'update']

In [24]: print dir(frozenset)

['__and__', '__class__', '__cmp__','__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__','__getattribute__', '__gt__', '__hash__', '__init__', '__iter__', '__le__','__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__','__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__','__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'copy', 'difference', 'intersection', 'isdisjoint','issubset', 'issuperset', 'symmetric_difference', 'union']

len(s)(返回集合s中的项目数);

s.copy()(制作s的副本);

s.difference(t)(求差集,返回所有在s中,但不在t中的项目);

s.intersection(t)(求交集,返回所有同时在st中的项目);

s.isdisjoint(t)(如果st没有相同项则返回True);

s.issubset(t)(如果st的一个子集则返回True);

s.issuperset(t)(如果st的一个超集则返回True);

s.symmetric_difference(t)(求对称差集,返回所有在st中,但又不同时在这两个集合中的项);

s.union(t)(求并集,返回所有在st中的项);

集合类型的操作符:

s | tst的并集,同s.union(t));

s & tst的交集,同s.intersection(t));

s - t(求差集,同s.difference(t));

s ^ t(求对称差集,同s.symmetric_difference(t));

max(s),min(s)

 

In [1]: s1=set([1,2,3])

In [2]: print s1

set([1, 2, 3])

In [3]: s2=set([2,3,4])

In [4]: s1 & s2

Out[4]: {2, 3}

In [5]: s1.intersection(s2)   (交集)

Out[5]: {2, 3}

In [6]: s1.symmetric_difference(s2)   symmetric对称)

Out[6]: {1, 4}

In [7]: s1|s2

Out[7]: {1, 2, 3, 4}

In [9]: s3=set('xyz')

In [10]: s3.pop()   (随机删除一个元素)

Out[10]: 'y'

In [11]: s1 | s2

Out[11]: {1, 2, 3, 4}

In [12]: s1 & s2

Out[12]: {2, 3}

In [13]: s1 - s2

Out[13]: {1}

In [14]: s1.difference(s2)

Out[14]: {1}

In [15]: s1 ^ s2

Out[15]: {1, 4}

In [16]: max(s1)

Out[16]: 3

In [17]: min(s2)

Out[17]: 2

In [18]: id(s1)

Out[18]: 39064560

In [19]: s1.update(s2)

In [20]: print s1

set([1, 2, 3, 4])

In [21]: id(s1)

Out[21]: 39064560

In [22]: s1.add(5)

In [23]: print s1

set([1, 2, 3, 4, 5])

 

 

总结:

可变对象(list,dict,set);

不可变对象(数值、字串、tuplefrozenset);

对象的三部分(身份id(),类型type(),值);

方法即是某类型支持的操作(支持的调用接口),如3+5转换为3.__add__(5)

类型确定后方法就确定了,不同的类有不同的方法,方法是施加在实例化的对象上;

python中类和类型不加区分,类=数据+方法,类在初始化时作赋值,类要实例化为对象这些对象数据不同称为不同的实例;

在内存中,变量名存储在一个位置,对象存储在另一个位置,变量名只是引用对象,python中变量名没有类型,对象才有,变量名引用了哪种对象则变量名就是哪种类型,当某一对象不被引用或引用计数为0时则该对象在一定时间内可被GC回收;

点运算符两种功能(获取属性和方法;属性即所属某实例的变量名,指定数据则会返回一个数据,要用print语句显示;方法就是类的函数也即支持的操作,获取方法时后面还要加小括号表示调用对象,callable()    查看某对象是否可调用,可调用对象一般为类中的方法);

字串用单引号、双引号、三引号,单双引号不加区分,三引号可跨多行;

列表用[]

元组用()

字典用{}

有闭合符号的里面的内容可直接换行,可不用加换行符,如[],(),{},''' '''

dir(OBJECT),获取对象支持使用的属性和方法,在python自己的交互模式下显示的内容不换行,而ipython将显示更人性化);

某方法的具体使用帮助help(dict.popitem)

获取可调用对象的文档字符串printOBJECT.__doc__

 

容器、类型、对象(列表、元组、字典):

字面量可跨行定义;

所有对象都有引用计数,通过sys.getrefcount(OBJECT)得到引用计数;

列表和字典都支持两种类型的复制操作,分别是浅复制和深复制,浅复制(仅是创建新引用并指向原有对象,当原有对象有修改时则最终是有影响的),深复制(创建新对象的引用并递归创建所有对象,l2=copy.deepcopy(l1)列表深复制,d2=d1.copy()字典深复制);

python可的所有对象都是“第一类”,这意味着使用标识符命名的所有对象(函数是创建的),都具有相同状态,于是,能够命名的所有对象都可以直接当数据进行处理;

所有序列都支持迭代;

所有序列都支持的操作和方法,s[i],s[i:j],s[i:j:stride],len(s),min(s),max(s),sum(s),all(s),any(s)

可变序列的操作,s[index]=value,s1+s2,s1*N,objectin s,object not in s,s[i:j]=t,del s[index],del s[i:j],del s[i:j:stride]

 

In [6]: str1='www.magedu.com'

In [7]: str1[6:0:-1]

Out[7]: 'gam.ww'

In [8]: str1[9:3:-1]

Out[8]: 'udegam'

 

In [1]: str1='www.magedu.com'

In [2]: str1.strip('www')

Out[2]: '.magedu.com'

In [3]: str1.capitalize()

Out[3]: 'Www.magedu.com'

In [4]: str1.index('edu')

Out[4]: 7

In [5]: str1.index('m',5)    (从第5个元素开始向后找)

Out[5]: 13

In [6]: l1=list(str1)

In [7]: print l1

['w', 'w', 'w', '.', 'm', 'a', 'g', 'e','d', 'u', '.', 'c', 'o', 'm']

In [8]: ''.join(l1)

Out[8]: 'www.magedu.com'

In [9]: str1.replace('edu','EDU')

Out[9]: 'www.magEDU.com'

In [10]: str1.split('.')

Out[10]: ['www', 'magedu', 'com']

In [11]: str1.split('e')

Out[11]: ['www.mag', 'du.com']

In [12]: str2='         hello     '

In [13]: str2.strip()

Out[13]: 'hello'

In [14]: id(l1)

Out[14]: 21990144

In [15]: type(l1)

Out[15]: list

In [16]: l1[0:3]=[]

In [17]: print l1

['.', 'm', 'a', 'g', 'e', 'd', 'u', '.','c', 'o', 'm']

In [18]: del l1[0]

In [19]: print l1

['m', 'a', 'g', 'e', 'd', 'u', '.', 'c','o', 'm']

In [20]: del l1[6:]

In [21]: print l1

['m', 'a', 'g', 'e', 'd', 'u']

In [22]: id(l1)    (删除元素后身份标识不会变,即原处修改)

Out[22]: 21990144

In [23]: l1.pop(0)

Out[23]: 'm'

In [24]: print l1

['a', 'g', 'e', 'd', 'u']

In [25]: l1.sort()  (原处修改)

In [26]: print l1

['a', 'd', 'e', 'g', 'u']

In [27]: l1.reverse()   (原处修改)

In [28]: print l1

['u', 'g', 'e', 'd', 'a']

In [29]: l1=[1,2,3]

In [30]: l1[3:]=[4,5,6]   (在切片级别修改并替换元素)

In [31]: print l1

[1, 2, 3, 4, 5, 6]

In [32]: range(6)   (生成器对象)

Out[32]: [0, 1, 2, 3, 4, 5]

In [33]: import copy

In [34]: help(copy.deepcopy)

deepcopy(x, memo=None, _nil=[])

   Deep copy operation on arbitrary Python objects.

In [35]: l2=copy.deepcopy(l1)

In [36]: id(l2)

Out[36]: 22026720

In [37]: id(l1)

Out[37]: 21999984

In [38]: l3=l1[:]

In [39]: id(l3)

Out[39]: 22027152

In [41]: t1=('x',[1,2,3])

In [42]: t1[1].pop()

Out[42]: 3

In [43]: print t1

('x', [1, 2])

 

 

 

list举例:

[root@localhost ~]# vim using_list.py

--------------script start------------------

#!/usr/bin/python

#filename:using_list.py

shoplist=['apple','mango','carrot','banana']

print 'I have',len(shoplist),'items topurchase.'

print 'these items are:',

for item in shoplist:

       print item,

print '\nI also have to buy rice.'

shoplist.append('rice')

print 'My shoplist is now',shoplist

print 'I will sort my list now.'

shoplist.sort()

print 'sorted shopping list is',shoplist

print 'the first item I will buyis',shoplist[0]

olditem=shoplist[0]

del shoplist[0]

print 'I bought the',olditem

print 'my shoplist is now',shoplist

--------------script end-------------------

[root@localhost ~]# python using_list.py

I have 4 items to purchase.

these items are: apple mango carrot banana

I also have to buy rice.

My shoplist is now ['apple', 'mango','carrot', 'banana', 'rice']

I will sort my list now.

sorted shopping list is ['apple', 'banana','carrot', 'mango', 'rice']

the first item I will buy is apple

I bought the apple

my shoplist is now ['banana', 'carrot','mango', 'rice']

 

tuple举例:

[root@localhost ~]# vim using_tuple.py

------------------script start----------------

#!/usr/bin/python

#filename:using_tuple.py

zoo=('wolf','elephant','penguin')

print 'number of animals in he zoois',len(zoo)

new_zoo=('monkey','dolphin',zoo)

print 'number of animals in the new zoois',len(new_zoo)

print 'all animals in the new_zooare',new_zoo

print 'animals brought from old zooare',new_zoo[2]

print 'last animals brought from old zoois',new_zoo[2][2]

---------------script end------------------

[root@localhost ~]# python using_tuple.py

number of animals in he zoo is 3

number of animals in the new zoo is 3

all animals in the new_zoo are ('monkey','dolphin', ('wolf', 'elephant', 'penguin'))

animals brought from old zoo are ('wolf','elephant', 'penguin')

last animals brought from old zoo ispenguin

 

dictionary举例:

[root@localhost ~]# vim using_dictionary.py

-------------------script start--------------

#!/usr/bin/python

#filename:using_dictionary.py

ab={'jowin':'jowin@163.com',

       'xiang':'xiang@qq.com',

       'matsumoto':'matsumoto@ruby-lang.org',

       'spammer':'spammer@hotmail.com'

       }

print "jowin's address is %s" %ab['jowin']

ab['guido']='guido@python.org'

del ab['jowin']

print '\nthere are %d contacts in theaddress-book\n' % len(ab)

for name,address in ab.items():

       print 'contact %s at %s' % (name,address)

if 'guido' in ab:

       print "\nguido's address is %s" % ab['guido']

------------------script end--------------------

[root@localhost ~]# python using_dictionary.py

jowin's address is jowin@163.com

 

there are 4 contacts in the address-book

 

contact matsumoto atmatsumoto@ruby-lang.org

contact xiang at xiang@qq.com

contact spammer at spammer@hotmail.com

contact guido at guido@python.org

 

guido's address is guido@python.org

 

序列(listtuple、字符串都是序列,序列的两个主要特点:索引index操作符(可获得一个特定条目)和切片split操作符(可获得一部分条目))

序列的神奇之处在于可用相同的方法访问tuplelist、字符串

序列举例:

[root@localhost ~]# vim seq.py

------------------script start-------------------

#!/usr/bin/python

#filename:seq.py

shoplist=['apple','mango','carrot','banana']

print 'item 0 is',shoplist[0]

print 'item 3 is',shoplist[3]

print 'item -1 is',shoplist[-1]

print 'item -2 is',shoplist[-2]

print 'item 1 to 3 is',shoplist[1:3]

print 'item 2 to end is',shoplist[2:]

print 'item start to end is',shoplist[:]

name='jowin'

print 'characters 1 to 3 is',name[1:3]

print 'characters 2 to end is',name[2:]

print 'characters start to end is',name[:]

-------------------script end---------------

[root@localhost ~]# python seq.py

item 0 is apple

item 3 is banana

item -1 is banana

item -2 is carrot

item 1 to 3 is ['mango', 'carrot']

item 2 to end is ['carrot', 'banana']

item start to end is ['apple', 'mango','carrot', 'banana']

characters 1 to 3 is ow

characters 2 to end is win

characters start to end is jowin

 

参考(当创建一个对象并给它赋一个变量时,这个变量仅仅参考那个对象,而不是表示这个对象本身,这称作名称到对象的绑定,变量名是指向存储那个对象的内存,若要复制listtuple或类似的序列或其它复杂的对象,必须使用切片操作符,若只是想要使用另一个变量名,两个名称都可参考同一个对象)

注:列表的赋值语句不创建拷贝,得使用切换操作符创建序列的拷贝

参考举例:

[root@localhost ~]# vim reference.py

--------------------script start---------------------

#!/usr/bin/python

#filename:reference.py

print 'simple assignment'

shoplist=['apple','mango','carrot','banana']

mylist=shoplist

del shoplist[0]

print 'shoplist is',shoplist

print 'mylist is',mylist

print 'copy by making a full slice'

mylist=shoplist[:]

del mylist[0]

print 'shoplist is',shoplist

print 'mylist is',mylist

-------------------script end--------------------------

[root@localhost ~]# python reference.py

simple assignment

shoplist is ['mango', 'carrot', 'banana']

mylist is ['mango', 'carrot', 'banana']

copy by making a full slice

shoplist is ['mango', 'carrot', 'banana']

mylist is ['carrot', 'banana']

 

更多字符串内容(字符串也是对象,同样具有方法(可检验一部分字符串,去除空格等各种工作),程序中使用的字符串都是str类的对象)

方法(startswith(测试字符串是否以给定的字符串开始);find(找出给定字符串在另一字符串的位置);'DELIMETER'.join(分隔符字符串join序列可整洁输出))

字符串举例:

[root@localhost ~]# vim str_methods.py

----------------script start--------------------

#!/usr/bin/python

#filename:str_methods.py

name='jowin'

if name.startswith('jow'):

       print 'yes,the string startswith "jow"'

if 'w' in name:

       print 'yes,it conatains the string "w"'

if name.find('win')!=-1:

       print 'yes,it contains the string "win"'

delimeter='_*_'

mylist=['Brazil','Russia','India','China']

print delimeter.join(mylist)

----------------script end---------------------

[root@localhost ~]# python str_methods.py

yes,the string startswith "jow"

yes,it conatains the string "w"

yes,it contains the string "win"

Brazil_*_Russia_*_India_*_China

 

备份脚本举例:

os.sep(会根据OS给出目录分隔符,如linux"/"win"\"mac":",使用os.sep有利于程序移植)

time.strftime('%Y%m%d')(格式化时间输出)

下例给出三个版本,先完成基本功能再逐步优化,还可以进一步优化(可用tar命令的-X选项将某文件排除在外,tar代替zip使备份更快更小;最好使用zipfiletarfile这是python标准库的一部分,不推荐使用os.system函数容易引发严重错误;使用-v使程序更具交互性;sys.argv使文件和目录通过命令行直接传递给脚本)

[root@localhost ~]# vim backup_ver1.py

----------------script start---------------

#!/usr/bin/python

#filename:backup_ver1.py(优化文件名,用日期作为目录名,用时间作为文件名)

import os,time

source=['/home/webgame/houtai','/usr/local/servernd']

target_dir='/backup/'

target=target_dir+time.strftime('%Y%m%d-%H%M%S')+'.zip'

zip_command="zip -qr '%s' %s" %(target,' '.join(source))

if os.system(zip_command)==0:

       print 'successful backup to',target

else:

       print 'backup failed'

-----------------script end----------------

[root@localhost ~]# python backup_ver1.py

successful backup to/backup/20160523-000610.zip

[root@localhost ~]# ll /backup/

total 4

-rw-r--r--. 1 root root 356 May 23 00:06 20160523-000610.zip

 

[root@localhost ~]# vim backup_ver2.py

-----------------script start-----------------

#!/usr/bin/python

#filename:backup_ver2.py

import os,time

source=['/home/webgame/houtai','/usr/local/servernd']

target_dir='/backup/'

today=target_dir+time.strftime('%Y%m%d')

now=time.strftime('%H%M%s')

if not os.path.exists(today):

       os.mkdir(today)

       print 'successfully created directory',today

target=today+os.sep+now+'.zip'

zip_command="zip -qr '%s' %s" %(target,' '.join(source))

if os.system(zip_command)==0:

       print 'successfully backup to',target

else:

       print 'backup failed'

-----------------scritp end----------------

[root@localhost ~]# python backup_ver2.py

successfully created directory/backup/20160523

successfully backup to/backup/20160523/002721.zip

 

[root@localhost ~]# vim backup_ver3.py

----------------script start------------------

#!/usr/bin/python

#filename:backup_ver3.py(优化可添加注释信息)

import os,time

source=['/home/webgame/houtai','/usr/local/servernd']

target_dir='/backup/'

today=target_dir+time.strftime('%Y%m%d')

now=time.strftime('%H%M%S')

comment=raw_input('Enter a comment-->')

if len(comment)==0:

       target=today+os.sep+now+'.zip'

else:

       target=today+os.sep+now+'_'+comment.replace(' ','_')+'.zip'

if not os.path.exists(today):

       os.mkdir(today)

       print 'successfully created directory',today

zip_command='zip -qr "%s" %s' %(target,' '.join(source))

if os.system(zip_command)==0:

       print 'successfully backup to',target

else:

        print 'backup failed'

------------------script end--------------------

[root@localhost ~]# python backup_ver3.py

Enter a comment-->test

successfully backup to/backup/20160523/002950_test.zip



本文转自 chaijowin 51CTO博客,原文链接:http://blog.51cto.com/jowin/1782169,如需转载请自行联系原作者

网友评论

登录后评论
0/500
评论
技术小阿哥
+ 关注