1 函数参数
（1）收集参数：以一个星号＊加上形参名的方式，表示这个函数的实参个数不定，可能0个可能n个。
def varParaFun(name,*param):
print(‘位置参数是：‘,name)
print(‘收集参数是：‘,param)
print(‘第一个收集参数是：‘,param[0])
varParaFun(‘数据之美‘,‘hello‘,123,‘abc‘)
#位置参数是： 数据之美
#收集参数是： (‘hello‘, 123, ‘abc‘)
#第一个收集参数是： hello
（2）收集参数：用两个星号（**）来标定可变参数，将变参数打包为字典。它表明可变参数是字典元素。调用函数的方法则需要采用诸如 arg I =value l的形式。
def varFun(**param):
if len(param)==0:
print(‘None‘)
else:
print(param)
varFun(a=‘beauty‘,b=2)
#{‘a‘: ‘beauty‘, ‘b‘: 2}
2 传值还是传引用——传引用
如果参数传递的是不可变对象，为了维护它的“不可变”属性，函数内部不得不重构一个实参的副本，这个实参的副本即形参和主调函数提供的实参在内存中实际分处于不同位置。因此，对函数形参的修改并不会对实参造成任何影响，因此在结果上看起来和传值一样。函数中对形参的改变只是新生成一个东西，再冠以相同的名称。
def foo1(a):
a=a+(‘d‘,‘e‘)
print(‘调用之中：‘,a)
tuple1=(‘a‘,‘b‘,‘c‘)
print(‘调用之前：‘,tuple1)
foo1(tuple1)
print(‘调用之后：‘,tuple1)
def foo2(a):
a.append(‘可变对象‘)
print(‘调用之中：‘,a)
List1=[‘a‘,1,2,3]
print(‘调用之前：‘,List1)
foo2(List1)
print(‘调用之后：‘,List1)
#调用之前： (‘a‘, ‘b‘, ‘c‘)
#调用之中： (‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘)
#调用之后： (‘a‘, ‘b‘, ‘c‘)
#调用之前： [‘a‘, 1, 2, 3]
#调用之中： [‘a‘, 1, 2, 3, ‘可变对象‘]
#调用之后： [‘a‘, 1, 2, 3, ‘可变对象‘]
3 面向过程与面向对象
POP（Procedure Oriented Programming ）程序=算法+数据结构，设计思想是"How to do",how即指函数。
OOP（Object Oriented Programming）程序=对象+消息传递=（对象+方法）+消息传递，设计思想是“Who to do”,who指即指对象，对象有各种方法。
4 python中的面向对象——类
（1）类：类中的数据成员可大致分为两类：属于对象的数据成员和属于类的数据成员。属于对象的数据成员主要在__init__()中定义，同一个类定义下的不同对象之间互不影响，而属于类的数据成员为所有对象共享。以__开始的数据成员或方法，属于私有的，这类内部成员只能在类内使用不能被继承，但可以通过“对象名._类名__xxx”的方式访问。以_开头的属于保护成员，只对自己和子类开放权限，不能通过“from module import *”的方式引入。“__xxx__”形式属于python系统自定义的特殊成员，如__init__,__del__。类中的方法参数必须包含self且为第一个参数。
class Person:
height=162 #定义类的数据成员
def __init__(self,name,age,weight):
self.name = name #定义对象的数据成员属性
self.age = age
self.__weight = weight #私有数据成员，只能通过类内的公有成员函数访问
def speak(self): #公有成员函数
print(‘我叫%s，我的年龄是%d，我的身高是%dcm，我的体重是%dKG.‘ %(self.name,self.age,Person.height,self.__weight))
people=Person(‘PinkFox‘,23,46)
people.speak() #调用公有成员函数，也称访问方法
Person.height=165 #为属于类的数据成员重新赋值
people.name=‘RedRabbit‘
people.age=24 #访问属性并赋值
people.speak()
#我叫PinkFox，我的年龄是23，我的身高是162cm，我的体重是46KG.
#我叫RedRabbit，我的年龄是24，我的身高是165cm，我的体重是46KG.
（2）python中的继承：继承的目的在于实现代码重用，即对已有的成熟的功能，子类从父类执行“拿来主义”。父类又称基类、超类，子类又称派生类。
class Students(Person):
school=‘霍格沃茨魔法学校‘
def __init__(self,name,age,weight,grad):
self.grade=grad
#调用父类的构造方法，初始化数据成员
Person.__init__(self,name,age,weight)
def speak(self):
print(‘我叫%s，我的年龄是%d,我的身高是%dcm，我在%s读%d年级。‘ %(self.name,self.age,Person.height,Students.school,self.grade))
stu=Students(‘PinkFox‘,13,36,5)
Person.height=158
stu.speak()
#我叫PinkFox，我的年龄是13,我的身高是158cm，我在霍格沃茨魔法学校读5年级。
人生就是一次次幸福的相聚，夹杂着一次次伤感的别离。我们不是在最好的时光相遇，而是遇见了你才有了最好的时光。——改编自《老师，好》
原文地址：https://www.cnblogs.com/DHuifang004/p/11067091.html