python基礎語法學習筆記

python

python安裝方法

http://www.python.org

python的使用

1. python的互動式環境進入，win10中採用win+R快捷鍵進入執行視窗，輸入python進入python。exit( )或者quit()退出互動式環境。

2. 申明一個.py檔案，即可儲存python程式碼。開啟命令列的提示符，進入到檔案所在的路徑，直接輸入python 檔名.py

   註釋

   單行註釋

   python的註釋是ctrl+/，或者是用 #

   多行註釋

   '''
   多行註釋採用的是三個多引號
   '''
   

   python的IDE

   使用的python的IDE為PyCharm

第一章

變數

python是一門強型別語言，不需要制定資料型別，給變數賦值的同時確定變數的資料型別

凡事皆物件

變數的定義

a = 10;
a = '小李同學';
print(a);
# 變數名 = 資料

變數的資料型別：

graph LR; A(資料型別) --> B(數字 num); A --> C(字串 str); A --> D(字典 dict); A --> E(元祖 Tuple); A --> F(列表 list); B --> B1(int 有符號整型); B --> B2(long 長整型 Python3中取消); B --> B3(float 浮點); B --> B4(complex 複數 ); B --> B5(布林 bool);

#查詢資料型別函式
b = type(a);
#元祖型別tuple
b = ();
#列表型別list
b = [];
#字典型別dict
b = {};
 

變數命名規則

• 變數必須以字母或者下劃線開始

• 變數不能是數字或者其他符號開始

• 變數可以區分大小寫

• python中的關鍵字不能作為變數名

運算子

算數運算子

算數運算子	作用描述	示例
+加	算數加	5 + 3 = 8
-減	算數減	5 - 3 = 2
*乘	算數乘	5 * 3 = 15
**指數	左邊是底數，右邊是指數	5 ** 3 = 125
%餘數	求餘數	5 % 3 = 2
/除法	結果包含小數（會自動轉換為float）	5 / 2 = 2.5
// 地板除	結果忽略小數	5//2 = 2

比較運算子

比較運算子	名稱
==	等於
！=	不等於
>	大於
<	小於
>=	大於等於
<=	小於等於

邏輯運算子

邏輯運算子	描述
and	與
or	或
not	非

位運算子

位運算子	描述
&	按位與
|	按位或
^	按位異或
~	按位取反
<<	左移位
>>	右移位

print(12&8) #結果是8 12:1100 8:1000 結果為1000 8
print(4|8) #結果是12
print(-8>>2) #結果是-2

賦值運算子

賦值運算	描述
=	右邊的值賦給左邊
+=	c += a; c = c + a;
-=	c -= a; c = c - a;
*=	c *= a; c = c * a;
/=	c /= a; c = c / a;
%=	c %= a; c = c % a;
**=	c **= a; c = c ** a;
//=	c //= a; c = c // a;

輸入和輸出

通過使用%佔位符號，\n換行。

name = 'zhang';
class =' 一（1）班';
print('我的名字是%s : 來自【%s】'%(name,class));

格式符號	轉換
%c	字元
%s	字串
%i	有符號十進位制整數
%d	有符號十進位制整數
%u	無符號十進位制整數
%o	八進位制整數
%x	十六進位制整數
%e	索引符號
%E	索引符號
%f	浮點數

個數畫輸出的其他方式 .format()

name = 'zhang';
class =' 一（1）班';
print('我的名字是:{}, 來自【{}】'.format(name,class));

函式input可以獲得輸入，獲得的為字串。

name = input('請輸入：');

print(print(3))

#結果為：
#3
#None

上例說明：

python是編譯一部分執行一部分，再編譯一部分執行一部分

每次執行一部分都會得到一個物件，執行print（3）語句的結果為None

None也是一個物件（object），物件型別是NoneType

輸出中文也可以使用Unicode的方法，在知道中文字對應的16進位制程式碼(也可以使用函式ord()獲得)

print('\u5317') #北
print('\u5317'，end=`-->`) #北  

print函式是以回車結束，中間是空格，可以通過在末尾加sep=和end=進行修改，也可以加file=修改列印的檔案

def print(self, *args, sep=' ', end='\n', file=None): # known special case of print
    """
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    
    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.
    """
    pass

第二章

流程控制

python 中藍色字型的對齊排版是非常重要的

流程：程式碼執行的順序

graph LR; A(流程)-->B1(順序流程) B1 --> C0(程式預設的流程) A -->B2(選擇流程) B2 -->C1(單分支) B2 -->C2(雙分支) B2 -->C3(多分支) A -->B3(迴圈流程)

if的使用

if 條件表示式：
   python程式碼
else:
   python程式碼

if 條件表示式：
   python程式碼
elif:
   python程式碼
elif:
   python程式碼
else:
   python程式碼

例項

score = 60
if (score <= 60):
    print('成績不及格')
    pass #pass代表空語句，表示暫時不處理，作用是使程式碼看起來更完整，常用於填坑
print('結束')

score = 60
if (score <= 60):
    print('成績不及格')
    pass #pass代表空語句，表示暫時不處理，作用是使程式碼看起來更完整，常用於填坑
else:
    print('成績及格')
    pass
print('結束')

注意在C語言中是沒有:的，注意區別。

//C 語言
  int score = 60;
  if (score <= 60){
      printf("成績不及格\n");
  }
  else{
      printf("成績及格\n");
  }
  printf("結束\n");

迴圈流程 while() for()

while(條件表示式)：
  python程式碼

for ...(變數) in ...(可迭代集合物件)
	python程式碼

注意在C語言中是沒有:的，注意區別。

python中的縮排是有語法意義的

示例1:輸出1到10

index = 1
while index <= 10:
    print(index)
    index += 1
    pass;

//C 語言
int index = 1;
while (index <= 10){
    printf("%d\n",index);
    index += 1;  
}

示例2：輸出三角形

