Python之函数

简介:

定义函数:

def xx():  

  print("xxx")

执行函数

xx()

函数返回值:

def emile():
    print("发邮件")
    return '123'
r = emile()
print(r)

结果:
发邮件
123

上述中,return为返回值,返回给r。return想返回什么就返回什么,如果没有写返回值,就返回None,就是空。

def emile():
    if True:
        return True
    else:
        return False
ret = emile()

if ret:
    print('好的')
else:
    print('滚')

结果:
好的

函数的普通参数:

def i1(p,q,r):    #p,q,r为形参
    print(p,q,r)    #打印出p,q,r的值    
    return True    #返回True
ret = i1('11',[22,11],'33')      #i1里面的为实参,是按照顺序给形参值
print(ret)

结果:
11 [22, 11] 33
True

如果实参不是按照顺序给形参值的情况:(在实参内指定就行了)

def i1(p,q,r):
    print(p,q,r)
    return True
ret = i1(q = '11',p = [22,11],r = '33')
print(ret)

结果:
[22, 11] 11 33
True

函数的默认值:

temp = ""
def drive(name="小七"):  #这里的name = "小七",就是函数默认值,当函数没有给name实参时,就会用默认值。注意默认值,都会放在形参的最后的位置。
    temp = name + "开车"
    return temp

ret = drive("小二")
print(ret)

ret = drive("小三")
print(ret)

ret = drive()
print(ret)

结果:
小二开车
小三开车
小七开车

函数的动态参数: 

动态参数一(*a):

def i1(*args):     #保存为元组
    print(args)
    
i1(12,33,44,55)    #实参能够全部传给a

结果:
(12, 33, 44, 55)

动态参数二(**a):

def i1(**kwargs):    #保存为字典形式
    print(kwargs)

i1(k1 = 123, k2 = 234)      #实参全部传给a

结果:
{'k1': 123, 'k2': 234}

动态参数形式结合(万能参数):

def i1(p,*args,**kwargs):
    print(p)
    print(args)
    print(kwargs)

i1(11,22,33,43,k1 = 123, k2 = 234)

结果:
11
(22, 33, 43)
{'k1': 123, 'k2': 234}
def i1(**kwargs):
    print(kwargs,type(kwargs))
dic={"k1":123,"k2":345}
i1(**dic)

结果:
{'k1': 123, 'k2': 345} <class 'dict'>

全局变量与局部变量:

全局变量要大写,局部变量要小写。

深浅拷贝:

对于int和str来说,深浅拷贝都是一样的,都能拷贝完整。

对于其他,浅拷贝只拷贝最外面一层,深拷贝除最内层都要拷贝。

import copy
i1 = "123avc"
i2 = copy.copy(i1)      #浅拷贝
i3 = copy.deepcopy(i1)    #深拷贝
print(i2)
print(i3)

结果:
123avc
123avc

lambda表达式:

def func1():
    return 123
i = func1()
print(i)

f2 = lambda :123
i1 = f2()
print(i1)

结果:
123
123
def func1(a1,a2):
    return a1+a2
i = func1(11,22)
print(i)

f2 = lambda a1,a2: a1+a2
i1 = f2(11,22)
print(i1)

结果
33
33

Python的内置函数: 

abs()    取绝对值

def func1(a1,a2):

    i2 = abs(a1+a2)
    print(i2)

i = func1(-11,-22)

结果:
33

type()    查看对象类型

all()    循环参数,如果每个元素都为真,那么就返回真,只要有一个为假都返回False(假:0,None,空字符串,空列表,空元组,空字典)

any()    循环参数,只要有一个元素是真就返回真(True)

ascii(对象)    对象的类中找_repr_功能,获取其返回值

class Foo:
    def __repr__(self):
        return "hello"
    
obj = Foo()
r = ascii(obj)
print(r)

结果:
hello

bin()    二进制

oct()    八进制

int()    十进制

hex()    十六进制

#!/bin/bash/env python
# -*- coding:utf-8 -*-
#functio:二进制改为十进制

i = int("0b11",base=2)    #其他进制之间的转换也一样,注意base的作用
print(i)

结果:
3

boll()    判断真假,把一个对象转换为布尔值

bytes()    字节(和bytearray类似于str和list的关系)  bytes("xxx",encoding="utf-8")

bytearray()    字节列表

chr()    输入一个数字找到相对应的字符(参照ascii表,数字找到对应的字符)

ord()    接受一个字母找到对应的数字(只使用于ascii码)

实现随机验证码:(应用到chr()--这个是对照ascii表和str())

import random

tmp = ""
for i in range(6):
    num = random.randrange(0,4)
    if num == 1 or num == 3:
        rad2 = random.randrange(0,10)
        tmp = tmp + str(rad2)
    else:
        rad1 = random.randrange(65,91)
        c1 = chr(rad1)
        tmp = tmp + c1

print(tmp)

flush()    使对象立即保存在硬盘中

callable()    检查输入对象是否可以执行(如果命令加()表示该命令可以被执行)

complie()    编译对象,使之能成为python可以执行的代码

divmod()    求除数的商和余数

i1 = 10/3
print(i1)
i2 = divmod(10,3)
print(i2)

结果:
3.3333333333333335
(3, 1)

enumerate()   自动生成一列,默认从0开始自增1,也可以自己指定字符串转换成数字int(字符串)

i1 = ["you","i","she","he"]
for key,item in enumerate(i1):
    print(key,item)

