python done函数作用_Python基础知识：函数

1、定义函数和调用函数

#定义函数def

defgreet_user(username):'''简单的问候语'''

print('Hello,%s!'%username)

greet_user('jack')#调用函数

2、形参和实参，实参的顺序很重要

def describe_flower(flower_type,flower_color='yellow'):print("My favorite flower is %s."%flower_type)print("My favorite %s is %s."%(flower_type,flower_color))

describe_flower('rose','red')

describe_flower(flower_type='lily',flower_color='white')

describe_flower(flower_type='babysbreath')#没有提供实参的形参将调用默认值

print('----------')

3、定义一个返回字典的函数

#返回字典

def make_album(singer_name,album_name,num_of_songs=''):

info_of_album={'singer':singer_name,'album':album_name}ifnum_of_songs:

info_of_album['number']=num_of_songsreturninfo_of_album

album1=make_album('周杰伦','十一月的肖邦')

album2=make_album('许嵩','寻雾启事','12')print(album1)print(album2)

4、在函数中修改列表

defmake_great(magicians):for i inrange(len(magicians)):

magicians[i]= 'The great' +magicians[i]print(magicians)defshow_magicians(magicians):for magician inmagicians:print(magician)

mags= ['jack','alex','james']

make_great(mags)

show_magicians(mags)

5、[:]切片法创建列表副本，不改变原列表

defmake_great(magicians,new_magicians):for i inrange(len(magicians)):

magicians[i]= 'The great' +magicians[i]

new_magicians.append(magicians[i])print(new_magicians)defshow_magicians(magicians):for magician inmagicians:print(magician)

mags= ['jack','alex','james']

new_mags=[]

make_great(mags[:],new_mags)#函数调用列表副本

show_magicians(mags)

show_magicians(new_mags)

6、结合使用位置实参和任意数量实参，Python将先匹配位置实参和关键字实参，再将余下的实参都收集到最后一个形参中；*表示建立一个名为topping的空元组。

#将多余实参全部存放到空元组中

def make_sandwich(size,*toppings):print('I will make a %s-inch sandwich with the following toppings:'

%str(size))for topping intoppings:print('- %s'%topping)

make_sandwich(12,'sausages')

make_sandwich(16,'sausages','mushrooms')

7、使用任意数量的关键字实参；**表示建立一个名为user_info的空字典

#将收到的所有键-值对都封装到这个字典中

def build_profile(first,last,**user_info):

profile={}

profile['first_name'] =first

profile['last_name'] =lastfor key,value inuser_info.items():

profile[key]=valuereturnprofile

user_profile= build_profile('james','lebran',

location='shanghai',

hobby='football')print(user_profile)

8、import 调用模块中函数的几种方法

#导入整个模块，就可以使用模块中所有的函数

importfunc

func.make_car()#导入特定的函数

from func importmake_car

make_car()#调用模块中的函数,并指定别名

from func importmake_car as mc

car=mc('subaru','outback',color='blue',tow_package=True)print(car)#调用模块中所有函数

from func import *make_sandwich(16,'sausages','mushrooms')

9、%运算符，相除返回余数

#--%--运算符

number = 10

print(number%2)print(number%3)

10、运算符**表示乘方；2**3表示2的3次方

#for循环求64是2的几次方

a = 64i=0for i in range(100):

a/= 2i+= 1

if a == 1:print(i)break

#while循环求64是2的几次方

a = 64i=0whileTrue:

a/= 2i+= 1

if a == 1:print(i)break

else:continue

11、循环语句中的特殊语句

continue ：跳出本次循环；

break：跳出所有循环；

执行return之后，不再执行下面的代码，如果函数中没有return，Python将自动返回一个值None。

12、函数中的默认参数必须放到参数设置的末尾，例如def send(a,b,c="10")

13、元组动态参数*args的两种情况：

第一种：实参不带*将实参放到args这个元组中，传递给函数，无论实参是一个列表还是字符串，都将作为元组的一个元素；

第二种：实参带*，就把实参列表里的每个元素加入到元组中

def send(*args):print(args,type(args))

a= [11,22,'ddd']

send(a)

send(*a)#([11, 22, 'ddd'],) #(11, 22, 'ddd')

14、字典动态参数**args：默认将传入的参数，全部放入字典中。实参中必须包含key和value

def send(**args):print(args,type(args))

send(a=1,b=2)

dic= {'a':1,'b':2}

send(n=dic)