row = 1
while(row <= 7):
    j = 1
    while(j <= row):
        print('*',end=' ')#將換行符修改為空格
        j += 1
        pass
    print('\n')#兩個換行符因為自帶一個換行符
    row += 1
    pass

//C語言
int row = 1;
while(row <= 7){
   int j = 1;
   while(j <= row){
        printf("* ");
        j += 1;  
   }
    printf("\n\n ");
    row += 1;
}

for迴圈示例

tags = '小李同學'; #字串是字元型別的集合
for item in tags:
    print(item);
    pass

#range 此函式可以生產一個數據集合列表
#range(開始：結束：步長) 步長不能為0  注意和MATLAB去別 MATLAB是(開始：步長：結束)

a = range(1,101,1); #資料是左包含 右不包含 此資料為1到100
for data in a:
    if (data % 3) == 0:
        print(data, end = ' ');
        pass
    pass

//C語言

for (int data = 1; data < 100; data++){
    if ((data % 3) == 0)
    printf("%d ", data);
} 

break中斷結束，僅能在迴圈中使用

continue跳過此次迴圈，進入下次迴圈僅能在迴圈中使用

例項 剪刀 石頭 布

import random;
while(1):
    person = int(input('請出拳[0:剪刀 1:石頭 2:布]:'));
    computer = random.randint(0, 2);
    print(computer);
    if (person - computer == 1) or (person - computer == -2):
        print('you win');
        pass;
    elif (person == computer):
        print('平手');
        pass;
    else:
        print('you lose');
    pass;

第三章

序列操作

2021年6月9日 day3 class3

序列：一組按順序排列的值【資料集合】

在python中存在三種內建的序列型別：字串 列表 和 元組 字典不屬於序列的範圍

序列的優點：可以支援索引和切片的操作

序列的特徵：第一個正索引為0，指向的是左端，第一個索引為負數的時候，指向的是右端。

字串string''

切片：擷取字串中的一段內容，是屬於字串的高階特性。

切片使用語法：[起始下標：結束下標：步長]切片擷取的內容不包含結束下標對應的資料，步長指的是隔幾個下標獲取一個字元，步長預設為1。

注意切片操作不會出現越界的情況，是左閉右開。

語法結構：[start: end: ​step]

函式名
capitalize()	isalnum()	islower	swapcase	title()
endswith/startwith()	isalpha	join	Istrip/rstrip/strip	replase(old,new,count=None)
find()	isdigit()	lower/uper	split	count()

部分函式解析：

a.index('a') 功能類似於find() ： 檢測字串中是否包含子字串，返回的是下標值（從0開始），index若沒有找到對應的資料便會報異常，find是返回（-1）

Test = 'python';
#print(type(Test));
print('獲取第一個字元%s'%Test[0])
for item in Test:
    print(item,end=' ')
    pass

name = 'peter'
print('首字母大寫%s'%name.capitalize()); #首字母大寫 輸出為Peter

name = '   hello   ';
b = name.strip();  #去除空格
c = name.lstrip(); #去除左空格
d = name.rstrip(); #去除右邊的空格
print(b);

f = name; #複製操作，此時name和f完全一致
print('f的id地址%d'%id(f));
print('name的id地址%d'%id(name)); #兩個的id是相同的 f重新賦值後，地址發生變化

dataStr = ' I love you';
m = dataStr.find('u');  #查詢目標值在目標值中的位置，返回位置值（從0開始），僅查詢一個，若不存在，則返回-1
print(m);
print(dataStr.startswith('I')); #判斷是否以I開頭，返回bool值true 或者false endswith類似

print(dataStr.lower()) #全部轉換為小寫
print(dataStr.upper()) #全部轉換為大寫

列表list []

特點1、支援增刪改查

2.列表中的資料是可以變化的【資料項可以變化，但是地址不變】

3.用中括號表示列表型別，資料項中間用逗號分割，資料項是任何型別的資料

4.支援切片操作

函式名	功能描述
append	在列表後面追加元素
count	統計元素出現的次數
exend	拓展，相當於批量新增
index	獲取指定元素索引號
insert	在指定位置插入元素
pop	刪除最後一個元素
remove	移除左邊找到的第一個元素
reverse	反轉列表
sort	列表排序

li=[1,2,2,'小李同學'];
print(len(li));  #結果是4個數據

list=[1,2,3,'abcd',343,234,True];
print(list); #輸出列印物件
print(list[3]); #輸出第3個元素  返回的是元素
print(list[0:3:1]); #輸出0到3個元素  返回的是列表
print(list*2); #輸出多次列表中的資料

#增加
list.append([2,3,4,'love']);
#插入
list.insert(1,'love'); #需要指定位置
#強制轉換
rsdata = list(range(3));
list.extend(rsdata);  #批量新增，拓展  等效於list.extend([0,1,2]); 
print(list);

#修改
list[0] = 'peter';
list[0] = 234.45;
#刪除
del list[0]; #通過del刪除列表元素
del list[2:4]; #通過切片實現批量操作
list.remove('love'); #移除指定元素，是元素
list.pop(0);  #移除的是指定位置的元素
list.index(a,ranga,rangb); #在ranga 到 rangb 中查詢a

元組tuple ()

元組是一種不可變的序列，建立後不能做任何修改，但是可以對元組中的列表元素進行修改

用（）建立元組，資料項可以是任何型別，用,分割，當元組中只有一個元素時也要加上,否則編譯器會當做整型處理，同樣可以支援切片操作。

無法進行增刪改，僅可以進行查詢

tupleA = ('abcd',2,3,4,True,'love',[2,3,4]); #元組建立 tuple
#元組的查詢
for item in tupleA:
    print(item,end=' ');
    pass
print(tupleA[0:3]); #使用切片取值
print(tupleA[-3:-1：1]); #倒著取下標    -1是最右邊的資料
print(tupleA[-2:-4：-1]); #倒著取下標

tupleA[6][0] = 23; #可以對元組中的列表修改
c = tupleA.count(2);#統計元素出現的次數

