一整形int
基本使用========
2 定义方式
age = 18
int功能可以把纯数字的字符串转成int类型
res = int("18")
res= int("1.8")
print(type(res))
了解
print(bin(11))二进制
print(oct(11))八进制
print(hex(11))十六进制
3,常用操作加内置方法
算数运算符与比较运算
二:浮点型float
该类型总结===
3,常用操作加内置方法
算数运算符与比较运算
二:浮点型float
该类型总结===
1,用途:薪资丶身高 体重
2,定义方式
salary = 3.1
float功能可以吧浮点数组成的字符串转成float类型
res = float("1.8")
print(type(res))
3,常用操作加内置方法
算数运算符与比较运算
=该类型总结====
存一个值
不可变
三 字符串类型
基本使用
2,定义方式:在引号("",'',"""""")内包含一段字符串
s = "helloo"
str功能可以把任意类型转换成str类型
res = str([1,2,3])
print(type(res))
3,常用操作加内置方法
==================>优先掌握的操作
1.按索引取值(正向取值加反向取值):只能取
s = "hello world"
print(s[0],type(s[0]))
print(s[-1])
s[1] = "E" # 不能修改
非法操作
s[2222]
s[11] = "A"
2、切片(顾头不顾尾，步长)=>属于拷贝操作
s = "hello world"
new_s=s[1:7]
print(new_s)
print(s)
new_s=s[1:7:2] #1 3 5
print(new_s)
print(s)
new_s=s[:7:2]
new_s=s[::2] # 0 2 4 6 8 10
h l o w r d
print(new_s)
new_s=s[::] # 完整拷贝字符串，只留一个冒号就可以new_s=s[:]
print(new_s)
3、长度len
s = "hello world"
print(len(s))
res=print("sfd")
print(res)
4、成员运算in和not in
s = "hello world"
# print("hel" in s)
print("egon" not in s) # 语义明确，推荐使用
# print(not "egon" in s)
5、移除空白strip
s = "
hel lo "
new_s = s.strip()
print(new_s)
print(s) # 没有改变原字符串
应用案列：
name = input("your name>>> ").strip() # name = "egon "
pwd = input("your pwd>>> ").strip()
if name == "egon" and pwd == "123":
print('login successful')
else:
print('user or password error')
去除左右两边的非空白字符
print("**+=-%^#****he**llo**%^#**+=**".strip("*+=-%^#"))
6、切分split：把字符串按照某个分隔符切成一个列表
userinfo = "egon_dsb:123:18:3.1"
res = userinfo.split(":")
# print(res[0])
print(res)
print("-".join(res))
纯字符串组成的列表
l = ["aaaa", "bbb", "ccc"]
# res=l[0]+":"+l[1]+":"+l[2]
res = ":".join(l)
print(res, type(res))
7、循环
for i in "hello":
print(i)
=======================>需要掌握的操作：
1、strip,lstrip,rstrip
print("***hello***".strip("*"))
print("***hello***".lstrip("*"))
print("***hello***".rstrip("*"))
2、lower,upper
msg = "AbCDEFGhigklmn"
res = msg.lower()
res = msg.upper()
print(res)
res=msg.swapcase()
print(res)
3、startswith,endswith
msg = "sb is lxx sb"
print(msg.startswith("sb"))
print(msg.endswith("b"))
print(msg.endswith("c"))
4、split,rsplit
userinfo="egon:123:18"
# print(userinfo.split(":"))
print(userinfo.split(":",1))
print(userinfo.rsplit(":",1))
5、format的三种玩法
5.1 %s的方式
name = "egon"
age = 18
res1="my name is %s my age is %s" % (name,age)
print(res1)
5.2 format的方式
name = "egon"
age = 18
res1="my name is {} my age is {}".format(name,age)
res1="{0}{0}{0}{1}".format(name,age)
res1="my name is {name} my age is {age}".format(age=18,name="egon")
print(res1)
5.3 f''
name = "egon"
age = 18
res1 = f"my name is {name} my age is {age}"
print(res1)
了解：f搭配{}可以执行字符串中的代码
res=f'{len("hello")}'
print(res)
f'{print("hello")}'
f包含的字符串可以放到多行
name = "egon"
age = 18
res1 = f"my name is {name} "
f"my age is {age}"
{}内不能有以及#
print(f'my name is {{egon}}')
print('胜率是 %s%%' %70)
了解：https://zhuanlan.zhihu.com/p/110406030
6、replace
msg = "***egon hello***"
res=msg.replace('*','').replace(' ','')
res=msg.strip('*').replace(' ','')
print(res)
s="lxx hahah wocale lxx sb 666"
# res=s.replace('lxx','sb')
res=s.replace('lxx','sb',1)
print(res
print(s)
7、isdigit:判断字符串是否由纯数字组成
print("adsf123".isdigit())
print("123".isdigit())
print("12.3".isdigit())
age = input('>>>: ') # age = " 18 "
if age.isdigit():
age=int(age)
if age > 18:
print('猜大了')
elif age < 18:
print('猜小了')
else:
print('猜对了')
else:
print('必须输入数字，小垃圾')
了解操作:
1.find,rfind,index,rindex,count
1.1 find：从指定范围内查找子字符串的起始索引，找得到则返回数字1，找不到则返回-1
msg='tony say hello'
msg.find('o',1,3) # 在索引为1和2(顾头不顾尾)的字符中查找字符o的索引
1
1.2 index:同find,但在找不到时会报错msg.index('e',2,4) # 报错ValueError
1.3 rfind与rindex：略
1.4 count:统计字符串在大字符串中出现的次数msg = "hello everyone"
msg.count('e') # 统计字符串e出现的次数
4msg.count('e',1,6) # 字符串e在索引1~5范围内出现的次数
1
2.center,ljust,rjust,zfill
name='tony'
name.center(30,'-') # 总宽度为30，字符串居中显示，不够用-填充
-------------tony-------------name.ljust(30,'') # 总宽度为30，字符串左对齐显示，不够用填充
tony**************************name.rjust(30,'') # 总宽度为30，字符串右对齐显示，不够用填充
**************************tonyname.zfill(50) # 总宽度为50，字符串右对齐显示，不够用0填充
0000000000000000000000000000000000000000000000tony
3.expandtabs
name = 'tony hello' # 表示制表符(tab键)
name
tony helloname.expandtabs(1) # 修改 制表符代表的空格数
tony hello
4.captalize,swapcase,title
4.1 captalize：首字母大写
message = 'hello everyone nice to meet you!'
message.capitalize()
Hello everyone nice to meet you!
4.2 swapcase：大小写翻转message1 = 'Hi girl, I want make friends with you!'
message1.swapcase()
hI GIRL, i WANT MAKE FRIENDS WITH YOU!
4.3 title：每个单词的首字母大写msg = 'dear my friend i miss you very much'
msg.title()
Dear My Friend I Miss You Very Much
5.is数字系列
在python3中
num1 = b'4' #bytes
num2 = u'4' #unicode,python3中无需加u就是unicode
num3 = '四' #中文数字
num4 = 'Ⅳ' #罗马数字
isdigt:bytes,unicode
num1.isdigit()
Truenum2.isdigit()
Truenum3.isdigit()
Falsenum4.isdigit()
False
isdecimal:uncicode(bytes类型无isdecimal方法)
num2.isdecimal()
Truenum3.isdecimal()
Falsenum4.isdecimal()
False
isnumberic:unicode,中文数字,罗马数字(bytes类型无isnumberic方法)
num2.isnumeric()
Truenum3.isnumeric()
Truenum4.isnumeric()
True
三者不能判断浮点数
num5 = '4.3'
num5.isdigit()
Falsenum5.isdecimal()
Falsenum5.isnumeric()
False
'''
总结:
最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
如果要判断中文数字或罗马数字,则需要用到isnumeric。
'''
6.is其他
name = 'tony123'
name.isalnum() #字符串中既可以包含数字也可以包含字母
True
name.isalpha() #字符串中只包含字母
False
name.isidentifier()
True
name.islower() # 字符串是否是纯小写
True
name.isupper() # 字符串是否是纯大写
False
name.isspace() # 字符串是否全是空格
False
name.istitle() # 字符串中的单词首字母是否都是大写
False
=该类型总结==
存一个值
有序
不可变
四 列表
4.1定义:在[]号内用逗号分隔开多个任意类型的值
l1 = [111,222,"aaa",[55,66]] # 本质l1 = list([111,222,"aaa",[55,66]])
4.2类型转换:但凡能够被for循环遍历的数据类型都可以传给list()转换成列表类型,
list()
if 会跟for循环一样遍历出数据类型中包含的每一个元素然后放到列表中:
list("aabbcc")
['a', 'a', 'b', 'b', 'c', 'c']
list([1, 2, 3])
[1, 2, 3]
list({"name": "liu", "age": 18})
['name', 'age']
list((1, 2, 3))
[1, 2, 3]
list({1, 2, 3, 4})
[1, 2, 3, 4]
4.3使用
4.3 优先掌握的操作
1.按索引位置存取值(正向存取,反向c存取):既可以存也可以取
正向取:(从左到右)
my_friends = ["tony","jason","tom",1,2]
my_friends[0] # tony
反向取(负号从右往左)
my_friends[-1] # 2
if对于list来说, 既可以按照索引取值, 又可以按照索引修改指定位置的值, 但是索引位置不存在则会报错:
my_friends = ["tony","jason","tom",1,2]
my_friends[1] = "liu"
my_frieds[9] # 报错
2.切片(顾头不顾尾,步长)
2.1切片顾头不顾尾:取出索引为0到3的元素
my_friends = ["tony","jason","tom",1,2]
my_friends[0:4]
['tony', 'jason', 'tom', 1]
2.2 步长：0:4:2,第三个参数2代表步长，会从0开始，每次累加一个2即可，所以会取出索引0、2的元素
2.2 步长：0:4:2,第三个参数2代表步长，会从0开始，每次累加一个2即可，所以会取出索引0、2的元素
my_friends[0:4:2]
['tony', 'tom']
3.长度
len(my_friends)
5
4.成员运算in和 not in
'tony' in my_friends
True
"tony" not in my_friends
False
"xxxx" not in my_friends
True
5.添加
5.1append()列表尾部追加元素
l1 = [11,22,33,44,55]
l1.append("a")
l1
[11, 22, 33, 44, 55, 'a']
5.2.extend()一次性在列表尾部添加多个元素
l1.extend(["aa","bb",99])
[11, 22, 33, 44, 55, 'a', 'aa', 'bb', 99]
l1.insert(22,111)
5.3.insert()在指定位置插入元素
5.3.insert()在指定位置插入元素
6.删除:
del万能删除法
L= [11,22,33,44]
del l[0]
l
[22,33,44]
pop()默认删除列表最后一个元素,并将删除的值返回,括号内可以通过加索引值来指定删除元素
l = [11,22,333,44]
res = l.pop()
res
44
res = l.pop()
res
333
remove()括号内指名道姓表示要删除那个元素,没有返回值
l = [11,22,33,44]
res = l.remove(22)
print(res)
None
7.reverse()颠倒列表内元素顺序
l = [11,22,33,44]
l.reverse()
[44, 33, 22, 11]
8.sort()给列表内所有元素排序
排序是列表元素之间必须是相同的数据类型,不可混搭,不然报错
l = [11,22,3,42,7,55]
l.sort()
l
[3, 7, 11, 22, 42, 55] # 默认从小到大排序
l = [11,22,3,42,7,55]
l.sort(reverse=True) # reverse用来指定是否跌倒排序，默认为False
l
[55, 42, 22, 11, 7, 3]
通过索引取值实现列表翻转
l[::-1]
[55, 42, 22, 11, 7, 3]
了解知识：
我们常用的数字类型直接比较大小，但其实，字符串、列表等都可以比较大小，原理相同：都是依次比较对应位置的元素的大小，如果分出大小，则无需比较下一个元素，比如
l1=[1,2,3]
l2=[2,]
l2 > l1
True
字符之间的大小取决于它们在ASCII表中的先后顺序，越往后越大
字符之间的大小取决于它们在ASCII表中的先后顺序，越往后越大
s1='abc'
s2='az'
s2 > s1 # s1与s2的第一个字符没有分出胜负，但第二个字符'z'>'b',所以s2>s1成立
True
所以我们也可以对下面这个列表排序
所以我们也可以对下面这个列表排序
l = ['A','z','adjk','hello','hea']
l.sort()
l
['A', 'adjk', 'hea', 'hello','z']
9.循环
循环遍历my_friends列表里面的值
for line in my_friends:
print(line)
'tony'
'jack'
'jason'
4
5
====该类型总结=
存多个值
有序
可变
五:元祖
5.1作用
元祖与列表类似,也是可以存多个任意类型的元素,不同之处是元祖的元素不可以改,
即元祖相当于不可变列表,用于记录多个固定不允许修改的值,单纯用于取.
元祖就是一个不可变的列表
用途:按照索引位置存放多个任意类型的值,索引反应的是位置/顺序
定义方式:在()内用逗号分隔开多个任意类型的值/元素
t = (10)
print(type(t))
强调:当元祖内只有一个元素时,必必须加括号
t = (10,)
print(type(t))
t = (11,22,"aa",10.1,[11,22])
print(t[-1][0])
t[0] = 111 # 不能改
t[-1] = 333 # 不能改
t=(11,22,[33,44])
print(id(t[0]),id(t[1]),id(t[2]))
t[2][0]=333333333
# print(t)
print(id(t[0]),id(t[1]),id(t[2]))
t=(11,22) # t=tuple(...)
print(type(t))
类型转换
tuple(所有可以被for循环遍历的类型)
t = ()
print(t)
print(type(t))
常用操作加内置方法
优先掌握的操作:
1.按照索引取值(正向取加反向取):只能取
t = (10,1.1,"aaa",[11,33])
print(t[0])
2.切片顾头不顾尾
t = (11,22,33,44,55)
print(t[0:3])
3.len长度
t = (11,22,33,44,55)
print(len(t))
4.成员运算 in 和 not in
t = (11,22,33,44,55)
print(11 in t)
5 循环
for x in t:
print(x)
====该类型总结=
存多个值
有序
不可变
六字典类型
1.用途:
按key:value的形式存放多个任意类型的value,key反应的是value的属性
2.定义方式:
在{}内用逗号分给开多个key:value,其中value可以是任意类型
而key必须是不可变类型,通常是字符串类型
d = {"k1":111,"k2":222,"k3":333} # key重复,只保留一个
print(d)
d = {1:"aaa",2.1:"bbb",[2,3]:"ccc"}
print(type(d))
print(d[()])
类型转换
类型转换
l = [("name","egon"),("age",18),["gender","male"]]
res = dict(l)
print(res)
d=dict(x=1,y=2,c=3)
print(d)
空字典
d = {}
print(type(d))
快速格式化字典
dic = {}.fromkeys(["name","age","gender"],None)
dic = {}.fromkeys("hello",None)
print(dic)
3.常用操作加内置方法
优先掌握的操作:
1.按key存取值:可存可取
d = {"k1":111}
print(d['k1'])
d['k2'] = 22
print(d)
2.长度 len()
d = {"k1":111,"k2":222}
print(len(d))
3.成员运算in和not in
d = {"k1":111,"k2":222}
print("k1"in d)
print(11 in d)
4、删除
d={'k1':111,'k2':222}
万能删除，没有返回值，代表的是单纯的删除
del d['k1']
print(d)
随机删,返回一个元组
res=d.popitem()
print(d)
print(res)
指定key删除，有返回值，代表的是取走操作
res=d.pop('k1')
print(d)
print(res)
5.键keys()，值values()，键值对items()
d={'k1':111,'k2':222}
d.keys()
['k2', 'k1']
d.values()
[222, 111]
d.items()
[('k2', 222), ('k1', 111)]
6、循环
d={'k1':111,'k2':222}
for k in d:
print(k)
for v in d.values():
print(v)
for k,v in d.items():
print(k,v)
keys=[]
for k in d:
keys.append(k)
keys=list(d.keys())
print(keys)
1.get方法
res = d.get('username')
print(res) # jason
res = d.get('xxx') # 找不到不会报错 会返回None
res = d.get('username',"没有这个key") # 键存在返回对应值
res = d.get('xxx','没有这个key') # 不存在返回get里的第二个参数
字典新增键值对
方式1
d['hobby'] = 'study' #字典的key不存在新增
print(d)
d['username'] = 'egon'
print(d) # 字典的key存在则修改
方式2
d.update(username = 'jason')
print(d) # 特点同上
方式3
"""
键如果存在的情况下 name不做修改 而是将对应的value取出
键如果不存在的情况下 那么就是新增
"""
d.setdefault('xxx',123)
print(d) # 键不存在是新增
res = d.setdefault('username',123)
print(d) # {'username':'jason','password':123}
print(res) #jason
快速构造字典
res = {}.fromkeys(["k1","k2","k3"],[])
print(res) # {'k1': [], 'k2': [], 'k3': []}
res.get("k1").append(123)
"""
A
{'k1': [123], 'k2': [], 'k3': []}
B
{'k1': [123], 'k2': [123], 'k3': [123]} # 对
C
报错
D
我TMD的也不知道
"""
弹出
res = d.pop('username')
print(d,res) # jason
res1 = d.popitem() #将弹出的键值对组织成元祖的形式返回出去
print(d,res1) # {'username':'jason',('password','123')}
字典三剑客
print(d.keys()) # 获取字典所有的key
print(d.values()) # 获取字典所有的value
print(d.items()) # 获取字典所有的key和value组织成小元组
"""
可以直接只看里面的数据结构
dict_keys(['username','password'])
dict_values(['jason',123])
dict_items([('username','jason'),('password',123)])
"""
for key in d.keys():
print(key)
for value in d.values():
print(value)
for item in d.items():
print(item)
for k,v in d.items():
print(k,v)
清空
d.clear()
print(d)
七 集合set
作用:
1,去重
集合内不可能出现相同的元素
2.关系运算
共同好友,共同关注...
用集合就是用上面两个功能 如果都用不上 那么就不要用
定义
s = {1,2,3,4,5,6,7,8}
"""
1.集合内元素必须是不可变类型
2.元素与元素之间逗号分隔开 不是键值对
3.集合内的元素也是无序的
"""
如何定义空集合
s1 = {}
s2 = {}
print(type(s1),type(s2)) # <class 'dict'> <class 'dict'>
定义一个空集合一定要用set关键字
s = set{}
print(s,type(s)) # set() <class 'set'>
类型转换:
能够被for循环的数据类型都能被转成集合
s1 = set('egon is o DSB')
print(s1)
s2 = set([1,2,3,4,5,6,6,6,6,6])
print(s2)
s3 = set({'username':'jason','password':123})
print(s3) # {'password','username'}
去重
s = {1,1,2,2,3,3,3,3,8,8,88,}
print(s) # 集合内如果有元素相同会自动去重
去重练习题
l = [4,2,2,2,33,33,4,5,6,6,77,77]
要求1 对列表进行去重不需要保持原来的元素顺序
先转成集合
s = set(1)
再转成列表
l1 = list(s)
print(l1)
要求2 对列表去重之后需要保持原来的元素顺序
new_l = []
for i in s:
if i not in new_l:
new_l.append(i)
print(new_l)
关系运算
用户1的好友列表
friends1 = {'jason','tank','egon','jerry'}
用户2的好友列表
friends2 = {'jason','tony','owen','oscar'}
1.求两个用户的共同好友 交集
res = friends1 & friends2
print(res)
2.求两个用户所有的好友
res = friends1 | friends2
print(res)
3.用户1独有的好友
res1 = friends1 - friends2
res2 = friends2 - friends1
print(res1,res2) # {'jerry', 'tank'} {'owen', 'oscar'}
4 求两个用户各自独有的好友 对称差集
res = friends1 ^ friends2
print(res) # {'owen', 'jerry', 'tank', 'oscar'}
5 子集 父集
s1 = {12,3,4,5,6}
s2 = {12,6}
print(s1 > s2) # s1是否是s2的父集
print(s2 < s1) # s2是否是s1的子集