python基础知识复习随写

#Python注释
#Python使用单引号(')、双引号(")、三引号(""")、#号来表示字符串;\n表示换行;\t表示制表符tab
'''Python标识符规则：1、由字母、数字、下划线组成；2、不能以数字开头；3、不能以关键字作为标识符；4、标识符区分大小写'''

#Python关键字
'''
import keyword
print(keyword.kwlist)'''

#python全局变量：在函数外部创建的变量称为全局变量。全局变量可以被函数内部和外部的每个人使用。例：
'''a="cute"
def myfunc():
    print("HelloKitty is "+a)
myfunc()'''

#python局部变量：在函数内部创建的变量称为局部变量。局部变量只能在函数内部使用，具有相同名称的全局变量将保留原值。例：
'''x="aaa"
def myfunc():
    x="bbb"
    print("this is "+x)
myfunc()
print("this is "+x) #具有相同名称的全局变量将保留原值'''

#global关键字：在函数内部创建一个全局变量，可以使用global关键字，则该变量属于全局范围。例：
'''def myfunc():
    global a
    a=111
myfunc()
print(a+222)

#函数内部更改全局变量的值，可以使用 global 关键字引用该变量
a=1
def myfunc():
    global a
    a=2
myfunc()
print(a)'''

#Python数据类型：数字(number)、字符串(String)、字典(dictionary)、列表(list)、元组(tuple)、集合(set)
#不可变数据：数字(number)、字符串(String)、元组(tuple)、集合(set)；可变数据：字典(dictionary)、列表(list)
#Python数字类型：整型int、浮点型float、复数complex(a+bj或complex(a,b)表示，a为实数，b为虚数)、布尔bool(true和false，0和1，逻辑为真和假)
#类型转换，注：复数无法转换为其他数字类型！！！
'''x=10;y=5.7;z=2+3j
a=float(x) #整型转换为浮点型
b=int(y) #浮点型转换为整型
c=complex(x) #整型转换为复数
print(a,b,c)'''

#随机数：python没有random()函数来创建随机数，但有一个random的内置模块可以用于生成随机数
'''import random
print(random.randrange(11,111)) #生成一个11-111范围内的随机数'''

#python字符串：由单引号或者双引号括起；可以使用三引号将多行字符串赋值给变量，例：
a= """Python is a widely used general-purpose, high level programming language. 
It was initially designed by Guido van Rossum in 1991 
and developed by Python Software Foundation. """
b='''Python is a widely used general-purpose, high level programming language. 
It was initially designed by Guido van Rossum in 1991  '''
#print(a)
#print(b)

#字符串索引和方法
'''
x="hello,world!HowAreYou? "
print(x[1])
print(x[3:6]) #指定开始索引和结束索引，冒号分隔，包头不包尾
print(x[-9:-5]) #从末尾-1开始索引
print(len(x))#获取字符串的长度
print(x)
print(x.strip())#删除开头和结尾的空白字符
print(x.lower())#将字符串输出为小写字母
print(x.upper())#将字符串输出为大写字母
print(x.replace("world","tom"))#替换字符串
print(x.split("e"))#找到分隔符的实例时将字符串拆分为子字符串
print(x.capitalize())#将首字母转换为大写字母
print(x.count("l"))#统计某个字符在字符串中出现的次数
print(x.index("o"))#在字符串中搜索指定的值并返回它被找到的位置'''

#format()方法组合字符串和数字；format() 方法接受传递的参数，格式化它们，并将它们放在占位符 {} 所在的字符串中
'''
age=21
txt="my name is lili,and i am {} "
print(txt.format(age))
print("今天天气不错，可以去{}玩".format("游乐园"))
print('今天没有{}，可以去{}玩'.format('下雨','游乐园'))
print('今天没有{a1}，可以去{a2}玩'.format(a1='下雨',a2='游乐园'))
'''

#检查字符串
'''
s1="abcdefg"
x="h" in s1 #s1中存在h则返回true，不存在返回false
y="l" not in s1 #判断s1中是否没有存在l，是返回true,否返回false
print(x,y)'''

#Python布尔
'''
print(34>21)
x=100;y=200
if x>y:
    print("x值比y大")
else:
    print("x值比y小")'''

