首页 > 其他分享> > 基础数类型总览

基础数类型总览

2020-05-18 16:02:04 作者：互联网

- 10203 123 3340 int +- * / 等等
- '今天吃了没？' str 存储少量的数据，+ *int 切片，其他操作方法
- True False bool 判断真假
- [12, True, 'alex', [1,2,3 ]] list 存储大量的数据。
- (12, True, 'alex', [1,2,3 ]) tuple 存储大量的数据，不可改变里面的元素。
- {'name': '太白金星'} dict 存储大量的关联型的数据，查询速度非常快。
- set 交集，并集差集。。。

十进制二进制转换

'''
二进制转换成十进制
0001 1010     ------> ?  26
'''
b = 1 * 2**4 + 1 * 2**3 + 0 * 2**2 + 1 * 2**1 + 0 * 2**0
# print(b)  # 26

'''
42  -----> 0010 1010
'''

str 索引、切片、步长

s1 = 'python全栈22期'
# 对字符串进行索引，切片出来的数据都是字符串类型。
# 按照索引取值
# 从左至右有顺序，下标，索引。
s2 = s1[0]
print(s2,type(s2))
s3 = s1[2]
print(s3)
s4 = s1[-1]
print(s4)

# 按照切片取值。
# 顾头不顾腚
s5 = s1[0:6]
s5 = s1[:6]
print(s5)
s6 = s1[6:]
print(s6)

# 切片步长
s7 = s1[:5:2]
print(s7)
print(s1[:])
# 倒序：
s8 = s1[-1:-6:-1]
print(s8)

# 按索引：s1[index]
# 按照切片： s1[start_index: end_index+1]
# 按照切片步长： s1[start_index: end_index+1:2]
# 反向按照切片步长： s1[start_index: end_index后延一位:2]
# 思考题：倒序全部取出来？

str常用操作方法：

upper lower

# upper 字母转为大写 lower 字母转为小写
# s1 = s.upper()
# # s1 = s.lower()
# print(s1,type(s1))

# 应用：
#验证码，不区分大小写
#upper 字母转为大写 lower 字母转为小写
username = input ('用户名：')
password = input ('密码：')
code = 'QweA'

print (code)

your_code = input ("请输入验证码，不区分大小写：")
if your_code.upper() == code.upper():
    if username == 'wyh' and password == '123':
        print ("登录成功")
        
    else:
        print("用户名或者密码错误")
    
else:
    print ('验证码错误')

startswith endswith

name = 'aleX leNb '
if name.startswith('al') :
    print('是以al开头')
else:
    print('不是以al开头')

split 分割：str---->list

默认按照空格。
可以指定分隔符。

#split 非常重要 切割成列表
#默认按照空格分隔，返回一个列表
 s6 = '太白 女神 Alex'
l = s6.split()
 print (l)

#也可以指定分隔符 .split(':')

strip：默认去除字符串两边的空格，换行符，制表符。

去除指定字符（从前往后，从后往前同时去，遇到非停止）

# strip 去除 空白 空格 \t \n 
s4 = ' \n 太白 \t'
s5 = s4.strip ()
print (s5)

join 连接

s1 = 'alex'
s2 = '+'.join(s1)
print (s2)

l1 = ['太白', '女神', 'Alex']
s2 = ':'.join(l1)
 print (s2)

replace

msg = 'alex 很NB,alex是老男孩创始人之一，alex长得帅'
msg1 = msg.replace ('alex','太白')
print (msg1)
print (msg)

count 次数出现的次数

s8 = 'asdfafdfadadfdfasdasdaaaasa'
print (s8.count('a')) #a 出现的次数

format的三种用法

#第一种
msg = '我叫{}，今年{}，性别{}'.format('大壮',25,'男')
print (msg)

#第二种
msg = '我叫{0}，今年{1}，性别{2}我依然叫{0}'.format('大壮',25,'男')
print (msg)

#第三种
msg = '我叫{name}，今年{age}，性别{sex}我依然叫{name}！！！'.format(age = 25 ,name = '大壮', sex = '男')
print (msg)

is 系列

name = 'taibais234'
print (name.isalnum()) #是否字符串由字母或数字组成；
print (name.isalpha()) #是否字符串只由字母组成；
print (name.isdecimal())#是否字符串只由十进制组成；

in 判断是否在字符串内

msg = '老男孩python'
print ('老' in msg)
print ('老' not in msg)

for 循环有限循环

格式：
for 变量 in iterable: #iterable可迭代对象
pass

s1 = '老男孩最好讲师：太白'
# len  获取可迭代对象元素总个数
index = 0 
while index < len(s1):
    print (s1[index])
    index = index +1

使用for循环等替上面代码

s1 = '老男孩最好讲师：太白'
for i in s1:
    print (i)

列表的初识

l1 = [100, 'alex',True,[1, 2, 3]] 承载任意数据类型，存储大量的数据。

