Python的简单介绍(二)

本文介绍了Python编程的基础知识,包括条件语句(if-else, if-elif-else)、循环(while, for)、集合(列表、元组、字典和集合)的使用,以及日期和时间、函数、模块、包、异常处理等概念,详细讲解了每个部分的关键点和示例代码,适合初学者学习。" 114366136,10649849,Delphi面向对象:方法分类与应用解析,"['Delphi', '面向对象编程', '方法', '类']

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

接Python的简单介绍(一):

九、条件语句
if 判断条件:
执行语句……
else:
执行语句……
if 判断条件1:
执行语句1……
elif 判断条件2:
执行语句2……
elif 判断条件3:
执行语句3……
else:
执行语句4……

十、循环语句
1.while
while 判断条件:
执行语句……

	while 判断条件:
		执行语句……
	else:
		循环条件为false时执行else语句块
	**支持continue、break、pass
2.for
	for iterating_var in sequence:
		执行语句……

	for index in range:
		执行语句……

	for.... else... #循环条件为false时执行else语句块

	**range()函数可以生成一个整数序列包含指定范围内的数据 再通过list()函数可以转换为一个List
	List(range(5))
	sum = 0
	for x in range(101):
		sum = sum + x
	print(sum)
3.列表生成式
	生成[1x1, 2x2, 3x3, ..., 10x10]:
		 [x * x for x in range(1, 11)]
	for循环后面还可以加上if判断:
		 [x * x for x in range(1, 11) if x % 2 == 0]	
	还可以使用两层循环
		 [m + n for m in 'ABC' for n in 'XYZ']
	for循环其实可以同时使用两个甚至多个变量
		d = {'x': 'A', 'y': 'B', 'z': 'C' }
		[k + '=' + v for k, v in d.iteritems()]
		生成['y=B', 'x=A', 'z=C']

十一、集合
1.列表 - List
内容可变 长度可变 类型可以不同 有序
定义列表:
list1 = [‘physics’, ‘chemistry’, 1997, 2000];
list2 = [1, 2, 3, 4, 5 ];
list3 = [“a”, “b”, “c”, “d”];
获取列表数据:
list1[1]
list2[1:5]
更新列表:
list[2] = 2001;
删除元素:
del list1[2];
列表函数:
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[2] ‘SPAM!’ 读取列表中第三个元素
L[-2] ‘Spam’ 读取列表中倒数第二个元素
L[1:] [‘Spam’, ‘SPAM!’] 从第二个元素开始截取列表
其他方法:
cmp(list1, list2)
比较两个列表的元素
len(list)
列表元素个数
max(list)
返回列表元素最大值
min(list)
返回列表元素最小值
list(seq)
将元组转换为列表
list.append(obj)
在列表末尾添加新的对象
list.count(obj)
统计某个元素在列表中出现的次数
list.extend(seq)
在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
list.index(obj)
从列表中找出某个值第一个匹配项的索引位置
list.insert(index, obj)
将对象插入列表
list.pop(obj=list[-1])
移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
list.remove(obj)
移除列表中某个值的第一个匹配项
list.reverse()
反向列表中元素
list.sort([func])
对原列表进行排序
2.元组
不能修改的列表
定义元组:
tup1 = (‘physics’, ‘chemistry’, 1997, 2000);
tup2 = (1, 2, 3, 4, 5 );
tup3 = “a”, “b”, “c”, “d”;
tup1 = ();
tup1 = (50,);#元组中只包含一个元素时,需要在元素后面添加逗号
访问元组:
tup1[0]
tup2[1:5]
修改元组:
元组是不允许修改的 但是可以进行连接组合
tup1 = (12, 34.56);
tup2 = (‘abc’, ‘xyz’);
tup3 = tup1 + tup2;
print tup3;
删除元组:
元组中的元素值是不允许删除的,但我们可以使用del语句来删除整个元组
tup = (‘physics’, ‘chemistry’, 1997, 2000);
del tup;
其他运算:
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[2] ‘SPAM!’ 读取第三个元素
L[-2] ‘Spam’ 反向读取;读取倒数第二个元素
L[1:] (‘Spam’, ‘SPAM!’) 截取元素
cmp(tuple1, tuple2)
比较两个元组元素。
len(tuple)
计算元组元素个数。
max(tuple)
返回元组中元素最大值。
min(tuple)
返回元组中元素最小值。
tuple(seq)
将列表转换为元组。
3.字典 - 相当于java中的map
创建字典:
d = {key1 : value1, key2 : value2,… }
键必须是唯一的,但值则不必。
值可以取任何数据类型,但键必须是不可变的,如字符串,数字或元组。
字典中的内容无序
访问字典:
dict[‘Name’]
修改字典:
dict[‘Age’] = 8; # update existing entry
dict[‘School’] = “DPS School”; # Add new entry
删除字典:
del dict[‘Name’]; # 删除键是’Name’的条目
dict.clear(); # 清空词典所有条目
del dict ; # 删除词典
其他方法:
cmp(dict1, dict2)
比较两个字典元素。
len(dict)
计算字典元素个数,即键的总数。
str(dict)
输出字典可打印的字符串表示。
type(variable)
返回输入的变量类型,如果变量是字典就返回字典类型。
dict.clear()
删除字典内所有元素
dict.copy()
返回一个字典的浅复制
dict.fromkeys(seq[, val]))
创建一个新字典,以序列 seq 中元素做字典的键,val 为字典所有键对应的初始值
dict.get(key, default=None)
返回指定键的值,如果值不在字典中返回default值
dict.has_key(key)
如果键在字典dict里返回true,否则返回false
dict.items()
以列表返回可遍历的(键, 值) 元组数组
dict.keys()
以列表返回一个字典所有的键
dict.setdefault(key, default=None)
和get()类似, 但如果键不存在于字典中,将会添加键并将值设为default
dict.update(dict2)
把字典dict2的键/值对更新到dict里
dict.values()
以列表返回字典中的所有值
4.set
set和dict类似,也是一组key的集合,但不存储value。由于key不能重复,所以,在set中,没有重复的key。
要创建一个set,需要提供一个list作为输入集合:
>>> s = set([1, 2, 3])
>>> s
{1, 2, 3}
>>> s = set([1, 1, 2, 2, 3, 3])
>>> s
{1, 2, 3}

