《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<sa)

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