python數據類型，格式話輸出

　一.程序交互

name = input(“你的名字是：”)  #用戶輸入，輸入的任何東西都存儲成str（字符串類型）的形式

二.注釋的重要性

　　以后動輒幾千行代碼的時候，回過頭再去看的時候，發現自己都看不懂了，在工作中還會大家一起合作完成代碼，不寫注釋的話，更難以交流了。
單行注釋直接在句首寫上#就好了
多行注釋可用快捷鍵ctrl+/，或者用三個引號括起來''' 99999999     
　　　　　　　　　　　　　　　　　　　　　　　　　12345789　
　　　　　　　　　　　　　　　　　　　　　　　'''

#1. 不用全部加注釋，只需要在自己覺得重要或不好理解的部分加注釋即可
#2. 注釋可以用中文或英文，但不要用拼音

三.基本數據類型（查看數據類型的方法type（））
　

1.數字類型

int（整型）
在32位機器上，整數的位數為32位，取值范圍為-2**31～2**31-1，即-2147483648～2147483647
在64位系統上，整數的位數為64位，取值范圍為-2**63～2**63-1，即-9223372036854775808～9223372036854775807

long（長整型）
跟C語言不同，Python的長整數沒有指定位寬，即：Python沒有限制長整數數值的大小，但實際上由於機器內存有限，我們使用的長整數數值不可能無限大。
注意，自從Python2.2起，如果整數發生溢出，Python會自動將整數數據轉換為長整數，所以如今在長整數數據后面不加字母L也不會導致嚴重后果了。
注意：在Python3里不再有long類型了，全都是int

float（浮點型）（精度限制17位，小數點后16位）
定義：salary=3.1 #salary=float(3.1)
用於標識：工資，身高，體重，
############    if a.isdigit():  #  判斷是不是a數字

2.字符串類型
python中，加了引號（單引號可以，雙引號也可以，三個單引號也可以）的字符都叫字符串

 你需要考慮單雙的配合（特殊情況，其他情況下隨意）

msg = "My name is Alex , I'm 22 years old!"
多引號什么作用呢？作用就是多行字符串必須用多引號

字符串拼接：
字符串可以進行相加和相乘的操作
>>> a='hello'
>>> b=' world'
>>>
>>> a + b
'hello world'
>>> res=a + b
>>> print(res)
hello world

>>> a*3
'hellohellohello'

a.isdigit()  #  判斷一字符串是否只包括數字
a.replace('old','new',max)  #  old被替換的字符，new換成的字符，max最大替換次數
a.find()  #  查找是否含有字符串，是返回索引值，否者返回-1
a.count()  #  統計字符出現次數
a.strip()  #  刪除一個字符串
a.center(10,'-')  #  左右填充10位的-
a.split('a',2)  #  在a出現是地方進行切片(a也沒有了)，切片2次
a.format()  

通過關鍵字

1 print('{名字}今天{動作}'.format(名字='陳某某',動作='拍視頻'))#通過關鍵字
2 grade = {'name' : '陳某某', 'fenshu': '59'}

通過位置

1 print('{1}今天{0}'.format('拍視頻','陳某某'))#通過位置
2 print('{0}今天{1}'.format('陳某某','拍視頻'))

a.join
>>> A = 'hello,world'
>>> ' '.join(A)
'h e l l o , w o r l d'
>>> '>'.join(A)
'h>e>l>l>o>,>w>o>r>l>d'

3.布爾類型（bool）
布爾類型很簡單，就只有兩個值，一個真（true），一個假（false），主要用於邏輯運算

4.列表類型（list）
創建    name = ['張三'，‘王五’，‘李四’，1，2，5，4，5，4，‘李四’]
    list('abc')  # 結果為['a', 'b', 'c']
查詢，取出    name[0]  #  結果為'張三'  name[-1]  #  結果為'李四'
  查詢索引值    name.index('李四')  #  結果為2，有重復的時候，只能找到第一個
  查詢重復出現的個數    name.count('李四')  #  結果為2（個）
切片（顧頭不顧尾）    name[0:2]  #結果為['張三','王五']
  值得注意的是    name[-5:-1]  #  結果為[5,4,5,4]  name[-5:]  #  結果才是[5,4,5,4,'李四']
  中間隔一個取一個    name[7:2]  #  結果為['張三','李四',2,4]
增加和修改    name.appeend('Xander')  #  加到了最后面
    name.insert(0,'lexi')  #  插入到指定位置
修改（直接賦值就好了）    name[1:3] = ‘abc’ #  批量修改‘王五’,‘李四’被修改成了'a','b','c'(中間還增加了一個)
刪除    name.pop()  #  刪掉最后一個
    name.remove('張三')  #  刪除索引到的第一個'張三'
    del name[1]  #  刪掉了name[1],刪除全局，可以刪除任何東西
    del name[1:5]  #  批量刪除
