Python进阶学习笔记-基础篇

打印原始字符串

print(r"D:\three\two\one\now")

D:\three\two\one\now

复现随机数

import random
x = random.getstate()
print(random.randint(1,10))
print(random.randint(1,10))
print(random.randint(1,10))
random.setstate(x)
print(random.randint(1,10))
print(random.randint(1,10))
print(random.randint(1,10))

浮点数精度运算函数decimal

# 浮点数采用E记法（科学计数法），所以如果要获得完全精准的浮点数，则需要使用decimal函数
import decimal
a = decimal.Decimal('0.1')
b = decimal.Decimal('0.2')
c = decimal.Decimal('0.3')
print(c)
print(a+b == c)
True

复数

# 复数分为实部和虚部，real和imag可以分别获取复数的实部和虚部x = 1+2j
print(x.real)
1.0
print(x.imag)
2.0

同时获取整除(向下取整)和取余函数divmod()

divmod(3,2)
(1,1)

幂运算函数pow()

# pow()还支持扩展参数--pow(x,y,z)，计算x的y次方，然后将结果与z进行求余运算
pow(2,3,5)
3

布尔值类型

False
# 1、定义为False的对象：None和False
# 2、值为0的数字类型：0,0j,0.0,Decimal(0),Fraction(0,1)
# 3、空的序列和集合：‘’,[],{},set(),range(0)

True == 1
False == 0

# 逻辑运算优先级 not>and>or

条件表达式

x = 10
result = "greater than 5" if x > 5 else "less than or equal to 5"
print(result)

循环else语句

for i in range(1,10):
    # 重复执行的代码
else:
    # 循环正常结束后要执行的代码

count = 0
while count < 5:
    # 重复执行的代码
    count += 1
else:
    # 循环正常结束后要执行的代码

# 不管是while还是for只要遇到break，else下方的代码都是不执行的

切片

s = [1, 2, 3, 4, 5]
s[len(s):] = [6] # == s.append(6)
s[len(s):] = [7, 8, 9] # == s.extend([7, 8, 9])

创建不可变集合

frozenset(iterable)

my_set = {1, 2, 3}
my_frozenset = frozenset(my_set)
print(my_frozenset)  # 输出: frozenset({1, 2, 3})

浅拷贝与深拷贝

# 浅拷贝（Shallow Copy）与深拷贝（Deep Copy）是数据复制中的两种方式，主要用于Python中的对象复制。
# 浅拷贝：拷贝父对象，不会递归拷贝内部的子对象。
# 深拷贝：递归拷贝父对象及其内部的所有子对象。
# 在Python中，可以使用copy模块的copy()函数进行浅拷贝，使用deepcopy()函数进行深拷贝。

import copy
 
# 定义一个嵌套结构的对象
original = [1, 2, [3, 4]]

# 浅拷贝
shallow_copy = copy.copy(original)

# 深拷贝
deep_copy = copy.deepcopy(original)
 
# 修改原始对象
original[2][0] = "changed"
 
# 输出浅拷贝和深拷贝结果
print("Shallow Copy:", shallow_copy)  # 输出: [1, 2, ['changed', 4]]
print("Deep Copy:", deep_copy)        # 输出: [1, 2, [3, 4]]
# 浅拷贝中，原始列表中的子列表并没有被复制，浅拷贝后的对象和原始对象中的子对象会指向同一个内存地址。
# 而深拷贝会创建子对象的新副本，原始对象和拷贝后的对象中的子对象会指向不同的内存地址。

列表推导式

# 列表推导式（list comprehension）是一种简洁快速创建列表的方法。它的结构是在方括号内，包含一个表达式，后面跟一个 for 子句，然后是零个或多个 for 或 if 子句。返回的列表由表达式计算的结果组成。

# 创建一个新列表，其中包含原列表中每个元素的平方。
numbers = [1, 2, 3, 4, 5]
squares = [num**2 for num in numbers]
print(squares)  # 输出: [1, 4, 9, 16, 25]

# 添加条件判断：只包含原列表中能被3整除的元素的平方。
numbers = [1, 2, 3, 4, 5]
squares = [num**2 for num in numbers if num % 3 == 0]
print(squares)  # 输出: [9, 16]

# 多层嵌套：创建一个全排列列表。
colors = ['red', 'green', 'blue']
permutations = [x + y for x in colors for y in colors]
print(permutations)
# 输出: ['redred', 'redgreen', 'redblue', 'greenred', 'greengreen', 'greenblue', 'bluered', 'bluegreen', 'blueblue']

