python学习笔记

（1）如何输出\字符：

可以使用原始字符：

str = r"C:\\place"+"\\" #\对\进行转义，使用原始字符，字符串最后一个字符不能是\（反斜杠）

print(str)  #结果为C:\\place\\

(2)猜数字游戏：知识点（while，if elif . 随机数）

import random
print('..............猜数字游戏.........')
temp = input("不妨猜一下我现在在想哪个数字（1~100），输入-1结束")#输入的是字符串
guess = int(temp)
flag = 1
count = 0
right = 0
while flag == 1 : #每次循环产生一个新的随机数
    a = random.randrange(1,100)
    count = 0 
    if guess == -1: #输入为-1的时候退出程序
        break
    while right == 0: #循环中不断让玩家猜数字，直到猜对
        if guess==a:
            if count<5:#在5次以内猜对
                print("卧槽，这么牛逼，你是我肚子里的蛔虫吗？%d\n" %count)
            print("猜对了，不过没有奖励哦，哇哈哈！")
            break
        elif guess > a:
            print("大了")
        elif guess < a:
            print("小了")
        count = count+1
        temp = input("再猜猜1~100")#输入的是字符串
        guess = int(temp)
    temp = input("不妨猜一下我现在在想哪个数字（1~100），输入-1结束")#输入的是字符串
    guess = int(temp)
        
print("game over")

（3）一些常用函数：int() , float() ,type(), len()长度:判断类型 isInstance

>>> a = "you"
>>> a
'you'
>>> type(a)
<class 'str'>
>>> isinstance(a,str)
True
>>> b = True
>>> b
True
>>> isinstance(b,bool)
True
>>> 

（4）Python常用操作符

+、-、*、**、//、/ 、%(取余数)

     先乘除后加减    

/：除以符号：注意，结果是正确的商，如 5/2 = 2.5

//：整除符号：5/2 = 2

**（幂运算）：类似^:如3**2=3^2= 9 ；

