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:
    	如果出现异常执行的代码
    
  • 捕获指定异常

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

你可能感兴趣的:(python,学习,笔记)