Python基础入门：从函数到高级魔法方法（第7天）--阿里云天池

最新推荐文章于 2024-08-21 00:07:22 发布
最新推荐文章于 2024-08-21 00:07:22 发布
阅读量230 收藏
点赞数
分类专栏： 阿里云天池Python训练营 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/haowei1999/article/details/119514203
版权

13 函数与Lambda表达式

13.1 函数

还记得 Python 里面“万物皆对象”么？Python 把函数也当成对象，可以从另一个函数中返回出来而去构建高阶函数，比如：

  1. 参数是函数

  2. 返回值是函数

13.1.1 函数的定义
  1. 函数以 def 关键词开头，后接函数名和圆括号()。
  2. 函数执行的代码以冒号起始，并且缩进。
  3. return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None 。
def functionname(parameters):
"函数_文档字符串"
function_suite
return [expression]
13.1.2 函数的调用

【例子】

def printme(str):
print(str)
printme("我要调用用户自定义函数!") # 我要调用用户自定义函数!
printme("再次调用同一函数") # 再次调用同一函数
temp = printme('hello') # hello
print(temp) # None

【例子】

def add(a, b):
print(a + b)
add(1, 2) # 3
add([1, 2, 3], [4, 5, 6]) # [1, 2, 3, 4, 5, 6]
1 2 3 4 5 6
13.1.3 函数文档
def MyFirstFunction(name):
"函数定义过程中name是形参"
# 因为Ta只是一个形式，表示占据一个参数位置
print('传递进来的{0}叫做实参，因为Ta是具体的参数值！'.format(name))
MyFirstFunction('老马的程序人生')
# 传递进来的老马的程序人生叫做实参，因为Ta是具体的参数值！
print(MyFirstFunction.__doc__)
# 函数定义过程中name是形参
help(MyFirstFunction)
# Help on function MyFirstFunction in module __main__:
# MyFirstFunction(name)
# 函数定义过程中name是形参
13.1.4 函数参数

Python 的函数具有非常灵活多样的参数形态，既可以实现简单的调用，又可以传入非常复杂的参数。从简到繁的参数形态
如下：

  1. 位置参数 (positional argument)
  2. 默认参数 (default argument)
  3. 可变参数 (variable argument)
  4. 关键字参数 (keyword argument)
  5. 命名关键字参数 (name keyword argument)
  6. 参数组合
1. 位置参数
# arg1 - 位置参数 ，这些参数在调用函数 (call function) 时位置要固定。
def functionname(arg1):
"函数_文档字符串"
function_suite
return [expression]
2.默认参数
#1.arg2 = v - 默认参数 = 默认值，调用函数时，默认参数的值如果没有传入，则被认为是默认值。
#2.默认参数一定要放在位置参数后面，不然程序会报错。
*/
def functionname(arg1, arg2=v):
"函数_文档字符串"
function_suite
return [expression]

def printinfo(name, age=8):
print('Name:{0},Age:{1}'.format(name, age))
printinfo('小马') # Name:小马,Age:8
printinfo('小马', 10) # Name:小马,Age:10

#3.Python 允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
def printinfo(name, age):
print('Name:{0},Age:{1}'.format(name, age))
printinfo(age=8, name='小马') # Name:小马,Age:8
3.可变参数

顾名思义，可变参数就是传入的参数个数是可变的，可以是 0, 1, 2 到任意个，是不定长的参数。

def functionname(arg1, arg2=v, *args):
"函数_文档字符串"
function_suite
return [expression]

#1. *args - 可变参数，可以是从零个到任意个，自动组装成元组。
#2. 加了星号（*）的变量名会存放所有未命名的变量参数。
def printinfo(arg1, *args):
print(arg1)
for var in args:
print(var)
printinfo(10) # 10
printinfo(70, 60, 50)
# 70
# 60
# 50
4.关键字参数
def functionname(arg1, arg2=v, *args, **kw):
"函数_文档字符串"
function_suite
return [expression]

#1. **kw - 关键字参数，可以是从零个到任意个，自动组装成字典。
def printinfo(arg1, *args, **kwargs):
print(arg1)
print(args)
print(kwargs)
printinfo(70, 60, 50)
# 70
# (60, 50)
# {}
printinfo(70, 60, 50, a=1, b=2)
# 70
# (60, 50)
# {'a': 1, 'b': 2}

「可变参数」和「关键字参数」的同异总结如下：

  1. 可变参数允许传入零个到任意个参数，它们在函数调用时自动组装为一个元组 (tuple)。
  2. 关键字参数允许传入零个到任意个参数，它们在函数内部自动组装为一个字典 (dict)。
5.命名关键字参数
def functionname(arg1, arg2=v, *args, *, nkw, **kw):
"函数_文档字符串"
function_suite
return [expression]
  1. *, nkw - 命名关键字参数，用户想要输入的关键字参数，定义方式是在nkw 前面加个分隔符 *。
  2. 如果要限制关键字参数的名字，就可以用「命名关键字参数」
  3. 使用命名关键字参数时，要特别注意不能缺少参数名。
