python笔记

最新推荐文章于 2024-02-10 17:11:54 发布

yangyangyangr

最新推荐文章于 2024-02-10 17:11:54 发布

阅读量533

点赞数

分类专栏： python

本文链接：https://blog.csdn.net/weixin_38698995/article/details/107094361

版权

python 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

python笔记

1.魔法方法

1.1 getattr (self, item):

在访问对象的item属性的时候，如果对象并没有这个相应的属性，方法，那么将会调用这个方法来处理。。。这里要注意的时，假如一个对象叫fjs, 他有一个属性：fjs.name = “fjs”，那么在访问fjs.name的时候因为当前对象有这个属性，那么将不会调用__getattr__()方法，而是直接返回了拥有的name属性了

class F():
ee=323
def __getitem__(self, index):
    print('index=',index)
    return index+1
def __init__(self,*r):
    self.w=r[0]
    print(r)

def __getattr__(self, item):
    print(type(item),'type')
    return item + ' is not exits'

a=F(4,‘d’)

print(a[2])

print(a.name)

输出结果：

(4, 'd')
index= 2
3
<class 'str'> type
name is not exits

总结：

(1) a.name会调用_gettattr_函数，name被转换为str类型（实验结论）

(2)function(*r)中的r，如果传入的为function（4，‘s’）,则r=（4，‘s’）,元组类型
#####1.2 __getitem__ (self, index):
用法如上，a[2]时候调用此函数，index=2

#####1.3 __call__ 方法
我们平时自定义的函数、内置函数和类都属于可调用对象，但凡是可以把一对括号()应用到某个对象身上都可称之为可调用对象，判断对象是否为可调用对象可以用函数 callable

class Entity:
'''调用实体来改变实体的位置。'''

def __init__(self, size, x, y):
    self.x, self.y = x, y
    self.size = size

def __call__(self, x, y):
    '''改变实体的位置'''
    self.x, self.y = x, y

e = Entity(1, 2, 3) // 创建实例
e(4, 5) //实例可以象函数那样执行，并传入x y值，修改对象的x y

#####1.5__repr__()
当我们输出某个实例化对象时，其调用的就是该对象的 repr() 方法，输出的是该方法的返回值

2.基础语法

2.1下划线

1.变量单下划线开头

标明是一个受保护(protected)的变量，原则上不允许直接访问，但外部类还是可以访问到这个变量。这只是程序员之间的一个约定，用于警告说明这是一个私有变量，外部类不要去访问它。

2.多下划线开头

私有类型(private)的变量。只能是允许这个类本身进行访问了, 连子类也不可以,用于命名一个类属性（类变量），调用时名字被改变（在类Student内部，__name变成_Student__name,如 self._Student__name)
双下划线开头的实例变量是不是一定不能从外部访问呢？其实也不是。仍然可以通过_Student__name来访问__name变量

3.多下划线开头结尾：是内置变量，内置变量是可以直接访问.如__init__，__import__或是__file__

python名称改编特性会将双下划綫开头的名称（以__var为例）改为"_classname__var"，以实现私有特性

2.2yield

2.3有关self

class a:
    list1 = [1, 2, 3]
    a1=9
    def ca(self):
        return self.list1
aa=a()
print(aa.ca())

也可return a.list1;
如果return list1，则会报错

2.4 列表中…三个点

作用：省略所有的冒号来用省略号代替,大家看这个a[:, :, None]和a[…, None]的输出是一样的

2.5

x=np.array([[3,4],[2,5]])
print(x[:,1]>1)

输出：[ True True]

进一步：

print(x[x[:,1]>1])

输出：（[[2,5]])

!!注意

x=np.array([[3,1],[2,5]])
print(type([False ,True]))
print(type(x[:,1]>1))
print(x[(x[:,1]>1)])
print(x[False,True])

输出：

<class 'list'>
<class 'numpy.ndarray'>
[[2 5]]
[]

2.6 列表中的extend()

extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

a=[3,4]
b=[7]
a.extend(b)
print(a)

输出：[3，4，7]

2.7 字典

注意：字典是无序的；如果要使用有序dict，必须用OrderedDict详细链接。字典的value可以是任何对象，如类、函数。

import collections
 
dic = collections.OrderedDict()

3.装饰器

3.1 函数特性

Python中的函数特性总的来说有四点:

1.函数作为变量传递

def add(x):
    return x + 1
 
a = add

2.函数作为参数传递

def add(x):
    return x + 1
 
def excute(f):
    return f(3)
 
excute(add)

3.函数作为返回值

def add(x):
    return x + 1
 
def get_add():
    return add

4.函数嵌套及跨域访问

def outer():
    x = 1
    def inner():
        print(x)        
    inner()
 
outer()

3.2.闭包的实现

(1)Python中的装饰器是通过闭包实现的，简单地讲，闭包就是引用了外部变量的内部函数，而闭包的实现正是利用了以上函数特性，

def outer(x):
    def inner():                  # 函数嵌套
        return x                  # 跨域访问，引用了外部变量x
 
  	 return inner                  # 函数作为返回值
 
closure = outer('外部变量')        # 函数作为变量赋给closure
print(closure())                  # 执行闭包

结果:

