美文网首页Python
Python基础篇之函数

Python基础篇之函数

作者: 山水墨阳 | 来源:发表于2019-12-23 00:30 被阅读0次

函数是具有特定功能可重复利用的代码块,有名字、参数(可选)、返回值(可选),又叫做方法。本篇介绍函数的定义、函数的参数、函数的返回值、函数的调用及Python内置函数。

云时代怎能没有云服务器,让应用飞起来吧

函数的定义

1、函数通过def关键字定义,def是define的缩写;
2、函数名称是一个有效的标识符;
3、函数名后面是一个括号,内部可传入0到多个参数,逗号隔开;
4、函数内容以冒号开始并缩进;
5、return 关键字结束函数并返回。没有return 默认返回None;
形如:

#a,b两个参数必须是相同类型且可加的
def getAdd(a,b):
    "返回两个数的最大值"
    return a+b

这里的getAdd为函数名,括号内a,b为两个参数。

函数的参数

函数括号内的参数可有可无,参数不用申明具体数据类型(Python中的变量都不用申明特定的类型,Python自动识别),多个参数用逗号隔开。函数名称括号内的参数为形参,传入的实际值为实参。

函数的返回值

函数的返回值为前面提到的七大基本类型:数字(Number 包括:int-整型,long-长整型,float-浮点型,complex-复数)、字符串(str)、列表(list)、集合(set)、元组(tuple)、字典(dict)、None。

函数的调用

函数的调用在可用的情况下直接使用其函数名,传入对应的参数,有返回值的用变量接受返回值即可。注意:这里的可用的情况是条件的,同一个脚本文件中的函数在本脚本中可直接使用,其他的脚本中申明的函数需要引入模块后才能直接使用。

#调用函数
c = getAdd(1,2)
print(c)#输出3
c = getAdd('darker','wang')
print(c)#darkerwang

Python内置函数

Python中封装了常用的基本内置函数,整理如下:

0、输入输出函数

x = inpupt("请录入:")#等待录入数据,赋值给x
print(x)#打印录入的数据

1、数据类型函数

原始七大数据类型对应的构造函数

x = int(1)# 构造一个整型对象
print(type(x)) #输出为 <class 'int'>
print("x="+str(x))#输出为 x=1

'''
long() python2函数,python3已弃用,python3只有int
如果int内参数溢出python3自动构造成一个长整型
'''

x = float()#构造一个浮点型对象
print(type(x)) #输出为 <class 'int'>
print("x="+str(x))#输出为 x=1

x = complex()#构造一个复数对象
print(type(x)) #输出为 <class 'float'>
print("x="+str(x))#输出为 x=0.0

x = bool()#构造一个布尔对象
print(type(x)) #输出为 <class 'complex'>
print("x="+str(x))#输出为 x=0j

x = list()#构造一个列表对象
print(type(x)) #输出为 <class 'bool'>
print("x="+str(x))#输出为 x=False

x = set()#构造一个集合对象
print(type(x)) #输出为<class 'set'>
print("x="+str(x))#输出为 x=set()

x = dict()#构造一个字典对象
print(type(x)) #输出为 <class 'dict'>
print("x="+str(x))#输出为 x={}

x = str()#构造一个字符串对象
print(type(x)) #输出为 <class 'str'>
print("x="+str(x))#输出为 x=

x = tuple()#构造一个元组对象
print(type(x)) #输出为 <class 'tuple'>
print("x="+str(x))#输出为 x=()

2、非数据类型函数

  • abs()
    绝对值,用于获取某个数的绝对值。
x = abs(-1)
print(x)#输出1

  • all()
    判断可迭代参数是否全为真(非0或False),是则返回True,否则返回False。
    可理解为:所有元素都为真则真。
    注意:可迭代参数为空时不含0或False,也返回True。
x = list()
print(x.__len__())#输出长度0
print(all(x))#无元素,返回True
x.append(0)#添加一个0元素,
print(all(x))#有一个0元素,返回False
x.append(False)#添加一个False元素
print(all(x))#有False元素,返回False
x[0]=1#第一个元素重新赋值为1,非0
print(x)#打印目前x [1,False]
print(all(x))#还有一个False元素,返回False
x[1]=True#将第二个False元素赋值为True
print(all(x))#没有0或者False元素,返回True
print(x)#打印最终x [1,True]

  • any()
    判断可迭代参数是否含有真值(非0),是则返回True,否则返回False。
    可理解为:任何一个元素是真则真。
    注意:可迭代参数为空时没有一个是真,返回False。
