python基础知识笔记

最新推荐文章于 2024-04-22 09:42:36 发布

老师你好ss

最新推荐文章于 2024-04-22 09:42:36 发布

阅读量944

点赞数

分类专栏： python 文章标签： python numpy 开发语言

本文链接：https://blog.csdn.net/qq_43384629/article/details/127272087

版权

python 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

1.变量名在命名时不能以数字开头例如 520baby

x=3
y=5
x,y=y,x
print(x,y)

4.在python中使用正常的‘\’而不是转义字符时需要在字符串前面加上r

#在输出一个正常的路径时'\'会被认为是一个转义字符，
#解决的办法是在前面加上r字母
print(r"D\three\two\one\now")

import random
answer=random.randint(1,10)
counts=3
while counts>0:
    temp=input("猜一下小甲鱼心中想的那个数字\n");
    guess=int(temp)
    if guess==answer:
        print("猜对了")
        break
    else:
        if guess<answer:
            print("小啦··")
        else:
            print("大了。。")
    counts=counts-1
print("游戏结束")

import decimal
a=decimal.Decimal('0.1')
b=decimal.Decimal('0.2')
c=decimal.Decimal('0.3')
print(a+b==c)

python在储存复数的时候用的是科学计数法，

x=1+2j
print(1 + 2j)
#取复数的虚部
print(x.real)
#取实数的实部
print(x.imag)

在以上的运算中x//y中，结果取比目标结果小的最大整数

