简介
学习python最快的方法就是和java对比!!!
所有 Python 文件将以 .py 为扩展名。
Linux下运行python脚本
Linux系统一般集成Python,如果没有安装,可以手动安装,联网状态下可直接安装。Fedora下使用yum install,Ubuntu下使用apt-get install,前提都是root权限。安装完毕,可将Python加入环境变量,这样在使用Python时无须每次都指定安装路径。
Python执行文件
与bash shell一样,可以直接执行Python程序文件。新建hello.py文件,键入如下内容并保存:
如果没有配置python的环境变量需要在py文件开头使用#!/usr/bin/python2.7,指定python的绝对路径
比如:
执行 ./test.py
Python编程模型
第一步 设置文件头
主要设置python的路径和文件的编码
#!/usr/bin/python
指定用什么解释器运行脚本以及解释器所在的位置
# -*- coding: utf-8 -*-
用来指定文件编码为utf-8的
Python与java对比
语法类区别
Python不需要指定数据类型,但是必须赋值
Python没有{ }作为结构体,同个严格的缩进表示结构体
Python中null使用 None表示
使用范围:在变量前加两个下划线如:__content = “haha”代表该类变量私有,不加则默认公有
Python的构造方法以固定的 __init__() 名字命名
类和对象的区别
Python的self相当于java中的this的关键字
和java相比调用方法无需new
定义方法用def +方法名,且类里面的每个方法必须含有入参且必须是第一个入参self;
Python中的继承和实现直接在类的括号内填写继承的类或实现的接口,class Child ( Parent ): Child类继承Parent类,可继承多个类,在Parent后用“,”隔开;
Python中的io流先用open打开,使用read直接读取
数据结构对比
数组
- java:
int[] array={1, 2, 3, 4, 5};
- Python:
list = [1, 2, 3, 4, 5 ]
不过由于Python 是动态数据类型 ,所以在list中的元素可以是不同的数据类型:
list=[1, 2, "a", "b", "c"]
语法
python #coding:utf-8和setdefaultencoding有什么区别?
这两个作用不一样,
1. # coding:utf-8
作用是定义源代码的编码. 如果没有定义, 此源码中是不可以包含中文字符串的.
PEP 0263 -- Defining Python Source Code Encodings
https://www.python.org/dev/peps/pep-0263/
2. sys.getdefaultencoding()
是设置默认的string的编码格式
一句话:两个都写没错。
Python 构造方法
__init__()
Python 标识符
在 Python 里,标识符由字母、数字、下划线组成。
在 Python 中,所有标识符可以包括英文、数字以及下划线(_),但不能以数字开头。
Python 中的标识符是区分大小写的。
以下划线开头的标识符是有特殊意义的。
- 以单下划线开头 _foo 的代表不能直接访问的类属性,需通过类提供的接口进行访问,不能用 from xxx import * 而导入;
- 以双下划线开头的 __foo 代表类的私有成员;
以双下划线开头和结尾的 __foo__ 代表 Python 里特殊方法专用的标识,如 __init__() 代表类的构造函数。
Python 可以同一行显示多条语句,方法是用分号 ; 分开,如:
>>> print 'hello';print 'runoob';
hello
runoob
Python 保留字符
下面的列表显示了在Python中的保留字。这些保留字不能用作常数或变数,或任何其他标识符名称。
所有 Python 的关键字只包含小写字母。
and |
exec |
not |
assert |
finally |
or |
break |
for |
pass |
class |
from |
|
continue |
global |
raise |
def |
if |
return |
del |
import |
try |
elif |
in |
while |
else |
is |
with |
except |
lambda |
yield |
行和缩进
学习 Python 与其他语言最大的区别就是,Python 的代码块不使用大括号 {} 来控制类,函数以及其他逻辑判断。python 最具特色的就是用缩进来写模块。
缩进的空白数量是可变的,但是所有代码块语句必须包含相同的缩进空白数量,这个必须严格执行。
注意:代码的缩进为一个TAB键,或者4个空格——官方建议使用空格
如下所示:
if True:
print "True"else:
print "False"
以下代码将会执行错误:
#!/usr/bin/python# -*- coding: UTF-8 -*-# 文件名:test.py
if True:
print "Answer"
print "True"else:
print "Answer"
# 没有严格缩进,在执行时会报错
print "False"
执行以上代码,会出现如下错误提醒:
$ python test.py
File "test.py", line 10
print "False"
^IndentationError: unindent does not match any outer indentation level
IndentationError: unindent does not match any outer indentation level错误表明,你使用的缩进方式不一致,有的是 tab 键缩进,有的是空格缩进,改为一致即可。
如果是 IndentationError: unexpected indent 错误, 则 python 编译器是在告诉你"Hi,老兄,你的文件里格式不对了,可能是tab和空格没对齐的问题",所有 python 对格式要求非常严格。
因此,在 Python 的代码块中必须使用相同数目的行首缩进空格数。
建议你在每个缩进层次使用 单个制表符 或 两个空格 或 四个空格 , 切记不能混用
多行语句
Python语句中一般以新行作为语句的结束符。
但是我们可以使用斜杠( \)将一行的语句分为多行显示,如下所示:
total = item_one + \
item_two + \
item_three
语句中包含 [], {} 或 () 括号就不需要使用多行连接符。如下实例:
days = ['Monday', 'Tuesday', 'Wednesday',
'Thursday', 'Friday']
Python 引号
Python 可以使用引号( ' )、双引号( " )、三引号( ''' 或 """ ) 来表示字符串,引号的开始与结束必须的相同类型的。
其中三引号可以由多行组成,编写多行文本的快捷语法,常用于文档字符串,在文件的特定地点,被当做注释。
word = 'word'
sentence = "这是一个句子。"
paragraph = """这是一个段落。
包含了多个语句"""
Python注释
python中单行注释采用 # 开头。
#!/usr/bin/python# -*- coding: UTF-8 -*-# 文件名:test.py
# 第一个注释
print "Hello, Python!"; # 第二个注释
输出结果:
Hello, Python!
注释可以在语句或表达式行末:
name = "Madisetti" # 这是一个注释
python 中多行注释使用三个单引号(''')或三个双引号(""")。
#!/usr/bin/python# -*- coding: UTF-8 -*-# 文件名:test.py
'''
这是多行注释,使用单引号。
这是多行注释,使用单引号。
这是多行注释,使用单引号。
'''
"""
这是多行注释,使用双引号。
这是多行注释,使用双引号。
这是多行注释,使用双引号。
"""
Python空行
函数之间或类的方法之间用空行分隔,表示一段新的代码的开始。类和函数入口之间也用一行空行分隔,以突出函数入口的开始。
空行与代码缩进不同,空行并不是Python语法的一部分。书写时不插入空行,Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码,便于日后代码的维护或重构。
记住:空行也是程序代码的一部分。
等待用户输入
下面的程序执行后就会等待用户输入,按回车键后就会退出:
#!/usr/bin/python# -*- coding: UTF-8 -*-
raw_input("按下 enter 键退出,其他任意键显示...\n")
以上代码中 ,\n 实现换行。一旦用户按下 enter(回车) 键退出,其它键显示。
同一行显示多条语句
Python可以在同一行中使用多条语句,语句之间使用分号(;)分割,以下是一个简单的实例:
#!/usr/bin/python
import sys; x = 'runoob'; sys.stdout.write(x + '\n')
执行以上代码,输入结果为:
$ python test.py
runoob
Print 输出
print 默认输出是换行的,如果要实现不换行需要在变量末尾加上逗号 ,
#!/usr/bin/python# -*- coding: UTF-8 -*-
x="a"
y="b"# 换行输出print xprint y
print '---------'# 不换行输出print x,print y,
# 不换行输出print x,y
以上实例执行结果为:
a
b---------
a b a b
多个语句构成代码组
缩进相同的一组语句构成一个代码块,我们称之代码组。
像if、while、def和class这样的复合语句,首行以关键字开始,以冒号( : )结束,该行之后的一行或多行代码构成代码组。
我们将首行及后面的代码组称为一个子句(clause)。
如下实例:
if expression :
suite elif expression :
suite else :
suite
命令行参数
很多程序可以执行一些操作来查看一些基本信息,Python 可以使用 -h 参数查看各参数帮助信息:
$ python -h
usage: python [option] ... [-c cmd | -m mod | file | -] [arg] ... Options and arguments (and corresponding environment variables): -c cmd : program passed in as string (terminates option list) -d : debug output from parser (also PYTHONDEBUG=x) -E : ignore environment variables (such as PYTHONPATH) -h : print this help message and exit
[ etc. ]
Python 变量类型
变量存储在内存中的值。这就意味着在创建变量时会在内存中开辟一个空间。
基于变量的数据类型,解释器会分配指定内存,并决定什么数据可以被存储在内存中。
因此,变量可以指定不同的数据类型,这些变量可以存储整数,小数或字符。
变量赋值
Python 中的变量赋值不需要类型声明。
每个变量在内存中创建,都包括变量的标识,名称和数据这些信息。
每个变量在使用前都必须赋值,变量赋值以后该变量才会被创建。
等号(=)用来给变量赋值。
等号(=)运算符左边是一个变量名,等号(=)运算符右边是存储在变量中的值。例如:
实例(Python 2.0+)
#!/usr/bin/python # -*- coding: UTF-8 -*- counter = 100 # 赋值整型变量 miles = 1000.0 # 浮点型 name = "John" # 字符串 print counter print miles print name
以上实例中,100,1000.0和"John"分别赋值给counter,miles,name变量。
执行以上程序会输出如下结果:
1001000.0John
多个变量赋值
Python允许你同时为多个变量赋值。例如:
a = b = c = 1
以上实例,创建一个整型对象,值为1,三个变量被分配到相同的内存空间上。
您也可以为多个对象指定多个变量。例如:
a, b, c = 1, 2, "john"
以上实例,两个整型对象 1 和 2 分别分配给变量 a 和 b,字符串对象 "john" 分配给变量 c。
标准数据类型
在内存中存储的数据可以有多种类型。
例如,一个人的年龄可以用数字来存储,他的名字可以用字符来存储。
Python 定义了一些标准类型,用于存储各种类型的数据。
Python有五个标准的数据类型:
- Numbers(数字)
- String(字符串)
- List(列表)
- Tuple(元组)
- Dictionary(字典)
Python数字
数字数据类型用于存储数值。
他们是不可改变的数据类型,这意味着改变数字数据类型会分配一个新的对象。
当你指定一个值时,Number对象就会被创建:
var1 = 1
var2 = 10
您也可以使用del语句删除一些对象的引用。
del语句的语法是:
del var1[,var2[,var3[....,varN]]]]
您可以通过使用del语句删除单个或多个对象的引用。例如:
del var
del var_a, var_b
Python支持四种不同的数字类型:
- int(有符号整型)
- long(长整型[也可以代表八进制和十六进制])
- float(浮点型)
- complex(复数)
实例
一些数值类型的实例:
int |
long |
float |
complex |
10 |
51924361L |
0.0 |
3.14j |
100 |
-0x19323L |
15.20 |
45.j |
-786 |
0122L |
-21.9 |
9.322e-36j |
080 |
0xDEFABCECBDAECBFBAEl |
32.3e+18 |
.876j |
-0490 |
535633629843L |
-90. |
-.6545+0J |
-0x260 |
-052318172735L |
-32.54e100 |
3e+26J |
0x69 |
-4721885298529L |
70.2E-12 |
4.53e-7j |
- 长整型也可以使用小写 l,但是还是建议您使用大写 L,避免与数字 1 混淆。Python使用 L 来显示长整型。
- Python 还支持复数,复数由实数部分和虚数部分构成,可以用 a + bj,或者 complex(a,b) 表示, 复数的实部 a 和虚部 b 都是浮点型。
Python字符串
字符串或串(String)是由数字、字母、下划线组成的一串字符。
一般记为 :
s="a1a2···an"(n>=0)
它是编程语言中表示文本的数据类型。
python的字串列表有2种取值顺序:
- 从左到右索引默认0开始的,最大范围是字符串长度少1
- 从右到左索引默认-1开始的,最大范围是字符串开头
如果你要实现从字符串中获取一段子字符串的话,可以使用 [头下标:尾下标] 来截取相应的字符串,其中下标是从 0 开始算起,可以是正数或负数,下标可以为空表示取到头或尾。
[头下标:尾下标] 获取的子字符串包含头下标的字符,但不包含尾下标的字符。
比如:
>>> s = 'abcdef'>>> s[1:5]'bcde'
当使用以冒号分隔的字符串,python 返回一个新的对象,结果包含了以这对偏移标识的连续的内容,左边的开始是包含了下边界。
上面的结果包含了 s[1] 的值 b,而取到的最大范围不包括尾下标,就是 s[5] 的值 f。
加号(+)是字符串连接运算符,星号(*)是重复操作。如下实例:
实例(Python 2.0+)
#!/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" # 输出连接的字符串
以上实例输出结果:
Hello World!
H
llo
llo World!Hello World!Hello World!Hello World!TEST
Python列表
List(列表) 是 Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。它支持字符,数字,字符串甚至可以包含列表(即嵌套)。
列表用 [ ] 标识,是 python 最通用的复合数据类型。
列表中值的切割也可以用到变量 [头下标:尾下标] ,就可以截取相应的列表,从左到右索引默认 0 开始,从右到左索引默认 -1 开始,下标可以为空表示取到头或尾。
加号 + 是列表连接运算符,星号 * 是重复操作。如下实例:
实例(Python 2.0+)
#!/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 # 打印组合的列表
以上实例输出结果:
['runoob', 786, 2.23, 'john', 70.2]
runoob[786, 2.23][2.23, 'john', 70.2][123, 'john', 123, 'john']['runoob', 786, 2.23, 'john', 70.2, 123, 'john']
Python元组
元组是另一个数据类型,类似于List(列表)。
元组用"()"标识。内部元素用逗号隔开。但是元组不能二次赋值,相当于只读列表。
实例(Python 2.0+)
#!/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 # 打印组合的元组
以上实例输出结果:
('runoob', 786, 2.23, 'john', 70.2)
runoob(786, 2.23)(2.23, 'john', 70.2)(123, 'john', 123, 'john')('runoob', 786, 2.23, 'john', 70.2, 123, 'john')
以下是元组无效的,因为元组是不允许更新的。而列表是允许更新的:
实例(Python 2.0+)
#!/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 # 元组中是非法应用 list[2] = 1000 # 列表中是合法应用
Python 字典
字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象集合,字典是无序的对象集合。
两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。
字典用"{ }"标识。字典由索引(key)和它对应的值value组成。
实例(Python 2.0+)
#!/usr/bin/python # -*- coding: UTF-8 -*- dict = {} dict['one'] = "This is one" dict[2] = "This is two" tinydict = {'name': 'john','code':6734, 'dept': 'sales'} print dict['one'] # 输出键为'one' 的值 print dict[2] # 输出键为 2 的值 print tinydict # 输出完整的字典 print tinydict.keys() # 输出所有键 print tinydict.values() # 输出所有值
输出结果为:
This is oneThis is two{'dept': 'sales', 'code': 6734, 'name': 'john'}['dept', 'code', 'name']['sales', 6734, 'john']
Python数据类型转换
有时候,我们需要对数据内置的类型进行转换,数据类型的转换,你只需要将数据类型作为函数名即可。
以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象,表示转换的值。
函数 |
描述 |
将x转换为一个整数 |
|
将x转换为一个长整数 |
|
将x转换到一个浮点数 |
|
创建一个复数 |
|
将对象 x 转换为字符串 |
|
将对象 x 转换为表达式字符串 |
|
用来计算在字符串中的有效Python表达式,并返回一个对象 |
|
将序列 s 转换为一个元组 |
|
将序列 s 转换为一个列表 |
|
转换为可变集合 |
|
创建一个字典。d 必须是一个序列 (key,value)元组。 |
|
转换为不可变集合 |
|
将一个整数转换为一个字符 |
|
将一个整数转换为Unicode字符 |
|
将一个字符转换为它的整数值 |
|
将一个整数转换为一个十六进制字符串 |
|
将一个整数转换为一个八进制字符串 |
Python 运算符
什么是运算符?
本章节主要说明Python的运算符。举个简单的例子 4 +5 = 9 。 例子中,4 和 5 被称为操作数,"+" 称为运算符。
Python语言支持以下类型的运算符:
接下来让我们一个个来学习Python的运算符。
Python算术运算符
以下假设变量: a=10,b=20:
运算符 |
描述 |
实例 |
+ |
加 - 两个对象相加 |
a + b 输出结果 30 |
- |
减 - 得到负数或是一个数减去另一个数 |
a - b 输出结果 -10 |
* |
乘 - 两个数相乘或是返回一个被重复若干次的字符串 |
a * b 输出结果 200 |
/ |
除 - x除以y |
b / a 输出结果 2 |
% |
取模 - 返回除法的余数 |
b % a 输出结果 0 |
** |
幂 - 返回x的y次幂 |
a**b 为10的20次方, 输出结果 100000000000000000000 |
// |
取整除 - 返回商的整数部分(向下取整) |
9//2 输出结果 4 , 9.0//2.0 输出结果 4.0 |
以下实例演示了Python所有算术运算符的操作:
实例(Python 2.0+)
#!/usr/bin/python
# -*- coding: UTF-8 -*-
a = 21 b = 10 c = 0 c = a + b
print "1 - c 的值为:", c c = a - b
print "2 - c 的值为:", c c = a * b
print "3 - c 的值为:", c c = a /
b print "4 - c 的值为:", c c = a % b
print "5 - c 的值为:", c # 修改变量 a 、b 、c a = 2 b = 3 c = a**b
print "6 - c 的值为:", c a = 10 b = 5 c = a//b
print "7 - c 的值为:", c
以上实例输出结果:
1 - c 的值为: 312 - c 的值为: 113 - c 的值为: 2104 - c 的值为: 25 - c 的值为: 16 - c 的值为: 87 - c 的值为: 2
注意:Python2.x 里,整数除整数,只能得出整数。如果要得到小数部分,把其中一个数改成浮点数即可。
>>> 1/20>>> 1.0/20.5>>> 1/float(2)0.5
Python比较运算符
以下假设变量a为10,变量b为20:
运算符 |
描述 |
实例 |
== |
等于 - 比较对象是否相等 |
(a == b) 返回 False。 |
!= |
不等于 - 比较两个对象是否不相等 |
(a != b) 返回 true. |
<> |
不等于 - 比较两个对象是否不相等 |
(a <> b) 返回 true。这个运算符类似 != 。 |
> |
大于 - 返回x是否大于y |
(a > b) 返回 False。 |
< |
小于 - 返回x是否小于y。所有比较运算符返回1表示真,返回0表示假。这分别与特殊的变量True和False等价。 |
(a < b) 返回 true。 |
>= |
大于等于 - 返回x是否大于等于y。 |
(a >= b) 返回 False。 |
<= |
小于等于 - 返回x是否小于等于y。 |
(a <= b) 返回 true。 |
以下实例演示了Python所有比较运算符的操作:
实例(Python 2.0+)
#!/usr/bin/python # -*- coding: UTF-8 -*- a = 21 b = 10 c = 0 if ( a == b ): print "1 - a 等于 b" else: print "1 - a 不等于 b" if ( a != b ): print "2 - a 不等于 b" else: print "2 - a 等于 b" if ( a <> b ): print "3 - a 不等于 b" else: print "3 - a 等于 b" if ( a < b ): print "4 - a 小于 b" else: print "4 - a 大于等于 b" if ( a > b ): print "5 - a 大于 b" else: print "5 - a 小于等于 b" # 修改变量 a 和 b 的值 a = 5 b = 20 if ( a <= b ): print "6 - a 小于等于 b" else: print "6 - a 大于 b" if ( b >= a ): print "7 - b 大于等于 a" else: print "7 - b 小于 a"
以上实例输出结果:
1 - a 不等于 b2 - a 不等于 b3 - a 不等于 b4 - a 大于等于 b5 - a 大于 b6 - a 小于等于 b7 - b 大于等于 a
Python赋值运算符
以下假设变量a为10,变量b为20:
运算符 |
描述 |
实例 |
= |
简单的赋值运算符 |
c = a + b 将 a + b 的运算结果赋值为 c |
+= |
加法赋值运算符 |
c += a 等效于 c = c + a |
-= |
减法赋值运算符 |
c -= a 等效于 c = c - a |
*= |
乘法赋值运算符 |
c *= a 等效于 c = c * a |
/= |
除法赋值运算符 |
c /= a 等效于 c = c / a |
%= |
取模赋值运算符 |
c %= a 等效于 c = c % a |
**= |
幂赋值运算符 |
c **= a 等效于 c = c ** a |
//= |
取整除赋值运算符 |
c //= a 等效于 c = c // a |
以下实例演示了Python所有赋值运算符的操作:
实例(Python 2.0+)
#!/usr/bin/python # -*- coding: UTF-8 -*- a = 21 b = 10 c = 0 c = a + b print "1 - c 的值为:", c c += a print "2 - c 的值为:", c c *= a print "3 - c 的值为:", c c /= a print "4 - c 的值为:", c c = 2 c %= a print "5 - c 的值为:", c c **= a print "6 - c 的值为:", c c //= a print "7 - c 的值为:", c
以上实例输出结果:
1 - c 的值为: 312 - c 的值为: 523 - c 的值为: 10924 - c 的值为: 525 - c 的值为: 26 - c 的值为: 20971527 - c 的值为: 99864
Python位运算符
按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下:
下表中变量 a 为 60,b 为 13,二进制格式如下:
a = 0011 1100
b = 0000 1101
-----------------
a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
~a = 1100 0011
运算符 |
描述 |
实例 |
& |
按位与运算符:参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 |
(a & b) 输出结果 12 ,二进制解释: 0000 1100 |
| |
按位或运算符:只要对应的二个二进位有一个为1时,结果位就为1。 |
(a | b) 输出结果 61 ,二进制解释: 0011 1101 |
^ |
按位异或运算符:当两对应的二进位相异时,结果为1 |
(a ^ b) 输出结果 49 ,二进制解释: 0011 0001 |
~ |
按位取反运算符:对数据的每个二进制位取反,即把1变为0,把0变为1 。~x 类似于 -x-1 |
(~a ) 输出结果 -61 ,二进制解释: 1100 0011,在一个有符号二进制数的补码形式。 |
<< |
左移动运算符:运算数的各二进位全部左移若干位,由 << 右边的数字指定了移动的位数,高位丢弃,低位补0。 |
a << 2 输出结果 240 ,二进制解释: 1111 0000 |
>> |
右移动运算符:把">>"左边的运算数的各二进位全部右移若干位,>> 右边的数字指定了移动的位数 |
a >> 2 输出结果 15 ,二进制解释: 0000 1111 |
以下实例演示了Python所有位运算符的操作:
实例(Python 2.0+)
#!/usr/bin/python # -*- coding: UTF-8 -*- a = 60 # 60 = 0011 1100 b = 13 # 13 = 0000 1101 c = 0 c = a & b; # 12 = 0000 1100 print "1 - c 的值为:", c c = a | b; # 61 = 0011 1101 print "2 - c 的值为:", c c = a ^ b; # 49 = 0011 0001 print "3 - c 的值为:", c c = ~a; # -61 = 1100 0011 print "4 - c 的值为:", c c = a << 2; # 240 = 1111 0000 print "5 - c 的值为:", c c = a >> 2; # 15 = 0000 1111 print "6 - c 的值为:", c
以上实例输出结果:
1 - c 的值为: 122 - c 的值为: 613 - c 的值为: 494 - c 的值为: -615 - c 的值为: 2406 - c 的值为: 15
Python逻辑运算符
Python语言支持逻辑运算符,以下假设变量 a 为 10, b为 20:
运算符 |
逻辑表达式 |
描述 |
实例 |
and |
x and y |
布尔"与" - 如果 x 为 False,x and y 返回 False,否则它返回 y 的计算值。 |
(a and b) 返回 20。 |
or |
x or y |
布尔"或" - 如果 x 是非 0,它返回 x 的值,否则它返回 y 的计算值。 |
(a or b) 返回 10。 |
not |
not x |
布尔"非" - 如果 x 为 True,返回 False 。如果 x 为 False,它返回 True。 |
not(a and b) 返回 False |
以上实例输出结果:
实例(Python 2.0+)
#!/usr/bin/python # -*- coding: UTF-8 -*- a = 10 b = 20 if ( a and b ): print "1 - 变量 a 和 b 都为 true" else: print "1 - 变量 a 和 b 有一个不为 true" if ( a or b ): print "2 - 变量 a 和 b 都为 true,或其中一个变量为 true" else: print "2 - 变量 a 和 b 都不为 true" # 修改变量 a 的值 a = 0 if ( a and b ): print "3 - 变量 a 和 b 都为 true" else: print "3 - 变量 a 和 b 有一个不为 true" if ( a or b ): print "4 - 变量 a 和 b 都为 true,或其中一个变量为 true" else: print "4 - 变量 a 和 b 都不为 true" if not( a and b ): print "5 - 变量 a 和 b 都为 false,或其中一个变量为 false" else: print "5 - 变量 a 和 b 都为 true"
以上实例输出结果:
1 - 变量 a 和 b 都为 true2 - 变量 a 和 b 都为 true,或其中一个变量为 true3 - 变量 a 和 b 有一个不为 true4 - 变量 a 和 b 都为 true,或其中一个变量为 true5 - 变量 a 和 b 都为 false,或其中一个变量为 false
Python成员运算符
除了以上的一些运算符之外,Python还支持成员运算符,测试实例中包含了一系列的成员,包括字符串,列表或元组。
运算符 |
描述 |
实例 |
in |
如果在指定的序列中找到值返回 True,否则返回 False。 |
x 在 y 序列中 , 如果 x 在 y 序列中返回 True。 |
not in |
如果在指定的序列中没有找到值返回 True,否则返回 False。 |
x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。 |
以下实例演示了Python所有成员运算符的操作:
实例(Python 2.0+)
#!/usr/bin/python # -*- coding: UTF-8 -*- a = 10 b = 20 list = [1, 2, 3, 4, 5 ]; if ( a in list ): print "1 - 变量 a 在给定的列表中 list 中" else: print "1 - 变量 a 不在给定的列表中 list 中" if ( b not in list ): print "2 - 变量 b 不在给定的列表中 list 中" else: print "2 - 变量 b 在给定的列表中 list 中" # 修改变量 a 的值 a = 2 if ( a in list ): print "3 - 变量 a 在给定的列表中 list 中" else: print "3 - 变量 a 不在给定的列表中 list 中"
以上实例输出结果:
1 - 变量 a 不在给定的列表中 list 中2 - 变量 b 不在给定的列表中 list 中3 - 变量 a 在给定的列表中 list 中
Python身份运算符
身份运算符用于比较两个对象的存储单元
运算符 |
描述 |
实例 |
is |
is 是判断两个标识符是不是引用自一个对象 |
x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True,否则返回 False |
is not |
is not 是判断两个标识符是不是引用自不同对象 |
x is not y , 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True,否则返回 False。 |
注: id() 函数用于获取对象内存地址。
以下实例演示了Python所有身份运算符的操作:
实例(Python 2.0+)
#!/usr/bin/python # -*- coding: UTF-8 -*- a = 20 b = 20 if ( a is b ): print "1 - a 和 b 有相同的标识" else: print "1 - a 和 b 没有相同的标识" if ( a is not b ): print "2 - a 和 b 没有相同的标识" else: print "2 - a 和 b 有相同的标识" # 修改变量 b 的值 b = 30 if ( a is b ): print "3 - a 和 b 有相同的标识" else: print "3 - a 和 b 没有相同的标识" if ( a is not b ): print "4 - a 和 b 没有相同的标识" else: print "4 - a 和 b 有相同的标识"
以上实例输出结果:
1 - a 和 b 有相同的标识2 - a 和 b 有相同的标识3 - a 和 b 没有相同的标识4 - a 和 b 没有相同的标识
is 与 == 区别:
is 用于判断两个变量引用对象是否为同一个, == 用于判断引用变量的值是否相等。
>>> a = [1, 2, 3]>>> b = a>>> b is a True>>> b == aTrue>>> b = a[:]>>> b is aFalse>>> b == aTrue
Python运算符优先级
以下表格列出了从最高到最低优先级的所有运算符:
运算符 |
描述 |
** |
指数 (最高优先级) |
~ + - |
按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) |
* / % // |
乘,除,取模和取整除 |
+ - |
加法减法 |
>> << |
右移,左移运算符 |
& |
位 'AND' |
^ | |
位运算符 |
<= < > >= |
比较运算符 |
<> == != |
等于运算符 |
= %= /= //= -= += *= **= |
赋值运算符 |
is is not |
身份运算符 |
in not in |
成员运算符 |
not and or |
逻辑运算符 |
以下实例演示了Python所有运算符优先级的操作:
实例(Python 2.0+)
#!/usr/bin/python # -*- coding: UTF-8 -*- a = 20 b = 10 c = 15 d = 5 e = 0 e = (a + b) * c / d #( 30 * 15 ) / 5 print "(a + b) * c / d 运算结果为:", e e = ((a + b) * c) / d # (30 * 15 ) / 5 print "((a + b) * c) / d 运算结果为:", e e = (a + b) * (c / d); # (30) * (15/5) print "(a + b) * (c / d) 运算结果为:", e e = a + (b * c) / d; # 20 + (150/5) print "a + (b * c) / d 运算结果为:", e
以上实例输出结果:
(a + b) * c / d 运算结果为: 90((a + b) * c) / d 运算结果为: 90(a + b) * (c / d) 运算结果为: 90
a + (b * c) / d 运算结果为: 50
Python 条件语句
Python条件语句是通过一条或多条语句的执行结果(True或者False)来决定执行的代码块。
可以通过下图来简单了解条件语句的执行过程:
Python程序语言指定任何非0和非空(null)值为true,0 或者 null为false。
Python 编程中 if 语句用于控制程序的执行,基本形式为:
if 判断条件:
执行语句……else:
执行语句……
其中"判断条件"成立时(非零),则执行后面的语句,而执行内容可以多行,以缩进来区分表示同一范围。
else 为可选语句,当需要在条件不成立时执行内容则可以执行相关语句,具体例子如下:
实例
#!/usr/bin/python # -*- coding: UTF-8 -*- # 例1:if 基本用法 flag = False name = 'luren' if name == 'python': # 判断变量否为'python' flag = True # 条件成立时设置标志为真 print 'welcome boss' # 并输出欢迎信息 else: print name # 条件不成立时输出变量名称
输出结果为:
luren # 输出结果
if 语句的判断条件可以用>(大于)、<(小于)、==(等于)、>=(大于等于)、<=(小于等于)来表示其关系。
当判断条件为多个值时,可以使用以下形式:
if 判断条件1:
执行语句1……elif 判断条件2:
执行语句2……elif 判断条件3:
执行语句3……else:
执行语句4……
实例如下:
实例
#!/usr/bin/python # -*- coding: UTF-8 -*- # 例2:elif用法
num = 5 if num == 3: # 判断num的值
print 'boss' elif num == 2:
print 'user' elif num == 1:
print 'worker' elif num < 0: # 值小于零时输出
print 'error' else: print 'roadman' # 条件均不成立时输出
输出结果为:
roadman # 输出结果
由于 python 并不支持 switch 语句,所以多个条件判断,只能用 elif 来实现,如果判断需要多个条件需同时判断时,可以使用 or (或),表示两个条件有一个成立时判断条件成功;使用 and (与)时,表示只有两个条件同时成立的情况下,判断条件才成功。
实例
#!/usr/bin/python # -*- coding: UTF-8 -*- # 例3:if语句多个条件 num = 9 if num >= 0 and num <= 10: # 判断值是否在0~10之间 print 'hello' # 输出结果: hello num = 10 if num < 0 or num > 10: # 判断值是否在小于0或大于10 print 'hello' else: print 'undefine' # 输出结果: undefine num = 8 # 判断值是否在0~5或者10~15之间 if (num >= 0 and num <= 5) or (num >= 10 and num <= 15): print 'hello' else: print 'undefine' # 输出结果: undefine
当if有多个条件时可使用括号来区分判断的先后顺序,括号中的判断优先执行,此外 and 和 or 的优先级低于>(大于)、<(小于)等判断符号,即大于和小于在没有括号的情况下会比与或要优先判断。
简单的语句组
你也可以在同一行的位置上使用if条件判断语句,如下实例:
实例
#!/usr/bin/python # -*- coding: UTF-8 -*- var = 100 if ( var == 100 ) : print "变量 var 的值为100" print "Good bye!"
以上代码执行输出结果如下:
变量 var 的值为100Good bye!
Python 循环语句
本章节将向大家介绍Python的循环语句,程序在一般情况下是按顺序执行的。
编程语言提供了各种控制结构,允许更复杂的执行路径。
循环语句允许我们执行一个语句或语句组多次,下面是在大多数编程语言中的循环语句的一般形式:
Python提供了for循环和while循环(在Python中没有do..while循环):
循环类型 |
描述 |
在给定的判断条件为 true 时执行循环体,否则退出循环体。 |
|
重复执行语句 |
|
你可以在while循环体中嵌套for循环 |
循环控制语句
循环控制语句可以更改语句执行的顺序。Python支持以下循环控制语句:
控制语句 |
描述 |
在语句块执行过程中终止循环,并且跳出整个循环 |
|
在语句块执行过程中终止当前循环,跳出该次循环,执行下一次循环。 |
|
pass是空语句,是为了保持程序结构的完整性。 |
Python pass 语句
Python pass是空语句,是为了保持程序结构的完整性。
pass 不做任何事情,一般用做占位语句。
Python 语言 pass 语句语法格式如下:
pass
实例:
#!/usr/bin/python# -*- coding: UTF-8 -*-
# 输出 Python 的每个字母for letter in 'Python':
if letter == 'h':
pass
print '这是 pass 块'
print '当前字母 :', letter
print "Good bye!"
以上实例执行结果:
当前字母 : P当前字母 : y当前字母 : t这是 pass 块当前字母 : h当前字母 : o当前字母 : nGood bye!
Python for 循环语句
Python for循环可以遍历任何序列的项目,如一个列表或者一个字符串。
语法:
for循环的语法格式如下:
for iterating_var in sequence:
statements(s)
实例:
实例
#!/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!"
尝一下 »
以上实例输出结果:
当前字母 : P当前字母 : y当前字母 : t当前字母 : h当前字母 : o当前字母 : n当前水果 : banana当前水果 : apple当前水果 : mangoGood bye!
通过序列索引迭代
另外一种执行循环的遍历方式是通过索引,如下实例:
实例
#!/usr/bin/python # -*- coding: UTF-8 -*- fruits = ['banana', 'apple', 'mango'] for index in range(len(fruits)): print '当前水果 :', fruits[index] print "Good bye!"
以上实例输出结果:
当前水果 : banana当前水果 : apple当前水果 : mangoGood bye!
以上实例我们使用了内置函数 len() 和 range(),函数 len() 返回列表的长度,即元素的个数。 range返回一个序列的数。
循环使用 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, '是一个质数'
以上实例输出结果:
10 等于 2 * 511 是一个质数12 等于 2 * 613 是一个质数14 等于 2 * 715 等于 3 * 516 等于 2 * 817 是一个质数18 等于 2 * 919 是一个质数
Python3常用内置函数
数学相关
- abs(a) : 求取绝对值。abs(-1)
- max(list) : 求取list最大值。max([1,2,3])
- min(list) : 求取list最小值。min([1,2,3])
- sum(list) : 求取list元素的和。 sum([1,2,3]) >>> 6
- sorted(list) : 排序,返回排序后的list。
- len(list) : list长度,len([1,2,3])
- divmod(a,b): 获取商和余数。 divmod(5,2) >>> (2,1)
- pow(a,b) : 获取乘方数。pow(2,3) >>> 8
- round(a,b) : 获取指定位数的小数。a代表浮点数,b代表要保留的位数。round(3.1415926,2) >>> 3.14
- range(a[,b]) : 生成一个a到b的数组,左闭右开。 range(1,10) >>> [1,2,3,4,5,6,7,8,9]
类型转换
- int(str) : 转换为int型。int('1') >>> 1
- float(int/str) : 将int型或字符型转换为浮点型。float('1') >>> 1.0
- str(int) : 转换为字符型。str(1) >>> '1'
- bool(int) : 转换为布尔类型。 str(0) >>> False str(None) >>> False
- bytes(str,code) : 接收一个字符串,与所要编码的格式,返回一个字节流类型。bytes('abc', 'utf-8') >>> b'abc' bytes(u'爬虫', 'utf-8') >>> b'\xe7\x88\xac\xe8\x99\xab'
- list(iterable) : 转换为list。 list((1,2,3)) >>> [1,2,3]
- iter(iterable): 返回一个可迭代的对象。 iter([1,2,3]) >>> <list_iterator object at 0x0000000003813B00>
- dict(iterable) : 转换为dict。 dict([('a', 1), ('b', 2), ('c', 3)]) >>> {'a':1, 'b':2, 'c':3}
- enumerate(iterable) : 返回一个枚举对象。
- tuple(iterable) : 转换为tuple。 tuple([1,2,3]) >>>(1,2,3)
- set(iterable) : 转换为set。 set([1,4,2,4,3,5]) >>> {1,2,3,4,5} set({1:'a',2:'b',3:'c'}) >>> {1,2,3}
相关操作
- eval() : 执行一个表达式,或字符串作为运算。 eval('1+1') >>> 2
- exec() : 执行python语句。 exec('print("Python")') >>> Python
- filter(func, iterable) : 通过判断函数fun,筛选符合条件的元素。 filter(lambda x: x>3, [1,2,3,4,5,6]) >>> <filter object at 0x0000000003813828>
- map(func, *iterable) : 将func用于每个iterable对象。 map(lambda a,b: a+b, [1,2,3,4], [5,6,7]) >>> [6,8,10]
- zip(*iterable) : 将iterable分组合并。返回一个zip对象。 list(zip([1,2,3],[4,5,6])) >>> [(1, 4), (2, 5), (3, 6)]
- type():返回一个对象的类型。
- id(): 返回一个对象的唯一标识值。
- hash(object):返回一个对象的hash值,具有相同值的object具有相同的hash值。 hash('python') >>> 7070808359261009780
- help():调用系统内置的帮助系统。
- isinstance():判断一个对象是否为该类的一个实例。
- issubclass():判断一个类是否为另一个类的子类。
- globals() : 返回当前全局变量的字典。
- next(iterator[, default]) : 接收一个迭代器,返回迭代器中的数值,如果设置了default,则当迭代器中的元素遍历后,输出default内容。
- reversed(sequence) : 生成一个反转序列的迭代器。 reversed('abc') >>> ['c','b','a']
Python 函数
函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。
函数能提高应用的模块性,和代码的重复利用率。你已经知道Python提供了许多内建函数,比如print()。但你也可以自己创建函数,这被叫做用户自定义函数。
定义一个函数
你可以定义一个由自己想要功能的函数,以下是简单的规则:
- 函数代码块以 def 关键词开头,后接函数标识符名称和圆括号()。
- 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
- 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
- 函数内容以冒号起始,并且缩进。
- return [表达式] 结束函数,选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
语法
def functionname( parameters ):
"函数_文档字符串" function_suite
return [expression]
默认情况下,参数值和参数名称是按函数声明中定义的顺序匹配起来的。
实例
以下为一个简单的Python函数,它将一个字符串作为传入参数,再打印到标准显示设备上。
实例(Python 2.0+)
def printme( str ):
"打印传入的字符串到标准显示设备上"
print str
return
函数调用
定义一个函数只给了函数一个名称,指定了函数里包含的参数,和代码块结构。
这个函数的基本结构完成以后,你可以通过另一个函数调用执行,也可以直接从Python提示符执行。
如下实例调用了printme()函数:
实例(Python 2.0+)
#!/usr/bin/python # -*- coding: UTF-8 -*- # 定义函数
def printme( str ):
"打印任何传入的字符串"
print str; return; # 调用函数
printme("我要调用用户自定义函数!");
printme("再次调用同一函数");
以上实例输出结果:
我要调用用户自定义函数!再次调用同一函数
参数传递
在 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 传不可变对象实例
实例(Python 2.0+)
#!/usr/bin/python # -*- coding: UTF-8 -*-
def ChangeInt( a ):
a = 10
b = 2 ChangeInt(b)
print b # 结果是 2
实例中有 int 对象 2,指向它的变量是 b,在传递给 ChangeInt 函数时,按传值的方式复制了变量 b,a 和 b 都指向了同一个 Int 对象,在 a=10 时,则新生成一个 int 值对象 10,并让 a 指向它。
传可变对象实例
实例(Python 2.0+)
#!/usr/bin/python # -*- coding: UTF-8 -*- # 可写函数说明 def changeme( mylist ): "修改传入的列表" mylist.append([1,2,3,4]); print "函数内取值: ", mylist return # 调用changeme函数 mylist = [10,20,30]; changeme( mylist ); print "函数外取值: ", mylist
实例中传入函数的和在末尾添加新内容的对象用的是同一个引用,故输出结果如下:
函数内取值: [10, 20, 30, [1, 2, 3, 4]]函数外取值: [10, 20, 30, [1, 2, 3, 4]]
参数
以下是调用函数时可使用的正式参数类型:
- 必备参数
- 关键字参数
- 默认参数
- 不定长参数
必备参数
必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
调用printme()函数,你必须传入一个参数,不然会出现语法错误:
实例(Python 2.0+)
#!/usr/bin/python # -*- coding: UTF-8 -*- #可写函数说明 def printme( str ): "打印任何传入的字符串" print str; return; #调用printme函数 printme();
以上实例输出结果:
Traceback (most recent call last):
File "test.py", line 11, in <module>
printme();TypeError: printme() takes exactly 1 argument (0 given)
关键字参数
关键字参数和函数调用关系紧密,函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致,因为 Python 解释器能够用参数名匹配参数值。
以下实例在函数 printme() 调用时使用参数名:
实例(Python 2.0+)
#!/usr/bin/python # -*- coding: UTF-8 -*- #可写函数说明 def printme( str ): "打印任何传入的字符串" print str; return; #调用printme函数 printme( str = "My string");
以上实例输出结果:
My string
下例能将关键字参数顺序不重要展示得更清楚:
实例(Python 2.0+)
#!/usr/bin/python # -*- coding: UTF-8 -*- #可写函数说明 def printinfo( name, age ): "打印任何传入的字符串" print "Name: ", name; print "Age ", age; return; #调用printinfo函数 printinfo( age=50, name="miki" );
以上实例输出结果:
Name: mikiAge 50
缺省参数
调用函数时,缺省参数的值如果没有传入,则被认为是默认值。下例会打印默认的age,如果age没有被传入:
实例(Python 2.0+)
#!/usr/bin/python # -*- coding: UTF-8 -*- #可写函数说明 def printinfo( name, age = 35 ): "打印任何传入的字符串" print "Name: ", name; print "Age ", age; return; #调用printinfo函数 printinfo( age=50, name="miki" ); printinfo( name="miki" );
以上实例输出结果:
Name: mikiAge 50Name: mikiAge 35
不定长参数
你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数,和上述2种参数不同,声明时不会命名。基本语法如下:
def functionname([formal_args,] *var_args_tuple ):
"函数_文档字符串"
function_suite
return [expression]
加了星号(*)的变量名会存放所有未命名的变量参数。不定长参数实例如下:
实例(Python 2.0+)
#!/usr/bin/python # -*- coding: UTF-8 -*- # 可写函数说明
def printinfo( arg1, *vartuple ):
"打印任何传入的参数"
print "输出: "
print arg1 for var in vartuple: print var return; # 调用printinfo 函数
printinfo( 10 );
printinfo( 70, 60, 50 );
以上实例输出结果:
输出:10输出:706050
匿名函数
python 使用 lambda 来创建匿名函数。
- lambda只是一个表达式,函数体比def简单很多。
- lambda的主体是一个表达式,而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
- lambda函数拥有自己的命名空间,且不能访问自有参数列表之外或全局命名空间里的参数。
- 虽然lambda函数看起来只能写一行,却不等同于C或C++的内联函数,后者的目的是调用小函数时不占用栈内存从而增加运行效率。
语法
lambda函数的语法只包含一个语句,如下:
lambda [arg1 [,arg2,.....argn]]:expression
如下实例:
实例(Python 2.0+)
#!/usr/bin/python # -*- coding: UTF-8 -*- # 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2;
# 调用sum函数
print "相加后的值为 : ", sum( 10, 20 )
print "相加后的值为 : ", sum( 20, 20 )
以上实例输出结果:
相加后的值为 : 30相加后的值为 : 40
return 语句
return语句[表达式]退出函数,选择性地向调用方返回一个表达式。不带参数值的return语句返回None。之前的例子都没有示范如何返回数值,下例便告诉你怎么做:
实例(Python 2.0+)
#!/usr/bin/python # -*- coding: UTF-8 -*- # 可写函数说明
def sum( arg1, arg2 ):
# 返回2个参数的和."
total = arg1 + arg2
print "函数内 : ", total
return total;
# 调用sum函数
total = sum( 10, 20 );
以上实例输出结果:
函数内 : 30
变量作用域
一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。
变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。两种最基本的变量作用域如下:
- 全局变量
- 局部变量
全局变量和局部变量
定义在函数内部的变量拥有一个局部作用域,定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问,而全局变量可以在整个程序范围内访问。调用函数时,所有在函数内声明的变量名称都将被加入到作用域中。如下实例:
实例(Python 2.0+)
#!/usr/bin/python # -*- coding: UTF-8 -*-
total = 0; # 这是一个全局变量 # 可写函数说明
def sum( arg1, arg2 ): #返回2个参数的和."
total = arg1 + arg2; # total在这里是局部变量.
print "函数内是局部变量 : ", total
return total;
#调用sum函数
sum( 10, 20 ); print "函数外是全局变量 : ", total
以上实例输出结果:
函数内是局部变量 : 30函数外是全局变量 : 0
Python 模块
Python 模块(Module),是一个 Python 文件,以 .py 结尾,包含了 Python 对象定义和Python语句。
模块让你能够有逻辑地组织你的 Python 代码段。
把相关的代码分配到一个模块里能让你的代码更好用,更易懂。
模块能定义函数,类和变量,模块里也能包含可执行的代码。
例子
下例是个简单的模块 support.py:
support.py 模块:
def print_func( par ): print "Hello : ", par return
import 语句
模块的引入
模块定义好后,我们可以使用 import 语句来引入模块,语法如下:
import module1[, module2[,... moduleN]
比如要引用模块 math,就可以在文件最开始的地方用 import math 来引入。在调用 math 模块中的函数时,必须这样引用:
模块名.函数名
当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。
搜索路径是一个解释器会先进行搜索的所有目录的列表。如想要导入模块 support.py,需要把命令放在脚本的顶端:
test.py 文件代码:
#!/usr/bin/python # -*- coding: UTF-8 -*- # 导入模块 import support # 现在可以调用模块里包含的函数了 support.print_func("Runoob")
以上实例输出结果:
Hello : Runoob
一个模块只会被导入一次,不管你执行了多少次import。这样可以防止导入模块被一遍又一遍地执行。
from…import 语句
Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中。语法如下:
from modname import name1[, name2[, ... nameN]]
例如,要导入模块 fib 的 fibonacci 函数,使用如下语句:
from fib import fibonacci
这个声明不会把整个 fib 模块导入到当前的命名空间中,它只会将 fib 里的 fibonacci 单个引入到执行这个声明的模块的全局符号表。
from…import* 语句
把一个模块的所有内容全都导入到当前的命名空间也是可行的,只需使用如下声明:
from modname import *
这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。
例如我们想一次性引入 math 模块中所有的东西,语句如下:
from math import *
搜索路径
当你导入一个模块,Python 解析器对模块位置的搜索顺序是:
- 1、当前目录
- 2、如果不在当前目录,Python 则搜索在 shell 变量 PYTHONPATH 下的每个目录。
- 3、如果都找不到,Python会察看默认路径。UNIX下,默认路径一般为/usr/local/lib/python/。
模块搜索路径存储在 system 模块的 sys.path 变量中。变量里包含当前目录,PYTHONPATH和由安装过程决定的默认目录。
PYTHONPATH 变量
作为环境变量,PYTHONPATH 由装在一个列表里的许多目录组成。PYTHONPATH 的语法和 shell 变量 PATH 的一样。
在 Windows 系统,典型的 PYTHONPATH 如下:
set PYTHONPATH=c:\python27\lib;
在 UNIX 系统,典型的 PYTHONPATH 如下:
set PYTHONPATH=/usr/local/lib/python
命名空间和作用域
变量是拥有匹配对象的名字(标识符)。命名空间是一个包含了变量名称们(键)和它们各自相应的对象们(值)的字典。
一个 Python 表达式可以访问局部命名空间和全局命名空间里的变量。如果一个局部变量和一个全局变量重名,则局部变量会覆盖全局变量。
每个函数都有自己的命名空间。类的方法的作用域规则和通常函数的一样。
Python 会智能地猜测一个变量是局部的还是全局的,它假设任何在函数内赋值的变量都是局部的。
因此,如果要给函数内的全局变量赋值,必须使用 global 语句。
global VarName 的表达式会告诉 Python, VarName 是一个全局变量,这样 Python 就不会在局部命名空间里寻找这个变量了。
例如,我们在全局命名空间里定义一个变量 Money。我们再在函数内给变量 Money 赋值,然后 Python 会假定 Money 是一个局部变量。然而,我们并没有在访问前声明一个局部变量 Money,结果就是会出现一个 UnboundLocalError 的错误。取消 global 语句的注释就能解决这个问题。
#!/usr/bin/python# -*- coding: UTF-8 -*-
Money = 2000def AddMoney():
# 想改正代码就取消以下注释:
# global Money
Money = Money + 1
print MoneyAddMoney()print Money
dir()函数
dir() 函数一个排好序的字符串列表,内容是一个模块里定义过的名字。
返回的列表容纳了在一个模块里定义的所有模块,变量和函数。如下一个简单的实例:
#!/usr/bin/python# -*- coding: UTF-8 -*-
# 导入内置math模块import math
content = dir(math)
print content;
以上实例输出结果:
['__doc__', '__file__', '__name__', 'acos', 'asin', 'atan', 'atan2', 'ceil', 'cos', 'cosh', 'degrees', 'e', 'exp', 'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log','log10', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh']
在这里,特殊字符串变量__name__指向模块的名字,__file__指向该模块的导入文件名。
globals() 和 locals() 函数
根据调用地方的不同,globals() 和 locals() 函数可被用来返回全局和局部命名空间里的名字。
如果在函数内部调用 locals(),返回的是所有能在该函数里访问的命名。
如果在函数内部调用 globals(),返回的是所有在该函数里能访问的全局名字。
两个函数的返回类型都是字典。所以名字们能用 keys() 函数摘取。
reload() 函数
当一个模块被导入到一个脚本,模块顶层部分的代码只会被执行一次。
因此,如果你想重新执行模块里顶层部分的代码,可以用 reload() 函数。该函数会重新导入之前导入过的模块。语法如下:
reload(module_name)
在这里,module_name要直接放模块的名字,而不是一个字符串形式。比如想重载 hello 模块,如下:
reload(hello)
Python中的包
包是一个分层次的文件目录结构,它定义了一个由模块及子包,和子包下的子包等组成的 Python 的应用环境。
简单来说,包就是文件夹,但该文件夹下必须存在 __init__.py 文件, 该文件的内容可以为空。__init__.py 用于标识当前文件夹是一个包。
考虑一个在 package_runoob 目录下的 runoob1.py、runoob2.py、__init__.py 文件,test.py 为测试调用包的代码,目录结构如下:
test.py
package_runoob|-- __init__.py|-- runoob1.py|-- runoob2.py
源代码如下:
package_runoob/runoob1.py
#!/usr/bin/python # -*- coding: UTF-8 -*- def runoob1(): print "I'm in runoob1"
package_runoob/runoob2.py
#!/usr/bin/python # -*- coding: UTF-8 -*- def runoob2(): print "I'm in runoob2"
现在,在 package_runoob 目录下创建 __init__.py:
package_runoob/__init__.py
#!/usr/bin/python # -*- coding: UTF-8 -*- if __name__ == '__main__': print '作为主程序运行' else: print 'package_runoob 初始化'
然后我们在 package_runoob 同级目录下创建 test.py 来调用 package_runoob 包
test.py
#!/usr/bin/python # -*- coding: UTF-8 -*- # 导入 Phone 包 from package_runoob.runoob1 import runoob1 from package_runoob.runoob2 import runoob2 runoob1() runoob2()
以上实例输出结果:
package_runoob 初始化
I'm in runoob1
I'm in runoob2
如上,为了举例,我们只在每个文件里放置了一个函数,但其实你可以放置许多函数。你也可以在这些文件里定义Python的类,然后为这些类建一个包。
Python 日期和时间
Python 程序能用很多方式处理日期和时间,转换日期格式是一个常见的功能。
Python 提供了一个 time 和 calendar 模块可以用于格式化日期和时间。
时间间隔是以秒为单位的浮点小数。
每个时间戳都以自从1970年1月1日午夜(历元)经过了多长时间来表示。
Python 的 time 模块下有很多函数可以转换常见日期格式。如函数time.time()用于获取当前时间戳, 如下实例:
实例(Python 2.0+)
#!/usr/bin/python # -*- coding: UTF-8 -*- import time; # 引入time模块 ticks = time.time() print "当前时间戳为:", ticks
以上实例输出结果:
当前时间戳为: 1459994552.51
时间戳单位最适于做日期运算。但是1970年之前的日期就无法以此表示了。太遥远的日期也不行,UNIX和Windows只支持到2038年。
什么是时间元组?
很多Python函数用一个元组装起来的9组数字处理时间:
序号 |
字段 |
值 |
0 |
4位数年 |
2008 |
1 |
月 |
1 到 12 |
2 |
日 |
1到31 |
3 |
小时 |
0到23 |
4 |
分钟 |
0到59 |
5 |
秒 |
0到61 (60或61 是闰秒) |
6 |
一周的第几日 |
0到6 (0是周一) |
7 |
一年的第几日 |
1到366 (儒略历) |
8 |
夏令时 |
-1, 0, 1, -1是决定是否为夏令时的旗帜 |
上述也就是struct_time元组。这种结构具有如下属性:
序号 |
属性 |
值 |
0 |
tm_year |
2008 |
1 |
tm_mon |
1 到 12 |
2 |
tm_mday |
1 到 31 |
3 |
tm_hour |
0 到 23 |
4 |
tm_min |
0 到 59 |
5 |
tm_sec |
0 到 61 (60或61 是闰秒) |
6 |
tm_wday |
0到6 (0是周一) |
7 |
tm_yday |
1 到 366(儒略历) |
8 |
tm_isdst |
-1, 0, 1, -1是决定是否为夏令时的旗帜 |
获取当前时间
从返回浮点数的时间戳方式向时间元组转换,只要将浮点数传递给如localtime之类的函数。
#!/usr/bin/python # -*- coding: UTF-8 -*-
import time localtime = time.localtime(time.time())
print "本地时间为 :", localtime
以上实例输出结果:
本地时间为 : time.struct_time(tm_year=2016, tm_mon=4, tm_mday=7, tm_hour=10, tm_min=3, tm_sec=27, tm_wday=3, tm_yday=98, tm_isdst=0)
获取格式化的时间
你可以根据需求选取各种格式,但是最简单的获取可读的时间模式的函数是asctime():
#!/usr/bin/python # -*- coding: UTF-8 -*-
import time localtime = time.asctime( time.localtime(time.time()) )
print "本地时间为 :", localtime
以上实例输出结果:
本地时间为 : Thu Apr 7 10:05:21 2016
格式化日期
我们可以使用 time 模块的 strftime 方法来格式化日期,:
time.strftime(format[, t])
实例演示:
#!/usr/bin/python # -*- coding: UTF-8 -*- import time
# 格式化成2016-03-20 11:45:39形式 print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) #
格式化成Sat Mar 28 22:24:24 2016形式 print time.strftime("%a %b %d %H:%M:%S %Y", time.localtime())
# 将格式字符串转换为时间戳 a = "Sat Mar 28 22:24:24 2016" print time.mktime(time.strptime(a,"%a %b %d %H:%M:%S %Y"))
以上实例输出结果:
2016-04-07 10:25:09Thu Apr 07 10:25:09 20161459175064.0
python中时间日期格式化符号:
- %y 两位数的年份表示(00-99)
- %Y 四位数的年份表示(000-9999)
- %m 月份(01-12)
- %d 月内中的一天(0-31)
- %H 24小时制小时数(0-23)
- %I 12小时制小时数(01-12)
- %M 分钟数(00=59)
- %S 秒(00-59)
- %a 本地简化星期名称
- %A 本地完整星期名称
- %b 本地简化的月份名称
- %B 本地完整的月份名称
- %c 本地相应的日期表示和时间表示
- %j 年内的一天(001-366)
- %p 本地A.M.或P.M.的等价符
- %U 一年中的星期数(00-53)星期天为星期的开始
- %w 星期(0-6),星期天为星期的开始
- %W 一年中的星期数(00-53)星期一为星期的开始
- %x 本地相应的日期表示
- %X 本地相应的时间表示
- %Z 当前时区的名称
- %% %号本身
获取某月日历
Calendar模块有很广泛的方法用来处理年历和月历,例如打印某月的月历:
#!/usr/bin/python # -*- coding: UTF-8 -*-
import calendar
cal = calendar.month(2016, 1)
print "以下输出2016年1月份的日历:"
print cal
以上实例输出结果:
以下输出2016年1月份的日历:
January 2016Mo Tu We Th Fr Sa Su
1 2 3
4 5 6 7 8 9 1011 12 13 14 15 16 1718 19 20 21 22 23 2425 26 27 28 29 30 31
Time 模块
Time 模块包含了以下内置函数,既有时间处理的,也有转换时间格式的:
序号 |
函数及描述 |
1 |
time.altzone |
2 |
time.asctime([tupletime]) |
3 |
time.clock( ) |
4 |
time.ctime([secs]) |
5 |
time.gmtime([secs]) |
6 |
time.localtime([secs]) |
7 |
time.mktime(tupletime) |
8 |
time.sleep(secs) |
9 |
time.strftime(fmt[,tupletime]) |
10 |
time.strptime(str,fmt='%a %b %d %H:%M:%S %Y') |
11 |
time.time( ) |
12 |
time.tzset() |
Time模块包含了以下2个非常重要的属性:
序号 |
属性及描述 |
1 |
time.timezone |
2 |
time.tzname |
日历(Calendar)模块
此模块的函数都是日历相关的,例如打印某月的字符月历。
星期一是默认的每周第一天,星期天是默认的最后一天。更改设置需调用calendar.setfirstweekday()函数。模块包含了以下内置函数:
序号 |
函数及描述 |
1 |
calendar.calendar(year,w=2,l=1,c=6) |
2 |
calendar.firstweekday( ) |
3 |
calendar.isleap(year) |
4 |
calendar.leapdays(y1,y2) |
5 |
calendar.month(year,month,w=2,l=1) |
6 |
calendar.monthcalendar(year,month) |
7 |
calendar.monthrange(year,month) |
8 |
calendar.prcal(year,w=2,l=1,c=6) |
9 |
calendar.prmonth(year,month,w=2,l=1) |
10 |
calendar.setfirstweekday(weekday) |
11 |
calendar.timegm(tupletime) |
12 |
calendar.weekday(year,month,day) |
其他相关模块和函数
在Python中,其他处理日期和时间的模块还有: