python元组 字典 集合

hongmeigui22027

　　1.列表构建栈的数据结构：
　　栈的特点：先进后出
　　

#!/usr/bin/env python　　
#coding:utf-8
　　
stack = []
　　

　　
info = """
　　

　　栈结构
　　1.入栈
　　2.出栈
　　3.栈长度
　　4.栈顶元素
　　5.退出
　　

　　
"""
　　
print info
　　

　　
while 1:
　　choice = raw_input("请输入你的选择：")
　　

　　if choice == "1":
　　in_value = raw_input("入栈元素：")
　　stack.append(in_value)
　　print "元素%s入栈成功！" %(in_value)
　　print stack
　　elif choice   == "2":
　　if stack:
　　out_value = stack.pop()
　　print "元素%s出栈成功！" %(out_value)
　　print stack
　　else:
　　print "栈为空！"
　　elif choice == "3":
　　print "栈长度为%d" %(len(stack))
　　elif choice == "4":
　　if stack:
　　print "栈顶元素为%s" %(stack[-1])
　　else:
　　print "栈为空"
　　elif choice == "5":
　　exit(0)
　　else:
　　print "请输入正确选择！"
　　

　　测试结果：

　　2.列表构建队列的数据结构：
　　队列的特点：先进先出
　　

#!/usr/bin/env python　　
#coding:utf-8
　　
queue = []
　　

　　
info = """
　　

　　队列结构
　　1.入队
　　2.出队
　　3.队长度
　　4.队头元素
　　5.队尾元素
　　6.退出
　　

　　
"""
　　
print info
　　

　　
while 1:
　　choice = raw_input("请输入你的选择：")
　　

　　if choice == "1":
　　in_value = raw_input("入队元素：")
　　queue.append(in_value)
　　print "元素%s入队成功！" % (in_value)
　　print queue
　　elif choice == "2":
　　if queue:
　　out_value = queue.pop(0)
　　print "元素%s出队成功！" % (out_value)
　　print queue
　　else:
　　print "队为空！"
　　elif choice == "3":
　　print "队长度为%d" % (len(queue))
　　elif choice == "4":
　　if queue:
　　print "队头元素为%s" % (queue[0])
　　else:
　　print "队为空"
　　elif choice == "5":
　　if queue:
　　print "队尾元素为%s" % (queue[-1])
　　else:
　　print "队为空"
　　elif choice == "6":
　　exit(0)
　　else:
　　print "请输入正确选择！"
　　

　　测试结果：

　　3.Is和等于号的区别：
　　字符串驻留机制：

• 对于较小的字符串，id相同
  
• 对于较长的字符串，id不相同，因为不会驻留字符串的副本。　　注意：在进行测试时，一定要在交互式环境测试。
  　　测试：
  　　
  
  　　
  In [1]: a = 'hello'
  
  

　　In [2]: b = 'hello'

　　In [3]: print>　　40886560 40886560
　　In [4]: c = 'hello java world'
　　In [5]: d = 'hello java world'

　　In [6]: print>　　40923296 40923464
　　In [7]: print c is d
　　False
　　In [8]: e = 'python'
　　In [9]: f = "".join(['p', 'y', 't', 'h', 'o', 'n'])

　　In [10]: print>　　140309747759888 40886608
　　

　　
结论：
　　
Is表示的是对象标识符；表示两个变量的值是否在统一块内存空间；
　　
== 表示的是值是否相等
　　

　　
总结: is返回值为True, ==返回一定是True;
　　
深拷贝与浅拷贝：
　　1. 直接赋值, 只是把新的变量指向li的内存空间, 没有复制;当li改变, li1也随之改变;
　　

　　In [11]: li = [1, 2, 3]
　　In [12]: li1 = li

　　In [13]:>　　Out[13]: 40893688

　　In [14]:>　　Out[14]: 40893688
　　

　　
2. 浅拷贝: 拷贝出一份副本, 但是没有拷贝子对象(列表里面的列表对象);不完全拷贝
　　
- 切片li[:]
　　

　　In [15]:  li1 = li[:]

　　In [16]:>　　Out[16]: (40893688, 40891672)

• copy.copy()　　In [17]:  li = ['fentiao', 'zhurou', ['fensi', 'fendai']]
  
  

　　In [18]: li1 = li[:]

　　In [19]:>　　Out[19]: (40891600, 40878592)

　　In [20]:>　　Out[20]: (40906264, 40906264)
　　In [21]: import copy
　　In [22]: li2 = copy.copy(li)

