1整數(shù)與浮點(diǎn)數(shù)

在數(shù)據(jù)類型中我們學(xué)習(xí)了，整數(shù)和浮點(diǎn)數(shù)在計(jì)算機(jī)內(nèi)部存儲方式不同，整數(shù)運(yùn)算永遠(yuǎn)是精確的，而浮點(diǎn)數(shù)則可能會(huì)有四舍五入的誤差。

Python的除法：

Python中有兩種除法，一種為/
>>>10/3
3.3333333333333335
>>>9/3
3.0
/除法計(jì)算結(jié)果是浮點(diǎn)數(shù)，即使能夠整除，得到的結(jié)果也是浮點(diǎn)數(shù)。
還有一種除法//，我們叫它地板除，兩個(gè)整數(shù)相除仍然是整數(shù)。
>>>10//3
3
最后，由于地板除//只保留了整數(shù)部分，Python還提供了余數(shù)計(jì)算%，可以得到兩個(gè)整數(shù)相除的余數(shù)
>>>10%3
1
所以無論整數(shù)的地板除//還是取余計(jì)算%，得到的結(jié)果永遠(yuǎn)是整數(shù)，也就是說整數(shù)運(yùn)算結(jié)果永遠(yuǎn)是精確的。

• Python的浮點(diǎn)數(shù)也沒有大小限制，但是超出一定范圍就直接表示為inf（無限大）
• 但事實(shí)上PI仍然是一個(gè)變量，Python根本沒有任何機(jī)制保證PI不會(huì)被改變

2字符問題：

由于計(jì)算機(jī)是美國人發(fā)明的，因此，最早只有127個(gè)字符被編碼到計(jì)算機(jī)里，也就是大小寫英文字母、數(shù)字和一些符號，這個(gè)編碼表被稱為ASCII編碼，比如大寫字母A的編碼是65，小寫a是96，小寫字母z的編碼是122。0是48.
因此，Unicode字符集應(yīng)運(yùn)而生。Unicode把所有語言都統(tǒng)一到一套編碼里，這樣就不會(huì)再有亂碼問題了。
Unicode標(biāo)準(zhǔn)也在不斷發(fā)展，但最常用的是UCS-16編碼，用兩個(gè)字節(jié)表示一個(gè)字符（如果要用到非常偏僻的字符，就需要4個(gè)字節(jié)）?，F(xiàn)代操作系統(tǒng)和大多數(shù)編程語言都直接支持Unicode。
現(xiàn)在，捋一捋ASCII編碼和Unicode編碼的區(qū)別：ASCII編碼是1個(gè)字節(jié)，而Unicode編碼通常是2個(gè)字節(jié)。
字母A用ASCII編碼是十進(jìn)制的65，二進(jìn)制的01000001；
字符0用ASCII編碼是十進(jìn)制的48，二進(jìn)制的00110000，注意字符'0'和整數(shù)0是不同的；
漢字中已經(jīng)超出了ASCII編碼的范圍，用Unicode編碼是十進(jìn)制的20013，二進(jìn)制的01001110 00101101。
你可以猜測，如果把ASCII編碼的A用Unicode編碼，只需要在前面補(bǔ)0就可以，因此，A的Unicode編碼是00000000 01000001。
新的問題又出現(xiàn)了：如果統(tǒng)一成Unicode編碼，亂碼問題從此消失了。但是，如果你寫的文本基本上全部是英文的話，用Unicode編碼比ASCII編碼需要多一倍的存儲空間，在存儲和傳輸上就十分不劃算。
所以，本著節(jié)約的精神，又出現(xiàn)了把Unicode編碼轉(zhuǎn)化為“可變長編碼”的UTF-8編碼。UTF-8編碼把一個(gè)Unicode字符根據(jù)不同的數(shù)字大小編碼成1-6個(gè)字節(jié)，常用的英文字母被編碼成1個(gè)字節(jié)，漢字通常是3個(gè)字節(jié)，只有很生僻的字符才會(huì)被編碼成4-6個(gè)字節(jié)。如果你要傳輸?shù)奈谋景罅坑⑽淖址?，用UTF-8編碼就能節(jié)省空間。
在計(jì)算機(jī)內(nèi)存中，統(tǒng)一使用Unicode編碼，當(dāng)需要保存到硬盤或者需要傳輸?shù)臅r(shí)候，就轉(zhuǎn)換為UTF-8編碼。
用記事本編輯的時(shí)候，從文件讀取的UTF-8字符被轉(zhuǎn)換為Unicode字符到內(nèi)存里，編輯完成后，保存的時(shí)候再把Unicode轉(zhuǎn)換為UTF-8保存到文件：
最早的計(jì)算機(jī)在設(shè)計(jì)時(shí)采用8個(gè)比特（bit）作為一個(gè)字節(jié)（byte），所以，一個(gè)字節(jié)能表示的最大的整數(shù)就是255（二進(jìn)制11111111=十進(jìn)制255）

