“人生苦短，我用Python“——python基础＜2＞_python函数打印生命苦短我用-CSDN博客

本文链接：https://blog.csdn.net/weixin_42902126/article/details/126593628

列表

为什么需要列表？

变量可以存储一个元素，而列表是一个“大容器”可以存储N多个元素，程序可以方便地对这些数据进行整体操作。
列表相当于其他语言中的数组。
列表示意图。

a=10#a变量存储的是10这个对象的内存地址
print(id(a))#1375625728
lst=['hello','world',97]#lst变量存储的是一个列表对象的内存地址。这个列表对象存储着n多个对象的地址(也就是表中元素的地址)。
print(id((lst)))#2414716576712
print(type(lst))#<class 'list'>
print(lst)#['hello', 'world', 97]

列表内存示意图
在这里插入图片描述

列表的创建

方式一：列表需要使用中括号[]，元素之间使用英文逗号分隔

lst=['英子','呆低']#内存示意图参考上图

方式二：调用内置函数list()

lst=list(['英子','呆低'])

列表的特点

列表元素按顺序有序排序。
索引映射唯一数据。
列表可以重复存储重复数据。
任意数据类型混存。
根据需要动态分配和回收内存。

lst=['hello','world',97]
print(lst[0])#hello
print(lst[-3])#hello

在这里插入图片描述

获取指定元素的索引

index()：获取指定元素的索引。
若列表当中存在多个相同的元素，只返回相同元素中的第一个元素的索引。
如果元素不在所查的列表当中，报错ValueError。

lst=['hello','world',97,'hello']
print(lst.index('hello'))#0
print(lst.index('Python'))#ValueError: 'Python' is not in list

index(i,x,y)：在索引x,y中查找元素i，索引范围不包含y。

lst=['hello','world',97,'hello']
print(lst.index('hello',1,3))#ValueError: 1 is not in list    #在['world',97]中查找。
print(lst.index('hello',1,4))#3   #在['world',97,'hello']中查找。

按照索引查询元素

lst=['hello','world',97,'hello']
print(lst[3])#hello
print(lst[-2])#97 ---逆向索引
print(lst[10])#IndexError: list index out of range   ---超出范围

获取列表多个元素_ 切片操作
列表名[start:stop:step]
在这里插入图片描述

lst=[10,20,30,40,50,60,70,80,90]
print(lst[1:6:1])#[20, 30, 40, 50, 60]
print('原列表',id(lst))#2211400115144
lst2=lst[1:6:1]
print('切断片段',id(lst2))#2211400154568  切片创建了一个新的对象
print(lst[1:6])#[20, 30, 40, 50, 60] 默认step为1
print(lst[1:6:])#[20, 30, 40, 50, 60]
print(lst[:6:2])#[10, 30, 50]  start默认是0
print(lst[1::2])#[20, 40, 60, 80] stop默认到末尾

#step为负数
print(lst[::-1])#[90, 80, 70, 60, 50, 40, 30, 20, 10] 逆序输出
print(lst[7::-1])#[80, 70, 60, 50, 40, 30, 20, 10] 从索引为7的元素逆序输出
print(lst[6:0:-2])#[70, 50, 30] 从索引为6的元素，逆序输出step为2

列表元素查询操作
判断指定元素在列表中是否存在：in ，not in

lst=[10,20,'python','hello']
print(10 in lst)#True
print(100 in lst)#False

列表元素的遍历:for 迭代变量 in 列表名：

lst=[10,20,'python','hello']

for item in lst:
    print(item)
'''
10
20
python
hello
'''

列表元素增加操作

方法/其他	操作描述
append()	在列表的末尾添加一个元素
extend()	在列表的末尾至少添加一个元素
insert()	在列表的任意位置添加一个元素
切片	在列表的任意位置添加至少一个元素

#向列表末尾添加一个元素
lst=[10,20,30]
print(id(lst))#2375283762248
lst.append(100)
print(lst)#[10, 20, 30, 100]
print(id(lst))#2375283762248 标识相同，意味着没有创建新的对象

