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中的保留字。这些保留字不能用作常数或变数，或任何其他标识符名称。

行和缩进

在 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,

print y,

多个语句构成代码组

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

像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

 

class a: pass class b(a): pass isinstance(a(), a) # returns true 测试：true type(a()) == a # returns true 测试：false isinstance(b(), a) # returns true 测试：false type(b()) == a # returns false 测试：false

pow()

sum()

basestring()

execfile() execfile() 函数可以用来执行一个文件。

issubclass()

print()

super()

super() 函数用于调用下一个父类(超类)并返回该父类实例的方法。

super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（mro）、重复调用（钻石继承）等种种问题。

mro 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。

 

bin()

file()

iter()

iter() 函数用来生成迭代器。

注意 和 enumerate的区别

>>>lst = [1, 2, 3] >>> for i in iter(lst): ... print(i) ...

property() 在新式类中返回属性值。

tuple()

bool()

filter() 用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

import math def is_sqr(x): return math.sqrt(x) % 1 == 0 newlist = filter(is_sqr, range(1, 101)) print(newlist)

len()

range() 可创建一个整数列表，一般用在 for 循环中。

>>>x = 'runoob' >>> for i in range(len(x)) : ... print(x[i]) ...

type() 函数如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象。

# 三个参数 >>> class x(object): ... a = 1 ... >>> x = type('x', (object,), dict(a=1)) # 产生一个新的类型 x >>> x <class '__main__.x'>

bytearray() 返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256

float()

list()

raw_input()

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

callable()

用于检查一个对象是否是可调用的。如果返回true，object仍然可能调用失败；但如果返回false，调用对象ojbect绝对不会成功。

对于函数, 方法, lambda 函式, 类, 以及实现了 __call__ 方法的类实例, 它都返回 true。

>>> class b: ... def __call__(self): ... return 0 ... >>> callable(b) true >>> b = b() >>> callable(b) # 实现 __call__, 返回 true true

format()

locals()

locals() 函数会以字典类型返回当前位置的全部局部变量。

对于函数, 方法, lambda 函式, 类, 以及实现了 __call__ 方法的类实例, 它都返回 true。

>>>def runoob(arg): # 两个局部变量：arg、z ... z = 1 ... print (locals()) ... >>> runoob(4) {'z': 1, 'arg': 4} # 返回一个名字/值对的字典

reduce()

reduce() 函数会对参数序列中元素进行累积。

函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给reduce中的函 数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果

>>>def add(x, y) : # 两数相加 ... return x + y ... >>> reduce(add, [1,2,3,4,5]) # 计算列表和：1+2+3+4+5 15 >>> reduce(lambda x, y: x+y, [1,2,3,4,5]) # 使用 lambda 匿名函数 15

unicode()

chr()

frozenset()

long()

reload() 用于重新载入之前载入的模块

>>>import sys >>> sys.getdefaultencoding() # 当前默认编码 'ascii' >>> reload(sys) # 使用 reload <module 'sys' (built-in)> >>> sys.setdefaultencoding('utf8') # 设置编码 >>> sys.getdefaultencoding() 'utf8'

vars() 返回对象object的属性和属性值的字典对象。

>>>print(vars()) {'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': none, '__package__': none} >>> class runoob: ... a = 1 ... >>> print(vars(runoob)) {'a': 1, '__module__': '__main__', '__doc__': none} >>> runoob = runoob() >>> print(vars(runoob)) {}

classmethod()

修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。

class a(object): bar = 1 def func1(self): print ('foo') @classmethod def func2(cls): print ('func2') print (cls.bar) cls().func1() # 调用 foo 方法 a.func2() # 不需要实例化

 

 

getattr()

map() 会根据提供的函数对指定序列做映射。

第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

>>>def square(x) : # 计算平方数 ... return x ** 2 ... >>> map(square, [1,2,3,4,5]) # 计算列表和：1+2+3+4+5 [1, 4, 9, 16, 25] >>> map(lambda x: x ** 2, [1, 2, 3, 4, 5]) # 使用 lambda 匿名函数 [1, 4, 9, 16, 25] # 提供了两个列表，对相同位置的列表数据进行相加 >>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]) [3, 7, 11, 15, 19]

