Python基础知识汇总【2】

python3.5+

关键字：

# 命令行查找
>>> import keyword
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else','except', 'finally', 
'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
# 或者直接去python\helps\tools\keywords

四，函数

# 函数的定义
def func(parameters...):
    statement
    (return)

# 函数的调用
......
func(args)# 很简单，不是吗
......

4.1 参数

arg参数分为形式参数（parameter）和实际参数（argument），且不用明确数据类型

函数可以接受零个或多个参数，这些参数是在函数定义时指定的。在函数调用时，它们提供了要操作的数据。例如：

4.1.1 位置参数

位置参数是按照参数在函数定义中的顺序进行传递的。例如：

def add(a, b):
    return a + b
    
sum = add(2, 3)

4.1.2 关键字参数

按照参数名进行传递的（通常用于传递默认参数）

def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")
    
greet("Alice")              # Hello, Alice!（不传参时默认顺序位置）
greet("Bob", greeting="Hi") # Hi, Bob!（传参时指定位置）

4.1.3 可变参数（不定长）

有时候，参数不定量，无法明确具体传几个参数，因此就用元组或字典将所有的参数并到一起（参数类型可以确定）

*args

使用 * 可以让函数接受任意数量的位置参数。位置参数被收集到一个元组中，并传递给函数。

def print_args(*args):
    print(args)
    for arg in args:
        print(arg)
        
print_args(1, 2, 3)        
# (1, 2, 3)      
# 1 2 3

**kwargs

使用 ** 可以让函数接受任意数量的关键字参数。关键字参数被收集到一个字典中，并传递给函数。

def print_kwargs(**kwargs):
    print(kwargs)
    for key, value in kwargs.items():
        print(f"{key}: {value}")
        
print_kwargs(name="Alice", age=30)   
# {'name': 'Alice', 'age': 30}
# name: Alice  age: 30

注：在调用函数时，参数先后顺序：位置参数，可变参数，关键字参数

4.2 返回值

函数可以返回一个或多个值（使用元组），这取决于函数的实际需求。在 Python 中，使用 return 语句返回一个值。例如：

def add_numbers(a, b):
    return a + b
    
sum = add_numbers(2, 3)
print(sum)

在这个例子中，add_numbers 函数返回 a + b 的值，这个值被赋给了 sum 变量。我们使用 print 函数输出这个值。

如果函数没有明确的返回值（也就是没有使用 return 语句），它将返回 None。

def divide(a, b):
    quotient = a/b
    remainder = a%b
    return quotient, remainder

res1, res2 = divide(5, 2)# 也可以有多个返回值，按顺序返回

4.3 变量作用域

变量作用域定义了变量的可见性和可用性

全局作用域
x = 10# 全局变量可以在程序的任何位置访问

def add():
局部作用域  
	a = 1# 局部作用域是在函数中定义的变量的作用域,这些变量只在函数内部可用
    print(x)
    return a
      
add()   # 10
print(add())# 1
print(a)# NameError: name 'a' is not defined

4.4 其他函数

4.4.1 匿名函数（Lambda)

使用lambda关键字创建匿名函数(不用def，只需一行，通常用于实现简单功能的代码)

有返回值（相关操作可以作为返回值写在一起）

lambda函数的语法格式为：lambda args: expression

add_numbers = lambda a, b: a + b

sum = add_numbers(2, 3)
print(sum)   # 5

4.4.2 闭包

五，模块

在Python中，模块是一组相关的函数、类和变量的集合，它们被组织成一个单独的文件（.py文件，相当于C中的头文件库）

导入模块方式：

• import module_name 导入模块
  • 调用 module_name.member()
• from module_name import member 从模块导入成员
  • 调用 member()
• import module_name as alias 相当于C中的typedef
  • 调用 alias.member()
• from module_name import member as alias 从模块导入成员，并命别名
  • 调用 alias()
• from module_name import * 导入模块所有成员，拿来就用(但这样不好，容易和自己定义的内容冲突)

5.1 内置模块

只介绍几种常用的：

5.1.1math模块

