基本数据类型及内置方法

目录

• 一整形int
• 二:浮点型float
• 三 字符串类型
  • 1.按索引取值(正向取值加反向取值):只能取
  • 2、切片(顾头不顾尾，步长)=>属于拷贝操作
  • 3、长度len
  • 4、成员运算in和not in
  • 5、移除空白strip
  • 6、切分split：把字符串按照某个分隔符切成一个列表
  • 7、循环
    • 1、strip,lstrip,rstrip
    • 2、lower,upper
    • 3、startswith,endswith
    • 4、split,rsplit
    • 5、format的三种玩法
    • 6、replace
    • 7、isdigit:判断字符串是否由纯数字组成
    • 1.find,rfind,index,rindex,count
    • 2.center,ljust,rjust,zfill
    • 3.expandtabs
    • 4.captalize,swapcase,title
    • 5.is数字系列
    • 6.is其他
• 四 列表
  • 4.1定义:在[]号内用逗号分隔开多个任意类型的值
  • 4.2类型转换:但凡能够被for循环遍历的数据类型都可以传给list()转换成列表类型,
  • 4.3 优先掌握的操作
    • 1.按索引位置存取值(正向存取,反向c存取):既可以存也可以取
    • 2.切片(顾头不顾尾,步长)
    • 3.长度
    • 4.成员运算in和 not in
    • 5.添加
    • 6.删除:
    • 7.reverse()颠倒列表内元素顺序
    • 8.sort()给列表内所有元素排序
    • 9.循环
• 五:元祖
  • 1.按照索引取值(正向取加反向取):只能取
  • 2.切片顾头不顾尾
  • 3.len长度
  • 4.成员运算 in 和 not in
• 六字典类型
  • 1.用途:
  • 2.定义方式:
  • 3.常用操作加内置方法
  • 1.按key存取值:可存可取
  • 2.长度 len()
  • 3.成员运算in和not in
  • 4、删除
  • 5.键keys()，值values()，键值对items()
  • 6、循环
  • 1.get方法
  • 字典新增键值对
• 七 集合set
  • 1,去重
  • 2.关系运算

一整形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出现的次数
4

msg.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，字符串右对齐显示，不够用填充
**************************tony

name.zfill(50) # 总宽度为50，字符串右对齐显示，不够用0填充
0000000000000000000000000000000000000000000000tony

3.expandtabs

name = 'tony hello' # 表示制表符(tab键)
name
tony hello

name.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()
True

num2.isdigit()
True

num3.isdigit()
False

num4.isdigit()
False

isdecimal:uncicode(bytes类型无isdecimal方法)

num2.isdecimal()
True

num3.isdecimal()
False

num4.isdecimal()
False

isnumberic:unicode,中文数字,罗马数字(bytes类型无isnumberic方法)

num2.isnumeric()
True

num3.isnumeric()
True

num4.isnumeric()
True

三者不能判断浮点数

num5 = '4.3'
num5.isdigit()
False

num5.isdecimal()
False

num5.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的子集