python实战打卡---day3_def excepter(f): i = 0 t1 = time.time() def wrappe-CSDN博客

本文链接：https://blog.csdn.net/liang0502/article/details/125569860

打印

lst=[1,3,5]
print(lst) # [1,3,5]
print('lst:{}'.format(lst)) # lst:[1, 3, 5]
print('lst:',lst) # lst: [1, 3, 5]

创建属性的两种方式

返回property属性，典型的用法：
```
class C:
    def __init__(self):
        self._x=None
    def getx(self):
        return self._x
    def setx(self,value):
        self._x=value
    def delx(self):
        del self._x
    # 使⽤property类创建 property 属性
    x = property(getx, setx, delx, "I'm the 'x' property.")
```
使⽤python装饰器，实现与上完全⼀样的效果代码：
```
class C:
    def __init__(self):
        self._x=None
    @property
    def x(self):
        return self._x
    @x.setter
    def x(self,value):
        self._x=value
    @x.deleter
    def x(self):
        del self._x
```
装饰器：

装饰器(Decorators)是 Python 的一个重要部分。简单地说：他们是修改其他函数的功能的函数。他们有助于让我们的代码更简短，也更Pythonic（Python范儿）。

简言之，python装饰器就是用于拓展原来函数功能的一种函数，这个函数的特殊之处在于它的返回值也是一个函数，使用python装饰器的好处就是在不用更改原函数的代码前提下给函数增加新的功能。

装饰器就是咱们的手机壳，你尽管套上了手机壳，但并不影响你的手机功能，可你的手机还是该可以给你玩，该打电话打电话，该玩游戏玩游戏，而你的手机就变成了带手机壳的手机。

*args就是就是传递一个可变参数列表给函数实参，这个参数列表的数目未知，甚至长度可以为0。

**kwargs则是将一个可变的关键字参数的字典传给函数实参，同样参数列表长度可以为0或为其他值

args和kwargs不仅可以在函数定义中使用，还可以在函数调用中使用。在调用时使用就相当于pack（打包）和unpack（解包），类似于元组的打包和解包。
```
def test_args_kwargs(arg1, arg2, arg3):
    print("arg1:", arg1)
    print("arg2:", arg2)
    print("arg3:", arg3)

args = ("two", 3, 5)
test_args_kwargs(*args)
'''
arg1: two
arg2: 3
arg3: 5
'''
```
```
kwargs = {"arg3": 3, "arg2": "two", "arg1": 5}
test_args_kwargs(**kwargs)
'''
arg1: 5
arg2: two
arg3: 3
'''
```
创建range序列
1. range(stop)
2. range(start,stop[,step])
```
range(11) # range(0,11)
```

反向迭代器

rev=reversed([1,4,2,3,1])
for i in rev:
    print(i)
    
'''
1
3
2
4
1
'''

四舍五入

ndigits代表小数点后保留几位
```
round(10.022222222,3) # 10.022
```
转为集合类型

返回一个set对象，集合内不允许有重复元素。
```
a=[1,4,2,3,1]
set(a) # [1,2,3,4]
```
转为切片对象

class slice(start, stop[, step])
返回⼀个表⽰由 range(start, stop, step) 所指定索引集的 slice对象，它让代码可读性、可维护性变好。
```
a=[1,4,2,3,1]
my_slice_meaning=slice(0,5,2)
a[my_slice_meaning] # [1,2,1]
```
拿来就用的排序函数

sort 与 sorted 区别：

sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
```
a=[1,4,2,3,1]
sorted(a,reverse=True) # [4,3,2,1,1]
# reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
```

求和函数

a=[1,4,2,3,1]
sum(a) # 11
sum(a,12) # 23

转元组

tuple()将对象转为一个不可变的类型序列

i_am_list=[1,3,5]
i_am_tuple=tuple(i_am_list)
i_am_tuple # (1, 3, 5)

查看对象类型