python常用的容器型数据类型。list 列表，其他语言：Java: 数组。

列表是有序的，可索引，切片（步长）。

索引，切片，步长

li = [100,'太白',50,True,[1,2,3]]
print (li[0])
print (li[1])
# 切片 （顾头不顾腚）
print (li[:2])

100
太白
[100, '太白']

列表的增、删、改、查

列表的创建

方式一：

l1 = [1,2,3,'Alex']

方式二：

l2 = list () #空
l2 = list ('asldkfjasd')#新增列表每个元素做为一项
print (l2)

方法三：列表推导式后面讲

增：

#append():追加
l1 = ['太白','女神','吴老师','xiao']
l1.append('xx') #在后面追加一项 不能打印它
print (l1)

#['太白', '女神', '吴老师', 'xiao', 'xx']

#insert() 插入
l1.insert(3,'wyh') #在索引3处，插入一项'wyh'

#extend() 迭代着追加
l1.extend('abcd')
print (l1)

#['太白', '女神', '吴老师', 'xiao', 'a', 'b', 'c', 'd']
# l1.extend(['alex', 1, 3])

删：

#pop() 按照索引位置删除
l1.pop(2) #按照索引删除 返回的是删除的元素；
l1.pop() 默认删除最后一个；

#remove() 制定元素删除，如果有重名，默认删除从左数第一个；
l1.remove('xiao')
print (l1)

#clear() 清空里面元素 了解
l1.clear()
print (l1)

改：

#按照索引改
l1[0] = '男神'

#按照切片改 了解
l1 = ['太白','女神','吴老师','xiao']
l1[2:] = 'dsgsfdag'
print(l1)
#['太白', '女神', 'd', 's', 'g', 's', 'f', 'd', 'a', 'g']

##按照切片（步长）（了解）
l1 = ['太白','女神','吴老师','xiao','ss','太白']
l1[::2] = 'abc'
print(l1)
#['a', '女神', 'b', 'xiao', 'c', '太白']

查：

#索引，切片（步长）
l1 = ['太白','女神','吴老师','xiao','ss','太白']
for i in l1:
    print(i)
'''
太白
女神
吴老师
xiao
ss
太白
'''

list 转str

list包含数字，不能直接转化成字符串。

解决办法：print(" ".join('%s' %id for id in list1))

li = []
for i in range(31):
   li.append(i)
print(li,type(li))
str1 = ''.join('%s'%(li))
print(str1,type(str1))

列表的嵌套

l1 = [1, 2, 'taibai', [1, 'alex', 3,]]
# 1, 将l1中的'taibai'变成大写并放回原处。
l1[2] = l1[2].upper()
# 2，给小列表[1,'alex',3,]追加一个元素,'男孩教育'。
l1[-1].append('男孩教育')
# 3，将列表中的'alex'通过字符串拼接的方式在列表中变成'alexsb'
l1[-1][1] = l1[-1][1] + 'sb'

元组（了解）

只读列表。存大量的数据，可索引、切片（步长）

(100,'太白'，True，[1,2,3])

应用：

重要数据，用户名，密码，个人信息，不想让别人改动的一些数据，存在元组中；

tu = (100,'太白',True,[1,2,3])
print (tu[:3])

#查看
for i in tu:
    print (i)
print (len (tu))  #列表的长度
#元组内元素不能改，只能查。元组内嵌套的小列表内元素可以改

元组的拆包：

a,b = (1,2)#多一个，少一个都不行
print (a,b)

range

类似与列表，自定制数字范围的数字列表

r = range ()
for i in r
print (i)
#1~9
#索引 [0,1,2,3,4,5,6,7,8,9] 顾头不顾腚 
for i in range(1,101):   #打印出1~100
    print (1)

range 多与for 循环结合

利用for循环，利用range 将l1的所有索引依次打印出来

l1 = [1,2,3,'alex','太白']
for i in range(len(l1)):
	print (i)

字典dict

容器型数据类型list缺点：

列表可以存储大量的数据类型，但是如果数据量大的话，他的查询速度比较慢。
列表只能按照顺序存储，数据与数据之间关联性不强。

针对于上的缺点，说咱们需要引入另一种容器型的数据类型，解决上面的问题，这就需要dict字典。

不可变（可哈希）的数据类型：int，str，bool，tuple。

可变（不可哈希）的数据类型：list，dict，set。

字典是Python语言中的映射类型，他是以{}括起来，里面的内容是以键值对的形式储存的：

Key: 不可变（可哈希）的数据类型.并且键是唯一的，不重复的。

Value:任意数据(int，str，bool，tuple，list，dict，set)，包括后面要学的实例对象等。

　在Python3.5版本（包括此版本）之前，字典是无序的。

　在Python3.6版本之后，字典会按照初建字典时的顺序排列(即第一次插入数据的顺序排序)。

　当然，字典也有缺点：他的缺点就是内存消耗巨大。

创建字典的几种方式