Python第四天（从入门到精通）

最新推荐文章于 2024-05-27 17:00:50 发布
最新推荐文章于 2024-05-27 17:00:50 发布
阅读量695 收藏 12
点赞数 11
分类专栏： # Python 文章标签： python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l5261_1625/article/details/138846428
版权

文章目录

Python第4天

Python容器的分类

字符串
列表
元组
字典
集合

容器-字符串

基本操作

  • 定义

    name1 = 'Tom'    #该方式内部不能再包含单引号
name2 = "Rose"   #该方式内部可以包含单引号
str1 = '''I am Tom, 
        nice to meet you! '''  #该方式内部可以包含单引号

str2 = """ I am Rose, 
        nice to meet you! """  #该方式内部可以包含单引号

  • 下标/索引的概念

    在这里插入图片描述

    1、将字符串存入内存中，这些字符串的每个字符是连续存放的，是挨着的
2、为了更加方便的去访问字符串中的每一个字符，python将每一个字符都进行了编号，编号从0开始
3、字符串中每个字符的编号被称为下标，索引，或者角标
4、之所以设计索引或者角标是为了以后能够快速的找到某个字符
5、如果一个字符串长度是n，则下标的范围是：0 到 n- 1
6、最后一个元素的索引也可以-1

  • 代码1-访问每个元素

    name = 'abcde'

print('------------使用下标访问---------------')
print(name[0])
print(name[1])
print(name[2])
print(name[3])
print(name[4])


print('------------使用for访问每个元素---------------')
for x in name:
    print(x)

print('------------使用for访问下标获取元素---------------')
for i in range(0,5):  # i是数字，当做索引
    print(name[i])

print('------------使用for访问下标获取元素2---------------')
for i in range(0, len(name)):  # 通过len获取字符串的长度，也就是字符串中字符的个数
    print(name[i])

切片

  • 格式

    #包含起始索引，不包含结束索引， 步长表示一次跳几个字符，如果步长为1表示一个一个截取，如果步长为2则就是一次跳过一个
字符串[起始索引:结束索引:步长]    #步长不写的话，默认就是1

  • 代码1

    card_id = '430421200112236789'

#截取出生年份
print(card_id[6:10:1])


name = 'abcdefghijk'
print(name[2:5:1]) # cde
print(name[2:5])   # cde  步长默认是1
print(name[2:7:2]) # ceg

print(name[:7:1])  # abcdefg  起始索引不写表示从0开始
print(name[2::])  # cdefghijk  结束索引不写，表示截取到最后
print(name[2:])  # cdefghijk  结束索引不写，步长不写，表示截取到最后

print(name[:-1])  # abcdefghij从开头截取到倒数第二个（-1表示倒数第一个）
print(name[:-3])  # abcdefgh 从开头截取到倒数第四个（-3表示倒数第三个）
print(name[-6:-3])  # fgh 从倒数第六个截取到倒数第四个

print(name[::-1])  #  kjihgfedcba 如果步长为-1，则将字符串翻转
print('-----------')
print(name[8:2:-1])  # ihgfed 从索引为8的字符开始截取到索引为3(不包含2)
print(name[8:2:-2])  # ige 将最后一个元素当做索引为0的元素，从右向左开始输出


file1 = 'ldlkdkl.txt'
file2 = 'a.py'

#判断文件是否是txt结尾
if file1[-3:] == 'txt':
    print('文件是txt')

  • 代码2

    s = 'Hello World!'

print(s[4])  # o 通过索引访问
print(s)     #  Hello World!
print(s[:])  #  Hello World!
print(s[1:]) #  ello World!
print(s[:5]) #  Hello
print(s[:-1]) # Hello World
print(s[-4:-1]) # rld
print(s[1:5:2]) #  el

方法

find方法

  • 特点

     #在大串中查找是否包含某个子串，可以指定查找的区间，这个区间是包头不包尾
 #查到之后会返回该子串在大串中第一次出现的索引，如果没有找到则返回-1
字符串序列.find(子串, 开始位置下标, 结束位置下标)

  • 操作

    mystr = "abchelloworldandhellopythonhelloaaa"

rs1 = mystr.find('hello')  #在整个字符串中查找hello第一次出现的索引
print(rs1)

rs2 = mystr.find('hello',2,7)  #在索引为 2 - 6 之间查找是否包含hello,注意不包含索引7
print(rs2)

rs2 = mystr.find('hello',5)  #在索引为 2 -最后 之间查找是否包含hello,注意不包含索引7
print(rs2)
index方法

  • 特点

    #作用和find相同，只是如果没有找到子串，则报错
字符串序列.index(子串, 开始位置下标, 结束位置下标)

  • 操作

    print('------------index--------------')

rs1 = mystr.index('hello')  #在整个字符串中查找hello第一次出现的索引
print(rs1)

rs2 = mystr.index('hello',2,7)  #在索引为 2 - 6 之间查找是否包含hello,注意不包含索引7
print(rs2)
replace方法

  • 特点

    字符串序列.replace(旧子串, 新子串, 替换次数)

#1、功能是将字符串中的旧字符串替换为新字符串，默认是全部替换
#2、如果你指定了替换次数n，则会替换前n个子串
#3、替换之后，原来的字符串并没有发生变化，会发生新的字符串

  • 操作

    print('------------replace--------------')


str1 = '你好，我是写作小帮，有任何写作的问题，都可以向我提问，我们一起提高写作能力。'
print(str1)

str2 = str1.replace('写作','编程')  # 全部替换
print(str2)

str3 = str1.replace('写作','编程',2) # 替换前2个

