python从入门到精通（二）：列表、元组、字典、集合、字符串

第十一章：列表

（一）学习架构

• 列表
• 元组
• 字典
• 字符串
• 公共方法
• 变量高级

在Python 中定义变量是不需要指定类型(在其他很多高级语言中都需要), 数据类型可以分为 数字型 和 非数字型

数字型

1. 整型(int)

	在这里提示在Python2.x中，整数根据保存数值的长度还分为
	int（整数）
	long（长整数）

1. 浮点型 (float )

2. 布尔型 (bool)

   真 True 非0数--非零即真
   假 False0
   

3. 复数型(complex)

   主要用于科学计算，例如:平面场问题、波动问题、电感电容等问题
   

非数字型

。字符串
。列表
。元组
。字典

在Python 中，所有非数字型变量都支持以下特点:

1. 都是一个序列sequence，也可以理解为容器
2. 取值 [ ]
3. 遍历 for in
4. 计算长度、最大/最小值、比较、删除
5. 链接+和重复*
6. 切片

（二）列表的定义

• List(列表)是Python 中使用最频繁的数据类型，在其他语言中通常叫做数组
• 专门用于存一串信息
• 列表使用符号<kbd>[ ]</kbd> 定义，数据之间使用，逗号分隔
• 列表的索引从0开始 。索引就是数据在列表中的位置编号，索引又可以被称为下标
• 注意:从列表中取值时，如果超出索引范围，程序会报错
• 列表（list）是一个有序且可更改的序列，允许重复

列表的语法格式：

name_list = ["liyue","wangwei","hezhizhang"]

name_list = list("liyue")

列表的切边
列表的索引代表了列表里的值，索引从0开始，所以获取第一个人的名字，应该使用name_list[0]
也可以反向索引，最后一个元素的索引为 -1，往前一位为 -2

列表的切片 listname[start:end:step]， step 表示步长 

a = [1,2,3,4,5,6,7,8,9]
a = [1,2,3,4,5,6,7,8,9]
print(a[0])
print(a[-5])
print(a[0:4])
print(a[0:5])
print(a[0:5:2])
print(a[0:])
print(a[:-1])
print(a[:])

（三）列表的基础操作

1.列表的组合

使用 + 将多个列表合并：

a = ["h", "e", "l", "l", "o"]
b = ["w", "o", "r", "l", "d"]
c = a + b
print(c)

2.列表的重复

使用 * 将列表重复打印：

a = ["h", "e", "l", "l", "o"]
print(a*3)

3.列表的长度

Python 中可以使用 len 函数查看列表长度，语法格式为：len(listname)

a = ["h", "e", "l", "l", "o"]
print(len(a))

4.返回列表中元素最小值和最大值

Python 中可以分别使用 max 函数和 min 函数查看列表中元素的最大值和最小值，语法格式为：max(listname)，min(listname)

a = [1,2,3,4,5,6,7,8,9]
print(max(a))
print(min(a))

5.返回列表中元素的总和

Python 中可以使用 sum 函数返回列表各元素的总和，语法格式为：sum(listname)

a = [1,2,3,4,5,6,7,8,9]
print(sum(a))

（四）列表进阶的操作

1.取值和取索引

name_list = ["liyue","wangwei","hezhizhang"]
# 取值  
# list index out of range - 列表索引超出范围，程序报错！
print(name_list[1])
# 知道数据的内容，想确定数据在列表中的位置
# 使用index方法需要注意，如果传递的数据不在列表中，程序会报错!
print(name_list.index("liyue"))

2.修改列表某个元素的值

name_list = ["liyue","wangwei","hezhizhang"]
name_list[1] = "lisi"
# list assignment index out of range
# 列表指定的索引超出范围,I程序会报错!
name_list[3] = "zhaoliu"   
print(name_list)

3.列表中增加数据

name_list = ["liyue","wangwei","hezhizhang"]
# append向列表末尾追加数据
name_iist.append("zhaoliu")
# insert向指定索引位置插入数据
name_list.insert(1,"xiaomeimei")
# extend扩展将另一个列表的数据追加到列表末尾
temp_list = ["孙悟空","猪八戒","沙师弟"]
name_list.extend(temp_list)

4.删除列表中的某个数据
提示: 在日常开发中，要从列表删除数据，建议使用列表提供的方法，不使用del

name_list = ["liyue","wangwei","hezhizhang","wangwu"]
# remove 从列表删除指定的数据
name_list.remove("wangwu")
# pop 默认删除最后一个元素
name_list.pop()
# pop删除指定索引位置的数据
name_list.pop(3)
# clear删除列表全部元素
name_list.clear()
# del 删除列表中指定数据
# del 本质是将一个变量从内存中删除
# 注意: 如果使用 del 关键字将变量从内存中删除# 后续的代码就不能再使用这个变量了
del name_list[1]