#bool()函数评估值：
# 1、除空字符串外，任何字符串均为true；
# 2、除0外，任何数字均为true；
# 3、除空列表外，任何列表、元组、集合和字典均为true
#()、[]、{}、""、0、None、false会被评估为false
"""
print(bool("hello?"))
print(bool(123))
print(bool(0))
print(bool([1,"apple",23]))
print(bool(None))"""

#python逻辑运算符
#and：两个语句均为真，返回true
#or:其中一个语句为真，返回true
#not:真为假，假为真

#列表list：有序且可更改的集合
#遍历列表
'''
list1=["apple","banana","cherry"]
for x in list1:
    print(x)'''
#检查项目是否存在
'''
list1=["apple","banana","cherry"]
if "apple" in list1:
    print("yes")'''
#列表长度
'''
list1=["apple","banana","cherry","strawberry"]
print(len(list1))'''
#追加内容
#1、append()方法
'''
list1=["apple","banana","cherry"]
list1.append("strawberry")
print(list1)'''
#2、insert()方法
'''
list1=["apple","banana","cherry"]
list1.insert(2,"orange")
print(list1)'''
#删除
#1、remove()方法，删除指定项目
'''
list1=["apple","banana","cherry"]
list1.remove("apple")
print(list1)'''
#2、pop()方法，删除指定索引
'''
list1=["apple","banana","cherry"]
list1.pop(1)#不指定索引，默认删除最后一项
print(list1)'''
#3、del关键字，删除指定索引
'''
list1=["apple","banana","cherry"]
del list1[2]
print(list1)'''
'''
list1=["apple","banana","cherry"]
del list1 #删除整个列表'''
#4、clear()方法，清空列表
'''
list1=["apple","banana","cherry"]
list1.clear()
print(list1)'''
#复制列表
#1、引用复制
'''
list1=["apple","banana","cherry"]
list2=list1
#或者list2=list1[:]
print(list2)
list1.append("hello")
print(list2) #因为list2将只是对list1的引用list1中所做的更改也将自动在list2中进行
'''
#2、copy()方法复制
'''
list1=["apple","banana","cherry"]
list2=list1.copy()
print(list2)'''
#3、list()内建的方法复制
'''
list1=["apple","banana","cherry"]
list2=list(list1)
print(list2)'''
#合并列表
#1、使用运算符+合并
'''
list1=[1,2,3,4,5]
list2=["a","b","c","d"]
list3=list1+list2
print(list3)'''
#2、使用append()方法追加合并
'''
list1=[1,2,3,4,5]
list2=["a","b","c","d"]
for x in list2:
    list1.append(x)
print(list1)
'''
#3、使用extend()方法添加合并
'''
list1=[1,2,3,4,5]
list2=["a","b","c","d"]
list1.extend(list2)
print(list1)'''
#list()构造函数
'''
list1=list((1,"abc",45))
print(list1)'''

#元组tuple:有序且不可更改的集合
#访问元组项目
'''
tuple1=("apple","banana","cherry","orange")
print(tuple1[1])
print(tuple1[1:2])
print(tuple1[-3:-1])'''
#更改元组值
#创建元组后，无法更改其值。元组是不可变的，或者也称为恒定的。
#可以将元组转换为列表，更改列表，然后将列表转换回元组
'''
x = ("apple", "banana", "cherry")
y = list(x)
y[1] = "kiwi"
x = tuple(y)
print(x)'''
#遍历元组
'''
tuple1=("apple","banana","cherry","orange")
for x in tuple1:
    print(x)'''
#检查元组中是否存在某项目
'''
tuple1=("apple","banana","cherry","orange")
if "apple" in tuple1:
    print("yes")
else:
    print("no")'''
#元组长度
'''
tuple1=("apple","banana","cherry","orange")
print(len(tuple1))'''
#创建一个元组,必须在该项目后添加一个逗号，否则 Python 无法将变量识别为元组
'''
tuple1=("apple",)
print(tuple1)
thistuple = ("apple")
print(type(thistuple)) #返回类型为字符串str类型'''
#完全删除项目：元组是不可更改的，无法从中删除项目，但可以用del完全删除元组
'''
tuple1=("apple","banana","cherry","orange")
del tuple1'''
#合并元组：运算符+合并
'''
tuple1 = ("a", "b" , "c")
tuple2 = (1, 2, 3)
tuple3=tuple1+tuple2
print(tuple3)'''