def printinfo(arg1, *, nkw, **kwargs):
print(arg1)
print(nkw)
print(kwargs)
printinfo(70, nkw=10, a=1, b=2)
# 70
# 10
# {'a': 1, 'b': 2}
#没有写参数名 nwk ，因此 10 被当成「位置参数」，而原函数只有 1 个位置函数，现在调用了 2 个，因此程序会报错。
printinfo(70, 10, a=1, b=2)
# TypeError: printinfo() takes 1 positional argument but 2 were given
6. 参数组合

在 Python 中定义函数，可以用位置参数、默认参数、可变参数、命名关键字参数和关键字参数，这 5 种参数中的 4 个都可以一起使用，但是注意，参数定义的顺序必须是：

  1. 位置参数、默认参数、可变参数和关键字参数。

  2. 位置参数、默认参数、命名关键字参数和关键字参数。

要注意定义可变参数和关键字参数的语法：

  1. *args 是可变参数， args 接收的是一个 tuple
  2. kw 是关键字参数， kw 接收的是一个 dict

命名关键字参数是为了限制调用者可以传入的参数名，同时可以提供默认值。定义命名关键字参数不要忘了写分隔符*，否则定义的是位置参数。

警告：虽然可以组合多达 5 种参数，但不要同时使用太多的组合，否则函数很难懂。

13.1.5 函数的返回值

【例子】

def add(a, b):
return a + b
print(add(1, 2)) # 3
print(add([1, 2, 3], [4, 5, 6])) # [1, 2, 3, 4, 5, 6]

【例子】

def back():
return [1, '小马的程序人生', 3.14]
print(back()) # [1, '小马的程序人生', 3.14]

【例子】

def back():
return 1, '小马的程序人生', 3.14
print(back()) # (1, '小马的程序人生', 3.14)

【例子】

def printme(str):
print(str)
temp = printme('hello') # hello
print(temp) # None
print(type(temp)) # <class 'NoneType'>
13.1.6 变量作用域
  1. Python 中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的。
  2. 定义在函数内部的变量拥有局部作用域，该变量称为局部变量。
  3. 定义在函数外部的变量拥有全局作用域，该变量称为全局变量。
  4. 局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。 \
global 和 nonlocal
  1. 当内部作用域想修改外部作用域的变量时，就要用到 global 和 nonlocal 关键字了。
num = 1
def fun1():
global num # 需要使用 global 关键字声明
print(num) # 1
num = 123
print(num) # 123
fun1()
print(num) # 123
内嵌函数
def outer():
print('outer函数在这被调用')
def inner():
print('inner函数在这被调用')
inner() # 该函数只能在outer函数内部被调用
outer()
# outer函数在这被调用
# inner函数在这被调用
闭包

  1. 是函数式编程的一个重要的语法结构，是一种特殊的内嵌函数。

  2. 如果在一个内部函数里对外层非全局作用域的变量进行引用，那么内部函数就被认为是闭包。

  3. 通过闭包可以访问外层非全局作用域的变量，这个作用域称为 闭包作用域。

def funX(x):
	def funY(y):
		return x * y
	return funY
i = funX(8)
print(type(i)) # <class 'function'>
print(i(5)) # 40

#闭包的返回值通常是函数
def make_counter(init):
	counter = [init]
	def inc(): counter[0] += 1
	def dec(): counter[0] -= 1
	def get(): return counter[0]
	def reset(): counter[0] = init
	return inc, dec, get, reset
inc, dec, get, reset = make_counter(0)
inc()
inc()
inc()
print(get()) # 3
dec()
print(get()) # 2
reset()
print(get()) # 0

如果要修改闭包作用域中的变量则需要 nonlocal 关键字

def outer():
	num = 10
	def inner():
		nonlocal num # nonlocal关键字声明
		num = 100
		print(num)
	inner()
	print(num)
outer()
# 100
# 100
递归
  1. 如果一个函数在内部调用自身本身，这个函数就是递归函数。

【例子】 n! = 1 x 2 x 3 x …x n

#++循环++
n = 5
for k in range(1, 5):
	n = n * k
print(n) # 120

#++递归++
def factorial(n):
	if n == 1:
		return 1
	return n * fact(n - 1)

print(factorial(5)) # 120

【例子】斐波那契数列 f(n)=f(n-1)+f(n-2), f(0)=0 f(1)=1

#++循环++
i = 0
j = 1
lst = list([i, j])
for k in range(2, 11):
k = i + j
lst.append(k)
i = j
j = k
print(lst)
# [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

#++递归++
def recur_fibo(n):
if n <= 1:
return n
return recur_fibo(n - 1) + recur_fibo(n - 2)
lst = list()
for k in range(11):
lst.append(recur_fibo(k))
print(lst)
# [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

【例子】设置递归的层数，Python默认递归层数为 100

import sys
sys.setrecursionlimit(1000)

13.2 Lambda 表达式

13.2.1 匿名函数的定义

在 Python 里有两类函数：

  1. 第一类：用 def 关键词定义的正规函数
  2. 第二类：用 lambda 关键词定义的匿名函数

python 使用 lambda 关键词来创建匿名函数，而非 def 关键词，它没有函数名，其语法结构如下：

lambda argument_list: expression
  1. lambda - 定义匿名函数的关键词。
  2. argument_list - 函数参数，它们可以是位置参数、默认参数、关键字参数，和正规函数里的参数类型一样。
  3. : - 冒号，在函数参数和表达式中间要加个冒号。
  4. expression - 只是一个表达式，输入函数参数，输出一些值。