print('------------先查找再替换--------------')
str1 = '你好，我是写作小帮，有任何写作的问题，都可以向我提问，我们一起提高写作能力'

rs1 = str1.find('写作')  #先查找
if rs1 != -1:
    str2 = str1.replace('写作','写代码')
    print('替换后的字符串:'+str2)
else:
    print('没有找到你要替换的内容')
split方法

  • 特点

    字符串序列.split(分割字符, num)
#1、功能是对字符串按照分隔符进行切割，默认是全部切割，指定num参数之后，可以切割前num次
#2、切割之后原字符串不变，返回切割后的内容
#3、split切割时，如果不指定分隔符，默认的分隔符是一切的空白符：一个空格，多个空格，\n、 \t

  • 操作

    print('------------split--------------')

str1 = '2024-12-24'

print(str1.split('-'))
print(str1.split('-',1))


str1 = '2024/12/24'
print(str1.split('/'))

print('-----------------------')
str1 = '2024                    12           24'
print(str1.split(' '))       # 只能切一个空格
print(re.split(' +',str1))   # 正则表达式，+表示一个空格或者多个空格都能切

endswith和startswith方法

  • 特点

    endswith:以什么结尾     字符串.endswith(子串)
startswith：以什么开头  字符串.startswith(子串)

  • 操作

print('--------------------------')
str_file = 'abc.png.txt'

# 该方法用来判断是否以某个字符串结尾
# 如果匹配成功则返回True，否则返回False
rs1 = str_file.endswith('.png')
if rs1:
    print('该文件是以.png结尾')
else:
    print('该文件不是以.png结尾')
    
    
print('--------------------------')
str1 = 'helloworldpython'
str1.endswith()
if str1.startswith('hello'):
    print('字符串以hello开头')
else:
    print('字符串不以hello开头')

练习

# 练习题1：输入一个字符串，打印所有偶数位上的字符(下标是0，2，4，6…位上的字符)
str1 = input('请输入一个字符串:') #abcdefghijk
print(str1[::2])

print('-----------------------------')
for  i in range(0, len(str1)):
    if i % 2 == 0:
        print(str1[i])

print('-----------------------------')
# 练习题2：给定一个文件名，判断其尾部是否以".png"结尾
str_file = 'abc.png.txt'
if str_file[-4:] == '.png':
    print('该文件是以.png结尾')
else:
    print('该文件不是以.png结尾')

print('--------------------------')

str_file = 'abc.png.txt'
rs1 = str_file.find('.png',-4)  #表示从倒数第4个开始查到最后，看是否包含.png
if rs1 != -1:
    print('该文件是以.png结尾')
else:
    print('该文件不是以.png结尾')


print('--------------------------')
str_file = 'abc.png.txt'

# 该方法用来判断是否以某个字符串结尾
# 如果匹配成功则返回True，否则返回False
rs1 = str_file.endswith('.png')
if rs1:
    print('该文件是以.png结尾')
else:
    print('该文件不是以.png结尾')

容器-列表

语法

列表名称 = [数据1, 数据2, 数据3, 数据4, ...]
解释：
 列表名称: list1、list2、list_student...
 列表的标记符号是中括号
 列表中可以同时存放任何类型的数据
    
    
#列表是可变的，也就是列表中的数据是可以被修改的

操作

定义列表
# 1、定义一个空列表
#空列表必须有[]
list1 = []
print(list1)

# 2、定义一个有内容列表,类型一致
#如果列表中只存放一个类型的数据，则类似其他语言的数组
list2 = ['刘备', '关羽', '张飞']
print(list2)

# 3、定义一个有内容列表,类型不一致
list3 = ['刘备', 32, False, 120.5]
print(list3)

# 4、定义一个嵌套列表
#List列表和其他容器包括自己可以无限的嵌套
list4 = [['刘备', 32, False, 120.5],['关羽', 33, True, 130.5]]

下标/索引

  • 概念

    列表的底层存储形式和字符串都是一样的，其也是通过索引下标来对其进行引用的
list1 = ['刘备', '关羽', '张飞', '赵云', '张飞']
正索引: 0 1 2 3 4 
负索引: -1 -2 -3 -4

    在这里插入图片描述

  • 操作

    # 1、定义列表
list1 = ['刘备', '关羽', '张飞', '赵云', '张飞']

# 2、使用索引来访问
"""
正索引: 0 1 2 3 4 
负索引: -1 -2 -3 -4 
"""
# 列表的名字[下标]
print(list1[0])   # 访问第一个元素
print(list1[4])   # 访问最后一个元素
print(list1[-1])  # 访问最后一个元素 使用 -1

print('---------------------------')
# 3、使用for来遍历列表
# for会将列表中的每一个元素依次的给x
for x in list1:
    print(x)

列表的遍历

  • 概念

    1、遍历就是将列表中的元素一个个的输出

  • 代码

    # 1、定义列表
list1 = ['刘备', '关羽', '张飞', '赵云', '张飞']

print('------------for遍历-1---------------')
# 2、使用for来遍历列表
# for会将列表中的每一个元素依次的给x
for x in list1:  #x是每一个元素数据，不是索引
    print(x)

print('------------for遍历-2---------------')
for i in range(0, len(list1)):  #i是每一个的索引
    print(list1[i])


print('------------while遍历---------------')
# while遍历可以直接访问到列表中每一个索引
i = 0
while i < len(list1):  # 0 1 2 3 4
    print(list1[i])
    i += 1

列表的切片

  • 介绍

    1、列表的切片规则和字符串是一样的
2、截取之后原来的列表不会发生变化，我们可以把截取后的列表存入一个新列表中，方便后期计算

  • 操作

    
