基礎數據類型--字符串、列表、字典操做

1、字符串

字符串的索引
程序員數數從0開始

  字符串[索引]
  切片:
  字符串[start:end] 從start到end拿到數據. end取不到
  字符串[start:end:step] 從start到end拿數據. 每step個拿出來一個.
  step:
  + 左到右
  - 右到左

經常使用操做

字符串是一個不可變的數據類型
1. upper() 轉化成大寫. 在忽略大小寫的時候.

name = "aleX leNb"
print(name.upper())
-->ALEX LENB

#lower()轉化爲小寫

2. strip() 默認去掉左右兩端的空白

name = "aleX leNb"
print(name.upper())

3. replace() 字符串的替換

#將name變量對應的值中的第一個"l"替換成"p",並輸出結果
name = "aleX leNb"
print(name.replace("l","p",1))
-->apeX leNb

4. split() 字符串切割, 結果是列表

name = "aleX leNb"
print(name.split("l"))

5. startswith() 判斷是否以xxx開頭

#判斷 name 變量是否以 "al" 開頭,並輸出結果
name = "aleX leNb"
print(name.startswith("al"))

#endswith()判斷是否以xxx結尾

6. find() 查找字符串中xxx字符的位置. 若是找不到返回-1，index()找不到則報錯

name = "aleX leNb"
#找不到返回-1
print(name.find("N"))

#找不到則報錯
print(name.index("N"))

7. len() 字符串長度

name = "alex"
print(len(alex))
-->4

8.capitalize()將字符串首字母變爲大寫

name = "alex"
print(name.capitalize())
-->Alex

9.count()統計字符串中的x出現次數

#判斷name變量對應的值字母"l"出現幾回，並輸出結果
name = "alex lenb"
print(name.count("l"))
-->2

#若是判斷name變量對應的值前四位"l"出現幾回,並輸出結果
name = "alex lenb"
print(name.count("l",0,3))
-->1

 

2、列表

list - > 裝數據的
列表使用[]表示
[]
列表也有索引和切片

增刪改查(重點)
增長:
1. append() 追加, 添加在列表的末尾
2. insert() 插入, 在xxxx位置插入一個元素
3. extend() 迭代新增.合併列表

str = "alex"
lst1 = [1,2,3]
lst2 = [a,b,c]
lst2.extend(lst1)
lst2.extend(str)

刪除:
1. pop() 刪除. 指定索引刪除
2. remove() 刪除某個指定元素
3. del list[1:4]
4. clear() 清空列表
5. reverse()將列表全部的元素反轉 

修改:
使用索引去修改

查詢:
直接用索引查找.
使用for循環能夠遍歷列表

綜合：

須要記憶的魔法有：append（追加），extend（擴展），insert（插入）

append　　原來值最後追加，數字，字符，列表均可以進行追加
    li = [6,8,7,5,8]
    li.append(2)                # 追加再最後 原來值再後面追加，所以不用賦予新的值
    print(li)
    　　  
clear　　   清空列表
    li = [6,8,7,5,8]
    li.clear()                  # 清空列表
    print(li)
    　　  
copy　　　拷貝（淺拷貝）
    li = [6,8,7,5,8]
    v = li.copy()               # 拷貝，淺拷貝
    print(li)

count　　  計數（計算元素出現的次數）
    li = [6,8,7,5,8]
    v = li.count(8)             # 計算元素出現的次數
    print(v)

extend　　擴展原列表，參數可迭代對象（數字不能擴展，數字不可迭代）
    li = [6,8,7,5,8]
    li.extend("b")              # 擴展追加。
    print(li)

index　　　根據值獲取值的指引位置
    li = [6,8,7,5,8]
    v = li.index(8)             # 根據值獲取值的索引位置
    print(v)<br><br>1　　　　　　　　　　　　　　　  重複字符，獲取最左邊位置，便再也不尋找

insert　　　插入，也能夠根據指引位置插入元素
    li = [6,8,7,5,8]
    li.insert(2,"b")　　　　　　　# 前面參數指定索引，逗號分隔，加要插入的元素
    print(li)

pop　　　　可索引刪除某個值，無索引則默認刪除最後一個值，賦予一個值也能夠得到被刪除的值
    li = [6,8,7,5,8]
    v = li.pop(2)               # 指定索引刪除，無索引則默認刪除最後一個值，也能夠獲取刪除的值
    print(li)
    print(v)

remove　　刪除列表指定值，左邊優先
    li = [6,8,7,5,8]
    li.remove(8)                # 刪除列表指定值，從左優先
    print(li)

reverse　　將當前列表進行反轉
    li = [6,8,7,5,8]
    li.reverse()                # 將當前列表進行反轉
    print(li)

sort　　　　排序，有秩序的排序。
    li = [6,8,7,5,8]
    li.sort(reverse=True)    　　# 當反轉正確，則從大到小排序
    print(li)
　　#reverse = True爲降序,  reverse = False爲升序(默認)

join　　把列表中每一項拼接起來

s = "_sb_".join(["alex", "太白", "太黑", "太綠"])
print(s)
-->alex_sb_太白_sb_太黑_sb_太綠

 

