1.函数的基本定义

def 函数名称（参数）
         执行语句
         return 返回值

def : 定义函数的关键字；

函数名称：顾名思义，就是函数的名字，可以用来调用函数，不能使用关键字来命名，做好是用这个函数的功能的英文名命名，可以采用驼峰法与下划线法；

参数：用来给函数提供数据，有形参和实参的区分；

执行语句：也叫函数体，用来进行一系列的逻辑运算；

返回值：执行完函数后，返回给调用者的数据，默认为None，所以没有返回值时，可以不写return。

 

2.函数的普通参数

最直接的一对一关系的参数，如:

def fun_ex(a,b):            #a,b是函数fun_ex的形式参数，也叫形参
    sum=a+b
    print('sum =',sum)
fun_ex(1,3)                  #1，3是函数fun_ex的实际参数，也叫实参

#运行结果
sum = 4

 

3.函数的默认参数

给参数定义一个默认值,如果调用函数时,没有给指定参数,则函数使用默认参数,默认参数需要放在参数列表的最后,如:

def fun_ex(a,b=6):    #默认参数放在参数列表最后，如b=6只能在a后面
    sum=a+b
    print('sum =',sum)
fun_ex(1,3)
fun_ex(1)

#运行结果
sum = 4
sum = 7

 

4.函数的动态参数

不需要指定参数是元组或字典,函数自动把它转换成元组或字典,如:

 1 #转换成元组的动态参数形式，接受的参数需要是可以转成元组的形式，就是类元组形式的数据，如数值，列表，元组。
 2 
 3 def func(*args):
 4     print(args,type(args))
 5 
 6 func(1,2,3,4,5)
 7 
 8 date_ex1=('a','b','c','d')
 9 func(*date_ex1)
10 
11 #运行结果
12 (1, 2, 3, 4, 5) <class 'tuple'>
13 ('a', 'b', 'c', 'd') <class 'tuple'>
动态参数形式一
 1 #转换成字典的动态参数形式，接收的参数要是能转换成字典形式的，就是类字典形式的数据，如键值对，字典
 2 
 3 def func(**kwargs):
 4     print(kwargs,type(kwargs))
 5 
 6 func(a=11,b=22)
 7 
 8 date_ex2={'a':111,'b':222}
 9 func(**date_ex2)
10 
11 #运行结果
12 {'b': 22, 'a': 11} <class 'dict'>
13 {'b': 222, 'a': 111} <class 'dict'>
动态参数形式二
 1 #根据传的参数转换成元组和字典的动态参数形式，接收的参数可以是任何形式。
 2 def func(*args,**kwargs):
 3     print(args, type(args))
 4     print(kwargs,type(kwargs))
 5 
 6 func(123,321,a=999,b=666)
 7 
 8 date_ex3={'a':123,'b':321}
 9 func(**date_ex3)
10 
11 #运行结果
12 (123, 321) <class 'tuple'>
13 {'b': 666, 'a': 999} <class 'dict'>
14 () <class 'tuple'>
15 {'b': 321, 'a': 123} <class 'dict'>
动态参数形式三

 

5.函数的返回值

运行一个函数，一般都需要从中得到某个信息，这时就需要使用return来获取返回值，如：

def fun_ex(a,b):
    sum=a+b
    return sum      #返回sum值

re=fun_ex(1,3)   
print('sum =',re)

#运行结果
sum = 4

 

6.lambda表达式

用来表达简单的函数，如：

#普通方法定义函数
def sum(a,b):
    return a+b
sum=sum(1,2)
print(sum)

#lambda表达式定义函数
myLambda = lambda a,b : a+b
sum=myLambda(2,3)
print(sum)

#运行结果
3
5


7.内置函数

1）内置函数列表

  Built-in Functions  
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()  

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

官方说明文档地址：https://docs.python.org/3/library/functions.html

中文版官方说明文档地址：http://python.usyiyi.cn/translate/python_352/index.html

2）内置函数功能

运算类内置函数：

ads(x): 取绝对值，参数是复数，返回它的模；

max(iterable, *[, key, default])/max(arg1, arg2, *args[, key]): 取所有元素的最大值；

min(iterable, *[, key, default])/min(arg1, arg2, *args[, key]): 取所有元素的最小值；

divmod(a, b): 返回a,b两数的商和余数的一对数字（可用于分页显示功能）；

 实例：

