小甲鱼python学习视频笔记

小甲鱼python学习视频笔记

基础知识

变量

• 在使用变量前需要对其先赋值
• 变量名可以包括字母、数字、下划线，但是不能以数字开头
• 字母可以大小写，但是大小写是不同的
• 等号是赋值的意思，左边是名字，右边是值，不可写反
• 变量命名理论可以取任何合法的名字，一个优秀的程序员需要给变量取一个专业的名字

数据类型

1. 字符串

• 字符串要成对得加上引号，单引号或者双引号均可
• 若字符串中需要出现单引号或者双引号：
  1）采用转义符号（\）对字符串中得引号进行转义
  2）用单引号引起这个字符串，例如：’ I l"o"ve fishc.com ’
• 原始字符串
  1）当出现特殊的\引用时，可以利用反斜杠对自身进行转义
  例如：str = “C:\now"就不会出现转行
  2）如果一个字符串中有很多个反斜杠，不如利用原始字符串进行打印，即加字母r，但字符串末尾不可加
  例如：str = r"C:\now”
• 长字符串（跨越多行）
  使用三重引号字符串得到跨越多行的长字符串
• 常用的字符串函数
  
  
• 字符串格式化
  1）format（）：接收未知参数和关键字参数
  eg：未知参数"{0}love{1}.{2}".format(“I”,“Fish”,“com”) —> “I love Fish.com”
  eg：关键字参数"{a}love{b}.{c}".format(a=“I”,b=“Fish”,c=“com”)
  eg：两种参数可以综合使用，未知参数必须在关键参数之前"{0}love{b}.{c}".format(“I”,b=“Fish”,c=“com”)
  2）格式化符号
  
  
  

2. 常用函数

• 整型、字符串和浮点型之间的转换
  整型int（），字符串str（），浮点型float（）
• 获得关于类型的信息
  type（）函数：获取输入的类型
  isinstance（）函数：判断两个输入类型是否一致

常用操作符

• 算术操作符
  1）%为取余数，**为幂次运算，//为整除（即使浮点数也是整除后的浮点数）
  2）优先级问题
  幂运算比起左侧的一元操作运算符优先级高，比起右侧的一元操作运算符优先级低
  幂运算>正负号>算术操作符>比较操作符>逻辑运算符
• 比较操作符
• 逻辑运算符

数据结构

1. 列表（list）

• 可以存放不同类型的数据，即混合列表
• 向列表添加元素
  1）append（）：参数为添加的元素，一次只能添加一个元素
  2）extend（）：参数为一个列表，用一个列表来扩展另一个列表
  3）insert（）：参数两个，第一个参数为添加的位置，第二个参数为添加的元素
• 从列表中获取元素
  与数组一样，通过元素的索引值从列表中获取单个元素，索引从0开始
• 从列表中删除元素
  1）remove（）：参数为元素，并不需要知道具体位置
  2）del（语句非函数）：del 列表[索引]
  3）pop（）：缺省时是堆栈形式，删除最后一个元素；加上索引可固定弹出某一元素
• 列表分片
  1）利用列表分片，一次性从列表中获取多个元素
  2）用冒号进行索引提取，如列表[2:6]
• 列表的一些常用操作符
  1）比较操作符：数字从第一个开始，只要为假即返回假
  2）逻辑操作符
  3）连接操作符：+连接两个列表
  4）重复操作符：*重复列表中的元素
  5）成员关系操作符：in/not in判断元素是否在列表中
• 列表中的内置函数
  1）count（）：计算某一列表中某个元素的个数
  2）index（元素，开始，结尾）：从开始到结尾位置元素出现的位置
  3）reverse（）：将整个列表翻转
  4）sort（）：对列表的成员进行排序，默认从小到大；若从大到小排序，list.sort(reverse=True)

2. 元组（tuple）

• 列表和元组的区别
  1）列表可以任意修改当中的元素，但是元组不可改变，不能任意插入或者删除
  2）创建和访问元组
  创建：用小括号表示，但是列表为中括号表示
  访问：均是使用索引进行直接访问
  3）单元素：列表[1]即可，但是元组需要写(1，)，否则为整型
  4）加入或删除一个元素
  元组加入元素：例如temp[:2]+(元素，)+temp[2:]
  元组删除元素：几乎是不可能的，不能使用del，但是可以使用切片的方式间接删除
  5）元组相关的操作符：拼接、重复、关系、逻辑、比较

3. 字符串
4. 序列（列表、元组、字符串）