字典dict{}

• 字典不是序列，不能採用切片操作，沒有下標的概念，是內建的高階資料型別
• 是有 鍵值對 組成的集合，通常使用鍵值對訪問資料

• 可以儲存任意物件，字典是以鍵值對的形式建立的{'key':'value'}每個鍵值對用逗號,隔開
• 鍵不能重複，且是不可變的，鍵是唯一的。值可以是任意的型別
• 每個鍵必定是惟一的，如果存在重複的鍵，後者會覆蓋前者

常用的鍵的操作

修改元素、新增元素、刪除元素、統計個數，獲取值：keys、獲取值：values，獲取鍵值對、刪除指定鍵

#新增字典資料
dictA = {};
dictA['name'] = '小李同學' #key ：value
dictA['age'] = 25;
dictA['pos'] = 'doctor'
print(dictA)

dictB = {'name':'zhangxf','school':'CQU'}
print(dictB)             #輸出完整的字典
print(len(dictB))

print(dictA['name'])   #讀取字典中的值即查詢 通過鍵獲取值
dictA['name'] = '小李同學'
print(dictA)

# 獲取所有的鍵
print(dictA.keys())
# 獲取所有的值
print(dictA.values())
# 獲取所有的資料項
print(dictA.items())

for item1,item2 in dictA.items():
    print('%s == %s'%(item1,item2))
    pass
# 輸出結果
# name == zhangxf
# age == 25
# pos == stu

#修改字典
dictA.update({'name':'xiaol'})
print(dictA)

#刪除操作  通過鍵進行操作
del dictA['name']
print(dictA)

dictA.pop('age')
print(dictA)

#排序操作
print( sorted(dictA.items(),key=lambda d:d[0]) )
# d:d[0]代表的是按照key排序，d:d[1]代表的是按照value 排序，key=lambda d:d[]是固定用法

共有方法

+ 合併

strA = '人生苦短'
strB = '還好有你'
print(strA+strB)
#結果：人生苦短還好有你 
#字串合併和列表合併相同

*複製 可以複製多倍

strA = '人生苦短'
print(strA*3)
#結果：人生苦短人生苦短人生苦短

in物件是否存在

strA = '人生苦短'
print('生' in strA)
#結果：True 是一個bool型別的資料
print('我' in strA)
#結果：False

字串和列表相同，對於字典來說是判斷 鍵是否存在於字典中。

第四章

函式

函式主要有：函式引數（傳參，呼叫，不定長引數）和返回值

函式定義

函式是一系列Python語句的組合，可以在程式中執行一次或者多次，可以完成具體的獨立功能。

函式的意思：程式碼的複用最大化以及最小化冗餘程式碼

def + 關鍵字 + 小括號 + 冒號 + 換行縮排 + 程式碼塊

定義一個函式

def 函式名（）：

​ 程式碼塊

函式呼叫：函式名加（）即可呼叫，在函式呼叫之前，必須先定義，函式的第一行是預設的備註資訊（三個單引號）

# 函式的定義
def printInfo():
    '''
    列印個人資訊，是對個人資訊的組合
    :return:
    '''
    #函式的程式碼塊
    print('小張的身高是：%f' % 1.77)
    print('小張的體重是：%d' % 160)
    print('小張的愛好是：%s' % '打籃球')
    print('小張的專業是：%s' % '電氣工程')
    pass
#函式的呼叫
printInfo()

函式的引數

def printInfo(name, height, weight, hobby, pro):
    '''
    列印個人資訊，是對個人資訊的組合
    :return:
    '''
    #函式的程式碼塊
    print('%s的身高是：%f' %(name,height))
    print('%s的體重是：%d' % (name,weight))
    print('%s的愛好是：%s' %(name,hobby))
    print('%s的專業是：%s' % (name, pro))
    pass
#呼叫函式
printInfo('小李',158,100,'打遊戲','醫生')

引數的分類：

必選引數，預設引數[預設引數]，可選引數，關鍵字引數

引數：函式為了實現某項特定的功能，進而為了得到實現功能所需要的資料，即為了得到外部的資料

1 必選引數 在函式呼叫的時候，是必須進行賦值的。

def sum(a,b):
    sum = a + b
    return sum

2 預設引數[預設引數]

預設引數，始終存在於引數的最後，因為函式呼叫的時候

def sum1(a = 20, b = 30):
    sum = a + b
    print(sum)
    pass
sum1()       #結果為50
sum1(10)     #結果為40  預設引數儘量放在後面，因為若後面引數是必選引數，此種情況會報錯
sum1(10,10)  #結果為20

3 可選引數*，即可以變化的引數【不定長引數】當引數的個數不確定時候使用，比較靈活 形式是元組

def getComputer(*args):
    '''
    計算累加和
    :param args:  可變長的引數型別
    :return:
    '''
    # print(args)
    result = 0
    for item in args:
        result += item
        pass
    print(result)
    pass

getComputer(1,2,3,5,6)  #結果是17
getComputer(1,2,3)      #結果是6

4 關鍵字引數 ** 是一個可變引數，在函式體內是字典型別，key必須是一個字串

def keyFunc(**kwargs):
    print(kwargs)
    pass

#呼叫
# keyFunc(1,23,4)  #錯誤使用方法
dictA = {'name':'zhang','age':'25'}
keyFunc(**dictA)
keyFunc(name = 'peter',age = 26,pos = 'doc')
keyFunc()  #不傳也可以

在混合呼叫時，可選引數必須放到關鍵字引數之前

可選引數接受的資料是一個元組

關鍵字引數接受的是一個字典

函式的返回值

概念：函式執行完成後會返回一個物件，如果在函式的內部有return，就可以返回實際的值，否則返回None

型別：可以返回任意型別，返回值型別應該取決於return後面的型別

用途：給呼叫方返回資料

在一個函式體內可以出現多個return關鍵字，但是隻能返回其中的一個

如果在一個函式體內執行了return就意味著，我們的函式就退出了，return後面的程式碼語句將不再執行

