标签：
基础篇2:
一切变量都是数据对象的引用
sys.getrefcount(‘test‘) 查看引用计数
变量命名不能以数字开头
编码：ascii、unicode、utf-8
1.阅读str对象的help文档，并解决如下的问题。
1.1.有如下字符串。
python是动态语言
要求如下[请分别写出脚本]：
a=‘ python是动态语言 ‘
(1.)去掉该字符串下前面所有的空格。
print a.lstrip()
(2.)去掉该字符串下后面所有的空格。
print a.rstrip()
(3.)去掉该字符串2边的空格。
print a.strip()
1.2有如下字符串
"abc"
（1）请将其全部大写。
b=‘abc b.upper
（2）请将其全部小写。
b=‘ABC‘ b.lower()
2 怎么查看变量的类型是什么？
type(a)
基础篇5习题
1 ：
info = ‘abc‘ info[2] = ‘d‘
结果是什么，为什么会报错呢?
TypeError: ‘str‘ object does not support item assignment
字符串不可变
2 如果要把上面的字符串info里面的c替换成d，要怎么操作呢？
info=‘abc‘ list(info) a[2]=‘d‘ info=‘‘.join(a)
3 下面2个变量
a = ‘1‘
b = 2
print a + b 的结果是什么，为什么会出现这个结果，如果希望结果是3，要怎么操作？
不同类型不能相加
int(a)+ b
基础篇6习题：
1 字符串:
a = ‘abcd‘
用2个方法取出字母d
a[3]
a = ‘jay‘
b = ‘python‘
用字符串拼接的方法输出：
my name is jay,i love python.
print ‘my name is %s,i love %s.‘ % (a,b)
"".join([a,b])
基础篇7习题：
1：
a = ‘pyer‘
b = ‘apple‘
用字典和format方法实现：
my name is pyer, i love apple.
2:打开文件info.txt,并且写入500这个数字。
a=open(‘info.txt‘,‘w‘) a.write(500) a.close()
基础篇8习题：
一.已经字符串 s = "i,am,lilei",请用两种办法取出之间的“am”字符。
s[2:4] s.split(‘,‘)[1]
二.在python中，如何修改字符串？
转成list来修改
用replace修改
三.bool("2012" == 2012) 的结果是什么。
false
四.已知一个文件 test.txt，内容如下：
____________
2012来了。
2012不是世界末日。
2012欢乐多。
_____________
1.请输出其内容。
print open(‘text.txt‘).read()
2.请计算该文本的原始长度。
date=open(‘text.txt‘).read() len(date.decode(‘GBK‘))
3.请去除该文本的换行。
4.请替换其中的字符"2012"为"2013"。
print date.replace(‘2012‘,‘2013‘)
5.请取出最中间的长度为5的子串。
6.请取出最后2个字符。
date[-1:-3:-1]
7.请从字符串的最初开始，截断该字符串，使其长度为11.
8.请将{4}中的字符串保存为test1.py文本.
五.请用代码的形式描述python的引用机制。
引用从3开始，引用一次加1，去引用减1
六.已知如下代码
________
a = "中文编程"
b = a
c = a
b2 = a.replace("中","中")
________
1.请给出str对象"中文编程"的引用计数
4
2.请给出str对象"python编程"的引用计数
0
七.已知如下变量
________
a = "字符串拼接1"
b = "字符串拼接2"
________
1.请用四种以上的方式将a与b拼接成字符串c。并指出每一种方法的优劣。
a+b
占位符号
"".join([a,b])
c="{1}{0}".format (a,b)
2.请将a与b拼接成字符串c，并用逗号分隔。
",".join([a,b])
3.请计算出新拼接出来的字符串长度，并取出其中的第七个字符。
c[7]
八.请阅读string模块，并且，根据string模块的内置方法输出如下几题的答案。
1.包含0-9的数字。
2.所有小写字母。
3.所有标点符号。
4.所有大写字母和小写字母。
5.请使用你认为最好的办法将{1}-{4}点中的字符串拼接成一个字符串。
九.已知字符串
________
a = "i,am,a,boy,in,china"
________
1.假设boy和china是随时可能变换的，例boy可能改成girl或者gay，而china可能会改成别的国家，你会如何将上面的字符串，变为可配置的。
2.请使用2种办法取出其间的字符"boy"和"china"。
3.请找出第一个"i"出现的位置。
4.请找出"china"中的"i"字符在字符串a中的位置。
5.请计算该字符串一共有几个逗号。
十.请将模块string的帮助文档保存为一个文件。
列表习题：
一 下面列表：
a = [1,2,3,4,5,333,11,44]
输出下面的结果：
[4,5,333]
a[3:6]
二 有下面2个列表
a = [1,2,3]
b = [4,5,6]
用2个方法输出下面结果：
[1,2,3,4,5,6]
a.extend(b)
a+b
三 有下面2个列表：
a = [1,99,33,44,55,22]
输出结果:
1：[1,2,99,33,44,55,22,(11,33,54)]
a.insert.()append
2: [1,2,99,33,101,44,55,22]
extend
四：用列表推导式生成100内的大于20的偶数
[x for x in range(20,100) if x%2==0]
列表应用习题：
xrange和range的具体区别:
xrange的用法：
xrange(开始，结束，步长) xrange 它生成一个xrange对象
当我们需要操作一个非常大的数据，而且内存比较吃紧的时候，我们可以用xrange来操作省内存
xrange一般用在循环里面，比如我们只需要操作部分数据的话，而不是返回全部元素来完成操作，推荐用xrange,效率更高
一: 已知：元组 a = (1,2,3) 利用list方法，输出下面的结果：
(1,2,4)
b=list(a) b[2]=4 a=tuple(b)
二: 利用列表推导完成下面习题：
1 输出结果：[1 love python,2 love python,3 love python,.... 10 love python]
["%s is love python" % x for x in range(1,10)]
2 输出结果：[(0,0),(0,2),(2,0),(2,2)]
[(x,y) for x in range(3) for y in range(3) if x%2==0 if y%2==0]
三：
a = [1,2,3]
b = a[:]
del a
b的值是什么。为什么呢？
[1,2,3]
元组和集合习题：
集合不能有切片操作
set 方法创建集合
基本操作：add、update、remove、
一 元组；a = (1,2,3)
1 有2种方法输出实现下面的结果：
(5,2,3)
2 判断2是否在元组里
二 集合a = set([‘a‘,‘b‘,‘c‘])做下面的操作：
1 添加字符串‘jay‘到集合a里。
a.add(‘jay‘)
2 集合b = set([‘b‘,‘e‘,‘f‘,‘g‘]) 用2种方法求集合a 和集合b的并集。
& --交集
| --并集
- --差集
字典习题:
字典类型：{‘key‘:‘value‘}
key必须为不可变的数据类型：数字，字符串，元组，列表不能做为key
字典是无序的，通过键名来读取内容，是可嵌套的
>>> binfo
{‘a‘: [1, 2, 3], ‘b‘: [4, 5, 6]}
>>> binfo[‘a‘][1]=5
>>> binfo
{‘a‘: [1, 5, 3], ‘b‘: [4, 5, 6]}
已知字典：ainfo = {‘ab‘:‘liming‘,‘ac‘:20}
完成下面的操作
1 使用2个方法，输出的结果：
ainfo = {‘ab‘:‘liming‘,‘ac‘:20,‘sex‘:‘man‘,‘age‘:20}
ainfo[‘sex‘]=‘man‘
2 输出结果：[‘ab‘,‘ac‘]
ainfo.keys()
3 输出结果：[‘liming‘,20]
ainfo.values()
4 通过2个方法返回键名ab对应的值。
ainfo.get(‘ab‘) info.keys()[1]
5 通过2个方法删除键名ac对应的值。
del info[‘age‘] info.pop(‘name‘)
基础篇13-数据结构习题：
列表a = [11,22,24,29,30,32]
1 把28插入到列表的末端
a.append(28)
2 在元素29后面插入元素57
a.insert(4,57)
3 把元素11修改成6
a[0]=6
3 删除元素32
a.remove(32)
4 对列表从小到大排序
b=list(set(a))
##习题2：
列表b = [1,2,3,4,5]
1 用2种方法输出下面的结果：
[1,2,3,4,5,6,7,8]
b+[6,7,8]
b.extend([6,7,8])
2 用列表的2种方法返回结果：[5,4]
b[-4:-6:-1]
[b[4],b[3]]
3 判断2是否在列表里
2 in b
##习题3：
b = [23,45,22,44,25,66,78]
用列表解析完成下面习题：
1 生成所有奇数组成的列表
[x for x in b if x%2==1]
2 输出结果: [‘the content 23‘,‘the content 45‘]
[‘The content %d‘ % x for x in b[0:2]]
3 输出结果: [25, 47, 24, 46, 27, 68, 80]
[x+2 for x in b]
##习题4：
用range方法和列表推导的方法生成列表：
[11,22,33]
range(11,44,11) [m*11 for m in range(1:4)]
##习题5：
已知元组:a = (1,4,5,6,7)
1 判断元素4是否在元组里
4 in a
2 把元素5修改成8
b=list(a) b[2]=8 a=tuple(b)
##习题6：
已知集合:setinfo = set(‘acbdfem‘)和集合finfo = set(‘sabcdef‘)完成下面操作：
1 添加字符串对象‘abc‘到集合setinfo
setinfo.add(‘abc‘)
2 删除集合setinfo里面的成员m
setinfo.remove(‘m‘)
3 求2个集合的交集和并集
setinfo & finfo
setinfo | finfo
##习题7：
用字典的方式完成下面一个小型的学生管理系统。
1 学生有下面几个属性：姓名，年龄，考试分数包括：语文，数学，英语得分。
比如定义2个同学：
姓名：李明，年龄25，考试分数：语文80，数学75，英语85
姓名：张强，年龄23，考试分数：语文75，数学82，英语78
2 给学生添加一门python课程成绩，李明60分，张强：80分
tongxue1[‘score‘][‘python‘]=60 tongxue2[‘score‘][‘python‘]=80
3 把张强的数学成绩由82分改成89分
tongxue2[‘score‘][‘shuxue‘]=89
4 删除李明的年龄数据
tongxue1.pop(‘age‘)
5 对张强同学的课程分数按照从低到高排序输出。
b=tongxue1[‘score‘].values() b.sort()
6 外部删除学生所在的城市属性，不存在返回字符串 beijing
tongxue1.pop(‘chengshi‘,[‘beijing‘])
基础篇18习题：
1. 已知字符串 a = "aAsmr3idd4bgs7Dlsf9eAF",要求如下
1.1 请将a字符串的大写改为小写，小写改为大写。
print a.swapcase()
1.2 请将a字符串的数字取出，并输出成一个新的字符串。
"".join([x for x in a if x.isdigit()])
1.3 请统计a字符串出现的每个字母的出现次数（忽略大小写，a与A是同一个字母），并输出成一个字典。 例 {‘a‘:4,‘b‘:2}
[(x,a.count(x)) for x in set(a.lower())]
1.4 请去除a字符串多次出现的字母，仅留最先出现的一个。例 ‘abcabb‘，经过去除后，输出 ‘abc‘
a_list = list(a) #转换成list set_list = list(set(a_list)) #去重以后再转换回list set_list.sort(key=a_list.index) #对去重以后的list进行原先的排序 print ‘‘.join(set_list)#拼接成字符串
1.5 请将a字符串反转并输出。例：‘abc‘的反转是‘cba‘
print a[::-1]
1.6 去除a字符串内的数字后，请将该字符串里的单词重新排序（a-z），并且重新输出一个排序后的字符 串。（保留大小写,a与A的顺序关系为：A在a前面。例：AaBb）
a = "aAsmr3idd4bgs7Dlsf9eAF"
l = sorted(a) a_upper_list = [] a_lower_list = [] for x in l: if x.isupper(): a_upper_list.append(x) elif x.islower(): a_lower_list.append(x) else: pass for y in a_upper_list: y_lower = y.lower() if y_lower in a_lower_list: a_lower_list.insert(a_lower_list.index(y_lower),y) print ‘‘.join(a_lower_list)
1.7 请判断 ‘boy‘里出现的每一个字母，是否都出现在a字符串里。如果出现，则输出True，否则，则输 出False.
a = "aAsmr3idd4bgs7Dlsf9eAF"
search = ‘boy‘
u = set(a) u.update(list(search)) print len(set(a)) == len(u) a = "aAsmr3idd4bgs7Dlsf9eAF" print set(‘boy‘).issubset(set(a))
1.8 要求如1.7，此时的单词判断，由‘boy‘改为四个，分别是 ‘boy‘,‘girl‘,‘bird‘,‘dirty‘，请判断如上这4个字符串里的每个字母，是否都出现在a字符串里。
a = "aAsmr3idd4bgs7Dlsf9eAF" search = [‘boy‘,‘girl‘,‘bird‘,‘dirty‘] b = set(a) for i in search: b.update(list(i)) print len(b) == len(set(a))
##另一个解答：
a = "aAsmr3idd4bgs7Dlsf9eAF" lst=[‘boy‘,‘girl‘,‘bird‘,‘dirty‘] s=‘‘.join(lst) print set(s).issubset(set(a))
1.9 输出a字符串出现频率最高的字母
l = ([(x,a.count(x)) for x in set(a)]) l.sort(key = lambda k:k[1],reverse=True) print l[0][0]
2.在python命令行里，输入import this 以后出现的文档，统计该文档中，"be" "is" "than" 的出现次数。
import os m = os.popen(‘python -m this‘).read() m = m.replace(‘\n‘,‘‘) l = m.split(‘ ‘) print [(x,l.count(x)) for x in [‘be‘,‘is‘,‘than‘]]
3.一文件的字节数为 102324123499123，请计算该文件按照kb与mb计算得到的大小。
size = 102324123499123 print ‘%s kb‘%(size >> 10) print ‘%s mb‘% (size >> 20)
4.已知 a = [1,2,3,6,8,9,10,14,17],请将该list转换为字符串，例如 ‘123689101417‘.
a = [1,2,3,6,8,9,10,14,17] print str(a)[1:-1].replace(‘, ‘,‘‘)
python 语句1.1:
print重定向>>
f=open(‘aa.txt‘,‘w‘) print >>f,‘hahahahaha‘ f.close()
进阶承上启下：
一：安装使用virtualenv，成功以后截个图。
二：把基础篇所学的：字符串，列表，元组，字典，集合。
从下面几个方面进行比较和总结：
1 是否支持边界检查
2 索引方法特点
3 哪些支持迭代协议
4 元素访问的特点，是顺序的还是无序的
列表元组有序，字典无序
5 哪些是可变和哪些是不可变的
元组不可变、字符串不可变 int不可变
6 哪些支持多层嵌套
三：通过基础篇的学习，说出你最喜欢python的哪一点，为什么?
函数第一节：
习题：
1.定义一个方法 func，该func可以引入任意多的整型参数，结果返回其中最大与最小的值。
def num(*num): #遍历参数列表，判断参数类型是否为整形 for i in num: if not isinstance(i,int): return ‘参数错误,参数必须为整数‘ return max(num),min(num)
2.定义一个方法func，该func可以引入任意多的字符串参数，结果返回（长度）最长的字符串。
def fun2(*num2): b=[] for i in num2: if isinstance(i,str): b.append(i) else:print "xx" print "max string is %s" % max(b, key=lambda x:len(x))
3.定义一个方法get_doc(module)，module参数为该脚本中导入或定义的模块对象，该函数返回module的帮助文档。
def get_doc(modu): print modu.__doc__
4.定义一个方法get_text(f),f参数为任意一个文件的磁盘路径，该函数返回f文件的内容。
>>> def get_text(f):
... a=open(f)
... return a.read()
5.定义一个方法get_dir(folder),folder参数为任意一个文件夹，该函数返回folder文件夹的文件列表。提示（可以了解python的glob模块）
import glob def get_dir(d): for i in glob.glob(d+‘\*‘): return i
函数第二节：
习题：
1 定义一个方法get_num(num),num参数是列表类型，判断列表里面的元素为数字类型。其他类型则报错，并且返回一个偶数列表：（注：列表里面的元素为偶数）。
def get_num(num): b=[] for i in num: if isinstance(i,int): b.append(i) return [x for x in b if x%2==0] print get_num([1,3,5,6,7,4,3,2])
2 定义一个方法get_page(url),url参数是需要获取网页内容的网址，返回网页的内容。提示（可以了解python的urllib模块）。
def get_page(url): if not (url.startswitch(‘http://‘)) or url.startswitch(‘https://‘): return u‘url地址不对‘ date=urllib2.urlopen(url) return date.read() print get_page(‘http://www.baidu.com‘)
3 定义一个方法 func，该func引入任意多的列表参数，返回所有列表中最大的那个元素。
def func(num): return max(num) print func([1,3,5,6,7,7,3])
4 定义一个方法get_dir(f),f参数为任意一个磁盘路径，该函数返回路径下的所有文件夹组成的列表，如果没有文件夹则返回"Not dir"。
def get_dir(f): if os.path.exists(f): return glob.glob(f+‘\*‘) else: print "Not dir" print get_dir("f:\\")
注明：吸取上次作业遇到的问题，要求写的函数逻辑清楚，并且考虑一些特殊的情况处理，能做断言的尽量用断言。
函数第三节：
习题：
1 定义一个方法get_fundoc(func),func参数为任意一个函数对象，返回该函数对象的描述文档，如果该函数没有描述文档，则返回"not found"
2 定义一个方法get_cjsum(),求1-100范围内的所有整数的平方和。返回结果为整数类型。
3 定义一个方法list_info(list), 参数list为列表对象，怎么保证在函数里对列表list进行一些相关的操作，不会影响到原来列表的元素值，比如：
a = [1,2,3]
def list_info(list):
‘‘‘要对list进行相关操作，不能直接只写一句return[1,2,5]，这样就没意义了‘‘‘
print list_info(a):返回结果：[1,2,5]
print a 输出结果：[1,2,3]
函数第四节：
1 用lambda和filter完成下面功能：输出一个列表，列表里面包括：1-100内的所有偶数。（提示：可以用filter,lambda）
filter(lambda x:x%2==0,range(1,100))
2 用位置匹配，关键字匹配，收集匹配(元组收集,字典收集)分别写4个函数，完成功能；
传递3个列表参数：
[1,2,3],[1,5,65],[33,445,22]
返回这3个列表中元素最大的那个，结果是：445
def fun1(list1,list2,list3): c=list1+list2+list3 return max(c) def fun2(list1=[],list2=[],list3=[]): c=list1+list2+list3 return max(c) a=[] def fun3(*kargs): for i in kargs: a.extend(i) print max(a) def fun4(**kwargs): print kwargs.values() for key in kwargs: b.extend(kwargs[key]) print max(b)
3 递归函数解释，用自己的话说明这个递归函数的工作流程。
def func1(i): if i<100: return i + func1(i+1) return i print func1(0)
函数周末习题：
#coding=utf-8
‘‘‘
1.定义一个func(name)，该函数效果如下。
assert func("lilei") = "Lilei"
assert func("hanmeimei") = "Hanmeimei"
assert func("Hanmeimei") = "Hanmeimei"
‘‘‘
"""
def func(name): return name.capitalize()
2.定义一个func(name,callback=None),效果如下。
assert func("lilei") == "Lilei"
assert func("LILEI",callback=string.lower) == "lilei"
assert func("lilei",callback=string.upper) == "LILEI"
def func2(name,callback=None): if callback==‘string.lower‘: return name.lower() elif callback=="string.upper": return name.upper() else: return name.capitalize()
3.定义一个func(*kargs),效果如下。
l = func(1,2,3,4,5)
for i in l:
print i,
#输出 1 2 3 4 5
l = func(5,3,4,5,6)
for i in l:
print i
#输出 5 3 4 5 6
"""
def func3(*kargs):
return kargs
"""
4.定义一个func(*kargs)，该函数效果如下。
assert func(222,1111,‘xixi‘,‘hahahah‘) == "xixi"
assert func(7,‘name‘,‘dasere‘) == ‘name‘
assert func(1,2,3,4) == None
def shortstr(*kargs): lis = filter(lambda x:isinstance(x,str),kargs) len_lis = [len(x) for x in lis] if len_lis: min_index = min(len_lis) return lis[len_lis.index(min_index)] return None
5.定义一个func(name=None,**kargs),该函数效果如下。
assert func(“lilei”) == "lilei"
assert func("lilei",years=4) == "lilei,years:4"
assert func("lilei",years=10,body_weight=20) == "lilei,years:4,body_weight:20"
def func4(name=None,**kwargs): data=[] for x,y in kwargs.items(): data.extend([‘,‘,str(x),":",str(y)]) info="".join(data) return(name,info)
面向对像第一节，习题：
一：定义一个学生类。有下面的类属性：
1 姓名
2 年龄
3 成绩（语文，数学，英语)[每课成绩的类型为整数]
类方法：
1 获取学生的姓名：get_name() 返回类型:str
2 获取学生的年龄：get_age() 返回类型:int
3 返回3门科目中最高的分数。get_course() 返回类型:int
写好类以后，可以定义2个同学测试下:
zm = student(‘zhangming‘,20,[69,88,100])
返回结果：
zhangming
20
100
lq = student(‘liqiang‘,23,[82,60,99])
返回结果：
liqiang
23
99
class Student(object): def __init__(self,name,age,*num): self.name=name self.age=age self.num=num def get_name(self): return self.name def get_age(self): return self.age def get_score(self): b=self.num print max(b) return max(b)
二：定义一个字典类：dictclass。完成下面的功能：
dict = dictclass({你需要操作的字典对象})
1 删除某个key
del_dict(key)
2 判断某个键是否在字典里，如果在返回键对应的值，不存在则返回"not found"
get_dict(key)
3 返回键组成的列表：返回类型;(list)
get_key()
4 合并字典，并且返回合并后字典的values组成的列表。返回类型:(list)
update_dict({要合并的字典})
class dictClass(object): def __init__(self,num): self.num=num print num def del_dict(self,key): self.key=key del self.num[self.key] def get_dict(self,key): self.key=key if self.num.has_key(self.key): return self.num[self.key] else: return "Not found" def get_key(self): return self.num.keys() def update_dict(self,dict): self.dict=dict self.num.update(dict) a=dictClass({‘qq‘:22,‘yy‘:44}) print a.get_key() print a.get_dict(‘qq‘) print a.get_dict(‘77‘)
面向对像第二节，习题：
定义一个列表的操作类：Listinfo
包括的方法:
1 列表元素添加: add_key(keyname) [keyname:字符串或者整数类型]
2 列表元素取值：get_key(num) [num:整数类型]
3 列表合并：update_list(list) [list:列表类型]
4 删除并且返回最后一个元素：del_key()
list_info = Listinfo([44,222,111,333,454,‘sss‘,‘333‘])
class ListInfo(object): def __init__(self,list_a): self.list_a=list_a def add_key(self,keyname): if not isinstance(keyname,int) or not isinstance(keyname.str): return "Input must str and int " self.list_a.append(keyname) return self.list_a def get_key(self,num): if not isinstance(num,int) or not num<0: return "num error" return self.list_a[num] def update_list(self,list_b): if not isinstance(list_b,list): return ‘must be a list‘ return self.list_a.extend(list_b) def def_key(self): return self.list_a.pop() list_info = ListInfo([44,222,111,333,454,‘sss‘,‘333‘]) print list_info.def_key()
定义一个集合的操作类：Setinfo
包括的方法:
1 集合元素添加: add_setinfo(keyname) [keyname:字符串或者整数类型]
2 集合的交集：get_intersection(unioninfo) [unioninfo :集合类型]
3 集合的并集： get_union(unioninfo)[unioninfo :集合类型]
4 集合的差集：del_difference(unioninfo) [unioninfo :集合类型]
set_info = Setinfo(你要操作的集合)
class Setinfo(object): def __init__(self,set_list): self.set_list=set_list def add_setinf(self,keyname): if not isinstance(keyname,str) or not isinstance(keyname,int): return "Errot" return self.set_list.add(keyname) def get_intersection(self,unioninfo): if not isinstance(unioninfo,set): return ‘Error‘ return self.set_list & unioninfo def del_difference(self,unioninfo): if not isinstance(unioninfo,set): return "Eroor" return self.set_list - unioninfo
面向对像第三节，习题：
题目一： 写一个网页数据操作类。完成下面的功能：
提示：需要用到urllib模块
get_httpcode()获取网页的状态码，返回结果例如：200,301,404等 类型为int
get_htmlcontent() 获取网页的内容。返回类型:str
get_linknum()计算网页的链接数目。
import re import urllib class get_url(object): def __init__(self,url): self.url=url print self.url if not self.url.startswith("http:") or self.url.startswith(‘https:‘): print ‘input url error‘ exit(-1) self.new=urllib.urlopen(self.url) def get_httpcode(self): httpcode=self.new.getcode() if httpcode ==200: return ‘Return code is 200,OK‘ elif httpcode==301: return "301" elif httpcode==404: return ‘not found‘ else:return ‘dont know code‘ def get_htmlcontent(self): return self.new.read() def get_linknum(self): data=self.new.read() cc=re.findall(‘href="(http:.*?)"‘,data) return len(cc) baidu=get_url(‘http://ww.baidu.com‘) print baidu.get_linknum()
题目二：
class SchoolMember: ‘‘‘Represents any school member.‘‘‘ def __init__(self, name, age): self.name = name self.age = age print ‘(Initialized SchoolMember: %s)‘ % self.name def tell(self): ‘‘‘Tell my details.‘‘‘ print ‘Name:"%s" Age:"%s"‘ % (self.name, self.age), class Teacher(SchoolMember): ‘‘‘Represents a teacher.‘‘‘ def __init__(self, name, age, salary): SchoolMember.__init__(self, name, age) self.salary = salary print ‘(Initialized Teacher: %s)‘ % self.name def tell(self): print ‘Salary: "%d"‘ % self.salary class Student(SchoolMember): ‘‘‘Represents a student.‘‘‘ def __init__(self, name, age, marks): SchoolMember.__init__(self, name, age) self.marks = marks print ‘(Initialized Student: %s)‘ % self.name def tell(self): print ‘Marks: "%d"‘ % self.marks t = Teacher(‘Mrs. Shrividya‘, 40, 30000) s = Student(‘Swaroop‘, 22, 75) members = [t, s] for member in members: member.tell()
体会下这段代码，把结果的执行流程用自己的话写下。
模块第一节：
导入模块两种方式：
import 模块名
from 模块名 import 方法
from 模块名 import all
包的创建
方法一:
1、创建一个文件夹，包后再新建一个__init__.py文件，再次可以创建自己的方法
2、引用
import 文件夹.方法 as 方法
print 方法.方法()
方法二:
1、创建一个文件夹，包后再新建一个__init__.py文件，再次可以创建自己的方法
2、from 文件夹 import 方法函数
import 路径 import sys sys.path.append(‘/tmp/aa.py‘)
模块第二节：
常用模块介绍：
urllib
urllib2
datetime time
os
pickle
bsddb -数据库
logging
习题：
习题一：
1.1 用time模块获取当前的时间戳.
import time time.strftime("%Y%m%d %H:%M:%S")
1.2 用datetime获取当前的日期，例如：2013-03-29
from datetime import date print date.today()
1.3 用datetime返回一个月前的日期：比如今天是2013-3-29 一个月前的话：2013-02-27
习题二:
1 用os模块的方法完成ping www.baidu.com 操作。
import subprocess subprocess.call(‘ping www.baidu.com‘,shell=True)
2 定义一个函数kouzhang(dirpwd)，用os模块的相关方法，返回一个列表，列表包括：dirpwd路径下所有文件不重复的扩展名，如果有2个".py"的扩展名，则返回一个".py"。
import os def kouzhang(dirpwd) c=[] dirpwd=raw_input(‘please input your dir:‘) if not os.path.isdir(dirpwd): return "Please input a dir" for i in os.listdir(dirpwd): if not os.path.isdir(dirpwd+i): c.append(i.split(‘.‘)[-1]) return list(set(c))
习题三：
定义一个函数xulie(dirname,info) 参数：dirname:路径名，info:需要序列化的数据，功能：将info数据序列化存储到dirname路径下随机的文件里。
pickle json
import pickle,random def xulie(dirname,info): if not os.path.exists(dirname): return ‘Not found!‘ a = pickle.dumps(info) filename = ‘‘ for i in range(10): filename=filename+random.choice(‘abcedfghijklmnopqrstuvwxyzABCDEFGHIGKLMNOPQRSTUVWXYZ1234567890‘) filepath = os.path.join(dirname,filename) f = open(filepath,‘a+‘) f.write(a) f.close() a=[1,2,3,4,5,6,7] xulie(‘C:\Users\Administrator\Desktop‘,a)
异常1.1
习题：
1 定义一个函数func(filename) filename:文件的路径，函数功能：打开文件，并且返回文件内容，最后关闭，用异常来处理可能发生的错误。
#coding:utf-8 def open_file(filename): try: f=open(filename) return f.read() except IOError: return "Open file Error" finally: if ‘data‘ in locals(): f.close() print open_file(‘ip.txt‘)
2 定义一个函数func(urllist) urllist:为URL的列表，例如：[‘http://xx.com‘,‘http://www.xx.com‘,‘http://www.xxx.com‘...]
函数功能：要求依次打开url，打印url对应的内容，如果有的url打不开，则把url记录到日志文件里，并且跳过继续访问下个url。
def get_url(url_list): for url in url_list: try: print url date=urllib.urlopen(url) #return date.read() print date.read() except: file_txt=open(‘error.txt‘,‘a+‘) file_txt.write(str(date.getcode())+‘Error\n‘) return ‘Error‘ print get_url([‘http://www.baidu.com‘,‘http://www.qq.com‘,‘http://www.xxx.com‘,‘www.qq.com‘])
3 定义一个函数func(domainlist) domainlist:为域名列表，例如：[‘xx.com‘,‘www.xx.com‘,‘www.xxx.com‘...]
函数功能：要求依次ping 域名，如果ping 域名返回结果为：request time out，则把域名记录到日志文件里，并且跳过继续ping下个域名。（提示用os模块的相关方法）
异常处理1.3习题：
一 编写with操作类Fileinfo()，定义__enter__和__exit__方法。完成功能：
1.1 在__enter__方法里打开Fileinfo(filename)，并且返回filename对应的内容。如果文件不存在等情况，需要捕获异常。
1.2 在__enter__方法里记录文件打开的当前日期和文件名。并且把记录的信息保持为log.txt。内容格式："2014-4-5 xxx.txt"
二：用异常方法，处理下面需求：
info = [‘http://xxx.com‘,‘http:///xxx.com‘,‘http://xxxx.cm‘....]任意多的网址
2.1 定义一个方法get_page(listindex) listindex为下标的索引，类型为整数。 函数调用：任意输入一个整数，返回列表下标对应URL的内容，用try except 分别捕获列表下标越界和url 404 not found 的情况。
2.2 用logging模块把404的url，记录到当前目录下的urlog.txt。urlog.txt的格式为：2013-04-05 15:50:03,625 ERROR http://wwwx.com 404 not foud、
三：定义一个方法get_urlcontent(url)。返回url对应内容。
要求：
1自己定义一个异常类，捕获URL格式不正确的情况，并且用logging模块记录错误信息。
2 用内置的异常对象捕获url 404 not found的情况。并且print ‘url is not found‘
模块：
习题一：
1.1 用time模块获取当前的时间戳.
time.asctime()
1.2 用datetime获取当前的日期，例如：2013-03-29
1.3 用datetime返回一个月前的日期：比如今天是2013-3-29 一个月前的话：2013-02-27
习题二:
1 用os模块的方法完成ping www.baidu.com 操作。
2 定义一个函数kouzhang(dirpwd)，用os模块的相关方法，返回一个列表，列表包括：dirpwd路径下所有文件不重复的扩展名，如果有2个".py"的扩展名，则返回一个".py"。
习题三：
定义一个函数xulie(dirname,info) 参数：dirname:路径名，info:需要序列化的数据，功能：将info数据序列化存储到dirname路径下随机的文件里。
标签：
原文地址：http://www.cnblogs.com/landhu/p/4959488.html
