1.字符串

python中的字符串：双引号或者单引号中的数据，就是字符串
如：

# 这个是一个整型数据
a = 10
# 这是一个字符串
b = 'hello world'
# 这也是一个字符串
c = "hello world"

1.f_strings的使用

demo：

name = '狗蛋'
age = 20
print("name is " + name)
print("name is %s" % name)# f-strings
f_strings = f"name is {name},age is {age}"
print(f_strings)
f_strings2 = f"3 + 5 = {3+5}";
print(f_strings2)a = 10
b = 20
f_strings3 = f"a + b = {a + b}";
print(f_strings3)

结果:

2.字符串的输入

input获取的数据，都以字符串的方式进行保存，即使输入的是数字，那么也是以字符串方式保存.
demo:

     password = input('请输入密码:')print("密码为：%s" % password)

结果：

  请输入密码:haohaoxuexitiantianxiangshang密码为： haohaoxuexitiantianxiangshang

3.字符串的下标操作

列表与元组支持下标索引好理解，字符串实际上就是字符的数组，所以也支持下标索引。

如果有字符串:name = 'abcdef'，在内存中的实际存储如下:

1.索引基本使用

s = "hello python"
# 打印字符串中的第一个元素
print(s[0])
# 得到字符串的长度
print(len(s))
# 打印字符串中最后一个元素
print(s[len(s) - 1])

输出:

h
12
n

2.遍历字符串

s = "this is a wonderful world"
# 遍历字符串方法1：使用while
i = 0
while i < len(s):print(s[i],end="")i += 1print()
print("==========================")# 方法2：使用for循环遍历
for x in s:print(x,end="")

输出：

this is a wonderful world
==========================
this is a wonderful world

3.for-else的使用

s = "hello world"
for x in s :if x == "r":print("该字符串包含r字母，终止一下")break
else:print("该字符串没有含有r字母")

输出:

该字符串包含r字母，终止一下

4.字符串切片的使用（截取字符串）

切片的语法：[起始:结束] (左闭右开)

"""
字符串切片的基本使用就是截取字符串切片的格式:字符串名[开始索引: 结束索引]从 开始索引 对应的元素截取, 一直截取到 结束索引 对应的元素.包含 开始索引 对应的元素, 不包含 结束索引 对应的元素
"""
s = "hello python"print(len(s)) # 12
# 从第一个字母截取到最后一个字母
print(s[0:12])
# 截取中间的一段
print(s[1:11]) # ello pytho
print(s[1:12]) # ello python# 如果是截取到最后的那个元素，后边的那个索引可以不用写的
print(s[1:]) # ello python# 如果截取的是从头开始的，第一个索引可以不用写出来的
print(s[:11]) # hello pytho# 如果右边的索引越界了会默认为就是截取到最后的那个元素
print(s[0:111]) # hello python# 如果截取的索引是负数，默认就是从右边开始
print(s[-11:-1]) # ello pytho
print(s[-12:-1]) # hello pythoprint(s[3:-2]) # lo pythprint(s[:-11])

5.带步长的字符串切片（有翻转方法介绍）

切片的语法：[起始:结束:步长]
注意：选取的区间从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身)，步长表示选取间隔。

"""
字符串切片步长的格式:字符串名[开始索引: 结束索引: 步长]假如步长是n.从开始索引对应的元素 截取,一直截取到 结束索引 对应的元素.先 截取出  开始索引对应的元素, 然后每次都是向后数n个元素,第n个元素是谁就把谁截出来.最后按照截取的先后顺序,组成一个字符串. 这个字符串 就是截取的结果.
"""
s = "hello python"
# 默认的步长是1
print(s[1:11]) # ello pytho
print(s[1:11:1]) # ello pytho
# 改变步长看结果
print(s[1:11:2]) # el yh# 步长可以为负数，表示倒序取
print(s[11:1:-2]) # nhy l 第一个索引表示右边开始的第一个索引，第二个为左边开始的索引,-2为倒序并且间隔1个元素来取print(s[-1:1:-2]) # nhy l# 字符串翻转操作,就是直接将步长设置为-1就行了
print(s[::-1]) # nohtyp olleh

6.字符串常用的方法——查找、统计、分割