# 使用字典推导式创建一个新字典。
keys = ['a', 'b', 'c']
values = [1, 2, 3]
dictionary = {k: v for k, v in zip(keys, values)}
print(dictionary)  # 输出: {'a': 1, 'b': 2, 'c': 3}

集合推导式

# 集合推导式（set comprehension）是一种简洁的用于创建集合的方法，它类似于列表推导式，但用于集合。集合推导式可以使用Python表达式过滤和转换集合中的元素。

# 语法如下：
{expression for item in collection}
{expression for item in collection if condition}
# 其中expression是你对每个元素应用的表达式，item是迭代的临时变量，collection是你要迭代的集合，而if condition是可选的条件表达式，用于筛选符合条件的元素。

# 假设我们有一个列表，我们想要创建一个集合，其中包含列表中所有大于10的数的平方：
numbers = [3, 8, 12, 16, 20]
squares = {x**2 for x in numbers if x > 10}
print(squares)  # 输出: {144, 256, 225}

字典推导式

# 字典推导（dictionary comprehensions）是Python 3.7+中引入的特性，它允许你用一种简洁的方式创建字典。字典推导式是一种可读性较高的方式，可以用来转换或过滤字典。

# 字典推导式的基本语法如下：
{key: value for (key, value) in iterable}
{key: value for (key, value) in iterable if condition}

# 创建一个新的字典，其中包含原字典中键值对的平方：
numbers = {x: x**2 for x in range(10)}
# 结果: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

# 只保留原字典中值大于10的键值对：
numbers = {x: x**2 for x in range(20)}
squares = {k: v for (k, v) in numbers.items() if v > 10}
# 结果: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100, 11: 121, 12: 144, 13: 169, 14: 196, 15: 225, 16: 256, 17: 289, 18: 324, 19: 361}

# 使用字典推导式进行复杂操作，例如过滤出字典中的特定键值对：
data = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
result = {k: v for (k, v) in data.items() if k in ['a', 'b', 'c']}
# 结果: {'a': 1, 'b': 2, 'c': 3}

序列化与反序列化

# pickle模块用于序列化和反序列化Python对象结构。"Pickle"是Python对象的二进制表示，可以保存到文件中，或在进程间传输。
# pickle模块提供了四个功能：dump(), load(), dumps(), loads()。

# pickle.dump(obj, file, [protocol])：将对象obj保存到文件file中。protocol是序列化的协议，默认值为0，表示以文本的形式序列化。protocol的值为1或True表示以二进制的形式序列化。
import pickle
my_list = [123, 3.14, 'Hello', None]
# 创建文件并写入
with open('pickle_example.pkl', 'wb') as my_file:
    pickle.dump(my_list, my_file)


#pickle.load(file)：从file文件中读取数据，并返回被序列化的对象。
import pickle
with open('pickle_example.pkl', 'rb') as my_file:
    my_list = pickle.load(my_file)
print(my_list)  # 输出：[123, 3.14, 'Hello', None]

# pickle.dumps(obj, [protocol])：将对象obj转换为一个字节流（bytes）。
import pickle
my_list = [123, 3.14, 'Hello', None]
my_bytes = pickle.dumps(my_list)
print(my_bytes)  # 输出：一串二进制字节

# pickle.loads(bytes_object)：从字节流（bytes）中读取对象。
import pickle
my_bytes = b'\x80\x03]q\x00(K\x00K?\x85q\x01cbuiltin_module_tq\x02X\x06\x00\x00\x00floatq\x03\x8c\x0bu.'
my_list = pickle.loads(my_bytes)
print(my_list)  # 输出：[123, 3.14, 'Hello', None]

# 注意：pickle模块不是安全的。当unpickle对象时，对象的类定义和模块必须可用。如果不是由可信的源进行unpickle操作，那么可能会导致安全问题。

异常

def divide(x, y):
    try:
        result = x / y
    except ZeroDivisionError:
        print("错误：除数不能为0")
    except TypeError:
        print("错误：参数需要是数字类型")
    except Exception as e:
        print(f"未知错误：{e}")
    else:
        print("程序没有发生异常")
        return result
    finally:
        print("程序是否异常都会打印")
 
# 示例调用
print(divide(10, 0))
print(divide(10, 2))
print(divide("a", 2))


# 使用 raise 引发自定义异常
class CustomError(Exception):
    pass
 
def raise_custom_error():
    raise CustomError("发生了一个自定义异常")
 
# 使用 assert 语句检查条件是否满足
def check_condition(condition):
    assert condition, "条件不满足"
 
# 示例函数调用
try:
    raise_custom_error()
except CustomError as e:
    print(e)
 
# 检查条件是否满足，如果不满足则会引发 AssertionError
try:
    check_condition(False)
except AssertionError as e:
    print(e)