python3學習筆記--python中的數據類型彙總。

Python3 中的數據類型：
Number（數值）、String（字符串）、List（列表）、Tuple（元組）、Sets（集合）、Dictionary（字典）

不可變數據：Number（數值）、String（字符串）、Tuple（元組）；
可變數據：List（列表）、Dictionary（字典）、Set（集合）。

一.數值型Number

1.int

通常被稱爲是整型或整數，是正或負整數，不帶小數點。Python3 整型是沒有限制大小的，可以當作 Long 類型使用，所以 Python3 沒有 Python2 的 Long 類型

2.float

浮點型數值用於保存帶小數點的數值，Python 的浮點數有兩種表示形式

十進制形式：這種形式就是平常簡單的浮點數，例如 5.12、512.0、0.512。浮點數必須包含一個小數點，否則會被當成整數類型處理
科學計數形式：例如 5.12e2（即 5.12×10^2）、5.12E2（也是 5.12 ×10^2）

a = 100
print(type(a),a)
b = 100.1
b1 = 10e2
print(type(b),b)
print(type(b1),b1)
結果：
<class 'int'> 100
<class 'float'> 100.1
<class 'float'> 1000.0

3.complex

複數是由實數部分和虛數部分組成，一般的形式爲x+yj，其中的X 是複數的實數部分，y是複數的虛數部分，複數的實部x和虛部y都是浮點型。

4.數據類型轉換

int(x)：將x轉換爲一個整數。
float(x) ：將x轉換到一個浮點數。
complex(x) ：將x轉換到一個複數，實數部分爲 x，虛數部分爲 0。
complex(x, y) ：將 x 和 y 轉換到一個複數，實數部分爲 x，虛數部分爲 y。x 和 y 是數字表達式。

二.字符串str

創建字符串可以使用單引號、雙引號、三單引號和三雙引號，其中三引號可以多行定義字符串，Python 不支持單字符類型，單字符也在Python也是作爲一個字符串使用

對字符串進行操作,字符串的方法。

1. 字符串切片

a ="abcdefg"
print(a,type(a))   #查看a的類型
print(a[1])      #取a的第一個元素
print(a[2:3])    #取a的第2個元素
print(a[0:3])   #字符串切片，取頭不取尾，012
print(a[1:])    #除過第0個其他都取
print(a[:])     #全取
print(a[:-1])    #最後一個不取，0到-1
print(a[2:5:2])  #234每兩個取一個，2和4
print(a[-1:-6:2])  #-1-2-3-4-5每兩個取一個
print(a*3)                 #字符串重複操作，a輸出三次

結果：
abcdefg <class 'str'>
b
c
abc
bcdefg
abcdefg
abcdef
ce
abcdefgabcdefgabcdefg

2. 字符串統計

name = "zhangsan"

print(name.count("a"))     #統計字母a個數
結果：2

3. 判斷

name = "zhangsan"
print(name.endswith("x"))      #判斷字符串結尾字符
False
print("123".isdigit())    #判斷字符串123是否爲數字
True
print("wq123q".isalnum())  #判斷字符串wq123q是否爲數字字母組合
True
print("wql".isalpha())    #判斷字符串是否爲字母
True
print("111".isdecimal())  #判斷字符串是否爲十進制
True
print(name.isidentifier()) #判斷是否爲合法的標識符
False
print("abc".islower()) #判斷是否爲小寫字母
True
print("Abc".istitle())         #判斷首字母是否大寫
True
print("123".isprintable())   #判斷字符串是否可打印，tty File OR driver File
True
print(" ".isspace()) #判斷是否爲空格
True
print("www.baidu.com".startswith("www")) #判斷以是否以www前綴開始

4. 拼接

a = "abc"
b = "def"
print(a+b)                  #字符串拼接，ab類型必須相同
# 若 b = 666666 則 print(a+str(b))  # 轉換b爲字符串
結果：
abcdef

5. 對字符串操作後輸出

name = "zhangsan"
print(name.capitalize()) #將字符串首字母大寫
Zhangsan

print(name.center(50,"-")) #將字符串格式化居中輸出
---------------------zhangsan---------------------

