python常用英文单词

python常用英文单词
Python常用的英文单词
在Python代码编写和提示信息中，有许多常用的英文单词。

虽然不需要背下每个单词的意思，但是看得多了，用到的多了，就会自然而然地熟悉它们的含义。

比如，print这个单词在Python中表示输出变量的值，起到一个输出的作用。

又比如，当出现syntax这个单词时，就代表着代码的语法有问题，初学者经常会出现这类错误。

如果出现error和invalid这些单词，就代表着代码里有错误或者无效的地方。

此时，我们需要检查一下代码是否和教学视频中的代码一致，是否有单词拼错或者输入法不正确等问题。

另外，在Python中特别注重缩进，所以我们也需要检查一下代码的缩进是否正确。

研究Python并不需要对英文有很高的要求，但如果你的英文好，那么在研究Python的过程中，你会更加得心应手。

你可以更快地从英文提示中知道问题出在哪里，节省时间，减少代码编写中关键词拼错的概率。

但如果你以前没有花时间研究过英文，那么你可能需要在研究Python的起初比别人稍稍
多花出一点时间来完成这个不熟悉到熟悉的过程。

因此，下面列出了一些常见的Python中的英文单词和意义：
一、交互式环境与print输出
1.print：打印/输出
2.coding：编码
3.syntax：语法
4.error：错误
5.invalid：无效
6.identifier：名称/标识符
7.character：字符
二、字符串的操作
er：用户
：姓名/名称
3.attribute：字段/属性
4.value：值
5.key：键
三、重复/转换/替换/原始字符串
1.upper：大写
2.lower：小写
3.capitalize：首字母大写
4.title：标题
5.replace：替换
6.old：旧的
7.new：新的
8.count：计数
9.swap：互换
10.case：情形
11.path：路径
12.new：新的/新建
1.Project、test、file、data分别代表项目、测试、文件、数据。

2.Strip用于去除字符串两端的空格或指定字符；index用于返回指定元素在列表中的索引；find用于查找字符串中指定
字符或子串的位置；count用于计算字符串中指定字符或子串
出现的次数。

3.Start代表开始，end代表结束，chars代表字符，sub代
表附属。

4.Input用于获取用户输入，prompt用于提示用户输入；
ID代表身份证号码，format用于格式化输出；args（argument）代表参数，kwargs代表关键字参数；year代表年，month代表月，day代表日。

5.Tuple代表元组，max用于返回元组中最大的元素，___
用于返回元组中最小的元素；iterable代表可迭代对象，key代
表关键字，n代表方法或函数，代表停止，object代表对象。

6.List代表列表，reverse用于将列表反向排序，true代表真，false代表假；___用于在列表末尾添加元素，extend用于
在列表末尾添加另一个列表的元素，insert用于在指定位置插
入元素，pop用于弹出列表中指定位置的元素，remove用于移
除列表中指定元素，del（delete）用于删除列表中指定位置的元素，clear用于清空列表，sort用于对列表进行排序。

7.Set代表集合或设置，add用于添加元素，update用于更新集合，discard用于移除指定元素，n用于返回两个集合的交集，n用于返回两个集合的并集，difference用于返回两个集合的差集，symmetric用于返回两个集合的对称差集，in用于判断元素是否在集合中，not用于判断元素是否不在集合中，disjoint用于判断两个集合是否不相交，subset用于判断一个集合是否为另一个集合的子集，superset用于判断一个集合是否为另一个集合的父集或超集，copy用于复制集合。

8.Dict代表字典，key代表键或关键字，value代表值，item代表项，mapping代表映射，seq（sequence）代表序列，from用于从某个地方获取数据，get用于获取字典中指定键的值，default代表默认值，none代表空值，arg代表可变元素，kwargs（keyword args）代表可变关键字元素。

9.循环包括for…in…循环和while…循环，range用于生成指定范围内的数字序列，sep（separate）用于指定分隔符，
flush用于清空缓存，step用于指定步长，continue用于跳过当
前循环，break用于跳出循环。

10.条件用于判断某个条件是否成立，跳出与结束循环用
于在满足某个条件时跳出循环或结束循环的执行。

十二、运算符与随机数
在Python中，我们可以使用各种运算符来执行各种操作。

例如，我们可以使用加号运算符来将两个数字相加。

