基础打牢咯！
- 列表
- 元组
- 集合
- 字典
收藏保存，天天码几遍热个身
1、列表：
可变数据类型：list，dict，set
不可变数据类型：int，float，str，tuple
'''-----------列表:5种创建的方式---------------
一、列表的特性
1、有序的集合
2、通过偏移来索引，从而读取数据
3、支持嵌套
4、可变的类型
list的实现方式是链表，空间利用率高追加元素快而方便。
range
列表生成式
append
列表相加
extend
按性能排列（时间复杂度小，性能好）： range() > list生成式 > append > 列表相加 > extend
'''
def test1():
li=list(range(100))
return li
def test2():
li=[i for i in range(100)]
return li
def test3():
li=[]
for i in range(100):
li.append(i)
return li
def test4():
li = []
for i in range(100):
li+=[i]
return li
def test5():
li = []
for i in range(100):
li.extend(i)
return li
增
#列表：4种添加方式
lis1=["2","22"]
lis1.append("1")
lis1.extend(["1","1","1",'2','3'])
lis1.insert(0,"11111")
lis1+=["33"]
print("列表的添删改查",lis1)
删
#4种删除方式
lis1.pop(1)#指定位数
lis1.remove("1")
lis1.clear()
del lis1
# print("列表的添删改查",lis1)
改
#列表修改
lis1=['ftp', 'ssh', 'http', 'ftp']
lis1[0]="ftp1"
lis1[:2]="ftp1" #列表修改 ['f', 't', 'p', '1', 'http', 'ftp']
lis1[:2]=["ftp1","ftp2"] #列表修改 ['ftp1', 'ftp2', 'http', 'ftp']
print("列表修改",lis1)
小扩展
#切片分组，建议直接跑一跑代码帮助理解，我就不放运行结果了
list3=[1,2,3,4,5,6,7,8,9]
print("源列表",id(list3))
list4=list3[1:6:1]
print("切片片段",list4)
list4=list3[::-1]
print("切片片段倒叙",list4)
list3[2:3]=lst
print(list3)
list3[2:5]=[]
print(list3)
2、元组
所谓元组的不可变指的是元组所指向的内存中的内容不可变。
tuple 不可变的好处：
相对于 list 而言，tuple 是不可变的，这使得它可以作为 dict 的 key，或者扔进 set 里，而 list 则不行。
tuple 放弃了对元素的增删（内存结构设计上变的更精简），换取的是性能上的提升：创建 tuple 比 list 要快，存储空间比 list 占用更小。所以就出现了“能用 tuple 的地方就不用 list”的说法。
多线程并发的时候，tuple 是不需要加锁的，不用担心安全问题，编写也简单多了。
上代码
#元组的2种创建方式
str=tuple(['1','1','1',"1","2",'3'])
print(str,type(str))
str1=(1,)
print(str1,type(str))
str=str[:1]+(0,)+str[-1:]
print(str)
#创建的同时加点花里胡哨的玩法
#直接在同一个元组上更新是不可行的，但是可以通过拷贝现有的元组片段构造一个新的元组的方式解决。
#通过分片的方法让元组拆分成两部分，然后再使用连接操作符（+）合并成一个新元组，最后将原来的变量名（temp）指向连接好的新元组。在这里就要注意了，逗号是必须的，小括号也是必须的！
temp = ("龙猫","泰迪","叮当猫")
temp = temp[:2] + ("小猪佩奇",)+temp[2:]
print(temp)
"""
('龙猫', '泰迪', '小猪佩奇', '叮当猫')
Process finished with exit code 0
"""
#删除元组中的元素：对于元组是不可变的原则来说，
#单独删除一个元素是不可能的，当然你可以利用切片的方式更新元组，间接的删除一个元素。
temp = ('龙猫', '泰迪', '小猪佩奇', '叮当猫')
temp = temp[:2] + temp[3:]
print(temp)
"""
('龙猫', '泰迪', '叮当猫')
Process finished with exit code 0
"""
3、集合
1.0 set()函数
描述：可以将其它的组合数据类型转化为可变集合类型(或将不可变的集合类型frozenset转变为可变的集合类型set)，返回一个无重复元素且排序任意的可变集合。
#两种创建方式
li=[1,2,3,4,5,1]
print(set(li))
s1={}
2.0 add()函数
描述：如果集合s中不存在元素x，则将元素x添加到集合s中。
s1.add(11)
3.0 clear()函数
描述：删除集合s中的所有元素。
s1.clear()
4.0 copy()函数
描述：复制生成一个新的集合。
s1.copy()
5.0 discard()函数
描述：移除集合s中的value元素。若value元素存在，则移除，不存在也不报错。
#移除集合s中的value元素。若value元素存在，则移除，不存在也不报错。
#s.discard(value)
s = {1,2,3,4,5,"a","ab","h"}
s.discard(1) #移除元素 1
s.discard("ab") #移除元素 "ab"
s.discard("hj") #移除元素 "hj",但集合s中不存在元素"hj"
print(s)
6.0 remove()函数
描述：移除集合s中的value元素。若value元素存在，则移除，不存在则报错(产生KeyError异常)。
s = {1,2,3,4,5,"a","ab","h"}
s.remove(1) #移除元素 1
s.remove("ab") #移除元素 "ab"
print(s)
s.remove("hj") #移除元素 "hj",但集合s中不存在元素"hj" 程序会报错
print(s)
7.0 pop()函数
描述：随机移除集合s中的一个元素并返回该元素。若集合为空则报错(产生KeyError异常)
s1 = {1,2,3,4,5,"a","b"}
print(s1.pop()) # 随机删除一个元素并返回
print(s1)
s2 = set() #创建一个空集合
print(s2.pop()) #s2为空集合，程序会报错。
8.0 difference()函数
差集概念：一般地，记A，B是两个集合，则所有属于A且不属于B的元素构成的集合，叫做集合A减集合B（或集合A与集合B之差），类似地，对于集合A、B，我们把集合 x|x∈A,且x∉B 叫做A与B的差集
a = {1,2,3,"a","b","c"}
b = {1,2,"a","h","78","b"}
x1 = a.difference(b) #集合a 减 集合b
x2 = b.difference(a) #集合b 减 集合a
print(x1)
print(x2)
print(a,b) #集合a和集合b的元素不改变。
#{3, 'c'}
#{'78', 'h'}
#{1, 2, 3, 'b', 'a', 'c'} {1, 2, 'b', 'a', 'h', '78'}
9.0 difference_update()函数
描述：把集合a更新为集合a与集合b的差集。集合a元素被更新改变，但集合b元素不改变。
#实例一
a = {1,2,3,"a","b","c"}
b = {1,2,"a","h","78","b"}
a.difference_update(b) #把集合a 更新 为集合a与集合b的差集
print(a.difference_update(b)) #返回值为空。
print(a) #集合a元素被更新改变。
print(b) #集合b元素不改变
#None
#{3, 'c'}
#{1, 2, 'b', 'a', 'h', '78'}
#实例二
a = {1,2,3,4,5,6,"a","b","c"}
b = {1,2,"h"} #集合
l = [4,"a"] #列表
t = ("c","88") #元组
d = {"k":11,5:"666"} #字典
#从集合a中删除在 集合b 列表l 元组t 字典d 中出现过的元素。
a.difference_update(b,l,t,d)
print(a)
#{'b', 3, 6}
10.0 union()函数
描述：生成集合的并集。即将集合a和集合b取并集，并将并集作为一个新的集合返回， 但是不改变原集合a和集合b
a = {1,2,"a","b"}
c = {3,5,"a"}
d = {"b",7,8,9}
print(a.union(c,d)) #返回集合a,集合b,集合c 的并集
print(a.union(c)) #返回集合a,集合c的并集
#{1, 2, 'b', 3, 5, 7, 8, 'a', 9}
#{1, 2, 'b', 3, 5, 'a'}
11.0 update()函数
描述：将集合a和集合b取并集，并将结果保存在集合a中(即更新集合a)，集合b不改变，但是没有返回值。
a = {1,2,3,"a","b"}
b = {7,2,9,"j"}
a.update(b)
print(a.update(b)) #返回值为空
print(a) #集合a被更新。
print(b) #集合b不改变。
#None
#{1, 2, 3, 7, 'b', 9, 'a', 'j'}
#{9, 2, 'j', 7}
12.0 symmetric_difference()函数
描述：返回对称差集(反向交集)，即返回两个集合中不重复的元素集合，即移除两个集合中都存在的元素。
a = {1,2,3,"a","b"}
b = {5,6,1,"b","c"}
x1 = a.symmetric_difference(b)
print(x1)
print(a,b)
#{2, 3, 5, 6, 'c', 'a'}
#{1, 2, 3, 'b', 'a'} {'c', 1, 'b', 5, 6}
13.0 symmetric_difference_update()函数
函数：把集合a更新为：集合a与集合b的对称差集。集合a元素被更新改变，但集合b元素不改变。
a = {1,2,3,"a","b"}
b = {1,5,6,"a",}
a.symmetric_difference_update(b) #取集合a和集合b的对称差集，更新集合a并保存在集合a中
print(a.symmetric_difference_update(b)) #返回值为空
print(a) #集合a被更新.
print(b) #集合b元素不变。
#None
#{1, 2, 3, 'b', 'a'}
#{1, 'a', 5, 6}
14.0 intersection()函数
描述：生成集合的交集。
a = {1,2,3,"a","b"}
c = {2,8,"b","a","c"}
b = {1,2,5,8,"a","k"}
x1 = a.intersection(b) #返回集合a 和集合b 的交集
x2 = a.intersection(b,c) #返回集合a,集合b,集合c的交集
print(x1)
print(x2)
print(a,b,c) #集合a,集合b,集合c 元素不改变
#{1, 2, 'a'}
#{2, 'a'}
#{1, 2, 3, 'b', 'a'} {1, 2, 'k', 5, 8, 'a'} {8, 'b', 2, 'a', 'c'}
15.0 intersection_update()函数
描述：把集合a更新为：集合a与集合b(或多个集合)的交集。集合a元素被更新，但集合b(其它集合)的元素不改变。
a = {1,2,3,"a","b"}
c = {2,8,"b","a","c"}
a.intersection_update(b) #取集合a和集合b的交集，更新集合a并把结果保存在集合a中
print(a.intersection_update(b)) #返回值为空
print(a) #集合a中的元素被更新
print(b) #集合b中的元素不改变
#None
#{1, 2, 'a'}
#{1, 2, 'k', 5, 8, 'a'}
16.0 isdisjoint()函数
描述：判断两个集合是否包含相同的元素，若没有相同元素则返回 True，否则返回 False。
a = {1,2,3,"a"}
b = {"b","c","55","66"}
c = {1,2,5,"a"}
print(a.isdisjoint(b)) #集合a与集合b无相同的元素 返回True
print(a.isdisjoint(c)) #集合a与集合c有相同的元素，返回False
17.0 issubset()函数
描述：判断两个集合是否是子集关系(A⊆B)。即判断集合a中的所有元素是否都包含在集合b中，若都包含在集合b中则返回True，否则返回False
a = {1,2,3,"a"}
b = {1,2,3,"a","b","c"}
c = {1,2,3,"b","h"}
print(a.issubset(b)) #集合a是集合b的子集
print(a.issubset(c)) #集合a不是集合b的子集
#True
#False
18.0 issuperset()函数
描述：判断两个集合是否是超集(父集)。即判断集合b中的所有元素是否都包含在集合a中，若都包含在集合a中则返回True，否则返回False
a = {1,2,3,"a","b","c"}
b = {1,3,"a"}
c = {1,2,3,"b","h"}
print(a.issuperset(b)) #集合a是集合b的超集.
print(a.issuperset(c)) #集合a不是集合b的超集。
#True
#False
4、字典
字典，不支持索引和切片，但可通过key值查询values值，key值唯一 字典的key值是唯一的
#两种创建方式
str={"1":1}
print(str,type(str))
str=dict(name=1,age=2)
print(str,type(str))
增/改
#增
service.update({'1':2})
service.update({'22':33,'44':55})
service['12321']='11'
service.update(s1=2)
service.setdefault('http',9090)
service.setdefault('oracle',44575)
#dict.fromkeys() # 设置相同的键对应的值
key=[]
def test5():
for i in range(20):
key.append(i)
test5()
print("键值",key)
dict1={}.fromkeys(key)
print("dict1",dict1)
dict1={}.fromkeys(key,"11")
print("dict1",dict1)
删
del service['1']
#字典不能切片，所以pop()括号中的是key
#pop删除指定key对应的value值
#如果key存在，删除，并且返回删除key对应的value(可以用变量取接收)
#如果不存在，直接报错
service.pop("22")
print(service)
service.popitem()
print(service)
service.clear()
print(service)
查
print(service.items())
print(service.values())
print(service.keys())
字典方法汇总
-
clear(self)
-
copy(self)
-
fromkeys(*args, **kwargs) @staticmethod
-
get(self, *args, **kwargs)
-
items(self)
-
keys(self)
-
pop(self, k, d=None)
-
popitem(self, *args, **kwargs)
-
setdefault(self, *args, **kwargs)
-
update(self, E=None, **F)
-
values(self)
fromkeys(*args, **kwargs) @staticmethod此处巨坑，仔细看输出有什么问题
d = dict.fromkeys(['a', 'b', 'c'], {'score':0, 'type': []})
print(d)
d['a']['score'] = 3
d['b']['type'].append('type b')
print(d)
#{'a': {'score': 0, 'type': []}, 'b': {'score': 0, 'type': []}, 'c': {'score': 0, 'type': []}}
#{'a': {'score': 3, 'type': ['type b']}, 'b': {'score': 3, 'type': ['type b']}, 'c': {'score': 3, 'type': ['type b']}}
建议换个方法实现，fromkeys类似于浅拷贝了，所设定的默认值，是存储在同一块存储空间上的，相当于所有的值都是同一个值，可以参考一下python变量的引用赋值及深浅拷贝
d = {key: {'score': 0, 'type': []} for key in ['a', 'b', 'c']}
print(d)
#{
# 'a': {'score': 0, 'type': []},
# 'b': {'score': 0, 'type': []},
# 'c': {'score': 0, 'type': []}
#}
d['a']['score'] = 3
d['b']['type'].append('type b')
print(d)
#{
# 'a': {'score': 3, 'type': []},
# 'b': {'score': 0, 'type': ['type b']},
# 'c': {'score': 0, 'type': []}
#}
扫一扫
1653
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
