Python基础 笔记(七) 容器--字符串、列表

发布于：2023-01-20 ⋅ 阅读:(398) ⋅ 点赞:(0)

一、字符串

1、字符串的定义

mystr1 = 'hello1'
mystr2 = "hello2"
mystr3 = """hello3
            hello4"""

print(mystr1)
print(mystr2)
print(mystr3) #三引号可以保持字符串原来的结构

2、字符串的索引 及 负索引

mystr = 'hello'

print(mystr[0])
print(mystr[1])
print(mystr[2])
print(mystr[3])
print(mystr[4])
print(len(mystr)) #计算字符串的长度

print('-----------------------------')
for s in mystr:
    print(s)

print('-----------------------------')
for i in range(len(mystr)): # 0 1 2 3 4
    print(mystr[i])
字符串的负索引（-1，-2，-3）
#-1索引是倒数第一个
mystr = 'hello'

print(mystr[-1],end='')
print(mystr[-2],end='')
print(mystr[-3],end='')
print(mystr[-4],end='')
print(mystr[-5])

3、切片

"""
切片的语法:
    字符串[起始索引:结束索引:步长]  ---》包头不包尾
"""
name = "abcdefg"

print(name[1:5])    # 从1索引截取字符串到4索引（5索引不会包含）  步长默认为1 bcde
print(name[1:5:1])  # 从1索引截取字符串到4索引（5索引不会包含） 步长为1 bcde
print(name[1:5:2])  # 从1索引截取字符串到4索引（5索引不会包含） 步长为2 bd
print(name[:5])     # 从0索引截取字符串到4索引（5索引不会包含） 步长为1  abcde
print(name[1:])     # 从1索引截取字符串到最后 步长为1  abcde
print(name[:])      # 从0索引截取字符串到最后 步长为1  abcdefg
print(name[::2])    # 从0索引截取字符串到最后 步长为2  aceg
print(name[:-1])    # 从0索引截取字符串到倒数第二个（不包含倒数第一个） 步长为1  aceg
print(name[-4:-1])  # 从0索引截取字符串到倒数第二个（不包含倒数第一个） 步长为1  def
print(name[::-1])   # 将字符串进行翻转

file_name = 'test.png'

if '.jpg' == file_name[-4:]:
    print('你的文件是.jpg图片文件')
else:
    print('你的文件不是.jpg图片文件')

4、字符串中的函数应用

"""
函数:
    find :  返回子串在大串中第一次出现的索引，如果没有该子串，则返回-1
    index： 返回子串在大串中第一次出现的索引，如果没有该子串，则报错
"""

mystr1 = 'hello world and hello python'

print(mystr1.find('world2'))
print(mystr1.index('world2'))
"""
函数: replace :  替换字符串，注意替换完成之后原来的字符串内容不会变化，而是返回一个新的字符串
"""

mystr1 = 'hello world and hello python hello'

mystr2 = mystr1.replace('hello','ok')  #替换

print(mystr1)
print(mystr2)

mystr3 = mystr1.replace('hello','ok',2)  #替换指定个数的字符串，如果没有指定，则全部替换

print(mystr3)


"""
函数:
    split :  切割字符串
"""
mystr1 = '2022-12-23'

list1 = mystr1.split('-') # ctrl + alt + v  ---> ['2022','12','23']

print(type(list1))
print(list1)
print(list1[0]) #2022
print(list1[1]) #12
print(list1[2]) #23
print('----------------------------')

list2 = mystr1.split('-',1)
print(list2)


print("--------------------------------------------")

mystr1 = '2022-12-23 10:37:46'
list1 = mystr1.split(' ')
list1_1 = list1[0].split('-')
print(list1_1[0])
print(list1_1[1])
print(list1_1[2])

list1_2 = list1[1].split(':')
print(list1_2[0])
print(list1_2[1])
print(list1_2[2])
"""字符串中函数（补充）"""
mystr = ' hello WORLD  JAVA python '

bl = mystr.startswith('hello')#判断字符串为某个字符串开头，如果是则返回True，否则返回False
print(bl)

bl = mystr.endswith('python')#判断字符串为某个字符串结尾，如果是则返回True，否则返回False
print(bl)

mystr2 = mystr.lower() #将字符串全部转为小写
print(mystr2)

mystr2 = mystr.upper() #将字符串全部转为大写
print(mystr2)

