小白学python3----列表，字典，集合，元组

小白学python3----列表，字典，集合，元组

本人小白自学python的历程（主要都是通过网站和视频学习，并在此记录下笔记）

书签

python列表listpython字典dictpython集合setpython元组tuple

小白学python3--列表list

创建空列表

#1.创建一个空列表(有两种方法) lst1=list() #方法一 lst2=[] #方法二 print(type(lst1)) print(type(lst2)) #result： #<class 'list'> #<class 'list'>

这边简单列举一下列表函数&方法 python列表函数：

len(list)查询列表中元素个数max(list) 返回列表元素的最大值min(list)返回列表元素的最小值list(seq) 将元组转换成列表

python列表方法：

list.append(obj)在列表的末尾添加新的对象list.count(obj) 统计某个元素在列表中出现的次数list.extend(seq) 合并两个列表list.index(obj) 从列表中找出某个值的第一个匹配项的索引位置list.insert(index,obj) 将对象插入列表中的指定位置list.pop(index=-1)移除列表中某个位置的元素（默认是最后一个）list.remove(obj) 移除列表中某个值的第一个匹配项list.reverse() 反向输出列表中的元素list.sort(key=None,reverse=False) 对原列表进行排序list.clear() 清空列表list.copy() 浅拷贝列表

下面是对列表函数&方法的简单使用介绍

python列表函数

1：len(list)

功能：查询列表中元素个数

#1.len(list) lst=[1,2,3,'a','b','c'] print(len(lst)) #result:6

2：max(list)

功能：返回列表元素的最大值

#2.max(list) lst=[1,2,3,4,5,6] print(max(lst)) #result:6

3：min(list)

功能：返回列表元素的最小值

#3.min(list) lst=[1,2,3,4,5,6] print(min(lst)) #result:1

4：list(seq)

功能：将元组转换成列表

tup=(1,2,3,4,5,6) print(list(tup)) #result:[1, 2, 3, 4, 5, 6]

python列表方法

1：list.append(obj)

功能：在列表的末尾添加新的对象

#1.list.append(obj) lst=[1,2,3,'a','b','c'] lst.append('d') print(lst) #result:[1, 2, 3, 'a', 'b', 'c', 'd']

2：list.count(obj)

功能：统计某个元素在列表中出现的次数

#2.list.count(obj) lst=[1,2,3,1,4,'a',1] print(lst.count(1)) #result:3

3：list.extend(seq)

功能：合并两个列表

lst1=[1,2,3] lst2=[4,5,6] lst1.extend(lst2) print(lst1) #result:[1, 2, 3, 4, 5, 6]

4：list.index(obj)

功能：从列表中找出某个值的第一个匹配项的索引位置

lst=[1,2,3,'a','b','c'] print(lst.index('b')) #result:4

5：list.insert(index,obj)

功能：将对象插入列表中的指定位置

lst=[1,2,3,'a','b','c'] lst.insert(3,4) #在第三个位置插入数值4 print(lst) #result:[1, 2, 3, 4, 'a', 'b', 'c']

6：list.pop(index=-1)

功能：移除列表中某个位置的元素（默认是最后一个）

lst=[1,2,3,'a','b','c'] lst.pop(4) print(lst) #result:[1, 2, 3, 'a', 'c']

7：list.remove(obj)

功能：移除列表中某个值的第一个匹配项

lst=[1,2,3,'a','b','c'] lst.remove(2) print(lst) #result:[1, 3, 'a', 'b', 'c']

8：list.reverse()

功能：反向输出列表中的元素

lst=[1,2,3,'a','b','c'] lst.reverse() print(lst) #result:['c', 'b', 'a', 3, 2, 1]

9：list.sort(key=None,reverse=False)

功能：对原列表进行排序

lst=[1,3,2,5,6,4] lst.sort() #升序 print(lst) lst.sort(reverse=True) #降序 print(lst) #result:[1, 2, 3, 4, 5, 6] #result:[6, 5, 4, 3, 2, 1]

10：list.clear()

功能：清空列表

lst=[1,3,2,5,6,4] lst.clear() print(lst) #result:[]

11：list.copy()

功能：浅拷贝列表

lst1=[1,2,3,'a','b','c'] lst1copy=lst1.copy() print(lst1copy) #result:[1, 2, 3, 'a', 'b', 'c']

小白学python3--字典dict

