自学Python之路-Python基础+模块+面向对象
自学Python之路-Python网络编程自学Python之路-Python并发编程+数据库+前端自学Python之路-django

自学Python3.2-函数分类(内置函数)

内置函数,自定义函数,匿名函数

内置函数(python3.x)

内置参数详解官方文档: https://docs.python.org/3/library/functions.html?highlight=built#ascii

1、以下为内置函数的整合分类

1.1、数学运算类

abs(x) 求绝对值
1、参数可以是整型,也可以是复数
2、若参数是负数,则返回负数的模
complex([real[, imag]]) 创建一个复数
divmod(a, b) 分别取商和余数
注意:整型、浮点型都可以
float([x]) 将一个字符串或数转换为浮点数。如果无参数将返回0.0
int([x[, base]])  将一个字符转换为int类型,base表示进制
long([x[, base]])  将一个字符转换为long类型
pow(x, y[, z])  返回x的y次幂
range([start], stop[, step])  产生一个序列,默认从0开始
round(x[, n])  四舍五入
sum(iterable[, start])  对集合求和
oct(x) 将一个数字转化为8进制
hex(x) 将整数x转换为16进制字符串
chr(i) 返回整数i对应的ASCII字符
bin(x) 将整数x转换为二进制字符串
bool([x]) 将x转换为Boolean类型

1.2、集合类操作

basestring() str和unicode的超,不能直接调用,可以用作isinstance判断
format(value [, format_spec]) 格式化输出字符串
格式化的参数顺序从0开始,如“I am {0},I like {1}”
unichr(i) 返回给定int类型的unicode
enumerate(sequence [, start = 0]) 返回一个可枚举的对象,该对象的next()方法将返回一个tuple
iter(o[, sentinel]) 生成一个对象的迭代器,第二个参数表示分隔符
max(iterable[, args...][key])  返回集合中的最大值
min(iterable[, args...][key]) 返回集合中的最小值
dict([arg]) 创建数据字典
list([iterable])  将一个集合类转换为另外一个集合类
set() set对象实例化
frozenset([iterable]) 产生一个不可变的set
str([object])  转换为string类型
sorted(iterable[, cmp[, key[, reverse]]])  队集合排序
tuple([iterable])  生成一个tuple类型
xrange([start], stop[, step])  xrange()函数与range()类似,但xrnage()并不创建列表,而是返回一个xrange对象,它的行为与列表相似,但是只在需要时才计算列表值,当列表很大时,这个特性能为我们节省内存

1.3、逻辑判断

all(iterable) 1、集合中的元素都为真的时候为真
2、特别的,若为空串返回为True
any(iterable) 1、集合中的元素有一个为真的时候为真
2、特别的,若为空串返回为False
cmp(x, y) 如果x < y ,返回负数;x == y, 返回0;x > y,返回正数

1.4、反射

