初识Python第三天（二）

import collections
dic = collections.defaultdict(list) #设置类型为列表类型
dic[‘k1‘].append(‘alex‘)
print(dic)

#defaultdict(<class ‘list‘>, {‘k1‘: [‘alex‘]})

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

1 import queue
2 q = queue.Queue([‘a‘, ‘b‘])

1 import copy  #导入拷贝模块
2 copy.copy()   #浅拷贝
3 copy.deepcopy()    #深拷贝
4 name = ‘alex‘
5 copyname = name   #赋值

 1 #浅拷贝
 2 import copy
 3 a1 = [10,‘b1‘,[111,112],‘ha‘,]
 4 a2 = copy.copy(a1)  #浅拷贝
 5 print(a1)
 6 print(a2)
 7 
 8 a1[1] = 11 #改变a1的值
 9 a1[2][0] = 1111  #改变a1内嵌列表的值，将a1的第2个下标的第0个下标值改变
10 print(a1)
11 print(a2)
12 print(id(a1))
13 print(id(a2))
14 print(id(a1[2][0]))
15 print(id(a2[2][0]))
16 
17 #[10, ‘b1‘, [111, 112], ‘ha‘]
18 #[10, ‘b1‘, [111, 112], ‘ha‘]
19 #通过下面的对比，发现浅拷贝对于内嵌多层数据类型的操作，如果多层数据类型值改变，浅拷贝的对象也会跟着改变
20 #[10, 11, [1111, 112], ‘ha‘]
21 #[10, ‘b1‘, [1111, 112], ‘ha‘]
22 
23 #12542664
24 #12543688
25 
26 #7183888
27 #7183888

 1 #深拷贝
 2 import copy
 3 a1 = [10,‘b1‘,[111,112],‘ha‘,]
 4 a2 = copy.deepcopy(a1)  #深拷贝
 5 print(a1)
 6 print(a2)
 7 
 8 a1[1] = 11 #改变a1的值
 9 a1[2][0] = 1111  #改变a1内嵌列表的值，将a1的第2个下标的第0个下标值改变
10 print(a1)
11 print(a2)
12 print(id(a1))
13 print(id(a2))
14 print(id(a1[2][0]))
15 print(id(a2[2][0]))
16 
17 #[10, ‘b1‘, [111, 112], ‘ha‘]
18 #[10, ‘b1‘, [111, 112], ‘ha‘]
19 #结合上面的例子进行对比发现，对应深层拷贝，内嵌多层的数据类型的值，被改变，不会影响到另一方拷贝或被拷贝的对象
20 #[10, 11, [1111, 112], ‘ha‘]
21 #[10, ‘b1‘, [111, 112], ‘ha‘]
22 #19030728
23 #19031752
24 #7118352
25 #1723483792

 1 def func():  #创建一个函数，没有接收参数
 2     print(‘hello‘)
 3 
 4 func()   #直接执行函数
 5 #执行结果  hello
 6 
 7 foo = func  #创建一个对象
 8 foo()   #执行对象
 9 #执行结果 hello
10 
11 def func(arg):   #传入一个参数
12     print(‘hello %s‘ % arg)
13 
14 func(‘laiying‘)    #执行结果输出 hello laiying
15 
16 
17 def func(arg1,arg2):  #传入两个参数
18     print(‘hello %s, %s‘ % (arg1, arg2))
19 
20 func(‘laiying‘,‘good‘)  #执行结果输出 hello laiying, good
21 
22 
23 def func(*args):   #动态参数，多个参数，可以为空
24     print(‘hello %s‘ % (‘‘.join(args)))
25 
26 func(‘laiying‘, ‘很棒‘, ‘very good‘)  #执行结果输出hello laiying很棒very good
27 
28 
29 
30 #以下两种方式得到的效果相同
31 def show(*args,**kwargs):
32     print(args,type(args))
33     print(kwargs,type(kwargs))
34 show(11,22,33, n1= 88,n2=‘alex‘)
35 #结果输出(11, 22, 33) <class ‘tuple‘>{‘n2‘: ‘alex‘, ‘n1‘: 88} <class ‘dict‘>
36 
37 
38 def show(*args,**kwargs):
39     print(args,type(args))
40     print(kwargs,type(kwargs))
41 a = [11, 22, 33, ]
42 b = {‘n1‘:88, ‘n2‘:‘alex‘}
43 show(*a, **b)
44 #结果输出(11, 22, 33) <class ‘tuple‘>{‘n2‘: ‘alex‘, ‘n1‘: 88} <class ‘dict‘>

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