x = list()
print(any(x))#x元素为空,没有任何一个为真(非0或False),返回False
x.append(0)#添加一个0(False)
print(any(x))#没有一个为真,返回False
x.append(True)#添加一个True
print(x)#打印此时x [0,True]
print(any(x))#x 有一个为真,返回真(True)

x[0] = 1#第一个元素为非0(真)
x[1] = False#第二个元素为否
print(x)#打印此时x[1,False]
print(any(x))#x有一个为真,返回真(True)

x[0] = 1#第一个元素为真(非0)
x[1] = 2#第二个元素为真(非0)
print(x)#打印此时的x[1,2]
print(any(x))#两个元素都为真(非0),返回真(True)

x[0] = 0#第一个元素为0
x[1] = -1#第二个元素为非0
print(x)#打印此时x[0,-1]
print(any(x))#有一个元素为真(非0),则返回True

  • isinstance()
    判断两个类型是否一致,是则返回True,否则返回False,与type()类似

isinstance() 与 type() 区别:
type() 不会认为子类是一种父类类型,不考虑继承关系。
isinstance() 会认为子类是一种父类类型,考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。


  • basestring()
    str 和 unicode 的超类,不能直接使用,可用于类型判断类型
from pip._vendor.pyparsing import basestring
x = "2232"
print(isinstance(x,basestring))
print(isinstance(x,str))
  • bin()
    二进制函数,将对应的数值参数转为二进制
    注意:参数必须是整型,否则会报TypeError
print(bin(0))#输出 0b0
print(bin(1))#输出 0b1
print(bin(-122))#输出 -0b1111010

bool()
将参数转为布尔值,参数非0即True

print(bool(0))#输出False
print(bool(-1))#输出True
print(bool(1))#输出True
print(bool(1.2))#输出True
print(bool('abc'))#输出True
  • bytearray()
    返回一个元素可变的新的字节数组类。
    可理解为:将目标转为字节数组类
    注意:如果没有输入任何参数,默认就是初始化数组为0个元素。

形如:class bytearray([source[, encoding[, errors]]])
如果 source 为整数,则返回一个长度为 source 的初始化数组;
如果 source 为字符串,则按照指定的 encoding 将字符串转换为字节序列;
如果 source 为可迭代类型,则元素必须为[0 ,255] 中的整数;
如果 source 为与 buffer 接口一致的对象,则此对象也可以被用于初始化 bytearray。

x = bytearray(4)
print(x.__len__())#单个数字时生成一个指定长度为4的元素都为0的新数组
print(x)#输出 bytearray(b'\x00\x00\x00\x00')
x = bytearray([1,2,4])#数组时长度为新数组长度3
print(x.__len__())#长度为原数组长度
print(x)#输出 bytearray(b'\x01\x02\x04')
x = bytearray('abc','utf-8') #输出 bytearray(b'abc')
print(x.__len__())#数组新数组长度3
print(x)#输出 bytearray(b'abc')

  • cmp()
    phthon2中比较两个对象的大小, x<y返回-1,x=y 返回0,x>y 返回1
    python3.4.3 以上的版本中已经没有cmp函数,被operator模块代替,使用时需要导入模块。operator模块中还有很多与比较相关的函数
import operator
print(operator.eq(1,3))#equal 判断两个参数是否相等
print(operator.ne(1, 3))#not equal 判断两个参数是否不相等
print(operator.gt(1, 3))#great than 判断大于
print(operator.ge(1, 3))#great equal 大于等于
print(operator.le(1, 3))#little equal 小于等于
print(operator.lt(1,3))#little than 小于

  • compile()
    将一个字符串的可执行代码编译为字节代码
    compile(source, filename, mode[, flags[, dont_inherit]])

