导图社区 Python基础
- 18
- 0
- 0
- 举报
Python基础
这是一个关于Python基础的思维导图，梳理了Python基础知识的多个关键方面，涵盖Python的注释、代码缩进、多行语句、引号使用、等待用户输入、多个语句、命令行参数等基础语法规则。
编辑于2025-10-08 18:07:52- 编程
- Python
- 基本数据类型
- 条件判断语句
- 相似推荐
- 大纲
Python基础
基础语法
编码
UTF-8编码，unicode字符串
标识符
1.第一个字符必须是字母表中字母或下划线 _ 。 2.标识符的其他的部分由字母、数字和下划线组成。 3.标识符对大小写敏感。
Python保留字
'False', 'None', 'True', 'and', 'as', 'assert', '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最具特色的就是使用缩进来表示代码块，不需要使用大括号 {} 。 缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数否则会报错
多行语句
Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠()来实现多行语句 在 [], {}, 或 () 中的多行语句，不需要使用反斜杠()
数字类型
int（整数）
bool（布尔）
float（浮点数
complex（复数）
同一行显示多条语句
Python可以在同一行中使用多条语句，语句之间使用分号(;)分割
多个语句构成代码组
缩进相同的一组语句构成一个代码块，我们称之代码组。 像if、while、def和class这样的复合语句，首行以关键字开始，以冒号( : )结束，该行之后的一行或多行代码构成代码组。 我们将首行及后面的代码组称为一个子句(clause)。
Print输出
print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=""：
import与from import
在 python 用 import 或者 from...import 来导入相应的模块。 将整个模块(somemodule)导入，格式为： import somemodule 从某个模块中导入某个函数,格式为： from somemodule import somefunction 从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc 将某个模块中的全部函数导入，格式为： from somemodule import *
命令行参数
很多程序可以执行一些操作来查看一些基本信息，Python可以使用-h参数查看各参数帮助信息：
基本数据类型
Number（数字）
Python3 支持 int、float、bool、complex（复数）。 在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。 像大多数语言一样，数值类型的赋值和计算都是很直观的。 内置的 type() 函数可以用来查询变量所指的对象类型。此外还可以用 isinstance 来判断 type()不会认为子类是一种父类类型。 isinstance()会认为子类是一种父类类型 可以使用del语句删除一些对象引用。通过使用del语句删除单个或多个对象
数值运算
>>>5 + 4 # 加法9 >>> 4.3 - 2 # 减法2.3 >>> 3 * 7 # 乘法21 >>> 2 / 4 # 除法，得到一个浮点数0.5 >>> 2 // 4 # 除法，得到一个整数0 >>> 17 % 3 # 取余 2 >>> 2 ** 5 # 乘方32
String（字符串）
创建字符串
strs＝''或（"")
访问字符串中的值
strs[start：end：step] start：起始值 end：默认取不到 step：默认为1
单字索引：strs[number]
使用负数索引：strs[-1]
切片：strs[0：5]或strs[：5]
反向切片：strs[-5：-1]或strs[-5：]
间隔取值：strs[::2]
翻转字符串：strs[::-1]
字符串大小写操作
strs.capitalize() # 返回原字符串副本，其首个字符大小，其余为小写 strs.casefold() # 消除大小写操作 strs.swapcase() # 将所有的大写改为小写，小写改为大写
使用场景较多的方法 strs.upper() # 将所有的字符都变为大写， strs.lower() # 将所有字符串都变为小写 strs.title() # 将所有的首字母变为大写
字符串的填充操作
strs.center(20,"-") # 填充字符到指定的长度，并让其居中 strs.rjust(20,'*') # 填充字符串到指定长度，让其右对齐 strs.ljust(20,'*') # 填充字符串到指定长度，让其左对齐 strs.zfill(10) # 填充字符串到指定长度，使用0填充
字符串的搜索操作
strs.find('Java') # 返回子字符串sub在整个字符串内容被找到的最小索引,如果没找到返回-1。 strs.index("Java") # 返回子字符串sub在整个字符串内容被找到的最小索引,如果没找到触发ValueError strs.count("a") # 找出指定字符出现的次数 strs.count("best") # 找出指定子字符串出现的次数 strs.startswith("python") # 判断字符串师傅以指定的字符串开头，是返回True,否返回False strs.endswith('world') # 判断字符串是否以指定的字符串结尾，是返回True,否返回False
字符串的判断操作
strs.isalnum() # 字符串当中所有的字符都是数字或字母且至少有一个字符,返回True,否则返回False' strs.isalpha() # 判断所有的字符是否都是字母且至少有一个字符 strs.isdigit() # 如果字符串所有的字符都是数字并且至少有一个字符,是返回True,否则返回False strs.isidentifier() # 判断字符串是不是一个标识符,是返回True,, from keyword import iskeyword # 判断字符串是不是内置的关键字(或者是否是python保留的标识符) iskeyword("hello") strs.isspace() # 判断字符串只有空白字符且至少有个一字符,是返回True,否则返回False strs.istitle() # 判断字符串中至少有一个字符且为标题字符串,是返回True,否则返回Fasle strs.isupper() # 判断字符串中至少有一个字符且为所有字符都是大写,是返回True,否则返回Fasle strs.islower() # 判断字符串中至少有一个字符且为所有字符都是大写,是返回True,否则返回Fasle
字符串的修改操作
# 这里返回的结果是一个副本 strs.replace('python','Java',2) # 将字符串中所有的指定字符改为新的指定字符,也可以设置修改次数 strs.strip(" ") # 移除字符串两端指定的字符,这里设定字符参数并非指某个单个前缀或者后缀,而是会移除参数值的所有组合 strs.rstrip("! ") # 只移除右边指定的字符组合 strs.lstrip("! ") # 只移除左边的指定字符组合
strs.expandtabs(4) # 返回字符粗的副本,其中所有的制表符会有一个或多个空格替换
trantab = strs.maketrans(intab, outtab) # 制作了一个翻译表 strs.translate(trantab)
strs.removesuffix("Tests") # 如果它以某个指定的字符串结尾且非空,则返回移除之后子字符串
字符串的分割合并
strs.split("best") # 可以将一个字符串以指定字符进行分割,分割的结果是一个列表 print("\t".join(lists)) # 可以以指定的字符,将列表的元素组合成一个字符串 strs.splitlines() # 按行进行字符串的划分
List（列表）
创建列表
lists=[]
访问列表
访问指定位置的列表元素：lists[0]
切片：lists[：Number]
lists[::-1] # 输出逆序之后的数据,原始数据不会发生变化, lists.reverse() # 没有输出,返回逆序之后的数据
express.sort() # 默认对数据进行升序排序 express.sort(reverse=True) # 对数据进行降序排序
列表添加操作
添加单个元素：lists.append（）
添加多个元素：lists.extend()#添加内容必须是可迭代的
将两个列表拼接：lists1+lists2
在指定位置插入元素：lists.insert(位置,元素）
列表的删除
lists.pop() # 默认去除最后一个或指定位置的元素,删除它,并返回删除之后的值 lists.remove('页面卡顿') # 通过元素的具体名字进行删除,删除一个不存在的内容,则会触发error lists.clear() # 清空整个列表 del lists # 在内容当中删除该变量
列表查询复制统计
查看指定元素对应的索引：lists.index()
统计某个元素出现的次数:lists.count()
lists = original # 引用传递，修改一个，另外一个也会随之修改 lists= original.copy() # 浅拷贝，对于嵌套的对象仍然内存共享 import copy lists = copy.deepcopy(original) # 深拷贝，嵌套对象不在共享，拥有完全不同的内存地址
Tuple（元组）
元组的创建
tuple=()
访问元组
通过索引访问元组：tup(:)
修改元组
元组元素值不允许修改，可以对元组进行连接 ：tup=tup1+tup3
删除元组
元素值不允许删除，可以删除整个元组：del tup；
元组的运算符
与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。
元组内置函数
len(tuple) 计算元组元素个数。 max(tuple) 返回元组中元素最大值。 min(tuple) 返回元组中元素最小值。 tuple(seq) 将列表转换为元组
Dictionary（字典）
创建字典
# 最常见的创建方法，使用字面量 employee = {'id':1210, 'name': 'alex', 'department':"HR"}
# 可以创建一个空字典并进行动态填充 cache = {} cache['item1'] = {'data': [220,284]}
# 使用可迭代键值对序列创建, 重要 pairs = [('id',"1210"),('name','alex')]
# 重要方法，使用zip结合列表或元组创建 ids = [220,284,1210] names = ['alex','alice','alpha'] dict(zip(ids,names))
# 重要方法， 使用fromkeys初始化一组键的默认值 names = ['alex','alice','alpha'] dict.fromkeys(names, 123456)
# 使用关键字参数构建，适用于简单配置，但是键必须是合法的标识符 cfg = dict(timeout=30, retries = 3)
字典取值
根据关键字取值：dicts['key']
返回一个迭代器，可以使用 list() 来转换为列表：dicts.values()
返回一个迭代器，可以使用 list() 来转换为列表：dicts.keys()
返回指定键的值，如果值不在字典中返回default值：dicts.get(key, default=None)
dicts.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
以列表返回可遍历的(键, 值) 元组数组：dicts.items()
字典的删除
删除字典内所有元素：dicts.clear()
pop(key[,default]) 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
随机返回并删除字典中的最后一对键和值：popitem()
内置函数
len(dict) 计算字典元素个数，即键的总数。 str(dict) 输出字典，以可打印的字符串表示。 type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。
内置方法
radiansdict.copy() 返回一个字典的浅复制 radiansdict.fromkeys() 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值 key in dict 如果键在字典dict里返回true，否则返回false radiansdict.update(dict2) 把字典dict2的键/值对更新到dict里 dicts.setdefault('class','人工智能3班') # 如果设定的键存在，则返回该键对应的值，不会修改原来的 dicts.setdefault('school','河南师范大学平原湖校区') # 如果设定的键不存在，则会给该键添加新的值 通过解包的方式将两个字典合并, python3.5特性，适合合并默认配置与覆盖配置{**dicts, **dicts2｝
Set（集合）
创建集合
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
集合的增加
add() 为集合添加元素
update() 给集合添加元素
copy() 拷贝一个集合
集合的删除
pop() 随机移除元素
remove() 移除指定元素，删除不存在的元素会报KeyError
discard() 删除集合中指定的元素，删除不存在的元素不会报错
difference_update() 移除集合中的元素，该元素在指定的集合也存在。
clear() 移除集合中的所有元素
集合的运算
class1 | class2 # 求集合的并集
union() 返回两个集合的并集
class1 & class2 # 求集合的交集
class1.intersection(class2) # 交集 class1.intersection_update(class2) # 返回交集结果并赋值给class1
class1 - class2 # 求集合的差集
class1.difference(class2) # 差集 class1.difference_update(class2) # 计算差集，并将差集的结果返回给class1
class1 ^ class2 # 求对称差集，并集减去交集
class1.symmetric_difference(class2) # 对称差集 class1.symmetric_difference_update(class2) # 返回对称差集的结果并赋值给class1
class1.isdisjoint(class2) # 判断两个集合是否交集，有交集返回Fasle ,没有返回返回True,没有交集返回True class1.issubset(class2) # 判断class1是不是class2的子集 class1.issuperset(class2) # 判断class1的元素包含class2的所有元素，是返回True,否则返回Falsesymmetric_difference() 返回两个集合中不重复的元素集合。 symmetric_difference_update() 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
输入输出语句
input()
输出语句
print输出
print (*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
格式化输出
format方法
print("员工 {0}, 年龄：{1}, 工资： {2:.2f}".format(name,age,salary))
{}: 最简单的替换，直接输出变量或者表达式 {:<width}: 左对齐，宽度不足时在右侧填充空格 {:>width}: 右对齐，宽度不足时在左侧填充空格 {:^width}: 居中对齐，宽度不足时在两侧填充空格 {:.2%}: 百分比格式化，将小数转为百分比 {:.num f}:浮点数格式化，保留指定的位数
f-strings格式化输出
user = "Alice" action = "登录" status = True print(f"[INFO] 用户 {user} 执行操作： {action}， 状态：{'成功' if status else '失败'}") # 金融与货币格式 salary = 12101184.220 print(f"基本工资：￥{salary:,.2f}") # 千位分隔，保留两位有效数字， # 百分比显示： completion = 0.57 print(f"项目完成率：{completion * 100:.2f}%") print(f"项目完成率：{completion:.2%}") # from rich import print # 表格对齐与报表输出 data = [ ("alex", 30, 8500), ('alice', 25, 7600), ('alpha', 32,10000) ] print(f"{'name':<10}{'age':<6}{'salary':>10}") for name,age,salary in data: print(f"{name:<10}{age:<6}{salary:>10.2f}")
条件判断语句
基本语句
if 条件: # 条件为真时，执行的语句块
if 条件: # 条件为真时执行 else: # 条件为假是执行
if 条件1: # 条件1为真执行的代码 elif 条件2: # 条件2为真时执行 elif 条件3: # 条件3为真时执行 else: # 所有条件都不满足时执行
and or not
for_in_
while 条件 循环体
match-case
文件IO操作
f = open('test.txt','w') # 以写的模式打开test.txt文件 f.write("今天是2025年9月18日，铭记历史，勿忘国耻") # 做写入操作
w模式：write写入模式，文件不存在会创建对应的文件，文件存在呢，会请空文件，写入新的内容 a模式：追加写入模式，文件不存在会创建对应的文件，文件存在，则会在原有内容后面追加新的内容 r模式：读取模式，文件不存在，则会触发filenotfounderror文件存在，则会正常读取内容 t模式文本模式，默认就是文本模式，一般省略，w 和 wt是等价的
# 二进制文件的写入 with open('./image/test.png','wb') as f: f.write(data.content) copy # 二进制我那件的读取操作 with open('./image/test.png','rb') as f: data = f.read()
with open('./getContentList.json','r',encoding='utf-8') as f:
序列化与反序列化
import json with open('dicts.txt','w',encoding='utf-8') as f: f.write(json.dumps(random_dict)) with open('dicts.txt','w',encoding='utf-8') as f: json.dump(random_dict,f,)
with open('dicts.txt','w',encoding='utf-8') as f: f.write(json.dumps(random_dict, indent=4))
函数
迭代器生成器
子主题
class CountUp: def __init__(self, limit): self.current = 0 self.limit = limit def __iter__(self): return self def __next__(self): if self.current < self.limit: value = self.current self.current += 1 return value else: raise StopIteration # 使用示例 counter = CountUp(5) for num in counter: print(num) # 输出：0 1 2 3 4
itertool.count(start, step) 无限迭代器
import itertools log_counter = itertools.count(start=100, step=2)
>>> import itertools as its >>> a = its.count(1, 2) >>> for i in a: ... print(i) ... 1 3 5 ...
itertools.cycle : 用于创建一个无限循环迭代器，重复遍历一个可以给定点迭代对象
>>> import itertools as its >>> a = its.cycle('ABC') >>> for i in a: ... print(i) ... A B C A B C ...
itertools.repeat : 用于创建一个重复的迭代器，可以无限次数返回指定的元素，或者按指定次数重复。
>>> import itertools as its >>> a = its.repeat(10, 3) >>> for i in a: ... print(i) ... 10 10 10
通用迭代器
accumulate(p, [func])依次累加序列p中的元素。
>>> import itertools as its >>> a = its.accumulate([1, 2, 3, 4, 5]) >>> for i in a: ... print(i) ... 1 # 1 3 # 1+2 6 # 1+2+3 10 # 1+2+3+4 15 # 1+2+3+4+5
用于可迭代对象中获取指定范围的元素。返回一个迭代器，因此他能处理大数据集时，节省内存 itertools.islice(iterable, strat, stop, end)：# 这里的start值得是索引
itertools.groupby # 用于将一个可迭代对象中的相邻元素分组，这个函数根据指定的跳将元素分为不同的组
itertools.zip_longest zip使用过程中，数量不匹配的元素，不会被使用 适用于处理长度不一致的可迭代对象时，能够提供一种优雅的填充方式。
chain(p, q, […])串联多个迭代器，形成一个更大的迭代器。
>>> import itertools as its >>> a = its.chain('ABD', 'DEF') >>> for i in a: ... print(i) ... A B D D E F
takewhile(pred, seq)迭代选择器。
>>> import itertools as its >>> a = its.takewhile(lambda x: x < 5, [1, 3, 5, 7]) >>> for i in a: ... print(i) ... 1 3
组合迭代器
product(p, q, […], [repeat=1])笛卡尔积，等效于嵌套的for循环：
>>> import itertools as its >>> a = its.product('ABC', repeat=2) >>> for i in a: ... print(i) ... ('A', 'A') ('A', 'B') ('A', 'C') ('B', 'A') ('B', 'B') ('B', 'C') ('C', 'A') ('C', 'B') ('C', 'C')
permutations(p, [r])同product()函数，但元素不允许重复，不会生成AA这样的：
>>> import itertools as its >>> a = its.permutations('ABC', r=2) >>> for i in a: ... print(i) ... ('A', 'B') ('A', 'C') ('B', 'A') ('B', 'C') ('C', 'A') ('C', 'B')
combinations(p, r)同permutations()函数，但AB和BA这样的视为同一元素，只取AB：
>>> import itertools as its >>> a = its.combinations('ABC', r=2) >>> for i in a: ... print(i) ... ('A', 'B') ('A', 'C') ('B', 'C')
combinations_with_replacement(p, r)同product()函数，允许重复，但AB和BA这样的视为同一元素，只取AB：
>>> import itertools as its >>> a = its.combinations_with_replacement('ABC', r=2) >>> for i in a: ... print(i) ... ('A', 'A') ('A', 'B') ('A', 'C') ('B', 'B') ('B', 'C') ('C', 'C')
生成器迭代器
generator生成器： 返回一个生成器迭代器函数，看起来很像普通函数，不同点在于其包含yeild表达式以便产生一系列的值，供for循环或者next()函数逐一获取。
generator iterator: 生成器迭代器创建的对象。每个yiled会临时暂停处理
列表推导式 和 生成器表达式
new_list = [表达式 for item in iterable if 条件] # 返回到是一个列表 new_dict = {键值对 for item in iterable if 条件} # 字典推导式 new_list = (表达式 for item in iterable if 条件) # 返回到是一个生成器对象
字符串 列表 元组