Python 是一種跨平台的計算機程序設計語言，是一種面向對象的動態類型語言，筆記內容包括編譯安裝python，python列表，字典，元組，文件操作等命令的基本使用技巧。
◆編譯安裝 Python◆
Python的開發環境安裝和配置非常的簡單,如果是Linux系統則會默認集成安裝了Python環境,Python的可執行文件被放在了/usr/local/bin目錄下,庫函數被安裝在了/usr/local/python 目錄中,由於二進制安裝非常簡單,故此處將使用源碼的方式來編譯安裝Python解釋器.
1.首先安裝gcc編譯器,和編譯Python所需要使用的相關依賴包.
[root@localhost ~]# yum -y install gcc zlib zlib-devel openssl openssl-devel libffi-devel wget
Package gcc-4.8.5-36.el7.x86_64 already installed and latest version
Package zlib-1.2.7-18.el7.x86_64 already installed and latest version
Package zlib-devel-1.2.7-18.el7.x86_64 already installed and latest version
Package openssl-1.0.2k-16.el7.x86_64 already installed and latest version
Package openssl-devel-1.0.2k-16.el7.x86_64 already installed and latest version
Package libffi-devel-3.0.13-18.el7.x86_64 already installed and latest version
Nothing to do
2.下載Python源代碼,然后依次執行nmake命令完成整個編譯過程,等待時間較長這里直接略過.
[root@localhost ~]# yum install -y readline
[root@localhost ~]# wget https://www.python.org/ftp/python/3.8.0/Python-3.8.0.tgz
[root@localhost ~]# tar -xzvf Python-3.8.0.tgz -C /usr/src/
[root@localhost ~]# cd /usr/src/Python-3.8.0/
[root@localhost ~]# ./configure --prefix=/usr/local/python3
[root@localhost ~]# make && make altinstall
3.將Python的頭文件拷貝到系統標准目錄下,避免直接使用Python時找不到所需的頭文件.
[root@localhost ~]# cd /usr/local/python3/include/python3.8
[root@localhost ~]# cp -a ./* /usr/local/include/
4.接着我們備份一下舊版本的Python,並創建符號鏈接鏈接到新版本的Python上面.
[root@localhost ~]# cd /usr/bin/
[root@localhost bin]# mv python python.old
[root@localhost bin]# ln -s /usr/local/python3/bin/python3.8 /usr/local/bin/python
[root@localhost bin]# cp -a /usr/local/python3/bin/python3.8 /usr/bin/python
5.由於YUM倉庫是用Python開發,這里為了避免Python2與Python3之間沖突需替換一下.
[root@localhost ~]# vim /usr/bin/yum
#!/usr/bin/python2.7 ←此處將python改成python2.7
[root@localhost ~]# vim /usr/libexec/urlgrabber-ext-down
#!/usr/bin/python2.7 ←此處將python改成python2.7
6.最后測試Python新版本是否生效,然后再使用YUM命令看是否有效,我這里一切正常.
[root@localhost bin]# python
Python 3.8.0 (default, Nov 9 2019, 01:48:59)
[GCC 4.8.5 20150623 (Red Hat 4.8.5-39)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> exit()
7.安裝pip包管理工具,該工具提供了對Python包的查找、下載、安裝、卸載的功能.
[root@localhost ~]# curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py
[root@localhost ~]# python get-pip.py
[root@localhost ~]# echo "alias pip=\"/usr/local/python3/bin/pip\"" >> /etc/profile
[root@localhost ~]# pip --version
pip 19.3.1 from /usr/local/python3/lib/python3.8/site-packages/pip (python 3.8)
將Python打包為EXE: 我們安裝pyinstaller工具,看能不能打包出獨立的可執行文件.
[root@localhost ~]# pip install pyinstaller
[root@localhost ~]# pip show pyinstaller
[root@localhost ~]# pyinstaller -F ./lyshark.py
[root@localhost ~]# pyinstaller -F -w -i lyshark.ico lyshark.py # -w :不提示控制台
將Python編譯為EXE: 通過使用Cython可以將Python編譯為exe可執行程序,注意是編譯並不是打包.
C:/> python -m cython -3 --embed -o lyshark.c lyshark.py
C:/> cl /c /nologo /Ox /MD /W3 /GS- /DNDEBUG -I"D:\python\include" /Tc lyshark.c /DWIN32
C:/> link lyshark.obj /SUBSYSTEM:CONSOLE /MACHINE:X64 /LIBPATH:"D:\python\libs"
C:/> link lyshark.obj /SUBSYSTEM:WINDOWS /MACHINE:X64 /LIBPATH:"D:\python\libs" /ENTRY:"wmainCRTStartup"
將Python編譯為ELF: ELF是Linux系統下的文件運行格式,我們可以Python編譯為ELF文件.
[root@localhost ~]# yum install -y epel-release
[root@localhost ~]# yum install -y python-pip
[root@localhost ~]# yum install -y python-dev*
[root@localhost ~]# pip install cython
[root@localhost ~]# cython lyshark.py --embed
[root@localhost ~]# gcc `python-config --cflags` `python-config --ldflags` lyshark.c -o lyshark
◆Python 輸入輸出◆
輸入與輸出是任何一門編程語言中都存在的東西,計算機的本質也就是輸入輸出,在學習Python之前,必須要先學會輸入輸出,Python的輸入輸出非常簡單,輸入的話直接使用input函數,輸出的話就是print函數.
標准輸入的用法: 默認接收都視為字符串,如果需要數字則需要另外強制轉換為int()轉換為數字.
>>> name = input("請輸入你的名字:")
請輸入你的名字:lyshark
>>> print("Hello " + name)
Hello lyshark
>>> age = input("請輸入你的年齡:")
請輸入你的年齡:22
>>> type(age)
<class 'str'>
>>> age1 = input("請輸入你的年齡:")
>>> age1 = int(age1) #此處強制類型轉換
>>> type(age1)
<class 'int'>
密碼輸入專用方法: 輸入密碼時,需要利用getpass模塊中的getpass方法,即:
import getpass
# 將用戶輸入的內容賦值給 pwd 變量
pwd = getpass.getpass("請輸入密碼：")
請輸入密碼：
# 打印輸入的內容
print(pwd)
簡單格式化輸出: 通過使用print函數,我們可以實現簡單的格式化輸出.
>>> string = "hello lyshark"
>>> print(string)
hello lyshark
>>> print(string,) # 不讓其自動換行
>>> print('hello', end = " ")
>>>
>>> string = "the length of (%s) is %d" %("hello lyshark",len("hello lyshark"))
>>> print(string)
the length of (hello lyshark) is 13
>>>
>>> string = "hello {} --> age {}".format("lyshark",22)
>>> print(string)
hello lyshark --> age 22
>>>
>>> string = "i am %(age).2f" %{"age":22}
>>> print(string)
i am 22.00
格式化轉換輸出: 格式化輸出十進制,十六進制,八進制.
>>> import math
>>> nHex=0x20
>>> print("十六進制=%x,十進制=%d,八進制=%o"%(nHex,nHex,nHex))
十六進制=20,十進制=32,八進制=40
>>>
>>> print("PI=%F"%math.pi)
PI=3.141593
>>> print("PI=%10.2f"%math.pi)
PI= 3.14
>>> print("PI=%-10.2f"%math.pi)
PI=3.14
格式化format的詳細用法:
>>> print("i am {0}, age {1}, really {0}".format("lyshark",22))
i am lyshark, age 22, really lyshark
>>>
>>> print("i am {name}, age {age}".format(**{"name":"lyshark","age":"22"}))
i am lyshark, age 22
>>>
>>> temp = "i am {0[0]}, age {0[1]}, really {0[2]}".format([1, 2, 3], [11, 22, 33])
>>> print(temp)
i am 1, age 2, really 3
>>>
>>> temp = "i am {:s}, age {:d}, money {:f}".format("lyshark", 18, 8.1)
>>> print(temp)
i am lyshark, age 18, money 8.100000
>>>
>>> temp = "%r %r %r %r"
>>> print(temp%(1,2,3,4))
1 2 3 4
>>>
>>> print("網站名稱:{name},地址:{url}".format(name="myblog",url="www.baidu.com"))
網站名稱:myblog,地址:www.baidu.com
>>>
>>> site={"name":"myblog","url":"www.baidu.com"}
>>> print("網站名稱:{name} 地址:{url}".format(**site))
網站名稱:myblog 地址:www.baidu.com
>>>
>>> my_list = ['myblog','www.baidu.com']
>>> print("網站名稱:{0[0]},地址:{0[1]}".format(my_list))
網站名稱:myblog,地址:www.baidu.com
◆Python 簡單運算◆
運算符用於執行程序代碼運算,會針對一個以上操作數項目來進行運算,在Python中運算符大致可以分為7種類型:算術運算符、比較運算符、賦值運算符、邏輯運算符、位運算等,下面的例子將依次介紹這幾種運算符的使用技巧.
算數運算符: 用來處理四則運算的符號,所有編程語言都會使用到算術運算符號.
>>> num1 = 10
>>> num2 = 20
>>>
>>> num1 + num2
30
>>> num1 - num2
-10
>>> num2 % num1 # 取模:返回除法的余數
0
>>> num2 // num1 # 取整:返回商的整數部分
2
>>> num1 ** num2 # 冪符:返回num1的num2次冪
100000000000000000000
比較運算符: 比較運算符結果是一個邏輯值,不是TRUE(成立)就是FALSE(不成立)的運算符號.
>>> num1 = 10
>>> num2 = 20
>>>
>>> num1 == num2
False
>>> num1 != num2
True
>>> num1 >= num2
False
>>> num1 <= num2
True
賦值運算符: 基本的賦值運算符是=(不是等號,等號為==),所以對該運算符往往最后讀取.
>>> num1 = 10
>>> num2 = 20
>>>
>>> num1 = 10
>>> num1 += 10
20
>>> num1 -= 10
10
位運算符號: 程序中,位運算就是直接對整數在內存中的二進制位進行操作.
>>> a=60 # 60 = 0011 1100
>>> b=13 # 13 = 0000 1101
>>> c=0
>>>
>>> c= a & b # 12 = 0000 1100
>>> print("a與b: ",c)
a與b: 12
>>>
>>> c= a | b # 61 = 0011 1101
>>> print("a或b: ",c)
a或b: 61
>>>
>>> c=a^b # 49 = 0011 0001
>>> print("a異或b:",c)
a異或b: 49
>>>
>>> c=a << 2 # 240 = 1111 0000
>>> print("a左移2",c)
a左移2 240
其他運算符: 其他運算符包括常用的,邏輯運算,成員運算,身份運算等.
>>> num1 = 10
>>> num2 = 20
>>> num3 = 0
>>> list = [10,20,30,40,50]
>>>
>>> num1 and num3
0
>>>
>>> num1 in list # 判斷num1是否在list里面
True
>>> num1 not in list
False
>>>
>>> num1 is num3 # 判斷兩個標識符是不是引用自一個對象
True
>>> num1 is num2
False
>>> num1 is not num2
True
四舍五入: 一些特殊需求情況下使用四舍五入等.
>>> import math
>>>
>>> math.ceil(3.14)
4
>>> round(3.14)
3
Python 數據類型
數據類型在數據結構中的定義是一個值的集合以及定義在這個值集上的一組操作,在Python當中數據類型包括數值類型、字符類型組、列表、字典、元組、等類型,下面的例子將依次介紹這幾種運算符的使用技巧.
◆數值的類型◆
Python支持int、float、bool、complex(復數),在Python中只有一種整數類型int表示為長整型,像大多數語言一樣,數值類型的賦值和計算都是很直觀的,數值間的數據互換可以參考如下列表:
int(x) #將x轉換為一個整數
long(x) #將x轉換為一個長整數
float(x) #將x轉換到一個浮點數
complex() #創建一個復數
str(x) #將對象x轉換為字符串
repr(x) #將對象x轉換為表達式字符串
eval(str) #用來計算在字符串中的有效Python表達式,並返回一個對象
tuple(x) #將序列s轉換為一個元組
list(x) #將序列s轉換為一個列表
chr(x) #將一個整數轉換為一個字符
unichr(x) #將一個整數轉換為Unicode字符
ord(x) #將一個字符轉換為它的整數值
hex(x) #將一個整數轉換為一個十六進制字符串
oct(x) #將一個整數轉換為一個八進制字符串
整數轉其他數值: 使用轉換命令將一個整數轉換為其他數值.
>>> temp=100
>>>
>>> float(temp)
100.0
>>> complex(temp)
(100+0j)
>>> str(temp)
'100'
整數轉換字符: 使用轉換命令將一個整數轉換為字符.
>>> temp=100
>>>
>>> chr(temp)
'd'
>>> ord(chr(temp))
100
進制轉換: 使用轉換命令實現進制轉換.
>>> temp=100
>>>
>>> hex(temp)
'0x64'
>>> oct(temp)
'0o144'
◆字符串類型◆
所謂字符串就是字符的集合,Python支持字符串這種數據類型,且提供了一些豐富的字符串處理函數,以下列表中就是Python所支持的字符串操作函數,接下來我們將找出幾個比較常用的字符串函數來進行演示.
str.capitalize() #將字符串的首字母變大寫
str.title() #將字符串中的每個單詞的首字母大寫
str.upper() #將字符串變成大寫
str.lower() #將字符串變成小寫
str.index() #找出索引對應的字符串
str.find() #找出索引對應的字符串
str.count() #找出字符串中元素出現的次數
str.format() #也是格式化的一種
str.center() #以什么字符從字符串兩邊填充
str.join() #以str為分隔符連接字符串
str.split() #以什么為分隔符分隔字符串
str.strip() #將字符串兩邊中的空格去掉
str.replace() #查找替換
str.isupper() #判斷是否為大寫
str.islower() #判斷是否為小寫
str.isalnum() #判斷是否是字母數字
str.isalpha() #判斷是否是字母下划線
str.isdigit() #判斷是否是數字
str.isspace() #判斷是否為空
str.startswith() #找出以什么為開頭的字符元素
str.endswith() #找出以什么為結尾的字符元素
首字母大寫: 使用capitalize()函數,將一個指定字符串首字母變成大寫.
>>> str="hello lyshark"
>>>
>>> str.capitalize()
'Hello lyshark'
全部首字母大寫: 使用title()函數,將字符串中的每一個單詞的首字母大寫.
>>> str="hello lyshark"
>>>
>>> str.title()
'Hello Lyshark'
查找字符串: 使用index()函數,找出指定字符串的索引編號,不存在則報錯.
>>> str="hello lyshark"
>>>
>>> str.index("hello")
0
>>> str.index("lyshark")
6
>>> str.index("mk")
ValueError: substring not found
查找字符串: 使用find()函數,找出指定字符串的索引編號,不存在則返回-1.
>>> str="hello lyshark"
>>>
>>> str.find("hello")
0
>>> str.find("lyshark")
6
>>> str.find("mk")
-1
統計字符串出現次數: 使用count()函數,統計指定字符串的出現次數.
>>> str="hello lyshark"
>>>
>>> str.count("h")
2
>>> str.count("l")
3
>>> str.count("hello")
1
>>> str.count("mk")
0
字符串填充: 使用center()函數,填充指定字符串兩邊的內容.
>>> str="hello lyshark"
>>>
>>> str.center(20,'*')
'***hello lyshark****'
>>>
>>> print(str.center(50,'-'))
------------------hello lyshark-------------------
字符串連接: 使用join()函數,將序列中以指定的字符連接生成一個新字符串
>>> str="-"
>>> seq=("hello","lyshark","welcome")
>>>
>>> print(str.join(seq))
hello-lyshark-welcome
>>> list =['1','2','3','4','5']
>>> print(''.join(list))
12345
>>> 'kill %s' % ' '.join(['1024','2234'])
切割字符串: 使用split()函數,指定分割一個字符串,並保存成列表.
>>> str="hello-lyshark-welcome"
>>>
>>> str.split("-")
['hello', 'lyshark', 'welcome']
去除字符串兩邊空格: 使用strip()函數,去除指定字符串兩邊空格.
>>> str=" hello lyshark "
>>> str
' hello lyshark '
>>>
>>> str.strip()
'hello lyshark'
去除字符串(左/右)兩邊空格: 使用str.lstrip()函數去除字符串左邊空格rstrip函數則相反.
>>> str=" hello lyshark "
>>>
>>> str.rstrip()
' hello lyshark'
>>>
>>> str.lstrip()
'hello lyshark '
>>>
字符串查找替換: 使用replace()函數,查找並替換指定字符串.
>>> str="hello lyshark"
>>> str
'hello lyshark'
>>>
>>> str.replace("lyshark","mkdirs")
'hello mkdirs'
判斷是否為大寫: 使用isupper()函數,判斷指定字符串是否為大寫.
>>> str="LYSHARK"
>>> str1="lyshark"
>>>
>>> str.isupper()
True
>>> str1.isupper()
False
查找開頭結尾: 使用startswith()函數,找出指定字母開頭的字符元素.
>>> str="hello lyshark welcome"
>>>
>>> str.startswith("hello")
True
>>> str.startswith("lyshark")
False
>>>
>>> str.startswith("lyshark") or str.endswith("welcome")
True
>>> str.startswith("lyshark") and str.endswith("welcome")
False
◆列表的類型◆
列表是Python中最基本的數據結構,同時也是最常用的,列表中的每個元素都分配一個數字-它的位置或索引,第一個索引是0,第二個索引是1,依此類推,,接下來我們將找出幾個比較常用的列表操作函數來進行演示.
list.insert() #在列表中指定索引位置前插入元素
list.append() #在列表尾部插入
list.remove() #刪除指定的元素
list.pop() #沒有指定索引,則彈出最后一個元素,返回的結果是彈出的索引對應的元素
list.copy() #淺復制,只復制第一層,如果有嵌套序列則不會復制,需要復制要導入copy模塊
list.extend() #把另外一個列表合並,並不是追加
list.index() #列表中元素出現的索引位置
list.count() #統計列表中元素的次數
list.reverse() #進行逆序
list.sort() #進行排序,無法把數字和字符串一起排序
list1 + list2 #合並兩個列表,返回一個新的列表,不會修改原列表
list * N #把list重復N次,返回一個新列表
向列表追加數據: 使用append()函數,追加寫入幾個數據到指定的列表里.
>>> list = [1,2,3]
>>> list
[1, 2, 3]
>>>
>>> list.append(4)
>>> list.append(5)
>>> list.append(6)
>>>
>>> list
[1, 2, 3, 4, 5, 6]
向列表插入數據: 使用insert()函數,向指定的列表插入幾個數據到指定的位置.
>>> list = ["admin","lyshark"]
>>> list
['admin', 'lyshark']
>>>
>>> list.insert(1,"python")
>>> list
['admin', 'python', 'lyshark']
>>>
>>> list.insert(2,"ruby")
>>> list.insert(2,"ruby")
>>> list
['admin', 'python', 'ruby', 'ruby', 'lyshark']
修改指定數據: 使用names[]變量賦值的方式,修改指定元素的字段值.
>>> list
['admin', 'python', 'ruby', 'ruby', 'lyshark']
>>> list[0]="mkdirs"
>>> list
['mkdirs', 'python', 'ruby', 'ruby', 'lyshark']
>>>
>>> list[3]="pip"
>>> list
['mkdirs', 'python', 'ruby', 'pip', 'lyshark']
刪除指定數據: 使用remove()函數,刪除指定數據,或使用del()函數來刪除.
>>> list
['mkdirs', 'python', 'ruby', 'pip', 'lyshark']
>>>
>>> del list[2] #通過下標刪除元素
>>> list
['mkdirs', 'python', 'pip', 'lyshark']
>>>
>>> list.remove("python") #刪除指定的元素
>>> list
['mkdirs', 'pip', 'lyshark']
>>>
>>> list.pop() #刪除列表的最后一個元素
'lyshark'
>>> list.pop()
'pip'
>>> list
['mkdirs']
擴展一個列表: 使用extend()函數,將一個列表追加到另一個列表的后面.
>>> list1 = ["admin","guest","lyshark"]
>>> list2 = [1,2,3]
>>>
>>> list1.extend(list2)
>>> list1
['admin', 'guest', 'lyshark', 1, 2, 3]
淺COPY列表: 使用copy()函數,實現列表的淺Copy.
>>> list1
['admin', 'guest', 'lyshark', 1, 2, 3]
>>>
>>> list1_copy = list1.copy()
>>> list1_copy
['admin', 'guest', 'lyshark', 1, 2, 3]
統計元素次數: 使用count()函數,統計列表中元素出現的次數.
>>> list = ["admin","admin","lyshark","mkdirs"]
>>>
>>> list.count("admin")
2
>>> list.count("mkdirs")
1
正反向排序: 使用sort(),reverse()函數,給指定列表元素排序.
>>> list = ["admin","python","ruby","1","3","6","9"]
>>> list
['admin', 'python', 'ruby', '1', '3', '6', '9']
>>>
>>> list.sort() #正向排序,必須元素類型一致
>>> list
['1', '3', '6', '9', 'admin', 'python', 'ruby']
>>>
>>> list
['1', '3', '6', '9', 'admin', 'python', 'ruby']
>>> list.reverse() #反向排序,必須元素類型一致
>>> list
['ruby', 'python', 'admin', '9', '6', '3', '1']
獲取元素下標: 使用index()函數,來獲取元素的下標.
>>> list
['ruby', 'python', 'admin', '9', '6', '3', '1']
>>>
>>> list.index("admin")
2
>>> list.index("1")
6
列表的切片: 使用[]實現列表的各種切片操作.
>>> list=[1,2,3,4,5,6,7,8,9,0]
>>>
>>> list[1:4] #取出下標1-4的元素,不包括4
[2, 3, 4]
>>>
>>> list[1:-1] #取出下標1至-1,不包括-1
[2, 3, 4, 5, 6, 7, 8, 9]
>>>
>>> list[1:] #取出下標從1到最后的數據
[2, 3, 4, 5, 6, 7, 8, 9, 0]
>>>
>>> list[:] #取出所有元素
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>
>>> list[0::2] #取元素時每次格2格
[1, 3, 5, 7, 9]
通過分片刪除數據: 通過使用分片來清除指定列表中的數據.
>>> list
[123, 111, 111, 111, 8, 7, 6, 5, 4, 3, 2, 1]
>>> list[0:3]
[123, 111, 111]
>>>
>>> list[0:3]=[] #將下標0-3替換成空,不包括3
>>> print(list)
[111, 8, 7, 6, 5, 4, 3, 2, 1]
>>>
嵌套列表的實現: 一次性聲明兩個列表,並於數據名稱相關聯.
>>> list1,list2 = [[1,"a","b"],[2,"a","b"]]
>>>
>>> print(list1)
[1, 'a', 'b']
>>> print(list2)
[2, 'a', 'b']
查找元素並修改(1): 查找列表中的指定元素,並修改,只修改第一次發現的.
[root@localhost]# cat test.py
#!/usr/bin/python
name = [1,2,3,4,5,1,5,6]
if 1 in name:
num_of_ele = name.count(1)
position_of_ele = name.index(1)
name[position_of_ele] = 888
print(name)
[root@localhost]# python test.py
[888, 2, 3, 4, 5, 1, 5, 6]
查找元素並修改(2): 查找列表中的指定元素,並批量修改,修改所有的.
[root@localhost]# cat test.py
#!/usr/bin/python
name = [1,2,3,4,5,1,5,6]
for i in range(name.count(1)):
ele_index = name.index(1)
name[ele_index] = 8888888
print(name)
[root@localhost]# python test.py
[8888888, 2, 3, 4, 5, 8888888, 5, 6]
◆字典的類型◆
字典是另一種可變容器模型,且可存儲任意類型對象,字典是使用鍵值對的數據類型,字典的每個鍵值(key=>value)用冒號作為分割符,而鍵值對與鍵值對之間則用逗號分割,整個字典都被包括在花括號中,且字典還有兩個特性,第一個特性字典中的數據是無序存儲的,第二個特性字典中的key必須是唯一的,所以Key天生去重,如下是字典的幾種格式聲明:
person = {"name": "lyshark", "age": 22}
person = dict({"name": "lyshark", "age": 22})
info = {
'stu1': "加藤鷹",
'stu2': "波多野結衣",
'stu3': "小澤瑪利亞",
}
字典需要使用字典專有的操作函數,字典的常用函數有以下這幾種,后面我會使用不同的例子進行說明.
dict.get(key) #取得某個key的value
dict.has_key(key) #判斷字典是否有這個key,在python3中已經廢除,使用in判斷
dict.keys() #返回所有的key為一個列表
dict.values() #返回所有的value為一個列表
dict.items() #將字典的鍵值拆成元組,全部元組組成一個列表
dict.pop(key) #彈出某個key-value
dict.popitem() #隨機彈出key-value
dict.clear() #清除字典中所有元素
dict.copy() #字典復制,d2=d1.copy()是淺復制,如果深復制需要copy模塊
dict.fromkeys(s) #生成一個新字典
dict.update(key) #將一個字典合並到當前字典中
dict.iteritems() #生成key-value迭代器,可以用next()取下個key-value
dict.iterkeys() #生成key迭代器
dict.itervalues() #生成values迭代器
增加字典: 在info字典的基礎上,增加一個字段info["stu4"] = "蒼老師".
>>> info
{'stu1': '加藤鷹', 'stu2': '波多野結衣', 'stu3': '小澤瑪利亞'}
>>> info["stu4"] = "蒼老師"
>>>
>>> info
{'stu1': '加藤鷹', 'stu2': '波多野結衣', 'stu3': '小澤瑪利亞', 'stu4': '蒼老師'}
修改字典: 在info字典的基礎上,修改將stu1:加藤鷹修改為stu1:金手指.
>>> info
{'stu1': '加藤鷹', 'stu2': '波多野結衣', 'stu3': '小澤瑪利亞', 'stu4': '蒼老師'}
>>>
>>> info["stu1"] = "金手指"
>>> info
{'stu1': '金手指', 'stu2': '波多野結衣', 'stu3': '小澤瑪利亞', 'stu4': '蒼老師'}
刪除字典: 在info字典的基礎上,刪除幾個字典,以下提供多種刪除方法.
>>> info
{'stu1': '金手指', 'stu2': '波多野結衣', 'stu3': '小澤瑪利亞', 'stu4': '蒼老師'}
>>>
>>> info.pop("stu1") #通過pop函數刪除
'金手指'
>>> info
{'stu2': '波多野結衣', 'stu3': '小澤瑪利亞', 'stu4': '蒼老師'}
>>>
>>> del info["stu4"] #通過del命令刪除
>>> info
{'stu2': '波多野結衣', 'stu3': '小澤瑪利亞'}
>>>
>>> info.popitem() #隨機刪除元素
('stu3', '小澤瑪利亞')
查找字典: 在info字典基礎上,完成幾個查詢任務,這里提供幾種方法.
>>> info
{'stu1': '加藤鷹', 'stu2': '波多野結衣', 'stu3': '小澤瑪利亞'}
>>>
>>> "stu1" in info #標准的查詢方式
True
>>>
>>> info.get("stu1") #使用get函數查詢
'加藤鷹'
>>>
>>> info["stu2"]
'波多野結衣'
更新字典: 在info字典的基礎上,更新字典內容,將temp字典與info字典合並.
>>> info
{'stu1': '加藤鷹', 'stu2': '波多野結衣', 'stu3': '小澤瑪利亞'}
>>>
>>> temp = {1:2,"stu4":"蒼老師"}
>>>
>>> info.update(temp)
>>> info
{'stu1': '加藤鷹', 'stu2': '波多野結衣', 'stu3': '小澤瑪利亞', 1: 2, 'stu4': '蒼老師'}
遍歷字典: 這里提供兩種字典遍歷方法,建議使用第二種,因為其遍歷速度最快.
>>> info = {'stu1': '加藤鷹', 'stu2': '波多野結衣', 'stu3': '小澤瑪利亞'}
>>>
>>> for keys,values in info.items():
... print(keys,values)
...
stu1 加藤鷹
stu2 波多野結衣
stu3 小澤瑪利亞
>>> for keys in info:
... print(keys,info[keys])
...
stu1 加藤鷹
stu2 波多野結衣
stu3 小澤瑪利亞
索引字典: 字典也支持索引的方式獲取字典中的元素,只不過必須以key作為索引.
>>> info = {'stu1': '加藤鷹', 'stu2': '波多野結衣', 'stu3': '小澤瑪利亞'}
>>>
>>> info['stu2']
'波多野結衣'
>>>
>>> len(info)
3
>>>
>>> dict = {"姓名":"加藤鷹","得分":[98,99,87]}
>>>
>>> dict["姓名"]
'加藤鷹'
>>> dict["得分"]
[98, 99, 87]
>>> dict["得分"][2:]
[87]
字典解包: 將字典分解為獨立的元組並將元組賦值給其他變量.
>>> dict = {"姓名":"加藤鷹","得分":[98,99,87]}
>>> t1,t2 = dict.items()
>>>
>>> print(t1)
('姓名', '加藤鷹')
>>> print(t2)
('得分', [98, 99, 87])
>>>
>>> k1,k2 = {"x":100,"y":200}
>>> print(k1)
x
列表合並為字典: 將兩個列表合成一個字典,其中list1是key,list2是values.
>>> dict = {}
>>> list = [100,200,300,400,500]
>>> head = ["MemTotal","MemFree","Cached","SwapTotal","SwapFree"]
>>>
>>> for (keys,values) in zip(head,list):
... dict[keys] = values
...
>>> dict
{'MemTotal': 100, 'MemFree': 200, 'Cached': 300, 'SwapTotal': 400, 'SwapFree': 500}
>>>
>>> dict(map(lambda x,y:[x,y],head,list))
{'MemTotal': 100, 'MemFree': 200, 'Cached': 300, 'SwapTotal': 400, 'SwapFree': 500}
>>>
>>> dict(zip(head,list))
{'MemTotal': 100, 'MemFree': 200, 'Cached': 300, 'SwapTotal': 400, 'SwapFree': 500}
字典鍵值對調: 將字典中的鍵與字典中的值進行位置的對調.
>>> {key:value for key,value in zip(head,list)}
{'MemTotal': 100, 'MemFree': 200, 'Cached': 300, 'SwapTotal': 400, 'SwapFree': 500}
>>> {value:key for key,value in zip(head,list)}
{100: 'MemTotal', 200: 'MemFree', 300: 'Cached', 400: 'SwapTotal', 500: 'SwapFree'}
字典拆分為列表: 將一個完整的字典拆分為兩個列表.
>>> dict = {'stu1': '加藤鷹', 'stu2': '波多野結衣', 'stu3': '小澤瑪利亞'}
>>> keys= dict.keys()
>>> values = dict.values()
>>>
>>> print("keys:{}".format(keys))
keys:dict_keys(['stu1', 'stu2', 'stu3'])
>>>
>>> dict = {'stu1': '加藤鷹', 'stu2': '波多野結衣', 'stu3': '小澤瑪利亞'}
>>>
>>> keys,values = zip(*dict.items())
>>> print("Keys:",str(keys))
Keys: ('stu1', 'stu2', 'stu3')
>>> dict = {'stu1': '加藤鷹', 'stu2': '波多野結衣', 'stu3': '小澤瑪利亞'}
>>>
>>> keys = []
>>> values = []
>>> items = dict.items()
>>> for x in items:
... keys.append(x[0]),values.append(x[1])
...
>>> print(str(keys))
['stu1', 'stu2', 'stu3']
字典合並與拷貝: 合並字典,但是在有相同的key時會覆蓋原有的key的值.
>>> dict1 = {"x":1,"y":2}
>>> dict2 = {"a":3,"b":4}
>>> dict3 = {}
>>>
>>> dict3 = {**dict1,**dict2}
>>> print(dict3)
{'x': 1, 'y': 2, 'a': 3, 'b': 4}
>>>
>>> dict3.update(dict1)
>>> dict3.update(dict2)
>>> print(dict3)
{'x': 1, 'y': 2, 'a': 3, 'b': 4}
>>>
>>> import copy
>>> n1 = {"k1": "wu", "k2": 123, "k3": ["lyshark", 456]}
>>> n2 = {}
>>>
>>> n2 = copy.deepcopy(n1)
>>> print(n2)
{'k1': 'wu', 'k2': 123, 'k3': ['lyshark', 456]}
復雜表格數據存儲:
>>> dict1 = {"name":"admin","age":19,"salary":3000,"address":"beijing"}
>>> dict2 = {"name":"guest","age":20,"salary":4000,"address":"shanghai"}
>>> dict3 = {"name":"lyshark","age":21,"salary":5000,"address":"shenzhen"}
>>> table = [dict1,dict2,dict3]
# 用於獲取指定人的指定字段數據
>>> print(table[1].get("name"))
guest
>>> print(table[2].get("address"))
shenzhen
# 打印表格中所有人的名字
>>> for i in range(len(table)):
... print(table[i].get("name"))
...
admin
guest
lyshark
◆元組的類型◆
元組是Python中常用的一種數據結構,元組由不同的元素組成,每個元素可以存儲不同類型的數據,如字符串、數字甚至元組,元組是"寫保護"的,即元組創建后不能再做任何修改操作,元組通常代表一行數據,而元組中的元素代表不同的數據項,元組一旦創建,便不能再修改,所以又叫只讀列表,元組使用小括號,列表使用方括號,元組創建很簡單,只需要在括號中添加元素,並使用逗號隔開即可.
創建元組: 同個幾個實例看一下元組是如何被創建的.
>>> tup1 = ("google","baidu",1997,1998)
>>> tup2 = (1,2,3,4,5,6,7)
>>> tup3 = "a","b","c","d"
>>>
>>> tup1
('google', 'baidu', 1997, 1998)
>>> tup2
(1, 2, 3, 4, 5, 6, 7)
>>> tup3
('a', 'b', 'c', 'd')
>>>
>>> type(tup1)
<class 'tuple'>
訪問元組: 元組可以使用下標索引來訪問元組中的值.
>>> tup1
('google', 'baidu', 1997, 1998)
>>>
>>> print("tup1[0:]",tup1[0])
tup1[0:] google
>>> print("tup1[1:2]",tup1[1:2])
tup1[1:2] ('baidu',)
連接元組: 元組中的元素值是不允許修改的,但我們可以對元組進行連接組合.
>>> tup1 = (1,2,3,4)
>>> tup2 = ("abc","xyz")
>>>
>>> tup3 = tup1+tup2
>>> print(tup3)
(1, 2, 3, 4, 'abc', 'xyz')
刪除元組: 元組中的元素值是不允許刪除的,但我們可以使用del語句來刪除整個元組.
>>> tup = ("admin","lyshark", 1997, 2000)
>>>
>>> print(tup)
('admin', 'lyshark', 1997, 2000)
>>> del tup;
>>> print(tup)
列表轉元組: 將一個列表,強制轉換成元祖.
>>> list = ["admin","lyshark","guest"]
>>>
>>> tuple = tuple(list)
>>>
>>> tuple
('admin', 'lyshark', 'guest')
數據統計: 通過使用count(),index()函數統計元組中的其他數據.
>>> tuple
('admin', 'lyshark', 'guest')
>>>
>>> tuple.count("lyshark") #統計lyshark出現次數
1
>>> tuple.index("lyshark") #統計lyshark索引位置
1
元素修改(拓展): 在沒有嵌套的情況,元組是不可變對象,但是元組內的列表是可變的.
>>> tup=("lyshark",[1,2,3,4,5])
>>> tup
('lyshark', [1, 2, 3, 4, 5])
>>>
>>> tup[1].pop()
5
>>> tup
('lyshark', [1, 2, 3, 4])
元組解包(拓展): 將兩個元組,查分開,分別存儲在兩個變量中.
>>> tup1,tup2=((1,2,3),("a","b","c"))
>>> print(tup1)
(1, 2, 3)
>>>
>>> print(tup2)
('a', 'b', 'c')
◆集合的類型◆
集合是一個無序的,不重復的數據組合,集合天生去重,把一個列表變成集合,就自動去重了,集合不支持：索引、元素獲取、切片,且沒有特定語法格式,只能通過工廠函數創建set,像字符串則直接創建即可,set集合中的元素必須是可迭代對象,所有元素不會重復,不像list列表是可以重復.
set.add(item) #將item添加到set中,如果item已經在set中,則無任何效果
set.remove(item) #從set中刪除item,如果item不是set的成員,則引發KeyError異常
set.discard(item) #從set中刪除item.如果item不是set的成員,則無任何效果
set.pop() #隨機刪除一個集合元素,並從set刪除,有變量接收則會接收刪除到的元素
set.clear() #刪除set中的所有元素
set.copy() #淺復制
set.update(t) #將t中的所有元素添加到set中,t可以是另一個集合、一個序列
set.union(t) #求並集,返回所有在set和t中的元素
set.intersection(t) #求交集,返回所有同時在set和t中的都有的元素
set.intersection_update(t) #計算set與t的交集,並將結果放入set
set.difference(t) #求差集,返回所有在set中,但不在t中的元素
set.difference_update(t) #從set中刪除同時也在t中的所有元素
set.symmetric_difference(t) #求對稱差集,返回所有set中沒有t中的元素和t中沒有set中的元素組成的集合
set.sysmmetric_difference_update(t) #計算set與t的對稱差集,並將結果放入set
set.isdisjoint(t) #如果set和t沒有相同項,則返回True
set.issubset(t) #如果s是t的一個子集,則返回True
set.issuperset(t) #如果s是t的一個超集,則返回True
創建集合: 使用兩種方式分別創建一個集合元素.
>>> s = {"tom","cat","name","lyshark"}
>>> s = set({"tom","cat","name","lyshark"})
>>>
>>> s
{'tom', 'cat', 'name', 'lyshark'}
>>> type(s)
<class 'set'>
定義可變集合: 定義一個可變集合,集合中的元素不可重復,都是不同的.
>>> set_test = set("hello")
>>> set_test
{'o', 'e', 'l', 'h'}
定義不可變集合: 定義一個不可變集合,集合中的元素不可重復,都是不同的.
>>> set_test = set("hello")
>>> set_test
{'o', 'e', 'l', 'h'}
>>>
>>> no_set_test = frozenset(set_test)
>>> no_set_test
frozenset({'o', 'e', 'l', 'h'})
求子集: 子集為某個集合中一部分的集合,故亦稱部分集合.
>>> A = set('abcd')
>>> B = set("cdef")
>>> C = set("ab")
>>>
>>> C<A #C是A的子集
True
>>> C.issubset(A) #C是A的子集
True
>>> C<B #C不是B的子集
False
求並集: 一組集合的並集是這些集合的所有元素構成的集合,而不包含其他元素.
>>> A
{'d', 'a', 'c', 'b'}
>>> B
{'f', 'd', 'e', 'c'}
>>>
>>> A | B
{'f', 'b', 'c', 'a', 'e', 'd'}
>>> A.union(B)
{'f', 'b', 'c', 'a', 'e', 'd'}
求交集: 兩個集合A和B的交集是含有所有既屬於A又屬於B的元素,而沒有其他元素的集合.
>>> A
{'d', 'a', 'c', 'b'}
>>> B
{'f', 'd', 'e', 'c'}
>>>
>>> A & B
{'c', 'd'}
>>> A.intersection(B)
{'c', 'd'}
求差集: A與B的差集是,所有屬於A且不屬於B的元素構成的集合.
>>> A
{'d', 'a', 'c', 'b'}
>>> B
{'f', 'd', 'e', 'c'}
>>>
>>> A - B
{'a', 'b'}
>>> A.difference(B)
{'a', 'b'}
對稱差: 兩個集合的對稱差是只屬於其中一個集合,而不屬於另一個集合的元素組成的集合.
>>> A
{'d', 'a', 'c', 'b'}
>>> B
{'f', 'd', 'e', 'c'}
>>>
>>> A ^ B
{'f', 'b', 'a', 'e'}
>>> A.symmetric_difference(B)
{'f', 'b', 'a', 'e'}
添加元素: 使用add()函數,向一個現有的集合添加一個元素.
>>> s = {1,2,3,4,5,6}
>>> s
{1, 2, 3, 4, 5, 6}
>>> s.add("s")
>>> s.add("e")
>>> s.add("t")
>>>
>>> s
{1, 2, 3, 4, 5, 6, 't', 's', 'e'}
清空集合: 使用clear()函數,清空一個集合中的所有元素.
>>> s
{1, 2, 3, 4, 5, 6, 't', 's', 'e'}
>>>
>>> s.clear()
>>>
>>> s
set()
刪除指定元素: 使用remove,discard函數,刪除集合中的指定元素.
>>> s = {1,2,3,4,5}
>>> s
{1, 2, 3, 4, 5}
>>>
>>> s.remove(3)
>>> s
{1, 2, 4, 5}
批量更新元素: 使用update()函數,用自己和另一個的並集來更新這個集合.
>>> s ={"p","y"}
>>> s
{'p', 'y'}
>>>
>>> s.update(["H","e"],{"1","2","3"})
>>> s
{'H', '1', 'y', 'p', '2', 'e', '3'}
拓展知識(1): 在多條數據中尋找差異.
# 數據庫中原有
old_dict = {
"#1":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 },
"#2":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 },
"#3":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 }
}
# cmdb 新匯報的數據
new_dict = {
"#1":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 800 },
"#3":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 },
"#4":{ 'hostname':'c2', 'cpu_count': 2, 'mem_capicity': 80 }
}
old_set=set(old_dict)
new_set=set(new_dict)
del_set=old_set.difference(new_set)
add_set=new_set.difference(old_set)
flush_set=old_set.intersection(new_set)
for i in del_set:
old_dict.pop(i)
for i in add_set:
old_dict[i]=new_dict[i]
for i in flush_set:
old_dict[i] = new_dict[i]
print(old_dict)
拓展知識(2): 在多條數據中尋找差異.
# 數據庫中原有
old_dict = {
"#1":8,
"#2":4,
"#3":2,
}
# cmdb 新匯報的數據
new_dict = {
"#1":4,
"#3":4,
"#4":2,
}
old_set = set(old_dict.keys())
print(old_set)
new_set = set(new_dict.keys())
print(new_set)
remove_set = old_set.difference(new_set)
print(remove_set)
add_set = new_set.difference(old_set)
print(add_set)
update_set = old_set.intersection(new_set)
print(update_set)
◆序列的補充◆
序列類型表示索引為非負整數的有序對象集合,包括字符串、列表、元組、字符串是字符的,列表和元組是任意python對象的序列,字符和元組屬於不可變序列,而列表則支持插入、刪除和替換元素等.所有序列都支持迭代,當然元組是不可變對象,對元素的操作是不支持的,當然了有嵌套列表字典是可以操作的,以下是幾個常用的序列操作函數:
s + r #連接字符串,與數據
s * n #重復s的n次復制
v1,v2...vn = s #變量解包(unpack)
s[i] #索引
s[i:j] #切片
s[i:j:stride] #擴展切片
x in s,x not in s #成員關系
for x in s: #迭代
all(s) #如果s中的所有項都為True,則返回True
any(s) #如果s中的任意項為True,則返回True
len(s) #長度,元素個數
min(s) #s中的最小項
max(s) #s中的最大項
sum(s [,initial]) #具有可選初始值的項的和
all判斷: 如果temp中的所有項都為True,則返回True.
>>> temp = [1,1,1,1,1,1]
>>> temp1 = [1,1,1,1,0,1]
>>>
>>> all(temp)
True
>>> all(temp1)
False
any判斷: 如果temp中的任意項為True,則返回True.
>>> temp = [1,1,1,1,1,1]
>>> temp1 = [1,1,1,1,0,1]
>>>
>>> any(temp)
True
>>> any(temp1)
True
len計算元素個數: 計算列表或字典等相關的元素個數.
>>> temp = [1,1,1,1,1,1]
>>> len(temp)
6
min返回最小: 返回列表中最小的數值.
>>> temp = [1,2,3,4,5,6,7,8,9]
>>>
>>> min(temp)
1
max返回最大: 返回列表中最大的數值.
>>> temp = [1,2,3,4,5,6,7,8,9]
>>>
>>> max(temp)
9
◆文件的操作◆
open: open函數用來打開一個文件,並返回一個句柄.
>>> f=open("./test.txt","r")
>>>
popen: 使用popen存儲命令執行結果,並打印執行結果.
>>> temp=os.popen("ifconfig").readlines()
>>> temp
['eth0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST> mtu 1500\n']
read: 此函數一次性讀取文件所有內容.
>>> f=open("./test.txt","r")
>>> f.read()
readline: 此函數每次讀取一行數據,直到全部讀取完畢.
>>> f=open("./test.txt","r")
>>> f.readline()
'root:x:0:0:root:/root:/bin/bash\n'
>>> f.readline()
'bin:x:1:1:bin:/bin:/sbin/nologin\n'
>>> f.readline()
'daemon:x:2:2:daemon:/sbin:/sbin/nologin\n'
readlines: 使用readlines一次性讀取全部內容,相當於全部加載.
>>> f=open("./test.txt","r")
>>> f.readlines()
seek: 使用seek移動光標位置,tell獲取當前光標位置.
>>> f=open("./test.txt","r")
>>> f.tell() #查詢當前光標所在位置
0
>>> f.readline() #讀取一行后
'root:x:0:0:root:/root:/bin/bash\n'
>>>
>>> f.tell() #再次查詢光標所在位置
32
>>>
>>> f.read() #完全讀取后，光標此時在文件最后面..
'bin:x:1:1:bin:/bin:/sbin/nologin\ndaemon:x:2:2:daemon:/sbin:/sbin/nologin\n'
>>>
>>> f.seek(32) #移動光標到32
>>>
>>> f.read() #重新讀取數據
'bin:x:1:1:bin:/bin:/sbin/nologin\ndaemon:x:2:2:daemon:/sbin:/sbin/nologin\n'
flush: 強制刷新內存中的數據,將其寫入磁盤.
>>> import sys
>>> import time
>>>
>>> for i in range(40):
... sys.stdout.write("#")
... sys.stdout.flush() #強制將內存中的數據寫入硬盤
... time.sleep(0.1)
close: 使用close關閉文件句柄,每次打開文件用完后記得關閉.
>>> f=open("./test.txt","r")
>>> f.readlines()
>>> f.close()
next: 每次讀取一行數據,可以使用next函數加載下一行.
>>> f = open("./test.txt", "r")
>>> print ("文件名為: ", f.name)
>>> for index in range(5):
... line = next(f)
... print ("第 %d 行 - %s" % (index,line))
>>> f.close()
truncate: 截取數據,可指定每次截取的字節數.
>>> f = open("./test.txt", "r+")
>>> print ("文件名為: ", f.name)
>>> f.truncate(10) #截取10個字節
>>> str = f.read()
>>> print ("讀取數據: %s" % (str))
>>> f.close()
with: 自動打開文件,並在執行完后自動的釋放文件句柄.
>>> with open('test.txt') as f:
... print(f.read())
linecache: 通過使用linecache模塊打開一個文件,並計算出文件總行數.
import sys
import linecache
count = len(open("./ip.log","r").readlines())
print("文件行數(包括空格): %d" %count)
count = linecache.getlines("./ip.log")
print("文件行數(支持大文件): %d" %len(count))
Python 流程控制
◆while 循環◆
分支結構:
# -*- coding: utf-8 -*-
import sys
number = 38
user_input = int(input("輸入一個數字:"))
if user_input == number:
print("你猜對了!")
elif user_input < number:
print("猜小了!")
else:
print("猜大了!")
實現加法循環:
import sys
count = 1
sum = 0
while count <=100:
sum+=count
count+=1
print(sum)
中斷循環: 演示一個while循環被中斷的情況.
import os
count = 0
while count <=9:
print(count, end=' ')
if count == 5:
break
count += 1
else:
print('end')
字符串的打印: 打印指定字符串,循環打印其中的每一個元素,並每次遞減.
import sys
string = "hello lyshark"
while string:
print(string)
string = string[:-1]
else:
print("gae over")
列表的打印: 逐一顯示指定列表中的所有元素,這里有三種方法.
>>> list=[1,2,3,4,5,6]
>>> count =0
>>>
>>> while list:
... print(list[0])
... list.pop(0)
...
>>> list=[1,2,3,4,5,6]
>>> while list:
... print(list[-1])
... list.pop()
...
>>> list=[1,2,3,4,5,6]
>>> while count < len(list):
... print(list[count])
... count+=1
練習實例: 求100以內所有偶數之和,使用嵌套判斷.
>>> num=0
>>> sum=0
>>> while num <=100:
... if num %2 ==0:
... sum=sum+num
... else:
... pass
... num=num+1
練習實例: 逐一顯示指定字典的所有鍵,並於顯示結束后說明總鍵數.
>>> d1 = {'x':1,'y':23,'z':78}
>>> keylists = d1.keys()
>>> while keylists:
print(keylists[0])
keylists.pop[0]
else:
print(len(d1))
練習實例: 創建一個包含了100以內所有奇數的列表.
>>> l1 = []
>>> x = 1
>>> while x < 100:
l1.append(x)
x += 2
練習實例: 如下存在兩個列表l1,l2,以第一個列表中的元素為鍵,以第二個列表中的元素為值生成新字典d1.
>>> l1 = [0,1,2,3,4,5,6]
>>> l2 = ['Sun','Mon','Tue','Wed','Thu','Fri','Sat']
>>> d1 = {}
>>> count = 0
>>> if len(l1) == len(l2):
while count < len(l1):
d1[l1[count]] = l2[count]
count += 1
>>> print(d1)
練習實例: 循環並打印相關文字,當到達100次的時候退出.
count = 0
while True:
print("hello lyshark:",count)
count +=1
if count == 100:
print("break")
break
練習實例: 模擬登陸小程序,程序啟動要求輸入密碼,並判斷如果次數小於3次則登陸成功,否則禁止登陸.
import getpass
import os
name = "lyshark"
pwd = "123123"
count = 0
while True:
if count < 3:
print("請輸入用戶名和密碼:")
username = input("用戶名:")
password = getpass.getpass("密碼:")
if username == name and password == pwd:
print("恭喜你登陸成功！")
break
else:
print("登陸失敗！用戶名或者密碼錯誤")
else:
print("你已經輸錯3次,正在退出....")
break
count += 1
◆for 循環◆
列表遍歷: 通過使用for循環打印一個list列表中的元素.
import os
names = ["tom","admin","lyshark","jack"]
for x in names:
print(x)
列表迭代: 對於一個序列來說,也可以通過索引進行迭代.
import os
names = ["tom","admin","lyshark","jack"]
for x in range(len(names)):
print(names[x])
打印序列: 通過for循環,遍歷並打印一個序列.
import os
T = [(1,2),(3,4),(5,6),(7,8)]
for (a,b) in T:
print(a,b)
循環遍歷: 遍歷0-9范圍內的所有數字,並通過循環控制語句打印出其中的奇數.
import os
for i in range(10):
if i % 2 == 0:
continue
print(i, end=' ')
循環遍歷: 通過循環控制語句打印一個列表中的前3個元素.
import os
names = ['Tom', 'Peter', 'Jerry', 'Jack', 'Lilly']
for i in range(len(names)):
if i >= 3:
break
print(names[i])
循環遍歷: 通過for循環打印99乘法表.
import os
for j in range(1, 10):
for i in range(1, j+1):
print('%d*%d=%d' % (i, j, i*j), end='\t')
i += 1
print()
j += 1
循環遍歷: 通過range函數,我們同樣可以實現遍歷.
>>> string="hello world my name lyshark"
>>> for i in range(0,len(string),2):
... print(string[i])
>>> list=[1,2,3,4,5]
>>> for i in range(len(list)):
... list[i]+=1
>>> list
[2, 3, 4, 5, 6]
>>> for i in range(1,10,2):
print(i)
enumrate: 給一個可迭代的對象添加序號,默認是編號是從0開始,可以設置從1開始.
>>> list=["蒼井空","小澤瑪利亞","吉澤明步"]
>>> for (x,y) in enumerate(list,1):
print(x,y)
1 蒼井空
2 小澤瑪利亞
3 吉澤明步
zip()函數: zip函數常用於動態的構造字典.
>>> L1 = [1,2,3,4,5]
>>> L2 = ['a','b','c','d','e',]
>>> zip(L1,L2)
>>>
>>> keys = [1,2,3,4,5,6,7]
>>> vaules = ['Sun','Mon','Tue','Wed','Thu','Fri','Sat']
>>> D = {}
>>> for (k,v) in zip(keys,values)
D[k] = v
>>> D
◆其他實例◆
練習實例: 逐一分開顯示指定字典d1中的所有元素,也就是字典遍歷打印.
>>> d1 = {'x':123,'y':321,'z':734}
>>> for (k,v) in d1.items():
print(k,v)
y 321
x 123
z 734
練習實例: 逐一顯示列表中l1中索引為奇數的元素.
>>> l1=['Sun','Mon','Tue','Wed','Thu','Fri','Sat']
>>>
>>> for i in range(1,len(l1),2):
print(l1[i])
練習實例: 將屬於列表l1,但不屬於列表l2的所有元素定義為一個新列表l3,並加入到其中.
>>> l1=['Sun','Mon','Tue','Wed','Thu','Fri','Sat']
>>> l2=['Sun','Mon','Tue','Thu','Sat']
>>> l3 = []
>>> for i in l1:
>>> if i not in l2:
>>> l3.append(i)
練習實例: 請將屬於removelist列表中的每個元素從namelist中移除(屬於removelist,但不屬於namelist的忽略即可).
>>> namelist=['stu1','stu2','stu3','stu4','stu5','stu6','stu7']
>>> removelist=['stu3','stu7','stu9']
>>> for i in removelist:
>>> if i in namelist:
>>> namelist.remove(i)
>>> print(namelist)
練習實例: 有四個數字：1、2、3、4,能組成多少個互不相同且無重復數字的三位數?各是多少?
程序分析:可填在百位、十位、個位的數字都是1、2、3、4,組成所有的排列后再去掉不滿足條件的排列.
>>> for i in range(1,5):
... for j in range(1,5):
... for k in range(1,5):
... if(i!=k) and (i!=j) and(j!=k):
... print(i,j,k)
...
練習實例: 輸入某年某月某日,程序自動判斷這一天是這一年的第幾天?
程序分析:以10月1日為例,應該先把前9個月的加起來,然后再加上1天即本年的第幾天,特殊情況,閏年且輸入月份大於2時需考慮多加一天.
# -*- coding: UTF-8 -*-
year = int(input('year:\n'))
month = int(input('month:\n'))
day = int(input('day:\n'))
months = (0,31,59,90,120,151,181,212,243,273,304,334)
if 0 < month <= 12:
sum = months[month - 1]
else:
print ('data error')
sum += day
leap = 0
if (year % 400 == 0) or ((year % 4 == 0) and (year % 100 != 0)):
leap = 1
if (leap == 1) and (month > 2):
sum += 1
print ('it is the %dth day.' % sum)
練習實例: 輸出9*9乘法口訣表,分行與列考慮,共9行9列,i控制行,j控制列.
import os
import sys
for x in range(1,10):
print()
for y in range(1,x+1):
print("%d*%d=%d "%(y,x,x*y),end="")
練習實例: 寫一個字符串遍歷查找工具,代碼如下.
import os
import sys
ls="Type help() for interactive help, or help(object) for help about object"
find="help"
for x in range(len(ls)):
temp=len(find)
if str(ls[x:x+temp]) == str(find):
print(ls[x:x+temp],x)
break
練習實例: 通過使用time模塊中的sleep函數,讓程序每隔1秒執行一次循環.
import os
import time
dic={1:"admin",2:"guest"}
for key,value in dict.items(dic):
print(key,value)
time.sleep(1)
練習實例: 輸入一行字符,分別統計出其中英文字母、空格、數字和其它字符的個數.
import os
import string
strs=input("請輸入一個字符串:")
letters=0
space=0
digit=0
others=0
for x in range(len(strs)):
ch=strs[x]
if ch.isalpha():
letters+=1
elif ch.isspace():
space+=1
elif ch.isdigit():
digit+=1
else:
others+=1
print("char=%d,space=%d,digit=%d,others=%d"%(letters,space,digit,others))
練習實例: 讀取db配置文件,並按照文件中的賬號密碼判斷是否允許登陸.
import os
import sys
def login(x,y):
fp=open("db","r",encoding="utf-8")
data=fp.readline().split(":")
count=len(open("db","r").readlines())
username=data[0]
password=data[1]
for i in range(3):
if x==username.strip() and y==password.strip():
print("登陸成功")
break
else:
data=fp.readline().split(":")
username=data[0]
password=data[1]
continue
fp.close()
login("admin","admin")
login("lyshark","lyshark")
實現元素分類: 有如下值集合list,將所有大於66的值保存至字典的第一個key中,將小於66的值保存至第二個key的值中,即{'k1': 大於66的所有值,'k2': 小於66的所有值}
list= [11,22,33,44,55,66,77,88,99]
bignum=[]
smallnum=[]
dir={}
for num in list:
if num>66:
bignum.append(num)
if num<66:
smallnum.append(num)
else:
pass
dir['k1']=bignum
dir['k2']=smallnum
print(dir)
實現元素查找: 查找元素,移動空格,並查找以a或A開頭,並且以c結尾的所有元素.
li = ["alec", " aric", "Alex", "Tony", "rain"]
tu = ("alec", " aric", "Alex", "Tony", "rain")
dic = {'k1': "alex", 'k2': ' aric', "k3": "Alex", "k4": "Tony"}
for i in li:
if i.strip().capitalize().startswith('A') and i.strip().endswith('c'):
print(i)
for i in tu:
if i.strip().capitalize().startswith('A') and i.strip().endswith('c'):
print(i)
for i in dic.values():
if i.strip().capitalize().startswith('A') and i.strip().endswith('c'):
print (i)
實現商品輸出: 輸出商品列表,用戶輸入序號,顯示用戶選中的商品.
#方法一
l1=[1,2,3,4]
l2=["手機", "電腦", '鼠標墊', '游艇']
d=dict(zip(l1,l2))
print(d)
num=input("請輸入商品編號：")
print("你選擇的商品為 %s" %d[int(num)])
#方法二
li = ["手機", "電腦", '鼠標墊', '游艇']
for k, i in enumerate(li):
print(k,i)
k=input("請輸入商品編號：")
print("你選擇的商品為 %s" % li[int(k)])
實現猜數游戲: 實現讓用戶不斷的猜年齡,但只給最多3次機會,再猜不對就退出程序.
# -*- coding:utf-8 -*-
age = 22
count = 0
for i in range(10):
if count < 3:
a = int(input("請輸入一個猜測的數:"))
if a == age:
print("恭喜你,答對了")
break
elif a > age:
print("你猜的數字大了")
else:
print("你猜的數字小了")
else:
b = input("這都猜不對,你繼續玩嗎？(yes or not):")
if b == 'yes':
count = 0
continue
else:
print("Bye!下次再玩")
count += 1
實現三級菜單: 實現用戶交互,顯示省市縣三級聯動的選擇.
dic = {
"河北": {
"石家庄": ["鹿泉", "藁城", "元氏"],
"邯鄲": ["永年", "涉縣", "磁縣"],
},
"湖南": {
"長沙":['a','b','c'],
"株洲":['d','e','f']
},
"湖北": {
"武漢":['g','h','i'],
"黃石":['j','k','l']
}
}
for k in dic.keys():
print(k)
flag=True
while flag:
n=input("請輸入你所在省：")
for k in dic.keys():
if n in dic.keys():
if k == n:
for i in dic[n].keys():
print(i)
w = input("請輸入你所在的城市：")
for i in dic[n].keys():
if w in dic[n].keys():
if i == w:
for k in dic[n][w]:
print(k)
s=input("請輸入你所在的縣：")
for j in dic[n][w]:
if s in dic[n][w]:
if j==s:
print("你所在的位置是：%s省%s市%s縣" % (n,w,s))
flag = False
break
else:
print('不存在，請重新輸入')
break
else:
print('不存在，請重新輸入')
break
else:
print('不存在，請重新輸入')
break
實現一個購物車: 實現一個購物車小程序,並符合以下要求.
product = [
("iphone",5800),
("watch",380),
("bike",800),
("book",120),
("computer",4000)
]
shopping_car = []
salary = input("請輸入你的金錢: ")
if salary.isdigit():
salary = int(salary)
while True:
for i in enumerate(product):
print(i)
user_choice = input(">>>或者q:")
if user_choice.isdigit():
user_choice = int(user_choice)
if user_choice >= 0 and user_choice < len(product):
p_item = product[user_choice]
if salary >= p_item[1]:
shopping_car.append(p_item[0])
salary -= p_item[1]
print("你購買了\033[32m%s\033[0m,你的余額剩余\033[31m%s\033[0m" % (p_item[0], salary))
else:
print("\033[31m你的余額不足\033[0m")
else:
print("你輸入的項目[%s]不存在,請重新輸入" % user_choice)
elif user_choice == 'q':
print("你購買了這些商品:".center(30,"-"))
for i in shopping_car:
print("\033[32m%s\033[0m" %i)
print("\033[31m余額%s\033[0m" %salary)
exit()
else:
print("你輸入的[%s]不存在" % user_choice)
else:
print("你輸入的金額不正確！請重新輸入金額！")
Python 高級特性
◆Python 迭代器◆
迭代器是訪問集合元素的一種方式,迭代器對象從集合的第一個元素開始訪問,直到所有的元素被訪問完結束.迭代器只能往前不會后退,迭代器特別適合用於遍歷一些巨大的或是無限的集合,比如遍歷大小為GB級別的文件時效率特別高.
創建基本迭代器: 如下首先聲明一個列表,然后使用__iter__將其轉為迭代器,並通過__next__遍歷迭代對象.
>>> list = [1,2,3,4,5,6,7,8,9,10]
>>>
>>> item = list.__iter__()
>>> type(item)
<class 'list_iterator'>
>>>
>>> item.__next__()
1
>>> item.__next__()
2
>>> next(item)
3
>>> next(item)
4
迭代器與元組轉換: 通過使用enumerate方法,將列表轉為迭代器,然后強制轉為元組.
>>> listvar = ["呂洞賓", "張果老", "藍采和", "特乖離", "和香菇", "漢鍾離", "王文"]
>>>
>>> iter = enumerate(listvar) # 轉換為迭代器
>>> dict = tuple(iter) # 轉換為元組
>>> print(dict)
((0, '呂洞賓'), (1, '張果老'), (2, '藍采和'), (3, '特乖離'), (4, '和香菇'), (5, '漢鍾離'), (6, '王文'))
循環遍歷迭代元素: 由於迭代器遍歷結束會報錯,所以要使用try語句拋出異常.
>>> listvar = ["呂洞賓", "張果老", "藍采和", "特乖離", "和香菇", "漢鍾離", "王文"]
>>> item = listvar.__iter__()
>>>
>>> while True:
... try:
... temp = next(item)
... print(temp)
... except StopIteration:
... break
◆Python 生成器◆
生成器(Generator)是一個特殊的程序,可以被用作控制循環的迭代行為,Python中生成器是迭代器的一種,使用yield返回值函數,每次調用yield會暫停,而可以使用next()函數和send()函數恢復生成器.
當我們調用一個生成器函數時,其實返回的是一個迭代器對象
在Python語言中,只要表達式中使用了,yield函數,通常將此類函數稱為生成器(generator)
運行生成器時,每次遇到yield函數,則會自動保存並暫停執行,直到使用next()方法時,才會繼續迭代
跟普通函數不同,生成器是一個返回迭代器的函數,只能用於迭代操作,更簡單點理解生成器就是一個迭代器
在學習生成器之前,需要一些前置知識,先來研究一下列表解析,列表解析是Python迭代機制的一種應用,它常用於實現創建新的列表,因此要放置於[]中,列表解析非常靈活,可以用戶快速創建一組相應規則的列表元素,且支持迭代操作.
求階乘: 通過列表解析式,來實現列表的迭代求階乘.
>>> temp1 = [1,2,3,4,5]
>>> temp2 = [ x ** 2 for x in temp1 ]
>>> temp1
[1, 2, 3, 4, 5]
>>> temp2
[1, 4, 9, 16, 25]
求階乘: 通過列表解析式,實現迭代求階乘,並且只打印大於2(if x>=2)的數據.
>>> temp1 = [1,2,3,4,5]
>>> temp2 = [ x**2 for x in temp if x>=2 ]
>>> temp1
[1, 2, 3, 4, 5]
>>> temp2
[4, 9, 16, 25]
求階乘: 通過列表解析式,實現迭代求階乘,並通過range函數生成相關數據.
>>> temp = [ (x**2)/2 for x in range(1,10)]
>>> temp
[0.5, 2.0, 4.5, 8.0, 12.5, 18.0, 24.5, 32.0, 40.5]
數據合並: 通過列表解析式,實現迭代將兩個列表按照規律合並.
>>> temp1=["x","y","z"]
>>> temp2=[1,2,3]
>>> temp3=[ (i,j) for i in temp1 for j in temp2 ]
>>> temp3
[('x', 1), ('x', 2), ('x', 3), ('y', 1), ('y', 2), ('y', 3), ('z', 1), ('z', 2), ('z', 3)]
文件過濾: 通過使用列表解析,實現文本的過濾操作.
>>> import os
>>> file_list=os.listdir("/var/log")
>>> file_log=[ i for i in file_list if i.endswith(".log") ]
>>> print(file_log)
['boot.log', 'yum.log', 'ecs_network_optimization.log', 'ntp.log']
>>> file_log=[ i for i in os.listdir("/var/log") if i.endswith(".log") ]
>>> print(file_log)
['boot.log', 'yum.log', 'ecs_network_optimization.log', 'ntp.log']
接下來我們就來研究一下生成器吧,生成器類似於返回值為數組的一個函數,這個函數可以接受參數,可以被調用,但不同於一般的函數會一次性返回包括了所有數值的數組,生成器一次只能產生一個值,這樣消耗的內存數量將大大減小,而且允許調用函數可以很快的處理前幾個返回值,因此生成器看起來像是一個函數,但是表現得卻像是迭代器.
我們先來看以下兩種情況的對比,第一種方法很簡單,只有把一個列表生成式的[]中括號改為()小括號,就創建了一個生成器.
>>> lis = [x*x for x in range(10)]
>>> print(lis)
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> generator = (x*x for x in range(10))
>>> print(generator)
<generator object <genexpr> at 0x0000022E5C788A98>
如上例子,第一個lis通過列表生成式,創建了一個列表,而第二個generator則打印出一個內存地址,如果我們想獲取到第二個變量中的數據,則需要迭代操作,如下所示:
>>> generator = (x*x for x in range(10))
>>> print(next(generator))
0
>>> print(next(generator))
1
>>> print(next(generator))
4
>>> print(next(generator))
9
以上可以看到,generator保存的是算法,每次調用next(generaotr),就計算出他的下一個元素的值,直到計算出最后一個元素,使用for循環可以簡便的遍歷出迭代器中的數據,因為generator也是可迭代對象.
>>> generator = (x*x for x in range(10))
>>>
>>> for i in generator:
print(i,end="")
0149162536496481
生成器表達式並不真正創建數字列表,而是返回一個生成器對象,此對象在每次計算出一個條目后,把這個條目"產生"(yield)出來,生成器表達式使用了"惰性計算"或稱作"延遲求值"的機制序列過長,並且每次只需要獲取一個元素時,應當考慮使用生成器表達式而不是列表解析.
>>> import sys
>>>
>>> yie=( i**2 for i in range(1,10) )
>>> next(yie)
1
>>> next(yie)
4
>>> next(yie)
9
>>> for j in ( i**2 for i in range(1,10)):print(j/2)
練習實例: 通過函數,和yield關鍵字,生成幾個生成器.
>>> import sys
>>>
>>> def func():
yield 1
yield 2
yield 3
yield 4
yield 5
>>> temp=func()
>>> temp.__next__()
1
>>> temp.__next__()
2
>>> temp.__next__()
3
練習實例: 使用while循環構建一個生成器,並通過for遍歷打印出結果.
>>> import sys
>>>
>>> def yieldNum(x):
y=0
while (y <= x):
yield y
y += 1
>>> yie=yieldNum(5)
>>> for i in yie:
print(i)
練習實例: 使用生成器求1-10的平方.
>>> def yieldNum():
x=1
while (x <=10 ):
yield x ** 2
x += 1
>>> yie=yieldNum()
>>>
>>> for i in yie:
print(i)
練習實例: 使用生成器,自定義實現range函數.
>>> def xrange(num):
temp=-1
while True:
temp=temp+1
if (temp >= num):
return
else:
yield temp
>>> xrange(10)
<generator object xrange at 0x038E3030>
練習實例: 通過使用生成器求斐波那契數列.
>>> def fib(max):
n,a,b=0,0,1
while n < max:
yield b
a,b=b,a+b
n+=1
return "done"
>>> f=fib(5)
>>> f
<generator object fib at 0x038F4A20>
練習實例: 使用生成器,在單個進程情況下實現並發效果.
import time
def consumer(name):
print("%s 准備吃包子啦!" %name)
while True:
baozi = yield
print("包子[%s]來了,被[%s]吃了!" %(baozi,name))
def producer(name):
c = consumer('A')
c2 = consumer('B')
c.__next__()
c2.__next__()
print("老子開始准備做包子啦!")
for i in range(10):
time.sleep(1)
print("做了2個包子!")
c.send(i)
c2.send(i)
producer("alex")