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

import math

# abs() 絕對值
print(abs(-1.2))
print(abs(3+2j)) #若參數(shù)為復(fù)數(shù)，則返回復(fù)數(shù)的模礁遣，就是 (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()
將一個整數(shù)轉(zhuǎn)化為一個二進制整數(shù)麦乞，并以字符串的類型返回蕴茴。
'''
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 參數(shù)不可為空 為空默認參數(shù)為10進制 會報錯 ValueError: invalid literal for int() with base 10: '0b1010'

#當然了，參數(shù)不僅可以接受十進制整數(shù)姐直，八進制倦淀、十六進制也是可以的，只要是int型數(shù)據(jù)就合法声畏。
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))  #查看十進制數(shù)對應(yīng)的ASCII碼值


'''
callable()　　判斷對象是否可以被調(diào)用撞叽，
'''
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  證明自定義的函數(shù)也可以


'''
@classmethod
classmethod 修飾符對應(yīng)的函數(shù)不需要實例化，不需要 self 參數(shù)，
但第一個參數(shù)需要是表示自身類的 cls 參數(shù)愿棋，可以來調(diào)用類的屬性科展，類的方法，實例化對象等初斑。
'''
class Stud:
    num=1
    def fn1(self):      #這個self不能缺
        print('方法一')
    @classmethod
    def fn2(cls):
        print('方法二')   #輸出 方法二
        print(cls.num)    #調(diào)用類的實例化對象
        cls().fn1()       #調(diào)用類的方法

Stud.fn2()    #輸出 方法二 不需要實例化——沒有傳參數(shù)哦

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


'''
@staticmethod
靜態(tài)方法無需實例化
'''
class C():
    @staticmethod
    def f():
        print('hello world')
C.f()               # 靜態(tài)方法無需實例化
cobj = C()
cobj.f()            # 也可以實例化后調(diào)用



#complie()　　將字符串編譯成python能識別或可以執(zhí)行的代碼辛润，也可以將文字讀成字符串再編譯
s="print('hello world')"
r=compile(s,'hello','exec')   #exec也可換成eval來計算
print(r)
r=compile(s,'iii','exec')
print(r)


#eval()  執(zhí)行計算
x=7
print(eval('3*x'))        #返回 21

#eval函數(shù)還可以實現(xiàn)list膨处、dict见秤、tuple與str之間的轉(zhuǎn)化

#1.字符串轉(zhuǎn)換成列表
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]]


'''
函數(shù)的作用：
動態(tài)執(zhí)行python代碼。也就是說exec可以執(zhí)行復(fù)雜的python代碼真椿，而不像eval函數(shù)那樣只能計算一個表達式的值鹃答。
exec(source, globals=None, locals=None, /)
source：必選參數(shù)，表示需要被指定的python代碼突硝。它必須是字符串或code對象测摔。如果source是一個字符串，該字符串會先被解析為一組python語句解恰，然后執(zhí)行锋八。如果source是一個code對象，那么它只是被簡單的執(zhí)行护盈。
返回值：
exec函數(shù)的返回值永遠為None挟纱。

eval()函數(shù)和exec()函數(shù)的區(qū)別：
eval()函數(shù)只能計算單個表達式的值，而exec()函數(shù)可以動態(tài)運行代碼段腐宋。
eval()函數(shù)可以有返回值紊服，而exec()函數(shù)返回值永遠為None。
'''

x = 10
def func():
    y = 20
    a = exec("x+y")
    print("a:",a)         #輸出  a: None胸竞，exec()函數(shù)返回值永遠為None欺嗤。
    b = exec("x+y",{"x":1,"y":2})
    print("b:",b)         #輸出  b: None，exec()函數(shù)返回值永遠為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]))   # 映射函數(shù)方式來構(gòu)造字典
print(dict2)    #輸出 {'one': 1, 'two': 2, 'three': 3}

dict3=dict([('one', 1), ('two', 2), ('three', 3)])    # 可迭代對象方式來構(gòu)造字典
print(dict3)     #輸出 {'one': 1, 'two': 2, 'three': 3}


'''
python divmod() 函數(shù)把除數(shù)和余數(shù)運算結(jié)果結(jié)合起來校赤，返回一個包含商和余數(shù)的元組(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()返回對象的每個元素都是一個元組意鲸，
每個元組包括兩個值，一個是計數(shù)，一個是sequence的值怎顾，
計數(shù)是從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"]
#這里加了個參數(shù)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"]
#創(chuàng)建一個空字典
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)
#輸出結(jié)果
# 0 a
# 1 b
# 2 c