5.统计列表中的元素

name_list = ["zhangsan","liyue","wangwei","hezhizhang","zhangsan"]
# len统计列表中有多少个元素
list_len = len(name_list)
print(f"列表中共有{list_len}个函数")
# count统计列表中某个元素出现的次数
count = name_list.count("zhangsan")
print(f"列表中共有{count}个张三")
# remove 删除列表中第一次出现的数据
name_list.remove("zhangsan")

6.排序列表中的元素

name_list = ["zhangsan", "liyue", "wangwei", "hezhizhang", "zhangsan"]
num_list = [6, 8, 4, 1, 9, 10]
# sort 将列表中的元素按照升序排列
name_list.sort()
num_list.sort()
# sort 将列表中的元素降序排列 recerse将排序过的数据反转就是相反顺序的排列
name_list.sort(reverse=True)
num_list.sort(reverse=True)
# 逆序排列 反转列表从后往前输出
name_list.reverse()
num_list.reverse()

print(name_list)
print(num_list)

7.列表的嵌套

a = [[10, 20, 30], ["q", "w"], ["d", 1]]
print(a[0])

（五）列表的for循环遍历

遍历就是从头到尾依次从列表中获取数据
在循环体内部针对每一个元素，执行相同的操作
在Python 中为了提高列表的遍历效率，专门提供的迭代iteration 遍历
使用for就能够实现迭代遍历

for循环的语法格式：

for 循环内部使用的变量 in 列表:
	循环内部针对元素操作
	print
for name in name_list:
	循环内部针对列表元素的操作
	print(name)

name_list = ["zhangsan", "liyue", "wangwei", "hezhizhang", "zhangsan"]
"""
顺序的从列表中依次获取数据，每一次循环过程中，数据都会保存在name这个变量中，
在循环体内部可以访问到当前这一次获取到的数据
"""
for name in name_list:
    print(name)

（六）列表的应用场景

尽管Python的列表中可以存储不同类型的数据但是在开发中，更多的应用场景是
1.列表存储相同类型的数据
2.通过选代遍历，在循环体内部，针对列表中的每一项元素，执行相同的操作

第十二章：元组

（一）元组的定义

Tuple (元组)与列表类似，不同之处在于元组的元素不能修改

• 元组 表示多个元素组成的序列
• 用于存储一串信息，元组使用符号<kbd>( )</kbd>定义，数据之使用，逗号分隔
• 元组的索引从0开始 索引就是数据在元组中的位置编号
• 元组（tuple）是一个有序且不可更改的集合，允许重复
• 元组一旦被创建，它的元素就不可更改了，所以元组是不可变序列

元组创建的语法格式：

info_tuple = ("zhangsan",18,17.5)

创建空元组

info_tuple = ()

创建一个元素的元组

info_tuple = (5,)

使用内置函数tuple

info_tuple = tuple("hello")

（二）元组的索引

与字符串和列表的索引一样，元组正向索引从 0 开始，第二个索引是 1，依此类推；也可以反向索引，最后一个元素的索引为 -1，往前一位为 -2，以此类推。

name_list = ("zhangsan", "liyue", "wangwei", "hezhizhang", "zhangsan")

1.元组的访问

info_tuple[0]

2.元组的截取

print(name_list[0])
print(name_list[-5])
print(name_list[0:4])
print(name_list[0:5])
print(name_list[0:5:2])

（三）元组的基础操作

1.元组的长度

使用 len 函数可以获取元组的长度：

name_list = ("zhangsan", "liyue", "wangwei", "hezhizhang", "zhangsan")
print(len(name_list))

元组的复制

使用 * 可以对元组进行复制：

name_list = ("zhangsan", "liyue", "wangwei", "hezhizhang", "zhangsan")
print(name_list * 2)

3.判断元组中是否存在某元素

使用 in 可以判断元组中是否存在某元素，如果存在，返回 True，如果不存在，返回 False。

name_list = (1, 2, "a", "b")
print(1 in name_list)
print(3 in name_list)

（四）元组的常用操作

取值和取索引

name_list = ("zhangsan", "liyue", "wangwei", "hezhizhang", "zhangsan")
# 1.取值和取索引
print(name_list[1])
# 根据内容查找内容的位置
print(name_list.index("wangwei"))

统计计数

# 统计元组中zhangsan出现的次数
print(name_list.count("zhangsan"))
# 统计元组中出现的元素的个数
print(len(name_list))