函式的巢狀

def fun1():
    print('---------start1-----------')
    print('---------函式1-----------')
    print('---------end1-----------')
    pass

def fun2():
    print('---------start2-----------')
    fun1()
    print('---------end2-----------')
    pass
fun2()

#結果
---------start2-----------
---------start1-----------
---------函式1-----------
---------end1-----------
---------end2-----------

函式的分類

有引數無返回值 ：一般是計算型，需要引數，最終需要計算的結果

有引數有返回值 ：一般用於無需返回值的引數設定

無引數有返回值 ：一般多用在資料採集中，比如獲取系統資訊，獲取CPU資訊等

無引數無返回值 ：一般用於提示資訊的答應

exercise

寫函式，接收n個數字，求這些引數數字的和

def CalcuSum(*num):
    result  = 0
    for item in num:
        result += item
        pass
    return result
    pass

print(CalcuSum(1,2,3,4,5))

寫函式，找出傳入的列表或元組的奇數位對應的元素，並返回一個新的列表

def process_Func(con):
    listNew = []
    index = 1;
    for i in con:
        if (index%2 == 1):    #判斷奇數位
            listNew.append(i)
            pass
        index += 1
        pass
    return listNew
    pass

print(process_Func([1,2,3,4,5]))

寫函式，檢查傳入字典的每一個value的長度，如果大於2，那麼僅保留前兩個長度的內容，並將新內容返回給呼叫者。PS：字典中的value只能是字串或者列表

def dictParamFun(dictParam):
    '''
    處理字典型別的資料
    :return:
    '''
    result = {} #空字典
    for key,value in dictParam.items():
        if len(value) > 2:
            result[key] = value[:2]
            pass
        else:
            result[key] = value
            pass
        pass
    return result
    pass
# 函式呼叫
dicObj = {'name':'zhang','hobby':['唱歌','dance','運動'],'pro':'stu'}
print(dictParamFun(dicObj))

第五章

變數

在python中變數是一種標籤，給需要賦值的物件貼標籤；對比C語言，可以理解為指標

a = 'hello'
b = 'hello'

這兩個hello是否是一個hello?

這是一個hello，因為變數a和b在記憶體中的地址是相同的

在python中=是一個捆綁的過程

a = print
a(3)
#這種方式也可以實現print(3)的功能

區域性變數

在函式內部定義的變數，作用範圍僅僅是在函式內部進行使用。

不同的函式可以定義相同的區域性變數，但是這些區域性變數直接不會互相影響。

作用：為了臨時的儲存資料，需要在函式中定義來進行

全域性變數

作用的範圍是整個檔案

當全域性變數和區域性變數命名重複時，程式優先執行使用函式內部定義的變數【區域性變數】

name = 'zhang'
def printinfo():
    name = 'xiaoli'
    print(name)
    pass

def TestInfo():
    print(name)
    pass

printinfo()
TestInfo()

#結果是
xiaoli
zhang

全域性變數的修改

鑑於以上在函式內部會將和全域性變數相同名稱的變數預設為函式內部的區域性變數，因此要在函式中修改全域性變數，必須要在變數前加關鍵字global

name = 'zhang'
print(name)
def changeGlobal():    
    global name 
    name = 'xiaoli'
    pass

changeGlobal()
print(name)

引用

核心思想：萬物皆物件

1、在函式呼叫的時候，實參傳遞的就是物件的引用

2、瞭解了原理之後，就可以更好的去把控，在函式內部的處理是否會影響到函式外部的資料變化

在python中，值是靠引用來傳遞的，可以用id()檢視一個物件的引用是否相同，id是值儲存在記憶體中那塊記憶體地址的標識。

變數只是對變數地址的引用，新的值會有新的地址

匿名函式

python中使用lambda關鍵字建立匿名函式，所謂匿名即這個函式沒有名字不用def關鍵字穿件標準的函式。

標準：lamdba 引數1，引數2，引數3：執行程式碼語句

使用lambda表示式計算兩個數之和：

test = lambda x,y:x+y
test(1,3)
test(4,5)

若是普通函式，則

def test(x,y)
	return x+y
	pass

特點

使用lambda關鍵字建立函式

函式沒有名字

匿名函式冒號後面的表示式有且只有一個，注意是表示式，而不是語句

匿名函式自帶return，而這個return的結果就是表示式計算之後的結果

通過變數呼叫匿名函式（類似C語言中的巨集定義）

functest  = lambda x,y:x if x > y else y #三目運算子
print(functest(12,2))

缺陷：只能是單個表示式，不是一個程式碼塊，lambda僅僅是為了簡單的函式場景，複雜邏輯實現不了，必須使用def

遞迴函式

在函式內部呼叫自己

遞迴函式必須有清楚的結束條件，即邊界條件

優點：邏輯簡單，定義簡單

缺點：容易導致堆疊溢位，記憶體資源緊張

遞迴案例 模擬實現 樹形結構的遍歷

import os  #引入檔案操作模組
def findFile(file_path):
    listRs = os.listdir(file_path)  #得到該路徑下所有的資料夾
    for fileitem in listRs:
        full_path = os.path.join(file_path,fileitem) #獲取完整的檔案路徑
        if os.path.isdir(full_path):  #判斷是否是資料夾？
            findFile(full_path)
            pass
        else:
            print(fileitem)
            pass
        pass
    else:
        return
    pass

#呼叫問價路徑
print( findFile('F:\\learningnotes\\00leetcode') )

第六章

內建函式

python中自帶的函式

所有內建函式官網文件：

http://docs.python.org/3/library/functions.html 文件中有函式的詳細說明

		Built-in Functions
