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]
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()函数用法与 range 完全相同,所不同的是生成的不是一个数组,而是一个生成器。
>>>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)
http://blog.csdn.net/dai_fun/article/details/49926113
Python2.x与3.x版本区别
Python 练习实例100
列表转换为字典
i = ['a', 'b'] l = [1, 2] print dict([i,l])
http://101.201.147.112/subject/widgets/auto_run/jl.html?&ysid=4122&batch=
git status命令可以列出当前目录所有还没有被git管理的文件和被git管理且被修改但还未提交(git commit)的文件.。 http://blog.csdn.net/hudashi/article/details/45080721
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")
python总结【来自Runoob】的更多相关文章
- Python简史
Python简史 作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明.谢谢! Python是我喜欢的语言,简洁,优美,容易使用.前两天,我很激 ...
- Python应用与实践【转】
转自:http://www.cnblogs.com/skynet/archive/2013/05/06/3063245.html 目录 1. Python是什么? 1.1. Pyt ...
- python与编码
Python中的文字对象 Python 3.x中处理文字的对象有str, bytes, bytearray. bytes和bytearray可以使用除了用作格式化的方法(format, format_ ...
- 《码农周刊》干货精选(Python 篇)
<码农周刊>已经累计发送了 38 期,我们将干货内容进行了精选.此为 Python 篇. <码农周刊>往期回顾:http://weekly.manong.io/issues/ ...
- Python补充04 Python简史
原文:Python简史 作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明.谢谢! Python是我喜欢的语言,简洁,优美,容易使用.前两天, ...
- Python系列教程(一):简介
Python发展历史 起源 Python的作者,Guido von Rossum,荷兰人.1982年,Guido从阿姆斯特丹大学获得了数学和计算机硕士学位.然而,尽管他算得上是一位数学家,但他更加享受 ...
- python 序列
序列 序列是python中的一种数据结构,这种数据结构根据索引来获取序列中的对象 有6种内建序列类:list,tuple,string,unicode,buffer,xrange. 其中xrange比 ...
- python中字符串拆分与合并——split()、join()、strip()和replace()
Python3 split()方法 描述split()通过指定分隔符对字符串进行切片,如果参数num 有指定值,则仅分隔 num 个子字符串 语法split()方法语法: str.split(str= ...
- python 简史
---恢复内容开始--- Python的作者,Guido von Rossum,确实是荷兰人.1982年,Guido从阿姆斯特丹大学(University of Amsterdam)获得了数学和计算机 ...
随机推荐
- git 使用详解(9)-- 分支的新建与合并 git branch -d、merge、 --merged/--no-merged/-v
现在让我们来看一个简单的分支与合并的例子,实际工作中大体也会用到这样的工作流程: 开发某个网站. 为实现某个新的需求,创建一个分支. 在这个分支上开展工作. 假设此时,你突然接到一个电话说有个很严重的 ...
- BZOJ 1861书架
小T有一个很大的书柜.这个书柜的构造有些独特,即书柜里的书是从上至下堆放成一列.她用1到n的正整数给每本书都编了号. 小T在看书的时候,每次取出一本书,看完后放回书柜然后再拿下一本.由于这些书太有吸引 ...
- 菜鸟系列docker——docker网络(8)
Docker网络 Docker在容器内部运行应用,这些应用之间的交互依赖于大量不同的网络,这意味着Docker需要强大的网络功能. Docker 网络从覆盖范围可分为单个 host 上的容器网络和跨多 ...
- Dubbo一致性哈希负载均衡的源码和Bug,了解一下?
本文是对于Dubbo负载均衡策略之一的一致性哈希负载均衡的详细分析.对源码逐行解读.根据实际运行结果,配以丰富的图片,可能是东半球讲一致性哈希算法在Dubbo中的实现最详细的文章了. 文中所示源码,没 ...
- 【JS】336- 拆解 JavaScript 中的异步模式
点击上方"前端自习课"关注,学习起来~ JavaScript 中有很多种异步编程的方式.callback.promise.generator.async await 甚至 RxJS ...
- 【Vuejs】269- 提升90%加载速度——vuecli下的首屏性能优化
前言 之前用 ,所以接下来还会介绍一些它们在优化上的异同 分析 vuecli 2.x自带了分析工具只要运行 npm run build --report 如果是 vuecli 3的话,先安装插件 cn ...
- ES6,箭头函数 (=>)注意点
函数体内的this对象,就是定义时所在的对象,而不是使用时所在的对象. 不可以当作构造函数,也就是说,不可以使用new命令,否则会抛出一个错误. 不可以使用arguments对象,该对象在函数体内不存 ...
- SecureCRT安装包和破解脚本
第一步下载 SecureCRT安装包和破解脚本 下载 http://pan.baidu.com/s/1c1D5Ala 破解脚本 securecrt_mac_crack.pl安装包scrt-7.3.7- ...
- node-sass下载失败
在angular项目中下载依赖npm install时提示node-sass安装失败,解决方法如下: 1.下载win32-x64-57_binding.node文件至指定目录 2.添加环境变量: 变量 ...
- (Concurrent)HashMap的存储过程及原理。
1.前言 看完咕泡Jack前辈的有关hashMap的视频(非宣传,jack自带1.5倍嘴速,高效),收益良多,所以记录一下学习到的东西. 2.基础用法 源码的注释首先就介绍了哈希表是基于Map接口,所 ...