元组的修改
1.对元组变量进行重新赋值

name_list = ("zhangsan", "liyue", "wangwei", "hezhizhang", "zhangsan")
name_list = ("heigou", "dagou", "sigou", "mugou", "gonggou")
print(name_list)

2.通过连接多个元组的方式向元组中添加新元素

name_list1 = ("zhangsan", "liyue", "wangwei", "hezhizhang", "zhangsan")
name_list2 = ("heigou", "dagou", "sigou", "mugou", "gonggou")
name_list3 = name_list2 + name_list1

元组的删除
当创建的元组不再使用时，可以通过 del 关键字将其删除，语法格式为：del tuplename，元组被删除后，输出变量会有异常信息。

name_list1 = ("zhangsan", "liyue", "wangwei", "hezhizhang", "zhangsan")
del name_list1
print(name_list1)
NameError: name 'name_list1' is not defined

（四）元组的循环遍历

• 取值就是从元组中获取存储在指定位置的数据
• 遍历就是从头到尾依次从元组中获取数据

for 循环内部使用的变量 in 列表:
	循环内部针对元组操作
	print
for item in name_list:
	循环内部针对元组元素的操作
	print(item)

在Python 中，可以使用for 循环遍历所有非数字型类型的变量:列表、元组、字典以及字符串
提示:在实际开发中，除非能够确认元组中的数据类型，否则针对元组的循环遍历需求并不是很多

name_list1 = (1, 2, 3,"a", "b")
for i in name_list1:
    print(i, end="\t")

（五）元组的应用场景

尽管可以使用 for in 遍历元组，但是在开发中，更多的应用场景是

• 函数的参数和返回值，一个函数可以接收 任意多个参数，或者 一次返回多个数据
• 有关函数的参数和返回值，在后续 函数高级给大家介绍
• 格式字符串，格式化字符串后面的()本质上就是一个元组
• 让列表不可以被修改，以保护数据安全

格式字符串，格式化字符串后面的()本质上就是一个元组

info_tuple = ("小明",18,1.75)
print("我的名字叫 %s 年龄 %d 身高%.2f" % ("小明",18,1.75))
# 实际上也可以这么写,证明格式化字符串后面的是个元组
print("我的名字叫 %s 年龄 %d 身高%.2f" % info_tuple)
#元组可以拼接字符串组成新的字符串
info_str = "我的名字叫 %s 年龄 %d 身高%.2f" % info_tuple
print(info_str)

（六）元组和列表之间的转换

让列表不可以被修改，以保护数据安全

• 使用list函数可以把元组转换成列表

list(元组)

• 使用 tuple 函数可以把列表转换成元组

tuple(列表)

num_list = [1,2,3,4,5,6,7,8,9]
print(num_list)
print(type(num_list))
num_tuple = tuple(num_list)
print(num_tuple)
print(type(num_tuple))
num1_list = list(num_tuple)
print(num1_list)
print(type(num1_list))

第十三章：字典

dictionary (字典) 是除列表以外Python 之中 最灵活的数据类型，字典同样可以用来存储多个数据，通常用于存储 描述一个物体 的相关信息

和列表的区别

• 列表是有序的对象集合
• 字典是无序的对象集合

（一）字典的定义

字典用符号<kbd>{ }</kbd>定义
字典中每个元素都包含两部分，分别是键（key）和值（value），因此在创建字典时，键和值之间使用冒号<kbd> : </kbd>分隔，相邻元素之间使用逗号 <kbd>, </kbd>分隔，

• 键key 是索引
• 值value 是数据
• 键和值之间使用<kbd>:</kbd>分隔
• 键必须是唯一的
• 值可以取任何数据类型，但键只能使用字符串、数字或元组

字典的语法格式：

my_dict = {"key":"value".....}
xiaming = {"name":"xiaoming","age":18,"height":185,"gender":True}

通过 dict 函数创建字典

demo1 = [('two', 2), ('one', 1), ('three', 3)]
demo2 = [['two', 2], ['one', 1], ['three', 3]]
dict(demo1)
dict(demo2)

字典是一个无序的数据集合，使用print函数输出字典时，通常输出的顺序和定义的顺序是不一致的!

（二）字典的基础操作

1.字典的访问

dict1["name"]

2.get 函数访问
当指定的键不存在时，get 函数不会抛出异常和报错会返回 None

dict1.get("name")

（三）字典的常用操作

xiaoming_dict = {"name":"xiaoming","age":18,"height":185,"gender":True}
# 1.取值
print(xiaoming_dict["name"])
# 取值不存在时会报错！
print(xiaoming_dict["name123"])

# 2.增加字典内容，如果key不存在就是新增
xiaoming_dict["weight"] = 195