创建空字典

#1.创建一个空字典(有两种方法) dct1=dict() dct2={} print(type(dct1)) print(type(dct2)) #result:<class 'dict'> #result:<class 'dict'>

这边简单列举一下字典函数&方法 python字典函数：

len(dict)计算字典里元素个数，即键的总数str(dict) 以字符串的格式输出字典

python字典方法：

dict.clear() 删除字典里的所有元素dict.copy() 浅拷贝字典dict.fromkeys() 创建一个新字典,以序列作为字典的键,值默认是Nonedict.get(key,default=None)返回字典中指定键对应的值，若不存在，则返回default值key in dict 判断某个键是否在字典中，存在则返回True，否则为Falsedict.items() 以列表返回可遍历的（键，值）的元组dict.keys() 返回一个迭代器，可以使用list()来转换成列表，获取key值的列表dict.values() 返回一个迭代器，可以使用list()来转换成列表，获取value值的列表dict.setdefault(key,default=None) 和dict.get()类似，但若键不存在，则会添加键并赋予default值dict.update(dict2) 把字典二的键/值更新到字典一（合并字典）dict.pop(key,defalut) 删除字典中指定的key对应的值，并返回被删除key所对应的value值，指定的key不存在，则返回default值dict.popitem() 随机删除一组键与值，并返回被删除的键与值

下面是字典函数&方法的简单使用介绍

python字典函数

1：len(dict)

功能：计算字典里元素个数，即键的总数

dct={'Name':'我','Age':19,'Gender':'male'} print(len(dct)) #result:3

2：str(dict)

功能：以字符串的格式输出字典

dct={'Name':'我','Age':19,'Gender':'male'} print(str(dct)) print(type(str(dct))) #result:{'Name': '我', 'Age': 19, 'Gender': 'male'} #result:<class 'str'>

python字典方法

1：dict.clear()

功能：删除字典里的所有元素

dct={'Name':'我','Age':19,'Gender':'male'} dct.clear() print(dct) #result:{}

2：dict.copy()

功能：浅拷贝字典

dct1={'Name':'我','Age':19,'Gender':'male'} dct2=dct1.copy() print(dct2) #result:{'Name': '我', 'Age': 19, 'Gender': 'male'}

3：dict.fromkeys()

功能：创建一个新字典,以序列作为字典的键,值默认是None

#3.dict.fromkeys() 创建一个新字典,以序列作为字典的键,值默认是None seq=('Name','Age','Gender') #先创建一个元组 dct=dict.fromkeys(seq,'不详') print(dct) #result:{'Name': '不详', 'Age': '不详', 'Gender': '不详'}

4：dict.get(key,default=None)

功能：返回字典中指定键对应的值，若不存在，则返回default值

dct={'Name':'我','Age':19,'Gender':'male'} print(dct.get('Name')) print(dct.get('Class')) #result:我 #result:None

5：key in dict

功能：判断某个键是否在字典中，存在则返回True，否则为False

dct={'Name':'我','Age':19,'Gender':'male'} print('Age' in dct) print('Class' in dct) #result:True #result:False

6：dict.items()

功能：以列表返回可遍历的（键，值）的元组

dct={'Name':'我','Age':19,'Gender':'male'} print(dct.items()) #reuult:dict_items([('Name', '我'), ('Age', 19), ('Gender', 'male')])

7：dict.keys()

功能：返回一个迭代器，可以使用list()来转换成列表，获取key值的列表

dct={'Name':'我','Age':19,'Gender':'male'} print(dct.keys()) print(list(dct.keys())) #result:dict_keys(['Name', 'Age', 'Gender']) #result:['Name', 'Age', 'Gender']

8：dict.values

功能：返回一个迭代器，可以使用list()来转换成列表，获取value值的列表

dct={'Name':'我','Age':19,'Gender':'male'} print(dct.values()) print(list(dct.values())) #result:dict_values(['我', 19, 'male']) #result:['我', 19, 'male']

9：dict.setdefault(key,default=None)

功能：和dict.get()类似，但若键不存在，则会添加键并赋予default值

dct={'Name':'我','Age':19,'Gender':'male'} dct.setdefault('Class',4) print(dct) #result:{'Name': '我', 'Age': 19, 'Gender': 'male', 'Class': 4}

10：dict.update(dict2)

功能：把字典二的键/值更新到字典一（合并字典）

