python是一门脚本语言,与HTML一样。书写非常简便。变量的声明与c++有着很大的区别,不用声明变量类型,语句末尾不用“;”
增加一个名为message的变量
message="hello python worla!"
1.变量名只能包括字母、数字和下划线。变量名能以字母或下划线打头,不能以数字打头`。
2.变量名不能包含空格,应该使用下划线分隔其中单词。
3.不能将python中的关键词与函数名当作变量名
4.变量名应该简短而且具有描述性
5.慎用小写字母l与大写O,与数组0和1不容易分清楚。
字符串就是一系列的字符,用单引号或者双引号括起来
name="ada lovelace"
使用title,将每个单词的首字母大写
print(name.title())
#结果应该是
Ada Lovelace
使用upper,将每个单词的字母大写
print(name.upper())
#结果应该是
ADA LOVELACE
使用lower,将每个单词的字母小写
要在字符串中插入变量的值,可以在引号前面加上字母f,然后把要插入字符串的变量放在花括号里
first_name=ada
last_mane=lovelace
print(f"my name is {first_name} {last_name}")
#结果应该是
my name is ada lovelace
\n换行 \t增加空格
使用rstrip消除后面的空格
#后面有空格
name="python "
print(f"{name.rstrip()}good")
#结果是
pythongood
print(f"{name}good")
#结果是
python good
使用lstrip消除前面的空格
#前面有空格
name=" python"
print(f"{name.lstrip()} good")
#结果是
python good
print(f"{name} good")
#结果是
python good
使用strip消除前后所有的空格
#前后都有空格
name=" python "
print(f"{name.strip()}good")
#结果是
pythongood
print(f"{name}good")
#结果是
python good
整数:加减乘除运算
平方:**
整数与浮点数运算,结果是浮点数。
如果数字比较长可以增加_分割,便于阅读,不影响结果\
number=14_000_000_000
同时给多个变量赋值:
x,y,z=1,2,3
常量:全部大写说明该数为常量
MAX_COMECTIONS = 5000
#大家好,我是python
由一系列按特定顺序排列的元素组成,可以将任何东西加入列表中,其中的元素之间可以没有关联,因为列表中常常有多个元素,因此列表名往往是一个复数的名称
方括号[]表示列表,用逗号分隔其中的元素
bicycles=['trek','cannondale','redline']
print(bicycles)
#结果是
['trek','cannondale','redline']
列表是有序集合,访问列表的任意元素,只需要将元素的位置告诉python:列表名称,元素的索引,后者放入方括号内
bicycles=['trek','cannondale','redline']
print(bicycles[0])
#结果是
trek
第一个列表元素索引并不是1,而是0,大部分编程语言均是如此,为了方便访问,若列表元素过多,python提供一种特殊语法,直接访问最后一个元素。
print(bicycles[-1])
#结果是
redline
print(bicycles[-2])
#结果是
cannondale
#于此类推...
修改:
bicycles=['trek','cannondale','redline']
bicycles[1]='honda'
print(bicycles)
#结果是
['trek','honda','redline']
增加元素:
bicycles=['trek','cannondale','redline']
bicycles.append('honda')
print(bicycles)
#结果是
['trek','cannondale','redline','honda']
#只在列表末尾处增加
bicycles=['trek','cannondale','redline']
bicycles.insert(0,'honda')
print(bicycles)
#结果是
['honda'.'trek','cannondale','redline']
#指定位置增加元素
删除元素:
bicycles=['trek','cannondale','redline']
del bicycles[0]
print(bicycles)
#结果是
[cannondale','redline']
弹出某个元素:如果pop后括号内没有声明索引,则默认弹出最后一个元素
bicycles=['trek','cannondale','redline']
a=bicycles.pop(1)
print(a)
print(bicycles)
#结果是
cannondale
['trek','redline']
根据值删除元素:remove只能删除第一个特定的值,如果重复多次,需要循环
bicycles=['trek','cannondale','redline']
bicycles.remove('trek')
print(bicycles)
#结果是
bicycles=['cannondale','redline']
使用sort()方法对列表永久排序:按首字母顺序
bicycles=['trek','cannondale','redline']
bicycles.sort()
print(bicycles)
#结果是
['cannondale','redline','trek']
使用sorted()对列表临时排序:但原来bicycles列表顺序不变
bicycles=['trek','cannondale','redline']
print(sorted(bicycles))
#结果是
['cannondale','redline','trek']
倒着打印列表:按照原列表的反顺序
bicycles=['trek','cannondale','redline']
bicycles.reverse()
print(bicycles)
#结果是
['redline','cannondale','trek']
确定列表的长度:
bicycles=['trek','cannondale','redline']
a=len(bicycles)
print(a)
#结果是
3
获取一个列表中所有元素
magicians = ['alice','david','carolina']
for magician in magicians:
print(magician)
#结果是
alice
david
carolina
删除空格,字符大小写变化等等操作都可以添加
magicians = ['alice','david','carolina']
for magician in magicians:
print(f"{magician.title()},that is a great magician!" )
#结果是
Alice,that is a great magician!
David,that is a great magician!
Carolina,that is a great magician!
生成一系列数
for number in range(1,5):
print(number)
#结果是
1
2
3
4
#到5停止打印,因此没有5
需要使用list()将range()的结果转换为列表
numbers = list(range(1,6))
print(numbers)
#结果是
[1,2,3,4,5]
使用range()生成数时,还可以规定步长
比如生成2-11之间的偶数
numbers = list(range(2,11,2))
print(number)
#结果是
[2,4,6,8,10]
生成1-5的平方数
squares =[]
for number in range(1,6):
square =number**2
squares.append(square)
print(squares)
#结果是
[1,4,9,16,25]
dights = [1,2,3,4,5,6,7,8]
min(digths)
-----1
max(digths)
-----8
sun(dights)
-----36
要创造切片,可指定要使用的第一个元素和最后一个元素的索引,
players =['charles','martina','michael','florence','eli']
print(players[0:3])
#结果是
['charles','martina','michael']
可以指定任何子集,比如第二,第三和第四元素
print(players[1:4])
没有指定第一个索引,将默认从第一个开始
print(players[:3])
不遍历整个列表,只遍历指定切片
players =['charles','martina','michael','florence','eli']
for player in players[1:4]
print(player)
#结果是
martina
michael
flarence
要复制整个列表,我们需要建立一个包含整个列表的切片,方法是同时省略起始索引跟终止索引
players =['charles','martina','michael','florence','eli']
M_players = player[:]
print(M_players)
['charles','martina','michael','florence','eli']
列表适合存储在程序运行中需要变化的数据集,但有些元素是不可修改的,元组可以满足这一要求
用圆括号而非中括号标识,用法与列表一样,但不能修改
names = ('kyle','mark')
用法与列表一样
names = ('kyle','mark')
for name in names:
print(name)
#结果是
kyle
mark
虽然不能修改某个具体的值,但可以整体重新赋值
names = ('kyle','mark')
#重新赋值
names =('simth','jack')
for name in names:
print(name)
#结果是
simth
jack
普通汽车名,全部大写打印,如果是bmw,只首字母大写打印即可
cars=['audi','bmw','subaru','toyota']
for car in cars:
if car =='bmw':
print(car.title())
else:
print(car.upper())
每个if语句后跟的都是一个值为True或False的表达式,根据值来决定是否执行if后面的代码
‘=’表示赋值,‘==’表示判断是否相等
car = bmw
car =='bmw'
#结果是
True
检查相等时忽略大小写
使用‘!=’
相等与字符方法相同
<,>,<=,>=。用法相同
and和or
cars = ['bmw','make']
'bmw' in cars
#结果是
True
names =['jack','mark','smith']
name = 'kyle'
if name not in names:
print(f"{name.title()},you are not a name"")
#结果是
Kyle,you are not a name
条件测试的别名,与其他条件表达式一样,结果只有两种。
前面有演示,记得if语句里的代码要缩进
如果条件测试通过执行一个操作,没通过,执行另一个操作。
age = 17
if age <= 18:
print("you are too young!")
else:
print("good")
#结果是
you are too young!
检查多个条件
age = 16
if age < 10:
a = 1
elif age < 18:
a = 2
else:
a = 3
print(a)
#结果是
2
可以使用多个elif代码块
else包括不符合if和elif的其他所有语句,有时候需要一个elif去结束if语句,而省略else
names =['jack','mark','smith']
for name in names:
if name == 'jack':
print("1")
else:
print("2")
#结果是
1
2
2
不为空,执行for循环,为空,则执行另一个操作
在python中,字典是一系列键值对,每个键都有值相关联,可以使用键来访问相关联的值,与键相关联的值可以是数,字符串,列表乃至字典。
字典用放在花括号“{}”中的一系列键值对表示:
people = {'name':'jack','sex'='man'}
要获取与键相关联的值,可依次指定字典名和放在方括号内的键
print(people['name'])
#结果是
jack
字典是一种动态结构,可以随时增加键值对。指定字典名,用方括号括起的键和相关联的值
people = {'name':'jack','sex'='man'}
people['grade'] = 1
people['hobit'] = soccer
print(people)
#结果是
{'name':'jack','sex'='man','grade'=1,'hobit'='soccer'}
使用字典来存储用户提供的数据或在编写能自动生成大量键值对的代码时,通常需要先定义一个空字典
people = {}
要修改字典中的值,可依次指定字典名,用方括号括起来的键,以及新值
people = {'name':'jack','sex'='man'}
people['name']='smith'
print(people)
#结果是
people = {'name':'smith','sex'='man'}
people = {'name':'jack','sex'='man'}
del people['sex']
print(people)
#结果是
people = {'name':'jack'}
之前的实例中,字典存储的是一个对象的多种信息,我们也可以用字典存储众多对象的同一信息
language = {
'jack':'c++',
'smith':'python',
'kyle':'java',
}
使用方括号的键从字典中获取感兴趣的值时,如果指定的键不存在,就会报错。
方法get(),第一个参数用于指定键,是必不可少的;第二个参数为指定的键不存在时要返回的值。
people = {'name':'jack','sex':'man'}
a = people.get('point','No point value assigned')
b = people.get('name','No name value assigned!')
print(a)
#结果是
No point value assigned
jack
要遍历字典得for循环,可声明两个变量,用于存储键值对中的键和值。
people = {'name':'jack','sex':'man'}
for key,value in people.items():
print (f"\nkey:{key}")
print (f"value:{value}")
#结果是
key:name
value:jack
key:sex
value:man
在不需要使用字典中的值时,方法keys()很有用。
people = {'name':'jack','sex':'man'}
for a in people.key():
print(a)
#结果是
name
sex
使用sorted()来获得按特定顺序排列的键列表得副本
languages = {
'jen':'python',
'sarah':'c',
'edward':'ruby',
'phil':'python'
}
for name in sorted(languages.keys()):
print(name)
#结果是
edward
jen
phil
sarah
使用values()来返回值,不包括任何键
languages = {
'jen':'python',
'sarah':'c',
'edward':'ruby',
'phil':'python'
}
for language in languages.values():
print(language)
#结果是
python
c
ruby
python
提取字典中的所有值,并没有考虑是否重复,要剔除重复项,可使用集合(set),集合中的每个元素都必须是独一无二的
for language in set(languages.values()):
print(language)
#结果是
python
c
ruby
创建三个字典,每个字典都是一个人的信息,然后将三个字典存储到一个列表中。
people1={'name':'jack','language':'python'}
people2={'name':'kylw','language':'c'}
people3={'name':'smith','language':'java'}
peoples=[people1,people2,people3]
print(peoples)
#结果是
{'name':'jack','language':'python'}
{'name':'kylw','language':'c'}
{'name':'smith','language':'java'}
people={'name':'jack','languages':['java','python','c']}
peoples={
' people1':{
'name':'jack',
'language':'python',
},
'people2':{
'name':'smith',
'language':'c'
}
}
函数input()让程序暂停运行,等待用户输入一些文本。获取用户输入后,Python将其赋给一个变量。
message = input("Tell me a thing:")
print(message)
如果提示有多行,可以将提示赋给一个变量,再将这个变量传给input()函数
message = "i want your name"
message +="\nwhat is your name: "
name = input(message)
我们使用input()获取用户输入的值,即使是数字,我们获得的确是字符串类型的,如果需要跟一个数比较,则需要将获得的字符串“数字”,转换成数值
age = input("how old are you? ")
age = int(age)
if age > 18:
print("hello")
求模运算符(%)是个很有用的工具,它将两个数相除并返回余数:
4%3
1
5%3
2
6%3
0
通过和2执行求模运算来判断该数的奇偶性
for循环用于针对集合中的每个元素都执行一个代码块,而while循环则不断运行,知道指定的条件不满足为止
使用while循环数数
number = 1
while number <5:
print(number)
number +=1
#结果是
1
2
3
4
5
prompt ="\ntell mo something,i will repeat it to you"
prompt = "\nenter'quit'to end the program"
message = ''
while message != 'quit':
message = input(promt)
print(message)
在要求很多条件都满足才继续运行的程序中,可定义一个变量,用于判断整个程序是否处于活动状态,这个变量我们称为标志,充当程序的交通信号灯。可以让程序在标志为True时继续执行,并在标志为False时让程序停止运行。
prompt ="\ntell mo something,i will repeat it to you"
prompt = "\nenter'quit'to end the program"
message = ''
active = True
while active:
message = input(prompt)
if message == 'quit':
active = False
else:
print(message)
要立刻退出while循环,不再运行循环中余下的代码,也不管条件测试的结果如何,可使用break语句。
prompt ="\ntell mo something,i will repeat it to you"
prompt = "\nenter'quit'to end the program"
while True:
message = input(prompt)
if message == 'quit':
break
else:
print(message)
要返回循环开头,并根据条件测试结果决定是否继续执行循环,可使用continue语句,它不像break语句那样不再执行余下的代码并退出整个循环。
number = 1
while number<10:
number +=1
if number%2 == 0:
continue
print(number)
如果程序陷入无限循环,可按Ctrl+C
friend_nums = ['1','2','3']
my_nums = []
while friend_nums:
number = friend_nums.pop()
my_nums.append(number)
for num in my_nums:
print(num)
#结果是
1
2
3
numbers = ['1','2','1','3','1']
print(numbers)
while '1' in numbers:
numbers.remove('1')
print(numbers)
#结果是
['1','2','1','3','1']
['2','3']
actives = True
dogs = {}
while actives:
name = input("\nwhat is you name?")
dog = input("what dog would you like?")
dogs[name] = dog
repeat =input("anyone else?(yes/no)")
if repeat =='no':
actives = False
print("show all databases:")
for name,dog in dogs.items():
print(f"{name} like {dog}")
使用def定义函数名,后面必须带圆括号,里面跟参数。下面可以有文档注释串
def index():
"""这是文档注释串"""
print("hello world")
index()
#结果是
hello world
通过给括号内指定参数,给函数传值
def index(name):
print(f"hello {name.title()}!")
index('kyle')
#结果是
hello Kyle!
在上述函数定义时,变量(name)是一个***形参***,即函数完成工作所需的信息。在代码index(‘kyle’)中’kyle’是***实参***,即调用函数所传递给函数的信息。
函数定义中可能包括多个形参,因此函数调用中也可能包括多个实参。向函数传递实参的方式有很多:位置实参,关键字实参,列表和字典。
实参与形参的顺序相同,调用函数时,python必须将函数调用中的每个实参都关联到函数定义中的一个形参(可以多次调用,给不同实参;一定要注意实参顺序)
def index(my_name,friend_name):
print(f"{my_name} is {friend_name}")
index('kyle','smith')
#结果是
kyle is smith
传递给函数名称对,直接在实参中将名称和值关联起来,所以不用考虑实参位置
def index(my_name,friend_name):
print(f"{my_name} is {friend_name}")
index(friend_name='smith',my_name='kyle')#顺序与形参顺序不相符,但没影响
#结果是
kyle is smith
定义函数时,可给每个形参指定默认值,如果调用函数时没有给该变量传递实参,则使用默认值
def index(my_name,friend_name='jack'):
print(f"{my_name} is {friend_name}")
index(my_name='smith')
#结果是
smith is jack
index('kyle')
#结果是
kyle is jack
index(friend_name='smith',my_name='kyle')#给有默认值的形参传递实参,将忽略其默认值
#结果是
kyle is smith
位置实参,关键字实参以及默认值可以混合使用,一种输出可以有多种调用方式
def animals(name,type='dog'):
......
#名叫willie的狗
animals('smith')
animals(name='smith')
#名叫jack的猫
animals('jack','cat')
animals(name='jack',type='cat')
animals(type='cat',name='jack')
调用函数后,如果实参不匹配,程序将会报错
函数并非总是直接显示输出的,同样可以处理一些数据,返回一个值或者一组值
def get_name(first_name,last_name):
name=f"{first_name.title()} {last_name.title.()}"
return name
my_name=get_name('smith','jack')
print(my_name)
#结果是
Smith Jack
def get_name(first,last,middle=''):
if middle:
name=...
else:
name=...
def peoples(name,dog):
peoples={'name'=name,'dog'=dog}
return people
people = peoples('jack','smith')
print(people)
#结果是
{'name'='jack','dog'='smith'}
也可以给函数定义时增加一个空的形参,给用户传递实参时提供选择
def get_name(first_name,last_name):
name=f"{first_name.title()} {last_name.title.()}"
return name
while True:
print("\nplease tell me:")
print("enter 'q' to stop!")
first=input("first name:")
if first=='q':
break
last=input("last name:")
if last=='q':
break
f_name=get_name(first,last)
print(f"hello {f_name}!")
将列表传递给函数
def get(names):
for name in names:
index=f"hello,{name.title()}"
print(index)
users=['jack','smith','kyle']
get(users)
#结果是
hello Jack!
hello Smith!
hello Kyle!
可以定义一个函数,形参是两个列表,然后在函数中进行列表的元素转移等等操作,用户只需要在调用函数时传递两个实参列表就行,即需要进行这种操作时,调用这个函数即可!
如果两个列表转移元素,但起始列表元素不能删除,可以把该列表的副本当作实参传递给函数,而不是该列表本身
index(my_name[:],friend_name)
传入my_name列表的副本
预先不知道函数需要多少个实参,使用 *变量名,如 *name让python创建一个名为name的空元组,将实参封装到一个元组中。
def get(*names):
for name in name:
print(name)
get('jack','smith')#任意数量实参
#结果是
jack
smith
def get(size,*toppings):
print(f"{size}:")
for topping in toppings:
print(topping)
get(16,'a','b')
get(15,'s'.'d','f')
#结果是
16:
a
b
15:
s
d
f
def get(first,last,**user_info):
user['first_name']=first
user['last_name']=last
return(user)
people=get('smith','jack',sex='man',year='16')
print(people)
#结果是
{'first_name':'smith','last_name'='jack','sex'='man','year'=16}
使用函数的优点之一就是将代码块与主程序分离。我们还可以将函数存储在称为模块的独立文件中,再将模块导入到主程序中,import语句允许当前运行程序文件中使用模块中的代码
首先创建模块,模块是拓展名为.py的文件,包含要导入程序中的代码
创建一个name.py文件,再其所在目录创建一个名为make.py文件
再name.py文件中声明函数,在导入到make.py文件中
import name
name.function()#使用模块的函数
可以导入某个模板中特定的函数
from name import function1
...
from name import function1,function2
如果要导入的函数名与该程序内函数名冲突,可以在调用时给函数指定别名,利用as
from name import function as md
md()#使用别名即可
import name as nm
nm.function()#模块名称使用别名即可
from name import *
导入模块name.py文件中的所有函数
根据类来创建对象称为实例化(面向对象编程)
每个类存储名字和年龄,赋予每条小狗蹲下和打滚的能力;
首字母大写的名称指的时类,定义时没有圆括号。
类中的函数称为方法。init()是一个特殊的函数,当根据类创建实例时,都会运行它。其中包含三个形参self,name,age。age的必不可少的,位置必须在其他形参的前面。
带有self前缀的变量可供类中所有方法使用
最有定义sit方法,这里只是打印一句话,在游戏中,可以时据以的蹲下动作的代码。
class Dog:
def _init_(self,name,age):
self.name = name
self.age = age
def sit(self):
print(f"{self.name} is sitting.")
my_dog=Dog('smith',6)
print(f"my dog's name is {my_dog.name}")
print(f"my dog's age is {my_dog.age}")
#结果是
my dog's name is smith
my dog's age is 6
#访问属性
my_dog.name
#调用方法
my_dog.sit()
class Dog:
def _init_(self,name,age):
self.name = name
self.age = age
self.size = mid
def read_dog(self):
print(f"my dog size is {self.size}")
my_dog=Dog('smith',6)
my_dog.read_dog()
#结果是
my dog size is mid
直接修改
my_dog.size = small
通过方法修改
class Dog:
----
def change(self,size):
self.size = size
my_dog=Dog('smith',6)
my_dog.change('small')
编写类时,并非都要从空白开始。如果要编写的类是已经存在的类的特殊类,可以使用继承,一个类继承另一个类时,将自动获得另一个类的属性和方法,原有的类为父类,新的类是子类。
在既有类的基础上编写新类时,通常要调用父类的方法_init_()。这将初始化在父类_init_()中定义的所有属性,从而让子类包含这些属性
创建子类时,父类必须包含在当前文件中,且位于子类的前面,定义子类时,必须在()中指定父类的名称。
super()方法是一个特殊的函数,让你能够调用父类的方法
class Dog:
def _init_(self,name,age):
self.name = name
self.age = age
self.size = mid
class Taidi(Dog):
def _init_(self,name,age):
super()._init_(name,age)
my_dog=Taidi('huahua',20)
子类的属性和方法的定义形式与父类定义形式一样
当父类的方法不适用所继承的子类时,可以重新定义该方法,Python将忽略父类的该方法,而使用子类中新的定义。
如果一个类的细节很多,我们可以将其分成许多不同部分的小类
class Move:
def _init_(self,name,age):
def action(self):
print = (f"{name} is {age} years old!")
class Dog:
def _init_(self,name,age):
self.name = name
self.age = age
self.size = mid
self.move = Move() #将动作单独作为一个类
my_dog=Taidi('huahua',20)
Taidi.move.action() #调用单独类中的方法
将类存储在模板中,然后在主程序中导入所需的模板,使得主程序更为简洁
from car import Dog
# 导入一个名叫car的模板中的Car类
一个模板中可以声明多个类
from car import Dog,Car
从模板中导入两个类
import car
也可以直接导入整个模板
from car import *
导入car模板重的所有类
from car import Dog as EC
给Dog类用另一个简易的名称代替
with open('ab.txt') as file1
contents = file1.read()
print(contents)
使用文件,首先都要打开文件,函数open()接受一个参数,要打开的文件名称,返回一个表示文件的对象。有了表示对象后,使用方法read()读取这个文件的内容
上述将简单的文件名传递给open()时,Python将在所执行文件目录中查找。
所以需要使用相对路径来表示文件的位置。
with open('text_files/filesname.txt') as ...
表示在所执行文件目录的子文件夹text.files文件中寻找文本文件,同时也可以使用绝对路径,方法相同,如果绝对路径太长,可以将其赋予给某个变量,将改变量传递给open函数。
with open ('files.txt') as object:
for line in object:
print(line)
执行循环来遍历文件中的每一行,但打印结果可能会出现很多空白行,因为在某些文件中,每行的末尾都有一个看不见的换行符,而函数调用print()也会加上一个换行符,因此每行末尾都有两个换行符,要想消除这些换行符,需要使用rstrip()
with open('fileaname.txt') as object:
lines = object.readlines()
for line in lines:
print(line.rstrip())
上述代码中readlines方法从文件中读取每一行,将其存储在一个列表中。
读取文件时,Python将所有文本都解读为字符串,如果读的是数,就需要使用int()或float()转换为数值
with open('files.txt','w') as object;
object.write("i like python!")
给open函数传入两个实参,一个是要打开的文件名称,另一个是打开的模式——"w"表示写入模式,“a”表示附加模式,“r+”表示读写模式,如果省略模式实参,则默认为只读模式打开,如果要写入的文件不存在,将自动创建它
写入模式:清除已有内容,写入新内容。
附加模式;保存已有内容,后面加上新内容,要注意换行。
做除法运算时,当除数为0时,将报错,可以使用try-except
try:
print(5/0)
except
print("this is error by zero!")
如果try里的代码出现错误,将执行except中的代码,这样可以避免程序崩溃。
try:
answer = print(5/2)
except:
print("this is a error!")
else:
print(answer)
如果没有错误,则执行else中的部分,这个形式用于由用户输入数字时,判断能否执行使用,避免报错。
如果打开一个文件,但该文件不存在,将会报这样的错误,避免此时程序崩溃,可以使用try-except形式。
如果不需要将异常告诉用户,希望程序在发生异常时保持静默:
try:
with open.....
except:
pass
这时如果找不到文件,也不会报错,自动忽略该部分代码
模块json可以将python简单的数据结构转储到文件中。
import json
numbers = [1,2,3,4,5]
with open('numbers.json','w') as f:
json.dump(numbers,f)
上述代码将一个列表写入到一个JSON文件中。
也可以讲json文件中的数据读取出来:
import json
with open('numbers.json') as f:
numbers = json.load(f)
print(numbers)