print(3 // 2)  结果为1
print(-3//2)  结果为-2

10.

python中的逻辑运算关系 and or not

其中and为一假为假 or为一真则真 not取相反的结果

python中的短路逻辑核心思想：从左到右，只有当第一个操作数的值无法确定逻辑运算结果时，才对第二个操作数进行求值。其意思示例如下：

3 and 4   #在and运算中，需要证明两边都为真才能确定最终的值，所以结果为4。
3 or 4  #在or运算中，只要确定一方为真，即可认定最终的结果， 所以结果是3。

11.优先级关系

12.

python中的条件语句与别的语言判断有所不同，

if  判断条件:
    elif 判断条件:
        else:

13.

print("九九乘法表")
k=0
for i in range(1,10) :
    for j in range(1,10):
        if j<=i:
            print(j,"*",i,"=",j*i," ",end='')
            k+=1
        if k>=i:
            k = 0
            print("\n")

14.

print("九九乘法表")
k=0
i=1
j=1
while i<10:
    while j<10:
        if j<=i:
            print(j, "*", i, "=", j * i, " ", end='')
        if k==i:
            print("\n")
        j += 1
        k += 1
    i+=1
    j=1
    k = 0

15.

在python中 range()函数的用法 range（起始值，截至值，跨度区间）;

for i in range(1,5,2):
    print(i)              #输出的结果是1  3

for i in range(5,1,-2):
    print(i)              #输出的结果是5  3

素数问题

print("1到10的素数")
for i in range(2,10):
    for j in range(2,i):
        if i%j==0:
            print(i,"不是素数")
            break
else:print(i,"是素数")

17.python中的列表问题

print("python中的列表问题")
rhyme=[1,2,3,4,5,"上山打老虎"]
print(rhyme)
for i in rhyme:
    print(i)

#在索引中可以根据len()函数观看列表中有几个元素，再通过下标来索引所求的元素
print(len(rhyme))
print(rhyme[-1])

18.

print("python在通过索引找元素的方法")
rhyme=[1,2,3,4,5,"上山打老虎"]
#1.只取前三个元素
print(rhyme[:3])   #输出结果   [1, 2, 3]
#2.只取后三个元素
print(rhyme[3:])   #输出结果   [4, 5, '上山打老虎']
#3.跨度取元素
print(rhyme[::2])  #输出结果   [1, 3, 5]
#4.跨度逆取元素
print(rhyme[::-2])  #输出结果  ['上山打老虎', 4, 2]
#5.逆取元素
print(rhyme[::-1])  #输出结果  ['上山打老虎', 5, 4, 3, 2, 1]

19.

heros=["钢铁侠","绿巨人"]
#python的列表元素的增加,对于它的增加有两个方法。
#1.使用函数，即append(),extend()两个方法.
  #1)append()函数增加元素，一次只能加一个
heros.append("黑寡妇")
  #2)extend()函数,一次能够增加多个元素
heros.extend(["鹰眼","雷神"])

s=[1,2,3,4]
#2.python除了函数能够实现这个效果，切片也能实现这个效果
  #1)append()函数的效果
s[len(s):]=[5]
  #2)extend()函数的效果
s[len(s):]=[6,7,8]

#在列表中增加元素时可以插入到任意位置可以使用insert()函数
s=[1,2,4]
s.insert(2,3)#前面的为插入的位置,后面的是插入的数字

20.

heros=["钢铁侠","绿巨人","灭霸","鹰眼","雷神"]
#python中对于列表中元素的移除的函数有三个
#1.remove函数
heros.remove("灭霸")
#2.pop()函数
heros.pop(2)
#3.clear()函数
heros.clear()

21.

heros=["钢铁侠","绿巨人","黑寡妇","鹰眼","雷神","蜘蛛侠"]
#python中列表元素的修改
heros[3:]=["武松","李逵","林冲"]  
#其中这个操作分成两个部分进行的，1.先把heros中的后三个删除。2.把想代替的内容放到heros中

22.

s=[3,5,4,2,9,4,1]
s.sort() #对列表中的元素进行顺序排序
s.reverse() #对列表中的元素进行倒序排序

#python中通过index函数找到元素所在列表中的位置
s=[3,5,4,2,9,4,1]
s.index(3)
#也可以有个区间去找它的值
s.index(4, 3, 6)

23.

print("一个简单的矩阵")
matrix=[[1,2,3],[4,5,6],[7,8,9]]
print(matrix)
for i in matrix:
    for x in i:
        print(x,end=' ')
    print()

print("python中的'is'的用法")
a='num'
b='num'
print(a is b)   #输出的结果为true
x=[1,2,3]
y=[1,2,3]
print(x is y)    #输出的结果是false

对于以上出现的结果的原因，第一个a，b中存储的为字符串，它在存储过程中是不可变的，而x，y为列表，在存储时是可变的，所以用‘is’追本溯源的时候显示的结果不同

print("在塑造一个矩阵的时候需要注意的一个经典的问题")
print("普通塑造矩阵的方法")
a=[0]*3
for i in range(3):
    a[i]=[0]*3
print(a)
print("有问题的塑造方法")
b=[[0]*3]*3
print(b)
print("用’is‘的进行追本溯源判断")
print(a[0] is a[1])   #输出结果为false
print(b[0] is b[1])   #输出的结果为true

print("python中的浅拷贝(2种方法)")
print("浅拷贝的第一种方法")
x=[1,2,3]
y=x.copy()
x[1]=1
print(x) #输出[1,1,3]
print(y) #输出[1,2,3]
print("浅拷贝的第二种方法")
a=[1,2,3]
b=a[:]
a[1]=1
print(a)  #输出[1,1,3]
print(b)  #输出[1,2,3]

print("python中的深拷贝")
import copy
a=[[1,2,3],[4,5,6],[7,8,9]]
b=copy.deepcopy(a)
a[1][1]=0
print(a)  #输出[[1, 2, 3], [4, 0, 6], [7, 8, 9]]
print(b)  #输出[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

print("python中的列表推导式在一维列表中的应用")
print("一维列表的使用")
oho=[1,2,3,4,5]
for i in range(len(oho)):
    oho[i]=oho[i]*2
print(oho)

x=[]
for i in range(10):
    x.append(i+1)
print(x)

print("列表推导式在一维数组中的应用")
oho=[1,2,3,4,5]
oho=[i*2 for i in oho]
print(oho)

x=[]
x=[i+1 for i in range(10)]
print(x)

print("列表推导式在二维数组中的应用")
a=[[1,2,3],[4,5,6],[7,8,9]]
print(a)
col2=[i[1] for i in a]
print(col2)
diag=[a[i][i] for i in range(len(a))]
print(diag)

s=[[0]*3 for i in range(3)] #用列表推导式创建二维数组

even=[i for i in range(10) if i%2==0]  
print(even)
even=[i+1 for i in range(10) if i%2==0]
print(even)
#由以上的两个式子对比可知它的执行顺序是[③ for ① in ②]

print("python中的列表推导式的使用")
matrix=[[1,2,3],[4,5,6],[7,8,9]]
f=[col for row in matrix for col in row] #使用列表推导式的方式
print(f)

f=[]
for row in matrix:  #普通的循环方式
    for col in row:
        f.append(col)
print(f)

print("使用列表推导式的应用2")
f=[]
f=[[x,y] for x in range(10) if x%2==0 for y in range(10) if y%3==0] #列表推导式的使用
print(f)
f=[]
for x in range(10): #普通方式的使用
    if x%2==0:
        for y in range(10):
            if y%3==0:
               f.append([x,y])
print(f)

24.python中的元组

在python中，元组的内容是不支持修改的。可以使用索引进行查找元素，

rhyme=(1,2,3,4,5,"上山打老虎")
rhyme[:3] #取前三个元素
rhyme[3:]#取第三个以后的元素
rhyme[::2]#取元素的时候间隔为二
rhyme[::-1]#把元素的值倒过来
nums=(3,1,5,3,6,9,4,2,0)
nums.count(3)#看元组中3的个数
nums.index(5)#看元组中的位置
s=1,2,3
t=4,5,6
s+t  #结果为(1, 2, 3, 4, 5, 6)
w=s,t #结果为((1, 2, 3), (4, 5, 6))

for i in s: #可以对元组进行循环
    print(i)

t=(123,"dasd",32.0)
x,y,z=t #元组的解包
a,b,c,d,e="fishc" #字符串的解包

需要注意的是在解包的过程中一定要注意元素的个数与元组或者字符串的个数相同。

25.字符串

x="12321"
"是回文数" if x == x[::-1] else "不是回文数"  #一句话判断是否为回文

x="I love FishC"
x.capitalize()  #capitalize()的作用是把首字母变成大写，其他的变成小写 结果为I love fishc
x.casefold()   #casefold()的作用是把所有的字母变成小写
x.title()      #title()的作用是把每个单词的首字母变成大写
x.swapcase()   #swapcase()的作用是将所有的字母大小写变换
x.upper()      #upper()的作用是将所有的字母变成大写
x.lower()      #lower()的作用是将所有的字母变成小写

x="有内鬼,中止交易!"
x.center(20) #把内容居中显示
x.ljust(15) #把内容左对齐
x.rjust(15) #把内容右对齐
x.zfill(15) #空余内容用0填充
x.center(15, '好')#选择填充的内容

x="上海自来水来自海上"
x.count("海",0,5) #count(所要查找的数,起始的索引值,中止的索引值)
x.find("海") #find()查找海字从左开始
x.rfind("海")#rfind()查找海字从又开始
x.index("海")#index()和rindex()两个函数与find()和rfind()函数基本未有差距,就在找不到所要查找的元素时返回的值不同，find()返回-1，index()抛出异常
x.rindex("海")

code="""
    print("i love fishc")
    print("I love my wife")"""
new_code=code.expandtabs(4) #expandtabs(4)的作用时将tab转成空格
"在吗！我在你家楼下，赶紧下来！".replace("在吗","想你")#replace()对内容进行替换
"I love FishC".translate(str.maketrans("ABCDEFG","1234567"))#maketrans()制定规则代换

x="我爱python"
x.startswith("我") #python中在字符串中查找是否含有元素，startswith(需查找元素,起始索引,终止索引)
x.endswith("on",0,10)#endswith("on")结果为false，加上索引范围就为true

x="她爱python"
if x.startswith(("他","它","她")):
    print("总有人爱python")

x="I love Python"
x.istitle()  #判断字符串中单词首字母是否为大写

x.isupper() #判断字符串是否全为大写

x.upper().isupper()#先对字符串进行大写转换，再去判断是否全为大写，相反用lower()

x="I love Python"
x.isalpha() #判断字符串是否全为字母

x.isspace()#判断字符串是否含有空白格

x.isprintable()#判断字符串是否可为可打印字符

x="12345"
#以下三个都是测试字符串是否为数字,但范围有所不同.
x.isdecimal()#结果true
x.isdigit()#结果true
x.isnumeric()#结果true
x="2²"
x.isdecimal()#结果false
x.isdigit()#结果true
x.isnumeric()#结果true
x="ⅠⅡⅢⅣⅤ"
x.isdecimal()#结果false
x.isdigit()#结果false
x.isnumeric()#结果true
x.isalnum()#集合了以上的三个方法,只要有一个显示为true,即为true

"I am good gay".isidentifier()#判断是否为合法的python变量名

"     左侧不要留白".lstrip()#去除左侧的空白
"右侧不要留白     ".rsplit()#去除右侧的空白
"   左右不要留白  ".split()#去除字符串中的空白

"www.ilovefishc.com".lstrip("wcom.")#结果为 ilovefishc.com
"www.ilovefishc.com".rsplit("wcom.")#结果为 www.ilovefishc
"www.ilovefishc.com".split("wcom.")#结果为 ilovefishc

"www.ilovefishc.com".partition(".") #结果为 ('www', '.', 'ilovefishc.com') 分隔符的使用
"www.ilovefishc.com".rpartition(".") #结果为('www.ilovefishc', '.', 'com')

"苟日新,日日新,又日新".split(',',1) #split(分割的标志,分割的次数)
"苟日新,日日新,又日新".splitlines(True) #splitlines()当参数为true的时候会把分割的标志也显示在分割的结果里面

".".join(("f","ish","C"))  #join的拼接作用 结果为f.ish.C

"1+2={},2的平方是{},3的立方是{}".format(1 + 2, 2 * 2, 3 * 3 * 3)#format()中前面的{}表示的占位
"{0}{0}{1}{1}".format("是","非")#根据索引方式显示
"我叫{name},我爱{fav}".format(name="小甲鱼", fav="python")#可以通过名称引用

"{:^10}".format(250) #结果是"   250    "

"{left:>10}{right:<10}".format(right=520, left=250) #结果为"       250520       "
"{1:>10}{0:<10}".format(520,250) #结果为"       250520       "

"{:010}".format(520)#结果为"0000000520"
"{1:%>10}{0:%<10}".format(520, 250)#"%%%%%%%250520%%%%%%%"用百分号进行填充

"{:,}".format(12345)#使用,来分割千分位
"{:.2f}".format(3.1415)#小数点保留两位数字
"{:.2g}".format(2.020)#保留前两位的有效数字
"{:.6}".format("i love fishc")#取字符串的前六个字符
"{:b}".format(80) #整数以二进制的形式输出二进制
"{:e}".format(3.1415)#浮点数以科学计数法输出
"{:.2%}".format(0.98)#结果为98.00%

f"{'ilovefishc':.6}" #f-string,新语法它的作用跟format基本没有差别 加f或者F效果基本上一样

26.

x="fishc"
y="fishc"
x is y #判断x与y的关系是不是同一个对象 结果为true
"你" in "你们" #判断第一个字符是否在第二个字符串里面
x=[1,2,3,4,5]
del x[1:4]#del删除元素的值，删除第二个到第五个之间的数，不包含第五个
del x[::2]#删除的元素为间隔元素

list("Fishc")#字符串转列表
list((1,2,3,4,5))#元组转列表
tuple([1,2,3,4,5])#列表转元组
tuple("FishC")#字符串转元组
str([1,2,3,4,5])#列表转字符串
str((1,2,3,4,5))#元组转字符串

s=[1,1,2,3,5]
min(s)#找到最小数
max(s)#找到最大数

min(1,2,3,4)#与上面的用法有一点不同，基本一致
max(1,2,3,4)

s=[1,2,3,0,6]
sorted(s)#会执行排序,但会创建成一个新的列表
s.sort()#会执行从小到大的排序，且不会改变列表的名称
sorted(s,reverse=True)#会执行从小到大的排序，之后反转
t=["Fishc","Banana","Book","Apple","Pen"]
sorted(t, key=len)#输出结果['Pen', 'Book', 'Fishc', 'Apple', 'Banana'] key的作用是加上限制条件
t.sort(key=len)#跟sorted的作用一样

s=[1,2,5,8,0]
list(reversed(s))#将元素反转过来变成[0,8,5,2,1]
s.reverse()#结果与上面的结果一致

x = [1, 2, 3]
y = [4, 5, 6]
z = [7, 8, 9]
list(zip(x, y, z))  # zip的作用是把x，y，z组合成元组的形式  结果为[(1, 4, 7), (2, 5, 8), (3, 6, 9)]

c = "fishc"
list(zip(x, y, c))  # 当组合长度不同的时候会只以短的为目标，结果为[(1, 4, 'f'), (2, 5, 'i'), (3, 6, 's')]

import itertools
list(itertools.zip_longest(x, y, c)) # 当自己需要以长的为输出目标的时候可以引入itertools，结果为[(1, 4, 'f'), (2, 5, 'i'), (3, 6, 's'), (None, None, 'h'), (None, None, 'c')]

mapped=map(ord,"fishc")
list(mapped)#ord为执行的函数，在此处他表示fishc的每个字母的编码值
list(pow,[2,3,10],[5,2,1])#结果为2，3，10对应的次方
list(map(max,[1,2,3],[4,5,6],[7,8,9,10]))#当对比的数不一致的时候跟zip的作用基本相同

x=[1,2,3,4,5]
y=iter(x)#它的作用是一个创建一个迭代器
type(x)#他是一个列表类型
type(y)#它是一个列表迭代器

next(y)#它是指向迭代器中元素的下一个值
next(y,"没有下一个了")#这样不会抛出异常了，在最后一个元素显示“没有下一个了”

27.

print("创建字典的6中方法")
a={"吕布":"口口布","关羽":"关习习","刘备":"刘baby"}
b=dict(吕布="口口布",关羽="关习习",刘备="刘baby")
c=dict([("吕布","口口布"),("关羽","关习习"),("刘备","刘baby")])
d=dict({"吕布":"口口布","关羽":"关习习","刘备":"刘baby"})
e=dict({"吕布":"口口布","关羽":"关习习"},刘备="刘baby")
f=dict(zip(["吕布","关羽","刘备"],["口口布","关习习","刘baby"]))
print("以上6中构建字典的方式均等价")

#字典中的增操作
d=dict.fromkeys("Fish",250)#结果为{'F': 250, 'i': 250, 's': 250, 'h': 250}
#改变其中一个键对应的值
d["F"]=70
#当添加的键值不存在时，会添加一个全新的值
d["C"]=67  #结果为{'F': 70, 'i': 250, 's': 250, 'h': 250, 'C': 67}

#字典中删除方法
d.pop("s")
#字典中的popitem方法，注意在python3.7版本之前是随机删除一个字典的值，在3.7之后变成了删除字典的最后一个元素
d.popitem()
#字典中的del方法，可以根据键来删除键值
del d["i"]
#当del只写字典名时，则会删除整个字典
del d
#如果只想清空字典里面的值可以使用clear方法
d.clear()

#字典中批量更改字典中的值，可以使用update方法
d=dict.fromkeys("FishC")
d.update(i='10',s='20')

#字典中查找值时，可以使用get(所要查找的值,如果没有所要查询的值则会打印这个内容)方法
d=dict.fromkeys("FishC")
d.get('c',"这里没有c")
#字典查找方法，在所要查询的内容没有值时可以使用setdefault()方法，它的作用是在字典没有这个元素是创建元素
d.setdefault('c',"code")#在字典中没有c的值，所以结果会出现c的值，并且c的对应的值为code

#字典的items，values，keys的三个方法
d=dict.fromkeys("FishC")
keys=d.keys() #dict_keys(['F', 'i', 's', 'h', 'C'])
items=d.items() #dict_items([('F', None), ('i', None), ('s', None), ('h', None), ('C', None)])
values=d.values() #dict_values([None, None, None, None, None])

len(d)#可以判断字典中有几个键值对
'C' in d #可以查看键值是否在d中
'c' not in d

#字典可以转换成列表
list(d)#这里是键组成的列表
list(d.values())#这里是键值组成的列表

#字典也可以转换成一个迭代器
e=iter(d)
#可以用next显示下一个键
next(e)#结果为F

#python在3.8版本之后对字典进行了排序，能够使用reversed的函数进行排序
list(reversed(d.values()))

d={"吕布":{"语文":80,"数学":60,"英语":70},"关羽":{"语文":10,"数学":60,"英语":50}}
d["吕布"]["数学"]
d={"吕布":[60,5,3],"关羽":[80,52,61]}
d["吕布"][1]

d={'F':70,'i':105,'s':115,'h':104}
b={v:k for k,v in d.items()}#对键和值进行调换

d={x:ord(x) for x in "FishC"}#输出字符串的ASCII码值

28.

字典与集合最大的区别在于集合元素都是独一无二的并且也是无序的。

#使用类型构造器构建集合
s=set("FishC")
s[0]#这种方式是错误的，因为集合的无序性，所以不能使用下标索引来查找值

'C' in s #查看元素是否在集合里面
'c' not in s

#查看元素中是否有相同的元素
s=[1,2,3,1,5]
len(s)==len(set(s))#看看长度是否相同，集合会自动去重

#判断两个集合是否有相同的元素
s=set("FishC")
s.isdisjoint(set("Python"))
s.isdisjoint("python")#传入可迭代的对象即可

#判断两个集合之间是否为子集的关系 子集<=,<  s> set("FishC")
s.issubset("FishC.COM.CN")

#判断两个集合有无超集关系 也就是包含关系  超集>,>=
s.issuperset("Fish")

#对两个集合进行合并  并集 |
s.union({1,2,3})#把1，2，3的元素对s集合进行合并

#找到两个集合之间的交集   交集 &
s.intersection("Fish")

#找到两个集合之间相差的元素  差集 -
s.difference("Fish")

# union函数和intersection函数以及difference函数之间都可以多函数下面举一个例子
s.union({1,2,3},"python")

#对称差数：抛出A,B之间的共有元素，对剩下的元素进行合并,他不支持多参数 ^
s.symmetric_difference("Python")

#用frozenset函数创建的字典是不可变的，用set函数创建的集合能够改变
t=frozenset("FishC")

s=set("FishC")
s.update([1, 1], "23")# 对set构建的字典进行内容的修改 结果为{'i', 1, '2', 'h', 's', 'C', 'F', '3'}

#对字典交集进行修改
s.intersection_update("Fish")

#对字典差集进行修改
s.difference_update("Php")

#对字典的对称差集进行修改
s.symmetric_difference_update("Python")

s.add("45")#需要注意add和update函数的差别，update函数会把修改的字符串变成一个个字符插入到字典中，而add是把整个的字符串都插入到字典中

s.remove("sda")#想要删除的元素在字典中不存在的情况，会抛出异常

s.discard("avs")#想要删除的元素在字典中不存在的情况，会静默处理,即字典原有的元素

s.pop()#随机弹出字典中的一个元素

29.

def div(x,y): #def为关键字
    if y==0:
        return "除数不能为0"
    return x/y

def myfunc(s,vt,o):
    return "".join((o,vt,s))

#两种参数的调用
myfunc("小鲫鱼","打了","我")

myfunc(o="我",vt="打了",s="小甲鱼")


def myfunc(s,*,vt,o):
    return "".join((o,vt,s))

myfunc("我",vt="打了",o="你")#需要注意的是在定义函数时有*号那么*后面的参数必须加上形参才不会报错

#函数传递多个参数，使用参数收集器
def myfunc(*args):
    print(args)
myfunc(1,2,3)#这样在传递参数时可以传递多个值了

def myfunc(*args):
    print(type(args))#函数在参数收集器中的值为元组的形式存在

def myfunc(*args,a,b):
    print(args,a,b)
myfunc(1,2,3,a=1,b=2)#在制定参数有参数收集器的形式，还要混合其他参数的时候需要注意其他的参数需要指明名称

#把参数打包成字典
def myfunc(**kwrgs):
    print(kwrgs)

myfunc(a=1,b=2,c=3)#因为是字典打包的形式，所以需要指定键和键值

def myfunc(a,*b,**c):
    print(a,b,c)

myfunc(1,2,3,4,x=5,y=6)#混合的形式1是a的值，2，3，4是b的值，剩下的是c的值

#函数元组的解包
args=(1,2,3,4)
def myfunc(a,b,c,d):
    print(a,b,c,d)

myfunc(*args)

#函数字典的解包
kwargs={'a':1,'b':2,'c':3,'d':4}
myfunc(**kwargs)

x=880
def myfunc():
    global x
    x=520
    print(x)
myfunc()#结果为520
print(x)#结果也为520

#函数的嵌套
def funA():
    x=520
    def funB():
        x=880
        print("in funB,x=",x)
    funB()
    print("in funA,x=",x)
funA()#结果为in funB,x=880  in funA,x=520

#函数的闭包
def power(exp):
    def exp_of(base):
        return base ** exp
    return  exp_of()
square=power(2)
cube=power(3)
square(2)#结果为2**2=4  **为幂函数次方
cube(2)#结果是2**3=8

def outer():
    x=0
    y=0
    def inner(x1,y1):
        nonlocal x,y
        x+=x1
        y+=y1
        print(f"现在，x={x},y={y}")
    return inner()
move=outer()
move(1,2)#nonlocal函数能够让内部的值修改外部的值，所以第一次调用的时候是x=1，y=2
move(-2,2)#而在第二次调用的时候x，y的被改变之后，再次调用的时候就会形成记忆，此时的结果为1-2=-1，2+2=4

#在python中一个函数调用另一个函数的方式
def myfunc():
    print("正在调用myfunc。。。")

def report(func):
    print("开始调用函数。。")
    func()
    print("调用函数完毕。。")

report(myfunc)

#使用装饰器统计python程序运行的时间  装饰器的内容就是闭包知识的使用
import time

def time_master(func):
    def call_func():
        print("开始运行程序....")
        start=time.time()
        func()
        stop=time.time()
        print("程序运行结束..")
        print(f"一共耗费了{(stop-start):.2f} 秒")
    return call_func

@time_master
def myfunc():
    time.sleep(2)
    print("holle word")
#myfunc=time_master(myfunc)与@time_master 作用一样
myfunc()

#lambda表达式  使用一行代码表示 lambda是一个表达式而非语句，它能够出现在python语法不允许def语句出现的地方
def squareX():
    return x*x
squareX(3) #普通的def实现平方的方式

squareY=lambda y:y*y
squareY(3)

def boring():
    return  ord(x)+10
list(map(boring,"FishC"))#普通的实现方式


mapped=map(lambda x:ord(x)+10,"FishC")
list(mapped)#用lambda表达式表示

#python中的生成器--yield语句
def counter():
    i=0
    while i<=5:
        yield i
        i+=1

for i in counter():
    print(i)
#yield生成器的作用是每一次的调用提供一个数据并且会记住当时的状态，它还支持next()函数，不支持下标索引
#用yield函数编写斐波那契数列
def fib():
    back1,back2=0,1
    while True:
        yield back1
        back1,back2=back2,back2+back1

# 生成器表示式
(i**2 for i in range(10))

#python中的递归方式
#求一个数的阶乘
def factIter(n):
    result=n
    for i in range(1,n):
        result*=1
    return result
factIter(5)
def factRecur(n):
    if n==1:
        return 1
    else:
        return n*factRecur(n-1)
factRecur(5)

#使用迭代器的方法算斐波那契数列
def fibIter(n):
    a=1
    b=1
    c=1
    while n>2:
        c=a+b
        a=b
        n-=1
    return c

#使用递归的方法
def fibRcur(n):
    if n==1 or n==2:
        return 1
    else:
        return fibRcur(n-1)+fibRcur(n-2)

#汉诺塔问题
def hanoi(n,x,y,z):
    if n==1:
        print(x,'-->',z)#如果只有1层，直接将金片从x移动到z
    else:
        hanoi(n-1,x,z,y)#将x上的n-1个金片移动到y
        print(x,'-->',z)#将最底下的金片从x移动到z
        hanoi(n-1,y,x,z)#将y上的n-1个金片移动到z
n=int(input('请输入汉诺塔的层数：'))
hanoi(n,'A','B','C')

#类型注释
def times(s:str,n:int)->str:
    return s*n
times("FishC",5)#输入的是字符串和数字类型，输出的是字符串类型

def times(s:list[int],n:int=3)->list:#列表的形式
    return s*n

def times(s:dict[str,int],n:int=3)->list:#字典的形式
    return list(s.keys())*n

#自省，它是指在程序运行的时候能够进行自我检测的一种机制
times().__annotations__#通过自省知道函数的类型
times().__doc__#查看函数的文档

#高级函数
#reduce函数
def add(x,y):
    return x+y
import functools
functools.reduce(add,[1,2,3,4,5])#相当于add(add(add(add(1,2),3),4),5)

functools.reduce(lambda x,y:x*y,range(1,11))#10的阶乘

#偏函数--把函数的多个参数拆分起来进行多次传递
square=functools.partial(pow,exp=2)
square(2)

cube=functools.partial(pow,exp=3)
cube(3)

30.

#永久储存
f=open("FishC.txt","w")#创建一个名字叫fishC的文件
f.write("I Love Python")#有返回值的写入
f.writelines(["I love FishC.\n","I love my wife."])#无返回值的写入，注意默认是不带换行
f.close()
f=open("FishC.txt","r+")#用r+更新文件的方式来打开
f.readable()#判断是否可以读取
f.writable()#判断是否可以写入
for each in f:#输出文档的内容
    print(each)
f.read()#读出文档剩下的内容
f.tell()#返回当前文件指针在文件对象中的位置
f.readline()#读取文档的一行
f.truncate(29)#截断29的字符串

#查询路径的方法
from pathlib import Path
Path.cwd()
p=Path("D:\python\\test")
q=p/"FishC.txt"

p.is_dir()#判断一个路径是否为一个文件夹
p.is_file()#判断一个路径是否为一个文件
p.exists()#判断路径是否存在
p.name#获取路径的最后一个部分
p.stem#获取文件名
q.suffix#获取文件的后缀
p.parent#获取父级目录
p.parents#获取逻辑祖先路径构成的序列
ps=p.parents
for each in ps:#可以打印出每个祖先路径到子孙路径的各个情况，同时支持索引
    print(each)
p.parts #把路径拆分成各个组件
p.stat()#查询文件或者文件夹的信息

Path("./doc").resolve()#由相对路径变成绝对路径
p.iterdir()#打印当前路径下的所有子文件和子文件夹
for each in p.iterdir():
    print(each)
[x for x in p.iterdir() if x.is_file()]#只要当前的文件夹

# #修改路径下的文件
n=p/"FishC"
# n.mkdir()#修改路径增加文件夹
n=n/"FishC.txt"
f=n.open("w")
f.write("I love FishC")
f.close()
n.rename("NewFishC.txt")#需要注意的是路径会发生改变
m=Path("NewFishC.txt")
m.replace(n)#路径变成n的路径文件名也会发生改变

#路径的删除操作redir()删除文件
n.unlink()#删除文件
n.parent.rmdir()#删除文件夹

#查找功能
p.glob("*.txt")

# #编写pki的文件
import pickle

x,y,z=1,2,3
s="FishC"
l=["小甲鱼",520,3.14]
d={"one":1,"two":2}
with open("data.pkl","wb") as f:
    pickle.dump(x,f)
    pickle.dump(y, f)
    pickle.dump(z, f)
    pickle.dump(s, f)
    pickle.dump(l, f)
    pickle.dump(d, f)

# #编写py文件
# import pickle

with open("data.pkl","rb") as f:
    x=pickle.load(f)
    y = pickle.load(f)
    z = pickle.load(f)
    s = pickle.load(f)
    l = pickle.load(f)
    d = pickle.load(f)
print(x,y,z,s,l,d)

31.

#处理异常
try:
    1/0
except:
    print("出错了")

#抛出指定的异常
try:
    250+"FishC"
except ZeroDivisionError:#抛出指定错误才会执行except语句
    print("出错了-")
#打印抛出异常的原因
try:
    1/0
except ZeroDivisionError as e:
    print(e)

#异常的try-except-finally语句
try:
    f=open("FishC.txt","w")
    f.write("I love FishC。")
except:
    print("出错了")
finally:
    f.close()

32.

#对象=属性(一个对象的静态特征称为属性)+方法(一个对象所能做的事情称为方法)
class Turtle:
    head=1
    eyes=2
    legs=4
    shell=True

    def crawl(self):  #self的作用是让python知道到底是那个对象在调用
        print("输出1")
    def run(self):
        print("输出2")
    def bite(self):
        print("输出3")
    def eat(self):
        print("输出4")
    def sleep(self):
        print("zzzz在...")

t1=Turtle()
print(t1.eat())

#继承
class A:
    x=520
    def hello(self):
        print("A")
class B(A):#B继承A
    x=880
    def hello(self):
        print("b")
b=B()
b.x

isinstance((b,B))#判断一个对象是否属于一个类

#多重继承
class A:
    x=520
    def hello(self):
        print("A")
class B():#B继承A
    x=880
    y=250
    def hello(self):
        print("b")
class C(A,B):
    pass
c=C()
print(c.y)

#组合
class Turtle:
    def say(self):
        print("不积跬步无以至千里")
class Cat:
    def say(self):
        print("喵喵喵~")
class Dog:
    def say(self):
        print("哦吼，我是一只小狗")
class Garden:
    t=Turtle()
    c=Cat()
    d=Dog()
    def say(self):
        self.t.say()
        self.c.say()
        self.d.say()
g=Garden()
print(g.say())

#构造函数
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
c=C(2,3)
print(c.add())

#重写
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):
        C.__init__(self,x,y)
        self.z=z
    def add(self):
        return C.add(self)+self.z
    def mul(self):
        return C.mul(self)*self.z
d=D(2,3,4)
print(d.add())

#钻石继承
class A:
    def __init__(self):
        print("哈喽，我是A")
class B1(A):
    def __init__(self):
        A.__init__(self)
        print("哈喽，我是B1")
class B2(A):
    def __init__(self):
        A.__init__(self)
        print("哈喽，我是B2")
class C(B1,B2):
    def __init__(self):
        B1.__init__(self)
        B2.__init__(self)
        print("哈喽，我是C")
c=C()
print(c)#问题是A的函数被调用了两次

#钻石继承问题的解决
class A:
    def __init__(self):
        print("哈喽，我是A")
class B1(A):
    def __init__(self):
        super().__init__()
        print("哈喽，我是B1")
class B2(A):
    def __init__(self):
        super().__init__()
        print("哈喽，我是B2")
class C(B1,B2):
    def __init__(self):
        super().__init__()
        print("哈喽，我是C")
c=C()
print(c)

#Mixin 混入或者乱入 -在各个方法中对于问题的补充的类
class Animal:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def say(self):
        print(f"我叫{self.name},今年{self.age}岁。")
class Pig(Animal)
    def special(self):
        print("我的技能是拱大白菜~")
p=Pig("大肠",5)
p.say()
p.special()
#想让大肠飞起来
class Animal:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def say(self):
        print(f"我叫{self.name},今年{self.age}岁。")
class FlyMixin:
    def fly(self):
        return "哦吼，我还会飞"
class Pig(FlyMixin,Animal):
    def special(self):
        return "我的技能是拱大白菜~"
p=Pig("大肠",5)
p.say()
p.special()
p.fly()

#示例二
class Displayer:
    def display(self,message):
        print(message)
class LoggerMixin:
    def log(self,message,filename="logfile.txt"):
        with open(filename,"a") as f:
            f.write(message)
    def display(self,message):
        super().display(message)#super指的父类，但是此方法没有父类，即object对象，会从头开始找，会在Display类的下面找到display方法
        self.log(message)#self指的是subclass，会指向MySubClass的类
class MySubClass(LoggerMixin,Displayer):
    def log(self,message):
        super().log(message,filename="subclasslog.txt")
subclass=MySubClass()
subclass.display("this is a test.")

#多态
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):
        return self.length*self.length