# 3.修改字典内容，如果key存在就是修改
xiaoming_dict["weight"] = 175

# 3.删除
xiaoming_dict.pop("name")

print(xiaoming_dict)

xiaoming_dict = {"name":"xiaoming","age":18,"height":185,"gender":True}

# 1.统计键值对数量
print(len(xiaoming_dict))

# 2.合并字典
temp_dict = {"weight":175}
#注意: 如果被合并的字典中包含已经存在的键值对，会覆盖原有的键值对
xiaoming_dict.update(temp_dict)

# 3.复制字典
xiaoming_dict = {"name":"xiaoming","age":18,"height":185,"gender":True}
xiaoming_dict2 = xiaoming_dict.copy()

# 4.清空字典
xiaoming_dict.clear()
print(xiaoming_dict)

#2. 判断字典中是否存在指定键值对
print("name" in xiaoming_dict)

（四）字典的循环遍历

遍历就是依次从字典中获取所有键值对

# 送代遍历字典
# 变量k是每一次循环中，获取到的键值对的key
xiaoming_dict = {"name":"xiaoming",
           "age":18,
           "height":185,
           "gender":True}

# 第一种方法
for key in xiaoming_dict:
    print("%s : %s" % (key,xiaoming_dict[key]))
    #提示:在实际开发中，由于字典中每一个键值对保存数据的类型是不同的，所以针对字典的循环遍历需求并不是很多

# 第二种方法
for key,value in xiaoming_dict.items():
    print(key, value)

（2）通过 keys 函数遍历

keys 函数用于返回字典中的所有键（key），语法格式为：dictname.keys()

print(dict1.keys())

（3）通过 values 函数遍历

values 函数用于返回字典中所有键对应的值（value），语法格式为：dictname.values()

print(dict1.values())

（4）通过 items 函数遍历

items 函数用于返回字典中所有的键值对（key-value），语法格式为：dictname.items()

print(dict1.items())

应用场景
尽管可以使用 for in 遍历字典
但是在开发中，更多的应用场景是:

• 使用多个键值对，存储描述一个物体 的相关信息 – 描述更复杂的数据信息。
• 将多个字典放在 一个列表中，再进行遍历，在循环体内部针对每一个字典进行 相同的处理

card_list = [{"name": "张三"
"qg":"12345"
"phone":"110"},
{"name":"委四"
"qg":"54321"
"phone":"10086"}]

for card_info in card_list:
	print(card_info)

第十四章：集合

（一）集合的概念

集合（set）是一个无序的不重复元素序列，集合会将所有元素放在一对大括号 <kbd>{} </kbd>中，相邻元素之间用 <kbd>, </kbd>分隔，

1.同一集合中，只能存储整型、浮点型、字符串、元组这些不可变的数据类型，无法存储列表、字典、集合这些可变的数据类型，否则 Python 解释器会抛出 TypeError 错误；
2. 数据必须保证是唯一的，因为集合对于每种数据元素，只会保留一份；
3.由于 Python 中的 set 集合是无序的，所以每次输出时元素的排序顺序可能都不相同。

集合的语法格式：

set1 = {1, 2, (3, 4, "a"), "b", "b"}

使用 set 函数创建集合

set1 = set("hello")

（二）集合的基础操作

集合的访问

由于集合中的元素是无序的，因此无法向列表那样使用下标访问元素。Python 中，访问集合元素最常用的方法是使用循环结构，将集合中的数据逐一读取出来，语法格式为：

for element in setname:
    print(element)

test = {10010, 20020, "apple", "orange", (10010, 20020, "orange", "banana")}
for i in test:
    print(i, end="\n")

集合的删除

和其他序列类型一样，手动函数集合类型，也可以使用 del 函数

test = {10010, 20020, "apple", "orange", (10010, 20020, "orange", "banana")}
del test
print(test)

集合中元素的添加

add 函数可以向集合中添加元素

test = {10010, 20020, "apple", "orange", (10010, 20020, "orange", "banana")}
test.add(30030)
print(test)

集合中元素的删除

remove 函数可以删除集合中的指定元素remove 函数在移除一个不存在的元素时会发生错误

test = {10010, 20020, "apple", "orange", (10010, 20020, "orange", "banana")}
test.remove("orange")

discard 函数也可以删除集合中的指定元素在移除一个不存在的元素时不会发生错误

test = {10010, 20020, "apple", "orange", (10010, 20020, "orange", "banana")}
test.discard(10010)

clear 函数删除集合中的所有元素

test = {10010, 20020, "apple", "orange", (10010, 20020, "orange", "banana")}
test.clear()

