intellij idea汉化 刷脸支付 视频剪辑软件 二分类数据集 XShell idea linux创建文件 JS testing oauth notifications vue响应式布局 angular视频 jquery遍历对象 jquery遍历子元素 jquery获取元素 jquery获取元素宽度 pytorch安装教程 python编程 python3文件操作 python使用教程 java8特性 java实现 java获取当前月份 java基础代码 java集合转数组 java实现栈 java八大基本数据类型 java注释规范 linux命令 p2pover pushstate typemonkey stl2stp 华为线刷工具 maxtoc4d 视频修复工具 魔兽改图工具 go2lan 古风头像女动漫
当前位置: 首页 > 学习教程  > python

Python自学8(列表、元祖、字符串)

2021/2/8 10:44:05 文章标签: 测试文章如有侵权请发送至邮箱809451989@qq.com投诉后文章立即删除

" 如果没有任意门 没有时光机 没有竹蜻蜓 没有记忆面包 " 这么多的数据结构(一):列表、元祖、字符串1、列表1.1、创建列表1.1.1、创建空的列表1.1.2、创建包含元素的列表1.2、列表元素的获取1.2.1、通过索引获取元素1.2.2、通过元素…

在这里插入图片描述
" 如果没有任意门 没有时光机 没有竹蜻蜓 没有记忆面包······· "

这么多的数据结构(一):列表、元祖、字符串

  • 1、列表
    • 1.1、创建列表
      • 1.1.1、创建空的列表
      • 1.1.2、创建包含元素的列表
    • 1.2、列表元素的获取
      • 1.2.1、通过索引获取元素
      • 1.2.2、通过元素获取索引
      • 1.2.3、查看元素是否存在于列表中
      • 1.2.4、统计元素在列表中的个数
    • 1.3、列表元素的添加
      • 1.3.1、向列表末尾追加元素
      • 1.3.2、向列表的任意位置插入元素
      • 1.3.3、列表末尾追加另一个列表的所有元素
    • 1.4、列表元素的删除
      • 1.4.1、按索引删除元素(pop方法)
      • 1.4.2、按索引删除元素(del方法)
      • 1.4.2、直接删除元素
      • 1.4.3、清空所有元素
    • 1.5、列表元素的修改
      • 1.5.1、通过赋值修改列表元素
      • 1.5.2、反转整个列表
      • 1.5.3、列表元素排序(正序和倒序)
  • 2、元组
    • 2.1、创建元组
      • 2.1.1、创建空的元组
      • 2.1.2、创建包含多个元素的元组
      • 2.1.3、创建只包含一个元素的元组
    • 2.2、元组元素的获取
      • 2.2.1、通过索引获取元素
      • 2.2.2、通过元素获取索引
      • 2.2.3、查看元素是否存在于元组中
      • 2.2.4、统计元素在元组中出现的个数
  • 3、元组和列表的区别
  • 4、字符串
    • 4.1、创建字符串
      • 4.1.1、创建空字符串(即不包含字符的字符串)
      • 4.1.2、创建包含元素的字符串
    • 4.2、字符的获取
      • 4.2.1、通过索引获取字符
      • 4.2.2、通过子串获取索引
      • 4.2.3、查看字符是否存在于字符串中
      • 4.2.4、统计字符在字符串中的个数
    • 4.3、字符串的处理
      • 4.3.1、startswith 方法
      • 4.3.2、endswith 方法
      • 4.3.3、replace 方法
      • 4.3.4、strip 方法
      • 4.3.5、split 方法
      • 4.3.6、join 方法
      • 4.3.7、upper 方法
      • 4.3.8、lower 方法
    • 4.4、字符转义
      • 4.4.1、常用转义字符
      • 4.4.2、示例
      • 4.4.3、转义字符长度问题
      • 4.4.4、原始字符串
      • 4.4.5、多行字符串
  • 5、列表、元组、字符串的通用操作
    • 5.1、使用 len() 函数获取序列长度
    • 5.2、获取序列中的一个子序列
    • 5.3、使用 + 符号来拼接两个序列
    • 5.4、使用 * 符号来重复序列中的元素
  • 6、总结

前言

  1. 我们之前学习了字符串和列表
  2. 除此之外 Python 中还内置有元组、字典、集合等常用的数据类型
  3. 它们都被用于存放批量数据

特点

  1. 列表、元祖、字典、集合、字符串这些数据类型中所存放的一个个单独的数据、叫作项(Item)或元素(Element)
  2. 这些数据类型除了可以存放元素以外、还能通过调用对象方法来操作管理其中的元素

