python基础-超详细-基本涵盖所有基础知识点

本文链接：https://blog.csdn.net/2301_80044751/article/details/143118214

python

1.重要的小细节

a.使用#注释的时候要空一格，保证代码的规范性

b.单行注释使用#，多行注释使用""" 三队 """

c.标识符不能用数字开头，会出错，同时大小写也可以区分不同的标识符

d. \t 相当于tab键

e.在写函数的时候，如果没有提示的话，就意味着该函数不在这个库里代表着出错

2.基础知识点

1.运算符与type

a. 查看数据类型使用type语句，同时可以用变量来存储变量的类型

b.类型装换，将浮点数转成整数会掉精度

c.七个运算符及复合赋值运算符；除法得到的结果是浮点型，保证精度

d.三引号定义；使用变量接收，就成了定义，如果不用变量接受，就成了多行注释

2.字符串

a.如果想要字符串内包含双引号，可以再单引号内包含双引号，反之可包含双引号；还可以使用转义字符来把引号的效用效果取消

c.函数如果没有加return，也会返回None

d.在定义函数之后可以解释函数参数的作用，使用""" """三对引号

e.在函数内部修改全局变量

f.在定义其他函数的时候，想要引用其他函数，可以通过加入参数来影响函数的执行结果

h. return的返回;可无限返回input

f.清空列表，统计列表，统计列表中元素的全部数量

g.元组定义：

h.序列

i.集合：{元素, 元素, }去重，顺序改变

c.匿名函数使用lambda关键字进行定义

1.重要的小细节

a.使用#注释的时候要空一格，保证代码的规范性

b.单行注释使用#，多行注释使用""" 三队 """

c.标识符不能用数字开头，会出错，同时大小写也可以区分不同的标识符

d. \t 相当于tab键

 print("hello\tworld")
 print ("查询余额\t[1]")
 print ("查询\t\t[1]")
 print ("查余额\t[1]")
 # 当相差的数字距离很远的时候可以选择多加一个/t来保证对齐

e.在写函数的时候，如果没有提示的话，就意味着该函数不在这个库里代表着出错

#### f. 输出方式

 """
 b:输出整数的二进制方式
 c:输出整数对应的 Unicode 字符,
 d:输出整数的十进制方式。
 o:输出整数的八进制方式
 x:输出整数的小写十六进制方式
 X:输出整数的大写十六进制方式
 """
 s = "asweqweqeq"
 d = "sdasdas"
 
 print("'{1:30}{0:^30}'".format(s, d))  # 0,1是参数的位置
 print("{0:o}{0:X}".format(123))#支持多种类型
 print("{:>15s}:{:<8.2f}".format("length", 23.12431))
 print("{0:*^40}".format(1))
 """
 e:输出浮点数对应的小写字母e的指数形式
 E:输出浮点数对应的大写字母E的指数形式
 f:输出浮点数的标准浮点形式。
 %:输出浮点数的百分形式。
 浮点数输出时尽量使用<.精度>表示小数部分的宽度，有助于更好控制输出格式
 """
 print("{0:.2e},{0:.2E},{0:.2f},{0:.2%}".format(3.14))

2.基础知识点

1.运算符与type

a. 查看数据类型使用type语句，同时可以用变量来存储变量的类型

 name = "黑马程序员"
 name_type = type(name) # 查看变量的类型
 print(name_type)

b.类型装换，将浮点数转成整数会掉精度

 num_str = str(11)
 print(type(num_str),num_str)
 
 float_str = str(11.345)
 print(type(float_str),float_str)

c.七个运算符及复合赋值运算符；除法得到的结果是浮点型，保证精度

d.三引号定义；使用变量接收，就成了定义，如果不用变量接受，就成了多行注释

 name = """你好
 ，我很好
 """

2.字符串

a.如果想要字符串内包含双引号，可以再单引号内包含双引号，反之可包含双引号；还可以使用转义字符来把引号的效用效果取消

 name = "\" 小王八蛋 "#可输出一个单引号

b.字符串的拼接

 name = "宇璠"
 address = "燕山"
 num_1 = 100
 print("xxx"+name+"xxx"+address)
 # 简单的拼接，但是这个只可以字符串的拼接
 message = "Python大数据学科，%s,你好%s" % (class_num, num_1)
 print(message)
 # 也可以使用%d，%f来占位，这样不改变数据类型
 # %5.2f,表示将宽度控制为5，将小数点精度控制在两位小数
 """
 还可以使用f{}来快速格式化
 """
 print(f"我是{name},我成长于：{address},我的是：{num_1}")
 
 #输出不换行！
 print("hello", end = '')
 print("world") # 使用一个接一行

c.字符串格式化表达式

 print("1 * 1的结果是：%d" % (1 * 1))
 print(f"1 * 1的结果是：{1 * 1}")
 print("字符串在python的中类型是：%s" % type('字符串'))
 for x in range(1, 10):
     for j in range(1, x+1):
         print(f"%d * %d = {x * j}\t" % (j, x), end='')
     print()
 #九九乘法表