abs()	delattr()	hash()	memoryview()	set()
all()	dict()	help()	min()	setattr()
any()	dir()	hex()	next()	slice()
ascii()	divmod()	id()	object()	sorted()
bin()	enumerate()	input()	oct()	staticmethod()
bool()	eval()	int()	open()	str()
breakpoint()	exec()	isinstance()	ord()	sum()
bytearray()	filter()	issubclass()	pow()	super()
bytes()	float()	iter()	print()	tuple()
callable()	format()	len()	property()	type()
chr()	frozenset()	list()	range()	vars()
classmethod()	getattr()	locals()	repr()	zip()
compile()	globals()	map()	reversed()	__import__()
complex()	hasattr()	max()	round()

abs()絕對值函式

#絕對值
abs(-34)  #結果是34

round()函式

描述：對浮點數進行近似取值，保留幾位小數

語法：round（x,n）

引數：x--數值表示式 n--保留位數

返回值：返回浮點數x的近似值

注意：這裡不完全是按照四捨五入或者四捨六入五成雙來進行取值，取值和python的版本有關，還和浮點數的精度有關

round(2.6)    3
round(2.4)    2
round(3.66,1) 3.7

pow()求次方 同**

max()最大值 引數可以是序列，元組，列表

min()最小值

sum()對系列進行求和計算

eval()執行字串表示式，並返回表示式的值

語法 eval(expression, [ globals, [ locals ] ] )

expression - 表示式

globals - 變數作用域，全域性變數，如果被提供，則必須是一個字典

locals - 變數作用域，區域性變數，如果被提供，可以是任何對映物件

返回值：返回表示式計算結果

a,b,c = 1,2,3
eval('a+b+c')   #結果為6  這是動態執行函式

型別轉換函式

chr()數字轉字元 按照ASCII碼進行的

chr(65)  #結果為A
chr(66)  #結果為B

bin() 十進位制轉為二進位制

hex() 十進位制轉為十六進位制

list()將元組轉換為列表

tuple() 將列表轉為元組

dict() 建立字典

#建立字典
dic = dict()
print(type(dic))
dic['name'] = 'xiaoli'
dic['age'] = 18
print(dic)

dic = dict(name = 'xiaoli',age = 18)
print(dic)

bytes() 轉換為位元組陣列

返回一個新位元組陣列，這個數組裡的元素時可變的，並且每個元素的值範圍：0 <= x < 256

需要指定編碼方式

print(bytes('我喜歡python',encoding = 'utf-8'))
#結果：
b'\xe6\x88\x91\xe5\x96\x9c\xe6\xac\xa2python'

序列操作函式

all( ) 函式用於判斷給定的可迭代引數的所有元素是否都為TRUE，如果是返回TRUE，否則返回False元素，除了是0、空、FALSE外都是TRUE

物件是元組或者列表

li = [1,2,3]
print(all(li))    #True
li = [1,2,3,4,5,0]
print(all(li))    #False

空元素和空列表返回值也是TRUE

any() 函式用於判斷給定的可迭代引數的所有元素是否都為FALSE，返回FALSE，如果有一個是True，則是True

類似於邏輯運算子中的OR的運用，有一個為真則結果為真

all() 函式類似於邏輯運算子中的AND運用，有一個為假則為假

sort函式和sorted

sort函式是應用在list上的方法，sorted可以對所有的可迭代的物件進行使用。

sort的返回值是對已經存在的列表進行的操作，和內建函式sorted方法返回的是一個新的list。而不是原來基礎上的進行的操作。

語法：sorted（iterable，[cmp]，[key]，[reverse]）

iterable 迭代物件

cmp 比較的函式，這個具有兩個引數，引數的值都是從可迭代物件中取出，此函式必須遵循的規則為，大於則返回1，小於則返回-1

key 主要用來進行比較的元素，只有一個引數，具體的函式的引數就是取自於可迭代物件中，指定可迭代物件中的一個元素來進行排序

reverse 排序規則，reverse = true 降序，reverse = false 升序

返回值：重新排列的列表

print( sorted([1,2,3,5,8,6,5,43]))   #結果為[1, 2, 3, 5, 5, 6, 8, 43]
print( sorted([1,2,3,5,8,6,5,43],reverse=True))  #結果為[43, 8, 6, 5, 5, 3, 2, 1]

range() 建立一個整數列表，一般用在for迴圈中

語法：range（start，stop，step） 左閉右開

也可以只有一個stop，如range（5） 等效於 range（0,5）等效於range（0,5,1）

zip（）函式用於將可迭代的物件作為引數，將物件中對應的元素打包成一個個元組，然後返回由這些元組組成的列表。如果各個迭代器的元素個數不一致，則返回列表長度與最短的相同，利用*號操作符，可以將元組解壓為列表。

s1 = ['a','b','c']
s2 = ['你','我','他']
print(zip(s1))             #結果是<zip object at 0x0000000002650680>
print( list(zip(s1)) )     #結果是[('a',), ('b',), ('c',)]
print( list(zip(s1,s2)) )  #結果為[('a', '你'), ('b', '我'), ('c', '他')]

圖書管理示例：

def printBookInfo():
    books = [] #儲存圖書資訊
    id = input('請輸出圖書編號：每項之間是空格分隔')
    bookname = input('請輸入書名：每項之間是空格分隔')
    bookpos = input('請輸入位置：每項之間是空格分隔')
    idlist  = id.split(' ')
    namelist = bookname.split(' ')
    poslist = bookpos.split(' ')

    bookInfo = zip(idlist,namelist,poslist)

    for bookitem in bookInfo:
        '''
        遍歷圖書資訊，進行儲存
        '''
        dictInfo = {'編號':bookitem[0],'書名':bookitem[1],'位置':bookitem[2]}
        books.append(dictInfo) #將字典物件新增到list容器中
        pass
    for item in books:
        print(item)
        pass
    print(books)
    pass
printBookInfo()

