一、字符串

1.創建字符串

字符串是 Python 中最常用的數據類型。我們可以使用引號('或")來創建字符串。

創建字符串很簡單，只要為變量分配一個值即可。

var1='apple' var2='Hello World!'

2.訪問字符串中的值

Python不支持單字符類型，單字符在 Python 中也是作為一個字符串使用。

Python訪問子字符串，可以使用方括號來截取字符串。

var1='apple' var2='Hello World!' print ("var1[0]: ", var1[0]) print ("var2[1:5]: ", var2[1:5]) # var1[0]: a # var2[1:5]: ello

3.字符串更新

var2='Hello World!' print('更新后的var2：',var2[:6]+'Java!') # 更新后的var2： Hello Java!

4.轉義字符

在需要在字符中使用特殊字符時，python用反斜杠()轉義字符。

5.字符串運算符

下表實例變量 a 值為字符串 "Hello"，b 變量值為 "Python"：

下面代碼實現：

a = "Hello" b = "Python" print ("a + b 輸出結果：", a + b) print ("a * 2 輸出結果：", a * 2) print ("a[1] 輸出結果：", a[1]) print ("a[1:4] 輸出結果：", a[1:4]) if("H" in a) :print ("H 在變量 a 中") else :print ("H 不在變量 a 中") if("M" not in a) :print ("M 不在變量 a 中") else :print ("M 在變量 a 中") print (r'n') print (R'n') # a + b 輸出結果： HelloPython # a * 2 輸出結果： HelloHello # a[1] 輸出結果： e # a[1:4] 輸出結果： ell # H 在變量 a 中 # M 不在變量 a 中 # n # n

6.字符串格式化

a.常規格式化字符串

name='Crystal' age=25 print("My name is %s,my age is %d." % (name,age)) # My name is Crystal,my age is 25.

python字符串格式化符號:

格式化操作符輔助指令：

b.格式化字符串函數format( )

格式化字符串函數str.format()，python2.6之后才有的。

基本語法是通過 {} 和 ：來代替以前的 % 。format 函數可以接受不限個參數，位置可以不按順序。

print("{} {}".format("hello", "world")) # 不設置指定位置，按默認順序 # hello world print("{0} {1}".format("hello", "world")) # 設置指定位置 # hello world print("{1} {0} {1}".format("hello", "world")) # 設置指定位置 # world hello world name='Crystal' age=25 print("My name is {},my age is {}." .format(name,age))

可以設置參數

print

也可以向 str.format() 傳入對象：

class AssignValue(object):def __init__(self, value):self.value = value my_value = AssignValue(6) print(('value 為: {0.value}'.format(my_value))) # "0" 是可選的

format( )數字格式化

下表展示了 str.format() 格式化數字的多種方法：

print('{:.2f}'.format(3.1415926)) # 3.14

^, <, > 分別是居中、左對齊、右對齊，后面帶寬度， : 號后面帶填充的字符，只能是一個字符，不指定則默認是用空格填充。

+ 表示在正數前顯示 +，負數前顯示 -； （空格）表示在正數前加空格

b、d、o、x 分別是二進制、十進制、八進制、十六進制。

我們可以使用大括號 {} 來轉義大括號：

print ("{} 對應的位置是 {{0}}".format("python")) # python 對應的位置是 {0}

7.三引號

python中三引號可以將復雜的字符串進行復制，允許一個字符串跨多行，字符串中可以包含換行符、制表符以及其他特殊字符。

三引號的語法是一對連續的單引號或者雙引號（通常都是成對的用）。單引號里面字符串如果存在換行，則會報錯。

hi='''hi,i am here!''' print(hi) # 返回結果： # hi, # i am here! hi # 'hi,ni am here!'

8.字符串內建函數

二、列表

1.創建列表

序列是Python中最基本的數據結構。序列中的每個元素都分配一個數字 - 它的位置，或索引，第一個索引是0，第二個索引是1，依此類推。

Python有6個序列的內置類型，但最常見的是列表和元組。序列都可以進行的操作包括索引，切片，加，乘，檢查成員。此外，Python已經內置確定序列的長度以及確定最大和最小的元素的方法。

列表是最常用的Python數據類型，它可以作為一個方括號內的逗號分隔值出現。列表的數據項不需要具有相同的類型

創建一個列表，只要把逗號分隔的不同的數據項使用方括號括起來即可。如下所示：

list1=['bldg','unit',23,(84,79)] print(list1) list2=['zjpg','case','all'] print(list2) list3=[25,87,46] print(list3) #返回結果 #['bldg', 'unit', 23, (84, 79)] #['zjpg', 'case', 'all'] #[25, 87, 46]

2.訪問列表中的值

使用下標索引來訪問列表中的值

print('list1[0]:',list1[0]) print('list2[1]:',list2[1]) print('list3[0:2]:',list3[0:2]) #返回結果 #list1[0]: bldg #list2[1]: case #list3[0:2]: [25, 87]

3.基本操作符

print(len(list1)) print(list1+list2) print(list2*3) print(46 in list3) # 4 # ['bldg', 23, (84, 79), 'one', 'zjpg', 'case', 'all'] # ['zjpg', 'case', 'all', 'zjpg', 'case', 'all', 'zjpg', 'case', 'all'] # True

4.列表截取

list2=list2*2 print(list2) print(list2[3]) print(list2[-2]) print(list2[1:5]) # ['zjpg', 'case', 'all', 'zjpg', 'case', 'all'] # zjpg # case # ['case', 'all', 'zjpg', 'case']

5.python列表常見函數

（1）cmp(list1,list2) 比較兩個列表的元素

如果比較的元素是同類型的,則比較其值,返回結果。

如果兩個元素不是同一種類型,則檢查它們是否是數字。

• 如果是數字,執行必要的數字強制類型轉換,然后比較。
• 如果有一方的元素是數字,則另一方的元素"大"(數字是"最小的")
• 否則,通過類型名字的字母順序進行比較。

如果有一個列表首先到達末尾,則另一個長一點的列表"大"。

如果我們用盡了兩個列表的元素而且所 有元素都是相等的,那么結果就是個平局,就是說返回一個 0。

list1, list2 = [123, 'xyz'], [456, 'abc'] print cmp(list1, list2) print cmp(list2, list1)list3 = list2 + [786] print cmp(list2, list3) # -1 # 1 # -1

（2）len(llist) 列表元素個數

（3）max(list) 返回列表元素最大值

（4）min(list) 返回列表元素最小值

（5）list(seq) 將元組轉化成列表

seq=(3,4,87,'abc') print(list(seq)) # [3, 4, 87, 'abc']

（6）list1.append() 追加和更改替換列表元素

#追加 list1.append('one') print(list1) #['bldg', 'unit', 23, (84, 79), 'one'] #更改替換 list3[2]='aaa' print(list3)#[25, 87, 'aaa']

（7）del list1、list1.pop() 刪除列表元素

del list1[1] print(list1) #['bldg', 23, (84, 79), 'one']

list.pop([index=-1]) 參數是要移除列表元素的索引值，不能超過列表總長度，默認為 index=-1，刪除最后一個列表值。

pop() 函數用于移除列表中的一個元素（默認最后一個元素），并且返回該元素的值。

print(list1) list1.pop() #默認參數為-1 print(list1) # ['bldg', 'unit', 23, (84, 79), 'one'] # ['bldg', 'unit', 23, (84, 79)] a=list1.pop(1) print(list1) print(a) # ['bldg', 23, (84, 79)] # 'unit'

（8）list.count() 統計某個元素在列表中出現的次數

aList = [123, 'xyz', 'zara', 'abc', 123] print ("Count for 123 : ", aList.count(123)) print ("Count for zara : ", aList.count('zara'))

（9）list.extend() 追加列表

該函數用于在列表末尾一次性追加另一個序列中的多個值（用新列表擴展原來的列表）

aList = [123, 'xyz', 'zara', 'abc', 123] bList = [2009, 'manni'] aList.extend(bList) print ("Extended List : ", aList) # Extended List : [123, 'xyz', 'zara', 'abc', 123, 2009, 'manni']

（10）list.index() 返回位置

函數用于從列表中找出某個值第一個匹配項的索引位置。該方法返回查找對象的索引位置，如果沒有找到對象則拋出異常。

aList = [123, 'xyz', 'zara', 'abc','xyz'] print ("Index for xyz : ", aList.index( 'xyz' )) print ("Index for zara : ", aList.index( 'zara' )) # Index for xyz : 1 # Index for zara : 2

（11）list.insert() 在指定位置插入指定對象

insert() 函數用于將指定對象插入列表的指定位置。

list.insert(index, obj) index是指定位置，obj是指定對象

aList = [123, 'xyz', 'zara', 'abc'] aList.insert( 3, 2009) print ("Final List : ", aList) # Final List : [123, 'xyz', 'zara', 2009, 'abc']

（12）list.remove() 移除元素

remove() 函數用于移除列表中某個值的第一個匹配項。該方法沒有返回值但是會移除列表中的某個值的第一個匹配項。

aList = [123, 'xyz', 'zara', 'abc', 'xyz'] aList.remove('xyz') print ("List : ", aList) aList.remove('abc') print ("List : ", aList) # List : [123, 'zara', 'abc', 'xyz'] # List : [123, 'zara', 'xyz']

（13）list.reverse() 反向排序列表元素

reverse() 函數用于反向排序列表中元素。該方法沒有返回值，但是會對列表的元素進行反向排序。

aList = [123, 'xyz', 'zara', 'abc', 'xyz'] aList.reverse() print ("List : ", aList) # List : ['xyz', 'abc', 'zara', 'xyz', 123]

（14）list.sort() 排序

sort() 函數用于對原列表進行排序，如果指定參數，則使用比較函數指定的比較函數。

list.sort(cmp=None, key=None, reverse=False) reverse=False默認升序，True降序。

該方法沒有返回值，但是會對列表的對象進行排序。

aList = ['123', 'Google', 'Runoob', 'Taobao', 'Facebook'] aList.sort() print ("List : ", aList) # List : ['123', 'Facebook', 'Google', 'Runoob', 'Taobao'] #降序 vowels = ['e', 'a', 'u', 'o', 'i'] vowels.sort(reverse=True) print ('降序輸出:', vowels) # 降序輸出: ['u', 'o', 'i', 'e', 'a'] #指定排序元素 def takeSecond(elem):return elem[1] random = [(2, 2), (3, 4), (4, 1), (1, 3)] random.sort(key=takeSecond) # 指定第二個元素排序 print ('排序列表：', random) # 排序列表： [(4, 1), (2, 2), (1, 3), (3, 4)]

（15）list.clear() 清除列表所有元素

ls = [1,2,3,"4",5,"a"] ls.clear() #刪除列表中的所有元素 print(ls.clear()) #無返回值 print(ls) #返回的ls為空列表 # None # []

（16）list.copy() 復制列表（淺層復制）

ls = [1,2,3,[4,5,6]] lt = ls.copy() #lt復制ls中的所有元素 ls.clear() #刪除ls所有元素，lt中的元素沒有被刪除 lk = ls #這不是復制，而是給列表ls新關聯一個引用，即增加一個別名，ls和lt指向同一個內存地址 print(id(ls),id(lk)) print(lt) print(ls) # 1820579702152 1820579702152 # [1, 2, 3, [4, 5, 6]] # []

無論是修改原列表ls的內嵌套列表的元素，還是修改復制列表lt的內嵌套列表元素。列表ls和列表lt的內嵌套列表元素都將改變。

但修改列表ls或列表lt的其它非嵌套元素，都不改變對方相應的元素。

ls = [1,2,3,[4,5,6]] lt = ls.copy() #lt復制ls中的所有元素 ls[0] = "a" #對變列表ls中的第一個元素進行修改 ls[3][0] = "a" #對列表ls中第四個元素的第一個元素進行修改 print(lt) #列表lt的第一個元素不變，但第四個元素的第一個元素發生改變 print(ls) # [1, 2, 3, ['a', 5, 6]] # ['a', 2, 3, ['a', 5, 6]]ls = [1,2,3,[4,5,6]] lt = ls.copy() lt[0] = "a" #對變列表lt中的第一個元素進行修改 lt[3][0] = "a" #對列表lt中第四個元素的第一個元素進行修改 print(lt) print(ls) #列表ls的第一個元素不變，但第四個元素的第一個元素發生改變 # ['a', 2, 3, ['a', 5, 6]] # [1, 2, 3, ['a', 5, 6]]

深層復制方法

import copy ls = [1,2,3,[7,"b",9],"a"] lt1 = copy.deepcopy(ls) #深層復制 lt2 = copy.copy(ls) #淺層復制 ls[3][1] = "abc123" #改變原列表ls中內嵌套列表[7,"b",9] 中的“b”元素。#深層復制的lt1列表對應位置元素不改變，但淺層復制改變。 print(ls) print("深層復制：",lt1) print("淺層復制：",lt2) # [1, 2, 3, [7, 'abc123', 9], 'a'] # 深層復制： [1, 2, 3, [7, 'b', 9], 'a'] # 淺層復制： [1, 2, 3, [7, 'abc123', 9], 'a']

三、元組

1.創建元組

Python的元組與列表類似，不同之處在于元組的元素不能修改。

元組使用小括號，列表使用方括號。

元組創建很簡單，只需要在括號中添加元素，并使用逗號隔開即可。

tup1=('Java','Python','R') tup2=(1,2,5,6,9) tup3='a','b','d' print(tup1) print(tup2) print(tup3) # ('Java', 'Python', 'R') # (1, 2, 5, 6, 9) # ('a', 'b', 'd')tup4=() tup5=(8,) #一個元素時需要加“，”，否則輸出不是元組 tup6=(8) print(tup4) print(tup5) print(tup6) # () # (8,) # 8

2.訪問元組

元組可以使用下標索引來訪問元組中的值。

tup1 = ('physics', 'chemistry', 1997, 2000) tup2 = (1, 2, 3, 4, 5, 6, 7 ) print ("tup1[0]: ", tup1[0]) print ("tup2[1:5]: ", tup2[1:5])# tup1[0]: physics # tup2[1:5]: (2, 3, 4, 5)

3.改變元組

元組中的元素值是不允許修改的，但我們可以對元組進行連接組合。

tup1 = (12, 34.56) tup2 = ('abc', 'xyz') # tup1[0] = 100，該操作不對 tup3 = tup1 + tup2 print (tup3) # (12, 34.56, 'abc', 'xyz')

4.刪除元組

元組中的元素值是不允許刪除的，但我們可以使用del語句來刪除整個元組。

#刪除tup后，tup不存在了 del tup

5.元組運算符

與字符串一樣，元組之間可以使用 + 號和 * 號進行運算。這就意味著他們可以組合和復制，運算后會生成一個新的元組。

6.元組索引、截取

因為元組也是一個序列，所以我們可以訪問元組中的指定位置的元素，也可以截取索引中的一段元素。

tup7=('java','python','mysql','r','oracle') print(tup7[1]) print(tup7[-1]) print(tup7[1:4]) # python # oracle # ('python', 'mysql', 'r')

7.無關閉分隔符

tup3='a','b','d' print(tup3) # ('a', 'b', 'd')

8.元組內置函數

總結

以上是生活随笔為你收集整理的python 字符串%和format_python基础任务二的全部內容，希望文章能夠幫你解決所遇到的問題。

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