代码收藏家技术教程 12天前

Python基础语法入门详解

输入输出：

输出

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

objects：这是一个可变参数，意味着你可以传入任意数量的对象。print 函数会将这些对象依次打印出来。在函数内部，这些对象会被转换为字符串形式。

sep：用于分隔多个对象的字符串，默认值是一个空格字符 ' '。如果你传入多个对象，print 会在它们之间插入 sep 指定的字符串。

end：在打印完所有对象后追加的字符串，默认值是换行符 '\n'。这意味着每次调用 print 函数后，会自动换行。你可以修改这个参数，比如让 print 不换行，或者在末尾添加其他字符。

file：指定输出的目标文件对象，默认是标准输出 sys.stdout，也就是控制台。你可以传入一个已打开的文件对象，将输出内容写入文件。

print("Hello Python!")

with open("./xxx.txt", 'w') as f:
    print(abc, file=f)  # 直接将abc直接写入xxx.txt文件

import time
print(a, b, c, sep="*", end="\n\n")  # 把三个数字a，b，c转成字符串写入，并用"*"分隔，在结尾部分写入两个换行
print("Loading", end="")
for i in range(10):
    # 如果这里flush为False，则要在10次循环结束之后，终端才会现实结果
    # 而flush为True，则每次循环都会刷新输出一次结果，看起来就是动态的效果
    print(".", end='', flush=True)
    time.sleep(1)  # 延迟1秒再往后执行

输入

input([prompt])

[prompt]：此为可选参数，是一个字符串。当提供该参数时，input 函数会先将这个字符串显示在控制台，当作提示信息，string 类型。

input函数会返回用户输入的内容，并且返回值的类型为字符串。

a = input("请输入")
print(a, "Python是世界上最好的语言")

a = input("请输入") print(a, "Python是世界上最好的语言")

基础语法规则

行结构：

逻辑行基本概念：

一个 Python 程序由多个逻辑行组成。逻辑行是程序中表达一个完整逻辑的代码单元。

单语句单行原则：

通常情况下，一个语句对应一行代码，不会跨越多行。每个语句独立存在，表达一个明确的操作或功能。

示例说明：

例如下面的 Python 程序，它包含 3 个逻辑行，每一行都通过print()函数输出一个结果：

print("这是第一个输出结果")
print("这是第二个输出结果")
print("这是第三个输出结果")

print("这是第一个输出结果") print("这是第二个输出结果") print("这是第三个输出结果")

错误示范：

print(这是第一
个输出结果)

print(这是第二
个输出结果)

print(这是第三
个输出结果)

#而如果是上面这种写法，程序执行是会运行报错的，因为print() 的一个语句跨越了 2 行

print(这是第一个输出结果) print(这是第二个输出结果) print(这是第三个输出结果) #而如果是上面这种写法，程序执行是会运行报错的，因为print() 的一个语句跨越了 2 行

其他示范：

#其实也可以把多个语句利用英文输入下的分号（ ; ）写在一行之内，不过通常并不这么做
print("这是第一个输出结果"); print("这是第二个输出结果"); print("这是第三个输出结果")

#也有语句是可以跨越多行的，比如：复合语句。复合语句由多行子语句组成，通常它会跨越多行
#比如下面的 if ... else ... 语句就是一个复合语句，它跨越了多行

target = 27
if target < 3:
    print(True)
else:
    print(False)


#有的时候，整个复合语句也可能包含于一行之内
#下面这种写法，叫做三元表达式，它把 if ... else ... 复合语句写在了一行之内
target = 27
print(True) if a < 3 else print(False)

#其实也可以把多个语句利用英文输入下的分号（ ; ）写在一行之内，不过通常并不这么做 print("这是第一个输出结果"); print("这是第二个输出结果"); print("这是第三个输出结果") #也有语句是可以跨越多行的，比如：复合语句。复合语句由多行子语句组成，通常它会跨越多行 #比如下面的 if … else … 语句就是一个复合语句，它跨越了多行 target = 27 if target < 3: print(True) else: print(False) #有的时候，整个复合语句也可能包含于一行之内 #下面这种写法，叫做三元表达式，它把 if … else … 复合语句写在了一行之内 target = 27 print(True) if a < 3 else print(False)

缩进：

在 Python 里，逻辑行开头的空白用于确定缩进等级，以此明确语句段落的组织结构。

以 if 语句为例，若第一个 print() 前有空白，即存在缩进，表明它是 if 语句的下级；第二个 print() 无缩进，则和 if 语句平级。若 if 条件不成立，第一个 print() 不会执行，而第二个 print() 不受影响，仍会执行。

