python入門day02數據類型

時間 2019-12-09

標籤 python 入門 day02 day 數據類型欄目 Python 简体版

原文原文鏈接

字符串：數據類型的學習python

#======================================基本使用======================================
#一、用途

#二、定義方式

#三、經常使用操做+內置的方法

#======================================該類型總結====================================
#存一個值or存多個值
    
#有序or無序

#可變or不可變（一、可變：值變，id不變。可變==不可hash 二、不可變：值變，id就變。不可變==可hash）

1、字符串索引

s2 = 'abc123嘿嘿'

# 正向索引，從0開始編號
print(s2[3])
# 反向索引，從-1開始編號
print(s2[-3])

2、字符串切片

切片：(獲取子字符串):

語法[開始索引:結束索引:步長]
i) 步長省略，默認爲1
ii) 起始索引省略，默認爲從頭開始
iii) 結束索引省略，默認到最後結束

# 顧頭不顧尾[6:8]，從索引6截取到索引8以前
ss2 = 'hello world'
new_ss2 = ss2[6:8:]
print(new_ss2)
>wo
# 結束索引:-1表明截取到最後一位以前，省略表明截取到最後
# 開始索引省略表明從頭開始截取
print(ss2[6:-1:])
>worl
# 截取一次只截取一個字符，可是截取後邁2步截取下一個hlowrd
print(ss2[::2])
>hlowrd
# 打印'dlrow olleh'，翻轉字符串
# 步長爲負數時，從後往前截取(開始索引建議使用負值)
print(ss2[-1::-1])
>dlrow olleh

#做用：名字，性別，國籍，地址等描述信息

#定義：在單引號\雙引號\三引號內，由一串字符組成
name='egon'

#優先掌握的操做：
#一、按索引取值(正向取+反向取) ：只能取
#二、切片(顧頭不顧尾，步長)
#三、長度len
#四、成員運算in和not in
#五、移除空白strip
#六、切分split
#七、循環

須要掌握：linux

#一、strip,lstrip,rstrip
#二、lower,upper
#三、startswith,endswith
#四、format的三種玩法
#五、split,rsplit
#六、join
#七、replace
#八、isdigit

# 1.獲取字符串長度
s3 = 'abcdef'
print(len(s3))  # len(s) 獲取s的字符長度
>6

# 2.成員運算
#語法：in | not in：子字符串是否在父字符串中
s5 = 'abc123嘿嘿'
# in | not in: 子字符串 in 父字符串
print('abcd' in s5)
print('abc' not in s5)
print('呵呵' not in s5)
>False
>False
>True
# not in要同步出現
# print('>>>', '呵呵' not in s5)
# 3.首尾去白 #語法：strip()
print(' hello wolrd  '.strip())
>hello wolrd
print('===login success==='.strip('='))
>login success
# 4.拆分 
#語法：split(拆分規則, 拆分次數) 

print('D:\\python36\\python3.exe'.split('\\', 1))
>['D:', 'python36\\python3.exe']
s4 = "D:\\pathon36\\python3.exe"
# 需求：1.獲取python的安裝盤符；2.獲取python的執行文件
s4_list = s4.split('\\')  # 拆分：就是將字符串轉化爲列表
print(s4_list)
>['D:', 'pathon36', 'python3.exe']
print(s4_list[0])
>D:
print(s4_list[-1])
>python3.exe
# 完成以上需求還要保證拆分獲得的結果儘量短
## 注：拆分的依據，拆分的次數
s4_list = s4.split('\\', 1)
print(s4_list[0])

#strip,lstrip,rstrip
name='*egon**'
print(name.strip('*')) # *所有去掉
print(name.lstrip('*')) # 去掉左邊的* leftstrip=lstrip
print(name.rstrip('*')) # 去掉右邊的* rightstrip=rstrip

#lower,upper
name='simoN'
print(name.lower()) # name內容所有小寫
print(name.upper()) # name內容所有大寫

#startswith,endswith
name='alex_SB'
print(name.endswith('SB'))      #以SB結尾爲真：True
print(name.startswith('alex'))  #以alex開頭爲真：True

#format的三種玩法
res='{} {} {}'.format('egon',18,'male')
>egon 18 male
res='{1} {0} {1}'.format('egon',18,'male')
>18 egon 18
res='{name} {age}{sex}'.format(sex='male',name='egon',age=18)
>egon 18 male

#split
name='root:x:0:0::/root:/bin/bash'
print(name.split(':')) #默認分隔符爲空格
name='C:/a/b/c/d.txt' #只想拿到頂級目錄
print(name.split('/',1))

name='a|b|c'
print(name.rsplit('|',1)) #從右開始切分
>['a|b', 'c']