　　In [23]:>　　Out[23]: (40891600, 40878592, 40865016)

　　In [24]: >　　Out[24]: (40906264, 40906264, 40906264)
　　

3.深拷贝: 里面的所有对象重新拷贝, 包括子对象;　　

　　In [25]: li3 = copy.deepcopy(li)

　　In [26]:>　　Out[26]: (40906264, 40906264, 40879960)
　　

元组（tuple）　　
1.元组创建
　　
可以把元组看作一个容器,任何数据类型都可以放在这个容器里面;
　　
通过赋值方式创建元组
　　

　　In [27]: t = (1, 1.0, 2j, True, (1,2,3))
　　In [28]: print t
　　(1, 1.0, 2j, True, (1, 2, 3))
　　

定义单个元组,一定要在这个元素后面加逗号　　

　　In [29]: t1 = (1,)
　　In [30]: print type(t1)
　　<type 'tuple'>
　　

通过工厂方法创建元组　　

　　In [31]: t = tuple()
　　In [32]: print type(t)
　　<type 'tuple'>
　　

2.元组的操作　　
索引
　　
切片
　　
连接
　　
重复
　　
成员操作符
　　

　　
`In [33]: t = (1, 1.0, 1L, 1+2j, 'hello', [1,2])`
　　
正向索引与反向索引以及元组嵌套时元素的访问
　　

　　In [34]: print t[0], t[-1], t[-1][-1]
　　1 [1, 2] 2
　　

逆转元组元素　　

　　In [35]:  print t[::-1]
　　([1, 2], 'hello', (1+2j), 1L, 1.0, 1)
　　

连接　　

　　In [36]:  print t+(1,2,3)
　　(1, 1.0, 1L, (1+2j), 'hello', [1, 2], 1, 2, 3)
　　

　　
重复
　　

　　In [37]: print t * 3
　　(1, 1.0, 1L, (1+2j), 'hello', [1, 2], 1, 1.0, 1L, (1+2j), 'hello', [1, 2], 1, 1.0, 1L, (1+2j), 'hello', [1, 2])
　　

成员操作符　　

　　In [38]: print 1 in t, 1 not in t
　　True False
　　

　　
3.元组是可迭代数据类型
　　

　　In [41]: allow_ips = ('172.25.254.1', '172.25.254.12', '172.25.254.13')
　　In [42]: for ip in allow_ips:
　　....:     print ip
　　....:
　　172.25.254.1
　　172.25.254.12
　　172.25.254.13
　　

测试练习：端口扫描器雏形　　
扫描172.25.254.0/24 这个网络所有主机的ftp， ssh， http， mariadb, samba(21, 22, 80, 3306,3020)
　　

　　ips = []
　　for i in range(1, 255):
　　#ip = '172.25.254.'+str(i)
　　ips.append('172.25.254.' + str(i))
　　ports = (21, 22, 80, 3306, 3020)
　　for ip in ips:
　　for port in ports:
　　print '[+] Scanning %s:%d' % (ip, port)
　　

4.元组方法　　
count 统计次数
　　

　　In [43]: t.count(1)
　　Out[43]: 3
　　

index 显示索引 　　

　　In [44]: t.index(1)
　　Out[44]: 0
　　

元组变量交换　　
python 中后面如果诗歌表达式  从右往左算
　　
x,y= (2,1) #先计算右边的表达式y,x,在内存中开辟内存空间,生成元组(y,x):
　　
x,y = y,x  #将x,y = (2,1)
　　
print x,y
　　
元组是不可变数据类型
　　

　　
字典
　　
1.字典创建
　　
字典的简单版定义1：
　　

　　d = {

:前面的称为键，key
　　

#:后面的称为值，value　　
#键值对(key-value)
　　
'name': 'root',
　　
'passwd':'westos'
　　

　　}
　　print d['name']
　　print d['passwd']
　　

　　
字典的升级版定义:
　　

　　info = {
　　'root':{
　　'name': 'root',
　　'passwd':'westos',
　　'age':18,
　　'eamil':['westos@qq.com', 'redhat@qq.com']
　　},
　　

'student': {　　'name': 'student',
　　'passwd': 'westos',
　　'age': 18,
　　'eamil': ['westos@qq.com', 'redhat@qq.com']
　　
},
　　

　　}
　　print info['root']
　　

　　通过工厂函数创建字典
　　

　　