逻辑操作符：and 、or、not (python中没有类似C语言中的&&等）。

条件表达式（三元操作符）

x ,y = 4 , 5
if x < y :
    small = x
else:
    small = y

等价于：
small = x if x < y else y

 （5）断言

assert这个关键词成为断言，当这个关键词后面的条件为假的时候，程序自动崩溃并抛出AssertionErrord的异常。

assert 3 > 4

一般来说，我们可以用它在程序中插入检查点，当需要确保程序中的某一个条件为真才让程序正常工作的话，assert关键字就非常有用了。

（6）for循环（跟C 语言中的不太一样）与range()

for 目标 in  ：

循环体

>>> favourite = 'First'
>>> for i in favourite:
print(i, end=' ')



F i r s t 

>>> member = ['小甲鱼','小乌龟','小布丁','小不点']
>>> for each in member:
print(each ,len(each))



小甲鱼 3
小乌龟 3
小布丁 3
小不点 3

语法：range([start,] stop[, step=1])

step = 1默认间隔大小为1。

start默认为0

生成从start参数数值到stop的参数的值结束的数字序列。

>>> range(5)
range(0, 5)
>>> list(range(5))
[0, 1, 2, 3, 4]

>>> for i in range(5):
print(i)



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



2
3
4
5
6
7
8
>>> for i in range(1,11,2):
print(i)



1
3
5
7
9

（7）列表list(可以插入混合元素）

append添加一个元素

extend添加一个list扩展原来的list

insert在制定位置添加元素

remove删除元素（有重复元素时，只删除早出现那个元素）

>>> member
['小布丁', '小不点', '老大', '小红']
>>> member.append('老大')
>>> member
['小布丁', '小不点', '老大', '小红', '老大']
>>> member.remove('老大')
>>> member
['小布丁', '小不点', '小红', '老大']

del语句

pop

<pre name="code" class="python">>>> member = ['小甲鱼','小乌龟','小布丁','小不点']
>>> member
['小甲鱼', '小乌龟', '小布丁', '小不点']
>>> number = [ 1,2,3,4]
>>> number
[1, 2, 3, 4]
>>> mix = [ 1,'小乌龟' ,3.14, [1,2,5]]
>>> mix
[1, '小乌龟', 3.14, [1, 2, 5]]
>>> empty = []
>>> empty
[]
>>> member.append('大白')
>>> member
['小甲鱼', '小乌龟', '小布丁', '小不点', '大白']
>>> len(member)
5

>>> member.extend(['小红','小白'])
>>> member
['小甲鱼', '小乌龟', '小布丁', '小不点', '大白', '小红', '小白']

>>> member.insert(0,'老大')
>>> member
['老大', '小甲鱼', '小乌龟', '小布丁', '小不点', '大白', '小红', '小白']

>>> member[0]
'老大'
>>> #交换大白和老大的位置
>>> temp = member[0]
>>> member[0] = member[5]
>>> member[5] = temp
>>> member
['大白', '小甲鱼', '小乌龟', '小布丁', '小不点', '老大', '小红', '小白']

>>> member.remove('小甲鱼')>>> member['大白', '小乌龟', '小布丁', '小不点', '老大', '小红', '小白']>>> del member[1]   #del member删除整个个列表>>> member['大白', '小布丁', '小不点', '老大', '小红', '小白']

>>> name = member.pop()#尾部元素出栈>>> name'小白'>>> member['大白', '小布丁', '小不点', '老大', '小红']>>> name = member.pop(0)#制定索引出栈>>> name'大白'>>> member['小布丁', '小不点', '老大', '小红']

列表分片

>>> member['小布丁', '小不点', '老大', '小红']

>>> member[1:3]['小不点', '老大']>>> member[1:]['小不点', '老大', '小红']>>> member[:3]['小布丁', '小不点', '老大']>>> member[:]#列表的拷贝['小布丁', '小不点', '老大', '小红']>>> 

列表的操作符

>>> list1 = [123]>>> list2 = [234]>>> list1 > list2False>>> list1 = [123,456]>>> list2 = [234,123]>>> list1 > list2#列表的比较跟字符串比较类似False

>>> list3 = [123,456]>>> (list1 < list2) and ( list1==list3)True

>>> list4 = list1+list2#加号的对象必须相同>>> list4[123, 456, 234, 123]

>>> list3*=3>>> list3[123, 456, 123, 456, 123, 456]>>> list3*=5>>> list3[123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456]

>>> 123 in list1True

>>> list5 = [123,['小白','小明'],456]>>> '小白' in list5False>>> '小白' in list5[1]True>>> list5[1][1]'小明'

>>> dir(list)#查看l列表的函数操作['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']>>> help(list.count)#查看列表下的count函数的具体定义。Help on method_descriptor:count(...)    L.count(value) -> integer -- return number of occurrences of value

<span style="font-size:18px;"><pre name="code" class="python"><span style="font-size:18px;">>>> list3
[123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456]
>>> list3.count(123)#123元素出现的个数
15
>>> list3.index(123)#元素123第一次出现的位置索引
0
>>> list3.index(123,3,5)#元素123在索引【3,5】之间首次出现的索引位置
4
>>> list3.reverse()#列表反转
>>> list3
[456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123]
>>> list3.sort()#列表排序，默认从小到大
>>> list3
[123, 123, 123, 123, 123, 123, 123, 123, 123, 123, 123, 123, 123, 123, 123, 456, 456, 456, 456, 456, 456, 456, 456, 456, 456, 456, 456, 456, 456, 456]
>>> list4
[123, 456, 234, 123]
>>> list4.sort(reverse=True)#列表排序，从大到小
>>> list4
[456, 234, 123, 123]

>>> list6 = list4[:]#列表拷贝
>>> list6
[456, 234, 123, 123]
>>> list8 = list4 #list8指向list4所以list8跟list4的内容一样
>>> list4.reverse()
>>> list4
[123, 123, 234, 456]
>>> list6
[456, 234, 123, 123]
>>> list8
[123, 123, 234, 456]
>>> </span></span>

</pre><pre name="code" class="python"><span style="font-size:18px;">
</span>

<span style="font-size:18px;">(8)元组：戴上枷锁的列表 （最大的区别是元祖不能修改）</span>

<span style="font-size:18px;">>>> tuple1 = ( 3,4,5)
>>> tuple1
(3, 4, 5)
>>> tuple2 = 1,2,3 #元组的创建，关键是逗号
>>> tuple2
(1, 2, 3)
</span>

<span style="font-size:18px;">>>> temp = (1)
>>> type(temp)
<class 'int'>
</span>

<span style="font-size:18px;">>>> tuple1[2] = 4 #不允许修改
Traceback (most recent call last):
  File "<pyshell#6>", line 1, in <module>
    tuple1[2] = 4
TypeError: 'tuple' object does not support item assignment
</span>

<span style="font-size:18px;">
</span>

类似列表有：tuple1[:]元组拷贝   tuple1[:2]  tuple1[1:]切片

>>> temp = 1,
>>> temp1=()#空元组，类似list1=[]
>>> type(temp1)
<class 'tuple'>
>>> type(temp)

<class 'tuple'>

>>> 8*(8,)#元组
(8, 8, 8, 8, 8, 8, 8, 8)

>>> temp = ('小乌龟','小笨蛋','小红','小白','小黑','小辉')#经过下面的操作后，temp不再指向这个数据，回收机制会回收。此时temp类似C语言指针。
>>> temp = temp[:3] + ('我来也',)+temp[3:]
>>> temp
('小乌龟', '小笨蛋', '小红', '我来也', '小白', '小黑', '小辉')

（9）字符串：格式化

>>> '{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 {1}.{a}'.format("I","FishC",a="com")#位置参数和关键字参数混合（位置参数必须在关键字参数前
'I love FishC.com'
>>> '{{0}}'.format("不打印")
'{0}'

>>> '{0:.1f}{1}'.format(27.658,'GB')#27.658小数位保留1位
'27.7GB'

>>> '{0:5.1f}{1}'.format(27.658,'GB')#27.658小数位保留一位，总的长度为5（ 27.7）数字前面有一个空格
' 27.7GB'

>>> '%c' %98
'b'
>>> '%c %c %c' %(97,98,99) #字符参数
'a b c'
>>> '%s' %'I love you' #字符串输出
'I love you'
>>> '%+d' %5#在正整数前显示加号
'+5'

>>> '%#o' %10#10在八进制中表示的值,并显示前缀（#的作用）
'0o12'

>>> '%05d' %5 #5在十进制中的值，长度为5，不够的在左边补0
'00005'
>>> '%-05d' %5 #5在十进制中的值，长度为5，不够的在右边补空格，不会出现50000这种情况。
'5    '

（10）序列和元组，以及一些函数操作

>>> help(list)
Help on class list in module builtins:


class list(object)
 |  list() -> new empty list
 |  list(iterable) -> new list initialized from iterable's items #迭代

>>> a=list()
>>> a#空列表
[]
>>> b = "I love you"
>>> b = list(b)#用迭代，将b中的每个字符作为一个元素。
>>> b
['I', ' ', 'l', 'o', 'v', 'e', ' ', 'y', 'o', 'u']

>>> c =[1,2,3]
>>> c = tuple(c)#将列表转换为元组
>>> c
(1, 2, 3)
>>> c = list(c)#将元组转换为列表
>>> c
[1, 2, 3]

>>> b = 'I love you'
>>> b
'I love you'
>>> b = list(b)
>>> b
['I', ' ', 'l', 'o', 'v', 'e', ' ', 'y', 'o', 'u']
>>> max(b)#求迭代或者序列中的最大值
'y'
>>> min(b)#求迭代或者序列中的最小值
' '

>>> a = [1,2,3,-55,66,4]
>>> sum(a)#求迭代或者序列中的值的和
21
>>> sum(a,11)#求迭代或者序列中的值的和再加上第二个参数的值。
32

>>> a
[1, 2, 3, -55, 66, 4]
>>> sorted(a)#默认从小到大排序，返回一个列表
[-55, 1, 2, 3, 4, 66]

>>> reversed(a)#返回一个迭代器
<list_reverseiterator object at 0x023B3430>
>>> list(reversed(a))
[4, 66, -55, 3, 2, 1]

>>> enumerate(a)#返回一个迭代器
<enumerate object at 0x022E9580>
>>> list(enumerate(a)) #每个元组的第一个数数为原来a中的数字索引，第二个为数字。
[(0, 1), (1, 2), (2, 3), (3, -55), (4, 66), (5, 4)]

>>> x = [1,2,3,4,5]
>>> y = [3,4,5]
>>> zip(x,y)
<zip object at 0x022E2DF0>
>>> list(zip(x,y))#将x和y中分别取一个数组合成新的元组
[(1, 3), (2, 4), (3, 5)]

（11）函数定义，调用，返回值等。

>>> def MyFirstFunction():
print("这是我创建的第一个函数")
>>> MyFirstFunction()
这是我创建的第一个函数

>>> def MyFunction1(name):#一个参数
print(name+",I love you")

>>> MyFunction1("nana")
nana,I love you

>>> def add(num1,num2):#两个参数
result = num1+num2
print(result)



>>> add(3,5)
8

>>> def add(num1,num2):
return (num1+num2)#返回值


>>> print(add(2,3))
5
>>> 

函数文档

>>> def MyFunction(name):
'函数定义过程中的name是形参'
#因为它只是一个形式，表示占据一个参数的位置
print("传递进来的"+name+"叫实参,因为它是具体的参数值！")



>>> MyFunction("大白")
传递进来的大白叫实参,因为它是具体的参数值！
>>> MyFunction.__doc__  #参看函数文档
'函数定义过程中的name是形参'
>>> help(MyFunction)
Help on function MyFunction in module __main__:


MyFunction(name)
    函数定义过程中的name是形参

>>> def SaySometing(name="大白",words="我是你的健康助理"):#参数的默认值
print(name+" : " + words)



>>> SaySometing()
大白 : 我是你的健康助理
>>> SaySometing("你好","小明")
你好 : 小明
>>> SaySometing(words="你好",name="小明")#关键字参数，防止因为参数顺序产生意想不到的结果
小明 : 你好

>>> def test(*params):#收集参数，类似C语言中的指针数组）
print("参数的长度是",len(params))
print("第二个参数为:",params[1])



>>> test(1,2,"you",33)
参数的长度是 4
第二个参数为: 2
>>> def test(*params,exp):
print("参数的长度是",len(params),exp)
print("第二个参数为:",params[1])



>>> test("yy","zz",33,exp=3)#必须使用关键字参数传入exp的值，否则函数把所有输入的参数都给params
参数的长度是 3 3
第二个参数为: zz

函数的可以通过返回一个列表或者元组，返回多个值。

>>> def manyReturn():
return [3,"you",35]


>>> list1 = manyReturn();
>>> list1[1]
'you'

>>> def function1():
count = 5;
print("function1")



>>> function1()
function1
>>> print(count)
4
>>> def function2():
global count  #函数体内修改全局变量
count =10
print("function2")



>>> function2()
function2
>>> print(count)
10

>>> def fun1():#在fun1中定义fun2. 在fun1函数体外不能调用fun2.
print("fun1正在被调用")
def fun2():
print("fun2正在被调用")
fun2()#在fun1中调用fun2



>>> fun1()
fun1正在被调用
fun2正在被调用

>>> def funX(x):#funY为闭包
def funY(y):
return x*y
return funY #将函数对象直接返回
>>> funX(5)(9)
45

>>> def fun1():
x = 5
def fun2():
x*=x;#相当于没有定义的局部变量，跟上面的x不是同一个对象
return x;
return fun2()


>>> fun1()
Traceback (most recent call last):
  File "<pyshell#145>", line 1, in <module>
    fun1()
  File "<pyshell#144>", line 6, in fun1
    return fun2()
  File "<pyshell#144>", line 4, in fun2
    x*=x;#相当于没有定义的局部变量，跟上面的x不是同一个对象
UnboundLocalError: local variable 'x' referenced before assignment
>>> def fun1():
x = 5
def fun2():
nonlocal x #强制把x声明为不是局部变量，此时就跟上面的x相同。
x*=x;
return x;
return fun2()


>>> fun1()
25

（12）lambda的使用：使用lambda可以省下定义函数的过程；

过滤器filter的使用

>>> def ds(x):
return 2*x+1


>>> ds(5)
11
>>> lambda x: 2*x+1
<function <lambda> at 0x02314738>
>>> g = lambda x: 2*x+1
>>> g(5)
11
>>> def add(x,y):
return x+y

>>> add(3,4)
7
>>> g = lambda x,y : x+y
>>> g(3,4)
7

过滤器filter

>>> filter(None,[1,0,33,True ,False])#第一个参数为None时，过滤掉后面迭代器中值为False的数
<filter object at 0x01ED31D0>
>>> list(filter(None,[1,0,33,True ,False]))
[1, 33, True]
>>> g = lambda x :x%2
>>> list(filter(g,range(12)))#第一个为函数时，过滤点第二个参数（迭代器）中代入函数后的求得的值为False的数。
[1, 3, 5, 7, 9, 11]

映射map

将第二个参数的值代入函数中，将返回值作为一个集合的元素。

>>>list(map(g,range(12)))
[0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1]
>>> g1 = lambda x : x*2
>>> list(map(g1,range(12)))
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22]

（13）递归：

>>> def recursion():
return recursion()#无限递归下去，会耗尽内存

按ctrl+C可以强制退出，Python默认递归的深度是100.

设置递归的深度方法：

>>> import sys
>>> sys.setrecursionlimit(1000)#设置递归深度为1000

求阶乘

非递归方法：

>>> def factorial(n):
result = n ;
for i in range(1,n):
result*=i
return result

递归方式：#当n大一点时，由于栈溢出，程序就会崩溃。

>>> def fac(n):
if n==1:
return 1
else:
return n*fac(n-1)



>>> fac(5)
120

兔子产子（斐波那数列）：

迭代方式：

>>> def fab1(n):
n1=1
n2=1
n3 =1
if n<1:
return -1
while(n-2)>0:
n3=n2+n1
n1=n2
n2=n3
n-=1
return n3


>>> fab1(20)

>>>6765

递归方式：#n>=35的时候就运行很慢了

>>> def fab(n):
if n<0 :
return -1
if (n==1) or (n==2):
return 1
else :
return fab(n-1)+fab(n-2)



>>> fab(20)
6765

输出前n个斐波那数（fab(1)=fab(2)=1)