list_name = ['刘备', '关羽', '张飞', '赵云', '郭嘉','曹操','孙权','徐晃','典韦','黄忠']

list_name2 = list_name[2:5:1]  # 我们可以把截取后的列表存入一个新列表中，方便后期计算

print(list_name[2:5:1]) # ['张飞', '赵云', '郭嘉']
print(list_name[2:5])   # ['张飞', '赵云', '郭嘉']
print(list_name[2:7:2]) # ['张飞', '郭嘉','孙权']
print(list_name[:7:1])  # ['刘备', '关羽', '张飞', '赵云', '郭嘉', '曹操', '孙权']
print(list_name[2::])   # ['张飞', '赵云', '郭嘉', '曹操', '孙权', '徐晃', '典韦', '黄忠']
print(list_name[2:])    # ['张飞', '赵云', '郭嘉', '曹操', '孙权', '徐晃', '典韦', '黄忠']
print(list_name[:-1])   # ['刘备', '关羽', '张飞', '赵云', '郭嘉', '曹操', '孙权', '徐晃', '典韦']
print(list_name[:-3])   # 从头到倒数第4个 ['刘备', '关羽', '张飞', '赵云', '郭嘉', '曹操', '孙权']
print(list_name[-6:-3]) # 倒数第6个到倒数第4个   ['郭嘉', '曹操', '孙权']
print(list_name[::-1])  # 倒叙 ['黄忠', '典韦', '徐晃', '孙权', '曹操', '郭嘉', '赵云', '张飞', '关羽', '刘备']
print(list_name[:-3:-1])  # 倒叙 ['黄忠', '典韦', '徐晃', '孙权', '曹操', '郭嘉', '赵云', '张飞', '关羽', '刘备']


print(list_name)

列表的操作-添加

  • 方法

    添加元素  ("增"append, extend, insert)

#1、append方法
语法: 列表.append(新的元素) 
 #1.1每次将新的元素追加到原来列表的后边
 #1.2如果添加一个列表，则会将改列表当做一个整体添加

#2、extend方法
语法: 列表.extend(新的元素) 
  #2.1 每次将新的元素追加到原来列表的后边，但是会把任何添加的内容当做一个容器，如果数据是一个序列，则将这个序列的数据逐一添加到列表
  #2.2 该方法可以将两个列表进行合并
  
  
#3、insert方法
语法：列表.insert(索引，新数据)
  #3.1 insert和append、extend不同，insert可以指定添加到列表中的任意位置
  #3.3 insert添加时，添加位置的元素及后边的元素依次向后移，空出一个空位进行添加

    在这里插入图片描述

  • 操作

    print('---------------append------------------')
# 1、定义列表
list1 = ['刘备', '关羽', '张飞', '赵云', '张飞']


# 2、向列表中追加元素: 曹操
list1.append('曹操')  #已经修改了原来的列表  ['刘备', '关羽', '张飞', '赵云', '张飞'，’曹操‘]
list1.append('孙权')  #已经修改了原来的列表
list1.append(18)  #添加其他类型，已经修改了原来的列表
list1.append(['周瑜','大乔'])  #这种添加会将小列表整体进行添加：['刘备', '关羽', '张飞', '赵云', '张飞', '曹操', '孙权', ['周瑜', '周瑜']]
list1.extend(['诸葛亮','吕布'])  #这种添加会将小列表整体进行添加：['刘备', '关羽', '张飞', '赵云', '张飞', '曹操', '孙权', ['周瑜', '大乔'], '诸葛亮', '吕布']
print(list1)


print('---------------extend------------------')

# 1、定义列表
list1 = ['刘备', '关羽', '张飞', '赵云', '张飞']

# 2、使用extend进行添加
list1.extend('小乔') #['刘备', '关羽', '张飞', '赵云', '张飞', '小', '乔'] 此时，会将小乔当做一个容器，进行拆分，将拆分后的 小  和 乔 分别进行添加
list1.extend(['小乔']) #['刘备', '关羽', '张飞', '赵云', '张飞', '小', '乔','小乔'] 此时，会将小乔当做一个容器，进行拆分，将拆分后的 小  和 乔 分别进行添加

print(list1)

print('---------------extend-列表合并------------------')

list1 = ['刘备', '关羽', '张飞', '赵云']
list2 = ['曹操', '郭嘉', '典韦', '徐晃']

list1.extend(list2)  #['刘备', '关羽', '张飞', '赵云', '曹操', '郭嘉', '典韦', '徐晃']

print(list1)
print(list2)


print('---------------insert------------------')

# 1、定义列表
list1 = ['刘备', '关羽', '张飞', '赵云']

#2、在索引为1的位置添加 曹操
list1.insert(1,'曹操')  # ['刘备', '曹操', '关羽', '张飞', '赵云']
print(list1)

list1.insert(1,['曹操','孙权']) # ['刘备', ['曹操', '孙权'], '曹操', '关羽', '张飞', '赵云']
print(list1)

#如果要添加的索引值超过了列表的最大索引，则会将数据添加到最后
list1.insert(100,'刘协') # ['刘备', ['曹操', '孙权'], '曹操', '关羽', '张飞', '赵云', '刘协']
print(list1)

列表的操作-查找

在这里插入图片描述

index

  • 语法

    语法：列表序列.index(数据, 开始位置下标, 结束位置下标)

解释：
 数据：是要查找的内容
 开始位置下标, 结束位置下标：要查找的区间索引，包头不包尾

  • 代码

    print('---------------index------------------')
