Python基础四

目录

一、函数

二、作用域，局部与全局变量

三、递归

四、内置函数

 

一、函数

定义: 函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可

特性:

1. 减少重复代码
2. 使程序变的可扩展
3. 使程序变得易维护

你可以定义一个由自己想要功能的函数，以下是简单的规则：

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
• 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

语法：

def 函数名（参数列表）:
      函数体

形参和实参：

形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量

实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值

# Author Cathy
a= 2
b= 3
def test(x,y):#x,y形式参数
    print(x,y)
    return x+y

c = test(a,b)#a,b实际参数
print(c)

View Code

c这个变量值，是函数返回值

函数3大优点：代码重用性，保持一致性，可扩展性

import time
def logs():
    time_format = '%Y-%m-%d %X'
    time_current = time.strftime(time_format)
    with open('testlist.txt','a+',encoding= 'utf-8') as f:
        f.write('%s something wrong\n'%time_current)

def test1():
    logs()
def test2():
    logs()
def test3():
    logs()

test1()
test2()
test3()

View Code

打印一段加时间log日志

位置参数和关键参数：关键参数必须放在位置参数之后

def test(x,y,z=3):#z是一个默认参数，不传值就显示默认值，传值就显示传过来的值
    print(x)
    print(y)
    print(z)
    return
test(1,2,8)#位置参数调用，必须一一对应，不能多也不能少
test(y=3,x=4)#关键字调用，与形参位置无关
test(5,6,z=7)#关键参数必须放在位置参数之后

View Code

默认参数：

def test(x,y=3):#y是一个默认参数，不传值就显示默认值，传值就显示传过来的值
    print(x)
    print(y)
    return
test(1)

View Code

默认参数特点：调用函数的时候，默认参数非必须传递
用途：比如软件默认安装的路径，连接数据库的端口号

非固定参数：接受N个位置参数，转换成元组的形式

如果参数为空，就返回一个空的元组（）

def test(*arge):#参数个数不固定
    print(arge)
test(1,23,4,5,6,6,7,8,8)#arge结果变成元组，实参数目不固定，多少都可以

def test1(x,y=5,*arge):
    print(x)
    print(y)
    print(arge)
test1(1,2,4,5,6)

View Code

执行结果：

(1, 23, 4, 5, 6, 6, 7, 8, 8)
1
2
(4, 5, 6)

传的参数是字典的格式**kwargs

如果参数为空，就返回一个空的字典{}

def test(**kwarge):
    print(kwarge)
test(name = 'cathy',age = 8,salary = 1000)#传的参数是字典，个数不固定

def test(x,y= 6,*args,**kwarge):#把N个关键字参数，转换成字典的方式
    print(x)
    print(y)
    print(args)
    print(kwarge)
    print(kwarge['name'])
    print(kwarge['age'])
    print(kwarge['salary'])
test(4,8,9,0,0,name = 'cathy',age = 8,salary = 1000)#传的参数是字典，个数不固定

View Code

执行结果：

{'name': 'cathy', 'age': 8, 'salary': 1000}
4
8
(9, 0, 0)
{'name': 'cathy', 'age': 8, 'salary': 1000}
cathy
8
1000

 二、作用域，局部与全局变量

全局与局部变量

在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。

全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。

当全局变量与局部变量同名时：在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。

shopping = 'iphone X'#全局变量
def shop(shopping):
    #global shopping   #可以将函数体内的局部变量变成全局变量
    print('最初的shopping：',shopping)#打印的是全局变量的值
    shopping = 'ipad'#局部变量
    print('函数体里面的shopping：',shopping)#输出的结果是ipad,是局部变量的值

shop(shopping)
print('调用函数后shopping：',shopping)#输出的结果依旧是iphone X

View Code

执行结果：

最初的shopping： iphone X
函数体里面的shopping： ipad
调用函数后shopping： iphone X

递归

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

1. 必须有一个明确的结束条件

2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少

3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

#10除以直到除尽为止
n = 10
def fun(n):
    print(n)
    if int(n/2) == 0:
        return n
    return fun(int(n/2))
fun(n)

View Code

执行结果：

10
5
2
1

高阶函数

变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

def add(x, y, f):
    return f(x) + f(y)

res = add(3, -6, abs)
print(res)

View Code

执行结果：

9

四、内置函数

abs()	dict()	help()	min()	setattr()
all()	dir()	hex()	next()	slice()
any()	divmod()	id()	object()	sorted()
ascii()	enumerate()	input()	oct()	staticmethod()
bin()	eval()	int()	open()	str()
bool()	exec()	isinstance()	ord()	sum()
bytearray()	filter()	issubclass()	pow()	super()
bytes()	float()	iter()	print()	tuple()
callable()	format()	len()	property()	type()
chr()	frozenset()	list()	range()	vars()
classmethod()	getattr()	locals()	repr()	zip()
compile()	globals()	map()	reversed()	__import__()
complex()	hasattr()	max()	round()
delattr()	hash()	memoryview()	set()

map，reduce，filter中的function都可以用lambda表达式来生成！

 

map(function,sequence)

把sequence中的值当参数逐个传给function，返回一个包含函数执行结果的list。

如果function有两个参数，即map(function,sequence1,sequence2)。

 

例子：

求1*1,2*2,3*3,4*4

map(lambda x:x*x,range(1,5))

返回值是[1,4,9,16]

 

reduce(function,sequence)

function接收的参数个数只能为2！

先把sequence中第一个值和第二个值当参数传给function，再把function的返回值和第三个值当参数传给

function，然后只返回一个结果。

 

例子：

求1到10的累加

reduce(lambda x,y:x+y,range(1,11))

返回值是55。

 

filter(function,sequence)

