查看帮助
help(dir) #查看手册
dir(__builtins__) #查看内置函数
str = r'C:\Program Files\FishC\Good''\\' #R或r原始数据，末尾不能加\，如非要加，则使用转义\\
file1 = open(r'C:\windows\temp\readme.txt', 'r')
random
Random.randint(1,10) #产生1-10直接的随机数
int(10.1+0.5) #默认int是向下取整，如果采用四舍五入+0.5即可
优先级
幂运算特殊 幂运算(* )>正负号(-x +x)>算术操作符( / // + -)>比较操作符（< <= > >= != ==）>逻辑运算符（not and or）
-3**2=-9
3**-2=0.1111
Not > and > or
Num=x if x>y else y #三元操作符
Assert
Assert 3>4 #条件为假，程序奔溃，抛出AssertionError
列表
List[:] #拷贝列表，等同于list2 = list1.copy()
List.append(a) #只有一个
List.extend([a,b]) #可以一次添加多个
List.insert(1,”hello”) #第二个元素变成hello
list.reverse() #反转
list.remove(“hello”) #删除1元素
list.pop() #默认删除最后一个元素，并返回它
del list #删除整个元素
list.clear() #清空元素，但不删除list
list.reverse() #将列表倒置过来，注意不是倒叙
list.sort() #正序排列
list.sort(reverse=True) #倒叙排列
list.count(value) #value出现的次数
list.index(value) #第一次出现value的下标
列表推导式或列表解析
```[有关A的表达式 for A in B] [ i*i for i in range(10) ] list1 = [(x, y) for x in range(10) for y in range(10) if x%2==0 if y%2!=0]
# 元组
Tulp1=() #空元组 Tulp1=(1,) #只有一个元素的时候，要加逗号
# 字符
Startswith() #以什么开始
Endswith()
‘.’.join([‘ab’, ‘pq’, ‘rs’]) -> ‘ab.pq.rs’
Str.lstrip() #去除左空格rstrip(),strip()
Str.partition(sub) #把子字符串用sub分成3个元组，
‘hello’.partition(‘e’) #返回(‘h’, ‘e’, ‘llo’)
Str.replace(old, new, count=-1, /) #替换
“www.benderfly.con”.split(‘.’) #返回[‘www’, ‘benderfly’, ‘cn’]
str.zfill(width) #前面填充0
(field1,field2)=str.split(‘:’,1) #按照：分割
# 字符串
s.isalnum() 所有字符都是数字或者字母，为真返回 Ture，否则返回 False。 s.isalpha() 所有字符都是字母，为真返回 Ture，否则返回 False。 s.isdigit() 所有字符都是数字，为真返回 Ture，否则返回 False。 s.islower() 所有字符都是小写，为真返回 Ture，否则返回 False。 s.isupper() 所有字符都是大写，为真返回 Ture，否则返回 False。 s.istitle() 所有单词都是首字母大写，为真返回 Ture，否则返回 False。 s.isspace() 所有字符都是空白字符，为真返回 Ture，否则返回 False。
# 格式化
“{0}.{1}.{2}”.format(‘www’,’benderfly’,’com’) #返回www.benderfly “{a}.{b}.{c}”.format(a=’www’,b=’benderfly’,c=’com’) “{a}.{b}.{c}.{0}”.format(‘http://’,a=’www’,b=’benderfly’,c=’com’) #位置和关键词混合，位置必须放前面 “0”.format(‘hello’) #返回’{0}’ “{0:10.1f}”.format(-23.1324) #定点数，四舍五入保留1位小数
%格式化
“%c %c %c”%(97,98,99) #返回’a b c’ %s #字符串 %d #整数 %0.1f #定点数”%0.1f”%(9.6745) 返回’9.7’ %-10.1f #减号左对齐 %010.1f #0用0取代空格填充
# 内置函数
Max() #返回最大值 Min() Len() Sum() Sorted() Reversed() #返回迭代器对象 Enumerate() #返回迭代器，用list转化list(enumerate([‘a’,’b’])) 返回 [(0, ‘a’), (1, ‘b’)] Zip a=[1,2,3,4,5,6] b=[‘a’,’b’] list(zip(a,b)) 返回[(1, ‘a’), (2, ‘b’)]
# 函数
### 函数默认返回None
def multi(): return [1,’hello’,[‘a’,’b’,123]] #返回一个列表 def’ tulp() return 1,’hello’,3 #返回（1，‘hello’，3）元组 Def func1(name,age=1) #默认参数必须放在后面 Print(name,age)
### 收集参数
Def func2(*params，[sep=’’..]): #sep设置成默认参数 Print(len(params)) Print(params[N]) #打印第N个参数
### 局部变量
Price=100 def local(): #print(price) #如果不注释会报错，因为下面定义了price与全局变量同名，函数内的price就变成局部变量了，修改其不影响全局变量 price=20 print(price)
price=100 def local(): global price #global定义全局变量，这样price就变成全局变量 print(price) price=20 print(price)
### 函数嵌套
def func1(): print(“func1”) def func2(): print(“func2”) func2() #func2的作用域仅限在func1函数内部
### 函数闭包
def funX(x): def funY(y): #内部函数对外部函数的的全局变量进行调用，即构成闭包 return x * y return funY
def a(): x=3 def b(): nonlocal x x=x+1 #如果不定义nonloal x会报错提示位定义x，因为此时x已经是局部变量 print(x) return b()
# lambda
def func(x, y): return x + y 等价于： func=lambda x, y : x + y func(2,3) #返回5
## filter
list(filter(lambda x : x % 2,range(10))) #返回基数
## map
list(map(lambda x:x**2,range(10))) #求幂
# 字典
Web={‘百度’: ‘www.baidu.com’, ‘google’: ‘www.google.com’}
### 遍历字典
for eachkeys in web.keys(): #输出keys for eachvalues in web.values(): #输出值 for eachkvs in web.items() #已元组形式输出（key,value） for k,v in web.items(): #分别输出key和value for each in dic: print(each,”->”,dic[each])
### 获取
web.get(“百度”,”不存在”) #如果简直不存在，则返回“不存在” key in web #判断key是否存在
### 清空字典
Web.clear() Web.copy() #浅拷贝 Web.pop(key) #删除key对应的item Web.popitem() #随机删除item web.setdefault(key,default) #如果key不存在则创建key:default,存在则返回对应值 web.update(dic) #根据dic更新web，如果不存在则添加到web
# set集合
set={1,2,3} #集合里面的元素是唯一的 s1.remove(3) #删除元素3 s1.add(‘hello’) #添加元素hello frozenset([1,2,3,3,32,2]) #设置只读集合
# 文件
f=open(r’C:\Users\only\Desktop\pythons\file.txt’,’r’) #只读方式打开 r #只读 w #写，（此模式一旦打开文件，即清空文件） x #文件不存在则写的方式打开，如果文件已存在，则引发异常 a #追加模式 b #二进制模式
- #可读写模式 f.close() #关闭 f.read(size=-1) #读取size个字符，默认读取所有字符，指针指向末尾 f.readline() #读取一行，指针指向下一行 for eachline in f: #读取所有行 print(eachline) f.write(str) #写，返回字符数 f.writelines(seq) #seq 是一个返回字符串的可迭代对象 f.seek(offset,from) #从from（0起始位置，1当前位置，2文件末尾）偏移offset个字节 f.tell() #返回当前位置
with open(file_name) as f #会自动调用f.close() with open(‘boy_1.txt’) as a,open(‘boy_2.txt’) as b: #多个可以写到一起
# 模块os模块
getcwd() #返回当前工作目录 chdir(path) #改变工作目录 listdir(path=’.’) #列举指定目录中的文件名（’.’表示当前目录，’..’表示上一级目录） mkdir(path) #创建单层目录，如该目录已存在抛出异常 makedirs(path) #递归创建多层目录，如该目录已存在抛出异常，注意：’E:\a\b’和’E:\a\c’并不会冲突 remove(path) #删除文件 rmdir(path) #删除单层目录，如该目录非空则抛出异常 removedirs(path) #递归删除目录，从子目录到父目录逐层尝试删除，遇到目录非空则抛出异常 rename(old, new) #将文件old重命名为new system(command) #运行系统的shell命令 walk(top) #遍历top路径以下所有的子目录，返回一个三元组：(路径, [包含目录], [包含文件])
以下是支持路径操作中常用到的一些定义，支持所有平台 os.curdir #指代当前目录（’.’） os.pardir #指代上一级 目录（’..’） os.sep #输出操作系统特定的路径分隔符（Win下为’\‘，Linux下为’/’） os.linesep #当前平台使用的行终止符（Win下为’\r\n’，Linux下为’\n’） os.name #指代当前使用的操作系统（包括：’posix’, ‘nt’, ‘mac’, ‘os2’, ‘ce’, ‘java’）
os.path模块中关于路径常用的函数使用方法 basename(path) #去掉目录路径，单独返回文件名 dirname(path) #去掉文件名，单独返回目录路径 join(path1[, path2[, …]]) #将path1, path2各部分组合成一个路径名 split(path) #分割文件名与路径，返回(f_path, f_name)元组。如果完全使用目录，它也会将最后一个目录作为文件名分离，且不会判断文件或者目录是否存在 splitext(path) #分离文件名与扩展名，返回(f_name, f_extension)元组 getsize(file) #返回指定文件的尺寸，单位是字节 getatime(file) #返回指定文件最近的访问时间（浮点型秒数，可用time模块的gmtime()或localtime()函数换算） getctime(file) #返回指定文件的创建时间（浮点型秒数，可用time模块的gmtime()或localtime()函数换算） getmtime(file) #返回指定文件最新的修改时间（浮点型秒数，可用time模块的gmtime()或localtime()函数换算）
以下为函数返回 True 或 False exists(path) #判断指定路径（目录或文件）是否存在 isabs(path) #判断指定路径是否为绝对路径 isdir(path) #判断指定路径是否存在且是一个目录 isfile(path) #判断指定路径是否存在且是一个文件 islink(path) #判断指定路径是否存在且是一个符号链接 ismount(path) #判断指定路径是否存在且是一个挂载点 samefile(path1, paht2) #判断path1和path2两个路径是否指向同一个文件
# pickle模块
my_list = [1,2,[‘hello’,’me’],’a’,(1,2)] #字典，列表等都可以
my_list [1, 2, [‘hello’, ‘me’], ‘a’, (1, 2)]
pickle_file = open(r”C:\Users\only\Desktop\pythons\my_list.pkl”,’wb’) #二进制打开,后缀名无所谓 pickle.dump(my_list,pickle_file) #导入 pickle_file.close()
pickle_file = open(r”C:\Users\only\Desktop\pythons\my_list.pkl”,’rb’) #二进制打开 ml = pickle.load(pickle_file) #导出 ml [1, 2, [‘hello’, ‘me’], ‘a’, (1, 2)] ```
异常处理
try:
sum = 1 + '1' #检测到异常，后边的程序将不再运行
int("abc")
a = 1
f = open('record.txt')
except FileNotFoundError as reson: #可以使用多个except
print('文件名不存在！T_T')
except (TypeError,KeyError) as reson: #可以对多个异常（元组的形式）进行统一捕获
print('类型错误T_T')
except: #不推荐使用，如ctrl+c 也会捕获，不会终止程序
print("捕获所有异常")
else: #没有异常则执行
print('文件成功打开')
finally: #不管有没有异常都执行
print("hello me")
可以手动raise异常
raise TypeError() #会引出异常
raise TypeError(“类型错误”)
While/for 中使用else #如果中途没有break,则循环结束之后会执行
count = 10
while count:
print(count)
count -=1
if count == 3:
break #beak终止循环,else不执行
else:
print("以下数字大于三:")
else:
print("else content")
for i in "hello python me and you ":
print(i)
if i == "p":
print('p')
break
else:
print("aa")
else:
print("最后内容")
input() 函数有可能产生两类异常EOFError（按下ctrl+d）和KeyboardInterrupt(ctrl+c)
面向对象
私有变量和私有函数（前面加_ _）
class Person():
name="han"
age=3.14195324
__secret = "井田" #定义私有变量
def sayHello(self,score):
self.score = score
print("Say hello to every body!%d"% self.score)
def getName(self):
return self.__secret #p1._Person__secret 私有变量依旧在外部访问
属性和函数同名时
class A():
y=0 #会被函数替换
def __init__(self):
self.x = 0
def x(self): #会被属性x替换，而无法调用
print("mathed x called")
def y(self):
print('method Y is called')
继承super
class A():
def __init__(self):
self.x = 1
self.y = 2
def hello(self):
print(self.x)
class B(A):
pass
class C(A):
def __init__(self):
#A.__init__(self) #基础父类方法1 父类.__init__(self)
super().__init__() #方法二，推荐
self.z = 3
组合
class Fish:
def __init__(self,x):
self.num = x
class Turtle:
def __init__(self,y):
self.num = y
class Pool:
def __init__(self,x,y):
self.fish = Fish(x)
self.turtle = Turtle(y)
def getNum(self):
print("水池里面共有{0}只鱼和{1}只乌龟O_O".format(self.fish.num,self.turtle.num))
有关类的内置函数
isinstance(object,classinfo)
### 参数：
object : 实例对象。
classinfo : 可以是直接或者间接类名、基本类型或者由它们组成的元组。
返回值：如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。
实例
以下是使用isinstance()函数的实例：
a = 2
isinstance(a,int) # 结果返回 True
isinstance(a,str) # 结果返回 False
isinstance(a,(str,int,list)) # 是元组中的一个，结果返回 True
isinstance()与type()的区别
例如在继承上的区别：
*
isinstance() 会认为子类是一种父类类型，考虑继承关系。
*
type() 不会认为子类是一种父类类型，不考虑继承关系。
class A:
pass
class B(A):
pass
isinstance(A(), A) # returns True
type(A()) == A # returns True
isinstance(B(), A) # returns True
type(B()) == A # returns False
issubclass(B,A) #returns True
issubclass(B,B) #True 类自身是自身的子类
issubclass(B,（A，C，D）) #只要B属于元组中的一个就返回True
hasattr(object,name)/getattr(object,name,[default])/setattr(object,name,value)/delattr(objece,name)
class C:
x=1
def __init__(self,y=2):
self.z = y
c=C()
print(hasattr(c,'x')) # True
print(hasattr(c,'y')) # False
print(hasattr(c,'z')) # True
print(getattr(c,'y',"没有y")) #没有y
print(getattr(c,'z',"有z")) #2
print(getattr(c,'w',"没有w")) #没有w
setattr(c,'w',"新建w属性") #不存在则新建，否则更新
print(getattr(c,'w',"没有w")) #新建w属性
delattr(c,'x') #删除成功
delattr(c,'x') #AttributeError
property
class Prop:
def __init__(self,size=0):
self.size = size
def getSize(self):
return self.size
def setSize(self,value):
self.size = value
def delSize(self):
del self.size
#x = property(fget=getSize,fset=setSize,fdel=delSize)
x = property(getSize,setSize,delSize)
p = Prop()
print(p.x) #0
p.x=10
print(p.x) #10
del p.x
print(p.x) #AttributeError
魔法方法
new
class CaptStr(str):
def __new__(cls,string):
string = string.upper()
return str.__new__(cls,string)
__init__/__del__/__str__/__repr__
class A():
def __init__(self):
print("调用__init__")
def __del__(self):
print("调用__del__")
def __str__(self): #print(a) 时被调用
return "重新定义__str__"
def __repr__(self):
return "重新定义__repr__" #执行a时被调用
#也可以直接赋值__repr__ = __str__
>>> a=A()
调用__init__
>>> a1=a
>>> a2=a
>>> del a1
>>> del a
>>> del a2
调用__del__ #只有在所有的引用都删除的情况下才会调用__del__
add/sub/rsub/radd
class Nint(int):
def __add__(self,other):
return int.__sub__(self,other)
def __sub__(self,other):
return int.__add__(self,other)
def __radd__(self,other):
return int.__sub__(self,other)
def __rsub__(self,other):
return int.__add__(self,other)
a=Nint('5')
b=Nint('3')
print(a+b) #2
print(1+a) #4
print(2-b) #5
print(1+b) #2
- getattr(self,name) 定义当用户试图获取一个不存在的属性时的行为
- getattribute(self,name) 定义当该类的属性被访问时的行为
- setattr(self,name,value) 定义当一个属性被设置时的行为
- delattr(self,name) 定义当一个属性被删除时的行为 ``` class A: def getattribute(self,name): #比getattr先调用 print(“getattribute”) return super().getattribute(name) def getattr(self,name): print(“getattr”) def setattr(self,name,value): print(“setattr”) super().setattr(name,value) def delattr(self,name): print(“delattr”) super().delattr(name)
class A: def init(self): self.width=0 self.height=0 def setattr(self,name,value): if name == ‘x’: self.width=value self.height=value else: super().setattr(name,value)
# 迭代器iter()/next()
s=”hello”
it=iter(s) »> next(it) ‘h’ next(it) ‘e’ next(it) #如果没有值了，就抛出StopIteration的异常 L
# wrapsfrom functools import wraps def wrapper(func): #@wraps(func) def inner(*args, **kwargs): print(“在前面执行的函数名：%s” % func.name) #始终是f.name func() print(“在后面执行的函数注释：%s” % func.doc) #始终是f.doc return inner
@wrapper def f(): “”” 这是一个用来测试装饰器修复技术的函数 “”” print(“f函数被调用”)
if name == ‘main’: print(“执行的函数名:”, f.name) #有wraps修饰，则显示f.name__否则inner.__name print(“函数的注释:”, f.doc) #有wraps修饰，则显示f.doc__否则inner.__doc
f()
# 带参数装饰器
#在调用sayHi之前，写入日志 from functools import wraps def loging(logFile=”hi.log”): def action(func): @wraps(func) def wrapper(*args,kwargs): #打印函数名 string= “调用了{}函数”.format(func.__doc__) with open(logFile,’w’) as f: f.write(string) return func(*args,kwargs) return wrapper return action
@loging(“sayHi.log”) def sayHi(): “"”sayhi文档””” print(“hi”)
# 类装饰器
class Dec: def init(self,log): self.log = log
def __call__(self,func):
def _call(*args,**kwargs):
print("调用装饰器")
with open(self.log,'a') as logFile:
logFile.write("调用了：%s"% func.__name__)
return func(*args,**kwargs)
return _call
#调用sayHi之前写入日志
class Test: @Dec(“call_log.txt”) def sayHi(self,name): print(“Hi”)
Test().sayHi(“周杰伦”) ```
