1. 格式字符串

%s, %d, %.2f, %c

name = '喜愛'
age = 18
message = name + '今年' + str(age) + '歲'
message = '%s今年%d %c' % (name, age, 0xe4ff)
print(message)

2.列表(list)

可變（支持增刪改）、有序(支持下標(biāo)操作)

列表中元素的增刪改查

1)查： 查單個(gè)元素: 列表[下標(biāo)] - 結(jié)果是元素 切片：列表[開始下標(biāo):結(jié)束下標(biāo):步長] - 是列表

遍歷 - 結(jié)果是元素

2)增: 列表.append(元素) \ 列表.insert(下標(biāo), 元素)

3)刪: del 列表[下標(biāo)] \ 列表.remove(元素) \ 列表.pop(下標(biāo))

4)改: 列表[下標(biāo)] = 新值

list1 = [1, 2, 3] # [100, 200, 300]

list1.remove(1)

print(list1)

print(list1.remove(1)) # null NULL Null

print(list1)
1.列表相關(guān)運(yùn)算

1)數(shù)學(xué)運(yùn)算: +, *

列表1+列表2 - 將兩個(gè)列表中的元素合并產(chǎn)生一個(gè)新的列表（原列表不會發(fā)生改變）

列表*N - 列表中的元素重復(fù)N次產(chǎn)生新的列表

list1 = [1, 2, 3]
list2 = ['name', 'age']
new_list = list1 + list2
print(new_list, list1, list2)
print(list13)
list3 = [1]100
print(list3)

2)比較運(yùn)算: ==, !=

list4 = [1, 2]
print([1, 2] == [2, 1]) # False
print([1, 2] != [2, 1]) # True
print([1, 2] == list4) # True

>, <, >=, <= 只支持相同位置上元素類型相同的兩個(gè)列表 (了解)

print([1, '2', 3] > [100, 'z'])

print([1, 2, 3] > ['a', 'b']) #TypeError: '>' not supported between instances of 'int' and 'str'

2.內(nèi)置函數(shù)

len(列表)楚昭、sum(列表) - 要求列表中的元素必須是數(shù)字栖袋、max(列表)、min(列表)

list(數(shù)據(jù)) - 將指定數(shù)據(jù)轉(zhuǎn)換成列表, 所有的序列都可以轉(zhuǎn)換成列表,比如: 字符串抚太，列表塘幅、字典、集合尿贫、元祖电媳、range、迭代器庆亡、生成器等

- 轉(zhuǎn)換的時(shí)候是將序列中的元素作為列表元素

print(sum(['1', 'abc', 'hj']))

print(max([1, 'a']))

print(list('abcd'))
print(list(range(5)))
print(list(str(123)))

nums = ['10', '23', '4'] # 10234
print(''.join(nums))

3.相關(guān)方法

1) 列表.count(元素) - 獲取指定元素在列表中出現(xiàn)的次數(shù), 結(jié)果是整數(shù)

print([1, 2, 3, 1, 4].count(1))

2) 列表.extend(序列) - 將序列中的元素添加到列表中, 結(jié)果None

list1 = []
list1.extend('abc')
print(list1)
list1.extend(range(3))
print(list1)
list1.extend(['張飛', '關(guān)羽', '趙云'])
print(list1)

list1.extend(['呂布'])
print(list1)

3)列表.index(元素) - 獲取指定元素在列表中的下標(biāo)匾乓，如果這個(gè)元素有多個(gè)只獲取第一個(gè)，如果元素不存在會報(bào)錯(cuò)

list2 = [1, 0, 1, 2, '張飛', '關(guān)羽', '趙云', '呂布']
print(list2.index('張飛'))

print(list2.index('諸葛亮')) # ValueError: '諸葛亮' is not in list

4)列表.reverse() - 將列表中的元素倒序, 不會產(chǎn)生新列表

list2.reverse()
print(list2)

補(bǔ)充: 內(nèi)置函數(shù): reversed(序列) - 將序列中的元素倒序產(chǎn)生一個(gè)新的迭代器又谋， 原序列不會修改

list1 = [1, 2, 3]
result = reversed('abc')

for item in result:

print(item)

print(list(result))
print(list1)

