1.python概述和環境

1.1python安裝目錄的介紹
DLLS:python的動態鏈接庫，跟編譯器有關，和python編程關系不大
Doc:python的參考書，有很多實例
Lib:這個庫很重要，是python的標準庫，你擴充的庫都安裝在這里
Libs：python的內置庫，語法存在的地方
Scripts：項目用到的各種腳本
Tools：python提供的一些工具
Tcl：桌面編程包
Lib和Libs的區別？
Lib是python的標準庫，我們安裝的第三方模板都在這里面，libs是python的內置庫，下載python的時候自帶的。所以我們不要把API(應用程序接口)放到libs，要放到lib中。

1.2python的腳本

1.2.1python腳本結構
.py文件
以.py后綴的文件是python源代碼文件，由python.exe解釋，可在控制臺下運行，當然也可以用文本編輯器修改。
.pyc文件
以.pyc后綴的文件是python編譯文件，.pyc文件是不能用文本編輯器修改的，其優點是執行速度遠快于.py文件。至于為什么要有.pyc文件，這個需求是.py文件可以看到源代碼，軟件開發商不可能把源代碼泄露出去，所以就編譯成.pyc文件再發布。

1.2.2python成熟的編譯器
Sublime
Pycharm
Ipython
IDLE python gui（python自帶的簡單的集成開發環境）
我們主要使用Pycharm，帶有一整套可以幫助用戶在使用python語言開發時提高效率的工具。

1.2.3python腳本運行
安裝完成，打開win+r，cmd，輸入python

2.python字符串常用操作
2.1字符串確實是一個數組，索引是從0開始的
例:name=‘abcdefg’
print(name[0]) —a
2.2字符串的截取操作
#字符串[start:end]:包頭不包尾
例:name=‘abcdefg’
print(name[0:3]) —abc
#步長截取：同樣包頭不包尾
字符串[start🔚step]：按照step步長進行隔取
例：name=‘abcdefg’
print(name[0:6:2]) —ace
#默認取法
[start🔚step]這三個參數都是有默認值的，start為0，end為字符串結尾元素，step為1。若step>0則表示從左向右進行切片，此時start必須小于end才有結果；若step<0，還是表示從左到右只不過反過來切片，此時start必須大于end才有結果。
例：name=‘abcdefg’
print(name[0:6:2]) —ace
print(name[6:0:-2]) —gec
2.2字符串的查找操作
count：計數功能，返回自定字符串在字符串中的個數
find：從左往右查找第一個指定字符串的索引，沒有返回-1
rfind：從右往左查找第一個指定字符串的索引，沒有返回-1
index：從左往右查找第一個指定字符串的索引，沒有報錯
rindex：從右往左查找第一個指定字符串的索引，沒有報錯
2.3字符串的分割替換操作
partition：把mystr以str分割成三部分，str前，str自身，str后
rpartition：類似于partition函數，只不過從右開始
splitlines：按照行分割，返回一個包含\n作為元素的列表，按照換行符分割、
replace：從左往右替換指定的元素，可以指定替換的個數，默認為全部替換
例：
mystr = ‘hello world’
print(mystr.partition(‘o’)) --(‘hell’, ‘o’, ’ world’)
print(mystr.rpartition(‘o’)) --(‘hello w’, ‘o’, ‘rld’)
print(mystr.replace(‘h’,‘q’)) --qello world
mystr = ‘hello\n world\n pathon\n’
print(mystr.splitlines()) --[‘hello’, ’ world’, ’ pathon’]
2.4字符串的變形
upper：字母轉大寫
lower：字母轉小寫
swapcase：大小寫互換
title：將字符串中的單詞首字母大寫，單詞以非字母劃分
capitalize：只有字符串的首字母大寫
expandtabs：把字符串中的tab符號(’\t’)轉為空格，tab符號(’\t’)默認的空格數是8，可以試下8，12
2.5字符串的判斷
isupper：是否完全是大寫
islower：是否完全是小寫
isdigit：是否完全是數字
isalpha：是否完全由字母組成
isalnum：是否完全由字母或者數字組成
istitle：字符串是否滿足title格式(首字母大寫)
isspace：字符串是否完全由空格組成
startswith：判斷字符串的開頭字符，也可以截取判斷
endswith：判斷字符串的結尾字符，也可以截取判斷
split：通過指定分隔符對字符串進行切片，如果參數 num 有指定值，則分隔 num+1 個子字符串，分隔符，默認為所有的空字符，包括空格、換行(\n)、制表符(\t)等，分割次數。默認為 -1, 即分隔所有。