3、元組(tuple): 不可變的列表, 只讀列表

放一些不進行修改的數據
元組用()表示.
空元組必須用tuple()來建立

len(tuple)  計算元祖個數

max(tuple)  返回元祖中元素最大值

min(tuple)  返回元祖中元素最小值

tuple(seq)  將列表轉換爲元祖

小知識點: 若是元組只有一個元素. 必須在末尾添加一個逗號

 

4、字典

在存儲數據的時候必須使用key:value的形式進行存儲,
key不能夠重複.
而且要求key必須可哈希-> 不可變(int, str, tuple, bool, float)
value沒有要求

字典的增刪改查:
新增:
1. 直接用新key添加

dic = {}
dic["消防員"] = "值得敬佩的人"
#key不能夠重複，會把數據覆蓋掉

2.

 setdefault(key, value) 若是key存在, 不新增. 不存在, 新增. 最後都查詢

刪除:

1. pop(key) 指定key刪除
2. popitem() 刪除最後一個.
3. del dic[key]
4. clear()

修改:

dic[老key] = 新value

查詢:

get(key) 使用key獲取value
dic[key] 查詢, 若是key不存在. 會報錯

循環:

for k in dict:
直接拿到key
dict[k]

for v in dict.values(): 直接拿value for k in dict.keys(): 直接拿到key dict[k] for k, v in dict.items(): 直接拿到key, value

1   dict.clear()
刪除字典內全部元素

2 dict.copy() 返回一個字典的淺複製 3 dict.fromkeys() 建立一個新字典，以序列seq中元素作字典的鍵，val爲字典全部鍵對應的初始值 print(dict.fromkeys('2', 4)) 結果爲 {'2': 4} 注意: 整數不能做爲Key 4 dict.get(key, default=None) 返回指定鍵的值，若是值不在字典中返回default值 5 key in dict 若是鍵在字典dict裏返回true，不然返回false 6 dict.items() 以列表返回可遍歷的(鍵, 值) 元組數組 7 dict.keys() 以列表返回一個字典全部的鍵 8 dict.setdefault(key, default=None) 和get()相似, 但若是鍵不存在於字典中，將會添加鍵並將值設爲default 9 dict.update({'k1':'v1'} OR k1=v1) 把字典dict2的鍵/值對更新到dict裏 10 dict.values() 以列表返回字典中的全部值 11 dict.popitem() 隨機刪除，並獲取刪除的鍵值以元組形式返回

5、集合set

基本數據類型特色（可變：列表，字典 　　不可變：字符串，數字，元組）

不一樣的元素組成

無序

集合中的元素必須是不可變類型，加入可變的類型會報錯==

student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
 
print(student)   # 輸出集合，重複的元素被自動去掉

# 成員測試
if('Rose' in student) :
    print('Rose 在集合中')
else :
    print('Rose 不在集合中')


# set能夠進行集合運算
a = set('abracadabra')
b = set('alacazam')
 
print(a)
 
print(a - b)     # a和b的差集
 
print(a | b)     # a和b的並集
 
print(a & b)     # a和b的交集
 
print(a ^ b)     # a和b中不一樣時存在的元素

set的方法

A、add　　添加，添加可變的數據類型也是會報錯的

s = {1,2,5,5,'g','h'}
s.add(3)
print(s)

執行結果

{1, 2, 3, 5, 'h', 'g'}

B、clear　 清空集合

C、intersection　　交集，至關於&

s = {1,7,9}
s1 = {1,9,5}
print(s&s1)
print(s.intersection(s1))
 
{9, 1}
{9, 1}

D、union　　並集，至關於 |

s = {1,7,9}
s1 = {1,9,5}
print(s|s1)
print(s.union(s1))<br><br>{1,5,7,9}<br>{1,5,7,9}

E、difference　　差集，至關於-

s = {1,7,9}
s1 = {1,9,5}
print(s-s1)
print(s.difference(s1))
 
{7}
{7}

F、symmetric_difference　　交叉補集，至關於^

s = {1,7,9}
s1 = {1,9,5}
print(s^s1)
print(s.symmetric_difference(s1))
 
{5, 7}
{5, 7}

G、difference-update　　 差集更新

H、isdisjoint　　　　　　 判斷是否有交集

I、issubset　　　　　　　 判斷是否爲子集

s1={1,2}
s2={1,2,3}
print(s1.issubset(s2))
print(s2.issubset(s1))
 
True
False

J、issuperset　　　　　　 判斷是否爲父集

s1={1,2}
s2={1,2,3}
print(s2.issuperset(s1))
 
True

k、update　　更新多個值，可迭代均可傳

L、pop,remove,discard　　均爲刪除

s = {9, 'sb', 1, 2, 3, 4, 5, 6}
s.pop()                           # pop不能指定刪除，只能夠隨機刪除
print(s)
s = {9, 'sb', 1, 2, 3, 4, 5, 6}  # 指定刪除元素，當刪除的元素不存在時，刪除會報錯
s.remove(4)
print(s)
s = {9, 'sb', 1, 2, 3, 4, 5, 6}
s.discard(5)
print(s)                          # 指定元素刪除；和remove惟一的區別刪除不存在不會報錯