Python笔记

常用pip源

（1）阿里云

http://mirrors.aliyun.com/pypi/simple/

（2）豆瓣

http://pypi.douban.com/simple/

（3）清华大学

https://pypi.tuna.tsinghua.edu.cn/simple/

（4）中国科学技术大学

http://pypi.mirrors.ustc.edu.cn/simple/

（5）华中科技大学

 http://pypi.hustunique.com/

第一讲 基础知识

# ctrl+/ 添加注释
# ctrl+alt+l 三键实现格式规范
# \+特定字符 产生一个新的含义，就是转义字符(# \\ \t)
#\\ 表示一个反斜杠 
#\n 是换行符
print(666)
print('我爱编程')
# sep=','指定,为分隔变量的符号
print('唐三', '小舞', '张三', sep=',')
print('唐三', '小舞', sep=' ')
# end='\n'指定换行结尾
print('唐三', '小舞', end='*')
print('唐三', '小舞', end='\n')  #这个是输出换行，其实py默认有
print('唐三', '小舞', end=' ')  #输出不换行
# 变量
# 1.有一定意义
# 2.由数字，字母，下划线组成，数字不能开头
name = '张三'
print(name)
# input()表示输入，在括号里面加入''可加入提示\
# input()函数接收的用户输入始终是字符串类型（str）
input('请输入您的密码')

第二讲 数据类型

# 整型 int
# 浮点型 float
# 字符型 str
# '''中间可以放几段话'''
name = '''
啦啦啦
啦啦啦
啦啦啦
'''
print(name)
# type函数
name = '漩涡鸣人' 
print(type(name))   #<class 'str'>
# 运算注意优先级以及从左向右计算
# 字符不能和整数类型相加，但可以变换
name = '张三'
age = 48
print(name + str(age))
# 同理整型和浮点类型也可以相互转换,但有非数字的字符不能转换为整数，也不能是浮点类型结构

第三讲 运算符

