https://www.cnblogs.com/yuxuanlian/p/10289190.html

import math

# abs() 绝对值
print(abs(-1.2))
print(abs(3+2j)) #若参数为复数，则返回复数的模，就是 (a平方+b平方) 开根。
print(math.sqrt(3**2+2**2))


'''
all()
如果iterable的所有元素不为0、''、False或者iterable为空，all(iterable)返回True，否则返回False；
注意：空元组、空列表返回值为True，这里要特别注意。
'''
print(all(['a','b','c','']))   #列表存在一个为空的元素，返回False
print(all(['a','b','c','d']))  #列表都有元素，返回True
print(all([0,1,2,3,4,5,6]))    #列表里存在为0的元素 返回False

print(all(('a','b','c','')))   #元组存在一个为空的元素，返回Fasle
print(all(('a','b','c','d')))  #元组都有元素，返回True
print(all((0,1,2,3,4,5)))      #元组存在一个为0的元素，返回Fasle

print(all([]))  #空列表返回 True
print(all(()))  #空元组返回 True


'''
any()
如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true。
'''
print(any(['a','b','c','']))   #列表存在一个为空的元素，返回True
print(any(['a','b','c','d']))  #列表都不为空，返回True
print(any([0,'',False]))       #列表里的元素全为  0,'',False  返回False

print(any(('a','b','c','')))   #元组存在一个为空的元素，返回True
print(any(('a','b','c','d')))  #元组都有元素，返回True
print(any((0,'',False)))       #元组里的元素全为  0,'',False  返回False

print(any([]))  #空列表返回 False
print(any(()))  #空元组返回 False


#返回字符串
print(ascii('tianna天呐'))


'''
bin()
将一个整数转化为一个二进制整数，并以字符串的类型返回。
'''
print(bin(-120))        #输出-12的二进制 -0b1111000
print(type(bin(12)))    #输出bin(12) 的类型 <class 'str'> 所以不能直接计算

print(int(bin(10),base=2)+int(bin(20),base=2))  #输出 30
#base 参数不可为空 为空默认参数为10进制 会报错 ValueError: invalid literal for int() with base 10: '0b1010'

#当然了，参数不仅可以接受十进制整数，八进制、十六进制也是可以的，只要是int型数据就合法。
print(bin(0b10010))    #输出0b10010
print(bin(0o1357))     #输出0b1011101111
print(bin(0x2d9))      #输出0b1011011001


print(bool(0))         #返回False
print(bool(False))     #返回False
print(bool(''))        #返回False


print(bytes('wo','ascii')) 
print(bytes('我','utf-8')) 
print(bytes('我',encoding='utf-8')) 

print(chr(8364))  #查看十进制数对应的ASCII码值


'''
callable()　　判断对象是否可以被调用，
'''
print(callable(max))       #输出True
print(callable([1,2,3]))   #输出Fasle
print(callable(None))      #输出Fasle
print(callable('str'))     #输出Fasle

def fn(x):
    return x*x
print(callable(fn))        #输出True  证明自定义的函数也可以


'''
@classmethod
classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，
但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。
'''
class Stud:
    num=1
    def fn1(self):      #这个self不能缺
        print('方法一')
    @classmethod
    def fn2(cls):
        print('方法二')   #输出 方法二
        print(cls.num)    #调用类的实例化对象
        cls().fn1()       #调用类的方法

Stud.fn2()    #输出 方法二 不需要实例化——没有传参数哦

print('===='*10)
object=Stud()
object.fn1()  #输出 方法一 需要实例化


'''
@staticmethod
静态方法无需实例化
'''
class C():
    @staticmethod
    def f():
        print('hello world')
C.f()               # 静态方法无需实例化
cobj = C()
cobj.f()            # 也可以实例化后调用



#complie()　　将字符串编译成python能识别或可以执行的代码，也可以将文字读成字符串再编译
s="print('hello world')"
r=compile(s,'hello','exec')   #exec也可换成eval来计算
print(r)
r=compile(s,'iii','exec')
print(r)


#eval()  执行计算
x=7
print(eval('3*x'))        #返回 21

#eval函数还可以实现list、dict、tuple与str之间的转化

#1.字符串转换成列表
a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]"
print(type(a))         #返回  <class 'str'>
b = eval(a)
print(type(b))         #返回  <class 'list'>
print(b)               #输出  [[1, 2], [3, 4], [5, 6], [7, 8], [9, 0]]