1、列表

  1. 列表是用于存放若干元素的有序序列
  2. 列表使用方括号来表示
  3. 其中的元素写入方括号中、多个元素时用逗号分隔
  4. 元素可以是任意数据类型、甚至也可以是个列表
  5. 元素之间有顺序关系、每个元素都有自己的位置
  6. 每个位置从 0 开始依次标号、这个表示位置的数字叫作索引
  7. 列表被创建之后、我们可以对它做很多操作
  8. 包括添加元素、删除元素、修改元素、查找元素等

1.1、创建列表

1.1.1、创建空的列表

# 语法
列表 = []

a = []
print(a)
# output:[]

1.1.2、创建包含元素的列表

# 语法
列表 = [元素1, 元素2, ..., 元素N]

a = [1,2,3,4,5]
print(a)
# output:[1,2,3,4,5]

1.2、列表元素的获取

1.2.1、通过索引获取元素

# 语法
元素 = 列表[索引]

a = [1,2,3,4,5]
print(a[1])
# output:2

1.2.2、通过元素获取索引

# 语法
索引 = 列表.index(元素)

a = [1,2,3,4,5]
print(a.index(1))
# output:0

1.2.3、查看元素是否存在于列表中

# 语法
布尔值 = 元素 in 列表

a = [1,2,3,4,5]
print(6 in a)
# output:False

1.2.4、统计元素在列表中的个数

# 语法
个数 = 列表.count(元素)

a = [1,2,2,3,4,5]
print(a.count(2))
print(a.count(5))
# output:2
#        1

1.3、列表元素的添加

1.3.1、向列表末尾追加元素

# 语法
列表.append(元素)

a = [1,2,3,4,5]
a.append(6)
print(a)
# output:[1,2,3,4,5,6]

1.3.2、向列表的任意位置插入元素

# 语法
列表.insert(索引, 元素)

a = [1,2,3,4,5]
a.insert(0,0)
print(a)
# output:[0, 1, 2, 3, 4, 5]

1.3.3、列表末尾追加另一个列表的所有元素

# 语法
列表.extend(另一列表)

a = [1,2,3,4,5]
b = [6,7,8,9,10]
a.extend(b)
print(a)
# output:[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

1.4、列表元素的删除

1.4.1、按索引删除元素(pop方法)

# 语法
# 不传递索引、默认删除最后一个元素
元素 = 列表.pop(索引)

a = [1,2,3,4,5]
a.pop(0)
print(a)
# output:[2, 3, 4, 5]

a = [1,2,3,4,5]
a.pop()
print(a)
# output:[1, 2, 3, 4]

1.4.2、按索引删除元素(del方法)

# 语法
del 列表[索引]

a = [1,2,3,4,5]
del a[0]
print(a)
# output:[2, 3, 4, 5]

1.4.2、直接删除元素

# 语法
列表.remove(元素)

a = [1,2,3,4,5]
a.remove(1)
print(a)
# output:[2, 3, 4, 5]

1.4.3、清空所有元素

# 语法
列表.clear()

a = [1,2,3,4,5]
a.clear()
print(a)
# output:[]

1.5、列表元素的修改

1.5.1、通过赋值修改列表元素

# 语法
列表[索引] = 新元素

a = [1,2,3,4,5]
a[1] = 100
print(a)
# output:[1, 100, 3, 4, 5]

1.5.2、反转整个列表

# 语法
列表.reverse()

a = [1,2,3,4,5]
a.reverse()
print(a)
# output:[5, 4, 3, 2, 1]

1.5.3、列表元素排序(正序和倒序)

# 语法
列表.sort()

%1 正序
a = [1,6,2,4,6]
a.sort()
print(a)
# output:[1, 2, 4, 6, 6]

%2 倒序
a = [1,6,2,4,6]
a.sort(reverse = True)
print(a)
# output:[6, 6, 4, 2, 1]

2、元组

  1. 元组和列表非常相似、也是用于存放元素的有序序列
  2. 它用的圆括号表示、元素写入圆括号中、多个元素时用逗号分隔
  3. 元组同样具有索引、索引使用方式与列表一致、其元素同样可以是任意类型

与列表的区别
4. 元组创建完成后,便不能向其中添加元素
5. 也不能修改和删除其中的任何一个元素
6. 所以它与列表相比、只能查找元素
7. 也就是说只具备读的功能、不具备写的功能
8. 元组的这一特性叫作不可变(性)(Immutable)而列表是可变的(Mutable)

2.1、创建元组

2.1.1、创建空的元组

# 语法
元组 = ()