#結果：
#請輸出圖書編號：每項之間是空格分隔1 2 3
#請輸入書名：每項之間是空格分隔python C C#
#請輸入位置：每項之間是空格分隔A1 A2 A3
#{'編號': '1', '書名': 'python', '位置': 'A1'}
#{'編號': '2', '書名': 'C', '位置': 'A2'}
#{'編號': '3', '書名': 'C#', '位置': 'A3'}
#[{'編號': '1', '書名': 'python', '位置': 'A1'}, {'編號': '2', '書名': 'C', '位置': 'A2'}, #{'編號': '3', '書名': 'C#', '位置': 'A3'}]

enumerate() 函式用於將一個可遍歷的資料物件（如列表、元組或字串）組合為一個索引序列，同時列出資料和資料下標，一般用在for迴圈當中

語法：enumerate（sequence，[start = 0]）

引數：sequence 一個序列

​ start--下標的其實位置

listobj = ['a','b','c']
for item in enumerate(listobj):
    print(item)
    pass
#結果：     結果是元組
#(0, 'a')
#(1, 'b')
#(2, 'c')
for item in enumerate(listobj,5):
    print(item)
    pass
#結果：     結果是元組
#(5, 'a')
#(6, 'b')
#(7, 'c')
dicObj = {}
dicObj['name'] = 'zhangxf'
dicObj['hobby'] = 'lalala'
dicObj['pro'] = 'stu'
for item in enumerate(dicObj):
    print(item)
    pass
#結果：
#(0, 'name')
#(1, 'hobby')
#(2, 'pro')

set（集合） 也是python中的一種資料型別{}

set1={'1','2'}

不支援索引和切片 類似於字典，但是隻有key 沒有value

add 新增 clear 清楚 difference（a,b） a中存在 b中不存在

intersection 取交集

union 取並集

pop 就是從集合中拿資料，並且拿了之後就刪除了

discard 指定移除資料

update 更新資料 需要兩個集合，在原來的基礎上將兩個結合合併，和union差不多。

第七章

面向物件程式設計

面向過程：根據業務邏輯從上到下寫程式碼

函式式：將某功能程式碼封裝到函式中，日後便無需重複編寫，即呼叫程式碼

面向物件程式設計：將資料與函式繫結到一起，進行封裝，這樣能夠更快速的開發程式，減少了重複程式碼的書寫過程。

oop(object oriented programming)

面向過程：在思考問題的時候，首先分析，如何按照步驟去實現，然後將問題解決拆解成若干個步驟，並將這些步驟對應成方法一步一步的最終完成功能。

面向物件：關注的是設計的思維，關注點是誰來做。

類和物件

類和物件是面向物件程式設計中重要的概念

類就是一個模板，模板裡可以包含對個函式，函式裡實現一些功能

物件則是根據模板建立的示例，通過例項物件可以執行類中的函式

類是具有一組相似或者相同特徵【屬性】和行為【方法】的一系列物件的結果

物件是實實在在的東西，是類的具象化和例項化

類的組成部分

1 類名

2 類的屬性 一組資料

3 類的方法 允許對類進行操作的方法

舉例 ：建立一個類：人

事物名稱（類名）：人

屬性：身高、年齡

方法：吃、跑

定義類和物件

結構：class 類名：

​ 屬性

​ 方法

class Person:
    name = '小明'   #人的特徵
    age = 20
    #方法
    def eat(self):
        #函式語法
        pass
    def run(self)
    	pass
    

物件 結構

物件名 = 類名（）

xm = Person()
xm.eat()  #呼叫函式
xm.run()  #呼叫函式

例項方法

在類的內部，使用def關鍵字可以定義一個例項方法，與一般函式定義不同，類方法必須包含引數self，且作為第一個引數。

類屬性

在類的內部定義的變數，歸屬於類所有，在方法外面的屬性稱之為類屬性

例項屬性

定義在方法裡面的使用self引用的屬性稱之為例項屬性，歸屬於例項物件所有

_init_(self)方法，初始化方法，例項化物件的時候自動呼叫，完成一些初始化設定

凡是由雙下劃線組成的函式，均是python內部的，魔術方法

_init_可以傳參

class Person:
    def __init__(self,name,sex,age):
        self.name = name
        self.sex = sex
        self.age = age
        pass
    pass
zp = Person('zp','男',18)
print(zp.name,zp.age,zp.sex)

初始化函式是python自帶的內建函式，特點是兩邊用雙下劃線包裹的，函式的作用為一個初始化的方法，主要是用來設定定義例項屬性和初始化資料的，在建立物件的時候自動呼叫，不用手動呼叫

利用傳參的機制，可以使得功能更加強大方便。

self

self和物件指向的是同一個記憶體地址，可以認為self即為物件的引用

魔法方法

在python內部，會有一些內建好的特定的方法，方法名是：“__xxx__”，在進行特定的操作時會自動被呼叫，這些方法稱之為魔法方法。

__init__初始化一個類，在建立物件的時候為其賦值時使用

__Str__在將物件轉換為字串

__new__建立並返回一個例項物件

__class__獲得已知物件的類

__del__物件在執行程式結束後進行物件銷燬的時候呼叫這個方法，並釋放資源

1 __Str__方法，在列印物件的時候，會執行此例項方法，返回一個字串

在print的時候呼叫

2__new__建立並返回一個例項物件

案例：決戰紫禁之巔

• 屬性：

  • name 玩家的名字
  • blood玩家血量

• 方法：

  • tong() 捅對方一刀，對方掉血10滴
  • kanren（）砍對方一刀，對方掉15滴
  • chiyao（）吃一顆藥丸，補血10滴
  • _str_列印玩家狀態

#第一步 需要先去定義一個類【角色類】
class Role:
    def __init__(self,name,hp):
        """
        構造初始化函式
        ：param name 角色名
        ：param hp 血量
        """
        self.name = name
        self.hp = hp
        pass
    def tong(self,enemy):
        """
        捅一刀
        :param enemy: 敵人
        :return:
        """
        enemy.hp -= 10  #敵人少10滴血
        info = '[%s]捅了[%s]一刀'%(self.name,enemy.name)
        print(info)
        pass

    def kanren(self, enemy):
        enemy.hp -= 15 #敵人少15滴血
        info = '[%s]砍了[%s]一刀'%(self.name,enemy.name)
        print(info)
        pass

    def chiyao(self):
        self.hp += 10 #敵人少15滴血
        info = '[%s]吃了一顆補血藥，增加了10滴血'%(self.name)
        print(info)
        pass
    def __str__(self):
        return  '[%s]的血量還剩下%d'%(self.name,self.hp)
    pass

