python中不同类型的数据不能相互运算_python数据类型和运算
常見數據類型和運算
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数据类型和运算的全部內容,希望文章能夠幫你解決所遇到的問題。
- 上一篇: mysql strcmp s1 s2_M
- 下一篇: python遇到一个问题_新手学习pyt