利用列表实现队列与堆栈的特征,字典内置方法,元组及元组内置方法,集合及集合内置方法,数据类型简单总结

昨日内容回顾

  • 猜年龄游戏

    务必完成
    
  • 整型

    # python中不同数据类型之间无法直接交互
    类型转换
    int()  # 只有纯数字可以
    
    进制转换
    bin()		# 转二进制
    oct()        # 转八进制
    hex()		# 转十六进制
    int(其他进制的字符串类型,原有进制)
    
  • 浮点型

    float()  # 在纯数字基础之上 可以再多一个小数点
    
  • 字符串

    str()  # 可以转换任意类型
    
    1.索引取值
    	索引从0开始  还支持负数  只能取不能改
    2.切片操作
    	起始索引:终止索引:步长	支持负数
    3.移除字符串首尾指定的字符
    	 strip()  # 不写默认移除空格
         lstrip()
         rstrip()
    4.按照指定的字符切割字符串
    	split()  # 指定的字符切割完就没了 结果是一个列表
        	还可以控制切割的次数
        rsplit()
    5.统计字符串字符个数
    	len()  # 空格也算
    6.格式化输出
    	format()
        	{}
            {索引}
            {name}
    7.大小写转换
    	upper()
        lower()
        isupper()
        islower()
        # 图片验证码案例
    8.字符串的替换
    	replace()
        	可以限制替换的个数
    9.统计字符串某个字符出现的次数
    	count()
    10.判断字符串中是否是纯数字
    	isdigit()
        # 猜年龄游戏
    11.首字母全部大写
    	title()
    12.判断是否以什么开头或者结尾
    	startswith()
        endswith()
    13.拼接操作
    	join()  # 一定要是字符串类型
        	跟split一起记
    
  • 列表

    类型转换
    list()  # 能否被for循环的类型都可以转换成列表
    	针对字典需要注意只有key被转换
        
    1.索引取值
    	索引从0开始  还支持负数  只能取不能改
    2.切片操作
    	起始索引:终止索引:步长	支持负数
    3.统计列表中元素的个数
    	len()
    4.增
    	尾部追加
        	append()  # 将括号内的数据当作列表的一个元素
        插入
        	insert()  # 根据索引控制插入位置  
            	将括号内的数据当作列表的一个元素
        扩展列表
        	extend()  # 等价于for循环 + append
            # ps:也可以通过加号做扩展 但是不推荐
    5.删
    	通用删除关键字
        	del 列表[索引]
        remove指名道姓的删
        	remove(元素)
        pop弹出元素
        	先提取出元素 之后删除
    6.改
    	列表[索引] = 新值
    7.排序
    	sort()  # 默认是升序
        	reverse=True  # 添加参数 改为降序
    8.反转
    	reverse()
    9.清空列表
    	clear()
    10.统计列表中某个元素出现的个数
    	count()
    
  • 补充

    前期学习很多内置方法名记不住 
    先借助于pycharm的自动提示 用多了自然就会了
    
    句点符(.)
    	数据类型.自动提示
    
  • 可变类型与不可变类型

    不可变类型
    	整型 浮点型 字符串
    可变类型
    	列表
        # 理解图例
    """
    可变类型
        值改变 内存地址不变
    不可变类型
        值改变 内存地址一定变
    """
    

概念

队列
	先进先出
堆栈
	先进后出
    
需求:使用列表模拟出上述两个概念的特征

今日内容概要

  • 利用列表实现队列与堆栈的特征
  • 字典内置方法
  • 元组及元组内置方法
  • 集合及集合内置方法
  • 数据类型简单总结

今日内容详细

利用列表实现队列与堆栈的特征

队列	先进先出堆栈	先进后出    需求:使用列表模拟出上述两个概念的特征        # 队列  先进先出'''先进去的元素 先出来'''# l = []# # 添加元素# l.append(111)  # l = [111,]# l.append(222)  # l = [111, 222]# l.append(333)  # l = [111, 222, 333]# # 取出元素# print(l.pop(0))  # 111  l = [222, 333]# print(l.pop(0))  # 222  l = [333,]# print(l.pop(0))  # 333  l = []# 堆栈  先进后出'''先进去元素 后出来'''l = []# 添加元素l.append(111)l.append(222)l.append(333)  # l = [111, 222, 333]# 取值print(l.pop())  # 333  l = [111, 222]print(l.pop())  # 222  l = [111,]print(l.pop())  # 111  l = []

字典内置方法

