一、集合

1、集合的簡介

• 集合表現形式為set 集合和串列非常相似
• 不同點
  • 集合只能存盤不可變物件
  • 集合中存盤的物件是無序的
• 集合不能出現重復元素
• 使用{}來創建集合
• 可以通過set()來將序列和字典轉換成集合

總結一下：
集合的最大特點是：集合里邊的元素是不可重復的并且集合內的元素還是無序的，
集合與字典的創建都是用花括號——{}，但是集合是沒有key與value鍵值對的，
一般情況下集合常用的兩個場景是：

• 去重（如：串列去重）；
• 關系測驗（如：取交集、取并集、取差集等）

• 代碼展示講解

#  使用{}來創建集合
set1 = {2, 'ab'}
print(set1)
# 運行結果 》》》{2, 'ab'}

# 創建空集合， 需要用到set()
s = {}  
print(type(s))
# 運行結果 》》》<class 'dict'>

s = set()
print(type(s))
# 運行結果 》》》<class 'set'>

# 集合只能存盤不可變物件
set1 = {2, 'ab', [1, 2, 3]}
print(set1, type(set1))
# 上述代碼一運行就會報錯，因為集合只能存盤不可變物件，串列是可變物件

# 集合中存盤的物件是無序的
set2 = {6, 8, 9}
print(set2)
# 運行結果 》》》{8, 9, 6}

# 集合不能出現重復元素 通過這一特性，我們可以來做一個資料去重的效果
set3 = {1, 2, 3, 4, 1, 2, 3, 4}
print(set3)
# 運行結果 》》》{1, 2, 3, 4}

list1 = [1, 1, 2, 3, 3]     # 串列通過set()轉換成集合去重
s4 = set(list1)
print(s4)
# 運行結果 》》》{1, 2, 3}

2、集合的使用

集合的一些方法與串列都是通用的，但是還是要看一下的哦,方法，雖然差不多，但是練習一下總沒壞處哦，

• len() 使用len()來獲取集合中元素的數量

set1 = {2, 'ab'}
print(len(set1))
# 運行結果 》》》2

• add()像集合中添加元素

s = set()
s.add(1)
s.add('a')
print(s)
# 運行結果 》》》{1, 'a'}

• update()將一個集合中的元素添加到另一個集合當中

s1 = {1, 2, 3}
s2 = {'a', 'b', 'c'}
s1.update(s2)
print(s1)
# 運行結果 》》》{'c', 1, 2, 3, 'a', 'b'}

• pop()隨機洗掉集合中的一個元素一般是洗掉開始一個元素

s1 = {'c', 1, 2, 3, 'a', 'b'}
s1.pop()
print(s1)
# 運行結果 》》》{2, 3, 1, 'a', 'b'}
s1.pop()
print(s1)
# 運行結果 》》》{3, 1, 'a', 'b'}

• remove() 洗掉集合中指定的元素

s1 = {1, 2, 3, 'a', 'b','c'}
s1.remove('a')
print(s1)
# 運行結果 》》》{1, 2, 3, 'c', 'b'}

• clear() 清空集合

s1 = { 1, 2, 3, 'a', 'b','c'}
s1.clear()
print(s1)
# 運行結果 》》》set()

3、集合的運算

• 代碼演示

s1 = {1, 2, 3, 7, 8}
s2 = {4, 5, 6, 7, 8}

#  交集運算（&）
s3 = s1 & s2
print(s3)
# 運行結果 》》》{8, 7}

# | 并集運算
s4 = s1 | s2
print(s4)
# 運行結果 》》》{1, 2, 3, 4, 5, 6, 7, 8}

# - 差集運算
s5 = s1 - s2
print(s5)
# 運行結果 》》》{1, 2, 3}

# ^ 亦或集
s6 = s1 ^ s2
print(s6)
# 運行結果 》》》{1, 2, 3, 4, 5, 6}

讓我們先了解一下子集，真子集和超集，真超集的基本概念

