Python3内置函数大全
1.abs()函数
'''
abs() 函数返回数字的绝对值。d'd'd'd
绝对值：absolutedddd
正如字面上的意思，可以返回一个绝对值
'''
import math
print('abs(45)的值:',abs(45))
print('abs(-45)的值:',abs(-45))
print('abs(45+23)的值:',abs(45+23))
print('abs(math.pi)的值:',abs(math.pi))
print(help(abs))
'''
运行结果：
abs(45)的值: 45
abs(-45)的值: 45
abs(45+23)的值: 68
abs(math.pi)的值: 3.141592653589793
Help on built-in function abs in module builtins:
abs(x, /)
Return the absolute value of the argument.
None
在python2 里还可以输出 print "abs(119L) : ", abs(119L) 不过python3中abs函数只能输入int型 不然会报错
'''
2.all()函数
'''
all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。
元素除了是 0、空、FALSE 外都算 TRUE。
语法
以下是 all() 方法的语法:
all(iterable)
参数
iterable -- 元组或列表。
返回值
如果iterable的所有元素不为0、''、False或者iterable为空，all(iterable)返回True，否则返回False；
注意：空元组、空列表返回值为True，这里要特别注意。
'''
print(all(['a','b','c','']))
print(all(['a','b','c','d']))
print(all([0,1,2,3,4,5,6]))
print(all(('a','b','c','')))
print(all(('a','b','c','d')))
print(all((0,1,2,3,4,5)))
print(all([]))
print(all(()))
3.any()函数
'''
any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。
元素除了是 0、空、FALSE 外都算 TRUE。
语法
以下是 any() 方法的语法:
any(iterable)
参数
iterable -- 元组或列表。
返回值
如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true。
'''
print(any(['a','b','c','']))
print(any(['a','b','c','d']))
print(any([0,'',False]))
print(any(('a','b','c','')))
print(any(('a','b','c','d')))
print(any((0,'',False)))
print(any([]))
print(any(()))
4.ascii()函数
'''
ascii() 函数类似 repr() 函数, 返回一个表示对象的字符串,
但是对于字符串中的非 ASCII 字符则返回通过 repr() 函数使用 \x, \u 或 \U 编码的字符。
生成字符串类似 Python2 版本中 repr() 函数的返回值。
语法
以下是 ascii() 方法的语法:
ascii(object)
参数
object -- 对象。
返回值
返回字符串
'''
print(ascii('uiatfu'))
5.bin()函数
'''
函数原型
bin(x)
参数解释
x
整数型，参数不可为空。
返回值
<class 'str'> 字符串类型，二进制整数。
函数说明
将一个整数转化为一个二进制整数，并以字符串的类型返回。
'''
print(bin(12))
print(bin(-120))
print(type(bin(12)))
print(int(bin(10),base=2)+int(bin(20),base=2))
print(bin(0b10010))
print(bin(0o1357))
print(bin(0x2d9))
6.bool()函数
'''
描述
bool() 函数用于将给定参数转换为布尔类型，如果没有参数，返回 False。
bool 是 int 的子类。
语法
以下是 bool() 方法的语法:
class bool([x])
参数
x -- 要进行转换的参数。
返回值
返回 Ture 或 False。
'''
print(bool(0))
print(bool(1))
print(bool(True))
print(bool(False))
print(bool(''))
7.bytes()函数
'''
描述
bytes 函数返回一个新的 bytes 对象，该对象是一个 0 <= x < 256 区间内的整数不可变序列。
它是 bytearray 的不可变版本。
语法
以下是 bytes 的语法:
class bytes([source[, encoding[, errors]]])
参数
如果 source 为整数，则返回一个长度为 source 的初始化数组；
如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
如果没有输入任何参数，默认就是初始化数组为0个元素。
返回值
返回一个新的 bytes 对象。
将一个字符串转换成字节类型
'''
print(bytes('python',encoding='utf-8'))
print(bytes('张三',encoding='utf-8'))
print(bytes([1,2,3,4]))
print(bytes('hello','ascii'))
print(type(bytes([1,2,3])))
8.challable()函数
'''
challable() 判断对象是否可以被调用，
能被调用的对象就是一个callables对象，
比如函数和带有__call__()的实例
'''
print(callable(max))
print(callable([1,2,3]))
print(callable(None))
print(callable('str'))
def fn(x):
return x*x
print(callable(fn))
9.chr()函数
'''
查看十进制数对应的ASCII码值
描述
chr() 用一个整数作参数，返回一个对应的字符。
语法
以下是 chr() 方法的语法:
chr(i)
参数
i -- 可以是 10 进制也可以是 16 进制的形式的数字，数字范围为 0 到 1,114,111 (16 进制为0x10FFFF)。
返回值
返回值是当前整数对应的 ASCII 字符。
'''
print(chr(0x30))
print(chr(97))
print(chr(8364))
10.classmethod()函数
'''
描述
classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，
但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。
语法
classmethod 语法：
classmethod
参数
无。
返回值
返回函数的类方法。
'''
class Stud:
num=1
def fn1(self):
print('方法一')
@classmethod
def fn2(cls):
print('方法二')
print(cls.num)
cls().fn1()
Stud.fn2()
print('===='*10)
object=Stud()
object.fn1()
11.complex()函数
'''
描述
complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。
如果第一个参数为字符串，则不需要指定第二个参数。。
语法
complex 语法：
class complex([real[, imag]])
参数说明：
real -- int, long, float或字符串；
imag -- int, long, float；
返回值
返回一个复数。
'''
print(complex(1,2))
print(complex(1))
print(complex('2'))
print(complex('2+3j'))
print(complex(1.2,3.4))
12.complie()函数
'''
complie() 将字符串编译成python能识别或可以执行的代码，也可以将文字读成字符串再编译
1 compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)
2 将source编译为代码或者AST对象。代码对象能过通过exec语句来执行或者eval()进行求值。
3 参数source：字符串或者AST（abstract syntax trees）对象。
4 参数filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
5 参数model：指定编译代码的种类。可以指定'exec', 'eval', 'single'。
6 参数flag和dont_inherit：这两个参数为可选参数。
'''
s="print('hello world')"
r=compile(s,'hello','exec')
print(r)
13.delattr()函数
'''
描述：
delattr函数用于删除属性
delattr(x,'foobar)相当于del x.foobar
语法：
setattr(object,name)
参数：
object--对象
name--必须是对象的属性
返回值：
无
'''
class People():
sex='男'
def __init__(self,name):
self.name=name
def peopleinfo(self):
print('欢迎%s访问'%self.name)
delattr(People,'sex')
print(People.__dict__)
class Foo:
def run(self):
while True:
cmd=input('cmd>>: ').strip()
if hasattr(self,cmd):
func=getattr(self,cmd)
func()
def download(self):
print('download....')
def upload(self):
print('upload...')
obj=Foo()
obj.run()
14.dict()函数
'''
描述
dict() 函数用于创建一个字典。
语法
dict 语法：
class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)
参数说明：
**kwargs -- 关键字
mapping -- 元素的容器。
iterable -- 可迭代对象。
返回值
返回一个字典。
'''
print(dict())
dict1=dict(a='a', b='b', t='t')
print(dict1)
dict2=dict(zip(['one', 'two', 'three'], [1, 2, 3]))
print(dict2)
dict3=dict([('one', 1), ('two', 2), ('three', 3)])
print(dict3)
15.dir()函数
'''
dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。
语法
dir 语法：
dir([object])
参数说明：
object -- 对象、变量、类型。
返回值
返回模块的属性列表。
'''
print(dir())
print(dir([]))
print(dir(str))
print(dir(dict))
def update_func(var):
print("var 的内存地址:", id(var))
var += [4]
lst_1 = [1, 2, 3]
print(dir())
class Shape:
def __dir__(self):
return ['area', 'perimeter', 'location']
s = Shape()
print(dir(s))
16.divmod()函数
'''
python divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。
在 python 2.3 版本之前不允许处理复数。
函数语法
divmod(a, b)
参数说明：
a: 数字
b: 数字
'''
print(divmod(20,4))
print(divmod(7,2))
print(divmod(8,2))
17.enumerate()函数
'''
enumerate是翻译过来是枚举的意思，看下它的方法原型：
enumerate(sequence, start=0)，返回一个枚举对象。
sequence必须是序列或迭代器iterator，或者支持迭代的对象。
enumerate()返回对象的每个元素都是一个元组，
每个元组包括两个值，一个是计数，一个是sequence的值，
计数是从start开始的，start默认为0。
---------------------
'''
a=["q","w","e","r"]
c=enumerate(a)
for i in c:
print(i)
'''
输出如下:
(0, 'q')
(1, 'w')
(2, 'e')
(3, 'r')
'''
a=["w","a","s","d"]
c=enumerate(a,2)
for i in c:
print(i)
'''
输出如下：
(2, 'w')
(3, 'a')
(4, 's')
(5, 'd')
'''
a=["q","w","e","r"]
b=dict()
for i,item in enumerate(a):
b[i]=item
print(b)
for i,j in enumerate('abc'):
print(i,j)
18.eval()函数
'''
eval() 函数用来执行一个字符串表达式，并返回表达式的值。
语法
以下是 eval() 方法的语法:
eval(expression[, globals[, locals]])
参数
expression -- 表达式。
globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
返回值
返回表达式计算结果。
'''
x=7
print(eval('3*x'))
print(eval('pow(2,2)'))
print(eval('3+5'))
a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]"
print(type(a))
b = eval(a)
print(type(b))
print(b)
a = "{1: 'a', 2: 'b'}"
print(type(a))
b = eval(a)
print(type(b))
print(b)
a = "([1,2], [3,4], [5,6], [7,8], (9,0))"
print(type(a))
b=eval(a)
print(type(b))
print(b)
19.exec()函数
'''
函数的作用：
动态执行python代码。也就是说exec可以执行复杂的python代码，而不像eval函数那样只能计算一个表达式的值。
exec(source, globals=None, locals=None, /)
source：必选参数，表示需要被指定的python代码。它必须是字符串或code对象。如果source是一个字符串，该字符串会先被解析为一组python语句，然后执行。如果source是一个code对象，那么它只是被简单的执行。
返回值：
exec函数的返回值永远为None。
eval()函数和exec()函数的区别：
eval()函数只能计算单个表达式的值，而exec()函数可以动态运行代码段。
eval()函数可以有返回值，而exec()函数返回值永远为None。
'''
x = 10
def func():
y = 20
a = exec("x+y")
print("a:",a)
b = exec("x+y",{"x":1,"y":2})
print("b:",b)
c = exec("x+y",{"x":1,"y":2},{"y":3,"z":4})
print("c:",c)
d = exec("print(x,y)")
print("d:",d)
func()
x = 10
expr = """
z = 30
sum = x + y + z #一大包代码
print(sum)
"""
def func():
y = 20
exec(expr)
exec(expr,{'x':1,'y':2})
exec(expr,{'x':1,'y':2},{'y':3,'z':4})
func()
20.filter()函数
'''
filter() 函数是一个对于可迭代对象的过滤器，过滤掉不符合条件的元素，
返回的是一个迭代器，如果要转换为列表，可以使用 list() 来转换。
该函数接收两个参数，第一个为函数的引用或者None，第二个为可迭代对象，
可迭代对象中的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到迭代器中
下面看下fiter()的用法：
'''
my_list=[1,2,'',3,4,'6',' ']
new_list=list(filter(None,my_list))
print(new_list)
def is_oushu(x):
return x%2==0
new_list=list(filter(is_oushu,list(range(1,11))))
print(new_list)
a=[1,2,3,4,5,6,2,2,2,]
print(list(filter(lambda x:x!=2,a)))
21.float()函数
'''
描述
float() 函数用于将整数和字符串转换成浮点数。
语法
float()方法语法：
class float([x])
参数
x -- 整数或字符串
返回值
返回浮点数。
'''
print(float(1))
print(float(112.0))
print(float('123'))
print(float(True))
print(float(False))
22.format()函数
'''
自python2.6开始，新增了一种格式化字符串的函数str.format()，此函数可以快速处理各种字符串。
语法
它通过{}和:来代替%。
请看下面的示例，基本上总结了format函数在python的中所有用法
'''
print ('{0},{1}'.format('chuhao',20))
print ('{},{}'.format('chuhao',20))
print ('{1},{0},{1}'.format('chuhao',20))
print ('{name},{age}'.format(age=18,name='chuhao'))
class Person:
def __init__(self,name,age):
self.name = name
self.age = age
def __str__(self):
return 'This guy is {self.name},is {self.age} old'.format(self=self)
print (str(Person('chuhao',18)))
a_list = ['chuhao',20,'china']
print ('my name is {0[0]},from {0[2]},age is {0[1]}'.format(a_list))
b_dict = {'name':'chuhao','age':20,'province':'shanxi'}
print ('my name is {name}, age is {age},from {province}'.format(**b_dict))
print ('{:>8}'.format('189'))
print ('{:0>8}'.format('189'))
print ('{:a>8}'.format('189'))
print ('{:.2f}'.format(321.33345))
print ('{:,}'.format(1234567890))
print ('{:b}'.format(18))
print ('{:d}'.format(18))
print ('{:o}'.format(18))
print ('{:x}'.format(18))
23.frozenset()函数
'''
描述
frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
语法
frozenset() 函数语法：
class frozenset([iterable])
参数
iterable -- 可迭代的对象，比如列表、字典、元组等等。
返回值
返回新的 frozenset 对象，如果不提供任何参数，默认会生成空集合。
'''
a=frozenset(range(10))
print(a)
b=frozenset('ltftyut1234')
print(b)
24.getattr()函数
'''
描述：
getattr()函数用于返回一个对象属性值
语法：
getattr(object,name,default)
参数：
object--对象
name--字符串，对象属性
default--默认返回值，如果不提供该参数，在没有对应属性时，将触发AttributeError。
返回值：
返回对象属性值
'''
class People():
sex='男'
def __init__(self,name):
self.name=name
def peopleinfo(self):
print('欢迎%s访问'%self.name)
obj=getattr(People,'sex')
print(obj)
'''
报错。。。
Traceback (most recent call last):
File "G:/pythonAI/Python_funs/getattr函数详解.py", line 24, in <module>
obj=getattr(People,'sexage')
AttributeError: type object 'People' has no attribute 'sexage'
'''
obj=getattr(People,'sexage',None)
print(obj)
25.globals() 函数
'''
描述
globals() 函数会以字典类型返回当前位置的全部全局变量。
语法
globals() 函数语法：
globals()
参数
无
返回值
返回全局变量的字典
'''
a='ltftyut1234'
print(globals())
def zero_promo():
return 0
def one_promo():
return 1
def two_promo():
return 2
def hello():
print("Hello")
if __name__ == '__main__':
promos = [name for name in globals()if name.endswith("_promo")]
print(promos)
promos = [globals()[name] for name in globals() if name.endswith("_promo")]
print(promos[0]())
26.hasattr()函数
'''
hasattr()函数用于判断是否包含对应的属性
语法：
hasattr(object,name)
参数：
object--对象
name--字符串，属性名
返回值：
如果对象有该属性返回True，否则返回False
'''
class People():
sex='男'
def __init__(self,name):
self.name=name
def peopleinfo(self):
print('欢迎%s访问'%self.name)
obj=People('zhangsan')
print(hasattr(People,'sex'))
print('sex'in People.__dict__)
print(hasattr(obj,'peopleinfo'))
print(People.__dict__)
27.hash()函数
'''
描述
hash() 用于获取取一个对象（字符串或者数值等）的哈希值。
语法
hash 语法：
hash(object)
参数说明：
object -- 对象；
返回值
返回对象的哈希值。
'''
print(hash('test'))
print(hash(1))
print(hash(str([1,2,3])))
print(hash(str(sorted({'1':1}))))
'''
hash() 函数可以应用于数字、字符串和对象，不能直接应用于 list、set、dictionary。
在 hash() 对对象使用时，所得的结果不仅和对象的内容有关，还和对象的 id()，也就是内存地址有关。
'''
class Test:
def __init__(self, i):
self.i = i
for i in range(10):
t = Test(1)
print(hash(t), id(t))
'''
-9223371889060894604 2364702099272
147793883435 2364702134960
-9223371889060894604 2364702099272
147793883435 2364702134960
-9223371889060894604 2364702099272
147793883435 2364702134960
-9223371889060894604 2364702099272
147793883435 2364702134960
-9223371889060894604 2364702099272
147793883435 2364702134960
'''
'''
hash() 函数的用途
hash() 函数的对象字符不管有多长，返回的 hash 值都是固定长度的，
也用于校验程序在传输过程中是否被第三方（木马）修改，
如果程序（字符）在传输过程中被修改hash值即发生变化，
如果没有被修改，则 hash 值和原始的 hash 值吻合，
只要验证 hash 值是否匹配即可验证程序是否带木马（病毒）。
'''
name1='正常程序代码'
name2='正常程序代码带病毒'
print(hash(name1))
print(hash(name2))
28.hex() 函数
'''
描述
hex() 函数将一个整数转换成十六进制字符串。
语法
hex 语法：
hex(x)
参数说明：
x -- 整数。
返回值
返回十六进制字符串。
'''
print(hex(12))
print(hex(-120))
print(type(hex(12)))
print(int(hex(10),base=16)+int(hex(15),base=16))
print(hex(0b10010))
print(hex(0o1357))
print(hex(0x2d9))
29id() 函数
'''
id() 函数用于获取对象的内存地址。
语法
id 语法：
id([object])
参数说明：
object -- 对象。
返回值
返回对象的内存地址。
'''
str='zhangsan'
print(id(str))
b=1
print(id(b))
'''
id方法的返回值就是对象的内存地址。
python2中会为每个出现的对象分配内存，哪怕他们的值完全相等（注意是相等不是相同）。
如执行a=2.0，b=2.0这两个语句时会先后为2.0这个Float类型对象分配内存，
然后将a与b分别指向这两个对象。所以a与b指向的不是同一对象
python3中 值相等的变量 内存一样 如下图所示
'''
a=10.21
b=10.21
print(id(a))
print(id(b))
print(a is b)
print(a == b)
'''
id 函数 涉及到 浅拷贝和深拷贝的相关知识
深copy和浅copy
深copy新建一个对象重新分配内存地址，复制对象内容。
浅copy不重新分配内存地址，内容指向之前的内存地址。
浅copy如果对象中有引用其他的对象，如果对这个子对象进行修改，子对象的内容就会发生更改。
'''
import copy
numbers=['1','2','3',['4','5']]
num1=copy.copy(numbers)
num2=copy.deepcopy(numbers)
num1.append('6')
print('numbers:',numbers)
print('numbers memory address:',id(numbers))
print('numbers[3] memory address',id(numbers[3]))
print('num1:',num1)
print('num1 memory address:',id(num1))
print('num1[3] memory address',id(num1[3]))
num1[3].append('6')
print('numbers:',numbers)
print('num1:',num1)
print('num2',num2)
'''
输出：
numbers: ['1', '2', '3', ['4', '5']]
numbers memory address: 1556526434888
numbers memory address 1556526434952
num1: ['1', '2', '3', ['4', '5'], '6']
num1 memory address: 1556526454728
num1[3] memory address 1556526434952
numbers: ['1', '2', '3', ['4', '5', '6']]
num1: ['1', '2', '3', ['4', '5', '6'], '6']
num2 ['1', '2', '3', ['4', '5']]
'''
30.input() 函数
'''
Python3.x 中 input() 函数接受一个标准输入数据，返回为 string 类型。
注意：在 Python3.x 中 raw_input() 和 input() 进行了整合，
去除了 raw_input( )，仅保留了input( )函数，其接收任意任性输入，
将所有输入默认为字符串处理，并返回字符串类型。
函数语法
input([prompt])
参数说明：
prompt: 提示信息
'''
a=input('请输入一个数:')
print(a)
print(type(a))
b=int(a)+10
print(b)
a=input('请输入一个字符串:')
print(a)
print(a.split('1'))
31.int()函数
'''
int([x[,radix]])
如果参数是字符串，那么它可能包含符号和小数点。参数radix表示转换的基数（默认是10进制）。
它可以是[2,36]范围内的值，或者0。如果是0，系统将根据字符串内容来解析。
如果提供了参数radix，但参数x并不是一个字符串，将抛出TypeError异常；
否则，参数x必须是数值（普通整数，长整数，浮点数）。通过舍去小数点来转换浮点数。
如果超出了普通整数的表示范围，一个长整数被返回。
如果没有提供参数，函数返回0。
int(x, [base])
作用：
将一个数字或base类型的字符串转换成整数。
int(x=0)
int(x, base=10)，base缺省值为10，也就是说不指定base的值时，函数将x按十进制处理。
注：
1. x 可以是数字或字符串，但是base被赋值后 x 只能是字符串
2. x 作为字符串时必须是 base 类型，也就是说 x 变成数字时必须能用 base 进制表示
'''
print(int(2.1))
print(int(2e3))
print(int('abc12',16))
print(int('FZ',36))
print(int('0x10', 16))
print(int('0x10', 36))
32isinstance() 函数
'''
isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。
isinstance() 与 type() 区别：
type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
语法
以下是 isinstance() 方法的语法:
isinstance(object, classinfo)
参数
object -- 实例对象。
classinfo -- 可以是直接或间接类名、基本类型或者有它们组成的元组。
返回值
如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。。
'''
a=2
print(isinstance(a,int))
print(isinstance(a,str))
print(isinstance(a,(str,int,list)))
class A:
pass
class B(A):
pass
print(isinstance(A(), A) )
print(type(A()) == A )
print(isinstance(B(), A))
print(type(B()) == A)
33.issubclass()函数
'''
描述
issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类。
语法
以下是 issubclass() 方法的语法:
issubclass(class, classinfo)
参数
class -- 类。
classinfo -- 类。
返回值
如果 class 是 classinfo 的子类返回 True，否则返回 False。
'''
class A:
pass
class B(A):
pass
class C(A):
pass
print(issubclass(B, A))
print(issubclass(C, A))
print(issubclass(C, B))
print(issubclass(C, (A, object)))
print(issubclass(C, (A, int, object)))
print(issubclass(C, (int, str)))
print(issubclass(C, (int, str, type)))
34.iter() 函数
'''
描述
iter() 函数用来生成迭代器。
语法
以下是 iter() 方法的语法:
iter(object[, sentinel])
参数
object -- 支持迭代的集合对象。
sentinel -- 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。
打开模式
返回值
迭代器对象。
1 iter(o[, sentinel])
2 返回一个iterator对象。该函数对于第一个参数的解析依赖于第二个参数。
3 如果没有提供第二个参数，参数o必须是一个集合对象，支持遍历功能（__iter__()方法）或支持序列功能（__getitem__()方法），
4 参数为整数，从零开始。如果不支持这两种功能，将处罚TypeError异常。
5 如果提供了第二个参数，参数o必须是一个可调用对象。在这种情况下创建一个iterator对象，每次调用iterator的next()方法来无
6 参数的调用o，如果返回值等于参数sentinel，触发StopIteration异常，否则将返回该值。
'''
lst = [1,2,3,4,5,6,7]
for i in iter(lst):
print(i)
class counter:
def __init__(self, _start, _end):
self.start = _start
self.end = _end
def get_next(self):
s = self.start
if(self.start < self.end):
self.start += 1
else:
raise StopIteration
return s
c = counter(1, 5)
iterator = iter(c.get_next, 3)
print(type(iterator))
for i in iterator:
print(i)
35.lambda()函数
'''
匿名函数lambda：是指一类无需定义标识符（函数名）的函数或子程序。
lambda 函数可以接收任意多个参数 (包括可选参数) 并且返回单个表达式的值。
要点：
1，lambda 函数不能包含命令，
2，包含的表达式不能超过一个。
说明：一定非要使用lambda函数；任何能够使用它们的地方，都可以定义一个单独的普通函数来进行替换。
我将它们用在需要封装特殊的、非重用代码上，避免令我的代码充斥着大量单行函数。
lambda匿名函数的格式：冒号前是参数，可以有多个，用逗号隔开，冒号右边的为表达式。
其实lambda返回值是一个函数的地址，也就是函数对象。
'''
def sum(x,y):
return x+y
print(sum(4,6))
f=lambda x,y:x+y
print(f(4,6))
a=lambda x:x*x
print(a(4))
b=lambda x,y,z:x+y*z
print(b(1,2,3))
from functools import reduce
foo=[2, 18, 9, 22, 17, 24, 8, 12, 27]
print(list(filter(lambda x:x%3==0,foo)))
print(list(map(lambda x:x*2+10,foo)))
print(reduce(lambda x,y:x+y,foo))
36.len()函数
'''
描述
Python len() 方法返回对象（字符、列表、元组等）长度或项目个数。
语法
len()方法语法：
len( s )
参数
s -- 对象。
返回值
返回对象长度。
'''
str1='ltf1234'
print(len(str1))
list1=[1,2,3,4,5,6,7,8]
print(len(list1))
for i in range(len(list1)):
print(i)
dict = {'num':777,'name':"anne"}
print(len(dict))
37.list()函数
'''
list() 列表构造函数
1 list([iterable])
2 list的构造函数。参数iterable是可选的，它可以是序列，支持编译的容器对象，或iterator对象。
3 该函数创建一个元素值，顺序与参数iterable一致的列表。如果参数iterable是一个列表，将创建
4 列表的一个拷贝并返回，就像语句iterables[:]。
'''
list=[1,2,3,4,5,6,7,8,9]
print(list)
list.append(10)
print(list)
list.insert(2,18)
print(list)
print(list.count(1))
list2=[-1,-2,-3]
list.extend(list2)
print(list)
list.remove(1)
print(list)
list.sort()
print(list)
list.reverse()
print(list)
print(max(list))
print(min(list))
list3=[1,2,3,'q','a','s']
38.locals() 函数
'''
locals() 函数会以字典类型返回当前位置的全部局部变量。
对于函数, 方法, lambda 函式, 类, 以及实现了 __call__ 方法的类实例, 它都返回 True。
语法
locals() 函数语法：
locals()
参数
无
返回值
返回字典类型的局部变量
1 不要修改locals()返回的字典中的内容；改变可能不会影响解析器对局部变量的使用。
2 在函数体内调用locals()，返回的是自由变量。修改自由变量不会影响解析器对变量的使用。
3 不能在类区域内返回自由变量。
'''
def test_py(arg):
z=1
print(locals())
test_py(6)
def foo(arg, a):
x = 100
y = 'hello python!'
for i in range(10):
j = 1
k = i
print(locals())
foo(1, 2)
39.map()函数
'''
map()函数
map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，
并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。
例如，对于list [1, 2, 3, 4, 5, 6, 7, 8, 9]
如果希望把list的每个元素都作平方，就可以用map()函数：
因此，我们只需要传入函数f(x)=x*x，就可以利用map()函数完成这个计算：
'''
list=[1,2,3,4,5,6,7,8,9]
def f(x):
return x*x
list1=map(f,list)
print(list1)
for i in list1:
print(i)
'''
注意：map()函数不改变原有的 list，而是返回一个新的 list。
利用map()函数，可以把一个 list 转换为另一个 list，只需要传入转换函数。
由于list包含的元素可以是任何类型，因此，map() 不仅仅可以处理只包含数值的 list，
事实上它可以处理包含任意类型的 list，只要传入的函数f可以处理这种数据类型。
任务
假设用户输入的英文名字不规范，没有按照首字母大写，后续字母小写的规则，
请利用map()函数，把一个list（包含若干不规范的英文名字）变成一个包含规范英文名字的
'''
def format_name(s):
s1=s[0:1].upper()+s[1:].lower()
return s1
names=['adam', 'LISA', 'barT']
print (map(format_name, names))
for i in map(format_name,names):
print(i)
40.max()函数
'''
描述
max() 方法返回给定参数的最大值，参数可以为序列。
语法
以下是 max() 方法的语法:
max( x, y, z, .... )
参数
x -- 数值表达式。
y -- 数值表达式。
z -- 数值表达式。
返回值
返回给定参数的最大值。
'''
print ("max(80, 100, 1000) : ", max(80, 100, 1000))
print ("max(-20, 100, 400) : ", max(-20, 100, 400))
print ("max(-80, -20, -10) : ", max(-80, -20, -10))
print ("max(0, 100, -400) : ", max(0, 100, -400))
'''
输出结果：
max(80, 100, 1000) : 1000
max(-20, 100, 400) : 400
max(-80, -20, -10) : -10
max(0, 100, -400) : 100
'''
print(max(1,2,3,4))
s='12345'
print(max(s))
s = [
{'name': 'sumcet', 'age': 18},
{'name': 'bbu', 'age': 11}
]
a = max(s, key=lambda x: x['age'])
print(a)
41.min()函数
'''
描述
min() 方法返回给定参数的最小值，参数可以为序列。
语法
以下是 min() 方法的语法:
min( x, y, z, .... )
参数
x -- 数值表达式。
y -- 数值表达式。
z -- 数值表达式。
返回值
返回给定参数的最小值。
'''
print ("min(80, 100, 1000) : ", min(80, 100, 1000))
print ("min(-20, 100, 400) : ", min(-20, 100, 400))
print ("min(-80, -20, -10) : ", min(-80, -20, -10))
print ("min(0, 100, -400) : ", min(0, 100, -400))
'''
输出结果
min(80, 100, 1000) : 80
min(-20, 100, 400) : -20
min(-80, -20, -10) : -80
min(0, 100, -400) : -400
'''
print(min(1,2,3,4))
s='12345'
print(min(s))
s = [
{'name': 'sumcet', 'age': 18},
{'name': 'bbu', 'age': 11}
]
a = min(s, key=lambda x: x['age'])
print(a)
42.next()函数
'''
描述
next() 返回迭代器的下一个项目。
语法
next 语法：
next(iterator[, default])
参数说明：
iterator -- 可迭代对象
default -- 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。
返回值
返回对象帮助信息。
'''
it = iter([1, 2, 3, 4, 5])
while True:
try:
x = next(it)
print(x)
except StopIteration:
break
a=iter('abcde')
print(next(a))
print(next(a))
print(next(a))
print(next(a))
print(next(a))
print(next(a,'e'))
43.oct() 函数
'''
描述
oct() 函数将一个整数转换成八进制字符串。
语法
oct 语法：
oct(x)
参数说明：
x -- 整数。
返回值
返回八进制字符串。
'''
print(oct(12))
print(oct(-120))
print(type(oct(12)))
print(int(oct(10),base=8)+int(oct(15),base=8))
print(oct(0b10010))
print(oct(0o1357))
print(oct(0x2d9))
44.open() 函数
'''
python open() 函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。
更多文件操作可参考：Python 文件I/O。
函数语法
open(name[, mode[, buffering]])
参数说明：
name : 一个包含了你要访问的文件名称的字符串值。
mode : mode 决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。
buffering : 如果 buffering 的值被设为 0，就不会有寄存。如果 buffering 的值取 1，访问文件时会寄存行。如果将 buffering 的值设为大于 1 的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。
不同模式打开文件的完全列表：
模式
描述
r
以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb
以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
r+
打开一个文件用于读写。文件指针将会放在文件的开头。
rb+
以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w
打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb
以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
w+
打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+
以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
a
打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab
以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+
打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+
以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。
file 对象方法
file.read([size])：size 未指定则返回整个文件，如果文件大小 >2 倍内存则有问题，f.read()读到文件尾时返回""(空字串)。
file.readline()：返回一行。
file.readlines([size]) ：返回包含size行的列表, size 未指定则返回全部行。
for line in f: print line ：通过迭代器访问。
f.write("hello\n")：如果要写入字符串以外的数据,先将他转换为字符串。
f.tell()：返回一个整数,表示当前文件指针的位置(就是到文件头的比特数)。
f.seek(偏移量,[起始位置])：用来移动文件指针。
偏移量: 单位为比特，可正可负
起始位置: 0 - 文件头, 默认值; 1 - 当前位置; 2 - 文件尾
f.close() 关闭文件
open(filename [, mode [, bufsize]])
打开一个文件，返回一个file对象。 如果文件无法打开，将处罚IOError异常。
应该使用open()来代替直接使用file类型的构造函数打开文件。
参数filename表示将要被打开的文件的路径字符串；
参数mode表示打开的模式，最常用的模式有：'r'表示读文本，'w'表示写文本文件，'a'表示在文件中追加。
Mode的默认值是'r'。
当操作的是二进制文件时，只要在模式值上添加'b'。这样提高了程序的可移植性。
可选参数bufsize定义了文件缓冲区的大小。0表示不缓冲；1表示行缓冲；任何其他正数表示使用该大小的缓冲区；
负数表示使用系统默认缓冲区大小，对于tty设备它往往是行缓冲，而对于其他文件往往完全缓冲。如果参数值被省却。
使用系统默认值。
'''
f=open('1.txt','r',encoding='utf-8')
print(f.read())
'''
输出...
ltf
zhongguo
shanxi
yuncheng
男
20
'''
45.ord() 函数
'''
描述
ord() 函数是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常。
语法
以下是 ord() 方法的语法:
ord(c)
参数
c -- 字符。
返回值
返回值是对应的十进制整数。
'''
print(ord('a'))
print(ord('b'))
print(ord('c'))
print(ord(']'))
print(ord('8'))
46.pow()函数
'''
描述
pow() 方法返回 xy（x的y次方） 的值。
语法
以下是 math 模块 pow() 方法的语法:
import math
math.pow( x, y )
内置的 pow() 方法
pow(x, y[, z])
函数是计算x的y次方，如果z在存在，则再对结果进行取模，其结果等效于pow(x,y) %z
注意：pow() 通过内置的方法直接调用，内置方法会把参数作为整型，而 math 模块则会把参数转换为 float。
参数
x -- 数值表达式。
y -- 数值表达式。
z -- 数值表达式。
返回值
返回 xy（x的y次方） 的值。
'''
import math
print("math.pow(100, 2) : ", math.pow(100, 2))
print("pow(100, 2) : ", pow(100, 2))
print("math.pow(100, -2) : ", math.pow(100, -2))
print("math.pow(2, 4) : ", math.pow(2, 4))
print("math.pow(3, 0) : ", math.pow(3, 0))
'''
输出结果...
math.pow(100, 2) : 10000.0
pow(100, 2) : 10000
math.pow(100, -2) : 0.0001
math.pow(2, 4) : 16.0
math.pow(3, 0) : 1.0
'''
47.property() 函数
'''
描述
property() 函数的作用是在新式类中返回属性值。
语法
以下是 property() 方法的语法:
class property([fget[, fset[, fdel[, doc]]]])
参数
fget -- 获取属性值的函数
fset -- 设置属性值的函数
fdel -- 删除属性值函数
doc -- 属性描述信息
返回值
返回新式类属性
'''
class C(object):
def __init__(self):
self._x = None
def getx(self):
return self._x
def setx(self, value):
self._x = value
def delx(self):
del self._x
x = property(getx, setx, delx, "I'm the 'x' property.")
class Parrot(object):
def __init__(self):
self._voltage = 100000
@property
def voltage(self):
"""Get the current voltage."""
return self._voltage
class D(object):
def __init__(self):
self._x = None
@property
def x(self):
"""I'm the 'x' property."""
return self._x
@x.setter
def x(self, value):
self._x = value
@x.deleter
def x(self):
del self._x
48.range() 函数
'''
python range() 函数可创建一个整数列表，一般用在 for 循环中。
函数语法
range(start, stop[, step])
参数说明：
start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)
'''
for i in range(10):
print(i)
for i in range(0,11,2):
print(i)
for i in range(0,-10,-3):
print(i)
list=[]
for i in range(5,-5,-1):
list.append(i)
print(list)
for i in 'ahfgohiauf':
print(i)
49.reduece()函数
'''
在python3中如果使用reduce需要先导入
from functools import reduce
reduce函数，reduce函数会对参数序列中元素进行累积。
reduce函数的定义：
reduce(function, sequence [, initial] ) -> value
function参数是一个有两个参数的函数，reduce依次从sequence中取一个元素，
和上一次调用function的结果做参数再次调用function。
第一次调用function时，如果提供initial参数，
会以sequence中的第一个元素和initial作为参数调用function，
否则会以序列sequence中的前两个元素做参数调用function。
'''
from functools import reduce
lst=[1,2,3,4,5,6]
def f(x,y):
return x+y
print(reduce(f,lst))
'''
过程1+2+3+4+5+6=21
'''
print(reduce(lambda x,y:x*y,lst))
print(reduce(lambda x,y:x*y+1,lst))
'''
运算步骤：1*2+1=3
3*3+1=10
10*4+1=41
41*5+1=206
206*6+1=1237
'''
print(reduce(lambda x,y:x+y,lst,5))
'''
计算步骤：5+1=6
6+2=8
8+3=11
11+4=15
15+5=20
20+6=26
'''
50.repr()函数
'''
描述
repr() 函数将对象转化为供解释器读取的形式。
语法
以下是 repr() 方法的语法:
repr(object)
参数
object -- 对象。
返回值
返回一个对象的 string 格式。
'''
s='qwerasdf'
print(s)
print(repr(s))
dict={'a':1,'b':2}
print(dict)
print(repr(dict))
print(repr([0,1,2,3,4]))
print(repr('hello'))
print(str(1.0/7.0))
print(repr(1.0/7.0))
51.reversed() 函数
'''
描述
reversed 函数返回一个反转的迭代器。
语法
以下是 reversed 的语法:
reversed(seq)
参数
seq -- 要转换的序列，可以是 tuple, string, list 或 range。
返回值
返回一个反转的迭代器。
1 reversed(seq)
2 返回一个逆序的iterator对象。参数seq必须是一个包含__reversed__()方法的对象或支持序列操作(__len__()和__getitem__())
3 该函数是2.4中新增的
'''
str='wasdqwer'
print(list(reversed(str)))
tuple=('r', 'e', 'w', 'q', 'd', 's', 'a', 'w')
print(list(reversed(tuple)))
seqRange = range(5, 9)
print(list(reversed(seqRange)))
seqList = [1, 2, 4, 3, 5]
print(list(reversed(seqList)))
a=[1,2,3,4,5,6]
b=reversed(a)
print(b)
print(list(b))
print(list(b))
52.round()函数
'''
描述
round() 方法返回浮点数x的四舍五入值。
语法
以下是 round() 方法的语法:
round( x [, n] )
参数
x -- 数字表达式。
n -- 表示从小数点位数，其中 x 需要四舍五入，默认值为 0。
返回值
返回浮点数x的四舍五入值。
'''
print ("round(70.23456) : ", round(70.23456))
print ("round(56.659,1) : ", round(56.659,1))
print ("round(80.264, 2) : ", round(80.264, 2))
print ("round(100.000056, 3) : ", round(100.000056, 3))
print ("round(-100.000056, 3) : ", round(-100.000056, 3))
'''
输出结果...
round(70.23456) : 70
round(56.659,1) : 56.7
round(80.264, 2) : 80.26
round(100.000056, 3) : 100.0
round(-100.000056, 3) : -100.0
'''
53.setattr()函数
'''
描述：
setattr函数，用于设置属性值，该属性必须存在
语法：
setattr(object,name,value)
参数：
object--对象
name--字符串，对象属性
value--属性值
返回值：
无
'''
class People():
sex='男'
def __init__(self,name):
self.name=name
def peopleinfo(self):
print('欢迎%s访问'%self.name)
obj=People('zhangsan')
setattr(People,'x',123)
print(People.x)
setattr(obj,'age',18)
print(obj.__dict__)
print(People.__dict__)
54.set() 函数
'''
描述
set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
语法
set 语法：
class set([iterable])
参数说明：
iterable -- 可迭代对象对象；
返回值
返回新的集合对象。
'''
a=set('www.baidu.com')
b=set('www.gogle.com')
print(a)
print(b)
print(a&b)
print(a|b)
print(a-b)
se = {11, 22, 33}
be = {22, 55}
temp1 = se.difference(be)
print(temp1)
print(se)
temp2 = se.difference_update(be)
print(temp2)
print(se)
se = {11, 22, 33}
se.discard(11)
se.discard(44)
print(se)
se = {11, 22, 33}
se.remove(11)
print(se)
se = {11, 22, 33}
temp = se.pop()
print(temp)
print(se)
se = {11, 22, 33}
be = {22, 55}
temp1 = se.intersection(be)
print(temp1)
print(se)
temp2 = se.intersection_update(be)
print(temp2)
print(se)
se = {11, 22, 33}
be = {22}
print(se.isdisjoint(be))
print(se.issubset(be))
print(se.issuperset(be))
se = {11, 22, 33}
be = {22}
temp1 = se.symmetric_difference(be)
print(temp1)
print(se)
temp2 = se.symmetric_difference_update(be)
print(temp2)
print(se)
se = {11, 22, 33}
be = {22,44,55}
temp=se.union(be)
print(se)
print(temp)
se = {11, 22, 33}
be = {22,44,55}
se.update(be)
print(se)
se.update([66, 77])
print(se)
se = set(range(4))
li = list(se)
tu = tuple(se)
st = str(se)
print(li,type(li))
print(tu,type(tu))
print(st,type(st))
55.slice() 函数
'''
描述
slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。
语法
slice 语法：
class slice(stop)
class slice(start, stop[, step])
参数说明：
start -- 起始位置
stop -- 结束位置
step -- 间距
返回值
返回一个切片对象。
实例
'''
myslice=slice(5)
print(myslice)
arr=list(range(10))
print(arr)
print(arr[myslice])
print(arr[3:6])
56.sorted() 函数
'''
描述
sorted() 函数对所有可迭代的对象进行排序操作。
sort 与 sorted 区别：
sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
语法
sorted 语法：
sorted(iterable, key=None, reverse=False)
参数说明：
iterable -- 可迭代对象。
key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
返回值
返回重新排序的列表。
'''
print(sorted([2,3,4,1,5,6]))
print(sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'}))
example_list = [5, 0, 6, 1, 2, 7, 3, 4]
result_list = sorted(example_list, key=lambda x: x*-1)
print(result_list)
example_list = [5, 0, 6, 1, 2, 7, 3, 4]
result_list=sorted(example_list, reverse=True)
print(result_list)
array = [{"age":20,"name":"a"},{"age":25,"name":"b"},{"age":10,"name":"c"}]
array = sorted(array,key=lambda x:x["age"])
print(array)
57.staticmethod()函数
'''
python staticmethod 返回函数的静态方法。
该方法不强制要求传递参数，如下声明一个静态方法：
class C(object):
@staticmethod
def f(arg1, arg2, ...):
...
以上实例声明了静态方法 f，类可以不用实例化就可以调用该方法 C.f()，当然也可以实例化后调用 C().f()。
函数语法
staticmethod(function)
参数说明：
无
'''
class C(object):
@staticmethod
def f():
print('hello world')
C.f()
cobj = C()
cobj.f()
class A(object):
def foo(self, x):
print("executing foo(%s,%s)" % (self, x))
print('self:', self)
@classmethod
def class_foo(cls, x):
print("executing class_foo(%s,%s)" % (cls, x))
print('cls:', cls)
@staticmethod
def static_foo(x):
print("executing static_foo(%s)" % x)
a = A()
print(a.foo)
print(a.class_foo)
print(a.static_foo)
58.str() 函数
'''
描述
str() 函数将对象转化为适于人阅读的形式。
语法
以下是 str() 方法的语法:
class str(object='')
参数
object -- 对象。
返回值
返回一个对象的string格式。
'''
print(str(1))
print(type(str(1)))
print(str(b'\xe5\xbc\xa0\xe4\xb8\x89',encoding='utf-8'))
dict={'zhangsan':'zhang1234','lisi':'li1234'}
print(type(dict))
a=str(dict)
print(str(dict))
print(type(a))
59.sum()函数
'''
描述
sum() 方法对系列进行求和计算。
语法
以下是 sum() 方法的语法:
sum(iterable[, start])
参数
iterable -- 可迭代对象，如：列表、元组、集合。
start -- 指定相加的参数，如果没有设置这个值，默认为0。
返回值
返回计算结果
'''
print(sum([0,1,2]))
print(sum((2,3,4),1))
print(sum([2,3,4,5,6],8))
a = list(range(1,11))
b = list(range(1,10))
c = sum([item for item in a if item in b])
print(c)
60.vars() 函数
'''
描述
vars() 函数返回对象object的属性和属性值的字典对象。
语法
vars() 函数语法：
vars([object])
参数
object -- 对象
返回值
返回对象object的属性和属性值的字典对象，如果没有参数，就打印当前调用位置的属性和属性值 类似 locals()。
'''
print(vars())
class A:
a=1
__dict__ = 'ltf'
print(vars(A))
a=A()
print(vars(a))
print(a.__dict__)
61.zip()函数
x=[1,2,3]
y=[4,5,6]
z=[7,8,9]
h=['a','b','c','d']
zip1=zip(x,y,z)
print(zip1)
for i in zip1:
print(i)
zip2=zip(x,y,h)
for i in zip2:
print(i)
zip3=zip(h)
for i in zip3:
print(i)
zip4=zip(*h*3)
for i in zip4:
print(i)
print('==*=='*10)
l1=[[1,2,3],[4,5,6],[7,8,9]]
print(l1)
print([[j[i] for j in l1] for i in range(len(l1[0])) ])
zip5=zip(*l1)
for i in zip5:
print(i)
