Python随笔——中篇

1.数据容器

1.1 列表

列表是一个有序且可更改的集合，并且是最常用的 Python 数据类型。在 Python 中，列表是使用方括号 [] 编写的。 

1.1.1 创建列表

（1）使用 [ ] 创建列表
创建一个列表，只需要把逗号分隔的不同数据项使用方括号 [ ] 括起来即可。

创建空列表

list = [] 

 创建非空列表

list = ['郭靖', '黄蓉', '过儿'] 

（2） 使用 list() 函数 创建(转换为)列表
可以使用 list() 构造函数创建列表：

list = list(('郭靖', '黄蓉', '过儿'))

注意：在使用 list() 函数创建列表时，一定要注意双括号。 

在Python中，我们可以使用 list() 函数将字符串、元组、字典和集合等其他类似对象转换为列表。

1.1.2 访问列表

（1）下标索引访问 

下标索引访问元组分为两大类，即正向索引和反向索引，格式为 list_name[i] ，其中，list_name 表示列表名，i表示索引值，i可以是正数（正向索引）也可以是负数（反向索引）。

可以得知，list_name[0]表示列表的第一个元素，list_name[-1]则表示列表的最后一个元素。

 （2）切片访问

使用切片访问列表的格式为 list_name[strat : end : step] ，其中，start 表示起始索引，end 表示结束索引，step 表示步长。

注意：在使用切片访问列表元素时，list_name[strat : end : step]，[start：end] 是左闭右开区间，即访问不了 end 代表的元素。 

1.1.3 遍历列表

list1 = [1,3,7,12,33]
# while循环
index = 0
while index < len(list1):
    print(f"第 {index + 1} 个元素是：{list1[index]}")
    index += 1
# for循环
for ele in list1:
    print(ele)

1.1.4 列表常用操作 

方法	要点	描述
list.insert(index,x)	增加元素	在列表 list 指定位置 index 处插入元素 x
list.append(x)	列表尾部增加元素	将元素 x 增加到列表 list 尾部
list.extend(aList)	A列表所有元素加到B列表尾部	将列表 alist 所有元素加到列表 list 尾部
list.remove(x)	删除元素	在列表 list 中删除首次出现的指定元素 x
list.pop([index])	删除元素	删除并返回列表 list 指定为止 index 处的元素，默认是最后一个元素
list.clear()	删除所有元素	删除列表所有元素，并不是删除列表对象
list.index(x)	访问元素	返回第一个 x 的索引位置，若不存在 x 元素抛出异常
list.count(x)	计数	返回指定元素 x 在列表 list 中出现的次数
len(list)	列表长度	返回列表中包含元素的个数
list.reverse()	翻转列表	所有元素原地翻转
list.sort()	排序	所有元素原地排序
list.copy()	浅拷贝	返回列表对象的浅拷贝
list.deepcopy()	深拷贝	返回列表对象的深拷贝

深拷贝：如果用deepcopy()方法，则无论多少层，无论怎样的形式，得到的新列表都是和原来无关的，这是最安全最清爽最有效的方法。

浅拷贝：copy()方法。对于List来说，其第一层，是实现了深拷贝，但对于其内嵌套的List，仍然是浅拷贝。因为嵌套的List保存的是地址，复制过去的时候是把地址复制过去了，嵌套的List在内存中指向的还是同一个。

直接赋值：如果用 = 直接赋值，是非拷贝方法。这两个列表是等价的，修改其中任何一个列表都会影响到另一个列表。

 1.1.5 列表生成式

list1 = [ele * ele for ele in range(1,11)]

print(list1) 

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100] 

1.2 元组 

元组（Tuple）是Python中一种重要的数据结构，具有不可变性和有序性的特点。它们可以存储不同类型的元素，是编写高效和安全代码的有力工具。 

1.2.1 创建元组

 在Python中，元组是一种有序的集合，元素用圆括号()包裹，元素之间用逗号,分隔。即使只包含一个元素的元组，也必须在元素后面加一个逗号。 

（1）使用括号() 

# 创建一个空元组
empty_tuple = ()
 
# 创建一个包含多个元素的元组
tuple1 = (1, 2, 3, 4)
 