"""大括号括起来 内部可以存放多个元素元素的表现形式是以K:V键值对形式    K是对V的描述性信息 一般都是字符串        K是不可变类型            整型 浮点型 字符串        V可以是任意类型"""# d1 = {#     'username':'jason',#     'password':123,#     'hobby':['read', 'run']# }# print(d1,type(d1))# d2 = {#     1:'jason',#     2:'egon',#     3:'kevin'# }# print(d2,type(d2))# d3 = {#     1.1:'jason',#     2.2:'egon',#     3.3:'kevin'# }# print(d2,type(d2))# # k值只要是不可变类型即可 同一个字典内可以混用# d4 = {#     'username':'jason',#     1:'egon',#     1.1:'kevin'# }# print(d4,type(d4))#作用:存多个值,key-value存取,取值速度快#定义:key必须是不可变类型,value可以是任意类型#优先掌握的操作:#1、按key存取值:可存可取d1 = {    'username':'jason',    'password':123,    'hobby':['read', 'run']}# print(d1['username'])  # jason# print(id(d1))# d1['username'] = 'tony'# print(id(d1))  # {'username': 'tony', 'password': 123, 'hobby': ['read', 'run']}# 字典是可变类型# print(d1['age'])  # 键不存在 直接报错!!!# d1['age'] = 18  # 键存在则修改 不存在则新建# print(d1)  # {'username': 'jason', 'password': 123, 'hobby': ['read', 'run'], 'age': 18}#2、长度len  统计字典中键值对的个数# print(len(d1))  # 3#3、成员运算in和not in# print('jason' in d1)  # False  字典默认只暴露key value不暴露 如果想取 一般只能通过key# print('username' in d1)  # True#4、删除# del d1['password']# print(d1)  # {'username': 'jason', 'hobby': ['read', 'run']}'''字典不能使用索引!!!'''# res = d1.pop('password')# print(d1)  # {'username': 'jason', 'hobby': ['read', 'run']}# print(res)  # 123#5、键keys(),值values(),键值对items()# 将keys()的结果可以直接看成是列表# print(d1.keys())  # 获取字典中所有的key   dict_keys(['username', 'password', 'hobby'])  老母猪# for k in d1.keys():#     print(k)"""python2与python3对比    python3         keys()  dict_keys(['username', 'password', 'hobby'])  老母猪    python2        keys()  ['username', 'password', 'hobby']"""# 将values()的结果可以直接看成是列表# print(d1.values())  # dict_values(['jason', 123, ['read', 'run']])  老母猪"""python2与python3对比    python3         values()  dict_keys(['jason', 123, ['read', 'run']])  老母猪    python2        values()  ['jason', 123, ['read', 'run']]"""# 将items()的结果可以直接看成是列表[]套小列表()# print(d1.items())# for k,v in d1.items():  # 解压赋值 结合 for循环#     print(k,v)"""python2与python3对比    python3         items()  dict_keys([('username', 'jason'), ('password', 123), ('hobby', ['read', 'run'])])  老母猪    python2        items()  [('username', 'jason'), ('password', 123), ('hobby', ['read', 'run'])]"""#6、循环'''字典for循环只能获取到key'''# for i in d1:#     print(i)# dict.get()  # 使用频率最为广泛   通过字典的key获取字典的value# print(d1.get('username'))  # jason# print(d1['username'])  # jason# key不存在# print(d1['age'])  # 直接报错# print(d1.get('age'))  # get方法键不存在也不会报错 返回None(什么都没有)# print(d1.get('username','嘿嘿嘿'))  # jason# print(d1.get('age','嘿嘿嘿'))  # 嘿嘿嘿'''get方法还可以给第二个参数  键存在则不使用 键不存在则返回第二个参数  不写默认返回None'''# 第一种创建字典的方式# d2 = {'k1':'v1','k2':'v2'}  # dict({'k1':'v1','k2':'v2'})# 第二种创建方式# res = dict(name='jason',pwd=123,hobby=['read','run'])# print(res)  # {'name': 'jason', 'pwd': 123, 'hobby': ['read', 'run']}# 第三种创建方式# l = [#     ['username','jason'],#     ['password',123],#     ['hobby',['read','run']]# ]# # d = {}# # for i in l:  # ['username','jason']     ['password',123]   ['hobby',['read','run']]# #     d[i[0]] = i[1]  # d['username'] = 'jason'# # print(d)## # d = {}# # for k,v in l:  # ['username','jason']     ['password',123]   ['hobby',['read','run']]# #     d[k] = v# # print(d)# res = dict(l)# print(res)  # {'username': 'jason', 'password': 123, 'hobby': ['read', 'run']}# dict.clear()  清空# d1.clear()# print(d1)# dict.fromkeys()  快速先生成一个字典# l = ['username','pwd','hobby']# res = dict.fromkeys(l,None)# print(res)# dict.popitem()# res = d1.popitem()  # 随机弹出一组键值对# print(d1)# print(res)  # ('hobby', ['read', 'run'])# dict.setdefault()  重点# dd = {'name':'jason','pwd':123}# dd.setdefault('age',18)  # 键不存在 则新建# res = dd.setdefault('name','egonSBSBSB')  # 键存在不修改 而是获取到键对应的值# print(dd,res)  # {'name': 'jason', 'pwd': 123, 'age': 18} jason# dict.update()# dd = {'name':'jason','pwd':123}# dd.update({'age':18})  # 键不存在 则新建# dd.update({'name':'EGONDSB'})  # 键存在则修改# print(dd)# # 还不如使用下列方式# dd['age'] = 18# dd['name'] = 'jason'