repr()

xrange()函数用法与  完全相同，所不同的是生成的不是一个数组，而是一个生成器。

>>>xrange(8) xrange(8) >>> list(xrange(8)) [0, 1, 2, 3, 4, 5, 6, 7]

cmp()

globals() 函数会以字典类型返回当前位置的全部全局变量。

>>>a='runoob' >>> print(globals()) # globals 函数返回一个全局变量的字典，包括所有导入的变量。

max()

reversed()

zip()用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。利用 * 号操作符，可以将元组解压为列表。

>>>a = [1,2,3] >>> b = [4,5,6] >>> c = [4,5,6,7,8] >>> zipped = zip(a,b) # 打包为元组的列表 [(1, 4), (2, 5), (3, 6)] >>> zip(a,c) # 元素个数与最短的列表一致 [(1, 4), (2, 5), (3, 6)] >>> zip(*zipped) # 与 zip 相反，可理解为解压，返回二维矩阵式 [(1, 2, 3), (4, 5, 6)]

 

compile() 函数将一个字符串编译为字节代码。

>>>str = "for i in range(0,10): print(i)" >>> c = compile(str,'','exec') # 编译为字节代码对象 >>> c <code object <module> at 0x10141e0b0, file "", line 1> >>> exec(c)

 

>>> str = "3 * 4 + 5" >>> a = compile(str,'','eval') >>> eval(a) 17

hasattr()

memoryview()

>>>v = memoryview('abcefg') >>> v[1] 'b' >>> v[-1] 'g' >>> v[1:4] <memory at 0x77ab28> >>> v[1:4].tobytes() 'bce'

round()

__import__() 用于动态加载类和函数 。

如果一个模块经常变化就可以使用 __import__() 来动态载入。

a.py

import os print ('在 a.py 文件中 %s' % id(os))

test.py

import sys __import__('a') # 导入 a.py 模块

 

 

complex()

hash() 用于获取取一个对象（字符串或者数值等）的哈希值

min()

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

>>>x = set('runoob') >>> y = set('google') >>> x, y

delattr()

help()

next() 返回迭代器的下一个项目。

# 首先获得iterator对象: it = iter([1, 2, 3, 4, 5]) # 循环: while true: try: # 获得下一个值: x = next(it) print(x) except stopiteration: # 遇到stopiteration就退出循环 break

setattr()

dict()

hex()

object()

slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。

>>>myslice = slice(5) # 设置截取5个元素的切片 >>> myslice slice(none, 5, none) >>> arr = range(10) >>> arr [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> arr[myslice] # 截取 5 个元素 [0, 1, 2, 3, 4]

 

slice实现分片和列表的拷贝

>>> alist = ['123', 'abc', 'good', 'hello', 'nice'] #定义一个列表 >>> alist1 = alist[:] #[:]分号左边表示从第0未开始，分号右边表示最后一位结束 >>> alist1 #成功将alist列表拷贝给了alist1 ['123', 'abc', 'good', 'hello', 'nice']

 

dir()

id() 用于获取对象的内存地址

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

sorted() 函数对所有可迭代的对象进行排序操作。

exec内置表达式

exec 执行储存在字符串或文件中的python语句，相比于 eval，exec可以执行更复杂的 python 代码。

exec 返回值永远为 none。

# 多行语句字符串 >>> exec """for i in range(5): ... print "iter time: %d" % i ... """

 

x = 10 expr = """ z = 30 sum = x + y + z print(sum) """ def func(): y = 20 exec(expr) exec(expr, {'x': 1, 'y': 2}) exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4}) func()

 

 

 

 

 

python 面向对象

self代表类的实例，而非类

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称,

按照惯例它的名称是 self。

class employee: '所有员工的基类' empcount = 0 def __init__(self, name, salary): self.name = name self.salary = salary employee.empcount += 1 def displaycount(self): print "total employee %d" % employee.empcount def displayemployee(self): print "name : ", self.name, ", salary: ", self.salary emp1 = employee("zara", 2000) emp2 = employee("manni", 5000)