注意：

  1. expression 中没有 return 语句，因为 lambda 不需要它来返回，表达式本身结果就是返回值。

匿名函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。

def sqr(x):
	return x ** 2
print(sqr)
# <function sqr at 0x000000BABD3A4400>

y = [sqr(x) for x in range(10)]
print(y)
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

lbd_sqr = lambda x: x ** 2
print(lbd_sqr)
# <function <lambda> at 0x000000BABB6AC1E0>

y = [lbd_sqr(x) for x in range(10)]
print(y)
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

sumary = lambda arg1, arg2: arg1 + arg2
print(sumary(10, 20)) # 30

func = lambda *args: sum(args)
print(func(1, 2, 3, 4, 5)) # 15
13.2.2 匿名函数的应用

函数式编程 是指代码中每一块都是不可变的，都由纯函数的形式组成。这里的纯函数，是指函数本身相互独立、互不影响，对于相同的输入，总会有相同的输出，没有任何副作用。

【例子】非函数式编程
def f(x):
	for i in range(0, len(x)):
		x[i] += 10
	return x
	
x = [1, 2, 3]
f(x)
print(x)
# [11, 12, 13]
【例子】函数式编程
def f(x):
	y = []
	for item in x:
		y.append(item + 10)
	return y
	
x = [1, 2, 3]
f(x)
print(x)
# [1, 2, 3]

匿名函数 常常应用于函数式编程的高阶函数 (high-order function)中，主要有两种形式：

  1. 参数是函数 (filter, map)
  2. 返回值是函数 (closure)

​ 如，在 filter 和 map 函数中的应用:

filter(function, iterable)
  1. filter(function, iterable) 过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。

【例子】

odd = lambda x: x % 2 == 1
templist = filter(odd, [1, 2, 3, 4, 5, 6, 7, 8, 9])
print(list(templist)) # [1, 3, 5, 7, 9]
map(function, *iterables)

2.map(function, *iterables) 根据提供的函数对指定序列做映射。

m1 = map(lambda x: x ** 2, [1, 2, 3, 4, 5])
print(list(m1))
# [1, 4, 9, 16, 25]
m2 = map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
print(list(m2))
# [3, 7, 11, 15, 19]

除了 Python 这些内置函数，我们也可以自己定义高阶函数。

def apply_to_list(fun, some_list):
	return fun(some_list)

lst = [1, 2, 3, 4, 5]
print(apply_to_list(sum, lst))
# 15

print(apply_to_list(len, lst))
# 5

print(apply_to_list(lambda x: sum(x) / len(x), lst))
# 3.0

14 类与对象

14.1 对象 = 属性 + 方法

对象是类的实例。换句话说，类主要定义对象的结构，然后我们以类为模板创建对象。类不但包含方法定义，而且还包含所有实例共享的数据。

1.封装：信息隐蔽技术

我们可以使用关键字 class 定义 Python 类，关键字后面紧跟类的名称、分号和类的实现。

class Turtle: # Python中的类名约定以大写字母开头
	"""关于类的一个简单例子"""
	# 属性
	color = 'green'
	weight = 10
	legs = 4
	shell = True
	mouth = '大嘴'
    
	# 方法
	def climb(self):
		print('我正在很努力的向前爬...')
        
	def run(self):
		print('我正在飞快的向前跑...')

    def bite(self):
		print('咬死你咬死你!!')

    def eat(self):
		print('有得吃，真满足...')

	def sleep(self):
		print('困了，睡了，晚安，zzz')
        
tt = Turtle()
print(tt)
# <__main__.Turtle object at 0x0000007C32D67F98>

print(type(tt))
# <class '__main__.Turtle'>

print(tt.__class__)
# <class '__main__.Turtle'>

print(tt.__class__.__name__)
# Turtle

tt.climb()
# 我正在很努力的向前爬...

tt.run()
# 我正在飞快的向前跑...

tt.bite()
# 咬死你咬死你!!

# Python类也是对象。它们是type的实例
print(type(Turtle))
# <class 'type'>
2.继承：子类自动共享父类之间数据和方法的机制
class MyList(list):
	pass

lst = MyList([1, 5, 2, 7, 8])
lst.append(9)
lst.sort()
print(lst)

# [1, 2, 5, 7, 8, 9]
3.多态：不同对象对同一方法响应不同的行动
class Animal:
	def run(self):
        raise AttributeError('子类必须实现这个方法')

class People(Animal):
	def run(self):
		print('人正在走')

class Pig(Animal):
	def run(self):
		print('pig is walking')
        
class Dog(Animal):
	def run(self):
		print('dog is running')

def func(animal):
	animal.run()
func(Pig())
# pig is walking

14.2 self 是什么？

Python 的 self 相当于 C++ 的 this 指针。

【例子】

class Test:
	def prt(self):
		print(self)
		print(self.__class__)

t = Test()
t.prt()
# <__main__.Test object at 0x000000BC5A351208>
# <class '__main__.Test'>

​ 类的方法与普通的函数只有一个特别的区别 —— 它们必须有一个额外的第一个参数名称（对应于该实例，即该对象本身），按照惯例它的名称是 self 。在调用方法时，我们无需明确提供与参数 self 相对应的参数。

【例子】

class Ball:
	def setName(self, name):
		self.name = name

	def kick(self):
		print("我叫%s,该死的，谁踢我..." % self.name)