1 a=abs(-10)
2 b=abs(3)
3 print(a)
4 print(b)
5 
6 #运行结果
7 10
8 3
ads()
1 a=max(1,2,*(3,4))
2 b=max(*(1,2),*[5,6])
3 print(a)
4 print(b)
5 
6 #运行结果
7 4
8 6
max()
1 a=min(1,2,*(3,4))
2 b=min(*(0,1,2),*[5,6])
3 print(a)
4 print(b)
5 
6 #运行结果
7 1
8 0
min()
1 a=divmod(5,2)
2 print(a)
3 
4 #运行结果
5 (2, 1)
divmod()

 

 

类型转换类内置函数：

int(x): 把数据转换成整数型；

ascii(object): 类似repr()，返回一个可打印的对象字符串方式表示。当遇到非ASCII码时，就会输出\x，\u或\U等字符来表示；

bin(x): 将一个整数转化成一个二进制字符串；

class bool([x]): 根据给的数据，返回一个布尔值，True 或 False；

class bytearray([source[, encoding[, errors]]]): 返回一个byte数组；

class bytes([source[, encoding[, errors]]]): 返回一个新的字节对象，是一个在 0<= x < 256之间的不可变的整数序列；

chr(i): 返回表示Unicode码点为整数i的字符的字符串，它是ord()的逆操作。参数的有效范围为0到1,114,111（基址16中的0x10FFFF）。如果i超出该范围，则会引发ValueError报错；

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1): 将source编译为代码或者AST对象。代码对象能够通过exec语句来执行或者eval()进行求值；