3字符串：

對于單個(gè)字符的編碼，Python提供了ord()函數(shù)獲取字符的整數(shù)表示，chr()函數(shù)把編碼轉(zhuǎn)換為對應(yīng)的字符：

print('%9d-%09d' % (3, 1)) 數(shù)字表示占位
print('%.2f' % 3.1415926)

如果你不太確定應(yīng)該用什么，%s永遠(yuǎn)起作用，它會(huì)把任何數(shù)據(jù)類型轉(zhuǎn)換為字符串：

format()
另一種格式化字符串的方法是使用字符串的format()方法，它會(huì)用傳入的參數(shù)依次替換字符串內(nèi)的占位符{0}、{1}……，不過這種方式寫起來比%要麻煩得多

f-string
最后一種格式化字符串的方法是使用以f開頭的字符串，稱之為f-string，它和普通字符串不同之處在于，字符串如果包含{xxx}，就會(huì)以對應(yīng)的變量替換：

r = (s2-s1)/s2*100
print('小爽成績提升了{(lán)0:.1f}%'.format(r))     
format語法有幾個(gè)變量對應(yīng)幾個(gè)表示。如有有倆個(gè)變量就對應(yīng):{0:xxx} {1:xxx}
print(f'小爽成績提升了{(lán)r:.1f}%')    
f語法最簡潔
print('小爽成績提升了: %.1f %%' %r)
基本語法最容易錯(cuò)]

---------------------------
L = ['Bart', 'Lisa', 'Adam']
for name in L:
   print("Hello %s" %name)  基本語法注意沒有逗號，百分號使用
   print(f"hello1 {name}")       f {變量}
   print("hello2  {0}".format(name))  {數(shù)字}占位即可
   print('Hello3,',name+'!')  字符串拼接最簡單了！

--------------------------------------
L = ['Bart', 'Lisa', 'Adam']
n=3
while n>0:
    print('hello',L[n-1])
    n=n-1  思路可以，但是麻煩了

4列表list與元組tuple：

Python內(nèi)置的一種數(shù)據(jù)類型是列表：list。list是一種有序的集合，可以隨時(shí)添加和刪除其中的元素。
當(dāng)索引超出了范圍時(shí)，Python會(huì)報(bào)一個(gè)IndexError錯(cuò)誤，所以，要確保索引不要越界，記得最后一個(gè)元素的索引是len(classmates) - 1。
如果要取最后一個(gè)元素，除了計(jì)算索引位置外，還可以用-1做索引，直接獲取最后一個(gè)元素。
以此類推，可以獲取倒數(shù)第2個(gè) [-2]、倒數(shù)第3個(gè)[-3]
list是一個(gè)可變的有序表，所以，可以往list中追加元素到末尾
也可以把元素插入到指定的位置，比如索引號為1的位置：.insert(1, 'Jack')
要?jiǎng)h除list末尾的元素，用pop()方法：
要?jiǎng)h除指定位置的元素，用pop(i)方法，其中i是索引位置：
要把某個(gè)元素替換成別的元素，可以直接賦值給對應(yīng)的索引位置：
list里面的元素的數(shù)據(jù)類型也可以不同，比如： L = ['Apple', 123, True]
如果一個(gè)list中一個(gè)元素也沒有，就是一個(gè)空的list，它的長度為0：L = []

list元素也可以是另一個(gè)lis 比如：s = ['python', 'java', ['asp', 'php'], 'scheme']
>>> p = ['asp', 'php']
>>> s = ['python', 'java', p, 'scheme']
要拿到'php'可以寫p[1]或者s[2][1]，因此s可以看成是一個(gè)二維數(shù)組，類似的還有三維、四維……數(shù)組。

