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

基础数类型总览

作者:互联网

    • 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, '太白']

相关练习题:

li = [1, 3, 2, "a", 4, "b", 5,"c"]
#通过对li列表的切片形成新的列表l1,l1 = [1,3,2]
l1 = li[:3]
print (l1)

#通过对li列表的切片形成新的列表l2,l2 = ["a",4,"b"]
l2 = li[3:6]
print (l2)

#通过对li列表的切片形成新的列表l4,l4 = [3,"a","b"]
l4 = li[1:6:2]
print (l4)

#通过对li列表的切片形成新的列表l6,l6 = ["b","a",3]
l6 = li[-3:0:-2]
print (l6)

列表的增、删、改、查

列表的创建

方式一:

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缺点:

  1. 列表可以存储大量的数据类型,但是如果数据量大的话,他的查询速度比较慢。

  2. 列表只能按照顺序存储,数据与数据之间关联性不强。

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

不可变(可哈希)的数据类型:int,str,bool,tuple。

可变(不可哈希)的数据类型:list,dict,set。

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

Key: 不可变(可哈希)的数据类型.并且键是唯一的,不重复的。

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

 在Python3.5版本(包括此版本)之前,字典是无序的。

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

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

创建字典的几种方式

方式一:

dic = dict ((('one',1),('two',2),('three',3)))
print (dic)
#{'one': 1, 'two': 2, 'three': 3}

方式二:

dic =dict (one = 1,two = 2, three = 3)
print(dic)
#{'one': 1, 'two': 2, 'three': 3}

方式三:官方推荐

dic = dict ({'one':1,'two':2,'three':3})
print(dic)
#{'one': 1, 'two': 2, 'three': 3}

其它方式:

# 方式5: 后面会讲到先了解
dic = dict(zip(['one', 'two', 'three'],[1, 2, 3]))
print(dic)

# 方式6: 字典推导式 后面会讲到
# dic = { k: v for k,v in [('one', 1),('two', 2),('three', 3)]}
# print(dic)

# 方式7:利用fromkey后面会讲到。
# dic = dict.fromkeys('abcd','太白')
# print(dic)  # {'a': '太白', 'b': '太白', 'c': '太白', 'd': '太白'}

验证字典的合法性

#合法
dic = {123:456,True:999,"id":1,"name":'sylar',"age":18,"stu":['帅哥','美女'],(1,2,3):'麻花'}
print(dic[123])
print(dic['stu'])
print (dic[(1,2,3)])

# 不合法
# dic = {[1, 2, 3]: '周杰伦'} # list是可变的. 不能作为key
# dic = {{1: 2}: "哈哈哈"} # dict是可变的. 不能作为key
dic = {{1, 2, 3}: '呵呵呵'} # set是可变的, 不能作为key

字典的常用操作方法

#通过键值对直接增加
dic = {'name': '太白', 'age': 18}
#dic['weight'] = 75 #没有weight这个键,就直接增加键值对
dic['name'] = 'barry' #有name这个键,就成了字典的改。--有则改之,无则增加;
print(dic)

#setdefault
dic = {'name': '太白','age':18}
#dic.setdefault('weight',75)   #没有weight此键,则增加
dic.setdefault('name','scott') #有name此键,则不变;
print(dic)

#pop 通过key删除字典的键值对,有返回值(返回键对应的值),可设置返回值;
dic = {'name':'太白','age':18}
ret = dic.pop('name')
print(dic,ret)
#{'age': 18} 太白

#popitem 3.5版本之前,popitem为随机删除,3.6之后为删除最后一个,有返回值
dic = {'name':'太白','age':18}
ret = dic.popitem()
print(dic,ret)
#{'name': '太白'} ('age', 18)

#clear 清空字典
dic = {'name':'太白','age':18}
dic.clear()
print(dic) 
#{}

# del
# 通过键删除键值对
dic = {'name': '太白', 'age': 18}
del dic['name']
print(dic) # {'age': 18}