外部变量

(2)
从func()到closure(),函数func就是被装饰了一番变成了clousre:

def func():
    return '函数func'
 
def outer(x):
    def inner():                              # 函数嵌套
        return '戴了inner牌帽子的 ' + x()       # 跨域访问，引用了外部变量x
 
    return inner                              # 函数作为返回值
 
closure = outer(func)                         # 函数func作为outer的参数；函数作为变量赋给closure
 
print(func())                                 # 执行原始函数
print(closure())

(3)装饰器语法糖@

Python给我们提供了语法糖 @，我们想执行 outer(func) 的时候，只需要把outer函数@到func函数的上面就可以了。

def outer(x):
    def inner():
        return '戴了inner牌帽子的 ' + x()
 
    return inner
 
@outer
def func():
    return '函数func'
 
print(func())

结果:

戴了inner牌帽子的函数fun

3.3常见–@property

class Student(object):

    def get_score(self):
        return self._score

    def set_score(self, value):
        if not isinstance(value, int):
            raise ValueError('score must be an integer!')
        if value < 0 or value > 100:
            raise ValueError('score must between 0 ~ 100!')
        self._score = value

如果我们不想写s.set_score(9999),直接写s.score = 9999，需要加上@property

class Student(object):

    @property
    def score(self):
        return self._score

    @score.setter
    def score(self,value):
        if not isinstance(value, int):
            raise ValueError('分数必须是整数才行呐')
        if value < 0 or value > 100:
            raise ValueError('分数必须0-100之间')
        self._score = value

4.生成器与迭代器

我们把可以通过for…in…这类语句迭代读取数据供我们使用的对象称之为可迭代对象。

4.1__iter()__函数
__iter()__返回迭代器，（通过iter()函数就是调用了__iter()__方法），具备了__iter()__方法的对象就是可迭代对象。
可以对获取的迭代器不断的使用next()函数来获取下一条数据。

在Python中，这种一边循环一边计算的机制，称为生成器：generator
生成器是一个特殊的程序，可以被用作控制循环的迭代行为，python中生成器是迭代器的一种，使用yield返回值函数，每次调用yield会暂
停，而可以使用next()函数和send()函数恢复生成器。

生成器就是迭代器

生成器的特点和迭代器一样.

1.省内存

2.惰性机制

3.只能向前
4.2

要创建一个generator，有很多种方法，第一种方法很简单，只有把一个列表生成式的[]中括号改为（）小括号，就创建一个generator

举例如下：

#列表生成式
lis = [x*x for x in range(10)]
print(lis)
#生成器
generator_ex = (x*x for x in range(10))
print(generator_ex)

结果：

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
<generator object <genexpr> at 0x000002A4CBF9EBA0>

那么创建list和generator_ex，的区别是什么呢？从表面看就是[ ]和（）,但是结果却不一样，一个打印出来是列表（因为是列表生成式），而第二个打印出来却是<generator object at 0x000002A4CBF9EBA0>，打印generator_ex的每一个元素可以通过next（）函数获得generator的下一个返回值。

4.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'
g = fib(6)
while True:
    try:
        x = next(g)
        print('generator: ',x)
    except StopIteration as e:
        print("生成器返回值：",e.value)
        break

结果：

generator:  1
generator:  1
generator:  2
generator:  3
generator:  5
generator:  8
生成器返回值： done

4.4
中括号生成列表，小括号生成迭代器

aa=(i for i in range(3))
print(aa)
print(type(aa))

输出：

aa=[i for i in range(3)]
print(aa)

输出：
[0,1,2]
4.5for循环的实质

iterator = dict01.__iter__()
while True:
    try:
        # 2.使用迭代器取所有的下一个元素并显示
        item = iterator.__next__()
        # print(item)
        print(item+":",dict01[item])
    # 3.遇到异常停止迭代
    except StopIteration:
        break```
 

-- 

**总结**: 

推导式有：列表推导式, 字典推导式, 集合推导式, 没有元组推导式 

**生成器表达式: (结果 for 变量 in 可迭代对象 if 条件筛选)**   

**生成器表达式可以直接获取到生成器对象. 生成器对象可以直接进行for循环. 生成器具有惰性机制****
**
所有由用户创建的类其实都是type类的实例对象。如：`class FF():...
print(type(FF))`#则FF的类型为`<class 'type'>`
**
## **5.其他注意的**
####5.1**父类可以调用子类方法、变量**
父类也可以查看所有子类。如下：
```python
class A(object):
    def f(self):
        print(self.p)
    def __call__(self, *args, **kwargs):
        print('this is call')
        print(self.p)
        for sc in A.__subclasses__():#查看所有子类
            print(sc.__name__)
            sc.bb(sc)
 
class B(A):
    p = 'This is in B'
    def bb(self):
        print('this is bb')
    

a=B()
a(10))```
输出：

	this is call
	This is in B
	this is bb
##6字符串
####6.1[字符串前加u、r、b、f](https://www.cnblogs.com/walo/p/10608436.html)

字符串前加 r
例：r"\n\n\n\n”　　# 表示一个普通生字符串 \n\n\n\n，而不表示换行了。

作用：
去掉反斜杠的转移机制。```
###.python内存管理