排序    n = ['a','c','b','f','e',1,3]
    n1 = ['a','c','b','f','e']
    n2 = [1,2]
    n.sort()  #  會報錯int和str不能一起排序
    n1.sort()  # 會按照ASCII碼表排序
反轉    n.reverse()
拼接列表    n1 + n2  #  或者n1.extend(n2)
清空列表    n.clear()
copy    n1 = n2  #  如果修改了n2列表中的值，n1也會一起被修改，這里和變量里面是不一樣的
    n1 = n2.copy()  #  這個時候修改n2不會一起修改n1的值
5.元組（tuple）

"""
元組【有序不可變】
　　作用：存多個值，對比列表來說，元組不可變（是可以當做字典的key的），主要是用來讀
　　定義：
　　　　與列表類型比，只不過[]換成()
"""
 
t = ('a',)  # 元祖只有一個元素時，需要加逗號, 和字符串區分開
t = ('a', 'b', 'b', 'c')  # 定義一個元組
t = tuple(('a', 'b', 'b', 'c'))
 
print(t.index('b'))  # 索引出元素第一次出現的位置，還可以指定在某一范圍里查找，這里默認在整個元組里查找輸出1
print(t.count('b'))  # 計算元素出現的次數，這里輸出2
print(len(t))  # 輸出遠組的長度，這里輸出4
print(t[1:3])  # 切片 輸出('b','b')
for i in t:
    print(i)  # 循環打印出元組數據

6.字典（dict）

"""
字典【無序可變】
　　作用：存多個值,key-value存取，取值速度快
　　定義：
　　　　key必須唯一，必須是不可變類型，value可以是任意類型
"""
 
# 創建：
info = {"name": "tom", "age": 18, "gender": "male"}  # 本質info=dict({"name":"tom","age":18})
# info=dict(name='tom',age=18,gender='male')
# info=dict([['name','tom'],('age',18)])
# info={}.fromkeys(('name','age','gender'),None) #{'name': None, 'gender': None, 'age': None}
 
# 增加
info['salary'] = 50000  # {'name': 'tom', 'age': 18, 'salary': 50000, 'gender': 'male'}
 
# 刪除
info.pop('age')  # 根據鍵刪除某一元素 d={'Michael': 95, 'Tracy': 85}
info.popitem()  # 隨機刪除
info.clear()  # {}
 
# 修改
info['age'] = '25'  # 如果沒有該key，則在字典創建新的的的key-value
 
# 查詢
info.get('age')  # 根據key獲取values，如果不存在返回None，這里輸出75
'''
setdefault的功能
1：key存在，則不賦值，key不存在則設置默認值
2：key存在，返回的是key對應的已有的值，key不存在，返回的則是要設置的默認值
'''
print(info.setdefault('age', 50000))  # 18
print(info.setdefault('salary', 50000))  # 50000
print(info)  # {'age': 18, 'name': 'tom', 'salary': 50000, 'gender': 'male'}
 
# 其他
print(len(info))  # 輸出字典長度
print('age' in info)  # python3 中移除了 has_key,要判斷鍵是否存在用in
 
for i in info:
    print(i)  # 循環默認按鍵輸出
 
for i in info.values():  # 循環按值輸出
    print(i)
 
for k, v in info.items():  # 循環按鍵值輸出
    print(k, v)

字典相關題目及答案

#創建一個字典

dic = {'k1':'v1','k2':'v2','k3':'v3'}

#1.請循環遍歷出所有的KEY

for k in dic:

print(k)

#2請循環遍歷出所有的value

for k in dic:

print(dic[k])

#3請循環遍歷初所有的KEY和VALUE

for k in dic:

print(k,dic[k])

#4請在字典中添加一個鍵值對，'k4':'v4',輸出添加后的字典

dic['k4'] = 'v4'

print(dic)

#5請刪除字典中鍵值對'k1','v1',並輸出刪除后的字典

dic.pop('k1')

print(dic)

#6請刪除字典中鍵'k5'對應的鍵值對，如果字典中不存在鍵'k5'，則不報錯，並且讓其返回none

if 'k5' in dic:

dic.pop('k5')

else:

print(dic.get('k5'))

#7請獲取字典中'k2'對應的值

print(dic.get('k2'))

#8請獲取字典中'k6'對應的值，如果'k6'不存在，則不報錯，並且讓其返回Nnoe

print(dic.get('k6'))

#9現有dic2 = {'k1':'v111','a':'b'}請通過一行操作使dic2 = {'k1':'v1','k2':'v2','k3':'v3','a':'b'}

dic = {'k1':'v1','k2':'v2','k3':'v3'}