5)列表.sort() - 對列表中的元素從小到大排序(列表中的元素類型一致并且支持比較運(yùn)算), 不會產(chǎn)生新的列表

列表.sort(reverse=True) - 從大到小排序

scores = [10, 100, 89, 20, 67, 34, 9]

scores.sort()

print(scores) # python cookbook/ 流暢的python

scores.sort(reverse=True)
print(scores)

6)列表.copy() - 產(chǎn)生一個(gè)新的列表拼缝，列表中的元素和原列表一樣，相當(dāng)于： 列表[:]

list1 = [1, 2, 3]
list2 = list1
list3 = list1.copy()
print(list2, list3)

list1.append(10)
print(list2, list3)

id(變量) - 查看變量中實(shí)質(zhì)存儲的地址

python所有變量實(shí)質(zhì)都是直接保存的數(shù)據(jù)在內(nèi)存中的地址

print(id(list1), id(list2), id(list3))

列表中刪除數(shù)據(jù)

刪除列表中所有小于60的數(shù)字

問題1: 通過元素刪除的時(shí)候可能出現(xiàn)刪不干凈的問題

scores = [10, 50, 90, 89, 45, 70]
for score in scores:
if score < 60:
scores.remove(score)

print(scores, score) # [50, 90, 89, 20, 70]

"""
scores = [10, 50, 90, 89, 45, 70]
score = 10 if 10 < 60 scores.remove(10) scores = [50, 90, 89, 45, 70]
score = 90 if 90 < 60
score = 89 if 89 < 60
score = 45 if 45 < 60 scores.remove(45) scores = [50, 90, 89, 70]
"""

解決問題1：

scores = [10, 50, 90, 89, 45, 70]
scores2 = scores[:]
for score in scores2:
if score < 60:
scores.remove(score)
del scores2 # score2只是提供遍歷用的彰亥，用完后沒有其他用處咧七，可以直接刪除
print(scores, score)

上面的簡寫

scores = [10, 50, 90, 89, 45, 70]
for score in scores[:]:
if score < 60:
scores.remove(score)
print(scores, score)
"""
scores = [10, 50, 90, 89, 45, 70]
scores2 = [10, 50, 90, 89, 45, 70]
score = 10 if 10<60 scores.remove(10) scores = [50, 90, 89, 45, 70]
score = 50 if 50<60 scores.remove(50) scores = [90, 89, 45, 70]
score = 90 if 90<60
score = 89 if 89<60
score = 45 if 45<60 scores.remove(45) scores = [90, 89,70]
score = 70 if 70<60
"""

問題2：通過下標(biāo)刪除滿足要求的元素的時(shí)候，出現(xiàn)下標(biāo)越界的錯(cuò)誤

print('====================問題2=====================')

scores = [10, 50, 90, 89, 45, 70]

for index in range(len(scores)):

if scores[index] < 60:

del scores[index]

print(scores)

"""
scores = [10, 50, 90, 89, 45, 70]
for index in range(6)
index = range(6) index = (0,1,2,3,4,5)
index = 0 if scores[0]<60 if 10<60 del scores[0] scores = [50, 90, 89, 45, 70]
index = 1 if scores[1]<60 if 90<60
index = 2 if scores[2]<60 if 89<60
index = 3 if scores[3]<60 if 45<60 del scores[3] scores = [50, 90, 89, 70]
index = 4 if scores[4]<60 (out of range)
"""

解決問題2:

scores = [10, 50, 90, 89, 45, 70]
index = 0
while index < len(scores):
if scores[index] < 60:
del scores[index]
continue
index += 1

print(scores)
"""
scores = [10, 50, 90, 89, 45, 70]
index = 0
while 0 < 6 if 10<60 del scores[0] scores = [50, 90, 89, 45, 70]
while 0 < 5 if 50<60 del scores[0] scores = [90, 89, 45, 70]
while 0 < 4 if 90<60 index += 1 index = 1
while 1 < 4 if 89<60 index += 1 index = 2
while 2 < 4 if 45<60 del scores[2] scores = [90, 89,70]
while 2 < 3 if 70<60 index += 1 index = 3
while 3 < 3
print(scores) - [90, 89,70]
"""

1.什么是元祖(tuple):

