Python是世界上最受欢迎和广泛的编程语言之一。它被广泛用于网络开发,数据分析,机器学习,自动化以及许多其他应用程序。 Python具有简单而优雅的语法,可以易于读写代码。它还具有丰富的内置库和模块,可提供许多有用的功能。
如何使用变量,数据类型,运算符,表达式和语句
变量:变量是指存储在内存中的值的名称。您可以使用=运算符为变量分配一个值。例如:
x = 10
y = "Hello"
这将值10分配给变量X,并将值“ Hello”分配给变量y。您可以在表达式和语句中使用变量,就像它们是值一样。例如:
x = 5
y = 9
z = x + y
print(z)
这添加了x和y的值,并将结果分配给z。然后将z打印到标准输出。
数据类型:数据类型是具有某些特征和行为的值类别。 Python具有几种内置数据类型,例如INT(Integer),浮点(浮点数),str(String),bool(boolean),列表(值序列),元组(价值的不可分割序列),dict(dict)(将键映射到值)和设置(唯一值的收集)。您可以使用Type()函数检查值或变量的类型。例如:
x = 5
y = 'Hello'
print(type(x)) # prints <class 'int'>
print(type(y)) # prints <class 'str'>
您还可以使用内置功能(例如int(),float(),str(),bool(),list(),tuple(),dict()
和set()将一种数据类型转换为另一种数据类型。例如:
a = 3.14
b = int(a) # converts a to an integer
c = str(a) # converts a to a string
操作员:操作员是对值或变量执行操作的特殊符号。 Python有几种类型的运营商,例如算术运算符(+, -, , /, *, %, //)
,分配运营商(=, +=, -=, *=, /= etc.)
,比较操作员(==, != , < , > , <= , >= )
,逻辑运营商(and, or, not )
,位于位操作员(& , | , ^ , ~ , << , >> )
,会员运营商(IN,IN,IN),身份操作员(INS IS,IS,IS,IS,IS)。优先级和关联规则决定了如何在表达式中评估操作员。
表达式:表达式是值,变量,运算符和函数的组合,可以评估以产生单个值。例如:
x = 5
y = x*2
这是一种使用算术运算符和变量来计算y。
的值的表达式语句:语句是执行某些操作或控制执行流的指令。例如:
y = 5
if y > 0: print("Positive")
elif y == 0: print("Zero")
else: print("Negative")
这是一个IF-ELIF-ELSE语句,检查Y的值并相应地打印不同的消息。
如何使用控制流量工具
if-else语句
也许最著名的控制流量工具是if-else语句。它允许您根据指定条件执行代码块。 IF-ELSE语句的语法如下:
if condition:
# do something
else:
# do something else
条件可以是评估布尔值的任何表达式(真或错误)。压痕在Python中很重要,因为它定义了每个块的范围。其他条款是可选的,只有在条件为false时才执行。
例如:
x = 10
if x > 0:
print("x is positive")
else:
print("x is negative or zero")
此代码将打印“ X IS录音”,因为x> 0评估为true。
您还可以使用Elif条款检查多个条件:
x = 10
if x > 0:
print("x is positive")
elif x < 0:
print("x is negative")
else:
print("x is zero")
此代码将打印“ X IS肯定”,因为X> 0评估为true,并且没有检查其他条件。
用于循环
另一个常见的控制流量工具是for循环。它使您可以迭代一系列项目,并为每个项目执行一个代码块。 for循环的语法如下:
for item in sequence:
# do something with item
序列可以是任何可触觉的对象,例如列表,元组,字符串或范围对象。项目变量可以是您选择的任何名称,并且会依次保存序列的每个元素。
例如:
fruits = ["apple", "banana", "orange"]
for fruit in fruits:
print(fruit)
此代码将在单独的行上的水果列表中打印每个水果。
启动参数指定启动值(包含在内),停止参数指定终结值(独家),而步骤参数指定每次迭代要增加多少。如果省略,请启动默认为0,然后步骤默认为1。
range(start, stop, step)
启动参数指定启动值(包含在内),停止参数指定终结值(独家),而步骤参数指定每次迭代要增加多少。如果省略,请启动默认为0,然后步骤默认为1。
例如:
for i in range(1, 11):
print(i)
循环
while condition:
# do something
条件可以是评估布尔值的任何表达式(真或错误)。循环将继续运行,直到以下任务:
条件变为false
断路语句从中退出
发生例外
例如:
n = 1
while n < 100:
print(n)
n = n * 2
此代码将在单独的行上打印两个小于100的功率。
中断并继续语句
有时您可能需要根据初始条件以外的某些条件更改或终止循环。为此,您可以使用break并继续循环中的语句。
Break语句允许您立即从当前循环中退出,并在下一个声明之后恢复执行。例如:
for i in range(1, 11):
if i == 5:
break # exit from loop when i equals 5
print(i)
此代码只会从1到4打印数字,因为当我等于5时,它会从中爆发。
继续语句允许您跳过当前循环的其余迭代,然后转到下一个。它可以在循环中和循环中使用。例如:
for i in range(10):
if i % 2 == 0: #if i is even
continue # skip this iteration
print(i) # print only odd numbers
此代码将仅打印0到9的奇数数字,因为它将使用Contine跳过每个偶数号码。
当您想避免循环中的某些不必要的值或条件时,您可以使用继续语句。例如,如果要计算列表中的正数之和,则可以使用继续跳过负数:
numbers = [1, -2, 3, -4, 5]
sum = 0
for n in numbers:
if n < 0: # if n is negative
continue # skip this iteration
sum += n # add n to sum
print(sum) #prints 9
此代码将打印9,因为它将使用Contine忽略-2和-4。
数据结构
列表
列表是可变且有序的任何类型的项目集合。列表是通过将项目包装在方括号中或使用list()构造函数函数来创建的。例如:
#Creating a list of numbers
numbers = [1, 2, 3, 4, 5]
print(numbers) # prints [1, 2, 3, 4, 5]
# Creating a list of strings
fruits = ["apple", "banana", "cherry"]
print(fruits) # prints ["apple", "banana", "cherry"]
# Creating a list of mixed types
mixed = [True, 3.14, "hello", None]
print(mixed) # prints [True, 3.14, "hello", None]
# Creating an empty list
empty = []
print(empty) # prints []
# Creating a list using the list() function
letters = list("abcde")
print(letters) # prints ["a", "b", "c", "d", "e"]
列出了支持各种操作,例如索引,切片,附加,插入,删除,分类,反向等等。这里有一些例子:
# Accessing items by index (zero-based)
numbers = [1 ,2 ,3 ,4 ,5]
print(numbers[0]) # prints 1
print(numbers[-1]) # 5
# Slicing a list (returns a new list)
numbers = [1 ,2 ,3 ,4 ,5]
print(numbers[1:3]) # prints [2 ,3]
print(numbers[:2]) # prints [1 ,2]
print(numbers[3:]) # prints [4 ,5]
print(numbers[:]) # prints [1 ,2 ,3 ,4 ,5]
# Changing items by index (mutating the list)
numbers = [1 ,2 ,3 ,4 ,5]
numbers[0] = 10
print(numbers) # prints [10 ,2 ,3 ,4 ,5]
元组
与列表不同,元组是不可变的,这意味着创建后不能更改它们。元组对于存储不应修改的数据很有用,例如坐标,日期或用户信息。
为了在Python中创建元组,我们可以将圆形支架内部逗号分隔的值序列()。例如:
my_tuple = (1, 2, 3)
print(my_tuple) #prints (1, 2, 3)
We can also create a tuple without using round brackets. This is called tuple packing. For example:
my_tuple = 1, 2, 3
print(my_tuple) #prints (1, 2, 3)
If we want to create a tuple with only one item, we need to add a comma after the item. Otherwise, Python will treat it as a regular value and not as a tuple. For example
my_tuple = (1,)
print(type(my_tuple))
输出:
<class 'tuple'>
但是,如果我们删除逗号:
my_tuple = (1)
print(type(my_tuple))
输出变为
<class 'int'>
要从元组访问项目,我们可以将Square Brackets []与项目的索引一起使用。该索引从零开始,比元组的长度少一个。例如:
my_tuple = ("apple", "banana", "cherry")
print(my_tuple[0])
print(my_tuple[1])
print(my_tuple[2])
输出:
apple
banana
cherry
我们还可以使用负索引从元组结束时访问项目。最后一项的索引为-1,每个上一项都下降一个。例如:
my_tuple = ("apple", "banana", "cherry")
print(my_tuple[-1])
print(my_tuple[-2])
print(my_tuple[-3])
输出:
cherry
apple
banana
我们还可以使用切片符号[start:stop:step]从元组中访问一系列项目。开始索引是包容性的,停止索引是独家的。该步骤指定在每个项目之间跳过多少个项目。如果省略,则默认为一个。例如:
my_tuple = ("apple", "banana", "cherry", "orange", "kiwi")
print(my_tuple[1:4]) # from index 1 (inclusive) to index 4 (exclusive)
print(my_tuple[:3]) # from index 0 (inclusive) by default to index 3 (exclusive)
print(my_tuple[2:]) # from index 2 (inclusive) to end by default
print(my_tuple[-4:-1]) # from index -4 (inclusive) to index -1 (exclusive)
print(my_tuple[::2]) # every second item from start (inclusive) by default)to end by default
输出:
('banana', 'cherry', 'orange')
('apple', 'banana', 'cherry')
('cherry', 'orange', 'kiwi')
('banana', 'cherry', 'orange')
('apple', 'cherry', 'kiwi')
要通过元组中的所有项目循环,我们可以使用迭代器变量或索引变量的循环使用。
使用迭代器变量意味着我们依次将每个项目分配给一个变量名称,并在循环主体内对其进行一些操作。例如:
my_tuple = ("red", "green", "blue")
for color in my_tuple:
print(color.upper())
输出:
RED
GREEN
BLUE
设置
一组是具有可见,可变且没有重复元素的数据类型的集合。集合中的元素顺序不确定,尽管它可能包含各种元素。一组可以具有任何数量的项目,它们可能具有不同的类型(整数,浮动,元组,字符串等)。但是集合不能将列表,集合或字典等可变元素作为其元素。
集集可用于存储和执行需要是唯一的数据的操作,例如会员测试,数学操作,例如联合,相交或差异或从序列中删除重复项。
在python中,我们通过将所有元素放在卷曲括号{}中,通过逗号分隔。例如:
# create an empty set
s = set()
# create a set with some integers
s = {1, 2, 3}
# create a set with mixed data types
s = {1.5, "hello", (4, 5)}
我们还可以使用内置函数集()从列表或元组等其他迭代物创建集。
例如:
# create a set from a list
l = [1, 2 ,3 ,4 ,5]
s = set(l)
# create a set from a tuple
t = ("a", "b", "c")
s = set(t)
请注意,如果我们将具有重复元素的值具有重复元素传递给set()函数,则只能将每个元素的出现在结果集中。
例如:
# create a list with duplicate elements
l = [1 ,2 ,3 ,4 ,5 ,1 ,2]
# create a set from the list
s = set(l)
# print the set
print(s) # prints {1 ,2 ,3 ,4 ,5}
设置支持许多方法和运算符,以执行各种操作。其中一些是:
-
len(s)
:返回集合s。 中的元素数量
-
x in s
:如果x是set s的元素,则返回true;否则false。 -
x not in s
:如果x不是集合s的元素,则返回true;否则false。 -
s.add(x)
:如果尚未存在,则将x添加到集合s; -
s.remove(x)
:如果存在,则从集合中删除x;提高KeyError
否则。 -
s.discard(x)
:如果存在,请从集合中删除x -
s.pop()
:删除并返回集合s的任意元素;如果S为空,请提高KeyError
。 -
s.clear()
:从集合s。 中删除所有元素
-
s.copy()
:返回集合s。 的浅副本
字典
词典是Python中最有用,最通用的数据结构之一。它们允许您存储和访问键值对数据,每个键都与值相关联。在本指南中,您将学习如何创建,操纵和使用Python中的字典。
词典是键值对的集合,由卷曲括号{}包含。每个键值对由一个逗号分隔,每对由一个钥匙组成,然后是结肠:然后是一个值。例如:
my_dict = {"name": "Alice", "age": 25, "occupation": "programmer"}
该词典具有三个键值对:“名称为“爱丽丝”,“年龄”地图为25,而“职业”地图为“程序员”。这些密钥可以是任何不变的数据类型,例如字符串,数字,布尔值或元组。值可以是任何数据类型,包括其他字典或列表。
您还可以使用dict()构造函数来创建字典。例如:
my_dict = dict(name="Alice", age=25, occupation="programmer")
这与上述相同的字典创建了。请注意,当使用dict()函数时,您无需将键包装在引号中。
如何访问字典值
要访问与词典中的键关联的值,您可以使用Square Brackets []并指定其内部的键。例如:
print(my_dict["name"]) # prints Alice
print(my_dict["age"]) # prints 25
如果您尝试访问字典中不存在的键,则会获得keyError异常。为了避免此错误,您可以使用get()字典方法。此方法采用两个参数:如果找不到密钥,则返回的键和可选默认值。例如:
print(my_dict.get("name")) # prints Alice
print(my_dict.get("gender")) # prints None
print(my_dict.get("gender", "female")) # prints female
如何添加或更新字典元素
要向现有字典添加一个新的键值对,您可以简单地使用Square Brackets []为新键分配一个值。例如:
my_dict["hobby"] = "reading"
print(my_dict) # prints {'name': 'Alice', 'age': 25, 'occupation': 'programmer', 'hobby': 'reading'}
要更新字典中的现有值,您可以使用Square Brackets []为现有密钥分配一个新值。例如:
my_dict["age"] = 26
print(my_dict) # prints {'name': 'Alice', 'age': 26, 'occupation': 'programmer', 'hobby': 'reading'}
您还可以使用字典的Update()方法一次添加或更新多个元素。该方法将另一个词典作为一个论点,并将其与原始词典合并。如果两个词典之间有任何重复的键,则第二个词典的值将覆盖第一个字典。例如:
my_dict.update({"name": "Bob", "city": "New York"})
print(my_dict) # prints {'name': 'Bob', 'age': 26, 'occupation': 'programmer', 'hobby': 'reading', 'city': 'New York'}
如何删除字典元素
要通过其键从字典中删除元素,您可以使用pop()字典方法。此方法采用一个参数:要删除的元素的键。它返回与删除元素关联的值并将其从字典中删除。例如:
value = my_dict.pop("hobby")
print(value) # prints reading print(my_dict) # prints {'name': 'Bob', 'age': 26, 'occupation': 'programmer', 'city': 'New York'}
如果您尝试在字典中弹出一个不存在的键,则将获得KeyError
异常。为了避免此错误,您可以将第二个参数传递给POP(),这是一个默认值,如果找不到密钥,则将返回。例如:
value = my_dict.pop("gender", "unknown")
print(value) # prints unknown
功能
函数是执行特定任务的代码的命名块。一个函数可以采用零或更多输入(称为参数或参数)并产生零或更多输出(称为返回值)。
功能很有用,因为它们允许您:
将复杂问题分解为较小,更简单的子任务
避免为不同的输入编写相同的代码
摘要如何完成任务的详细信息,并专注于它的工作
通过隔离程序的不同部分
来测试和调试代码通过为任务提供有意义的名称来增强代码的可读性和结构
例如,假设您要编写一个程序来计算不同形状的区域,例如圆,正方形,矩形,三角形等。您可以在主程序中为每个形状编写单独的公式长,重复且难以阅读。一种更好的方法是为每个形状定义单独的功能,以采用必要的输入(例如半径,长度,宽度等),并返回该区域作为输出。然后,您可以在主要程序中需要这些功能时调用这些功能。
如何在python中定义和调用函数?
要在Python中定义一个函数,您可以使用DEF关键字,然后使用函数的名称和一对括号()。在括号内,您可以选择指定该函数期望为输入的一个或多个参数。括号后,您添加了一个结肠:然后是一个缩进的代码块,其中包含构成功能正文的语句。
定义python函数的一般语法是:
def function_name(parameter1, parameter2,...):
# body of the function
# statements
要在python中调用函数,您使用其名称,然后是括号()
。在括号内,
您可以选择通过一个或多个与
匹配的参数
由
定义的参数
功能。这些论点被逗号分开,。
在python中调用函数的一般语法是:
function_name(argument1, argument2,...)
例如,
# Define a function that takes two numbers as input
#and returns their sum as output
def add(x,y):
result = x + y # calculate the sum of x and y return result # return the sum as output
return result
# Call the add function with 3 and 5 as arguments
sum = add(3,5) # store the returned value in sum variable
print(sum) # prints 8
- 函数的名称应具有描述性并遵循PEP 8样式指南。
- 参数是仅在函数范围内存在的局部变量。 将它们分配给函数时作为参数传递的值分配。
- 返回语句结束了函数的执行,并将值返回到 呼叫者,召集者。如果没有返回语句或之后没有价值,则 功能默认返回无。
- ,只要在拨打呼叫之前定义了程序中的任何地方,就可以从程序中的任何地方调用功能。
模块和软件包
一个模块是包含Python代码的文件。它可以定义其他Python程序可以使用的变量,函数,类和其他对象。例如,数学模块包含数学函数和常数。
包装是在层次结构中组织的模块集合。一个软件包可以包含子包(也是软件包)和模块。例如,Numpy软件包包含许多子弹(例如线性代数的numpy.linalg)和模块(例如numpy.random for ander Numbhergenopen)。
模块和软件包允许您重复使用其他开发人员或您自己编写的代码。它们还可以帮助您将代码组织成易于维护和理解的逻辑单元。
如何导入模块和软件包
要在Python代码中使用模块或软件包,您需要先导入它。 Python中有不同的方式导入模块和软件包:
您可以使用导入语句,然后使用模块或软件包的名称。例如
import math
import numpy
这种导入方式使您可以使用点表示法访问模块或软件包中定义的所有对象。例如:
math.sqrt(25) # returns 5.0
numpy.array([1, 2, 3]) # returns an array object
您可以使用来自... import ...的语句,然后使用模块或软件包的名称以及要导入的一个或多个对象的名称。例如:
from math import pi
from numpy import random
这种导入方式可让您仅访问指定的对象而不使用点表示法。例如:
random.randint(10) # returns a random integer between 0 and 9
您可以使用来自... import *语句,然后使用模块或软件包的名称导入其中定义的所有对象。例如:
from math import *
from numpy import *
这种导入方式使您无需使用点符号即可访问所有对象。但是,不建议这样做,因为它可能导致名称与代码或其他导入模块或软件包中定义的其他对象发生冲突。
Python中流行且有用的软件包
有成千上万个用于Python的模块和软件包,这些模块和包裹涵盖了各种域和功能。以下是您应该知道的流行和有用软件包的一些示例:
-
requests
:一个简单而功能强大的软件包,用于向Web服务器提出HTTP请求。 -
pandas
:一个快速而灵活的包装,用于数据操纵和分析。 -
matplotlib
:一个用于创建高质量图和可视化的综合包装。 -
scikit-learn
:用于机器学习算法的用户友好式软件包。 -
tensorflow
:深度学习框架的尖端包装。 -
flask
:一个轻巧但可靠的软件包。
您可以在其官方网站或文档页面上找到有关这些软件包的更多信息。
如何处理异常
尝试...除了块以外用于处理Python中的异常。这是尝试的语法...除了块:
try:
# code that may cause exception
except:
# code to run when exception occurs
尝试子句包含可能导致异常的代码。除非子句发生在异常时,该条款包含应运行的代码。除非子句除外,还可以指定它可以通过在关键字之后命名的类型的异常。例如:
try:
x = 0
y = 10 / x
print(y)
except ZeroDivisionError:
print("You cannot divide by zero")
在此示例中,我们尝试从用户输入中获取一个数字,并通过其除以10。如果用户进入零,则会导致ZeroDivisionError
异常。除非子句捕获此异常并打印消息而不是崩溃程序。
您可以有多个条款以不同的方式处理不同类型的异常。例如:
try:
a = int(input("Enter a number: "))
b = 0
c = a / 0
print(y)
except ZeroDivisionError:
print("You cannot divide by zero")
except ValueError:
print("You must enter a valid number")
在此示例中,我们添加了另一个以外的条款来处理ValueError
异常,如果用户输入了一个数字以外的其他内容。
如果您未在关键字之后指定任何类型的异常,则它将捕获Try子句中发生的任何类型的异常。但是,不建议这样做,因为它可能隐藏了代码中的一些意外错误或错误。
如何提高自己的异常
有时您可能需要在代码中提出自己的异常,以指示某些自定义错误条件或对数据或逻辑执行一些约束。您可以使用RAID关键字进行此操作,然后使用异常类的实例。
def square_root(x):
if x < 0:
raise ValueError("Cannot take square root of negative number")
return x ** 0.5
print(square_root(4))
print(square_root(-1))
在此示例中,我们定义了一个符合数字平方根的函数。但是,我们要确保输入不是负面的,因为这将导致一个虚构的数字,而python的内置数学功能不支持。因此,如果x为负,我们提出了一个ValueError
例外。
当我们以正数(例如4)调用此功能时,它可以正常工作并返回其正方根(例如2)。但是,当我们以负数为负数(例如-1)时,它提高了我们的自定义异常,该异常用错误消息阻止了我们的程序。
class NegativeNumberError(ValueError):
pass
def square_root(x):
if x < 0:
raise NegativeNumberError("Cannot take square root of negative number")
return math.sqrt(x)
如何读写文件
在我们可以从/到文件读取数据或写入数据之前,我们需要使用open()
函数将其打开。 open()
函数采用两个参数:文件名(字符串)和访问模式(也是字符串)。访问模式指定了我们要与文件进行交互的方式,例如仅读取,仅编写,附加数据等。
open()
函数返回代表打开文件的文件对象。我们可以使用此文件对象在文件上执行各种操作。例如,我们可以使用read()
方法将文件中的所有数据读取为单个字符串。
这是打开一个名为示例的文件的示例。
# Open the file for reading only
file = open("example.txt", "r")
# Read all the data from the file
data = file.read()
# Print the data
print(data)
# Close the file
file.close()
输出可能看起来像这样:
This is an example text file.
It contains some sample data.
We can read it using Python.
请注意,我们在代码末尾使用了file.close()
。这很重要,因为它可以释放文件对象使用的任何资源并防止任何潜在的错误或冲突。完成后,最好始终关闭文件。
另外,我们可以在退出其块后自动关闭文件。用语句创建了一个上下文管理器,该管理器会为我们处理文件的打开和关闭。这是我们可以使用语句:
重写以前的代码的方式
# Open the file for reading only using a with statement
with open("example.txt", "r") as file:
# Read all the data from the file
data = file.read()
# Print the data
print(data)
# No need to close the file explicitly
输出将与以前相同。
阅读和写入数据
有几种可用于从Python中/到文件的读取和编写数据的方法。其中一些是:
-
read()
:从文件中读取所有或指定的字节/字符数字为单个字符串。 -
readline()
:一次从文件中读取一行作为字符串。 -
readlines()
:将文件中的所有行读取为字符串列表。 -
write()
:将给定的字符串或字节对象写入文件。 -
writelines()
:将字符串或字节对象的列表写入文件。
让我们看看这些方法中这些方法的一些示例。
阅读数据
分别在打开的文本/二进制模式下从给定位置读取所有或指定的字节/字符,我们可以使用read()方法。如果没有更多数据要读取,此方法将返回一个空字符串。例如:
# Open a text file in read mode
f = open("example.txt", "r")
#Read 10 characters from the current position
data = f.read(10)
print(data)
#Read all remaining characters from the current position
data = f.read()
print(data)
#Close the file
f.close()
输出可能看起来像这样:
Hello world! This is an example text file.
我们还可以使用readline()
方法一次从打开的文本模式文件中读取一行。如果没有更多的行读取,此方法将返回一个空字符串。例如:
#Open a text file in read mode
f = open("example.txt", "r")
# Read one line and print it
line = f.readline()
print(line)
#Read another line and print it
line = f.readline()
print(line)
#Close the file
f.close()
输出可能看起来像这样:
Hello world!
This is an example text file.
写数据
要分别将数据写入打开的文本/二进制模式,我们可以使用write()方法。此方法将写入文件的字节/字符的数量返回。例如:
#Open a text file in write mode (this will overwrite any existing content)
f = open("example.txt", "w")
#Write some data to the file
num_bytes = f.write("This is some new data.\n")
print(num_bytes)
#Close the file
f.close()
输出可能看起来像这样:
19
我们还可以使用writelines()
方法分别为打开的文本/二进制模式编写多行(字符串列表)。此方法不会在列表中的每个元素之间添加任何newline字符,因此我们需要在需要时手动添加它们。例如:
#Open a text file in append mode (this will add new content at the end)
f = open("example.txt", "a")
#Write some lines to the file (note that we need to add \n for each line)
lines = ["This is another line.\n", "And one more.\n"] num_bytes = f.writelines(lines) print(num_bytes)
#Close the file
f.close()
为了避免任何错误或资源泄漏,建议使用Python中的文件时与语句一起使用。带有语句退出其块后自动关闭文件,因此我们无需明确调用Close()方法。
jsons
JSON是一种基于文本的键值数据格式,遵循特定语法。 JSON值可以是以下类型之一:
字符串:以双引号封闭的字符序列。例如:“ Hello World”
一个数字:整数或浮点数。例如:42或3.14
布尔人:true或false
null:文字值null
一个数组:零或更多JSON值的有序集合,封闭在方括号中,并由逗号隔开。例如:[1, 2, 3]
或["red", "green", "blue"]
一个对象:无序的钥匙值对集合,封闭在卷曲括号中,并由逗号隔开。每个键必须是字符串,每个值必须是JSON值。例如:{"name": "Alice", "age": 25}
或{"scores": [100, 90, 80]}
JSON文档可以包含任何有效的JSON值作为其根元素。
如何在python中读写json
Python具有一个名为JSON的内置模块,该模块提供了用于编码和解码JSON数据的功能。要使用它,我们需要先导入它:
import json
To read a JSON string or file into a Python object (such as a list or a dictionary), we can use the json.loads() function for strings or the json.load() function for files. For example:
# Read a JSON string into a Python object
json_string = '{"name": "Bob", "hobbies": ["reading", "gaming", "coding"]}'
python_object = json.loads(json_string)
print(python_object)
# Output: {'name': 'Bob', 'hobbies': ['reading', 'gaming', 'coding']}
# Read a JSON file into a Python object
with open("data.json") as f:
python_object = json.load(f)
print(python_object)
# Output: {'name': 'Bob', 'hobbies': ['reading', 'gaming', 'coding']}
要将python对象写入json字符串或文件,我们可以使用json.dumps()函数来用于字符串或json.dump()函数。例如:
# Write a Python object into a JSON string
python_object = {'name': 'Bob', 'hobbies': ['reading', 'gaming', 'coding']}
json_string = json.dumps(python_object)
print(json_string)
# Output: {"name": "Bob", "hobbies": ["reading", "gaming", "coding"]}
# Write a Python object into a JSON file
with open("data.json", "w") as f:
json.dump(python_object, f)
JSON模块还提供了一些可选参数来自定义编码和解码过程。例如:
-
indent
参数可以指定缩进级别,以打印出输出。 -
sort_keys
参数可以指定是否按字母顺序排列对象的键。 -
ensure_ascii
参数可以指定是否使用\ uxxxx序列逃脱非ASCII字符。
有关JSON模块的这些参数和其他功能的更多详细信息,请参考官方文档。
结论
在本文中,我们介绍了Python编程语言的基础知识以及如何将其用于各种任务。我们已经探索了构成任何Python程序构建块的变量,数据类型,运算符,表达式和语句的基本概念。我们已经看到了如何使用控制流量工具,例如if-else语句,循环,循环,并破坏和继续语句以根据某些条件或迭代来控制我们的代码的执行。我们已经学习了如何使用列表,元组,集合,词典等数据结构以有效且有条理的方式来存储和操纵数据集合。我们已经讨论了如何使用功能,模块和软件包。我们学会了如何处理异常以及如何读取文件。通过遵循本文,您应该能够编写可以解决各种问题或执行各种任务的基本Python程序。
恭喜您完成了本文!您已经获得了Python编程技能的坚实基础,这些技能将在未来的项目中为您提供帮助。希望您喜欢和我一起学习Python,并希望您在编码旅程中祝您好运。
-rohan