-
2020-03-10 16:59:03
python常用内置数据类型的总结:
1.形式:
列表list:[1,2,3] [a,b,c] [‘myss’,{2},(1,3),[‘c’,2],{65:‘A’}]
【所有元素放在一对方括号中,元素之间使用逗号分隔,其中的元素可以是任意类型】
元组tuple:(1,2,3) (1,)
【所有元素放在一对圆括号中,元素之间使用逗号分隔,元组中只有一个元素时后面的逗号不能省略】
字典dict:{‘a’:97,‘b’:98,‘c’:99,‘d’:100} {1:‘a’:2:‘b’}
【所有元素放在一对大括号中,元素之间使用逗号分隔,元素形式为“键:值”,其中“键”不允许重复并且必须为不可变类型,“值”可以是任意类型的数据】
集合set:{‘a’,‘b’,‘c’}
【所有元素放在一对大括号中,元素之间使用逗号分隔,元素不允许重复且必须为不可变类型;集合中只能包含数字、字符串、元组等不可变类型的数据,而不能包含列表、字典、集合等可变类型的数据,包含列表等可变类型数据的元组也不能作为集合的元素。集合不支持使用下标直接访问特定位置上的元素,也不支持使用random中的choice()函数从集合中随机选取元素,但支持使用random模块中的sample()函数随机选取部分元素。】
字符串str:‘abcd’ “abcd” ‘’‘a"bc"d’’’
【使用单引号、双引号、三引号作为定界符,不同定界符之间可以互相嵌套;前面加字母r或R表示原始字符串,任何字符都不进行转义】
2.功能和用法
(1)可用下标0寻找列表或元组的第一个元素;而字典不可下标,应用“键”寻找对应的值。
(2)列表,字典,集合可变;元组,字符串不可变。所以不可以修改字符串里的内容,也不能删除其中的字符。所以元组不存在追加插入删除等函数,且元组可使代码更安全。
(3)元组可以作为字典的键,也可作为集合的元素;列表均不可。
(4)字符串,列表和元组的元素是有顺序的;集合和字典内的元素则忽略顺序。
(5)元组可由tuple()转换,列表用list()。
(6)字符串前加r或者R表示原始字符串,避免因为特殊字符进行转义。
(7){}:空字典
[]:空列表
():空元组
(8)创建方法除了可以直接创建外:
列表:x=list()
元组:x=tuple()
字典:x=dict()
集合:x=set()
字符串:x=str()
(9)encode()函数可以把字符串转化为字节串,decode()解码成为字符串更多相关内容 -
python列表元组字典集合,运算符
2022-03-18 11:51:41列表创建一个列表更新列表删除列表元素嵌套列表(类似于多维数组)列表函数,方法3.元组创建元组元组的连接删除元组元组内置函数4.字典访问字典修改字典删除字典的元素字典内置函数,方法5.集合添加元素移除元素集合...python列表元组字典集合,运算符
1.运算符
算术运算符
以下假设变量
a=10
,变量b=21
:
逻辑运算符
以下假设变量 a 为 10, b为 20:
位运算符
a = 0011 1100 b = 0000 1101
成员运算符
a = 10 b = 20 list = [1, 2, 3, 4, 5 ] if ( a in list ): print ("变量 a 在给定的列表中 list 中") else: print ("变量 a 不在给定的列表中 list 中") if ( b not in list ): print ("变量 b 不在给定的列表中 list 中") else: print ("变量 b 在给定的列表中 list 中")
身份运算符
身份运算符用于比较两个对象的存储单元
注:id(object) 函数返回对象的唯一标识符,标识符是一个整数
>>>a = 'runoob' >>> id(a) 4531887632 #变量a的唯一标识符 >>> b = 1 >>> id(b) 140588731085608 #变量b的唯一标识符
2.列表
列表是最常用的 Python 数据类型,它可以作为一个方括号内的逗号分隔值出现。
列表的数据项不需要具有相同的类型
创建一个列表
list1 = ['Google', 'dahe', 1997, 2000] list2 = [1, 2, 3, 4, 5 ] list3 = ["a", "b", "c", "d"] list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']
与字符串的索引一样,列表索引从 0 开始,第二个索引是 1,依此类推
索引也可以从尾部开始,最后一个元素的索引为 -1,往前一位为 -2,以此类推
通过索引列表可以进行截取、组合等操作
截取
nums = [10, 20, 30, 40, 50, 60, 70, 80, 90] print(nums[0:4]) # 从第二位开始(包含)截取到倒数第二位(不包含) print (nums[1:-2]) #从第二位开始,到列表末尾的所有元素 print(nums[1:]) -------------------------------------------------- 输出: [10, 20, 30, 40] [20, 30, 40, 50, 60, 70] [20, 30, 40, 50, 60, 70, 80, 90]
更新列表
你可以对列表的数据项进行修改或更新,你也可以使用
append()
方法来添加列表项,如下所示:nums = [10, 20, 30, 40, 50, 60, 70, 80, 90] nums[2]=521 #更改列表中的元素 nums.append(1314) #向列表末尾插入数据 print(nums) --------------------------------------------------------------- 输出: [10, 20, 521, 40, 50, 60, 70, 80, 90, 1314]
删除列表元素
nums = [10, 20, 30, 40, 50, 60, 70, 80, 90] del nums[1] #删除第二个元素 print(nums) -------------------------------------------------- 输出: [10, 30, 40, 50, 60, 70, 80, 90]
嵌套列表(类似于多维数组)
>>>a = ['a', 'b', 'c'] >>> n = [1, 2, 3] >>> x = [a, n] >>> x [['a', 'b', 'c'], [1, 2, 3]] >>> x[0] ['a', 'b', 'c'] >>> x[0][1] 'b'
列表函数,方法
1.基本使用方法
nums = [10, 20, 30, 40, 50, 60, 70, 80, 90] print(len(nums)) #返回列表元素个数 print(max(nums)) #返回列表的最大值 print(min(nums)) #返回列表的最小值 print(nums.count(10)) #统计列表中某元素出现的个数 nums.reverse() #反向列表元素 nums.clear() #清空列表 print(nums)
2.列表追加
list.extend()
函数用于在列表末尾一次性追加另一个序列中的多个值list1=[10,20,30] list2=[521,1314] list2.extend(list1) #在list2追加元素list1,注意,list1不一定需要是列表类型 #也可以是元组,集合类型 print(list2)
3.列表查找list.index(x,[start],[end])
list1=['Google','Tencent','ctfoj'] print(list1.index('Google')) #输出:0 print(list1.index('aiqiyi')) #没有找到,返回一个异常信息
4.列表排序
list.sort([key],[reverse])
函数用于对原列表进行排序参数:
- key – 主要是用来进行比较的函数
- reverse – 排序规则,reverse = True 降序, reverse = False 升序(默认)
演示:
# 获取列表的第二个元素 def takeSecond(elem): return elem[1] # 列表 random = [(2, 2), (3, 4), (4, 1), (1, 3)] # 指定第二个元素排序,降序排序 random.sort(key=takeSecond,reverse=True) print('排序列表:', random)
5.插入元素到列表中
list.insert(index,obj)
参数:
- index – 对象obj需要插入的索引位置
- obj – 要插入列表中的对象
list1 = ['Google', 'imustoj', 'Taobao'] list1.insert(1, 'Baidu') print ('列表插入元素后为 : ', list1) ---------------------------------------------------- 输出: 列表插入元素后为 : ['Google', 'Baidu', 'imustoj', 'Taobao']
6.移除列表元素
list1 = ['Google', 'imustctf', 'Taobao', 'Baidu'] list1.remove('Taobao') print ("列表现在为 : ", list1) list1.remove('Baidu') print ("列表现在为 : ", list1) ------------------------------------------------------- 输出: 列表现在为 : ['Google', 'imustctf', 'Baidu'] 列表现在为 : ['Google', 'imustctf']
7.移除列表中的某一个元素
list.pop([index])
index默认为-1,会返回删除的元素list1 = ['Google', 'imustctf', 'Taobao'] list1.pop() print ("列表现在为 : ", list1) list1.pop(1) print ("列表现在为 : ", list1) --------------------------------------------------- 输出: 列表现在为 : ['Google', 'imustctf'] 列表现在为 : ['Google']
3.元组
Python 的元组与列表类似,不同之处在于元组的元素不能修改。
元组使用小括号 ( ),列表使用方括号 [ ]。
元组与字符串类似,下标索引从 0/-1 开始,可以进行截取,组合等,元组可以使用下标索引来访问元组中的值
创建元组
tup=(1,2,3) print(tup) #注意,当元组中只有一个元素时,要用如此表示 #tup=(1,),否则编译器会把它当作整形来对待
元组的连接
元组中的元素值是不允许修改的,但我们可以对元组进行连接组合
tup1 = (12, 34.56) tup2 = ('abc', 'xyz') # 以下修改元组元素操作是非法的。 # tup1[0] = 100 # 创建一个新的元组 tup3 = tup1 + tup2 print(tup3) ------------------------------------ 输出: (12, 34.56, 'abc', 'xyz')
删除元组
元组中的元素值是不允许删除的,但我们可以使用del语句来删除整个元组
tup = ('Google', 'imustctf', 1997, 2000) del tup #删除一整个元组 print("删除后的元组 tup : ") print(tup) -------------------------------------------------- 输出:异常信息
元组内置函数
4.字典
字典是另一种可变容器模型,且可存储任意类型对象。
字典的每个键值对用冒号 : 分割,每个对之间用逗号(,)分割,整个字典包括在花括号 {} 中 ,格式如下所示:
注:键必须是唯一的,但值则不必。值可以取任何数据类型,但键必须是不可变的,如字符串,数字
d = {key1 : value1, key2 : value2, key3 : value3 } tinydict = {'name': 'imustctf', 'likes': 123, 'url': 'imustctf.top'}
访问字典
把相应的键放入到方括号中
tinydict = {'name': 'imustctf', 'likes': 123, 'url': 'imustctf.top'} print(tinydict['name']) print(tinydict['now']) #字典中没有的数据,访问会抛出一个异常
修改字典
tinydict = {'Name': 'imustctf', 'Age': 7, 'Class': 'First'} tinydict['Age'] = 8 # 更新 Age tinydict['School'] = "内蒙古科技大学" # 添加信息
删除字典的元素
tinydict = {'Name': 'imustctf', 'Age': 7, 'Class': 'First'} del tinydict['Name'] # 删除键 'Name' #tinydict.pop['name'] 删除键的函数表示方法 #tinydict.popitem() 删除字典的最后一串元素 tinydict.clear() # 清空字典 del tinydict # 删除字典
字典内置函数,方法
1.dict.fromkeys(seq,[value])
用于创建一个新字典,以序列 seq 中元素做字典的键,value 为字典所有键对应的初始值
参数:
- seq – 字典键值列表。
- value – 可选参数, 设置键序列(seq)对应的值,默认为 None。
seq = ('name', 'age', 'sex') tinydict = dict.fromkeys(seq) print(tinydict) tinydict = dict.fromkeys(seq, 10) print(tinydict) ---------------------------------------------- 输出: {'name': None, 'age': None, 'sex': None} {'name': 10, 'age': 10, 'sex': 10}
2.
len(dict)
返回字典的个数tinydict = {'Name': 'imustctf', 'Age': 7, 'Class': 'First'} print(len(tinydict)) #输出字典的个数
3.dict.items()
以列表返回视图对象,是一个可遍历的key/value 对
dict1={'one':1,'two':2} print(dict1.items()) -------------------------------- 输出: dict_items([('one', 1), ('two', 2)])
将字典的 key 和 value 组成一个新的列表:
d={1:"a",2:"b",3:"c"} result=[] for k,v in d.items(): result.append(k) result.append(v) print(result) --------------------------------------------- 输出: [1, 'a', 2, 'b', 3, 'c']
4.
update
添加d={1:"a",2:"b",3:"c"} c={4:"d"} d.update(c) #将c字典添加到d字典里 print(d) -------------------------- 输出: {1: 'a', 2: 'b', 3: 'c', 4: 'd'}
5.集合
集合(set)是一个无序的不重复元素序列,支持集合的运算操作
>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'} #创建一个集合 >>> print(basket) # 这里演示的是去重功能{'orange', 'banana', 'pear', 'apple'} >>> # 下面展示两个集合间的运算 >>> a = set('abracadabra') #set方法创建集合 >>> b = set('alacazam') >>> a - b # 集合a中包含而集合b中不包含的元素 {'r', 'd', 'b'} >>> a | b # 集合a或b中包含的所有元素 {'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'} >>> a & b # 集合a和b中都包含了的元素 {'a', 'c'} >>> a ^ b # 不同时包含于a和b的元素{'r', 'd', 'b', 'm', 'z', 'l'}
添加元素
1.
s.add(x)
将元素 x 添加到集合 s 中(开头处),如果元素已存在,则不进行任何操作
thisset = set(("Google", "imustctf", "Taobao")) thisset.add("jingdong") print(thisset) --------------------------------------------------- 输出: {'jingdong', 'Google', 'imustctf', 'Taobao'}
2.
s.update(x)
添加元素,且参数可以是列表,元组,字典等
thisset = set(("Google", "imustctf", "Taobao")) thisset.update({1,3}) print(thisset) thisset.update([1,4],[5,6]) print(thisset) ---------------------------------------------------- 输出: {'Google', 'Taobao', 1, 3, 'imustctf'} {'Google', 'Taobao', 1, 3, 4, 5, 6, 'imustctf'}
移除元素
1.
s.remove(x)
将元素 x 从集合 s 中移除,如果元素不存在,则会发生错误
thisset = {"Google", "imustctf", "Taobao"} thisset.remove("Google")
2.
s.discard(x)
移除集合中的元素,且如果元素不存在,不会发生错误
thisset = {"Google", "imustctf", "Taobao"} thisset.discard("imustctf")
3.
s.pop()
随机删除集合中的一个元素
thisset = {"Google", "imustctf", "Taobao"} thisset.pop()
多次执行测试结果都不一样。 set 集合的 pop 方法会对集合进行无序的排列,然后将这个无序排列集合的左面第一个元素进行删除
4.
s.clear()
清空集合中的元素
thisset = {"Google", "imustctf", "Taobao"} thisset.clear()
集合内置方法
1.差集
x = {"apple", "banana", "cherry"} y = {"google", "microsoft", "apple"} z = x.difference(y) #返回x与y的差集,元素包含在集合 x ,但不在集合 y print(z) x.difference_update(y) #移除x集合中两个集合中都存在的元素 print(x) -------------------------------------------------- 输出: {'cherry', 'banana'} {'cherry', 'banana'}
2.交集
x = {"apple", "banana", "cherry"} y = {"google", "runoob", "apple"} z = x.intersection(y) #返回集合的交集 print(z) x.intersection_update(y) #返回x与y都存在的元素,并赋值给x集合 print(x) ----------------------------------------------- 输出: {'apple'} {'apple'}
3.并集
x = {"a", "b", "c"} y = {"f", "d", "a"} z = {"c", "d", "e"} result = x.union(y, z) #合并多个集合 print(result) ----------------------------------- 输出: {'e', 'b', 'd', 'c', 'f', 'a'}
4.集合的一些判断
x = {"apple", "banana", "cherry"} y = {"google", "runoob", "facebook"} z = x.isdisjoint(y) #判断两个集合是否包含相同的元素,如果没有返回 True,否则返回 False print(z) z2 = x.issubset(y) #判断x是否为y集合的子集,是则返回True,不是则返回False print(z2) ---------------------------------------------------------------------- 输出: True False
-
Python语法——列表、元组、集合、字典
2022-04-29 18:30:28Python语法——列表、元组、集合、字典 综述: 列表(List) [ ] 是一种有序和可更改 的集合。允许重复的成员。 元组(Tuple) ( ) 是一种有序且不可更改的集合。允许重复的成员。 集合(Set) { } 是一个无序和无...Python语法——列表、元组、集合、字典
综述:
列表(List) [ ] 是一种有序和可更改 的集合。允许重复的成员。 元组(Tuple) ( ) 是一种有序且不可更改的集合。允许重复的成员。 集合(Set) { } 是一个无序和无索引的集合。没有重复的成员。 词典(Dictionary){"key":"value"......} 是一个无序,有索引和可变的集合。没有重复的成员。
一、列表的相关操作
#创建列表 thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"] print(thislist) #访问 负索引表示从末尾开始,0 表示第一个项目,-1 表示倒数第一个项目,依此类推。 print(thislist[-1]) #结果是 mango #len()方法 获取列表有多少项 print(len(thislist)) #count()方法 返回具有指定值的元素数量 变量=列表.count("元素") #reverse()方法 反转元素的排序顺序 列表.reverse() #sort()方法 默认情况下,对列表进行升序排序,还可以让函数来决定排序标准 list.sort(reverse=True/False, key=函数方法) 实例: def myFunc(e): return len(e) cars = ['Porsche', 'Audi', 'BMW', 'Volvo'] cars.sort(key=myFunc) print(cars) count()函数:统计了列表指定元素的个数 实例: >>> a = 'banana pie banana' >>> a.count('a',2) 5 #列表的增 1. append()方法 将项目添加到列表的末尾 方法:列表.append("元素") 2. insert()方法 在指定的索引出添加项目 方法:列表.insert(索引位置,"元素") 3. extend()方法 指定的列表元素(或任何可迭代的元素)添加到当前列表的末尾 方法:目标列表.extende(后接的列表) #列表的删 1. remove()方法 删除指定的元素 方法:列表.remove("元素") 删除列表第一个匹配项 2. pop()方法 删除指定的索引(如果未指定索引,则删除最后一项)方法:列表.pop(index) 3. del()方法 删除指定的索引 方法:del thinlist[index] 删除完整的列表 方法:del 列表名 4. clear()方法 清空列表内容,保留列表格式 方法:列表名.clear() #列表的改 直接覆盖 #列表的查 if "apple" in thislist: print("Yes, 'apple' is in the fruits list")
二、元组的相关操作
#创建元组 thistuple = ("apple", "banana", "cherry") print(thistuple) #访问 返回第三、第四、第五个项目 thistuple = ("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango") print(thistuple[2:5]) 左闭右开 print(thistuple[-4:-1]) 左开右闭 #元组的增 #元组的删 #元组的改 注意: 创建元组后,您将无法更改其值。元组是不可变的,或者也称为恒定的。 但是有一种解决方法。您可以将元组转换为列表,更改列表,然后将列表转换回元组。 实例: x = ("apple", "banana", "cherry") y = list(x) y[1] = "kiwi" x = tuple(y) print(x) #合并两个元组 实例: tuple1 = ("a", "b" , "c") tuple2 = (1, 2, 3) tuple3 = tuple1 + tuple2 print(tuple3)
三、集合的相关操作
#创建集合 thisset = {"apple", "banana", "cherry"} print(thisset) #访问 无法通过引用索引来访问 set 中的项目,因为 set 是无序的,项目没有索引。 但是您可以使用 for 循环遍历 set 项目,或者使用 in 关键字查询集合中是否存在指定值。 #集合的增 1. add() 要将一个项添加到集合 方法:集合.add("元素") 2. update() 要向集合中添加多个项目 方法:集合.update(["orange", "mango", "grapes"]) 实例: set1 = {"a", "b" , "c"} set2 = {1, 2, 3} set1.update(set2) print(set1) 3. union() 返回一个新集合,其中包含两个集合中的所有项目 实例: set1 = {"a", "b" , "c"} set2 = {1, 2, 3} set3 = set1.union(set2) print(set3) '''注意:union() 和 update() 都将排除任何重复项。''' #集合的删 1. remove() 与列表一致 如果要删除的项目不存在 将引发错误 2. discard() 集合.discard("元素") 如果要删除的项目不存在 不会引发错误 3. pop() 与列表一致 但是注意: 集合是没有索引的,因此在使用该方法时,您不会知道删除的是哪个项目 4. del() 与列表一致 #集合的改 #集合的查 1.for 循环遍历 2.if xx in xx:
四、字典的相关操作
#字典的创建 thisdict = { "brand": "Porsche", "model": "911", "year": 1963 } print(thisdict) #访问 通过在方括号内引用其键名来访问字典的项目 x = thisdict["model"] #打印所有键名 for x in thisdict: print(x) #打印所有值 for x in thisdict: print(thisdict[x]) #打印键和值 for x, y in thisdict.items(): print(x, y) #字典的改 直接覆盖 thisdict["year"] = 2019 #字典的删 1. pop() 删除键和值 字典.pop("key") 2. popitem() 删除最后的键和值 字典.popitem() 3. del 关键字删除具有指定键名的项目 也可以完全删除字典 4. clear() 关键字清空字典
-
Python基础—列表、元组、集合、字典
2019-07-24 18:29:36列表中的数据类型可以包含多种,包含数字、字符串、字典、布尔型等,并且列表中还可以嵌套列表 print(type([1, 2, 3, 4, 5, 6])) print(type(['Hello', 'World', 1, 6])) print(type(['Hello', 1, 2, True, 'a'])) ...1、列表(list)
列表中的数据类型可以包含多种,包含数字、字符串、字典、布尔型等,并且列表中还可以嵌套列表print(type([1, 2, 3, 4, 5, 6])) print(type(['Hello', 'World', 1, 6])) print(type(['Hello', 1, 2, True, 'a'])) print(type([['Hello', 1, 2, 3], [True, 1]])) # 列表中嵌套列表 print(type([['Hello', 'World'], [1, 2, 3], [True, False]])) print(type([['Hello', 'World'], [1, 2, 3], [True, False], {'name': 'alex', 'age': 18}]))
结果为:
<class ‘list’>
<class ‘list’>
<class ‘list’>
<class ‘list’>
<class ‘list’>
<class ‘list’>- 列表的访问
print(["新月打击", "苍白之瀑", "月之降临", "月神冲刺"][0]) print(["新月打击", "苍白之瀑", "月之降临", "月神冲刺"][3]) print(["新月打击", "苍白之瀑", "月之降临", "月神冲刺"][0:2]) print(["新月打击", "苍白之瀑", "月之降临", "月神冲刺"][-1:]) print(["新月打击", "苍白之瀑", "月之降临", "月神冲刺"][-1])
结果为:
新月打击
月神冲刺
[‘新月打击’, ‘苍白之瀑’]
[‘月神冲刺’]
月神冲刺可以发现,单一数字的索引来访问的时候,得到的是一个元素;用冒号的方式来访问,得到的是一个列表,哪怕这个列表只有一个元素
- 列表的操作
print(["新月打击", "苍白之瀑", "月之降临", "月神冲刺"] + ["点燃", "打击"]) print(["点燃", "打击"]*3)
结果为:
[‘新月打击’, ‘苍白之瀑’, ‘月之降临’, ‘月神冲刺’, ‘点燃’, ‘打击’]
[‘点燃’, ‘打击’, ‘点燃’, ‘打击’, ‘点燃’, ‘打击’]注意: print([“点燃”, “打击”]-[“点燃”]) # 输出错误
2、元组(tuple)
元组中的数据类型也可以包含多种
print((1, 2, 3, 4, 5)) print((1, '-1', True, 'morning', {'name': 'alex', 'age': 18}, [1, 'Hello', '1']))
结果为:
(1, 2, 3, 4, 5)
(1, ‘-1’, True, ‘morning’, {‘name’: ‘alex’, ‘age’: 18}, [1, ‘Hello’, ‘1’])- 元组的访问
print((1, 2, 3, 4, 5)[0]) print((1, 2, 'morning', 4, True)[0:3]) print((1, 2, 'morning', 4, True)[-1:]) print((1, 2, 'morning', 4, True)[-1]) print((1, 2, 3) + (4, 5, 6)) print((1, 2, 3) * 3) print((1, 2)[-1:])
结果为:
1 (1, 2, 'morning') (True,) True (1, 2, 3, 4, 5, 6) (1, 2, 3, 1, 2, 3, 1, 2, 3) (2,)
注意:单一数字的索引来访问的时候,得到的是一个元素;用冒号的方式来访问,得到的是一个元组,哪怕这个元组只有一个元素
- 类型的判断1
print(type((1, 2, 3))) print(type(1)) print(type((1))) # 小括号代表运算符号时,比如(1+1)*2,和元组的括号有冲突,Python当括号里面只有一个元素时,规定为运算符号 # 定义只有一个元素的元组 print(type((1,))) # 表示一个空的元组 print(type(()))
结果为:
<class 'tuple'> <class 'int'> <class 'int'> <class 'tuple'> <class 'tuple'>
- 类型的判断2
print(type("Hello")) print(type(("Hello"))) print(type([1, 2, 3])) print(type([1]))
结果为:
<class 'str'> <class 'str'> <class 'list'> <class 'list'>
3、str list tuple ---->序列
- 每个元素都被分配一个序号
print((1, 2, 3)[2]) print('hello world'[2])
结果为:
3 l
- 都可以进行切片操作
print([1, 2, 3, 4, 5][0:3]) print([1, 2, 3, 4, 5][-1:]) print("Hello world"[0:8:2])
结果为:
[1, 2, 3] [5] Hlow
- 都可进行 + 和 *
- 判断元素是否在序列中
print(3 in [1, 2, 3, 4, 5]) print(3 not in [1, 2, 3, 4, 5])
结果为:
True
False- 都可以求取序列的长度、元素的最大最小值
print(len([1, 2, 3, 4, 5, 6])) print(len("Hello world")) print(max([1, 2, 3, 4, 5, 6])) print(min([1, 2, 3, 4, 5, 6])) print(max("Hello world")) print(min("Helloworld"))
结果为:
6 11 6 1 w H
求取ASCII 的求取
print(ord('H')) print(ord('w')) print(ord(' '))
结果为:
72
119
32
4、 集合
- 无序
print(type({1, 2, 3, 4, 5, 6})) # print({1, 2, 3, 4, 5, 6}[0]) # 错误
结果为:
<class 'set'>
- 不重复
print({1, 1, 2, 3, 6, 6})
结果为:
{1, 2, 3, 6}
- 长度
print(len({1, 2, 3}))
结果为:
3
- 剔除3,4,求集合的差集
print({1, 2, 3, 4, 5, 6}-{3, 4})
{1, 2, 5, 6}
- 求集合的交集
print({1, 2, 3, 4, 5, 6} & {3, 4})
结果为:
{3, 4}
- 两个合并成一个,不出现相同的元素,合集或并集
print({1, 2, 3, 4, 5, 6} | {3, 4, 7})
结果为:
{1, 2, 3, 4, 5, 6, 7}
- 定义一个空的集合
print(type({})) print(type(set()))
结果为:
<class 'dict'> <class 'set'>}
约个拓展练习可好:
快乐的LeetCode — 14. 最长公共前缀 方法2中包含了集合的巧妙使用
5、字典(dict)
形式:{key1:value1,key2:value2,key3:value3,} 。 可以有很多个key和value,属于集合类型(set),不是序列类型- 访问
print({'Q': "新月打击", 'W': "苍白之瀑", 'R': "月之降临", 'E': "月神冲刺"}['Q']) # 相同的key情况,尽管有结果输出 print({'Q': "新月打击", 'Q': "苍白之瀑", 'R': "月之降临", 'E': "月神冲刺"}['Q']) # 验证发现,已经存在丢失 print({'Q': "新月打击", 'Q': "苍白之瀑", 'R': "月之降临", 'E': "月神冲刺"})
结果为:
新月打击 苍白之瀑 {'Q': '苍白之瀑', 'R': '月之降临', 'E': '月神冲刺'}
- 可以有数字类型的key
print({1: "新月打击", '1': "苍白之瀑", 'R': "月之降临", 'E': "月神冲刺"}) # key必须是不可变的类型, 数字1,字符串"1" # 反例 print({[1, 2]: "新月打击", 'Q': "苍白之瀑", 'R': "月之降临", 'E': "月神冲刺"})
结果为:
{1: '新月打击', '1': '苍白之瀑', 'R': '月之降临', 'E': '月神冲刺'}
- value 本身可以是 int float str set dict list…
print({1: "新月打击", '1': "苍白之瀑", 'R': {1, 2, 3}, 'E': "月神冲刺"})
结果为:
{1: '新月打击', '1': '苍白之瀑', 'R': {1, 2, 3}, 'E': '月神冲刺'}
- 定义空的字典
print(type({}))
结果为:
<class 'dict'>
大家加油!
第4章 Python中表示“组”的概念与定义.mp4 -
【python学习】列表、元组、字典、集合(详解)
2022-03-31 16:34:55关注作者,持续阅读作者的文章,学习更多知识! ... 一、列表 列表(list)是Python中的一种数据结构,它可以存储不同类型的数据。...3.每个元素的排列是有序号的,元素相同但排列不同的列表属于不同的列表。 4... -
python的列表,字典,元组,集合的区别和各自使用方法
2019-05-23 22:41:22列表是处理一组有序的数据结构,可以读写,添加和删除,或者搜索列表里的元素。因为可以添加和删除,所以称为可变的数据类型,即这种类型是可以被改变的,并且列表可以嵌套。 res = [1,2,'yihang'] #增加元素:... -
Python基础篇(三)-- 列表、元组、字典、集合、字符串
2021-03-30 21:29:39本篇主要介绍Python里的数据结构,包括列表、元组、字典、集合、字符串的使用,学习这些序列的方法以及性质。 -
Python-列表,元组,集合,字典常用操作
2022-01-19 15:04:49列表: index():返回指定数据所在位置的下标 ,查不到会报错 index(数据, 开始位置下标, 结束位置下标) count():统计指定数据在当前列表中出现的次数。 len():访问列表⻓度,即列表中数据的个数。 in:判断指定... -
Python——列表,元组,字典,集合的相关操作总结
2022-04-04 22:30:351.1 列表(list): 1.2 元组(tuple): 1.3 字典(dict ): 1.4 集合(set): 2.创建 2.1 创建列表 2.2 创建元组 2.2 创建字典 2.4 创建集合 3.查找 3.1 查找列表元素 3.2 查找元组元素 3.3 查找... -
Python:列表,元组,字典,集合
2019-03-26 17:38:391,列表,元组,字典,集合 1.1,概念 列表(list):是长度可变有序的数据存储器,可通过下标索引取到相应的数据。 元组(tuple):固定长度不可变的顺序容器,访问效率高,适合存储一些长常量数据,可以作为... -
列表应用及和字典、元组、集合的区别
2021-11-28 17:14:551.列表,元组,字典是有顺序的,而集合是没顺序的 2.列表是以方括号形式表示,元组是以圆括号表示,字典以花括号表示,集合则是以[()]的形式表示 3.列表是可变对象,它支持在原处修改的操作.也可以通过指定的索引和分... -
python中列表、元组、集合、字典、字符串的区别
2020-07-29 20:24:00二、元组和列表的区别 (1)元组号称不可修改的列表,也就是只能查 果然是好兄弟,他俩还可以互换 元组 = tuple(列表) 列表 = list(元组) 三、集合和列表的区别 (1)集合无序、列表有序 (2)集合成员不可... -
Python3-列表、元组、字典和集合
2022-05-07 11:21:51python3-列表、元组、字典和集合概述一、列表1.定义2.函数:排序反转3.基本操作:增、删、改、查4.列表推导式5. 练习二、元组1.基本操作三、字典1. 增删改查基本操作四、集合1. 基本操作2. ord 和chr五、公共方法1. ... -
一文看懂系列:元组、列表、字典、集合
2021-03-31 11:45:37一文看懂系列:元组、列表、字典、集合究竟怎么学 一、数据结构 1、元组 含义:元组是一种固定长度、不可变的Python对象序列。虽然对象元组中存储的对象其自身是可变的,但是元组一旦创建,各个位置上的对象是... -
列表、元组、字典、集合的异同
2022-01-14 21:32:49列表、元组、字典、集合的异同 1.list: (1)可以用list()函数或者方括号[]创建,元素之间用逗号’,‘’分隔; (2)列表的元素不需要具有相同的类型,可以是多种类型; (3)使用索引来访问元素; (4)可... -
Python列表,元组,字典,集合的比较总结【表格对比】
2021-12-29 10:01:30列表,元组,字典,集合,都用于存放数据,它们区别总结如下: 项目 列表 元组 字典 集合 关键字 list tuple dict set 是否可变 可变 不可变 可变 可变 是否有序 有序 ... -
Python中列表元组字典集合的区别
2021-01-28 20:06:25列表list定义符号:[]创建:[]直接创建 , list()可变性:可变是否有序:有序元素是否重复:可以重复切片:支持切片索引:支持索引访问:索引访问删除:del()list.remove(value)list.pop()修改插入:list[]=append()... -
【python基础】python序列--列表、元组、字典和集合详解
2021-10-31 11:21:08只有元组属于不可变类型,因此它没有增删查改操作,其余列表、字典和集合都属于可变对象。集合和字典不支持索引、切片、相加和相乘操作。1. 序列共同特点在 Python 中,序列类型包括字符串、列表、元组、集合和字典... -
Python中列表,元组,字典,集合的区别
2021-02-09 09:00:26参考文档https://blog.csdn.net/Yeoman92/article/details/56289287理解Python中列表,元组,字典,集合的区别列表,元组,字典,集合的区别是python面试中最常见的一个问题。这个问题虽然很基础,但确实能反映出... -
Python 列表、元组、字典、集合(定义、常用操作)
2020-06-16 19:57:021、列表(list) 操作:索引,切片,增,乘,查找(注:列表的数据项不需要具有相同的类型,类似tuple,但列表允许修改值,tuple不允许) 翻转(List.reverse())、排序(List.sort())、列表嵌套(List=[list1, ... -
python列表、元组、字典、集合总结
2020-01-31 20:02:16列表、元组、字典分别对应list, tuple, dict 1.list的简介 列表是python内置的一种数据类型,是一种有序的集合,可对其进行增删改查。列表中的元素不一定是同类型的。列表是可变序列 2.list的初始化 list = [] #... -
Python字符串、列表、元组、字典、集合的常用函数
2019-04-29 17:29:46将列表转换为元组。 >>> list1= ['Google', 'Taobao', 'Runoob', 'Baidu'] >>> tuple1=tuple(list1) >>> tuple1 ('Google', 'Taobao', 'Runoob', 'Baidu') 字典 1 radiansdict.... -
理解Python中列表,元组,字典,集合的区别
2020-12-21 16:50:44列表,元组,字典,集合的区别是python面试中最常见的一个问题。这个问题虽然很基础,但确实能反映出面试者的基础水平。1.列表(List)什么是列表呢?我觉得列表就是我们日常生活中经常见到的清单。比如,统计过去一周... -
Python 列表/元组/字典总结
2020-11-28 18:31:08Python有6个序列的内置类型,但最常见的是列表和元组。序列都可以进行的操作包括索引,切片,加,乘,检查成员。此外,Python已经内置确定序列的长度以及确定最大和最小的元素的方法。列表是最常用的Python数据类型... -
python的字符串、列表、元组、字典、集合
2021-11-01 20:53:28python数据类型前言一、字符串二、列表三、元组四、字典五、集合 前言 Python3 中有六个标准的数据类型: Number(数字) String(字符串) List(列表) Tuple(元组) Set(集合) Dictionary(字典) Python3 的... -
Python中的列表、元组、字典、集合详解
2020-07-29 11:03:051、列表 列表:使用方括号将用逗号分隔不同的数据项括起来。 可以存储不同类型的数据。 list = [1,‘a’,[1,2 ],“python”] 创建列表 list = [obj0,obj1] list1 = [1,2,3] list2 = ["C","python","java"] list3 = ... -
字符串、列表、元组、集合、字典
2019-07-16 21:08:46字符串 字符串就是一系列数字,在...python的字串列表有2种取值顺序: 从左到右索引默认0开始的,最大范围是字符串长度少1 从右到左索引默认-1开始的,最大范围是字符串开头 如果你要实现从字符串中获取一段子字... -
python中列表、字典、元组与集合的特点以及差异
2020-05-15 23:53:121.列表(List) 列表的特点 1. 数据按顺序存储 2. 列表有正序、倒序两种索引 3. 列表可存储任意类型的数据,并且允许重复。 列表的遍历: lst = [1,2,3] for i in range(len(lst)): print(lst[i]) 列表的增删改...