#集合set：无序和无索引的集合,不可更改，但可以添加新项目
#创建集合
'''
set1={"apple","banana","cherry","orange"}
print(set1)'''
#访问项目
'''
set1={"apple","banana","cherry","orange"}
for x in set1:
    print(x)'''
#检查集合中是否存在某个项目
'''
set1={"apple","banana","cherry","orange"}
if "cherry" in set1:
    print("yes")'''
#添加项目
#1、使用add()方法添加
'''
set1={"apple","banana","cherry"}
set1.add("orange")
print(set1)'''
#2、使用update()方法添加多个项目
'''
set1={"apple","banana","cherry"}
set1.update(("orange","mango","grapes"))
print(set1)'''
#集合长度
'''
set1={"apple","banana","cherry"}
print(len(set1))'''
#删除项目
#1、remove()方法删除，如果要删除的项目不存在，则remove()将引发错误
'''
set1={"apple","banana","cherry","mango"}
set1.remove("apple")
print(set1)'''
#2、discard()方法删除，如果要删除的项目不存在，则discard()不会引发错误。
'''
set1={"apple","banana","cherry","mango"}
set1.discard("cherry")
print(set1)'''
#3、pop()方法删除最后一项，但集合是无序的，因此在使用pop()方法时，不会知道删除的是哪个项目。
'''
set1={"apple","banana","cherry","mango"}
set1.pop()
print(set1)'''
#4、clear()方法清空集合
'''
set1={"apple","banana","cherry","mango"}
set1.clear()
print(set1)'''
#5、del关键词彻底删除集合
'''
set1={"apple","banana","cherry","mango"}
del set1
print(set1) #会报错，提示set1不存在'''
#合并集合,union()和update()都将排除任何重复项
#1、使用Union()方法
'''
set1={"a","b","c"}
set2={1,2,3}
set3=set1.union(set2)
print(set3)'''
#2、使用update()方法
'''
set1={"a","b","c"}
set2={1,2,3}
set1.update(set2)
print(set1)'''

#字典dict：无序、可变和有索引的集合，有键和值
#创建字典
'''
dict1={"name":"tom","age":"18","hobby":"reading"}
print(dict1)'''
#访问项目
#1、通过键名获取对应值
'''
dict1={"name":"tom","age":"18","hobby":"reading"}
x=dict1["age"]
print(x)'''
#2、get()方法获取
'''
dict1={"name":"tom","age":"18","hobby":"reading"}
x=dict1.get("name")
print(x)'''
#3、values()获取值
'''
dict1={"name":"tom","age":"18","hobby":"reading"}
print(dict1.values())'''
#4、keys()获取键名
'''
dict1={"name":"tom","age":"18","hobby":"reading"}
print(dict1.keys())'''
#更改值
'''
dict1={"name":"tom","age":"18","hobby":"reading"}
dict1["age"]=20
print(dict1)'''
#遍历字典
#1、for循环遍历
'''
dict1={"name":"tom","age":"18","hobby":"reading"}
for x in dict1:
    print(x)#返回字典中所有键名
    print(dict1[x])#返回字典中所有值'''
#2、values()遍历
'''
dict1={"name":"tom","age":"18","hobby":"reading"}
for x in dict1.values():
    print(x) #返回字典中所有值
for y in dict1.keys():
    print(y)#返回字典中所有键名'''
#3、items()遍历键和值
'''
dict1={"name":"tom","age":"18","hobby":"reading"}
for x,y in dict1.items():
    print(x,y)'''
#检查键是否存在
'''
dict1={"name":"tom","age":"18","hobby":"reading"}
if "name" in dict1.keys():
    print("yes")
else:
    print("no")'''