d.字符串的替代,分割，查找，指定输出

 my_str = "ni hao wo shi xiao shu"
 # 输出倒数的第十个元素
 value_2 = my_str[::-1][1: 2] # 倒序输出第二个字符
 # index方法
 value =my_str.index("wo")
 print(f"在字符串{my_str}中查找and，其起始下标是:{value}")
 # replace方法
 new_my_str = my_str,replace("wo"，"程序")
 print(f"将字符串{my_str}，进行替换后得到:{new_my_str}")

e.字符串的分割

 # 语法:字符串.split(分隔符字符串)
 # 功能:按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中注意:字符串本身不变，而是得到了一个列表对象
 my_str = "hello python itheima itcast"
 my_str_list = my_str.split(" ")
 print(f"将字符串{my_str}进行split切分后得到：{my_str_list},类型是:{type(my_str_list)}")

f.字符串的规整操作

g.总结字符串函数的使用

#作为数据容器，字符串有如下特点
"""
只可以存储字符串
长度任意(取决于内存大小)
支持下表索引
允许重复字符串存在
不可以修改(增加或删除元素)
支持for循环，遍历取出字符串
"""

h. format的使用

3.布尔类型 True or False

a.布尔类型的简单说明

 result = "itcast" == "itheima"
 print(f"字符串itcast是否和itheima相等，结果是：{result}，类型是：{type(result)}")
 # 定义布尔类型
 bool_1 = True
 bool_2 = False
 print(f"bool_1变量的内容是：{bool_1},类型是：{type(bool_1)}")
 
 # 可以在print语句中使用{}直接格式化表达式， {num1 == num2},会返回True 或者 Flase

b.六类运算符

4.判断语句

a.使用if的时候要记得缩进和冒号

 age = int(input("请输入你的年龄："))
 if age > 19 :  # 冒号
     # 缩进
 elif age < 10 :
     print("小王八别打人")
 else :
     print("小王八")
 # 自上而下运行，一定只有一个被执行
 if int(input("请输入你的年龄：")) > 19 :  # 冒号
     # 缩进
 # 这样写就不用一直输入多个数，而是一个一个判断
 import random  # 随机取数
 num = random.randint(1,10)
 print(num)

5.循环语句

a. while循环

i = 0
while i < 100 :
    print("小王八")
    i += 1
#循环一百次

b. for循环

# for循环处理字符串
for x in name :
    print(name) # 可以逐步打印出字符串
# range的基本用法
"""
range(0,10,2)前面两个是范围，后面一个是步长；
范围是左闭右开
默认从0开始range(10);步长为 1
千万别忘记打冒号！
"""
for x in range(0,10,1) ：
	print(x)

6.函数的使用

a.函数的使用需要调用

def say_hi() :
    print("你好")
say_hi()

b.函数的返回值可以通过变量去接收

def add_up(a,b) :
    result = a + b
    return result
r = add(5,6)
print(r)

c.函数如果没有加return，也会返回None

 def xiaowangba() :
     print("xiaowangba")
     return None
 #在if判断中，None表示False的意思
 def check_age(age):
     if age > 18 :
         return "SUCCESS"
     else :
         return None
 result = check_age(16)
 if not result:
     print("未成年，不可以进入")
 else is result:
     print(f"您是成年人，可以自由玩游戏！{result}{check_age(18)}")

d.在定义函数之后可以解释函数参数的作用，使用""" """三对引号

 def add_up(age,weight):
     """
     函数说明
     ：param age.....
     : parem weight...
     : return: ...
     
     """
     print("nihao")
     return None

e.在函数内部修改全局变量

num = 500
def text():
    global num  # 设置内部定义的变量为全局变量
    num = 100
    print(f"{num}")
# 记得定义函数之后要记得执行

f.在定义其他函数的时候，想要引用其他函数，可以通过加入参数来影响函数的执行结果

def text(shou_header):
    if shou_header :
        print("------xiao---------")
    print("xxx")
def guess():
    print("xxx")
    text(False)
    #这样可以选择性的使用text函数的内容

h. return的返回;可无限返回input

def text():
    if input("请输入数字:") == 1:
        return input("请输入数字哦:")
while True :
    text()

7.数据容器入门

a.列表可以一次存储多个数据，且都可以为不同的数据类型，支持嵌套

 my_list = ["itheima","itcast","python"]
 print(my_list) # 会将所有的内容打印出来
 list_1 = [[1,2,3],[2,3,4]，"你好"] # 可以嵌套使用
 print(type(my_list)) # 打印类型
 print(my_list[0])
 """
 第一个元素是0，从后向前也可以，最后一个是-1，以此类推
 双层嵌套
 使用下标索引的时候不要超出范围
 """
 print(list_1[0][2])  # 将会是3