pop 函数随机删除集合中的某个元素
如果集合的元素都是数字，删除时，删掉的是最小的数字，其余数字升序排列；
如果集合的元素是非数字，删除时，删掉的是随机的元素，其余元素随机排列；
如果集合里既有数字又有非数字元素，删除时：

1. 若删掉的是数字，则一定是删掉了最小的，其他数字升序排列，非数字元素随机排列；
2. 若删掉的非数字，则一定是随机删掉了一个，其他数字升序排列，非数字则随机排列

test = {10010, 20020, "apple", "orange", (10010, 20020, "orange", "banana")}
test.pop()

集合的交集、并集、差集、对称差集运算

（1）集合的交集

集合的交集用于取两集合公共的元素，语法格式为：setname1 & setname2

2）集合的并集

集合的并集用于取两集合全部的元素，语法格式为：setname1 | setname2

（3）集合的差集

集合的差集用于取一个集合中另一集合没有的元素，语法格式为：setname1 - setname2

4）集合的对称差集

集合的对称差集用于取集合 1 和 2 中不属于 1&2 的元素，语法格式为：setname1 ^ setname2

set1 = {1, 2, 3}
set2 = {3, 4, 5}
print(set1 & set2)
print(set1 | set2)
print(set1 - set2)
print(set2 - set1)
print(set1 ^ set2)

集合的复制（拷贝）

copy 函数用于拷贝一个集合，语法格式为：setname.copy()

set1 = {3, 4, 5}
set2 = set1.copy()

第十五章：字符串

（一）字符串的赋值

1.1 单引号

使用单引号表示字符串

str = 'hackone'

1.2 双引号

使用双引号表示字符串

str = "hackone"

1.3 三引号

利用三引号，表示多行字符串，三引号中可以自由的使用单引号和双引号

str = '''hackone
hackone
hackone'''

1.4 转义字符

字符\是转义字符的符号，\n表示换行，\t表示制表符

print('I\'m ok')

1.5 原始字符串R

使用r前缀时，字符串中的反斜杠不会被视为转义符号，而是作为普通的字符输出，也就是说字符串里面有很多字符都需要转义，就需要加很多\，为了简化，Python还允许用r“表示”内部的字符串默认不转义，可以自己试试

print(r'\\\t\\')

1.6 字符串的拼接

1. 空格自动拼接

print("h" "a" "p" "p" "y")

执行以上代码，输出结果为：happy

1. 加号“+”拼接

print("h" + "a" + "p" + "p" + "y")

执行以上代码，输出结果为：happy

1. 多行字符串拼接

print("h"
      "a"
      "p"
      "p"
      "y")

执行以上代码，输出结果为：happy

1. 乘号“*”重复拼接

print("happy"*5)

执行以上代码，输出结果为：happyhappyhappyhappyhappy

1.5 encode和decode

字符串可以通过编码解码来转变字符的格式,encode 函数用于将 str 类型转换成 bytes 类型，这个过程也成为编码。decode 函数用于将 bytes 类型的二进制数据转换为 str 类型，这个过程也成为解码。

str = "我爱Python"

str_en = str.encode("UTF-8")     //编码

str_de = str_en.decode("UTF-8")  //解码

print("UTF-8编码：", str_en)
print("UTF-8解码：", str_de)

UTF-8编码： b'\xe6\x88\x91\xe7\x88\xb1Python'
UTF-8解码： 我爱Python

'ABC'.encode('ascii')  //编码

b'ABC'.decode('ascii') //解码

（二）字符串的定义

字符串就是一串字符，是编程语言中表示文本的数据类型

• 在 Python 中可以使用一对双引号<kbd>"</kbd>或者一对单引号<kbd>'</kbd>定义一个字符串
• 虽然可以使用<kbd>"</kbd>或者<kbd>'</kbd>做字符串的转义，但是在实际开发中
• 如果字符串内部需要使用<kbd>"</kbd>，可以使用<kbd>'</kbd>定义字符串
• 如果字符串内部需要使用<kbd>'</kbd>，可以使用<kbd>"</kbd>定义字符串
• 可以使用索引获取一个字符串中 指定位置的字符，索引计数从0开始
• 也可以使用 for 循环遍历字符串中每一个字符
• 大多数编程语言都是用<kbd>"</kbd>来定义字符串

字符串语法格式：

string = "hello world"
for c in string:
	print(c)

字符串取值
Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。

string[6]
p

（三）字符串的常用操作

hello_str = "hello hello"
# 1.统计字符串长度
print(len(hello_str))
# 2.统计某一个小 (子) 字符串出现的次数 str.count(sub, start, end)
print(hello_str.count("abc", 0, 3))
print(hello_str.count("llo"))
print(hello_str.count("abc"))
# 3，某一个子字符串出现的位置
print(hello_str.index("llo"))

