基础数据
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 native5. set 集合6. tuple 元组, 不可变。只读列表 当涉及到数据共享的时候。 必须用不可变的数据类型7. bytes 文件上传下载。 自己写socket, 转码 encode decode8. 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 wrapsdef wrapper(fn): @wraps(fn) def inner(*args, **kwargs): '''在xxx之前 ''' ret = fn(*args, **kwargs) '''在xxx之后 ''' return inner@wrapperdef func(): passfunc() # 此时调用的是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 = 0right = len(lst) - 1while left <= right: # 算中间 mid = (left + right)//2 if n > lst[mid] : left = mid + 1 elif n < lst[mid]: right = mid - 1 else: print("找到了你要查找的数据. 它的索引是%s" % mid) breakelse: 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 + bdef test(): # 生成器函数 for r_i in range(4): yield r_ig = test() # 创建生成器 0,1,2,3for n in [2, 10]: g = (add(n, i) for i in g)n = 5print(list(g)) # 程序是从这里开始执行def func(): func()func()a = 10def 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("绿色", "大宝贝") # 创建车1c2 = Car("粉色", "小心肝") # 创建车2print(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): passclass A: passclass B(A): passclass C(A): passclass D(B,C): passclass E(D, A): passclass F(D): passclass G(E): passclass H: passclass I(H, F, G): passprint(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'''# 在之前不知道aa = "哈哈哈" # 动态数据类型绑定 -> 多态 # 在运行 的时候. 程序看到了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)