python学习_17

Posted 2021-01-12

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了python学习_17相关的知识，希望对你有一定的参考价值。

生成器
和推导列表定义类似，但是使用()定义，而不是使用[]
使用方式1：用括号定义
next(g)访问元素

>> g = (x*x for x in range(10))

>> next(g)
0
>> next(g)
1
>> next(g)
4
>> next(g)
9
>> next(g)
16
>> next(g)
25
>> next(g)
36
>> next(g)
49
>> next(g)
64
>> next(g)
81
>> next(g)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration

遍历生成器

>> g = (x**2 for x in range(5))
>> for v in g:
... print(v)
...
0
1
4
9
16

习题3：用生成器生成10以内的奇数

>> g = (x for x in range(1,10,2))
>> for n in g:
... print(n)
...
1
3
5
7
9

使用方式2：用yield定义

def odd():
print (‘step 1‘)
yield 1
print (‘step 2‘)
yield 3
print (‘step 3‘)
yield 5
o = odd()
print (next(o))
print (next(o))
print (next(o))
print (next(o))

#for i in o:

print i

def g():
print("a")
yield 1
print("b")
yield 2
print("c")
yield 3
print("d")

g = g()
for i in g:
print(i)

深、浅拷贝

import copy
lst_1 = [1,2,3,["a","b"]]
lst_2 = copy.copy(lst_1)
lst_3 = copy.deepcopy(lst_1)

lst_1.append(4)
lst_1[3].append("c")

print(lst_1)
print(lst_2)
print(lst_3)

直接赋值、浅拷贝和深度拷贝解析
?直接赋值：其实就是对象的引用（别名）。
?浅拷贝(copy)：拷贝父对象，不会拷贝对象的内部的子对象。
?深拷贝(deepcopy)：?copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象。
字典浅拷贝实例
实例1：

>>a = {1: [1,2,3]}
>> b = a.copy()
>> a, b
({1: [1, 2, 3]}, {1: [1, 2, 3]})
>> a[1].append(4)
>> a, b
({1: [1, 2, 3, 4]}, {1: [1, 2, 3, 4]})
深度拷贝需要引入 copy 模块：

实例

>>import copy
>> c = copy.deepcopy(a)
>> a, c
({1: [1, 2, 3, 4]}, {1: [1, 2, 3, 4]})
>> a[1].append(5)
>> a, c
({1: [1, 2, 3, 4, 5]}, {1: [1, 2, 3, 4]})
解析
1、b = a:?赋值引用，a 和 b 都指向同一个对象。

2、b = a.copy():?浅拷贝, a 和 b 是一个独立的对象，但他们的子对象还是指向统一对象（是引用）。

3、b = copy.deepcopy(a):?深度拷贝, a 和 b 完全拷贝了父对象及其子对象，两者是完全独立的。

实例2：
列表的深浅拷贝
以下实例是使用 copy 模块的 copy.copy（浅拷贝）和（copy.deepcopy ）:

实例

#!/usr/bin/python # -*-coding:utf-8 -*- import copy 
a = [1, 2, 3, 4, [‘a‘, ‘b‘]] #原始对象 
b = a #赋值，传对象的引用 
c = copy.copy(a) #对象拷贝，浅拷贝 
d = copy.deepcopy(a) #对象拷贝，深拷贝 
a.append(5) #修改对象a 
a[4].append(‘c‘) #修改对象a中的[‘a‘, ‘b‘]数组对象 
print( ‘a = ‘, a ) 
print( ‘b = ‘, b ) 
print( ‘c = ‘, c )
print( ‘d = ‘, d )
以上实例执行输出结果为：
(‘a = ‘, [1, 2, 3, 4, [‘a‘, ‘b‘, ‘c‘], 5])
(‘b = ‘, [1, 2, 3, 4, [‘a‘, ‘b‘, ‘c‘], 5])#因为b和a指向同一个内存地址，是同一个对象，对a的任何改动都会影响到b
(‘c = ‘, [1, 2, 3, 4, [‘a‘, ‘b‘, ‘c‘]])#c是浅拷贝，只影响对子对象元素的修改，其他元素是独立的
(‘d = ‘, [1, 2, 3, 4, [‘a‘, ‘b‘]])#每个元素都是独立的，修改互不影响

通过list实现一个简单的堆栈

#encoding=utf-8
stack_list = []

stack_list.append(1)
print(stack_list)
stack_list.append(2)
print(stack_list)
stack_list.append(3)
print(stack_list)

print(stack_list)
print(stack_list.pop())
print(stack_list)
print(stack_list.pop())
print(stack_list)
print(stack_list.pop())

print(‘*‘*30)

for i in range(1,6):
    stack_list.append(i)
    print(stack_list)

for i in range(5):
    stack_list.pop()
print(stack_list)

通过list实现一个简单的队列

#encoding=utf-8

stack_list = []

for i in range(5):
    stack_list.append(i)
    print(stack_list)

for j in range(5):
    print(stack_list)
    print(stack_list.pop(0))

from collections import deque

queue = deque([1,2,3,4,5,6])

queue.append(7)
queue.append(8)

print(queue.popleft())
print(queue.popleft())
print(queue)

元组
元素只能访问其元素，不能进行修改、删除，适用元素固定的情况

创建元组
创建空元组

>> t = ()

创建只有一个元素的元组

>> t = (1,)

>> t = 2,3
>> t
(2, 3)
访问元组元素
元组属于序列，可通过下标访问元素

>> t = (1,2,3,4,5)
>> t[0]
1
>> t[3]
4

通过切片访问元组

>> t[:]
(1, 2, 3, 4, 5)

>> t[-1]
5

>> t[:3]
(1, 2, 3)

>> t[:3:2]
(1, 3)

>> t[::-1]
(5, 4, 3, 2, 1)

>> t[-3:-1:-1]
()

>> t[-3:-1:1]
(3, 4)

倒序start 要大于end

>> t[-1:-3:-1]
(5, 4)

>> t[-1:-4:-1]
(5, 4, 3)

>> t
(1, 2, 3, 4, 5)
>> for i in range(len(t)-1,-1,-1):#倒序遍历start要大于end，因为要全部取end =-1
... print(t[i])
...
5
4
3
2
1

连接元组 +