本文详细介绍了Python的高级数据类型，包括列表、元组、字典和字符串的定义、操作及应用场景。列表支持增删改查，如append、insert、remove等；元组不可修改，常用于函数参数和返回值；字典是无序的键值对集合，可用于存储对象信息；字符串提供多种操作，如切片、大小写转换、查找替换等。此外，还涵盖了公共方法如len、del以及成员运算符的使用。
高级变量类型
- 列表
- 元祖
- 字典
- 公共方法
01 列表
列表的定义
list(列表) 是python中使用最频繁的数据类型，在其他语言中通常叫做数组- 专门用于存储一串的信息
- 列表用
[]定义，数据之间使用,分割 - 列表的索引从
0开始- 索引就是数据在列表中的位置编号，索引又可以被称为下标
注意：从列表中取值时，如果超出索引范围，程序为报错
In [1]: name_list = ["zhangsan","lisi","wangwu"]
In [2]: name_list
Out[2]: ['zhangsan', 'lisi', 'wangwu']
# 如果想从列表中拿到我们需要的数据
使用：
列表名[索引编号]
In [3]: name_list[0]
Out[3]: 'zhangsan'
In [4]: name_list[2]
Out[4]: 'wangwu'
In [5]: name_list[1]
Out[5]: 'lisi'
列表常用操作
- 在
ipython3中定义一个列表，例如 :name_list = [] - 输入
name_list.按下TAB键，会提示列表能够使用的方法如下：
In [8]: name_list.
append() count() insert() reverse()
clear() extend() pop() sort()
copy() index() remove()
| 序号 | 分类 | 关键字/函数/方法 | 说明 |
|---|---|---|---|
| 1 | 增加 | 列表.insert(索引，数据) | 在指定位置插入数据 |
列表.append(数据) | 在末尾追加数据 | ||
列表.extend(列表2) | 将列表2的数据追加到列表 | ||
| 2 | 修改 | 列表[索引] = 数据 | 修改指定索引的数据 |
| 3 | 删除 | del 列表[索引] | 删除指定索引的数据 |
列表.remove(数据) | 删除第一个出现的指定数据 | ||
列表.pop() | 删除末尾的数据 | ||
列表.pop(索引) | 删除指定的索引数据 | ||
列表.clear | 清空列表 | ||
| 4 | 统计 | len(列表) | 列表长度 |
列表.count(数据) | 数据在列表中出现的次数 | ||
| 5 | 排序 | 列表.sort | 升序排序 |
列表.sort(reverse) | 降序排序 | ||
列表.reverse() | 逆序、反转 |
列表的增删改查
name_list = ["zhangsan", "lisi", "wangwu"]
# 1. 取值和取索引
print(name_list[0])
# 知道数据的内容，想知道数据在列表中的位置
print(name_list.index("lisi")) # "lisi" 对应的索引编号为 1
# 2. 修改
# 修改列表中的内容
name_list[1] = "李四" # 将列表中 "lisi" 改为了 "李四"
# 3. 增加
# 向已经存在的列表中增加数据
# append 方法可以在列表的末尾追加数据
name_list.append("zhaoliu")
# insert 方法可以在列表指定的位置追加数据
name_list.insert(1,"zhanshanshan")
# extend 方法可以将一个完整的列表数据追加到指定列表的尾部
tmp_list = ["孙悟空", "猪二哥", "沙师弟"]
name_list.extend(tmp_list)
# 4. 删除
# remove 方法可以删除列表中指定的数据
name_list.remove("zhaoliu")
# pop 方法默认会删除列表中最后一项数据
name_list.pop()
# pop 方法还可以删除指定索引编号的数据
name_list.pop(2)
# clear 方法会清空当前列表中的所有数据
name_list.clear()
print(name_list)
del 关键字
del本质上是用来将一个变量从内存中删除的- 如果使用
del关键字将变量从内存中删除，后续的代码就不能使用这个变量了
name = "xiaoming"
del name
print(name)
## 执行代码时会报错，name没有被定义
- 也可使用
del关键字删除列表中的数据- 但是日常开发中建议使用列表中提供的方法
name_list = ["zhangsan", "lisi", "wangwu"]
del name_list[1]
print(name_list)
输出：
['zhangsan', 'wangwu']
列表统计
len(length 长度)函数可以统计列表中元素的总数
name_list = ["zhangsan", "lisi", "wangwu"]
list_len = len(name_list)
print("列表中一共有 %d 个元素" % list_len)
输出：
列表中一共有 3 个元素
count方法可以统计列表中某一个数据出现的次数
name_list = ["zhangsan", "lisi", "wangwu", "lisi"]
count = name_list.count("lisi")
print("\"lisi\"出现了 %d 次" % count)
输出：
"lisi"出现了 2 次
# 现在列表中有两个 lisi ，如果现在删除列表中的 lisi 会删除第一个出现的数据
name_list = ["zhangsan", "lisi", "wangwu", "lisi"]
name_list.remove("lisi")
print(name_list)
输出：
['zhangsan', 'wangwu', 'lisi'] # 第一个 lisi 果然被删除了
排序
升序：
name_list = ["zhangsan", "lisi", "wangwu", "zhaoliu"]
num_list = [5,6,2,3,8,1]
name_list.sort() # sort默认升序
num_list.sort()
print(name_list)
print(num_list)
输出：
['lisi', 'wangwu', 'zhangsan', 'zhaoliu'] # 已按照字母升序排序
[1, 2, 3, 5, 6, 8]
降序：
name_list = ["zhangsan", "lisi", "wangwu", "zhaoliu"]
num_list = [5,6,2,3,8,1]
name_list.sort(reverse=True) # sort里参数指定reverse=True降序
num_list.sort(reverse=True)
print(name_list)
print(num_list)
输出：
['zhaoliu', 'zhangsan', 'wangwu', 'lisi']
[8, 6, 5, 3, 2, 1]
反转：
# 反转就是将列表中的数据从头到尾颠倒顺序排列
num_list = [5,6,2,3,8,1]
num_list.reverse()
print(num_list)
输出：
[1, 8, 3, 2, 6, 5]
循环遍历
- 遍历就是从头到尾依次从列表中获取数据
- 在循环体内部针对每一个元素，执行相同的操作
- 在
python中为了提高列表的遍历效率，专门提供的迭代iteration遍历 - 使用
for就能够实现迭代遍历
for 的基本语法格式：
for 循环体内部使用的变量 in 列表
循环体内部对列表元素进行操作
print(name)
name_list = ["zhangsan", "lisi", "wangwu"]
for my_name in name_list:
print("我的名字叫 %s" % my_name)
输出：
我的名字叫 zhangsan
我的名字叫 lisi
我的名字叫 wangwu
应用场景
- 尽管
python的列表中可以存储不同类型的数据 - 但是在开发中，更多的应用场景是
- 列表存储相同类型的数据
- 通过迭代遍历，在循环体内部，针对列表中的每一项元素，执行相同的操作
02 元祖
元祖的定义
-
Tuple(元祖) 与列表类似，不同之处在于元祖的元素不能修改- 元祖表示多个元素组成的序列
- 元祖在
python开发中、有特定的应用场景
-
用于存储一串信息，数据之间使用
，分隔 -
元祖用
()定义 -
元祖的索引从
0开始- 索引就是数据在元祖中的位置编号
In [1]: info_tuple = ("zhangsan", 18, 1.75) In [2]: type(info_tuple) Out[2]: tuple In [3]: info_tuple Out[3]: ('zhangsan', 18, 1.75) # 从元祖中获取数据与列表的使用相同 In [4]: info_tuple[0] Out[4]: 'zhangsan' In [5]: info_tuple[2] Out[5]: 1.75创建空元祖
In [6]: empty_tuple = () In [7]: empty_tuple Out[7]: () 元祖中只包含一个元素时，需要在元素后面添加逗号
In [12]: singe_tuple = (4,) In [13]: type(singe_tuple) Out[13]: tuple ## 如果没加逗号会是int类型
元祖常用操作
- 在
ipython3中定义一个元祖info = () - 在输入
info.按下TAB键，ipython会提示元祖能够使用的函数
In [14]: info = ()
In [15]: info.
count() index()
取值取索引和统计
info_tuple = ("zhangsan", 18, 1.75)
# 取值
print(info_tuple[0]) ## 输出：zhangsan
# 取索引
print(info_tuple.index("zhangsan")) ## 输出：0
# 统计计数
print(info_tuple.count(18)) ## 输出：1
# 统计元祖中包含有多少个元素
print(len(info_tuple)) ## 输出：3
循环遍历
- 取值就是从元祖中获取的存储在指定位置的数据
- 遍历就是从头到尾依次从元祖中获取数据
for 循环内部使用的变量 in 元祖：
循环体内部针对元素进行操作
print(xxx)
- 在
Python中，可以使用for循环遍历所有非数字类型的变量：列表、元祖、字典、以及 字符串- 提示：在实际开发中，除非能够确认元祖中的数据类型，否则针对元祖的循环遍历需求并不是很多
- 因为元祖保存的数据类型是不一样的，所以对它们进行相同的操作是不方便的
my_tuple = ("zhangsan", 18, 1.75)
for my_info in my_tuple:
print(my_info)
应用场景
- 尽管可以使用
for in遍历元祖 - 但是在开发中，更多应用场景是：
- 函数的参数和返回值，一个函数可以接受任意多个参数，或者一次返回多个数据
- 格式字符串，格式化字符串后面的
()本质上就是一个元祖 - 让列表不可以被修改，以保护数据安全
## 格式字符串，格式化字符串后面的`()` 本质上就是一个元祖
print("%s 的年龄是 %d 身高是 %.2f" % ("小明", 18, 1.75))
输出：
小明 的年龄是 18 身高是 1.75
info_tuple = ("小明", 18, 1.75)
print("%s 的年龄是 %d 身高是 %.2f" % info_tuple)
输出：
小明 的年龄是 18 身高是 1.75
## 使用格式化字符串可以拼接成一个新的字符串变量
info_tuple = ("小明", 18, 1.75)
info_str = "%s 的年龄是 %d 身高是 %.2f" % info_tuple
print(info_str)
输出：
小明 的年龄是 18 身高是 1.75
元祖列表之间的转换
-
使用
list函数可以把元祖转换成列表list(元祖) -
使用
tuple函数可以把列表转换成元祖tuple(列表)
In [1]: num_list = [1,3,5,7]
In [2]: num_tuple = tuple(num_list)
In [3]: type(num_tuple)
Out[3]: tuple
In [4]: num2_list = list(num_tuple)
In [5]: type(num2_list)
Out[5]: list
03 字典
字典的定义
dictionary（字典）是除了列表以外python之中最灵活的数据类型- 字典同样可以用来存储多个数据
- 通常用于存储描述一个物体的相关信息
- 和列表的区别
- 列表是有序的对象集合
- 字典是无序的对象集合
- 字典用
{}定义 - 字典使用键值对存储数据，键值之间使用
,分隔- 键
key是索引 - 键
value是数据 - 键和值之间使用
:分隔 - 键必须是唯一的
- 值可以取任何数据类型，但键只能使用字符串、数字或元祖
- 键
# 字典是一个无序的数据集合
# print函数在输出字典时，顺序和定义的顺序是不一致的
xiaoming = {"name": "小明",
"age": 18,
"height": 1.75,
"weight": 75,
"gender": True}
print(xiaoming)
字典的常用操作
- 在
ipython3中定义一个空字典xiaoming = {} - 输入
xiaoming.按下TAB键，ipython会提示字典能够使用的函数如下：
In [8]: xiaoming = {}
In [9]: xiaoming.
clear() get() pop() update()
copy() items() popitem() values()
fromkeys() keys() setdefault()
增删改查
xiaoming_dict = {"name": "小明"}
## 1. 取值
print(xiaoming_dict["name"]) # 会取出name对应的值"小明"
## 2. 增加/修改
# 如果key不存在会新增key
xiaoming_dict["age"] = 18
# 如果key存在会修改已存在的键值对
xiaoming_dict["name"] = "小小明" # name的值会被修改为"小小明"
## 3. 删除
xiaoming_dict.pop("name") # 删除 "name" 这个key
其他操作
xiaoming_dict = {"name": "小明",
"age": 18}
## 1. 统计键值对的数量
print(len(xiaoming_dict))
## 2. 合并字典
# 如果被合并的字典中包含已存在的键值对时，会覆盖原有的键值对
tmp_dict = {"height": "1.75",
"age": 20}
xiaoming_dict.update(tmp_dict)
## 3. 清空字典
xiaoming_dict.clear()
print(xiaoming_dict)
循环遍历
- 遍历就是依次从字典中获取所有键值对
xiaoming_dict = {"name": "小明",
"qq": "123456",
"phone": "110"}
# 变量k是每一次循环中获取到的键值对的key
for k in xiaoming_dict:
print("%s: %s" % (k, xiaoming_dict[k]))
提示：在实际开发中，由于字典中每一个键值对保存数据类型是不同的，所以针对字典的循环遍历需求并不是很多
应用场景
- 尽管可以使用
for in遍历字典 - 但是再开发中，更多的应用场景是：
- 使用多个键值对，存储描述一个物体的相关信息
- 将多个字典放在一个列表中、再进行遍历，在循环体内部针对每一个字典进行相同的处理
# 使用多个键值对，存储描述一个物体的相关信息
# 将多个字典放在一个列表中、再进行遍历，在循环体内部针对每一个字典进行相同的处理
card_list = [
{"name": "张三",
"qq": "1234567",
"phone": "1010"},
{"name": "李四",
"qq": "1538846",
"phone": "10086"}
]
for card_info in card_list:
print(card_info)
输出：
{'name': '张三', 'qq': '1234567', 'phone': '1010'}
{'name': '李四', 'qq': '1538846', 'phone': '10086'}
04 字符串
字符串的定义
-
字符串就是一串字符，是编程语言中表示文本的数据类型
-
在
python中可以使用一对双引号""或者使用一对单引号''定义一个字符串-
虽然可以使用
\"或者\'做字符串的转义，但是在实际开发中- 如果字符串内部需要使用
""，可以使用''定义字符串 - 如果字符串内部需要使用
''，可以使用""定义字符串
- 如果字符串内部需要使用
-
-
也可以使用索引获取一个字符串中指定位置的字符，索引计数从 0 开始
-
也可以使用
for循环遍历 字符串中每一个字符
大多数编程语言都是用
""来定义字符串
# 单引号内部使用双引号
print('我的外号是"大西瓜"')
# 双引号内部使用单引号
print("我的外号是'大西瓜'")
# 取字符串内部的内容
str = "hello python"
print(str[6])
# 字符串的循环遍历，依次取出字符串内的每一个字符
str = "hello python"
for char in str:
print(char)
字符串常用操作
-
在
ipython3中定义一个字符串，例如：hello_str = "" -
输入
hello_str.按下TAB键会提示字符串能够使用的方法如下：In [1]: hello_str = "hello hello" In [2]: hello_str. capitalize() expandtabs() isalpha() isprintable() lower() rindex() splitlines() upper() casefold() find() isdecimal() isspace() lstrip() rjust() startswith() zfill() center() format() isdigit() istitle() maketrans() rpartition() strip() count() format_map() isidentifier() isupper() partition() rsplit() swapcase() encode() index() islower() join() replace() rstrip() title() endswith() isalnum() isnumeric() ljust() rfind() split() translate()hello_str = "hello hello" # 统计字符串长度 print(len(hello_str)) # 统计某一个小(子)字符串出现的次数 print(hello_str.count("llo")) print(hello_str.count("abc")) # 统计不存在的字符串时，不会报错，而是输出0次 # 某一个子字符串出现的位置 print(hello_str.index("llo"))
1) 判断类型
| 方法 | 说明 |
|---|---|
string.isspace() | 如果string中只包含空格，则返回 True |
string.isnumeric() | 如果 string 至少有一个字符并且所有字符都是数字则返回 True |
string.isalpha() | 如果 string 至少有一个字符并且所有字符都是字母则返回 True |
string.isdecimal() | 如果 string 只包含数字则返回 True ，全角数字 |
string.isdigit() | 如果 string 只包含数字则返回 True 全角数字、(1)、\u00b2 |
string.isnumeric() | 如果 string 只包含数字则返回 True 全角数字，汉子数字 |
string.istitle() | 如果 string 是标题化的(每个单词的首字母大写)则返回 True |
string.islower() | 如果 string 中至少包含一个区分大小写的字符并且所有这些(区分大小写的)字符都是小写，则返回 True |
string.isupper() | 如果 string 中包含至少一个区分大小写的字符并且所有这些(区分大小写的)字符都是大写，则返回 True |
2) 查找和替换
| 方法 | 说明 |
|---|---|
srting.startswith(str) | 检查字符串是否是以 str 开头，是则返回 True |
string.endswith(str) | 检查字符串是否是以 str 结束，是则返回 True |
string.find(str,start=0,end=len(string)) | 检查 str 是否包含在 string 中，如果 start 和 end 指定范围则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回 -1 |
string.rfind(str,start=0,end=len(string)) | 类似于 find 函数，不过是从右边开始查找 |
string.index(str,start=0,end=len(string)) | 跟 find 函数类似，不过如果 str 不存在 string 会报错 |
string.rindex(str,start=0,end=len(string)) | 类似 index()，不过是从右边开始 |
string.replace(old_str,new_str,num=string.count(old)) | 把 string 中的 old_str 替换成 new_str，如果 num 指定，则替换不超过 num 次 |
3) 大小写转换
| 方法 | 说明 |
|---|---|
string.capitalize() | 把字符串的第一个字符大写 |
string.title() | 把字符串的每个单词首字母大写 |
string.lower() | 转换 string 中所有大写字符为小写 |
string.upper() | 转换 string 中的小写字母为大写 |
string.swapcase() | 反转 string 中的大小写 |
4) 文本对齐
| 方法 | 说明 |
|---|---|
string.ljust(width) | 返回一个原字符串左对齐，并使用空格填充至长度 width 的新字符串 |
string.rjust(width) | 返回一个原字符串右对齐，并使用空格填充至长度 width 的新字符串 |
string.center(width) | 返回一个原字符串居中，并使用空格填充至长度 width 的新字符串 |
5) 去除空白字符
| 方法 | 说明 |
|---|---|
string.lstrip() | 卸掉 string 左边（开始）的空白字符 |
string.lstrip() | 卸掉 string 右边（末尾）的空白字符 |
string.strip() | 卸掉 string 左右两边的空白字符 |
6) 拆分和连接
| 方法 | 说明 |
|---|---|
string.partition(str) | 把字符串 string 分成一个 3 元素的元祖（str前面，str，str后面） |
string.rpartition(str) | 类似于 partition() 函数，不过是从右边开始查找 |
string.split(str="",num) | 以 str 为分隔符切片 string，如果 num 有指定值，则仅显示 num + 1个字符串str 默认包含 '\r','\t','\n' 和空格 |
string.splitlines() | 按照行 ('\r','\n','\r\n') 分隔，返回一个包含各行作为元素的列表 |
string.join(seq) | 以 string 作为分隔符，将 seq 中所有的元素（的字符串表示）合并为一个新的字符串 |
字符串方法使用
判断方法演练：
# isspace空白字符判断
# 使用isspace方法不仅可以判断空白字符还可以判断\t\n\r
space_str = " " 也可以：space_str = " \t\r\n"
print(space_str.isspace())
输出：True
# 判断字符串是否只有数字组成
test_str = "21325"
print(test_str.isnumeric())
输出：True
# 判断字符串是否只有英文字母组成
# 如果字符串至少有一个字符并且所有字符都是字母则返回 `True`
test_str = "hello"
print(test_str.isalpha())
输出：True
test_str = "hello word" # 同样不能出现其他任何字符
# isdecimal，isdigit，isnumeric都是判断是否只包含数字的
num_str = "1" #判断数字三个都可以实现，小数都不能实现
print(num_str) ：1
print(num_str.isdecimal()) ：True
print(num_str.isdigit()) ：True
print(num_str.isnumeric()) ：True
num_str = "\u00b2"
print(num_str.isdecimal()) ：FALSE
print(num_str.isdigit()) ：True #isdigit支持Unicode字符串
print(num_str.isnumeric()) ：True #isnumeric也支持Unicode字符串
num_str = "一千"
print(num_str.isdecimal()) ：FALSE
print(num_str.isdigit()) ：FALSE
print(num_str.isnumeric()) ：True #只有isnumeric支持中文数字
# 是标题化的(每个单词的首字母大写)则返回 `True`
test_str = "Hello World" ：True
test_str = "Hello world" ：Flase
test_str = "HelloWorld" ：Flase
test_str = "Helloworld" ：True
print(test_str.istitle())
# 字符串中包含的字母都是小写字母
test_str = "hellowo,,??rld dfsd1564"
print(test_str.islower()) ：True
# 字符串包含的字母都是大写字母
test_str = "456,,..??GDS"
print(test_str.isupper()) ：True
查找和替换:
hello_str = "hello world"
# 1. 判断是否以指定的字符串开始
print(hello_str.startswith("hello")) ：True
# 2. 判断是否以指定的字符串结束
print(hello_str.endswith("rld")) ：True
# 3. 查找指定的字符串
# 使用index方法也可以查找出指定的字符串的索引
print(hello_str.find("llo")) ：2
print(hello_str.index("llo")) ：2
# 使用find方法查找不存在的字符串时，不会报错而是返回-1，index则回报错
print(hello_str.find("abc")) ：-1
# 4. 替换字符串
# replace方法执行完成之后会返回一个新的字符串
# 注意：replace方法不会修改原来的字符串
print(hello_str.replace("world", "python")) ：hello python
print(hello_str) ：hello world
大小写转换
# capitalize 方法把字符串的第一个字符大写
hello_str = "hello world"
print(hello_str.capitalize()) :Hello world
# title 方法把字符串的每个单词首字母大写
print(hello_str.title()) :Hello World
# lower 方法转换字符串中所有大写字符为小写
test_str = "HELLO WORLD"
print(test_str.lower()) :hello world
# upper方法转换字符串中的小写字母为大写
test2_str = "hello world"
print(test2_str.upper()) :HELLO WORLD
# swapcase 方法反转字符串中的大小写
test3_str = "AAbb"
print(test3_str.swapcase()) :aaBB
文本对齐
# 使用center居中对齐：
poetry = ["春晓",
"孟浩然",
"春眠不觉晓",
"处处闻啼鸟",
"夜来风雨声",
"花落知多少"]
for i in poetry:
print("|%s|" % i.center(10, " "))
输出：
| 春晓 |
| 孟浩然 |
| 春眠不觉晓 |
| 处处闻啼鸟 |
| 夜来风雨声 |
| 花落知多少 |
# 使用ljust左对齐
|春晓 |
|孟浩然 |
|春眠不觉晓 |
|处处闻啼鸟 |
|夜来风雨声 |
|花落知多少 |
# 使用rjust右对齐
| 春晓|
| 孟浩然|
| 春眠不觉晓|
| 处处闻啼鸟|
| 夜来风雨声|
| 花落知多少|
去除空白字符
# 就以上面居中显示的一首诗为例，我们加一下空白字符
poetry = ["\t\n春晓",
"孟浩然",
"春眠不觉晓\t",
"处处闻啼鸟\t\n",
"夜来风雨声",
"花落知多少"]
for i in poetry:
print("|%s|" % i.rjust(10, " "))
输出的结果为：
|
春晓|
| 孟浩然|
| 春眠不觉晓 |
| 处处闻啼鸟
|
| 夜来风雨声|
| 花落知多少|
# 这个时候我们只需要调整一下代码，先去除空白字符，然后居中打印
print("|%s|" % i.strip().center(10, " "))
改好之后输出结果为：
| 春晓 |
| 孟浩然 |
| 春眠不觉晓 |
| 处处闻啼鸟 |
| 夜来风雨声 |
| 花落知多少 |
拆分和连接
# 首先定义一个参差不齐的字符串
num = "1\n2\t3\t4\t5\r\n6\n7\n8\t9"
print(num)
# 通过split方法拆分字符串为一个字符串列表
num_list = (num.split())
print(num_list) 输出： ['1', '2', '3', '4', '5', '6', '7', '8', '9']
# 使用 join 方法将字符串列表合并为一个整齐的字符串
result = " ".join(num_list)
print(result)
最后输出：
1 2 3 4 5 6 7 8 9
字符串的切片
- 切片方法适用于 字符串、列表、元祖
- 切片使用索引值来限定范围，从一个大的字符串中切出小的字符串
- 列表和元祖都是有序的集合，都能够通过索引值获取到对应的数据
- 字典是一个无序的集合，是使用键值对保存数据
字符串[开始索引:结束索引:步长]
字符串切片演练：
定义一个字符串 num_str = "0123456789"
1. 截取从 2~5 位置的字符串
In [2]: num_str[2:6]
Out[2]: '2345'
2. 截取从 2~末尾 的字符串
In [3]: num_str[2:]
Out[3]: '23456789'
3. 截取从 开始~5 位置的字符串
In [4]: num_str[:6]
Out[4]: '012345'
4. 截取完整的字符串
In [5]: num_str[:]
Out[5]: '0123456789'
5. 从开始位置，每隔一个字符截取字符串
In [6]: num_str[::2]
Out[6]: '02468'
6. 从索引 1 开始，每隔一个取一个
In [7]: num_str[1::2]
Out[7]: '13579'
7. 截取从 2~末尾-1 的字符串
In [8]: num_str[2:-1]
Out[8]: '2345678'
8. 截取字符串末尾两个字符
In [9]: num_str[-2:]
Out[9]: '89'
9. 字符串的逆序
In [10]: num_str[::-1]
Out[10]: '9876543210'
05 公共方法
Python内置函数
Python 包含了以下内置函数：
| 函数 | 描述 | 备注 |
|---|---|---|
len(item) | 计算容器中元素个数 | |
del(item) | 删除变量 | del 有两种方式 |
max(item) | 返回容器中元素最大值 | 如果是字典，只针对 key 比较 |
min(item) | 返回容器中元素最小值 | 如果是字典，只针对 key 比较 |
cmp(item1,item2) | 比较两个值 | python3.x取消了cmp函数 |
注意：
- 字符串比较符合以下规则：
"0"<"A"<"a"
切片
| 描述 | Python表达式 | 结果 | 支持的数据类型 |
|---|---|---|---|
| 切片 | “0123456789”[::-2] | "97531" | 字符串、列表、元祖 |
- 切片使用索引值来限定范围，从一个大的字符串中切出小的字符串
- 列表和元祖都是有序的集合，都能够通过索引值获取到对应的数据
- 字典是一个无序的集合，是使用键值对保存数据
- 字典没有索引值的概念所以字典不支持切片
# 字符串切片
In [3]: "0123456789"[2:9:2]
Out[3]: '2468'
# 列表和元祖切片
In [4]: [1,2,3,4,5][::-2]
Out[4]: [5, 3, 1]
In [5]: (1,2,3,4,5)[::-1]
Out[5]: (5, 4, 3, 2, 1)
运算符
| 运算符 | Python表达式 | 结果 | 描述 | 支持的数据类型 |
|---|---|---|---|---|
+ | [1,2]+[3,4] | [1,2,3,4] | 合并 | 字符串、列表、元祖 |
* | ["hi"]*4 | ['hi', 'hi', 'hi', 'hi'] | 重复 | 字符串、列表、元祖 |
in | 3 in [1,2,3] | True | 元素是否存在 | 字符串、列表、元祖、字典 |
not in | 4 not in (1,2,3) | True | 元素是否不存在 | 字符串、列表、元祖、字典 |
> >= == < <= | (1,2,3)<(2,2,3) | True | 元素比较 | 字符串、列表、元祖 |
注意：
in在对字典操作时，判断的是字典的键in和not in被称为成员运算符
成员运算符
成员运算符用于测试序列中是否包含指定的成员
| 运算符 | 描述 | 实例 |
|---|---|---|
in | 如果在指定的序列中找到值返回True，否则返回False | 3 in (1, 2, 3)返回True |
not in | 如果在指定的序列中没有找到值返回True，否则返回False | 3 not in (1, 2, 3)返回False |
注意：在对字典操作时，判断的是字典的键
完整的 for 循环语法
- 在
python中完整的for 循环的语法如下：
for 变量 in 集合：
循环体代码
else：
没有通过break退出循环，循环结束后，会执行的代码
num = [1, 2, 3, 4]
for i in num:
print(i)
if i == 3:
break # 如果循环体内部使用过break退出了循环
else: # else下方的代码就不会执行
print("else执行的时机")
print("循环结束")
应用场景
- 在迭代遍历嵌套的数据类型时，例如一个列表包含了多个字典
- 需求：要判断某一个字典中是否存在指定的值
- 如果存在，提示并且退出循环
- 如果不存在，在循环整体结束后，希望得到一个统一的提示
# 在列表中搜索指定学生的所有信息
student_list = [{"name": "张三",
"age": 20,
"gender": True,
"height": 1.7,
"weight": 70},
{"name": "李四",
"age": 19,
"gender": False,
"height": 1.75,
"weight": 60},
]
for k in student_list:
print(k)
find_name = "张三"
if k["name"] == find_name:
print("找到了%s" % find_name)
break
else:
print("抱歉%s没有找到" % find_name)
扫一扫
159
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
