python 內置函數簡介及其作用

1. abs() 函數

• abs() 函數返回數字的絕對值。
• 語法
  • abs( x )
• 參數
  • x -- 數值表達式，可以是整數，浮點數，復數。
• 返回值
  • 函數返回 x（數字）的絕對值，如果參數是一個復數，則返回它的大小。

實例：

num1 = 52
num2 = -52
num3 = 100.10

print(abs(num1))
print(abs(num2))
print(abs(num3))

# 52
# 52
# 100.1

2. dict() 函數

• dict() 函數用於創建一個字典。
• 語法：
  • class dict(**kwarg)
  • class dict(mapping, **kwarg)
  • class dict(iterable, **kwarg)
• 參數說明：
  • **kwargs -- 關鍵字
  • mapping -- 元素的容器。
  • iterable -- 可迭代對象。
• 返回值：
  • 返回一個字典。

實例：

data1 = dict()　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 # 使用dict函數創建一個空字典
data2 = dict(name="菜鳥程序員",age=18,gender="male")　　　　　　　　　　　　　　# 傳入關鍵字
data3 = dict(zip(['name', 'age', 'gender'], ["菜鳥程序員", 18, "male"]))　　# 映射函數方式來構造字典
data4 = dict([('name', "菜鳥程序員"), ('age', 18), ('gender', "male")])　　 # 可迭代對象方式來構造字典

print(data1)
print(data2)
print(data3)
print(data4)

"""
{}
{'gender': 'male', 'name': '菜鳥程序員', 'age': 18}
{'age': 18, 'name': '菜鳥程序員', 'gender': 'male'}
{'age': 18, 'name': '菜鳥程序員', 'gender': 'male'}
"""

3. help() 函數

• help() 函數用於查看函數或模塊用途的詳細說明。
• 語法
  • help([object])
• 參數說明：
  • object -- 對象；
• 返回值
  • 返回對象幫助信息。

實例：

help_sys = help('sys')                      # 查看 sys 模塊的幫助
help_str = help('str')                      # 查看 str 數據類型的幫助
my_list = [1, 2, 3]
help_list = help(my_list)                   # 查看列表 list 幫助信息
help_list_append = help(my_list.append)     # 顯示list的append方法的幫助

4. min() 函數

• min() 方法返回給定參數的最小值，參數可以為序列。
• 語法
  • min( x, y, z, .... )
• 參數
  • x -- 數值表達式。
  • y -- 數值表達式。
  • z -- 數值表達式。
• 返回值
  • 返回給定參數的最小值。

實例：

my_tuple = (5,2,34,9,15,78,-80)
my_list = [5,2,34,9,15,78,-80]
print(min(my_tuple))
print(min(my_list))

# -80
# -80

5. setattr() 函數

• setattr() 函數對應函數 getattr()，用於設置屬性值，該屬性不一定是存在的。
• 語法
  • setattr(object, name, value)
• 參數
  • object -- 對象。
  • name -- 字符串，對象屬性。
  • value -- 屬性值。
• 返回值
  • 無。

實例：

# 對已存在的屬性進行賦值：
class A(object):
    bar = 1
a = A()
print(getattr(a, 'bar'))        # 獲取屬性 bar 值
setattr(a, 'bar', 5)            # 設置屬性 bar 值
print(a.bar)

# 如果屬性不存在會創建一個新的對象屬性，並對屬性賦值：
class B():
    name = "runoob"
b = B()
setattr(b, "age", 18)
print(b.age)

# 1
# 5
# 28

6. all() 函數

• all() 函數用於判斷給定的可迭代參數 iterable 中的所有元素是否都為 TRUE，如果是返回 True，否則返回 False。元素除了是 0、空、None、False 外都算 True。
• 函數等價於：

  def all(iterable):
      for element in iterable:
          if not element:
              return False
      return True
  

• 語法 all(iterable)
• 參數 iterable -- 元組或列表。
• 返回值
  • 如果iterable的所有元素不為0、''、False或者iterable為空，all(iterable)返回True，否則返回False；
• 注意：空元組、空列表返回值為True，這里要特別注意。

# 1. 字典，元素都不為空或0
data_1 = {
    "name": "菜鳥程序員",
    "age": 18,
    "gender": "male"
}
status_1 = all([data_1["name"], data_1["age"], data_1["gender"]])
print(status_1)

# 2. 字典，元素name為空
data_2 = {
    "name": None,
    "age": 18,
    "gender": "male"
}
status_2 = all([data_2["name"], data_2["age"], data_2["gender"]])
print(status_2)

# 3. 列表list，元素都不為空或0
list_1 = ["菜鳥程序員",18,"male"]
status_3 = all(list_1)
print(status_3)

# 4. 列表list，存在一個為空的元素
list_2 = ["",18,"male"]
status_4 = all(list_2)
print(status_4)

# 5. 列表list，存在一個為0的元素
list_3 = ["菜鳥程序員",0,"male"]
status_5 = all(list_3)
print(status_5)

# 6. 元組tuple，元素都不為空或0
tuple_1 = ("菜鳥程序員",18,"male")
status_6 = all(tuple_1)
print(status_6)


# 7. 元組tuple，存在一個為0的元素
tuple_2 = ("菜鳥程序員",0,"male")
status_7 = all(tuple_2)
print(status_7)

print(all([]))
print(all(()))

"""
結果：
True
False
True
False
False
True
False
True
True
"""

7. dir() 函數

• dir() 函數不帶參數時，返回當前范圍內的變量、方法和定義的類型列表；帶參數時，返回參數的屬性、方法列表。如果參數包含方法__dir__()，該方法將被調用。如果參數不包含__dir__()，該方法將最大限度地收集參數信息。
• 語法
  • dir([object])
• 參數說明：
  • object -- 對象、變量、類型。
• 返回值 返回模塊的屬性列表。

實例：

# 獲得 當前模塊 的屬性列表
print(dir())

# 查看 列表 的方法
my_list = list()
print(dir(my_list))

# 查看 元祖 的方法
my_tuple = tuple()
print(dir(my_tuple))

# 查看 字典 的方法
my_dict = dict()
print(dir(my_dict))

# 查看 set集合 的方法
my_set = set()
print(dir(my_set))

"""
['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__']
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
['__and__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__iand__', '__init__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']
"""

8. hex() 函數

• hex() 函數用於將一個指定數字轉換為 16 進制數。
• 語法
  • hex(x)
• 參數說明：
  • x -- 一個整數
• 返回值
  • 返回一個字符串，以 0x 開頭。

實例：

# 將 十進制的255 轉換為 16進制
print(hex(255))
# 將 十進制的-42 轉換為 16進制
print(hex(-42))
# 將 十進制的12 轉換為 16進制
print(hex(12))
# 將 十進制的12 轉換為 16進制，獲取返回值類型
print(type(hex(12)))

"""
0xff
-0x2a
0xc
<class 'str'>
"""

9. next() 函數

• next() 返回迭代器的下一個項目。
• 語法
  • next(iterator[, default])
