Python学习(二)

一、基础语法学习

        都是最基础的语法, 基于学习文档, 再拓展去学习具体的一些语法

1. 生成器表达式 - 动态生成值，节省内存。

        生成器表达式是一个对象，它执行的计算和列表包含相同，但会迭代地生成结果。语法也和列表包含相同，但要用圆括号代替方括号。和列表推导不同，生成器表达式实际上不创建列表或者立即圆括号内的表达式求值。相反，它会创建一个通过迭代并按照需要生成值的生成器对象, 例如：

even_a = [1, 2, 3, 4]
even_gen = (x for x in even_a if x > 2)
print(even_gen)  # 输出 <generator object <genexpr> at 0x0000022A318E2C70>
print(next(even_gen))  # 输出 3
print(next(even_gen))  # 输出 4

       

        使用列表推导时，python实际上创建了包含结果数据的列表。而使用生成器表达式时，python创建的是只知道如何按照需要生成数据的生成器。在某些应用中，这可能极大地影响性能和内存使用。

• 列表推导 --> 使用[ ], 创建包含结果的列表
• 生成器表达式 --> 使用( ), 创建一个生成器

  # 读取一个文件
  f = open("data.txt")                    # 打开文件
  lines = (t.strip() for t in f)          # 读取行，并删除前后空白
  comments = (t for t in lines if t[0] == '#')    # 所有注释
  for c in comments:
      print(c)
  

        这个例子中，生成器表达式提取各行并删除其中的空白，但它实际上没有将整个文件读取到内存中。提取注释的表达式也是如此。相反，在程序开始在for循环中进行迭代时，读取了文件的各行。

在这个迭代过程中，按照需要生成了文件的各行并对其进行过滤。事实上，该过程中绝对没有把整个文件加载到内存中。因此，这是一种从很大的python源文件中提取注释的高效方法。

和列表推导不同，生成器表达式不会创建序列形式的对象。不能对它进行索引，也不能进行任何常规的列表操作，例如append()。但是，使用内置的list()函数可以将生成器表达式转换为列表, 例如：

clist = list(comments)

2. 内置函数大全 - len(), min(), max(), 功能强大。

• len（）函数用来返回列表的长度

  even_a = [1, 2, 3, 4]
  _len = len(even_a)
  print(_len)  # 输出 4

• max（）函数用来取列表元素中的最大值
• min（）函数用来取列表元素中的最小值

aa = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
ab = max(aa)
ab_min = min(aa)
bb = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'p']  # 列表中的元素必须为同数据类型才能求最大值，否则会报错
bc = max(bb)
bc_min = min(bb)
print(ab)  # 结果为:10
print(ab_min)  # 结果为:1
print(bc)  # 结果为:p
print(bc_min)  # 结果为:a

3. 字典的键值对操作 - keys(), values(), items(), 访问元素。 

d = {"name": "Alice", "age": 25}
print(d["name"])  # 输出 "Alice"
c = d.keys()  # 输出 dict_keys(['name', 'age'])
print(c)
e = d.values()  # 输出 dict_values(['Alice', 25])
print(e)
f = d.items()
print(f)  # 输出 dict_items([('name', 'Alice'), ('age', 25)])

4. 列表推导式优化 - 使用三元表达式简化条件。

numbers = [i for i in range(10) if i % 2 == 0 or i % 3 == 0]
print(numbers)  # 输出 [0, 2, 3, 4, 6, 8, 9]

5. 列表切片操作 - [start:end:step], 选择子序列。

fruits = ["apple", "banana", "cherry", "date"]
sliced_fruits = fruits[1:3]
print(sliced_fruits)  # 输出 ["banana", "cherry"]

6.  面向对象继承 - class 和 super(), 复用已有功能。

        跳转学习: 关于pyhton的class的super用法

class Animal:
    def __init__(self, name):
        self.name = name


class Dog(Animal):
    def bark(self):
        print(self.name + " says woof!")