#删除整个字典
del dic

#通过键值对直接改
dic = {'name':'太白','age':18}
dic['name'] = 'alex'
print(dic)

#update
dic = {'name':'太白','age':18}
dic.update(sex = '男',weight = 74)
print(dic)
#{'name': '太白', 'age': 18, 'sex': '男', 'weight': 74}

dic = {'name':'太白','age':18}
dic.update([(1,'a'),(2,'b'),(3,'c')]) #列表-元组
print(dic)
#{'name': '太白', 'age': 18, 1: 'a', 2: 'b', 3: 'c'}

dic1 = {'name':'太白','age':18}
dic2 = {'name':'alex','weight': 74}
dic1.update(dic2)   # 有键对应的改之,没有的增加
print(dic1)
print(dic2)
#{'name': 'alex', 'age': 18, 'weight': 74}
#{'name': 'alex', 'weight': 74}



#通过键查询
#直接dic[key] 没有此键会报错;
dic = {'name': '太白', 'age': 18}
print(dic['name'])
#太白

#get  通过键查询,有则返回值,没有返回None  不会报错。*****
dic = {'name': '太白', 'age': 18}
v = dic.get('name')
print(v) #太白

dic = {'name': '太白', 'age': 18}
v = dic.get('name1')
print(v) #None

dic = {'name': '太白', 'age': 18}
v = dic.get('name1','没有此键')
print(v)
#没有此键

#keys()
dic = {'name': '太白', 'age': 18}
print(dic.keys())
#dict_keys(['name', 'age'])

#values()
dic = {'name': '太白', 'age': 18}
print(dic.values())
#dict_values(['太白', 18])

#items()
dic = {'name': '太白', 'age': 18}
print(dic.items())
#dict_items([('name', '太白'), ('age', 18)])

练习

#ex
# dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
# 请在字典中添加一个键值对,"k4": "v4",输出添加后的字典
# dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
# dic['k4'] = 'v4'
# print(dic)

# 请在修改字典中 "k1" 对应的值为 "alex",输出修改后的字典
# dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
# dic.update(k1 = 'scott')
# print(dic)

# 请在k3对应的值中追加一个元素 44,输出修改后的字典
# dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
# dic['k3'].append(44)
# print(dic)

# 请在k3对应的值的第 1 个位置插入个元素 18,输出修改后的字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
dic['k3'].insert(0,'18')
print(dic)

字典的嵌套

a,b = {'汪峰':'北京','章':'天后'} #解包
print(a,b)
#汪峰 章

dic = {
    'name': '汪峰',
    'age': 48,
    'wife': [{'name': '章子怡', 'age': 38}],
    'children': {'girl1': '小苹果', 'girl2': '小亦', 'girl3': '顶顶'}
}
1. 获取汪峰的名字。
print(dic['name'])

2.获取这个字典:{'name':'国际章','age':38}。
de = dic['wife'][0]
print(de)

3. 获取汪峰妻子的名字。
de = dic['wife'][0]['name']
print(de)

4. 获取汪峰的第三个孩子名字。
de = dic['children']['girl3']
# print(de)

练习

dic1 = {
 'name':['alex',2,3,5],
 'job':'teacher',
 'oldboy':{'alex':['python1','python2',100]}
 }
1,将name对应的列表追加⼀个元素’wusir’。
dic1['name'].append('wusir')
print(dic1)

2,将name对应的列表中的alex⾸字⺟⼤写。
dic1['name'][0] = dic1['name'][0].upper()
print(dic1)

3,oldboy对应的字典加⼀个键值对’⽼男孩’,’linux’。
dic1['oldboy'].setdefault('老男孩' , 'Linux')
print(dic1)

4,将oldboy对应的字典中的alex对应的列表中的python2删除
dic1['oldboy']['alex'].pop(1)
print(dic1)

id is ==

