Python基础知识：是什么使Python如此强大？
Python ，您已经听说过它，并且想知道这种语言有什么特别之处。随着机器学习和人工智能的兴起，无法摆脱它。您可能会问自己，Python易于学习吗？我告诉你，实际上是！我在这里可以帮助您开始使用Python基础知识。
该博客将是以下内容的演练：
- What is Python?
- Features of Python
- Jumping to the Python Basics
- Flow Control
- File Handling
- OOPS with Python
让我们开始吧。
什么是Python？
简单来说，Python是一种高级动态编程语言，可以对其进行解释。Python之父 Guido van Rossum在开发Python时就想到了简单的目标，易于看懂的代码，可读性强和开放源代码。在2018年Stack Overflow进行的一项调查中，Python被评为第三大最杰出的语言，其次是JavaScript和Java，这证明了Python是增长最快的语言。
Python的功能
由于它的简单性，强大的库和易读性， Python是目前我最喜欢的语言，也是最喜欢使用的语言。您可能是老派的编码员，或者可能对编程完全陌生，Python是入门的最佳方法！
Python提供以下功能：
- 简洁性：少考虑语言的语法，而多考虑代码。
- 开源：一种强大的语言，每个人都可以根据需要免费使用和更改。
- 可移植性： Python代码可以共享，并且可以按预期的方式工作。无缝且无忧。
- 可嵌入和可扩展： Python可以在其内部包含其他语言的片段来执行某些功能。
- 解释： Python本身可以解决大内存任务和其他繁重的CPU任务的烦恼，使您仅需担心编码。
- 大量的图书馆：数据科学？Python已经覆盖了您。Web开发？Python仍然为您服务。总是。
- 面向对象：对象有助于将复杂的现实问题分解为可以编码和解决的问题，从而获得解决方案。
综上所述，Python具有简单的语法，易读且具有强大的社区支持。您现在可能会遇到一个问题：如果您知道Python怎么办？好吧，您有许多选择。
跳到Python基础
要开始使用Python基础知识，您需要先在系统中安装Python，对吗？所以，现在就开始做吧！您应该知道，当今大多数Linux和Unix发行版都带有现成的Python版本。要设置自己，您可以按照此分步指南进行操作。
设置完成后，您需要创建第一个项目。按着这些次序：
- 创建项目并输入名称，然后单击创建。
- 右键单击项目文件夹，然后使用New-> File-> Python File创建一个python文件，然后输入文件名
你完成了。您已设置文件以开始使用Python进行编码。您为开始编码感到兴奋吗？让我们开始。第一个也是最重要的是“ Hello World”程序。
print('Hello World, Welcome to edureka!')
输出：世界您好，欢迎来到 python！
在那里，这是您的第一个程序。您可以通过语法看出它非常容易理解。让我们转到Python基础知识中的注释。
Python注释
Python中的单行注释使用＃符号和“'”进行多行注释。如果您想了解更多有关评论的信息，请阅读此完整指南。了解Python基础知识中的注释后，让我们进入Python基础知识中的变量。
变量
简单来说，变量就是可以存储数据或值的存储空间。但是Python的问题在于，不需要像其他语言那样在使用前声明变量。该数据类型被自动分配给变量。如果输入整数，则数据类型将分配为整数。您输入一个字符串，该变量被分配一个字符串数据类型。你明白了。这使Python成为动态类型的语言。您可以使用赋值运算符（=）将值赋给变量。
a = 'Welcome to edureka!' b = 123 c = 3.142 print(a, b, c)
输出：欢迎来到edureka！123 3.142
您可以看到我为这些变量分配值的方式。这是在Python中为变量分配值的方式。而且，如果您想知道，可以在一个print语句中打印多个变量。现在让我们回顾一下Python基础知识中的数据类型。
Python中的数据类型
数据类型基本上是一种语言支持的数据，因此有助于定义现实生活中的数据，例如薪水，员工姓名等。可能性是无止境。数据类型如下所示：
数值数据类型
顾名思义，这是将数字数据类型存储在变量中。您应该知道它们是不可变的，这意味着变量中的特定数据无法更改。
有3种数值数据类型：
- 整数：这很简单，您可以在变量中存储整数值。例如：a = 10。
- 浮点数：浮点数包含实数，并用十进制表示，有时甚至用科学计数法表示，E或e表示10的幂（2.5e2 = 2.5 x 102 = 250）。例如：10.24。
- 复数：这些复数的形式为a + bj，其中a和b为浮点数，J表示-1的平方根（这是一个虚数）。例如：10 + 6j。
a = 10 b= 3.142 c = 10+6j
因此，既然您已经了解了各种数值数据类型，就可以在此Python Basics博客中了解将一种数据类型转换为另一种数据类型的方法。
类型转换
类型转换是一种数据类型到另一种数据类型的转换，这在我们开始编程以获得问题的解决方案时对我们确实有帮助。让我们通过示例来理解。
a = 10 b = 3.142 c = 10+6j print(int(b), float(a), str(c))
输出：10.0 3 '10 + 6j'
您可以理解，通过上面的代码片段键入转换。“ a”为整数，“ b”为浮点数，“ c”为复数。您可以使用Python内置的float（），int（），str（）方法来帮助我们进行转换。当您进入实际示例时，类型转换可能非常重要。
一个简单的情况是您需要计算公司中员工的薪水，这些薪水应为浮动格式，但以字符串格式提供给我们。因此，为了使我们的工作更轻松，您只需使用类型转换并将薪金字符串转换为float，然后继续进行我们的工作。现在，让我们转到Python Basics中的List数据类型。
列表(list)
简单表中的列表可以认为是其他语言中存在的数组，但是它们中可以包含 异构元素，即同一列表中的数据类型不同。列表是可变的，这意味着您可以更改列表中可用的数据。
对于那些不知道数组是什么的人，您可以想象一个可以按照您需要的方式保存数据的机架来理解它。您以后可以通过调用存储数据的位置（在编程语言中称为索引）来访问数据。使用a = list（）方法或使用a = []定义列表，其中“ a”是列表的名称。
您可以从上图中看到存储在列表中的数据以及与存储在列表中的数据相关的索引。请注意，Python中的索引始终以'0'开头。现在，您可以移至列表可能的操作。
列表操作如下表格式所示。
| Code Snippet | Output Obtained | Operation Description |
| a[2] | 135 | Finds the data at index 2 and returns it |
| a[0:3] | [3.142, ‘Hindi’, 135] | Data from index 0 to 2 is returned as the last index mentioned is always ignored. |
| a[3] = ‘edureka!’ | moves ‘edureka!’ to index 3 | The data is replaced in index 3 |
| del a[1] | Deletes ‘Hindi’ from the list | Delete items and it does not return any item back |
| len(a) | 3 | Obtain the length of a variable in Python |
| a * 2 | Output the list ‘a’ twice | If a dictionary is multiplied with a number, it is repeated that many number of times |
| a[::-1] | Output the list in the reverse order | Index starts at 0 from left to right. In reverse order, or, right to left, the index starts from -1. |
| a.append(3) | 3 will be added at the end of the list | Add data at the end of the list |
| a.extend(b) | [3.142, 135, ‘edureka!’, 3, 2] | ‘b’ is a list with value 2. Adds the data of the list ‘b’ to ‘a’ only. No changes are made to ‘b’. |
| a.insert(3,’hello’) | [3.142, 135, ‘edureka!’, ’hello’, 3, 2] | Takes the index and the value and adds value to that index. |
| a.remove(3.142) | [135, ‘edureka!’, ’hello’, 3, 2] | Removes the value from the list that has been passed as an argument. No value returned. |
| a.index(135) | 0 | Finds the element 135 and returns the index of that data |
| a.count(‘hello’) | 1 | It goes through the string and finds the times it has been repeated in the list |
| a.pop(1) | ‘edureka!’ | Pops the element in the given index and returns the element if needed. |
| a.reverse() | [2, 3, ‘hello’, 135] | It just reverses the list |
| a.sort() | [5, 1234, 64738] | Sorts the list based on ascending or descending order. |
| a.clear() | [] | Used to remove all the elements that are present in the list. |
现在您已经了解了各种列表函数，接下来让我们继续了解Python Basics中的Tuple。
元组（Tuples）
Python中的元组与列表相同。要记住的一件事是，元组是不可变的。这意味着一旦声明了元组，就不能添加，删除或更新元组。就那么简单。这使元组比List快得多，因为它们是恒定值。
操作与列表类似，但是涉及更新，删除，添加的操作，这些操作不起作用。Python中的元组写为a =（）或a = tuple（），其中“ a”是元组的名称。
a = ('List', 'Dictionary', 'Tuple', 'Integer', 'Float')
print(a)
输出=（``列表''，``字典''，``元组''，``整数''，``浮点数''）
基本上，这包装了元组所需的大部分内容，因为只有在您想要一个具有恒定值的列表的情况下才使用它们，因此您使用元组。让我们转到Python Basics中的Dictionary。
字典(Dictionary)
当您与我们有一个真实的例子时，最好能理解字典。最容易理解的例子是电话簿。想象一下电话簿，并了解其中存在的各个字段。您可以想到“姓名”，“电话”，“电子邮件”和其他字段。将名称视为键，将输入的名称视为值。同样，以电话为键，输入数据为值。这就是字典。它是包含键值对的结构。
使用a = dict（）或使用a = {}（其中a是字典）来编写字典。键可以是字符串，也可以是整数，其后必须跟有“：”和该键的值。
MyPhoneBook = { 'Name' : [ 'Akash', 'Ankita' ] ,
'Phone' : [ '12345', '12354' ] ,
'E-Mail' : [ 'akash@rail.com', 'ankita@rail.com' ]}
print (MyPhoneBook)
输出：{'名称'：['Akash'，'Ankita']，'电话'：['12345'，'12354']，'电子邮件'：['akash@rail.com'，'ankita @ rail .com']}
访问字典的元素
您会看到密钥分别是名称，电话和电子邮件，它们分别分配了2个值。当您打印字典时，键和值将被打印。现在，如果您只想获取特定键的值，则可以执行以下操作。这称为访问字典的元素。
print(MyPhoneBook['E-Mail'])
输出：['akash@rail.com'，'ankita@rail.com']
字典操作
| Code Snippet | Output Obtained | Operation Description |
| MyPhoneBook.keys() | dict_keys([‘Name’, ‘Phone’, ‘E-Mail’]) | Returns all the keys of the dictionary |
| MyPhoneBook.values() | dict_values([[‘Akash’, ‘Ankita’], [12345, 12354], [‘ankita@rail.com’, ‘akash@rail.com’]]) | Returns all the values of the dictionary |
| MyPhoneBook[‘id’]=[1, 2] | {‘Name’: [‘Akash’, ‘Ankita’], ‘Phone’: [12345, 12354], ‘E-Mail’: [‘ankita@rail.com’, ‘akash@rail.com’], ‘id’: [1, 2]} is the updated value. | The new key, value pair of id is added to the dictionary |
| MyPhoneBook[‘Name’][0]=”Akki” | ‘Name’: [‘Akki’, ‘Ankita’] | Access the list of names and change the first element. |
| del MyPhoneBook[‘id’] | {‘Name’: [‘Akash’, ‘Ankita’], ‘Phone’: [12345, 12354], ‘E-Mail’: [‘ankita@rail.com’, ‘akash@rail.com’]} | The key, value pair of ID has been deleted |
| len(MyPhoneBook) | 3 | 3 key-value pairs in the dictionary and hence you obtain the value 3 |
| MyPhoneBook.clear() | {} | Clear the key, value pairs and make a clear dictionary |
您现在可能对Python基础知识中的字典有了更好的了解。因此，让我们转到此Python基础知识博客中的Sets。
集合（Sets）
集合基本上是元素或项目的无序集合。元素在集合中是唯一的。在Python中，它们用大括号括起来并用逗号分隔。您可以看到，即使集合'a'中存在相似的元素，由于集合是唯一元素的集合，因此它仍将仅打印一次。
a = {1, 2, 3, 4, 4, 4}
b = {3, 4, 5, 6}
print(a,b)
输出：{1,2,3,4} {3,4,5,6}
集合中的运算
| Code Snippet | Output Obtained | Operation Description |
| a | b | {1, 2, 3, 4, 5, 6} | Union operation where all the elements of the sets are combined. |
| a & b | {3, 4} | Intersection operation where only the elements present in both sets are selected. |
| a – b | {1, 2} | Difference operation where the elements present in ‘a’ and ‘b’ are deleted and remaining elements of ‘a’ is the result. |
| a ^ b | {1, 2, 5, 6} | Symmetric difference operation where the intersecting elements are deleted and the remaining elements in both sets is the result. |
集合很容易理解，因此让我们转到Python基础知识中的字符串。
字符串（Strings）
Python中的字符串是最常用的数据类型，尤其是因为它们使我们人类更容易与之交互。从字面上看，它们是单词和字母，它们在如何使用以及在什么上下文中有意义。Python之所以将它拒之门外是因为它具有与字符串的如此强大的集成。字符串写在单引号（“ ）或双引号（”“）中。字符串是不可变的，这意味着不能在特定索引处更改字符串中的数据。
Python中字符串的操作可以显示为：
注意：我在这里使用的字符串是：mystsr =“ edureka！”。是我的地方”
| Code Snippet | Output Obtained | Operation Description |
| len(mystr) | 20 | Finds the length of the string |
| mystr.index(‘!’) | 7 | Finds the index of the given character in the string |
| mystr.count(‘!’) | 1 | Finds the count of the character passed as the parameter |
| mystr.upper() | EDUREKA! IS MY PLACE | Converts all the string into the upper case |
| mystr.split(‘ ‘) | [‘edureka!’, ‘is’, ‘my’, ‘place’] | Breaks the string based on the delimiter passed as the parameter. |
| mystr.lower() | edureka! is my place | Converts all the strings of the string into lower case |
| mystr.replace(‘ ‘, ‘,’) | edureka!,is,my,place | Replaces the string which has old value with the new value. |
| mystr.capitalize() | Edureka! is my place | This capitalizes the first letter of the string |
这些只是可用功能中的一部分，如果您进行搜索，可以找到更多功能。
拼接字符串
拼接会将字符串分为所需的格式或获取方式。有关此主题的更多信息，您可以阅读此博客。 Python中有许多内置函数，您可以在此处查看本文。这基本上总结了Python中的数据类型。希望您对此有所了解，如有任何疑问，请发表评论，我会尽快与您联系。
现在，让我们转到Python基础知识中的Operators。
Python中的运算符
运营商们构建你用来操作的数据，这样你可以断定某种形式的解决方案给我们。一个简单的例子是，如果有2个朋友每个人有70卢比，而您想知道他们每个人的总数，则可以加钱。在Python中，您可以使用+运算符来添加总计为140的值，这是解决该问题的方法。
Python有一个运算符列表，可以将其分组为：
让我们继续前进，仔细了解这些操作员。
注意：变量称为运算符，位于运算符的左侧和右侧。例如：
a=10 b=20 a+b
这里的“ a”和“ b”是操作数，而“ +”是运算符。
算术运算符
它们用于对数据执行算术运算。
| Operator | Description |
| + | Adds the values of the operands |
| – | Subtracts the value of the right operator with the left operator |
| * | Multiples left operand with the right operand |
| / | Divides the left operand with the right operand |
| % | Divides the left operand with the right operand and returns the remainder |
| ** | Performs the exponential of the left operand with the right operand |
下面的代码段将帮助您更好地理解它。
a = 2 b = 3 print(a+b, a-b, a*b, a/b, a%b, a**b, end=',')
输出：5，-1，6，0.6666666666666666，2，8
了解了Python Basics中的算术运算符后，让我们开始使用赋值运算符。
赋值运算符
顾名思义，这些用于为变量分配值。就那么简单。
各种赋值运算符是：
| Operator | Description |
| = | It is used to assign the value on the right to the variable on the left |
| += | Notation for assigning the value of the addition of the left and right operand to the left operand. |
| -= | Notation for assigning the value of the difference of the left and right operand to the left operand. |
| *= | Short-hand notation for assigning the value of the product of the left and right operand to the left operand. |
| /= | Short-hand notation for assigning the value of the division of the left and right operand to the left operand. |
| %= | Short-hand notation for assigning the value of the remainder of the left and right operand to the left operand. |
| **= | Short-hand notation for assigning the value of exponential of the left and right operand to the left operand. |
让我们继续阅读此Python Basics博客中的比较运算符。
比较运算符
这些运算符用于导出左右操作数之间的关系，并得出您需要的解决方案。简单地说，您将它们用于比较目的。这些运算符获得的输出将为true或false，这取决于这些值的条件是否为true。
| Operator | Description |
| == | Find out whether the left and right operands are equal in value or not |
| != | Find out whether the values of left and right operators are not equal |
| < | Find out whether the value of the right operand is greater than that of the left operand |
| > | Find out whether the value of the left operand is greater than that of the right operand |
| <= | Find out whether the value of the right operand is greater than or equal to that of the left operand |
| >= | Find out whether the value of the left operand is greater than or equal to that of the right operand |
您可以在以下示例中查看它们的工作原理：
a = 21
b = 10
if a == b:
print ( 'a is equal to b' )
if a != b
print ( 'a is not equal to b' )
if a < b:
print ( 'a is less than b' )
if a > b:
print ( 'a is greater than b' )
if a <= b:
print ( 'a is either less than or equal to b' )
if a >= b:
print ( 'a is either greater than or equal to b' )
输出：
a不等于b
a大于b
a大于或等于b
让我们继续使用Python基础知识中的按位运算符。
按位运算符
要了解这些运算符，您需要了解bit的理论。这些运算符用于直接操作位。
| Operator | Description |
| & | Used to do the AND operation on individual bits of the left and right operands |
| | | Used to do the OR operation on individual bits of the left and right operands |
| ^ | Used to do the XOR operation on individual bits of the left and right operands |
| ~ | Used to do the 1’s compliment operation on individual bits of the left and right operands |
| << | Used to shift the left operand by right operand times. One left shift is equivalent to multiplying by 2. |
| >> | Used to shift the left operand by right operand times. One right shift is equivalent to dividing by 2. |
最好自己在计算机上进行练习。在Python基础知识中继续使用逻辑运算符。
逻辑运算符
这些用于从操作数获得特定逻辑。我们有3个操作数。
- 和（如果左右操作数均为真，则为真）
- 或（如果一个操作数为真，则为真）
- 不（给出与传递的操作数相反的方向）
a = True b = False print(a and b, a or b, not a)
输出： False是False
转到Python基础知识中的成员运算符。
会员运营商
这些用来测试一个是否特定变量或值存在于任一列表，字典，元组，集合等。
运营商是：
- in（如果在序列中找到值或变量，则为真）
- 不在（如果在序列中找不到该值，则为真）
a = [1, 2, 3, 4]
if 5 in a:
print('Yes!')
if 5 not in a:
print('No!')
输出：不！
让我们跳到Python基础知识中的身份运算符。
身份运算符
这些运算符用于检查值，变量是否相同。就如此容易。
运营商是：
- 是（如果相同，则为真）
- 不是（如果不相同，则为真）
a = 5
b = 5
if a is b:
print('Similar')
if a is not b:
print('Not Similar!')
关于Python运算符的结论就是正确。
在移至名称空间之前，建议您阅读Python函数的文章，以更好地理解Python中的函数。完成此操作后，让我们继续使用Python基础知识中的命名空间。
命名空间和范围
您确实还记得Python中的一切都是对象，对吧？那么，Python如何知道您要访问的内容？考虑一下您有两个具有相同名称的函数的情况。您仍然可以调用所需的函数。那怎么可能？这是使用命名空间进行救援的地方。
Namespacing是Python用于为代码中的所有对象分配唯一名称的系统。而且，如果您想知道，对象可以是变量和方法。Python通过维护字典结构来进行命名间隔。其中名称充当键，对象或变量充当结构中的值。现在您想知道名字是什么？
好的，名称只是您用来访问对象的一种方式。这些名称用作访问您分配给它们的值的参考。
范例：a = 5，b ='edureka！'
如果我想访问值“ edureka！” 我可以简单地用“ b”来命名变量名，然后我就可以访问“ edureka！”。这些是名字。您甚至可以分配方法名称并相应地调用它们。
import math
square_root = math.sqrt
print('The square root is ',square_root(9))
输出：根是3.0
命名空间可与范围一起使用。范围是它们所属的函数或类中的函数/变量/值的有效性。Python内置函数的命名空间覆盖了Python的所有其他范围。诸如print（）和id（）等的函数即使没有任何导入也可以使用，并且可以在任何地方使用。在它们下面是全局和局部命名空间。让我在下面的代码片段中解释范围和命名空间：
def add():
x = 3
y = 2
def add2():
p, q, r = 3, 4, 5
print('Inside add2 printing sum of 3 numbers:'(p+q+r))
add2()
print('The values of p, q, r are :', p, q, r)
print('Inside the add printing sum of 2 numbers:'(x+y))
add()
如您在上面的代码中所看到的，我已经声明了两个函数，名称分别为add（）和add2（）。您具有add（）的定义，并在以后调用方法add（）。在add（）中，您调用add2（），因此由于3 + 4 + 5为12，因此您可以获得12的输出。但是，一旦退出add2（），p，q，r的范围被终止意味着p，q，r仅在您位于add2（）中时可访问和可用。由于您现在位于add（）中，因此不存在p，q，r，因此会收到错误，并且执行将停止。
您可以从下图更好地了解范围和命名空间。在内置的范围包括了所有的Python使他们可以在需要时。在全球范围内覆盖了所有的程序正在执行。在本地范围覆盖所有的方法在程序执行。基本上，这就是Python中的命名空间。让我们继续进行Python Basics中的流控制。
Python中的流控制和条件
您知道代码会以任何语言顺序运行，但是如果您想中断该流程，以便能够添加逻辑并重复某些语句，从而减少代码并能够以更少，更聪明的代码获得解决方案，该怎么办。毕竟，这就是编码。查找问题的逻辑和解决方案，这可以使用Python中的循环和条件语句来完成。
条件语句仅在满足特定条件时才执行，否则将向前跳到满足条件的位置。Python中的条件语句是if，elif和else。
句法：
if condition:
statement
elif condition:
statement
else:
statement
这意味着，如果满足条件，请执行某些操作。否则，通过其余的elif条件，最后，如果不满足任何条件，则执行else块。您甚至可以在if-else块中嵌套if-else语句。
a = 10
b = 15
if a == b:
print ( 'They are equal' )
elif a > b:
print ( 'a is larger' )
else :
print ( 'b is larger' )
了解条件语句后，让我们进入循环。您可能会有某些时间想要一次又一次地执行某些语句以获得解决方案，或者可以应用某种逻辑，以便仅使用2至3行代码即可执行某种类似类型的语句。这是您在Python中使用循环的地方。
循环可分为2种。
- 有限：这种循环在满足特定条件之前有效
- 无限循环：这种循环无限循环，永远不会停止。
Python或任何其他语言中的循环必须测试条件，并且可以在语句之前或之后执行循环。他们叫 ：
- 测试前循环：首先测试条件，然后执行条件语句
- 测试后循环：语句至少执行一次，然后检查条件。
Python中有两种循环：
- 对于
- 而
让我们用下面的语法和代码片段来理解每个循环。
对于循环：这些循环用于为给定条件执行一组特定的语句，并继续执行直到条件失败为止。您知道执行for循环所需的次数。
句法：
for variable in range: statements
代码片段如下：
basket_of_fruits= ['apple', 'orange', 'pineapple', 'banana']
for fruit in basket_of_fruits:
print(fruit, end=',')
输出：苹果，橙子，菠萝，香蕉
这就是for循环在Python中的工作方式。让我们继续进行Python Basics中的while循环。
While循环：While循环与for循环相同，不同之处在于您可能不知道结束条件。for循环条件是已知的，而while循环条件可能不是。
句法：
while condition:
statements
该代码段为：
second = 10
while second >= 0:
print(second, end='->')
second-=1
print('Blastoff!')
输出：10-> 9-> 8-> 7-> 6-> 5-> 4-> 3-> 2-> 1-> Blastoff！
这就是while循环的工作方式。
稍后，您将拥有嵌套循环，您可以在其中嵌套一个循环。下面的代码应该给您一个想法。
count = 1
for i in range(10):
print(str(i) * i)
for j in range(0, i):
count = count+1
输出：
1
22
333
4444
55555
666666
777777
88888888
999999999
您具有第一个for循环，该循环输出数字的字符串。另一个for循环将数字加1，然后执行这些循环，直到满足条件为止。这就是for循环的工作方式。这样就结束了我们的循环和条件会话。继续使用Python基础知识进行文件处理。
使用Python处理文件
Python已经内置的功能，你可以用它来工作，文件，如阅读和书写 数据 从或文件。一个文件对象当一个文件被使用open（）函数调用，然后你可以做它的操作，例如读取，写入，修改等返回。
如果您想详细了解文件处理，可以阅读完整的教程-Python中的文件处理。
文件的处理流程如下：
- 使用open（）函数打开文件
- 对文件对象执行操作
- 使用close（）函数关闭文件，以避免对该文件造成任何损坏
句法：
File_object = open('filename','r')
模式是您要与文件交互的方式。如果您不传递任何模式变量，则默认设置为读取模式。
| Mode | Description |
| r | Default mode in Python. It is used to read the content from a file. |
| w | Used to open in write mode. If a file does not exist, it shall create a new one else truncates the contents of the present file. |
| x | Used to create a file. If the file exists, the operation fails |
| a | Open a file in append mode. If the file does not exist, then it opens a new file. |
| b | This reads the contents of the file in binary. |
| t | This reads the contents in text mode and is the default mode in Python. |
| + | This opens the file for updating purposes. |
例：
file = open('mytxt','w')
string = ' --Welcome to edureka!-- '
for i in range(5):
file.write(string)
file.close()
输出：–欢迎来到edureka！– –欢迎来到edureka！– –欢迎来到edureka！– –欢迎来到edureka！– –欢迎来到edureka！– mytxt文件中
您可以继续尝试越来越多的文件。让我们转到博客的最后主题。OOPS以及对象和类。两者密切相关。
面向对象
较旧的编程语言经过了结构设计，使得任何代码模块都可以访问数据。这可能会导致潜在的安全问题，导致开发人员转向面向对象的编程，这可以帮助我们将现实世界中的示例模拟为代码，从而可以获得更好的解决方案。
OOPS有4个重要的概念，需要理解。他们是：
- 继承：继承允许我们从父类派生属性和方法，并根据需要对其进行修改。最简单的示例可以是描述了汽车结构的汽车，并且可以派生此类来描述跑车，轿车等。
- 封装：封装是将数据和对象绑定在一起，以便其他对象和类不访问数据。Python具有私有，受保护和公共类型，其名称表明了它们的作用。Python使用'_'或'__'指定私有或受保护的关键字。
- 多态性：这使我们能够为需要的各种类型的数据提供一个通用接口。您可以使用传递不同数据的相似函数名称。
- 抽象： 通过对适合问题的类进行建模，抽象可用于简化复杂的现实。
- 点赞
- 收藏
- 关注作者
评论（0）