函数是一种仅在调用时运行的代码块。
您可以将数据（称为参数）传递到函数中。
函数可以把数据作为结果返回。
1).创建函数
在 Python 中，使用 def 关键字定义函数：
实例
def my_function():
print("Hello from a function")
调用函数
如需调用函数，请使用函数名称后跟括号：
实例
def my_function():
print("Hello from a function")
my_function()
参数
信息可以作为参数传递给函数。
参数在函数名后的括号内指定。您可以根据需要添加任意数量的参数，只需用逗号分隔即可。
下面的例子有一个带参数（fname）的函数。当调用此函数时，我们传递一个名字，在函数内部使用它来打印全名：
实例
def my_function(fname):
print(fname + " Gates")
my_function("Rory John")
my_function("Jennifer Katharine")
my_function("Phoebe Adele")默认参数值
下面的例子展示如何使用默认参数值。
如果我们调用了不带参数的函数，则使用默认值：
实例
def my_function(country = "China"):
print("I am from " + country)
my_function("Sweden")
my_function("India")
my_function()
my_function("Brazil")
#
I am from Sweden
I am from India
I am from China
I am from Brazil以 List 传参
您发送到函数的参数可以是任何数据类型（字符串、数字、列表、字典等），并且在函数内其将被视为相同数据类型。
例如，如果您将 List 作为参数发送，它到达函数时仍将是 List（列表）：
实例
def my_function(food):
for x in food:
print(x)
fruits = ["apple", "banana", "cherry"]
my_function(fruits)
返回值
如需使函数返回值，请使用 return 语句：
实例
def my_function(x):
return 5 * x
print(my_function(3))
print(my_function(5))
print(my_function(9))
关键字参数
您还可以使用 key = value 语法发送参数。
参数的顺序无关紧要。
实例
def my_function(child3, child2, child1):
print("The youngest child is " + child3) #The youngest child is Rory
my_function(child1 = "Phoebe", child2 = "Jennifer", child3 = "Rory")
在 Python 文档中，“关键字参数”一词通常简称为 kwargs。
任意参数
如果您不知道将传递给您的函数多少个参数，请在函数定义的参数名称前添加 *。
这样，函数将接收一个参数元组，并可以相应地访问各项：
实例
如果参数数目未知，请在参数名称前添加 *：
def my_function(*kids):
print("The youngest child is " + kids[2])
my_function("Phoebe", "Jennifer", "Rory")
pass 语句
函数定义不能为空，但是如果您出于某种原因写了无内容的函数定义，请使用 pass 语句来避免错误。
实例
def myfunction:
pass
递归
Python 也接受函数递归，这意味着定义的函数能够调用自身。
递归是一种常见的数学和编程概念。它意味着函数调用自身。这样做的好处是可以循环访问数据以达成结果。
开发人员应该非常小心递归，因为它可以很容易地编写一个永不终止的，或者使用过量内存或处理器能力的函数。但是，在被正确编写后，递归可能是一种非常有效且数学上优雅的编程方法。
在这个例子中，tri_recursion() 是我们定义为调用自身 ("recurse") 的函数。我们使用 k 变量作为数据，每次递归时递减（-1）。当条件不大于 0 时（比如当它为 0 时），递归结束。
对于新的开发人员来说，可能需要一些时间来搞清楚其工作原理，最好的方法是测试并修改它。
实例
递归的例子：
def tri_recursion(k):
if(k>0):
result = k+tri_recursion(k-1)
print(result)
else:
result = 0
return result
print("\n\nRecursion Example Results")
tri_recursion(6)
#Recursion Example Results
1
3
6
10
15
21 6+5+4+3+2+1+0=212).Python Lambda
lambda 函数是一种小的匿名函数。
lambda 函数可接受任意数量的参数，但只能有一个表达式。
语法
lambda arguments : expression执行表达式并返回结果：
实例
一个 lambda 函数，它把作为参数传入的数字加 10，然后打印结果：
x = lambda a : a + 10
print(x(5)) #15
lambda 函数可接受任意数量的参数：
实例
一个 lambda 函数，它把参数 a 与参数 b 相乘并打印结果：
x = lambda a, b : a * b
print(x(5, 6))
实例
一个 lambda 函数，它把参数 a、b 和 c 相加并打印结果：
x = lambda a, b, c : a + b + c
print(x(5, 6, 2))
为何使用 Lambda 函数？
当您把 lambda 用作另一个函数内的匿名函数时，会更好地展现 lambda 的强大能力。
假设您有一个带一个参数的函数定义，并且该参数将乘以未知数字：
def myfunc(n):
return lambda a : a * n
使用该函数定义来创建一个总是使所发送数字加倍的函数：
实例
def myfunc(n):
return lambda a : a * n
mydoubler = myfunc(2)
print(mydoubler(11)) #22
或者，使用相同的函数定义来创建一个总是使您发送的数字增加三倍的函数：
实例
def myfunc(n):
return lambda a : a * n
mytripler = myfunc(3)
print(mytripler(11))
或者，在同一程序中使用相同的函数定义来生成两个函数：
实例
def myfunc(n):
return lambda a : a * n
mydoubler = myfunc(2)
mytripler = myfunc(3)
print(mydoubler(11)) #22
print(mytripler(11)) #33
如果在短时间内需要匿名函数，请使用 lambda 函数。
3).Python 数组
请注意，Python 没有内置对数组的支持，但可以使用 Python 列表代替。
数组
数组用于在单个变量中存储多个值：
实例
创建一个包含汽车品牌的数组：
cars = ["Porsche", "Volvo", "BMW"]什么是数组？
数组是一种特殊变量，能够一次包含多个值。
如果您有一个项目列表（例如，汽车品牌列表），将牌子存储在单个变量中可能如下所示：
car1 = "Porsche"
car2 = "Volvo"
car3 = "BMW"
但是，如果您想遍历这些品牌并找到特定的汽车品牌怎么办？如果不是 3 辆车，而是 300 辆怎么办？
解决方案是数组！
数组可以在单个名称下保存多个值，您可以通过引用索引号来访问这些值。
访问数组元素
通过索引号来引用数组元素。
实例
获取首个数组项目的值：
x = cars[0]
实例
修改首个数组项目的值：
cars[0] = "Audi"
数组长度
使用 len() 方法来返回数组的长度（数组中的元素数量）。
实例
返回 cars 数组中的元素数量：
x = len(cars)
注释：数组长度总是比最高的数组索引大一个。
循环数组元素
您可以使用 for in 循环遍历数组的所有元素。
实例
打印 cars 数组中的每个项目：
for x in cars:
print(x)
添加数组元素
您可以使用 append() 方法把元素添加到数组中。
实例
向 cars 数组再添加一个元素：
cars.append("Audi")
删除数组元素
您可以使用 pop() 方法从数组中删除元素。
实例
删除 cars 数组的第二个元素：
cars.pop(1)
您也可以使用 remove() 方法从数组中删除元素。
实例
删除值为 "Volvo" 的元素：
cars.remove("Volvo")
注释：列表的 remove() 方法仅删除首次出现的指定值。
数组方法
Python 提供一组可以在列表或数组上使用的内建方法。
| 方法 | 描述 |
|---|---|
| append() | 在列表的末尾添加一个元素 |
| clear() | 删除列表中的所有元素 |
| copy() | 返回列表的副本 |
| count() | 返回具有指定值的元素数量。 |
| extend() | 将列表元素（或任何可迭代的元素）添加到当前列表的末尾 |
| index() | 返回具有指定值的第一个元素的索引 |
| insert() | 在指定位置添加元素 |
| pop() | 删除指定位置的元素 |
| remove() | 删除具有指定值的项目 |
| reverse() | 颠倒列表的顺序 |
| sort() | 对列表进行排序 |
注释：Python 没有内置对数组的的支持，但可以使用 Python 列表代替。
4).Python 类和对象
Python 类/对象
Python 是一种面向对象的编程语言。
Python 中的几乎所有东西都是对象，拥有属性和方法。
类（Class）类似对象构造函数，或者是用于创建对象的“蓝图”。
创建类
如需创建类，请使用 class 关键字：
实例
使用名为 x 的属性，创建一个名为 MyClass 的类：
class MyClass:
x = 5创建对象
现在我们可以使用名为 myClass 的类来创建对象：
实例
创建一个名为 p1 的对象，并打印 x 的值：
p1 = MyClass()
print(p1.x)__init__() 函数
上面的例子是最简单形式的类和对象，在实际应用程序中并不真正有用。
要理解类的含义，我们必须先了解内置的 __init__() 函数。
所有类都有一个名为 __init__() 的函数，它始终在启动类时执行。
使用 __init__() 函数将值赋给对象属性，或者在创建对象时需要执行的其他操作：
实例
创建名为 Person 的类，使用 __init__() 函数为 name 和 age 赋值：
class Person:
def __init__(self, name, age): #self在这起什么作用呢，类似this还是void呢
self.name = name
self.age = age
p1 = Person("Bill", 63)
print(p1.name)
print(p1.age)
注释：每次使用类创建新对象时，都会自动调用 __init__() 函数。
对象方法
对象也可以包含方法。对象中的方法是属于该对象的函数。
让我们在 Person 类中创建方法：
实例
插入一个打印问候语的函数，并在 p1 对象上执行它：
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def myfunc(self):
print("Hello my name is " + self.name)
p1 = Person("Bill", 63)
p1.myfunc()提示：self 参数是对类的当前实例的引用，用于访问属于该类的变量。
self 参数
self 参数是对类的当前实例的引用，用于访问属于该类的变量。
它不必被命名为 self，您可以随意调用它，但它必须是类中任意函数的首个参数：
实例
使用单词 mysillyobject 和 abc 代替 self：
class Person:
def __init__(mysillyobject, name, age):
mysillyobject.name = name
mysillyobject.age = age
def myfunc(abc):
print("Hello my name is " + abc.name)
p1 = Person("Bill", 63)
p1.myfunc()修改对象属性
您可以这样修改对象的属性：
实例
把 p1 的年龄设置为 40：
p1.age = 40
删除对象属性
您可以使用 del 关键字删除对象的属性：
实例
删除 p1 对象的 age 属性：
del p1.age
删除对象
使用 del 关键字删除对象：
实例
删除 p1 对象：
del p1
pass 语句
类定义不能为空，但是如果您处于某种原因写了无内容的类定义语句，请使用 pass 语句来避免错误。
实例
class Person:
pass5).Python 继承
Python 继承
继承允许我们定义继承另一个类的所有方法和属性的类。
父类是继承的类，也称为基类。
子类是从另一个类继承的类，也称为派生类。
创建父类
任何类都可以是父类，因此语法与创建任何其他类相同：
实例
创建一个名为 Person 的类，其中包含 firstname 和 lastname 属性以及 printname 方法：
class Person:
def __init__(self, fname, lname):
self.firstname = fname
self.lastname = lname
def printname(self):
print(self.firstname, self.lastname)
# 使用 Person 来创建对象，然后执行 printname 方法：
x = Person("Bill", "Gates")
x.printname()
创建子类
要创建从其他类继承功能的类，请在创建子类时将父类作为参数发送：
实例
创建一个名为 Student 的类，它将从 Person 类继承属性和方法：
class Student(Person):
pass
注释：如果您不想向该类添加任何其他属性或方法，请使用 pass 关键字。
现在，Student 类拥有与 Person 类相同的属性和方法。
实例
使用 Student 类创建一个对象，然后执行 printname 方法：
x = Student("Elon", "Musk")
x.printname()
添加 __init__() 函数
到目前为止，我们已经创建了一个子类，它继承了父类的属性和方法。
我们想要把 __init__() 函数添加到子类（而不是 pass 关键字）。
注释：每次使用类创建新对象时，都会自动调用 __init__() 函数。
实例
为 Student 类添加 __init__() 函数：
class Student(Person):
def __init__(self, fname, lname):
# 添加属性等
当您添加 __init__() 函数时，子类将不再继承父的 __init__() 函数。
注释：子的 __init__() 函数会覆盖对父的 __init__() 函数的继承。
如需保持父的 __init__() 函数的继承，请添加对父的 __init__() 函数的调用：
实例
class Student(Person):
def __init__(self, fname, lname):
Person.__init__(self, fname, lname)
现在，我们已经成功添加了 __init__() 函数，并保留了父类的继承，我们准备好在 __init__() 函数中添加功能了。
使用 super() 函数
Python 还有一个 super() 函数，它会使子类从其父继承所有方法和属性：
实例
class Student(Person):
def __init__(self, fname, lname):
super().__init__(fname, lname)
通过使用 super() 函数，您不必使用父元素的名称，它将自动从其父元素继承方法和属性。
添加属性
实例
把名为 graduationyear 的属性添加到 Student 类：
class Student(Person):
def __init__(self, fname, lname):
super().__init__(fname, lname)
self.graduationyear = 2019
在这例子中，2019 年应该是一个变量，并在创建 student 对象时传递到 Student 类。为此，请在 __init__() 函数中添加另一个参数：
实例
添加 year 参数，并在创建对象时传递正确的年份：
class Student(Person):
def __init__(self, fname, lname, year):
super().__init__(fname, lname)
self.graduationyear = year
x = Student("Elon", "Musk", 2019)
添加方法
实例
把名为 welcome 的方法添加到 Student 类(在继承Person类后，想有自己的方法)：
class Student(Person):
def __init__(self, fname, lname, year):
super().__init__(fname, lname)
self.graduationyear = year
def welcome(self):
print("Welcome", self.firstname, self.lastname, "to the class of", self.graduationyear)
提示：如果您在子类中添加一个与父类中的函数同名的方法，则将覆盖父方法的继承。
105
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