• 子集，真子集：
  兩者的包含范圍不同，子集比真子集范圍大，子集是包括本身的元素的集合，真子集是除本身的元素的集合，
  子集：集合A范圍大于或等于集合B，B是A的子集；
真子集：集合A范圍比B大，B是A的真子集，
  如果集合A的任意一個元素都是集合B的元素（任意a∈A則a∈B），那么集合A稱為集合B的子集，記為A?B或B?A，讀作“集合A包含于集合B”或集合B包含集合A”，
  如果集合A是B的子集，且A≠B，即B中至少有一個元素不屬于A，那么A就是B的真子集，
• 超集，真超集
  超級和真超集與子集和真子集對應，
  如果一個集合S2中的每一個元素都在集合S1中，且集合S1中可能包含S2中沒有的元素，則集合S1就是S2的一個超集， S1是S2的超集，若S1中一定有S2中沒有的元素，則S1是S2的真超集，S2是S1的真子集，

簡單點來說：
如果集合B是集合A的子集，那么集合A就是集合B的超集
如果集合B是集合A的真子集，那么集合A就是集合B的真超集
集合B是集合A的真子集，那么集合B就一定是集合A的子集,如果B∈A那么B?A
但集合B是集合A的子集，集合B不一定是集合A的真子集
超集的結論與子集差不多

# <= 檢驗是否為子集
set1 = {4, 5, 6, 7, 8}
set2 = {4, 5, 6, 7, 8}
set7 = set1 <= set2
print(set7)
# 運行結果 》》》True

# < 檢驗是否為真子集
set1 = {4, 5, 6, 7, 8}
set2 = {4, 5, 6, 7, 8}
set8 = set1 < set2
print(set8)
# 運行結果 》》》False

# < 檢驗是否為超集
set1 = {4, 5, 6, 7, 8}
set2 = {4, 5, 6, 7, 8}
set9 = set1 > set2
print(set9)
# 運行結果 》》》False

# < 檢驗是否為真超集
set1 = {4, 5, 6, 7, 8}
set2 = {4, 5, 6, 7, 8}
set10 = set1 >= set2
print(set10)
# 運行結果 》》》True

二、可變型別和不可變型別

結合之前博客中,我們已經講完所有python中的基本型別,這里我們還要總結一下所有的資料型別，

• 可變型別（mutable）：串列，字典（key是不可變），集合
  里面的元素改變了，但是他的id還是不會變化
• 不可變型別（unmutable）：int，float，字串，元組
  里面的元素改變了，那么他的id也就發生了變化

這里的可變不可變，從物件記憶體地址方向來說，是指記憶體中的值（value）是否可以被改變，
python所宣告的變數都以物件的形式存在，存在于機器的固定記憶體之中，

• 代碼實操

# 字串的更改
str1 = 'abc'
print(id(str1))
# 運行結果 》》》2480058428696

str2 = str1.replace('a', 'b')   # 將字串中的a換成b
print(id(str2))
# 運行結果 》》》2480059406632

a = 'abc'
print(id(a))
# 運行結果 》》》2480058428696

a = 'bcd'
print(id(a))
# 運行結果 》》》2480059406352

# 串列更改
list1 = [1, 2, 3, 4]
print(id(list1))
# 運行結果 》》》2480058553160

list1.remove(4)   # 洗掉4這個元素
print(id(list1))
# 運行結果 》》》2480058553160

? 通過上述代碼，我們就可以很直觀的看到ID的變換，不可變型別的字串，只要更改，ID就會隨之改變，可變型別的串列，不管怎么更改，還是原先的ID

三、函式（上）

• 函式分為3個章節，本章為上，下期博客鏈接

1、函式簡介

語法：

def 函式名([形參1,形參2,形參3....]):
    代碼塊
	pass
xxx(實參)

• 函式可以用來保存一些可以執行的代碼，在你需要的時候可以對這些代碼進行多次的使用
• 函式保存的代碼不會立即執行，需要呼叫函式的時候代碼才會執行
• 函式名必須符合識別符號的規范(可以包含字母、數字、下劃線但是不能以數字開頭)
• 函式物件 fun
• 函式呼叫 fun()