元祖就是不可變的列表, 作為序列不可變(不支持增刪改)但是有序(支持下標(biāo)操作)

(元素1, 元素2, 元素3,....) , 元素的要求和列表一樣

2.查 - 獲取元素 (和列表一樣)

tuple1 = ('abc', 2, 3, 4)
print(tuple1[0], tuple1[-1])

print(tuple1[10]) # IndexError: tuple index out of range

print(tuple1[0:5:2])
for item in tuple1:
print(item)

for index in range(len(tuple1)):
print(index, tuple1[index])

3.數(shù)學(xué)運(yùn)算任斋、比較運(yùn)算继阻、in/not in、 len(), max(), min(), sum(), tuple()和對應(yīng)的列表操作是一樣的

print((1, 2, 3)+('a', 'b', 'c'))
print((1, 2, 3) * 2)
print(100 in (1, 2, 3))
print(tuple('abcd'), tuple(range(4)), tuple(['abc', 100]))

4.元祖專有特點(diǎn)

1)只有一個(gè)元素的元祖, 需要在這個(gè)元素的后面加一個(gè)逗號

tu1 = ('abc',)
print(type(tu1))

2)元祖的值可以去掉小括號废酷，(直接將多個(gè)元素用逗號隔開穴翩，也表示一個(gè)元祖)

tu2 = 10, 20, 30, 'abc'
print(tu2, type(tu2))

3) 讓變量的個(gè)數(shù)和元祖中元素的個(gè)數(shù)保持一致，可以讓變量依次取出元祖的中的元素

point = (100, 200)
x, y = point
print(x, y)

x, y = (100, 200)
x, y = 100, 200

a = 10
b = 20
a, b = (b, a) # a, b = (b,a) = (20, 10) a = 20, b=10

3.2) 通過多個(gè)變量去獲取元祖元素的時(shí)候锦积，可以在某個(gè)變量的前面加來將這個(gè)變量變成列表獲取不帶的變量取剩下的數(shù)據(jù)

注意：這兒帶*的變量只能有一個(gè)

student = ('小明', 30, 60, 50, 100, 175)
name, age, *scores, height = student
print(name, scores)

name, *x = student
print(name, x)

*x, y, z = student
print(x, y)

1.什么是字典(dict)

字典是python內(nèi)置的一個(gè)容器型數(shù)據(jù)類型, 可變(支持增刪改)芒帕、無序(不支持下標(biāo)操作)

{鍵1:值1, 鍵2:值2, 鍵3:值3,....} 鍵:值 -> 鍵值對

鍵(key): a.不可變 b.唯一 (實(shí)際開發(fā)建議用字符串)

值(value): 和列表元素的要求一樣

注意: 鍵值對是成對出現(xiàn)；字典存數(shù)據(jù)丰介，實(shí)質(zhì)要存的是值背蟆，鍵是值的索引

dict1 = {'a': 100, 'b': 'abc', 'c': [1, 2], 'd': {'a': 100}}
print(dict1)

dict1 = {'a': 100, 'b': 'abc', 'a': [1, 2]}
print(dict1) # {'a': [1, 2], 'b': 'abc'}

2.什么時(shí)候用字典

如果同時(shí)保存的多個(gè)數(shù)據(jù)是具有相同意義的數(shù)據(jù)鉴分，用列表；如果同時(shí)保存的多個(gè)數(shù)據(jù)的意義不同带膀，就使用字典

person1 = ['余婷', 18, 100, 40, 155, 50]
person2 = {'name': '余婷', 'age': 18, 'score': 100, 'height': 155, 'weight': 50}
print(person1[0])
print(person2['name'])

allstudents = [
{'name': '張三', 'age': 18, 'tel': '110', 'dog':{'sex': '母狗', 'color': '白色', 'name': '大黃'}},
{'name': '小明', 'age': 20, 'tel': '220'},
{'name': '張三', 'age': 18, 'tel': '110'}
]

print(allstudents[0]['dog']['color'])

3.查 - 獲取字典的值

1) 獲取key對應(yīng)的值: 字典[key] - 獲取字典中指定key對應(yīng)的值

注意: 如果key不存在志珍，會報(bào)KeyError