将上述的字符串方法进行分类记忆，分类之后根据我们想要的效果来查找会更方便使用
下面将常用的字符串方法分成六大类，根据分类名称查找非常快速

3.1 判断字符串类型

3.2 字符串查找和替换

3.3 字符串大小写转换

3.4 字符串文本对齐

3.5 字符串去除空白字符串

3.6 字符串拆分和连接

空白字符包括\t \r \n

1.判断空白字符

space_str = "    \t\n\r"
print(space_str.isspace())

判断字符串是不是只有数字组成
1.检查字符串是否只由字母或文字组成
isalpha 函数用于检查字符串是否只由字母或文字组成，如果字符串至少有一个字符并且所有字符都是字母或文字则返回 True，否则返回 False，语法格式为：str.isalpha()

str3 = "hai里约"
str4 = "hai 里约"
str5 = "hai——里约"
str6 = "hai_里约!"

print(str3.isalpha())
print(str4.isalpha())
print(str5.isalpha())
print(str6.isalpha())

2.isdigit 函数、isdecimal 函数和 isnumeric 函数均可用于检查字符串是否只由数字组成，如果字符串只包含数字则返回 True，否则返回 False，它们的区别如下：

#1>都不能判断小数
num_str ="1.1"
#2>
num_str = "(1)"
#3>unicode字符串
num_str = "\u00ba"
print(num_str)
print(num_str.isdecimal()) #代码中常用这个，其他识别的范围太大
print(num_str.isdigit())
print(num_str.isnumeric())

3.istitle 函数

istitle 函数用于检查字符串中所有的单词拼写首字母是否为大写，且其他字母为小写，如果字符串中所有的单词拼写首字母是否为大写，且其他字母为小写则返回 True，否则返回 False，语法格式为：str.istitle()

str1 = "Welcome To Beijing !"
str2 = "Welcome to beijing !"
print(str1.istitle())
print(str2.istitle())

4.isupper 函数

isupper 函数用于检查字符串中所有的字母是否都为大写，如果字符串中包含至少一个区分大小写的字符，并且所有这些（区分大小写的）字符都是大写，则返回 True，否则返回 False，语法格式为：str.isupper()

str1 = "WELCOME TO  BEIJIGN !"
str2 = "Welcome To Beijing !"
print(str1.isupper())
print(str2.isupper())

5.islower 函数

islower 函数用于检查字符串是否由小写字母组成，如果字符串中包含至少一个区分大小写的字符，并且所有这些（区分大小写的）字符都是小写，则返回 True，否则返回 False，语法格式为：str.islower()

str1 = "Hello World"
str2 = "hello world"
print(str1.islower())
print(str2.islower())

6.isspace 函数

isspace 函数用于检查字符串是否只由空白字符组成，如果字符串中只包含空格，则返回 True，否则返回 False，语法格式为：str.isspace()

str1 = "         "
str2 = "h e l l o"
print(str1.isspace())
print(str2.isspace())

7.isalnum 函数

isalnum 函数用于检查字符串是否由字母和数字组成，如果 str 至少有一个字符并且所有字符都是字母或数字则返回 True，否则返回 False，语法格式为：str.isalnum()

str3 = "helloworld123"
str4 = "hello world123"
str5 = "hello-world123"

查找和替换字符串

1.判断是否以指定字符串开始

startswith 函数用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 start 和 end 指定值，则在指定范围内检查，语法格式为：str.startswith(substr[, start[, end]])

hello_str = "hello world"
print(hello_str.startswith("h"))
print(hello_str.startswith("hel"))
print(hello_str.startswith("he", 0, 6))
print(hello_str.startswith("hel", 1, 5))

2.判断是否以指定字符串结束
endswith 函数用于检查字符串是否是以指定子字符串结尾，如果是则返回 True，否则返回 False。如果参数 start 和 end 指定值，则在指定范围内检查，语法格式为：str.endswith(substr[, start[, end]])

hello_str = "hello world"
print(hello_str.endswith("d"))
print(hello_str.endswith("rld"))
print(hello_str.endswith("world", 0, 6))
print(hello_str.endswith("ld", 1, 5))

3.查找指定字符串

find 函数用于查找字符串中是否包含目标字符串，指定 start 和 end 的范围 find指定的字符串不存在，会返回-1
str.find(sub, start, end)

print(hello_str.find("e", 2, 10))
print(hello_str.find("llo"))
print(hello_str.find("adc"))

4.查找指定字符串

