Python基础及函数
内置函数
- 内置函数
- 无需导包即可使用的函数
- 不同版本的Python内置函数可能略有不同
- 之前已经接触过的内置函数
- type()、dir()、input()、print()、id()
- 各版本内置函数和使用方法参考文档
- https://docs.python.org/zh-cn/3/library/functions.html
自定义函数
- 定义函数
def func_name(参数列表)：
函数体
[return/yield 函数返回值]
- Python函数的特点
- 函数参数类型多样
- 允许嵌套函数
- 无需声明函数返回值类型
- yield可以作为函数返回值的关键字
- 函数能够被赋值给变量
Python的函数参数
- Python的函数参数
- 无参函数
- 位置参数
- 关键字参数
- 包裹位置参数
- 包裹关键字参数
函数参数
- 无参函数
def show_log():
print('I am a log')
show_log()
- 位置参数
- 传入的参数与定义的参数
def func_name(arg1,arg2,arg3):
print(arg1,arg2,arg3)
func_name(val1,val2,val3)
- 关键字参数
- 直接通过等号传递参数
def func_name(arg1,arg2,arg3):
print(arg1,arg2,arg3)
func_name(arg1=val1,arg3=val3,arg2=val2)
- 默认值参数
- 定义函数时，设置参数的默认值
- 调用函数时，可以指定通过位置或者关键字指定参数的值，如果不指定，参数为默认值
def func_name(arg1=val1,arg2=val2,arg3=val3) ：
print(arg1,arg2,arg3)
func_name()
- 定义默认值参数的错误示范
def func1(x=10, y) : # <= ERROR!
value = x + y ** 2
if value > 5 :
return value
-
不定长函数
- 参数的个数不确定
- 可适应更加复杂情况
- 不定长参数种类
- 包裹（packing）位置参数
- 接收不定长的位置参数，参数被组织成一个元组传入
- 包裹（packing）关键字参数
- 接收不定长的关键字参数，参数被组织成一个字典传入
- 包裹（packing）位置参数
-
包裹（packing）位置参数
- 参数表示为*args
- 调用函数时，参数自动会组织成一个元组传入
- 传入的位置参数与组织成的元组索引位置一致
def func2( *t ) : # t is a tuple
print(t)
func2() # no argument
func2(1,2,3)
func2(1,2,3,4,5)
- 包裹（packing）关键字参数
- 参数表示为**kwargs
- 调用函数时，参数自动会组织成一个字典传入
- 传入的位置参数与组织成的字典的键值对一致
def func3( **d ) : # d is a dictionary
print(d)
func3() # no argument
func3(a=1, b=2, c=3)
- 不同类型函数参数混用顺序
- 位置参数
- 默认值参数
- 包裹位置参数
- 包裹关键字参数
def func5(x, y=10, *args, **kwargs) :
print(x, y, args, kwargs)
func5(0) :
func5(a=1, b=2, y=3, x=4)
func5(1, 2, 3, 4, a=5, b=6)
函数是对象
- Python中函数是对象
- 函数可以被引用，即函数可以赋值给一个变量
- 函数可以被当做参数传递
- 函数可以作返回值
- 函数可以嵌套
def factorial(n):
if n <= 2: return n
return factorial(n-1)*n
f=factorial
f(4)
l=[factorial, f]
l[0](4)
l[1](4)
d={'x':factorial}
d['x'](4)
嵌套函数
- 嵌套函数
- 在函数内部定义新的函数
- 内部函数不能被外部直接调用
- 函数可以被当做变量赋值，因为本质函数是一个对象
def func6() :
def nestedFunc() :
print('Hi')
return nestedFunc
x = func6() # x is the nestedFunc
x()
装饰器
- 装饰器
- 修改其他函数的功能的函数
- 使函数更加简洁
def my_decorator(some_func):
def wrapper(*args):
print("I am watching you!")
some_func(*args)
print("You are called.")
return wrapper
@my_decorator
def add(x, y):
print(x,'+',y,'=',x+y)
add(5,6)
变量作用域
- 变量作用域
- 变量能够生效的范围
- 按照作用域划分变量类型
- 全局变量
- 局部变量
全局变量
- 全局变量
- 定义在模块中的变量
- 全局变量在整个模块中可见
- globals()函数
- 返回所有定义在该模块中的全局变量
- 修改全局变量时，要先使用global关键字声明变量
- 定义在模块中的变量
msg = 'created in module'
def outer_1() :
def inner() :
print("print in inner",msg)
inner()
outer_1()
msg = 'created in module'
def outer() :
def inner() :
global msg
msg = 'changed in inner'
inner()
outer()
print(msg)
局部变量
- 局部变量
- 定义在函数中的变量
- 局部变量仅在定义的函数中可变
- locals()函数
- 返回所有定义在函数中的局部变量
- 自由变量
- 在函数中使用，但未定义在该函数中的非全局变量
def outer_1() :
msg = 'created in outer'
def inner() :
print(msg) # msg is a Free variable
inner()
outer_1()
- nonlocal关键字
- 修改自由变量时，要先使用nonlocal关键字声明变量
def outer():
msg = 'created in outer'
def inner() :
nonlocal msg
msg = 'changed in inner' # msg is a Free variable
inner()
print(msg)
outer()
LEGB规则
- 使用LEGB的顺序来查找一个符号对应的对象
- Local->Enclosed->Global->Built-in
- Local：一个函数或者类方法内部
- Enclosed：嵌套函数内
- Global：模块层级
- Built-in：Python内置符号
- Local->Enclosed->Global->Built-in
type=4
def f1():
type=3
def f2():
type=2
def f3():
type=1
print('type=', type)
f3()
f2()
f1()
函数的返回值
- 函数的返回值
- 函数无需声明返回值类型
- 在函数没有返回值时，函数默认返回None
- return关键字用于返回返回值
- yield关键字
- 当函数使用yield关键字时，函数变为生成器
- 生成器是Python中的一种迭代对象
- 能够使用for循环遍历
- 生成器每次只被读取一次
- 生成器有内置方法_next()_，调用后返回下一个元素
- yield不会终止程序，返回值之后程序继续运行
- 当函数使用yield关键字时，函数变为生成器
生成器示例
- 求斜边小n的勾股数组合
def list_pythagorean_triples(n) :
for c in range(n):
for a in range(1, c):
for b in range(1, c):
if a*a+b*b==c*c:
yield (a,b,c)
- 生成器的使用方法
- for循环迭代生成器
- next()函数从生成器中取值
- 构造生成器的结果列表
#使用循环迭代生成器
for i in list_pythagorean_triples(35):
print(i)
#使用next()方法从生成器中取值
g = list_pythagorean_triples(100)
next(g)
#构造生成器的结果列表
g = list_pythagorean_triples(100)
list(g)
生成器表达式和列表生成式
- 生成器表达式
(x**3 for x in range(10))
- 列表生成式
[x**3 for x in range(10)]
lambda表达式
- lambda表达式
- lambda表达式是一个匿名的函数
- 语法
lambda param1, param2, … : expression
- 使用示例
f=lambda x: x * x
f(3)
lambda表达式举例
# return results of +, -, *, //, % in a list
lambda x,y: [x+y, x-y, x*y, x//y, x%y]
# return max, min, sum in a tuple
lambda *n: (max(n), min(n), sum(n))
# sum 1 to n
lambda n: sum(range(1, n+1))
lambda表达式使用技巧
- filter()函数中使用lambda表达式
- 过滤掉不符合条件的元素，返回符合条件元素的组成的新列表
items=[0, 1, 2, 3, 4, 5]
list(filter(lambda x: x%2==0, items))
list(filter(None, items))
- map()函数中使用lambda表达式
- 根据提供的函数对指定序列做映射
i1=[1, 2, 3, 4, 5, 6]
i2=[11, 12, 13, 14]
i3=[111, 112]
list(map(lambda x,y,z: x+y+z, i1, i2, i3))
- max()函数中使用lambda表达式
- 返回序列中的最大值
max(1,2,3,4)
max([1,2,3,4])
max([1,2,3,4], key=lambda x:-x)
- min()函数中使用lambda表达式
- 返回序列中的最小值
min(1,2,3,4)
min([1,2,3,4])
min([1,2,3,4], key=lambda x:-x)
- sorted()函数中使用lambda表达式
- 对序列进行排序
sorted([1,2,4,3], reverse=True)
sorted([1,2,4,3], key=lambda x:-x)
Python中使用正则表达式
- Python正则表达式模块
- re模块
- 常用方法
| 表达式 | 说明 |
|---|---|
| compile() | 用于编译正则表达式，生成一个正则表达式（Pattern）对象 |
| match() | 查看字符串的开头是否符合匹配模式，如果匹配失败，返回none |
| search() | 扫描整个字符串并返回第一个成功的匹配 |
| findall() | 在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配，则返回空列表 |
| sub() | 替换字符串中的匹配项 |
正则表达式
| 符号 | 说明 | 示例 |
|---|---|---|
| 逐字匹配 | re.match(‘abc’, ‘abc123’)# match! re.match(‘abc’, ‘123abc’)# not match! | |
| | | 或 | re.match('abc |
| . | 除换行符外匹配任意字符 | re.match(’.’, ‘123abc’) # match! |
| […] | 匹配任意一组字符中的一个 | re.match(’[aAbc]’, ‘b’) # a, A, b, or c re.match(’[a-c]’, ‘b’) # a to c re.match(’[A-C0-9]’, ‘B’) # A to C and 0 to 9 |
| [^…] | 匹配不在[]中的字符 | re.match(’[^A-Z0-9]’, ‘b’)# not A to Z nor 0 to 9 |
| \d | 匹配任意数字 | re.match(r’\d’, ‘8’) # match! |
| \D | 匹配任意非数字 | re.match(r’\D’, ‘B’) # match! |
| \w | 匹配字母数字及下划线 | re.match(r’\w’, ‘_’) # match! |
| \W | 匹配非字母数字及下划线 | re.match(r’\W’, ‘?’) # match! |
| \s | 匹配任意空白字符 | re.match(r’\s’, ’ ') # match! |
| \S | 匹配任意非空字符 | re.match(r’\S’, ‘#’) # match! |
| ^ | 匹配字符串的开头 | re.findall(’^[abc]’, ‘xabc’) # not found |
| $ | 匹配字符串的末尾 | re.findall(’[c]$’, ‘cc cc’) # found one |
| \b | 匹配一个单词边界 | re.findall(r’\bc’, ‘cc cc’) # cc cc |
| \B | 匹配非单词边界 | re.findall(r’c\B’, ‘cc cc’) # cc cc |
| re* | 匹配0个或多个的表达式 | re.match(’[abc]*’, ‘xabc’) # match |
| re+ | 匹配1个或多个的表达式 | re.match(’[abc]+’, ‘abcd’) # match |
| re? | 匹配0个或1个表达式 | re.match(’[abc]?’, ‘xabc’) # match |
| re{n} | 匹配n个面前的表达式 | re.match(’[abc]{2}’, ‘abc’) # match |
| re{n,m} | 匹配n到m次前面的表达式 | re.match(’[abc]{1,3}’, ‘abc’) # match |
-
默认为贪婪匹配
- re.match(’.{2,6}c’, ‘abcdcfchc’) # match ‘abcdcfc’
-
?为非贪婪匹配
- re.match(’.{2,6}?c’, ’ abcdcfchc’) # match ‘abc’
-
0长度匹配
- re.sub(‘a?’, ‘-’, ‘bb’) # result: ‘-b-b-’
- re.sub(‘a*’, ‘-’, ‘bb’) # result: ‘-b-b-’
-
使用()分组
match=re.match(r'(\d+)', '123')
groups=match.groups() # groups is ('123',)
g1=match.group(1) # g1 is '123'
match=re.match(r'(\d)(\d)(\d)', '123')
groups=match.groups() # groups is ('1', '2', '3')
g1=match.group(1) # g1 is '1'
g2=match.group(2) # g2 is '2'
g3=match.group(3) # g3 is '3'
- \1…\9匹配第n个分组的内容
ma = re.match(r'(\d(\d(\d)))\1\2\3', '123123233')
print(ma.groups())
- 解析
初始分为三组:
组1: (\d(\d(\d))) 123123233
组2: (\d(\d(\d))) 123123233
组3: (\d(\d(\d))) 123123233
\1： 123123233
\2： 123123233
\3： 123123233
- ?：跳过分区
ma = re.match(r'(\d(?:\d(\d)))-\2', '647-7')
print(ma.groups())
- 解析
初始分为三组:
组1: (\d(\d(\d))) 647-7
组2: (\d(\d(\d))) 647-7
组3: (\d(\d(\d))) 647-7
?:在组2中，所以组2被跳过了，所以有两个分组
组1: (\d(\d(\d))) 647-7
组2: (\d(\d(\d))) 647-7
| 符号 | 说明 | 示例 |
|---|---|---|
| ?= | 前向肯定界定符 | 用\b\w+(?=ing\b)查找I’m singing while you’re dancing.匹配到sing danc |
| ?! | 前向否定界定符 | \d{3}(?!\d)匹配三位数字，而且这三位数字的后面不能是数字 |
| ?<- | 向后肯定界定符 | 用(?<=\bre)\w+\b查找reading a book得到ading。 |
| ?<! | 向后否定界定符 | (?<![a-z])\d{7}匹配前面不是小写字母的七位数字 |
Python面向对象
- 定义类
- 实例方法
- 使用对象才能够调用的方法
- 方法的第一个参数为self表示对象本身
class Shape : //定义类，关键字
def __init__(self, x=0, y=0) : //构造方法
self.x = x //实例变量
self.y = y
def move(self, deltaX, deltaY) : //实例方法，对象实例
self.x += deltaX
self.y += deltaY
shape = Shape() //创建对象
shape.move(2,3) //调用实例方法
print(shape.x)
print(shape.y)
扫一扫
1279
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