send(**dic)#{'a': 1, 'b': 2} #{'n': {'a': 1, 'b': 2}} #{'a': 1, 'b': 2}

15、万能参数：同时使用*args和**kwargs：顺序不能反，一个*必须放在前面

def send(*args,**kwargs):print(args,type(args))print(kwargs,type(kwargs))

send(1,2,3,a='1',b='2')#(1, 2, 3) #{'a': '1', 'b': '2'}

16、全局变量

定义全局变量默认字母全部大写；

如果想在函数中对全局变量重新赋值，需要加入global；

如果全局变量是列表或字典，函数中可以修改全局变量，比如添加删除元素。

#全局变量，任何作用域都可以读取

NAME = 'alex'

deff1():print(NAME)deff2():#修改全局变量

globalNAME

NAME= 'alice'

print(NAME)deff3():print(NAME)

f1()

f2()

f3()#alex#alice#alice

17、两个函数之间加两个空行，函数下面的波浪线就消失了，这样才符合函数的规范操作。

18、练习题：为每个函数添加注释要养成习惯，注释要放在双引号中，单引号会出现波浪线，不规范

deflogin(username,password):"""用于用户登陆

:param username: 用户输入的用户名

:param password:用户输入的密码

:return:True表示登陆成功，False表示登陆失败"""t= open('text_file\KJ', 'r')for line int:

line_list= line.strip().split('|')if username == line_list[0] and password == line_list[1]:returnTruereturnFalsedefregister(username,password):"""用于用户注册

:param username: 用户输入的用户名

:param password: 用户输入的密码

:return: 默认返回None"""t= open('text_file\KJ', 'a')

user_info= '\n' + username + '|' +password

t.write(user_info)

t.close()defmain():"""让用户选择登陆或注册"""user_input= input('1：登陆；2：注册：')if user_input == '1':

user= input('请输入账户名：')

pwd= input('请输入密码：')

user_login=login(user,pwd)ifuser_login:print('登陆成功')else:print('登陆失败')elif user_input == '2':

user= input('请输入账户名：')

pwd= input('请输入密码：')

register(user, pwd)

main()

19、lambda表达式

就是简单函数的另一种表达方式,只能有一行

=前面是函数名，：前面是参数

#def函数

deff1(a):return a + 100

#lambda表达式

f2 = lambda a,b:a + b + 100ret1= f1(10)print(ret1)

ret2= f2(10,20)print(ret2)#设置默认值

f3 = lambda a,b=10:a + b + 100ret3= f3(10)print(ret3)

20、Python内置函数

#abs( )--取绝对值

a = -1

print(abs(a))#bool( )--返回布尔值(False：0,None,"",[],(),{})

print(bool(None))#all( )--括号内接受一个可迭代的数据集，数据集中的每个元素都为真，函数的返回值才为True；

a = all([0,1,2,3])print(a)#any( )--括号内也是一个可迭代数据集，任意一个元素为真，就为真；

a = any([0,0,0,3])print(a)#ascii( )自动执行类的__repr__

className():def __repr__(self):return 'abc'n=ascii(Name())print(n)#bin()接受一个十进制，转换成一个二进制

print(bin(8))#结果为0b1000，0b为二进制标识,8的二进制为1000#oct()十进制转八进制

print(oct(9))#结果为0o11,0o标识八进制#hex()十进制转十六进制

print(hex(15))#结果为0xf，0x标识十六进制#UTF-8 一个汉字，三个字节，一个字节8位；#gbk 一个汉字，两个字节；#bytes(字符串，encoding=编码类型)把字符串转换为一个字节类型

s = "小明"

print(bytes(s,encoding='utf-8'))#b'\xe5\xb0\x8f\xe6\x98\x8e'

print(bytes(s,encoding='gbk'))#b'\xd0\xa1\xc3\xf7'#bytearray()将每个字节存储为一个数组的元素

print(bytearray(s,encoding='utf-8'))#字节类型转字符串，用同样的编码才能往回转换

n = bytes("小芳",encoding='utf-8')#字节类型

print(str(n,encoding='utf-8'))#文件操作

filename = 'text_file\cats.txt'with open(filename,'r') as f1:#只读

with open(filename,'w') as f2:#先清空文件，只写

with open(filename,'x') as f3:#文件存在，报错，不存在，创建并只写

with open(filename,'a') as f4:#追加内容#读取文件时，出现乱码，很可能是编码语言选择错误

with open('text_file\word.txt','r',encoding='gbk') as f5:

