python | 一文带你掌握Python27入门 ~

一、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'}
------以下是类型------
<type 'int'>
<type 'float'>
<type 'str'>
<type 'list'>
<type 'tuple'>
<type 'dict'>
'''

删除：

可以使用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)    #num1<num2输出-1；num1==num2输出0；num1>num2输出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 === <type 'str'>
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