10月16学习归纳总结

10月16学习归纳总结

一、文件读写操作

1.文件的操作

1.文件的概念
  文件精神操作系统给用户操作硬盘最快捷的方式
2.打开文件
  双击打开文件，就是把硬盘中的东西读取出来，加载到内存
3.保存文件
  保存文件就是，把内存中的东西放入硬盘最简便的方式，把内存中的数据刷到硬盘保存
4.打开文件的两种方式
  方式1：
     f =  with open(r'a.txt', 'r',encode = 'utf8') as f:
     f.close()
 # 为了解决路径与有些字母混在一起出现一些其他意思的问题，我们在文件路径前面加上r,就能很好地处理这个问题了       
  方式2：
     with open(r'a.txt', 'r',encode = 'utf8') as f:
        with 子代码
 # with代码的好处就是代码结束以后自动调用close方法关闭资源

2.文件读写模式总概括

二、文件多种方法及光标移动

1.文件操作的诸多方式

1.read()
# 一次性读取文件，如果光标停留在文件末尾，再读则为空取不到，括号内可以写数字，写数字几表示读取几个字符
2.for循环
# 读取文件内容，文件过大时，不建议一次性读取，建议一行一行的读取，避免内存溢出
3.readline()
# 一行一行的读取文件内容
eg:
    with open(r'a.txt', 'r', encoding = 'utf8') as f:
        print(f.readline())
4.readlines() 
# 一次性读取文件内容，会按照行数将取到的数据排列出来
eg:
    with open(r'a.txt', 'r', encoding = 'utf8') as f:
        print(f.readlines())
5.readable()
# 是否具有读的能力
eg:
    with open(r'a.txt', 'r', encoding = 'utf8') as f:
        print(f.readable())
6.write()
# 写入数据
eg:
    with open(r'a.txt', 'r', encoding = 'utf8') as f:
        f.readline('今天适合努力')
7.writeable()
# 判断是否具备写数据的能力
eg:
    with open(r'a.txt', 'r', encoding = 'utf8') as f:
        print(f.writeable())
8.writelines()
# 一次性将读取到的文件写出来
eg:
    with open(r'a.txt', 'r', encoding = 'utf8') as f:
        f.writelines('今天适合学习')
9.flush()
# 将内存中的文件数据刷到硬盘，相当于ctrl + s
eg:
    with open(r'a.txt', 'r', encoding = 'utf8') as f:
        f.writelines('今天适合学习')
        f.flush()

2.文件光标的移动

我们在读取文件时，光标会随着我们的移动读取内容移至末尾，下面已经在方法让我们能够光标随着指令移动
1.read()  文本模式
# 在文本模式下，读取文件内容时，括号内填写读取字符的个数，换行符算两个字节
eg:
    with open(r'a.txt', 'r', encoding = 'utf8') as f:
        print(f.read(3))
2.read()  二进制模式
# 在二进制模式下，读取文件内容时，括号内填写读取的个数，英文一个字节，中文三个字节，换行符算两个字节
eg:
    with open(r'a.txt', 'r', encoding = 'utf8') as f:
        data = f.read(3) 
        print(data(decode()))   # 解码
3.tell()  读取内容的字节数
eg:
    with open(r'a.txt', 'r', encoding = 'utf8') as f:
        data = f.read(3) 
        print(data(decode()))   # 解码
        print(f.tell())
4.seek(offset,whence)
# offset是位移量，whence是模式
eg:
    with open(r'a.txt', 'r', encoding = 'utf8') as f:
        print(f.read())
        f.seek(7,4)

3.decode与encode的区别

1.decode---->>解码     encode---->>编码
2.字符串在Python内部表示是unicode编码，在做编码转换时，通常用Unicode作为中间编码
3.decode--->将其他字符串解码成unicode,然后再从unicode编码成另外一种编码
  encode--->将unicode编码换成其他编码的字符串
 '''
编码：
 res = '数据值'
 data = bytes(需要编码的变量名, '编码格式') #encode
解码：
 ret = 数据类型(需要解码的变量名，'')
'''
eg:
# 编码
res = 'go'
data = bytes(res,'utf8')
print(data,type(data))   # b'go' <class 'bytes'>
# 解码
res = 'go'
# data = bytes(res,'utf8')
print(res,type(res))     # go <class 'str'>