　　d = dict()
　　print type(d)
　　d = dict(a=1, b=2, c=3)
　　print d, type(d)
　　

　　
fromkeys方法创建字典
　　
d = {}.fromkeys(['user1', 'user2', 'user3'])
　　
print d
　　

　　
　　

　　
测试练习：
　　
批量生成卡号并初始化密码
　　
要求描述：
　　
1.生成银行卡号， 前5位为:61021 后面4位: 1~1000
　　
2.并给每个银行卡初始化密码为666666
　　
3. 每5个为一行
　　

　　

　　cardids = []
　　for i in range(1, 1001):
　　cardid = &quot;61021%.4d&quot; % (i)
　　cardids.append((cardid))
　　cardInfo = {}.fromkeys(cardids, '666666')
　　#print len(cardInfo)
　　for i, j in enumerate(cardInfo):
　　

if i % 5 == 0:　　print
　　
print  j,
　　

测试结果：　　
　　

　　
2.字典的特性
　　
不可行的特性: 索引， 切片， 连接， 重复，   (因为dict是无序的数据类型;)
　　
可行的特性: 成员操作符
　　
3.字典操作
　　
字典值增加
　　
update(key=value, .....)
　　- 如果key值存在， 更新该key对应的value值;
　　- 如果key不存在， 添加key-value值;
　　

　　In [1]: d = dict(a=1, b=2)
　　In [2]: d
　　Out[2]: {'a': 1, 'b': 2}
　　In [3]: d.update(c=5,d=6)
　　In [4]: d
　　Out[4]: {'a': 1, 'b': 2, 'c': 5, 'd': 6}
　　In [5]: d.update(a=10,d=100,f=9)
　　In [6]: d
　　Out[6]: {'a': 10, 'b': 2, 'c': 5, 'd': 100, 'f': 9}
　　

setdefault(key,value)　　- 如果key值存在， 不操作;
　　- 如果key不存在， 添加key-value值;
　　

　　In [1]: d = dict(a=1, b= 2)
　　In [2]: d.setdefault('a', 10)
　　Out[2]: 1
　　In [3]: d
　　Out[3]: {'a': 1, 'b': 2}
　　In [4]: d.setdefault('f', 10)
　　Out[4]: 10
　　In [5]: d
　　Out[5]: {'a': 1, 'b': 2, 'f': 10}
　　

　　
字典值查看
　　

　　In [6]: d.keys()   #查询key值
　　Out[6]: ['a', 'b', 'f']
　　In [7]: d.values()   #查询values值
　　Out[7]: [1, 2, 10]
　　In [8]: d.items()     #查询键值对
　　Out[8]: [('a', 1), ('b', 2), ('f', 10)]
　　In [9]:  for i,j in d.items():
　　...:     print i,j
　　...:
　　a 1
　　b 2
　　f 10
　　In [10]: d.has_key('a') #查询字典里是否含有‘a’这个key值
　　Out[10]: True
　　

字典删除　　pop(k[,d]):
　　
- 如果key存在， 删除key-value；
　　
- 如果key不存在，判断d是否存在：
　　- 如果d不存在， 报错KeyError;
　　- 如果d存在， 返回d;
　　

　　

　　In [11]: d
　　Out[11]: {'a': 1, 'b': 2, 'f': 10}
　　In [12]: d.pop('e', 1)
　　Out[12]: 1
　　In [13]: d.pop('a')
　　Out[13]: 1
　　In [14]: d
　　Out[14]: {'b': 2, 'f': 10}
　　In [15]: d.pop('b', 10)
　　Out[15]: 2
　　

popitem():随机删除key-value对;当字典为空时报错;　　

　　In [19]: d
　　Out[19]: {'a': 1, 'b': 2, 'c': 3, 'f': 10}
　　In [20]: d.popitem()
　　Out[20]: ('a', 1)
　　In [21]: d
　　Out[21]: {'b': 2, 'c': 3, 'f': 10}
　　In [22]: del d['c']
　　In [23]: d
　　Out[23]:{'b': 2, 'f': 10}

In[24]:del d['c']
　　KeyError                                  Traceback (most recent call last)
　　<ipython-input-24-975cd7d7076f> in <module>()
　　----> 1 del d['c']
　　KeyError: 'c'
　　In [34]: d.clear()     #删除字典里所有元素
　　In [35]: d
　　Out[35]: {}
　　In [36]: del d      #删除整个字典
　　

　　
利用if语句实现switch（实现四则运算）
　　

　　#!/usr/bin/env python
　　#coding:utf-8
　　from future import division
　　while 1:
　　num1 = input('Num1:')
　　oper = raw_input('操作符:')
　　num2 = input('Num2:')
　　