# 1、定义列表
list1 = ['刘备', '关羽', '张飞',['孙权','黄盖'], '赵云','曹操', '郭嘉', '典韦', '徐晃']

"""
语法：列表序列.index(数据, 开始位置下标, 结束位置下标)
"""

# 2、查看列表中是否有赵云
rs1 = list1.index('赵云')  # 如果找到返回第一个索引值，找不到则报错
print(rs1)

# 3、查看列表中是否有孙权
rs1 = list1.index('孙权')  # 找不到，因为index只能看到['孙权','黄盖']这个子列表整体，看不到里边的内容
print(rs1)

# 3、查看列表中是否有['孙权','黄盖']
rs1 = list1.index(['孙权','黄盖'])  # 可以找到
print(rs1)
count

  • 语法

    #count()方法：统计指定数据在当前列表中出现的次数
列表序列.count(数据)

#解释：
  数据：你要统计的内容
  该方法返回统计的次数

  • 代码

    print('---------------count------------------')

list1 = ['刘备', '关羽', '张飞',['孙权','黄盖','张飞'], '赵云','曹操', '郭嘉', '典韦','张飞', '徐晃']

# 统计list1列表中有几个张飞
print(list1.count('张飞'))    # 2 次
in和not in

  • 语法

    数据 in  列表  #判断数据是否在列表中，如果是返回True，否则返回False
数据 not in  列表  #判断数据是否不在列表中，如果是返回True，否则返回False

  • 代码

    print('---------------in和not ------------------')
list1 = ['刘备', '关羽', '张飞',['孙权','黄盖','张飞'], '赵云','曹操2', '郭嘉', '典韦','张飞', '徐晃']
list2 = ['刘备', '关羽', '张飞',['孙权','黄盖','张飞'], '赵云','曹操', '郭嘉', '典韦','张飞', '徐晃']

#判断曹操是否在list1中
print('曹操' in list1)  # list1.in('曹操')
#判断曹操是否不在list1中
print('曹操' not in list1)


if '曹操' in list1 and 3 >2:
    print('曹操在列表中')
else:
    print('曹操不在列表中')

列表的操作-删除

在这里插入图片描述

del：一般知道要删除的数据索引，用该方法 ，销毁列表，也可以该方法
pop：一般删除最后一个元素，用该方法, 或者知道索引，也可以用该方法
remove： 知道要删除数据的内容，用该方法
clear： 清空表内容，用该方法
del方法

  • 语法

    del 列表[要删除的数据索引] # 将索引对应元素的数据删除
del 列表  # 将整个列表销毁,列表不存在

  • 操作

    print('---------------del------------------')
# 1、定义列表
list1 = ['刘备', '关羽', '张飞',['孙权','黄盖'], '赵云','曹操', '郭嘉', '典韦', '徐晃']

# 2、在list1列表删除典韦
del list1[-2]  # 删除list1中索引为1位元素
# del list1[100]  # 索引下标越界
print(list1)

# 3、在list1列表删除内嵌的列表：['孙权','黄盖']
del list1[3]
print(list1)

print('-----------')
# 4、将整个列表销毁
del list1
print(list1)  # 报错，因为列表已经被删除
pop方法

  • 语法

    列表序列.pop()    # 弹出列表最后一个数据，并返回
列表序列.pop(下标) # 弹出（获取）指定索引的数据，并将数据返回

#pop其实是弹栈或者出栈，是一种先进后出的数据结构

  • 代码

    print('---------------pop------------------')
"""
列表.pop(索引)
"""
# 1、定义列表
list1 = ['刘备', '关羽', '张飞',['孙权','黄盖'], '赵云','曹操', '郭嘉', '典韦', '徐晃']

print(list1.pop())   #  取出最后一个元素，并返回 ，原列表会被修改
print(list1.pop(1))  #  取出索引为1元素, 并返回 ，原列表会被修改

print(list1)  # 原列表少了被取出的元素
remove方法

  • 语法

    列表.remove(要删除的数据) # 在列表中删除指定的数据，但是只能删除第一次遇到的数据

  • 代码

    print('---------------remove------------------')
"""
列表.remove(要删除的数据)
该方法没有返回值
"""
# 1、定义列表
list1 = ['刘备', '关羽', '张飞',['孙权','黄盖'], '赵云','曹操', '郭嘉', '关羽', '徐晃']
print(list1)

# 2、在list1列表中删除关羽
list1.remove('关羽')
print(list1)

# 3、在list1列表中删除 ['孙权','黄盖']
list1.remove(['孙权','黄盖'])
print(list1)

# 4、删除一个不存在的元素
if '诸葛亮' in list1:  # 判断 诸葛亮是否存在，如果存在则删除，否则不存在，删除则报错
    list1.remove('诸葛亮')
clear方法

  • 语法

    列表.clear()  #将列表的内容清空，留下空列表 []

  • 代码

    print('---------------remove------------------')
"""
列表.clear()
"""
# 1、定义列表
list1 = ['刘备', '关羽', '张飞',['孙权','黄盖'], '赵云','曹操', '郭嘉', '关羽', '徐晃']

# 2、清空list1列表
list1.clear()
print(list1)

列表的操作-修改

修改操作

  • 语法

    列表[索引] = 新值 #将指定索引的值修改为新值


列表序列.reverse()：将字符串翻转


列表序列.sort(  reverse=False)
注意：reverse表示排序规则，reverse = True降序， reverse = False升序（默认)

  • 代码

    print('-----------------根据索引修改---------------------')
# 1、定义列表
list1 = ['刘备', '关羽', '张飞',['孙权','黄盖'], '赵云','曹操', '郭嘉', '典韦', '徐晃']
print(list1)