三、文件拷贝方式

1.文件拷贝方式

先读取再将读取的内容写入
eg:
    with open(r'a.txt', 'r', encoding = 'utf8') as f:
       data = f.read(3)
     with open(r'b.txt', 'w', encoding = 'utf8') as f1:
       f1.write(data)

2.字节与字符的区别

字节(bytes)是计量单位，表示数据量的多少，是计算机用于计量存储容量的一种计量单位，通常下一字节等于八位。1bytes = 8bit
字符(character)计算机中使用字母，数字，字和符号。

四、函数的定义、返回值与分类

1.python函数是指组织好的、可重复使用的、用来实现单一或相关联功能的代码段,通过一个函数名封装起来，若想执行这个函数，只需要调用函数名。
2.语法结构
  def 函数名(参数)：
    函数体代码
    return 返回值
3.函数在调用阶段只检测语法，不执行代码
4.函数的分类
 1.空函数：函数体用pass或者....代替，函数体没有任何的功能，主要用于前期项目的框架搭     建，提示主要功能，让整体的框架清晰
 2.无参函数
  定义函数阶段括号内没有参数
    def func():
        print('from function')
3.有参函数
  函数定义阶段括号内有参数，类似于变量，调用函数的时候括号传参数
    def func(a):
         print(a)

五、函数的参数、名称空间及作用域

1.形参与实参

1.形式参数
  在函数定义阶段括号内填写的参数，简称'形参'
2.实际参数
   在函数调用阶段括号内填写的参数，简称'实参'
形参与实参的关系：
  形参类似于变量名，在函数定义阶段可以随便写，最好知名见意
   eg：
     def register(name, pwd):
        pass
 实参类似于数据值，在函数调用阶段与形参临时绑定，函数运行结束立刻断开
    eg:
        register('jason', 123) 形参name与jason绑定，形参pwd与123绑定
  eg:
    def register(name, pwd):
        print(name,pwd)
    register('jason', 123)

2.位置参数

1.位置形参
  在函数定义阶段括号内从左到右依次填写的变量名
  def func(a, b, c):pass   # 当代码只有一行的情况下，可以直接在冒号后编写，不用换行
2.位置实参
  在函数调用阶段括号内从左到右依次填写的数据值
  eg:
    def func(a, b,c):
        print(a,b,c)
    func(1,2,3)     # 1 2 3
    name = 'jason'
    func(name,1,2)   # jason 1 2
 # 实参必须要与形参的个数一一对应（个数一致),不能多也不能少

3.关键字参数

1.关键字实参，给函数传值时指定参数名
2.关键字参数指调用阶段，括号内什么等于什么的形式传值，比如a=name,b=pwd
3.注意位置实参必须在关键字参数的前面
4.无论是实参函数形参，遵循简单的在前，复杂的在后，同一个形参在调用的时候不能多次赋值
eg:
    def func(a,b,c):
        print(a,b,c)
    func(1,a=3,b=6)      # 报错，同一个形参不能多次赋值

4.默认参数

默认参数的本质就是关键字形参，别名默认参数，提前已经给了，用户可以不传，也可以传
eg:
    def register(name,age,gender = 'male'):
        print(f'''
        name:{name}
        age:{age}
        gender:{gender}
        ''')
    register('jason',12)    # name:jason    age:12   gender:male
    register('jia',11,'female')  # name:jason    age:12   gender:female
 # 自定义阶段，后续调用不用传值，如果自己传值的话，则后续用自己写的值

5.名称空间

eg:
   name = 'jason'
# 1.申请一个内存空间存储jason
# 2.给jason绑定一个变量名name
# 3.后续通过name就可以访问到jason了
名称空间就是用来存储变量名与数据值绑定关系的地方（存储变量名的地方）
1.内置名称空间
  解释器运行自动产生的，可直接使用的方法名字都在里面
   eg: len   print   input
2.全局名称空间
  py文件运行产生的，里面存放文件级别的名字
  eg:
    name = 'jason'
  eg: if name ='jason':
        age = 18
  eg: while True:
        gender='male'
  eg: def index()；
        pass
# 上述的name，age，gender，index都是存放文件级别的名字
3.局部名称空间
  函数体代码运行/类体代码运行 产生的空间