>>> def allFab(n):
fabList=list()
fabList.insert(0,1)
fabList.insert(1,1)
def fab2(n2):#内部函数
if n2<1:
return -1
nonlocal fabList#非局部变量，可以访问allFab中的fabList.
if(n2<=len(fabList)):
return fabList[n2-1]
return fab2(n2-1)+fab2(n2-2)
for i in range(1,n+1):
if i < 3:
print(i,fabList[i-1])
continue
temp = fab2(i)
fabList.insert(i-1,temp)
print(i,fabList[i-1])



>>> allFab(20)
1 1
2 1
3 2
4 3
5 5
6 8
7 13
8 21
9 34
10 55
11 89
12 144
13 233
14 377
15 610
16 987
17 1597
18 2584
19 4181
20 6765

递归求解汉诺塔问题：

hanoi.py

<span style="font-size:18px;">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上
        #将y上的n-1个盘子移动到z上
        hanoi(n-1,y,x,z)
n = 1
while n:
    
    n = int(input("请输入盘子的个数,输入0退出"))
    if n==0:
        print("Game Over!")
        break
    hanoi(n,"x","y","z")</span>

（14）字典和集合

字典是Python中的映射类型，字典中的元素顺序不是按插入的顺序。

>>> dict1 = {'李宁':'一切即有可能' , '耐克':'Just do it' , '阿迪达斯': 'Impossible is nothing'}
>>> dict1['耐克']
'Just do it'
>>> dict2 = dict( ( ('F',70) , ('i' ,105) , ('s',115) , ('h',104) ,('C',67) ) )
>>> dict2['F']
70

