解構賦值

a, b, c = [1, 2, 3]  # 列表解構
print(a, b, c)
a, b, c = (1, 2, 3,)  # 元組解構
print(a, b, c)
a, b, c = {1, 2, 3}  # 集合解構
print(a, b, c)
a, b, c = range(1, 4)  # 範圍解構
print(a, b, c)
a, b, c = "hel"  # 字串解構
print(a, b, c)
a, b = {"name": "lisi", "age": 34}  # 字典解構
print(a, b)
 

將可迭代物件依次賦值給左邊變數

函式定義

def my_sum(num1, num2):
    '''
    calculate two num sum
    :param num1:
    :param num2:
    :return:
    '''
    return num1 + num2


print(my_sum(2, 5))  # 位置對應
print(my_sum(num2=5, num1=2))  # 引數名稱對應
print(my_sum(3, num2=8))  # 混合

使用def關鍵字宣告函式，3引號宣告函式文件註釋，沒有return語句會返回None，多個返回值會包裝成元組。實參和形參必須一一對應，不能多也不能少。位置對應必須在名稱對應之前。

預設引數

def my_sum(num1, num2, num3=0):
    '''
    calculate three num sum
    :param num1: 
    :param num2: 
    :param num3: 
    :return: 
    '''
    return num1 + num2 + num3


print(my_sum(6, 5))
print(my_sum(6, 5, 2))

預設引數在宣告函式時定義，傳參使用引數值，不傳使用預設值。預設引數必須為不可變物件。

可變引數

def my_sum(*nums):
    sum = 0
    for num in nums:
        sum += num
    return sum


print(my_sum(1, 2, 3, 4, 6))  # 可變引數
print(my_sum(*[1, 2, 3, 4, 5]))  # 解構賦值
 

python會將多個引數包裝成元組傳遞給函式。

關鍵字引數

def person(name, age, **kwargs):
    return {"name": name, "age": age, **kwargs}

print(person("lisi", 23, city="shanghai", job="java"))
print(person(**{"name": "lisi", "age": 23, "city": "shanghai", "job": "java"}))  # 解構賦值

python會將多個關鍵字引數包裝成字典傳遞給函式。

區域性變數和全域性變數

NAME = "lisi"  # 全域性變數
AGE = 23  # 全域性變數

def change_name():
    global NAME  # 關聯全域性變數
    NAME = "lisi2"  # 修改全域性變數
    AGE = 34  # 區域性變數
    print(NAME, AGE)

change_name()

print(NAME, AGE)

使用global修改全域性變數，先找區域性變數，找不到再找全域性變數。

NAME = "lisi"  # 全域性變數

def change_name():
    NAME = "xioaming" 

    def change_name2():
        nonlocal NAME  #關聯上一級作用域變數
        NAME = "xioali" # 修改
        print(NAME)

    change_name2()
    print(NAME)

change_name()
print(NAME)

使用nonlocal修改上一級作用域變數

遞迴函式

def my_sum(*nums):
    if len(nums) == 0:
        return 0
    return my_sum(*nums[0:-1]) + nums[-1]


print(my_sum(1, 2, 3, 6))
print(my_sum(1))
print(my_sum())

遞迴就是直接或間接的呼叫自己。

閉包

def create_counter(num=0):
    def inc():
        nonlocal num
        num += 1
        return num

    return inc


counter = create_counter()
print(counter())  # 1
print(counter())  # 2
counter = create_counter(5)
print(counter())  # 6
print(counter())  # 7

python中，只有函式內部或函式內部的子函式才可以讀取或修改區域性變數，閉包就是可以讀取其他函式內部變數的函式，簡單理解為函式內部的函式，它是將函式內部和函式外部連線的橋樑。

lambda函式

my_sum = lambda x, y: x + y
print(my_sum(3, 4))

python的lambda函式的函式體只能是表示式，不能是多條語句。

內建函式