2、函式的引數

• 形參(形式引數) 定義形參就相當于在函式內部宣告了變數，但是并不是賦值
• 實參(實際引數)指定了形參，那么在呼叫函式時必須傳遞實參，實參將會賦值給對應的形參，簡單來說有幾個形參就要有幾個實參

# 需求： 定義一個函式求任意2個數的和
# 在函式中定義形參，相當于在函式內宣告了變數
def fun(a, b):   # a, b  是形參  就是形式上的引數  ，你如果定義了形參，那么就必須在呼叫的時候傳遞實參
    print(a + b)

fun(1, 2)  # 1, 2 是實參，也就是實際引數

3、函式的傳遞方式

3.1、設定默認值

引數可以再設定形參的時候，直接給他設定一個默認值, 如果實參沒有傳遞引數，那么直接使用默認值，如果實參傳遞了，那么就是用實參

def fun(a, b, c=20):
    print(a, b, c)

fun(1, 2)
# 運行結果 》》》1 2 20

fun(1, 2, 3)
# 運行結果 》》》1 2 3

3.2、位置傳參

位置傳參 就是講對應位置上的實參賦予給對應位置上的形參

def fun1(a, b, c):
    print(a, b, c)

fun1(1, 2, 3)
# 運行結果 》》》1 2 3

3.3、關鍵字傳參

關鍵字傳參 可以不按照定義的順序去進行引數的傳遞，根據引數名去傳遞實參

def fun2(a, b, c):
    print(a, b, c)

fun2(b=1, a=2, c=3)
# 運行結果 》》》2 1 3

3.4、混合使用

混合使用 位置傳參必須放到關鍵字傳參的前面

def fun2(a, b, c):
    print(a, b, c)

fun2(2, c=1, b=2)
# 運行結果 》》》2 2 1

4、不定長引數

不定長引數在一個函式中不管是還是**都只能存在一個，而且必須要在**之前
(*args , **kwargs)

4.1、*args引數

• *不定長引數必須放到位置引數后面, 放到關鍵字引數的前面

# 需求： 求任意個數的和
def fn(*a):
    r = 0
    for i in a:
        r += i
    print(r)

fn(1, 2, 3, 4)
# 運行結果 》》》10

# 如需第一位為1	，最后一位為5，則
def fn(b, *a, c):
    r = b + c
    for i in a:
        r += i
    print(r)

fn(1, 2, 3, 4, c=5)
# 運行結果 》》》15

4.2、**kwargs引數

• **kwargs不定長引數必須放到位置引數和關鍵字引數的后面

def fn1(*args, a, **kwargs):
    print(args)
    print(a)
    print(kwargs)

fn1(2,1, a=1, b=2, c=3, d=4, e=5)
# 運行結果 》》》
(2, 1)
1
{'b': 2, 'c': 3, 'd': 4, 'e': 5}

5、引數傳遞型別

• 任意型別的引數都是可以傳遞的
  包括：int(整型)；float(浮點型)；string(字串)；bool(布林值)；None(空值)；list(串列)；tuple(元組)；dict(字典)；set(集合)
• 這里還要說一下不同型別的引數傳遞后的改變

# 不可變型別 int
def fun2(a):  # a = b = 1
    a = 10
    print(a)

b = 1
fun2(b)
print(b)
# 運行結果 》》》
10
1

# 可變型別 list
def fun3(a):  # a = b = [1, 2, 3]
    a[2] = 10
    print(a)

b = [1, 2, 3]
fun3(b)
print(b)
# 運行結果 》》》
[1, 2, 10]
[1, 2, 10]

對于不可變型別來說，將其作為實參傳遞給形參，并通過函式，對其本身的值不產生變化，但是可變型別的值會隨之改變，此處需注意，不清楚可以自行嘗試其他幾種基本資料型別，