'''
filter() 函數(shù)是一個對于可迭代對象的過濾器，過濾掉不符合條件的元素募强，
返回的是一個迭代器株灸，如果要轉(zhuǎn)換為列表，可以使用 list() 來轉(zhuǎn)換擎值。
該函數(shù)接收兩個參數(shù)慌烧，第一個為函數(shù)的引用或者None，第二個為可迭代對象鸠儿，
可迭代對象中的每個元素作為參數(shù)傳遞給函數(shù)進行判屹蚊，然后返回 True 或 False，最后將返回 True 的元素放到迭代器中
下面看下fiter()的用法：
'''

my_list=[1,2,'',3,4,'6',' ']
new_list=list(filter(None,my_list))
print(new_list)
#None 函數(shù) 過濾掉'' 而不是過濾掉空字符串

def is_oushu(x):
    return x%2==0
new_list=list(filter(is_oushu,list(range(1,11))))
print(new_list)
#過濾掉不是偶數(shù)的數(shù)

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開始，新增了一種格式化字符串的函數(shù)str.format()，此函數(shù)可以快速處理各種字符串栖茉。
語法
它通過{}和:來代替%抄罕。
請看下面的示例，基本上總結(jié)了format函數(shù)在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
#通過關(guān)鍵字參數(shù)
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
#保留兩位小數(shù)
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() 返回一個凍結(jié)的集合鲫趁，凍結(jié)后集合不能再添加或刪除任何元素斯嚎。
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() 函數(shù)會以字典類型返回當前位置的全部全局變量。
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  調(diào)用了第一個函數(shù)zero_promo()


#hash()
print(hash('test'))      #輸出 -2950866779904704330   會改變的
print(hash('test'))      #輸出 -2950866779904704330   根上面一樣挨厚，因為內(nèi)存地址一樣
print(hash(1))              #數(shù)字  輸出 1
print(hash(str([1,2,3])))      # 集合   輸出 -6217131644886971364   會改變的
print(hash(str(sorted({'1':1})))) # 字典   輸出 -6233802074491902648    會改變的
'''
hash() 函數(shù)可以應(yīng)用于數(shù)字堡僻、字符串和對象，不能直接應(yīng)用于 list疫剃、set钉疫、dictionary。
在 hash() 對對象使用時巢价，所得的結(jié)果不僅和對象的內(nèi)容有關(guān)牲阁，還和對象的 id()固阁，也就是內(nèi)存地址有關(guān)。
'''


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()
#傳入命名參數(shù)key备燃，其為一個函數(shù)，用來指定取最大值的方法
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 無序無重復(fù)集合
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
#要進行反向排序酥夭，也通過傳入第三個參數(shù) 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]

#另一個區(qū)別在于list.sort() 方法只為 list 定義。而 sorted() 函數(shù)可以接收任何的 iterable脊奋。
print(sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'}))      #輸出  [1, 2, 3, 4, 5]

#sorted 的應(yīng)用熬北，也可以通過 key 的值來進行數(shù)組/字典的排序，比如
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函數(shù)接受任意多個可迭代對象作為參數(shù),將對象中對應(yīng)的元素打包成一個tuple,然后返回一個可迭代的zip對象.
#這個可迭代對象可以使用循環(huán)的方式列出其元素
#若多個可迭代對象的長度不一致,則所返回的列表與長度最短的可迭代對象相同.

#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每個元素依次讀一個诚隙，相當于行列轉(zhuǎn)換x讶隐、y、z生成的矩陣
print(zip1)         #<zip object at 0x107d6c0f0>
for i in zip1:
    print(i)
'''
行列轉(zhuǎn)換了
(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)行列轉(zhuǎn)換久又，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])) ])     # 行列轉(zhuǎn)換 [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

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