Python之路--Python基礎1--數據類型

時間 2019-11-10

原文原文鏈接

1、變量

　　Variables are used to store information to be referenced and manipulated in a computer program. They also provide a way of labeling data with a descriptive name, so our programs can be understood more clearly by the reader and ourselves. It is helpful to think of variables as containers that hold information. Their sole purpose is to label and store data in memory. This data can then be used throughout your program.html

聲明變量：python

　　name = "Silence" #次代碼聲明瞭一個變量，變量名爲： name，變量name的值爲："Silence"git

tips：在Python中單行註釋用 #註釋內容程序員

　　多行註釋用　　　　　 '''註釋內容'''
api

變量定義的規則：安全

　　一、變量名只能是字母、數字或下劃線的任意組合app

　　二、變量名的第一個字符不能是數字ide

　　三、標識符名稱是對大小寫敏感的。例如， myname 和 myName 不是一個標識符。注意前者中的小寫 n 和後者中的大寫 N 。測試

tips：變量是標識符的例子。標識符是用來標識某樣東西的名字。優化

　　四、如下關鍵字不能聲明爲變量名：

　　['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']

變量賦值：

name = "Silence_IOT" name2 = name
print(name,name2)

2、字符編碼

　　python解釋器在加載 .py 文件中的代碼時，會對內容進行編碼（默認ascill）

　　ASCII（American Standard Code for Information Interchange，美國標準信息交換代碼）是基於拉丁字母的一套電腦編碼系統，主要用於顯示現代英語和其餘西歐語言，其最多隻能用 8 位來表示（一個字節），即：2**8 = 256-1，因此，ASCII碼最多隻能表示 255 個符號。

關於中文

　　爲了處理漢字，程序員設計了用於簡體中文的GB2312和用於繁體中文的big5。

　　GB2312(1980年)一共收錄了7445個字符，包括6763個漢字和682個其它符號。漢字區的內碼範圍高字節從B0-F7，低字節從A1-FE，佔用的碼位是72*94=6768。其中有5個空位是D7FA-D7FE。

　　GB2312 支持的漢字太少。1995年的漢字擴展規範GBK1.0收錄了21886個符號，它分爲漢字區和圖形符號區。漢字區包括21003個字符。2000年的 GB18030是取代GBK1.0的正式國家標準。該標準收錄了27484個漢字，同時還收錄了藏文、蒙文、維吾爾文等主要的少數民族文字。如今的PC平臺必須支持GB18030，對嵌入式產品暫不做要求。因此手機、MP3通常只支持GB2312。

　　從ASCII、GB23十二、GBK 到GB18030，這些編碼方法是向下兼容的，即同一個字符在這些方案中老是有相同的編碼，後面的標準支持更多的字符。在這些編碼中，英文和中文能夠統一地處理。區分中文編碼的方法是高字節的最高位不爲0。按照程序員的稱呼，GB23十二、GBK到GB18030都屬於雙字節字符集 (DBCS)。

　　有的中文Windows的缺省內碼仍是GBK，能夠經過GB18030升級包升級到GB18030。不過GB18030相對GBK增長的字符，普通人是很難用到的，一般咱們仍是用GBK指代中文Windows內碼。

3、用戶輸入

name = input("What is your name?") print("Hello ", name )

輸入密碼時，若是想要不可見（就像Linux裏面輸入密碼的時候同樣），須要利用getpass 模塊中的 getpass方法，即：

import getpass
  
# 將用戶輸入的內容賦值給 name 變量
pwd = getpass.getpass("請輸入密碼：")
  
# 打印輸入的內容
print(pwd)

tips：getpass模塊在PyCharm中很差使（程序會卡住），其餘地方絕對好使

4、.pyc文件

一、解釋型語言和編譯型語言

　　計算機是不可以識別高級語言的，因此當咱們運行一個高級語言程序的時候，就須要一個「翻譯機」來從事把高級語言轉變成計算機能讀懂的機器語言的過程。這個過程分紅兩類，第一種是編譯，第二種是解釋。

　　編譯型語言在程序執行以前，先會經過編譯器對程序執行一個編譯的過程，把程序轉變成機器語言。運行時就不須要翻譯，而直接執行就能夠了。最典型的例子就是C語言。

　　解釋型語言就沒有這個編譯的過程，而是在程序運行的時候，經過解釋器對程序逐行做出解釋，而後直接運行，最典型的例子是Ruby。

