python3基礎學習筆記

title: python基礎學習筆記
date: 2019-11-16 16:47:01
tags: python
categories: python

python基礎學習導圖

python程序基礎

程序 = 數據結構 + 算法，因此我用兩部分歸納了python程序設計基礎的內容。

數據結構

數據

	可變	不可變
有序	列表	元組、字符串
無序	字典、集合	數值

數據結構指數據的類型，計算機程序能處理各類數據，如數字、網頁、音頻、文本、視頻等等，不一樣的數據則須要定義不一樣的數據類型。python中能直接處理的數據類型有：整型、浮點型、字符型以及布爾型、複數類型五種。

整型

整型，整數類型，例如一、100、-122一、1213243455...，整型有四種表現形式，分別是：

二進制：如 0十、110...，只由1和0組成的數字，用0b或0B開頭的數字就是二進制類型。

八進制：如0O17一、0O732，由三位二進制組成，0o或0O開頭的數據就是八進制。

十進制：日常的數字如 一、二、-121等。

十六進制：由四位二進制組成，如0x01af,a~f表示10~15，由0x或0X表示。

由位數不一樣又分爲int 、short、long等。

浮點型

浮點數（float）也就是小數，python的浮點數有兩種表現形式：

一是十進制數表示，如：12.21等等

二是用科學計數法表示，如1.32e3,即1.32 * 10^3,雖然結果是整數，但類型是浮點型。

字符串型

字符串字符串是以單引號或雙引號括起來的任意文本，好比'hello'和"hello",字符串還有原始字符串表示法、字節字符串表示法、Unicode字符串表示法，並且能夠書寫成多行的形式（用三個單引號或三個雙引號開頭，三個單引號或三個雙引號結尾）。

布爾類型

布爾值只有True、False兩種值，要麼是True，要麼是False，在Python中，能夠直接用True、False表示布爾值（請注意是大寫），也能夠經過布爾運算計算出來（例如3 < 5會產生布爾值True，而2 == 1會產生布爾值False）。

複數類型

import cmath

形如 3 + 2j,和數學上表示同樣，只不過虛部是把i換成了j。

python至關於一個計算器，直接輸入便可，

>>> (3+2j)*(3+2j)
(5+12j)

變量

變量（variable），在python中，名稱只能由字母、數字、下劃線組成，且只能由字母開頭，變量不能和關鍵字相同。

python關鍵字列表：

其實開發者本身能夠在python自帶IDLE查看關鍵字列表

keyword.kwlist

字符串

全部的標準序列操做都適用與字符串，如索引、切片、乘法、成員資格檢查、長度。最小值、最大值，可是別忘了字符串是不可變的，因此全部的賦值都是非法的。

字符串設置

字符串轉義字符

'/'，在字符前加反斜線表示此字符不是特殊字符，是能夠讀出來的，若是不加程序會認爲是特殊字符從而會有不一樣的效果。

format字符串格式轉換

設置格式的值時，可使用單個的值（如字符串或數字），可以使用元組（若是要設置多個值的格式），還可使用字典。‘%’ 字符串格式運算符，‘%’較format簡單，format能夠運用於更復雜的格式替換。

下面簡單用元組演示：

>>> format = "Hello,%s,my name is %s"
>>> values = ("python","yujian")
>>> format%values
'Hello,python,my name is yujian'

關於如何用format設置格式：

每一個值被替換到字符串中都是替換用‘{}’括起來的元素，要在最終結果中包含‘{}’，則能夠用兩個花括號表示。

格式替換字段能夠設置三部分：

替換字段名

能夠向format提供未命名的參數，此參數表示一個字段名，而後在後面格式替換時代表參數值便可替換。如：

>>> "Hello,{name},welcome to {destination} world".format(name="yujian",destination="python")
'Hello,yujian,welcome to python world'

name即字段名，後面賦值字符串‘yujian’替換此字段

若在{}裏面是數字即表示索引，如：

>>> "{a}{0}{b}{1}".format(1,2,a=3,b=4)
'3142'

運用此方法要注意必須把索引的值放在前面，否則會引發位置衝突。

轉換標誌轉換

'!'轉換標誌符

轉換標誌：跟在‘ ！’號後面的單個字符，當前支持的字符包括r(表示repr，簡寫‘r’，轉義字符)、s(表示str)、a(表示ASCII)。