class Circle(Shape):
    def __init__(self,radius):
        super().__init__("圆形")
        self.radius=radius
    def area(self):
        return 3.14*self.radius*self.radius
class Triangle(Shape):
    def __init__(self,base,heiht):
        super().base=base
        self.base=base
        self.heiht=heiht
    def area(self):
        return self.base*self.heiht/2
s=Square(5)
c=Circle(6)
t=Triangle(3,4)
#以上三个对象都是继承了shape的对象，但是输出的值不同，这就是多态的体现

class Cat:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def intro(self):
        print(f"我是一只小猫，我叫{self.name},今年{self.age}岁~")
    def say(self):
        print("miaomiao~")
class Dog:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def intro(self):
        print(f"我是一只小狗，我叫{self.name},今年{self.age}岁~")
    def say(self):
        print("汪汪叫~")
class Pig:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def intro(self):
        print(f"我是一只小猪，我叫{self.name},今年{self.age}岁~")
    def say(self):
        print("哼哼~")
c=Cat("web",4)
d=Dog("布布",7)
p=Pig("大肠",5)
def animal(x):
    x.intro()
    x.say()


animal(c)
animal(d)


#鸭子类型---只要对象的方法与要继承的方法一样，就能够去执行

def animal(x):
    x.intro()
    x.say()

