Python 所有基础知识和一些高级主题

Python 所有基础知识和一些高级主题

目录

 Relational Operators 关系运算符

 Logical Operators 逻辑运算符

Bitwise Operators 按位运算符

Membership Operators

Identity Operators

If Statement

Else Statement

Elif Statement

For Loop

Break

Continue

Array

NumPy

Lambda Function

Filter Function

Map Function

Reduce Function

Class

Inheritance

Encapsulation

Polymorphism

结论

---

Python 是当今最流行的编程语言之一。它广泛应用于各个业务领域，例如编程、Web 开发、机器学习和数据科学。鉴于其广泛使用，Python 超越 Java 成为顶级编程语言也就不足为奇了。

本 Python 教程涵盖了 Python 的所有基础知识和 Python 语言的一些高级主题，例如变量、数据类型、数组、函数和 OOP 概念，所有这些都将帮助您为成为专业 Python 程序员的职业生涯做好准备。

本 Python 教程中使用的示例已使用 PyCharm IDE 实现。你可以在这里下载 PyCharm 。PyCharm创建了一个虚拟环境，您可以在其中更改要使用的 Python 版本。您可以通过单击“文件”菜单，然后选择“新建暂存文件”来创建一个新的 Python 文件。

首先，我们将从“变量”开始，它是编写 Python 代码任何部分的基本构建块。变量是程序中保存值的实体。下面显示的图像是一个数值为 100 的框。在这里，变量将是框的名称，即x。 

在 Python 教程的这一部分中，让我们看看如何在 Python 中分配变量

print(“Meet Jane”)

print(“Jane works as a software engineer”)

print(“Elise is Jane’s manager”)

Python 中的 print 函数打印出括号内的任何内容。在 PyCharm 中有多种运行文件的方法：您可以使用“Alt+Shift+F10”，或者单击“运行”菜单并选择要运行的 Python 文件。或者，您可以单击运行按钮。这是代码的输出：

您可以通过使用主题标签“ #”添加注释来向代码添加额外信息。 

您可以将其存储在一个变量中，而不是每次都键入“Jane”，如下例所示：

name = “Jane”

print(“Meet,” name)

这将在输出打印出“Meet Jane”。

您还可以在打印语句中使用字符串格式来显示结果：

print(“%s works as a software engineer”%name)

print(“Elise is %s’s manager”%name)

 这将在输出控制台中打印出以下内容：

“Jane works as a software engineer”

“Elise is Jane’s manager”

具有相同值的变量携带相同的地址。例如：

name=’Jane’

name2=’Jane’

print(id(name))

print(id(name2)) 

具有不同值的变量具有不同的地址：

name=’Jane’

name2=’May’

print(id(name))

print(id(name2))

Python 使用不同类型的程序数据。我们将首先介绍数字数据。数字数据有三种不同的类型：int、float、complex。 

以下是Python 中整数 (int)数据类型的示例

num = 5

要确认它是哪种数据类型，请使用 type()。

print(type(num))

Float是第二个最常用的数据类型。

num = 5.6

print(type(num))

最后，我们有复杂的数据类型。

num = 5+6j

print(type(num))

Python 允许您使用 Python 强制转换指定变量类型或将一种数据类型转换为另一种数据类型。转换是使用构造函数完成的——int()、float()、complex()、str()。

num = 5

print(num, type(num))

print(float(num), type(float(num)))

print(complex(num), type(complex(num)))

From the above example, you can see that num is an integer variable. To convert this variable into float and complex type, we use float(num) and complex(num).

您还可以将浮点数转换为整数。

num=5.6

print(int(num), type(int(num)))

如果您有大量数据，则不能将其存储在多个变量中，因为这会占用大量内存。为了克服这个问题，我们在 Python 中有“列表”，它是包含多种数据类型值的数据集合。列表在方括号内声明。

您还可以使用元组存储各种类型的数据，元组是异构数据的不可变集合。你可以改变元组的值，元组之间用大括号区分。

在 Python中，数据也可以以Set的形式存储。集合是唯一异构数据的无序集合。

让我们声明一个简单的列表并使用索引过滤值。

lst=[1,4,5,2,7,5]

print(lst)

print(lst[0])

print(lst[1])

在 Python 列表中，第一个索引从 0 开始，然后是 1，依此类推。因此， lst[0] 将返回列表中的第一个元素，而 lst[1] 将给出列表中的第二个元素。

要返回列表中元素的总数，请使用 length len() 函数。

print(len(lst)) # 它将返回 6，因为列表中有六个元素。

要从列表中提取最后一个元素和倒数第二个元素，您可以使用

print(lst[-1])  # This will return 5

print(lst[-2])  # This will return 7 

要从列表中获取前四个元素，您可以使用

print(lst[0:4]) # 它将返回前四个索引的值并排除最后一个索引

您还可以使用以下方法对列表的前四个元素进行切片：

print(lst[:4])

同样，您可以使用以下方法对从索引 2 开始的所有元素进行切片：

print(lst[2:])

以下打印语句返回列表中的前两个元素：

print(lst[:-4])

要显示列表中的最后四个元素，您可以使用：

print(lst[-4:])

如果要打印列表中的每个替代值：

print(lst[1::2]) # 它将打印从第一个索引开始的值，然后是第三个索引，依此类推。

注意：当从列表中切片值时，它只能接受整数。如果您提供任何其他类型的数据，它将引发错误。

打印（lst [1.0:4]）print(lst[1.0:4])

列表还可以包含浮动和字符串文字。

lst=[1,4,”Python”,2,7.4,5]

print(lst)

列表是可变的，这意味着您可以更改列表中的值。

lst[1] =”hello” # 这会将第一个索引处的值从 4 替换为 hello 

print(lst)

Python 允许您使用 append() 函数将新元素添加到列表的末尾。

lst.append('Simplilearn')

print(lst)

您可以在另一个列表中创建一个列表。这称为嵌套列表。下面是一个例子：nested=[1,2,[2,3,4]]

print(nested)

在列表中附加元素的另一种方法是使用extend()函数。

nested.extend([[7,8,9]])

print(nested)

现在您已经对 Python 中的列表有了很好的理解，让我们继续使用元组来学习这个 Python 教程。

'tpl=(1,2,3)

print(tpl)

要提取元组的值，您可以使用其索引对其进行切片。

print(tpl[1]) # 这将从元组中返回值 2。

要从列表中提取第一个元素，您可以使用：print(tpl[:1])

要反转列表中的元素，您可以使用

print(tpl[::-1])

元组是不可变的，所以你不能改变它们的值。如果您尝试更改它们，则会引发错误。

tpl=(1,2,3)

print(tp1)

tpl[1]=7

当您不希望数据或信息随时间变化时使用元组。您还可以通过以下方式声明元组：

tpl=5,6,8

print(tpl)

Python 允许您打包和解包元组。

a,b,c=tpl

print(a,b,c)

您还可以通过以下方式在 Python 中创建列表：

a, *lst=tpl

print(a, lst)

以下是如何在 Python 中创建Set：

s={1,3,3,3,4,5} # 集合只取唯一值，所以它只会打印 3 一次，

print(s)

您不能更改集合中的值。如果你这样做，它会抛出一个错误。

这是将列表更改为集合的示例：

lst=[1,3,3,3,4,5]

print(lst)

print(set(lst))

如您所见，列表中的重复值现在已在将其转换为集合后被删除。