例如：

>>> "{a!r} {a!s} {a!a}".format(a = "Π")
"'Π' Π '\\u03a0'"

格式說明符

':'冒號表示格式說明符，冒號後面跟單個表達格式符或表達式，能夠參照正則表達式。

>>> "This number is {0:b}".format(8)
'This number is 1000'

設置浮點數的格式

設置浮點數默認格式是到小數點後六位，若不是你想要的格式，則能夠自行設定寬度和精度。

寬度和精度都是使用整數整定，例如：

整數整定：

>>> "This number is {0:b}".format(8)
'This number is 1000'
>>> "{num:10}".format(num = 3.14)
'     3.14'
>>> "{num:10}".format(num = "python")
'python   '

可見，數字和字符串的對齊方式不同。

精度整定:前面加一個小數點便可

>>> import math
>>> print("{num:.2f}".format(num = math.pi))
3.14

符號、對齊和0填充

在整度和精度的值前面添加一個標誌，這個標誌能夠是0、加號、減號、或空格，其中0表示用0來填充數字。

填充0：

>>> "{num:05}".format(num = 3.14)
'03.14'

對齊：

>>> print("{0:<8.2f}\n{0:^8.2f}\n{0:>8.2f}".format(math.pi))
3.14
3.14
3.14

指定字符填充：

>>> "{0:a^15}".format("yujian")
'aaaayujianaaaaa'

說明符「=」

它指定將填充字符放在符號與數字之間，如：

>>> print("{0:8.2f}\n{1:=8.2f}".format(math.pi,-math.pi))
3.14
-   3.14

如圖負號和數字分開了

若要加正負號，填充字符放在符號與數字之間加’+‘’-‘

'#'

放在符號說明符和寬度之間，如：

>>> "{:b}".format(32)
'100000'
>>> "{:#b}".format(32)
'0b100000'

如圖添加上了二進制信息

字符串經常使用方法

repr 和str

都表達轉換成字符串的意思，函數str() 用於將值轉化爲適於人閱讀的形式，而repr() 轉化爲供解釋器讀取的形式（若是沒有等價的語法，則會發生SyntaxError 異常）

print('1:' + str(123))  
print('2:' + repr(123))  
print('3:' + str('123'))  
print('4:' + repr('123'))

#結果：

1:123  
2:123  
3:123  
4:'123'

發現結果一、2是同樣的，4卻較3保留了引號，其實形成這種的緣由是str和repr都分別調用的是對象的__str__,__repr__方法，repr保留了符號是其實就是機器識別的語言。

center

方法center()經過在字符串兩邊添加填充字符，若是不指定默認是空格，如：

>>> print("Hello,YuJian".center(20,' '))
Hello,YuJian

find、index

方法find()經過在字符串中尋找子串，若是找到返回子串第一個字符的索引，不然返回-1，如：

>>> "the sun,the moon and you".find("moon",1,20)
12

如上我尋找到「moon「在第12個字符位置處，查找範圍是從從位置1到20，注意位置1是'the的'’t‘位置，但返回的都是在整個字符串中的位置。

方法index()查找指定字串在字符串中出現的位置，若沒有則引起ValueError。

如：

>>> "hello world".index("world")
6
>>> "hello world".index("wo")
6
>>> "hello world".index(" ")
5
>>> "hello world".index("w",0,15)
6
>>> "hello world".index("w",1,15)
6
>>> "hello world".index("you",1,15)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: substring not found

返回值與find方法同樣。

split、join

做用於join相反，用於將字符串拆分爲序列，返回的是列表。如：

>>> str = "maybe is she"
>>> print(str.split(' ' ,1))
['maybe', 'is she']
>>> print(str.split(' ' ,2))
['maybe', 'is', 'she']
>>> print(str.split('is' ,1))
['maybe ', ' she']
​

spite()方法若沒有指定分隔符，這默認從一個或多個連續的空白字符（空格、製表符、換行符等進行差分）。

join()方法鏈接多個字符串，返回經過指定「字符」鏈接生成的新字符串。如：

>>> str1 = "-"
>>> str2 = \["2019","11","11"\]
>>> print(str1.join(str2))
2019-11-11
>>> print(str.join(str1,str2))
2019-11-11

