Python学习笔记

文档是在B站学习“黑马程序员”Python课程记录的笔记，供自己和大家参考，原视频链接:
https://www.bilibili.com/video/BV1qW4y1a7fU/?spm_id_from=333.337.search-card.all.click
目前是第一阶段结束第二章结束，后面要学习mysq了！准备单独写一篇！

第1章

• 主要讲的python的安装，此处省略

第2章

01 字面量

常见的值类型

python中常用的有6种（数据）类型

类型	描述	说明
数字（Number）	支持 - 整数（int） - 浮点数（float） - 布尔（bool）
字符串（String）	描述文本的一种类型
列表（List）	有序的可变序列
元组（Tuple）	有序的不可变序列
集合（Set）	无序不重复集合
字典（Dictionary）	无序Key-Value集合

02 注释

• 单行注释：以#开头

  # 我是单行注释
  print("Hello World")
  

• 多行注释：以一对三个双引号引起来

  • 一般对Python文件、类或方法进行注释

  """
  	我是多行注释
  	哈哈哈哈
  	哈哈哈
  """
  print("第一行")
  print("第二行")
  print("第三行")
  

03 变量

• 例如

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

• print(内容1，内容2，……，内容N)

04 数据类型

• 验证数据类型

  print(type("黑马程序员"))
  print(type(666))
  print(type(13.14))
  
  name = "zhangsan"
  name_type = type(name)
  print(name_type)
  

05 数据类型转换

语句	说明
int(x)	将x转换为一个整数
float（x）	将x转换成为一个浮点数
str(x)	将对象x转换为字符串

• 示例

  num_str = str(11)
  print(type(num_str), num_str)
  
  float_str = str(13.14)
  print(type(float_str), float_str)
  
  num = int ("11")
  print(type(int), num)
  
  num2 = float ("11.234")
  print(type(int), num2)
  
  # 整数转浮点数
  float_num = float(11)
  print(type(float_num),float_num)
  
  #浮点数转整数
  int_num = int(float(11.345))
  print(type(int_num), int_num)
  

06 标识符

标识符命名中，只允许出现：

• 英文 大小写敏感
• 中文 不推荐中文
• 数字 不能以数字开头
• 下划线（_）

这四类元素

• 变量的命名规范
  • 见名知意
  • 下划线命名法
  • 英文字母全小写

07 运算符

运算符	描述	实例
+	加
-	减
*	乘
/	除
//	取整数	9//2 输出结果4 9.0//2.0 输出结果4.0
%	取余数	9 % 2 输出结果1
**	指数	2的3次方，输出结果8

复合赋值运算符

运算符	描述	实例
+=	加	c += a 等效与c = c + a
-=	减	c -= a 等效与c = c - a
*=	乘	c *= a 等效与c = c * a
/=	除	c /= a 等效与c = c / a
//=	取整数	c //= a 等效与c = c // a
%=	取余数	c %= a 等效与c = c % a
**=	指数	c **= a 等效与c = c** a

08 字符串的三种定义方式

1. 单引号定义

2. 双引号定义

3. 三引号定义

   name = '黑马程序员'
   name = "黑马程序员"
   name = """黑马
             程序员"""
   print(name)
   # 使用转义字符 \ 解除引号效用
   name = "\"黑马程序员\""
   name1 = '\'黑马程序员\''
   print(name, name1)
   

09 如何拼接字符串

name = "zhangsan"
age = 20
print(name + "今年" + age + "岁了！")
# 无法和数字拼接

10 字符串格式化

• 占位**%s**，多个变量占位，变量需要用括号，并按顺序填写

  name = "zhangsan"
  age = 20
  print("我是%s,今年%s岁了!" % (name, age))
  

• 常用的三种数据类型占位

  格式符号	转化
  %s	将内容转换为字符串，放入占位位置
  %d	将内容转换为整数，放入占位位置
  %f	将内容转换为浮点型，放入占位位置

  name = "zhangsan"
  age = 20
  high = 167.88
  print("我是%s,今年%d岁了! 我身高%f" % (name, age, high))
  

11 字符串格式化的精度控制

• 辅助符号：“m.n”

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

• 示例

  • %5d：表示将整数的宽度控制在5位

    如数字11，设置为5d，就会变成 [空格][空格][空格]11

  • %5.2f：表示将宽度设置为5，小数点精度设置为2

    如，对11.345设置了%7.2f后，结果是 [空格][空格]11.35 空格补全，小数部分限制2位精度后，四舍五入为.35

  • %.2f：表示不限制宽度，只设置小数点精度为2，如11.345设置%.2f后，结果是11.35

    num1 = 11
    num2 = 11.345
    print("数字11宽度限制5，结果是：%5d" % num1)
    print("数字11宽度限制1，结果是：%1d" % num1)
    print("数字11.345宽度限制7，小数点精度2，结果是：%7.2d" % num2)
    print("数字11.345宽度不限制，小数点精度2，结果是：%.2d" % num2)
    
    # 数字11宽度限制5，结果是：   11
    # 数字11宽度限制1，结果是：11
    # 数字11.345宽度限制7，小数点精度2，结果是：     11
    # 数字11.345宽度不限制，小数点精度2，结果是：11
    

12 字符串格式化方式2

• 语法：f"内容{变量}"

  不理会类型，不做精度控制

  name = "zhangsan"
  age = 20
  high = 167.88
  print(f"我是{name}, 今年{age}岁了，身高{high}")
  

13 对表达式的格式化

print("1 * 1 的结果是：%d" % (1 * 1))
print(f"1 * 2 的结果是：{1 * 2}")
print("字符串在Python中的类型名称是：%s" % type('字符串'))

# 1 * 1 的结果是：1
# 1 * 2 的结果是：2
# 字符串在Python中的类型名称是：

小练习

name = "传智播客"
stock_price = 19.99
stock_code = '003032'
stock_price_daily_growth_factor = 1.2
growth_days = 7
print(f"公司：{name}, 股票代码：{stock_code}, 当前股价：{stock_price}")
print("每日增长系数是：%.1f, 经过%d天的增长后，股价达到了：%.2f" % (stock_price_daily_growth_factor, growth_days,stock_price*stock_price_daily_growth_factor**growth_days))

# 公司：传智播客, 股票代码：003032, 当前股价：19.99
# 每日增长系数是：1.2, 经过7天的增长后，股价达到了：71.63

015 数据输入（input语句）

name = input("请告诉我你是谁？")
print("我知道了，你是：%s" % name)

num = input("请告诉我你的银行卡密码：")
num = int(num)
print("你的银行卡密码类型是：", type(num))

获取到的数据永远都是字符串类型，如果需要其他类型需要转换

• 小练习

  user_name = input("请输入您的用户名:")
  user_type = input("请输入您的用户类型:")
  print(f"您好！{user_name}, 您是尊贵的：{user_type}用户，欢迎您的光临。")
  

第3章

01 布尔类型和比较运算符

• 布尔类型

  True 表示真

  False表示假

• 比较运算符

  • == 判断是否相等
  • != 是否不相等
  • > 是否大于
  • < 是否小于
  • >= 是否大于等于
  • <= 是否小于等于

02 if语句的基本格式

03 案例练习

# 获取键盘输入
age = int(input("请输入你的年龄："))

if age >= 18:
    print("您已成年，游玩需要买票，10元")

print("祝您游玩愉快！")

04 if else组合判断语句

# 获取键盘输入
age = int(input("请输入你的年龄："))

if age >= 18:
    print("您已成年，游玩需要买票，10元")
else:
    print("您未成年，可以免费游玩")

print("祝您游玩愉快！")

06 if_elif_else组合判断语句

height = int(input("请输入你的身高（cm）："))
vip_level = int(input("请输入你的VIP等级（1-5）："))

if height < 120 :
    print("身高小于120cm，可以免费。")
elif vip_level > 3:
    print("vip等级大于3，可以免费。")
else:
    print("不好意思，所有条件都不满足，需要买票10元。")

08 判断语句的嵌套

09 判断语句综合案例

import random
num = random.randint(1,10)

guess_num = int(input("输入你要猜测的数字："))

if guess_num == num:
    print("恭喜，第一次就猜中了")
else:
    if guess_num > num:
        print("你猜测的数字大了")
    else:
        print("你猜测的数字小了")

    guess_num = int(input("再次输入你要猜测的数字："))
    if guess_num == num:
        print("恭喜，第二次猜中了")
    else:
        if guess_num > num:
            print("你猜测的数字大了")
        else:
            print("你猜测的数字小了")

        guess_num = int(input("再次输入你要猜测的数字："))
        if guess_num == num:
            print("恭喜，第三次猜中了")
        else:
            print("三次机会用完了！没有猜中")

第4章

01 while循环的应用基础

i = 0
while i < 100:
    print("小美，我喜欢你")
    i = i + 1

• 计算1-100的和

  i = 1
  sum = 0
  while i<= 100:
      i += 1
      sum =sum +i
  print(f"1到100和是:{sum}")
  

• 猜数字案例

  import random
  num = random.randint(1,100)
  count = 0
  flag = True
  while flag:
      guess_num = int(input("请输入你猜测的数字："))
      count += 1
      if guess_num == num:
          print("猜中了！")
          flag = False
      elif guess_num > num:
          print("猜大了")
      else:
          print("猜小了")
  
  print(f"你总共猜测了{count}次。")
  

04 while循环的嵌套应用

# 外层：表白100天的控制
# 内层：每天表白都送10支玫瑰花的控制

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

    j = 1
    while j <= 10:
        print(f"送给小宇的第{j}支玫瑰花")
        j += 1
    print("小宇，我喜欢你！")
    i += 1
print(f"坚持到第{i-1}天，表白成功")

05 while循环的嵌套案例

打印9*9乘法表

• print()不换行

  print("Hello", end='')
  print("Hello", end='')
  

• 制表符：\t

  print("Hello World")
  print("itheima best")
  print("Hello\tWorld")
  print("itheima\tbest")
  
  # Hello World
  # itheima best
  # Hello	World
  # itheima	best
  

  i = 1
  while i <= 9:
      print(f"")
      j = 1
      while j<= i:
          print(f"{j}*{i}={i*j}\t",end='')
          j += 1
      i += 1
  

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-U4bViP2V-1686107515096)(C:\Users\28193\AppData\Roaming\Typora\typora-user-images\image-20230527200524459.png)]

