python學習基礎彙總

python

python語言使用強制縮進,表示語句層次以及代碼塊,不像C/C++/java等語言使用{}表示語句層次代碼塊

python的基本數據結構

變量(variable)

變量表示對象的引用,而現實世界的一切都可以看成對象,一個杯子,一支筆,一本書。。。等等都是對象,我們將其抽象化,然後用計算機語言描述,就是各種各樣的類,而具體到比如我桌子上的筆,那麼這支筆就是一個類實例對象,我們就可以用一個變量名來表示。假設我定義了一個筆變量,‘bi = 10’就表示我有10支筆。= 表示賦值

變量既然可以命名那我們是不是什麼名字都可以取呢?不是的

變量的命名規則:

1. 變量名由:字母,數字,下劃線 組成,數字不能打頭

2. 變量名對字母大小寫敏感,大寫小寫表示不同的變量

3. 變量名要避開python的關鍵字保留字

python中,變量就是變量沒有類型,類型是指變量所引用的內存中對象的類型

int

float

bool

string

list

tuple

set

dictionary

int – 整型

float – 浮點型

a = 10
b = 10.8
c = -5

上面定義的三個對象a,c是int型對象,而b是浮點型對象

簡單的說就是一切整數都是int型,一切帶小數的都是浮點型,不管小數有多少位

int 和 float 兩種都是數據類型,支持一些數據運算

支持的運算符有:+ - * / // ** %

上述運算符‘+ - * /’和規則數學上一樣,不過 ‘/’ 運算後對象都會變爲float型
並且如果運算過程中有float型變量參與,結果都會變爲float型

// 表示整除法,結果爲整數(不是四捨五入,小數部分直接被捨棄)

** 表示冥運算 %表示取模,就是求餘數
說明:如果運算過程中有float型對象參與,結果都會變爲float型