class Bicycle:
    def intro(self):
        print("啦啦啦")
    def say(self):
        print("嘟嘟嘟")
b=Bicycle()
print(animal(b))

#私有变量--在python中无法做到真正的私有化，还是能通过改名称的方式访问到值
class C:
    def __init__(self,x):
        self.__x=x
    def set_x(self,x):
        self.__x=x
    def get_x(self):
        print(self.__x)
c=C(250)
#访问方式1
print(c.get_x())
#访问方式2
print(c._C__x)
#_单个下横线开头的变量是仅供内部使用的变量
#单个下横线结尾的变量_是在定义变量时想使用关键字

#__slots__函数 固定对象的属性
class C:
    __slots__ = ["x","y"]
    def __init__(self,x):
        self.x=x
c=C(250)

#在访问c的属性x，y都是没有问题，但是不能动态添加属性
#继承自父类的__slots__属性是不会在子类中生效的

class C:
    __slots__ = ["x","y"]
    def __init__(self,x):
        self.x=x
class E(C):
    pass

e=E(250)
e.x
e.y
e.z=666#在这里能够添加

#__init__在对象初始化的时候实现个性化定制
#__now__能够对不可变的对象进行修改，它能赶在实例对象被创建之前进行拦截
class CapStr(str):
    def __new__(cls, string):
        string=string.upper()
        return super().__new__(cls,string)