emp1.displayemployee() emp2.displayemployee() print "total employee %d" % employee.empcount

添加删除修改类的属性

emp1.age = 7 # 添加一个 'age' 属性 emp1.age = 8 # 修改 'age' 属性 del emp1.age # 删除 'age' 属性

第二种方式

hasattr(emp1, 'age') # 如果存在 'age' 属性返回 true。 getattr(emp1, 'age') # 返回 'age' 属性的值 setattr(emp1, 'age', 8) # 添加属性 'age' 值为 8 delattr(empl, 'age') # 删除属性 'age'

python内置类属性

• __dict__ : 类的属性（包含一个字典，由类的数据属性组成）
• __doc__ :类的文档字符串
• __name__: 类名
• __module__: 类定义所在的模块（类的全名是'__main__.classname'，如果类位于一个导入模块mymod中，那么classname.__module__ 等于 mymod）
• __bases__ : 类的所有父类构成元素（包含了一个由所有父类组成的元组）

 

self 代表的是类的实例，代表当前对象的地址，而 self.class 则指向类。

self 不是 python 关键字，我们把他换成 runoob 也是可以正常执行的

class test: def prt(self): print(self) print(self.__class__) t = test() t.prt()

垃圾回收机制

python 使用了引用计数这一简单技术来跟踪和回收垃圾。

在 python 内部记录着所有使用中的对象各有多少引用。

一个内部跟踪变量，称为一个引用计数器。

当对象被创建时， 就创建了一个引用计数， 当这个对象不再需要时， 也就是说， 这个对

象的引用计数变为0 时， 它被垃圾回收。但是回收不是"立即"的， 由解释器在适当的时

机，将垃圾对象占用的内存空间回收

 

垃圾回收机制不仅针对引用计数为0的对象，同样也可以处理循环引用的情况。循环引用指的

是，两个对象相互引用，但是没有其他变量引用他们。这种情况下，仅使用引用计数是不够的。

python 的垃圾收集器实际上是一个引用计数器和一个循环垃圾收集器。作为引用计数的补充，

垃圾收集器也会留心被分配的总量很大（及未通过引用计数销毁的那些）的对象。 在这种情况

下， 解释器会暂停下来， 试图清理所有未引用的循环

析构函数 __del__ ，__del__在对象销毁的时候被调用，当对象不再被使用时，__del__方

法运行

class point: def __init__( self, x=0, y=0): self.x = x self.y = y def __del__(self): class_name = self.__class__.__name__ print class_name, "销毁" pt1 = point() pt2 = pt1 pt3 = pt1 print id(pt1), id(pt2), id(pt3) # 打印对象的id del pt1 del pt2 del pt3

继承

在python中继承中的一些特点：

• 1：在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。
• 2：在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数
• 3：python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。

、 如果在继承元组中列了一个以上的类，那么它就被称作"多重继承" 。

class parent: # 定义父类 parentattr = 100 def __init__(self): print "调用父类构造函数" def parentmethod(self): print '调用父类方法' def setattr(self, attr): parent.parentattr = attr def getattr(self): print "父类属性 :", parent.parentattr class child(parent): # 定义子类 def __init__(self): print "调用子类构造方法" def childmethod(self): print '调用子类方法' c = child() # 实例化子类 c.childmethod() # 调用子类的方法 c.parentmethod() # 调用父类方法 c.setattr(200) # 再次调用父类的方法 - 设置属性值 c.getattr() # 再次调用父类的方法 - 获取属性值

issubclass() - 布尔函数判断一个类是另一个类的子类或者子孙类，语法：issubclass(sub,sup)

isinstance(obj, class) 布尔函数如果obj是class类的实例对象或者是一个class子类的实例对象则返回true。

方法重写

如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法：

基础重载方法

__init__ __del__ __repr__ __str__ __cmp__

运算符重载

python同样支持运算符重载

#!/usr/bin/python class vector: def __init__(self, a, b): self.a = a self.b = b def __str__(self): return 'vector (%d, %d)' % (self.a, self.b) def __add__(self,other): return vector(self.a + other.a, self.b +

