编程面向过程（函数）及内置函数

1，面向过程

过程：没有返回值的函数就是过程 一个步骤一个步骤来

例如：想实现 y = 2*x+1

def cal (x) :

　　res = 2*x

　　res = res + 1

　　return res

2，函数式

函数式 = 编程语言定义的函数 + 数学意义的函数

通俗来讲，函数式就是用编程语言去实现数学函数。这种函数的内对象是永恒不变的，要么参数是函数，要么返回值是函数。没有for 循环 while循环，所有循环是由递归去实现，无变量的赋值（即不用变量去保存状态），无赋值即不改变

例如：想实现 y = 2 * x +1

def cal(x) :

　　return 2 * x + 1

特点：不可变对象，第一类对象，尾调用优化（尾递归）

1）不可变：不用变量保存状态，不修改变量

例如： 非函数式

a = 1
def cal():
    global a
    a +=1
    return a

cal()
print(a)=====结果是2，变量由1变成 2

函数式

n = 1

def cal(n):

    return n + 1


print(cal(3))=====》结果是 4
print(n)=====>结果是1，变量保持不变

2）尾调用：在函数的最后一步调用另一个函数（最后一行不一定是函数的最后一步）

-高阶函数：1）函数接收的参数是一个函数名 2）返回值中包含函数或者函数名

1）把函数接收的是另一个函数

def foo(n):
    print(n)

def bar(name):
    print("my name is %s" %name)

foo(bar('alisa'))====>结果是：my name is alisa
　　　　　　　　　　　　　　　　　None

2）返回值中包含函数名

def foo(n):
    print('from foo')
    return foo

print(foo(2))====》结果是from foo

　　　　　　　　　　　      <function foo at 0x7fc1b1dd01e0>
********************************************************

def test1():
    print('from test1')

def test2():
    print('from test2')
    return test1()=====》return test1() 就是return: test1()运行的返回值
print(test2())======>结果是：

from test2
from test1
None

-filter 函数 

filter(参数1，参数2)  参数1：函数   参数2:可迭代对象

 filter 遍历列表中的每个元素，判断每个元素的布尔值，如果是True则留下来。

即：对序列中的元素进行删选，如果是true,则留下来，最终获取符合条件的序列

print (filter(函数，可迭代对象))====>打印结果是地址。查看最终结果需要

list(filter(函数，可迭代对象)),然后打印代码：print(list(filter(函数，可迭代对象)),)

 filter函数作用：删选

打印列表movie_people = ['hi_sb', 'show_sb', 'wang', 'alisa_sb']中没有以sb 结尾的元素。

分析：

首先先写基本代码：

new_people = []

for i in movie_people:

　　if not i.endswith('sb'):

　　　　new_people.append(i)

print (new_people)

再将将其转变为函数：其中发现movie_people 可以作为函数参数 any，再在结尾加上返回变为以下函数：

def  filter_test(any)：

　　new_people = []

　　for i in movie_people:

　　　　if not i.endswith('sb'):

　　　　　　new_people.append(i)

　　return new_people

res = filter_test(movie_people)

print(res)

另外 其中以什么结尾的判断可以另外列为一个函数。将其放在函数filter_test(any)中，即为filter_test(func,any),其中func 代表函数sb_show.

def sb_show(n):

　　return n.endswith('sb')　

所以函数如下：　　　　　　

movie_people = ['hi_sb', 'show_sb', 'wang', 'alisa_sb']

def sb_show(n):
    return n.endswith('sb')

def filter_test(func, any):
    new_people = []
    for i in any:
        if not func(i):
            new_people.append(i)
    return new_people
res = filter_test(sb_show, movie_people)
print(res)

 由于函数sb_show.改为匿名函数：lambda n: n.endswith('sb')，所以最终函数如下：

movie_people = ['hi_sb', 'show_sb', 'wang', 'alisa_sb']

def filter_test(func, any):
    new_people = []
    for i in any:
        if not func(i):
            new_people.append(i)
    return new_people
