Python基础——从函数到高级魔法方法
函数到高级魔法方法
- 函数
-
- 定义函数
- 调用函数
- 函数文档
- 函数参数
- 函数的返回值
- 变量作用域
- Lambda表达式
- 匿名函数的定义
- 类与对象
-
- 对象 = 属性 + 方法
- self是什么
- Python的魔法方法
- 公有和私有
- 组合
- 魔法方法
-
- 基本的魔法方法
- 算数运算符
- 增量赋值运算符
- 定制序列
函数
定义函数
每一种编程语言都离不开函数，Python也不例外，关于Python函数的定义：
以def关键词开头，后接函数名和圆括号()；
函数执行的代码以:起始，并且缩进；
return[表达式]结束函数，选择性的返回一个值给调用方。不带表达式的return相当于返回None。
调用函数
例：
def printme(str):
print(str)
printme("我要调用用户自定义函数!") # 我要调用用户自定义函数!
printme("再次调用同一函数") # 再次调用同一函数
temp = printme('hello') # hello
print(temp) # None
函数文档
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是形参
函数参数
Python的参数从简到繁的形态：
- 位置参数(positional argument)
- 默认参数(default argument)
- 可变参数(variable argument)
- 关键字参数(keyword argument)
- 命名关键字参数(name keyword argument)
- 参数组合
调用参数时，如果没有值的传入，则被认为是使用默认值。
默认参数一定要放在位置参数后面，否则会报错。
例：
def printinfo(name, age=8):
print('Name:{0},Age:{1}'.format(name, age))
printinfo('小马') # Name:小马,Age:8
printinfo('小马', 10) # Name:小马,Age:10defprintfo
在大部分编程语言中函数调用时参数的顺序与声明必须一致，但是在Python中可以不一致，因为Python解释器能够用参数名匹配参数值。
例：
def printinfo(name, age):
print('Name:{0},Age:{1}'.format(name, age))
printinfo(age=8, name='小马') # Name:小马,Age:8
函数的返回值
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 discounts(price, rate):
final_price = price * rate
return final_price
old_price = float(input('请输入原价:')) # 98
rate = float(input('请输入折扣率:')) # 0.9
new_price = discounts(old_price, rate)
print('打折后价格是:%.2f' % new_price) # 88.20
但是，当内部作用域想要修改外部作用域的变量是，就要用到两个关键字：global、nonlocal。
num = 1
def fun1():
global num # 需要使用 global 关键字声明
print(num) # 1
num = 123
print(num) # 123
fun1()
print(num) # 123
Lambda表达式
匿名函数的定义
Python中的两类函数：
- 第一类：用def关键字定义的正规函数
- 第二类用lambda关键字定义的匿名函数
在函数参数和表达式中间要加个冒号。
例：
def sqr(x):
return x ** 2
print(sqr)
# 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
类与对象
对象 = 属性 + 方法
定义Python类可以使用关键字class，关键字后面要紧跟类的名称、分号和类的实现。
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 MyList(list):
pass
lst = MyList([1, 5, 2, 7, 8])
lst.append(9)
lst.sort()
print(lst)
# [1, 2, 5, 7, 8, 9]
多态：不同对象对同一方法响应不同的行动
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
self是什么
Python中的self相当于c++的this指针
例：
class Test:
def prt(self):
print(self)
print(self.__class__)
t = Test()
t.prt()
# <__main__.Test object at 0x000000BC5A351208>
# Python的魔法方法
Python有一个魔法方法，该方法在类实例化时会自动调用。
例：
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,该死的，谁踢我...
公有和私有
在变量或函数名前加上"_"两个下划线，那么这个函数或变量就会为私有的了。
例：
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
# Python的私有为伪私有
print(counter._JustCounter__secretCount) # 2
print(counter.__secretCount)
# AttributeError: 'JustCounter' object has no attribute '__secretCount'
组合
例：
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条
魔法方法
魔法方法总是被下划线包围，例：__init__
基本的魔法方法
例：
class Rectangle:
def __init__(self, x, y):
self.x = x
self.y = y
def getPeri(self):
return (self.x + self.y) * 2
def getArea(self):
return self.x * self.y
rect = Rectangle(4, 5)
print(rect.getPeri()) # 18
print(rect.getArea()) # 20
算数运算符
例：
class C:
pass
print(type(len)) # 增量赋值运算符
- __iadd__(self, other)定义赋值加法的行为：+=
- __isub__(self, other)定义赋值减法的行为：-=
- __imul__(self, other)定义赋值乘法的行为：*=
- __itruediv__(self, other)定义赋值真除法的行为：/=
- __ifloordiv__(self, other)定义赋值整数除法的行为：//=
- __imod__(self, other)定义赋值取模算法的行为：%=
- __ipow__(self, other[, modulo])定义赋值幂运算的行为：**=
- __ilshift__(self, other)定义赋值按位左移位的行为：<<=
- __irshift__(self, other)定义赋值按位右移位的行为：>>=
- __iand__(self, other)定义赋值按位与操作的行为：&=
- __ixor__(self, other)定义赋值按位异或操作的行为：^=
- __ior__(self, other)定义赋值按位或操作的行为：|=
定制序列
Python中的协议像是一种指南。
例：
class CountList:
def __init__(self, *args):
self.values = [x for x in args]
self.count = {}.fromkeys(range(len(self.values)), 0)
def __len__(self):
return len(self.values)
def __getitem__(self, item):
self.count[item] += 1
return self.values[item]
c1 = CountList(1, 3, 5, 7, 9)
c2 = CountList(2, 4, 6, 8, 10)
print(c1[1]) # 3
print(c2[2]) # 6
print(c1[1] + c2[1]) # 7
print(c1.count)
# {0: 0, 1: 2, 2: 0, 3: 0, 4: 0}
print(c2.count)
# {0: 0, 1: 1, 2: 1, 3: 0, 4: 0}