数据类型及内置方法
- 数字类型
- 字符串类型及内置方法
- 列表类型及内置方
int类型基本使用
1、用途：记录手机号，年龄，身份证号，手机号
2、定义方式：
age = 20 # age = int(20)
3、常用操作+内置的方法
int('asd') # 报错
int(11.1) #报错，int只能将字符串是数字类型转为整型，小数点都不行
进制转换
1.其他进制转十进制
二进制转十进制 0 1
10 # 0*（2**0）+1*（2**1）= 2
print(int('10',2))
八进制转十进制 1 - 7
256 # 6*（8**0）+5*（8**1）+2*（8**2）= 174
print(int('256',8))
十六进制转十进制 1-9 A-F
215 # 5*(16**0)+1*(16**1)+2*(16**2) = 533
print(int('215',16))
2.十进制转其他进制
十进制转二进制
print(bin(2)) # 0b10
十进制转八进制
print(oct(174)) # 0o256
十进制转十六进制
print(hex(533)) # 0x215
该类型总结
存一个值
无序(有序：但凡有索引的数据都是有序的)
不可变
字符串类型
1、用途：记录描述性信息
2、定义方式 ：用单引号或多因号括起来'','' '',''' '''
s = 'hello word' # s = str(hello word)
3、常用操作+内置的方法 (所有的方法均不改变字符串原值）
按索引取值（正向，反向），只能取
print(s[0]) # >>> h print(s[-1]) # >>> d
切片（可以正切，反切，指定步长）
print(s[0:5]) # >>> hello print(s[0:8]) # 默认步长为1 >>> hello wo print(s[0:8:2]) # hlow print(s[1:5:-2]) # 步长为负数，取不出 print(s[-1:-5]) # 步长为正数，取不出 print(s[-1:-5:-2]) # 反向切片 >>> do
用 len() 统计字符串长度（字符个数）
s = ' ' print(len(s)) # >>> 1
成员运算 in和not in 判断数据是否其中
s = 'hello word' print('he'in s) # True print(' 'in s) # True print('w'in s) # True print('H'in s) # False print('H'not in s) # True
用 .strip() 默认去掉字符串两边的空格，不去中间的空格
s = 'hello word' inp_s = input('your input>>>:').strip() if s == inp_s: print('good') # ps : 内置方法统一采用句点符‘.’号 s = 'hello word' s1 = ' hello word '.strip() print(s == s1) # True
若要去掉其他符号，在.strip()的括号内加入你想去掉的符号，用引号引起来
s = 'hello word' s1 = '#%^hello word#% ^&'.strip('#$%^ &') print(s == s1) # True
lstrip()去点字符串左边的符号 rstrip()去掉字符串右边的符号 l=left r=right
s = '&&&hello word####' print(s.lstrip('&')) #去掉左边 >>> hello word#### print(s.rstrip('#')) #去掉右边 >>> &&&hello word
split 字符串按某种分隔符（也可以是字符）切分成列表,进行进一步的操作
s = 'waller:123:a' print(s.split(':')) # >>> ['waller', '123', 'a'] name,psw,info = s.split(':') # 把切分出来的列的值，解压赋值给name,psw,info print(name,psw,info) # >>> waller 123 a #split 默认由左向右切分，rsplit由右向左切分，可以设定却分的次数 s = 'waller:name:age:20' print(s.split(':')) # 默认从左向右依次切分 >>> ['waller', 'name', 'age', '20'] print(s.split('e',1)) # 只切分一次 >>> ['wall', 'r:name:age:20'] print(s.rsplit('e',1)) # 从右向左切分一次 >>> ['waller:name:ag', ':20']
join 把容器类型里的数据按某种符号或字符结合成一整个字符串 注意：容器里的数据类型必须是str类型
l = ['waller','123','a'] s = '|'.join(l) print(s) # >>> waller|123|a
循环 字符串类似容器类型数据，可以用for循环取除字符
s = 'ab cd' for item in s: print(item,end='') # >>> ab cd
lower()把字符串转成全小写； upper()把字符串转成全大写
captalize,swapcase,title
s = 'Hello WoRD' print(s.lower()) # >>> hello word print(s.upper()) # >>> HELLO WORD
s = 'hElLo WorD' # captalize 首字母大写 print(s.capitalize()) # >>> Hello word # swapcase 大小写互换 print(s.swapcase()) # >>> HeLlO wORd # title 每个单词首字母大写 print(s.title()) # >>> Hello Word
starswith endswith
s = 'hello word' print(s.startswith('h')) # True 判断字符串是以什么为开头的 print(s.startswith('he')) # True print(s.endswith('d')) # True 判断字符串是以什么为结尾的
.format 的格式化输出
# 按位置占位，谁先来谁先进 print('my name is {},my age is {}'.format('waller',20))
# >>> my name is waller,my age is 20 print('my name is {},my age is {}'.format(20,'waller'))
# >>> my name is 20,my age is waller
# 按索引占位 print('my name is {0},my age is {1}'.format('waller',20))
# >>> my name is waller,my age is 20 print('my name is {1},my age is {0}'.format('waller',20))
# >>> my name is 20,my age is waller print('my name is {0},my age is {0}'.format('waller',20))
# >>> my name is waller,my age is waller
# 按指定位置占位 print('my name is {name},my age is {age}'.format(name = 'waller',age = 20))
# >>> my name is waller,my age is 20 print('my name is {age},my age is {name}'.format(name = 'waller',age = 20))
# >>> my name is 20,my age is waller
replace 字符替换
s = 'waller is stutend for oldboy , waller in python10 class ' print(s.replace('waller','wong',1)) # .replace('被替换的字符','替换字符',替换次数) 默认全部替换
# >>> wong is stutend for oldboy , waller in python10 class
isdigit 判断字符串中包含的是否是纯数字
age = 25 num = 0 while True: if num == 3: an = input('是否继续 y/n>>>:').lower().strip() if an == 'y': num = 1 continue else: break guess_age = input('>>>:').strip() if guess_age.isdigit: # isdigit有布尔值属性 guess_age = int(guess_age) if guess_age == age: print('猜对了') break else: print('猜错') num += 1 else: print('请输入数字')
find,rfind 查找字符的索引值,找不到不报错，返回-1.
index,rindex 查找字符的索引值,找不到则报错。
count 统计字符串出现的次数。
s = 'hello word' print(s.find('w')) # >>> 6 print(s.find('w',0,3)) # >>> -1 按索引范围查找 print(s.index('w')) # >>> 6 print(s.index('w',0,3)) # >>> 报错 print(s.count('o')) # >>> 2
center,ljust,rjust,zfill
s = 'hello word' print(s.center(30,'*') ) # 居中 字符串加* 共30个字符，字符串居中显示 # >>> **********hello word********** print(s.ljust(30,'%')) # 居左 # >>> hello word%%%%%%%%%%%%%%%%%%%% print(s.rjust(30,'$')) # 居右 # >>> $$$$$$$$$$$$$$$$$$$$hello word print(s.zfill(30)) # 居右 用 0 补位 # >>> 00000000000000000000hello word
expandtabs
s = 'w\tps' print(s.expandtabs(10)) # 在字符串\t处插入空格 # >>> w ps
is数字系列
s1 = b'2' # bytes 二进制 s2 = u'2' # unicode,python3中无需加u就是unicode s3 = '壹' # 中文大写数字 s4 = 'Ⅳ' # 罗马数字 #isnumeric(): unicode,中文数字，罗马数字 只要是表示数字都识别 print(s2.isnumeric()) # True print(s3.isnumeric()) # True print(s4.isnumeric()) # True #isdecimal(): unicode 只识别普通的阿拉伯数字 print(s2.isdecimal()) # True print(s3.isdecimal()) # False print(s4.isdecimal()) # False # isdigit() :bytes,unicode 通常情况下使用isdigit就已经满足需求了 print(s1.isdigit()) # True print(s2.isdigit()) # True print(s3.isdigit()) # False
该类型总结
存多个值
有序(有序：但凡有索引的数据都是有序的)
不可变
列表类型
1、用途：记录多个值，可以是不同类型的值
2、定义方式 ：[ ] 内用逗号分隔开
l_list = ['waller',123,'age',20,'info','wong'] l = list({'name':'waller','age':20,'info':'wong'}) # 列表内部就是for循环取值，然后一个个塞进列表 print(l) # >>> ['name', 'age', 'info']
按索引取值(正取，反取），可存可取id不变
l_list = ['waller',123,'age',20,'info','wong'] print(l_list[0]) # 'waller' print(l_list[-1]) # 'wong'
按索引切片 (步长)
print(l_list[0:3]) # ['waller', 123, 'age'] print(l_list[0:3:2]) # ['waller', 'age'] print(l_list[0:3:-1]) # [] print(l_list[-1:-3:-1]) # ['wong', 'info']
列表添加元素：
append，insert，extend
1.append 在列表内直接添加元素（追加）
l_list = ['waller',123,'age',20,'info','wong'] l_list.append('hoddy') print(l_list) # >>> ['waller', 123, 'age', 20, 'info', 'wong', 'hoddy']
2.insert 通过索引位置添加元素
l_list = ['waller',123,'age',20,'info','wong'] l_list.insert(1,'hobby') # .insert(索引,添加的元素) print(l_list) # >>> ['waller', 'hobby', 123, 'age', 20, 'info', 'wong']
3.extend 添加容器类型数据 内部原理是for循环取值容器内的元素添加到另一个列表
l_list = ['waller',123,'age',20,'info','wong'] l = [1,2,'a'] l_list.extend(l) # 把 l 添加到l_list print(l_list) # >>> ['waller', 123, 'age', 20, 'info', 'wong', 1, 2, 'a']
删除列表中的元素
del，pop， remove
del 按索引暴力删除元素，没有返回值 （可以删除任意类型数据的值）
l_list = ['waller',123,'age',20,'info','wong'] del l_list[0] print(l_list) # [123, 'age', 20, 'info', 'wong']
pop 按索引删除元素，有返回值
l_list = ['waller',123,'age',20,'info','wong'] msg = l_list.pop(1) print(l_list) # >>> ['waller', 'age', 20, 'info', 'wong'] print(msg) # >>> 123
remove 指定要删除的元素
l_list = ['waller',123,'age',20,'info','wong'] l_list.remove('wong') print(l_list) # >>> ['waller', 123, 'age', 20, 'info']
for 循环取值
l_list = ['waller',123,'age',20,'info','wong'] for i in l_list: print(i,end='/') # >>> waller/123/age/20/info/wong/
len() 统计列表长度（元素个数）
l_list = ['waller',123,'age',20,'info','wong'] print(len(l_list)) # >>> 6
成员运算in和not in
l_list = ['waller',123,'age',20,'info','wong'] print('age'in l_list) # True
count 查找数据出现的次数
#l_list = ['waller',123,'age',20,'info','wong'] l_list = ['waller',123,'age',20,'info','wong',20] print(l_list.count(20)) # >>> 2
clear 清空列表 返回值是None 列表id不变
l_list = ['waller', 123, 'age', 20, 'info', 'wong', 20] mgs = l_list.clear() print(l_list) # >>> [] print(mgs) # >>> None
reverse 反转列表 返回值是None
l_int = [1,2,3,4,5] l_int.reverse() print(l_int) # >>> [5, 4, 3, 2, 1]
sort 排序列表 （升序） 只能对存的是纯数字（int，float）类型的列表进行sort,否则报错
l_int = [1,10,3,12,5,4.1,] l_int.sort() print(l_int) # >>> [1, 3, 4.1, 5, 10, 12] l_int.sort(reverse = True) # 可以通过操作sort里的reverse参数使列表降序 print(l_int) # >>> [12, 10, 5, 4.1, 3, 1]
该类型总结
存多个值
有序(有序：但凡有索引的数据都是有序的)
可变
tuple 元组类型
作用： 存多个元素，元素之间用逗号分隔开，元素可以是任意类型，元素不能被修改
定义：（）内，逗号分隔开
t_tuple = ('waller',123,'age',20,['read','study']) t_tuple = tuple(('waller',123,'age',20,['read','study'])) # for循环取值存到元组t_tuple中 tuple() # 括号内只能放容器类型的数据，如放单个数字类型数据，需要加个逗号 tuple((1，))
# 索引取值（正取，反取）只能取
# 切片
# 长度 len()
# 成员运算 in， not in
# 循环
索引取值
t_tuple = ('waller',123,'age',20,['read','study']) print(t_tuple[0]) # >>> waller print(t_tuple[-1]) # >>> ['read', 'study']
切片
t_tuple = ('waller',123,'age',20,['read','study']) print(t_tuple[0:3:2]) # >>> ('waller', 'age') print(t_tuple[0:-1]) # >>> ('waller', 123, 'age', 20)
长度 len 统计的是元组内元素的个数
t_tuple = ('waller',123,'age',20,['read','study']) print(len(t_tuple)) # >>> 5
成员运算
t_tuple = ('waller',123,'age',20,['read','study']) print('waller'in t_tuple) # True
循环
t_tuple = ('waller',123,'age',20,['read','study']) for i in t_tuple: if i == 123: continue print(i,end=' ') # >>> waller age 20 ['read', 'study']
该类型总结
存多个值
有序(有序：但凡有索引的数据都是有序的)
不可变
dict 字典类型
作用：能存多个值，key:value 键值对，key只能是不可变类型，通常是字符串类型
定义：{}内用逗号分隔开的key：value键值对
三种定义方法 d1 = {'name':'waller','age':20,'hobby':['read','studt',123]} d2 = dict(name = 'waller',age = 20,hobby = ['read','study',123]) l = [ ['name','waller'], ['age',20], ['hobby',['read','study',123]] ] d3 = {} for i in l: # 循环取出列表的值。 k,v = i # 把循环出来的列表解压赋值给k和v d3[k] = v # 通过字典用key增加元素的方法 print(d3) # {'name': 'waller', 'age': 20, 'hobby': ['read', 'study', 123]}
通过key存取值
#存值：当key不存在时，添加key：value，若key存在，则key的新value代替原value d = {'name':'waller','age':20,'hobby':['read','studt',123]} d['name'] = 'wong' print(d) # {'name': 'wong', 'age': 20, 'hobby': ['read', 'studt', 123]} d['school'] = 'oldboy' print(d) # {'name': 'waller', 'age': 20, 'hobby': ['read', 'studt', 123], 'school': 'oldboy'}
#取值：当key存在，返回value，若key不存在则报错 d = {'name':'waller','age':20,'hobby':['read','studt',123]} print(d['name']) # >>> waller print(d['school']) # 报错
长度len（）：键值对的个数
d = {'name':'waller','age':20,'hobby':['read','studt',123]}
print(len(d)) # >>> 3
成员运算 in not in 只能判断key时否在字典中
d = {'name':'waller','age':20,'hobby':['read','studt',123]}
print('age'in d) # True
删除 del pop 通过key删除键值对
#del 通过key删除，没有返回值 d = {'name':'waller','age':20,'hobby':['read','studt',123]} del d['name'] print(d) # {'age': 20, 'hobby': ['read', 'studt', 123]} #pop 通过key删除，返回值是 value d = {'name':'waller','age':20,'hobby':['read','studt',123]} res = d.pop('name') print(d) # {'age': 20, 'hobby': ['read', 'studt', 123]}
查询 所有键keys()，所有值values()，所有键值对items()
ps python2和python3有区别，py2中打印的是列表，占内存空间，py3返回的不占内存空间
d = {'name': 'waller', 'age': 20, 'hobby': ['read', 'studt', 123]}
print(d.keys()) # >>> dict_keys(['name', 'age', 'hobby'])
print(d.values()) # >>> dict_values(['waller', 20, ['read', 'studt', 123]])
print(d.items()) # 把它看作是元组，第一个值是key，第二个值是value
# >>> dict_items([('name', 'waller'), ('age', 20), ('hobby', ['read', 'studt', 123])])
get() 根据key取value
d = {'name': 'waller', 'age': 20, 'hobby': ['read', 'studt', 123]}
print(d.get('name')) # >>> waller
print(d.get('school')) # >>> None
print(d.get('name','我是返回的值')) # >>> waller
print(d.get('school','我是返回的值')) # >>> 我是返回的值
总结：
get方法取值时：
当key存在，则返回value，当key不存在时，不报错，返回None
get的第二个参数，当key存在时，第二个蚕食不打印，返回value,当key不存在时，打印第二个参数
#dict.fromkeys 快速创建字典
d = {'name':'waller','psw':123}
print(dict.fromkeys(d,11))
# >>> {'name': 11, 'psw': 11}
popitem 弹出键值对 从字典后面以元组的形式弹出键值对
d = {'name':'waller','psw':123}
print(d.popitem()) # >>> ('psw', 123)
dict.setdefault();dict.update() 新增键值对
dict.setdefault() d = {'name':'waller','psw':123} print(d.setdefault('name','wong')) # 当key存在时，不修改原值，返回原value # >>> waller print(d) # >>> {'name': 'waller', 'psw': 123} print(d.setdefault('sge',20)) # 当key不存在时，添加键值对，返回的时添加的value # >>> 20 print(d) # {'name': 'waller', 'psw': 123, 'sge': 20}
dict.update() d1 = {'name':'waller','psw':123} d2 = {'age':20} d1.update(d2) print(d1) # {'name': 'waller', 'psw': 123, 'age': 20} d3 = {'name':'wong'} # 若键值对奴存在，则添加；若键值对存在，则顶替 d1.update(d3) print(d1) # {'name': 'wong', 'psw': 123, 'age': 20} d1.update(age = 20) # {'name': 'wong', 'psw': 123, 'age': 20}
循环 取的是key
d1 = {'name':'waller','psw':123}
for i in d1:
print(i)
该类型总结
存多个值
无序(有序：但凡有索引的数据都是有序的)
可变
set 集合
作用：去重，关系运算
定义：{}内用逗号隔开多个元素，元素必须是不可变类型
特点：自动去重，无序，每个元素是不可变类型
s = {1,'1','a','b','c',2,2,2,2,2,}
print(s) # >>> {1, 2, 'b', 'a', 'c', '1'}
#关系运算： s1 = {'a','b',1,5,'d','w'} s2 = {1,2,5,'a','c','e','w'} #s1与s2中共同的元素 交集 ： #方法一： l = [] for i in s1: for j in s2: if i == j: l.append(i) print(l) #方法二： for itme in s1: # for循环取出s1里的元素 if itme in s2: # 判断取出的元素如果也在s2中，则打印出来 print(itme) #方法三： print(s1 & s2) # 利用集合的方法，取出交集，取出的也是一个集合 {1, 'a', 5, 'w
| 合集 s1与s2中的所有的元素
print(s1 | s2) # {1, 2, 5, 'w', 'c', 'd', 'b', 'e', 'a'}
- 差集
print(s1 - s2) # {'d', 'b'} print(s2 - s1) # {2, 'e', 'c'}
^ 对称差集 s1和s2 不同元素的集合
print(s1 ^ s2) # {2, 'e', 'b', 'c', 'd'}
父级，子集
s1 = {1,2,3,4,5}
s2 = {1,2,3}
# >= 父级：
print(s1 >= s2) # True
# <= 子集
print(s2 <= s1) #True
长度 len（）
s1 = {'a','b',1,5,'d','w'}
print(len(s1)) # >>> 6
成员运算 in ，not in
s1 = {'a','b',1,5,'d','w'}
print('a' in s1) # True
该类型总结
存多个值
无序(有序：但凡有索引的数据都是有序的)
不可变