除此之外，Python还提供了一些随机数生成函数，可以帮助我们生成随
机数。

为了使用这些函数，我们需要导入Python的模块。

我们
可以使用sys模块来访问系统相关的函数，使用path模块来访问路径相关的函数。

我们可以使用import关键字来导入模块，也可以使用from关键字来从模块中导入特定的函数。

十三、定义函数与设定参数
在Python中，我们可以定义自己的函数来执行特定的任务。

为了定义一个函数，我们需要指定函数名称以及函数的参数列表。

例如，我们可以定义一个名为birthday的函数，该函
数接受三个参数：年份、月份和日期。

我们可以使用type关
键字来指定参数的类型，以及使用error关键字来指定参数的
错误信息。

如果某些参数是必须的，我们可以使用required关键字来
指定它们。

如果某些参数是位置参数，nal关键字来指定它们。

如果某些参数不受支持，我们可以使用unsupported关键字来
指定它们。

十四、设定收集参数
有时候，我们需要定义一个函数，该函数可以接受任意数量的参数。

为了实现这一点，我们可以使用Python的收集参
数功能。

我们可以使用create关键字来创建一个包含所有参数
的字典，关键字来获取参数的信息，例如年龄、身高、宽度和重量等。

我们还可以使用splicing关键字来拼接参数，使用
params关键字来获取参数列表，使用volume关键字来计算参
数的体积。

十五、嵌套函数/作用域/闭包
在Python中，我们可以定义嵌套函数来执行特定的任务。

嵌套函数可以访问外部函数的变量，这样可以帮助我们实现更复杂的功能。

我们可以使用radius关键字来获取半径，使用perimeter关键字来计算周长，使用case关键字来处理不同的
情况。

我们还可以使用synthesis关键字来合成不同的函数，
使用execute关键字来执行函数。

十六、递归函数
递归函数是一种特殊的函数，它可以在函数内部调用自己。

在Python中，我们可以使用递归函数来解决各种问题，例如
计算阶乘、查询列表中的元素等。

但是，递归函数可能会导致无穷递归，因此我们需要设置最大递归深度来避免这种情况的发生。

我们可以使用maximum关键字来获取最大值，使用depth关键字来获取递归深度，使用exceeded关键字来判断是
否超过最大深度，使用factorial关键字来计算阶乘，使用search关键字来查询列表中的元素，使用power关键字来计算
幂等操作，使用lower和upper关键字来指定搜索范围，使用middle关键字来指定搜索的中间位置，n关键字来处理异常情况。

十七、列表推导式/lambda表达式
列表推导式和lambda表达式是Python中的两种特殊语法。

列表推导式可以帮助我们快速创建一个列表，而lambda表达
式可以帮助我们快速定义一个简单的函数。

我们可以使用___
关键字来计算平方，使用even关键字来判断偶数，n关键字
来理解列表推导式，使用lambda关键字来定义一个lambda表
达式。

十八、正则表达式
正则表达式是一种强大的文本处理工具，可以帮助我们快速匹配和搜索文本。

在Python中，我们可以使用re模块来处
理正则表达式。

我们可以使用regular关键字来指定正则表达
式的规则，n关键字来指定表达式，使用group关键字来分组匹配，使用match关键字来匹配文本，使用span关键字来指定匹配的跨度，使用ignore case关键字来忽略大小写，使用multi line关键字来处理多行文本，使用dot all关键字来匹配任意字符，使用unicode关键字来处理万国码，使用verbose 关键字来处理复杂的正则表达式，使用pos/n关键字来指定匹配的位置。

chr_string += chr(elem)
ord_list.append(ord(elem))
return ord_list
测试
print(chrplus([80.121.116.104.111.110]))
输出Python
print(ordplus('Python'))
输出[80.121.116.104.111.110]
二、条件语句
条件语句主要包括if、elif和else三个关键字。

if后面的条件为True时，执行对应的代码块；否则，执行下一个elif
的条件语句，如果所有的elif条件都为False，则执行else语句块。

条件语句的缩进必须一致，一般为四个空格或者一个TAB键。

示例
score = 80
if score。

= 90:
print('A')
elif score。

= 80:
print('B')
elif score。

= 70:
print('C')
___:
print('D')
输出B
三、循环语句
循环语句分为for和while两种，for循环用于遍历一个可迭代对象，while循环则用于当某个条件为True时一直执行代码块。