>>> dict2
{'h': 104, 'i': 105, 'F': 70, 's': 115, 'C': 67}

>>> dict3 = dict(天使= '让世界更美好' , 恶魔= '让世界更丑陋')#关键字赋值
>>> dict3
{'天使': '让世界更美好', '恶魔': '让世界更丑陋'}
>>> dict3['天使'] = '天使的笑容是最阳光的' #存在天使关键词则替换
>>> dict3
{'天使': '天使的笑容是最阳光的', '恶魔': '让世界更丑陋'}
>>> dict3['爱迪生']= '发明专家'#不存在爱迪生关键词则添加
>>> dict3
{'天使': '天使的笑容是最阳光的', '爱迪生': '发明专家', '恶魔': '让世界更丑陋'}   

字典中的函数方法：

fromkeys(iterable, value=None, /) method of builtins.type instance
    Returns a new dict with keys from iterable and values equal to value.

>>> dict4 = dict.fromkeys((1,2,3))
>>> dict4
{1: None, 2: None, 3: None}
>>> dict4 = dict.fromkeys( (1,2,3), ('香茗'))
>>> dict4
{1: '香茗', 2: '香茗', 3: '香茗'}
>>> dict4 = dict.fromkeys( (1,2,3), '香茗')
>>> dict4
{1: '香茗', 2: '香茗', 3: '香茗'}
>>> dict4 = dict.fromkeys( (1,2,3), ('香茗','大白'))
>>> dict4
{1: ('香茗', '大白'), 2: ('香茗', '大白'), 3: ('香茗', '大白')}
>>> dict4 = dict.fromkeys( (1,2,3), ('香茗','大白','小白'))
>>> dict4
{1: ('香茗', '大白', '小白'), 2: ('香茗', '大白', '小白'), 3: ('香茗', '大白', '小白')}