str.index(sub, start, end) index如果指定的字符串不存在，会报错也就是index 函数会抛出异常 这是和find的区别

str.index(sub, start, end)  
print(hello_str.index("llo"))
print(str.index("n", 5, 10))

5.替换字符串

replace 函数可以将指定字符串替代为目标字符串，语法格式为：str.replace(old_str, new_str, num)
参数 num，则将字符串 str 中的前不超过 num 个的字符串进行替换

print(hello_str.replace("hello","helloworld"))
print(hello_str.replace("hello","helloworld",2))  #将前两个hello替换成helloworld

字符串居中展示

# 要: 顺序并且居中对齐输出以下内容

poem = ["登鹤雀楼",
        "王之涣",
        "自日依山尽",
        "黄河入海流",
        "欲穷千里目",
        "更上一层楼"
        ]
for poem_str in poem:
    print("|%s|" % poem_str.center(10,"　"))
    # ljust 函数返回一个原字符串左对齐，并使用指定字符填充至指定长度的新字符串 width：包括 str 本身长度在内，字符串要占的总长度；
    print("|%s|" % poem_str.ljust(10, "　"))
    print("|%s|" % poem_str.rjust(10, "　"))
    

去除字符串左右的空白字符

# 要: 顺序并且居中对齐输出以下内容
poem = ["\t\n登鹤雀楼",
        "王之涣",
        "自日依山尽\t\n",
        "黄河入海流",
        "\t\n欲穷千里目",
        "更上一层楼"
        ]
for poem_str in poem:
	# lstrip 函数用于删除字符串左侧指定的字符（默认为空格）或字符序列
    print("|%s|" % poem_str.lstrip().center(10,"　"))
    # rstrip 函数用于删除字符串右侧指定的字符（默认为空格）或字符序列，
    print("|%s|" % poem_str.rstrip().ljust(10, "　"))
    # strip 函数用于删除字符串头、尾指定的字符（默认为空格）或字符序列，但只能删除开头或是结尾的字符，不能删除中间部分的字符
    print("|%s|" % poem_str.strip().rjust(10, "　"))

拆分字符串和拼接字符串

# 假设: 以下内容是从网络上抓取的
# 要求:
#1.将字符串中的空白字符全部去掉
#2.再使用 " "作为分隔符，拼接成一个整齐的字符串
poem_str ="登鹤雀楼\t 王之涣 \t 白日依山尽 \t\n 黄河入海流 \t\t 欲穷千里目\t\n 更上一层楼\t\t"

# 1.拆分字符串
# split 函数可以将一个字符串按照指定的分隔符切分成多个子串，这些子串会被保存到列表中（不包含分隔符），作为方法的返回值反馈回来
# str.split(sep=" ",num)[n] sep：表示分隔符，不能为空，可以是字符串中的任何元素 num：表示分割次数。
str = "www.runoob.com.cn"
print(str.split("."))
print(str.split("c"))
print(str.split(".", 2))
print(str.split(".", 2)[2])
a, b, c, d = str.split(".")
print(a)
print(b)
print(c)
print(d)

['www', 'runoob', 'com', 'cn']
['www.runoob.', 'om.', 'n']
['www', 'runoob', 'com.cn']
com.cn
www
runoob
com
cn

2，合并字符串
“sep”.join(sequence) sep：表示分隔符，可以为空；sequence：要连接的元素序列，join 后只能接受一个参数

result = " ".join(poem_list)
print(result)
sequence = "h", "e", "l", "l", "o"
print("".join(sequence))
print(" ".join(sequence))
print("-".join(sequence))

hello
h e l l o
h-e-l-l-o

字符串的大小写字母转换

1.首字母大写

capitalize 函数可以将字符串的第一个字母变成大写，其他字母变小写，语法格式为：str.capitalize()，其中 str 为定义的字符串：

str = "aBCDEF"
print(str.capitalize())

2.字母全部大写

upper 函数可以将字符串中的字母全部大写，语法格式为：str.upper()，其中 str 为定义的字符串：

str = "abcdef"
print(str.upper())

3.字母全部小写

lower 函数可以将字符串中的字母全部小写，语法格式为：str.lower()，其中 str 为定义的字符串：

str = "ABCDEF"
print(str.lower())

4.字母大小写互换

swapcase 函数可以对字符串的大小写字母进行转换，即将大写字母转换为小写字母，小写字母会转换为大写字母，语法格式为：str.swapcase()，其中 str 为定义的字符串：

str = "ABcdeF"
print(str.swapcase())

5.标题化

title 函数用于返回“标题化”的字符串，就是说所有单词的首个字母转化为大写，其余字母均为小写，语法格式为：
str.title()