#字典长度
'''
dict1={"name":"tom","age":"18","hobby":"reading"}
print(len(dict1))'''
#添加新项目
'''
dict1={"name":"tom","age":"18","hobby":"reading"}
dict1["sex"]="boy"
print(dict1)'''
#删除项目
#1、pop()方法删除
'''
dict1={"name":"tom","age":"18","hobby":"reading"}
dict1.pop("age")
print(dict1)'''
#2、popitem()方法删除最后插入的项目
'''
dict1={"name":"tom","age":"18","hobby":"reading"}
dict1.popitem()
print(dict1)'''
#3、del关键字删除
'''
dict1={"name":"tom","age":"18","hobby":"reading"}
del dict1["name"] #删除指定键名的项目
print(dict1)
del dict1 #删除整个字典'''
#4、clear()清空字典
'''
dict1={"name":"tom","age":"18","hobby":"reading"}
dict1.clear()
print(dict1)'''
#复制字典
#1、引用复制
'''
dict1={"name":"tom","age":"18","hobby":"reading"}
dict2=dict1
print(dict2)
dict1["name"]="kali" #dict2只是对dict1的引用，dict1中的更改也将自动在dict2中进行
print(dict2)'''
#2、copy()方法复制
'''
dict1={"name":"tom","age":"18","hobby":"reading"}
dict2=dict1.copy()
print(dict2)'''
#3、dict()内建方法复制
'''
dict1={"name":"tom","age":"18","hobby":"reading"}
dict2=dict(dict1)
print(dict2)'''
#嵌套字典
'''
dict={"dict1":{"name":"a1","age":11},"dict2":{"name":"a2","age":12},"dict3":{"name":"a3","age":13}}
print(dict)'''
#dict()构造函数
'''
dict1=dict(name="tom",age=18)
print(dict1)'''

#python条件语句
#if、elif、else
'''
a=11;b=22
if a>b:
    print("a最大")
elif a==b:
    print("一样大")
else:
    print("b最大")'''
#简写if...else语句
'''
a=11;b=22
print("a最大") if a>b else print("b最大")
print("a最大") if a>b else print("一样大") if a==b else print("b最大")'''
#pass语句
# if语句不能为空，但是如果您处于某种原因写了无内容的if语句，可以使用pass语句来避免错误
'''
a = 66
b = 200
if b > a:
  pass'''

#python循环语句
#while循环,条件为真，执行语句
'''
i=0
while i<7:
    i+=1
    print(i)'''
#break语句：停止循环
'''
i=1
while i<7:
    print(i)
    if i==3:
        break
    i += 1'''
#continue语句:停止当前的迭代，并继续下一个
'''
i=0
while i<7:
    i += 1
    if i==3:
        continue
    print(i)'''
#for循环:不需要预先设置索引变量
#range()函数 可添加第3个参数指定增量值
'''
for x in range(0,12,2):
    print(x)'''
#else关键字:指定循环结束时要执行的代码块
'''
for x in range(1,8):
    print(x)
else:
    print("for循环结束了")'''
#嵌套循环：“外循环”每迭代一次，“内循环”将执行一次
'''
adj=["red","big","tasty"]
fruits=["apple","banana","cherry"]
for x in adj:
    for y in fruits:
     print(x,y)'''

#python函数，def关键字定义函数
'''
def dom(): #定义函数
    print("hello world")
dom() #调用函数'''
#参数，多个参数用逗号分隔
'''
def dom(name,age):
    print("我叫"+name,age)
dom("小红",12)'''
#默认参数
'''
def demo(x="china"):
    print("i am from "+x)
demo("india")
demo()'''
#list传参：函数的参数可以是任何数据类型（字符串、数字、列表、字典等），并且在函数内其将被视为相同数据类型
#将 List 作为参数发送，它到达函数时仍将是 List
'''
def demo(food):
    for x in food:
        print(x)
fruits=["apple","banana","cherry"]
demo(fruits)'''
#return语句返回值
'''
def demo(x):
    return x*2
print(demo(3))'''
#关键字参数
'''
def demo(a1,a2,a3):
    print("this is "+a2)
demo(a1="apple",a2="banana",a3="cherry")'''
#任意参数:如果不知道将传递给您的函数多少个参数，可以在函数定义的参数名称前添加 *
#这样，函数将接收一个参数元组，并可以相应地访问各项
'''
def demo(*fruits):
    print("this is "+fruits[1])
demo("apple","banana","cherry","orange")'''
#pass语句
'''
def demo():
    pass'''