math模块提供了许多常见的数学函数，例如三角函数、对数函数、幂函数等

模块中定义：
DESCRIPTION
    This module provides access to the mathematical functions
    defined by the C standard.

import math

1.常量，类似于C的宏定义
print(math.pi)  # 3.141592653589793
print(math.e)  # 2.718281828459045
# 黄金比例
print(math.phi)  # 1.618033988749895
# 欧拉常数
print(math.gamma)  # 0.5772156649015329

2.数值转换
x = 4.7
# 四舍五入到最近的整数
print(round(x))  # 5
# 向下取整
print(math.floor(x))  # 4
# 向上取整
print(math.ceil(x))  # 5
# 截断小数部分
print(math.trunc(x))  # 4
# 绝对值
prnt(abs(x))  # 4.7
# 符号函数
print(math.copysign(x, -1))  # -4.7

from math import *   # 因为代码少，并且都是调用，所以不会冲突
3.三角函数
print(sin(math.pi / 2))  # 1.0
print(cos(math.pi / 2))  # 6.123233995736766e-17
print(tan(math.pi / 4))  # 0.9999999999999999

4.指数函数和对数函数
x = 2
prnt(exp(x))  # 7.38905609893065
# 对数函数log(x[, base]), 一个参数时相当于ln(), 后面的参数表示底数
print(log(x))  # 0.6931471805599453
print(log(x, 2))  # 1.0

5.其它函数
Math模块还包含了三角函数的反函数（asin、acos、atan）、双曲正弦函数（sinh）、双曲余弦函数（cosh）、双曲正切函数（tanh）、伽马函数（gamma）等

5.1.2 time模块

也有datetime模块，但那个更倾向于日期，这个time更轻量级(用于处理时间和日期数据。可以使用这些函数来获取当前时间、计算程序运行时间、延迟执行等操作)

DESCRIPTION
    There are two standard representations of time.  One is the number
    of seconds since the Epoch, in UTC (a.k.a. GMT).  It may be an integer
    or a floating point number (to represent fractions of seconds).
    The Epoch is system-defined; on Unix, it is generally January 1st, 1970.
    The actual value can be retrieved by calling gmtime(0).


The other representation is a tuple of 9 integers giving local time.
The tuple items are:
  year (including century, e.g. 1998)
  month (1-12)
  day (1-31)
  hours (0-23)
  minutes (0-59)
  seconds (0-59)
  weekday (0-6, Monday is 0)
  Julian day (day in the year, 1-366)

from time import * # 调用几个常用的

start = time()# 记录起始时间（时间戳）
sleep(2)# 程序暂停2s
now = localtime(t)# 当前时间
print(now)
end = time()# 记录结束时间
print(end - start)# 执行时间

5.1.3 random模块

random模块提供了随机数生成函数

DESCRIPTION
        bytes
        -----
               uniform bytes (values between 0 and 255)

        integers
        --------
               uniform within range

        sequences
        ---------
               pick random element
               pick random sample
               pick weighted random sample
               generate random permutation

        distributions on the real line:
        ------------------------------
               uniform
               triangular
               normal (Gaussian)
               lognormal
               negative exponential
               gamma
               beta
               pareto
               Weibull

        distributions on the circle (angles 0 to 2pi)
        ---------------------------------------------
               circular uniform
               von Mises

from random import*
                
1.生成随机整数

# randrange([start,] stop[, step])：返回一个在给定范围内[start,stop）的随机整数
print(random.randrange(1, 100, 2))
print(random.randint(1, 100))  # 随机生成1到100之间的整数

# uniform(a, b)：返回一个在a和b之间（包括a和b）的随机浮点数
print(random.uniform(1.0, 10.0))  # 随机生成1.0到10.0之间的浮点数

2.生成随机序列（只能改变可变序列，使用前先变成列表）

# choice(seq[, x])：从序列seq中随机选择x个元素
choice(["apple", "banana", "cherry"]) 
# sample(population, k)：从population序列中随机选择k个元素
sample([1, 2, 3, 4, 5], 3)
# shuffle(x[, random])：将序列x中的元素随机排序,改变原来的变量
a = [1, 2, 3, 4, 5]
shuffle([1, 2, 3, 4, 5]) 
print(a)