dct1={'Name':'我','Age':18,'Gender':'male'} dct2={'Gender':'male','Age':19} dct1.update(dct2) print(dct1) #result:{'Name': '我', 'Age': 19, 'Gender': 'male'}

11：dict.pop(key,defalut)

功能：删除字典中指定的key对应的值，并返回被删除key所对应的value值，指定的key不存在，则返回defalut值

dct={'Name':'我','Age':19,'Gender':'male'} print(dct.pop('Name')) #若删除的key不存在，则一定要添加default，否则会报错 print(dct) #result:我 #result:{'Age': 19, 'Gender': 'male'}

12：dict.popitem()

功能：随机删除一组键与值，并返回被删除的键与值

dct={'Name':'我','Age':19,'Gender':'male'} print(dct.popitem()) #被删除的一组 print(dct) #result:('Gender', 'male') #result:{'Name': '我', 'Age': 19}

小白学python3--集合set

集合(set)是一个无序的，不重复的元素序列

创建空集合

#1.创建一个空集合 set1=set() print(type(set1)) #result:<class 'set'>

集合特性的简单体现

集合不重复的体现

set1={1,2,2,3,1,4} print(set1) #result:{1, 2, 3, 4}

集合无序性的体现

set1={1,2,3,'a','b','c'} print(set1) #result:{1, 2, 3, 'a', 'c', 'b'}

这边简单列举一下集合函数&方法 python集合函数：

len(set) 计算集合里元素的个数

python集合方法：

set.add()为集合添加元素 set.clear() 清空集合中的所有元素 set.copy() 浅拷贝集合set.difference() 返回多个集合的差集（有返回值） set.difference_update()移除集合中的元素，该元素在指定的集合也存在（无返回值） set.discard() 移除集合中指定的元素set.intersection() 返回多个集合中的交集（有返回值）set.intersection_update() 获取两个集合中的交际（无返回值）set.isdisjoint() 判断两个集合中是否包含相同的元素，包含则返回False，否则为Trueset.issubset() 判断指定集合是否为该方法参数集合的子集,是则返回True，否则为False set.issuperset() 判断该方法的参数集合是否为指定集合的子集,包含则返回True，不包含则返回False set.pop()随机移除元素，会返回被移除的元素set.remove() 移除指定元素 set.symmetric_difference()返回两个集合中不重复的元素集合set.symmetric_difference_update() 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中set.union() 返回两个集合的并集set.update() 合并两个集合

下面是集合函数&方法的简单使用介绍

python集合函数

1：len(set)

功能：计算集合里元素的个数

set1={1,2,3,'a','b','c'} print(len(set1)) #result:6

python集合方法

1：set.add()

功能：为集合添加元素

set1={1,2,3,'a','b','c'} set1.add(4) print(set1) #result:{1, 2, 3, 4, 'a', 'c', 'b'}

2：set.clear()

功能：清空集合中的所有元素

set1={1,2,3,'a','b','c'} set1.clear() print(set1) #result:set()

3：set.copy()

功能：浅拷贝集合

set1={1,2,3,'a','b','c'} set2=set1.copy() print(set2) #result:{'a', 1, 2, 3, 'c', 'b'}

4：set.difference()

功能：返回多个集合的差集（有返回值）

set1={1,2,3} set2={3,4,5} print(set1.difference(set2)) print(set2.difference(set1)) #result:{1, 2} #result:{4, 5}

5：set.difference_update()

功能：移除集合中的元素，该元素在指定的集合也存在（无返回值）

set1={1,2,3,4,5,6,7} set2={3,4,5,6} set1.difference_update(set2) print(set1) #result:{1, 2, 7}

6：set.discard()

功能：移除集合中指定的元素

set1={1,2,3,'a','b','c'} set1.discard('a') print(set1) #result:{1, 2, 3, 'c', 'b'}

7：set.intersection()

功能：返回多个集合中的交集（有返回值）

set1={1,2,3,4,5} set2={2,4,6,8,0} print(set1.intersection(set2)) #result:{2, 4}

8：set.intersection_update()

功能：获取两个集合中的交际（无返回值）

set1={1,2,3,4,5} set2={2,4,6,8,0} set1.intersection_update(set2) print(set1) #result:{2, 4}

9：set.isdisjoint()

功能：判断两个集合中是否包含相同的元素，包含则返回False，否则为True