lst2=['hello','world']
lst.append(lst2)#将lst2作为一个对象添加到lst1的末尾
print(lst)#[10, 20, 30, 100, ['hello', 'world']]

lst.extend(lst2)#向列表末尾添加多个元素
print(lst)#[10, 20, 30, 100, ['hello', 'world'], 'hello', 'world']

#在任意位置上添加一个元素
lst.insert(1,90)#在索引为1的位置上添加90
print(lst)#[10, 90, 20, 30, 100, ['hello', 'world'], 'hello', 'world']

#在列表任意位置添加多个元素-切片
lst3=[True,False,'hello']
lst[1:]=lst3#把索引为1之后的元素全部切掉，再添加lst3的内容
print(lst)#[10, True, False, 'hello']

列表元素的删除操作

方法/其他	操作描述
remove()	①一次删除一个元素 ②重复元素只删除第一个 ③元素不存在抛出ValueError
pop()	①删除一个指定索引位置上的元素 ②指定索引不存在抛出IndexError ③不指定索引，删除列表最后一个元素
切片	一次至少删除一个元素
clear()	清空列表
del	删除列表

lst=[10,20,30,40,50,60,30]

lst.remove(30)
print(lst)#[10, 20, 40, 50, 60, 30]
#lst.remove(100)#ValueError: list.remove(x): x not in list 元素不存在

lst.pop(0)#移除索引为0的元素
print(lst)#[20, 40, 50, 60, 30]
lst.pop()#移除最后一个元素
print(lst)#[20, 40, 50, 60]
#lst.pop(10)#IndexError: pop index out of range 索引超出范围报错

new_list=lst[1:3]#这里的删除，就是切片生成要给新的列表对象
print(lst)#[20, 40, 50, 60]
print(new_list)#[40, 50]
#不产生新列表对象，而是删除原列表中的内容
lst[1:3]=[]#将索引1-3的元素替代为空，也就是变相删除
print(lst)#[20, 60]

lst.clear()#清空表
print(lst)#[]

del lst#删除表对象
print(lst)#NameError: name 'lst' is not defined

列表元素的修改操作

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

lst=[10,20,30,40]
#修改一个元素
lst[2]=100
print(lst)#[10, 20, 100, 40]
#切片修改多个元素
lst[1:3]=[300,400,500,600]
print(lst)#[10, 300, 400, 500, 600, 40]

列表元素的排序操作

常见的两种方式：

调用sort()方法，列有中的所有元素默认按照从小到大的顺序进行排序，可以指定reverse=True，进行降序排序。
调用内置函数sorted()，可以指定reverse=True，进行降序排序，源列表不发生改变。

lst=[20,40,10,98,54]
print(lst,id(lst))#[20, 40, 10, 98, 54] 2841028322376
lst.sort()
print(lst,id(lst))#[10, 20, 40, 54, 98] 2841028322376 内存地址未发生改变，没有创建新的对象
lst.sort(reverse=True)
print(lst)#[98, 54, 40, 20, 10]

lst=[20,40,10,98,54]
print(lst)#[20, 40, 10, 98, 54]
new_list=sorted(lst)#创建了一个新的对象
print(new_list)#[10, 20, 40, 54, 98]
desc_list=sorted(lst,reverse=True)
print(desc_list)#[98, 54, 40, 20, 10]

列表生成式

列表生成式简称“生成列表的公式”
语法格式：

[ i*i for i in range(1,10)]

注意事项：“表示列表元素的表达式”中通常包含自定义变量。

lst=[i for i in range(1,10)]
print(lst)#[1, 2, 3, 4, 5, 6, 7, 8, 9]
lst2=[i*i for i in range(1,10)]
print(lst2)#[1, 4, 9, 16, 25, 36, 49, 64, 81]

"""列表中的元素为2，4，6，8，10"""
lst3=[i*2 for i in range(1,6)]
print(lst3)#[2, 4, 6, 8, 10]

字典

什么是字典？

Python内置的数据结构之一，与列表一样是一个可变序列。
以键值对的方式存储数据，字典是一个无序的序列。