cs=CapStr("FishC")

#当对象被销毁的时候会触发__del__
class C:
    def __init__(self):
        print("我来了")
    def __del__(self):
        print("我走了")
c=C()
del c#触发条件

#在对象被销毁之后使得对象重生
#方法一  全局变量的方法
class D:
    def __init__(self,name):
        self.name=name
    def __del__(self):
        global x
        x=self
d=D("小甲鱼")
del d
x.name

#方法二 使用闭包的方法
class E:
    def __init__(self,name,func):
        self.name=name
        self.func=func
    def __del__(self):
        self.func(self)
def outter():
    x=0
    def inner(y=None):
        nonlocal x
        if y:
            x=y
        else:
            return x
    return inner
f=outter()
e=E("小甲鱼",f)
del e
g=f()
print(g.name)

#__add__ 在使用加运算时调用函数
class S(str):
    def __add__(self, other):
        return len(self)+len(other)
s1=S("FishC")
s2=S("Python")
print(s2+s1)

#__radd__ 在add方法不能实现时会调用此方法 注意：要基于不同的类
class S1(str):
    def __add__(self, other):
        return NotImplemented
class S2(str):
    def __radd__(self, other):
        return len(self)+len(other)
s1=S1("Apple")
s2=S2("Banana")
s1+s2#结果是11


