Python基本數(shù)據(jù)類型

• 數(shù)字
• 組

數(shù)字

分為整型、浮點型、布爾型、復數(shù)

1. 整型(int)
2. 浮點型(float)
3. 布爾型(bool)
4. 復數(shù)(complex)

組

1. 序列

• 字符串(str)
• 列表(list)
• 元組(tuple)

2. 集合(set)
3. 字典(dict)

數(shù)字（Number）

• 整型(int)、浮點型(float)

1
type(1)
-1
type(-1)
type(1.1)
type(1.11111111111111111111111111111111)
1+0.1
type(1+0.1)
type(1+1)
type(1+1.0)
type(1*1)
type(1*1.0)
type(2/2)
type(2//2)
1//2

• 進制（十進制、二進制、八進制、十六進制）

1. 如何進位
   逢十進一、 逢二進一、 逢八進一、 逢十六進一
2. 進制表示
   二進制: 0b開頭
   八進制: 0o開頭
   十六進制:0x開頭
3. 案例

0b10
0b11
0o10
0o11
0x10

#轉二進制
print(bin(10))
print(bin(0o7))
print(bin(0xE))
#轉八進制
print(oct(0b111))
print(oct(0x777))
#轉十進制
print(int(0b10))
print(int(0o77))
#轉十六進制
print(hex(888))
print(hex(0o777))

2. 其他進制
   比如60s=1minute

• 布爾型(bool)
  bool類型表示真假。

True
False
type(True)
type(False)
int(True)
int(False)
bool(1)
bool(0)

#非0代表True,0假
bool(2.2)
bool(0b01)
bool(0b0)
#其他類型也可以轉bool
bool("abc")
bool("")
bool([1,2,3])
bool([])
bool({1,2,3})
bool({})
bool(None)

結論:除了0表示False外，其他類型的空值也為False

• 復數(shù)(complex)
  數(shù)字后加j

36j

組

現(xiàn)實中總是存在一組一組的事物。

1. 序列

• 字符串(str)

宣室求賢訪逐臣，賈生才調更無倫。
可憐夜半虛前席，不問蒼生問鬼神。

字符串是由獨立字符組成的一個序列，通常包含在單引號（''）雙引號（"")）或者三引號之中（''' ''' 或""" """)

'helloworld'
"let's go"
"""hello
world
"""

單引號換行

print("hello\nworld\n")
print('hello \
      world')

轉義字符
特殊字符
無法"看見"的字符
與語言本身語法有沖突的字符
常見的轉義字符
\n 換行
\' 單引號
\t 橫向制表符
\r 回車

思考：print("c\nworld\ntesd")打印: 兩行，現(xiàn)在想打印一行即 c\nworld\ntesd如何實現(xiàn)？
答案見末尾。

1）字符串合并

"hello"+"world"
"hello"*3

2）字符串替換

"hello".replace('h','w') ->wello

3）獲取單個字符
通過索引獲取

'hello'[0] ->h
'hello'[-1] ->o

【-n】:從字符串末尾，往前數(shù)n次，獲取字符
4）字符串切片
切片 ,左閉右開 [)

"helloworld"[0:4]->hell
"helloworld"[0:-1]->helloworl
#獲取world
"helloworld"[5:] -> world

"hello python java javascript ruby go" 僅獲取go

"hello python java javascript ruby go" [-2:]

5）字符串格式化
format()

print('name={}age={}'.format("張三",20))
print('name={0}age={1}'.format("張三",20))
print('name={name}age={age}'.format(age=20,name='張三'))

6）查找元素find ，index
通過元素找索引找到第一個就返回，找不到返回-1

a="javascript"
print(a.find('a')) # 1
print(a.find('m')) # -1
print(a.index('v'))# 2

7）split 把字符串分割成列表

s = 'java python go'
s1 = 'java;x python;sir bar;ryy'

print(s.split()) #['java', 'python', 'go']
print(s1.split(";"))# ['java', 'x python', 'sir bar', 'ryy']

8）join()
join將序列中的元素以指定的字符連接生成一個新的字符串

s = 'alex' ####看成字符列表
li = ['aa', 'ddj', 'kk']    #### 必須全是字符串
s1 = '_'.join(s)
print(s1)
s2 = ' '.join(li)
print(s2)