b.查找索引

 my_list = ["iao",2,4,67]
 index = mylist.index("67")
 print(f"67在列表中的下标位置是{index}")

c.修改列表

 my_list = ["iao",2,4,67]
 my_list[1] = 6
 print(my_list)  # 列表的内容发生改变
 # 反向下标 
 check_num =  my_list[-2]   # 4

d.插入数据,追加数据

 my_list = [2,4,67]
 my_list.insert(1,"best")
 my_list.insert(2,2)
 my_list.append("nihao")
 print(f"列表在追加了元素后，结果是：{my_list}")
 #添加一批元素
 list_2 = [1,2,4,7]
 list_2.extend([4,3,2]) 
 print(list_2)

e.删除下标

 mylist = [1,2,45,6]
 del mylist[2]
 print(f"列表删除元素之后的结果是：{mylist}")
 ###
 mylist.pop(2)
 element = mylist.pop(1)  # 可以使用变量来接收删除的元素
 print(mylist)
 """
 通过查找内容来删除元素
 """
 list_3 = [56,7,1,5,3,2,1,5,"sdas"]
 list_3.remove(1)
 #一次只能去除一个值
 list_3.remove("sdas")
 print(list_3)

f.清空列表，统计列表，统计列表中元素的全部数量

 # 清空列表
 list_4 = [2,5,7,3,7,4]
 list_4.clear()
 print(list_4)
 # 统计列表
 count = list_4.count(7)
 print(count)
 # 统计列表中元素的全部数量
 print(len(list_4))
 receive = len(list_4)
 print(receive)

g.元组定义：

定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型

 #定义空元组
 #定义元组
 t1=(1,"Hello", True)
 变量名称 = () # 方式1
 变量名称 = tuple() # 方式2
 # ！# 定义单个元素时要在后面加上“,”号
 t = ("hello",)
 #根据下标(索引)取出数据
 t1=(1,2,'hello')
 print(t1[2]) #结果:"he11o
 # 根据indexO)，查找特定元素的第一个匹配项
 t1=(1,2,'hello',3,4,'hello')
 
 print(t1.index('hello'))  # 结果:2
 # 统计某个数据在元组内出现的次数
 t1=(1,2,'hello',3,4,'hello')
 print(t1.count('hello'))  # 结果:2
 # 统计元组内的元素个数
 t1=(1,2,3)
 print(len(t1))  # 结果 3

h.序列

 # 对list进行切片，从1开始，4结束，步长1
 my_list = [0,1,2,3,4,5,6]
 result1 = my_list[1:4]      # 步长默认是一，可以省略
 print(f"结果1：{result1}，类型是{type(result1)}")
 print(f"{result1[2]}")
 
 # 对tuple 进行切片，从头开始，到最后结束，步长1
 my_tuple = (0,1,2,3,4,5,6)
 result2 = my_tuple[:]
 # 起始和结束不写表示从头到尾，步长为一可以省略
 print(f"结果2：{result2}")
 
 # 对str进行切片，从头开始，到最后结束，
 my_str = "1234567"
 result3 = my_str[::2]
 print(f"结果3：{result3}")
 
 #对str进行切片，从头开始，到最后结束，步长-1
 my_str = "1234567"
 result4 = my_str[::-1]
     #将序列反转
 print(f"结果4：{result4}")
 
 #可以注意我们对于不同的类型有不同的处理方法
 #省略的东西不同；序列反转是一个很好的东西

i.集合：{元素, 元素, }去重，顺序改变

 my_set_empyt = set()  # 定义空集合
 my_set = {'as',"sdasd"}
 print(f"my_set的内容是：{my_set},类型是：{type(my_set)}")
 # 添加新元素
 my_set.add("Python")
 print(my_set)
 # 移除元素
 my_set.remove("as")
 print(f"移除后的结果是：{my_set}")
 # 随机去除一个元素，集合内容发生改变
 element = my_set.pop()
 print(f"集合被取出元素是：{element},取出元素后：{my_set}")
 # 清空集合
 my_set.clear()
 print(f"集合被清空，结果是：{my_set}")
 
 #取两个集合的差集
 set1 = {1,2,3}
 set2 = {1,4,6}
 set3 = set1.difference(set2)
 print(f"set1的结果是：{set1}")
 print(f"set2的结果是：{set2}")
 print(f"set3的结果是：{set3}")
 
 #消除两个集合的差集
 #对比集合1和集合2，在集合1内，删除和集合2相同的元素
 #结果：集合1被修改，集合2不变
 set4 = {23,24,14,235,52}
 set5 = {23,235,4,1,41,13,4}
 set4.difference_update(set5)
 print(f"set4的结果是：{set4}")
 print(f"set5的结果是：{set5}")
 
 #将集合合并，将集合1和集合2组成新集合
 setx1 = {1,2,45}
 setx2 = {1,3,5,23}
 setx3 = setx1.union(setx2)
 print(f"集合setx1和集合setx2合并的结果是：{setx3}")
 
 #统计元素数量
 number = len(setx2)
 print(number)
 
 #集合的遍历，不能用while循环
 set6 = {123,35,12,3123,21,3}
 for element in set6:
     print(f"集合的元素有：{element},类型是：{type(element)}")

