​​​​Python基础学习--（5）

一、引言

        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()
可变序列
"""