s1 = "hello python"print("=========find==============")# 查找功能练习
print(s1.find("p")) # 6 查找p字母在字符串中第一次出现的位置
print(s1.find("p", 3, 6)) # -1 在s1的索引为3-6的区间内查找h字母的位置，找不到的返回-1
print(s1.find("p", 3, 7)) # 6 返回的是在原字符串中的索引位置print(s1.find("pyt")) # 6 寻找该字符串在原字符串中第一次出现的索引
print(s1.find("pyx")) # -1 没有这个子字符串，返回-1
print(s1.index("pyt")) # 6print(s1.rfind("pyt")) # 6 从右边开始查找第一次出现pyt的索引ss = "hello pythonpyt"
print(ss.rfind("pyt")) # 对比上边的可以看出来，确实就是从右边来搜索的# 统计功能的练习
print("============count==================")
print(s1.count("o")) # 2
print(s1.count("o",5,11)) # 1# 分割方法的练习
print("==============split====================")
s2 = "hello python android"
# 分割的结果是一个列表, 把分割出来的几部分字符串作为元素放到列表中了
list1 = s2.split(" ")
print(list1) # ['hello', 'python', 'android']
print(type(list1)) # <class 'list'># 这个方法只能分割出3部分: 左边部分,自己,右边部分
list2 = s2.partition(" ")
print(list2) # ('hello', ' ', 'python android')
print(type(list2)) # <class 'tuple'>

7.字符串常用方法——判断（包含子串、大小写）

# 1.判断字符串是否都由字母组成
s1 = "asdsafda"
print(s1.isalpha()) # True
# 2.判断字符串是否都是由数字组成的
s2 = "123456"
print(s2.isdigit()) # True
print(s2.isdecimal()) # True# 3.判断字符串是否都是大写的或者都是小写的
s3 = "LED123AAA"
print(s3.isupper()) # True
s4 = "led111aaa"
print(s4.islower()) # True# 4. 判断字符串是否以另外的一个字符串作为开头或者结尾
s5 = "hello fafa mama"
print(s5.startswith("hello")) # True
print(s5.startswith("h")) # Trueprint(s5.endswith("mama")) # True
print(s5.endswith("a")) # True

8.字符串常用方法——大小写转换、替换、去空格、对齐

# 1.替换的方法: s1.replace(oldstr, newstr)
s1 = "hello world python"
s2 = s1.replace("python", "java") # 下边两种写法的结果是一样的
# s2 = s1.replace("python", "java", 10)
# s2 = s1.replace("python", "java", 1)
print(s2) # hello world java# 2.大小写转换的方法:
s3 = "hello 123 PyThon"
print(s3.lower()) # hello 123 python
print(s3.upper()) # HELLO 123 PYTHON# 3.去掉空格:(strip去掉的是首尾的空格，replace去掉所有的空格)
print("========去掉空格===========")
s4 = " hello python "
print("a" + s4.strip() + "b") # ahello pythonb
print("a" + s4.strip() + "b") # ahello pythonb
print(s4.replace(" ", "")) # hellopython# 4.对齐方法
# center:返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
print("======对齐方法=======")
s5 = "hello"
print(s5) # hello
print(s5.ljust(15)) # hello          一直到这里都是空白
print(s5.rjust(15)) #           hello
print(s5.center(15)) #     hello     # join
s6 = "hello"
s7 = "python"
# 使用s6连接s7中的元素,得到一个新的字符串
result = s6.join(s7)
print(result) # phelloyhellothellohhelloohellon 在python的每个字母间插入字符串s7
print(type(result)) # class 'str'>

2. 常用函数——f-strings简化字符串格式化

demo:

name = '狗蛋'
age = 20
print("name is " + name)
print("name is %s" % name)#
f_strings = f"name is {name},age is {age}"
print(f_strings)
f_strings2 = f"3 + 5 = {3+5}";
print(f_strings2)a = 10
b = 20
f_strings3 = f"a + b = {a + b}";
print(f_strings3)

输出结果：

name is 狗蛋
name is 狗蛋
name is 狗蛋,age is 20
3 + 5 = 8
a + b = 30

3. 列表的使用

比C语言的数组强大的地方在于列表中的元素可以是不同类型的

testList = [1, ‘a’]

5.1基本使用：

"""
列表:也是一个容器,可以存储多个元素,元素可以是任何类型的.定义格式:# 非空列表名 = [元素1, 元素2, ...]# 空列表列表名 = []
"""
name_list = ["vivi","爽儿", "千寻","冬冬", "冰冰", "圆圆"]
print(name_list) # ['vivi', '爽儿', '千寻', '冬冬', '冰冰', '圆圆']
print(type(name_list)) # <class 'list'>list1 = [10, 3.14, "hello", True] # 放什么元素都行的
print(list1) # [10, 3.14, 'hello', True]# 定义空列表
list2 = []
print(list2) # []

