Python基础-----列表、元组、集合（2）

fjqzyc

　　raw_input ##字符类型
　　input##数值类型
　　'''##格式化输出+注释
　　切片
　　s[2:5]##切片从2开始到5，不包括5
　　[kiosk@foundation39 mnt]$ python
　　Python 2.7.5 (default, Oct 11 2015, 17:47:16)
　　[GCC 4.8.3 20140911 (Red Hat 4.8.3-9)] on linux2
　　Type "help", "copyright", "credits" or "license" for more information.
　　>>> s = 'hello'
　　>>> s [1:3]
　　'el'
　　>>> s [1:5:2]
　　'el'
　　>>> s [:-1]
　　'hell'
　　>>> s [3:]
　　'lo'
　　>>> s [2:3]
　　'l'
　　>>>
　　##字符串的其他操作
　　In [22]: s.
　　s.capitalize  s.islower     s.rpartition
　　s.center      s.isspace     s.rsplit
　　s.count       s.istitle     s.rstrip
　　s.decode      s.isupper    s.split
　　s.encode      s.join        s.splitlines
　　s.endswith    s.ljust       s.startswith
　　s.expandtabs  s.lower       s.strip
　　s.find        s.lstrip      s.swapcase
　　s.format      s.partition   s.title
　　s.index       s.replace     s.translate
　　s.isalnum     s.rfind       s.upper
　　s.isalpha     s.rindex      s.zfill
　　s.isdigit     s.rjust
　　In [6]: s='xixi'
　　In [7]: s
　　Out[7]: 'xixi'
　　In [9]: help(s.center)##查询帮助
　　Help on built-in function center:
　　center(...)
　　S.center(width[, fillchar]) -> string

　　Return S centered in a string of length>　　done using the specified fill character (default is a space)
　　(END)
　　s.center##输入数字为宽度，不够的默认空格补齐
　　In [16]: s.center(6)
　　Out[16]: ' xixi '##默认使用空格填充
　　In [17]: s.center(6,'#')
　　Out[17]: '#xixi#'
　　s.isalnum ##包含数字和字母
　　In [29]: "w2".isalnum()
　　Out[29]: True
　　s.istitle ##第一个字母大写为标题语言，返回true
　　In [27]: "Hello".istitle()
　　Out[27]: True
　　s.capitalize##将第一个字母转换为大写字母
　　In [26]: "hello".capitalize()
　　Out[26]: 'Hello'
　　s.isupper##输入字符均为大写为true
　　In [30]: "WQ".isupper()
　　Out[30]: True
　　In [31]: "Wq".isupper()
　　Out[31]: False
　　s.lower##将输入转换为小写
　　In [32]: "Wq".lower()
　　Out[32]: 'wq'
　　s.upper##将输入转换为大写
　　In [8]: s.upper()
　　Out[8]: '      SEWQF   FEW'
　　s.swapcase##大小写互相转换
　　In [11]: a
　　Out[11]: 'svwgdSre'
　　In [13]: a.swapcase()
　　Out[13]: 'SVWGDsRE'
　　s.islower##默认输入为小写
　　In [33]: "Wq".islower()
　　Out[33]: False
　　In [34]: "wq".islower()
　　Out[34]: True
　　s.isspace #空格
　　In [39]: " ".isspace()
　　Out[39]: True
　　s.isdigit #数字
　　In [40]: "123".isdigit()
　　Out[40]: True
　　s.isalpha #字母
　　import string ##导入模块
　　In [35]: import string
　　In [36]: str
　　str     string
　　In [36]: string.digits##数字
　　Out[36]: '0123456789'
　　In [37]: string.letters##字母
　　Out[37]: 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
　　s.strip##屏蔽前后的空格
　　In [6]: s="      sewqf   few"
　　In [7]: s.strip()##屏蔽前后空格，但是不能去中间的
　　Out[7]: 'sewqf   few'
　　s.lstrip##屏蔽左边的空格
　　s.rstrip##屏蔽右边的空格
　　s.startswith('?')##s是以?开头的，输出true或false
　　s.endswith('?')##s是以?结尾的，输出true或false
　　s.split##指定分隔符
　　In [15]: ip.split('.')##括号里面指用什么作分隔符，默认是空格
　　Out[15]: ['172', '25', '254', '39']
　　In [18]: 'swfr:def:21:dfew:///'.split(":")
　　Out[18]: ['swfr', 'def', '21', 'dfew', '///']
　　练习：
　　要求用户输入一个英文句子，统计该英文句子中含有单词的数目；
　　提示：英文单词间可以认为都用英文空格进行分割
　　测试数据：
　　-输入：my name is aely
　　-输出：4
　　#########
　　#!/usr/bin/env python
　　#coding:utf-8
　　__author_ = "aely"
　　'''
　　@author:aely
　　@file:tsetter.1.py
　　@contact:
　　@time:7/1/1711:13 AM
　　@desc:
　　'''
　　a = raw_input("Please input an English sentence:")##定义字符型
　　str1 = a.split()##用空格分隔a
　　print len(str1)##输出str1的长度
　　##########
　　实验输出：
　　Please input an English sentence:my name is xiao
　　4
　　列表的定义:
　　# 定义一个空列表
　　list = []
　　In [24]: li
　　Out[24]: ['xiaowenya', 3, 'boy']
　　In [27]: "xiaowenya" in li
　　Out[27]: True
　　In [28]: "xiaopangpang" in li
　　Out[28]: False
　　In [29]: "xiaopangpang" not in li
　　Out[29]: True
　　# 定义一个包含元素的列表,元素可以是任意类型,包括数值类型,列表,字符串等均可。
　　列表是可变类型的序列,而元组与字符串是不可变类型的序列
　　# 此处定义一列表,名为list1
　　>>> list1 = ["fentiao", 4, "male"]
　　# 通过python的内置函数type查看list1的数据类型
　　>>> type(list1)
　　<type 'list'>##类型是列表
　　>>> list1[1]##查看下标为1元素的值
　　4
　　>>> list1[1] = 5##重新给这个索引赋值
　　>>> list1##发现列表的元素是可变的
　　['fentiao', 5, 'male']
　　列表的操作:理解"对象=属性+方法"与类
　　列表的索引和切片
　　# 列表的索引:下标是从0开始计算,比如list[0]读取的是列表的第1个元素;
　　list[-1]读取的是列表的倒数第1个元素;
　　>>> list1[0]
　　'fentiao'
　　>>> list1[-1]
　　'male'
　　# 列表的切片
　　>>> list1[:]            //通过切片的方式可以实现列表的复制
　　['fentiao', 5, 'male']
　　# 0代表从哪个索引开始切片,3代表切片到哪个位置,并且不包含第三个索引,2代表切片的步长;
　　>>> list1[0:3:2]
　　['fentiao', 'male']
　　列表的添加:
　　>>> list1[3] = "cat"
　　Traceback (most recent call last):
　　File "<stdin>", line 1, in <module>
　　IndexError: list assignment index out of range
　　>>> list1.append('cat')##添加元素
　　>>> list1
　　['fentiao', 5, 'male', 'cat']
　　列表的删除:
　　方法一:
　　>>> list1.remove("cat")>>> list1
　　['fendai', 5, 'male']
　　方法二:
　　>>> list1.remove(list1[3])
　　>>> list1
　　['fendai', 5, 'male']
　　方法三:
　　>>> del(list1[3])
　　>>> list1
　　['fendai', 5, 'male']
　　列表的修改
　　>>> list1
　　['fentiao', 5, 'male', 'cat']

　　>>>>　　140205776057408
　　>>> list1[0] = "fendai"
　　>>> list1
　　['fendai', 5, 'male', 'cat']

　　>>>>　　140205776057408
　　列表的重复
　　In [36]: li3 = li*3
　　In [37]: li3
　　Out[37]: ['xiaowenya', 3, 'boy', 'xiaowenya', 3, 'boy', 'xiaowenya', 3, 'boy']
　　列表的计算
　　In [30]: li1 = [1,2]+[3]
　　In [31]: li1
　　Out[31]: [1, 2, 3]
　　In [32]: li = [1,2]+3##只能类型相同
　　---------------------------------------------------------------------------
　　TypeError                                 Traceback (most recent call last)
　　<ipython-input-32-ca053263556f> in <module>()
　　----> 1 li = [1,2]+3
　　TypeError: can only concatenate list (not "int") to list
　　li.append 添加  li.extend 可叠代的   li.insert  插入 li.remove  删除 li.sort 排序
　　li.count  计数  li.index 索引    li.pop 弹出     li.reverse  倒叙
　　In [44]: li
　　Out[44]: ['xiao', 3, 'boy', 'like', 'yes']
　　In [47]: li.remove(li[1])##删除
　　In [50]: li
　　Out[50]: ['xiao', 'boy', 'like', 'yes']
　　In [51]: li.pop()##弹出
　　Out[51]: 'yes'
　　In [52]: li
　　Out[52]: ['xiao', 'boy', 'like']
　　In [53]: li.append('ni')##添加
　　In [54]: li
　　Out[54]: ['xiao', 'boy', 'like', 'ni']
　　In [55]: li.extend(['5','wq'])##可叠带增加多个元素
　　In [56]: li
　　Out[56]: ['xiao', 'boy', 'like', 'ni', '5', 'wq']
　　In [57]: li.insert(1,'is')##在“1”的位置上插入is
　　In [58]: li
　　Out[58]: ['xiao', 'is', 'boy', 'like', 'ni', '5', 'wq']
　　In [63]: li.sort()##排序
　　In [64]: li
　　Out[64]: ['5', 'boy', 'is', 'like', 'ni', 'wq']
　　In [71]: li.index('is')##索引，is是li列表的第2位
　　Out[71]: 2
　　In [72]: li.count('is')##计数，查看is出现几次
　　Out[72]: 1
　　In [74]: li.reverse()##倒序
　　In [75]: li
　　Out[75]: ['wq', 'ni', 'like', 'is', 'boy', '5']
　　continue##跳出本轮循环
　　break##彻底跳出循环
　　元组的定义:
　　定义空元组
　　tuple = ()
　　定义单个值的元组
　　tuple = (fentiao,)##后面要加，隔开
　　一般的元组
　　tuple = (fentiao, 8, male)
　　为什么需要元组?
　　>>> userinfo1 = "fentiao 4 male"
　　>>> userinfo2 = "westos 10 unknown"
　　>>> userinfo1[:7]
　　'fentiao'
　　>>> userinfo2[:6]
　　'westos'
　　字符串中操作提取姓名/年龄/性别的方式不方便,诞生元组与列表这两个数据类型
　　>>> t1 = ("fentiao",4,"male")>>> t2 = ("westos", 10, "unknown")
　　>>> type(t1)
　　<type 'tuple'>
　　>>> type(t2)
　　<type 'tuple'>
　　>>> t1[0]
　　'fentiao'
　　>>> t2[0]
　　'westos'
　　>>> t2[0:2]
　　('westos', 10)
　　不能对元组的值任意更改
　　>>> t1
　　('fentiao', 4, 'male')
　　>>> t1[1] = 5
　　Traceback (most recent call last):
　　File "<stdin>", line 1, in <module>
　　TypeError: 'tuple' object does not support item assignment
　　In [93]: t
　　Out[93]: ('1', '2', '3', [1, 3])
　　In [94]: t(3)=5
　　File "<ipython-input-94-230a57c5feed>", line 1
　　t(3)=5
　　SyntaxError: can't assign to function call
　　In [95]: t[3][0]=5##不是绝对不能更改，元组里面的列表可以更改
　　In [96]: t
　　Out[96]: ('1', '2', '3', [5, 3])
　　对元组分别赋值,引申对多个变量也可通过元组方式分别赋值
　　>>> t1
　　('fentiao', 4, 'male')
　　>>> name,age,gender=t1
　　>>> print name,age,gender
　　fentiao 4 male
　　>>> a,b,c=(1,2,3)
　　>>> print a,b,c
　　1 2 3
　　注意:C语言中,定义一类型,必须先开辟一存储空间,当后期重新赋值时也一定是整型的;
　　python中,先在内存上存储数据后,再通过标签去引用。不同的字符串占用不同的存储空间。
　　>>> str1
　　'12345'

　　>>>>　　140205776037520
　　>>> str1 = "abcde"

　　>>>>　　140205776037424
　　>>> str2 = "12345"

　　>>>>　　140205776037520
　　元组的切片：
　　In [97]: t
　　Out[97]: ('1', '2', '3', [5, 3])
　　In [98]: t[0:2]
　　Out[98]: ('1', '2')
　　元组的添加：
　　In [100]: t=(1,2,3)
　　In [101]: type(t)
　　Out[101]: tuple
　　In [102]: t=(1,2,3)+(1,2)
　　In [103]: t
　　Out[103]: (1, 2, 3, 1, 2)
　　In [104]: t=(1,2,3)+1##只能添加相同类型的
　　---------------------------------------------------------------------------
　　TypeError                                 Traceback (most recent call last)
　　<ipython-input-104-fbc0071c5f9b> in <module>()
　　----> 1 t=(1,2,3)+1
　　TypeError: can only concatenate tuple (not "int") to tuple
　　In [105]:
　　元组的
　　In [105]: t.
　　t.count  t.index
　　del(t)##删除元组t
　　集合：
　　1.集合不能为空
　　2.集合中不能出现列表
　　set的应用场景
　　根据前面的这些铺垫,对于为什么会有集合set这个数据类型有了一定的了解,那现在我们做以总结:
　　集合是一个无序的,不重复的数据组合。
　　集合可去除列表中重复的元素。集合有其他数据类型没有的属性,即关系测试,包含交集、差集、并集、是否为子集、是否为父集等方法。
　　集合的关系测试操作
　　#/usr/bin/env python
　　#coding:utf-8
　　定义集合的两种方法：
　　1） 定义一列表,名为list_1
　　list_1 = [1, 2, 3, 4, 5, 1, 2, 3]
　　通过set方法,将数据类型从列表转换为集合的数据类型
　　set_1 = set(set_1)
　　2） 直接定义一集合,名为set_2
　　set_2 = {1, 2, 45, 66, 3}
　　print set_1, type(list_1),type(set_1)
　　print set_1, set_2
　　'''
　　实现集合的关系的第一种方式:set已有方法实现
　　'''
　　# 交集
　　print "交集为: set_1.intersection(set_2)    或者  s1&s2
　　#并集
　　print "并集为: set_1.union(set_2)    或者    s1 | s2
　　list1 = [1,2,3,4,1,2,3]
　　s1 = set(list1)
　　print s1
　　s2 = {1,2,100,'hello'}
　　print s1.union(s2)##s2与s1的并集
　　print s1.intersection(s2)##s2与s1的交集
　　s2.intersection_update(s1)##将s1与s2求交集并更新给s2
　　print s1
　　print s2
　　输出：
　　set([1, 2, 3, 4])
　　set([1, 2, 3, 4, 100, 'hello'])
　　set([1, 2])
　　set([1, 2, 3, 4])
　　set([1, 2])
　　#差集s1 - s2
　　print "set_1与set_2的差集为:set_1.difference(set_2)
　　print "set_2与set_1的差集为:set_2.difference(set_1)
　　list1 = [1,2,3,4,1,2,3]
　　s1 = set(list1)
　　print s1
　　s2 = {1,2,100,'hello'}
　　print s1.difference(s2)
　　print s2.difference(s1)
　　输出：
　　set([1, 2, 3, 4])
　　set([3, 4])
　　set([100, 'hello'])
　　# 对等差分       s2 ^ s1(只取两个不同的部分)
　　//symmetric 对称的,与set_1.difference刚好相反
　　print "set_1的对等差分:%s " % set_1.symmetric_difference(set_2)
　　#子集
　　print "set_1是set_2的子集么?  %s" % set_1.issubset(set_2)#父集
　　print "set_2是set_1的父集么?  %s" % set_1.issuperset(set_2)
　　#Return True if two sets have a null intersection.
　　print  "set_1和set_2是否没有交集?  %s" % set_1.isdisjoint(set_2)
　　'''
　　实现集合的关系的第二种方式:数学符号实现
　　'''
　　# 交集
　　print set_1 & set_2
　　#并集
　　print set_1 | set_2
　　#差集
　　print set_1 - set_2
　　print set_2 - set_1
　　# 对等差分
　　print set_1 ^ set_2
　　集合的增删
　　#!/usr/bin/env python
　　#coding:utf-8
　　'''
　　实现集合的增加与删除
　　'''
　　s = {1,2,3}
　　# 集合的添加
　　s.add(1)            #在集合中添加一项
　　s.update([1,3,4])   #在集合中添加多项,跟的参数应该是可迭代类型
　　print s# 集合的删除
　　s.remove(1)         #删除集合中指定的元素,如果该元素不存在,则报错
　　s.discard(1)        #删除集合中指定的元素,如果该元素不存在,则不报错
　　s.pop()             #随机删除集合中的某个元素
　　s.clear()           #清空集合的所有元素
　　# 集合的其他操作
　　print len(s)        #显示集合set的长度
　　print 1 in s        #检测某元素是否为集合s的成员,返回布尔值
　　s.copy()          #集合的浅拷贝,此处不深入研究,后面会说