if oper == "+":　　print  num1 +num2
　　
elif oper == '-':
　　print  num1 - num2
　　
elif oper == '/':
　　print  num1 / num2
　　
elif oper == '*':
　　print  num1 * num2
　　
else:
　　print 'error'
　　

测试结果：　　
　　

　　
利用字典与函数实现switch（实现四则运算）
　　

　　#!/usr/bin/env python
　　#coding:utf-8
　　from future import division
　　num1 = input('Num1:')
　　oper = raw_input('操作符:')
　　num2 = input('Num2:')
　　def add(num1, num2):
　　return num1 + num2
　　def div(num1, num2):
　　if num2 == 0:
　　raise IOError
　　else:
　　return num1 / num2
　　d = {
　　'+': add,
　　'-': num1 - num2,
　　'': num1 num2,
　　'/': div,
　　}
　　if oper in d:
　　print d[oper](num1, num2)
　　else:
　　print 'error'
　　

　　
测试结果：
　　
　　

　　
字典遍历
　　

　　#!/usr/bin/env python
　　#coding:utf-8
　　favourite_places = {
　　'lee': ['xian', 'hangzhou'],
　　'fentiao':['hanzhong', 'xianyang']
　　}
　　for name in favourite_places:
　　print &quot;\n&quot; + name.title() + &quot;'s favourite place are:&quot;
　　for place in favourite_places[name]:
　　print place
　　

　　
测试结果：
　　
　　

　　
集合：
　　
集合是不重复的数据类型;字典中的key值不能重复;
　　
In [37]: s = {1, 2, 3, 4, 1, 2}
　　

　　
In [38]: s
　　
Out[38]: {1, 2, 3, 4}
　　

　　
列表去重
　　
方法一：可以转换为集合
　　

　　
In [39]: li = [1, 2, 3, 4, 1, 2, 4]
　　

　　
In [40]: list(set(li))
　　
Out[40]: [1, 2, 3, 4]
　　
方法二：转化为字典，拿出所有的key； 注意: dict()不能直接将列表转化为字典;
　　
In [41]: {}.fromkeys(li).keys()
　　
Out[41]: [1, 2, 3, 4]
　　
定义集合
　　
定义一个空集合
　　
In [44]: s1 = set()
　　

　　
In [45]: type(s1)
　　
Out[45]: set
　　
字典可以转化为集合
　　
In [46]: d = dict(a=1, b=2, c=3)
　　

　　
In [47]: set(d)
　　
Out[47]: {'a', 'b', 'c'}
　　集合是无序的数据类型;
　　
In [48]: s = {91, 2, 3, 12, 89}
　　

　　
In [49]: s.add(13)
　　

　　
In [50]: print s
　　
set([2, 3, 12, 13, 89, 91])
　　
集合不支持的特性: 索引， 切片， 重复，连接
　　
集合支持的特性: 成员操作符
　　
集合是可迭代的对象， 因此支持for循环遍历元素；
　　
In [51]: s = {91, 2, 3, 12, 89}
　　

　　
In [52]: for i in s:
　　....:     print i
　　....:
　　
91
　　
89
　　
2
　　
3
　　
12
　　
集合的增删查改
　　
增加
　　
In [53]: s = {1, 2, 3}
　　

　　
In [54]: s.add(4)
　　

　　
In [55]: s.update({3,4,5,6})
　　

　　
In [56]: s.update('hello')
　　

　　
In [57]: s.update([1,2,37,10])
　　

　　
In [58]: s
　　
Out[58]: {1, 2, 3, 4, 5, 6, 10, 37, 'e', 'h', 'l', 'o'}
　　
删除
　　
In [68]: s1.pop()
　　
Out[68]: 1
　　

　　
In [69]: s1
　　
Out[69]: {3, 4, 5}
　　
In [74]: s1.remove(5)
　　

　　
In [75]: s1
　　
Out[75]: {4}
　　
In [78]: s1.discard(4)
　　

　　
In [79]: s1
　　
Out[79]: set()
　　

　　
集合的交，补差集
　　
In [3]: s1 = {1, 2, 3, 4}
　　

　　
In [4]: s2 = {1, 2, 4, 5}
　　
#交集
　　
In [5]: s1 & s2
　　
Out[5]: {1, 2, 4}
　　
#补集
　　
In [6]: s1 |  s2
　　
Out[6]: {1, 2, 3, 4, 5}
　　
#差集
　　
In [7]: s1 -  s2
　　
Out[7]: {3}