a = ()
print(a)
# output:()

2.1.2、创建包含多个元素的元组

# 语法
元组 = (元素1, 元素2, ..., 元素N)

a = (1,2,3)
print(a)
# output:(1,2,3)

2.1.3、创建只包含一个元素的元组

  1. 只包含一个元素的情况需要单独说明一下、因为它的形式与直觉不相符
  2. 创建只包含一个元素的元组、需要在唯一的那个元素后面加上逗号
# 语法
元组 = (元素,)

a = (1,)
print(a)
# output:(1,)

# 这是因为、如果括号中只有一个元素
# 那么 Python 会将这个括号当作优先级符号进行处理(像数学中的那样)、而不是当作元组

a = (1)
print(type(a))
# output:<class 'int'>

2.2、元组元素的获取

2.2.1、通过索引获取元素

# 语法
元素 = 元组[索引]

a = (1,2,3,4)
print(a[1])
# output:2

2.2.2、通过元素获取索引

# 语法
索引 = 元组.index(元素)

a = (1,2,3,4,"22")
print(a.index('22'))
# output:4

2.2.3、查看元素是否存在于元组中

# 语法
布尔值 = 元素 in 元组

a = (1,2,3,4,"22")
print(4 in a)
# output:True

2.2.4、统计元素在元组中出现的个数

# 语法
个数 = 元组.count(元素)

a = (1,2,3,4,4)
print(a.count(4))
print(a.count(1))
# output:2
#         1 

3、元组和列表的区别

  1. 我们可以看到、元组所具有的操作在使用方式上与和列表非常相似
  2. 甚至在一定程度上可以将元组看作是列表的精简版、但它们之间也有明显的差别
  3. 元组是不可变的(Immutable)、列表是可变的(Mutable)
  4. 元组在被创建之后,就不能添加、删除和修改元素、而列表可以
  5. 一般情况下元组的性能略高于列表
  6. 列表还是元组、通常性能不是从它们中做选择的主要考虑因素
  7. 因为它们之间的性能差异不是很大
  8. 我们的选择通常围绕着可变和不可变的特性进行
  9. 当我们需要添加元素或修改元素时、使用列表
  10. 当我们希望所有元素在创建之后便不再改变、可使用元组

4、字符串

  1. 字符串也是 Python 中非常常用的内置数据类型我
  2. 字符串是 Python 中用来存放字符序列的数据类型
  3. 其中的元素只能是字符、字符串使用单引号或双引号来表示
  4. 字符串是有序序列、可以使用索引来获取其中某个位置的元素
  5. 它是不可变的、被创建之后其中的元素(也就是字符)不能被修改和删除

4.1、创建字符串

4.1.1、创建空字符串(即不包含字符的字符串)

# 语法
字符串 = ''

a = ""

4.1.2、创建包含元素的字符串

# 语法
字符串 = '若干字符'

a = "happy"

4.2、字符的获取

4.2.1、通过索引获取字符

# 语法
字符 = 字符串[索引]

a = "happy"
print(a[1])
# output:a

4.2.2、通过子串获取索引

# 语法
索引 = 字符串.index(字符)

a = "happy"
print(a.index('p'))
print(a.index('app'))
# output:2
#        1

# 当字符或子串不存在时\index 方法将抛出 ValueError 错误

# 也可采用字符串的 find 方法来查找子串\使用方式与 index 一致
# 不同点在于 find 方法未找到子串时返回数字 -1、而不抛出异常

a = "happy"
print(a.index('p'))
print(a.index('z'))
# output:2
#       -1

4.2.3、查看字符是否存在于字符串中

# 语法
布尔值 = 字符 in 字符串

a = "happy"
print('a' in a)
# output:True

4.2.4、统计字符在字符串中的个数

# 语法
个数 = 字符串.count(字符)

a = "happy"
print(a.count(p))
print(a.count(h))
# output:2
#        1

4.3、字符串的处理

4.3.1、startswith 方法

# 判断字符串是否以某个子串开头,返回布尔值
a = "happy"
print(a.startswith("hap"))
print(a.startswith("hp"))
# output:True
#        False

4.3.2、endswith 方法

# 判断字符串是否以某个子串结尾,返回布尔值
a = "happy"
print(a.endswith("py"))
print(a.endswith("hp"))
# output:True
#        False

4.3.3、replace 方法

# 将字符串的子串用一个另一个字符串替换、返回一个新的字符串
a = "happy"
b = a.replace('y','iness')
print(b)
# output:happiness

4.3.4、strip 方法

