列表和元组是 Python 中的内置数据结构，可以包含多种数据类型的元素。而
列表的语法
list_1 = [10, ‘abc’, 11]元组的语法
tup_1 = (10, ‘abc’ , 11)Python 是一种解释型语言，用于后端通用编程。Python 也可用于脚本编写，因此也被认为是脚本语言。
Python 代码不会被编译成机器语言指令。它通过解释器进行处理，解释器将您的代码转换为机器语言并加快执行速度。
PEP 是 Python 增强提案（Python Enhancement Proposal）的缩写。它是一套规则，有助于程序员以更易读的格式编写代码。
Pip 是 Python 的包管理器。它有助于安装运行 Python 程序所需的其他包和依赖项。
在 Python 中，内存管理是通过 Python 私有堆空间完成的，由 Python 内存管理器管理，这使得对象访问速度很快。Python 内存管理器中的垃圾收集器会回收未使用的空间并重新分配指针，以便有效地使用它们而不会出现内存空洞。
命名空间是 Python 中使用的所有符号的集合。它们像字典一样保存，以避免命名冲突。
PYTHONPATH 是一个环境变量。当将路径分配给此变量时，Python 将在此路径中查找导入到 Python 程序中的模块。然后，如果在该路径中找不到，解释器会引发错误。
Python 模块的最低要求是它应该包含一个 Python 文件。即：扩展名为 '.py' 的文件。此外，它可以是一个包含任意数量 Python 文件的文件夹，包括 Python 类、函数等。它还可以包含 Python 可执行文件。
在函数范围之外定义的变量称为全局变量。而在函数内部定义的变量称为局部变量，其作用域仅限于该函数。
例如：a = '我是一个全局变量。'
def fun()
a = '这个函数是局部的。'
print a ## 这里，值将是“这个函数是局部的。”
print a ## 这里，值将是“我是一个全局变量。”
假设一个变量被分配了某些数据，并且程序员希望更改变量的类型，可以使用类型转换。
例如：a = 1.0
b = int(a) // 这里 'a' 最初是浮点数，已被转换为整数。
类似地，下面提到的函数可以转换 Python 变量的类型
float() – 将任何数据类型转换为浮点类型。
ord() – 将字符转换为整数。
hex() – 将整数转换为十六进制。
oct() – 将整数转换为八进制。
tuple() – 此函数用于转换为元组。
set() – 此函数在转换为集合后返回类型。
list() – 此函数用于将任何数据类型转换为列表类型。
dict() – 此函数用于将有序元组（键，值）转换为字典。
str() – 用于将整数转换为字符串。
complex(real,imag) – 此函数将实数转换为复数（实数，虚数）。
在 Python 中，代码块由缩进识别。循环结构、类、函数等都包含在缩进块中。通常使用四个空格字符来完成。如果代码没有正确缩进，解释器会报错。
数组和列表是 Python 中的数据结构，可以包含一个以上的元素。区别在于数组只能存储相同数据类型的元素，而列表可以包含异构项，即不同数据类型的元素。
注意：在 Python 中，默认情况下不提供数组数据结构，可以通过导入 NumPy 等模块来使用。
函数是一段在被调用时执行以完成任务的代码块。函数概念提高了模块化并增加了代码的可重用性。使用 'def' 关键字定义函数 示例：'?? 函数定义 ??? def ExFun(): print("Hi,This is a function") ExFun(); # 调用函数 输出：Hi,This is a function
\_\_init\_\_ 是在每个类中定义的函数/方法。每当创建一个新对象时，都会调用此方法。它们也被称为构造函数。
Lambda 函数或匿名函数是单行函数。这些函数在没有名称的情况下定义，因此称为匿名函数。lambda 关键字用于定义此类函数。
语法：lambda 参数 : 表达式 示例：sum = lambda x,y : x+y print(sum(1, 2)) 输出：3
在 Python 中，没有默认的数组数据结构。数组是通过列表实现的。NumPy 是一个 Python 库，提供了更快的数组。NumPy 的意思是 Numerical Python。
文档字符串（docstrings）用于将文档与代码关联。文档字符串使用三单引号或三双引号。Python 中的注释以 # 开头。
通常在调用函数时，值是根据位置使用的。例如；def Subtract(a,b) 返回 a-b 调用函数时，第二个传递的参数将首先被减去。但在关键字参数中，我们可以以 key = 'value' 格式传递参数。这样它们就会被使用，而不管它们的位置如何。示例：Subtract(b=2,a=5) #结果将是 3
单继承：派生类继承单个基类的成员。
多级继承：派生类 d1 继承自基类 base1，d2 继承自 d1。
分层继承：从一个基类，我们可以继承任意数量的子类。
多重继承：派生类继承自多个基类。
Python 中的 Monkey Patching 意味着在运行时动态地进行修改。因此，程序可以通过仅更改正在运行的实例来扩展。
多态的字面意思是“多种形态”。在 Python 中，多态是指同名函数用于不同目的。
我们可以通过更改签名来实现这一点。这意味着参数的数量或参数的类型会发生变化。多态也可以在 '类内' 方法中看到。同名方法可以存在于不同的类中。
抽象是从用户那里隐藏实现细节，并仅强调如何使用应用程序的过程。在 Python 中，通过使用抽象类和方法来实现数据抽象。
封装是将数据和方法绑定到一个单元的过程。在 Python 中，封装的概念是通过类来实现的。类充当变量和方法的模板。
是通过 Python 实现的面向对象概念。
Django、Flask 和 Pyramid 是基于 Python 的全栈框架。这些框架帮助开发人员进行干净的 Web 开发。
'is' 是一个二元运算符，用于检查两个变量是否指向同一个对象。它通常用于检查变量的类型。
示例
a=1 if type(a) is int: print(‘Yes’) else: print(‘No’)
'==' 运算符检查两个变量的值是否相等。
'is' 运算符仅当两个变量都指向同一个对象时才为 True。即使值相同，如果两个变量指向不同的对象，'is' 运算符也返回 False。
成员运算符应用于元组、字符串或列表等序列。Python 中有两种成员运算符：'in' 和 'not in'。
'in' 当在指定的序列中找到元素时，返回 True。'not in' 当指定的元素在指定的序列中未找到时，返回 True。
例如
list_a = [1,2,3,4,5]
X= 5
Y= 10
if X in list_a:
print(“Element Found)
else:
print(“Element not Found)
If Y not in list_a:
print(“This illustrates the not in membership”)
输出
找到元素
这说明了 not in 成员资格
要访问 Python 中的目录和文件，可以使用 操作系统 (os) 模块。os 模块 包含许多用于操作目录和文件的函数。
os.getcwd(): 返回当前目录。os.chdir(path): 它有助于将目录更改为指定的路径。os.listdir(): 列出目录的内容。os.mkdir(): 创建一个新目录。os.remove(file): 删除文件，如果找不到指定文件则引发 os 异常。SciPy 库利用 NumPy 模块的数组，并帮助用户实现科学编程。它有助于解决线性代数问题、微积分等。
将 Python 对象转换为字节流的过程称为序列化。这可以通过 Python 中的 pickle 库来实现。
装饰器是 Python 中的特殊函数，用于修改现有的 Python 函数。示例
def decorate_funs(fun):
def inner_func():
print("Now it is decorated\n")
func()
return inner
def exisitng_fun():
print("I am an exisiting function")
>> existing_fun()
Returns “I am an exisitng function”
>>decorate_funs(exisitng_fun)
Returns :
Now it is decorated.
“I am an existing function
Can also be written as:
@decorate_funs
def existing_fun():
print("“I am an exisitng function")
这里 decorate_funs 是一个装饰器函数，它接受另一个函数作为参数并对其进行修改。
不，在 Python 中，没有默认的数组数据结构。数组是通过列表实现的。NumPy 是一个 Python 库，提供更快的数组。NumPy 的意思是 Numerical Python。
在 Python 中，没有默认的数组数据结构。数组是通过列表实现的。NumPy 是一个 Python 库，提供更快的数组。NumPy 的意思是 Numerical Python。示例
import numpy as np arr_eg = np.array([1, 2, 3, 4, 5]) print(arr_eg )
集合是一种可变数据类型，具有不重复、无序的值，有助于实现数学集合的属性。示例：vehicle_set = { ‘car’, ’jeep’, ’bus’ }
集合是一种可变数据类型，具有不重复、无序的值，有助于实现数学集合的属性。示例：vehicle_set = {?car?,?jeep?,?bus?}
add() 方法用于只向集合添加一个项；如果需要向集合添加多个项，则使用 update() 方法。 示例
#add() method
vehicle_set = {‘car’,’jeep’,’bus’}
vehicle_set.add(‘van’)
#update() method
vehicle_set = {‘car’,’jeep’,’bus’}
vehicle_set.update([‘van’,’scooter’])
remove 和 discard 方法都会从集合中删除指定的项。区别在于，如果指定的项不在集合中，remove() 方法将引发错误，而 discard() 则不会。示例
vehicle_set = {'car','jeep','bus'}
vehicle_set.remove('car') #Removes 'car' from the set, if 'car' not found throws error.
vehicle_set.remove('bus') #Removes 'bus' from set , no error will be thrown if 'bus' not found in the set.
可以使用 clear() 方法删除集合中的所有项。示例
vehicle_set = {‘car’,’jeep’,’bus’}
vehicle_set.clear()
print(vehicle_set)
## prints an empty set.
字典是存储在键值对中的项的集合。它们是可变的、索引的且无序的。可以使用相关的键访问值。示例
marks_dict = { 'physics' : 80 , 'chemistry' : 90, 'maths' : 95}
我们可以使用 values() 方法只获取字典中的值。示例
marks_dict = { 'physics' : 80 , 'chemistry' : 90, 'maths' : 95}
marks_dict.values()
可以使用 keys() 函数将字典的所有键作为列表返回。示例
marks_dict = { ‘physics’ : 80 , ‘chemistry’ : 90, ‘maths’ : 95}
print(marks_dict.keys())
Output : [‘physics’,’chemistry’,’maths’]
可以使用 items() 方法迭代键和值。示例
marks_dict = { ‘physics’ : 80 , ‘chemistry’ : 90, ‘maths’ : 95}
for sub,mark in marks_dict.items():
print(sub,mark)
这会打印键和值。
import sys
print ("使用的 Python 版本是:", format(sys.version)).
Sys 模块提供系统特定的参数和函数。
切片是获取数据子集的过程。它最常应用于字符串和列表。
可以使用 'in' 关键字来确定字典中是否存在某个键。示例
marks_dict = { ‘physics’ : 80 , ‘chemistry’ : 90, ‘maths’ : 95}
If ‘physics’ in marks_dict:
print(‘yes’)
Output: yes
slice() 函数用于对字符串、元组或列表等序列进行切片。
语法：slice(begin, end, step)
切片运算符 [n:m] 返回从第 n 个字符到第 m 个字符的字符串部分，包括第一个但不包括最后一个。
输出：[1,2,3,4,5,'a']
当我们使用 '=' 运算符复制对象时，不会创建新对象，而是创建一个新变量，指向旧对象。当我们 print( id(list1)) 和 print(id(list2)) 时，我们可以看到它们的 ID 相同。
在 Python 中，不能使用 '=' 来创建列表等容器的独立副本。要创建独立副本，可以使用 copy 模块。
Copy module （导入 Copy）提供深拷贝和浅拷贝。浅拷贝通过复制旧对象来创建一个新对象。但对于嵌套项，它不创建新对象，而是使用引用。
因此，当我们使用浅拷贝并且更改嵌套列表中的任何现有元素时，更改都会同时出现在两者上。而深拷贝会为嵌套对象创建新对象。
Copy 模块（导入 Copy）提供深拷贝和浅拷贝。浅拷贝通过复制旧对象来创建一个新对象。但对于嵌套项，它不创建新对象，而是使用引用。因此，当我们使用浅拷贝并且更改嵌套列表中的任何现有元素时，更改都会同时出现在两者上。
而深拷贝会为嵌套对象创建新对象。示例
List_1 = [[1,1,1],[2,2,2],[3,3,3]] List_2 = copy.copy(List_1) # Shallow Copy List_1.append([4,4,4]) print(List2) # Output : [[1,1,1],[2,2,2],[3,3,3]] List_1[1][1] = ‘a’ print(List2) # Output : [[1,1,1],[2,’a’,2],[3,3,3]]
Copy 模块（导入 Copy）提供深拷贝和浅拷贝。浅拷贝通过复制旧对象来创建一个新对象。但对于嵌套项，它不创建新对象，而是使用引用。因此，当我们使用浅拷贝并且更改嵌套列表中的任何现有元素时，更改都会同时出现在两者上。
而深拷贝会为嵌套对象创建新对象。示例
List_1 = [[5,5,5],[6,6,6],[7,7,7]] List_2 = copy.deepcopy(List_1) # Deep Copy List_1.append([8,8,8]) print(List2) # Output : [[5,5,5],[6,6,6],[7,7,7]] List_1[1][1] = ‘a’ print(List1) # Output : [[5,5,5],[6,’a’,6],[7,7,7],[8,8,8] print(List2) # Output : [[5,5,5],[6,6,6],[7,7,7]]
Self 指向类的当前对象。使用 self，我们可以访问类的变量，并可以对特定对象应用成员函数。
惰性求值是一种解释器用于减少执行时间和内存使用量的策略。在惰性求值中，表达式的结果在需要之前不会被计算。
range() 方法使用了惰性求值的概念。对于较大的范围，range 仅在需要值进行执行时才提供该值。
生成器函数是一个普通的函数，其中包含一个 yield 关键字，而不是 return。yield 关键字将值返回给调用者，但也会保存当前函数的状态以恢复执行。
简而言之，通过使用 yield，您可以返回值并继续执行当前被调用者。
如果程序员不确定要传递给函数的参数数量，开发人员可以在函数定义中参数名前加上 '*'。
该函数将接收一个参数元组，并且该元组的长度可以是任意的。参数可以作为元组元素传递并相应地访问。
如果程序员不确定要传递给函数的参数数量，开发人员可以在函数定义中参数名前加上 **（双星号）。
该函数将接收一个参数字典，并且程序员可以传递任意数量的参数（键：值对），并可以相应地访问它们。
函数可以编写为具有参数的默认值。如果一个函数在调用时没有为参数传递值，那么函数值将在计算中使用默认值。例如
def add( a, b =0)
return a+b
add(2,3) #returns 5
add(2) #returns 2
当传递 2 时，第二个参数将是 0，因为它是默认值 2 + 0 = 0
通常，在函数、循环、类、if 等内部不允许空代码块。如果程序员希望添加一个空代码块，在这种情况下可以使用 pass 关键字。
当解释器遇到 pass 关键字时，解释器什么也不做，但由于空代码也不会报错。示例
If (a > b): Pass
递归是一种编程技术，其中定义的函数可以反复调用自身。Python 支持递归。
def find_factorial(n):
if n==1:
return n:
Else:
Return n*find_factorial(n-1) #The same function is called by itself.
迭代器是可遍历的项目序列。技术上讲，迭代器对象实现了迭代器协议，包含 __iter__() 和 __next__() 方法。
当列表等可迭代对象传递给 iter() 方法时。返回起始点。然后使用 next() 方法可以访问可迭代对象的所有项。示例
List_1 = [1,2,3] Iter = iter(List_1) next(iter) # now points to 1 and returns 1 next(iter) # now points to 2 and returns 2 and so on
列表、元组、字典和集合都是可迭代对象。
所有这些对象都有一个 iter() 方法，用于通过 iter() 方法获取迭代器。
要使一个类成为迭代器，开发者必须在类中实现 __iter()__ 和 __next__() 方法。
__iter()__ 方法可用于操作，但必须返回迭代器对象。
__next()__ 方法也可用于计算，但应指向下一项。
当变量在函数内部声明时，默认情况下它们只有局部作用域。这意味着它们在函数外部无法访问。
为了使这些变量在作用域内可用，我们可以在定义变量之前加上 **global 关键字**。
JSON 是用于存储和交换数据的语法。在 Python 中，有一个内置模块 json 用于处理和操作 JSON 数据。
Python 提供了各种标准异常来处理意外错误并有效地调试代码。当发生错误时，Python 会停止并引发错误。
Try... Except 是用于引发异常的标准方法。
语法
Try:
Do something;
Except :
Do somthing else
Finally:
Do this finally
##finally is optional
示例
Try:
4/0
Except:
print(‘Exception Occured”)
Sep 和 end 参数用于 print 函数内部。end 参数接受一个字符，并用指定的参数结束打印的语句。默认情况下，end 的值为换行符。
Sep 参数帮助程序员在输出之间添加分隔符。示例
print(‘Hi Welcome’,end=’!’) >> Hi Welcome! Print(‘15’,’Aug’,’1947’,sep=’-’) >>15-Aug-1947
三元运算符也称为条件运算符。三元运算符用于根据二元 True 或 False 来评估任何内容。
语法：[true 时求值] **if** [表达式] **else** [false 时求值]
a if a > b else b
Any 关键字可用于可迭代对象，它等效于连续的 OR 操作。如果可迭代对象中的任何表达式为 true，则返回 true；如果所有表达式都为 false 或可迭代对象为空，则返回 false。
All 关键字可用于可迭代对象，它等效于连续的 AND 操作。如果可迭代对象中的所有表达式都为 true，则返回 true；如果任何表达式为 false，则返回 false。
在 Python 中，可以链式比较。也就是说，如果要进行两个比较，可以将它们组合成一个。例如：if x>y 和 y>z 可以链式写成 if x> y >z.
zip() 方法主要用作循环技术。Zip 有助于将两个相似的可迭代对象合并为一个。示例
ListA = [1,2,3] ListB = ['a','b','c'] X = zip(ListA, ListB) print(X) Output : [[1,'a'],[2,'b'],[3,'c']]
标识符可以使用字母、数字和下划线构成。保留关键字不能用作标识符。标识符不能以数字开头。标识符可以是任意长度的。
assert 关键字经常用于调试。Assert 帮助程序员检查表达式是否返回 True。
通过使用 assert 关键字，如果条件返回 True，则不会发生什么特别的事情；但如果给定表达式返回 False，则会引发 Assertion Error。
语法：assert condition
'//' 是截断除法的运算符。之所以这样称呼它，是因为它只返回商的整数部分，忽略小数部分。
例如：10//3 = 3。
break 和 continue 语句都有助于改变循环的流程。
'break' 语句会停止流程并退出循环。
'continue' 语句会停止当前迭代，并在可能的情况下继续进行下一次迭代。
max() 返回 ASCII 值最高的字符。
类似地，min() 函数在应用于字符串时，返回 ASCII 值最低的字符。
'__add__' 是一个可以用于字符串连接的魔法方法。
示例：s1 = 'Python' s2 = 'programming' S1.__add(s2) 结果：Pythonprogramming
'__init__' 是在每个类中定义的函数/方法。每当创建一个新对象时，都会调用此方法。它们也被称为构造函数。
当索引作为参数传递时，__getitem_() 函数返回指定索引处的字符。
encode() 方法用于以不同格式编码字符串。在 Python 3 中，默认的字符串编码是 UTF8。
语法：string.encode(encoding='encode_format', error=error_response)。
encoding_format 用于 utf8、ASCII 等流行编码。
Error response：错误发生时该怎么办。
我们可以使用 identifier() 函数来检查所选标识符在 Python 中是否有效。
split 函数将给定的字符串分割成字符串或字符列表。用户可以指定一个分隔符来执行分割。
语法： String.split(delimiter, maxsplits)。
这两个参数都是可选的。如果未指定分隔符，则字符串将按空格分割。Maxsplit 指定要执行的最大分割次数。示例
split_eg = ‘Mary had a little lamb’ split_list = split_eg.split() Print(split_list) Output : [‘Mary’,’had’,’a’,’little’,’lamb’]
strip() 函数接受一个参数，并去除字符串开头和结尾的指定字符。
语法：string.strip(characters)
characters 参数是可选的，如果未提供字符，则会去除开头和结尾的空白字符。
示例
strip_eg = ‘ Hi ‘ X = strip_eg.strip() print(X) Output:Hi
split 函数将给定的字符串分割成字符串或字符列表。用户可以指定一个分隔符来执行分割。如果未提供分隔符，则将根据空格分割字符串。示例
split_eg = ‘Mary had a little lamb’ split_list = split_eg.split() Print(split_list) Output : [‘Mary’,’had’,’a’,’little’,’lamb’]
Splitlines() 函数根据换行符将字符串分割成列表。
语法：string.splitlines(True/False)。
如果作为参数传递 True，则换行符将包含在结果列表中，否则换行符将被删除。参数是可选的，默认值为 False。
example_str = ‘Mary had a little lamb\n its fleece are white as snow’ X = example_str.Splitlines(True) print(X) Output : [‘Mary had a little lamb\n’,’its fleece are white as snow’]
当 map 函数用于函数和可迭代对象时，将为可迭代对象中的每个项执行指定的函数。
换句话说，可迭代对象中的每个项都将作为参数传递给函数，并执行该函数。
语法：map(function,iterable)
Translate 函数用于根据映射表将字符串的指定字符翻译成其他字符。
我们可以使用 maketrans() 方法 创建此映射表。示例
txt = ‘Smile Please’ mapping_table = txt.maketrans(‘a’,’@’) print(txt.translate(mapping_table)) Output : Smile Ple@se
Translate 函数可以在没有 maketrans 方法的情况下工作。在这种情况下，我们可以使用字典作为映射表。在这种情况下，我们必须使用 ASCII 码而不是字符。示例
txt = ‘Smile Please’
mapping_dict = {80:83}
Txt.translate(mapping_dict)
#returning string will have all ascii 80(P) replaced with ascii 83 (S)
Output : Smile Slease
remove() 函数会删除列表中指定的项；如果找到该项的多个实例，则删除第一个实例。
而 pop() 方法接受一个索引作为参数，并弹出该索引处的项并返回该项。
remove() 的语法：string.remove(item)
remove() 的示例：my_str = [1,2,3] my_str.remove(2)
pop() 的语法：string.pop(index)
pop() 的示例：my_str.pop(0) # 返回 1
列表推导式是 Python 支持的一种特定方式，它有助于从现有列表中创建和定义新列表。有时列表推导式会取代循环的使用。
语法：[Expression for element in list]
示例
[item*2 for item in [1,2,3]] Gives [2,4,6]
‘+’ 运算符通过操作数的连接创建一个新元组。
示例：(‘a’, ‘b’ , ‘c’) + (1,2,3)
结果是 ('a', 'b', 'c', 1, 2, 3)
Frozen set 表示不可变的集合。也就是说，一个不能被更改的集合。Frozenset() 函数可用于从列表、集合和字典等可迭代对象创建不可变集合。
语法：frozenset(iterable) # iterable 是可选的
示例
Values = [1,2,3] frozenset(Values)
Python 支持使用匿名函数，它们是没有名称的函数。这些函数使用 lambda 关键字定义。
语法：lambda arguments: expression
示例：sum = lambda x,y : x+y print(sum(1, 2)) 输出：3
当函数在类中使用时，它们被称为方法。方法是属于类的成员函数。
Python 支持使用匿名函数，它们是没有名称的函数。这些函数使用 lambda 关键字定义。
语法：lambda arguments: expression
示例
sum = lambda x,y : x+y print(sum(1, 2)) Output : 3
'is' 和 'is not' 是 Python 中的身份运算符。'is' 当两个操作数指向同一个对象时返回 True，否则返回 False。'is not' 当两个操作数指向同一个对象时返回 False，否则返回 False。
globals() 和 locals() 返回字典。
Locals() 返回在本地命名空间中定义的变量的字典。
Globals() 返回包含模块全局命名空间的字典。
为了在 R 中处理和存储分类数据，我们使用 Factor 数据对象。
Final 的概念是在 PHP 5 版本中引入的，它表示它是最终的。如果它是 final class，则表示它不能被进一步扩展。如果 final 是用于方法，则该方法不能被更改。
33. 如何通过 URL 或表单在 PHP 中传递值？
我们可以通过加密和使用函数解密，将用户的值从 URL 传递到 PHP 代码中。
• htmlspecialchars()
• urlencode()。