# + - * / % 加减乘除求余
number = input('请输入数字')
number = int(number) # 输入的是字符类型，用int转换为整数类型进行运算
result = number % 2
print(result)
# //表示整除运算
bounty = 5000
print(bounty/280) # 结果是17.86
print(bounty//280) # 结果是17
# += *= /= -= 运算符
# 关系运算符返回值类型是布尔类型
# ord()函数可以查看字符对应的整数数值
print(ord('a'))
# 逻辑运算符 and or not
# and 有假就为假   or 有真就为真  not 真就假假就真

第四讲 条件语句

1. if语句的使用
2. if…else语句的使用
3. 多重if语句的使用
4. if嵌套

# if 要判断的条件：        （标准结构）
#     条件成立时要做的事情
# else:
#     条件成立时要做的事情
money = input('请输入您的钱数')
money = int(money) # 注意转换
things1 = '盲盒'
if money>35:
   print('拿下{}'.format(things1))
# 用{}进行占位，用.format()函数填充占位
else:
   print('买不起')

# elif语句
# if 条件1：
#     事情1
# elif 条件2：
#     事情2
# else:
#     事情3
choice1 = input('请输入你要选的品牌')
choice2 = input('请输入你要选的衣服类型')
money = input('请输入你手中有多少钱')
money = int(money)
if choice1 == '安踏' and choice2 == '短袖' and money > 60 :
    print('您购买了{}品牌的{}'.format(choice1,choice2), '您还有{}元钱'.format(money-60) , sep = '\n')
elif choice1 == '李宁' and choice2 == '短袖' and money > 60 :
    print('您购买了{}品牌的{}'.format(choice1,choice2), '您还有{}元钱'.format(money-60) , sep = '\n')
elif choice1 == '耐克' and choice2 == '短袖' and money > 60:
    print('您购买了{}品牌的{}'.format(choice1, choice2), '您还有{}元钱'.format(money - 60), sep='\n')
else:
    print('您要的我们没有或者您的钱不足以支付请重试')
    # if下语句可继续嵌套if

第五讲 循环语句

1. while的使用
2. for的使用
3. break和continue的使用
4. while或者for与else结合使用

循环的核心在于减少重复代码，条件要尽量通用化

# while 循环条件：（当循环条件不成立时结束）
# 	循环执行的代码
# break，整个循环会立即终止，不再执行后续的循环体代码，直接跳出循环
# continue 跳过本次循环，后面语句不执行，继续执行下一次循环
i = input('请输入数字')
i = int(i)
while i <= 5:
    i += 1
    print(i)
# 需求：限制登陆次数
i = 3
while i >= 1:
    username = input('请输入用户名')
    password = input('请输入密码')
    if username == 'admin' and password == '123456' :
        print('登录成功')
        break # 作用在于登录成功后退出循环
    else:
        print('登录失败')
        i -= 1
        print('还有{}次机会' .format(i))
        continue # 继续循环

# for 变量 in 序列：
#		循环体
# 变量：自定义变量名，要求和单独定义时候一样
# 序列：容器型数据类型的数据，比如字符串，布尔，列表，元组，集合
# 循环体：需要重复执行的代码
for x in range(1,11):
    print('今天你直播下单{}次'.format(x))
    # range()函数作用是产生一个序列，从0开始
    # range(1,11)则表示从1开始11结束但是不包括11
    # range(1,6,2)表示135的序列，即2为步长（可以是负数）
# 需求：限制登陆次数
for i in range(3):
    username = input('请输入用户名')
    password = input('请输入密码')
    if username == 'admin' and password == '123456' :
        print('登录成功')
        break # 作用在于登录成功后退出循环
    else:
        print('登录失败')
        print('还有{}次机会' .format(2-i))
        continue # 继续循环

# 需求：打印1-12数字，除了8不打印
# 方法一
for i in range(1,13):
    if i == 8:
        continue
    else:
        print(i)
# 方法二
i = 1
while i <12:
    i += 1
    if i == 8 :
        continue
    print(i)
# else可以和while,for进行配合
# 案例一
i = 13
while i <12:
    print('验证失败')
else:
    print('验证成功')
# 案例二
for i in range(8):
    print(i , end=' ')
else:
    print('\n')
    print('结束')

第六讲 数据类型列表

列表类似数组，字典类似结构体

1. 列表的使用

# 以前介绍的int bool str float都只能存放一个值，需要列表存放一堆值
# 变量名字 = [元素，元素，元素]
heros = ['张三', '张四', '张五', '张六', '张七', '张八']
print(type(heros))

输出结果是<class ‘list’>，即构成了一种新的数据类型列表

# 那怎么找到列表中的某一个元素呢？这就要用到列表索引
# 计算机编号从0开始，相关方式类比数组
heros = ['张三', '张四', '张五', '张六', '张七', '张八']
print(heros[1])

即可获取张四，同理可以获取其他元素，若要同时获取多个元素，则要使用列表切片的办法

# 1:3表示索引的一个左闭右开区间，只包含左边不包含右边
heros = ['张三', '张四', '张五', '张六', '张七', '张八']
print(heros[0:6])
# [3:]若省去终止位置，则表示从标明的初始位置一直索引到终止位置
heros = ['张三', '张四', '张五', '张六', '张七', '张八']
print(heros[0:])

这样就可以把上述元素全部输出出来了（俩个方法结果一样）

输出结果为 [‘张三’, ‘张四’, ‘张五’, ‘张六’, ‘张七’, ‘张八’]

但是显然不可能所有的取法步长都为一也不可能都是顺序取元素

# 完整格式  print(列表名(初始位置:终止位置:步长)) 默认步长为+1
#输出从第一个元素开始的所有奇数项元素
heros = ['张三', '张四', '张五', '张六', '张七', '张八']
print(heros[0::2])

我们在长数据超大数据时，往往不方便一次看出到底有多少个元素

# len()函数可以获取列表的长度
print(len(heros))

我们往往需要增加删除修改查找列表元素，实现列表元素动态管理

（增删改查）

增
# append可以实现列表元素增加
heros.append('张九')
# insert函数可以定向添加元素
# insert方法只是插入元素，原来在此位置以及之后的元素全体后移
heros.insert(3, '张六plus')

删
# pop或者remove可以实现列表元素删除
# 列表.pop[索引]表示删除特定位置索引位置的元素
heros.pop() # 若索引为空表示删除最后一个元素
heros.remove('张三') # 移除张三这个元素

改
heros[0] = '张三plus' # 实现修改定向位置的元素

查
# index函数可以实现查找某一元素具体位置，并通过变量存储，在案例实现的时候有奇效
number1 = heros.index('张三')
print(number1)
# 可以利用 in 来判断元素在不在列表内
# 格式  查找的元素 in 列表名  返回值是布尔类型，可以用int转换后用变量储存下来
heros = ['张三', '张四', '张五', '张六', '张七', '张八']
number3 = int('张2' in heros)
print(number3)  #输出1或0
# index 和 in 可以相互补充相互协调，index返回具体位置，in判断在不在，还可以配合后面的count来判断在不在

有些时候一个列表会有很多重复的元素，我们需要函数来帮我们进行计数

# 列表名.count（要查询的元素）   返回值为元素个数
heros = ['张三', '张四', '张五', '张六', '张七', '张八']
heros.append('张三')
heros.append('张三')
heros.append('张三')
heros.append('张三')
number2 = heros.count('张三')
print(number2)

2. 字典的使用

# 基础格式 变量名字 = {key1:value1,key2:value2}
hero = {'姓名': '孙悟空','性别': '男', '定位':'战士' }
print(hero)
print(type(hero))

得到的结果是<class ‘dict’>即构成了一种新的数据类型列表

字典还可以和列表搭配使用

hero = {'姓名': '孙悟空', '性别': '男', '定位': '战士', '最佳搭档': ['八戒', '沙僧', '唐僧']}
print(hero)
print(type(hero))
# 那如何获取里面中的东西呢
print(hero['性别'])
# 如何判断字典里面是否有我们查找的键呢
# print(字典名.get(查找的键,如果找不到返回的东西))
hero = {'姓名': '孙悟空', '性别': '男', '定位': '战士', '最佳搭档': ['八戒', '沙僧', '唐僧']}
print(hero.get('定位', '未知'))
# 我们用get的时候，如果键存在则返回键的值，如果键不存在则返回设定的返回值，如果我们没有设定返回值，则返回NONE

字典同样支持增删改查操作，实现动态管理

hero = {'姓名': '孙悟空', '性别': '男', '定位': '战士', '最佳搭档': ['八戒', '沙僧', '唐僧']}
hero['血量'] = 4399 # 对于一个原来没有的键进行操作会添加
hero['性别'] = '未知' # 对于一个原来有的键进行操作会修改
print(hero)
# 字典名.pop[键名]表示删除特定键
heros.pop('定位') 
# 可以利用 in 来判断元素在不在字典内
# 格式  查找的键 in 字典  返回值是布尔类型，可以用int转换后用变量储存下来
hero = {'姓名': '孙悟空', '性别': '男', '定位': '战士', '最佳搭档': ['八戒', '沙僧', '唐僧']}
number4 = int('姓名' in hero)
print(number4)
# value函数可以输出字典的所有值
hero = {'姓名': '孙悟空', '性别': '男', '定位': '战士', '最佳搭档': ['八戒', '沙僧', '唐僧']}
print(hero.values())
# 结果为：                                                    dict_values(['孙悟空', '男', '战士', ['八戒', '沙僧', '唐僧']])
# value的作用不光只是显示，还可以配合in进行逻辑判断
hero = {'姓名': '孙悟空', '性别': '男', '定位': '战士', '最佳搭档': ['八戒', '沙僧', '唐僧']}
print(int('孙尚香' in hero.values())) # 返回值为布尔类型

3. 字符串的使用

# 单引号，双引号，三引号三种声明方式，三引号的优点在于可以原样输出，空格空行都会被保留
hero1 = 'hello'
hero2 = "hi"
hero3 =     '''
            hello
            hi
            '''
print(hero1, hero2, hero3)

字符串和列表一样，也有切片和索引的访问形式

把字符串当成字符的列表

message = '王者荣耀'
print(message[0])
print(message[:2]) # 从初始位置到2这个位置
# 案例 在任意一个输入字符串中，查找是否有英雄这个子串
string = input('请输入一个字符串')
lenstr = int(len(string))
for x in range(0, lenstr):
    if string.find('英雄') >= 0:
 # find函数可以查找，如果找到显示第一个字符的位置，如果没找到会返回-1
        print('有英雄这个子串')
        break
    else:
        if x == lenstr - 1 :
            print('没有英雄这个子串')
        else:
            continue
print(string.startswith('王者'))
print(string.endswith('王者'))
# startswitch函数可以判断是否以某某字符或字符串开头，返回值为布尔类型
# endswitch函数可以判断是否以某某字符或字符串结尾，返回值为布尔类型

简化字符串技巧

strip()去除了字符串 开头和结尾的空白字符

# strip函数
s = '       hello\\\\mm\n\n\n\n'
print(s.strip())

输出结果是:hello\mm

第七讲 函数

1. 函数的作用与定义
2. 函数的参数
3. 函数的返回值

# 函数格式（定义）
def sum(num): 
# def关键字表示定义一个函数 sum是函数名 num是形参可以有多个
    result = 0
    for x in range(1, num+1):
        result += x
        print(result)
# 要注意缩进，以及分号的使用
# 函数调用
# 调用格式: 函数名（参数）这里参数是实参
def sum(num):
    result = 0
    for x in range(1, num+1):
        result += x
        print(result)
number = 1
sum(number)

案例

定义一个函数来实现用户的登录

def login():
    username = input('输入用户名')
    password = input('输入密码')
    if username == 'admin' and password == '123456':
        print('登录成功')
    else:
        print('登录失败')
login()

函数的参数

# 有参传参，无参空着，顺序一致
def milk_tea(n,kind='波霸奶茶'): # n表示奶茶数量，kind表示奶茶种类
    # 默认参数一定要在普通参数后，默认参数可以不传参使用默认值
    # 可以有很多默认参数但一定要在所有普通参数结束后再写默认参数
    for i in range(n):
        print('正在制作第{}杯奶茶'.format(i+1))
        print('放入{}的原材料'.format(kind))
        print('调制奶茶')
        print('倒入奶茶')
        print('封口')
milk_tea(5)
milk_tea(1, '珍珠奶茶')
milk_tea(4, '椰果奶茶')
milk_tea(5, '黑糖珍珠奶绿')

关键字参数

def milk_tea(n, kind='波霸奶茶',price=15): # n表示奶茶数量，kind表示奶茶种类
    print('顾客您需要的{},每杯{}元，应收{}元'.format(kind,price,n*price))
    for i in range(n):
        print('正在制作第{}杯奶茶'.format(i+1))
        print('放入{}的原材料'.format(kind))
        print('调制奶茶')
        print('倒入奶茶')
        print('封口')
milk_tea(1)
milk_tea(2, '原味奶茶')
milk_tea(n=4, kind='原味奶茶',price=18) # 关键字参数可以自定义传输

返回值

# 计算从1到num的和
def ger_sum(num):
    total = 0
    for i in range(1, num + 1):  # 直接从1开始遍历
        total += i
    return total
num=5
num1 = int(num)
result = ger_sum(num1)
print('result = {}'.format(result))

第八讲 面向对象基础

知识讲解

一类人或一类车等的定义方法用列表太过复杂，所以抽象出类这一概念

面向过程编程（把大象放进冰箱需要几步）

• 把冰箱门打开
• 把大象装进去
• 把冰箱门关上

面向对象编程（大象，冰箱的种类，具象化目标具象化实现）

1. 类的定义

# class 类名:
#     属性
#     方法

要求

1. 类的首字母必须大写

2. 类名后面必须有冒号

3. 类体有缩进

4. 类的方法：类中定义的函数称为方法

   类中的方法定义与函数定义基本相同，区别有：

5. 方法中的第一个参数必须是self,而且不能省略

6. 方法的调用实例化类，并以“实例名.方法名”形式调用

7. 整体进行一个单位的缩进，表示其属于类中的内容

8. 面向对象三大特征：

   1. 多态：同一个方法调用由于对象不同会产生不同的方法
   2. 封装：隐藏对象的属性和实现细节，只对外提供必要的方法。通过私有属性，私有方法的方式，实现封装
   3. 继承：继承可以让子类具有父类的特性，提高代码的重用性

代码示例：

1. 类的定义

class Phone:
    pass
# 在python中 pass是空语句，是为了保持程序结构的完整性。pass不做任何事情，一般用于占位有语句，支撑结构
class Phone:
    brand = '华为'
    color = '黑色'
    type = 'Mate30 pro'
    price = 9999
# 定义行为和函数相似，只是必须带上一个参数self
    def call(self):
        print('打电话')
    def send_message(self):
        print('可以发信息')
class Saiya:
    name = '悟空'
    hair = '固定'
    has_tail = True
    appetite = '大'
    def fight(self):
        print('我们赛亚人就是喜欢战争')

2. 类的使用类的定义主要用途是把一个类的所有特征抽象出来，而用到具体对象时则需要讲抽象的特征一一赋值一一对应

# 对象名 = 类名（参数），其中参数是可选参数，可有可无
phone1 = Phone()
phone2 = Phone()
phone3 = Phone()
print(phone1)
print(phone2)
print(phone3)
# 访问方式  对象名.属性名  or   对象名.方法名
print(phone1.price)

3. 属性添加的方式

# __init__魔术构造方法也就是构造函数，会在开始时自动调用
class Person:
    country = '中国'
    def __init__(self,name):
# self表示对象本身，self.name = name表示在当前对象中增加一个属性并且赋值（在这里也就是Person）
        print('我是一个__init__方法')
        self.name =name
    def eat(self):
        print('我是一个吃货')
p1 = Person('龟龟')
p2 = Person(name = '兔兔')
p1.eat()
p2.eat()

1. 通过外层的对象动态添加
2. 使用构造函数添加

4. 类的方法的定义与调用

class Person:
    name = '悟空'
    def __init__(self,name):
        self.name =name
    def eat(self):
        print('我是一个吃货')
    def sprot(self, time):
        if time < 6:
            print(self.name + '你怎么这么勤快，这么早就起床了')
        else:
            print(self.name + '怎么这么爱睡懒觉！')
        self.eat()
p1 = Person(name = '龟龟')
p2 = Person(name = '兔兔')
p1.sprot(time=3)
p2.sprot(time=7)

5. 类的封装

#前面加双下划线"__"使其变成私有
class Dog:
    #设置私有属性
    __legs=4
#     内部设置方法
    def print_legs_count(self):
        print(f'狗有{self.__legs}条腿')

# 实例化小狗
my_dog=Dog()
my_dog.print_legs_count()

用get/set方法

class Dog:
    __legs=4
    def get_legs(self):
        return self.__legs
    def set_legs(self,legs):
        self.__legs=legs

my_dog=Dog()
print(my_dog.get_legs())
my_dog.set_legs(2)
print(my_dog.get_legs())

6. 类的继承

class Person:
    def __init__(self, name):
        self.name = name
    
    def eat(self):
        print(self.name + '我是一个吃货')

class Saiya(Person):  # Saiya 继承 Person
    def sport(self, time):
        if time < 6:
            print(self.name + '你怎么这么勤快，这么早就起床了')
        else:
            print(self.name + '怎么这么爱睡懒觉！')
        self.eat()  # 调用父类的 eat() 方法

# 实例化 Saiya 并测试方法
saiya1 = Saiya("悟空")  # 创建对象，自动调用 __init__
saiya1.eat()          # 调用继承自 Person 的方法
saiya1.sport(4)       # 调用 Saiya 新增的方法（早睡情况）
saiya1.sport(8)       # 调用 Saiya 新增的方法（懒睡情况）

super()实现

class Person:
    def __init__(self, name):
        self.name = name
    
    def eat(self):
        print(self.name + '我是一个吃货')

class Saiya(Person):
    def __init__(self, name):
        super().__init__(name)  # 调用父类的 __init__
    
    def sport(self, time):
        if time < 6:
            print(self.name + '你怎么这么勤快，这么早就起床了')
        else:
            print(self.name + '怎么这么爱睡懒觉！')
        super().eat()  # 显式调用父类的 eat()

# 测试
saiya1 = Saiya("悟空")
saiya1.eat()      # 输出: 悟空我是一个吃货
saiya1.sport(4)   # 输出: 悟空你怎么这么勤快... \n 悟空我是一个吃货
saiya1.sport(8)   # 输出: 悟空怎么这么爱睡懒觉！ \n 悟空我是一个吃货

多继承语法格式

class A:
    pass
class B:
    pass
class C(A,B):
    pass

class Dog:
    def __init__(self,name):
        self.name=name
    def show_info(self):
        print(f'狗的名字叫做{self.name}')
    def run(self):
        print('狗跑的很快')
class Husky:
    def __init__(self,name):
        self.name=name
    def show_info(self):
        print(f'哈市其的名字叫:{self.name}')
    def run(self):
        print("哈士奇跑得快")

    def sofa(self):
        print("哈士奇咬沙发")

class MyDog(Dog,Husky):
    def __init__(self,name,age):
        super().__init__(name)
        self.age=age
    def show_info(self):
        print(f'MyDog的名字叫：{self.name}')

my_dog=MyDog('小嘎',4)
my_dog.run()   #输出狗跑的很快
my_dog.sofa()   #输出哈士奇咬沙发
my_dog.show_info()  #输出：MyDog的名字叫：小嘎

第九讲 模块

1. 模块简介与导入

#创建一个文件test_module_1.py
#创建一个自定义模块
#自定义模块
test_name='自定义模块test_module_1的变量'
def test_function():
    print("自定义模块test_module_1的函数")

编写主程序

import test_module_1
print(test_module_1.test_name)
test_module_1.test_function()

当导入多个模块的时候，并且模块内有同名的功能，这时候调用同名功能用的是后导入的功能查看模块位置

import sys
print(sys.path)   
输出：
['E:\\python', 'E:\\python', 'D:\\Program Files\\JetBrains\\PyCharm 2023.3.7\\plugins\\python\\helpers\\pycharm_display', 'D:\\Program Files\\Python312\\python312.zip', 'D:\\Program Files\\Python312\\DLLs', 'D:\\Program Files\\Python312\\Lib', 'D:\\Program Files\\Python312', 'C:\\Users\\ASUS\\AppData\\Roaming\\Python\\Python312\\site-packages', 'D:\\Program Files\\Python312\\Lib\\site-packages', 'D:\\Program Files\\JetBrains\\PyCharm 2023.3.7\\plugins\\python\\helpers\\pycharm_matplotlib_backend']

2. 自定义包包就是一个文件夹其中必须包含一个__init__.py 的文件。这个可以是一个空文件，仅表示该目录是个包。包可以嵌套，即把子包放在某个包中包可以看作同一目录中的模块在Python中首先需要先使用目录名，然后使用模块名导入需要的模块举个例子：建包:my_package建完自动生成__init__.py空文件

#在包下创立文件package_module_1.py
def print_info():
    print("my_package中的模块1的函数")

#在包下创立文件package_module_2.py
def print_info():
    print("my_package中的模块2的函数")

在demo.py调用这两个模块：

from my_package import package_module_1,package_module_2
package_module_1.print_info()
package_module_2.print_info()

3. 系统内置模块
   1. time模块
   2. random模块
   3. os模块

# 可以获取当前的时间戳
import time
t1 = time.time()
print(time.ctime(t1))
# 利用sleep函数进行每隔一秒循环进行一次
import time
for i in range(5):
    print(i)
    time.sleep(1)
# datetime
# datetime中封装了date,time,datetime,timedelta其中timedelta是值时间差
from datetime import *
print(datetime.now())
dt = datetime.now()
dt1 = dt + timedelta(days=-1) # 表示日期-1
print(dt, dt1, sep='\n')

import random
print(random.random()) # 表示从0到1的随机小书
print(random.randint(1, 10))
# 表示从1到10的随机整数（包括1和10）
print(random.randrange(1, 10))
# 表示从1到10的随机整数（不包括10）
print(random.choice(range(10)))
# random.choice(列表或数据集)，表示从列表或数据集中随机获取一个元素，起到定范围而又随机的作用

import os
# 查看当前工作目录
result1 = os.getcwd()
print(result1)
# 在当前文件夹中创建一个文件夹
# os.mkdir()只能创建一级目录。而os.makedirs()可以创建多级目录。
os.mkdir('images')
# 获取当前环境变量
print(os.environ)
# 获取绝对路径
result = os.path.abspath('harry.py')
print(result)
# os.listdir('package')查看文件列表
# os.remove('package/text.py')删除某个模块
注意以下操作只能针对同级或下级文件，如harry.py中使用下面代码则会报错，一定要在与package同级的.py文件中操作才有用
result = os.listdir('package')
print(result)
os.remove('package/text.py')
# 查看文件大小
path = './package/harry.py' # .表示当前目录下
result = os.path.getsize(path)
print(result)
# 查看是否为文件
result1 = os.path.isfile('path')
print(result1)
# 查看是否为文件夹
result1 = os.path.isdir('path')
print(result1)

第十讲 文件操作和异常处理

文件操作

1. 文件写入
2. 文件读取
3. csv文件的写入
4. csv文件的读取

# open()函数的使用，open函数的作用是打开一个文件并且有返回值（布尔类型）
# 文件要素：存放位置，文件名字
# 相对位置 ./main.py同一目录下的文件表示
# 绝对路径 D://user/hello/main.py
stream = open(file='./666') # 变量stream起到了传输管道的作用
print(stream)

输出结果为<_io.TextIOWrapper name=‘./666’ mode=‘r’ encoding=‘cp936’>

mode = 'r’读操作,'w’写操作,'a’追加,'t’文本格式,'b’字节方式读取且这些字母可以组合使用

encoding表示编码集即翻译方式

# mode，encoding可以修改
stream = open(file='./666', mode='w')
print(stream)
stream = open(file='./666', mode='w', encoding='utf-8')
print(stream)

文件写入以及关闭

stream = open(file='./666', mode='w', encoding='utf-8')
print(stream)
record = '4月18日 17：00 FPX PK RNG'
stream.write(record) # 文件写入
stream.close() # 文件关闭 一定要关闭涉及数据安全
# 如果打开的文件不存在，则会新建一个文件
stream = open(file='./text1.txt', mode='w', encoding='utf-8')
print(stream)
# 将mode改成a即可实现不断追加，但追加并不会帮我们换行，所以当我们需要换行的时候需要在加入的文本前用换行符号
stream = open(file='./text1.txt', mode='a', encoding='utf-8')
print(stream)
record = '\n4月18日 17：00 FPX PK RNG'
stream.write(record) # 文件写入
stream.close()

那如果数据量很大怎么办呢

record = ['4月1日 17：00 IG PK RA',
          '4月2日 17：00 LGD PK SN',
          '4月3日 17：00 FPX PK RA',
          '4月4日 17：00 SN PK WE',
          '4月5日 17：00 JDG PK FPX',
          '4月6日 17：00 SN PK TEX'
          ]
stream = open('records.txt',mode='w',encoding='utf-8')
for record1 in record: # 通过循环来进行写入并在后面添加换行符号
    stream.write(record1 + '\n')
stream.close()
stream = open('records.txt',mode='a',encoding='utf-8')
# 再次写入的时候格式要变成a，并且重新打开
stream.write('123456')
stream.close()
# 写入后一定要关闭文件

那文件的读取改如何操作

stream = open('records.txt', mode='r', encoding='utf-8')
# 读取中格式为r
content = stream.read()
# 用一个变量保存我们阅读的值
print(content)
stream.close()
# 读格式和写格式有所不同，当写格式文件不存在的时候会创建一个文件，而读取一个不存在的文件则会报错

csv文件的操作

csv文件是以逗号隔开的

import csvrecord = [['4月1日 17：00 IG PK RA'],          ['4月2日 17：00 LGD PK SN'],          ['4月3日 17：00 FPX PK RA'],          ['4月4日 17：00 SN PK WE'],          ['4月5日 17：00 JDG PK FPX'],          ['4月6日 17：00 SN PK TEX']]with open('electronic_sport.csv', 'w', encoding='utf_8') as stream:    writer = csv.writer(stream)    writer.writerow(['date', 'time','adversary'])    for recod in record:    writer.writerow(recod)    # 也可以直接用writer.writerows来实现多行同时写入

文件写入不同操作系统的展示结果不同，windows常会附加空行

如有需要改变可以open(‘electronic_sport.csv’, ‘w’, encoding=‘utf_8’，newline = ‘’ )

csv文件的读取

with open('electronic_sport.csv', mode='r', encoding='utf-8') as stream:    reader = csv.reader(stream)    for row in reader:        print(row)

文件的异常处理

# 格式
try:
    可能会有异常的代码
except:
    发生异常的时候要执行的代码
finally:
    无论是否有异常都要执行的代码

# 方法1
content = None
try:
    stream = open('records.txt', mode='r', encoding='utf-8')
    content = stream.read()
except:
    print('文件找不到')
finally:
    print(content)
 # 这段代码逻辑就是，设置变量为空，如果文件可以找到并打开，将改空代码重新赋值并且输出，如果文件无法找到并打开，则会输出except的提示语句，并且输出空。这样就可以避免了报错导致程序异常终止
输出：
文件找不到
None

# with关键字的使用
with 表达式 as 变量:
    语句

with open('records.txt',mode='r',encoding='utf-8') as  stream:    content = stream.read()    print(content)

第十一讲 多任务的介绍

想要实现多个函数同时执行就要使用多任务，充分利用CPU资源

多任务就是电脑同一时间内执行多个任务

两种表现形式：并发和并行

进程的介绍

进程是资源分配的最小单位，它是操作系统进行资源分配和调度运行的基本单位

说白了：一个正在运行的程序就是进程

def func_a():
    print("任务A")
def func_b():
    print("任务B")
func_a()
func_b()

是否可以让func_a和func_b同时运行呢？用多进程就可以

多进程是python实现多任务的一种方式

多进程完成多任务

进程创建步骤

1. 导入进程包。import multiprocessing
2. 通过进程类创建进程对象。 进程对象=multiprocessing.Process(target=任务名)
3. 启动进程执行任务。 进程对象.start()

注意第二步，括号里面歧视有很多参数

# 创建子进程
coding_process=multiprocessing.Process(target=coding)
# 创建子进程
music_process=multiprocessing.Process(target=music)
#启动进程
coding_process.start()
music_process.start()

举个例子：

单任务

import time
def coding():
    for i in range(3):
        print("coding...")
        time.sleep(0.2)
#听音乐
def music():
    for i in range(3):
        print("music...")
        time.sleep(0.2)

if __name__=='__main__':
    coding()
    music()

改进成多任务：

import time
import multiprocessing

def coding():
    for i in range(3):
        print("coding...")
        time.sleep(0.2)
#听音乐
def music():
    for i in range(3):
        print("music...")
        time.sleep(0.2)

if __name__=='__main__':
    # 创建子进程
    coding_process = multiprocessing.Process(target=coding)
    # 创建子进程
    music_process = multiprocessing.Process(target=music)
    # 启动进程
    coding_process.start()
    music_process.start()

程序运行起来就默认创建一个主进程，两个子进程是主进程创建的，两个子进程是2个主进程启动的

进程执行带参数的任务

args参数的使用

coding_process = multiprocessing.Process(target=coding,args=(3,))  
coding_process.start()

kwargs参数的使用

#kwargs:表示以字典的方式给函数传参
coding_process = multiprocessing.Process(target=coding,kwargs={"num":3})  
coding_process.start()

举个例子：

import time
import multiprocessing

def coding(num,name):
    for i in range(num):
        print("coding...")
        print(name)
        time.sleep(0.2)
#听音乐
def music(count):
    for i in range(count):
        print("music...")
        time.sleep(0.2)

if __name__=='__main__':
    # 创建子进程
    coding_process = multiprocessing.Process(target=coding,args=(3,"zxy"))
    # 创建子进程
    music_process = multiprocessing.Process(target=music,kwargs={"count":2})
    # 启动进程
    coding_process.start()
    music_process.start()

获取进程编号

当程序中的进程越来越多，就无法区分主进程和子进程和不同的子进程。实际上为了方便管理，每个进程都是有自己的编号的，通过获取编号就可以快速区分不同的进程

1. 获取当前进程编号 getpid()方法
   1. os.getpid()的使用

import os
def work():
    #获取当前进程的编号
    print("work进程编号：",os.getpid())

2. 获取当前父进程编号 gerppid()方法
   1. os.getppid()的使用

if __name__=='__main__':
    #获取主进程
    print("主进程>>>%d"%os.getppid())
    # 创建子进程
    coding_process = multiprocessing.Process(target=coding)
    # 创建子进程
    music_process = multiprocessing.Process(target=music)
    # 启动进程
    coding_process.start()
    music_process.start()

进程间不共享全局变量

进程间是不共享全局变量的

实际上创建一个子进程就是把主进程的资源进行拷贝产生了一个新的进程，这里主进程和子进程是相互独立的

也就是说操作的不是一个进程里面的全局变量，只不过是不同进程里面的全局变量名字相同而已

验证：

#定义全局变量
import multiprocessing

my_list=[]

#写入数据函数
def write_data():
    for i in range(3):
        my_list.append(i)
        print("add:",i)
    print(my_list)

#读取数据函数
def read_data():
    print(my_list)

if __name__=='__main__':
    # 创建写入数据的进程
    write_process=multiprocessing.Process(target=write_data)
    #创建读取数据进程
    read_process = multiprocessing.Process(target=read_data)
    write_process.start()
    read_process.start()

运行结果：

add: 0
add: 1
add: 2
[0, 1, 2]
[]

主进程和子进程的结束顺序

主进程会等待所有的子进程执行结束再结束

import multiprocessing
import time
#工作函数
def work():
    for i in range(10):
        print("工作中。。。")
        time.sleep(0.2)

if __name__=='__main__':
    #创建子进程
    work_process=multiprocessing.Process(target=work)
    #启动子进程
    work_process.start()
    #延时一秒
    time.sleep(1)
    print("主程序执行完毕")

结果：

工作中。。。
工作中。。。
工作中。。。
工作中。。。
工作中。。。
主程序执行完毕
工作中。。。
工作中。。。
工作中。。。
工作中。。。
工作中。。。

如何保证主进程销毁之后子进程也直接销毁？

设置守护主进程 ： 主进程.daemon=True

import multiprocessing
import time
#工作函数
def work():
    for i in range(10):
        print("工作中。。。")
        time.sleep(0.2)

if __name__=='__main__':
    #创建子进程
    work_process=multiprocessing.Process(target=work)
    #设置守护主进程，主进程退出后子进程直接销毁，不再执行子进程中的代码
    work_process.daemon=True
    #启动子进程
    work_process.start()
    #延时一秒
    time.sleep(1)
    print("主程序执行完毕")

输出：

工作中。。。
工作中。。。
工作中。。。
工作中。。。
工作中。。。
主程序执行完毕

另外一种方式：手动销毁子进程 子进程.terminate()

import multiprocessing
import time
#工作函数
def work():
    for i in range(10):
        print("工作中。。。")
        time.sleep(0.2)

if __name__=='__main__':
    #创建子进程
    work_process=multiprocessing.Process(target=work)
    #启动子进程
    work_process.start()
    #延时一秒
    time.sleep(1)
    #让子进程直接销毁，表示终止运行，主进程退出之前，把所有的子进程直接销毁就可以了
    work_process.terminate()
    print("主程序执行完毕")

第十二讲 网络

网络是将具有独立功能的多台计算机通过通信线路和通信设备连接起来，在网络管理软件及网络通信协议下，实现资源共享和信息传递的虚拟平台

学习网络的目的是编写基于网络通信的软件或程序，通常来说就是网络编程

IP地址介绍

IP地址是分配给网络设备上网使用的数字标签，它能够标识网络中唯一的一台设备

IP地址分为两类:IPv4（目前使用的）和IPv6

ifconfig和ping命令

ifconfig：查看网卡信息

127.0.0.1代表本机（也称localhost）

ping：检查网络是否正常

ping 本机通了说明本机网络没问题

端口和端口号

每个运行的程序都有一个端口，想要给对应程序发送数据，找到对应的端口即可

端口就是传输数据的通道，想要找到端口找到端口号即可

端口号就是一个数字

端口号有65536个

用IP地址找到对应的设备，通过端口号找到对应的端口，然后通过端口把数据给应用程序

端口号可分为：知名端口号（0到1023，这些端口号通常分配给一些固定的任务，比如21端口分配给FTP服务，25端口分配给SMTP服务，80端口分配给HTTP服务）和动态端口号（1024到65536，开发过程若为指定则操作系统在这个范围内随机生成一个给开发的应用程序使用）

socket分类

socket(套接字)是程序之间网络通信的一个工具，好比知道对方的电话号码才能给对方打电话，程序之间想要进行通信需要基于这个socket

程序之间网络数据的传输可以通过socket来完成

TCP

数据不能乱发送，发送之前要选择网络传输方式（传输协议），保证程序之间按照指定的传输规则进行数据的通信

TCP简称传输控制协议，面向连接的，可靠的，基于字节流的传输层通信协议

通信步骤：创建连接，传输数据，关闭连接。

python3编码转换

数据转化用到了：

encode()和decode()函数可以接受参数，encoding是指在编解码过程中使用的编码方案

bytes.decode(encoding=“utf-8”)

str.encode(encoding=“utf-8”)

TCP客户端程序开发

主动发起建立连接请求的是客户端程序

等待接受连接请求的是服务端程序

客户端socket类的参数和方法说明：

要用到的函数

# 模板
# 导入socket模块
import socket
#创建客户端socket对象使用socket类
socket.socket(AddressFamily,Type)

举个例子：

客户端：client.py

import socket

if __name__ == '__main__':
    try:
        # 1. 创建 socket
        tcp_client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

        # 2. 连接 Node.js 服务器
        tcp_client_socket.connect(("127.0.0.1", 8080))  # 确保端口一致

        # 3. 发送数据
        tcp_client_socket.send("Hello Node.js Server!".encode("utf-8"))

        # 4. 接收服务器回复，,rece阻塞等待数据的到来
        recv_data = tcp_client_socket.recv(1024)
        print("服务器回复:", recv_data.decode("utf-8"))

        # 5. 关闭连接
        tcp_client_socket.close()
    except Exception as e:
        print("发生错误:", e)

服务端 server.js

const net = require('net');

// 创建 TCP 服务器
const server = net.createServer((socket) => {
    console.log(`客户端已连接: ${socket.remoteAddress}:${socket.remotePort}`);

    // 接收客户端数据
    socket.on('data', (data) => {
        console.log(`收到客户端消息: ${data.toString()}`);
        socket.write("你好，我是Node.js服务器！"); // 回复客户端
    });

    // 客户端断开连接
    socket.on('end', () => {
        console.log('客户端已断开连接');
    });
});

// 监听 8080 端口
server.listen(8080, '0.0.0.0', () => {
    console.log('服务器已启动，等待客户端连接...');
});

先运行服务端再运行客户端

TCP服务端程序开发

TCP服务端程序开发相关函数：

举个例子:

服务端 server.py

import socket
if __name__=='__main__':
    # 创建服务端套接字对象。
    tcp_server_socket=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    #  绑定IP地址和端口号
    #如果bind中的第一个参数IP地址元素设置为"",默认为本机IP地址
    tcp_server_socket.bind(("",8080))
    # 设置监听128:代表服务端等待连接排队的最大数量
    tcp_server_socket.listen(128)
    # 等待接受客户端的连接请求 accept阻塞等待
    conn_socket,ip_port=tcp_server_socket.accept()
    print("客户端地址：",ip_port)
    # 接收数据
    recv_data=conn_socket.recv(1024)
    print("接收到的数据是：",recv_data.decode())
    # 发送数据
    conn_socket.send("客户端你的数据我收到了".encode())
    # 关闭套接字
    conn_socket.close()
    tcp_server_socket.close()

# 输出：
# 客户端地址： ('127.0.0.1', 57402)
# 接收到的数据是： 你好，服务端！

客户端 client.py

import socket

if __name__ == '__main__':
    try:
        # 1. 创建客户端套接字（IPv4, TCP）
        tcp_client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

        # 2. 连接服务端（假设服务端运行在本机 8080 端口）
        server_ip = "127.0.0.1"  # 本机回环地址
        server_port = 8080
        tcp_client_socket.connect((server_ip, server_port))
        print("已连接到服务端...")

        # 3. 发送数据到服务端
        send_data = "你好，服务端！".encode("utf-8")  # 编码为字节流
        tcp_client_socket.send(send_data)
        print(f"已发送数据: {send_data.decode('utf-8')}")

        # 4. 接收服务端的回复
        recv_data = tcp_client_socket.recv(1024)  # 最大接收 1024 字节
        print(f"服务端回复: {recv_data.decode('utf-8')}")

    except ConnectionRefusedError:
        print("连接被拒绝，请检查服务端是否启动！")
    except Exception as e:
        print(f"发生错误: {e}")
    finally:
        # 5. 关闭套接字
        tcp_client_socket.close()
        print("客户端已关闭")

# 输出：
# 已连接到服务端...
# 已发送数据: 你好，服务端！
# 服务端回复: 客户端你的数据我收到了
# 客户端已关闭

注意的点：