• 列表(list)
  1）列表概念
  實際上，列表和元組，都是一個可以放置任意數(shù)據(jù)類型的有序集合
  2）列表的創(chuàng)建
  []表示空列表

[1,2,3]

使用list()函數(shù)將元組、range對象、字符串或其他類型的可迭代對象類型的數(shù)據(jù)轉換為列表

list("abc") 
['a', 'b', 'c']

3）在絕大多數(shù)編程語言中，集合的數(shù)據(jù)類型必須一致。不過，對于 Python 的列表和元組來說，并無此要求：

l = [1, 2, 'hello', 'world'] # 列表中同時含有 int 和 string 類型的元素
l
[1, 2, 'hello', 'world']

tup = ('jason', 22) # 元組中同時含有 int 和 string 類型的元素
tup
('jason', 22)

列表的元素還可以是列表，稱為嵌套列表

[[1,2],[3,4],[True,False]]

2,列表操作
2.1 列表增加

• 列表元素添加-append()
  向列表尾部追加一個元素，不改變其內存首地址，屬于原地操作。 例如：

x = [1，2，3]
x.append(4)
x
[1,2,3,4]

• 列表元素添加-insert()
  向列表任意位置插入一個元素，不改變其內存首地址，屬于原地操作。

x = [1,3,4]
x.insert(1,2)
x
[1,2,3,4]

• 列表元素添加-extend()
  將另一個迭代對象的所有元素添加至該列表對象尾部，不改變其內存首地址，屬于原地操作。

x = [1,2]
x.extend([3,4])
x
[1,2,3,4]

2.2運算符"+"和*
并不是真的為列表添加元素，而是創(chuàng)建一個新列表,不屬于原地操作，而是返回新列表。

• 列表加法

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

• 列表乘法

x=[1,2,3]
y=x*3
y
[1,2,3,1,2,3,1,2,3]

此時x保持不變，依舊是[1,2,3]

[1,2,3][0] ->1
[1,2,3][0:2]-> [1,2]
[1,2,3][-1:]->[3]  注意：結果是列表 

2.3列表元素刪除

• pop()
  使用列表的pop()方法刪除并返回指定（默認為最后一個）位置上的元素，如果給定的索引超出了列表的范圍則拋出異常。

x = [1,2,3,4]
x.pop()   #彈出并返回尾部元素
x.pop(1) #彈出并返回指定位置的元素
2

• remove()
  刪除首次出現(xiàn)的指定元素，如果列表中不存在要刪除的元素，則拋出異常。

x = [1,2,2,3,4]
x.remove(2)
x
[1,2,3,4]

• clear()
  清空列表

x = [1,2,3,4]
x.clear()
x
[ ]

• del()
  刪除列表中的指定位置上的元素。

x = [1,2,3,4]
del x[1]
x
[1,3,4]

2.4列表中常用內置函數(shù)

• len()
  返回列表中的元素個數(shù)，同樣適用于元組、字典、集合、字符串等。

• max()、 min()
  返回列表中的最大或最小元素，同樣適用于元組、字典、集合、range對象等。

• sum()
  對列表的元素進行求和運算。

• zip()
  返回可迭代的zip對象。

• enumerate()
  枚舉列表元素，返回枚舉對象，其中每個元素為包含下標和值的元組。該函數(shù)對元組、字符串同樣有效。

for item in enumerate('abcdef'):
print(item)
(0, 'a')
(1, 'b')
(2, 'c')
(3, 'd')
(4, 'e')
 (5, 'f')

2.5遍歷列表的三種方式

a = ['a','b','c','d','e','f']
for i in a:
    print(i)

for i in range(len(a)):
    print(i,a[i])
for i,ele in enumerate(a):
    print(i,ele)

• 元組(tuple)
  元組屬于不可變序列，一旦創(chuàng)建，用任何方法都不可以修改其元素。從形式上，元組的所有元素放在一對圓括號中，元素之間用逗號分隔。

1）元組的創(chuàng)建

(1,2,3,4,5)
(1,2,3,4,5)[0]
(1,2,3,4,5)[0:]
(1,2,3,4,5)+(6,7) 
 (1,2,3,4,5,6,7)