5.2 增删改查操作

list1 = ["大双", "小双", "建宁"]
print(list1) # ['大双', '小双', '建宁']# 1.向列表中添加一个元素
# append(数据):在列表的最后添加一个元素
list1.append("龙儿")
print(list1) # ['大双', '小双', '建宁', '龙儿']# 2.在指定的索引处插入一个元素
list1.insert(2, "小宝")
print(list1) # ['大双', '小双', '小宝', '建宁', '龙儿']# 3.继承:把另外一个容器中的元素添加自己的容器中
list_age = [18, 19, 20]
list1.extend(list_age) #
print(list1) # ['大双', '小双', '小宝', '建宁', '龙儿', 18, 19, 20]list1.extend("hello")
print(list1) # ['大双', '小双', '小宝', '建宁', '龙儿', 18, 19, 20, 'h', 'e', 'l', 'l', 'o']# 4.修改
list2 = [10, 20, "Hello", True]
print(list2[2]) # Hello
list2[2] = "vivi"
print(list2) # [10, 20, 'vivi', True]# 5.删除元素
# 删除指定位置的元素
list2.remove("vivi")
print(list2) # [10, 20, True]# 删除指定索引处的元素,返回被删除的元素
result = list2.pop(2)
print(result) # True
print(list2) # [10, 20]# pop方法中没有写索引,默认删除最后一个元素
list2.pop()
print(list2) # [10]list1.append("python")
print(list1) #  [10, "python"]
list1.pop()
print(list1) # [10]# 把列表中的元素全部删除,清空
list1.clear()
print(list1) # []

5.3 列表的遍历操作

list1 = [10, 20, 30]
# 方式一:while循环语句
# 作为元素的索引
i = 0
while i < 3:print(list1[i])i += 1print("==========================")# 方式二: for循环遍历
for e in list1:print(e)

5.4 列表的嵌套

# 如果列表中的元素还是一个列表,你的列表就是嵌套的列表.
name_list = [["孙俪", "谢娜", "贾玲"], ["蓉蓉", "百合", "露露"]]print(name_list[0][0])
print(name_list[0][1])
print(name_list[0][2])print(name_list[1]) # ["蓉蓉", "百合", "露露"]# list2 = name_list[1] # ;list2 = ["蓉蓉", "百合", "露露"]
# print(list2[0])
# print(list2[1])
# print(list2[2])print(name_list[1][0])
print(name_list[1][1])
print(name_list[1][2])# 遍历嵌套的列表
for list in name_list:print(list)for e in list:print(e)
'''
孙俪
谢娜
贾玲
['蓉蓉', '百合', '露露']
蓉蓉
百合
露露
'''

5.5 列表的排序

"""
排序:可以按照升序/降序排序.
"""
list1 = [1, 5, 2, 8, 6, 4]# 默认是按照升序排列的
list1.sort()
print(list1) # [1, 2, 4, 5, 6, 8]# 倒序排序
list1.sort(reverse=True)
print(list1) # [8, 6, 5, 4, 2, 1]list2 = ["java", "python", "C++", "Php", "中国"]
list2.sort()
print(list2)  # ['C++', 'Php', 'java', 'python', '中国'] 按照ASCIIprint(ord("中")) # 20013 返回对应的 ASCII 数值

4.元组

Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。

>>> aTuple = ('et',77,99.9)
>>> aTuple
('et',77,99.9)

<1>访问元组

<2>修改元组

说明： python中不允许修改元组的数据，包括不能删除其中的元素。

<3>count, index

index和count与字符串和列表中的用法相同

>>> a = ('a', 'b', 'c', 'a', 'b')
>>> a.index('a', 1, 3) # 注意是左闭右开区间
Traceback (most recent call last):File "<stdin>", line 1, in <module>
ValueError: tuple.index(x): x not in tuple
>>> a.index('a', 1, 4)
3
>>> a.count('b')
2
>>> a.count('d')
0

5.字典介绍

变量info为字典类型：

info = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国北京'}

说明：

