Python入门

基础语法

字面量

字面量：在代码中，背写下来的固定的值。
常见的值类型：

注释

注释：在程序代码中对程序代码进行解释说明的文字。（不会被执行）
单行注释：#
多行注释：“”" 123 “”"三引号

变量

变量：在程序运行时，能储存计算结果或能表示值的抽象概念。

变量名称 = 变量的值

# 定义一个变量，来记录钱包余额
money = 50
print("钱包余额还有：",money)

# 买了一个冰淇淋，花费十元
money = money - 10
print("买了一个冰淇淋,钱包余额还有：",money)

# 假设，每隔一小时，输出一下钱包的余额
print("现在时下午1点，钱包余额剩余：",money)
print("现在时下午2点，钱包余额剩余：",money-10)#ctrl+D 直接复制
print("现在时下午3点，钱包余额剩余：",money-20)
print("现在时下午4点，钱包余额剩余：",money-30)

数据类型

# 使用type查看数据类型, type(要查看的数据)
print(type("上海师范大学"))
print(type(666))
print(type(13.14))

# 用变量存储type得到结果
string_type = type("上海师范大学")
int_type = type(666)
float_type = type(13.14)
print(string_type)
print(int_type)
print(float_type)

# 查看变量的存贮类型
school = "上海师范大学"
school_type = type(school)
print(school_type)

变量是没有类型的，有类型的是变量存贮的数据

数据类型转换

数据类型在特定的场景下转换，如字符串转数字，数字转字符串等。

# 将数字类型转换成字符串
num_str = str(123)
print(num_str,"的数据类型是",type(num_str))

# 将字符串转换成数字
str_num = int("123")
print(str_num,"的数据类型是",type(str_num))

# 将字符串转换成数字
str_flo = float("123")
print(str_flo,"的数据类型是",type(str_flo))

# 浮点数转整数
float_int = int(13.14)
print(float_int,"的数据类型是",type(float_int))    #会丢失精度，小数部分丢失

标识符

在python中，我们可以给很多东西取名字，比如：

• 变量的名字
• 方法的名字
• 类的名字，等等

这些名字，我们把它统一的称之为标识符，用来做内容的标识。

所以，标识符：用户在编程的时候所使用的一系列名字，用于给变量、类、方法等命名。

标识符命名有三大规则：

• 内容限定（只限：英文，中文，数字，下划线(_)）数字不可以在开头
• 大小写敏感
• 不可使用关键字

# 内容限定（只限：英文，中文，数字，下划线(_)）`数字不可以在开头`
name = 1
名字 = 2
_name = 3

# 大小写敏感
Item = 123
item = 456
print(Item)
print(item)

# 不可使用关键字
# class = 1  报错
Class = 1 #大小写规则

运算符

算数运算符：