六、闭包函数

定义在函数内部的函数，并且用到了外部函数名称空间中的名字
条件：
    1.定义在函数内部
    2.用到外部函数名称空间中的名字
简单的一个闭包函数案例：
  def index():
    name = 'jia'
    def inner():
        print(name)
闭包函数实际应用>>>:是一种给函数体代码传参的方式！！!
1.形参方式：代码里面缺什么变量名形参里面就补什么变量名
  eg:
     def register(name,age):   # 缺什么变量名补什么变量名
        print(f'''
        name:{name}
        age:{age}
        ''')
    register('jason',18)
2.闭包方式
  eg:
     def outer(name,age):
        def register():
            print(f'''
            name:{name}
            age:{age}
            ''')
        return register
    res = outer('jason',19)
    res()
    #     name:jason   age:19

七、装饰器

1.概念：
    在不改变被装饰对象原代码和调用方式的情况下，给被装饰对象添加新的功能
2.本质：
    并不是一门新的技术，而是由函数参数，名称空间，函数的多种用法，闭包函数组合到一起的结果
3.原则：
    对修改封闭，对拓展开放
    (不可以修改，但是可以添加新功能)
4.模板：
  def outer(func):
    def inner(*args,**kwargs):
        #执行被操作对象之前的操作
        res = func(*args,**kwargs)
        # 执行被操作对象之前的操作
        return res
    return inner()

八、有参装饰器

# 当装饰器需要额外的参数时，我们可以用有参装饰器
def outter(mode):                  # '1'会被形参mode接收
    def login_auth(func_name):
        def inner(*args,**kwargs):
            username = input('请输入您的用户名').strip()
            password = input('请输入您的密码').strip()
            if mode == '1':
                print('用户名和密码是写死的')
            elif mode == '2':
                print('数据来源于文本文件')
            elif mode == '3':
                print('数据来源于字典')
            elif mode == '4':
                print('数据来源于数据库mysql')
        return inner()
    return login_auth()

@outter('1')        # 函数名加括号执行的优先级最高
def index():
    print('from index')
index()
# 函数名加括号执行优先级最高，先执行函数名加括号的操作，再是语法糖
@outter('2')
def func():
    print('from func')
func()
# 为装饰器里面传递更多的参数

九、算法及二分法、三元表达式

1.算法的概念
  算法通俗来讲就是解决问题的有效方法
  算法可以在有限的空间和时间内用定义明确的形式语言来表示，以计算函数
2.常见的二分法
  二分法，快拍，插入，堆排，链表，桶排，双向链表，约瑟夫问题等
3.二分法
   二分法是最简单的算法
   要求:待查找的数据集必须是有序的
 eg:
l1 = [11,22,33,44,55,66,77,88,99,123,456,789]
def get_num(l1,target_num):
    # 添加递归韩顺的结束条件，不然会报错
    if len(l1) == 0:
        print('没找到啊啊啊')
        return
    # 按照数据集的长度，取中间数，然后索引取值
    middle_num = len(l1) // 2
    #判断中间数和目标数的大小
    if target_num > l1[middle_num]:
        # 切片保留列表右边一半
        right_num = l1[middle_num + 1:]
        print(right_num)
        return get_num(right_num,target_num)
    elif target_num < l1[middle_num]:
        # 切片保留列表左边一半
        left_num = l1[:middle_num]
        print(left_num)
        # 针对左边的表进行二分并判断
        return get_num(left_num,target_num)
    else:
        print(l1[middle_num])
get_num(l1,22)
# [11, 22, 33, 44, 55, 66]
# [11, 22, 33]
# 22
4.三元表达式基本形式：
   数据值1 if条件 else 数据值2

十、各种内置函数及可迭代对象

记住下面这个图：

1.迭代就是更新换代，但是每次的更新都是基于上次。类似于我们更新微信版本，没更新一次功能变多但是它依旧是聊天软件。
2.内置方法中有__iter__方法的都叫可迭代对象。通过.__iter__若有则是.__name__叫双下name。
3.整型、浮点型、布尔型、函数名都为不可迭代对象
字符串、列表、集合、字典、元组、集合、文件都是可迭代对象

原文地址：http://www.cnblogs.com/zx0524/p/16797394.html