• 字典和列表一样，也能够存储多个数据
• 列表中找某个元素时，是根据下标进行的
• 字典中找某个元素时，是根据’名字’（就是冒号:前面的那个值，例如上面代码中的’name’、‘id’、‘sex’）
• 字典的每个元素由2部分组成，键:值。例如 ‘name’:‘班长’ ,'name’为键，'班长’为值

5.1 字典取值（查看）：

info = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国北京'}
print(info["name"]) # 班长
print(info["sex"]) # f
# print(info["aa"])
print(info.get("aa")) # None
print(info.get("name")) # 班长

5.2 修改元素

字典的每个元素中的数据是可以修改的，只要通过key找到，即可修改

  info = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国北京'}newId = input('请输入新的学号')info['id'] = int(newId)print('修改之后的id为%d:'%info['id'])

输出:

5.3添加元素

info = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国北京'}
print(info["name"]) # 班长# 添加元素
info["aa"] = 1111
print(info) # {'name': '班长', 'id': 100, 'sex': 'f', 'address': '地球亚洲中国北京', 'aa': 1111}

输出：

5.4 删除元素

对字典进行删除操作，有一下几种：

• del
• clear()
  demo:del删除指定的元素

    info = {'name':'班长', 'sex':'f', 'address':'地球亚洲中国北京'}print('删除前,%s'%info['name'])del info['name']print('删除后,%s'%info['name'])

输出：

demo: del 删除整个字典

info = {'name':'monitor', 'sex':'f', 'address':'China'}print('删除前,%s'%info)del infoprint('删除后,%s'%info)

输出：

demo:clear清空整个字典

info = {'name':'monitor', 'sex':'f', 'address':'China'}print('清空前,%s'%info)info.clear()print('清空后,%s'%info)

5.5 字典中常用的方法(keys/values/items)

5.6 字典的遍历

5.7 有序字典:OrderDcit（py3.6以上不用考虑了）

我们先看一段代码, 此代码运行在 Python3.5 版本中:

# 创建无序字典
my_dict = dict()
# 向字典中添加元素
my_dict['one'] = 1
my_dict['two'] = 2
my_dict['three'] = 3
my_dict['four'] = 4
print(my_dict)

输出结果(不固定):

{'three': 3, 'two': 2, 'four': 4, 'one': 1}

输出结果并不是按照我们创建字典、添加元素的顺序输出, 这是由于 dict 是无序的. 如果我们想最终打印输出的顺序和我们操作时的顺序保持一致, 我们就需要使用有序字典:

from collections import OrderedDict# 创建有序字典
my_dict = OrderedDict()
# 向字典中添加元素
my_dict['one'] = 1
my_dict['two'] = 2
my_dict['three'] = 3
my_dict['four'] = 4
print(my_dict)

输出结果:

OrderedDict([('one', 1), ('two', 2), ('three', 3), ('four', 4)])

在 Python3.6 版本中, dict 字典已经经过优化, 变为有序字典. 并且字典所占用的内存占用减少了20％到25％.

第一段代码在 Python3.6 运行下, 输出结果如下:

{'one': 1, 'two': 2, 'three': 3, 'four': 4}

6.公共方法

6.1运算符

+

>>> "hello " + "itcast"
'hello itcast'
>>> [1, 2] + [3, 4]
[1, 2, 3, 4]
>>> ('a', 'b') + ('c', 'd')
('a', 'b', 'c', 'd')

*

>>> 'ab' * 4
'ababab'
>>> [1, 2] * 4
[1, 2, 1, 2, 1, 2, 1, 2]
>>> ('a', 'b') * 4
('a', 'b', 'a', 'b', 'a', 'b', 'a', 'b')

in

>>> 'itc' in 'hello itcast'
True
>>> 3 in [1, 2]
False
>>> 4 in (1, 2, 3, 4)
True
>>> "name" in {"name":"Delron", "age":24}
True

注意，in在对字典操作时，判断的是字典的键

6.2 python内置函数

Python包含了以下内置函数

python入门（3）—— python容器.字符串、列表、元组、字典相关推荐

1. 4.Python基础语法(数字运算/字符串/列表/元组/字典/集合)

   4.1 数字运算 编程是将问题数据化的一个过程,数据离不开数字,Python的数字运算规则与我们学习的四则运算规则是一样的,即使不使用Python来编写复杂的程序,也可以将其当作一个强大的计算器.打开 ...

2. Python 字符串/列表/元组/字典之间的相互转换 - Python零基础入门教程

   目录 一.字符串 str 与列表 list 1.字符串转列表 2.列表转字符串 二.字符串 str 与字典 dict 1.字符串转字典 2.字典转字符串 三.列表 list 与字典 dict 1.列表 ...