callable(object) 检查对象object是否可调用
1、类是可以被调用的
2、实例是不可以被调用的,除非类中声明了__call__方法
classmethod() 1、注解,用来说明这个方式是个类方法
2、类方法即可被类调用,也可以被实例调用
3、类方法类似于Java中的static方法
4、类方法中不需要有self参数
compile(source, filename, mode[, flags[, dont_inherit]]) 将source编译为代码或者AST对象。代码对象能够通过exec语句来执行或者eval()进行求值。
1、参数source:字符串或者AST(Abstract Syntax Trees)对象。
2、参数 filename:代码文件名称,如果不是从文件读取代码则传递一些可辨认的值。
3、参数model:指定编译代码的种类。可以指定为 ‘exec’,’eval’,’single’。
4、参数flag和dont_inherit:这两个参数暂不介绍
dir([object]) 1、不带参数时,返回当前范围内的变量、方法和定义的类型列表;
2、带参数时,返回参数的属性、方法列表。
3、如果参数包含方法__dir__(),该方法将被调用。当参数为实例时。
4、如果参数不包含__dir__(),该方法将最大限度地收集参数信息
delattr(object, name) 删除object对象名为name的属性
eval(expression [, globals [, locals]]) 计算表达式expression的值
execfile(filename [, globals [, locals]]) 用法类似exec(),不同的是execfile的参数filename为文件名,而exec的参数为字符串。
filter(function, iterable) 构造一个序列,等价于[ item for item in iterable if function(item)]
1、参数function:返回值为True或False的函数,可以为None
2、参数iterable:序列或可迭代对象
getattr(object, name [, defalut]) 获取一个类的属性
globals() 返回一个描述当前全局符号表的字典
hasattr(object, name) 判断对象object是否包含名为name的特性
hash(object) 如果对象object为哈希表类型,返回对象object的哈希值
id(object) 返回对象的唯一标识
isinstance(object, classinfo) 判断object是否是class的实例
issubclass(class, classinfo) 判断是否是子类
len(s)  返回集合长度
locals()  返回当前的变量列表
map(function, iterable, ...)  遍历每个元素,执行function操作
memoryview(obj)  返回一个内存镜像类型的对象
next(iterator[, default])  类似于iterator.next()
object()  基类
property([fget[, fset[, fdel[, doc]]]])  属性访问的包装类,设置后可以通过c.x=value等来访问setter和getter
reduce(function, iterable[, initializer])  合并操作,从第一个开始是前两个参数,然后是前两个的结果与第三个合并进行处理,以此类推
reload(module)  重新加载模块
setattr(object, name, value) 设置属性值
repr(object)  将一个对象变幻为可打印的格式
slice()  
staticmethod 声明静态方法,是个注解
super(type[, object-or-type])  引用父类
type(object) 返回该object的类型
vars([object])  返回对象的变量,若无参数与dict()方法类似
bytearray([source [, encoding [, errors]]]) 返回一个byte数组
1、如果source为整数,则返回一个长度为source的初始化数组;
2、如果source为字符串,则按照指定的encoding将字符串转换为字节序列;
3、如果source为可迭代类型,则元素必须为[0 ,255]中的整数;
4、如果source为与buffer接口一致的对象,则此对象也可以被用于初始化bytearray.
zip([iterable, ...])   

1.5、IO操作

file(filename [, mode [, bufsize]]) file类型的构造函数,作用为打开一个文件,如果文件不存在且mode为写或追加时,文件将被创建。添加‘b’到mode参数中,将对文件以二进制形式操作。添加‘+’到mode参数中,将允许对文件同时进行读写操作
1、参数filename:文件名称。
2、参数mode:'r'(读)、'w'(写)、'a'(追加)。
3、参数bufsize:如果为0表示不进行缓冲,如果为1表示进行行缓冲,如果是一个大于1的数表示缓冲区的大小 。
input([prompt])  获取用户输入
推荐使用raw_input,因为该函数将不会捕获用户的错误输入
open(name[, mode[, buffering]])  打开文件
与file有什么不同?推荐使用open
print 打印函数
raw_input([prompt])  设置输入,输入都是作为字符串处理

内置函数,一般都是因为使用频率比较频繁或是是元操作,所以通过内置函数的形式提供出来,通过对python的内置函数分类分析可以看出来:基本的数据操作基本都是一些数学运算(当然除了加减乘除)、逻辑操作、集合操作、基本IO操作,然后就是对于语言自身的反射操作,还有就是字符串操作,也是比较常用的,尤其需要注意的是反射操作。

2、内置函数使用示例

2.1 abs 绝对值


print(abs(-1))
print(abs(1))

输出
1
1  

2.2 all 所有的都为真,他才为真

print(all([1,2,'1']))
print(all([1,2,'1','']))
print(all('')) #如果可迭代对象是空,就返回True

执行结果:

True
False
True

2.3  any 集合中的元素有一个为真的时候为真,      若为空串返回为False

print(any([0,'']))
print(any([0,'',1]))

输出

False
True

2.4 bin 把十进制转成二进制

print(bin(3))

输出 0b11

2.5 bool 布尔值   空,None,             0的布尔值为False,其余都为True

print(bool(''))  #空字符串,返回值None
print(bool(None))
print(bool(0))

执行结果:

False
False
False

2.6  bytes 把字符串转成字节

name='你好,carlos'
print(bytes(name,encoding='utf-8')) #手动把字符串编码,转成二进制
print(bytes(name,encoding='utf-8').decode('utf-8')) #需要把字符串进行编码,再解码(用什么编码,就用什么解码)

输出

b'\xe4\xbd\xa0\xe5\xa5\xbd,carlos'
你好,carlos

name='你好,carlos'
print(bytes(name,encoding='gbk')) #手动把字符串编码,转成二进制
print(bytes(name,encoding='gbk').decode('gbk')) #需要把字符串进行编码,再解码(用什么编码,就用什么解码)

