Python入门

注释

单行注释：以# 开头，#与注释内容一般建议以一个空格隔开

# 这是单行注释
print('Hello World')

多行注释：以一对三引号括起来

"""
这是多行注释
Hello
World
"""
print('Hello World')

命名规范

变量命名基本规则

• 变量名大小写敏感，例如 name 和 Name 是两个不同的变量。
• 变量名字中可以包含英文、下划线、数字，但是不能以数字开头，不能是关键字

模块(module)命名风格
模块名应尽量短小，使用全小写字母，可以使用下划线来分隔多个单词。例如，my_module 是一个正确的模块名；不推荐使用大写字母或者过于复杂的名称

类(class)的命名
类名使用驼峰（CamelCase）命名风格，首字母大写，私有类可用一个下划线开头。例如，MyClass 是一个公共类，_PrivateClass 是一个私有类

函数（function）的命名
函数名应该使用全小写字母，如有多个单词，用下划线隔开。例如，user_name

变量（variable）的命名
变量名尽量小写，如有多个单词，用下划线隔开

常量（constant）的命名
常量名使用全大写字母，如有多个单词，用下划线隔开。例如，MAX_VALUE

运算符

算数运算符

运算符	描述	示例
+	加
-	减
*	乘
/	除
//	取整除	返回商的整数部分 9//2 输出结果 4
%	取余
**	指数	a**b 为10的20次方， 输出结果 100000000000000000000

逻辑运算符

运算符	描述
==	判断内容是否相等，满足为True，不满足为False
!=	判断内容是否不相等，满足为True，不满足为False
>	判断运算符左侧内容是否大于右侧，满足为True，不满足为False
<	判断运算符左侧内容是否小于右侧，满足为True，不满足为False
>=	判断运算符左侧内容是否大于等于右侧，满足为True，不满足为False
<=	判断运算符左侧内容是否小于等于右侧，满足为True，不满足为False

数据类型

常用的6种数据类型

类型	说明
数字 Number	整数 int，例如10、-10 浮点数 float，例如 3.2 复数 complex，例如 4+3j 布尔 bool，True为真，False为加，True本质为1，False 为0
字符串 String	描述文本的一种数据类型 ,单引号、双引号或三引号
列表 List	有序的可变序列
元组 Tuple	有序的不可变序列
集合 Set	无序不重复集合
字段 Dictionary	无序Key-Value

查看数据类型

查看数据类型使用type()

a = 10
b = 3.2
c = 3 + 4j
d = True
print(type(a), type(b), type(c), type(d))
# 输出为：<class 'int'> <class 'float'> <class 'complex'> <class 'bool'> 

常见数据类型转换

函数	说明
int(x)	将x转换为一个整数
float(x)	将x转换为一个浮点数
str(x)	将x转换为字符串

字符串

字符串定义

str = 'Hello World'
str2 = "Hello World"
str3 = """Hello World""" # 支持换行

字符串拼接
使用“+”号连接字符串变量或字符串字面量即可，无法和非字符串类型进行拼接

字符串格式化

1. 语法：‘%占位符’ % 变量
   常用占位符: 字符串%s、整数%d、浮点数%f，
   使用辅助符号"m.n"来控制数据的宽度和精度，m控制宽度，n控制小数点精度
   例如：
   %5d：表示将整数的宽度控制在5位
   %5.2f：表示将宽度控制为5，将小数点精度设置为2
   %.2f：表示不限制宽度，只设置小数点精度为2

name = 'Mike'
age = 29
str = '我是%s，今年%d岁' % (name, age)
print(str)

2. 语法:f’{变量} {变量}'的方式进行快速格式化

name = 'Mike'
age = 29
str = f'我是{name}，今年{age}岁'
print(str)

字符串常用方法