参数
source 字符串或者AST(Abstract Syntax Trees)对象。。
filename 代码文件名称,如果不是从文件读取代码则传递一些可辨认的值。
mode 指定编译代码的种类。可以指定为 exec, eval, single。
flags 变量作用域,局部命名空间,如果被提供,可以是任何映射对象。
flags和dont_inherit是用来控制编译源码时的标志

str = "print('hello world')" 
c = compile(str,'','exec')   # 编译为字节代码对象 
print(c)
exec(c)#执行字节代码

'''
打印内容
<code object <module> at 0x0000000002162810, file "", line 1>
hello world
'''
exec("print('hello world')")#直接exec(字符串的代码)也能正常执行

  • callable()
    检查一个对象是否是可调用,是则返回True否则返回False
    可理解为:函数、方法、lambda 函式、 类以及实现了 call 方法的类实例, 它都返回 True
    注意:具体字符串与数值不是对象
#自定义一个函数
def testFun():
    print('test')

print(callable(0))#不是对象,函数,返回False
print(callable('abc'))#不是对象,函数,返回False
print(callable(str))#可用函数,返回True
print(callable(exec))#可用函数,返回True
print(callable(testFun))#可用函数,返回True

s = str("abc")#申明一个对象,
print(callable(s))#可用对象,返回True

#自定义一个没有实现__call__()方法的类    
class A(object):
    def aFun(self):
        print("A.aFun")
print(callable(A))#是一个类,返回True
a = A()#申明一个类实例
print(callable(a))#类对象没有实现__call__返回False
#自定义一个实现纳__call__()方法的类    
class A(object):
    def __call__(self):
        print("A.__call_")
print(callable(A))#是一个类,返回True
a = A()#申明一个类实例
print(callable(a))#类对象实现__call__返回True

  • chr() / ord()
    chr 返回数字对应的字符,参数0-256内的某个16进制,10进制的数值
    ord 返回对应的 ASCII 数值
print(chr(48))#输出48对应的字符 0
print(chr(49))#输出49对应的字符1
print(chr(97))#输出97对应的字符a
print(chr(98))#输出98对应的字符b

print(ord("a"))#输出97
print(ord("1"))#输出49

  • classmethod / staticmethod
    classmethod 声明为类方法,修饰符对应的函数不需要实例化
    可理解为:静态方法,类名直接调用 与java 的 public static 声明类似
    注意:使用形式为@classmethod
    staticmethod 声明为静态方法,该方法不强制要求传递参数
    注意:使用形式为@staticmethod
#自定义一个类
class A(object):
    
    #自定义方法
    def add(self,a,b):
        return a+b
    
    #自定义方法,声明为类方法
    @classmethod
    def getClassName(self):
        return 'A'
    
a = A()#实例化类
print(a.add(1, 2))#实例化调用,输出3
print(a.getClassName())#实例化调用,输出A
print(A.getClassName())#类直接调用,输出A
print(A.add(1, 2))#类直接调用,该方法未声明为类方法执行出错
class A(object):
    @staticmethod
    def method1():
        print('method1')
    
    @classmethod
    def method2(self):
        print("method2")

A.method1()
A.method2()

  • delattr()
    用于删除类中的属性
    注意:必须是类且属性存在
#创建一个测试类
class ClassA(object):
    a = 'A'#属性a
    b = 'B'#属性b
#实例化对象
ca = ClassA()
print(ca.a)#打印ca对象的属性a,值为A
delattr(ClassA,'a')#删除类的属性a
print(ca.a)#属性已被删除,报错AttributeError: 'ClassA' object has no attribute 'a'

  • dir()
    不带参数返回当前范围内的变量,变量包括,属性,方法等构造元素
    指定参数返回指定参数对应范围内的变量
    可理解为:显示一个文件或者类的所有构造元素
class ClassA(object):
    a = 'A'
    b = 'B'
    c = "123"

ca = ClassA()
print(dir())#当前变量
print(dir(ca))#制定ca对象的变量

  • divmod()
    把除数和余数运算结果结合起来,返回一个包含商和余数的元组
    注意:返回的元组第一个是商,第二个是余数
x = divmod(7, 2)
print(x)# 输出(3,1)

-enumerate()
将一个可遍历的数据对象(列表,元组,字符串等)组合成一个索引-值序列
注意:一般用于for循环 【常用】
语法:enumerate(sequence, [start=0])
参数:sequence 可遍历对象,可选参数start 下标起始位置,默认0