06 for循环的基础语法

• 遍历字符串

  name = "itheima is a brand of itcast"
  count = 0
  for x in name:
      if x == "a":
          count = count + 1
  print(f"itheima is a brand of itcast中共含有：{count}字母a")
  

08 range语句

• 语法1：

  range(num) 获取一个从0开始，到num结束的数字序列（不含num本身）

  例如range(5)取得的数据是[0, 1, 2, 3, 4]

• 语法2：

  获得一个从num开始，到num2结束的数字序列（不含num2本身）

  如，range(5, 10)取得的数据是[5, 6, 7, 8, 9,]

• 语法3

  range(num1, num2, step)

  获得一个从num1开始，num2结束的数字序列（不含num2本身）

  数字之间的步长，以step为准，step默认为1

  如，range(5,10,2)取得的数据是[5, 7 ,9]

09 循环临时变量作用域

i = 0  #全局变量
for i in range(5):
    print(i) 

print(i)

不建议这么做，需要定义全局变量

10 for循环的嵌套使用

# 坚持表白100天，每天都送10朵花
for i in range(1,101):
    print(f"今天是向小美表白的第{i}天，加油坚持")
    for j in range(1,11):
        print(f"给小美送的第{j}朵玫瑰花")

11 乘法表

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aZ1e5Fzj-1686107515097)(C:\Users\28193\AppData\Roaming\Typora\typora-user-images\image-20230527211438931.png)]

12 contine 和 break

• continue关键字用于：中断本次循环，直接进入下一次循环

• continue可以用于：for 和while循环，效果一致

  for i in range(5):
      print("语句1")
      for j in range(5):
          print("语句2")
          continue
          print("语句3")
      print("语句4")
  

  for i in range(6):
      print("语句1")
      for j in range(1,6):
          print("语句2")
          break
          print("语句3")
      print("语句4")
  

  13 综合案例

  import random
  count = 0
  for i in range(1,21):
      score = random.randint(1, 10)
      if sum == 0:
          print(f"工资发完了，下个月领取吧！")
          break
      if score >=5:
          count = count + 1
          sum = 10000 - 1000 * count
          print(f"向员工{i}发放工资1000元，账户余额还剩余{sum}元。")
      else:
          print(f"员工{i}，绩效分{score}，低于5，不发工资，下一位。")
          continue
  

第5章

02 函数的基础

def 函数名 (传入参数):
	函数体
	return 返回值

• 参数不需要，可以省略
• 返回值不需要，可以省略

04 函数的传入参数

def add(x, y):
    result = x + y
    print(f"{x}+{y}={result}")

add(3, 5)

• x, y 是形式参数
• 函数调用中的3和5是实际参数，需要按顺序传递

综合案例

def Tem(x):
    print(f"请出示您的健康码以及72小时核酸证明，并配合测量体温！\n体温测量中，",end='')
    if x <= 37.5:
        print(f"您的体温是:{x}度，体温正常请进！")
    else:
        print(f"您的体温是：{x}度，需要隔离！")
    print("------------------------------------------------")

Tem(35)
Tem(39)

06 函数的返回值

• 所谓“返回值”，就是程序中函数完成事情后，最后给调用者的结果

def 函数(参数……):
	函数体
	return 返回值

变量 = 函数(参数)

def add(x, y):
    result = x + y
    return result
	print("------") #不会执行

r = add(2, 5)
print(r)

07 函数返回值-None

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

result = say_hi()
print(f"无返回值函数，返回的内容是：{result}")
print(f"无返回值函数，返回的内容类型是：{type(result)}")

• if 判断中None表示False

• 用于声明无初始内容变量

  name = None

08 函数的说明文档

def add(x, y):
    """
    ada函数可以接受两个参数，进行两数相加功能
    :param x: 其中一个数字
    :param y: 其中另一个数字
    :return: 两数相加的结果
    """
    result = x + y
    print(f"2数相加的结果是：{result}")
    return result

09 函数的嵌套调用

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

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

    fun_b()

    print("---3---")

fun_a()

10 变量在函数中的作用域

• 局部变量

  定义在函数体的内部，只在函数体内部生效

• 全局变量

  在函数体内外都可以使用

  num = 200
  def test_a():
      print(f"test_a:{num}")
  
  def test_b():
      print(f"test_b:{num}")
  
  test_a()
  test_b()
  

• 使用global关键字 可以在函数内部声明变量为全局变量

  num = 100
  def testA():
      print(num)
  
  def testB():
      global num
      num = 200
      print(num)
  
  testA()
  testB()
  print(num)
  

11 综合案例

money = 5000000
name = input("请输入你的名字：")
def query(show_header):
    if show_header:
        print(f"-------------查询余额-------------")
    print(f"{name}，您好，您的余额剩余：{money}元")
def cuk(x):
    global money
    money = money + x
    print(f"---------------存款---------------")
    print(f"{name}，您好，您存款{x}元成功")
    query(False)

def quk(x):
    global money
    money -= x
    print(f"---------------取款---------------")
    print(f"{name}，您好，您取款{x}元成功")
    query(False)

def main():
    print("------------------主菜单--------------------")
    print(f"{name}，您好，欢迎来到未来银行ATM。请选择操作：")
    print(f"查询余额\t[输入1]")
    print(f"存款\t\t[输入2]")
    print(f"取款\t\t[输入3]")
    print(f"退出\t\t[输入4]")
    return input("请输入您的选择：")

while True:
    keyword_input = main()
    if keyword_input == "1":
        query(True)
        continue
    elif keyword_input == "2":
        x = int(input("您想要存入多少钱？请输入？"))
        cuk(x)
        continue
    elif keyword_input == "3":
        x = int(input("您想要取出多少钱？请输入？"))
        quk(x)
        continue
    else:
        break

第6章

01 数据容器的入门

• 数据容器类型
  1. 列表（list）
  2. 元组（temple）
  3. 字符串（str）
  4. 集合（set）
  5. 字典

02 列表

• 基本语法：

  字面量

  [元素1，元素2，元素3，元素4，……]

  定义变量

  变量名称 = [元素1，元素2，元素3，元素4，……]

  定义空列表

  变量名称 = []

  变量名称 = list()

my_list = ['ithema', 'itcast', 'python']
print(my_list)
print(type(my_list))

my_list = ['itheima', 666, True]
print(my_list)
print(type(my_list))

# 定义一个嵌套列表
my_list = [['1', '2', '3'], ['4', '5', '6']]
print(my_list)
print(type(my_list))

• 列表的下标索引

• 列表[下标索引]，从前向后从0开始，每次+1， 从后向前从-1开始，每次-1

  my_list = [['1', '2', '3'], ['4', '5', '6']]
  print(my_list[0])
  print(my_list[1])
  print(my_list[0][2])
  print(my_list[1][1])
  
  # 通过下标索引取出对应位置的数据
  my_list = ['Tom', 'Lily', 'Rose']
  print(my_list[0])
  print(my_list[1])
  print(my_list[2])
  
  print(my_list[-1])
  print(my_list[-2])
  print(my_list[-3])
  

04 列表的常用操作方法

使用方式	作用
列表.append(元素)	向列表中追加一个元素
列表.extend(元素)	将数据容器的内容依次取出，追加到列表尾部
列表.insert(下标，元素)	在指定下标处，插入指定的元素
del 列表[下标]	删除列表指定下标元素
列表.pop(下标)	删除列表指定下标元素
列表.remove(元素)	从前向后，删除此元素第一个匹配项
列表.clear()	清空列表
列表.count(元素)	统计此元素在列表中出现的次数
列表.index(元素)	查找指定元素在列表的下标，找不到报错ValueError
len(列表)	统计容器内有多少元素

my_list = ['itcast', 'itheima', 'python']
# 查找元素在列表内的下标索引
index = my_list.index('itheima')
print(index)
# 如果被查找的元素不存在，会报错
# index = my_list.index('hello')
# print(f"hello在列表中的下标索引值是：")
# 修改特定元素的下标索引值
my_list[0] = '教育'
print(my_list)
# 在指定下标位置插入元素
my_list.insert(1, 'best')
print(my_list)
# 在尾部追加单个新元素
my_list.append('zhangsan')
print(my_list)
# 在列表尾部追加一批新元素
my_list2 = [1, 2, 3]
my_list.extend(my_list2)
print(my_list)
# 删除元素
my_list = ['itcast', 'itheima', 'python']
# 1.通过下标指定元素进行删除
del my_list[2]
print(my_list)
#2.使用pop方法删除
my_list = ['itcast', 'itheima', 'python']
element = my_list.pop(2)
print(element)
my_list = ['itcast', 'itheima', 'python']
# 删除某元素在列表中的第一个匹配项
my_list = ['itcast','itheima', 'itcast', 'itheima', 'python']
my_list.remove('itheima')
print(my_list)
# 清空列表
my_list.clear()
print(my_list)
# 统计某元素在列表中的数量
my_list = ['itcast','itheima', 'itcast', 'itheima', 'python']
count = my_list.count('itheima')
print(count)
#统计列表中全部的元素数量
my_list = ['itcast','itheima', 'itcast', 'itheima', 'python']
count = len(my_list)
print(count)

05 案例练习

age = [21, 25, 21, 23, 22, 20]
age.append(31)
print(age)
age1 = [29, 33, 30]
age.extend(age1)
print(age)
num1 = age[0]
print(num1)
num2 = age[-1]
print(num2)
a = age.index(31)
print(a)

06 列表的循环遍历

• 列表的遍历 - while循环

  index = 0
  while index <len(列表)：
  	元素 = 列表
  	对元素进行处理
  	index += 1
  

  def list_while_func():
      """
      使用while循环遍历列表的演示函数
      :return:
      """
      my_list = ['itcast', 'itheima', 'python']
      index = 0
      while index < len(my_list):
          element = my_list[index]
          print(f"列表的元素：{element}")
          index += 1
  list_while_func()
  