现在，让我们在本 Python 教程中解决算术运算符的主题。Python 支持各种算术运算符，例如加法(+)、减法(-)、乘法(*)、除法(/)、除法(//)、模数(%)和幂(**)。

a,b=10, 5

print(‘a+b’, a+b)

print(‘a-b’, a-b)

print(‘a*b’, a*b)

print(‘a/b’, a/b)

print(‘a//b’, a//b)

print(‘a%b’, a%b)

print(‘a**2’, a**2)

您可以将任何算术运算的值存储在变量中。

a,b = 10,5

res = a*b

print(res)

使用 Python，您可以增加变量的值。

a,b = 10,5

count=0

count=count+1

count += 1 # 另一种使用赋值运算符递增变量值的方法

print(count)

上面代码的输出是两个。

a//=3 # 这将返回 10//3 即 3

Relational Operators 关系运算符

关系运算符用于比较两个值。关系运算符返回布尔值。

a,b=10, 5

print(a,b)

print(a>b) # Greater than operator

print(a

print(a>=b) # Greater than or equal to operator

print(a<=b) # Less than or equal to operator

print(a==b) # Equal operator

print(a!=b) # Not equal operator

 Logical Operators 逻辑运算符

逻辑运算符用于组合条件语句。

a1, b1, c1=10, 20, 30 

print(a1, b1, c1)

print(c1>a1 and c1>b1) # “and” operator returns True if both the statements are true

print(a1>b1 and c1>b1) # Returns “False” since a1 is not greater than b1

print(a1>b1 or c1>b1) # Gives “True” as or operator returns True if one of the statements is true

print(not a1>b1) # Reverses the results, returns True if the result is false

Bitwise Operators 按位运算符

位运算符用于比较二进制数。以下是二元运算符（&、|、^、~、<<、>>）的一些示例。

a,b = 10,5

打印（bin（a），bin（b））

print(a & b) # 如果两位都为 1，则将每一位设置为 1

打印（bin（a＆b））

print(a | b) # 如果 2 位之一为 1，则将每一位设置为 1

打印（bin（a | b））

print(bin(a ^ b)) # 如果两位中只有一位为 1，则将每一位设置为 1 

print(bin(a ^ b)) # 如果两位中只有一位为 1，则将每一位设置为 1 

print(bin(~a)) # 反转所有位

print(bin(a<<2)) # 通过从右边推入零来左移，让最左边的位掉下来

print(bin(a>>2)) # 将最左边位的副本从左边推入右移，让最右边的位脱落

Membership Operators

这些运算符用于检查对象（列表、元组、字典等）中是否存在序列。此类运算符的示例是in和not in。

list = [1,2,3,4,5]

x = 2

print(x in list) # 返回 True 因为列表中存在 2

print(x not in list) # 返回 False 因为 x 的值存在于列表中

Identity Operators

这些运算符用于比较对象以查看它们是否是具有相同内存位置的相同对象。此类运算符的示例是“是”和“不是”。

x = 10

y = 10

print(x is y) # 当 x 和 y 的值相同时返回 True

打印（x 不是 y）# 返回 False

如果更改 y = 12，则 print(x is not y) 将返回 True。

某些函数未预先构建到 Python 中，但可以在 Python Modules 中找到这些函数。数学就是这样一个模块，它具有广泛的数学函数集合。以下链接详细介绍了所有数学函数：数学函数 - Python

一些可用的基本函数是 ceil()、floor()、factorial()、fabs()、isfinite()、exp()。您还可以使用其他三角函数和双曲线函数。

要使用这些函数，您需要导入 math 模块。

导入数学

打印（数学。pi）

您还可以从 math 模块导入特定函数。

从数学导入 pi

打印（圆周率）

以下是如何使用附加数学函数：

导入数学

X = 9.5

print(ceil(X)) # 返回最接近的大于 9.5 的整数

打印（math.tan（X））

y = 3

打印（math.pow（X，y））

打印（数学.sqrt（x））

打印（math.factorial（y））

让我们来谈谈如何在 Python 中接受来自用户的输入。

Python 有一个内置的input()函数，它以prompt作为参数，它是一个字符串，表示输入之前的默认消息。

name = input("Enter your name") # "" 代表换行

print(“Hi”, name)

内联输入函数总是接受一个字符串。

age = input(“Enter your age”)

print(type(age))

print(age + 5) # 出错误，因为age是一个字符串，5是一个整数

要将整数添加到年龄变量，您需要将其转换为整数。

print(int(age) + 5)

print(“%s is %d years old”%(name, int(age)))

Python 具有从用户输入函数中切分字符的功能。

name = input(“输入一个词”)[:4]

print(name) # 返回单词的前四个字母

由于您知道 input() 函数接受字符串形式的值，因此您可以显式地以整数形式传递输入。

a = int(input(“Enter a multiple of 5”))

print(type(a))

接下来在本 Python 教程中，您将学习 Python 中的不同决策语句和循环。

If Statement

if 语句用于测试特定条件。如果条件为真，则执行代码块。

a = int(input(“Enter a multiple of 5”))

if a%5 != 0:

    print(a, ‘Not a multiple of 5’)

a = int(input(“Enter a multiple of 5”))

if a%5 != 0:

    print(a, ‘Not a multiple of 5’)

print(“this is what happens next”)

从上面的输出中，您可以看到 if 语句只运行那些缩进的代码行。Python 中的缩进代码行从行首起有四个空格。

Else Statement

在别人当if条件表达式为假时，执行语句。

a = int(input(“Enter a number”))
if a%2 != 0:

    print(a, ‘is an odd number’)

else:

    print(a, ‘is an even number’)

print(“this is what happens next”)

从上面的输出中，由于 5 不能被 2 整除，我们可以看到结果是“5 是一个奇数”。

但是，因为四可以被二整除，所以执行else语句，结果是“4是偶数”。

Elif Statement

The elif statement in Python enables you to check multiple conditions and execute specific block of statements if the previous conditions were false.

Python 中的elif语句使您能够检查多个条件并在先前的条件为假时执行特定的语句块。

a = int(input(“输入一个数字a”))

b = int(input(“输入一个数字 b”))

c = int(input(“输入一个数字 c”))

如果 a>b 且 a>c：

    print(a, '是最大的数')

elif b>a 和 b>c：

    print(b, '是最大的数')

别的：

    print(c, '是最大的数')

如你所见，由于 b>a 和 b>c，elif 语句被执行。

嵌套 if：在某些情况下，您可能希望在某个条件最终为真后检查另一个条件。在这些情况下，您可以使用嵌套的 if 语句。

age = int(input(“Enter your age”))

if age >= 60:

    print(“You  are eligible for senior citizen discount”)

else:

    if age <=18:

        print(“You are eligible for minor discount”)

    else:

        print(“You are not eligible for any discount”) 

以下是Python 中While 循环的工作原理：

While 循环：While 循环用于只要条件为真就执行一组语句。

word = “Python”

i = 0

while i<5:

    print(i, word)

    i+=1

上面的代码打印 Python 5 次，因为 while 条件为真，直到 i<5。

您还可以使用 while 循环将元素添加到空列表中。

lst = []

c = input(“Enter any key to add elements to list and 0 to exit loop”)

#“输入任意键将元素添加到列表和0退出循环”while c != “0”:

    lst.append(c) # Add elements to the empty list until c is not equal to 0

    c = input(“Enter any key to add elements to list and 0 to exit loop”)

print(lst)

For Loop

Python 中的for循环用于迭代序列（列表、元组、集合、字典和字符串）。word = “Python”

for w in range(3):

    print(w, word)

使用 for 循环，您可以按顺序打印列表中存在的所有元素。

lst = [1,2,”hello”,[1,2,3]]

for obj in list: # This will iterate through all the elements in the list and print it one by one

    print(obj)

# 使用for循环计算输入中元音数量的程序：

word = input(“enter word ”)

count = 0

for i in word:

    if i in [‘a’,’e’,’i’,’o’,’u’,’A’,’E’,’I’,’O’,’U’]:

        count += 1

print(“number of vowels in %s is %d”%(word, count))

Break

break 语句在循环遍历所有项目之前终止循环。

fruits = [“apple”, “orange”, “grapes”]

for x in fruits:

    print(x)

    if x == “orange”: # This will break the loop when the element in the list is an orange

        break

Continue

continue 语句将停止循环的当前迭代，并继续下一次迭代。

fruits = [“apple”, “orange”, “grapes”]

for x in fruits:

    if x == “orange”:

        continue

    print(x)

下面是另一个说明“ continue ”语句如何工作的示例：

n = 20

for i in range(2, n//2+1):

    if n%i != 0:

        continue

    print(“%d is divisible by %d”%(n,i))

Python 最有用的特性之一是它的内置库，使编程更容易。考虑到这一点，我们现在将讨论Array和NumPy 的工作原理。

 通过Python 培训课程学习 Python 中的数据 *** 作、字符串、条件语句、错误处理以及常用的 Python Web 框架 Django 。

Array

Python 没有对数组的内置支持。然而，Python; 可以使用 ists 代替。数组是一种特殊的变量，一次可以保存多个值。

Syntax: array(data type, value list)

The following example shows how to declare an array:

from array import * # imports all the sub modules and functions from array module 

ar = array(‘i’, [1,2,3,4,5]) # Here ‘i’ represents an array of integer type

print(type(ar))

print(ar[2])

ar.append(-10) # Adds -10 to end of the array

print(ar)

ar.remove(3) # Removes element 3 from the array list

print(ar)

ar = ar*3 # Multiplies the array elements three times

print(ar)

NumPy

NumPy 是一个 Python库，用于处理大型多维数组和矩阵。

如果你在 IDE 中工作，你需要使用“ pip install numpy ”来安装 NumPy。如果你正在使用 Jupyter notebook，你可以使用“ conda install NumPy”。”

在 PyCharm 中，您将转到 File>>>Settings>>>Project>>>Project Interpreter>>>单击右上角的加号 (+) 并搜索 NumPy。单击安装包。

将 numpy 导入为 np

ar1 = np.array([1,2,3])

从输出中可以看出，这是一个一维数组，值之间没有逗号。它不同于值之间有逗号的列表。

您可以按如下方式创建二维数组：

ar1 = np.array([[1,2,3], [4,5,6]])

print(ar1)

可以使用以下方法检查数组中元素的维度、大小、形状和类型：

print(“Dimension:”,ar1.ndim)

print(“Size:”,ar1.size)

print(“Shape:”,ar1.shape)

print(“type of elements:”,ar1.dtype)

以下是了解NumPy 库更多信息的链接

接下来，我们将介绍 NumPy 中可用的函数。

要创建一个填充零的数组，您可以执行以下 *** 作：

z = np.zeros((2,2),dtype=”int”) # 创建一个用零填充的 2x2 数组

print(z)

您可以使用full()函数来创建任何维度和元素的数组。

z = np.full((2,3),1) # 创建一个填充为 1 的 2x3 数组

print(z)

与列表一样，Python 中的数组可以使用索引位置进行切片。

ar3 = np.array([[1,2,3],[4,5,6],[10,11,12]])

print(ar3[1,2]) # 返回 6 作为输出

print(ar3[1,::-1]) # 以相反的顺序打印数组的第二个列表的元素

print(ar3[:2,::-1]) # 以相反的顺序打印第一个和第二个列表的元素

您可以对数组的元素执行算术运算。

ar3 = np.array([[1,2,3],[4,5,6],[10,11,12]])

print(ar3+10) # 所有元素加10

print(ar3*10) #数组中每个元素乘以10

NumPy 数组还有其他功能。例如，您可以找到数组中元素的总和、均值、最大值和最小值。

ar3 = np.array([[1,2,3],[4,5,6],[10,11,12]])

print(ar3.sum()) # 给出所有元素的总和

print(ar3[0].sum()) # 只返回数组中第一个元素列表的总和

print(ar3[0].min()) # 返回第一个列表的最后一个元素

数组中的元素也可以转置。

ar3 = np.array([[1,2,3],[4,5,6]])

打印（ar3）

打印（ar3.T）

要将数组返回到正常形式，请使用：

ar3 = ar3.T

打印（ar3.T）

现在让我们通过学习Python 中的函数来继续这个 Python 教程。一个函数是一个代码块，只有当它被称为运行。您可以将数据以参数的形式传递给函数，它可以作为结果返回数据。

Syntax: def function_name():

                 Block of code  

def fun(): # fun is the function name

  print(“Simplilearn”)

fun() # Calling the function

以下是使用函数将两个数字相加的另一个示例。

def add(a,b): # 函数 add 接受两个参数，a 和 b

    打印（a+b）

add(4,5) # 调用函数时必须传递所需数量的参数

def add(a,b):

    s = a+b

    return s # 从函数中返回 a+b 的值

n = add(4,5)

print(n)

def add(a,b):

    s = a+b

    d = a-b

    return s, d # Returns two values for addition and subtraction from the function

n1, n2 = add(4,5)

print(n1, n2)

您还可以在声明函数时为参数赋值。

def add(a=5, b=3):

    s = a+b

    d = a-b

    return s, d 

n1, n2 = add()

print(n1, n2)

*args和**kwargs：它们主要用于函数定义中，以将可变数量的参数传递给函数。

*args：在 Python 中，*args的单个星号形式可用作参数以向函数发送非关键字可变长度参数列表。

def args_kwargs(*myArgs):

    print(myArgs)

    print(myArgs[1])

args_kwargs(1,2,3,4)

def args_kwargs(*myArgs):

    a = myArgs[0] + myArgs[1]

    return a

a = args_kwargs(1,2,3,4)

print(a) # 这返回 3 因为 myArgs[0]=1 和 myArgs[1]=2

**kwargs：**kwargs的双星号形式用于将关键字化的可变长度参数字典传递给函数。

def args_kwargs(**myKwargs):

    print(myKwargs) # 以字典的形式打印值

    打印（myKwargs['a']+myKwargs['b']）

args_kwargs(a=10, b=20)

def args_kwargs(**myKwargs):

    打印（myKwargs）

    如果 myKwargs 中的“a”和 myKwargs 中的“b”：

        print(myKwargs['a']+myKwargs['b']) # 不会打印，= as 'a' in not present in the function call

args_kwargs(c=10, b=20)

Python 允许您将函数名称分配给变量。

def args_kwargs(**myKwargs):

    打印（myKwargs）

    如果 myKwargs 中的“a”和 myKwargs 中的“b”：

        打印（myKwargs['a']+myKwargs['b']）

args_kwargs(c=10, b=20)

d=args_kwargs

d(a=1, b=2)

您将在本 Python 基础教程中学习的最后一个 Python 函数称为Recursive。递归是一种编程方法，其中函数在其主体中一次或多次调用自身。

def rec(n):

    if n==1:

        print(n)

        return

    print(n)

    return rec(n-1)

rec(3)

递归可用于编写返回数字阶乘的函数。

以下代码被认为是编写函数以返回阶乘的一般方法。

事实上（n）：    f = 1

    for i in range(1, n+1):

        f *= i

    return f

print(fact(3))

使用递归函数返回一个数的阶乘：

def fact(n):

    if n==1:

        return 1

    return n * fact(n-1)

print(fact(3))

Lambda Function

Lambda 可以接受任意数量的参数，但只能有一个表达式。

语法：lambda 参数：表达式

在这里，您将看到 Lambda 函数的工作原理以及它的重要性。

下面是一个 Lambda 函数，用于将作为参数传递的两个数字相加，并打印结果：

l = λ a,b : a+b

print(l(10,20))

Next, we’ll go over how to implement filter, map, and reduce a list using the Lambda function.

Filter Function

Python 中的 filter() 函数接受一个函数和列表作为参数。它过滤掉一个序列的所有元素，函数返回True。

list = [‘a’, ‘b’, ‘e’, ‘f’, ‘o’, ‘a’]

l = list(filter(lambda x:x in [‘a’, ‘e’, ‘i’, ‘o’, ‘u’],lst))

print(l)

Map Function

map() 函数也接受一个函数和列表作为参数。将返回一个新列表，其中包含该函数的每个项目返回的所有 Lambda 修改项目。

以下示例是一个函数，该函数根据其 ASCII 值将每个字符更改为前一个字符：lst = [‘a’, ‘b’, ‘e’, ‘f’, ‘o’, ‘a’]

result = map(lambda x:chr(ord(x)+1),lst) # 使用 ord() 将所有字母映射到它的 ascii 值

print(list(result))

Reduce Function

Reduce() 函数接受一个函数和一个序列，并返回一个值。这个函数在“ functools ”模块中定义。

lst = [‘a’, ‘b’, ‘e’, ‘f’, ‘o’, ‘a’]

result = map(lambda x:chr(ord(x)+1),lst) 

print(list(result))

from functools import reduce

result = reduce(lambda x,y:x+y,lst)

print(result)

到目前为止，我们已经了解了函数以及编写它们的不同方式。现在，让我们关注Python 基础下的模块。

一个模块可以被视为一个代码库同样的事情。它是一个文件，其中包含要包含在应用程序中的一组函数。

假设在与临时文件相同的位置有一个名为mod1.py的文件，它有一个质数函数和一个偶数函数。def prime(a):

    for i in range(2,a):

        if a%i == 0:

            print(“Number is not prime”)

            return

    print(“Number is prime”)

def even(a):

    if a%2 == 0:

        print(“Number is even”)

    else:

        print(“Number is odd”)

You can access mod1.py file from the scratch file by importing it.

from mod1 import *

n = int(input(“Enter a number”))

prime(n) # Calling the prime function

even(n) # Calling the even function

使用模块可以让你的代码更紧凑、更易读；你不必通读一百行代码。此外，您可以与可以在项目中使用它的其他人共享此模块。

现在您已经了解了 Python 编程的基础知识，是时候了解面向对象编程( OOP ) 及其不同的特性了。

一切，包括每个实例，都是Python 中的一个对象。OOP 是一种专注于对象的编程范式。一个对象具有Attributes和Behavior。

属性包含描述对象的数据，例如列表、元组、数组、变量。

该行为具有应用于属性的方法。

以下是具有以下属性和行为的汽车示例：

Class

OOP 中的类是相似对象的集合。

Inheritance

Python 中的继承机制是 OOP 最重要的特性之一。它允许一个新类继承另一个类的特性。

示例：可以有一个“车辆”类，在车辆下，有一个称为“汽车”的类。”这里，“车辆”称为父类，“汽车”称为子类。汽车可以继承汽车的所有功能和特点。

Encapsulation

这是保留数据免于直接访问的功能。

Polymorphism

Polymorphism多态性是一种特性，可以让您以多种方式使用相同的功能。

假设你有汽车和自行车。自行车的加速与汽车截然不同；汽车靠燃料行驶，自行车有踏板。它们都可以加速，但使用方式不同。

下面的例子解释了面向对象编程的概念：

class Car:

    carType = “manual” # global feature

    def __init__(self, year, speed): #__init()__ is executed when the function is being initiated

        self.year=year # creating an instance

        self.speed=speed

    @staticmethod

    def welcome():

        print(“Welcome to the car showroom”)

    @classmethod

    def type(cls):

        print(print(“These cars are”, cls.carType))

    def getSpeed(self):

        print(“Maximum speed is”, self. speed)

BMW = Car(2018, 155)

Ford = Car(2016, 140)

Car.welcome()

BMW.getSpeed()

Ford.getSpeed()

Car.type()

The following is an example of Inheritance:

class Car:

    def __init__(self, year, speed): 

        self.year=year # creating an instance

        self.speed=speed

    def getSpeed(self):

        print(“Maximum speed:”, self.speed)

class Sedan(Car): # Sedan inherits the features of Car

    pass

BMW = Car(2018, 155)

Ford = Car(2016, 140)

BMW.getSpeed()

在本 Python 基础教程的最后一节中，让我们看一个示例，展示如何在 Python 中实现多态。

class Car:

    def __init__(self,name):

        self.name=name

class Sedan(Car):

    def getSpeed(self):

        print(“Maximum speed 150”)

class SUV(Car):

    def getSpeed(self):

        print(“Maximum speed 120”)

carLst = [Sedan(“Camry”), SUV(“Scorpio”)]

for car in carLst:

    print(car.name + “:”,end= “”)

    car.getSpeed()

可以看到我们已经将汽车类变形为轿车和SUV，并继承了汽车类的功能。

期待进入编程领域吗？参加Python 培训课程，开始您作为专业 Python 程序员的职业生涯

结论

这个 Python 教程应该让读者更好地理解所有的基本的 Python 概念，包括不同的条件语句、使用 NumPy 处理数据、如何编写函数、如何创建模块、如何使用类和对象实现面向对象编程的不同功能。

如需更多实践经验，请扫描公众号，获得更多信息。