python-day2

Posted 2020-10-06

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

#-*-coding:utf-8-*- #1、字典 dict = {‘name‘: ‘Zara‘, ‘age‘: 7, ‘class‘: ‘First‘} #字典转为字符串，返回：<type ‘str‘> {‘age‘: 7, ‘name‘: ‘Zara‘, ‘class‘: ‘First‘} print type(str(dict)), str(dict) #字典可以转为元组，返回：(‘age‘, ‘name‘, ‘class‘) print tuple(dict) #字典可以转为元组，返回：(7, ‘Zara‘, ‘First‘) print tuple(dict.values()) #字典转为列表，返回：[‘age‘, ‘name‘, ‘class‘] print list(dict) #字典转为列表 print dict.values #2、元组 tup=(1, 2, 3, 4, 5) #元组转为字符串，返回：(1, 2, 3, 4, 5) print tup.__str__() #元组转为列表，返回：[1, 2, 3, 4, 5] print list(tup) #元组不可以转为字典 #3、列表 nums=[1, 3, 5, 7, 8, 13, 20]; #列表转为字符串，返回：[1, 3, 5, 7, 8, 13, 20] print str(nums) #列表转为元组，返回：(1, 3, 5, 7, 8, 13, 20) print tuple(nums) #列表不可以转为字典 #4、字符串 #字符串转为元组，返回：(1, 2, 3) print tuple(eval("(1,2,3)")) #字符串转为列表，返回：[1, 2, 3] print list(eval("(1,2,3)")) #字符串转为字典，返回：<type ‘dict‘> print type(eval("{‘name‘:‘ljq‘, ‘age‘:24}"))

一、元组(tuple)

1.特性：不可更改的数据序列。【理解：一旦创建元组，则这个元组就不能被修改，即不能对元组进行更新、增加、删除操作】

2.创建：一对圆括号“（）”和其包含的元素（若没有元素，则为空元组）。

　　　　创建一般元组：即一维元组。如：tempTuple = ("one","two","three",4,5,6)。

　　　　创建嵌套元组：元组中还可以包含元组，即嵌套元组或二维（多维）元组。如：mulTuple = (("you","are","a","dog"),"you","too")。

　　注：若想创建包含一个元素的元组，则必须在该元素后面加逗号“,”，否则创建的不是一个元组，而是一个字符串。

　　　　如：aTuple = ("one",)，aString = ("one")。type(aTuple) -> "tuple"，type(aString) ->"string"。

3.访问：元组名[index],index为元素在元组中的索引，索引为整数，从0开始。注意：index不能越界，否则会报错。

　　　　访问一般元组：tempTuple[0] -> "one",tempTuple[3] -> 4。

　　　　访问嵌套元组：mulTuple[0][1] ->"are"。

　　注：可以使用负数作为索引来访问元组。-1代表最后一个元素，-2代表倒数第二个，以此类推。如：tempTuple[-1] ->"too"。

　　      可用for循环遍历元组。如：for element in tempTuple: print(elment)。

4.求长：len(元组名)。如len(tempTuple) ->6。（长度也即元组中元素的个数）。

5.打印：print(元组名)，可打印元组中的所有元素。

6.类型：type(元组名) ->"tuple"。

7.删除：del 元组名，删除元组，当访问被删除的元组时会报错，提示：元组未定义。（其他类型也可以用此方法）

二、列表(list)

1.特性：可更改的数据数列。(区别于元组，可动态增加，删除，更新)

2.创建：一对方括号“[]”和其包含的元素,单个元素可以不加逗号，同元组一样，可以创建嵌套列表。如：tempList = ["one","two","three"]。

3.基本操作及方法：

　　（1）访问、遍历、求长、打印、类型等操作同元组

　　（2）更新：给列表中的元素重新赋值，不可给列表中不存在的元素赋值。如：tempList[2] = 3 ->tempList = ["one","two",3]，tempList[3] = "four" ->报错！！！

　　（3）删除：删除元素后（若不是最后一个），右边的元素会左移。

　　　　1)del:删除指定元素。如：del tempList[0] ->tempList = ["two","three"]

　　　　2)pop：删除指定位置的元素并返回被删除的元素，默认删除最后一个。如：element = tempList.pop(1) ->element = two,tempList = ["one","three"]。

　　（4）增加(插入)：

　　　　1)append:向列表末尾添加一个元素,参数不能为空，否则报错。如：tempList.append("four") ->tempList = ["one","two","three","four"]。

　　　　2)extend:向列表末尾添加多个元素，参数不能为空，不能是int型，可为字符串（当成列表处理，每个字符就是一个元素）、元组、列表。如：

　　　　　　　　　参数为字符串：tempList.extend("str") ->tempList = ["one","two","three","s","t","r"]。

　　　　　　　　　参数为元组或列表：tempList.extend(("four",“five”)) ->tempList = ["one","two","three","four",“five”]。

　　　　3)list[index:index] = [value]:向列表list指定的位置index插入一个元素。如：tempList[1:1] = ["add"] -> tempList = ["one","add","two","three"].

　　　　　　注：更一般的形式：listname[start:end] = 元组/列表/字符串，可插入多个元素.

4.高级操作及方法：

　　(1)产生一个数值递增列表：