class type(name, bases, dict)传⼊⼀个参数时，返回 object 的类型：

class Student():
    def __init__(self,id,name):
        self.id=id
        self.name=name
    def __repr__(self):
        return 'id='+self.id+'name='+self.name
xiaoming=Student(id='001',name='xiaoming')
type(xiaoming) # __main__.Student
type(tuple()) # tuple

聚合迭代器

创建⼀个聚合了来⾃每个可迭代对象中的元素的迭代器：
```
x=[3,2,1]
y=[4,5,6]
list(zip(y,x)) # [(4, 3), (5, 2), (6, 1)]
```

nonlocal用于内嵌函数中

关键词 nonlocal常⽤于函数嵌套中，声明变量 i 为⾮局部变量；如果不声明， i+=1表明 i 为函数wrapper内的局部变量，因为在 i+=1引⽤(reference)时,i未被声明，所以会报 unreferenced variable的错误。

def excepter(f):
    i = 0
    t1 = time.time()
    def wrapper():
        try:
            f()
        except Exception as e:
            nonlocal i
            i += 1
            print(f'{e.args[0]}: {i}')
            t2 = time.time()
            if i == n:
                print(f'spending time:{round(t2-t1,2)}')
    return wrapper

global声明全局变量

先回答为什么要有 global，⼀个变量被多个函数引⽤，想让全局变量被所有函数共享。有的伙伴可能会想这还不简单，这样写：
```
i = 5
def f():
    print(i)
def g():
    print(i)
    pass
f()
g()
'''
5
5
'''
```
f和g两个函数都能共享变量 i ，程序没有报错，所以他们依然不明⽩为什么要⽤ global.但是，如果我想要有个函数对 i 递增，这样：
```
def h():
    i += 1
h()
'''
---------------------------------------------------------------------------
UnboundLocalError                         Traceback (most recent call last)
<ipython-input-28-bafe41838c9e> in <module>
      1 def h():
      2     i += 1
----> 3 h()

<ipython-input-28-bafe41838c9e> in h()
      1 def h():
----> 2     i += 1
      3 h()

UnboundLocalError: local variable 'i' referenced before assignment
'''
```
此时执⾏程序，bang, 出错了！抛出异常： UnboundLocalError，原来编译器在解释 i+=1时会把 i解析为函数 h()内的局部变量，很显然在此函数内，编译器找不到对变量 i 的定义，所以会报错。global就是为解决此问题⽽被提出，在函数h内，显⽰地告诉编译器 i 为全局变量，然后编译器会在函数外⾯寻找 i 的定义，执⾏完 i+=1后， i 还为全局变量，值加1：
```
i = 0
def h():
    global i
    i += 1
h()
print(i) # 1
```

链式比较

i=3
print(1<i<3)
print(1<i<=3)
'''
False
True
'''

不用else和if实现计算器

from operator import *
def calculator(a, b, k):
    return {
    '+': add,
    '-': sub,
    '*': mul,
    '/': truediv,
    '**': pow
    }[k](a, b)

calculator(3, 4, '**') # 81

calculator(1, 2, '+') # 3

链式操作

from operator import (add, sub)
def add_or_sub(a, b, oper):
    return (add if oper == '+' else sub)(a, b)
add_or_sub(1, 2, '-') # -1

交换两元素

def swap(a, b):
    return b, a
print(swap(1, 0)) # (0,1)

去最求平均

def score_mean(lst):
    lst.sort()
    lst2=lst[1:(len(lst)-1)]
    return round((sum(lst2)/len(lst2)),1)
lst=[9.1, 9.0,8.1, 9.7, 19,8.2, 8.6,9.8]
score_mean(lst) # 9.1

打印九九乘法表

for i in range(1,10):
    for j in range(1,i+1):
        print("%d*%d=%d"%(j,i,j*i),end='\t')
    print()

python实战打卡---day3

“相关推荐”对你有帮助么？