10：set.issubset()

功能：判断指定集合是否为该方法参数集合的子集,是则返回True，否则为False

set1={1,2,3,4,5} set2={1,2,3} set3={6,7,8} print(set2.issubset(set1)) #是则返回True print(set3.issubset(set1)) #不是则返回False #result:True #result:False

11：set.issuperset()

功能：判断该方法的参数集合是否为指定集合的子集,包含则返回True，不包含则返回False

set1={1,2,3,4,5} set2={1,2,3} set3={6,7,8} print(set1.issuperset(set2)) #包含则返回True print(set1.issuperset(set3)) #不包含则返回False #result:True #result:False

12：set.pop()

功能： 随机移除元素，会返回被移除的元素

set1={1,2,3,'a','b','c'} print(set1.pop()) print(set1) #result:1 #result:{2, 3, 'a', 'c', 'b'}

13：set.remove()

功能： 移除指定元素

set1={1,2,3,'a','b','c'} set1.remove('b') print(set1) #result:{1, 2, 3, 'a', 'c'}

14：set.symmetric_difference()

功能：返回两个集合中不重复的元素集合

set1={1,2,3,4,5} set2={2,4,6,8,0} print(set1.symmetric_difference(set2)) #result:{0, 1, 3, 5, 6, 8}

15：set.symmetric_difference_update()

功能：移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中

set1={1,2,3,4,5} set2={2,4,6,8,0} set1.symmetric_difference_update(set2) print(set1) #result:{0, 1, 3, 5, 6, 8}

16：set.union()

功能：返回两个集合的并集

set1={1,2,3,4,5} set2={2,4,6,8,0} set3=set1.union(set2) print(set3) #result:{0, 1, 2, 3, 4, 5, 6, 8}

17：set.update()

功能：合并两个集合

set1={1,2,3} set2={3,4,5} set1.update(set2) print(set1) #result:{1, 2, 3, 4, 5}

小白学python3--元组tuple

元组（tuple）与列表类似，不同之处就在于元组的元素不能修改。

创建空元组

#1.创建一个空元组（有两种方法） tup1=tuple() tup2=() print(type(tup1)) print(type(tup2)) #result:<class 'tuple'> #result:<class 'tuple'>

这边简单列举一下元组运算符&函数 python元组运算符：

tuple1+tuple2连接，合并两个元组tuple*n复制，将元组的元素重复n次n in tuple判断元素n是否包含在元组tuple中

python元组函数：

len(tuple) 计算元组元素的个数max(tuple)返回元组中元素的最大值min(tuple)返回元组中元素的最小值tuple(iterable) 将可迭代系列转换成元组

下面是元组运算符&函数的简单使用

python元组运算符

1：tuple1+tuple2

功能：连接，合并两个元组

#合并元组 tup1=(1,2,3) tup2=(4,5,6) tup3=tup1+tup2 print(tup3) #result:(1, 2, 3, 4, 5, 6)

2：tuple*n

功能：复制，将元组的元素重复n次

#复制元组元素 tup1=('a',) #如果创建只含有单个元素的元组，后面要加个逗号，否则类型为字符串 tup2=tup1*3 print(tup2) #result:('a', 'a', 'a')

3：n in tuple

功能：判断元素n是否包含在元组tuple中

#判断元组是否包含某元素 tup1=(1,2,'a','b') print(2 in tup1) print('c' in tup1) #result:True #result:False

python元组函数

1：len(tuple)

功能：计算元组元素的个数

#1.len(tuple) 计算元组元素的个数 tup=(1,2,'a','b') print(len(tup)) #result:4

2：max(tuple)

功能：返回元组中元素的最大值

#2.max(tuple) 返回元组中元素的最大值 tup=(1,3,6,4) print(max(tup)) #result:6

3：min(tuple)

功能：返回元组中元素的最小值

#3.min(tuple) 返回元组中元素的最小值 tup=(1,3,6,4) print(min(tup)) #result:1

4：tuple(iterable)

功能：将可迭代系列转换成元组

#4.tuple(iterable) 将可迭代系列转换成元组 lst=[1,3,6,4] tup=tuple(lst) print(tup) #result:(1, 3, 6, 4)

以上内容就是对于python的列表，字典，集合，元组的简单使用的笔记（本人学术不精，可能存在不少错误，还望多多指出！） END！