初识Python第三天（二）

2.2 OrderedDict有序字典

 import collections
 dic = collections.OrderedDict()
 dic['k1'] = 'v1'
 dic['k2'] = 'v2'
 dic['k3'] = 'v3'
 print(dic)
 dic.move_to_end('k1')  #将'k1'放到字典末尾
 print(dic)
 
 #OrderedDict([('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3')])
 #OrderedDict([('k2', 'v2'), ('k3', 'v3'), ('k1', 'v1')])

move_to_end将指定元素放到最后

 import collections
 dic = collections.OrderedDict()
 dic['k1'] = 'v1'
 dic['k2'] = 'v2'
 dic['k3'] = 'v3'
 print(dic
 
 dic.popitem()
 print(dic)
 
 #OrderedDict([('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3')])
 #OrderedDict([('k1', 'v1'), ('k2', 'v2')])

popitem 移除最新添加的元素（后进先出）

 #移除指定元素，可将移除的元素赋值给自己
 import collections
 dic = collections.OrderedDict()
 dic['k1'] = 'v1'
 dic['k2'] = 'v2'
 dic['k3'] = 'v3'
 print(dic)
 dic.pop('k2')
 print(dic)
 
 #OrderedDict([('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3')])
 #OrderedDict([('k1', 'v1'), ('k3', 'v3')])
 
 import collections
 dic = collections.OrderedDict()
 dic['k1'] = 'v1'
 dic['k2'] = 'v2'
 dic['k3'] = 'v3'
 print(dic)
 ret = dic.pop('k2')
 print(ret)   #将移除的元素赋值给变量
 
 #OrderedDict([('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3')])
 #v2 

pop移除指定元素

 import collections
 dic = collections.OrderedDict()
 dic['k1'] = 'v1'
 dic['k2'] = 'v2'
 dic['k3'] = 'v3'
 print(dic)
 dic.setdefault('k4', '')  #setdefault设置默认值，如果对象后面不加参数默认为None
 print(dic)
 
 #OrderedDict([('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3')])
 #OrderedDict([('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3'), ('k4', '66')])

setdefault设置默认值

 import collections
 dic = collections.OrderedDict()
 dic['k1'] = 'v1'
 dic['k2'] = 'v2'
 dic['k3'] = 'v3'
 print(dic)
 dic.update({'k1':'v111', 'k10':'v10'})
 print(dic)
 
 #OrderedDict([('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3')])
 #OrderedDict([('k1', 'v111'), ('k2', 'v2'), ('k3', 'v3'), ('k10', 'v10')])

update更新原有的数据

2.3 默认字典

import collections
dic = collections.defaultdict(list) #设置类型为列表类型
dic['k1'].append('alex')
print(dic)
 
#defaultdict(<class 'list'>, {'k1': ['alex']})

2.4可命令元组

 #可命令元组
 import collections
 MytupleClass = collections.namedtuple('MytupleClass',['x', 'y', 'z'])  #创建一个类，类名为MytupleClass
 obj = MytupleClass(11,22,33)
 print(obj.x) #直接通过命令元素去访问元组对应的元素
 print(obj[0]) #等同于上面这种方式，但是没有上面这种方式可读性强
 print(obj.y)
 print(obj.z)
 
 #
 #
 #
 #

2.5 deque双向队列

import collections
newdeque = collections.deque(['alex', 'eric', 'jack']) #创建一个双向队列
print(newdeque) #deque(['alex', 'eric', 'jack'])
 
newdeque.append('')  #追加一个元素到队列
print(newdeque)  #deque(['alex', 'eric', 'jack', '11'])
 
newdeque.appendleft('')  #追加一个元素到左侧
print(newdeque) #deque(['22', 'alex', 'eric', 'jack', '11'])
 
newc = newdeque.count('alex')  #对队列里某个元素进行计数
print(newc)  #
 
newdeque.extend(['', ''])  #扩展队列元素
print(newdeque)  #deque(['22', 'alex', 'eric', 'jack', '11', '44', '55'])
 
newdeque.extendleft(['aa', 'bb'])  #从左侧进行扩展
print(newdeque)  #deque(['bb', 'aa', '22', 'alex', 'eric', 'jack', '11', '44', '55'])
 
newdeque.insert(2, 'haha')  #插入到下标2的位置
print(newdeque)  #deque(['alex', 'eric', 'haha', 'jack'])
 
newdeque.reverse()  #顺序反转
print(newdeque)   #deque(['jack', 'haha', 'eric', 'alex'])
 
newdeque.rotate(3)  #将队列末尾3个元素反转到队列左侧
print(newdeque)  #deque(['haha', 'eric', 'alex', 'jack'])

2.5.1 deque双向队列，该对象与collections的deque实质是完全一样的效果，这里就不作演示了，使用方法如下：

 import queue
 q = queue.Queue(['a', 'b'])

 import queue
 newdeque = queue.Queue(3)  #设置队列长度为3，也就是队列里面只有3个任务，如果不设置队列长度，就可以有
 #无限个任务，直到内存耗尽
 newdeque.put(['', ''])  #放入第一个任务
 get1 = newdeque.get()    #获取第一个任务
 print(get1)              #['1', '2']
 
 newdeque.put(['a', 'b'])  #放入第二个任务
 get2 = newdeque.get()    #获取第二个任务
 print(get2)              #['a', 'b']
 
 isempty = newdeque.empty()  #判断队列是否为空
 print(isempty)             # True
 
 isfull = newdeque.full()  #判断多列是否已经满了
 print(isfull)             #False

queue 单项队列

三.深浅拷贝

 import copy  #导入拷贝模块
 copy.copy()   #浅拷贝
 copy.deepcopy()    #深拷贝
 name = 'alex'
 copyname = name   #赋值

 #浅拷贝
 import copy
 a1 = [10,'b1',[111,112],'ha',]
 a2 = copy.copy(a1)  #浅拷贝
 print(a1)
 print(a2)
 
 a1[1] = 11 #改变a1的值
 a1[2][0] = 1111  #改变a1内嵌列表的值，将a1的第2个下标的第0个下标值改变
 print(a1)
 print(a2)
 print(id(a1))
 print(id(a2))
 print(id(a1[2][0]))
 print(id(a2[2][0]))
 
 #[10, 'b1', [111, 112], 'ha']
 #[10, 'b1', [111, 112], 'ha']
 #通过下面的对比，发现浅拷贝对于内嵌多层数据类型的操作，如果多层数据类型值改变，浅拷贝的对象也会跟着改变
 #[10, 11, [1111, 112], 'ha']
 #[10, 'b1', [1111, 112], 'ha']
 
 #12542664
 #12543688
 
 #7183888
 #7183888

 #深拷贝
 import copy
 a1 = [10,'b1',[111,112],'ha',]
 a2 = copy.deepcopy(a1)  #深拷贝
 print(a1)
 print(a2)
 
 a1[1] = 11 #改变a1的值
 a1[2][0] = 1111  #改变a1内嵌列表的值，将a1的第2个下标的第0个下标值改变
 print(a1)
 print(a2)
 print(id(a1))
 print(id(a2))
 print(id(a1[2][0]))
 print(id(a2[2][0]))
 
 #[10, 'b1', [111, 112], 'ha']
 #[10, 'b1', [111, 112], 'ha']
 #结合上面的例子进行对比发现，对应深层拷贝，内嵌多层的数据类型的值，被改变，不会影响到另一方拷贝或被拷贝的对象
 #[10, 11, [1111, 112], 'ha']
 #[10, 'b1', [111, 112], 'ha']
 #19030728
 #19031752
 #7118352
 #1723483792

四.函数

函数定义主要有如下要点

1.def：表示函数的关键字

2.函数名：函数的名称，日后可根据函数名调用函数

3.函数体：函数中进行一系列的逻辑计算。

4.参数：为函数提供数据

5.返回值：当函数中执行完成后，可以给调用者返回数据

以上要点中，比较重要的有参数和返回值

 def func():  #创建一个函数，没有接收参数
     print('hello')
 
 func()   #直接执行函数
 #执行结果  hello
 
 foo = func  #创建一个对象
 foo()   #执行对象
 #执行结果 hello
 
 def func(arg):   #传入一个参数
     print('hello %s' % arg)
 
 func('laiying')    #执行结果输出 hello laiying
 
 def func(arg1,arg2):  #传入两个参数
     print('hello %s, %s' % (arg1, arg2))
 
 func('laiying','good')  #执行结果输出 hello laiying, good
 
 def func(*args):   #动态参数，多个参数，可以为空
     print('hello %s' % (''.join(args)))
 
 func('laiying', '很棒', 'very good')  #执行结果输出hello laiying很棒very good
 
 #以下两种方式得到的效果相同
 def show(*args,**kwargs):
     print(args,type(args))
     print(kwargs,type(kwargs))
 show(11,22,33, n1= 88,n2='alex')
 #结果输出(11, 22, 33) <class 'tuple'>{'n2': 'alex', 'n1': 88} <class 'dict'>
 
 def show(*args,**kwargs):
     print(args,type(args))
     print(kwargs,type(kwargs))
 a = [11, 22, 33, ]
 b = {'n1':88, 'n2':'alex'}
 show(*a, **b)
 #结果输出(11, 22, 33) <class 'tuple'>{'n2': 'alex', 'n1': 88} <class 'dict'>

函数参数

1.形参变量只有在被调用时才分配内存单元， 在调用结束时，即可释放所分配的内存单元，因此，形参只在函数内部有效，

函数调用结束返回时主调用函数后则不能在使用该形参变量

2.实参可以是常量，变量，表达试，函数等，无论实参是何类型的量，在进行函数调用时，它们都必须有确定的值，

以便把这些值传送给行参，因此应预先用赋值，输入等办法使参数获得确定值

3.位置参数和关键字(标准调用：实参与行参位置必须一一对应，关键字调用：位置无需固定)

4.默认参数

5.参数组 *args 以元组的形式传入参数  **kwagrs以字典的形式传入参数

以上参数是以一个整体，元组，字典的方式传入，如果需要一次传入多个元素，但是又可以分开一个一个传入，可以使用以下方式

参数的传入规则  （位置参数，关键字参数）---------默认参数------------参数组

五.嵌套函数

# 创建嵌套函数
NAME = 'alex'
def global_test():   # 第一层定义的函数
    name = 'rain'
    print("global_test: ",name)
    def local_test():  #  第二层定义的函数
        name = 'jack'
        print("local_test: ",name)
        def test():   # 第三成第一的函数
            name = 'ying'
            print("test: ",name)
 
        test()
    local_test()
global_test()
 
#执行结果
global_test:  rain
local_test:  jack
test:  ying
 
#通过以上结果我们可以看出，嵌套函数的执行顺序是，先执行外层函数，然后依次执行内层中的嵌套函数， 内层中的函数不可在其他地方调用，只能在该函数中调用   

六:函数中global与nonlocal的作用

通过以上截图可以看出，只要通过global关键字将变量改为了全局变量，那么以前的那个全局变量就会被覆盖，以后在执行该变量时，执行的就是通过global从新定义的这个全局变量，

全局变量的范围就是整个程序

通过以上截图可以看出nonloacl关键字的作用就是，将上一层的变量修改为当前变量，只对上一层生效，不能对其它层生效

六.递归

在函数内部，可以调用其他函数，如果一个函数在内部调用自己本身，这个函数就是递归函数

 def calc(n):
     print(n)
     if int(n/2) == 0:
         return n
     return calc(int(n/2))
 calc(10)
 
 #执行结果
 10
 5
 2
 1
 
 #根据以上结果，我们来分析一下执行的流程
 1.给calc这个函数传入一个参数n为10
 2.打印这个函数
 3.if判断n是不是等0,如果n==0就终止这个函数，并给一个返回值n
 4.终止自身函数的运行，然后调用自己，计算n/2，并将这个值给返回。
 
 5.重复以上执行流程，一直到n/2==0，就终止这个函数本身的运行，并return一个返回值n

递归问路

 person_list = ["alex","jakc","rain"]
 def ask_way(person_list):
     print('-'*60)
     if len(person_list) == 0:
         return "没有人知道"
     person = person_list.pop(0)
     if person == "rain":
         return "%s说：我知道，圆明园在海淀，下地铁就到" %person
     print("hi [%s]，请问圆明园在什么地方" %person)
     print("%s回答道:我不知道，你等在，我帮你问下一个人%s"%(person,person_list))
     res = ask_way(person_list)
     print("%s问的结果是：%res" %(person,res))
     return res
 res = ask_way(person_list)
 print(res)
 
 ###########执行结果##########
 ------------------------------------------------------------
 hi [alex]，请问圆明园在什么地方
 alex回答道:我不知道，你等在，我帮你问下一个人['jakc', 'rain']
 ------------------------------------------------------------
 hi [jakc]，请问圆明园在什么地方
 jakc回答道:我不知道，你等在，我帮你问下一个人['rain']
 ------------------------------------------------------------
 jakc问的结果是：'rain说：我知道，圆明园在海淀，下地铁就到'es
 alex问的结果是：'rain说：我知道，圆明园在海淀，下地铁就到'es
 rain说：我知道，圆明园在海淀，下地铁就到

递归特性

1.必须要有一个明确的结束条件

2.每次进入更深一次递归时，问题规模相比上次递归都应有所减少

3.递归效率不高，递归层次过多会导致栈溢出

（在计算机中，函数调用是通过栈（stack）这个数据结果实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧，

由于栈的大小不是无限的，所以，递归调用的次数过多，会会导致栈溢出）

七.lambda & map

lambda书写格式：参数：表达式   直接得出一个结果，赋值给一个变量

lamdba存在的意义是对简单函数的简洁表达

 func = lambda a:a+1     #创建形式参数a
 ret = func(1)     #函数内容，a+1 并把结果retun回去
 
 print(ret)
 #打印输出 2
 
 map1 = map(lambda x:x+100, [11,22,33])  #map(函数，'参数')
 print(list(map1))
 #结果输出 [111, 122, 133] ，python2.x可以直接看到结果，python3.x需要转换成list才能看到结果