• 常用内置函数
  1）list（）：把一个可迭代对象转换为列表
  2）tuple（[iterable]）：把一个可迭代对象转换为元组
  3）str（obj）：把obj对象转换为字符串
  4）max（）：返回参数或者序列中的最大值
  min（）：返回参数或者序列中的最小值
  注：元素类型需要相同，否则无法比较
  5）len（）：返回长度
  6）sum（iterable[，start=0]）：返回序列iterable和可选参数start的总和
  7）sorted（）：与list.sort（）性质相同
  8）reversed（）：需要list（reversed（））才可以显示出最终结果

5. 字典

• 创建和访问字典（dict）
  1）创建：{键：值，键：值}或函数dict（（（键：值），（键：值）））或dict（键=值，键=值）
  2）当dict[键]中的键为字典中已有的时，则改变其值，若键没有，则添加该对元素
• 常用函数
  1）dict.fromkeys（s[，v]）:设置一个字典键为s，值均为v，v缺省为None，其中s可为多个键
  2）dict.keys（）访问键，dict.values（）访问值，dict.items（）访问键和值
  3）dict[键]若无该键则出错，故采用dict.get（ [，]），有该键则返回值，否则返回None或者自定义的提示语
  4）=为浅拷贝，占据同样的内存位置，对原始字典的操作会影响拷贝过来的字典的内容
  dict.copy（）为深拷贝，占据不同的内存位置，对原始字典的操作不会影响拷贝过来的字典的内容
  5）pop给定键弹出对应的值，popitem弹出顶部的一对键值
  6）dict.setdefault（）：有该键则返回值，否则将该键添加进入字典，默认值为None，可自设初始值
  7）dict.update（）：用一对键值更新字典中的内容

6. 集合（set）
   1）创建：set = {1，2，3，4}或者工厂函数set（[1，2，3，4]）
   2）集合中元素具有唯一性，如果定义时有重复的数字，会自动消除
   3）集合是无序的，不具备索引功能
   4）访问集合中的值：使用for将集合中的数据一个个读取出来，或者利用in和not in判断一个元素是否在集合中已经存在
   5）增加元素set.add（）去除元素set.remove（）
   6）不可变集合：frozenset（[1，2，3，4]），不可添加或删减元素
7. 文件
   

逻辑结构

1. 分支
   1）elif = else if
   2）python可以有效避免“悬挂else”，因为匹配的if和else缩进相同
   3）条件表达式（三元操作符）：small = x if x <y else y
   4）断言：assert关键字后面的条件为假时，程序自动崩溃并抛出AssertionError的异常，一般用于程序中置入检查点，来确保程序中某个条件一定为真才能让程序正常工作
2. 循环
   1）标准格式
   while 条件：循环体
   for 目标 in 表达式（为一个列表）：循环体
   2）生成for表达式的序列：range（[start=0,]stop[,step=1]）生成一个从start开始到stop结束的且步进为step的数字序列（包含start但是不包含stop），其中括号中的参数可以省略
   3）两个关键的语句
   break：终止当前循环
   continue：终止本次循环并开始下一次循环，并需要测试循环条件是否为真
3. 丰富的else语句（不一定与if连用）
   1）要么怎样，要么不怎样（与if一起使用）
   2）干完了能怎样，干不完就不能怎样（与循环例如while使用）
   3）没有问题，那就干吧（异常处理中使用）
4. 简洁的with语句

异常处理

• python标准异常总结
• 检测异常语句
  1）try-except语句

try：
     检测范围
except Exception[as reason]：
     出现异常（Exception）后的处理代码

2）try-finally语句

try：
     检测范围
except Exception[as reason]：
     出现异常（Exception）后的处理代码
finally：
     无论如何都会被执行的代码

3）raise语句+异常

函数

1. 基础知识

• 函数的定义——def 函数名（参数）：函数体
• 函数文档：函数名._doc_打印函数中的注释文档（未用#注释的其余注释）
• 参数
  1）形参：函数定义过程中的参数，只是一个形式，表示占据一个参数位置
  2）实参：实际传递进来的参数，是具体的参数值
  3）关键字参数：即使改变赋值实参的顺序，标注关键字也可以正确输出
  4）默认参数
• 函数作用域：局部变量和全局变量

2. 内嵌函数和闭包
   1）python可以函数内嵌函数
   2）内部函数的整个作用域都在外部函数之内
   3）闭包：如果内部函数中对外部作用域中的变量进行引用，则内部函数被认为闭包
   注意：此时如果内部函数对外部函数引用，则提前在内部函数中声明[nonlocal 变量]