lists = ['Spring', 'Summer', 'Fall', 'Winter']
for i,v in enumerate(lists):
    print('index='+str(i)+" value="+v)#这里k是下标

idict = {'a':"darker","b":"wang","c":"godbirds"}

#1、直接编列字典
for i,v in enumerate(idict):
    print('index='+str(i)+" value="+str(v))#这里k是下标 ,v是key的值
    
#2、遍历其建
for i,v in enumerate(idict.keys()):
    print('index='+str(i)+" value="+str(v))#与1、同
    
#2、遍历其元素
for i,v in enumerate(idict.items()):
    print('index='+str(i)+" value="+str(v))#这里k是下标,v是内部元素(元组展示)

#3、一般遍历字典我们用如下方法
for i,v in idict.items():
    print('index='+str(i)+" value="+str(v))#这里k是元素的键,v是元素的值

  • eval()
    执行一个字符串表达式,并返回其值
    注意:与exec的区别,exec是执行一个python语句,eval是表达式【常用】
print(eval('1+2'))    #输出3
exec('print(eval("1+2"))')#执行一个语句输出3

  • execfile()
    执行一个python脚本文件【常用】
execfile('hello.py')#hello.py是编写好的一个文件

  • filter()
    用于过滤序列,过滤掉不符合条件的元素,返回一个迭代器对象,如果要转换为列表,可以使用 list() 来转换过滤后的对象。
    注意:该方法接收两个参数,第一个为函数,第二个为序列,序列的每个元素作为参数传递给函数进行判,然后返回 True 或 False,最后将返回 True 的元素放到新列表中。过滤函数根据需求灵活编写运用。
    语法:filter(function, iterable)
#自定义一个函数:判断是否是素数
def is_prime(n):
    if n == 1:
        return False
    for i in range(2,n//2+1):
        if n % i == 0:
            return False
    return True
 
tmplist = filter(is_prime, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10,11,12,13,14,15,16,17])
newlist = list(tmplist)
print(newlist)

  • format()
    格式化字符串的函数,str.format(value)。
    语法:通过"{}"或者":"来格式化目标
    注意:参数个数大于等于待格式化目标数
#1、通过参数索引地址格式化赋值
x = "{} {}".format("hello", "world") # 不设置指定位置,按默认顺序
print(x)#输出 hello,world
x = "{0},{0}".format("hello","world")#制定索引位置
print(x)#输出hello,hello
x = "{0},{1}".format("hello","world")#制定索引位置
print(x)#输出hello,world

#2、通过默认从参数格式化赋值
x = "姓名:{name},年龄:{age},性别:{sex}".format(name="Darker", age="18",sex="男");
print(x)#输出 姓名:Darker,年龄:18,性别:男

#3、按字典的键进行格式化赋值
idict = dict({"name":"Darker","age":"18","sex":"男"})
x = "姓名:{name},年龄:{age},性别:{sex}".format(**idict);
print(x)#输出 姓名:Darker,年龄:18,性别:男

#4、数字格式化 『:.2f』 冒号后面制定精度格式
x = "{:.2f}".format(0.33333333)#待小鼠点
print(x)#输出0.33
x = "{:.0f}".format(0.33333333)#不带小数点
print(x)#输出0,不带小数点会四舍五入

  • frozenset()
    返回一个冻结的集合,冻结后集合不能再添加或删除任何元素。
    可理解为:返回一个冻结不让修改的集合,原集合不变
list1 = [1,2,3]
list2 = frozenset(list1)
list1.append(4)#原始集合未冻结,可操作
print(list1)#输出:[1,2,3,4]
#报错:AttributeError: 'frozenset' object has no attribute 'append'
list2.append(5)#list2为冻结集合,不能修改

  • getattr()/setattr()
    getattr用于获取一个对象属性值。等价于getXXX方法,getattr(object,name)。
    setattr用于设置一个对象属性值。等价于setXXX方法,setattr(object,name,value)。
class Person(object):
    name = "Darker"
    age = 18
    sex = "男"