输出:

b'\xc4\xe3\xba\xc3,carlos'
你好,carlos

name='你好'
print(bytes(name,encoding='ascii')) #ascii不能编码中文,会报错

2.7  ascll 码对应的编码

print(chr(89))  # ascll 码对应的编码

输出
Y
2.8 dir 显示函数内置属性和方法

print(dir(dict))  #打印内置属性和方法

输出
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']

2.9 divmod 取商得余数,用于做分页显示功能

print(divmod(258, 8))  # 取商得余数,用于做分页显示

输出(32, 2)

2.10 eval  把字符串中的数据结构给提取出来

dic={'name':'alex'}
dic_str=str(dic) #字典类型转成字符串
print(dic_str)
d1=eval(dic_str) #eval:把字符串中的数据结构给提取出来
print(d1)

输出

{'name': 'alex'}
{'name': 'alex'}

2.11  可hash的数据类型即不可变数据类型,不可hash的数据类型即可变数据类型

#hash的作用:去网上下载软件,判断是否被人修改,通过比对hash值,就知道
print(hash('12sdfdsaf3123123sdfasdfasdfasdfasdfasdfasdfasdfasfasfdasdf'))
print(hash('12sdfdsaf31231asdfasdfsadfsadfasdfasdf23'))
name='carlos'
print(hash(name))
print(hash(name))
print('--->before',hash(name))
name='gary'
print('--->after',hash(name))

输出

733648477
895994456
-794251862
-794251862
--->before -794251862
--->after 245391844

2.12  help 查看函数用法的说细信息

print(help(all))

2.13  bin、hex、oct  进制转换

print(bin(20))   #10进制->2进制
print(hex(6)) #10进制->16进制
print(oct(78)) #10进制->8进制

输出

0b10100
0x6
0o116

2.14 isinstance判断类型,返回True或Flase

print(isinstance(667,int))       #判断是不是int类型
print(isinstance('carlos',str)) #判断字符串
print(isinstance([],list)) #判断列表
print(isinstance({},dict)) #判断字典
print(isinstance({5,2},set)) #判断集合

输出

True
True
True
True
True

2.15 globals 全局变量

name='fagaggagsregha'
print(globals()) #全局变量

输出

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00296570>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'C:/Users/Administrator/PycharmProjects/untitled/aaaa.py', '__cached__': None, 'name': 'fagaggagsregha'}

name='fagaggagsregha'
print(__file__) #直接打印文件名

输出
C:/Users/Administrator/PycharmProjects/untitled/aaaa.py

def test():
age='1111111111111111111111111111111111111111111111111111111111111'
print(globals()) #打印全局变量
print(locals()) #打印上一层的变量
test()

globals 打印全局变量,locals 打印上一层的变量
输出

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x002B6570>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'C:/Users/Administrator/PycharmProjects/untitled/aaaa.py', '__cached__': None, 'test': <function test at 0x005B5300>}
{'age': '1111111111111111111111111111111111111111111111111111111111111'}
2.16 max 最大值 和 min最小值

l=[555,23,-100,-1,45]
print(max(l))
print(min(l))  

输出
555
-100

max 高级用法

说明:
1、max函数处理的是可迭代对象,相当于一个for循环取出每个元素进行比较。
      注意:不同类型之间不能进行比较
2、每个元素间进行比较,是从每个元素的第一位置依次比较,如果这一个位置分出大小,后面的都不需要比较了,直接得出这俩元素的大小。

age_dic={'alex_age':18,'wupei_age':20,'zsc_age':100,'lhf_age':30}
print(max(age_dic.values())) #取出最大年龄
print(max(age_dic)) #默认比较的是字典的key

输出

100
zsc_age

 取出年龄最大的key和values

age_dic={'alex_age':18,'wupei_age':20,'zsc_age':100,'lhf_age':30}
for item in zip(age_dic.values(),age_dic.keys()): #[(18,'alex_age') (20,'wupeiqi_age') () () ()]
print(item)#取出年龄最大的key和values
print('=======>',list(max(zip(age_dic.values(),age_dic.keys())))) #max和zip联合使用  

输出

(18, 'alex_age')
(20, 'wupei_age')
(100, 'zsc_age')
(30, 'lhf_age')
=======> [100, 'zsc_age']

