小甲鱼python学习笔记

http://fishc.com/
高级语言要编译成汇编语言才能被机器，然后再转换成二进制文件才能被机器所理解
idle
window
alt+n 上一条命令
alt+p 下一条命令
苹果mac
ctrl+n 上一条命令
ctrl+p 下一条命令


语法
2.X版本
print "字符串"
3.X版本
print ("字符串")


算数
1.>>>print(1+1)
2.>>>1+1


字符串拼接
print ("字符串A"+"字符串B")


字符串打印
print("字符串或者值"*8) #连着打印8次
print("字符串或者值\n"*8) #连着打印8行字符串，\n是回车转义符
print(变量或者值,end='\n') #在变量或者值后面加换行
print(变量或者值,end=' ') #在变量或者值后面加空格打印
print(变量或者值,len(变量或者值)) #在变量或者值后面加该在变量或者值后面加的长度
字符串可以用单引号括住，也可以用双引号括住，但是必须是成对出现
想要打印  '  可以通过 \ 转义符  写成  \'
\转义符可以对自己进行转义，想要打印\n，可以写成\\n，或者是
python print格式化输出。
1. 打印字符串
print ("His name is %s"%("Aviad"))  #相当于把第二个%后面的字符串给前面%打印出来
print ("His name is %s %s"%("Aviad",'Lucy'))
2.打印整数
print ("He is %d years old"%(25))  #相当于把第二个%后面的数字给前面%打印出来
3.打印浮点数
print ("His height is %f m"%(1.83))  #相当于把第二个%后面的浮点数字给前面%打印出来，保留6位小数
4.打印浮点数（指定保留小数点位数）
print ("His height is %.2f m"%(1.83))  #相当于把第二个%后面的浮点数字格式化成两位小数给前面%打印出来
5.指定占位符宽度
print ("Name:%10s Age:%8d Height:%8.2f"%("Aviad",25,1.83))  #%后面的那个数字是占位符，打印的字符和后面%传进来的值中间的位置宽度
6.指定占位符宽度（左对齐）
print ("Name:%-10s Age:%-8d Height:%-8.2f"%("Aviad",25,1.83))  #%后面的那个数字是占位符，打印的字符和后面%传进来的值后面的位置宽度
7.指定占位符（只能用0当占位符？）
print ("Name:%-10s Age:%08d Height:%08.2f"%("Aviad",25,1.83))  #%后面的那个数字是占位符，打印的字符和后面%传进来的值中间的位置宽度，前面的0是表示用0填充这个位置宽度
8.科学计数法
format(0.0015,'.2e')  #格式化成科学计数法，保留以为正整数
>>>str = r'c:\now'  #最后的字符不能是\
>>>str
c:\\now
>>>print(str)
c:\now
>>>str = """测试回车
我是回车
我是回车"""
>>>str
测试回车\n我是回车\n我是回车
>>>print(str)
>>>
测试回车
我是回车
我是回车


print('----------我爱鱼C工作室------------')
temp = input("不妨猜一下小甲鱼现在心里像的是那个数字:")  #这里接受的默认是字符串类型
guess = int(temp)
if guess == 8:
print("我草，你是小甲鱼心里的蛔虫吗？！")
print("哼，猜中了也没有奖励！")
else:
print("猜错拉，小甲鱼心里想的是8！")
print("游戏结束，不玩啦")


input也有显示字符串功能
int(变量)  格式化变量为int格式


BIF == built-in functions
dir(--builtins--)  #打印当前所有的BIF，小写的才是BIF
 #查看BIF中的input功能和语法


变量(variable)
命名规则跟C语言一样，可以包含字母、数字、下划线，但是不能以数字开头
变量名区分大小写,Flase和flase不一样，True和true不一样 bool类型只有Flase,True
>>>first = 3
>>>second = 8
>>>third = first + second
>>>pint(third)
11
>>>char1 = '我的老师是：'
>>>char2 = '小甲鱼'
>>>teacher = char1 + char2
>>>print(teacher)
我的老师是：小甲鱼


条件判断
>   大于
>=  大于或者是等于
< 小于
<= 小于或者是等于
== 等于
!= 不等于


print('----------我爱鱼C工作室------------')
temp = input("不妨猜一下小甲鱼现在心里像的是那个数字:")
guess = int(temp)
while guess ！= 8：
if guess == 8:
print("我草，你是小甲鱼心里的蛔虫吗？！")
print("哼，猜中了也没有奖励！")
else:
if guess > 8:
print("大了")
else:
print('小了')
print("游戏结束，不玩啦")


浮点型：有小数点的数值
E记法：用来表示特别大或者是特别小的数值 
>>> a = 0.000005
>>> a
5e-06
>>> a = 0.00000000005
>>> a
5e-11
>>> 1.5e10
15000000000.0


int(A)  #把A转换成int类型
str(A)  #把A转换成string类型
float(A)#把A转换成float类型
type(A) #显示A的类型
isinstance(A, X) #判断值A或者是变量A是否是X类型，返回bool类型（Ture,Flase）
优先级
1.幂运算 **
2.正负号 + -
3.算术操作符 * / // + -
4.比较操作符 < <= > >= == !=
5.逻辑运算符 not and or


>>> a = 1.6
>>> c = int(a)  #这个会直接截断小数位
>>> c
1


>>> a = 12
>>> b = float(a)  #把a转换成float类型
>>> b
12.0


>>> str = 11
>>> c = str(11)  #相当于把str重新赋值，修改了原来str的BIF功能
'11'


>>> type(11)
<class 'int'>


>>> a = '字符串'
>>> isinstance(a, str)  #判断a变量是否是str类型，返回bool类型
True 
>>> type(isinstance(a, str))  #功能嵌套
<class 'bool'>


>>> a = 5
>>> a = a + 3
>>> a
8
>>> a = 5
>>> a += 3   #和a = a + 3功能一样
>>> a
8


>>> a = b = c = d = e = 10  #多变量赋值
>>> a
10
>>> b
10
>>> c
10
>>> d
10
>>> e
10


>>> 10/8  #除法
1.25
>>> 10.1//8  #求除数，结果按除数类型保留
1.0
>>> 10%8  #求余数
2
>>> 3 ** 2  #求3的2次幂
9


>>> -3 * 2 + 5 / -2 - 4  #和((-3) * 2) + (5 / (-2)) - 4等价
-12.5
>>> ((-3) * 2) + (5 / (-2)) - 4
-12.5
>>> -3 ** 2
-9


>>> not True
False
>>> not False
True
>>> not 0  #0在python里面解释为False
True
>>> not 1  #0在python里面解释为True
False
>>> 3 < 4 < 5  #和3 < 4 and 4 < 5功能一样
True


悬挂else
C语言中出现的悬挂else
hi = 9
if ( hi > 2 )
if (hi > 7 )
printf( "好棒! 好棒！" );
else
printf( "切~" );
python中不会出现悬挂else
hi = 9
if ( hi > 2 ):
if (hi > 7 ):
print( "好棒! 好棒！" )
else:
print( "切~" )



三元操作符
x, y = 4, 5
if x < y:
    small = x
else:
    small = y
和下面的功能一样
small = x if x < y else y


assert #断言，用于异常捕获，当assert后面的语句为假的时候程序自动崩溃并抛出AssertionError的异常，跟存储过程的exception差不多
>>> assert 3 > 4
Traceback (most recent call last):
  File "<pyshell#78>", line 1, in <module>
    assert 3 > 4
AssertionError


while循环
while 条件:
循环体


for 循环
for 目标 in 表达式:
循环体


range()
range( [strat,] stop[, step=1] )
#这个BIF有三个参数，其中用中括号括起来的两个表示这两个参数是可选的
#stop=1表示第三个参数的值默认是1
#range这个BIF的作用是生成一个从start参数的值开始到stop参数的值结束的数字序列
>>> for i in range(5):
print(i)


0
1
2
3
4
>>> for i in range(1,5):
print(i)


1
2
3
4
>>> for i in range(1,10,2):
print(i)



1
3
5
7
9


break和continue


bingo = '小甲鱼是帅哥'
answer = input('请输入小甲鱼是最想听的一句话：')
while True:
        if answer == bingo:
                break
        answer = input ('抱歉，错了，请重新输入（答案正确才能退出游戏）：')
print('呀哟，帅哦~')
print('您真是小甲鱼肚子里的蛔虫啊^_^')


for i in range(10):
        if i%2 != 0:
                print(i)
                continue
        i += 2
        print(i)


列表
普通列表
aa = [1,2,3,4,5]
混合列表
bb = [1,2,3,3.14,'字符串',[7,8]]
空列表


len(aa)  #求列表aa的长度
aa.append(6)  #向列表aa后面追加加6，只能添加一个
aa.extend([7,8])  #用列表[7,8]扩展列表aa
aa.insert(0,1)  #向列表aa的第0个位置插入1
aa.remove(7)  #把元素7从列表aa中删除，不需要知道这个元素在那个位置，如果有多个相同的元素，会按从左到由的顺序删除
del aa(1)  #删除列表aa第一个位置的元素
del aa  #删除整个列表aa
aa.pop(1) #把列表aa位置为1的元素删除并打印出来，也可以赋值给变量
aa.count(1)  #统计出列表aa里面有几个1
aa.index(1)   #把1在列表aa中那个位置打印出来
aa.index(1,3,7)  #只看在列表aa中第3个位置到第7个位置的1在列表中的位置打印出来
aa.reverse()  #把列表aa的所有元素位置顺序颠倒
aa.sort(func,key,reverse)  #整理列表aa的顺序排序,方法不带参数表示只默认从小到大排序整理，func,key暂时不管，reverse=True从大到小,
#reverse=False从小到大(默认)
dir(aa)  #把列表aa所有的方法都打印出来
以上对列表操作，不指定位置，都是操作最后面的位置的元素，列表有那些操作方法，可以通过aa.提示出来所有的方法范围




>>> aa = [1, 2, 3, 4, 5, 6]
>>> bb = [7,8]
>>> aa.append(bb)
>>> aa
[1, 2, 3, 4, 5, 6, [7, 8]]


修改列表的顺序
>>> aa = [1, 2, 3, 4, 5, 6]
>>> aa[0]
1
>>> aa[1]
2
>>> temp = aa[0]
>>> aa[0] = aa[1]
>>> aa[1] = temp
>>> aa
[2, 1, 3, 4, 5, 6]


列表分片Slice
aa = [1, 2, 3, 4, 5, 6]
>>> aa[1:3]  #不包含第三个位置的元素，两个参数中的第一个不写默认从0开始，第二不写默认是默认到结尾，两个不写默认整个列表
[2, 3]


列表常用操作符
比较操作符
逻辑操作符
连接操作符
重复操作符
成员关系操作符


aa = [123,456]
>>> bb = [234,123]
>>> aa > bb  #从第一个元素的第一个字符开始比较，如果为真直接返回True，如果为假直接返回False
False


>>> aa = [123,456]
>>> bb = [234,123]
>>> cc = aa + bb  两个变量对象必须是一直，列表不能直接加元素
>>> cc
[123, 456, 234, 123]


>>> aa = [123, 456]
>>> aa * 2   #不会改表列表aa的内容
[123, 456, 123, 456]
>>> aa *= 2  #相当于aa = aa + aa
>>> aa
[123, 456, 123, 456]
>>> 


>>> aa = [123, 456, 123, 456]
>>> 123 in aa
True
>>> 234 in aa
False
>>> 234 not in aa
True
>>> aa = [123, 456, [789, 000]]
>>> 789 in aa  #只能判断一层的元素
False
>>> 789 in aa[2]
True
>>> aa[2][0]  #指的列表aa的第2个位置的元素的列表[789, 000]的第0个元素
789