(1,2,3)*3
（1,2,3,1,2,3,1,2,3）

思考題:
type((1)) ，type(('helo'))，結果是？為什么？

原因; （）既可以表示數(shù)學運算，也表示了元組，在這個例子中，編譯器不知道()表示什么，就按照數(shù)學運算表示了。
那么，如何定義只有一個元素的元組呢？

(1，)
type((1,))->tuple

2) 使用tuple函數(shù)將其他序列轉換為元組

tuple("abc")
('a', 'b', 'c')

3)元組的優(yōu)點

• 元組的速度比列表更快。
• 元組對不需要改變的數(shù)據(jù)進行“寫保護”將使得代碼更加安全。
• 元組可用作字典鍵（特別是包含字符串、數(shù)值和其它元組這樣的不可變數(shù)據(jù)的元組）。元組有時還作為函數(shù)的返回值返回（返回多個值）。

總結：
1). 實際上，列表和元組，都是一個可以放置任意數(shù)據(jù)類型的有序集合
2). 列表是動態(tài)的，長度大小不固定，可以隨意地增加、刪減或者改變元素（mutable）。而元組是靜態(tài)的，長度大小固定，無法增加刪減或者改變（immutable）。

a=[1,2,3]
a.append(4)

3.增加元素，列表用append（)而元組只能創(chuàng)建新的元組。
4）str list tuple都是序列；

序列特點：
1）都可以通過索引訪問
2)都具有切片功能

"helloworld"[0:8:2]

3)in關鍵字判斷元素是否在序列中

3 in [1,2,3,4] ->True
3 not in [1,2,3] -> False

4)序列長度、最大值、最小值

len([1,2,3]) ->3
max([1,2,5])->5
min([1,2,5])->1

ASCII碼值：

ord('a')

列表和元組常用方法

l = [3, 2, 3, 7, 8, 1]
l.count(3) 
l.index(7)
l.reverse()
l.sort()

tup = (3, 2, 3, 7, 8, 1)
tup.count(3)
tup.index(7)
list(reversed(tup))
sorted(tup)

count(item) 表示統(tǒng)計列表 / 元組中 item 出現(xiàn)的次數(shù)。
index(item) 表示返回列表 / 元組中 item 第一次出現(xiàn)的索引。
list.reverse() 和 list.sort() 分別表示原地倒轉列表和排序（注意，元組沒有內置的這兩個函數(shù))。
reversed()和 sorted() 同樣表示對列表 / 元組進行倒轉和排序，但是會返回一個倒轉后或者排好序的新的列表 / 元組。

2. 集合(set)
   1）集合的定義
   集合是無序可變序列，使用一對大括號界定，元素不可重復，同一個集合中每個元素都是唯一的。集合中只能包含數(shù)字、字符串、元組等不可變類型的數(shù)據(jù)，而不能包含列表、字典、集合等可變類型的數(shù)據(jù)。
   2）集合的創(chuàng)建

{}
{1,2,3}

定義空集合

{} 
set()

3）集合元素的增加與刪除

• 增加元素
  使用add()方法為集合添加新元素，如果該元素已存在于集合中則忽略該操作。

s = {1,2,3}
s.add(3)
s
{1,2,3}

使用update()方法合并另外一個集合中的元素到當前集合中

s = {1,2,3}
s.update({3,4,5})
s
{1,2,3,4,5}

• 刪除元素
  當不再使用某個集合時，可以使用del命令刪除整個集合。集合對象的pop()方法彈出并刪除其中一個元素，remove()方法直接刪除指定元素，clear()方法清空集合。

 a = {1, 4, 2, 3}
 a.pop()
1
 a.pop()
2
a
{3, 4}
 a.add(2)
 a
{2, 3, 4}
 a.remove(3)
 a
{2, 4}

4)集合操作
移除集合中的元素, "-"號求差集

{1,2,3,4} -{3,4} ->{1,2}

求交集

{1,2,3,4} & {3,4} ->{3,4}

求并集

{1,2,3,4} | {3,4} ->{1,2,3,4}

tip
集合無法通過下標和切片訪問

s={1,2,3}
print(s[0])