3.python列表、元組、字典、集合
3.1列表
*列表的定義
name = [‘12’,12,[1,2,3]]
#列表里面的數據類型是可變的，甚至可以嵌套一個列表
列表是一個有序的，可修改的，元素以逗號隔開，以中括號包圍的序列。
*列表和字符串的區別
列表和字符串的索引類似，但列表是可以通過索引修改的，而字符串不可以。
*列表的基本操作
append：列表尾部加入指定元素
insert：將元素加入指定的索引上，注意負索引
extend：將指定序列的元素依次追加到列表的尾部(合并)
pop：返回并刪除指定索引位上的元素，默認刪除索引位-1的元素
remove：從左往右刪除一個指定的元素
del：刪除整個列表或列表的數據
count：計數，摸個元素在列表中的個數
index：從左往右查找一個元素，沒有找到報錯
in：是否在列表中，有返回true，沒有返回false
reverse：順序倒序
sort：按照ascii碼進行排序，注意列表中如果有不同類型的數據不能進行比較
*list函數
list()，以一個序列作為參數并把它轉換為列表，如果參數是list，那么該參數就會被原樣返回
例：
a = ‘abcd’
print(list(a)) —[‘a’,‘b’,‘c’,‘d’]
b = [‘a’,‘b’,‘c’]
*列表的切片操作
列表的切片操作和字符串一樣
例：
list1 = [0,1,2,3,4,5,6,7,8]
list1[0:6] --[0,1,2,3,4,5]
list1[0:6:2] --[0,2,4]
list1[::-1] --[8,7,6,5,4,3,2,1,0]
list1[6:0:-1] --[6,5,4,3,2,1]

