[資料型別]
* [數值]
* [整數]
* [浮點數]
* [簡單數學函式]
* [隨機函式]
* [三角函式]
* [布爾型別]
* [字串]
* [串列]
* [元組]
* [字典]
### Python資料型別
#### 數值
##### 整數
```
# 二進制
n1 = 0b1010
# 八進制
n2 = 0o567
# 十六進制
n3 = 0xfdc2
```
##### 浮點數
```
# 一般形式
n1 = 3.14
# 科學計數法
n2, n3 = 3.2e6, 1.2e-3
```
##### 簡單數學函式
* 內建函式
* **abs(num)**:
```
# 回傳數的絕對值
n1, n2, n3 = 1, 0, -1
print(abs(n1), abs(n2), abs(n3)) # 1 0 1
```
* **max(num)** 和 **min(num)**:
```
# 引數不定長
n1, n2, n3, n4 = 1, 2, 3, 4
print(max(n1, n2), min(n2, n3 , n4)) # 2 4
# 接收可迭代物件
li = [1, 2, 3, 4]
print(max(li)) # 4
```
* **round(num, n])**:
```
# 四舍五入
# n表示四舍五入的小數位數，不寫默認是0(取整)
pi = 3.14159
print(round(pi)) # 3
print(round(pi, 3)) #3.142
```
* math模塊中的函式
* **ceil()**:
```
# 用來向上取整
import math
pi = 3.14159
print(round(pi)) # 3
print(math.ceil(pi)) # 4
print(round(pi + 0.5)) # 可以替代ceil()
```
* **floor()**:
```
# 用來向下取整
import math
x = 3.678
print(round(x)) # 4
print(math.floor(x)) # 3
print(floor(x - 0.5)) # 可以替代floor()
```
* **sqrt()**:
```
# 平方根運算
import math
print(math.sqrt(16)) # 4
print(math.sqrt(17)) # 4.123105635
```
##### 隨機函式
* **random()**:
```
import random
print(random.random()) # 生成[0, 1)的一個小數
```
* **choice(seq)**:
```
import random
li = [1, 2, 4, 5]
print(random.choice(li)) # 從對應的串列中隨機選擇一個元素
```
* **uniform(x, y)**:
```
import random
print(random.uniform(1, 3) # 得到[1, 3]之間的隨機小數
```
* **randint(x, y)**:
```
import random
print(random.randint(1, 5)) # [1, 5]之間的隨機整數
```
* **randrange(start, stop, step)**:
```
import random
print(random.randrange(2, 10, 2) # 引數型別與range()函式一樣
# 相當于random.choice([2, 4, 6, 8])
```
##### 三角函式
```
import math
angle = 1 / 6 * math.pi # 30°, pi/6
res1 = math.sin(angle) # 接識訓度值
angle = math.radians(30) # 將角度值轉換為弧度值
res1 = math.cos(angle)
```
#### 布爾型別
* 是`int`的子型別
```
# True = 1, False = 0
# 可以與整數進行運算
print(2 + True) # 3
print(1 + False) # 1
```
* 是一種單獨的型別
```
flag, tag = True, False
```
* 當作判定條件使用
```
if True:
# todo
```
#### 字串
##### 字串表示方式
```
str = 'abc' # 單引號對
str = "abc" # 雙引號對
str = '''abc''' # 三個單引號
str = """abc""" # 三個雙引號
# 混合表示，去掉字串兩端的限制符號就得到字串資料
# 可以避免使用引號的轉義來表示引號
str = "his name is 'rity', that is a good name"
# 使用轉義字符來完成
str = "his name is \'rity\', that is a good name"
# 消除字串的轉義
str1 = "That\'s all"
str2 = r"That\'s all"
print(str1) # That's all
print(str2) # That\'s all
# 字串的跨行表示
str = "his name is 'rity', " \
"that is a good name"
str = ("his name is 'rity', "
"that is a good name")
"""
可以直接在三對雙引號內進行換行
多用于程式的注釋
---end---
"""
```
##### 字串的操作
* 一般操作
* 字串拼接
```
res1 = "abc" + "def"
print(res1) # abcdef
res2 = "abc" "def"
print(res2) # abcdef
res3 = "%s%S" % ("abc", "def")
print(res3) # abcdef
```
* 字串的乘法
```
res = "a" * 3
print(res) # aaa
```
* 字串的切片
```
str = "abcdefg"
# 獲得單個字符
print(str[3]) # d
print(str[-1]) # g
# 獲得字串片段
# str[start:end:step]
# 默認值：start=0, end=len(str), step=1
# 獲得范圍 [start, end)
print(str[::]) # abcdefg
print(str[0:len(str):1]) # agcdefg
print(str[::2]) #aceg
print(str[::-1]) #gfedcba
```
* 函式操作
* **len()**:
```
# 可用于所有可迭代物件
# 計算字串中字符的個數
name1， name2 = "rity", "瑞迪"
print(len(name1), len(name2)) # 4 2
```
* **find()**:
```
# 查找子串的索引
# find(substr, start, end)
# 默認值：start=0, end=len(str)
str = "abcdabefg"
print(str.find("ab")) # 0
print(str.find("ab", 1)) # 4
print(str.find("xy")) # -1
```
* **count()**:
```
# 計算子字串出現的個數
# count(sub, start, end)
# 默認值：start=0, end=len(str)
str = "abcda"
print(str.count("a")) # 2
print(str.count("a", 2) # 1
print(str.count("x")) # 0
```
* **replace()**:
```
# 用給定的新字串替換舊的字串
# replace(old, new, count)
# 默認值：count(省略)，全部替換
str = "abacad"
print(str.replace("a", "A")) #AbAcAd
print(str.replace("a", "A", 2)) #AbAcad
print(str) # abacad
```
* **ljust() 和 rjust()**:
```
# 對字串進行長度調整(擴長)
# ljust(width, fillchar)
# width:要擴展到的長度，fillchar:填充的字符
str = "abc"
print(str.ljust(6, "x")) # abcxxx
print(str.rjust(6, "x")) # xxxabc
print(str) # abc
```
* **lstrip() 和 rstrip() 和 strip()**
```
# 移除字串指定位置的字符
# lstrip(str)
# 默認值：str是空字符集
name = "xi am rity ."
print(name.lstrip("ix")) # | am rity .|
print(name.rstrip(". ") # |xi am rity|
print(name.strip("ix.")) # | am rity |
```
* **split()**:
```
# 將父字串分割成幾個子字串
# split(sep, maxsplit)
# sep:要分割的字符，maxsplit：最大分割次數
# 默認值：maxsplit(省略)，全部分解
# 回傳字串串列
info = "rity,nanchang,158-7926-7420"
res = info.split(",")
print(res) # ['rity', 'nanchang', '158-7926-7420']
```
* **partition()**:
```
# 把整個字串分三部分
# partition(sep)
# 從左往右找
# 回傳一個元組(分隔符左側， 分隔符， 分隔符右側)
pi = 3.14159
res1 = pi.partition(".")
res2 = pi.partition("-")
print(res1) # ('3', '.', '14159')
print(res2) # ('3.14159', '', '')
```
* **join()**:
```
# 用指定的字串，對可迭代引數進行拼接，回傳字串
# "xx".join(iterable)
# 與split()的作用相反
li = ["137", "9878", "0098"]
res1 = "-".join(li)
res2 = "".join(li)
print(res1) # 137-9878-0098
print(res2) # 13798780098
```
* **isalpha(), isdigit(), isalnum()**
```
str1, str2, str3, str4, str5 = "agcD", "123", "2j3e4ef", ""
print(str1.isalpha()) # True
print(str2.isdigit()) # True
print(str4.isalnum()) # True
print(str5.isalpha(), str5.isdigit(), str5.isalnum()) # False False False
```
* **startswith() 和 endswith()**
```
# 是否以某個前綴開頭/結尾,范圍 [start, end)
# startswith("xx", start, end)
# 默認值：start=0, end=len(str)
name = "2018-08-09: xxx報告"
file = "xxx.md"
print(name.startswith("2018")) # True
print(file.endswith(".md")) # True
```
#### 串列
有序可變元素的集合
##### 表示方式
```
# 元素型別單一
li = ["a", "b", "c"]
# 多種型別的元素
li = ["a", "b", 1, 2, True]
# 串列可以相互嵌套
li = [[1, 2, 3], 2, True, "hehe"]
# list()函式，引數為可迭代物件
li = list(range(1, 4)) # [1, 2, 3]
li = list("abc") # ('a', 'b', 'c')
# 串列推導
nums = [1, 2, 3, 4, 5]
li = [n*n for n in nums if n % 2]
print(li) # [1, 9, 25]
```
##### 常用操作
* **append()**:
```
# 向串列的尾部添加元素
nums = [1, 2, 3, 4]
nums.append(5)
print(nums) # [1, 2, 3, 4, 5]
```
* **insert**:
```
# 向串列中的任意位置插入元素
nums = [1, 2, 3, 4]
nums.insert(1, 9)
print(nums) # [1, 9, 2, 3, 4]
```
* **extend()**:
```
# 合并兩個串列
nums1, nums2 = [1, 2], [3, 4]
nums1.extend(nums2)
print(nums1) # [1, 2, 3, 4]
```
* **del陳述句**:
```
nums = [1, 2, 3]
del nums[0]
print(nums) # [2, 3]
# del用來洗掉所參考的物件
```
* **pop()**:
```
# 移除并回傳串列中指定索引的元素
# pop(index)
# 默認值：index(不寫)，洗掉回傳最后一個
nums = [1, 2, 3]
res = nums.pop()
print(nums, res) # [1, 2] 3
```
* **remove()**:
```
# 移除串列中指定的元素
# remove(obj)
# 若元素不存在會報錯，若有多個元素，洗掉最左邊的那個
names = ["Rity", "Jack", "Tom"]
names.remove("Jack")
print(names) # ["Rity", "Tom"]
# 遍歷洗掉元素會出現錯誤
# 元素洗掉后影響了串列的結構，進而影響了遍歷的程序
nums = [1, 2, 2, 3, 4, 2]
for n in nums:
if n == 2:
nums.remove(n)
print(nums) # [1, 3, 4, 2]
```
* **index()**:
```
# 獲得元素所在的索引值,查找范圍：[start, end)
# index(obj, start, end)
# 默認值：start=0, end=len(list)
li = [12, 34, 99]
idx = li.index(34)
print(idx) # 1
```
* **count()**:
```
# 獲得其中某個元素的個數
li = [1, 1, 2, 3, 5]
print(li.count(1)) # 2
```
* **切片**：參考字串切片
* **串列遍歷**：
```
# 索引問題
val = ["a", "b", "a", "d"]
currentIdx = 0 # 解決index("a")恒為0的問題
for v in val:
idx = val.index(v, currentIdx)
print(idx, v)
currentIdx += 1
# 建立索引串列
idxList = list(range(0, len(val)))
for idx in idxList:
print(idx, val[idx])
# 利用列舉物件
val = ["a", "b", "c", "d"]
print(list(enumerate(val))) # [(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]
for idx, val in enumerate(val):
print(idx, val)
```
* **排序**
```
# ----------------------------------------
# 使用內建函式 sorted()，可以對所有可迭代物件排序
# sorted(itrearble, key=None, reverse=False)
# 不改變原物件，以串列的形式回傳處理后的結果
# 默認按照升序排列
s = "acgehijd"
res = sorted(s)
print(res) # ['a', 'c', 'd', 'e', 'g', 'h', 'i', 'j']
print(sorted(s), reverse=True) # ['j', 'i', 'h', 'g', 'e', 'd', 'c', 'a']
# 指定關鍵字進行排序
def getKey(x):
return x[1]
li = [("s0", 18), ("s1", 17), ("s2", 16)]
res0, res1 = sorted(li), sorted(li, key=getKey)
print(res0) # [("s0", 18), ("s1", 17), ("s2", 16)]
print(res1) # [("s2", 15), ("s1", 17), ("s0", 18)]
# -----------------------------------------
# 使用串列的物件方法
# 直接修改原物件
# 引數串列與 sorted()相同
li = [1, 3, 5, 2, 0]
li.sort()
print(li) # [0, 1, 2, 3, 4, 5]
```
* **亂序**
```
# 打亂串列中元素的順序
# 直接修改原物件
import random
li = [1, 2, 3, 4, 5]
random.shuffle(li)
print(li) # [2, 4, 3, 1, 5]
```
* **反轉**
```
# 使用reverse()直接修改原物件
li = [1, 2, 4, 0]
li.reverse()
print(li) # [0, 4, 2, 1]
# 使用切片操作獲得新的物件
li = ["ss", "yu", "sfj"]
res = li[::-1]
print(li, res) # ["ss", "yu", "sfj"] ['sfj', 'yu', 'ss']
```
#### 元組
有序的**不可變**的元素集合，**切片**和根據索引獲得單個元素的方式和串列相同，
##### 表示方法
```
# 單元組
t = (1,)
# 多元組
t1, t2 = (1, 2), (2, 3, 9, 0)
# 復合元組
t = ("abc", [1, 2], 666)
# 嵌套元組
t = ("rity", (18, "nanchang"))
# tuple()函式，用法與list()相同
```
##### 拆包操作
```
t = (1, 2, 3)
a, b, c = t
print(a, b, c) # 1 2 3
```
#### 字典
**無序**、**可變**的**鍵值對**的集合
##### 表示方式
* key不能重復，若有重復，后定義的覆寫前面定義的
* key的型別必須是不可變的型別
* **可變**型別（串列，字典，可變集合）
* **不可變**型別（數值，布爾，字串，元組）
* `Python`的字典是通過哈希（hash）的方式實作的，計算鍵的哈希值，存盤在哈希表中，
```
person = {"name": "rity", "age": 18}
print(person, type(person)) # {'name': 'rity', 'age': 18} <class 'dict>'
print(person["name"]) # rity
print(person["age"]) # 18
d = dict.fromkeys("abc", 666)
print(d) # {'a': 666, 'b': 666, 'c':666}
```
##### 添加元素
```
d = {"name": "s1", "age": 18}
d["height"] = 175
d["height"] = 180 # 若鍵已經存在，則會修改原來對應的值
# 多次列印的結果可能不同，因為字典是無序的
print(d) # {'age': 18, 'name': 's1', 'height': 175}
# 使用 d0.update(d1)
# 將兩個字典合并，若舊字典中有對應的 key，則更新；否則添加
d.update({"year": 1997, "height":180})
```
##### 洗掉元素
```
d = {"name": "s1", "age": 18}
# 使用 del直接洗掉鍵值
# 洗掉不存在的鍵值對會直接報錯
del d["name"]
print(d) # {"age": 18}
del d["name1"] # KeyError: 'name1'
# dic.pop()
# 洗掉指定的鍵值對，并回傳對應的值
# 洗掉不存在的鍵值對會直接報錯
v = d.pop("age")
print(v, d) # 18 {'name': 's1'}
# dic.popitem()
# 洗掉按升序排序后的第一個鍵值對，并以元組的形式回傳鍵值對
# 字典為空報錯
res = d.popitem()
print(res) # ('age', 18)
# dic.clear()
# 清空字典，空字典，不是未定義的物件
d.clear()
print(d) # {}
del d
print(d) # 報錯
```
##### 獲得元素
```
d = {"name":"Rity", "age": 18}
# 下標訪問
print(d["name"]) # Rity
print(d["height") # 報錯，鍵不存在
# dic.get(key, default)
# 鍵不存在不會報錯，default是鍵不存在時的回傳值，默認為 None
print(d.get("age")) # 18
print(d.get("height")) # None
print(d.get("height", 170) # 170
```
##### 遍歷
```
d = {"name":"Rity", "age": 18}
#-------------------------------------
# 下面三種方法回傳的是一個 Dictionary view objects, 雖然以串列的形式展現，但嚴格來說不是串列
# 不支持索引訪問，但可以使用 list()來轉換成普通的串列物件
# 特點：當字典被修改后，以下 ks, vs, itms會同步修改
# 獲取所有的鍵
ks = d.keys()
print(ks) # dict_values(['Rity', 18])
# 獲取所有的值
vs = d.values()
print(vs) # dict_keys(['name', 'age'])
# 獲取所有的鍵值對
itms = d.items()
print(itms) #dict_items([('name', 'Rity'), ('age', 18)])
#-------------------------------------
# 字典是可迭代物件，使用 for in
# 若直接遍歷字典，得到的是它的鍵
for x in d.items():
print(k, end=' ') # ('name':'Rity') ("age":18)
# 元組解包
for k, v in d.items():
print(k, v, sep='-') # name-Rity age-18
```
##### 推薦一下我建的python學習交流扣扣qun：850973621，群里有免費的視頻教程，開發工具、
##### 電子書籍、專案原始碼分享，一起交流學習，一起進步！
作者：MetaT1an
鏈接：https://www.jianshu.com/p/ef02257bd191
來源：簡書
著作權歸作者所有，商業轉載請聯系作者獲得授權，非商業轉載請注明出處，
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/232297.html
標籤：Python
上一篇：python實戰筆記（一）
下一篇：python實戰筆記（三）