字典内存示意图：

字典的实现原理：
字典的实现原理与查字典类似，查字典是先根据部首或拼音查找相应页码，Python中的字典是根据key查找value所在的位置。

字典的创建

使用花括号：scores={ ‘张三’:100,‘李四’:98,‘王五’:45}
使用内置函数dict()：dict(name=‘jack’,age=20)

scores={'张三':100,'王五':98,'李四':45}
print(scores)#{'张三': 100, '王五': 98, '李四': 45}
print(type(scores))#<class 'dict'>

stu=dict(name='jack',age=10)
print(stu)#{'name': 'jack', 'age': 10}

d={}#空字典
print(d)#{}

字典元素的获取

在这里插入图片描述
[]取值与使用get()取值的区别

[]如果字典中不存在指定的key，抛出KeyError异常。
get()方法取值，如果字典中不存在指定的key，并不会抛出KeyError而是返回None，可以通过参数设置默认的value，以便指定的key不存在时返回。

scores={'张三':100,'王五':98,'李四':45}
#[]
print(scores['张三'])#100
#print(scores['陈六'])#KeyError: '陈六'

#get()
print(scores.get('张三'))#100
print(scores.get('陈六'))#None

#设置默认值
print(scores.get('麻七',99))#99 这括号里的99就是默认值。若字典中不存在，则输出默认值。

key的判断

在这里插入图片描述

scores={'张三':100,'王五':98,'李四':45}

print('张三' in scores)#True
print('张三' not in scores)#False

字典元素的删除与新增

删除：del scores[‘张三’]
新增：scores[‘jack’]=90

scores={'张三':100,'王五':98,'李四':45}

del scores['张三']
print(scores)#{'王五': 98, '李四': 45}
scores.clear()#清空字典元素
print(scores)#{}

scores['陈六']=98
print(scores)#{'陈六': 98}

获取字典视图的三个方法

在这里插入图片描述

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()
print(values)#dict_values([100, 98, 45])
print(type(values))#<class 'dict_values'>
print(list(values))#[100, 98, 45] 同样转成列表

#获取所有的key-value对
items=scores.items()
print(items)#dict_items([('张三', 100), ('王五', 98), ('李四', 45)])
print(list(items))#[('张三', 100), ('王五', 98), ('李四', 45)]  转换后的列表是由元组组成的

字典元素的遍历

scores={'张三':100,'王五':98,'李四':45}
for item in scores:
    #遍历键
    print(item)
    #遍历值
    print(scores[item])
    print(scores.get(item))

字典的特点

字典中的所有元素都是一个key-value对，key不允许重复，value可以重复。
字典中的元素是无序的。
字典中的key必须是不可变对象。
字典也可以根据需要动态的伸缩。
字典会浪费较大的内存，是一种使用空间换时间的数据结构。

l1={123:'zhangsan',123:'lisi'}
print(l1)#{123: 'lisi'} 键重复会出现覆盖情况
l2={123:'zhangsan',456:'zhangsan'}
print(l2)#{123: 'zhangsan', 456: 'zhangsan'} 值是可以重复的

#字典中元素是无序的，不能像列表通过索引直接找到想要的元素，只能通过key来hash计算value的位置。

#不可变对象指：整数，字符串等。list列表就不能作为键。
lst=[1,2,3,4]
d={lst:100}#TypeError: unhashable type: 'list'   list是一个可变对象

#字典是通过hash计算位置，那么必然会产生大量的空余空间。同时直接通过hash计算也节省了查找时间。

字典生成式

在这里插入图片描述
内置函数zip()
用于将可迭代的对象作为参数，将对象中对应的元素打包成一个元组，然后返回由这些元组组成的列表。

{item.upper():price for item,price in zip(items,prices)}

items=['Fruits','Books','Others']
prices=[96,78,87,100,222]
d={item.upper():price for item,price in zip(items,prices)}
print(d)#{'Fruits': 96, 'Books': 78, 'Others': 87}
#zip()会截取短的列表生成元组
#upper()将字符串改为大写