# 去除字符串前后的空白符号、如空格、换行符、制表符、返回一个新的字符串
a = "    \t\t\n  happy\n   "
b = a.strip()
print(b)
# output:happy

4.3.5、split 方法

# 将字符串用某个子串分隔开、分隔后的各个部分放入列表中、并返回这个列表
a = "i am happy"
b = a.split(" ")
print(b)
# output:['i', 'am', 'happy']

4.3.6、join 方法

# 将一个序列中的元素用某个字符(串)拼接、组成一个大的字符串、并返回这个字符串
a = "i am happy"
b = a.split(" ")
c = "ccc".join(b)
print(c)
# output:icccamccchappy

4.3.7、upper 方法

# 将字符串转化为大写字母形式、返回一个新的字符串
a = "i am happy"
b = a.upper()
print(b)
# output:I AM HAPPY

4.3.8、lower 方法

# 将字符串转化为小写字母形式、返回一个新的字符串
a = "I AM HAPPY"
b = a.lower()
print(b)
# output:i am happy

4.4、字符转义

  1. 我们在创建字符串时、有一些字符是没法直接在引号中表示的
  2. 如单引号或双引号、因为这和表示字符串本身的符号冲突了
a = 'I'm happy'
# output: SyntaxError: invalid syntax

# 使用字符转义
a = 'I\'m happy'
print(a)
# output:I'm happy

4.4.1、常用转义字符

常用的转义字符含义
单引号
"双引号
\n换行符
\t制表符(Tab)
\r回车

4.4.2、示例

%1 输出换行
print('第一行\n第二行')
# output:第一行
#        第二行

%2 如果我们就想在字符串中表示 \n 这两个字符,而不是让它表示换行
print('第一行\\n第二行')
# output:第一行\n第二行

4.4.3、转义字符长度问题

  1. 转义字符虽然在书写时使用了两个字符、但是在程序中它只是一个字符
print(len('\n'))
# output:1

4.4.4、原始字符串

  1. 原始字符串就是在字符串的起始引号前加上一个 r 或 R 字母
  2. 这样字符串中的内容将不会被转义、将按照原样输出
# 语法
r'字符串内容'

print(r'第一行\n第二行')
# output:第一行\n第二行    

4.4.5、多行字符串

  1. 我们之前所使用的字符串都被书写成一行
  2. 要想让字符串可以跨行书写、写成多行的形式、有两种方法
%1
# 字符串的每行末尾使用 \ 续行
a = '第一行\
第二行\
第三行'
print(a)
# output:第一行
#        第二行
#        第三行

%2
# 使用三个单引号或三个双引号来表示字符串
a = '''第一行
第二行
第三行'''
print(a)
# output:第一行
#        第二行
#        第三行

5、列表、元组、字符串的通用操作

5.1、使用 len() 函数获取序列长度

a = [1,2,3]
b = (1,2,3)
c = "123"
print(len(a))
print(len(b))
print(len(c))
# output:3
#        3
#        3

5.2、获取序列中的一个子序列

# 获取序列中的子序列可以使用切片
# 以 [起始索引:结束索引] 表示切片其实代表一个索引区间
# 这个区间是一个左闭右开区间、该区间内的所有元素作为子序列被返回

a = [1,2,3]
b = (1,2,3)
c = "123"
print(a[0:2])
print(b[0:2])
print(c[0:2])
# output:[1, 2]
#        (1, 2)
#        12

5.3、使用 + 符号来拼接两个序列

a1 = [1,2,3]
a2 = [4,5,6]
b1 = (1,2,3)
b2 = (4,5,6)
c1 = "123"
c2 = "456"
print(a1 + a2)
print(b1 + b2)
print(c1 + c2)
# output:[1, 2, 3, 4, 5, 6]
#        (1, 2, 3, 4, 5, 6)
#        123456

5.4、使用 * 符号来重复序列中的元素

a1 = [1,2,3]
b1 = (1,2,3)
c1 = "123"
print(a1 * 3)
print(b1 * 3)
print(c1 * 3)
# output:[1, 2, 3, 1, 2, 3, 1, 2, 3]
#        (1, 2, 3, 1, 2, 3, 1, 2, 3)
#        123123123

6、总结

  1. 列表、元组、字符串都是有序序列、都可以使用索引
  2. 列表和元组中可以存放任意数据类型的元素、而字符串中只能存放字符
  3. 列表是可变的、而元组和字符串是不可变的

本文链接: http://www.dtmao.cc/news_show_2000293.shtml

附件下载

相关教程

    暂无相关的数据...

共有条评论 网友评论

验证码: 看不清楚?