常見數據類型和運算

1 變量的命名規范

'''只能以字母，數字，下劃線組成，不能以數字開頭。命名時 避免與系統關鍵字重復，關鍵字：['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']長變量名建議使用下劃線組成在一起，如：name_of_owen多個單詞的簡寫建議全用大寫，ege; URL | HTTP'''

2 常見的數據數據類型

整形 int

py3中所有整形都用int來表示 py2中長整形用long類型存儲

浮點型 float

用來存儲小數的

salary=888888.0123456789

# 可以通過格式化方式來絕對輸出格式

# %.6f % salary

# 1)%f對浮點型數據進行占位

# 2).后的數據數字表示小數精度

# 3).前的數據是輸出的長度，小于等于要輸出的數據長度不起作用，超出就采用規定的最大長度

# 注：%015.6f：右對齊，左側不足拿0填充， %-15.6f: 左對齊輸出

print('%015.6f' % salary)

# 了了解

# 可以將格式化的結果進行保存，以便之后再次使用

info = '%015.6f' % salary

print(info)

%s是萬能占位符, %是用來連接有占位符的字符串與需要占位的變量，多個變量用()包裹

info = """信息:name:%sage:%s""" % (name, age)

print(info)

布爾 bool

True 真 數字1也代表

False 假 None 和 0 都為False

字符串 str

單行字符串; " " | ' '

多行字符串： """ """ | ''' '''

列表 list

# 1、定義：變量名 = [多個值，之間用,隔開]

ls = [3, 1, 2]

# 2、列表變量名ls訪問的是列表整體

print(ls) # [3, 1, 2]

# 3、通過索引(index)來訪問具體的值，index從0開始編號： ls[index]

print(ls[0]) # 3

# 4、ls的嵌套及值的訪問

ls = [[1, 2, 3], [4, 5, 6], [7, 8, [9]]]

# 訪問數字9

print(ls[2][2][0])

# 重點：list存放值的方式： eg：[3, 1, 2] => 列表的0號位存放的不是數字3，而是堆區3空間的地址 索引都是從0開始的

字典 dict

# 定義：{}是用來定義字典的語法，key是用來描述最終要訪問的value值的，key對于開發者來說是已知的

# 訪問：通過 dic[key]來訪問key描述的值

dic = {'key': 'value'}

元祖 (x,)

元祖：只讀列表，只能查詢；兒子不能改，孫子是列表則可以改

只有一個元素，不加逗號，是原數據類型；否則是元祖類型

集合 set

集合：可變的數據類型，里面的元素必須是不可變的數據類型 　 無序----每次運行結果都不一定一樣 　 不重復----列表去重：先轉換為集合，再轉換成列表即可

3 運算符

算術運算符

\# + | - | * | / | // | ** | %

\# 1.字符串和list可以做 + 和 *

\# 2./非整除，// 為整除

# 3.**求冪：5 ** 2 => 25

\# 4.任意數 % n => [0, n-1] 取模(余)的公式

\# 5.有負數參與的取余：符號跟著 % 后面那個數

比較運算符

# == 等于 != 不等于 >= <= > <

賦值運算符

# += 依次相加 *= %= //=

1 鏈式賦值

a = b = num

2 交叉賦值

x = 10

y = 20

x,y = y,x

print(x,y) # 20 10

3 解壓賦值

ls = [3, 1, 2]

a, b, c = ls

# _是合法的變量名，會接受值，但我們認為_代表該解壓位不用接收，用_來接收表示

_, _, g = ls # g才存放2，其他表示不接受

邏輯運算符

# and | or | not

# 1.and: 左右都成立才成立，有不成立的就不成立

# 2.or: 左右都不成立才不成立，有成立的就成立

# 3.ont: 成立則不成立，不成立則成立

res = 0 and 20 # and前為假，整個式子就可以確定為假了，and后就不需要執行(短路)

print(res) # 0