• 列表的遍历 - for循环

  for 临时变量 in 数据容器：
  	对临时变量进行处理
  

  def list_for_func():
      """
      使用for循环遍历列表的演示函数
      :return:
      """
      my_list = [1, 2, 3, 4, 5]
      for element in my_list:
          print(element)
  list_for_func()
  

• 练习

  oushu1 = []
  oushu2 = []
  index = 0
  while index < len(nums):
      if nums[index] % 2 ==0:
          oushu1.append(nums[index])
      index += 1
  print(oushu1)
  for num in nums:
      if num %2 == 0:
          oushu2.append(num)
  print(oushu2)
  

07 元组的定义和操作

• 元组使用小括号，逗号隔开

  变量名称 = ()

  变量名称 = tuple()

• 注意：元组只有一个数据，这个数据后面要加上逗号。

  t1 = (1, 'Hello', True)
  print(t1)
  t4 = ('Hello',)
  print(f"{type(t4)}")
  # 元组的嵌套
  t5 = ((1, 2, 3), (4, 5, 6))
  print(f"t5的类型是：{type(t5)}，内容是{t5}")
  # 下标索引取出内容
  num = t5[1][2]
  print(f"从嵌套元组中取出的数据是：{num}")
  

• 元组的操作

  • index() 查找某个数据，如果数据存在返回对应的下标，否则报错
  • count() 统计某个数据在当前元组出现的次数
  • len() 统计元组内的元素个数

• 支持for和while循环

• 元组只读，不可修改

• 可以修改元组内的list内容(修改元素、增加、删除、反转等)

  t9 = (1, 2, ['itheima', 'itcast'])
  t9[2][0] = "zhangsan"
  t9[2][1] = "lisi"
  print(t9)
  

• 练习

  message = ('zhangsan', 11, ['football', 'music'])
  num1 = message.index(11)
  print(num1)
  name = message[0]
  print(name)
  message[2].remove('football')
  print(message)
  message[2].append('coding')
  print(message)
  

08 字符串的定义和操作

my_str = "itheima and incast"
value = my_str[2]
value2 = my_str[-16]
print(value)
print(value2)

• 同元组一样，字符串是一个：无法修改的数据容器

• 下标索引

  my_str = "itheima and incast"
  value = my_str.index('and')
  print(value)
  

• 字符串的转换

  my_str = "itheima and itcast"
  new_str = my_str.replace('it', "程序")
  print(my_str)
  print(new_str)
  

• 字符串的分割

  my_str = "hello python itheima itcast"
  my_str_list = my_str.split(" ")
  print(my_str_list)
  

• 字符串的规整操作

  my_str = "  itheima itcast  "
  new_my_str = my_str.strip()
  print(new_my_str)  #不传入参数，取出收尾空格
  my_str = "12itheima itcast21"
  new_my_str = my_str.strip('12') 
  print(new_my_str)
  

• 统计字符串的长度

  my_str = "itheima itcast"
  count = my_str.count("it")
  print(count)
  length = len(my_str)
  print(length)
  

• 字符串的遍历

  支持for和while循环

• 小练习

  str = "itheima itcast boxuegu"
  count = str.count("it")
  print(count)
  new_str = str.replace(" ", "|")
  print(new_str)
  str_list = new_str.split("|")
  print(str_list)
  

10 数据容器（序列）的切片

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

• 切片操作

  语法：序列[起始下标:结束下标:步长]

  步长表示：

  • 步长1表示：一个个取元素
  • 步长2表示：每次跳过一个元素取
  • 步长N表示：每次跳过N-1个元素取
  • 步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）

  my_list = [0, 1, 2, 3, 4, 5, 6]
  result1 = my_list[1:4]
  print(result1)
  
  my_tuple = (0, 1, 2, 3, 4, 5, 6)
  result2 = my_tuple[:]
  print(result2)
  
  my_str = "01234567"
  result3 = my_str[::2]
  print(result3)
  
  my_str = "01234567"
  result4 = my_str[::-1]
  print(result4)
  
  my_list = [0, 1, 2, 3, 4, 5, 6]
  result5 = my_list[3:1:-1]
  print(result5)
  
  my_tuple = (0, 1, 2, 3, 4, 5, 6)
  result6 = my_tuple[::-2]
  print(result6)
  

12 集合的定义和操作

• 语法

  变量名称 = {元素，元素，元素}

  变量名称 = set()

  my_set = {"张三", "李四", "王五", "张三", "李四", "王五", "张三", "李四", "王五"}
  my_set_empty = set()
  print(f"my_set的内容是：{my_set}，类型是：{type(my_set)}")
  print(f"my_set的内容是：{my_set_empty }，类型是：{type(my_set_empty)}")
  

• 集合内容不能重复

• 无序的，不支持下标索引访问

• 是允许修改的

  my_set.add('python')
  my_set.add("张三")
  print(f"my_set添加元素后的结果是：{my_set}")
  my_set.remove("python")
  print(f"my_移除python元素后的结果是：{my_set}")
  element = my_set.pop()
  print(f"集合被取出元素是：{element}")
  my_set.clear()
  print(my_set)
  

• 取出2个集合的差集

  语法：集合1.difference(集合2)

  功能：取出集合1和集合2的差集（集合1有而集合2没有的）

  结果：得到一个新集合，集合1和集合2不变

  set1 = {1, 2 ,3}
  set2 = {1, 5, 6}
  set3 = set1.difference(set2)
  print(set1)
  print(set2)
  print(set3)
  

• 消除2个集合的差集

  语法：集合1.difference_update(集合2)

  功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素

  结果：集合1被修改，集合2不变

  set1 = {1, 2 ,3}
  set2 = {1, 5, 6}
  set1.difference_update(set2)
  print(set1)
  print(set2)
  

• 2个集合合并

  语法：集合1.union(集合2)

  功能：将集合1和集合2组合成新集合

  结果：得到新集合，集合1和集合2不变

  set1 = {1, 2 ,3}
  set2 = {1, 5, 6}
  set3 = set1.union(set2)
  print(set1)
  print(set2)
  print(set3)
  

• 统计集合元素数量

  num = len(set3)
  print(num)
  

• 集合的遍历

  不能用while循环

  可以用for循环

  for i in set3:
      print(f"集合的元素有：{i}")
  

14 字典的定义

• 语法

  my_dict = {key1:value1, key2:value2}

  my_dict = dict()

  dict1 = {"zhangsan":80, "lisi":90, "wangwu":95}
  dict2 = {}
  dict3 = dict()
  print(f"字典1的内容是：{dict1}，类型是{type(dict1)}")
  print(f"字典1的内容是：{dict2}，类型是{type(dict2)}")
  print(f"字典1的内容是：{dict3}，类型是{type(dict3)}")
  

• key不能重复

• 从字典中通过key获取value的值

  socre = dict1["lisi"]
  print(socre)
  

• 字典的嵌套

  stu_ccore = {
      "zhangsan": {
          "语文": 77,
          "数学": 66,
          "英语": 33
  
      },
      "lisi": {
          "语文": 88,
          "数学": 86,
          "英语": 55
      },
      "wangwu": {
          "语文": 99,
          "数学": 96,
          "英语": 66
      }
  }
  print(f"学生的考试信息是{stu_ccore}")
  score = stu_ccore["zhangsan"]["语文"]
  print(score)
  

15 字典的常用操作

• 新增/修改元素

  语法:字典[key] = value

  stu_ccore = {"zhangsan": 90, "lisi": 98, "wangwu": 89}
  stu_ccore["zhaoliu"] = 86
  print(stu_ccore)
  stu_ccore["zhangsan"] = 60
  print(stu_ccore)
  

• 删除元素

  score = stu_ccore.pop("zhangsan")
  print(stu_ccore, score)
  

• 清空字典

  stu_ccore.clear()
  print(stu_ccore)
  

• 取出全部key

  stu_ccore = {"zhangsan": 90, "lisi": 98, "wangwu": 89}
  stus = stu_ccore.keys()
  print(stus)
  # 遍历字典
  # 方式1
  for key in stus:
      print(f"字典的key是：{key}")
      print(f"字典的value是：{stu_ccore[key]}")
  # 方式2
  for key in stu_ccore:
      print(f"字典的key是：{key}")
      print(f"字典的value是：{stu_ccore[key]}")
  # 统计字典的元素数量
  num = len(stu_ccore)
  print(num)
  

16 练习

emps = {
    "zhangsan": {
        "部门": "科技部",
        "工资": 3000,
        "级别": 1
    },
    "lisi": {
        "部门": "市场部",
        "工资": 5000,
        "级别": 2
    },
    "wangwu":{
        "部门": "市场部",
        "工资": 7000,
        "级别": 3
    },
    "zhaoliu":{
        "部门": "科技部",
        "工资": 4000,
        "级别": 1
    },
    "liqi":{
        "部门": "市场部",
        "工资": 6000,
        "级别": 2
    }
}
for key in emps:
    if emps[key]["级别"] == 1:
        emps[key]["级别"] += 1
        emps[key]["工资"] += 1000
print(emps)

17 5类数据容器的总结对比

• 是否支持下标索引

  • 支持：列表，元组，字符串 ——序列类型
  • 不支持：集合、字典 ——非序列类型

• 是否支持重复元素

  • 支持：列表，元组，字符串 ——序列类型
  • 不支持：集合、字典 ——非序列类型

• 是否可以修改

  • 支持：列表，集合，字典
  • 不支持：元组，字符串

18 数据容器的通用操作

• 数据容器的通用功能

  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}
  # 长度
  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)}")
  # 容器类型转换
  # …………………………省略
  

• 通用排序功能

  sorted(容器，[reverse = True])

  print(f"列表对象的排序结果：{sorted(my_list)}")
  print(f"元组对象的排序结果：{sorted(my_tuple)}")
  print(f"字符串对象的排序结果：{sorted(my_str)}")
  print(f"集合对象的排序结果：{sorted(my_set)}")
  print(f"字典对象的排序结果：{sorted(my_dict)}")
  # 反向排序
  print(f"列表对象的排序结果：{sorted(my_list, reverse=True)}")
  print(f"元组对象的排序结果：{sorted(my_tuple, reverse=True)}")
  print(f"字符串对象的排序结果：{sorted(my_str, reverse=True)}")
  print(f"集合对象的排序结果：{sorted(my_set, reverse=True)}")
  print(f"字典对象的排序结果：{sorted(my_dict, reverse=True)}")
  

