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

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

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

书签

• python列表list
• python字典dict
• python集合set
• python元组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()	创建一个新字典,以序列作为字典的键,值默认是None
dict.get(key,default=None)	返回字典中指定键对应的值，若不存在，则返回default值
key in dict	判断某个键是否在字典中，存在则返回True，否则为False
dict.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，否则为True
set.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！