欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

python总结【来自Runoob】

程序员文章站 2022-04-15 14:07:51
test.py #!/usr/bin/python print "Hello, Python!"; $ chmod +x test.py # 脚本文件添加可执行权限 $ ./test.py 标识符 以下划线开头的标识符是有特殊意义的。以单下划线开头 _foo 的代表不能直接访问的类属性,需通过类提供 ......

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]

 

 

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")