# 2、将张飞修改为张苞
list1[2] = '张苞'
print(list1)

# 3、将['孙权','黄盖'] 改为 ['孙坚','黄盖']

list1[3] = ['孙坚','黄盖']
print(list1)

print('-----------------反转---------------------')
"""
列表名.reverse()
"""

# 1、定义列表
list1 = ['刘备', '关羽', '张飞',['孙权','黄盖'], '赵云','曹操', '郭嘉', '典韦', '徐晃']
print(list1)

# 2、对以上列表进行翻转
list1.reverse()
print(list1)

print('--------------------------------------')
"""
列表序列.sort(reverse=False)
注意：reverse表示排序规则，reverse = True降序， reverse = False升序（默认）
      列表中一般是数字和字母
"""
# 1、定义列表
list1 = [34,524,56,77,12,66,22]
print(list1)

# 2、对列表进行排序-升序
list1.sort()  # 默认是升序
print(list1)

list1.sort(reverse=False)  # 指定升序
print(list1)

# 3、对列表进行排序-降序
list1.sort(reverse=True)  # 指定降序序
print(list1)

# 4、对有英文字母的列表进行排序-升序
# 如果是英文排序，则按照单词在字典中出现的先后顺序来排
# 两个单词如果前边一样一样，哪个短，哪个在前边
list1 = ['student','hello','123','zero','aba','door','23','about','teachr','female','abandon']
list1.sort(reverse=False)  # 指定升序
print(list1)

列表的嵌套

  • 概念

    列表的嵌套可以理解为一个大列表中嵌套了小列表

  • 代码

    list1 = [
    ['刘备','关羽','张飞'], # 这个小列表名字是：list1[0]
    ['宝玉','黛玉','宝钗'], # 这个小列表名字是：list1[1]
    ['宋江','智深','武松','门庆'], # 这个小列表名字是list1[2]
    ['悟空','悟净','悟能']  # 这个小列表名字是：list1[3]
]

# 访问智深
print(list1[2][1])

# 将 悟净 修改为 八戒
list1[3][1] = '八戒'
print(list1)

print('---------------对嵌套的列表进行遍历-----------------------')

for x in list1: # x是大列表中包含的每一个小列表 ['刘备','关羽','张飞']
    for name in  x: # name是小列表中每一个元素
        print(name)


print('--------------------------------------')


list1 = [
    ['刘备',['关羽','诸葛'],'张飞'], # list1[0]
    ['宝玉','黛玉','宝钗'], # list1[1]
    ['宋江','智深','武松','门庆'], # list1[2]
    ['悟空','悟净','悟能']  # list1[3]
]

#访问 诸葛
print(list1[0][1][1])

容器-元组

概念

1、在python中列表的内容是可以修改的   list1 =  [1,2,3]
2、在python中元组的内容不可修改      tuple1 = (1,2,3)
3、在python中元组的关键字是：tuple

元组的定义

元组的名字 = (元素值1,元素值2...)

# 1、定义元组
t1  = (10,20,30)
t2  = ('刘备',20,True)

# 2、定义空元组
t3 = ()
t4 = tuple() #醒目

# 3、定义只有一个元素的元组
t5 = (10)  # 这个不是元组，是int类型
print(type(t5))  # <class 'int'>

t6 = (10,) # 这个是元组,必须加,
print(type(t6))  # <class 'tuple'>

元组的操作-索引访问

在这里插入图片描述

如果元组嵌套列表，则小列表中的内容可以修改，但是该列表的整体不可以修改

# 1、定义元组
#列表和元组之间可以无限的嵌套
t1 = ('刘备',['孙权','黄盖','陆逊','吕蒙'], '关羽',(1,2,3) ,'张飞', '赵云','曹操', '郭嘉', '典韦', '徐晃')

# 2、根据索引来查找 关羽
print(t1[2])
# 3、根据索引来查找 陆逊
print(t1[1][2])

# 4、尝试去将刘备修改为刘禅
t1[0] = '刘禅'   #不支持 报错

# 5、尝试去将孙权修改为孙坚
t1[1][0] = '孙坚' # 支持 可以修改
print(t1)

# 6、尝试去将索引为1的列表改为其他列表
t1[1] = ['司马懿','司马昭']  #不支持 报错
print(t1)

# 7、元组切片
# 元组的切片和列表相同
t1 = ('刘备','张飞', '赵云','曹操', '郭嘉', '典韦', '徐晃')

print(t1[2:5:1])     # ('赵云', '曹操', '郭嘉')
print(t1[-2:-5:-1])  # ('典韦', '郭嘉', '曹操')

# 1、定义元组
t1 = ('刘备','张飞', '赵云','曹操', '郭嘉', '典韦', '徐晃','曹操','曹操')

# 2、在列表中查找曹操，并返回第一次出现对应的索引,找不到就报错
print(t1.index('曹操'))

# 3、统计曹操在元组中出现的次数
print(t1.count('曹操'))

# 4、统计元组的长度
print(len(t1))

print('-----------字符串-------------')
str1 = "hello"
str2 = "world"

# 拼接字符串
print(str1 + str2)
# 将字符串进行复制10份
print(str1 * 10)

print('-----------列表-------------')

list1 =  ['刘备', '关羽', '张飞']
list2 =  ['曹操', '郭嘉', '典韦']

# 拼接列表
list3 = list1 + list2
print(list1 + list2)

# 将列表进行复制10份
print(list1 * 10)


print('-----------元组-------------')

t1 = ('刘备', '关羽', '张飞')
t2 = ('曹操', '郭嘉', '典韦')