a = Ball()
a.setName("球A")
b = Ball()
b.setName("球B")
c = Ball()
c.setName("球C")
a.kick()
# 我叫球A,该死的，谁踢我...
b.kick()
# 我叫球B,该死的，谁踢我...

14.3 Python 的魔法方法

据说，Python 的对象天生拥有一些神奇的方法，它们是面向对象的 Python 的一切…
它们是可以给你的类增加魔力的特殊方法…
如果你的对象实现了这些方法中的某一个，那么这个方法就会在特殊的情况下被 Python 所调用，而这一切都是自动发生的…
类有一个名为 init(self[, param1, param2…]) 的魔法方法，该方法在类实例化时会自动调用。

【例子】

class Ball:
	def __init__(self, name):
		self.name = name
	def kick(self):
		print("我叫%s,该死的，谁踢我..." % self.name)

a = Ball("球A")
b = Ball("球B")
c = Ball("球C")
a.kick()
# 我叫球A,该死的，谁踢我...
b.kick()
# 我叫球B,该死的，谁踢我...

14.4 公有和私有

在 Python 中定义私有变量只需要在变量名或函数名前加上“__”两个下划线，那么这个函数或变量就会为私有的了。

【例子】类的私有属性实例

class JustCounter:
	__secretCount = 0 # 私有变量
	publicCount = 0 # 公开变量

	def count(self):
		self.__secretCount += 1
		self.publicCount += 1
		print(self.__secretCount)

counter = JustCounter()
counter.count() # 1
counter.count() # 2
print(counter.publicCount) # 2

print(counter._JustCounter__secretCount) # 2 Python的私有为伪私有
print(counter.__secretCount)
# AttributeError: 'JustCounter' object has no attribute '__secretCount'

【例子】类的私有方法实例

class Site:
	def __init__(self, name, url):
		self.name = name # public
		self.__url = url # private

	def who(self):
		print('name : ', self.name)
		print('url : ', self.__url)

	def __foo(self): # 私有方法
		print('这是私有方法')
	
	def foo(self): # 公共方法
		print('这是公共方法')
		self.__foo()

x = Site('老马的程序人生', 'https://blog.csdn.net/LSGO_MYP')
x.who()
# name : 老马的程序人生
# url : https://blog.csdn.net/LSGO_MYP

x.foo()
# 这是公共方法
# 这是私有方法

x.__foo()
# AttributeError: 'Site' object has no attribute '__foo'

14.5 继承

Python 同样支持类的继承，派生类的定义如下所示：

class DerivedClassName(BaseClassName):
	<statement-1>
	.
	.
	.
	<statement-N>

BaseClassName （示例中的基类名）必须与派生类定义在一个作用域内。除了类，还可以用表达式，基类定义在另一个模块中时这一点非常有用：

class DerivedClassName(modname.BaseClassName):
	<statement-1>
	.
	.
	.
	<statement-N>

【例子】如果子类中定义与父类同名的方法或属性，则会自动覆盖父类对应的方法或属性。

# 类定义
class people:
	# 定义基本属性
	name = ''
	age = 0
	# 定义私有属性,私有属性在类外部无法直接进行访问
	__weight = 0
	
	# 定义构造方法
	def __init__(self, n, a, w):
		self.name = n
		self.age = a
		self.__weight = w

	def speak(self):
		print("%s 说: 我 %d 岁。" % (self.name, self.age))


# 单继承示例
class student(people):
	grade = ''

	def __init__(self, n, a, w, g):
		# 调用父类的构函
		people.__init__(self, n, a, w)
		self.grade = g

	# 覆写父类的方法
	def speak(self):
		print("%s 说: 我 %d 岁了，我在读 %d 年级" % (self.name, self.age, self.grade))
		
s = student('小马的程序人生', 10, 60, 3)
s.speak()
# 小马的程序人生 说: 我 10 岁了，我在读 3 年级

注意：如果上面的程序去掉： people.init(self, n, a, w) ，则输出： 说: 我 0 岁了，我在读 3 年级 ，因为子类的构造方法把父类的构造方法覆盖了。

【例子】

class Fish:
	def __init__(self):
		self.x = r.randint(0, 10)
		self.y = r.randint(0, 10)

    def move(self):
		self.x -= 1
		print("我的位置", self.x, self.y)

class GoldFish(Fish): # 金鱼
	pass

class Carp(Fish): # 鲤鱼
	pass

class Salmon(Fish): # 三文鱼
	pass

class Shark(Fish): # 鲨鱼
	def __init__(self):
		self.hungry = True

    def eat(self):
		if self.hungry:
			print("吃货的梦想就是天天有得吃！")
			self.hungry = False
		else:
			print("太撑了，吃不下了！")
			self.hungry = True

g = GoldFish()
g.move() # 我的位置 9 4
s = Shark()
s.eat() # 吃货的梦想就是天天有得吃！
s.move()
# AttributeError: 'Shark' object has no attribute 'x'

解决该问题可用以下两种方式：

  1. 调用未绑定的父类方法 Fish._init_(self)

class Shark(Fish): # 鲨鱼
	def __init__(self):
        Fish.__init__(self)
		self.hungry = True

    def eat(self):
		if self.hungry:
			print("吃货的梦想就是天天有得吃！")
			self.hungry = False
		else:
			print("太撑了，吃不下了！")
			self.hungry = True