res = filter_test(lambda n :n.endswith('sb'), movie_people)
print(res)

 用 filter 函数解决：

filter(lambda n : not n.endswith('sb'),movie_people)
res = list(filter(lambda n : not n.endswith('sb'),movie_people))
print(res)

用filter函数解决例如：

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

s=filter(lambda x:x>2,li)
print(list(s))#====结果是：[3, 4, 5]

-reduce函数 

 reduce(function, sequence,inital)

refuce函数作用：处理序列，并对序列进行合并操作，例如：求和等

function:功能一般是函数

sequence:序列：如列表等

inital 代表初始值，一般默认是None

打印结果代码：print(reduce(function, sequence,inital)))

如下：

li = [1,2,3,4,5]
from functools import reduce
s=reduce(lambda x,y:x+y,li)
print(s)#====结果是15

------------------------------------------ 

 

 设置默认值 init.

num_1 = [1, 2, 3,100]

def reduce_test(funct, any, init = None):
    if init is None:
        start = any.pop(0)
    else:
        start = init
    for num in any:
        start = funct(start, num)
    return start
print(reduce_test(lambda x,y: x + y,num_1))

  reduce 函数：合并序列压倒一起。

运用reduce 函数，需要先引入函数代码：

from functools import reduce

上述用reduce函数表示：

from functools import reduce
num_1 = [1, 2, 3,100]
print(reduce(lambda x,y: x + y, num_1))=======》结果是106

-map 函数

map(funct, array)  funct: 函数   array:序列

查看map函数结果代码：print（list(map())）

map 函数作用：处理序列中每个元素，得到的结果组成一个“列表”，该列表元素的位置与个数与原列表一样

 对列表list1 = [1, 2, 3,100]中的每个元素做平方处理

list1 = [1, 2, 3,100]
map(lambda x: x**2,list1)
print(list(map(lambda x:x**2,list1)))======》结果是：[1, 4, 9, 10000]

-内置函数 

 可参考网址：https://www.runoob.com/python/python-built-in-functions.html

1）abs() 求绝对值

print(abs(-1))======>结果是1

 2）all() 布尔运算

一个假，结果是假

所有为真，结果是真

注意：0,空，以及None的布尔值都是False

另外如果可迭代对像看作一个整体，整体是空的话，布尔值为true

print(all(""))=====>结果是：True

print(all([1,2,'']))====》结果是：False。因为列表中有一个空，其布尔值是假，有一个为假，其结果就是假。所有都为真，其结果才是真

3）any() 布尔运算

有一个真，结果是真

print(any([1,'']))=======》结果为True

4）bin() 将十进制转换成二进制

print(bin(10))======>结果是：0b1010 其中0b代表二进制

5) bool() 判断布尔值

print(bool(''))========结果是：False
0,空，以及None的布尔值都是False

6) bytes() 求编码

name = "你好"
print(bytes(name,encoding='utf-8'))=======结果是：b'xe4xbdxa0xe5xa5xbd'

print(bytes(name,encoding='utf-8').decode('utf-8'))======》结果是：你好
decode 是解码

7)chr() 返回值是当前整数对应的 ASCII 字符。数字对应字符

print(chr(88))=======> X

8)dict()字典

9)dir()打印某一个对象下的所有方法

10)divmod() 求商取余，用来做分页

 print(divmod(4,2))======>结果是（2，0）  

11）enumerate() 

函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中.添加索引序列

>>>seasons = ['Spring', 'Summer', 'Fall', 'Winter'] >>> list(enumerate(seasons)) [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')] >>> list(enumerate(seasons, start=1)) # 下标从 1 开始 [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

12）eval()

-把字符串中的数据结构提取出来

dic = {'name':"alisa"}
dic_str = str(dic)
d1=eval(dic_str)
print(d1['name'])======>结果是alisa

-字符串中的数学运算计算出来

str1 = "1*2+(3/3-1)"
print(eval(str1))======>结果是2.0

13) filter 参考之前，过滤序列中元素，留存结果是true的元素，组成新列表

14）float(x)函数用于将整数和字符串转换成浮点数。 x -- 整数或字符串