>>> aa = [2,1,4,5,3,7,6]
>>> bb = aa[:]  #相当于拷贝了一个列表
>>> cc = aa #列表cc相当于aa的一个快捷方式，仅仅是指向的作用，aa改变，cc也会跟着改变
>>> bb
[2, 1, 4, 5, 3, 7, 6]
>>> cc
[2, 1, 4, 5, 3, 7, 6]
>>> aa.sort()
>>> bb
[2, 1, 4, 5, 3, 7, 6]
>>> cc
[1, 2, 3, 4, 5, 6, 7]


元组
1.创建元组使用小括号并且带逗号，空元组直接是()，只有一个元素的时候如(1,)，列表使用中括号
2.元组里面的元素不能直接修改，可以通过切片方法实现，其他的操作跟列表一样，有点类似字符串的属性（比较片面的说法）


>>> temp = (1)
>>> temp
1
>>> type(temp)
<class 'int'>
>>> temp = 1,2,3,4
>>> temp
(1, 2, 3, 4)
>>> type(temp)
<class 'tuple'>
>>> temp = (1,)
>>> type
<class 'type'>
>>> type(temp)
<class 'tuple'>




>>> aa = (1,2,3,5,6)
>>> aa = aa[:3] + (4,) + aa[3:]  #注意元素端点问题，含头不含尾
>>> aa
(1, 2, 3, 4, 5, 6)


内置方法
对字符串进行切片
>>> str1 = 'i love fishc.com'
>>> str1[:6]
'i love'


capitalize() 把字符串的第一个字符改为大写
casefold() 把整个字符串的所有字符改为小写
center(width) 将字符串居中，并使用空格填充至长度 width 的新字符串
count(sub[, start[, end]]) 返回 sub 在字符串里边出现的次数，start 和 end 参数表示范围，可选。
encode(encoding='utf-8', errors='strict') 以 encoding 指定的编码格式对字符串进行编码。
endswith(sub[, start[, end]]) 检查字符串是否以 sub 子字符串结束，如果是返回 True，否则返回 False。start 和 end 参数表示范围，可选。
expandtabs([tabsize=8]) 把字符串中的 tab 符号（\t）转换为空格，如不指定参数，默认的空格数是 tabsize=8。
find(sub[, start[, end]]) 检测 sub 是否包含在字符串中，如果有则返回索引值，否则返回 -1，start 和 end 参数表示范围，可选。
index(sub[, start[, end]]) 跟 find 方法一样，不过如果 sub 不在 string 中会产生一个异常。
isalnum() 如果字符串至少有一个字符并且所有字符都是字母或数字则返回 True，否则返回 False。
isalpha() 如果字符串至少有一个字符并且所有字符都是字母则返回 True，否则返回 False。
isdecimal() 如果字符串只包含十进制数字则返回 True，否则返回 False。
isdigit() 如果字符串只包含数字则返回 True，否则返回 False。
islower() 如果字符串中至少包含一个区分大小写的字符，并且这些字符都是小写，则返回 True，否则返回 False。
isnumeric() 如果字符串中只包含数字字符，则返回 True，否则返回 False。
isspace() 如果字符串中只包含空格，则返回 True，否则返回 False。
istitle() 如果字符串是标题化（所有的单词都是以大写开始，其余字母均小写），则返回 True，否则返回 False。
isupper() 如果字符串中至少包含一个区分大小写的字符，并且这些字符都是大写，则返回 True，否则返回 False。
join(sub) 以字符串作为分隔符，插入到 sub 中所有的字符之间。
ljust(width) 返回一个左对齐的字符串，并使用空格填充至长度为 width 的新字符串。
lower() 转换字符串中所有大写字符为小写。
lstrip() 去掉字符串左边的所有空格
partition(sub) 找到子字符串 sub，把字符串分成一个 3 元组 (pre_sub, sub, fol_sub)，如果字符串中不包含 sub 则返回 ('原字符串', '', '')
replace(old, new[, count]) 把字符串中的 old 子字符串替换成 new 子字符串，如果 count 指定，则替换不超过 count 次。
rfind(sub[, start[, end]]) 类似于 find() 方法，不过是从右边开始查找。
rindex(sub[, start[, end]]) 类似于 index() 方法，不过是从右边开始。
rjust(width) 返回一个右对齐的字符串，并使用空格填充至长度为 width 的新字符串。
rpartition(sub) 类似于 partition() 方法，不过是从右边开始查找。
rstrip() 删除字符串末尾的空格。
split(sep=None, maxsplit=-1) 不带参数默认是以空格为分隔符切片字符串，如果 maxsplit 参数有设置，则仅分隔 maxsplit 个子字符串，
返回切片后的子字符串拼接的列表。
splitlines(([keepends])) 按照 '\n' 分隔，返回一个包含各行作为元素的列表，如果 keepends 参数指定，则返回前 keepends 行。
startswith(prefix[, start[, end]]) 检查字符串是否以 prefix 开头，是则返回 True，否则返回 False。start 和 end 参数可以指定范围检查，可选。
strip([chars]) 删除字符串前边和后边所有的空格，chars 参数可以定制删除的字符，可选。
swapcase() 翻转字符串中的大小写。
title() 返回标题化（所有的单词都是以大写开始，其余字母均小写）的字符串。
translate(table) 根据 table 的规则（可以由 str.maketrans('a', 'b') 定制）转换字符串中的字符。
upper() 转换字符串中的所有小写字符为大写。
zfill(width) 返回长度为 width 的字符串，原字符串右对齐，前边用 0 填充。




format()
>>> "{0} love {1},{2}".format("i","FishC","com")  #数字位置参数进行格式化
'i love FishC,com'
>>> "{a} love {b},{c}".format(a="i",b="FishC",c="com")  #关键字参数进行格式化
'i love FishC,com'
>>> "{0} love {b},{c}".format("i",b="FishC",c="com")  #数字位置参数，关键字参数格式化，要注意，数字参数必须要在关键字参数前面
'i love FishC,com'


转义符
\t  相当于tab键，制表符
>>> print('\ta')
a
>>> print('\\')
\
>>> "{{0}}".format("不打印")
'{0}'


浮点数：浮点数中小数点的位置是不固定的
定点数：定点数指小数点在数中的位置是固定不变的
>>> '{0:.1f}{1}'.format(27.658,'GB')  #:  在替换域中，格式化开始,:后面的.1是保留一位小数的意思，f是打印出来定点数，27.658是定点数
'27.7GB'


%c     格式化字符及其ASCII码
%s     格式化字符串
%d     格式化整数
%o     格式化无符号八进制数
%x     格式化无符号十六进制数
%X     格式化无符号十六进制数（大写）
%f     格式化定点数，可指定小数点后的精度
%e     用科学计数法格式化定点数
%E     作用同%e，用科学计数法格式化定点数
%g     根据值的大小决定使用%f活%e
%G     作用同%g，根据值的大小决定使用%f或者%E
m.n    m是显示的最小总宽度，n是小数点后的位数
-      用于左对齐
+      在正数前面显示加号（+）
#      在八进制数前面显示 '0o'，在十六进制数前面显示 '0x' 或 '0X'
0      显示的数字前面填充 '0' 取代空格
\'   单引号
\"   双引号
\a   发出系统响铃声
\b   退格符
\n   换行符
\t   横向制表符（TAB）
\v   纵向制表符
\r   回车符
\f   换页符
\o   八进制数代表的字符
\x   十六进制数代表的字符
\0   表示一个空字符
\\   反斜杠


>>> '%c' % 97
'a'
>>> '%c %c %c' % (97, 98, 98)
'a b b'


序列
列表，元组和字符串的共同点
都可以通过索引得到每一个元素
默认索引值都是从0开始
可以通过分片的方法得到一个范围内的元素的集合
有很多共同的操作符（重复操作符，拼接操作符，成员关系操作符）


迭代：重复反馈过程的活动，其目的通常是为了接近并达到所需的目标或结果，每一次对过程重复
>>> b = 'i love fishc.com'
>>> a = list(b)
>>> a
['i', ' ', 'l', 'o', 'v', 'e', ' ', 'f', 'i', 's', 'h', 'c', '.', 'c', 'o', 'm']


>>> c = (1,1,2,3,5,8,13,21,34)
>>> c = list(c)
>>> c
[1, 1, 2, 3, 5, 8, 13, 21, 34]


tuple([iterable])  #把一个可迭代对象转换成元祖
str(obj) #把obj对象转换成字符串
len(sub) #求sub的长度，sub可以是字符串，可以是变量
max() #返回序列或者参数集合中的最大值,根据字符串的ascii码比较大小的，不管是序列，还是元组，列表，里面的元组必须是同一个数据类型，不然会报错
min() #返回序列或者参数集合中的最小值,根据字符串的ascii码比较大小的，不管是序列，还是元组，列表，里面的元组必须是同一个数据类型，不然会报错
sorted()和list.sort()这个列表内置函数是一样的，不会该表元素位置
reversed()  #排倒序
enumerate()  #枚举
>>> c = (2,4,6,1,3,3,5)
>>> reversed(c)
<reversed object at 0x02E619D0>  #这样是返回一个对象，
>>> list(reversed(c))
[5, 3, 3, 1, 6, 4, 2]
>>> list(enumerate(c))
[(0, 2), (1, 4), (2, 6), (3, 1), (4, 3), (5, 3), (6, 5)]
zip()  #压缩，相对位置的元素进行合并
>>> a = [1,2,3,4,5,6,7,8]
>>> b = [4,5,6,7,8]
>>> zip(a,b)
<zip object at 0x02E58E68>   #这样是返回一个对象，
>>> list(zip(a,b))
[(1, 4), (2, 5), (3, 6), (4, 7), (5, 8)]


函数定义和调用
>>> def firstfun():  #定义，格式为  def 函数名()，可以带参数，参数个数没有限制
print('aaaaa')
print('bbbbb')


>>> firstfun()  #调用，直接函数名()
aaaaa
bbbbb


>>> def firstfun(name):
print(name + 'aaaaa')

>>> firstfun('打印:')
打印:aaaaa


>>> def adds(num1,num2):
nums = num1 + num2
return nums


>>> adds(1,4)
5


>>> def MyFisrtFunction(name):  #name是形式参数(parameter)，可以这样定义一个函数文档
'函数定义过程中的name是叫形参'
#因为ta只是一个形式，表示占据一个参数位置
print('传递进来的' + name + '叫做实参，因为Ta是具体的参数值！')


>>> MyFisrtFunction('小甲鱼')   #name是实际参数(argument)
传递进来的小甲鱼叫做实参，因为Ta是具体的参数值！


>>> MyFisrtFunction.__doc__
'函数定义过程中的name是叫形参'


>>> help(MyFisrtFunction)
Help on function MyFisrtFunction in module __main__:


MyFisrtFunction(name)
    函数定义过程中的name是叫形参
    
>>> def SaySome(name, words):
print(name + '->' + words)

>>> SaySome(words='让变成改变世界！', name='小甲鱼')  #关键字参数可以不考虑参数位置
小甲鱼->让变成改变世界！


>>> def SaySome(name='小甲鱼', words='让变成改变世界！'):
print(name + '->' + words)


>>> SaySome()
小甲鱼->让变成改变世界！


>>> def test(*params):   #*params收集参数，或者是可变参数，用于不确定需要几个参数的时候，定义时，仅需要在参数前面加*号就可以
print('参数的长度是：', len(params));
print('第二个参数是：',params[1]);


>>> test(1,'小甲鱼',2,3,4,5,6)
参数的长度是： 7
第二个参数是： 小甲鱼


>>> def test(*params,exp = 8):  #带默认值的不能写在不带默认值的参数前面
print('参数的长度是：', len(params));
print('第二个参数是：',params[1]);