res = 10 or 20 # or前為真，整個式子就可以確定為真了，or后就不需要執行(短路)

print(res) # 10

res=0 and 20 ===>0 整數時，and為假時，直接為前面值 res= 20 and 0 ===>20 整數時，and為真時，后面值覆蓋前面值 所以結果為20 .

and優先級大于or

4 數據類型操作

1 字符串操作

1.字符串的索引取值: 字符串[index]

# 正向取值從0編號，反向取值從-1編號

res = '12345'

print(res[0]) # 1

res = '1,2 ,3, 4, 5'

print(res[0]) # 1

res = '1,2 ,3, 4, 5'

print(res[-1]) # 5

2.字符串拼接

ls1 = '1,2345'

ls2 = 'abcde'

res = ls1 + ls2

print(res) # 1,2345abcde

# 拼接其他類型

s1 = 10

s2 = 'abc'

s3 = True

#res = s1+s2+s3

#print(res) # 報錯 不是同類型

res = str(s1) + s2 + str(s3) # 正確 10abcTrue 這種情況只能轉化為字符串 不能‘abc’轉化為整數類型

res = '%s%s%s' % (s1, s2, s3) # %s 萬能占位符 位置一一對應

3.字符串長度

res = '10abcTrue'

print(len(res)) # 9 字符串長度為9

print(len(res[0])) # 1

4 字符串切片:

取子字符串 [::數字] [start_index:end_index:step] 表示索引從某某開始到某某結束，以多少步長計算

res = '123456abc'

print(res[0::]) # 表示從0號位開始到結束 123456abc

print(res[0:6:]) # 123456 表示從0號位開始到6號位結束 則是 123456

print(res[3:7:]) # 456a

print(res[::-1]) # cba654321 # 符號表示倒敘取值

print(res[::-2]) # ca531 # 倒敘2步取值

print(res[-1:-6:-1]) # cba65 倒敘 取五位值

5.成員運算：判斷某字符串是否在該字符串中 (in 和 not in)

res = '123456呵呵'

ls5 = '呵呵'

print(ls5 in res) # True

print(ls5 not in res) # False

6 字符串循環。涉及for循環

res = '123456呵呵'

for i in res:

print(i) # 1 2 3 4 5 6 呵 呵 打印出來每個都是一行

字符串重要方法

# 1.索引(目標字符串的索引位置)

s1 = '123abc呵呵'

print(s1.index('b')) # 4 表示b對應的位置是從0到4的位置

# 2.去留白(默認去兩端留白，兩端沒有空格時也可以去兩端指定字符) res.strip()

res = ' ***anc * 789*** '

print(res.strip()) # ***anc*789*** 把兩端的空格去掉了

res = ' ***anc * 789*** '

print(res.strip('*')) # ***anc * 789*** 當兩端有空格時，還是只能取空格

res = '***anc * 789***'

print(res.strip('*')) # anc * 789 兩端無空格的情況下 去掉兩端的*字符

# 3.計算子字符串個數 len(res)

res = '***anc * 789***'

print(len(res)) # 15

# 4.判斷字符串是否是正整數 res.isdigit

res = '12345'

print(res.isdigit()) # True

# 判斷是否是負數 首先判定首字母是-號，在判斷后面是不是正整數

res = '-12345'

if res.startswith("-") and res[1::].isdigit(): # 首先判斷是否是負數 然后在判斷-號后面的數就好 ，所以從1開始

print('負數')

# 5.大小寫轉換 res.lower() 轉化為小寫 | res.upper() 轉為大寫

res = 'aBCdEFf'

print(res.lower()) # 轉化為全小寫 abcdeff

print(res.upper()) # ABCDEFF

# 補充 res.islower() 判斷是不是小寫 | res.isupper()判斷是不是大寫

print(res.islower()) # False

print(res.isupper()) # False

# 6.以某某開頭或結尾

res = '12345wsx345'

