《跟老齊學Python：輕鬆入門》學習筆記：章一：基礎物件型別
第1章 基本物件型別
浮點數的所有運算都要注意
1.1 數和四則運算
1.python可以自動處理大整數問題，不必擔心溢位
2.單精度浮點數（4個位元組）在計算機內部儲存方式：
1位為符號位（0為正，1為負），8位用作整數，最後的23位表示有效數字
3.每個物件在記憶體中都有自己的地址，可以使用函式id()檢視每個物件的記憶體地址；但是通過id()得到的記憶體地址是隻讀的，不能夠修改。
4.使用函式type()可以檢視物件的型別，當然得到的結果也是隻讀的；
5.物件有型別，變數無型別
6.四則運算中運算子兩側只要有一個為浮點數，結果就是浮點數，否則為整數
7.浮點數會出現溢位的問題 * 表示相乘 ；** 表示乘冪 ，等效於pow()函式，當然使用的時候要匯入math庫， e-08 表示10的-8次方；
8.python中的除法的結果都是浮點數，不論參與運算的數有沒有浮點數
9.// 表示兩個數相除之後的商（取整），這個商一定為整數
10.python中的已經寫好的工具叫做 “庫” ，或者“模組”、或者“類庫”
11.匯入模組：
- 單一模組：
import module-name表示匯入模組：module-name - 大模組中的小模組：
from module1 import module11,表示從庫module1（大模組），裡面的子模組 module11
12.針對python中的浮點數問題
python以雙精度64位表示浮點數，預設的小數精度為17位，所以電腦中以二進位制進行儲存的時候會丟掉後面的一部分，造成儲存的實際上就有誤差；
- 除法會將無限迴圈小數截斷，還不是按照四捨五入的截斷
解決方法，匯入decimal：
#Author:GJXAIOU
#coding:utf-8
#!/usr/bin/env python
import decimal #匯入decimal 模組
a = decimal.Decimal("10.0") #使用decimal模組中的Decimal函式
b= decimal.Decimal( 程式執行結果：3.333333333333333333333333333
- 兩個數相除將結果保留為分數：使用
fraction
#Author:GJXAIOU
#coding:utf-8
#!/usr/bin/env python
from fractions import Fraction
ans = Fraction(10,4)
print(ans)
程式執行結果：5/2
13.取餘：%
14.同時獲得除法的商和餘數，使用內建函式divmod()
#Author:GJXAIOU
#coding:utf-8
#!/usr/bin/env python
print(divmod(5,2))
程式執行結果：(2, 1)前面為商，後面為餘數
15.對小數進行四捨五入，使用內建函式 round(),前一個引數為數字，後一個引數為小數點後的位數
#Author:GJXAIOU
#coding:utf-8
#!/usr/bin/env python
print(round(1.256452233 ,3))
程式執行結果：1.256
- round()如果只有一個數作為引數，不指定位數的時候：
返回的是一個整數，而且是最靠近的整數（這點上類似四捨五入）。但是當出現.5的時候，兩邊的距離都一樣，round()取靠近的偶數。 - 當指定取捨的小數點位數的時候：
一般情況也是使用四捨五入的規則，但是碰到.5的這樣情況，如果要取捨的位數前的小數是奇數，則直接捨棄，如果偶數這向上取捨。
1.3 常見的數學函式以及運算優先順序
- 使用
math
#Author:GJXAIOU
#coding:utf-8
#!/usr/bin/env python
import math
print(math.pi)
print(dir(math))
程式執行結果：
3.141592653589793
下面是math中的所有東西（函式）
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc']
其中math.floor()為取整函式，math.fabs(-2)為求絕對值（也可以使用內建函式abs()）,求除法的餘數：math.fmod(5,3)(也可以使用內建的/)
2.運算優先順序
見書P25-26頁
實在不行先加括號
1.4 一個簡單的程式
1.未經編譯就可執行的程式稱為指令碼程式（script）
2.程式前面兩行
#Author:GJXAIOU
#coding:utf-8
#本程式採用utf-8編碼
#!/usr/bin/env python
#在Linux中必須寫，在Windows中可以不寫，能夠載入程式找到python的直譯器
3.python 中的註釋：當行註釋：# ,多行註釋：使用一對'''或者一對"""
1.5 字串
1.字串使用單引號或者雙引號包裹
當字串內部含有其中一種符號（單引號或者雙引號）時候，外面採用另一種符號進行包裹，或者在字串中出現的的符號前加上\,相當於轉義字元。
事例說明：
#Author:GJXAIOU
#coding:utf-8
#!/usr/bin/env python
str = "what's your name?" #採用雙引號包含單引號
str1 = 'what\'s your name?' # 使用轉義字元
print(str)
print(str1)
程式執行結果為：
what's your name?
what's your name?
2.可以使用type()進行檢驗型別
#Author:GJXAIOU #coding:utf-8
#!/usr/bin/env python
print(type(330))
print(type("330"))
程式執行結果為：
<class 'int'> 物件型別為整型
<class 'str'> 物件型別為字串型別
3.使用+實現字串的連線
首先 +兩邊的物件給的資料型別必須一致 ，例如都是數字就是加法，字串就是拼接；
str()實現將整數轉換為字串；
repr()函式作用是返回一個字串物件；
補充_Python中str()與repr()函式的區別int()實現將字串轉換為整數
4.一行的結尾加上\，實現續行，對於字串可以採用字串開頭結尾各加上三個"表示字串的續行
5.鍵盤輸入：使用input()獲取輸入的資料,input ()返回的結果為字串型別的物件
#Author:GJXAIOU
#coding:utf-8
#!/usr/bin/env python
name = input("what's your name ?")
age = input("how old are you ?")
print("your name is " + name)
print("you are " + age + "years old.")
after_ten = int(age) + 10
print("you will be" +str(after_ten) + "years old after ten years.")
程式執行結果：
what's your name ?gaojixu
how old are you ?23
your name is gaojixu
you are 23years old.
you will be33years old after ten years.
6.原始字串：由r開頭引起的字串就是原始字串，在裡面放置任何字元都是原始含義，也就是說沒有轉義字元的性質
a = r"c:\hello"
print(a)
程式執行結果：c:\hello
7.序列: 有序排列，例如字串、列表等等統稱為序列
8.索引： 序列中每一個都有編號，這個編號即為：索引
例如：
#Author:GJXAIOU
#coding:utf-8
#!/usr/bin/env python
# 索引
lang = "python is beautiful"
print("lang = " ,lang)
print("lang[3] = ",lang[3])
ans1 = lang.index("p")# 在lang字串中查詢字元p的位置
print("index('p')= ",ans1)
#字串的切片：複製字串的一部分，（不改變原有的字串）
ans2 = lang[2:9]#得到第2到第9個字元（包括第2 個，不包括第9個）
print("lang[2:9] = ",ans2)
ans3 = lang[1:]#得到從第一個到最後的字元（包括第一個）
print("lang[1:] = ",ans3)
ans4 = lang[:] #得到所有的字元,這時候新的字串（其實本質上這時候並沒有生成新的字串）和原來字串的地址也是一樣的
print("ans4 = ",ans4)
print("id(lang) = ",id(lang),"id(ans4) = ",id(ans4)) #id()是檢視該物件在記憶體中的地址
#對比如下的賦值語句
ans = lang
print("id(lang) = ",id(lang),"id(ans4) = ",id(ans4))
ans5 = lang[:9] #得到第9個之前的所有字元（不包括第9個）
print("lang[:9] = ",ans5)
程式執行結果：
lang = python is beautiful
lang[3] = h
index('p')= 0
lang[2:9] = thon is
lang[1:] = ython is beautiful
ans4 = python is beautiful
id(lang) = 2381962817448 id(ans4) = 2381962817448
id(lang) = 2381962817448 id(ans4) = 2381962817448
lang[:9] = python is
1.5.8 字串的基本操作
len()求字串的長度 ,返回值為int型
str = "hello"
print(len(str))
程式執行結果；5
+連線兩個序列
str1 = "python"
str2 = "lisp"
print(str1 + "&"+ str2)
程式執行結果：python&lisp
*重複序列元素
str = "hello"
print(str *3)
程式執行結果：hellohellohello
in判斷元素是否存在於序列中
str1 = "python"
print("th" in str1)
程式執行結果：True
max()返回最大值 ;min()返回最小值
str1 = "python"
print("max(str1)= ",max(str1),"min(str1)=",min(str1))
程式執行結果：max(str1)= y min(str1)= h
比較的是字元編碼：可以使用內建函式ord()獲得一個字元對應的數字編碼，使用chr()實現數字編碼向字元的轉換
例如：
print("ord('h') = ",ord("h"), "chr(104) = ",chr(104))
程式執行結果：ord('h') = 104 chr(104) = h
*字串的比較是挨個比較，直到得出結果；
ASCII碼：A：65 a :97
1.5.9 字串的格式化輸出
- 輸出方式
- 方法一：使用佔位符
%s,(不推薦使用)
- 方法一：使用佔位符
print("I like %s" % "python")
程式執行結果：I like python
- 方法二：使用
format()方法,使用方法：string.format(),format()方法的返回值為一個字串
同樣是使用佔位符{},根據中間的數字序號來對應替換
print("I like {1} and {0}".format("lalala","python"))
程式執行結果：I like python and lalala
- 輸出格式：
- 對齊：
print("I like {1:10} and {0:^15} and{2:>12}".format("lalala","python","hahaha"))
# 引數含義：第一個位置：佔得位置為10個位元組，預設左對齊； 第0個位置，佔的位置為15個位元組，居中對齊；
第2個位置，佔得位置長度為12個位元組，右對齊；
程式執行結果：I like python and lalala and hahaha
- 長度：
print("I like {1:.2} and {0:^15.4} and{2:>12}".format("lalala","python","hahaha"))
# 引數含義：第1個位置，：後面沒有數字表示佔得長度自動適應即將放入該位置的字串，.號後面數字表示對於即將傳入的字串擷取前兩個字元；
# 第2個引數的含義；放在第0個位置，佔位長度為15個位元組，居中對齊，擷取將傳入的字串前4個字元
程式執行結果：I like py and lala and hahaha
- 格式符(針對數字（包括整數和浮點數）)
print("I like {1:4d} and {0:f} and{2:6.2f} and {3:04f}".format(12345,900897,3434478,368937987))
#引數含義：第1個位置，長度為4個位元組，以整數形式，預設是右對齊
# 第2個位置：長度自適應，以浮點數形式。預設右對齊
#第3個位置：長度6個位元組，填充到此的浮點數保留2位小數，右對齊
#第4個位置：數字前面加0表示如果位數不足則補0；
程式執行結果：I like 900897 and 12345.000000 and3434478.00 and 368937987.000000
1.5.10 常用的字串方法
- 判斷是否全為字母，使用
isalpha()判斷字串是否全由字母組成
str= "python"
# 下面兩個等價
print(str.isalpha())
print("python".isalpha())
程式執行結果：
True
True
- 根據分隔符分割字串,返回結果形式為列表
str= "python,is a python.lan"
print(str.split(" "))#以空格分割
print("python,is a python.lan".split("."))#以.進行分割
print(str.split())#預設的分割符為所有空字元，包括空格、換行、製表符等等
程式執行結果：
['python,is', 'a', 'python.lan']
['python,is a python', 'lan']
['python,is', 'a', 'python.lan']
- 去掉字串兩頭的空格，會產生新的字串，原來的字串不變
str = " hello "
print(id(str))#獲得原來的字串的地址
print("star"+str.strip()+ "end")#去除左右所有的空格
print(id("star"+str.strip()+ "end"))#獲取變換之後的字串的地址
print("start"+str.lstrip()+ "end")#去除左邊的空格
print("start"+str.rstrip()+ "end")#去除右邊的空格
print("start"+str+"end")#去除之後的字串，原來的值沒有變化，這種去除產生了新的字串
程式執行結果：
1651046031536
starhelloend
1651046258096
starthello end
start helloend
start hello end
- 字元大小寫的轉換，生成一個新的字串，不改變原有的值
- str.upper() :將str中的字母全部轉換為大寫
- str.lower() :將str中的字母全部轉換為小寫
- str.capitalize() :將首字母轉換為大寫
- str.isupper() :判斷str中的字母是否全為大寫
- str.islower() :判斷str中的字母是否全為小寫
- str.istitle() :判斷str是否為標題模式，即所有單詞首字母大寫，其餘字母全部小寫
str = "hello PyThon"
print(str.upper())
print(str.lower())
程式執行結果：
HELLO PYTHON
hello python
- 用join()拼接字串,主要用於將列表中的各種型別元素連線，或者使用某個符號來拼接字串
a = ["python","is","the","best"]
print("*".join(a))
程式執行結果：python*is*the*best
1.6 字元編碼
python 3 中所有字串均採用Unicode編碼，UTF-8只是其實現方法之一(採用可變長度字元編碼)，同時可以使用encode()將Unicode編碼的字元轉換為其他編碼
1.7 列表
1.7.1 定義
- 形式為
[] - 判斷列表是否為空：
bool()空為false - 定義：
a = ['2',3,"hello"]#包含字元、數字、字串
b= ["python",a]#同時可以套一個列表
print(a)
print(b)
程式執行結果為：
['2', 3, 'hello']
['python', ['2', 3, 'hello']]
1.7.2 索引和切片
#索引
#列表元素的索引
a = ['2',3,"hello","end"]
print(a[2])
print(a[:2])
print(a[2][1:4])
#列表元素地址的索引
"""
編號方式（適用於字串和列表等所有序列型別）：從左至右0、1、2 或者從右至左-1、-2、-3、-4.。。。
"""
print(a.index("hello"))#這樣預設返回時是按照從左到右的順序
#切片
#典型的錯誤讀取方式
print(a[-1:-3]) # 等價於a[(4-1):(4-3)]=a[3:1],又因為序列都是從左到右讀取，這裡是從右到左的讀取，因此返回空值
#正確用法
print(a[-3:-1]) #等價於a[1:3]
#根據步長切片，當步長為正數的時候，相當於從左往右看數列，先看到的值為開始的值
print(a[::2])#從頭搜到位，步長為2，實際上中間也就間隔一個字元 [開始：結束：步長]
# 當步長為負數的時候，相當於從右往左看數列，先看到的值為開始的值
print(a[1:3:2])
print(a[-3:3:2])
print(a[-2:1:-2])
程式執行結果：
hello
['2', 3]
ell
2
[]
[3, 'hello']
['2', 'hello']
[3]
[3]
['hello']
1.7.3 反轉（適用於列表以及字串）
lst = [1,2,3,4,5,6]
str = "python"
print(lst[: : -1])
print(str[: : -1])
print(lst)
print(str)
#可以使用reversed函式進行反轉，但是必須加上list，最後的結果也都是列表格式
print(list(reversed(str)))
print(list(reversed(lst)))
#注意比較兩個的不同
程式執行結果：
[6, 5, 4, 3, 2, 1]
nohtyp
[1, 2, 3, 4, 5, 6]
python
['n', 'o', 'h', 't', 'y', 'p']
[6, 5, 4, 3, 2, 1]
1.7.4 操作列表
- 基本操作
len()
lst= ["i","python","lalla"]
print(len(lst))
程式執行結果：3
+:連線兩個列表*:重複序列元素in:判斷元素是否在列表中（完整性的元素，不是字元）
lst= ["i","python","lalla"]
print("python" in lst)
print("la" in lst)
程式執行結果：
True
False
max()和min()尋找列表中最大或者最小的元素
lst= ["i","python","lalla"]
print(max(lst))
print(min(lst))
程式執行結果：
python
i
- 修改列表元素（修改和追加）
#修改元素
lst= ["i","python","lalla"]
lst[1] = "hello" #將第1個元素修改為“hello”
print(lst)
#追加元素
lst.append("hulala")#在結尾追加元素,返回值為None,直接使用print(lst.append("hulala")),結果為None 同時進行的也是原地修改
print(lst)
程式執行結果：
['i', 'hello', 'lalla']
['i', 'hello', 'lalla', 'hulala']
1.7.5 常見的列表函式
- extend ：將兩個列表合併，a:b - >a+b :b,引數可以是列表或者字串，但是如果為數值型就會報錯
extend的引數必須為iterable(可迭代的（可以重複反饋）)
使用hasattr()判斷型別是否可迭代，判斷本質是看型別中是否含有_iter_()這個方法，可以使用dir檢視
示例；
lst = [1,2]
lat= 3
print(hasattr(lst,'__iter__'))
#hasattr(object，'x') 函式，用於判斷物件object是否含有x屬性或方法，有則返回True，否則返回False
print(hasattr(lat,"__iter__"))
程式執行結果：
True
False
la = ["lala","lblb"]
lb = [1,2,3]
print(la.extend(lb))#la.extend(lb)的返回值為none,同時拓展之後的記憶體位置仍然沒有改變，原地修改
print(la)
print(lb)
lc= "abcde"#當拓展引數為字串的時候，結果是將字串挨個字元拆開形成列表，然後在追加
la.extend(lc)
print(la)
程式執行結果：
None
['lala', 'lblb', 1, 2, 3]
[1, 2, 3]
['lala', 'lblb', 1, 2, 3, 'a', 'b', 'c', 'd', 'e']
append（）和extend（）區別：
append直接將所有內容整體打包什麼都不動（包括列表的[])追加在後面
extend將追加的內容先拆開（針對列表），然後合併成一個列表
- count：查詢列表中元素出現的次數
lst = [1,2,3,2,1,2,1,'a']
print(lst.count(1))
print(lst.count('a'))
程式執行結果：
3
1
- index :查詢列表中的元素（必須是完整的）在列表中第一次出現的位置
lst = [1,2,3,2,1,2,1,'a']
print(lst.index(1))
print(lst.index('a'))
程式執行結果：
0
7
- insert ：將元素新增在列表中的任意位置：
list(i,x),其中i為想插入的位置，X為插入的元素，該元素插入位置之前
lst = [1,2,'a']
lst.insert(2,"lalala")#insert()函式也是列表的原地修改，沒有返回值，或者說返回值為None
print(lst)
lst.insert(len(lst),"end") #使用len函式，將插入值放在字串的最後面
print(lst)
程式執行結果為：
[1, 2, 'lalala', 'a']
[1, 2, 'lalala', 'a', 'end']
- remove 和pop實現刪除列表中的元素
- remove ：
#remove使用方式：
# 正確就刪除第一個符合的物件，沒有返回值；對列表進行原地修改
#如果刪除的元素不在列表中，則會報錯：X not in list
lst= ["python","hello","lala",1,2]
print("hello" in lst)#可以在刪除之前先判斷該元素是否在列表中
lst.remove("hello")#同樣沒有返回值，
print(lst)
程式執行結果：
True
['python', 'lala', 1, 2]
- pop :使用方式:
list.pop([i]),其中i為所要刪除的元素的位置,實際使用的時候沒有[]，如果為空則表示刪除最後一個，返回值為刪除的元素
lst= ["python","hello","lala",1,2]
print(lst.pop(1))#刪除列表中第1個元素，返回值為第1個元素的值
print(lst)
程式執行結果：
hello
['python', 'lala', 1, 2]
- reverse :將列表的元素順序返回來，是原地反過來(原來列表的值變化)，沒有返回值,
- reversed :原來列表的值沒有變化，有返回值，但是返回值並不是list（），需要轉換為list()
lst= ["python","hello","lala",1,2]
#reverse()
lst.reverse()
print(lst)#原列表的值改變了
#reversed()
print(reversed(lst)