mystr2 = mystr.strip() #去除字符串两端的空格
print(mystr2)

mystr2 = mystr.lstrip() #去除字符串左侧的空格
print(mystr2+"xxx")

mystr2 = mystr.rstrip() #去除字符串右侧的空格
print(mystr2+"xxx")

5、字符串总结

  • 字符串

    • 下标

      • a = "123"

      • a[0] 获取字符串里的第一个元素

    • 切片

      • a[起始位置:结束位置:步长]

      • 1 找起始位置

      • 2 找结束位置

      • 3 看步长的正负

        • 如果步长为正

          • 从起始位置向右找结束位置

        • 如果步长为负

          • 从起始位置向左找结束位置

        • 如果步长没写

          • 默认是正1

        • 步长长度不为1

          • 按照步长的长度获取数据

      • 4 取头不取尾的取值范围

  • 字符串的常见操作

    • 字符串的函数都不会改变原始的字符串, 返回一个新的字符串

      • 字符串是不可以变的数据类型

      • b = a.replace(xxx,xxx) 并不会改变a字符串 而是产生一个新的字符串b

    • 字符串.find(子串, 开始位置下标, 结束位置下标)

      • 如果字符串中有子串, 返回子串的首字母在整个字符串中的下标位置

      • 指定子串查找的范围, 取头不取尾

      • 如果没有找到子串,返回-1

    • index方法(列表只有index方法没有find方法)

      • 用法和find完全一样

      • 区别: 如果找不到子串 直接报错

    • replace(老的子串,新的子串,替换次数)

      • 进行子串的替换

      • 如果不设置替换次数 默认就是替换无数次

    • split(子串)

      • 会把切割好的元素 返回到一个列表中 列表会存储这些元素

      • 字符串序列.split(分割字符, num)

        注意：num表示的是分割字符出现的次数，即将来返回数据个数为num+1个

二、列表

1、列表的格式

"""
列表的格式：
 列表的名字 = [值1，值2，值3]
"""

#1、定义列表
list_name = ['李华','王刚','刘力','赵松']

#2、访问列表-1
print(list_name)

#2、访问列表-2
print(list_name[0])
print(list_name[1])
print(list_name[2])
print(list_name[3])

#2、访问列表-3
print('*'*30)
for a in list_name:
    print(a)

#2、访问列表-4
print('*'*30)
i = 0
while i < len(list_name):
    print(list_name[i])
    i += 1

2、关键字-in

"""
in 关键字：判断某个元素是否在列表中，如果在，则返回True，否则，返回False
         in的判断语句以后一般用在if语句中
         in的后边一般跟上容器（字符串、列表、元组、字典、集合）

not in 关键字：判断某个元素是否不在列表中，如果不在，则返回True，否则，返回False
"""
list1 = ['Tom', 'Jack', 'Rose', 'LinDa', 'Lili', 'Rose']

print('Jack' in list1)  # True

if 'Jack' in list1:
    print('该列表中包含Jack')
else:
    print('该列表中不包含Jack')

print('***********************not in ******************************')

print('Jack' not in list1)  # False

print('*********************字符串使用in关键字*******************************')

mystr1 = 'hello world'
print('w' in mystr1)  # True  'w' 在字符串mystr1中
print('hello' in mystr1)  # True  'hello' 在字符串mystr1中

3、列表-增

"""
列表的格式：
 列表的名字 = [值1，值2，值3]

  1、列表的值可以被改变
  2、append向集合添加元素都是添加到最后
"""

#1、定义列表
list_name = ['李华','王刚','刘力','赵松']

#2、通过append向列表中添加元素
list_name.append('孙权') #append向集合添加元素都是添加到最后
print(list_name)

#2、通过extend向列表中添加元素
list_name.extend(['刘备','关羽','张飞']) #extend可以将另一个列表的元素添加到该列表中
print(list_name)

#3、在执行索引位置添加元素
list_name.insert(1,'曹操')
print(list_name)

#4、修改元素
list_name[1] = '曹操'
print(list_name)

4、列表-删

"""
del ：
      1、根据索引来删除，不能返回被删除的值
      2、如果删除的下标不存在，则报错
pop ：
      1、根据索引来删除，可以返回被删除的值
      2、如果删除的下标不存在，则报错
remove函数：
      1、可以根据内容来删除
      2、如果删除的内存不存在，则报错
clear函数：
      1、清空集合所有数据
      del list1  删除列表本身，列表不存在
      list1.clear 清空列表数据，列表本身还在
"""