>>>float(1) 1.0

>>> float(112)112.0

>>> float(-123.6) -123.6

>>> float('123') # 字符串 123.0

15) format()基本语法是通过 {} 和 : 来代替以前的 % 。

# 通过字典设置参数

site = {"name": "菜鸟教程", "url": "www.runoob.com"}

print("网站名：{name}, 地址 {url}".format(**site))==========网站名：菜鸟教程, 地址 www.runoob.com

# 通过列表索引设置参数

my_list = ['菜鸟教程', 'www.runoob.com']

print("网站名：{0[0]}, 地址 {0[1]}".format(my_list)) # "0" 是必须的======网站名：菜鸟教程, 地址 www.runoob.com

16)frozenset() 生成一个不可变，冻结的集合，冻结后集合不能再添加或删除任何元素。

b = frozenset('alisa')
print(b)======>frozenset({'a', 's', 'i', 'l'})

a = frozenset(range(10))
print(a)=========frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})

17)globals() 全局变量

18）hash用于获取取一个对象（字符串或者数值等）的哈希值。

可hash的数据类型是不可变数据类型，不可hash的数据类型是可变数据类型

19）help() 查看具体用法

print(help(dict))======》查看字典的具体用法

11）hex() 十进制改为十六进制

12）oct() 十进制改为八进制

print(hex(10))=======a
print(oct(10))=======12

13) id 打印对象的内存地址

14）isinstance() 判断对象是否符合

print(isinstance('1',int))======》“1” 不是数据类型，所以结果是False

15）globals 全局变量，locals 当前级别变量

16）max 取最大值 

-不同类型之间不能进行比较，比如 1 和“你”不能比较

-字典元素比较，默认比较字典的key

age = {'age1':22, 'age2':125, 'age3':35}
print(max(age))======>字典比较大小时默认比较key,所以结果时age3
print(max(zip(age.values(),age.keys())))=====>结果是集合(125, 'age2')

c1 = ['a2', 'b1','c1']======》进行比较时是从第一个开始比较，即a,b,c进行比较，c大因此后边不进行比较直接得到结果
print(max(c1))======》结果是c1
c2 = ['a12300', 'a3','a1']=====>第一位都是a因此进行比较第二位大小，由于a3第二位3大于其他所有，因此不再进行比较，直接得到结果
print(max(c2))=====》a3
c3 = [21, 123,13]====>数字进行比较时，直接按照数字大小比较
print(max(c3))=====》结果是123
**********************************************************

求取出年纪最大的元素
people = [{'name':'tina', 'age':12},
          {'name':'tom', 'age':88},
          {'name':'alisa', 'age':123}]

print(max(people,key=lambda dic:dic['age']))=====》{'name': 'alisa', 'age': 123}

17） zip() 对应组合

print(list(zip([1, 2, 3], ('a', 'b', 'c'))))============>[(1, 'a'), (2, 'b'), (3, 'c')]

print(list(zip([1, 2, 3, 4], ('a', 'b', 'c'))))==========>[(1, 'a'), (2, 'b'), (3, 'c')]

print(list(zip([1, 2, 3], ('a', 'b', 'c','d'))))==========>[(1, 'a'), (2, 'b'), (3, 'c')]

print(list(zip('hi','123')))============[('h', '1'), ('i', '2')]

p = {'name':'alisa', 'age':18, 'colour':'red'}
print(list(zip(p.keys(),p.values())))==============>[('name', 'alisa'), ('age', 18), ('colour', 'red')]

list(),结果最终是以[]显示，zip(),结果是以集合显示。

18）ord   字符在ASCII 中对应的数字

print(ord('X'))======>88

19）pow(x,y,z)

pow(x,y) 代表x 的y 次方即 x**y

print(pow(2,3))======>结果是8

pow(x,y,z) 代表x 的y 次方然后除以z,求余数即x**y%z

print(pow(2,3,3))======>结果是2

20）reversed 元素反转