print(res.startswith("123")) # True

res = 'wsx1234edc789'

print(res.endswith('78')) # False

# 7.替換 res.replace('y','x',數字) 表示x將替換y, 數字表示將替換幾次

res = 'egon say he is 逗比,egon egon egon!'

print(res.replace('egon', 'lxx')) # lxx 替換egon 默認替換所有 lxx say he is 逗比,lxx lxx lxx!

print(res.replace('egon', 'lxx', 3)) # lxx 替換egon三次 lxx say he is 逗比,lxx lxx egon!

# 8.格式化 只能格式化掉{}的內容

s8 = 'name：{}，age：{}'

print(s8.format('owen', 18)) # name：owen，age：18 # 默認按位置去掉空字典

print('name：{1}，age：{0}, height：{1}'.format('Owen', 18)) # name：18，age：Owen, height：18

# 指定位置 name：{1}指的是被format()里的索引1的位置值18代替 age：{0}指的是被format()后面索引的0位置的owen代替

print('name：{n}，age：{a}, height：{a}'.format(a=18, n="Zero")) # name：Zero，age：18, height：18

# 指名道姓

# 其他格式

s7 = '123wsx'

print(s7.isalnum()) # True 由字母和數字組成的

s9 = '1234'

print(s9.isalnum()) # True 由字母和數字組成的

s10 = '123qaz' # .isalpha判斷是否是字母組成

print(s10.isalpha()) # False

# 1. find | rfind：查找子字符串索引，無結果返回-1

# 2. lstrip：去左留白

# 3. rstrip：去右留白

# 4. center | ljust | rjust | zfill：按位填充

# 語法：center(所占位數, '填充符號')

# 5. expandtabs：規定\t所占空格數

# 6. captialize | title | swapcase：首字母大寫 | 單詞首字母大寫 | 大小寫反轉

# 7. isdigit | isdecimal | isnumeric：數字判斷

# 8. isalnum | isalpha：是否由字母數字組成 | 由字母組成

# 9. isidentifier：是否是合法標識符

# 10. islower | isupper：是否全小 | 大寫

# 11. isspace：是否是空白字符

# 12. istitle：是否為單詞首字母大寫格式

2 列表操作

列表：

names = ['a','b','c','d']

1、追加：names.append()

>>> names.append('e')

>>> names

['a', 'b', 'c', 'd', 'e']

2、刪除：pop，remove，del

1)pop()

如果沒有指定下標，則默認會刪除最后一個元素

>>> names.pop()

'e'

指定下標時，就會刪除下標所對應的元

>>> names.pop(2)

'c'

2)remove()

>>> names.remove('e')

>>> names

['a', 'b', 'c', 'd']

3)del

>>> del names[4]

>>> names

['a', 'b', 'c', 'd']

3、查找元素所在位置：index()

>>> names.index('c')

2

4、統計元素的次數：count()

>>> names.append('d')

>>> names.count('d')

2

5、反轉：reverse()

>>> names.reverse()

>>> names

['d', 'c', 'b', 'a']

6、清空：clear()

>>> names.clear()

>>> names

[]

7、插入：insert()

>>> names.insert(2,'devilf')

>>> names

['a', 'b', 'devilf', 'c', 'd']

還有其他的插入方法：

>>> names[3] = 'lebron'

>>> names

['a', 'b', 'devilf', 'lebron', 'd']

8、排序：sort()按照ascii碼來進行排序

>>> names.insert(4,'&&')

>>> names

['a', 'b', 'd', 'devilf', '&&', 'lebron']

>>> names.sort()

>>> names

['&&', 'a', 'b', 'd', 'devilf', 'lebron']

9、列表拼接：extend()

>>> names.extend(place)

>>> names

['&&', 'a', 'b', 'd', 'devilf', 'lebron', 'beijing', 'shandong', 'usa']

10、列表切片

1)列出所有的元素