list1 = ['李刚', '王华', '赵亮', '牛山', '孙帅', '周数']

print(list1)
del list1[2]
print(list1)

print('-----------------------------------')
print(list1)
list1.pop(2)
print(list1)

print('-----------------------------------')
print(list1)
list1.remove('周数')  # 删除 列表中 ‘赵亮’ 元素
print(list1)

print('-----------------------------------')
print(list1)
list1.clear()
print(list1)

5、列表-改

"""
列表的格式：
 列表的名字 = [值1，值2，值3]

  1、列表的值可以被改变
"""

# 1、定义列表
list_name = ['李华', '王刚', '刘力', '赵松']

# 修改元素
list_name[1] = '曹操'
print(list_name)

6、列表-查

"""
index函数：查找某个数据在列表中的第一次出现索引,如果没有找到则报错
count函数：表示查找指定数据在列表中出现的次数，如果没有则返回0
"""
list1 = ['Tom', 'Jack', 'Rose', 'LinDa', 'Lili', 'Rose',1]

print(list1.index('Rose'))  # 索引为：2

#  索引为：2   0表示查找的起始索引，3表示结束索引（不包含该索引的值）
print(list1.index('Rose', 0, 3))

#  count表示查找指定数据在列表中出现的次数
print(list1.count('Rose'))

7、列表-reverse

"""
reverse: 对列表的元素进行翻转
sort :对列表的元素进行排序
"""
list1 = ['李刚1','王华2','赵亮3','牛山4','孙帅5','周数6']

print(list1)
list1.reverse()
print(list1)

8、列表-sort

"""
sort :对列表的元进行排序
      如果排序的英文单词，则是按照这个单词在字典中出现的先后顺序排序
"""
list1 = ['student', 'about', 'blue', 'nice', 'person', 'zoo', 'abdon']

print(list1)
list1.sort()
print(list1)

print('------------------------------------------')
list2 = [78, 32, 59, 76, 15, 22]

print(list2)
# 升序排序
list2.sort()  # 将列表的数据从小到大排序，默认是升序
list2.sort(reverse=False)  # 同上

# 降序排序
list2.sort(reverse=True)  # 将列表的数据大到小排序
print(list2)

9、嵌套


name_list = [
    ['小明','小红'],
    ['Tom','Lily','Rose'],
    ['张三','李四','王五']
]

print(len(name_list))

print(name_list[1][1])


print('--------------使用索引遍历---------------------')
for i in range(len(name_list)): #rang(4) ---> 0 1 2 3
    for j in range(len(name_list[i])):
        print(name_list[i][j])

print('----------------不使用索引遍历-------------------')

for list_i in name_list:
    for list_value in list_i:
        print(list_value)

10、列表总结

列表

  • 下标查出界限也会报错

  • 作用: 存储数据

    • 可以存储多个数据

    • 可以存储多种类型的数据

  • 列表: 可变的数据类型(局部数据可以修改, 通过下标修改他的局部数据)

  • 增

    • 从末尾追加数据

      • append(数据)

    • 按照指定位置添加数据

      • insert(下标,数据)

    • 多个列表融合

      • extend()

  • 删除

    • 按照指定的数据的值删除列表中的元素

      • remove()

    • 从末尾删除数据

      • pop()

    • 彻底删除数据

      • del a

  • 改

    • a[0] = 10

      • 直接通过下标修改

  • 查

    • index(元素, 起始位置, 结束位置)

      • 返回元素 在列表中的下标的位置

      • 如果找不到直接报错

    • count(元素)

      • 统计列表中某个元素的出现次数

    • in/not in

      • 判断一个元素是否存储于列表中

      • if xxx in a:

  • 排序方法

    • 列表.sort()

      • 默认从小到大给列表排序(升序)

    • 列表.sort(reverse=True)

      • 从大到小给列表排序(降序)

    • 列表.reverse()

      • 列表[::-1] 效果一样

      • 逆序

    • 数字数据就按大小进行排序

    • 字符串数据按ASCII码进行排序

<end>

本文含有隐藏内容，请 开通VIP 后查看

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布