# id 身份证号
# i = 100
# s = 'alex'
# print(id(i))
# print(id(s))
# == 比较的是两边的值是否相等
# l1 = [1, 2, 3]
# l2 = [1, 2, 3]
# print(l1 == l2)
# s1 = 'alex'
# s2 = 'alex '
# print(s1 == s2)

# is 判断的是内存地址是否相同
# l1 = [1, 2, 3]
# l2 = [1, 2, 3]
# print(id(l1))
# print(id(l2))
# print(l1 is l2)

s1 = 'alex'
s2 = 'alex'
print(id(s1))
print(id(s2))
print(s1 is s2)

# id 相同,值一定相同
# 值相同,id不一定相同

代码块

    • 代码块:我们所有的代码都需要依赖代码块执行。
    • 一个文件就是一个代码块。
    • 交互式命令下一行就是一个代码块。
  1. 两个机制: 同一个代码块下,有一个机制。不同的代码块下,遵循另一个机制。

  2. 同一个代码块下的缓存机制。

    • 前提条件:同一个代码块内。
    • 机制内容:pass
    • 适用的对象: int bool str
    • 具体细则:所有的数字,bool,几乎所有的字符串。
    • 优点:提升性能,节省内存。
  3. 不同代码块下的缓存机制: 小数据池。

    • 前提条件:不同代码块内。
    • 机制内容:pass
    • 适用的对象: int bool str
    • 具体细则:-5~256数字,bool,满足规则的字符串。
    • 优点:提升性能,节省内存。
# i1 = 1000
# i2 = 1000
# i3 = 1000
# l1 = [1,2,3]
# l2 = [1,2,3]
# print(id(l1))
# print(id(l2))
# print(id(i1))
# print(id(i2))
# print(id(i3))

i = 800
i1 = 800
s1 = 'hfdjka6757fdslslgaj@!#fkdjlsafjdskl;fjds中国'
s2 = 'hfdjka6757fdslslgaj@!#fkdjlsafjdskl;fjds中国'
print(i is i1)
print(s1 is s2)

集合 set

器型的数据类型,它要求它里面的元素是不可变的数据,但是它本身是可变的数据类型。集合是无序的。{}。

# 集合的创建:
# set1 = set({1, 3, 'Barry', False})
# set1 = {1, 3, '太白金星', 4, 'alex', False, '武大'}
# print(set1)

# 空集合:
# print({}, type({}))  # 空字典
# set1 = set()
# print(set1)

# 集合的有效性测试
# set1 = {[1,2,3], 3, {'name': 'alex'}}
# print(set1)

# set1 = {'太白金星', '景女神',  '武大', '三粗', 'alexsb', '吴老师'}
# 增:
# add
# set1.add('xx')
# print(set1)

# update迭代着增加
# set1.update('fdsafgsd')
# print(set1)

# 删
# remove
# remove 按照元素删除
# set1.remove('alexsb')
#
# print(set1)
# pop 随即删除
# set1.pop()
# print(set1)

# 变相改值
# set1.remove('太白金星')
# set1.add('男神')
# print(set1)

#关系测试:***
#  交集
# set1 = {1, 2, 3, 4, 5}
# set2 = {4, 5, 6, 7, 8}
# print(set1 & set2)

# 并集:
# print(set1 | set2)

# 差集 -
# print(set1 - set2)

# 反交集
# print(set1 ^ set2)

# 子集
# set1 = {1,2,3}
# set2 = {1,2,3,4,5,6}
# # print(set1 < set2)
#
# # 超集
# print(set2 > set1)


# 列表的去重 ***
# l1 = [1,'太白', 1, 2, 2, '太白',2, 6, 6, 6, 3, '太白', 4, 5, ]
# set1 = set(l1)
# l1 = list(set1)
# print(l1)

# 用处:数据之间的关系,列表去重。

标签:太白,name,s1,基础,dic,print,l1,类型,总览
来源: https://www.cnblogs.com/wyh0717/p/12911112.html