>>> names[::]

['&&', 'a', 'b', 'd', 'devilf', 'lebron', 'beijing', 'shandong', 'usa']

2)列出最后一個元素，從中間位置開始，列出后面所有的元素

>>> names[-1]

'usa'

>>> a = int(len(names)/2)

>>> names[a:]

['devilf', 'lebron', 'beijing', 'shandong', 'usa']

11、復制：copy()

>>> names.copy()

['&&', 'a', 'b', 'd', 'devilf', 'lebron', 'beijing', 'shandong', 'usa']

另外的幾種復制的方法：

>>> info = ['name',['a',100]]

>>> n1 = copy.copy(info)

>>> n2 = info[:]

>>> n3 = list(info)

在使用copy.copy()時，需要導入copy模塊

這些均是淺copy

例如：

>>> info

['name', ['a', 100]]

>>> n1 = info[:]

>>> n2 = copy.copy(info)

>>> n1

['name', ['a', 100]]

>>> n1[0] = 'devilf'

>>> n2[0] = 'lebron'

>>> n1;n2

['devilf', ['a', 100]]

['lebron', ['a', 100]]

>>> n1[1][1] = 80

>>> n1

['devilf', ['a', 80]]

>>> n2

['lebron', ['a', 80]]

這里可以看到修改n1列表中的值，n2中的值也會跟著改變，這就是淺copy,也就是說，淺copy會復制原列表的內存地址，也就是說，我們修改了n1和n2，就是修改了指向同一內存地址的對象，所以info列表會變化，n1和n2都會變化，例如：

>>> info

['name', ['a', 80]]

5 字典操作

字典類型

容器(集合)：存放多個值的變量

單列容器(系統中的單列容器很多)：list | tuple

雙列容器(map)：只有dict，存放數據 成對出現，dict存放數據采用 key-value鍵值對方式

字典中的key可以為什么類型：key必須為不可變類型

-- key是取value的唯一依據，key一旦被確定，就需要唯一確定(不能被改變)

字典中的value可以為什么類型：value可以為任意類型

-- value是用來存放世間所有存在的數據

key要確保唯一性，不能重復，值可以重復，并且可以被改變 => 字典為可變類型

dic = {'a': 10, 1: 20, True: 30, (): 40} # 1和True都是1，key具有唯一性，所以只保留最后一次值 print(dic) # {'a': 10, 1: 30, (): 40}

字典的創建

空字典

d1 = {} d2 = dict()

用map映射創建字典

d3 = dict({'a': 1, 'b': 1}) print(d3)

用關鍵字賦值方式

d4 = dict(name='Bob', age=18) # 參數=左側的名字就是合法的變量名，都會被轉化為字符串形式的key print(d4)

創建有多個key值采用默認值的方式: 默認值不寫默認None，也可以自定義

d5 = {}.fromkeys('abc', 0) print(d5)

字典的操作

dic = {'a': 1, 'b': 2} print(dic)

增:

字典名["key"] = 值 => key已存在就是修改值，不存在就是新增值

dic['c'] = 3

print(dic)

改

dic['c'] = 30 print(dic)

查:字典名[key]

print(dic['c']) # 只能查找已有的key，沒有崩潰

有默認值的查詢：有key取出對應value，沒有返還默認值，默認值可以自定義

print(dic.get('d', 'http://www.baidu.com'))

刪

print(dic)

清空

dic.clear()

pop(k)刪除指定key的value并返還刪除的value

res = dic.pop('a')

# 從dic末尾刪除，返還(key, value)形成的元組

res = dic.popitem()

print(dic, res)

更新:

a有值覆蓋，c沒被新操作，帶下來，b為新增，增加并賦值

dic = {'a': 1, 'c': 2}

d = {'a': 10, 'b': 20}

dic.update(d)

print(dic) # {'a': 10, 'c': 2, 'b': 20}

