python开发函数进阶：内置函数

一，内置函数

#内置的模块
#拿过来直接就用的：内置的函数

  1 #!/usr/bin/env python
  2 #_*_coding:utf-8_*_
  3 
  4 #内置的模块
  5 #拿过来直接就用的：内置的函数
  6 #作用域相关（2）（了解）
  7 #1.globals()==获取全局变量的字典
  8 #2.locals()==获取执行方法所在命名空间内的局部变量的字典
  9 
 10 
 11 #str类型代码执行相关(3)
 12 #1.eval()==将字符串类型的代码执行并返回结果==(掌握)
 13 #print(eval('1+2+3+4'))
 14 #print(eval('{'a':1}'))
 15 
 16 #2.exec()==将自字符串类型的代码执行==(掌握)
 17 #print(exec("1+2+3+4"))
 18 #exec("print('hello,world')")
 19 
 20 #3.compile()==（了解）
 21 #将字符串类型的代码编译。代码对象能够通过exec语句来执行或者eval()进行求值
 22 #http://www.cnblogs.com/Eva-J/articles/7266087.html
 23 #正常代码执行过程   读代码》执行
 24 #                  字符串》转换成代码》执行
 25 #compile()帮你去完成字符串》转化的过程
 26 # com = compile('1+2+3','',mode='eval')  编译  节省时间
 27 # print(eval(com))
 28 # print(eval(com))
 29 # 上面代码和下面代码结果一样，但是上面是先编译后执行的，下面代码每一次执行都要编译
 30 # print(eval('1+2+3'))
 31 # print(eval('1+2+3'))
 32 #mode 有 eval（有返回值） exec（无返回值）
 33 # single   # 这个模式千万不要用，会把内存改的乱七八糟   ********* 没懂
 34 # s = "name = input('user:')"
 35 # com = compile(s,'',mode='single')
 36 # exec(com)
 37 
 38 
 39 #其他（11）
 40 #输入输出（2）(了解)
 41 #1.input()==输入==输入的值str数据类型
 42 #2.print()==输出
 43 # def print(self, *args, sep=' ', end='\n', file=None): # known special case of print
 44 """
 45 # print源码剖析
 46 
 47     print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
 48     file:  默认是输出到屏幕，如果设置为文件句柄，输出到文件
 49     sep:   打印多个值之间的分隔符，默认为空格，必须关键字传参，seq = ','
 50     end:   每一次打印的结尾，默认为换行符
 51     flush: 立即把内容输出到流文件，不作缓存
 52 
 53 f = open('tmp_file','w')  #######################  未来写日志用
 54 print(123,456,sep=',',file = f,flush=True)
 55 """
 56 
 57 #数据类型（1）（掌握）
 58 #type(o)==返回变量o的数据类型
 59 
 60 #内存相关（2）（掌握）
 61 #id(o)==o是参数，返回一个变量的内存地址
 62 #hash(o)==o是参数，返回一个可hash变量的哈希值，不可hash的变量被hash之后会报错
 63 '''
 64 hash函数会根据一个内部的算法对当前可hash变量进行处理，返回一个int数字。
 65 *每一次执行程序，内容相同的变量hash值在这一次执行过程中不会发生改变。
 66 t = (1,2,3)
 67 l = [1,2,3]
 68 print(hash(t))  #可hash
 69 print(hash(l))  #会报错
 70 结果：
 71 TypeError: unhashable type: 'list'
 72 hash实例
 73 当你需要唯一的值需要的时候才会用到
 74 '''
 75 
 76 #身份运算（课外补充）
 77 #is  比对值和内存地址  id
 78 #==  只是比对值
 79 
 80 #文件操作相关（1）（掌握）
 81 #open()==打开一个文件，返回一个文件操作符(文件句柄)
 82 #r,w,a,r+,w+,a+,(都可以+b)
 83 # f = open('tmp','r+')
 84 # print(f.read(3))
 85 # f.seek(5)
 86 # f.write('ccccccc')
 87 # #不要一边写一边读
 88 # f.close()
 89 #r+打开文件
 90 #如果直接写 从头覆盖
 91 #如果读了再写 追加
 92 #如果seek指定了光标的位置 就在从该位置开始覆盖着写
 93 
 94 #模块操作相关（1）（掌握）
 95 #_import_==import==导入一个模块 import相当于_import_语法糖
 96 # print(1+2)
 97 # print(sum(1,2))
 98 
 99 #帮助（1）（了解）
