基本資料型別
數值型
Python 中的資料皆是物件，比如被熟知的 int 整型物件、float 雙精度浮點型、bool 邏輯物件，它們都是單個元素，舉兩個例子，
前綴加 0x，創建一個十六進制的整數：
0xa5 # 等于十進制的 165
使用 e 創建科學計數法表示的浮點數：
1.05e3 # 1050.0
另外大家也要注意：不管你是為了Python就業還是興趣愛好，記住：專案開發經驗永遠是核心，如果你沒有2020最新python入門到高級實戰視頻教程，可以去小編的Python交流.裙 ：七衣衣九七七巴而五（數字的諧音）轉換下可以找到了，里面很多新python教程專案，還可以跟老司機交流討教！
容器型
可容納多個元素的容器物件，常用的比如：list 串列物件、 tuple 元組物件、dict 字典物件、set 集合物件，Python 定義這些型別的變數，語法非常簡潔，
舉例如下，
使用一對中括號 []，創建一個 list 型變數：
lst = [1,3,5] # list 變數
示意圖看出，右側容器為開環的，意味著可以向容器中增加和洗掉元素：
image-20200218111947234
使用一對括號 ()，創建一個 tuple 型物件：
tup = (1,3,5) # tuple 變數
示意圖看出，右側容器為閉合的，意味著一旦創建元組后，便不能再向容器中增刪元素：
image-20200218112031346
但需要注意，含單個元素的元組后面必須保留一個逗號，才被解釋為元組，
tup = (1,) # 必須保留逗號
否則會被認為元素本身：
In [14]: tup=(1)
...: print(type(tup))
<class 'int'>
使用一對花括號 {} 另使用冒號 :，創建一個 dict 物件：
dic = {'a':1, 'b':3, 'c':5} # dict變數
字典是一個哈希表，下面的示意圖形象的表達出字典的 “形”，
image-20200218112256968
僅使用一對花括號 {}，創建一個 set 物件：
s = {1,3,5} # 集合變數
Python 的容器型別，list、dict、tuple、set 等能方便地實作強大的功能，下面給出幾個案例，
1. 去最求平均
去掉串列中的一個最小值和一個最大值后，計算剩余元素的平均值，
def score_mean(lst):
lst.sort()
lst2=lst[1:-1]
return round((sum(lst2)/len(lst2)),1)
lst=[9.1, 9.0,8.1, 9.7, 19,8.2, 8.6,9.8]
score_mean(lst) # 9.1
代碼執行程序，影片演示：
image-20200218112655335
2. 列印 99 乘法表
列印出如下格式的乘法表：
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
一共有 10 行，第 i 行的第 j 列等于：j*i，其中：
- i 取值范圍：
1<=i<=9 - j 取值范圍：
1<=j<=i
根據“例子分析”的語言描述，轉化為如下代碼：
In [13]: for i in range(1,10):
...: for j in range(1,i+1):
...: print('%d*%d=%d'%(j,i,j*i),end='\t')
...: print()
3. 樣本抽樣
使用 sample 抽樣，如下例子從 100 個樣本中隨機抽樣 10 個，
from random import randint,sample
lst = [randint(0,50) for _ in range(100)]
print(lst[:5])# [38, 19, 11, 3, 6]
lst_sample = sample(lst,10)
print(lst_sample) # [33, 40, 35, 49, 24, 15, 48, 29, 37, 24]
字串
注意 Python 中沒有像 C++ 表示的字符型別（char），所有的字符或串都被統一為 str 物件，如單個字符 c 的型別也為 str，
str 型別會被經常使用，先列舉 5 個被高頻使用的方法，
strip 用于去除字串前后的空格：
In [1]: ' I love python\t\n '.strip()
Out[1]: 'I love python'
replace 用于字串的替換：
In [2]: 'i love python'.replace(' ','_')
Out[2]: 'i_love_python'
join 用于合并字串：
In [3]: '_'.join(['book', 'store','count'])
Out[3]: 'book_store_count'
title 用于單詞的首字符大寫：
In [4]: 'i love python'.title()
Out[4]: 'I Love Python'
find 用于回傳匹配字串的起始位置索引：
In [5]: 'i love python'.find('python')
Out[5]: 7
舉個應用字串的案例，判斷 str1 是否由 str2 旋轉而來，
字串 stringbook 旋轉后得到 bookstring，寫一段代碼驗證 str1 是否為 str2 旋轉得到，
轉化為判斷：str1 是否為 str2+str2 的子串，
下面函式原型中，注明了每個引數的型別、回傳值的型別，增強代碼的可讀性和可維護性，
def is_rotation(s1: str, s2: str) -> bool:
if s1 is None or s2 is None:
return False
if len(s1) != len(s2):
return False
def is_substring(s1: str, s2: str) -> bool:
return s1 in s2
return is_substring(s1, s2 + s2)
測驗函式 is_rotation：
r = is_rotation('stringbook', 'bookstring')
print(r) # True
r = is_rotation('greatman', 'maneatgr')
print(r) # False
代碼執行程序，影片演示：
字串的匹配操作除了使用 str 封裝的方法外，Python 的 re 正則模塊功能更加強大，寫法更為簡便，廣泛適用于爬蟲、資料分析等，
下面這個案例實作：密碼安全檢查，使用正則運算式非常容易實作，
密碼安全要求：
- 要求密碼為 6 到 20 位；
- 密碼只包含英文字母和數字，
import re
pat = re.compile(r'\w{6,20}') # 這是錯誤的，因為 \w 通配符匹配的是字母，數字和下劃線，題目要求不能含有下劃線
# 使用最穩的方法：\da-zA-Z 滿足“密碼只包含英文字母和數字”
# \d匹配數字 0-9
# a-z 匹配所有小寫字符；A-Z 匹配所有大寫字符
pat = re.compile(r'[\da-zA-Z]{6,20}')
選用最保險的 fullmatch 方法，查看是否整個字串都匹配，
以下測驗例子都回傳 None，原因都在解釋里，
pat.fullmatch('qaz12') # 回傳 None，長度小于 6
pat.fullmatch('qaz12wsxedcrfvtgb67890942234343434') # None 長度大于 22
pat.fullmatch('qaz_231') # None 含有下劃線
下面這個字串 n0passw0Rd 完全符合：
In [20]: pat.fullmatch('n0passw0Rd')
Out[20]: <re.Match object; span=(0, 10), match='n0passw0Rd'>
自定義型別
Python 使用關鍵字 class 定制自己的類，self 表示類實體物件本身，
一個自定義類內包括屬性、方法，其中有些方法是自帶的，
類（物件）：
class Dog(object):
pass
以上定義一個 Dog 物件，它繼承于根類 object，pass 表示沒有自定義任何屬性和方法，
下面創建一個 Dog 型別的實體：
wangwang = Dog()
Dog 類現在沒有定義任何方法，但是剛才說了，它會有自帶的方法，使用 __dir__() 查看這些自帶方法：
In [26]: wangwang.__dir__()
Out[26]:
['__module__',
'__dict__',
'__weakref__',
'__doc__',
'__repr__',
'__hash__',
'__str__',
'__getattribute__',
'__setattr__',
'__delattr__',
'__lt__',
'__le__',
'__eq__',
'__ne__',
'__gt__',
'__ge__',
'__init__',
'__new__',
'__reduce_ex__',
'__reduce__',
'__subclasshook__',
'__init_subclass__',
'__format__',
'__sizeof__',
'__dir__',
'__class__']
有些地方稱以上方法為魔法方法，它們與創建類時自定義個性化行為有關，比如：
- __init__ 方法能定義一個帶引數的類；
- __new__ 方法自定義實體化類的行為；
- __getattribute__ 方法自定義讀取屬性的行為；
- __setattr__ 自定義賦值與修改屬性時的行為，
類的屬性：
def __init__(self, name, dtype):
self.name = name
self.dtype = dtype
通過 __init__，定義 Dog 物件的兩個屬性：name、dtype，
類的實體：
wangwang = Dog('wangwang','cute_type')
wangwang 是 Dog 類的實體，
類的方法：
def shout(self):
print('I\'m %s, type: %s' % (self.name, self.dtype))
注意：
- 自定義方法的第一個引數必須是 self，它指向實體本身，如 Dog 型別的實體 dog；
- 參考屬性時，必須前面添加 self，比如
self.name等，
總結以上代碼：
In [40]: class Dog(object):
...: def __init__(self,name,dtype):
...: self.name=name
...: self.dtype=dtype
...: def shout(self):
...: print('I\'m %s, type: %s' % (self.name, self.dtype))
In [41]: wangwang = Dog('wangwang','cute_type')
In [42]: wangwang.name
Out[42]: 'wangwang'
In [43]: wangwang.dtype
Out[43]: 'cute_type'
In [44]: wangwang.shout()
I'm wangwang, type: cute_type
看到創建的兩個屬性和一個方法都被暴露在外面，可被 wangwang 呼叫，這樣的話，這些屬性就會被任意修改：
In [49]: wangwang.name='wrong_name'
In [50]: wangwang.name
Out[50]: 'wrong_name'
如果想避免屬性 name 被修改，可以將它變為私有變數，改動方法：屬性前加 2 個 _ 后，變為私有屬性，如：
In [51]: class Dog(object):
...: def __init__(self,name,dtype):
...: self.__name=name
...: self.__dtype=dtype
...: def shout(self):
...: print('I\'m %s, type: %s' % (self.name, self.dtype))
同理，方法前加 2 個 _ 后，方法變為“私有方法”，只能在 Dog 類內被共享使用，
但是這樣改動后，屬性 name 不能被訪問了，也就無法得知 wangwang 的名字叫啥，不過，這個問題有一種簡單的解決方法，直接新定義一個方法就行：
def get_name(self):
return self.__name
綜合代碼：
In [52]: class Dog(object):
...: def __init__(self,name,dtype):
...: self.__name=name
...: self.__dtype=dtype
...: def shout(self):
...: print('I\'m %s, type: %s' % (self.name, self.dtype))
...: def get_name(self):
...: return self.__name
...:
In [53]: wangwang = Dog('wangwang','cute_type')
In [54]: wangwang.get_name()
Out[54]: 'wangwang'
但是，通過此機制，改變屬性的可讀性或可寫性，怎么看都不太優雅！因為無形中增加一些冗余的方法，如 get_name，
下面，通過另一個例子，解釋如何更優雅地改變某個屬性為只讀或只寫，
自定義一個最精簡的 Book 類，它繼承于系統的根類 object：
class Book(object):
def __init__(self,name,sale):
self.__name = name
self.__sale = sale
使用 Python 自帶的 property 類，就會優雅地將 name 變為只讀的，
@property
def name(self):
return self.__name
使用 @property 裝飾后 name 變為屬性，意味著 .name 就會回傳這本書的名字，而不是通過 .name() 這種函式呼叫的方法，這樣變為真正的屬性后，可讀性更好，
In [101]: class Book(object):
...: def __init__(self,name,sale):
...: self.__name = name
...: self.__sale = sale
...: @property
...: def name(self):
...: return self.__name
In [102]: a_book = Book('magic_book',100000)
In [103]: a_book.name
Out[103]: 'magic_book'
property 是 Python 自帶的類，前三個引數都是函式型別，更加詳細的討論放在后面討論裝飾器時再展開，
In [104]: help(property)
Help on class property in module builtins:
class property(object)
| property(fget=None, fset=None, fdel=None, doc=None)
如果使 name 既可讀又可寫，就再增加一個裝飾器 @name.setter，
In [105]: class Book(object):
...: def __init__(self,name,sale):
...: self.__name = name
...: self.__sale = sale
...: @property
...: def name(self):
...: return self.__name
...: @name.setter
...: def name(self,new_name):
...: self.__name = new_name
In [106]: a_book = Book('magic_book',100000)
In [107]: a_book.name = 'magic_book_2.0'
In [108]: a_book.name
Out[108]: 'magic_book_2.0'
注意這種裝飾器寫法：name.setter，name 已經被包裝為 property 實體，呼叫實體上的 setter 函式再包裝 name 后就會可寫，對于 Python 入門者，可以暫時不用太糾結這部分理論，使用 Python 一段時間后，再回過頭來自然就會理解，
小結注意：不管你是為了Python就業還是興趣愛好，記住：專案開發經驗永遠是核心，如果你沒有2020最新python入門到高級實戰視頻教程，可以去小編的Python交流.裙 ：七衣衣九七七巴而五（數字的諧音）轉換下可以找到了，里面很多新python教程專案，還可以跟老司機交流討教！
今天學習 Python 的四大基本資料型別，數值型 int、float 等；容器型 list、dict、tuple、set 等；字符型 str 與正則運算式介紹；自定義類的基本語法規則，class、屬性和方法等，
本文的文字及圖片來源于網路加上自己的想法,僅供學習、交流使用,不具有任何商業用途,著作權歸原作者所有,如有問題請及時聯系我們以作處理，
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/148136.html
標籤：Python
上一篇：python中的反射