#join
tag=' '
print(tag.join(['egon','say','hello','world'])) #可迭代對象必須都是字符串
>egon say hello world

#replace
name='alex say :i have one tesla,my name is alex'
print(name.replace('alex','SB',1))
>SB say :i have one tesla,my name is alex

#isdigit：能夠判斷bytes和unicode類型,是最經常使用的用於於判斷字符是否爲"數字"的方法
age=input('>>: ')
print(age.isdigit())

各種參數例子

參數

#  rsplit：從右開始拆分
s4 = "D:\\pathon36\\python3.exe"
s4_list = s4.rsplit('\\', 1)
print(s4_list)

#  startswith | endswith：以某某開頭 | 結尾：返回值爲bool類型
print("http://www.baidu.com".startswith('https://'))
print("http://www.baidu.com".endswith('com'))  # 思考：自學正則：re

#  format：格式化
print('name:%s，age:%s' % ('owen', 18))
# 佔位與實際數據要進行個數與位置的匹配
print('name:{}，age:{}'.format('Liuxx', 8))
# 指定位置要數據：{0}要0號位數據
print('name:{0}，age:{1}, name:{0}'.format('Linoo', 58))
# 指定名字要數據
print('name:{usr}，age:{age}, name:{usr}'.format(age=58, usr='Linoo'))

#  replace：替換
# 語法：replace(oldS, newS, count)
s6 = 'abcabcabc'
newS6 = s6.replace('a', 'A', 2)
print(newS6)

補充

參數補充

# 1. find | rfind：查找子字符串索引，無結果返回-1
s1 = 'abcabc'
print(s1.rfind('ab'))  # 返回第一次查詢到的（目標字符串首位）正向索引

# 2. index | rindex：查找子字符串索引，無結果拋出異常
print(s1.index('cb'))  # 崩潰

# # 3. count：計算子字符串個數
print(s1.count('abc'))
#
# 4. center | ljust | rjust | zfill：按位填充,通常在進制時使用，不足填0
# 語法：center(所佔位數, '填充符號')
# 使用： 調用者.center(參數)
print("華麗分割線".center(30, '-'))
print("華麗分割線".ljust(30, '-'))
print("1240".zfill(5))
print("9010".zfill(5))
print("59000".zfill(5))
#
# # 5. expandtabs：規定\t所佔空格數
print('hello\tworld'.expandtabs(8))
#
# # 6. captialize | title | swapcase：首字母大寫 | 單詞首字母大寫 | 大小寫反轉
print("hello world".capitalize())
print("hello world".title())
print("hello WORLD".swapcase())
#
# # 7. isdigit | isdecimal | isnumeric：數字判斷
s7 = b'123'  # isdigit來判斷是否能夠轉換爲數字
print(b'123'.isdigit())
# 三個方法均有
print(u'123'.isdigit())
print(u'123'.isdecimal())
print(u'123'.isnumeric())

print('肆'.isdigit())
print('肆'.isdecimal())
print('肆'.isnumeric())  # 能夠判斷中文數字
print('Ⅳ'.isdigit())
print('Ⅳ'.isdecimal())  # 不用管
print('Ⅳ'.isnumeric())  # 能夠判斷羅馬數字
#
# # 8. isalnum | isalpha：是否由字母數字組成 | 由字母組成
print('abc123_'.isalnum())
print('abc'.isalpha())
#
# # 9. isidentifier：是否爲合法變量名
print('>>>', 'a_123'.isidentifier())
#
# # 10. islower | isupper：是否全小 | 大寫
print("aBc".islower())
print("ABC".isupper())
#
# # 11. isspace：是不是空白字符
print(" ".isspace())
#
# 12. istitle：是否爲單詞首字母大寫格式
print("Hello World".istitle())

3、字符串循環

s = 'hello world'

# 字符串循環（遍歷）
i = 0
while i < len(s):
    print(s[i])
    i += 1

# 迭代
for c in s:
    print(c)
# 總結：
# 1.循環迭代s，一次在s中取出一個字符，存放到c中
# 2.下一次取出會覆蓋上一次c
# 3.當s中全部字符取出後，循環自動中止

# 哪些變量是能夠被迭代的：str、list、dict、tuple、set、range生產的對象
print(range(5))
# 從什麼數字開始，到什麼數字前結束，步長是多少
for i in range(1, 5, 2):
    print(i)

for i in range(10, 16):
    print(i)