3. lambda表达式
   1）格式：lambda x：2 * x + 1
   注：实际上定义了一个函数，即g = lambda x：2 * x + 1
   2）作用
   编写一些执行脚本时，使用lambda就可以省下定义函数过程使代码更加精简；
   对于一些比较抽象并且整个程序执行下来只需要一两次的函数，使用lambda避免了函数命名问题；
   简化代码的可读性，避免重新跳到函数定义处进行阅读。
4. 两个重要的内置函数（BIF）
   1）filter（function or None，iterable）过滤器
   eg：filter（None，[1，0，False，True]）—>[1，True]将正的筛选出来
   eg：filter（odd，range（10））—>[1，3，5，7，9]将函数作用后得正数得原始数据筛选出来
   2）map（function，iterable）将序列的每个元素作为函数的参数进行映射，返回作用后序列结果值
   eg：map（lambda x：x * 2，range（10））—>[0，2，4，6，8，10，12，14，16，18]
5. 递归（详见算法）
   斐波拉契数列&汉诺塔问题

类和对象

1. 对象 = 属性 + 方法
2. OO（面向对象）的特征
   1）封装：信息隐蔽技术
   2）继承：子类自动共享父类之间数据和方法的机制
   3）多态：不同对象对同一方法响应不同的行动
3. 面向对象编程
   1）python的self相当于C++的this指针
   2）__ init __（self，parm1，parm2）：类似于构造函数
   3）公有和私有：在python中定义私有变量只需要在变量名或函数名前加上“_”两个下划线，那么这个函数或变量就会变为私有的了。
   注：python为伪私有，可以通过对象._类名__变量名访问私有变量
4. 构造和析构

• 构造
  1）__ new__（cls[，……]），返回值为一个实例对象，一般不进行重写，但是继承不可变类型时，需要对其进行重写，例如继承str类
  2）__ init __（self[,……]），返回值一定为None
• 析构
  __ del __（self）：当没有其他析构方法时会自动调用

4. 继承
   1）格式：class 子类（父类或基类）
   2）如果子类中定义与父类同名的方法或属性，则会自动覆盖父类对应的方法或属性
   3）类中出现同名方法时，如何继承的同时补充子类的内容
   调用未绑定的父类方法：父类.__ init__（self）
   使用super函数：super（）.__ init__（）
   4）多重继承：class 子类（父类1，父类2，父类3）
5. 拾遗
   1）组合：将类的实例化放进一个新类里面，从而无需继承将旧类组合进去
   2）Mix-in编程机制
   3）类、类对象和实例对象
   i）改变实例对象的值并不会改变类以及类对象的属性
   ii）改变类对象的值会直接影响实例对象的值
   iii）若对实例对象中的某项属性进行直接更改，会影响再次调用该属性时的输出，有时会报错
   iv）不要试图在一个类里面定义出所有能想到的特性和方法，应该利用继承和组合机制来进行扩展
   v）用不同的词性命名，如属性名用名词，方法名用动词
   vi）当定义的时候，为类，定义完之后就成为类对象，其定义的变量就为实例对象
   4）绑定：python严格要求方法需要有实例才能被调用，这种限制其实就是python所谓的绑定
   注：类中定义的属性是静态对象，即使类对象被删除了，这些属性依旧存放在内存中
6. 相关的内置函数

• issubclass（class，classinfo）：若第一个参数是第二个参数的子类，则返回true
  1）一个类被认为是自身的子类
  2）classinfo可以是类对象组成的元组，只要class为其中任何一个候选类的子类，则返回true
  3）object是所有类的基类，所有类都为其子类
• isinstance（object，classinfo）：检查一个实例对象是否属于一个类
  1）若第一个参数不是对象，则永远返回false
  2）若第二个参数不是类或者由类对象组成的元组，会抛出一个TypeError异常
• hasattr（object，name）：测试一个对象是否有指定的属性，属性要用字符串表示
• getattr（object，name[，default]）：default为未找到时打印的参数
• setattr（object，name，value）：若未找到则会新建并赋值
• delattr（object，name）：删除对象中指定的属性
• property（fget = None，fset = None，fdel = None，doc = None）：通过属性设置属性，在新式类中返回属性值
  1）fget为获取属性的方法，当类外面 print(对象.属性) 的时候会调用get_xxx方法
  2）fset为设置属性的方法，当类外面 对象.属性=值 的时候会调用set_xxx方法
  3）fdel为删除属性的方法，当类外面 del 对象.属性 的时候会调用del_xxx方法 ，执行删除属性操作的时候，调用del_xxx方法
  4）“引号里面是字符串内容” ----> 字符串中写该属性的描述 ，当 类名.属性名.doc 的时候会打印出字符串的内容
  eg：