lower 、upper、title

title() #將每一個單詞開頭改成大寫
lower() #將整個字符串改成小寫
upper() #將整個字符串改成大寫

例如：

str = "hello,stranger"
print(str.lower())
print(str.upper())
print(str.title())
#結果
hello,stranger
HELLO,STRANGER
Hello,Stranger

strip、istrip、rstrip

strip() #刪除字符串先後的空白並返回刪除後的結果 lstrip() #刪除字符串前面的空白並返回刪除後的結果 rstrip() #刪除字符串後面的空白並返回刪除後的結果

如：

>>> str.strip()
'Hello,  world'
>>> str.lstrip()
'Hello,  world   '
>>> str.rstrip()
'    Hello,  world'
#指定刪除哪些字符
>>> str.strip("\*@")
'yujian'
>>> str.strip("\* @")
'yujian'
>>> str.strip("\*or@")
'yujian'
>>> str.strip("\*and@")
'yuji'

replace、translate

replace()方法用指定子串替換字符串中的目標子串

如：

>>> "Hello world".replace("world","yujain",4)
'Hello yujain'
將world替換成了yujian,4表示不超過4次

translate()方法使用指定的映射表對字符串進行替換，不過translate()方法須要手動輸入各字符的編碼進行替換，因此有了一種更方便的方法maketrans（）來建立映射表，如：

>>> table = str.maketrans('abc','αβγ')
>>> table
{97: 945, 98: 946, 99: 947}

此時映射表已經建立完成，而後就能夠較便捷的使用translate()替換了，如：

>>> str = "abscond"
>>> print(str.translate(table))
αβsγond

下面用一段程序來了解其餘一些字符串的應用：

def main():
    str1 = 'hello, world!'
    # 經過len函數計算字符串的長度
    print(len(str1))  # 13
    # 得到字符串首字母大寫的拷貝
    print(str1.capitalize())  # Hello, world!
    # 得到字符串變大寫後的拷貝
    print(str1.upper())  # HELLO, WORLD!
    # 從字符串中查找子串所在位置
    print(str1.find('or'))  # 8
    print(str1.find('shit'))  # -1
    # 與find相似但找不到子串時會引起異常
    # print(str1.index('or'))
    # print(str1.index('shit'))
    # 檢查字符串是否以指定的字符串開頭
    print(str1.startswith('He'))  # False
    print(str1.startswith('hel'))  # True
    # 檢查字符串是否以指定的字符串結尾
    print(str1.endswith('!'))  # True
    # 將字符串以指定的寬度居中並在兩側填充指定的字符
    print(str1.center(50, '*'))
    # 將字符串以指定的寬度靠右放置左側填充指定的字符
    print(str1.rjust(50, ' '))
    str2 = 'abc123456'
    # 從字符串中取出指定位置的字符(下標運算)
    print(str2[2])  # c
    # 字符串切片(從指定的開始索引到指定的結束索引)
    print(str2[2:5])  # c12
    print(str2[2:])  # c123456
    print(str2[2::2])  # c246
    print(str2[::2])  # ac246
    print(str2[::-1])  # 654321cba
    print(str2[-3:-1])  # 45
    # 檢查字符串是否由數字構成
    print(str2.isdigit())  # False
    # 檢查字符串是否以字母構成
    print(str2.isalpha())  # False
    # 檢查字符串是否以數字和字母構成
    print(str2.isalnum())  # True
    str3 = '  jackfrued@126.com '
    print(str3)
    # 得到字符串修剪左右兩側空格的拷貝
    print(str3.strip())


if __name__ == '__main__':
    main()

列表、元組、字典、集合

列表

建立列表，兩種方法，

a: a = []

b: a = list()

list() #list() 方法用於將元組或字符串轉換爲列表。

列表是能夠修改的序列，能夠像通常的序列進行增、刪、修改、檢查成員操做。

append() #追加元組，元組會被當成一個元素添加到列表中，追加列表也是同樣，會被當成一個元素 若是不想把追加的列表或元組當成一個總體，能夠用extend()方法。

PS:也就是說append追加的是一個總體，會把"[]"也加進去，而extend是把裏面的元素逐一加進去，元組不能追加，裏面的元素是固定了的不能改的