19 拓展-字符串大小比较方式

• ASCII码表

第7章

01 函数的多返回值

• 语法

  def test_return():
  	return 1, 2
  
  x, y = test_return()
  print(x)    #结果1
  print(y)    #结果2
  

02 函数的多种传参方式

• 位置参数

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

  def user_info(name, age, gender):
      print(f"您的名字是{name}, 年龄是{age}, 性别是{gender}")
  user_info('Tom', 30, '男')
  

• 关键字参数

  可以不按照固定顺序

  def user_info(name, age, gender):
      print(f"您的名字是{name}, 年龄是{age}, 性别是{gender}")
  user_info(name='Tom', age=30, gender='男')
  

• 缺省参数

  函数调用时没有传递参数，就会使用默认是缺省参数对应的值

  该参数需要放在最后面

  def user_info(name, age, gender = '男'):
      print(f"您的名字是{name}, 年龄是{age}, 性别是{gender}")
  user_info('小甜', 15)
  user_info('小六', 23, '女')
  

• 不定长参数

  # 方式1：位置传递
  def user_info(*args):
      print(args)
  
  user_info('小甜', 15)
  user_info('小六', 23, '女')
  # 方式2：关键字传递
  def user_info1(**kwargs):
      print(kwargs)
  user_info1(name='xiaoer', age=18, gender='女')
  

03 函数作为参数传递

def test_func(compute):
    result = compute(1, 2)
    print(f"compute参数的类型是：{type(compute)}")
    print(f"计算结果是：{result}")

def compute(x, y):
    result = x + y
    return result
test_func(compute)

04 lambda匿名函数

• 函数定义中

  • def关键字，可以定义带有名称的函数；可基于名称重复使用

  • lambda关键字，可以定义匿名函数（无名称）；只能临时使用一次

  • 语法：

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

    lambda x, y : x + y
    

第8章

01 文件编码概念

02 文件的读取操作

• 打开文件

• 读写文件

• 关闭文件

• open()打开函数

  open(name, mode, encoding)
  

  name: 是要打开的目标文件名的字符串（可以包含文件所在的具体路径）

  mode：设置打开的文件模式（访问模式）：只读、写入、追加等

  encoding：编码格式（推荐使用UTF-8）

  示例代码

  f = open('python.txt', 'r', encoding="UTF-8")
  

• mode常用的三种基础访问

  模式	描述
  r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式
  w	打开一个文件用于写入。如果该文件已经存在则打开文件，并从头开始编辑，原内容会被删除。如果该文件不存在，创建新文件
  a	打开一个文件用于追加。如果该文件已存在，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入

• 文件读操作相关方法

  • read()

    文件对象.read(num)
    # num表示要从文件中读取的数据长度（单位是字节），如果没有传入num，那么就表示读取文件中所有的数据
    

  • readlines()

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

    f = open("D:/测试.txt", "r", encoding="UTF-8")
    print(type(f))
    # print(f"读取10字节的结果：{f.read(10)}")
    # print(f"读取全部内容的结果：{f.read()}")
    print("----------------------------------")
    # readlines()方法
    lines = f.readlines()
    print(f"lines对象的类型：{type(lines)}")
    print(f"lines对象的内容是{lines}")
    

  • readline()方法：一次读取一行内容

    line1 = f.readline()
    line2 = f.readline()
    line3 = f.readline()
    line4 = f.readline()
    print(line1)
    print(line2)
    print(line3)
    print(line4)
    

  • for循环

    f = open("D:/测试.txt", "r", encoding="UTF-8")
    for line in f:
        print(f"每一行数据是：{line}")
    

  • close()关闭文件对象

    f.close()
    

  • with open 语法

    通过在with open的语句中对文件进行操作，可以在操作完成后自动关闭close文件，避免遗忘掉close方法

    with open("D:/测试.txt", "r", encoding="UTF-8") as f:
        for line in f:
            print(line)
    time.sleep(500000)
    

• 练习

  with open("D:/测试.txt", 'r', encoding='UTF-8') as f:
      count = 0
      for words in f:
          words = words.strip()
          for word in words:
              if word == '你':
                  count += 1
      print(f"'你'字共有{count}个")
  # 第二种方法----------------------------------------------
  with open("D:/测试.txt", 'r', encoding='UTF-8') as f:
      content = f.read()
      count = content.count("你")
      print(f"'你'字共有{count}个")
  

04 文件的写入操作

• 文件写入

  f.write(‘hello, world’) 写内存

• 内容刷新

  f.flush() 写到硬盘里面

  import time
  
  f = open('D:/test.txt', 'w', encoding='UTF-8')
  f.write("Hello World!!!")
  f.flush()
  

  f = open('D:/test.txt', 'w', encoding='UTF-8')
  f.write("我喜欢学python")
  f.flush()
  

• close()方法，会带有flush()方法功能

05 文件的追加写入操作

• a模式，文件不存在会创建文件

• a模式，文件存在会在最后，追加写入文件

  f = open('D:/test1.txt', 'a', encoding='UTF-8')
  f.write("Hello World!!!")
  f.flush()
  

06 文件操作的综合练习

f1 = open("D:/bill.txt", 'r', encoding='UTF-8')
f2 = open("D:/bill.txt.bak", 'w', encoding='UTF-8')

for lines in f1:
    lines = lines.strip()
    line = lines.split(",")
    print(lines)
    if line[4] == "测试":
        continue
    else:
        f2.write(lines)
        f2.write("\n")
f1.close()
f2.close()

第9章

01 了解异常

02 捕获异常

• 捕获异常

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

• 捕获指定异常

  try：
  	print(name)
  except NameError as e:
  	print('name变量名称未定义错误')
  

  try:
      print(name)
  except NameError as e:
      print("出现了变量未定义异常")
      print(e)
  

• 捕获多个异常

  try:
  	print(1/0)
  except (NameError,ZeroDivisionError):
  	print('ZeroDivision错误')
  

  try:
  	# print(1/0)
      print(name)
  except(NameError,ZeroDivisionError) as e:
      print('出现变量未定义或除0异常')
  

• 捕获全部异常

  try:
      1/0
  except Exception as e:
      print('出现异常了')
  

• 异常else

  try:
      print(1)
  except Exception as e:
      print('e')
  else:
  	print('我是else,是没有异常的时候的代码')
  

• finally

  try:
      f = open('D:/abcd.txt', 'r', encoding='UTF-8')
  except Exception as e:
      print('出现异常了')
      f = open('D:/abcd.txt', 'w', encoding='UTF-8')
  else:
  	print('我是else,是没有异常的时候的代码')
  finally:
      print("我是finally，有没有异常我都要执行")
      f.close()
  

03 异常的传递

def func1():
    print("func1 开始执行")
    num = 1/0
    print("func1 结束执行")

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

def main():
    func2()
    
main()

Traceback (most recent call last):
  File "C:\Users\28193\Desktop\Python\python-learn\test.py", line 14, in 
    main()
  File "C:\Users\28193\Desktop\Python\python-learn\test.py", line 12, in main
    func2()
  File "C:\Users\28193\Desktop\Python\python-learn\test.py", line 8, in func2
    func1()
  File "C:\Users\28193\Desktop\Python\python-learn\test.py", line 3, in func1
    num = 1/0
ZeroDivisionError: division by zero
func2 开始执行
func1 开始执行

def func1():
    print("func1 开始执行")
    num = 1/0
    print("func1 结束执行")

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

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

main()

04 模块的概念和导入

• 什么是模块

  Python模块（Module）,是一个Python文件，以.py结尾。

  模块能定义函数，类和变量，模块里也可能包含可执行的代码

  **大白话：**模块就是一个python文件，里面有类、函数、变量等，我们可以直接拿过来用

• 模块的导入方式

  [from 模块名] import [模块 | 类 | 变量 | 函数 | *] [as 别名]

  常见的组合形式如：

  • import 模块名
  • from 模块名 import 类、变量、方法等
  • from 模块名 import *
  • from 模块名 as 别名
  • from 模块名 import 功能名 as 别名

05 自定义模块并导入

• 制作自定义模块

  # 新建一个module.py文件
  def test(a, b):
      print(a + b)
  # import module
  test(2, 6)
  

• 测试模块

  解决测试时也执行问题

  if __name__ == '__main__':
      test(1, 2)
  

• _all_

  __all__ = ['test_a']
  def test_a(a, b):
      print(a + b)
  
  def test_b(a, b):
      print(a - b)
      
  from module import *
  只能使用test_a()
  

06 自定义python包

• 可以理解为python包为文件夹

  包含各个模块的文件和_init_.py文件

  import my_package.module1
  import my_package.module2
  my_package.module1.info_print()
  my_package.module2.info_print()
  
  from my_package import module2
  from my_package.module2 import info_print
  
  module2.info_print()
  info_print()
  

• 导入包，方法二

  # 在__init__文件中输入
  __all__ = ['module1']
  # 则import*时只能使用module1
  from my_package import *
  module1.info_print()
  module2.info_print()
  

07 安装第三方包

• 常用的第三方包

  • 科学计算中常用的：numpy包
  • 数据分析中常用的：pandas包
  • 大数据计算中常用的：pyspark、apache-flink
  • 图形可视化常用的：matplotlib、pyecharts
  • 人工智能常用的：tensortflow
  • 等

• pip 安装

  • pip install 包名称
  • pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名称

• 在PyCharm安装

08 综合案例

• file_util.py

def print_file_info(file_name):
    try:
        f = open(file_name, 'r', encoding='UTF-8')
        txt = f.read()
        print(txt)
    except Exception as e:
        print(e)
    finally:
        f.close()
if __name__ == '__main__':
    print_file_info("D:/bill.txt")

def append_to_file(file_name, data):
    f = open(file_name, 'a', encoding='UTF-8')
    f.write(data)
    f.flush()
    f.close()
if __name__ == '__main__':
    append_to_file('D:/abc.txt', "我爱学python1\n")

• str_util.py

def str_reverse(s):
    s = s[::-1]
    print(s)
if __name__ == '__main__':
    str_reverse('python')

