################## 列表中的基本操作 ##################
1.列表的基本形式
Li = [1,2,3,”henry”,”hello”,[“hhhh”,”aaaa”]]
# 用中括号括起来
# 利用逗号分割每个元素
# 列表是有序的
# 列表中的元素可以是数字，字符串，也可以嵌套列表，也可以是布尔值
2.列表为可迭代类型，支持for循环，也支持whilw循环
3.列表的存储与字符串的存储方式不同，列表通过链表进行存储，不需要连续的空间，列表元素可在原列表中进行修改，不必创建新的列表（对字符串的修改相当于创建新的空间来存放字符串）
4.列表索引或切片
5.用索引来删除元素 del [1]
6.利用切片来删除元素 del [0:3]
7.in 操作 # 判断一个元素或字符串是否在列表中
>>> test = ["aaa","b","ccc",1,2,3,] >>> a = "aaa" in test >>> a True >>>
8.将一个字符串转为列表（不能对数字进行for循环，所以不能将数字转为列表）
>>> test = "helloworld" >>> new_test = list(test) >>> new_test ['h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd'] >>>
9.将字符串进行拼接
test_list = [11,22,33,"hello","world"] s = " " for item in test_list: s = s + str(item) print(s) # 输出 112233helloworld ################################ 当列表中只包含字符串时，有数字时不能用join进行拼接 test_list = ["hello","world"] print(",".join(test_list)) # 输出为 hello,world
################## 列表中的方法 ##################
1.test.append(x) # 在列表test后追加元素x
2.test.clear() # 清空列表
3.test_new = test.copy() # 浅拷贝
4.test.count(x) # 计算列表中元素x的出现次数，不带参数则报错
5.append() 和 extend() 的区别
# append() # 将括号中的列表当成一个元素 >>> test = [1,2,3,4,5] >>> test.append([111,"hello"]) >>> test [1, 2, 3, 4, 5, [111, 'hello']] # extend() # 将列表的每个元素插入 >>> test = [1,2,3,4,5] >>> test.extend([111,"hello"]) >>> test [1, 2, 3, 4, 5, 111, 'hello'] >>> # 插入字符串 test.extend("aaa") # [1, 2, 3, 4, 5, 'a', 'a', 'a'] test.append("aaa") # [1, 2, 3, 4, 5, 'aaa']
6.test.index(a,start=None,end=None) # 查找，找到第一个就停止查找，指定开始statrt，结束end位置,返回索引值
7.test.insert(0,99) # 在指定的位置插入指定元素，在索引0处插入元素99，原先索引位置的元素往后移
8.a = test.pop(x) # 删除索引x处的元素(默认删除最后一个元素)，并返回当前被删除的值
>>> test = [1,2,3,4,5] >>> a = test.pop(2) >>> a 3
9.test.remove(a) # 删除列表中指定的元素 a，删除列表从左到右第一个元素a
10.test.reverse() # 将列表test反转
>>> test = [1,2,3,2,4,5] >>> test.reverse() >>> test [5, 4, 2, 3, 2, 1] >>>
11.test.sort() # 将当前列表进行排序，默认从小到大，括号中可指定从大到小 reverse=True
1.基本形式：tu = (11,22,33,44,55)
2.特性：元素不能被修改，不能增加或删除元素，元组为有序的
3.一般写元组时，在元组的最后加上一个","（对长度没有影响） 用来区别元组和方法
4.对元组进行切片，索引 tu[1:2] tu[0]
5.元组/列表/字符串，三者之间可以进行相互转换
# 元组->列表 tu = (1,2,4,"111","hello") li = list(tu) print(li) # [1, 2, 4, '111', 'hello'] # 列表->元组 li = [1,2,4,"111","hello"] tu = tuple(li) print(tu) # (1, 2, 4, '111', 'hello') # 列表->字符串 li = [1,2,4,"111","hello"] s = str(li) print(s) # [1, 2, 4, '111', 'hello'] # 字符串->列表 s = "1,2,4,111,hello" li = list(s) print(li) # ['1', ',', '2', ',', '4', ',', '1', '1', '1', ',', 'h', 'e', 'l', 'l', 'o'] # 元组->字符串 tu = (1,2,4,"111","hello") s = str(tu) print(s) #(1, 2, 4, '111', 'hello') # 字符串->元组 s = "1,2,4,111,hello" tu = list(s) print(tu) # ['1', ',', '2', ',', '4', ',', '1', '1', '1', ',', 'h', 'e', 'l', 'l', 'o']
6.元组的一级元素不可被修改/删除/增加
>>> tu = (1,"hello",(11,22),[11,22],True,11) >>> tu[0] = 2 Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'tuple' object does not support item assignment >>>
6.若元组的二级元素不再是元组，则可对其进行修改
>>> tu = (1,"hello",(11,22),[11,22],True,11) >>> tu[3][0] = 33 >>> tu (1, 'hello', (11, 22), [33, 22], True, 11) >>>
1.字典的基本形式：info = {"k1":"v1","k2":"v2"}
2.字典就是键值对形式： key:value
3.注
value：可以是任意值，字符串，元组，列表均可
key：数字，字符串，元组，布尔值（但应注意会和0和1会重复 出现重复只保留其中的一个）
列表不能作为字典key
字典不能作为字典的key
4.当字典中的键key出现重复时 只保留其中的一个
5.字典是无序的，例如每次打印出来的顺序会不同
6.info["k1"] 根据键值对的键来进行查找
7.因为字典是无序的，所以不能通过切片方式进行查找
8.对字典进行循环，默认进行循环的是字典的key
for item in info：
print(item) 输出为 k1 k2
for item in info.key：# 取得键值对的键
print(item)for item in info.value：# 取得键值对的值
print(item)for k,v in info.items： # 取得键值对
print(k,v)
################## 字典中的方法 ##################
1.a = dict.fromkeys(["k1 ",123,"999"],123) # 创建一个新的字典，其中键由迭代和值设置为值
(1, 'hello', (11, 22), [33, 22], True, 11) >>> a = dict.fromkeys(["k1 ",123,"999"],123) >>> a {'999': 123, 123: 123, 'k1 ': 123} >>>
2.v = info.pop('k1') # 删除当前的键值对 并且可以获得当前所删除键值对的值
3.v = info.popitem() # 随机删除一个键值对 并返回所删除的值
4.info.setdefault("k1","hello")
# 设置值 当前的key已经存在的话 获取当前key对应的值 # 如果key不存在的话 设置当前的键值对 并获取当前key 对应的值 # 当key值存在时 info = {"k1":"v1","k2":"v2"} a = info.setdefault("k1","hello") print(a) # 输出为 v1 # 当key不存在时 info = {"k1":"v1","k2":"v2"} a = info.setdefault("k3","hello") print(a) # 输出为 hello
5.info.update({"xxx":"yyy"}) # 更新当前字典
info = {"k1":"v1","k2":"v2"}
a = info.update({"k3":"hello"})
print(info)
# 输出 {'k1': 'v1', 'k2': 'v2', 'k3': 'hello'}
6.根据key获取值，存在时，返回该值，当key不存在时，返回None
info = {"k1":"v1","k2":"v2"}
v = info.get('k5')
print(v) # 输出的结果为 v1
# 集合基本形式：agg = {"sss",1,2,3,4,5,6}
1.由不同的元素组成
2.无序（不能通过下标的方式来进行访问）
3.集合中的元素必须为不可变类型
4.集合本身为可变类型（可进行追加元素）
5.让集合变为不可变类型
6.agg.add(7) # 往集合中添加元素 只能更新一个值
7.agg.clear() # 清空集合
8.agg.copy() # 拷贝
9.agg.remove('sss') # 删除指定的元素（当所指定的字符串不在集合中时 会产生报错）
10.agg.discard('sss') #删除指定元素 （当删除指定的元素不在集合中时 不会产生报错）
11.agg.pop() # 随机删除一个元素
12.将列表转为集合后，原列表中重复的元素会被去除
li = ['ss','aa','ss',1,23,4] agg = set(li) print(agg) # {1, 4, 'ss', 'aa', 23}
13.求交集
python = ['hello','world','pycharm'] java = ['hello','world','eclipse'] python_s = set(python) java_s = set(java) print(python_s.intersection(java_s)) print(python_s&java_s) ## {'world', 'hello'} ## {'world', 'hello'}
14.求并集
python = ['hello','world','pycharm'] java = ['hello','world','eclipse'] python_s = set(python) java_s = set(java) print(python_s.union(java_s)) print(python_s|java_s) ## {'eclipse', 'hello', 'world', 'pycharm'} ## {'eclipse', 'hello', 'world', 'pycharm'}
15.求差集
python = ['hello','world','pycharm'] java = ['hello','world','eclipse'] python_s = set(python) java_s = set(java) print(python_s - java_s) # python_s中有的 而java_s中没有的 print(java_s - python_s) # java_s中有的 而python_s中没有的 print(python_s.difference(java_s)) # 形如 python_s - java_s ## 输出 # {'pycharm'} # {'eclipse'} # {'pycharm'}
16.交叉补集（先求两个集合的并集，再将并集中两个集合公共部分去除）
python = ['hello','world','pycharm'] java = ['hello','world','eclipse'] python_s = set(python) java_s = set(java) print(python_s.symmetric_difference(java_s)) print(python_s^java_s)
17.s1.isdisjoint(s2) # 如果s1和s2没有交集，则返回True
18.s1.issubset(s2) # 如果s1为s2的子集，则返回True
19.s1.issuperst(s2) # 如果s1为s2的父级，则返回True
20.更多用法
python_s.intersection_update(java_s) # 求出交集，并将交集付给python_s python_s.difference_update(java_s) # 求出差集，并将差集赋值给python_s python_s.update(java_s) # 求出并集，并将值赋给python_s
#############
############
li_num= "hello"
id(li_num) #可以得出当前存放的地址# 不可变类型 当给其重新赋值 会开辟一个新的空间（id号发生了变化）
### 字符串为不可变类型>>> li_num = "hello" >>> print(id(li_num)) 139825721992224 >>> li_num = "world" >>> print(id(li_num)) 139825721992336 >>>### 数字为不可变类型
>>> i = 1 >>> print(id(i)) 10919424 >>> print(id(i)) 10919424 >>> i = i + 1 >>> print(id(i)) 10919456 >>>
### 元组为不可变类型
>>> tu = (1,"hello",(11,22),[11,22],True,11) >>> print(id(tu)) 140134117327112 >>> tu[3][0] = 33 >>> tu (1, 'hello', (11, 22), [33, 22], True, 11) >>> print(id(tu)) 140134117327112 >>> # 元组每次执行id都不一样
### 列表:可变类型，可以在原先的基础上对其进行改变，不需要重新开辟内存
>>> li = [1,2,3,4] >>> print(id(li)) 140134148737160 >>> li.append(5) >>> li [1, 2, 3, 4, 5] >>> print(id(li)) 140134148737160 >>>### 字典为可变类型
>>> dic = {"k1":"v1"} >>> print(id(dic)) 140134148741512 >>> a = dic.setdefault("k2","v2") >>> print(id(dic)) 140134148741512 >>>
不可变类型：字符串，数字，元组
可变类型：列表，字典
访问顺序：
1.直接访问：数字
2.顺序访问：字符串，列表，元组
3.映射：字典
未完待续.....
1605
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