contents=f5.read()print(contents)#rb,wb,xb,ab,r+b,w+b,x+b,a+b后面带b的，表示直接以字节的方式处理

with open(filename,'rb') as f:

data=f.read()print(data,type(data))#b'\xe5\xb0\x8f\xe7\xb1\xb3\r\n' #把二进制数据添加到文件,需要bytes先转换为字符串

with open(filename,'ab') as f:

data= f.write(bytes('小芳',encoding='utf-8'))#f.seek(n)指针跳转到n指定的位置(字节)#f.write()当前指针位置开始向后覆盖，n代表字节的位置#f.tell()获取文件当前指针的字节位置#r+,既能读，又能写；如果打开模式无b，read按照字符读取，有b,按字节#无b，f.read(1)读取第一个字符，有b,读取第一个字节

with open('text_file\cats.txt','r+',encoding='utf-8') as f5:

contents= f5.read(1)print(contents)#读取第一个字：小#a+,无论你怎么调整指针位置，写入时都会写在最后#w+，先清空内容，再写入，才能读取刚才写入的内容#使用open,close,打开读写文件

f = open(filename,'r')

f.write('111')

f.close()#f.flush()强制刷入硬盘#f.readable()是否可读#f.readline()只读取一行#f.seekable()指针是否可操作#f.truncate()截断：把指针位置后面的数据都清空#for line in f: 按行循环文件对象#同时打开两个文件，最后同时关闭#例如：想把一个文件的内容修改一个人名后写入另一个文件

with open('db1','r') as f1,open('db2','a') as f2:for line inf1:

new_line= line.replace('alex','alice')

f2.write(new_line)

#将ascii码对照表里十进制转换为字母

r = chr(100)print(r)#d#将ascii码对照表里字母转换为十进制

n = ord("d")print(n)#100#random随机返回一串验证码；ascII码表里65-90为大写字母

importrandom

li=[]for i in range(4):

r= random.randrange(0,5)if r == 1 or r == 3:

num1= random.randrange(0,10)

li.append(str(num1))else:

num2= random.randrange(65,91)

li.append(chr(num2))print(li)

temp= ''.join(li)#join()把列表拼接成字符串

print(temp)#compile()编译成Python代码

s = "print(123)"r= compile(s,"","exec")#exec()执行Python代码；接受代码或者字符串，没有返回值

exec(r)#eval()将字符串转换成Python代码，并获取结果#函数只能执行表达式代码

r = "8*8"ret=eval(r)print(ret)#dir()快速查看一个对象提供了哪些功能

print(dir(random))#help()查看对象提供的详细功能#divmod()接受两个整数，得到商和余数#第一种，可以将返回值赋给两个变量

a,b = divmod(97,10)print(a,b)#第二种，可以当成一个元组

n = divmod(98,10)print(n[0])print(n[1])#判断对象是否是某个类的实例

r = "abc"

print(isinstance(r,str))#True

'''filter(函数，可迭代的对象)，循环第二个参数，

对参数的每一个元素执行函数，如果函数返回True,

就把这个元素加入结果，否则就舍弃'''

deff(a):if a >2:returnTrue

li= [1,2,3,4]

ret=filter(f,li)print(list(ret))#记得要以列表的形式输出#以lambda表达式实现

ret = filter(lambda a:a>3,li)print(list(ret))'''map(函数，可迭代的对象),循环第二个参数，

对参数的每一个元素执行函数,将函数返回值存放到结果'''li= [1,2,3]

ret= map(lambda a:a+100,li)print(list(ret))#[101, 102, 103]#globals()返回所有全局变量#locals()返回所有局部变量#hash()返回一个对象的hash值，一般用于存储字典的key#id()查看内存地址

s = "sss"

print(id(s))#327689119312#issubclass()判断一个类是否是另一个类的子类#Python2中字符长度按字节来算，3中按字符来算#len('小明')2中返回6，3中返回2#pow(2,10)求2的10次方#rount()四舍五入#slice()切片#zip()将列表的相同索引的值放到一个元组中

l1 = ['a',1,2]

l2= ['b',1,2]

l3= ['c',1,2]

r=zip(l1,l2,l3)

ret=list(r)[0]print(' '.join(ret))

21、装饰器：@函数名

本质上就是函数，功能是为其他函数添加附加功能，前提是不改变装饰函数的源代码和调用方式；

高阶函数+函数嵌套+闭包

高阶函数：函数的参数或者返回值是一个函数名

函数嵌套：在函数内部定义函数

闭包：在一个作用域里放入定义变量，相当于打了一个包

