【Python】一文让你掌握Python27入门
文章目录
- 一、python基础
- 1.编码问题
- 2.Python 标识符
- 3.行与缩进
- 4.多行语句
- 5.引号、注释和空行
- 6.变量赋值
- 二、python进阶
- 7.Python数字
- 8.Python字符串
- 9.Python列表
- 10.Python元组
- 11.Python字典
- 12.数据类型的转换
- 13.python运算符
- 三、python语句
- 14.if-elif-else
- 15.for循环语句
- 16.pass语句
- 17.python函数
- 四、python文件和异常处理
- 18.Python 模块
- 19.Python 文件I/O
- 五、参考文献
一、python基础
1.编码问题
1.首先是代码中设置的编码问题,可以通过下面两行代码（二选一）解决问题
# coding=utf-8
# -*- coding: UTF-8 -*-
若不添加以上两行代码可能汇出入如下错误
2.然后是控制台中的编码问题，由于我们在代码中设置中文字符串，虽然在代码中设置了utf-8作为编码规范，但是在控制台（vs code）的默认是GBK2312编码，输入chcp可以查到它的编号，（GBK2312的编号是936），那要与代码中的编码匹配，则需要控制台的编码：chcp 65001，如此即可
chcp
#若不为65001，则修改编号
chcp 65001
导入库
找到python安装路径，其中有Scripts文件夹里有一个pip.exe文件，使用命令行进入该文件下，然后
#.\pip install [安装的库]，如导入xlrd库：
.\pip install xlrd
2.Python 标识符
以下划线开头的标识符是有特殊意义的。
以单下划线开头 _foo 的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xxx import * 而导入。
以双下划线开头的 __foo 代表类的私有成员，以双下划线开头和结尾的 foo 代表 Python 里特殊方法专用的标识，如 init() 代表类的构造函数。
3.行与缩进
Python 的代码块不使用大括号 {} 来控制类，函数以及其他逻辑判断。python 最具特色的就是用缩进来写模块。
缩进的空白数量是可变的，但是所有代码块语句必须包含相同的缩进空白数量，这个必须严格执行。
4.多行语句
Python语句中一般以新行作为语句的结束符。
但是我们可以使用斜杠（ \）将一行的语句分为多行显示，如下所示：
item_one = 1
item_two = 2
item_three = 3
total = item_one + \
item_two + \
item_three
print(total)
5.引号、注释和空行
引号：
Python 可以使用引号( ’ )、双引号( " )、三引号( ‘’’ 或 “”" ) 来表示字符串，引号的开始与结束必须是相同类型的。
注意：三引号可以由多行组成，编写多行文本的快捷语法，常用于文档字符串，在文件的特定地点，被当做注释。
word = 'word'
sentence = "这是一个句子。"
paragraph = """这是一个段落。
包含了多个语句"""
注释：
单行注释：#
多行注释：python 中多行注释使用三个单引号(’’’)或三个双引号(""")。——与引号中定义字符串不同的是，字符串都是有名字的。
#这是单行注释
"""
这是多行注释
这是多行注释
这是多行注释
"""
空行：
函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。
同一行显示多条语句：
Python可以在同一行中使用多条语句，语句之间使用分号(;)分割==（并不建议这样做）==
输出：
print 默认输出是换行的，如果要实现不换行需要在变量末尾加上逗号 ,。
x=1
y=2
print(x,y) #当括号中多于一个对象时，这是一种集合输出方式
print(x)
print(y)
print x,y
print x
print y
"""
输出：
(1, 2)
1
2
1 2
1
2
"""
6.变量赋值
赋值说明：
Python 中的变量赋值不需要类型声明。
每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。
每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
#类型测试
int1 = 1 #这是整型
float1 = 2.0 #这是浮点型
string1 = "hello world" #这是字符型
list1 = ['physics', 'chemistry', 1997, 2000] #这是列表型
tup1 = ('physics', 'chemistry', 1997, 2000) #这是元组
dict1 = {'a': 1, 'b': 2, 'b': '3'} #这是字典
print int1
print float1
print string1
print list1
print tup1
print dict1
print("------以下是类型------")
print(type(int1))
print(type(float1))
print(type(string1))
print(type(list1))
print(type(tup1))
print(type(dict1))
'''
输出：
1
2.0
hello world
['physics', 'chemistry', 1997, 2000]
('physics', 'chemistry', 1997, 2000)
{'a': 1, 'b': '3'}
------以下是类型------
'''
删除：
可以使用del语句删除一些对象的引用。
del语句的语法是：
del var1[,var2[,var3[....,varN]]]]
也可以通过使用del语句删除单个或多个对象的引用。例如：
del var
del var_a, var_b
二、python进阶
7.Python数字
python数学函数
#python中一些数字函数的用法
import math #在使用数学函数的时候要用到cmath和math库
num1 = -10.2
print "abs函数取数字的绝对值：",abs(num1) #取绝对值，输出10。和fabs库差不多
num2 = 3.14
num3 = 2
num4 = 3
num5 = 4.5
print "ceil函数取数字的向上取整：",math.ceil(num2) #输出4.0
print "cmp函数用于比较数字的大小：",cmp(num1,num2) #num1num2输出1
print "floor函数取数字的向下取整：",math.floor(num2) #输出3.0,返回的是一个浮点数
print "取一个最大值：",max(num1,num2) #输出3.14
print "取一个最小值：",min(num1,num2) #输出-10.2
print "幂次方",pow(2,3) #2的3次方
print "四舍五入：",round(num2),",",round(num5)
print "取根号：",math.sqrt(num3)
python随机数函数
#Python随机数函数
import math
import random #使用random函数就必须导入random包
list2 = list(range(10))
print list2
print "随机选择一个0~10之间的数:",random.choice(list2) #choice(s)函数用于随机选择序列s中的一个数
print "指定递增基数集合中的一个随机数，基数默认值为1: ", random.randrange(100, 1000, 2)
#开始为100，结束为1000，步长为2
print "随机生成一个0~1之间的随机数(后扩展为随机生成一个整数)：",int(math.ceil(random.random()*1000))
print "Random number with seed 10 : ", random.random()
random.shuffle(list2) #直接修改序列中的数随机排列
print "将序列中的数随机排列：",list2
print "随机生成一个在一定区间中的数：",random.uniform(1,10)
#seed设置一个种子，设置这个种子后，所有的随机数都在一定的规则中运行
print random.random()
print random.random()
print "------- 设置种子 seed -------"
random.seed( 10 )
print "Random number with seed 10 : ", random.random()
# 生成同一个随机数
random.seed( 10 )
print "Random number with seed 10 : ", random.random()
# 生成同一个随机数
random.seed( 10 )
8.Python字符串
python的字串列表有2种取值顺序:
- 从左到右索引默认0开始的，最大范围是字符串长度少1
- 从右到左索引默认-1开始的，最大范围是字符串开头
如果你要实现从字符串中获取一段子字符串的话，可以使用 [头下标:尾下标] 来截取相应的字符串，其中下标是从 0 开始算起，可以是正数或负数，下标可以为空表示取到头或尾。
[头下标:尾下标] 获取的子字符串包含头下标的字符，但不包含尾下标的字符。
str = 'Hello World!'
print str # 输出完整字符串
print str[0] # 输出字符串中的第一个字符
print str[2:5] # 输出字符串中第三个至第六个之间的字符串
print str[2:] # 输出从第三个字符开始的字符串
print str * 2 # 输出字符串两次
print str + "TEST" # 输出连接的字符串
hi = '''hi
there'''
print hi
"""
Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST
hi
theres
"""
#字符串拼接
var1 = 'Hello World!'
print "输出 :- ", var1[:6] + 'Runoob!' #字符串用加号拼接
#Python 字符串格式化
print "My name is %s and weight is %d kg!" % ('Zara', 21)
#输出：My name is Zara and weight is 21 kg!
元组和列表的区别：
1.元组使用小括号，列表使用方括号。
2.元组中的元素值是不允许修改的，但列表可以。
3.元组中的元素值是不允许删除的，但列表元素值可以删除。
4.同理，元组没有pop、insert、append等对元组进行修改删除插入的方法或函数。
Python字符串运算符
下表实例变量 a 值为字符串 “Hello”，b 变量值为 “Python”：
| 操作符 | 描述 | 实例 |
|---|---|---|
| + | 字符串连接 | >>>a + b ‘HelloPython’ |
| * | 重复输出字符串 | >>>a * 2 ‘HelloHello’ |
| [] | 通过索引获取字符串中字符 | >>>a[1] ‘e’ |
| [ : ] | 截取字符串中的一部分 | >>>a[1:4] ‘ell’ |
| in | 成员运算符 - 如果字符串中包含给定的字符返回 True | >>>“H” in a True |
| not in | 成员运算符 - 如果字符串中不包含给定的字符返回 True | >>>“M” not in a True |
| r/R | 原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母"r"（可以大小写）以外，与普通字符串有着几乎完全相同的语法。 | >>>print r’\n’ \n >>> print R’\n’ \n |
python字符串内建函数
#python的字符串内建函数
hello = "hello"
world = "world"
print hello.capitalize() #将字符串的第一个字符大写，不改变原字符类型
print hello.center(11,"=") #第一个参数为整个字符串的长度，第二个参数为将目标字符串居中后，前后字符位置填充的内容
print hello.count('l',0,len(hello)) #统计字符串里某个字符出现的次数
print hello.endswith("o",0,len(hello)) #用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回True，否则返回False
print hello.find("lo",0,len(hello)) #检测 str 是否包含在 string 中,返回的是开始时候的索引
print ("第一个字符串：{str1}, 第二个字符串：{str2}".format(str1=hello, str2=world))
print "第一个字符串：%s, 第二个字符串：%s" % (hello , world)
#增强了字符串格式化的功能。基本语法是通过 {} 和 : 来代替以前的 % 。
print hello.isalnum() #如果 string 至少有 一个字符 并且 所有字符 都是 字母或数字 则返回 True,否则返回 False
print hello.isalpha() #如果 string 至少有 一个字符 并且 所有字符 都是 字母 则返回 True,否则返回 False
str = "-"
seq = ("a", "b", "c") # 字符串序列
print "用join拼接后的数组：",str.join( seq ) #将序列中的元素以指定的字符连接生成一个新的字符串。
#这一部分可以查网址 菜鸟教程：https://www.runoob.com/python/python-strings.html
print hello
"""
输出：
Hello
===hello===
2
True
3
第一个字符串：hello, 第二个字符串：world
第一个字符串：hello, 第二个字符串：world
True
True
用join拼接后的数组： a-b-c
hello
测试python函数
"""
9.Python列表
List（列表） 是 Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套）。
列表用 [ ] 标识，是 python 最通用的复合数据类型。
列表中值的切割也可以用到变量 [头下标:尾下标] ，就可以截取相应的列表，从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标可以为空表示取到头或尾。
#列表
list = [ 'hello world', 54 , 3.14, '123', 5.56 ,[111,"123"]]
tinylist = [123, 'john']
plus = [list,tinylist]
print list # 输出完整列表
print list[0] # 输出列表的第一个元素
print list[1:3] # 输出第二个至第三个元素
print "找到列表最后的元素",list[-1] # 找到列表最后的元素
print list[2:] # 输出从第三个开始至列表末尾的所有元素
print tinylist * 2 # 输出列表两次
print list + tinylist # 打印组合的列表
print list.append("159") # 使用 append() 添加元素
del list[1] # 使用del删除元素
list[1] = 0.168 # 修改列表中的元素
# 一些方法具体参考 菜鸟教程：https://www.runoob.com/python/python-lists.html
print plus
"""
输出：
['hello world', 54, 3.14, '123', 5.56, [111, '123']]
hello world
[54, 3.14]
找到列表最后的元素 [111, '123']
[3.14, '123', 5.56, [111, '123']]
[123, 'john', 123, 'john']
['hello world', 54, 3.14, '123', 5.56, [111, '123'], 123, 'john']
None
[['hello world', 0.168, '123', 5.56, [111, '123'], '159'], [123, 'john']]
"""
10.Python元组
元组是另一个数据类型，类似于 List（列表）。
元组用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表——相当于不能修改的列表，定义方式不同
#元组——不可修改的列表
tuple = ('hello world', 54 , 3.14, '123', 5.56 ,[111,"123"])
tinytuple = (123, 'john')
plus = (tuple ,tinytuple )
#访问元组
print tuple # 输出完整元组
print tuple [0] # 输出元组的第一个元素
print tuple [1:3] # 输出第二个至第三个元素
print tuple [2:] # 输出从第三个开始至元组末尾的所有元素
#增加元组元素。当前元组元素不允许增加元素，所以要增加元组中的元素要新建元组，把需要添加进去的元素添加
#修改元组元素。当前元组元素不允许增加元素，所以要修改元组中的元素要新建元组
tuple_append = tuple + tinytuple #新的元组
print tinytuple * 2 # 输出元组两次
print tuple_append # 打印组合的元组
#删除元组元素，元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
print plus
"""
输出：
('hello world', 54, 3.14, '123', 5.56, [111, '123'])
hello world
(54, 3.14)
(3.14, '123', 5.56, [111, '123'])
(123, 'john', 123, 'john')
('hello world', 54, 3.14, '123', 5.56, [111, '123'], 123, 'john')
(('hello world', 54, 3.14, '123', 5.56, [111, '123']), (123, 'john'))
"""
11.Python字典
字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象集合，字典是无序的对象集合。
两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典用"{ }"标识。字典由索引(key)和它对应的值value组成。类似于Java中的map。
dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"
tinydict = {'name': 'python','code':3.14, 'dept': [111,"222"]}
#读取数据
print dict['one'] # 输出键为'one' 的值
print dict[2] # 输出键为 2 的值
print tinydict # 输出完整的字典
print tinydict.keys() # 输出所有键
print tinydict.values() # 输出所有值
#增加字典中的映射关系
def Merge(dict1, dict2):
return(dict2.update(dict1))
add_dict = Merge(dict, tinydict) #将第一个参数中的合并到第二个参数的字典中去
print "合并字典，add_dict的值",add_dict,"；tinydict的值",tinydict
#修改字典中的映射关系
tinydict["dept"] = 123
print tinydict
#删除字典中的映射关系
del tinydict["dept"] #删除字典中key值为“dept”的键值对
tinydict.clear() #清空整个字典
print tinydict
"""
输出：
This is one
This is two
{'dept': [111, '222'], 'code': 3.14, 'name': 'python'}
['dept', 'code', 'name']
[[111, '222'], 3.14, 'python']
合并字典，add_dict的值 None ；tinydict的值 {'dept': [111, '222'], 2: 'This is two', 'code': 3.14, 'name': 'python', 'one': 'This is one'}
{'dept': 123, 2: 'This is two', 'code': 3.14, 'name': 'python', 'one': 'This is one'}
{}
"""
字典的特性：
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
2）键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行
12.数据类型的转换
| 函数 | 描述 |
|---|---|
| int(x,base) | 将x转换为一个整数,base指的是基数 |
| float(x) | 将x转换到一个浮点数 |
| str(x) | 将对象 x 转换为字符串 |
| repr(x) | 将对象 x 转换为表达式字符串 |
| tuple(s) | 将序列 s 转换为一个元组 |
| list(s) | 将序列 s 转换为一个列表 |
| set(s) | 转换为可变集合 |
| dict(d) | 创建一个字典。d 必须是一个序列 (key,value)元组。 |
num1 = 3.14
num2 = 6
string = "unittec"
dict_ex = {'runoob': 'dict_ex', 'google': 'google.com'}
list_ex = [123,"list_ex",13.25]
tuple_ex = (458,"tuple_ex",5.56)
toInt = int(num1) #将浮点数强转为整数
toFloat = float(num2) #将整型强转为浮点型
toString = str(num1) #将浮点型强转为字符串
s = repr(dict_ex) #repr() 函数将对象转化为供解释器读取的形式。
toTuple = tuple(list_ex) #tuple(s)是将序列s转为元组模式
toList = list(tuple_ex) #list(s)是将序列s转为列表模式
toSet = set(string) #set(s)是将字符创转化为集合模式
toDict1 = dict(zip(list_ex,toList)) #映射函数方式来构造字典
toDict2 = dict([('one',1),('two',2)]) #可迭代对象方式来构造字典
print "int(x):",toInt
print "float(x):",toFloat
print "str(x):",toString,"===",type(toString)
print "repr(x):",s,"===",type(toString)
print "tuple(s):",toTuple
print "list(s):",toList
print "set(s):",toSet
print "映射方式生成字典：",toDict1
print "迭代方式生成字典",toDict2
"""
int(x): 3
float(x): 6.0
str(x): 3.14 ===
repr(x): {'google': 'google.com', 'runoob': 'dict_ex'}
tuple(s): (123, 'list_ex', 13.25)
list(s): [458, 'tuple_ex', 5.56]
set(s): set(['c', 'e', 'i', 'n', 'u', 't'])
映射方式生成字典： {13.25: 5.56, 123: 458, 'list_ex': 'tuple_ex'}
迭代方式生成字典 {'two': 2, 'one': 1}
"""
13.python运算符
算数运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 加 - 两个对象相加 | 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//2 -5 |
Python比较运算符
以下假设变量a为10，变量b为20：
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 等于 - 比较对象是否相等 | (a == b) 返回 False。 |
| != | 不等于 - 比较两个对象是否不相等 | (a != b) 返回 true. |
| <> | 不等于 - 比较两个对象是否不相等。python3 已废弃。 | (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赋值运算符
以下假设变量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中的按位运算法则如下：
下表中变量 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语言支持逻辑运算符，以下假设变量 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成员运算符
除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。
| 运算符 | 描述 | 实例 |
|---|---|---|
| in | 如果在指定的序列中找到值返回 True，否则返回 False。 | x 在 y 序列中 , 如果 x 在 y 序列中返回 True。 |
| not in | 如果在指定的序列中没有找到值返回 True，否则返回 False。 | x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。 |
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。 |
三、python语句
14.if-elif-else
语法格式：
if 判断条件1:
执行语句1……
elif 判断条件2:
执行语句2……
elif 判断条件3:
执行语句3……
else:
执行语句4……
实例：
#if-elif-else
num = 0
while num < 15:
if num % 3 == 0:
print num,"是3的倍数"
elif num % 3 == 1:
print num,"是除3余1的数"
else:
print num,"是除3余2的数"
num += 1
15.for循环语句
语法格式：
for iterating_var in sequence:
statements(s)
实例:
#for循环
for letter in "qwe":
print "当前字母:",letter
seasons = ["spring","summer","fall","winter"]
nums = (1,2,3,4)
for season in seasons:
print "当前季节为:",season
for num in nums:
print "当前数字是：",num
通过索引迭代：
#for循环中的索引迭代
for index in range(len(seasons)): #range是生成一组序列的意思
print index
print seasons[index]
循环使用 else 语句：
在 python 中，for … else 表示这样的意思，for 中的语句和普通的没有区别，else 中的语句会在循环正常执行完的情况下执行，while … else 也是一样。
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, '是一个质数'
循环嵌套：
#第一种嵌套
for iterating_var in sequence:
for iterating_var in sequence:
statements(s)
statements(s)
#第二种嵌套
while expression:
while expression:
statement(s)
statement(s)
16.pass语句
pass一般用于占位置。
在 Python 中有时候会看到一个 def 函数:
def sample(n_samples):
pass
该处的 pass 便是占据一个位置，因为如果定义一个空函数程序会报错，当你没有想好函数的内容是可以用 pass 填充，使程序可以正常运行。
17.python函数
python可以定义一个函数
可以定义一个由自己想要功能的函数，以下是简单的规则：
- 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号**()**。
- 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
- 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
- 函数内容以冒号起始，并且缩进。
- return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
1.函数的调用
定义语法：
def printme( str ):
"打印传入的字符串到标准显示设备上"
print str
return
printme("测试python函数")
2.参数传递
在 python 中，类型属于对象，变量是没有类型的：
a=[1,2,3] a="Runoob"
以上代码中，[1,2,3] 是 List 类型，“Runoob” 是 String 类型，而变量 a 是没有类型，她仅仅是一个对象的引用（一个指针），可以是 List 类型对象，也可以指向 String 类型对象。
3.python 传不可变对象实例
# -*- coding: UTF-8 -*-
def ChangeInt( a ):
a = 3
b = 2
ChangeInt(b)
print b # 结果是 2
实例中有 int 对象 2，指向它的变量是 b，在传递给 ChangeInt 函数时，按传值的方式复制了变量 b，a 和 b 都指向了同一个 Int 对象，在 a=3 时，则新生成一个 int 值对象3，并让 a 指向它。
4.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]]
"""
上述实例修改的是值本身
5.参数
以下是调用函数时可使用的正式参数类型：
-
必备参数：必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
-
关键字参数：关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
def printme( str ): "打印任何传入的字符串" print str return #调用printme函数 printme( str = "My string") -
默认参数：调用函数时，默认参数的值如果没有传入，则被认为是默认值。
#可写函数说明 def printinfo( name, age = 35 ): "打印任何传入的字符串" print "Name: ", name print "Age ", age return #调用printinfo函数 printinfo( age=50, name="miki" ) printinfo( name="miki" ) -
不定长参数：可能需要一个函数能处理比当初声明时更多的参数。
# 可写函数说明 def printinfo( arg1, *vartuple ): "打印任何传入的参数" print "输出: " print arg1 for var in vartuple: print var return # 调用printinfo 函数 printinfo( 10 ) printinfo( 70, 60, 50 )6.return语句
若没有返回值，直接写return；有返回值就返回返回值
# 可写函数说明 def sum( arg1, arg2 ): # 返回2个参数的和." total = arg1 + arg2 print "函数内 : ", total return total # 调用sum函数 total = sum( 10, 20 )
四、python文件和异常处理
18.Python 模块
1.import载入
#import module1[, module2[,... moduleN]]
# 导入模块
import support
# 现在可以调用模块里包含的函数了
support.print_func("Runoob")
2.from…import 语句
Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中。
from fib import fibonacci
3.dir()函数
dir() 函数一个排好序的字符串列表，内容是一个模块里定义过的名字。
返回的列表容纳了在一个模块里定义的所有模块，变量和函数。
import math
content = dir(math)
print content
"""
输出：
['__doc__', '__name__', '__package__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'hypot', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']
"""
19.Python 文件I/O
1.读取键盘输入
Python提供了两个内置函数从标准输入读入一行文本，默认的标准输入是键盘。如下：
- raw_input
- input
# -*- coding: UTF-8 -*-
#raw_input([prompt]) 函数从标准输入读取一个行，并返回一个字符串（去掉结尾的换行符）
str = raw_input("请输入：")
print "你输入的内容是: ", str
#input([prompt]) 函数和 raw_input([prompt]) 函数基本类似，但是 input 可以接收一个Python表达式作为输入，并将运算结果返回。
str = input("请输入：")
print "你输入的内容是: ", str
2.打开和关闭文件
现在，已经可以向标准输入和输出进行读写。现在，来看看怎么读写实际的数据文件。
Python 提供了必要的函数和方法进行默认情况下的文件基本操作。你可以用 file 对象做大部分的文件操作。
（1）open 函数
首先必须先用Python内置的open()函数打开一个文件，创建一个file对象，相关的方法才可以调用它进行读写。
file object = open(file_name [, access_mode][, buffering])
# file_name：file_name变量是一个包含了你要访问的文件名称的字符串值。
# access_mode：access_mode决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。
# buffering:如果buffering的值被设为0，就不会有寄存。如果buffering的值取1，访问文件时会寄存行。如果将buffering的值设为大于1的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。
| 模式 | r | r+ | w | w+ | a | a+ |
|---|---|---|---|---|---|---|
| 读 | + | + | + | + | ||
| 写 | + | + | + | + | + | |
| 创建 | + | + | + | + | ||
| 覆盖 | + | + | ||||
| 指针在开始 | + | + | + | + | ||
| 指针在结尾 | + | + |
2.File对象的属性
一个文件被打开后，你有一个file对象，你可以得到有关该文件的各种信息。
以下是和file对象相关的所有属性的列表：
| 属性 | 描述 |
|---|---|
| file.closed | 返回true如果文件已被关闭，否则返回false。 |
| file.mode | 返回被打开文件的访问模式。 |
| file.name | 返回文件的名称。 |
| file.softspace | 如果用print输出后，必须跟一个空格符，则返回false。否则返回true。 |
# 打开一个文件
#文件IO,在这里遇到一个小问题。
#一个文件如果是用“r”打开出现找不到该文件的错误，用""a+"或“w”方式处理则正常
file = open("mss-project.xls","w",1)
file.close()
print "文件名：",file.name
print "文件是否关闭：",file.closed
print "文件读取方式：",file.mode
print "末尾是否强制加空格",file.softspace
"""
输出：
文件名： mss-project.xls
文件是否关闭： True
文件读取方式： w
末尾是否强制加空格 0
"""
3.close()方法
File 对象的 close（）方法刷新缓冲区里任何还没写入的信息，并关闭该文件，这之后便不能再进行写入。
当一个文件对象的引用被重新指定给另一个文件时，Python 会关闭之前的文件。用 close（）方法关闭文件是一个很好的习惯。
语法：
fileObject.close()
4.write()方法
write()方法可将任何字符串写入一个打开的文件。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。
write()方法不会在字符串的结尾添加换行符(’\n’)：
语法：
fileObject.write(string)
在这里，被传递的参数是要写入到已打开文件的内容。
例子：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 打开一个文件
fo = open("foo.txt", "w")
fo.write( "www.runoob.com!\nVery good site!\n")
# 关闭打开的文件
fo.close()
上述方法会创建foo.txt文件，并将收到的内容写入该文件，并最终关闭文件。
5.read()方法
read（）方法从一个打开的文件中读取一个字符串。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。
语法：
fileObject.read([count])
在这里，被传递的参数是要从已打开文件中读取的字节计数。该方法从文件的开头开始读入，如果没有传入count，它会尝试尽可能多地读取更多的内容，很可能是直到文件的末尾。
例子：
这里我们用到以上创建的 foo.txt 文件。
#打开文件
file_read = open("fileRead.txt","a+")
#读到的字符串要写入的内容
write_file = file_read.read()
file = open("fileWirte.txt","a+")
file.write(write_file)
file.close(
fo.close()
6.文件定位：
#打开文件
file_read = open("fileRead.txt","a+")
#读到的字符串要写入的内容
write_file = file_read.read()
file = open("fileWirte.txt","a+")
file.write(write_file)
#输出文件指针位置
position = file.tell()
print position
# 把指针再次重新定位到文件开头
position = file.seek(0, 0)
string = file.read()
print string
file_read.close()
file.close()
"""
输出：
62
python is a good code language
"""
7.重命名和删除文件：
import os
#重命名文件
os.rename(原来文件,目标文件)
#删除文件
os.remove(文件名)
实例：
import os
#重命名文件
os.rename("fileRead.txt","new_fileRead.txt")
file = open("new_fileRead.txt","a+")
file.close()
#删除文件
os.remove("fileWrite.txt")
print file.name
8.mkdir()方法
可以使用os模块的mkdir()方法在当前目录下创建新的目录们。需要提供一个包含了要创建的目录名称的参数。
import os
# 创建目录test
os.mkdir("test")
9.chdir()方法
可以用chdir()方法来改变当前的目录。chdir()方法需要的一个参数是想设成当前目录的目录名称.
# -*- coding: UTF-8 -*-
import os
# 将当前目录改为"/home/newdir"
os.chdir("/home/newdir")
10.rmdir()方法
rmdir()方法删除目录，目录名称以参数传递。
在删除这个目录之前，它的所有内容应该先被清除。
os.remove("F:\\sd\\sd.txt")
os.rmdir("F:\\sd")
11.文件目录相关的方法
- File 对象方法: file 对象提供了操作文件的一系列方法。
- File对象方法链接
- OS 对象方法: 提供了处理文件及目录的一系列方法。
- Os对象方法链接
rte.txt","a+")
file.write(write_file)
#输出文件指针位置
position = file.tell()
print position
# 把指针再次重新定位到文件开头
position = file.seek(0, 0)
string = file.read()
print string
file_read.close()
file.close()
"""
输出：
62
python is a good code language
"""
7.重命名和删除文件：
import os
#重命名文件
os.rename(原来文件,目标文件)
#删除文件
os.remove(文件名)
实例：
import os
#重命名文件
os.rename("fileRead.txt","new_fileRead.txt")
file = open("new_fileRead.txt","a+")
file.close()
#删除文件
os.remove("fileWrite.txt")
print file.name
8.mkdir()方法
可以使用os模块的mkdir()方法在当前目录下创建新的目录们。需要提供一个包含了要创建的目录名称的参数。
import os
# 创建目录test
os.mkdir("test")
9.chdir()方法
可以用chdir()方法来改变当前的目录。chdir()方法需要的一个参数是想设成当前目录的目录名称.
# -*- coding: UTF-8 -*-
import os
# 将当前目录改为"/home/newdir"
os.chdir("/home/newdir")
10.rmdir()方法
rmdir()方法删除目录，目录名称以参数传递。
在删除这个目录之前，它的所有内容应该先被清除。
os.remove("F:\\sd\\sd.txt")
os.rmdir("F:\\sd")
11.文件目录相关的方法
- File 对象方法: file 对象提供了操作文件的一系列方法。
- File对象方法链接
- OS 对象方法: 提供了处理文件及目录的一系列方法。
- Os对象方法链接
五、参考文献
菜鸟教程-python2