Python总结 列表 元组 字典 集合_创建新列表,其中每个元素是字符串hello中字符的重复三次

说明：本篇文章为作者复习阶段观看网课所写笔记，如有侵权，请联系作者删除。

创建列表

1.创建列表的第一种方式，使用[]

lst1 = ['hello','world',98,789]
 
print(lst1)
 
#列表元素按顺序有序排列
 
print(lst1[0])
 
#索引对应唯一的元素：索引可以是正数（从0开始）；也可以是负数（从-1开始）
 
print(lst1[-1],lst1[-4])

2.创建列表的第二种方式，使用内置函数list()

lst2 = list(['china','home',123])
 
print(lst2)
 
#列表元素按顺序有序排列
 
print(lst2[1])
 
#负数从最后一个开始往前递减（即最后一个是-1，倒数第二个是-2，以此类推）
 
print(lst2[-3])
 
#列表任意的数据类型可以混存
 
#根据需要动态分配和回收内存（即使用前不需要定义内存大小，使用后不需要释放内存）

列表的查询操作：（单个元素）

1.获取列表中指定元素的索引

    如果列表中存在N个相同元素，只返回相同元素中第一个元素的索引

    如果查询的元素在列表中不存在，则会抛出ValueError

    还可以在指定的start和top之间进行查找

2.获取列表中的单个元素

    正向索引从0到N-1

    逆向索引从-N到-1

    指定索引不存在，抛出indexError

#创建一个列表(其中有相同元素）
 
#lst = ['hello','world',98,'hello']
 
#print(lst.index('hello'))       #输出0
 
#index()函数获取括号内元素的索引（即元素在列表中的序号）
 
#print(lst.index('Python'))
 
#查找的元素不在列表中，ValueError
 
#print(lst.index('hello',1,3))   #从列表中索引为1的元素开始查找，直到索引为3的元素为止（不包括3）
 
#输出ValueError错误，1-3（不包括3）中的元素没有hello
 
#创建一个列表
 
lst2 = ['hello','world',98,'world',234]
 
#获取索引为2的元素
 
print(lst2[2])
 
#获取索引为-3的元素
 
print(lst2[-3])
 
#获取索引为10的元素
 
print(lst2[10])     #输出IndexError错误

列表的查询操作：（多个元素）

1.获取列表中的多个元素：切片

2.语法格式：列表名[start：stop：step]

3.切片操作：

    #切片的结果：原列表片段的拷贝

    #切片的范围:[start,stop)     左闭右开

    #step默认为1，简写为[start,stop]

    #step为正数，从start开始往后计算切片

    #step为负数，从start开始往后计算切片

lst=[10,20,30,40,50,60,70,80]
 
#start=1.stop=6,step=1
 
#print(lst[1:6:1])      #输出结果为[20,30,40,50,60]
 
print('原列表',id(lst))
 
lst2=lst[1:6:1]
 
print('切的片段',id(lst2))
 
print(lst[1:6])     #默认步长为1
 
#start=1;stop=6;step=2
 
print(lst[1:6:2])
 
#stop=6;step=2;start采用默认
 
print(lst[:6:2])    #start默认为0
 
#start=1;step=2;stop采用默认
 
print(lst[1::2])    #stop默认到最后
 
print('----------------------------step为负数的情况----------------------------------------')
 
print('原列表:',lst)
 
print(lst[::-1])    #逆序输出原列表
 
#start=7；stop省略；step=-1
 
print(lst[7::-1])
 
#strat=6;stop=0;step=-2
 
print(lst[6:0:-2])

列表元素的判断及遍历

1.判断指定元素在列表中是否存在

print('p' in 'python')      #判断p在python中，输出结果为True
 
print('k' not in 'python')  #判断k不在python中，输出结果为True
 
 
 
lst=[10,20,'python','hello']
 
print(10 in lst)        #True
 
print(100 in lst)       #False
 
print(10 not in lst)    #False
 
print(100 not in lst)   #True

2.列表元素的遍历

for item in lst:
 
print(item)

列表元素的增加操作

#append()在列表的末尾添加一个元素,在原列表末尾添加，并不创建新的列表

lst1=[10,20,30]
 
print('添加元素之前：',lst1,id(lst1))
 
lst1.append(100)
 
print('添加元素之后：',lst1,id(lst1))