>>> list_a = [1,23,4]
>>> list_b = [2,5]
>>> list_a.extend(list_b)
>>> print(list_a)
[1, 23, 4, 2, 5]
>>> list_a.append(list_b)
>>> list_a
[1, 23, 4, 2, 5, [2, 5]]

del() #刪除列表裏單個元素或者一列元素，還能夠刪除變量 insert(number,element) #插入一個或者一段元素，可指定位置 remove() #移除列表匹配到元素的第一項 list.remove(obj) clear() #清空列表

sort() #list.sort( key=None, reverse=False) 默認升序，返回一個列表,sort()返回原列表，sorted()返回新列表。

>>> a = [1,2,3,4,5]
>>> b = [2,3,1,4,0]
>>> b.sort()
>>> b
[0, 1, 2, 3, 4]
>>> c = sorted(a)
>>> c
[1, 2, 3, 4, 5]
>>>

pop() #將列表當成棧使用

PS:pop是惟一既修改列表又返回一個非None值的列表方法

reverse() #將列表中的元素反向存放

def main():
    list1 = [1, 3, 5, 7, 100]
    print(list1)
    list2 = ['hello'] * 5
    print(list2)
    # 計算列表長度(元素個數)
    print(len(list1))
    # 下標(索引)運算
    print(list1[0])
    print(list1[4])
    # print(list1[5])  # IndexError: list index out of range
    print(list1[-1])
    print(list1[-3])
    list1[2] = 300
    print(list1)
    # 添加元素
    list1.append(200)
    list1.insert(1, 400)
    list1 += [1000, 2000]
    print(list1)
    print(len(list1))
    # 刪除元素
    list1.remove(3)
    if 1234 in list1:
        list1.remove(1234)
    del list1[0]
    print(list1)
    # 清空列表元素
    list1.clear()
    print(list1)


if __name__ == '__main__':
    main()

元組

元組，是不可更改的序列，用（）包括的序列就是元組，元組和列表的建立和內存佔比明顯前者更優。元組的列表有許多類似的，惟一不一樣之處就在於元組不可更改，裏面的元素是固定了的。

建立方式：

a = (element1,element2...)

a = turple()

tuple() #Python 元組 tuple() 函數將列表轉換爲元組

元組和列表的共用方法：

只有一個元素的元組：（1，） 必須帶逗號

列表和元組均可以用加法和乘法，但只能同類型的

max() 求元組或列表的最大值 min() 求元組或列表的最小值 len() 求元組或列表的長度

index() #用於某個元素出如今列表或元組中的位置 count() #用於統計某個元素在列表中或元組出現的次數

in運算運用於列表、元組是否包含元素

列表封包和序列解包

程序把多個值賦給一個變量時，python會自動把多個值封裝成元組，這叫作封包；

程序容許直接將序列（列表或元組）賦給多個變量，此時序列的各元素會依次賦給各個變量，這叫作解包，但序列的元素和變量的元素應該相同。

>>> list_a = [1,2,3]
>>> a,b,c = list_a
>>> print(a,b,c)
1 2 3
#變量前加\*號表示該變量表示一個列表
>>> c,*d = list_a
>>> print(c,d)
1 [2, 3]

集合

set和dict相似，也是一組key的集合，但不存儲value。因爲key不能重複，因此，在set中，沒有重複的key。

要建立一個set，須要提供一個list做爲輸入集合：

>>> set1 = set([1,2,2,3,3,4,4,5,6,])
>>> set1
{1, 2, 3, 4, 5, 6}
>>> set2 = set([2,3,4,7,8])
>>> set1&set2
{2, 3, 4}
>>> set1|set2
{1, 2, 3, 4, 5, 6, 7, 8}
>>> set1-set2
{1, 5, 6}

Python中的集合跟數學上的集合是一致的，不容許有重複元素，並且能夠進行交集、並集、差集等運算,也和數學上的運算一致。

字典

元組能夠做爲dictionary的key,但列表不能，這是由於字典要求key是不可變的

dict = dict()
dict = {}.fromkeys()
dict = {}

字典的基本用法： 經過key訪問value值，修改、刪除、添加key-value對，以及判斷key-value對是否存在

字典的經常使用方法：