# 算数运算符
print("1+1=",1+1)
print("2-1=",2-1)
print("2*3=",2*3)
print("4/2=",4/2)
print("11//2=",11//2) # 整除
print("9%2=",9%2) # 取余
print("4**2=",4**2) # 指数

复合运算符：

# 复合运算符
num = 10
num += 1     # num = num + 1
print(num)
num -= 1
print(num)
num *= 2
print(num)
num /= 2
print(num)
num %= 2
print(num)
num //= 2
print(num)
num **= 2
print(num)

字符串扩展

字符串的定义

字符串在python中有多种定义方式：

• 单引号：name = ‘上海师范大学’
• 双引号：name = “上海师范大学”
• 三引号：name = “”“上海师范大学”“”

如果想要在定义的字符串中本身就含有引号，有多种办法

# 字符串本身含有双引号
name4 = "shnu'sh'"
print(name4)
name5 = 'shnu"sh"'
print(name5)
name6 = ' shnu\'sh\' '      # 用\ 来解除符号的效用
print(name6)

字符串的拼接

# 字符串字面量之间的拼接
print("我是一个"+"大傻逼")
# 字符串字面量与字符串变量的拼接
name = "猪猪人"
addrees = "溧杉矶"
print(name+"住在"+addrees)

字符串变量不能和数值型变量直接拼接

字符串格式化(占位)

因为字符串拼接过于繁琐、无法与其他类型完成拼接，所以我们要用到字符串格式化。
%：表示占位
s：将变量变成字符串放入占位的地方
d：将变量变成整数放入占位的地方
f：将变量变成浮点数放入占位的地方

message = "学java的%s" % name
print(message)
# 通过占位的形式，完成数字和字符串的拼接
class_num = 57
avg_sal = 16000
message2 = "班级里有%s人，平均生活费%s" % (class_num,avg_sal)
print(message2)
message3 = "班级里有%d人，平均生活费%f" % (class_num,avg_sal)
print(message3)

格式化（占位）的精度控制

我们可以使用辅助符号"m,n"来控制数据的宽度和精度

• m：控制宽度，要求是数字（很少使用），设置的宽度小于数字本身，不生效。
• n：控制小数点精度，要求是数字，会进行四舍五入。
  

# 格式化中的精度控制
message3 = "班级里有%5d人，平均生活费%7.2f" % (class_num,avg_sal) #宽度限制为7，精度限制为2，如果不限制宽度则为（.2）
print(message3)

字符串格式化（快速格式化）

语法：f“内容{变量}”
缺点：没法做精度控制

# 快速格式化
print(f"班级里有{class_num}名学生，平均生活费是{avg_sal}元")

对表达式进行格式化

表达式：一条具有明确的执行结果的代码语句

#对表达式进行字符串格式化
print("1 * 1 的结果是：%d" %(1*1))
print(f"1 * 2 的结果是：{1 * 2}")
print("这个字符串的类型是：%s" %type("字符串"))

数据输入 (input)

input输入的永远是字符串类型

name = input("告诉我你是谁")
print("你是：%s" %name)

#输入数字类型
num = input("请输入数字密码")
print(type("num")) 

Python的判断语句

布尔（bool）类型和比较运算符

布尔类型的字面量：

• True表示为真（是、肯定）
• False表示假（否、否定）

定义变量存贮布尔类型数据： 变量名称 = 布尔类型字面量

比较运算符：

# 定义变量存储布尔类型的数据
bool_1 = True
bool_2 = False
print(f"bool_1的内容是:{bool_1},类型是：{type(bool_1)}")
print(f"bool_1的内容是:{bool_2},类型是：{type(bool_2)}")

#比较运算符的使用：==、！=、>、<、>=、<=
num1 = 10
num2 = 10
print(f"10 == 10的结果是：{num1 == num2}")
print(f"10 == 10的结果是：{10 == 10}")
#字符串型
name1 = "tom"
name2 = "pig"
print(f"tom = pig的结果是：{name1 == name2}")

#演示>、<、>=、<=
print(f"15 >= 10的结果是：{15 >= 10}")

if语句的基本格式

age = int(input("请输入您的年龄："))
if age >= 18:
    print("您已经成年啦")
print("时间过的真快")

if else 语句

age = int(input("请输入您的年龄："))
if age >= 18:
    print("您可以去网吧了")
else:
    print("还是个小屁孩")
print("时间过的真快")

if elif else 语句

num = 5
if int(input("请猜一个数字：")) == num:
    print("恭喜第一次就猜对了")
elif int(input("请再猜一次：")) == num:
    print("恭喜您猜对了")
else:
    print("很遗憾，您没有猜对")

注意细节：
1、所有条件只会有一个满足，按顺序来
2、else也可以省略不写，效果等同3个独立的if判断

判断语句的嵌套

print("欢迎来到动物园")
if int(input("请输入您的身高（cm）：")) >= 120:
    print("您的身高过高，不满足免费条件")
    print("如果您的VIP等级大于等于4级，仍可免费游玩")
    if int(input("请输入您的VIP等级(1-5)：")) >= 4:
        print("恭喜您,您的VIP等级大于等于4级，可以免费游玩")
    else:
        print("不好意思，请购票")
else:
    print("欢迎您，您可以免费游玩")

公司要发礼物，条件是：
1、级别大于3
2、年龄必须再18-30岁之间，并且工龄大于两年

if work_level > 3:
    print("恭喜您，您可以领取礼物")
elif age >= 18:
    if age < 30:
        if work_age <= 2:
            print("您无法领取礼物")
        else:
            print("恭喜您，您可以领取礼物")
    else:
        print("sorry")
else:
    print("sorry")

实战案例(猜数字)

定义一个数字，通过三次判断来猜出数字。
要求：
1、数字1-10，随机产出
2、有三次机会。
3、猜错会提示大了还是小了

import random
num = random.randint(1,10)
num_guess = int(input("请猜一个数字"))
if num_guess == num:
    print("恭喜您，一次就猜对啦")
else:
    if num_guess > num:
        print("大了，您还有两次机会")
    else:
        print("小了，您还有两次机会")
    num_guess2 = int(input("请猜一个数字,第二次机会"))
    if num_guess2 == num:
        print("恭喜您在第二次猜对啦")
    else:
        if num_guess2 > num:
            print("大了，您还有一次机会")
        else:
            print("小了，您还有一次机会")
        num_guess3 = int(input("请猜一个数字,第三次机会"))
        if  num_guess3 == num:
            print("恭喜您在最后一次猜对啦")
        else:
            print("sorry")

Python循环语句

while循环的基础语法

i = 0
while i < 100:
    print(f"倒了{i}次")
    i += 1
    
# 练习：求1累加到100的和
x = 1
y = 0
while x < 101:
    y += x
    x += 1
print(f"1累加到100的和是{y}")

while循环的基础案例

"""
设置一个范围1-100的随机整数变量，通过while循环，配合input语句，判断输入的数字是否等于随机数
要求：
1、无限次机会，直到猜中为止
2、每一次猜不中，会提示大了还是小了
3、猜完数字后，提示猜了几次
"""
import random
num = random.randint(1,100)
flag = True
i = 1
while flag:
    num_guess = int(input("请猜一个数字（1-100）："))
    if num_guess == num:
        print(f"猜对了，猜了{i}次")
        flag = False   #终止循环的意思
    else:
        if num_guess > num:
            print(f"猜大了,猜了{i}次")
        else:
            print(f"猜小了,猜了{i}次")
        i += 1

while循环的嵌套应用

i = 1
while i <= 100:
    print(f"今天是表白第{i}天")

    # 内存循环的控制变量
    j = 1
    while j <= 10:
        print(f"送给小妹第{j}只玫瑰")
        j += 1

    print("i like u")
    i += 1
print(f"坚持到第{i-1}天，表白成功")

while循环的嵌套案例

"""
# 自动不换行end=''
print("hello", end='')
print("world",end='')

# 自动不换行并对齐，制表符\t
print("hello\tworld")
print("item\tzmx")
"""

# 通过while循环输出九九乘法表
i = 1
while i <= 9:
    # 定义内层循环的控制变量
    j = 1
    while j <= i:
        # 内存循环，不要换行，再用制表符对齐
        print(f"{j} * {i} = {j * i}\t", end='')
        j += 1
    i += 1
    print()    # print()，就是输出一个换行

for 循环

基础语法

遍历

name = "zhaomengxuan"
# for循环处理字符串
for x in name:
    print(x)

运行结果

案例

# 案例，统计字符串中有多少个a
name2 = "asnodiqhwiuabiaasadbuaaaadinihuoouadaadas"
count_a = 0
for x in name2:
    if x == 'a':
        count_a += 1
print(f"name2中一共有{count_a}个a")

range语句

左闭右开
语法：

• 1、range(num)：获取一个从0开始，到num结束的数字序列（不含num）。
• 2、range(num1，num2)：获取一个从num1开始，到num2结束的数字序列（不含num2）。
• 3、range(num1，num2，step)：获取一个从num1开始，到num2结束的数字序列（不含num2)，数字之间的步长为step，默认为1。

# range案例：定义num,range(1,num),统计有多少个偶数
num = 10213
count_num = 0
for x in range(1,num+1):
    if x % 2 == 0:
        count_num += 1
print(f"num中有{count_num}个偶数")

for循环临时变量作用域

# 临时变量作用域
i = 0 #提前定义
for i in range(5):
    print(i)
print(i)

for循环的嵌套应用

# 坚持表白100天
# 每天送花10束
i = 1
for i in range(1,101):
    print(f"今天是表白的第{i}天")
    for j  in range(1,11):
        print(f"送出第{j}朵花")
    print(f"第{i}表白结束")
print(f"表白第{i}天，表白成功")

案例：九九乘法表

for i in range(1,10):

    for j in range(1,i+1):
        print(f"{j} * {i} = {j * i}\t",end='')
        
    print()

循环中断：break和continue

break

continue

综合案例

"""
某公司，账户余额有1w元，给20名员工发工资，要求
1、员工编号从1-20，从编号1开始依次领取工资，没人可领1000元
2、领工资时，财务判断员工的绩效分（1-10）（随机生成），如果低于5，不发工资，换下一位
3、如果工资发完了，结束发工资
"""
import random
sal_total = 10000
for i in range(1,21):
    print(f"第{i}位员工开始领取工资")
    performance = random.randint(1,10)
    if sal_total <= 0:
        print("工资已经发放完毕，请下个月再来")
        break
    elif performance < 5:
        print(f"第{i}号员工的绩效不合格，不发放工资,下一位")
        continue
    else:
        sal_total -= 1000
        print(f"向员工{i}支付1000元工资,账户余额{sal_total}元")

函数

函数的介绍

函数：是组织好的，可重复使用的，用来实现特定功能的代码段。

# 统计字符串的长度，不使用内置函数len()
str1 = "ithiema"
str2 = "itcast"
str3 = "python"

def my_len(data):
    count = 0
    for i in data:
        count += 1
    print(f"字符串{data}的长度是{count}")
my_len(str1)
my_len(str2)
my_len(str3)

函数的定义

def say_hi():
    print("Hi, im pig")

say_hi()

函数的参数

传入参数的功能：再函数进行计算的时候，接受外部（调用时）提供的数据。

def add(x,y):
    result_add = x + y
    print(f"{x} + {y}的结果是{result_add}")

add(1123,1544235)

"""
定义一个函数，接受参数输入（数字类型表示体温），在参数内进行体温判断（正常范围：<=37.5）
"""
def temp(x):
    x = float(x)
    if x <= 37.5:
        print("体温正常")
    else:
        print("发烧了，立即枪毙")

temp(37.6)

