Python入门

声明：本文内容由本人在网上整理并结合个人理解进行编写，我会尽可能的详细记录，希望对想要入门python的同学有所帮助

名词解释：

IDE ：集成开发环境（Integrated Development Environment）的缩写， 一般指集成的开发环境，比如pycharm

基础语法规则

Python 基础语法是编写代码的核心框架，相比其他语言更简洁、易读，核心特点是缩进敏感、动态类型、语法简洁。以下从核心语法规则到常用语法模块，逐一拆解说明。

tips:在python语句中，所有标点符号均是英文输入法状态下的符号，中文符号不能用!!!

缩进

python使用**缩进（4个空格或者1个Tab）**进行代码层级的区分，缩进不一致会直接报错。这一点python与其他语言是不一样的

正确示例如下：

# python缩进展示
if 3 > 2: #一下内容均属于这个if代码块
    print('3 大于 2')
    if 4 < 5:# 这是一个嵌套在if中的if，下面这个print属于当前if
        print('4 小于 5')

一般来说，如果是使用IDE进行编码，换行时会自动进行缩进，大多数情况下不需要关心缩进问题，但是如果你想在一个代码块底下写第二个代码，这个时候就需要手动进行调整缩进

假如我们在写代码的时候，写了一个很长的语句，需要进行换行操作，这个时候可以使用 \ 实现单个语句换行操作

换行主要是为了在语句过长时，保证代码美观的同时提升可读性

a = 10
b = a + 10 \
    + 10 \
    + 22 \
    + 33
print(b) # 输出85

注释

这个时候有的同学就会发现，在上一份代码中，运行完成后，好像有的部分并没有执行，没错！

这就是注释的功劳

在python中，有两种注释：单行注释（以**#开头）和多行注释（以3对单引号’或者3对双引号"**包裹）

1、单行注释

以**#**开头，后续内容只有我们自己可以看见，程序运行时电脑不可见

每个 # 只能注释一行内容，不负责下一行的注释与否

# 这是一行注释
# 这也是一行注释
print('hello') # 行尾也能注释

2、多行注释

如果想要进行多行注释就需要使用’‘’‘’',或者"“”“”"，单引号与双引号使用方法一致，就不过多赘述了，但是不能两个进行混用，否则可能会发生意想不到的事情哦

# 下面是一个多行注释

'''可以这样'''

# 下面也是一个多行注释

'''也可以
这样
'''
# 下面也是一个多行注释

'''
甚
至
是
这
样
'''

在IDE中，注释掉的部分，和正常代码的颜色不一样，应该很好区分的

标识符和命名规则

标识符的作用就相当于我们养了小宠物，在想要逗它玩的时候，总不能直接说：那个谁，过来一下

标识符就相当于给我们的小宠物取了一个名字，可以更加方便沟通

标识符是变量、函数、类等的名字，规则：

• 由字母（A-Z/a-z）、数字（0-9）、下划线（_）组成
• 不能以数字开头
• 区分大小写（age 和 Age 是两个不同变量）
• 不能使用 Python 关键字（如 if、for、def 等）

# 合法命名
name = "小明"
age_18 = True
_name = "私有变量"  # 习惯用下划线开头表示私有

# 非法命名
18_age = 18  # 以数字开头，报错
if = 5       # 使用关键字，报错

关键字

Python 内置的有特殊含义的单词，不能作为标识符。可通过以下代码查看所有关键字：

import keyword
print(keyword.kwlist)
# 输出示例：['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', ...]

语句结束标识

Python 一行代码默认是一条语句，无需加分号 ;（加了也不报错，但不推荐）；若一行想写多条语句，需用 ; 分隔。一行写多条语句会导致代码可读性变差，故不推荐这么写。

# 推荐写法（单行单语句）
print(1)
print(2)

# 不推荐（单行多语句）
print(1); print(2)

变量与数据类型

变量赋值

Python 是动态类型语言，变量无需声明类型，赋值时自动确定类型，等号 = 是赋值符号（不是等于）。

a = 10          # 整数
b = 3.14        # 浮点数
c = "Python"    # 字符串
d = True        # 布尔值
e = None        # 空值（表示无内容，不是0/空字符串）

除了每次进行单个变量进行赋值，也可以有如下赋值方法

a, b, c, d = 10,"这个是b", 3.14159,True # 一行赋值多个变量
print(a)
print(b)
print(c)
print(d)

采用以上赋值方式也是可以的

基本数据类型