class complex([real[, imag]]): 返回值形式为real + imag * j的复数，或将字符串(数字形式的字符串）或数字转换为复数；

enumerate(iterable, start=0): 返回一个枚举对象。iterable 必须是一个序列、一个迭代器，或者其它某种支持迭代的对象；

eval(expression, globals=None, locals=None): 还原字符串中的数据结构；

 

实例：

 1 a=3.14159
 2 b="12"
 3 c=int(a)
 4 d=int(b)
 5 print(a,type(a))
 6 print(b,type(b))
 7 print(c,type(c))
 8 print(d,type(d))
 9 
10 运行结果
11 3.14159 <class 'float'>
12 12 <class 'str'>
13 3 <class 'int'>
14 12 <class 'int'>
int()
 1 print(ascii('a'))
 2 print(ascii(999999))
 3 print(ascii('\11'))
 4 print(ascii('\200'))
 5 
 6 #运行结果
 7 'a'
 8 999999
 9 '\t'
10 '\x80'
ascii()
1 a=bin(5)
2 print(a,type(a))
3 
4 #运行结果
5 0b101 <class 'str'>
bin()
1 a=bool(5)
2 b=bool(0)
3 print(a)
4 print(b)
5 
6 #运行结果
7 True
8 False
bool()
 1 #如果source为空，则返回一个长度为0的字节数组
 2 a=bytearray()
 3 print(a,len(a))
 4 
 5 #如果source为字符串，则按照指定的encoding将字符串转换为字节序列
 6 b=bytearray('abcd中文','utf-8 ')
 7 print(b)
 8 
 9 #如果source为整数，则返回一个长度为source整数的初始化数组
10 c=bytearray(5)
11 print(c,len(c))
12 
13 #如果source为可迭代类型，则元素必须为[0 ,255]中的整数
14 d=bytearray([9,8,7])
15 print(d)
16 
17 #运行结果
18 bytearray(b'') 0
19 bytearray(b'abcd\xe4\xb8\xad\xe6\x96\x87')
20 bytearray(b'\x00\x00\x00\x00\x00') 5
21 bytearray(b'\t\x08\x07')
bytearray()
 1 a='abcd'
 2 b='中文'
 3 
 4 #转换成字节编码
 5 c=bytes(a,encoding='gbk')
 6 d=bytes(b,encoding='utf-8')
 7 e=bytes(b,encoding='gbk')
 8 
 9 #解码过程,用什么规则编码，就用什么解码
10 f=d.decode('utf-8')
11 h=e.decode('gbk')
12 
13 #打印信息
14 print(c)
15 print(d)
16 print(e)
17 print(f)
18 print(h)
19 
20 #运行结果
21 '''
22 b'abcd'
23 b'\xe4\xb8\xad\xe6\x96\x87'
24 b'\xd6\xd0\xce\xc4'
25 中文
26 中文
27 '''
bytes()
 1 print(chr(65))
 2 print(chr(0))
 3 print(chr(33))
 4 print(chr(1114111))
 5 
 6 #运行结果
 7 A
 8  
 9 !
10 􏿿
chr()
 1 '''
 2 参数source：字符串或者AST（Abstract Syntax Trees）对象。
 3 
 4 参数filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
 5 
 6 参数model：指定编译代码的种类。可以指定为 ‘exec’,’eval’,’single’。
 7 '''
 8 
 9 code_one = "print('hello')"
10 a = compile(code_one,'','exec')
11 exec(a)
12 
13 code_two ="print(1+2*3)"
14 b = compile(code_two,'','eval')
15 eval(b)
16 print(b)
17 
18 #运行结果
19 hello
20 7
21 <code object <module> at 0x005419D0, file "", line 1>
compile()
 1 print(complex(1,2))
 2 
 3 #如果省略imag，则默认为零，构造函数会像int和float一样进行转换。如果省略这两个参数，则返回0j。
 4 print(complex(1))
 5 
 6 #如果第一个参数为字符串，则不需要指定第二个参数。
 7 print(complex('1'))      
 8 
 9 #当从字符串转化成复数的时候，字符串中+或者-两边不能有空白,如下不能写成"1 + 2j"，应该是"1+2j"，否则会报错
10 print(complex('1+2j'))
11 
12 #运行结果
13 (1+2j)
14 (1+0j)
15 (1+0j)
16 (1+2j)
complex()
1 str='abcd'     
2 print(list(enumerate(str)))
3 print(dict(enumerate(str)))
4 
5 #运行结果
6 [(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]
7 {0: 'a', 1: 'b', 2: 'c', 3: 'd'}
enumerate()
 1 x=1
 2 print(eval('x+1'))
 3 
 4 dic={'a':1,'b':2}
 5 str=str(dic)
 6 print(str,type(str))
 7 ev=eval(str)
 8 print(ev,type(ev))
 9 
10 #运行结果
11 2
12 {'a': 1, 'b': 2} <class 'str'>
13 {'a': 1, 'b': 2} <class 'dict'>
eval()

 

 判断类内置函数：

all(iterable): 判断iterable序列中是否所有元素都为真，或整个序列为空，满足条件则返回True；

any(iterable): 判断iterable序列中是否任意一个元素为真，满足条件则返回True，这里整个序列为空，返回False；

callable(object): 判断对象object是否可调用。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功；

实例：

 1 a=[]
 2 b=[1,2,'']
 3 c=[0,1,2,3]
 4 d=[1,2,3]
 5 print(all(a))
 6 print(all(b))
 7 print(all(c))
 8 print(all(d))
 9 
10 #运行结果
11 True
12 False
13 False
14 True
all()
 1 a=[]
 2 b=[1,2,'']
 3 c=[0,0,0,1]
 4 d=[0,0,0]
 5 print(any(a))
 6 print(any(b))
 7 print(any(c))
 8 print(any(d))
 9 
10 #运行结果
11 False
12 True
13 True
14 False
any()
 1 #基本数据类型callable情况
 2 print('基本数据类型callable情况')
 3 print(callable(1))
 4 print(callable('string'))
 5 
 6 #函数的callable情况
 7 print('#函数的callable情况')
 8 def sum(a,b):
 9     return a+b
10 a=sum(1,2)
11 print(callable(sum))
12 print(callable(a))
13 
14 #类的callable情况
15 print('#类的callable情况')
16 class ex_1:
17     def add(self):
18         return 0
19 b=ex_1()
20 print(callable(ex_1))
21 print(callable(b))
22 class ex_2:
23     def __call__(self, *args, **kwargs):
24         return 0
25 c=ex_2()
26 print(callable(ex_2))
27 print(callable(c))    #类是可调用的，而类的实例实现了__call__()方法才可调用。
28 
29 #运行结果
30 '''
31 基本数据类型callable情况
32 False
33 False
34 #函数的callable情况
35 True
36 False
37 #类的callable情况
38 True
39 False
40 True
41 True
42 '''
callable()

 

IO操作类内置函数：

input([prompt]): 获取用户的输入，获取的数据会转换成字符串；

 实例：

 1 a=input('fist input  :')
 2 b=input('second input :')
 3 print(a,type(a))
 4 print(b,type(b))
 5 
 6 #运行结果
 7 fist input  :as
 8 second input :12
 9 as <class 'str'>
10 12 <class 'str'>
input()

 

基础数据类型内置函数：

class dict(): 创建字典。

 

 

其他内置函数：

help([object]): 调用内置帮助系统；

classmethod(function): 用来指定一个类的方法为类方法，没有此参数指定的类的方法为实例方法，类方法既可以直接类调用(C.f())，也可以进行实例调用(C().f())；

delattr(object, name): 删除object对象的某个属性；

dir([object]): 显示函数内置属性和方法；

 实例：

  1 help(int)
  2 
  3 #运行结果
  4 Help on class int in module builtins:
  5 
  6 class int(object)
  7  |  int(x=0) -> integer
  8  |  int(x, base=10) -> integer
  9  |  
 10  |  Convert a number or string to an integer, or return 0 if no arguments
 11  |  are given.  If x is a number, return x.__int__().  For floating point
 12  |  numbers, this truncates towards zero.
 13  |  
 14  |  If x is not a number or if base is given, then x must be a string,
 15  |  bytes, or bytearray instance representing an integer literal in the
 16  |  given base.  The literal can be preceded by '+' or '-' and be surrounded
 17  |  by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.
 18  |  Base 0 means to interpret the base from the string as an integer literal.
 19  |  >>> int('0b100', base=0)
 20  |  4
 21  |  
 22  |  Methods defined here:
 23  |  
 24  |  __abs__(self, /)
 25  |      abs(self)
 26  |  
 27  |  __add__(self, value, /)
 28  |      Return self+value.
 29  |  
 30  |  __and__(self, value, /)
 31  |      Return self&value.
 32  |  
 33  |  __bool__(self, /)
 34  |      self != 0
 35  |  
 36  |  __ceil__(...)
 37  |      Ceiling of an Integral returns itself.
 38  |  
 39  |  __divmod__(self, value, /)
 40  |      Return divmod(self, value).
 41  |  
 42  |  __eq__(self, value, /)
 43  |      Return self==value.
 44  |  
 45  |  __float__(self, /)
 46  |      float(self)
 47  |  
 48  |  __floor__(...)
 49  |      Flooring an Integral returns itself.
 50  |  
 51  |  __floordiv__(self, value, /)
 52  |      Return self//value.
 53  |  
 54  |  __format__(...)
 55  |      default object formatter
 56  |  
 57  |  __ge__(self, value, /)
 58  |      Return self>=value.
 59  |  
 60  |  __getattribute__(self, name, /)
 61  |      Return getattr(self, name).
 62  |  
 63  |  __getnewargs__(...)
 64  |  
 65  |  __gt__(self, value, /)
 66  |      Return self>value.
 67  |  
 68  |  __hash__(self, /)
 69  |      Return hash(self).
 70  |  
 71  |  __index__(self, /)
 72  |      Return self converted to an integer, if self is suitable for use as an index into a list.
 73  |  
 74  |  __int__(self, /)
 75  |      int(self)
 76  |  
 77  |  __invert__(self, /)
 78  |      ~self
 79  |  
 80  |  __le__(self, value, /)
 81  |      Return self<=value.
 82  |  
 83  |  __lshift__(self, value, /)
 84  |      Return self<<value.
 85  |  
 86  |  __lt__(self, value, /)
 87  |      Return self<value.
 88  |  
 89  |  __mod__(self, value, /)
 90  |      Return self%value.
 91  |  
 92  |  __mul__(self, value, /)
 93  |      Return self*value.
 94  |  
 95  |  __ne__(self, value, /)
 96  |      Return self!=value.
 97  |  
 98  |  __neg__(self, /)
 99  |      -self
100  |  
101  |  __new__(*args, **kwargs) from builtins.type
102  |      Create and return a new object.  See help(type) for accurate signature.
103  |  
104  |  __or__(self, value, /)
105  |      Return self|value.
106  |  
107  |  __pos__(self, /)
108  |      +self
109  |  
110  |  __pow__(self, value, mod=None, /)
111  |      Return pow(self, value, mod).
112  |  
113  |  __radd__(self, value, /)
114  |      Return value+self.
115  |  
116  |  __rand__(self, value, /)
117  |      Return value&self.
118  |  
119  |  __rdivmod__(self, value, /)
120  |      Return divmod(value, self).
121  |  
122  |  __repr__(self, /)
123  |      Return repr(self).
124  |  
125  |  __rfloordiv__(self, value, /)
126  |      Return value//self.
127  |  
128  |  __rlshift__(self, value, /)
129  |      Return value<<self.
130  |  
131  |  __rmod__(self, value, /)
132  |      Return value%self.
133  |  
134  |  __rmul__(self, value, /)
135  |      Return value*self.
136  |  
137  |  __ror__(self, value, /)
138  |      Return value|self.
139  |  
140  |  __round__(...)
141  |      Rounding an Integral returns itself.
142  |      Rounding with an ndigits argument also returns an integer.
143  |  
144  |  __rpow__(self, value, mod=None, /)
145  |      Return pow(value, self, mod).
146  |  
147  |  __rrshift__(self, value, /)
148  |      Return value>>self.
149  |  
150  |  __rshift__(self, value, /)
151  |      Return self>>value.
152  |  
153  |  __rsub__(self, value, /)
154  |      Return value-self.
155  |  
156  |  __rtruediv__(self, value, /)
157  |      Return value/self.
158  |  
159  |  __rxor__(self, value, /)
160  |      Return value^self.
161  |  
162  |  __sizeof__(...)
163  |      Returns size in memory, in bytes
164  |  
165  |  __str__(self, /)
166  |      Return str(self).
167  |  
168  |  __sub__(self, value, /)
169  |      Return self-value.
170  |  
171  |  __truediv__(self, value, /)
172  |      Return self/value.
173  |  
174  |  __trunc__(...)
175  |      Truncating an Integral returns itself.
176  |  
177  |  __xor__(self, value, /)
178  |      Return self^value.
179  |  
180  |  bit_length(...)
181  |      int.bit_length() -> int
182  |      
183  |      Number of bits necessary to represent self in binary.
184  |      >>> bin(37)
185  |      '0b100101'
186  |      >>> (37).bit_length()
187  |      6
188  |  
189  |  conjugate(...)
190  |      Returns self, the complex conjugate of any int.
191  |  
192  |  from_bytes(...) from builtins.type
193  |      int.from_bytes(bytes, byteorder, *, signed=False) -> int
194  |      
195  |      Return the integer represented by the given array of bytes.
196  |      
197  |      The bytes argument must be a bytes-like object (e.g. bytes or bytearray).
198  |      
199  |      The byteorder argument determines the byte order used to represent the
200  |      integer.  If byteorder is 'big', the most significant byte is at the
201  |      beginning of the byte array.  If byteorder is 'little', the most
202  |      significant byte is at the end of the byte array.  To request the native
203  |      byte order of the host system, use `sys.byteorder' as the byte order value.
204  |      
205  |      The signed keyword-only argument indicates whether two's complement is
206  |      used to represent the integer.
207  |  
208  |  to_bytes(...)
209  |      int.to_bytes(length, byteorder, *, signed=False) -> bytes
210  |      
211  |      Return an array of bytes representing an integer.
212  |      
213  |      The integer is represented using length bytes.  An OverflowError is
214  |      raised if the integer is not representable with the given number of
215  |      bytes.
216  |      
217  |      The byteorder argument determines the byte order used to represent the
218  |      integer.  If byteorder is 'big', the most significant byte is at the
219  |      beginning of the byte array.  If byteorder is 'little', the most
220  |      significant byte is at the end of the byte array.  To request the native
221  |      byte order of the host system, use `sys.byteorder' as the byte order value.
222  |      
223  |      The signed keyword-only argument determines whether two's complement is
224  |      used to represent the integer.  If signed is False and a negative integer
225  |      is given, an OverflowError is raised.
226  |  
227  |  ----------------------------------------------------------------------
228  |  Data descriptors defined here:
229  |  
230  |  denominator
231  |      the denominator of a rational number in lowest terms
232  |  
233  |  imag
234  |      the imaginary part of a complex number
235  |  
236  |  numerator
237  |      the numerator of a rational number in lowest terms
238  |  
239  |  real
240  |      the real part of a complex number
help()
 1 class C:
 2     @classmethod
 3     def f(self):
 4         print('this is class method')
 5 print(C.f())
 6 print(C().f())
 7 
 8 class D:
 9     def f(self):
10         print('this is not a class method')
11 print(D().f())            #这里不能用D.f()
12 
13 #运行结果
14 this is class method
15 None
16 this is class method
17 None
18 this is not a class method
19 None
classmethod()
 1 class Dog :
 2     def __init__(self,name,age):
 3         self.name=name
 4         self.age=age
 5 dahuang = Dog('dahuang',2)
 6 print(dir(dahuang))
 7 delattr(dahuang,"age")
 8 print(dir(dahuang))
 9 
10 #运行结果
11 ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'age', 'name']
12 ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name']
delattr()
1 print(dir(int))
2 
3 #运行结果
4 ['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']
dir()