'''
函数的作用：
动态执行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)         #输出  a: None，exec()函数返回值永远为None。
    b = exec("x+y",{"x":1,"y":2})
    print("b:",b)         #输出  b: None，exec()函数返回值永远为None。
func()

x = 10
expr = """
z = 30
sum = x + y + z   #一大包代码
print(sum)
"""
def func():
    y = 20
    exec(expr)   #10+20+30       输出60
    exec(expr,{'x':1,'y':2}) #30+1+2         输出 33
    exec(expr,{'x':1,'y':2},{'y':3,'z':4}) #30+1+3，x是全局变量更新为1，y是局部变量更新为3  输出34

func()



#dict()
dict2=dict(zip(['one', 'two', 'three'], [1, 2, 3]))   # 映射函数方式来构造字典
print(dict2)    #输出 {'one': 1, 'two': 2, 'three': 3}

dict3=dict([('one', 1), ('two', 2), ('three', 3)])    # 可迭代对象方式来构造字典
print(dict3)     #输出 {'one': 1, 'two': 2, 'three': 3}


'''
python divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。
'''
print(divmod(7,2))    #返回  (3, 1)
# print(divmod(1+2j,1+0.5j))
#报错 TypeError: can't take floor or mod of complex number.


'''
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"]
#这里加了个参数2，代表的是start的值
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()
#这里i表示的是索引，item表示的是它的值
for i,item in enumerate(a):
    b[i]=item
print(b)   #输出 {0: 'q', 1: 'w', 2: 'e', 3: 'r'}

for i,j in enumerate('abc'):
    print(i,j)
#输出结果
# 0 a
# 1 b
# 2 c



'''
filter() 函数是一个对于可迭代对象的过滤器，过滤掉不符合条件的元素，
返回的是一个迭代器，如果要转换为列表，可以使用 list() 来转换。
该函数接收两个参数，第一个为函数的引用或者None，第二个为可迭代对象，
可迭代对象中的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到迭代器中
下面看下fiter()的用法：
'''

my_list=[1,2,'',3,4,'6',' ']
new_list=list(filter(None,my_list))
print(new_list)
#None 函数 过滤掉'' 而不是过滤掉空字符串

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)))
#筛选出列表里所有的不是 2  的元素

from functools import reduce
foo=[2, 18, 9, 22, 17, 24, 8, 12, 27]
print(list(filter(lambda x:x%3==0,foo))) #筛选x%3==0 的元素
print(list(map(lambda x:x*2+10,foo)))    #遍历foo 每个元素乘2+10 再输出
print(reduce(lambda x,y:x+y,foo))        #返回每个元素相加的和



'''
自python2.6开始，新增了一种格式化字符串的函数str.format()，此函数可以快速处理各种字符串。
语法
它通过{}和:来代替%。
请看下面的示例，基本上总结了format函数在python的中所有用法
'''
#通过位置
print ('{0},{1}'.format('chuhao',20))
#chuhao,20
print ('{},{}'.format('chuhao',20))
#chuhao,20
print ('{1},{0},{1}'.format('chuhao',20))
#20,chuhao,20
#通过关键字参数
print ('{name},{age}'.format(age=18,name='chuhao'))
#chuhao,18
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)))       #This guy is chuhao,is 18 old

#通过映射 list
a_list = ['chuhao',20,'china']
print ('my name is {0[0]},from {0[2]},age is {0[1]}'.format(a_list))
#my name is chuhao,from china,age is 20

#通过映射 dict
b_dict = {'name':'chuhao','age':20,'province':'shanxi'}
print ('my name is {name}, age is {age},from {province}'.format(**b_dict))
#my name is chuhao, age is 20,from shanxi

#填充与对齐
print ('{:>8}'.format('189'))
#     189
print ('{:0>8}'.format('189'))
#00000189
print ('{:a>8}'.format('189'))
#aaaaa189

#精度与类型f
#保留两位小数
print ('{:.2f}'.format(321.33345))
#321.33

#用来做金额的千位分隔符
print ('{:,}'.format(1234567890))
#1,234,567,890

#其他类型 主要就是进制了，b、d、o、x分别是二进制、十进制、八进制、十六进制。
print ('{:b}'.format(18)) #二进制 10010
print ('{:d}'.format(18)) #十进制 18
print ('{:o}'.format(18)) #八进制 22
print ('{:x}'.format(18)) #十六进制12


# frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
a=frozenset(range(10))
print(a)
#输出  frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
b=frozenset('ltftyut1234')
print(b)
#输出  frozenset({'2', '4', 't', 'f', '1', '3', 'l', 'y', 'u'}) 乱序哦


#getattr() 得到对象属性
class People():
    sex='男'
    def __init__(self,name):
        self.name=name
    def peopleinfo(self):
        print('欢迎%s访问'%self.name)

obj=getattr(People,'sex')
print(obj)       #返回值  男



# globals() 函数会以字典类型返回当前位置的全部全局变量。
def hello():
    print("Hello")

def zero_promo():
    return 22

def one_promo():
    return 1

def two_promo():
    return 2

if __name__ == '__main__':
    promos = [name for name in globals()if name.endswith("_promo")]
    print(promos)   #输出 ['zero_promo', 'one_promo', 'two_promo']

    promos = [globals()[name] for name in globals() if name.endswith("_promo")]
    print(promos[0]())    #输出 22  调用了第一个函数zero_promo()


