Python笔记

一、变量

1、命名

- 类命名：大驼峰（每个首字母大写，单词串联）
- 变量命名：POSIX（全小写，下划线连接）

2、变量类型

- 整数类型（int）
- 浮点数（float）
- 字符串（str）
    - 转义字符“\n:换行，\t:制表符”
    - 格式化输出
        %s：格式化输出字符串
        %d：格式化输出整数
        %f：格式化输出浮点数
            %.2f：保留两位小数点
    - f-字符串
        f'{‘我的名字｛name｝，我的年龄｛age｝’}
    - print结束符
        print（‘内容’，end=""）
- 布尔值（bool）
    true = 1
    false = 0
- 元组（tuple）
- 集合（set）
- 字典（dict）

3、运算符

- 算数运算
    加、减、乘、除 = +  -  *  /
    取余 = %
    取整 = //
    幂运算 = **
- 比较运算（结果为布尔值）
    等于 = ==
    不等于 = ！=
    大于 = >
    小于 = <
- 赋值运算
    赋值 = =
- 逻辑运算
    与 = and
    非 = not
    或 = or
    - 运算规则
        true为1，false为0，and为乘法，or为加法，值为0则false，否则为true
        a的值一定为true是，运行到or则不再向下运行，逻辑运算短路
- 成员运算
    检测某一个变量是否为另一个变量的成员
    in ， not in
- 身份运算
    检测两个变量是否为同一变量
    is ， not is

4、用户输入