def substr(s, x, y):
    s = s[x:y:1]
    print(s)
if __name__ == '__main__':
    substr('pythonoopython', 6, 8)

第10章

02 json数据格式的转化

"""
演示json数据和python字典的相互转换
"""
import json
# 准备列表
data = [{"name": "张三", "age": 11}, {"name": "李四", "age": 13}, {"name": "王五", "age": 12}]
json_str = json.dumps(data, ensure_ascii=False)  # 转换中文时，需要用ensure_ascii=False
print(type(json_str))
print(json_str)
# 准备字典，将字典转换为json
d = {"name": "张三", "age": 11}
json_str = json.dumps(d, ensure_ascii=False)
print(json_str)
# 将JSON字符串转换为python数据类型-列表
s = '[{"name": "张三", "age": 11}, {"name": "李四", "age": 13}, {"name": "王五", "age": 12}]'
l = json.loads(s)
print(type(l))
print(l)
# 将JSON字符串转换为python数据类型-字典
s = '{"name": "张三", "age": 11}'
l = json.loads(s)
print(type(l))
print(l)

03 pyecharts模块简介

• 如果想要做出数据可视化
• (https://pyecharts.org/#/zh-cn/)
• (https://gallery.pyecharts.org/#/README)

04 pyecharts的入门使用

• 生成简单图表

  """
  演示pyecharts的基础入门
  """
  from pyecharts.charts import Line
  # 创建一个折线图对象
  line = Line()
  # 给折线图对象添加X轴数据
  line.add_xaxis(["中国", "美国", "英国"])
  # 给折线图对象添加Y轴数据
  line.add_yaxis("GDP", [30, 20, 10])
  # 通过render方法，将代码生成为图像
  line.render()
  

• 全局配置

  set_global_opts方法

  """
  演示pyecharts的基础入门
  """
  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%"),
      legend_opts=LegendOpts(is_show=True),
      toolbox_opts=ToolboxOpts(is_show=True),
      visualmap_opts=VisualMapOpts(is_show=True)
  )
  # 通过render方法，将代码生成为图像
  line.render()
  

05 数据准备

• 小练习

  """
  演示可视化需求1：折线图开发
  """
  import json
  from pyecharts.charts import Line
  from pyecharts.options import TitleOpts, LabelOpts
  # 处理数据
  f_us = open("D:/美国.txt", 'r', encoding='UTF-8')
  us_data = f_us.read()
  
  f_jp = open("D:/日本.txt", 'r', encoding='UTF-8')
  jp_data = f_jp.read()
  
  f_in = open("D:/印度.txt", 'r', encoding='UTF-8')
  in_data = f_in.read()
  
  # 去掉不规范的开头或结尾
  us_data = us_data.replace("jsonp_1629344292311_69436(", "")
  us_data = us_data[:-2]
  
  jp_data = jp_data.replace("jsonp_1629350871167_29498(", "")
  jp_data = jp_data[:-2]
  
  in_data = in_data.replace("jsonp_1629350745930_63180(", "")
  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年（到314下标结束）
  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年（314下标结束）
  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)   # x轴数据可以共用，添加一个就行
  # 添加y轴数据
  line.add_yaxis("美国确诊人数", us_y_data, label_opts=LabelOpts(is_show=False))
  line.add_yaxis("日本确诊人数", jp_y_data, label_opts=LabelOpts(is_show=False))
  line.add_yaxis("印度确诊人数", in_y_data, label_opts=LabelOpts(is_show=False))
  
  # 设置全局选项
  line.set_global_opts(
  #     标题设置
      title_opts=TitleOpts(title="2020年美日印三国确诊人数对比折线图", pos_bottom="1%", pos_left="center"),
  
  )
  
  # 调用render（）方法生成图表
  line.render()
  # 关闭文件
  f_us.close()
  f_jp.close()
  f_in.close()
  

第11章

01 数据可视化案例-地图-基础地图使用

• 地图基本演示

  """
  演示地图可视化的基本使用
  """
  from pyecharts.charts import Map
  from pyecharts.options import VisualMapOpts
  
  # 准备地图对象
  map = Map()
  # 准备数据
  data = [
      ("北京市", 99),
      ("上海市", 199),
      ("湖南省", 299),
      ("台湾省", 399),
      ("广东省", 499)
  ]
  # 添加数据
  map.add("测试地图", data, "china")
  
  # 设置全局选项
  map.set_global_opts(
      visualmap_opts=VisualMapOpts(
          is_show=True,
          is_piecewise=True,
          pieces=[
              {"min": 1, "max": 99, "label": "1-9人", "color": "#CCFFFF"},
              {"min": 100, "max":299, "label": "100-299人", "color": "#FF6666"},
              {"min": 300, "label": "300以上", "color": "#990033"}
          ]
      )
  )
  # 绘图
  map.render()
  

02 全国疫情地图构建

"""
演示地图可视化的基本使用
"""
import json
from pyecharts.charts import Map
from pyecharts.options import *

# 读取文件
f = open("D:/疫情.txt", 'r', encoding="UTF-8")
data = f.read()
# 关闭文件
f.close()
# 取到各省数据
# 将字符串json转换为python的字典
data_dict = json.loads(data)
# 从字典中取省份数据
province_data_list = data_dict["areaTree"][0]["children"]
print(province_data_list)
# 取出各个省份名称，确诊人数
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))
print(data_list)
# 准备地图对象
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, "label": "1-99人", "color": "#CCFFFF"},
            {"min": 100, "max":999, "label": "100-999人", "color": "#FFFF99"},
            {"min": 1000, "max":4999, "label": "1000-4999人", "color": "#FF9966"},
            {"min": 5000, "max":9999, "label": "5000-9999人", "color": "#FF6666"},
            {"min": 10000, "max":99999, "label": "10000-99999人", "color": "#CC3333"},
            {"min": 100000, "label": "100000+", "color": "#990033"}
        ]
    )
)
# 绘图
map.render("全国疫情地图.html")

03 省级疫情地图

"""
演示地图可视化的基本使用
"""
import json
from pyecharts.charts import Map
from pyecharts.options import *

# 读取文件
f = open("D:/疫情.txt", 'r', encoding="UTF-8")
data = f.read()
# 关闭文件
f.close()
# 取到各省数据
# 将字符串json转换为python的字典
data_dict = json.loads(data)
# 从字典中取省份数据
cities_data = data_dict["areaTree"][0]["children"][3]["children"]
print(cities_data)
# 取出各个省份名称，确诊人数
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))
print(data_list)
# 准备地图对象
map = Map()
# 添加数据
map.add("各市确诊人数", data_list, "河南")

# 设置全局选项
map.set_global_opts(
    title_opts=TitleOpts(title="河南省疫情地图"),
    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": "#FFFF99"},
            {"min": 100, "max":499, "label": "100-499人", "color": "#FF9966"},
            {"min": 500, "label": "500人以上", "color": "#FF6666"},
        ]
    )
)
# 绘图
map.render("河南省疫情地图.html")

第12章

01 基础柱状图构建

from pyecharts.charts import Bar
from pyecharts.options import *
bar = Bar()
bar.add_xaxis(["中国", "美国", "英国"])
bar.add_yaxis("GDP", [30, 20, 10], label_opts=LabelOpts(position="right"))
bar.reversal_axis()
bar.render("基础柱状图.html")

02 基础时间线柱状图绘制

• 创建时间线

  Timeline()-时间线

  from pyecharts.charts import Bar, Timeline
  from pyecharts.options import *
  from pyecharts.globals import ThemeType
  bar1 = Bar()
  bar1.add_xaxis(["中国", "美国", "英国"])
  bar1.add_yaxis("GDP", [30, 20, 10], label_opts=LabelOpts(position="right"))
  bar1.reversal_axis()
  
  bar2 = Bar()
  bar2.add_xaxis(["中国", "美国", "英国"])
  bar2.add_yaxis("GDP", [50, 30, 20], label_opts=LabelOpts(position="right"))
  bar2.reversal_axis()
  
  timeline = Timeline(
      {"theme": ThemeType.LIGHT}   # 设置主题
  )
  timeline.add(bar1, "2021年GDP")
  timeline.add(bar2, "2022年GDP")
  
  # 设置自动播放
  timeline.add_schema(
      play_interval=300,  # 自动播放时间间隔
      is_timeline_show=True,  # 是否在自动播放的时候，显示时间线
      is_auto_play=True,  # 是否自动播放
      is_loop_play=True   # 是否循环播放
  )
  # 通过时间线绘图
  timeline.render("基础柱状图-时间线.html")
  

03 动态GDP柱状图绘制

• 列表的sort方法

  列表.sort(key=选择排序依据的函数，reverse=True|False)

  • 参数key，要去传入一个函数，表示将列表的每一个元素都传入函数中，返回排序依据
  • 参数reverse，是否反转排序结果，True表示降序，False表示升序

  my_list = [["a", 33], ["b", 55], ["c", 11]]
  def chosse_sort_key(element):
      return element[1]
  my_list.sort(key=chosse_sort_key, reverse=True)
  print(my_list)
  
  # 匿名函数
  my_list.sort(key=lambda element: element[1], reverse=True)
  print(my_list)
  

• 数据处理

  """
  GDP动态图开发
  """
  from pyecharts.charts import Bar, Timeline
  from pyecharts.options import *
  from pyecharts.globals import ThemeType
  
  timeline = Timeline({
      "theme": ThemeType.LIGHT
  })
  f = open("D:/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])  # 年份
      country = line.split(",")[1]   # 国家
      gdp = float(line.split(",")[2])  # GDP数据
      # 如何判断字段里面有没有key
      try:
          data_dict[year].append([country, gdp])
      except KeyError:
          data_dict[year] = []
          data_dict[year].append([country, gdp])
  
  # print(data_dict[1960])
  sorted_year_list = sorted(data_dict.keys())
  for year in sorted_year_list:
      data_dict[year].sort(key=lambda element: element[1], reverse=True)
      # 取出本年份前8的国家
      year_data = data_dict[year][0:8]
      x_data = []
      y_data = []
      for country_gdp in year_data:
          x_data.append(country_gdp[0])
          y_data.append(country_gdp[1]/100000000)
  
      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=500,
      is_timeline_show=True,
      is_auto_play=True,
      is_loop_play=False
  )
  # 绘图
  timeline.render("1960年-2019全球GDP前8国家.html")
  