　　經過以上的例子，咱們能夠來總結一下解釋型語言和編譯型語言的優缺點，由於編譯型語言在程序運行以前就已經對程序作出了「翻譯」，因此在運行時就少掉了「翻譯」的過程，因此效率比較高。可是咱們也不能一律而論，一些解

釋型語言也能夠經過解釋器的優化來在對程序作出翻譯時對整個程序作出優化，從而在效率上超過編譯型語言。

　　此外，隨着Java等基於虛擬機的語言的興起，咱們又不能把語言純粹地分紅解釋型和編譯型這兩種。

　　用Java來舉例，Java首先是經過編譯器編譯成字節碼文件，而後在運行時經過解釋器給解釋成機器文件。因此咱們說Java是一種先編譯後解釋的語言。

二、簡述Python的運行過程

　　在說這個問題以前，咱們先來講兩個概念，PyCodeObject和pyc文件。

　　咱們在硬盤上看到的pyc天然沒必要多說，而其實PyCodeObject則是Python編譯器真正編譯成的結果。咱們先簡單知道就能夠了，繼續向下看。

　　當python程序運行時，編譯的結果則是保存在位於內存中的PyCodeObject中，當Python程序運行結束時，Python解釋器則將PyCodeObject寫回到pyc文件中。

　　當python程序第二次運行時，首先程序會在硬盤中尋找pyc文件，若是找到，則直接載入，不然就重複上面的過程。

　　因此咱們應該這樣來定位PyCodeObject和pyc文件，咱們說pyc文件實際上是PyCodeObject的一種持久化保存方式。

5、數據類型

一、數字

　　2 是一個整數的例子。
長整數不過是大一些的整數。
　　3.23和52.3E-4是浮點數的例子。E標記表示10的冪。在這裏，52.3E-4表示52.3 乘以10的-4次方。
　　(-5+4j)和(2.3-4.6j)是複數的例子，其中-5,4爲實數，j爲虛數，學過數學的人都知道。

int （整型）

　　在32位機器上，整數的位數爲32位，取值範圍爲-2**31～2**31-1，即-2147483648～2147483647
　　在64位系統上，整數的位數爲64位，取值範圍爲-2**63～2**63-1，即-9223372036854775808～9223372036854775807

tips：在Python中 ** 表示冪，例如2**32表示2的32次冪

long（長整型）

　　跟C語言不一樣，Python的長整數沒有指定位寬，即：Python沒有限制長整數數值的大小，但實際上因爲機器內存有限，咱們使用的長整數數值不可能無限大。　　注意，自從Python2.2起，若是整數發生溢出，Python會自動將整數數據轉換爲長整數，因此現在在長整數數據後面不加字母L也不會致使嚴重後果了。

float（浮點型）

先掃盲 http://www.cnblogs.com/alex3714/articles/5895848.html
　　浮點數用來處理實數，即帶有小數的數字。相似於C語言中的double類型，佔8個字節（64位），其中52位表示底，11位表示指數，剩下的一位表示符號。

complex（複數）

　　複數由實數部分和虛數部分組成，通常形式爲x＋yj，其中的x是複數的實數部分，y是複數的虛數部分，這裏的x和y都是實數。

注：Python中存在小數字池：-5 ～ 257

二、布爾值

　　真或假

　　1 或 0

　　True 或 False

三、字符串

特性：不可修改

username = input("username:") password = input("password:") age = int(input("age:"))  #強制類型轉換
print(type(age)) info = ''' ------username %s------- username:%s password:%s age:%d ''' % (username, username, password, age) info2 = ''' ------username2 {_username}------- username:{_username} password:{_password} age:{_age} '''.format(_username = username, _password = password, _age = age) info3 = ''' ------username3 {0}------- username:{0} password:{1} age:{1} '''.format(username, password, age) print(info3)

print("{0}dada{1}".format(name, age))

ID = "001"
print("2015", ID, "3921") #這樣也能夠

我的推薦使用info3方式的格式打印！！！

字符串經常使用功能：

name = "my name is Silence_IOT"

print(name.capitalize())        #首字母大寫
print(name.count('i'))          #求個數
print(name.center(50, '-'))     #總共50個字符，把原字符串放中間，兩邊用-補齊
print(name.endswith("ei"))      #判斷是否是以「ei」結尾
print(name.find("name"))        #返回索引
print(name[3:9])                #切片 返回第3個字符到第8個字符
print(name[3:])                 #切片 返回從第3個字符到結束


#print(name[name.find("name"):]) #切片 #print(name.expandtabs(tabsize=30)) #
 names = "my \tname is {name},{years} old"