操作	说明
字符串[下标]	根据下标索引取出特定位置字符
字符串.index(字符串）	查找给定字符的第一个匹配项的下标
字符串.replace(字符串1, 字符串2)	将字符串内的全部字符串1，替换为字符串2 不会修改原字符串，而是得到一个新的
字符串.split(字符串)	按照给定字符串，对字符串进行分隔 不会修改原字符串，而是得到一个新的列表
字符串.strip() 字符串.strip(字符串)	移除首尾的空格和换行符或指定字符串
字符串.count(字符串)	统计字符串内某字符串的出现次数
len(字符串)	统计字符串的字符个数

字符串遍历

# for循环
for s in str:
	print(s)

# while循环
index = 0
while index < len(str):
	print(str[index])
	index += 1

列表 List

列表List定义

# 字面量
[元素1, 元素2, 元素3...]

# 定义空列表
变量 = []
变量 = list()

列表下标索引

# 正向索引：列表[下标索引]，索引从0开始
name_list = ['Tom', 'Bob', 'Lucy']
print(name_list[0]) # Tom
print(name_list[1]) # Bob
print(name_list[2]) # Lucy

# 逆向索引：从后向前，下标索引为-1，-2,-3，依次递减
print(name_list[-1])  # Lucy
print(name_list[-2]) # Bob
print(name_list[-3]) # Tom

# 嵌套list
l_list = [[1, 2, 3], [4, 5, 6]]
print(l_list[0]) # [1, 2, 3]
print(l_list[0][0]) # 1

常用方法

方法	说明
列表.append(元素)	向列表中追加一个元素
列表.extend(容器)	将数据容器的内容依次取出，追加到列表\
列表.insert(下标，元素)	在指定下标处，插入指定的元素
del 列表[下标]	删除列表指定下标元素
列表.pop(下标)	删除列表指定下标元素
列表.remove(元素)	从前向后，删除此元素第一个匹配项
列表.clear()	清空列表
列表.count(元素)	统计此元素在列表中出现的次数
列表.index(元素)	查找指定元素在列表的下标,找不到报错ValueError
len(列表)	统计容器内有多少元素

遍历列表

# for循环遍历
for 临时变量 in 列表：
	对临时变量进行处理
# while循环遍历
index = 0
while index < len(列表)：
	元素= 列表[index]
	对元素进行处理
	index += 1

元组 Tuple

定义元组
定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型
元组是不可修改的

# 字面量
(元素,元素,元素...)

# 定义空元组
变量 = ()
变量= tuple()

常用方法

方法	说明
index()	查找某个数据，如果数据存在返回对应的下标，否则报错
count()	统计某个数据在当前元组出现的次数
len(元组)	统计元组内的元素个数

遍历元组

# for循环遍历
for 临时变量 in 元组：
	对临时变量进行处理
# while循环遍历
index = 0
while index < len(元组)：
	元素= 元组[index]
	对元素进行处理
	index += 1

集合 Set

集合Set不包含重复元素（自带去重功能）、内容无序

定义集合

# 字面量
{元素,元素,元素...}

# 空集合
变量 = set()

常用方法

操作	说明
集合.add(元素)	集合内添加一个元素
集合.remove(元素)	移除集合内指定的元素
集合.pop()	从集合中随机取出一个元素
集合.clear()	将集合清空
集合1.difference(集合2)	得到一个新集合，内含2个集合的差集 原有的2个集合内容不变
集合1.difference_update(集合2)	在集合1中，删除集合2中存在的元素 集合1被修改，集合2不变
集合1.union(集合2)	得到1个新集合，内含2个集合的全部元素 原有的2个集合内容不变
len(集合)	得到一个整数，记录了集合的元素数量

遍历集合
集合不支持下标索引，所以也就不支持使用while循环

# for循环遍历
for 临时变量 in 集合：
	对临时变量进行处理

字典 Dictionary

定义字典
字典的定义，同样使用{}，不过存储的元素是一个个的键值对，Key不可重复，重复会对原有数据覆盖，如下语法：

# 字面量
{key: value, key: value,...}
# 空字典
变量 = {}
变量 = dict()

常用方法

操作	说明
字典[Key]	获取指定Key对应的Value值
字典[Key] = Value	添加或更新键值对
字典.pop(Key)	取出Key对应的Value并在字典内删除此Key的键值对
字典.clear()	清空字典
字典.keys()	获取字典的全部Key，可用于for循环遍历字典
len(字典)	计算字典内的元素数量

序列切片

序列是指内容连续、有序，可使用下标索引的一类数据容器,列表、元组、字符串，均可以可以视为序列。
序列支持切片，即列表、元组、字符串，均支持进行切片操作
切片：从一个序列中，取出一个子序列

语法：序列[起始下标:结束下标:步长]
表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列

容器比较

列表	元组	字符串	集合	字典
元素数量	支持多个	支持多个	支持多个	支持多个
元素类型	任意	任意	仅字符	任意
下标索引	支持	支持	支持	不支持
重复元素	支持	支持	支持	不支持
可修改性	支持	不支持	不支持	支持
数据有序	是	是	是	否
使用场景	可修改、可重复的一批数据记录场景	不可修改、可重复的一批数据记录场景	一串字符的记录场景	不可重复的数据记录场景

数据容器的通用操作

功能	描述
通用for循环	遍历容器（字典是遍历key）
max()	容器内最大元素
min()	容器内最小元素
len()	容器元素个数
list()	转换为列表
tuple()	转换为元组
str()	转换为字符串
set()	转换为集合
sorted(序列, [reverse=True])	排序，reverse=True表示降序 得到一个排好序的列表

判断语句

age = 10
if age > 5:
    print('大于5')
elif age > 10:
    print('大于10')
else:
    print('其他')

循环语句

while循环

"""
while 条件:
    条件满足时执行的代码
"""
i = 0
while i < 100:
    print(i)
    i = i + 1

for循环

"""
for 临时变量 in 待处理的数据集:
    循环执行的代码
"""
for i in 'abcdefg':
    print(i)

语法中的：待处理数据集，严格来说，称之为：可迭代类型，包括：字符串、列表、元组
使用range进行循环

"""
range(num)  从0开始，到num结束（不含num本身）
range(num1, num2) 从num1开始，到num2结束（不含num2本身）
range(num1, num2, step) 从num1开始，到num2结束（不含num2本身），步长以step值为准
"""
for i in range(5):
    print(i)

循环中断：
continue：中断所在循环的当次执行，直接进入下一次
break：直接结束所在的循环
在嵌套循环中，只能作用在所在的循环上，无法对上层循环起作用

函数

函数定义

传入参数不需要时可以省略
返回值不需要时可以省略，没有return时，返回值为None
在函数内部定义全局变量使用globle关键字

def 函数名(x, y):
	"""
	函数说明
	:param x : 形参x
	:param y : 形参y
	:return: 返回值说明
	"""
	函数体
	return 返回值

函数多返回值

按照返回值的顺序，写对应顺序的多个变量接收即可
变量之间用逗号隔开
支持不同类型的数据return

def test_return():
	return 1, 2
x, y = test_return()
print(x, y)

函数参数

位置参数
调用函数时根据函数定义的参数位置来传递参数,传递的参数和定义的参数的顺序及个数必须一致

def user_inf(name, age, gender):
	print(name, age, gender)
user_info('Bob', 29, 'Male')

关键字参数
函数调用时通过“键=值”形式传递参数

def user_inf(name, age, gender):
	print(name, age, gender)
# 关键字参数
user_info(name='小王', age=11, gender='女')
# 可以不按照参数的定义顺序传参
user_info(age=10, gender='女', name='潇潇')    
# 可以与位置参数混用，位置参数必须在前，且匹配参数位置
user_info('甜甜', gender='女', age=9)

缺省参数
缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调用）

def user_inf(name, age, gender='Male'):
	print(name, age, gender)
user_info('Bob', 29)
user_info('Lucy', 29, 'Female')

不定长参数
数也叫可变参数. 用于不确定调用的时候会传递多少个参数(不传参也可以)的场景
位置传递：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple)，args是元组类型，这就是位置传递