示例
计算1到10的和
sum = 0
for i in range(1.11):
sum += i
print(sum)
输出55
示例
计算1到10的阶乘
___ 1
i = 1
while i <= 10:
___ i
i += 1
print(factorial)
输出xxxxxxx
四、函数定义
函数定义使用关键字def，后面紧跟着函数名和参数列表。

函数体缩进，一般为四个空格或者一个TAB键。

函数可以有
返回值，也可以没有。

如果没有返回值，则默认返回None。

示例
def add(a。

b):
return a + b
print(add(1.2))
输出3
五、模块导入
Python中的模块可以包含变量、函数、类等。

要使用模块中的内容，需要使用关键字import进行导入。

导入后，可以使用模块名.变量名、模块名.函数名等方式进行调用。

示例
import math
print(math.pi)
输出3.xxxxxxxxxxx9793
ord_list = []
for elem in x:
ord_list.append(ord(elem))
temp = ord_list
print(temp)
init = ''
for elem in temp:
init += chr(elem)
print(init)
输出：[112.121.116.104.111.110....]
输出：Python高效编程
3.enumerate(iterable。

start=0)函数返回一个enumerate对象。

参数iterable必须是序列、迭代器或其他支持迭代的对象。

enumerate()函数返回的是迭代器，同样是可迭代对象。

每次迭
代的元素，都包含元素在序列中的序号（start默认值为0）和
元素对应的值。

因此，我们可以用for循环获取返回值。

等价于：
def enumerate(sequence。

start=0):
n = start
for elem in sequence:
yield n。

elem
n += 1
for i。

elem in ___(['P'。

'y'。

't'。

'h'。

'o'。

'n']):
print(i。

elem)
4.abs(x)函数返回数的绝对值。

参数可以是整数或浮点数。

如果参数是复数，返回复数的模。

Python中虚数用数值加上
字符j的形式表示。

要注意j前面的数值不能省略，比如1j。

下面是我写的简易版的abs函数：
from math import sqrt
def naive_abs(x):
isinstance判断参数x是否为整数或浮点数
if isinstance(x。

int) or isinstance(x。

float):
if x < 0:
x = - x
判断参数x是否为复数
elif isinstance(x。

complex):
x.real复数的实部
x.imag复数的虚部
real = x.real
imag = x.imag
求复数的模
x = sqrt(real ** 2 + imag ** 2)
else:
return '请输入int float complex'
return x
print(abs(3+4j))
print(naive_abs(3+4j)) #输出5.0
print(abs(-6))
print(naive_abs(-6)) #输出6
二、算法与数据结构
1.二分查找
为了使用二分搜索，必须确保迭代序列是有序的。

如果序列无序，则需要先进行排序操作。

每次循环都会将搜索范围缩小一半，时间复杂度为O(logn)。

在每次循环中，选取中间数并将其与需要查找的数字进行比较。

如果待查数小于中间数，则将右界缩小到中间数的前一个数；如果待查数大于中间数，则将左界增加到中间数的后一个数；如果待查数等于中间数，
则返回中间数的下标，该下标即为待查数在序列中的位置。

当左界大于右界时，循环结束，说明序列中并没有待查数。

以下是二分查找的代码实现：
def binary_search(item。

find):
有序可迭代对象
left。

right = 0.len(item) - 1
mid = left + (right - left) // 2
while left <= right:
if item[mid] == find:
return mid
elif item[mid]。

find:
right = mid - 1
else:
left = mid + 1
mid = left + (right - left) // 2
return None
seq = [1.4.7.9.13.17.18.21.34.45.65]
binary_search(seq。

13) #输出：4
2.快速排序
在进行快速排序之前，需要将序列的顺序打乱，以防止算法陷入最坏时间复杂度。

快速排序使用“分而治之”的方法。

对于一串序列，首先从中选取一个数，将小于这个数的值放在左边一摞，将大于这个数的值放在右边一摞。

然后，继续对左右两摞进行快速排序，直到进行快速排序的序列长度小于2（即序列中只有一个值或者空值）。