j.字典

 # 定义字典
 my_dict1 = {"小王八":99,"炸裂":98,"钉钉":98}
 
 # 定义空字典
 my_dict2 = {}
 my_dict3 = dict()
 print(f"字典1的内容是：{my_dict2},类型：{type(my_dict2)}")
 print(f"字典1的内容是：{my_dict3},类型：{type(my_dict3)}")
 
 # 不能重复，新的会把老的覆盖
 score = my_dict1["小王八"]
 print(f"小王八的考试分数是：{score}")
 
 # 字典的嵌套
 stu_score_dict = {
     "小王八":{
         "语文":99,
         "数学":100,
         "英语":100,
     },#不要忘记这还有一个符号
     "小明" :{
         "语文":99,
         "数学":100,
         "英语":100,
     }
 }
 print(f"小王八的成绩是：{stu_score_dict["小王八"]}")
 print(f"小王八的语文成绩是：{stu_score_dict["小王八"]["语文"]}")

k.字典的常用操作

 # 字典的常用操作
 my_dict1 = {"小王八":99,"炸裂":98,"钉钉":98}
 # 新增元素
 my_dict1["张信哲"] = 66
 print(f"字典经过新增元素后，结果是：{my_dict1}")
 
 # 更新元素
 my_dict1["小王八"] = 100
 print(f"字典经过更新后，结果是：{my_dict1}")
 
 #删除元素
 score = my_dict1.pop("张信哲")
 print(f"字典中被移除了一个元素，结果：{my_dict1},张信哲的考试分数是：{score}")
 
 #清空元素
 my_dict1.clear()
 print(f"字典被清空了，内容是：{my_dict1}")
 
 my_dict1 = {"小王八":99,"炸裂":98,"钉钉":98}
 keys = my_dict1.keys()
 print(f"字典的全部keys是：{keys}")
 
 #字典的遍历
 for key in keys :  #可以换成my_dict1
     print(f"字典的key是：{key}")
     print(f"字典的value是：{my_dict1[key]}")
 
 #字典元素数量，用len（字典）

l. max与min，类型转换

 print(f"比较大小：{'be' > 'c'}")
 my_str = "asdad "
 my_str = max(my_str)
 print(f"my_str的排序之后的结果是:{my_str}")
 my_str = list(my_str)
 print(f"将my_str转换成元组类型:{my_str},类型是：{type(my_str)}")
 ###################
 my_list =[1,2,3,4,5]
 my_tuple =(1,2,3,4,5)
 my_str = "abcdefg"
 my_set ={1,2,3,4,5}
 my_dict ={"key1":1,"key2":2,"key3":3,"key4":4,"key5": 5}
 #len元素个数
 print(f"列表 元素个数有:{len(my_list)}")
 print(f"元组 元素个数有:{len(my_tuple)}")
 print(f"字符串元素个数有:{len(my_str)}")
 print(f"集合 元素个数有:{len(my_set)}")
 print(f"字典 元素个数有:{len(my_dict)}")
 #max最大元素
 print(f"列表 最大的元素是:{max(my_list)}")
 print(f"元组 最大的元素是:{max(my_tuple)}")
 print(f"字符串最大的元素是:{max(my_str)}")
 print(f"集合 最大的元素是:{max(my_set)}")
 print(f"字典 最大的元素是:{max(my_dict)}")
 #min最小元素
 print(f"列表 最小的元素是:{min(my_list)}")
 print(f"元组 最小的元素是:{min(my_tuple)}")
 print(f"字符串最小的元素是:{min(my_str)}")
 print(f"集合 最小的元素是:{min(my_set)}")
 print(f"字典 最小的元素是:{min(my_dict)}")
 #类型转换:容器转列表
 print(f"列表转列表的结果是:{list(my_list)}")
 print(f"元组转列表的结果是:{list(my_tuple)}")
 print(f"字符串转列表结果是:{list(my_str)}")
 print(f"集合转列表的结果是:{list(my_set)}")
 print(f"字典转列表的结果是:{list(my_dict)}")
 #其他的类型也是这样转，但是不可以转成字典，因为不符合字典的书写规范

m.总结

3.函数的进阶使用

a.接收函数的多返回值

 # 接收函数的多返回值
 def text_return():
     return 1, "hello", True
 
 
 x, y, z = text_return()
 print(x)
 print(y)
 print(z)
 # 位置参数
 
 
 def user_info(name, age, gender):
     print(f"你的名字是{name}，年龄是{age}，性别是{gender}")
 
 
 user_info("TOM", 19, "男")