　　　　　　1)pList = range(N)，产生一个元素值为0~N-1的列表。如：pList = range(10) ->pList = [0,1,2,3,...,9]。

　　　　　　2)pList = range(sn,en),产生一个元素值为sn~en-1的列表。如：pList =  range(1,5) ->pList = [1,2,3,4]。

　　　　　　3)pList = range(sn,en,inc),产生一个元素值以inc递增的列表。如：pList = range(1,10,2) ->pList = [1,3,5,7,9]

　　(2)固定值初始化：pList = [value for index  in range(N)]，产生一个长度为N的列表，元素值都为value.

　　　　　　如：value = "x",N=10,则pLsit = ["x","x",...,"x"]

　　　　更简单的形式：pList = [value]*N。

　　(3)操作符：

　　　　1)"+"：两个列表相加，将合成为一个列表。如 pL1 = [1,2],pL2 = [3,4],pL1+pL2 ->[1,2,3,4]

　　　　2)"*"：形式：[value]*N。如value="a",N=4,则得到列表["a","a","a","a"]。

　　　　3)del：del pL[index]:删除指定位置的元素。 del pL[sIndex:eIndex]:删除sIndex~eIndex-1位置的元素。

　　(4)列表复制：

　　　　1)pL1 = pL：pL1为pL的别名，即pL1和pL实质为同一个列表，修改其中一个列表，另一个列表也随之变化。

　　　　　　　　如：pL = [1,2,3],pL1 = pL,pL1[2] = 33,->pL = pL1 = [1,2,33]

　　　　2)pL2 = pL[:]：pL2为pL的一个克隆（或拷贝），即pL2和pL为不同的列表，修改其中一个列表，另一个不会受影响。

　　(5)常用方法：

　        1)L.append(value):向列表末尾插入一个元素

　　　　2)L.insert(index,value)：向列表的index位置插入一个元素value。
　　　　3)L.pop(index)： 从列表中删除指定位置index的元素并返回元素值，默认删除最后一个元素。
　　　　4)L.remove(value)：删除在列表中第一次出现的元素value。如：pList = [1,2,3,2],pList.remove(2) ->pList = [1,3,2]。
　　　　5)L.count(value)：返回元素value在列表中出现的次数。
　　　　6)L.index(value) ：该元素第一次出现的的位置,无则抛异常 。
　　　　7)L.extend(list/tuple/string) ：向列表末尾插入多个元素。
　　　　8)L.sort()：排序

　　　　9)L.reverse()：倒序

三、字典(dictionary)

1.特性：以名称索引的分组数据。元组和列表以数字顺序索引，而字典的索引可以数字，字母，字符串，符号等。

　　　　在字典中，索引叫做：键，即key,对应的值叫做值，即value。

2.创建：dic = {key1:value1,key2:value2},可先创建空字典dic =｛｝，然后再初始化，如dic["one"] = "firstValue"。

　　　　注：键是唯一的，字典只认最后一个赋的键值。如：dic = {1:1,2:2,1:3} ->dic = {1:3,2:2},最后一个元素（1:3）被“舍弃”。

3.访问：dic[key]，获得key对应的值，若key不存在，则报错。

4.常用方法和操作：

　　　　1)D.get(key, defualtValue)：获得key对应的值，若key不存在，则返回设置的默认值defualtValue,若没有设置默认值则返回None。
　　　　2)D.has_key(key) ：检查字典中是否存在键key，有该键返回TRUE，否则FALSE。
　　　　3)D.keys()：返回由字典所有键构成的列表。
　　　　4)D.values()：返回由字典所有值构成的列表。
　　　　5)D.items()：返回由字典所有键值对构成的列表，即[(key1,value1),(key2,value2),(key3,value3),...]。

　　　　6)D.update(dic2)：将字典dic2中的元素合并到字典D中。
　　　　7)D.popitem()：随机删除字典中的一个键值对（一项），并返回值。若字典为空则抛出异常。
　　　　8)D.clear()：清空字典中的元素并返回None

　　　　9)D.pop(key)：删除指定键所对应的项，并返回key对应的值。key不能为空，也不默认删除排在最后的元素，因为字典是无序的，注意和列表的区别！！！
　　　 10)D.copy()：拷贝字典，两个字典不是同一个字典。如d = {1:1,2:2},d1 = d.copy() ->d1 = {1:1,2:2}。
　　　 11)cmp(dict1,dict2)：比较字典，(优先级为元素个数、键大小、键值大小)，第一个大则返回1，第一个小则返回-1，一样大则返回0。
               

四、字符串(string)

1.特性：不能修改的字符序列。除了不能修改，可把字符串当成列表一样处理。

2.访问：访问字符串中某个字符同访问元组或列表中的元素是一样的，专业术语叫“分片（slicing）”。如：str = "aString",str[0] = "a",str[1] = "S"。

　　这里不做深入讨论字符串，把字符串放在这里主要是为了说明字符串具备列表的一些特点。

五、集合(set)

1.特性：与字典类似，但只包含键，而没有对应的值，包含的数据不重复。

2.创建：s = set(list or tuple or string)。重复的值在集合中只存在一个。如：

　　　　列表list：s = set([1,2,3,3]) ->s = set([1,2,3])

　　　　元组tuple：s = set((1,2,3))  ->s = set([1,2,3])

　　　　字符串string：s = set("abc") ->s = set(["a","b","c"])