#extend()在列表的末尾至少添加一个元素

lst2=['hello','world']
 
#lst1.append(lst2)       #将lst2整体作为一个元素添加到lst1的末尾
 
lst1.extend(lst2)        #向lst1的末尾一次性添加多个元素
 
print(lst1)

#insert()在列表的任意位置添加一个元素

lst1.insert(1,90)       #在lst1索引为1的位置之后添加元素90
 
print(lst1)

#切片:在列表的任意一个位置添加至少一个元素,把原来的元素切掉，换上新的元素

lst3=[True,False,'hello']
 
lst1[1:]=lst3
 
print(lst1)

列表元素的删除操作

#remove():一次删除一个元素；重复元素删除第一个；元素不存在抛出ValueError

lst=[10,20,30,40,50,60,30]
 
lst.remove(30)      #删除重复元素的第一个
 
print(lst)
 
#lst.remove(100)     #删除不存在的元素，抛出ValueError
 
print(lst)

#pop():删除一个指定索引位置上的元素；指定索引不存在抛出IndexError;不指定索引删除列表中最后一个元素

lst.pop(1)         #删除索引为1的元素
 
print(lst)
 
lst.pop()          #不指定索引删除列表中最后一个元素
 
print(lst)
 
#lst.pop(5)         #指定索引不存在，抛出IndexError
 
print(lst)

#切片:一次至少删除一个元素

#产生新的列表 #不产生新的列表，删除原列表中的元素
 
new_list=lst[1:3] lst[1:3]=[]
 
print('原列表：',lst) print(lst)
 
print('切片后：',new_list)

#clear():清空列表中的所有元素 #del:将列表删除

lst.clear() del lst
 
print(lst) print(lst)

列表的修改操作

#为指定索引的元素赋予一个新值 #为指定的切片赋予一个新值

lst=[10,20,30,40] lst[1:3]=[300,400,500]
 
#一次修改一个值 print(lst)
 
lst[2]=100
 
print(lst)

列表的排序操作

sort()和sorted()的区别在于：sort()是在原列表的基础上排序，sorted()是创建新列表进行排序

#sort()：默认将列中的所有元素从小到大排序，也可以指定reverse=True进行降序排序

lst=[20,40,10,98,54]
 
print('排序前的列表：',lst,id(lst))
 
#调用sort()，默认升序,没有产生新的列表
 
lst.sort()
 
print('排序后的列表：',lst,id(lst))
 
#通过指定关键字参数reverse=True,将列表中的元素进行降序排序
 
lst.sort(reverse= True)     #reverse=True 表示升序排序
 
print(lst)
 
lst.sort(reverse= False)     #reverse=False 表示降序排序
 
print(lst)

#sorted():指定reverse=True，进行降序排序，原列表不发生改变，产生新的列表

lst=[20,40,10,98,54]
 
print('原列表：',lst)
 
#开始排序
 
new_list=sorted(lst)
 
print(lst)
 
print(new_list )
 
#指定关键字参数，实现降序排序
 
desc_list=sorted(lst,reverse=True)
 
print(desc_list )

列表生成式

1.列表中的元素是1,2,3,4,5,6,7,8,9

lst=[i for i in range(1, 10)]
 
print(lst)

2.列表中的元素是 1,4,9,16,25,49,64,81 3.列表中的元素是2,4,6,8,10

lst=[i*i for i in range(1, 10)] lst2=[i*2 for i in range(1,6)]
 
print(lst) print(lst2)

1.列表 []  有序序列，第一个放入列表的元素索引就是1

2.字典 {}  无序序列，第一个放入字典的元素索引不一定就是1，可利用hash()

3.列表和字典都是可变序列，即都可进行增删改

4.字典是以键值对的方式存储数据的

5.字典名={'键':值，'键':值,'键':值}

6.scores={'张三':100,'李四':99,'王五':98}

创建字典 字典的创建方式：使用花括号{}；使用内置函数dict()

1.使用{}创建字典 3.创建空字典

scores={'张三':100,'李四':98,'王五':45} d={}
 
print(scores) print(d)    #输出{}
 
print(type(scores))     #类型是dict

2.使用内置函数dict()创建字典 4.使用字典生成式创建

student=dict(name='jack',age=20)
 
print(student)
 
print(type(student))    #类型是dict

