一、环境搭建

• 官网地址
  • https://www.python.org/downloads/windows/
• 打包文件
  • https://wwkg.lanzouq.com/irMtv2so9g8d 密码:5853
• 配置环境变量
  • 如将 D:\env\Python\Python313\和D:\env\Python\Python313\Scripts\放到path中
  • 参考如下

二、变量

Numbers（数字）

• 不可改变数据类型，改变数字类型会分配一个新的对象

python
    #var1两次赋值为不同的对象
    var1 = 1
    var1 = 'hello'
    var2 = 10

• del语法

python
del var1[,var2[,var3[....,varN]]]
#删除单个或多个对象的引用
del var
del var_a, var_b

• 四种数据类型
  • int（有符号整型）
  • long（长整型，也可以代表八进制和十六进制）
  • float（浮点型）
  • complex（复数）

String（字符串）

• 字符串为数字、字符、字母、下划线组成的一串字符

python
s = 'abcdef'

• 截取，[头下标:尾下标]

python
s = 'abcdef'
print(s[1:5])
#结果为'bcde'

• 字符串运算符

操作符	描述	实例
+	字符串连接	>>>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

List（列表）

• 列表用 [ ] 标识，是 python 最通用的复合数据类型，一个数组中可以同时存在多种数据类型

python
list = [ 'jack', 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    # 打印组合的列表

输出结果如下

['jack', 786, 2.23, 'john', 70.2]
jack
[786, 2.23]
[2.23, 'john', 70.2]
[123, 'john', 123, 'john']
['jack', 786, 2.23, 'john', 70.2, 123, 'john']

• 更新列表，可以使用append()方法添加列表项

python
list = []          ## 空列表
list.append('Google')   ## 使用 append() 添加元素
list.append('Runoob')
print list

输出结果

['Google', 'Runoob']

• 删除，可以用del函数

python
list1 = ['physics', 'chemistry', 1997, 2000]
 
print list1
del list1[2]
print "After deleting value at index 2 : "
print list1

输出结果为

['physics', 'chemistry', 1997, 2000]
After deleting value at index 2 :
['physics', 'chemistry', 2000]

• 列表脚本操作符

Python 表达式	结果	描述
len([1, 2, 3])	3	长度
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	组合
['Hi!'] * 4	['Hi!', 'Hi!', 'Hi!', 'Hi!']	重复
3 in [1, 2, 3]	True	元素是否存在于列表中
for x in [1, 2, 3]: print x	1 2 3	迭代

• 列表截取

L = ['Google', 'Jack', 'Taobao']

Python 表达式	结果	描述
L[2]	'Taobao'	读取列表中第三个元素
L[-2]	'Jack'	读取列表中倒数第二个元素
L[1:]	['Jack', 'Taobao']	从第二个元素开始截取列表

• 列表函数&方法

序号	函数
1	cmp(list1, list2)比较两个列表的元素
2	len(list)列表元素个数
3	max(list)返回列表元素最大值
4	min(list)返回列表元素最小值
5	list(seq)将元组转换为列表
6	list.append(obj)在列表末尾添加新的对象
7	list.count(obj)统计某个元素在列表中出现的次数
8	list.extend(seq)在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
9	list.index(obj)从列表中找出某个值第一个匹配项的索引位置
10	list.insert(index, obj)将对象插入列表
11	list.pop([index=-1])移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
12	list.remove(obj)移除列表中某个值的第一个匹配项
13	list.reverse()反向列表中元素
14	list.sort(cmp=None, key=None, reverse=False)对原列表进行排序

Tuple（元组）

• 类似于List(列表)，用()标识，内部元素用,分隔。元组不能二次赋值，相当于只读列表

python
tuple = ( 'jack', 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   # 打印组合的元组

输出结果

python
('jack', 786, 2.23, 'john', 70.2)
jack
(786, 2.23)
(2.23, 'john', 70.2)
(123, 'john', 123, 'john')
('jack', 786, 2.23, 'john', 70.2, 123, 'john')

• 创建空元组

python
tup1 = ()

元组中只包含一个元素时，需要在元素后面添加逗号

python
tup1 = (50,)

元组与字符串类似，下标索引从0开始，可以进行截取，组合等。

• 修改元组 元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下:

python
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
 
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
 
# 创建一个新的元组
tup3 = tup1 + tup2
print tup3

输出结果为

(12, 34.56, 'abc', 'xyz')

• 删除元组 元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下:

python
tup = ('physics', 'chemistry', 1997, 2000)
 
print tup
del tup
print "After deleting tup : "
print tup

输出结果为

('physics', 'chemistry', 1997, 2000)
After deleting tup :
Traceback (most recent call last):
  File "test.py", line 9, in <module>
    print tup
NameError: name 'tup' is not defined

• 无关闭分隔符 任意无符号的对象，以逗号隔开，默认为元组，如下：

python
print 'abc', -4.24e93, 18+6.6j, 'xyz'
x, y = 1, 2
print "Value of x , y : ", x,y

• 元组内置函数

序号	方法及描述
1	cmp(tuple1, tuple2)比较两个元组元素。
2	len(tuple)计算元组元素个数。
3	max(tuple)返回元组中元素最大值。
4	min(tuple)返回元组中元素最小值。
5	tuple(seq)将列表转换为元组。

Dictionary（字典）

• 字典用"{ }"标识，由索引(key)和它对应的值value组成且无序

python
dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"
 
tinydict = {'name': 'jack','code':6734, 'dept': 'sales'}
 
 
print dict['one']          # 输出键为'one' 的值
print dict[2]              # 输出键为 2 的值
print tinydict             # 输出完整的字典
print tinydict.keys()      # 输出所有键
print tinydict.values()    # 输出所有值

输出结果

This is one
This is two
{'dept': 'sales', 'code': 6734, 'name': 'jack'}
['dept', 'code', 'name']
['sales', 6734, 'runoob']

如果用字典里没有的键访问数据，会输出错误

• 修改字典

python
tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
 
tinydict['Age'] = 8 # 更新
tinydict['School'] = "jack" # 添加
 
 
print "tinydict['Age']: ", tinydict['Age']
print "tinydict['School']: ", tinydict['School']

输出结果为

tinydict['Age']:  8
tinydict['School']:  jack

• 删除字典元素 能删单一的元素也能清空字典，清空只需一项操作。

python
tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
 
del tinydict['Name']  # 删除键是'Name'的条目
tinydict.clear()      # 清空字典所有条目
del tinydict          # 删除字典
 
print "tinydict['Age']: ", tinydict['Age'] 
print "tinydict['School']: ", tinydict['School']

但这会引发一个异常，因为用del后字典不再存在

• 字典键的特性
  • 字典值可以没有限制地取任何 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。
    • 不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
    • 键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行
• 字典内置函数&方法

序号	函数及描述
1	cmp(dict1, dict2)比较两个字典元素。
2	len(dict)计算字典元素个数，即键的总数。
3	str(dict)输出字典可打印的字符串表示。。
4	type(variable)返回输入的变量类型，如果变量是字典就返回字典类型。
5	dict.clear()删除字典内所有元素
6	dict.copy()返回一个字典的浅复制
7	dict.fromkeys(seq[, val])创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
8	dict.get(key, default=None)返回指定键的值，如果值不在字典中返回default值
9	dict.items()以列表返回可遍历的(键, 值) 元组数组
10	dict.keys()以列表返回一个字典所有的键
11	dict.setdefault(key, default=None)和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
12	dict.update(dict2)把字典dict2的键/值对更新到dict里
13	dict.values()以列表返回字典中的所有值
14	pop(key[,default])删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
15	popitem()返回并删除字典中的最后一对键和值。

数据类型转换

函数	描述
int(x [,base])	将x转换为一个整数
long(x [,base])	将x转换为一个长整数
float(x)	将x转换到一个浮点数
complex(real [,imag])	创建一个复数
str(x)	将对象 x 转换为字符串
repr(x)	将对象 x 转换为表达式字符串
eval(str)	用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s)	将序列 s 转换为一个元组
list(s)	将序列 s 转换为一个列表
set(s)	转换为可变集合
dict(d)	创建一个字典。d 必须是一个序列 (key,value)元组。
frozenset(s)	转换为不可变集合
chr(x)	将一个整数转换为一个字符
unichr(x)	将一个整数转换为Unicode字符
ord(x)	将一个字符转换为它的整数值
hex(x)	将一个整数转换为一个十六进制字符串
oct(x)	将一个整数转换为一个八进制字符串

三、运算符

算术运算符

运算符	描述	实例
+	加 - 两个对象相加	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

比较运算符

运算符	描述	实例
==	等于 - 比较对象是否相等	(a == b) 返回 False
!=	等于 - 比较对象是否相等	(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

赋值运算符

运算符	描述	实例
=	简单的赋值运算符	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

位运算符

&、|

逻辑运算符

运算符	逻辑表达式	描述	实例
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。

成员运算符

运算符	描述	实例
in	如果在指定的序列中找到值返回 True，否则返回 False	x 在 y 序列中 , 如果 x 在 y 序列中返回 True
not in	如果在指定的序列中没有找到值返回 True，否则返回 False	x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True

身份运算符

运算符	描述	实例
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程序语言指定任何非0和非空（null）值为true，0 或者 null为false

python
if 判断条件：
    执行语句……
else：
    执行语句……
    
##多条件
if 判断条件1:
    执行语句1……
elif 判断条件2:
    执行语句2……
elif 判断条件3:
    执行语句3……
else:
    执行语句4……

五、循环语句

while循环

python
while 判断条件(condition)：
    执行语句(statements)……

• 使用else语句 在 python 中，while … else 在循环条件为 false 时执行 else 语句块：

python

count = 0
while count < 5:
   print count, " is  less than 5"
   count = count + 1
else:
   print count, " is not less than 5"

输出结果

0 is less than 5
1 is less than 5
2 is less than 5
3 is less than 5
4 is less than 5
5 is not less than 5

for循环

python
for iterating_var in sequence:
   statements(s)

如下

python
for letter in 'Python':     # 第一个实例
   print("当前字母: %s" % letter)
 
 #遍历元素
fruits = ['banana', 'apple',  'mango']
for fruit in fruits:        # 第二个实例
   print ('当前水果: %s'% fruit)
 
print ("Good bye!")

#通过索引
for index in range(len(fruits)):
   print ('当前水果 : %s' % fruits[index])
 
print ("Good bye!")

循环控制语句

• break 语句
  • 在语句块执行过程中终止循环，并且跳出整个循环
• continue 语句
  • 在语句块执行过程中终止当前循环，跳出该次循环，执行下一次循环。
• pass 语句
  • pass是空语句，是为了保持程序结构的完整性。

六、函数

规则

1. 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
2. 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
3. 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
4. 函数内容以冒号起始，并且缩进。
5. return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

python
def functionname( parameters ):
   "函数_文档字符串"
   function_suite
   return [expression]

默认参数

python
 
#可写函数说明
def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print "Name: ", name
   print "Age ", age
   return
 
#调用printinfo函数
printinfo( age=50, name="miki" )
printinfo( name="miki" )

输出结果

Name:  miki
Age  50
Name:  miki
Age  35

不定长参数

def functionname([formal_args,] *var_args_tuple ):
   "函数_文档字符串"
   function_suite
   return [expression]

python
# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print "输出: "
   print arg1
   for var in vartuple:
      print var
   return
 
# 调用printinfo 函数
printinfo( 10 )
printinfo( 70, 60, 50 )

输出结果

输出:
10
输出:
70
60
50

匿名函数

- lambda只是一个表达式，函数体比def简单很多。
- lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去
- lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
- 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

python
lambda [arg1 [,arg2,.....argn]]:expression

# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2
 
# 调用sum函数
print "相加后的值为 : ", sum( 10, 20 )
print "相加后的值为 : ", sum( 20, 20 )

变量作用域

局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。如下：

python
total = 0 # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
   #返回2个参数的和."
   total = arg1 + arg2 # total在这里是局部变量.
   print "函数内是局部变量 : ", total
   return total
 
#调用sum函数
sum( 10, 20 )
print "函数外是全局变量 : ", total

输出结果

函数内是局部变量 :  30
函数外是全局变量 :  0

注：全局变量在函数内时可通过golbal来声明，实现更改

7、模块

模块(Module)，是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。

import 语句

• 模块的引入

python
import module1[, module2[,... moduleN]]

比如要引用模块 math，就可以在文件最开始的地方用 import math 来引入。在调用 math 模块中的函数时，必须这样引用：

模块名.函数名

support.py：

python
def print_func( par ):
   print "Hello : ", par
   return

test.py

# 导入模块
import support
 
# 现在可以调用模块里包含的函数了
support.print_func("jack")

一个模块只会被导入一次，不管你执行了多少次import。这样可以防止导入模块被一遍又一遍地执行。

from…import 语句

from 语句让你从模块中导入一个指定的部分到当前命名空间中。语法如下：

python
from modname import name1[, name2[, ... nameN]]

要导入模块 fib 的 fibonacci 函数，使用如下语句：

python
from fib import fibonacci

from…import* 语句

把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：

from modname import *

包

包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的 Python 的应用环境。

简单来说，包就是文件夹，但该文件夹下必须存在 init.py 文件, 该文件的内容可以为空。init.py 用于标识当前文件夹是一个包。

package_test 目录下的 test1.py、test2.py、init.py 文件，test.py 为测试调用包的代码，目录结构如下：

test.py
package_test
|-- __init__.py
|-- test1.py
|-- test2.py

8、文件

open 函数

- file_name：file_name变量是一个包含了你要访问的文件名称的字符串值。
- access_mode：access_mode决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。
- buffering:如果buffering的值被设为0，就不会有寄存。如果buffering的值取1，访问文件时会寄存行。如果将buffering的值设为大于1的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。

file object = open(file_name [, access_mode][, buffering])

• 不同模式打开文件的完全列表

模式	描述
t	文本模式 (默认)。
x	写模式，新建一个文件，如果该文件已存在则会报错。
b	二进制模式。
+	打开一个文件进行更新(可读可写)。
U	通用换行模式（不推荐）。
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

File对象的属性

属性	描述
file.closed	关闭文件。关闭后文件不能再进行读写操作。
file.mode	返回被打开文件的访问模式。
file.name	返回文件的名称。
file.softspace	如果用print输出后，必须跟一个空格符，则返回false。否则返回true。
file.flush()	刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
file.fileno()	返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。
file.isatty()	如果文件连接到一个终端设备返回 True，否则返回 False。
file.next()	返回文件下一行。
file.read([size])	从文件读取指定的字节数，如果未给定或为负则读取所有。
file.readline([size])	读取整行，包括 "\n" 字符。
file.readlines([sizeint])	读取所有行并返回列表，若给定sizeint>0，则是设置一次读多少字节，这是为了减轻读取压力。
file.seek(offset[, whence])	设置文件当前位置
file.tell()	返回文件当前位置。
file.truncate([size])	截取文件，截取的字节通过size指定，默认为当前文件位置。
file.write(str)	将字符串写入文件，返回的是写入的字符长度。
file.writelines(sequence)	向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。

# 打开一个文件
fo = open("foo.txt", "w")
print "文件名: ", fo.name
print "是否已关闭 : ", fo.closed
print "访问模式 : ", fo.mode
print "末尾是否强制加空格 : ", fo.softspace

输出结果

文件名:  foo.txt
是否已关闭 :  False
访问模式 :  w
末尾是否强制加空格 :  0

close()方法

File 对象的 close（）方法刷新缓冲区里任何还没写入的信息，并关闭该文件，这之后便不能再进行写入。

当一个文件对象的引用被重新指定给另一个文件时，Python 会关闭之前的文件。

python
fileObject.close()

write()方法

write()方法可将任何字符串写入一个打开的文件。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。

write()方法不会在字符串的结尾添加换行符('\n')：

fileObject.write(string)

示例：

# 打开一个文件
fo = open("foo.txt", "w")
fo.write( "hello\nVery good site!\n")
 
# 关闭打开的文件
fo.close()

read()方法

read（）方法从一个打开的文件中读取一个字符串。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。

fileObject.read([count])

被传递的参数是要从已打开文件中读取的字节计数。该方法从文件的开头开始读入，如果没有传入count，它会尝试尽可能多地读取更多的内容，很可能是直到文件的末尾。

# 打开一个文件
fo = open("foo.txt", "r+")
str = fo.read(10)
print "读取的字符串是 : ", str
# 关闭打开的文件
fo.close()

##文件定位 tell()方法告诉你文件内的当前位置, 换句话说，下一次的读写会发生在文件开头这么多字节之后。

seek（offset [,from]）方法改变当前文件的位置。Offset变量表示要移动的字节数。From变量指定开始移动字节的参考位置。

如果from被设为0，这意味着将文件的开头作为移动字节的参考位置。如果设为1，则使用当前的位置作为参考位置。如果它被设为2，那么该文件的末尾将作为参考位置。

python
# 打开一个文件
fo = open("foo.txt", "r+")
str = fo.read(10)
print "读取的字符串是 : ", str
 
# 查找当前位置
position = fo.tell()
print "当前文件位置 : ", position
 
# 把指针再次重新定位到文件开头
position = fo.seek(0, 0)
str = fo.read(10)
print "重新读取字符串 : ", str
# 关闭打开的文件
fo.close()

重命名和删除文件

• rename() 方法 rename() 方法需要两个参数，当前的文件名和新文件名。

os.rename(current_file_name, new_file_name)

import os
 
# 重命名文件test1.txt到test2.txt。
os.rename( "test1.txt", "test2.txt" )

• remove()方法

os.remove(file_name)

import os
 
# 删除一个已经存在的文件test2.txt
os.remove("test2.txt")

目录操作

mkdir()方法

使用os模块的mkdir()方法在当前目录下创建新的目录

import os
 
# 创建目录test
os.mkdir("test")

chdir()方法

用chdir()方法来改变当前的目录。chdir()方法需要的一个参数是你想设成当前目录的目录名称。

os.chdir("newdir")

# 将当前目录改为"/home/newdir"
os.chdir("/home/newdir")

getcwd() 方法

显示当前的工作目录

python
import os
 
# 给出当前的目录
print os.getcwd()

rmdir()方法

rmdir()方法删除目录，目录名称以参数传递。

在删除这个目录之前，它的所有内容应该先被清除。

os.rmdir('dirname')

import os
 
# 删除”/tmp/test”目录
os.rmdir( "/tmp/test"  )

os 模块操作文件/目录方法

函数	描述
os.access(path, mode)	检验权限模式
os.chdir(path)	改变当前工作目录
os.chflags(path, flags)	设置路径的标记为数字标记。
os.chmod(path, mode)	更改权限
os.chown(path, uid, gid)	更改文件所有者
os.chroot(path)	改变当前进程的根目录
os.close(fd)	关闭文件描述符 fd
os.closerange(fd_low, fd_high)	关闭所有文件描述符，从 fd_low (包含) 到 fd_high (不包含), 错误会忽略
os.dup(fd)	复制文件描述符 fd
os.dup2(fd, fd2)	将一个文件描述符 fd 复制到另一个 fd2
os.fchdir(fd)	通过文件描述符改变当前工作目录
os.fchmod(fd, mode)	改变一个文件的访问权限，该文件由参数fd指定，参数mode是Unix下的文件访问权限。
os.fchown(fd, uid, gid)	修改一个文件的所有权，这个函数修改一个文件的用户ID和用户组ID，该文件由文件描述符fd指定。
os.fdatasync(fd)	强制将文件写入磁盘，该文件由文件描述符fd指定，但是不强制更新文件的状态信息。
os.fdopen(fd[, mode[, bufsize]])	通过文件描述符 fd 创建一个文件对象，并返回这个文件对象
os.fpathconf(fd, name)	返回一个打开的文件的系统配置信息。name为检索的系统配置的值，它也许是一个定义系统值的字符串，这些名字在很多标准中指定（POSIX.1, Unix 95, Unix 98, 和其它）。
os.fstat(fd)	返回文件描述符fd的状态，像stat()。
os.fstatvfs(fd)	返回包含文件描述符fd的文件的文件系统的信息，像 statvfs()
os.fsync(fd)	强制将文件描述符为fd的文件写入硬盘。
......

9、异常处理

捕捉异常可以使用try/except语句。

try/except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理。

如果你不想在异常发生时结束你的程序，只需在try里捕获它。 try....except...else的语法：

python
try:
<语句>        #运行别的代码
except <名字>：
<语句>        #如果在try部份引发了'name'异常
except <名字>，<数据>:
<语句>        #如果引发了'name'异常，获得附加的数据
else:
<语句>        #如果没有异常发生

python
try:
    fh = open("testfile", "w")
    fh.write("这是一个测试文件，用于测试异常!!")
except IOError:
    print "Error: 没有找到文件或读取文件失败"
else:
    print "内容写入文件成功"
    fh.close()

• 使用except而不带任何异常类型

try:
    正常的操作
   ......................
except:
    发生异常，执行这块代码
   ......................
else:
    如果没有异常执行这块代码

• 使用except而带多种异常类型

try:
    正常的操作
   ......................
except(Exception1[, Exception2[,...ExceptionN]]):
   发生以上多个异常中的一个，执行这块代码
   ......................
else:
    如果没有异常执行这块代码

• try-finally 语句

try:
<语句>
finally:
<语句>    #退出try时总会执行
raise

try:
    fh = open("testfile", "w")
    fh.write("这是一个测试文件，用于测试异常!!")
finally:
    print "Error: 没有找到文件或读取文件失败"

try:
    fh = open("testfile", "w")
    try:
        fh.write("这是一个测试文件，用于测试异常!!")
    finally:
        print "关闭文件"
        fh.close()
except IOError:
    print "Error: 没有找到文件或读取文件失败"

当在try块中抛出一个异常，立即执行finally块代码。

finally块中的所有语句执行后，异常被再次触发，并执行except块代码。

参数的内容不同于异常。

• 用户自定义异常 通过创建一个新的异常类，异常应该是典型的继承自Exception类，通过直接或间接的方式。 以下为与RuntimeError相关的实例,实例中创建了一个类，基类为RuntimeError，用于在异常触发时输出更多的信息。 在try语句块中，用户自定义的异常后执行except块语句，变量 e 是用于创建Networkerror类的实例。

class Networkerror(RuntimeError):
    def __init__(self, arg):
        self.args = arg

try:
    raise Networkerror("Bad hostname")
except Networkerror,e:
    print e.args

10、面向对象

类(Class)

用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。

• 语法

class ClassName:
   '类的帮助信息'   #类文档字符串
   class_suite  #类体

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

init()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法

self 代表类的实例，self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。

• self代表类的实例，而非类 类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。

class Test:
    def prt(self):
        print(self)
        print(self.__class__)
 
t = Test()
t.prt()

输出结果为

<__main__.Test instance at 0x10d066878>
__main__.Test

self 代表的是类的实例，代表当前对象的地址，而 self.class 则指向类。

类变量

类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。

数据成员

类变量或者实例变量, 用于处理类及其实例对象的相关的数据。

方法重写

如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。

class Parent:        # 定义父类
   def myMethod(self):
      print '调用父类方法'
 
class Child(Parent): # 定义子类
   def myMethod(self):
      print '调用子类方法'
 
c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法

局部变量

定义在方法中的变量，只作用于当前实例的类。

实例变量

在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。

继承

即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系

class 派生类名(基类名)
    ...

• 继承的特点
  • 1、如果在子类中需要父类的构造方法就需要显式的调用父类的构造方法，或者不重写父类的构造方法。
  • 2、在调用基类的方法时，需要加上基类的类名前缀，且需要带上 self 参数变量。区别在于类中调用普通函数时并不需要带上 self 参数
  • 3、Python 总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。 如果在继承元组中列了一个以上的类，那么它就被称作"多重继承" 。

派生类的声明，与他们的父类类似，继承的基类列表跟在类名之后，如下所示：

class SubClassName (ParentClass1[, ParentClass2, ...]):
    ...

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()          # 再次调用父类的方法 - 获取属性值

输出结果

调用子类构造方法
调用子类方法
调用父类方法
父类属性 : 200

• 继承多个类

class A:        # 定义类 A
.....

class B:         # 定义类 B
.....

class C(A, B):   # 继承类 A 和 B
.....

• 可以使用issubclass()或者isinstance()方法来检测。
  • issubclass() - 布尔函数判断一个类是另一个类的子类或者子孙类，语法：issubclass(sub,sup)
  • isinstance(obj, Class) 布尔函数如果obj是Class类的实例对象或者是一个Class子类的实例对象则返回true。

对象

通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。 实例化类其他编程语言中一般用关键字 new，但是在 Python 中并没有这个关键字，类的实例化类似函数调用方式。

以下使用类的名称 Employee 来实例化，并通过 init 方法接收参数。

"创建 Employee 类的第一个对象"
emp1 = Employee("Zara", 2000)
"创建 Employee 类的第二个对象"
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' 属性

• 其它相关属性
  • getattr(obj, name[, default]) : 访问对象的属性。
  • hasattr(obj,name) : 检查是否存在一个属性。
  • setattr(obj,name,value) : 设置一个属性。如果属性不存在，会创建一个新属性。
  • delattr(obj, name) : 删除属性。

类属性与方法

类的私有属性

__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs

类的方法

在类的内部，使用 def 关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数 self,且为第一个参数

类的私有方法

__private_method：两个下划线开头，声明该方法为私有方法，不能在类的外部调用。在类的内部调用 self.__private_methods

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  # 报错，实例不能访问私有变量

输出结果为

1
2
2
Traceback (most recent call last):
  File "test.py", line 17, in <module>
    print counter.__secretCount  # 报错，实例不能访问私有变量
AttributeError: JustCounter instance has no attribute '__secretCount'

Python不允许实例化的类访问私有数据，但你可以使用 object._className__attrName（ 对象名._类名__私有属性名 ）访问属性，参考以下实例：

class Jack:
    __name = "jack"

Jack = Jack()
print Jack._Jack__name

输出结果为

jack