s = ['ni','hi', 'hao','who']
print(list(reversed(s)))=============>['who', 'hao', 'hi', 'ni']
print(s)=======》['ni','hi', 'hao','who'] 因为reversed 只是临时执行并未保存，所以s不变 

21）round 四舍五入

print(round(2.53))=======>3

22) set 将元素变成集合

a = ['ni','wo']
print(set(a))=======》{'wo', 'ni'}

23）slice 切片

slice(x,y,z)  slice(x) 代表默认slice(0,x)

slice(x,y) 代表切片位置是大于等于x,小于y

slice(x,y,z) 代表切片位置是大于等于x,小于y 并且按照步长是z进行取值

a = 'nidehaoma'
print(a[2:6])
s1 = slice(2,6)
s2 = slice(2,6,2)
s3 = slice(2)
print(a[s1])==========》deha
print(a[s2])==========>首先取出deha然后按照步长是2进行切片最终结果是:dh
print(a[s3])==========>ni

24）sorted 排序

不同类型不能进行排序

sorted(iterable, cmp=None, key=None, reverse=False)

• iterable -- 可迭代对象。
• cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
• key -- 排序规则：主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
• reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

排序本质是在比较大小，sorted()函数默认会将列表元素按照从小到大排序。当给sorted函数传入参数“reverse=True”时，会进行反向排序，即会将列表元素从大到小排序

a = [3,5,0,2,1,0]
print(sorted(a))=====》结果是：[0, 0, 1, 2, 3, 5]

#按照age进行排序
people = [{'name':'tina', 'age':12},
          {'name':'tom', 'age':88},
          {'name':'alisa', 'age':123}]
print(sorted(people,key = lambda dic:dic['age']))=====>结果如下：
[{'name': 'tina', 'age': 12}, {'name': 'tom', 'age': 88}, {'name': 'alisa', 'age': 123}]

************************************************************
people = {'tom': 100, 'alisa': 150, 'tina': 166}
# 默认按照key进行排序,结果只有key
print(sorted(people))=================================================>['alisa', 'tina', 'tom']
# 按照value进行排序，结果只有value
print(sorted(people, key=lambda key: people[key]))====================>['tom', 'alisa', 'tina']
# 按照value 进行排序，结果显示出相对应的字典元素（key,value)
print(sorted(zip(people.values(),people.keys())))======================>[(100, 'tom'), (150, 'alisa'), (166, 'tina')]

25) import 导入模块

-在python中新建文档 test.py.并在此文档中写入一些功能，比如：

def say_hi:

　　print('你好‘）

需要在另一个文档中引入调用此功能 代码是：

import test

test.say_hi()=======>结果是：你好

*******************************

-若module name = "test" 是字符串类型，引入调用方法如下：

module name = "test"

m = _import_(module name)

m.say_hi()========>结果是：你好

26） time

-获取当前时间戳 time.time()

首先引入time : import time

import time
a = time.time()
print('当前时间戳为%s'%a)=====>当前时间戳为1619149658.361079

-获取当前格式化时间：time.asctime(time.localtime(time.time()))

import time
a = time.asctime(time.localtime(time.time()))
print(a)

====》结果是：Fri Apr 23 11:56:23 2021
**************************************

-import time 
# 格式化成2016-03-20 11:45:39形式
print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())

# 格式化成Sat Mar 28 22:24:24 2016形式 
print time.strftime("%a %b %d %H:%M:%S %Y", time.localtime())

# 将格式字符串转换为时间戳 

a = "Sat Mar 28 22:24:24 2016" print time.mktime(time.strptime(a,"%a %b %d %H:%M:%S %Y"))

-time.sleep(secs)
推迟调用线程的运行，secs指秒数。

-

time.asctime([tupletime])
接受时间元组并返回一个可读的形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日 周二18时07分14秒）的24个字符的字符串。

 27, struct 函数

