目录
3、pathlib——面向对象文件系统路径 from pathlib import Path
一、基础知识点
1.1变量
1.2字符串
1.3分支、循环
1.4数据类型（int，double，bool，转换）
- 运算
- bool
返回值为false：
- 定义为false的对象（none，false）
- 值为0的数据类型（0，0.0, Decimal(0) )
- 空的序列和集合（''，[]，set()，range()）//含空格的字符串返回值为true
1.5操作符
- 逻辑运算（and，or，not）
and与or返回值不一定是true或false：短路逻辑——从左到右只有第一个操作数的值无法确定最终结果，才对第二个操作数求职
Eg: and4——4 0and4——0 3or4——3 0or4——4
- 优先级
为什么csdn电脑版不能自动保存，
这几天学的东西全没了，
就这样吧，此博卒！！！！！
中间无了的就这样吧......再加点
四、序列
概念
可变：列表
不可变：元组、字符串
1、可在序列用的运算
- ” + ” ： 连接
(1,2,3) + (4,5,6)
>>>(1,2,3,4,5,6)
- ” * “ : 重复
- is VS is not 是否为同一对象
- in VS not in 是否包含
- del 删除对象
n = [1,2,3,4,5,6,7]
del n[5:6] //[1,2,3,4,5]
del n[:] //[]
del n //找不到列表
2、转换
- list() 将可迭代对象转化为列表
print(list("HELLO")) //['H', 'E', 'L', 'L', 'O']
print(list((1,2,3))) //[1, 2, 3]
- tuple() 将可迭代对象转化为元组
print(tuple("HELLO"))
print(tuple([1,2,3]))
//('H', 'E', 'L', 'L', 'O')
(1, 2, 3)
- str() 将可迭代对象转化为字符串
3、常用函数
- len() VS sum()
- sorted() VS .sort() //排序，前者返回新的列表，s.sort()更改列表,且只能处理列表
s = ["apple","pen","happy"]
print(sorted(s))
print(sorted(s,key=len))
//['apple', 'happy', 'pen']
['pen', 'apple', 'happy']
- reversed() VS .reverse()
- all() VS any() //所以和任一
- enumerate(可迭代对象，开始序号) //返回一个枚举对数，即一个二元组列表
s = ["apple","pen","happy"]
print(list(enumerate(s,3)))
//[(3, 'apple'), (4, 'pen'), (5, 'happy')]
- zip() //聚合多个可迭代对象,以最短为主
x=[1,2,3]
y=[4,5,6,7]
z=zip(x,y)
print(list(z))
//[(1, 4), (2, 5), (3, 6)]
- zip_longest() //import itertools 以最长为主
- map() //运算指定的可迭代对象并返回所有结果，以最短为准
x = [1,2,3]
y = [2,2,3]
mapped = map(pow,x,y)
print(list(mapped))
//[1, 4, 27]
- filter() //运算指定的可迭代对象并返回结果为TRUE的元素
- iter() //迭代器
五、字典和集合
字典
概念：Python中唯一的映射类型。映射字（key）与值（value）
1、字典的创建
- dict = {”key”: “value”} //大括号，冒号；建唯一，值不
- dict(key=”value”) //键不能加引号
d = dict(F = "70",i = "105",C = "67")
print(d)
//{'F': '70', 'i': '105', 'C': '67'}
- dict([(”key”,”value”)])
d = dict([("F","70"),("i","105"),("C","67")])
print(d)
//{'F': '70', 'i': '105', 'C': '67'}
- dict({”key”: “value”})
d = dict({"F":"70","i":"105","C":"67"})
print(d)
//{'F': '70', 'i': '105', 'C': '67'}
- dict({”key”: “value”},key1=”value1”)
- dict(zip([”key”],[”value”]))
d = dict(zip(["F","i","C"],["70","105","67"]))
print(d)
//{'F': '70', 'i': '105', 'C': '67'}
2、增、删、改、查
- fromkeys(iterable[,values]) //使所有键值都相同
d = dict.fromkeys("Hello", 22) //初始化
print(d)
d['e']=10 //更改键值
print(d)
d['a']=22 //增加键、值
print(d)
//{'H': 22, 'e': 22, 'l': 22, 'o': 22}
{'H': 22, 'e': 10, 'l': 22, 'o': 22}
{'H': 22, 'e': 10, 'l': 22, 'o': 22, 'a': 22}
- .pop(key[,defult]) //删除字典中元素，返回该键对应的值
d = dict.fromkeys("Hello", 22)
print(d)
print(d.pop('l'))
print(d.pop('i',"not in"))
print(d)
//{'H': 22, 'e': 22, 'l': 22, 'o': 22}
22
not in //当删除的键不存在时，返回指定默认值
{'H': 22, 'e': 22, 'o': 22}
- .popitem() //删除字典最后一个值
- del d[’key’] ;del d //删除字典元素和删除字典
- .clear() //清空字典内容
- .update({’key’:value}) .update(key = ‘value’) //更改键值
d = dict.fromkeys("Hello")
print(d)
d.update({'H':1,'e':2})
print(d)
d.update(l='3',o='4',y='5')
print(d)
//{'H': None, 'e': None, 'l': None, 'o': None} //键的唯一性
{'H': 1, 'e': 2, 'l': None, 'o': None}
{'H': 1, 'e': 2, 'l': '3', 'o': '4', 'y': '5'}
- .get(key[,defult]) //查找key，返回对应的值；不存在设置默认值
- .setdefult(key[,defult]) //不存在，即加入
d = dict.fromkeys("Helo")
print(d)
print(d.get('y',"None"))
print(d)
print(d.setdefault('y',"None"))
print(d)
//{'H': None, 'e': None, 'l': None, 'o': None}
None
{'H': None, 'e': None, 'l': None, 'o': None}
None
{'H': None, 'e': None, 'l': None, 'o': None, 'y': 'None'}
视图对象：当字典改变，其视图也跟着改变
- .items() //键值对的视图对象
- .keys() //键的视图对象
- .values() //值的视图对象
d = dict.fromkeys("Enjoy",365)
i = d.items()
k = d.keys()
v = d.values()
print(d)
print(i)
print(k)
print(v)
//{'E': 365, 'n': 365, 'j': 365, 'o': 365, 'y': 365}
dict_items([('E', 365), ('n', 365), ('j', 365), ('o', 365), ('y', 365)])
dict_keys(['E', 'n', 'j', 'o', 'y'])
dict_values([365, 365, 365, 365, 365])
- .copy() //浅拷贝
3、外部操作
- len()
- in || not in
- list() //list(d) keys对应的列表； list(d.values()) values对应的列表
- reversed() //逆序（3.8版以后才行）
- 嵌套
d = {"ABC":{"A":65,"B":66,"C":67},"DEF":{"D":68,"E":69,"F":70}}
print(d)
print(d["ABC"]["B"]) //[外key][内key]
d = {"ABC":[65,66,67],"DEF":[68,69,70]}
print(d)
print(d["ABC"][1]) //[外key][内索引]
//{'ABC': {'A': 65, 'B': 66, 'C': 67}, 'DEF': {'D': 68, 'E': 69, 'F': 70}}
66
{'ABC': [65, 66, 67], 'DEF': [68, 69, 70]}
66
- 字典推导式
d = {"A":65,"B":66,"C":67,"D":68,"E":69,"F":70}
print(d)
exch = {v:k for k,v in d.items()} //交换键值
print(exch)
d1 = {n : ord(n) for n in "Phone"} //生成字典
print(d1)
//{'A': 65, 'B': 66, 'C': 67, 'D': 68, 'E': 69, 'F': 70}
{65: 'A', 66: 'B', 67: 'C', 68: 'D', 69: 'E', 70: 'F'}
{'P': 80, 'h': 104, 'o': 111, 'n': 110, 'e': 101}
集合
概念：集合中所有元素都是唯一的。无序性
1、集合创建
- {“元素1”,”元素2”,”元素n”}
- 推导式{ s for s in “String”}
- set{”String”}
s = {"Hello","World"}
print(s)
s1 = {s for s in "Evian"}
print(s1)
s2 = set("Great")
print(s2)
//{'World', 'Hello'}
{'a', 'v', 'i', 'E', 'n'}
{'t', 'a', 'r', 'G', 'e'}
2、对集合的处理
- 因为无序，不能访问下标
- in || not in
- 去重 set([])
l = [1,1,2,4,3,6,1]
print(l)
s = set(l)
print(s)
//[1, 1, 2, 4, 3, 6, 1]
{1, 2, 3, 4, 6}
s = "talented"
print(s)
s = set(s)
print(s)
//talented
{'t', 'n', 'd', 'a', 'l', 'e'}
3、内置方法
| 集合（s）.方法名 | 等价符号 | 方法说明 |
|---|---|---|
| s.isdisjoint(t) | 判断s和t是否存在交集 | |
| s.issubset(t) | s <= t | 子集测试（允许不严格意义上的子集）：s 中所有的元素都是 t 的成员 |
| s < t | 子集测试（严格意义上）：s != t 而且 s 中所有的元素都是 t 的成员 | |
| s.issuperset(t) | s >= t | 超集测试（允许不严格意义上的超集）：t 中所有的元素都是 s 的成员 |
| s > t | 超集测试（严格意义上）：s != t 而且 t 中所有的元素都是 s 的成员 | |
| s.union(t) | s | t |
| s.intersection(t) | s & t | 交集操作：s "与" t 中的元素 |
| s.difference | s - t | 差分操作：在 s 中存在，在 t 中不存在的元素 |
| s.symmetric_difference(t) | s ^ t | 对称差分操作：s "或" t 中的元素，但不是 s 和 t 共有的元素 |
| s.copy() | 返回 s 的拷贝（浅复制） | |
| 以下方法仅适用于可变集合 | ||
| s.update | s | = t |
| s.intersection_update(t) | s &= t | 交集修改操作：s 中仅包括 s 和 t 中共有的成员 |
| s.difference_update(t) | s -= t | 差修改操作：s 中包括仅属于 s 但不属于 t 的成员 |
| s.symmetric_difference_update(t) | s ^= t | 对称差分修改操作：s 中包括仅属于 s 或仅属于 t 的成员 |
| s.add(obj) | 加操作：将 obj 添加到 s | |
| s.remove(obj) | 删除操作：将 obj 从 s 中删除，如果 s 中不存在 obj，将引发异常 | |
| s.discard(obj) | 丢弃操作：将 obj 从 s 中删除，如果 s 中不存在 obj，也没事儿^_^ | |
| s.pop() | 弹出操作：移除并返回 s 中的任意一个元素 | |
| s.clear() | 清除操作：清除 s 中的所有元素 |
符号运算时左右类型要相等
s = set("talented")
t = set("girl")
print(s.union(t)) //等价于print( s | t )
print(s.intersection(t)) //等价于print( s & t )
//{'r', 'e', 'g', 'd', 'i', 'a', 'n', 't', 'l'}
{'l'}
s = set("girl")
print(s)
s.update("789",[2,3,2]) //以单个集合元素插入
s1 = s
print(s1)
s.add("657") //以字符串插入
print(s) //输出的s是更新后的集合
//{'i', 'r', 'l', 'g'}
{'g', 2, '8', 3, 'r', 'l', 'i', '9', '7'}
{2, 3, '8', 'r', '9', 'i', '657', 'l', 'g', '7'}
updata方法是没有返回值的（返回值为None），不能直接赋值返回值给变量
哈希
-
hash(object) //获取对象hash值
- 整数的哈希值是本身
- 两个对象值相等，其哈希值也相等
- Python中不可变对象可哈希，可变对象不可哈希
- 可哈希对象才能创建字典和集合
-
frozenset() //将可变对象不可变
x = {1,2,3}
print(x)
x = frozenset(x)
print(x)
y = {x,4,5}
print(y)
//{1, 2, 3}
frozenset({1, 2, 3})
{frozenset({1, 2, 3}), 4, 5}
六、函数
概念
打包代码，实现代码重用，减少冗余代码
将不同功能代码封装，降低结构复杂性，提高代码可读性
1、创建和调用
-
定义：def myfunc(): 函数体
调用：myfunc()
def cnt():
for i in range(3):
print("The num is ",i)
cnt()
//The num is 0
The num is 1
The num is 2
2、函数的参数
- 位置参数（参数位置固定） ——斜杠左侧只能使用位置参数 ：sum(x,/,y)，x只能是位置参数，不能进行赋值和关键字，y则可以赋值
def fun(name,times):
for i in range(times):
print(f"The nam is: {name}")
fun("Neo",3)
//The nam is: Neo
The nam is: Neo
The nam is: Neo
- 关键字参数，只要参数名对应就行，无论位置 ——*右侧只能是关键字参数
def fun(s,vt,o):
return "".join((o,vt,s))
s1 = fun("cat ","eat ", "fish ") //s——cat
print(s1)
s = fun(s = "fish ",vt = "eat ", o = "cat ") //s——fish
print(s)
//
fish eat cat //s——cat
cat eat fish //s——fish
如果位置参数和关键字参数混用，位置参数在关键字参数之前
- 默认参数——定义在形参最后
- 函数的返回值
def fun():
pass //占位
return "Haha,Nothing"
z = fun()
print(z)
//Haha,Nothing
//返回运算
def add(x,y):
return x+y
print(add(4,8))
//12
- 参数的打包与解包
- 打包——元组; 形参加*
def fun(*args):
print(args)
fun(1,2,3,4,"end")
//(1, 2, 3, 4, 'end')
若要传入其他参数，只能用关键字传入
def fun(*args,a,b):
print(args,a,b)
fun(1,2,3,a = "y",b = "n")
//(1,2,3) y n
以字典打包，必须用关键字参数；加**
def fun(**key):
print(key)
fun(l=5,y=3,z=9)
//{'l': 5, 'y': 3, 'z': 9}
- 解包——用元组内容赋值
def fun(*args):
return 1,2,3
x,y,z = fun()
print(x,y,z)
//1 2 3
3、变量的作用域
局部变量和全局变量
- global //声明为全局变量
4、嵌套函数——在封闭函数中定义的函数
不能直接调用内部函数，若内部函数有返回，嵌套函数的外层作用域会被保留
- nonlocal //内部函数修改外部函数
- LEGB规则——Local（局部），Enclosed（嵌套函数的外层），Global（全局），Build-In（内置作用域），地位由高到低
5、闭包（closure）
def power(exp):
def exp_of(base):
return base **exp
return exp_of
square = power(3) //exp_of()的函数继承外层的，exp = 2
cube = power(2) //exp = 3
print(square(3),cube(2))
//9 8
6、装饰器
https://blog.csdn.net/m0_51971452/article/details/111757163?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522165709407416781818779496%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=165709407416781818779496&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-3-111757163-null-null.142%5Ev31%5Epc_search_result_control_group,185%5Ev2%5Econtrol&utm_term=python%E8%A3%85%E9%A5%B0%E5%99%A8&spm=1018.2226.3001.4187#运行日志
import time
from tracemalloc import stop
def time_master(func):
def call_func():
print("Starting")
start = time.time()
func()
stop = time.time()
print("Ending")
print(f"spend {(stop-start):.3f}s")
return call_func
@time_master #不使用语法糖（注意位置）myfunc = time_master(myfunc) myfunc被赋值为call_func
def myfunc():
time.sleep(1)
print("Just be happy")
myfunc()
-
带参数的语法糖
@最外层函数名（对最外层变量赋值） == 调用的函数 = 最外层函数（对最外层变量赋值）（调用的函数名） 先调用扔参数，再调用扔函数
#运行日志
import time
def time_master(func):
def call_func():
print("Starting")
start = time.time()
func()
stop = time.time()
print("Ending")
print(f"spend {(stop-start):.3f}s")
return call_func
@time_master #不使用语法糖（注意位置）myfunc = time_master(myfunc) myfunc被赋值为call_func
def funA():
time.sleep(1)
print("Just be happy")
funA()
def funB():
time.sleep(2)
print("Relax")
funB()
7、匿名表达式（lambda)
一个表达式而非语句，支持单个函数表达式、列表、闭包
- lambda arg1,arg2,arg3,…argn : expression //lambda 参数 : 返回值
y = [lambda x : x*x,1,2,3]
for i in range(1,len(y)):
print(y[0](y[i])) //切片y[0]()引用一个函数，参数用切片的下标赋值
//
1
4
9
- 与map()
M = map(lambda x: ord(x),"Hert")
print(list(M))
#def M(x):
# return ord(x)
#print(list(map(M,"Hert")))
//[72, 101, 114, 116]
8、生成器（将函数的return 换为yield）
每次调用提供一个数据，并记住当前状态；不走回头路，每次调用都加1，不能使用下标索引
- 生成器表达式，一次只产生一个推导 （列表推导式一次产生所有结果）
9、递归
结束条件、向结束条件靠近的变量表达式
def result(n):
if n==1:
return n
else:
return n*result(n-1)
print(result(4))
//24
#迭代
def result(n):
r = n
for i in range(1,n):
r *=i
return r
print(result(4))
- 汉诺塔
#汉诺塔步骤
def Hano(n,x,y,z):
if n==1:
print(x,'-->',z)
else:
Hano(n-1,x,z,y) #将x上的n-1移动到y
print(x,'-->',z) #将最下面从x到z
Hano(n-1,y,x,z) #将y上的n-1移动到z
n = int(input("请输入层数： "))
Hano(n,'A','B','C')
-
高阶函数
- map(); filter(); min(); max(); salty()
-
functools模块
- .reduce()，连续执行可迭代对象的元素
import functools def add(x,y): return x+y print(functools.reduce(add,[1,2,3])) //6- .partial()偏函数（对函数2次包装，即将函数的参数多次拆分进行传递）
- @functools.wraps(外函数函数名)装饰器（用于装饰装饰器，保持被装饰函数的函数名不变）
七、永久存储
文件:.exe可执行文件 .txt文本文件
1、文件的打开
- .open(name,mode) //与.close()对应
mode: 读（r)、写(w)、追加(a)等
2、文件对象的方法
| 方法 | 含义 |
|---|---|
| file.close() | 关闭文件 |
| file.flush() | 将缓存区数据写入文件（不一定有效） |
| file.read(size=-1) | 从文件读取 size 个字，当未指定size或值为负数，读取剩余所有并以字符串返回 |
| file.readline(size=-1) | 从文件中读取并返回一行(包括行结束符), 或返回最大 size |
| file.readlines(sizhint=0) | 读取文件的所有行并作为一个列表返回(包含所有的行结束符) |
| file.tell() | 返回当前文件指针所在位置 |
| file.seek(off, whence=0) | 在文件中移动文件指针, 从 whence ( 0 代表文件其始, 1代表当前位置, 2 代表文件末尾)偏移 off 字节；以字节为单位，返回最新的索引位置 |
| file.truncat() | 截断数据，清除文件指针之后的数据（单独以w打开也会截断） |
3、pathlib——面向对象文件系统路径 from pathlib import Path
| 方法 | 含义 |
|---|---|
| Path.cwd() | 获取文件当前路径 |
| .is_dir() | 判断路径对象是否为文件夹 |
| 文件.parent | 获取文件上一级路径 |
| name | 目录的最后一个部分 |
| stem | 目录的最后一个部分，无后缀 |
| suffixes | 返回多个扩展名列表 |
| .resolve() | 将相对路径转化为绝对路径 |
| .iterdir() | 获取当前路径子文件 |
- with上下文管理器 //不用再关闭文件
- pickle() //将Python转化为二进制字节流
八、类和对象
类（class）：模具 对象：属性＋方法
class Dog: #类首字母大写
foot = 4 #属性
def run(self): #方法，设置默认参数
print("Fast")
#调用
pup = Dog()
a = pup.name = "Joe" #添加属性
print(a)
print(pup.foot)
pup.run()
//Joe
4
Fast
1、封装
在创建对象之前将相关属性和方法打包
2、继承
子类与父类、基类、超类 子类与父类属性和方法名，子类覆盖父类
class P:
x = 305
def what(self):
print("305 is a birthday")
class C(P):
x = 22
y = 520
c = C()
print(c.x)
print(c.y)
c.what()
//22
520
305 is a birthday
- isinstance() #判断是否为继承关系
- issubclass() #检查是否为子类
- 多重继承 #一个子类可继承多个父类，多代父类
- 组合
class Cat():
def say(self):
print("喵喵~")
class Dog():
def say(self):
print("汪汪~")
class Bird():
def say(self):
print("啾咪~")
class Pats:
c = Cat()
d = Dog()
b = Bird()
def say(self):
print("The pats start to sing")
self.c.say() #self将实例对象与类的方法绑定，防止方法共享
self.d.say()
self.b.say()
h = Pats()
h.say()
//The pats start to sing
喵喵~
汪汪~
啾咪~
- .dict #查看一个类的属性
- 构造函数 *init*() #双下划线
class C:
def __init__(self,x,y):
self.x = x
self.y = y
def sum(self):
print(self.x + self.y)
def mul(self):
print(self.x * self.y)
c =C(2, 3)
c.sum()
C(2,3).mul()
print(c.__dict__)
//5
6
{'x': 2, 'y': 3}
- 重写 //调用未绑定的父类方法
class C:
def __init__(self,x,y):
self.x = x
self.y = y
def add(self):
return self.x + self.y
def mul(self):
return self.x * self.y
class D(C):
def __init__(self, x, y,z): #等价于self.x =x self.y = y
C.__init__(self,x, y) #换为super().__ini__()可以避免重复调用
self.z = z
def add(self):
print(C.add(self) + self.z)
D(2,3,4).add()
//9
- .mro() .mro // 查看MRO顺序（方法解析顺序（Method Resolu orde））
- Mixin 混入 。可复用性；方法和参数在各组件中不共；值为对象的选项，选项会被合并，键冲突的组件会覆盖混入对象的；值为函数的选项，就会被合并调用，混合对象里的钩子函数在组件里的钩子函数之前调用
3、多态
一类事物有多种形态。同一运算符、函数、对象在不同场景的不同作用
- 一类方法被多种实例使用
import math
class Shape:
def __init__(self,name):
self.name = name
def area(self):
pass
class Square(Shape):
def __init__(self, length):
super().__init__("正方形")
self.length = length
def area(self):
print( self.length*self.length)
def Girth(self): #正方形自己的方法求周长
print(4*self.length)
class Circle(Shape):
def __init__(self, radius):
super().__init__("圆形")
self.radius = radius
def area(self):
print(self.radius*self.radius*math.pi)
s = Square(3)
c = Circle(5)
print(s.name)
s.Girth()
c.area()
//正方形
12
78.53981633974483
- 多态性：指具有不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同内容的函数。增加了程序的灵活性和可拓展性
#抽象
import abc
class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
@abc.abstractmethod
def talk(self):
pass
class Cat(Animal): #动物的形态之一:猫
def talk(self):
print('say miaomiao')
class Dog(Animal): #动物的形态之二:狗
def talk(self):
print('say wangwang')
class Pig(Animal): #动物的形态之三:猪
def talk(self):
print('say aoao')
c = Cat()
d = Dog()
p = Pig()
def func(obj):
obj.talk()
func(c)
func(d)
func(p)
- __x两个下横线开头的变量/函数——“私有变量”
- 单个下横线开头 或 单个下横线结尾 // 仅供内部使用
- slots 固定字典空间。防止动态添加；继承自父类的__slots__属性不被子类使用
九、魔法方法
被双下划线前后包围的方法。在类或对象进行特定的操作时会自动被调用，我们可以使用或重写这些魔法方法，给自定义的类添加各种特殊的功能来满足自己的需求。
1、构造与解析
- init(self[,…]) 初始化
- new(cls[,…]) 创建实例和对象，比__init__先执行 //可更改不可变对象
class S(str):
def __new__(cls,string):
string = string.upper()
return super().__new__(cls,string)
c = S("Evian")
print(c)
print(c.lower())
//EVIAN
evian
- del(self) 当对象被销毁时触发的魔法方法
扫一扫
1095
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