dog = Dog("Rex")
dog.bark()

 7. 异常处理实践 - finally 子句, 确保清理工作。

        python中的异常处理跟java里的类似, 换汤不换药

try:
    file.close()
except Exception as e:
    print("Error:", e)
finally:
    print("File closed.")

8. 全局和局部变量 - 在函数内外区别变量。

global_var = "global"
def func():
    local_var = "local"
    print(local_var)  # 输出 "local"

print(global_var)  # 输出 "global"
func()

9. 模块导入优化 - 使用from ... import *, 但需谨慎。

from math import sqrt  # 相当于从math模块中单独引用sqrt模块
print(sqrt(16))  # 输出 4.0

10. 列表和元组的区别 - 元组不可变，列表可变。

t = (1, 2, 3)  # 元组
l = [1, 2, 3]  # 列表
l[0] = 0
print(l)  # 输出 [0, 2, 3]
print(t)  # 输出 (1, 2, 3), 元组不变

11.  列表解析与生成器表达式对比 - 生成器节省内存。

# 列表解析
even_numbers_list = [i for i in range(10) if i % 2 == 0]

# 生成器表达式
even_numbers_generator = (i for i in range(10) if i % 2 == 0)
print(list(even_numbers_generator))  # 输出相同，但生成器更节省内存

12. 函数参数传递 - pass by value vs pass by reference, 对象传递。

def change_list(lst):
    lst.append(4)

original = [1, 2]
change_list(original)
print(original)  # 输出 [1, 2, 4], 实际上是引用传递

13. 列表推导式与map()对比 - 列表推导简洁

numbers = [1, 2, 3, 4]
squared_list = [x ** 2 for x in numbers]
squared_map = map(lambda x: x ** 2, numbers)
print(list(squared_map))  # 输出 [1, 4, 9, 16], 相同结果，但列表推导更易读
print(squared_list)  # 输出 [1, 4, 9, 16]

14. 迭代器和生成器的应用 - 节省内存和性能。

def infinite_sequence():
    n = 0
    while True:
        yield n
        n += 1

gen = infinite_sequence()
for _ in range(5):
    print(next(gen))  # 输出前5个自然数

15. 装饰器高级用法 - 多装饰器链。

       继续学习: Python装饰器的高级用法（多个装饰器，带参数装饰器，类装饰器）

def log_time(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"{func.__name__} took {end_time - start_time} seconds.")
        return result
    return wrapper

@log_time
@count_calls
def fibonacci(n):
    pass  # 实现斐波那契数列

fibonacci(10)

16.  异常处理最佳实践 - 明确异常类型和处理。

def safe_division(a, b):
    try:
        result = a / b
    except ZeroDivisionError:
        print("Can't divide by zero!")
        result = None
    return result

print(safe_division(10, 2))  # 输出 5
print(safe_division(10, 0))  # 输出 Can't divide by zero!

17.  类方法和静态方法 - @classmethod 和 @staticmethod, 提供不同访问权限。

class MyClass:
    @classmethod
    def class_method(cls):
        print(f"This is a class method, {cls}")

    @staticmethod
    def static_method():
        print("This is a static method.")

MyClass.class_method()  # 输出 This is a class method, MyClass
MyClass.static_method()  # 输出 This is a static method.

18.  模块导入的别名 - 使用as关键字，简化导入。

import math as m
print(m.pi)  # 输出 π 的近似值

19.  字符串格式化 - 使用f-string或format(), 易于定制输出。

name = "Alice"
age = 25
print(f"My name is {name}, and I am {age} years old.")
print("My name is {name}, and I am {age} years old.".format(name=name, age=age))
# 输出 My name is Alice, and I am 25 years old.

20.  列表推导式嵌套 - 多层次的数据处理。

matrix = [[1, 2], [3, 4]]
transposed = [[row[i] for row in matrix] for i in range(2)]
print(transposed)  # 输出 [[1, 3], [2, 4]]