zoukankan      html  css  js  c++  java
  • python基础复习汇总

    基础数据                   

    1. int
        整数
    2. str
        字符串
        所有程序根源就是字符串.
        1. capitalize 首字母大写
        2. title 标题,每个单词的首字母大写
        3. upper 转化成大写 -> 忽略掉用户输入的大小写问题
        4. lower 小写
        5. replace(old, new) 字符串替换
        6. split() 字符串切割  默认使用空白切割  切割的结果放在列表
        7. strip()  去掉空白(
     	 空格)
        8. startswith()判断是否以xxx开头
        9. endswith() 以xxx结尾
        10. index() 查找字符串中xxx字符串的索引位置
        11. find() 查找。 找到了返回索引找不到不报错返回-1
        12. count() 计数
        13. join() 连接
        14. isdigit() 判断是否是数字组成
        15. len()  求长度
    
    3. list 列表
        算法
        冒泡-> 最基本的计算机入门第一难算法. 快排
        二分法 -> 精髓: 掐头结尾曲中间
    
        树 -> 堆
        红黑树
        B树. B+4. dict 字典
             {key:value}
             key必须是可哈希的. 不可变就是可哈希
             JSON: javsscript Object native
    5. set 集合
    6. tuple 元组, 不可变。只读列表
        当涉及到数据共享的时候。 必须用不可变的数据类型
    
    7. bytes
        文件上传下载。 自己写socket, 转码
        encode
        decode
    
    8. open() 打开一个文件
        r, w, a, r+, w+, a+, rb, wb, ab.

    函数                                   

    def 函数(形参列表):
        函数体(return)
    
    函数(实参列表)
    
    函数名: 实际上就是一个变量名
    形参: 函数声明的位置写的变量的声明
        1. 位置参数
        2. 默认值参数
        3. 动态传参
            *args 动态接收位置参数
            **kwargs 动态接收关键字参数
        顺序: 位置, *args, 默认值, **kwargs
        *, ** 聚合  元组
    实参: 在函数执行的时候. 给函数传递的数据
        1. 位置参数
        2. 关键字参数
        3. 混合参数 位置, 关键字
    
        *. ** 打散 可迭代对象
    
    返回值:
        谁调用的, 返回给谁
    
    # 闭包
    def wrapper():
        a = 10 # 局部变量
        def inner(): # 闭包
            print(a)
        return inner
    
    闭包的意义:
        1. 让一个变量常驻内容
        2. 保护你的变量不被别人侵害.
    
    装饰器: 在不改变源代码基础上给函数添加新的功能. 动态代理
    通用装饰器
    from functools import wraps
    def wrapper(fn):
        @wraps(fn)
        def inner(*args, **kwargs):
            '''在xxx之前 '''
            ret = fn(*args, **kwargs)
            '''在xxx之后 '''
        return inner
    
    @wrapper
    def func():
        pass
    func()  # 此时调用的是inner  func.__name__
    
    
    迭代器
        lst = [1,2,3,4,5]
        it = lst.__iter__()
        it = iter(lst)
    
        it.__next__()
        next(it)
    
        StopIteration 迭代器中的内容被拿完了. 再次获取数据的时候就会报这个错
    
        from collections import Iterable, Iterator
        isinstance(对象, Iterable)
        isinstance(对象, Iterator)
    
        特点;
            1. 省内存 (生成器)
            2. 惰性机制
            3. 只能向前. 不能反复
    
    生成器的本质是迭代器
        创建生成器:
            1. 生成器函数
            2. 生成器表达式
    
            def func():
                yield
    
            生成器函数的特点:执行这个函数. 并没有运行.而是帮你创建一个生成器对象.
                生成器对象中存的是代码
    
            __next__()
            send() 给上一个yield位置传值
    
            列表推导式
            [结果 for循环 if判断]
    
            字典推导式
            {key:value for循环 if}
    
            集合推导式
            {key for循环 if}
    
            生成器表达式
            (结果 for循环 if判断)
    
            特点就是迭代器的特点
    
    
    nonlocal
        在局部. 把外层离他最近的局部变量引入到内层函数
    global
        把全局变量引入到局部

    面向对象                               

    面向对象和面向过程:
        面向过程: 重点在流程. 按照事务的发展顺序去写代码. 流水账
            局限性非常的大. 预见非常复杂的项目的时候
    
        面向对象: 侧重点在对象. 让对象去做xxx事情. 所有的数据都保存在对象里面
            优点: 可扩展性非常强. 以对象为中心.
    
        例子: 大象装冰箱
    
    如何创建对象:
        1. 先写类.
            class 类名(父类):
                pass
    
        2. 使用类来实例化对象
            类名()
            每个对象都有独立的名称空间.
    
        封装:
            1. 对属性进行封装 -> 把属性写在__init__(self):
                self.xxx = xxxx
            2. 对方法进行封装 -> 把方法写在类中.
                方法的调用
                对象.方法()
        继承:
            子类可以自动拥有父类中除了私有内容外的其他所有内容
    
            class Zi(Fu):
                pass
            在python中支持多继承
    
            class Zi(Fu1, Fu2, Fu3, Fu4):
                pass
    
            z = Zi()
            z.chi() # 方法的查找顺序: MRO 在新式类中使用的是C3算法,  经典类:树形结构的深度优先遍历
    
        多态:
            同一个对象, 拥有多种形态.
            动态数据类型绑定
    
            超强的可扩展性.
            多态是面向对象的核心
    
        成员:
                    return 2018-birthday
            变量
                1. 类变量    写在类中的变量, 实际上类变量是给类名使用的
                2. 实例变量  对象.变量 -> 属性
            方法
                1. 实例方法. 对象.方法()
                2. 类方法. @classmethod, 第一个参数必须是cls,  本质是类的方法. 把类当成对象来看.
                3. 静态方法. @staticmethod 对参数没有要求. 本质: 就是在类中声明了一堆函数
                    类也是对象
    
            属性
                @property  把一个方法变成属性, 不能被赋值
                def age(self):
                对象.age
    
            私有: __开头的内容, 私有的内容只能自己类中访问. 出了类以外没人能访问的到
    
            特殊成员:
                __init__
                __new__
                __getitem__  对象[]
                __enter__
                __exit__
                __str__   一个对象的字符串表示
                __repr__  原形毕露. 一个对象的官方的字符串表示
                    repr() 把一个对象还原成最应该显示的样子
    
        约束
            父类对子类进行约束
            1. 使用抛异常的形式来完成对子类的约束.
            2. 使用抽象类, 接口类来完成约束
    
        反射:
            1. getattr(对象, str)
            2. setattr(对象, str, value)
            3. hasattr(对象, str)
            4. delattr(对象, str)

    二分算法:                      

    # 查找元素的
    # 二分法前提 有序序列
    lst = [11, 22, 33, 44, 157, 245, 345, 447]
    n = int(input("请输入你要查找的数据:"))
    # 掐头结尾取中间
    left = 0
    right = len(lst) - 1
    while left <= right:
        # 算中间
        mid = (left + right)//2
        if n > lst[mid] :
            left = mid + 1
        elif n < lst[mid]:
            right = mid - 1
        else:
            print("找到了你要查找的数据. 它的索引是%s" % mid)
            break
    else:
        print("没有这个数字")

    冒泡:                     

    lst = [216, 115, 128, 19, 136,218,219,327]
    # 通过循环。 找最大的那个。 把它换到整个列表的最后
    for j in range(len(lst)): # 外层循环控制的是内层循环执行的次数
        for i in range(len(lst)-j-1): # 内层循环执行排序
            if lst[i] > lst[i+1]:
                lst[i], lst[i+1] = lst[i+1], lst[i] # 冒泡排序的核心
    print(lst)

    迭代器                                 

    lst = ["梁颖", "没叫你", "嘎哈啊", "你答应什么"]
    
    try: # 试一试
        it = lst.__iter__()
        print(it.__next__())
        print(it.__next__())
        print(it.__next__())
        print(it.__next__())
        print(1/0)
        print(it.__next__())
    except StopIteration:
        print("没了")
    except Exception:
        print("没了")
    
    def func():
        print("")
        yield "戴恩"
        print("")
        yield "段浩鑫"
    
    g = func()
    print(g)
    
    print(g.__next__())
    print(g.__next__())
    
    def add(a, b): # 求和
        return a + b
    
    def test(): # 生成器函数
        for r_i in range(4):
            yield r_i
    
    g = test() # 创建生成器 0,1,2,3
    
    for n in [2, 10]:
        g = (add(n, i) for i in g)
    n = 5
    print(list(g)) # 程序是从这里开始执行
    
    def func():
        func()
    
    func()
    
    
    a = 10
    def func():
        global a # 把全局变量拿到局部使用, 改变他
        a += 20 # a = a + 20
        print(a)
    print(a)
    
    
    def func():
        hahahaha = 10
        def inner():
            nonlocal hahahaha  # 在局部
            hahahaha += 10

    面向对象                 

    class Car: # 类就是图纸. 通过图纸可以创建具体的个体
        def __init__(self, color, name): # 初始化方法
            self.color = color
            self.name = name
            self.pai = "京A66666"
            print("一辆车就造完了")
    
        # 把不相干的一些方法集中到一起. 对方法的封装
        def run(self):
            print("会跑")
    
        def xiu(self):
            print("会修车")
    
        def jump(self):
            print("跳高")
    
        def 扔铅球(self):
            print("我的车会飞")
    
        def __new__(cls, *args, **kwargs): # 构造方法
            print("我要创建一辆车")
            return object.__new__(cls)
    
    c1 = Car("绿色", "大宝贝") # 创建车1
    c2 = Car("粉色", "小心肝") # 创建车2
    print(c1.name)
    print(c2.name)
    print(c1.color)
    print(c2.color)
    
    
    
    class Message:
        def to_wechat(self):
            pass
        def to_email(self):
            pass
        def to_qq(self):
            pass
        def to_dd(self):
            pass
        def to_oa(self):
            pass
    
    
    
    
    class A:
        pass
    class B(A):
        pass
    class C(A):
        pass
    class D(B,C):
        pass
    class E(D, A):
        pass
    class F(D):
        pass
    class G(E):
        pass
    class H:
        pass
    
    class I(H, F, G):
        pass
    print(I.__mro__)
    '''
        设L()为求某个类的MRO
        1. 拆分
        L(I) = I + L(H) + L(F) + L(G) + HFG
        L(H) = H 
        L(F) = F + L(D) + D
        L(G) = G + L(E) + E
        L(D) = D + L(B) + L(C) + BC
        L(E) = E + L(D) + L(A) + DA
        L(A) = A
        L(B) = B + L(A) + A
        L(C) = C + L(A) + A
        
        2. 合并, c3算法的核心就是这个merge, 用前面的第一项的头和后面每一项的身体比较. 如果头没有在后面的身体里出现. 
        这个头会被算出, 继续用头去比较后面的身体. 如果头在后面的身体中出现了, 此时更换为第二项的头继续和其他项的身体比较
        .....
        
        L(I) = IHFGEDBCA
        L(H) = H 
        L(F) = FDBCA
        L(G) = GEDBCA
        L(D) = DBCA
        L(E) = EDBCA
        L(A) = A
        L(B) = BA
        L(C) = CA
    '''
    # 在之前不知道a
    a = "哈哈哈" # 动态数据类型绑定 -> 多态      # 在运行 的时候. 程序看到了10才知道a是int类型
    
    # 狭义的多态性
    # alex : 站在不同的角度看同一个对象. 一个对象拥有多种形态
    # python提供的多态性:  鸭子模型. 只要会嘎嘎叫的. 就可以当做鸭子
    
    class Duck: # 鸭子
        def gagajiao(self):
            print("鸭子会嘎嘎叫")
    
    class Desk():
        def gagajiao(self):
            print("我的桌子成精了. 也会嘎嘎叫")
    
    def func(duck): # 可扩展性
        duck.gagajiao()
    
    
    class Person:
        country = "大清"  # 国家,  类变量
        def __init__(self, name, age, address): # self是 当前类的对象
            self.name = name # 实例变量
            self.age = age # 实例变量
            self.address = address # 实例变量
    
    p = Person("alex", "58", "沙河")
    print(p.name)
    print(p.age)
    print(p.address)
    # print(p.country) # 对象可以使用类变量. 但是对象不能更改类变量
    p.country = "新中国" # 此时并没有改变类变量. 给对象添加了一个实例变量.
    print(p.country)
    
    p1 = Person("wusir", "68", "巩华城")
    print(p1.name)
    print(p1.age)
    print(p1.address)
    print(p1.country)
    
    
    
    
    
    
    
    
    from abc import ABCMeta, abstractmethod
    
    # 抽象类中可以有抽象方法.
    # 有抽象方法的类一定是抽象类
    # 接口:类中所有的方法都是抽象方法
    class Base(metaclass=ABCMeta):
        @abstractmethod
        def login(self):
            pass
            # # 对子类进行约束. 约束子类中必须要重写该方法. 否则程序报错
            # raise NotImplementedError("没有写login")
    
    class Member(Base):
        def login(self):
            print("会员在登录")
    
    class Normal(Base):
        def login(self):
            print("普通人登录")
    
    class GuanLiYuan(Base):
        def login(self): # login被称为方法的覆盖. 方法的重写
            print("后台登录")
    
    def login(ren):
        ren.login()
    
    
    m = Member()
    n = Normal()
    gly = GuanLiYuan()
    login(m)
    login(n)
    login(gly)
  • 相关阅读:
    入门菜鸟
    FZU 1202
    XMU 1246
    Codeforces 294E Shaass the Great 树形dp
    Codeforces 773D Perishable Roads 最短路 (看题解)
    Codeforces 814E An unavoidable detour for home dp
    Codeforces 567E President and Roads 最短路 + tarjan求桥
    Codeforces 567F Mausoleum dp
    Codeforces 908G New Year and Original Order 数位dp
    Codeforces 813D Two Melodies dp
  • 原文地址:https://www.cnblogs.com/ls13691357174/p/10175921.html
Copyright © 2011-2022 走看看