# 寫代碼,有以下變量,請按照要求實現每一個功能 （共6分，每小題各0.5分）
name = " aleX"
# 1)    移除 name 變量對應的值兩邊的空格,並輸出處理結果
# 2)    判斷 name 變量對應的值是否以 "al" 開頭,並輸出結果 
# 3)    判斷 name 變量對應的值是否以 "X" 結尾,並輸出結果 
# 4)    將 name 變量對應的值中的 「l」 替換爲 「p」,並輸出結果
# 5)    將 name 變量對應的值根據 「l」 分割,並輸出結果。
# 6)    將 name 變量對應的值變大寫,並輸出結果 
# 7)    將 name 變量對應的值變小寫,並輸出結果 
# 8)    請輸出 name 變量對應的值的第 2 個字符
# 9)    請輸出 name 變量對應的值的前 3 個字符
# 10)    請輸出 name 變量對應的值的後 2 個字符
# 11)    請輸出 name 變量對應的值中 「e」 所在索引位置? 
# 12)    獲取子序列,去掉最後一個字符。如: oldboy 則獲取 oldbo。

練習題目

name = " aleX"

# 1)
print(name.strip())  # >aleX
# 2)
print(name.startswith("al")) # >False
# 3)
print(name.endswith("X")) # >True
# 4)
print(name.replace('l','p')) #> apeX
#5)
print(name.split("l")) # >[' a', 'eX']
# 6)
print(name.lower()) # > alex
# 7)
print(name.upper()) # > ALEX
# 8)
print(name[2]) #> l
# 9)
print(name[:3]) # > al
# 10)
print(name[3:]) # >eX
print(name[-2:]) #步長爲正數時從前日後取值，爲負數時從後往前取值
#11)
print(name.index("e")) # >3
#12)
print(name[:4]) #> ale
print(name[:-1]) #> ale

練習結果

4、可變和不可變類型

# 數字
# 1.只能存放一個值
# 2.數字爲不可變類型: 值改變了id必定改變（值一旦肯定，就不能再修改）

a = 10
print(id(a))
# a = 11
a += 1
print(id(a))

# 字符串
# 1.只能存放一個值
# 2.字符串爲不可變類型
s = '123'
print(id(s))
s = s * 2
print(id(s))


# 列表: 爲可變類型，在id不改變的狀況下，還能夠修改內部數據
l = [1, 2, 3]
print(id(l))
# print(l[0])
l[0] = 10
print(id(l))
l.append(20)
print(id(l))

5、列表

介紹：
#做用：多個裝備，多個愛好，多門課程，多個女友等

#定義：[]內能夠有多個任意類型的值，逗號分隔
my_girl_friends=['alex','wupeiqi','yuanhao',4,5] #本質my_girl_friends=list([...])
或
l=list('abc')

l1 = [1, 3.14, 5 + 4j, True, 'abc', [[1]]]
print(l1)

l2 = list([1, 3.14, 5 + 4j, True, 'abc', [[1]]])
print(l2)

#優先掌握的操做： #一、按索引存取值(正向存取+反向存取)：便可存也能夠取  #二、切片(顧頭不顧尾，步長) #三、長度 #四、成員運算in和not in #五、追加 #六、刪除 #七、循環

#ps:反向步長
l=[1,2,3,4,5,6]

#正向步長
l[0:3:1] #[1, 2, 3]
#反向步長
l[2::-1] #[3, 2, 1]
#列表翻轉
l[::-1] #[6, 5, 4, 3, 2, 1]

1.字符串轉換爲列表git

# 將字符串轉換爲列表: 字符串方法
l3 = 'hello world'.split(' ')
print(l3)

# 將列表轉換爲字符串: 字符串方法，調用方法的字符串爲拼接字符串的依據
# 將列表中的全部數據，從前日後，安裝拼接符進行拼接
newStr = '@'.join(l3)  # hello@world
print(newStr)

列表轉換爲字符串：

l = ["hi","hello","world"]
print(" ".join(l))

2.列表切片api

list3 = [1, 2, 3, 4, 5]
print(list3[1:-1:2])  # [2, 4]

3.列表的增刪改查bash

#1. 刪除普通變量
a = 10
del a
print(a)

#2. 增：append(obj) 在末尾添加對象
list4 = []
print(id(list4)) #id:35656200
list4.append(1)
list4.append(5)
list4.append(2)
print(list4)       #[1, 5, 2]
print(id(list4)) # id:35656200

#3. 插入(對應位置插入數據)
list4.insert(0, 10)
print(list4)    #[10, 1, 5, 2]
print(id(list4)) #35656200

#4. 刪
# 刪除指定索引
del list4[0]
print(list4) # [1, 5, 2]
# 刪除指定對象
list4.remove(5)
print(list4) #[1, 2]

#5. 改：
list4[0] = 10000
print(list4) #[10000, 2]

#6. 查
print(list4[1]) # 2