@函数名 是python的一种语法糖

#函数名可以当做参数传递

deff1():print(123)deff2(xx):

xx()

f2(f1)#123#装饰器@+函数名，有两个功能：#1、自动执行outer函数并将其下面的函数名f1当做参数传递#2、将outer函数的返回值重新赋值给f1=inner#3、万能参数*args,**kwargs,接受任何数量的参数

defouter(func):def inner(*args,**kwargs):print("before")

r= func(*args,**kwargs)print("after")returnrreturninner

@outer #相当于f1=outer(f1)，返回的是inner的内存地址f1=inner，然后f1(args)执行inner(args)函数deff1(args):print(args)return "fff" +args

ret= f1("ddd")#其实是在运行inner函数，最终得到inner函数的返回值print(ret)

22、生成器，有两种表达方式

生成器表达式：m=(i for i in range(10))    m.__next__()

生成器函数：其实就是由函数改造而来，具有生成能力的函数，标识：函数内部有yield，相当于return，但是可以执行多次

deffunc():print(111)yield 1

print(222)yield 2ret= func()#得到一个生成器

print(ret)##进入函数执行函数，直到遇到yield，获取yield后面的数据，输出

r1 = ret.__next__()print(r1)#111，1

r2 = ret.__next__()print(r2)#222，2

#利用生成器创造一个循环函数

defmyrange(arg):

start=0whileTrue:if start >arg:return

yieldstart

start+= 1ret= myrange(3)

r= ret.__next__()print(r)

r= ret.__next__()print(r)

23、迭代器：就是一个封装了调用函数__next__的循环，让我们不用一步一步调用__next__函数

凡是可作用于for循环的对象都是Iterable类型(可迭代对象)；

凡是可作用于next()函数的对象都是Iterator类型(迭代器对象)，它们表示一个惰性计算的序列；

生成器都是Iterator对象，生成器不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到最后抛出StopIteration错误表示无法继续返回下一个值了

集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。

Python的for循环本质上就是通过不断调用next()函数实现的；

24、递归：自己调用自己

#递归应用于用户重复登录

deflogin():

inp= input("输入姓名")if inp == "admin":print("success")else:returnlogin()

login()

#递归实现从1循环加到7

defadd(n):

n+= 1

if n <7:returnadd(n)else:returnn

r= add(1)print(r)#7#递归实现1*2*3*4*5*6*7=5040

defmul(m,n):

n+= 1m*=nif n < 7:returnmul(m,n)returnm

ret= mul(1,1)print(ret)#5040#另一种方法

deffunc(num):if num == 1:return 1

return num * func(num-1)

ret= func(7)print(ret)

练习：递归实现斐波那契数列 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946，17711，28657，46368

deffib(max):

n, a, b= 0, 0, 1

while n

a, b= b, a +b

n= n + 1

return 'done'

25、反射

利用字符串的形式去对象(模块)中(寻找/检查/删除/设置)成员

getattr()寻找、hasattr()检查、delattr()删除、setattr()设置

通过字符串导入模块：

obj = __import__("xxx")

obj = __import__("file.xxx", fromlist=True)

deffunc():

inp= input("请输入你要访问的URL(模块名/函数名)：")#hasattr()检查对象中是否包含该成员，是返回True

m, h = inp.split("/")#__import__通过字符串导入模块,obj.func()调用函数

obj = __import__(m)#如果模块在文件夹中,后面加个参数fromlist,意思是按前面的指定路径导入

#obj = __import__("lib." + m, fromlist=True)

ifhasattr(obj,h):#getattr()获取对象中的成员

func =getattr(obj,h)

func()else:print("404")

26、解压序列

a,b,c=(1,2,3)

a=1b=2c=3

#取开头和结尾的值

l=[1,2,3,4,5]

a,*_,b=l

a=1b=5

#*加一个变量，可以是任意字符，表示中间的所有值

27、冒泡算法

需求：请按照从小到大对列表 [13, 22, 6, 99, 11] 进行排序

思路：相邻两个值进行比较，将较大的值放在右侧，依次比较！

li = [13, 22, 6, 99, 11]deffunc(arg):for i in range(1,len(arg)):for m in range(len(li) -i):if arg[m] > arg[m+1]:

arg[m],arg[m+1] = arg[m+1],arg[m]print(arg)

func(li)

28、列表转字典

status_choice = [(1, '上线'), (2, '下线')]

status_list= list(map(lambda x:{'id':x[0],'name':x[1]},Video.status_choice))