• 參數說明：
  • iterator -- 可迭代對象
  • default -- 可選，用於設置在沒有下一個元素時返回該默認值，如果不設置，又沒有下一個元素則會觸發 StopIteration 異常。
• 返回值
  • 返回對象幫助信息。

實例：

# 首先獲得Iterator對象:
it = iter([1, 2, 3, 4, 5])
# 循環:
while True:
    try:
        # 獲得下一個值:
        x = next(it)
        print(x)
    except StopIteration:
        # 遇到StopIteration就退出循環
        break
        
"""
1
2
3
4
5
"""

10. slice() 函數

• slice() 函數實現切片對象，主要用在切片操作函數里的參數傳遞。
• 語法
  • class slice(stop)
  • class slice(start, stop[, step])
• 參數說明：
  • start -- 起始位置
  • stop -- 結束位置
  • step -- 間距
• 返回值
  • 返回一個切片對象。

實例：

my_slice = slice(5)      # 設置截取5個元素的切片
print(my_slice)

# 定義一個列表
my_list = list()
# 循環0-9
for i in range(10):
    # 將循環出來的每個對象添加至my_list
    my_list.append(i)
print(my_list)
print(my_list[my_slice])     # 截取 5 個元素

"""
slice(None, 5, None)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4]
"""

11. any() 函數

• any() 函數用於判斷給定的可迭代參數 iterable 是否全部為 False，則返回 False，如果有一個為 True，則返回 True。元素除了是 0、空、FALSE 外都算 TRUE。
• 函數等價於：

  def any(iterable):
      for element in iterable:
          if element:
              return True
      return False
  

• 語法
  • any(iterable)
• 參數
  • iterable -- 元組或列表。
• 返回值
  • 如果都為空、0、false，則返回false，如果不都為空、0、false，則返回true。

實例：

print(any(['a', 'b', 'c', 'd']))    # 列表list，元素都不為空或0
print(any(['a', 'b', '', 'd']))     # 列表list，存在一個為空的元素
print(any([0, '', False]))          # 列表list,元素全為0,'',false
print(any(('a', 'b', 'c', 'd')))    # 元組tuple，元素都不為空或0
print(any(('a', 'b', '', 'd')))     # 元組tuple，存在一個為空的元素
print(any((0, '', False)))          # 元組tuple，元素全為0,'',false
print(any([]))                      # 空列表
print(any(()))                      # 空元組

"""
True
True
False
True
True
False
False
False
"""

12. divmod() 函數