#递归
'''
def demo(x):
    if(x>0):
        sum=x+demo(x-1)
        print(sum)
    else:
        sum=0
    return sum
demo(4)'''

#Python lambda函数：lambda 函数可接受任意数量的参数，但只能有一个表达式
'''
def demo(x):
    return lambda a:a*x
sum=demo(3)
print(sum(2))'''
'''
sum=lambda a,b:a+b
print(sum(2,3))'''

#python类和对象
#对象有属性和方法
'''
class Fruits: #创建类
    a="apple"
food1=Fruits() #创建对象food1
print(food1.a)'''
#_init_()函数：_init_() 函数将值赋给对象属性，或者在创建对象时需要执行的其他操作
#所有类都有一个名为 _init_() 的函数，它始终在启动类时执行
'''
class Person:
    def __init__(self,name,age):
        self.name=name
        self.age=age
person1=Person("小红",12)
print(person1.name,person1.age)'''
#对象方法  self 参数是对类的当前实例的引用，用于访问属于该类的变量
'''
class Person:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def demo(self):
        print("my name is "+self.name)
p1=Person("tom",21)
p1.demo()'''
#self参数：对类的当前实例的引用，用于访问属于该类的变量
#不必被命名为 self，可以随意调用它，但它必须是类中任意函数的首个参数
'''
class Person:
    def __init__(object1,name,age):
        object1.name=name
        object1.age=age
    def demo(abb):
        print("my name is "+abb.name,abb.age)
p1=Person("tom",22)
p1.age=33 #修改对象属性
del p1.age #删除对象的age属性
del p1 #删除对象
p1.demo()'''
#pass语句
'''
class Person:
    pass'''

#python继承:父类子类
'''
class Person: #创建父类
    def __init__(self,fname,lname):
        self.firstname=fname
        self.lastname=lname
    def demo(self):
        print(self.firstname,self.lastname)
p1=Person("bill","gates")
p1.demo()
class Student(Person): #创建子类
    pass
p2=Student("elon","musk")
p2.demo()'''
#添加_init_()函数
#添加_init_()函数时，子类将不再继承父的_init_()函数
#子的_init_()函数会覆盖对父的_init_()函数的继承
#如果需要保持父的_init_()函数的继承，需要添加对父的_init_()函数的调用
'''
class Person:
    def __init__(self,fname,lname):
        self.firstname=fname
        self.lastname=lname
    def demo(self):
        print(self.firstname,self.lastname)
class Student(Person):
    def __init__(self,fname,lname):
        Person.__init__(self,fname,lname)
x=Student("elon","musk")
x.demo()'''
#super()函数:使子类从其父继承所有方法和属性
#super()函数不必使用父元素的名称，它将自动从其父元素继承方法和属性
'''
class Person:
    def __init__(self,fname,lname):
        self.firstname=fname
        self.lastname=lname
    def demo(self):
        print(self.firstname,self.lastname)
class Student(Person):
    def __init__(self,fname,lname):
        super().__init__(fname,lname)
p1=Student("elon","musk")
p1.demo()'''
#添加属性
'''
class Person:
    def __init__(self,fname,lname):
        self.firstname=fname
        self.lastname=lname
    def demo(self):
        print(self.firstname,self.lastname)
class Student(Person):
    def __init__(self,fname,lname,year):
        super().__init__(fname,lname)
        self.bothyears=year #添加year属性
p1=Student("elon","musk",2019)
p1.demo()
print(p1.bothyears)'''
#添加方法
#子类中添加一个与父类中的函数同名的方法，则将覆盖父方法的继承
'''
class Person:
    def __init__(self,fname,lname):
        self.firstname=fname
        self.lastname=lname
    def demo(self):
        print(self.firstname,self.lastname)
class Student(Person):
    def __init__(self,fname,lname,year):
        super().__init__(fname,lname)
        self.bothyear=year
    def welcome(self):
        print(self.firstname,self.lastname,self.bothyear,"hello world")
p1=Student("elon","musk",2020)
p1.welcome() #调用方法'''