3.2元組
*元組的定義：元組是有序的(只有在定義的一瞬間可以修改)，不可修改的，以逗號隔開，以小括號包圍的序列，可以通過()和tuple函數定義。
例：
tuple1 = (11,22,33,‘a’)
tuple2 = (11,) --tuple
tuple3 = (11) --int
注意：元組在定義時如果只傳入一個參數，必須要在后面加一個’，’，不然就是int類型而不是tuple類型
*元組的優點：
1.由于不可變，遍歷元組比列表要快
2.由于不可變，相當于數據被保護，所以一些重要數據都寫在元組
*修改元組
說明：python中不允許修改元組的數據，包括不能刪除其中的數據。
元組是不可變的，元組中的元素被賦值后不能改變。但是，如果元素本身是一個可變數據類型的裂變，那么其嵌套項可以被改變。
例：
num = (1,‘a’,[1,2])
num[0] = 2 --報錯，不可修改
num[2].append(3) --可以修改，追加一個3
print(num) --(1,‘a’,[1,2,3])
*tuple函數
tuple函數的功能與list函數基本上一樣，以一個序列作為參數并把它轉換為元組，如果參數是元組那么該參數就被原樣返回。
列表轉元組：
list1 = [‘a’,‘b’,‘c’,1,2,3]
num1 = tuple(list1)
元組轉列表：
list2 = list(num1)
字符串轉元組：
str1 = ‘hello world’
tuple1 = tuple(str1)
print(tuple1) --(‘h’, ‘e’, ‘l’, ‘l’, ‘o’, ’ ', ‘w’, ‘o’, ‘r’, ‘l’, ‘d’)
元組轉字符串：
str2 = ‘’.join(tuple1)
print(str2) --hello world
元組轉int整數：
a = (1,2,3)
str = ‘’.join([str(i) for i in a])
print(str) --123
print(int(str)) --123
*元組的嵌套
tup1 = ((‘落手’,‘雪人’,‘寒冰’),(‘女槍’,‘猴子’,‘大嘴’))
print(len(tup1)) --2
print(tup1[1]) --(‘女槍’, ‘猴子’, ‘大嘴’)
print(tup1[1][1]) --猴子
*元組的切片
tup1 = (0,1,2,3,4,5,6)
print(tup1[0:6]) --(0, 1, 2, 3, 4, 5)
print(tup1[0:6:2]) --(0, 2, 4)
print(tup1[::-1]) --(6, 5, 4, 3, 2, 1, 0)
print(tup1[6:0:-1]) --(6, 5, 4, 3, 2, 1)
*元組的操作
index：從左往右查找第一個指定字符串的索引，沒有報錯
count：返回元組中指定元素的個數

3.3 字典
*字典的定義
字典是一個無序的，可以修改的， 元素呈鍵值對的形式，以逗號分開，以大括號包圍的數據類型。
查詢
info = {‘name’:‘lili’,‘addr’:‘beijing’,‘age’:18}
print(info[‘name’]) --lili
print(info.get(‘name’)) --lili
添加和修改
info = {‘name’:‘lili’,‘addr’:‘beijing’,‘age’:18}
info[‘like’]=‘basketball’
print(info) --{‘name’:‘lili’,‘addr’:‘beijing’,‘age’:18,‘like’:‘basketball’}
info[‘age’]=22
print(info) --{‘name’:‘lili’,‘addr’:‘beijing’,‘age’:22,‘like’:‘basketball’}
刪除
del info[‘like’]
print(info) --{‘name’:‘lili’,‘addr’:‘beijing’,‘age’:22}
*字典的特性
1.字典是無序的，所以字典沒有索引值
2.字典沒有索引值，所以字典以鍵取值
3.字典以鍵取值，所以字典的鍵唯一且不可修改
4.字典的鍵不可修改，所以列表和字典等可變類型的數據不可以給字典做鍵
*字典的常見操作
keys：返回一個包含字典所有key的列表
values：返回一個包含字典所有value的列表
get：以鍵取值，如果指定鍵不存在，默認返回None，可以指定返回內容
setdefault：設置默認，如果鍵存在，返回值，如果鍵不存在創造鍵，值默認為None，值亦可以自定義setdefault(key，default=None)
update：以字典格式更新指定鍵的內容，如果鍵不存在，創建鍵和值
items：返回字典鍵值呈元組形式的格式
len：鍵值對的個數
pop:返回并刪除指定鍵對應的值
popitem：隨機彈出一個鍵值元組，這里隨機的原因是因為字典本身無序
in：判斷指定的鍵是否在字典中
info = {‘name’:‘lili’,‘addr’:‘beijing’,‘age’:18}
print(‘name’ in info) --True
for…in…：通過for…in…的語法結構，我們可以遍歷字符串、列表、元組、字典等數據結構
info = {‘name’:‘lili’,‘addr’:‘beijing’,‘age’:18}
#遍歷鍵
for i in info:
print(i)
#遍歷值
for i in info.values():
print(i)

3.4 集合
*集合定義
集合是一組無序不重復的元素集合。
集合和之前的列表、元組類似，可以存儲多個數據，但是這些數據是不重復的。
可以使用{}或者set()函數創建集合，注意：創建一個空集合必須用set()而不是{}，因為{}是用來創建一個空字典。
set1 = {1,2,3,4}
set2 = set()
print(type(set1)) --<class ‘set’>
print(type(set2)) --<class ‘set’>
*集合的交集、差集、并集、對稱差集
交集(&)：兩個集合的公共部分
并集(|)：兩者集合合并，沒有重復元素
差集(-)：只有前者有的元素，不存在后者中的元素
對稱差集(^)：只在a或b中，但是不會同時出現在二者中
a = set(‘1234’)
b = set(‘3456’)
print(a&b) --{‘4’, ‘3’}
print(a|b) --{‘5’, ‘6’, ‘4’, ‘3’, ‘1’, ‘2’}
print(a-b) --{‘2’, ‘1’}
print(b-a) --{‘5’, ‘6’}
print(a^b) --{‘5’, ‘6’, ‘1’, ‘2’}
*set、list、tuple之間的轉換
a = ‘hello’
b = list(a) --[‘h’, ‘e’, ‘l’, ‘l’, ‘o’]
c = tuple(a) --(‘h’, ‘e’, ‘l’, ‘l’, ‘o’)
d = set(a) --{‘l’, ‘h’, ‘e’, ‘o’}
*集合的操作
add：無規律的添加元素
update：也可以添加元素，且參數可以是不同類型，并用逗號隔開
remove：刪除集合中指定的元素，當指定的元素不存在時會報錯
discard：刪除集合中指定的元素，當指定的元素不存在時不會報錯
pop：隨機刪除集合中的一個元素

4.python運算和流程控制循環
4.1python運算
4.1.1布爾值(bool)
True：非0的數字，非空的(字符串、列表、元組、字典)
False：0，’’，()，[],{}，None
4.1.2自增運算
其他語言的自增 i++ 等同于 i=i+1
python語言的自增 i+=1 等同于i=i+1
4.1.3 not,and,or
執行順序為：not>and>or

4.2python流程控制
流程控制三兄弟：if，for，while
4.2.1 if語句
if 條件1 :
block語句塊
else if 條件2 :
block語句塊
else :
block語句塊

4.2.2 for語句
for 變量 in 可迭代對象 :
block語句塊
*特殊的for循環(序列解包賦值)：
list中的tuple遍歷
a = [(1,2),(3,4),(5,6)]
for i,j in a :
print(“這是i %s” %i)
print(“這是j %s” %j)
嵌套循環(重要)
外層循環1次，每層循環1遍
for 條件1 :
條件1滿足時，做的事情1
for 條件2 :
條件2滿足時，做的事情2
例：九九乘法表
for i in range(1,10) :
for j in range(1,i+1) :
print(’%d x %d = %d\t’ %(j,i,ji),end=’’)
print()

4.2.3 while語句
當滿足while條件時，就一直循環while，直到不滿足條件
while(條件) :
條件滿足時，做的事情
else :
條件不滿足時，做的事情

4.2.4 流程控制詞
pass:寫在任何縮進的語句塊部分，只是占位，什么事情都不做，等著以后再來補全代碼
continue:提前結束本輪循環，開始下一輪循環
break:直接退出循環

4.3 推導式
4.3.1 列表推導式
列表推導能非常簡潔的構造一個新列表：只用一條簡潔的表達式即可對得到的元素進行轉換便變形
語法：[變量 for 變量 in 可迭代對象]
例1：比如我們現在要生成一個列表，列表當中的元素為0-10。
首先我們不用列表推導式。
result = []
for i in range(11) :
result.append(i)
print(result) --[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
用推導式。
result1 = [i for i in range(11)] --[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
例2：一組列表l1=[[1,2,3],[4,5,6],[7,8,9]],如何取出1/4/7和1/5/9呢？
l1 = [[1,2,3],[4,5,6],[7,8,9]]
result = [i[0] for i in l1]
print(result) --[1, 4, 7]
l1 = [[1,2,3],[4,5,6],[7,8,9]]
result = [l1[i][i] for i in range(len(l1))] --[1, 5, 9]
print(result)
*嵌套for推導式
a = [(i,j) for i in range(1,5) for j in range(6,10)]
print(a) --[(1, 6), (1, 7), (1, 8), (1, 9), (2, 6), (2, 7), (2, 8), (2, 9), (3, 6), (3, 7), (3, 8), (3, 9), (4, 6), (4, 7), (4, 8), (4, 9)]

4.3.2 字典推導式
語法：
dic = {k:v for k,v in {‘name’:‘jack’,‘age’:18,‘hobby’:‘basketball’}.items()}
print(dic) --{‘name’: ‘jack’, ‘age’: 18, ‘hobby’: ‘basketball’}
4.3.3 集合推導式
語法：
l = [1,2,3,4,4,5,6,2,3]
set1 = {i for i in l}
print(set1)

4.3.3 元組生成式
格式：
a = (i for i in range(5))
for i in a :
print(i)

4.4 深淺拷貝
深拷貝：拷貝所有對象，包括頂級對象以及嵌套對象，所以原始對象的改變不會造成深拷貝里任何子元素的改變
淺拷貝：只拷貝頂級對象，沒有拷貝嵌套對象，所以原始數據改變，嵌套對象會改變！
例：
import copy
a = [1,2,3,4,[5,6,7]]
#在這個列表里頂級對象是1，2，3，4，[5，6，7] ,嵌套對象是[5，6，7]里的5，6，7
b = a
c = copy.copy(a) #淺拷貝
d = copy.deepcopy(a) #深拷貝
print(“a的id是%s,b的id是%s” %(id(a),id(b))) --a的id是2678960247688,b的id是2678960247688
print(“c的id是%s,d的id是%s” %(id?,id(d))) --c的id是2679009389896,d的id是2678960789576
a.append(9) #添加了一個頂級對象9
a[4].append(8) #嵌套對象[5，6，7]添加了一個8
print(a) --[1, 2, 3, 4, [5, 6, 7, 8], 9]
print(b) --[1, 2, 3, 4, [5, 6, 7, 8], 9]
print( c) --[1, 2, 3, 4, [5, 6, 7, 8]]
print(d) --[1, 2, 3, 4, [5, 6, 7]]

5 函數裝飾器
5.1 遞歸函數
函數的內部調用了自身本身，這個函數就是遞歸函數，遞歸會形成一個深度循環。
5.2 函數的劃分
按照參數類型劃分：位置參數、關鍵字參數、默認參數、參數組
位置參數：是我們在傳參時，實參傳遞的順序按照形參定義的順序進行傳遞的傳參方式。
def func(name,city) :
print(“我的名字叫%s，來自%s” %(name,city))
func(‘tracy’,‘houston’) --我的名字叫tracy，來自houston
關鍵字參數：傳參的時候，以形參等于實參的形式忽略形參定義的順序進行傳參的傳參方式。
def func(name,city) :
print(“我的名字叫%s，來自%s” %(name,city))
func(name = ‘tracy’,city = ‘houston’) --我的名字叫tracy，來自houston
func(city = ‘houston’,name = ‘tracy’) --我的名字叫tracy，來自houston
默認參數、缺省參數：定義參數的時候我們給形參一個默認值，在我調用函數的時候，如果不給有默認值的形參傳參，會自動采用默認值。
注意：默認參數，必須要在普通參數的最后面
def func(name,city = ‘beijing’) :
print(“我的名字叫%s，來自%s” %(name,city))
func(‘zhaosi’) --我的名字叫zhaosi，來自beijing
func(‘zhasi’,‘liaoning’)–我的名字叫zhasi，來自liaoning
參數組：處理比當初聲明時更多的參數，會將傳入的參數變成元組(args)或者字典(kwargs)，聲明的時候不用命名。
1.元組參數組
通過給形參前面添加使參數變成一個元組，所有傳遞的參數變成元組的元素
def say_hello(*args) :
print(args)
say_hello() --()
say_hello(1,2,3,4,5) --(1, 2, 3, 4, 5)
2.字典參數組
通過給形參前面添加使參數變成一個字典，所有傳遞的參數變成字典的鍵值對，這里傳遞參數要求鍵等于值的形式。
def say_hello(**args) :
print(args)
say_hello() --{}
say_hello(a=1) --{‘a’: 1}
say_hello(a=1,b=2,c=3) --{‘a’: 1, ‘b’: 2, ‘c’: 3}

5.3 匿名函數lambda
不存在函數名的函數
語法：lambda 參數:表達式(block)
參數：可選，通常以逗號分隔的變量表達式形式，也就是位置參數
表達式：不能包含循環、return、elif，可以包含if，else
例：
l = lambda x : xx
print(l(5))
def l(x) : --此匿名函數的展開式
return xx
l = lambda x : ‘x大于5’ if x>5 else ‘x小于等于5’
print(l(5))
5.3.1 map()
map()是python的內置函數，它接受一個函數和一個可迭代的對象，并且通過函數依次作用在可迭代對象的每個元素上，得到一個新的對象。
a = [1,2,3]
b = [4,5,6]
c = map(lambda x,y:x+y,a,b)
print(list?) – [5, 7, 9]

5.4 作用域
name = ‘while’#作用于全局，全局變量
def outer():
name = ‘for’#嵌套作用域
def inner():
name = ‘dj’#本地作用域
age = 18
print(name)
print(age)
inner()

outer() --dj 18

6 函數裝飾器
6.1 閉包的定義：
1.閉包函數必須有內嵌函數；
2.內嵌函數可以引用該嵌套函數上一級namespace(命名空間)中的變量；
3.閉包函數必須返回內嵌函數；
注意：通過這三點就可以創建一個閉包，python裝飾器就是使用了閉包
例1:
def outer():
print(“我是outer函數”)
def inner():
print(“我是inner函數”)
return inner

f = outer() #inner
print(f) --<function outer…inner at 0x00000289CC27E0D8>
outer()() #等于inner()

例2：
def outer(num) :
def inner(num_inner) :
return num_inner+num
return inner

a = outer(20) #a==inner a()==inner()
print(a(200)) --220

6.2 裝飾器
裝飾器是程序開發中經常會用到的一個功能，用來在原有的函數上增添新的代碼需求。
執行順序：先返回內嵌函數->有參數直接傳參給內嵌函數->執行內嵌函數
例：
def func1():
print(‘this is func1’)

def outer(func):
def inner():
func()
print(‘i come from china’)
return inner

f1 = outer(func1)
f1()
#this is func1
i come from china
但是上面的操作我們在給一個函數進行裝飾的時候會調用f1這個函數，但是我們調用func1的時候并沒有給我裝飾上具體的需求，python認為上面的寫法不簡潔，所以提出了@語法糖
def outer(func):
def inner():
func()
print(‘i come from china’)
return inner

@outer #func1=outer(func1) 此時func1這個變量就相當于inner
def func1():
print(‘this is func1’)

func1() #此時func1()就相當于inner()
–this is func1
i come from china
例：模擬登錄驗證
import time
a = [‘susisi’,‘xulutao’,‘suyiang’]

def outer(func) :
def inner(name) :
func(name)
print(‘開始判斷你有沒有登錄’)
time.sleep(2)

if name in a :print('您已經登錄，可以進行訪問')time.sleep(1) else :print('你沒有登錄，沒有權限進行訪問')time.sleep(1)

return inner
1
2
3
4
5
6
7
@outer #func1=outer(func1) 此時func1這個變量就相當于inner
def login(name):
print(’%s要瀏覽’% name)
@outer
def goods_car(name):
print(’%s要加入購物車’% name)

login(‘susisi’)

總結

以上是生活随笔為你收集整理的(课程学习笔记)Python基础学习的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。