3.其他函数

# random随机生成0.0到1.0之间的浮点数
print(random())  
# getstate和setstate函数
state = getstate()  # 获取当前生成器状态
print(randint(1, 100))  # 随机生成1到100之间的整数
setstate(state)  # 恢复随机数生成器状态
print(randint(1, 100))  # 再次随机生成1到100之间的整数，结果和之前相同

# 随机种子（DL中的概念）

5.1.4 os模块

文件

5.1.5 sys模块

系统

5.1.6 re模块

正则表达式

5.1.7 Threading/Multiprocessing/asyncio模块

多线程、多进程、异步协程

5.1.8 Tkinter模块

GUI编程

5.2 第三方模块

除了Python的内置模块外，还有许多由第三方开发人员编写的模块可供使用。这些模块可以通过pip或conda等工具进行安装。以下是一些最常用的第三方模块：

NumPy模块

数学库，可以使用numpy创建数组

Pandas模块

数据分析库

Requests模块

网络爬虫

PyTorch模块

深度学习

到此就完成了python与其它语言语法相似的部分，以下是面向对象编程的相关知识

明确python中的包含关系：数据信息 < 容器 < 函数(方法) < 类 < 模块 < 包 < 库

六，类

6.1 面向对象

类是创建对象的蓝图，对象是类的实例。Python面向对象编程的核心概念是“类”和“对象”，以及它们之间的关系

OOP思想扩展性强，可读性高，适用于大型软件开发。OOP思考问题角度更偏向对象，每涉及一个对象，就要站在这个对象的角度创建属性，调用行为；与之相对的POP（面向过程编程）则更倾向于任务的角度，将大型任务拆分为一个个小任务，再按顺序一一执行，适用于后期无需过多修改且不需协作的事务。

每一种编程语言都不是非常明确地要求必须使用某种编程思想，而是根据需求结合各种思维方式，以达到开发和应用的目的。Python中，站在设计者思维制高点创建对象，调用对象；以执行者思维处理各部分实现。

对象：一切皆对象，将不同类型对象整合到一起也是对象

每个对象都包括属性（静态）和行为（动态）

面向对象编程的基本概念

概念	描述
类	用来描述具有相同的属性和方法的对象的集合，定义了该集合中每个对象所共有的属性和方法。
方法	类中定义的函数
类变量	类变量在整个实例化的对象中是公用的；类变量定义在类中且在函数体之外；类变量通常不作为实例变量使用。
局部变量	定义在方法中的变量，只作用于当前实例的类。
实例变量	实例变量就是一个用 self 修饰的变量
数据成员	类变量或者实例变量用于处理类及其实例对象的相关的数据
封装（Encapsulation）	将数据和行为包装到一个单元中，即将数据和行为作为一个整体对外界进行隐藏和保护
继承（Inheritance）	子类会继承父类的所有方法和属性，并可以根据需要进行修改和扩展
方法重写	子类对从父类继承来的方法的修改，也称为方法的重写。
多态（Polymorphism）	一个对象可以有多种不同形态或者可以被看作是多种类型

6.2 类

类是将数据（属性，同C语言的结构）和函数（行为，又称方法）组合在一起的一种方式。
其将数据和功能打包在一起，以便在程序的其他部分重复使用。类可以包含属性（即类变量和实例变量）和方法（即函数）

类的语法结构：
class ClassName: # 类名称采用驼峰命名法（各单词首字母大写）
    """注释"""
    variable = data # 属性
    ...       
    def func1(): # 方法
        <statement>
 
类的调用：
c1 = ClassName() # 实例化：类的具体对象，对象是类的实例（包含类的属性和方法）
print(c1.variable) # 访问属性
c1.func1() # 调用方法

还可以多次实例化：
c2 = ClassName() # 默认性质相同，有自己的属性和方法

实例：