#__iadd__ 加等于运算函数
class S1(str)
    def __iadd__(self, other):
        return len(self)+len(other)
class S2(str):
    def __radd__(self, other):
        return len(self)+len(other)
s1=S1("Apple")
s2=S2("Banana")
s1+=s2

#属性访问
class C:
    def __init__(self,name,age):
        self.name=name
        self.__age=age
    def __getattribute__(self, attrname):
        print("拿来吧你")
        return super().__getattribute__(attrname)
    def __getattr__(self, attrname):
        if attrname=="FishC":
            print("I love FishC")
        else:
            raise AttributeError(attrname)
c=C("小甲鱼",18)
hasattr(c,"name")#判断对象中是否含有该属性
getattr(c,"name")#获取属性的值
getattr(c,"_C__age")#获取私有变量的值
setattr(c,"_C__age",19)#设置私有属性的值
getattr(c,"_C__age")
delattr(c,"_C__age")#删除属性

getattr(c,"name")#__getattribute__会在使用getattr的方法时触发

c.FishC#访问一个不存在的方法时会先调用__getattribute__后调用__getattr__抛出异常

class D:
    def __setattr__(self, name, value):
        self.name=value

d=D()
d.name="小甲鱼"#这样实现会进入死循环，因为在刚开始给它设置值时会触发__setattr__，而后执行这个方法之后再执行self.name=value这句又会执行到__setattr__
#改进上面的方法是使用字典的方法，如以下的代码
class D:
    def __setattr__(self, name, value):
        self.__dict__[name]=value

