一、引言
Python作为一门流行的编程语言,其前景一直是编程界的热门话题。Python简洁的语法、强大的标准库和丰富的第三方库使其在众多领域都有广泛的应用,从网站开发、数据分析、人工智能到科学计算等。随着数据科学和人工智能的兴起,Python的需求持续增长,成为了许多初学者和转行人士的首选语言。
根据业界调查,Python的流行度持续位于顶尖位置。技术发展的趋势表明,Python在未来仍然是一个值得投资学习的语言,不仅因为其在当前的技术市场中的需求,还因为它在教育、科研和自动化等领域的扩展性。
二、第五章
1.集合
# Author : zzd
# Date : 2016/2/3 22:41
# 集合
"""
集合:
Python语言提供的内置数据结构
与列表、字典一样都属于可变类型的序列
集合是没有value的字典
"""
# 1.集合的创建
"""
集合的创建方式:
直接{}
s = {'python','java'}
使用内置函数set()
s = set(range(6))
s = set([1,2,3,4])
s = set((1,2,3,4))
s = set('python')
s = set({1,2,3,4})
s = set()
"""
def create_tuple():
s = {'python', 'java','java'} # 集合中元素不能重复,会把重复的元素自动去掉
print(s,type(s))
s = set(range(6))
print(s, type(s))
s = set([5, 2, 3, 4]) # 集合中元素是无序的
print(s, type(s))
s = set((1, 6, 3, 4))
print(s, type(s))
s = set('python')
print(s, type(s))
s = set({1, 2, -1, 4})
print(s, type(s))
s = set() # 空集合
print(s, type(s))
s = {} # 空字典
print(s, type(s)) # 不能使用空的大括号创建集合,因为这默认是字典
# 2. 集合相关操作
"""
集合元素的判断
in
not in
集合元素的新增:
add() ,一次添加一个元素
update()至少添加一个元素
集合元素的删除:
remove() ,一次删除一个指定元素,如果指定元素不存在抛出异常KeyError
discord(),一次删除指定元素,如果指定元素不存在不抛出异常
调用pop(),一次只删除一个任意元素
调用clear() ,情况集合
"""
def opter_set():
s = {'hello','my','python','time'}
print('python是否在集合中?','python' in s)
print('python是否不在集合中?', 'python' not in s)
s.add('java')
print('add添加元素Java:',s)
s.update('a','b','c')
print('update添加元素a,b,c:',s)
s.remove('java')
print('指定删除Java元素:',s)
# s.remove('zxy') remove删除一个不存在的元素,会抛出异常
s.discard('zxy')
print('discard删除不存在的元素,不会报错:',s)
s.pop()
print('pop删除任意一个元素:',s)
s.clear()
print('clear清空所有集合元素:',s)
# 3.集合的关系
"""
两个集合是否相等
可以使用运算符==或!=判断
一个集合是否是另一个集合的子集
可以调用方法issubset进行判断
B是A的子集
一个集合是否另一个集合的超集
可以调用方法issuperset进行判断
A是B的超集
两个集合是否没有交集
可以调用方法isdisjoint进行判断
"""
def relation_set():
s1 = {10,20,30,40}
s2 = {40,10,20,30}
s3 = {10,20}
s4 = {60,70}
print('s1和s2相同?',s1==s2)
print('s1和s2不相同',s1!=s2)
print('s3是s1的子集?',s3.issubset(s1))
print('s1是s3的超集',s1.issuperset(s3))
print('s1和s4没有交集?',s1.isdisjoint(s4)) # 没有交集为True,有交集为False
# 4.集合的数据操作
"""
交集
并集
差级
"""
def data_opetate():
s1 = {10, 20, 'hello'}
s2 = {40, 10, 20, 30}
print('方式一:s1和s2交集:',s1.intersection(s2)) # 交集
print('方式二:s1和s2交集:',s1 & s2)
print('方式一:s1和s2并集:',s1.union(s2)) # 并集
print('方式二:s1和s2并集:',s1 | s2)
print('方式一:s1减去[s1和s2的交集]:',s1.difference(s2)) # 差集
print('方式一:s2减去[s1和s2的交集]:',s2.difference(s1))
print('方式二:s1减去[s1和s2的交集]:', s1 - s2)
print('方式二:s2减去[s1和s2的交集]:', s2 - s1)
print('s1和s2的并集减去s1和s2的交集:',s1.symmetric_difference(s2)) # 对称差集
# 5. 集合生成式
def create_set():
s = { i for i in range(6)}
print(s,type(s))
if __name__ == '__main__':
create_set()
2.列表
# Author : zzd
# Date : 2016/2/3 14:04
"""
列表:
变量 可以存储一个元素,
而列表是一个”大容器“可以存储N多个元素,
程序可以方便的对这些数据进行整体操作
列表相当于其他语言中的数组
特点:
列表元素按顺序有序排序
索引映射唯一一个数据
列表可以存储重复数据
任意数据类型混存
根据需要动态分配和回收内存
"""
def test():
lst = [98,98.8,'hello']
print(lst,id(lst))
print(lst,type(lst))
print(lst)
lst2 = list(lst)
print(lst2,type(lst2))
print(lst[0])
print(lst2[0])
'''
元素位置索引
索引:
正向 0 到 N
逆向 -N 到 -1
'''
def index_test():
lst = [98, 98.8, 'hello']
print(lst.index(98))
print(lst.index('hello',1,3))
"""
切片:
获取列表中多个元素
切片的结果->原列表片段的拷贝
切片的范围->
"""
def split_test():
lst = [10,20,30,40,50,60,70]
print('原列表:',lst)
print('起始位2,结束为6,步长为1:',lst[2:6:1])
print('不设起始,结束为6,步长为2:',lst[:6:2])
print('起始为2,不设结束,步长为1:',lst[2::1])
print('不设起始,不设结束,步长为1',lst[::1])
print('不设起始,不设结束,步长为-1,类似反转',lst[::-1])
"""
判断元素在列表中是否存在:
in
not in
"""
def exists_test():
lst = ['yyds','python','java']
print('yyds' in lst)
print('zxy' not in lst)
"""
列表元素的遍历
"""
def list_test():
lst = ['yyds', 'python', 'java']
for ls in lst:
print(ls)
"""
列表元素的增加操作
"""
def append_test():
lst = ['yyds', 'python', 'java']
lst2 = ['a','b','c']
lst3 = [1,2,3]
print('原数据',lst)
lst.append('zxy')
print('append追加后:',lst)
lst.extend(lst2)
print('extend追加多个元素:',lst)
lst.insert(0,666)
print('insert在索引为0的位置添加666:',lst)
lst[1:]=lst3
print('切片替换,从下标1开始的所有元素替换为lst3',lst)
def remove_test():
lst = ['yyds', 'python', 'java','scala','html']
print('原数据:',lst)
lst.remove("yyds") # 从列表中移除一个元素,如果有重复元素,只移除第一个元素
print('删除lst中指定元素',lst)
lst.pop(0) # 通过指定索引,删除元素,如果不指定索引,则删除最后一个元素
print('删除索引为0的数据:',lst)
new_list = lst[1:3]
print('切片删除,只留下索引1到3的数据,会产生新的列表对象:',new_list)
lst[0:1] = []
print('将列表中索引0到1的位置置空,相当于删除:',lst)
"""
修改列表元素
"""
def modify_test():
lst = ['yyds', 'python', 'java', 'scala', 'html']
print('原数据:', lst)
lst[0] = 'bigdata'
print('指定下标修改:',lst)
lst[2:4] = [100,200,300,400]
print('切片修改:',lst)
"""
排序查询
"""
def sort_test():
lst = [40,10,30,90,100]
print('原数据:',lst)
lst.sort()
print('不指定排序方式,默认升序排序:',lst)
lst.sort(reverse=False)
print('指定升序排序:', lst)
lst.sort(reverse=True)
print('指定降序排序:',lst)
print('-------------------sorted()跟sort()的区别是,sort()是在原有list基础上排序,sorted()是生成新的列表-------------')
lst = [40, 10, 30, 90, 100]
print('原数据:', lst)
new_list = sorted(lst)
print('默认升序排序:',new_list)
desc_list = sorted(lst,reverse=True)
print('指定降序排序:',desc_list)
"""
列表生成式
"""
def create_test():
lst = [i for i in range(1,10)]
print(lst)
if __name__ == '__main__':
create_test()
3.元组
# Author : zzd
# Date : 2016/2/3 21:52
# 元组
"""
什么是元组?
Python 内置的数据结构之以,是一个不可变序列
不可变序列与可变序列
不可变序列:字符串、元组
不可变序列没有增、删、改的操作
可变序列:列表、字典
可变序列:可以对序列执行增、删、改操作,对象地址不发生改变
"""
# 1.元组的创建
"""
1.1 直接小括号
t = ('python','java')
1.2 使用内置函数tuple()
t = tuple(('python','java'))
1.3 只包含一个元组的元素需要使用逗号和小括号
t = (10,)
"""
def create_tuple():
# 空列表创建
lst = []
lst = list()
# 空字典创建
dic = {}
dic = dict()
# 空元组创建
tup = ()
tup = tuple()
t = ('python','java')
print(t,type(t))
t = tuple(('python', 'java'))
print(t, type(t))
t = (10,)
print(t, type(t))
# 如果不加逗号,会被识别为int类型
t = (10)
print(t, type(t))
# 2.为什么要将元组设计成不可变序列
"""
为什么要将元组设计成不可变序列
在多任务环境下,同时操作对象时不需要加锁
因此,在程序中尽量使用不可变序列
注意事项:
元组中存储的是对象的引用
a) 如果元组中对象本身是不可变对象,则不能再引用其他对象
b) 如果元组中的对象是可变对象,则可变对象的引用不允许改变,但数据可以改变
"""
def test():
tup = (10,['a','b','c'],20)
print(tup,'类型',type(tup)) # 元组类型
print(tup[0],'类型',type(tup[0])) # 元组类型中的不可变对象
print(tup[1],'类型',type(tup[1])) # 元组类型中的可变对象
# tup[1]是list类型,可以增、删、改数据。但是不能将其改为tup[1]=100这种
# 3.元组的遍历
def list_tuple():
print('--------------方式一:索引获取--------------------')
tup = (10, ['a', 'b', 'c'], 20)
print(tup[0])
print(tup[1])
# 但是这样的缺陷是,你要知道总共有多少数据
print('--------------方式二:遍历查询----------------------')
for item in tup:
print(item)
# 主函数
if __name__ == '__main__':
list_tuple()
4.字典
# Author : zzd
# Date : 2016/2/3 16:47
"""
字典:
1.什么是字典
2.字典得原理
3.字典的创建与删除
4.字典的查询操作
5.字典的增删改
6.字典推导式
"""
# 1.什么是字典
"""
以Python内置的数据结构之一,与列表一样是一个可变序列
以键值对的方式存储数据,字典是一个无序的序列
eg: scores = {'张三':100,'李四':99}
字典名:scores
花括号:{}
键:'张三'
值:100
冒号::
逗号:,
"""
# 2.字典原理
"""
字典的实现原理与查字典类似,查字典是先根据部首或拼音查找对应的页码,Python中的字典是根据Key查找Value所在位置
字典元素的位置,不是按照输入的位置,是按照hash函数计算key的得到的
key:不可变的序列
"""
# 3.字典的创建
def create_dict():
list1 = ['张三','李四']
list2 = [100,99]
scores = {'张三':100,'李四':99}
print('字典创建方式一:',scores)
scores = dict(name='张三',age=18)
print('字典创建方式二:',scores)
scores = {list1:list2 for list1,list2 in zip(list1,list2)}
print('字典创建方式三:',scores)
# 4.字典的查询
def get_dict():
scores = {'张三': 100, '李四': 99}
print('-----------------方式一和二的区别主要在于:方式一查找不存在的键会报错,方式二会返回一个None值')
print('查找方式一',scores['张三'])
print('查找方式二',scores.get('张三'))
print('查找方式二,不存在的键:',scores.get('zxy'))
print('查找方式二,不存在的键,修改默认返回值None:',scores.get('zxy',100))
# 5.字典的常用操作
"""
key的判断:in 或者 not in
字典的删除:del scores['张三']
字典的元素新增:scores['zxy']=100
"""
def operate_test():
# 判断是否存在
scores = {'张三': 100, '李四': 99}
print('判断张三是否存在:','张三' in scores)
print('判断张三是否存在:', 'zxy' in scores)
# 删除元素
del scores['张三']
print("删除key='张三':",scores)
# 清空字典
scores.clear()
print('清空数据元素:',scores)
# 新增元素
scores['zxy'] = 100
print("增加key='zxy',value='100",scores)
# 修改元素
scores['zxy'] = 99
print('key是唯一的,如果重复新增,会覆盖原有值:',scores)
# 6.获取字典试图的三种方法
"""
keys() 获取字典中所有key
values() 获取字典中所有value
items() 获取字典中所有key,value
"""
def view_test():
scores = {'张三': 100, '李四': 99}
keys = scores.keys()
print('获取字典的所有key:',keys)
values = scores.values()
print('获取字典的所有value:',values)
print('-----------------将key集合和list集合转成列表-----------------')
print(list(keys),list(values))
items = scores.items()
print('获取字典中的所有key,value',items)
print('--------------------将items转成元组tuple集合--------------')
print(tuple(items))
# 7.循环字典元素
def list_dict():
scores = {'张三': 100, '李四': 99}
for item in scores:
print('key=',item,'value=',scores[item])
print('key=',item,'value=',scores.get(item))
# 8.字典的特点
"""
字典的特点:
字典中所有元素都是一个key-value键值对,key不允许重复,value可以重复
字典中的元素是无序的
字典中的key必须是不可变对象
字典也可以根据需要动态的伸缩
字典会浪费较大的内存,是一种使用空间换时间的数据结构 *********************
"""
# 9.字典生成式
"""
内置函数zip()
用于将可迭代的对象作为参数,将对象中对应的元素打包成一个元组,
然后返回由这些元组组成的列表
"""
def zip_dict():
lst1 = ['张三','李四','王五']
lst2 = [100,20,50]
# 使用zip将两个列表,压缩成一个元组组成的列表
dic1 = zip(lst1,lst2)
print(list(dic1),type(dic1))
# 使用zip元素,将两个元组,组成一个字典
dic2 = {lst1:lst2 for lst1,lst2 in zip(lst1,lst2) }
print(dic2,type(dic2))
# 主函数
if __name__ == '__main__':
zip_dict()
5.生成式
# Author : zzd
# Date : 2016/2/4 10:27
# 列表生成式
list1 = [ i for i in range(6)]
print(list1,type(list1))
# 集合生成式
set1 = { i for i in range(6)}
print(set1,type(set1))
# 字典生成式
k = ['张三','李四']
v = [100,90]
dict1 = {k:v for k,v in zip(k,v)}
print(dict1,type(dict1))
三、总结
共有列表、字典、元组、集合。
列表 []
字典 {key:value}
元组 ()
集合 {}
其中:
列表、字典、集合都是可变的,元组不可变
列表、元组可以有重复,集合不可以重复,字典的key不可以重复,value可以重复
列表、元组是有序的,字典、集合是无序的
1.元组
"""
创建元组:
使用小括号()创建
使用内置函数tuple()创建
元组遍历:
for ... in
不可变序列
"""
2.集合
"""
创建集合
使用花括号{}
内置函数set()
集合生成式
集合遍历
for ... in
新增
add()
update()
删除
remove()
discard()
pop()
clear()
可变序列
"""