# 位置传递
def user_inf(*args):
	print(args)
user_info('Tom')
user_info('Lucy', 29)

关键字传递：参数是“键=值”形式的形式的情况下, 所有的“键=值”都会被kwargs接受, 同时会根据“键=值”组成字典

# 关键字传递
def user_inf(**kwargs):
	print(kwargs)
user_info(name='Tom', age=29, id='110')

匿名函数

函数作为参数传递
函数本身，也可以作为参数传入另一个函数内，不仅仅是相加，相见、相除、等任何逻辑都可以自行定义并作为函数传入

def test_func(compute):
	result = compute(1, 2)
	print(result)

def compute(x, y):
	return x + y

test_func(compute)

匿名函数
函数的定义中
def关键字，可以定义带有名称的函数
lambda关键字，可以定义匿名函数（无名称）
有名称的函数，可以基于名称重复使用。
无名称的匿名函数，只可临时使用一次。

匿名函数定义语法：

lambda 传入参数: 函数体(一行代码)

def test_func(compute):
	result = compute(1, 2)
	print(result)
test_func(lambda x, y : x + y)

注意：匿名函数的定义中，函数体只能写一行代码，如果函数体要写多行代码，不可用lambda匿名函数，应使用def定义带名函数

异常

try:
	可能发生异常的语句