2.使用super函数 super().init()

class Shark(Fish): # 鲨鱼
	def __init__(self):
        super().__init__()
		self.hungry = True

    def eat(self):
		if self.hungry:
			print("吃货的梦想就是天天有得吃！")
			self.hungry = False
		else:
			print("太撑了，吃不下了！")
			self.hungry = True
多继承

Python 虽然支持多继承的形式，但我们一般不使用多继承，因为容易引起混乱。

class DerivedClassName(Base1, Base2, Base3):
	<statement-1>
	.
	.
	.
	<statement-N>

需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，Python 从左至右搜索，即方法在子类中未找到时，从左到右查找父类中是否包含方法。

# 类定义
class People:
	# 定义基本属性
	name = ''
	age = 0
	# 定义私有属性,私有属性在类外部无法直接进行访问
    
    __weight = 0

    # 定义构造方法
	def __init__(self, n, a, w):
		self.name = n
		self.age = a
		self.__weight = w

    def speak(self):
		print("%s 说: 我 %d 岁。" % (self.name, self.age))

# 单继承示例
class Student(People):
	grade = ''

    def __init__(self, n, a, w, g):
		# 调用父类的构函
		People.__init__(self, n, a, w)
		self.grade = g

# 覆写父类的方法
	def speak(self):
		print("%s 说: 我 %d 岁了，我在读 %d 年级" % (self.name, self.age, self.grade))

# 另一个类，多重继承之前的准备
class Speaker:
	topic = ''
	name = ''

    def __init__(self, n, t):
		self.name = n
		self.topic = t

        def speak(self):
			print("我叫 %s，我是一个演说家，我演讲的主题是 %s" % (self.name, self.topic))

# 多重继承
class Sample01(Speaker, Student):
	a = ''
    
	def __init__(self, n, a, w, g, t):
		Student.__init__(self, n, a, w, g)
        Speaker.__init__(self, n, t)

        
test = Sample01("Tim", 25, 80, 4, "Python")
test.speak() # 方法名同，默认调用的是在括号中排前地父类的方法

# 我叫 Tim，我是一个演说家，我演讲的主题是 Python

class Sample02(Student, Speaker):
	a = ''
	def __init__(self, n, a, w, g, t):
		Student.__init__(self, n, a, w, g)
		Speaker.__init__(self, n, t)

test = Sample02("Tim", 25, 80, 4, "Python")
test.speak() # 方法名同，默认调用的是在括号中排前地父类的方法

# Tim 说: 我 25 岁了，我在读 4 年级

14.6 组合

【例子】

class Turtle:
	def __init__(self, x):
		self.num = x

class Fish:
	def __init__(self, x):
		self.num = x

class Pool:
	def __init__(self, x, y):
		self.turtle = Turtle(x)
        self.fish = Fish(y)
        def print_num(self):
		print("水池里面有乌龟%s只，小鱼%s条" % (self.turtle.num, self.fish.num))

p = Pool(2, 3)
p.print_num()
# 水池里面有乌龟2只，小鱼3条

14.7 类、类对象和实例对象

在这里插入图片描述

类对象

类对象：创建一个类，其实也是一个对象也在内存开辟了一块空间，称为类对象，类对象只有一个。

# 类对象
class A(object):
	pass
实例对象

实例对象：就是通过实例化类创建的对象，称为实例对象，实例对象可以有多个。

# 实例化对象 a、b、c都属于实例对象。
a = A()
b = A()
c = A()
类属性

类属性：类里面方法外面定义的变量称为类属性。类属性所属于类对象并且多个实例对象之间共享同一个类属性，说白了就是类属性所有的通过该类实例化的对象都能共享。

class A():
	a = xx #类属性
	def __init__(self):
		A.a = xx #使用类属性可以通过 （类名.类属性）调用。
实例属性

实例属性：实例属性和具体的某个实例对象有关系，并且一个实例对象和另外一个实例对象是不共享属性的，说白了实例属性只能在自己的对象里面使用，其他的对象不能直接使用，因为 self 是谁调用，它的值就属于该对象。

class 类名():
	__init__(self)：
		self.name = xx #实例属性
类属性和实例属性区别
  1. 类属性：类外面，可以通过 实例对象.类属性 和 类名.类属性 进行调用。类里面，通过 self.类属性
    和 类名.类属性 进行调用。
  2. 实例属性 ：类外面，可以通过 实例对象.实例属性 调用。类里面，通过 self.实例属性 调用。
  3. 实例属性就相当于局部变量。出了这个类或者这个类的实例对象，就没有作用了。
  4. 类属性就相当于类里面的全局变量，可以和这个类的所有实例对象共享。
# 创建类对象
class Test(object):
	class_attr = 100 # 类属性

    def __init__(self):
		self.sl_attr = 100 # 实例属性

    def func(self):
		print('类对象.类属性的值:', Test.class_attr) # 调用类属性
		print('self.类属性的值', self.class_attr) # 相当于把类属性 变成实例属性
		print('self.实例属性的值', self.sl_attr) # 调用实例属性

a = Test()
a.func()
# 类对象.类属性的值: 100
# self.类属性的值 100
# self.实例属性的值 100

b = Test()
b.func()
# 类对象.类属性的值: 100
# self.类属性的值 100
# self.实例属性的值 100