d=D()
d.name="小甲鱼"

#__delattr__方法的使用
class D:
    def __setattr__(self, name, value):
            self.__dict__[name]=value
    def __delattr__(self, name):
        del self.__dict__[name]
d=D()
d.name="小甲鱼"
del d.name

#__getitem__和__settitem__
class D:
    def __init__(self,data):
        self.data=data
    def __getitem__(self, index):
        return self.data[index]
    def __setitem__(self, index, value):
        self.data[index]=value
d=D([1,2,3,4,5])
d[1]
d[2:4]=[2,3]##getitem函数在获取值或者切片的时候会触发

#__iter__和__next__在可迭代中可以用到
class Double:
    def __init__(self,start,stop):
        self.value=start-1
        self.stop=stop
    def __iter__(self):
        return self
    def __next__(self):
        if self.value==self.stop:
            raise StopIteration
        self.value+=1
        return self.value*2
d=Double(1,5)
for i in d:
    print(i,end=' ')

#__contains__主要用于实现成员关系的检测
class C:
    def __init__(self,data):
        self.data=data
    def __contains__(self, item):
        print("(｡･∀･)ﾉﾞ嗨")
        return item in self.data
c=C([1,2,3,4,5])
3 in c#如果3在c里面就会返回True，否则为False
#当对象里面没有__contains__方法时，会尝试代偿的方式处理问题
class C:
    def __init__(self,data):
        self.data=data
    def __iter__(self):
        print("Iter",end='->')
        self.i=0
        return self
    def __next__(self):
        print("next",end='->')
        if self.i==len(self.data):
            raise StopIteration
        item=self.data[self.i]
        self.i+=1
        return item
c=C([1,2,3,4,5])

#当对象既没有__contains__也没有__iter__和__next__函数时
class C:
    def __init__(self,data):
        self.data=data
    def __getitem__(self, index):
        print("Getitem",end='->')
        return self.data[index]
c=C([1,2,3,4,5])

#__bool__函数
class D:
    def __bool__(self):
        print("Bool")
        return True