target = 27
if target < 3:
    print(True)
print(target)

#在 IDE 编写程序，需缩进的语句敲回车换行后会自动缩进，通常占 4 个空格。
#我们一般用 Tab 键缩进（多数 IDE 可设置），而非按 4 次空格。
#缩进空格数可变，但同一代码块的语句缩进空格数必须相同。

target = 27
if target < 3:
  print(True)
     print(target)  # 这个缩进不对，同为if语句下的代码，应和上面的print缩进一样
else:
       print(False)  # 这个缩进是对的，在else语句下面，可以和if语句下的print缩进不一样
print(789)  # 这个print是在if...else...语句外的，是平级的，故而不需要缩进

target = 27 if target < 3: print(True) print(target) #在 IDE 编写程序，需缩进的语句敲回车换行后会自动缩进，通常占 4 个空格。 #我们一般用 Tab 键缩进（多数 IDE 可设置），而非按 4 次空格。 #缩进空格数可变，但同一代码块的语句缩进空格数必须相同。 target = 27 if target < 3: print(True) print(target) # 这个缩进不对，同为if语句下的代码，应和上面的print缩进一样 else: print(False) # 这个缩进是对的，在else语句下面，可以和if语句下的print缩进不一样 print(789) # 这个print是在if…else…语句外的，是平级的，故而不需要缩进

注释：

在 Python 代码的世界里，注释如同隐形的助手，在解释器进行语法分析的过程中会被直接无视。通俗来讲，注释是给程序员阅读、理解代码逻辑用的，程序在执行时，注释就像不存在一样，不会对程序运行产生任何影响。

Python 中，单行注释以 # 开头，用来对某一行代码或一小段逻辑进行解释。如果需要注释多行内容，有两种常见方式：一是每行都以 # 开头；二是使用三引号（单引号 ''' 或双引号 """ 均可）将注释内容包裹起来。

print(27)
# 这是第一个注释

# 这是第二个注释

'''
这是第三个注释
三引号可以进行多行注释
'''

"""
这是第四个注释
三引号可以进行多行注释
"""

print("Hello, Python!")  # 这是第五个注释

print(27) # 这是第一个注释 # 这是第二个注释 ''' 这是第三个注释三引号可以进行多行注释 ''' """ 这是第四个注释三引号可以进行多行注释 """ print("Hello, Python!") # 这是第五个注释

语句拼接：

Python 一般一行写一条语句，若语句过长，可使用反斜杠（\）进行显式行拼接，将其拆成多行书写。

""" 下面 a,b 两种写法都是对的，它们二者结果是一样的 """
a = 1 + 2 + 3
b = 1 + \
    2 + \
    3

""" 下面 a,b 两种写法都是对的，它们二者结果是一样的 """ a = 1 + 2 + 3 b = 1 + \ 2 + \ 3

在 Python 中，若语句位于圆括号、方括号或花括号内，即便跨越多行书写，也无需使用反斜杠（\）进行显式的行拼接，这种方式被称为隐式的行拼接。如此一来，代码能够自然地跨行书写，使代码的编写更加简洁、易读。

long_list = [
    1, 2, 3,
    4, 5, 6
]

变量：

变量，简单来说就是在计算机语言里能够存储计算结果，或者用以代表特定数值的抽象概念，其关键特性就在于它是可以改变的量。

在编程实践中，变量必须先经过定义才能被使用。当解释器运行到变量定义的相关代码片段时，会在内存中开辟出一块空间，用于存放变量所对应的值，随后将这块内存空间的地址与所设定的变量名进行绑定。

从构成要素来看，变量的定义包含三个关键部分：

其一，变量名，它如同一个指向标，直接关联着变量值所在的内存地址，我们在程序中正是通过这个名称来获取和访问对应的值；

其二，等于号（=），这是一个具有关键意义的赋值符号，其核心作用在于建立起变量名与内存地址之间的绑定关系，使得两者紧密相连；

其三，值，也就是实实在在存储在内存地址当中的数据，它是变量的核心内容承载部分。另外，还有标识符这一概念，它广泛应用于变量、函数、类、模块等的命名过程，起到区分和标识不同编程元素的作用，为代码的组织与编写提供了清晰的框架。

命名规范：

变量名仅能包含字母、数字和下划线，且禁止以数字开头，同时不能出现空格，若想分隔多个单词，可借助下划线达成。