# 创建一个包含不同类型元素的元组
tuple2 = (1, "Hello", 3.14, True)
 
# 创建一个单元素元组
single_element_tuple = (5,)

（2）不使用圆括号，直接用逗号分隔元素 

tuple3 = 1, 2, 3, 4
#这也是一种创建方法

（3）使用内置函数tuple()将其他序列转换为元组 

list1 = [1, 2, 3, 4]
tuple_from_list = tuple(list1)
#将列表转换为元组
string1 = "Hello"
tuple_from_string = tuple(string1)
#将字符串转换为元组

1.2.2 元组访问与遍历

tuple1 = (1,3,6,9,15)
print(tuple1,type(tuple1))
# 索引从0开始
# 元组也支持切片操作
print(tuple1[1])
# 遍历
index = 0
while index < len(tuple1):
    print(f"第 {index + 1} 个元素为：{tuple1[index]}")
    index += 1
for ele in tuple1:
    print(ele)

# 元组内list
tuple2 = (1,5,'tom',['杨过','郭靖','黄蓉'])
print(tuple2[3])
print(tuple2[3][2])
tuple2[3][0] = "洪七公"    #修改的是列表中的元素，而不能修改列表
print(tuple2)
tuple2[3].append("雕")
print(tuple2)

1.2.3 元组总结

1. 元组的核心特点是：不可变序列。
2. 元组的访问和处理速度比列表快。
3. 与整数和字符串一样，元组可以作为字典的键，列表则永远不能作为字典的键使用。

1.3 列表 vs 元组

列表和元组都是Python中常用的数据结构，用于存储多个元素。它们的区别主要体现在以下几个方面：

1. 可变性：列表是可变的，即可以修改、添加或删除其中的元素；而元组是不可变的，一旦创建就不能修改其中的元素。如果尝试修改元组中的元素，会引发TypeError异常。

2. 语法表示：列表使用方括号 [] 来表示，元素之间用逗号分隔；元组使用圆括号 () 或者省略括号来表示，元素之间也用逗号分隔。

3. 性能：由于列表是可变的，所以在进行频繁的增删操作时性能更好。而元组的不可变性使得它在一些特定的场景下更高效，例如元组可以作为字典的键，而列表不能。

4. 使用场景：由于列表的灵活性，它常用于存储一组数据来进行增删改查的操作。而元组通常用于存储不可变的数据，例如一些固定的配置信息。

总之，列表适用于存储需要频繁修改的数据，而元组适用于存储不可变的数据。在选择使用列表还是元组时，需要根据具体的需求来进行判断。

1.4 字符串 

在Python中，字符串（String）是用于表示文本信息的基本数据类型。字符串在编程中非常重要，因为它们可以用于存储和处理文本数据。 字符串是由Unicode码构成的不可变序列。

1.4.1 字符串字面值三种写法

Python中可以使用单引号（'）、双引号（"）和三引号（''' 或 """）来定义字符串。虽然它们都可以用来表示字符串，但在某些情况下，它们有各自的优势和用法。

单引号（'）和双引号（"）

单引号和双引号在使用上几乎没有区别，主要是为了方便开发者在字符串中包含引号。例如，如果字符串中包含单引号，则可以使用双引号包围，反之亦然。

三引号（''' 或 """）

三引号主要用于表示多行字符串，也可以包含单引号和双引号，而不需要使用转义字符。使用三引号可以方便地书写包含多行文本的字符串，如文档字符串（docstring）。

1.4.2 操作符 

操作符	描述	实例
+	字符串连接	>>>a + b 'HelloPython'
*	重复输出字符串	>>>a * 2 'HelloHello'
[]	通过索引获取字符串中字符	>>>a[1] 'e'
[ : ]	截取字符串中的一部分	>>>a[1:4] 'ell'
in	成员运算符 - 如果字符串中包含给定的字符返回 True	>>>"H" in a True
not in	成员运算符 - 如果字符串中不包含给定的字符返回 True	>>>"M" not in a True
r/R	原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母"r"（可以大小写）以外，与普通字符串有着几乎完全相同的语法。	>>>print r'\n' \n >>> print R'\n' \n
%	格式字符串

