python总结【来自Runoob】

python总结【来自Runoob】

test.py

#!/usr/bin/python

print "Hello, Python!";

$ chmod +x test.py # 脚本文件添加可执行权限

$ ./test.py

标识符

以下划线开头的标识符是有特殊意义的。以单下划线开头 _foo 的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xxx import * 而导入；

以双下划线开头的 __foo 代表类的私有成员；以双下划线开头和结尾的 __foo__ 代表 Python 里特殊方法专用的标识，如 __init__() 代表类的构造函数。

Python 保留字符

下面的列表显示了在Python中的保留字。这些保留字不能用作常数或变数，或任何其他标识符名称。

>>> import keyword

>>> keyword.kwlist

['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

行和缩进

在 Python 的代码块中必须使用相同数目的行首缩进空格数。

建议你在每个缩进层次使用 单个制表符 或 两个空格 或 四个空格 , 切记不能混用

多行语句

Python语句中一般以新行作为为语句的结束符

但是我们可以使用斜杠（ \）将一行的语句分为多行显示

total = item_one + \ item_two + \ item_three

语句中包含 [], {} 或 () 括号就不需要使用多行连接符

Python 引号

Python 可以使用引号( ' )、双引号( " )、三引号( ''' 或 """ ) 来表示字符串，引号的开始与结束必须的相同类型的。其中三引号可以由多行组成，编写多行文本的快捷语法，常用于文档字符串，在文件的特定地点，被当做注释

word = 'word'

sentence = "这是一个句子。"

paragraph = """这是一个段落。

包含了多个语句"""

Python注释

python中单行注释采用 # 开头。

python 中多行注释使用三个单引号(''')或三个双引号(""")。

Python空行

函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。

空行与代码缩进不同，空行并不是Python语法的一部分。书写时不插入空行，Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。

记住：空行也是程序代码的一部分。

等待用户输入

raw_input("\n\nPress the enter key to exit.")

同一行显示多条语句

import sys; x = 'runoob'; sys.stdout.write(x + '\n')

Print 输出

print 默认输出是换行的，如果要实现不换行需要在变量末尾加上逗号

#!/usr/bin/python

# -*- coding: UTF-8 -*-

x="a"

y="b"

# 换行输出

print (x)

print (y)

print '---------'

# 不换行输出

print (x, "  end")

print (y, " end")

多个语句构成代码组

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

像if、while、def和class这样的复合语句，首行以关键字开始，以冒号( : )结束，该行之后的一行或多行代码构成代码组。

我们将首行及后面的代码组称为一个子句(clause)。

if expression : suite

elif expression : suite

else : suite

命令行参数

很多程序可以执行一些操作来查看一些基本信息，Python 可以使用 -h 参数查看各参数帮助信息

#!/usr/bin/python

# -*- coding: UTF-8 -*-

import sys

print sys.argv

#sys.argv 用来获取命令行参数

./test.py hello

['./test.py', 'hello']

sys.argv[0] 代表文件本身路径，所带参数从 sys.argv[1] 开始

#!/usr/bin/env python 会去环境设置寻找 python 目录,推荐这种写法

变量赋值

#!/usr/bin/python

# -*- coding: UTF-8 -*-

counter = 100 # 赋值整型变量

miles = 1000.0 # 浮点型

name = "John" # 字符串

print counter

print miles

print name

多个变量赋值

a = b = c = 1

a, b, c = 1, 2, "john"

标准数据类型

Python有五个标准的数据类型：

Numbers（数字）

String（字符串）

List（列表）

Tuple（元组）

Dictionary（字典）

Python数字

var1 = 1

var2 = 10

del var_a, var_b

Python支持四种不同的数字类型：

int（有符号整型）

long（长整型[也可以代表八进制和十六进制]）

float（浮点型）

complex（复数）

Python使用"L"来显示长整型。

Python还支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型

Python字符串

#!/usr/bin/python # -*- coding: UTF-8 -*- str = 'Hello World!' print str # 输出完整字符串 print str[0] # 输出字符串中的第一个字符 print str[2:5] # 输出字符串中第三个至第五个之间的字符串 print str[2:] # 输出从第三个字符开始的字符串 print str * 2 # 输出字符串两次 print str + "TEST" # 输出连接的字符串

Python列表

#!/usr/bin/python # -*- coding: UTF-8 -*- list = [ 'runoob', 786 , 2.23, 'john', 70.2 ] tinylist = [123, 'john'] print list # 输出完整列表 print list[0] # 输出列表的第一个元素 print list[1:3] # 输出第二个至第三个的元素 print list[2:] # 输出从第三个开始至列表末尾的所有元素 print tinylist * 2 # 输出列表两次 print list + tinylist # 打印组合的列表

Python元组

元组是另一个数据类型，类似于List（列表）。

元组用"()"标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。

#!/usr/bin/python # -*- coding: UTF-8 -*- tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 ) tinytuple = (123, 'john') print tuple # 输出完整元组 print tuple[0] # 输出元组的第一个元素 print tuple[1:3] # 输出第二个至第三个的元素 print tuple[2:] # 输出从第三个开始至列表末尾的所有元素 print tinytuple * 2 # 输出元组两次 print tuple + tinytuple # 打印组合的元组

以下是元组无效的，因为元组是不允许更新的。而列表是允许更新的：

#!/usr/bin/python # -*- coding: UTF-8 -*- tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 ) list = [ 'runoob', 786 , 2.23, 'john', 70.2 ] tuple[2] = 1000 # 元组中是非法应用 报错'tuple' object does not support item assignment list[2] = 1000 # 列表中是合法应用

Python 字典

字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。

两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典用"{ }"标识。字典由索引(key)和它对应的值value组成。

#!/usr/bin/python # -*- coding: UTF-8 -*- dict = {} dict['one'] = "This is one" dict[2] = "This is two" tinydict = {'name': 'john','code':6734, 'dept': 'sales'} #不能输出不存在key的项 print dict['one'] # 输出键为'one' 的值 print dict[2] # 输出键为 2 的值 print tinydict # 输出完整的字典 print tinydict.keys() # 输出所有键 print tinydict.values() # 输出所有值

Python数据类型转换

int() 函数用于将一个字符串会数字转换为整型。

>>> int(3.6) 3 >>> int('12',16) # 如果是带参数base的话，12要以字符串的形式进行输入，12 为 16进制 18

long() 函数将数字或字符串转换为一个长整型。

>>>long() 0L >>> long('123') 123L

float() 函数用于将整数和字符串转换成浮点数。

>>>float(1) 1.0 >>> float(-123.6) -123.6 >>> float('123') # 字符串 123.0

complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数

>>>complex(1, 2) (1 + 2j) >>> complex(1) # 数字 (1 + 0j) >>> complex("1") # 当做字符串处理 (1 + 0j)

str() 函数将对象转化为适于人阅读的形式。

>>>s = 'RUNOOB' >>> str(s) 'RUNOOB' >>> dict = {'runoob': 'runoob.com', 'google': 'google.com'}; >>> str(dict) "{'google': 'google.com', 'runoob': 'runoob.com'}" >>>

repr() 函数将对象转化为供解释器读取的形式。

>>>s = 'RUNOOB' >>> repr(s) "'RUNOOB'" >>> dict = {'runoob': 'runoob.com', 'google': 'google.com'}; >>> repr(dict) "{'google': 'google.com', 'runoob': 'runoob.com'}" >>>

eval() 函数用来执行一个字符串表达式，并返回表达式的值

>>>x = 7 >>> eval( '3 * x' ) 21

tuple() 函数将列表转换为元组

>>>tuple([1,2,3,4]) (1, 2, 3, 4) >>> tuple({1:2,3:4}) #针对字典 会返回字典的key组成的tuple (1, 3) >>> tuple((1,2,3,4)) #元组会返回元组自身 (1, 2, 3, 4)

aList = [123, 'xyz', 'zara', 'abc']; aTuple = tuple(aList) print "Tuple elements : ", aTuple #这里必须是,

list() 方法用于将元组转换为列表。

注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。

aTuple = (123, 'xyz', 'zara', 'abc'); aList = list(aTuple) print "列表元素 : ", aList

列表元素 : [123, 'xyz', 'zara', 'abc']

set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

>>>x = set('runoob') >>> y = set('google') >>> x, y (set(['b', 'r', 'u', 'o', 'n']), set(['e', 'o', 'g', 'l'])) # 重复的被删除 >>> x & y # 交集 set(['o']) >>> x | y # 并集 set(['b', 'e', 'g', 'l', 'o', 'n', 'r', 'u']) >>> x - y # 差集 set(['r', 'b', 'u', 'n']) >>>

dict() 函数用于创建一个字典。（暂时报错 'dict' object is not callable）

>>>dict() # 创建空字典 {} >>> dict(a='a', b='b', t='t') # 传入关键字 {'a': 'a', 'b': 'b', 't': 't'} >>> dict(zip(['one', 'two', 'three'], [1, 2, 3])) # 映射函数方式来构造字典 {'three': 3, 'two': 2, 'one': 1} >>> dict([('one', 1), ('two', 2), ('three', 3)]) # 可迭代对象方式来构造字典 {'three': 3, 'two': 2, 'one': 1} >>>

frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

>>>a = frozenset(range(10)) # 生成一个新的不可变集合 >>> a frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) >>> b = frozenset('runoob') >>> b frozenset(['b', 'r', 'u', 'o', 'n']) # 创建不可变集合 >>>

chr() 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符。

>>>print chr(0x30), chr(0x31), chr(0x61) # 十六进制 0 1 a >>> print chr(48), chr(49), chr(97) # 十进制 0 1 a

unichr() 函数 和 chr()函数功能基本一样， 只不过是返回 unicode 的字符。

>>>unichr(97) u'a'

hex() 函数用于将10进制整数转换成16进制整数

>>>hex(255) '0xff'

oct() 函数将一个整数转换成8进制字符串。

>>>oct(10) '012'

运算符

算术运算符

幂运算符 **

取整除 \\

成员运算符 in not in

身份运算符 is is not

逻辑运算符 and or not

is 是判断两个标识符是不是引用自一个对象

is 与 == 区别：

is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。

条件语句

python的符合表达式采用短路原则 下面的代码报错 or改成and不会报错

a=0 b=1 if ( a > 0 ) or ( b / a > 2 ): print "yes" else : print "no"

循环语句

Python提供了for循环和while循环（在Python中没有do..while循环）

嵌套循环 可以在while循环中嵌套for循环

支持 break continue pass循环控制语句

while循环

#!/usr/bin/python

member =[1,2,3,4]

odd=[]

even=[]

while len(member)>0:

mem=member.pop()

if(mem%2==0):

odd.append(mem)

else:

even.append(mem)

print odd

print even

while 语句时还有另外两个重要的命令 continue，break 来跳过循环，continue 用于跳过该次

循环，break 则是用于退出循环，此外"判断条件"还可以是个常值，表示循环必定成立

# continue 和 break 用法 i = 1 while i < 10: i += 1 if i%2 > 0: # 非双数时跳过输出 continue print i # 输出双数2、4、6、8、10 i = 1 while 1: # 循环条件为1必定成立 print i # 输出1~10 i += 1 if i > 10: # 当i大于10时跳出循环 break

在python中 while...else在循环条件为false时 执行else语句块

类似于if的语法 如果while循环体中只有一条语句 可以写在一行

Python的for循环可以遍历任何序列的一个项目 如一个列表或者一个字符串

#!/usr/bin/python # -*- coding: UTF-8 -*- for letter in 'Python': # 第一个实例 print '当前字母 :', letter fruits = ['banana', 'apple', 'mango'] for fruit in fruits: # 第二个实例 print '当前水果 :', fruit print "Good bye!"

通过序列索引迭代

#!/usr/bin/python # -*- coding: UTF-8 -*- fruits = ['banana', 'apple', 'mango'] for index in range(len(fruits)): print '当前水果 :', fruits[index] print "Good bye!"

for循环中的else语句

在 python 中，for … else 表示这样的意思，for 中的语句和普通的没有区别，else

中的语句会在循环正常执行完（即 for 不是通过 break 跳出而中断的）的情况下执

行，while … else 也是一样。

#!/usr/bin/python # -*- coding: UTF-8 -*- for num in range(10,20): # 迭代 10 到 20 之间的数字 for i in range(2,num): # 根据因子迭代 if num%i == 0: # 确定第一个因子 j=num/i # 计算第二个因子 print '%d 等于 %d * %d' % (num,i,j) break # 跳出当前循环 else: # 循环的 else 部分 print num, '是一个质数'

嵌套循环

可以在循环体内嵌入其他的循环体，如在while循环中可以嵌入for循环， 反之，你可以在

for循环中嵌入while循环。

Python pass是空语句，是为了保持程序结构的完整性。

pass 不做任何事情，一般用做占位语句。

Python字符串

字符串是 Python 中最常用的数据类型。我们可以使用引号('或")来创建字符串

字符串运算符：+ * [] [:] in not in %

此外关于格式化还有 字符串格式化符号 格式化操作符指令

>>> hi = '''hi there''' >>> hi # repr() 'hi\nthere' >>> print hi # str() hi there

Unicode字符串

Python的字符串内建函数

Python列表

Python有6个序列的内置类型，但最常见的是列表和元组。

序列都可以进行的操作包括索引，切片，加，乘，检查成员。

此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。

删除列表中的值可以使用 del

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

列表函数 cmp len max min list

方法 append count insert pop remove reverse

Python创建二维列表 将需要的参数写入cols rows

list_2d = [[0 for col in range(cols)] for row in range(rows)]

Python元组

元组中只包含一个元素时，需要在元素后面添加逗号

tup1 = (50,);

修改元组的值 元组中的元素值是不允许修改的，但我们可以对元组进行连接组合

删除元组元素 元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组

与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运

算后会生成一个新的元组

无关闭分隔符

任意无符号的对象，以逗号隔开，默认为元组

print 'abc', -4.24e93, 18+6.6j, 'xyz'; x, y = 1, 2; print "Value of x , y : ", x,y;

>>> tup1 = ("all",) >>> print tup1 ('all',) >>>

Python字典

dict.clear(); # 清空词典所有条目 del dict ; # 删除词典

字典键的特性

字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，

但键不行。

两个重要的点需要记住：

1）不允许同一个键出现两次

2）键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行(列表是无序的) dict = {['Name']: 'Zara', 'Age': 7}; print "dict['Name']: ", dict['Name'];

字典内置函数&方法

Python日期和时间

import time; # 引入time模块 ticks = time.time() print "当前时间戳为:", ticks

localtime = time.asctime( time.localtime(time.time()) ) print "本地时间为 :", localtime

# 格式化成2016-03-20 11:45:39形式 print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())

Python 函数

定义一个函数

return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返

回 None。

参数传递

在 python 中，类型属于对象，变量是没有类型的：

a=[1,2,3] a="Runoob"

以上代码中，[1,2,3] 是 List 类型，"Runoob" 是 String 类型，而变量 a 是没有类型，她

仅仅是一个对象的引用（一个指针），可以是 List 类型对象，也可以指向 String 类型对

象。

可更改(mutable)与不可更改(immutable)对象

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可

以修改的对象。

不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。

可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：

不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。

可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传

不可变对象和传可变对象。

参数

以下是调用函数时可使用的正式参数类型：

必备参数

关键字参数

默认参数

不定长参数

必备参数

必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

关键字参数

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。

使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用

参数名匹配参数值。

#可写函数说明 def printinfo( name, age ): "打印任何传入的字符串" print "Name: ", name; print "Age ", age; return; #调用printinfo函数 printinfo( age=50, name="miki" );

缺省参数

调用函数时，缺省参数的值如果没有传入

不定长参数

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数

加了星号（*）的变量名会存放所有未命名的变量参数

# 可写函数说明 def printinfo( arg1, *vartuple ): "打印任何传入的参数" print "输出: " print arg1 for var in vartuple: print var return; # 调用printinfo 函数 printinfo( 10 ); printinfo( 70, 60, 50 );

匿名函数

python 使用 lambda 来创建匿名函数。

# 可写函数说明 sum = lambda arg1, arg2: arg1 + arg2; # 调用sum函数 print "相加后的值为 : ", sum( 10, 20 ) print "相加后的值为 : ", sum( 20, 20 )

global

global---将变量定义为全局变量。可以通过定义为全局变量，实现在函数内部改变

变量值。

From…import 语句

Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中

From…import* 语句

把一个模块的所有内容全都导入到当前的命名空间也是可行的

搜索路径

当你导入一个模块，Python 解析器对模块位置的搜索顺序是：

1、当前目录

2、如果不在当前目录，Python 则搜索在 shell 变量 PYTHONPATH 下的每个目录。

3、如果都找不到，Python会察看默认路径。UNIX下，默认路径一般为/usr/local/lib/python/。

模块搜索路径存储在 system 模块的 sys.path 变量中。变量里包含当前目录，

PYTHONPATH和由安装过程决定的默认目录。

dir()函数

dir() 函数一个排好序的字符串列表，内容是一个模块里定义过的名字

# 导入内置math模块 import math content = dir(math) print content;

globals() 和 locals() 函数

reload() 函数

Python中的包

包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的

Python 的应用环境。

Python 文件I/O

input([prompt]) 函数和 raw_input([prompt]) 函数基本类似，但是 input 可以接收一个

Python表达式作为输入，并将运算结果返回。

str = input("请输入："); print "你输入的内容是: ", str

请输入：[x*5 for x in range(2,10,2)] 你输入的内容是: [10, 20, 30, 40]

File 对象方法: file对象提供了操作文件的一系列方法。

OS 对象方法: 提供了处理文件及目录的一系列方法。

Python 异常处理

# 定义函数 def temp_convert(var): try: return int(var) except ValueError, Argument: print "参数没有包含数字\n", Argument # 调用函数 temp_convert("xyz");

使用raise语句自己触发异常

# 定义函数 def mye( level ): if level < 1: raise Exception("Invalid level!", level) # 触发异常后，后面的代码就不会再执行 try: mye(0) // 触发异常 except "Invalid level!": print 1 else: print 2

Python 内置函数

abs()

divmod()

input()

python input() 相等于 eval(raw_input(prompt)) ，用来获取控制台的输入。

raw_input() 将所有输入作为字符串看待，返回字符串类型。而 input() 在对待纯数字输入时具有自己的特性，它返回所输入的数字的类型（ int, float ）

staticmethod()

class C(object): @staticmethod def f(): print('runoob'); C.f(); # 静态方法无需实例化 cobj = C() cobj.f() # 也可以实例化后调用

all()

all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否不为 0、''、False 或者 iterable 为空，如果是返回 True，否则返回 False。

enumerate()

>>>seasons = ['Spring', 'Summer', 'Fall', 'Winter'] >>> list(enumerate(seasons))

普通for循环

>>>i = 0 >>> seq = ['one', 'two', 'three'] >>> for element in seq: ... print i, seq[i] ... i +=1 ...

for循环使用enumerate

>>>seq = ['one', 'two', 'three'] >>> for i, element in enumerate(seq): ... print i, seq[i] ...

int() str() ord()

any()

any() 函数用于判断给定的可迭代参数 iterable 是否全部为空对象，如果都为空、0、false，则返回 False，如果不都为空、0、false，则返回 True。

>>> any([]) # 空列表 >>> any(()) # 空元组

eval()

isinstance()

isinstance() 与 type() 区别：

type() 不会认为子类是一种父类类型，不考虑继承关系。

isinstance() 会认为子类是一种父类类型，考虑继承关系。

如果要判断两个类型是否相同推荐使用 isinstance()。

>>>a = 2 >>> isinstance (a,int) True >>> isinstance (a,str) False >>> isinstance (a,(str,int,list)) # 是元组中的一个返回 True True

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。