print("abc".ljust(10,"+"))   #輸出十個字節，空出的用+右邊補齊
abc+++++++
print("abc".rjust(10,"+"))  #輸出十個字符，空出來的+左邊補齊
+++++++abc

print("   ABC".lstrip())   #左邊空格不輸出
print("ABC     ".rstrip())  #右邊空格不輸出
print("   ABC   ".strip())  #中間空格不輸出
ABC
ABC
ABC
print(name.format(name="anliu",yunwei="linux")) #格式化輸出
print(name.format_map({"name":"anliu","yunwei":"linux"}))  #字典的方式格式輸出

6. 轉換

print('hello'.upper())  #轉換爲大寫
print('HELLO'.lower())  #轉換爲小寫
print('hello world'.title())  #將字串符當中的單詞首字母大寫，單詞以非字母劃分
print("anliu".replace("a","A"))  #替代，A替代a
print("abc".swapcase())          #大小寫相互轉化

7. 索引

name = "zhangsan"
print(name.index("a")) #獲取索引a,在第幾個位置
print(name.find("a"))  #獲取索引
2
2

詳細內容：字符串知識點歸納

三.列表list

列表用 [ ]標識，是 python 最通用的複合數據類型
在 Python 中，最基本的數據結構是序列（列表和元組），序列中的每個元素都有一個序號（元素的具體位置），這個序號叫索引，索引下標從0開始，以此類推…

對列表進行操作，列表的方法。

1. 切片