b.函数作为参数传递

 # 函数的传入
 def text_func(compute):
     result = compute(3, 2)  # 确定compute是函数
     print(f"compute参数类型是：{type(compute)}")
     print(f"计算结果是：{result}")
 
 
 def compute(x, y):
     return x + y
 # 调用，并传入函数
 
 
 text_func(compute)

c.匿名函数使用lambda关键字进行定义

 """
 注意事项：
 匿名函数用于临时构建一个函数，只用一次的场景
 匿名函数的定义中，函数体只能写一行代码，如果函数体要写多行代码，不可用lambda匿名函数，应使用def定义带名函数
 """
 def test_func(compute):
     result = compute(1,2)
     print(f"结果是：{result}")
 # 通过lambda匿名函数的形式，将匿名函数作为参数传入
 test_func(lambda x, y: x + y)
 test_func(lambda x, y: x + y)
 # 再次使用需要重新定义，自带return

d. random函数的使用

e. 函数date time

4.文件

a.文件的编码

 #编码就是一种规则集合，记录了内容和二进制间进行相互转换的逻辑，最常用的是UTF-8编码

b. open()打开函数

   """
   使用open函数，可以打开一个已经存在的文件，或者创建一个新文件
   open(name,mode.encoding)
   name:是要打开的目标文件名的字符串(可以包含文件所在的具体路径)
   mode:设置打开文件的模式(访问模式):只读、写入、追加等
   encoding:编码格式(推荐使用UTF-8)
   注意:此时的'f'是'open'函数的文件对象，对象是Python中一种特殊的数据类型，拥有属性和方法，可以使用对象.属性或对象,方法对其进行访问
   r:以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
   w:打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，原有内容会被删除。如果该文件不存在，创建新文件。
   a:打开一个文件用于追加。如果该文件已存在，新的内容将会被写入到已有内容之后如果该文件不存在，创建新文件进行写入。
   read(num):num表示要从文件中读取的数据的长度(单位是字节)，如果没有传入num，那么就表示读取文件中所有的数据。
   
   readlines():可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素。
   """
 f = open(r"D:\software\pycharm\text.txt", 'r', encoding="UTF-8")
 print(type(f))
 print(f"读取十个字节的结果：{f.read(10)}")
 print(f"read方法读取全部内容的结果是：{f.read()}")
 # 使用read之后的光标不会回到原来的位置，所以前面的内容不会被再次读取
 
 print("{0:*^40}".format(1))
 # readlines()的使用
 lines = f.readlines()  # 读取全部文件，封装到列表中
 print(f"lines对象的类型是：{type(lines)}")
 print(f"lines的内容：{lines}")
 # readline一次读取一行
 
 # for循环读取文件行
 for line in f:
     print(f"每一行的数据是：{line}")
 # 文件的关闭
 f.close()
 # with open as f:
 with open(r"D:\software\pycharm\text.txt", 'r', encoding="UTF-8") as f:
     for line in f:
         print(f"每一行数据是：{line}")

c.文件的使用

 """
 直接调用write，内容并未真正写入文件，而是会积攒在程序的内存中，称之为缓冲区
 当调用flush的时候，内容会真正写入文件
 这样做是避免频繁的操作硬盘，导致效率下降(攒一堆，一次性写磁盘)
 """
 with open(r"D:\software\pycharm\text1.txt", "w", encoding="UTF-8") as f:
     f.write("Hello world!!")
     f.flush()
 # close自带flush（）操作
 # 打开文件得到文件对象，准备读取
 fr = open("D:/bill.txt", "r", encoding="UTF-8")
 # 打开文件得到文件对象，准备写入
 fw = open("D:/bill.txt.bak", "W", encoding="UTF-8")
 # for循环读取文件
 for line in fr:
     line = line.strip()
     # 判断内容，将满足的内容写出
     if line.split("")[4] == "测试":
         continue  # continue进入下一次循环，这一次后面的内容就跳过了
     # 将内容写出去
     fw.write(line)
     # 由于前面对内容进行了strip()的操作，所以要手动的写出换行符
     fw.write("\n")
 # close2个文件对象
 fr.close()
 fw.close()  # 写出文件调用close()会自动flush()

5.异常捕获

1.格式

 try:
     #写正文
 except：
     print("error")
 #也可以在except后面加上错误，指定异常
 except NameError as e:
     print(e)#能将异常打出来
 #捕获多个异常
 except (NameError,xxx...) as e:
     # 捕获所有异常
 try:
     print(name)
 except Exception as e:
     print("出现异常")
     print(e)
 
 else:
     print("没有出现异常，执行该代码")
 finally:
     # 无论如何都会执行的代码
     print("nihao")
     # 关闭文件
 # 异常传递具有传递性