结果:
0 you
1 i
2 she
3 he

eval()    (做表格汇总)执行一个字符串形式的表达式

i1 = eval("1 + 3")
print(i1)

结果:
4

filter(函数,可迭代对象)    循环可迭代的对象,获取每一个参数(函数),筛选功能

ret = filter(lambda x:x > 22,[11,22,33,44])
for i in ret:
    print(i)

结果:
33
44

map(函数,可迭代对象)    

def func1(x):
    return x + 100
ret = map(func1,[1,2,3,4,5])
print(ret)
for i in ret:
    print(i)

结果:
<map object at 0x000000000260B2B0>
101
102
103
104
105

globals()    获取全部的全局变量

locals()    获取全部的局部变量

hash()    获取哈希值(为了节省内存,而且快速找到,优化key

isinstance()    判断某个对象是否由某个类创建的

issubclass()    判断是否是子类

iter()    next()

obj = iter([11,22,33,44])
print(obj)
r1 = next(obj)
print(r1)
r2 = next(obj)
print(r2)

结果:
<list_iterator object at 0x000000000291B1D0>
11
22

max()    取最大值

min()    取最小值

pow()    求幂

round()    四舍五入

sum()    求和

sorted()    排序:(想要排序必须是同一种类型,比如都是数字)字符串比较,先比第一个字符,以后一个一个比,然后排序

i1 = [11,22,11,33,22,44,55,66,]
new_list = sorted(i1)
print(new_list)

结果:
[11, 11, 22, 22, 33, 44, 55, 66]

打开文件的模式有:

默认是只读模式

r:只读模式(默认)

w:只写模式(不可读,不存在创建键;存在则清空内容)

x:只写模式(不可读,不存在创建键,存在则报错)

a:追加模式(不可读,不存在创建键,存在则只追加内容)

+表示可以同时读写某个文件:

r+:读写(可读,可写)

w+:写读(可读,可写) 先清空,再写之后就可以读了

x+:写读(可读,可写和上面差不多)

a+:写读(可读,可写)  打开同时,指针已经到最后了,写时追加,放在最后

b表示以字节的形式操作:

rb  或r+b

wb  或w+b

xb  或x+b

ab  或a+b

f = open('cai.log','r',encoding="utf-8")
i1 = f.read()
f.close()
print(i1)

结果:
中国

基本打开:

#1、只读r
i1 = open('cai.log','r')
i2 = i1.read()
i1.close()
print(i2)

#2、w,只写模式,清空原来的内容,重新输入,文件不存在则创建
i3 = open('cai.log','w')
i4 = i3.write('111')
i3.close()

#3、x,只写模式,原来有内容则报错
i5 = open('cai.log','x')
i6 = i5.write('222')
i5.close()

#4、追加模式,追加在末尾
i1 = open('cai.log','a')
i2 = i1.write('222')
i1.close()

以字节(二进制)的方式打开:

①只读,rb

②只写wb

关闭:

with open("cai.log","r") as f:

  f.read()

执行过后自己关闭,不需要close

Python2.7之后,with可以同时支持打开两个文件:

with open("log1") as obj1,open("log2") as obj2:

  pass

 不需要消耗很大的内存的复制

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏思考的代码世界

Python基础学习05天

15450
来自专栏尚国

PHP反序列化漏洞

这里你可以看到, 我代码里的类定义为: class F, 这个序列化就是 F, 我定义变量名字是filename, 它这里也是 filename, 我们可以修改...

12320
来自专栏闪电gogogo的专栏

Python入门学习(二)

1 字典 1.1 字典的创建和访问 字典不同于前述的序列类型,它是一种映射类型。它的引入是为了简化定义索引值和元素值存在特定关系的定义和访问问题。 字典的定义形...

32780
来自专栏小樱的经验随笔

C/C++中inline用法详解

(一)inline函数(摘自C++ Primer的第三版) 在函数声明或定义中函数返回类型前加上关键字inline即把min()指定为内联。       in...

28730
来自专栏前端进阶之路

JS学习系列 06 - 变量对象

上一节我们讨论了执行上下文,那么在上下文中到底有什么内容,为什么它会和作用域链扯上关系,JS 解释器又是怎么找到我们声明的函数和变量,看完这一节,相信大家就不会...

12020
来自专栏Python自动化测试

python的set集合学习(七)

在python中,set集合是一个无序并且不重复的元素集合,它的关键字是set,依然按照之前的思维方式,我们定义一个set集合,来看它的类所具备的功...

14030
来自专栏程序你好

在C#中用Var 和 Dynamic声明变量的区别

C#中的很多关键词用法比较容易混淆,var和dynamic就是其中一组,但其实它们是有本质的区别的。

8410
来自专栏pangguoming

理解闭包 js回收机制

为什么要有回收机制?why? 打个比方,我有一个内存卡,这个内存是8G的,我把文件,视频,音乐,都保存到了这个内存卡,随着我的储存的内容越来越多,这个内存卡已经...

45570
来自专栏Phoenix的Android之旅

动态代理-进阶高级开发必学技能

关于代理模式的话题有很多, 在开发中经常用到的应该是静态代理模式,能很好的去耦合。 动态代理是代理模式的另外一种实现。

9630
来自专栏python3

python3--中一些常见的坑(机制上的问题)

重点:在循环一个列表时,最好不要进行删除的动作(一旦删除,索引会随之改变),容易错误。

8110

扫码关注云+社区

领取腾讯云代金券