Weekday = ['Monday','Tuesday','Wednesday','Thursday','Friday']
print(Weekday)
print(Weekday[0])      # 輸出 Monday
print(Weekday[1:3])
print(Weekday[2:])
結果：
['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
Monday
['Tuesday', 'Wednesday']
['Wednesday', 'Thursday', 'Friday']

2. 拼接和重複操作(+,*)

加號 + 是列表連接運算符，星號 * 是重複操作。

list = [1,2,3,4,5,6,7]
Weekday = ['Monday','Tuesday','Wednesday','Thursday','Friday']
print(Weekday+list)
print(list*2)
結果：
['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 1, 2, 3, 4, 5, 6, 7]
[1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7]

3. index 索引

index 方法：用於從列表中找出某個元素第一次匹配的位置的索引位置

Weekday = ['Monday','Tuesday','Wednesday','Thursday','Friday']
print(Weekday.index("Monday"))

結果：
0

4. count 統計

count方法：統計某個元素在列表中出現的次數

Weekday = ['Monday','Tuesday','Wednesday','Thursday','Friday']
print(Weekday.count("Friday"))           #Friday出現了幾次
結果：
1

5. 增加(append,instert,extend)

append:在列表末尾添加元素

list = [1,2,3,4,5,6,7]
list.append("加油")
print(list)

>>[1, 2, 3, 4, 5, 6, 7, '加油']

insert ：在列表中指定位置插入元素

list = [1,2,3,4,5,6,7]
list.insert(1,'加油')
print(list)

>>[1, '加油', 2, 3, 4, 5, 6, 7, '加油']

extend(合併)：表示追加內容，它可以在列表的末尾一次性追加另一個序列中的多個值，也就是用新列表擴展原有列表

list = [1,2,3,4,5,6,7]
list2 = ['加油','加油']
list.extend(list2)
print(list)

>>[1, 2, 3, 4, 5, 6, 7, '加油', '加油']

6. 刪除(del,pop,remove)

del：刪除表中元素

list = [1,2,3,4,5,6,7]
del list[2]    #刪除第三個元素
print(list)

>>[1, 2, 4, 5, 6, 7]

pop：移除列表中的一個元素（默認是最後一個），並且返回該元素的值
- pop 和 append 方法是 Python 中數據結構的出棧和入棧，如果追加（append）剛剛出棧（pop）的值，得到的還是原來的列表

list = [1,2,3,4,5,6,7]
list.pop()
print(list)

>>[1, 2, 3, 4, 5, 6]

remove：用於移除列表中第一個匹配的元素

Weekday = ['Monday','Tuesday','Wednesday','Thursday','Friday']
Weekday.remove('Friday')
print(Weekday)

>>['Monday', 'Tuesday', 'Wednesday', 'Thursday']

7.修改或替換

Weekday = ['Monday','Tuesday','Wednesday','Thursday','Friday']
Weekday[1] = '星期二'
print(Weekday)

>>['Monday', '星期二', 'Wednesday', 'Thursday', 'Friday']

8.反轉操作 reverse

reverse：將列表中的元素進行反轉操作

list = [1,2,3,4,5,6,7]
list.reverse()
print(list)

>>[7, 6, 5, 4, 3, 2, 1]

9.排序 sort

sort：在原位置排序，‘原位置排序’意味着改變原來的列表而讓列表中的元素有順序排列

list2 = [3,6,3,9,1,12,33]
list2.sort()
print(list2)

>>[1, 3, 3, 6, 9, 12, 33]

10.清空列表 clean

clear

list2 = [3,6,3,9,1,12,33]
print(list2)
list2.clear()
print(list2)

>>[3, 6, 3, 9, 1, 12, 33]
[]

11.複製copy

names = ["zhangsan","lisi",["wanger","xx"],"lisi"]
names.copy()
name = names.copy()
print(names.copy())
print(name)

>>['zhangsan', 'lisi', ['wanger', 'xx'], 'lisi']
['zhangsan', 'lisi', ['wanger', 'xx'], 'lisi']

12.遍歷

names = ["zhangsan","lisi",["wanger","xx"],"lisi"]
for i in names:
    print(i)

>>zhangsan
lisi
['wanger', 'xx']
lisi

四.字典dictionary

字典(dictionary)是除列表以外python之中最靈活的內置數據結構類型。列表是有序的對象集合，字典是無序的對象集合。
兩者之間的區別在於：字典當中的元素是通過鍵來存取的，而不是通過偏移存取。
字典用"{ }"標識。字典由索引(key)和它對應的值value組成,字典是一種映射類型，它的元素是鍵值，字典的關鍵字必須爲不可變類型，且不能重複
字典的每個鍵值 key=>value 對用冒號 : 分割，每個鍵值對之間用逗號 , 分割，整個字典包括在花括號 {} 中

示例：

dict = {'name': 'john', 'code': 6734, 'dept': 'sales'}
print(dict['code'])      #輸出鍵爲code的值
print(dict)               # 輸出完整的字典
print(dict.keys())         # 輸出所有鍵
print(dict.values())       # 輸出所有值

>>
6734
{'name': 'john', 'code': 6734, 'dept': 'sales'}
dict_keys(['name', 'code', 'dept'])
dict_values(['john', 6734, 'sales'])

特性：鍵一般是唯一的，如果鍵重複，最後的一個鍵值對會替換前面的鍵值對，值沒有唯一性要求

dict = {'name': 'john', 'code': 6734, 'dept': 'sales','name':'zhangsan'}
print(dict)
print(dict['name'])

>>
{'name': 'zhangsan', 'code': 6734, 'dept': 'sales'}
zhangsan                                  #name的值取最後一個

修改字典元素

添加

dict = {'name': 'john', 'code': 6734, 'dept': 'sales'}
dict['from'] = 'china'
print(dict)

>>
{'name': 'john', 'code': 6734, 'dept': 'sales', 'from': 'china'}

刪除

dict.clear()

刪除字典內所有元素，clear() 方法沒有任何返回值，和del一樣

dict = {'name': 'john', 'code': 6734, 'dept': 'sales'}
dict.clear()                       # 刪除字典內所有元素
print(dict)
>>{}

del dic

dict.pop(key[,default])

Python 字典 pop() 方法刪除字典給定鍵 key 所對應的值，返回值爲被刪除的值。key值必須給出。否則，返回default值

pop(key[,default])
#參數key: 要刪除的鍵值default: 如果沒有 key，返回 default 值
# 返回值返回被刪除的值。

dic_new = dict.pop('name')
print(dict)
>>
{'code': 6734, 'dept': 'sales'}

更改

dict = {'name': 'john', 'age':'12','code': 6734, 'dept': 'sales'}
dict['age'] = 20
print(dict)

>>{'name': 'john', 'age': 20, 'code': 6734, 'dept': 'sales'}

複製copy

深copy

dict1 對父對象進行了深拷貝，深拷貝不會隨dict 修改而修改

dict = {'name': 'john', 'age':'12','code': 6734, 'dept': 'sales'}
dict1 = dict.copy()
print(dict1)

>>{'name': 'john', 'age':'12','code': 6734, 'dept': 'sales'}

淺copy:引用對象賦值

dict2 其實是 dict的引用，即別名，所以輸出結果都是一致的

dict = {'name': 'john', 'age':'12','code': 6734, 'dept': 'sales'}
dict2 = dict
print(dict2)
>>{'name': 'john', 'age':'12','code': 6734, 'dept': 'sales'}

子對象是淺拷貝,所以隨 dict 的修改而修改，即賦值會隨父對象的修改而修改，拷貝不會隨父對象的修改而修改。

總結

dict = {'name': 'john', 'age':'12','num':[1,2,3,4]}
dict1 = dict                    #淺copy
dict2 = dict.copy()              #深copy
dict['age'] = '20'           #修改age
dict1['num'].remove(1)        #移除num中元素
print(dict)
print(dict1)
print(dict2)
>>
{'name': 'john', 'age': '20', 'num': [2, 3, 4]}
{'name': 'john', 'age': '20', 'num': [2, 3, 4]}
{'name': 'john', 'age': '12', 'num': [2, 3, 4]}

五.元祖

元組類似於list，用 () 標識。內部元素用逗號隔開。
元組不能二次賦值，相當於只讀列表

tuple = ('wang','li','zhao',17,18,19)
tuple2 = ('hello','thank you ')
print(tuple)         #輸出元祖
print(tuple[2])          #輸出第二個元素
print(tuple[2:4])       #輸出第2和三個
print(tuple*2)            #元祖輸出兩次
print(tuple+tuple2)   #元祖拼接

>>結果
('wang', 'li', 'zhao', 17, 18, 19)
zhao
('zhao', 17)
('wang', 'li', 'zhao', 17, 18, 19, 'wang', 'li', 'zhao', 17, 18, 19)
('wang', 'li', 'zhao', 17, 18, 19, 'hello', 'thank you ')

六.集合

集合是一個無序的，不重複的數據集合，可以使用大括號 { } 或者 set() 函數創建集合
創建一個空集合必須用 set() 而不是 { }，因爲 { } 是用來創建一個空字典

#去重，將列表轉換爲集合就自動去重
list = [1,2,3,4,1,2]
list_1 = set(list)
print(list_1,type(list_1))

>>
{1, 2, 3, 4} <class 'set'>

集合關係

test1 = set([1,2,5,8,23,51])
test2 = set([2,4,7,26,45])
print(test1)
print(test2)

>>
{1, 2, 5, 8, 51, 23}
{2, 4, 7, 45, 26}

#求交集
print(test1.intersection(test2))
#求並集
print(test1.union(test2))
#求差集
print(test1.difference(test2))
#求子集
print(test1.issubset(test2))
#求父集
print(test1.issuperset(test2))
#對稱差集
print(test1.symmetric_difference(test2))
#判斷是否有交集，有則爲錯，不爲真
print(test1.isdisjoint(test2))

>>
{2}
{1, 2, 4, 5, 7, 8, 45, 51, 23, 26}
{1, 5, 8, 51, 23}
False
False
{1, 4, 5, 7, 8, 23, 26, 45, 51}
False

集合的相關操作

添加

test1 = set([1,2,5,8,23,51])
test2 = set([2,4,7,26,45])
test1.add(100)
print(test1)
test1.update([250,500])
print(test1)

>>
{1, 2, 100, 5, 8, 51, 23}
{1, 2, 100, 5, 8, 51, 500, 23, 250}

刪除

test1 = set([1,2,5,8,23,51])
test1.remove(2)
print(test1)

>>
{1, 5, 8, 51, 23}

其他

#取長度
test1 = set([1,2,5,8,23,51])
print(len(test1))

>>
6

#判斷元素是否在集合中
test1 = set([1,2,5,8,23,51])
print(23 in test1)
print(2 not in  test1)

>>

True
False