print(str.title("hello world"))
print(str.title("hello world 上海"))
str1 = "hello world123"
print(str1.title())

Hello World
Hello World 上海
Hello World123

（四）字符串的切片

切片 方法适用于 字符串、列表、元组

• 切片使用索引值来限定范围，从一个大的字符串中切出小的字符串
• 列表和元组都是有序的集合，都能够通过索引值获取到对应的数据
• 字典是一个无序的集合，是使用键值对 保存数据

字符串切片的语法格式：

字符串[开始索引：结束索引：步长]

print(num_str[0:10:2])

注意

• 1.指定的区间属于左闭开型[开始索引，结束索引) => 开始索引 >= 范围结束索引
• 2.从起始位开始，到结束位的前一位结束(不包含结束位本身)
• 3.从头开始，开始索引数字可以省略，冒号不能省略
• 4到末尾结束，结束索引数字可以省略，冒号不能省略
• 5.步长默认为1，如果连续切片，数字和冒号都可以省略
• 6.进行字符串的截取，省略起始位置时，默认从第一位开始输出；省略结束位置时，默认输出到最后一位。

练习题：切片

• 1.截取队 2 ~ 5 位置 的字符串
• 2.截取从 2 ~末尾 的字符串
• 3.截取从 开始 ~ 5 位置的字符串
• 4.截取完整的字符串
  5.从开始位置，每隔一个字符截取字符串
  6.从索引 1 开始，每隔一个取一个
  7.截取从 2 ~ 末尾 -1 的字符串
  8.截取字符串末尾两个字符
  9.字符串的逆序 (面试题)

num_str = "0123456789"
# - 1.截取队 2 ~ 5 位置 的字符串
print(num_str[2:6])
#  - 2.截取从 2 ~末尾 的字符串
print(num_str[2:])
#  - 3.截取从 开始 ~ 5 位置的字符串
print(num_str[:6])
#  - 4.截取完整的字符串
print(num_str[:])
#    5.从开始位置，每隔一个字符截取字符串
print(num_str[::2])
#    6.从索引 1 开始，每隔一个取一个
print(num_str[1::2])
#    7.截取从 2 ~ 末尾 -1 的字符串
print(num_str[2:-1])
#    8.截取字符串末尾两个字符
print(num_str[-2:])
#    9.字符串的逆序 (面试题)
print(num_str[::-1])

第十六章：四种数据类型的应用场景的比较

（1）列表

① 存储相同类型的数据；

② 通过迭代遍历，在循环体内部，针对列表中的每一项元素，执行相同的操作。

（2）元组

① 函数的参数和返回值；

② 格式化字符串，格式化字符串后面的 () 本质上就是一个元祖；

③ 让列表不可以修改，保护数据安全。

（3）字典

① 需要多个键值对，可作为某个事务的说明；

② 将多个字典放在一个列表中，再进行遍历，再循环体内针对每一个字典进行相同的处理。

（4）集合

① 有序的列表；

② 使用集合做排行榜等类型的场景。

第十七章：python的公共方法

（一）python的内置函数

注意：字符串 比较符合以下规则:0”<A<“a”

a = [1,2,3]
del a[1]
del(a[1])
del(a)

t_list= [1,8,10,20,50]
print(max(t_list))
print(min(t_list))
t_dict = {"a":"z","b":"y","c":"x"} # 只比较key 也就是最大是c

（二）python的切片

• 切片 使用 索引值 来限定范围，从一个大的 字符串 中 切出 小的 字符串。
• 列表和元组都是有序的集合，都能够 通过索引值获取到对应的数据。
• 字典 是一个 无序 的集合，是使用 键值对 保存数据

（三）python的运算符

注意
in 在对 字典操作时，判断的是字典的键in和not in 被称为成员运算符

（四）python完整的for循环运算

for 变量 in 集合:
 	循环体代码
else：
	没用通过break退出循环，循环结束后，会执行的代码
	

for num in [1, 2, 3]:
    print(num)
    if num == 2:
    # 如果循环体内部使用break退出了循环# else 下方的代码就不会被执行
        break
else:
    print("会执行吗?")
print("循环结束")

student = [
    {"name":"李白"},
    {"name":"贺知章"}
]

find_str = "李白"

for s in student:
    print(s)
    if s["name"] == "李白":
        name1 =s["name"] 
        # 如果已经找到，应该直接退出循环，而不再遍历后续的元素
        print(f"找到 {name1}" )
        break
else:
#如果希望在搜索列表时，所有的字典检查之后，都没有发现需要搜索的目材,还希望得到一个统一的提示!
    print("没有找到")
print("循环结束")