获取字典中的元素

字典中元素的获取：通过键获取与其对应的值   1.scores['张三']    2.scores.get('张三')

scores={'张三':100,'李四':98,'王五':45}
 
#第一种方式：使用[] print(scores['张三'])     #输出100
 
#第二种方式：使用get()
 
print(scores.get('李四'))     #输出98
 
print(scores.get('陈六'))     #输出None
 
print(scores.get('麻七',99))  #输出99；99是在查找‘麻七’所对的value不存在时，提供的一个默认值

字典的增删查改操作

scores={'张三':100,'李四':98,'王五':45}
 
#键(key)的判断
 
print('张三' in scores )          #张三在scores中，输出True
 
print('张三' not in scores )      #张三不在scores中，输出False
 
#字典元素的删除
 
#通过删除指定的键(key)，从而删除整个键值对(key-value)
 
del scores['张三']   #删除指定键值对
 
print(scores)        #输出{'李四': 98, '王五': 45}
 
#scores.clear()      #将字典中的所有元素都删除
 
#print(scores)       #输出{}
 
#字典元素的新增
 
scores['陈六']=98
 
print(scores)       #输出{'李四': 98, '王五': 45, '陈六': 98}
 
#字典元素的修改
 
scores['陈六']=100   #对指定键值对进行修改
 
print(scores)       #输出{'李四': 98, '王五': 45, '陈六': 100}
 
获取字典视图
 
1.keys()    获取字典中所有key（键）
 
2. values()  获取字典中所有value（值）
 
3. items()   获取字典中所有key-value对（键值对）
 
scores={'张三':100,'李四':98,'王五':45}
 
#获取字典中所有key
 
keys=scores.keys()
 
print(keys)             #输出dict_keys(['张三', '李四', '王五'])
 
print(type(keys))       #输出<class 'dict_keys'>
 
print(list(keys))       #将所有的key组成的视图转换成列表
 
#获取字典中所有value
 
values=scores.values()  #输出dict_values([100, 98, 45])
 
print(values)           #输出<class 'dict_values'>
 
print(type(values))     #将所有的value组成的视图转换成列表
 
#获取字典中所有key-value对
 
items=scores.items()
 
print(items)            #输出dict_items([('张三', 100), ('李四', 98), ('王五', 45)])
 
print(type(items))      #输出<class 'dict_items'>
 
print(list(items))      #输出[('张三', 100), ('李四', 98), ('王五', 45)]；转换之后的列表元素是由元组组成的

字典元素的遍历 依次获取字典中的元素

scores={'张三':100,'李四':98,'王五':45}
 
for item in scores:
 
    print(item)     #item代表键
 
    #根据键获取字典中的值
 
    print(scores[item])
 
    print(scores.get(item))

字典的特点

1.字典中的所有元素都是一个key-value对，key不允许重复，value可以重复

a={'name':'张三','name':'李四'}
 
print(a)        #输出{'name': '李四'}；key不允许重复
 
b={'name':'张三','firstname':'张三'}
 
print(b)        #输出{'name': '张三', 'firstname': '张三'}；value可以重复

2.字典中的元素是无序的，即无法指定某个位置插入元素

3.字典当中的key必须是不可变对象

4.字典可以根据需要，动态地伸缩

5.字典会浪费较大的内存，是一种使用空间换时间的数据结构

字典生成式

items1=['Fruits','Books','Others']   #列表1
 
prices1=[96,78,85]   #列表2
 
#upper()将字母全部转换为大写
 
d1={item.upper():price   for item,price in zip(items1,prices1)}
 
print(d1)    #输出{'FRUITS': 96, 'BOOKS': 78, 'OTHERS': 85}
 
 
 
#当两个列表数据个数不匹配时，以少的为依据
 
items2=['Fruits','Books','Others']   #列表1
 
prices2=[96,78,85,100,500]   #列表2
 
d2={item.upper():price   for item,price in zip(items2,prices2)}
 
print(d2)    #输出{'FRUITS': 96, 'BOOKS': 78, 'OTHERS': 85}

元组

1.元组：Python内置的数据结构之一，是不可变序列

2.元组()   列表[]    字典{}

3.不可变序列：字符串、元组；没有增删改的操作

4.可变序列：列表、字典；可以对序列执行增删改操作，对象地址不发生改变