l=[
(5,'e'),
(1,'b'),
(3,'a'),
(4,'d'), ]
l1=['a10','b12','c10',100] #不同类型之间不能进行比较
l1=['a10','a2','a10'] #不同类型之间不能进行比较
print(list(max(l)))
print('--->',list(max(l1)))

输出

[5, 'e']
---> ['a', '2']

2.17  zip  将对象逐一配对

print(list(zip(('a','n','c'),(1,2,3))))
print(list(zip(('a','n','c'),(1,2,3,4))))
print(list(zip(('a','n','c','d'),(1,2,3))))  

输出

[('a', 1), ('n', 2), ('c', 3)]
[('a', 1), ('n', 2), ('c', 3)]
[('a', 1), ('n', 2), ('c', 3)]

p={'name':'alex','age':18,'gender':'none'}
print(list(zip(p.keys(),p.values())))
print(list(p.keys())) #取keys
print(list(p.values())) #values
print(list(zip(['a','b'],'12345'))) #列表,只要是序列就可以打印出来  

输出

[('name', 'alex'), ('age', 18), ('gender', 'none')]
['name', 'age', 'gender']
['alex', 18, 'none']
[('a', '1'), ('b', '2')]

max总结:

l=[1,3,100,-1,2]
print(max(l)) #比较出最大值
dic={'age1':18,'age2':10}
print(max(dic)) #比较的是key
print(max(dic.values())) #比较的是key,但是不知道是那个key对应的值
print(max(zip(dic.values(),dic.keys()))) #结合zip使用  

输出

100
age2
18
(18, 'age1')

people=[
{'name':'alex','age':1000},
{'name':'carlos','age':10000},
{'name':'gary','age':9000},
{'name':'amy','age':18},] # max(people,key=lambda dic:dic['age'])
print('agaggdgafadg',max(people,key=lambda dic:dic['age'])) #提取年龄中的values,再进行比较
#上面题分解步骤,先取出ret的值,再给max进行比较
people=[
{'name':'alex','age':1000},
{'name':'carlos','age':10000},
{'name':'gary','age':9000},
{'name':'amy','age':18},]
ret=[]
for item in people:
ret.append(item['age'])
print(ret)
max(ret) 

输出

agaggdgafadg {'name': 'carlos', 'age': 10000}
[1000, 10000, 9000, 18]

chr : 返回一个字符串,其ASCII码是一个整型.比如chr(97)返回字符串'a'。参数i的范围在0-             255之间。

ord: 参数是一个ascii字符,返回值是对应的十进制整数

pow: 几的几次方

print(chr(97))     #ascll码应对的编码
print(ord('a')) #ascll码应对的数字
print(pow(3,3)) #3**3 几的几次方,相当于3的3次方
print(pow(3,3,2)) #3**3%2 3的3次方,取余  

输出

a
97
27
1

2.18 reversed 反转

l=[1,2,3,4]
print(list(reversed(l)))
print(l)

输出

[4, 3, 2, 1]
[1, 2, 3, 4]

2.19  round  四舍五入

print(round(3.5))  # 四舍五入

输出 4

2.20 set 集合

print(set('hello'))  # 集合

输出 {'l', 'o', 'h', 'e'}  

2.21 slice 切片

l='hello'
s1=slice(3,5) #切片 取3到5的元素
s2=slice(1,4,2) #切片,指定步长为2
print(l[3:5])
print(l[s1]) #切片
print(l[s2])
print(s2.start) #开始
print(s2.stop) #结束
print(s2.step) #步长

输出

lo
lo
el
1
4
2

2.22  sorted 排序

l=[3,2,1,5,7]
l1=[3,2,'a',1,5,7]
print(sorted(l)) #排序
# print(sorted(l1)) #直接运行会报错,因为排序本质就是在比较大小,不同类型之间不可以比较大小

输出[1, 2, 3, 5, 7]  

people=[
{'name':'alex','age':1000},
{'name':'wupei','age':10000},
{'name':'yuanhao','age':9000},
{'name':'linhaifeng','age':18},]
print(sorted(people,key=lambda dic:dic['age'])) #按年龄进行排序

输出 

[{'name': 'linhaifeng', 'age': 18}, {'name': 'alex', 'age': 1000}, {'name': 'yuanhao', 'age': 9000}, {'name': 'wupei', 'age': 10000}]

