python 笔记 （第二周）
1. 输入一个数值 n （未知位数），将该数各位数倒序输出？
2. 字典调用
当许多个字典在同一个列表中时，需要找到某个value所对应的字典，先通过for遍历找到列表中的dict，当找到 dict[‘key’] = value,此时就已经调用到想要的dict。
3. 字典key
当a[ i ]中的key 不带“ ’ ’ ” 时，key不再是字符，而是一个变量。
4. return使用
如在使用自定义函数def时，当你需要使用到def产生的数字x时，则 return x，如函数只是为公式方法，则不用返回值并可以不填参数值。
...
a = []
while True:
n = str (input("shuru :"))
if n == 'quit':
break
else:
a.append(n)
def f1(i):
n = i[0].upper()+i[1:].lower()
return n
b = list(map(f1,a))
print(b)
...
#### 5. map函数使用
map(function, iterable, ...) 根据提供的函数对指定序列做映射
function为 所用的函数
iterable为 使用的序列
例1：
```python
>>>def square(x) : # 计算平方数
... return x ** 2
...
>>> map(square, [1,2,3,4,5]) # 计算列表各个元素的平方
[1, 4, 9, 16, 25]
>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5]) # 使用 lambda 匿名函数
[1, 4, 9, 16, 25]
#提供了两个列表，对相同位置的列表数据进行相加
>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
[3, 7, 11, 15, 19]
例2: 利用map()函数，把用户输入的不规范的英文名字，变为首字母大写，其他小写的规范名字。例如输入：[‘adam’, ‘LISA’, ‘barT’]，输出：[‘Adam’, ‘Lisa’, ‘Bart’]
a = []
while True:
n = str (input("shuru :"))
if n == 'quit':
break
else:
a.append(n)
def f1(i):
n = i[0].upper()+i[1:].lower()
return n
b = list(map(f1,a))
print(b)
结果
shuru :asasd
shuru :adasd
shuru :wqeqre
shuru :wr
shuru :ewr
shuru :quit
['Asasd', 'Adasd', 'Wqeqre', 'Wr', 'Ewr']
6. filter() 函数使用
filter(function, iterable)
用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象
该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
例1：
def is_odd(n):
return n % 2 == 1
tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
newlist = list(tmplist)
print(newlist)
结果 [1, 3, 5, 7, 9]
例2：请尝试用filter()删除1~30的素数
def f2(x):
flag = 0
if (x<2):
flag = 1
for n in range(2,x):
if x % n == 0:
flag = 1
break
if flag == 1:
return x
print(list(filter(f2,range(1,30))))
结果 [1, 4, 6, 8, 9, 10, 12, 14, 15, 16, 18, 20, 21, 22, 24, 25, 26, 27, 28]
#### 7.reduce函数使用
reduce(function, iterable[, initializer])
用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到结果再与第三个数据用 function 函数运算.
```PYTHON
例1;
from functools import reduce
def add(x, y) : # 两数相加
return x + y
print（reduce(add, [1,2,3,4,5])) # 计算列表和：1+2+3+4+5
print(reduce(lambda x, y: x+y, [1,2,3,4,5]) ) # 使用 lambda 匿名函数
例2: Python提供的sum()函数可以接受一个list并求和，请编写一个prod()函数，可以接受一个list并利用reduce()求积.
from functools import reduce
print(reduce(lambda x,y: x+y,[1,2,3,4,5]))
结果 15
8. 文件file
关于****open 模式：
w以写方式打开，如果没有则会创建，有则覆盖。
a 以追加模式打开 (从 EOF 开始, 必要时创建新文件)，没有则创建
r+ 以读写模式打开
w+ 以读写模式打开 (参见 w )
a+ 以读写模式打开 (参见 a )
rb 以二进制读模式打开
wb 以二进制写模式打开 (参见 w )
ab 以二进制追加模式打开 (参见 a )
rb+ 以二进制读写模式打开 (参见 r+ )
wb+ 以二进制读写模式打开 (参见 w+ )
ab+ 以二进制读写模式打开 (参见 a+ )
内建函数
fp.read([size]) #size为读取的长度，以byte为单位
fp.readline([size]) #读一行，如果定义了size，有可能返回的只是一行的一部分 ,如果超过，则返回一行到\n
fp.readlines([size]) #把文件每一行作为一个list的一个成员，并返回这个list。其实它的内部是通过循环调用readline()来实现的。如果提供size参数，size是表示读取内容的总长，也就是说可能只读到文件的一部分。
fp.write(str) #把str写到文件中，write()并不会在str后加上一个换行符
fp.writelines(seq) #把seq的内容全部写到文件中(多行一次性写入)。这个函数也只是忠实地写入，不会在每行后面加上任何东西。
fp.close() #关闭文件。python会在一个文件不用后自动关闭文件，不过这一功能没有保证，最好还是养成自己关闭的习惯。如果一个文件在关闭后还对其进行操作会产生ValueError
fp.flush() #把缓冲区的内容写入硬盘
fp.fileno() #返回一个长整型的”文件标签“
fp.isatty() #文件是否是一个终端设备文件（unix系统中的）
fp.tell() #返回文件操作标记的当前位置，以文件的开头为原点
fp.next() #返回下一行，并将文件操作标记位移到下一行。把一个file用于for … in file这样的语句时，就是调用next()函数来实现遍历的。
fp.seek(offset[,whence]) #将文件打操作标记移到offset的位置。这个offset一般是相对于文件的开头来计算的，一般为正数。但如果提供了whence参数就不一定了，whence可以为0表示从头开始计算，1表示以当前位置为原点计算。2表示以文件末尾为原点进行计算。需要注意，如果文件以a或a+的模式打开，每次进行写操作时，文件操作标记会自动返回到文件末尾。
fp.truncate([size]) #把文件裁成规定的大小，默认的是裁到当前文件操作标记的位置。如果size比文件的大小还要大，依据系统的不同可能是不改变文件，也可能是用0把文件补到相应的大小，也可能是以一些随机的内容加上去。
例1：
import codecs # 使用file函数必须引用模块
l = [1,5,8,4,2,3]
l.sort()
with codecs.open("1.txt","w") as fd: # 打开1.txt，如果没有就新建
for i in l:
fd.write(str(i)) # 将l中的数据写入1.txt
fd.write("\n")
l1 = [] # 处理数据必须在写入文件之前，将l的数据排序在再倒序
l = [1,5,8,4,2,3]
l.sort()
l.reverse()
with codecs.open("1.txt","a") as fd: # “a” 追加模式打开文件
for i in l:
l1.append(i)
fd.write(str(i))
li = ['a','b','c']
with codecs.open("1.txt","a") as fd:
fd.write('\n')
for i in li:
fd.write(str(i))
li = [1,2,3]
with codecs.open('1.txt','a') as fd:
fd.write('\n')
for i in li:
fd.write(str(i))
tu = ('one','two','three')
with codecs.open('1.txt','a') as fd:
fd.write('\n')
for i in tu:
fd.write(i)
dic = {1:'a',2:'b'}
with codecs.open('1.txt','a') as fd:
for line in dic.items():
fd.write('\n')
for i in line:
fd.write(str(i))
f = open("1.txt")
for line in f:
print(line)
例2：
import codecs
with open("130.txt","r") as f: # 打开130.txt文件，并阅读内容
... print f.read()
例3：
import codecs
f = open("you.md")
f.readline()
显示出一行一行读取了，每操作一次 f.readline()，就读取一行，并且将指针向下移动一行，如此循环。显然，这种是一种循环，或者说可迭代的。因此，就可以用循环语句来完成对全文的读取。
例4：
while True:
line = f.readline()
if not line: #到 EOF，返回空字符串，则终止循环
break
print line , #注意后面的逗号，去掉 print 语句后面的 '\n'，保留原文件中的换行
f.close() #别忘记关闭文件
输出：
You Raise Me Up
When I am down and, oh my soul, so weary;
When troubles come and my heart burdened be;
Then, I am still and wait here in the silence,
Until you come and sit awhile with me.
You raise me up, so I can stand on mountains;
You raise me up, to walk on stormy seas;
I am strong, when I am on your shoulders;
You raise me up: To more than I can be.
例5：
f = open("you.md")
f.readline()
#'You Raise Me Up\n' # 显示第一行
f.readline()
#'When I am down and, oh my soul, so weary;\n' # 显示第二行
f.seek(0) # 当执行此句时指针移动到第一个字节
f.readline() # 回到第一行
>>> f.tell() # 显示指针位置
17L
>>> f.seek(4) # 指针移动到第4个字节，也就是"You "之后，字母"R"之前的位置。tell()也是这么说的。这时候如果使用 readline()，得到就是从当前位置开始到行末。
>>> f.tell()
4L
9.正则表达式
1. 用\d可以匹配一个数字，\w可以匹配一个字母，
2. 要匹配变长的字符，在正则表达式中，用*表示任意个字符（包括0个），用+表示至少一个字符，用?表示0个或1个字符，用{n}表示n个字符，用{n,m}表示n-m个字符：来看一个复杂的例子：\d{3}\s+\d{3,8}。
3. \s可以匹配一个空格（也包括Tab等空白符），所以\s+表示至少有一个空格，例如匹配’ ‘，’ '等，“-”可以用“ \- ”
转义。
-
要做更精确地匹配，可以用[]表示范围，比如：[0-9a-zA-Z_]可以匹配一个数字、字母或者下划线。
-
在pyhon中，正则表达式需要调用 re 模块。
\
>>> **import** re >>> re.match(r'^\d{3}\-\d{3,8}$', '010-12345') <_sre.SRE_Match object at 0x1026e18b8> >>> re.match(r'^\d{3}\-\d{3,8}$', '010 12345') >>> -
切分字符串
用正则表达式切分字符串比用固定的字符更灵活
>>> 'a b c'.split(' ') ['a', 'b', '', '', 'c'] -
由于\d+采用贪婪匹配，直接把后面的0全部匹配了，结果0*只能匹配空字符串了。
必须让\d+采用非贪婪匹配（也就是尽可能少匹配），才能把后面的0匹配出来，加个?就可以让\d+采用非贪婪匹配：
re.match(r’^(\d+?)(0*)$’, ‘102300’).groups()
(‘1023’, ‘00’正则表达式练习
1、求非负整数 (Tips:需要注意的是这个匹配模式为多行模式下进行的)
1[0-9]|0
2、匹配正整数
^ [1-9][0-9]*
3、非正整数
^-[1-9][0-9]|0
4、负整数
^-[1-9][0-9]*
5、整数
^ [1-9][0-9]|-[1-9][0-9]|0
6、非负浮点数
^ [1-9][0-9]*(.\d+)|0((.\d+))
7、正浮点数
^ [1-9][0-9]*(.\d+)|0((.\d+))
8、非正浮点数
^-[1-9][0-9]*(.\d+)|-0((.\d+))|0
9、负浮点数
^-[1-9][0-9]*(.\d+)|-0((.\d+))
10、浮点数
^-[1-9][0-9](.\d+)|-0((.\d+))|[1-9][0-9](.\d+)|-0((.\d+))
11、有数字、26个英文字母组成的字符串
2+
中级练习
1、长度为8-10的用户密码（以字母开头、数字、下划线）
3{1}[a-zA-Z0-9_]{7,9}
2、验证输入只能是汉字
4+
3、电子邮箱验证
5+@[a-zA-Z]+.[a-zA-Z]+
4、URL地址验证
6+://[a-zA-Z]+.[a-zA-Z0-9]+.[a-zA-Z]+
5、电话号码的验证
^\d{4}-\d{7}|\d{3}-\d{8}$
6、简单的身份证号验证
^\d{18}|\d{17}[x]{1}$
10. 错误与异常
即便Python程序的语法是正确的，在运行它的时候，也有可能发生错误。运行期检测到的错误被称为异常。
try语句按照如下方式工作；
-
首先，执行try子句（在关键字try和关键字except之间的语句）
-
如果没有异常发生，忽略except子句，try子句执行后结束。
-
如果在执行try子句的过程中发生了异常，那么try子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符，那么对应的except子句将被执行。最后执行 try 语句之后的代码。
-
如果一个异常没有与任何的except匹配，那么这个异常将会传递给上层的try中。一个 try 语句可能包含多个except子句，分别来处理不同的特定的异常。最多只有一个分支会被执行。处理程序将只针对对应的try子句中的异常进行处理，而不是其他的 try 的处理程序中的异常。一个except子句可以同时处理多个异常，这些异常将被放在一个括号里成为一个元组。
例如：
import sys
try:
f = open('myfile.txt')
s = f.readline()
i = int(s.strip())
except OSError as err:
print("OS error: {0}".format(err))
except ValueError:
print("Could not convert data to an integer.")
except:
print("Unexpected error:", sys.exc_info()[0])
raise
try except 语句还有一个可选的else子句，如果使用这个子句，那么必须放在所有的except子句之后。这个子句将在try子句没有发生任何异常的时候执行。例如:
for arg in sys.argv[1:]:
try:
f = open(arg, 'r')
except IOError:
print('cannot open', arg)
else:
print(arg, 'has', len(f.readlines()), 'lines')
f.close()
抛出异常
使用raise 语句抛出一个指定的异常。例如：
>>> raise NameError('HiThere')
Traceback (most recent call last):
File "<stdin>", line 1, in ?
NameError: HiThere
raise 唯一的一个参数指定了要被抛出的异常。它必须是一个异常的实例或者是异常的类（也就是 Exception 的子类）。
如果你只想知道这是否抛出了一个异常，并不想去处理它，那么一个简单的 raise 语句就可以再次把它抛出。
>>> try:
raise NameError('HiThere')
except NameError:
print('An exception flew by!')
raise
An exception flew by!
Traceback (most recent call last):
File "<stdin>", line 2, in ?
NameError: HiThere
11. 面向对象
在Python中，所有数据类型都可以视为对象，当然也可以自定义对象。自定义的对象数据类型就是面向对象中的类（Class）的概念。
面向对象最重要的概念就是类（Class）和实例（Instance），必须牢记类是抽象的模板，比如Student类，而实例是根据类创建出来的一个个具体的“对象”，每个对象都拥有相同的方法，但各自的数据可能不同。
class Student(object):
pass
class后面紧接着是类名，即Student，类名通常是大写开头的单词，紧接着是(object)，表示该类是从哪个类继承下来的，继承的概念我们后面再讲，通常，如果没有合适的继承类，就使用object类，这是所有类最终都会继承的类。
定义好了Student类，就可以根据Student类创建出Student的实例，创建实例是通过类名+()实现的：
>>> bart = Student()
>>> bart
<__main__.Student object at 0x10a67a590>
>>> Student
<class '__main__.Student'>
由于类可以起到模板的作用，因此，可以在创建实例的时候，把一些我们认为必须绑定的属性强制填写进去。通过定义一个特殊的__init__方法，在创建实例的时候，就把name，score等属性绑上去：
class Student(object):
def __init__(self, name, score):
self.name = name
self.score = score
注意到__init__方法的第一个参数永远是self，表示创建的实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。
有了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不需要传，Python解释器自己会把实例变量传进去：
例1：
class Account:
def __init__(self, number, name):
self.number = number
self.name = name
self.balance = 0
def deposit(self, amount):
if amount <= 0:
raise ValueError('must be positive')
self.balance += amount
def withdraw(self, amount):
if amount <= self.balance:
self.balance -= amount
else:
raise RuntimeError('balance not enough')
练习：
1.封装一个学生类，有姓名，有年龄，有性别，有英语成绩，数学成绩，语文成绩，封装方法，求总分，平均分，以及打印学生的信息。
对象：学生
类：学生（student）
属性：姓名（name）
年龄（age）
性别（gender）
英语成绩（English—achievements）
数学成绩（mathematics）
语文成绩（chinese-achievement-test）
成绩：总成绩（total points）
平均成绩
class Student:
def __init__(self):
name = None
age = None
gender = None
English_achievements = None
mathematics = None
chinese_achievements = None
def sum(self):
print('姓名：%s 年龄：%s 年级：%s 英语成绩：%s 数学成绩 ：%s 语文成绩： %s 总分：%s 平均分：%s'%(m.name,m.age,m.gender,m.English_achievements,m.mathematics,m.chinese_achievements,(m.English_achievements+m.mathematics+m.chinese_achievements),((m.mathematics+m.chinese_achievements+m.English_achievements)/3)))
m = Student()
m.name = str(input("name"))
m.age = int(input("age"))
m.gender = str(input("sex"))
m.English_achievements= int(input("eng"))
m.mathematics = int(input("math"))
m.chinese_achievements = int(input("chi"))
m.sum()
2.创建一个Cat类，属性:姓名，年龄 方法：抓老鼠
创建老鼠类，属性：姓名，型号。
一只猫抓一只老鼠，再创建一个测试类：创建一个猫对象，再创建一个老鼠对象，打印观察猫抓的老鼠的姓名和型号。
例如：一个5岁的名叫tom的猫抓到了一只名叫jerry的小老鼠。
class Cat:
def init(self):
name=None
age=None
class Mouse:
def init(self):
name=None
model=None
class Test:
def Catch_a_Mouse(self):
print(‘一个%s岁的名叫%s的猫抓到了一个名叫%s的小老鼠’%(cat.age,cat.name,mouse.name))
cat=Cat()
cat.name=‘tom’
cat.age=5
mouse=Mouse()
mouse.name=‘jerry’
mouse.module=1
test=Test()
test.Catch_a_Mouse()
3.学生应该有姓名(name)、年龄(age)、性别(sex)，班级号(classNum)，座位号(sno)。
提供一个方法(displayInfo())用来显示这个学生的姓名、年龄、性别、所在的班级和他的座位号。
在测试模块中创建两个学生对象，分别调用displayInfo()方法显示各自的信息。
class Student:
def init(self):
name=None
age=None
sex=None
classNum=None
sno=None
def displayInfo(self):
print(‘姓名:%s,年龄%s,性别%s，班级号%s，座位号%s’%(student.name,student.age,student.sex,student.classNum,student.sno))
student=Student()
student.name=“张三”
student.age=15
student.sex=“男”
student.classNum=‘python1805’
student.sno=18
student.displayInfo()
student=Student()
student.name=“李四”
student.age=16
student.sex=“男”
student.classNum=‘python1805’
student.sno=19
student.displayInfo()
4.定义一“圆”Cirlcle类，圆心为“点”Point类，构造一圆，求圆的周长和面积，并判断某点与圆的关系。
点类:X y
圆类:
圆心点和半径
class Circle:
def __init__(self):
center_point = None
r = None
def displayinfo(self):
print('半径为%s 的 圆周长为 %s ，面积为 %s ' %(a.r,(2*3.1415*a.r),(3.1415*a.r*a.r)))
class Point:
def __init__(self):
r = None
x = None
y = None
def ju(self):
if (b.x**2+b.y**2)**0.5 > b.r:
print("在圆外")
elif (b.x**2+b.y**2)**0.5 == b.r:
print("在圆上")
else:
print("在圆外")
a = Circle()
a.r = int(input("输入半径："))
a.displayinfo()
b = Point()
b.r = int(input("输入半径："))
b.x = int(input("输入x坐标："))
b.y = int(input("输入y坐标："))
b.ju()
注意：
1. 在建立类时，在__init__中可以不添加属性，之后可将属性赋值为None。
2. 由于建立的实例将将调用上述参数如“ a.r, b.r, b.x, b.y”,可直接在函数中定义。
3. 使用函数时，根据”Circle“， ”Point“ 类创建实例“ a , b “,，通过input将函数内参数赋值，最后调用类中的函数。
285
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