print(names.format(name='alex', years=18)) print(names.format_map({"name": "Silence_IOT", 'years': '18'})) #單引號、雙引號沒多大區別



print("123ad".isalnum())        #判斷是否爲字母加數字
print("ad".isalpha())           #判斷是否爲純英文字母

print("_ad".isidentifier())     #判斷是否爲合法標識符

print("123".isnumeric()) print("1".isdigit())            #判斷是否爲純數字，有小數點都不行

print("123".isdecimal())        #判斷是否爲純十進制數字

print("My Name Is".istitle())   #判斷是否爲標題，即每一個單詞第一個是否大寫

print("MY NAME".isupper())      #判斷是否都是大寫

print("+".join(["asd", '2', '3']))      #結果asd+2+3

print(name.ljust(30, '+'))              #結果my name is yanglei+++++++++++
print(name.rjust(30, '-'))              #結果-----------my name is yanglei

print(name.lower())              #所有變小寫
print(name.upper()) print("1 \nAlex".lstrip())       #從左邊開始去掉空格和回車
print("Alex \n1".rstrip())       #從右邊開始去掉空格和回車
print(" \nAlex \n".strip())    #去掉空格和回車
 p = str.maketrans("adcdefghij", "0123456789")   #加密
print(name.translate(p))                        #結果my n0m4 8s y0n6l48

print("alex li".replace('li', 'L', 1))          #替換 #結果aLex Li

print("alex li".rfind('l'))          #查找最右邊出現的那個元素的下標值 #結果5
print("alex li".find('l')) print("alex-li".split('-'))          #分割 #結果 ['alex', 'li']
print("al20ex\nli".splitlines())       #按換行符分割 #結果 ['alex', 'li']

print("Alex-Li".swapcase())          #大小寫反轉 #結果 aLEX-lI

print("alex li".title())             #把字符串變成title #結果 Alex Li

print("alex li".zfill())           #結果 0000000000000alex li

四、列表

建立列表：name_list = ['alex', 'seven', 'eric']

　　　　　　　　　　或

　　　　　　name_list ＝ list(['alex', 'seven', 'eric'])

列表基本操做：

import copy #列表能夠多層嵌套
names = ["YangLei", "ZhangYang",["YL", ["001010"], "OP"],  "LiJie", "GuYun", "123"] #增
names.append("Leijun")        #插入列表最後面
names.insert(1, "MaYun")      #將「MaYun」插入到下標爲1的位置上

#刪
names.remove("GuYun")                #刪除"GuYun"這一項 #del names[2] <--> names.pop(2) #帶下標數字二者相等
names.pop()                          #不帶下標數字，刪除列表最後一個元素


#修改
names[2] = "123"

#查找
print(names) print(names.index("123"))           #查找某元素的位置 #print(names[names.index("123")])
print(names.count("123"))           #查找某元素的數量 （列表裏面的元素能夠相同）
 list = [1, 33, 44, 456, 33] list.reverse() #反轉列表元素的順序
print(list)         #[33, 456, 44, 33, 1]
list.sort()                #排序,按照Ascll碼排序
print(list)         #[1, 33, 33, 44, 456]
 names2 = [1,2,3,4] list.extend(names2) #把集合names添加到集合list 裏面
print(list)                #[1, 33, 33, 44, 456, 1, 2, 3, 4]
 list2 = ["YangLei", "ZhangYang",["YL", ["001010"], "OP"],  "LiJie", "GuYun", "123"] #names3 = copy.deepcopy(names)  #深copy，數據所有不共享，就是徹底複製一份獨立的數據 要import copy模塊
names3 = list2.copy()           #淺copy，數據半共享，只複製第一層數據,第一層數據不變，深層的數據仍是引用原始數據
list2[1] = "11111111" list2[2][1] = "22222"
print(list2)     #['YangLei', '11111111', ['YL', '22222', 'OP'], 'LiJie', 'GuYun', '123']
print(names3)    #['YangLei', 'ZhangYang', ['YL', '22222', 'OP'], 'LiJie', 'GuYun', '123']
 list3 = [1, 44, 44, 545, 246, 4566, 55] print(list3[0:-1:2])         #切片[起始位置：結尾位置：間隔項數(n-1)] [1, 44, 246]
print(list3[::3])            #每隔2項去一次 [1, 545, 55]
print(list3[-1])             #打印倒數第1個 55
print(list3[0], list3[3])    #打印第一個和第三個 1 545
print(list3[0:3])   #切片 顧頭不顧尾原則  [1, 44, 44]
print(list3[1:3])   #切片 [44, 44]