name_dic={
'abyuanhao': 11900,
'alex':1200,
'wupei':300, }
print(sorted(name_dic)) #按key排序
print(sorted(name_dic,key=lambda key:name_dic[key])) #取出字典的values
print(sorted(zip(name_dic.values(),name_dic.keys()))) #按价格从低到高排序

输出

['abyuanhao', 'alex', 'wupei']
['wupei', 'alex', 'abyuanhao']
[(300, 'wupei'), (1200, 'alex'), (11900, 'abyuanhao')]

2.23  str , type

    str   转换成字符型
    type 查看某一个东西的数据类型
    eval 转换数据类型

print(str('1'))             #str  转换成字符型
print(type(str({'a':1}))) #type 查看数据类型
dic_str=str({'a':1})
print(type(eval(dic_str))) #eval 转换数据类型

输出

1
<class 'str'>
<class 'dict'>

msg='123'
if type(msg) is str:
msg=int(msg)
res=msg+1 # int类型+1
print(res)

输出 124 

2.24  vars 跟一个列表或多个字典

def test():
msg='我就是一个天才'
print(locals()) #打印出上一层的值,如果上一层没有,再往上找
print(vars()) #如果没有参数,跟locals一样,如果有参数,查看某一个方法,显示成字典的方式
test()
print(vars(int))

输出

{'msg': '我就是一个天才'}
{'msg': '我就是一个天才'}
{'__repr__': <slot wrapper '__repr__' of 'int' objects>, '__hash__': <slot wrapper '__hash__' of 'int' objects>, '__str__': <slot wrapper '__str__' of 'int' objects>, '__getattribute__': <slot wrapper '__getattribute__' of 'int' objects>, '__lt__': <slot wrapper '__lt__' of 'int' objects>, '__le__': <slot wrapper '__le__' of 'int' objects>, '__eq__': <slot wrapper '__eq__' of 'int' objects>, '__ne__': <slot wrapper '__ne__' of 'int' objects>, '__gt__': <slot wrapper '__gt__' of 'int' objects>, '__ge__': <slot wrapper '__ge__' of 'int' objects>, '__add__': <slot wrapper '__add__' of 'int' objects>, '__radd__': <slot wrapper '__radd__' of 'int' objects>, '__sub__': <slot wrapper '__sub__' of 'int' objects>, '__rsub__': <slot wrapper '__rsub__' of 'int' objects>, '__mul__': <slot wrapper '__mul__' of 'int' objects>, '__rmul__': <slot wrapper '__rmul__' of 'int' objects>, '__mod__': <slot wrapper '__mod__' of 'int' objects>, '__rmod__': <slot wrapper '__rmod__' of 'int' objects>, '__divmod__': <slot wrapper '__divmod__' of 'int' objects>, '__rdivmod__': <slot wrapper '__rdivmod__' of 'int' objects>, '__pow__': <slot wrapper '__pow__' of 'int' objects>, '__rpow__': <slot wrapper '__rpow__' of 'int' objects>, '__neg__': <slot wrapper '__neg__' of 'int' objects>, '__pos__': <slot wrapper '__pos__' of 'int' objects>, '__abs__': <slot wrapper '__abs__' of 'int' objects>, '__bool__': <slot wrapper '__bool__' of 'int' objects>, '__invert__': <slot wrapper '__invert__' of 'int' objects>, '__lshift__': <slot wrapper '__lshift__' of 'int' objects>, '__rlshift__': <slot wrapper '__rlshift__' of 'int' objects>, '__rshift__': <slot wrapper '__rshift__' of 'int' objects>, '__rrshift__': <slot wrapper '__rrshift__' of 'int' objects>, '__and__': <slot wrapper '__and__' of 'int' objects>, '__rand__': <slot wrapper '__rand__' of 'int' objects>, '__xor__': <slot wrapper '__xor__' of 'int' objects>, '__rxor__': <slot wrapper '__rxor__' of 'int' objects>, '__or__': <slot wrapper '__or__' of 'int' objects>, '__ror__': <slot wrapper '__ror__' of 'int' objects>, '__int__': <slot wrapper '__int__' of 'int' objects>, '__float__': <slot wrapper '__float__' of 'int' objects>, '__floordiv__': <slot wrapper '__floordiv__' of 'int' objects>, '__rfloordiv__': <slot wrapper '__rfloordiv__' of 'int' objects>, '__truediv__': <slot wrapper '__truediv__' of 'int' objects>, '__rtruediv__': <slot wrapper '__rtruediv__' of 'int' objects>, '__index__': <slot wrapper '__index__' of 'int' objects>, '__new__': <built-in method __new__ of type object at 0x5EAA7370>, 'conjugate': <method 'conjugate' of 'int' objects>, 'bit_length': <method 'bit_length' of 'int' objects>, 'to_bytes': <method 'to_bytes' of 'int' objects>, 'from_bytes': <method 'from_bytes' of 'int' objects>, '__trunc__': <method '__trunc__' of 'int' objects>, '__floor__': <method '__floor__' of 'int' objects>, '__ceil__': <method '__ceil__' of 'int' objects>, '__round__': <method '__round__' of 'int' objects>, '__getnewargs__': <method '__getnewargs__' of 'int' objects>, '__format__': <method '__format__' of 'int' objects>, '__sizeof__': <method '__sizeof__' of 'int' objects>, 'real': <attribute 'real' of 'int' objects>, 'imag': <attribute 'imag' of 'int' objects>, 'numerator': <attribute 'numerator' of 'int' objects>, 'denominator': <attribute 'denominator' of 'int' objects>, '__doc__': "int(x=0) -> integer\nint(x, base=10) -> integer\n\nConvert a number or string to an integer, or return 0 if no arguments\nare given. If x is a number, return x.__int__(). For floating point\nnumbers, this truncates towards zero.\n\nIf x is not a number or if base is given, then x must be a string,\nbytes, or bytearray instance representing an integer literal in the\ngiven base. The literal can be preceded by '+' or '-' and be surrounded\nby whitespace. The base defaults to 10. Valid bases are 0 and 2-36.\nBase 0 means to interpret the base from the string as an integer literal.\n>>> int('0b100', base=0)\n4"}