function的返回值只能是True或False！

把sequence中的值逐个当参数传给function，如果function(x)的返回值是True，就把x加到filter的返回值里面。一般来说filter的返回值是list，特殊情况如sequence是string或tuple，则返回值按照sequence的类型。

 

例子：

找出1到10之间的奇数

filter(lambda x:x%2!=0,range(1,11))

返回值

[1,3,5,7,9]

 

如果sequence是一个string

filter(lambda x:len(x)!=0,'hello')返回'hello'

filter(lambda x:len(x)==0,'hello')返回''

1.abs() 取绝对值
2.all() 如果括号里所以数据为True 就返回True，否则False；
3.any() 如果括号里任意一个数据为True，就返回True；反则False；
4.ascii() ascii([1,2,"我们"]) 结果看起来是一个列表，实际上结果类型是str；
        把一个内存变成一个可打印的字符串形式。
5.bin() 把一个整数十进制转换成二进制：二进制代表：ob
6.bool() 判断True/False
7.btyearray()   把一个字符串变成一个列表可以修改，打印和修改的内容是字符对应的ascii表里边的位置；
例如：
a = bytearray("abcde",encoding="utf-8")
print (a[1])
a[1] = 50
print (a)
8.bytes() 将一个字符转换成二进制格式
9.callable() 判断括号里边参数可否被调用； print(callable([1,2,3])) 列表不可以被调用；函数可以被调用；
10.chr()  输入整数返回ascii表对应的字符 chr(97) 输出a；ord()是相反的ord(a)
11.classmethod
12.compile() 用于将python代码编译成源代码的意思
例如：
c = for i in range(10);print (i)
c = compile(code,"","exec")     #exec:代表可执行代码
exec(c)     #执行代码

修正：：：：：：：：：：：：：：：：：：；
13.complex() 负数
14.delattr() 关于面向对象的
15.dir() 查看参数有什么方法
16.divmod() 返回商和余数；divmod(5,2)
17.enumerate()
18.eval()   把字符串转成字典，有for循环、语句之类的要用exec
19.exec()
20.filter()

匿名函数：
#函数就用一次，用完就删除
def a(n):
        print(n)
a(5)
#用匿名函数写成如下：
a2 = lambda n :print(n)
a2(6)
#匿名函数只能处理简单的print或者计算，复杂的就不行了，如：
def b(n):
        print(n)
        for i in range(n):
                print(n)

#filter() 过滤想要的打印出来
#如：
res = filter(lambda n:n>5 ,range(10))   #res是一个迭代器,把大于5的全部打印出来。
print(res)
for i in res:
        print(i)

21.map() 把后边的值放到前边的数据里来处理，再接着运行；
res = map(lambda n:n*2,range(10))
#相当于[i*2 for i in range(10)]
#也可以写成:[lambda i:i*2 for i in range(10)]
for i in res:
        print(i)

22.reduce() 累加运算
import functools
res = functools.reduce(lambda x,y: x+y,range(10))
#x默认是0  y是1 ，处理x+y 将值赋值给x ，再循环第二次 x=1 y=2 在相加；依次相加赋值累加；
print(res)

23.float() 浮点数
24.format() 字符串格式化
25.frozenset() 不可变集合；a = frozenset([1,2,3,4,5,4,3,2])
26.getattr()
27.globals() 返回当前整个文件的内容 以key value形式显示；print(globals())
                        用于查看变量当前存在不存在
28.hasattr()
29.hash()   利用折半查找；非常高效；
例如：
有一个信息表：
        张三 12 男
        李四 13 女
hash会把上边的表对应生成一个对应关系：
        1   张三 。。。
        2   李四 。。。
然后再将1 2 3 4 生成一个有序的列表；

当要查找张三的时候：
        hash利用折半查找法 查找张三对应的序号；
30.help()   帮助
31.hex()    把一个数字转成十六进制
32.id() 返回内存地址
33.input() 输入
34.int()   把一个数字转成一个整形
35.isinstance()
36.issubclass() 是否是一个子类
37.iter() 转换成一个迭代器
38.len() 查看宽度
39.locals() 打印内部变量
def test():
        local_var =333
        print(locals())
test()

40.max() 返回列表里边最大值

41.memoryview()
42.min() 返回列表里边最小值
43.next() 相当于迭代器里边的__next__()
44.object  对象；在python里边一切皆对象；
45.oct()  转八进制 oct(8)  ;逢八进一
46.open()
47.pow() 返回第一个参数的第二个参数次方；pow(2,4) 返回2的4次方
48.print()
49.property
50.range()
51.repr() 用字符串表示一个对象，但是转不回去。
52.reversed() 反转
53.round() 设置保留余数位数；round(1.222.2) 输出：1.22
54.set() 集合
55.setattr()
56.slice() 切片
57.sorted() 排序
a = {6:2,8:0,1:4,-5:1,99:22}
print(sorted(a.items()))    #key 按顺序排序
print(sorted(a.items(),key=lambda x:x[1]))  #value 按顺序排序
print(a)

58.staticmethod()
59.str()
60.sum() 列表求和
61.super() 面向对象里边的继承概念
62.tuple()
63.type() 查看数据类型
64.vars() 返回一个对象的所有属性名
65.zip() 把数据对应拼一块
a = [1,2,3]
b = ["a","b","c"]
for i in zip(a,b):
        print(i)
输出：
(1, 'a')
(2, 'b')
(3, 'c')
如果a=[1,2,3,4,5,6] 按照最小的数据列表显示，也就不显示456；

66.__import__  直接导入模块里边的字符串，在不知道模块名字的情况下；
__import__("abcd")

 

转载于:https://www.cnblogs.com/cathy-cc/p/8682823.html