except[异常 as 别名:]
	出现异常的处理
[else:]
	为出现异常的处理
[finally:]
	始终都会执行的操作

例如：

# 不会特定异常
try:
    print(num)
except (NameError, ZeroDivisionError) as e:
    print(e)

# 捕获所有异常
try:
    print(name)
except Exception:
    pass
    
try:
    print(name)
except:
    pass

try:
    print(name)
except Exception as e:
    print(e)

模块与包

Python 模块

Python 模块(Module)是一个 Python 文件，以 .py 结尾. 模块能定义函数，类和变量，模块里也能包含可执行的代码.
模块在使用前需要先导入 导入的语法如下:

[from 模块名] import [模块| 类 | 变量 | 函数 | *] [as 别名]

如果一个模块文件中有__all__变量，当使用from xxx import *导入时，只能导入这个列表中的元素

__all__ = ['A']

Python包

从物理上看，包就是一个文件夹，在该文件夹下包含了一个 init.py 文件，该文件夹可用于包含多个模块文件
从逻辑上看，包的本质依然是模块
当我们的模块文件越来越多时,包可以帮助我们管理这些模块, 包的作用就是包含多个模块，但包的本质依然是模块
在__init__.py文件中添加 __all__ = []，控制允许导入的模块列表，all 针对的是 ’ from … import * ‘ 这种方式，对 ‘ import xxx ’ 这种方式无效

不同目录Python模块的导入

在 Python 中，如果两个 .py 文件位于不同的文件夹中，要实现一个文件导入另一个文件中的内容，关键在于 确保被导入的模块（文件）在 Python 的模块搜索路径（sys.path）中。以下是几种常见的方法。
假设目录结构如下：

project/
├── folder1/
│   └── module1.py
└── folder2/
    └── module2.py

方法一：使用相对导入（推荐用于包结构）
在每个文件夹中添加 init.py（可以是空文件）

project/
├── __init__.py
├── folder1/
│   ├── __init__.py
│   └── module1.py
└── folder2/
    ├── __init__.py
    └── module2.py

从项目根目录运行（不能直接运行 module2.py，否则相对导入会失败）

python -m folder2.module2

在 module2.py 中使用相对导入

from ..folder1.module1 import some_function

方法二：修改 sys.path（简单但不够规范）
在 module2.py 中临时将 folder1 的路径加入 sys.path

import sys
import os

# 获取当前文件所在目录
current_dir = os.path.dirname(os.path.abspath(__file__))
# 获取项目根目录（假设 folder1 和 folder2 同级）
project_root = os.path.dirname(current_dir)
# 将 folder1 路径加入 sys.path
sys.path.append(os.path.join(project_root, 'folder1'))

# 现在可以导入 module1
import module1
# 或
from module1 import some_function

方法三：设置 PYTHONPATH 环境变量
在运行脚本前，设置环境变量 PYTHONPATH 指向项目根目录

# Linux/macOS
export PYTHONPATH="${PYTHONPATH}:/path/to/project"
python folder2/module2.py

# Windows (PowerShell)
$env:PYTHONPATH += ";C:\path\to\project"
python folder2/module2.py

然后在 module2.py 中可以直接

from folder1.module1 import some_function

方法四：使用 importlib 动态导入

import importlib.util
import os

spec = importlib.util.spec_from_file_location(
    "module1",
    os.path.join(os.path.dirname(__file__), "..", "folder1", "module1.py")
)
module1 = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module1)

# 使用 module1 中的内容
module1.some_function()

面向对象

类的定义

class 类名称:
	成员变量

	def 成员方法(self, 参数列表):
		成员方法体

对象 = 类名称()

self的作用：表示类对象本身；只有通过self成员方法才能访问成员变量；self出现在形参列表中，但是不占用形参位置参数

