初识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')])

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

#移除指定元素，可将移除的元素赋值给自己
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 

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

#OrderedDict([('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3')])
#OrderedDict([('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3'), ('k4', '66')])

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

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)

#11
#11
#22
#33

2.5 deque双向队列

import collections
newdeque = collections.deque(['alex', 'eric', 'jack']) #创建一个双向队列
print(newdeque) #deque(['alex', 'eric', 'jack'])

newdeque.append('11')  #追加一个元素到队列
print(newdeque)  #deque(['alex', 'eric', 'jack', '11'])

newdeque.appendleft('22')  #追加一个元素到左侧
print(newdeque) #deque(['22', 'alex', 'eric', 'jack', '11'])

newc = newdeque.count('alex')  #对队列里某个元素进行计数
print(newc)  # 1

newdeque.extend(['44', '55'])  #扩展队列元素
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(['1', '2'])  #放入第一个任务
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

三.深浅拷贝

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才能看到结果