十二、日期和时间
1.time 时间戳
ticks = time.time()
localtime = time.localtime(time.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 = time.asctime( time.localtime(time.time()) )
time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
其他方法:
1 time.altzone
返回格林威治西部的夏令时地区的偏移秒数。如果该地区在格林威治东部会返回负值(如西欧,包括英国)。对夏令时启用地区才能使用。
2 time.asctime([tupletime])
接受时间元组并返回一个可读的形式为"Tue Dec 11 18:07:14 2008"(2008年12月11日 周二18时07分14秒)的24个字符的字符串。
3 time.clock( )
用以浮点数计算的秒数返回当前的CPU时间。用来衡量不同程序的耗时,比time.time()更有用。
4 time.ctime([secs])
作用相当于asctime(localtime(secs)),未给参数相当于asctime()
5 time.gmtime([secs])
接收时间辍(1970纪元后经过的浮点秒数)并返回格林威治天文时间下的时间元组t。注:t.tm_isdst始终为0
6 time.localtime([secs])
接收时间辍(1970纪元后经过的浮点秒数)并返回当地时间下的时间元组t(t.tm_isdst可取0或1,取决于当地当时是不是夏令时)。
7 time.mktime(tupletime)
接受时间元组并返回时间辍(1970纪元后经过的浮点秒数)。
8 time.sleep(secs)
推迟调用线程的运行,secs指秒数。
9 time.strftime(fmt[,tupletime])
接收以时间元组,并返回以可读字符串表示的当地时间,格式由fmt决定。
10 time.strptime(str,fmt=’%a %b %d %H:%M:%S %Y’)
根据fmt的格式把一个时间字符串解析为时间元组。
11 time.time( )
返回当前时间的时间戳(1970纪元后经过的浮点秒数)。
12 time.tzset()
根据环境变量TZ重新初始化时间相关设置。
2.calendar 日历
cal = calendar.month(2016, 1)
1 calendar.calendar(year,w=2,l=1,c=6)
返回一个多行字符串格式的year年年历,3个月一行,间隔距离为c。 每日宽度间隔为w字符。每行长度为21* W+18+2* C。l是每星期行数。
2 calendar.firstweekday( )
返回当前每周起始日期的设置。默认情况下,首次载入caendar模块时返回0,即星期一。
3 calendar.isleap(year)
是闰年返回True,否则为false。
4 calendar.leapdays(y1,y2)
返回在Y1,Y2两年之间的闰年总数。
5 calendar.month(year,month,w=2,l=1)
返回一个多行字符串格式的year年month月日历,两行标题,一周一行。每日宽度间隔为w字符。每行的长度为7* w+6。l是每星期的行数。
6 calendar.monthcalendar(year,month)
返回一个整数的单层嵌套列表。每个子列表装载代表一个星期的整数。Year年month月外的日期都设为0;范围内的日子都由该月第几日表示,从1开始。
7 calendar.monthrange(year,month)
返回两个整数。第一个是该月的星期几的日期码,第二个是该月的日期码。日从0(星期一)到6(星期日);月从1到12。
8 calendar.prcal(year,w=2,l=1,c=6)
相当于 print calendar.calendar(year,w,l,c).
9 calendar.prmonth(year,month,w=2,l=1)
相当于 print calendar.calendar(year,w,l,c)。
10 calendar.setfirstweekday(weekday)
设置每周的起始日期码。0(星期一)到6(星期日)。
11 calendar.timegm(tupletime)
和time.gmtime相反:接受一个时间元组形式,返回该时刻的时间辍(1970纪元后经过的浮点秒数)。
12 calendar.weekday(year,month,day)
返回给定日期的日期码。0(星期一)到6(星期日)。月份为 1(一月) 到 12(12月)。

十三、函数
函数定义:
普通函数定义:
函数代码块以 def 关键词开头,后接函数标识符名称和圆括号()和冒号。
任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容需要缩进。
return [表达式] 结束函数,选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
def functionname( parameters ):
“函数_文档字符串”
function_suite
return [expression]
匿名函数定义 - lambda表达式 - 函数直接量:
# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2;
# 调用sum函数
print "相加后的值为 : ", sum( 10, 20 )
print "相加后的值为 : ", sum( 20, 20 )
函数调用:
定义一个函数只给了函数一个名称,指定了函数里包含的参数,和代码块结构。
def printme( str ):
“打印任何传入的字符串”
print str;
return;
printme(“My string”);
printme(str = “My string”);
缺省参数:
def printinfo( name, age = 35 ):
“打印任何传入的字符串”
print "Name: ", name;
print "Age ", age;
return;
printinfo( age=50, name=“miki” );
printinfo( name=“miki” );
不定长参数 - 可变参数:
def functionname([formal_args,] *var_args_tuple ):
“函数_文档字符串”
function_suite
return [expression]
空函数
如果想定义一个什么事也不做的空函数,可以用pass语句:
def nop():
pass
pass语句什么都不做,那有什么用?实际上pass可以用来作为占位符,比如现在还没想好怎么写函数的代码,就可以先放一个pass,让代码能运行起来。
pass还可以用在其他语句里,比如:
if age >= 18:
pass
缺少了pass,代码运行就会有语法错误。
函数是一等公民
可以作为类的成员使用
可以作为局部成员定义在另一个函数的内部
可以被赋值给常量变量
可以作为另一个函数的参数被传递 被当作另一个函数的返回值被返回
闭包问题

十四、模块
Python 模块(Module),是一个 Python 文件,以 .py 结尾,包含了 Python 对象定义和Python语句。
模块让你能够有逻辑地组织你的 Python 代码段。
把相关的代码分配到一个模块里能让你的代码更好用,更易懂。
模块能定义函数,类和变量,模块里也能包含可执行的代码。
引入模块
import module1[, module2[,… moduleN]
比如要引用模块 math,就可以在文件最开始的地方用 import math 来引入。在调用 math 模块中的函数时,必须这样引用:
模块名.函数名
From…import 语句
Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中。语法如下:
from modname import name1[, name2[, … nameN]]
From…import* 语句
把一个模块的所有内容全都导入到当前的命名空间也是可行的,只需使用如下声明:
from modname import *
搜索路径
当你导入一个模块,Python 解析器对模块位置的搜索顺序是:
1、当前目录
2、如果不在当前目录,Python 则搜索在 shell 变量 PYTHONPATH 下的每个目录。
3、如果都找不到,Python会察看默认路径。UNIX下,默认路径一般为/usr/local/lib/python/。

十五、包
包是一个分层次的文件目录结构,它定义了一个由模块及子包,和子包下的子包等组成的 Python 的应用环境。
简单来说,包就是文件夹,但该文件夹下必须存在 init.py 文件, 该文件的内容可以为空。init.py用于标识当前文件夹是一个包。
考虑一个在 package_runoob 目录下的 runoob1.pyrunoob2.pyinit.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
		#!/usr/bin/python
		# -*- coding: UTF-8 -*-	 
		if __name__ == '__main__':
		    print '作为主程序运行'
		else:
		    print '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

十六、IO
1.打印到屏幕
print “aaa”;
2.读取键盘输入
raw_input函数
str = raw_input(“请输入:”);
input函数 - input([prompt]) 函数和 raw_input([prompt]) 函数基本类似,但是 input 可以接收一个Python表达式作为输入,并将运算结果返回。
str = input(“请输入:”);
输入:[x*5 for x in range(2,10,2)]
str: [10, 20, 30, 40]
3.打开和关闭文件
open 函数
file = open(file_name [, access_mode][, buffering])
file_name:file_name变量是一个包含了你要访问的文件名称的字符串值。
access_mode:access_mode决定了打开文件的模式:只读,写入,追加等。所有可取值见如下的完全列表。这个参数是非强制的,默认文件访问模式为只读®。
buffering:如果buffering的值被设为0,就不会有寄存。如果buffering的值取1,访问文件时会寄存行。如果将buffering的值设为大于1的整数,表明了这就是的寄存区的缓冲大小。如果取负值,寄存区的缓冲大小则为系统默认。
r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w 打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。
wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。
w+ 打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。
wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。
a 打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。
ab 以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。
a+ 打开一个文件用于读写。如果该文件已存在,文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在,创建新文件用于读写。
ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。如果该文件不存在,创建新文件用于读写。
file对象属性
file.closed 返回true如果文件已被关闭,否则返回false。
file.mode 返回被打开文件的访问模式。
file.name 返回文件的名称。
file.softspace 如果用print输出后,必须跟一个空格符,则返回false。否则返回true。
关闭文件:
fileObject.close();
写文件:
fileObject.write(string);
读文件:
fileObject.read([count]);
文件随机读写:
tell()方法告诉你文件内的当前位置;换句话说,下一次的读写会发生在文件开头这么多字节之后。
seek(offset [,from])方法改变当前文件的位置。Offset变量表示要移动的字节数。From变量指定开始移动字节的参考位置。
如果from被设为0,这意味着将文件的开头作为移动字节的参考位置。如果设为1,则使用当前的位置作为参考位置。如果它被设为2,那么该文件的末尾将作为参考位置。
重命名文件:
os.rename(current_file_name, new_file_name)
删除文件:
os.remove(file_name)
创建目录:
import os
os.mkdir(“newdir”)
改变的当前目录:
os.chdir(“newdir”)
删除目录:
os.rmdir(‘dirname’)
File其他方法:
file.close()
关闭文件。关闭后文件不能再进行读写操作。
file.flush()
刷新文件内部缓冲,直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
file.fileno()
返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。
file.isatty()
如果文件连接到一个终端设备返回 True,否则返回 False。
file.next()
返回文件下一行。
file.read([size])
从文件读取指定的字节数,如果未给定或为负则读取所有。
file.readline([size])
读取整行,包括 “\n” 字符。
file.readlines([sizehint])
读取所有行并返回列表,若给定sizeint>0,返回总和大约为sizeint字节的行, 实际读取值可能比sizhint较大, 因为需要填充缓冲区。
file.seek(offset[, whence])
设置文件当前位置
file.tell()
返回文件当前位置。
file.truncate([size])
截取文件,截取的字节通过size指定,默认为当前文件位置。
file.write(str)
将字符串写入文件,没有返回值。
file.writelines(sequence)
向文件写入一个序列字符串列表,如果需要换行则要自己加入每行的换行符。

十七、异常处理
python标准异常
异常名称 描述
BaseException 所有异常的基类
SystemExit 解释器请求退出
KeyboardInterrupt 用户中断执行(通常是输入^C)
Exception 常规错误的基类
StopIteration 迭代器没有更多的值
GeneratorExit 生成器(generator)发生异常来通知退出
StandardError 所有的内建标准异常的基类
ArithmeticError 所有数值计算错误的基类
FloatingPointError 浮点计算错误
OverflowError 数值运算超出最大限制
ZeroDivisionError 除(或取模)零 (所有数据类型)
AssertionError 断言语句失败
AttributeError 对象没有这个属性
EOFError 没有内建输入,到达EOF 标记
EnvironmentError 操作系统错误的基类
IOError 输入/输出操作失败
OSError 操作系统错误
WindowsError 系统调用失败
ImportError 导入模块/对象失败
LookupError 无效数据查询的基类
IndexError 序列中没有此索引(index)
KeyError 映射中没有这个键
MemoryError 内存溢出错误(对于Python 解释器不是致命的)
NameError 未声明/初始化对象 (没有属性)
UnboundLocalError 访问未初始化的本地变量
ReferenceError 弱引用(Weak reference)试图访问已经垃圾回收了的对象
RuntimeError 一般的运行时错误
NotImplementedError 尚未实现的方法
SyntaxError Python 语法错误
IndentationError 缩进错误
TabError Tab 和空格混用
SystemError 一般的解释器系统错误
TypeError 对类型无效的操作
ValueError 传入无效的参数
UnicodeError Unicode 相关的错误
UnicodeDecodeError Unicode 解码时的错误
UnicodeEncodeError Unicode 编码时错误
UnicodeTranslateError Unicode 转换时错误
Warning 警告的基类
DeprecationWarning 关于被弃用的特征的警告
FutureWarning 关于构造将来语义会有改变的警告
OverflowWarning 旧的关于自动提升为长整型(long)的警告
PendingDeprecationWarning 关于特性将会被废弃的警告
RuntimeWarning 可疑的运行时行为(runtime behavior)的警告
SyntaxWarning 可疑的语法的警告
UserWarning 用户代码生成的警告
try:
<语句> #运行别的代码
except <名字>:
<语句> #如果在try部份引发了’name’异常
except <名字>,<数据>:
<语句> #如果引发了’name’异常,获得附加的数据
else:
<语句> #如果没有异常发生
如果当try后的语句执行时发生异常,python就跳回到try并执行第一个匹配该异常的except子句,异常处理完毕,控制流就通过整个try语句(除非在处理异常时又引发新的异常)。
如果在try后的语句里发生了异常,却没有匹配的except子句,异常将被递交到上层的try,或者到程序的最上层(这样将结束程序,并打印缺省的出错信息)。
如果在try子句执行时没有发生异常,python将执行else语句后的语句(如果有else的话),然后控制流通过整个try语句。
try:
fh = open(“testfile”, “w”)
fh.write(“这是一个测试文件,用于测试异常!!”)
except IOError:
print “Error: 没有找到文件或读取文件失败”
else:
print “内容写入文件成功”
fh.close()
使用except而不带任何异常类型
你可以不带任何异常类型使用except,如下实例:
try:
正常的操作

except:
发生异常,执行这块代码

else:
如果没有异常执行这块代码
try-finally 语句
try-finally 语句无论是否发生异常都将执行最后的代码。
try:
<语句>
finally:
<语句> #退出try时总会执行
异常参数
一个异常可以带上参数,可作为输出的异常信息参数。
你可以通过except语句来捕获异常的参数,如下所示:
try:
正常的操作

except ExceptionType, Argument:
你可以在这输出 Argument 的值…
触发异常
我们可以使用raise语句自己触发异常
raise语法格式如下:
raise [Exception [, args [, traceback]]]
def functionName( level ):
if level < 1:
raise Exception(“Invalid level!”, level)
# 触发异常后,后面的代码就不会再执行
用户自定义异常
通过创建一个新的异常类,程序可以命名它们自己的异常。异常应该是典型的继承自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

十八、面向对象
1.创建类
使用class语句来创建一个新类,class之后为类的名称并以冒号结尾,如下实例:
class ClassName:
‘类的帮助信息’ #类文档字符串
class_suite #类体
类的帮助信息可以通过ClassName.doc__查看。
class_suite 由类成员,方法,数据属性组成。
实例
#!/usr/bin/python
# -- coding: UTF-8 --
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
empCount 变量是一个类变量,它的值将在这个类的所有实例之间共享。你可以在内部类或外部类使用 Employee.empCount 访问。
第一种方法__init
()方法是一种特殊的方法,被称为类的构造函数或初始化方法,当创建了这个类的实例时就会调用该方法
self 代表类的实例,self 在定义类的方法时是必须有的,虽然在调用时不必传入相应的参数。
self代表类的实例,而非类
类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。
class Test:
def prt(self):
print(self)
print(self.class)
t = Test()
t.prt()
#self 不是 python 关键字,我们把他换成 runoob 也是可以正常执行的:
实例
class Test:
def prt(runoob):
print(runoob)
print(runoob.class)
t = Test()
t.prt()
创建实例对象
实例化类的对象在其他编程语言中一般用关键字 new,但是在 Python 中并没有这个关键字,在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) : 删除属性。
hasattr(emp1, ‘age’) # 如果存在 ‘age’ 属性返回 True。
getattr(emp1, ‘age’) # 返回 ‘age’ 属性的值
setattr(emp1, ‘age’, 8) # 添加属性 ‘age’ 值为 8
delattr(empl, ‘age’) # 删除属性 ‘age’
Python内置类属性
dict : 类的属性(包含一个字典,由类的数据属性组成)
doc :类的文档字符串
name: 类名
module: 类定义所在的模块(类的全名是’main.className’,如果类位于一个导入模块mymod中,那么className.module 等于 mymod)
bases : 类的所有父类构成元素(包含了一个由所有父类组成的元组)
实例
#!/usr/bin/python
# -- coding: UTF-8 --
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
print “Employee.doc:”, Employee.doc
print “Employee.name:”, Employee.name
print “Employee.module:”, Employee.module
print “Employee.bases:”, Employee.bases
print “Employee.dict:”, Employee.dict
执行以上代码输出结果如下:
Employee.doc: 所有员工的基类
Employee.name: Employee
Employee.module: main
Employee.bases: ()
Employee.dict: {‘module’: ‘main’, ‘displayCount’: <function displayCount at 0x10a939c80>, ‘empCount’: 0, ‘displayEmployee’: <function displayEmployee at 0x10a93caa0>, ‘doc’: ‘\xe6\x89\x80\xe6\x9c\x89\xe5\x91\x98\xe5\xb7\xa5\xe7\x9a\x84\xe5\x9f\xba\xe7\xb1\xbb’, ‘init’: <function init at 0x10a939578>}
阅读python对象销毁(垃圾回收)
Python 使用了引用计数这一简单技术来跟踪和回收垃圾。
在 Python 内部记录着所有使用中的对象各有多少引用。
一个内部跟踪变量,称为一个引用计数器。
当对象被创建时, 就创建了一个引用计数, 当这个对象不再需要时, 也就是说, 这个对象的引用计数变为0 时, 它被垃圾回收。但是回收不是"立即"的, 由解释器在适当的时机,将垃圾对象占用的内存空间回收。
a = 40 # 创建对象 <40>
b = a # 增加引用, <40> 的计数
c = [b] # 增加引用. <40> 的计数
del a # 减少引用 <40> 的计数
b = 100 # 减少引用 <40> 的计数
c[0] = -1 # 减少引用 <40> 的计数
垃圾回收机制不仅针对引用计数为0的对象,同样也可以处理循环引用的情况。循环引用指的是,两个对象相互引用,但是没有其他变量引用他们。这种情况下,仅使用引用计数是不够的。Python 的垃圾收集器实际上是一个引用计数器和一个循环垃圾收集器。作为引用计数的补充, 垃圾收集器也会留心被分配的总量很大(及未通过引用计数销毁的那些)的对象。 在这种情况下, 解释器会暂停下来, 试图清理所有未引用的循环。
实例
析构函数 del ,__del__在对象销毁的时候被调用,当对象不再被使用时,__del__方法运行
#!/usr/bin/python
# -- coding: UTF-8 --
class Point:
def init( self, x=0, y=0):
self.x = x
self.y = y
def del(self):
class_name = self.class.name
print class_name, “销毁”
pt1 = Point()
pt2 = pt1
pt3 = pt1
print id(pt1), id(pt2), id(pt3) # 打印对象的id
del pt1
del pt2
del pt3
以上实例运行结果如下:
3083401324 3083401324 3083401324
Point 销毁
类的继承
面向对象的编程带来的主要好处之一是代码的重用,实现这种重用的方法之一是通过继承机制。继承完全可以理解成类之间的类型和子类型关系。
需要注意的地方:继承语法 class 派生类名(基类名)://… 基类名写在括号里,基本类是在类定义的时候,在元组之中指明的。
在python中继承中的一些特点:
1:在继承中基类的构造(init()方法)不会被自动调用,它需要在其派生类的构造中亲自专门调用。
2:在调用基类的方法时,需要加上基类的类名前缀,且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数
3:Python总是首先查找对应类型的方法,如果它不能在派生类中找到对应的方法,它才开始到基类中逐个查找。(先在本类中查找调用的方法,找不到才去基类中找)。
如果在继承元组中列了一个以上的类,那么它就被称作"多重继承” 。
语法:
派生类的声明,与他们的父类类似,继承的基类列表跟在类名之后,如下所示:
class SubClassName (ParentClass1[, ParentClass2, …]):
‘Optional class documentation string’
class_suite
实例
#!/usr/bin/python
# -- coding: UTF-8 --
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 ‘调用子类方法 child method’
c = Child() # 实例化子类
c.childMethod() # 调用子类的方法
c.parentMethod() # 调用父类方法
c.setAttr(200) # 再次调用父类的方法
c.getAttr() # 再次调用父类的方法
以上代码执行结果如下:
调用子类构造方法
调用子类方法 child method
调用父类方法
父类属性 : 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。
方法重写
如果你的父类方法的功能不能满足你的需求,你可以在子类重写你父类的方法:
实例
#!/usr/bin/python
# -- coding: UTF-8 --
class Parent: # 定义父类
def myMethod(self):
print ‘调用父类方法’
class Child(Parent): # 定义子类
def myMethod(self):
print ‘调用子类方法’
c = Child() # 子类实例
c.myMethod() # 子类调用重写方法
执行以上代码输出结果如下:
调用子类方法
基础重写方法
下表列出了一些通用的功能,你可以在自己的类重写:
1 init ( self [,args…] )
构造函数
简单的调用方法: obj = className(args)
2 del( self )
析构方法, 删除一个对象
简单的调用方法 : dell obj
3 repr( self )
转化为供解释器读取的形式
简单的调用方法 : repr(obj)
4 str( self )
用于将值转化为适于人阅读的形式
简单的调用方法 : str(obj)
5 cmp ( self, x )
对象比较
简单的调用方法 : cmp(obj, x)
运算符重载
Python同样支持运算符重载,实例如下:
实例
#!/usr/bin/python
class Vector:
def init(self, a, b):
self.a = a
self.b = b
def str(self):
return ‘Vector (%d, %d)’ % (self.a, self.b)
def add(self,other):
return Vector(self.a + other.a, self.b + other.b)
v1 = Vector(2,10)
v2 = Vector(5,-2)
print v1 + v2
以上代码执行结果如下所示:
Vector(7,8)
类属性与方法
类的私有属性
__private_attrs:两个下划线开头,声明该属性为私有,不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。
类的私有方法
__private_method:两个下划线开头,声明该方法为私有方法,不能在类地外部调用。在类的内部调用 self.__private_methods
实例

#!/usr/bin/python
			# -*- coding: UTF-8 -*-
			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  
		# 报错,实例不能访问私有变量
		单下划线、双下划线、头尾双下划线说明:
	__foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。
	__foo__: 定义的是特列方法,类似 __init__() 之类的。

使用类相关函数:
	type() 判断对象类型
		type(123)
		type('abc')==types.StringType
	isinstance(对象,类) 判断class的类型
		isinstance(p,Person)
	dir() 获得一个对象的所有属性和方法
		dir('ABC')
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值