元組
有序列表叫元組：tuple。tuple和list非常類似，但是tuple一旦初始化就不能修改
因?yàn)閠uple不可變，所以代碼更安全。
【重點(diǎn)】
如果可能，能用tuple代替list就盡量用tuple。
【容易混淆點(diǎn)1】
只有1個(gè)元素的tuple定義時(shí)必須加一個(gè)逗號,來消除歧義：【因?yàn)橛?jì)算優(yōu)先】

>>> t = (1,)
>>> t
(1,)

【容易混淆點(diǎn)2】
你定義一個(gè)tuple時(shí)，在定義的時(shí)候，tuple的元素就必須被確定下來，不可變

>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])

表面上看，tuple的元素確實(shí)變了，但其實(shí)變的不是tuple的元素，而是list的元素。tuple一開始指向的list并沒有改成別的list，所以，tuple所謂的“不變”是說，tuple的每個(gè)元素，指向永遠(yuǎn)不變。即指向'a'，就不能改成指向'b'，指向一個(gè)list，就不能改成指向其他對象，但指向的這個(gè)list本身是可變的！

5條件判斷

【易混淆點(diǎn)1】注意格式，縮進(jìn)錯(cuò)誤，elif寫法

IndentationError: expected an indented block 

age = 3
if age >= 18:
    print('adult')
elif age >= 6:
    print('teenager')
else:
    print('kid')

只要條件是是非零數(shù)值、非空字符串、非空list等，就判斷為True，否則為False。倆條路選一個(gè)。

【易混淆點(diǎn)2】input()返回的數(shù)據(jù)類型是str，str不能直接和整數(shù)比較，必須先把str轉(zhuǎn)換成整數(shù)。Python提供了int()函數(shù)來完成這件事情：

s = input('birth: ')
birth = int(s)
if birth < 2000:
    print('00前')
else:
    print('00后')

6循環(huán)（for...in和while）

Python的循環(huán)有兩種，一種是for...in循環(huán)，依次把list或tuple中的每個(gè)元素迭代出來，看例子：

names = ['Michael', 'Bob', 'Tracy']
for name in names:
    print(name)
----------------------------------
sum = 0
for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
    sum = sum + x
print(sum)

如果要計(jì)算1-100的整數(shù)之和，從1寫到100有點(diǎn)困難，幸好Python提供一個(gè)range()函數(shù)，可以生成一個(gè)整數(shù)序列，再通過list()函數(shù)可以轉(zhuǎn)換為list。比如range(5)生成的序列是從0開始小于5的整數(shù)：

>>> list(range(5))
[0, 1, 2, 3, 4]
---------------------
sum = 0
for x in range(101):
    sum = sum + x
print(sum)

sum = 0
n = 100
while n > 0:
    sum = sum + n
    n = n - 1
print(sum)
最后sum=5050

第二種循環(huán)是while循環(huán)，只要條件滿足，就不斷循環(huán)，條件不滿足時(shí)退出循環(huán)。

n = 1
while n <= 100:
    print(n)
    n = n + 1
print('END')

break 和 continue

用break語句，提前結(jié)束整個(gè)循環(huán)：
用continue語句的作用是提前結(jié)束本輪循環(huán)，并直接開始下一輪循環(huán)。
這兩個(gè)語句通常都必須配合if語句使用。
要特別注意，不要濫用break和continue語句。break和continue會(huì)造成代碼執(zhí)行邏輯分叉過多，容易出錯(cuò)。大多數(shù)循環(huán)并不需要用到break和continue語句，上面的兩個(gè)例子，都可以通過改寫循環(huán)條件或者修改循環(huán)邏輯，去掉break和continue語句。
這時(shí)可以用Ctrl+C退出程序，或者強(qiáng)制結(jié)束Python進(jìn)程。

n = 0
while n < 10:
    n = n + 1
    if n > 10: # 當(dāng)n = 11時(shí)，條件滿足，執(zhí)行break語句
        break # break語句會(huì)結(jié)束當(dāng)前循環(huán)
    if n % 2 == 0: # 如果n是偶數(shù)，執(zhí)行continue語句
        continue # continue語句會(huì)直接繼續(xù)下一輪循環(huán)，后續(xù)的print()語句不會(huì)執(zhí)行
    print(n)