- input
    password = input('请输入的密码'）
    print（password）
- 数据类型转换
    整数    int（x）
    浮点数    float（x）
    字符串    str（x）
    计算在字符串中的有效python表达式，并返回一个对象    eval（str）
    将序列s转换为一个元组    tuple（s）
    将序列s转换为一个列表    list（s）

二、程序结构

1、判断分支

- 表达式   
    if 条件表达式 ：    （条件表达式为布尔值，注意冒号）
        语句1
        语句2
    elif 条件表达式：    （elif可以没有，可以多个；elif只选择一个执行）
        语句1
        语句2
    else：                （else可以没有，最多一个）
        语句1
        语句2
 - 三目运算（例）
    a = 1
    b = 2
    c = a if a > b else b        （条件成立时的表达式 if 判断条件 else 不成立的表达式）
    print(c)

2、循环结构

（1）、while循环

- 表达式
    while 条件表达式：        （当表达式成立的时候执行循环）
        语句1
        语句2
    else：            （else可以没有，当表达式不成立时执行一次，结束循环）
        语句1
        语句2
- 案例（打印10次）
    a = 10
    while a > 0:
        print(f'"今天天气真好" {a}')
        a = a-1
    else:
        print("结束了")

（2）、break、continue和pass

- break
    终止整个循环结构（注意，break结束后，不执行else后语句）
- continue
    结束当前一次循环，执行下次循环
- pass
    略过，占位符不执行

（3）、九九乘法表

- '九九乘法表'
    i = 1
    while i <= 9:
        j = 1
        while j <= i:
            print(f'{i}*{j}={i*j}',end="\t")        ‘\t为制表符使格式美观’
            j += 1
        print()
        i += 1

（4）、for循环

- 表达式
    for 变量 in 序列：    ‘循环变量不重要可用下划线代替，序列为列表形式’
        语句1
        语句2
    else：            ‘else可以省略，表示循环后最后一次执行’
        语句1
        语句2
- 案例
    str1 = "hello"
    for a in str1:
        print(a)

3、顺序结构

- 自上而下，逐行执行，遇到错误停止

三、内置数据结构（变量类型）

1、字符串--str

    - 格式化输出
        name = ‘tom’
        print（‘我的名字是%s’ % name）
        print（f‘我的名字是｛name｝’）
    - 格式化输入
        input输入的数据为字符串格式
    - 下标
        - 每一个字符串，电脑会给他一个从0开始的编号
        - 打印字符串的第二的字符
            a = 'hello'
            print(a[1])        ‘注意括号为中括号’
    - 切边
        - 截取字符串的一部分
        - 语法
            序列【开始位置下标：结束位置下标：步长】
            注意：左闭右开

（1）、字符串常用方法

    - 查找
        - find（rfind-从右侧查找）
            查找字符串中是否有某一个字符，如果有返回字符左边，否则返回-1
            str1 = '我叫mt，哈哈，你叫神魔'
            print(str1.find('叫', 1, 6))        ‘1是其实查找下标，6是结束查找坐标’
        - index（rindex-从右侧查找）
            和find相似，查找值不存在时报错
        - count
            统计某字符的出现次数
    - 修改
        - replace（）：替换
            字符串序列.replace(旧字符，新字符，替换次数）
                a = 'hello'
                b = a.replace('l', '9')
    - 分割
        - split（）：按照指定字符分割字符串，返回列表，会丢失分割字符
            字符串序列.split（字符，分割次数）
    - 合并
        - join（）：合并列表的字符
            字符串.join（多字符序列）
    - 大小写转换
        - capitalize（）：字符串首字母大写，其他小写
        - title（）：将字符串每个单词都大写
        - lower（）：所有大写转小写
        - upper（）：所有小写转大写
    - 删除空白字符
        - lstrip（）：删除字符串左侧空白字符
        - rstrip（）：删除字符串右侧空白字符
        - strip（）：删除字符串两侧空白字符
    - 字符串对齐       
        - ljust（字符长度，填充字符）：左对齐
        - rjust（字符长度，填充字符）：右对齐
        - center（字符长度，填充字符）：中间对齐
    - 字符串判断
        - startswith（）：判断是否是以某字符开头，返回布尔值
            字符串.startswith（子串，开始下标，结束下标）
        - endwith（）：判断是否是以某字符结尾，返回布尔值
            字符串.endwith（子串，开始下标，结束下标）
        - isalpha（）：非空字符串全部由字母组成，返回布尔值
        - isdigit（）：非空字符串全部由数字组成，返回布尔值
        - isalnum（）：非空字符串全部由字母或数字组成，返回布尔值
        - isspace（）：都是空白，返回布尔值

2、列表--list

（1）、列表的常用操作

- 查找
    - 按照下标
        a = ['aaa', 'bbb', 'sss']
        print(a[1])
    - 函数
        - index（）：类似字符串中的，返回下标
        - count（）：类似字符串中的，返回出现次数
        - len（）：查看列表的长度，即数据个数
    - 判断是否存在
        - in
        - not in
- 增加
    - append（）：在列表结尾增加
    - insert（）：指定位置插入
        a.insert(3,666)        在a的第四个位置插入666
- 删除
    - del（）：删除指定位置
    - remove（）：按值删除
    - pop（）：把末尾元素拿出来
    - clear（）：清空，地址不变
- 改变
    - 分片
        l=[1,2,3,4,5]
        print(l[1:4:2])     包左不包右，从0开始，【起始：结束：步长】
    - 运算
        加号相连表示列表相接
        乘号相连表示n个列表相接
        b （not）in a       b是否在列表内，返回布尔值
    - 复制
        a = [1,2,3]
        b = [i for i in a]
        c = [i for i in a if i = 3]    过滤
    - 其他函数
        len（）：列表长度
        max（）：列表最大值
        mix（）：列表最小值
        list（）：转换为列表
        reverse（）：列表翻转
        count（）：列表中有几个被查元素
        extend（）：列表拼接
        copy（）：拷贝

3、元组--typle 类似列表，但是不能更改

（1）、创建

    - 创建空的
        t = ()
    - 创建只有一个值的
        t = (1,)
    - 创建多个值的
        t = (1,2,3,4)
    - 其他结构创建
        l = [1,2,3]
        t = typle(l)

(2)、操作

    - 索引
        t = (1,2,3,4,5,6)
        print(t[4])
    - 超标错误
        print(t[12])
    - 切片
        t1 = t[1:2:2]        【开始：结束：步长】类似列表
    - index（）：元素在元组中的位置

4、集合--set 类似列表，确定的无序唯一的数据

（1）、创建

s = set()
s={1,2,3,4}

（2）、操作

- add（）：向集合中增加
- clear（）：清空
- copy（）：拷贝
- remove（）：移除特定值，值不存在时报错
- discard（）：移除指定的值，值不存在不报错
- pop（）：随机移除一个元素
- intersection（）：交集
- difference（）：差集
- union（）：并集
- issubest（）：检查一个集合是否是另一个集合的子集
- issuperset（）：检查一个集合是否是另一个集合的超集
- forzen set（）：冰冻集合

5、字典--dict

（1）、创建

d = {}
d = dict()

（2）、操作

- 循环
    d={'a':1,'b':2,'c':3}
    for k,v in d.items()
- 字典生成式
    dd = {k:v for k,v in d.items() if v%2 ==0)
- clear（）：清空
- items（）：返回字典键值对

四、OOP--python面向对象

1、面向对象（Object Orjented）

- OOP思想--任务由这个世界构成
    OO:面向对象
    OOA：面向对象的分析
    OOD：面向对象的设计
    OOI：面向对象的实现
    OOP：面向对象的编程
- 类和对象的概念
    - 类：抽象名词，代表一个集合，共性的事物
    - 对象：具体的事物，单个个体
    - 类的内容
        变量--表明事物的特征，叫做属性
        函数--表明事物的功能或动作，叫做方法

2、类的基本实现

- 类的命名
    大驼峰，避开系统命名
- 类的声明
    必须用class关键字
    只能有属性和方法
    成员属性定义可以直接使用变量赋值
- 实例
    class PythonStundent():
        name = none            -- 属性
        age = 18
        coutse = 'python'
        def dohomework(self)        -- 动作
            print("我做作业")
            return none

    xiaoli = PythonStudent()    -- 实例化
    print(xiaoli.name())
- 其他
    xiaoli.__dict__        对象的所有属性
    PythonStundent.__dict__            类的所有属性
    在对象没有新的属性复制时，他的属性和类的相同，并指向同一块内存

3、类与对象的成员分析

- 类储存成员的时候，使用与类关联的一个对象
- 创建一个对象的时候，如果对象没有该成员，则和类使用同一成员
- 创建对象的时候，创建的是一个空的对象
- 修改对象的成员，对类不会有影响

4、关于self

- self表示自己，会回传给自己本身，不是关键参数，可以更改
- 方法中，有self是非绑定类方法，可以对象调用，没有self，则只能用类调用
- 用类调用绑定类方法，使用类的属性，则可以用__class__调用
- 调用A类的方式时，有方法需要的成员就可以执行，可以是A的对象，A,B，都可以--鸭子模型

5、面向对象的三大特性

（1）、封装

- 对对象成员进行访问限制
- 封装的三个级别--不是关键字
    - 公开，public
    - 受保护的，protected
    - 私有的，private
- 判别对象的位置
    - 对象内部
    - 对象外部
    - 子类中
- 私有
    - 最高级别封装，只能在当前类和对象中访问
    - 在成员前添加两个下划线，（python障眼法，name mangling的改名策略）
        class Person():
            name = 'll'   --name为共有
            __age = 14    --age为私有
- 受保护的
    - 类和子类都可以访问，在外部不行
    - 封装方法，在成员前添加一个下划线
- 公开的
    - 没用操作

（2）、继承

- 继承是一个类可以获得使用另一个类中的成员属性和成员方法
- 作用：减少代码
- 继承与被继承
    - 被继承的类：父类，基类，超类
    - 用于继承的类： 子类。派生类
- 特征
    - 所有类都是object类的子类
    - 可以继承共有，受保护的
    - 子类指向父类，在同一内存
    - 子类的属性不会影响父类
    - 子类中定义的如果和父类相同，优先子类的
    - 子类如果想扩充父类的方法，可以用父类名.父类成员的格式或super().父类成员的格式
- 代码示例
    class Person():
        name = 'none'
        age = 0
        def sleep(self):
            print('Sleep.....')
    class Teacrer(Person):        --继承Person
        def work(self):
            pass
        def sleep(self):
            Person.work(self)        --在父类的方法上进行扩充，还可以用super
            print('ooo')
- 继承变量函数的查找顺序问题
    - 优先查找自己
    - 二级，查找父类
- 构造函数
    - 是一种特殊函数，在实例化的时候第一个自动调用
    -概念
        class Dog():
            def __int__(self):        --此函数为构造函数
                pass
- __mro__        --查父类（MethodResolustionOrder)
- 单继承和多继承
    - 多继承存在菱形问题
    - 示例
        class dog(dongwu,aa)
            pass
- 构造函数
    - 在实例化的时候，系统自动调用的函数。用于实例初始化
    - 实例
        class person():
            def __init__(self):        --此句定义构造函数
                self.name = "noname"
                self.age = 18
    - 当实例化的时候没有构造函数，则去找他父类的构造函数，按照MRO的顺序

（3）、多态

五、高级语言

1、模块

- 一个python文件
-解决模块导入时被执行
    if _name_ == '_main'