print(abs(-12))  # 求絕對值
print(min(3, 5, 7, -3, 4))  # 最小值
print(max(4, 5, 6, 7))  # 最大值
print(sum([1, 2, 3], 0))  # 求和
print(pow(3, 2))  # 求冪次方
print(round(3.4568, 2))  # 四捨五入
print(divmod(9, 2))  # 求商和餘數
print(int("123"))  # 轉為int型別
print(float("123"))  # 轉為float型別
print(bool("1"))  # 轉為bool型別 0或空為False
print(bin(123))  # 轉為2進位制字串
print(oct(123))  # 轉為8進位制字串
print(hex(123))  # 轉為16進位制字串
print(ord("A"))  # 獲取對應的10進位制整數
print(chr(65))  # 獲取對應的字元
print(eval('2**3'))  # 執行python語句
exec('print(2**3)')  # 執行python語句

f = open("test.txt", "r")  # 開啟檔案
print(f.readlines())

print(str([1, 2, 3]))  # 轉為字串形式


class Person():
    pass


p = Person()
setattr(p, "len", 4)  # 設定屬性值
print(getattr(p, "len"))  # 獲取屬性值
print(hasattr(p, "len"))  # 是否包含屬性
delattr(p, "len")  # 刪除屬性
print(all([1, 2, 3, 0]))  # 可迭代物件是否全部為True
print(any([1, 2, 3, 0]))  # 可迭代物件是否有一個為True
print(dir())  # 獲取當前模組的屬性列表
it = iter([1, 2, 3])  # 獲取列表的迭代器物件
while True:
    try:
        print(next(it))  # 獲取迭代器的下一個物件，沒有丟擲異常
    except StopIteration:
        break
sli = slice(0, 2, 1)  # 建立切片物件
print([1, 2, 3, 4, 5][sli])
print(id("lisi"))  # 獲取物件的記憶體地址
print(sorted([1, 3, 6, 4]))  # 對可迭代物件排序
print(list(reversed([1, 3, 6, 4])))  # 翻轉可迭代物件
print(ascii([1, 2, 3]))  # 獲取物件的字串表示
for (i, v) in enumerate(["lisi", "zhangsan"]):  # 獲取可迭代物件的索引序列，包含索引和資料
    print(i, v)
print(isinstance("", (str, list)))  # 物件是否為類的例項
print(issubclass(bool, int))  # 是否為父類


class Father:
    def sing(self):
        print("father sing")


class Child(Father):
    def sing(self):
        super().sing()  # 呼叫父類方法
        print("child sing")


print(Child().sing())
print(bytearray("lisi", encoding="utf-8"))  # 建立位元組陣列
print(bytes("lisi", encoding="utf-8"))  # 建立不可變位元組陣列
print(dict(name="lisi", age=23))  # 建立一個字典
print(tuple([1, 2, 3]))  # 建立元組
print(list((1, 2, 3,)))  # 建立列表
print(set([1, 2, 3]))  # 建立集合
print(frozenset([1, 2, 3]))  # 建立不可變集合
print(range(5))  # 建立範圍物件
print(list(filter(lambda x: len(x) >= 4, ["java", "go", "python"])))  # 過濾可迭代物件
print("abc")  # 列印輸出函式
print(callable(Child))  # 是否是可呼叫的
print("name:{name},age:{age}".format(name="lisi", age=23))  # 字串格式化
print(len("hello"))  # 獲取物件長度
print(type(""))  # 獲取物件型別
print(vars(p))  # 獲取物件的屬性
print(hash("abxc"))  # 獲取物件的雜湊值
print(list(map(lambda x: x ** 2, [1, 2, 3])))  # 對映
print(list(zip([1, 2, 3], [4, 5, 6])))  # 將可迭代物件打包成元組
print(help('str'))  # 檢視函式或模組的詳細資訊
print(input("please input num: "))  # 接受標準輸入