a.class_attr = 200
a.sl_attr = 200
a.func()
# 类对象.类属性的值: 100
# self.类属性的值 200
# self.实例属性的值 200

b.func()
# 类对象.类属性的值: 100
# self.类属性的值 100
# self.实例属性的值 100

Test.class_attr = 300

a.func()
# 类对象.类属性的值: 300
# self.类属性的值 200
# self.实例属性的值 200

b.func()
# 类对象.类属性的值: 300
# self.类属性的值 300
# self.实例属性的值 100

注意：属性与方法名相同，属性会覆盖方法。

【例子】

class A:
	def x(self):
		print('x_man')

aa = A()
aa.x() # x_man
aa.x = 1
print(aa.x) # 1
aa.x()
# TypeError: 'int' object is not callable

14.8 什么是绑定？

Python 严格要求方法需要有实例才能被调用，这种限制其实就是 Python 所谓的绑定概念。
Python 对象的数据属性通常存储在名为 .__ dict__ 的字典中，我们可以直接访问 _dict_ ，或利用 Python 的内置函数 vars() 获取 .__ dict__ 。

class CC:
	def setXY(self, x, y):
		self.x = x
		self.y = y

    def printXY(self):
		print(self.x, self.y)

dd = CC()
print(dd.__dict__)
# {}

print(vars(dd))
# {}

print(CC.__dict__)
# {'__module__': '__main__', 'setXY': <function CC.setXY at 0x000000C3473DA048>, 'printXY':
<function CC.printXY at 0x000000C3473C4F28>, '__dict__': <attribute '__dict__' of 'CC' objects>,
'__weakref__': <attribute '__weakref__' of 'CC' objects>, '__doc__': None}

dd.setXY(4, 5)
print(dd.__dict__)
# {'x': 4, 'y': 5}

print(vars(CC))
# {'__module__': '__main__', 'setXY': <function CC.setXY at 0x000000632CA9B048>, 'printXY':
<function CC.printXY at 0x000000632CA83048>, '__dict__': <attribute '__dict__' of 'CC' objects>,
'__weakref__': <attribute '__weakref__' of 'CC' objects>, '__doc__': None}

print(CC.__dict__)
# {'__module__': '__main__', 'setXY': <function CC.setXY at 0x000000632CA9B048>, 'printXY':
<function CC.printXY at 0x000000632CA83048>, '__dict__': <attribute '__dict__' of 'CC' objects>,
'__weakref__': <attribute '__weakref__' of 'CC' objects>, '__doc__': None}

14.9 一些相关的内置函数（BIF）

issubclass(class, classinfo)
  1. issubclass(class, classinfo) 方法用于判断参数 class 是否是类型参数 classinfo 的子类。
  2. 一个类被认为是其自身的子类。
  3. classinfo 可以是类对象的元组，只要class是其中任何一个候选类的子类，则返回 True 。
class A:
	pass

class B(A):
	pass

print(issubclass(B, A)) # True
print(issubclass(B, B)) # True
print(issubclass(A, B)) # False
print(issubclass(B, object)) # True
isinstance(object, classinfo)
  1. isinstance(object, classinfo) 方法用于判断一个对象是否是一个已知的类型，类似 type() 。
  2. type() 不会认为子类是一种父类类型，不考虑继承关系。
  3. isinstance() 会认为子类是一种父类类型，考虑继承关系。
  4. 如果第一个参数不是对象，则永远返回 False 。
  5. 如果第二个参数不是类或者由类对象组成的元组，会抛出一个 TypeError 异常。
a = 2
print(isinstance(a, int)) # True
print(isinstance(a, str)) # False
print(isinstance(a, (str, int, list))) # True

class A:
	pass

class B(A):
	
	pass
print(isinstance(A(), A)) # True
print(type(A()) == A) # True
print(isinstance(B(), A)) # True
print(type(B()) == A) # False
hasattr(object, name)

hasattr(object, name) 用于判断对象是否包含对应的属性。

class Coordinate:
	x = 10
	y = -5
	z = 0

point1 = Coordinate()
print(hasattr(point1, 'x')) # True
print(hasattr(point1, 'y')) # True
print(hasattr(point1, 'z')) # True
print(hasattr(point1, 'no')) # False
getattr(object, name[, default])

getattr(object, name[, default]) 用于返回一个对象属性值。

class A(object):
	bar = 1

a = A()
print(getattr(a, 'bar')) # 1
print(getattr(a, 'bar2', 3)) # 3
print(getattr(a, 'bar2'))
# AttributeError: 'A' object has no attribute 'bar2'

【例子】这个例子很酷！

class A(object):
	def set(self, a, b):
		x = a
		a = b
		b = x
		print(a, b)

a = A()
c = getattr(a, 'set')
c(a='1', b='2') # 2 1
setattr(object, name, value)

setattr(object, name, value) 对应函数 getattr() ，用于设置属性值，该属性不一定是存在的。

class A(object):
	bar = 1

a = A()
print(getattr(a, 'bar')) # 1
setattr(a, 'bar', 5)
print(a.bar) # 5
setattr(a, "age", 28)
print(a.age) # 28
delattr(object, name)

delattr(object, name) 用于删除属性。

class Coordinate:
	x = 10
	y = -5
	z = 0

point1 = Coordinate()