6是用字典dict和集合set

字典dict全稱dictionary，在其他語言中也稱為map，使用鍵-值（key-value）存儲

>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael']

• 把數(shù)據(jù)放入dict的方法，除了初始化時(shí)指定外，還可以通過key放入：
• 由于一個(gè)key只能對應(yīng)一個(gè)value，所以，多次對一個(gè)key放入value，后面的值會(huì)把前面的值沖掉：
• 如果key不存在，dict就會(huì)報(bào)錯(cuò)：
• 要?jiǎng)h除一個(gè)key，用pop(key)方法，對應(yīng)的value也會(huì)從dict中刪除：

>>> d['Thomas']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Thomas'

要避免key不存在的錯(cuò)誤，有兩種辦法，注意：返回None的時(shí)候Python的交互環(huán)境不顯示結(jié)果。

一是通過in判斷key是否存在：
>>> 'Thomas' in d
False

二是通過dict提供的get()方法，如果key不存在，可以返回None，或者自己指定的value：
>>> d.get('Thomas')
>>> d.get('Thomas', -1)
-1

list優(yōu)點(diǎn)：

1. 查找和插入的速度極快，不會(huì)隨著key的增加而變慢；
2. 需要占用大量的內(nèi)存，內(nèi)存浪費(fèi)多。

dic優(yōu)點(diǎn)：

1. 查找和插入的時(shí)間隨著元素的增加而增加；
2. 占用空間小，浪費(fèi)內(nèi)存很少。
   所以，dict是用空間來換取時(shí)間的一種方法。

請務(wù)必注意，dict內(nèi)部存放的順序和key放入的順序是沒有關(guān)系的。
dict可以用在需要高速查找的很多地方，在Python代碼中幾乎無處不在，正確使用dict非常重要，需要牢記的第一條就是dict的key必須是不可變對象。
這是因?yàn)閐ict根據(jù)key來計(jì)算value的存儲位置，如果每次計(jì)算相同的key得出的結(jié)果不同，那dict內(nèi)部就完全混亂了。這個(gè)通過key計(jì)算位置的算法稱為哈希算法（Hash）。
要保證hash的正確性，作為key的對象就不能變。在Python中，字符串、整數(shù)等都是不可變的，因此，可以放心地作為key。而list是可變的，就不能作為key：

>>> key = [1, 2, 3]
>>> d[key] = 'a list'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

set

set和dict類似，也是一組key的集合，但不存儲value。由于key不能重復(fù)，所以，在set中，沒有重復(fù)的key。

要?jiǎng)?chuàng)建一個(gè)set，需要提供一個(gè)list作為輸入集合：

>>> s = set([1, 2, 3])
>>> s
{1, 2, 3}
注意，傳入的參數(shù)[1, 2, 3]是一個(gè)list，而顯示的{1, 2, 3}只是告訴你這個(gè)set內(nèi)部有1，2，3這3個(gè)元素，顯示的順序也不表示set是有序的。。

1. 重復(fù)元素在set中自動(dòng)被過濾：

2. 通過add(key)方法可以添加元素到set中，可以重復(fù)添加，但不會(huì)有效果：

3. 通過remove(key)方法可以刪除元素：>>> s.remove(4)

set可以看成數(shù)學(xué)意義上的無序和無重復(fù)元素的集合，因此，兩個(gè)set可以做數(shù)學(xué)意義上的交集、并集等操作：

>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
{2, 3}
>>> s1 | s2
{1, 2, 3, 4}

set和dict的唯一區(qū)別僅在于沒有存儲對應(yīng)的value，但是，set的原理和dict一樣，所以，同樣不可以放入可變對象，因?yàn)闊o法判斷兩個(gè)可變對象是否相等，也就無法保證set內(nèi)部“不會(huì)有重復(fù)元素”。試試把list放入set，看看是否會(huì)報(bào)錯(cuò)。

對于不變對象來說，調(diào)用對象自身的任意方法，也不會(huì)改變該對象自身的內(nèi)容。相反，這些方法會(huì)創(chuàng)建新的對象并返回，這樣，就保證了不可變對象本身永遠(yuǎn)是不可變的。