构造方法

Python类可以使用 __init__ 方法，称之为构造方法，在创建类对象（构造类）的时候，会自动执行

class Student:
    # 成员变量为None可以省略
	name = None
	age = None
	tel = None	

	def __init__(self, name, age, tel):
		self.name = name
		self.age = age
		self.tel = tel
stu = Student('Mark', 29, '13600000000')

其他内置方法

方法	功能
init	构造方法，可用于创建类对象的时候设置初始化行为
str	用于实现类对象转字符串的行为
lt	用于2个类对象进行小于或大于比较
le	用于2个类对象进行小于等于或大于等于比较
eq	用于2个类对象进行相等比较

封装

将现实世界事物在类中描述为属性和方法，即为封装。
现实事物有部分属性和行为是不公开对使用者开放的。同样在类中描述属性和方法的时候也需要达到这个要求，就需要定义私有成员了
成员变量和成员方法的命名均以 __ 作为开头即可
类对象无法访问私有成员，类中的其它成员可以访问私有成员

class Student:
	# 私有成员变量
	__address = None

	# 私有方法
	def __get_address(self):
		return self.address

继承

继承就是一个类，继承另外一个类的成员变量和成员方法
单继承：一个类继承另一个类
多继承：一个类继承多个类，按照顺序从左向右依次继承
多继承中，如果父类有同名方法或属性，先继承的优先级高于后继承

class 类(父类,[父类2, 父类3...]):
	内容

复写的语法：在子类中重新实现同名成员方法或成员属性
调用父类成员：
父类名.成员变量、父类名.成员方法
super().成员变量、super().成员方法

多态

# 演示抽象类
class AC:
    def cool_wind(self):
        """制冷"""
        pass

    def hot_wind(self):
        """制热"""
        pass

    def swing_l_r(self):
        """左右摆风"""
        pass


class Midea_AC(AC):
    def cool_wind(self):
        print("美的空调制冷")

    def hot_wind(self):
        print("美的空调制热")

    def swing_l_r(self):
        print("美的空调左右摆风")


class GREE_AC(AC):
    def cool_wind(self):
        print("格力空调制冷")

    def hot_wind(self):
        print("格力空调制热")

    def swing_l_r(self):
        print("格力空调左右摆风")


def make_cool(ac: AC):
    ac.cool_wind()


midea_ac = Midea_AC()
gree_ac = GREE_AC()


make_cool(midea_ac)
make_cool(gree_ac)

类型注解

Python在3.5版本的时候引入了类型注解，以方便静态类型检查工具，IDE等第三方工具。
类型注解：在代码中涉及数据交互的地方，提供数据类型的注解（显式的说明）。
主要功能：
帮助第三方IDE工具（如PyCharm）对代码进行类型推断，协助做代码提示
帮助开发者自身对变量进行类型注释
支持：变量的类型注解，函数（方法）形参列表和返回值的类型注解
变量的类型注解语法:
语法1： 变量: 类型
语法2： 在注释中，# type: 类型

函数（方法）的类型注解语法:

def 函数方法(形参:类型...) -> 返回值类型:
	pass

Union类型
使用Union可以定义联合类型注解
.Union的使用方式
导包：from typing import Union
使用：Union[类型, …, 类型]

注意：类型注解只是提示性的，并非决定性的。数据类型和注解类型无法对应也不会导致错误

文件操作

文件读取

操作	功能
文件对象 = open(file, mode, encoding)	打开文件获得文件对象
文件对象.read(num)	读取指定长度字节，不指定num读取文件全部
文件对象.readline()	读取一行
文件对象.readlines()	读取全部行，得到列表
for line in 文件对象	for循环文件行，一次循环得到一行数据
文件对象.close()	关闭文件对象
with open() as f	通过with open语法打开文件，可以自动关闭

文件写入

# 打开文件，不存在的文件, r, w, a
import time
# 打开一个存在的文件
f = open("test.txt", "w", encoding="UTF-8")
# write写入
f.write("abcde")
# close关闭
f.close()

追加写入，通过a模式打开文件

f = open("test.txt", "a", encoding="UTF-8")
# write写入、flush刷新
f.write("efgh")
# close关闭
f.close()