函数的返回值

返回值的定义

返回值：可以将结果返回给调用者

def add(a,b):
    result_add = a + b
    return result_add    # 函数在return处直接结束

r = add(23,43)
print(r)

返回值的None类型

None表示：空的、无实际意义的意思，在python中返回为空。
None 写不写无所谓，不写默认返回None。

def say_hi():
    print("Hi, im pig")

x = say_hi()
print(x)              # 返回值为None
print(type(x))        # 结果为<class 'NoneType'>

#None在if中使用
def check_age(age):
    if age >= 18:
        return "success"
    else:
        return None
result_age = check_age(16)
print(result_age)       # 返回值为None
if not result_age:      # not false(none) == true
    print("未成年")

# None赋值
name = None              # 暂时不提供值

函数的说明文档

注意：说明内容应写在函数体之前

def add(x,y):
    """
    add函数可以接受两个参数进行参加
    :param x: 1
    :param y: 2
    :return: 相加的结果
    """
    result_add = x + y
    return result_add
add(5,6)

函数的嵌套调用

函数的嵌套调用是指在一个函数里面又调用了另一个函数。

def func_b():
    print("-2-")

def fun_a():
    print("-1-")
    func_b()
    print("-3-")

fun_a()

变量的作用域

变量的作用域指的是变量的作用范围（在哪可以用，在哪不可以用）
主要分为两类：局部变量和全局变量

局部变量

所谓局部变量是定义在函数内部的变量，即只在函数体内部生效。

# 其中的result_add就是一个局部变量
def add(x,y):
    """
    add函数可以接受两个参数进行参加
    :param x: 1
    :param y: 2
    :return: 相加的结果
    """
    result_add = x + y
    return result_add

print(result_add)     # 报错，出了函数体，无法使用

全局变量

num = 200

def tes_a():
    print(f"tes_a={num}")

tes_a()

def tes_b():

    # global num  # 将内部变量设置为全局变量，不然函数体的num是始终与外部的num无关
    num = 500                   # 依旧是一个局部变量，与外部的num无关
    print(f"tes_b={num}")
    
tes_b()                             # tes_b=500
print(num)                        # 还是200

综合案例

"""
1、定义一个全部变量money，用来记录银行卡余额，初始为5000000
2、定义一个全部变量name，用来记录客户姓名（启动程序时输入）
3、定义如下函数：余额查询函数、存款函数、取款函数、主菜单函数
要求：
- 程序启动后要求输入客户姓名
- 程序余额、存款、取款后都会返回主菜单
- 取款、存款后，都显示一下当前余额
- 客户选择退出或者输错时程序才会推出，不然程序会一直允许
"""
# 定义全局变量
money = 5000000
name = input("请输入您的姓名")

# 定义查询函数
def query(show):
    if show:
        print("---------------------余额查询---------------------")
    print(f"{name},您好，您的余额剩余{money}元")

# 定义存款函数
def deposit(num):
    global money
    money += num
    print("---------------------存款--------------------")
    print(f"存款{num}元成功")
    # 调用query函数查询余额
    query(False)

# 定义取款函数
def withdraw(num):
    global money
    money -= num
    print("---------------------取款--------------------")
    print(f"取款{num}元成功")
    # 调用query函数查询余额
    query(False)

# 定义主菜单函数
def main():
    print("---------------------主菜单--------------------")
    print(f"{name},您好，欢迎来到atm，请选择操作：")
    print("查询余额\t[输入1]")
    print("存款\t\t[输入2]")
    print("取款\t\t[输入3]")
    print("推出\t\t[输入4]")
    return int(input("请输入您的选择"))

# 设置循环，保证程序不退出
while True:
    keyboard_input = main()
    if keyboard_input == 1:
        query(True)
        continue          # 通过continue继续下一次循环，回到主菜单
    elif keyboard_input == 2:
        num = int(input("请输入您要存款的金额"))
        deposit(num)
        continue
    elif keyboard_input == 3:
        num = int(input("请输入您要取出的金额"))
        withdraw(num)
        continue
    else:
        print("程序已退出")
        break

数据容器

数据容器入门

数据容器：一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素。每一个元素可以是任意的类型，如字符串、数字、布尔等。

数据容器根据特点不同，如：

• 是否支持重复元素
• 是否可以修改
• 是否有序，等

可以分为为五类：列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）

list（列表）

列表的每一个数据，称之为元素
注意：列表是可以嵌套的，即一个列表可以存储另一个列表。

name_list = ["itheima","itcast","python"]
print(name_list)
print(type(name_list))

my_list = ["zmx","上海师范大学",name_list]
print(my_list)

输出结果为

列表的下标索引

列表中的每一个元素都有其位置下表索引，从前往后的方向，从0开始递增；或者也可以从后往前的方向，从-1开始递减。

# 下表索引
print(name_list[0])
print(name_list[-1])
print(my_list[-1][0])         # 返回的是itheima，嵌套索引

列表的常用操作

列表的查询功能（方法）

功能：查找定制元素在列表的下标，如果找不到，报错ValueError。
语法：list.index(元素)

# 查询
index1 = my_list.index("zmx")
print(f"zmx在列表中的下标索引值是{index1}")
"""
不存在查询
index2 = my_list.index("hello")
print(index2)
"""

列表的修改功能（方法）

# 修改
my_list[1] = "hh"
print(my_list)

列表的插入功能（方法）

语法：list.insert(下标，元素)，指定位置插入指定元素。

# 插入
my_list.insert(4,"shnu")
print(my_list)

列表的追加功能（方法）

语法：list.append(元素)，将指定元素追加到列表的尾部。

# 追加
my_list.append("ntu")
print(my_list)

如果想要增加一批新元素
语法：list.extend(其他数据容器)，将其他数据容器的内容取出，一次追加到列表尾部。

# 追加2
my_list.extend([1,2,3])
print(my_list)

列表的删除功能（方法）

语法1：del list[下标]
语法2：list.pop[下标]

# 删除
del my_list[-1]
my_list.pop(-1)
print(my_list)

语法3，删除指定元素：list.remove(元素)
从前到后索引，删除找到的第一个匹配元素

my_list.remove(1)
print(my_list)

列表的清空功能（方法）

语法：list.clear()

# 清空
name_list.clear()
print(name_list)

列表的统计功能（方法）

语法：list.count(元素)

# 统计
my_list.count("zmx")
print(my_list)

统计列表中全部元素的数量
语法：len（列表）

listlen = len(my_list)
print(listlen)

list列表的遍历

while循环遍历列表

# while循环遍历列表
def list_while_func():
    my_list = ["zmx","hh","pig"]

    index = 0
    while index < len(my_list):
        element = my_list[index]
        print(f"列表的元素：{element}")

        index += 1

for循环遍历列表

# for循环遍历列表
def list_for_func():
    my_list = [1,2,3,4]
    for element in my_list:
        print(f"列表的元素：{element}")

练习

# 练习
"""
定义一个列表[1,2,3,4,5,6,7,8,9,10]
- 遍历列表，取出列表内的偶数，存放入一个新的列表
- 两种循环遍历
"""
def practice_while():
    my_list = [1,2,3,4,5,6,7,8,9,10]
    you_list = []
    index = 0
    while index < len(my_list):
        element = int(my_list[index])
        if element % 2 == 0:
            you_list.append(element)
        index += 1
    print(you_list)

