溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
這篇文章主要介紹“Python入門基礎知識點實例分析”的相關知識，小編通過實際案例向大家展示操作過程，操作方法簡單快捷，實用性強，希望這篇“Python入門基礎知識點實例分析”文章能幫助大家解決問題。
在 Python 中，所有標識符可以包括英文（區分大小寫的）、數字以及下劃線(_)，但不能以數字開頭。
以單下劃線開頭 _foo 的代表不能直接訪問的類屬性，需通過類提供的接口進行訪問，不能用 from xxx import * 而導入。
以雙下劃線開頭的 __foo 代表類的私有成員，
以雙下劃線開頭和結尾的 __ foo__ 代表 Python 里特殊方法專用的標識，如 __init__() 代表類的構造函數。
Python 的代碼塊中必須使用相同數目的行首縮進空格數
python中單行注釋采用 # 開頭。
python 中多行注釋使用三個單引號(‘’')或三個雙引號(“”")。
# Python語句中一般以新行作為語句的結束符。但是我們可以使用【斜杠（ \）】將一行的語句分為多行顯示，
# 語句中包含 [], {} 或 () 括號就不需要使用多行連接符。
# Python可以在同一行中使用多條語句，語句之間使用【分號(;)】分割
total = item_one + \
item_two + \
item_three
days = ['Monday', 'Tuesday', 'Wednesday',
'Thursday', 'Friday']
# Python可以在同一行中使用多條語句，語句之間使用【分號(;)】分割。
import sys; x = 'runoob'; sys.stdout.write(x + '\n')
# Python 可以使用【引號( ' )、雙引號( " )、三引號( ''' 或 """ ) 】來表示字符串
word = 'word'
sentence = "這是一個句子。"
paragraph = """這是一個段落。
包含了多個語句"""
# print 默認輸出是換行的，如果要實現【不換行需要在變量末尾加上逗號】 。
print x,y
Python3 中有六個標準的數據類型：
Number（數字）
String（字符串）
List（列表）
Tuple（元組）
Set（集合）
Dictionary（字典）
Python3 的六個標準數據類型中：
不可變數據（3 個）：Number（數字）、String（字符串）、Tuple（元組）；
可變數據（3 個）：List（列表）、Dictionary（字典）、Set（集合）。
int、float、bool、complex（復數）
內部函數中，strings, tuples, 和 numbers 是不可更改的對象，全局變量必須為init變量或者在函數中用self定義；而 list,dict 等則是可以修改的對象，內部函數可以直接使用函數中的局部變量。
counter = 100 # 賦值整型變量
miles = 1000.0 # 浮點型
name = "John" # 字符串
二進制轉換：
int('10',2)
> 2
bin(10)
> '0b1010'
bin(10)[2:]
ord(c) # c為字符
# 返回值：對應的十進制整數（ASCll數值）
int(c) # c為字符，轉化為對應的數字
float('-inf') # 最小值
-inf
a = b = c = 1
a, b, c = 1, 2, "john"
all() # 函數用于判斷給定的可迭代參數 iterable 中的所有元素是否都為 TRUE，如果是返回 True，否則返回 False。
# 從左到右索引默認【0開始的】，最大范圍是字符串【長度少1】
# 從右到左索引默認【-1開始的】，最大范圍是【字符串開頭】
# 第三個參數，參數作用是【截取的步長】
s = "a1a2···an" # n>=0
向上取整：math.ceil()
向下取整：math.floor()、整除"//"
四舍五入：round()——奇數向遠離0取整，偶數去尾取整；或言之：奇數進位，偶數去尾
向0取整：int()
tinylist = [123, 'john']
print list[0] # 輸出列表的第一個元素
print list[1:3] # 輸出第二個至第三個元素
print list[2:] # 輸出從第三個開始至列表末尾的所有元素
# 二維數組
num_list = [ [0] * 5 for i in range(2)]
dp = [[1]*n] + [[1]+[0] * (n-1) for _ in range(m-1)]
clone_node.neighbors = [self.cloneGraph(n) for n in node.neighbors]
# 加號 + 是列表連接運算符，星號 * 是重復操作
print tinylist * 2 # 輸出列表兩次
print list + tinylist # 打印組合的列表
list.append('Google') # 使用 append() 添加元素
del list[2] # 可以使用 del 語句來刪除列表的元素
list.pop(3) # 指定pop參數，將會刪除該位置的元素；無參數時默認刪除最后一個元素
list.append(sublist) # 引用傳遞
list.append([]+sublist) # 值傳遞
list.append(list(path))
len([1, 2, 3]) 3 #長度
[1, 2, 3] + [4, 5, 6] [1, 2, 3, 4, 5, 6] #組合
['Hi!'] * 4 ['Hi!', 'Hi!', 'Hi!', 'Hi!'] #重復
3 in [1, 2, 3] True #元素是否存在于列表中
for x in [1, 2, 3]: print x, 1 2 3 #迭代
[::-1] # 數組反轉
max(list) # 求list的最大值
sum(sp[i] for i in range(n)) #求和
sum(s in jewelsSet for s in stones)
nums.sort() # 排序
score.sort(reverse=True)
list有一個sort方法，list.sort()將list進行排序，返回None
sort(*,key = None,reverse = False)
key是一個函數，這個函數的作用是從list的每個元素中提取用于當作排序依據的屬性
默認是從小到大，即reserve為False的時候，如果reserve為True，排列順序就是從大到小
def f(item):
return item[1]
list.sort(key = f)
list.sort(key = lambda item:item[0])
sorted(iterable,*,key=None,reverse=False) # 默認正序排列
sorted(dict.items(),key=lambda item:item[0])
res = sorted(hash,key = lambda word:(-hash[word],word)) # 第一個參數 -hash[word] 即單詞出現次數的相反數
# 當詞頻相同時，用第二個參數 word 進行排序，即字母正序排列
列表解析 List Comprehensions
表達式：[expression for iter_val in iterable if cond_expr]
[expression]：最后執行的結果
[for iter_val in iterable]：這個可以是一個多層循環
[if cond_expr]：兩個for間是不能有判斷語句的，判斷語句只能在最后；順序不定，默認是左到右。
print[(x,y)for x in [1,2]for y in [3,4]]
for (k1, v1), (k2, v2) in zip(dict_one, dict_two): # 遍歷兩個list或者dict
for item in product([1,2],[10,20]): # 對矩陣做笛卡爾積
print(item)
for i, j in product(range(m), range(n)):
neighbors = [(1,0), (1,-1), (0,-1), (-1,-1), (-1,0), (-1,1), (0,1), (1,1)]
for neighbor in neighbors:
r = (row + neighbor[0])
c = (col + neighbor[1])
for u,v in neighbors:
s = [1, 2, 3, 4, 5]
# 從指定索引1開始
for index, value in enumerate(s, 1):
list(str(n)) # int轉化為字符串，轉化為list
next(word for word,f in freq.items() if f==maxFreq) # next()取list第一個值
map(max, grid) # 求每行的最大值
map(max, zip(*grid)) # 求每列的最大值
strs = map(str,nums) # 轉換為list(str)
r1,m1 = map(int, num1[:-1].split('+')) # list(str)轉化為list(int)
list(map(list,numSet))
>>> a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b) # 返回一個對象
>>> zipped
<zip object at 0x103abc288>
>>> list(zipped) # list() 轉換為列表
[(1, 4), (2, 5), (3, 6)]
>>> list(zip(a,c)) # 元素個數與最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> a1, a2 = zip(*zip(a,b)) # 與 zip 相反，zip(*) 可理解為解壓，返回二維矩陣式
>>> list(a1)
[1, 2, 3]
>>> list(a2)
[4, 5, 6]
# 元組用 () 標識。內部元素用逗號隔開。但是元組不能二次賦值，相當于只讀列表。
tinytuple = (123, 'john')
# 字典用"{ }"標識。字典由索引(key)和它對應的值value組成。
dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"
# 值可以取任何數據類型，但鍵必須是不可變的，如字符串，數字或 元組 。 用列表就不行
dict[tuple(count)]
# 以列表返回字典中的所有值
dict.values()
list(dict.values())
for key in dict:
print (key)
tinydict = {'name': 'runoob','code':6734, 'dept': 'sales'}
print dict['one'] # 輸出鍵為'one' 的值
print dict[2] # 輸出鍵為 2 的值
print tinydict # 輸出完整的字典
print tinydict.keys() # 輸出所有鍵
print tinydict.values() # 輸出所有值
maxFreq = max(freq.values()) # 求value的最大值
tinydict['Age'] = 8 # 更新
tinydict['School'] = "RUNOOB" # 添加
del tinydict['Name'] # 刪除鍵是'Name'的條目
tinydict.clear() # 清空字典所有條目
del tinydict # 刪除字典
defaultdict(list) defaultdict(int) # defaultdict類的初始化函數接受一個類型作為參數，當所訪問的鍵不存在的時候，可以實例化一個值作為默認值：
count.get(c, 0) # 默認值為0
items():返回所有（key，value）元組的數組,類似于‘列表’
[s for s, c in cnt.items() if c == maxCnt] # 遍歷dict
dict排序
sorted(dict.items(),key=lambda item:item[0])
items = [(-val, key) for key, val in count.items()] # 變更為tuple
for val, key in sorted(items): # 遍歷排序后的tuple
parame = {value01,value02,...}
或者
set(value)
s.add( x )
s.update( x ) # 參數可以是列表，元組，字典等
s.remove( x )
s.discard( x )
len(s)
s.clear()
x in s
for key in set:
print (key)
/ 除 - x除以y
% 取模 - 返回除法的余數
** 冪 - 返回x的y次冪
// 取整除 - 返回商的整數部分（向下取整）
and x and y 布爾"與" - 如果 x 為 False，x and y 返回 False，否則它返回 y 的計算值。
or x or y 布爾"或" - 如果 x 是非 0，它返回 x 的計算值，否則它返回 y 的計算值。
not not x 布爾"非" - 如果 x 為 True，返回 False 。
is is 是判斷兩個標識符是不是引用自一個對象
is not is not 是判斷兩個標識符是不是引用自不同對象
is 與 == 區別：
is 用于判斷兩個變量引用對象是否為同一個(同一塊內存空間)， == 用于判斷引用變量的值是否相等。
if num == 3: # 判斷num的值
print 'boss' elif num == 2:
print 'user'elif num == 1:
print 'worker'elif num < 0: # 值小于零時輸出
print 'error'else:
print 'roadman' # 條件均不成立時輸出
i = 1
while i < 10:
i += 1
if i%2 > 0: # 非雙數時跳過輸出
continue
print i # 輸出雙數2、4、6、8、10
i = 1
while 1: # 循環條件為1必定成立
print i # 輸出1~10
i += 1
if i > 10: # 當i大于10時跳出循環
break
flag = 1
while (flag): print 'Given flag is really true!'
fruits = ['banana', 'apple', 'mango']
for fruit in fruits: # 第二個實例
print ('當前水果: %s'% fruit)
fruits = ['banana', 'apple', 'mango']
for index in range(len(fruits)):
print ('當前水果 : %s' % fruits[index])
for i in reversed(range(length - 1)): # 逆序
for letter in 'Python': # 第一個實例
if letter == 'h':
break
print '當前字母 :', letter
for i, ch in enumerate(s):
if frequency[ch] == 1:
return i
diff = [(a,b) for a,b in zip(s,goal) if a!=b]
+ 字符串連接
>>>a + b
'HelloPython'
* 重復輸出字符串
>>>a * 2
'HelloHello'
[] 通過索引獲取字符串中字符
>>>a[1]
'e'
[ : ] 截取字符串中的一部分
>>>a[1:4]
'ell'
in 成員運算符 - 如果字符串中包含給定的字符返回 True
>>>"H" in a
True
not in 成員運算符 - 如果字符串中不包含給定的字符返回 True
>>>"M" not in a
True
r/R 原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思來使用，沒有轉義特殊或不能打印的字符。 原始字符串除在字符串的第一個引號前加上字母"r"（可以大小寫）以外，與普通字符串有著幾乎完全相同的語法。
>>>print r'\n'
\n
>>> print R'\n'
\n
strs = 'abcd'
for ch in strs:
print(ch)
strs = 'abcd'
for index in range(len(strs)):
print(strs[index], end=' ')
res += 'a'*3 # 'aaa'
s.split(" ") # 將字符串分割成單詞列表
" ".join(list) # 將單詞列表轉換為字符串，以空格分隔
f'{bulls}A{cows}B' # {}計算格式化
a = list(str(n)) # int轉成list
a[i-1] = str(int(a[i-1]) - 1) # 操作字符
int("".join(a)) # list轉化為int
isdigit # 函數判斷是否數字
isalpha # 判斷是否字母
print "My name is %s and weight is %d kg!" % ('Zara', 21)
%s 格式化字符串
%d 格式化整數
%f 格式化浮點數字，可指定小數點后的精度
允許一個字符串跨多行，字符串中可以包含換行符、制表符以及其他特殊字符
>>> hi = '''hi
there'''
>>> hi # repr()
'hi\nthere'
>>> print hi # str()
hi
there
string.count(str, beg=0, end=len(string))
# 返回 str 在 string 里面出現的次數，如果 beg 或者 end 指定則返回指定范圍內 str 出現的次數
string.endswith(obj, beg=0, end=len(string))
# 檢查字符串是否以 obj 結束，如果beg 或者 end 指定則檢查指定的范圍內是否以 obj 結束，如果是，返回 True,否則返回 False.
string.find(str, beg=0, end=len(string))
# 檢測 str 是否包含在 string 中，如果 beg 和 end 指定范圍，則檢查是否包含在指定范圍內，如果是返回開始的索引值，否則返回-1
string.format()
# 格式化字符串
string.index(str, beg=0, end=len(string))
# 跟find()方法一樣，只不過如果str不在 string中會報一個異常.
string.join(seq)
# 以 string 作為分隔符，將 seq 中所有的元素(的字符串表示)合并為一個新的字符串
string.replace(str1, str2, num=string.count(str1))
# 把 string 中的 str1 替換成 str2,如果 num 指定，則替換不超過 num 次.
string.split(str="", num=string.count(str))
# 以 str 為分隔符切片 string，如果 num 有指定值，則僅分隔 num+1 個子字符串
在 python 中，strings, tuples, 和 numbers 是不可更改的對象，而 list,dict 等則是可以修改的對象。
不可變類型：變量賦值 a=5 后再賦值 a=10，這里實際是新生成一個 int 值對象 10，再讓 a 指向它，而 5 被丟棄，不是改變a的值，相當于新生成了a。
可變類型：變量賦值 la=[1,2,3,4] 后再賦值 la[2]=5 則是將 list la 的第三個元素值更改，本身la沒有動，只是其內部的一部分值被修改了。
在Python中，數字、字符或者元組等不可變對象類型都屬于值傳遞，而字典dict或者列表list等可變對象類型屬于引用傳遞。
如果要想修改新賦值后原對象不變，則需要用到python的copy模塊，即對象拷貝。
copy.copy屬于淺拷貝，拷貝的是第一層list，而copy.deepcopy屬于深拷貝，對list所有子元素都進行深拷貝。
#可寫函數說明
def printinfo( name, age = 35 ):
"打印任何傳入的字符串"
print "Name: ", name
print "Age ", age
return
#調用printinfo函數
printinfo( age=50, name="miki" )
printinfo( name="miki" )
# 可寫函數說明
def printinfo( arg1, *vartuple ):
"打印任何傳入的參數"
print "輸出: "
print arg1
for var in vartuple:
print var
return
# 調用printinfo 函數
printinfo( 10 )
printinfo( 70, 60, 50 )
import copy
l1 = [[1, 2], 3]
l2 = copy.copy(l1)
l3 = copy.deepcopy(l1)
l2.append(4)
l2[0].append(5)
l3[0].append(6)
l1 = [[1, 2, 5], 3]
l2 = [[1, 2, 5], 3, 4]
l3 = [[1, 2, 6], 3]
# 可寫函數說明
sum = lambda arg1, arg2: arg1 + arg2
# 調用sum函數
print "相加后的值為 : ", sum( 10, 20 )
print "相加后的值為 : ", sum( 20, 20 )
import support
from fib import fibonacci
from math import *
搜索路徑
1、當前目錄
2、如果不在當前目錄，Python 則搜索在 shell 變量 PYTHONPATH 下的每個目錄。
3、如果都找不到，Python會察看默認路徑。UNIX下，默認路徑一般為/usr/local/lib/python/。
模塊搜索路徑存儲在 system 模塊的 sys.path 變量中。變量里包含當前目錄，PYTHONPATH和由安裝過程決定的默認目錄。
Python中的包
包是一個分層次的文件目錄結構，它定義了一個由模塊及子包，和子包下的子包等組成的 Python 的應用環境。
簡單來說，包就是文件夾，但該文件夾下必須存在 __init__.py 文件, 該文件的內容可以為空。 __init__.py 用于標識當前文件夾是一個包。
考慮一個在 package_runoob 目錄下的 runoob1.py、runoob2.py、 __init__.py 文件，test.py 為測試調用包的代碼，目錄結構如下:
test.py
package_runoob
|-- __init__.py
|-- runoob1.py
|-- runoob2.py
# 導入 Phone 包from package_runoob.runoob1 import runoob1from package_runoob.runoob2 import runoob2
runoob1()runoob2()
str = input("請輸入：")
print "你輸入的內容是: ", str
fo = open("foo.txt", "w")
print "文件名: ", fo.name
print "是否已關閉 : ", fo.closed
print "訪問模式 : ", fo.mode
print "末尾是否強制加空格 : ", fo.softspace
# 打開一個文件
fo = open("foo.txt", "w")
str = fo.read(10)
fo.write( "www.runoob.com!\nVery good site!\n")
# 關閉打開的文件
fo.close()
import os
os.rename( "test1.txt", "test2.txt" )
os.remove("test2.txt")
os.mkdir("test")
# 將當前目錄改為"/home/newdir"
os.chdir("/home/newdir")
# 給出當前的目錄
print os.getcwd()
# 刪除”/tmp/test”目錄
os.rmdir( "/tmp/test" )
try:
正常的操作
......................
except:
發生異常，執行這塊代碼
......................
else:
如果沒有異常執行這塊代碼
try:
fh = open("testfile", "w")
fh.write("這是一個測試文件，用于測試異常!!")
except IOError:
print "Error: 沒有找到文件或讀取文件失敗"
else:
print "內容寫入文件成功"
fh.close()
try-finally 語句無論是否發生異常都將執行最后的代碼。
try:
<語句>
finally:
<語句> #退出try時總會執行
raise
try:
fh = open("testfile", "w")
try:
fh.write("這是一個測試文件，用于測試異常!!")
finally:
print "關閉文件"
fh.close()
except IOError:
print "Error: 沒有找到文件或讀取文件失敗"
class Employee:
'所有員工的基類'
empCount = 0
def __init__(self, name, salary):
self.name = name
self.salary = salary
Employee.empCount += 1
def displayCount(self):
print "Total Employee %d" % Employee.empCount
def displayEmployee(self):
print "Name : ", self.name, ", Salary: ", self.salary
"創建 Employee 類的第一個對象"
emp1 = Employee("Zara", 2000)
"創建 Employee 類的第二個對象"
emp2 = Employee("Manni", 5000)
emp1.displayEmployee()
emp2.displayEmployee()
print "Total Employee %d" % Employee.empCount
empCount 變量是一個類變量，它的值將在這個類的所有實例之間共享。你可以在內部類或外部類使用 Employee.empCount 訪問。
第一種方法__init__()方法是一種特殊的方法，被稱為類的構造函數或初始化方法，當創建了這個類的實例時就會調用該方法
self 代表類的實例，self 在定義類的方法時是必須有的，雖然在調用時不必傳入相應的參數。
登錄后復制class A: # 定義類 A
.....
class B: # 定義類 B
.....
class C(A, B): # 繼承類 A 和 B
.....
class Parent: # 定義父類
def myMethod(self):
print '調用父類方法'
class Child(Parent): # 定義子類
def myMethod(self):
print '調用子類方法'
class Parent: # 定義父類
def myMethod(self):
print '調用父類方法'
class Child(Parent): # 定義子類
def myMethod(self):
print '調用子類方法'
類的私有屬性
__private_attrs：兩個下劃線開頭，聲明該屬性為私有，不能在類的外部被使用或直接訪問。在類內部的方法中使用時 self.__private_attrs。
類的方法
在類的內部，使用 def 關鍵字可以為類定義一個方法，與一般函數定義不同，類方法必須包含參數 self,且為第一個參數
類的私有方法
__private_method：兩個下劃線開頭，聲明該方法為私有方法，不能在類的外部調用。在類的內部調用 self.__private_methods
單下劃線、雙下劃線、頭尾雙下劃線說明：
__foo__: 定義的是特殊方法，一般是系統定義名字 ，類似 __init__() 之類的。
_foo: 以單下劃線開頭的表示的是 protected 類型的變量，即保護類型只能允許其本身與子類進行訪問，不能用于 from module import *
__foo: 雙下劃線的表示的是私有類型(private)的變量, 只能是允許這個類本身進行訪問了。
關于“Python入門基礎知識點實例分析”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識，可以關注億速云行業資訊頻道，小編每天都會為大家更新不同的知識點。
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