以下是快速排序的代码实现：
import random
def quicksort(seq):
if len(seq) < 2:
return seq
else:
base = seq[0]
left = [elem for elem in seq[1:] if elem < base]
right = [elem for elem in seq[1:] if elem。

base]
return quicksort(left) + [base] + quicksort(right)
外层循环，遍历整个序列
min_index = find_minimal_index(seq[i:]) + i
找到当前序列中最小值的索引
seq[i]。

seq[min_index] = seq[min_index]。

seq[i]
将最小值与当前序列的第一个元素交换位置
return seq
冒泡排序是一种简单直观的排序算法，但由于其时间复杂度较高，不适用于大规模数据的排序。

其基本思想是从左向右，两两比较，如果左边元素大于右边，就交换两个元素的位置。

其中，每一轮排序，序列中最大的元素浮动到最右面。

每次内层循环次数都会减一，直到所有元素都排序完毕。

如果有一轮循环之后，次序并没有交换，这时我们就可以停止循环，得到我们想要的有序序列了。

选择排序，每次选择当前序列的最小值，将其与当前序列的第一个元素交换位置，每迭代一次，当前序列长度减一。

迭
代结束，即可得到有序序列。

这种算法的时间复杂度也较高，但相对于冒泡排序，其交换次数更少，因此在实际应用中更为常见。

快速排序是一种高效的排序算法，其基本思想是选取一个基准元素，将序列分为左右两部分，其中左边部分的元素都小于基准元素，右边部分的元素都大于基准元素。

然后对左右两部分分别进行递归操作，最终得到有序序列。

在实际应用中，快速排序是最常用的排序算法之一。

5.去重序列重复元素
首先，我们可以使用一个集合(set)来存储序列中的元素。

如果元素已经在集合中，就不返回这个值。

如果不在集合中，就向集合添加这个元素，并返回这个值。

在这个过程中，我们可以通过传递一个函数作为参数来改变重复元素的判断依据。

例如，对于下面这个序列：
a = [{'a': 6.'b': 4}。

{'a': 6.'b': 3}。

{'a': 6.'b': 4},{'a': 8.'b':12}]
pe函数，基于关键字‘a’对应值去除重复元素，也就是说集合中添加的元素为关键字‘a’对应值。

输出为：
a': 6.'b': 4}。

{'a': 8.'b': 12}]
我们也可以使用lambda函数，集合添加的是关键字’a’和’b’对应值的元组。

输出为：
a': 6.'b': 4}。

{'a': 6.'b': 3}。

{'a': 8.'b': 12}]
pe函数的实现代码：
def pe(sequence。

___):
依序去除重复元素
seen = set()
for item in sequence:
val = item if key is None else key(item)
if val not in seen:
seen.add(val)
yield item
6.Vector
接下来，我们来实现一个简单的Vector类。

Vector类有两个属性，为x，y坐标，即对应向量的横纵坐标。

我们可以使用__add__方法重载加号，实现两个向量的加法。

具体做法是：将加号两边的Vector对象的x。

y值相加，得到新的x。

y 值并且返回一个新的向量对象。

__sub__方法实现了Vector对象的减法，和加法差不多。

让向量对象的对应属性相减，并返回新的向量对象。

下面是Vector类的实现代码：
class Vector:
def __init__(self。

x=0.y=0):
self.x = x
self.y = y
def __add__(self。

other):
return Vector(self.x + other.x。

self.y + other.y)
def __sub__(self。

other):
return Vector(self.x - other.x。

self.y - other.y) import math
class Vector(object):
def __init__(self。

x。

y):
self.x = x
self.y = y
def __add__(self。

other):
x = self.x + other.x
y = self.y + other.y
return Vector(x。

y)
def __sub__(self。

other):
x = self.x - other.x
y = self.y - other.y
return Vector(x。

y)
def __abs__(self):
return math.sqrt(self.x ** 2 + self.y ** 2)
def __bool__(self):
return bool(self.x or self.y)
def __mul__(self。

times):
return Vector(self.x * times。

self.y * times)
def __repr__(self):
return 'Vector({}。

{})'.format(self.x。

self.y) __str__ = __repr__
def main():
v1 = Vector(3.5)
v2 = Vector(4.5)
v3 = v1 + v2
v4 = v3 * 2
v5 = v2 - v1
print(v3)
print(v4)
print(abs(v3))
print(v5)
if __name__ == '__main__':
main()
输出：
Vector(7.10)
Vector(14.20)
12.xxxxxxxxxxxxxxx
Vector(1.0)
具名元组
具名元组是一个类似于元组的数据结构，但是它可以通过名称来访问元素，而不是通过索引。