# 拼接元组
t3 = t1 + t2
print(t1 + t2)

# 将元组进行复制10份
t4 = t1 * 10
print(t1 * 10)

容器-字典

概念

在这里插入图片描述

1、python中的字典的关键字： dict(dictionary)
2、python中的字典用的是{}
3、python中的字段元素是一个个键值对,键值对之间用逗号分隔，键和值之间用冒号
4、python中的键一般是字符串
5、python中字典一般是根据键找值
6、python中的字段键值对的顺序无所谓，因为我们根据键找值，而不是根据下标来找
7、python的字典中没有下标的概念

定义

# 1、定义字典
"""
语法： 字典名 = {键:值,键：值....}
字典中的键不能重复，否则后边的值会替换掉前边的值
"""
d1 = {'name': '刘备','name':'刘禅', 'age': 18, 'sex': '男', 'address': '河北'}
d2 = {}      # 空字典
d3 = dict()  # 空字典

print(d1)
print(d2)
print(d3)

# 2、字典的嵌套
d4 = {'name': '刘备', 'age': 18, 'sex': '男', 'address': '河北','firends':{'name':'刘璋','age':19}}
print(d4)


d5 = {'name': '刘备', 'age': 18, 'sex': '男', 'address': '河北','dest_city':['北京','广州','纽约']}
print(d5)

d6 = {'name': '刘备', 'age': 18, 'sex': '男', 'address': '河北','dest_city':('北京','广州','纽约')}
print(d6)


list1 = [{'name': '刘备', 'age': 18},{'name':'刘璋','age':19}]
print(list1)


t1 = ({'name': '刘备', 'age': 18},{'name':'刘璋','age':19})
print(t1)

操作-增加和修改

语法
字典名字[键] = 值
特点
如果这个键存在，则修改原来的值，如果键不存在，则添加新的减值对
操作
# 1、定义字典
"""
语法： 字典名 = {键:值,键：值....}
字典中的键不能重复，否则后边的值会替换掉前边的值
"""
d1 = {'name': '刘备', 'age': 18, 'sex': '男', 'address': '河北', 'phone': '138'}

# 2、向字典中添加一个新的键值对 , 键不存在
print(d1)

# 3、向字典中添加一个新的键值对 , 键存在将河北修改为河南
d1['address'] = '河南'
print(d1)

# 4、修改字典嵌套中的容器数据
#将北京修改为上海
d2 = {'name': '刘备', 'sex': '男', 'address': '河北','dest_city':['北京','广州','纽约']}
d2['dest_city'][0] = '上海'
print(d2)

# 5、修改字典嵌套中的容器数据
#将刘璋修改为刘表
d3 = {'name': '刘备', 'address': '河北','firends':{'name':'刘璋','age':19}}
d3['firends']['name'] = '刘表'
print(d3)


# 6、修改字典嵌套中的容器数据
#将刘璋修改为刘表
list4 = [{'name': '刘备', 'age': 18},{'name':'刘璋','age':19}]
list4[1]['name']  = '刘表'
print(list4)

操作-删除和清空

语法
#删除
del 字典名[键名]  

#清空
字典名.clear
特点
del操作和列表类似，只是这里不能用索引，要用键名 ,如果要删除的键不存在，则报错
操作

print('------------删除和清空------------')

d1 = {'name': '刘备', 'age': 18, 'sex': '男', 'address': '河北', 'phone': '138'}

# 删除 age这个键值对
del d1['age']
print(d1)

# 删除 firends这个键值对
d2 = {'name': '刘备', 'address': '河北','friends':{'name':'刘璋','age':19}}
del d2['friends']
print(d2)

# 清空d1
d1.clear()
print(d1)

# 销毁字典d1
del d1
print(d1)

操作-查询

在这里插入图片描述

根据键获取值

  • 语法

    #方式1
字典名字[键]

#方式2
字典名.get(键,默认值)  #根据键获取值，如果键不存在，则返回默认值

  • 代码

    print('------------查询-根据键获取值------------')
# 1、定义字典

d1 = {'name': '刘备', 'age': 18, 'sex': '男', 'address': '河北', 'phone': '138'}

# 2、根据name的键获取对应的值

# 方式1 - 键存在
print(d1['name'])

# 方式2 - 键存在
print(d1.get('name'))

# 方式3 - 键不存在,没有默认值，则返回None
print(d1.get('city'))

# 方式4 - 键不存在,有默认值，则返回默认值
print(d1.get('city','北京'))
获取所有的键和值

  • 语法

    字典名.keys()   #获取字典所有的键，将这些键存入封装列表并返回
字典名.values() #获取字典所有的值，将这些键存入封装列表并返回

  • 代码

    print('------------查询-获取所有的键------------')
d1 = {'name': '刘备', 'age': 18, 'sex': '男', 'address': '河北', 'phone': '138'}

# 获取所有的键,返回一个封装好的列表:
list1 = d1.keys()
print(list1) # d1 = {'name': '刘备', 'age': 18, 'sex': '男', 'address': '河北', 'phone': '138'}


print('------------查询-获取所有的值------------')
d1 = {'name': '刘备', 'age': 18, 'sex': '男', 'address': '河北', 'phone': '138'}

# 获取所有的值,返回一个封装好的列表:
list1 = d1.values()
print(list1)
获取键值对-items

  • 语法

    字典名.items()   #获取字典所有的键值对，返回一个封装列表中，列表中存放的是元组

  • 代码

    d1 = {'name': '刘备', 'age': 18, 'sex': '男', 'address': '河北', 'phone': '138'}