元组

什么是元组？

Python内置的数据结构之一，是一个不可变序列。
不可变序列与可变序列
不可变序列：字符串、元组——没有增删改操作。
可变序列：列表、字典——可对序列执行增删改操作，对象地址不发生改变。

#可变序列 列表、字典
lst=[10,20,45]
print(id(lst))#1843391751240
lst.append(300)
print(id(lst))#1843391751240 添加元素地址不产生新的对象，地址不变

#不可变序列 字符串、元组
s='hello'
print(id(s))#3130940821888
s=s+'world'
print(id(s))#3130940907888  #地址改变，产生了新的对象

元组的创建方式

直接小括号：t=(‘python’,‘hello’,90)
使用内置函数tuple()：t=tuple((‘python’,‘hello’,90))
只包含一个元组的元素需要使用逗号和小括号：t=(10,)

#()
t=('Python','world',99)
print(t)#('Python', 'world', 99)
print(type(t))#<class 'tuple'>

t1='Python','world',99#省略小括号
print(t1)#('Python', 'world', 99)
print(type(t1))#<class 'tuple'>

#tuple()
t2=tuple(('Python', 'world', 99))
print(t2)#('Python', 'world', 99)
print(type(t2))#<class 'tuple'>

#只包含一个元素的元组，需要添加 , 和 ()
t3=('Python')
print(type(t3))#<class 'str'>

t4=('Python',)
print(type(t4))#<class 'tuple'>

#空元组
t5=()
t6=tuple()
print(t5)#()
print(t6)#()

为什么将元组设计成不可变序列

多任务环境下，同时操作对象时不需要加锁，也不会对数据造成破坏。因此，在程序中尽量使用不可变序列。
注意事项：元组中存储的是对象的引用

如果元组中对象本身不可变对象，则不能引用其他对象。
如果元组中对象本身是可变对象，则可变对象的引用不允许改变，但数据可以改变。

t=(10,[20,30],9)#其中10，9是整数不可变类型，[20,30]是列表可变类型
print(t)#(10, [20, 30], 9)
print(type(t))#<class 'tuple'>
print(t[0],type(t[0]))#10 <class 'int'>
print(t[1],type(t[1]))#[20, 30] <class 'list'>
print(t[2],type(t[2]))#9 <class 'int'>

"""尝试将t[1]修改为100"""
#t[1]=100#TypeError: 'tuple' object does not support item assignment 元组是不允许修改的
#由于[20,30]是列表，列表是可变序列，所以可以向列表添加元素，而列表的内存地址不变
t[1].append(100)#向列表添加元素
print(t)#(10, [20, 30, 100], 9)

元组的遍历

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

t=('Python',[20,30],9)
for item in t:
    print(item)
"""
Python
[20, 30]
9
"""

集合

什么是集合？

Python语言提供的内置数据结构。
与列表、字典一样都属于可变类型的序列。
集合是没有value的字典。

集合的创建方式

直接{}：s={‘Python’,‘hello’,90}
使用内置函数set()

#{}
s={2,2,4,5,5,6,7}#集合中的元素不允许重复
print(s)#{2, 4, 5, 6, 7}

#set()
s1=set(range(6))
print(s1,type(s1))#{0, 1, 2, 3, 4, 5} <class 'set'>

print(set([1,2,3,4,5,6,6]))#{1, 2, 3, 4, 5, 6} 将列表元素转换成集合，同时去掉重复元素

print(set([1,2,3,4,65]))#{65, 1, 2, 3, 4}  集合元素是无序的

s2=set('Python')#将字符串序列转成集合中的元素
print(s2,type(s2))#{'y', 'n', 'h', 't', 'o', 'P'} <class 'set'>

s3=set({'python','ssss',2323})#将集合转成集合
print(s3,type(s3))#{'ssss', 'python', 2323} <class 'set'>

#空集合
s4={} #dict字典类型
print(s4,type(s4))#{} <class 'dict'>

s5=set()#定义空集合
print(s5,type(s5))#set() <class 'set'>