#列表
 
lst=[10,20,45]
 
print(id(lst))
 
lst.append(300)     #在原列表中增加元素300
 
print(id(lst))      #增加元素前后列表的地址没有改变
 
 
 
#字符串
 
s='hello'
 
print(id(s))
 
s=s+' world'
 
print(id(s))        #增加元素前后字符串的地址发生改变
 
print(s)

创建元组

1.第一种，直接使用小括号

t=('Python','world',98)
 
print(t)
 
print(type(t))      #输出<class 'tuple'>
 
#第一种方式可以省略小括号
 
n='Python','world',98
 
print(n)
 
print(type(n))      #输出<class 'tuple'>
 
#只包含一个元组的元素需要使用逗号和小括号
 
l=(10,)
 
print(l)             #一定要加逗号
 
print(type(l))       #输出<class 'tuple'>
 

2.第二种，使用内置函数tuple()

m=tuple(('Python','world',98))
 
print(m)
 
print(type(m))      #输出<class 'tuple'>
 
#创建空列表
 
lst1=[]
 
lst2=list()
 
print('空列表',lst1 ,lst2 )
 
#创建空字典
 
d1={}
 
d2=dict()
 
print('空字典',d1 ,d2 )
 
#创建空元组
 
t1=()
 
t2=tuple()
 
print('空元组',t1 ,t2 )
 
#为什么要将元组设计成不可变序列
 
        #在多任务环境下，同时操作对象时不需要加锁
 
        #因此，在程序中尽量使用不可变序列
 
#注意事项：元组中存储的是对象的引用
 
        #如果元组中的对象是不可变对象，则不能再引用其它对象
 
        #如果元组中的对象是可变对象，则可变对象的引用不允许改变，但数据可以改变
 
t=(10,[20,30],9)
 
print(t)
 
print(type(t))
 
print(t[0],type(t[0]),id(t[0]))     #输出10 <class 'int'>
 
print(t[1],type(t[1]),id(t[1]))     #输出[20, 30] <class 'list'>
 
print(t[2],type(t[2]),id(t[2]))     #输出9 <class 'int'>
 
#将t[1]修改为100
 
print(id(100))
 
#t[1]=100            #元组不允许修改元素
 
#由于t[1](即[20,30])是列表，而列表是可变序列，所以可以向该列表中添加元素，而列表的内存地址不变
 
t[1].append(100)        #在列表的末尾添加元素
 
print(t)                #输出(10, [20, 30, 100], 9)
 
print(id(t))            #添加后与最初的地址相同

遍历元组 元组是可迭代对象，所有可以使用for...in进行遍历

t=('Python','world',98)

1.第一种获取元组元素的方式:使用索引

print(t[0])
 
print(t[1])
 
print(t[2])
 
#print(t[3])     #IndexError: tuple index out of range

2.第二种获取元组元素的方式:遍历元组

for item in t:
 
    print(item)

集合创建

1.python中的内置数据结构：列表、字典、元组、集合

2.列表、字典、集合都是可变序列

3.集合是没有value的字典

4.元素放入集合的顺序并不是其索引顺序，需要使用dash()计算元素的位置

#集合的创建方式
 
#第一种，使用{}
 
s={2,3,4,5,5,6,7,7}
 
print(s)            #输出{2, 3, 4, 5, 6, 7}；因为集合中的元素不可以重复
 
#第二种，使用set()
 
s1=set(range(6))    #range(6)产生0-5的序列
 
print(s1)           #输出{0, 1, 2, 3, 4, 5}
 
print(type(s1))     #输出<class 'set'>
 
 
 
s2=set([1,2,3,3])   #通过set()将列表转换为集合
 
print(s2)           #输出{1, 2, 3}；因为集合中的元素不可以重复
 
print(type(s2))     #输出<class 'set'>
 
 
 
s3=set((1,4,4,65))  #通过set()将字典转换为集合
 
print(s3)           #输出{65, 1, 4}；因为集合中的元素是无序的
 
print(type(s3))     #输出<class 'set'>
 
 
 
s4=set('python')    #通过set()将字符串转换为集合
 
print(s4)           #输出{'t', 'n', 'y', 'o', 'h', 'p'};因为集合中的元素的无序的
 
print(type(s4))     #输出<class 'set'>
 
 
 