以下是用chatgpt写的电商系统：
class Customer: # 创建客户类，调用时可以多次实例化
    # 类变量
    num_customers = 0 # 初始化

    def __init__(self, name, email): # __init__为默认属性，作为方法初始化类对象，类似于构造函数，无需调用直接执行
        # 实例变量
        self.name = name # 使类实例带有name这个属性
        self.email = email # 类实例中传入Email（假设传入@qq.com），那么实例就带有Email = @qq.com这个属性。在调用时（看下面的调用）
        # self.variable = argument 指的是使类实例自身（self）的属性（variable）为一个数据（arg，传参）
        self.orders = [] # 空列表的初始化
        
        
        # 计数器
        Customer.num_customers += 1 # Customer类的计数器，
		# 只要涉及方法的调用，必须指明这是哪个类的：
        # 类外调用方法，要先声明类的实例化，再多层级表明调用（同模块中方法的调用：instance.method）
        # 类内的方法调用分为两类：
        # 1.方法中调用：没有instance，但也需要指明，于是这里就用类自己（self）来代指包含其的类，所以：self.method
        # 2.方法外调用：如计数器，独立行为，既不属于方法，也不属于属性，只是类内的行为，不应用到类外，因此要用类的名字调用，即：ClassName.
    def place_order(self, order): # self为类方法中默认参数，构造时要写，调用时不用
        self.orders.append(order) # 下订单

    def view_orders(self): # 遍历订单（查看订单）
        for order in self.orders:
            print(order)

    def total_spent(self): # 订单总价钱
        total = 0
        for order in self.orders:
            total += order.total_cost() # 用到其他类（在类中调用方法，且不在包含该方法的类中，所以应用“调用2”的格式）
        return total

    def __str__(self): # __str__方法返回对象的字符串表示形式，注：不会默认执行
        return f"{self.name} ({self.email})" # 客户名（邮箱）

class Order: # 订单类
    # 类变量
    num_orders = 0

    def __init__(self, customer):
        # 实例变量
        self.customer = customer
        self.items = []
        self.order_number = Order.num_orders + 1 # 

        # 自增计数器
        Order.num_orders += 1

    def add_item(self, item):
        self.items.append(item)

    def remove_item(self, item):
        self.items.remove(item)

    def total_cost(self):
        total = 0
        for item in self.items:
            total += item.price
        return total

    def __str__(self):
        return f"Order {self.order_number}: {self.customer}, Total Cost: ${self.total_cost()}"

class Item:
    def __init__(self, name, price):
        self.name = name
        self.price = price

    def __str__(self):
        return f"{self.name} (${self.price})"

# 创建两个客户对象
customer1 = Customer("John Doe", "johndoe@gmail.com")
customer2 = Customer("Jane Smith", "janesmith@yahoo.com")

# 创建两个物品对象
item1 = Item("iPhone X", 999)
item2 = Item("MacBook Pro", 1999)

# 创建两个订单对象
order1 = Order(customer1)
order2 = Order(customer2)

# 为订单添加物品
order1.add_item(item1)
order1.add_item(item2)
order2.add_item(item2)

# 为客户下订单
customer1.place_order(order1)
customer2.place_order(order2)

# 查看客户订单
print(customer1)
print("Orders:")
customer1.view_orders()
print(f"Total spent: ${customer1.total_spent()}")

print(customer2)
print("Orders:")
customer2.view_orders()
print(f"Total spent: ${customer2.total_spent()}")

- __init__(): 初始化对象，类似于构造函数。 - __str__(): 返回对象的字符串表示形式。 - __repr__(): 返回对象的“官方”表示形式。 - __len__(): 返回对象的长度。 - __iter__(): 返回对象的一个迭代器。 - __next__(): 返回迭代器的下一个元素。

Python中的类提供了面向对象编程的所有基本功能

6.3 核心概念

6.3.1 封装

对象和类就是封装的两个技术工具。封装通过暴露公共接口，同时将内部实现细节隐藏起来，提高了代码的灵活性和可维护性。

6.3.2 继承

实现代码重用和可扩展性

6.3.3 多态

提高了代码的灵活性和可扩展性