帶默認值的新增: 新增key，key已有，啥事不干，沒有添加key，值就是第二個參數

dic.setdefault('z', 100)

print(dic)

字典的循環

1.直接循環，就是循環得到key

# for k in dic:

# print(k)

2.循環keys

# print(dic.keys())

# for k in dic.keys():

# print(k)

3.循環values

# print(dic.values())

# for v in dic.values():

# print(v)

同時循環key和value (key, value)

print(dic.items())

# a, b = (1, 2)

# print(a, b)

# for res in dic.items():

# print(res)

重點 解壓賦值

for k, v in dic.items(): print(k, v)

a, ,, b = (1, 2, 3, 4)

6 元祖操作

元組：可以理解為不可變的列表

# 1.值可以為任意類型

# 2.可以存放多個值 - 可以進行成員運算

# 3.可以存放重復的值 - 可以計算成員出現的次數

# 4.有序存儲 - 可以通過索引取值，可以切片

# 常用操作

# 1.索引取值

print(t1[1], type(t1[1]))

print(t1[-3])

# 2.運算(拼接)

print((1, 2) + (2, 3))

# 3.長度

print(len(t1))

# 4.切片

print((2, 1, 3)[::-1])

# 5.成員運算

print(True in t1)

print(False in t1) # False == 0， t1中如果有0或False，該結果都是True

# 6.for循環

for obj in t1:

print(obj, end=" ")

print()

# 方法

print(t1.count(0)) # 對象0在元組中出現的次數

print(t1.index(123, 4, len(t1))) # 對象0在區間4~末尾第一次出現的索引

7 集合操作

集合類型

# 空集合：不能用{},因為用來標示空字典

s = set()

print(s, type(s))

# 概念：

# 1.set為可變類型 - 可增可刪

# 2.set為去重存儲 - set中不能存放重復數據

# 3.set為無序存儲 - 不能索引取值

# 4.set為單列容器 - 沒有取值的key

# 總結：set不能取值

# 增

s.add('1')

s.add('2')

s.add('1')

print(s)

s.update({'2', '3'})

print(s)

# 刪

# res = s.pop()

# print(res)

# s.remove('1')

# print(s)

s.clear()

print(s)

# set運算

# 交集：兩個都有 &

py = {'a', 'b', 'c', 'egon'}

lx = {'x', 'y', 'z', 'egon'}

print(py & lx)

print(py.intersection(lx))

# 合集：兩個的合體 |

print(py | lx)

print(py.union(lx))

# 對稱交集：拋出共有的辦法的合體 ^

print(py ^ lx)

print(py.symmetric_difference(lx))

# 差集：獨有的

print(py - lx)

print(py.difference(lx))

# 比較：前提一定是包含關系

s1 = {'1', '2'}

s2 = {'2'}

print(s1 < s2)

5 深淺拷貝

值拷貝 ：ls = [1,2,3] res = ls 則print(res)就是[1，2，3]

淺拷貝 ：ls.copy()

深拷貝：ls3 = deepcopy(ls) # 新開辟列表空間，ls列表中的不可變類型的地址直接拿過來，但是可變類型的地址一定重新開辟空間 # ls內部的所有類型的值發生改變，ls3都不會隨之變化

可變對象 指 可以在原處修改，而不用創建新的對象(包括列表，字典，集合)； 不可變對象指 不支持在原處修改，只能通過表達式創建新的對象，然后把結果分配給變量(包括 數字，字符串，元組)。

6 數據類型的轉換

數字類型之間的轉化

主要關注兩個用法

join 組合 用于 列表轉為字符串

split 拆分 字符串和列表都可以使用

字典與其他之間的轉化 間接轉化

1 轉化為數字類型

res = int('10') # 字符串轉化為數字

print(res)

res = int('-3')

print(res)

res = float('.15')

print(res) # 0.15

res = float('-.15')

print(res) # -015

res = float('-3.15')