6、引數拆包

def fun(a, b, c):
    print(a, b, c)

# 元組的拆包
t = (4, 5, 6)
fun(t[0], t[1], t[2])    # 通過索引取值為實參
# 運行結果 》》》4 5 6
fun(*t)					 # args不定長引數取值
# 運行結果 》》》4 5 6

# 字典的拆包
t = {'a': 1, 'b': 2, 'c': 3}		# kargs不到場引數取值
fun(**t)

字典的拆包需要注意key，key值必須與形參定義的一樣，比如形參是abc，key也必須是abc

四、課后作業

1. 列印名片程式:輸入姓名，電話號碼，性別，最后列印出來名片

• 控制姓名長度為6-20
• 電話號碼長度11
• 性別只能允許輸入男或女
• 每一樣資訊不允許為空

# 第一種方法
while True:
    a = input("請輸入姓名:")
    if len(a) > 20 or len(a) < 6:
        print("姓名長度在20到6之間")
    else:
        break
while True:
    b = input("請輸入手機號碼:")
    if len(b) == 11 and b.isdigit() == True:
        break
    else:
        print("手機號只能是11位")
while True:
    c = input("請輸入性別:")
    c1 = ['男', '女']
    if c not in c1:
        print("性別只能是男或女")
    else:
        break
def fun(e,f,g):
    print("\t名片")
    print(f"姓名:\t{e}")
    print(f"手機號碼:\t{f}")
    print(f"性別:\t{g}")

print("》》》》開始列印名片》》》》")
fun(a,b,c)

• 運行結果如下：
  

• 知識點運用及撰寫思路：

此方法為最后輸出的部分撰寫了一個函式，開始先進行3個輸入回圈判斷，都沒問題后，將得到的3個值作為函式fun的實參，然后進行輸出，此題運用的while回圈，if判斷，以及運算子的使用都在往期博客中提過，此處就不過多贅述，

# 第二種方法
def name():
    while True:
        a = input("請輸入姓名:")
        if len(a) > 20 or len(a) < 6:
            print("姓名長度在20到6之間")
        else:
            return a
def tel():
    while True:
        b = input("請輸入手機號碼:")
        if len(b) == 11 and b.isdigit() == True:
            return b
        else:
            print("手機號只能是11位")
def sex():
    while True:
        c = input("請輸入性別:")
        c1 = ['男', '女']
        if c not in c1:
            print("性別只能是男或女")
        else:
            return c
print(f"》》》》開始列印名片》》》》\n\t名片\n姓名：\t{name()}\n電話：\t{tel()}\n性別：\t{sex()}")

• 運行結果如下：
  

• 知識點運用及撰寫思路：

此方法與第一題的方法有相似之處，不同的地方就是將3個輸入判斷分別寫成3個函式，最后直接輸出，在輸出中呼叫函式，重要的就是那個思路，相同就容易了，知識點運用與第一種方法一樣，

2. 使用函式求前20個斐波那契數列斐波那契數列：1,1,2,3,5,8,13,21…即: 起始兩項均為1，此后的項分別為前兩項之和

# 方法一
def sum(a,b):
    return a+b
list1 = []
for i in range(20):
    if i <= 1:
        list1.append(1)
    else:
        list1.append(sum(list1[i-2],list1[i-1]))
else:
    print(list1)

• 運行結果如下：

[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]

• 知識點運用及撰寫思路：

方法一就是創建一個sum的函式，將傳入的引數相加然后return出和的值，再創建一個空串列，通過for回圈，將i作為串列的索引，之后每次回圈都添加一個數，數為前2個數的和，
有人問我這樣還是看不懂怎么辦，那么我們來看圖:

這樣寫應該就很清晰了吧，可以再往后推幾步哦，

# 方法二 遞回
def fun(n):
    return 1 if n <= 1 else fun(n - 1) + fun(n - 2)
for i in range(20):
    print(fun(i), end=' ')

• 運行結果如下：

1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 