print('x = ', point1.x) # x = 10
print('y = ', point1.y) # y = -5
print('z = ', point1.z) # z = 0

delattr(Coordinate, 'z')
print('--删除 z 属性后--') # --删除 z 属性后--
print('x = ', point1.x) # x = 10
print('y = ', point1.y) # y = -5

# 触发错误
print('z = ', point1.z)
# AttributeError: 'Coordinate' object has no attribute 'z'
class property([fget[, fset[, fdel[, doc]]]])

class property([fget[, fset[, fdel[, doc]]]]) 用于在新式类中返回属性值。
a. fget – 获取属性值的函数
b. fset – 设置属性值的函数
c. fdel – 删除属性值函数
d. doc – 属性描述信息

class C(object):
	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

    x = property(getx, setx, delx, "I'm the 'x' property.")

cc = C()
cc.x = 2
print(cc.x) # 2
haowei1999
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SV重点知识回顾
hcyhdm的博客
02-25 862
1.virtual interface和interface的区别 2.验证的完备性，覆盖率 3.随机化的打开和关闭 4.mailbox的作用 5.静态变量与动态变量 6.rand和randc的区别 7.画出验证框架 8.异步fifo同时读写是如何实现的：分为单口ram和双口ram 9.fork...join 、fork...join_any、fork...join_none以及如何关闭。disable 10.代码覆盖率包括哪些 11.类型转换的关键词：$cast 12.sv中虚方法的作
SV理论知识六：代码覆盖率、功能覆盖率以及断言覆盖率
m0_59208577的博客
09-24 1345
单独列出每个covergroup实例的覆盖率，/*-----------------------------断言和断言覆盖率-------------------------------------------------(1) 采样monitor监听到的事务，由于monitor监听的事务是动态变化的，也就是说虽然采样的是某种事务类型的某个变量，但是具体所属的实例是会变化的。2. 覆盖组的覆盖点可以会自动建仓或者自定义仓，对于自动建仓，会根据采样点的取值范围来生成仓，例如一个N比特的就有2的N次方个仓，
SV---随机约束和分布
weixin_42263208的博客
07-17 4966
为什么需要随机 1.芯片越来越复杂，定向测试已经无法满足验证的需求，而随机测试的比例逐渐提高。 2.定向测试能找到你认为可能存在的缺陷，而随机测试可以找到连你自己都想不到的缺陷。 为什么需要约束 没有约束，产生有效激励的同时也产生了很多无效和非法的激励。 1.声明随机变量的类 关键字：rand/randc，只能出现在class中，用来修饰成员变量。 rand：每次随机的概率都是一样的，假设随机10次，每次都是1/10。 randc：每做一次随机，总数会减1，假设随机10次，第一次随机..
SV学习（8）——随机约束和分布、约束块控制
Bunny9__的博客
03-20 7467
SV学习（8）——随机约束和分布1. 随即约束和分布1.1. 为什么需要随机？1.2. 要随机做什么？1.3. 声明随机变量的类1.4. 什么是约束1.5. 权重分布1.6. 集合成员和inside运算符1.7. 条件约束1.8. 双向约束2. 约束块控制2.1. 打开或关闭约束2.2. 内嵌约束 1. 随即约束和分布 1.1. 为什么需要随机？ 芯片体积增大，复杂度日渐提高，传统定向测试已经无法满足验证的需求，而随机测试的比例逐渐提高； 定向测试能找到你认为可能存在缺陷，而随机测试可以找到连你都没想想到
SV随机化Randomization
杰之行的博客
08-17 7250
随机化验证策略 为什么使用随机化验证策略？ 设计复杂度提高之后，直接测试（定向测试）（directedtestcase），没有办法通过穷举法验证所有矢量 定向测试案例用于检查确定的设计属性，仅仅用于检查可以预期的错误 定向测试方式跟测试时间是线性关系 定向测试案例不能检查隐形的错误 解决办法：采用带约束的随机化测试（CRT），对输入的激励随机化 随机内容有哪些？ 必须对DUT里的所有关键点都采用随机化的技术。 （1）RTL设计的配置： 需要测试足够多 （2）环境的配置： 随机化配置整个环.
SV函数内的参数随机方式（待补充
验证小白的记录
01-23 531
/可设置权重的随机。
sv语法
qq_28238141的博客
09-04 2105
1、Distribution(分配随机变量的权重) The := operator assigns the specified weight to the item or, if the item is a range, to every value in the range. The :/ operator assigns the specified weight to the item or...
SV-TVP-SVAR模型代码
01-19
本压缩包文件“SV-TVP-SVAR模型代码”提供了一套用于此类分析的工具，尤其适用于研究时间序列数据的动态变化。以下是对该模型及其应用的详细解释： 1. **SV-TVP-SVAR模型**： - **SV（Stochastic Volatility）**：...
禾川SV-X5系列总线伺服产品中文操作手册V1.3.pdf
12-07
《禾川SV-X5系列总线伺服产品中文操作手册V1.3》是为用户提供禾川SV-X5系列总线伺服产品的详细操作指南，旨在帮助用户理解和应用这一先进的自动化解决方案。该手册涵盖了一系列重要的技术信息，包括产品介绍、选型...
HCFA禾川SV-X6系列伺服驱动器使用说明书V1.2.rar
07-04
《HCFA禾川SV-X6系列伺服驱动器使用说明书V1.2》是为操作和维护禾川品牌SV-X6系列伺服驱动器提供的重要参考资料。这份详细的文档旨在帮助用户理解和应用该系列伺服驱动器，从而在工业自动化领域实现高效、精准的运动...
MI-TVP-SV-VAR_sv_tvp-var-sv_SV模型_tvpsvvar_TVP-SV_
10-04
Koop大神写出来的时变向量自回归模型的进化版，希望对大神写作有帮助。
HCFA禾川SV-D3E系列伺服驱动器使用说明书V1.3.rar
07-04
【HCFA禾川SV-D3E系列伺服驱动器使用说明书V1.3.rar】这个压缩包文件包含了关于禾川SV-D3E系列伺服驱动器的详细使用指南，版本号为V1.3，日期为2021年9月2日。这份说明书是针对那些需要了解或操作该系列伺服驱动器的...
SV精通4-①随机约束和分布
changshengqiu的博客
02-17 1022
1.为什么需要随机？ 2.为什么需要约束？ 3.需要随机什么？ 例题 答案：AC。 4.声明随机变量的类 随机的变量有且只能在“class”类里声明，用rand或randc关键词表面变量的随机属性。有且只有是类的成员变量才能随机，类中的方法中的局部变量不能被rand和randc修饰。 randc表示周期随机性，即所有可能的值都赋过值后随机值才能被重复。 p.randomize()函数进行随机，利用句柄和函数，该函数会返回值0或1，返回1则随机化...
【SystemVerilog】SV 随机测试
小邦是名小ICer的博客
11-09 469
在计算机系统中， 游戏算法和编码技术一直对随机有特殊的需求。一个顺序执行机器，如处理器， 是一个的系统， 它自动地执行指令。计算机行为的确定特性使得它们的数字序列是的。对于真正的随机， 无法凭借当前值来预测下一个值。计算机系统的确定性是一个随机的行为。借助， 计算机系统中引入随机。也就如其名字一样，伪随机数不是真正意义上的随机。然而通过数学公式或者一个预处理的列表， 随机数是可以获取的。有很多研究伪随机算法的理论， 现代算法对于生成伪随机数已经可以很接近真正的随机。伪随机数是可以预测。
SV基础知识4----随机化和约束
热门推荐
m0_59670134的博客
08-10 1万+
1 随机约束和分布 为什么需要随机和约束 随着芯片体积的增大，复杂度日益提高，定向测试已无法满足验证的需求，随机测试的比例逐渐提高。定向测试只能找到你认为可能存在的缺陷，而随机测试可以找到连你都没有想到的缺陷。 若只有随机没有约束，那么会产生很多无效和非法的激励。随机的对象不只是一个数据，而是有联系的变量集。通常这些变量会封装在一个数据类中，同时需要在类中声明数据之间的约束关系。约束不但可以指定数据的取值范围，还可以指定数据的随机权重分布。 随机的内容 器件配置：寄存器和系统信号 环境配置：随.
(十)随机化约束的种类及其控制
一个粉尘的成长博客
10-30 874
SV学习
[SV]SystemVerilog Coverage Options用法總結及案例
元直的博客
04-04 2925
SystemVerilog Coverage Options Coverage options control the behavior of the covergroup, coverpoint, and cross. 一、at_least A minimum number of hits for each bin....
SV理论知识五：随机和约束
m0_59208577的博客
09-24 1144
(2) 动态数组 : 可以使用 size()约束数组的大小，使用 sum()约束数组的和，使用 product()约束数组的积。与在类中定义约束，并且通过对象调用随机化函数 randomize() 相对的是，一些细碎的场景并不需要像类那么全面支持随机约束的方式，而是需要一种更简单的机制来随机化一些在类之外的变量。(2) 可以直接把数组当成一个集合，然后使用inside进行约束，注意，如果数组中某个元素出现多次，那么出现的概率是相同的，也就是说不管元素重复出现多少次，求解的概率都是一样的；
Freertos学习笔记
最新发布
qq_45031559的博客
08-21 678
Freertos学习笔记
tvp-sv-var
01-16
TVP-SV-VAR是一个经济学术语，代表着传统向量自回归模型中的时间变体平滑（TVP），保持向量自回归（VAR）的结构。 传统VAR模型是一种多元时间序列模型，它假设各个变量之间的关系是线性的，并且稳定不变的。然而，在真实世界中，经济变量往往受到外部冲击的影响，因此其关系可能在不同时间段内发生变化。 为了解决这个问题，引入了时间变体平滑（TVP）的概念。TVP模型允许经济变量之间的关系在不同时间段内发生改变，并通过引入状态变量来跟踪这些变化。状态变量可以解释在不同时间段内经济变量之间关系变化的原因，例如政策调整、经济周期等。 TVP-SV-VAR将TVP和VAR两个模型结合起来。它通过引入状态变量和时间变体平滑技术，同时保持VAR模型的结构，能够更准确地捕捉到经济变量之间的关系变化。这个模型可以更好地描述和分析经济系统中的动态调整过程，并提供更可靠的预测结果。 总的来说，TVP-SV-VAR是一个结合了时间变体平滑和向量自回归模型的经济学术语，用于描述经济变量之间关系的动态变化，并提供更精确的分析和预测。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值