clear() #清空全部的key-value對 get() #獲取key的value值 update() #用新字典更新原有字典，如有則覆蓋無則添加 items()、keys()、values() #分別用於獲取全部的key-value值，全部的key值，全部的value值，分別返回 dict_items、dict_keys、dict_values對象。

pop() #獲取指定key的value同時這個鍵-值會從子典中刪除。

popitem() #方法用於彈出字典最後一個key-value對，而且封裝成元組

setdefalt() #也是根據key來獲取value值，但有一點不一樣，如若沒有它將返回爲之設置的默認值。

>>> dict1 = {'sun':20,'liu':21}
#沒有 key='deng',則先設置key = 'deng',value=20,而後返回該key的鍵值
>>> print(dict1.setdefault('deng',20))
20
>>> dict1['xia'] = 21
>>> dict1
{'sun': 20, 'liu': 21, 'deng': 20, 'xia': 21}
#存在key='xia'，則不會修改該value值
>>> dict1.setdefault('xia',23)
21

{}.fromkeys() #設置新字典

運算符

Python支持多種運算符，下表大體按照優先級從高到低的順序列出了全部的運算符，咱們會陸續使用到它們。

運算符	描述
[] [:]	下標，切片
**	指數
~ + -	按位取反, 正負號
* / % //	乘，除，模，整除
+ -	加，減
>> <<	右移，左移
&	按位與
^	按位異或，按位或
<= < > >=	小於等於，小於，大於，大於等於
== !=	等於，不等於
is is not	身份運算符
in not in	成員運算符
not or and	邏輯運算符
= += -= *= /= %= //= **= &= = ^= >>= <<=	（複合）賦值運算符

注：在實際開發中，若是搞不清楚優先級可使用括號來確保運算的執行順序。

算法

過程控制

程序控制結構有順序結構、分支結構以及循環結構，相似於C語言及、java。

順序

順序結構很好理解，一行一行運行下去，直達最後爲止。

分支

grades = int(input("請輸入你的成績："))

if grades >= 90:
    print("excellent")
elif grades >= 70:
    print("good")
elif grades >= 60:
    print("qualified")
else: 
    print("disqualified")

上面用簡單的if分支結構來輸出你的成績等級，共有三條關鍵語句，if 、elif(else if)，和else語句。

if 語句還有一個親戚斷言即 assert,語句邏輯爲

grades = int(input("請輸入你的成績："))  
​  
assert grades >= 80  
print("great")  
​  
#結果  
請輸入你的成績：60  
Traceback (most recent call last):  
 File "d:\Vscode\My code\blog.py", line 3, in <module>  
 assert grades >= 80  
AssertionError

如上，未爲知足成績大於等於80將引起錯誤

注意：python語句縮進必須所有相同，通常python習慣縮進四個字符， 另外if條件能夠是任意類型，當下面的值做爲bool類型表達式時，會被認爲false類型 ，各種空值如：False、None、0、""、[]、{}

循環

Python中構造循環結構有兩種作法，一種是for-in循環，一種是while循環。

for循環

若是明確的知道循環執行的次數或者是要對一個容器進行迭代（後面會講到），那麼咱們推薦使用for-in循環， for循環專門用於遍歷範圍、列表、元素和字典等可迭代對象包含的元素。語法格式以下：

for 變量 in 字符串|範圍|集合等：
statements

例如咱們要計算1~100的和

sum = 0  
for i in range (1,101):  
 sum += i  
print(sum)

.range()能夠用來產生一個不變的數值序列，並且這個序列一般都是用在循環中的，例如： ·range(101),能夠用來產生1-100的數 ·range(1,10),能夠產生1-9的數 ·range(0,101,2)能夠產生1-100的偶數序列，2是步長

while循環

若是要構造不知道具體循環次數的循環結構，咱們推薦使用while循環，while循環經過一個可以產生或轉換出bool值的表達式來控制循環，循環條件表達式的值爲True循環繼續，表達式的值爲False循環結束。

while 循環條件：

循環體

舉一個簡單例子，

name = str(input("input your name:"))
while name == "yujian":
    print("welcome,yujian")
    break
else:
    print("hey,who are you?")

注意：上面的代碼中使用了 break關鍵字來提早終止循環，須要注意的是 break只能終止它所在的那個循環，這一點在使用嵌套的循環結構（下面會講到）須要引發注意。除了 break以外，還有另外一個關鍵字是 continue，它能夠用來放棄本次循環後續的代碼直接讓循環進入下一輪。

