天天看點
傳回

Python基礎-進階變量類型                                Python基礎-進階變量類型

                                Python基礎-進階變量類型

1.進階變量類型 

"""
數值型:int float bool compex
非數值型:str list set dict tuple
"""
# 儲存所有人的姓名資訊?
# str = '秦海根張剛'
# 擷取第二個人的姓名
"""------------------ 定義清單 ------------------"""
# 定義清單儲存我們班所有人的姓名
# nameList = ['秦海根','張剛','昌子為','易文']
# print(nameList)

# 清單可以儲存不同的資料類型嗎?
# nameList = ['秦海根','張剛','昌子為','易文',20,1.23,True]
# print(nameList)

"""------------------ 通路清單中某一個元素 ------------------"""
# nameList = ['秦海根','張剛','昌子為','易文']
# 秦海根 張剛 昌子為 易文
# 0     1       2   3
# 通路第三個元素
# 兩種方式操作效果都是一樣的
# ele = nameList[2]
# ele = nameList.__getitem__(2)
# print(ele)

"""------------------ 周遊清單 ------------------"""
nameList = ['秦海根', '張剛', '昌子為', '易文']
# for ele in nameList:
#     print(ele)
# while循環可不可以周遊nameList中所有的元素?
# 1:可以  2:不可以
index = 0
while index < len(nameList):
    # 擷取目前元素
    ele = nameList[index]
    print(ele)
    # 修改循環變量
    index += 1

list清單的增删:

# nameList = ['秦海根', '張剛', '昌子為', '易文']
"""------------------ 清單增加 ------------------"""
# append增加朱烜甫 在末尾追加一條資料
# nameList.append('朱烜甫')
# print(nameList)

# insert添加 在特定的位置添加資料
# nameList.insert(1,'朱烜甫')
# print(nameList)

# nameList = ['秦海根', '張剛', '昌子為', '易文']
# l = ['張三','李四']
# # extend 将另外一個容器中所有的元素添加到目前容器中
# nameList.extend(l)
# print(nameList)


"""------------------ 删除 ------------------"""
nameList = ['秦海根', '張剛', '李四','昌子為','張三', '易文']
# del删除張三 按照索引删除
# del nameList[4]
# print(nameList)

# remove 删除某一個資料
# nameList.remove('李四')
# print(nameList)

# pop(索引)删除 可以傳回删除的資料
# deleteEle = nameList.pop(4)
# print(deleteEle)
# print(nameList)

# pop沒有參數 删除末尾元素
# deleteEle = nameList.pop()
# print(deleteEle)
# print(nameList)

# 清空清單
nameList.clear()
print(nameList)
nameList.append('鳳姐')
print(nameList)

清單其他操作:

"""------------------ 清單修改 ------------------"""
# nameList = ['秦海根', '張剛', '張三','昌子為', '易文']
# 修改張三 為 張四
# nameList[2] = '張四'
# print(nameList)
"""------------------ 清單查詢 ------------------"""
# nameList = ['秦海根', '張剛', '張三','昌子為', '易文']
# 查詢某一個元素
# print(nameList[2])

# index 查詢角标
# 檢視張三的角标
# i = nameList.index('張三')
# print(i)
# del nameList[nameList.index('張三')]
# print(nameList)

# 清單中可以存儲多個相同的元素
# count
# nameList = ['秦海根', '張剛', '張三','昌子為', '易文','張三']
# # 檢視張三在清單中出現多少次
# c = nameList.count('李四')
# print(c)

清單的排序和最值:

"""------------------ 清單的排序 ------------------"""
ageList = [90,10,30,20,50,70]
# 從小到大 升序
# ageList.sort()
# print(ageList)
# 從大到小 降序
# ageList.sort(reverse=True)

# reverse 将清單進行反轉
# ageList.reverse()
# print(ageList)

"""------------------ 最值 ------------------"""
# 最大值
maxValue = max(ageList)
print(maxValue)
minValue = min(ageList)
print(minValue)

冒泡排序:

"""
有一個數字集合[9,8,7,6,5,4,3,2,1],請手動對這個集合正序排序(不要使用sort方法)

"""
# l = [9, 8, 7, 6, 5, 4, 3, 2, 1]
l = [9, 68, 17, 6, 45, 4, 133, 2, 121]
# 不借助于sort函數(幫你實作了算法)
# 1.定義雙層循環
row = 0
while row < len(l) - 1:
    col = 0
    while col<len(l)-1-row:
        # 目前元素:  l[col]
        # 下一個元素:l[col+1]
        # 如果下一個元素比目前元素小 交換
        if l[col]>l[col+1]:
            # 交換
            tmp = l[col]
            l[col]=l[col+1]
            l[col+1] = tmp

        col += 1
    row += 1

print(l)