#建立兩個例項化物件
zhang = Role('西門吹雪',100)
ygc = Role('葉孤城',100)
while True:
    if zhang.hp <= 0 or ygc.hp <= 0:
        break
        pass

    zhang.tong(ygc)   #西門吹雪捅了葉孤城一刀
    print(zhang)
    print(ygc)
    print('************************************')
    ygc.kanren(zhang) #西門吹雪被葉孤城砍了一刀
    print(zhang)
    print(ygc)
    print('************************************')
    ygc.tong(zhang)
    print(zhang)
    print(ygc)
    print('************************************')
    zhang.chiyao()
    print(zhang)
    print(ygc)
    pass

第八章

面向物件：繼承、多型和封裝

封裝：把內容封裝到某個地方，便於後面的使用

• 把內容封裝到某個地方
• 從另外一個地方去呼叫唄封裝內容

對於封裝來說，其實就是使用初始化構造方法將內容封裝到物件中，然後通過物件直接或者self來獲取唄封裝的內容

繼承：和字面意思相同，即子繼承父的內容【屬性和行為】，反之不一定成立。就是將多個類的共有方法提取到父類中，子類僅需繼承父類而不必一一去實現

析構方法

__del__():當一個物件被刪除或者銷燬時，python直譯器也會預設呼叫這個方法，程式在結束的時候會自動呼叫這個函式。

class Animal:
    def __init__(self,name):
        self.name = name
        print('這是構造初始化方法')
        pass
    def __del__(self):
        print('這是析構方法')
        pass
    pass

dog = Animal('dog')

#結果為：
#這是構造初始化方法
#這是析構方法

在呼叫函式del刪除某個物件的時候，也會呼叫解構函式

當整個程式指令碼執行完畢後會自動呼叫__del__方法

當物件被手動銷燬時也會自動呼叫此函式

解構函式一般用於資源回收，利用__del__方法銷燬物件回收記憶體等資源

單繼承

class Animal:
    def eat(self):
        pass
    def drink(self):
        pass
    pass

class  Dog(Animal):
    def wwj(self):
        print('小狗汪汪叫')
        pass
    pass

class Cat(Animal):
    def mmj(self):
        print('小貓喵喵叫')
        pass
    pass
d1 = Dog()
d1.eat()    #具備了父類的行為，是繼承了父類的行為

在每個子類中實現自己獨有的行為，可以減少程式碼的重複

class 子類（父類）：

​ 行為

​ pass

多繼承

同時可以繼承多個父類

class 子類(父類1，父類2)：

​ 行為

​ pass

class shenxian:
    def fly(self):
        print('神仙會飛')
        pass
    pass

class Monkey:
    def chitao(self):
        print('猴子喜歡吃桃')
        pass
    pass

class sunwukong(shenxian,Monkey):
    pass
swk = sunwukong()
swk.chitao()
swk.fly()

當多個類中存在存在相同方法的時候，應該呼叫哪一個？

從左到右，一層一層，先找到誰就先執行誰

繼承的傳遞

可以一級一級的傳遞，和多繼承類似

重寫父類方法

在子類中的方法可以將父類進行覆蓋，由於父類中已經存在相同的方法，在此相當於方法的覆蓋

呼叫父類方法

在重寫父類的方法中，利用class在重新寫一下父類發方法

還可以使用super().__init__() #super是自動找到父類，進而呼叫方法，若繼承了多個父類，會按照順序逐個的去尋找，在呼叫找到的第一個。

多型

定義時的型別和執行時的型別不一樣，此時就可以成為多型。

同一種行為，對於不同的子類，有著不同的行為表現

要想實現多型 必須有兩個前提條件：

• 繼承，多型必須發生在父類和子類之間
• 重寫，子類需重寫父類的方法

# 多型 案例演示
class Animal:    #父類
    def say_who(self):
        print('我是一個動物')
        pass
    pass

class Duck(Animal):  #子類 鴨子類
    def say_who(self):   #子類重寫父類的方法
        print('我是一隻鴨子')
        pass
    pass

class Dog(Animal):
    def say_who(self):   #子類重寫父類的方法
        print('我是一隻狗子')
        pass
    pass

class zhang:
    def say_who(self):   #子類重寫父類的方法
       print('我是zhang')
       pass
    pass

def commonInvoke(obj):   #統一呼叫的方法
    obj.say_who()
    pass
# duck1 = Duck()
# duck1.say_who()   #結果是 我是一隻鴨子
# Dog1 = Dog()
# Dog1.say_who()    #結果是 我是一隻狗子
listObj = [Duck(),Dog(),zhang()]
for item in listObj:
    commonInvoke(item)    //體現了多型
    pass

多型可以增加程式的靈活性，增加程式的擴充套件性

類方法和靜態方法

一般使用的方法為例項方法，類物件所擁有的方法為類方法，需要使用裝飾器@classmethod來標識其為類方法，對於類方法，第一個引數必須是類物件，一般是cls作為第一個引數，其餘類似例項方法

class People:
    country = 'China'

    @classmethod    #這是類方法
    def get_Country(cls):
        return cls.country   #訪問類屬性
        pass

    @classmethod
    def change_Country(cls,data):
        cls.country = data
        pass
    pass
pass


print(People.get_Country())   #通過類物件直接去應用
p=People()
print('例項物件訪問 %s'%p.get_Country())   #例項物件也可以訪問類物件
People.change_Country('英國')
print('例項物件訪問 %s'%p.get_Country())   #例項物件也可以訪問類物件