print(res) # -3.15

2:字符串與列表相互轉換 (重要)

s = 'abc123呵呵'

print(list(s)) # ['a', 'b', 'c', '1', '2', '3', '呵', '呵'] 字符串轉列表

ls = ['a', 'b', 'c', '1', '2', '3', '呵', '呵']

n_s = '.'.join(ls) # 列表轉字符串 ''.join()

print(n_s) # a.b.c.1.2.3.呵.呵

#

s = 'abc123呵呵'

print(list(s)) # ['a', 'b', 'c', '1', '2', '3', '呵', '呵']

ls = ['a', 'b', 'c', '1', '2', '3', '呵', '呵']

n_s = ''.join(ls) # 這是沒有點號的顯示

print(n_s) # abc123呵呵 這是沒有點號的顯示，點好也可以轉換為其他

#

s1 = 'a b c 1 2 3 呵 呵'

res = s1.split() # 把字符串轉化為列表 默認按空格拆

print(res) # ['a', 'b', 'c', '1', '2', '3', '呵', '呵']

s2 = 'ie=UTF-8&wd=你好帥'

res = s2.split('&') # 字符串改列表

print(res) # ['ie=UTF-8', 'wd=你好帥'] split默認按空格來隔開，s2.split('&')則是把&兩邊分開為列表,中間可以是其他的，

# 比如- 或8，只要是在s2里就行

ls2 = ['ie=UTF-8', 'wd=你好帥']

n_s2 = '@'.join(ls2)

print(n_s2) # ie=UTF-8@wd=你好帥 ''.join() 中''可以加其他的 比如@ 或4 則列表組合中間多一個其他

# 4:需求："ie=UTF-8&wd=你好帥" => [('ie', 'UTF-8'), ('wd', '你好帥')]

res = []

s4 = "ie=UTF-8&wd=你好帥"

ls4 = s4.split('&') # ['ie=UTF-8', 'wd=你好帥']

for ele in ls4: # v = ie=UTF-8 | wd=你好帥 for 循環把每個值取出來

k, v = ele.split('=') # k: ie v: UTF-8 賦值 k ,v = ele.split('=')

res.append((k, v))

print(res)

# 5.需求："ie=UTF-8&wd=你好帥" => {'ie': 'UTF-8', 'wd': '你好帥'}

res = {}

s5 = "ie=UTF-8&wd=你好帥"

ls5 = s5.split('&') # ['ie=UTF-8', 'wd=你好帥']

for ele in ls5:

k, v = ele.split('=') # 去掉 =

res[k] = v # 添加字典的模式 res[k] = v 如果字典中res，有k這個，則把值v賦值給k,如果沒有，則在字典中添加k:v

print(res) # {'ie': 'UTF-8', 'wd': '你好帥'}

# 6.需求：[('ie', 'UTF-8'), ('wd', '你好帥')] => {'ie': 'UTF-8', 'wd': '你好帥'}

res = {} # 建立新的空字典

ls6 = [('ie', 'UTF-8'), ('wd', '你好帥')]

for k, v in ls6:

res[k] = v

print(res)

3.list與tuple、set直接相互轉化 - 直接 類型()

# 8.需求：將漢字轉化為數字

# 將 壹、貳、叁、肆、伍、陸、柒、捌、玖、拾、佰、仟

# 轉化為 1、2、3、4、5、6、7、8、9、10、100、100

# 作業：壹仟捌佰玖拾叁 => 1893

num_map = {

'壹': 1,

'貳': 2,

'仟': 1000

}

ls8 = ['貳', '壹', '仟']

res = []

for v in ls8:

num = num_map[v] # 通過key去映射表拿到對應的值，完成 '貳' => 2

res.append(num)

print(res)

總結

以上是生活随笔為你收集整理的python中不同类型的数据不能相互运算_python数据类型和运算的全部內容，希望文章能夠幫你解決所遇到的問題。

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