发布于2019-08-05 18:28 阅读(808) 评论(0) 点赞(1) 收藏(1)
基本数据类型:
整型(int
),浮点型(float
),字符串(str
),列表(list
),元组(tuple
),字典(dict
),集合(set
),布尔(bool
)
数值类型(整数,浮点,布尔)
序列类型(字符串,列表,元组)
散列类型(字典,集合)
字节类型 a=bytes(‘123’)/a=b’123’
字节数组bytearrary(‘123’)
可变序列:列表,集合,字典
不可变序列:字符串,元组
增:
字符串拼接
1.str1+str2+str3
2.””.join([str1,str2,str3])
3."%s %s %s"%(str1,str2,str3)
4."{} {} {}".format(str1,str2,str3)
删:
x.replace(m,n,x)
m:准备替换的内容 n:替换的内容 x:替换的个数
查:
x.index(m)
m:索引的内容
x.find(m)
m:索引的内容
x.count(m)
m:计数的内容
x.isdigit()
x是否是数字
x.isalpha()
x是否是字母
x.isupper()
x是否是大写
x.islower()
x是否是小写
x.startswith(m)
x是否以m开头
x.endswith(m)
x是否以m结尾
改:
x.upper()
x转化为大写
x.lower()
x转化为小写
x.strip()
去x左右空白/lstrip去左空白/rstrip去右空白
x.title()
x标题化
x.capitalize()
x第一个字母大写
x.split(m,x)
以m为界分割 分割x次
增:
li.append(m)
m:添加的内容
li.insert(x,m)
x:元素下标位置 m:插入的内容
li.extend(list)
list:为另一个列表
删:
li.pop(x)
x:删除一个元素并返回该元素的值 若无参数x则从最后开始删除
li.remove(m)
m:需要删除的内容
li.clear()
清空列表li
查:
li.index(m)
m:索引的内容
li.count(m)
m:计数的内容
改:
list[n]=x
其他:
copy() 浅复制
import copy 深复制 适用于两层列表
list1=copy.deepcopy(list2)
永久排序
li.sort(reverse=True/False)
m:列表 True倒排序 False正排序
m.reverse()
永久倒排序
临时排序
sorted(li,reverse=True/False)
m:列表 True倒排序 False正排序
reversed(m)
临时倒排序
查:
t.index(m)
m:索引的内容
t.count(m)
m:计数的内容
交集& 并集| 差集-
增:
a.add(m)
m:向集合里面添加的内容
删:
a.pop()
随机删除集合内容
a.remove()
指定删除集合内容
查:
a.isdisjoint(b)
a与b是否存在交集
a.issubset(b)
a是b的子集吗
a.issuperset(b)
a是b的父集吗
改:
a.update(m)
向集合里面添加元素m可以为字符串 列表 元组 集合 字典
增:
d=dict.fromkeys(m,n)
m:键的来源可迭代对象 n:设置值的默认值
d.setdefault(m,n)
查询有则返回无则添加m:键 n:值
删:
d.clear()
清空字典
d.pop(m)
m:键 删除以m为键的字典
d.popitem()
删除最后一个字典
改:
d.update(m)
m:添加的字典
dic[m]=n
m:键 n:值
查:
d.get(m)
m:键 返回m键对应的值
d.keys()
获得键的列表
d.values()
获得值的列表
d.items()
同时获得键与值的元组 再通过遍历获得键与值
判断类型:type()
isinstance(变量,类型)
运算符 | 说明 |
---|---|
** ^ ! | 指数 按位翻转 非 |
* / % // | 乘 除 取模 整除 |
+ - | 加 减 |
>> << | 右移 左移 |
== >= <= > < != | 是否 /等于 大于等于 小于等于 大于 小于 不等于 |
= += -= *= /= %= **= //= | 赋值 |
is is not |
判断内存地址是否相同 |
in not in |
判断成员是否存在 |
and or not |
与 或 非 |
if-else
语法:
if 条件:
语句
else:
语句
例子:
a=1
#使用方式一
if a>1:
print('大于1')
else:
print('小于等于1')
#使用方式二
print('大于1') if a>1 else print('小于等于1')
输出:
>>小于等于1
>>小于等于1
if-elif-else
语法:
if 条件:
语句
elif 条件:
语句
else:
语句
例子:
a=1
if a>1:
print('大于1')
elif a<1:
print('小于1')
else:
print('等于1')
输出:
>>等于1
while
语法:
while 条件:
语句
例子:
a=5
while a>0:
print(a)
a-=1
输出:
>>5
>>4
>>3
>>2
>>1
while-else
语法:
while 条件:
语句
else:
循环结束后执行的语句
例子:
a=5
while a>0:
print(a)
a-=1
#循环中若出现break则跳出循环,且不再执行else中的语句
else:
print('ok')
输出:
>>5
>>4
>>3
>>2
>>1
>>ok
for循环
for i in 可迭代对象:
语句
例子:实现九九乘法表
for i in range(1,10):
for j in range(1,i+1):
print(str(i)+'x'+str(j)+'='+str(i*j),end=' ')
print('\n',end='')
输出:
>>1x1=1
>>2x1=2 2x2=4
>>3x1=3 3x2=6 3x3=9
>>4x1=4 4x2=8 4x3=12 4x4=16
>>5x1=5 5x2=10 5x3=15 5x4=20 5x5=25
>>6x1=6 6x2=12 6x3=18 6x4=24 6x5=30 6x6=36
>>7x1=7 7x2=14 7x3=21 7x4=28 7x5=35 7x6=42 7x7=49
>>8x1=8 8x2=16 8x3=24 8x4=32 8x5=40 8x6=48 8x7=56 8x8=64
>>9x1=9 9x2=18 9x3=27 9x4=36 9x5=45 9x6=54 9x7=63 9x8=72 9x9=81
定义函数
def myfunc(x):
if x >= 0:
return x
else:
return -x
空函数
def emptyfunc():
pass
参数检查
def checkfunc(x):
if not isinstance(x,(int,float)):
raise TypeError("must be int or float type!")
if x >= 0:
return x
else:
return -x
返回多个值
def price(x):
apple=x*2
banana=x*2.5
return apple,banana
a,b=price(1)
必选参数parameter
def printdetail1(name,age,telephone):
print("姓名:",name)
print("年龄:",age)
print("电话:",telephone)
printdetail1("Jack",12,12356435678)
默认参数parameter=value
def printdetail2(name,age,telephone,gender='fale'):
print("姓名:",name)
print("性别:",gender)
print("年龄:",age)
print("电话:",telephone)
printdetail2("Jack",12,12356435678,gender='female')
可变参数*
1.不定长传参
def fun1(*number):
for i in number:
print(i)
fun1(1,2,3,4,5,6,7,8)
2.元组和列表的压包
def fun2(*number):
s=0
for i in number:
s+=i
print(s)
fun2(*[1,2,3,4,5])
fun2(*(1,2,3,4,5))
关键参数**
使用方法一
def fun(id,name,**kargs):
print("id:",id)
print("name:",name)
print("others:",kargs)
fun(2,"xiaohua",sex="man",age='12')
使用方法二
extra={'sex': 'man', 'age': 12}
def fun(id,name,**kargs):
print("id:",id)
print("name:",name)
print("others:",kargs)
fun(2,"xiaohua",sex=extra['sex'],age=extra['age'])
使用方法三
extra={'sex': 'man', 'age': 12}
def fun(id,name,**kargs):
print("id:",id)
print("name:",name)
print("others:",kargs)
fun(2,"xiaohua",**extra)
关键字参数*
def fun(name,age,*,city,job,completion):
print("name:",name)
print("age:",age)
print("city:",city)
print("job:",job)
print("completion:",completion)
fun('Jack',12,city='shanghai',job='teacher',completion=True)
*
,后面的参数被视为命名关键字参数*
了参数组合
def fun(parameter,*args,keyparameter,**kargs):
print(parameter)
print(args)
print(keyparameter)
print(kargs)
fun(1,*(1,2,3,4),keyparameter=True,**{'id':2})
#阶乘计算
def fact(n):
if n == 1:
return 1
return n * fact(n-1)
def add(x,y):
return x+y
def multiply(x,y):
return x*y
def use(func,x,y):
return func(x,y)
print(use(add,1,2))
print(use(multiply,1,2))
输出:
>>3
>>2
函数作用域
global
:在函数内部修改函数外部的值,需要在函数内用global声明需要修改的变量
nonlocal
:在多层函数嵌套的情况下,在里层函数里修改外层函数里面的变量值
1.外部不能访问函数内部变量
2.函数内部能够访问函数外部变量
3.函数里面不能修改函数外部变量(若要修改需声明global x x=n)
4.函数里面和函数外部变量名相同
map()
map(函数名,列表/元组/集合/字符串)
a='12345'
def square(x):
return int(x)*int(x)
b=list(map(square,a))
print(b)
输出:
>>[1, 4, 9, 16, 25]
filter()
filter(函数名,列表/元组/集合/字符串)
a=[1,2,3,4,5,6,7,8,9,10]
def even_number(x):#筛选偶数
return x%2==0
b=list(filter(even_number,a))
print(b)
输出:
>>[2, 4, 6, 8, 10]
a=['A', '', 'B', None, 'C', ' ']
def remove_blank(x):#去除空元素
return x and x.strip()
b=list(filter(remove_blank,a))
print(b)
输出:
>>['A', 'B', 'C']
def delay_sum(*args):
def sumfunc():
s=0
for i in args:
s+=i
return s
return sumfunc
f=delay_sum(1,2,3,4)
print(f())
输出:
>>10
闭包:动态的生成函数
def f_out(times):
print('in f_out')
#times在f_out函数中相对于f_in函数的外部变量
def f_in(num):
return times*num # f_in可以调用外部变量times
return f_in #函数f_in()的地址f_in返回给f_out()
f_10_times=f_out(10)
f_20_time=f_out(20)
print(f_10_times(5))
print(f_20_time(5))
输出:
>>in f_out #给外部函数f_out传参后会先执行该函数内的所有语句
>>in f_out
>>50
>>100
def count():
fs = []
for i in range(1, 4):
def f():
return i*i
fs.append(f)
return fs
f1, f2, f3 = count()
print(f1())
print(f2())
print(f3())
输出:
>>9
>>9
>>9
def count():
def f(j):
def g():
return j*j
return g
fs = []
for i in range(1, 4):
fs.append(f(i)) # f(i)立刻被执行,因此i的当前值被传入f()
return fs
f1,f2,f3=count()
print(f1())
print(f2())
print(f3())
输出:
>>1
>>4
>>9
lambda 形参:含形参的表达式
f = lambda x:x+1
print(list(map(f,[1,2,3,4,5])))
输出:
>>[2, 3, 4, 5, 6]
map
和filter
函数联用装饰器:我们要增强函数的功能,比如,在函数调用前后自动打印日志,但又不希望修改函数的定义,这种在代码运行期间动态增加功能的方式,称之为“装饰器”(Decorator)
定义装饰器
import time
#计算函数运行时间
def run_time(func):
def wrapper():
start_time=time.time()
func()
spend_time=time.time()-start_time
return spend_time
return wrapper
@run_time #等价于multiply=run_time(multiply)
def multiply():
sum=0
for i in range(100000):
sum+=i
print(sum)
print(multiply())
输出:
>>4999950000
>>0.004987001419067383
使用装饰器
#使用方法一
now=decorator(函数名)#装饰器不传入参数时
now=decorator(参数)(函数名)#装饰器传入参数时
now()#执行被装饰过的函数
#使用方法二
@decorator#已定义的装饰器
def f():#自定义函数
pass
f()#执行被装饰过的函数
自身不传入参数的装饰器
def login(func):
def wrapper(*args,**kargs):
print('函数名:%s'% func.__name__)
return func(*args,**kargs)
return wrapper
@login
def f():
print('inside decorator!')
f()
输出:
>>函数名:f
>>函数本身:inside decorator!
自身传入参数的装饰器
def login(text):
def decorator(func):
def wrapper(*args,**kargs):
print('%s----%s'%(text,func.__name__))
return func(*args,**kargs)
return wrapper
return decorator
@login('this is a parameter of decorator')
def f():
print('2019-06-13')
f()
输出:
>>this is a parameter of decorator----f
>>2019-06-13
内置装饰器
@property
:就像访问属性一样和普通访问少了一个(),将函数名作为一个返回值 被装饰的类方法不可回调
@staticmethod
: 可以直接通过类名.函数名直接调用被装饰的方法
@classmethod
: 可以直接通过类名.函数名直接调用被装饰的方法
class Myclass():
a=100#类属性
def __init__(self,height,width):
self.height=height#实例属性
self.width=width
@property #属性装饰器:将函数名作为一个返回值 被装饰的类方法不可回调
def get_area(self):
#因为外部可以直接通过实例对象.函数名调用来获得结果 所以必须得有返回值
#通过类名.函数名调用只能得到该方法的地址 等于下面的cls.get_area
return self.height*self.width
@classmethod #类方法装饰器:可以通过类名.函数名直接调用被装饰的方法
def info(cls):
print('you can use class attribution and class method!')
print(cls.a,cls.get_area)#可以通过cls调用类属性和类方法
@staticmethod#静态装饰器:可以直接通过类名.函数名直接调用被装饰的方法
def help():
print('there is no cls and self!')
a=Myclass(20,50)
print('-----------实例化对象.函数名调用----------------')
print(a.get_area)
print('---------实例化对象.函数调用----------')
a.info()
a.help()
print('---------类名.函数直接调用----------')
Myclass.info()
Myclass.help()
输出:
>>-----------实例化对象.函数名调用----------------
1000
>>---------实例化对象.函数调用----------
>>you can use class attribution and class method!
>>100 <property object at 0x0000025D9322D958>
>>there is no cls and self!
>>---------类名.函数直接调用----------
>>you can use class attribution and class method!
>>100 <property object at 0x0000025D9322D958>
>>there is no cls and self!
@staticmethod
和@classmethod
的区别:
类装饰器
常用函数
len()
求长度
min()
求最小值
max()
求最大值
sorted()
排序
sum()
求和
进制转换函数
bin()
转换为二进制
oct()
转换为八进制
hex()
转换为十六进制
ord()
字符转ASCII码
chr()
ASCII码转字符
内置对象查看:dir(_builtins_)
enumerate()
转化为元组标号
eval(str)
只能运行一行字符串代码
exec(str)
执行字符串编译过的字符串 可以运行多行字符串代码
filter(函数名,可迭代对象)
过滤器
map(函数名,可迭代对象)
对每个可迭代对象的每个元素处理
zip(可迭代对象,可迭代对象)
将对象逐一配对
字符串的切片
s='hello world!'
print(s[0])#取0对应的下标值
print(s[::])#取全部值
print(s[::2])#步长为2
print(s[1:5])#左开右闭区间
print(s[1:])#包含下标为1对应的值
print(s[:5])#不包含下标为5对应的值
输出:
>>h
>>hello world!
>>hlowrd
>>ello
>>ello world!
>>hello
可迭代对象:可以直接作用于for循环的对象统称为可迭代对象(Iterable
)
判断对象是否可迭代
from collections import Iterable
a=isinstanc(对象,Iterable)
print(a)
输出:
>>True为可迭代
>>False为不可迭代
可迭代对象的遍历
对字符串的遍历
s='hello world!'
for i in s:
print(i,end="")
输出:
>>hello world!
对字典的遍历
#遍历键
d={'name':'Jack','age':12}
for key in d.keys():
print(key)
#遍历值
d={'name':'Jack','age':12}
for value in d.values():
print(value)
列表生成式
语法:[返回的参数 for循环 条件判断]
使用方法一 单层循环
l=[i for i in range(11) if i%2==0]
print(l)
输出:
>>[0, 2, 4, 6, 8, 10]
使用方法二 多层循环
l=[m+n for m in 'ABC' for n in '123']
print(l)
输出:
>>['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']
例一 对列表中的数据批量操作
import os
l=[d.upper() for d in os.listdir('.')]
print(l)
输出:
>>['2345看图王.LNK','DESKTOP.INI', 'DEVC++.LNK', 'FIDDLER.LNK']
例二 取出字典中的键值保存到列表中
d={'a':1,'b':2,'c':3}
l=[k+'='+str(v) for k,v in d.items()]
print(l)
输出:
>>['a=1', 'b=2', 'c=3']
例三 判断列表中数据的类型
li=[1,1.5,7j+1,'a',True,False,None]
p=[type(x) for x in li]
print(p)
输出:
[<class 'int'>, <class 'float'>, <class 'complex'>, <class 'str'>, <class 'bool'>, <class 'bool'>, <class 'NoneType'>]
集合生成式
语法:{返回的参数 for循环 条件判断}
s = {i for i in range(1,10) if i%2==0}
print(s)
输出:
>>{8, 2, 4, 6}
字典生成式
语法:{key:value for循环 条件判断}
li=['a','b','c','d','e','f','g','h']
d={i:j for i,j in enumerate(li) if i%2==0}
print(d)
输出:
>>{0: 'a', 2: 'c', 4: 'e', 6: 'g'}
生成器:为了节省内存空间,提高程序速度,这种一边循环一边计算的机制,称为生成器。
next()取值
li=[1,2,3,4,5]
g=(x for x in li)
print(g)
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
输出:
>><generator object <genexpr> at 0x0000018F628397C8>
>>1
>>2
>>3
>>4
>>5
for循环遍历取值
li=[1,2,3,4,5]
g=(x for x in li)
print(g)
for i in g:
print(i)
输出:
>><generator object <genexpr> at 0x0000018F628397C8>
>>1
>>2
>>3
>>4
>>5
函数的yield返回
next()取值
def fun():
yield 1
yield 2
yield 3
a=fun()
print(next(a))
print(next(a))
print(next(a))
输出:
>>1
>>2
>>3
for循环遍历取值
def fun():
yield 1
yield 2
yield 3
a=fun()
print(a)
for i in a:
print(i)
输出:
<generator object fun at 0x00000233B8C697C8>
1
2
3
例一 斐波拉契数列的推算值生成
def fib(max):
n, a, b = 0, 0, 1
while n < max:
yield b
a, b = b, a + b
n = n + 1
return 'done'
a=fib(5)
for i in a:
print(i)
输出:
>>1
>>1
>>2
>>3
>>5
迭代器:可以被next()函数调用并不断返回下一个值的对象称为迭代器(Iterator
)
可迭代对象转化为迭代器
使用iter(可迭代对象)实现将可迭代对象转化为迭代器
# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
try:
# 获得下一个值:
x = next(it)
print(x)
except StopIteration:
# 遇到StopIteration就退出循环
break
类的定义
class Flower(object):
pass
添加实例属性值
class Flower(object):
def __init__(self,name,color,height):
#默认值
self.name=name
self.color=color
self.height=height
类的实例化
class Flower(object):
def __init__(self,name,color,height):
self.name=name
self.color=color
self.height=height
f=Flower('玫瑰','红色',20)
print(f.name)
print(f.color)
print(f.height)
输出:
>>玫瑰
>>红色
>>20
类没有实例属性时会调用类属性
class Flower(object):
height=20
def __init__(self,name,color):
self.name=name
self.color=color
f=Flower('玫瑰','红色')
print(f.height)
输出:
>>20
实例属性的优先级高于类属性
class Flower(object):
height=20
def __init__(self,name,color,height):
self.name=name
self.color=color
self.height=height
f=Flower('玫瑰','红色',10)
print(f.height)
输出:
>>10
删除实例属性
class Flower(object):
height=20
def __init__(self,name,color,height):
self.name=name
self.color=color
self.height=height
f=Flower('玫瑰','红色',10)
del f.height
print(f.height)
输出:
>>20#由于此时实例属性被删除,自动调用了类属性height=20
私有属性
伪私有属性_attrname
:可以访问但是不要随意访问
私有属性__attrname
:一般不可以访问
访问和修改私有属性
访问私有属性
class Student(object):
def __init__(self,name,score):
self.__name=name
self.__score=score
def get_name(self):
return self.__name
def get_score(self):
return self.__score
s=Student('Jack',88)
#通过自定义方法来访问私有属性
print(s.get_name())
print(s.get_score())
#直接访问私有属性
print(s._Student__name)
print(s._Student__score)
输出:
>>Jack
>>88
>>Jack
>>88
>>a
修改私有属性
class Student(object):
def __init__(self,name,score):
self.__name=name
self.__score=score
def get_name(self,newname):
self.__name=newname
return self.__name
def get_score(self,newscore):
self.__score=newscore
return self.__score
s=Student('Jack',88)
#通过自定义方法修改私有属性
print(s.get_name('Peter'))
print(s.get_score('85'))
#直接修改私有属性
s._Student__name='Mark'
s._Student__score='86'
print(s._Student__name)
print(s._Student__score)
输出:
>>Peter
>>85
>>Mark
>>86
type()函数获取对象信息
判断函数类型
import types
def fn():
pass
print(type(fn)==types.FunctionType)#判断是否是自定义函数
print(type(abs)==types.BuiltinFunctionType)#判断是否是内置函数
print(type(lambda x: x)==types.LambdaType)#判断是否是lambda函数
print(type((x for x in range(10)))==types.GeneratorType)#判断是否是生成器类型
输出:
>>True
>>True
>>True
>>True
isinstance()函数获取对象信息
判断类对象
class Animal(object):
pass
class Dog(Animal):
pass
class Xiaohuang(Dog):
pass
a=Xiaohuang()
b=Dog()
c=Animal()
print(isinstance(a,Dog))#Xiaohuang是否属于Dog类
print(isinstance(b,Animal))#Dog是否属于Animal类
print(isinstance(c,object))#Animal是否属于object类
输出:
>>True
>>True
>>True
判断基本类型数据
a=[1,2,3,4,5]
print(isinstance(a,(list,dict)))#判断a是否属于列表或者字典类型
输出:
>>True
dir()获取一个对象的所有属性和方法
s='hello'
print(dir(s))
输出:
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
内置方法的重写
class myclass():
def __len__(self):
return 10
def __repr__(self):
return 'rewrite repr!'
def __str__(self):
return 'rewrite str!'
a=myclass()
print(len(a)
print(repr(a))
print(str(a))
输出:
>>10
>>rewrite repr!
>>rewrite str!
定制属性访问
hasattr(m,’n’)
m:实例 n:类里面的属性 确定属性是否存在
getattr(m,‘n’)
m:实例 n:类里面的属性 得到指定类属性的值
setattr(m,’n’,x)
m:实例 n:类里面的属性 x:设置属性的值 有则改无则添加
delattr(m,’n’)
m:实例 n:类里面的属性 删除一个类属性
重写__new__方法实现单例模式
class myclass(object):
__instance=None
def __new__(cls, *args, **kwargs):#cls代表myclass类本身
if cls.__instance == None:
cls.__instance=super().__new__(cls)#调用base父类的new方法
return cls.__instance
a=myclass()
b=myclass()
print(id(a))
print(id(b))
输出:
>>3032841896736
>>3032841896736
4.类的析构(销毁无用变量)
5.继承 重写
6.多继承 重写
在类中
super()可以调用父类里面的方法
self.方法()可以调用父类里面的方法
类中查询相关信息
1、class 查看类名
格式: 实例.class
2、dict 查看全部属性,返回属性和属性值键值对形式
格式:实例.dict
3、doc 查看对象文档,即类中(用三个引号引起来的部分)
格式:类名.dict
4、bases 查看父类
格式:类名.base
5.mro 查看多继承的情况下,子类调用父类方法时,搜索顺序
格式:子类名.mro 实例.class.mro
魔术方法:
str repr call init add
描述符
class Myattr():
def get(self,instance,owner):
print(“this is get”)
def set(self,instance,value):
print(“this is set”)
def delete(self,instance):
print(“this is delete”)
class Myclass():
attr=Myattr()
a=Myclass()
a.attr #访问属性来激活__get__方法
a.attr=1 #赋值来激活__set__方法
del a.attr #删除来激活 __delete__方法
文件方法
fp=open(地址,模式,encoding=’utf-8’,errors=’none’/’ignore’) 打开文件
fp.close() 关闭文件
with open() as f1,open() as f2: 上下文管理(可以自动关闭文件)
fp.seek(m) 移动文件指针 当前位置向后移动m个字节
fp.tell() 查看文件指针
fp.flush() 刷新缓冲区和fp.close()类似
文件读取
fp.read(m) 文件读取 读取m个字节
fp.readline() 按行文件读取
fp.readlins() 列表形式读取文件
遍历文件内容
for i in fp:
for i in fp.readlins()
文件写入
fp.write(内容) 文件中写入内容
fp.writelines(list) 文件中写入列表类型内容
文件内容清空
fp.truncate() 文件内容清空
引入模块io
f=io.StringIO()
f=io.BytesIO()
f.getvalue()
try:
print(a) #尝试运行代码
except Exception as e: #将错误类型储存在e中
print("error!")
print(e)
raise Myerror #抛出自定义异常
else:
print("right!") #不出异常才执行
finally:
print("display all the time") #无论是否异常都会执行
导入一个同级1.py文件 import 1 导入一个只可以被引用不可执行的同级1.py文件import .1
导入上一级的 1.py文件 import …1
from a.b.c import hi表示从a下面的b下面的c中导入一个hi函数
from 和 import 后面既可以接目录名也可以接不带后缀的文件名
import sys
sys.path.append(r"filedir") filedir:目录路径 可以是绝对路径也可以是相对路径
引入模块:
import threading
实例化 对象=Thread(target=函数名,args=(函数参数,))
设置线程名 对象.setName(‘线程名’)
获取线程名 对象.getName()
获取当前线程名 threading.current_thread().name
开启线程 对象.start()
线程守护 对象.Daemon(True)
主线程结束它的子线程就结束
线程阻塞对象.join()
当子线程结束后主线程才结束
线程锁
解决cpu资源竞争问题
实例化线程锁对象=threading.Lock()
上锁对象.acquire()
解锁对象.release()
协程(Coroutine
),又称微线程,纤程。
Python对协程的支持是通过生成器(generator
)实现的。
def f1():
print('1')
print('2')
print('3')
def f2():
print('a')
print('b')
print('c')
利用协程输出结果可以为:
>>1
>>2
>>a
>>b
>>3
>>c
作者:妖怪还我师傅
链接:https://www.pythonheidong.com/blog/article/6261/e8b569fa0b56f2404e1f/
来源:python黑洞网
任何形式的转载都请注明出处,如有侵权 一经发现 必将追究其法律责任
昵称:
评论内容:(最多支持255个字符)
---无人问津也好,技不如人也罢,你都要试着安静下来,去做自己该做的事,而不是让内心的烦躁、焦虑,坏掉你本来就不多的热情和定力
Copyright © 2018-2021 python黑洞网 All Rights Reserved 版权所有,并保留所有权利。 京ICP备18063182号-1
投诉与举报,广告合作请联系vgs_info@163.com或QQ3083709327
免责声明:网站文章均由用户上传,仅供读者学习交流使用,禁止用做商业用途。若文章涉及色情,反动,侵权等违法信息,请向我们举报,一经核实我们会立即删除!