o = Person()
x = getattr(o,"name")
print(x)#输出Darker
print(getattr(o, "age"))#输出18
setattr(o,"age",28)#重新设置属性值
print(getattr(o,"age"))#输出28

  • globals() / locals()
    返回当前位置的全部全局变量,字典方式展示(接收)。
    注意:与dir()的区别,dir是返回对象的属性,列表方式展示(接收)
    注意:与locals()的区别,locals返回的是局部变量。
class Person(object):
    name = "Darker"

print(globals())
print(dir())
print(locals())

  • hasattr()
    于判断对象是否包含对应的属性,即属性是否存在
    注意:在获取属性或者设置属性之前判断一下属性是否存在可用此方法
class Person(object):
    name = "Darker"
obj = Person()
print(hasattr(obj, "name"))#输出True
print(hasattr(obj, "sex"))#输出False

  • hash()
    获对象(字符串或者数值等)的哈希值。
class Person(object):
    name = "Darker"
obj = Person()
print(hash(obj))
print(hash(1))
print(hash("abc"))

  • help()
    用于查看函数或模块用途的详细说明。
help(hash)#输出如下图

#自定义一个类
class Person(object):
    '''
    自定义的一个函数
    '''
    name = "Darker"
    
help(Person)#输出如下图
图片.png
  • hex() / oct()
    hex将数值参数转换为16进制
    oct将数值参数转换为8尽职
    注意:参数只能是数值否则会报:TypeError: 'str' object cannot be interpreted as an integer
print(hex(1))#输出:0x1
print(oct(1))#输出:0o1
print(hex(10))#输出 :0xa
print(oct(10))#输出:0o12

  • id()
    用于获取对象的内存地址。从下可以看出,数值时数值的地址是一样的,修改后地址发生改变,方法内部修改形参,实参地址不变,值不变(除非生命全局变量)
a = "1"
b = 1
d = [1,2,3]
print(id(a))#打印a的地址:30510528
print(id(b))#打印b的地址:1797680144
print(id(d))#打印d的地址:39341128
print(id(d[0]))#打印d[0]的地址: 1797680144
def modify(x):
    x = "10"
    return x
modify(a)#修改a的值
print(id(a))#打印a的地址:30510528
modify(d[0])#修改d[0]的值
print(id(d))#打印d的地址:39341128
print(id(d[0]))#打印d[0]的值: 1797680144

a = "abc"
print(id(a))#30768744

  • isinstance() / type()
    判断一个对象是否是一个已知的类型,类似 type()
    isinstance 会认为子类是一种父类类型,考虑继承关系。
    type 不会认为子类是一种父类类型,不考虑继承关系
class A:
    pass

 #B继承A
class B(A):
    pass
 
isinstance(A(), A)    # returns True
type(A()) == A        # returns True
isinstance(B(), A)    # returns True
type(B()) == A        # returns False

  • issubclass()
    判断是否是继承关系
class A(object):
    pass

class B(A):
    pass

class C(object):
    pass

print(issubclass(B,A))#B是A的继承,输出True
print(issubclass(A,B))#A是B的集成,输出False
print(issubclass(C,A))#C是A的集成,输出False
print(issubclass(C,object))#C是object的继承,输出True

  • iter()
    用来生成对象的一个迭代器,一般用在for循环中
    语法:iter(object[, sentinel])
    参数:object-支持迭代的集合,sentinel- 如果传递了第二个参数,则参数 object 必须是一个可调用的对象(如,函数),此时,iter 创建了一个迭代器对象,每次调用这个迭代器对象的__next__()方法时,都会调用 object。
lst = [1, 2, 3]
for i in iter(lst):
    print(i)

  • len()
    返回对象(字符、列表、元组等)长度或项目个数
lst = [1, 2, 3]
x = "abcd"
print(len(lst))#输出3
print(len(x))#输出4

  • map()
    根据提供的函数对指定序列做映射。与iter用法相同
    语法:map(function, iterable, ...)
    参数:function 映射到具体函数,返回对应的值,iterable迭代对象
def mapping(x):
    if x == 1:return "男"
    if x == 0:return "女"
    else: return "未知"
    