class Card:
    def __init__(self, card_no):
        '''初始化方法'''
        self.card_no = card_no
        self.__money = 0
    def set_money(self,money):
        if money % 100 == 0:
            self.__money += money
            print("存钱成功！")
        else:
            print("不是一百的倍数")
    def get_money(self):
        return self.__money
    def __str__(self):
        return "卡号%s,余额%d" % (self.card_no, self.__money)
    # 删除money属性
    def del_money(self):
        print("----->要删除money")
        # 删除类属性
        del Card.money
    money = property(get_money, set_money, del_money, "有关余额操作的属性")

c = Card("4559238024925290")
print(c)

c.money = 500
print(c.money)

print(Card.money.__doc__)

#删除
del c.money
print(c.money)

执行结果：
卡号4559238024925290,余额0
存钱成功！
500
有关余额操作的属性
----->要删除money
AttributeError: 'Card' object has no attribute 'money'

8. 算术运算
9. 属性访问
   注：死循环陷阱
   1）当初始化对变量进行赋值后，再次在__ setattr__中进行赋值调用时就会出现赋值递归
   解决方法：__ setattr__中采用基类函数，即super（）.__ setattr__（），该方法较推荐
   或者在__ setattr__中采用字典形式的赋值，即self.__ dict__[name] = value
   2）同样，__getattribute __（self，name）中也容易出现相同的问题
10. 描述符

• 定义：描述符就是将某种特殊类型的类的实例指派给另一个类的属性
• 特殊类型的标准：实现以下三种之一及以上
  1）__ get__（self，instance，owner）：用于访问属性，返回属性的值
  2）__ set__（self，instance，value）：将在属性分配操作中调用，不返回任何内容
  3）__ delete__（self，instance）：控制删除操作，不返回任何内容
• propety属于描述符类

12. 定制序列

• 协议：与其他编程语言中的接口相似，规定哪些方法必须要定义，但是，在python中，协议更像是一种指南
• 容器类型的协议
  1）如果希望定制的容器是不可变的话，只需要定义__ len__（）和__ getitem__（）方法
  2）日过希望定制的容器是可变的话，除了__ len__（）和__ getitem__（）方法，还需要定义__ settitem__（）和__ delitem__（）两个方法
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kQ1k4HB7-1628308291401)(_v_images/20210806165930697_588.png =588x)]

13. 迭代器（在类中实现）
    1）iter（）：生成迭代器
    __ iter__（）
    2）next（）：指向下一个元素
    __ next__（）
14. 生成器（无需在类中实现，普通函数中就可以实现）

模块

1. 基本概念

• 定义：模块是一个包含所有定义的函数和变量的文件，其后缀名是.py，模块可以被别的程序引入，以使用该模块中的函数等功能。
• 命名空间：需要加上模块名进行内部内容调用
• 导入模块
  1）import 模块名
  2）from 模块名 import 函数
  3）from 模块名 import *
  4）import 模块名 as 自定义命名

2. 几个关键问题
   1）if __ name__ == ‘__ main__’
   若将某一个python文件作为模块进行import，同时原模块中有对函数的调用过程，则会出现import时输出模块中的调用结果。为了避免这种情况，在原模块的函数调用前加上if __ name__ == ‘__ main__’的条件判断，即当运行文档是自身文档时，才对原模块中的调用进行运行
   2）搜索路径
   当导入的模块与IDLE不在同一路径下时，会无法导入，此时可以添加路径，即依序运行
   import sys
   sys.path.append（路径）
   import 模块
   3）包
   i）创建一个文件夹，用于存放相关的模块，文件夹的名字即包的名字
   ii）在文件夹中创建一个__ init__.py的模块文件，内容可以为空
   iii）将相关的模块放入文件夹中
   iv）import 包名.模块名
3. 分类

• OS模块：操作系统
  常用的操作系统有Windows，Mac OS，Linux，UNIX等，这些操作系统底层对于文件系统的访问工作原理是不一样的，因此需要针对不同的系统考虑使用哪些文件系统模块，也就意味着程序环境一旦改变，就需要修改大量的代码来应付。有了OS模块，就不需要关心什么操作系统下使用什么模块，OS模块会帮助选择正确的模块并调用。
• pickle 模块：永久存储
  pickle.dump（）：将现有内容装入到指定的文档之中
  pickle.load（）：将文档中的内容加载出来
• time模块