元组

"""小括号括起来 括号内可以存放多个元素元素与元素之间逗号隔开 元素可以是任意类型    元组也可以简单的理解为是列表    元组属于不可变类型"""# t1 = (1,2,3,4,5,6)# print(type(t1))  # tuple# 类型转换 与list一致 支持for循环的都可以# t1 = (1)# print(type(t1))  # int# t2 = ('a')# print(type(t2))  # str# l1 = [1]# print(type(l1))  # list"""元组当内部只有一个元素的时候 逗号不能省略以后只要是容器类型 无论内部有几个元素 都必须要有逗号    尤其是只有一个元素的情况下        (1,)        [1,]        {'username':'jason',}"""#作用:存多个值,对比列表来说,元组不可变(是可以当做字典的key的),主要是用来读#定义:与列表类型比,只不过[]换成()#优先掌握的操作:#1、按索引取值(正向取+反向取):只能取# t1 = (11,22,33)# t1[0] = 666# print(t1)"""笔试题    元组内元素的内存地址不能修改    但是如果元素是可变类型 那么元素值可以改"""# t2 = (11,22,[11,22])# t2[2].append(33)# # 问:上述代码执行的结果是什么# print(t2)  # (11, 22, [11, 22, 33])#2、切片(顾头不顾尾,步长)# 与字符串 列表一致#3、长度# len()#4、成员运算in和not in# 与列表一致#5、循环# for i in (11,22,33):#     print(i)

集合

"""大括号括起来 内部可以存放多个元素元素与元素之间逗号隔开(不是k:v键值对)  元素只能是不可变类型(整型 浮点型 字符串 元组)    s = {1,2,3,4}    只有两种情况才会考虑使用集合        1.关系运算            两个群体之间判断 交叉并集                共同好友 共同关注 共同点赞...        2.去重操作            去除重复的元素"""# se = {1,2,3,4,5}  # set(1,2,3,4,5)# print(type(se))  # set# d1 = {}# s1 = {}# print(type(d1),type(s1))  # <class 'dict'> <class 'dict'># """定义空集合 需要使用关键字set"""# ss = set()# print(ss,type(ss))  # set# s = {11,1.1,'hello',(1,2,3)}# 2.去重操作l = [11,22,33,22,11,44,33,22,55,66,66,66]# for循环一个个元素 判断当前元素是否已存在# new_l = []# for i in l:#     if i not in new_l:#         new_l.append(i)# print(new_l)  # [11, 22, 33, 44, 55, 66]# 将列表转换成集合# res = set(l)# print(res)# '''集合内默认不能出现重复的元素 如果出现了会自动去重'''# r1 = {11,22,22,22,11,44,44,44}# print(r1)# 关系运算f1 = {'jason','egon','kevin','tony'}f2 = {'jason','jack','oscar','kevin'}# 共同好友print(f1 & f2)  # {'jason', 'kevin'}# f1独有的好友print(f1 - f2)  # {'tony', 'egon'}# f2独有的好友print(f2 - f1)  # {'oscar', 'jack'}# 所有的好友print(f1 | f2)  # {'jason', 'oscar', 'egon', 'tony', 'kevin', 'jack'}# 求各自好友 不包含共有的print(f1 ^ f2)  # {'jack', 'oscar', 'tony', 'egon'}# 父集 子集"""父级:A包含B 那么A就是B的父级子级:A包含B 那么B就是A的子级"""s1 = {1,2,3,4,5}s2 = {1,2,3}print(s1 > s2)  # Trueprint(s1 < s2)  # False

作业

1.整理今日内容至自己博客2.字典练习题    1.将列表中大于等于66的元素放入字典k1键对应的列表中    	将列表中小于66的元素放入字典k2键对应的列表中        nums=[11,22,33,44,55,66,77,88,99,90]        dic={            'k1':[],            'k2':[]        }    2.s='hello jason jason say hello sb sb sb'		统计字符串中每个单词出现的次数        	{'jason':2,...}3.集合练习题	 一.关系运算      有如下两个集合,pythons是报名python课程的学员名字集合,linuxs是报名linux课程的学员名字集合      pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}      linuxs={'wupeiqi','oldboy','gangdan'}      1. 求出即报名python又报名linux课程的学员名字集合      2. 求出所有报名的学生名字集合      3. 求出只报名python课程的学员名字      4. 求出没有同时这两门课程的学员名字集合      二 去重并且保留原来的顺序    	l = [11,22,33,22,22,33,11,22,55,66,66,77,77]        1.去重不保留顺序        2.去重并且保留顺序
posted @ 2021-06-03 21:00  余昆  阅读(79)  评论(0)    收藏  举报