#Python迭代器
#迭代器是实现迭代器协议的对象，包含方法__iter__()和__next__()
#创建一个返回数字的迭代器，从 1 开始，每个序列将增加 1（返回 1、2、3、4、5 等）
'''
class Numbers:
    def __iter__(self):
        self.a=1
        return self
    def __next__(self):
        x=self.a
        self.a+=1
        return x
p1=Numbers()
p2=iter(p1)
print(next(p2))
print(next(p2))
print(next(p2))
print(next(p2))'''
#StopIteration:防止迭代永远进行
#__next__()方法中，如果迭代完成指定的次数，我们可以添加一个终止条件来引发错误
'''
class Numbers():
    def __iter__(self):
        self.a=1
        return self
    def __next__(self):
        if self.a<=5:
          x=self.a
          self.a+=1
          return x
        else:
            raise StopIteration
p1=Numbers()
p2=iter(p1)
for n in p2:
    print(n)'''


#python作用域
#变量仅在创建区域内可用，称为作用域
#1.局部作用域：函数内部创建的变量属于该函数的局部作用域，只能在函数内部使用
'''
def demo():
    x=100
    def demo1():
        print(x+1)
    demo1()
demo()'''
#2.全局作用域:函数外部创建的变量是全局变量，属于全局作用域，在任何范围中可用
'''
x=100
def demo():
    print(x+1)
demo()
print(x+2)'''
#3.命名变量：函数外部和内部操作同名变量，Python会视为两个单独的变量，一个在全局范围可用，一个局部范围可用
'''
x=100
def demo():
    x=200
    print(x)
demo()
print(x)'''
#4.global关键字:可以使变量成为全局变量,或者在函数内部改全局变量时可用
'''
y=200
def demo():
    global x,y
    x=100
    y=300
demo()
print(x,y)'''


#python模块：模块是包含一组函数的文件，希望在应用程序中引用
#创建模块：将代码保存在文件扩展名为.py的文件中
'''
def demo(name):
    print("hello,"+name) #保存为name1.py的文件'''
#使用模块：使用import语句引用
'''
import name1
name1.demo("tom")'''
#使用模块中的变量
'''
person1={"name":"tom","age":23,"contry":"china"}
fruits=["apple","banana","cherry"] #保存为name1.py文件'''
'''
import name1
x=name1.person1["age"]
y=name1.fruits[2]
print(x,y)'''
#重命名模块
'''
import name1 as nm
a=nm.fruits[2]
print(a)'''
#内建模块：Python中会自带几个内建模块，可以随时导入
'''
import platform #返回系统类型
x=platform.system()
print(x)'''
#dir()函数：列出模块中所有函数名或者变量名，也可以用于自创的模块
'''
import name1
x=dir(name1)
print(x)'''
#使用from关键字从模块中导入函数或者变量
'''
from name1 import person1
print(person1["age"])'''


#python日期
#导入datetime模块显示当前日期
"""
%a：返回缩写版的weekday，例：wed
%A：返回完整版的weekday，例：wednesday
%w：返回数字版的weekday，0-6,0表示周日
%d：返回数字版的日，01-31
%b：返回缩写版的月，例：Dec
%B：返回完整版的月，例：December
%m：返回数字版的月份，01-12
%y：返回缩写版的年，例：23
%Y：返回完整版的年份，例：2023
%H：返回24时制的小时，00-23
%I：返回12时制的小时，00-12
%p：上午/下午，AM/PM
%M：返回分，00-59
%S：返回秒，00-59
%f：返回微秒，000000-999999
%Z：返回时区
%j：返回天数，001-366
%U：返回周数，每周第一天是周日，00-53
%W：返回周数，每周第一天是周一，00-53
%c：返回日期和时间的本地版本，例：Wed Mar 29 11:13:06 2023
%x：返回本地版本的日期，例：03/29/23(表示：2023年3月29日)
%X：返回本地版本的时间，例：11:14:30
"""
'''
import datetime
x=datetime.datetime.now()
print(x) #返回年、月、日、时、分、秒、微妙
print(x.year)#返回年份
print(x.month)#返回月份'''
#strftime()方法:把日期对象格式化为可读字符串
'''
import datetime
x=datetime.datetime(2023,3,29)
print(x.strftime("%A"))#返回星期'''