具名元组可以看作是一个轻量级的类定义，它提供了一个快速的方式来创建简单的不可变对象。

下面是一个具名元组的例子：
from ns import namedtuple
Person = namedtuple('Person'。

['name'。

'age'。

'gender'])
p1 = Person('Alice'。

25.'female')
p2 = Person('Bob'。

30.'male')
print(。

p1.age。

p1.gender)
print(。

p2.age。

p2.gender)
具名元组可以用于任何需要简单、不可变的数据结构的场合，比如函数返回多个值的情况。

它也可以用于代替字典，因为它比字典更加轻量级，而且访问元素的速度更快。

总之，具名元组是一个非常有用的数据结构，它可以让你以一种更加简洁、优雅的方式来表示数据。

修正后的文章：
定义一个待办事项类
class ToDoItem:
def __init__(self。

date。

content。

rity):
self.date = date
self.content = content
rity = rity
def __repr__(self):
return 'ToDoItem({}。

{}。

{})'.format(self.date。

self.content。

rity)
def __str__(self):
fmt = '{:<10} {:<20} {}'
return fmt.format('date'。

'content'。

'rity') + '\n' +
fmt.format(self.date。

self.content。

rity)
定义一个待办事项列表类
class ToDoList:
def __init__(self):
self.items = []
def add(self。

date。

content。

rity):
item = ToDoItem(date。

content。

rity)
self.items.append(item)
def __add__(self。

other):
result = ToDoList()
result.items = self.items + other.items
return result
def __str__(self):
text = ''
fmt = '{:<10} {:<20} {}'
text += fmt.format('date'。

'content'。

'rity') + '\n'
for item in self.items:
text += fmt.format(item.date。

item.content。

rity) + '\n' return text
__repr__ = __str__
测试代码
def main():
t1 = ToDoList()
t1.add(12.'play'。

0)
t1.add(8.'seek'。

6)
t2 = ToDoList()
t2.add(4.'sleep'。

2)
t3 = t1 + t2
print(t3)
if __name__ == '__main__': main()
输出
date。

content。

rity
12.play。

0
8.seek。

6
4.sleep。

2
递归
1.阶乘
n。

0
def factor(n):
return 1 if n < 2 else n * factor(n-1)
2.序列和
def naive_sum(seq):
if not seq:
return 0
else:
return seq[0] + naive_sum(seq[1:])
3.求序列长度
def naive_count(seq):
if not seq:
return 0
else:
return 1 + naive_count(seq[1:]) 4.求序列最大值
count = 1
def naive_max(seq):
global count
global max_num
if count:
max_num = seq[0]
count = 0
if not seq:
count = 1
return max_num
else:
if seq[0]。

max_num:
seq[0]。

max_num = max_num。

seq[0]
return naive_max(seq[1:])
总结
学会Python很简单，谨记“3456”这四个数字，研究效率事半功倍。

为了更好地展现Python知识的系统性、逻辑性和层次性，我们整理了研究Python最基础的知识研究框架，希望能够帮
助大家快速入门。

以下是我们整理的四个数字：3456.
首先，让我们来描述一下这四个数字的含义。

但在研究的顺序上，请按照5、6、3、4的顺序展开研究。

5个基本语句
首先，我们来研究5个基本语句，它们分别是赋值语句、输入输出语句、条件判断语句、循环语句和异常处理语句。

这些语句是Python编程的基础，掌握它们对于后续的研究非常
重要。

6种数据类型
接下来，我们来研究6种数据类型，它们分别是数字类型、字符串、列表、元组、字典和集合。

Python是一种动态类型
语言，因此了解这些数据类型可以帮助我们更好地理解
Python的编程思想。

3个基本概念
在掌握了基本语句和数据类型之后，我们来研究3个基本概念，它们分别是结构化、面向对象和虚拟环境。

掌握这些概念可以帮助我们更好地组织代码和管理项目。

4类基本操作
最后，我们来研究4类基本操作，它们分别是数据操作、文件操作、模块操作和并发操作。

这些操作是Python编程中常用的操作，掌握它们可以让我们更加熟练地编写Python程序。

如果你能够掌握以上几个要点，那么你就可以算是真正地入门了。