• 知識點運用及撰寫思路：

這里我們直接上圖：
這種方法是遞回法，原先函式里面的是if條件陳述句，但是改成三元運算子也可以，只不過看上去更簡便，此方法每次回圈都呼叫一次fun函式，并將回傳值輸出，最終得到效果

# 方法三 遞推
def fun1(n):
    a, b = 0, 1
    for i in range(n + 1):
        a, b = b, a + b
    return a
for j in range(20):
    print(fun1(i), end=' ')

• 運行結果如下：

1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 

• 知識點運用及撰寫思路：

i = 0 》fun1(0) 》n=0 》開始回圈
a=1,b=1  》回圈結束
return a 》fun(0)=1
i = 1 》fun1(1) 》n=1 》開始回圈
a=1,b=1
a=1,b=2  》回圈結束
return a 》fun(1)=1
i = 2 》fun1(2) 》n=2 》開始回圈
a=1,b=1
a=1,b=2
a=2,b=3  》回圈結束
return a 》fun(2)=2
i = 3 》fun1(3) 》n=3 》開始回圈
a=1,b=1
a=1,b=2
a=2,b=3
a=3,b=5  》回圈結束
return a 》fun(3)=3
i = 4 》fun1(4) 》n=4 》開始回圈
a=1,b=1
a=1,b=2
a=2,b=3
a=3,b=5
a=5,b=8》回圈結束
return a 》fun(4)=5
》》》以此類推》》》

以上為遞推的程序，這個程序看上去就挺煩的把，對，雖然這種方法也能得到最終結果，但是每次回圈，都要從開始算，會造成極大的運算性能浪費，所以看看就好，不建議使用哦，

# 方法四 生成器
def fun2(n):
    a, b = 0, 1
    for i in range(0, n):
        a, b = b, a + b
        yield a
for i in fun2(20):
    print(i, end=' ')

• 運行結果如下：

1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 

• 知識點運用及撰寫思路：

首先用到yield生成器，我們肯定得知道他是做什么的，再次我就直接參考一篇大神的文章，感覺寫的特別詳細，博客鏈接，方法四與方法三有很多相似，方法四加上了yield生成器，減少了許多不必要的運算，定義一個函式生成器fun2()，之間用fun2()進行遍歷：

3. 撰寫一段代碼，定義一個函式求1-100之間所有整數的和，并呼叫該函式列印出結果

# 方法一
def sum1():
    sum = 0
    for i in range(101):
        sum+=i
    return sum
print(sum1())

# 方法二
def sum2(a):
    sum = 0
    for i in range(a+1):
        sum += i
    return sum
print(sum2(100))

• 運行結果如下：
  

• 知識點運用及撰寫思路：

這題其實很容易，雖然不用函式也可以寫，但題意要求，所以還是用一下函式，第一種方法沒有給函式引數，直接將所有的都寫在函式里面，然后直接print輸出就得到了值，
第二種方法是定義了個引數，定義引數的好處就在于如果我們要想求一個其他的數的值，只用改一個引數就可以了，
定義引數的作用在一些簡單的程式中體現不是特別明顯，但是如果是在一個很長的程式中，定義引數就會減少很多作業量，

旺仔注：

古人說:“萬般皆下品,惟有讀書高，”說粗淺一點，人是能讀書著書的動物，故讀書是劃分人與禽獸的界限，也是劃分文明人與野蠻人的界限，讀現代的書就是與同時代的人作精神上的溝通交談，讀古人的書可以承受古圣先賢的精神遺產，　　
人不是天生就明白很多東西，但是先人會給后人留下知識寫在書上，人們通過讀書對世界、對自己、對大自然有了更深刻的了解，然后在這個基礎上繼續探索,從而讓人類更好的活著，　
csdn真的是一個非常好的平臺，集結了各類大佬，大神，許多不懂的知識，看一下他們的文章，真的是豁然開朗，多看看大佬的文章，像大佬們努力！！！( ?? ω ?? )?