第二阶段 第1章

01 初识对象

• 设计一个类

  class Student:
      name = None
      gender = None
      nationality = None
      native_place = None
      age = None
  
  stu1 = Student()
  
  stu1.name = "zhangsan"
  stu1.gender = "男"
  stu1.nationality = "中国"
  stu1.native_place = "山东省"
  stu1.age = 26
  print(stu1.name)
  print(stu1.gender)
  print(stu1.nationality)
  print(stu1.native_place)
  print(stu1.age)
  

02 类的成员方法

• 类的定义和使用

  class 类名称
  	类的属性   # 即定义在类中的变量（成员变量）
  	类的行为   # 即定义在类函数中的函数（成员方法）
      
  对象 = 类名称（）创建类对象的语法
  

• 成员方法的定义语法

  def 方法名(self, 形参1， 形参2，……，形参N)：
  	方法体
  

  self关键字是成员方法定义的时候，必须填写的。

  • 它用来表示自身的意思
  • 当我们使用类对象调用方法的是，self会自动被python传入
  • 在方法内部，想要访问类的成员变量，必须使用self

  self关键字传参数的时候可以忽略

  """
  演示面向对象类中的成员方法定义和使用
  """
  
  # 定义一个带有成员方法的类
  class Student:
      name = None   # 学生的姓名
  
      def say_hi(self):
          print(f"大家好呀！我是{self.name}，欢迎大家多多关照")
  
      def say_hi2(self, msg):
          print(f"大家好！我是{self.name}, {msg}")
          
  stu = Student()
  stu.name = "zhangsan"
  stu.say_hi2("哎呦不错哟")
  
  stu2 = Student()
  stu2.name = "lisi"
  stu2.say_hi2("小伙子，我看好你")
  
  stu3 = Student()
  stu3.name = "wangwu"
  stu3.say_hi2("希望大家天天开心")
  

03 类和对象

• 基于类创建对象

  """
  演示类和对象的关系，即面向对象的编程套路
  """
  
  # 设计一个闹钟类
  class Clock:
      id = None
      price = None
  
      def ring(self):
          import winsound
          winsound.Beep(2000, 3000)
  
  # 构建2个闹钟对象并让其工作
  clock1 = Clock()
  clock1.id = "003032"
  clock1.price = 19.99
  print(f"闹钟ID：{clock1.id}，价格：{clock1.price}")
  clock1.ring()
  
  clock2 = Clock()
  clock2.id = "003033"
  clock2.price = 21.99
  print(f"闹钟ID：{clock2.id}，价格：{clock2.price}")
  clock1.ring()
  

04 构造方法

• 属性（成员变量赋值）

• 构造方法

  python类可以使用：_init_()方法，称之为构造方法

  可以实现

  • 在创建类对象（构造类）的时候，会自动执行
  • 在创建类对象（构造类）的时候，将传入参数自动传递给_init_()方法使用。

  """
  演示类的构造方法
  """
  # 演示使用构造方法对成员变量进行赋值
  # 构造方法的名称：__init__
  
  class Student:
      def __init__(self, name, age, tel):
          self.name = name
          self.age = age
          self.tel = tel
          print("Student类创建了一个类对象")
  
  stu = Student("zhangsan", 18, "1888888888")
  

• 构造方法注意事项

  • 构造方法不要忘记self关键字
  • 在方法内使用成员变量需要使用self

• 学生信息录入

  class Student:
      def __init__(self, name, age, addr):
          self.name = name
          self.age = age
          self.addr = addr
  for i in range(1,11):
      print(f"当前录入第{i}位学生信息，总共需录入10位学生信息")
      name = input("请输入学生姓名:")
      age = input("请输入学生年龄:")
      addr = input("请输入学生地址:")
      stu = Student(name, age, addr)
      print(f"学生{i}信息录入完成，信息为：【学生姓名:{name}，年龄：{age}，地址：{addr}】")
  

05 魔术方法

• __str__字符串方法

  class Student:
      def __init__(self, name, age):
          self.name = name   # 学生姓名
          self.age = age     # 学生年龄
  
      # __str__魔术方法
      def __str__(self):
          return f"Student类对象，name:{self.name}，age:{self.age}"
  
  stu = Student("zhangsan", 18)
  print(stu)
  

• __lt__小于符号比较方法

  class Student:
      def __init__(self, name, age):
          self.name = name   # 学生姓名
          self.age = age     # 学生年龄
  
      # __lt__魔术方法
      def __lt__(self, other):
          return self.age < other.age
  
  stu1 = Student("zhangsan", 18)
  stu2 = Student("lisi", 26)
  print(stu1 < stu2)
  

• __le__小于等于比较运算符

  class Student:
      def __init__(self, name, age):
          self.name = name   # 学生姓名
          self.age = age     # 学生年龄
  
      # __le__魔术方法
      def __le__(self, other):
          return self.age <= other.age
  
  stu1 = Student("zhangsan", 18)
  stu2 = Student("lisi", 26)
  print(stu1 <= stu2)
  

• __eq__比较运算符实现方法

  class Student:
      def __init__(self, name, age):
          self.name = name   # 学生姓名
          self.age = age     # 学生年龄
  
      # __eq__魔术方法
      def __eq__(self, other):
          return self.age == other.age
  
  stu1 = Student("zhangsan", 18)
  stu2 = Student("lisi", 26)
  print(stu1 == stu2)
  

06 封装

• 私有成员 只能类内部其他成员使用

  __变量名

  __方法名

  """
  演示面向对象封装思想中私有成员的使用
  """
  
  # 定义一个类，内含私有成员变量和私有成员方法
  class Phone:
  
      __current_voltage = 0.5    # 当前手机运行电压
  
      def __keep_single_core(self):
          print("让CPU以单核模式运行")
  
      def call_by_5g(self):
          if self.__current_voltage >= 1:
              print("5G通话已开启")
          else:
              self.__keep_single_core()
              print("电量不足，无法使用5G通话，并已设置为单核运行")
  
  phone = Phone()
  phone.call_by_5g()
  

• 练习

  class Phone:
  
      __is_5g_enable = False
  
      def __check_5g(self):
          if self.__is_5g_enable:
              print("5G开启")
          else:
              print("5G关闭，使用4G网络")
  
      def call_by_5g(self):
          self.__check_5g()
          print("正在通话中")
  phone = Phone()
  phone.call_by_5g()
  

08 继承

• 语法

  class 类名(父类名):
  	类内容体
  

• 单继承 --一个子类继承1个父类

  class Phone:
     IMEI = None       # 序列号
     producer = "HM"   # 厂商
  
     def call_by_4g(self):
         print("4g通话")
  
  class Phone2022(Phone):
      face_id = "10001"     # 面部识别ID
  
      def call_by_5g(self):
          print("2022年新功能：5g通话")
  
  phone = Phone2022()
  print(phone.producer)
  phone.call_by_5g()
  phone.call_by_4g()
  

• 多继承—一个子类继承多个父类

  多个父类中，如果有同名成员，那么默认以继承顺序（从左到右）为优先级

  即：先继承的保留，后继承的被覆盖

  class 类名(父类1, 父类2，……，父类N):
  	类内容体
  

  """
  演示面向对象：继承的基础语法
  """
  
  # 演示单继承
  class Phone:
      IMEI = None       # 序列号
      producer = "HM"   # 厂商
  
      def call_by_4g(self):
          print("4g通话")
  
  # 演示多继承
  class NFCReader:
      nfc_type = "第五代"
      producer = "It"
  
      def read_card(self):
          print("NFC读卡")
  
      def write_card(self):
          print("NFC写卡")
  
  class RemoteControl:
      rc_type = "红外遥控"
  
      def control(self):
          print("红外遥控开启了")
  
  class MyPhone(NFCReader,Phone, RemoteControl):
      pass
  
  phone = MyPhone()
  phone.call_by_4g()
  phone.read_card()
  phone.write_card()
  phone.control()
  print(phone.producer)
  # 演示多继承下，父类成员名一致的场景
  

• pass关键字的作用

  pass是占位语句，用来保证函数（方法）或类的定义完整性，表示无内容，空的意思

09 复写父类成员和调用父类成员

• 复写父类

  class Phone:
      IMEI  = None
      producer  = "ITCAST"
  
      def call_by_5g(self):
          print("使用5g进行通话")
  
  class MyPhone(Phone):
      producer = "ITHAIMA"   # 复写父类的成员属性
  
      def call_by_5g(self):
          print("开启CPU单核模式，确保通话的时候省电")
          print("使用5g网络进行通话")
  
  phone = MyPhone()
  phone.call_by_5g()
  print(phone.producer)
  

• 调用父类的同名成员

  方式1：调用父类成员

  • 使用成员变量：父类名.成员变量
  • 使用成员方法：父类名.成员方法（self）

  方式2：使用super()调用父类成员

  • 使用成员变量：super().成员变量
  • 使用成员方法：super().成员方法()

  class Phone:
      producer  = "ITCAST"
  
      def call_by_5g(self):
          print("使用5g进行通话")
  
  class MyPhone(Phone):
      producer = "ITHAIMA"   # 复写父类的成员属性
  
      def call_by_5g(self):
          print("开启CPU单核模式，确保通话的时候省电")
          super().call_by_5g()
  
  phone = MyPhone()
  phone.call_by_5g()
  print(Phone.producer)
  

10 类型注解

• 变量的类型注解

  语法：变量：类型

• 函数（方法）形参列表和返回值的类型注解

  """
  演示变量的注释类型
  """
  import json
  import random
  
  # 基础数据类型注解
  var_1: int = 10
  var_2: str = "itheima"
  var_3: bool = True
  # 类对象类型注解
  class Student:
      pass
  stu: Student = Student()
  # 基础容器类型注解
  my_list: list = [1, 2, 3]
  my_tuple: tuple = (1, 2, 3)
  my_dict: dict = {"zhangsan": 18}
  
  # 容器类型详细注解
  my_list1: list[int] = [1, 2, 3]
  my_tuple1: tuple[int, str, bool] = (1, 2, 3)
  my_dict1: dict[str, int] = {"zhangsan": 18}
  # 在注释中进行类型注解
  var_11 = random.randint(1, 10)    # type: int
  var_22 = json.loads({"name": "zhangsan"})   # type: dict[str, str]
  def func():
      return 10
  var_33 = func()    #type: int
  