other.b) v1 = vector(2,10) v2 = vector(5,-2) print v1 + v2

输出：vector (7, 8)

类属性与方法

类的方法

在类的内部，使用 def 关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数 self,且为第一个参数

class justcounter: __secretcount = 0 # 私有变量 publiccount = 0 # 公开变量 def count(self): self.__secretcount += 1 self.publiccount += 1 print self.__secretcount counter = justcounter() counter.count() counter.count() print counter.publiccount print counter.__secretcount # 报错，实例不能访问私有变量

python不允许实例化的类访问私有数据，但你可以使（相当于在类外访问私有属性）

用 object._classname__attrname 访问属性

print counter._justcounter__secretcount

 

单下划线、双下划线、头尾双下划线说明：

• __foo__: 定义的是特列方法，类似 __init__() 之类的。
• _foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import *
• __foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。

 

python正则表达式

python 自1.5版本起增加了re 模块，它提供 perl 风格的正则表达式模式。

re 模块使 python 语言拥有全部的正则表达式功能。

 

re.match函数

re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。

import re print(re.match('www', 'www.runoob.com').span()) # 在起始位置匹配 print(re.match('com', 'www.runoob.com')) # 不在起始位置匹配

 

re.search 函数 扫描整个字符串并返回第一个成功的匹配

import re line = "cats are smarter than dogs"; searchobj = re.search( r'(.*) are (.*?) .*', line, re.m|re.i) if searchobj: print "searchobj.group() : ", searchobj.group() print "searchobj.group(1) : ", searchobj.group(1) print "searchobj.group(2) : ", searchobj.group(2) else: print "nothing found!!"

 

re.match与re.search的区别

re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回none；而re.search匹配整个字符串，直到找到一个匹配。

 

检索和替换

python 的 re 模块提供了re.sub用于替换字符串中的匹配项。

不仅可以替换匹配项 还可以对匹配项目进行各种变换

 

 

python操作mysql数据库

什么是mysqldb?

mysqldb 是用于python链接mysql数据库的接口，它实现了 python 数据库 api 规范 v2.0，基于 mysql c api 上建立的。

 

python 网络编程

python 提供了两个级别访问的网络服务。：

• 低级别的网络服务支持基本的 socket，它提供了标准的 bsd sockets api，可以访问底层操作系统socket接口的全部方法。
• 高级别的网络服务模块 socketserver， 它提供了服务器中心类，可以简化网络服务器的开发

 

 

python 多线程

每个线程都有他自己的一组cpu寄存器，称为线程的上下文，该上下文反映了线程上次运行该线程

的cpu寄存器的状态。

指令指针和堆栈指针寄存器是线程上下文中两个最重要的寄存器，线程总是在进程得到上下文中运

行的，这些地址都用于标志拥有线程的进程地址空间中的内存。

开始学习python线程

python中使用线程有两种方式：函数或者用类来包装线程对象。

函数式：调用thread模块中的start_new_thread()函数来产生新线程

thread.start_new_thread ( function, args[, kwargs] )

参数说明:

• function - 线程函数。
• args - 传递给线程函数的参数,他必须是个tuple类型。
• kwargs - 可选参数

 

 

 

线程的结束一般依靠线程函数的自然结束；也可以在线程函数中调用thread.exit()，他抛出systemexit exception，达到退出线程的目的。

线程模块

使用threading模块创建线程

线程同步

线程优先级队列（ queue）

python2.x与3​​.x版本区别

 

 

python 练习实例100

列表转换为字典

i = ['a', 'b'] l = [1, 2] print dict([i,l])

 

 

 

 

git status命令可以列出当前目录所有还没有被git管理的文件和被git管理且被修改但还未提交(git commit)的文件.。

c:\zjy\www\subject_book>git status

on branch master

changes not staged for commit:

(use "git add <file>..." to update what will be committed)

(use "git checkout -- <file>..." to discard changes in working directory)

modified: .idea/workspace.xml

modified: widgets/noto/html_tpl/default/order/select_school.html

no changes added to commit (use "git add" and/or "git commit -a")