dog1 = {'name': '大黃', 'type': '中華田園犬', 'color': 'yellow', 'age': 3}
print(dog1['type'])

print(dog1['gender']) # KeyError: 'gender'

獲取key對應(yīng)的值:

字典.get(key) - 獲取字典中指定key對應(yīng)的值, 如果key值不存在返回默認(rèn)值None

字典.get(key, 默認(rèn)值) - 獲取字典key對應(yīng)的值，如果key不存在返回指定的默認(rèn)值

None是python中的關(guān)鍵字,表示數(shù)據(jù)為空或者沒有的意思

print(dog1.get('color'))
print(dog1.get('gender'))
print(dog1.get('gender', '公狗'))

2)遍歷

直接遍歷字典拿到是key

dog1 = {'name': '大黃', 'type': '中華田園犬', 'color': 'yellow', 'age': 3}
print('===========遍歷===========')
for key in dog1:
print(key, dog1[key])

遍歷字典選第一種方法垛叨，后面的方法要看得懂

print('===========遍歷2===========')
print(dog1.values())
for value in dog1.values():
print(value)

print('===========遍歷3===========')
for key in dog1.keys():
print(key)

print('===========遍歷4===========')
print(dog1.items())
for key, value in dog1.items():
print(key, value)

4.增/改 - 添加鍵值對

字典[key] = 值 - 當(dāng)key不存在的時(shí)候就是添加鍵值對伦糯；當(dāng)key存在的時(shí)候，就是修改key對應(yīng)的值

film = {'name': '流浪地球', '主演': '吳京', 'time': '2019-2-5'}
film['票房'] = '40億'
print(film)

film['time'] = '2019-2-6'
print(film)

film.setdefault('a', 10)
print(film)

字典.setdefault(key, value) - 只能條件鍵值對嗽元，不能修改

film.setdefault('name', '戰(zhàn)狼2')
print(film)

5.刪

del 字典[key] - 刪除字典中key對應(yīng)的鍵值對, 如果key不存在會報(bào)錯(cuò)

film = {'name': '流浪地球', '主演': '吳京', 'time': '2019-2-5'}
del film['time']
print(film)

字典.pop(key) - 從字典中取出key對應(yīng)的值敛纲，結(jié)果是key對應(yīng)的值

name = film.pop('name')
print(film, name)

6.相關(guān)運(yùn)算

只支持比較運(yùn)算符

print({'a': 10, 'b': 20} == {'b': 20, 'a': 10}) # True

in / not in

key in 字典 - 判斷字典中是否存在某個(gè)key對應(yīng)的鍵值對

student = {'name': '小明', 'age': 20, 'tel': '16362738493'}
print('小明' in student) # False
print('name' in student) # True

len(), max(), min()

dict() - 本身是一個(gè)序列，序列中元素是小序列剂癌，小序列必須有且只有2個(gè)元素淤翔，而且這個(gè)2個(gè)元素中的第一個(gè)元素是不可變的

注意：取最大值最小值是取key的最大值和最小值;字典轉(zhuǎn)列表/元祖的時(shí)候，是將字典的key取出來作為列表/元祖的元素

print(len(student))
print(max(student))
print(dict(['cb', ['a', 100], [1000, [1]] ]))
print(list(student))

7.相關(guān)方法

1)字典.clear() - 清空字典

student.clear()
print(student)

2)字典.copy() - 復(fù)制字典的內(nèi)容佩谷，產(chǎn)生一個(gè)新的字典

student = {'name': '小明', 'age': 20, 'tel': '16362738493'}
student1 = student.copy()
student1['name'] = '小花'
print(student)

3) dict.fromkeys(序列,值) - 創(chuàng)建一個(gè)新的字典旁壮，將序列中的元素作為新字典的key,指定的值作為每個(gè)key對應(yīng)的值

new_dict = dict.fromkeys(['name', 'age', 'gender'], None)
print(new_dict)

person_keys = ['name', 'age', 'gender']
person1 = dict.fromkeys(person_keys, None)
person2 = dict.fromkeys(person_keys, None)

4) 字典1.update(字典2) - 將字典2中的鍵值對添加到字典1中

dict1 = {'a': 10, 'b': 20, 'z': 100}
dict1.update({'c': 30, 'b': 200})
print(dict1)