Python入门笔记

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. 类的方法：类中定义的函数称为方法

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

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

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

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

4. 面向对象三大特征：

   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. 属性添加的方式

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

   # __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()
   

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() 方法
   

   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. 模块简介
2. 模块导入
3. 包的导入
4. 模块搜索路径
5. __name__的使用
6. 常见系统模块介绍

# 创建模块的本质就是创建一个.py文件，它可以被其他模块导入并使用
# 调用模块的方法
# import 
# from ... import
# 模块命名要用小写字母，且不要和内置模块重名
创建一个.py文件（harry.py）
# harry.py
name = 'Harry Potter'
age = 10
def Fight(tool=None):
    if tool:
        print('在魔法学校驾驶' + tool + '练习飞行')
    else:
        print('走到魔法学校就会练习飞行了！')
class Course:
    def __init__(self,name,c_list=[]):
        self.name = name
        self.c_list = []
    def add_course(self,c_name):
        if c_name:
            self.c_list.append(c_name)
        else:
            print('选修课不能为空')
    def remove_course(self,c_name):
        if c_name:
            self.c_list.remove(c_name)
        else:
            print('选修课不能为空')
再创建一个magic.py文件
# magic.py
def use_magic():
    print('我会施展厉害的魔法')

此时两个模块已经封装完毕，我们只需要import 模块名即可调用模块里面的函数变量以及类，我们的使用方式主要是通过点运算符来完成的

# 在包文件中进行调用（一般导入语句都在开头）
import harry
import magic
print(harry.name)
harry.Fight()
c = harry.Course('哈利')
c.add_course('黑魔法防御术')
magic.use_magic()
# 模块重命名
import harry as hy # 这样防止模块名字太长起到重命名的作用
# 导入方法2
from harry import name
from harry import Fight
from harry import Course
print(name)
Fight()
c = Course('哈利')
c.add_course('黑魔法防御术')
# 这种方法就不用使用harry.的方法，相当于提前声明来源，简化逻辑，也可以起到引入特定变量特定函数特点类的作用
# from harry import name
# from harry import Fight
# from harry import Course
也可以用以下表达代替用来简化代码
from harry import name, Fight, Course
或者
from harry import *
# 这个表示把所有的都导入

导入模块从本质上来说就是去执行一个.py文件，开辟一个新内存，把导入的东西放进内存中，这样我们调用就可以直接从内存中获取，当模块数量越来越多时，我们就需要通过包的形式对模块进行管理

包就是一个包含__init__.py的文件夹

# 创建一个包(包的命名规则与模块相同)
# 右键点击new，然后创建python package

# 创建好以后将之前封装好的harry.py和magic.py拖到包中文件夹

包的导入

# 拖入后我们可以看到原来的导入格式被修改了
from package.harry import *
# 编译器自动维护了package.的格式表明路径
import sys
print(sys.path)
# 利用sys包我们可以查找我们当前脚本文件的位置
# 在新创建的包文件中创建magic1,magic2,text的.py文件
magic1.py
def use_magic():
    print('我会施展最厉害的魔法')
print('我是一个新的magic模块' + __name__)
text.py
from package.harry import *
from package.magic1 import use_magic
# __name__的用途在于，如果在它原本的模块运行，输出为__main__在别的模块运行则输出为路径。可以利用这一性质，来实现一些语句只模块内输出而不模块外输出
magic.py
def use_magic():
    print('我会施展最厉害的魔法')
if __name__ == '__main__':
    print('我是一个新的magic模块' + __name__)
这样'我是一个新的magic模块'这个语句就不会被误输出了！妙啊

系统内置模块

• # time模块 
  # 可以获取当前的时间戳
  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')
  

• # random模块
  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(列表或数据集)，表示从列表或数据集中随机获取一个元素，起到定范围而又随机的作用
  

• # os模块
  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)
  

第十讲 python的文件操作（自动化记录）

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()
# 读格式和写格式有所不同，当写格式文件不存在的时候会创建一个文件，而读取一个不存在的文件则会报错

文件的异常处理（处理报错情况）

• # 格式
  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的提示语句，并且输出空。这样就可以避免了报错导致程序异常终止
  

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

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

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)