d=D()
bool(d)

#bool函数的代偿len函数
class D:
    def __init__(self,data):
        self.data=data
    def __len__(self):
        print("Len")
        return len(self.data)
d=D("FishC")
bool(d)

#大于，小于，等于的拦截
#更改传统的字符串比较的方式，更改成长度判断
class S(str):
    def __lt__(self,other):
        return len(self)<len(other)
    def __gt__(self, other):
        return len(self)>len(other)
    def __eq__(self, other):
        return len(self)==len(other)
s1=S("FishC")
s2=S("fishc")

class C:
    def __call__(self, *args, **kwargs):#一个*是位置参数，二个*是关键参数
        print(f"位置参数->{args}\n关键字参数->{kwargs}")
c=C()
c(1,2,3,x=250,y=520)

#在实现平方的对象时，也可以使用call方法
class Power:
    def __init__(self,exp):
        self.exp=exp
    def __call__(self, base):
        return base**self.exp
square=Power(2)
square(2)
#关于字符串的方法,__str__和__repr__的方法
str(123)#是将数值型变换成string型
repr(123)#也是将数值型变成字符型
str("FishC")#结果为'FishC'
repr("FishC")#结果为"'FishC'"
eval("1+2")#是将参数去除引号之后进行操作

#当对象里面没有str方法可以用repr进行补偿
class C:
    def __repr__(self):
        return "I love FishC"
c=C()
str(c)
#上述方法反之不行

#property函数
class C:
    def __init__(self):
        self._x=250
    def getx(self):
        return self._x
    def setx(self,value):
        self._x=value
    def delx(self):
        del self._x
    x=property(getx,setx,delx)
c=C()

#使用__getattr__函数__setattr__函数__delattr__函数实现property函数
class D:
    def __init__(self):
        self._x=250
    def __getattr__(self, item):
        if item=='x':
            return self._x
        else:
            super().__getattr__(item)
    def __setattr__(self, name, value):
        if name=='x':
            super().__setattr__('_x',value)
        else:
            super().__setattr__(name,value)
    def __delattr__(self, item):
        if item=='x':
            super().__delattr__('_x')
        else:
            super().__delattr__(item)
d=D()
print(d.x)

#使用装饰器property函数
class E:
    def __init__(self):
        self._x=250
    @property
    def x(self):
        return self._x
e=E()
e.x#由于只给了一个参数这里只有读取的功能
#上面的语法糖的原始写法
class E:
    def __init__(self):
        self._x=250
    def x(self):
        return self._x
    x=property(x)
e=E()
e.x#由于只给了一个参数这里只有读取的功能

#使用装饰器实现第一个例子
class E:
    def __init__(self):
        self._x=250
    @property
    def x(self):
        return self._x
    @x.setter
    def x(self,value):
        self._x=value
    @x.deleter
    def x(self):
        del self._x
e=E()
print(e.x)

#类方法-classmethod
class C:
    def funA(self):
        print(self)
    @classmethod
    def funB(cls):
        print(cls)
c=C()
c.funA()#普通方法
c.funB()#类方法

#类方法-classmethod的应用1
class C:
    count=0
    def __init__(self):
        C.count+=1
    @classmethod
    def get_count(cls):
        print(f"该类一共实例了{cls.count}个对象")
c1=C()
c2=C()
c3=C()
print(c3.get_count())

#类方法-classmethod的应用2
class C:
    count=0
    @classmethod
    def add(cls):
        cls.count+=1
    def __init__(self):
        self.add()
    @classmethod
    def get_count(cls):
        print(f"该类一共实例了{cls.count}个对象")

class D(C):
    count = 0
class E(C):
    count = 0

c1=C()
d1,d2=D(),D()
e1,e2,e3=E(),E(),E()
c1.get_count()
d1.get_count()
e1.get_count()


#静态方法 -staticmethod
class C:
    @staticmethod
    def funC():
        print("I love FishC")
c=C()
c.funC()
C.funC()#C与小c的调用效果一样

#静态方法的应用
class C:
    count=0
    def __init__(self):
        C.count+=1
    @staticmethod
    def get_count():
        print(f"该类一共实例化了{C.count}个对象")
c1=C()
c2=C()
c3=C()
c3.get_count()

#描述符--只要实现了__get__,__set__,delete__其中一个函数就被称为描述符
class D:
    def __get__(self,instance,owner):
        print(f"get-\nself->{self}\ninstance->{instance}\nower->{owner}")
    def __set__(self, instance, value):
        print(f"set-\nself->{self}\ninstance->{instance}\nvalue->{value}")
    def __delete__(self, instance):
        print(f"delete-\nself->{self}\ninstance->{instance}")
class C:
    x=D()
c=C()


#property函数与描述符的比较，显然property函数更加合理，因为描述符比property出现早
class E:
    def __get__(self, instance, owner):#instance是被描述符拦截的属性所在的类的实例对象
        return instance._x
    def __set__(self, instance, value):
        instance._x=value
    def __delete__(self, instance):
        del instance._x
class F:
    def __init__(self,x=250):
        self._x=x
    x=E()

f=F()
print(f.x)
print(f.__dict__)
#property实现的方法
class E:
    def __init__(self):
        self._x=250
    @property
    def x(self):
        return self._x
    @x.setter
    def x(self,value):
        self._x=value
    @x.deleter
    def x(self):
        del self._x
e=E()
print(e.x)

#描述符只能应用到类属性
# 描述符分为数据描述符和非数据描述符
#数据描述符有__set__()和__delete()和__set_name__(3.6版本之后新加的函数)
#非数据描述符有__get__()
#优先级的顺序是数据描述符->实例对象属性->非数据描述符->类属性

# __set_name__的作用
class D:
    def __init__(self,name):
        self.name=name
    def __get__(self, instance, owner):
        print("get")
        return instance.__dict__.get(self.name)
    def __set__(self, instance, value):
        print("set")
        instance.__dict__[self.name]=value
class C:
    x=D("x")
c=C()
c.x

#__set_name__使用
class D:
    def __set_name__(self, owner, name):
        self.name=name
    def __get__(self, instance, owner):
        print("get")
        return instance.__dict__.get(self.name)
    def __set__(self, instance, value):
        print("set")
        instance.__dict__[self.name]=value
class C:
    x=D()
c=C()
print(c.x)
c.x=520
print(c.x)