python基础复习汇总

基础数据                   

 

1. int
    整数
2. str
    字符串
    所有程序根源就是字符串.
    1. capitalize 首字母大写
    2. title 标题,每个单词的首字母大写
    3. upper 转化成大写 -> 忽略掉用户输入的大小写问题
    4. lower 小写
    5. replace(old, new) 字符串替换
    6. split() 字符串切割  默认使用空白切割  切割的结果放在列表
    7. strip()  去掉空白(\n \t 空格)
    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)