python列表元组字典集合实验心得_《Python学习手记》——Python容器：列表，元组，字典，集合...

列表

#coding=gbk

#元组和列表不要求所含元素种类相同

#元组不可变，列表可变

#列表

#使用[]和list()创建列表

test=['a','b']

print(test)

test.append('c')

print(test)

test2=list()

test2.append("test2'str")

#使用extend()或+=合并列表

test.extend(test2)

print(test)

#使用insert()在指定位置插入元素

#if offset equal to 0 insert to head,else if offset greater than end,then will insert to end

test.insert(0,'1')

test.insert(4,'d')

print(test)

#使用del删除指定位置的元素,del是Python语句，不是列表方法

del test[0]

print(test)

#使用remove()删除具有指定值的元素

test.remove('d')

#使用pop()获取并删除指定位置的元素

#该功能类似出栈，但可以指定偏移量，默认弹出列表最后一个元素

print("poping"+test.pop())

#使用index()查询具有特定值的元素位置

print(test.index('a'))

#使用in判断值是否存在

print('g' in test)

#使用count()记录特定值出现的次数

test.append('1')

test.append('1')

print(test)

print("1出现的次数:",test.count('1'))

#使用join()转换为字符串，join()是字符串方法，不是列表方法

#join()是split()的逆过程

tuples=['hello','py']

separator=','

str=separator.join(tuples)

print(str)

separated = str.split(separator)

print(separated)

#使用sort()重新排列元素

#列表方法sort()会对原列表进行排序，改变原列表内容

#通用函数则会返回排好序的列表副本，原列表内容不变

#tosort=[1,'a',3,2,'c','b']会抛出异常,不能对同时含有字母和数字的列表进行排序

tosort=[1,3,2]

print(sorted(tosort))

#通过对sort()添加参数reverse=True实现降序排列

tosort.sort(reverse=True)

print(tosort)

#使用=复制，使用copy()复制

list1=list()

list1.append("")

list1[0]="to"

list2=list1.copy()

#使用list()转换函数和列表分片可以实现复制

list3=list(list1)

list4=list1[:]

print(list1)

print(list2)

print(list3)

print(list4)

元组

#encoding=gbk

#元组，由任意类型元素组成的序列，相当于一个常量列表

#使用元组的原因：

#1.元组占用的空间较小

#2.可以避免意外修改元组的值

#3.可以将元组用作字典的键

#4.命名元组可以作为对象的替代

#5.函数的参数是以元组形式传递的

#使用()创建一个空元组

empty=();

#创建一个包含一个或多个元素的元组时，每一个元素后面都需要跟一个逗号，即使只包含一个元素也不能省略

#如果创建的元组元素数量超过1，最后一个元素的逗号可以省略,定义元组真正靠的是每个元素的后缀逗号

tuples='a',"str",'tuple'

print(tuples)

#元组解包-将元组赋值给多个变量

a,b,c=tuples

print(a,b,c)

#利用元组对多个变量值进行交换，而不借助临时变量

a='广州','天河'

b='北京','海淀'

a,b=b,a

print(a,b)

#使用tuple()函数，用其他类型的数据来创建元组

li=['a','b','d']

print(tuple(li))

字典

#coding=gbk

#字典，又称关系型数组，哈希表(Hash Table)，哈希图，与列表类似，简写成dict

#通过键访问元素而非偏移量，每个元素拥有与之对应的互不相同的键key

#字典是可变的，可以对键值对进行增删改

#使用{}创建字典

#用大括号{}将一系列以逗号隔开的键值对(key:value)包裹起来即可进行字典的创建

#创建空字典并添加键值对

dicts={}

dicts={

"day":"one",

"month":"April",

"year":2018

}

print(dicts)

#使用dict()转换为字典，dict()可以将包含双值子序列的序列转换为字典

#1.双值列表的列表

bat=[['tencent','qq'],['baiduyun','baidu'],['taobao','alibaba']]

toDict=dict(bat)

print(toDict)

#2.双值元组的列表

words=[('1','a'),('2','b')]

toDict=dict(words)

print(toDict)

#3.双值列表的元组

words=(['1','一'],['2','二'])

toDict=dict(words)

print(toDict)

#4.双字符的字符串组成的列表

words=['ab','cd']

toDict=dict(words)

print(toDict)

#5.双字符的字符串组成的元组

words=('ab','cd')

toDict=dict(words)

print(toDict)

#使用[key]添加或修改元素

prog={

'soft':'java',

'hard':'c/c++',

'web':'html'

}

prog['web']+='/css'

prog['ai']='python'

print(prog)

#使用update()合并字典，若待添加字典与待扩充字典包含相同键，则新归入字典的值会取代原有的值

other={

'mobile':'ios/andriod',

'web':'jquery'

}

prog.update(other)

print(prog)

#使用del删除具有指定键的元素

del prog['hard']

print(prog)

#使用clear()删除所有元素

prog.clear()

print(prog)

#使用in判断是否存在

print('web' in other)

print('hard' in other)

#使用[key]获取元素，若指定键不存在，会抛出一个异常

print(other['web'])

#字典函数get()，需要指定字典名，键，以及一个可选值，若键不存在但指定了可选值，则返回可选值，否则返回None

print(other.get('soft','c#'))

#使用keys()获取所有键

#Python2,keys()返回一个列表，而在Python3则返回dict_keys(),它是键的迭代形式，这种返回形式对大型字典非常有用

#因为它不需要时间和空间来创建返回的列表，若需要一个完整的列表，可以调用list()将ditc_keys转换为列表类型

key_list=other.keys()

print(key_list)

print(list(key_list))

#使用values()获取所有值

print(list(other.values()))

#使用items获取所有键值对，以元组的形式返回

print(list(other.items()))

#使用=赋值，使用copy()复制

other['web']+=' html/css3'

print(other)

oth_cp=other.copy()

print(oth_cp)

集合

#encoding=gbk

#集合

#使用set()创建集合，或者用{}将一系列以逗号隔开的值包裹起来

number=set('1234')

letter={'a','b','c'}

print(number)

print(letter)

#使用set()将其他类型转换为集合

print(set(['java','c++','c#']))

print(set(('java','c++','c#')))

print(set({'soft':'java','hard':'c'}))

#使用in测试值是否存在

food={

"中餐":{"扬州炒饭","重庆火锅"},

"西餐":{"牛排"},

"日系料理":{"拉面"}

}

#超严格，要注意缩进和对齐！！！

for kind,name in food.items():

if "中餐" in kind and not ("炒面" in name):

print(name)

#合并及运算符

#交集运算符&

for kind,name in food.items():

if {'炒面'} & name:

print(True)

else:

print(False)

#使用&或者集合函数intersection()获取集合的交集

sa={'a','b','c'}

sb={'a','d','e'}

print(sa&sb)

print(sa.intersection(sb))

#使用|或union()获取集合的并集，每次结果顺序不一定一致，因为集合是无序的

print(sa|sb)

print(sa.union(sb))

#使用-或者difference()获取集合的差集

print(sa-sb)

print(sa.difference(sb))

#使用^或symmetric_difference()获取集合的异或集

print(sa^sb)

print(sa.symmetric_difference(sb))

#使用<=或者issubset()判断一个结合是否是另一个集合的子集(第一个集合的所有元素都出现在第二个集合中)

sc={'a','c'}

print(sc<=sa)

print(sa.issubset(sb))

#使用

print(sc

#使用>=或issupuerset()判断超集，与子集相反，即第二个集合的所有元素都出现在第一个集合中

print(sa>=sc)