lst = [1,2,3,1,3,2,2,1]
x = map(mapping,lst)#次数为一个类,因为mapping中换了返回值的类型
x = list(x)#转化为List
print(x)#输出:['男', '未知', '未知', '男', '未知', '未知', '未知', '男']

  • max() / min() / sum() / pow()
    max 返回给定参数的最大值,参数可以为序列
    min 返回给定参数的最小值,参数可以为序列。
    sum 对系列进行求和计算
    pow 返回 x的y次方
print(max([1,2,3]))#输出3
print(min([1,2,3]))#输出1
print(sum([1,2,3]))#输出6
print(pow(2,3))#输出8

  • memoryview()
    返回给定参数的内存查看对象(Momory view)
v = memoryview(bytearray("abcefg", 'utf-8'))
print(v[0])#输出97
print(v[1])#输出98

  • next()
    返回迭代器的下一个项目
    语法:next(iterator[, default])
    参数:iterator-可迭代对象,default-可选,用于设置在没有下一个元素时返回该默认值,如果不设置,又没有下一个元素则会触发 StopIteration 异常。
    注意:以StopIteration异常时结束迭代
# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it)
        print(x)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break

  • open()
    用于打开一个文件,并返回文件对象。在对文件进行处理过程都需要使用到这个函数,如果该文件无法被打开,会抛出 OSError。
    注意:使用 open() 函数一定要保证关闭文件对象,即调用 close() 函数。
    语法:open(file, mode='r')
    参数:
    file: 必需,文件路径(相对或者绝对路径)。
    mode: 可选,文件打开模式
    buffering: 设置缓冲
    encoding: 一般使用utf8
    errors: 报错级别
    newline: 区分换行符
    closefd: 传入的file参数类型
    opener:
mode模式 相关描述
t 文本模式 (默认)。
x 写模式,新建一个文件,如果该文件已存在则会报错。
b 二进制模式。
+ 打开一个文件进行更新(可读可写)。
U 通用换行模式(不推荐)。
r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
w 打开一个文件只用于写入。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。
wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。一般用于非文本文件如图片等。
w+ 打开一个文件用于读写。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。
wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。一般用于非文本文件如图片等。
a 打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。
ab 以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。
a+ 打开一个文件用于读写。如果该文件已存在,文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在,创建新文件用于读写。
ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。如果该文件不存在,创建新文件用于读写。

  • property()
    用以在新式类中返回属性值。
class Parrot(object):
    def __init__(self):
        self._voltage = 100000
 
    @property
    def voltage(self):
        """Get the current voltage."""
        return self._voltage

  • range()
    返回的是一个可迭代对象(类型是对象),而不是列表类型, 所以打印的时候不会打印列表,可用list转型。
x = range(5)
print(x)#输出 range(0, 5)
print(list(x))#输出 [0, 1, 2, 3, 4]

返回Python修炼册大纲

相关文章

  • Python基础篇之函数

    函数是具有特定功能可重复利用的代码块,有名字、参数(可选)、返回值(可选),又叫做方法。本篇介绍函数的定义、函数的...

  • Django 创建第一个项目

    python3之Django基础篇 python爬虫从入门到放弃(八)之 Selenium库的使用

  • python基础笔记

    Python基础 函数:

  • 【小白福利、快速入门Python】之内置函数

    欢迎大家关注公众号【哈希大数据】python的内置函数――基础介绍总结篇68个内置函数python3内置了68个常...

  • ReactiveCocoa(RAC)

    一、参考 ReactiveCocoa之基础篇 ReactiveCocoa之进阶篇 函数响应式编程 Reactive...

  • 花姐的python学习目录

    一,Python基础 1.1 Python学习【第1篇】:Python之数据类型 1.1.1python基本数据类...

  • Python基础之函数

    简单的函数定义如下 Default Argument Valuesdefault argument又称为optio...

  • python基础之函数

    函数是python为了代码最大程度的重用和最小化代码冗余而提供的最基本的程序结构。函数也是一种设计工具,使用函数,...

  • Python基础之:函数

    简介 函数是结构化编程的基础,也是代码复用的基石。Python中通过def来自定义函数。本文将会深入探索Pytho...

  • Python精简学习(九)

    Python精简学习之函数之匿名函数-匿名函数

网友评论

    本文标题:Python基础篇之函数

    本文链接:https://www.haomeiwen.com/subject/xtejnctx.html