>>> dict4 = dict.fromkeys(range(1,33),'赞')
>>> for eachKey in dict4.keys():
print(eachKey,dict4[eachKey])#32个赞

>>> for eachValue in dict4.values():#字典的值集合
print(eachValue)

>>>for eachItem in dict4.items():#打印项
print(eachItem)

>>> 33 in dict4#判断32在不在dict4的key中
False
>>> 22 in dict4
True
>>> dict4.get(32,'key 不存在')#如果key=32存在，返回对应的值，否则返回第二个参数（'key 不存在'）
'赞'
>>> dict4.get(77,'key 不存在')
'key 不存在'
>>> 

注意：要使字典内容为空，要使用clear方法，不要用={}。否则可能会信息泄露。

>>> a = {}
>>> a ={'大白是':'健康助手'}
>>> b = a
>>> a
{'大白是': '健康助手'}
>>> b
{'大白是': '健康助手'}
>>> a={}

>>> id(a)
36722168
>>> id(b)
36722168
>>> a={} #a变为跟b不一样的对象。所以b的对象内容还是为原来a中的内容，不会被清空。
>>> id(a)
37300304
>>> b
{'大白是': '健康助手'}

>>> a ={'大白是':'健康助手'}
>>> b = a
>>> a.clear()
>>> b
{}
>>> a
{}

>>> c ={'大白是': '健康助手'}
>>> c1 = c.copy()#浅拷贝
>>> c1
{'大白是': '健康助手'}
>>> c2 = c
>>> c2['小白是']='一条狗'
>>> c
{'大白是': '健康助手', '小白是': '一条狗'}
>>> c1
{'大白是': '健康助手'}
>>> c2
{'大白是': '健康助手', '小白是': '一条狗'}

>>> c2
{'大白是': '健康助手', '小白是': '一条狗'}
>>> c2.pop('大白是')#根据key的值弹出对应元素
'健康助手'
>>> c2
{'小白是': '一条狗'}
>>> c2.popitem()#弹出一个元素
('小白是', '一条狗')
>>> c2
{}
>>> c2.setdefault("苹果")#插入键值对，默认值为None
>>> c2.setdefault('葡萄','有的是酸的哦')
'有的是酸的哦'
>>> c2
{'苹果': None, '葡萄': '有的是酸的哦'}

>>> c4 = {"apple":" It is nice " ,"orange" : "fruit"}
>>> c2.update(c4)#将c4的值插入c2中。
>>> c2
{'苹果': None, '葡萄': '有的是酸的哦', 'orange': 'fruit', 'apple': ' It is nice '}
>>> 

集合

>>> num = {}
>>> type(num)
<class 'dict'>
>>> num2 ={1,3,5,7,9}
>>> type(num2)
<class 'set'>
>>> num2 = {1,2,2,3,4,3,5,6}#集合中的元素是唯一的，会自动删除重复元素
>>> num2
{1, 2, 3, 4, 5, 6}
>>> set1 = set([1,222,3,3,4,4,5,6])
>>> set1
{1, 3, 4, 5, 6, 222}

>>> num1 = [1,2,3,4,5,56,6,6,7,0]
>>> set(num1)
{0, 1, 2, 3, 4, 5, 6, 7, 56}#set会把序列中的元素去重复后排序形成set集合

>>> set2.add(4)#集合的添加
>>> set2
{0, 1, 2, 4, 55}
>>> set2.remove(55)#集合的删除
>>> set2
{0, 1, 2, 4}
>>> 

>>> frozenSet = frozenset([1,2,2,1.0,5])#不可修改的集合
>>> frozenSet
frozenset({1, 2, 5})