practice_while()

def practice_for():
    my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    you_list = []
    for element in my_list:
        if int(element) % 2 == 0:
            you_list.append(element)
    print(you_list)

practice_for()

tuple（元组）

元组的信息不可被修改。
当我们需要在程序内封装数据，但又不希望封装的数据被篡改，那么元组就非常合适。

# 定义元组
tuple1 = (1,"zmx",True)
tuple2 = ()
tuple3 = tuple()

定义单元素的元组时，必须加（,） 否则不是元组类型

# 定义单个元组
tuple4 = ("zmx",)  # 必须加（，）否则不是元组类型
print(type(tuple4))     # 结果：<class 'tuple'>
x = ("zmx")
print(type(x))          # 结果：<class 'str'>

元组的嵌套

# 元组的嵌套
tuple5 = (1,2,3,(4,5,6))
print(type(tuple5))     # 结果：<class 'tuple'>

元组的常用操作

对元组进行修改则会报错

元组的下标索引

下标索引

# 下标索引
tuple5 = (1,2,3,(4,5,6))
num = tuple5[3][2]
print(num)              # 结果：6

元组的查询功能

index查询

tuple1 = (1,"zmx",True)
# index查询
index = tuple1.index("zmx")
print(index)            # 结果：1

元组的统计功能

# count统计
tuple7 = (1,"zmx",True,"zmx","zmx","zmx","zmx")
count = tuple7.count("zmx")
print(count)            # 结果：5
# 统计全部元素的个数
num = len(tuple7)
print(num)              # 结果：7

元组的遍历

# 元组的遍历while
index = 0
while index < len(tuple7):
    element = tuple7[index]
    print(element)
    index += 1

# 元组的遍历for
for element in tuple7:
    print(element)

元组修改的特例

虽然我们无法直接对元组进行修改，但是我们可以修改元组内的列表内的内容。（本质还是对列表进行修改）

# 对元组内的列表进行修改
tuple8 = (1,2,"zmx",["hh",4,5])
tuple8[3][1] = 3
print(tuple8)           # 结果：(1, 2, 'zmx', ['hh', 3, 5])

str(字符串)

字符串不像是元组、列表那样，一看就是存放了许多数据的容器。
但不可否认的是，字符串同样也是数据容器的一员。
字符串是字符的容器，一个字符串可以存放任意数量的字符。
跟元组一样，字符串同样是一个不可修改的数据容器。

字符串的常用操作

字符串的下标索引

字符串的查询功能

# index
v3 = my_str.index("zmx")
print(v3)           #结果：11 ， 注意：这里得到的是索引的起始坐标

字符串的替换功能（新）

语法：str.replace(str1,str2)
功能：将字符串内的全部str1替换成str2
注意：这不是修改字符串本身，而是得到了一个新字符串。

# replace
new_str = my_str.replace("zmx","hh")
print(new_str)

字符串的分割功能（新）

语法：str.split(分隔符字符串)
功能：按照指定的分隔符字符串，，将字符串划分为多个字符串，并存入列表对象中国
注意：字符串本身不变，而是得到了一个列表对象。

# split
new_str_split = my_str.split(" ")
print(new_str_split)            # 结果：['my', 'name', 'is', 'zmx']
print(type(new_str_split))      # 结果：<class 'list'>

字符串的规则操作（去前后空格或者指定字符串）

语法：str.strip()

# strip
new_str_strip1 = my_str.strip()
print(new_str_strip1)           # 结果：my name is zmx
new_str_strip2 = my_str.strip("mx")
print(new_str_strip2)           # 结果：y name is z
#注意：输入的是"mx"，其实就是"m"和"x"都会移除，是按照单个字符串

字符串的统计功能

# count
count = my_str.count("zmx")
print(count)            # 结果：1

# len
num = len(my_str)
print(num)              # 结果：14

字符串的遍历

# 字符串的遍历while
index = 0
while index < len(my_str):
    element = my_str[index]
    print(element)
    index += 1

# 字符串的遍历for
for element in my_str:
    print(element)

字符串操作的练习

"""
给定一个字符串："zmx is godzmx"
- 统计字符串内又多少个“zmx”字符
- 将字符串内的空格，全部替换为字符：“|”
- 并按照“|”进行字符串分割，得到列表
"""
practice_str = "zmx is godzmx"
count = practice_str.count("zmx")
print(count)
practice_str_new = practice_str.replace(" ","|")
print(practice_str_new)
practice_str_split = practice_str_new.split("|")
print(practice_str_split)

数据容器的切片（序列）

序列是指：内容连续、有序，可使用下标索引的一类数据容器。

列表、元组、字符串均可以视为序列。

序列的常用操作

切片

序列支持切片，即：列表、元组、字符串均支持切片操作。
切片：从一个序列中，取出一个子序列。左闭右开

语法：序列[其实下标：结束下标：步长]
功能：表示从序列中，从指定位置开始，一次取出元素，到指定位置结束，等到一个新序列。

说明：
1、起始下标可以为空，表示从头开始。
2、结束下标可以为空，表示到尾结束。
3、步长表示，依次取元素的间隔，步长为N表示每两个元素之前间隔N-1个元素；步长为负数表示反向取数（注意，起始小标和结束下标也要反向标记）。

# 对list进行切片，从1开始，4结束，步长1
my_list = [0,1,2,3,4,5,6]
result1 = my_list[1:4]      # 步长为1，可以默认不写
print(result1)

# 对tuple进行切片，从头开始，到最后结束，步长1
my_tuple = (0,1,2,3,4,5,6)
result2 = my_tuple[:]       # 起始和结束不写默认从头开始，到最后结束
print(result2)

# 对str进行切片，从头开始，到最后结束，步长2
my_str = "01234567"
result3 = my_str[: :2]
print(result3)

# 对str进行切片，从头开始，到最后结束，步长-1
my_str = "01234567"
result4 = my_str[: :-1]     # 等同于将序列反转了
print(result4)

# 对list进行切片，从3开始，1结束，步长-1
my_list = [0,1,2,3,4,5,6]
result5 = my_list[3:1:-1]
print(result5)

# 对tuple进行切片，从头开始，到最后结束，步长-2
my_tuple = (0,1,2,3,4,5,6)
result6 = my_tuple[::-2]       # 起始和结束不写默认从头开始，到最后结束
print(result6)

set(集合)

基础定义

列表、元组、字符串的局限性在于他们都支持重复元素。如果场景需要对内容做去重处理，列表、元组、字符串就不方便了。

而集合，就自带去重功能，并且内容无序。

集合的常用操作

集合的添加操作

首先，集合是无序的，所以集合不支持下标索引。
但是集合和列表是一样的，是允许修改的。

语法：set.add(元素)。将指定元素，添加到集合内。
结果：集合本身被修改，添加了新元素

# 添加新元素
my_set.add("python")
my_set.add("zmx")               # 集合自动去重，不会重复添加
print(my_set)                   # 结果：{1, 'zmx', 'shnu', 'python', 'hh'}

集合的移除操作

语法：set.remove(元素)。将指定元素，从集合移除。
结果：集合=本身被修改，移除了元素。