类型	说明	示例	常用操作
int（整数）	正 / 负整数、0	num = 10	算术运算、比较运算
float（浮点）	带小数的数	pi = 3.1415	同 int，注意浮点精度（如 0.1+0.2≠0.3）
str（字符串）	文本，单 / 双 / 三引号包裹	s = "hello"	切片、拼接、替换、查找
bool（布尔）	只有 True/False（首字母大写）	flag = False	逻辑运算、条件判断
NoneType（空值）	表示 “无”	n = None	判断是否为空（if n is None）

在看见一个变量不确定其类型的时候，可以使用 type 函数进行判断

a, b, c, d, e = 10,"这个是b", 3.14159,True,None
# 使用type判断数据类型
print(type(a))
print(type(b))
print(type(c))
print(type(d))
print(type(e))

会得到如下输出：

<class 'int'>
<class 'str'>
<class 'float'>
<class 'bool'>
<class 'NoneType'>

类型转换

当需要不同类型交互时，可通过内置函数转换：

# 转整数
print(int("123"))   # 123（字符串转整数）
print(int(3.9))     # 3（浮点数转整数，直接截断小数）

# 转浮点数
print(float(10))    # 10.0（整数转浮点数）
print(float("3.14"))# 3.14（字符串转浮点数）

# 转字符串
print(str(100))     # "100"（整数转字符串）
print(str(True))    # "True"（布尔值转字符串）

# 转布尔值（空/0为False，其余为True）
print(bool(0))      # False
print(bool(""))     # False
print(bool([1]))    # True

运算符

运算符是用来实现数据运算的符号，比如我们数学中常用的 加、减、乘、除、大于、小于、等于 等等

Python 运算符主要分为 7 大类，按常用程度排序：

• 算术运算符（数学运算）
• 赋值运算符（变量赋值）
• 比较运算符（条件判断）
• 逻辑运算符（布尔运算）
• 成员运算符（判断归属）
• 身份运算符（判断内存地址）
• 位运算符（二进制运算，新手先了解）

算术运算符

用于实现加减乘除等运算

运算符	名称	作用	示例	结果	注意点
+	加法	两数相加 / 字符串拼接	3+5/"a"+"b"	8/“ab”	字符串只能和字符串拼接
-	减法	两数相减	10-4	6	-
*	乘法	两数相乘 / 字符串重复	4*6/"a"*3	24/“aaa”	字符串只能和整数相乘
/	除法	两数相除，返回浮点数	10/3	3.333…	结果永远是 float
//	整除	向下取整的除法	10//3/-10//3	3/-4	负数整除会向下取整（不是四舍五入）
%	取余（模）	返回除法余数	10%3/-10%3	1/2	余数符号和除数一致
**	幂运算	求次方	2**3/4**0.5	8/2.0	支持小数次方（开根号）

示例代码