print(list3[-3:-1])   #還能倒着切 [246, 4566]
print(list3[-3:])     #切片 [246, 4566, 55]

五、元組

俗稱不可變列表

建立元組：

ID = (11, 22, 33, 44, 55) 或 ID = tuple((11, 22, 33, 44, 55))

它只有2個方法，一個是count,一個是index，完畢。

六、字典

字典一種key - value 的數據類型，使用就像咱們上學用的字典，經過筆劃、字母來查對應頁的詳細內容。

字典的特性：

dict是無序的
key必須是惟一的,so 天生去重

person = {"name": "mr.wu", 'age': 18} 或 person = dict({"name": "mr.wu", 'age': 18})

字典的基本操做：

info = { 'stu001': "LeiJun", "stu002": "MaYun", 'stu003': "Alex" } for i in info: print(i, info[i])  #最推薦使用的，循環打印字典


''' for k,v in info.items(): print(k,v) ''' b = { "stu001": "Alex", 1: 2, 3: 5 } info.update(b) #將字典b更新到字典info
print(info)     #{3: 5, 1: 2, 'stu002': 'MaYun', 'stu001': 'Alex', 'stu003': 'Alex'}

print(info.items())#dict_items([(3, 5), (1, 2), ('stu002', 'MaYun'), ('stu001', 'Alex'), ('stu003', 'Alex')])
 c = dict.fromkeys([1, 2, 3], "test")  #初始化新字典，1,2,3共享一個內存地址，value都是「test」
print(c)     #{1: 'test', 2: 'test', 3: 'test'}
 dict1 = { "stu001": "YL", 1: 2, 3: 5 } print(dict1.keys())          #打印全部的keys dict_keys([3, 1, 'stu001'])
print(dict1.values())        #打印全部的values dict_values([5, 2, 'YL'])

#首先查找，stu004,如有則返回原來字典裏面stu004對應的value，沒有則建立一個鍵值對，並返回值
print(dict1.setdefault("stu004", "YL")) #YL
print(dict1)  #{'stu001': 'YL', 'stu004': 'YL', 3: 5, 1: 2}
 dict1["stu001"] = "LJ"           #有Key，則修改value
dict1["stu005"] = "1234565"      #無Key，則建立新的鍵值對
print(dict1)    #{'stu005': '1234565', 1: 2, 'stu004': 'YL', 3: 5, 'stu001': 'LJ'}

#del dict1["stu001"] #刪除
dict1.pop("stu005") print(dict1) dict1.popitem() #隨便刪除一個
print(dict1) #print(dict1["stu002"]) #沒有就報錯 print(dict1.get("stu006")) #沒有就返回None 安全獲取的方法

print("stu006" in dict1)        #查找是否有stu003,有就返回True

七、集合

集合是一個無序的，不重複的數據組合，它的主要做用以下：

去重，把一個列表變成集合，就自動去重了
關係測試，測試兩組數據以前的交集、差集、並集等關係

集合經常使用操做：

list_1 = [1, 4, 5, 4, 7, 3, 6, 7, 6] list_1 = set(list_1)         #將列表轉換爲集合
list_2 = set([1, 5, 7, 6, 9, 11, 33])   #建立一個數值集合， 集合是無序的
list_5 = set("Hello")         #建立一個惟一字符的集合


print(list_1.intersection(list_2))  #求交集
print(list_1 & list_2)              #交集


print(list_1.union(list_2))         #求並集
print(list_1 | list_2)              #並集


print(list_1 - list_2)              #差集
print(list_1.difference(list_2))    #求差集 list_1中有，list_2中沒有的元素
print(list_2.difference(list_1)) list_3 = set([1, 3, 7]) print(list_3.issubset(list_1))      #判斷list_3是否是list_1的子集
print(list_1.issuperset(list_3))    #判斷list_1是否是list_3的父集


#並集-差集=對稱差集
print(list_1.symmetric_difference(list_2))  #項在兩個集合中，但不會同時出如今兩者中
print(list_1 ^ list_2)                      #對稱差集 項在兩個集合中，但不會同時出如今兩者中
 list_4 = set([2, 4, 6]) print(list_3.isdisjoint(list_4))   #若是兩個集合沒有交集返回 True


#print(list_1.add(999)) 錯誤的寫法
list_1.add(999)                 #添加一個項
list_1.update([123, 345, 455])  #添加多個項
print(list_1)