只有輸入正確的名字才能夠經過，這就相似於登陸帳戶時的情景了。

練習：

一、判斷一個數是否是素數( 素數又叫質數（prime number），有無限個。質數定義爲在大於1的天然數中，除了1和它自己之外再也不有其餘因數 )

num = int(input('please enter a number:'))  
for i in range(2, num):  
    if num % i == 0:  
    print('%d不是素數' % num)  
    break  
else:  
    print('%d是素數' % num)

#或者

from math import sqrt

num = int(input('請輸入一個正整數: '))
end = int(sqrt(num))
is_prime = True
for x in range(2, end + 1):
    if num % x == 0:
        is_prime = False
        break
if is_prime and num != 1:
    print('%d是素數' % num)
else:
    print('%d不是素數' % num)
#參照一個大佬的計算量減了一個深度,zan

二、統計素數

a, b = int(input("請輸入起點數：")), int(input("請輸入終點數:"))
sum = 0
for i in range(a, b+1):
    for j in range(2, i):
        if i % j == 0:
            break
    else:
        print(i, end=",")
        sum += 1
print("質素一共有%d個" % sum) 
​

三、打印等腰三角形

#正等腰
lines = int(input("請輸入行數 ： "))
for i in range(lines):
    for j in range(lines - i):
        print(end=" ")
    print("\*" \* (2\*i+1))
    print()
'''請輸入行數 ： 5
     *

    ***

   *****

  *******

 *********'''

#倒等腰
lines = int(input("請輸入行數 ： "))
for i in range(lines):
    for j in range(i):
        print(end=" ")
    print("*" * ((lines - i) * 2 - 1))
    print()
'''
請輸入行數 ： 5
*********

 *******

  *****

   ***

    *
'''

四、打印菱形

#實心菱形
lines = int(input("請輸入奇數行： "))
half_lines = lines // 2 + 1

#上半部分
for i in range(half_lines):
    print(" "*(half_lines-i), end="")
    print("*" * (2*i+1))

#下半部分
for i in range(half_lines-1):
    print((" ")*(i+2), end="")
    print("*" * (lines-2-2*i))
'''請輸入奇數行： 5
   *
  ***
 *****
  ***
   *'''

#空心菱形
side = int(input("請輸入菱形每條邊星星的個數: "))
a = side
b = side

print(" "*(a-1), "*")

#上半部分菱形
for i in range(2, a+1):
    print(" "*(a-i), "*", " "*(2*i-4), "*")

#下半部分
for i in range(b-1, 1, -1):
    print(" "*(b-i), "*", " "*(2*i-4), "*")

print(" "*(side-1), "*")
'''請輸入菱形每條邊星星的個數: 5
     *
    *  *
   *    *
  *      *
 *        *
  *      *
   *    *
    *  *
     *'''

五、N宮格橫豎斜和相等算法

lines = int(input("請輸入奇數行數： "))

array = [[0] * lines]

for i in range(lines):
    array = array + [[0] * lines]

row, col = 0, lines // 2

for i in range(1, lines * lines + 1):
    array[row][col] = i
    if i % lines == 0:
        row += 1
    elif row == 0:
        row = lines - 1
        col += 1
    elif col == lines - 1:
        row -= 1
        col = 0
    else:
        row -= 1
        col += 1

for i in range(lines):
    for j in range(lines):
        print("%02d" % array[i][j], end=" ")
    print()
'''
請輸入奇數行數： 5
17 24 01 08 15
23 05 07 14 16
04 06 13 20 22
10 12 19 21 03
11 18 25 02 09
'''

​

如今才懂的多位數的解法 🤦‍♂

n奇數幻方口訣：

1. 數字1放在第一行中間
2. 依次放在上一個數的右上角

2.1若是右邊出去了就回到左邊（3，4） 2.2 若是上面出去了就放下面（1，2） 2.3 若是右上角有了就放在這個數的下面

六、水仙花數

水仙花數指一個三個位，其個位數字的立方和等於該數自己，如153 = 1^3+5^3+3^3

#查找100~1000之間的水仙花數
for i in range(100, 1000):
    a = i % 10
    b = i // 10 % 10
    c = i//100
    if a**3 + b**3 + c**3 == i:
        print(i,end="、")  