2. import，创建一个包

 from random import random
 #里面的函数直接用，不需要加点缀
 """
 引入自己的模块的时候，直接把名字引入就ok
 如果自己模块的东西有的你不想执行
 在上面加上
 if __name__=='__main__':
 这句话在源文件中可以执行，但是引用过去之后就不可以
 __all__ = [, "", ""]
 该语句作用是仅指定作用的函数可以使用
 """
 
 """
 python包
 包就是就是一个文件夹，在该文件夹下包含了一个__init__.py（没有就是一个普通的文件夹）文件，该文件夹可用于包含多个模块文件，本质上依然是模块
 """
 #简单来说，这个就是大包包小包，然后只引用大包就可以用小包
 __all__ :控制 import *能够导入的内容

3. j s o n

 import json
 # json数据可视化
 # json数据与python数据的相互转换
 data = [{"name": "张", "age": 16}, {"name": "zhang", "age": 20}]
 data_str = json.dumps(data, ensure_ascii=False)
 print(type(data_str))
 # 如果想显示中文，需要加入ensure_ascii=False,不是用ascii码表来显示
 print(data_str)
 # json转python
 data = json.loads(data_str)
 print(type(data))
 print(data)

6. p ye charts 的基础入门

1.折线图

 from pyecharts.charts import Line
 from pyecharts.options import TitleOpts, LegendOpts, ToolboxOpts, VisualMapOpts
 # 创建一个对象
 line = Line()
 # 给折线图添加x轴的数据
 line.add_xaxis(["中国", "美国", "英国"])
 # 给折线图添加y轴的数据
 line.add_yaxis("GDP", [30, 20, 10])
 # 生成图像
 # line.render()
 # 全局配置选项
 line.set_global_opts(
     title_opts=TitleOpts(title="GDP展示", pos_left="center", pos_bottom="1%"),
     legend_opts=LegendOpts(is_show=True),
     toolbox_opts=ToolboxOpts(is_show=True),
     visualmap_opts=VisualMapOpts(is_show=True),
 )
 line.render()

2.数据处理成折线图

 import json
 from pyecharts.charts import Line
 from pyecharts.options import *
 # 打开文件
 f_us = open("D:/software/pycharm/docx/美国.txt", "r", encoding="Utf-8")
 f_jp = open("D:/software/pycharm/docx/日本.txt", "r", encoding="Utf-8")
 f_yd = open("D:/software/pycharm/docx/印度.txt", "r", encoding="Utf-8")
 
 us_data = f_us.read()   # 读取所有文件
 jp_data = f_jp.read()   # 读取所有文件
 in_data = f_yd.read()   # 读取所有文件
 
 us_data = us_data.replace("jsonp_1629344292311_69436(", "")
 jp_data = jp_data.replace("jsonp_1629350871167_29498(", "")
 in_data = in_data.replace("jsonp_1629350745930_63180(", "")
 
 us_data = us_data[:-2]  # 除去末尾的符号，不然不符合要求
 jp_data = jp_data[:-2]  # 除去末尾的符号，不然不符合要求
 in_data = in_data[:-2]  # 除去末尾的符号，不然不符合要求
 
 # JSON转Python字典
 us_dict = json.loads(us_data)
 jp_dict = json.loads(jp_data)
 in_dict = json.loads(in_data)
 
 # 获取trend key
 us_trend_data = us_dict['data'][0]['trend']
 jp_trend_data = jp_dict['data'][0]['trend']
 in_trend_data = in_dict['data'][0]['trend']
 
 # 获取日期数据，用于x轴，取2020年(到315下标结束)
 us_x_data = us_trend_data['updateDate'][:314]
 jp_x_data = jp_trend_data['updateDate'][:314]
 in_x_data = in_trend_data['updateDate'][:314]
 
 
 # 获取确认数据，用于y轴，取2020年(到315下标结束)
 us_y_data = us_trend_data['list'][0]['data'][:314]
 jp_y_data = jp_trend_data['list'][0]['data'][:314]
 in_y_data = in_trend_data['list'][0]['data'][:314]
 
 # 生成图表
 line = Line()  # 构建折线图对象
 
 # x轴数据
 line.add_xaxis(us_x_data)
 
 # y轴
 line.add_yaxis("美国确诊人数", us_y_data, label_opts=LabelOpts(False))
 line.add_yaxis("日本确诊人数", jp_y_data, label_opts=LabelOpts(False))
 line.add_yaxis("印度确诊人数", in_y_data, label_opts=LabelOpts(False))
 
 # 设置全局选项
 line.set_global_opts(
     title_opts=TitleOpts(title="2020年疫情三国数据", pos_left="center", pos_bottom="1%"),
     legend_opts=LegendOpts(is_show=True),
     toolbox_opts=ToolboxOpts(is_show=True),
     visualmap_opts=VisualMapOpts(True)
 
 )
 
 
 # 生成图表
 line.render()
 
 
 f_us.close()
 f_jp.close()
 f_yd.close()