python 字符串格式化符号:

符   号	描述
%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%u	格式化无符号整型
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e，用科学计数法格式化浮点数
%g	%f和%e的简写
%G	%F 和 %E 的简写
%p	用十六进制数格式化变量的地址

1.4.3 常用方法

方法	描述
string.capitalize()	把字符串的第一个字符大写
string.center(width)	返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
string.count(str, beg=0, end=len(string))	返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
string.decode(encoding='UTF-8', errors='strict')	以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的 异 常 ， 除非 errors 指 定 的 是 'ignore' 或 者'replace'
string.encode(encoding='UTF-8', errors='strict')	以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'
string.endswith(obj, beg=0, end=len(string))	检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
string.expandtabs(tabsize=8)	把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。
string.find(str, beg=0, end=len(string))	检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
string.format()	格式化字符串
string.index(str, beg=0, end=len(string))	跟find()方法一样，只不过如果str不在 string中会报一个异常.
string.isalnum()	如果 string 至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False
string.isalpha()	如果 string 至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False
string.isdecimal()	如果 string 只包含十进制数字则返回 True 否则返回 False.
string.isdigit()	如果 string 只包含数字则返回 True 否则返回 False.
string.islower()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
string.isnumeric()	如果 string 中只包含数字字符，则返回 True，否则返回 False
string.isspace()	如果 string 中只包含空格，则返回 True，否则返回 False.
string.istitle()	如果 string 是标题化的(见 title())则返回 True，否则返回 False
string.isupper()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
string.join(seq)	以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
string.ljust(width)	返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
string.lower()	转换 string 中所有大写字符为小写.
string.lstrip()	截掉 string 左边的空格
string.maketrans(intab, outtab)	maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
max(str)	返回字符串 str 中最大的字母。
min(str)	返回字符串 str 中最小的字母。
string.partition(str)	有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string.
string.replace(str1, str2,  num=string.count(str1))	把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.
string.rfind(str, beg=0,end=len(string) )	类似于 find() 函数，返回字符串最后一次出现的位置，如果没有匹配项则返回 -1。
string.rindex( str, beg=0,end=len(string))	类似于 index()，不过是返回最后一个匹配到的子字符串的索引号。
string.rjust(width)	返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
string.rpartition(str)	类似于 partition()函数,不过是从右边开始查找
string.rstrip()	删除 string 字符串末尾的空格.
string.split(str="", num=string.count(str))	以 str 为分隔符切片 string，如果 num 有指定值，则仅分隔 num+1 个子字符串
string.splitlines([keepends])	按照行('\r', '\r\n', '\n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
string.startswith(obj, beg=0,end=len(string))	检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查.
string.strip([obj])	在 string 上执行 lstrip()和 rstrip()
string.swapcase()	翻转 string 中的大小写
string.title()	返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
string.translate(str, del="")	根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 del 参数中
string.upper()	转换 string 中的小写字母为大写
string.zfill(width)	返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0

1.5 切片操作

切片是从 python 对象中提取出部分值。

切片操作基本表达式：object[start_index : end_index : step]

注：前闭后开

举个例子：

# 切片
str = "123456"
slice_str1 = str[::]
slice_str2 = str[:3:]
slice_str3 = str[-4::-1]
slice_str4 = str[-4:-7:-1]
print("slice_str1 =",slice_str1)
print("slice_str2 =",slice_str2)
print("slice_str3 =",slice_str3)
print("slice_str4 =",slice_str4)
# 切片操作并不会影响原序列，而是返回了一个序列
print("str =",str)

运行结果： 

slice_str1 = 123456
slice_str2 = 123
slice_str3 = 321
slice_str4 = 321
str = 123456 

1.6 集合

集合（set）是一个无序的不重复元素序列。可以使用大括号 { } 或者 set() 函数创建集合。

注意：创建一个空集合必须用 set() 而不是 { }， { } 用来创建一个空字典。 

1.6.1 集合操作 

集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。

"""
选课
"""
c = {'张三','张无忌','张三丰','玄冥二老'}
java = {'张三','杨过','郭靖','黄蓉'}
python = {'张三','郭靖','黄蓉'}
# 总共有多少人
all = c | java | python
print(all)
print(len(all))
# 只选了c
stu1 = c - java - python
print(stu1)
print(len(stu1))
# 只选了一门
stu2 = (c - java - python) | (java - c - python) | (python - c - java)
print(stu2)
print(len(stu2))
# 选了三门 -> 交集
stu3 = c & java & python
print(stu3)
print(len(stu3))

 {'郭靖', '张无忌', '张三丰', '杨过', '张三', '玄冥二老', '黄蓉'}
7
{'张三丰', '张无忌', '玄冥二老'}
3
{'张三丰', '张无忌', '玄冥二老', '杨过'}
4
{'张三'}
1

 常用集合操作：

python文档之set()

1.7 字典 

• 格式：变量 = {key1 : value1, key2: value2…}
• 空字典定义：
  • {}
  • dict（）
• 字典中键不能重复，是唯一的，但是值可以重复

 不同于以固定范围的数字进行索引的序列，字典是以 键 进行索引的，键可以是任何不可变类型；字符串和数字总是可以作为键。 如果一个元组只包含字符串、数字或元组则也可以作为键；如果一个元组直接或间接地包含了任何可变对象，则不能作为键。 

 1.7.1 字典常用操作

python文档之dict()

1.7.2 字典遍历 

字典是以 键 进行索引的，故而只能使用for循环进行遍历。

# 每次循环取出键
for key in dict1:
    print(key,dict1[key])
print("-" * 20)
# 同时取出键和值
for k,v in dict1.items():
    print(k,v)
print("-" * 20)
# 只取值
for value in dict1.values():
    print(value)

1.7.3 字典生成式 

# 字典生成式
books = ["红楼梦","三国演义","西游记","水浒传"]
authors = ["曹雪芹","罗贯中","吴承恩","施耐庵"]
dict = {book:author
for book, author in zip(books, authors)}
print(dict)

{'红楼梦': '曹雪芹', '三国演义': '罗贯中', '西游记': '吴承恩', '水浒传': '施耐庵'}

2.排序和查找 

2.1 冒泡排序 

def bubble_sort(num_list):
    """
    冒泡排序 ->基于比较
    :param num_list: 数字序列
    :return:
    """
    for i in range(0, len(list1) - 1):
        for j in range(0, len(list1) - i - 1):
            if list1[j] > list1[j + 1]:
                list1[j], list1[j + 1] = list1[j + 1], list1[j]

2.2 查找

2.2.1 顺序查找

def seq_search(my_list,find_val):
    """
    顺序查找
    :param my_list: 目标列表
    :param find_val: 要查找的元素值
    :return: 若找到则返回索引，否则返回-1
    """
    find_index = -1
    for i in range(len(my_list)):
        if my_list[i] == find_val:
            find_index = i
            break
    else:
        print("元素不存在")
    return find_index
def seq_search_all(my_list,find_val):
    """
    顺序查找
    :param my_list: 目标列表
    :param find_val: 要查找的元素值
    :return: 若找到则返回索引，否则返回-1 ->返回所有索引
    """
    find_index_list = []
    for i in range(len(my_list)):
        if my_list[i] == find_val:
            find_index_list.append(i)
    return find_index_list

2.2.2 二分查找 

 二分查找的前提是当前列表已经有序。

# 非递归
def binary_search(num_list,find_val):
    left_index = 0;right_index = len(num_list) - 1
    find_index = -1
    while left_index <= right_index:
        mid_index = (left_index + right_index) // 2
        if find_val < num_list[mid_index]:
            right_index = mid_index - 1
        elif find_val > num_list[mid_index]:
            left_index = mid_index + 1
        else:   # 相等
            find_index = mid_index
            break
    return find_index

# 递归
def binary_search_rec(num_list,left,right,find_val):
    if left > right:
        return -1
    mid = (left + right) // 2
    if find_val < num_list[mid]:
        return binary_search_rec(num_list,left,mid - 1,find_val)
    elif find_val > num_list[mid]:
        return binary_search_rec(num_list,mid + 1,right,find_val)
    else:
        return mid