-将整型(int)转换成字节 代码 struct.pack(‘i’，需要转换的内容）i 代表整型

-将字节转换成整型 代码 struct.unpack('i'，字节）

如下：

import struct
s=struct.pack('i',123489)
print(s)====>b'axe2x01x00'

s2 = struct.unpack('i',s)
print(s2)====》(123489,)

28，偏函数 如下：

from functools import partial

def add_test(x,y):
    return x+y
func =partial(add_test,1) #代表默认add_test函数中第一个变量为1，即x=1

print(func(1)) #等于1+1，结果是2
print(func(2)) #等于1+2，结果是3

29，iter 函数

-1，运用iter函数使其变成迭代器

l = ['a','b','c','d']

s = iter(l)#将列表l其变成可迭代s
print(next(s))#next(s)是迭代器，结果是a
print(next(s)) ======>结果是b
print(next(s)) =======>结果是c

-2，iter(x,y) x是变量，y是代表执行x 时，碰到y就运行结束

l = ['a','b','c','d']

def test_pop():
    return l.pop() #pop()函数是删除列表最后一个元素，并返回这个删除的元素
x=iter(test_pop,'b') #此处代表得到b,就不再执行迭代器
print(next(x))
print(next(x))
print(next(x))

 *30，三元运算

三元运算是对简单的条件语句的缩写。

代码如下：

变量名 = 值1 if 条件 else 值2

如果条件成立，那么值1赋值给变量，否则值2赋值给变量

例如：

name = 'nick' if 1==1 else 'jenny'

print(name) #====>结果是 nick

31,python 中的一些特殊代码

-变量1，变量2，变量3 = 值1，值2，值3  那么变量会与值会一一对应

s1,s2,s3 = 1,2,3
print(s1)#===>结果是 1
print(s2)#===>结果是 2
print(s3)#===>结果是 3

-2个变量的值互换

代码：变量1 = 值1

　　   变量2 = 值2

         变量1，变量2 =变量2，变量1

如下：

a = 1
b = 2
a,b = b,a
print(a)#===结果是2
print(b)#===结果是1

32，% 用法

第一种：数值运算 1 % 3 是指模运算, 取余数（remainder）

s = 7%2
print(s)#====求余数，结果是1

第二种：字符串操作 'abc %s' % 'abc' '%s'类似占位符 这行代码的结果

 问的是%操作符（字符串格式化，string formatting），说明如下：
%[(name)][flags][width].[precision]typecode
(name)为命名
flags可以有+，-，' '或0。+表示右对齐。-表示左对齐。' '为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填充。
width表示显示宽度
precision表示小数点后精度

以下是类型码
%s    字符串 (采用str()的显示)
%r    字符串 (采用repr()的显示)
%c    单个字符
%b    二进制整数
%d    十进制整数
%i    十进制整数
%o    八进制整数
%x    十六进制整数
%e    指数 (基底写为e)
%E    指数 (基底写为E)
%f    浮点数
%F    浮点数，与上相同%g    指数(e)或浮点数 (根据显示长度)
%G    指数(E)或浮点数 (根据显示长度)
%%    字符"%"即：百分号符号

举例：

s = '%6.3f' % 2.3
print(s)==》结果是： 2.300

# 第一个"%"后面的内容为显示的格式说明，6为显示宽度，3为小数点位数，f为浮点数类型
# 第二个"%"后面为显示的内容来源，输出结果右对齐，2.300长度为5，故前面有一空格

-----------------------------------------

s = '%+10x' % 10
print(s)#===结果是：        +a

# x为表示16进制，显示宽度为10，前面有8个空格

--------------------------

s = '%-5x' % 10
print(s)#====结果是：a    

#  "%-5x" 负号为左对齐，显示宽度为5，故a后面有3个空格

---------------------

s = '345'
print('s的值是%s'%s)#==结果是：s的值是345
****************************

s = ('345',3,2.1)
print('s的值是%s %d %f'%s)#===结果是：s的值是345 3 2.100000

#此处%是占位符，规定了替换的内容的类型

----------------

width, precision为两个整数。我们可以利用*，来动态代入这两个量。比如

a = '%10.*f'%(4,1.2)
print(a)#====结果是：    1.2000

# 此处的4替代了*，代表小数点后是4位数