3.简单的地图表

 from pyecharts.charts import *
 from pyecharts.options import VisualMapOpts
 
 
 # 准备地图对象
 map = Map()
 
 # 准备数据
 data = [
     ("北京市", 99),
     ("上海市", 199),
     ("湖南省", 299),
     ("台湾省", 399),
     ("广东省", 499)
 ]
 # 添加数据
 map.add("测试地图", data, "china")
 map.add("测试地图", data, "china", layout_size=100)
 # 设置全局选项
 
 map.set_global_opts(
      visualmap_opts=VisualMapOpts(
        is_show=True,
        is_piecewise=True,
        max_=1000
        # pieces=[
        #     {"min": 1, "max": 9, "label": "1-9", "color": "white"},  # #CCFFFF}
        #     {"min": 2, "max": 99, "label": "10-99", "color": "black"},
        #     {"min": 3, "max": 500, "label": "100-500", "color": "#990033"}
        # ]
      )
 )
 map.render()

4.全国疫情图

 # 记得加省，加自治区，加市，不然没用，而且max_和pieces不能混用
 import json
 from pyecharts.charts import *
 from pyecharts.options import *
 # 读取文件
 f = open("D:/software/pycharm/docx/疫情.txt", "r", encoding="UTF-8")
 data = f.read()
 # 关闭文件
 f.close()
 # 取数据
 data_dict = json.loads(data)
 province_data_list = data_dict["areaTree"][0]["children"]
 # 组装每个省份和确诊人数为元组，并将各个省份的数据都封装入列表中
 data_list = []  # 绘图需要的数据列表
 
 for province_data in province_data_list:
     province_name = province_data["name"]
     province_confirm = province_data["total"]["confirm"]
     data_list.append((province_name, province_confirm))
 # 造一个对象
 map = Map()
 map.add("各省份确诊人数", data_list, "china")
 # 配置全局选项
 
 map.set_global_opts(
     title_opts=TitleOpts(title="全国疫情图"),
     visualmap_opts=VisualMapOpts(
         is_show=True,
         is_piecewise=True,
         max_=100000
     )
 )
 # 绘图
 map.render("全国疫情地图.html")

5.河南省疫情地图

import json
from pyecharts.charts import *
from pyecharts.options import *
f = open("D:/software/pycharm/docx/疫情.txt", "r", encoding="UTF-8")
data = f.read()
f.close()
data_dict = json.loads(data)
cities_data = data_dict["areaTree"][0]["children"][3]["children"]

data_list = []

for city_data in cities_data:
    city_name = city_data["name"] + "市"
    city_confirm = city_data["total"]["confirm"]
    data_list.append((city_name, city_confirm))

data_list.append(("济源市", 9))
map=Map()
map.add("河南省疫情分布", data_list, "河南")
map.set_global_opts(
    title_opts=TitleOpts(title="全国疫情图"),
    toolbox_opts=ToolboxOpts(is_show=True),
    visualmap_opts=VisualMapOpts(
        is_show=True,
        is_piecewise=True,
        max_=300
    )
)
map.render("河南省疫情地图.html")

6.横向柱状图

from pyecharts.charts import Bar
from pyecharts.options import *
# 使用Bar构建基础柱状图
bar = Bar()
# 添加x轴的数据
bar.add_xaxis(["中国", "美国", "英国"])
# 添加y轴的数据
bar.add_yaxis("GDP", [30, 20, 10], label_opts=LabelOpts(position="right"))
# 反转x轴和y轴
bar.reversal_axis()  # 不反转就是正常的图形
# 绘图
bar.render("基础柱状图.html")

7.动态时间线示意图

# 有时间线的柱状图开发
from pyecharts.globals import ThemeType
from pyecharts.charts import *
from pyecharts.options import *
# 修改颜色,创立时间线对象
timeline = Timeline(
    {"theme": ThemeType.ESSOS}
)
d = [[30, 20, 10], [50, 40, 60], [30, 89, 76]]  # 贮存数据 
range_color = ['#FFC0CB', '#FFFF00', '#008000']  # 颜色变化
for i in range(3):
    bar = Bar()
    bar.add_xaxis(["中国", "美国", "英国"])
    bar.add_yaxis("GDP", d[i], label_opts=LabelOpts(position="right"))
    bar.reversal_axis()
    bar.set_global_opts(
        title_opts=TitleOpts(title="GDP柱状图"),  # 加名称
        visualmap_opts=VisualMapOpts(  # 加范围显示
            is_show=True,
            dimension=0,  # 加上这个就欧克了，映射维度
            range_color=range_color,  # 这个厉害，可以改变你的颜色，然后动态显示
            # max_=100
        )
    )
    timeline.add(bar, f"点{i}")