Traceback (most recent call last):
  File "C:/Users/Administrator/Desktop/movie/core.py", line 4, in <module>
    print(s[0])
TypeError: 'set' object does not support indexing

3. 字典(dict)

   
   

1)字典概念
字典(dictionary)是包含若干“鍵：值”元素的無序可變序列，字典中的每個元素包含“鍵”和“值”兩部分，定義字典時，每個元素的鍵和值用冒號分隔，元素之間用逗號分隔，所有的元素放在一對大括號“｛｝”中。字典中的鍵可以為任意不可變數(shù)據(jù)，比如整數(shù)、實數(shù)、字符串、元組等等。
2）字典的創(chuàng)建

{} #空字典
{1:1,2:2}
type({1:1,2:2})

3)字典元素的讀取
以鍵作為下標可以讀取字典元素，若鍵不存在則拋出異常

{"q":1,"w":2}["q"]->1

使用字典對象的get方法獲取指定鍵對應的值，并且可以在鍵不存在的時候返回指定值。

a={"name":"張三"}
print(a.get("name"))
a={"name":"張三"}
print(a.get("age",20))

使用字典對象的items()方法可以返回字典的鍵、值對列表

a={"name":"張三"}
print(a.items()) # dict_items([('name', '張三')])

使用字典對象的keys()方法可以返回字典的鍵列表

a={"name":"張三","age":21}
print(a.keys()) # dict_keys(['name', 'age'])

使用字典對象的values()方法可以返回字典的值列表

a={"name":"張三","age":21}
print(a.values()) # dict_values(['張三', 21])

使用字典對象的setdefault()方法返回指定“鍵”對應的“值”，如果字典中不存在該“鍵”，就添加一個新元素并設置該“鍵”對應的“值”,如果字典中存著該"鍵"，就不做任何操作，只是返回該"鍵"在字典中的值。

a={"name":"張三","age":21}
re=a.setdefault("sex","male")
print(re)  #male
print(a.values()) # dict_values(['張三', 21, 'male'])

4）字典元素的添加
當以指定鍵為下標為字典賦值時，若鍵存在，則可以修改該鍵的值；若不存在，則表示添加一個鍵、值對。

person={"name":"張三","age":21}
person['name']="lisi"
person["sex"]="male"
print(person)

5)字典刪除

• 字典clear()方法
  clear()方法是用來清除字典中的所有數(shù)據(jù)，因為是原地操作，所以返回None（也可以理解為沒有返回值）

person={"name":"張三","age":21}
person.clear()
print(person) # {}

• 字典pop()方法
  pop()刪除指定給定鍵所對應的值，返回這個值并從字典中把它移除。

x = {'a':1,'b':2}
print(x.pop('a')) # 1
print(x) #{}

• 字典popitem()方法
  字典popitem()方法作用是：隨機返回并刪除字典中的一對鍵和值（項）。為什么是隨機刪除呢？因為字典是無序的，沒有所謂的“最后一項”或是其它順序。在工作時如果遇到需要逐一刪除項的工作，用popitem()方法效率很高。

x = {'a':1,'b':2}
print(x.popitem()) # ('b':2)
print(x) #{'a':1}

6）判斷一個key是否在字典中
使用in方法

#生成一個字典
d = {'name':'tom', 'age':10, 'Tel':110}
#打印返回值，其中d.keys()是列出字典所有的key
print ('name'  in d.keys())
print ('name' in d)
#兩個的結果都是返回True

7）字典遍歷

• 遍歷key值

{'a': '1', 'b': '2', 'c': '3'}
for key in a:
       print(key+':'+a[key])
a:1
b:2
c:3

• 遍歷value值

for value in a.values():
       print(value)

• 遍歷字典項

for kv in x.items():
    print(kv)

• 遍歷字典健值

for (k,v) in x.items():
    print("k={},v={}".format(k,v))

tip:
在字典中，key不能相同,且必須是不可變的類型
思考：下面兩個字典，有什么問題？

{[1,2]:1}
{(1,2):1}

答案
方法一： print('c\nworld\ntest')
解決方法2： print(r'c\nworld\ntest') ->加入r后，變成原始字符串，\不具備轉義字符能力