print(d1.items()) # dict_items([('name', '刘备'), ('age', 18)])

#我们可以使用强制，将返回的列表转为普通列表(脱马甲)
list(d1.items())

操作-遍历

print('------------对字典进行遍历------------')
# 1、定义字典
d1 = {'name': '刘备', 'age': 18, 'sex': '男', 'address': '河北', 'phone': '138'}

print('--------方式1--------')
for key in d1.keys(): #获取所有的键 dict_keys(['name', 'age', 'sex', 'address', 'phone'])
    print(f'{key}----{d1.get(key)}')

print('--------方式2--------')
list1 = list(d1.keys())  #获取所有的键，并强转成列表，脱去马甲
for key in list1:
    print(f'{key}----{d1.get(key)}')


print('--------方式3--------')
for key in d1:  # 如果直接对字典遍历，则可以直接获取key
    print(f'{key}----{d1.get(key)}')
    
    
print('--------方式4--------')

d1 = {'name': '刘备', 'age': 18, 'sex': '男', 'address': '河北', 'phone': '138'}
print(d1.items()) # dict_items([('name', '刘备'), ('age', 18)])

list1 = list(d1.items())  # [('name', '刘备'), ('age', 18)]
for x in list1: # x就是一个元组:('name', '刘备')
    print(f'{x[0]}----{x[1]}')

print('--------方式5--------')
d1 = {'name': '刘备', 'age': 18, 'sex': '男', 'address': '河北', 'phone': '138'}
for key,value in d1.items(): # dict_items([('name', '刘备'), ('age', 18)])
    print(f'{key}----{value}')

在这里插入图片描述

容器-集合

概念

1、python中的集合关键字：set
2、python集合中的元素不能重复，数据存入的顺序和取出的顺序不能保持一致
3、python中集合的样例：s1 = {10, 20, 30, 40, 50}

操作

定义集合
# 1、定义一个空集合
s1 = set()
print(type(s1))

# 2、定义一个非空集合

# 2.1 列表中的元素可以重复，而且数据存入的顺序的和取出的顺序是一致的
list1 = ['刘备', '关羽', '张飞', '赵云', '张飞']
print(list1)

# 2.1 集合中的元素不可以重复，自动去重，而且数据存入的顺序的和取出的顺序是不一致的
set1 = {'刘备', '关羽', '张飞', '赵云', '张飞'}
print(set1)
添加元素

  • 语法

    集合名字.add(值)     # 一次只能添加一个值
集合名字.update(值)  # 一次可以添加一个列表，或者一个集合 ，或者一个元组

  • 代码

    # 5、向集合添加元素
print('---------add---------')
set1 = set()
set1.add('刘备')
set1.add('关羽')
set1.add('曹操')
print(set1)

print('---------update---------')
set1 = {1,4,5}

set1.update([1,2,8])
set1.update({1,2,9})
set1.update((1,2,10))
删除元素

  • 概念

    集合名字.remove(要删除的元素)  # 如果删除的元素不存在，则报错
集合名字.discard(要删除的元素) # 如果删除的元素不存在，则返回None

  • 代码

    print('---------删除----------')
# 6、从集合删除张飞
set1 = {'刘备', '关羽', '张飞', '赵云', '张飞'}
set1.remove('张飞')
set1.discard('关羽')
print(set1)
修改元素

  • 概念

    集合中没有提供专门的修改方法，如果要对元素进行修改，则需要先删除，再添加

  • 代码

    # 先删除，再插入
set1 = {'刘备', '关羽', '张飞', '赵云', '张飞'}
set1.discard('张飞')  # discard删除数据时，如果数据不存在，则不会报错，remove会报错
set1.add('张苞')
print(set1)
查询元素

  • 概念

    集合由于是乱序的，所以集合中不能使用下标来访问，但是可以遍历

  • 代码

    print('---------查询----------')
set1 = {'刘备', '关羽', '赵云', '张飞'}

for x in set1:
    print(x)

在这里插入图片描述

