python内容总结二
1.函数
1.1函数的语法
def 函数名（参数列表）:
函数体
1.2例子
def max(a,b):
if a>b:
return a
else:
return b
print(max(3,5))
1.2参数
1.2.1参数传递
- 不可变类型：类似 C++ 的值传递，如整数、字符串、元组。如 fun(a)，传递的只是 a 的值，没有影响 a 对象本身。如果在 fun(a) 内部修改 a 的值，则是新生成一个 a 的对象。
实例：
def change(a):
a+=5
print("函数内的对象：",end='')
print(id(a))
a=3
print("刚开始：",end='')
print(a,end=' 对象a:')
print(id(a))
change(a)
print("函数调用后：",end='')
print(a,end=' 对象a:')
print(id(a))
运行结果：
刚开始：3 对象a:1592290400
函数内的对象：1592290560
函数调用后：3 对象a:1592290400
- 可变类型：类似 C++ 的引用传递，如 列表，字典。如 fun(la)，则是将 la 真正的传过去，修改后 fun 外部的 la 也会受影响
实例：
def change(a):
a.append([4,5,6])
print("函数内的对象：",end='')
print(id(a))
a=[1,2,3]
print("刚开始：",end='')
print(a,end=' 对象a:')
print(id(a))
change(a)
print("函数调用后：",end='')
print(a,end=' 对象a:')
print(id(a))
运行结果：
刚开始：[1, 2, 3] 对象a:1522837328968
函数内的对象：1522837328968
函数调用后：[1, 2, 3, [4, 5, 6]] 对象a:1522837328968
1.2.2正式参数类型
-
必需参数
必需2数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。 -
关键字参数
关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
def printinfo( name, age ):
"打印任何传入的字符串"
print ("名字: ", name)
print ("年龄: ", age)
return
#调用printinfo函数
printinfo( age=18, name="7个七" )
- 默认参数
调用函数时，如果没有传递参数，则会使用默认参数
def printinfo( name, age = 18 ):
"打印任何传入的字符串"
print ("名字: ", name)
print ("年龄: ", age)
return
#调用printinfo函数
printinfo( age=20, name="7个七" )
print ("------------------------")
printinfo( name="7个七" )
- 不定长参数
加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。
def printinfo( arg1, *vartuple ):
"打印任何传入的参数"
print ("输出: ")
print (arg1)
print (vartuple)
# 调用printinfo 函数
printinfo( 70, 60, 50 )
加了两个星号 ** 的参数会以字典的形式导入
def printinfo( arg1, **vardict ):
"打印任何传入的参数"
print ("输出: ")
print (arg1)
print (vardict)
# 调用printinfo 函数
printinfo(1, a=2,b=3)
2.面向对象
1.对象–类的实例化
class MyClass:
"""一个简单的类实例"""
i = 12345
def f(self):
return 'hello world'
# 实例化类
x = MyClass()
# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i)
print("MyClass 类的方法 f 输出为：", x.f())
2.类的方法
在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。
class test:
def prt(self):
print(self)
print(self.__class__)
a=test()
a.prt()
b=test()
b.prt()
运行结果：
<__main__.test object at 0x0000022389595898>
<class '__main__.test'>
<__main__.test object at 0x000002238965B978>
<class '__main__.test'>
从执行结果可以很明显的看出，self 代表的是类的实例，代表当前对象的地址，而 self.class 则指向类。self 不是 python 关键字，我们把他换成 runoob 也是可以正常执行的
3.构造方法
类有一个名为 init() 的特殊方法（构造方法），该方法在类实例化时会自动调用
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))
# 实例化类
p = people('runoob',10,30)
p.speak()
4.继承
4.1单继承
class dog:
type='狗'
food='狗粮'
def __init__(self,type,food):
self.type=type
self.food=food
def eat(self):
print("%s爱吃%s"%(self.type,self.food))
def sleep(self):
print("%s正在睡觉"%(self.type))
#继承
class selfdog(dog):
def __init__(self,name,type,food):
dog.__init__(self, type, food)
self.name=name
def eat(self):
print("%s%s爱吃%s"%(self.name,self.type,self.food))
def sleep(self):
print("%s%s正在睡觉"%(self.name,self.type))
sd=selfdog("小黄","狗","狗粮")
sd.eat()
sd.sleep()
4.2多继承
补充：对于python而言，类的属性的可见度只有两种，public和private。类的私有属性便是在前面加上“__”标识符，而公共属性则不必。
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 sample(speaker,student):
a =''
def __init__(self,n,a,w,g,t):
student.__init__(self,n,a,w,g)
speaker.__init__(self,n,t)
test = sample("Tim",25,80,4,"Python")
test.speak() #方法名同，默认调用的是在括号中排前地父类的方法
5方法重写
class Parent: # 定义父类
def myMethod(self):
print ('调用父类方法')
class Child(Parent): # 定义子类
def myMethod(self):
print ('调用子类方法')
c = Child() # 子类实例
c.myMethod() # 子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法
5运算符重载
class Vector:
def __init__(self, a, b):
self.a = a
self.b = b
def __str__(self):
return 'Vector (%d, %d)' % (self.a, self.b)
def __add__(self,other):
return Vector(self.a + other.a, self.b + other.b)
v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