2.25  import 模块
 ①先创建一个文件
 ②定义函数
 ③调用模块

def say_hi():
print('hello carlos')
import aaaa
aaaa.say_hi()

输出
hello carlos
hello carlos 

2.26  __import__  :导入一个字符串类型模块,就要用__import__

①先创建一个文件
 ②定义函数
 ③调用模块

def say_hi():
print('hello carlos')
module_name='aaaa'
m=__import__(module_name) #有字符串的模块
m.say_hi()

输出

hello carlos
hello carlos

二、自定义函数

日常使用的大多数函数,以及开发中创建的函数,都属于自定义函数。这极大的提高了代码的重用性和可读性。

自学Python3.2-函数分类(内置函数)的更多相关文章

  1. 自学Python3.3-函数分类(内置函数补充)

    自学Python之路-Python基础+模块+面向对象自学Python之路-Python网络编程自学Python之路-Python并发编程+数据库+前端自学Python之路-django 自学Pyth ...

  2. day 14 三元运算符,列表字典推导式,递归,匿名函数,内置函数(排序,映射,过滤,合并)

    一.三元运算符 就是if.....else..... 语法糖 前提:if和else只有一条语句 #原始版 cmd=input('cmd') if cmd.isdigit(): print('1') e ...

  3. python协程函数、递归、匿名函数与内置函数使用、模块与包

    目录: 协程函数(yield生成器用法二) 面向过程编程 递归 匿名函数与内置函数的使用 模块 包 常用标准模块之re(正则表达式) 一.协程函数(yield生成器用法二) 1.生成器的语句形式 a. ...

  4. python基础之函数式编程、匿名函数、内置函数

    一 函数式编程 不修改外部状态. 模仿数学里得函数进行编程. 用函数编程写出得代码相当精简. 可读性比较差. 例子: y=2*x+1 x=1 def test(x): return 2*x+1 tes ...

  5. python递归-三元表达式-列表生成式-字典生成式-匿名函数-部分内置函数-04

    递归 递归: # 函数在调用阶段直接或间接地又调用了自身 应用场景: # 将列表中的数字依次打印出来(循环的层数是你必须要考虑的点)   -->  l = [1, [2, [3, [4, [5, ...

  6. Python函数05/内置函数/闭包

    Python函数05/内置函数/闭包 目录 Python函数05/内置函数/闭包 内容大纲 1.内置函数(二) 2.匿名函数及内置函数(重要) 3.闭包 4.今日总结 5.今日练习 内容大纲 1.内置 ...

  7. day03 函数基本语法及特性 2. 参数与局部变量 3. 返回值 嵌套函数 4.递归 5.匿名函数 6.函数式编程介绍 7.高阶函数 8.内置函数

    本节内容 1. 函数基本语法及特性 2. 参数与局部变量 3. 返回值 嵌套函数 4.递归 5.匿名函数 6.函数式编程介绍 7.高阶函数 8.内置函数 温故知新 1. 集合 主要作用: 去重 关系测 ...

  8. python基础知识15---三元表达式、列表推导式、生成器表达式、递归、匿名函数、内置函数

    阅读目录 一 三元表达式.列表推导式.生成器表达式 二 递归与二分法 三 匿名函数 四 内置函数 五 阶段性练习 一. 三元表达式.列表推导式.生成器表达式 1 三元表达式 name=input('姓 ...

  9. day14(1)--递归、匿名函数、内置函数

    一.递归 定义:本质上是回溯和递推 回溯:询问答案的过程 递推:推出答案的过程 前提: 回溯到一个有结果的值开始递推 回溯与递推的条件要有规律 方式: 直接递归:自己调用自己 间接递归:通过别人来调用 ...

  10. python之三元表达式、列表推导、生成器表达式、递归、匿名函数、内置函数

    目录 一 三元表达式 二 列表推到 三 生成器表达式 四 递归 五 匿名函数 六 内置函数 一.三元表达式 def max(x,y): return x if x>y else y print( ...

随机推荐

  1. CF97C Winning Strategy 构造、图论

    题目传送门:http://codeforces.com/problemset/problem/97/C 题意:给出$n$与一个范围在$[0,1]$内的递增序列$P_0-P_n$,试构造一个无穷序列$\ ...

  2. DataWorks使用小结(二)——功能面板使用指南

    一.数据开发 1.任务开发 新建表 野路子可以直接新建一个任务,粘贴DDL,手动运行任务即可完成建表 正常应当是在“数据管理”->数据表管理中建表: 支持可视化建表和DDL建表(配合之前的宏,建 ...

  3. python3通过gevent.pool限制协程并发数量

    协程虽然是轻量级的线程,但到达一定数量后,仍然会造成服务器崩溃出错.最好的方法通过限制协程并发数量来解决此类问题. server代码: #!/usr/bin/env python # -*- codi ...

  4. R绘图 第十二篇:散点图(高级)

    散点图用于描述两个连续性变量间的关系,三个变量之间的关系可以通过3D图形或气泡来展示,多个变量之间的两两关系可以通过散点图矩阵来展示. 一,添加了最佳拟合曲线的散点图 使用基础函数plot(x,y)来 ...

  5. 分布式监控系统Zabbix--完整安装记录(7)-使用percona监控MySQL

    前面已经介绍了分布式监控系统Zabbix-3.0.3-完整安装记录(2)-添加mysql监控,但是没有提供可以直接使用的Key,太过简陋,监控效果不佳.要想更加仔细的监控Mysql,业内同学们都会选择 ...

  6. jsonrpc环境搭建和简单实例

    一.环境准备 下载需要的jar包和js文件,下载地址:https://yunpan.cn/cxvbm9DhK9tDq  访问密码 6a50 二.新建一个web工程,jsonrpc-1.0.jar复制到 ...

  7. [2019BUAA软件工程]结对编程感想

    结对编程感想 写在前面   本博客为笔者在完成软件工程结对编程任务后对于编程过程.最终得分的一些感想与经验分享.此外笔者还对于本课程的结对编程部分提出了一些建议. Tips Link 作业要求博客 2 ...

  8. java_web—JSP+Servlet+JavaBean

    JSP -> Java Server Page  后端 jsp -> JavaScript  前端 JSP语法 1.JSP插入Java代码 三种形式: (1)<%!  %> ( ...

  9. 阅读<构建之法>13、14、15、16、17章

    13章 这么多测试为什么不能整理出一个包括所有功能的测试呢?看着那么多测试都感觉奇怪了. 14章 怎样才能体现一个测试人员的工作价值呢?这样的判断又是否会太独断了? 15章 在时间上,会不会因不同功能 ...

  10. A11-java学习-二维数组-面向对象概念-类的编写-测试类的编写-创建对象-使用对象-递归

    二维数组的内存结构和使用 引用类型的内存结构 栈区.堆区.方法区.数据栈等内存分析和介绍 面向对象.面向过程区别和发展 类型的定义 引用类型.值类型 预定义类型和自定义类型 类型与对象(实例) 对象的 ...