# 移除元素
my_set.remove(1)
print(my_set)                   # 结果：{'python', 'zmx', 'hh', 'shnu'}

集合的随机取出操作

语法：set.pop()。从集合中随机取出一个元素。
结果：会得到一个元素的结果，同时集合本身被修改，元素被移除。

# 随机取出元素
element = my_set.pop()
print(my_set)                   # 结果：{'python', 'hh', 'shnu'}
print(element)                  # 结果：zmx

集合的清空操作

语法：set.clear()

my_set.clear()

取出两个集合的差集

语法：set1.difference(set2)。
功能：取出集合1和集合2的差集（集合1有而集合2没有的）。
结果：得到一个新集合，而集合1和集合2不变。

消除两个集合的差集

语法：set1.difference_update(set2)。
功能：对比集合1和集合2的结果，在集合1内，删除和集合2相同的元素。
结果：集合1被修改，集合2不变。

# 消除两个集合的差集
set1 = {1,2,3}
set2 = {1,3,5,6}
set1.difference_update(set2)
print(set1)                     # 结果：{2}改变
print(set2)                     # 结果：{1, 3, 5, 6}不变

集合的合并操作

语法：set1.union(set2)
功能：将集合1和集合2组合成新集合。
结果：得到新集合，集合1和集合2不变。

# 合并
set1 = {1,2,3}
set2 = {1,3,5,6}
set3 = set1.union(set2)
print(set3)                     # 结果：{1, 2, 3, 5, 6}
print(set1)                     # 结果：{1, 2, 3}不变
print(set2)                     # 结果：{1, 3, 5, 6}不变

集合的统计操作

# 统计
set1 = {1,2,3}
num = len(set1)
print(num)

集合的遍历

因为集合不支持下标索引，所以不能用while循环。

# 遍历
for element in set1:
    print(element)

集合的练习

# 练习
"""
创建一个列表["my","name","zmx","your","are","pig"]
1、定义一个空集合
2、通过for循环遍历列表
3、在for循环中将列表的元素添加到集合
4、最终得到元素去重后的集合对象，并打印输出
"""
my_list = ["my","name","zmx","your","are","pig"]
practice_set = set()
for element in my_list:
    practice_set.add(element)
print(practice_set)

dict(字典、映射)

基础定义

通过字典，我们可以实现用key取出value的操作。

字典的定义，同样使用{}，不过存储的元素是一个个的：键值对。

同集合相同，字典的key也不允许重复。

# 定义字典
my_dict = {"王力宏":99,"周杰伦":88,"林俊杰":77}
dict1 = dict()
dict2 = {}

# 重复的key
dict3 = {"王力宏":99,"周杰伦":88,"林俊杰":77,"林俊杰":66}
print(dict3)                # 结果：{'王力宏': 99, '周杰伦': 88, '林俊杰': 66} dict不允许重复，后面的值会把前面的值替换

字典数据的获取

字典同集合一样，不可以使用下标索引。
但是字典可以通过key值来取得对应的value。

# 字典数据的获取
my_dict = {"王力宏":99,"周杰伦":88,"林俊杰":77}
print(my_dict["王力宏"])           # 结果：99

字典的嵌套

字典的key和value可以是任意数据类型（key不可为字典）。
那么就表面字典是可以嵌套的。

# 字典的嵌套
dict4 = {
    "王力宏":{"语文":77,"数学":88,"英语":99},
    "周杰伦":{"语文":66,"数学":86,"英语":96},
    "林俊杰":{"语文":33,"数学":55,"英语":93}
}
print(dict4)

# 从嵌套的字典中获取数据
score = dict4["王力宏"]["语文"]
print(score)

dict的常用操作

字典的添加操作

语法：dict[key] = value
结果：字典被修改，新增了元素。

# 字典的新增操作
my_dict["张杰"] = 66
print(my_dict)          # 结果：{'王力宏': 99, '周杰伦': 88, '林俊杰': 77, '张杰': 66}

字典的更新操作

语法：dict[key] = value
结果：字典被修改，元素被更新。
注意：字典的key不可以重复，所以对已有的key进行操作，就是更新value值。

# 字典的更新操作
my_dict["张杰"] = 55
print(my_dict)          # 结果：{'王力宏': 99, '周杰伦': 88, '林俊杰': 77, '张杰': 55}

字典的删除操作

语法：dict.pop(key)
结果：获得指定key的value，同时字典被修改，指定key的数据被删除。

# 字典的删除操作
value = my_dict.pop("张杰")
print(value)            # 结果：55
print(my_dict)          # 结果：{'王力宏': 99, '周杰伦': 88, '林俊杰': 77}

字典的清空操作

my_dict.clear()

获取全部的key

语法：dict.keys()
结果：得到字典中的全部key

# 获取全部的key
keys = my_dict.keys()
print(keys)             # 结果：dict_keys(['王力宏', '周杰伦', '林俊杰'])

字典的遍历

同集合一样，字典同样不能用while循环，因为是无序的，不能使用下标索引。

# 遍历字典
for key in keys:
    print(f"字典的key是{key}")
    print(f"字典的value是{my_dict[key]}")
    
# 方法2，推荐
for key in my_dict:
    print(f"{key}的值是{my_dict[key]}")

字典的统计操作

# 字典的统计操作
num = len(my_dict)
print(num)

字典的练习

# 练习
"""
对员工信息，用字典完成数据的记录，并通过for循环，对所有级别为1的员工，，级别上升一级，薪水增加1000元
"""
practice_dict = {
    "王力宏":{"部门":"科技部","工资":3000,"级别":1},
    "周杰伦":{"部门":"市场部","工资":5000,"级别":2},
    "林俊杰":{"部门":"市场部","工资":7000,"级别":3},
    "刘德华":{"部门":"科技部","工资":4000,"级别":1},
    "张杰":{"部门":"市场部","工资":5000,"级别":2},
}
for key in practice_dict:
    if practice_dict[key]["级别"] == 1:
        practice_dict[key]["级别"] = 2
        practice_dict[key]["工资"] += 1000
print(practice_dict)

数据容器的总结与对比

数据容器的分类

数据容器的特点对比

数据容器的通用操作

容器的通用操作

首先，五种类型都可以使用for循环遍历。
但是，只有元组、字符串、列表支持while循环遍历。

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 = {"k1":1,"k2":2,"k3":3,"k4":4,"k5":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)}")     # 字符串转列表的结果是：['a', 'b', 'c', 'd', 'e', 'f', 'g']
print(f"集合转列表的结果是：{list(my_set)}")
print(f"字典转列表的结果是：{list(my_dict)}")     # 字典转列表的结果是：['k1', 'k2', 'k3', 'k4', 'k5']

# 类型转换：容器转元组
print(f"列表转元组的结果是：{tuple(my_list)}")
print(f"元组转元组的结果是：{tuple(my_tuple)}")
print(f"字符串转元组的结果是：{tuple(my_str)}")     # 字符串转列表的结果是：('a', 'b', 'c', 'd', 'e', 'f', 'g')
print(f"集合转元组的结果是：{tuple(my_set)}")
print(f"字典转元组的结果是：{tuple(my_dict)}")     # 字典转列表的结果是：('k1', 'k2', 'k3', 'k4', 'k5')