選擇排序

"""
[9,8,7,6,5,4,3,2,1]
通過選擇排序 升序排序
"""

# l = [9, 8, 7, 6, 5, 4, 3, 2, 1]
l = [95, 88, 7, 46, 15, 4, 113, 452, 21]

row = 0
while row < len(l) - 1:
    # 新的一輪
    # 假定最小值角标 row
    # 實際最小值角标
    index = row
    # 裡層循環
    col = row + 1
    while col < len(l):
        # 對比目前元素和實際最小值角标元素
        if l[col]<l[index]:
            # 修改index
            index = col
        col += 1
    # 一輪結束 如果假定的最小值角标和實際的最小值角标不一緻,交換資料
    if row!=index:
        # 交換資料
        tmp = l[row]
        l[row] = l[index]
        l[index] = tmp
    row += 1

print(l)

嵌套清單:

"""
1班有三位同學:林青霞 狄龍 鄭少秋
2班有2位同學:張曼玉  梁朝偉
"""
# nameList = ['林青霞','狄龍','鄭少秋' ,'張曼玉','梁朝偉']
nameList = [['林青霞','狄龍','鄭少秋'],['張曼玉','梁朝偉']]
# 查詢張曼玉
print(nameList[1][0])
# 修改狄龍  史泰龍
nameList[0][1] = '史泰龍'
print(nameList)

# 知道梁朝偉角标
index = nameList.index(['張曼玉','梁朝偉'])
print(index)

.清單嵌套練習:

"""
需求:
一個學校，有3個辦公室，現在有8位老師等待工位的配置設定，
請編寫程式:
1. 完成随機的配置設定
2. 擷取辦公室資訊 (每個辦公室中的人數，及分别是誰)

分析:
1.3個辦公室(辦公室:清單) 清單嵌套
2.8位老師 清單中儲存
3.周遊老師的清單

4.随機存放到辦公室中
"""
import random
"""------------------ 随機配置設定辦公室 ------------------"""

# # 1.3個辦公室(辦公室:清單) 清單嵌套
# classroomList = [[], [], []]
# # 2.8位老師 清單中儲存
# teachers = ['袁騰飛', '羅永浩', '俞敏洪', '李永樂', '王芳芳', '馬雲', '李彥宏', '馬化騰']
# # 3.周遊老師的清單
# for teacher in teachers:
#     # 随機辦公室的角标 Ctrl+P檢視提示
#     # Ctrl+Alt+V 提取變量
#     index = random.randint(0, 2)
#     # 4.随機存放到辦公室中
#     classroom = classroomList[index]
#
#     classroom.append(teacher)
# print(classroomList)

"""------------------ 每一個辦公室至少有一個人 ------------------"""
# TDD開發
# 1.3個辦公室(辦公室:清單) 清單嵌套
classroomList = [[], [], []]
# 2.8位老師 清單中儲存
teachers = ['袁騰飛', '羅永浩', '俞敏洪', '李永樂', '王芳芳', '馬雲', '李彥宏', '馬化騰']
# 3.每一個辦公室中添加一名老師,周遊辦公室還是老師清單  辦公室:1  老師 2
for classroom in classroomList:
    # 随機擷取一名老師
    # teacher = teachers[random.randint(0,len(teachers)-1)]
    # 添加到辦公室中
    classroom.append(teachers.pop(random.randint(0,len(teachers)-1)))
    # 從老師清單中删除這個元素
    # del teachers[index]
    # teachers.remove(teacher)

# print(classroomList)
# print(teachers)
# 4.把剩下的老師随機配置設定到辦公室中
for teacher in teachers:
    # 随機辦公室的角标 Ctrl+P檢視提示
    # Ctrl+Alt+V 提取變量
    index = random.randint(0, 2)
    # 4.随機存放到辦公室中
    classroom = classroomList[index]

    classroom.append(teacher)

# 清空teachers
teachers.clear()

print(classroomList)
print(teachers)

素數練習:

"""
需求:
列出1~1000内的所有素數

素數:除了1和它本身以外,不能被其它資料整除

2:1 2
3:1 3

5:1 5
7
11
13
17
19

分析:
1.1到1000列舉出來 while for
2.6  2..5 7 2 6 11 2..10
    看目前資料是否能被從2到目前資料小1的資料整除,隻要有一個可以整除,就不是素數
    如果所有都不能整除,就是素數
"""
# 執行效率
# 11 1 11 2..6  7
# 1.1到1000列舉出來 while for
for ele in range(1,1001):
    # 看目前資料是否能被從2到目前資料小1的資料整除,隻要有一個可以整除,就不是素數
    # 如果所有都不能整除,就是素數
    # for a in range(2,ele):# 1000 減少循環次數
    for a in range(2,ele//2+1):# 1000 減少循環次數
        if ele %a==0:
            # 能夠被目前資料整除
            # print('%d 不是素數'%ele)
            break
    else:
        print(ele)

登入驗證練習:

"""
需求:
判斷登入使用者名是否合法(不能用正規表達式)
使用者名是數字字母或者_,需要在3到20位,必須有2個或以上大寫字母,2個或以上小寫字母,3個或以上數字
hhew2383dW_fkf&[email protected]^

分析:
1.數字字母或者_
2.需要在3到20位
3.必須有2個或以上大寫字母
4.2個或以上小寫字母
5.3個或以上數字

步驟:
1.定義三個容器分别存放數字 大寫字母  小寫字母
2.周遊使用者名字元串
3.檢視元素
    1.是否在三個容器中或者是_ 使用者名不滿足
    2.統計數字 小寫字母 大寫字母
4.循環結束之後,判斷數字 字母是否滿足長度需求

"""
name = 'hhew2383dW_fkfE'
# 1.定義三個容器分别存放數字 大寫字母  小寫字母
numberStr = '0123456789'
lowerStr = 'abcdefghijklmnopqrstuvwxyz'
upperStr = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

# 數字個數  小寫字母個數  大寫字母個數
numberCount = 0
lowerCount = 0
upperCount = 0
# 2.周遊使用者名字元串
for ele in name:
    # 1.是否在三個容器中或者是_ 使用者名不滿足
    # if (ele in numberStr) or (ele in lowerStr) or (ele in upperStr) or ele == '_':
    if (ele in numberStr):
        # 數字
        # 2.統計數字 小寫字母 大寫字母
        numberCount += 1
    elif (ele in lowerStr):
        # 小寫字母
        lowerCount += 1
    elif (ele in upperStr):
        # 大寫字母
        upperCount += 1
    elif ele == '_':
        pass
    else:
        # 不合法字元
        print('密碼不合法')
        # 跳出循環
        break
else:
    # 需要在3到20位, 必須有2個或以上大寫字母, 2
    # 個或以上小寫字母, 3
    # 個或以上數字
    if (len(name)>=3 and len(name)<=20) and upperCount>=2 and lowerCount>=2 and numberCount>=3:
        print('密碼合法')
    else:
        print('密碼不合法')

2.元組的定義和特點 

"""------------------ 元組的定義 ------------------"""
# 定義元組 儲存同學姓名
# t = ('秦海根','朱烜甫','張剛')
"""------------------ 元組特點 ------------------"""
# 擷取某一個元素
# ele = t[0]
# print(ele)
# 不能增加元素
# 不能修改元素
# t[0] = '易文'
# 能不能删除元素
# del t[0]

# print(type(t))

"""------------------ 元組元素可以重複的 ------------------"""

"""------------------ 一個元組元組的定義:需要在元組後面加上, ------------------"""
# 空清單
# l = []
# print(type(l))

# 空元組
# t = ()
# print(type(t))

# 定義一個元素的元組
t = ('張曼玉',)
print(type(t))

元組的操作:

t = ('秦海根', '張剛', '朱烜甫', '張剛')

"""------------------ 查詢 ------------------"""
# 查詢某一個元素
# ele = t[0]
# print(ele)

# 擷取元素的索引
# index = t.index('張剛')
# print(index)

# 張剛出現的次數
# print(t.count('張剛'))

for ele in t:
    print(ele)

清單的作用:

# t = ('秦海根', '張剛', '朱烜甫', '張剛')

"""------------------ 元組的自動組包 ------------------"""
# a = 10
# b = 20
# 同時定義了多個變量
# a,b = 10,20

# 自動組包
# a = 10,20
# print(type(a))

"""------------------ 元組的自動解包 ------------------"""
# t = ('秦海根', '張剛', '朱烜甫')
# name1  =t[0]
# name2  =t[1]
# name3  =t[2]
# print(name1,name2,name3)
# 自動解包 保證接收的變量和元組的元素個數保持一緻
# name1,name2,name3 = t
# print(name1,name2,name3)


"""------------------ 資料交換 ------------------"""
a = 10
b = 20
# 交換a和b
# tmp = a
# a = b
# b = tmp
# go語言
a,b = b,a # 組包(20,10) 解包:a:20 b:10

# print(a,b)

"""------------------ 格式化輸出 ------------------"""
# t = (10,20)
# print('第一個資料:%d,第二個資料:%d'%(t[0],t[1]))
# print('第一個資料:%d,第二個資料:%d'%t)

"""------------------ 讓清單不可變 ------------------"""
l = ['秦海根', '張剛', '朱烜甫']
# 可以把清單變成元組 讓它不可修改
t = tuple(l)
print(t)

3.集合 

"""
python資料類型:
數值型:int  float bool compex
進階變量類型: list tuple set dict str
list:容器  可以增删改查 有序 元素不唯一
"""
# l = ['張三','李四','王五','張三']
# print(l)
# t = ('張三','李四','王五','張三')
# print(t)

"""------------------ 建立集合 ------------------"""
# 集合特點:元素唯一的
# s = {'張三','李四','王五','張三'}
# 容器中元素是無序的
# s = {'張三','李四','王五'}

# print(s)
"""------------------ 資料類型 ------------------"""
# s = {'張三','李四','王五'}
# print(type(s))

"""------------------ 集合的周遊 ------------------"""
# s = {'張三','李四','王五'}
# for ele in s:
#     print(ele)

"""------------------ 擷取集合中第二個元素 ------------------"""
# 能  1  不能 2
# ele = s[1]
# print(ele)

"""------------------ 集合中添加元素 ------------------"""
# s = {'張三','李四','王五'}
# l = ['張曼玉','林青霞','趙六']
# # 添加趙六 add
# # s.add('趙六')
# # print(s)
#
# # update添加
# s.update(l)
# print(s)

"""------------------ 删除元素 ------------------"""
s = {'張三','李四','王五'}
# 删除張三 remove 删除元素,如果元素不存在,删除失敗
# s.remove('張三')
# print(s)
# s.remove('林青霞')

# pop 随機删除
# s.pop()
# print(s)

# discard 删除元素 如果元素不存在,不做任何處理
s.discard('林青霞')
print(s)

集合的其它操作:

"""------------------ 子集和超集 ------------------"""
# s1 = {1,2,3}
# s2 = {1,2,3}
# result = s2.issubset(s1)
# print(result)
# result = s1.issuperset(s2)
# print(result)

"""------------------ 并集 ------------------"""
# s1 = {1,2,3}
# s2 = {3,4,5}
# result = s1.union(s2)
# print(result)

"""------------------ 交集 ------------------"""
# s1 = {1,2,3}
# s2 = {3,4,5}
# result = s1.intersection(s2)
# print(result)

"""------------------ 抑或 ------------------"""
s1 = {1,2,3}
s2 = {3,4,5}
# result = s1.symmetric_difference(s2)
# print(result)
s1.symmetric_difference_update(s2) # 更新s1為抑或的結果
print(s1)
# s1.symmetric_difference(s2)
# s1.symmetric_difference_update(s2)  更新s1為異或的結果

集合的作用:

l = ['張三','李四','王五','張三']
# newL = []
# for ele in l:
#     if ele not in newL:
#         newL.append(ele)
#
# print(newL)
# 通過集合對清單去重
# s = set(l)
# print(s)
# l = list(s)
# print(l)

"""------------------ list tuple set互相轉換 ------------------"""
# list轉換成set
# s = set(l)
# print(s)

# list轉換成tuple
t = tuple(l)
# print(t)

# tuple轉換成set
s = set(t)
# print(s)

l = list(s)
print(l)

4.字元串: 

"""------------------ 字元串的定義 ------------------"""
# 字元:a b c d e f 中  過  華
# str = 'hello'
# str = "hello"
# str = 'hel'你好'lo'
# str = 'hel\'你好\'lo'
# # print(str)
#
# str = "hel\"你好\"lo"
# # print(str)
#
# str = "hel'你好'lo"

"""------------------ 擷取某一個元素 ------------------"""
# str = 'hello'
# 擷取第三個元素
# ele = str[2]
# print(ele)

"""------------------ 周遊字元串中每一個元素 ------------------"""
# for ele in str:
#     print(ele)

"""------------------ 原樣輸出字元串 ------------------"""
# str = 'hello'
# str = "hello"
# 省
# 市
# 區
# str = '廣東省\n深圳市\n寶安區'
# kotlin
str = '''廣東省
深圳市
寶安區'''
print(str)

字元串判斷:

# str = 'a'
"""------------------ isalpha  ------------------"""
# result = str.isalpha()
# print(result)

"""------------------ isdecimal ------------------"""
# 字元串非空  并且都是數字  傳回True
# str = ''
# result = str.isdecimal()
# print(result)

"""------------------ islower ------------------"""
# str = '123123a'
# result = str.islower()
# print(result)

"""------------------ isupper ------------------"""
# str = '1203123A'
# result = str.isupper()
# print(result)
"""------------------ startwith ------------------"""
# str = 'helloworld'
# result = str.startswith('w',5)
# print(result)

"""------------------ endwith ------------------"""
# str = 'helloworld'
# result = str.endswith('o',2,5)
# print(result)

查找和替換:

# str = 'helloworld'
"""------------------ find ------------------"""
# find傳回在字元串中的角标  如果不存在傳回-1
# result = str.find('z')
# print(result)
# 首字母對應的角标
# result = str.find('loww')
# 傳回的角标 3 4 5
# print(result)

# 預設找到第一個目前元素 傳回它的角标
# 可以通過start以及end指定查找範圍
# result = str.find('l',5)
# print(result)

"""------------------ rfind:從右邊開始找到第一個結束 ------------------"""
# str = 'helloworld'
# print(str.find('l'))
# print(str.rfind('l',1,5))

"""------------------ index ------------------"""
# 如果不存在 就報錯  存在傳回索引
# str = 'helloworld'
# print(str.index('o'))
# print(str.index('z'))
"""------------------ rindex ------------------"""
# 從右邊開始  如果存在傳回索引  不存在就報錯

"""------------------ replace ------------------"""
str = 'helloworld'
# 如果替換的字元串不存在  不做任何處理
# newStr = str.replace("loww",'up')
# 預設 隻要遇到字元串就替換 可以通過第三個參數指定替換的個數
newStr = str.replace("l",'up',2)
print(str)
print(newStr)

字元串拆分和連接配接:

# str = 'helloworld'
"""------------------ partition ------------------"""
# 根據str将字元串拆分 傳回元組 (str前 str  str後)
# result = str.partition('low')
# print(result)

"""------------------ rpartition ------------------"""
# str = 'helloworldhelloworld'
# result = str.partition('low')
# result = str.rpartition('low')
# print(result)

"""------------------ split ------------------"""
# 對字元串進行分割  傳回清單  不會儲存分割字元串
# str = '張三hello李四hello王五hello趙六'
# result = str.split('hello')
# print(result)

"""------------------ splitlines ------------------"""
# 按\n換行符分割
# str = '廣東省\n深圳市\n寶安區'
# str = '''廣東省
# 深圳市
# 寶安區'''
# result= str.splitlines()
# print(result)

"""------------------ + ------------------"""
# str1 = 'hello'
# str2 = 'world'
# newStr = str1 +str2
# print(newStr)

"""------------------ join ------------------"""
l = ['張三','李四','王五']
str = 'hello'
# 将容器中所有的元素加上目前字元串分割輸出
result = str.join(l)
print(result)

大小寫轉換:

"""------------------ lower ------------------"""
# str = 'HELLOw12312'
# 字元串轉換小寫
# result = str.lower()
# print(result)
"""------------------ upper ------------------"""
str = 'helloA1231中國'
result = str.upper()
print(result)

文本對齊:

"""------------------ ljust ------------------"""
# str = 'hello'
# result = str.ljust(10,'-')
# print(str)
# print(result)
"""------------------ rjust ------------------"""
# str = 'hello'
# result = str.rjust(10,'*')
# print(result)
"""------------------ center ------------------"""
# str = 'hello'
# result = str.center(10,"&")
# print(result)

去空白:

"""------------------ lstrip ------------------"""
# 去除左邊的空白
# str = '   hello   '
# result = str.lstrip()
# print(result)

# str = '----hello   '
# result = str.lstrip('-')
# print(result)

"""------------------ rstrip ------------------"""
# str = '   he**llo****'
# result = str.rstrip('*')
# print(result)

"""------------------ strip ------------------"""
str = '  hello  '
result = str.strip()
print(result)

字元串練習-判斷使用者名和密碼.:

"""
需求:
使用者名和密碼格式校驗程式
要求從鍵盤輸入使用者名和密碼，校驗格式是否符合規則，如果不符合，列印出不符合的原因，并提示重新輸入
使用者名長度6-20，使用者名必須以字母開頭
密碼長度至少6位，不能為純數字，不能有空格

分析:
1.從鍵盤輸入使用者名(需要while循環)
2.長度6-20
3.必須字母開頭

4.輸入密碼(while循環)
5.密碼長度至少6位
6.不能為純數字
7.不能有空格
"""
while True:
    # 1.從鍵盤輸入使用者名(需要while循環)
    name = input('請輸入使用者名:')
    # 2.長度6-20
    if not (len(name) >= 6 and len(name) <= 20):
        print('使用者名必須6到20位')
        continue
    # 3.必須字母開頭 ab A-Z
    # 擷取第一個字母  是否是a-z A-Z a
    ele = name[0]
    if not ele.isalpha():
        print('使用者名第一個必須為字母')
        continue

    # 使用者名滿足
    print('使用者名合法')
    break

# 4.輸入密碼(while循環)
while True:
    pwd = input('請輸入密碼')
    # 5.密碼長度至少6位
    if len(pwd) < 6:
        print('密碼長度至少為6位')
        continue
    # 6.不能為純數字
    if pwd.isdecimal():
        print('密碼不能為純數字')
        continue
    # 7.不能有空格
    # ' 張 三  '
    if ' ' in pwd:
        print('密碼不能有空格')
        continue
    print('密碼合法')
    break

print('開始登入')

5.字典 

"""------------------ 字典的定義 ------------------"""
# d = {'中國':'China','英國':'England','美國':'America',30:'sadf',(10,20,30):'afdsf'}
# key隻能是數字 字元串 元組類型
# d = {'中國':'China','英國':'England','美國':'America',30:'sadf',(10,20,30):'afdsf',1.2323:12,True:243234}

# vlaue可以是任意類型
# d = {'中國':'China','英國':'England','美國':'America',30:[1,2,3],40:{1,2,3}}
# print(d)

"""------------------ key必須是唯一的 ------------------"""
# key必須要唯一  如果出現多個相同的key  後面的會覆寫前面的内容
# key相當于字典的索引
d = {'中國':'China','英國':'England','美國':'America','美國':'USA'}
print(d)

字典的增删改:

"""------------------ 增加 ------------------"""
# d = {'中國':'China','英國':'England','美國':'America'}
# 添加 法國
# 字典[key] = value
# d['法國'] = 'France'
# print(d)

# d.setdefault('法國','France')
# print(d)

"""------------------ 删除 ------------------"""
# d = {'中國':'China','英國':'England','美國':'America'}
# 删除美國 如果鍵不在字典中,會報錯
# del d['法國']
# print(d)

# pop 删除元素 并且傳回删除元素的值 如果删除不存在會報錯
# result = d.pop('法國')

# print(d)
# print(result)


# del d
# del d # 銷毀目前容器  不能再繼續使用
# print(d)

# 清空容器中的資料  還可以繼續使用
# d.clear()
# print(d)
# d['中國'] = 'China'
# print(d)

"""------------------ 修改 ------------------"""
d = {'中國':'China','英國':'England','美國':'America'}
# 修改美國
# d['美國'] = 'USA'
# d.setdefault('美國','USA')
# d['法國'] = 'France'
# print(d)

字典的查詢和周遊:

"""------------------ 字典查詢鍵對應的值 ------------------"""
# d = {'中國':'China','英國':'England','美國':'America'}
# 根據鍵擷取值  如果鍵值對不存在,就會報KeyError
# ele = d['法國']
# print(ele)

# get 擷取鍵對應的值 如果鍵值對不存在,不會報錯 傳回的結果是None
# ele = d.get('英國')
# if ele:
#     print('成功',ele)
# else:
#     print('失敗')
"""------------------ 查詢所有的鍵值對 ------------------"""
# d = {'中國':'China','英國':'England','美國':'America'}
# 查詢所有的鍵 視圖對象
# result = d.keys()
# 視圖轉換成清單
# keyList = list(result)
# print(keyList)

# 擷取所有的values 傳回視圖
# result = d.values()
# 視圖轉換成list
# valuesList = list(result)
# print(valuesList)

# items擷取所有的鍵值對 傳回清單  清單中每一個元素是鍵值對的元組
# result = d.items()
# 視圖轉換成list
# itemsList = list(result)
# print(itemsList)

"""------------------ 周遊 ------------------"""
d = {'中國':'China','英國':'England','美國':'America'}
print(len(d))
# for ele in 周遊 ele代表鍵
# for ele in d:
#     print(ele,d[ele])

# 擷取所有的鍵
# for key in d.keys():
#     print(key)

# 列印所有的values
# for value in d.values():
#     print(value)

# items列印所有的鍵值對
# for ele in d.items():
#     print(ele)

for key,value in d.items():
    print(key,value)

字典的應用場景:

# 描述人 姓名 電話  年紀  性别  動态行為 吃飯 開車 學習
# l = ['張三','12321',40,'男']
# 字典
d = {'name':'張三','phone':'12332','age':40,'性别':'男'}

l = []
l.append(d)
d = {'name':'李四','phone':'12332','age':40,'性别':'男'}
l.append(d)
print(l)

空字典:

# 空清單
l = []
# 空元組
# d = ()
# d = (10,)

# 空字典 {}
# d = {}
# print(type(d))

# 空集合 不能通過{}定義  需要通過set定義
s = set()
print(s)

字典練習:

students = [
    {"name": "阿土",
     "age": 20,
     "gender": True,
     "height": 1.7,
     "weight": 75.0},
    {"name": "小美",
     "age": 19,
     "gender": False,
     "height": 1.6,
     "weight": 45.0},
]
"""------------------ 判斷如下清單中是否存在name為'阿土'的元素 ------------------"""
mark = False
# 周遊清單
for ele in students:
    # 周遊每一個字典的資料
    for key,value in ele.items():
        # name=='阿土'是否存在
        if key=='name' and value=='阿土圖':
            print('找到了資料')
            mark = True
            break

    if mark:
        break
else:
    print('沒有這個資料')

進階變量練習:

"""
需求:
有10個球分别3紅、3藍、4白，現需要将這10個球放入這3個盒子，要求每個盒子至少有一個白球，請用程式實作

一個容器儲存所有的球
分析:
1.定義容器儲存所有的球
2.定義三個盒子 嵌套清單
3.周遊三個盒子,每個盒子添加一個白球

三個容器儲存三種球
1.定義三個容器儲存三種球
2.定義三個盒子 嵌套清單
3.白球配置設定到三個盒子中
4.三個容器合并,再進行配置設定

"""
"""------------------ 一個容器儲存所有的球 ------------------"""
# import random
# # 1.定義容器儲存所有的球
# balls = ['白','藍','白','白','紅','白','藍','藍','紅','紅']
# # 2.定義三個盒子 嵌套清單
# boxes = [[],[],[]]
# # 3.周遊三個盒子,每個盒子添加一個白球
# for box in boxes:
#     # 找到白球
#     # 添加白球
#     box.append(balls.pop(balls.index('白')))
#     # 從balls容器把添加的白球删除掉
# # for box in boxes:
# #     # 找到白球
# #     index = balls.index('白')
# #     ball = balls[index]
# #     # 添加白球
# #     box.append(ball)
# #     # 從balls容器把添加的白球删除掉
# #     balls.remove(ball)
#
# # print(balls)
# # print(boxes)
#
# # 4.剩下的球再進行配置設定
# # 球 1  盒子 2
# for ball in balls:
#     index = random.randint(0,2)
#     # 随機擷取box
#     box = boxes[index]
#     # 添加球到盒子中
#     box.append(ball)
#
# balls.clear()
# print(balls)
# print(boxes)
"""------------------ 三個容器儲存三種球 ------------------"""
import random
# 1.定義三個容器儲存三種球
whiteBalls = ['白','白','白','白']
redBalls = ['紅','紅','紅']
blueBalls = ['藍','藍','藍']

# 2.定義三個盒子 嵌套清單
boxes = [[],[],[]]
# 3.白球配置設定到三個盒子中
for box in boxes:
    # 找到白球
    # 添加白球
    box.append(whiteBalls.pop(whiteBalls.index('白')))
# print(boxes)
# print(whiteBalls)
# 4.三個容器合并,再進行配置設定
l = []
l.extend(whiteBalls)
l.extend(redBalls)
l.extend(blueBalls)

whiteBalls.clear()
redBalls.clear()
blueBalls.clear()

for ball in l:
    index = random.randint(0,2)
    # 随機擷取box
    box = boxes[index]
    # 添加球到盒子中
    box.append(ball)

print(boxes)

6.内置函數: 

# d = {'name':'張三','age':40}
# del d
# print(len(d))
# print(d)

s = {20,50,100}
# print(max(s))
d = {20:60,90:40}
print(max(d))

運算符:

"""------------------ + ------------------"""
str1 = 'hello'
str2 = 'world'
newStr = str1+str2
# result = str1+10
# print(newStr)

# 清單+
# l1 = [1,2,3]
# l2 = [4,5,6]
# newL = l1+l2
# print(newL)

# 元組+
# t1 = (1,2,3)
# t2 = (4,5,6)
# newT = t1+t2
# print(newT)

"""------------------ * ------------------"""
str = 'hello'
# print(str * 5)

# l = [1,2,3]
# print(l * 5)

# t = (1,2,3)
# print(t * 5)


"""------------------ in 和not in ------------------"""
# 字典中in和not in判斷的是key是否在字典中

"""------------------ 比較 ------------------"""
# str1 = 'hemlo'
# str2 = 'hfllo'
# print(str1 < str2)

l1 = [1,2,3]
l2 = [1]
print(l1 > l2)

切片:

"""
切片:字元串 清單  元組
"""

# str = '中華人民共和國歡迎您'
"""------------------ 切片的簡單使用 ------------------"""
# 擷取前三個文字
# newStr = str[0:3:1]
# print(newStr)

# 步長:預設1 省略預設步長
# newStr = str[0:3:]
# 不寫步長 可以省略步長前面的:
# newStr = str[0:3]
# 索引從0開始 可以省略開始索引,不能省略:
# newStr = str[:3]

#  後5個元素
# newStr = str[5:10]
# 結束索引是在最後 可以省略結束索引
# newStr = str[5:]
# print(newStr)


"""------------------ 步長 ------------------"""
# str = '中華人民共和國歡迎您'
# newStr = str[0:8:3]
# print(newStr)

倒序索引:

"""
需求:
str = "中華人名共和國歡迎您"
把字元串中從第一個到倒數第二個(不包含)列印出來

"""
str = "中華人名共和國歡迎您"
# 把字元串中從第一個到倒數第二個(不包含)列印出來
# newStr = str[:8]
# 開始位置 正序  結束位置:倒序
newStr = str[:-2]
print(newStr)

負數步長:

"""
需求:
str = "中華人名共和國歡迎您"
把從角标為2到7(包含)倒序列印出來

"""
str = "中華人名共和國歡迎您"
# 把從角标為2到7(包含)倒序列印出來
# 歡國和共名人
# newStr = str[2:8:-1]
# 步長為負  索引也應該逆序索引
newStr = str[7:1:-1]

print(newStr)

進階變量練習:

"""

需求:
完成字元串的逆序以及統計
設計一個程式，要求隻能輸入長度低于31的字元串，否則提示使用者重新輸入
列印如下内容:
您輸入的字元串: ...
長度: ...
逆序後為: ...
字元統計結果: ...(afsfdsf)  a:1  f:3 s:2 d:1
zhangsanlisi

分析
1.輸入字元串(while循環)
2.字元串長度小于31位,否則提示重新輸入
3.您輸入的字元串: ...
4.長度: ...
5.逆序後為: ...  (切片)
6.字元統計結果: ...(afsfdsf)  a:1  f:3 s:2 d:1
 safljdsfl  s:2 a:1 f:2 l:2 j:1 d:1
"""
while True:
    # 1.輸入字元串(while循環)
    str = input('請輸入字元串')
    # 2.字元串長度小于31位,否則提示重新輸入
    if len(str)>=31:
        print('不能超過31位,請重新輸入')
        continue
    # 跳出循環
    break
print('輸入正确')
# 3.您輸入的字元串: ...
print('您輸入的字元串:%s'%str)
# 4.長度: ...
print('長度:%d'%len(str))
# 5.逆序後為: ...  (切片)
# hello  olleh
newStr = str[::-1]
# print('逆序後為:%s'%newStr)
# 6.字元統計結果: ...(afsfadsf)  a:1  f:3 s:2 d:1
# 1.字典 儲存結果  {}
resultDict = {}
# 2. 如果字典中沒有這個a  a添加進去 {'a':1}
for ele in str:
    # 3.字典中有a 将元素個數+1
    if ele not in resultDict:
        resultDict[ele] = 1
    else:
        resultDict[ele] += 1
print('字元統計結果:{}'.format(resultDict))

7.清單推導式 

# l = []
# for ele in range(1,10001):
#     if ele % 2 ==0:
#         l.append(ele)
#
# print(l)
"""------------------ 推導式 ------------------"""
# 需要定義清單儲存從1到10000的資料,怎麼做?
# l = [ele for ele in range(1,10001)]
# print(l)

"""------------------ 2.建立包含1到10000中所有偶數的清單 ------------------"""
# l = [ele for ele in range(1, 10001) if ele % 2 == 0]
# print(l)

"""------------------ 3.建立嵌套清單(清單每個元素是兩個元素的元組) ------------------"""
# l = [(1,2),(2,4),(3,6)..,(100,200)]
# l = [(ele,ele*2)for ele in range(1,101)]
# print(l)

"""------------------ 4.建立嵌套清單(清單每個元素是三個元素的元組) ------------------"""
# l = [(1,2,3),(2,4,6),(3,6,9)..,(100,200,300)]
# l = [(ele,ele*2,ele*3)for ele in range(1,101)]
# print(l)

推導式練習:

"""
需求:
請寫出一段 Python 代碼實作分組一個 list 裡面的元素
比如 [1,2,3,...100]變成 [[1,2,3],[4,5,6]....[100]]

"""
l = [ele for ele in range(1,101)]
# print(l)
# [[1,2,3],[4,5,6]....[100]]
# [[ele,ele+1,ele+2]for ele in l if ]
# 切片 0:3  3:6 6:9
newL = [l[ele:ele+3]for ele in range(0,len(l)) if ele %3==0]
print(newL)
# str = 'hello'
# print(str[3:10])

集合和字典推導式:

"""------------------ 集合推導式 ------------------"""
# s = {ele for ele in range(1,101)}
# print(s)

"""------------------ 字典的推導式 ------------------"""
# 需求:
# 定義{"1":1,"2":4,'3':9,..,'10':100}這樣的字典
# d = {str(ele):ele**2 for ele in range(1,11)}
# print(d)

l1 = [ele for ele in range(1,11)]
l2 = [ele for ele in range(21,31)]
# {1:21,2:22,3:23}
# 錯誤寫法
# d = {key:value for key in l1 for value in l2}
# 正确寫法 l1和l2打包一起 一起周遊 zip
d = {key:value for key,value in zip(l1,l2)}
print(d)
Python
上一篇: 改變顔色透明度
下一篇: 16進制顔色透明度

繼續閱讀