(15)文件

<span style="font-size:18px;"><span style="color:#cc0000;">>>> f = open("d:\\夫君，求断案.txt","rb")#\进行转义</span>
>>> f.seek(5,0)<span style="color:#990000;">#第二个参数位0时，代表从文件开始出移动指针，为1时，从当前位置，为2时，从文件末尾（后两种参数值只能在以二进制打开的模式中）</span>
5
>>> f.seek(5,1)
10
>>> f.read(5)
b'\xd4\xdahtt'
>>> f.seek(-10,1)
5
>>> f.seek(-5,1)
0
>>> f.read(5)#读取五个字符
b'\xd0\xa1\xcb\xb5\xcf'
<span style="color:#cc0000;">>>> f.tell()#返回当前文件指针的位置（字节单位)中文一个字符为两个字节</span>
5
>>> f.seek(0,0)
0
>>> f.read(5)
b'\xd0\xa1\xcb\xb5\xcf'
>>> f.close()
</span>

<span style="font-size:18px;">>>> f = open("d:\\夫君，求断案.txt")
>>> list(f)<span style="color:#990000;">#将文件转换为序列，不过文件稍微大点，转化就很慢，甚至程序卡死</span>
['小说下载尽在http://www.txt99.cc\n',（后面内容省略）
>>> f.seek(0,0)
0
>>> f.readline()#读取一行
'小说下载尽在http://www.txt99.cc\n'
>>> lines = list(f)
>>> for line in lines:
	print(line)<span style="background-color: rgb(204, 0, 0);">#打印出一行，不过效率很低</span>

晋江VIP2015-03-07完结
（后面内容省略）

>>> f.seek(0,0)
0
>>> for each_line in f:<span style="color:#cc0000;">#官方推荐使用，读取文件中的每一行</span>
	print(each_line)	
小说下载尽在http://www.txt99.cc
（后面内容省略）

>>> f.close()</span>

>>> f.close()
>>> fw = open("d:\\1.txt","w")
>>> fw.write("I like it!")#写入文件
10
>>> fw.close()
>>> 

①用文件操作完的一个文件处理。

任务：将文件（record.txt)中的数据进行分割并按如下规则保存起来。