• 一般，无法直接看出变量类型时会添加变量的类型注解

• 帮助开发者自身对变量进行类型注释（备注）

11 函数和方法类型注解

• 语法：

  def 函数方法名(形参名：类型，形参名：类型)：
  	pass
  

• 对返回值进行类型注解

  def 函数方法名(形参名：类型，形参名：类型) -> 返回值类型：
  	pass
  

  """
  演示函数（方法）进行类型注解
  """
  
  # 对形参进行类型注解
  def add(x: int, y: int):
      return x + y
  add()
  # 对返回值进行类型注解
  def func(data: list) -> list:
      return data
  

12 Union联合类型注解

• Union类型

  """
  演示Union联合类型注解
  """
  
  # 使用Unino类型，必须先导包
  from typing import Union
  
  my_list: list[Union[int, str]] = [1, 2, "iit", "python"]
  
  def func(data: Union[int, str]) -> Union[str, int]:
      pass
  func()
  

13 多态

• 示例

  """
  演示面向对象的多态特性以及抽象类（接口）的使用
  """
  
  class Animal:
      def speak(self):
          pass
  
  class Dog(Animal):
      def speak(self):
          print("汪汪汪")
  
  class Cat(Animal):
      def speak(self):
          print("喵喵喵")
  
  def make_noise(animal: Animal):
      """制造噪音点，需要传入Aniaml对象"""
      animal.speak()
  
  # 演示多态，使用2个子类对象来调用函数
  dog = Dog()
  cat = Cat()
  make_noise(dog)
  make_noise(cat)
  

14 综合案例

• data_define.py

  """
  数据定义的类
  """
  
  
  class Record:
  
      def __init__(self, date, order_id, money, province):
          self.date = date  # 订单日期
          self.order_id = order_id  # 订单ID
          self.money = money  # 订单金额
          self.province = province  # 销售省份
  
      def __str__(self):
          return f"{self.date}, {self.order_id}, {self.money}, {self.province}"
  

• file_define.py

  """
  数据定义的类
  """
  
  
  class Record:
  
      def __init__(self, date, order_id, money, province):
          self.date = date  # 订单日期
          self.order_id = order_id  # 订单ID
          self.money = money  # 订单金额
          self.province = province  # 销售省份
  
      def __str__(self):
          return f"{self.date}, {self.order_id}, {self.money}, {self.province}"
  

• main.py

  """
  面向对象，数据分析案例，主业务逻辑代码
  实现步骤：
  1. 设计一个类。可以完成数据的封装
  2. 设计一个抽象类，定义文件读取相关功能，并使用子类实现具体功能
  3. 读取文件，生产数据对象
  4. 进行数据需求的逻辑计算（计算每一天的销售额）
  5. 通过pyecharts进行图形绘制
  """
  from file_define import FileReader, TextFileReader, JsonFileReader
  from data_define import Record
  from pyecharts.charts import Bar
  from pyecharts.options import *
  from  pyecharts.globals import ThemeType
  
  text_file_reader = TextFileReader("D:/2011年1月销售数据.txt")
  json_file_reader = JsonFileReader("D:/2011年2月销售数据JSON.txt")
  
  jan_data: list[Record] = text_file_reader.read_data()
  feb_data: list[Record] = json_file_reader.read_data()
  
  # 将两个月份的数据合并为一个list来存储
  all_data: list[Record] = jan_data + feb_data
  
  # 开始进行数据计算
  data_dict = {}
  for record in all_data:
      if record.date in data_dict.keys():
          # 当前日期已存在
          data_dict[record.date] += record.money
      else:
          data_dict[record.date] = record.money
  
  # 可视化图表开发
  bar = Bar(init_opts=InitOpts(theme=ThemeType.LIGHT))
  
  bar.add_xaxis(list(data_dict.keys()))   # 添加X轴数据
  bar.add_yaxis("销售额", list(data_dict.values()), label_opts=LabelOpts(is_show=False))  # 添加Y轴数据
  bar.set_global_opts(
      title_opts=TitleOpts(title="每日销售额")
  )
  
  bar.render("每日销售额柱状图.html")
  

第三阶段 Python高阶技巧

01 闭包

• 定义双层嵌套函数，内层函数可以访问外层函数的变量

• 将内层函数作为外层函数的返回，此内层函数就是闭包函数

• 在闭包函数（内层函数中）想要修改外部函数的变量值，需要用nonloacl声明这个外部变量

• 简单示例

  def outer(logo):
  
      def inner(msg):
          print(f"<{logo}>{msg}<{logo}>")
      return inner
  
  fn1 = outer("黑马程序员")
  fn1("大家好")
  
  f2 = outer("传智教育")
  f2("大家好")
  

  def account_create(initial_amount=0):
  
      def atm(num, deposit=True):
          nonlocal initial_amount
          if deposit:
              initial_amount += num
              print(f"存款：+{num}，账户余额：{initial_amount}")
          else:
              initial_amount -= num
              print(f"取款：+{num}，账户余额：{initial_amount}")
  
      return atm
  
  a = account_create()
  a(100)
  a(100)
  a(100, deposit=False)
  

02 装饰器

• 其实也是一种闭包，其功能就是在不破坏目标函数原有的代码和功能的前提下，为目标函数增加新功能

• 装饰器的一般写法（闭包写法）

  """
  演示装饰器的写法
  """
  
  # 装饰器的一般写法（闭包）
  def outer(func):
      def inner():
          print("我睡觉了")
          func()
          print("我起床了")
      return inner
  
  def sleep():
      import random
      import time
      print("睡眠中……")
      time.sleep(random.randint(1, 5))
  
  fn = outer(sleep)
  fn()
  

• 装饰器的语法糖写法

  # 装饰器的快捷语法
  
  def outer(func):
      def inner():
          print("我睡觉了")
          func()
          print("我起床了")
      return inner
  
  @outer
  def sleep():
      import random
      import time
      print("睡眠中……")
      time.sleep(random.randint(1, 5))
  
  sleep()
  

03 设计模式-单例模式

• 单例：节省内存，节省创建对象的开销

• str_tools.py

  class StrTools:
      pass
  
  str_tool = StrTools()
  

• main.py

  from str_tools import str_tool
  
  s1 = str_tool
  s2 = str_tool
  print(id(s1))
  print(id(s2))
  

04 工厂模式

• 大量创建一个类的实例的时候，可以使用工厂模式

  """
  演示设计模式之工厂模式
  """
  class Person:
      pass
  
  class Worker(Person):
      pass
  
  class Student(Person):
      pass
  
  class Teacher(Person):
      pass
  
  
  class PersonFactory:
      def get_person(self, p_type):
          if p_type == 'w':
              return Worker()
          elif p_type == "s":
              return Student()
          else:
              return Teacher()
  
  pf = PersonFactory()
  worker = pf.get_person('w')
  stu = pf.get_person('s')
  teacher = pf.get_person('t')
  

05 多线程并行执行概念

• 进程：程序在一个操作系统内运行，即成为一个运行进程
• 线程：进程内部可以有多个线程，程序的运行本质就是由进程内部的线程在实际工作的
• 并行执行：
  • 多个进程同时在运行，即不同程序同时运行，称之为：多任务并行执行
  • 一个进程内的多个线程同时在运行，称之为：多线程并行执行

06 多线程编程

• threading模块

  """
  演示多线程编程的使用
  """
  import time
  import threading
  
  def sing(msg):
      while True:
          print(msg)
          time.sleep(1)
  def dance(msg):
      while True:
          print(msg)
          time.sleep(1)
  
  if __name__ == '__main__':
      # 创建一个唱歌的线程
      sing_thread = threading.Thread(target=sing, args=("我要唱歌 哈哈哈", ))
      # 创建一个跳舞的线程
      dance_thread = threading.Thread(target=dance, kwargs={"msg": "我在跳舞，啦啦啦"})
  
      # 让线程开始工作
      sing_thread.start()
      dance_thread.start()
  

07 Socket服务端开发

• socket服务端

  """
  演示Socket服务端开发
  """
  import socket
  # 创建Socket对象
  socket_sever = socket.socket()
  # 绑定ip地址和端口
  socket_sever.bind(("localhost", 8888))
  # 监听端口
  socket_sever.listen(1)
  # listen方法内接受一个整数传参数，表示接受的链接数量
  # 等待客户端连接
  # result = socket_sever.accept()
  # conn = result[0]        # 客户端和服务端的链接对象
  # address = result[1]     # 客户端地址信息
  conn, address = socket_sever.accept()
  # accept方法返回的是二元元组（链接对象， 客户端地址信息）
  # 可以通过变量1，变量2 = socket_server.accept()的形式，直接接受二元元组内的两个元素
  # accept()方法，是阻塞方法，等待客户端的链接，如果没有链接，就卡在这一行不执行了
  print(f"接收到了客户端的链接，客户端信息是：{address}")
  
  while True:
      # 接受客户端信息，要使用客户端和服务单的本次链接对象，而非socket_server对象
      data : str = conn.recv(1024).decode("UTF-8")
      # recv接受的参数是缓冲区大小，一般给1024即可
      # recv方法的返回值是一个字节数组也就是bytes对象，不是字符串，可以通过decode方法编码，将字节数组转换为字符串对象
      print(f"客户端发来的消息是：{data}")
      # 发送回复消息
      msg = input("请输入你要和客户端回复的消息:")
      if msg == 'exit':
          break
      conn.send(msg.encode("UTF-8"))
  # 关闭链接
  conn.close()
  socket_sever.close()
  

08 Socket客户端编程