#7.長度
print(list4)
list4.append(88888)
print(len(list4))  # list4: [10000, 2, 88888] 共3個值

#8. 成員運算
print(2 in list4)  #True

# 9. 循環：迭代
list7 = [1, 3, 5, 7, 0]

for obj in list7:
    print(obj, end=',')
# 1,3,5,7,0,

# 需求：打印1,3,5,7,0
sss = ""
for obj in list7:
    sss += str(obj) + ','  # obj是int類型，不能直接作字符串拼接，轉化成字符串
print('>>>', sss[:-1])
# >>> 1,3,5,7,0

增刪改查

# 翻轉
a = [1, 3, 2]
a.reverse()
print(a) # [2, 3, 1]

# 排序:
# 前提：1.數據之間所有具備可比性；2：數據要統一類型
b = [1, 3, 2, 5, 4]
b.sort()
print(b) # [1, 2, 3, 4, 5]
# 倒序
b.reverse()
print(b) # [4, 5, 2, 3, 1]
b.sort(reverse=True)
print(b) # [5, 4, 3, 2, 1]

''' ***
1. copy：複製
2. clear：清空
3. count：計算成員個數
4. extend：添加多個值(參數爲可迭代對象)
5. index：查找索引
'''
x = [1, 3, 5, 3]
y = x
print(x, id(x)) # [1, 3, 5, 3] 32117256
print(y, id(y)) # [1, 3, 5, 3] 32117256

z = x.copy()
print(z, id(z)) # [1, 3, 5, 3] 32091976
#copy複製,id會變,x值被修改，但copy出來的z卻不會
x[0] = 10000
print(x[0]) # 10000
print(y[0]) # 10000
print(z[0]) # 1
#清空列表
z.clear()
print(z) # []
#統計成員個數
# # [10000, 3, 5, 3]
print(x.count(3))  # 2  3在列表中的總數量
#extend添加多個值
list1 = []
list1.extend('abc')
print(list1) # ['a', 'b', 'c']
#
list2 = ['abc', 'xyz']
list1.extend(list2)
print(list1) # ['a', 'b', 'c', 'abc', 'xyz']

參數補充

max(list)：返回列表元素最大值
min(list)：返回列表元素最小值
list(seq)：將元組轉換爲列表 app

總結：
1. 列表中能夠存放多個值
2. 列表爲可變類型：id不變的狀況下，能夠發生值變化
3. 列表爲有序存儲結構：能夠經過索引取值