西瓜瓜尓
关注
  • 11
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
全网最全Python课程，从入门到精通！.pdf
06-13
Python_PYTHON⼊门_零基础Python⼊门_Python爬⾍_Python课程第⼆篇_Python进阶 【Python基础】Python_PYTHON⼊门_零基础Python⼊门_Python爬⾍_Python课程第三篇_Python终极 【Python基础】Python教程第四篇_...
精品课件 Python从入门到精通 第20章 Web编程（共14页）.pptx
10-17
Python从入门到精通 第4章 流程控制语句.ppt Python从入门到精通 第5章 列表与元组.ppt Python从入门到精通 第6章 字典与集合.ppt Python从入门到精通 第7章 字符串.ppt Python从入门到精通 第8章 Python中使用正则...
python爬虫从入门到精通（模块）
03-17
python从入门到精通第二版pdf 这份文档旨在帮助想要学习Python爬虫的初学者，从入门到精通逐步提升自己的技能。以下是我们将要涵盖的主题： ## 入门篇 1. Python爬虫简介 2. Requests库的使用 3. Beautiful Soup库...
精品课件 Python从入门到精通 第13章 文件及目录操作（共26页）.ppt
10-17
Python从入门到精通 第4章 流程控制语句.ppt Python从入门到精通 第5章 列表与元组.ppt Python从入门到精通 第6章 字典与集合.ppt Python从入门到精通 第7章 字符串.ppt Python从入门到精通 第8章 Python中使用正则...
python3.8入门教程完整版-Python3.8从入门到精通（视频教学版）.pdf
06-11
Python3.8从⼊门到精通（视频教 学版） ⽬ 录 第壹章 感受Python精彩世界 1 1.1 Python概述 1 1.2 选择Python的理由 2 1.3 搭建Python的编程环境 2 1.3.1 在Windows下安装Python 3 1.3.2 在Linux下安装Python 4 1.4 ...
【hackmyvm】Slowman靶机
woshicainiao666的博客
05-20 1849
发现/secretLOGIN/login.html为登录地址，根据账号密码登录发现一个zip，但是需要密码。在FTP中得到的账号，爆破一下SSH。上传linpeas.sh文件，报一下。SSH爆破无果，试试mysql。得到用户名和加密的密码。
python中用“*”运算符复制列表时子列表实际上引用的是同一个列表，列表和嵌套列表的坑
ThreeS_tones的博客
05-21 1191
当你修改了一个子列表的元素时，所有的子列表都会随之改变。因为他们实际上都是同一个子列表的引用。输出如下，可以看到每个子列表中的第5个元素相同，并没有实现从0.8-1.2分布。先看一个例子，我想改变load的子列表中第五个元素，从0.8-1.2分布。的时候，Python实际上。
深入理解Python中None和““的区别
最新发布
m0_54701273的博客
05-27 302
在Python的世界里，None和空字符串""经常被用作默认值或用于表示缺省值的情况。尽管它们在某些语境下似乎可互换，但实际上None和""在Python中有着根本的区别。
《Python编程从入门到实践》day36
m0_37565294的博客
05-22 1706
我们要编写一个名为“学习笔记”的Web应用程序，让用户能够记录感兴趣的主题，并在学习每个主题的过程中添加日志条目。django-admin startproject learning_log . # 新建一个名为learning_log的项目，末尾的句点让新项目使用合适的目录结构。运行命令ls，其输出表明Django有创建一个db.sqlite3.SQLite使用一种使用单个文件的数据库。# 包含4个文件（settings.py、urls.py、wsgi.py、__init__.py）
提取COCO 数据集的部分类
qq_53682472的博客
05-24 686
若报错，pip install git+https://github.com/philferriere/cocoapi.git#subdirectory=PythonAPI。注意skimage用pip install scikit-image -i https://pypi.tuna.tsinghua.edu.cn/simple。安装pycocotools github地址：https://github.com/philferriere/cocoapi。实在不行的话，手动下载。
微信小程序uniapp+django洗脚按摩足浴城消费系统springboot
QQ1304979694的博客
05-24 713
Python语言官方规范访问数据库的统一接口规范(Python DB-API)，防止在使用不同数据库时，由于底层数据库技术不同造成接口程序紊乱的问题。（3）项目初期开发，美工设计，前端实现，开发信息系统的用户功能的实现，完善界面排版，实现信息提取发送等一系列功能。项目系统最后阶段的修改及最终测试运行。当然，在研究过程中也可以直接调查，对调查搜集到的资料进行综合分析、比较，调查法是科学研究中普遍的研究方法。（5）系统测试：对设计好的程序进行最终调试，通过调试发现存在的问题并解决，从而达到完善系统的目的。
Python 造数据神器Faker
pythondh1的博客
05-23 683
Faker 是一个用于生成假数据的 Python 包。它能够生成各种类型的数据，包括名字、地址、电话号码、电子邮件、公司名称、文本、日期等。Faker 库特别适合在测试和开发阶段使用，帮助我们模拟现实世界中的数据，提高工作效率。
python绘制多级饼图（分层饼图）
summerriver1的博客
05-25 707
python绘制多级饼图（分层饼图）
centos7.x安装python3.12.3
大怀特的博客
05-22 151
【代码】centos7.8安装python3.12.3。
一个超级简单的Python UI库：NiceGUI
pythondh1的博客
05-24 796
NiceGUI是一个基于Python的Web框架，它的设计理念是简洁和易用。NiceGUI不仅能帮助你快速创建Web界面，还能让你的应用看起来非常漂亮。无论你是一个新手开发者还是有经验的程序员，NiceGUI都能让你轻松上手，快速构建出色的Web应用。
jQuery知识点（二）
shsjssnn的博客
05-21 941
1.获取节点： 通过各种选择器或选择器的组合来获取想要的网页元素。 2.创建节点： 元素节点通过工厂函数$()直接创建，文本节点和属性节点可以随着元素节点创建时一起创建，也可以通过先创建元素节点，再使用操作内容和属性的方法产生。 3.插入节点： append()、prepend(): 是父元素的方法 appendTo()、prependTo(): 是要插入的节点的方法 before()、after(): 是要插入
python画PCoA
fanre的专栏
05-21 146
【代码】python画PCoA。
patroni 部分源码阅读
喝醉酒的小白
05-20 407
py.py。
GpuMall智算云：xinntao/Real-ESRGAN/Real-ESRGAN-v0.2.5.0
GpuMall的博客
05-22 424
Real-ESRGAN旨在开发用于一般图像/视频恢复的实用算法。用纯合成数据训练现实世界盲人超级分辨率。我们将强大的ESRGAN扩展到一个实用的恢复应用程序（即Real-ESRGAN），该应用程序使用纯合成数据进行训练。GpuMall智算云 | 省钱、好用、弹性。租GPU就上GpuMall,面向AI开发者的GPU云平台我们提供了一个带有上采样X4的预训练模型（RealESRGAN_x4plus.pth）。
八天Python从入门到精通
04-09
八天Python从入门到精通是一套针对Python编程语言的学习教程，旨在帮助初学者快速掌握Python的基础知识并逐步深入学习高级主题。以下是该教程的大致内容： 第一天：Python基础 - Python的历史和特点 - 安装Python...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值