集合元素的判断in或not in

s={1,2,3,100}
print(1 in s)#True
print(10 in s)#False
print(1 not in s)#False
print(10 not in s)#True

集合元素的新增操作

调用add()方法，一次添中一个元素。
调用update()方法至少添中一个元素。

s={10,20,30,404,505}
s.add(80)#添加一个元素
print(s)#{10, 80, 404, 20, 505, 30}
s.update({200,300,123})#添加多个元素
print(s)#{200, 10, 300, 80, 404, 20, 505, 123, 30}
s.update([1,2])#添加列表
print(s)#{1, 2, 200, 10, 300, 80, 404, 20, 505, 123, 30}
s.update((3,4,555))#添加元组
print(s)#{1, 2, 3, 4, 200, 10, 555, 300, 80, 404, 20, 505, 123, 30}

集合元素的删除操作

调用remove()方法，一次删除一个指定元素，如果指定的元素不存在抛出KeyError。
调用discard()方法，一次删除一个指定元素，如果指定元素不存在不抛出异常。
调用pop()方法，一次只删除一个任意元素。
调用clear()方法，清空结合。

s={10,20,30,404,505}

s.remove(10)
print(s)#{404, 20, 505, 30}
#s.remove(500)#KeyError: 500

s.discard(500)#有则删除，没有也不抛出异常。
print(s)#{404, 20, 505, 30}

s.pop()
print(s)#{20, 505, 30}
#s.pop(505)#TypeError: pop() takes no arguments (1 given) pop()方法不能添加参数，只能删除任意的元素。

s.clear()
print(s)#set()

集合间的关系

***两个集合是否相等：***可以使用运算符==或!=进行判断。
***一个集合是否是另一个集合的子集：***可以调用方法issubset进行判断。
***一个集合是否是另外一个结合的超集：***可以调用方法issuperset进行判断。
***两个集合是否没有交集：***可以调用方法isdisjoint进行判断。

#相等
s1={10,20,30,40}
s2={40,20,10,30}
print(s1==s2)#True
print(s1!=s2)#False

#子集、超集、交集
s1={10,20,30,40}
s2={10,30,40}
s3={10,50}
print(s2.issubset(s1))#True
print(s3.issubset(s2))#False

print(s1.issuperset(s3))#False
print(s1.issuperset(s2))#True

print(s2.isdisjoint(s3))#False  有交集为False
s4={100,200,300}
print(s3.isdisjoint(s4))#True  s3与s4没有交集，没有交集为True

集合的数学操作

在这里插入图片描述

#交集
s1={10,20,30,40}
s2={20,30,40,50,60}
print(s1.intersection(s2))#{40, 20, 30}
print((s1 & s2))#{40, 20, 30} intersection()与 & 等价，交集操作

#并集
print(s1.union(s2))#{40, 10, 50, 20, 60, 30} 去重合并
print(s1 | s2)#{40, 10, 50, 20, 60, 30}  | 与 union 等价

#差集
print(s1.difference(s2))#{10}  "s1-s2"
print(s1-s2)#{10}

#对称差集
print(s1.symmetric_difference(s2))#{50, 10, 60}
print(s1^ s2)#{50, 10, 60}

"""数学操作皆不会改变原来的集合"""
print(s1)#{40, 10, 20, 30}
print(s2)#{40, 50, 20, 60, 30}

集合生成式

{i*i for i in range(1,10)}

==注意：==将{}修改为[]就是列表生成式。元组没有生成式。

lst=[i*i for i in range(1,10)]#列表生成式
print(lst)#[1, 4, 9, 16, 25, 36, 49, 64, 81]
s={i*i for i in range(1,10)}#集合生成式
print(s)#{64, 1, 4, 36, 9, 16, 49, 81, 25}

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

数据结构	是否可变	是否重复	是否有序	定义符号
列表(list)	可变	可重复	有序	[]
元组(tuple)	不可变	可重复	有序	()
字典(dict)	可变	key不可重复、value可重复	无序	{key:value}
集合(set)	可变	不可重复	无序	{}