#hash()
print(hash('test'))      #输出 -2950866779904704330   会改变的
print(hash('test'))      #输出 -2950866779904704330   根上面一样，因为内存地址一样
print(hash(1))              #数字  输出 1
print(hash(str([1,2,3])))      # 集合   输出 -6217131644886971364   会改变的
print(hash(str(sorted({'1':1})))) # 字典   输出 -6233802074491902648    会改变的
'''
hash() 函数可以应用于数字、字符串和对象，不能直接应用于 list、set、dictionary。
在 hash() 对对象使用时，所得的结果不仅和对象的内容有关，还和对象的 id()，也就是内存地址有关。
'''


lst = [1,2,3,4,5,6,7]
for i in iter(lst):
    print(i)      #输出1,2,3,4,5,6,7

lst = [1,2,3,4,5,6,7]
for i in lst:
    print(i)      #输出1,2,3,4,5,6,7


# 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))  #python2 这样写可以直接输出列表,python3 是<map object at 0x10d9300d0>
for i in map(format_name,names):
    print(i)                      #python3 得这样写才可以


# max()
#传入命名参数key，其为一个函数，用来指定取最大值的方法
s = [
    {'name': 'sumcet', 'age': 18},
    {'name': 'bbu', 'age': 11}
]
a = max(s, key=lambda x: x['age'])
print(a)        #输出 {'name': 'sumcet', 'age': 18}


#round() 四舍五入
print (round(80.264, 2))   #80.26


# set 无序无重复集合
se = {11, 22, 33}
be = {22, 55}
temp1 = se.difference(be)        #找到se中存在，be中不存在的集合，返回新值
print(temp1)        #{33, 11}
print(se)        #{33, 11, 22}

temp2 = se.difference_update(be) #找到se中存在，be中不存在的集合，覆盖掉se
print(temp2)        #None
print(se)           #{33, 11},

#4.判断
se = {11, 22, 33}
be = {22}

print(se.isdisjoint(be))        #False，判断是否不存在交集（有交集False，无交集True）
print(se.issubset(be))          #False，判断se是否是be的子集合
print(se.issuperset(be))        #True，判断se是否是be的父集合


se = {11, 22, 33}
be = {22,44,55,'2'}

se.update(be)  # 把se和be合并，得出的值覆盖se
print(se)
se.update([66, 77])  # 可增加迭代项
print(se)


#sorted
#要进行反向排序，也通过传入第三个参数 reverse=True：
example_list = [5, 0, 6, 1, 2, 7, 3, 4]
result_list=sorted(example_list, reverse=True)
print(result_list)                   #输出 [7, 6, 5, 4, 3, 2, 1, 0]

#另一个区别在于list.sort() 方法只为 list 定义。而 sorted() 函数可以接收任何的 iterable。
print(sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'}))      #输出  [1, 2, 3, 4, 5]

#sorted 的应用，也可以通过 key 的值来进行数组/字典的排序，比如
array = [{"age":20,"name":"a"},{"age":25,"name":"b"},{"age":10,"name":"c"}]
array = sorted(array,key=lambda x:x["age"])
print(array)    #[{'age': 10, 'name': 'c'}, {'age': 20, 'name': 'a'}, {'age': 25, 'name': 'b'}]


#str()
print(str(1))             #输出  字符串1
print(type(str(1)))       #输出  <class 'str'>
print(str(b'\xe5\xbc\xa0\xe4\xb8\x89',encoding='utf-8'))  #输出张三

dict={'zhangsan':'zhang1234','lisi':'li1234'}
print(type(dict))         #输出  <class 'dict'>
a=str(dict)
print(str(dict))          #输出  字符串 {'zhangsan': 'zhang1234', 'lisi': 'li1234'}
print(type(a))            #输出  <class 'str'>


#sum()
print(sum((2,3,4),1))            # 元组计算总和后再加 1


#zip()
#zip函数接受任意多个可迭代对象作为参数,将对象中对应的元素打包成一个tuple,然后返回一个可迭代的zip对象.
#这个可迭代对象可以使用循环的方式列出其元素
#若多个可迭代对象的长度不一致,则所返回的列表与长度最短的可迭代对象相同.

#1.用列表生成zip对象
x=[1,2,3]
y=[4,5,6]
z=[7,8,9]
h=['a','b','c','d']
zip1=zip(x,y,z)     # zip每个元素依次读一个，相当于行列转换x、y、z生成的矩阵
print(zip1)         #<zip object at 0x107d6c0f0>
for i in zip1:
    print(i)
'''
行列转换了
(1, 4, 7)
(2, 5, 8)
(3, 6, 9)
'''

zip3=zip(h)
for i in zip3:
    print(i)
'''
('a',)
('b',)
('c',)
('d',)
'''

zip4=zip(*h*3)        # *h把zip(h)行列转换，h是一元所以只有一行，再*3
for i in zip4:
    print(i)
'''
('a', 'b', 'c', 'd', 'a', 'b', 'c', 'd', 'a', 'b', 'c', 'd')
'''

print('==*=='*10)

#2.二维矩阵变换
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])) ])     # 行列转换 [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

zip5=zip(*l1)       # 直接行列转换
for i in zip5:
    print(i)
'''
(1, 4, 7)
(2, 5, 8)
(3, 6, 9)
'''