>>> test(1,'小甲鱼',2,3,4,5,exp=6)  #第二个关键字参数引用的时候一定要加上  参数名='值'  来引用
参数的长度是： 6
第二个参数是： 小甲鱼




019函数：我的地盘听我的
python严格来说只有函数，没有过程
当没有任何返回的时候就返回none
>>> def hello():
print('hello fishc!')
>>> temp = hello()
hello fishc!
>>> print(temp)
None
python函数返回多个值
>>> def return_back():
return [1,'小甲鱼',3.14]
>>> return_back()
[1, '小甲鱼', 3.14]
全局变量和局部变量，可以是同一个名字，建议不要在局部函数里面修改全局变量
def discounts(price, rete):
    final_price = price * rate  #这里的final_price是局部变量
    old_price = 50
    print('打印局部变量old_price:', old_price)  #这里相当于调用了局部变量，能正常打印，值是这里局部变量赋的值50
    return final_price
old_price = float(input('请输入原价：'))  #这里的变量和函数里面的old_price互不影响，能正常打印，值是调用时输入的赋值
rate = float(input('请输入折扣率：'))
new_price = discounts(old_price, rate)  #这里用的函数的局部变量会先保存到栈stack里面，等这个函数调用完，就会清空栈stack
print('打折后价格是：', new_price)  #这里能正常打印这个全局变量
print('final_price的值：',final_price)  #这里不能正常打印，这个是局部变量，不能使用


这里的函数不能修改全局变量
>>> count=5  #全局变量
>>> def test():
count=10 #局部变量
print(count)
>>> test()
10   #打印出来的是局部变量
>>> print(count)
5    #打印出来的是全局变量


020函数：内嵌函数和闭包
这里的函数能修改全局变量
>>> count=5
>>> def test():
global count  #声明这个是全局变量
count = 10
print(count)
>>> test()
10
>>> print(count)
10
内嵌函数
>>> def fun1():
print('fun1()')
def fun2():    #这里是内嵌函数
print('fun2()')
fun2()  #调用内嵌函数
>>> fun1()
fun1()
fun2()


闭包
>>> def funx(x):
def funy(y):  #这里的funy()引用了funx()的一个变量x，则这里的 funx()是一个闭包
return x*y
return funy  #返回的时候是一个对象，不用管是函数或者是变量
>>> i = funx(8)  
>>> type(i)
<class 'function'>
>>> i(5)
40
>>> funx(8)(5)
40


>>> def fun1():
x = 5
def fun2():
nonlocal x  #相当于声明这个不是fun2()的局部变量，而是使用fun1()中的局部变量x
x *= x
return x
return fun2()
>>> fun1()
25


021函数：lambda表达式
匿名函数lambda，当不用的时候内存清理器会把它清除掉，不用考虑申请和释放资源
>>> def ds(x):
return 2*x+1
>>> ds(5)
11
等效于下面的写法
>>> lambda x:2*x+1
<function <lambda> at 0x0346FB70>
>>> g=lambda x:2*x+1
>>> g(5)
11


>>> def add(x, y):
return x + y


>>> add(3,4)
7
等效于下面的写法
>>> lambda x,y:x+y
<function <lambda> at 0x036E7D20>
>>> g=lambda x,y:x+y
>>> g(3,4)
7


filter()
语法
filter(function or None, iterable)两个参数，iterable可迭代的数据，
当第一个参数是函数的时候，就将第二个可迭代的每一个数作为函数的参数进行计算，返回函数值为Ture的值列表
当第一个参数是None的时候，就将第二个可迭代的每一个值为True的值列表
>>> filter(None,[1,0,False,True])
<filter object at 0x034C19B0>
>>> list(filter(None,[1,0,False,True]))
[1, True]
>>> 
>>> def odd(x):
return x%2
>>> temp=range(10)  #range()函数是生成0~9的数字
>>> show=filter(odd,temp)
>>> list(show)
[1, 3, 5, 7, 9]
>>> 
>>> list(filter(lambda x:x%2,range(10)))
[1, 3, 5, 7, 9]


map()映射
将序列的每一个元素作为函数的参数进行加工，直到可迭代的每个元素都加工完毕，返回所有加工后的所有元素，构成新序列
>>> list(map(lambda x:x*2,range(10)))  #range(10)得到0，1，2，3，4，5，6，7，8，9，然后分别乘以2，形成了如下的序列
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]


022函数：递归是神马
recursion()递归，简单的解释就是函数本身一直调用自己，符合某个条件后返回，不然一直递归下去
下面的函数要写在py文件里面
def factorial(n):  #阶乘的非递归的写法
result = n
for i in range(1, n):
result *= i
return result
number = int(input('请输入一个正整数：'))
result = factorial(number)
print('%d 的阶乘是：%d' %(number, result))
下面是用递归的写法(也要写在py文件里面执行)
def factorial(n):
        if n == 1:
                return 1
        else:
                return n * factorial(n-1)
number = int(input('请输入一个正整数：'))
result = factorial(number)
print('%d 的阶乘是：%d' %(number, result))


023递归：这帮小兔崽子
斐波那契(Fibonacci)
兔子繁殖的规律
迭代的写法：
def fab(n):
        n1 = 1
        n2 = 1
        n3 = 1
        if n < 1:
                print('输入有误！')
                return -1
        while (n-2) > 0:
                n3 = n2 + n1
                n1 = n2
                n2 = n3
                n -= 1
        return n3
result = fab(20)
if result != -1:
        print('总共有%d对小兔崽子诞生！' % result)
递归的写法：
def fab(n):
        if n < 1:
                print('输入有误！')
                return -1
        if n == 1 or n == 2:
                return 1
        else:
                return fab(n-1) + fab(n-2)
result = fab(20)
if result != -1:
        print('总共有%d对小兔崽子诞生！' % result)


024递归：汉诺塔
def hanoi(n, x, y, z):
        if n == 1:
                print(x, ' --> ', z)
        else:
                hanoi(n-1, x, z, y) #将前n-1个盘子从x移动到y上
                print(x, ' --> ', z) #将最底下的最后一个盘子从x移动到z上
                hanoi(n-1, y, x, z) #将y上的n-1个盘子移动到z上
n = int(input('请输入哈诺塔的层数：'))
hanoi(n, 'x', 'y', 'z')


025字典：当索引不好用时
键(key),值(value)
1.字典是无序的
2.print出来的结果是按照字典values()的id排序的


第一种方式是通过调用index()函数进行一一对应，但是这个效率低
>>> brand = ['李宁', '耐克', '阿迪达斯', '鱼C工作室']
>>> slogan = ['一切皆有可能', 'Just do it', 'Impossible is nothing', '让编程改变世界']
>>> print('鱼C工作室的口号是：', slogan[brand.index('鱼C工作室')])
鱼C工作室的口号是： 让编程改变世界


第二种方式通过字典的方式进行直接映射定义字典要使用{}
>>> dict1 = {'李宁':'一切皆有可能', '耐克':'Just do it', '阿迪达斯':'Impossible is nothing', '鱼C工作室':'让编程改变世界'}  #注意这里用的是{}
>>> print('鱼C工作室的口号是：', dict1['鱼C工作室'])  #注意dict1后面的[]
鱼C工作室的口号是： 让编程改变世界


help(dict)中的用法例子
>>> dict2 = dict((('F', 70),('i', 105), ('s', 115), ('h', 104), ('c', 67)))
>>> dict2
{'s': 115, 'F': 70, 'h': 104, 'c': 67, 'i': 105}


>>> dict3 = dict(aa = '第一个参数', bb = '第二个参数')
>>> dict3
{'aa': '第一个参数', 'bb': '第二个参数'}
对这个字典的键值进行修改
>>> dict3['aa'] = '第一个参数(修改后)'
>>> dict3
{'aa': '第一个参数(修改后)', 'bb': '第二个参数'}
继续对这个字典增加键值,序列则不能这样直接增加值
>>> dict3['cc'] = '第三个参数'  #这里不能检索字典中不存在的键，会报错
>>> dict3
{'aa': '第一个参数(修改后)', 'cc': '第三个参数', 'bb': '第二个参数'}


026字典：当索引不好用时2
>>> dict1 = {}
>>> dict1.fromkeys((1, 2, 3))  #这里是由于没有给对应的键赋值
{1: None, 2: None, 3: None}
>>> dict1.fromkeys((1, 2, 3), 'Number')  #这里的键赋值是赋相同的值，不支持单个赋值
{1: 'Number', 2: 'Number', 3: 'Number'}
>>> dict1.fromkeys((1, 2, 3), ('One', 'Two', 'Three'))
{1: ('One', 'Two', 'Three'), 2: ('One', 'Two', 'Three'), 3: ('One', 'Two', 'Three')}
>>> dict1.fromkeys((1, 3), ('One', 'Three'))  #不能支持部分赋值，这样只会修改这个字典的结构
{1: ('One', 'Three'), 3: ('One', 'Three')}


keys()    #返回字典的键
values()  #返回字典键对应的值
#items()  #返回字典的所有元素，用()括起来他每个元素
>>> dict1 = {}
>>> dict1 = dict1.fromkeys(range(5), '赞')
>>> dict1
{0: '赞', 1: '赞', 2: '赞', 3: '赞', 4: '赞'}
>>> for eachkey in dict1.keys():
print(eachkey)

0
1
2
3
4
>>> for eachvalue in dict1.values():
print(eachvalue)


赞
赞
赞
赞
赞
>>> for eachitem in dict1.items():
print(eachitem)


(0, '赞')
(1, '赞')
(2, '赞')
(3, '赞')
(4, '赞')


>>> dict1.get(4)
'赞'
>>> dict1.get(5)
>>> print(dict1.get(5))  #当字典引用的键不存在的时候，返回的是None
None
>>> dict1.get(4, '没有这个键值！')  #get()函数有相当于oracle中的nvl函数
'赞'
>>> dict1.get(5, '没有这个键值！')
'没有这个键值！'
当不知道某个键是否存在字典中，可以用成员资格操作符(in或者not in)进行判断
>>> 4 in dict1
True
>>> 5 in dict1
False


#在字典中检查键的成员资格比序列更加高效，数据量大的时候很明显
#在字典中查找的是键，不是值，而在序列中查找的是值，相当于oracle里面的表的索引


清空字典
>>> dict1.clear()  #建议用这种方法
>>> dict1
{}
>>> dict1 = {}
>>> dict1
{}
举例说明
>>> a = {'姓名':'小甲鱼'}
>>> b = a
>>> b
{'姓名': '小甲鱼'}
>>> a = {}  #如果用{}赋值的方式，字典b还是原来字典的内容，但是利用 字典.clear()方法可以将这两个都清空掉
>>> a
{}
>>> b
{'姓名': '小甲鱼'}


copy()函数
>>> a = {1:'one', 2:'two', 3:'three'}
>>> b = a.copy()  #指的是浅拷贝，内存地址是不一样的，当修改字典c时，字典b的值不会改变
>>> c = a  #这里是赋值，内存地址是一样，当修改字典a或者是c其中一个，字典a和c都会跟着一期改变
>>> b
{1: 'one', 2: 'two', 3: 'three'}
>>> c
{1: 'one', 2: 'two', 3: 'three'}
id()获取内存地址
>>> id(a)
67604888
>>> id(b)
65005048
>>> id(c)
67604888


pop()移除给定键的一个元素，并且返回该元素的值
popitem()随机移除一个元素(包含键和键值)
>>> a
{1: 'one', 2: 'two', 3: 'three'}
>>> a.pop(2)     #移除指定的一个元素
'two'
>>> a
{1: 'one', 3: 'three'}
>>> a.popitem()    #随机的移除一个元素
(1, 'one')
>>> a
{3: 'three'}