3. Python基础之day03-字符串,列表,元组,字典

   Python基础之day03-字符串,列表,元组,字典 文章目录 Python基础之day03-字符串,列表,元组,字典 一.字符串 二.下标与字符串切片 三.列表 四.元祖 五.字典 六.公用方法 ...

4. Python入门学习 DAY 05 字符串,列表的内置方法

   Python入门 DAY 05 本篇文章主要介绍字符串类型及内置方法,列表类型及内置方法 1.字符串类型及内置方法 (1)字符串定义       1.字符串中的字符是有序的          可以通过 ...

5. python字符串转换元组_python 字符串,列表,元组,字典相互转换

   1.字典 dict = {'name': 'Zara', 'age': 7, 'class': 'First'} 字典转为字符串,返回: {'age': 7, 'name': 'Zara', 'cla ...

6. python列表添加元素的三种方法定义集合数据对象_（1） List，tuple，dictionary，Python语法基础集,一,之,列表,元组,字典,集合...

   Python序列(列表.元组.字典.集合) 一.列表(List)与列表推导式 (一)列表(list) 1.列表是Python内置 可变序列 (列表中元素可增加删除或修改): 2.列表元素放在一对中括号 ...

7. day02 格式化输出 运算符 编码 字符串 列表 元组 字典 set集合 深浅拷贝

   day02学习大纲 一. 格式化输出: %s 占位字符串 %d 占位数字 "xxx%sx %sxx" % (变量, 变量) 二. 运算符: a+=b a = a + b and 并 ...

8. python 高级变量类型（列表/元组/字典/字符串）

   前言 Python 中数据类型可以分为 数字型 和 非数字型 数字型 整型 (int) 浮点型(float) 布尔型(bool) 真 True 非 0 数 -- 非零即真 假 False 0 复数型 ...

9. python列表元组字典集合实验心得_python学习小总结（列表、元组、字典、集合、字符串）...

   ---恢复内容开始--- 一.列表(list) 1.添加 append():追加,在列表末尾添加元素. 列表名.append(添加的元素) extend():扩展,在列表末尾添加元素. 列表名.ext ...

10. python序列类型包括字符串_python序列类型字符串列表元组

    字符串 序列:序号 列 012345678 索引 序列类型,就是带有索引的数据类型:字符串/列表/元祖 name = 'wuhao dsb' # 012345678 name3 = name[0] n ...

最新文章

1. 解题报告 『[NOI2014]起床困难综合症（位运算）』
2. P2085 最小函数值 堆
3. qt中如何模拟按钮点击_qt – 在Windows中模拟鼠标按钮单击
4. .NET 机器学习生态调查
5. npm install 报错 汇总_2020年特岗教师招聘征集志愿人员资格复审、面试公告汇总...
6. python 发邮件_python发邮件
7. C++ Primer Plus学习（十四）——友元、异常和其他
8. oracle 定义变量 查询,Oracle定义PL/SQL变量
9. 【MySQL：查看自己数据库文件所在的位置】
10. 持久层框架的比较Hibernate与 MyBatis
11. Android11.0系统去掉桌面谷歌搜索栏
12. 2018年大数据趋势 ：人工智能… 数据分析将包含可视化模型…
13. power apps 里 嵌套 html
14. stm32正点原子和普中或是野火哪个好？
15. 最后一课——没有拥抱，已成永远
16. 中国生物农药市场投资前景及“十四五”规划建议报告2022-2028年
17. Benchmarking Learned Indexes(VLDB2021)
18. 网络原理之TCP/IP协议
19. 沃森和特朗普：一家伟大美国企业的兴与衰
20. html form 提交json数据格式,表单提交时编码类型enctype详解

热门文章

1. 两连续型随机变量得到复合随机变量的分布函数及密度函数
2. 通过PowerShell启用AADC的密码同步功能
3. 面对强者恒强局面 安防如何运用好资本杠杆？
4. vue+django前后端分离之hippo后端初始化
5. VR城市街景让用户全面地了解城市状况
6. 推荐富士通I2C接口FRAM芯片MB85RC16V
7. JVM中篇：字节码与类的加载篇
8. 密码破解--Ophcrack Rainbow Tables彩虹表原理
9. BJCORE半导体划片机设备——封装的八道工序
10. 你们要的微信红包封面来了