绝对不能用 Python 的关键字以及内置函数名当作变量名

变量名应尽量简短且具备描述性，要做到短小精悍、见名知义。

另外，Python 对变量名的大小写是敏感的，像 `Name` 和 `name` 代表的就是两个不同的变量。

在命名时也可参考驼峰命名法，以此让命名更规范、易读。

内置函数：

内置函数

功能简介

示例

示例说明

abs()	返回一个数的绝对值	num = -5; result = abs(num)	将 -5 的绝对值 5 赋给 result
all()	可迭代对象元素全为真时返回 True，空可迭代对象也返回 True	result = all([True, True])	列表元素都为 True，返回 True
any()	可迭代对象只要有一个元素为真就返回 True，空可迭代对象返回 False	result = any([False, True])	列表有一个 True，返回 True
ascii()	返回对象的可打印 ASCII 表示形式	s = "你好"; result = ascii(s)	如将字符串转为类似 '\u4f60\u597d' 的 ASCII 表示
bin()	将整数转换为二进制字符串	num = 10; result = bin(num)	把 10 转为 '0b1010'
bool()	将对象转换为布尔值	result = bool(1)	1 转换为 True
breakpoint()	暂停程序执行，进入调试模式（Python 3.7+）	breakpoint()	程序运行到此处暂停，可调试
bytearray()	创建可变字节数组	arr = bytearray(b'abc')	创建包含 'abc' 的字节数组
bytes()	创建不可变字节对象	b = bytes(b'abc')	创建不可变的 'abc' 字节对象
callable()	判断对象是否可调用（如函数、方法等）	result = callable(print)	print 可调用，返回 True
chr()	将 Unicode 编码整数转换为对应的字符	result = chr(97)	97 转为字符 'a'
classmethod()	将方法转换为类方法	class A:<br> @classmethod<br> def cm(cls):<br> pass	定义类 A 的类方法 cm
compile()	将字符串编译为代码对象	code = compile('print("Hello")', '<string>', 'exec')	编译字符串为可执行代码对象
complex()	创建复数对象	c = complex(1, 2)	创建复数 1 + 2j
delattr()	删除对象的属性	class A:<br> x = 1<br>a = A(); delattr(a, 'x')	删除实例 a 的属性 x
dict()	创建字典	d = dict(a=1, b=2)	创建字典 {'a': 1, 'b': 2}
dir()	返回对象的属性和方法列表，无参数时返回当前作用域名称列表	result = dir([1, 2, 3])	得到列表的属性和方法列表
divmod()	返回除法的商和余数组成的元组	result = divmod(7, 2)	结果为 (3, 1)
enumerate()	为可迭代对象添加索引，返回枚举对象	for i, v in enumerate(['a', 'b']):<br> print(i, v)	依次输出 0 a，1 b
eval()	计算字符串表达式的值	result = eval('1 + 2')	计算结果为 3
exec()	执行字符串或代码对象中的 Python 代码	exec('print("Executing")')	执行并打印 "Executing"
filter()	过滤可迭代对象，返回使函数返回 True 的元素组成的迭代器	result = list(filter(lambda x: x > 2, [1, 3, 2]))	得到 [3]
float()	将对象转换为浮点数	result = float('3.14')	字符串转浮点数 3.14
format()	格式化字符串	result = format(3.14159, '.2f')	格式化 3.14159 为保留两位小数的 '3.14'
frozenset()	创建不可变集合	fs = frozenset([1, 2, 3])	创建不可变集合
getattr()	获取对象的属性值	class A:<br> x = 1<br>a = A(); result = getattr(a, 'x')	获取实例 a 的属性 x 的值 1
globals()	返回全局符号表字典	g = globals()	获取全局变量字典
hasattr()	判断对象是否有指定属性	class A:<br> x = 1<br>a = A(); result = hasattr(a, 'x')	有属性 x，返回 True
hash()	返回对象的哈希值	result = hash('abc')	返回字符串 'abc' 的哈希值
help()	提供对象的帮助信息	help(print)	显示 print 函数的帮助文档
hex()	将整数转换为十六进制字符串	num = 15; result = hex(num)	15 转为 '0xf'
id()	返回对象的内存地址（唯一标识）	obj = [1, 2]; result = id(obj)	返回列表对象的内存地址
input()	从标准输入读取一行文本，返回字符串	name = input("请输入名字：")	等待用户输入并赋值给 name
int()	将对象转换为整数	result = int('123')	字符串转整数 123
isinstance()	判断对象是否为指定类（或子类）的实例	class A:<br> pass<br>a = A(); result = isinstance(a, A)	a 是 A 的实例，返回 True
issubclass()	判断一个类是否是另一个类的子类	class A:<br> pass<br>class B(A):<br> pass<br>result = issubclass(B, A)	B 是 A 的子类，返回 True
iter()	返回迭代器对象	lst = [1, 2, 3]; it = iter(lst)	获取列表的迭代器
len()	返回对象长度或元素个数	result = len([1, 2, 3])	列表长度为 3
list()	将可迭代对象转换为列表	result = list((1, 2, 3))	元组转列表 [1, 2, 3]
locals()	返回局部符号表字典	def func():<br> x = 1; result = locals()	获取函数内局部变量字典
map()	将函数应用到可迭代对象的每个元素，返回迭代器	result = list(map(lambda x: x * 2, [1, 2, 3]))	得到 [2, 4, 6]
max()	返回可迭代对象或多个参数中的最大值	result = max([1, 3, 2])	列表中最大值 3
memoryview()	创建内存视图对象，用于操作数组等数据的内存	arr = bytearray(b'abc'); mv = memoryview(arr)	创建字节数组的内存视图
min()	返回可迭代对象或多个参数中的最小值	result = min([1, 3, 2])	列表中最小值 1
next()	获取迭代器的下一个元素	lst = [1, 2, 3]; it = iter(lst); result = next(it)	得到 1
object()	创建一个空对象，所有类的基类	obj = object()	创建空对象
oct()	将整数转换为八进制字符串	num = 8; result = oct(num)	8 转为 '0o10'
open()	打开文件，返回文件对象	f = open('test.txt', 'r')	以读模式打开 test.txt 文件
ord()	返回字符的 Unicode 编码整数	result = ord('a')	'a' 的 Unicode 编码 97
pow()	计算幂次方，可指定取模	result = pow(2, 3)	2 的 3 次方，结果 8
print()	将对象打印输出到控制台	print("Hello")	打印 Hello
property()	用于创建属性，可实现对类属性的访问控制	class A:<br> def __init__(self):<br> self._x = 0<br> @property<br> def x(self):<br> return self._x<br> @x.setter<br> def x(self, value):<br> self._x = value	定义类 A 的属性 x 及设置方法
range()	创建整数序列迭代器	r = range(1, 5)	生成 1 到 4 的整数序列迭代器
repr()	返回对象的可打印表示形式	s = "abc"; result = repr(s)	得到 '"abc"'
reversed()	返回反向迭代器	lst = [1, 2, 3]; it = reversed(lst)	列表反向迭代器
round()	对数字进行四舍五入	result = round(3.14159, 2)	保留两位小数，结果 3.14
set()	创建集合，或把可迭代对象转换为集合	s = set([1, 2, 3])	创建集合 {1, 2, 3}
setattr()	设置对象的属性值	class A:<br> pass<br>a = A(); setattr(a, 'x', 1)	为实例 a 设置属性 x 为 1
slice()	创建切片对象，用于对序列进行切片操作	s = slice(1, 3); lst = [1, 2, 3, 4]; result = lst[s]	对列表切片得到 [2, 3]
sorted()	对可迭代对象排序，返回新列表	result = sorted([3, 1, 2])	得到排序后的列表 [1, 2, 3]
staticmethod()	将方法转换为静态方法	class A:<br> @staticmethod<br> def sm():<br> pass	定义类 A 的静态方法 sm
str()	将对象转换为字符串	num = 123; result = str(num)	整数转字符串 '123'
sum()	对可迭代对象中的元素求和	result = sum([1, 2, 3])	求和结果 6
super()	用于调用父类的方法	class A:<br> def f(self):<br> print('A')<br>class B(A):<br> def f(self):<br> super().f()	在 B 的 f 方法中调用 A 的 f 方法
tuple()	将可迭代对象转换为元组	result = tuple([1, 2, 3])	列表转元组 (1, 2, 3)
type()	返回对象的类型，也可用于创建类	result = type(1)	返回 <class 'int'>
vars()	返回对象的属性字典，无参数时返回局部变量字典	class A:<br> x = 1<br>a = A(); result = vars(a)	获取实例 a 的属性字典
zip()	将多个可迭代对象的对应元素打包成元组，返回迭代器	result = list(zip([1, 2], ['a', 'b']))	得到 [(1, 'a'), (2, 'b')]
import()	导入模块，与 import 语句功能相关	math = __import__('math')	导入 math 模块