"""
#zip dict index list enumerate（取下標） len
s爲字符串
s.isalnum() 全部字符都是數字或者字母
s.isalpha() 全部字符都是字母
s.isdigit() 全部字符都是數字
s.islower() 全部字符都是小寫
s.isupper() 全部字符都是大寫
s.istitle() 全部單詞都是首字母大寫，像標題
s.isspace() 全部字符都是空白字符、\t、\n、\r
"""
"""
name = "my \tname is {name} and I am {year} yearold"
print(name.capitalize())  #首字母大寫
print(name.count("o"))  #統計出現o的次數
print(name.center(10,"-"))
print(name.endswith("on"))  #判斷以什麼結尾，True
print(name.expandtabs(tabsize=10))  #轉換空格，不多用
print(name.find("name")) #列表中以什麼開頭
print(name[name.find("name"):]) #字符串切片
print(name.format(name='alex',year=23))
print(name.format_map( {'name':'alex','year':12} ))
print(name.isalnum())   #isalnum判斷是否是阿拉伯數字，不能有特殊字符
print(name.isalpha())  #純由於字符
print('1'.isdecimal())  #
print('11'.isdigit()) #是否是整數
print('_1A'.isidentifier()) #判斷是否是一個合法的標識符或合法的變量名
print('11'.isnumeric())  #是否是一個整數字
print(' '.isspace()) #是否是空格
print('My Name Is'.istitle())  #每一個首字母是否大寫
print('My Name Is'.isprintable())  #pty、drive文件
print('MY'.isupper()) #是否是都是大寫
print('+'.join(['1','2','3']))  #列表轉換爲字符串
print(name.ljust(50,'*'))  #末尾補齊50個字符
print(name.rjust(50,'*')) #開頭補齊
print('Simon'.lower()) #轉換爲小寫
print('Simon'.upper())  #轉換爲大寫
print('\nSimon'.lstrip()) #從左邊去掉空格和回車
print('\nSimon\n'.rstrip())  #從右邊去掉空格和回車
print('  Simon\n'.strip())  #2變空格和換行都去掉
p = str.maketrans("abcdefmn",'1234567$')
print("simon xiong".translate(p))  #將內容進行對應轉換，感受加密的時候也許可使用
print('simon'.replace('s','S'))  #小寫s替換爲大寫
print('simons'.replace('s','S',1)) #只替換1個
print("simon xiong".rfind('n')) #找到最後邊值的下標
print("simon".rsplit())
print("simon".split('m')) #將字符串按空格進行分隔
print('1=2\n+3+4'.splitlines())  #識別不一樣系統的換行
print('Simon Xiong'.swapcase()) #大小寫轉換
print('Simon Xiong'.title()) #首字母大寫
print("Simon xiong".zfill(50))  #16進制補位

參數詳細解釋

練習：ide

# 1. 有列表data=['alex',49,[1970,3,18]]，分別取出列表中的名字，年齡，出生的年，月，日賦值給不一樣的變量
data=['alex',49,[1970,3,18]]
name = data[0]
age = data[1]
born1 = [str(i) for i in data[2]]
born = '-'.join(born1)

print(name,age,born)

# 2. 用列表模擬隊列
#隊列的特色：先進先出、後進後出

#用列表insert、pop模擬進隊出隊:
>>> l = []
>>> l.insert(0,'s1')
>>> l.insert(0,'s2')
>>> l.insert(0,'s3')
>>> l
['s3', 's2', 's1']
>>> l.pop()
's1'
>>> l
['s3', 's2']
>>> l.pop()
's2'
>>> l
['s3']
>>> l.pop()
's3'
>>> l
[]

# 用列表append、pop模擬進隊出隊
>>> l
[]
>>> l.append('s4')
>>> l.append('s5')
>>> l.append('s6')
>>> l
['s4', 's5', 's6']
>>> l.pop(0)
's4'
>>> l
['s5', 's6']
>>> l.pop(0)
's5'
>>> l
['s6']
>>> l.pop(0)
's6'
>>> l
[]

# 3. 用列表模擬堆棧
# 堆棧特色：先進後出、後進先出
# 用列表insert、pop方法模擬進棧出棧:
>>> l = []
>>> l.insert(0,'a1')
>>> l.insert(0,'a2')
>>> l.insert(0,'a3')
>>> l
['a3', 'a2', 'a1']
>>> l.pop()
'a1'
>>> l
['a3', 'a2']
>>> l.pop()
'a2'
>>> l
['a3']
>>> l.pop()
'a3'
>>> l
[]

# 用列表append、pop方法模式進棧出棧:
>>> l = []
>>> l.append('a1')
>>> l.append('a2')
>>> l.append('a3')
>>> l
['a1', 'a2', 'a3']
>>> l.pop()
'a3'
>>> l
['a1', 'a2']
>>> l.pop()
'a2'
>>> l
['a1']
>>> l.pop()
'a1'
>>> l
[]

# 4. 有以下列表，請按照年齡排序（涉及到匿名函數）
l=[
    {'name':'alex','age':84},
    {'name':'oldboy','age':73},
    {'name':'egon','age':18},
]
# 答案：
l.sort(key=lambda item:item['age'])
print(l)

練習

6、元組

# 元組：能夠理解爲，不可變的列表
# 1.元組的長度不能夠變化
# 2.元組中的值能夠變化，可是變化實際上是存放了可變的數據類型，元組本質沒有改變

#做用：存多個值，對比列表來講，元組不可變（是能夠當作字典的key的），主要是用來讀

#定義：與列表類型比，只不過[]換成()
age=(11,22,33,44,55)本質age=tuple((11,22,33,44,55))

#優先掌握的操做：
#一、按索引取值(正向取+反向取)：只能取   
#二、切片(顧頭不顧尾，步長)
#三、長度
#四、成員運算in和not in
#五、循環

# 1、定義
t1 = (1, 2, 3, 4, 5)
print(t1) # (1, 2, 3, 4, 5)

t2 = tuple((1, 2, 3, 4, 5))
print(t2) # (1, 2, 3, 4, 5)

# 空元組
t3 = ()
print(t3) #()

t4 = tuple()
print(t4) # ()

# 含義一個值的元組
t5 = (1, )
print(t5)

# 元組取值
t7 = (5, 3, 2, 1, 6)
print(t7[0])
print(t7[-1])

# 不可改變: 但一個列表須要對其進行限制，讓其沒法發生改變，能夠將其轉化爲元組
list1 = [1, 2, 3]
tuple1 = tuple(list1)
print(tuple1)  # (1, 2, 3)
# 若是從新想更改，能夠轉化回去
list2 = list(tuple1)
print(list2)  # [1, 2, 3]

# 注：元組中存放了可變類型數據，能夠發生形式上的值改變，本質值未發生改變
t1 = (1, 'abc', [10, 'xyz'])
print(t1, id(t1))
>(1, 'abc', [10, 'xyz']) 41766776

# 成立：元組中列表值發生改變，列表自身id不變，因此元組中的中未發生改變
t1[2][1] = 'XYZ'
print(t1, id(t1))
>(1, 'abc', [10, 'XYZ']) 41766776

總結：
1. 能夠存放多個值：t = (1, 2, 3)
2. 爲不可變類型
3. 有序存儲：按索引取值

練習：函數

#簡單購物車,要求以下：
# 實現打印商品詳細信息，用戶輸入商品名和購買個數，則將商品名，價格，購買個數加入購物列表，若是輸入爲空或其餘非法輸入則要求用戶從新輸入　　

msg_dic={
'appale':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}

shop_cart=[]

while True:
    for item, value in msg_dic.items():
        print(item, value)
        #print('name:{name} price:{price}'.format(price=item,name=key))
    product_name = input('please input product name:').strip()
    if not product_name or product_name not in msg_dic:continue
    count = input('please input amount:').strip()
    if not count.isdigit():continue
    shop_cart.append((product_name,msg_dic[product_name],count))
    print(shop_cart)
    #break

練習

7、字典

# 1、聲明
dic1 = {'name': 'Owen', 'age': 18}
dic1 = {'name': None, 'age': None}
print(dic1)
>{'name': None, 'age': None}

dic2 = dict([('name', 'Egon'), ('age', 58)])
print(dic2)
>{'name': 'Egon', 'age': 58}

dic3 = dict(name='Zero', age=18)
print(dic3)
>{'name': 'Zero', 'age': 18}

dic4 = {}.fromkeys(['name', 'age'], None)
print(dic4)
>{'name': None, 'age': None}

# 2、get：有默認值的取值
dic = {'name': 'Owen', 'age': 18}
print(dic.get('name', "該key不存在"))  # 存在就會打印實際的值
>Owen
print(dic.get('name123', "該key不存在"))  # 不存在，未規定默認值，打印None，規定就打印規定的默認值
>該key不存在

# 3、字典的key能夠爲惟一不可變類型，value能夠爲任意類型
# 緣由：字典的key是取值的惟一途徑，因此必定要保證惟一性(一旦肯定值，就不會再更改)
d1 = {}.fromkeys([1, 3.14, (1,), '123', True], None)
print(d1)
>{1: None, 3.14: None, (1,): None, '123': None}

# 4、增刪改查
dic = {'name': 'Hou', 'age': 3}
print(dic)
# 增
dic['gender'] = '哇塞'
print(dic)
# 刪
del dic['age']
print(dic)
# 改
dic['name'] = 'DaHou'
print(dic)
# 查
print(dic['name'])

#字典的循環

# 多值更新
dic = {'name': 'Engo', 'salary': 100}
dic.update({'name': "Egon", 'age': 58, 'gender': '未知'})
print(dic)

# 類列表類型，不能直接經過index取值，但能夠被for循環迭代取值
print(dic.keys())
print(dic.values())
print(dic.items())

for k in dic.keys():
    print(k, ":", dic[k])
print('------------------------------------')
for v in dic.values():
    print(v)

print('------------------------------------')
for k, v in dic.items():  # *****
    print(k, v)

a, b, c = [1, 2, 3]
print(c)
a, b, _ = (1, 2, 3)
print(a)

# 嵌套: JSON
dic = {
    'students': [
        {
            'name': 'Bob',
            'id': 1,
            'gender': '男'
        },
        {
            'name': 'Tom',
            'id': 2,
            'gender': '女'
        }
    ],
    'teachers': []
}

stus = dic['students']  # list
tom_stu = stus[1]  # dic
name = tom_stu['name']
print(name)
print(dic['students'][1]['name'])
print('======================')
for k, v in dic.items():
    # 只遍歷學生
    if k == 'students':
        for stu in v:
            for s_k, s_v in stu.items():
                print(s_k, ":", s_v)
            print('--------------')
    if k == 'teachers':
        pass

字典循環

# 總結：
# 1. 字典能夠存放多個值
# 2. 字典爲可變類型
# 3. 字典是無序存儲，用key進行取值

練習1

# 1 有以下值集合 [11,22,33,44,55,66,77,88,99,90...]，將全部大於 66 的值保存至字典的第一個key中，將小於 66 的值保存至第二個key的值中

# 即： {'k1': 大於66的全部值, 'k2': 小於66的全部值}

a={'k1':[],'k2':[]}
c=[11,22,33,44,55,66,77,88,99,90]
for i in c:
    if i>66:
        a['k1'].append(i)
    else:
        a['k2'].append(i)
print(a)

# 2 統計s='hello alex alex say hello sb sb'中每一個單詞的個數
#結果如：{'hello': 2, 'alex': 2, 'say': 1, 'sb': 2}

s='hello alex alex say hello sb sb'
s1 = s.split()
dic = {}

for i in s1:
    if i in dic:
        dic[i] += 1
    else:
        dic[i]=1
print(dic)

練習2

s='hello alex alex say hello sb sb'
dic={}
words=s.split()
print(words)
for word in words: #word='alex'
    dic[word]=s.count(word)
    print(dic)


#利用setdefault解決重複賦值
'''
setdefault的功能
1：key存在，則不賦值，key不存在則設置默認值
2：key存在，返回的是key對應的已有的值，key不存在，返回的則是要設置的默認值
d={}
print(d.setdefault('a',1)) #返回1

d={'a':2222}
print(d.setdefault('a',1)) #返回2222
'''
s='hello alex alex say hello sb sb'
dic={}
words=s.split()
for word in words: #word='alex'
    dic.setdefault(word,s.count(word))
    print(dic)



#利用集合，去掉重複，減小循環次數
s='hello alex alex say hello sb sb'
dic={}
words=s.split()
words_set=set(words)
for word in words_set:
    dic[word]=s.count(word)
    print(dic)

其餘作法（重點看setdefault的用法）

練習2的其餘解法

8、集合

#做用：去重，關係運算，

#定義：
            知識點回顧
            可變類型是不可hash類型
            不可變類型是可hash類型

#定義集合:
            集合：能夠包含多個元素，用逗號分割，
            集合的元素遵循三個原則：
             1：每一個元素必須是不可變類型(可hash，可做爲字典的key)
             2:沒有重複的元素
             3：無序

注意集合的目的是將不一樣的值存放到一塊兒，不一樣的集合間用來作關係運算，無需糾結於集合中單個值
 

#優先掌握的操做：
#一、長度len
#二、成員運算in和not in

#三、|合集
#四、&交集
#五、-差集
#六、^對稱差集
#七、==
#八、父集：>,>= 
#九、子集：<,<=

# 有以下兩個集合，pythons是報名python課程的學員名字集合，linuxs是報名linux課程的學員名字集合
pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}
linuxs={'wupeiqi','oldboy','gangdan'}
# 求出即報名python又報名linux課程的學員名字集合
print(pythons & linuxs)
# 求出全部報名的學生名字集合
print(pythons | linuxs)
# 求出只報名python課程的學員名字
print(pythons - linuxs)
# 求出沒有同時這兩門課程的學員名字集合
print(pythons ^ linuxs)

練習

做業學習

#做業一: 三級菜單
#要求:
打印省、市、縣三級菜單
可返回上一級
可隨時退出程序

menue = {
    '湖北省':{
        '黃岡市':{
            '羅田縣':{
                '大別山':'板栗',
                '薄刀峯':'風景區',
                '鏨字石村':'柿子',
            },
            '鏨字石':{
                '楊梅衝':'渡橋',
                '夏家鋪':'水庫',
                '雷家壪':'道觀',
            },
        },
        '黃梅':{},
        '黃石':{},
    },
    '上海市':{
        '徐彙區':{
            '徐家彙':{
                '徐家彙': '美羅城',
                '漕河涇': '開發區',
                '華山路': '交通大學',
            },
            '浦東區':{
                '陸家嘴':'金融區',
                '淮海中路':'酒吧',
                '人民廣場':'南京東路步行街',
            },
        },
    },
    '山東省':{
        '青島市':{
            '嶗山區':{
                '風景':'嶗山風景區',
                '道觀':'嶗山太清宮',
                '海邊':'海邊浴場',
            },
        },
    },
}


tag = True
while tag:
    for key in menue:
        print(key)
    choice = input("請輸入省份,退出輸入q>>").strip()
    if choice == "q": break
    if not choice or choice not in menue:continue

    #二級菜單
    while tag:
        menue2 = menue[choice]
        for key2 in menue2:
            print(key2)
        choice_2 = input("請輸入市,退出輸入q,返回上級菜單輸入b>>").strip()
        if choice_2 == "b":
           # print("返回上一層")
            break
        if choice_2 == "q":
            tag = False
            #continue
        if choice_2 not in menue2:continue

        #三級菜單
        while tag:
            menue3 =menue2[choice_2]
            for key3 in menue3:
                print(key3)
            choice_3 = input("請輸入縣,退出輸入q,返回上級菜單輸入b>>").strip()
            if choice_3 == "b":
                # print("返回上一層")
                break
            if choice_3 == "q":
                tag = False
            if not choice_3 or choice_3 not in menue3:continue

            #四級詳細菜單
            while tag:
                menue4 = menue3[choice_3]
                for key4,value in menue4.items():
                    print(key4,value)
                choice_4 = input("請看列出風景,退出輸入q,返回上級菜單輸入b>>").strip()
                if choice_4 == "b":
                    break
                if choice_4 == "q":
                    tag = False
                if not choice_4 or choice_4 not in menue4: continue

做業一

# 做業一優化答案

#part1（初步實現）：可以一層一層進入
layers = [menue, ]

while True:
    current_layer = layers[-1]
    for key in current_layer:
        print(key)

    choice = input('>>: ').strip()

    if choice not in current_layer: continue

    layers.append(current_layer[choice])

#part2（改進）：加上退出機制
layers=[menue,]

while True:
    if len(layers) == 0: break
    current_layer=layers[-1]
    for key in current_layer:
        print(key)

    choice=input('>>: ').strip()

    if choice == 'b':
        layers.pop(-1)
        continue
    if choice == 'q':break

    if choice not in current_layer:continue

    layers.append(current_layer[choice])

做業一改進

9、數據類型總結

按存儲空間的佔用分（從低到高）優化

數字
字符串
集合：無序，即無序存索引相關信息
元組：有序，須要存索引相關信息，不可變
列表：有序，須要存索引相關信息，可變，須要處理數據的增刪改
字典：無序，須要存key與value映射的相關信息，可變，須要處理數據的增刪改

按存值個數區分：

標量／原子類型	數字，字符串
容器類型	列表，元組，字典

按可變不可變區分：

可變	列表，字典
不可變	數字，字符串，元組

按訪問順序區分：

直接訪問	數字
順序訪問（序列類型）	字符串，列表，元組
key值訪問（映射類型）	字典

# 1.統計元組中全部數據屬於字符串串的個數，提示：isinstance()
# 數據：t1 = (1, 2, '3', '4', 5, '6')
# 結果：3
# 2.將如下數據存儲爲字典類型
# 數據：info = "name:Owen|age:18|gender:男"
# 結果：{'name': 'Owen', 'age': 18, 'gender': '男'}
# 注：年年齡存儲爲數字類型
# 3.完成數據的去重
# 數據：t3 = (1, 2, 1, 2, 3, 5, 9)
# 結果：t3 = (1, 2, 3, 5, 9)
# 注：從不不考慮順序、考慮順序兩⽅方⾯面完成
# 4.計算元組中全部能夠轉換爲數字的數據的總和
# 數據：t4 = (10, 'abc', '100', '3')
# 運算結果：113
# 5.將數據轉換類型存儲
# 原數據：dic = {'name': 'Owen', 'age': 18, 'gender': '男'}
# 處理理後：info = [('name', 'Owen'), ('age', 18), ('gender', '男')]
# 拓拓展：選作
# 1.計算元組中全部能夠轉換爲數字的數據的總和
# 數據：t4 = (10, 'abc', '100', '3', '壹', '肆', [1000], (10000,))
# 運算結果：11118
# 提示：
# -- 利利⽤用字符串串isnumeric()判斷漢字
# -- 利利⽤用字典{'壹': 1 ...}將漢字轉換爲數字
# -- 利利⽤用isinstance()將list和tuple中數據取出來
# -- 先將全部轉化爲數字的數據存放在⼀一個單列列集合中，在作運算
# 2.完成錄⼊入電話本
# 需求：
'''
-- 從鍵盤中錄⼊入姓名(不不區分⼤大⼩小寫)：
-- 姓名必須是全英⽂文組成，不不是則從新錄⼊入姓名，若是是q，表明退出
-- 從鍵盤中再錄⼊入電話：
-- 電話必須爲數字且⻓長度必須是11位(不不能轉換爲數字)
-- 若是出現姓名相同，則保留留最後⼀一次電話號碼
-- 造成的數據是有電話分組的，如：第⼀一次錄⼊入Owen，13355667788，則會造成
-- {
'O': {
'Owen': '13355667788'
}
}
最終數據，分組名⼀必定⼤大寫：
{
'E': {
'egon': '17788990000',
'engo': '16633445566'
},
'O': {
'Owen': '13355667788'
}
}

做業2

# 做業3：
#需求:
用戶名和密碼存放於文件中，格式爲：egon|egon123
啓動程序後，先登陸，登陸成功則讓用戶輸入工資,而後打印商品列表，失敗則從新登陸，超過三次則退出程序
容許用戶根據商品編號購買商品
用戶選擇商品後，檢測餘額是否夠，夠就直接扣款，不夠就提醒
可隨時退出，退出時，打印已購買商品和餘額