# 类型转换：容器转字符串
print(f"列表转字符串的结果是：{str(my_list)}")
print(f"元组转字符串的结果是：{str(my_tuple)}")
print(f"字符串转字符串的结果是：{str(my_str)}")
print(f"集合转字符串的结果是：{str(my_set)}")
print(f"字典转字符串的结果是：{str(my_dict)}")     # 字典转列表的结果是：{'k1': 1, 'k2': 2, 'k3': 3, 'k4': 4, 'k5': 5}

# 类型转换：容器转集合(无序、去重)
print(f"列表转集合的结果是：{set(my_list)}")
print(f"元组转集合的结果是：{set(my_tuple)}")
print(f"字符串转集合的结果是：{set(my_str)}")
print(f"集合转集合的结果是：{set(my_set)}")
print(f"字典转集合的结果是：{set(my_dict)}")

容器的通用排序功能

语句：sorted(容器，[reverse = True])，reverse = Trued代表反转。
排完序变成列表

# 正序排序
print(f"列表的排序结果：{sorted(my_list)}")
print(f"元组的排序结果：{sorted(my_tuple)}")
print(f"字符串的排序结果：{sorted(my_str)}")     # 字符串的排序结果：['a', 'b', 'c', 'd', 'e', 'f', 'g']
print(f"集合的序结果：{sorted(my_set)}")
print(f"字典的排序结果：{sorted(my_dict)}")     # 字典的排序结果：['k1', 'k2', 'k3', 'k4', 'k5']

# 倒序排序
print(f"列表的排序结果：{sorted(my_list, reverse=True)}")
print(f"元组的排序结果：{sorted(my_tuple, reverse=True)}")
print(f"字符串的排序结果：{sorted(my_str, reverse=True)}")     # 字符串的排序结果：['g', 'f', 'e', 'd', 'c', 'b', 'a']
print(f"集合的序结果：{sorted(my_set, reverse=True)}")
print(f"字典的排序结果：{sorted(my_dict, reverse=True)}")     # 字典的排序结果：['k5', 'k4', 'k3', 'k2', 'k1']

拓展：字符串如何进行大小比较

Python函数进阶

函数的多返回值

def tes_return():
    return 1,"hello",True

x,y,z = tes_return()
print(x)            # 1
print(y)            # hello
print(z)            # True

函数多种传参方式

位置参数

位置参数：调用函数时根据函数定义的参数位置来传递参数。

注意：传递的参数和定义的参数的顺序及个数必须一致。

# 位置参数
def user_info(name,age,gender):
    print(f"您的名字是{name},年龄是{age},性别是{gender}")

user_info("zmx",18,"男")

关键字参数

关键字参数：函数调用时通过键=值的形式传递参数。
作用：可以让函数更加清晰、任意使用，同时也清楚了参数的顺序要求。

注意：函数调用时，如果有位置参数时，位置参数必须在关键字参数前面，但关键字参数之间不存在先后顺序。

# 关键字参数
user_info(name="zmx",age=16,gender="男")
user_info(age=24,name="zmx",gender="男")          # 可以不按照顺序
user_info("zmx",gender="男",age=16)         # 如果有位置参数时，位置参数必须在关键字参数前面

缺省参数（默认参数）

缺省参数：缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值。

注意：所有位置参数必须出现在默认参数前，包括函数定义和调用。

# 缺省参数
def user_info2(name,age,gender="男"):
    print(f"您的名字是{name},年龄是{age},性别是{gender}")
user_info2("zmx",12)                # 您的名字是zmx,年龄是12,性别是男
user_info2("zmmx",12,"女")   # 您的名字是zmmx,年龄是12,性别是女

不定长参数(可变参数)

不定长参数：不定长参数也叫可变参数。用于不确定调用的时候会传递多少个参数（不传参也可以）的场景。

不定长参数的类型：

• 位置传递
• 关键字传递

位置传递

传出来的是元组类型

# 位置传递
def user_info3(*args):
    print(args)
user_info3("zmx",16,"男")        # ('zmx', 16, '男')

关键字传递

传出来的是字典类型

# 关键字传递
def user_info4(**args):
    print(args)
user_info4(name="zmx",age=16,gender="男")    # {'name': 'zmx', 'age': 16, 'gender': '男'}

匿名函数

函数作为参数传递

这是一种计算逻辑的传递，而非数据的传递

# 函数作为参数传递
def tes_func(computer):
    result = computer(1,2)
    print(result)

def computer(x,y):
    return x + y
tes_func(computer)              # 3

lambda匿名函数

语法：lambda 传入参数：函数体（一行代码）

# lambda匿名函数
def tes_func(computer):
    result = computer(1,2)
    print(result)
tes_func(lambda x,y : x + y)    # 3

Python文件操作

文件的编码

UTF-8是目前全球通用的编码格式。
除非有特殊需求，否则一律以UTF-8格式进行文件编码。

文件的读取

open()打开文件

语法：open(name,mode,encoding)
name：是要打开的目标文件名的字符串（可以包含文件所在的具体路径）
mode：设置打开文件的模式（只读、写入、追加等）
encoding：编码格式（一般为UTF-8）

f = open("python.txt","r",encoding="UTF-8")  # encoding位置不是第三位，要用关键字参数

注意：此时的f是open函数的文件对象，对象是Python中一种特殊的数据类型，拥有属性和方法，可以使用对象.属性或对象.方法对其进行访问。

读取文件

read()

语法：文件.read(num)
num表示要从文件读取的数据的长度（单位是字节），默认是读取全部数据。

如果在程序中多次调用read()，下一次读取时，会从上一次read的结尾开始读取。

# read读取文件
x = f.read(3)               # zmx
print(x)

realines()

readlines可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素。

# readlines读取文件
lines = f.readlines()
print(type(lines))          # <class 'list'>
print(lines)                # [' is god\n'],也是接着读取

readline()

一次只读取一行内容

# readline
line1 = f.readline()        # 读取第一行
line2 = f.readline()        # 读取第二行
print(line1)
print(line2)

for循环读取

for line in f:
    print(line)

关闭文件

close()

# 关闭文件
f.close()

如果不调用close关闭文件，同时程序没有停止运行，那么这个文件将一直被python程序占用。

with open

通过在with open的语句块总对文件进行操作，可以在操作完成后自动关闭文件。

# with open
with open("python.txt","r") as f:
    x = f.readlines()
    print(x)

文件读取的练习

# 练习
"""
打开文件word.txt，统计字符串“zmx”出现的次数
"""
with open("word.txt","r",encoding="UTF-8") as f:
    content = f.read()
    count = content.count("zmx")
    print(count)

# 方法2
f = open("word.txt","r",encoding="UTF-8")
count = 0
for line in f:
    line = line.strip()         # 取出前后空格以及换行符\n
    words = line.split(" ")
    for word in words:
        if word == "zmx":
            count += 1
print(count)
f.close()

文件的写入操作

文件不存在时，会新建文件
当文件存在时，会清空文件再写入

# 打开文件
f = open("word.txt","w",encoding="UTF-8")

# 文件写入
f.write("hello world")

# 文件内容刷新
f.flush()

注意：

• 直接调用write，内容并未真正写入文件，而是会积攒在程序的内存中，称之为缓冲区。
• 当调用flush的时候，内容才会真正写入文件。
• 这样做是为了避免频繁操作。