i. boy 的对话单独保存为boy_*.txt(去掉boy:）

ii.girl的对话单独保存为girl_*.txt(去掉girl:）

iii.文本中有三段对话，对话间用"======"分割，本别保存为

boy_1.txt,girl_1.txt以此类推（文件中不包含"======"分割）

record.txt

boy:hello!
girl:hi!
boy:where are going ?
girl:Just go shopping.
=============================================================
boy:听说你生病了？
girl:是啊，不过现在好了。
girl:昨天考试怎么样呀？
boy:数学题目不会做呀！
==============================================================
boy:你今天看起来真漂亮啊
girl:是吗？
boy:必须是呀，哪里买的裙子呀？
girl:我妈妈送我的生日礼物呢，我也不知道哪里买的。

<span style="font-size:18px;"><span style="font-size:18px;"></span>

<span style="font-size:18px;">import os
file_root_path = "d:"+os.sep
record_file = file_root_path+"record.txt"
def save_file(boy,girl,count):#写入文件操作
    file_name_boy = file_root_path+'boy_'+str(count)+'.txt'
    file_name_girl = file_root_path+'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.clear()
    girl.clear()

def split_file(file_name):#分割文件内容并作处理写入文件
        f = open(file_name)
        boy = []
        girl = []
        count = 1
        for each_line in f:
            if each_line =="\n":#不处理空行
                continue
            if each_line[:6]!='======':
                (role,line_spoken)= each_line.split(':',1)#字符串 分割函数,冒号都为英文冒号
                if role =='boy':
                    boy.append(line_spoken)
                if role =='girl':
                    girl.append(line_spoken)
            else:
                save_file(boy,girl,count)
                count+=1

        save_file(boy,girl,count)
        count+=1
        f.close()

split_file(record_file)</span><strong>
</strong>
    </span>

（16）文件中的OS模块和os.path模块参见如下文档

点击打开链接

>>> import os
>>> os.getcwd()#返回当前工作目录
'C:\\Python34'
>>> sep = os.sep#获取系统分隔符
>>> os.chdir("d:"+sep)#改变工作目录
>>> os.getcwd()
'd:\\'
>>> os.listdir('.')#列举目录中的文件名，'.'表示当前目录,'..'表示上一级目录

（17）pickle泡菜：

>>> import pickle#泡菜，可以将所有对象转化成对应的二进制文件存储。并且可以方便的将二进制数据转换出对象。

import pickle
list1 = [123,3.14,'大白',['another list']]
pickle_file = open('list1.pkl','wb')
pickle.dump(list1,pickle_file)#将list1写入文件
pickle_file.close()
pickle_file = open('list1.pkl','rb')
list2 = pickle.load(pickle_file)<strong><span style="font-size:18px;"><span style="color:#cc0000;">#将二进制文件换成列表。</span></span></strong>
pickle_file.close()
print(list2)

</pre><pre name="code" class="python"><pre name="code" class="python"><strong><span style="font-size:24px;">（18）异常处理：</span></strong>

</pre><pre name="code" class="python"><pre name="code" class="python"><span style="font-size:18px;">
<strong>##①语法：try:
##           检测范围
##       except Exception[as reason]:
##           出现异常（Exception）后的处理代码
##       finally:
##           无论如何都活被执行的代码
##一个try可以用多个exception捕获，一个except可以同时捕获多种异常
</strong>

##def my_except():
##   #如果f声明为全局变量，可能在函数内部改变f的值
##    file_name = input("请输入需要打开的文件名：")#文件名包含后缀如：README.txt.单独输入名字会出错
##    f = None
##    def read():
##        try:
##            nonlocal f
##            f = open(file_name)#maybe OSError
##        ##    sum ='1'+1#TypeError
##        ##    int('abc')#ValueError
##            print("文件的内容是：")
##            for each_line in f:
##                print(each_line)
##        except OSError as reason:
##            print("文件打开出错T_T\n错误的原因是："+str(reason))
##        except (TypeError,ValueError) as reason:#可以同时捕获多种异常
##            print("出错啦\n错误的原因是："+str(reason))
##        finally:
##            nonlocal f
##            if(f!=None):
##                f.close()
##    read()
####    print(f.closed)
####    f.close()
##    
##f = 1
##print(f)
##my_except()
##print(f)

<span style="color:#ff0000;">try:</span>
    file_name = input("请输入需要打开的文件名：")#文件名包含后缀如：README.txt.单独输入名字会出错
    f = open(file_name)#maybe OSError <strong><span style="color:#cc0000;">下面的try、finally都可访问到f</span></strong>
    <span style="color:#ff6600;">try:</span>
    
##        sum ='1'+1#TypeError
##        int('abc')#ValueError
        print("文件的内容是：")
        for each_line in f:
            print(each_line)
    except OSError as reason:
        print("出错T_T\n错误的原因是："+str(reason))
    except (TypeError,ValueError) as reason:#可以同时捕获多种异常
        print("出错啦\n错误的原因是："+str(reason))
    finally:
        f.close()#关闭文件
except OSError as reason:
    print("文件打开出错T_T\n错误的原因是："+str(reason))

raise Exception("人为的抛出错误")
##使用raise抛出异常
##当程序出现错误，python会自动引发异常，也可以通过raise显示地引发异常。一旦执行了raise语句，raise后面的语句将不能执行。</span>

</pre><pre name="code" class="python">

(19）else和with语句（with语句会自动关闭文件）

try:
    print(int('123'))
except ValueError as reason:
    print("出错啦"+str(reason))
else:
    print("没有任何异常")#else 可以和try一起用，此时try相当于if


##try:
##    f = open("data8.txt")
##    for each_line in f:
##        print(each_line)
##except OSError as reason:
##    print("出错啦"+str(reason))
##finally:
##    f.close()


try:
    with open("data1.txt") as f1:#with 会关注这个文件，并在合适的时候去关闭它。
        for each_line in f1:
            print(each_line)
    print(f1.closed)
except OSError as reason:
    print("出错啦"+str(reason))

(20)类和对象

class Ball:
    __money = 100
    #默认方法和变量都是共有的
    #__name:在变量前加两个下横线，就成为私有了。其实__变量名是转化为：_类名__变量名
    #__init__(self):#类似C++构造函数,可以有除了self的参数。
    def __init__(self,name):
        self.name = name
        
    #def setName(self,name):#self类似C++中this
        #self.name = name
    def kick(self):
        print('我叫%s,该死 的，谁踢我...' % self.name)
a = Ball('乌龟')
#a.setName('乌龟')
a.kick()


b = Ball('有钱人')
#print(b.money)私有变量访问出错
#print(b.__money)




##类的继承和多态
#子类中定义跟父类中同名的方法会覆盖父类的方法。
#类中变量名跟方法名同名，会覆盖掉方法的申明。


class Parent:
    def hello(self):
        print('正在调用父类的方法')




class Child(Parent):#括号内的类名就是继承的类名。可以多继承，即里面有多个类名。
    #pass 跳过定义。
    def hello(self):
        print('正在调用子类的方法')




c = Child()
c.hello()
p = Parent()
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):
    def move(self):
        print('我的位置是:',self.x,self.y,'我不移动')


class Garp(Fish):
    pass
class Salmon(Fish):
    pass


class Shark(Fish):
    def __init__(self):#覆盖父类的方法，所以原来父类中变量都访问不了
       #解决方法1： Fish.__init__(self)此时self是Shark对象。
       #解决方法2：（要是多继承），这个方法更好
        super().__init__()#会去调用所有父类的__init__()方法
        self.hungry = True
    
    def eat(self):
        if self.hungry:
            print('吃货的梦想就是天天有好吃的')
            self.hungry = False
        else:
            print('吃不下了')


fish = Fish()
fish.move()


goldfish = GoldFish()
garp = Garp()
list1 = list()
list1.append(goldfish)
list1.append(garp)
for f in list1:
    print(f.move())
goldfish.move()


shark = Shark()
shark.eat()
shark.eat()
shark.move()




##多重继承
class Base1:
    def foo1(self):
        print('我是foo1')


class Base2:
    def foo2(self):
        print('我是foo2')


class C(Base1,Base2):
    pass


c =C()
c.foo1()
c.foo2()


#聚合，一个类中包含另外一个或几个其他的类作为变量。
#一个池塘，有鱼，乌龟等


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))