• Socket客户端

  """
  演示Socket客户端开发
  """
  import socket
  # 创建socket对象
  socket_client = socket.socket()
  # 连接到服务器
  socket_client.connect(("localhost", 8888))
  # 发送消息
  while True:
      msg = input("请输入你要给服务端发送的消息：")
      if msg == 'exit':
          break
      socket_client.send(msg.encode("UTF-8"))
      # 接收返回消息
      recv_data = socket_client.recv(1024)    # 1024是缓冲区的大小，一般1024即可，同样recv方法是阻塞的
      print(f"服务端回复的消息是：{recv_data.decode('UTF-8')}")
  # 关闭链接
  socket_client.close()
  

09 正则表达式-基础方法

• 正则的三个基础方法

  Python正则表达式，使用re模块，并基于re模块中三个基础方法来做正则匹配

  分别是：match、search、findall三个基础方法

  • re.match（匹配规则，被匹配字符串）

    从被匹配字符串开头进行匹配，匹配成功返回匹配对象（包含匹配信息），匹配不成功返回空

  • re.search（匹配规则，被匹配字符串）

    搜索整个字符串，找出匹配的。从前向后，找到第一个后，就停止 ，不会继续向后

  • re.findall（匹配规则，被匹配字符串）

    匹配整个字符串，找出全部匹配项。找不到返回空list: []

  """
  演示Python正则表达式re模块的3个基础匹配方法
  """
  
  import re
  
  s = "python itheima"
  # match 从头匹配
  result = re.match("python", s)
  print(result)
  print(result.span())
  print(result.group())
  
  # search 搜索匹配
  s1 = "1python666itheima6666python1111python"
  result = re.search("python", s1)
  print(result)
  
  # findall搜索匹配
  result = re.findall("python", s1)
  print(result)
  import re
  
  s = "python itheima"
  # match 从头匹配
  result = re.match("python", s)
  print(result)
  print(result.span())
  print(result.group())
  
  # search 搜索匹配
  s1 = "1python666itheima6666python1111python"
  result = re.search("python", s1)
  print(result)
  
  # findall搜索匹配
  result = re.findall("python", s1)
  print(result)
  

10 正则表达式-元字符匹配

字符	工能
.	匹配任意1个字符（除了\n）,\. 匹配.本身
[]	匹配[]中列举的字符
\d	匹配数字，即0-9
\D	匹配非数字
\s	匹配空白，即空格、tab键
\S	匹配非空白
\w	匹配单词字符，即a-z、A-Z、0-9、_
\W	匹配非单词字符

数量匹配

字符	功能
*	匹配前一个规则的字符出现0至无数次
+	匹配前一个规则的字符出现1至无数次
？	匹配前一个规则的字符出现0次或1次
{m}	匹配前一个规则的字符出现m次
{m,}	匹配前一个规则的字符出现最少m次
{m,n}	匹配前一个规则的字符出现m到n次

边界匹配

字符	功能
^	匹配字符串开头
$	匹配字符串结尾
\b	匹配一个单词的边界
\B	匹配非单词边界

分组匹配

字符	功能
|	匹配左右任意一个表达式
()	将括号中字符作为一个分组

示例

"""
演示python正则表达式使用元字符进行匹配
"""
import re
s = "zhangsan @@python !!!6666  ##study8899"

result1 = re.findall(r'\d', s)   # 字符串前面带上r的标记，表示字符串中转义字符无效，就是普通字符的意思
print(result1)

# 找出特殊字符
result2 = re.findall(r'\W', s)
print(result2)

# 找出全部英文字母
result3 = re.findall(r'[a-zA-Z]', s)   # []内可以写：a-zA-Z0-9这三种指定范围组合或指定单个字符如[aceDFG123]
print(result3)

# 匹配账号，只能由字母和数字组成，长度限制6-10位
r = '[a-zA-Z0-9]{6,10}$'
s = '123328a'
print(re.findall(r, s))
# 匹配QQ号，要求纯数字，长度5-11，第一位不为0
r = '^[1-9][0-9]{4,10}$'
s = '123445'
print(re.findall(r, s))
# 匹配邮箱地址，只允许qq、163、gmail这三种邮箱地址
r = '(^[\w-]+(\.[\w-]+)*@(qq|163|gmail)(\.[\w-]+)+$)'
s = '[email protected]'
print(re.match(r, s).group())

11 递归

• 自己调用自己

• 递归使用注意事项：

  • 注意退出的条件，否则容易变成无限递归
  • 注意返回值的传递，确保从最内层，层层传递到最外层

  """
  演示python递归操作
  需求：通过递归，找出一个指定文件内的全部内容
  
  思路：写一个函数，列出文件夹内的全部内容，如果是文件就收集到list
  如果是文件夹，就递归调用自己，再次判断
  """
  import os
  
  
  def test_os():
      """演示os模块的3个基础方法"""
      print(os.listdir("D:/test"))       # 列出路径下的内容
      print(os.path.isdir("D:/test/a"))  # 判断指定路径是不是文件夹
      print(os.path.exists("D:/test"))   # 判断指定路径是否存在
  
  
  def get_files_recursion_from_dir(path):
      """
      从指定的文件夹中使用递归的方式，获取全部的文件列表
      :param path: 被判断的文件夹
      :return: list，包含全部的文件，如果目录不存在或者无文件就返回一个空list
      """
      file_list = []
      if os.path.exists(path):
          for f in os.listdir(path):
              new_path = path + "/" + f
              if os.path.isdir(new_path):
                  # 进入这里，表明这个目录是文件不是文件
                  file_list += get_files_recursion_from_dir(new_path)
              else:
                  file_list.append(new_path)
      else:
          print(f"指定的目录{path}，不存在")
          return []
  
      return file_list
  
  if __name__ == '__main__':
      print(get_files_recursion_from_dir("D:/test"))
  

))
print(result.group())

• search 搜索匹配
  s1 = “1python666itheima6666python1111python”
  result = re.search(“python”, s1)
  print(result)

• findall搜索匹配
  result = re.findall(“python”, s1)
  print(result)
  import re

s = “python itheima”

• match 从头匹配
  result = re.match(“python”, s)
  print(result)
  print(result.span())
  print(result.group())

• search 搜索匹配
  s1 = “1python666itheima6666python1111python”
  result = re.search(“python”, s1)
  print(result)

• findall搜索匹配
  result = re.findall(“python”, s1)
  print(result)

## 10 正则表达式-元字符匹配

| 字符 | 工能                                    |
| ---- | --------------------------------------- |
| .    | 匹配任意1个字符（除了\n）,\\. 匹配.本身 |
| []   | 匹配[]中列举的字符                      |
| \d   | 匹配数字，即0-9                         |
| \D   | 匹配非数字                              |
| \s   | 匹配空白，即空格、tab键                 |
| \S   | 匹配非空白                              |
| \w   | 匹配单词字符，即a-z、A-Z、0-9、_        |
| \W   | 匹配非单词字符                          |

数量匹配

| 字符  | 功能                              |
| ----- | --------------------------------- |
| *     | 匹配前一个规则的字符出现0至无数次 |
| +     | 匹配前一个规则的字符出现1至无数次 |
| ？    | 匹配前一个规则的字符出现0次或1次  |
| {m}   | 匹配前一个规则的字符出现m次       |
| {m,}  | 匹配前一个规则的字符出现最少m次   |
| {m,n} | 匹配前一个规则的字符出现m到n次    |

边界匹配

| 字符 | 功能               |
| ---- | ------------------ |
| ^    | 匹配字符串开头     |
| $    | 匹配字符串结尾     |
| \b   | 匹配一个单词的边界 |
| \B   | 匹配非单词边界     |

分组匹配

| 字符 | 功能                     |
| ---- | ------------------------ |
| \|   | 匹配左右任意一个表达式   |
| ()   | 将括号中字符作为一个分组 |

示例

```python
"""
演示python正则表达式使用元字符进行匹配
"""
import re
s = "zhangsan @@python !!!6666  ##study8899"

result1 = re.findall(r'\d', s)   # 字符串前面带上r的标记，表示字符串中转义字符无效，就是普通字符的意思
print(result1)

# 找出特殊字符
result2 = re.findall(r'\W', s)
print(result2)

# 找出全部英文字母
result3 = re.findall(r'[a-zA-Z]', s)   # []内可以写：a-zA-Z0-9这三种指定范围组合或指定单个字符如[aceDFG123]
print(result3)

# 匹配账号，只能由字母和数字组成，长度限制6-10位
r = '[a-zA-Z0-9]{6,10}$'
s = '123328a'
print(re.findall(r, s))
# 匹配QQ号，要求纯数字，长度5-11，第一位不为0
r = '^[1-9][0-9]{4,10}$'
s = '123445'
print(re.findall(r, s))
# 匹配邮箱地址，只允许qq、163、gmail这三种邮箱地址
r = '(^[\w-]+(\.[\w-]+)*@(qq|163|gmail)(\.[\w-]+)+$)'
s = '[email protected]'
print(re.match(r, s).group())

11 递归

• 自己调用自己

• 递归使用注意事项：

  • 注意退出的条件，否则容易变成无限递归
  • 注意返回值的传递，确保从最内层，层层传递到最外层

  """
  演示python递归操作
  需求：通过递归，找出一个指定文件内的全部内容
  
  思路：写一个函数，列出文件夹内的全部内容，如果是文件就收集到list
  如果是文件夹，就递归调用自己，再次判断
  """
  import os
  
  
  def test_os():
      """演示os模块的3个基础方法"""
      print(os.listdir("D:/test"))       # 列出路径下的内容
      print(os.path.isdir("D:/test/a"))  # 判断指定路径是不是文件夹
      print(os.path.exists("D:/test"))   # 判断指定路径是否存在
  
  
  def get_files_recursion_from_dir(path):
      """
      从指定的文件夹中使用递归的方式，获取全部的文件列表
      :param path: 被判断的文件夹
      :return: list，包含全部的文件，如果目录不存在或者无文件就返回一个空list
      """
      file_list = []
      if os.path.exists(path):
          for f in os.listdir(path):
              new_path = path + "/" + f
              if os.path.isdir(new_path):
                  # 进入这里，表明这个目录是文件不是文件
                  file_list += get_files_recursion_from_dir(new_path)
              else:
                  file_list.append(new_path)
      else:
          print(f"指定的目录{path}，不存在")
          return []
  
      return file_list
  
  if __name__ == '__main__':
      print(get_files_recursion_from_dir("D:/test"))