文件的追加操作

与写入操作相同，只是把文件模式改为“a”

# 打开文件
f = open("word.txt","a",encoding="UTF-8")

# 文件写入
f.write("hello world")
f.write("\ndog is pig")

# 文件内容刷新
f.flush()

在“a”模式下，文件不存在会创建文件，文件存在时则会在文件的最后追加写入文件。

文件操作综合案例

"""
1、读取bill.txt文件
2、将文件写入bill.txt.bak文件作为备份
3、将文件内标注为测试的数据行丢弃
"""
f = open("bill.txt","r",encoding="UTF-8")
f_b = open("bill.txt.bak","w",encoding="UTF-8")
for line in f:
    if line.count("测试") == 0:
        f_b.write(line)
    else:
        continue
f.close()
f_b.close()

Python异常、模块与包

了解异常

异常就是程序运行的过程中出现了错误

# 通过open读取一个不存在的文件
f = open("zmx.txt","r",encoding="UTF-8")  # FileNotFoundError: [Errno 2] No such file or directory: 'zmx.txt'

异常的捕获方式

捕获常规异常

基本语句：

try:
    可能发生错误的代码
except:
    如果出现异常执行的代码

try:
    f = open("zmx.txt", "r", encoding="UTF-8")
except:
    f = open("zmx.txt", "w", encoding="UTF-8")

捕获指定异常

# 捕获指定异常
try:
    print(name)
    #1/0                 # 报错，未捕获异常
except NameError as e:
    print("出现未命名的异常")

捕获多个异常

try:
    print(name)
    1/0                 # 报错，未捕获异常
except (NameError,ZeroDivisionError) as e:
    print("出现未命名，0除的异常")

捕获所有异常

# 捕获所有异常
try:
    1/0
    print(name)
except Exception as e:
    print("出现异常")

异常的finally

finally表示的是无论是否异常都要执行的代码，例如关闭文件。

# finally
try:
    f = open("zmx.txt", "r", encoding="UTF-8")
except:
    f = open("zmx.txt", "w", encoding="UTF-8")
else:
    print("没有异常")
finally:
    f.close()

异常的传递

def func1():
    print("f1开始执行")
    num = 1/0           # 0除异常
    print("f1结束")

def func2():
    print("f2开始执行")
    func1()
    print("f2结束")

def func3():
    try:
        func2()
    except Exception as e:
        print(e)

func3()                 # division by zero

Python模块

模块的导入

# 使用import导入time模块使用sleep功能（函数）
import time
print(1)
time.sleep(2)
print(2)

# 通过from导入time的sleep功能
from time import sleep
print(1)
sleep(2)
print(2)

# 使用*导入time模块的全部功能
from time import *
print(1)
sleep(2)
print(2)

# 使用as给特定功能加上别名
from time import sleep as zmx
print(1)
zmx(2)
print(2)

自定义模块并导入

# 自定义模块并导入
import my_module
my_module.tes(1,2)

Python包

安装第三方Python包

安装语句：pip install 包名称（终端输入）

下载太慢的话
使用语句： pip install -i https://pypi,tuna.tsinghua.edu.cn/simple 包名称

异常-模块-包，综合案例

"""
创建一个自定义包，名称为my_utils
在包内提供两个模块
1、str_util.py(字符串相关工具，包含)：
    1、函数：str_reverse(s)接受传入字符串，将字符串反转返回
    2、函数：substr(s,x,y)，按照下标x,y对字符串进行切片
2、file_util.py(文件处理相关工具，内含)
    1、函数：print_file_info(file_name)，接收传入文件的路径，打印文件的全部内容，
            如文件不存在则捕获异常，输出提示信息，通过finally关闭文件对象。
    2、函数：append_to_file(file_name,data)，接收文件路径以及传入数据，将数据追加写入到文件中
"""
# 新建my_utils包
# 新建两个python文档str_util.py、file_util.py
# 在str_util.py写入
def str_reverse(s):
    x = s[::-1]
    return x

def substr(s,x,y):
    x = s[x:y]
    return x

if __name__ == '__main__':
    print(str_reverse("zmx is god"))
    print(substr("zmx is god",1,3))
    
# 在file_util.py写入
def print_file_info(file_name):
    f = None
    try:
        f = open(file_name,"r",encoding="UTF-8")
        content = f.read()
        print(content)
    except Exception as e:
        print(f"程序异常，原因是：{e}")
    finally:
        if f:                       # 如果变量是None,表示False
            f.close()

def append_to_file(file_name,data):
    try:
        f = open(file_name,"a",encoding="UTF-8")
        f.write("\n")
        f.write(data)
        f.flush()
        print("已输入")
    except Exception as e:
        print(f"程序异常，原因是：{e}")
    finally:
        if f:                    # 如果变量是None,表示False
            f.close()


if __name__ == '__main__':
    print_file_info("E:/ProgramData/Python/learn_py/anaconda环境/pythonProject/python入门/7、Python文件操作/bill.txt")
    append_to_file("E:/ProgramData/Python/learn_py/anaconda环境/pythonProject/python入门/7、Python文件操作/billxxx.txt",
                   "林俊杰，2022-01-07，200000，消费，正式")

# 调用自定义包
import my_utils.str_util
from my_utils import file_util
print(my_utils.str_util.str_reverse("zmx is good"))
print(my_utils.str_util.substr("zmx is good",2,6))

file_util.append_to_file("E:/ProgramData/Python/learn_py/anaconda环境/pythonProject/python入门/7、Python文件操作/bill.txt",
                         "123")
file_util.print_file_info("E:/ProgramData/Python/learn_py/anaconda环境/pythonProject/python入门/7、Python文件操作/bill.txt")

Python数据可视化–折线图

json数据格式

json格式数据

# json格式的数据要求很严格，下面我们看一下他的要求
# json数据的格式可以是：
{"name":"admin","age":18}
# 也可以是
[{"name":"admin","age":18},{"name":"root","age":16},{"name":"pig","age":12}]

python数据和json数据的相互转化

# 导入json模块
import json

# 准备符合格式json格式要求的python数据
data = [{"name":"admin","age":18},{"name":"root","age":16},{"name":"pig","age":12}]

# 通过json.dumps(data)把python数据转化为json数据
data = json.dumps(data)

# 通过json.loads(data)把json数据转化为python数据
data = json.loads(data)

pyecharts模块介绍

官方网站：pyecharts.org
画廊：gallery.pyecharts.org

pyecharts入门使用

# 导包
from pyecharts.charts import Line

# 创建一个折线图对象
line = Line()

# 给折线图添加x轴对象
line.add_xaxis(["中国","美国","日本"])

# 给折线图添加y轴对象
line.add_yaxis("GDP",[30,20,10])

# 通过render方法，将代码生成为图像
line.render()
# 生成了一个html文件

pyecharts中有很多的配置选项，常用两个类别的选项：
1、全局配置选项
2、系列配置选项

全局配置选项

set_global_opts

# 导包
from nltk import toolbox
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.set_global_opts(
    title_opts=TitleOpts(title="GDP展示",pos_left="center",pos_bottom="1%"), # pos_left 位置
    legend_opts=LegendOpts(is_show=True),                                   # 图例
    toolbox_opts=ToolboxOpts(is_show=True),                                 # 工具箱
    visualmap_opts=VisualMapOpts(is_show=True)                              # 视觉映像
)