• Python divmod() 函數接收兩個數字類型（非復數）參數，返回一個包含商和余數的元組(a // b, a % b)。在 python 3.x 版本該函數不支持復數。
• 語法
  • divmod(a, b) 參數說明：
  • a: 數字，非復數。
  • b: 數字，非復數。 如果參數 a 與 參數 b 都是整數，函數返回的結果相當於 (a // b, a % b)。 如果其中一個參數為浮點數時，函數返回的結果相當於 (q, a % b)，q 通常是 math.floor(a / b)，但也有可能是 1 ，比小，不過 q * b + a % b 的值會非常接近 a。 如果 a % b 的求余結果不為 0 ，則余數的正負符號跟參數 b 是一樣的，若 b 是正數，余數為正數，若 b 為負數，余數也為負數，並且 0 <= abs(a % b) < abs(b)。

實例：

print(divmod(7, 2))
print(divmod(8, 2))
print(divmod(8, -2))
print(divmod(3, 1.3))

"""
(3, 1)
(4, 0)
(-4, 0)
(2.0, 0.3999999999999999)
"""

13. id() 函數

• id() 函數返回對象的唯一標識符，標識符是一個整數。CPython 中 id() 函數用於獲取對象的內存地址。
• 語法
  • id([object])
• 參數說明：
  • object -- 對象。
• 返回值 返回對象的內存地址。

實例：

string = '菜鳥程序員'
print(id(string))  # 打印變量string的內存地址

def func():
    return '菜鳥程序員'
print(id(func))     # 打印 函數func 的內存地址

"""
2417805698744
2417805850824
"""

14. sorted() 函數

• sorted() 函數對所有可迭代的對象進行排序操作。
• 語法
  • sorted(iterable, key=None, reverse=False) 
• 參數說明：
  • iterable -- 可迭代對象。
  • key -- 主要是用來進行比較的元素，只有一個參數，具體的函數的參數就是取自於可迭代對象中，指定可迭代對象中的一個元素來進行排序。
  • reverse -- 排序規則，reverse = True 降序 ， reverse = False 升序（默認）。
• 返回值
  • 返回重新排序的列表。

實例：

# 列表排序
my_list = [33,28,18,23,21]
print(sorted(my_list))

# 使用list.sort()方法排序(效率更高)
my_list_1 = [33,28,18,23,21]
my_list_1.sort()
print(my_list_1)

# 利用key進行倒序排序
example_list = [5, 0, 6, 1, 2, 7, 3, 4]
result_list = sorted(example_list, key=lambda x: x*-1)
print(result_list)

# 要進行反向排序，也通過傳入第三個參數 reverse=True：
reverse_list = [5, 0, 6, 1, 2, 7, 3, 4]
print(sorted(reverse_list, reverse=True))

# 元祖排序
my_tuple = (33,28,18,23,21)
print(sorted(my_tuple))

# 字典排序
my_dict = {
    33: 'age',
    28: 'age',
    18: 'age',
    23: 'age',
    21: 'age'
}
print(sorted(my_dict))

"""
[18, 21, 23, 28, 33]
[18, 21, 23, 28, 33]
[7, 6, 5, 4, 3, 2, 1, 0]
[7, 6, 5, 4, 3, 2, 1, 0]
[18, 21, 23, 28, 33]
[18, 21, 23, 28, 33]
"""

15. ascii() 函數

• ascii() 函數類似 repr() 函數, 返回一個表示對象的字符串, 但是對於字符串中的非 ASCII 字符則返回通過 repr() 函數使用 \x, \u 或 \U 編碼的字符。 生成字符串類似 Python2 版本中 repr() 函數的返回值。
• 語法
  • ascii(object)
• 參數
  • object -- 對象。
• 返回值
  • 返回字符串。

實例：

string_1 = "菜鳥程序員"
print(ascii(string_1))

string_2 = "python"
print(ascii(string_2))

"""
'\u83dc\u9e1f\u7a0b\u5e8f\u5458'
'python'
"""

16. enumerate() 函數

• enumerate() 函數用於將一個可遍歷的數據對象(如列表、元組或字符串)組合為一個索引序列，同時列出數據和數據下標，一般用在 for 循環當中。
• 語法
  • enumerate(sequence, [start=0])
• 參數
  • sequence -- 一個序列、迭代器或其他支持迭代對象。
  • start -- 下標起始位置。
• 返回值
  • 返回 enumerate(枚舉) 對象。

實例：

my_list_1 = ["菜鳥程序員",18,"male"]
print(list(enumerate(my_list_1)))
print(list(enumerate(my_list_1, start=1)))       # 下標從 1 開始


my_list_2 = ["菜鳥程序員",18,"male"]
tuple_list = list()
i = 0
for element in my_list_2:
    my_tuple = (i,my_list_2[i])
    tuple_list.append(my_tuple)
    i += 1
print(tuple_list)

my_list_3 = ["菜鳥程序員",18,"male"]
for i, element in enumerate(my_list_3):
    print(i, my_list_3[i])

"""
[(0, '菜鳥程序員'), (1, 18), (2, 'male')]
[(1, '菜鳥程序員'), (2, 18), (3, 'male')]
[(0, '菜鳥程序員'), (1, 18), (2, 'male')]
0 菜鳥程序員
1 18
2 male
"""

17. input() 函數

• Python3.x 中 input() 函數接受一個標准輸入數據，返回為 string 類型。
• 函數語法
  • input([prompt])
• 參數說明：
  • prompt: 提示信息

實例：

while True:
    name = input("你愛我嗎?:\n")
    if name == "愛":
        print("******* 燈紅酒綠惹人醉，大哥帶你混社會。*******")
        break
    elif name == "不愛":
        print("******* 你是好人我不配，忘了我吧下一位。*******")
    else:
        print("******* 花花世界迷人眼，沒有實力別賽臉。*******")

 

18. oct() 函數

• oct() 函數將一個整數轉換成8進制字符串
• 語法
  • oct(x)
• 參數說明：
  • x -- 整數。
• 返回值
  • 返回8進制字符串。

實例：

print(oct(10))
print(oct(20))
print(oct(15))

"""
0o12
0o24
0o17
"""

19. staticmethod() 函數

• python staticmethod 返回函數的靜態方法。該方法不強制要求傳遞參數，如下聲明一個靜態方法：

  class C(object):
      @staticmethod
      def f(arg1, arg2, ...):
          ...
  # 以上實例聲明了靜態方法 f，從而可以實現實例化使用 C().f()，當然也可以不實例化調用該方法 C.f()。
  

• 函數語法
  • staticmethod(function)
• 參數說明：
  • 無

實例：

class MyClass(object):
    @staticmethod
    def f():
        print('菜鳥程序員')


MyClass.f()     # 靜態方法無需實例化
cobj = MyClass()
cobj.f()        # 也可以實例化后調用

"""
菜鳥程序員
菜鳥程序員
"""

20. bin() 函數

• bin() 返回一個整數 int 或者長整數 long int 的二進制表示。
• 語法
  • bin(x)
• 參數
  • x -- int 或者 long int 數字
• 返回值
  • 字符串。

實例：

print(bin(10))
print(bin(20))

"""
0b1010
0b10100
"""

21. eval() 函數

• eval() 函數用來執行一個字符串表達式，並返回表達式的值。
• 語法
  • eval(expression[, globals[, locals]])
• 參數
  • expression -- 表達式。
  • globals -- 變量作用域，全局命名空間，如果被提供，則必須是一個字典對象。
  • locals -- 變量作用域，局部命名空間，如果被提供，可以是任何映射對象。
• 返回值
  • 返回表達式計算結果。

實例：

x = 7
print(eval('3 * x'))
print(eval('pow(2,2)'))
print(eval('2 + 2'))
n = 81
print(eval('n + 4'))

dict_str = '{"name":"菜鳥程序員","age":18,"gender":True}'
print(type(eval(dict_str)))
print(eval(dict_str))

list_str = '["菜鳥程序員", 18, True]'
print(type(eval(list_str)))
print(eval(list_str))

tuple_str = '("菜鳥程序員", 18, True)'
print(type(eval(tuple_str)))
print(eval(tuple_str))

"""
21
4
4
85
<class 'dict'>
{'name': '菜鳥程序員', 'age': 18, 'gender': True}
<class 'list'>
['菜鳥程序員', 18, True]
<class 'tuple'>
('菜鳥程序員', 18, True)
"""

 22. int() 函數

• int() 函數用於將一個字符串或數字轉換為整型。
• 語法
  • class int(x, base=10)
• 參數
  • x -- 字符串或數字。
  • base -- 進制數，默認十進制。
• 返回值
  • 返回整型數據。

實例：

print(int())             # int() 函數默認值
print(int(3))
print(int(3.6))
print(int('12',16))        # 如果是帶參數base的話，12要以字符串的形式進行輸入，12 為 16進制
print(int('0xa',16))
print(int('10',8))
print(int("9"))         # 默認10進制
print(int("1001",2))
print(int("0xa",16))    # "1001"才是2進制格式，並轉化為十進制數字9
print(int("123",8))     # 視123為8進制數字，對應的10進制為83


############################### 錯誤示范 ###############################
print(int("9",2))       # 報錯，因為2進制無9
print(int("3.14",8))    # 報錯，str須為整數
print(int("1.2"))       # 報錯，str須為整數
print(int("b",8))       # 報錯,≥16進制才會允許入參為a,b,c...

"""
0
3
3
18
10
8
9
9
10
83
Traceback (most recent call last):
  File "D:/projects/學習項目目錄/python相關/python 常用模塊/python 內置函數/22. python-int() 函數.py", line 13, in <module>
    print(int("9",2))       # 報錯，因為2進制無9
ValueError: invalid literal for int() with base 2: '9'
"""

23. open() 函數

• Python open() 函數用於打開一個文件，並返回文件對象，在對文件進行處理過程都需要使用到這個函數，如果該文件無法被打開，會拋出 OSError。
• 語法
  • open(file, mode='r')
  • open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
• 參數
  • file: 必需，文件路徑（相對或者絕對路徑）。
  • mode: 可選，文件打開模式
  • buffering: 設置緩沖
  • encoding: 一般使用utf8
  • errors: 報錯級別
  • newline: 區分換行符
  • closefd: 傳入的file參數類型
  • opener:
• mode 參數有：
  • 模式 描述
  • t 文本模式 (默認)。
  • x 寫模式，新建一個文件，如果該文件已存在則會報錯。
  • b 二進制模式。

  • •   打開一個文件進行更新(可讀可寫)。
      

  • U 通用換行模式（不推薦）。
  • r 以只讀方式打開文件。文件的指針將會放在文件的開頭。這是默認模式。
  • rb 以二進制格式打開一個文件用於只讀。文件指針將會放在文件的開頭。這是默認模式。一般用於非文本文件如圖片等。
  • r+ 打開一個文件用於讀寫。文件指針將會放在文件的開頭。
  • rb+ 以二進制格式打開一個文件用於讀寫。文件指針將會放在文件的開頭。一般用於非文本文件如圖片等。
  • w 打開一個文件只用於寫入。如果該文件已存在則打開文件，並從開頭開始編輯，即原有內容會被刪除。如果該文件不存在，創建新文件。
  • wb 以二進制格式打開一個文件只用於寫入。如果該文件已存在則打開文件，並從開頭開始編輯，即原有內容會被刪除。如果該文件不存在，創建新文件。一般用於非文本文件如圖片等。
  • w+ 打開一個文件用於讀寫。如果該文件已存在則打開文件，並從開頭開始編輯，即原有內容會被刪除。如果該文件不存在，創建新文件。
  • wb+ 以二進制格式打開一個文件用於讀寫。如果該文件已存在則打開文件，並從開頭開始編輯，即原有內容會被刪除。如果該文件不存在，創建新文件。一般用於非文本文件如圖片等。
  • a 打開一個文件用於追加。如果該文件已存在，文件指針將會放在文件的結尾。也就是說，新的內容將會被寫入到已有內容之后。如果該文件不存在，創建新文件進行寫入。
  • ab 以二進制格式打開一個文件用於追加。如果該文件已存在，文件指針將會放在文件的結尾。也就是說，新的內容將會被寫入到已有內容之后。如果該文件不存在，創建新文件進行寫入。
  • a+ 打開一個文件用於讀寫。如果該文件已存在，文件指針將會放在文件的結尾。文件打開時會是追加模式。如果該文件不存在，創建新文件用於讀寫。
  • ab+ 以二進制格式打開一個文件用於追加。如果該文件已存在，文件指針將會放在文件的結尾。如果該文件不存在，創建新文件用於讀寫。
  • 默認為文本模式，如果要以二進制模式打開，加上 b 。

參考：https://www.cnblogs.com/xingxingnbsp/p/12408522.html

24. str() 函數

• str() 函數將對象轉化為適於人閱讀的形式。
• 語法
  • class str(object='')
• 參數
  • object -- 對象。
• 返回值
  • 返回一個對象的string格式。

實例：

name = '菜鳥程序員'
print(str(name))
print(type(str(name)))

age = 18
print(str(age))
print(type(str(age)))

gender = True
print(str(gender))
print(type(str(gender)))

my_dict = {'name': '菜鳥程序員', 'age': 18, 'gender': True}
print(str(my_dict))
print(type(str(my_dict)))

my_list = ['菜鳥程序員', 18, True]
print(str(my_list))
print(type(str(my_list)))

my_tuple = ('菜鳥程序員', 18, True)
print(str(my_tuple))
print(type(str(my_tuple)))

my_set = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(str(my_set))      # set 集合自帶去重
print(type(str(my_set)))

"""
菜鳥程序員
<class 'str'>
18
<class 'str'>
True
<class 'str'>
{'gender': True, 'name': '菜鳥程序員', 'age': 18}
<class 'str'>
['菜鳥程序員', 18, True]
<class 'str'>
('菜鳥程序員', 18, True)
<class 'str'>
{'orange', 'banana', 'pear', 'apple'}
<class 'str'>
"""

25. bool() 函數

• bool() 函數用於將給定參數轉換為布爾類型，如果沒有參數，返回 False。
• 語法
  • class bool([x])
• 參數
  • x -- 要進行轉換的參數。
• 返回值
  • 返回 True 或 False。

實例：

print(bool())
print(bool(0))
print(bool(1))
print(bool(2))
print(issubclass(bool, int))  # bool 是 int 子類

"""
False
False
True
True
True
"""

26. exec 函數

• exec 執行儲存在字符串或文件中的 Python 語句，相比於 eval，exec可以執行更復雜的 Python 代碼。
• 語法
  • exec(object[, globals[, locals]])
• 參數
  • object：必選參數，表示需要被指定的Python代碼。它必須是字符串或code對象。如果object是一個字符串，該字符串會先被解析為一組Python語句，然后在執行（除非發生語法錯誤）。如果object是一個code對象，那么它只是被簡單的執行。
  • globals：可選參數，表示全局命名空間（存放全局變量），如果被提供，則必須是一個字典對象。
  • locals：可選參數，表示當前局部命名空間（存放局部變量），如果被提供，可以是任何映射對象。如果該參數被忽略，那么它將會取與globals相同的值。
• 返回值
  • exec 返回值永遠為 None。

實例：

exec('print("Hello World")')

# 單行語句字符串
exec("print ('runoob.com')")

#  多行語句字符串
exec("""
for i in range(5):
    print ("iter time: %d" % i)
""")

"""
Hello World
runoob.com
iter time: 0
iter time: 1
iter time: 2
iter time: 3
iter time: 4
"""

27. isinstance() 函數

• isinstance() 函數來判斷一個對象是否是一個已知的類型，類似 type()。
• 語法
  • isinstance(object, classinfo)
• 參數
  • object -- 實例對象。
  • classinfo -- 可以是直接或間接類名、基本類型或者由它們組成的元組。
• 返回值
  • 如果對象的類型與參數二的類型（classinfo）相同則返回 True，否則返回 False。。

實例：

a = 2
print(isinstance (a,int))               # 判斷 變量a 是否為 int類型
print(isinstance (a,str))               # 判斷 變量a 是否為 str類型
print(isinstance (a,(str,int,list)))    # 判斷 變量a 是否為 str|int|list 中的一個

# type() 與 isinstance() 區別：
class A:
    pass
class B(A):
    pass
print(isinstance(A(), A))
print(type(A()) == A)
print(isinstance(B(), A))
print(type(B()) == A)

"""
True
False
True
True
True
True
False
"""

28. ord() 函數

• ord() 函數是 chr() 函數（對於 8 位的 ASCII 字符串）的配對函數，它以一個字符串（Unicode 字符）作為參數，返回對應的 ASCII 數值，或者 Unicode 數值。
• 語法
  • ord(c)
• 參數
  • c -- 字符。
• 返回值
  • 返回值是對應的十進制整數。

實例：

print(ord('a'))
print(ord('€'))

"""
97
8364
"""

29. sum() 函數

• sum() 方法對系列進行求和計算。
• 語法
  • sum(iterable[, start])
• 參數
  • iterable -- 可迭代對象，如：列表、元組、集合。
  • start -- 指定相加的參數，如果沒有設置這個值，默認為0。
• 返回值
  • 返回計算結果。

實例：

list_1 = [12,34,56]
list_2 = [0,21,59,48,90,42]
list_3 = [59,48,90,42]

print(sum(list_1))
print(sum(list_2, 1))        # 元組計算總和后再加 1
print(sum(list_3, 2))      # 列表計算總和后再加 2

"""
102
261
241
"""

30. bytearray() 函數

• bytearray() 方法返回一個新字節數組。這個數組里的元素是可變的，並且每個元素的值范圍: 0 <= x < 256。
• 語法
  • class bytearray([source[, encoding[, errors]]])
• 參數
  • 如果 source 為整數，則返回一個長度為 source 的初始化數組；
  • 如果 source 為字符串，則按照指定的 encoding 將字符串轉換為字節序列；
  • 如果 source 為可迭代類型，則元素必須為[0 ,255] 中的整數；
  • 如果 source 為與 buffer 接口一致的對象，則此對象也可以被用於初始化 bytearray。
  • 如果沒有輸入任何參數，默認就是初始化數組為0個元素。
• 返回值
  • 返回新字節數組。

實例：

print(bytearray())
print(bytearray([1,2,3]))
print(bytearray('菜鳥程序員', 'utf-8'))

"""
bytearray(b'')
bytearray(b'\x01\x02\x03')
bytearray(b'\xe8\x8f\x9c\xe9\xb8\x9f\xe7\xa8\x8b\xe5\xba\x8f\xe5\x91\x98')
"""

31. filter() 函數

• filter() 函數用於過濾序列，過濾掉不符合條件的元素，返回一個迭代器對象，如果要轉換為列表，可以使用 list() 來轉換。
• 該接收兩個參數，第一個為函數，第二個為序列，序列的每個元素作為參數傳遞給函數進行判，然后返回 True 或 False，最后將返回 True 的元素放到新列表中。
• 語法
  • filter(function, iterable)
• 參數
  • function -- 判斷函數。
  • iterable -- 可迭代對象。
• 返回值
  • 返回一個迭代器對象

實例：

# 過濾出列表中的所有奇數：
def is_odd(n):
    return n % 2 == 1
tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
newlist = list(tmplist)
print(newlist)
# [1, 3, 5, 7, 9]

# 過濾出1~100中平方根是整數的數：
import math
def is_sqr(x):
    return math.sqrt(x) % 1 == 0
tmplist = filter(is_sqr, range(1, 101))
newlist = list(tmplist)
print(newlist)
# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

32. issubclass() 函數

• issubclass() 方法用於判斷參數 class 是否是類型參數 classinfo 的子類。
• 語法
  • issubclass(class, classinfo)
• 參數
  • class -- 類。
  • classinfo -- 類。
• 返回值
  • 如果 class 是 classinfo 的子類返回 True，否則返回 False。

實例：

class A:
    pass
class B(A):
    pass
print(issubclass(B, A))  # 返回 True

33. pow() 函數

• pow() 方法返回 xy（x的y次方） 的值。
• 語法

  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   # 導入 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
"""

34. super() 函數

• 描述
  • super() 函數是用於調用父類(超類)的一個方法。
  • super 是用來解決多重繼承問題的，直接用類名調用父類方法在使用單繼承的時候沒問題，但是如果使用多繼承，會涉及到查找順序（MRO）、重復調用（鑽石繼承）等種種問題。
  • MRO 就是類的方法解析順序表, 其實也就是繼承父類方法時的順序表。
• 語法
  • super(type[, object-or-type])
• 參數
  • type -- 類。
  • object-or-type -- 類，一般是 self
• 返回值 無。

實例：

class A:
    def add(self, x):
        y = x + 1
        print(y)

class B(A):
    def add(self, x):
        super().add(x)

b = B()
b.add(2)  # 3

35. bytes 函數

• 描述
  • bytes 函數返回一個新的 bytes 對象，該對象是一個 0 <= x < 256 區間內的整數不可變序列。它是 bytearray 的不可變版本。
• 語法
  • class bytes([source[, encoding[, errors]]])
• 參數
  • 如果 source 為整數，則返回一個長度為 source 的初始化數組；
  • 如果 source 為字符串，則按照指定的 encoding 將字符串轉換為字節序列；
  • 如果 source 為可迭代類型，則元素必須為[0 ,255] 中的整數；
  • 如果 source 為與 buffer 接口一致的對象，則此對象也可以被用於初始化 bytearray。
  • 如果沒有輸入任何參數，默認就是初始化數組為0個元素。
• 返回值
  • 返回一個新的 bytes 對象。

實例：

a = bytes([1,2,3,4])
print(a)
print(type(a))

b = bytes('hello','ascii')
print(b)
print(type(b))

"""
b'\x01\x02\x03\x04'
<class 'bytes'>
b'hello'
<class 'bytes'>
"""

36. float() 函數

• 描述
  • float() 函數用於將整數和字符串轉換成浮點數。
• 語法
  • class float([x])
• 參數
  • x -- 整數或字符串
• 返回值
  • 返回浮點數。

實例：

print(float(1))
print(float(112))
print(float(-123.6))
print(float('123'))     # 字符串

"""
1.0
112.0
-123.6
123.0
"""

37. iter() 函數

• 描述
  • iter() 函數用來生成迭代器。
• 語法
  • iter(object[, sentinel])
• 參數
  • object -- 支持迭代的集合對象。
  • sentinel -- 如果傳遞了第二個參數，則參數 object 必須是一個可調用的對象（如，函數），此時，iter 創建了一個迭代器對象，每次調用這個迭代器對象的__next__()方法時，都會調用 object。
• 返回值
  • 迭代器對象。

實例：

lst = [1, 2, 3]
for i in iter(lst):
    print(i)
    
"""
1
2
3
"""

38. print() 函數

• 描述
  • print() 方法用於打印輸出，最常見的一個函數。
• 語法
  • print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
• 參數
  • objects -- 復數，表示可以一次輸出多個對象。輸出多個對象時，需要用 , 分隔。
  • sep -- 用來間隔多個對象，默認值是一個空格。
  • end -- 用來設定以什么結尾。默認值是換行符 \n，我們可以換成其他字符串。
  • file -- 要寫入的文件對象。
  • flush -- 輸出是否被緩存通常決定於 file，但如果 flush 關鍵字參數為 True，流會被強制刷新。
• 返回值
  • 無。

實例：

# 以下展示了使用 print函數 的實例：
print(1)
print("Hello World")
a = 1
b = 'runoob'
print(a, b)
print("aaa""bbb")
print("aaa", "bbb")
print("www", "runoob", "com", sep=".")  # 設置間隔符


# 使用flush參數生成一個Loading的效果：

import time
print("---RUNOOB EXAMPLE ： Loading 效果---")
print("Loading", end="")
for i in range(20):
    print(".", end='', flush=True)
    time.sleep(0.5)
    
"""
1
Hello World
1 runoob
aaabbb
aaa bbb
www.runoob.com
---RUNOOB EXAMPLE ： Loading 效果---
Loading.......
"""

39. tuple 函數

• 描述
  • tuple 函數將可迭代系列（如列表）轉換為元組。
• 語法
  • tuple( iterable )
• 參數
  • iterable -- 要轉換為元組的可迭代序列。
• 返回值
  • 返回元組。

實例：

list1 = ['Google', 'Taobao', 'Runoob', 'Baidu']
tuple1 = tuple(list1)
print(tuple1)

a = 'www'
b = tuple(a)
print(b)

a = {'www': 123, 'aaa': 234}
b = tuple(a)  # 將字段轉換為元組時，只保留鍵！
print(b)

a = set('abcd')
print(a)

b = tuple(a)
print(b)

"""
('Google', 'Taobao', 'Runoob', 'Baidu')
('w', 'w', 'w')
('aaa', 'www')
{'b', 'd', 'a', 'c'}
('b', 'd', 'a', 'c')
"""

40. callable() 函數

• 描述
  • callable() 函數用於檢查一個對象是否是可調用的。如果返回 True，object 仍然可能調用失敗；但如果返回 False，調用對象 object 絕對不會成功。
  • 對於函數、方法、lambda 函式、 類以及實現了 call 方法的類實例, 它都返回 True。
• 語法
  • callable(object)
• 參數
  • object -- 對象
• 返回值
  • 可調用返回 True，否則返回 False。

實例：

print(callable(0))
print(callable("runoob"))


def add(a, b):
    return a + b


print(callable(add))  # 函數返回 True


class A:  # 類
    def method(self):
        return 0


print(callable(A))  # 類返回 True

a = A()
print(callable(a))  # 沒有實現 __call__, 返回 False


class B:
    def __call__(self):
        return 0


print(callable(B))

b = B()
print(callable(b))  # 實現 __call__, 返回 True
"""
False
False
True
True
False
True
True
"""

41. format 格式化函數

• 描述
  • format 函數用來格式化字符串
• 語法 .format(object)
• 參數
  • object -- 可以是一個對象，函數，字符串，數字
• 返回值
  • 返回格式化后的字符串，或對象

實例：

# 默認傳參
str_1 = "我是{}，我今年{}歲，我的性別是{}".format("菜鳥程序員", 18, "男")
print(str_1)

# 位置傳參
str_2 = "我是{0}，我今年{1}歲，我的性別是{2}".format("菜鳥程序員", 18, "男")
print(str_2)

# 位置傳參
str_3 = "我是{1}，我今年{0}歲，我的性別是{2}".format(18, "菜鳥程序員", "男")
print(str_3)

# 關鍵字傳參
str_4 = "我是{name}，我今年{age}歲，我的性別是{gender}".format(age=18, name="菜鳥程序員", gender="男")
print(str_4)

# 字典傳參數
data = {"name": "菜鳥程序員", "age": 18, "gender": "男"}
str_5 = "我是{name}，我今年{age}歲，我的性別是{gender}".format(**data)
print(str_5)

# 通過列表索引設置參數
my_list = ['菜鳥程序員', 18, "男"]
str_6 = "我是{0[0]}，我今年{0[1]}歲，我的性別是{0[2]}".format(my_list)   # "0" 是必須的
print(str_6)

"""
我是菜鳥程序員，我今年18歲，我的性別是男
我是菜鳥程序員，我今年18歲，我的性別是男
我是菜鳥程序員，我今年18歲，我的性別是男
我是菜鳥程序員，我今年18歲，我的性別是男
我是菜鳥程序員，我今年18歲，我的性別是男
我是菜鳥程序員，我今年18歲，我的性別是男
"""

42. len()方法

• 描述
  • Python len() 方法返回對象（字符、列表、元組等）長度或項目個數。
• 語法
  • len( s )
• 參數
  • s -- 對象。
• 返回值
  • 返回對象長度。

實例：

str_1 = "菜鳥程序員"
print(len(str_1))  # 字符串長度

list_1 = [1, 2, 3, 4, 5]
print(len(list_1))  # 列表元素個數

tuple_1 = (1, 2, 3, 4, 5)
print(len(tuple_1))

dict_1 = {"name": "菜鳥程序員", "age": 18, "gender": True}
print(len(dict_1))

set_1 = {"name", "age", "gender"}
print(len(set_1))

"""
5
5
5
3
3
"""

######################################### 錯誤示范 ############################################
"""
num_1 = 18
print(len(num_1))
# TypeError: object of type 'int' has no len()

bool_1 = True
print(len(bool_1))
# TypeError: object of type 'bool' has no len()

float_1 = 3.14
print(len(float_1))
# TypeError: object of type 'float' has no len()
"""

43. 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

44. type() 函數

• 描述
  • type() 函數如果你只有第一個參數則返回對象的類型，三個參數返回新的類型對象。

  isinstance() 與 type() 區別：
      type() 不會認為子類是一種父類類型，不考慮繼承關系。
      isinstance() 會認為子類是一種父類類型，考慮繼承關系。
  如果要判斷兩個類型是否相同推薦使用 isinstance()。
  

• 語法
  • type(object)
  • type(name, bases, dict)
• 參數
  • name -- 類的名稱。
  • bases -- 基類的元組。
  • dict -- 字典，類內定義的命名空間變量。
• 返回值
  • 一個參數返回對象類型, 三個參數，返回新的類型對象。

實例：

name = "菜鳥程序員"
print(type(name))

age = 18
print(type(age))

gender = True
print(type(gender))

my_dict = {"name": "菜鳥程序員", "age": 18, "gender": True}
print(type(my_dict))

my_list = ["菜鳥程序員", 18, True]
print(type(my_list))

my_set = {"菜鳥程序員", 18, True}
print(type(my_set))

my_tuple = ("菜鳥程序員", 18, True)
print(type(my_tuple))

def my_func():
    pass
print(type(my_func))

class my_class(object):
    pass
print(type(my_class))

"""
<class 'str'>
<class 'int'>
<class 'bool'>
<class 'dict'>
<class 'list'>
<class 'set'>
<class 'tuple'>
<class 'function'>
<class 'type'>
"""

45. chr() 函數

• 描述
  • chr() 用一個整數作參數，返回一個對應的字符。
• 語法
  • chr(i)
• 參數
  • i -- 可以是 10 進制也可以是 16 進制的形式的數字，數字范圍為 0 到 1,114,111 (16 進制為0x10FFFF)。
• 返回值
  • 返回值是當前整數對應的 ASCII 字符。

實例：

print(chr(0x30))
print(chr(97))
print(chr(8364))

"""
0
a
€
"""

46. frozenset() 函數

• 描述
  • frozenset() 返回一個凍結的集合，凍結后集合不能再添加或刪除任何元素。
• 語法
  • class frozenset([iterable])
• 參數
  • iterable -- 可迭代的對象，比如列表、字典、元組等等。
• 返回值
  • 返回新的 frozenset 對象，如果不提供任何參數，默認會生成空集合。

實例：

a = frozenset(range(10))    # 生成一個新的不可變集合
print(a)

b = frozenset('菜鳥程序員')     # 創建不可變集合
print(b)

"""
frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
frozenset({'鳥', '程', '員', '菜', '序'})
"""

47. list()方法

• 描述
  • list() 方法用於將元組或字符串轉換為列表。
  • 注：元組與列表是非常類似的，區別在於元組的元素值不能修改，元組是放在括號中，列表是放於方括號中。
• 語法
  • list( seq )
• 參數
  • seq -- 要轉換為列表的元組或字符串。
• 返回值
  • 返回列表。

實例：

my_tuple = ("菜鳥程序員", 18, True)
list1 = list(my_tuple)
print("列表元素 : ", list1)

name = "菜鳥程序員"
list2 = list(name)
print("列表元素 : ", list2)

"""
列表元素 :  ['菜鳥程序員', 18, True]
列表元素 :  ['菜', '鳥', '程', '序', '員']
"""

48. range() 函數用法

• 描述
  • Python3 range() 函數返回的是一個可迭代對象（類型是對象），而不是列表類型， 所以打印的時候不會打印列表。
  • Python3 list() 函數是對象迭代器，可以把range()返回的可迭代對象轉為一個列表，返回的變量類型為列表。
  • Python2 range() 函數返回的是列表。
• 函數語法
  • range(stop)
  • 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(5):
    print(i)

print(list(range(0, 30, 5)))
print(list(range(0, 10, 2)))
print(list(range(0, -10, -1)))
print(list(range(1, 0)))

"""
0
1
2
3
4
[0, 5, 10, 15, 20, 25]
[0, 2, 4, 6, 8]
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
[]
"""

49. vars() 函數

• 描述
  • vars() 函數返回對象object的屬性和屬性值的字典對象。
• 語法
  • vars([object])
• 參數
  • object -- 對象
• 返回值
  • 返回對象object的屬性和屬性值的字典對象，如果沒有參數，就打印當前調用位置的屬性和屬性值 類似 locals()。

實例：

print(vars())

class Runoob:
    a = 1
print(vars(Runoob))

runoob = Runoob()
print(vars(runoob))

"""
{'__package__': None, '__builtins__': <module 'builtins' (built-in)>, '__cached__': None, '__name__': '__main__', '__file__': 'D:/projects/學習項目目錄/python相關/python 常用模塊/python 內置函數/49. python-vars() 函數.py', '__doc__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000002B9AC196B38>, '__spec__': None}
{'__module__': '__main__', '__dict__': <attribute '__dict__' of 'Runoob' objects>, '__doc__': None, '__weakref__': <attribute '__weakref__' of 'Runoob' objects>, 'a': 1}
{}
"""

50. classmethod 修飾符

• 描述
  • classmethod 修飾符對應的函數不需要實例化，不需要 self 參數，但第一個參數需要是表示自身類的 cls 參數，可以來調用類的屬性，類的方法，實例化對象等。
• 語法
  • classmethod
• 參數
  • 無。
• 返回值
  • 返回函數的類方法。

實例：

class A(object):
    bar = 1
    def func1(self):
        print('foo')
    @classmethod
    def func2(cls):
        print('func2')
        print(cls.bar)
        cls().func1()  # 調用 foo 方法

A.func2()  # 不需要實例化

"""
func2
1
foo
"""

51. getattr() 函數

• 描述
  • getattr() 函數用於返回一個對象屬性值。
• 語法
  • getattr(object, name[, default])
• 參數
  • object -- 對象。
  • name -- 字符串，對象屬性。
  • default -- 默認返回值，如果不提供該參數，在沒有對應屬性時，將觸發 AttributeError。
• 返回值
  • 返回對象屬性值。

實例：

class A(object):
    bar = 1

a = A()
print(getattr(a, 'bar'))        # 獲取屬性 bar 值

"""
print(getattr(a, 'bar2'))       # 屬性 bar2 不存在，觸發異常
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'A' object has no attribute 'bar2'
"""
print(getattr(a, 'bar2', 3))    # 屬性 bar2 不存在，但設置了默認值

"""
1
3
"""

52. locals() 函數

• 描述
  • locals() 函數會以字典類型返回當前位置的全部局部變量。
  • 對於函數, 方法, lambda 函式, 類, 以及實現了 call 方法的類實例, 它都返回 True。
• 語法
  • locals()
• 參數
  • 無
• 返回值
  • 返回字典類型的局部變量。

實例：

def func(name):    # 兩個局部變量：arg、z
    age = 18
    gender = True
    print (locals())
func("菜鳥程序員")

"""
{'name': '菜鳥程序員', 'age': 18, 'gender': True}
"""

53. repr() 函數

• 描述
  • repr() 函數將對象轉化為供解釋器讀取的形式。
• 語法
  • repr(object)
• 參數
  • object -- 對象。
• 返回值
  • 返回一個對象的 string 格式。

實例：

name = '菜鳥程序員'
print(repr(name))

dict = {'name': '菜鳥程序員', 'age': 18, 'gender': True}
print(repr(dict))

"""
'菜鳥程序員'
{'name': '菜鳥程序員', 'gender': True, 'age': 18}
"""

54. zip() 函數

• 描述
  • zip() 函數用於將可迭代的對象作為參數，將對象中對應的元素打包成一個個元組，然后返回由這些元組組成的對象，這樣做的好處是節約了不少的內存。
  • 我們可以使用 list() 轉換來輸出列表。
  • 如果各個迭代器的元素個數不一致，則返回列表長度與最短的對象相同，利用 * 號操作符，可以將元組解壓為列表。
  • zip 方法在 Python 2 和 Python 3 中的不同：在 Python 2.x zip() 返回的是一個列表。
• 語法
  • zip([iterable, ...])
• 參數說明：
  • iterabl -- 一個或多個迭代器;
• 返回值
  • 返回一個對象。

實例：

a = [1, 2, 3]
b = [4, 5, 6]
c = [4, 5, 6, 7, 8]
zipped = zip(a, b)  # 返回一個對象
print(zipped)
print(list(zipped))  # list() 轉換為列表
print(list(zip(a, c)))  # 元素個數與最短的列表一致
a1, a2 = zip(*zip(a, b))  # 與 zip 相反，zip(*) 可理解為解壓，返回二維矩陣式
print(list(a1))
print(list(a2))

"""
<zip object at 0x000002686FBF41C8>
[(1, 4), (2, 5), (3, 6)]
[(1, 4), (2, 5), (3, 6)]
[1, 2, 3]
[4, 5, 6]
"""

55. compile() 函數

• 描述
  • compile() 函數將一個字符串編譯為字節代碼。
• 語法
  • compile(source, filename, mode[, flags[, dont_inherit]])
• 參數
  • source -- 字符串或者AST（Abstract Syntax Trees）對象。。
  • filename -- 代碼文件名稱，如果不是從文件讀取代碼則傳遞一些可辨認的值。
  • mode -- 指定編譯代碼的種類。可以指定為 exec, eval, single。
  • flags -- 變量作用域，局部命名空間，如果被提供，可以是任何映射對象。。
  • flags和dont_inherit是用來控制編譯源碼時的標志
• 返回值
  • 返回表達式執行結果。

實例：

str = "for i in range(0,10): print(i)"
c = compile(str,'','exec')   # 編譯為字節代碼對象
print(c)
print(exec(c))

str = "3 * 4 + 5"
a = compile(str,'','eval')
print(eval(a))

"""
<code object <module> at 0x000002608A160B70, file "", line 1>
0
1
2
3
4
5
6
7
8
9
None
17
"""

56. globals() 函數

• 描述
  • globals() 函數會以字典類型返回當前位置的全部全局變量。
• 語法
  • globals()
• 參數
  • 無
• 返回值
  • 返回全局變量的字典。

實例：

my_dict = {'name': '菜鳥程序員', 'age': 18, 'gender': True}
print(globals()) # globals 函數返回一個全局變量的字典，包括所有導入的變量。
"""
{'__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000027060226B38>, '__package__': None, '__cached__': None, '__file__': 'D:/projects/學習項目目錄/python相關/python 常用模塊/python 內置函數/56. python-globals() 函數.py', 'my_dict': {'gender': True, 'name': '菜鳥程序員', 'age': 18}, '__name__': '__main__', '__builtins__': <module 'builtins' (built-in)>, '__spec__': None, '__doc__': None}
"""

# 擴展=====================================================================
# 該函數修改全局變量my_dict
def func():
    #
    global my_dict
    my_dict = {'name': '小李子', 'age': 48, 'gender': "不男不女"}

def func1():
    return my_dict

def func2():
    return my_dict

if __name__ == '__main__':
    print(func1())      # 打印修改之前的全局變量
    func()              # 調用func函數修改全局變量
    print(func2())      # 打印修改之后的全局變量

"""
{'age': 18, 'gender': True, 'name': '菜鳥程序員'}
{'age': 48, 'gender': '不男不女', 'name': '小李子'}
"""

57. map() 函數

• 描述
  • map() 會根據提供的函數對指定序列做映射。
  • 第一個參數 function 以參數序列中的每一個元素調用 function 函數，返回包含每次 function 函數返回值的新列表。
• 語法
  • map(function, iterable, ...)
• 參數
  • function -- 函數
  • iterable -- 一個或多個序列
• 返回值
  • Python 2.x 返回列表。
  • Python 3.x 返回迭代器。

實例：

# 計算平方數
def square(x):
    return x ** 2

# 計算列表各個元素的平方
print(map(square, [1, 2, 3, 4, 5]))

# 使用 lambda 匿名函數
print(map(lambda x: x ** 2, [1, 2, 3, 4, 5]))

# 提供了兩個列表，對相同位置的列表數據進行相加
print(map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]))

58. reversed 函數

• 描述
  • reversed 函數返回一個反轉的迭代器。
• 語法
  • reversed(seq)
• 參數
  • seq -- 要轉換的序列，可以是 tuple, string, list 或 range。
• 返回值
  • 返回一個反轉的迭代器。

實例：

# 字符串
seqString = 'Runoob'
print(list(reversed(seqString)))

# 元組
seqTuple = ('R', 'u', 'n', 'o', 'o', 'b')
print(list(reversed(seqTuple)))

# range
seqRange = range(5, 9)
print(list(reversed(seqRange)))

# 列表
seqList = [1, 2, 4, 3, 5]
print(list(reversed(seqList)))

"""
['b', 'o', 'o', 'n', 'u', 'R']
['b', 'o', 'o', 'n', 'u', 'R']
[8, 7, 6, 5]
[5, 3, 4, 2, 1]
"""

59. import() 函數

• 描述
  • import() 函數用於動態加載類和函數 。
  • 如果一個模塊經常變化就可以使用 import() 來動態載入。
• 語法
  • import(name[, globals[, locals[, fromlist[, level]]]])
• 參數說明：
  • name -- 模塊名
• 返回值
  • 返回元組列表。

60. complex() 函數

• 描述
  • complex() 函數用於創建一個值為 real + imag * j 的復數或者轉化一個字符串或數為復數。如果第一個參數為字符串，則不需要指定第二個參數。。
• 語法
  • class complex([real[, imag]])
• 參數說明：
  • real -- int, long, float或字符串；
  • imag -- int, long, float；
• 返回值
  • 返回一個復數。

實例：

print(complex(1, 2))
print(complex(1))  # 數字
print(complex("1"))  # 當做字符串處理
# 注意：這個地方在"+"號兩邊不能有空格，也就是不能寫成"1 + 2j"，應該是"1+2j"，否則會報錯
print(complex("1+2j"))

"""
(1+2j)
(1+0j)
(1+0j)
(1+2j)
"""

61. hasattr() 函數

• 描述
  • hasattr() 函數用於判斷對象是否包含對應的屬性。
• 語法
  • hasattr(object, name)
• 參數
  • object -- 對象。
  • name -- 字符串，屬性名。
• 返回值
  • 如果對象有該屬性返回 True，否則返回 False。

實例：

class Coordinate:
    x = 10
    y = -5
    z = 0


point1 = Coordinate()
print(hasattr(point1, 'x'))
print(hasattr(point1, 'y'))
print(hasattr(point1, 'z'))
print(hasattr(point1, 'no'))  # 沒有該屬性

"""
True
True
True
False
"""

62. 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
"""

63. round() 函數

• 描述
  • round() 方法返回浮點數 x 的四舍五入值，准確的說保留值將保留到離上一位更近的一端（四舍六入）。
  • 精度要求高的，不建議使用該函數。
• 語法
  • 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
"""

64. delattr() 函數

• 描述
  • delattr 函數用於刪除屬性。
  • delattr(x, 'foobar') 相等於 del x.foobar。
• 語法
  • delattr(object, name)
• 參數
  • object -- 對象。
  • name -- 必須是對象的屬性。
• 返回值
  • 無。

實例：

class Coordinate:
    x = 10
    y = -5
    z = 0

point1 = Coordinate()
print('x = ', point1.x)
print('y = ', point1.y)
print('z = ', point1.z)
delattr(Coordinate, 'z')

print('--刪除 z 屬性后--')
print('x = ', point1.x)
print('y = ', point1.y)
# 觸發錯誤
print('z = ', point1.z)

"""
x =  10
y =  -5
z =  0
--刪除 z 屬性后--
x =  10
y =  -5
Traceback (most recent call last):
  File "D:/projects/學習項目目錄/python相關/python 常用模塊/python 內置函數/64. python-delattr() 函數.py", line 16, in <module>
    print('z = ', point1.z)
AttributeError: 'Coordinate' object has no attribute 'z'
"""

65. hash() 函數

• 描述
  • hash() 用於獲取取一個對象（字符串或者數值等）的哈希值。
• 語法
  • hash(object)
• 參數說明：
  • object -- 對象；
• 返回值
  • 返回對象的哈希值。

實例：

print(hash('test'))                 # 字符串
print(hash(1))                      # 數字
print(hash(str([1,2,3])))           # 集合
print(hash(str(sorted({'1':1}))))   # 字典

"""
-1439481417051484773
1
7079383964553032146
9045757919402142588
"""

66. memoryview() 函數

• 描述
  • memoryview() 函數返回給定參數的內存查看對象(Momory view)。
  • 所謂內存查看對象，是指對支持緩沖區協議的數據進行包裝，在不需要復制對象基礎上允許Python代碼訪問。
• 語法
  • memoryview(obj)
• 參數說明：
  • obj -- 對象
• 返回值
  • 返回元組列表。

實例：

v = memoryview(bytearray("abcefg", 'utf-8'))
print(v[1])
print(v[-1])
print(v[1:4])
print(v[1:4].tobytes())

"""
98
103
<memory at 0x000001E3CEBCE1C8>
b'bce'
"""

67. set() 函數

• 描述
  • set() 函數創建一個無序不重復元素集，可進行關系測試，刪除重復數據，還可以計算交集、差集、並集等。
• 語法
  • class set([iterable])
• 參數說明：
  • iterable -- 可迭代對象對象；
• 返回值
• 返回新的集合對象。

實例：

x = set('菜鳥程序員_python')
y = set('Python,py3')
print(x, y)
print(x & y)    # 交集
print(x | y)         # 並集
print(x - y)         # 差集

"""
{'序', '員', 'n', 'o', 'y', '程', 't', '鳥', '_', '菜', 'p', 'h'} {'n', 'P', '3', 'o', 'y', 't', ',', 'p', 'h'}
{'n', 'o', 'y', 't', 'p', 'h'}
{'序', '員', 'n', 'P', '3', 'o', 'y', '程', 't', '鳥', '_', ',', '菜', 'p', 'h'}
{'序', '員', '程', '鳥', '_', '菜'}
"""