100 #help()==帮助模式，可以随意输入变量或者变量的类型。输入q退出。或者直接执行help(o)，o是参数，查看和变量o有关的操作。
101 
102 #调用相关（1）（了解） 判断是不是可调用
103 #callable(o)==o是参数，看这个变量是不是可调用。
104             #如果o是一个函数名，就会返回True
105 '''
106 def func():pass
107 print(callable(func))  #参数是函数名，可调用，返回True
108 print(callable(123))   #参数是数字，不可调用，返回False
109 '''
110 # print(callable(123)) FALSE
111 # print(callable(open)) TRUE
112 
113 #查看参数所属类型的所有内置方法（1）（掌握）
114 #dir()==默认查看全局空间内的属性，也接受一个参数，查看这个参数内的方法或变量
115 '''
116 print(dir(list))  #查看列表的内置方法
117 print(dir(int))  #查看整数的内置方法
118 '''
119 # print(dir(__builtins__))  #告诉所有内置的名称
120 # print(dir(int))
121 # print(dir(list))
122 # print(set(dir(list)) - set(dir(tuple)))  #list方法有，tuple里面没有的
123 
124 
125 #数字相关（14）
126 #数据类型相关（4）
127 #bool==
128 #int==
129 #float==
130 #complex==复数==（了解）
131 
132 #进制转换相关（3）=（了解）
133 #bin==二进制
134 #oct==八进制
135 #hex==六进制
136 
137 #数学运算（7）
138 #abs==计算绝对值
139 #divmod==返回（除，余）
140 # divmod(7.3) == (2,1)
141 #min==计算最小值
142 #min(list,数字)，可以使序列，可以使散列
143 #max==计算最大值，可以是序列，可以是散列
144 #sum==求和==参数必须是一个序列类型
145 # print(1+2) == print(int(1).__add__(2))
146 #round==小数的精确
147 #pow==幂次方的运算
148 # print(pow(2,2))
149 
150 
151 #数据结构相关（24）
152 #序列（13）
153 #列表和元祖（2）
154 #相关内置函数（2）
155 #1.reversed()==顺序的反转
156 # l = [1,2,3,4]
157 # print(list(reversed(l)))  #生成一个新列表,迭代器
158 # l.reverse()  #更改了源列表
159 # print(l)
160 #2.slice()略过
161 #字符串（9）
162 #1.str()==关键字
163 #2.format()
164 # print(format('test', '<20')) 左对齐，开辟20个空间
165 # print(format('test', '>40')) 右对其
166 # print(format('test', '^40')) 居中
167 #3.bytes()==（掌握）
168 # s = "你好"
169 # sb = bytes(s,encoding='utf-8')
170 # print(sb)
171 # ret = sb.decode('utf-8')
172 # print(ret)
173 #4.bytearray()==字节数组
174 # sb2 = bytearray(s,encoding='utf-8')  #列表
175 # print(sb2)
176 # sb2[0] = 229
177 # print(sb2.decode('utf-8'))
178 # print(sd(s))
179 #5.memoryview()
180 #6.ord()==字符按照unicode转数字
181 #7.chr（）==数字按照unicode转字符
182 #8.ascii（）==字符串转ascii
183 #9.repr==用于%r的格式化输出==（掌握）
184 # print(repr('1234'))
185 # print(repr(1234))
186 # print('name : %r'%('egon')) 保留引号
187 
188 #数据集合（3）
189 #字典（1）
190 #dict()
191 #集合（2）
192 #set()
193 #frozenset()不可变得集合,括号内加集合
194 
195 
196 
197 #相关内置函数（8）
198 #len()  字典也是有长度的 == (掌握)
199 #enumerate()==有一个拆包过程 == （掌握）
200 # for i,j in enumerate(l,1):
201 #     print(i,j)
202 #all()==有一个不是真，就返回false
203 # print(all([1,2,3]))
204 # print(all([0,2,3]))
205 # any()
206 # print(any([0,1,0]))
207 # print(any([0,0,0]))
208 # zip()
209 # l = [1,2,3]
210 # l2 = [4,5,6]
211 # print(zip(l,l2))  #地址
212 # print(list(zip(l,l2)))  #只取前面匹配住的，超过按短的来.字典也可以
213 # l = [1,2,3]      #3
214 # l2 = {'k':'v'}  #1
215 # print(zip(l,l2))
216 # print(list(zip(l,l2)))
217 #sorted()==排序==（掌握）
218 #sort针对list的成员函数sort进行排序，不返回副本
219 # l = [1,3,5,-2,-4,-6]
220 # l.sort()
221 # print(l)
222 
223 # l2 = [1,3,5,-2,-4,-6]
224 # print(sorted(l2,key=abs,reverse=True))  #创建新的内存地址，返回了一个新的列表，也不修改原列表
225 # print(sorted(l2))     #abs按绝对值排序，reverse降序
226 # print(l2)
227 
228 # filer（） #从一个列表当中找到符合筛选条件的组成新列表==（掌握）
229 # map（）   #对一个列表当中每一个值，做一样的操作，组成新的列表

# filter  第一个参数，判断函数，第二个参数，可迭代对象
# filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
# 该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
# 语法：filter(function, iterable) filter返回迭代器
def is_odd(n):
    return n % 2 == 1

newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

print(newlist)  # <filter object at 0x102079b00>
for i in newlist:
    print(i) # 13579
# 匿名函数写法
print(list(filter(lambda x:x%2==1,[1,2,3])))

# map() 会根据提供的函数对指定序列做映射。第一个是函数，第二个是可迭代对象，第三个一样。。。
# 第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
# 语法 map(function, iterable, ...)
def square(x,Y) :            # 计算平方，如果参数多个，那么是相对位置
    return x ** 2,Y ** 2

print(map(square, [1,2,3,4,5]))   # 计算列表各个元素的平方，返回迭代器
for i in map(square, [1,2,3,4,5],[6,7,8]):
    print(i)
'''
(1, 36)
(4, 49)
(9, 64)
'''
    
# 匿名函数写法
print(map(lambda x: x ** 2, [1, 2, 3, 4, 5]))  # 使用 lambda 匿名函数
# 提供了两个列表，对相同位置的列表数据进行相加
map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])

 

转载于:https://www.cnblogs.com/jokerbj/p/7282093.html