s5=set({56,45,99})  #通过set()将集合转换为集合，也可直接当作集合
 
print(s5)           #输出{56, 99, 45}；因为集合中的元素是无序的
 
print(type(s5))     #输出<class 'set'>
 
 
 
#定义空集合
 
s6={}
 
print(type(s6))     #输出<class 'dict'>；没有定义成功，不可以直接使用{}定义空集合
 
s7=set()
 
print(type(s7))     #输出<class 'set'>；定义成功

集合的数据操作

s1={10,20,30,40}
 
s2={20,30,40,50,60}
 
#交集：集合A和集合B共有的元素组成的集合
 
print(s1.intersection(s2) )
 
print(s1 & s2)          # &  与  intersection() 等价，都可以求两个集合的交集
 
 
 
#并集：集合A+集合B
 
print(s1.union(s2) )
 
print(s1 | s2)          # |  与  union() 等价，都可以求两个集合的并集
 
 
 
#差集：集合A-集合B
 
print(s1.difference(s2) )       #集合A-集合B
 
print(s1-s2)            # -  与  difference() 等价，都可以求两个集合的差集
 
 
 
#对称差集:并集-交集
 
print(s1.symmetric_difference(s2) )
 
print(s1 ^ s2)

集合的运算

#随机生成 [0,10]范围的整数，分别组成集合A和集合B
 
#输出A和B的内容、长度、最大值、最小值以及它们的并集、交集和差集。
 
import random
 
def fun():
 
    List = []
 
    for j in range(5):
 
        x = random.randint(0,10)
 
        List.append(x)
 
    return set(List)
 
A = fun()
 
B = fun()
 
print(str.format("集合的内容,长度,最大值,最小值分别为：\n{0} {1} {2} {3}",A,len(A),max(A),min(A)))
 
print(str.format("{0} {1} {2} {3}",B,len(B),max(B),min(B)))
 
print(str.format("A和B的并集,交集和差集分别为：\n{0} {1} {2} ",A|B,A&B,A-B))
 
 
 

集合间的关系

#两个集合是否相等：可以使用==或！=进行判断；元素相同就相等
 
s1={10,20,30,40}
 
s2={30,40,20,10}
 
print(s1==s2)       #True
 
print(s1!=s2)       #False
 
s3={10,20,30,40,50,60}
 
s4={10,20,30,40}
 
s5={10,20,90}
 
#一个集合是否为另一个集合的子集：可以调用issubest进行判断
 
print(s4.issubset(s3) )         #判断s4是不是s3的子集；输出True
 
print(s5.issubset(s3) )         #判断s5是不是s3的子集；输出False
 
#一个集合是否为另一个集合的超集：可以调用issuperset进行判断
 
#若A是B的子集，那么B就是A的超集
 
print(s3.issuperset(s4) )       #判断s3是不是s4的超集；输出True
 
print(s3.issuperset(s5) )       #判断s3是不是s5的超集；输出True
 
#两个集合是否没有交集：可以使用isdisjiont进行判断
 
print(s3.isdisjoint(s5) )       #判断s3和s5没有交集；输出False
 
print(s5.isdisjoint(s3) )       #与其上作用相同
 
s6={500,900}
 
print(s3.isdisjoint(s6) )       #判断s3和s6没有交集；输出True

列表生成式 集合生成式

lst=[i*i for i in range(6)] s={i*i for i in range(6)}
 
print(lst) print(s)

列表、元组、字典、集合总结

#列表   可变     可重复                          有序      []
 
#元组   不可变   可重复                          有序     ()
 
#字典   可变     key不可重复；value可以重复     无序     {key:value}
 
#集合   可变     不可重复                        无序     {}
 
 
 
#元组创建：使用()创建；使用内置函数tuple()
 
#元组遍历：for...in
 
#元组是不可变序列，无法进行增删改操作
 
 
 
#集合创建：使用{}创建；使用内置函数set();使用集合生成式 s={i*i for i in range(6)}
 
#集合遍历：for...in
 
#集合新增：add()一次只删除一个元素;update()一次至少删除一个元素
 
#集合删除：remove()若删除元素不存在抛出错误;discard()若删除元素不存在不抛出错误;pop()随机删除任意一个元素;clear()清空列表
 
#集合是可变序列，可以进行增删改操作