dic2 = {'k1':'v111','a':'b'}

dic2.update(dic)

print(dic2)

#10.組合嵌套題，寫代碼，有如下列表，按照要求實現每一個功能

lis = [['k',['qwe',20,{'k1':['tt',3,'1']},89],'ab']]

#10.1.將列表lis 中的'tt'變成大寫（用兩種方式）

#10.1.1

print(lis[0][1][2].get('k1')[0].upper())

#10.1.2

print(lis[0][1][2].get('k1')[0].swapcase())

#10.2.將列表中的數字3 變成字符串'100'(用兩種方式）

#10.2.1

print(lis)

lis[0][1][2].get('k1')[1] = '100'

print(lis)

#10.2.2

lis = [['k',['qwe',20,{'k1':['tt',3,'1']},89],'ab']]

dic3 = {'k1':['tt','100','1']}

print(lis)

lis[0][1][2].update(dic3)

print(lis)

#10.3 將列表中的字符串'1'變成數字101（用兩種方式）

#10.3.1

lis = [['k',['qwe',20,{'k1':['tt',3,'1']},89],'ab']]

print(lis)

lis[0][1][2].get('k1')[2] = 101

print(lis)

#10.3.2

lis = [['k',['qwe',20,{'k1':['tt',3,'1']},89],'ab']]

dic3 = {'k1':['tt',3,101]}

print(lis)

lis[0][1][2].update(dic3)

print(lis)

#11 按照要求實現以下功能：

#現有一個列表li = [1,2,3,'a','b',4,'c']，有一個字典（此字典是動態生成的，你並不知道他里賣弄有多少鍵值對，所以

#用dic = {}模擬此字典）；現在需要完成這樣的操作：如果該字典沒有'k1'這個鍵，那就創建'k1'鍵和其對應的值(該鍵對應的值設置為空列表）

#並將列表li 中的 索引為奇數的對應元素，添加到'k1'這個鍵對應的空列表中。如果該字典有'k1'這個鍵，且'k1'對應的value

#是列表類型，那就將li中的索引為奇數的對應元素，添加到'k1'這個鍵對應的鍵中

dic = {'k2':2,'k3':3}#1. dic{}字典中 沒有 'k1'

#dic = {'k1':['we','tt'],'k2':2}#2 dic{}字典中有'k1'

#dic = {'k1':1,'k2':33} # 有'k1'但'k1'value 非列表

li = [1,2,3,'a','b',4,'c']

if not 'k1' in dic:

dic.setdefault('k1',[])

for i in li :

if li.index(i) % 2 == 1:

dic['k1'].append(i)

else:

if type(dic['k1']) == type([]):

for i in li:

if li.index(i) % 2 == 1:

dic['k1'].append(i)

else:

print("字典K1,VALUE 不是列表，無法追加")

print(dic)

6集合（set）

"""
集合【無序可變】
　　作用：去重，關系運算
　　定義：
　　　　 1：每個元素必須是不可變類型(可hash，可作為字典的key)
         2:沒有重復的元素
         3：無序
         4：可以包含多個元素，用逗號分割，
"""
a = {1, 2, 3, 4, 5, 6, 7, 8, 9}
b = {1, 3, 9, 10, 11}
 
a.add(10)  # 添加一個元素
 
a.discard(1)  # 刪除元素1，不存在的話不報錯
a.remove(1)  # 刪除元素1，不存在的話報錯
a.pop()  # 隨機刪除
 
a.update([1, 8, 34])  # 更新，沒有就添加，有就不添加
 
# 並集
a.union(b)
a | b
# 返回一個新的集合包含a和b的所有元素
 
# 交集
a.intersection(b)
a & b
# 返回一個新的集合包含a和b的公共元素
 
# 差集
a.difference(b)
a - b
# 返回一個新的集合，包含a中的元素，但是沒有b中的元素
 
# 對稱差集
a.symmetric_difference(b)
print(a ^ b)
# 返回一個新的集合包含 a和b中不重復的元素

數據類型總結

• 【有序】: 列表，元組
• 【無序】: 字典，集合
• 【可變】:列表，字典，集合
• 【不可變】：數字，字符串，元組
• 【存單值】:數字，字符串
• 【存多值】:列表，元組，字典

四.格式化輸出
　　利用占位符
%s就是代表字符串占位符，除此之外，還有%d,是數字占位符， 如果把上面的age后面的換成%d，就代表你必須只能輸入數字啦；
%f小數

name = input('Name:')
age = input('Age:')
job = input('Job:')
hometown = input('Hometown:')

info='''
--------info of %s---------------
Name:       %s
Age:        %s
Job:        %s
Hometown:   %s
------------end------------------
'''%(name,name,age,job,hometown)
print(info)