a = 10
b = 6.6
c = 2
print(a + b)  # a + b = 16.6
print(a - b)  # a - b = 3.400...
print(a + c)  # a + c = 12
print(a / c)  # a / c = 5.0
print(a // c) # a // c = 5
print(a // b) # a // b = 1.0
print(a ** c) # a ** c = 100 
print(a % b) # a % b = 3.400...
print(a % c) # a % c = 0

說明:’=’ 表示賦值 ‘==’表示相等

bool – 布爾型

bool型只有兩種值,True 和 False ,一般是用在條件判斷語句上,表示真 or 假
bool型也可以用在數據運算上,這時候True = 1,False = 0

a = 1
print(a + True)
print(a - False)

運行結果 2 ,1

string – 字符串型

字符串類型比較特殊,字符串對象一旦定義就不能再修改,但是我們還可以做一些其他的操作
python中沒有char類型表示一個字符,所以在python中一個字符‘a’也是字符串

a = 'wills '
b = 'hello  world'
c = '  '
len(a)                  # len函數用來求字符串的長度,結果是5
for i in a:               # 遍歷字符串a,打印其中的每一個元素
    print(i,end=' ')       # end=‘’表示,打印時不換行,a這個字符串的所有字符打印在一行
a1 = str.replace(a,'w','K')
print(a.title())           # capitalize()和title()函數都可以將字符串首字母大寫,並且把其他字母小寫
print(a.capitalize())
print(a,a1)               # 結果是 wills  Kills,可以看出,a並沒有被修改,而是給了一個修改後的新字符串a1
print(a+b+c)              # 字符串支持拼接操作,使用 + 操作符
print(a * 3)              # 字符串支持複製操作,使用 * 操作符
# 字符串還支持切片下標操作,下標就是字符串從左邊往右數,從0開始數,數字放在[]裏
print(a[0],a[4])           # 結果‘w’和 ‘s’
print(a[0:3],a[2:4])        # 結果 wil  和  ll
print(a[0:-1],b[-3:0])       #  結果 wills  和  無
print(b[::2],b[::-2])        # 結果 ‘hlo ol’  和‘drw le’ 
print(b[::-1])             # 將字符串倒過來
# 下標切片運算時
# 當只有一個‘:’左邊表示起點,右邊表示終點,正數表示從左往右0開始數,負數表示從右往左-1開始數
# 當有兩個‘:’,第一個‘:’左右兩邊規則不變,最右邊數的大小表示步長,正負表示數數方向

print(sorted(a))           # 結果 ['i', 'l', 'l', 's', 'w'] 
# 字符串可以轉換爲list,字符串可以按照字母表順序排序,不過排序後返回一個列表

x = '   hello   world!   '  # 所有空格都是3個
print(x)
print(x.index('o'))         # 7
print(x.rindex('o'))        # 12
print(x.find('h'))         #  3
print(x.rfind('o'))         # 12         
# index和find 都表示下標索引,r表示從右邊開始的某個字符

print(x.join('kk'))        # 表示在‘kk’的間隔插入加一個x

print(x.strip(' '))        # 去掉x左右兩邊空格
print(x.lstrip(' '))        # 去掉x左邊空格
print(x.rstrip(' '))        # 去掉x右邊空格

print(x.ljust(20,'+'))       # 以20字符長度進行左對齊,x字符不夠添加 + 補足20個
print(x.rjust(20,'/'))       # 右對齊,x字符不夠 用 / 補齊20個
print(x.center(30,'*'))      # 將x以30個字符長度居中,x字符不足以 * 補齊
print(x.split('d'))         # 將x從字符‘d’這裏截斷爲2個字符串,返回一個list
print(x.split('k'))         # 如果x中中找到不到‘k’則返回整個字符串

列表(list)

列表中可以存放多個不同種類的元素,並且元素允許重複和修改

string類型中的切片index,find在list中都可以使用,並且用法相同

list中的元素是可以刪除的

在python解釋器中輸入dir([]),即可獲取list的所有內置方法

# 假設我們需要25個元素,5*5的形式
# 列表生成辦法
# 1 列表生成式
list1 = [[x for x in range(5)] for _ in range(5)]
# [[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]
# 2 列表生成器
list2 = ((x for x in range(15))
# 列表生成器生成的是一個元組
for val in list2:
    print(val,end=' ')
list1 = [2,1,3,5,4]
sorted(list1)     # list1本身不變,返回一個將列表中的元素排序好的新列表【1,2,3,4,5】
print(list1)     #  [2,1,3,5,4]
list1.sort()      # 將列表排序,但是list1本身被改變
print(list1)     #  [1,2,3,4,5]
del list1       # 刪除整個列表
del list1[0]     # 利用下標刪除列表中的某個元素
del list1[1:3]    # 利用刪除列表中某幾個元素
list1.remove(3)   # 刪除列表中某個已知元素
list1.append(33)   # 在列表最後追加元素
list1.insert(2,11) #  插入元素,第一個參數表示插入的位置
list1 + list1     # list支持拼接,使用 + 運算符

元組(tuple)

元組的操作幾乎和列表沒什麼差別,幾個要點

a。 元組的元素是不可修改的,並且不可刪除,但可用del刪除整個元組

b。 元組放在()括號裏面,列表放在 [] 裏面

c。 創建一個列表用 list = [ 1 ] ;而創建空元組 用 tuple =(1,)

一定要加一個,號,不然會變成整型

我們能用元組完成的就絕不要用列表,因爲tuple不可修改,更安全

集合(set)

集合就像數學上的集合一樣,放在大括號裏,支持 交 並 差 對稱差 子集 超集

集合無序,無法進行下標運算,自動去重複的元素,可以進行關係測試

set1 = {1,3,5,7,7}
set2 = {2,4,6,8}
print(set1,set3)
if 1 in set1:
    print('ok')     #關係測試,判斷1是否在set1中
set1 - set2         # set1 與 set2 的差集
set2 - set1         # set2 與 set1 的差集
set1 & set2         # set1 與 set2 的交集
set1 | set2         # set1 與 set2 的並集
set1 ^ set2         # set1 與 set2 的對稱差集

字典(dictionary)

字典中的元素都是一個個的鍵值對,一個鍵值對錶示一個元素,一個元素由鍵+值構成,鍵唯一不可修改,但是值可變
字典和集合一樣也是放在大括號 {} 裏面,可以使用鍵來取得對應的元素

鍵:可以用數字,字符串,元組(都不可修改)

可以使用del語句刪除元素,len()函數可以返回字典元素個數

dic = {'name': 'wills','age':22,'sex':'man','class':'python','age':25}
# 如果鍵的值定義2次,後面回覆蓋前面的
print(dic)                # {'name': 'wills','sex':'man','class':'python','age':25}
for v in dic:              # {'name': 'wills','sex':'man','class':'python','age':25}
    print(v,end=' ')        #   遍歷後獲取鍵值  name sex  class  age 
del dic['age']             # 刪除 鍵age 對應的元素
print(dic)                # {'name': 'wills','sex':'man','class':'python'}
dic.get('age','沒有')        # 判斷age是否在字典,有輸出對應的值沒有,返回‘沒有’
print(dic.items())          # 將字典元素以(key,value)對應形式建立一個元組
print(dic.keys())           # 將字典所有key建立一個列表對象
print(dic.values())         #  將字典元素所有value建立一個列表對象
dic.update({'hi':'nihao'})     # 添加一個字典對象,注意用大括號括起來
print(dic)

分支結構if():條件語句

程序一般都是自上往下一次執行,但是有時候遇到多種情況都需要執行,但是又不能同時進行,這個時候就需要if條件語句

if True :那麼條件成立,if False:那麼條件不成立

a = 2
b = 3
c = 1
if a>b:   # if 條件語句成立的條件是a > b
    a = a+b
else:
    a = b
# 這裏是個單次判斷,如果a>b 那麼 就把a+b的值賦給a;否則把b的值賦給a

if a < b:
    a = b - a
elif a == b:
    a = a + b
else: 
    a = 0
# 此處判斷2次,a < b 則 a = b - a
a == b 則 a = a + b
否則  a = 0

邏輯語句 and or not

and 表示 且; or 表示 或者; not 表示 非

真 and 真 —- 》真

真 and 假 —- 》假

真 or 假 —-》 真

假 or 假 —-》 假

not 真 —–》 假

not 假 —-》 真

and 和 or還具有斷點功能

如果 and 前面語句爲假,那麼後面就不執行

如果 or 前面爲真,後面也不再執行

比如 1. if 事件1 and 事件2
2. if 事件1 or 事件2
3. if not 事件1
假設 事件1: 真 事件2: 假 那麼以上3個條件只有2成立

循環結構:‘for x in range(n):’;‘while True:’

循環語句用來解決我們需要反覆執行的重複內容

for 循環

for n in range(10):# 輸出10個星號*
    print('*',end = ' ')
for n in range(1,100,2)
    print(n,end=' ')
# 輸出100以內的奇數,range(1,100,2)
# 1 表示n取值的起點可以取到1,100表示終點,取不到100,2表示步長

while 循環

while 循環是根據循環條件運行

while true:執行
while false:不執行

while True:
    print(*)
# 死循環,不停打印*,沒有停止條件

t=10
while t>0:
    print(t)
    t - =3
# t的值不斷變小,當t<0時,while條件不成立,結束循環


a = 100

while True:
    a -= 3
    if a < 0:
        break
# while True:恆成立,一直循環,但是a不斷變小,滿足if條件是,break語句可以立刻打破當前循環

定義函數(defind)

雖然python自定義了很多很多功能強大函數,但我們有時候也會自己定義函數

# 定義函數格式
def faction(*args):
    ...
    statement
    ...
    return ...
# 我們有一個列表 l1 = [1,32,3,42,2],我想要把它打印爲[00,00,00,00,00]的格式

def display(list):
    for val in list:
        print('%02d' % val,end=' ')
   return 0

l1 = [1,32,3,42,2]
display(l1)                 # 輸出結果爲  01 32 03 42 02

定義函數時也要注意函數名,規則和變量名規則一樣

如果在同一模塊中定義了兩個同名函數,那麼後定義的那個會將前面的覆蓋

函數的參數可以給一個默認值,那麼不傳參就表示使用默認值

類(class)

我們現實世界的萬事萬物都是對象,一個人,一輛車,一條魚,一隻鳥,一篇文章,這些都是對象,當我們把具有相同靜態屬性和動態特徵的一些對象放在一起時,就構成了類,比如人類,車類,魚類,鳥類,書籍類,當我們定義了這些類之後,我們就有了一些對應的屬性概念,比如定義了人類,那麼人類的靜態屬性就有姓名,年齡,身高,性別,。。。等靜態固定的屬性,除此之外,人還有相同動態特徵例如跑,走,笑,哭,攻擊行爲,學習,但是人與人又有不同,比如一個是是學生,有考試,有成績。另一個是嬰兒,只有名字 性別 身高 哭 笑.名字,性別這些名詞就是靜態屬性,哭笑就是動態特徵那麼我們可以創建2個新的子類,叫學生類,嬰兒類。學生類和嬰兒類都是人類的子類
那麼我現在來創建一個學生類,類名首字母大寫

class ClassName(object):
    def __init__(self,args):
        self.args = args
class Student(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
    # age 和 name 就是學生共同的靜態屬性
    def __str__(self):
        return 'name = %s , age = %s' % (self.name,self.age)

    # 設置默認返回函數,來返回名字和年齡屬性,字符串形式

    def study(self,course):
        print('%s is studing %s ...' % (self.name,course))

    def sport(self,sports):
        print('%s is playing %s ...' % (self.name,sports))


stu1 = Student('king',23)
stu1.study('math')
stu2 = Student('queen',22)
stu2.sport('dance')

在上面的學生類中,我給學生定義了兩種靜態屬性name 和 age,兩種動態特徵 study 和 sport,然後調用了這個類生成了兩個類實例stu1和stu2,並且調用了stu1的方法study,讓stu1去學習‘math’,調用了stu2的方法sport,讓stu2去跳舞‘dance’
這就是面向對象的思想,讓對象去做事,這裏,stu1和stu2就是對象,也叫類實例,以後遇到同樣的問題,調用這個學生類就好了

發佈了43 篇原創文章 · 獲贊 19 · 訪問量 5萬+
發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章