# 通过render方法，将代码生成为图像
line.render()
# 生成了一个html文件

数据处理

import json
# 处理数据
f_us = open("美国.txt","r",encoding="UTF-8")
us_data = f_us.read()           # 美国的全部内容

# 去掉不符json规范的开头
us_data = us_data.replace("jsonp_1629344292311_69436(","")

# 去掉不符json规范的结尾
us_data = us_data[:-2]

# json转python字典
us_dict = json.loads(us_data)

# 获取trend key
trend_data = us_dict["data"][0]["trend"]

# 获取日期数据，用于x轴，取2020年（到314下标结束）
x_data = trend_data["updateDate"][:314]

# 获取确认数据，用于y轴，取2020年（到315下标结束）
y_data = trend_data["list"][0]["data"][:314]

创建折线图

from pyecharts.charts import Line
from pyecharts.options import TitleOpts,LegendOpts,ToolboxOpts,VisualMapOpts
from rich.markup import render
# 生成图表
line = Line()

# 添加x轴数据
line.add_xaxis(us_x_data)

# 添加y轴数据
line.add_yaxis("美国确诊人数",us_y_data)

# 设置全局配置项
line.set_global_opts(
    title_opts=TitleOpts(title="GDP展示",pos_left="center",pos_bottom="1%"), # pos_left 位置
    legend_opts=LegendOpts(is_show=True),                                   # 图例
    toolbox_opts=ToolboxOpts(is_show=True),                                 # 工具箱
    visualmap_opts=VisualMapOpts(is_show=True)                              # 视觉映像
)


# 调用render，生成图表
line.render()

# 关闭对象文件
f_us.close()

Python数据可视化–地图可视化

from pyecharts.charts import Map
from pyecharts.options import VisualMapOpts
# 准备地图对象
map = Map()

# 准备数据
data = [
    ("北京",99),
    ("上海",199),
    ("湖南",299),
    ("台湾",399)
]

# 添加数据
map.add("测试地图",data,"china")

# 设置全局选项
map.set_global_opts(
    visualmap_opts=VisualMapOpts(           # 可视
        is_show=True,                  
        is_piecewise=True,
        pieces=[
            {"min":1,"max":9,"label":"1-9","color":"#CCFFFF"},
            {"min":10,"max":99,"label":"10-99","color":"#CC6666"},
            {"min":100,"max":999,"label":"100-999","color":"#990033"},
        ]
    )
)

# 绘图
map.render()

全国疫情绘制

import json
from pyecharts.charts import Map
from pyecharts.options import VisualMapOpts,TitleOpts

f = open("疫情.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,                  # 是否分段
        pieces=[
            {"min":1,"max":99,"lable":"1-99","color": "#CCFFFF"},
            {"min":100,"max":999,"lable":"100-999","color": "#FFFF99"},
            {"min":1000,"max":4999,"lable":"1000-4999","color": "#FF9966"},
            {"min":5000,"max":9999,"lable":"5000-9999","color": "#FF6666"},
            {"min":10000,"max":99999,"lable":"10000-99999","color": "#CC3333"},
            {"min":100000,"lable":"100000-","color": "#990033"},
        ]
    )
)

map.render("全国疫情地图.html")

Python数据可视化–柱状图

基础柱状图

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")

基础时间线柱状图

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

# 使用Bar构建基础柱状图
bar1 = Bar()

# 添加x轴的数据
bar1.add_xaxis(["中国","美国","英国"])
# 添加y轴的数据
bar1.add_yaxis(
"GDP",[30,20,10],label_opts=LabelOpts(
        position="right"            # 将数值显示在柱子上方
    )
)


bar2 = Bar()
bar2.add_xaxis(["中国","美国","英国"])
bar2.add_yaxis(
"GDP",[40,70,25],label_opts=LabelOpts(
        position="right"            # 将数值显示在柱子上方
    )
)

bar3 = Bar()
bar3.add_xaxis(["中国","美国","英国"])
bar3.add_yaxis(
"GDP",[60,120,55],label_opts=LabelOpts(
        position="right"            # 将数值显示在柱子上方
    )
)

# 构建时间线对象
timeline = Timeline({"theme": ThemeType.LIGHT})  # 更换主题
# 在时间线内添加柱状图对象
timeline.add(bar1,"点1")
timeline.add(bar2,"点2")
timeline.add(bar3,"点3")

# 自动播放设置
timeline.add_schema(
    play_interval=1000,         # 自动播放的时间间隔，单位：毫秒
    is_timeline_show=True,      # 是否在自动播放的时候显示时间线
    is_auto_play=True,          # 是否自动播放
    is_loop_play=True           # 是否循环播放
)

# 绘图
timeline.render("基础时间线柱状图.html")

GDP动态图表绘制

列表的sort方法

my_list = [["a",33],["b",55],["c",11]]

# 排序，基于带名函数
def choose_sort_key(element):
    return element[1]
my_list.sort(key=choose_sort_key,reverse=True)
print(my_list)              # [['b', 55], ['a', 33], ['c', 11]]
# 排序，基于lambda匿名函数
my_list.sort(key=lambda element: element[1],reverse=True)
print(my_list)              # [['b', 55], ['a', 33], ['c', 11]]

数据处理

from pyecharts.charts import Bar, Timeline
from pyecharts.globals import ThemeType
from pyecharts.options import *
from sphinx.builders.latex import Theme
# 读取数据
f = open("1960-2019全球GDP数据.csv","r",encoding="GB2312")
data_lines = f.readlines()
f.close()
# 删除第一行数据
data_lines.pop(0)
# 将数据转化为字典存储
data_dict={}
for line in data_lines:
    year = int(line.split(",")[0])
    counter = line.split(",")[1]
    gdp = float(line.split(",")[2])   # float函数可以取消科学计数法
    # 如何判断字典里面有没有指定的key

    try:
        data_dict[year].append([counter,gdp])
    except KeyError:
        data_dict[year] = []
        data_dict[year].append([counter, gdp])

绘图

# 创建时间线对象
timeline = Timeline({"Theme": ThemeType.LIGHT})
# 年份排序
sorted_year_list = sorted(data_dict.keys())
for year in sorted_year_list:
    data_dict[year].sort(key=lambda element: element[1],reverse=True)  # 按gdp排序
    # 取出前八名的国家
    year_data = data_dict[year][0:8]
    x_data = []
    y_data = []
    for country_gdp in year_data:
        x_data.append(country_gdp[0])       # x轴添加国家
        y_data.append(country_gdp[1])       # 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()
    # 设置标题
    bar.set_global_opts(
        title_opts=TitleOpts(title=f"{year}年全球前8GDP数据")
    )
    timeline.add(bar,str(year))

# 自动播放设置
timeline.add_schema(
    play_interval=1000,         # 自动播放的时间间隔，单位：毫秒
    is_timeline_show=True,      # 是否在自动播放的时候显示时间线
    is_auto_play=True,          # 是否自动播放
    is_loop_play=False           # 是否循环播放
)

# 绘图
timeline.render("动态GDP图表.html")