​```

七、統計字符串裏面的字母、數字、空格以及其餘字符

input_str = input("請輸入一個字符串：")

char_num, digit_num, char_kon, other_num = 0, 0, 0, 0

for c in input_str:
    if c.isdigit():
        digit_num += 1
    elif c.isalpha():
        char_num += 1
    elif c is " ":
        char_kon += 1
    else:
        other_num += 1

print("字母個數爲：", char_num)
print("數字個數爲：", digit_num)
print("空格個數爲: ", char_kon)
print("其餘字符個數：", other_num)
'''請輸入一個字符串：qaz123_- - =——  +——23sasd^%&
字母個數爲： 7
數字個數爲： 5
空格個數爲:  4
其餘字符個數： 12'''

說明： str.isalpha() 判斷是否由字符組成，str.isdigit() 判斷是否由數字組成

函數

定義函數

一、語法格式：

def 函數名（形參列表）: //由零條到多條可執行語句組成的函數 return 返回值

二、從程序的可讀性來看，函數名應該由一個或多個有意義的單詞連綴而成，每一個單詞所有小寫，單詞與單詞之間使用下劃線分隔。

三、函數的說明文檔， 在函數聲明以後,註釋說明便可。

def max(x,y):  
 '''  
 獲取兩個值較大的那個數  
 '''  
 max = x if x \> y else y  
 return max  
​  
help(max)  
print(max.\_\_doc\_\_)

能夠調用__doc__函數來看說明文檔,也能夠 用help()函數來看說明文檔

四、遞歸函數

在一個函數內調用它自身，被稱爲遞歸函數，定義遞歸函數時，遞歸必定要向已知方向進行，不然形成死循環。

函數參數

一、python要求將帶默認值的參數定義在形參的最後，關鍵字參數必須位於位置參數的後面，意思是若傳入兩個參數，有一個是關鍵字參數，那另外一個就是位置參數，必須將位置參數放在傳入參數的第一位，若此時關鍵字參數對應的事函數的第一位參數，則將與傳入的參數起衝突。

例如：

def student(grade,number):
    print("I am in %d grade %d number" % (grade,number))

student(15,1)
student(grade=15,number=1)
student(number=1,grade=15)
student(15,number=1)
#不可將關鍵字參數放在前面，錯誤方式
#student(number=1,15)
#或者兩個都指向同一個位置參數，錯誤
#student(grade=15,15)

二、參數收集（參數可變的參數）

說明：在形參前面添加一個星號，這就意味着該參數能夠接受多個參數，多個參數會被當成 元組傳入，加兩個星號該參數能夠收集 字典。

def foo(x,\*y):
    print("x參數：",x)
    print("y參數:",y)
foo(1,2,3,4,"伍")
#逆向參數收集
my\_tuple = (1,2,3,4)
foo(\*my\_tuple)

'''
x參數： 1
y參數: (2, 3, 4, '伍')'''
'''

觀察結果，y傳入的參數是一個元組

三、逆向參數收集

說明： 指的是在傳入的列表、元組參數以前添加一個星號，字典添加兩個，可使他們的元素拆開來傳遞。

可見，它傳入的參數是一個已經定義的數組，逆向參數收集方式能夠把這個數組拆開傳遞。

lambda表達式

格式：lambda [parameter_list]: 表達式

說明： lambda關鍵字以後，冒號左邊的是參數列表，能夠沒有參數，也能夠用逗號隔開的多個參數，右邊是該lambda表達式的返回值。

#例子
lambda x,y:x + y
#等同於
def sum(x,y):
     return x + y

調用函數

說明：__name__是Python中一個隱含的變量它表明了模塊的名字

只有被Python解釋器直接執行的模塊的名字纔是__main__

類和對象

定義類

class [name]():可調用參數

類可繼承，父類寫在括號裏，默認是object參數，全部的類都是object的繼承 類的實例化叫對象，對象是存在的具體

def __init__(self,):

#也叫作構造方法，self參數是默認的，也就是自動綁定到構造方法初始化的對象。

class Student(object):
    def __init__(self,name,age,height):
        self.name = name
        self.age  = age
        self.height = height
    def student_name(self):
        print("The boy who watching book is name %s" % self.name,end=",")
    def student_age(self):
        print("ia a %d boy"%self.age,end=",")
    def student_height(self):
        print("and am is %5.2f tall."%self.height)

def main():
    student_A = Student('sun',20,175)
    student_A.student_name()
    student_A.student_age()
    student_A.student_height()

if __name__ == "__main__":
    main()

類能夠調用實例方法，類方法與靜態方法區別是：類方法會自動綁定第一個參數class到類自己，而靜態方法則不會。

注意：在英語交談中，使用複數來表示一個類如birds-鳥類，可是python中約定使用單數並將首字母大寫。

@函數裝飾器

在函數前加@表示將被裝飾的函數被做爲一個從參數傳給了裝飾函數，而且將返回值給被裝飾函數，所以被裝飾的函數此時可能再也不是一個函數而多是一個值或字符串。

def funB(fn):
    print('B')
    fn()#執行傳入的fn參數
    return 'result'

@funB
def funA():
    print("A")
print(funA)

step1：將funA做品爲參數傳給funB,即funB(funA)。

step2: 將funA替換成step1的返回值即’result‘，此時funB不在是一個函數而是一個字符。

變量

變量分爲類變量和實例變量，分屬不一樣的命名空間，從而調用的時候方式就不同。

類命名空間對象均可以訪問。

property()定義屬性 property（getting,setting,doing,doc） property函數有四個參數，分別是不讀不寫、只讀、讀寫、讀寫刪 。其實程序嘗試對對象進行讀寫操做都被委託給了property裏參數表明的方法來實現。

封裝

封裝指將對象的信息隱藏在對象內部，用戶只能經過對象訪問。python使用雙下劃線來表示變量隱藏起來，但實際並無隱藏，經過類依舊能夠訪問。

類中將雙下劃線開頭（__）的認定爲隱藏屬性，Import*不會導入隱藏屬性的變量、方法。

直接訪問下劃線開頭的方法會被python報錯，能夠經過類訪問，但一般不會這麼作，由於隱藏屬性就是不但願外部人員能直接訪問。

繼承

一個子類能夠繼承多個父類，只須要在類命名是在後面括號類聲明便可。子類繼承父類的方法。戶能夠直接從寫父類方法，也可使用未綁定方法調用被重寫的方法，須要注意的是：在經過類名調用實例方法時，python不會爲實例方法的第一個參數self自動綁定值，而是須要本身顯式綁定self，這種機制被稱爲未綁定方法。

使用super()調用父類的構造方法， python在繼承多個父類時，排在前面的構造方法會被優先使用 super（）會自動綁定第一個參數self

def __init__(self,method1,method2...):
    #使用super方法重構造屬性
    super().__init__(methods1)
    #直接經過繼承的父類重構造
    class2.__init__(self,method2)

多態

當同一變量在調用同一個方法時，徹底可能呈現不一樣的多種行爲，這就是多態。 issubclass(cls,class or tuple):檢查cls是不是後一個類或元組的子類 isinstance(obj,class or tuple)檢測obj是不是後一個類或元組的對象

**__slots__限定屬性**

lass Person(object):
   # 限定Person對象只能綁定_name, _age和_gender屬性
    __slots__ = ('_name', '_age', '_gender')

python語言的動態性

動態性指對象、方法都是能夠增刪修改的，類都是type（）方法建立的，type（'類名'，（object）,dict(,)） __slots__動態添加方法屬性

異常處理

try:
    x = int(input("please input a number: "))
    y = int(input("please input a number: "))
    print(x/y)
except:
    print("something wrong...")

try:
    print('try...')
    r = 10 / 0
    print('result:', r)
except ZeroDivisionError as e:
    print('except:', e)
finally:
    print('finally...')
print('END')

當咱們認爲某些代碼可能會出錯時，就能夠用try來運行這段代碼，若是執行出錯，則後續代碼不會繼續執行，而是直接跳轉至錯誤處理代碼，即except語句塊，執行完except後，若是有finally語句塊，則執行finally語句塊，至此，執行完畢。

二、斷言assert、logging也是調試異常處理的重要方式

參考資料

駱昊大神GitHub Python-100-Days-master

python3基礎 芒努斯·利·海特蘭德

瘋狂的python講義 李剛

python教程 廖雪峯

...

學無止境，未完待續...