靜態方法，需要使用@staticmethod 來表示靜態方法，靜態方法不需要任何引數

為什麼要使用靜態方法

由於靜態方法主要來存放邏輯性的程式碼，本身和類以及例項並沒有互動，不會涉及類屬性和例項屬性的操作，故一般不需要任何引數

資料資源能夠得到有效的充分利用

#返回當前的系統時間
import time
class TimeTest:
    def __init__(self,hour,min,sec):
        self.hour = hour
        self.min = min
        self.sec = sec
        pass

    @staticmethod
    def showTime():
        return time.strftime('%H:%M:%S',time.localtime())
        pass
    pass

print(TimeTest.showTime())

第九章

私有化屬性（封裝）

為了更好的儲存屬性安全，即不能隨意修改，將屬性定義為私有屬性，新增一個可呼叫的方法去訪問

私有屬性，利用兩個下劃線開頭。__屬性

使用場景：

• 把特定的屬性進行隱藏，不想讓類的外部直接呼叫
• 保護該屬性，不想讓這個屬性值隨意改變
• 保護這個屬性，不想讓子類繼承

#屬性私有化
class Person:
    def __init__(self):
        self.__name = '李四'  #加兩個下劃線 將此屬性私有化 在外部不能使用，在類的內部可以使用
        self.age = 30
        pass
    def __str__(self):
        return '{}的年齡是{}'.format(self.__name,self.age)   #私有化可以在內部使用
        pass
    pass

class Student(Person):
    def printInfo(self):
        print(self.__name)     #在此訪問父類中的私有屬性，是不可以的
    pass

xl = Person()
# print(xl.__name)    # 會報錯，私有化之後不能再外部直接訪問

• 私有化的【例項】屬性 不能在外部直接訪問 可以在類的內部隨意使用
• 子類是無法繼承父類的私有化屬性的 只能繼承父類公共的屬性和方法
• 類屬性和例項屬性一樣，都是不能在外部直接訪問

私有化方法

有些重要的方法，不允許外部呼叫，防止子類意外重寫，把普通的方法設定成私有化方法

在前面加兩個下劃線__

Property屬性

方法一針對上述私有化的情況，可以才用屬性函式（property）的方法

#Property
class Person:
    def __init__(self):
        self.__age  = 18
        pass

    def get_age(self):
        return self.__age

    def set_age(self,age):
        if age < 0 :
            print('年齡不能小於0')
        else:
            self.__age = age
            pass
        pass
    # 定義一個類屬性，實現通過直接訪問屬性的形式去訪問私有的屬性
    age = property(get_age,set_age)

    pass

p1 = Person()
# print( p1.get_age() )
print(p1.age)

方法二採用裝飾器的方法實現

#Property
class Person:
    def __init__(self):
        self.__age  = 18
        pass

    @property  #用裝飾器修飾，新增屬性標誌 提供一個getter方法
    def age(self):
        return self.__age

    @age.setter     #提供一個setter方法
    def age(self,age):
        if age < 0 :
            print('年齡不能小於0')
        else:
            self.__age = age
            pass
        pass


    pass

p1 = Person()
# print( p1.get_age() )
print(p1.age)

__new__方法

• 建立並返回一個例項物件，如果__new__只調用了一次，就會得到一個物件。繼承自object的新式類才有new這一魔法方法
• 注意事項
  • 是物件例項化的時候所呼叫的第一個方法
  • 至少必須要有一個引數是cls，代表要例項化的類，此引數在例項化時由python直譯器自動提供
  • 該魔法方法可以決定是否要使用該__init__方法，因為__new__可以呼叫其他類的構造方法或者直接返回別的例項物件最為本類的例項，如果__new__沒有返回例項物件則__init__不會被呼叫
  • 不能呼叫自己的__new__方法

單例模式

確保某個類在該系統中只有一個例項存在，是一種常用的軟體設計模式

class DataBaseClass(object):
    def __new__(cls, *args, **kwargs):
        #cls._instance = cls.__new__(cls) 不能使用自身的new方法
    if not hasattr(cls,'_instance'):    #如果不存在就開始建立
        cls._instance = super().__new__(cls, *args, **kwargs)
     return cls._instance
    pass

錯誤與異常處理

有一些程式碼塊

try： 可能出現錯誤的程式碼塊

except：出錯之後執行的程式碼塊

else：沒有出錯的程式碼塊

finally：不管有沒有出錯都執行的程式碼塊

try:
    print(b)  #捕獲邏輯程式碼    try裡面有多個錯誤，但是隻會捕獲第一個錯誤
    pass
except NameError as msg:   #這是名稱錯誤
    #若捕獲到錯誤，才會在這裡執行
    print(msg)
    pass
except IndexError as msg:
    #若捕獲到錯誤，才會在這裡執行
    print(msg)
    pass
except Exception as result: #都可以捕獲的錯誤型別
    print(result)
    pass
print('初次接觸異常處理')
print('HAHAHAHAHAHA')

#結果
#name 'b' is not defined
#初次接觸異常處理
#HAHAHAHAHAHA

except 在捕獲錯誤異常處理的時候 只要根據具體的錯誤型別來捕獲的

該捕獲機制是可以跨越多重呼叫的 不需要在每一個可能出錯的地方去捕獲

自定義異常

自定義異常，都要直接或間接繼承Error或Exception

由開發者主動跑出自定義異常，在python中使用raise關鍵字

class Toollong(Exception):
    def __init__(self,leng):
        self.len = leng
        pass
    def __str__(self):
        return '輸入的資料長度是'+str(self.len)+'超出長度了'
    pass

def name_Test():
    name = input('請輸入姓名。。。')
    if  len(name) >= 5:
        raise Toollong( len(name))
    else:
        print(name)
        pass
name_Test()

python動態新增屬性和方法

__slots__屬性

限制動態屬性的新增。只有在__slots__變數中的屬性才會被新增，其他的屬性會新增失敗，slots屬性子類不會被繼承，只有在當前類中才有效