#python JSON:用于存储和交换数据的语法，使用json函数需要导入json库:import json
#json.loads()方法：解析json-把JSON字符串转换为Python对象
'''
import json
data='{"a1":1,"a2":2,"a3":3,"a4":4}'
x=json.loads(data)
print(x)'''
#json.dumps()方法：将Python对象转换成JSON字符串
'''
import json
data={
  "name": "Bill",
  "age": 63,
  "married": True,
  "divorced": False,
  "children": ("Jennifer","Rory","Phoebe"),
  "pets": None,
  "cars": [
    {"model": "Porsche", "mpg": 38.2},
    {"model": "BMW M5", "mpg": 26.9}
  ]
}
x=json.dumps(data)
print(x)
#格式化结果
#1、indent参数定义缩进数
print(json.dumps(data,indent=4))
#2、separators参数更改默认分隔符（默认分隔符为 , 和 : ）
print(json.dumps(data,indent=4,separators=(".","=")))
#3、sort_keys参数对结果中的键进行排序
print(json.dumps(data,indent=4,sort_keys=True))
'''

#python RegEx:需要导入re库，用于处理正则表达式
#1、re.search()：搜索整个字符串中的匹配项，并返回第一个成功匹配值；未找到匹配，则返回值None
#2、span(),返回匹配值的起始位置
#3、start(),返回匹配值的开始位置
'''
import re #导入re模块
str="China is a great country"
x=re.search("i",str).span()
y=re.search("i",str).start()
print(x)
print(y)
#4、re.match()：只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，返回None
#5、group()返回匹配的字符串部分
z=re.match("i",str)
m=re.match("China",str).span()
n=re.match("China",str).group()
print(z) #返回None
print(m)#返回(0, 5)
print(n)#返回China
#6、re.findall():返回包含所有匹配项的列表，未找到匹配项，则返回空列表
a=re.findall("a",str)
b=re.findall("x",str)
print(a)#返回['a', 'a', 'a']
print(b)#返回[]
#6、re.split():返回用匹配的子串将字符串分割后的列表，可以加第3个参数控制出现次数
c=re.split("i",str)
d=re.split("i",str,1)
print(c)#返回['Ch', 'na ', 's a great country']
print(d)#返回['Ch', 'na is a great country']
#7、re.sub()：替换匹配值，可以加第3个参数控制替换次数
e=re.sub("i","X",str)
f=re.sub("i","X",str,1)
print(e)#返回 ChXna Xs a great country
print(f)#返回 ChXna is a great country'''


#Python Try Except
#try:有异常的时候不要停止工作，要继续工作同时把异常情况输出来
#当Python脚本发生异常或错误时，通常会终止执行并生成错误消息，可以使用try语句处理这些异常
#try/except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理。
#异常处理
'''
try:
    print(x) #因为x没有定义，try块引发错误，会执行except块；如果没有try..except块，该语句会引发Python错误
except:
    print("有异常情况")'''
#多个异常：可以定义多个except块
#如果try块引发 NameError，则打印一条消息，如果是其他错误则打印另一条消息
'''
try:
    print(x)
except NameError:
    print("x没有定义异常")
except:
    print("其他异常错误")'''
#else：没有异常错误，使用else定义要执行的代码块
'''
try:
    print("hello")
except:
    print("有异常情况")
else:
    print("无异常情况")'''
#finally:无论try块是否异常，都会执行finally块
'''
try:
    print(x)
except:
    print("这是一个x未定义的异常情况")
finally:
    print("最后都有执行的语句")'''
#打开文件模拟
'''
try:
    f=open("aa.txt")
    f.write("这是try练习")
except:
    print("有异常情况出现")
finally:
    f.close()'''
#raise关键字引发异常
'''
x=3
if x<1:
    raise Exception("sorry,x值不小于1")#触发异常后，后面的代码就不会再执行
'''


#python文件处理
#1、open()函数
'''
打开方式：
r：读取，默认，如果文件不存在则报错
a:追加文件，如果不存在则创建该文件
w：写入内容，如果不存在则创建该文件
x：创建文件，如果文件存在则返回错误
文件模式：
t：文本，默认
b：二进制
'''
f=open("aa.txt","w+")
print(f)