setdefault()   #和get()相似，但是setdefault()如果没有这个键，会给你添加到字典里面
update()  #用别的字典去更新当前字典的值，有对应的键就修改，没有对应的键就增加对应的元素
>>> a
{1: 'one', 2: 'two', 3: 'three'}
>>> a.setdefault(4)
>>> a
{1: 'one', 2: 'two', 3: 'three', 4: None}
>>> a.setdefault(5, 'five')
'five'
>>> a
{1: 'one', 2: 'two', 3: 'three', 4: None, 5: 'five'}


>>> a
{1: 'one', 2: 'two', 3: 'three', 4: None, 5: 'five'}
>>> b = {4:'four'}
>>> a.update(b)
>>> a
{1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five'}
>>> c = {6:'six'}
>>> a.update(c)
>>> a
{1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five', 6: 'six'}


027集合：在我的世界里，你就是唯一
集合，包含的元素是唯一的，元素是无序的
>>> a = {}  #定义一个空字典
>>> type(a)
<class 'dict'>
>>> a = {1:'one', 2:'two', 3:'three'}   #定义一个只有三个元素的字典
>>> type(a)
<class 'dict'>
>>> a = {1,2,3}  #定一个集合第一种方法
>>> type(a)
<class 'set'>
>>> a = set([1,2,3,4,5,5])   #定一个集合第二种方法
>>> type(a)
<class 'set'>


>>> a = {1,2,3,4,5,5,4,3,2,1}
>>> a
{1, 2, 3, 4, 5}  #集合里面的元素都是唯一的
>>> a[2]   #集合不支持索引，会报错
Traceback (most recent call last):
  File "<pyshell#13>", line 1, in <module>
    a[2]
TypeError: 'set' object does not support indexing


去除列表里面的重复的元素
第一种用循环方式
>>> a = [1,2,3,4,5,5,3,1,0]
>>> temp = []
>>> for each in a:
if each not in temp:
temp.append(each)


>>> temp
[1, 2, 3, 4, 5, 0]
第二种用集合的方式
>>> a = [1,2,3,4,5,5,3,1,0]
>>> a = list(set(a))   #先通过集合元素的唯一性去除重复元素，然后通过list()转换成列表。注意，字典values()的id排序的，这样去重会改变列表顺序
>>> a
[0, 1, 2, 3, 4, 5]


访问集合中的元素
1.可以通过for循环一个一个读取
2.通过in或者not in判断元素是否在集合中


add()和remove()
>>> a = set([0, 1, 2, 3, 4, 5])
>>> a
{0, 1, 2, 3, 4, 5}
>>> a.add(6)
>>> a
{0, 1, 2, 3, 4, 5, 6}
>>> a.remove(0)
>>> a
{1, 2, 3, 4, 5, 6}


不可变集合
frozenset()修改集合的属性，让集合不可修改
>>> a = frozenset([0, 1, 2, 3, 4, 5])
>>> a
frozenset({0, 1, 2, 3, 4, 5})
>>> type(a)
<class 'frozenset'>
>>> a.add(6)   #使用此函数会报错
Traceback (most recent call last):
  File "<pyshell#80>", line 1, in <module>
    a.add(6)
AttributeError: 'frozenset' object has no attribute 'add'


028文件：因为懂你，所以永恒
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
第一个参数file是文件名，不带路径是指当前所在路径
第二个参数：r 只读方式打开(默认)
w 写入方式打开，不存在则新建，存在会覆盖
x 文件存在，则会报异常
a 是在已存在文件末追加方式写入
b 二进制方式打开
t 以文本模式打开(默认)
+ 可读写模式(可添加到其他模式中使用)
U 通用换行符支持(大写的U)
close() 关闭文件
read(size=1) 从文件读取size个字符，当为给定size或给定复制的时候，读取剩余的所有字符，然后作为字符串返回
readline() 以写入模式打开，如果文件存在，则追加
write(str) 将字符串str写入文件
writelines(seq) 向稳健写入字符串序列seq，seq应该是一个返回字符串的可迭代对象
seek(offset,from) 在文件中移动文件指针，从from(0代表文件起始位置，1代表当前位置，2代表文件末尾)偏移offset个字节
tell() 返回当前在文件中的位置
>>> f = open('E:\\record.txt')
>>> f
<_io.TextIOWrapper name='E:\\record.txt' mode='r' encoding='cp936'>
>>> f.read()  #没有带参数默认都读取出来
'文件使用  测试\n第一行\n第二行\n第三行\n第四行\n'
>>> f.read()  #在读取一次，就会是空，因为上一次读取是文件末尾了
''
>>> f.close()  #要从新读取该文件，需要关闭，再打开
>>> f = open('E:\\record.txt')  #等价与 f = open('E:/record.txt')
>>> f.read(3)
'文件使'
>>> f.tell()  #一个中文占两个字节，英文和英文字符占一个字节
6
>>> f.seek(4,0)  #从文件的起始位置偏移4个字节
4
>>> f.readline()
'使用  测试\n'
>>> list(f)  #从文件当前读取位置开始转换成列表
['第一行\n', '第二行\n', '第三行\n', '第四行\n']




>>> f.seek(0,0)
0
>>> lines = list(f)
>>> for each_line in lines:  #这样的效率相对较差
print(each_line)



文件使用  测试


第一行


第二行


第三行


第四行


>>> for each_line in f:  #这个打开方式相对高一些
print(each_line)



文件使用  测试


第一行


第二行


第三行


第四行


029文件：一个任务
对文件的处理
第一个版本
f = open('E:/record.txt')


boy = []
girl = []
count = 1


for each_line in f:
    if each_line[:6] != '======':
        (role, line_spoken) = each_line.split('：', 1)
        if role == '小甲鱼':
            boy.append(line_spoken)
        if role == '小客服':
            girl.append(line_spoken)
    else:
        file_name_boy = 'boy_' + str(count) + '.txt'
        file_name_girl = 'girl_' + str(count) + '.txt'


        boy_file = open(file_name_boy, 'w')
        girl_file = open(file_name_girl, 'w')


        boy_file.writelines(boy)
        girl_file.writelines(girl)


        boy_file.close()
        girl_file.close()


        boy = []
        girl = []
        count += 1


file_name_boy = 'boy_' + str(count) + '.txt'
file_name_girl = 'girl_' + str(count) + '.txt'


boy_file = open(file_name_boy, 'w')
girl_file = open(file_name_girl, 'w')


boy_file.writelines(boy)
girl_file.writelines(girl)


boy_file.close()
girl_file.close()


f.close()


---------------------------------------------------------------------------------------
第二个版本
def save_file(boy, girl, count):
    file_name_boy = 'boy_' + str(count) + '.txt'
    file_name_girl = 'girl_' + str(count) + '.txt'


    boy_file = open(file_name_boy, 'w')
    girl_file = open(file_name_girl, 'w')


    boy_file.writelines(boy)
    girl_file.writelines(girl)


    boy_file.close()
    girl_file.close()


def split_file(file_name):
    f = open(file_name)


    boy = []
    girl = []
    count = 1


    for each_line in f:
        if each_line[:6] != '======':
            (role, line_spoken) = each_line.split('：', 1)
            if role == '小甲鱼':
                boy.append(line_spoken)
            if role == '小客服':
                girl.append(line_spoken)
        else:
            save_file(boy, girl, count)


            boy = []
            girl = []
            count += 1


    save_file(boy, girl, count)


    f.close()


split_file('E:/record.txt')


030文件系统：介绍一个高大上的东西
模块，一个包含所有你定义的函数和变量的文件，其后缀名是.py，模块可以被其他程序引用，以使用该模块中的函数等功能
>>> import random  #要使用random的函数，要先引入
>>> secret = random.randint(1, 10)  #randint()是产生随机数的函数
>>> secret
1
操作系统模块
OS：Operating System
不同系统(Windows,Mac OS,Linus,UNIX)，对文件系统访问工作原理是不一样的,要使用那个系统模块，就引用那个系统模块是不够健壮的，
python提供可以直接引用OS系统模块，就会自动适应引用那个系统模块


os模块中关于文件/目录常用的函数使用方法
getcwd() 返回当前工作目录
chdir(path) 改变工作目录，目录要用单引号括住
listdir(path='.') 列举指定目录中的文件名（'.'表示当前目录，'..'表示上一级目录）
mkdir(path) 创建单层目录，创建目录的父目录必须要存在，如该目录已存在抛出异常
makedirs(path) 递归创建多层目录，如该目录已存在抛出异常，注意：'E:\\a\\b'和'E:\\a\\c'并不会冲突
remove(path) 删除文件
rmdir(path) 删除单层目录，删除之前要先删除该目录下的所有文件，如该目录非空则抛出异常
removedirs(path) 递归删除目录，从子目录到父目录逐层尝试删除，遇到目录非空则抛出异常
rename(old, new) 将文件old重命名为new
system(command) 运行系统的shell命令，如os.system('calc')打开系统计算器
walk(top) 遍历top路径以下所有的子目录，返回一个三元组：(路径, [包含目录], [包含文件])【具体实现方案请看：第30讲课后作业^_^】


以下是支持路径操作中常用到的一些定义，支持所有平台
os.curdir 指代当前目录（相当于'.'，但使用该函数能使程序适用更多的操作系统）
os.pardir 指代上一级目录（相当于'..'，但使用该函数能使程序适用更多的操作系统）
os.sep 输出操作系统特定的路径分隔符（Win下为'\\'一个是转义符，真正只有一个\，Linux下为'/'）
os.linesep 当前平台使用的行终止符（Win下为'\r\n'，Linux下为'\n'）
os.name 指代当前使用的操作系统（包括：'posix'UNIX系统,  'nt'window系统, 'mac'苹果系统, 'os2', 'ce', 'java'）


os.path模块中关于路径常用的函数使用方法
basename(path) 去掉目录路径，单独返回文件名
dirname(path) 去掉文件名，单独返回目录路径
join(path1[, path2[, ...]]) 将path1, path2各部分组合成一个路径名
split(path) 分割文件名与路径，返回(f_path, f_name)元组。如果完全使用目录，它也会将最后一个目录作为文件名分离，且不会判断文件或者目录是否存在
splitext(path) 分离文件名与扩展名，返回(f_name, f_extension)元组
getsize(file) 返回指定文件的尺寸，file要制定路径，不指定路径则是当前工作路径，单位是字节
getatime(file) 返回指定文件最近的访问时间（浮点型秒数，可用time模块的gmtime()UTC时间或localtime()函数换算）
getctime(file) 返回指定文件的创建时间（浮点型秒数，可用time模块的gmtime()或localtime()函数换算）
getmtime(file) 返回指定文件最新的修改时间（浮点型秒数，可用time模块的gmtime()或localtime()函数换算）


以下为函数返回 True 或 False
exists(path) 判断指定路径（目录或文件）是否存在
isabs(path) 判断指定路径是否为绝对路径
isdir(path) 判断指定路径是否存在且是一个目录
isfile(path) 判断指定路径是否存在且是一个文件
islink(path) 判断指定路径是否存在且是一个符号链接
ismount(path) 判断指定路径是否存在且是一个挂载点
samefile(path1, paht2) 判断path1和path2两个路径是否指向同一个文件


031永久存储：腌制一缸美味的泡菜
pickle 把所有文件都转换成二进制文件存放的过程
unpickling  把二进制文件反过来转换成对象的过程


把一个列表文件装到一个pickle文件
>>> import pickle  #先引入pickle模块
>>> pickle_file = open('my_list.pkl', 'wb')  #二进制文件写入，要以'wb'方式打开，'w'是写的意思，'b'是以二进制文件方式打开
>>> my_list = [123,3.14,'小甲鱼',['anthor list']]  
>>> pickle.dump(my_list,pickle_file)  #把列表my_list装进去pickle_file
>>> pickle_file.close()  #对文件进行open动作就需要close()


把上面得到的pickle文件转换成原来的列表数据
>>> pickle_file = open('my_list.pkl', 'rb')
>>> my_list2 = pickle.load(pickle_file)
>>> print(my_list2)
[123, 3.14, '小甲鱼', ['anthor list']]
>>> pickle_file.close()


032异常处理：你不可能总是对的


Python标准异常总结
AssertionError 断言语句（assert）失败，当为真，正常运行，当为假，抛出异常，可以用于测试曾许
AttributeError 尝试访问未知的对象属性，python中的对象可以是函数，文件等等
EOFError 用户输入文件末尾标志EOF（Ctrl+d）
FloatingPointError 浮点计算错误
GeneratorExit generator.close()方法被调用的时候
ImportError 导入模块失败的时候
IndexError 索引超出序列的范围
KeyError 字典中查找一个不存在的关键字
KeyboardInterrupt 用户输入中断键（Ctrl+c）
MemoryError 内存溢出（可通过删除对象释放内存）
NameError 尝试访问一个不存在的变量
NotImplementedError 尚未实现的方法
OSError 操作系统产生的异常（例如打开一个不存在的文件）
OverflowError 数值运算超出最大限制
ReferenceError 弱引用（weak reference）试图访问一个已经被垃圾回收机制回收了的对象
RuntimeError 一般的运行时错误
StopIteration 迭代器没有更多的值
SyntaxError Python的语法错误
IndentationError 缩进错误
TabError Tab和空格混合使用
SystemError Python编译器系统错误
SystemExit Python编译器进程被关闭
TypeError 不同类型间的无效操作
UnboundLocalError 访问一个未初始化的本地变量（NameError的子类）
UnicodeError Unicode相关的错误（ValueError的子类）
UnicodeEncodeError Unicode编码时的错误（UnicodeError的子类）
UnicodeDecodeError Unicode解码时的错误（UnicodeError的子类）
UnicodeTranslateError Unicode转换时的错误（UnicodeError的子类）
ValueError 传入无效的参数
ZeroDivisionError 除数为零


033异常处理：你不可能总是对的2
try-except语句格式
try:
检测范围
except Exception[as reason]:
出现异常(Exception)后的处理代码


try:
    sum = 1 + '1'  #这里是第一个异常，程序执行到这里会直接报错，就不再往后执行
    f = open('aaa.txt')   #这里尝试打开一个不存在的文件
    print(f.read())
    f.close()
except OSError as reason:  #打开不存在的文件是IO错误，python归属到OSError异常，as reason是把错误信息赋值给season，同样的异常检测还可以写多个
    print('文件不存在T_T\n错误的原因是:' + str(reason))  #中间的\n是换行转义符
except TypeError as reason:  #异常捕捉部分先后，都能正常检测到异常
    print('类型错误\n错误的原因是:' + str(reason))  


try:
    f = open('我为什么是一个文件.txt','w')
    print(f.write('我存在了！'))
    sum = 1 + '1'
    f.close()
except (OSError,TypeError):  #同时捕获两个异常
    print('程序报错了T_T')
finally:
    f.close()  #无论如何都会执行的代码


直接raise
>>> raise ZeroDivisionError('除数为零的异常')
Traceback (most recent call last):
  File "<pyshell#1>", line 1, in <module>
    raise ZeroDivisionError('除数为零的异常')
ZeroDivisionError: 除数为零的异常


034丰富的else语句及简洁的with语句
else语句
#要么怎样，要么不怎样
#干完了能怎样，干不完就别想怎样
def showMaxFactor(num):  #求输入的一个数的约数
    count = num // 2  #//是整除
    while count > 1:
        if num % count == 0:
            print('%d最大的约数是%d'%(num, count))
            break
        count -= 1
    else:
        print('%d是素数' % num)


num = int(input('请输入一个数：'))
showMaxFactor(num)


#没有问题，那就干吧
try:
    print(int('abc'))
except ValueError as reason:
    print('出错了：'+ str(reason))
else:
    print('没有任何异常！')


with语句
#常规写法
try:
    f = open('data.txt','w')
    for each_line in f:
        print(each_line)
except OSError as reason:
    print('出错了：'+ str(reason))
finally:   #这里也是不太合理，当没有打开这个不存在的文件时，不存在要关闭文件
    f.close()


try:
    with open('data.txt','w') as f:  #with语句会把打开文件当作一个对象，这个对象是系统内置的，会有自动打开和关闭文件的动作
        for each_line in f:
            print(each_line)
except OSError as reason:
    print('出错了：'+ str(reason))


035图形用户界面入门：EasyGui
导入和调用函数的几种方法
>>> import easygui
>>> easygui.msgbox('Hello World!')
'OK'
>>> from easygui import *
>>> msgbox('Hello World!')
'OK'
>>> import easygui as g  #推荐用这种方式
>>> g.msgbox('Hello World!')
'OK'


import easygui as g
import sys


while 1:
        g.msgbox("嗨，欢迎进入第一个界面小游戏^_^")


        msg ="请问你希望在鱼C工作室学习到什么知识呢？"
        title = "小游戏互动"
        choices = ["谈恋爱", "编程", "OOXX", "琴棋书画"]
        
        choice = g.choicebox(msg, title, choices)


        # note that we convert choice to string, in case
        # the user cancelled the choice, and we got None.
        g.msgbox("你的选择是: " + str(choice), "结果")


        msg = "你希望重新开始小游戏吗？"
        title = "请选择"
        
        if g.ccbox(msg, title):     # show a Continue/Cancel dialog
                pass  # user chose Continue
        else:
                sys.exit(0)     # user chose Cancel


036类和对象：给大家介绍对象
封装：信息隐蔽技术，把实现过程封装，只需要对其作用了解，然后怎么调用就行
继承：子类自动共享父类之间数据和方法的机制
多态：不同对象对同一方法响应不同的功能
对象 = 属性 + 方法
class Turtle:  #Python 中的类名约定以大写字母开头
    """关于类的一个简单例子"""
    #属性
    color = 'green'
    weight = 10
    legs = 4
    shell = Ture
    mouth = '大嘴'


    #方法
    def climb(self):
        print("我正在很努力的向前跑。。。。")


    def run(self):
        print("我正在飞快的向前跑。。。。")


    def bite(self):
        print("咬死你咬死你！！")


    def eat(self):
        print("有得吃，真满足^_^")


    def sleep(self):
        print("困了，睡了，晚安，Zzzz")


OO = Object Oriented面向对象


037类和对象：面向对象编程
OOA:面向对象分析 Object Oriented Analysis
OOD:面向对象设计 Object Oriented Design
OOP:面向对象编程 Object Oriented Programming
OOAD（Object Orient Analysis & Design，面向对象的分析和设计，面向对象分析与设计）
self是什么
相当于C++的this指针
1.假如你有一个类称为MyClass和这个类的一个实例MyObject。当你调用这个对象的方法MyObject.method(arg1, arg2)的时候，这会由Python自动转为MyClass.method(MyObject, arg1, arg2)——这就是self的原理了
2.self只有在类的方法中才会有且必须要有，独立的函数或方法是不必带有self的。self在定义类的方法时是必须有的，
虽然在调用时不必传入相应的参数。self名称不是必须的，在python中self不是关键词，
你可以定义成a或b或其它名字都可以,但是约定成俗使用self
3.self在Python里不是关键字。self代表当前对象的地址。self能避免非限定调用造成的全局变量。
4.http://www.crifan.com/summary_the_meaning_of_self_and___init___in_python_and_why_need_them/
5.类是图纸，类实例化后才是房子，一个图纸可以造出很多房子，一个类可是实例化出很多实例化对象，self就相当与门牌号，有了self才能找到对应的实例化对象
>>> class Ball:
def setName(self, name):  #定义类的方法中才会有且必须要有的一个个参数，可以用其他名字，但是约定俗成为self
self.name = name
def kick(self):
print("我叫%s，该死的，谁踢我..." % self.name)

>>> a = Ball()    #把Ball类实例化给变量a
>>> a.setName('BallA')
>>> b = Ball()    #把Ball类实例化给变量b
>>> b.setName('BallB')
>>> c = Ball()    #把Ball类实例化给变量c
>>> c.setName('BallC')
>>> a.kick()  #这里有一个默认的参数self,把a的对象的标志传进来，上面已经把a中name的值设置为BallA
我叫BallA，该死的，谁踢我...
>>> c.kick()
我叫BallC，该死的，谁踢我...


__init__(self)  #构造方法，实例化对象的时候可以传入参数
class Person:
         def __init__(self,name):
                  self.name = name
         def sayhello(self):
                  print('My name is:%s'%self.name)
p=Person('Bill')  #这里可以传入参数，在__init__()实例化的接收
p.sayhello()


公有和私有
name mangling 名字改编，名字重整
定义私有变量，在变量名或函数名前加上两个下划线"__"即可
>>> class Person:
__name = '小甲鱼'  #定义私有变量
age = 25


>>> p = Person()
>>> p.__name  #这里相当于在函数的外部，是访问不到私有变量的，会报错
Traceback (most recent call last):
  File "<pyshell#102>", line 1, in <module>
    p.__name
AttributeError: 'Person' object has no attribute '__name'
>>> p.age  #这里可以正常访问公有变量
25
>>> p._Person__name  #私有变量相当于变量改编，可以通过  _类名__变量名  来使用
'小甲鱼'


038类和对象：继承
继承定义方法
class DerivedClassName(BaseClassName):  
这里的BaseClassName是基类，或者是父类，超类，DerivedClassName是子类，可以继承父类的属性和方法
当子类中定义了与父类同名的方法或属性，则会自动覆盖父类对应的方法或属性
>>> class Parent:
def hello(self):
print('正在调用父类的方法...')


>>> class Child(Parent):  #定义子类，继承子类不存在父类的方法和属性
pass


>>> p = Parent()
>>> p.hello()
正在调用父类的方法...
---------------------------
>>> class Child(Parent):  #重新定义子类，子类存在了hello()方法，则不继承父类的hello()方法
def hello(self):
print('正在调用子类的方法...')


>>> c = Child()
>>> c.hello()
正在调用子类的方法...
>>> p.hello()
正在调用父类的方法...


例子
import random as r


class Fish:
    def __init__(self):
        self.x = r.randint(0, 10)
        self.y = r.randint(0, 10)


    def move(self):
        self.x -= 1
        print("我的位置是：",self.x,self.y)


class Goldfish(Fish):
    pass


class Carp(Fish):
    pass


class Salmon(Fish):
    pass


class Shark(Fish):
    def __init__(self):
        super().__init__()  #相当把继承多重的父类都继承下来，提高代码复用，继承的对象包括基类，父类，超类
        #或者可以这样写Fish.__init__(self)  #这里是调用未绑定的父类方法，self不是父类的实例对象，是子类的实例对象
        self.hungry = True


    def eat(self):
        if self.hungry:
            print("吃货的梦想就是天天有的吃^_^")
            self.hungry = False
        else:
            print("太撑了，吃不下了！")


多重继承小例子
>>> class Base1:
   def foo1(self):
       print("我是foo1,我为Base1代言...")


>>> class Base2:
   def foo2(self):
       print("我是foo2,我为Base2代言...")


>>> class Base3(Base1,Base2):  #容易导致代码混乱，不推荐使用
    pass


>>> 
>>> c = Base3()  #实例初始化
>>> c.foo1()
我是foo1,我为Base1代言...
>>> c.foo2()
我是foo2,我为Base2代言...


039类和对象：拾遗
组合继承：把多个父类实例化的形式在新类中进行初始化，相当与横向继承，多重继承相当于纵向继承
class Turtle:
    def __init__(self, x):
        self.num = x
        
class Fish:
    def __init__(self, x):
        self.num = x
        
class Pool:
    def __init__(self, x, y):
        self.turtle = Turtle(x)  #以父类实例化的形式在新类中进行初始化
        self.fish = Fish(y)  #以父类实例化的形式在新类中进行初始化


    def print_num(self):
        print("水池里总共有乌龟%d只，小鱼%d条！" %(self.turtle.num, self.fish.num))


Python Mixin 编程机制
http://bbs.fishc.com/forum.php?mod=viewthread&tid=48888&extra=page%3D1%26filter%3Dtypeid%26typeid%3D403


类、类对象和实例对象
>>> class x:   #这是一个类，写完后，即定义完后就是一个类对象
count = 0


>>> a = x()  #实例化对象，即c是是一个实例对象
>>> b = x()
>>> c = x()
>>> a.count
0
>>> b.count
0
>>> c.count
0
>>> c.count += 10  #实例化给实例对象c后，进行类调用实例对象的实例属性count的值进行自加10
>>> c.count
10
>>> a.count
0
>>> b.count
0
>>> x.count  #这个类定义完后，就没有进行过修改，所以没有发生改变
0
>>> x.count += 100  #对类定义的静态属性count进行自加100
>>> a.count
100
>>> b.count
100
>>> c.count  #这个还是实例对象的值，调用的只是类的方法，跟x类中定义的静态属性count现在值没有关系
10


>>> class x:
def y(self):
print("X-man!")


>>> c = x()
>>> c.y()
X-man!
>>> c.y = 1  #这里相当于实例化后的对象c定义了一个属性y，和原来类的方法名字相同，覆盖原来类的属性y
>>> c.y
1
>>> c.y()
Traceback (most recent call last):
  File "<pyshell#9>", line 1, in <module>
    c.y()
TypeError: 'int' object is not callable


注意：
1.不要试图在一个类里面定义出所有能想到的特性和方法，应该利用继承和组合机制来进行扩展
2.用不同的词性命名，如属性名用名次，方法名用动词


绑定：python严格要求方法需要有实例才能被调用，这种限制其实就是python所谓的绑定概念
>>> class BB:  #这种写法是不正确的
def printBB():
print(""no zuo no die)

SyntaxError: invalid syntax
>>> class BB:
def printBB():
print("no zuo no die")


>>> BB.printBB()
no zuo no die
>>> bb = BB()
>>> bb.printBB()  #需要绑定一个参数，实际上Python解释成BB.printBB(bb)，但是也没有这么调用，只是python这么解释语法
Traceback (most recent call last):
  File "<pyshell#23>", line 1, in <module>
    bb.printBB()
TypeError: printBB() takes 0 positional arguments but 1 was given


>>> class CC:
def setXY(self, x, y):
self.x = x
self.y = y
def printXY(self):
print(self.x, self.y)


>>> dd = CC()
>>> dd.__dict__
{}
>>> CC.__dict__
mappingproxy({'printXY': <function CC.printXY at 0x030F1588>, '__weakref__': <attribute '__weakref__' of 'CC' objects>, '__doc__': None, '__dict__': <attribute '__dict__' of 'CC' objects>, 'setXY': <function CC.setXY at 0x030F1540>, '__module__': '__main__'})
>>> dd.setXY(4, 5)
>>> dd.__dict__  #这里是由于变量绑定，只有实例化的对象dd才能有这个x,y的属性
{'x': 4, 'y': 5}
>>> CC.__dict__  #这里是由于变量绑定，定义类CC没有这个属性
mappingproxy({'printXY': <function CC.printXY at 0x030F1588>, '__weakref__': <attribute '__weakref__' of 'CC' objects>, '__doc__': None, '__dict__': <attribute '__dict__' of 'CC' objects>, 'setXY': <function CC.setXY at 0x030F1540>, '__module__': '__main__'})
>>> dd.printXY()
4 5
>>> del CC  #删除掉定义类CC
>>> dd.printXY()  #删除掉定义类对象后，实例对象是静态变量，还会存在内存，只有在程序退出的时候才会释放
4 5


040类和对象：一些相关的BIF
issubclass(class, classinfo)  
第一个参数class是classinfo的一个子类，则返回True，否则返回False
1.一个类被认为是其自身的子类
2.classinfo可以是类对象组成的元祖，只要class与其中任何一个候选类的子类，则返回True
>>> class A:
pass


>>> class B(A):
pass


>>> issubclass(B,A)
True
>>> issubclass(B,B)
True
>>> issubclass(B,object)  #object是所有类的一个基类
True
>>> issubclass(A,B)
False


isinstance(object, classinfo)
参数object是一个实例对象，第二个参数是一个类，检查一个实例对象是否属于一个类的，属于则True，否则False
第二个参数也可以传入一个元组，元组里面有多个类，如果第一个参数传入的实例对象属于这个元组的其中一个类，则True，否则False
1.如果第一个参数不是对象，则永远返回False
2.如果第二个参数不是类或者由类对象组成的元组，会抛出一个TypeError
>>> b1 = B()
>>> isinstance(b1, B)
True
>>> isinstance(b1, A)
True
>>> isinstance(b1, (A, B))
True


hasattr(object, name)  #attr = attribute 属性
判断第二个参数（属性）是否属于第一个参数（类）的属性，第二个参数是字符串
>>> class C:
def __init__(self, x=0):
self.x = x


>>> c1 = C()
>>> hasattr(c1, 'x')  #类的属性x要转换成字符，用单引号或者是双引号引起来
True


getattr(object, name[, default])  #[, default]是一个可选参数,属性name要加引号
返回对象指定的属性的值，如果指定的属性不存且有可选参数，则返回可选参数的值，否则抛出AttributeError
>>> getattr(c1, 'x')
0
>>> getattr(c1, 'y')
Traceback (most recent call last):
  File "<pyshell#243>", line 1, in <module>
    getattr(c1, 'y')
AttributeError: 'C' object has no attribute 'y'
>>> getattr(c1, 'y', '你访问的属性不存在...')
'你访问的属性不存在...'


setattr(object, name, value)
返回对象指定的属性的值，如果属性不存在，则新建这个属性，并把第三个变量的值赋值给我这个新建的属性
>>> setattr(c1, 'y', 'FishC')
>>> getattr(c1, 'y', '你访问的属性不存在...')
'FishC'


delattr(object, name)
删除对象的属性name，如果属性不存在则抛出AttributeError
>>> delattr(c1, 'y')
>>> delattr(c1, 'y')
Traceback (most recent call last):
  File "<pyshell#257>", line 1, in <module>
    delattr(c1, 'y')
AttributeError: y


property(fget=None, fset=None, fdel=None, doc=None)
通过类的属性设置属性的值，对于给其他系统接口的时候，需要改程序，接口不用改
>>> class C:
def __init__(self, size=10):
self.size = size
def getSize(self):
return self.size
def setSize(self, value):
self.size = value
def delSize(self):
del self.size
x = property(getSize, setSize, delSize)  #这里的是property属性和self.size是绑定的，执行del C.x后，self.size也会删除掉


>>> c1 = C()
>>> c1.x  #相当于c1.getSize()，直接调用x会直接映射到property的一个参数
10
>>> c1.x = 18   #相当于c1.setSize()，直接调用x会直接映射到property的二个参数
>>> c1.x
18
>>> del c1.x  #相当于c1.delSize()，直接调用x会直接映射到property的三个参数
>>> c1.x  #这里只是删除了size的值，定义的类C还会存在，BIF的x也存在
Traceback (most recent call last):
  File "<pyshell#283>", line 1, in <module>
    c1.x
  File "<pyshell#275>", line 5, in getSize
    return self.size
AttributeError: 'C' object has no attribute 'size'
>>> c1.getSize()  #删除property后对应的size的值会删掉
Traceback (most recent call last):
  File "<pyshell#284>", line 1, in <module>
    c1.getSize()
  File "<pyshell#275>", line 5, in getSize
    return self.size
AttributeError: 'C' object has no attribute 'size'


041魔法方法：构造和析构
1.魔法方法被双下划线包围，例如__init__
2.魔法方法是面向对象的Python的一切
3.总能够在适当的时候被自动调用


在定义一个新的类的时候是先默认先调用__new__方法，然后调用__init__方法，
__new__方法一般重构它比较少，重构__init__方法相对会比较多


__new__(cls[, ..])
1. __new__ 是在一个对象实例化的时候所调用的第一个方法
2. 它的第一个参数是这个类，其他的参数是用来直接传递给 __init__ 方法
3. __new__ 决定是否要使用该 __init__ 方法，因为 __new__ 可以调用其他类的构造方法或者直接返回别的实例对象来作为本类的实例，如果 __new__ 没有返回实例对象，则 __init__ 不会被调用
4. __new__ 主要是用于继承一个不可变的类型比如一个 tuple 或者 string
>>> class CapStr(str):
def __new__(cls, string):  #__new__方法的第一个参数是cls(class的缩写)，指的是要新生成的类可选参数string会直接传给__init__方法
string = string.upper()
return str.__new__(cls, string)


>>> a = CapStr("wo shi xiaoxie")  #实例化类的时候，不能在__init__方法进行对str的值进行修改，但是可以通过修改__new__方法修改
>>> a
'WO SHI XIAOXIE'


__init__(self,[, ...])
构造器，当一个实例被创建的时候调用的初始化方法
相当于其他面向对象语言的构造方法，类在实例化对象的时候会调用的方法
>>> class Rectangle:
def __init__(self, x, y):  #这里是因为需要增加两个参数，所以要对__init__进行重构，没有返回值，因为实例化这个定义类的时候是不可能返回什么东西的
self.x = x
self.y = y
def getPeri(self):
return (self.x + self.y) * 2
def getArea(self):
return self.x * self.y


>>> rect = Rectangle(3, 4)
>>> rect.getPeri()
14
>>> rect.getArea()
12


__del__(self)
析构器，当一个实例被销毁的时候调用的方法
>>> class test:
def __init__(self):
print("我是__init__方法，我被调用了...")
def __del__(self):
print("我是__del__方法，我被调用了...")


>>> a = test()
我是__init__方法，我被调用了...
>>> b = a
>>> c = b
>>> del c  #内置的魔法方法不是在发生del的时候就会引用__del__方法
>>> del b
>>> del a  #在所有的引用都删除掉后或者程序退出，或者删除的时候才会调用__del__方法
我是__del__方法，我被调用了...


__call__(self[, args...]) 允许一个类的实例像函数一样被调用：x(a, b) 调用 x.__call__(a, b)
__len__(self) 定义当被 len() 调用时的行为
__repr__(self) 定义当被 repr() 调用时的行为
__str__(self) 定义当被 str() 调用时的行为
__bytes__(self) 定义当被 bytes() 调用时的行为
__hash__(self) 定义当被 hash() 调用时的行为
__bool__(self) 定义当被 bool() 调用时的行为，应该返回 True 或 False
__format__(self, format_spec) 定义当被 format() 调用时的行为
有关属性
__getattr__(self, name) 定义当用户试图获取一个不存在的属性时的行为
__getattribute__(self, name) 定义当该类的属性被访问时的行为
__setattr__(self, name, value) 定义当一个属性被设置时的行为
__delattr__(self, name) 定义当一个属性被删除时的行为
__dir__(self) 定义当 dir() 被调用时的行为
__get__(self, instance, owner) 定义当描述符的值被取得时的行为
__set__(self, instance, value) 定义当描述符的值被改变时的行为
__delete__(self, instance) 定义当描述符的值被删除时的行为
比较操作符
__lt__(self, other) 定义小于号的行为：x < y 调用 x.__lt__(y)
__le__(self, other) 定义小于等于号的行为：x <= y 调用 x.__le__(y)
__eq__(self, other) 定义等于号的行为：x == y 调用 x.__eq__(y)
__ne__(self, other) 定义不等号的行为：x != y 调用 x.__ne__(y)
__gt__(self, other) 定义大于号的行为：x > y 调用 x.__gt__(y)
__ge__(self, other) 定义大于等于号的行为：x >= y 调用 x.__ge__(y)


042魔法方法：算术运算
工厂函数，（在python2.2后把int,float,string,list,property等内置函数转化成工厂函数）即类对象
>>> type(len)  #这是一个内置函数或方法
<class 'builtin_function_or_method'>
>>> type(int)  #这个和下面的这个定义类是一个类型，都是类对象
<class 'type'>
>>> class test:
pass


>>> type(test)
<class 'type'>


>>> a = int('123')  #以前是调用int函数将'123'转换成123，然后返回整形的123，现在是实例化int类对象，返回int实例化对象
>>> b = int('456')
>>> a
123
>>> b
456
>>> a + b
579
算术运算符
__add__(self, other)          #定义加法的行为：+
__sub__(self, other) #定义减法的行为：—
__mul__(self, other) #定义乘法的行为：*
__truediv__(self, other) #定义真除法的行为：/
__floordiv__(self, other) #定义整数除法的行为：//
__mod__(self, other) #定义取模算法的行为：%
__divmod__(self, other) #定义当被divmod()调用时的行为:(self//other,a%b)
__pow__(self, other[, ...]) #定义当被power()调用或**运算时的行为
__lshift__(self, other) #定义按位左移位的行为：<<
__rshift__(self, other) #定义按位右移位的行为：>>
__and__(self, other) #定义按位与操作的行为：&
__xor__(self, other) #定义按位或操作的行为：^
__or__(self, other) #定义按位或操作的行为：|


>>> class New_int(int):  #这个实例化对象是将__add__方法和__sub__方法相减
def __add__(self, other):
return int.__sub__(self, other)
def __sub__(self, other):
return int.__add__(self, other)


>>> a = New_int(3)
>>> b = New_int(5)
>>> a
3
>>> b
5
>>> a + b
-2
>>> a - b
8


043魔法方法：算术运算2
反运算
__radd__(self, other)       #与上方相同，当左操作数不支持相应的操作时被调用
__rsub__(self, other)       #与上方相同，当左操作数不支持相应的操作时被调用
__rmul__(self, other)       #与上方相同，当左操作数不支持相应的操作时被调用
__rtruediv__(self, other)   #与上方相同，当左操作数不支持相应的操作时被调用
__rfloordiv__(self, other)  #与上方相同，当左操作数不支持相应的操作时被调用
__rmod__(self, other)       #与上方相同，当左操作数不支持相应的操作时被调用
__rdivmod__(self, other)    #与上方相同，当左操作数不支持相应的操作时被调用
__rpow__(self, other)       #与上方相同，当左操作数不支持相应的操作时被调用
__rlshift__(self, other)    #与上方相同，当左操作数不支持相应的操作时被调用
__rrshift__(self, other)    #与上方相同，当左操作数不支持相应的操作时被调用
__rand__(self, other)       #与上方相同，当左操作数不支持相应的操作时被调用
__rxor__(self, other)       #与上方相同，当左操作数不支持相应的操作时被调用
__ror__(self, other)        #与上方相同，当左操作数不支持相应的操作时被调用
增量赋值运算
__iadd__(self, other)           #定义赋值加法的行为：+=
__isub__(self, other)           #定义赋值减法的行为：-=
__imul__(self, other)           #定义赋值乘法的行为：*=
__itruediv__(self, other)       #定义赋值真除法的行为：/=
__ifloordiv__(self, other)      #定义赋值整数除法的行为：//=
__imod__(self, other)           #定义赋值取模算法的行为：%=
__ipow__(self, other[, modulo]) #定义赋值幂运算的行为：**=
__ilshift__(self, other)        #定义赋值按位左移位的行为：<<=
__irshift__(self, other)        #定义赋值按位右移位的行为：>>=
__iand__(self, other)           #定义赋值按位与操作的行为：&=
__ixor__(self, other)           #定义赋值按位异或操作的行为：^=
__ior__(self, other)            #定义赋值按位或操作的行为：|=
一元操作符(只对一个表达式执行操作，该表达式可以是数值数据类型类别中的任何一种数据类型)
__pos__(self)     #定义正号的行为：+x
__neg__(self)     #定义负号的行为：-x
__abs__(self)     #定义当被 abs() 调用时的行为
__invert__(self)  #定义按位求反的行为：~x
  类型转换
__complex__(self)     #定义当被 complex() 调用时的行为需要返回恰当的值
__int__(self)         #定义当被 int() 调用时的行为需要返回恰当的值
__float__(self)       #定义当被 float() 调用时的行为需要返回恰当的值
__round__(self[, n])  #定义当被 round() 调用时的行为需要返回恰当的值
__index__(self)       #1. 当对象是被应用在切片表达式中时，实现整形强制转换
                      #2. 如果你定义了一个可能在切片时用到的定制的数值型,你应该定义 __index__
                      #3. 如果 __index__ 被定义，则 __int__ 也需要被定义，且返回相同的值
上下文管理with 语句
__enter__(self) #1. 定义当使用 with 语句时的初始化行为
                #2. __enter__ 的返回值被 with 语句的目标或者 as 后的名字绑定
__exit__(self, exc_type, exc_value, traceback)  #1. 定义当一个代码块被执行或者终止后上下文管理器应该做什么
                                                #2. 一般被用来处理异常，清除工作或者做一些代码块执行完毕之后的日常工作
容器类型
__len__(self)                 #定义当被 len() 调用时的行为返回容器中元素的个数
__getitem__(self, key)        #定义获取容器中指定元素的行为，相当于 self[key]
__setitem__(self, key, value) #定义设置容器中指定元素的行为，相当于 self[key] = value
__delitem__(self, key)        #定义删除容器中指定元素的行为，相当于 del self[key]
__iter__(self)                #定义当迭代容器中的元素的行为
__reversed__(self)            #定义当被 reversed() 调用时的行为
__contains__(self, item)      #定义当使用成员测试运算符in 或 not in时的行为


>>> class Nint(int):
def __radd__(self,other):
return int.__sub__(self,other)


>>> a = Nint(5)
>>> b = Nint(3)
>>> a + b   #运算顺序是实例化a然后调用调用工厂函数__add__方法，然后是实例化b,这个正常执行
8
>>> 1 + b   #由于前面的是数字1而不是实例化对象，当执行到+号的时候跳过，当执行到实例化b的时候，就反过来相加，调用工厂函数__radd__方法，但是该方法被改写成减法，所有变成3-1
2


>>> class Nint(int):
def __rsub__(self,other):
return int.__sub__(self,other)


>>> a = Nint(5)
>>> 3 - a   #由于前面的是数字3而不是实例化对象，当执行到-号的时候跳过，当执行到实例化a的时候，就反过来相减，调用工厂函数__rsub__方法，所有变成5-3
2


044魔法方法：简单定制
__str__方法，当需要用string类型打印输出的时候就会默认调用这个方法
>>> class A():
def __str__(self):
return "xxxxxxxxxxxxxx"


>>> 
>>> a = A()
>>> print(a)
xxxxxxxxxxxxxx
__repr__方法
>>> class B():
def __repr__(self):
return "xxxxxxxxxxxxxx"


>>> b = B()
>>> b
xxxxxxxxxxxxxx


计时器
import time as t


class MyTimer():
    def __init__(self):
        self.unit = ['年','月','天','小时','分钟','秒']
        self.prompt = "为开始计时！"
        self.lasted = []
        self.begin = 0  #这里的名字不要和下面定义的方法名字一样，不然会报TypeError错误，因为这里的start不是一个方法，只是一个int类型的数字，不能进行调用
        self.end = 0


    def __str__(self):
        return self.prompt  #如果直接执行实例化类要先初始化它一下，在__init__方法初始化一下就好


    __repr__ = __str__  #这种写法相当于把__str__方法直接赋值给__repr__


    #开始计时
    def __add__(self, othen):
        prompt = "总共运行了"
        result = []
        for index in range(6):
            result.append(self.lasted[index] + other.lasted[index])
            if result[index]:
                prompt += (str(result[index]) + self.unit[index])
        return prompt


    def start (self):
        self.begin = t.localtime()
        self.prompt = "提示：请先调用stop()停止计时！"
        print("计时开始...")


    #停止计时
    def stop (self):
        if not self.prompt:
            print("提示：请线调用start()进行计时！")
        else:
            self.end = t.localtime()
            self._calc()
            print("计时结束")


    #内部方法，计算运行时间
    def _calc(self):
        self.lasted = []
        self.prompt = "总共运行了"
        for index in range(6):
            self.lasted.append(self.end[index] - self.begin[index])
            if self.lasted[index]:
                self.prompt += (str(self.lasted[index]) + self.unit[index])


045魔法方法：属性访问
__getattr__(self, name)  #定义当用户试图获取一个不存在的属性时的行为
__getattribute__(self, name)  #定义当该类的属性被访问时的行为
__setattr__(self, name, value)  #定义当一个属性被设置时的行为
__delattr__(self, name)  #定义当一个属性被删除时的行为


>>> class X:
def __getattribute__(self, name):
print("getattribute")
return super().__getattribute__(name)
def __getattr__(self, name):
print("getattr")
def __setattr__(self, name, vaule):
print("setattr")
return super().__setattr__(name, vaule)
def __delattr__(self, name):
print("delattr")
return super().__delattr__(name)


>>> c = X()
>>> c.x
getattribute
getattr
>>> c.x = 1
setattr
>>> c.x   #这里就不会调用__getattr__方法了，因为__getattr__是试图获取一个不存在的树形时的行为，而__getattr__方法只要是属性访问时都会调用
getattribute
1
>>> del c.x
delattr


class Rectangle:
    def __init__(self, width=0, height=0):
        self.width = width
        self.height = height
    def __setattr__(self, name, value):
        if name == 'square':
            self.width = value
            self.height = value
        else:
            #self.name = value  #这样写会进入死循环
            super().__setattr__(name, value)  #推荐使用这个方法
            #self.__dict__[name] = value  #这个是第二种方法，参考下面的r1.__dict__方法
    def getArea(self):
        return self.width * self.height
F5运行后
>>> r1 = Rectangle(4, 5)
>>> r1.getArea()
20
>>> r1.square = 10
>>> r1.getArea()
100


>>> r1.__dict__
{'width': 4, 'height': 5}


046魔法方法：描述符（Property的原理）
描述符:将某种特殊类型的类的实例指派给另一个类的属性
特殊类是指至少要实现以下三个方法中的一个
__get__(self, instance, owner)  #用于访问属性，他返回属性的值
__set__(self, instance, value)  #将在属性分配(也叫做赋)操作中调用，不返回任何内容
__delete__(self, instance)  #控制删除操作，不返回任何内容


>>> class MyDecriptor:
def __get__(self, instance, owner):
print("getting...", self, instance, owner)
def __set__(self, instance, value):
print("setting...", self, instance, value)
def __delete__(self, instance):
print("deleting...", self, instance)



>>> class Test:
x = MyDecriptor()



>>> test = Test()
>>> test.x
getting... <__main__.MyDecriptor object at 0x000002412F4F6F98> <__main__.Test object at 0x000002412F44CE10> <class '__main__.Test'>
#打印四个东西，第一个正常打印，第二个是self即实例test的描述符类MyDecriptor，第三个是拥有者的类的实例，第四个就是拥有者本身，见如下
>>> test
<__main__.Test object at 0x000002412F44CE10>
>>> Test
<class '__main__.Test'>
>>> test.x = "X-man"  #同理上面参数对应的位置
setting... <__main__.MyDecriptor object at 0x000002412F4F6F98> <__main__.Test object at 0x000002412F44CE10> X-man
>>> del test.x  #同理上面参数对应的位置
deleting... <__main__.MyDecriptor object at 0x000002412F4F6F98> <__main__.Test object at 0x000002412F44CE10>


#实现property函数的小例子
>>> class MyProperty:
def __init__(self, fget=None, fset=None, fdel=None):
self.fget = fget
self.fset = fset
self.fdel = fdel
def __get__(self, instance, owner):
return self.fget(instance)
def __set__(self, instance, value):
self.fset(instance, value)
def __delete__(self, instance):  #这里的__delete__方法不能用del缩写的方法
self.fdel(instance)


>>> class C:
def __init__(self):
self._x = None
def getX(self):
return self._x
def setX(self, value):
self._x = value
def delX(self):
del self._x
x = MyProperty(getX, setX, delX)


>>> c = C()
>>> c.x = 'X-man'
>>> c.x
'X-man'
>>> c._x
'X-man'
>>> del c.x


摄氏度转换成华氏度 公式：（华氏度 = 摄氏度 * 1.8 + 32）
class Celsius:
    def __init__(self, value = 26.0):
        self.value = float(value)
    def __get__(self, instance, owner):
        return float(self.value)
    def __set__(self, instance, value):
        self.value = float(value)
class Fahrenheit:
    def __init__(self, value = 78.8):
        self.value = float(value)
    def __get__(self, instance, owner):
        return float(instance.cel * 1.8 + 32)  #华氏度 = 摄氏度 * 1.8 + 32
    def __set__(self, instance, value):
        instance.cel = (float(value)- 32) /1.8
class Temperature:
    cel = Celsius()
    fah = Fahrenheit()


运行结果
>>> temp = Temperature()
>>> temp.cel
26.0
>>> temp.cel = 30
>>> temp.fah
86.0
>>> temp.fah = 100
>>> temp.cel
37.77777777777778


047魔法方法：定制序列
协议(Protocols)与其他编程语言中的接口很相似，它规定你哪些方法必须要定义。然而，在Python中的协议就是显得不那么正式。事实上，在Python中，协议更像是一种指南
如果说你希望定制的容器是不可变的话，你只须要定义__len__()和__getitem__()方法
如果你希望定制的容器是可变的话，除了__len__()和__gettiem__()方法，你还须要定义__setitem__()和__delitem__()两个方法
__len__(self)                 #定义当被 len() 调用时的行为返回容器中元素的个数
__getitem__(self, key)        #定义获取容器中指定元素的行为，相当于 self[key]
__setitem__(self, key, value) #定义设置容器中指定元素的行为，相当于 self[key] = value
__delitem__(self, key)        #定义删除容器中指定元素的行为，相当于 del self[key]
__iter__(self)                #定义当迭代容器中的元素的行为
__reversed__(self)            #定义当被 reversed() 调用时的行为
__contains__(self, item)      #定义当使用成员测试运算符in 或 not in时的行为


class CountList:
    def __init__(self, *args):
        self.values = [x for x in args]
        self.count = {}.fromkeys(range(len(self.values)), 0)
    def __len__(self):
        return len(self.values)
    def __getitem__(self, key):
        self.count[key] += 1
        return self.values[key]
运行结果
>>> c1 = CountList(1, 3, 5, 7, 9)
>>> c2 = CountList(2, 4, 6, 8, 10)
>>> c1[1]  #访问一次
3
>>> c2[1]  #访问一次
4
>>> c1[1] + c2[1]  #各访问一次
7
>>> c1.count  #实例c1的第一个元素访问了两次
{0: 0, 1: 2, 2: 0, 3: 0, 4: 0}
>>> c1[1]  #再访问一次
3
>>> c1.count  #实例c1的第一个元素访问了三次
{0: 0, 1: 3, 2: 0, 3: 0, 4: 0}


048魔法方法：迭代器
字符串就是个容器，也是个迭代器，for语句就是触发这个迭代的迭代功能，每次从容器里面一次拿一个数据
>>> for i in "FishC":
print(i)


F
i
s
h
C
同样也可以这样实现
>>> string = "FishC"
>>> it = iter(string)
>>> while True:
try:
each = next(it)
except StopIteration:
break
print(each)


F
i
s
h
C


>>> links = {'鱼C工作室':'http://www.fishc.com',\  #注意这里的\
'鱼C论坛':'http://bbs.fishc.com',\
'鱼C博客':'http://blog.fishc.com',\
'鱼C网店':'http://fishc.taobao.com'}
>>> for each in links:
print("%s -> %s" % (each, links[each]))


鱼C工作室 -> http://www.fishc.com
鱼C论坛 -> http://bbs.fishc.com
鱼C博客 -> http://blog.fishc.com
鱼C网店 -> http://fishc.taobao.com


迭代期提供的方法
iter()
__iter__()
next()  #当已经迭代到最后一个数据的时候，在调用next()方法的时候就会报StopIteration错误
__next__()


斐波那契数列
>>> class Fibs:
def __init__(self, n=10):
self.a = 0
self.b = 1
self.n = n
def __iter__(self):
return self
def __next__(self):
self.a, self.b = self.b, self.a + self.b  #相当于self.a = self.b和self.b = self.a + self.b
if self.a > self.n:
raise StopIteration
return self.a


>>> fibs = Fibs()
>>> for each in fibs:
print(each)


1
1
2
3
5
8
>>> fibs = Fibs(100)
>>> for each in fibs:
print(each)


1
1
2
3
5
8
13
21
34
55
89


049乱入：生成器(Generator)
迭代器是需要定义类和实现相关方法，
生成器是在普通的函数的基础上加上yield语句
协同程序就是可以运行的独立函数调用，函数可以暂停或者挂起，并在需要的时候从程序离开的地方继续或者重新开始
>>> def myGen():
print("生成器被调用!")
yield 1
yield 2


>>> mygen = myGen()
>>> next(mygen)
生成器被调用!
1
>>> next(mygen)
2
>>> next(mygen)
Traceback (most recent call last):
  File "<pyshell#87>", line 1, in <module>
    next(mygen)
StopIteration


>>> for each in myGen():
print(each)


生成器被调用!
1
2


上节课的斐波那契数列也可以这么写
>>> def libs():
a = 0
b = 1
while True:
a, b = b, a + b
yield a


>>> for each in libs():
if each > 100:
break
print(each)


1
1
2
3
5
8
13
21
34
55
89
>>> for each in libs():
if each > 100:
break
print(each, end = ' ')


1 1 2 3 5 8 13 21 34 55 89


列表推导式
>>> a = [i for i in range(100) if not(i % 2) and i % 3]  #求100以内的整数能被2整除，不能被3整除的
>>> a
[2, 4, 8, 10, 14, 16, 20, 22, 26, 28, 32, 34, 38, 40, 44, 46, 50, 52, 56, 58, 62, 64, 68, 70, 74, 76, 80, 82, 86, 88, 92, 94, 98]
字典推导式
>>> b = {i:i %2 == 0 for i in range(10)}  #通过字典的形式把0~9这十个数，显示出是否为偶数
>>> b
{0: True, 1: False, 2: True, 3: False, 4: True, 5: False, 6: True, 7: False, 8: True, 9: False}
集合推导式
>>> c = {i for i in [1, 1, 2, 3, 4, 5, 5, 6, 7, 8, 3, 2, 1]}
>>> c
{1, 2, 3, 4, 5, 6, 7, 8}
没有字符推导式，因为只要是“”括住了就是字符，就会如是打印出来
>>> d = "i for i in 'I love FishC.com'"  #字符串里面嵌套字符当外层用的是"",里面用''
>>> d
"i for i in 'I love FishC.com'"
生成器推导式，也没有元组推导式，下面的写法是生成器推导式
>>> e = (i for i in range(10))
>>> e
<generator object <genexpr> at 0x015BD8D0>
>>> for each in e:
print(each)


0
1
2
3
4
5
6
7
8
9
生成器推导式例子，把整数100以内的不能被2整除的数加起来
>>> sum(i for i in range(100) if i % 2)
2500


有空阅读
http://bbs.fishc.com/thread-56023-1-1.html


050模块：模块就是程序
什么是模块
容器 -> 数据的封装
函数 -> 语句的封装
类 -> 方法和属性的封装
模块 -> 模块就是程序


新建一个*.py文件就是一个模块，同路径可以直接通过import模块名(不带后缀)就可以导入
然后可以通过
1.import 模块名 后“import的模块名.类名()”或者是“import的模块名.方法名()”调用
2.from 模块名 import 函数名  或者是函数名改成*，建议制定函数名
3.import 模块名 as 别名  #推荐使用这个方法


051模块：__name__='__main__'、搜索路径和包


__name__='__main__'
温度转换例子
def c2f(cel):
    fah = cel * 1.8 +32
    return fah
def f2c(fah):
    cel = (fah - 32) / 1.8
    return cel
def test():
    print("测试，0摄氏度 = %.2f华氏度" % c2f(0));
    print("测试，0华氏度 = %.2f摄氏度" % f2c(0));
if __name__=="__main__":  #这里是要判断这个test()方法要在程序中运行
    test()
    
>>> import TemperatureConversion as tc
>>> __name__   #主程序里面的__name__方法指的是当前主程序
'__main__'
>>> tc.__name__   #这里指的是导入的模块的名字
'TemperatureConversion'


搜索路径
python在import模块的时候需要路径搜索的过程
推荐模块放在'C:\\Python\\Python35-32\\lib\\site-packages'路径下
>>> import sys
>>> sys.path
['', 'C:\\Python\\Python35-32\\Lib\\idlelib', 'C:\\Python\\Python35-32\\python35.zip', 'C:\\Python\\Python35-32\\DLLs', 'C:\\Python\\Python35-32\\lib', 'C:\\Python\\Python35-32', 'C:\\Python\\Python35-32\\lib\\site-packages']
>>> sys.path.append("C:\\Users\\lijc\\Desktop")  #添加搜索路径
>>> sys.path
['', 'C:\\Python\\Python35-32\\Lib\\idlelib', 'C:\\Python\\Python35-32\\python35.zip', 'C:\\Python\\Python35-32\\DLLs', 'C:\\Python\\Python35-32\\lib', 'C:\\Python\\Python35-32', 'C:\\Python\\Python35-32\\lib\\site-packages', 'C:\\Users\\lijc\\Desktop']


包(package)
1.创建一个文件夹，用于存放相关的模块，文件夹的名字即包的名字
2.在文件夹中创建一个__init__.py的模块文件，内容可以为空
3.将相关的模块放入文件夹中


导入模块变成：
1.import 包名.模块名 后“import的包名.模块名.类名()”或者是“import的包名.模块名.方法名()”调用
2.from 包名.模块名 import 函数名  或者是函数名改成*，建议制定函数名
3.import 包名.模块名 as 别名  #推荐使用这个方法


052模块：像个极客一样去思考
>>> import timeit  #导入timeit模块
>>> timeit.__doc__  #查看文档内容
>>> print(timeit.__doc__)  #带文档格式的，更方便阅读
>>> dir(timeit)  #定义这个模块下面的变量，方法，函数
>>> timeit.__all__  #打印出所有能调用的方法，函数等
>>> from timeit import *  #这种方式只能导入用__all__属性能打印出来的方法，函数等
>>> timeit.__file__  #打印文件所在文件路径
'C:\\python\\lib\\timeit.py'
>>> help(timeit)  #帮助文档


pip list
查看已安装的包
把数据写入到excel
import xlwt
ws = xlwt.Workbook(encoding='utf-8').add_sheet('Sheet1')  #新建一个sheet页
ws.write()
ws.save('1111.xls')

来源： https://blog.csdn.net/m0_37085523/article/details/79509450