# 设置自动循环
timeline.add_schema(
    play_interval=1000,   # 1000ms
    is_timeline_show=True,
    is_auto_play=True,
    is_loop_play=True
)

# 绘图是用时间线对象绘图，而不是bar对象
timeline.render("基础时间线柱状图.html")

8.扇形图

import matplotlib.pyplot as plt

# 扇形图的标签
labels = ['A', 'B', 'C', 'D']
# 每个扇形的大小
sizes = [15, 30, 45, 10]
# 每个扇形的颜色
colors = ['gold', 'yellowgreen', 'lightcoral', 'lightskyblue']
# 突出显示的扇形
explode = (0.2, 0, 0, 0)

# 生成扇形图
plt.pie(sizes,
        explode=explode,
        labels=labels, colors=colors,
        autopct='%1.1f%%',
        shadow=True,
        startangle=140
        )
# 保持纵横比相等
plt.axis('equal')

# 显示图形
plt.show()

9.动态GDP柱状图绘制

from pyecharts.charts import Bar, Timeline
from pyecharts.options import *
from pyecharts.globals import ThemeType

# 读取文件
f = open("D:/software/pycharm/docx/第1-12章资料/资料/资料/可视化案例数据/动态柱状图数据/1960-2019全球GDP数据.csv", "r", encoding="ANSI")
data_lines = f.readlines()
# 关闭文件
f.close()
# 删除第一行数据
data_lines.pop(0)

# 将数据转为字典存储，格式为：
# { 年份:[[国家, gdp]，[国家, gdp]，...... ]，年份:[[国家,gdp]，[国家, gdp]，.....], ...... }，比如：
# { 1960:[[美国, 123]，[中国, 231]，...... ]，1961:[[美国,124]，[中国, 234]，.....], ...... }
# 先定义一个字典
data_dict = {}
for line in data_lines:
    year = int(line.split(",")[0])  # 年份
    country = line.split(",")[1]  # 省份
    GDP = float(line.split(",")[2])  # 因为美国的GDP是科学计数法，所以用float强制转回来
    # 如何判断字典里面有没有制定的key呢？
    try:
        data_dict[year].append([country, GDP])
    except KeyError:
        data_dict[year] = []
        data_dict[year].append([country, GDP])

# 排序年份
sorted_year_list = sorted(data_dict.keys())
timeline = Timeline({"theme": ThemeType.LIGHT})  # 创建时间线对象

for year in sorted_year_list:
    data_dict[year].sort(key=lambda element: element[1], reverse=True)
    # 取出本年份前八名的国家
    year_data = data_dict[year][:8]
    x_data = []
    y_data = []
    for country_gdp in year_data:
        x_data.append(country_gdp[0])  # x轴添加国家
        y_data.append(country_gdp[1] / 100000000)  # y轴添加GDP数据,单位为亿元

    # 构建柱状图
    bar = Bar()
    x_data.reverse()
    y_data.reverse()
    bar.add_xaxis(x_data)
    bar.add_yaxis("GDP亿元", y_data, label_opts=LabelOpts(position="right"))
    # 反转x轴，y轴
    bar.reversal_axis()
    range_color = ['#FFC0CB', '#FFFF00', '#008000']
    # 设置每一年的图表标题
    bar.set_global_opts(
        title_opts=TitleOpts(title=f"{year}年全球GDP前八数据"),
        visualmap_opts=VisualMapOpts(  # 加范围显示
            is_show=True,
            dimension=0,  # 加上这个就欧克了，映射维度
            range_color=range_color,  # 这个厉害，可以改变你的颜色，然后动态显示
            max_=10000
        )
    )
    # 创建时间线对象

    timeline.add(bar, str(year))

# 设置时间为自动播放
timeline.add_schema(
    play_interval=1000,  # 时间间隔
    is_timeline_show=True,  # 是否显示时间
    is_loop_play=True,  # 是否循环
    is_auto_play=True  # 是否自动播放
)
# 绘图
timeline.render("1960——2019全球GDP前八国家.html")

7.类

1.初始对象--变量

# 设计一个类
class Student:
    name = None
    gender = None
    nationality = None
    native_place = None
    age = None


stu_1 = Student()
stu_1.name = "小王八"
stu_1.gender = "女"
stu_1.nationality = "中国"
stu_1.native_place = "邯郸"
stu_1.age = 19

print(stu_1.name)
print(stu_1.gender)
print(stu_1.native_place)

2.成员方法--def

class Student:
    name = None

    def say_hi(self):  # self不占变量数量，但得有
        print(f"大家好，我是{self.name},请大家多多关照")

    def say_hi2(self, msg):
        print(f"大家好，我是：{self.name},{msg}")  # 使用类里面得变量


stu = Student()
stu.name = "小王八"
stu.say_hi()
stu.say_hi2("咋，你想咋")

stu_1 = Student()
stu_1.name = "树"
stu_1.say_hi()
stu_1.say_hi2("哎哟哟")