# 基础算术运算
print(3 + 5)       # 8（加法）
print(10 - 4)      # 6（减法）
print(4 * 6)       # 24（乘法）
print(10 / 3)      # 3.3333333333333335（除法，返回浮点数）
print(10 // 3)     # 3（整除，向下取整）
print(10 % 3)      # 1（取余）
print(2 ** 3)      # 8（幂运算）

# 特殊场景
print("Python" + "入门")  # Python入门（字符串拼接）
print("*" * 5)            # *****（字符串重复）
print(-10 // 3)           # -4（负数整除向下取整）
print(-10 % 3)            # 2（余数和除数同符号）
print(16 ** 0.5)          # 4.0（开平方）

赋值运算符（变量赋值）

用于给变量赋值，核心是 =，还有「复合赋值符」简化代码（结合算术运算符）。

运算符	示例	等价于	作用
=	a = 10	-	基础赋值
+=	a += 5	a = a + 5	加后赋值
-=	a -= 3	a = a - 3	减后赋值
*=	a *= 2	a = a * 2	乘后赋值
/=	a /= 2	a = a / 2	除后赋值
//=	a //= 3	a = a // 3	整除后赋值
%=	a %= 3	a = a % 3	取余后赋值
**=	a **= 2	a = a ** 2	幂运算后赋值

示例：

a = 10
a += 5  # 等价于 a = a + 5 → a=15
print(a)  # 15

a *= 2   # 等价于 a = a * 2 → a=30
print(a)  # 30

a %= 7   # 等价于 a = a % 7 → a=2
print(a)  # 2

比较运算符（条件判断）

用于比较两个值的关系，返回结果永远是布尔值（True/False），是 if/while 等流程控制的核心。

运算符	名称	示例	结果	注意点
==	等于	5==5	True	注意区分 =（赋值）和 ==（判断相等）
!=	不等于	5!=3	True	Python2 中可用 <>，Python3 已废弃
>	大于	6>4	True	-
<	小于	2<7	True	-
>=	大于等于	8>=8	True	-
<=	小于等于	3<=5	True	-

x = 8
y = 5

print(x == y)  # False（8不等于5）
print(x != y)  # True（8不等于5）
print(x >= y)  # True（8大于等于5）

逻辑运算符（布尔运算）

用于组合多个布尔值，返回最终的布尔结果，核心是 and/or/not，有「短路求值」特性（提升效率）。

运算符	名称	逻辑规则	示例	结果	短路特性
and	逻辑与	所有条件为 True，结果才为 True	(5>3) and (2<4)	True	左边为 False 时，右边不执行
or	逻辑或	任意一个条件为 True，结果就为 True	(5>10) or (2<4)	True	左边为 True 时，右边不执行
not	逻辑非	取反（True 变 False，False 变 True）	not (5>3)	False	无短路（只有一个操

示例：

# 基础用法
print((3 > 1) and (4 < 6))  # True
print((3 > 5) or (4 < 6))   # True
print(not (3 > 1))          # False

# 短路求值示例（关键！）
a = 0
# and短路：左边False，右边a+=1不执行
if (10 < 5) and (a += 1):
    pass
print(a)  # 0（a没变化）

# or短路：左边True，右边a+=1不执行
if (10 > 5) or (a += 1):
    pass
print(a)  # 0（a仍没变化）

成员运算符（判断归属）

用于判断一个元素是否存在于「可迭代对象」中（列表、字符串、字典等），返回布尔值。

运算符	名称	作用	示例	结果
in	存在	判断元素是否在序列中	"a" in "abc"/2 in [1,2,3]	True
not in	不存在	判断元素是否不在序列中	4 not in [1,2,3]	True

示例：

# 列表判断
lst = [1, 2, 3, 4]
print(3 in lst)      # True
print(5 not in lst)  # True

# 字符串判断
s = "Python"
print("y" in s)      # True
print("z" not in s)  # True

# 字典判断（默认判断键，不是值）
dic = {"name": "小明", "age": 18}
print("name" in dic)    # True（判断键）
print("小明" in dic)    # False（值不在键中）
print("小明" in dic.values())  # True（判断值）

身份运算符（判断内存地址）

用于判断两个变量是否指向「同一个内存对象」（不是值相等，而是地址相同），新手需区分 is 和 ==。

运算符	名称	作用	示例	说明
is	是	判断两个变量指向同一对象	a is b	比较内存地址
is not	不是	判断两个变量指向不同对象	a is not b	比较内存地址

示例：

# 示例1：小整数池（Python优化，-5~256的整数复用内存）
a = 10
b = 10
print(a == b)   # True（值相等）
print(a is b)   # True（地址相同）

# 示例2：大整数（超出小整数池，地址不同）
c = 257
d = 257
print(c == d)   # True（值相等）
print(c is d)   # False（地址不同）

# 示例3：列表（可变对象，即使值相同，地址也不同）
lst1 = [1,2,3]
lst2 = [1,2,3]
print(lst1 == lst2)  # True（值相等）
print(lst1 is lst2)  # False（地址不同）

# 示例4：None的判断（推荐用is，不是==）
n = None
print(n is None)  # True（推荐写法）
# print(n == None)  # 不推荐

位运算符（了解即可）

按二进制位进行运算，常用于底层编程、性能优化，日常开发中使用较少。

运算符	名称	作用	示例（二进制）
&	按位与	对应位都为 1 则为 1，否则 0	6 & 3 → 二进制 110 & 011 = 010 → 2
`	`	按位或	对应位有一个 1 则为 1	`6	3→110	011 = 111` → 7
^	按位异或	对应位不同则为 1，相同则 0	6 ^ 3 → 110 ^ 011 = 101 → 5
~	按位取反	按位取反（~x = -x-1）	~6 → -7
<<	左移	左移 n 位，等价于 ×2ⁿ	6 << 1 → 12（110→1100）
>>	右移	右移 n 位，等价于 ÷2ⁿ（整除）	6 >> 1 → 3（110→11）

运算符优先级

当一行代码中有多个运算符时，Python 会按「优先级」执行，优先级从高到低排序（只列常用的）：

1. 括号 ()（最高优先级，可手动改变执行顺序）
2. 幂运算 **
3. 算术运算符（*//////% > +/-）
4. 比较运算符（==/!=/>/</>=/<=）
5. 身份运算符（is/is not）
6. 成员运算符（in/not in）
7. 逻辑运算符（not > and > or）
8. 赋值运算符（=/+=/-= 等，最低优先级）

示例：

# 优先级示例1：括号改变顺序
print(2 + 3 * 4)    # 14（先乘后加）
print((2 + 3) * 4)  # 20（先算括号内）

# 优先级示例2：逻辑运算符
print(not 5 > 3 and 6 < 4)  # False
# 步骤：5>3→True → not True→False → False and False→False