pool = Pool(19,30)
pool.print_num()






##########类、类对象和类实例


class C:####C.__dict__可以查看类C中的公有方法和属性。
    count = 0
    def print_count(self):
        print(self.count)
#a,b,c 都是实例对象。
a =C()
b =C()
c =C()
print('a'+str(a.count))
print('b'+str(b.count))
print('c'+str(c.count))




#C 是类对象
b.count = 10
c.count =  1
C.count = 111


print('a'+str(a.count))#a没有覆盖过类中的属性count所以跟C.count中值一样
print('b'+str(b.count))
print('c'+str(c.count))
print('a'+str(a.count))
print('b'+str(b.count))
print('c'+str(c.count))


##>>> a.__dict__
##{}
##>>> a.count =4
##>>> a.__dict__
##{'count': 4}
##a.__dict__
##b.__dict__
##c.__dict__
#del C可以删除类C ,删除后类C就没有定义了。

（21）与类有关的一些内置函数（BIF）

#跟类相关的一些内置函数（BIF）


#issubclass(class ,classinfo)宽松检查，自己也是自己的子类
class A:
    pass
class B(A):
    pass


print('B是A的子类吗',issubclass(B,A))


#isinstance(object,classinfo)如果第一个参数不是对象，永远返回false.,判断是否是实例对象


a = A()
print('a是A的实例对象吗',isinstance(a,A))
print('a是C的实例对象吗',isinstance(a,C))
print('a是A,B,C中的实例对象吗',isinstance(a,(A,B,C)))


#hasattr(object,name) 判断对象是否包含指定的属性。


class C:
    def __init__(self,x=0):
        self.x=x


c1 =C()
print('c1中有x属性吗',hasattr(c1,'x'))
#getattr(object,name[,default])查询指定属性的值。
print('c1中x的值',getattr(c1,'x'))
print('c1中y的值',getattr(c1,'y','您所查询的属性不存在'))


#setattr(object,name,value) 指定属性不存在则新建一个属性
setattr(c1,'fish','鲨鱼')
print('c1中fish的值',getattr(c1,'fish','您所查询的属性不存在'))


#delattr(object,name)删除指定属性，属性不存在抛出异常


if hasattr(c1,'fish'):
    delattr(c1,'fish')
print('c1中fish的值',getattr(c1,'fish','您所查询的属性不存在'))


#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)


c1 =C()
print(c1.x)
c1.x=22
print(c1.x)
del c1.x
print('c1中size的值',getattr(c1,'size','您所查询的属性不存在'))

（21）类中的魔方方法：自动调用的方法

##python中的魔方方法：类中自动调用的方法




#__new__(cls[,...])类是先调用new方法后在调用init方法。一般不重写，继承父类时，要改变从父类里面的属性。
#比如继承str,将string变为大写
class CapStr(str):
    def __new__(cls,string):
        string = string.upper()
        return str.__new__(cls,string)
a = CapStr("I love you")
print(a)


#初始化方法__init__(self[,...])类似构造方法,返回值为空
class Rectangle:
    def __init__(self,x,y):
        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)
print('长方形周长为:',str(rect.getPeri()))
print('长方形面积为:',str(rect.getArea()))


#类似析构函数__def__(self)，所有类实例对象的引用被销毁时调用
class C:
    def __init__(self):
        print("我是__init__方法，我被调用了")
    def __del__(self):
        print("我是__del__方法，我被调用了。。。")


c1 = C()
c2=c1
c3 = c2
print("删除c3")
del c3
print("删除c2")
del c2
print("删除c1")
del c1

(22)魔法方法：运算

#类有关的算数运算
class New_int(int):
    def __add__(self,other):#重写类的加法操作
        return int.__sub__(self,other)
        #return self+other会发生无限递归。
    def __sub__(self,other):#重写减法操作
        return int.__add__(self,other)


a = New_int(3)
b = New_int(4)


print(a+b)
print(a-b)




class Try_int(int):
    def __add__(self,other):#重写类的加法操作
        return int(self)+int(other)
    def __sub__(self,other):#重写减法操作
        return int(self)-int(other)
    def __mul__(self,other):
        return int(self)*int(other)
a = Try_int(3)
b = Try_int(4)


print(a+b)
print(a-b)
print(a*b)

（23）魔法方法：属性访问

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:
            super().__setattr__(name,value)#推荐方法
            #也可以用这个方法，self.__dict__[name]=value
            #self.name = value会出现死循环，因为赋值操作会调用setattr.
    def getArea(self):
        return self.width*self.height
    

>>> g = Rectangle()
>>> g.getArea()
0
>>> g.square = 10
>>> g.getArea()
100
>>> g.width
10
>>> g.height
10
>>> 

（24）描述符：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):
        return self.fset(instance,value)
    def __delete__(self,instance):
        return 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'
print(c._x)
del c.x